TensorFlow是一個採用資料流圖（data flow graphs），用於數值計算的開源軟體庫。節點（Nodes）在圖中表示數學操作，圖中的線（edges）則表示在節點間相互聯絡的多維資料陣列，即張量（tensor）。它靈活的架構讓你可以在多種平臺上展開計算，例如臺式計算機中的一個或多個CPU（或GPU），伺服器，移動裝置等等。TensorFlow 最初由Google大腦小組（隸屬於Google機器智慧研究機構）的研究員和工程師們開發出來，用於機器學習和深度神經網路方面的研究，但這個系統的通用性使其也可廣泛用於其他計算領域。

一、Tensorflow的特徵

• 高度的靈活性

TensorFlow 不是一個嚴格的“神經網路”庫。只要你可以將你的計算表示為一個數據流圖，你就可以使用Tensorflow。你來構建圖，描寫驅動計算的內部迴圈。我們提供了有用的工具來幫助你組裝“子圖”（常用於神經網路），當然使用者也可以自己在Tensorflow基礎上寫自己的“上層庫”。定義順手好用的新複合操作和寫一個python函式一樣容易，而且也不用擔心效能損耗。當然萬一你發現找不到想要的底層資料操作，你也可以自己寫一點c++程式碼來豐富底層的操作。

• 真正的可移植性（Portability）

Tensorflow 在CPU和GPU上執行，比如說可以執行在臺式機、伺服器、手機移動裝置等等。想要在沒有特殊硬體的前提下，在你的筆記本上跑一下機器學習的新想法？Tensorflow可以辦到這點。準備將你的訓練模型在多個CPU上規模化運算，又不想修改程式碼？Tensorflow可以辦到這點。想要將你的訓練好的模型作為產品的一部分用到手機app裡？Tensorflow可以辦到這點。你改變主意了，想要將你的模型作為雲端服務執行在自己的伺服器上，或者執行在Docker容器裡？Tensorfow也能辦到

• 多語言支援

Tensorflow 有一個合理的c++使用介面，也有一個易用的python使用介面來構建和執行你的graphs。你可以直接寫python/c++程式，也可以用互動式的ipython介面來用Tensorflow嘗試些想法，它可以幫你將筆記、程式碼、視覺化等有條理地歸置好。當然這僅僅是個起點——我們希望能鼓勵你創造自己最喜歡的語言介面，比如Go，Java，Lua，Javascript，或者是R

• 效能最優化

比如說你又一個32個CPU核心、4個GPU顯示卡的工作站，想要將你工作站的計算潛能全發揮出來？由於Tensorflow 給予了執行緒、佇列、非同步操作等以最佳的支援，Tensorflow 讓你可以將你手邊硬體的計算潛能全部發揮出來。你可以自由地將Tensorflow圖中的計算元素分配到不同裝置上，Tensorflow可以幫你管理好這些不同副本。

二、下載以及安裝

選擇型別

必須選擇以下型別的TensorFlow之一來安裝：

• TensorFlow僅支援CPU支​​持。如果您的系統沒有NVIDIA®GPU，則必須安裝此版本。請注意，此版本的TensorFlow通常會更容易安裝（通常在5或10分鐘內），因此即使您有NVIDIA GPU，我們建議先安裝此版本。
• TensorFlow支援GPU。TensorFlow程式通常在GPU上比在CPU上執行得更快。因此，如果您的系統具有滿足以下所示先決條件的NVIDIA®GPU，並且您需要執行效能關鍵型應用程式，則應最終安裝此版本。

Ubuntu和Linux

如果要安裝GPU版本的，需要安裝一大堆NVIDIA軟體(不推薦)：

• CUDA®Toolkit 8.0。有關詳細資訊，請參閱 NVIDIA的文件。確保您將相關的Cuda路徑名附加到 LD_LIBRARY_PATH環境變數中，如NVIDIA文件中所述。與CUDA Toolkit 8.0相關的NVIDIA驅動程式。
• cuDNN v5.1。有關詳細資訊，請參閱 NVIDIA的文件。確保CUDA_HOME按照NVIDIA文件中的描述建立環境變數。
• 具有CUDA Compute Capability 3.0或更高版本的GPU卡。有關支援的GPU卡的列表，請參閱 NVIDIA文件。
• libcupti-dev庫，即NVIDIA CUDA Profile Tools介面。此庫提供高階分析支援。要安裝此庫，請發出以下命令：

