TensorFlow导入数据详解

原文地址：https://www.tensorflow.org/programmers_guide/datasets

tf.data API 可以让人从简单可复用的piece中建立复杂的输入管道。例如，一个对于图像模型的管道，可能要从分布式文件系统中整合数据，对每个图片产生随机干扰，并且合并这些随机选择的图片到batch中用于训练；一个对于文字模型的管道可能涉及到从原始文本数据中提取符合， 利用查询表将它们转化成embedding identifier，并且整合不同长度的序列。

tf.data API 简化了大量数据、不同数据格式以及复杂转化的处理。

tf.data API带来了TensorFlow的两种新抽象：

• tf.data.Dataset : 表示元素的序列，其中每个元素包含了一个或多个Tensor对象。例如，一个图像数据管道中，一个元素可能是一个具有一对张量表示其图像数据和标签的训练样本 。有两个不同的方法创建dataset ：
  
  • 创造source (例如Dataset.from_tensor_slices()) 从一个或多个tf.Tensor对象中构建dataset
  • 使用transformation(例如Dataset.batch()) 从一个或多个tf.data.Dataset对象中构建dataset
• tf.data.Iterator : 是从dataset中提取元素的主要方式。该操作通过 Iterator.get_next() yield出 Dataset的下一个元素，一般作为输入管道和模型之间的接口。最简单的迭代器是 “one-shot iterator” ，用来迭代一次某个特定的Dataset。更复杂的使用中，Iterator.initializer操作可以用不同的dataset重新初始并且参数化一个迭代器，可以以此在一个程序中训练和验证数据多次。

基础机制

启动一个输入管道，需要首先定义source 。 为了从内存的张量中构建Dataset，可以使用 tf.data.Dataset.from_tensors() 或者
tf.data.Dataset.from_tensor_slices()，再或者，如果数据在硬盘上以推荐的TFRecord格式存储，可以构建一个tf.data.TFRecordDataset

拥有了Dataset对象以后，可以将它们转化为新的Dataset。例如Dataset.map() ， Dataset.batch() 等

最常用于使用Dataset的方式是使用一个迭代器(例如 Dataset.make_one_shot_iterator())。

tf.data.Iterator提供两种操作：

• Iterator.initializer (重新)初始化迭代器
• Iterator.get_next() 返回下一个元素的tf.Tensor对象

Dataset构建

dataset包括了含有相同结构的元素。一个元素包含一个或多个tf.Tensor对象，称作组件。每个组件有一个tf.DType 表示元素的类型；还有一个tf.TensorShape表示元素的形状。可以用Dataset.output_types和Dataset.output_shapes来检查:

dataset1 = tf.data.Dataset.from_tensor_slices(tf.random_uniform([4, 10]))
print(dataset1.output_types)  # ==> "tf.float32"
print(dataset1.output_shapes)  # ==> "(10,)"

dataset2 = tf.data.Dataset.from_tensor_slices(
   (tf.random_uniform([4]),
    tf.random_uniform([4, 100], maxval=100, dtype=tf.int32)))
print(dataset2.output_types)  # ==> "(tf.float32, tf.int32)"
print(dataset2.output_shapes)  # ==> "((), (100,))"

dataset3 = tf.data.Dataset.zip((dataset1, dataset2))
print(dataset3.output_types)  # ==> (tf.float32, (tf.float32, tf.int32))
print(dataset3.output_shapes)  # ==> "(10, ((), (100,)))"

给元素中的组件命名也很方便 :

dataset = tf.data.Dataset.from_tensor_slices(
   {"a": tf.random_uniform([4]),
    "b": tf.random_uniform([4, 100], maxval=100, dtype=tf.int32)})
print(dataset.output_types)  # ==> "{'a': tf.float32, 'b': tf.int32}"
print(dataset.output_shapes)  # ==> "{'a': (), 'b': (100,)}"  

以及转变操作 :

