# 二、TensorFlow 的高級庫
TensorFlow 有幾個高級庫和接口（API），允許我們使用 TFLearn，TFSlim，Sonnet，PrettyTensor，Keras 和最近發布的 TensorFlow Estimators 輕松構建和訓練模型。
我們將在本章中介紹以下高級庫，同時將下一章專門用于 Keras：
* TFEstimator - 以前的 TF 學習
* TFSlim
* TFLearn
* PrettyTensor
* Sonnet
我們將提供使用所有五個庫構建 MNIST 數據集模型的示例。當我們從第 4 章開始介紹模型的細節時，不要擔心理解模型的細節。
您可以使用代碼包中包含的 Jupyter 筆記本`ch-02_TF_High_Level_Libraries`來遵循本章中的代碼示例。 嘗試修改筆記本中的示例以進行實驗和游戲。
# TFEstimator - 以前的 TF 學習
TFEstimator 是一個高級 API，通過封裝訓練，評估，預測和導出函數，可以輕松創建和訓練模型。 TensorFlow 最近重新命名并在 TensorFlow 中以新名稱 TFEstimator 發布了 TFLearn 包，可能是為了避免與 tflearn.org 的 TFLearn 包混淆。 TFEstimator API 對原始 TF 學習包進行了重大改進，這些包在 KDD 17 會議上提供的研究論文中有所描述，[可以在此鏈接中找到](https://doi.org/10.1145/3097983.3098171)。
TFEstimator 接口設計靈感來自流行的機器學習庫 SciKit Learn，允許從不同類型的可用模型創建估計器對象，然后在任何類型的估計器上提供四個主要函數：
* `estimator.fit()`
* `estimator.evaluate()`
* `estimator.predict()`
* `estimator.export()`
函數的名稱是不言自明的。估計器對象表示模型，但模型本身是從提供給估計器的模型定義函數創建的。
我們可以在下圖中描述估計器對象及其接口：
使用 Estimator API 而不是在核心 TensorFlow 中構建所有內容，可以不用擔心圖，會話，初始化變量或其他低級細節。在撰寫本書時，TensorFlow 提供了以下預構建的估計器：
* `tf.contrib.learn.KMeansClustering`
* `tf.contrib.learn.DNNClassifier`
* `tf.contrib.learn.DNNRegressor`
* `tf.contrib.learn.DNNLinearCombinedRegressor`
* `tf.contrib.learn.DNNLinearCombinedClassifier`
* `tf.contrib.learn.LinearClassifier`
* `tf.contrib.learn.LinearRegressor`
* `tf.contrib.learn.LogisticRegressor`
TFEstimator API 中的簡單工作流程如下：
1. 找到與您要解決的問題相關的預構建 Estimator。
2. 編寫導入數據集的函數。
3. 定義包含特征的數據中的列。
4. 創建在步驟 1 中選擇的預構建估計器的實例。
5. 訓練估計器。
6. 使用經過訓練的估計器進行評估或預測。
下一章討論的 Keras 庫提供了將 Keras 模型轉換為 Estimators 的便捷函數：`keras.estimator.model_to_estimator()`。
筆記本`ch-02_TF_High_Level_Libraries`中提供了 MNIST 分類示例的完整代碼。 TFEstimator MNIST 示例的輸出如下：
```py
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmprvcqgu07
INFO:tensorflow:Using config: {'_save_checkpoints_steps': None, '_task_type': 'worker', '_save_checkpoints_secs': 600, '_service': None, '_task_id': 0, '_master': '', '_session_config': None, '_num_worker_replicas': 1, '_keep_checkpoint_max': 5, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x7ff9d15f5fd0>, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_is_chief': True, '_save_summary_steps': 100, '_model_dir': '/tmp/tmprvcqgu07', '_num_ps_replicas': 0, '_tf_random_seed': None}
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Saving checkpoints for 1 into /tmp/tmprvcqgu07/model.ckpt.
INFO:tensorflow:loss = 2.4365, step = 1
INFO:tensorflow:global_step/sec: 597.996
INFO:tensorflow:loss = 1.47152, step = 101 (0.168 sec)
INFO:tensorflow:global_step/sec: 553.29
INFO:tensorflow:loss = 0.728581, step = 201 (0.182 sec)
INFO:tensorflow:global_step/sec: 519.498
INFO:tensorflow:loss = 0.89795, step = 301 (0.193 sec)
INFO:tensorflow:global_step/sec: 503.414
INFO:tensorflow:loss = 0.743328, step = 401 (0.202 sec)
INFO:tensorflow:global_step/sec: 539.251
INFO:tensorflow:loss = 0.413222, step = 501 (0.181 sec)
INFO:tensorflow:global_step/sec: 572.327
INFO:tensorflow:loss = 0.416304, step = 601 (0.174 sec)
INFO:tensorflow:global_step/sec: 543.99
INFO:tensorflow:loss = 0.459793, step = 701 (0.184 sec)
INFO:tensorflow:global_step/sec: 687.748
INFO:tensorflow:loss = 0.501756, step = 801 (0.146 sec)
INFO:tensorflow:global_step/sec: 654.217
INFO:tensorflow:loss = 0.666772, step = 901 (0.153 sec)
INFO:tensorflow:Saving checkpoints for 1000 into /tmp/tmprvcqgu07/model.ckpt.
INFO:tensorflow:Loss for final step: 0.426257.
INFO:tensorflow:Starting evaluation at 2017-12-15-02:27:45
INFO:tensorflow:Restoring parameters from /tmp/tmprvcqgu07/model.ckpt-1000
INFO:tensorflow:Finished evaluation at 2017-12-15-02:27:45
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8856, global_step = 1000, loss = 0.40996
{'accuracy': 0.88559997, 'global_step': 1000, 'loss': 0.40995964}
```
您將在第 5 章中看到如何使用核心 TensorFlow 創建此類模型。
# TFSlim
TFSlim 是一個基于 TensorFlow 核心構建的輕量級庫，用于定義和訓練模型。 TFSlim 可與其他 TensorFlow 低級和高級庫（如 TFLearn）結合使用。 TFSlim 是包裝中 TensorFlow 安裝的一部分：`tf.contrib.slim`。運行以下命令以檢查 TFSlim 安裝是否正常工作：
```py
python3 -c 'import tensorflow.contrib.slim as slim; eval = slim.evaluation.evaluate_once'
```
TFSlim 提供了幾個模塊，可以獨立挑選和應用，并與其他 TensorFlow 包混合使用。例如，在撰寫本書時，TFSlim 有以下主要模塊：
| TFSlim 模塊 | 模塊說明 |
| --- | --- |
| `arg_scope` | 提供將元素應用于作用域下定義的所有圖節點的機制。 |
| `layer` | 提供幾種不同的層，如`fully_connected`，`conv2d`等等。 |
| `loss` | 提供用于訓練優化器的損失函數 |
| `learn` | 提供訓練模型的函數 |
| `evaluate` | 提供評估函數 |
| `metics` | 提供用于評估模型的度量函數 |
| `regularizers` | 提供用于創建正則化方法的函數 |
| `variable` | 提供變量創建的函數 |
| `net` | 提供各種預制和預訓練模型，如 VGG16，InceptionV3，ResNet |
TFSlim 的簡單工作流程如下：
1. 使用 Slim 層創建模型。
2. 提供層的輸入以實例化模型。
3. 使用對率和標簽來定義損失。
4. 使用便利函數`get_total_loss()`獲得全部損失。
5. 創建一個優化器。
6. 使用便利函數`slim.learning.create_train_op()`，`total_loss`和`optimizer`創建訓練函數。
7. 使用上一步中定義的便捷函數`slim.learning.train()`和訓練函數運行訓練。
筆記本`ch-02_TF_High_Level_Libraries`中提供了 MNIST 分類示例的完整代碼。 TFSlim MNIST 示例的輸出如下：
```py
INFO:tensorflow:Starting Session.
INFO:tensorflow:Saving checkpoint to path ./slim_logs/model.ckpt
INFO:tensorflow:global_step/sec: 0
INFO:tensorflow:Starting Queues.
INFO:tensorflow:global step 100: loss = 2.2669 (0.010 sec/step)
INFO:tensorflow:global step 200: loss = 2.2025 (0.010 sec/step)
INFO:tensorflow:global step 300: loss = 2.1257 (0.010 sec/step)
INFO:tensorflow:global step 400: loss = 2.0419 (0.009 sec/step)
INFO:tensorflow:global step 500: loss = 1.9532 (0.009 sec/step)
INFO:tensorflow:global step 600: loss = 1.8733 (0.010 sec/step)
INFO:tensorflow:global step 700: loss = 1.8002 (0.010 sec/step)
INFO:tensorflow:global step 800: loss = 1.7273 (0.010 sec/step)
INFO:tensorflow:global step 900: loss = 1.6688 (0.010 sec/step)
INFO:tensorflow:global step 1000: loss = 1.6132 (0.010 sec/step)
INFO:tensorflow:Stopping Training.
INFO:tensorflow:Finished training! Saving model to disk.
final loss=1.6131552457809448
```
從輸出中可以看出，便捷函數`slim.learning.train()`將訓練輸出保存在指定日志目錄中的檢查點文件中。如果重新開始訓練，它將首先檢查檢查點是否存在，并且默認情況下將從檢查點恢復訓練。
在撰寫本文時，[TFSlim 的文檔頁面在此鏈接中被發現為空](https://www.tensorflow.org/api_docs/python/tf/contrib/slim)。 但是，[可以在此鏈接的源代碼中找到一些文檔](https://github.com/tensorflow/tensorflow/tree/r1.4/tensorflow/contrib/slim)。
我們將使用 TFSlim 來學習如何在后面的章節中使用預訓練的模型，如 VGG16 和 InceptionV3。
# TFLearn
TFLearn 是 Python 中的模塊化庫，它構建在核心 TensorFlow 之上。
TFLearn 與 TensorFlow Learn 包不同，后者也稱為 TFLearn（TF 和 Learn 之間有一個空格）。[TFLearn 可從此鏈接獲得](http://tflearn.org)，[源代碼可在 GitHub 上的此鏈接獲得](https://github.com/tflearn/tflearn)。
可以使用以下命令在 Python 3 中安裝 TFLearn：
```py
pip3 install tflearn
```
要在其他環境或源中安裝 TFLearn，請參閱[此鏈接](http://tflearn.org/installation/)。
TFLearn 中的簡單工作流程如下：
1. 首先創建一個輸入層。
2. 傳遞輸入對象以創建更多層。
3. 添加輸出層。
4. 使用估計器層（例如`regression`）創建網絡。
5. 從上一步中創建的網絡創建模型。
6. 使用`model.fit()`方法訓練模型。
7. 使用訓練的模型進行預測或評估。
# 創建 TFLearn 層
讓我們學習如何在 TFLearn 中創建神經網絡模型的層：
1. 首先創建一個輸入層：
```py
input_layer = tflearn.input_data(shape=[None,num_inputs]
```
1. 傳遞輸入對象以創建更多層：
```py
layer1 = tflearn.fully_connected(input_layer,10,
activation='relu')
layer2 = tflearn.fully_connected(layer1,10,
activation='relu')
```
1. 添加輸出層：
```py
output = tflearn.fully_connected(layer2,n_classes,
activation='softmax')
```
1. 從估計器層創建最終網絡，例如`regression`：
```py
net = tflearn.regression(output,
optimizer='adam',
metric=tflearn.metrics.Accuracy(),
loss='categorical_crossentropy'
)
```
TFLearn 為以下子部分中描述的層提供了幾個類。
# TFLearn 核心層
TFLearn 在`tflearn.layers.core`模塊中提供以下層：
| 層類 | 描述 |
| --- | --- |
| `input_data` | 該層用于指定神經網絡的輸入層。 |
| `fully_connected` | 該層用于指定一個層，其中所有神經元都連接到前一層中的所有神經元。 |
| `dropout` | 該層用于指定丟棄正則化。輸入元素由`1/keep_prob`縮放，同時保持預期的總和不變。 |
| `custom_layer` | 此層用于指定要應用于輸入的自定義函數。此類包裝我們的自定義函數并將該函數顯示為層。 |
| `reshape` | 此層將輸入重新整形為指定形狀的輸出。 |
| `flatten` | 該層將輸入張量轉換為 2D 張量。 |
| `activation` | 該層將指定的激活函數應用于輸入張量。 |
| `single_unit` | 該層將線性函數應用于輸入。 |
| `highway` | 該層實現了完全連接的公路函數。 |
| `one_hot_encoding` | 此層將數字標簽轉換為二元向量單熱編碼表示。 |
| `time_distributed` | 該層將指定的函數應用于輸入張量的每個時間步長。 |
| `multi_target_data` | 此層創建并連接多個占位符，特別是在層使用來自多個源的目標時使用。 |
# TFLearn 卷積層
TFLearn 在`tflearn.layers.conv`模塊中提供以下層：
| 層類 | 描述 |
| --- | --- |
| `conv_1d` | 該層將 1D 卷積應用于輸入數據 |
| `conv_2d` | 該層將 2D 卷積應用于輸入數據 |
| `conv_3d` | 該層將 3D 卷積應用于輸入數據 |
| `conv_2d_transpose` | 該層將`conv2_d`的轉置應用于輸入數據 |
| `conv_3d_transpose` | 該層將`conv3_d`的轉置應用于輸入數據 |
| `atrous_conv_2d` | 該層計算二維動態卷積 |
| `grouped_conv_2d` | 該層計算深度 2D 卷積 |
| `max_pool_1d` | 該層計算 1D 最大池化 |
| `max_pool_2d` | 該層計算 2D 最大池化 |
| `avg_pool_1d` | 該層計算 1D 平均池化 |
| `avg_pool_2d` | 該層計算 2D 平均池化 |
| `upsample_2d` | 該層應用行和列 2D 重復操作 |
| `upscore_layer` | 該層實現了[這個頁面](http://arxiv.org/abs/1411.4038)中規定的最高分。 |
| `global_max_pool` | 該層實現全局最大池化操作 |
| `global_avg_pool` | 該層實現全局平均池化操作 |
| `residual_block` | 該層實現殘差塊以創建深度殘差網絡 |
| `residual_bottleneck` | 該層實現深度殘差網絡的殘差瓶頸塊 |
| `resnext_block` | 該層實現 ResNext 塊 |
# TFLearn 循環層
TFLearn 在`tflearn.layers.recurrent`模塊中提供以下層：
| 層類 | 描述 |
| --- | --- |
| `simple_rnn` | 該層實現了簡單的循環神經網絡模型 |
| `bidirectional_rnn` | 該層實現雙向 RNN 模型 |
| `lstm` | 該層實現了 LSTM 模型 |
| `gru` | 該層實現 GRU 模型 |
# TFLearn 正則化層
TFLearn 在`tflearn.layers.normalization`模塊中提供以下層：
| 層類 | 描述 |
| --- | --- |
| `batch_normalization` | 該層正則化每個批次的先前層激活的輸出 |
| `local_response_normalization` | 該層實現 LR 正則化 |
| `l2_normalization` | 該層將 L2 歸一化應用于輸入張量 |
# TFLearn 嵌入層
TFLearn 在`tflearn.layers.embedding_ops`模塊中只提供一層：
| 層類 | 描述 |
| --- | --- |
| `embedding` | 該層實現整數 ID 或浮點序列的嵌入函數 |
# TFLearn 合并層
TFLearn 在`tflearn.layers.merge_ops`模塊中提供以下層：
| 層類 | 描述 |
| --- | --- |
| `merge_outputs` | 該層將張量列表合并為單個張量，通常用于合并相同形狀的輸出張量 |
| `merge` | 該層將張量列表合并為單個張量；您可以指定需要進行合并的軸 |
# TFLearn 估計層
TFLearn 在`tflearn.layers.estimator`模塊中只提供一層：
| 層類 | 描述 |
| --- | --- |
| `regression` | 該層實現線性或邏輯回歸 |
在創建回歸層時，您可以指定優化器以及損失和度量函數。
TFLearn 在`tflearn.optimizers`模塊中提供以下優化器函數作為類：
* `SGD`
* `RMSprop`
* `Adam`
* `Momentum`
* ``AdaGrad``
* `Ftrl`
* `AdaDelta`
* `ProximalAdaGrad`
* `Nesterov`
您可以通過擴展`tflearn.optimizers.Optimizer`基類來創建自定義優化器。
TFLearn 在`tflearn.metrics`模塊中提供以下度量函數作為類或操作：
* `Accuracy`或`accuracy_op`
* `Top_k`或`top_k_op`
* `R2`或`r2_op`
* `WeightedR2`或`weighted_r2_op`
* `binary_accuracy_op`
您可以通過擴展`tflearn.metrics.Metric`基類來創建自定義指標。
TFLearn 在`tflearn.objectives`模塊中提供以下損失函數，稱為目標：
* `softymax_categorical_crossentropy`
* `categorical_crossentropy`
* `binary_crossentropy`
* `weighted_crossentropy`
* `mean_square`
* `hinge_loss`
* `roc_auc_score`
* `weak_cross_entropy_2d`
在指定輸入，隱藏和輸出層時，您可以指定要應用于輸出的激活函數。 TFLearn 在`tflearn.activations`模塊中提供以下激活函數：
* `linear`
* `tanh`
* `sigmoid`
* `softmax`
* `softplus`
* `softsign`
* `relu`
* `relu6`
* `leaky_relu`
* `prelu`
* `elu`
* `crelu`
* `selu`
# 創建 TFLearn 模型
從上一步創建的網絡創建模型（創建 TFLearn 層部分的步驟 4）：
```py
model = tflearn.DNN(net)
```
# TFLearn 模型的類型
TFLearn 提供兩種不同的模型：
* `DNN`（深度神經網絡）模型：此類允許您從通過層創建的網絡創建多層感知機
* `SequenceGenerator`模型：該類允許您創建可以生成序列的深度神經網絡
# 訓練 TFLearn 模型
創建后，使用`model.fit()`方法訓練模型：
```py
model.fit(X_train,
Y_train,
n_epoch=n_epochs,
batch_size=batch_size,
show_metric=True,
run_id='dense_model')
```
# 使用 TFLearn 模型
使用訓練的模型預測或評估：
```py
score = model.evaluate(X_test, Y_test)
print('Test accuracy:', score[0])
```
筆記本`ch-02_TF_High_Level_Libraries`中提供了 TFLearn MNIST 分類示例的完整代碼。 TFLearn MNIST 示例的輸出如下：
```py
Training Step: 5499 | total loss: 0.42119 | time: 1.817s
| Adam | epoch: 010 | loss: 0.42119 - acc: 0.8860 -- iter: 54900/55000
Training Step: 5500 | total loss: 0.40881 | time: 1.820s
| Adam | epoch: 010 | loss: 0.40881 - acc: 0.8854 -- iter: 55000/55000
--
Test accuracy: 0.9029
```
[您可以從此鏈接獲得有關 TFLearn 的更多信息](http://tflearn.org/)。
# PrettyTensor
PrettyTensor 在 TensorFlow 上提供了一個薄包裝器。 PrettyTensor 提供的對象支持可鏈接的語法來定義神經網絡。例如，可以通過鏈接層來創建模型，如以下代碼所示：
```py
model = (X.
flatten().
fully_connected(10).
softmax_classifier(n_classes, labels=Y))
```
可以使用以下命令在 Python 3 中安裝 PrettyTensor：
```py
pip3 install prettytensor
```
PrettyTensor 以名為`apply()`的方法提供了一個非常輕量級和可擴展的接口。可以使用`.apply(function, arguments)`方法將任何附加函數鏈接到 PrettyTensor 對象。 PrettyTensor 將調用`function`并提供當前張量作為`function`的第一個參數。
用戶創建的函數可以使用`@prettytensor.register`裝飾器來裝飾。[詳細信息在這里](https://github.com/google/prettytensor)。
在 PrettyTensor 中定義和訓練模型的工作流程如下：
1. 獲取數據。
2. 定義超參數和參數。
3. 定義輸入和輸出。
4. 定義模型。
5. 定義評估器，優化器和訓練器函數。
6. 創建運行器對象。
7. 在 TensorFlow 會話中，使用`runner.train_model()`方法訓練模型。
8. 在同一會話中，使用`runner.evaluate_model()`方法評估模型。
筆記本`ch-02_TF_High_Level_Libraries`中提供了 PrettyTensor MNIST 分類示例的完整代碼。 PrettyTensor MNIST 示例的輸出如下：
```py
[1] [2.5561881]
[600] [0.3553167]
Accuracy after 1 epochs 0.8799999952316284
[601] [0.47775066]
[1200] [0.34739292]
Accuracy after 2 epochs 0.8999999761581421
[1201] [0.19110668]
[1800] [0.17418651]
Accuracy after 3 epochs 0.8999999761581421
[1801] [0.27229539]
[2400] [0.34908807]
Accuracy after 4 epochs 0.8700000047683716
[2401] [0.40000191]
[3000] [0.30816519]
Accuracy after 5 epochs 0.8999999761581421
[3001] [0.29905257]
[3600] [0.41590339]
Accuracy after 6 epochs 0.8899999856948853
[3601] [0.32594997]
[4200] [0.36930788]
Accuracy after 7 epochs 0.8899999856948853
[4201] [0.26780865]
[4800] [0.2911002]
Accuracy after 8 epochs 0.8899999856948853
[4801] [0.36304188]
[5400] [0.39880857]
Accuracy after 9 epochs 0.8999999761581421
[5401] [0.1339224]
[6000] [0.14993289]
Accuracy after 10 epochs 0.8899999856948853
```
# Sonnet
Sonnet 是一個用 Python 編寫的面向對象的庫。它是由 DeepMind 在 2017 年發布的。Sonnet 打算從對象中清晰地分離構建計算圖的以下兩個方面：
* 稱為模塊的對象的配置
* 對象與計算圖的連接
可以使用以下命令在 Python3 中安裝 Sonnet：
```py
pip3 install dm-sonnet
```
[可以按照此鏈接的說明從源安裝 Sonnet](https://github.com/deepmind/sonnet/blob/master/docs/INSTALL.md)。
模塊被定義為抽象類`sonnet.AbstractModule`的子類。在編寫本書時，Sonnet 中提供了以下模塊：
| 基本模塊 | `AddBias`，`BatchApply`，`BatchFlatten`，`BatchReshape`，`FlattenTrailingDimensions`，`Linear`，`MergeDims`，`SelectInput`，`SliceByDim`，`TileByDim`和`TrainableVariable` |
| --- | --- |
| 循環模塊 | `DeepRNN`，`ModelRNN`，`VanillaRNN`，`BatchNormLSTM`，`GRU`和`LSTM` |
| Recurrent + ConvNet 模塊 | `Conv1DLSTM`和`Conv2DLSTM` |
| ConvNet 模塊 | `Conv1D`，`Conv2D`，`Conv3D`，`Conv1DTranspose`，`Conv2DTranspose`，`Conv3DTranspose`，`DepthWiseConv2D`，`InPlaneConv2D`和`SeparableConv2D` |
| ResidualNets | `Residual`，`ResidualCore`和`SkipConnectionCore` |
| 其他 | `BatchNorm`，`LayerNorm`，`clip_gradient`和`scale_gradient` |
我們可以通過創建`sonnet.AbstractModule`的子類來定義我們自己的新模塊。從函數創建模塊的另一種非推薦方法是通過傳遞要包裝為模塊的函數來創建`sonnet.Module`類的對象。
在 Sonnet 庫中構建模型的工作流程如下：
1. 為從`sonnet.AbstractModule`繼承的數據集和網絡架構創建類。在我們的示例中，我們創建了一個 MNIST 類和一個 MLP 類。
2. 定義參數和超參數。
3. 從上一步中定義的數據集類定義測試和訓練數據集。
4. 使用定義的網絡類定義模型。例如，在我們的案例中，`model = MLP([20, n_classes])`創建了一個 MLP 網絡，其中包含兩層 20 和每個神經元`n_classes`的數量。
5. 使用模型為訓練和測試集定義`y_hat`占位符。
1. 定義訓練和測試集的損失占位符。
2. 使用訓練損失占位符定義優化器。
3. 在 TensorFlow 會話中執行所需數量的周期的損失函數以優化參數。
筆記本電腦`ch-02_TF_High_Level_Libraries`中提供了 Sonnet MNIST 分類示例的完整代碼。 每個類中的`__init__`方法初始化類和相關的超類。`_build`方法在調用類時創建并返回數據集或模型對象。 Sonnet MNIST 示例的輸出如下：
```py
Epoch : 0 Training Loss : 236.79913330078125
Epoch : 1 Training Loss : 227.3693084716797
Epoch : 2 Training Loss : 221.96337890625
Epoch : 3 Training Loss : 220.99142456054688
Epoch : 4 Training Loss : 215.5921173095703
Epoch : 5 Training Loss : 213.88958740234375
Epoch : 6 Training Loss : 203.7091064453125
Epoch : 7 Training Loss : 204.57427978515625
Epoch : 8 Training Loss : 196.17218017578125
Epoch : 9 Training Loss : 192.3954315185547
Test loss : 192.8847198486328
```
由于神經網絡中計算的隨機性，您的輸出可能會有所不同。這包括我們對 Sonnet 模塊的概述。
[有關 Sonnet 的更多詳細信息，您可以瀏覽此鏈接](https://deepmind.github.io/sonnet/)。
# 總結
在本章中，我們瀏覽了一些構建在 TensorFlow 之上的高級庫。我們了解了 TFEstimator，TFSlim，TFLearn，PrettyTensor 和 Sonnet。我們為所有五個實現了 MNIST 分類示例。如果您無法理解模型的細節，請不要擔心，因為為 MNIST 示例構建的模型將在以下章節中再次介紹。
我們總結了下表中提供的庫和框架，如下表所示：
| 高級庫 | 文檔鏈接 | 源代碼鏈接 | PIP3 安裝包 |
| --- | --- | --- | --- |
| TFEstimator | <https://www.tensorflow.org/get_started/estimator> | <https://github.com/tensorflow/tensorflow/tree/master/tensorflow/python/estimator> | TensorFlow 預置 |
| TFSlim | <https://github.com/tensorflow/tensorflow/tree/r1.4/tensorflow/contrib/slim> | <https://github.com/tensorflow/tensorflow/tree/r1.4/tensorflow/contrib/slim/python/slim> | TensorFlow 預置 |
| TFLearn | <http://tflearn.org/> | <https://github.com/tflearn/tflearn> | `tflearn` |
| PrettyTensor | <https://github.com/google/prettytensor/tree/master/docs> | <https://github.com/google/prettytensor> | `prettytensor` |
| Sonnet | <https://deepmind.github.io/sonnet/> | <https://github.com/deepmind/sonnet> | `dm-sonnet` |
在下一章中，我們將了解 Keras，這是用于創建和訓練 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
- 六、自編碼器，變分自編碼器和生成對抗網絡
- 七、遷移學習
- 八、機器學習最佳實踐和故障排除
- 九、大規模訓練
- 十、參考文獻