TensorFlow文本文件行的数据集
tf.contrib.data.TextLineDataset
继承自: Dataset
定义在:tensorflow/contrib/data/python/ops/dataset_ops.py.
一个包含来自一个或多个文本文件的行的数据集.
属性
- output_shapes
- output_types
方法
__init__
__init__(
filenames,
compression_type=None
)
创建一个 TextLineDataset.
ARGS:
- filenames:一个 tf.string 张量包含一个或多个文件名.
- compression_type:一个字符串,是:"" (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.
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 的枚举.
例如:
# NOTE: The following examples use `{ ... }` to represent the
# contents of a dataset.
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.
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.
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() 同时处理多个输入文件:
# Preprocess 4 files concurrently, and interleave blocks of 16 records from
# each file.
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 }
# NOTE: New lines indicate "block" boundaries.
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.initializer 操作,然后再使用它.
ARGS:
- shared_name:(可选)如果为非空, 则此迭代器将在共享相同设备的多个会话 (例如, 使用远程服务器时) 的给定名称下共享.
返回:
此数据集的元素上的迭代器.
make_one_shot_iterator
make_one_shot_iterator ()
创建用于枚举此数据集的元素的迭代器.
返回的迭代器将自动初始化."one-shot" 迭代器当前不支持重新初始化.
返回:
此数据集的元素上的迭代器.
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 )
将此数据集的连续元素合并为填充的批处理.
与数据集 dense_to_sparse_batch () 一样, 此方法将此数据集的多个连续元素 (可能具有不同的形状) 合并到单个元素中.结果元素中的张量有一个额外的外部维度, 并填充到 padded_shapes 中的相应形状.
ARGS:
- batch_size:一个 tf.int64 的标量 tf.Tensor,表示在单个批次中组合的此数据集的连续元素的数量.
- padded_shapes:表示每个输入元素的各个组件在批量之前应填充的形状的嵌套结构 tf.TensorShape 或 tf.int64 向量张量样对象.任何未知的维度(例如,tf.Dimension(None)在一个 tf.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:可以用文件名张量和 (可选) 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)
创建一个从该数据集中跳过计数元素的数据集.
ARGS:
- count:一个 tf.int64 的标量 tf.Tensor,表示应跳过的此数据集的元素数,以形成新的数据集.如果 count 大于此数据集的大小,则新数据集将不包含任何元素.如果计数为-1,则跳过整个数据集.
返回:
返回一个 Dataset.
take
take(count)
使用此数据集中的最多的 count 元素创建数据集.
ARGS:
- count:一个 tf.int64 的标量 tf.Tensor,表示应用于形成新数据集的此数据集的元素数.如果 count 为-1,或者如果 count 大于此数据集的大小,则新数据集将包含此数据集的所有元素.
返回:
返回一个 Dataset.
unbatch
unbatch()
将此数据集的元素拆分为连续元素的序列.
例如,如果此数据集的元素被塑造为 [B, a0, a1, ...],其中 B 可能会因元素而异,那么对于此数据集中的每个元素,未分割数据集将包含 B 连续的形状元素 [a0, a1, ...].
返回:
返回一个 Dataset.
zip
zip (datasets)
通过将给定数据集压缩在一起来创建数据集.
此方法与 Python 中的内置 zip () 函数具有相似的语义,主要区别在于数据集参数可以是数据集对象的任意嵌套结构.例如:
# NOTE: The following examples use `{ ... }` to represent the
# contents of a dataset.
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.
更多建议: