【TensorFlow學習一】TensorFlow全新的數據讀取方式：tf.data.Dataset

原文鏈接：https://www.cnblogs.com/hellcat/p/8569651.html#_label6

轉載自：http://www.cnblogs.com/hellcat/p/8569651.html#_label6

官方代碼：https://www.tensorflow.org/api_docs/python/tf/data/Dataset

Tensorflow中之前主要用的數據讀取方式主要有：

1. 建立placeholder，然後使用feed_dict將數據feed進placeholder進行使用。使用這種方法十分靈活，可以一下子將所有數據讀入內存，然後分batch進行feed；也可以建立一個Python的generator，一個batch一個batch的將數據讀入，並將其feed進placeholder。這種方法很直觀，用起來也比較方便靈活jian，但是這種方法的效率較低，難以滿足高速計算的需求。
2. 使用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.initializer operation 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，方便調試。