- 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)