使用pip安裝,分別有2.7和3.6版本的

# 僅使用 CPU 的版本
$  pip install https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.0.1-cp27-none-linux_x86_64.whl

$  pip3 install https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.0.1-cp36-cp36m-linux_x86_64.whl

Mac

macX下也可以安裝2.7和3.4、3.5的CPU版本

# 2.7
$ pip install https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.0.1-py2-none-any.whl

# 3.4、3.5
$ pip3 install https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.0.1-py3-none-any.whl

三、初識tf

使用 TensorFlow, 你必須明白 TensorFlow：

Tensorflow有一下幾個簡單的步驟：

• 使用 tensor 表示資料.
• 使用圖 (graph) 來表示計算任務.
• 在會話（session)中執行圖s

關於新版本

TensorFlow提供多種API。最低階API為您提供完整的程式設計控制。請注意，tf.contrib.learn這樣的高階API可以幫助您管理資料集，估計器，培訓和推理。一些高階TensorFlow API（方法名稱包含的那些）contrib仍在開發中。某些contrib方法可能會在隨後的TensorFlow版本中發生變化或變得過時。這個模組類似於scikit-learn中演算法模型。

在 TF 中發生的所有事，都是在會話（Session） 中進行的。所以，當你在 TF 中編寫一個加法時，其實你只是設計了一個加法操作，而不是實際新增任何東西。所有的這些設計都是會在圖（Graph）中產生，你會在圖中保留這些計算操作和張量，而不是具體的值。

圖

TensorFlow程式通常被組織成一個構建階段和一個執行階段. 在構建階段, op的執行步驟被描述成一個圖. 在執行階段, 使用會話執行執行圖中的op。我們來構建一個簡單的計算圖。每個節點採用零個或多個張量作為輸入，併產生張量作為輸出。一種型別的節點是一個常數。像所有TensorFlow常數一樣，它不需要任何輸入，它輸出一個內部儲存的值。我們可以建立兩個浮點型常量node1 ，node2如下所示：

node1 = tf.constant(3.0, tf.float32)
node2 = tf.constant(4.0)
print(node1, node2)

最終的列印宣告生成

Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)

他為什麼不是輸出結果，那是因為tensorflow中的圖形節點操作必須在會話中執行，稍後介紹

構建圖

構建圖的第一步, 是建立源 op (source op). 源 op 不需要任何輸入, 例如 常量 (Constant). 源 op 的輸出被傳遞給其它 op 做運算.TensorFlow Python 庫有一個預設圖 (default graph), op 構造器可以為其增加節點. 這個預設圖對 許多程式來說已經足夠用了.，後面我們會接觸多個圖的使用

預設Graph值始終註冊，並可通過呼叫訪問 tf.get_default_graph()

import tensorflow as tf

# 建立一個常量 op, 產生一個 1x2 矩陣. 這個 op 被作為一個節點,加到預設圖中.構造器的返回值代表該常量 op 的返回值.
matrix1 = tf.constant([[3., 3.]])

# 建立另外一個常量 op, 產生一個 2x1 矩陣.
matrix2 = tf.constant([[2.],[2.]])

# 建立一個矩陣乘法 matmul op , 把 'matrix1' 和 'matrix2' 作為輸入.返回值 'product' 代表矩陣乘法的結果.
product = tf.matmul(matrix1, matrix2)

print tf.get_default_graph(),matrix1.graph,matrix2.graph

重要注意事項：此類對於圖形構造不是執行緒安全的。所有操作都應從單個執行緒建立，或者必須提供外部同步。除非另有說明，所有方法都不是執行緒安全的

在會話中啟動圖

構造階段完成後，才能啟動圖。啟動圖的第一步是建立一個Session物件，如果無任何建立引數，會話構造器將啟動預設圖。

呼叫Session的run()方法來執行矩陣乘法op, 傳入product作為該方法的引數，會話負責傳遞op所需的全部輸入，op通常是併發執行的。

