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

翻译 2016年11月29日 13:15:10

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)算法对于短文分类的效果好,精度很高。

相关文章推荐

中文文本分类(机器学习算法原理与编程实践笔记)

以文本分类算法为中心,详细介绍一个中文文本分类项目的流程及相关知识,知识点涉及中文分词、向量空间模型、TF-IDF方法、几个典型的文本分类算法;主要有朴素贝叶斯算法,kNN最近邻算法。 所用到的外部...

用朴素贝叶斯分类算法做中文文本分类

一. 朴素贝叶斯分类算法的原理朴素贝叶斯分类器基于属性条件独立假设:对于已知类别,假设所有属性相互独立,也就是说,假设每个属性独立地对分类结果产生影响。 设待分类的样本属性集为TT,其中包含nn个属...

Cart文本分类算法原理和例子

ID3使用信息增益作为属性选择标准,c4.5使用信息增益率作为属性选择标准。Cart算法使用GIni系数来度量对某个属性变量测试输出的狼族取值的差异性,理想的分组应该尽量使两组中样本输出变量的差异性总...

数据挖掘:基于朴素贝叶斯分类算法的文本分类实践

如果你想对一个陌生的文本进行分类处理,例如新闻、游戏或是编程相关。那么贝叶斯分类算法应该正是你所要找的了。贝叶斯分类算法是统计学中的一种分类方法,它利用概率论中的贝叶斯公式进行扩展。下面我们就针对朴素...

卷积神经网络在NLP领域的实践:文本分类[转]

卷积神经网络(CNN)在计算机视觉领域取得了极大的进展,但是除此之外CNN也逐渐在自然语言处理(NLP)领域攻城略地。本文主要以文本分类为例,介绍卷积神经网络在NLP领域的一个基本使用方法。 ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)