dataset1 = dataset1.map(lambda x: ...)

dataset2 = dataset2.flat_map(lambda x, y: ...)

# Note: Argument destructuring is not available in Python 3.
dataset3 = dataset3.filter(lambda x, (y, z): ...)

创建迭代器

有了表示输入数据的Dataset后，下一步是创建可以得到其中元素的迭代器，随着复杂程度的提高，tf.data API 提供以下迭代器:

• one-shot
• initializable
• reinitializable
• feedable

one-shot是最简单的迭代器，不需要明确的初始化，迭代一次，但不支持参数化：

dataset = tf.data.Dataset.range(100)
iterator = dataset.make_one_shot_iterator()
next_element = iterator.get_next()

for i in range(100):
  value = sess.run(next_element)
  assert i == value

目前，one-shot迭代器是唯一易于在 Estimator上使用的类型

initializable迭代器需要在使用前进行iterator.initializer的操作，虽然不方便，但支持参数化，可以使用一个或多个 tf.placeholder() 在初始化迭代器时占位：

max_value = tf.placeholder(tf.int64, shape=[])
dataset = tf.data.Dataset.range(max_value)
iterator = dataset.make_initializable_iterator()
next_element = iterator.get_next()

# Initialize an iterator over a dataset with 10 elements.
sess.run(iterator.initializer, feed_dict={max_value: 10})
for i in range(10):
  value = sess.run(next_element)
  assert i == value

# Initialize the same iterator over a dataset with 100 elements.
sess.run(iterator.initializer, feed_dict={max_value: 100})
for i in range(100):
  value = sess.run(next_element)
  assert i == value

reinitializable迭代器可以从多个不同的Dataset对象中初始化。例如，一个使用随机干扰以提升泛化能力的训练输入管道，和一个评估未修改数据上的预测的验证输入管道。这些管道一般使用不同的Dataset对象，但是这些对象有相同的结构：

# Define training and validation datasets with the same structure.
training_dataset = tf.data.Dataset.range(100).map(
    lambda x: x + tf.random_uniform([], -10, 10, tf.int64))
validation_dataset = tf.data.Dataset.range(50)

# A reinitializable iterator is defined by its structure. We could use the
# `output_types` and `output_shapes` properties of either `training_dataset`
# or `validation_dataset` here, because they are compatible.
iterator = tf.data.Iterator.from_structure(training_dataset.output_types,
                                           training_dataset.output_shapes)
next_element = iterator.get_next()

training_init_op = iterator.make_initializer(training_dataset)
validation_init_op = iterator.make_initializer(validation_dataset)

# Run 20 epochs in which the training dataset is traversed, followed by the
# validation dataset.
for _ in range(20):
  # Initialize an iterator over the training dataset.
  sess.run(training_init_op)
  for _ in range(100):
    sess.run(next_element)

  # Initialize an iterator over the validation dataset.
  sess.run(validation_init_op)
  for _ in range(50):
    sess.run(next_element)

feedable 迭代器可以和tf.placeholder一起使用，以通过相似的feed_dict机制，选择每一次tf.Session.run中的迭代器。它提供和reinitializable 迭代器相同的功能，但是不需要在选择迭代器启动dataset时就初始化迭代器：

# Define training and validation datasets with the same structure.
training_dataset = tf.data.Dataset.range(100).map(
    lambda x: x + tf.random_uniform([], -10, 10, tf.int64)).repeat()
validation_dataset = tf.data.Dataset.range(50)

# A feedable iterator is defined by a handle placeholder and its structure. We
# could use the `output_types` and `output_shapes` properties of either
# `training_dataset` or `validation_dataset` here, because they have
# identical structure.
handle = tf.placeholder(tf.string, shape=[])
iterator = tf.data.Iterator.from_string_handle(
    handle, training_dataset.output_types, training_dataset.output_shapes)
next_element = iterator.get_next()

