首页手记利用LSTM算法处理PTB文本数据集(1)

利用LSTM算法处理PTB文本数据集(1)

标签：

深度学习自然语言处理

数据集下载地址：
http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz
下载到的文件目录结构：

我们需要ptb.test.txt , ptb.train.txt,ptb.valid.txt作为算法建模用的测试集，训练集和验证集。

查看一下数据文件：

一.PTB数据集的预处理
这三个数据文件中的数据已经过预处理，相邻单词之间用空格隔开。数据集共包含了9998个不同的单词词汇，加上稀有词语的特殊符号(比如<unk>)和语句结束标记符(比如<eos>)在内，一共是10000个词汇。
为了将文本转化为模型可以读入的单词序列，需要将这10000个不同的词汇分别映射到0~9999之间的整数编号。下面的辅助程序首先按照词频顺序为每个词汇分配一个编号，然后将词汇表保存到一个独立的vocab文件中

代码：

import os 
import sys 
import datetime 
import collections 

import numpy as np  
import tensorflow as tf  
from operator import itemgetter 


#训练集数据文件
raw_data = "D:/Demo2/LSTM/Data/simple-examples/data/ptb.train.txt" 
#输出的词汇表文件
vocab_output = 'ptb.vocab' 

#统计单词出现的频率
counter = collections.Counter()
with open(raw_data,'r',encoding = 'utf-8') as f:
	for line in f:
		for word in line.strip().split():
			counter[word] += 1  

#按词频顺序对单词进行排序
sorted_word_to_cnt = sorted(counter.items(),key = itemgetter(1),reverse = True)
sorted_words       = [x[0] for x in sorted_word_to_cnt] 
# 需要在文本换行处加入句子结束符'<eos>' 
# 因此，需要将'<eos>'也添加到字典
#关于itemgetter的讲解： 
#https://www.cnblogs.com/zhoufankui/p/6274172.html
sorted_words = ['<eos>'] + sorted_words
# 在PTB中，输入数据已经将低频词汇替换成了 '<unk>',因此不需要这一步骤
# sorted_words = ['<unk>', '<sos>', '<eos>'] + sorted_words
# if len(sorted_words) > 10000:
#     sorted_words = sorted_words[:10000] 

with open(vocab_output,'w',encoding = 'utf-8') as file_output:
	for word in sorted_words:
		file_output.write(word + '\n')

print(sorted_words[0:10])

出现频率最高的前10个词汇：

在确定了词汇表之后，再将训练文件、测试文件等根据词汇文件转化为单词编号。每个单词的编号就是它在词汇文件中的行号。

import os 
import sys 
import datetime 
import collections 

import numpy as np  
import tensorflow as tf  
from operator import itemgetter 



train_data = "D:/Demo2/LSTM/Data/simple-examples/data/ptb.train.txt" 
test_data = "D:/Demo2/LSTM/Data/simple-examples/data/ptb.test.txt" 
valid_data = "D:/Demo2/LSTM/Data/simple-examples/data/ptb.valid.txt" 


#输出的词汇表文件
vocab_output = 'ptb.vocab'
#将单词替换为单词编号后的输出文件
output_train_data = './ptb.train'  
output_test_data = './ptb.test'  
output_valid_data = './ptb.valid'  

#读取词汇表，并生成单词到单词编号的映射
with open(vocab_output,'r',encoding = 'utf-8') as f_vocab:
	vocab = [w.strip() for w in f_vocab.readlines()]
#生成'单词:编号'字典
word_to_id = {k:v for (k,v) in zip(vocab,range(len(vocab)))}

#如果新的单词不在字典vocab中，没有对应的id，则替换为'<unk>'的id
def get_id(word):
	return word_to_id[word] if word in word_to_id else word_to_id['<unk>']  



fin1 = open(train_data,'r',encoding = 'utf-8')
fout1 = open(output_train_data,'w',encoding = 'utf-8')
for line in fin1:
	#读取单词并添加<eos>结束符
	words = line.strip().split() + ['<eos>']
	#将每个单词替换为词汇表中的编号
	out_line = ' '.join([str(get_id(w)) for w in words])  + '\n'
	fout1.write(out_line) 
fin1.close()
fout1.close()

