令人困惑的TensorFlow！谷歌大腦工程師幫你解決麻煩

1. TensorFlow 不是一個標準的 Python 庫

大多數 Python 庫被編寫為 Python 的自然擴充套件形式。當你匯入一個庫時，你得到的是一組變數、函式和類，他們擴充套件並補充了你的程式碼「工具箱」。當你使用它們時，你能預期到傳回的結果是怎樣的。在我看來，當談及 TensorfFlow 時，應該把這種認知完全拋棄。思考什麼是 TensorFlow 及其如何與其他程式碼進行互動從根本上來說就是錯誤的。

Python 和 TensorFlow 之間的關係可以類比 Javascript 和 HTML 之間的關係。Javascript 是一種全功能的程式語言，可以做各種美妙的事情。HTML 是用於表示某種型別的實用計算抽象（此處指可由 Web 瀏覽器呈現的內容）的框架。Javascript 在互動式網頁中的作用是組裝瀏覽器看到的 HTML 物件，然後在需要時透過將其更新為新的 HTML 來與其互動。

與 HTML 類似，TensorFlow 是用於表示某種型別的計算抽象（稱為「計算圖」）的框架。但我們用 Python 操作 TensorFlow 時，我們用 Pyhton 程式碼做的第一件事就是構建計算圖。一旦完成，我們做的第二件事就是與它進行互動（啟動 TensorFlow 的「會話」）。

但重要的是，要記住計算圖不在變數內部；而是處在全域性名稱空間中。正如莎士比亞所說：「所有的 RAM 都是一個階段，所有的變數都僅僅是指標」。

2. 第一個關鍵抽象：計算圖

當你在瀏覽 TensorFlow 檔案時，可能會發現對「圖形」和「節點」的間接取用。如果你仔細閱讀，你甚至可能已經發現了這個頁面（https://www.tensorflow.org/programmers_guide/graphs），該頁面涵蓋了我將以更準確和技術化的方式去解釋的內容。本節是一篇高階攻略，把握重要的直覺概念，同時忽略一些技術細節。

那麼：什麼是計算圖？它本質上是一個全域性資料結構：是一個有向圖，用於捕獲有關如何計算的指令。

讓我們來看看構建計算圖的一個示例。在下圖中，上半部分是我們執行的程式碼及其輸出，下半部分是生成的計算圖。

import tensorflow as tf

計算圖：

可見，僅僅匯入 TensorFlow 並不會給我們生成一個有趣的計算圖。而只是一個單獨的，空白的全域性變數。但當我們呼叫一個 TensorFlow 操作時，會發生什麼？

程式碼：

import tensorflow as tf
two_node = tf.constant(2)
print two_node

輸出：

Tensor("Const:0", shape=(), dtype=int32)

計算圖：

快看！我們得到了一個節點。它包含常量 2。很驚訝吧，這來自於一個名為 tf.constant 的函式。當我們列印這個變數時，我們看到它傳回一個 tf.Tensor 物件，它是一個指向我們剛剛建立的節點的指標。為了強調這一點，以下是另外一個示例：

程式碼：

import tensorflow as tf
two_node = tf.constant(2)
another_two_node = tf.constant(2)
two_node = tf.constant(2)
tf.constant(3)

計算圖：

每次我們呼叫 tf.constant 時，我們都會在圖中建立一個新的節點。即使該節點的功能與現有節點相同，即使我們將節點重新分配給同一個變數，或者即使我們根本沒有將其分配給一個變數，結果都是一樣的。

程式碼：

import tensorflow as tf
two_node = tf.constant(2)
another_pointer_at_two_node = two_node
two_node = None
print two_node
print another_pointer_at_two_node

輸出：

None
Tensor("Const:0", shape=(), dtype=int32)

計算圖：

好啦，讓我們更進一步：

程式碼：

import tensorflow as tf
two_node = tf.constant(2)
three_node = tf.constant(3)
sum_node = two_node + three_node ## equivalent to tf.add(two_node, three_node)

計算圖：

