使用低层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