标签: tensorflow-datasets

根据TensorFlow 文档,类prefetch和map方法tf.contrib.data.Dataset,都有一个名为的参数buffer_size.

对于prefetch方法,该参数称为buffer_size并且根据文档:

buffer_size:tf.int64标量tf.Tensor,表示预取时将被缓冲的最大元素数.

对于该map方法,该参数称为output_buffer_size并且根据文档:

output_buffer_size :(可选.)tf.int64标量tf.Tensor,表示将被缓冲的最大处理元素数.

类似地,对于该shuffle方法,出现相同的数量并且根据文档:

buffer_size:tf.int64标量tf.Tensor,表示新数据集将从中采样的数据集中的元素数.

这些参数之间有什么关系？

假设我创建一个Dataset对象如下:

 tr_data = TFRecordDataset(trainfilenames)
    tr_data = tr_data.map(providefortraining, output_buffer_size=10 * trainbatchsize, num_parallel_calls\
=5)
    tr_data = tr_data.shuffle(buffer_size= 100 * trainbatchsize)
    tr_data = tr_data.prefetch(buffer_size = 10 * trainbatchsize)
    tr_data = tr_data.batch(trainbatchsize)

buffer上述代码段中的参数扮演了什么角色？

我是TensorFlow的新手.我正在寻找有关图像识别的帮助,我可以在那里训练自己的图像数据集.

有没有训练新数据集的例子？

有很多关于如何创建和使用 TensorFlow 数据集的示例，例如

dataset = tf.data.Dataset.from_tensor_slices((images, labels))

我的问题是如何以 numpy 形式从 TF 数据集中取回数据/标签？换句话说，想要是上面那一行的反向操作，即我有一个 TF 数据集，想从中取回图像和标签。

我有一个数据集表示为NumPy形状矩阵,(num_features, num_examples)我希望将其转换为TensorFlow类型tf.Dataset.

我正在努力去理解这两种方法之间的区别:Dataset.from_tensors和Dataset.from_tensor_slices.什么是正确的,为什么？

TensorFlow文档(链接)表示两种方法都接受张量的嵌套结构,尽管使用from_tensor_slices张量时在第0维应该具有相同的大小.

我有一个非常简单的输入管道,from_generator非常适合......

dataset = tf.data.Dataset.from_generator(complex_img_label_generator,
                                        (tf.int32, tf.string))
dataset = dataset.batch(64)
iter = dataset.make_one_shot_iterator()
imgs, labels = iter.get_next()

其中complex_img_label_generator动态生成图像,并返回表示一个numpy的阵列(H, W, 3)图像和一个简单的string标签.处理不是我可以表示从文件和tf.image操作中读取的内容.

我的问题是关于如何平衡发电机？我如何让N个这些生成器在自己的线程中运行.

一个想法是使用dataset.map与num_parallel_calls处理线程; 但是地图在张量上运行......另一个想法是创建多个生成器,每个生成器都有自己的,prefetch并以某种方式加入它们,但我看不出我如何加入N个生成器流？

我可以遵循任何规范的例子吗？

我正在阅读数据加载部分的 TF 性能指南。对于预取它说，

tf.data API 通过 tf.data.Dataset.prefetch 转换提供了软件流水线机制，可用于将数据产生时间与数据消耗时间解耦。特别是，转换使用后台线程和内部缓冲区在请求元素之前从输入数据集中预取元素。要预取的元素数应等于（或可能大于）单个训练步骤消耗的批次数。您可以手动调整此值，或将其设置为 tf.data.experimental.AUTOTUNE，这将提示 tf.data 运行时在运行时动态调整该值。

AUTOTUNE 内部在做什么？正在应用哪种算法，启发式？

另外，在实践中，进行了什么样的手动调整？

我尝试优化我的数据输入管道。该数据集是一组 450 个 TFRecord 文件，每个文件大小约为 70MB，托管在 GCS 上。该作业使用 GCP ML Engine 执行。没有 GPU。

这是管道：

