【Tensorflow】Tensorflow一些常用基本概念與函數（2）

1、tensorflow的基本運作

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

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的一個基本的算數運算，接下來介紹跟多的相關函數。

2、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圖的相關類或函數

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

tf.Graph

操作	描述
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
#以下兩段代碼功能相同
#1、使用Graph.as_default():
g = tf.Graph()
with g.as_default():
  c = tf.constant(5.0)
  assert c.graph is g

#2、構造和設置爲默認
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.Operation

操作	描述
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.RegisterGradient

操作	描述
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中數據的讀入相關類或函數

* 佔位符（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文件。
1、獲取這種格式的文件方式爲，首先將一般的數據格式填入Example protocol buffer中，再將 protocol buffer序列化爲一個字符串，然後使用tf.python_io.TFRecordWriter類的相關方法將字符串寫入一個TFRecords文件中，參見MNIST例子，將MNIST 數據轉換爲該類型數據。
2、讀取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

相關鏈接：

[1] 安裝Tensorflow（Linux ubuntu） http://blog.csdn.net/lenbow/article/details/51203526
[2] ubuntu下CUDA編譯的GCC降級安裝 http://blog.csdn.net/lenbow/article/details/51596706
[3] ubuntu手動安裝最新Nvidia顯卡驅動 http://blog.csdn.net/lenbow/article/details/51683783
[4] Tensorflow的CUDA升級，以及相關配置 http://blog.csdn.net/lenbow/article/details/52118116
[5] 基於gensim的Doc2Vec簡析 http://blog.csdn.net/lenbow/article/details/52120230
[6] TensorFlow的分佈式學習框架簡介 http://blog.csdn.net/lenbow/article/details/52130565
[7] Tensorflow一些常用基本概念與函數（1） http://blog.csdn.net/lenbow/article/details/52152766

【Tensorflow】Tensorflow一些常用基本概念與函數（2）

1、tensorflow的基本運作

2、tf函數

2.1 建立圖(Building Graphs)

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

* tensor類型(Tensor types)

* 通用函數（Utility functions）

* 圖收集（Graph collections）

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

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

* 佔位符（Placeholders）

* 讀取器（Readers）

* 數據轉換（Converting）

* Example protocol buffer

* 隊列(Queues)

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

* 輸入管道(Input pipeline)

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

【opencv3】視頻壓縮 ffmpeg

【Tensorflow keras】輕量級深度學習框架 Keras簡介

【Tensorflow】Tensorflow一些常用基本概念與函數（2）

【微積分】傅里葉變換及傅里葉級數

python操作mysql之pymysql

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結