黑马程序员技术交流社区

标题: 【上海校区】python中文文本分类 [打印本页]

---

作者: 梦缠绕的时候    时间: 2019-1-24 10:32
标题: 【上海校区】python中文文本分类
一，中文文本分类流程：
预处理
中文分词
结构化表示-构建词向量空间
权重策略—TF-IDF
分类器
评价.
二，具体实现
预处理
1.1 打标签：
对评论数据打好标签，这里将汽车评论数据分为正面和负面两类。假设负面标签为0，正面标签为1.

1.2 整理数据集：
一般可分为训练集，验证集和测试集。为什么要这么分，这篇博文给了浅显的解释：训练集、验证集和测试集的意义本试验将数据分为训练集和测试集两类。

1.3 得到训练集预料库：
例如，训练集文本的路径：train_data/train_positive.xlsx , train_data/train_negtive.xlsx…

1.4 得到测试集语料库：
例如，测试集文本的路径：test_data/test_negtive.xlsx , test_data/test_positive.xlsx…

2 中文分词
2.1 概述
第1节预处理中的语料库都是没有分词的原始语料（即连续的句子，而后面的工作需要把文本分为一个个单词），现在需要对这些文本进行分词，只有这样，才能在基于单词的基础上，对文档进行结构化表示。
中文分词有其特有的难点（相对于英文而言），最终完全解决中文分词的算法是基于概率图模型的条件随机场（CRF），CRF的原理我们不细说了，直接调用中文分词的工具，这里用的是python第三方分词库jieba(所采用的算法就是条件随机场)
关于分词库的更多讨论可以参考这篇文章：python分词工具推荐

2.2 jieba分词简述
首先讲解jieba分词使用方法（详细的和更进一步的，可以参考jieba分词原理

jieba.cut 方法接受三个输入参数: 需要分词的字符串；cut_all 参数用来控制是否采用全模式；HMM 参数用来控制是否使用 HMM 模型
jieba.cut_for_search 方法接受两个参数：需要分词的字符串；是否使用 HMM 模型。该方法适合用于搜索引擎构建倒排索引的分词，粒度比较细
待分词的字符串可以是 unicode 或 UTF-8 字符串、GBK 字符串。注意：不建议直接输入 GBK 字符串，可能无法预料地错误解码成 UTF-8
jieba.cut 以及 jieba.cut_for_search 返回的结构都是一个可迭代的 generator，可以使用 for 循环来获得分词后得到的每一个词语(unicode)，或者用
jieba.lcut 以及 jieba.lcut_for_search 直接返回 list
jieba.Tokenizer(dictionary=DEFAULT_DICT) 新建自定义分词器，可用于同时使用不同词典。jieba.dt 为默认分词器，所有全局分词相关函数都是该分词器的映射。

实例代码：

import jieba

seg_list = jieba.cut("我来到北京清华大学", cut_all=True)
print("Full Mode: " + "/ ".join(seg_list))  # 全模式

seg_list = jieba.cut("我来到北京清华大学", cut_all=False)
print("Default Mode: " + "/ ".join(seg_list))  # 精确模式

seg_list = jieba.cut("他来到了网易杭研大厦")  # 默认是精确模式
print(", ".join(seg_list))

seg_list = jieba.cut_for_search("小明硕士毕业于中国科学院计算所，后在日本京都大学深造")  # 搜索引擎模式
print(", ".join(seg_list))

输出:
【全模式】: 我/ 来到/ 北京/ 清华/ 清华大学/ 华大/ 大学

【精确模式】: 我/ 来到/ 北京/ 清华大学

【新词识别】：他, 来到, 了, 网易, 杭研, 大厦    (此处，“杭研”并没有在词典中，但是也被Viterbi算法识别出来了)

【搜索引擎模式】： 小明, 硕士, 毕业, 于, 中国, 科学, 学院, 科学院, 中国科学院, 计算, 计算所, 后, 在, 日本, 京都, 大学, 日本京都大

接下来，我们要通过python编程，来将1.3节中的 ./train_data/原始训练语料库和1.4节中的./test_data/原始测试语料库进行分词，分词后保存的路径可以设置为：./train_data_seg/和./test_data_seg/

代码如下，思路很简单，就是将excel里面的评论数据一条一条取出来保存到DataFrame中，然后遍历DataFrame中的文本数据，将每个文本依次进行分词之后保存到对应路径。

# encoding = utf-8

