從1.4版本起數(shù)據(jù)集框架從tf.contrib.data遷移到了tf.data，成為了TensorFlow的核心組成部件瓜晤。
在數(shù)據(jù)集框架中棍厂，每一個數(shù)據(jù)集代表一個數(shù)據(jù)的來源：數(shù)據(jù)可以是一個張量丸逸，一個TFRecord文件锦援，一個文本文件蝗碎，等等湖笨。由于訓(xùn)練數(shù)據(jù)通常無法全部寫入內(nèi)存中，從數(shù)據(jù)集中讀取數(shù)據(jù)時通常需要使用一個迭代器按順序進行讀取衍菱，數(shù)據(jù)集也是計算圖中的一個節(jié)點赶么。

從一個張量中創(chuàng)建數(shù)據(jù)集

• from_tensor_slices：表示從張量中獲取數(shù)據(jù)。
• make_one_shot_iterator():表示只將數(shù)據(jù)讀取一次脊串，然后就拋棄這個數(shù)據(jù)了辫呻。

input_data = [1,2,3,5,8]
dataset = tf.data.Dataset.from_tensor_slices(input_data)
iterator = dataset.make_one_shot_iterator()
x = iterator.get_next()

dataset中的常用函數(shù)

• dataset = dataset.map(parser)：map是在數(shù)據(jù)集中的最常用的操作，表示對數(shù)據(jù)集中的每一條數(shù)據(jù)都調(diào)用參數(shù)中指定的parser方法琼锋，對每一條數(shù)據(jù)處理后放闺，map將處理后的數(shù)據(jù)包裝成一個新的數(shù)據(jù)集后返回。
  搭配lambda函數(shù)是最為常用的形式

