# 一、TensorFlow 2 簡介
TensorFlow 于 2011 年以 Google 的內部封閉源代碼項目 DisBelief 誕生。 DisBelief 是采用深度學習神經網絡的機器學習系統。 該系統演變為 TensorFlow,并在 2015 年 11 月 9 日根據 Apache 2.0 開源許可證發布到開發人員社區。版本 1.0.0 于 2017 年 2 月 11 日出現。此后有許多版本發布。 合并了許多新功能。
在撰寫本書時,最新版本是 TensorFlow 2.0.0 alpha 版本,該版本在 2019 年 3 月 6 日的 TensorFlow 開發峰會上宣布。
TensorFlow 的名字來源于張量。 張量是向量和矩陣到更高維度的一般化。 張量的等級是唯一指定該張量的每個元素所用的索引數。 標量(簡單數字)是等級 0 的張量,向量是等級 1 的張量,矩陣是等級 2 的張量,三維數組是等級 3 的張量。張量具有數據類型和形狀(張量中的所有數據項必須具有相同的類型)。 4 維張量的示例(即等級 4)是圖像,其中維是例如`batch`,`height`,`width`和`color`通道內的示例:
```py
image1 = tf.zeros([7, 28, 28, 3]) # example-within-batch by height by width by color
```
盡管 TensorFlow 通常可以用于許多數值計算領域,尤其是機器學習,但其主要研究和開發領域是**深層神經網絡**(**DNN**)的應用,它已在語音和聲音識別等不同領域使用,例如,在如今廣泛使用的聲控助手中; 基于文本的應用,例如語言翻譯器; 圖像識別,例如系外行星搜尋,癌癥檢測和診斷; 以及時間序列應用(例如推薦系統)。
在本章中,我們將討論以下內容:
* 現代 TensorFlow 生態系統
* 安裝 TensorFlow
* 急切操作
* 提供有用的 TensorFlow 操作
# 現代 TensorFlow 生態系統
讓我們討論**急切執行**。 TensorFlow 的第一個化身包括構造由操作和張量組成的計算圖,隨后必須在 Google 所謂的會話中對其進行評估(這稱為聲明性編程)。 這仍然是編寫 TensorFlow 程序的常用方法。 但是,急切執行的功能(以研究形式從版本 1.5 開始可用,并從版本 1.7 被烘焙到 TensorFlow 中)需要立即評估操作,結果是可以將張量像 NumPy 數組一樣對待(這被稱為命令式編程)。
谷歌表示,急切執行是研究和開發的首選方法,但計算圖對于服務 TensorFlow 生產應用將是首選。
`tf.data`是一種 API,可讓您從更簡單,可重復使用的部件中構建復雜的數據輸入管道。 最高級別的抽象是`Dataset`,它既包含張量的嵌套結構元素,又包含作用于這些元素的轉換計劃。 有以下幾種類:
* `Dataset`包含來自至少一個二進制文件(`FixedLengthRecordDataset`)的固定長度記錄集
* `Dataset`由至少一個 TFRecord 文件(`TFRecordDataset`)中的記錄組成
* `Dataset`由記錄組成,這些記錄是至少一個文本文件(`TFRecordDataset`)中的行
* 還有一個類表示通過`Dataset`(`tf.data.Iterator`)進行迭代的狀態
讓我們繼續進行**估計器**,這是一個高級 API,可讓您構建大大簡化的機器學習程序。 估計員負責訓練,評估,預測和導出服務。
**TensorFlow.js** 是 API 的集合,可讓您使用底層 JavaScript 線性代數庫或高層 API 來構建和訓練模型。 因此,可以訓練模型并在瀏覽器中運行它們。
**TensorFlow Lite** 是適用于移動和嵌入式設備的 TensorFlow 的輕量級版本。 它由運行時解釋器和一組工具組成。 這個想法是您在功率更高的機器上訓練模型,然后使用工具將模型轉換為`.tflite`格式。 然后將模型加載到您選擇的設備中。 在撰寫本文時,使用 C++ API 在 Android 和 iOS 上支持 TensorFlow Lite,并且具有適用于 Android 的 Java 包裝器。 如果 Android 設備支持 **Android 神經??網絡**(**ANN**)API 進行硬件加速,則解釋器將使用此 API,否則它將默認使用 CPU 執行。
**TensorFlow Hub** 是一個旨在促進機器學習模型的可重用模塊的發布,發現和使用的庫。 在這種情況下,模塊是 TensorFlow 圖的獨立部分,包括其權重和其他資產。 該模塊可以通過稱為遷移學習的方法在不同任務中重用。 這個想法是您在大型數據集上訓練模型,然后將適當的模塊重新用于您的其他但相關的任務。 這種方法具有許多優點-您可以使用較小的數據集訓練模型,可以提高泛化能力,并且可以大大加快訓練速度。
例如,ImageNet 數據集以及許多不同的神經網絡架構(例如`inception_v3`)已非常成功地用于解決許多其他圖像處理訓練問題。
**TensorFlow Extended**(**TFX**)是基于 TensorFlow 的通用機器學習平臺。 迄今為止,已開源的庫包括 TensorFlow 轉換,TensorFlow 模型分析和 TensorFlow 服務。
`tf.keras`是用 Python 編寫的高級神經網絡 API,可與 TensorFlow(和其他各種張量工具)接口。 `tf.k` `eras`支持快速原型設計,并且用戶友好,模塊化且可擴展。 它支持卷積和循環網絡,并將在 CPU 和 GPU 上運行。 Keras 是 TensorFlow 2 中開發的首選 API。
**TensorBoard** 是一套可視化工具,支持對 TensorFlow 程序的理解,調試和優化。 它與急切和圖執行環境兼容。 您可以在訓練期間使用 TensorBoard 可視化模型的各種指標。
TensorFlow 的一項最新開發(在撰寫本文時仍處于實驗形式)將 TensorFlow 直接集成到 Swift 編程語言中。 Swift 中的 TensorFlow 應用是使用命令性代碼編寫的,即命令急切地(在運行時)執行的代碼。 Swift 編譯器會自動將此源代碼轉換為一個 TensorFlow 圖,然后在 CPU,GPU 和 TPU 上以 TensorFlow Sessions 的全部性能執行此編譯后的代碼。
在本書中,我們將重點介紹那些使用 Python 3.6 和 TensorFlow 2.0.0 alpha 版本啟動和運行 TensorFlow 的 TensorFlow 工具。 特別是,我們將使用急切的執行而不是計算圖,并且將盡可能利用`tf.keras`的功能來構建網絡,因為這是研究和實驗的現代方法。
# 安裝 TensorFlow
TensorFlow 的最佳編程支持是為 Python 提供的(盡管確實存在 Java,C 和 Go 的庫,而其他語言的庫正在積極開發中)。
Web 上有大量信息可用于為 Python 安裝 TensorFlow。
Google 也建議在虛擬環境中安裝 TensorFlow,這是一種標準做法,該環境將一組 API 和代碼與其他 API 和代碼以及系統范圍的環境隔離開來。
TensorFlow 有兩種不同的版本-一個用于在 CPU 上執行,另一個用于在 GPU 上執行。 最后,這需要安裝數值庫 CUDA 和 CuDNN。 Tensorflow 將在可能的情況下默認執行 GPU。 參見[這里](https://www.tensorflow.org/alpha/guide/using_gpu)。
與其嘗試重新發明輪子,不如跟隨資源來創建虛擬環境和安裝 TensorFlow。
總而言之,可能會為 Windows 7 或更高版本,Ubuntu Linux 16.04 或更高版本以及 macOS 10.12.6 或更高版本安裝 TensorFlow。
有關虛擬環境的完整介紹,請參見[這里](http://docs.python-guide.org/en/latest/dev/virtualenvs/)。
[Google 的官方文檔](https://www.tensorflow.org/install/)中提供了有關安裝 TensorFlow 所需的所有方面的非常詳細的信息。
安裝后,您可以從命令終端檢查 TensorFlow 的安裝。 [這個頁面](http://www.laurencemoroney.com/tensorflow-to-gpu-or-not-to-gpu/)有執行此操作,以及安裝 TensorFlow 的夜間版本(其中包含所有最新更新)的說明。
# 急切的操作
我們將首先介紹如何導入 TensorFlow,然后介紹 TensorFlow 編碼風格,以及如何進行一些基本的整理工作。 之后,我們將看一些基本的 TensorFlow 操作。 您可以為這些代碼片段創建 Jupyter 筆記本,也可以使用自己喜歡的 IDE 創建源代碼。 該代碼在 GitHub 存儲庫中都可用。
# 導入 TensorFlow
導入 TensorFlow 很簡單。 請注意幾個系統檢查:
```py
import tensorflow as tf
print("TensorFlow version: {}".format(tf.__version__))
print("Eager execution is: {}".format(tf.executing_eagerly()))
print("Keras version: {}".format(tf.keras.__version__))
```
# TensorFlow 的編碼風格約定
對于 Python 應用,Google 遵守 PEP8 標準約定。 特別是,他們將 CamelCase 用于類(例如`hub.LatestModuleExporter`),將`snake_case`用于函數,方法和屬性(例如`tf.math.squared_difference`)。 Google 還遵守《Google Python 風格指南》,該指南可在[這個頁面](https://github.com/google/styleguide/blob/gh-pages/pyguide.md)中找到。
# 使用急切執行
急切執行是 TensorFlow 2 中的默認設置,因此不需要特殊設置。
以下代碼可用于查找是否正在使用 CPU 或 GPU,如果它是 GPU,則該 GPU 是否為`#0`。
我們建議鍵入代碼,而不要使用復制和粘貼。 這樣,您將對以下命令有所了解:
```py
var = tf.Variable([3, 3])
if tf.test.is_gpu_available():
print('Running on GPU')
print('GPU #0?')
print(var.device.endswith('GPU:0'))
else:
print('Running on CPU')
```
# 聲明急切變量
聲明 TensorFlow 急切變量的方法如下:
```py
t0 = 24 # python variable
t1 = tf.Variable(42) # rank 0 tensor
t2 = tf.Variable([ [ [0., 1., 2.], [3., 4., 5.] ], [ [6., 7., 8.], [9., 10., 11.] ] ]) #rank 3 tensor
t0, t1, t2
```
輸出將如下所示:
```py
(24,
<tf.Variable 'Variable:0' shape=() dtype=int32, numpy=42>,
<tf.Variable 'Variable:0' shape=(2, 2, 3) dtype=float32, numpy=
array([[[ 0., 1., 2.],
[ 3., 4., 5.]],
[[ 6., 7., 8.],
[ 9., 10., 11.]]], dtype=float32)>)
```
TensorFlow 將推斷數據類型,對于浮點數默認為`tf.float32`,對于整數默認為`tf.int32`(請參見前面的示例)。
或者,可以顯式指定數據類型,如下所示:
```py
f64 = tf.Variable(89, dtype = tf.float64)
f64.dtype
```
TensorFlow 具有大量的內置數據類型。
示例包括之前看到的示例`tf.int16`,`tf.complex64`和`tf.string`。 參見[這里](https://www.tensorflow.org/api_docs/python/tf/dtypes/DType)。 要重新分配變量,請使用`var.assign()`,如下所示:
```py
f1 = tf.Variable(89.)
f1
# <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=89.0>
f1.assign(98.)
f1
# <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=98.0>
```
# 聲明 TensorFlow 常量
TensorFlow 常量可以在以下示例中聲明:
```py
m_o_l = tf.constant(42)
m_o_l
# <tf.Tensor: id=45, shape=(), dtype=int32, numpy=42>
m_o_l.numpy()
# 42
```
同樣,TensorFlow 將推斷數據類型,或者可以像使用變量那樣顯式指定它:
```py
unit = tf.constant(1, dtype = tf.int64)
unit
# <tf.Tensor: id=48, shape=(), dtype=int64, numpy=1>
```
# 調整張量
張量的形狀通過屬性(而不是函數)訪問:
```py
t2 = tf.Variable([ [ [0., 1., 2.], [3., 4., 5.] ], [ [6., 7., 8.], [9., 10., 11.] ] ]) # tensor variable
print(t2.shape)
```
輸出將如下所示:
```py
(2, 2, 3)
```
張量可能會被重塑并保留相同的值,這是構建神經網絡經常需要的。
這是一個示例:
```py
r1 = tf.reshape(t2,[2,6]) # 2 rows 6 cols
r2 = tf.reshape(t2,[1,12]) # 1 rows 12 cols
r1
# <tf.Tensor: id=33, shape=(2, 6), dtype=float32,
numpy= array([[ 0., 1., 2., 3., 4., 5.], [ 6., 7., 8., 9., 10., 11.]], dtype=float32)>
```
這是另一個示例:
```py
r2 = tf.reshape(t2,[1,12]) # 1 row 12 columns
r2
# <tf.Tensor: id=36, shape=(1, 12), dtype=float32,
numpy= array([[ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.]], dtype=float32)>
```
# 張量的等級(尺寸)
張量的等級是它具有的維數,即指定該張量的任何特定元素所需的索引數。
張量的等級可以這樣確定,例如:
```py
tf.rank(t2)
```
輸出將如下所示:
```py
<tf.Tensor: id=53, shape=(), dtype=int32, numpy=3>
(the shape is () because the output here is a scalar value)
```
# 指定張量的元素
正如您期望的那樣,通過指定所需的索引來指定張量的元素。
以這個為例:
```py
t3 = t2[1, 0, 2] # slice 1, row 0, column 2
t3
```
輸出將如下所示:
```py
<tf.Tensor: id=75, shape=(), dtype=float32, numpy=8.0>
```
# 將張量轉換為 NumPy/Python 變量
如果需要,可以將張量轉換為`numpy`變量,如下所示:
```py
print(t2.numpy())
```
輸出將如下所示:
```py
[[[ 0\. 1\. 2.] [ 3\. 4\. 5.]] [[ 6\. 7\. 8.] [ 9\. 10\. 11.]]]
```
也可以這樣:
```py
print(t2[1, 0, 2].numpy())
```
輸出將如下所示:
```py
8.0
```
# 查找張量的大小(元素數)
張量中的元素數量很容易獲得。 再次注意,使用`.numpy()`函數從張量中提取 Python 值:
```py
s = tf.size(input=t2).numpy()
s
```
輸出將如下所示:
```py
12
```
# 查找張量的數據類型
TensorFlow 支持您期望的所有數據類型。 完整列表位于[這里](https://www.tensorflow.org/versions/r1.1/programmers_guide/dims_types),其中包括`tf.int32`(默認整數類型),`tf.float32`(默認浮動點類型)和`tf.complex64`(復數類型)。
要查找張量的數據類型,請使用以下`dtype`屬性:
```py
t3.dtype
```
輸出將如下所示:
```py
tf.float32
```
# 指定按元素的基本張量操作
如您所料,使用重載運算符`+`,`-`,`*`和`/`來指定逐元素基本張量操作,如下所示:
```py
t2*t2
```
輸出將如下所示:
```py
<tf.Tensor: id=555332, shape=(2, 2, 3), dtype=float32, numpy= array([[[ 0., 1., 4.], [ 9., 16., 25.]], [[ 36., 49., 64.], [ 81., 100., 121.]]], dtype=float32)>
```
# 廣播
按元素張量操作以與 NumPy 數組相同的方式支持廣播。 最簡單的示例是將張量乘以標量:
```py
t4 = t2*4
print(t4)
```
輸出將如下所示:
```py
tf.Tensor( [[[ 0\. 4\. 8.] [12\. 16\. 20.]] [[24\. 28\. 32.] [36\. 40\. 44.]]], shape=(2, 2, 3), dtype=float32)
```
在該示例中,在概念上至少將標量乘法器 4 擴展為一個數組,該數組可以與`t2`逐元素相乘。 在[上對廣播進行了非常詳細的討論,網址為](https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)。
# 轉置 TensorFlow 和矩陣乘法
要緊急轉置矩陣和矩陣乘法,請使用以下命令:
```py
u = tf.constant([[3,4,3]])
v = tf.constant([[1,2,1]])
tf.matmul(u, tf.transpose(a=v))
```
輸出將如下所示:
```py
<tf.Tensor: id=555345, shape=(1, 1), dtype=int32, numpy=array([[14]], dtype=int32)>
```
再次注意,默認整數類型為`tf.int32`,默認浮點類型為`tf.float32`。
可用于構成計算圖一部分的張量的所有操作也可用于急切執行變量。
在[這個頁面](https://www.tensorflow.org/api_guides/python/math_ops)上有這些操作的完整列表。
# 將張量轉換為另一個(張量)數據類型
一種類型的 TensorFlow 變量可以強制轉換為另一種類型。 可以在[這個頁面](https://www.tensorflow.org/api_docs/python/tf/cast)中找到更多詳細信息。
請看以下示例:
```py
i = tf.cast(t1, dtype=tf.int32) # 42
i
```
輸出將如下所示:
```py
<tf.Tensor: id=116, shape=(), dtype=int32, numpy=42>
```
截斷后,將如下所示:
```py
j = tf.cast(tf.constant(4.9), dtype=tf.int32) # 4
j
```
輸出將如下所示:
```py
<tf.Tensor: id=119, shape=(), dtype=int32, numpy=4>
```
# 聲明參差不齊的張量
參差不齊的張量是具有一個或多個參差不齊尺寸的張量。 參差不齊的尺寸是具有可能具有不同長度的切片的尺寸。
聲明參差不齊的數組的方法有很多種,最簡單的方法是常量參差不齊的數組。
以下示例顯示了如何聲明一個常數的,參差不齊的數組以及各個切片的長度:
```py
ragged =tf.ragged.constant([[5, 2, 6, 1], [], [4, 10, 7], [8], [6,7]])
print(ragged)
print(ragged[0,:])
print(ragged[1,:])
print(ragged[2,:])
print(ragged[3,:])
print(ragged[4,:])
```
輸出如下:
```py
<tf.RaggedTensor [[5, 2, 6, 1], [], [4, 10, 7], [8], [6, 7]]>
tf.Tensor([5 2 6 1], shape=(4,), dtype=int32)
tf.Tensor([], shape=(0,), dtype=int32)
tf.Tensor([ 4 10 7], shape=(3,), dtype=int32)
tf.Tensor([8], shape=(1,), dtype=int32)
tf.Tensor([6 7], shape=(2,), dtype=int32)
```
注意單個切片的形狀。
創建參差不齊的數組的常用方法是使用`tf.RaggedTensor.from_row_splits()`方法,該方法具有以下簽名:
```py
@classmethod
from_row_splits(
cls,
values,
row_splits,
name=None
)
```
在這里,`values`是要變成參差不齊的數組的值的列表,`row_splits`是要拆分該值列表的位置的列表,因此行`ragged[i]`的值存儲在其中 `ragged.values[ragged.row_splits[i]:ragged.row_splits[i+1]]`:
```py
print(tf.RaggedTensor.from_row_splits(values=[5, 2, 6, 1, 4, 10, 7, 8, 6, 7],
row_splits=[0, 4, 4, 7, 8, 10]))
```
`RaggedTensor`如下:
```py
<tf.RaggedTensor [[5, 2, 6, 1], [], [4, 10, 7], [8], [6, 7]]>
```
# 提供有用的 TensorFlow 操作
在[這個頁面](https://www.tensorflow.org/api_docs/python/tf)上有所有 TensorFlow Python 模塊,類和函數的完整列表。
可以在[這個頁面](https://www.tensorflow.org/api_docs/python/tf/math)中找到所有數學函數。
在本節中,我們將研究一些有用的 TensorFlow 操作,尤其是在神經網絡編程的上下文中。
# 求兩個張量之間的平方差
在本書的后面,我們將需要找到兩個張量之差的平方。 方法如下:
```py
tf.math.squared.difference( x, y, name=None)
```
請看以下示例:
```py
x = [1,3,5,7,11]
y = 5
s = tf.math.squared_difference(x,y)
s
```
輸出將如下所示:
```py
<tf.Tensor: id=279, shape=(5,), dtype=int32, numpy=array([16, 4, 0, 4, 36], dtype=int32)>
```
請注意,在此示例中,Python 變量`x`和`y`被轉換為張量,然后`y`跨`x`廣播。 因此,例如,第一計算是`(1 - 5)^2 = 16`。
# 求平均值
以下是`tf.reduce_mean()`的簽名。
請注意,在下文中,所有 TensorFlow 操作都有一個名稱參數,當使用急切執行作為其目的是在計算圖中識別操作時,可以安全地將其保留為默認值`None`。
請注意,這等效于`np.mean`,除了它從輸入張量推斷返回數據類型,而`np.mean`允許您指定輸出類型(默認為`float64`):
```py
tf.reduce_mean(input_tensor, axis=None, keepdims=None, name=None)
```
通常需要找到張量的平均值。 當在單個軸上完成此操作時,該軸被稱為減少了。
這里有些例子:
```py
numbers = tf.constant([[4., 5.], [7., 3.]])
```
# 求所有軸的均值
求出所有軸的平均值(即使用默認的`axis = None`):
```py
tf.reduce_mean(input_tensor=numbers)
#( 4\. + 5\. + 7\. + 3.)/4 = 4.75
```
輸出將如下所示:
```py
<tf.Tensor: id=272, shape=(), dtype=float32, numpy=4.75>
```
# 求各列的均值
用以下方法找到各列的均值(即減少行數):
```py
tf.reduce_mean(input_tensor=numbers, axis=0) # [ (4\. + 7\. )/2 , (5\. + 3.)/2 ] = [5.5, 4.]
```
輸出將如下所示:
```py
<tf.Tensor: id=61, shape=(2,), dtype=float32, numpy=array([5.5, 4\. ], dtype=float32)>
```
當`keepdims`為`True`時,縮小軸將保留為 1:
```py
tf.reduce_mean(input_tensor=numbers, axis=0, keepdims=True)
```
輸出如下:
```py
array([[5.5, 4.]]) (1 row, 2 columns)
```
# 求各行的均值
使用以下方法找到各行的均值(即減少列數):
```py
tf.reduce_mean(input_tensor=numbers, axis=1) # [ (4\. + 5\. )/2 , (7\. + 3\. )/2] = [4.5, 5]
```
輸出將如下所示:
```py
<tf.Tensor: id=64, shape=(2,), dtype=float32, numpy=array([4.5, 5\. ], dtype=float32)>
```
當`keepdims`為`True`時,縮小軸將保留為 1:
```py
tf.reduce_mean(input_tensor=numbers, axis=1, keepdims=True)
```
輸出如下:
```py
([[4.5], [5]]) (2 rows, 1 column)
```
# 生成充滿隨機值的張量
開發神經網絡時,例如初始化權重和偏差時,經常需要隨機值。 TensorFlow 提供了多種生成這些隨機值的方法。
# 使用`tf.random.normal()`
`tf.random.normal()`輸出給定形狀的張量,其中填充了來自正態分布的`dtype`類型的值。
所需的簽名如下:
```py
tf. random.normal(shape, mean = 0, stddev =2, dtype=tf.float32, seed=None, name=None)
```
以這個為例:
```py
tf.random.normal(shape = (3,2), mean=10, stddev=2, dtype=tf.float32, seed=None, name=None)
ran = tf.random.normal(shape = (3,2), mean=10.0, stddev=2.0)
print(ran)
```
輸出將如下所示:
```py
<tf.Tensor: id=13, shape=(3, 2), dtype=float32, numpy= array([[ 8.537131 , 7.6625767], [10.925293 , 11.804686 ], [ 9.3763075, 6.701221 ]], dtype=float32)>
```
# 使用`tf.random.uniform()`
所需的簽名是這樣的:
```py
tf.random.uniform(shape, minval = 0, maxval= None, dtype=tf.float32, seed=None, name=None)
```
這將輸出給定形狀的張量,該張量填充了從`minval`到`maxval`范圍內的均勻分布的值,其中下限包括在內,而上限不包括在內。
以這個為例:
```py
tf.random.uniform(shape = (2,4), minval=0, maxval=None, dtype=tf.float32, seed=None, name=None)
```
輸出將如下所示:
```py
tf.Tensor( [[ 6 7] [ 0 12]], shape=(2, 2), dtype=int32)
```
請注意,對于這兩個隨機操作,如果您希望生成的隨機值都是可重復的,則使用`tf.random.set_seed()`。 還顯示了非默認數據類型的使用:
```py
tf.random.set_seed(11)
ran1 = tf.random.uniform(shape = (2,2), maxval=10, dtype = tf.int32)
ran2 = tf.random.uniform(shape = (2,2), maxval=10, dtype = tf.int32)
print(ran1) #Call 1
print(ran2)
tf.random.set_seed(11) #same seed
ran1 = tf.random.uniform(shape = (2,2), maxval=10, dtype = tf.int32)
ran2 = tf.random.uniform(shape = (2,2), maxval=10, dtype = tf.int32)
print(ran1) #Call 2
print(ran2)
```
`Call 1`和`Call 2`將返回相同的一組值。
輸出將如下所示:
```py
tf.Tensor(
[[4 6]
[5 2]], shape=(2, 2), dtype=int32)
tf.Tensor(
[[9 7]
[9 4]], shape=(2, 2), dtype=int32)
tf.Tensor(
[[4 6]
[5 2]], shape=(2, 2), dtype=int32)
tf.Tensor(
[[9 7]
[9 4]], shape=(2, 2), dtype=int32)
```
# 使用隨機值的實際示例
這是一個適合從[這個頁面](https://colab.research.google.com/notebooks/mlcc/creating_and_manipulating_tensors.ipynb#scrollTo=6UUluecQSCvr)執行的小示例。
請注意,此示例顯示了如何通過調用 TensorFlow 函數來初始化急切變量。
```py
dice1 = tf.Variable(tf.random.uniform([10, 1], minval=1, maxval=7, dtype=tf.int32))
dice2 = tf.Variable(tf.random.uniform([10, 1], minval=1, maxval=7, dtype=tf.int32))
# We may add dice1 and dice2 since they share the same shape and size.
dice_sum = dice1 + dice2
# We've got three separate 10x1 matrices. To produce a single
# 10x3 matrix, we'll concatenate them along dimension 1.
resulting_matrix = tf.concat(values=[dice1, dice2, dice_sum], axis=1)
print(resulting_matrix)
```
示例輸出如下:
```py
tf.Tensor(
[[ 5 4 9]
[ 5 1 6]
[ 2 4 6]
[ 5 6 11]
[ 4 4 8]
[ 4 6 10]
[ 2 2 4]
[ 5 6 11]
[ 2 6 8]
[ 5 4 9]], shape=(10, 3), dtype=int32)
```
# 查找最大和最小元素的索引
現在,我們將研究如何在張量軸上查找具有最大值和最小值的元素的索引。
這些函數的簽名如下:
```py
tf.argmax(input, axis=None, name=None, output_type=tf.int64 )
tf.argmin(input, axis=None, name=None, output_type=tf.int64 )
```
以這個為例:
```py
# 1-D tensor
t5 = tf.constant([2, 11, 5, 42, 7, 19, -6, -11, 29])
print(t5)
i = tf.argmax(input=t5)
print('index of max; ', i)
print('Max element: ',t5[i].numpy())
i = tf.argmin(input=t5,axis=0).numpy()
print('index of min: ', i)
print('Min element: ',t5[i].numpy())
t6 = tf.reshape(t5, [3,3])
print(t6)
i = tf.argmax(input=t6,axis=0).numpy() # max arg down rows
print('indices of max down rows; ', i)
i = tf.argmin(input=t6,axis=0).numpy() # min arg down rows
print('indices of min down rows ; ',i)
print(t6)
i = tf.argmax(input=t6,axis=1).numpy() # max arg across cols
print('indices of max across cols: ',i)
i = tf.argmin(input=t6,axis=1).numpy() # min arg across cols
print('indices of min across cols: ',i)
```
輸出將如下所示:
```py
tf.Tensor([ 2 11 5 42 7 19 -6 -11 29], shape=(9,), dtype=int32)
index of max; tf.Tensor(3, shape=(), dtype=int64)
Max element: 42
index of min: tf.Tensor(7, shape=(), dtype=int64)
Min element: -11
tf.Tensor( [[ 2 11 5] [ 42 7 19] [ -6 -11 29]], shape=(3, 3), dtype=int32)
indices of max down rows; tf.Tensor([1 0 2], shape=(3,), dtype=int64)
indices of min down rows ; tf.Tensor([2 2 0], shape=(3,), dtype=int64)
tf.Tensor( [[ 2 11 5] [ 42 7 19] [ -6 -11 29]], shape=(3, 3), dtype=int32)
indices of max across cols: tf.Tensor([1 0 2], shape=(3,), dtype=int64)
indices of min across cols: tf.Tensor([0 1 1], shape=(3,), dtype=int64)
```
# 使用檢查點保存和恢復張量值
為了保存和加載張量值,這是最好的方法(有關保存完整模型的方法,請參見第 2 章和 “Keras,TensorFlow 2” 的高級 API):
```py
variable = tf.Variable([[1,3,5,7],[11,13,17,19]])
checkpoint= tf.train.Checkpoint(var=variable)
save_path = checkpoint.save('./vars')
variable.assign([[0,0,0,0],[0,0,0,0]])
variable
checkpoint.restore(save_path)
print(variable)
```
輸出將如下所示:
```py
<tf.Variable 'Variable:0' shape=(2, 4) dtype=int32, numpy= array([[ 1, 3, 5, 7], [11, 13, 17, 19]], dtype=int32)>
```
# 使用`tf.function`
`tf.function`是將采用 Python 函數并返回 TensorFlow 圖的函數。 這樣做的好處是,圖可以在 Python 函數(`func`)中應用優化并利用并行性。 `tf.function`是 TensorFlow 2 的新功能。
其簽名如下:
```py
tf.function(
func=None,
input_signature=None,
autograph=True,
experimental_autograph_options=None
)
```
示例如下:
```py
def f1(x, y):
return tf.reduce_mean(input_tensor=tf.multiply(x ** 2, 5) + y**2)
f2 = tf.function(f1)
x = tf.constant([4., -5.])
y = tf.constant([2., 3.])
# f1 and f2 return the same value, but f2 executes as a TensorFlow graph
assert f1(x,y).numpy() == f2(x,y).numpy()
```
斷言通過,因此沒有輸出。
# 總結
在本章中,我們通過查看一些說明一些基本操作的代碼片段開始熟悉 TensorFlow。 我們對現代 TensorFlow 生態系統以及如何安裝 TensorFlow 進行了概述。 我們還研究了一些管家操作,一些急切操作以及各種 TensorFlow 操作,這些操作在本書的其余部分中將是有用的。 在 [www.youtube.com/watch?v=k5c-vg4rjBw](https://www.youtube.com/watch?v=k5c-vg4rjBw) 上對 TensorFlow 2 進行了出色的介紹。
另請參閱“附錄 A”,以獲得`tf1.12`到`tf2`轉換工具的詳細信息。 在下一章中,我們將介紹 Keras,這是 TensorFlow 2 的高級 API。
- TensorFlow 1.x 深度學習秘籍
- 零、前言
- 一、TensorFlow 簡介
- 二、回歸
- 三、神經網絡:感知器
- 四、卷積神經網絡
- 五、高級卷積神經網絡
- 六、循環神經網絡
- 七、無監督學習
- 八、自編碼器
- 九、強化學習
- 十、移動計算
- 十一、生成模型和 CapsNet
- 十二、分布式 TensorFlow 和云深度學習
- 十三、AutoML 和學習如何學習(元學習)
- 十四、TensorFlow 處理單元
- 使用 TensorFlow 構建機器學習項目中文版
- 一、探索和轉換數據
- 二、聚類
- 三、線性回歸
- 四、邏輯回歸
- 五、簡單的前饋神經網絡
- 六、卷積神經網絡
- 七、循環神經網絡和 LSTM
- 八、深度神經網絡
- 九、大規模運行模型 -- GPU 和服務
- 十、庫安裝和其他提示
- TensorFlow 深度學習中文第二版
- 一、人工神經網絡
- 二、TensorFlow v1.6 的新功能是什么?
- 三、實現前饋神經網絡
- 四、CNN 實戰
- 五、使用 TensorFlow 實現自編碼器
- 六、RNN 和梯度消失或爆炸問題
- 七、TensorFlow GPU 配置
- 八、TFLearn
- 九、使用協同過濾的電影推薦
- 十、OpenAI Gym
- TensorFlow 深度學習實戰指南中文版
- 一、入門
- 二、深度神經網絡
- 三、卷積神經網絡
- 四、循環神經網絡介紹
- 五、總結
- 精通 TensorFlow 1.x
- 一、TensorFlow 101
- 二、TensorFlow 的高級庫
- 三、Keras 101
- 四、TensorFlow 中的經典機器學習
- 五、TensorFlow 和 Keras 中的神經網絡和 MLP
- 六、TensorFlow 和 Keras 中的 RNN
- 七、TensorFlow 和 Keras 中的用于時間序列數據的 RNN
- 八、TensorFlow 和 Keras 中的用于文本數據的 RNN
- 九、TensorFlow 和 Keras 中的 CNN
- 十、TensorFlow 和 Keras 中的自編碼器
- 十一、TF 服務:生產中的 TensorFlow 模型
- 十二、遷移學習和預訓練模型
- 十三、深度強化學習
- 十四、生成對抗網絡
- 十五、TensorFlow 集群的分布式模型
- 十六、移動和嵌入式平臺上的 TensorFlow 模型
- 十七、R 中的 TensorFlow 和 Keras
- 十八、調試 TensorFlow 模型
- 十九、張量處理單元
- TensorFlow 機器學習秘籍中文第二版
- 一、TensorFlow 入門
- 二、TensorFlow 的方式
- 三、線性回歸
- 四、支持向量機
- 五、最近鄰方法
- 六、神經網絡
- 七、自然語言處理
- 八、卷積神經網絡
- 九、循環神經網絡
- 十、將 TensorFlow 投入生產
- 十一、更多 TensorFlow
- 與 TensorFlow 的初次接觸
- 前言
- 1.?TensorFlow 基礎知識
- 2. TensorFlow 中的線性回歸
- 3. TensorFlow 中的聚類
- 4. TensorFlow 中的單層神經網絡
- 5. TensorFlow 中的多層神經網絡
- 6. 并行
- 后記
- TensorFlow 學習指南
- 一、基礎
- 二、線性模型
- 三、學習
- 四、分布式
- TensorFlow Rager 教程
- 一、如何使用 TensorFlow Eager 構建簡單的神經網絡
- 二、在 Eager 模式中使用指標
- 三、如何保存和恢復訓練模型
- 四、文本序列到 TFRecords
- 五、如何將原始圖片數據轉換為 TFRecords
- 六、如何使用 TensorFlow Eager 從 TFRecords 批量讀取數據
- 七、使用 TensorFlow Eager 構建用于情感識別的卷積神經網絡(CNN)
- 八、用于 TensorFlow Eager 序列分類的動態循壞神經網絡
- 九、用于 TensorFlow Eager 時間序列回歸的遞歸神經網絡
- TensorFlow 高效編程
- 圖嵌入綜述:問題,技術與應用
- 一、引言
- 三、圖嵌入的問題設定
- 四、圖嵌入技術
- 基于邊重構的優化問題
- 應用
- 基于深度學習的推薦系統:綜述和新視角
- 引言
- 基于深度學習的推薦:最先進的技術
- 基于卷積神經網絡的推薦
- 關于卷積神經網絡我們理解了什么
- 第1章概論
- 第2章多層網絡
- 2.1.4生成對抗網絡
- 2.2.1最近ConvNets演變中的關鍵架構
- 2.2.2走向ConvNet不變性
- 2.3時空卷積網絡
- 第3章了解ConvNets構建塊
- 3.2整改
- 3.3規范化
- 3.4匯集
- 第四章現狀
- 4.2打開問題
- 參考
- 機器學習超級復習筆記
- Python 遷移學習實用指南
- 零、前言
- 一、機器學習基礎
- 二、深度學習基礎
- 三、了解深度學習架構
- 四、遷移學習基礎
- 五、釋放遷移學習的力量
- 六、圖像識別與分類
- 七、文本文件分類
- 八、音頻事件識別與分類
- 九、DeepDream
- 十、自動圖像字幕生成器
- 十一、圖像著色
- 面向計算機視覺的深度學習
- 零、前言
- 一、入門
- 二、圖像分類
- 三、圖像檢索
- 四、對象檢測
- 五、語義分割
- 六、相似性學習
- 七、圖像字幕
- 八、生成模型
- 九、視頻分類
- 十、部署
- 深度學習快速參考
- 零、前言
- 一、深度學習的基礎
- 二、使用深度學習解決回歸問題
- 三、使用 TensorBoard 監控網絡訓練
- 四、使用深度學習解決二分類問題
- 五、使用 Keras 解決多分類問題
- 六、超參數優化
- 七、從頭開始訓練 CNN
- 八、將預訓練的 CNN 用于遷移學習
- 九、從頭開始訓練 RNN
- 十、使用詞嵌入從頭開始訓練 LSTM
- 十一、訓練 Seq2Seq 模型
- 十二、深度強化學習
- 十三、生成對抗網絡
- TensorFlow 2.0 快速入門指南
- 零、前言
- 第 1 部分:TensorFlow 2.00 Alpha 簡介
- 一、TensorFlow 2 簡介
- 二、Keras:TensorFlow 2 的高級 API
- 三、TensorFlow 2 和 ANN 技術
- 第 2 部分:TensorFlow 2.00 Alpha 中的監督和無監督學習
- 四、TensorFlow 2 和監督機器學習
- 五、TensorFlow 2 和無監督學習
- 第 3 部分:TensorFlow 2.00 Alpha 的神經網絡應用
- 六、使用 TensorFlow 2 識別圖像
- 七、TensorFlow 2 和神經風格遷移
- 八、TensorFlow 2 和循環神經網絡
- 九、TensorFlow 估計器和 TensorFlow HUB
- 十、從 tf1.12 轉換為 tf2
- TensorFlow 入門
- 零、前言
- 一、TensorFlow 基本概念
- 二、TensorFlow 數學運算
- 三、機器學習入門
- 四、神經網絡簡介
- 五、深度學習
- 六、TensorFlow GPU 編程和服務
- TensorFlow 卷積神經網絡實用指南
- 零、前言
- 一、TensorFlow 的設置和介紹
- 二、深度學習和卷積神經網絡
- 三、TensorFlow 中的圖像分類
- 四、目標檢測與分割
- 五、VGG,Inception,ResNet 和 MobileNets
- 六、自編碼器,變分自編碼器和生成對抗網絡
- 七、遷移學習
- 八、機器學習最佳實踐和故障排除
- 九、大規模訓練
- 十、參考文獻