TensorFlow的数据集

tf.contrib.data.Dataset

tf.contrib.data.Dataset 类

定义在：tensorflow/contrib/data/python/ops/dataset_ops.py.

表示一组潜在的大型元素集.
数据集可用于将输入管道表示为元素的集合 (张量的嵌套结构) 和作用于这些元素的变换的“逻辑计划”.

属性

output_shapes

返回此数据集元素的每个组件的形状.

返回：

tf.TensorShape 对象的嵌套结构对应于该数据集的元素的每个组件.

output_types

返回此数据集元素的每个组件的类型.

返回：

tf.DType 对象的嵌套结构对应于该数据集的元素的每个组件.

方法

__init__

__init__ ()

batch

batch( batch_size )

将此数据集的连续元素组合成批量.

ARGS：

• batch_size：一个 tf.int64 的标量 tf.Tensor,表示该数据集的连续元素的个数,并组合成一个单批.

返回：

一个数据集.

dense_to_sparse_batch

dense_to_sparse_batch ( 
    batch_size ,
    row_shape
)

将这个数据集的不规则元素批量放入 tf.SparseTensors.

与数据集 padded_batch () 一样, 此方法将此数据集的多个连续元素 (可能具有不同的形状) 合并到单个元素中.生成的元素有三组件 (索引、值和 dense_shape), 其中包括一个tf.SparseTensor 表示相同数据的组件.row_shape 表示生成的 tf.SparseTensor 中每一行的稠密形状,有效的批次尺寸是预先规定的.例如:

＃注意：以下示例使用“{...}”来表示
数据集的＃个内容.
a =  {  [ 'a' , 'b' , 'c' ] , [ 'a' , 'b' ] , [ 'a' , 'b' , 'c' , 'd' ]  }