import sys
import os
import jieba
import jieba.analyse
import pandas as pd
import xlrd
import importlib
from pandas import DataFrame
from sklearn.datasets.base import Bunch
'''
#全模式
seg_list = jieba.cut("我是一位小仙女", cut_all = True)
print("Full Mode:" + "/".join(seg_list))

#精确模式,cut_all 属性不写的话也是默认精确模式
seg_list = jieba.cut("DX7 Prime是国产汽车SUV由内到外最上乘的！", cut_all= False)
print("Default Mode："  + "/".join(seg_list))
'''

#保存至文件
def savefile(savepath, content):
    with open(savepath, "wb") as fp:
        fp.write(content.encode("utf-8"))

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

#读取Excel中的文件
def read_excel(path):
    df = pd.read_excel(path)
    return df

#搜索引擎模式，对数据集做分词切分
def data_segment(df):
    list=[]
    for item in df :
        seg = jieba.cut_for_search(item)
        seg_str = " ".join(seg)
        list.append(seg_str)
        dff = pd.DataFrame(list, columns=["context"])
    return dff

def text_segment(df, seg_path ):
    """
    corpus_path是未分词预料库的路径
    seg_path是分词后语料库的路径
    """
    list =[]
    i = 1
    if not os.path.exists(seg_path):
        os.makedirs(seg_path)
    for item in df:
        seg =jieba.cut(item)
        seg_str =",".join(seg)
        class_path = str(i)+".txt"
        savefile(seg_path + class_path, "".join(seg_str))
        i+=1

if __name__ == "__main__":
    #训练集
    df_positive = pd.read_excel('train_data/train_positive.xlsx')
    seg_path1 = "./train_data_seg/1/"  # 分词后分类语料库路径
    df_positive_segment = text_segment(df_positive['context'], seg_path1)

    df_negtive = pd.read_excel('train_data/train_negtive.xlsx')
    seg_path0 = "./train_data_seg/0/" #分词后分类预料库的路径
    df_negtive_segment = text_segment(df_negtive['context'], seg_path0)
    #df_negtive_segment = data_segment(df_negtive['context'])

    #测试集
    test_positive = pd.read_excel('test_data/test_positive.xlsx')
    seg_test_path1 = "./test_data_seg/1/"  #分词后分类语料库路径
    test_positive_segment = text_segment(test_positive['context'] ,seg_test_path1)

    test_negtive = pd.read_excel('test_data/test_negtive.xlsx')
    seg_test_path0 = "./test_data_seg/0/" #分词后分类语料库路径
    test_negtive_segment = text_segment(test_negtive['context'] , seg_test_path0)

现在，我们已经得到了分词后的训练集语料库和测试集语料库，下面我们要把这两个数据集表示为变量，从而为下面程序调用提供服务。我们采用的是Scikit-Learn库中的Bunch数据结构来表示这两个数据集。

首先来看看Bunch:，通俗的说：

Bunch这玩意儿，其实就相当于python中的字典。你往里面传什么，它就存什么。

接下来，让我们看看的我们的数据集（训练集）有哪些信息：

1，类别，也就是所有分类类别的集合，即我们./train_data_seg/和./test_data_seg/下的所有子目录的名字。我们在这里不妨把它叫做target_name（这是一个列表）

2，文本文件名。例如./train_data_seg/0/1.txt，我们可以把所有文件名集合在一起做一个列表，叫做filenames

3，文本标签（就是文本的类别），不妨叫做label（与2中的filenames相对应）

例如2中的文本“1.txt”在./train_data_seg/0/目录下，则它的标签就是0。

文本标签与1中的类别区别在于：文本标签集合里面的元素就是1中类别，而文本标签集合的元素是可以重复的，因为./train_data_seg/0/目录下有好多文本，不是吗？相应的，1中的类别集合元素显然都是独一无二的类别。

4，文本内容（contens）。

上一步代码我们已经成功的把文本内容进行了分词，并且去除掉了所有的换行，得到的其实就是一行词袋。

那么，用Bunch表示，就是：

from sklearn.datasets.base import Bunch
bunch = Bunch(target_name=[],label=[],filenames=[],contents=[])

我们在Bunch对象里面创建了有4个成员：
target_name：是一个list，存放的是整个数据集的类别集合。
label：是一个list，存放的是所有文本的标签。
filenames：是一个list，存放的是所有文本文件的名字。
contents：是一个list，分词后文本文件（一个文本文件只有一行）

代码实现：

# -*- coding: UTF-8 -*-
#数据集的变量表示
from Jieba import data_segment as ds
from sklearn.datasets.base import Bunch
import os
import sys
import pandas as pd
import pickle

def _readfile(path):
    with open(path, "r" ,encoding="utf-8") as fp:
        content = fp.read()
    return content

