NLP（自然语言处理）--新浪新闻文本分类（tensorflow+RNN）详细解释

github链接：https://github.com/gaussic/text-classification-cnn-rnn（结构化编程）

以下将以上结构化编程统一起来，并对每行代码进行了解释。

 数据集

数据集下载链接: https://pan.baidu.com/s/1oLZZF4AHT5X_bzNl2aF2aQ 提取码: 5sea
下载压缩文件cnews.zip完成后，选择解压到cnews

cnew文件夹中有4个文件：
1.训练集文件cnews.train.txt
2.测试集文件cnew.test.txt
3.验证集文件cnews.val.txt
4.词汇表文件cnews.vocab.txt
共有10个类别，65000个样本数据，其中训练集50000条，测试集10000条，验证集5000条。

代码文件需要放到和cnews文件夹同级目录。

 

代码解释

import warnings
warnings.filterwarnings('ignore')  #ignore中文叫做忽略，即不打印警告信息；

import time
startTime = time.time()   #把程序开始时间赋值给变量startTime；
def printUsedTime():   #定义printUsedTime函数，作用是打印程序运行时间
    used_time = time.time() - startTime
    print('used time: %.2f seconds' %used_time)

with open('./cnews/cnews.train.txt', encoding='utf8') as file:  #调用open方法打开文本文件
    line_list = [k.strip() for k in file.readlines()]  #使用列表推导式得到文本文件中的行内容列表赋值给变量label_list
    train_label_list = [k.split()[0] for k in line_list]  #得到训练集的标签列表赋值给变量train_label_list
    train_content_list = [k.split(maxsplit=1)[1] for k in line_list]  #得到训练集的内容列表赋值给变量train_content_list
with open('./cnews/cnews.vocab.txt', encoding='utf8') as file:  #得到词汇表文件cnews.vocab.txt中的词汇列表赋值给变量vocabulary_list
    vocabulary_list = [k.strip() for k in file.readlines()]
print('0.load train data finished')  #表示加载训练集数据完成
printUsedTime()  #打印程序运行至此步使用的时间

word2id_dict = dict([(b, a) for a, b in enumerate(vocabulary_list)])  #使用列表推导式得到词汇及其id对应的列表，并调用dict方法将列表强制转换为字典
list(word2id_dict.items())[:5]   #打印变量word2id_dict的前5项
content2idList = lambda content : [word2id_dict[word] for word in content if word in word2id_dict]   #使用列表推导式和匿名函数定义函数content2idlist，函数作用是将文章中的每个字转换为id
train_idlist_list = [content2idList(content) for content in train_content_list]  #使用列表推导式得到的结果是列表的列表，总列表train_idlist_list中的元素是每篇文章中的字对应的id列表

vocabolary_size = 5000  # 词汇表大小
sequence_length = 150  # 序列长度
embedding_size = 64  # 词向量大小
num_hidden_units = 256  # LSTM细胞隐藏层大小
num_fc1_units = 64 #第1个全连接下一层的大小
dropout_keep_probability = 0.5  # dropout保留比例
num_classes = 10  # 类别数量
learning_rate = 1e-3  # 学习率
batch_size = 64  # 每批训练大小

import tensorflow.contrib.keras as kr  #获得能够用于模型训练的特征矩阵和预测目标值
train_X = kr.preprocessing.sequence.pad_sequences(train_idlist_list, sequence_length)  #将每个样本统一长度为seq_length，即600
from sklearn.preprocessing import LabelEncoder
labelEncoder = LabelEncoder()  #实例化LabelEncoder对象
train_y = labelEncoder.fit_transform(train_label_list)  #调用LabelEncoder对象的fit_transform方法做标签编码
train_Y = kr.utils.to_categorical(train_y, num_classes)  #调用keras.untils库的to_categorical方法将标签编码的结果再做Ont-Hot编码