# 啟動預設圖.
sess = tf.Session()

# 函式呼叫 'run(product)' 觸發了圖中三個 op (兩個常量 op 和一個矩陣乘法 op) 的執行.返回值 'result' 是一個 numpy `ndarray` 物件.
result = sess.run(product)
print result

# 任務完成, 關閉會話.
sess.close()

Session物件在使用完後需要關閉以釋放資源，當然也可以使用上下文管理器來完成自動關閉動作。

op

計算圖中的每個節點可以有任意多個輸入和任意多個輸出，每個節點描述了一種運算操作（operation, op），節點可以算作運算操作的例項化（instance）。一種運算操作代表了一種型別的抽象運算，比如矩陣乘法、加法。tensorflow內建了很多種運算操作，如下表所示：

型別	示例
標量運算	Add、Sub、Mul、Div、Exp、Log、Greater、Less、Equal
向量運算	Concat、Slice、Splot、Constant、Rank、Shape、Shuffle
矩陣運算	Matmul、MatrixInverse、MatrixDeterminant
帶狀態的運算	Variable、Assign、AssignAdd
神經網路元件	SoftMax、Sigmoid、ReLU、Convolution2D、MaxPooling
儲存、恢復	Save、Restore
佇列及同步運算	Enqueue、Dequeue、MutexAcquire、MutexRelease
控制流	Merge、Switch、Enter、Leave、NextIteration

feed

TensorFlow還提供了feed機制, 該機制可以臨時替代圖中的任意操作中的tensor可以對圖中任何操作提交補丁,直接插入一個 tensor。feed 使用一個 tensor 值臨時替換一個操作的輸入引數，從而替換原來的輸出結果.

feed 只在呼叫它的方法內有效, 方法結束,feed就會消失。最常見的用例是將某些特殊的操作指定為"feed"操作, 標記的方法是使用 tf.placeholder() 為這些操作建立佔位符.並且在Session.run方法中增加一個feed_dict引數

# 建立兩個個浮點數佔位符op
input1 = tf.placeholder(tf.types.float32)
input2 = tf.placeholder(tf.types.float32)

#增加一個乘法op
output = tf.mul(input1, input2)

with tf.Session() as sess:
  # 替換input1和input2的值
  print sess.run([output], feed_dict={input1:[7.], input2:[2.]})

如果沒有正確提供feed, placeholder() 操作將會產生錯誤

四、張量的階和資料型別

TensorFlow用張量這種資料結構來表示所有的資料.你可以把一個張量想象成一個n維的陣列或列表.一個張量有一個靜態型別和動態型別的維數.張量可以在圖中的節點之間流通.其實張量更代表的就是一種多位陣列。

階

在TensorFlow系統中，張量的維數來被描述為階.但是張量的階和矩陣的階並不是同一個概念.張量的階（有時是關於如順序或度數或者是n維）是張量維數的一個數量描述.比如，下面的張量（使用Python中list定義的）就是2階.

t = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

你可以認為一個二階張量就是我們平常所說的矩陣，一階張量可以認為是一個向量.

階	數學例項	Python	例子
0	純量	(只有大小)	s = 483
1	向量	(大小和方向)	v = [1.1, 2.2, 3.3]
2	矩陣	(資料表)	m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
3	3階張量	(資料立體)	t = [[[2], [4], [6]], [[8], [10], [12]], [[14], [16], [18]]]
n	n階	(自己想想看)	....

資料型別

Tensors有一個數據型別屬性.你可以為一個張量指定下列資料型別中的任意一個型別:

資料型別	Python 型別	描述
DT_FLOAT	tf.float32	32 位浮點數.
DT_DOUBLE	tf.float64	64 位浮點數.
DT_INT64	tf.int64	64 位有符號整型.
DT_INT32	tf.int32	32 位有符號整型.
DT_INT16	tf.int16	16 位有符號整型.
DT_INT8	tf.int8	8 位有符號整型.
DT_UINT8	tf.uint8	8 位無符號整型.
DT_STRING	tf.string	可變長度的位元組陣列.每一個張量元素都是一個位元組陣列.
DT_BOOL	tf.bool	布林型.
DT_COMPLEX64	tf.complex64	由兩個32位浮點陣列成的複數:實數和虛數.
DT_QINT32	tf.qint32	用於量化Ops的32位有符號整型.
DT_QINT8	tf.qint8	用於量化Ops的8位有符號整型.
DT_QUINT8	tf.quint8	用於量化Ops的8位無符號整型.

