杂项，后期整理
1.tf.sampled_softmax_loss
此函数和tf.nn.nce_loss是差不多的, 取样求loss
def sampled_softmax_loss(
weights, #[num_classes, dim]
biases, #[num_classes]
inputs, #[batch_size, dim]
labels, #[batch_size, num_true]
num_sampled,
num_classes,
num_true=1,
sampled_values=None,
remove_accidental_hits=True,
partition_strategy="mod",
name="sampled_softmax_loss")
关于参数labels:一般情况下，num_true为1, labels的shpae为[batch_size, 1]。假设我们有1000个类别， 使用one_hot形式的label的话， 我们的labels的shape是[batch_size, num_classes]。显然，如果num_classes非常大的话，会影响计算性能。所以，这里采用了一个稀疏的方式,即：使用3代表了[0,0,0,1,0….]
2.tf.contrib.layers.embed_sequence
tf.contrib.layers.embed_sequenceembed_sequence(
ids,
vocab_size=None,
embed_dim=None,
unique=False,
initializer=None,
regularizer=None,
trainable=True,
scope=None,
reuse=None
)
一般用于seq2seq网络，可以完成对输入序列数据的嵌入工作。一般只需关注前三个参数即可。
ids：形状为[batch_size, seq_length]，也就是输入数据
vocab_size：输入数据为字典的长度
embed_dim：想要的嵌入矩阵的维度
3.tf.contrib.layers.embed_sequence
tf.stride_slice(data, begin, end)
tf.slice(data, begin, end)
tf.stride_slice的end是开区间，tf.slice的end是闭区间。
一般有一个常用的小技巧是tf.stride_slice(data, [0, 0], [rows, -1])，可以截掉最后一列，很实用。
import tensorflow as tf
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])
with tf.Session() as sess:
print(sess.run(x))
#就是第0行到第一行，然后弄完[[[1, 1, 1], [2, 2, 2]]]，再第0行到第一行，弄完
#[[[1, 1, 1]]]，再到第0列到第一列，弄完[[[1]]]
4.tf.contrib.seq2seq.TrainingHelper
A helper for use during training. Only reads inputs.
Returned sample_ids are the argmax of the RNN output logits.
helper = tf.contrib.seq2seq.TrainingHelper(
input=input_vectors,
sequence_length=input_lengths)
5.tf.contrib.seq2seq.BasicDecoder
用于构造一个decoder
decoder = tf.contrib.seq2seq.BasicDecoder(
cell=cell,
helper=helper,
initial_state=cell.zero_state(batch_size, tf.float32))
6.tf.contrib.seq2seq.dynamic_decode
用于构造一个动态decoder，返回的内容是：就是3个返回值
（final_outputs, final_state, final_sequence_lengths），final_outputs是一个元祖，包含两项(rnn_outputs, sample_id)，他们的说明如下：
rnn_output：[batch_size, decoder_targets_length, vocab_size]，保存是decoder中每个时间步的输出，很容易理解。
sample_id：[batch_size]，保存最终的编码结果，可以表示最后的答案
#新版本的tensorflow是3个返回值，注意了
outputs, _ , _= tf.contrib.seq2seq.dynamic_decode(
decoder=decoder,
output_time_major=False,
impute_finished=True,
maximum_iterations=20)
7.tf.tile
通过复制input的multiples时间来创建新的张量。输出的张量的第i维是input[i] * multiples[i] ，通俗点就是沿着“i”维度input值被复制了multiples[i]次。比如:
a = tf.constant([[1, 2],[2, 3],[3, 4]], dtype=tf.float32)
tile_a_1 = tf.tile(a, [3,1])
with tf.Session() as sess:
print(sess.run(tile_a_1))
#结果是：
[[1. 2.]
[2. 3.]
[3. 4.]
[1. 2.]
[2. 3.]
[3. 4.]
[1. 2.]
[2. 3.]
[3. 4.]]
8.tf.contrib.seq2seq.GreedyEmbeddingHelper
这是用于seq2seq中帮助建立Decoder的一个类，在预测时使用，示例代码如下：
helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(
embedding=embedding,
#可以结合7，知道为啥tf.tile要batch_size了吧
start_tokens=tf.tile([GO_SYMBOL], [batch_size]),
end_token=END_SYMBOL)
9.tf.sequence_mask
函数原型
sequence_mask(
lengths,
maxlen=None, #maxlen：标量整数张量，返回张量的最后维度的大小；默认值是lengths中的最大值。
dtype=tf.bool,
name=None
)
返回一个表示每个单元的前N个位置的mask张量。如果lengths的形状为[d_1, d_2, ..., d_n]，由此产生的张量mask有dtype类型和形状[d_1, d_2, ..., d_n, maxlen]，并且：mask[i_1, i_2, ..., i_n, j] = (j < lengths[i_1, i_2, ..., i_n])
例如：
tf.sequence_mask([1, 3, 2], 5) # [[True, False, False, False, False],
# [True, True, True, False, False],
# [True, True, False, False, False]]
tf.sequence_mask([[1, 3],[2,0]]) # [[[True, False, False],
# [True, True, True]],
# [[True, True, False],
# [False, False, False]]]
#这个就是最大长度是3，所以3列
10.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参数常常使用我们tf.sequence_mask()中得到的mask。
11.tf.train.AdamOptimizer
训练需要优化器，这边主要不是讲优化器（真脑残，为啥一个函数分成两个来写）。其实可以用tf.train.Optimizer.minimize()，这个函数用于最小化loss，并更新var_list。这个函数可以拆分成两个函数实现同样的功能：
#该函数对var_list中的变量计算loss的梯度，为minimize()的第一部分，返回一个以#元祖(gradient, variavle)组成的列表
tf.train.Optimizer.compute_gradients(
loss,var_list=None, gate_gradients=1,
aggregation_method=None,
colocate_gradients_with_ops=False, grad_loss=None)
#该函数将计算出的梯度应用到变量上，是函数minimize()的第二部分，返回一个应#用指定梯度的操作，对global_step做自增操作。
tf.train.Optimizer.apply_gradients(
grads_and_vars, global_step=None, name=None
)
#上述两个函数组合起来就能对loss进行优化
