，中文文本分类流程：
预处理
中文分词
结构化表示-构建词向量空间
权重策略—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)
当然，你也可以采用其他分类器
来源：CSDN
作者：xiaoyaGrace
链接：https://blog.csdn.net/xiaoyaGrace/article/details/103814733