五、張量操作

在tensorflow中，有很多操作張量的函式，有生成張量、建立隨機張量、張量型別與形狀變換和張量的切片與運算

生成張量

固定值張量

tf.zeros(shape, dtype=tf.float32, name=None)

建立所有元素設定為零的張量。此操作返回一個dtype具有形狀shape和所有元素設定為零的型別的張量。

tf.zeros_like(tensor, dtype=None, name=None)

給tensor定單張量（），此操作返回tensor與所有元素設定為零相同的型別和形狀的張量。

tf.ones(shape, dtype=tf.float32, name=None)

建立一個所有元素設定為1的張量。此操作返回一個型別的張量，dtype形狀shape和所有元素設定為1。

tf.ones_like(tensor, dtype=None, name=None)

給tensor定單張量（），此操作返回tensor與所有元素設定為1 相同的型別和形狀的張量。

tf.fill(dims, value, name=None)

建立一個填充了標量值的張量。此操作建立一個張量的形狀dims並填充它value。

tf.constant(value, dtype=None, shape=None, name='Const')

建立一個常數張量。

用常數張量作為例子

t1 = tf.constant([1, 2, 3, 4, 5, 6, 7])

t2 = tf.constant(-1.0, shape=[2, 3])

print(t1,t2)

我們可以看到在沒有執行的時候，輸出值為：

(<tf.Tensor 'Const:0' shape=(7,) dtype=int32>, <tf.Tensor 'Const_1:0' shape=(2, 3) dtype=float32>)

一個張量包含了一下幾個資訊

• 一個名字，它用於鍵值對的儲存，用於後續的檢索：Const: 0
• 一個形狀描述， 描述資料的每一維度的元素個數：（2，3）
• 資料型別，比如int32,float32

建立隨機張量

一般我們經常使用的隨機數函式 Math.random() 產生的是服從均勻分佈的隨機數，能夠模擬等概率出現的情況，例如 扔一個骰子，1到6點的概率應該相等，但現實生活中更多的隨機現象是符合正態分佈的，例如20歲成年人的體重分佈等。

假如我們在製作一個遊戲，要隨機設定許許多多 NPC 的身高，如果還用Math.random()，生成從140 到 220 之間的數字，就會發現每個身高段的人數是一樣多的，這是比較無趣的，這樣的世界也與我們習慣不同，現實應該是特別高和特別矮的都很少，處於中間的人數最多，這就要求隨機函式符合正態分佈。

tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

從截斷的正態分佈中輸出隨機值，和 tf.random_normal() 一樣，但是所有數字都不超過兩個標準差

tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

從正態分佈中輸出隨機值，由隨機正態分佈的數字組成的矩陣

# 正態分佈的 4X4X4 三維矩陣，平均值 0， 標準差 1
normal = tf.truncated_normal([4, 4, 4], mean=0.0, stddev=1.0)

a = tf.Variable(tf.random_normal([2,2],seed=1))
b = tf.Variable(tf.truncated_normal([2,2],seed=2))
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    print(sess.run(a))
    print(sess.run(b))

輸出：
[[-0.81131822  1.48459876]
 [ 0.06532937 -2.44270396]]
[[-0.85811085 -0.19662298]
 [ 0.13895047 -1.22127688]]

tf.random_uniform(shape, minval=0.0, maxval=1.0, dtype=tf.float32, seed=None, name=None)

從均勻分佈輸出隨機值。生成的值遵循該範圍內的均勻分佈 [minval, maxval)。下限minval包含在範圍內，而maxval排除上限。

a = tf.random_uniform([2,3],1,10)

with tf.Session() as sess:
  print(sess.run(a))

tf.random_shuffle(value, seed=None, name=None)

沿其第一維度隨機打亂

tf.set_random_seed(seed)

設定圖級隨機種子

要跨會話生成不同的序列，既不設定圖級別也不設定op級別的種子：

