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重新初始并且参数化一个迭代器，可以以此在一个程序中训练和验证数据多次。
基本使用
1.数据集对象实例化：
dataset = tf.data.Dataset.from_tensor_slices(数据)
迭代器对象实例化(非Eager模式下)：
iterator = dataset.make_one_shot_iterator()
one_element = iterator.get_next()
import tensorflow as tf
import numpy as np
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() as sess:
for i in range(5):
print(sess.run(one_element))输出：1.0 2.0 3.0 4.0 5.0读取结束异常：
如果一个dataset中元素被读取完了，再尝试sess.run(one_element)的话，就会抛出tf.errors.OutOfRangeError异常，这个行为与使用队列方式读取数据的行为是一致的。
在实际程序中，可以在外界捕捉这个异常以判断数据是否读取完，综合以上三点请参考下面的代码：
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!")输出：1.0 2.0 3.0 4.0 5.0 end!2、高维数据集使用
tf.data.Dataset.from_tensor_slices真正作用是切分传入Tensor的第一个维度，生成相应的dataset，即第一维表明数据集中数据的数量，之后切分batch等操作都以第一维为基础。
dataset = tf.data.Dataset.from_tensor_slices(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!")[0.09787406 0.71672957]
[0.25681324 0.81974072]
[0.35186046 0.39362398]
[0.75228199 0.6534702 ]
[0.39695169 0.9341708 ]
end!3、字典使用
在实际使用中，我们可能还希望Dataset中的每个元素具有更复杂的形式，如每个元素是一个Python中的元组，或是Python中的词典。例如，在图像识别问题中，一个元素可以是{“image”: image_tensor, “label”: label_tensor}的形式，这样处理起来更方便，
注意，image_tensor、label_tensor和上面的高维向量一致，第一维表示数据集中数据的数量。相较之下，字典中每一个key值可以看做数据的一个属性，value则存储了所有数据的该属性值。
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))
})
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])}
end!4、复杂的tuple组合数据
类似的，可以使用组合的特征进行拼接
dataset = tf.data.Dataset.from_tensor_slices(
(np.array([1.0, 2.0, 3.0, 4.0, 5.0]), 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!")(1.0, array([6.55877282e-04, 6.63244735e-01]))
(2.0, array([0.04756927, 0.44968581]))
(3.0, array([0.97841076, 0.06465231]))
(4.0, array([0.46639246, 0.39146086]))
(5.0, array([0.61085016, 0.61609538]))
end!5.数据集处理方法
Dataset支持一类特殊的操作：Transformation。一个Dataset通过Transformation变成一个新的Dataset。通常我们可以通过Transformation完成数据变换，打乱，组成batch，生成epoch等一系列操作。
常用的Transformation有：
- map
- batch
- shuffle
- repeat
map
和python中的map类似，map接收一个函数，Dataset中的每个元素都会被当作这个函数的输入，并将函数返回值作为新的Dataset
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) # <-----
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!")输出：2.0 3.0 4.0 5.0 6.0 end!注意map函数可以使用num_parallel_calls参数加速
batch
batch就是将多个元素组合成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 ]])}
end!shuffle
shuffle的功能为打乱dataset中的元素，它有一个参数buffersize，表示打乱时使用的buffer的大小，建议舍的不要太小，一般是1000：
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.shuffle(buffer_size=5) # <-----
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': 3.0, 'b': array([0.82048268, 0.39821839])}
{'a': 4.0, 'b': array([0.42775421, 0.36749283])}
{'a': 1.0, 'b': array([0.09588742, 0.01954797])}
{'a': 2.0, 'b': array([0.10992948, 0.24416772])}
{'a': 5.0, 'b': array([0.15447616, 0.09005545])}
end!repeat
repeat的功能就是将整个序列重复多次，主要用来处理机器学习中的epoch，假设原先的数据是一个epoch，使用repeat(2)就可以将之变成2个epoch：
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.repeat(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.85180201, 0.1703507 ])}
{'a': 2.0, 'b': array([0.37874819, 0.81303628])}
{'a': 3.0, 'b': array([0.99560094, 0.56446562])}
{'a': 4.0, 'b': array([0.86341794, 0.69984075])}
{'a': 5.0, 'b': array([0.85026424, 0.74761098])}
{'a': 1.0, 'b': array([0.85180201, 0.1703507 ])}
{'a': 2.0, 'b': array([0.37874819, 0.81303628])}
{'a': 3.0, 'b': array([0.99560094, 0.56446562])}
{'a': 4.0, 'b': array([0.86341794, 0.69984075])}
{'a': 5.0, 'b': array([0.85026424, 0.74761098])}
end!注意，如果直接调用repeat()的话，生成的序列就会无限重复下去，没有结束，因此也不会抛出tf.errors.OutOfRangeError异常。
5.模拟读入磁盘图片与对应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来建立模型了。
help(tf.data.Dataset.map)
可见：
Help on function map in module tensorflow.python.data.ops.dataset_ops: map(self, map_func, num_parallel_calls=None) Maps `map_func` across this datset. Args: map_func: A function mapping a nested structure of tensors (having shapes and types defined by `self.output_shapes` and `self.output_types`) to another nested structure of tensors. num_parallel_calls: (Optional.) A `tf.int32` scalar `tf.Tensor`, representing the number elements to process in parallel. If not specified, elements will be processed sequentially. Returns: A `Dataset`.
由此可见map作为读取处理的关键步骤，是可以多线程加速的。
从Dataset初始化Dataset
讲完了如何读取数据，我们再回过头来讲获取数据的另一种方法：从Dataset获取。
之所以这么安排，是因为要结合输出才能理解这种获取方法的意义。
为了从dataset中初始化，这里有三个接口：
Dataset.map
Dataset.flat_map
Dataset.filter
这三个接口从字面上就很好理解，map就是对于给定Dataset中的每一个元素，都执行一次map操作，而flat_map就是既执行了map，还对数据进行了一次扁平化，也就是降维，而filter就是进行了一次过滤， 我们直接从代码的角度看以看这三个接口怎么用。
with tf.Session() as sess:
np.random.seed(0)#持有种子，使得每次随机出来的数组是一样的
normal_dataset = tf.data.Dataset.from_tensor_slices(np.random.randn(3,2,3))
np.random.seed(0)
map_dataset = tf.data.Dataset.from_tensor_slices(np.random.randn(3,2,3)).map(map_func=lambda x:x+1)#各数加一
np.random.seed(0)
flat_map_dataset = tf.data.Dataset.from_tensor_slices(np.random.randn(3,2,3)).flat_map(map_func=lambda x:tf.data.Dataset.from_tensor_slices(x))#输出的还是原来的x，但是降维了
np.random.seed(0)
filter_dataset = tf.data.Dataset.from_tensor_slices(np.random.randn(3,2,3)).filter(lambda x:x[0][0] > 0.8)#进行了一次过滤
iterator1 = tf.data.Iterator.from_structure(normal_dataset.output_types,
normal_dataset.output_shapes)
iterator2 = tf.data.Iterator.from_structure(map_dataset.output_types,
map_dataset.output_shapes)
iterator3 = tf.data.Iterator.from_structure(flat_map_dataset.output_types,
flat_map_dataset.output_shapes)
iterator4 = tf.data.Iterator.from_structure(filter_dataset.output_types,
filter_dataset.output_shapes)
next_element1 = iterator1.get_next()
next_element2 = iterator2.get_next()
next_element3 = iterator3.get_next()
next_element4 = iterator4.get_next()
training_init_op1 = iterator1.make_initializer(normal_dataset)
training_init_op2 = iterator2.make_initializer(map_dataset)
training_init_op3 = iterator3.make_initializer(flat_map_dataset)
training_init_op4 = iterator4.make_initializer(filter_dataset)
print("normal:")
sess.run(training_init_op1)
for _ in range(3):
print(sess.run(next_element1))
print("map:")
sess.run(training_init_op2)
for _ in range(3):
print(sess.run(next_element2))
print("falt_map:")
sess.run(training_init_op3)
for _ in range(6):
print(sess.run(next_element3))
print("filter:")
sess.run(training_init_op4)
for _ in range(2):
print(sess.run(next_element4))
output:
normal:
[[ 1.76405235 0.40015721 0.97873798]
[ 2.2408932 1.86755799 -0.97727788]]
[[ 0.95008842 -0.15135721 -0.10321885]
[ 0.4105985 0.14404357 1.45427351]]
[[ 0.76103773 0.12167502 0.44386323]
[ 0.33367433 1.49407907 -0.20515826]]
map:
[[ 2.76405235 1.40015721 1.97873798]
[ 3.2408932 2.86755799 0.02272212]]
[[ 1.95008842 0.84864279 0.89678115]
[ 1.4105985 1.14404357 2.45427351]]
[[ 1.76103773 1.12167502 1.44386323]
[ 1.33367433 2.49407907 0.79484174]]
#各数加一了
falt_map:
[ 1.76405235 0.40015721 0.97873798]
[ 2.2408932 1.86755799 -0.97727788]
[ 0.95008842 -0.15135721 -0.10321885]
[ 0.4105985 0.14404357 1.45427351]
[ 0.76103773 0.12167502 0.44386323]
[ 0.33367433 1.49407907 -0.20515826]
#这里降维成一维数组了
filter:
[[ 1.76405235 0.40015721 0.97873798]
[ 2.2408932 1.86755799 -0.97727788]]
[[ 0.95008842 -0.15135721 -0.10321885]
[ 0.4105985 0.14404357 1.45427351]]代码虽然很大一段，需要理解的东西却很少， 首先，我们定义了一个3*2*3的随机多维数组，可以看到
正常的输出就是输出3个2*3的数组
而map的作用我这里写的是各数加一，所以输出的是3个2*3的各数加一的数组
flat_map的作用是降维，所以输出的是6个1*3的数组
filter的作用是过滤，所以输出的是我的过滤内容：[0][0]元素大于0.8的，由于最有一个数组其元素为0.76103773，被过滤掉了
6、更多的Dataset创建方法
除了tf.data.Dataset.from_tensor_slices外，目前Dataset API还提供了另外三种创建Dataset的方式：
- tf.data.TextLineDataset()：这个函数的输入是一个文件的列表，输出是一个dataset。dataset中的每一个元素就对应了文件中的一行。可以使用这个函数来读入CSV文件。
- tf.data.FixedLengthRecordDataset()：这个函数的输入是一个文件的列表和一个record_bytes，之后dataset的每一个元素就是文件中固定字节数record_bytes的内容。通常用来读取以二进制形式保存的文件，如CIFAR10数据集就是这种形式。
- tf.data.TFRecordDataset()：顾名思义，这个函数是用来读TFRecord文件的，dataset中的每一个元素就是一个TFExample。
7.更多的iterator创建方法
在非Eager模式下，最简单的创建Iterator的方法就是通过dataset.make_one_shot_iterator()来创建一个one shot iterator。
除了这种one shot iterator外，还有三个更复杂的Iterator，即：
- initializable iterator
- reinitializable iterator
- feedable iterator
initializable iterator方法要在使用前通过sess.run()来初始化，使用initializable iterator，可以将placeholder代入Iterator中，实现更为灵活的数据载入，实际上占位符引入了dataset对象创建中，我们可以通过feed来控制数据集合的实际情况。
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)
print(value)
assert i == value输出：0 1 2 3 4 5 6 7 8 9initializable iterator还有一个功能：读入较大的数组。
在使用tf.data.Dataset.from_tensor_slices(array)时，实际上发生的事情是将array作为一个tf.constants保存到了计算图中。当array很大时，会导致计算图变得很大，给传输、保存带来不便。这时，我们可以用一个placeholder取代这里的array，并使用initializable iterator，只在需要时将array传进去，这样就可以避免把大数组保存在图里，示例代码为（来自官方例程）
# 从硬盘中读入两个Numpy数组
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})可见，在上面程序中，feed也遵循着类似字典一样的规则，创建两个占位符(keys)，给data_holder去feed数据文件，给label_holder去feed标签文件。
reinitializable iterator和feedable iterator相比initializable iterator更复杂，也更加少用，如果想要了解它们的功能，可以参阅官方介绍，这里就不再赘述了。
8、总结
在非Eager模式下，Dataset中读出的一个元素一般对应一个batch的Tensor，我们可以使用这个Tensor在计算图中构建模型。
在Eager模式下，Dataset建立Iterator的方式有所不同，此时通过读出的数据就是含有值的Tensor，方便调试。
转载：https://www.cnblogs.com/hellcat/p/8569651.html
扫一扫
2364
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