import tensorflow as tf
tf.reset_default_graph()  #重置tensorflow图，加强代码的健壮性
X_holder = tf.placeholder(tf.int32, [None, sequence_length])  #将每次训练的特征矩阵X和预测目标值Y赋值给变量X_holder和Y_holder
Y_holder = tf.placeholder(tf.float32, [None, num_classes])
print('1.data preparation finished')   #数据准备完成
printUsedTime()  #运行至此步使用的时间

#搭建神经网络
embedding = tf.get_variable('embedding',
                            [vocabolary_size, embedding_size])  #get_variable方法实例化可以更新的模型参数embedding，矩阵形状为vocabulary_size*embedding_size，即5000*64
embedding_inputs = tf.nn.embedding_lookup(embedding,
                                          X_holder)  #embedding_inputs的形状为batch_size*sequence_length*embedding_size，即50*100*64
gru_cell = tf.contrib.rnn.GRUCell(num_hidden_units)  #调用tf.contrib.rnn.GRUCell方法实例化GRU细胞对象
outputs, state = tf.nn.dynamic_rnn(gru_cell,
                                   embedding_inputs,
                                   dtype=tf.float32)  #动态计算循环神经网络中的结果，outputs是每个细胞的h的结果，state是最后一个细胞的h和c的结果，LSTM网络中h是短时记忆矩阵，c是长时记忆矩阵
last_cell = outputs[:, -1, :]  #获取最后一个细胞的h，即最后一个细胞的短时记忆矩阵，等价于state.h
full_connect1 = tf.layers.dense(last_cell,
                                num_fc1_units)  #添加全连接层，tf.layers.dense方法结果赋值给变量full_connect1，形状为batch_size*num_fc1_units，即50*128
full_connect1_dropout = tf.contrib.layers.dropout(full_connect1,
                                                  dropout_keep_probability)
full_connect1_activate = tf.nn.relu(full_connect1_dropout)
full_connect2 = tf.layers.dense(full_connect1_activate,
                                num_classes)
predict_Y = tf.nn.softmax(full_connect2)
cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(labels=Y_holder,
                                                          logits=full_connect2)
loss = tf.reduce_mean(cross_entropy)  #使用交叉熵作为损失函数
optimizer = tf.train.AdamOptimizer(learning_rate)
train = optimizer.minimize(loss)
isCorrect = tf.equal(tf.argmax(Y_holder,1), tf.argmax(predict_Y, 1))  #计算预测准确率
accuracy = tf.reduce_mean(tf.cast(isCorrect, tf.float32))
print('2.build model finished')  #表示搭建神经网络完成
printUsedTime()

#参数初始化
init = tf.global_variables_initializer()
session = tf.Session()
session.run(init)
print('3.initialize variable finished')
printUsedTime()

#获取文本文件cnews.test.txt，即测试集中的数据
with open('./cnews/cnews.test.txt', encoding='utf8') as file:
    line_list = [k.strip() for k in file.readlines()]
    test_label_list = [k.split()[0] for k in line_list]
    test_content_list = [k.split(maxsplit=1)[1] for k in line_list]
test_idlist_list = [content2idList(content) for content in test_content_list]
test_X = kr.preprocessing.sequence.pad_sequences(test_idlist_list, sequence_length)
test_y = labelEncoder.transform(test_label_list)
test_Y = kr.utils.to_categorical(test_y, num_classes)
print('4.load test data finished')
printUsedTime()

print('5.begin model training')
import random
for i in range(5000):
    selected_index = random.sample(list(range(len(train_y))), k=batch_size)  #从训练集中选取batch_size大小，即50个样本做批量梯度下降
    batch_X = train_X[selected_index]
    batch_Y = train_Y[selected_index]
    session.run(train, {X_holder:batch_X, Y_holder:batch_Y})  #每运行1次，表示模型训练1次
    step = i + 1  #记录当前步数，赋值给变量step
    if step % 100 == 0:
        selected_index = random.sample(list(range(len(test_y))), k=200)  #从测试集中随机选取200个样本
        batch_X = test_X[selected_index]
        batch_Y = test_Y[selected_index]
        #计算损失值loss_value、准确率accuracy_value
        loss_value, accuracy_value = session.run([loss, accuracy], {X_holder:batch_X, Y_holder:batch_Y})
        print('step:%d loss:%.4f accuracy:%.4f' %(step, loss_value, accuracy_value))
        printUsedTime()

