阅读(163) 赞(11)

包含TFRecord文件记录的数据集

2017-09-27 14:04:42 更新

TFRecordDataset 类

继承自： Dataset

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

使用 TensorFlow 函数：tf.contrib.data.TFRecordDataset 表示包含一个或多个 TFRecord 文件的记录的数据集.

属性

output_shapes
output_types

方法

init

__init__(
    filenames,
    compression_type=None
)

创建一个 TFRecordDataset.

ARGS：

filenames：包含一个或多个文件名的 tf.string 类型的张量.
compression_type：一个 tf.string 类型标量对" "(no compression)、"ZLIB" 或 "GZIP" 中的某一个进行评价.

batch

batch(batch_size)

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

ARGS：

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

返回值：

返回一个 Dataset.

cache

cache(filename='')

缓存这个数据集中的元素.

ARGS：

filename：一个 tf.string 类型的标量 tf.Tensor,表示文件系统中用于缓存此数据集中的张量的目录的名称.如果未提供文件名,则数据集将缓存在内存中.

返回值：

返回一个 Dataset.

concatenate

concatenate(dataset)

通过将给定的数据集与此数据集连接来创建数据集.

# NOTE: The following examples use `{ ... }` to represent the
# contents of a dataset.
a = { 1, 2, 3 }
b = { 4, 5, 6, 7 }

# Input dataset and dataset to be concatenated should have same
# nested structures and output types.
# c = { (8, 9), (10, 11), (12, 13) }
# d = { 14.0, 15.0, 16.0 }
# a.concatenate(c) and a.concatenate(d) would result in error.

a.concatenate(b) == { 1, 2, 3, 4, 5, 6, 7 }

ARGS：

dataset：需要连接的 Dataset.

返回值：

该操作件返回一个 Dataset.

dense_to_sparse_batch

dense_to_sparse_batch ( 
    batch_size ,
    row_shape
)

将该数据集的不规则元素批量放入到 tf . sparsetenUNK 中.

