#####好好好＃＃＃＃＃ 双端 LSTM 实现序列标注（分词）

import tensorflow as tf
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
from tensorflow.contrib import rnn
import numpy as np'''
For Chinese word segmentation.
'''
# ##################### config ######################
decay = 0.85
max_epoch = 5
max_max_epoch = 10
timestep_size = max_len = 32           # 句子长度
vocab_size = 5159    # 样本中不同字的个数，根据处理数据的时候得到
input_size = embedding_size = 64       # 字向量长度
class_num = 5
hidden_size = 128    # 隐含层节点数
layer_num = 2        # bi-lstm 层数
max_grad_norm = 5.0  # 最大梯度（超过此值的梯度将被裁剪）lr = tf.placeholder(tf.float32)
keep_prob = tf.placeholder(tf.float32)
batch_size = tf.placeholder(tf.int32)  # 注意类型必须为 tf.int32
model_save_path = 'ckpt/bi-lstm.ckpt'  # 模型保存位置def weight_variable(shape):"""Create a weight variable with appropriate initialization."""initial = tf.truncated_normal(shape, stddev=0.1)return tf.Variable(initial)def bias_variable(shape):"""Create a bias variable with appropriate initialization."""initial = tf.constant(0.1, shape=shape)return tf.Variable(initial)X_inputs = tf.placeholder(tf.int32, [None, timestep_size], name='X_input')
y_inputs = tf.placeholder(tf.int32, [None, timestep_size], name='y_input')    

如果你看过我上一篇文章 TensorFlow入门（五）多层 LSTM 通俗易懂版 的话，应该已经知道 LSTM 是怎么实现的了（如果不懂的话请先把上篇文章看懂再继续往下看了）。

下面重点终于来啦!!!
在这里，为了那些不懂 embedding 的朋友能够看懂下面的代码，我必须啰嗦几句说明一下什么是 word embedding。这是自然语言处理的一个大杀器，我们平时口口声声说的词向量就是这东西。在这个例子中我们指的是字向量，原理完全是一样的。刚才我们已经说过，每个 timestep 输入的是一个字对应的 id, 也就是一个整数。经过 embedding 操作之后，就变成了一个长度为 embedding_size（我们可以自己指定字向量的长度） 的实数向量。具体它是怎么做的呢？如果你是做自然语言处理的应该已经知道了，如果你不是做自然语言处理的呢，那就不用管了。反正，真正输入到 LSTMCell 中的数据 shape 长这样 [ batchsize, timestep_size, input_size ]。 input_size 是每个 timestep 输入样本的特征维度，如上个例子中就是MNIST字符每行的28个点，那么就应该 input_size=28。把你要处理的数据整理成这样的 shape 就可以了，管它什么 embedding。

