tf.data.Dataset.from_tensor_slices:

它的作用是切分传入Tensor的第一个维度，生成相应的dataset。

例1：

dataset = tf.data.Dataset.from_tensor_slices(np.random.uniform(size=(5, 2))) 
传入的数值是一个矩阵，它的形状为(5, 2)，tf.data.Dataset.from_tensor_slices就会切分它形状上的第一个维度，最后生成的dataset中一个含有5个元素，每个元素的形状是(2, )，即每个元素是矩阵的一行。

例2：

对于更复杂的情形，比如元素是一个python中的元组或者字典：在图像识别中一个元素可以是｛”image”:image_tensor,”label”:label_tensor｝的形式。 
dataset = tf.data.Dataset.from_tensor_slices ( { “a”:np.array([1.0,2.0,3.0,4.0,5.0]), “b”:np.random.uniform(size=(5,2) ) } ) 
这时，函数会分别切分”a”中的数值以及”b”中的数值，最后总dataset中的一个元素就是类似于{ “a”:1.0, “b”:[0.9,0.1] }的形式。

shuffle(
    buffer_size,
    seed=None,
    reshuffle_each_iteration=None
)

batch很好理解，就是batch size。注意在一个epoch中最后一个batch大小可能小于等于batch size 
dataset.repeat就是俗称epoch，但在tf中与dataset.shuffle的使用顺序可能会导致个epoch的混合 
dataset.shuffle就是说维持一个buffer_size 大小的 shuffle buffer，图中所需的每个样本从shuffle buffer中获取，取得一个样本后，就从源数据集中加入一个样本到shuffle buffer中。对于完美的洗牌，需要大于或等于数据集的完整大小的缓冲区大小。

tf.slice: 

tf.slice(
    input_,
    begin,
    size,
    name=None
)

函数参数

• input_：一个Tensor.
• begin：一个int32或int64类型的Tensor.
• size：一个int32或int64类型的Tensor.
• name：操作的名称(可选).

函数返回

tf.slice函数返回与input具有相同类型的Tensor.

此操作从由begin指定位置开始的张量input中提取一个尺寸size的切片.切片size被表示为张量形状,其中size[i]是你想要分割的input的第i维的元素的数量.切片的起始位置(begin)表示为每个input维度的偏移量.换句话说,begin[i]是你想从中分割出来的input的“第i个维度”的偏移量.

input = [[[1, 1, 1], [2, 2, 2]],
         [[3, 3, 3], [4, 4, 4]],
         [[5, 5, 5], [6, 6, 6]]]
tf.slice(input, [1, 0, 0], [1, 1, 3]) ==> [[[3, 3, 3]]]
tf.slice(input, [1, 0, 0], [1, 2, 3]) ==> [[[3, 3, 3],
                                            [4, 4, 4]]]
tf.slice(input, [1, 0, 0], [2, 1, 3]) ==> [[[3, 3, 3]],
                                           [[5, 5, 5]]]
                                           
tf.gather(input, [0, 2]) ==> [[[1, 1, 1], [2, 2, 2]],
                              [[5, 5, 5], [6, 6, 6]]]

假设我们要从input中抽取[[[3, 3, 3]]]，这个输出在inputaxis=0的下标是1，axis=1的下标是0，axis=2的下标是0-2，所以begin=[1,0,0]，size=[1,1,3]。
 
假设我们要从input中抽取[[[3, 3, 3], [4, 4, 4]]]，这个输出在inputaxis=0的下标是1，axis=1的下标是0-1，axis=2的下标是0-2，所以begin=[1,0,0]，size=[1,2,3]。
 
假设我们要从input中抽取[[[3, 3, 3], [5, 5, 5]]]，这个输出在inputaxis=0的下标是1-2，axis=1的下标是0，axis=2的下标是0-2，所以begin=[1,0,0]，size=[2,1,3]。
 
假设我们要从input中抽取[[[1, 1, 1], [2, 2, 2]],[[5, 5, 5], [6, 6, 6]]]，这个输出在input的axis=0的下标是[0, 2]，不连续，可以用tf.gather抽取。input[0]和input[2]

tf.identity

tf.sequence_mask：

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

函数参数

• lengths：整数张量,其所有值小于等于maxlen.
• maxlen：标量整数张量,返回张量的最后维度的大小；默认值是lengths中的最大值.
• dtype：结果张量的输出类型.
• name：操作的名字.

函数返回值

形状为lengths.shape + (maxlen,)的mask张量,投射到指定的dtype.

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

tf.boolean_mask：

tf.boolean_mask(
    tensor,
    mask,
    name='boolean_mask',
    axis=None
)

一般情况下,0 < dim(mask) = K <= dim(tensor) 并且 mask 的形状必须与张量形状的第一 K 维度匹配.然后我们就有：(tensor, mask)[i, j1,...,jd] = tensor[i1,...,iK,j1,...,jd] 当(i1,...,iK) 是 mask (row-major order) 的第 i 个真输入.

ARGS：

• tensor：N -D 张量.
• mask：K - D 布尔张量,K <= N 和 K 必须是静态已知的.
• name：此操作的名称(可选).

返回：

返回(N-K + 1)维张量由条目中填充的 tensor 对应于 mask 中的 True 值.

注意：

• ValueError：如果形状不符合时.

＃1-D 示例 
tensor =  [ 0 , 1 , 2 , 3 ] 
mask = np.array([True,False,True,False] ) 
boolean_mask (tensor,mask) == >  [ 0 , 2 ]
＃2-D示例 
tensor =  [ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ] 
mask = np.array([True,False,True] ) 
boolean_mask (tensor,mask) == >  [ [ 1 , 2 ] , [ 5 , 6 ] ]