# You can use feedable iterators with a variety of different kinds of iterator
# (such as one-shot and initializable iterators).
training_iterator = training_dataset.make_one_shot_iterator()
validation_iterator = validation_dataset.make_initializable_iterator()

# The `Iterator.string_handle()` method returns a tensor that can be evaluated
# and used to feed the `handle` placeholder.
training_handle = sess.run(training_iterator.string_handle())
validation_handle = sess.run(validation_iterator.string_handle())

# Loop forever, alternating between training and validation.
while True:
  # Run 200 steps using the training dataset. Note that the training dataset is
  # infinite, and we resume from where we left off in the previous `while` loop
  # iteration.
  for _ in range(200):
    sess.run(next_element, feed_dict={handle: training_handle})

  # Run one pass over the validation dataset.
  sess.run(validation_iterator.initializer)
  for _ in range(50):
    sess.run(next_element, feed_dict={handle: validation_handle})

从迭代器中获取数据

使用 Iterator.get_next() 方法。

当迭代器到达dataset尾部时，运行Iterator.get_next() 会raise一个tf.errors.OutOfRangeError。这个迭代器就处于不可用状态，必须重新初始化才可以使用。

dataset = tf.data.Dataset.range(5)
iterator = dataset.make_initializable_iterator()
next_element = iterator.get_next()

# Typically `result` will be the output of a model, or an optimizer's
# training operation.
result = tf.add(next_element, next_element)

sess.run(iterator.initializer)
print(sess.run(result))  # ==> "0"
print(sess.run(result))  # ==> "2"
print(sess.run(result))  # ==> "4"
print(sess.run(result))  # ==> "6"
print(sess.run(result))  # ==> "8"
try:
  sess.run(result)
except tf.errors.OutOfRangeError:
  print("End of dataset")  # ==> "End of dataset"

一个常见的方式是使用try-except 块：

sess.run(iterator.initializer)
while True:
  try:
    sess.run(result)
  except tf.errors.OutOfRangeError:
    break

如果每个元素都有嵌套结构，那么 Iterator.get_next() 会返回相同结构的一个或多个 tf.Tensor 对象：

dataset1 = tf.data.Dataset.from_tensor_slices(tf.random_uniform([4, 10]))
dataset2 = tf.data.Dataset.from_tensor_slices((tf.random_uniform([4]), tf.random_uniform([4, 100])))
dataset3 = tf.data.Dataset.zip((dataset1, dataset2))

iterator = dataset3.make_initializable_iterator()

sess.run(iterator.initializer)
next1, (next2, next3) = iterator.get_next()

评估next1，next2，next3中的任意一个，都将推动迭代器

读入输入数据

使用Numpy数组

如果所有的输入数据都在内存里，从中创建dataset最简单的方法是将它们转化为tf.Tensor对象，然后用Dataset.from_tensor_slices() :

# Load the training data into two NumPy arrays, for example using `np.load()`.
with np.load("/var/data/training_data.npy") as data:
  features = data["features"]
  labels = data["labels"]

# Assume that each row of `features` corresponds to the same row as `labels`.
assert features.shape[0] == labels.shape[0]

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

以上代码将feature和label数组以 tf.constant() 操作组合。这个适用于小数据集，但是浪费内存——会将数组内容复制多次，并且可能会遇到tf.GraphDef规定的2GB缓存限制。

作为替代，可以用tf.placeholder() 张量来定义Dataset ， 并在迭代器初始化时，把Numpy数组feed进去。

# Load the training data into two NumPy arrays, for example using `np.load()`.
with np.load("/var/data/training_data.npy") as data:
  features = data["features"]
  labels = data["labels"]

# Assume that each row of `features` corresponds to the same row as `labels`.
assert features.shape[0] == labels.shape[0]

features_placeholder = tf.placeholder(features.dtype, features.shape)
labels_placeholder = tf.placeholder(labels.dtype, labels.shape)

