2019-01-21 Seq2Seq模型涉及的函数

tf.contrib.layers.embed_sequence
该函数的原型是：

embed_sequence(
    ids,
    vocab_size=None,
    embed_dim=None,
    unique=False,
    initializer=None,
    regularizer=None,
    trainable=True,
    scope=None,
    reuse=None
)

该函数将输入的ids，转换成embeddings，输入的id是整型的维数为[batch_size, doc_length] 的张量，返回维数为[batch_size, doc_length, embed_dim]的张量。

tf.strided_slice
该函数的原型是：

strided_slice(
    input_,
    begin,
    end,
    strides=None,
    begin_mask=0,
    end_mask=0,
    ellipsis_mask=0,
    new_axis_mask=0,
    shrink_axis_mask=0,
    var=None,
    name=None
)

有四个参数，input，begin，end和strides。begin和input以及strides和input的维数要一致。begin，end和strides决定了input的每一维要如何剪切。这里end是闭区间。

data = [[[1, 1, 1], [2, 2, 2]],
            [[3, 3, 3], [4, 4, 4]],
            [[5, 5, 5], [6, 6, 6]]]
x = tf.strided_slice(data,[0,0,0],[1,1,1])
y = tf.strided_slice(data,[0,0,0],[2,2,2],[1,1,1])
z = tf.strided_slice(data,[0,0,0],[2,2,2],[1,2,1])
with tf.Session() as sess:
    print(sess.run(x))
    print(sess.run(y))
    print(sess.run(z))

输出为：
x[[[1]]]
y[[[1 1][2 2]]
[[3 3][4 4]]]
z[[[1 1]]
[[3 3]]]

x的输出为[[[1]]]，因为在每一维我们只截取[0,1)，因此只保留了[0,0,0]这里的元素，即1。y在每一位截取[0,2)，且步长为1，因此剩了8个元素。而z在第二维的步长是2，因此保留[0,0,0],[1,0,0],[1,0,1],[0,0,1]四个元素。

tf.nn.embedding_lookup
该函数的原型是：

embedding_lookup(
    params,
    ids,
    partition_strategy='mod',
    name=None,
    validate_indices=True,
    max_norm=None
)

tf.nn.embedding_lookup函数的用法主要是选取一个张量里面索引对应的元素。tf.nn.embedding_lookup（params, id）:params就是输入张量，id就是张量对应的索引，其他的参数不介绍。看个例子吧：

c = np.random.random([10, 1])
b = tf.nn.embedding_lookup(c, [1, 3])
with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    print(sess.run(b))
    print(c)

输出为：
[[ 0.94285588]
[ 0.75749925]]
[[ 0.69653103]
[ 0.94285588]
[ 0.23237639]
[ 0.75749925]
[ 0.53966384]
[ 0.05784376]
[ 0.80573055]
[ 0.90221424]
[ 0.34374387]
[ 0.51868458]]

可以看到，embedding_lookup选择了c中的索引为1和3的元素返回。

tensorflow.ayers.Dense
Dense是一个构建全链接层的类，如下面的例子：

output_layer = Dense(target_vocab_size,kernel_initializer=tf.truncated_normal_initializer(mean=0.1,stddev=0.1))

target_vocab_size定义了神经元的个数。

tf.contrib.seq2seq.TrainingHelper
这是用于seq2seq中帮助建立Decoder的一个类，只能在训练时使用，示例代码如下：

helper = tf.contrib.seq2seq.TrainingHelper(
    input=input_vectors,
    sequence_length=input_lengths)

tf.contrib.seq2seq.GreedyEmbeddingHelper
这是用于seq2seq中帮助建立Decoder的一个类，在预测时使用，示例代码如下：

helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(
      embedding=embedding,
      start_tokens=tf.tile([GO_SYMBOL], [batch_size]),
      end_token=END_SYMBOL)

start_tokens是预测时每个输入的开头的一个标志。

tf.contrib.seq2seq.BasicDecoder
用于构造一个decoder，示例代码如下

decoder = tf.contrib.seq2seq.BasicDecoder(
    cell=cell,
    helper=helper,
    initial_state=cell.zero_state(batch_size, tf.float32))

tf.contrib.seq2seq.dynamic_decode
用于构造一个动态的decoder，返回的内容是：

(final_outputs, final_state, final_sequence_lengths).

其中，final_outputs是一个namedtuple，里面包含两项(rnn_outputs, sample_id)
rnn_output: [batch_size, decoder_targets_length, vocab_size]，保存decode每个时刻每个单词的概率，可以用来计算loss
sample_id: [batch_size], tf.int32，保存最终的编码结果。可以表示最后的答案

示例代码如下

outputs, _ = tf.contrib.seq2seq.dynamic_decode(
   decoder=decoder,
   output_time_major=False,
   impute_finished=True,
   maximum_iterations=20)

上面的5-8结合使用，可以构造一个完整的Decoder：

cell = # instance of RNNCellif mode == "train":
  helper = tf.contrib.seq2seq.TrainingHelper(
    input=input_vectors,
    sequence_length=input_lengths)elif mode == "infer":
  helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(
      embedding=embedding,
      start_tokens=tf.tile([GO_SYMBOL], [batch_size]),
      end_token=END_SYMBOL)

decoder = tf.contrib.seq2seq.BasicDecoder(
    cell=cell,
    helper=helper,
    initial_state=cell.zero_state(batch_size, tf.float32))
