tensorflow RNN搭建

使用低层api，即自己组建计算图，再进行计算，这样也便于计算自定义的准确率。
导入包

import tensorflow as tf
import pandas as pd
import numpy as np
import os
import pickle
pd.set_option('display.max_rows', 300)
pd.set_option('display.max_columns', 300)

（数据处理部分略过了，不同的问题数据不同）
设定超参数

learning_rate = 0.1
state_size = 128 # hidden layer num of features
n_classes = 19
n_features = 23

输入，我的数据是会动态调整batch_size和time_step，所以这里将前两维都设成None，后面run的时候可以用feed_dict自适应填充，第三维是特征维度，一般是确定的，要是不确定的也可以设成None

x = tf.placeholder(tf.float32, [None, None, n_features], name='input_placeholder')  #batch_size, time_step, feat_len
y = tf.placeholder(tf.float32, [None, None, n_classes], name='labels_placeholder')  #batch_size, time_step, n_classes

batch_size = tf.placeholder(tf.int32, (), name='batch_size')
time_steps = tf.placeholder(tf.int32, (), name='times_step')

定义RNN单元，这里用的是LSTM

rnn_cell = tf.contrib.rnn.BasicLSTMCell(state_size)
init_state = rnn_cell.zero_state(batch_size, dtype=tf.float32)  #状态初始化为0

定义输出层的weights和bias，rnn_cell输出的是它的状态，hidden_size和n_classes是不同的，得到分类结果最简单的就是加上一层输出层 再加 softmax处理。

weights = tf.get_variable("weights", [state_size, n_classes], dtype=tf.float32,
                         initializer = tf.random_normal_initializer(mean=0, stddev=1))
biases = tf.get_variable("biases", [n_classes], dtype=tf.float32, 
                        initializer = tf.random_normal_initializer(mean=0, stddev=1))

执行rnn_cell，得到相应的输出，outputs是[batch_size, max_time, state_size], 包含每次时间步的输出，可以设置一个参数time_major=True就是[max_time, batch_size, state_size]，当然这个时候输入x的shape也需要变化了。
这里也可以换成tf.nn.static_run，dynamic_run的好处是可以使用一个sequence_len的变量，表示batch中每个sample序列长度，免去了输入长度固定时，还需要补零，输出去零。这里我的输入都是等长的，所以不需要设置这个变量。

outputs, final_state = tf.nn.dynamic_rnn(cell=rnn_cell, 
                                         inputs=x,
                                        initial_state=init_state,
                                        dtype=tf.float32)
#outputs是[batch_size, max_time, state_size], 包含每次时间步的输出
#final_state是最后一次的状态[batch_size, state_size]

计算n_classes的原始值，需要注意的是tf.matmul只能对二维矩阵进行乘法，所以要先转换shape为二维

#计算rnn输出的状态值，先reshape成2维以便可以和W，b进行运算
#再reshape回来，变成batch_size * time_step * n_classes
state_out = tf.matmul(tf.reshape(outputs, [-1, state_size]), weights) + biases
logits = tf.reshape(state_out, [batch_size, time_steps, n_classes])

Softmax

#进行softmax计算
probs = tf.nn.softmax(logits, -1)   #-1也是默认值，表示在最后一维进行运算
predict = tf.argmax(probs, -1)  #最大的概率在最后一维的哪一列，从0计数，
                                #维度变为  batch_size * time_step

这里先得到真实labal，再计算交叉熵

true_val = tf.argmax(y, -1)   #真实结果，维度为 batch_size * time_step
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
            logits=logits, labels=y))  #计算交叉熵

定义优化器最小化loss，即关键的训练步骤，这里是对rnn_cell中的参数和输出层的参数进行优化，采用梯度下降

optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)  #优化方法
train_op = optimizer.minimize(loss_op)

然后就是进行训练和预测了，值得一提的是可以通过feed_dict可以对所有Tensor及其子类型进行赋值

def train_network(num_epochs = 30):
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())  #初始化variable
        
        acc_record = pd.DataFrame(columns=['n_epoch', 'train_loss'])  #记录Loss变化

        for epoch in range(num_epochs):
            #开始训练
            for idx, (time_step, inputs, labels) in enumerate(get_dump_seq_data()):  #得到开始整理好的数据
                _= sess.run(train_op,    #只计算train_op，在计算train_op之前会先执行其他前置运算
                           feed_dict = {x: inputs,  #这里placeholder进行填充
                                       y:labels,
                                       batch_size:len(inputs),
                                       time_steps: time_step})
                
            #这一轮训练完毕，计算训练集损失值和准确率
            total_loss = 0
            total_input = 0

            for idx, (time_step, inputs, labels) in enumerate(get_dump_seq_data()):
                #这里的run只是计算了损失和预测的值，没有train_op，所以不会改变参数的值
                loss, pred, label= sess.run([loss_op, predict, true_val],
                                                        feed_dict = {x: inputs,
                                                            y:labels,
                                                            batch_size:len(inputs),
                                                            time_steps: time_step})
                #损失
                sample_cnt = len(inputs) * time_step
                total_loss += loss * sample_cnt
                total_input += sample_cnt
            
            acc_record.loc[epoch] = [epoch, total_loss / total_input].copy()
        return acc_record