a = tf.random_uniform([1])
b = tf.random_normal([1])

print "Session 1"
with tf.Session() as sess1:
  print sess1.run(a)  
  print sess1.run(a)  
  print sess1.run(b)
  print sess1.run(b)  

print "Session 2"
with tf.Session() as sess2:
  print sess2.run(a)
  print sess2.run(a)
  print sess2.run(b)
  print sess2.run(b)

要為跨會話生成一個可操作的序列，請為op設定種子：

a = tf.random_uniform([1], seed=1)
b = tf.random_normal([1])


print "Session 1"
with tf.Session() as sess1:
  print sess1.run(a)
  print sess1.run(a)
  print sess1.run(b)
  print sess1.run(b)

print "Session 2"
with tf.Session() as sess2:
  print sess2.run(a)
  print sess2.run(a)  
  print sess2.run(b)
  print sess2.run(b)

為了使所有op產生的隨機序列在會話之間是可重複的,設定一個圖級別的種子：

tf.set_random_seed(1234)
a = tf.random_uniform([1])
b = tf.random_normal([1])


print "Session 1"
with tf.Session() as sess1:
  print sess1.run(a)
  print sess1.run(a)
  print sess1.run(b)
  print sess1.run(b)

print "Session 2"
with tf.Session() as sess2:
  print sess2.run(a)
  print sess2.run(a)
  print sess2.run(b)
  print sess2.run(b)

我們可以看到結果

張量變換

TensorFlow提供了幾種操作，您可以使用它們在圖形中改變張量資料型別。

改變型別

提供瞭如下一些改變張量中數值型別的函式

• tf.string_to_number(string_tensor, out_type=None, name=None)
• tf.to_double(x, name='ToDouble')
• tf.to_float(x, name='ToFloat')
• tf.to_bfloat16(x, name='ToBFloat16')
• tf.to_int32(x, name='ToInt32')
• tf.to_int64(x, name='ToInt64')
• tf.cast(x, dtype, name=None)

我們用一個其中一個舉例子

tf.string_to_number(string_tensor, out_type=None, name=None)

將輸入Tensor中的每個字串轉換為指定的數字型別。注意，int32溢位導致錯誤，而浮點溢位導致舍入值

n1 = tf.constant(["1234","6789"])
n2 = tf.string_to_number(n1,out_type=tf.types.float32)

sess = tf.Session()

result = sess.run(n2)
print result

sess.close()

形狀和變換

可用於確定張量的形狀並更改張量的形狀

• tf.shape(input, name=None)
• tf.size(input, name=None)
• tf.rank(input, name=None)
• tf.reshape(tensor, shape, name=None)
• tf.squeeze(input, squeeze_dims=None, name=None)
• tf.expand_dims(input, dim, name=None)

tf.shape(input, name=None)

返回張量的形狀。

t = tf.constant([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]])
shape(t) -> [2, 2, 3]

靜態形狀與動態形狀

靜態維度 是指當你在建立一個張量或者由操作推匯出一個張量時，這個張量的維度是確定的。它是一個元祖或者列表。TensorFlow將盡最大努力去猜測不同張量的形狀（在不同操作之間），但是它不會總是能夠做到這一點。特別是如果您開始用未知維度定義的佔位符執行操作。tf.Tensor.get_shape方法讀取靜態形狀

t = tf.placeholder(tf.float32,[None,2])
print(t.get_shape())

結果

動態形狀 當你在執行你的圖時，動態形狀才是真正用到的。這種形狀是一種描述原始張量在執行過程中的一種張量。如果你定義了一個沒有標明具體維度的佔位符，即用None表示維度，那麼當你將值輸入到佔位符時，這些無維度就是一個具體的值，並且任何一個依賴這個佔位符的變數，都將使用這個值。tf.shape來描述動態形狀

t = tf.placeholder(tf.float32,[None,2])
print(tf.shape(t))

tf.squeeze(input, squeeze_dims=None, name=None)

這個函式的作用是將input中維度是1的那一維去掉。但是如果你不想把維度是1的全部去掉，那麼你可以使用squeeze_dims引數，來指定需要去掉的位置。

import tensorflow as tf