a .dense_to_sparse_batch (batch_size = 2 , row_shape = [ 6 ] ) ==  { 
    ([ [ 0 , 0 ] , [ 0 , 1 ] , [ 0 , 2 ] , [ 1 , 0 ] , [ 1 , 1 ] ] , #indices
     [ 'A' ,  'b' ,  'C' , 'A' , 'B' ] ,                                  #values
     [ 2 , 6 ] ),                                                     #dense_shape 
    ([ [ 2 , 0 ] , [ 2 , 1 ] , [ 2 , 2 ] , [ 2 , 3 ] ] ,
     [ “a' , 'b' , 'C' , 'D' ] ,
     [ 1 , 6 ] )
}

ARGS：

• batch_size：一个 tf.int64 的标量 tf.Tensor,表示在单个批次中组合的此数据集的连续元素的数量.
• row_shape：表示一个 tf.TensorShape 或一个 tf.int64 向量张量样的对象,表示所产生的 tf.SparseTensor 的一行的等效致密形状.该数据集的每个元素必须具有与 row_shape 相同的秩,并且在每个维度中必须具有小于或等于 row_shape 的大小.

返回：

一个数据集.

enumerate

enumerate( start = 0 )

枚举此数据集的元素.类似于 python 的 enumerate.

例如：

#注意：以下示例使用“{...}”来表示
#数据集的内容.
a =  {  1 , 2 , 3  } 
b =  {  (7 , 8 ), (9 , 10 ), (11 , 12 ) }

#“datasets”参数的嵌套结构决定
#了结果数据集中元素的结构.
a .enumerate(start = 5 ) ==  {  (5 , 1 ), (6 , 2 ), (7 , 3 ) } 
b .enumerate() ==  {  (0 , (7 , 8 )), (1 , (9 , 10 )), (2 , (11 , 12 )) }

#### Args：

*  < b > `start` < / b > ：A `tf.int64` scalar `tf.Tensor` ,代表着开始
    值的枚举.

#### Returns：

  A `Dataset` .

< h3 id = “filter” > < code > filter < / code > < / h3 >

```python
filter(predicate)

根据谓词过滤此数据集.

ARGS：

• predicate：一个函数,用来映射张量的嵌套结构 (具有自 output_shapes 和自 output_types 定义的形状和类型) 到标量 tf.bool 张量.

返回：

一个数据集.

flat_map

flat_map ( map_func )

将map_func映射到这个数据集,并拼合结果.

ARGS：

• map_func：一种函数, 用于映射张量的嵌套结构 (具有自 output_shapes 和 self output_types 定义的形状和类型) 到数据集.

返回：

一个数据集.

from_sparse_tensor_slices

from_sparse_tensor_slices ( sparse_tensor )

在此数据集中逐行分裂每个秩为 N 的 tf.SparseTensor.

ARGS：

• sparse_tensor：一个 tf.SparseTensor.

返回：

返回秩为 (N-1) 的稀疏张量的数据集.

from_tensor_slices

from_tensor_slices (tensors)

创建一个数据集,它的元素是给定张量的某部分.

ARGS：

• tensors：张量的嵌套结构,在第0维度中各有相同的大小.

返回：

一个数据集.

from_tensors

from_tensors (tensors)

创建一个包含给定张量的单个元素的数据集.

ARGS：

• tensors：张量的嵌套结构.

返回：

一个数据集.

group_by_window

group_by_window ( 
    key_func , 
    reduce_func ,
    WINDOW_SIZE
)

对此数据集执行窗口的 “group-by” 操作.

此方法将此数据集中的每个连续元素映射到使用 key_func 的键, 并按键对元素进行分组.然后, 它将 reduce_func 应用于与同一密钥匹配的大多数 window_size 元素.每个键除了最后窗口外的其它窗口将包含 window_size 元素,最后的窗口可能会较小.

ARGS：

• key_func：一个函数映射张量的嵌套结构 (具有 self. output_shapes 和 self.output_types 定义的形状和类型) 到标量 tf.int64 张量.
• reduce_func：一个函数将一个键和一个数据集映射到 batch_size 的连续元素,并将该键匹配到另一个数据集.
• window_size：一个 tf.int64 标量 tf.Tensor,表示匹配同一密钥的连续元素的数量,并将其合并到一个批处理中,将被传递给reduce_func.

返回：

一个数据集.

make_dataset_resource

make_dataset_resource ()

创建一个表示此数据集 tf.Tensor 的 tf.resource 张量.

返回：

标量 tf.Tensor 的 tf.resource 类型,这表示该数据集.

make_initializable_iterator

make_initializable_iterator (shared_name = None)

创建一个 Iterator 枚举这个数据集的元素.

返回的迭代器将处于未初始化状态,您必须在使用之前运行 iterator.initializer 操作.

ARGS：

• shared_name：(可选)如果不是空的,这个迭代器将在共享相同设备的多个会话中以给定的名称共享(例如,当使用远程服务器时).

返回：

此数据集的元素上的迭代器.

make_one_shot_iterator

make_one_shot_iterator ()

创建一个 Iterator 枚举这个数据集的元素.

返回的迭代器将被自动初始化.“一键式” 迭代器目前不支持重新初始化.

返回：

此数据集的元素上的迭代器.

map

map ( 
    map_func , 
    num_threads = None , 
    output_buffer_size = None
 ) 

将 map_func 映射到这个数据集.

ARGS：

• map_func：一个函数用来映射一个嵌套结构的张量(具有由 self.output_shapes 和 self.output_types 定义的形状和类型)到另一个嵌套结构的张量.
• num_threads：(可选)一个 tf.int32 标量 tf.Tensor,表示用于并行处理元素的线程数.如果未指定,元素将被顺序处理而不进行缓冲.
• output_buffer_size：(可选)一个 tf.int64 标量 tf.Tensor,表示在并行处理时将被缓冲的已处理元素的最大数量.

返回：

一个数据集.

padded_batch

padded_batch ( 
    batch_size , 
    padded_shapes , 
    padding_values = None
 )

将此数据集的连续元素合并为填充的批处理.

像 Dataset.dense_to_sparse_batch() 一样, 此方法将此数据集的多个连续元素 (可能具有不同的形状) 合并到单个元素中.结果元素中的张量有一个额外的外部维度, 并填充到 padded_shapes 中的相应形状.

ARGS：

• batch_size：一个 tf.int64 标量 tf.Tensor,表示此数据集的连续元素在单个批处理中合并的数量.
• padded_shapes：tf.TensorShape 的嵌套结构或 tf. int64 向量张量样对象,表示每个输入元素的各自组件在批处理之前应填充的形状.任何未知的维度 (例如 tf.Dimension(None) 在一个 TensorShape 或-1 在一个类似张量的对象中) 将被填充到每个批次中该维度的最大维度.

• padding_values：(可选)一个标量形状的嵌套结构 tf.Tensor,表示要用于各个组件的填充值.对于数字类型和字符串类型的空字符串,默认值为 0.

返回：

一个数据集.

range

range(* args )

创建一个分步分隔的值范围的数据集.

例如：

Dataset.range(5 ) ==  [ 0 , 1 , 2 , 3 , 4 ] 
Dataset.range(2 , 5 ) ==  [ 2 , 3 , 4 ] 
Dataset.range(1 , 5 , 2 ) ==  [ 1 , 3 ] 
Dataset.range(1 , 5 , - 2 ) ==  [ ] 
Dataset.range(5 , 1 ) ==  [ ] 
Dataset.range(5 , 1 , - 2 ) ==  [ 5 , 3 ]

ARGS：

* args：遵循与 python 的 xrange 相同的语义：len(args)== 1 - > start = 0,stop = args [0],step = 1 len(args)== 2 - > start = args [0],stop = args [1],step = 1 len (args)== 3 - > start = args [0],stop = args [1,stop = args [2]

返回：

返回一个 RangeDataset.

注意：

• ValueError：当 len(args)== 0.

read_batch_features

read_batch_features ( 
    file_pattern , 
    batch_size , 
    features , 
    reader , 
    reader_args = None , 
    randomize_input = True , 
    num_epochs = None , 
    capacity = 10000 
)

读取批次的示例.

ARGS：

• file_pattern：字符串模式或带有文件名列表的占位符.
• batch_size：一个 tf.int64 类型的标量 tf.Tensor,表示此数据集的连续元素在单个批处理中合并的数量.
• features：字典映射功能键 FixedLenFeature 或 VarLenFeature 值.见 tf.parse_example.
• reader：可以用 filenames 张量和 (可选) reader_args 调用的函数或类, 并返回序列化示例的数据集.
• reader_args：要传递给读取器类的其他参数.
• randomize_input：输入是否应该是随机的.
• num_epochs：整数, 指定通过数据集读取的次数.如果没有, 则永远循环遍历数据集.
• capacity：ShuffleDataset 的容量.

返回：

一个数据集.

repeat

repeat( count = None )

重复此数据集 count 次数.

ARGS：

• count：(可选)一个 tf.int64 标量 tf.Tensor,表示应该重复此数据集的元素的次数.默认行为(如果 count 是 None 或-1)是为了无限期地重复这些元素.

返回：

一个数据集.

shuffle

shuffle( 
    buffer_size , 
    seed = None
 )

随机地打乱这个数据集的元素.

ARGS：

• buffer_size：一个 tf.int64 标量 tf.Tensor,表示来自此数据集的元素数, 新数据集将从中取样.
• seed：(可选.)一个tf.int64标量tf.Tensor,表示将用于创建分布的随机种子.

返回：

一个数据集.

skip

skip(count)

创建一个从该数据集中跳过计数元素的数据集.

ARGS：

• count：一个 tf.int64 标量 tf.Tensor,表示应跳过的此数据集的元素数, 以形成新的数据集.如果 count 大于此数据集的大小, 则新数据集将不包含任何元素.如果计数为-1, 则跳过整个数据集.

返回：

一个数据集.

take

take(count)

使用此数据集中的最多计数元素创建 Dataset.

ARGS：

• count：一个 tf.int64 类型的标量 tf.Tensor,表示应用于形成新数据集的此数据集的元素数,如果 count 为-1, 或者如果 count 大于此数据集的大小, 则新数据集将包含此数据集的所有元素.

返回：

一个数据集.

unbatch

unbatch()

将此数据集的元素分解为连续元素的序列.

例如,如果此数据集的元素被塑造为 [B、a0、a1,...], 其中 B 可能因元素而异, 则对于此数据集中的每个元素, unbatched 数据集将包含形状的 B 连续元素 [a0, a1,......].

返回：

一个数据集.

zip

zip (datasets)

通过将给定数据集合在一起来创建 Dataset .

该方法与 Python 中的内置函数 zip() 具有相似的语义,主要区别在于 datasets 参数可以是 Dataset 对象的任意嵌套结构.例如：

#注意：以下示例使用“{...}”来表示
#数据集的内容.
a =  {  1 , 2 , 3  } 
b =  {  4 , 5 , 6  } 
Ç =  {  (7 , 8 ), (9 , 10 ), (11 , 12 ) } 
ð =  {  13 , 14  }

#“datasets”参数的嵌套结构决定
#了结果数据集中元素的结构.
Dataset.zip((a, b )) ==  {  (1 , 4 ), (2 , 5 ), (3 , 6 ) } 
Dataset.zip(( b ,a)) ==  {  (4 , 1 ), (5 , 2 ), (6 , 3 ) }

#“datasets”参数可能包含任意数量的
#数据集.
Dataset.zip((a,b ,c ) ==  {(1 , 4 ,(7 ,8)),
                           (2 , 5 ,(9 ,10)),
                           (3 , 6 ,(11 ,12))}

#结果数据集中的元素数与
#数据集中最小数据集的大小相同.
Dataset.zip((a, d )) ==  {  (1 , 13 ), (2 , 14 ) }

ARGS：

• datasets：数据集的嵌套结构.

返回：

一个数据集.