dataset = tf.data.Dataset.from_tensor_slices((features_placeholder, labels_placeholder))
# [Other transformations on `dataset`...]
dataset = ...
iterator = dataset.make_initializable_iterator()

sess.run(iterator.initializer, feed_dict={features_placeholder: features,
                                          labels_placeholder: labels})

使用TFRecord数据

# Creates a dataset that reads all of the examples from two files.
filenames = ["/var/data/file1.tfrecord", "/var/data/file2.tfrecord"]
dataset = tf.data.TFRecordDataset(filenames)

filenames参数可以是一个字符串、一个字符串列表或者一个字符串的tf.Tensor对象。因此，如果有两组文件分别用于训练和验证，可以使用tf.placeholder(tf.string) 来表示filenames，并且以适当的filename启动迭代器 :

filenames = tf.placeholder(tf.string, shape=[None])
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...)  # Parse the record into tensors.
dataset = dataset.repeat()  # Repeat the input indefinitely.
dataset = dataset.batch(32)
iterator = dataset.make_initializable_iterator()

# You can feed the initializer with the appropriate filenames for the current
# phase of execution, e.g. training vs. validation.

# Initialize `iterator` with training data.
training_filenames = ["/var/data/file1.tfrecord", "/var/data/file2.tfrecord"]
sess.run(iterator.initializer, feed_dict={filenames: training_filenames})

# Initialize `iterator` with validation data.
validation_filenames = ["/var/data/validation1.tfrecord", ...]
sess.run(iterator.initializer, feed_dict={filenames: validation_filenames})

使用文本数据

许多数据集分布成一个或多个文本文件，tf.data.TextLineDataset 提供了简单方式从一个或多个文件中提取行。

filenames = ["/var/data/file1.txt", "/var/data/file2.txt"]
dataset = tf.data.TextLineDataset(filenames)  

TextLineDataset 默认yield每个文件的每一行，有时可能不必如此，例如有些文件从一个标题栏开始，或者包含评论：这些行可以用 Dataset.skip() 和 Dataset.filter() 去除。为了在每个文件上分别应用这些转化，我们使用Dataset.flat_map() 为每个文件创造一个嵌套的数据集。

filenames = ["/var/data/file1.txt", "/var/data/file2.txt"]

dataset = tf.data.Dataset.from_tensor_slices(filenames)

# Use `Dataset.flat_map()` to transform each file as a separate nested dataset,
# and then concatenate their contents sequentially into a single "flat" dataset.
# * Skip the first line (header row).
# * Filter out lines beginning with "#" (comments).
dataset = dataset.flat_map(
    lambda filename: (
        tf.data.TextLineDataset(filename)
        .skip(1)
        .filter(lambda line: tf.not_equal(tf.substr(line, 0, 1), "#"))))

使用Dataset.map() 预处理数据

Dataset.map(f) 在每一个元素上进行所给函数f的操作来产生一个新数据集。函数f接受一个元素(tf.Tensor 对象)的输入 , 然后返回一个元素(tf.Tensor 对象)成为新数据集。

解析 tf.Example 协议缓冲区信息

许多输入管道从TFRecord格式文件中提取协议缓冲区信息(例如使用tf.python_io.TFRecordWriter 写入)，每个tf.train.Example 记录包含一个或多个“features”，输入管道一般将这些features转化为张量。

# Transforms a scalar string `example_proto` into a pair of a scalar string and
# a scalar integer, representing an image and its label, respectively.
def _parse_function(example_proto):
  features = {"image": tf.FixedLenFeature((), tf.string, default_value=""),
              "label": tf.FixedLenFeature((), tf.int32, default_value=0)}
  parsed_features = tf.parse_single_example(example_proto, features)
  return parsed_features["image"], parsed_features["label"]

# Creates a dataset that reads all of the examples from two files, and extracts
# the image and label features.
filenames = ["/var/data/file1.tfrecord", "/var/data/file2.tfrecord"]
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(_parse_function)

解码图像数据并调整大小