sess = tf.Session()
data = tf.constant([[1, 2, 1], [3, 1, 1]])
print sess.run(tf.shape(data))
d_1 = tf.expand_dims(data, 0)
d_1 = tf.expand_dims(d_1, 2)
d_1 = tf.expand_dims(d_1, -1)
d_1 = tf.expand_dims(d_1, -1)
print sess.run(tf.shape(d_1))
d_2 = d_1
print sess.run(tf.shape(tf.squeeze(d_1)))
print sess.run(tf.shape(tf.squeeze(d_2, [2, 4])))

tf.expand_dims(input, dim, name=None)

該函式作用與squeeze相反,新增一個指定維度

import tensorflow as tf
import numpy as np

sess = tf.Session()
data = tf.constant([[1, 2, 1], [3, 1, 1]])
print sess.run(tf.shape(data))
d_1 = tf.expand_dims(data, 0)
print sess.run(tf.shape(d_1))
d_1 = tf.expand_dims(d_1, 2)
print sess.run(tf.shape(d_1))
d_1 = tf.expand_dims(d_1, -1)
print sess.run(tf.shape(d_1))

切片與擴充套件

TensorFlow提供了幾個操作來切片或提取張量的部分，或者將多個張量加在一起

• tf.slice(input_, begin, size, name=None)
• tf.split(split_dim, num_split, value, name='split')
• tf.tile(input, multiples, name=None)
• tf.pad(input, paddings, name=None)
• tf.concat(concat_dim, values, name='concat')
• tf.pack(values, name='pack')
• tf.unpack(value, num=None, name='unpack')
• tf.reverse_sequence(input, seq_lengths, seq_dim, name=None)
• tf.reverse(tensor, dims, name=None)
• tf.transpose(a, perm=None, name='transpose')
• tf.gather(params, indices, name=None)
• tf.dynamic_partition(data, partitions, num_partitions, name=None)
• tf.dynamic_stitch(indices, data, name=None)

其它一些張量運算（瞭解查閱）

張量複製與組合

• tf.identity(input, name=None)
• tf.tuple(tensors, name=None, control_inputs=None)
• tf.group(inputs, *kwargs)
• tf.no_op(name=None)
• tf.count_up_to(ref, limit, name=None)

邏輯運算子

• tf.logical_and(x, y, name=None)
• tf.logical_not(x, name=None)
• tf.logical_or(x, y, name=None)
• tf.logical_xor(x, y, name='LogicalXor')

比較運算子

• tf.equal(x, y, name=None)
• tf.not_equal(x, y, name=None)
• tf.less(x, y, name=None)
• tf.less_equal(x, y, name=None)
• tf.greater(x, y, name=None)
• tf.greater_equal(x, y, name=None)
• tf.select(condition, t, e, name=None)
• tf.where(input, name=None)

判斷檢查

• tf.is_finite(x, name=None)
• tf.is_inf(x, name=None)
• tf.is_nan(x, name=None)
• tf.verify_tensor_all_finite(t, msg, name=None) 斷言張量不包含任何NaN或Inf
• tf.check_numerics(tensor, message, name=None)
• tf.add_check_numerics_ops()
• tf.Assert(condition, data, summarize=None, name=None)
• tf.Print(input_, data, message=None, first_n=None, summarize=None, name=None)

六、變數的的建立、初始化、儲存和載入

其實變數的作用在語言中相當，都有儲存一些臨時值的作用或者長久儲存。在Tensorflow中當訓練模型時，用變數來儲存和更新引數。變數包含張量（Tensor）存放於記憶體的快取區。建模時它們需要被明確地初始化，模型訓練後它們必須被儲存到磁碟。值可在之後模型訓練和分析是被載入。

Variable類

tf.Variable.init(initial_value, trainable=True, collections=None, validate_shape=True, name=None)

建立一個帶值的新變數initial_value

• initial_value:A Tensor或Python物件可轉換為a Tensor.變數的初始值.必須具有指定的形狀,除非 validate_shape設定為False.

• trainable:如果True，預設值也將該變數新增到圖形集合GraphKeys.TRAINABLE_VARIABLES,該集合用作Optimizer類要使用的變數的預設列表