dataset = dataset.map( lambda x :preprocess_for_train(x, image_size, image_size, None)

• dataset = dataset.shuffle(buffer_size):buffle的機制是在內(nèi)存緩沖區(qū)中保存一個buffer_size條數(shù)據(jù)缕坎，每讀入一條數(shù)據(jù)后怖侦，從這個緩沖區(qū)中隨機選擇一條數(shù)據(jù)進行輸出，緩沖區(qū)的大小越大谜叹，隨機的性能就越好匾寝，但是也更耗費內(nèi)存。
• dataset = dataset.batch(batch_size)
• dataset = dataset.repeat(N) 表示將數(shù)據(jù)復(fù)制N份
• concatenate()：表示將兩個數(shù)據(jù)集順序連接起來荷腊。
• take(N)：從數(shù)據(jù)集中讀取前N項數(shù)據(jù)艳悔。
• skip(N)：表示在數(shù)據(jù)集中跳過前N項數(shù)據(jù)。
• flap_map()表示從多個數(shù)據(jù)集中輪流讀取數(shù)據(jù)女仰。

制作詞匯表

• counter = collections.Counter()：創(chuàng)作計數(shù)器counter[word] += 1
• sorted_word_to_cnt = sorted(counter.items(), key=itemgetter(1), reverse=True)：表示根據(jù)詞頻對單詞進行排序猜年。

operator.itemgetter函數(shù)
operator模塊提供的itemgetter函數(shù)用于獲取對象的哪些維的數(shù)據(jù)，參數(shù)為一些序號疾忍∏峭猓看下面的例子

a = [1,2,3] 
>>> b=operator.itemgetter(1)      //定義函數(shù)b，獲取對象的第1個域的值
>>> b(a) 

2

>>> b=operator.itemgetter(1,0)  //定義函數(shù)b一罩，獲取對象的第1個域和第0個的值
>>> b(a) 
(2, 1)

要注意杨幼，operator.itemgetter函數(shù)獲取的不是值，而是定義了一個函數(shù)擒抛，通過該函數(shù)作用到對象上才能獲取值推汽。

• vocab = [w.strip() for w in f_vocab.readlines()]讀取詞匯表的信息。
• word_to_id = {k: v for v, k in enumerate(vocab)}制作映射字典
• return word_to_id[word] if word in word_to_id else word_to_id["<unk>"]對不在詞匯表中的單詞返回"<unk>"的id
• words = line.strip().split() + ["<eos>"] =讀取單詞并添加<eos>結(jié)束符,
  out_line = ' '.join([str(get_id(w)) for w in words]) + '\n',將單詞數(shù)據(jù)用id數(shù)據(jù)代換歧沪。

import codecs
import collections
from operator import itemgetter
MODE = "PTB"    # 將MODE設(shè)置為"PTB", "TRANSLATE_EN", "TRANSLATE_ZH"之一。

if MODE == "PTB":             # PTB數(shù)據(jù)處理
    RAW_DATA = "../../datasets/PTB_data/ptb.train.txt"  # 訓(xùn)練集數(shù)據(jù)文件
    VOCAB_OUTPUT = "ptb.vocab"                         # 輸出的詞匯表文件
elif MODE == "TRANSLATE_ZH":  # 翻譯語料的中文部分
    RAW_DATA = "../../datasets/TED_data/train.txt.zh"
    VOCAB_OUTPUT = "zh.vocab"
    VOCAB_SIZE = 4000
elif MODE == "TRANSLATE_EN":  # 翻譯語料的英文部分
    RAW_DATA = "../../datasets/TED_data/train.txt.en"
    VOCAB_OUTPUT = "en.vocab"
    VOCAB_SIZE = 10000
# 對單詞按照詞頻進行排序
counter = collections.Counter()
with codecs.open(RAW_DATA, "r", "utf-8") as f:
    for line in f:
        for word in line.strip().split():
            counter[word] += 1

# 按詞頻順序?qū)卧~進行排序莲组。
sorted_word_to_cnt = sorted(counter.items(), key=itemgetter(1), reverse=True)

sorted_words = [x[0] for x in sorted_word_to_cnt]
# 插入特殊符號
if MODE == "PTB":
    # 稍后我們需要在文本換行處加入句子結(jié)束符"<eos>"诊胞，這里預(yù)先將其加入詞匯表。
    sorted_words = ["<eos>"] + sorted_words
elif MODE in ["TRANSLATE_EN", "TRANSLATE_ZH"]:
    # 在9.3.2小節(jié)處理機器翻譯數(shù)據(jù)時，除了"<eos>"以外撵孤，還需要將"<unk>"和句子起始符
    # "<sos>"加入詞匯表迈着，并從詞匯表中刪除低頻詞匯。
    sorted_words = ["<unk>", "<sos>", "<eos>"] + sorted_words
    if len(sorted_words) > VOCAB_SIZE:
        sorted_words = sorted_words[:VOCAB_SIZE]
# 保存
with codecs.open(VOCAB_OUTPUT, 'w', 'utf-8') as file_output:
    for word in sorted_words:
        file_output.write(word + "\n")
# 讀取詞匯表邪码，并建立詞匯到單詞編號的映射裕菠。
with codecs.open(VOCAB, "r", "utf-8") as f_vocab:
    vocab = [w.strip() for w in f_vocab.readlines()]
word_to_id = {k: v for (k, v) in zip(vocab, range(len(vocab)))}

# 如果出現(xiàn)了不在詞匯表內(nèi)的低頻詞，則替換為"unk"闭专。
def get_id(word):
    return word_to_id[word] if word in word_to_id else word_to_id["<unk>"]

制作訓(xùn)練數(shù)據(jù)

• tf.string_split( source, delimiter=' ', skip_empty=True ):返回的是一個sparseTensor ,TensorFlow使用三個dense tensor來表達(dá)一個sparse tensor：indices奴潘、values、dense_shape影钉。indices表示索引画髓，values表示索引處的值，shape表示形狀平委。例如tf.SparseTensorValue(indices=[[0, 0], [1, 2]], values=[1.1, 1.2], dense_shape=[2,6])奈虾，.values是取出對應(yīng)的tensor值。

return : A SparseTensor of rank 2, the strings split according to the delimiter. The first column of the indices corresponds to the row in source and the second column corresponds to the index of the split component in this row.

• tf.string_to_number(string, tf.int32) 類型轉(zhuǎn)換廉赔。
• dataset.map(lambda x: (x, tf.size(x))) 獲取數(shù)據(jù)和對應(yīng)的lenth肉微。
• dataset = tf.data.Dataset.zip((src_data, trg_data))將源數(shù)據(jù)和目標(biāo)數(shù)據(jù)進行合并

通過zip操作將兩個Dataset合并為一個Dataset。
現(xiàn)在每個Dataset中每一項數(shù)據(jù)ds由4個張量組成：
ds[0][0]是源句子
ds[0][1]是源句子長度
ds[1][0]是目標(biāo)句子
ds[1][1]是目標(biāo)句子長度

• ((src_input, src_len), (trg_label, trg_len)) = (src_tuple, trg_tuple) 進行數(shù)據(jù)的解包
• src_len_ok = tf.logical_and( tf.greater(src_len, 1), tf.less_equal(src_len, MAX_LEN))刪除過小或者過大的數(shù)據(jù)蜡塌。
• dataset = dataset.filter(FilterLength) 根據(jù)條件過濾掉過長或者過短的句子碉纳。
• 因為tf中的dynamic_rnn不要求每一個batch的長度是一樣的，所以padded的時候岗照，只要保證一個batch內(nèi)的形狀是一樣的就行了dataset.padded_batch(batch_size, padded_shapes)村象。

# 使用Dataset從一個文件中讀取一個語言的數(shù)據(jù)。
# 數(shù)據(jù)的格式為每行一句話攒至，單詞已經(jīng)轉(zhuǎn)化為單詞編號厚者。
def MakeDataset(file_path):
    dataset = tf.data.TextLineDataset(file_path)
    # 根據(jù)空格將單詞編號切分開并放入一個一維向量。
    dataset = dataset.map(lambda string: tf.string_split([string]).values)
    # 將字符串形式的單詞編號轉(zhuǎn)化為整數(shù)迫吐。
    dataset = dataset.map(
        lambda string: tf.string_to_number(string, tf.int32))
    # 統(tǒng)計每個句子的單詞數(shù)量库菲，并與句子內(nèi)容一起放入Dataset中。
    dataset = dataset.map(lambda x: (x, tf.size(x)))
    return dataset

# 從源語言文件src_path和目標(biāo)語言文件trg_path中分別讀取數(shù)據(jù)志膀，并進行填充和
# batching操作熙宇。
def MakeSrcTrgDataset(src_path, trg_path, batch_size):
    # 首先分別讀取源語言數(shù)據(jù)和目標(biāo)語言數(shù)據(jù)。
    src_data = MakeDataset(src_path)
    trg_data = MakeDataset(trg_path)
    # 通過zip操作將兩個Dataset合并為一個Dataset「日悖現(xiàn)在每個Dataset中每一項數(shù)據(jù)ds
    # 由4個張量組成：
    #   ds[0][0]是源句子
    #   ds[0][1]是源句子長度
    #   ds[1][0]是目標(biāo)句子
    #   ds[1][1]是目標(biāo)句子長度
    dataset = tf.data.Dataset.zip((src_data, trg_data))

    # 刪除內(nèi)容為空（只包含<EOS>）的句子和長度過長的句子烫止。
    def FilterLength(src_tuple, trg_tuple):
        ((src_input, src_len), (trg_label, trg_len)) = (src_tuple, trg_tuple)
        src_len_ok = tf.logical_and(
            tf.greater(src_len, 1), tf.less_equal(src_len, MAX_LEN))
        trg_len_ok = tf.logical_and(
            tf.greater(trg_len, 1), tf.less_equal(trg_len, MAX_LEN))
        return tf.logical_and(src_len_ok, trg_len_ok)
    dataset = dataset.filter(FilterLength)
    
    # 從圖9-5可知，解碼器需要兩種格式的目標(biāo)句子：
    #   1.解碼器的輸入(trg_input)戳稽，形式如同"<sos> X Y Z"
    #   2.解碼器的目標(biāo)輸出(trg_label)馆蠕，形式如同"X Y Z <eos>"
    # 上面從文件中讀到的目標(biāo)句子是"X Y Z <eos>"的形式，我們需要從中生成"<sos> X Y Z"
    # 形式并加入到Dataset中。
    def MakeTrgInput(src_tuple, trg_tuple):
        ((src_input, src_len), (trg_label, trg_len)) = (src_tuple, trg_tuple)
        trg_input = tf.concat([[SOS_ID], trg_label[:-1]], axis=0)
        return ((src_input, src_len), (trg_input, trg_label, trg_len))
    dataset = dataset.map(MakeTrgInput)

    # 隨機打亂訓(xùn)練數(shù)據(jù)互躬。
    dataset = dataset.shuffle(10000)

    # 規(guī)定填充后輸出的數(shù)據(jù)維度播赁。
    padded_shapes = (
        (tf.TensorShape([None]),      # 源句子是長度未知的向量
         tf.TensorShape([])),         # 源句子長度是單個數(shù)字
        (tf.TensorShape([None]),      # 目標(biāo)句子（解碼器輸入）是長度未知的向量
         tf.TensorShape([None]),      # 目標(biāo)句子（解碼器目標(biāo)輸出）是長度未知的向量
         tf.TensorShape([])))         # 目標(biāo)句子長度是單個數(shù)字
    # 調(diào)用padded_batch方法進行batching操作。
    batched_dataset = dataset.padded_batch(batch_size, padded_shapes)
    return batched_dataset