fin2 = open(test_data,'r',encoding = 'utf-8')
fout2 = open(output_test_data,'w',encoding = 'utf-8')
for line in fin2:
	#读取单词并添加<eos>结束符
	words = line.strip().split() + ['<eos>']
	#将每个单词替换为词汇表中的编号
	out_line = ' '.join([str(get_id(w)) for w in words])  + '\n'
	fout2.write(out_line) 
fin2.close()
fout2.close()

fin3 = open(valid_data,'r',encoding = 'utf-8')
fout3 = open(output_valid_data,'w',encoding = 'utf-8')
for line in fin3:
	#读取单词并添加<eos>结束符
	words = line.strip().split() + ['<eos>']
	#将每个单词替换为词汇表中的编号
	out_line = ' '.join([str(get_id(w)) for w in words])  + '\n'
	fout3.write(out_line) 
fin3.close()
fout3.close()

转换结果：

二，PTB数据的Batch操作

在文本数据中，由于每个句子的长度不同，又无法像图像一样调整到固定维度，因此在对文本数据进行batching时需要采取一些特殊操作。最常见的办法时使用填充（padding）将同一batch内的句子长度补齐。在PTB数据集中，每个句子并非随机抽取的文本，而是在上下文之间有关联的内容。语言模型为了利用上下文信息，必须将前面句子的信息传递到后面的句子。为了实现这个目标，在PTB上下文有关联的数据集上，通常采用另一种batching方法。将长序列切割为固定长度的子序列。循环神经网络在处理完一个子序列后，它最终的隐藏状态将复制到下一个序列中作为初始值，这样在前向计算时，效果等同于一次性顺序地读取了整个文档；而在反向传播时，梯度则只在每个子序列内部传播。

import numpy as np  
import tensorflow as tf

#加载数据
TRAIN_DATA = './ptb.train'
EVAL_DATA  = './ptb.valid'
TEST_DATA  = './ptb.test' 

TRAIN_BATCH_SIZE = 20 
TRAIN_NUM_STEP   = 35 

#从文件中读取数据，并返回包含单词编号的数组
def read_data(file_path):
	with open(file_path,'r') as fin:
		#将整个文档读进一个长字符串
		id_string = ' '.join([line.strip() for line in fin.readlines()])
	id_list = [int(w) for w in id_string.split()] #将读取的单词编号转为整数
	return id_list

def make_batch(id_list, batch_size, num_step):
    # 计算总的batch数量，每个batch包含的单词数量是batch_size * num_step
    num_batches = (len(id_list) - 1) // (batch_size * num_step)
    # 将数据整理成一个维度为[batch_size, num_batches * num_step]的二维数组
    data = np.array(id_list[: num_batches * batch_size * num_step])
    data = np.reshape(data, [batch_size, num_batches * num_step])
    # 沿着第二个维度将数据切分成num_batches个batch,存入一个数组
    data_batches = np.split(data, num_batches, axis=1)

    # 重复上述操作，但是每个位置向右移动一位，这里得到的是RNN每一步输出所需要预测的下一个单词
    label = np.array(id_list[1: num_batches * batch_size * num_step + 1])
    label = np.reshape(label, [batch_size, num_batches * num_step])
    label_batches = np.split(label, num_batches, axis=1)
    # 返回一个长度为num_batches的数组，其中每一项包含一个data矩阵和一个label矩阵
    return list(zip(data_batches, label_batches))

三，神经网络语言模型搭建
词向量层：
在输入层，每一个单词用一个实数向量表示，这个向量被称为“词向量”（word embedding）。词向量可以形象地理解为将词汇表嵌入到一个固定维度的实数空间里。将单词编号转化为词向量主要有两大作用。
1.降低输入的维度。
如果不适用词向量层，而直接将单词以one-hot vector的形式输入循环神经网络，那么输入的维度大小将与词汇表大小相同，通常在10000以上。而词向量的维度通常在200~1000之间，这将大大减少循环神经网络的参数数量与计算量。
2.增加语义信息。
简单的单词编号是不包含任何语义信息的。两个单词之间编号相近，并不意味着它们的含义有任何关联。而词向量将稀疏的编号转化为稠密的向量表示，这使得词向量有可能包含更为丰富的信息。
假设词向量的维度是EMB_SIZE，词汇表的大小为VOCAB_SIZE，那么所有单词的词向量可以放入一个大小为VOCAB_SIZE * EMB_SIZE的矩阵内。在读取词向量时，可以使用 tf.nn.embedding_lookup方法：

