TensorFlow对于自然语言序列(PTB)的预测----RNN模型

PTB(Penn Treebank Dataset)文本数据集是语言模型学习中广泛使用的数据集。
一、定义各层变量

DATA_PATH   = "simple-examples/data"
HIDDEN_SIZE = 200       #隐藏层层数
NUM_LAYERS  = 2         #RNN层数
VOCAB_SIZE  = 10000     #一共10000个单词
    
LEARNNING_RATE   = 1.0  #学习率  
TRAIN_BATCH_SIZE = 20   #训练的batch  共有20个数组构成一个batch
TRAIN_NUM_STEP   = 35   #训练截断长度  一个数组35个数据

#测试时 不需要使用数据的截断 可以将测试数据看成一个超长的序列
EVAL_BATCH_SIZE  = 1    #测试数据batch的大小
EVAL_NUM_STEP    = 1    #测试数据截断长度
NUM_EPOCH        = 2    #使用训练数据的轮数
KEEP_PROB        = 0.5  #节点不被dropout的概率
MAX_GRAD_NORM    = 5    #用于控制梯度膨胀的参数

二、构建RNN模型
2.1定义传入参数

	self.batch_size = batch_size
    self.num_step   = num_steps     
    #定义输入层
    self.input_data = tf.placeholder(tf.int32,[batch_size,num_steps])        
    #定义预期输出
    self.targets    = tf.placeholder(tf.int32,[batch_size,num_steps])

2.2 定义LSTM结构的RNN模型

	#定义LSTM结构 构建RNN
    lstm_cell  = tf.nn.rnn_cell.BasicLSTMCell(HIDDEN_SIZE)
    if is_training:  #训练时dropout
        lstm_cell = tf.nn,rnn_cell.DropoutWrapper(lstm_cell,output_keep_prob = KEEP_PROB)
    #深层循环神经网络  NUM_LAYERS代表有多少层
    cell = tf.nn.rnn_cell.MultiRnnCell([lstm_cell] * NUM_LAYERS)

2.3初始化状态

	#初始化最初的状态  全零向量
    self.initial_state = cell.zero_state(batch_size,tf.float32)
    #一共VOCAB_SIZE个单词   每个单词的维度都是HIDDEN_SIZE
    embedding = tf.get_variable("embedding",[VOCAB_SIZE,HIDDEN_SIZE])
    #一个batch原本的batch_size*num_step个单词ID转化为单词向量  
    #转化后的输入层维度为 batch_size*num_step*HIDDEN_SIZE
    #根据self.input_data的数据当作标号  找到对应的行的标号  填充
    #因为self.input_data是一个batch_size*num_step的  每一个输入找到一个HIDDEN_SIZE的隐藏层  
    #共计batch_size*num_step*HIDDEN_SIZE
    #inputs为batch_size*num_step*HIDDEN_SIZE
    inputs = tf.nn.embedding_lookup(embedding,  self.input_data)

2.4 设置dropout

	if is_trainning:
       inputs = tf.nn.dropout(inputs,KEEP_PROB)

2.5定义输出列表

	#定义输出列表  将不同时刻的LSTM输出收集  最后通过一个全连接得到最终的输出
    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()
            #从输入数据中获取当前时刻的输入  并传入RNN中  调用tf.nn.rnn_cell.MultiRnnCell      
            cell_output,state = cell(inputs[:,time_step,:],state)
            #将当前输出加入输出队列  在列表末尾添加新的对象
            outputs.append(cell_output)

2.6 reshape输出

	#把输出展开为[batch,hidden_size*num_step]的形状  然后reshape[batch*num_step,hidden_size]
    output = tf.reshape(tf.concat(1,outputs),[-1,HIDDEN_SIZE])

2.7 全连接层

	weight = tf.get_variable("weight",[HIDDEN_SIZE,VOCAB_SIZE])
    bias   = tf.get_variable("bias",[VOCAB_SIZE])
    logits = tf.matmul(output,weight)+bias

2.8计算一个序列的交叉熵

	#计算一个序列的交叉熵
    loss = tf.nn.seq2seq.sequeue_loss_by_example(
        [logits],                           #预测的结果
        [tf.reshape(self.targets,[-1])],    #预期正确结果  将[batch,num_step]二维压缩为1维
        [tf.ones([batch_size*num_step],dtype=tf.float32)] #损失的权重 都为1  代表所有的权重相同
    )
    #计算每个batch的平均损失
    self.cost = tf.reduce_mean(loss)/batch_size
    self.final_state = state

2.9 控制梯度膨胀

	trainable_variables = tf.trainable_variables()
    grads,_ = tf.clip_by_global_norm(tf.gradients(self.cost,trainable_variables),MAX_GRAD_NORM)

2.10 定义优化算法

	#定义优化方法
    optimizer = tf.train.GradientDescentOptimizer(LEARNNING_RATE)
    #定义训练步骤
    self.train_op = optimizer.apply_gradients(zip(grads,trainable_variables))

三、运行LSTM模型

	for step,(x,y) in enumerate(reader.ptb_iterator(data, model.batch_size, model.num_steps)):
    #在当前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):
        printf("after %d steps ,perplexity is %.3f" % (step,np.exp(total_costs/iters)))
 
 #返回给定模型在给定数据上的  perplexity     
return np.exp(total_costs/iters)

四、主函数
4.1 获取数据

	#获取原始数据
    train_data,valid_data,test_data ,_ = reader.ptb_raw_data(DATA_PATH)        
    #定义初始化函数
    initializer = tf.random_uniform_initializer(-0.05,0.05)

4.2 构建训练模型

	with tf.variable_scope("language model",reuse = None ,initializer = initializer ):
        train_model = PTBModel(True,TRAIN_BATCH_SIZE,TRAIN_NUM_STEP)

4.3 构建测试模型

	with tf.variable_scope("language model",reuse = None ,initializer = initializer ):
        eval_model  = PTBModel(False,EVAL_BATCH_SIZE,EVAL_NUM_STEP)

4.4 session初始化

	with tf.Session() as session:
        tf.initialize_all_variables().run()

4.5 训练&&测试

	with tf.Session() as session:
       tf.initialize_all_variables().run()
       
       for i in range(NUM_EPOCH):
           print("in iteration %d"%(i+1))
           
           #在所有训练数据上训练循环神经网络模型
           run_epoch(session,train_model,train_data,train_model.train_op,True)
           
           #使用验证数据评测模型效果
           valid_perplexity = run_epoch(session,eval_model,eval_data,tf.no_op,False)
           print("epoch %d   ,valid perplexity is %.3f" %(i+1,valid_perplexity))
           
       test_perplexity = run_epoch(session,eval_model,test_data,tf.no_op,False)
       print("epoch %d   ,test perplexity is %.3f" %(i+1,test_perplexity))

最近新开的公众号，文章正在一篇篇的更新，

公众号名称：玩转电子世界

各位朋友有什么问题了可以直接在上面提问，我会一一进行解答的。

跟着阳光非宅男，一步步走进电子的世界。

关注之后回复 资料下载 关键词可以获得免费的视频学习资料下载~~~~！！

已共享的学习视频资料，共享资料正在不断更新中。

共享机器学习/tensorflow视频学习资料：