像 Dataset.padded_batch() 一样,此方法将此数据集的多个连续元素 (可能具有不同的形状) 合并到单个元素中.所得到的元素具有三个组件(indices,values 和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 的枚举.

例如：

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

# The nested structure of the `datasets` argument determines the
# structure of elements in the resulting dataset.
a.enumerate(start=5) == { (5, 1), (6, 2), (7, 3) }
b.enumerate() == { (0, (7, 8)), (1, (9, 10)), (2, (11, 12)) }

ARGS：

start：一个 tf.int64 类型的标量 tf.Tensor,用来表示枚举的起始值.

返回指：

返回一个 Dataset.

filter

filter(predicate)

根据 predicate 过滤此数据集.

ARGS：

predicate：一个函数,用于映射张量的嵌套结构(具有由 self.output_shapes 和 self.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)

创建一个数据集,其元素是给定张量的 slices.

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 的 key,并通过该 key 对元素进行分组.然后将 reduce_func 最多应用于与同一 key 匹配的大多数 window_size 元素.每个 key 将包含 window_size 元素,除了最后的窗口,最后的窗口可能较小.

ARGS：

key_func：一个函数,用于映射张量的嵌套结构(具有由 self.output_shapes 和 self.output_types 定义的形状和类型)到标量类型为 tf.int64 的张量.
reduce_func：一个函数,将一个 key 和一个数据集映射到 batch_size 的连续元素,并将该 key 匹配到另一个数据集.
window_size：一个 tf.int64 类型的标量 tf.Tensor,表示与同一 key 相匹配的连续元素的个数,以便在单个批处理中合并,将传递给 reduce_func.

返回值：

返回一个 Dataset.

ignore_errors

ignore_errors()

从此项创建数据集,并默认忽略任何错误.

使用此转换可以生成包含与输入相同元素的数据集,但会默认删除导致错误的任何元素.例如:

dataset = tf.contrib.data.Dataset.from_tensor_slices([1., 2., 0., 4.])

# Computing `tf.check_numerics(1. / 0.)` will raise an InvalidArgumentError.
dataset = dataset.map(lambda x: tf.check_numerics(1. / x, "error"))

# Using `ignore_errors()` will drop the element that causes an error.
dataset = dataset.ignore_errors()  # ==> { 1., 0.5, 0.2 }

返回值：

返回一个 Dataset.

interleave

interleave(
    map_func,
    cycle_length,
    block_length=1
)

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

例如,您可以 Dataset.interleave() 同时处理多个输入文件：

# 同时处理4个文件,并从每个文件的16个记录块中插入结果.
filenames = ["/var/data/file1.txt", "/var/data/file2.txt", ..."]
dataset = (Dataset.from_tensor_slices(filenames)
           .interleave(
               lambda x: TextLineDataset(x).map(parse_fn, num_threads=1),
               cycle_length=4, block_length=16))

cycle_length 和 block_length 参数控制元素的生成顺序.cycle_length 控制并发处理的输入元素的数量.如果设置 cycle_length 为1,则此转换将一次处理一个输入元素,并将产生与 tf.contrib.data.Dataset.flat_map 相同的结果.一般来说,这种转换将适用 map_func 到 cycle_length 的输入元素,开启迭代器对返回的Dataset 对象,并循环通过它们生成每个迭代器的 block_length 连续元素,并且每次当迭代器结束时,都要使用下一个输入元素.

例如：

# 注意：以下示例使用 `{ ... }` 来表示数据集的内容
a = { 1, 2, 3, 4, 5 }

# 注意：新行显示 "block" 边界
a.interleave(lambda x: Dataset.from_tensors(x).repeat(6),
             cycle_length=2, block_length=4) == {
    1, 1, 1, 1,
    2, 2, 2, 2,
    1, 1,
    2, 2,
    3, 3, 3, 3,
    4, 4, 4, 4,
    3, 3,
    4, 4,
    5, 5, 5, 5,
    5, 5,
}

ARGS：

map_func：一个函数,用于映射张量的嵌套结构(具有由 self.output_shapes 和 self.output_types 定义的形状和类型)到一个Dataset.
cycle_length：将同时处理该数据集中的元素个数.
block_length：在循环到另一个输入元素之前,从每个输入元素生成的连续元素的数量.

返回值：

返回一个 Dataset.

list_files

list_files(file_pattern)

与模式匹配的所有文件的数据集.

示例：如果我们的文件系统上有以下文件： - /path/to/dir/a.txt - /path/to/dir/b.py - /path/to/dir/c.py；如果我们传递 “/ path / to / dir / *.py“ 作为目录,数据集将产生： - /path/to/dir/b.py - /path/to/dir/c.py

ARGS：

file_pattern：字符串或标量字符串 tf.Tensor,表示将匹配的文件名模式.

返回值：

返回一个与文件名相对应的字符串的数据集.

make_dataset_resource

make_dataset_resource ()

make_initializable_iterator

make_initializable_iterator(shared_name=None)

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

注意：返回的 Iterator 将处于未初始化状态,您必须先运行 iterator.initializer 操作,然后再使用它.

ARGS：

shared_name：(可选)如果非空,则该 Iterator 将在共享相同设备的多个会话(例如,使用远程服务器)时在给定名称下共享.

返回值：

返回一个此数据集的元素上的 Iterator.

make_one_shot_iterator

make_one_shot_iterator()

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

注意：返回的 Iterator 将自动初始化."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,表示在并行处理时将缓冲的已处理元素的最大数量.

返回值：

返回一个 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.TensorShape 中的 tf.Dimension(None) 或张量样对象中的-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：dict 映射功能键 FixedLenFeature 或 VarLenFeature 值.
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,表示将用于创建分布的随机种子.见 tf. set_random_seed 的行为.

返回值：

返回一个 Dataset.

skip

skip(count)

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

ARGS：

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

返回值：

返回一个 Dataset.

take

take(count)

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

ARGS：

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

返回值：

返回一个 Dataset.

unbatch

unbatch()

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

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

返回值：

返回一个 Dataset.

zip

zip(datasets)

通过将给定数据集压缩在一起来创建数据集.
此方法与 Python 中内置的 zip () 函数具有相似的语义,主要区别在于数据集参数可以是数据集对象的任意嵌套结构.例如:

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

# The nested structure of the `datasets` argument determines the
# structure of elements in the resulting dataset.
Dataset.zip((a, b)) == { (1, 4), (2, 5), (3, 6) }
Dataset.zip((b, a)) == { (4, 1), (5, 2), (6, 3) }

# The `datasets` argument may contain an arbitrary number of
# datasets.
Dataset.zip((a, b, c)) == { (1, 4, (7, 8)),
                            (2, 5, (9, 10)),
                            (3, 6, (11, 12)) }

# The number of elements in the resulting dataset is the same as
# the size of the smallest dataset in `datasets`.
Dataset.zip((a, d)) == { (1, 13), (2, 14) }

ARGS：

datasets：数据集的嵌套结构.

返回值：

返回一个 Dataset.

← TensorFlow文本文件行的数据集

TensorFlow的errors模块总览 →

包含TFRecord文件记录的数据集

TFRecordDataset 类

属性

output_shapesoutput_types

方法

__init__

ARGS：

batch

ARGS：

返回值：

cache

ARGS：

返回值：

concatenate

ARGS：

返回值：

dense_to_sparse_batch

ARGS：

返回值：

enumerate

ARGS：

返回指：

filter

ARGS：

返回值：

flat_map

ARGS：

返回值：

from_sparse_tensor_slices

ARGS：

返回值：

from_tensor_slices

ARGS：

返回值：

from_tensors

ARGS：

返回值：

group_by_window

ARGS：

返回值：

ignore_errors

返回值：

interleave

ARGS：

返回值：

list_files

ARGS：

返回值：

make_dataset_resource

make_initializable_iterator

ARGS：

返回值：

make_one_shot_iterator

返回：

map

ARGS：

返回值：

padded_batch

ARGS：

返回值：

range

ARGS：

返回值：

注意：

read_batch_features

ARGS：

返回值：

repeat

ARGS：

返回值：

shuffle

ARGS：

返回值：

skip

ARGS：

返回值：

take

ARGS：

返回值：

unbatch

output_shapes
output_types

init