精华内容
参与话题
问答
  • 欠抽样算法使用遗传算法与knn实现分类
  • 文本分类KNN算法

    万次阅读 2007-08-06 15:47:00
    文本分类KNN算法,该方法的思路非常简单直观:如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类别。该方法在定类决策上只依据最邻近的一个或者几个...
    文本分类中KNN算法,该方法的思路非常简单直观:如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类别。该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。
    

        KNN方法虽然从原理上也依赖于极限定理,但在类别决策时,只与极少量的相邻样本有关。因此,采用这种方法可以较好地避免样本的不平衡问题。另外,由于KNN方法主要靠周围有限的邻近的样本,而不是靠判别类域的方法来确定所属类别的,因此对于类域的交叉或重叠较多的待分样本集来说, KNN方法较其他方法更为适合。

        该方法的不足之处是计算量较大,因为对每一个待分类的文本都要计算它到全体已知样本的距离,才能求得它的K个最近邻点。目前常用的解决方法是事先对已知样本点进行剪辑,事先去除对分类作用不大的样本。另外还有一种Reverse KNN法,能降低KNN算法的计算复杂度,提高分类的效率。

        该算法比较适用于样本容量比较大的类域的自动分类,而那些样本容量较小的类域采用这种算法比较容易产生误分。

    k近邻分类器具有良好的文本分类效果,对仿真实验结果的统计分析表明:作为文本分类器,k近邻仅次于支持向量机,明显优于线性最小二乘拟合、朴素贝叶斯和神经网络。

    重点:

    1:特征降维(一般用CHI方法)

    2:截尾算法(三种截尾算法)

    3:降低计算量

     
    展开全文
  • 机器学习分类篇-最邻近规则分类KNN

    千次阅读 2016-10-12 17:03:17
    最邻近规则分类算法(K-Nearest Neighbor),Cover和Hart在1968年提出了最初的邻近算法,也被称为基于实例的学习或懒惰学习

    最邻近规则分类算法(K-Nearest Neighbor),Cover和Hart在1968年提出了最初的邻近算法,也被称为基于实例的学习或懒惰学习,与决策树算法相比,处理训练集的时候并不建立任何模型,进行分类时才将测试样例和所有已知实例进行比较进而分类。

    这里写图片描述

    如上图,主要有两种色块,蓝色方块和红色三角,对绿色未知圆点进行判断分类,其属于红色还是蓝色?
    KNN算法一般可以分为两步,为了判断未知实例的类别,会以所有已知实例作为参照,计算未知实例与所有已知实例的距离。所以第一步先分别计算出圆点和所有色块的距离。

    第二步,选择一个参数K,判断离未知实例最近的K个实例是什么类型,以少数服从多数的原则进行归类。
    上图中,假如我们选择K的值是1,则离未知实例最近的一个色块是蓝色,未知实例被归类为蓝色。假如我们选择K的值为4,则很明显,离未知实例最近的4个色块3个是红色,1个是蓝色,未知实例被归类为红色。

    所以K的选择对结果的影响很大,一般为了得出结果K选择奇数,通过增大K也可以增强对噪音数据的健壮性。

    对于距离的衡量方式有很多种,最常用的是Euclidean distance:
    这里写图片描述
    二维的下距离计算公式如上图简单的数学公式,扩展到n维下x,y两点的距离公式:
    这里写图片描述

    KNN算法优点是简单易于理解和实现,缺点是需要大量的空间存储所有实例,因为未知实例要和所有实例进行计算算法复杂度高,而且当一类样本过大,则不管未知实例属于哪一类都很容易归为数量过大的这一类。
    如图:
    这里写图片描述
    Y点肉眼去看因为在红色区域内很容易判断出多半属于红色一类,但因为蓝色过多,若K值选取稍大则很容易将其归为蓝色一类。为了改进这一点,可以为每个点的距离增加一个权重,这样里的近的点可以得到更大的权重,比如距离d,权重1/d。

    再计算一个例子:
    这里写图片描述

    根据电影的打斗次数和接吻次数,将电影分类为Romance和Action,已经有6个已知样例,怎么样根据未知样例的打斗次数和接吻次数判断其电影类型?

    将打斗次数和接吻次数作为二维坐标,判断每个已知样例电影与未知电影的距离,可以得出最近的3个电影都是Romance电影,则未知电影判断为Romance电影,这就是KNN算法。

    下一篇是Python对KNN算法的实践。

    展开全文
  • KNN算法实现文本分类 ascii 系统 5 账号 2 密码 2 分辨率 2 用户名 1 用户 1 软件 1 苹果 1 密码技术 1 宽度 1 火狐 1 0、rd-doc—count矩阵 分辨率 2 2 2 [1, 1] 用户名 1 1 2 [1, 1] 鼠标 0 1 ...

    文本分类流程:

    1、特征选取:

    网页爬取-》网页预处理获取汉字-》中文分词及词性标注-》保留名词-》词频统计-》输出词-文档矩阵-》计算词的信息增益值-》选取增益大的前N个词作为特征词-》计算每个词在文档中的权重-》生成文档-词矩阵-》对词的权重进行归一化处理-》即每个训练文档特征词及权重选取完毕。

    2、匹配流程

    获取新的网页重复上面步骤到分词,得到分词后统计此文档所对应的特征词的词频-》采用KNN等机器学习算法对要分类的文档与现有训练样本中的每个样本进行夹角余弦计算-》夹角余弦最大值为其所最接近的分类,分类成功。



    KNN算法实现文本分类,程序及输出结果如下:

    1、程序

    # -*- coding: cp936 -*-
    import urllib2
    import re
    import sys
    import os
    import math


    #os.system(cmd)os.system('ls')


    #class MyClass:
    #    key_word
        
    doc_no = 1
    def start_fun():
            reload(sys)
            sys.setdefaultencoding('utf-8')
            print sys.getdefaultencoding()


    def testfun():
            str_test = "http://hao123.com\" class is >china</b>"
            searchstr= re.findall(r'http://(.*?)\"',str_test)
            print searchstr[0]
    def split_word(webpage_chinese_file,webpage_chinese_word_file):
            #调用命令行对中文文档进行分词处理
            os.system('cd splitword && ictclas_demo_c.exe ../'+ webpage_chinese_file + ' ../'+webpage_chinese_word_file )
    def doc_word_count_deal(webpage_chinese_word_file,webpage_all_word_count_docno):
            global doc_no
            word_dicts = dict()


            #1、读取中文分词内容到缓存中
            word_file = open(webpage_chinese_word_file,"r")
            word_buf = word_file.read()
            word_file.close()


            #2、将分词以空格分隔并按/过滤提取分词中文内容和词性,不是名词或者长度小于2的不进行记录
            word_sets =  word_buf.split(' ')
            for i in word_sets:
                    #print i
                    if i == "" :
                            continue
                    j = i.index('/')
                    #print 'j='+str(j)
                    k = i[j+1:j+2]
                    i = i[0:j]
                    
                    
                    #print i
                    #word_dicts[i]如果不存在KEY则会报KeyError错误
                    if len(i) <= 2 or (k != None and k != 'n'):
                            #print 'k='+k
                            continue
                    if word_dicts.get(i) == None :
                            word_dicts[i] = 1
                    else:
                            word_dicts[i] = word_dicts[i] + 1
            #sorted(word_dicts.viewvalues())
            #list ->word_dicts = [ v for v in sorted(word_dicts.values())]


            #3、将过滤后的中文分词按照出现次数进行排序,将排序好的数据存储到相应的文件中                       
            word_count = open(webpage_all_word_count_docno,'w')
            word_dicts_list = sorted([(v, k) for k, v in word_dicts.items()], reverse=True)
            for i in word_dicts_list:
                    print i[1],i[0]
                    word_count.write(str(doc_no)+" "+i[1]+" "+str(i[0])+"\n")
            word_count.close()
            doc_no = doc_no + 1
                            
            """
            for i in word_dicts.viewkeys():
                    print i,word_dicts[i]
            """        
    def get_webpage_china(url_addr,webpage_src_file,webpage_chinese_file):
            #reload( sys )
            #sys.setdefaultencoding('utf-8')
            print sys.getdefaultencoding()
            #1、获取URL地址网页内容,默认为ascii,GB2312编码
            url = url_addr
            content = urllib2.urlopen(url).read()


            #2、打开文件将网页内容写入文件        
            file = open(webpage_src_file,'w')
            file.write(content)
            file.close


            #str=f.read()
            #fp.write(str.encode("utf-8"))
            
            #3、正则匹配获取网页中alert中所对应的内容
            """
            pattern1 = re.findall(r'alert\(\"(.*)\"\)',content)
            for i in pattern1:
                    print i
                    print 'hello world!\n'


            sub1 = re.sub(r'alert\(\"(.*)\"\)','Hello World!',content)
            """


            #chinaeseStr = re.match(ur".*[\u4e00-\u9fa5]+",content)
            #a="<p class=\"w490\"> 百度知道</p> "
            #(?<=>)[^a-zA-Z0-9_]+(?=<) 正则 ?<=只匹配最前面不进入分组,?=匹配最后不进入分组
            #4、获取网页中文内容
            chinaeseStr= re.findall(ur"[\u4e00-\u9fa5]+",content.decode('GB2312'))
            #5、将中文内容写入文件
            file_chinese = open(webpage_chinese_file,'w')
            for i in chinaeseStr:
                    #print i
                    file_chinese.write(i.encode('GB2312'))
            file_chinese.close()                
    def KNN(c1,c2):
        list1 = []
        list2 = []
        list3 = []
        dict1 = dict()
        ig_dict = dict()
        features_dict = dict()
        weigh_dict = dict()
        weigh_doc_matrix_dict = dict()


        class_count = 2
        doc_count = 3
        
        c1_file = open(c1,"r")
        #c1_word_sets = c1_file.read()
        for line in c1_file:
            list1.append(line.split(" "))        
        
        c2_file = open(c2,"r")
        for line in c2_file:
            list1.append(line.split(" "))


        #1、计算word-doc—count矩阵
        """
        分辨率 [2, 2, 0] 2 2
        用户名 [1, 1, 0] 1 1
        鼠标 [0, 1] 0 1
        密码技术 [1, 1, 0] 1 1
        """
        for i in list1:
            #print i[0],i[1],i[2]
            if dict1.get(i[1]) == None:
                list2 = list()
                list2 = [0]
                if i[2] == None:
                    list2.insert((int)(i[0]) - 1,0)
                else:                
                    list2.insert((int)(i[0]) - 1,(int)(i[2]))
                dict1[i[1]] = list2
            else:
                if i[2] == None:
                    dict1[i[1]].insert((int)(i[0]) - 1,0)
                else:                
                    dict1[i[1]].insert((int)(i[0]) - 1,(int)(i[2]))


        
        #2、计算每个Word的信息增益IG并保存到dit中
        print "0、rd-doc—count矩阵"                
        for dict_cont in dict1.viewkeys():
            print dict_cont,dict1[dict_cont][0],dict1[dict_cont][1]


            t= class_count
            entropy = class_count * 1/class_count * (math.log(1,10) - math.log(t,10));
            wcount = 0 # // 出现word的文档的文档数量


            category_doc_count = doc_count/class_count #每个类别中的文档数量
            wcount_class = [0 for i in range(class_count)] #// 每个类别中出现单词word的文档数


            pw = 0.0# // 出现word的文档占全部文档的比重
            pcw = [0 for i in range(class_count)]# // 在单词word出现时各个类别中文档数占总文档数的比重
            pcw_b = [0 for i in range(class_count)]#// 在单词word不出现时各个类别中文档数占总文档数的比重
            #listabc = [0 for i in range(100)] or [0] * 100


            for i in range(0,class_count):
                for j in range(0,category_doc_count):
                    if dict1[dict_cont][j + i * category_doc_count] > 0 :                    
                        wcount_class[i] += 1
                wcount += wcount_class[i]
                
            print wcount, wcount_class


            pw = 1.0 * wcount / doc_count;
            for i in range(0,class_count):
                    pcw[i] = 1.0 * wcount_class[i] / wcount;
                    pcw_b[i] = 1.0 * (category_doc_count - wcount_class[i])/ (doc_count - wcount);


            d1 = 0.0;
            d2 = 0.0;


            for i in range(0,class_count):
                    #print pcw[i],pcw_b[i]
                    if pcw[i] == 0:
                            t1 = 0
                    else:
                            t1 = math.log(pcw[i],10)                        
                    d1 += pcw[i] * t1;
                    if pcw_b[i] == 0:
                            t2 = 0
                    else:
                            t2 = math.log(pcw_b[i],10)
                    d2 += pcw_b[i] * t2;


            ig = entropy + pw * d1 + (1.0 - pw) * d2;
            ig_dict[dict_cont] = ig
                
            
        #3、打印信息增益信息
        print "1、word IG"
        for dict_cont in ig_dict.viewkeys():
            print dict_cont,ig_dict[dict_cont]


        print "1、sort word IG"
        word_dicts_list = sorted([(v, k) for k, v in ig_dict.items()], reverse=True)
        j = 1
        for i in word_dicts_list:
            print i[1],i[0]
            if j == 6 :
                continue
            features_dict[i[1]] = i[0]
            j += 1
        print "2、feature values"
        for i in features_dict.viewkeys():
            print i,features_dict[i]
            
            


        
        #4、计算权重及归一化
        for dict_cont in dict1.viewkeys():
            #print dict_cont,dict1[dict_cont][0],dict1[dict_cont][1]
            if features_dict.get(dict_cont) == None:
                continue
            tf = 0 #特征项在本文档中出现的频率
            Ni = 0 #出现特征项的文档数目
            N = doc_count #
            
            for i in range(doc_count - 1):
                if dict1[dict_cont][i] > 0 :                    
                        Ni += 1


            for i in range(doc_count - 1):
                tf = dict1[dict_cont][i]
                weight = -1.0 * tf * (math.log(1.0,10) + math.log(Ni,10) - math.log(N,10))
                #print "********"+str(i)+"*****"+str(tf)+"***"+str(weight)
                if weigh_dict.get(dict_cont) == None:
                    weight_list = [0.0]*doc_count
                    weigh_dict[dict_cont] = weight_list
                    weigh_dict[dict_cont][i] = weight
                else:
                    weigh_dict[dict_cont][i] = weight
        print "3、weight values"
        
        for j in range(doc_count-1):
            for i in weigh_dict.viewkeys():
                print i,weigh_dict[i][0],weigh_dict[i][1]
                if weigh_doc_matrix_dict.get(j) == None:
                    weith_doc_list = dict()
                    weigh_doc_matrix_dict[j] = weith_doc_list
                    weigh_doc_matrix_dict[j][i] = weigh_dict[i][j]
                else:
                    weigh_doc_matrix_dict[j][i] = weigh_dict[i][j]


        print "4、归一化doc-word martix"
        weight_sum = [0.0]*doc_count
        for i in weigh_doc_matrix_dict.viewkeys():
            for j in weigh_doc_matrix_dict[i].viewkeys():
                weight_sum[i] += weigh_doc_matrix_dict[i][j]


        test_doc_matrix_dict = dict()
        ttstr = ""
        ttstr1 = ""
        for i in weigh_doc_matrix_dict.viewkeys():
            ttstr = ""
            ttstr1 = ""
            print "doc num " + str(i)
            for j in weigh_doc_matrix_dict[i].viewkeys():
                weigh_doc_matrix_dict[i][j] /= weight_sum[i]
                ttstr += " " + str(weigh_doc_matrix_dict[i][j])
                ttstr1 += " " + j
                test_doc_matrix_dict[j] = 1
            print ttstr1
            print ttstr


        #5、获取新样本的特征词出现次数统计与现有2个文档进行KNN算法计算,计算夹角余弦大的说明越接近
        res = 0.0
        mul = 0.0
        p1 = 0.0
        p2 = 0.0
        max_res = 0.0


        
        print "5、KNN分类算法对如下样本进行分类"
        for i in weigh_doc_matrix_dict.viewkeys():
            for j in weigh_doc_matrix_dict[i].viewkeys():
                one = weigh_doc_matrix_dict[i][j]
                two = test_doc_matrix_dict[j]
                print j,two
                mul += one * two
                p1 += math.pow(one,2)
                p2 += math.pow(two,2)
            res = math.fabs(mul) / math.sqrt(p1 * p2)
            if res > max_res:
                max_res = res
                class_no = i
            
            print "样本" + str(i) + "计算结果=" + str(res)


        print "最终分类编号为:" + str(class_no)


        


    """
    69     // 计算两个向量的夹角的余弦。如果此值的绝对值越大,说明夹角越小,越相似,距离越近。
     70     public double cos(Vector<Double> v1, Vector<Double> v2, int len) {
     71         double res = 0.0;
     72         double mul = 0.0;
     73         double p1 = 0.0, p2 = 0.0;
     74         for (int i = 0; i < len; i++) {
     75             double one = v1.get(i);
     76             double two = v2.get(i);
     77             mul += one * two;
     78             p1 += Math.pow(one, 2);
     79             p2 += Math.pow(two, 2);
     80         }
     81         res = Math.abs(mul) / Math.sqrt(p1 * p2);
     82         return res;
     
    """
    def main():
            url_addr = 'http://192.168.1.170:8000/jsoa/CheckUser.jspx'
            webpage_src_file = 'webpage_src_file.txt'
            webpage_chinese_file = 'webpage_chinese_file.txt'
            webpage_chinese_word_file = 'webpage_chinese_word_file.txt'
            webpage_all_word_count_docno = 'webpage_all_word_count_docno.txt'
            webpage_all_word_count_docno1 = 'webpage_all_word_count_docno1.txt'
            webpage_all_word_count_docno2 = 'webpage_all_word_count_docno2.txt'


            get_webpage_china(url_addr,webpage_src_file,webpage_chinese_file)
            split_word(webpage_chinese_file,webpage_chinese_word_file)
            doc_word_count_deal(webpage_chinese_word_file,webpage_all_word_count_docno)
            KNN(webpage_all_word_count_docno1,webpage_all_word_count_docno2)


    main()






            
            

    2、输出结果

    ascii
    系统 5
    账号 2
    密码 2
    分辨率 2
    用户名 1
    用户 1
    软件 1
    苹果 1
    密码技术 1
    宽度 1
    火狐 1
    0、rd-doc—count矩阵
    分辨率 2 2
    2 [1, 1]
    用户名 1 1
    2 [1, 1]
    鼠标 0 1
    1 [0, 1]
    密码技术 1 1
    2 [1, 1]
    密码 2 2
    2 [1, 1]
    账号 2 2
    2 [1, 1]
    电脑 0 1
    1 [0, 1]
    火狐 1 1
    2 [1, 1]
    系统 5 3
    2 [1, 1]
    苹果 1 1
    2 [1, 1]
    软件 1 1
    2 [1, 1]
    用户 1 1
    2 [1, 1]
    宽度 1 1
    2 [1, 1]
    键盘 0 1
    1 [0, 1]
    1、word IG
    分辨率 -0.50171665944
    用户 -0.50171665944
    鼠标 -0.401373327552
    密码技术 -0.50171665944
    系统 -0.50171665944
    账号 -0.50171665944
    电脑 -0.401373327552
    软件 -0.50171665944
    密码 -0.50171665944
    苹果 -0.50171665944
    火狐 -0.50171665944
    用户名 -0.50171665944
    宽度 -0.50171665944
    键盘 -0.401373327552
    1、sort word IG
    鼠标 -0.401373327552
    键盘 -0.401373327552
    电脑 -0.401373327552
    账号 -0.50171665944
    用户名 -0.50171665944
    用户 -0.50171665944
    系统 -0.50171665944
    软件 -0.50171665944
    苹果 -0.50171665944
    密码技术 -0.50171665944
    密码 -0.50171665944
    宽度 -0.50171665944
    火狐 -0.50171665944
    分辨率 -0.50171665944
    2、feature values
    电脑 -0.401373327552
    账号 -0.50171665944
    鼠标 -0.401373327552
    用户名 -0.50171665944
    键盘 -0.401373327552
    3、weight values
    鼠标 0.0 0.47712125472
    电脑 0.0 0.47712125472
    账号 0.352182518111 0.352182518111
    用户名 0.176091259056 0.176091259056
    键盘 0.0 0.47712125472
    鼠标 0.0 0.47712125472
    电脑 0.0 0.47712125472
    账号 0.352182518111 0.352182518111
    用户名 0.176091259056 0.176091259056
    键盘 0.0 0.47712125472
    4、归一化doc-word martix
    doc num 0
     电脑 账号 鼠标 用户名 键盘
     0.0 0.666666666667 0.0 0.333333333333 0.0
    doc num 1
     电脑 账号 鼠标 用户名 键盘
     0.24347423677 0.179718193127 0.24347423677 0.0898590965636 0.24347423677
    5、KNN分类算法对如下样本进行分类
    电脑 1
    账号 1
    鼠标 1
    用户名 1
    键盘 1
    样本0计算结果=0.6
    电脑 1
    账号 1
    鼠标 1
    用户名 1
    键盘 1
    样本1计算结果=0.718992940348
    最终分类编号为:1

    展开全文
  • 我的微信公众号名称:深度学习与先进智能决策微信公众号ID:...KNN算法是学者Cover和Hart早在1968年提出的算法,最初的最邻近规则分类算法最早也是被用来处理分类的问题,是基于实例的学习(instance-based l...

    我的微信公众号名称:深度学习与先进智能决策
    微信公众号ID:MultiAgent1024
    公众号介绍:主要研究强化学习、计算机视觉、深度学习、机器学习等相关内容,分享学习过程中的学习笔记和心得!期待您的关注,欢迎一起学习交流进步!

    KNN算法是学者Cover和Hart早在1968年提出的算法,最初的最邻近规则分类算法最早也是被用来处理分类的问题,是基于实例的学习(instance-based learning),也叫做懒惰学习(lazy learning),之所以这么说呢,是因为最开始我们并不设计算法的模型,而是基于实例来给他归类。

    假设我们有一个电影集,我们有一个任务,来给电影分类。电影有很多类型,如浪漫的,动作片。对于每个电影我们可以把它想象成实例,我们的任务是给他归类,在实例中我们可以提取不同的特征值,在下面的这张图片中我们提取了两个特征值:打斗次数,接吻次数。最终实现对未知电影根据特征值分类。

    首先我们如何将电影这个例子表达得更像一个数学模型,我们可以表达地如下图所示:

    也就是我们可以把每部电影表达为每个实例点,每个点相当于空间中的多维向量,我们的目的是为了将其归类。

    KNN算法祥述

    为了判断未知实例的类别,以所有已知类别的实例作为参考,选择参数K,计算未知实例与所有已知实例的距离,选择最近K个已知实例,根据少数服从多数的投票法则(majority-voting),让未知实例归类为K个最邻近样本中最多的类别。举个例子来说呢就是:

    假设我们有一个豆子A,我们不知道他是哪一类的,我们根据已知的这三类豆子给他进行分类。我们选择最近的K个豆子,假设K=3,那么我们就看这最近的三个豆子属于哪一类,并根据少数服从多数的投票法则来判断这个豆子A的类别。

    细节

    K如何选取?我们可以依据训练时候的准确度来选取。

    关于距离的衡量方法:

    Euclidean Distance(欧几里得距离

    其他距离衡量:余弦值(cos),相关度(correlation),曼哈顿距离(Manhanttan distance)

    以上面所讲的电影的数据集为例,介绍一下具体的算法工作流程:

    1. 算G点到A、B、C、D、E、F,点的距离,程序计算欧几里得距离如下(以A和G点之间的距离为例):

    import math
    def ComputeEuclideanDistance(x1, y1, x2, y2):
        d = math.sqrt(math.pow((x1 - x2), 2) + math.pow((y1- y2), 2))
        return d
    d_ag = ComputeEuclideanDistance(18, 90, 3, 104)
    print(d_ag)
    

    2. 之后的话我们选取三个距离最小的三个临近豆子,看这三个临近豆子属于哪一类,用少数服从多数的原则判别出这个豆子的种类。

    KNN的算法对K的选择非常敏感,如下图所示:

    算法优点:简单;易于理解;容易实现;通过对K的选择可具备丢噪音数据的健壮性。

    算法缺点:需要大量空间存储所有已知实例;算法复杂度高(需要比较所有已知实例与要分类的实例);当其样本分布不平衡时,比如其中一类样本过大(实例数量过多)占主导的时候,新的未知实例容易被归为这个主导样本,因为这类样本实例的数量过大,但这个新的未知实例并不接近目标样本。

    对于样本点x_{i},其silhouette值s{(x_{i})}定义为:

    s(x_{i})= \frac{b(x_{i})-a(x_{i})}{max[b(x_{i}),a(x_{i})]}

    a(x_{i})为样本点x_{i}与当前所属类别的差异度(dissimilarity),用与所有样本点的平均距离度量。b(x_{i})为样本点x_{i}与其他类别差异度最小值。由此可知,s{(x_{i})}接近1表示样本点x_{i}更倾向于当前类,s{(x_{i})}接近0表示样本点x_{i}更在两类之间,s{(x_{i})}接近-1表示样本点x_{i}更倾向于其他类。


    Python实现:

    from sklearn import neighbors
    from sklearn import datasets
    # 调用KNN的分类器
    knn = neighbors.KNeighborsClassifier()
    # 加载数据库
    iris = datasets.load_iris()
    # 打印数据集 包含一个四维的特征值和其对应的标签
    print(iris)
    
    knn.fit(iris.data, iris.target)
    # 预测[0.1, 0.2, 0.3, 0.4]属于哪一类
    predictedLabel = knn.predict([[0.1, 0.2, 0.3, 0.4]])
    # 打印出预测的标签
    print(predictedLabel)

     

     

     

    展开全文
  • github地址: https://github.com/YLD10/Machine-Learning/tree/master/cifar 下面是训练量为10000的时候的效果图
  • KNN

    千次阅读 2018-02-06 20:54:19
    KNN---最近邻,k-NearestNeighbor使用场景:可回归,可分类,对于类域的交叉或重叠较多的待分样本集来说,KNN方法较其他方法更为适合。更有用的方法是将不同距离的邻居对该样本产生的影响给予不同的权值(weight),如...
  • knn

    千次阅读 2016-06-15 15:26:17
    KNN算法 看到的一个很简单的例子,用knn算法来实现分类,引用sklearn 很简单就实现 ...knn = neighbors.KNeighborsClassifier() #取得knn分类器 data = np.array([[3,104],[2,100],[1,81],[101,10],
  • KNN算法

    千次阅读 2016-04-04 22:36:47
    KNN算法
  • kNN算法

    2018-08-21 14:53:56
    kNN算法将样本分到离它最相似的样本所属的类。算法本质上使用了模板匹配的思想。要确定一个样本的类别,可以计算它与所有训练样本的距离,然后找出和该样本最接近的k个样本,统计这些样本的类别进行投票,票数最多的...
  • 机器学习实战笔记——KNN算法

    千次阅读 2018-06-21 00:46:16
    KNN算法是监督学习分类方法。何为监督学习?我们用来训练的数据集应当包括数据特征和标签两个部分,通过训练建立数据特征和标签之间关系的算法模型,这样的话,将测试数据集套用算法模型,可以得到测试数据的标签。...
  • 学习KNN(一) 图像分类KNN原理

    万次阅读 2017-09-11 22:47:54
    学习KNN(一) 图像分类KNN原理 学习KNN(二)KNN算法手写数字识别的OpenCV实现 学习KNN(三)KNN+HOG实现手写数字识别 简介 KNN算法,即K近邻算法是一种监督学习算法,本质上是要在给定的训练样本中找到与...
  • 【模式识别】K-近邻分类算法KNN

    万次阅读 多人点赞 2014-04-15 20:19:35
    K-近邻(K-Nearest Neighbors, KNN)是一种很好理解的分类算法,简单说来就是从训练样本中找出K个与其最相近的样本,然后看这K个样本中哪个类别的样本多,则待判定的值(或说抽样)就属于这个类别。 KNN算法的步骤 ...
  • KNN分类

    2018-07-23 15:39:33
    KNN是机器学习的最经典分类算法之一,其核心原理为: 通过度量函数,比如常用的欧氏距离找出训练样本中与待测点距离最近的K个点; 通过K个点的Label标签进行民主投票,从而对待测点样本进行分类。 通过对上述两个...
  • 机器学习之KNN最邻近分类算法

    万次阅读 多人点赞 2018-09-15 13:13:33
    KNN(K-Nearest Neighbor)最邻近分类算法是数据挖掘分类(classification)技术中最简单的算法之一,其指导思想是”近朱者赤,近墨者黑“,即由你的邻居来推断出你的类别。 KNN最邻近分类算法的实现原理:为了...
  • KNN 分类算法

    2019-05-01 15:48:29
    KNN分类算法,当K=1时,计算最相似的一个点。 输入需为csv文件
  • JAVA实现KNN分类

    千次阅读 2016-04-05 15:02:02
    KNN算法又叫近邻算法,是数据挖掘中一种常用的分类算法,接单的介绍KNN算法的核心思想就是:寻找与目标最近的K个个体,这些样本属于类别最多的那个类别就是目标的类别
  • KNN分类

    热门讨论 2013-02-14 20:57:49
    KNN分类
  • 遥感图像分类

    万次阅读 2019-01-28 21:36:02
    遥感图像分类 一、背景简介 遥感图像分类就是利用计算机通过对遥感图像中各类地物的光谱信息和空间信息进行分析,选择特征,将图像中各个像元按照某种规则或算法划分不同的类别,然后获得遥感图像中与实际地物的...
  • 分类算法之KNN分类

    2018-05-23 15:56:00
    1、介绍  KNN是k nearest neighbor 的简称,即k最邻近,就是找k个最近的实例投票决定新实例的类标。...KNN也成为懒惰学习,它不需要训练过程,在类标边界比较整齐的情况下分类的准确率很高。KNN...
  • 数据挖掘之KNN分类

    千次阅读 2013-11-16 21:18:34
    分类算法有很多,贝叶斯、决策树、支持向量积、KNN等,神经网络也可以用于分类。这篇文章主要介绍一下KNN分类算法。 1、介绍  KNN是k nearest neighbor 的简称,即k最邻近,就是找k个最近的实例投票决定新实例的...
  • KNN和线性分类

    千次阅读 2017-02-28 21:44:10
    英文笔记:http://cs231n.github.io/K最近邻和线性分类器K最近邻从图像分类入手:将图像表示成一个向量,进行分类(文中以猫为例) 图像一般比较复杂,会产生旋转、缩放、平移、聚集点不同等,如何让图片样式不同,...
  • 用matlab写的代码,采用KNN实现多分类,代入数据就可以成功运行!
  • 文本分类KNN

    千次阅读 2013-01-15 18:27:52
    预处理: 解析文档,中科院分词ICTCLAS、过滤:去标点,去停用词HIT等   特征提取: 卡方、信息增益、交叉熵等,这里我们选用卡方(Chi-square test) ... For this method is easy to implement and also very ...
  • KNN分类算法

    千次阅读 2017-04-08 18:08:31
    KNN分类算法原理 KNN概述 KNN算法图示 KNN算法要点 KNN算法不足之处 KNN分类算法Python实战 KNN简单数据分类实践 KNN实现手写数字识别 KNN算法...

空空如也

1 2 3 4 5 ... 20
收藏数 523,323
精华内容 209,329
关键字:

分类