2、tensorflow讀取數據、形成batch、顯示數據

1、變量常量輸入

x = tf.Variable([1,2])

b = tf.Constant([3,3])

2、placeholder輸入

    1     # 定義兩個placeholder
    2     x = tf.placeholder(tf.float32,[None,784])
    3     y = tf.placeholder(tf.float32,[None,10])
dtype = tf.float32:
    一般dtype要去輸入的格式，如果賦值的不是這種格式，就會出錯誤。
    但是這里是tf的入口，所以無論什么格式，只要能轉換成這種類型即可
    輸入可以是np格式的

3、使用內存隊列、不使用文件隊列

queue：定義一個隊列，文件隊列tf自己會定義，自己定義的是內存隊列
enqueue：定義輸入隊列的操作，  傳入一個批次或者多個批次的數據，這個就沒有使用文件名列表
dequeue：定義輸出隊列的操作
train_batch:這個利用dequeue獲取一個批次的數據，傳入網絡

1、定義文件隊列-數據
input_queue=data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string,tf.int64],
shapes=[(3,),(3,)],
shared_name=None,name=None)
2、定義文件隊列的輸入操作
enqueue_op=input_queue.enqueue_many([image_paths_placeholder,labels_placeholder])
文件隊列的輸出和內存隊列的輸入可以不用定義
3、定義文件隊列隊列的輸出操作
filenames,label=input_queue.dequeue()
4、利用文件隊列的輸出操作獲取一個批量的數據，內存隊列的輸入操作
這是一個內存隊列
image_batch,labels_batch=tf.train.batch_join(
images_and_labels,#將這個整體的第一維度進行差分
batch_size=batch_size_placeholder,#出隊的時候的大小
shapes=[(args.image_size,args.image_size,3),()],
enqueue_many=True,#表示image_batch和labels_batch同時入隊
capacity=4*nrof_preprocess_threads*args.batch_size,
allow_smaller_final_batch=True)
5、內存隊列的輸出操作時自動訓練的時候自動獲取的
6、之前都是定義的隊列的操作，這個相當於閥門的打開，數據開始流入
tf.train.start_queue_runners(coord=coord,sess=sess)

4、使用內存隊列 和 文件隊列、里面是imageDirList

#將一系列的圖片的絕對路徑組成list
def GetImageDirList():
    pass
    return ImageDirList

#對於分類的任務，lable就是每個類別的號碼
def GetLabelList():
    pass
    return labelList

#根據路徑可以
def GetBatch(ImageDirList, labelList):
    #第一個是我們的原始圖片
    imagesTensor = tf.convert_to_tensor(imageList, dtype=tf.string)
    #如果進行實力分割，這個就是我們的label，也就是說，一個batch里面可以有兩組圖片
    imagesMaskTensor = tf.convert_to_tensor(imageMaskList, dtype=tf.string)
    #batch里面還可以有數字
    label0Tensor = tf.convert_to_tensor(label0List, dtype=tf.int32)
    label1Tensor = tf.convert_to_tensor(label1List, dtype=tf.int32)

    #形成文件隊列
    queue = tf.train.slice_input_producer(
        [imagesTensor, imagesMaskTensor, label0Tensor, label1Tensor])

    # 提取圖片內容和標簽內容，一定注意數據之間的轉化；
    image_content0 = tf.read_file(queue[0])
    imageData0 = tf.image.decode_jpeg(image_content, channels=3)  # channels必須要制定，當時沒指定，程序報錯
    imageData0 = tf.image.convert_image_dtype(imageData0, tf.uint8)  # 圖片數據進行轉化，此處為了顯示而轉化
    image_content1 = tf.read_file(queue[1])
    imageData1 = tf.image.decode_jpeg(image_content, channels=3)  # channels必須要制定，當時沒指定，程序報錯
    imageData1 = tf.image.convert_image_dtype(imageData0, tf.uint8)  # 圖片數據進行轉化，此處為了顯示而轉化
    label0Data = tf.cast(queue[1], tf.int32)
    label1Data = tf.cast(queue[2], tf.int32)

    # resieze
    new_size = tf.constant([imgHeight, imgWidth], dtype=tf.int32)
    image0 = tf.image.resize_images(imageData0, new_size)

    # 這是數據提取關鍵，因為設置了batch_size，決定了每次提取數據的個數，比如此處是3，則每次為3個文件
    imageBatch, label0Batch, label1Batch, label2Batch, label3Batch, label4Batch = \
        tf.train.shuffle_batch([image0, label0Data, label1Data],
                               batch_size=batchSize,
                               capacity=2000, 
                               min_after_dequeue=1000)

    return imageBatch, label0Batch, label1Batch
    

 

5、使用內存隊列 和 文件隊列、里面是tfrecord

• string-into producer:這個傳輸的是文件名這樣的列表，而上一個是多個批次的數據，這個相當於是兩步
• 這個使用了文件名列表專門的reader
reader = tf.WholeFileReader（）不同的reader對應不同的文件結構
• train_batch:這個利用dequeue獲取一個批次的數據，傳入網絡


文件用不用入隊，直接用reader出隊。而數據需要全部進行
1、指定文件隊列-文件，這個就相當於前面的第一步和第二步，這一步文件隊列入隊操作已經完成。
filename_queue = tf.train.string_input_producer(tfrecord_dir_list, shuffle = True) 
2、不同的文件有不同的reader，文件隊列的輸出操作
reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue)
image_features = tf.parse_single_example(serialized_example,    
features = {
       'image/encoded':tf.FixedLenFeature([],tf.string),
      'image/roi':tf.FixedLenFeature([4], tf.float32),
      'image/landmark':tf.FixedLenFeature([10],tf.float32)
          })    
3、放入內存隊列入隊，使用的時候是出隊。內存隊列的輸入操作    
image, label, roi ,mark = tf.train.batch(    
         [image, label, roi, mark],
         batch_size = batch_size,#從隊列中獲取的出隊列的數量
         num_threads = 2,#入隊線程的限制
         capacity = 1 * batch_size#設置隊列的最大數量
    ）
4、內存隊列的輸出操作時自動訓練的時候自動獲取的    
6、之前都是定義的隊列的操作，這個相當於閥門的打開，數據開始流入
tf.train.start_queue_runners(coord=coord,sess=sess)

sess.中顯示數據

import tensorflow as tf

# Fetch:可以在session中同時計算多個tensor或執行多個操作
# 定義三個常量
input1 = tf.constant(3.0)
input2 = tf.constant(2.0)
input3 = tf.constant(5.0)
# 加法op
add = tf.add(input2,input3)
# 乘法op
mul = tf.multiply(input1, add)

with tf.Session() as sess:
#sess.run([ ]),列表里面就可以放置很多輸出。這樣就可以一步獲得多個輸出。
    result1,result2 = sess.run([mul, add])
    print(result1,result2)
# Feed:先定義占位符，等需要的時候再傳入數據
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
# 乘法op
output = tf.multiply(input1, input2)

with tf.Session() as sess:
#feed_dict():用字典的方式，進行輸出所需要的輸入的提供
    print(sess.run(output, feed_dict={input1:8.0,input2:2.0}))