轉自https://www.cnblogs.com/hellcat/p/8569651.html

Dataset有兩個重要的類：Dataset和Iterator。

Dataset可以看作是相同型別“元素”的有序列表。在實際使用時，單個“元素”可以是向量，也可以是字串、圖片，甚至是tuple或者dict。

迭代器物件例項化(非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!

高維資料集使用

tf.data.Dataset.from_tensor_slices真正作用是切分傳入Tensor的第一個維度，生成相應的dataset，即第一維表明資料集中資料的數量，之後切分batch等操作都以第一維為基礎。

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 = 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!

字典使用

在實際使用中，我們可能還希望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!

複雜的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!

四、資料集處理方法

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異常。

更多的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。

更多的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 9

initializable 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更復雜，也更加少用，如果想要了解它們的功能，可以參閱官方介紹，這裡就不再贅述了。

總結

在非Eager模式下，Dataset中讀出的一個元素一般對應一個batch的Tensor，我們可以使用這個Tensor在計算圖中構建模型。

在Eager模式下，Dataset建立Iterator的方式有所不同，此時通過讀出的資料就是含有值的Tensor，方便除錯。