【python 编程】文本分类KNN算法实现及结果输出

文本分类流程：

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