# 二、TensorFlow 數學運算 在本章中，我們將介紹以下主題： * 張量數據結構 * 使用 TensorFlow 處理張量 * 復數和分形 * 計算導數 * 隨機數 * 求解偏微分方程 # 張量數據結構 張量是 TensorFlow 中的基本數據結構。 正如我們已經說過的那樣，它們表示數據流圖中的連接邊。 張量只是標識多維數組或列表。 可以通過三個參數`rank`，`shape`和`type`進行標識： * `rank`：每個張量由稱為等級的維度單位描述。 它確定張量的維數。 因此，秩被稱為張量的階數或 n 維數（例如，秩 2 張量是矩陣，秩 1 張量是向量）。 * `shape`：張量的形狀是其張數和列數。 * `type`：這是分配給張量元素的數據類型。 好吧，現在我們對這種基本的數據結構充滿信心。 要構建張量，我們可以： * 建立一個 n 維數組； 例如，通過使用 NumPy 庫 * 將 n 維數組轉換為 TensorFlow 張量 一旦獲得張量，就可以使用 TensorFlow 運算符對其進行處理。 下圖直觀地介紹了所引入的概念：  多維張量的可視化 ## 一維張量 要構建一維張量，我們使用 Numpy 數組命令，其中`s`是 Python 列表： ```py >>> import numpy as np >>> tensor_1d = np.array([1.3, 1, 4.0, 23.99]) ``` 與 Python 列表不同，元素之間的逗號不顯示： ```py >>> print tensor_1d [ 1.3 1\. 4\. 23.99] ``` 索引與 Python 列表相同。 第一個元素的位置為 0，第三個元素的位置為 2，依此類推： ```py >>> print tensor_1d[0] 1.3 >>> print tensor_1d[2] 4.0 ``` 最后，您可以查看張量的基本屬性，即張量的`rank`： ```py >>> tensor_1d.ndim 1 ``` 張量維度的元組如下： ```py >>> tensor_1d.shape (4L,) ``` 張量的形狀連續只有四個值。 張量中的*數據類型*： ```py >>> tensor_1d.dtype dtype('float64') ``` 現在，讓我們看看如何將 NumPy 數組轉換為 TensorFlow 張量： ```py import TensorFlow as tf ``` TensorFlow 函數`tf_convert_to_tensor`將各種類型的 Python 對象轉換為張量對象。 它接受張量對象，Numpy 數組，Python 列表和 Python 標量： ```py tf_tensor=tf.convert_to_tensor(tensor_1d,dtype=tf.float64) ``` 運行`Session`，我們可以可視化張量及其元素，如下所示： ```py with tf.Session() as sess: print sess.run(tf_tensor) print sess.run(tf_tensor[0]) print sess.run(tf_tensor[2]) ``` 得到以下結果： ```py >> [ 1.3 1\. 4\. 23.99] 1.3 4.0 >>> ``` ## 二維張量 要創建二維張量或矩陣，我們再次使用數組，但是`s`將是數組序列： ```py >>> import numpy as np >>> tensor_2d=np.array([(1,2,3,4),(4,5,6,7),(8,9,10,11),(12,13,14,15)]) >>> print tensor_2d [[ 1 2 3 4] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15]] >>> ``` `tensor_2d`中的值由表達式`tensor_2d[row,col]`標識，其中`row`是行位置，`col`是列位置： ```py >>> tensor_2d[3][3] 15 ``` 您還可以使用切片運算符`:`提取子矩陣： ```py >>> tensor_2d[0:2,0:2] array([[1, 2], [4, 5]]) ``` 在這種情況下，我們提取了一個`2×2`子矩陣，其中包含`tensor_2d`的行 0 和 1，以及列 0 和 1。 TensorFlow 有自己的切片運算符。 在下一個小節中，我們將看到如何使用它。 ### 張量操作 讓我們看看如何對這些數據結構進行一些更復雜的操作。 考慮以下代碼： 1. 導入庫： ```py import TensorFlow as tf import numpy as np ``` 2. 讓我們構建兩個整數數組。 它們代表兩個 3×3 矩陣： ```py matrix1 = np.array([(2,2,2),(2,2,2),(2,2,2)],dtype='int32') matrix2 = np.array([(1,1,1),(1,1,1),(1,1,1)],dtype='int32') ``` 3. 可視化它們： ```py print "matrix1 =" print matrix1 print "matrix2 =" print matrix2 ``` 4. 要在我們的 TensorFlow 環境中使用這些矩陣，必須將它們轉換為張量數據結構： ```py matrix1 = tf.constant(matrix1) matrix2 = tf.constant(matrix2) ``` 5. 我們使用 TensorFlow `constant`運算符執行轉換。 6. 準備使用 TensorFlow 運算符來處理矩陣。 在這種情況下，我們計算矩陣乘法和矩陣和： ```py matrix_product = tf.matmul(matrix1, matrix2) matrix_sum = tf.add(matrix1,matrix2) ``` 7. 以下矩陣將用于計算矩陣行列式： ```py matrix_3 = np.array([(2,7,2),(1,4,2),(9,0,2)],dtype='float32') print "matrix3 =" print matrix_3 matrix_det = tf.matrix_determinant(matrix_3) ``` 8. 現在是時候創建我們的圖并運行會話了，并創建了張量和運算符： ```py with tf.Session() as sess: result1 = sess.run(matrix_product) result2 = sess.run(matrix_sum) result3 = sess.run(matrix_det) ``` 9. 通過運行以下命令將打印出結果： ```py print "matrix1*matrix2 =" print result1 print "matrix1 + matrix2 =" print result2 print "matrix3 determinant result =" print result3 ``` 下圖顯示了運行代碼后的結果：  TensorFlow 在張量上提供了許多數學運算。 下表總結了它們： | TensorFlow 運算符 | 描述 | | --- | --- | | `tf.add` | 返回和 | | `tf.sub` | 返回差 | | `tf.mul` | 返回積 | | `tf.div` | 返回商 | | `tf.mod` | 返回模數 | | `tf.abs` | 返回絕對值 | | `tf.neg` | 返回相反值 | | `tf.sign` | 返回符號 | | `tf.inv` | 返回逆 | | `tf.square` | 返回平方 | | `tf.round` | 返回最接近的整數 | | `tf.sqrt` | 返回平方根 | | `tf.pow` | 返回冪 | | `tf.exp` | 返回指數 | | `tf.log` | 返回對數 | | `tf.maximum` | 返回最大值 | | `tf.minimum` | 返回最小值 | | `tf.cos` | 返回余弦 | | `tf.sin` | 返回正弦 | ## 三維張量 以下命令構建三維張量： ```py >>> import numpy as np >>> tensor_3d = np.array([[[1,2],[3,4]],[[5,6],[7,8]]]) >>> print tensor_3d [[[1 2] [3 4]] [[5 6] [7 8]]] >>> ``` 創建的三維張量是`2x2x2`矩陣： ```py >>> tensor_3d.shape (2L, 2L, 2L) ``` 要從三維張量中檢索元素，我們使用以下形式的表達式： ```py tensor_3d[plane,row,col] ``` 遵循以下設置：  Matrix 3×3 representation 因此，由可變平面的值標識的第一平面中的所有四個元素都等于零： ```py >>> tensor_3d[0,0,0] 1 >>> tensor_3d[0,0,1] 2 >>> tensor_3d[0,1,0] 3 >>> tensor_3d[0,1,1] 4 ``` 三維張量允許引入與圖像操作相關的下一個主題，但更籠統地介紹我們以對張量的簡單變換進行操作。 ## 使用 TensorFlow 處理張量 TensorFlow 旨在處理各種大小的張量和可用于操縱它們的運算符。 在此示例中，為了查看數組操作，我們將使用數字圖像。 您可能知道，彩色數字圖像是 MxNx3 大小的矩陣（三階張量），其分量與圖像（RGB 空間）中的紅色，綠色和藍色分量相對應，這意味著矩形中的每個特征 RGB 圖像的框將由`i`，`j`和`k`三個坐標指定。  The RGB tensor 我想向您展示的第一件事是如何使用 TensorFlow 切片運算符上傳圖像，然后從原始圖像中提取子圖像。 ### 準備輸入數據 使用 matplotlib 中的`imread`命令，我們以標準格式的顏色（JPG，BMP，TIF）導入數字圖像： ```py import matplotlib.image as mp_image filename = "packt.jpeg" input_image = mp_image.imread(filename) ``` 但是，我們可以看到張量的`rank`和`shape`： ```py print 'input dim = {}'.format(input_image.ndim) print 'input shape = {}'.format(input_image.shape) ``` 您將看到輸出（`80, 144, 3`）。 這意味著圖像的高度為`80`像素，寬度為`144`像素，深度為`3`。 最后，使用`matplotlib`可以可視化導入的圖像： ```py import matplotlib.pyplot as plt plt.imshow(input_image) plt.show() ```  The starting image 在此示例中，切片是起始圖像的二維段，其中每個像素都具有 RGB 分量，因此我們需要一個占位符來存儲切片的所有值： ```py import TensorFlow as tf my_image = tf.placeholder("uint8",[None,None,3]) ``` 對于最后一個維度，我們僅需要三個值。 然后，我們使用 TensorFlow 運算符切片創建一個子圖像： ```py slice = tf.slice(my_image,[10,0,0],[16,-1,-1]) ``` 最后一步是構建 TensorFlow 工作會話： ```py with tf.Session() as session: result = session.run(slice,feed_dict={my_image: input_image}) print(result.shape) plt.imshow(result) plt.show() ``` 最終的形狀如下圖所示：  The input image after the slice 在下一個示例中，我們將使用轉置運算符對輸入圖像進行幾何變換： ```py import TensorFlow as tf ``` 我們將輸入圖像與一個稱為`x`的變量相關聯： ```py x = tf.Variable(input_image,name='x') ``` 然后，我們初始化模型： ```py model = tf.initialize_all_variables() ``` 接下來，我們使用我們的代碼構建會話： ```py with tf.Session() as session: ``` 要執行矩陣的轉置，請使用 TensorFlow 的`transpose`函數。 此方法在輸入矩陣的軸 0 和 1 之間執行交換，而`z`軸保持不變： ```py x = tf.transpose(x, perm=[1,0,2]) session.run(model) result=session.run(x) plt.imshow(result) plt.show() ``` 結果如下：  The transposed image # 復數和分形 首先，我們看一下 Python 如何處理復數。 這很簡單。 例如，在 Python 中設置`x = 5 + 4j`，我們必須編寫以下代碼： ```py >>> x = 5.+4j ``` 這意味著`>>> x`等于`5+4j`。 同時，您可以編寫以下內容： ```py >>> x = complex(5,4) >>> x (5+4j) ``` 我們還注意到： * Python 在數學中使用`j`表示`√-1`而不是`i`。 * 如果將數字放在`j`之前，Python 會將其視為虛數，否則將其視為變量。 這意味著，如果要寫入虛數`i`，則必須寫入`1j`而不是`j`。 要獲取 Python 復數的實部和虛部，可以使用以下代碼： ```py >>> x.real 5.0 >>> x.imag 4.0 >>> ``` 現在我們來看我們的問題，即如何使用 TensorFlow 顯示分形。 Mandelbrot 圖案是最著名的分形之一。 分形是一種幾何對象，其結構以不同的比例重復出現。 分形在自然界中很常見，例如大不列顛海岸。 為復數`c`定義了 Mandelbrot 集，對于該復數來說，以下連續是有界的： ```py Z(n + 1) = Z(n)^2 + c，其中 Z(0) = 0 ``` 這套作品以其創造者 Beno?tMandelbrot（波蘭數學家以制造著名的分形而聞名）的名字命名。 但是，僅在計算機編程的幫助下，他才能為 Mandelbrot 設置形狀或圖形表示。 1985 年，他在《科學美國人》上發表了第一個計算 Mandelbrot 集的算法。 算法（對于每個點的復數點`Z`）： 1. `Z`的初始值`Z(0) = 0`。 2. 選擇復數`c`作為當前點。 在笛卡爾平面中，橫坐標軸（水平線）代表實部，而縱坐標軸（垂直線）代表`c`的虛部。 3. 迭代： `Z(n + 1) = Z(n)^2 + c` * 當`Z(n)^2`大于最大半徑時停止； 現在我們通過簡單的步驟了解如何使用 TensorFlow 轉換前面提到的算法。 ## 準備 Mandelbrot 集的數據 將必要的庫導入到我們的示例中： ```py import TensorFlow as tf import numpy as np import matplotlib.pyplot as plt ``` 我們構建了一個復雜的網格，其中將包含 Mandelbrot 的集合。 復平面的區域在實軸上位于`-1.3`和`+1.3`之間，在虛軸上位于`-2j`和`+1j`之間。 每個圖像中的每個像素位置將代表不同的復數值`z`： ```py Y, X = np.mgrid[-1.3:1.3:0.005, -2:1:0.005] Z = X+1j*Y c = tf.constant(Z.astype(np.complex64)) ``` 然后，我們定義數據結構或張量 TensorFlow，其中包含要包含在計算中的所有數據。 然后，我們定義兩個變量。 第一個是我們進行迭代的那個。 它具有與復雜網格相同的尺寸，但是被聲明為變量，也就是說，其值將在計算過程中發生變化： ```py zs = tf.Variable(c) ``` 下一個變量初始化為零。 它的大小也與變量`zs`相同： ```py ns = tf.Variable(tf.zeros_like(c, tf.float32)) ``` ## 為 Mandelbrot 集建立并執行數據流圖 代替引入會話，我們實例化一個`InteractiveSession()`： ```py sess = tf.InteractiveSession() ``` 正如我們將看到的，它需要`Tensor.eval()`和`Operation.run()`方法。 然后，我們通過`run()`方法初始化所有涉及的變量： ```py tf.initialize_all_variables().run() ``` 開始迭代： ```py zs_ = zs*zs + c ``` 定義迭代的停止條件： ```py not_diverged = tf.complex_abs(zs_) < 4 ``` 然后，我們使用對多個操作進行分組的分組運算符： ```py step = tf.group(zs.assign(zs_),\ ns.assign_add(tf.cast(not_diverged, tf.float32))) ``` 第一個操作是步驟迭代`Z(n + 1) = Z(n)^2 + c`以創建新值。 第二個操作將此值添加到`ns`中的對應元素變量中。 此`op`完成時，輸入中的所有操作都已完成。 該運算符沒有輸出。 然后，我們將運算符運行兩百步： ```py for i in range(200): step.run() ``` ## 可視化 Mandelbrot 的結果 結果將是張量`ns.eval()`。 使用 matplotlib，讓我們可視化結果： ```py plt.imshow(ns.eval()) plt.show() ```  曼德布羅集 當然，Mandelbrot 集并不是我們可以看到的唯一分形。 朱莉婭集合是分形，以加斯頓·莫里斯·朱莉亞（Gaston Maurice Julia）的名字在該領域的工作而得名。 它們的構建過程與用于 Mandelbrot 集的過程非常相似。 ## 準備 Julia 的數據 讓我們定義輸出復雜平面。 它在實軸上位于`-2`和`+2`之間，在虛軸上位于`-2j`和`+2j`之間： ```py Y, X = np.mgrid[-2:2:0.005, -2:2:0.005] ``` 和當前點位置： ```py Z = X+1j*Y ``` 朱莉婭集合的定義需要將`Z`重新定義為恒定張量： ```py Z = tf.constant(Z.astype("complex64")) ``` 因此，支持我們的計算的輸入張量如下： ```py zs = tf.Variable(Z) ns = tf.Variable(tf.zeros_like(Z, "float32")) ``` ## 為 Julia 集建立并執行數據流圖 與前面的示例一樣，我們創建了自己的交互式會話： ```py sess = tf.InteractiveSession() ``` 然后我們初始化輸入張量： ```py tf.initialize_all_variables().run() ``` 為了計算 Julia 集的新值，我們將使用迭代公式`Z(n + 1) = Z(n)^2 + c`，其中初始點`c`等于虛數`0.75i`： ```py c = complex(0.0,0.75) zs_ = zs*zs - c ``` 分組運算符和停止迭代的條件將與 Mandelbrot 計算中的相同： ```py not_diverged = tf.complex_abs(zs_) < 4 step = tf.group(zs.assign(zs_),\ ns.assign_add(tf.cast(not_diverged, "float32"))) ``` 最后，我們將操作符運行兩百步： ```py for i in range(200): step.run() ``` ## 可視化結果 要顯示結果，請運行以下命令： ```py plt.imshow(ns.eval()) plt.show() ```  朱莉婭套裝 # 計算梯度 TensorFlow 具有解決其他更復雜任務的功能。 例如，我們將使用數學運算符來計算`y`相對于其表達式`x`參數的導數。 為此，我們使用`tf.gradients()`函數。 讓我們考慮數學函數`y = 2*x2`。 我們要計算相對于`x=1`的梯度`dy/dx`。 以下是計算此梯度的代碼： 1. 首先，導入 TensorFlow 庫： ```py import TensorFlow as tf ``` 2. `x`變量是函數的自變量： ```py x = tf.placeholder(tf.float32) ``` 3. 讓我們構建函數： ```py y = 2*x*x ``` 4. 最后，我們以`y`和`x`作為參數調用 `tf.gradients()`函數： ```py var_grad = tf.gradients(y, x) ``` 5. 要求解梯度，我們必須建立一個會話： ```py with tf.Session() as session: ``` 6. 將通過變量`x=1`求解梯度： ```py var_grad_val = session.run(var_grad,feed_dict={x:1}) ``` 7. `var_grad_val`值是要打印的進紙結果： ```py print(var_grad_val) ``` 8. 得到以下結果： ```py >> [4.0] >> ``` # 隨機數 隨機數的生成對于機器學習和訓練算法至關重要。 當計算機生成隨機數時，它們是由**偽隨機數生成器**（**PRNG**）生成的。 術語“偽”來自這樣一個事實，即計算機是僅能模擬隨機性的指令的染色邏輯編程運行。 盡管存在邏輯限制，但計算機在生成隨機數方面非常有效。 TensorFlow 為開發者提供了創建具有不同分布的隨機張量的方法。 ## 均勻分布 通常，當我們需要使用隨機數時，我們嘗試獲得相同頻率，均勻分布的重復值。 運算符 TensorFlow 提供`minval`和`maxval`之間的值，所有這些值具有相同的概率。 讓我們看一個簡單的示例代碼： ```py random_uniform(shape, minval, maxval, dtype, seed, name) ``` 我們導入`TensorFlow`庫和`matplotlib`以顯示結果： ```py import TensorFlow as tf import matplotlib.pyplot as plt ``` `uniform`變量是一維張量，元素`100`的值范圍從 0 到 1，以相同的概率分布： ```py uniform = tf.random_uniform([100],minval=0,maxval=1,dtype=tf.float32) ``` 讓我們定義會話： ```py sess = tf.Session() ``` 在我們的會話中，我們使用`eval ()`運算符求值均勻的張量： ```py with tf.Session() as session: print uniform.eval() plt.hist(uniform.eval(),normed=True) plt.show() ``` 如您所見，所有介于 0 和 1 之間的中間值都具有大致相同的頻率。 這種行為稱為均勻分布。 因此，執行結果如下：  均勻分布 ## 正態分布 在某些特定情況下，您可能需要生成相差幾個單位的隨機數。 在這種情況下，我們使用隨機數的*正態分布*，也稱為*高斯分布*，這增加了下一個問題在 0 處提取的可能性。每個整數代表標準差。 從未來的問題可以看出，該范圍的邊被提取的可能性很小。 以下是 TensorFlow 的實現： ```py import TensorFlow as tf import matplotlib.pyplot as plt norm = tf.random_normal([100], mean=0, stddev=2) with tf.Session() as session: plt.hist(norm.eval(),normed=True) plt.show() ``` 我們使用運算符`tf.random_normal`創建了一個形狀為`[100]`的`1d-tensor`，該形狀由均值等于 0 且標準差等于`2`的隨機正態值組成。 結果如下：  正態分布 ## 用種子生成隨機數 我們回想起我們的序列是*偽隨機*，因為這些值是使用確定性算法計算的，并且概率沒有實際作用。 種子只是序列的起點，如果從同一種子開始，則將以相同的序列結束。 例如，這對于調試代碼非常有用，例如當您在程序中搜索錯誤時，由于每次運行都會有所不同，因此您必須能夠重現該問題。 考慮以下示例，其中有兩個均勻分布： ```py uniform_with_seed = tf.random_uniform([1], seed=1) uniform_without_seed = tf.random_uniform([1]) ``` 在第一個均勻分布中，我們從種子`= 1`開始。這意味著重復求值兩個分布，第一個均勻分布將始終生成值相同的序列： ```py print("First Run") with tf.Session() as first_session: print("uniform with (seed = 1) = {}"\ .format(first_session.run(uniform_with_seed))) print("uniform with (seed = 1) = {}"\ .format(first_session.run(uniform_with_seed))) print("uniform without seed = {}"\ .format(first_session.run(uniform_without_seed))) print("uniform without seed = {}"\ .format(first_session.run(uniform_without_seed))) print("Second Run") with tf.Session() as second_session: print("uniform with (seed = 1) = {}\ .format(second_session.run(uniform_with_seed))) print("uniform with (seed = 1) = {}\ .format(second_session.run(uniform_with_seed))) print("uniform without seed = {}"\ .format(second_session.run(uniform_without_seed))) print("uniform without seed = {}"\ .format(second_session.run(uniform_without_seed))) ``` 如您所見，這是最終結果。 `seed = 1`的均勻分布總是得到相同的結果： ```py >>> First Run uniform with (seed = 1) = [ 0.23903739] uniform with (seed = 1) = [ 0.22267115] uniform without seed = [ 0.92157185] uniform without seed = [ 0.43226039] Second Run uniform with (seed = 1) = [ 0.23903739] uniform with (seed = 1) = [ 0.22267115] uniform without seed = [ 0.50188708] uniform without seed = [ 0.21324408] >>> ``` ### 蒙特卡洛法 我們以有關蒙特卡洛方法的簡單注釋結束有關隨機數的部分。 它是一種數值概率方法，廣泛應用于高性能科學計算的應用中。 在我們的示例中，我們將計算`π`的值： ```py import TensorFlow as tf trials = 100 hits = 0 ``` 使用`random_uniform`函數在正方形`[-1,1]×[-1,1]`內生成偽隨機點： ```py x = tf.random_uniform([1],minval=-1,maxval=1,dtype=tf.float32) y = tf.random_uniform([1],minval=-1,maxval=1,dtype=tf.float32) pi = [] ``` 開始會話： ```py sess = tf.Session() ``` 在會話中，我們計算`π`的值：圓的面積為`π`，正方形的面積為`4`。 圓內的數字與生成的點的總數之間的關系必須收斂（非常緩慢）到`π`，并且我們計算圓方程`x<sup>2</sup>+y<sup>2</sup>=1`內有多少點。 ```py with sess.as_default(): for i in range(1,trials): for j in range(1,trials): if x.eval()**2 + y.eval()**2 < 1 : hits = hits + 1 pi.append((4 * float(hits) / i)/trials) plt.plot(pi) plt.show() ```  該圖顯示了測試次數達到π值時的收斂性 # 求解偏微分方程 **偏微分方程**（**PDE**）是一個微分方程，涉及多個獨立變量的未知函數的偏導數。 PDE 通常用于制定和解決從量子力學到金融市場等各個領域的重大物理問題。 在本節中，我們以[這里](https://www.TensorFlow.org/versions/r0.8/tutorials/pdes/index.html)為例，展示了 TensorFlow 在二維 PDE 解決方案中的用法，它建模了方形池塘的表面，上面有幾滴雨滴。 效果將是在池塘本身上產生二維波。 我們不會專注于問題的計算方面，因為這超出了本書的范圍。 相反，我們將專注于使用 TensorFlow 定義問題。 起點是導入以下基本庫： ```py import TensorFlow as tf import numpy as np import matplotlib.pyplot as plt ``` ## 初始條件 首先，我們必須定義問題的范圍。 假設我們的池塘是`500x500`正方形： ```py N = 500 ``` 以下二維張量是時間`t = 0`處的池塘，即我們問題的*初始條件*： ```py u_init = np.zeros([N, N], dtype=np.float32) ``` 我們上面有`40`個隨機雨滴 ```py for n in range(40): a,b = np.random.randint(0, N, 2) u_init[a,b] = np.random.uniform() ``` `np.random.randint(0, N, 2)`是 NumPy 函數，可在二維形狀上返回從 0 到`N`的隨機整數。 使用 matplotlib，我們可以顯示初始正方形池塘： ```py plt.imshow(U.eval()) plt.show() ```  在初始狀態下放大池塘：彩色圓點表示掉落的雨滴 然后我們定義以下張量： ```py ut_init = np.zeros([N, N], dtype=np.float32) ``` 它是池塘的*時間演變*。 在時間`t = t<sub>end</sub>`，它將包含池塘的最終狀態。 ## 構建模型 我們必須定義一些基本參數（使用 TensorFlow 占位符）和仿真的時間步長： ```py eps = tf.placeholder(tf.float32, shape=()) ``` 我們還必須定義模型的物理參數，即`damping`系數： ```py damping = tf.placeholder(tf.float32, shape=()) ``` 然后我們將起始張量重新定義為 TensorFlow 變量，因為它們的值將在模擬過程中發生變化： ```py U = tf.Variable(u_init) Ut = tf.Variable(ut_init) ``` 最后，我們建立 PDE 模型。 它代表雨滴落下后池塘時間的演變： ```py U_ = U + eps * Ut Ut_ = Ut + eps * (laplace(U) - damping * Ut) ``` 如您所見，我們引入了`laplace(U)`函數來解析 PDE（將在本節的最后一部分中進行介紹）。 使用 TensorFlow 組運算符，我們定義了時間池`t`應該如何演變： ```py step = tf.group( U.assign(U_), Ut.assign(Ut_)) ``` 讓我們回想一下，組運算符將多個操作分組為一個操作。 ## 執行圖 在我們的會話中，我們將以`1000`步長看到池塘的時間演變，其中每個時間步長等于`0.03s`，而阻尼系數設置為`0.04`。 讓我們初始化 TensorFlow 變量： ```py tf.initialize_all_variables().run() ``` 然后我們運行模擬： ```py for i in range(1000): step.run({eps: 0.03, damping: 0.04}) if i % 50 == 0: clear_output() plt.imshow(U.eval()) plt.show() ``` 每`50`個步驟，仿真結果將顯示如下：  經過 400 個模擬步驟的池塘 ### 使用的計算函數 現在讓我們看看`Laplace(U)`函數和所使用的輔助函數是什么： ```py def make_kernel(a): a = np.asarray(a) a = a.reshape(list(a.shape) + [1,1]) return tf.constant(a, dtype=1) def simple_conv(x, k): x = tf.expand_dims(tf.expand_dims(x, 0), -1) y = tf.nn.depthwise_conv2d(x, k, [1, 1, 1, 1],padding='SAME') return y[0, :, :, 0] def laplace(x): laplace_k = make_kernel([[0.5, 1.0, 0.5], [1.0, -6., 1.0], [0.5, 1.0, 0.5]]) return simple_conv(x, laplace_k) ``` 這些函數描述了模型的物理性質，也就是說，隨著波浪的產生和在池塘中的傳播。 我不會詳細介紹這些函數，對它們的理解超出了本書的范圍。 下圖顯示了雨滴落下后池塘上的波浪。  放大池塘 # 總結 在本章中，我們研究了 TensorFlow 的一些數學潛力。 從*張量*的基本定義（任何類型的計算的基本數據結構），我們看到了一些使用 TensorFlow 的數學運算符處理這些數據結構的示例。 使用*復數*數，我們探索了分形的世界。 然后，我們介紹了*隨機*數的概念。 這些實際上用于機器學習中的模型開發和測試，因此本章以使用偏微分方程定義和解決數學問題的示例結尾。 在下一章中，最后我們將開始在 TensorFlow 的開發領域立即開始運作-在機器學習中，解決諸如*分類*和*數據聚類*之類的復雜問題 。