文本挖掘-实战记录（一）新闻文本nmi降维+分类训练_文本挖掘作业

1. import pandas as pd  
2. import jieba, time  
3. #tfidf  
4. from sklearn.feature_extraction.text import TfidfVectorizer  
5. #计算nmi  
6. from sklearn import metrics  

1. train_df = pd.read_csv(
2. 'D:/文本挖掘/作业四/data.csv', sep=',', header=None,encoding='utf-8')  
3. train_df.columns = ['分类', '文章']  
4. #生成停用词表  
5. stopword_list = [k.strip() for k in open(
6. 'D:/文本挖掘/新闻类/stopwords.txt', encoding='utf-8') if k.strip() != '']  
7. #生成分词表   
8. cutWords_list = []  
9.   
10. for i in range(0,len(train_df)):  
11.     #分词  
12.     outstr = ''  
13.     seg_list = jieba.cut(train_df['文章'][i].strip())  
14.     for word in seg_list :#读取每一行分词  
15.         if word not in stopword_list:  
16.             if word != '\t':  #不加空格进去  
17.                 outstr += word + " "  
18.     cutWords_list.append(outstr)#将该行分词写入列表形式的总分词列表 

1. #遍历带字符的列  
2. for fea in  ['分类']:  
3.     labels = train_df[fea].unique().tolist()   #unique去重复元素，tolist转成列表  
4.     train_df[fea] = train_df[fea].apply(lambda x:labels.index(x))  
5. y = train_df['分类']  

1. tfidfVectorizer = TfidfVectorizer(  
2.     dtype = float,       
3.     min_df = 2,  
4.     token_pattern=u'[\u4e00-\u9fa5]+',  
5.     norm = 'l2' )   
6. #生成矩阵的数值类型  
7. #如果某个词的document frequence小于2，则这个词不会被当作关键词  
8. #通过正则表达式来确定非中文字符数据被过滤掉  
9. #标准化  
10.   
11. #训练和测试的词频向量格式保持一致  
12. X_Vector=tfidfVectorizer.fit_transform(cutWords_list)  # 将文章转化为tfidf矩阵  
13. b = tfidfVectorizer.get_feature_names()

1. #将列名添加给矩阵  
2. df = pd.DataFrame(X_Vector.toarray(),columns=b) 

1. #计算nmi  
2. nmi ={}  
3. for i in range(X_Vector.shape[1]):  
4.     x = X_Vector.toarray()[:,i]  
5.     result_NMI = metrics.normalized_mutual_info_score(x,y)  
6.     nmi[b[i]] = result_NMI 

1. #给nmi值进行排序  
2. nmi=sorted(nmi.items(),key=lambda x:x[1],reverse=True)  
3. print(len(nmi))  
4. #获取nmi前500  
5. ls=nmi[:500]  
6. #查看是否降维成功  
7. print(len(ls)) 

1. #定义一个空列表为l  
2. l = []  
3. #遍历通过nmi降维得到的nmi词袋列表ls，将得到的500个词追加到l中，便于后边循环  
4. for i in range(len(ls)):  
5.     l.append(ls[i][0]) 

1. #定义新列表  
2. hh = []  
3. #将降维得到的500个词和原来917个词对比，将原tfidf矩阵中对应词列追加到新列表hh中  
4. for j in l:  
5.     for z in b:  
6.         if j == z:  
7.             hh.append(df[z].tolist())  
8. #基于nmi降维得到的全新tfidf矩阵hh转换为数组形式方便后续分类器模型运用  
9. xx = np.array(hh).reshape(200,500)  
10. #至此预处理完成