当训练用于图像数据的神经网络时，经常需要把不同大小的图片转化成统一大小。

# Reads an image from a file, decodes it into a dense tensor, and resizes it
# to a fixed shape.
def _parse_function(filename, label):
  image_string = tf.read_file(filename)
  image_decoded = tf.image.decode_image(image_string)
  image_resized = tf.image.resize_images(image_decoded, [28, 28])
  return image_resized, label

# A vector of filenames.
filenames = tf.constant(["/var/data/image1.jpg", "/var/data/image2.jpg", ...])

# `labels[i]` is the label for the image in `filenames[i].
labels = tf.constant([0, 37, ...])

dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))
dataset = dataset.map(_parse_function)

用tf.py_func() 使用任意的python逻辑

有时解析数据时需要使用外部python库，此时可以在Dataset.map() 上用tf.py_func() 操作调用：

import cv2

# Use a custom OpenCV function to read the image, instead of the standard
# TensorFlow `tf.read_file()` operation.
def _read_py_function(filename, label):
  image_decoded = cv2.imread(filename.decode(), cv2.IMREAD_GRAYSCALE)
  return image_decoded, label

# Use standard TensorFlow operations to resize the image to a fixed shape.
def _resize_function(image_decoded, label):
  image_decoded.set_shape([None, None, None])
  image_resized = tf.image.resize_images(image_decoded, [28, 28])
  return image_resized, label

filenames = ["/var/data/image1.jpg", "/var/data/image2.jpg", ...]
labels = [0, 37, 29, 1, ...]

dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))
dataset = dataset.map(
    lambda filename, label: tuple(tf.py_func(
        _read_py_function, [filename, label], [tf.uint8, label.dtype])))
dataset = dataset.map(_resize_function)

批处理数据集元素

简单批处理

最简单的批处理将n个连续的元素堆栈进一个元素中。Dataset.batch() 即是如此，有着与 tf.stack() 操作相同的限制，在元素的每个组件上应用操作：例如对于每个组件i，所有的元素都必须有相同大小的张量。

inc_dataset = tf.data.Dataset.range(100)
dec_dataset = tf.data.Dataset.range(0, -100, -1)
dataset = tf.data.Dataset.zip((inc_dataset, dec_dataset))
batched_dataset = dataset.batch(4)

iterator = batched_dataset.make_one_shot_iterator()
next_element = iterator.get_next()

print(sess.run(next_element))  # ==> ([0, 1, 2,   3],   [ 0, -1,  -2,  -3])
print(sess.run(next_element))  # ==> ([4, 5, 6,   7],   [-4, -5,  -6,  -7])
print(sess.run(next_element))  # ==> ([8, 9, 10, 11],   [-8, -9, -10, -11])  

使用填充批处理张量

上面的方法适用于相同大小的张量。然而很多模型的输入数据会是不同大小，Dataset.padded_batch() 操作可以通过指定填充它们的一个或多个尺寸来批量处理不同形状的张量。

dataset = tf.data.Dataset.range(100)
dataset = dataset.map(lambda x: tf.fill([tf.cast(x, tf.int32)], x))
dataset = dataset.padded_batch(4, padded_shapes=[None])

iterator = dataset.make_one_shot_iterator()
next_element = iterator.get_next()

print(sess.run(next_element))  # ==> [[0, 0, 0], [1, 0, 0], [2, 2, 0], [3, 3, 3]]
print(sess.run(next_element))  # ==> [[4, 4, 4, 4, 0, 0, 0],
                               #      [5, 5, 5, 5, 5, 0, 0],
                               #      [6, 6, 6, 6, 6, 6, 0],
                               #      [7, 7, 7, 7, 7, 7, 7]]

训练工作流

处理多次

tf.data API 提供两种主要方式来多次处理相同数据。

最简单的方式是使用 Dataset.repeat() 转换，例如建立一个数据集重复输入10次：