def bi_lstm(X_inputs):"""build the bi-LSTMs network. Return the y_pred"""# ** 0.char embedding，请自行理解 embedding 的原理！！做 NLP 的朋友必须理解这个embedding = tf.get_variable("embedding", [vocab_size, embedding_size], dtype=tf.float32)# X_inputs.shape = [batchsize, timestep_size]  ->  inputs.shape = [batchsize, timestep_size, embedding_size]inputs = tf.nn.embedding_lookup(embedding, X_inputs)  # ** 1.LSTM 层lstm_fw_cell = rnn.BasicLSTMCell(hidden_size, forget_bias=1.0, state_is_tuple=True)lstm_bw_cell = rnn.BasicLSTMCell(hidden_size, forget_bias=1.0, state_is_tuple=True)# ** 2.dropoutlstm_fw_cell = rnn.DropoutWrapper(cell=lstm_fw_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)lstm_bw_cell = rnn.DropoutWrapper(cell=lstm_bw_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)# ** 3.多层 LSTMcell_fw = rnn.MultiRNNCell([lstm_fw_cell]*layer_num, state_is_tuple=True)cell_bw = rnn.MultiRNNCell([lstm_bw_cell]*layer_num, state_is_tuple=True)# ** 4.初始状态initial_state_fw = cell_fw.zero_state(batch_size, tf.float32)initial_state_bw = cell_bw.zero_state(batch_size, tf.float32)  # 下面两部分是等价的# **************************************************************# ** 把 inputs 处理成 rnn.static_bidirectional_rnn 的要求形式# ** 文档说明# inputs: A length T list of inputs, each a tensor of shape# [batch_size, input_size], or a nested tuple of such elements.# *************************************************************# Unstack to get a list of 'n_steps' tensors of shape (batch_size, n_input)# inputs.shape = [batchsize, timestep_size, embedding_size]  ->  timestep_size tensor, each_tensor.shape = [batchsize, embedding_size]# inputs = tf.unstack(inputs, timestep_size, 1)# ** 5.bi-lstm 计算（tf封装）  一般采用下面 static_bidirectional_rnn 函数调用。#   但是为了理解计算的细节，所以把后面的这段代码进行展开自己实现了一遍。
#     try:
#         outputs, _, _ = rnn.static_bidirectional_rnn(cell_fw, cell_bw, inputs, 
#                         initial_state_fw = initial_state_fw, initial_state_bw = initial_state_bw, dtype=tf.float32)
#     except Exception: # Old TensorFlow version only returns outputs not states
#         outputs = rnn.static_bidirectional_rnn(cell_fw, cell_bw, inputs, 
#                         initial_state_fw = initial_state_fw, initial_state_bw = initial_state_bw, dtype=tf.float32)
#     output = tf.reshape(tf.concat(outputs, 1), [-1, hidden_size * 2])# ***********************************************************# ***********************************************************# ** 5. bi-lstm 计算（展开）with tf.variable_scope('bidirectional_rnn'):# *** 下面，两个网络是分别计算 output 和 state # Forward directionoutputs_fw = list()state_fw = initial_state_fwwith tf.variable_scope('fw'):for timestep in range(timestep_size):if timestep > 0:tf.get_variable_scope().reuse_variables()(output_fw, state_fw) = cell_fw(inputs[:, timestep, :], state_fw)outputs_fw.append(output_fw)# backward directionoutputs_bw = list()state_bw = initial_state_bwwith tf.variable_scope('bw') as bw_scope:inputs = tf.reverse(inputs, [1])for timestep in range(timestep_size):if timestep > 0:tf.get_variable_scope().reuse_variables()(output_bw, state_bw) = cell_bw(inputs[:, timestep, :], state_bw)outputs_bw.append(output_bw)# *** 然后把 output_bw 在 timestep 维度进行翻转# outputs_bw.shape = [timestep_size, batch_size, hidden_size]outputs_bw = tf.reverse(outputs_bw, [0])# 把两个oupputs 拼成 [timestep_size, batch_size, hidden_size*2]output = tf.concat([outputs_fw, outputs_bw], 2)  # output.shape 必须和 y_input.shape=[batch_size,timestep_size] 对齐output = tf.transpose(output, perm=[1,0,2])output = tf.reshape(output, [-1, hidden_size*2])# ***********************************************************softmax_w = weight_variable([hidden_size * 2, class_num]) softmax_b = bias_variable([class_num]) logits = tf.matmul(output, softmax_w) + softmax_breturn logitsy_pred = bi_lstm(X_inputs)
# adding extra statistics to monitor
# y_inputs.shape = [batch_size, timestep_size]
correct_prediction = tf.equal(tf.cast(tf.argmax(y_pred, 1), tf.int32), tf.reshape(y_inputs, [-1]))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
cost = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels = tf.reshape(y_inputs, [-1]), logits = y_pred))# ***** 优化求解 *******
# 获取模型的所有参数
tvars = tf.trainable_variables()
# 获取损失函数对于每个参数的梯度
grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars), max_grad_norm)
# 优化器
optimizer = tf.train.AdamOptimizer(learning_rate=lr)
# 梯度下降计算
train_op = optimizer.apply_gradients( zip(grads, tvars),global_step=tf.contrib.framework.get_or_create_global_step())
print 'Finished creating the bi-lstm model.'

过多的解释也没有了，都在上面的代码中！但还是得说一声，在这个双端 LSTM 模型中，重点要理解两点：

1. 两个 LSTM （cell_fw, cell_bw）的计算是各自独立的，只是最后输出的时候把二者的状态向量结合起来。
2. 本例中每个 timestep 都有结果输出，而上篇的分类问题中我们只拿最后一个 h_state 来计算最后的输出（注意这不是 Bi-LSTM 和 单向 LSTM 的区别， 单向的也可以每个 timestep 都输出）。注意本例中的 y_input 也对应的每个 timestep 对应一个 tag(id)。