1. #训练集预处理  
2. test_df = pd.read_csv(
3. 'D:/文本挖掘/作业四/test.csv', sep=',', header=None,encoding='utf-8')  
4. test_df.columns = ['分类', '文章']  
5. #生成停用词表  
6. stopword_list = [k.strip() for k in open(
7. 'D:/文本挖掘/新闻类/stopwords.txt', encoding='utf-8') if k.strip() != '']  
8. #生成分词表   
9. test_cutWords_list = []  
10.   
11. for i in range(0,len(test_df)):  
12.     #分词  
13.     outstr = ''  
14.     seg_list = jieba.cut(test_df['文章'][i].strip())  
15.     for word in seg_list :#读取每一行分词  
16.         if word not in stopword_list:  
17.             if word != '\t':  #不加空格进去  
18.                 outstr += word + " "  
19.     test_cutWords_list.append(outstr)#将该行分词写入列表形式的总分词列表  
20. #遍历带字符的列  
21. for fea in  ['分类']:  
22.     labels = test_df[fea].unique().tolist()   #unique去重复元素，tolist转成列表  
23.     test_df[fea] = test_df[fea].apply(lambda x:labels.index(x))  
24. y_text = test_df['分类']  
25.   
26. #生成矩阵的数值类型  
27. #如果某个词的document frequence小于5，则这个词不会被当作关键词  
28. #通过正则表达式来确定非中文字符数据被过滤掉  
29. #标准化  
30. test_tfidfVectorizer = TfidfVectorizer(  
31.     dtype = float,       
32.     min_df = 2,  
33.     token_pattern=u'[\u4e00-\u9fa5]+',  
34.     norm = 'l2' )   
35.   
36. #训练和测试的词频向量格式保持一致  
37. test_X_Vector=text_tfidfVectorizer.fit_transform(test_cutWords_list)  # 将文章转化为tfidf矩阵  
38. b = test_tfidfVectorizer.get_feature_names()#获得tfidf矩阵对应特征  
39. #将列名添加给矩阵  
40. df = pd.DataFrame(test_X_Vector.toarray(),columns=b)  
41. xx_test = np.array(test_X_Vector.toarray()).reshape(44,107)  
42. #至此预处理完成 

 二、模型训练

1.训练集模型训练

将得到的xx作为训练集‘x’参数与y（总文档分类列重编码后的结果）作为‘y’参数进行模型训练

a)支持向量机（SVC）

b)逻辑斯蒂分类器

c)高斯朴素贝叶斯

d)随机森林分类器

e)Knn分类器

f)AdaBoost分类器

2.训练集模型训练

3.结果展示

a)训练集模型得分

 

b)测试集模型得分

 三、难点与总结

难点

遇到的问题在nmi降维上，实际上选取nmi总体前500的词并不能完全代表数据中的每个文档，因为并不明确每个文档前几的词是否有重复，最应该选择的nmi降维方式应该是对应每个文档nmi为前5或者前10的词进行降维，但是本次小组讨论中并没有讨论出合适的方法，找到合适的文献去进行该工作。

总结

文本挖掘与数据挖掘不同点在于文本挖掘需要清楚了解如何通过tfidf矩阵将字符型词转换为数值型方便后续运算。

在最终模型测试中可以看见朴素贝叶斯分类器在测试集与训练集都非常高，随机森林分类器简直为训练集量身定制，准确率吻合1.0，而神经网络有关的两个分类器准确率需要通过调参去找到使分类结果准确率更高的参数，如果按默认参数使用该两个神经网络分类器，在训练集中效果不足。

四、源码

import pandas as pd

import jieba, time

import numpy as np

#tfidf

from sklearn.feature_extraction.text import TfidfVectorizer

#计算nmi

from sklearn import metrics

#svc支持向量机

from sklearn.svm import SVC

from sklearn.metrics import accuracy_score

#朴素贝叶斯

from sklearn.naive_bayes import GaussianNB

#随机森林

from sklearn.ensemble import RandomForestClassifier

#逻辑斯蒂

from sklearn.linear_model import LogisticRegression

#knn分类器

from sklearn.neighbors import KNeighborsClassifier

#AdaBoost分类

from sklearn.ensemble import AdaBoostClassifier

