官方代码：https://www.tensorflow.org/api_docs/python/tf/data/Dataset
Tensorflow中之前主要用的数据读取方式主要有：
- 建立placeholder，然后使用feed_dict将数据feed进placeholder进行使用。使用这种方法十分灵活，可以一下子将所有数据读入内存，然后分batch进行feed；也可以建立一个Python的generator，一个batch一个batch的将数据读入，并将其feed进placeholder。这种方法很直观，用起来也比较方便灵活jian，但是这种方法的效率较低，难以满足高速计算的需求。
- 使用TensorFlow的QueueRunner，通过一系列的Tensor操作，将磁盘上的数据分批次读入并送入模型进行使用。这种方法效率很高，但因为其牵涉到Tensor操作，不够直观，也不方便调试，所有有时候会显得比较困难。使用这种方法时，常用的一些操作包括tf.TextLineReader，tf.FixedLengthRecordReader以及tf.decode_raw等等。如果需要循环，条件操作，还需要使用TensorFlow的tf.while_loop，tf.case等操作。这种方式，可以参考原作者之前的一篇文章：十图详解TensorFlow数据读取机制）。。同时就是cifar10的例子，可以参看https://blog.csdn.net/lyb3b3b/article/details/86315662
Dataset API同时支持从内存和硬盘的读取，相比之前的两种方法在语法上更加简洁易懂。此外，如果想要用到TensorFlow新出的Eager模式，就必须要使用Dataset API来读取数据。
tf.data.Dataset的API导入
在tf 1.3.0版本中，Dataset API是放在contrib包中的：
tf.contrib.data.Dataset
从tf 1.4.0开始该API独立出来：
tf.data.Dataset
一、基本概念：Dataset与Iterator
在初学时，我们只需要关注两个最重要的基础类：Dataset和Iterator。
Dataset可以看作是相同类型“元素”的有序列表。在实际使用时，单个“元素”可以是向量，也可以是字符串、图片，甚至是tuple或者dict。
from_tensor_slices是这个Dataset类的一个方法
先tf.data.Dataset.from_tensor_slices产生数据集Dataset，经过实例化，才产生迭代器Iterator。
注意迭代器Iterator分为：
iterator = dataset.make_one_shot_iterator() 只能读一次
iterator = dataset.make_initializable_iterator() （这个需要iterator.initializer初始化）
-
import tensorflow
as tf
-
import numpy
as np
-
'''创建dataset'''
-
dataset = tf.data.Dataset.from_tensor_slices(np.array([
1.0,
2.0,
3.0,
4.0,
5.0]))
-
-
'''实例化iterator'''
-
iterator = dataset.make_one_shot_iterator()
-
one_element = iterator.get_next()
-
with tf.Session()
as sess:
-
for i
in range(
5):
-
print(sess.run(one_element))
#则输出1.0 2.0 3.0 4.0 5.0
-
#或者
-
#不过，make_initializable_iterator的情况需要初始化
-
iterator = dataset.make_initializable_iterator()
-
next_element = iterator.get_next()
-
with tf.Session()
as sess:
-
#注意：这里多了一个初始化，
-
sess.run(iterator.initializer)
-
for i
in range(
5):
-
print(sess.run(next_element))
#则输出1.0 2.0 3.0 4.0 5.0
先使用dataset=tf.data.Dataset.from_tensor_slices创建dataset，然后使用iterator = dataset.make_one_shot_iterator()从dataset中实例化了一个Iterator，这个Iterator是一个“one shot iterator”，即只能从头到尾读取一次。one_element = iterator.get_next()表示从iterator里取出一个元素。上面这是非Eager模式，所以one_element只是一个Tensor，并不是一个实际的值。调用sess.run(one_element)后，才能真正地取出一个值。
且当一个dataset中的元素被读取完了，再尝试sess.run(one_element)会报tf.errors.OutOfRangeError异常，这个行为与使用队列方式读取数据的行为是一致的。在实际程序中，可以在外界捕捉这个异常以判断数据是否读取完，如：try … except语句。
-
dataset = tf.data.Dataset.from_tensor_slices(np.array([
1.0,
2.0,
3.0,
4.0,
5.0]))
-
iterator = dataset.make_one_shot_iterator()
-
one_element = iterator.get_next()
-
with tf.Session(config=config)
as sess:
-
try:
-
while
True:
-
print(sess.run(one_element))
-
except tf.errors.OutOfRangeError:
-
print(
"end!")
在Eager模式中（正常都是非Eager模式）如下例，创建Iterator的方式有所不同。是通过tfe.Iterator(dataset)的形式直接创建Iterator并迭代。迭代时可以直接取出值，不需要使用sess.run()：
-
import tensorflow.contrib.eager
as tfe
-
tfe.enable_eager_execution()
-
dataset = tf.data.Dataset.from_tensor_slices(np.array([
1.0,
2.0,
3.0,
4.0,
5.0]))
-
for one_element
in tfe.Iterator(dataset):
-
print(one_element)
二、高维数据集使用
tf.data.Dataset.from_tensor_slices真正的作用是切分传入Tensor的第一个维度，生成相应的dataset。
例如：
dataset = tf.data.Dataset.from_tensor_slices(np.random.uniform(size=(5, 2)))
传入的数值是一个矩阵，它的形状为(5, 2)，tf.data.Dataset.from_tensor_slices就会切分它形状上的第一个维度，最后生成的dataset中一个含有5个元素，每个元素的形状是(2, )，即每个元素是矩阵的一行。
在实际使用中，我们可能还希望Dataset中的每个元素具有更复杂的形式，如每个元素是一个Python中的元组，或是Python中的词典。
例如，输入是训练集和标签的tuple，生成的每条记录也是tuple
-
dataset = tf.contrib.data.Dataset.from_tensor_slices(
-
( np.random.uniform(size=(
5,
2)), np.
array([
1.0,
2.0,
3.0,
4.0,
5.0])))
-
iterator = dataset.make_one_shot_iterator()
-
one_element = iterator.get_next()
-
with tf.Session()
as sess:
-
try:
-
while
True:
-
print(sess.run(one_element))
-
except tf.errors.OutOfRangeError:
-
print(
"end!")
-
输出：
-
(
array([
6.55877282e-04,
6.63244735e-01]),
1.0)
-
(
array([
0.04756927,
0.44968581]),
2.0)
-
(
array([
0.97841076,
0.06465231]),
3.0)
-
(
array([
0.46639246,
0.39146086]),
4.0)
-
(
array([
0.61085016,
0.61609538]),
5.0)
例如，在图像识别问题
一个元素可以是{“image”: image_tensor, “label”: label_tensor}的形式，这样处理起来更方便。
tf.data.Dataset.from_tensor_slices同样支持创建这种dataset，例如我们可以让每一个元素是一个词典。
-
dataset = tf.contrib.data.Dataset.from_tensor_slices(
-
{
-
"a": np.
array([
1.0,
2.0,
3.0,
4.0,
5.0]),
-
"b": np.random.uniform(size=(
5,
2))
-
}
-
)
-
iterator = dataset.make_one_shot_iterator()
-
one_element = iterator.get_next()
-
with tf.Session(config=config)
as sess:
-
try:
-
while
True:
-
print(sess.run(one_element))
-
except tf.errors.OutOfRangeError:
-
print(
"end!")
-
输出：
-
{
'a':
1.0,
'b':
array([
0.31721037,
0.33378767])}
-
{
'a':
2.0,
'b':
array([
0.99221946,
0.65894961])}
-
{
'a':
3.0,
'b':
array([
0.98405468,
0.11478854])}
-
{
'a':
4.0,
'b':
array([
0.95311317,
0.57432678])}
-
{
'a':
5.0,
'b':
array([
0.46067428,
0.19716722])}
这时函数会分别切分”a”中的数值以及”b”中的数值，最终dataset中的一个元素就是类似于{“a”: 1.0, “b”: [0.9, 0.1]}的形式。
三、对Dataset中的元素做变换
Dataset支持一类特殊的操作：Transformation。一个Dataset通过Transformation变成一个新的Dataset。通常我们可以通过Transformation完成数据变换，打乱，组成batch，生成epoch等一系列操作。
常用的Transformation有：
- Map
- batch
- shuffle
- repeat
1 .map
map接收一个函数，Dataset中的每个元素都会被当作这个函数的输入，并将函数返回值作为新的Dataset，如我们可以对dataset中每个元素的值加1:
-
dataset = tf.data.Dataset.from_tensor_slices(np.array([
1.0,
2.0,
3.0,
4.0,
5.0]))
-
dataset = dataset.map(
lambda x: x +
1)
# 2.0, 3.0, 4.0, 5.0, 6.0
2.batch
batch就是将多个元素组合成batch，如下面的程序将dataset中的每个元素组成了大小为32的batch:
-
dataset = tf.data.Dataset.from_tensor_slices(
-
{
-
"a": np.
array([
1.0,
2.0,
3.0,
4.0,
5.0]),
-
"b": np.random.uniform(size=(
5,
2))
-
})
-
dataset = dataset.batch(
2)
-
iterator = dataset.make_one_shot_iterator()
-
one_element = iterator.get_next()
-
with tf.Session(config=config)
as sess:
-
try:
-
while
True:
-
print(sess.run(one_element))
-
except tf.errors.OutOfRangeError:
-
print(
"end!")
-
输出
-
{
'a':
array([
1.,
2.]),
'b':
array([[
0.87466134,
0.21519021], [
0.6123372 ,
0.95722733]])}
-
{
'a':
array([
3.,
4.]),
'b':
array([[
0.76964374,
0.22445015], [
0.08313089,
0.60531841]])}
-
{
'a':
array([
5.]),
'b':
array([[
0.37901654,
0.3955096 ]])}
3.shuffle
shuffle的功能为打乱dataset中的元素，它有一个参数buffersize，表示打乱时使用的buffer的大小：
dataset = dataset.shuffle(buffer_size=10000)
4.repeat
repeat的功能就是将整个序列重复多次，主要用来处理机器学习中的epoch，假设原先的数据是一个epoch，使用repeat(5)就可以将之变成5个epoch：
dataset = dataset.repeat(5)
如果直接调用repeat()的话，生成的序列就会无限重复下去，没有结束，因此也不会抛出tf.errors.OutOfRangeError异常：dataset = dataset.repeat()
读入磁盘图片与对应label
我们可以来考虑一个简单，但同时也非常常用的例子：读入磁盘中的图片和图片相应的label，并将其打乱，组成batch_size=32的训练样本。在训练时重复10个epoch。
官方示例程序修改而来：
-
# 函数的功能时将filename对应的图片文件读进来，并缩放到统一的大小
-
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
-
-
# 图片文件的列表
-
filenames = tf.constant([
"/var/data/image1.jpg",
"/var/data/image2.jpg", ...])
-
# label[i]就是图片filenames[i]的label
-
labels = tf.constant([
0,
37, ...])
-
-
# 此句后dataset中的一个元素是(filename, label)
-
dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))
-
-
# 此句后dataset中的一个元素是(image_resized, label)
-
dataset = dataset.map(_parse_function)
-
-
# 此句后dataset中的一个元素是(image_resized_batch, label_batch)
-
dataset = dataset.shuffle(buffersize=
1000).batch(
32).repeat(
10)
这个过程中，dataset经历三次转变：
- 运行dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))后，dataset的一个元素是(filename, label)。filename是图片的文件名，label是图片对应的标签。
- 之后通过map，将filename对应的图片读入，并缩放为28x28的大小。此时dataset中的一个元素是(image_resized, label)。
- 最后，dataset.shuffle(buffersize=1000).batch(32).repeat(10)的功能是：在每个epoch内将图片打乱组成大小为32的batch，并重复10次。最终，dataset中的一个元素是(image_resized_batch, label_batch)，image_resized_batch的形状为(32, 28, 28, 3)，而label_batch的形状为(32, )，接下来我们就可以用这两个Tensor来建立模型了。
三、Dataset的其他创建方法
除了tf.data.Dataset外，目前Dataset API还提供了另外三种创建Dataset的方式：
- tf.data.TextLineDataset()：这个函数的输入是一个文件的列表，输出是一个dataset。dataset中的每一个元素就对应了文件中的一行。可以使用这个函数来读入CSV文件。
- tf.data.FixedLengthRecordDataset()：这个函数的输入是一个文件的列表和一个record_bytes，之后dataset的每一个元素就是文件中固定字节数record_bytes的内容。通常用来读取以二进制形式保存的文件，如CIFAR10数据集就是这种形式。
- tf.data.TFRecordDataset()：顾名思义，这个函数是用来读TFRecord文件的，dataset中的每一个元素就是一个TFExample。
四、创建iterator的两种方式
一般来说就是上文中说的两种方式：
make_one_shot_iterator
在非Eager模式下，最简单的创建Iterator的方法就是通过dataset.make_one_shot_iterator()来创建一个one shot iterator。
Note: The returned iterator will be initialized automatically. A "one-shot" iterator does not currently support re-initialization.
注意：这个迭代器自动初始化，也不支持重新初始化
make_initializable_iterator
Note: The returned iterator will be in an uninitialized state, and you must run the
iterator.initializeroperation before using it:
注意：返回的迭代器处于未初始化状态，必须使用iterator.initializer操作初始化
initializable iterator必须要在使用前通过sess.run()来初始化。使用initializable iterator，可以将placeholder代入Iterator中，这可以方便我们通过参数快速定义新的Iterator。一个简单的initializable iterator使用示例:
-
limit = tf.placeholder(dtype=tf.int32, shape=[])
-
dataset = tf.data.Dataset.from_tensor_slices(tf.range(
start=
0,
limit=
limit))
-
iterator = dataset.make_initializable_iterator()
-
next_element = iterator.get_next()
-
with tf.Session()
as sess:
-
sess.run(iterator.initializer, feed_dict={
limit:
10})
-
for i
in
range(
10):
-
value = sess.run(next_element)
-
assert i ==
value
此时的limit相当于一个“参数”，它规定了Dataset中数的“上限”。
initializable iterator还有一个功能：读入较大的数组。
在使用tf.data.Dataset.from_tensor_slices(array)时，实际上发生的事情是将array作为一个tf.constants保存到了计算图中。当array很大时，会导致计算图变得很大，给传输、保存带来不便。这时，我们可以用一个placeholder取代这里的array，并使用initializable iterator，只在需要时将array传进去，这样就可以避免把大数组保存在图里，示例代码为（来自官方例程）：
-
with np.load(
"/var/data/training_data.npy")
as
data:
-
features =
data[
"features"]
-
labels =
data[
"labels"]
-
-
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))
-
iterator = dataset.make_initializable_iterator()
-
sess.run(iterator.initializer, feed_dict={features_placeholder: features,
-
labels_placeholder: labels})
最后，这是一个相对完整的例子。
next_element = iterator.get_next() 产生了一个get_next()操作
运行一下bx_data, by_data = sess.run(next_element)，则产生了一次批次的数据
-
'''tfx和tfy占位符，其实只是用于导入np数据集。 和模型的输入没关系'''
-
tfx = tf.placeholder(npx_train.dtype, npx_train.shape)
-
tfy = tf.placeholder(npy_train.dtype, npy_train.shape)
-
-
dataset = tf.contrib.data.Dataset.from_tensor_slices((tfx, tfy))
-
dataset = dataset.shuffle(buffer_size=
1000)
# choose data randomly from this buffer
-
dataset = dataset.batch(
32)
# batch size you will use
-
dataset = dataset.repeat(
3)
#重复3个epochs，如果是repeat(),则无限制
-
iterator = dataset.make_initializable_iterator()
# later we have to initialize this one
-
sess = tf.Session()
-
'''iterator必须要在使用前通过sess.run()来初始化，这里喂的数据npx_train和npy_train是np数组'''
-
sess.run(iterator.initializer,feed_dict={tfx: npx_train, tfy: npy_train})
-
'''netx_element是一个产生批次的operation，run()一下就产生一个批次'''
-
next_element = iterator.get_next()
-
-
在使用的时候：
-
bx_data, by_data = sess.run(next_element)
#运行一下产生一个批次数据
-
_, trainloss = sess.run([train, loss],feed_dict={bx:bx_data,by:by_data})
总结
本文主要介绍了Dataset API的基本架构：Dataset类和Iterator类，以及它们的基础使用方法。
在非Eager模式下，Dataset中读出的一个元素一般对应一个batch的Tensor，我们可以使用这个Tensor在计算图中构建模型。
在Eager模式下，Dataset建立Iterator的方式有所不同，此时通过读出的数据就是含有值的Tensor，方便调试。
1021
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