現在我們正談論—這才是我們真正想要的計算圖！請註意，+ 操作在 TensorFlow 中過載，因此同時新增兩個張量會在圖中增加一個節點，儘管它錶面上看起來不像是 TensorFlow 操作。

那好，所以 two_node 指向包含 2 的節點，three_node 指向包含 3 的節點，同時 sum_node 指向包含 …+ 的節點？怎麼回事？它不是應該包含 5 嗎？

事實證明，並沒有。計算圖只包含計算步驟；不包含結果。至少……現在還沒有！

3. 第二個關鍵抽象： 會話

如果錯誤地理解 TensorFlow 抽象概念也有個「瘋狂三月」（NCAA 籃球錦標賽，大部分在三月進行），那麼會話將成為每年的一號種子選手。會話有著那樣令人困惑的殊榮是因為其反直覺的命名卻又普遍存在—幾乎每個 TensorFlow 呈現都至少一次明確地呼叫 tf.Session()。

會話的作用是處理記憶體分配和最佳化，使我們能夠實際執行由計算圖指定的計算。你可以將計算圖想象為我們想要執行的計算的「模版」：它列出了所有步驟。

為了使用計算圖，我們需要啟動一個會話，它使我們能夠實際地完成任務；例如，遍歷模版的所有節點來分配一堆用於儲存計算輸出的儲存器。為了使用 TensorFlow 進行各種計算，你既需要計算圖也需要會話。

會話包含一個指向全域性圖的指標，該指標透過指向所有節點的指標不斷更新。這意味著在建立節點之前還是之後建立會話都無所謂。

建立會話物件後，可以使用 sess.run(node) 傳回節點的值，並且 TensorFlow 將執行確定該值所需的所有計算。

程式碼：

import tensorflow as tf
two_node = tf.constant(2)
three_node = tf.constant(3)
sum_node = two_node + three_node
sess = tf.Session()
print sess.run(sum_node)

輸出：

5

計算圖：

太好了！我們也可以傳遞一個串列，sess.run([node1, node2, …])，並讓它傳回多個輸出：

程式碼：

import tensorflow as tf
two_node = tf.constant(2)
three_node = tf.constant(3)
sum_node = two_node + three_node
sess = tf.Session()
print sess.run([two_node, sum_node])

輸出：

[2, 5]

計算圖：

一般來說，sess.run() 的呼叫往往是 TensorFlow 最大的瓶頸之一，因此呼叫它的次數越少越好。如果可以的話，在一個 sess.run() 的呼叫中傳回多個專案，而不是進行多個呼叫。

4. 佔位符和 feed_dict

迄今為止，我們所做的計算一直很乏味：沒有機會獲得輸入，所以它們總是輸出相同的東西。一個更有價值的應用可能涉及構建一個計算圖，它接受輸入，以某種（一致）方式處理它，並傳回一個輸出。

最直接的方法是使用佔位符。佔位符是一種用於接受外部輸入的節點。

程式碼：

import tensorflow as tf
input_placeholder = tf.placeholder(tf.int32)
sess = tf.Session() 
print sess.run(input_placeholder)

輸出：

Traceback (most recent call last):
...
InvalidArgumentError (see above *for* traceback): You must feed a value *for* placeholder tensor 'Placeholder' *with* dtype int32
 [[Node: Placeholder = Placeholder[dtype=DT_INT32, shape=, _device="/job:localhost/replica:0/task:0/device:CPU:0"]()]]

計算圖：

… 這是一個糟糕的例子，因為它引發了一個異常。佔位符預計會被賦予一個值。但我們沒有提供一個值，所以 TensorFlow 崩潰了。

為了提供一個值，我們使用 sess.run() 的 feed_dixt 屬性。

程式碼：

import tensorflow as tf 
input_placeholder = tf.placeholder(tf.int32) 
sess = tf.Session() 
print sess.run(input_placeholder, feed_dict={input_placeholder: 2})

輸出：

2

計算圖：