outputs, _ = tf.contrib.seq2seq.dynamic_decode(
   decoder=decoder,
   output_time_major=False,
   impute_finished=True,
   maximum_iterations=20)

tf.tile
该函数的原型是：

tile(
    input,
    multiples,
    name=None
)

tf.tile主要的功能就是在tensorflow中对矩阵进行自身进行复制的功能，比如按行进行复制，或是按列进行复制，如下面的例子：

a = tf.constant([[1, 2],[2, 3],[3, 4]], dtype=tf.float32)
tile_a_1 = tf.tile(a, [1,2])
tile_a_2 = tf.tile(a,[2,1])
tile_a_3 = tf.tile(a,[2,2])
with tf.Session() as sess:
    print(sess.run(tile_a_1))
    print(sess.run(tile_a_2))
    print(sess.run(tile_a_3))

输出为：
[[ 1. 2. 1. 2.]
[ 2. 3. 2. 3.]
[ 3. 4. 3. 4.]]
[[ 1. 2.]
[ 2. 3.]
[ 3. 4.]
[ 1. 2.]
[ 2. 3.]
[ 3. 4.]]
[[ 1. 2. 1. 2.]
[ 2. 3. 2. 3.]
[ 3. 4. 3. 4.]
[ 1. 2. 1. 2.]
[ 2. 3. 2. 3.]
[ 3. 4. 3. 4.]]
第一次按第二维复制了两倍，即列数变成了两倍，第二次是第一维复制了两倍，所以行数变成了两倍。第三次是两个维度都复制两倍，因此横向纵向都变成了两倍长。
10 .tf.identity
该函数的原型是：

identity(
    input,
    name=None
)

该函数用于返回一个跟input一样维度和内容的张量。

tf.sequence_mask
该函数的原型是：

sequence_mask(
    lengths,
    maxlen=None,
    dtype=tf.bool,
    name=None
)

lengths代表的是一个一维数组，代表每一个sequence的长度，那么该函数返回的是一个mask的张量，张量的维数是：(lengths.shape,maxlen)：

例如：
tf.sequence_mask([1, 3, 2], 5)
输出为：
[[True, False, False, False, False],
[True, True, True, False, False],
[True, True, False, False, False]]

tf.contrib.seq2seq.sequence_loss
该函数的原型是：

sequence_loss(
    logits,
    targets,
    weights,
    average_across_timesteps=True,
    average_across_batch=True,
    softmax_loss_function=None,
    name=None
)

用于计算seq2seq中的loss。当我们的输入是不定长的时候，weights参数常常使用我们1.11中得到的mask。

tf.train.AdamOptimizer
我们都知道，我们进行训练需要使用一个优化器，这里我并不是想讲AdamOptimizer，你当然可以使用其他的优化器。这里我们想要介绍的是在使用优化器之后，我们想要对什么进行优化，在之前的代码中，我们可能用tf.train.Optimizer.minimize更多，这个函数用于最小化loss，并更新var_list。这个函数其实可以拆解成两个函数来实现同样的功能：

tf.train.Optimizer.compute_gradients(loss,var_list=None, gate_gradients=1,

aggregation_method=None,

colocate_gradients_with_ops=False, grad_loss=None)

该函数对var_list中的变量计算loss的梯度

该函数为函数minimize()的第一部分，返回一个以元组(gradient, variable)组成的列表。

tf.train.Optimizer.apply_gradients(grads_and_vars, global_step=None, name=None)

该函数将计算出的梯度应用到变量上，是函数minimize()的第二部分，返回一个应用指定的梯度的操作Operation，对global_step做自增操作。
本文中，将使用以上两个函数来对loss进行优化。

tf.contrib.rnn.LSTMCell
用于构建一个LSTMCell的类，示例如下：
lstm_cell = tf.contrib.rnn.LSTMCell(rnn_size,initializer=tf.random_uniform_initializer(-0.1,0.1,seed=2))
rnn_size就是我们隐藏层的神经元的数量。
tf.contrib.rnn.MultiRNNCell
用于构建多层RNN的类，需要传入一个cell的list，示例如下：

def get_decoder_cell(rnn_size):
        decoder_cell = tf.contrib.rnn.LSTMCell(rnn_size,initializer=tf.random_uniform_initializer(-0.1,0.1,seed=2))
        return decoder_cell

cell = tf.contrib.rnn.MultiRNNCell([get_decoder_cell(rnn_size) for _ in range(num_layers)])

tf.nn.dynamic_rnn
该函数的原型是：

dynamic_rnn(
    cell,
    inputs,
    sequence_length=None,
    initial_state=None,
    dtype=None,
    parallel_iterations=None,
    swap_memory=False,
    time_major=False,
    scope=None
)

用于构造一个动态的rnn模型,返回模型的输出，以及state的值，如果是lstm，那么state是一个tuple，有短时记忆c和长时记忆h。示例如下：

rnn_layers = [tf.nn.rnn_cell.LSTMCell(size) for size in [128, 256]]

create a RNN cell composed sequentially of a number of RNNCells
multi_rnn_cell = tf.nn.rnn_cell.MultiRNNCell(rnn_layers)
'outputs' is a tensor of shape [batch_size, max_time, 256]# 'state' is a N-tuple where N is the number of LSTMCells containing a# tf.contrib.rnn.LSTMStateTuple for each cell
outputs, state = tf.nn.dynamic_rnn(cell=multi_rnn_cell,
                                   inputs=data,
                                   dtype=tf.float32)