流程

tendorflow可以讀取文字檔案，二進位制檔案，圖片檔案和tfrecords檔案。除了閱讀器不一樣，讀檔案的流程是差不多的。

1.構造檔案佇列 2.讀取檔案內容 3.解碼 4.批處理

import tensorflow as tf
import os


# 模擬一下同步先處理資料，然後才能取資料訓練
# tensorflow當中，執行操作有依賴性

# # 1、首先定義佇列
# Q = tf.FIFOQueue(3, tf.float32)
#
# # 放入一些資料
# enq_many = Q.enqueue_many([[0.1, 0.2, 0.3], ])
#
# # 2、定義一些處理資料的螺距，取資料的過程      取資料，+1， 入佇列
 

#
# out_q = Q.dequeue()
#
# data = out_q + 1
#
# en_q = Q.enqueue(data)
#
# with tf.Session() as sess:
#     # 初始化佇列
#     sess.run(enq_many)
#
#     # 處理資料
#     for i in range(100):
#         sess.run(en_q)
#
#     # 訓練資料
#     for i in range(Q.size().eval()):
#         print(sess.run(Q.dequeue()))
 



# 模擬非同步子執行緒 存入樣本， 主執行緒 讀取樣本

# # 1、定義一個佇列，1000
# Q = tf.FIFOQueue(1000, tf.float32)
#
# # 2、定義要做的事情 迴圈 值，+1， 放入隊列當中
# var = tf.Variable(0.0)
#
# # 實現一個自增  tf.assign_add
# data = tf.assign_add(var, tf.constant(1.0))
#
# en_q = Q.enqueue(data)
#
# # 3、定義佇列管理器op, 指定多少個子執行緒，子執行緒該幹什麼事情
# qr = tf.train.QueueRunner(Q, enqueue_ops=[en_q] * 2)
 

#
# # 初始化變數的OP
# init_op = tf.global_variables_initializer()
#
# with tf.Session() as sess:
#     # 初始化變數
#     sess.run(init_op)
#
#     # 開啟執行緒管理器
#     coord = tf.train.Coordinator()
#
#     # 真正開啟子執行緒
#     threads = qr.create_threads(sess, coord=coord, start=True)
#
#     # 主執行緒，不斷讀取資料訓練
#     for i in range(300):
#         print(sess.run(Q.dequeue()))
#
#     # 回收你
#     coord.request_stop()
#
#     coord.join(threads)


# 批處理大小，跟佇列，資料的數量沒有影響，只決定 這批次取多少資料


def csvread(filelist):
    """
    讀取CSV檔案
    :param filelist: 檔案路徑+名字的列表
    :return: 讀取的內容
    """
    # 1、構造檔案的佇列
    file_queue = tf.train.string_input_producer(filelist)

    # 2、構造csv閱讀器讀取佇列資料（按一行）
    reader = tf.TextLineReader()

    key, value = reader.read(file_queue)

    # 3、對每行內容解碼
    # record_defaults:指定每一個樣本的每一列的型別，指定預設值[["None"], [4.0]]
    records = [["None"], ["None"]]

    example, label = tf.decode_csv(value, record_defaults=records)

    # 4、想要讀取多個數據，就需要批處理
    example_batch, label_batch = tf.train.batch([example, label], batch_size=9, num_threads=1, capacity=9)

    print(example_batch, label_batch)
    return example_batch, label_batch


def picread(filelist):
    """
    讀取狗圖片並轉換成張量
    :param filelist: 檔案路徑+ 名字的列表
    :return: 每張圖片的張量
    """
    # 1、構造檔案佇列
    file_queue = tf.train.string_input_producer(filelist)

    # 2、構造閱讀器去讀取圖片內容（預設讀取一張圖片）
    reader = tf.WholeFileReader()

    key, value = reader.read(file_queue)

    print(value)

    # 3、對讀取的圖片資料進行解碼
    image = tf.image.decode_jpeg(value)

    print(image)

    # 5、處理圖片的大小（統一大小）
    image_resize = tf.image.resize_images(image, [200, 200])

    print(image_resize)

    # 注意：一定要把樣本的形狀固定 [200, 200, 3],在批處理的時候要求所有資料形狀必須定義
    image_resize.set_shape([200, 200, 3])

    print(image_resize)

    # 6、進行批處理
    image_batch = tf.train.batch([image_resize], batch_size=20, num_threads=1, capacity=20)

    print(image_batch)

    return image_batch


# 定義cifar的資料等命令列引數
FLAGS = tf.app.flags.FLAGS

tf.app.flags.DEFINE_string("cifar_dir", "./data/cifar10/cifar-10-batches-bin/", "檔案的目錄")
tf.app.flags.DEFINE_string("cifar_tfrecords", "./tmp/cifar.tfrecords", "存進tfrecords的檔案")