train_df = pd.read_csv('D:/文本挖掘/作业四/data.csv', sep=',', header=None,encoding='utf-8')

train_df.columns = ['分类', '文章']

#生成停用词表

stopword_list = [k.strip() for k in open('D:/文本挖掘/新闻类/stopwords.txt', encoding='utf-8') if k.strip() != '']

#生成分词表

cutWords_list = []

for i in range(0,len(train_df)):

    #分词

    outstr = ''

    seg_list = jieba.cut(train_df['文章'][i].strip())

    for word in seg_list :#读取每一行分词

        if word not in stopword_list:

            if word != '\t':  #不加空格进去

                outstr += word + " "

    cutWords_list.append(outstr)#将该行分词写入列表形式的总分词列表

#遍历带字符的列

for fea in  ['分类']:

    labels = train_df[fea].unique().tolist()   #unique去重复元素，tolist转成列表

    train_df[fea] = train_df[fea].apply(lambda x:labels.index(x))

y = train_df['分类']

#生成矩阵的数值类型

#如果某个词的document frequence小于5，则这个词不会被当作关键词

#通过正则表达式来确定非中文字符数据被过滤掉

#标准化

tfidfVectorizer = TfidfVectorizer(

    dtype = float,    

    min_df = 2,

    token_pattern=u'[\u4e00-\u9fa5]+',

    norm = 'l2' )

#训练和测试的词频向量格式保持一致

X_Vector=tfidfVectorizer.fit_transform(cutWords_list)  # 将文章转化为tfidf矩阵

b = tfidfVectorizer.get_feature_names()#获得tfidf矩阵对应特征

#将列名添加给矩阵

df = pd.DataFrame(X_Vector.toarray(),columns=b)

#计算nmi

nmi ={}

for i in range(X_Vector.shape[1]):

    x = X_Vector.toarray()[:,i]

    result_NMI = metrics.normalized_mutual_info_score(x,y)

    nmi[b[i]] = result_NMI

#给nmi值进行排序

nmi=sorted(nmi.items(),key=lambda x:x[1],reverse=True)

print(len(nmi))

#获取nmi前500

ls=nmi[:500]

#查看是否降维成功

print(len(ls))

#查看排序后的前500个词的nmi

ls

#定义一个空列表为l

l = []

#遍历通过nmi降维得到的nmi词袋列表ls，将得到的500个词追加到l中，便于后边循环

for i in range(len(ls)):

    l.append(ls[i][0])

#查看l

l

#定义新列表

hh = []

#将降维得到的500个词和原来917个词对比，将原tfidf矩阵中对应词列追加到新列表hh中

for j in l:

    for z in b:

        if j == z:

            hh.append(df[z].tolist())

#基于nmi降维得到的全新tfidf矩阵hh转换为数组形式方便后续分类器模型运用

xx = np.array(hh).reshape(200,500)

#至此预处理完成

print(xx.shape)

print(xx)

#训练集预处理

test_df = pd.read_csv('D:/文本挖掘/作业四/test.csv', sep=',', header=None,encoding='utf-8')

test_df.columns = ['分类', '文章']

#生成停用词表

stopword_list = [k.strip() for k in open('D:/文本挖掘/新闻类/stopwords.txt', encoding='utf-8') if k.strip() != '']

#生成分词表

test_cutWords_list = []

for i in range(0,len(test_df)):

    #分词

    outstr = ''

    seg_list = jieba.cut(test_df['文章'][i].strip())

    for word in seg_list :#读取每一行分词

        if word not in stopword_list:

            if word != '\t':  #不加空格进去

                outstr += word + " "

    test_cutWords_list.append(outstr)#将该行分词写入列表形式的总分词列表

#遍历带字符的列

for fea in  ['分类']:

    labels = test_df[fea].unique().tolist()   #unique去重复元素，tolist转成列表

    test_df[fea] = test_df[fea].apply(lambda x:labels.index(x))