#以上已经完成循环神经网络的训练

##词汇表
'''
本项目已提供词汇表文件cnews.vocab.txt，但在实践中需要自己统计语料的词汇表。
下面代码可以由内容列表content_list产生词汇表：

from collections import Counter

def getVocabularyList(content_list, vocabulary_size):
    allContent_str = ''.join(content_list)
    counter = Counter(allContent_str)
    vocabulary_list = [k[0] for k in counter.most_common(vocabulary_size)]
    return vocabulary_list

def makeVocabularyFile(content_list, vocabulary_size):
    vocabulary_list = getVocabularyList(content_list, vocabulary_size)
    with open('vocabulary.txt', 'w', encoding='utf8') as file:
        for vocabulary in vocabulary_list:
            file.write(vocabulary + '\n')

makeVocabularyFile(train_content_list, 5000)

本段代码产生的文件，与提供的词汇表文件cnews.vocab.txt稍有不同。
造成原因有2点：
1.词汇表文件的第1个字<PAD>是补全字，无实际含义，与kr.preprocessing.sequence.pad_sequences方法补全的0对应；
2.源代码作者使用了训练集、验证集、测试集作为总语料库，上面一段代码只使用了训练集作为语料库。
'''

##计算混淆矩阵

import numpy as np
import pandas as pd
from sklearn.metrics import confusion_matrix

def predictAll(test_X, batch_size=100):
    predict_value_list = []
    for i in range(0, len(test_X), batch_size):
        selected_X = test_X[i: i + batch_size]
        predict_value = session.run(predict_Y, {X_holder:selected_X})
        predict_value_list.extend(predict_value)
    return np.array(predict_value_list)

Y = predictAll(test_X)
y = np.argmax(Y, axis=1)
predict_label_list = labelEncoder.inverse_transform(y)
pd.DataFrame(confusion_matrix(test_label_list, predict_label_list), 
             columns=labelEncoder.classes_,
             index=labelEncoder.classes_ )

#从混淆矩阵的结果可以看出哪些分类效果较差。


##报告表

#下面一段代码能够成功运行的前提是已经运行混淆矩阵代码。

import numpy as np
from sklearn.metrics import precision_recall_fscore_support

def eval_model(y_true, y_pred, labels):
    # 计算每个分类的Precision, Recall, f1, support
    p, r, f1, s = precision_recall_fscore_support(y_true, y_pred)
    # 计算总体的平均Precision, Recall, f1, support
    tot_p = np.average(p, weights=s)
    tot_r = np.average(r, weights=s)
    tot_f1 = np.average(f1, weights=s)
    tot_s = np.sum(s)
    res1 = pd.DataFrame({
        u'Label': labels,
        u'Precision': p,
        u'Recall': r,
        u'F1': f1,
        u'Support': s
    })
    res2 = pd.DataFrame({
        u'Label': ['总体'],
        u'Precision': [tot_p],
        u'Recall': [tot_r],
        u'F1': [tot_f1],
        u'Support': [tot_s]
    })
    res2.index = [999]
    res = pd.concat([res1, res2])
    return res[['Label', 'Precision', 'Recall', 'F1', 'Support']]

eval_model(test_label_list, predict_label_list, labelEncoder.classes_)


'''
1.本项目数据共有65000条。
2.分类模型的评估指标F1score为0.89左右，总体来说这个分类模型比CNN模型效果差，而且训练时间更久；
3.本文为了节省实验时间，设置sequence_length为150，迭代5000次总共花费1123秒，即18分43秒；
4.如果设置sequence_length为300，迭代5000次总共花费时间2184秒，即36分24秒，评估指标F1score为0.9282。
'''