def data2Bunch(wordbag_path, seg_path):
    catelist = os.listdir(seg_path) #获取seg_path所有的子目录，也就是分类信息
    #print(catelist)
    #创建一个Bunchshili
    bunch = Bunch(target_name=[], label=[], filenames=[],contents=[])
    #print(bunch)
    bunch.target_name.extend(catelist)
    '''
       extend(addlist)是python list中的函数，意思是用新的list（addlist）去扩充
       原来的list
    '''
    #获取每个目录下的所有文件
    for mydir in catelist:
        class_path = seg_path + mydir +"/" #拼出分类子目录的路径
        file_list =os.listdir(class_path)  #获取class_path下的所有文件
        for file_path in file_list:
            fullname = class_path + file_path #拼出文件的全名称
            bunch.label.append(mydir)
            bunch.filenames.append(fullname)
            bunch.contents.append(_readfile(fullname)) #读取文件的内容
            '''append(element)是python list中的函数，向原来的list中添加element'''
    #将bunch存储到wordbag_path路径中
    #print(bunch.contents)
    if not os.path.exists(wordbag_path):  # 如果没有这个路径就先创建出来
        os.makedirs(wordbag_path)

    with open(wordbag_path, "wb" ) as file_obj:
        pickle.dump(bunch, file_obj , 0)


if __name__ == "__main__":
    #对训练集进行Bunch化操作
    wordbag_path = "train_word_bag/train_set1.dat" #Bunch存储路径
    seg_path = "train_data_seg/"
    data2Bunch(wordbag_path, seg_path)

    #对测试集进行Bunch化操作
    wordbag_path = "test_word_bag/test_set.dat" #Bunch存储路径
    seg_path = "test_data_seg/"
    data2Bunch(wordbag_path, seg_path)


3，结构化表示–向量空间模型
在第2节中，我们对原始数据集进行了分词处理，并且通过绑定为Bunch数据类型，实现了数据集的变量表示。词向量并没有清晰的概念，简单来讲，词向量就是词向量空间里面的一个向量。这里有一篇非常棒的文章《Deep Learning in NLP （一）词向量和语言模型》

你可以类比为三维空间里面的一个向量，例如：

如果我们规定词向量空间为：（我，喜欢，相国大人），这相当于三维空间里面的（x，y，z）只不过这里的x，y，z的名字变成了“我”，“喜欢”，“相国大人”

现在有一个词向量是：我 喜欢 喜欢相国大人

表示在词向量空间中就变为：（1,2,1），归一化后可以表示为：（0.166666666667 0.333333333333 0.166666666667）表示在刚才的词向量空间中就是这样：

接下来我们要做的，就是把所有这些词统一到同一个词向量空间中。

为了节省空间，我们首先将训练集中每个文本中一些垃圾词汇去掉。所谓的垃圾词汇，就是指意义模糊的词，或者一些语气助词，标点符号等等，通常他们对文本起不了分类特征的意义。这些垃圾词汇我们称之为停用词。把所有停用词集合起来构成一张停用词表格，这样，以后我们处理文本时，就可以从这个根据表格，过滤掉文本中的一些垃圾词汇了。
下面的程序，目的就是要将训练集所有文本文件统一到同一个词向量空间中。

下面的一节主要目标是希望得到两个东西：

1.词典（单词和单词对应的序号）

2.权重矩阵tdm，其中，权重矩阵是一个二维矩阵，tdm[i][j]表示，第j个词（即词典中的序号）在第i个类别中的IF-IDF值（下文有讲解）。

事实上，tdm的每一列都是一个单词在各个类别中的全职。我们把这每一列当作词向量。

4，权重策略–TF-IDF
什么是TF-IDF?今后有精力我会在这里更新补充，现在，先给你推荐一篇非常棒的文章《使用scikit-learn工具计算文本TF-IDF值》
下面，我们假定你已经对TF-IDF有了最基本的了解。请你动动你的小脑袋瓜想一想，我们把训练集文本转换成了一个TF-IDF词向量空间，姑且叫它为A空间吧。那么我们还有测试集数据，我们以后实际运用时，还会有新的数据，这些数据显然也要转到词向量空间，那么应该和A空间为同一个空间吗？

是的。

即使测试集出现了新的词汇（不是停用词），即使新的文本数据有新的词汇，只要它不是训练集生成的TF-IDF词向量空间中的词，我们就都不予考虑。这就实现了所有文本词向量空间“大一统”，也只有这样，大家才在同一个世界里。才能进行下一步的研究。

