TensorFlow创建固定长度记录的Dataset

tf.contrib.data.FixedLengthRecordDataset

tf.contrib.data.FixedLengthRecordDataset 类

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

来自一个或多个二进制文件的固定长度记录的 Dataset.

属性

• output_shapes
  
• output_types
  

方法

__init__

__init__ ( 
    filenames, 
    record_bytes , 
    header_bytes = None, 
    footer_bytes = None
 )

创建 FixedLengthRecordDataset.

ARGS：

• filenames：tf.string 类型的张量,包含一个或多个文件名.
• record_bytes：tf.int64 的标量,表示每个记录中的字节数.
• header_bytes：(可选)tf.int64 类型的标量,表示在文件开头跳过的字节数.
• footer_bytes：(可选)tf.int64 类型的标量,表示在文件末尾要忽略的字节数.

batch

batch( batch_size )

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

ARGS：

• batch_size：一个 tf.int64 类型的标量 tf.Tensor,表示在单个批次中组合的此数据集的连续元素的数量.

返回：

返回一个 Dataset.

dense_to_sparse_batch

dense_to_sparse_batch ( 
    batch_size ,
    row_shape
)

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

与 Dataset.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 的大小.

返回：

返回一个 Dataset.

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> ：一个 `tf .int64` 类型的标量 `tf.Tensor` ,代表着开始值的枚举.

####Returns：

  一个 `Dataset` .

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

```python
filter(predicate)

根据谓词筛选此数据集.

ARGS：

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

返回：

返回一个 Dataset.

flat_map

flat_map ( map_func )

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

ARGS：

• map_func：一个函数,用来映射张量的嵌套结构(具有由 self.output_shapes 和 self.output_types 定义的形状和类型)到一个 Dataset.

返回：

返回一个 Dataset.

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维度中各有相同的大小.

返回：

返回一个 Dataset.

from_tensors

from_tensors (tensors)

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

ARGS：

• tensors：张量的嵌套结构.

返回：

一个 Dataset.

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.

返回：

返回一个 Dataset.

make_dataset_resource

make_dataset_resource ()

make_initializable_iterator

make_initializable_iterator (shared_name = None)

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

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

ARGS：

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

返回

在这个数据集的元素的一个 Iterator .

make_one_shot_iterator

make_one_shot_iterator ()

创建一个 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,表示在并行处理时将被缓冲的已处理元素的最大数量.

返回：

一个 Dataset.

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.

返回：

一个 Dataset.

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 的容量.

返回：

返回一个 Dataset.

repeat

repeat( count = None )

重复此数据集 count 次数.

ARGS：

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

返回：

返回一个 Dataset.

shuffle

shuffle( 
    buffer_size , 
    seed = None
 )

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

ARGS：

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

返回：

返回一个 Dataset.

skip

skip(count)

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

ARGS：

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

返回：

返回一个 Dataset.

take

take(count)

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

ARGS：

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

返回：

返回一个 Dataset.

unbatch

unbatch()

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

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

返回：

返回一个 Dataset.

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：数据集的嵌套结构.

返回：

返回一个 Dataset.