class CifarRead(object):
    """完成讀取二進位制檔案， 寫進tfrecords，讀取tfrecords
    """
    def __init__(self, filelist):
        # 檔案列表
        self.file_list = filelist

        # 定義讀取的圖片的一些屬性
        self.height = 32
        self.width = 32
        self.channel = 3
        # 二進位制檔案每張圖片的位元組
        self.label_bytes = 1
        self.image_bytes = self.height * self.width * self.channel
        self.bytes = self.label_bytes + self.image_bytes

    def read_and_decode(self):

        # 1、構造檔案佇列
        file_queue = tf.train.string_input_producer(self.file_list)

        # 2、構造二進位制檔案讀取器，讀取內容, 每個樣本的位元組數
        reader = tf.FixedLengthRecordReader(self.bytes)

        key, value = reader.read(file_queue)

        # 3、解碼內容, 二進位制檔案內容的解碼
        label_image = tf.decode_raw(value, tf.uint8)

        print(label_image)

        # 4、分割出圖片和標籤資料，切除特徵值和目標值
        label = tf.cast(tf.slice(label_image, [0], [self.label_bytes]), tf.int32)

        image = tf.slice(label_image, [self.label_bytes], [self.image_bytes])

        # 5、可以對圖片的特徵資料進行形狀的改變 [3072] --> [32, 32, 3]
        image_reshape = tf.reshape(image, [self.height, self.width, self.channel])

        print(label, image_reshape)
        # 6、批處理資料
        image_batch, label_batch = tf.train.batch([image_reshape, label], batch_size=10, num_threads=1, capacity=10)

        print(image_batch, label_batch)
        return image_batch, label_batch

    def write_ro_tfrecords(self, image_batch, label_batch):
        """
        將圖片的特徵值和目標值存進tfrecords
        :param image_batch: 10張圖片的特徵值
        :param label_batch: 10張圖片的目標值
        :return: None
        """
        # 1、建立TFRecord儲存器
        writer = tf.python_io.TFRecordWriter(FLAGS.cifar_tfrecords)

        # 2、迴圈將所有樣本寫入檔案，每張圖片樣本都要構造example協議
        for i in range(10):
            # 取出第i個圖片資料的特徵值和目標值
            image = image_batch[i].eval().tostring()

            label = int(label_batch[i].eval()[0])

            # 構造一個樣本的example
            example =  tf.train.Example(features=tf.train.Features(feature={
                "image": tf.train.Feature(bytes_list=tf.train.BytesList(value=[image])),
                "label": tf.train.Feature(int64_list=tf.train.Int64List(value=[label])),
            }))

            # 寫入單獨的樣本
            writer.write(example.SerializeToString())

        # 關閉
        writer.close()
        return None

    def read_from_tfrecords(self):

        # 1、構造檔案佇列
        file_queue = tf.train.string_input_producer([FLAGS.cifar_tfrecords])

        # 2、構造檔案閱讀器，讀取內容example,value=一個樣本的序列化example
        reader = tf.TFRecordReader()

        key, value = reader.read(file_queue)

        # 3、解析example
        features = tf.parse_single_example(value, features={
            "image": tf.FixedLenFeature([], tf.string),
            "label": tf.FixedLenFeature([], tf.int64),
        })

        # 4、解碼內容, 如果讀取的內容格式是string需要解碼， 如果是int64,float32不需要解碼
        image = tf.decode_raw(features["image"], tf.uint8)

        # 固定圖片的形狀，方便與批處理
        image_reshape = tf.reshape(image, [self.height, self.width, self.channel])

        label = tf.cast(features["label"], tf.int32)

        print(image_reshape, label)

        # 進行批處理
        image_batch, label_batch = tf.train.batch([image_reshape, label], batch_size=10, num_threads=1, capacity=10)

        return image_batch, label_batch


if __name__ == "__main__":
    # 1、找到檔案，放入列表   路徑+名字  ->列表當中
    file_name = os.listdir(FLAGS.cifar_dir)

    filelist = [os.path.join(FLAGS.cifar_dir, file) for file in file_name if file[-3:] == "bin"]

    # print(file_name)
    cf = CifarRead(filelist)

    # image_batch, label_batch = cf.read_and_decode()

    image_batch, label_batch = cf.read_from_tfrecords()

    # 開啟會話執行結果
    with tf.Session() as sess:
        # 定義一個執行緒協調器
        coord = tf.train.Coordinator()

        # 開啟讀檔案的執行緒
        threads = tf.train.start_queue_runners(sess, coord=coord)

        # 存進tfrecords檔案
        # print("開始儲存")
        #
        # cf.write_ro_tfrecords(image_batch, label_batch)
        #
        # print("結束儲存")

        # 列印讀取的內容
        print(sess.run([image_batch, label_batch]))

        # 回收子執行緒
        coord.request_stop()

        coord.join(threads)