下面的程序就是要将训练集所有文本文件（词向量）统一到同一个TF-IDF词向量空间中（或者叫做用TF-IDF算法计算权重的有权词向量空间）。这个词向量空间最终存放在train_word_bag/tfdifspace.dat中。

这段代码你可能有点看不懂，因为我估计你可能比较懒，还没看过TF-IDF（尽管我刚才已经给你推荐那篇文章了）。你只需要明白，它把一大坨训练集数据成功的构建了一个TF-IDF词向量空间，空间的各个词都是出自这个训练集（去掉了停用词）中，各个词的权值也都一并保存了下来，叫做权重矩阵。

需要注意的是，你要明白，权重矩阵是一个二维矩阵，a[i][j]表示，第j个词在第i个类别中的IF-IDF值（看到这里，我估计你压根就没去看那篇文章，所以你可能到现在也不知道 这是个啥玩意儿。。。）

请记住权重矩阵这个词，代码解释中我会用到。

# -*- coding: UTF-8 -*-

import os
import sys
from scikit_Bunch import Bunch
from sklearn.feature_extraction.text import TfidfVectorizer

import pickle

#读取文件
def _readfile(path):
    with open(path, "r" ,encoding="utf-8") as fp:
        content = fp.read()
    return content

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

#写入bunch对象
def _writebunchobj(path, bunch_obj):
    with open(path, "wb") as file_obj:
        pickle.dump(bunch_obj, file_obj, 0)


#这个函数用于创建TF-IDF词向量空间
def Vector_Space(stopWords_path, bunch_path, space_path, train_tfidf_path = None):
    stopWords = _readfile(stopWords_path).splitlines() #读取停用词
    stopWords[0] = "？？？"
    bunch = _readbunchobj(bunch_path) #导入分词后的词向量bunch对象
    # 构建tf-idf词向量空间对象
    tfidfspace = Bunch(target_name=bunch.target_name, label=bunch.label, filenames=bunch.filenames, tdm=[], vocabulary={})
    '''
        与下面这2行代码等价的代码是：
        vectorizer=CountVectorizer()#构建一个计算词频（TF）的玩意儿，当然这里面不只是可以做这些
        transformer=TfidfTransformer()#构建一个计算TF-IDF的玩意儿
        tfidf=transformer.fit_transform(vectorizer.fit_transform(corpus))
        #vectorizer.fit_transform(corpus)将文本corpus输入，得到词频矩阵
        #将这个矩阵作为输入，用transformer.fit_transform(词频矩阵)得到TF-IDF权重矩阵
        看名字你也应该知道：
        TfidfTransformer + CountVectorizer  = TfidfVectorizer
        下面的代码一步到位，把上面的两个步骤一次性全部完成
        值得注意的是，CountVectorizer()和TfidfVectorizer()里面都有一个成员叫做vocabulary_(后面带一个下划线)
        这个成员的意义，与我们之前在构建Bunch对象时提到的自己定义的那个vocabulary的意思是一样的，只不过一个是私有成员，一个是外部输入，原则上应该保持一致。
        创建tfidfspace中定义的vocabulary就应该被赋值为这个vocabulary_
    '''
    #构建一个快乐地一步到位的玩意儿，专业一点儿叫做：使用TfidfVectorizer初始化向量空间模型
    #这里面有TF-IDF权重矩阵还有我们要的词向量空间坐标轴信息vocabulary_
    if train_tfidf_path is not None:
        trainbunch = _readbunchobj(train_tfidf_path)
        tfidfspace.vocabulary = trainbunch.vocabulary
        vectorizer = TfidfVectorizer(stop_words=stopWords, sublinear_tf=True,max_df=0.5, vocabulary=trainbunch.vocabulary,analyzer='word',token_pattern=u"(?u)\\b\\w+\\b")
        # 此时tdm里面存储的就是if-idf权值矩阵
        print(bunch.contents)
        #print("gggggggggg")
        tfidfspace.tdm = vectorizer.fit_transform(bunch.contents)

        '''
        stop_words：
        参数是用来传入停用词，以后我们获得vocabulary_的时候，就会根据文本信息去掉停用词得到
        sublinear_tf:
        计算tf值采用亚线性策略。比如，我们以前算tf是词频，现在用1+log(tf)来充当词频。
        smooth_idf:
        计算idf的时候log(分子/分母)分母有可能是0，smooth_idf会采用log(分子/(1+分母))的方式解决。默认已经开启，无需关心。
        norm:
        归一化，我们计算TF-IDF的时候，是用TF*IDF，TF可以是归一化的，也可以是没有归一化的，一般都是采用归一化的方法，默认开启.
        max_df:
        有些词，他们的文档频率太高了（一个词如果每篇文档都出现，那还有必要用它来区分文本类别吗？当然不用了呀），所以，我们可以
        设定一个阈值，比如float类型0.5（取值范围[0.0,1.0]）,表示这个词如果在整个数据集中超过50%的文本都出现了，那么我们也把它列
        为临时停用词。当然你也可以设定为int型，例如max_df=10,表示这个词如果在整个数据集中超过10的文本都出现了，那么我们也把它列
        为临时停用词。
        min_df:
        与max_df相反，虽然文档频率越低，似乎越能区分文本，可是如果太低，例如10000篇文本中只有1篇文本出现过这个词，仅仅因为这1篇
        文本，就增加了词向量空间的维度，太不划算。
        当然，max_df和min_df在给定vocabulary参数时，就失效了。
        '''
    else:
        vectorizer = TfidfVectorizer(stop_words=stopWords, sublinear_tf=True, max_df=0.5, analyzer='word',token_pattern=u"(?u)\\b\\w+\\b")
        tfidfspace.tdm = vectorizer.fit_transform(bunch.contents)
        tfidfspace.vocabulary = vectorizer.vocabulary_
        print(tfidfspace)
        print("666666666666")

    _writebunchobj(space_path, tfidfspace)