filenames = ["/var/data/file1.tfrecord", "/var/data/file2.tfrecord"]
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...)
dataset = dataset.repeat(10)
dataset = dataset.batch(32)

不提供参数的Dataset.repeat() 会无期限的重复输入。Dataset.repeat() 转换将其参数连接起来，而不用指示一次迭代的结束和下一次迭代的开始。

如果想在每一次迭代结束时收到信号，可以写一个循环catch tf.errors.OutOfRangeError。

filenames = ["/var/data/file1.tfrecord", "/var/data/file2.tfrecord"]
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...)
dataset = dataset.batch(32)
iterator = dataset.make_initializable_iterator()
next_element = iterator.get_next()

# Compute for 100 epochs.
for _ in range(100):
  sess.run(iterator.initializer)
  while True:
    try:
      sess.run(next_element)
    except tf.errors.OutOfRangeError:
      break

  # [Perform end-of-epoch calculations here.]

随机切割输入数据

Dataset.shuffle() 转换采取与tf.RandomShuffleQueue 相似的算法来随机切割输入数据：它维护一个固定大小的缓冲区，并从该缓冲区随机选择下一个元素

filenames = ["/var/data/file1.tfrecord", "/var/data/file2.tfrecord"]
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...)
dataset = dataset.shuffle(buffer_size=10000)
dataset = dataset.batch(32)
dataset = dataset.repeat()

使用高级API

tf.train.MonitoredTrainingSession API 简化了在分布式环境中运行TensorFlow的许多方面。它使用 tf.errors.OutOfRangeError 来表示训练已经完成，因此若要将其与tf.data API结合使用，推荐使用Dataset.make_one_shot_iterator() ：

filenames = ["/var/data/file1.tfrecord", "/var/data/file2.tfrecord"]
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...)
dataset = dataset.shuffle(buffer_size=10000)
dataset = dataset.batch(32)
dataset = dataset.repeat(num_epochs)
iterator = dataset.make_one_shot_iterator()

next_example, next_label = iterator.get_next()
loss = model_function(next_example, next_label)

training_op = tf.train.AdagradOptimizer(...).minimize(loss)

with tf.train.MonitoredTrainingSession(...) as sess:
  while not sess.should_stop():
    sess.run(training_op)

要在tf.estimator.Estimator 的 input_fn函数中使用 Dataset ，同样推荐使用Dataset.make_one_shot_iterator() ：

def dataset_input_fn():
  filenames = ["/var/data/file1.tfrecord", "/var/data/file2.tfrecord"]
  dataset = tf.data.TFRecordDataset(filenames)

  # Use `tf.parse_single_example()` to extract data from a `tf.Example`
  # protocol buffer, and perform any additional per-record preprocessing.
  def parser(record):
    keys_to_features = {
        "image_data": tf.FixedLenFeature((), tf.string, default_value=""),
        "date_time": tf.FixedLenFeature((), tf.int64, default_value=""),
        "label": tf.FixedLenFeature((), tf.int64,
                                    default_value=tf.zeros([], dtype=tf.int64)),
    }
    parsed = tf.parse_single_example(record, keys_to_features)

    # Perform additional preprocessing on the parsed data.
    image = tf.image.decode_jpeg(parsed["image_data"])
    image = tf.reshape(image, [299, 299, 1])
    label = tf.cast(parsed["label"], tf.int32)

    return {"image_data": image, "date_time": parsed["date_time"]}, label

  # Use `Dataset.map()` to build a pair of a feature dictionary and a label
  # tensor for each example.
  dataset = dataset.map(parser)
  dataset = dataset.shuffle(buffer_size=10000)
  dataset = dataset.batch(32)
  dataset = dataset.repeat(num_epochs)
  iterator = dataset.make_one_shot_iterator()

  # `features` is a dictionary in which each value is a batch of values for
  # that feature; `labels` is a batch of labels.
  features, labels = iterator.get_next()
  return features, labels