• collections:圖表集合鍵列表,新變數新增到這些集合中.預設為[GraphKeys.VARIABLES]

• validate_shape:如果False允許使用未知形狀的值初始化變數,如果True，預設形狀initial_value必須提供.

• name:變數的可選名稱,預設'Variable'並自動獲取

變數的建立

建立當一個變數時，將你一個張量作為初始值傳入建構函式Variable().TensorFlow提供了一系列操作符來初始化張量，值初始的英文常量或是隨機值。像任何一樣Tensor，建立的變數Variable()可以用作圖中其他操作的輸入。此外，為Tensor該類過載的所有運算子都被轉載到變數中，因此您也可以通過對變數進行算術來將節點新增到圖形中。

x = tf.Variable(5.0,name="x")
weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),name="weights")
biases = tf.Variable(tf.zeros([200]), name="biases")

呼叫tf.Variable()向圖中添加了幾個操作：

• 一個variable op儲存變數值。
• 初始化器op將變數設定為其初始值。這實際上是一個tf.assign操作。
• 初始值的ops，例如 示例中biases變數的zeros op 也被新增到圖中。

變數的初始化

• 變數的初始化必須在模型的其它操作執行之前先明確地完成。最簡單的方法就是新增一個給所有變數初始化的操作，並在使用模型之前首先執行那個操作。最常見的初始化模式是使用便利函式 initialize_all_variables()將Op新增到初始化所有變數的圖形中。

init_op = tf.global_variables_initializer()

with tf.Session() as sess:
  sess.run(init_op)

• 還可以通過執行其初始化函式op來初始化變數，從儲存檔案還原變數，或者簡單地執行assign向變數分配值的Op。實際上，變數初始化器op只是一個assignOp，它將變數的初始值賦給變數本身。assign是一個方法，後面方法的時候會提到

with tf.Session() as sess:
    sess.run(w.initializer)

通過另一個變數賦值

你有時候會需要用另一個變數的初始化值給當前變數初始化，由於tf.global_variables_initializer()初始化所有變數，所以需要注意這個方法的使用。

就是將已初始化的變數的值賦值給另一個新變數！

weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),name="weights")

w2 = tf.Variable(weights.initialized_value(), name="w2")

w_twice = tf.Variable(weights.initialized_value() * 0.2, name="w_twice")

所有變數都會自動收集到建立它們的圖形中。預設情況下，建構函式將新變數新增到圖形集合GraphKeys.GLOBAL_VARIABLES。方便函式 global_variables()返回該集合的內容。

屬性

name

返回變數的名字

weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),name="weights")
print(weights.name)

op

返回op操作

weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35))
print(weights.op)

方法

assign

為變數分配一個新值。

x = tf.Variable(5.0,name="x")
w.assign(w + 1.0)

eval

在會話中，計算並返回此變數的值。這不是一個圖形構造方法，它不會向圖形新增操作。方便列印結果

v = tf.Variable([1, 2])
init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)

    # 指定會話
    print(v.eval(sess))
    # 使用預設會話
    print(v.eval())

變數的靜態形狀與動態形狀

TensorFlow中，張量具有靜態（推測）形狀和動態（真實）形狀

• 靜態形狀：

建立一個張量或者由操作推匯出一個張量時,初始狀態的形狀

• tf.Tensor.get_shape:獲取靜態形狀
• tf.Tensor.set_shape():更新Tensor物件的靜態形狀，通常用於在不能直接推斷的情況下

• 動態形狀：

一種描述原始張量在執行過程中的一種形狀

• tf.shape(tf.Tensor):如果在執行的時候想知道None到底是多少,只能通過tf.shape(tensor)[0]這種方式來獲得
• tf.reshape:建立一個具有不同動態形狀的新張量

要點

1、轉換靜態形狀的時候，1-D到1-D，2-D到2-D，不能跨階數改變形狀

2、 對於已經固定或者設定靜態形狀的張量／變數，不能再次設定靜態形狀

3、tf.reshape()動態建立新張量時，元素個數不能不匹配

4、執行時候，動態獲取張量的形狀值，只能通過tf.shape(tensor)[]

管理圖中收集的變數

tf.global_variables()

返回圖中收集的所有變數

weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35))

print(tf.global_variables())