算法原理与编程实践 第二章 中文文本分类

1.文本挖掘是从非结构化文本信息中获取用户感兴趣或者有用的模式过程.定义如下:

  文本挖掘是指从大量文本数据中抽取事先未知的、可理解的、最终可用的知识的过程，同时运用这些知识更好地组织信息以便将来参考.

2.文本挖掘的7个主要领域:

     (1)搜索和信息检索(IR)

     (2)文本聚类

     (3)文本分类

     (4)Web挖掘:在互联网上进行数据和文本挖掘，并且特别关注网络的规模和相互联系。

     (5)信息抽取(IE)

     (6)自然语言处理(NLP)

     (7)概念提取

3.下面主要讲:文本分类

   目前主要有两种文本分类的方法:(1)基于模式系统(运用知识工程技术)

                                                       (2)分类模型(通过使用统计和、或机器学习的技术)

4.讲述机器学习的分类过程

   4.1 文本预处理 (通常转化为文本文件)

   4.2 Scikit-Learn库简介:

          (1)模块分类:广义线性模型，岭回归，支持向量机(SVN)，梯度下降，KNN，高斯过程，朴素贝叶斯，决策树，多细粒度算法，特征选择，概率校准；

          (2)聚类算法: K-Means,谱聚类，仿射传播，均值漂移，分层聚类，DBSCAN

          (3)维度约简:PCA,字典学习，因子分析，ICA

          (4)模型选择:交叉验证，评价预估性能，网络搜素，模型的持久化，验证曲线

          (5)数据预处理: 标准化，正规化，二值化，编码分类特征，缺失值的插补。

   4.3 使用朴素贝叶斯分类模块

    (1)算法定义  

 

 # -*- coding: utf-8 -*-


import sys  
import os 
import numpy as np


def loadDataSet():
    postingList=[['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
                 ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
                 ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him','my'],
                 ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
                 ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                 ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
    classVec = [0,1,0,1,0,1]    #1 is abusive, 0 not
    return postingList,classVec


# 读取文件
def readfile(path):
fp = open(path,"rb")
content = fp.read()
fp.close()
return content

''' 
#计算分类精度：
def metrics_result(actual,predict):
print '精度:{0:.3f}'.format(metrics.precision_score(actual,predict))  
print '召回:{0:0.3f}'.format(metrics.recall_score(actual,predict))  
print 'f1-score:{0:.3f}'.format(metrics.f1_score(actual,predict))  
'''


#读取bunch对象
def readbunchobj(path):
file_obj = open(path, "rb")
bunch = pickle.load(file_obj) 
file_obj.close()
return bunch

#写入bunch对象 
def writebunchobj(path,bunchobj):
file_obj = open(path, "wb")
pickle.dump(bunchobj,file_obj) 
file_obj.close()




class NBayes(object):
def __init__(self):
self.vocabulary = [] # 词典
self.idf=0           # 词典的idf权值向量
self.tf=0            # 训练集的权值矩阵
self.tdm=0           # P(x|yi)
self.Pcates = {}     # P(yi)--是个类别字典
self.labels=[]       # 对应每个文本的分类，是个外部导入的列表
self.doclength = 0   # 训练集文本数
self.vocablen = 0    # 词典词长
self.testset = 0     # 测试集
# 加载训练集并生成词典，以及tf, idf值
def train_set(self,trainset,classVec):
self.cate_prob(classVec)   # 计算每个分类在数据集中的概率：P(yi) 
self.doclength = len(trainset)
tempset = set()
[tempset.add(word) for doc in trainset for word in doc ] # 生成词典
self.vocabulary = list(tempset) 
self.vocablen = len(self.vocabulary)
self.calc_wordfreq(trainset)
# self.calc_tfidf(trainset)  # 生成tf-idf权值
self.build_tdm()           # 按分类累计向量空间的每维值：P(x|yi)
# 生成 tf-idf 
def calc_tfidf(self,trainset):
self.idf = np.zeros([1,self.vocablen])
self.tf = np.zeros([self.doclength,self.vocablen])
for indx in xrange(self.doclength):
for word in trainset[indx]:
self.tf[indx,self.vocabulary.index(word)] +=1
# 消除不同句长导致的偏差
self.tf[indx] = self.tf[indx]/float(len(trainset[indx]))
for signleword in set(trainset[indx]):
self.idf[0,self.vocabulary.index(signleword)] +=1
self.idf = np.log(float(self.doclength)/self.idf)
self.tf = np.multiply(self.tf,self.idf) # 矩阵与向量的点乘

# 生成普通的词频向量 
def calc_wordfreq(self,trainset):
self.idf = np.zeros([1,self.vocablen]) # 1*词典数
self.tf = np.zeros([self.doclength,self.vocablen]) # 训练集文件数*词典数
for indx in xrange(self.doclength):    # 遍历所有的文本
for word in trainset[indx]:          # 遍历文本中的每个词
self.tf[indx,self.vocabulary.index(word)] +=1  # 找到文本的词在字典中的位置+1
for signleword in set(trainset[indx]):              
self.idf[0,self.vocabulary.index(signleword)] +=1 

# 计算每个分类在数据集中的概率：P(yi)
def cate_prob(self,classVec):
self.labels = classVec
labeltemps = set(self.labels) # 获取全部分类
for labeltemp in labeltemps:  
# 统计列表中重复的值：self.labels.count(labeltemp)
self.Pcates[labeltemp] = float(self.labels.count(labeltemp))/float(len(self.labels))

#按分类累计向量空间的每维值：P(x|yi)
def build_tdm(self):
self.tdm = np.zeros([len(self.Pcates),self.vocablen]) #类别行*词典列
sumlist = np.zeros([len(self.Pcates),1])  # 统计每个分类的总值
for indx in xrange(self.doclength):
self.tdm[self.labels[indx]] += self.tf[indx]  # 将同一类别的词向量空间值加总
sumlist[self.labels[indx]]= np.sum(self.tdm[self.labels[indx]])  # 统计每个分类的总值--是个标量
self.tdm = self.tdm/sumlist # P(x|yi)

# 测试集映射到当前词典
def map2vocab(self,testdata):
self.testset = np.zeros([1,self.vocablen])
for word in testdata:
self.testset[0,self.vocabulary.index(word)] +=1

# 输出分类类别 
def predict(self,testset):
if np.shape(testset)[1] != self.vocablen:
print "输入错误"
exit(0)
predvalue = 0
predclass = ""
for tdm_vect,keyclass in zip(self.tdm,self.Pcates):
# P(x|yi)P(yi)
temp = np.sum(testset*tdm_vect*self.Pcates[keyclass])
if temp > predvalue:
predvalue = temp
predclass = keyclass
return predclass
(2)运用算法进行预测
 # -*- coding: utf-8 -*-


import sys  
import os 
import time
from numpy import *
import numpy as np
from Nbayes_lib import *



# 配置utf-8输出环境
reload(sys)
sys.setdefaultencoding('utf-8')


dataSet,listClasses = loadDataSet()
nb = NBayes()
nb.train_set(dataSet,listClasses)
nb.map2vocab(dataSet[3])
print nb.predict(nb.testset)
  4.4分类算法:KNN
# -*- coding: utf-8 -*-


import sys  
import os 
import time
from numpy import *
import numpy as np
import matplotlib.pyplot as plt
import operator


# 配置utf-8输出环境
reload(sys)
sys.setdefaultencoding('utf-8')
# 
def createDataSet():
    group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])
    labels = ['A','A','B','B']
    return group, labels