def build_dataset(file_pattern):
    return tf.data.Dataset.list_files(
        file_pattern
    ).interleave(
        tf.data.TFRecordDataset,
        num_parallel_calls=tf.data.experimental.AUTOTUNE
    ).shuffle(
        buffer_size=2048
    ).batch(
        batch_size=2048,
        drop_remainder=True,
    ).cache(
    ).repeat(
    ).map(
        map_func=_parse_example_batch,
        num_parallel_calls=tf.data.experimental.AUTOTUNE
    ).prefetch(
        buffer_size=1
    )

使用映射函数：

def _bit_to_float(string_batch: tf.Tensor):
    return tf.reshape(tf.math.floormod(tf.dtypes.cast(tf.bitwise.right_shift(
        tf.expand_dims(tf.io.decode_raw(string_batch, tf.uint8), 2),
        tf.reshape(tf.dtypes.cast(tf.range(7, -1, -1), tf.uint8), (1, 1, 8))
    ), tf.float32), 2), (tf.shape(string_batch)[0], -1))


def _parse_example_batch(example_batch):
    preprocessed_sample_columns = {
        "features": tf.io.VarLenFeature(tf.float32),
        "booleanFeatures": tf.io.FixedLenFeature((), tf.string, ""),
        "label": tf.io.FixedLenFeature((), tf.float32, -1)
    }
    samples = tf.io.parse_example(example_batch, preprocessed_sample_columns)
    dense_float = tf.sparse.to_dense(samples["features"])
    bits_to_float …

我已经阅读了 TF 页面和一些关于使用 prefetch() 和 cache() 来加速模型输入管道的帖子，并尝试在我的数据上实现它。Cache() 按预期为我工作，即在第一个纪元中从 dist 读取数据，在所有后续纪元中它只是从内存中读取数据。但我在使用 prefetch() 时遇到很多困难，我真的不明白何时以及如何使用它。有人可以帮我吗？我真的需要一些帮助。我的应用程序是这样的：我有一组大型 TFRecord 文件，每个文件都包含一些在馈送到我的网络之前要处理的原始记录。它们将被混合（不同的样本流），所以我要做的是：

def read_datasets(pattern, numFiles, numEpochs=125, batchSize=1024, take=dataLength):

    files = tf.data.Dataset.list_files(pattern)

    def _parse(x):
        x = tf.data.TFRecordDataset(x, compression_type='GZIP')
    return x

    np = 4 # half of the number of CPU cores
    dataset = files.interleave(_parse, cycle_length=numFiles, block_length=1, num_parallel_calls=np)\
    .map(lambda x: parse_tfrecord(x), num_parallel_calls=np)
    dataset = dataset.take(take)
    dataset = dataset.batch(batchSize)
    dataset = dataset.cache()
    dataset = dataset.prefetch(buffer_size=10)
    dataset = dataset.repeat(numEpochs)
    return dataset

interleave 函数中的 parse_tfrecord(x) 函数是数据应用于模型之前所需的预处理，我的猜测是预处理时间与网络的批处理时间相当。我的整个数据集（包括所有输入文件）包含大约 500 批 1024 个样本。我的问题是：

1-如果我进行缓存，我真的需要预取吗？

2- 映射、批处理、缓存、预取和重复的顺序是否正确？ …

随着最近升级到1.4版,Tensorflow包含tf.data在库核心中.在描述一个"主要的新功能" 版本1.4发行说明是tf.data.Dataset.apply(),这是一个"应用自定义转换功能的方法".这与现有的有tf.data.Dataset.map()什么不同？

我是 tensoflow 的新手，我想用我自己的数据（40x40 的图像）调整 MNIST 教程https://www.tensorflow.org/tutorials/layers。这是我的模型函数：

def cnn_model_fn(features, labels, mode):
        # Input Layer
        input_layer = tf.reshape(features, [-1, 40, 40, 1])

        # Convolutional Layer #1
        conv1 = tf.layers.conv2d(
                inputs=input_layer,
                filters=32,
                kernel_size=[5, 5],
                #  To specify that the output tensor should have the same width and height values as the input tensor
                # value can be "same" ou "valid"
                padding="same",
                activation=tf.nn.relu)

        # Pooling Layer #1
        pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

        # Convolutional Layer #2 and Pooling Layer #2
        conv2 …