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 resultsess.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 tfsess = 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 npsess = 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())

總結

以上是生活随笔為你收集整理的机器学习Tensorflow基础知识、张量与变量的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。