# 二、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
- 六、自编码器，变分自编码器和生成对抗网络
- 七、迁移学习
- 八、机器学习最佳实践和故障排除
- 九、大规模训练
- 十、参考文献