這就好多了。註意傳遞給 feed_dict 的 dict 格式，其關鍵應該是與圖中的佔位符節點相對應的變數（如前所述，它實際上意味著指向圖中佔位符節點的指標）。相應的值是要分配給每個佔位符的資料元素——通常是標量或 Numpy 陣列。

5. 第三個關鍵抽象：計算路徑

讓我們看看另一個使用佔位符的示例：

程式碼：

import tensorflow as tf
input_placeholder = tf.placeholder(tf.int32)
three_node = tf.constant(3)
sum_node = input_placeholder + three_node
sess = tf.Session()
print sess.run(three_node)
print sess.run(sum_node)

輸出：

3
Traceback (most recent call last):
...
InvalidArgumentError (see above for traceback): You must feed a value *for* placeholder tensor 'Placeholder_2' with dtype int32
 [[Node: Placeholder_2 = Placeholder[dtype=DT_INT32, shape=, _device="/job:localhost/replica:0/task:0/device:CPU:0"]()]]

計算圖：

為什麼第二次呼叫 sess.run() 會失敗？即使我們沒有評估 input_placeholder，為什麼仍會引發與 input_placeholder 相關的錯誤？答案在於最終的關鍵 TensorFlow 抽象：計算路徑。幸運的是，這個抽象非常直觀。

當我們在依賴於圖中其他節點的節點上呼叫 sess.run() 時，我們也需要計算那些節點的值。如果這些節點具有依賴關係，那麼我們需要計算這些值（依此類推……），直到達到計算圖的「頂端」，即節點沒有父節點時。

sum_node 的計算路徑：

所有三個節點都需要進行求值以計算 sum_node 的值。最重要的是，這包含了我們未填充的佔位符，並解釋了異常！

現在來看 three_node 的計算路徑：

根據圖結構，我們不需要計算所有節點才能評估我們想要的節點！因為我們在評估 three_node 時不需要評估 placehoolder_node，所以執行 sess.run(three_node) 不會引發異常。

TensorFlow 僅透過必需的節點自動進行計算這一事實是該框架的一個巨大優勢。如果計算圖非常大並且有許多不必要的節點，那麼它可以節省大量呼叫的執行時間。它允許我們構建大型的「多用途」計算圖，這些計算圖使用單個共享的核心節點集合，並根據所採取的不同計算路徑去做不同的事情。對於幾乎所有應用而言，根據所採取的計算路徑考慮 sess.run() 的呼叫是很重要的。

6. 變數 & 副作用

至此，我們已經看到兩種型別的「無祖先」節點（no-ancestor node）：每次執行都一樣的 tf.constant 和每次執行都不一樣的 tf.placeholder。我們常常要考慮第三種情況：一個通常在執行時保持值不變的節點也可以被更新為新值。

這時就需要引入變數。

變數對於使用 TensorFlow 進行深度學習是至關重要的，因為模型的引數就是變數。在訓練期間，你希望透過梯度下降在每個步驟更新引數；但在評估時，你希望保持引數不變，並將大量不同的測試集輸入模型。通常，模型所有可訓練引數都是變數。

要建立變數，就需要使用 tf.get_variable()。tf.get_variable() 的前兩個引數是必需的，其餘引數是可選的。它們是 tf.get_variable(name，shape)。name 是一個唯一標識這個變數物件的字串。它必須相對於全域性圖是唯一的，所以要明瞭你使用過的所有命名，確保沒有重覆。shape 是與張量形狀對應的整數陣列，它的語法非常直觀：按順序，每個維度只有一個整數。例如，一個 3×8 矩陣形狀是 [3, 8]。要建立一個標量，就需要使用形狀為 [] 的空串列。

程式碼：

import tensorflow as tf
count_variable = tf.get_variable("count", [])
sess = tf.Session()
print sess.run(count_variable)

輸出：

Traceback (most recent call last):
...
tensorflow.python.framework.errors_impl.FailedPreconditionError: Attempting to use uninitialized value count
 [[Node: _retval_count_0_0 = _Retval[T=DT_FLOAT, index=0, _device="/job:localhost/replica:0/task:0/device:CPU:0"](count)]]