embedding = tf.get_variable("embedding", [VOCAB_SIZE, EMB_SIZE])
# 输出的矩阵比输入数据多一个维度, 新增维度的大小是EMB_SIZE. 在语言模型中, 一般input_data的维度是
# batch_size x num_steps, 而输出的input_embedding的维度时batch_size x num_steps x EMB_SIZE
input_embedding = tf.nn.embedding_lookup(embedding, input_data)

完整的训练程序：

import numpy as np
import tensorflow as tf

TRAIN_DATA = './data/ptb.train'     # 训练数据路径
EVAL_DATA = './data/ptb.valid'      # 验证数据路径
TEST_DATA = './data/ptb.test'       # 测试数据路径
HIDDEN_SIZE = 300                   # 隐藏层规模
NUM_LAYERS = 2                      # 深层循环神经网络中LSTM结构的层数
VOCAB_SIZE = 10000                  # 词典规模
TRAIN_BATCH_SIZE = 20               # 训练数据batch的大小
TRAIN_NUM_STEP = 35                 # 训练数据截断长度

EVAL_BATCH_SIZE = 1                 # 测试数据batch的大小
EVAL_NUM_STEP = 1                   # 测试数据截断长度
NUM_EPOCH = 5                       # 使用训练数据的轮数
LSTM_KEEP_PROB = 0.9                # LSTM节点不被dropout的概率
EMBEDDING_KEEP_PROB = 0.9           # 词向量不被dropout的概率
MAX_GRAD_NORM = 5                   # 用于控制梯度膨胀的梯度大小上限
SHARE_EMB_AND_SOFTMAX = True        # 在softmax层和词向量层之间共享参数

# 通过一个PTBModel来描述模型，这样方便维护循环神经网络中的状态
class PTBModel(object):
    def __init__(self, is_training, batch_size, num_steps):
        # 记录使用的batch大小和截断长度
        self.batch_size = batch_size
        self.num_steps = num_steps

        # 定义每一步的输出和预期输出，两个的维度都是[batch_size, num_steps]
        self.input_data = tf.placeholder(tf.int32, [batch_size, num_steps])
        self.targets = tf.placeholder(tf.int32, [batch_size, num_steps])

        # 定义使用LSTM结构为循环结构且使用dropout的深层循环神经网络
        dropout_keep_prob = LSTM_KEEP_PROB if is_training else 1.0
        lstm_cells = [
            tf.nn.rnn_cell.DropoutWrapper(
                tf.nn.rnn_cell.LSTMCell(HIDDEN_SIZE),
                output_keep_prob=dropout_keep_prob
            ) for _ in range(NUM_LAYERS)
        ]
        cell = tf.nn.rnn_cell.MultiRNNCell(lstm_cells)
        # 通过zero_state函数获取初始状态
        self.initial_state = cell.zero_state(batch_size, tf.float32)
        # 初始化最初的状态，即全零的向量。这个量只在每个epoch初始化第一个batch时使用
        embedding = tf.get_variable('embedding', [VOCAB_SIZE, HIDDEN_SIZE])
        # 将输入单词转换为词向量
        inputs = tf.nn.embedding_lookup(embedding, self.input_data)
        # 只在训练时使用dropout
        if is_training:
            inputs = tf.nn.dropout(inputs, EMBEDDING_KEEP_PROB)
        # 定义输出列表。在这里先将不同时刻LSTM结构的输出收集起来，再一起提供给softmax层
        outputs = []
        state = self.initial_state
        with tf.variable_scope('RNN'):
            for time_step in range(num_steps):
                if time_step > 0: tf.get_variable_scope().reuse_variables()
                cell_output, state = cell(inputs[:, time_step, :], state)
                outputs.append(cell_output)
        # 把输出队列展开成[batch, hidden_size * num_steps]的形状，
        # 然后再reshape成[batch*num_steps, hidden_size]的形状
        output = tf.reshape(tf.concat(outputs, 1), [-1, HIDDEN_SIZE])

        # softmax层：将RNN在每个位置上的输出转化为各个单词的logits
        if SHARE_EMB_AND_SOFTMAX:
            weight = tf.transpose(embedding)
        else:
            weight = tf.get_variable('weight', [HIDDEN_SIZE, VOCAB_SIZE])
        bias = tf.get_variable('bias', [VOCAB_SIZE])
        logits = tf.matmul(output, weight) + bias

        # 定义交叉熵损失函数和平均损失
        loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
            labels=tf.reshape(self.targets, [-1]),
            logits=logits
        )
        self.cost = tf.reduce_sum(loss) / batch_size
        self.final_state = state

        # 只在训练模型时定义反向传播操作
        if not is_training: return

        trainable_variables = tf.trainable_variables()
        # 控制梯度大小，定义优化方法和训练步骤
        grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, trainable_variables), MAX_GRAD_NORM)
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=1.0)
        self.train_op = optimizer.apply_gradients(zip(grads, trainable_variables))

