Tensorflow一些經常使用基本概念與函數（二）

時間  2019-11-18
標籤 tensorflow 一些 經常 使用 基本概念 函數 简体版
原文   原文鏈接

一、tensorflow的基本運做

爲了快速的熟悉TensorFlow編程，下面從一段簡單的代碼開始：html

import tensorflow as tf #定義‘符號’變量，也稱爲佔位符 a = tf.placeholder("float") b = tf.placeholder("float") y = tf.mul(a, b) #構造一個op節點 sess = tf.Session()#創建會話 #運行會話，輸入數據，並計算節點，同時打印結果 print sess.run(y, feed_dict={a: 3, b: 3}) # 任務完成, 關閉會話. sess.close()

 

 

其中tf.mul(a, b)函數即是tf的一個基本的算數運算，接下來介紹跟多的相關函數。node

二、tf函數

TensorFlow 將圖形定義轉換成分佈式執行的操做, 以充分利用可用的計算資源(如 CPU 或 GPU。通常你不須要顯式指定使用 CPU 仍是 GPU, TensorFlow 能自動檢測。若是檢測到 GPU, TensorFlow 會盡量地利用找到的第一個 GPU 來執行操做.
並行計算能讓代價大的算法計算加速執行，TensorFlow也在實現上對複雜操做進行了有效的改進。大部分核相關的操做都是設備相關的實現，好比GPU。本文主要涉及的相關概念或操做有如下內容：
操做組 操做
Building Graphs Core graph data structures，Tensor types，Utility functions
Inputs and Readers Placeholders，Readers，Converting，Queues，Input pipeline

2.1 創建圖(Building Graphs)

本節主要介紹創建tensorflow圖的相關類或函數python

* 核心圖的數據結構（Core graph data structures）

tf.Graphgit

操做 描述
class tf.Graph tensorflow中的計算以圖數據流的方式表示
一個圖包含一系列表示計算單元的操做對象
以及在圖中流動的數據單元以tensor對象表現
tf.Graph.__init__() 創建一個空圖
tf.Graph.as_default() 一個將某圖設置爲默認圖，並返回一個上下文管理器
若是不顯式添加一個默認圖，系統會自動設置一個全局的默認圖。
所設置的默認圖，在模塊範圍內所定義的節點都將默認加入默認圖中
tf.Graph.as_graph_def
(from_version=None, add_shapes=False)		 返回一個圖的序列化的GraphDef表示
序列化的GraphDef能夠導入至另外一個圖中(使用 import_graph_def())
或者使用C++ Session API
tf.Graph.finalize() 完成圖的構建，即將其設置爲只讀模式
tf.Graph.finalized 返回True，若是圖被完成
tf.Graph.control_dependencies(control_inputs) 定義一個控制依賴，並返回一個上下文管理器
with g.control_dependencies([a, b, c]):
# `d` 和 `e` 將在 `a`, `b`, 和`c`執行完以後運行.
d = …
e = …
tf.Graph.device(device_name_or_function) 定義運行圖所使用的設備，並返回一個上下文管理器
with g.device('/gpu:0'): ...
with g.device('/cpu:0'): ...
tf.Graph.name_scope(name) 爲節點建立層次化的名稱，並返回一個上下文管理器
tf.Graph.add_to_collection(name, value) 將value以name的名稱存儲在收集器(collection)中
tf.Graph.get_collection(name, scope=None) 根據name返回一個收集器中所收集的值的列表
tf.Graph.as_graph_element
(obj, allow_tensor=True, allow_operation=True)		 返回一個圖中與obj相關聯的對象，爲一個操做節點或者tensor數據
tf.Graph.get_operation_by_name(name) 根據名稱返回操做節點
tf.Graph.get_tensor_by_name(name) 根據名稱返回tensor數據
tf.Graph.get_operations() 返回圖中的操做節點列表
tf.Graph.gradient_override_map(op_type_map) 用於覆蓋梯度函數的上下文管理器 
#class tf.Graph #tensorflow運行時須要設置默認的圖 g = tf.Graph() with g.as_default(): # Define operations and tensors in `g`. c = tf.constant(30.0) assert c.graph is g ##也可使用tf.get_default_graph()得到默認圖，也可在基礎上加入節點或子圖 c = tf.constant(4.0) assert c.graph is tf.get_default_graph()

 

 

#tf.Graph.as_default #如下兩段代碼功能相同 #一、使用Graph.as_default(): g = tf.Graph() with g.as_default(): c = tf.constant(5.0) assert c.graph is g #二、構造和設置爲默認 with tf.Graph().as_default() as g: c = tf.constant(5.0) assert c.graph is g

 

 

#tf.Graph.control_dependencies(control_inputs) # 錯誤代碼 def my_func(pred, tensor): t = tf.matmul(tensor, tensor) with tf.control_dependencies([pred]): # 乘法操做(op)沒有建立在該上下文，因此沒有被加入依賴控制 return t # 正確代碼 def my_func(pred, tensor): with tf.control_dependencies([pred]): # 乘法操做(op)建立在該上下文，因此被加入依賴控制中 #執行完pred以後再執行matmul return tf.matmul(tensor, tensor)

 

 

# tf.Graph.name_scope(name) # 一個圖中包含有一個名稱範圍的堆棧，在使用name_scope(...)以後，將壓(push)新名稱進棧中， #並在下文中使用該名稱 with tf.Graph().as_default() as g: c = tf.constant(5.0, name="c") assert c.op.name == "c" c_1 = tf.constant(6.0, name="c") assert c_1.op.name == "c_1" # Creates a scope called "nested" with g.name_scope("nested") as scope: nested_c = tf.constant(10.0, name="c") assert nested_c.op.name == "nested/c" # Creates a nested scope called "inner". with g.name_scope("inner"): nested_inner_c = tf.constant(20.0, name="c") assert nested_inner_c.op.name == "nested/inner/c" # Create a nested scope called "inner_1". with g.name_scope("inner"): nested_inner_1_c = tf.constant(30.0, name="c") assert nested_inner_1_c.op.name == "nested/inner_1/c" # Treats `scope` as an absolute name scope, and # switches to the "nested/" scope. with g.name_scope(scope): nested_d = tf.constant(40.0, name="d") assert nested_d.op.name == "nested/d" with g.name_scope(""): e = tf.constant(50.0, name="e") assert e.op.name == "e"

 

 

tf.Operationgithub

操做 描述
class tf.Operation 表明圖中的一個節點，用於計算tensors數據
該類型將由python節點構造器產生(好比tf.matmul())
或者Graph.create_op()
例如c = tf.matmul(a, b)建立一個Operation類
爲類型爲」MatMul」,輸入爲’a’,’b’，輸出爲’c’的操做類
tf.Operation.name 操做節點(op)的名稱
tf.Operation.type 操做節點(op)的類型，好比」MatMul」
tf.Operation.inputs
tf.Operation.outputs		 操做節點的輸入與輸出
tf.Operation.control_inputs 操做節點的依賴
tf.Operation.run(feed_dict=None, session=None) 在會話(Session)中運行該操做
tf.Operation.get_attr(name) 獲取op的屬性值

tf.Tensor算法

操做 描述
class tf.Tensor 表示一個由操做節點op產生的值，
TensorFlow程序使用tensor數據結構來表明全部的數據, 
計算圖中, 操做間傳遞的數據都是 tensor，一個tensor是一個符號handle,
裏面並無表示實際數據，而至關於數據流的載體
tf.Tensor.dtype tensor中數據類型
tf.Tensor.name 該tensor名稱
tf.Tensor.value_index 該tensor輸出外op的index
tf.Tensor.graph 該tensor所處在的圖
tf.Tensor.op 產生該tensor的op
tf.Tensor.consumers() 返回使用該tensor的op列表
tf.Tensor.eval(feed_dict=None, session=None) 在會話中求tensor的值
須要使用with sess.as_default()或者 eval(session=sess)
tf.Tensor.get_shape() 返回用於表示tensor的shape的類TensorShape
tf.Tensor.set_shape(shape) 更新tensor的shape
tf.Tensor.device 設置計算該tensor的設備 
#tf.Tensor.get_shape() c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) print(c.get_shape()) ==> TensorShape([Dimension(2), Dimension(3)])

 

 

#如今有個用於圖像處理的tensor->image print(image.get_shape()) ==> TensorShape([Dimension(None), Dimension(None), Dimension(3)]) # 假如咱們知道數據集中圖像尺寸爲28 x 28，那麼能夠設置 image.set_shape([28, 28, 3]) print(image.get_shape()) ==> TensorShape([Dimension(28), Dimension(28), Dimension(3)])

 

 

* tensor類型(Tensor types)

tf.DType編程

操做 描述
class tf.DType 數據類型主要包含
tf.float16，tf.float16,tf.float32,tf.float64,
tf.bfloat16,tf.complex64,tf.complex128,
tf.int8,tf.uint8,tf.uint16,tf.int16,tf.int32,
tf.int64,tf.bool,tf.string
tf.DType.is_compatible_with(other) 判斷other的數據類型是否將轉變爲該DType
tf.DType.name 數據類型名稱
tf.DType.base_dtype 返回該DType的基礎DType，而非參考的數據類型(non-reference)
tf.DType.as_ref 返回一個基於DType的參考數據類型
tf.DType.is_floating 判斷是否爲浮點類型
tf.DType.is_complex 判斷是否爲複數
tf.DType.is_integer 判斷是否爲整數
tf.DType.is_unsigned 判斷是否爲無符號型數據
tf.DType.as_numpy_dtype 返回一個基於DType的numpy.dtype類型
tf.DType.max
tf.DType.min		 返回這種數據類型能表示的最大值及其最小值
tf.as_dtype(type_value) 返回由type_value轉變得的相應tf數據類型

* 通用函數（Utility functions）

操做 描述
tf.device(device_name_or_function) 基於默認的圖，其功能便爲Graph.device()
tf.container(container_name) 基於默認的圖，其功能便爲Graph.container()
tf.name_scope(name) 基於默認的圖，其功能便爲 Graph.name_scope()
tf.control_dependencies(control_inputs) 基於默認的圖，其功能便爲Graph.control_dependencies()
tf.convert_to_tensor
(value, dtype=None, name=None, as_ref=False)		 將value轉變爲tensor數據類型
tf.get_default_graph() 返回返回當前線程的默認圖
tf.reset_default_graph() 清除默認圖的堆棧，並設置全局圖爲默認圖
tf.import_graph_def(graph_def, input_map=None,
return_elements=None, name=None, op_dict=None,
producer_op_list=None)		 將graph_def的圖導入到python中

* 圖收集（Graph collections）

操做 描述
tf.add_to_collection(name, value) 基於默認的圖，其功能便爲Graph.add_to_collection()
tf.get_collection(key, scope=None) 基於默認的圖，其功能便爲Graph.get_collection()

* 定義新操做節點（Defining new operations）

tf.RegisterGradientjson

操做 描述
class tf.RegisterGradient 返回一個用於寄存op類型的梯度函數的裝飾器
tf.NoGradient(op_type) 設置操做節點類型op_type的節點沒有指定的梯度
class tf.RegisterShape 返回一個用於寄存op類型的shape函數的裝飾器
class tf.TensorShape 表示tensor的shape
tf.TensorShape.merge_with(other) 與other合併shape信息，返回一個TensorShape類
tf.TensorShape.concatenate(other) 與other的維度相連結
tf.TensorShape.ndims 返回tensor的rank
tf.TensorShape.dims 返回tensor的維度
tf.TensorShape.as_list() 以list的形式返回tensor的shape
tf.TensorShape.is_compatible_with(other) 判斷shape是否爲兼容
TensorShape(None)與其餘任何shape值兼容
class tf.Dimension  
tf.Dimension.is_compatible_with(other) 判斷dims是否爲兼容
tf.Dimension.merge_with(other) 與other合併dims信息
tf.op_scope(values, name, default_name=None) 在python定義op時，返回一個上下文管理器 
#tf.RegisterGradient #該裝飾器只使用於定義一個新的op類型時候，若是一個op有m個輸入，n個輸出。那麼該梯度函數應該設置原始的 #操做類型，以及n個Tensor對象（表示每個op輸出的梯度），以及m個對象(表示每個op輸入的偏梯度) #以操做節點類型爲'Sub'爲例，兩輸入爲x,y。爲一個輸出x-y @tf.RegisterGradient("Sub") def _sub_grad(unused_op, grad): return grad, tf.neg(grad)

 

 

#tf.op_scope #定義一個名稱爲my_op的python操做節點op def my_op(a, b, c, name=None): with tf.op_scope([a, b, c], name, "MyOp") as scope: a = tf.convert_to_tensor(a, name="a") b = tf.convert_to_tensor(b, name="b") c = tf.convert_to_tensor(c, name="c") # Define some computation that uses `a`, `b`, and `c`. return foo_op(..., name=scope)

 

 

2.2 輸入和讀取器(Inputs and Readers)

本節主要介紹tensorflow中數據的讀入相關類或函數api

* 佔位符（Placeholders）

tf提供一種佔位符操做，在執行時須要爲其提供數據data。網絡

操做 描述
tf.placeholder(dtype, shape=None, name=None) 爲一個tensor插入一個佔位符
eg:x = tf.placeholder(tf.float32, shape=(1024, 1024))
tf.placeholder_with_default(input, shape, name=None) 當輸出沒有fed時，input經過一個佔位符op
tf.sparse_placeholder(dtype, shape=None, name=None) 爲一個稀疏tensor插入一個佔位符

* 讀取器（Readers）

tf提供一系列讀取各類數據格式的類。對於多文件輸入，可使用函數tf.train.string_input_producer，該函數將建立一個保持文件的FIFO隊列，以供reader使用。或者若是輸入的這些文件名有相雷同的字符串，也可使用函數tf.train.match_filenames_once。

操做 描述
class tf.ReaderBase 不一樣的讀取器類型的基本類
tf.ReaderBase.read(queue, name=None) 返回下一個記錄對(key, value),queue爲tf文件隊列FIFOQueue
tf.ReaderBase.read_up_to(queue, num_records, name=None) 返回reader產生的num_records對(key, value)
tf.ReaderBase.reader_ref 返回應用在該reader上的Op
tf.ReaderBase.reset(name=None) 恢復reader爲初始狀態
tf.ReaderBase.restore_state(state, name=None) 恢復reader爲以前的保存狀態state
tf.ReaderBase.serialize_state(name=None) 返回一個reader解碼後產生的字符串tansor
class tf.TextLineReader  
tf.TextLineReader.num_records_produced(name=None) 返回reader已經產生的記錄(records )數目
tf.TextLineReader.num_work_units_completed(name=None) 返回該reader已經完成的處理的work數目
tf.TextLineReader.read(queue, name=None) 返回reader所產生的下一個記錄對 (key, value)，該reader能夠限定新產生輸出的行數
tf.TextLineReader.reader_ref 返回應用在該reader上的Op
tf.TextLineReader.reset(name=None) 恢復reader爲初始狀態
tf.TextLineReader.restore_state(state, name=None) 恢復reader爲以前的保存狀態state
tf.TextLineReader.serialize_state(name=None) 返回一個reader解碼後產生的字符串tansor
class tf.WholeFileReader 一個閱讀器，讀取整個文件，返回文件名稱key,以及文件中全部的內容value,該類的方法同上，不贅述
class tf.IdentityReader 一個reader，以key和value的形式，輸出一個work隊列。該類其餘方法基本同上
class tf.TFRecordReader 讀取TFRecord格式文件的reader。該類其餘方法基本同上
class tf.FixedLengthRecordReader 輸出

* 數據轉換（Converting）

tf提供一系列方法將各類格式數據轉換爲tensor表示。

操做 描述
tf.decode_csv(records, record_defaults, 
field_delim=None, name=None)		 將csv轉換爲tensor，與tf.TextLineReader搭配使用
tf.decode_raw(bytes, out_type, 
little_endian=None, name=None)		 將bytes轉換爲一個數字向量表示，bytes爲一個字符串類型的tensor
與函數 tf.FixedLengthRecordReader搭配使用，詳見tf的CIFAR-10例子

選取與要輸入的文件格式相匹配的reader，並將文件隊列提供給reader的讀方法( read method)。讀方法將返回文件惟一標識的key，以及一個記錄(record)（有助於對出現一些另類的records時debug），以及一個標量的字符串值。再使用一個（或多個）解碼器(decoder) 或轉換操做(conversion ops)將字符串轉換爲tensor類型。

#讀取文件隊列，使用reader中read的方法，返回key與value filename_queue = tf.train.string_input_producer(["file0.csv", "file1.csv"]) reader = tf.TextLineReader() key, value = reader.read(filename_queue) record_defaults = [[1], [1], [1], [1], [1]] col1, col2, col3, col4, col5 = tf.decode_csv( value, record_defaults=record_defaults) features = tf.pack([col1, col2, col3, col4]) with tf.Session() as sess: # Start populating the filename queue. coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) for i in range(1200): # Retrieve a single instance: example, label = sess.run([features, col5]) coord.request_stop() coord.join(threads)

 

 

* Example protocol buffer

提供了一些Example protocol buffers，tf所推薦的用於訓練樣本的數據格式，它們包含特徵信息，詳情可見。 
這是一種與前述將手上現有的各類數據類型轉換爲支持的格式的方法，這種方法更容易將網絡結構與數據集融合或匹配。這種tensorflow所推薦的數據格式是一個包含tf.train.Example protocol buffers (包含特徵Features域)的TFRecords文件。 
一、獲取這種格式的文件方式爲，首先將通常的數據格式填入Example protocol buffer中，再將 protocol buffer序列化爲一個字符串，而後使用tf.python_io.TFRecordWriter類的相關方法將字符串寫入一個TFRecords文件中，參見MNIST例子，將MNIST 數據轉換爲該類型數據。 
二、讀取TFRecords格式文件的方法爲，使用tf.TFRecordReader讀取器和tf.parse_single_example解碼器。parse_single_example操做將 example protocol buffers解碼爲tensor形式。參見MNIST例子

操做 描述
class tf.VarLenFeature 解析變長的輸入特徵feature相關配置
class tf.FixedLenFeature 解析定長的輸入特徵feature相關配置
class tf.FixedLenSequenceFeature 序列項目中的稠密(dense )輸入特徵的相關配置
tf.parse_example(serialized, features, 
name=None, example_names=None)		 將一組Example protos解析爲tensor的字典形式
解析serialized所給予的序列化的一些Example protos
返回一個由特徵keys映射Tensor和SparseTensor值的字典
tf.parse_single_example(serialized, features, 
name=None, example_names=None)		 解析一個單獨的Example proto，與tf.parse_example方法雷同
tf.decode_json_example(json_examples, name=None) 將JSON編碼的樣本記錄轉換爲二進制protocol buffer字符串 
#tf.parse_example的使用舉例 #輸入序列化數據以下： serialized = [ features { feature { key: "ft" value { float_list { value: [1.0, 2.0] } } } }, features { feature []}, features { feature { key: "ft" value { float_list { value: [3.0] } } } ] #那麼輸出爲一個字典(dict),以下： {"ft": SparseTensor(indices=[[0, 0], [0, 1], [2, 0]], values=[1.0, 2.0, 3.0], shape=(3, 2)) } ######### #再來看一個例子，給定兩個序列化的原始輸入樣本： [ features { feature { key: "kw" value { bytes_list { value: [ "knit", "big" ] } } } feature { key: "gps" value { float_list { value: [] } } } }, features { feature { key: "kw" value { bytes_list { value: [ "emmy" ] } } } feature { key: "dank" value { int64_list { value: [ 42 ] } } } feature { key: "gps" value { } } } ] #相關參數以下： example_names: ["input0", "input1"], features: { "kw": VarLenFeature(tf.string), "dank": VarLenFeature(tf.int64), "gps": VarLenFeature(tf.float32), } #那麼有以下輸出： { "kw": SparseTensor( indices=[[0, 0], [0, 1], [1, 0]], values=["knit", "big", "emmy"] shape=[2, 2]), "dank": SparseTensor( indices=[[1, 0]], values=[42], shape=[2, 1]), "gps": SparseTensor( indices=[], values=[], shape=[2, 0]), } ######### #對於兩個樣本的輸出稠密結果狀況 [ features { feature { key: "age" value { int64_list { value: [ 0 ] } } } feature { key: "gender" value { bytes_list { value: [ "f" ] } } } }, features { feature { key: "age" value { int64_list { value: [] } } } feature { key: "gender" value { bytes_list { value: [ "f" ] } } } } ] #咱們可使用如下參數 example_names: ["input0", "input1"], features: { "age": FixedLenFeature([], dtype=tf.int64, default_value=-1), "gender": FixedLenFeature([], dtype=tf.string), } #指望的結果以下 { "age": [[0], [-1]], "gender": [["f"], ["f"]], }

 

 

##Example protocol buffer相關使用的例子 #將mnist的數據轉換爲TFRecords文件格式 import os import tensorflow as tf from tensorflow.contrib.learn.python.learn.datasets import mnist SOURCE_URL = 'http://yann.lecun.com/exdb/mnist/' TRAIN_IMAGES = 'train-images-idx3-ubyte.gz' # MNIST filenames TRAIN_LABELS = 'train-labels-idx1-ubyte.gz' TEST_IMAGES = 't10k-images-idx3-ubyte.gz' TEST_LABELS = 't10k-labels-idx1-ubyte.gz' tf.app.flags.DEFINE_string('directory', '/tmp/data', 'Directory to download data files and write the ' 'converted result') tf.app.flags.DEFINE_integer('validation_size', 5000, 'Number of examples to separate from the training ' 'data for the validation set.') FLAGS = tf.app.flags.FLAGS def _int64_feature(value): return tf.train.Feature(int64_list=tf.train.Int64List(value=[value])) def _bytes_feature(value): return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) def convert_to(data_set, name): images = data_set.images labels = data_set.labels num_examples = data_set.num_examples if images.shape[0] != num_examples: raise ValueError('Images size %d does not match label size %d.' % (images.shape[0], num_examples)) rows = images.shape[1] cols = images.shape[2] depth = images.shape[3] filename = os.path.join(FLAGS.directory, name + '.tfrecords') print('Writing', filename) writer = tf.python_io.TFRecordWriter(filename) for index in range(num_examples): image_raw = images[index].tostring() example = tf.train.Example(features=tf.train.Features(feature={ 'height': _int64_feature(rows), 'width': _int64_feature(cols), 'depth': _int64_feature(depth), 'label': _int64_feature(int(labels[index])), 'image_raw': _bytes_feature(image_raw)})) writer.write(example.SerializeToString()) writer.close() def main(argv): # Get the data. data_sets = mnist.read_data_sets(FLAGS.directory, dtype=tf.uint8, reshape=False) # Convert to Examples and write the result to TFRecords. convert_to(data_sets.train, 'train') convert_to(data_sets.validation, 'validation') convert_to(data_sets.test, 'test') if __name__ == '__main__': tf.app.run()

 

 

* 隊列(Queues)

tensorflow提供了幾個隊列應用，用來將tf計算圖與tensors的階段流水組織到一塊兒。隊列是使用tensorflow計算的一個強大的機制，正如其餘Tensorflow的元素同樣，一個隊列也是tf圖中的一個節點(node),它是一個有狀態的node，就像一個變量：其餘節點能夠改變其內容。 
咱們來看一個簡單的例子，以下gif圖，咱們將建立一個先入先出隊列(FIFOQueue)而且將值全設爲0，而後咱們構建一個圖以獲取隊列出來的元素，對該元素加1操做，並將結果再放入隊列末尾。漸漸地，隊列中的數字便增長。 
這裏寫圖片描述

操做 描述
class tf.QueueBase 基本的隊列應用類.隊列(queue)是一種數據結構，
該結構經過多個步驟存儲tensors,
而且對tensors進行入列(enqueue)與出列(dequeue)操做
tf.QueueBase.enqueue(vals, name=None) 將一個元素編入該隊列中。若是在執行該操做時隊列已滿，
那麼將會阻塞直到元素編入隊列之中
tf.QueueBase.enqueue_many(vals, name=None) 將零個或多個元素編入該隊列中
tf.QueueBase.dequeue(name=None) 將元素從隊列中移出。若是在執行該操做時隊列已空，
那麼將會阻塞直到元素出列，返回出列的tensors的tuple
tf.QueueBase.dequeue_many(n, name=None) 將一個或多個元素從隊列中移出
tf.QueueBase.size(name=None) 計算隊列中的元素個數
tf.QueueBase.close
(cancel_pending_enqueues=False, name=None)		 關閉該隊列
f.QueueBase.dequeue_up_to(n, name=None) 從該隊列中移出n個元素並將之鏈接
tf.QueueBase.dtypes 列出組成元素的數據類型
tf.QueueBase.from_list(index, queues) 根據queues[index]的參考隊列建立一個隊列
tf.QueueBase.name 返回最隊列下面元素的名稱
tf.QueueBase.names 返回隊列每個組成部分的名稱
class tf.FIFOQueue 在出列時依照先入先出順序，其餘方法與tf.QueueBase雷同
class tf.PaddingFIFOQueue 一個FIFOQueue ，同時根據padding支持batching變長的tensor
class tf.RandomShuffleQueue 該隊列將隨機元素出列，其餘方法與tf.QueueBase雷同

* 文件系統的處理(Dealing with the filesystem)

操做 描述
tf.matching_files(pattern, name=None) 返回與pattern匹配模式的文件名稱
tf.read_file(filename, name=None) 讀取並輸出輸入文件的整個內容

* 輸入管道(Input pipeline)

用於設置輸入預取數的管道TF函數，函數 「producer」添加一個隊列至圖中，同時一個相應用於運行隊列中子圖(subgraph)的QueueRunner

操做 描述
tf.train.match_filenames_once(pattern, name=None) 保存與pattern的文件列表
tf.train.limit_epochs(tensor, num_epochs=None, name=None) 返回一個num_epochs次數，而後報告OutOfRange錯誤
tf.train.input_producer(input_tensor, element_shape=None, 
num_epochs=None, shuffle=True, seed=None, capacity=32, 
shared_name=None, summary_name=None, name=None)		 爲一個輸入管道輸出input_tensor中的多行至一個隊列中
tf.train.range_input_producer(limit, num_epochs=None, 
shuffle=True, seed=None, capacity=32, 
shared_name=None, name=None)		 產生一個從1至limit-1的整數至隊列中
tf.train.slice_input_producer(tensor_list, num_epochs=None, 
shuffle=True, seed=None, capacity=32, 
shared_name=None, name=None)		 對tensor_list中的每個tensor切片
tf.train.string_input_producer(string_tensor, num_epochs=None,
shuffle=True, seed=None, capacity=32, 
shared_name=None, name=None)		 爲一個輸入管道輸出一組字符串(好比文件名)至隊列中

* 在輸入管道末端批量打包(Batching at the end of an input pipeline)

該相關函數增添一個隊列至圖中以將數據同樣本打包爲batch。它們也會添加 一個QueueRunner，以便執行的已經被填滿隊列的子圖

操做 描述
tf.train.batch(tensors, batch_size, num_threads=1,
capacity=32, enqueue_many=False, shapes=None, 
dynamic_pad=False, allow_smaller_final_batch=False, 
shared_name=None, name=None)		 在輸入的tensors中建立一些tensor數據格式的batch，
若輸入爲shape[*, x, y, z]，那麼輸出則爲[batch_size, x, y, z]
返回一個列表或者一個具備與輸入tensors相同類型tensors的字典
tf.train.batch_join(tensors_list, batch_size, 
capacity=32, enqueue_many=False, shapes=None, 
dynamic_pad=False, allow_smaller_final_batch=False, 
shared_name=None, name=None)		 將一個tensors的列表添加至一個隊列中以建立樣本的batches
len(tensors_list)個線程將啓動，
線程i將tensors_list[i]的tensors入列
tensors_list[i1][j]與tensors_list[i2][j]有相同的類型和shape
tf.train.shuffle_batch(tensors, batch_size, capacity, 
min_after_dequeue, num_threads=1, seed=None, 
enqueue_many=False, shapes=None, 
allow_smaller_final_batch=False,
shared_name=None, name=None)		 使用隨機亂序的方法建立batches
tensors:用於入列的一個list或者dict
capacity:一個整數，表示隊列中元素最大數目
tf.train.shuffle_batch_join(tensors_list, batch_size, 
capacity, min_after_dequeue, seed=None, 
enqueue_many=False, shapes=None, 
allow_smaller_final_batch=False, 
shared_name=None, name=None)		 隨機亂序的tensors建立batches，
其中tensors_list參數爲tensors元組或tensors字典的列表
len(tensors_list)個線程將啓動，
線程i將tensors_list[i]的tensors入列
tensors_list[i1][j]與tensors_list[i2][j]有相同的類型和shape		 
# 一個簡單例子，使用tf.train.shuffle_batch建立一個具備32張圖像和32個標籤的batches. image_batch, label_batch = tf.train.shuffle_batch( [single_image, single_label], batch_size=32, num_threads=4, capacity=50000, min_after_dequeue=10000)

 

 

#Batching函數相關例子，以函數tf.train.shuffle_batch爲例 #爲training, evaluation等操做將樣本batching，如下代碼使用隨機順序打包樣本 def read_my_file_format(filename_queue): reader = tf.SomeReader() key, record_string = reader.read(filename_queue) example, label = tf.some_decoder(record_string) processed_example = some_processing(example) return processed_example, label def input_pipeline(filenames, batch_size, num_epochs=None): filename_queue = tf.train.string_input_producer( filenames, num_epochs=num_epochs, shuffle=True) example, label = read_my_file_format(filename_queue) # min_after_dequeue defines how big a buffer we will randomly sample # from -- bigger means better shuffling but slower start up and more # memory used. # capacity must be larger than min_after_dequeue and the amount larger # determines the maximum we will prefetch. Recommendation: # min_after_dequeue + (num_threads + a small safety margin) * batch_size min_after_dequeue = 10000 capacity = min_after_dequeue + 3 * batch_size example_batch, label_batch = tf.train.shuffle_batch( [example, label], batch_size=batch_size, capacity=capacity, min_after_dequeue=min_after_dequeue) return example_batch, label_batch

 

 

#若是須要跟多的並行或文件之間的樣本亂序操做，可使用函數tf.train.shuffle_batch_join多實例化reader def read_my_file_format(filename_queue): # 與上例子相同 def input_pipeline(filenames, batch_size, read_threads, num_epochs=None): filename_queue = tf.train.string_input_producer( filenames, num_epochs=num_epochs, shuffle=True) example_list = [read_my_file_format(filename_queue) for _ in range(read_threads)] min_after_dequeue = 10000 capacity = min_after_dequeue + 3 * batch_size example_batch, label_batch = tf.train.shuffle_batch_join( example_list, batch_size=batch_size, capacity=capacity, min_after_dequeue=min_after_dequeue) return example_batch, label_batch轉自：http://blog.csdn.net/lenbow/article/details/52181159
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程