計算圖：

噫，另一個異常。當首次建立變數節點時，它的值基本上為「null」，並且任何試圖對它求值的操作都會引發這個異常。我們只能在將值放入變數之後才能對其求值。主要有兩種將值放入變數的方法：初始化器和 tf.assign()。我們先看看 tf.assign()：

程式碼：

import tensorflow as tf
count_variable = tf.get_variable("count", [])
zero_node = tf.constant(0.)
assign_node = tf.assign(count_variable, zero_node)
sess = tf.Session()
sess.run(assign_node)
print sess.run(count_variable)

輸出：

0

計算圖：

與我們迄今為止見過的節點相比，tf.assign(target, value) 是具備一些獨特屬性：

• 恆等運算。tf.assign(target, value) 不做任何有趣的運算，通常與 value 相等。

• 副作用。當計算「流經」assign_node 時，副作用發生在圖中的其他節點上。此時，副作用是用儲存在 zero_node 中的值替換 count_variable 的值。

• 非依賴邊。即使 count_variable 節點和 assign_node 在圖中是相連的，但它們彼此獨立。這意味著計算任一節點時，計算不會透過邊迴流。然而，assign_node 依賴於 zero_node，它需要知道分配了什麼。

「副作用」節點支撐著大部分 Tensorflow 深度學習工作流程，所以請確保自己真正理解了在該節點發生的事情。當我們呼叫 sess.run(assign_node) 時，計算路徑會透過 assign_node 和 zero_node。

計算圖：

當計算流經圖中的任何節點時，它還會執行由該節點控制的任何副作用，如圖中綠色所示。由於 tf.assign 的特殊副作用，與 count_variable（之前為「null」）關聯的記憶體現在被永久設定為 0。這意味著當我們下一次呼叫 sess.run(count_variable) 時，不會引發任何異常。相反，我們會得到 0 值。成功！

接下來，讓我們看看初始化器：

程式碼：

import tensorflow as tf
const_init_node = tf.constant_initializer(0.)
count_variable = tf.get_variable("count", [], initializer=const_init_node)
sess = tf.Session()
print sess.run([count_variable])

輸出：

Traceback (most recent call last):
...
tensorflow.python.framework.errors_impl.FailedPreconditionError: Attempting to use uninitialized value count
 [[Node: _retval_count_0_0 = _Retval[T=DT_FLOAT, index=0, _device="/job:localhost/replica:0/task:0/device:CPU:0"](count)]]

計算圖：

那好，這裡發生了什麼？為什麼初始化器不工作？

問題出現在會話和圖之間的分離。我們已將 get_variable 的 initializer 屬性設定為指向 const_init_node，但它只是在圖中的節點之間添加了一個新的連線。

我們還沒有做任何解決異常根源的事：與變數節點（儲存在會話中，而不是計算圖中）相關聯的記憶體仍然設定為「null」。我們需要透過會話使 const_init_node 去更新變數。

程式碼：

import tensorflow as tf
const_init_node = tf.constant_initializer(0.)
count_variable = tf.get_variable("count", [], initializer=const_init_node)
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
print sess.run(count_variable)

輸出：

0

計算圖：

為此，我們新增另一個特殊的節點：init = tf.global_variables_initializer()。與 tf.assign() 類似，這是一個帶有副作用的節點。與 tf.assign() 相反，實際上我們不需要指定它的輸入是什麼！tf.global_variables_initializer() 將在其建立時檢視全域性圖並自動將依賴關係新增到圖中的每個 tf.initializer。當我們在之後使用 sess.run(init) 對它求值時，它會告訴每個初始化程式執行變數初始化，並允許我們執行 sess.run(count_variable) 而不出錯。

7. 變數共享

你可能會遇到帶有變數共享的 Tensorflow 程式碼，其涉及建立作用域並設定「reuse = True」。我強烈建議不要在自己的程式碼中使用變數共享。如果你想在多個地方使用單個變數，只需以程式設計方式記錄指向該變數節點的指標，併在需要時重新使用它。換言之，對於想要儲存在記憶體中的每個變數，你只需要呼叫一次 tf.get_variable()。