# 使用给定的模型model在数据data上运行train_op并返回再全部数据上的perplexity值
def run_epoch(session, model, batches, train_op, output_log, step):
    # 计算平均perplexity的辅助变量
    total_costs = 0.0
    iters = 0
    state = session.run(model.initial_state)
    # 训练一个epoch
    for x, y in batches:
        # 在当前batch上运行train_op并计算损失值，交叉熵损失函数计算的就是下一个单词为给定单词的概率
        cost, state, _ = session.run(
            [model.cost, model.final_state, train_op],
            {model.input_data: x, model.targets: y, model.initial_state: state}
        )
        total_costs += cost
        iters += model.num_steps

        # 只有在训练时输出日志
        if output_log and step % 100 == 0:
            print('After %d steps, perplexity is %.3f' % (step, np.exp(total_costs / iters)))
        step += 1
    # 返回给定模型在给定数据上的perplexity值
    return step, np.exp(total_costs / iters)

# 从文件中读取数据，并返回包含单词编号的数组
def read_data(file_path):
    ... # 见预处理代码

def make_batch(id_list, batch_size, num_step):
    ... # 见预处理代码

def main():
    # 定义初始化函数
    initializer = tf.random_uniform_initializer(-0.05, 0.05)
    # 定义训练用的循环神经网络模型
    with tf.variable_scope('language_model', reuse=None, initializer=initializer):
        train_model = PTBModel(True, TRAIN_BATCH_SIZE, TRAIN_NUM_STEP)
    # 定义测试用的循环神经网络模型。它与train_model公用参数，但是没有dropout
    with tf.variable_scope('language_model', reuse=True, initializer=initializer):
        eval_model = PTBModel(False, EVAL_BATCH_SIZE, EVAL_NUM_STEP)
    # 训练模型
    with tf.Session() as sess:
        tf.global_variables_initializer().run()
        train_batches = make_batch(read_data(TRAIN_DATA), TRAIN_BATCH_SIZE, TRAIN_NUM_STEP)
        eval_batches = make_batch(read_data(EVAL_DATA), EVAL_BATCH_SIZE, EVAL_NUM_STEP)
        test_batches = make_batch(read_data(TEST_DATA), EVAL_BATCH_SIZE, EVAL_NUM_STEP)

        step = 0
        for i in range(NUM_EPOCH):
            print('In iteration: %d' % (i + 1))
            step, train_pplx = run_epoch(sess, train_model, train_batches, train_model.train_op, True, step)
            print('Epoch: %d Train Perplexity: %.3f' % (i + 1, train_pplx))
            _, eval_pplx = run_epoch(sess, eval_model, eval_batches, tf.no_op(), False, 0)
            print('Epoch: %d Eval Perplexity: %.3f' % (i + 1, eval_pplx))
        _, test_pplx = run_epoch(sess, eval_model, test_batches, tf.no_op(), False, 0)
        print('Test Perplexity: %.3f' % test_pplx)


if __name__ == '__main__':
    main()

参考教程：
https://www.cnblogs.com/zhoufankui/p/6274172.html
https://blog.csdn.net/m0_38007695/article/details/84648131
https://coding.imooc.com/learn/list/176.html

点击查看更多内容