y_text = test_df['分类']

#生成矩阵的数值类型

#如果某个词的document frequence小于5，则这个词不会被当作关键词

#通过正则表达式来确定非中文字符数据被过滤掉

#标准化

test_tfidfVectorizer = TfidfVectorizer(

    dtype = float,    

    min_df = 2,

    token_pattern=u'[\u4e00-\u9fa5]+',

    norm = 'l2' )

#训练和测试的词频向量格式保持一致

test_X_Vector=text_tfidfVectorizer.fit_transform(test_cutWords_list)  # 将文章转化为tfidf矩阵

b = test_tfidfVectorizer.get_feature_names()#获得tfidf矩阵对应特征

#将列名添加给矩阵

df = pd.DataFrame(test_X_Vector.toarray(),columns=b)

xx_test = np.array(test_X_Vector.toarray()).reshape(44,107)

#至此预处理完成

print(xx_test.shape)

print(xx_test)

#训练集测试模型

clf = SVC()  #选择SVC模型

clf.fit(xx,y)

#4.计算svc分类器的准确率

print("训练集：",clf.score(xx,y))

#逻辑斯蒂文本分类实现

logitmodel=LogisticRegression()#定义回归模型

logitmodel.fit(xx,y)#训练模型

#4.计算逻辑斯蒂文本分类器的准确率

print("训练集：",logitmodel.score(xx,y))

#朴素贝叶斯的实现

beiyesi = GaussianNB()#定义回归模型

beiyesi.fit(xx,y)#训练模型

print("训练集：",beiyesi.score(xx,y))

#随机森林分类实现

rfc = RandomForestClassifier()#定义回归模型

rfc.fit(xx,y)#训练模型

print("训练集：",rfc.score(xx,y))

#knn分类器

classifier = KNeighborsClassifier()    # 定义模型

classifier.fit(xx,y)#训练模型

print("训练集：",classifier.score(xx,y))

# AdaBoost的实现

AB = AdaBoostClassifier()#定义模型

AB.fit(xx,y)#训练模型

print("训练集：",AB.score(xx,y))

#测试集模型测试

#逻辑斯蒂文本分类实现

logitmodel=LogisticRegression()#定义模型

logitmodel.fit(xx_test,y_test)#训练模型

#4.计算逻辑斯蒂文本分类器的准确率

print("测试集：",logitmodel.score(xx_test,y_test))

#朴素贝叶斯的实现

beiyesi = GaussianNB()#定义模型

beiyesi.fit(xx_test,y_test)#训练模型

print("测试集：",beiyesi.score(xx_test,y_test))

#随机森林分类实现

rfc = RandomForestClassifier()#定义模型

rfc.fit(xx_test,y_test)#训练模型

print("测试集：",rfc.score(xx_test,y_test

clf = SVC()  #选择SVC模型

clf.fit(xx_test,y_test)

#4.计算svc分类器的准确率

print("测试集：",clf.score(xx_test,y_test))

#knn分类器

classifier = KNeighborsClassifier()    # 定义模型

classifier.fit(xx_test,y_test)#训练模型

print("测试集：",classifier.score(xx_test,y_test))

# AdaBoost的实现

AB = AdaBoostClassifier()#定义模型

AB.fit(xx_test,y_test)#训练模型

print("测试集：",AB.score(xx_test,y_test))

#4.计算svc分类器的准确率

print("训练集：",clf.score(xx,y))

#4.计算逻辑斯蒂文本分类器的准确率

print("训练集：",logitmodel.score(xx,y))

#4.计算高斯朴素贝叶斯分类器的准确率

print("训练集：",beiyesi.score(xx,y))

#4.计算随机森林分类器的准确率

print("训练集：",rfc.score(xx,y))

#4.计算knn分类器的准确率

print("训练集：",classifier.score(xx,y))

#4.计算AdaBoost分类器准确率

print("训练集：",AB.score(xx,y))