8. 最佳化器

最後：進行真正的深度學習！如果你跟上我的節奏，那麼其餘概念對你來說應該非常簡單。

在深度學習中，典型的「內迴圈」訓練如下：

1. 獲取輸入和 true_output

2. 根據輸入和引數計算「推測」值

3. 根據推測與 true_output 之間的差異計算「損失」

4. 根據損失的梯度更新引數

讓我們把所有東西放在一個快速腳本里，解決簡單的線性回歸問題：

程式碼：

import tensorflow as tf
### build the graph## first set up the parameters
m = tf.get_variable("m", [], initializer=tf.constant_initializer(0.))
b = tf.get_variable("b", [], initializer=tf.constant_initializer(0.))
init = tf.global_variables_initializer()
## then set up the computations
input_placeholder = tf.placeholder(tf.float32)
output_placeholder = tf.placeholder(tf.float32)

x = input_placeholder
y = output_placeholder
y_guess = m * x + b

loss = tf.square(y - y_guess)
## finally, set up the optimizer and minimization node
optimizer = tf.train.GradientDescentOptimizer(1e-3)
train_op = optimizer.minimize(loss)
### start the session
sess = tf.Session()
sess.run(init)
### perform the training loop*import* random
## set up problem
true_m = random.random()
true_b = random.random()
*for* update_i *in* range(100000):
 ## (1) get the input and output
 input_data = random.random()
 output_data = true_m * input_data + true_b

 ## (2), (3), and (4) all take place within a single call to sess.run()!
 _loss, _ = sess.run([loss, train_op], feed_dict={input_placeholder: input_data, output_placeholder: output_data})
 *print* update_i, _loss
### finally, print out the values we learned for our two variables*print* "True parameters: m=%.4f, b=%.4f" % (true_m, true_b)*print* "Learned parameters: m=%.4f, b=%.4f" % tuple(sess.run([m, b]))

輸出：

0 2.32053831 0.57927422 1.552543 1.57332594 0.64356485 2.40612656 1.07462567 2.19987158 1.67751169 1.646242310 2.441034
...99990 2.9878322e-1299991 5.158629e-1199992 4.53646e-1199993 9.422685e-1299994 3.991829e-1199995 1.134115e-1199996 4.9467985e-1199997 1.3219648e-1199998 5.684342e-1499999 3.007017e-11*True* parameters: m=0.3519, b=0.3242
Learned parameters: m=0.3519, b=0.3242

就像你看到的一樣，損失基本上變為零，並且我們對真引數數進行了很好的估計。我希望你只對程式碼中的以下部分感到陌生：

## finally, set up the optimizer and minimization node
optimizer = tf.train.GradientDescentOptimizer(1e-3)
train_op = optimizer.minimize(loss)

但是，既然你對 Tensorflow 的基本概念有了很好的理解，這段程式碼就很容易解釋！第一行，optimizer = tf.train.GradientDescentOptimizer(1e-3) 不會向計算圖中新增節點。它只是建立一個包含有用的幫助函式的 Python 物件。第二行，train_op = optimizer.minimize(loss) 將一個節點新增到圖中，並將一個指標儲存在變數 train_op 中。train_op 節點沒有輸出，但是有一個十分複雜的副作用：

train_op 回溯輸入和損失的計算路徑，尋找變數節點。對於它找到的每個變數節點，計算該變數對於損失的梯度。然後計算該變數的新值：當前值減去梯度乘以學習率的積。最後，它執行賦值操作更新變數的值。

因此基本上，當我們呼叫 sess.run(train_op) 時，它對我們的所有變數做了一個梯度下降的步驟。當然，我們也需要使用 feed_dict 填充輸入和輸出佔位符，並且我們還希望列印損失的值，因為這樣方便除錯。

9. 用 tf.Print 除錯