if __name__ == '__main__':
    #训练集
    stopword_path = "train_word_bag/stop_words.txt"#停用词表的路径
    bunch_path = "train_word_bag/train_set1.dat"  #导入训练集Bunch的路径
    space_path = "train_word_bag/tfdifspace.dat"  # 词向量空间保存路径
    Vector_Space(stopword_path, bunch_path, space_path)

    #测试集
    bunch_path = "test_word_bag/test_set.dat" #导入测试集Bunch的路径
    space_path = "test_word_bag/testspace.dat" #测试集词向量保存路径
    train_tfidf_path = "train_word_bag/tfdifspace.dat"
    Vector_Space(stopword_path, bunch_path, space_path , train_tfidf_path)


上面的代码运行之后，会将训练集数据转换为TF-IDF词向量空间中的实例，保存在train_word_bag/tfdifspace.dat中，具体来说，这个文件里面有两个我们感兴趣的东西，一个是vocabulary，即词向量空间坐标，一个是tdm，即训练集的TF-IDF权重矩阵。

接下来，我们要开始第5步的操作，设计分类器，用训练集训练，用测试集测试。在做这些工作之前，你一定要记住，首先要把测试数据也映射到上面这个TF-IDF词向量空间中，也就是说，测试集和训练集处在同一个词向量空间（vocabulary相同），只不过测试集有自己的tdm，与训练集（train_word_bag/tfdifspace.dat）中的tdm不同而已。

同一个世界，同一个梦想。

至于说怎么弄，请看下节。

5，分类器
这里我们采用的是朴素贝叶斯分类器，今后我们会详细讲解它。

现在，你即便不知道这是个啥玩意儿，也一点不会影响你，这个分类器我们有封装好了的函数，MultinomialNB，这玩意儿获取训练集的权重矩阵和标签，进行训练，然后获取测试集的权重矩阵，进行预测（给出预测标签）。

from sklearn.naive_bayes import MultinomialNB #导入多项式贝叶斯算法
from sklearn import metrics
import pickle
from sklearn.feature_extraction.text import TfidfVectorizer

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

#导入训练集
trainpath = "train_word_bag/tfdifspace.dat"
train_set =_readbunchobj(trainpath)
print(train_set.tdm.shape)

#导入测试集
testpath = "test_word_bag/testspace.dat"
test_set = _readbunchobj(testpath)
print(test_set.tdm.shape)

# 训练分类器：输入词袋向量和分类标签，alpha:0.001 alpha越小，迭代次数越多，精度越高
clf = MultinomialNB(alpha=0.001).fit(train_set.tdm, train_set.label)

#之前报训练集和测试集维度不匹配，predict方法出错，百度搜到的解决办法，然而并没有什么鬼用的三行
# vectorizer = TfidfVectorizer()
# fea_train = vectorizer.fit_transform(train_set)
# fea_test = vectorizer.transform(test_set)

#预测分类结果,输出是测试训练集预测出来的标签列表
predicted = clf.predict(test_set.tdm)

for flabel, file_name, expct_cate in zip(test_set.label, test_set.filenames, predicted):
    if flabel != expct_cate:
        print(file_name, ": 实际类别:", flabel, " -->预测类别:", expct_cate)

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

metrics_result(test_set.label, predicted)


当然，你也可以采用其他分类器

---

作者: 不二晨    时间: 2019-1-24 14:41
奈斯

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2