# 二、Keras:TensorFlow 2 的高級 API
在本章中,我們將討論 Keras,這是 TensorFlow 2 的高級 API。Keras 是由 Fran?oisChollet 在 Google 上開發的。 Keras 在快速原型制作,深度學習模型的構建和訓練以及研究和生產方面非常受歡迎。 Keras 是一個非常豐富的 API。 正如我們將看到的,它支持急切的執行和數據管道以及其他功能。
自 2017 年以來,Keras 已可用于 TensorFlow,但隨著 TensorFlow 2.0 的發布,其用途已擴展并進一步集成到 TensorFlow 中。 TensorFlow 2.0 已將 Keras 用作大多數深度學習開發工作的首選 API。
可以將 Keras 作為獨立模塊導入,但是在本書中,我們將集中精力在 TensorFlow 2 內部使用 Keras。因此,該模塊為`tensorflow.keras`。
在本章中,我們將介紹以下主題:
* Keras 的采用和優勢
* Keras 的特性
* 默認的 Keras 配置文件
* Keras 后端
* Keras 數據類型
* Keras 模型
* Keras 數據集
# Keras 的采用和優勢
下圖顯示了 Keras 在工業和研究領域的廣泛應用。 *PowerScore* 排名由 Jeff Hale 設計,他使用了 7 個不同類別的 11 個數據源來評估框架的使用,興趣和受歡迎程度。 然后,他對數據進行了加權和合并,[如 2018 年 9 月的這篇文章所示](https://towardsdatascience.com/deep-learning-framework-power-scores-2018-23607ddf297a):

Keras 具有許多優點,其中包括:
* 它專為新用戶和專家而設計,提供一致且簡單的 API
* 通過簡單,一致的接口對用戶友好,該接口針對常見用例進行了優化
* 它為用戶錯誤提供了很好的反饋,這些錯誤很容易理解,并且經常伴隨有用的建議
* 它是模塊化且可組合的; Keras 中的模型是通過結合可配置的構建塊來構建的
* 通過編寫自定義構建塊很容易擴展
* 無需導入 Keras,因為它可以作為`tensorflow.keras`獲得
# Keras 的特性
如果您想知道 TensorFlow 隨附的 Keras 版本,請使用以下命令:
```py
import tensorflow as tf
print(tf.keras.__version__)
```
在撰寫本文時,這產生了以下內容(來自 TensorFlow 2 的 Alpha 版本):
```py
2.2.4-tf
```
Keras 的其他功能包括對多 GPU 數據并行性的內置支持,以及 Keras 模型可以轉化為 TensorFlow Estimators 并在 Google Cloud 上的 GPU 集群上進行訓練的事實。
Keras 可能是不尋常的,因為它具有作為獨立開源項目維護的參考實現,位于 [www.keras.io](http://www.keras.io) 。
盡管 TensorFlow 在`tf.keras`模塊中確實具有 Keras 的完整實現,但它獨立于 TensorFlow 進行維護。 默認情況下,該實現具有 TensorFlow 特定的增強功能,包括對急切執行的支持。
急切的執行意味著代碼的執行是命令式編程環境,而不是基于圖的環境,這是在 TensorFlow(v1.5 之前)的初始產品中工作的唯一方法。 這種命令式(即刻)風格允許直觀的調試,快速的開發迭代,支持 TensorFlow `SavedModel`格式,并內置支持對 CPU,GPU 甚至 Google 自己的硬件**張量處理單元**(**TPU**)進行分布式訓練。
TensorFlow 實現還支持`tf.data`,分發策略,導出模型(可通過 TensorFlow Lite 部署在移動和嵌入式設備上)以及用于表示和分類結構化數據的特征列。
# 默認的 Keras 配置文件
Linux 用戶的默認配置文件如下:
```py
$HOME/.keras/keras.json
```
對于 Windows 用戶,將`$HOME`替換為`%USERPROFILE%`。
它是在您第一次使用 Keras 時創建的,可以進行編輯以更改默認值。 以下是`.json`文件包含的內容:
```py
{ "image_data_format": "channels_last", "epsilon": 1e-07, "floatx": "float32", "backend": "tensorflow" }
```
默認值如下:
* `image_data_format`:這是圖像格式的字符串,`"channels_last"`或`channels_first`。 在 TensorFlow 之上運行的 Keras 使用默認值。
* `epsilon`:這是一個浮點數,是一個*模糊*常數,用于在某些操作中避免被零除。
* `floatx`:這是一個字符串,指定默認的浮點精度,為`"float16"`,`"float32"`或`"float64"`之一。
* `backend`:這是一個字符串,指定 Keras 在`"tensorflow"`,`"theano"`或`"cntk"`中的一種之上發現自己的工具。
對于所有這些值,在`keras.backend`中有獲取器和設置器方法。 參見[這里](https://keras.io/backend/)。
例如,在以下集合中,供 Keras 使用的浮點類型為`floatx`,其中`floatx`參數是以下命令中所示的三種精度之一:
```py
keras.backend.set_floatx(floatx)
```
# Keras 后端
由于其模型級別的庫結構,Keras 可能具有處理低級操作(例如卷積,張量乘積等)的不同張量操縱引擎。 這些引擎稱為**后端**。 其他后端可用; 我們在這里不考慮它們。
相同的[鏈接](https://keras.io/backend/)可帶您使用許多`keras.backend`函數。
使用 Keras `backend`的規范方法是:
```py
from keras import backend as K
```
例如,以下是有用函數的簽名:
```py
K.constant(value, dtype=None, shape=None, name=None)
```
`value`是要賦予常數的值,`dtype`是創建的張量的類型,`shape`是創建的張量的形狀,`name`是可選名稱。
實例如下:
```py
from tensorflow.keras import backend as K
const = K.constant([[42,24],[11,99]], dtype=tf.float16, shape=[2,2])
const
```
這將產生以下恒定張量。 注意,由于啟用了急切執行,(默認情況下)在輸出中給出常量的值:
```py
<tf.Tensor: id=1, shape=(2, 2), dtype=float16, numpy= array([[42., 24.], [11., 99.]], dtype=float16)>
```
急切不啟用,輸出將如下所示:
```py
<tf.Tensor 'Const:0' shape=(2, 2) dtype=float16>
```
# Keras 數據類型
Keras **數據類型**(`dtypes`)與 TensorFlow Python 數據類型相同,如下表所示:
| Python 類型 | 描述 |
| --- | --- |
| `tf.float16` | 16 位浮點 |
| `tf.float32` | 32 位浮點 |
| `tf.float64` | 64 位浮點 |
| `tf.int8` | 8 位有符號整數 |
| `tf.int16` | 16 位有符號整數 |
| `tf.int32` | 32 位有符號整數 |
| `tf.int64` | 64 位有符號整數 |
| `tf.uint8` | 8 位無符號整數 |
| `tf.string` | 可變長度字節數組 |
| `tf.bool` | 布爾型 |
| `tf.complex64` | 由兩個 32 位浮點組成的復數-一個實部和虛部 |
| `tf.complex128` | 由兩個 64 位浮點組成的復數-一個實部和一個虛部 |
| `tf.qint8` | 量化運算中使用的 8 位有符號整數 |
| `tf.qint32` | 量化運算中使用的 32 位有符號整數 |
| `tf.quint8` | 量化運算中使用的 8 位無符號整數 |
# Keras 模型
Keras 基于神經網絡模型的概念。 主要模型稱為**序列**,是層的線性棧。 還有一個使用 Keras 函數式 API 的系統。
# Keras 順序模型
要構建 Keras `Sequential`模型,請*向其中添加層*,其順序與您希望網絡進行計算的順序相同。
建立模型后,您可以*編譯*; 這樣可以優化要進行的計算,并且可以在其中分配優化器和希望模型使用的損失函數。
下一步是*使模型擬合數據*。 這通常稱為訓練模型,是所有計算發生的地方。 可以分批或一次將數據呈現給模型。
接下來,您評估模型以建立其準確率,損失和其他指標。 最后,在訓練好模型之后,您可以使用它對新數據進行預測。 因此,工作流程是:構建,編譯,擬合,評估,做出預測。
有兩種創建`Sequential`模型的方法。 讓我們看看它們中的每一個。
# 創建順序模型的第一種方法
首先,可以將層實例列表傳遞給構造器,如以下示例所示。
在下一章中,我們將對層進行更多的討論。 目前,我們將僅作足夠的解釋,以使您了解此處發生的情況。
采集數據。 `mnist`是手繪數字的數據集,每個數字在`28 x 28`像素的網格上。 每個單獨的數據點都是一個無符號的 8 位整數(`uint8`),如標簽所示:
```py
mnist = tf.keras.datasets.mnist
(train_x,train_y), (test_x, test_y) = mnist.load_data()
```
`epochs`變量存儲我們將數據呈現給模型的次數:
```py
epochs=10
batch_size = 32 # 32 is default in fit method but specify anyway
```
接下來,將所有數據點(`x`)歸一化為`float32`類型的浮點數范圍為 0 到 1。 另外,根據需要將標簽(`y`)投射到`int64`:
```py
train_x, test_x = tf.cast(train_x/255.0, tf.float32), tf.cast(test_x/255.0, tf.float32)
train_y, test_y = tf.cast(train_y,tf.int64),tf.cast(test_y,tf.int64)
```
模型定義如下。
注意在模型定義中我們如何傳遞層列表:
* `Flatten`接受`28 x 28`(即 2D)像素圖像的輸入,并產生 784(即 1D)向量,因為下一個(密集)層是一維的。
* `Dense`是一個完全連接的層,意味著其所有神經元都連接到上一層和下一層中的每個神經元。 下面的示例有 512 個神經元,其輸入通過 ReLU(非線性)激活函數傳遞。
* `Dropout`隨機關閉上一層神經元的一部分(在這種情況下為 0.2)。 這樣做是為了防止任何特定的神經元變得過于專業化,并導致模型*與數據*過擬合,從而影響測試數據上模型的準確率指標(在后面的章節中將對此進行更多介紹)。
* 最后的`Dense`層具有一個稱為`softmax`的特殊激活函數,該函數將概率分配給可能的 10 個輸出單元中的每一個:
```py
model1 = tf.keras.models.Sequential([
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(512,activation=tf.nn.relu),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10,activation=tf.nn.softmax)
])
```
`model.summary()`函數是一種有用的同義詞方法,并為我們的模型提供以下輸出:

`401920`的數字來自輸入`28 x 28 = 784 x 512`(`dense_2`層)輸出`784 * 512 = 401,408`以及每個`dense_1`層神經元的偏置單元 ,則`401,408 + 512 = 401,920`。
`5130`的數字來自`512 * 10 + 10 = 5,130`。
接下來,我們編譯模型,如以下代碼所示:
```py
optimiser = tf.keras.optimizers.Adam()
model1.compile (optimizer= optimiser, loss='sparse_categorical_crossentropy', metrics = ['accuracy'])
```
`optimizer`是一種方法,通過該方法可以調整模型中加權連接的權重以減少損失。
`loss`是模型所需輸出與實際輸出之間差異的度量,而`metrics`是我們評估模型的方式。
為了訓練我們的模型,我們接下來使用`fit`方法,如下所示:
```py
model1.fit(train_x, train_y, batch_size=batch_size, epochs=epochs)
```
調用`fit()`的輸出如下,顯示了周期訓練時間,損失和準確率:
```py
Epoch 1/10 60000/60000 [==============================] - 5s 77us/step - loss: 0.2031 - acc: 0.9394 ...
Epoch 10/10 60000/60000 [==============================] - 4s 62us/step - loss: 0.0098 - acc: 0.9967
```
最后,我們可以使用`evaluate`方法檢查我們訓練有素的模型的準確率:
```py
model1.evaluate(test_x, test_y)
```
這將產生以下輸出:
```py
10000/10000 [==============================] - 0s 39us/step [0.09151900197149189, 0.9801]
```
這表示測試數據的損失為 0.09,準確率為 0.9801。 精度為 0.98 意味著該模型平均可以識別出 100 個測試數據點中的 98 個。
# 創建順序模型的第二種方法
對于同一體系結構,將層列表傳遞給`Sequential`模型的構造器的替代方法是使用`add`方法,如下所示:
```py
model2 = tf.keras.models.Sequential();
model2.add(tf.keras.layers.Flatten())
model2.add(tf.keras.layers.Dense(512, activation='relu'))
model2.add(tf.keras.layers.Dropout(0.2))
model2.add(tf.keras.layers.Dense(10,activation=tf.nn.softmax))
model2.compile (optimizer= tf.keras.Adam(), loss='sparse_categorical_crossentropy',
metrics = ['accuracy'])
```
如我們所見,`fit()`方法執行訓練,使用模型將輸入擬合為輸出:
```py
model2.fit(train_x, train_y, batch_size=batch_size, epochs=epochs)
```
然后,我們使用`test`數據評估模型的表現:
```py
model2.evaluate(test_x, test_y)
```
這給我們帶來了`0.07`的損失和`0.981`的準確率。
因此,這種定義模型的方法產生的結果與第一個結果幾乎相同,這是可以預期的,因為它是相同的體系結構,盡管表達方式略有不同,但具有相同的`optimizer`和`loss`函數。 現在讓我們看一下函數式 API。
# Keras 函數式 API
與以前看到的`Sequential`模型的簡單線性棧相比,函數式 API 使您可以構建更復雜的體系結構。 它還支持更高級的模型。 這些模型包括多輸入和多輸出模型,具有共享層的模型以及具有剩余連接的模型。
這是函數式 API 的使用的簡短示例,其架構與前兩個相同。
設置代碼與先前演示的相同:
```py
import tensorflow as tf
mnist = tf.keras.datasets.mnist
(train_x,train_y), (test_x, test_y) = mnist.load_data()
train_x, test_x = train_x/255.0, test_x/255.0
epochs=10
```
這是模型定義。
注意如何在`tensor`上調用層并返回張量作為輸出,然后如何使用這些輸入和輸出張量來定義模型:
```py
inputs = tf.keras.Input(shape=(28,28)) # Returns a 'placeholder' tensor
x = tf.keras.layers.Flatten()(inputs)
x = tf.layers.Dense(512, activation='relu',name='d1')(x)
x = tf.keras.layers.Dropout(0.2)(x)
predictions = tf.keras.layers.Dense(10,activation=tf.nn.softmax, name='d2')(x)
model3 = tf.keras.Model(inputs=inputs, outputs=predictions)
```
請注意,此代碼如何產生與`model1`和`model2`相同的體系結構:

`None`出現在這里是因為我們沒有指定我們有多少輸入項(即批量大小)。 這確實意味著*未提供*。
其余代碼與前面的示例相同:
```py
optimiser = tf.keras.optimizers.Adam()
model3.compile (optimizer= optimiser, loss='sparse_categorical_crossentropy', metrics = ['accuracy'])
model3.fit(train_x, train_y, batch_size=32, epochs=epochs)
model3.evaluate(test_x, test_y)
```
對于相同的體系結構,這同樣會產生`0.067`的損失和`0.982`的精度。
接下來,讓我們看看如何對 Keras `model`類進行子類化。
# 子類化 Keras 模型類
Keras `Model`類可以被子類化,如下面的代碼所示。 Google 指出,*純*函數風格(如前面的示例所示)比子類風格更可取(我們在此包括其內容是出于完整性的考慮,因為它很有趣)。
首先,請注意如何在構造器(`.__init__()`)中分別聲明和命名層。
然后,注意在`call()`方法中各層如何以函數風格鏈接在一起。 此方法封裝了*前向傳播*:
```py
class MyModel(tf.keras.Model):
def __init__(self, num_classes=10):
super(MyModel, self).__init__()
# Define your layers here.
inputs = tf.keras.Input(shape=(28,28)) # Returns a placeholder tensor
self.x0 = tf.keras.layers.Flatten()
self.x1 = tf.keras.layers.Dense(512, activation='relu',name='d1')
self.x2 = tf.keras.layers.Dropout(0.2)
self.predictions = tf.keras.layers.Dense(10,activation=tf.nn.softmax, name='d2')
def call(self, inputs):
# This is where to define your forward pass
# using the layers previously defined in `__init__`
x = self.x0(inputs)
x = self.x1(x)
x = self.x2(x)
return self.predictions(x)
model4 = MyModel()
```
該定義可以代替本章中的任何較早的模型定義使用,它們具有相同的數據下載支持代碼,以及相似的用于訓練/評估的代碼。 下面的代碼顯示了最后一個示例:
```py
model4 = MyModel()
batch_size = 32
steps_per_epoch = len(train_x.numpy())//batch_size
print(steps_per_epoch)
model4.compile (optimizer= tf.keras.Adam(), loss='sparse_categorical_crossentropy',
metrics = ['accuracy'])
model4.fit(train_x, train_y, batch_size=batch_size, epochs=epochs)
model4.evaluate(test_x, test_y)
```
結果是`0.068`的損失,準確率為`0.982`; 再次與本章中其他三種模型構建風格產生的結果幾乎相同。
# 使用數據管道
也可以使用以下代碼將數據作為`tf.data.Dataset()`迭代器傳遞到`fit`方法中(數據獲取代碼與先前描述的相同)。 `from_tensor_slices()`方法將 NumPy 數組轉換為數據集。 注意`batch()`和`shuffle()`方法鏈接在一起。 接下來,`map()`方法在輸入圖像`x`上調用一種方法,該方法在`y`軸上隨機翻轉其中的兩個,有效地增加了圖像集的大小。 標簽`y`在這里保持不變。 最后,`repeat()`方法意味著在到達數據集的末尾(連續)時,將從頭開始重新填充該數據集:
```py
batch_size = 32
buffer_size = 10000
train_dataset = tf.data.Dataset.from_tensor_slices((train_x, train_y)).batch(32).shuffle(10000)
train_dataset = train_dataset.map(lambda x, y: (tf.image.random_flip_left_right(x), y))
train_dataset = train_dataset.repeat()
```
`test`設置的代碼類似,除了不進行翻轉:
```py
test_dataset = tf.data.Dataset.from_tensor_slices((test_x, test_y)).batch(batch_size).shuffle(10000)
test_dataset = train_dataset.repeat()
```
現在,在`fit()`函數中,我們可以直接傳遞數據集,如下所示:
```py
steps_per_epoch = len(train_x)//batch_size # required because of the repeat on the dataset
optimiser = tf.keras.optimizers.Adam()
model5.compile (optimizer= optimiser, loss='sparse_categorical_crossentropy', metrics = ['accuracy'])
model.fit(train_dataset, batch_size=batch_size, epochs=epochs, steps_per_epoch=steps_per_epoch)
```
編譯和評估代碼與之前看到的類似。
使用`data.Dataset`迭代器的優點在于,管道可以處理通常用于準備數據的大部分管道,例如批量和改組。 我們也已經看到,各種操作可以鏈接在一起。
# 保存和加載 Keras 模型
TensorFlow 中的 Keras API 具有輕松保存和恢復模型的能力。 這樣做如下,并將模型保存在當前目錄中。 當然,這里可以通過更長的路徑:
```py
model.save('./model_name.h5')
```
這將保存模型體系結構,權重,訓練狀態(`loss`,`optimizer`)和優化器的狀態,以便您可以從上次中斷的地方繼續訓練模型。
加載保存的模型的步驟如下。 請注意,如果您已經編譯了模型,那么負載將使用保存的訓練配置來編譯模型:
```py
from tensorflow.keras.models import load_model
new_model = load_model('./model_name.h5')
```
也可以僅保存模型權重并以此加載它們(在這種情況下,必須構建體系結構以將權重加載到其中):
```py
model.save_weights('./model_weights.h5')
```
然后使用以下內容加載它:
```py
model.load_weights('./model_weights.h5')
```
# Keras 數據集
可從 Keras 中獲得以下數據集:`boston_housing`,`cifar10`,`cifar100`,`fashion_mnist`,`imdb`,`mnist`和`reuters`。
它們都可以通過`load_data()`函數訪問。 例如,要加載`fashion_mnist`數據集,請使用以下命令:
```py
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()
```
可以在[這個頁面](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/datasets/)中找到更多詳細信息。
# 總結
在本章中,我們使用通用注釋和見解探索了 Keras API,然后以四種不同的方式表示相同的基本體系結構,以訓練`mnist`數據集。
在下一章中,我們將通過探索許多監督的學習場景,包括線性回歸,邏輯回歸和 K 近鄰,開始認真使用 TensorFlow。
- 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
- 六、自編碼器,變分自編碼器和生成對抗網絡
- 七、遷移學習
- 八、機器學習最佳實踐和故障排除
- 九、大規模訓練
- 十、參考文獻