當你用 Tensorflow 開始做更複雜的事情時，你需要進行除錯。一般來說，檢查計算圖中發生了什麼是相當困難的。因為你永遠無法訪問你想列印的值—它們被鎖定在 sess.run() 的呼叫中，所以你不能使用常規的 Python 列印陳述句。具體來說，假設你是想檢查一個計算的中間值。在呼叫 sess.run() 之前，中間值還不存在。但是，當你呼叫的 sess.run() 傳回時，中間值又不見了！

讓我們看一個簡單的示例。

程式碼：

import tensorflow as tf
two_node = tf.constant(2)
three_node = tf.constant(3)
sum_node = two_node + three_node
sess = tf.Session()
print sess.run(sum_node)

輸出：

5

這讓我們看到了答案是 5。但是，如果我們想要檢查中間值，two_node 和 three_node，怎麼辦？檢查中間值的一個方法是向 sess.run() 中新增一個傳回引數，該引數指向要檢查的每個中間節點，然後在傳回後，列印它的值。

程式碼：

import tensorflow as tf
two_node = tf.constant(2)
three_node = tf.constant(3)
sum_node = two_node + three_node
sess = tf.Session()
answer, inspection = sess.run([sum_node, [two_node, three_node]])
print inspection
print answer

輸出：

[2, 3]5

這通常是有用的，但當程式碼變得越來越複雜時，這可能有點棘手。一個更方便的方法是使用 tf.Print 陳述句。令人困惑的是，tf.Print 實際上是一種具有輸出和副作用的 Tensorflow 節點！它有兩個必需引數：要複製的節點和要列印的內容串列。

「要複製的節點」可以是圖中的任何節點；tf.Print 是一個與「要複製的節點」相關的恆等操作，意味著輸出的是輸入的副本。但是，它的副作用是打印出「列印串列」裡的所有當前值。

程式碼：

import tensorflow as tf
two_node = tf.constant(2)
three_node = tf.constant(3)
sum_node = two_node + three_node
print_sum_node = tf.Print(sum_node, [two_node, three_node])
sess = tf.Session()
print sess.run(print_sum_node)

輸出：

[2][3]5

計算圖：

有關 tf.Print 一個重要且有點微妙的點：列印是一個副作用。像所有其他副作用一樣，只要在計算流經 tf.Print 節點時才會進行列印。如果 tf.Print 節點不在計算路徑上，則不會列印任何內容。特別的是，即使 tf.Print 節點正在複製的原始節點位於計算路徑上，但 tf.Print 節點本身可能不在。

請註意這個問題！當這種情況發生時（總會發生的），如果你沒有明確地找到問題所在，它會讓你感到十分沮喪。一般來說，最好在建立要複製的節點後，立即建立你的 tf.Print 節點。

程式碼：

import tensorflow as tf
two_node = tf.constant(2)
three_node = tf.constant(3)
sum_node = two_node + three_node### this new copy of two_node is not on the computation path, so nothing prints!
print_two_node = tf.Print(two_node, [two_node, three_node, sum_node])
sess = tf.Session() 
print sess.run(sum_node)

輸出：

5

計算圖：

這裡有一個很好的資源（https://wookayin.github.io/tensorflow-talk-debugging/#1），它提供了其他一些實用的除錯建議。

03 結論

希望這篇博文可以幫助你更好地理解什麼是 Tensorflow，它是如何工作的以及怎麼使用它。總而言之，本文介紹的概念對所有 Tensorflow 專案都很重要，但只是停留在錶面。在你探索 Tensorflow 的旅程中，你可能會遇到其他各種你需要的有趣概念：條件、迭代、分散式 Tensorflow、變數作用域、儲存和載入模型、多圖、多會話和多核、資料載入器佇列等等。

但如果你使用官方檔案、一些程式碼示例和一點深度學習的魔力來鞏固你在本文學到的思想，我相信你一定可以弄明白 Tensorflow！

原文連結：

https://jacobbuckman.com/post/tensorflow-the-confusing-parts-1/