# 夹角余弦距离公式
def cosdist(vector1,vector2):
Lv1 = sqrt(vector1*vector1.T)
Lv2 = sqrt(vector2*vector2.T)
return vector1*vector2.T/(Lv1*Lv2)
    


# kNN分类器
# 测试集：inX
# 训练集：dataSet
# 类别标签：labels
# k:k个邻居数
def classify(testdata, dataSet, labels, k):
 # 返回样本集的行数
    dataSetSize = dataSet.shape[0]    
    # 计算测试集与训练集之间的距离：标准欧氏距离
    # 1.计算测试项与训练集各项的差
    diffMat = tile(testdata, (dataSetSize,1)) - dataSet
    # 2.计算差的平方和
    sqDiffMat = diffMat**2
    # 3.按列求和
    sqDistances = sqDiffMat.sum(axis=1)
    # 4.生成标准化欧氏距离
    distances = sqDistances**0.5
    print distances
    # 5.根据生成的欧氏距离大小排序,结果为索引号
    sortedDistIndicies = distances.argsort()        
    classCount={}     
    # 获取欧氏距离的前三项作为参考项          
    for i in range(k):  # i = 0~(k-1)    
     # 按序号顺序返回样本集对应的类别标签
        voteIlabel = labels[sortedDistIndicies[i]]
        # 为字典classCount赋值,相同key，其value加1
        # key:voteIlabel，value: 符合voteIlabel标签的训练集数 
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
    # 对分类字典classCount按value重新排序
    # sorted(data.iteritems(), key=operator.itemgetter(1), reverse=True) 
    # 该句是按字典值排序的固定用法
    # classCount.iteritems()：字典迭代器函数
    # key：排序参数；operator.itemgetter(1)：多级排序
    sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
    # 返回序最高的一项
    return sortedClassCount[0][0]


k=3
testdata=[0.2,0.2]
dataSet,labels = createDataSet()


# 绘图
fig = plt.figure()
ax = fig.add_subplot(111)
indx = 0 
for point in dataSet:
if labels[indx] == 'A' :
ax.scatter(point[0],point[1],c='blue',marker='o',linewidths=0, s=300)
plt.annotate("("+str(point[0])+","+str(point[1])+")",xy = (point[0],point[1]))
else:
ax.scatter(point[0],point[1],c='red',marker='^',linewidths=0, s=300)
plt.annotate("("+str(point[0])+", "+str(point[1])+")",xy = (point[0],point[1]))
indx += 1


ax.scatter(testdata[0],testdata[1],c='green',marker='s',linewidths=0, s=300)
plt.annotate("("+str(testdata[0])+", "+str(testdata[1])+")",xy = (testdata[0],testdata[1]))


plt.show()
print classify(testdata, dataSet, labels, k)

结果显示如下:

总结：本文主要讲述了两个比较简单的算法:朴素贝叶斯和最近邻算法。一般而言，KNN算法的原理简单，分类精度尚可;支持向量机(SVN)算法的优势支持线性不可分的情况，精度上取中;朴素贝叶斯(bayes)算法对于短文分类的效果好，精度很高。