Python 深度学习应用指南（一）

原文：Deep Learning with Applications Using Python

协议：CC BY-NC-SA 4.0

一、TensorFlow 基础

本章涵盖深度学习框架 TensorFlow 的基础知识。深度学习在模式识别方面做得非常好，特别是在图像、声音、语音、语言和时序数据的背景下。在深度学习的帮助下，你可以分类、预测、聚类和提取特征。好在 2015 年 11 月，谷歌发布了 TensorFlow，已经在谷歌搜索、垃圾邮件检测、语音识别、谷歌助手、Google Now、Google Photos 等谷歌大部分产品中使用。本章的目的是解释 TensorFlow 的基本组成部分。

TensorFlow 具有执行部分子图计算的独特能力，从而允许在划分神经网络的帮助下进行分布式训练。换句话说，TensorFlow 允许模型并行和数据并行。TensorFlow 提供了多个 API。最低级别的 API—tensor flow Core—为您提供完整的编程控制。

关于 TensorFlow，请注意以下要点:

• 它的图表是对计算的描述。
• 它的图有节点是操作。
• 它在给定的会话上下文中执行计算。
• 对于任何计算，必须在会话中启动图形。
• 会话将图形操作放到 CPU 和 GPU 等设备上。
• 会话提供了执行图形操作的方法。

请前往 https://www.tensorflow.org/install/ 进行安装。

我将讨论以下主题:

张量

在进入 TensorFlow 库之前，让我们先熟悉一下 TensorFlow 中的基本数据单位。张量是一个数学对象，是标量、向量和矩阵的概括。张量可以表示为多维数组。零阶张量只不过是一个标量。向量/数组是秩为 1 的张量，而矩阵是秩为 2 的张量。简而言之，张量可以认为是一个 n 维数组。

下面是一些张量的例子:

• 5:这是一个秩为 0 的张量；这是一个形状为[ ]的标量。
• [2.,5., 3.]:这是一个秩为 1 的张量；这是一个形状为[3]的矢量。
• [[1., 2., 7.], [3., 5., 4.]]:这是一个秩 2 张量；它是一个形状为[2, 3]的矩阵。
• [[[1., 2., 3.]], [[7., 8., 9.]]]:这是一个形状为[2, 1, 3]的秩为 3 的张量。

计算图形和会话

TensorFlow 因其 TensorFlow 核心程序而广受欢迎，该程序有两个主要动作。

• 在构建阶段构建计算图
• 在执行阶段运行计算图

我们来了解一下 TensorFlow 是如何工作的。

• 它的程序通常分为构建阶段和执行阶段。
• 构建阶段组装一个有节点(ops/operations)和边(tensors)的图。
• 执行阶段使用一个会话来执行图中的操作。
• 最简单的操作是一个常数，它不接受输入，但将输出传递给其他进行计算的操作。
• 运算的一个例子是乘法(或加法或减法，将两个矩阵作为输入，并将一个矩阵作为输出)。
• TensorFlow 库有一个默认图形，ops 构造函数会向其中添加节点。

因此，TensorFlow 程序的结构有两个阶段，如下所示:

计算图是排列成节点图的一系列 TensorFlow 运算。

让我们看看 TensorFlow 对 Numpy。在 Numpy 中，如果你计划乘两个矩阵，你创建矩阵并乘它们。但是在 TensorFlow 中，你设置了一个图(默认的图，除非你创建另一个图)。接下来，您需要创建变量、占位符和常量值，然后创建会话并初始化变量。最后，将数据输入占位符，以便调用任何操作。

要实际评估节点，您必须在会话中运行计算图。

会话封装了 TensorFlow 运行时的控制和状态。

下面的代码创建了一个Session对象:

sess = tf.Session()

然后，它调用 run 方法运行足够的计算图来计算 node1 和 node2。

计算图定义了计算。它既不计算任何东西，也不保存任何值。它旨在定义代码中提到的操作。将创建一个默认图表。所以，你不需要创建它，除非你想创建多用途的图表。

会话允许您执行图形或部分图形。它为执行分配资源(在一个或多个 CPU 或 GPU 上)。它保存中间结果和变量的实际值。

在 TensorFlow 中创建的变量值仅在一个会话中有效。如果您稍后在第二个会话中尝试查询该值，TensorFlow 将会引发一个错误，因为该变量没有在那里初始化。

要运行任何操作，您需要为该图创建一个会话。会话还将分配内存来存储变量的当前值

下面是演示的代码:

常量、占位符和变量

TensorFlow 程序使用张量数据结构来表示所有数据，在计算图中的操作之间只传递张量。可以把 TensorFlow 张量想象成一个 n 维数组或列表。张量有静态类型、秩和形状。这里，图形产生一个恒定的结果。变量在图的执行过程中保持状态。

深度学习一般要处理很多图像，所以要为每张图像放置像素值，对所有图像不断迭代。

要训练模型，您需要能够修改图形来调整一些对象，如权重和偏差。简而言之，变量使您能够将可训练参数添加到图形中。它们是用类型和初始值构造的。

让我们在 TensorFlow 中创建一个常量并打印出来。

下面是对前面代码的简单解释:

1. 导入tensorflow模块，将其命名为tf。
2. 创建一个常数值(x)，并将其赋值为数值 12。
3. 创建一个用于计算值的会话。
4. 只运行变量x并打印出其当前值。

前两步属于构建阶段，后两步属于执行阶段。我现在将讨论 TensorFlow 的构建和执行阶段。

您可以用另一种方式重写前面的代码，如下所示:

现在您将探索如何创建一个变量并初始化它。下面是实现这一点的代码:

下面是对前面代码的解释:

1. 导入tensorflow模块，将其命名为tf。
2. 创建一个名为x的常量值，并赋予其数值 12。
3. 创建一个名为y的变量，并将其定义为等式 12+11。
4. 用tf.global_variables_initializer()初始化变量。
5. 创建一个用于计算值的会话。
6. 运行步骤 4 中创建的模型。
7. 只运行变量y并打印出其当前值。

这里有更多的代码供您阅读:

占位符

占位符是一个变量，您可以在以后向其输入内容。它意味着接受外部输入。占位符可以有一维或多维，用于存储 n 维数组。

下面是对前面代码的解释:

1. 导入tensorflow模块，将其命名为tf。
2. 创建一个名为x的占位符，提及float类型。
3. 创建一个名为y的张量，它是将x乘以 10 再加上 500 的运算。注意，x的任何初始值都没有定义。
4. 创建一个用于计算值的会话。
5. 定义feed_dict中x的值，以便运行y。
6. 打印出它的值。

在下面的示例中，您创建了一个 2×4 矩阵(2D 数组)来存储一些数字。然后，使用与前面相同的操作，按元素乘以 10 并加 1。占位符的第一个维度是None，这意味着允许任意数量的行。

你也可以考虑用 2D 数组代替 1D 数组。代码如下:

这是一个 2×4 矩阵。所以，如果用 2 代替None，可以看到同样的输出。

但是，如果您创建了一个[3, 4]形状的占位符(注意，您将在稍后填充一个 2×4 的矩阵)，就会出现错误，如下所示:

################# What happens in a linear model ##########
# Weight and Bias as Variables as they are to be tuned
W = tf.Variable([2], dtype=tf.float32)
b = tf.Variable([3], dtype=tf.float32)
# Training dataset that will be fed while training as Placeholders

x = tf.placeholder(tf.float32)
# Linear Model
y = W * x + b

常数在你调用tf.constant时被初始化，它们的值永远不能改变。相比之下，当您调用tf.Variable时，变量不会被初始化。要初始化 TensorFlow 程序中的所有变量，必须显式调用一个特殊操作，如下所示。

重要的是要认识到init是初始化所有全局变量的 TensorFlow 子图的句柄。在调用sess.run之前，变量是未初始化的。

创建张量

图像是三阶张量，其中维度属于高度、宽度和通道数(红色、蓝色和绿色)。

这里你可以看到图像是如何转换成张量的:

您可以生成各种类型的张量，如固定张量、随机张量和顺序张量。

固定张量

这里有一个固定的张量:

tf:.fill创建一个具有唯一数字的形状张量(2×3)。

tf.diag创建一个具有指定对角元素的对角矩阵。

tf.constant创建一个常量张量。

序列张量

tf.range创建从指定值开始并具有指定增量的数字序列。

tf.linspace创建一个等距值序列。

随机张量

tf.random_uniform从一个范围内的均匀分布中生成随机值。

tf.random_normal根据具有指定平均值和标准偏差的正态分布生成随机值。

你能猜出结果吗？

如果你找不到结果，请修改之前我讨论张量创建的部分。

您可以在这里看到结果:

处理矩阵

一旦你习惯了创建张量，你就可以享受处理矩阵的乐趣了(2D 张量)。

激活功能

激活函数的想法来自于对人类大脑中神经元如何工作的分析(见图 1-1 )。神经元在超过某个阈值后变得活跃，这个阈值更好地被称为激活电位。在大多数情况下，它还试图将输出放在一个小范围内。

Sigmoid、双曲正切(tanh)、ReLU 和 eLU 是最流行的激活函数。

我们来看看现在比较流行的激活功能。

正切双曲线和 Sigmoid

图 1-2 显示了正切双曲线和 sigmoid 激活函数。

图 1-2

Two popular activation functions

图 1-1

An activation function

下面是演示代码:

ReLU 和 eLU

图 1-3 显示了 ReLU 和 eLU 功能。

图 1-3

The ReLU and ELU functions

下面是生成这些函数的代码:

ReLU6

ReLU6 类似于 ReLU，只是输出不能超过 6。

请注意，tanh 是一个重新调整的逻辑 sigmoid 函数。

损失函数

损失函数(成本函数)将被最小化，以便获得模型的每个参数的最佳值。例如，您需要获得权重(斜率)和偏差(y 截距)的最佳值，以便根据预测值(X)来解释目标(y)。方法是实现斜率的最佳值，y 截距是最小化代价函数/损失函数/平方和。对于任何模型，都有许多参数，并且预测或分类中的模型结构是用参数值来表示的。

你需要评估你的模型，为此你需要定义成本函数(损失函数)。损失函数的最小化可以是找到每个参数的最佳值的驱动力。对于回归/数值预测，L1 或 L2 可能是有用的损失函数。对于分类，交叉熵可以是有用的损失函数。Softmax 或 sigmoid 交叉熵可以是相当流行的损失函数。

损失函数示例

下面是演示的代码:

常见损失函数

以下是最常见的损失函数列表:

| `tf.contrib.losses.absolute_difference` | | `tf.contrib.losses.add_loss` | | `tf.contrib.losses.hinge_loss` | | `tf.contrib.losses.compute_weighted_loss` | | `tf.contrib.losses.cosine_distance` | | `tf.contrib.losses.get_losses` | | `tf.contrib.losses.get_regularization_losses` | | `tf.contrib.losses.get_total_loss` | | `tf.contrib.losses.log_loss` | | `tf.contrib.losses.mean_pairwise_squared_error` | | `tf.contrib.losses.mean_squared_error` | | `tf.contrib.losses.sigmoid_cross_entropy` | | `tf.contrib.losses.softmax_cross_entropy` | | `tf.contrib.losses.sparse_softmax_cross_entropy` | | `tf.contrib.losses.log(predictions,labels,weight=2.0)` |

优化者

现在你应该确信你需要使用一个损失函数来获得模型的每个参数的最佳值。如何才能获得最佳价值？

最初，您假设模型的权重和偏差的初始值(线性回归等)。).现在你需要找到达到参数最佳值的方法。优化器是达到参数最佳值的方法。在每次迭代中，该值都按照优化器建议的方向变化。假设你有 16 个权重值(w1、w2、w3、…、w16)和 4 个偏差(b1、b2、b3、b4)。最初，你可以假设每一个权重和偏差都是零(或者一或任何数字)。优化器建议w1(和其他参数)是否应该在下一次迭代中增加或减少，同时牢记最小化的目标。经过多次迭代后，w1(以及其他参数)将稳定到参数的最佳值。

换句话说，TensorFlow 和其他每一个深度学习框架都提供了优化器，这些优化器缓慢地改变每个参数，以便最小化损失函数。优化器的目的是为下一次迭代中的变化给出权重和偏差的方向。假设你有 64 个权重和 16 个偏差；您尝试在每次迭代(反向传播期间)中改变权重和偏差值，以便在多次迭代后获得正确的权重和偏差值，同时尝试最小化损失函数。

为模型选择最佳优化器以快速收敛并正确学习权重和偏差是一项棘手的任务。

适应性技术(adadelta、adagrad 等。)对于复杂的神经网络收敛更快是很好的优化器。Adam 被认为是大多数情况下的最佳优化器。它也优于其他自适应技术(adadelta、adagrad 等)。)，但是计算量很大。对于稀疏数据集，SGD、NAG、momentum 等方法不是最佳选择；自适应学习率方法有。一个额外的好处是，你不需要调整学习率，但可以用默认值达到最佳效果。

损失函数示例

下面是演示的代码:

常见优化器

以下是常见优化器的列表:

韵律学

学了一些建立模型的方法，是时候评估模型了。所以，你需要评估回归器或分类器。

评价指标有很多，其中分类准确率、对数损失、ROC 曲线下面积是最受欢迎的。

分类准确度是正确预测数与所有预测数的比率。当每个类别的观察值没有太大偏差时，精确度可以被认为是一个很好的度量。

tf.contrib.metrics.accuracy(actual_labels, predictions)

还有其他评估指标。

指标示例

本节展示了要演示的代码。

在这里，您创建实际值(称为x)和预测值(称为y)。然后你检查准确性。准确度表示实际值等于预测值的次数与实例总数的比率。

通用指标

以下是常见指标的列表:

二、了解和使用 Keras

Keras 是一个简洁易学的深度学习高级 Python 库，可以运行在 TensorFlow(或者 Theano 或者 CNTK)之上。它允许开发人员专注于深度学习的主要概念，例如为神经网络创建层，同时关注张量的本质细节、形状和数学细节。TensorFlow(或 Theano 或 CNTK)必须是 Keras 的后端。可以使用 Keras 进行深度学习应用，而不需要与相对复杂的 TensorFlow(或者 Theano 或者 CNTK)进行交互。有两种主要的框架:顺序 API 和功能 API。顺序 API 基于一系列层的思想；这是 Keras 最常见的用法，也是 Keras 最容易的部分。顺序模型可以被认为是层的线性堆叠。

简而言之，您可以创建一个顺序模型，在这个模型中，您可以轻松地添加层，并且每个层都可以有卷积、最大池化、激活、退出和批处理规范化。让我们来看看在 Keras 中开发深度学习模型的主要步骤。

深度学习模型的主要步骤

Keras 中深度学习模型的四个核心部分如下:

1. 定义模型。在这里，您创建一个顺序模型并添加层。每一层可以包含一个或多个卷积、汇集、批量标准化和激活功能。
2. 编译模型。在这里，您在模型上调用compile()函数之前应用损失函数和优化器。
3. 用训练数据拟合模型。在这里，您通过调用模型上的fit()函数来训练测试数据上的模型。
4. 做预测。在这里，您通过调用函数(如evaluate()和predict())来使用模型生成对新数据的预测。

Keras 的深度学习流程有八个步骤:

1. 加载数据。
2. 预处理数据。
3. 定义模型。
4. 编译模型。
5. 符合模型。
6. 评估模型。
7. 做出预测。
8. 保存模型。

加载数据

以下是加载数据的方式:

预处理数据

以下是预处理数据的方法:

定义模型

Keras 中的顺序模型被定义为一系列层。创建一个顺序模型，然后添加层。您需要确保输入图层具有正确的输入数量。假设你有 3072 个输入变量；然后你需要创建第一个有 512 个节点/神经元的隐藏层。在第二个隐藏层，你有 120 个节点/神经元。最后，输出层中有十个节点。例如，一幅图像映射到十个节点上，显示了被标记为 1(飞机)、2(汽车)、3(猫)、…、10(卡车)的概率。概率最高的节点是预测的类别/标签。

一幅图像有三个通道(RGB)，在每个通道中，图像有 32×32 = 1024 个像素。因此，每个图像有 3×1024 = 3072 个像素(特征/X/输入)。

在 3072 个特征的帮助下，你需要预测标签 1(数字 0)、标签 2(数字 1)等等的概率。这意味着模型预测十个输出(数字 0-9)，其中每个输出代表相应标签的概率。最后一个激活函数(sigmoid，如前所示)为 9 个输出提供 0，仅为 1 个输出提供 1。该标签是图像的预测类别(图 2-1 )。

例如，3072 功能➤ 512 节点➤ 120 节点➤ 10 节点。

图 2-1

Defining the model

下一个问题是，你如何知道要使用的层数和它们的类型？没有人有确切的答案。对于评估指标来说，最好的是确定最佳层数以及每层中的参数和步骤。还使用了启发式方法。通过反复试验的过程找到最佳的网络结构。一般来说，你需要一个足够大的网络来捕捉问题的结构。

在本例中，您将使用三层全连接网络结构。密集类定义完全连接的层。

在这种情况下，将网络权重初始化为从均匀分布(均匀)生成的小随机数(在这种情况下介于 0 和 0.05 之间)，因为这是 Keras 中默认的均匀权重初始化。另一个传统的选择是从高斯分布产生的小随机数的常态。您可以使用或捕捉任一类的硬分类，默认阈值为 0.5。你可以通过添加每一层把它们拼凑在一起。

编译模型

按照层定义了模型之后，您需要声明损失函数、优化器和评估指标。当提出模型时，初始权重和偏差值被假定为 0 或 1、随机正态分布数或任何其他方便的数。但是初始值并不是模型的最佳值。这意味着权重和偏差的初始值不能解释预测值(x)方面的目标/标签。所以，你想得到模型的最优值。从初始值到最优值的旅程需要一个动机，这个动机将最小化成本函数/损失函数。旅程需要一个路径(每次迭代中的变化)，这是优化器建议的。这个旅程也需要一个评估测量，或者评估度量。

流行的损失函数是二元交叉熵、分类交叉熵、均方对数误差和铰链损失。流行的优化器是随机梯度下降(SGD)、RMSProp、adam、adagrad 和 adadelta。流行的评估指标是准确性、召回率和 F1 分数。

简而言之，这一步的目的是基于损失函数，通过基于优化器的迭代来调整权重和偏差，优化器由诸如准确性之类的度量来评估。

符合模型

定义并编译了模型之后，您需要通过对一些数据执行模型来做出预测。这里您需要指定纪元；这些是训练过程运行数据集的迭代次数和批量大小，批量大小是在权重更新之前评估的实例数量。对于这个问题，该程序将运行少量的时段(10)，并且在每个时段中，它将完成 50 次(=50，000/1，000)迭代，其中批量大小为 1，000，训练数据集具有 50，000 个实例/图像。同样，没有选择批量大小的硬性规定。但是它不应该非常小，并且应该比训练数据集的大小小得多，以消耗更少的内存。

评估模型

在训练数据集上训练了神经网络之后，您需要评估网络的性能。请注意，这只能让您了解对数据集建模的效果(例如，训练精度)，但您不知道该算法对新数据的执行效果如何。这是为了简单起见，但理想情况下，您可以将数据分为训练和测试数据集，用于模型的训练和评估。您可以使用模型上的evaluation()函数在您的训练数据集上评估您的模型，并将用于训练模型的相同输入和输出传递给它。这将为每个输入和输出对生成一个预测，并收集分数，包括平均损失和您已配置的任何度量，如准确性。

预报

一旦建立并评估了模型，就需要对未知数据进行预测。

保存并重新加载模型

这是最后一步:

可选:总结模型

现在来看如何总结模型。

改进 Keras 模型的其他步骤

以下是改进模型的更多步骤:

1. Sometimes, the model building process does not complete because of a vanishing or exploding gradient. If this is the case, you should do the following:

   

2. 对输出形状建模。

   #Shape of the n-dim array (output of the model at the current position)
   
     model.output_shape
   
   

3. 对摘要表示进行建模。

   model.summary()
   
   

4. 对配置建模。

   model.get_config()
   
   

5. 列出模型中所有的重量张量。

   model.get_weights()
   
   

在这里，我分享了 Keras 模型的完整代码。你能试着解释一下吗？

使用 TensorFlow 很难

Keras 通过利用 TensorFlow/Theano 之上强大而清晰的深度学习库来提供高级神经网络。Keras 是 TensorFlow 的一个很好的补充，因为它的层和模型与纯 TensorFlow 张量兼容。此外，它可以与其他 TensorFlow 库一起使用。

以下是将 Keras 用于 TensorFlow 的步骤:

1. 首先创建一个 TensorFlow 会话，并将其注册到 Keras。这意味着 Keras 将使用您注册的会话来初始化它在内部创建的所有变量。

   import TensorFlow as tf
   
   sess = tf.Session()
   
   from keras import backend as K
   
   K.set_session(sess)
   
   

2. Keras 模块(如模型、层和激活)用于构建模型。Keras 引擎自动将这些模块转换成等价于 TensorFlow 的脚本。

3. 除了 TensorFlow，Theano 和 CNTK 可以用作 Keras 的后端。

4. TensorFlow 后端具有按照深度、高度、宽度顺序制作输入形状(到网络的第一层)的惯例，其中深度可以表示通道的数量。

5. 您需要正确配置keras.json文件，以便它使用 TensorFlow 后端。它应该是这样的:

   {
   
          "backend": "theano",
   
          "epsilon": 1e-07,
   
          "image_data_format": "channels_first",
   
          "floatx": "float32"
   
   }
   
   

在接下来的章节中，您将学习如何利用 Keras 在 CNN、RNN、LSTM 和其他深度学习活动中工作。

三、多层感知器

在开始学习多层感知器之前，你需要对人工神经网络有一个大致的了解。这就是我在这一章要开始讲的。

人工神经网络

人工神经网络(ANN)是一种受生物神经网络启发的计算网络(节点和节点之间的互连系统)，生物神经网络是人脑中神经元的复杂网络(见图 3-1 )。人工神经网络中创建的节点应该被编程为像实际神经元一样的行为，因此它们是人工神经元。图 3-1 显示了构成人工神经网络的节点(人工神经元)的网络。

图 3-1

Artificial neural network

层数和每层的神经元/节点数可以是人工神经网络的主要结构组成部分。最初，权重(代表互连)和偏差不足以做出决定(分类等)。).它就像一个没有任何经验的婴儿的大脑。婴儿从经验中学习，以便成为一个好的决策者(分类者)。经验/数据(标记)帮助大脑的神经网络调整(神经)权重和偏差。人工神经网络经历相同的过程。每次迭代调整权重以创建好的分类器。由于手动调整数千个神经元的权重非常耗时，因此需要使用算法来完成这些任务。

调整权重的过程被称为学习或训练。这和人类日常所做的是一样的。我们试图让计算机像人类一样工作。

让我们开始探索最简单的人工神经网络模型。

典型的神经网络包含大量被称为单元的人工神经元，这些单元排列在一系列不同的层中:输入层、隐藏层和输出层(图 3-2 )。

图 3-2

Neural network

神经网络是连接的，这意味着隐藏层中的每个神经元都与前一个输入层中的每个神经元以及下一个输出层完全连接。神经网络通过反复调整每层中的权重和偏差来学习，以获得最佳结果。

单层感知器

单层感知器是一个简单的线性二元分类器。它获取输入和相关权重，并将它们组合起来以产生用于分类的输出。它没有隐藏层。逻辑回归是单层感知器。

多层感知器

多层感知器(MLP)是反馈人工神经网络的一个简单例子。除了输入层和输出层之外，MLP 至少包含一个隐藏节点层。除输入层之外的层的每个节点被称为神经元，其使用诸如 sigmoid 或 ReLU 的非线性激活函数。MLP 使用一种称为反向传播的监督学习技术进行训练，同时最小化损失函数，如交叉熵。它使用优化器来调整参数(权重和偏差)。它的多层和非线性激活将 MLP 与线性感知器区分开来。

多层感知器是深度神经网络的基本形式。

在学习 MLPs 之前，我们先来看看线性模型和逻辑模型。你可以体会到线性、逻辑和 MLP 模型在复杂性方面的细微差别。

图 3-3 显示了一个输入(X)和一个输出(Y)的线性模型。

图 3-3

Single-input vector

单输入模型有一个权重为 W、偏差为 b 的向量 X。输出 Y 是 WX + b，这是线性模型。

图 3-4 显示了多个输入(X1 和 X2)和一个输出(Y)。

图 3-4

Linear model

此线性模型有两个输入要素:X1 和 X2，每个输入要素的对应权重为 W1、W2 和偏差 b。输出 Y 为 W1X1 + W2X2 + b

逻辑回归模型

图 3-5 显示了当二进制分类问题的输出标签 Y 为 0 或 1 时使用的学习算法。给定一个输入特征向量 X，你想要的是给定输入特征 X，Y = 1 的概率，这也被称为浅层神经网络或单层(无隐层；只有和输出层)神经网络。输出图层 Y 是σ (Z)，其中 Z 是 WX + b，σ是 sigmoid 函数。

图 3-5

One input (X) and one output (Y)

图 3-6 显示了当二进制分类问题的输出标签 Y 为 0 或 1 时使用的学习算法。

图 3-6

Multiple inputs (X1 and X1) and one output (Y)

给定输入要素向量 X1 和 X2，您需要给定输入要素 Y = 1 的概率。这也被称为感知器。输出层 Y 为σ (Z)，其中 Z 为 WX + b.

图 3-7 是一个两层的神经网络，有一个隐含层和一个输出层。考虑你有两个输入特征向量 X1 和 X2 连接到两个神经元，X1’和 X2’。从输入层到隐藏层的相关参数(权重)是 w1，w2，w3，w4，b1，b2。

图 3-7

Two-layer neural network

X1 '和 X2 '计算线性组合(图 3-8 )。

(2×1)(2×2)(2×1)(2×1)是输入层和隐藏层的维数。

图 3-8

Computation in the neural network

线性输入 X1’和 X2’通过隐藏层中的激活单元 a1 和 a2。

a1 是σ (X1 ')，a2 是σ(X2 ')，那么你也可以把方程写成:

该值从隐藏层向前传播到输出层。输入 a1 和 a2 以及参数 w5、w6 和 b3 通过输出层 a’(图 3-9 )。

图 3-9

Forward propagation

创建(w5a1 + w6a2) + b3 的线性组合，该组合将通过非线性 sigmoid 函数到达最终输出层 Y.

)

假设一维的初始模型结构为 Y = w*X + b，其中参数 w 和 b 为权重和偏差。

对于参数 w = 1 和 b = 1 的初始值，考虑损失函数 L(w，b) = 0.9。你得到这样的输出:y = 1*X+1 & L(w，b) = 0.9。

目标是通过调整参数 w 和 b 来最小化损失。误差将从输出层反向传播到隐藏层，再到输入层，以通过学习率和优化器来调整参数。最后，我们想建立一个模型(回归量)，可以用 x 来解释 Y。

为了开始建立模型的过程，我们初始化权重和偏差。为方便起见，w = 1，b = 1(初始值)，(优化器)带学习率的随机梯度下降(α = 0.01)。

下面是第一步:Y = 1 * X + 1。

1.20               0.35

参数调整为 w = 1.20，b = 0.35。

下面是第二步:Y1 = 1.20*X + 0.35。

1.24               0.31

参数调整为 w = 1.24，b = 0.31。

下面是第三步:Y1 = 1.24*X + 0.31。

1.25               0.30

经过一些迭代后，权重和偏差变得稳定。如您所见，在调优时，初始变化很大。经过一些迭代后，变化并不显著。

当 w = 1.26 且 b = 0.29 时，L(w，b)最小；因此，最终模型如下所示:

Y = 1.26 * X + 0.29

同样，在二维中，可以考虑参数，权重矩阵和偏置向量。

让我们假设初始权重矩阵和偏差向量为和。

你迭代并反向传播误差来调整 w 和 b。

是初始模型。权重矩阵(2x2)和偏差矩阵(2x1)在每次迭代中进行调整。因此，我们可以看到权重和偏差矩阵的变化

下面是第一步:

下面是第二步:

下面是步骤 3: 你可以注意到迭代中权重矩阵(2x2)和偏差矩阵(2x1)的变化。

You can notice change in weight matrix(2x2) and bias matrix(2x1) in the iteration.

调整 w 和 b 后的最终模型如下:

在本章中，您学习了如何在每次迭代中调整权重和偏差，同时保持损失函数最小化的目标。这是在优化器如随机梯度下降的帮助下完成的。

在这一章中，我们已经理解了人工神经网络和 MLP 作为基本的深度学习模型。在这里，我们可以看到 MLP 作为线性和逻辑回归的自然进展。我们已经看到在反向传播的每次迭代中权重和偏差是如何调整的。不用深入反向传播的细节，我们已经看到了反向传播的作用/结果。在接下来的两章中，我们将学习如何在 TensorFlow 和 keras 中建立 MLP 模型。

四、TensorFlow 中的 MLP 回归

长期以来，人们一直在使用回归和分类器。现在是时候切换到神经网络的话题了。多层感知器(MLP)是一个简单的神经网络模型，您可以在输入和输出层之间添加一个或多个隐藏层。

在本章中，您将看到 TensorFlow 如何帮助您构建模型。您将从最基本的模型开始，这是一个线性模型。本章还讨论了逻辑斯蒂和 MLP 模型。

TensorFlow 构建模型的步骤

在这一节中，我将讨论在 TensorFlow 中建立模型的步骤。我将带您完成这里的步骤，然后您将看到贯穿本章的代码:

1. 加载数据。
2. 将数据拆分到训练和测试中。
3. 如果需要，进行标准化。
4. 初始化包含预测值和目标值的占位符。
5. 创建将被调整的变量(权重和偏差)。
6. 声明模型操作。
7. 声明损失函数和优化器。
8. 初始化变量和会话。
9. 通过使用训练循环来拟合模型。
10. 用测试数据检查并显示结果。

TensorFlow 中的线性回归

首先你需要理解 TensorFlow 中线性回归的代码。图 4-1 显示了一个基本的线性模型。

图 4-1

Basic linear model

如图 4-1 所示，调整重量(W)和偏差(b)以获得正确的重量和偏差值。所以，权重(W)和偏差(b)是 TensorFlow 代码中的变量；您将在每次迭代中调整/修改它们，直到获得稳定(正确)的值。

您需要为 x 创建占位符。占位符具有特定的形状并包含特定的类型。

当你有一个以上的特性时，你会有一个类似于图 4-2 的工作模型。

图 4-2

Linear model with multiple inputs

在下面的代码中，您将使用 Seaborn 的 Iris 数据集，它有五个属性。您将把萼片长度作为输入，花瓣长度作为输出值。这个回归模型的主要目的是在给定萼片长度值的情况下预测花瓣长度。x 是萼片长度，Y 是花瓣长度。

利用 TensorFlow 对虹膜数据进行线性回归

如果您运行代码，您将看到如图 4-3 所示的输出。

图 4-3

Weights, bias, and loss at each step

图 4-4 显示了花瓣长度预测值的曲线图。

图 4-4

Petal length versus sepal length

逻辑回归模型

对于分类，最简单的方法是逻辑回归。在本节中，您将了解如何在 TensorFlow 中执行逻辑回归。在这里，您将权重和偏差创建为变量，以便每次迭代都有调整/更改它们的范围。创建占位符是为了包含 x。您需要为 x 创建占位符。占位符具有特定的形状，包含特定的类型，如图 4-5 所示。

图 4-5

Chart of logistic regression model

在下面的代码中，您将使用 Iris 数据集，它有五个属性。第五个是目标阶层。您将把萼片长度和萼片宽度视为预测属性，将花的种类视为目标值。这个逻辑回归模型的主要目的是在给定萼片长度和萼片宽度值的情况下预测物种的种类。

创建一个 Python 文件并导入所有需要的库。

如果你运行前面的代码，每个时期的交叉熵损失图如图 4-6 所示。

图 4-6

Plot for cross entropy loss per epoch

TensorFlow 中的多层感知器

多层感知器(MLP)是反馈人工神经网络的一个简单例子。除了输入层和输出层之外，MLP 至少包含一个隐藏节点层。除输入层之外的层的每个节点被称为神经元，其使用诸如 sigmoid 或 ReLU 的非线性激活函数。MLP 使用一种称为反向传播的监督学习技术进行训练，同时最小化交叉熵等损失函数，并使用优化器来调整参数(权重和偏差)。它的多层和非线性激活将 MLP 与线性感知器区分开来。

TensorFlow 非常适合构建 MLP 模型。在 MLP 中，您需要调整每次迭代的权重和偏差。这意味着权重和偏差保持变化，直到它们变得稳定，同时最小化损失函数。因此，您可以在 TensorFlow 中将权重和偏差创建为变量。我倾向于给它们初始值(全 0 或者全 1 或者一些随机的正态分布值)。占位符应该具有特定类型的值和定义的形状，如图 4-7 所示。

图 4-7

Flowchart for MLP

导入所有需要的库。在 TensorFlow 中实现 MLP。

如果您运行这段代码，您将得到如图 4-8 所示的曲线图。

图 4-8

Plot for loss while training and testing

在本章中，我讨论了如何在 TensorFlow 中系统地构建线性、逻辑和 MLP 模型。

五、Keras 的 MLP 回归

你在解决机器学习应用的同时，一直在做回归工作。线性回归和非线性回归用于预测数字目标，而逻辑回归和其他分类器用于预测非数字目标变量。在这一章，我将讨论多层感知器的进化。

具体来说，您将比较使用和不使用 Keras 时不同模型生成的准确性。

对数线性模型

创建一个新的 Python 文件并导入以下包。确保您的系统上安装了 Keras。

您将使用 Iris 数据集作为数据源。从 Seaborn 下载数据集。

虹膜数据集有五个属性。您将使用前四个属性来预测物种，其类别在数据集的第五个属性中定义。

使用scikit-learn的函数，分割测试和训练数据集。

##################################
# scikit Learn for (Log) Linear Regression #
##################################

使用model.fit功能用训练数据集训练模型。

随着模型的定型，您可以预测测试集的输出。

线性回归的 Keras 神经网络

现在，让我们建立一个线性回归的 Keras 神经网络模型。

使用model.fit功能用训练数据集训练模型。

随着模型的定型，您可以预测测试集的输出。

打印两种模型获得的精度。

如果运行该代码，您将看到以下输出:

逻辑回归

在这一节，我将分享一个逻辑回归的例子，这样你就可以比较scikit-learn和 Keras 中的代码(见图 5-1 )。

图 5-1

Logistic regression used for classification

创建一个新的 Python 文件并导入以下包。确保您的系统上安装了 Keras。

您将使用 Iris 数据集作为数据源。因此，从 scikit-learn 加载数据集。

使用scikit-learn的函数，分割测试和训练数据集。

sci kit-学习逻辑回归

使用model.fit功能用训练数据集训练模型。模型定型后，您可以预测测试集的输出。

########################################

用于逻辑回归的 Keras 神经网络

一键编码将要素转换为更适合分类和回归算法的格式。

使用model.fit功能用训练数据集训练模型。

使用model.evaluate功能评估模型的性能。

打印两种模型获得的精度。基于 scikit-learn 的模型的准确性

精度为 0.83。keras 模型的精度

精度为 0.99。

如果运行该代码，您将看到以下输出:

为了给出真实的例子，我将讨论一些使用时尚 MNIST 数据集的代码，这是 Zalando.com 的图像数据集，由 60，000 个示例的训练集和 10，000 个示例的测试集组成。每个示例都是一个 28×28 灰度图像，与来自 10 个类别的标签相关联。

时尚 MNIST 数据:Keras 中的逻辑回归

创建一个新的 Python 文件并导入以下包。确保您的系统上安装了 Keras。

如上所述，您将使用时尚 MNIST 数据集。将数据和标签存储在两个不同的变量中。

规范化数据集，如下所示:

定义模型，如下所示:

将模型保存在一个.h5文件中(这样您以后可以直接使用 keras.models 中的load_model()函数)并打印测试集中模型的准确性，如下所示:

如果运行前面的代码，您将看到以下输出:

('train-images-idx3-ubyte.gz', <http.client.HTTPMessage object at 0x00000171338E2B38>)
_______________________________________________________________
Layer (type)                 Output Shape              Param #   
===============================================================
dense_59 (Dense)             (None, 256)               200960    
_______________________________________________________________
dropout_10 (Dropout)         (None, 256)               0         
_______________________________________________________________
dense_60 (Dense)             (None, 512)               131584    
_______________________________________________________________
dense_61 (Dense)             (None, 10)                5130      
===============================================================
Total params: 337,674
Trainable params: 337,674
Non-trainable params: 0
_______________________________________________________________
Train on 60000 samples, validate on 10000 samples
Epoch 1/2
60000/60000 [==============================] - loss: 0.5188 - acc: 0.8127 - val_loss: 0.4133 - val_acc: 0.8454
Epoch 2/2
60000/60000 [==============================] - loss: 0.3976 - acc: 0.8545 - val_loss: 0.4010 - val_acc: 0.8513
Test loss: 0.400989927697
Test accuracy: 0.8513

上的 mips

多层感知器是一个最小的神经网络模型。在这一部分，我将向您展示代码。

写代码

创建一个新的 Python 文件并导入以下包。确保您的系统上安装了 Keras。

通过使用 Pandas 读取 CSV 文件来加载数据集。

将数值分配给数据集的类别。

将数据框转换为数组。

分割数据和目标，并将它们存储在两个不同的变量中。

使用 Numpy 更改目标格式。

建立一个连续的 Keras 模型

在这里，您将建立一个多层感知器模型与一个隐藏层。

• 输入层:输入层包含四个神经元，代表虹膜的特征(萼片长度等。).
• 隐层:隐层包含十个神经元，激活使用 ReLU。
• 输出层:输出层包含三个神经元，代表 Iris softmax 层的类别。

编译模型并选择优化器和损失函数来训练和优化数据，如下所示:

使用model.fit功能训练模型，如下所示:

加载并准备测试数据，如下所示:

将字符串值转换为数值，如下所示:

将数据框转换为数组，如下所示:

分割x和y，换句话说，特性集和目标集，如下所示:

对训练好的模型进行预测，如下所示:

计算精确度，如下所示:

打印模型生成的精度，如下所示:

如果运行该代码，您将看到以下输出:

Epoch 1/100
120/120 [==============================] - 0s - loss: 2.7240 - acc: 0.3667
Epoch 2/100
120/120 [==============================] - 0s - loss: 2.4166 - acc: 0.3667
Epoch 3/100
120/120 [==============================] - 0s - loss: 2.1622 - acc: 0.4083
Epoch 4/100
120/120 [==============================] - 0s - loss: 1.9456 - acc: 0.6583

Epoch 98/100
120/120 [==============================] - 0s - loss: 0.5571 - acc: 0.9250
Epoch 99/100
120/120 [==============================] - 0s - loss: 0.5554 - acc: 0.9250
Epoch 100/100
120/120 [==============================] - 0s - loss: 0.5537 - acc: 0.9250

MNIST 数据的 MLPs(数字分类)

MNIST 是预测手写数字的标准数据集。在本节中，您将看到如何应用多层感知器的概念并制作一个手写数字识别系统。

创建一个新的 Python 文件并导入以下包。确保您的系统上安装了 Keras。

定义了一些重要的变量。

使用mnist.load_data()功能加载数据集。

训练集和测试集的类型被转换为float32。

数据集是标准化的；换句话说，它们被设置为 Z 分数。

显示数据集中存在的训练样本的数量以及可用测试集的数量。

将类别向量转换为二进制类别矩阵。

定义多层感知器的顺序模型。

使用优化器。

要优化的函数是真实标签和模型输出(softmax)之间的交叉熵。

使用model.fit功能训练模型。

使用模型，评估函数来评估模型的性能。

打印模型中生成的精度。

如果运行该代码，您将获得以下输出:

60000 train samples
10000 test samples
Train on 60000 samples, validate on 10000 samples
Epoch 1/20
13s - loss: 0.2849 - acc: 0.9132 - val_loss: 0.1149 - val_acc: 0.9652
Epoch 2/20
11s - loss: 0.1299 - acc: 0.9611 - val_loss: 0.0880 - val_acc: 0.9741
Epoch 3/20
11s - loss: 0.0998 - acc: 0.9712 - val_loss: 0.1121 - val_acc: 0.9671
Epoch 4/20
Epoch 18/20
14s - loss: 0.0538 - acc: 0.9886 - val_loss: 0.1241 - val_acc: 0.9814
Epoch 19/20
12s - loss: 0.0522 - acc: 0.9888 - val_loss: 0.1154 - val_acc: 0.9829
Epoch 20/20
13s - loss: 0.0521 - acc: 0.9891 - val_loss: 0.1183 - val_acc: 0.9824
Test score: 0.118255248802
Test accuracy: 0.9824

现在，是时候创建一个数据集并使用多层感知器了。在这里，您将使用随机函数创建自己的数据集，并对生成的数据运行多层感知器模型。

随机生成数据的 MLPs

创建一个新的 Python 文件并导入以下包。确保您的系统上安装了 Keras。

使用random功能生成数据。

创建顺序模型。

编译模型。

使用model.fit功能训练模型。

使用model.evaluate功能评估模型的性能。

如果运行该代码，您将获得以下输出:

Epoch 1/20
1000/1000 [==============================] - 0s - loss: 2.4432 - acc: 0.0970     
Epoch 2/20
1000/1000 [==============================] - 0s - loss: 2.3927 - acc: 0.0850     
Epoch 3/20
1000/1000 [==============================] - 0s - loss: 2.3361 - acc: 0.1190     
Epoch 4/20
1000/1000 [==============================] - 0s - loss: 2.3354 - acc: 0.1000
Epoch 19/20
1000/1000 [==============================] - 0s - loss: 2.3034 - acc: 0.1160     
Epoch 20/20
1000/1000 [==============================] - 0s - loss: 2.3055 - acc: 0.0980     
100/100 [==============================] - 0s

在这一章中，我讨论了如何系统地在 Keras 中建立线性、逻辑和 MLP 模型。

六、卷积神经网络

卷积神经网络(CNN)是一种深度前馈人工神经网络，其中神经网络通过学习内部特征表示并概括常见图像问题(如对象识别和其他计算机视觉问题)中的特征来保留分层结构。它不限于图像；它还在自然语言处理问题和语音识别方面取得了最先进的成果。

CNN 中的不同层

一个 CNN 由多层组成，如图 6-1 所示。

图 6-1

Layers in a convolution neural network

卷积层由滤镜和图像贴图组成。假设灰度输入图像的大小为 5×5，这是一个 25 像素值的矩阵。图像数据表示为宽×高×通道的三维矩阵。

Note

图像映射是与特定图像相关的坐标列表。

卷积旨在从输入图像中提取特征，因此它通过使用输入数据的小方块学习图像特征来保持像素之间的空间关系。可以预期旋转不变性、平移不变性和比例不变性。例如，由于卷积步骤，CNN 可以容易地识别旋转的 cat 图像或重新缩放的 cat 图像。在原始图像(此处为 1 个像素)上滑动滤镜(方形矩阵)，在每个给定位置，计算元素级乘法(滤镜和原始图像的矩阵之间),并将乘法输出相加，以获得形成输出矩阵元素的最终整数。

子采样是简单的平均池，每个特征图具有可学习的权重，如图 6-2 所示。

图 6-2

Subsampling

如图 6-2 所示，滤波器有输入权值，产生一个输出神经元。假设您定义了一个卷积层，它有六个过滤器和接收域，宽 2 像素，高 2 像素，默认步长为 1，默认填充设置为 0。每个滤波器从图像的 2×2 像素部分接收输入。换句话说，就是一次 4 个像素。因此，您可以说它将需要 4 + 1(偏差)输入权重。

输入体积为 5×5×3(宽×高×通道数)，有 6 个 2×2 大小的滤波器，步长为 1，pad 为 0。因此，对于每个滤波器，该层中的参数数量为 223 + 1 = 13 个参数(对于偏差加上+ 1)。因为有六个过滤器，所以有 13*6 = 78 个参数。

图 6-3

Input volume

这里有一个总结:

• 输入体积的大小为 W1 × H1 × D1。
• 该模型需要超参数:滤波器的数量(f)、步距(S)、零填充量§。
• 这产生尺寸为 W2 × H2 × D2 的体积。
• W2 = (W1-f+ 2P) /S + 1 = 4。
• H2 = (H1-f+2P)/S +1 = 4。
• D2 =过滤器数量= f = 6。

池层减少了先前层的激活映射。接下来是一个或多个卷积层，整合了前几层激活图中的所有特性。这减少了训练数据的过拟合，并概括了网络所表示的特征。感受野大小几乎总是设置为 2×2，并使用 1 或 2(或更高)的步幅以确保没有重叠。您将对每个感受野使用最大操作，以便激活为最大输入值。在这里，每四个数字映射到一个数字。于是，这一步像素数下降到原来的四分之一(图 6-4 )。

图 6-4

Maxpooling-reducing the number of pixels

全连接层是前馈人工神经网络层。这些层具有非线性激活函数来输出类别预测概率。在所有特征被卷积层识别和提取并且已经被网络中的汇集层合并之后，它们被用于最后。这里，隐藏层和输出层是完全连接的层。

CNN 架构

CNN 是一种前馈深度神经网络架构，由几个卷积层组成，每个卷积层后面都有一个池层、激活函数和可选的批量标准化。它还包括完全连接的层。当图像在网络中移动时，它会变小，这主要是因为 max pooling。最后一层输出类别概率预测。

图 6-5

CNN Architecture for Classification

在过去的几年中，已经开发了许多架构，这些架构在图像分类领域取得了巨大的进步。屡获殊荣的预训练网络(VGG16、VGG19、ResNet50、Inception V3 和 Xception)已被用于各种图像分类挑战，包括医学成像。迁移学习是一种除了几层之外还使用预训练模型的实践。它可以用来解决图像分类在各个领域的挑战。

七、TensorFlow 中的 CNN

本章将演示如何使用 TensorFlow 建立一个 CNN 模型。CNN 模型可以帮助你建立一个可以预测/分类图像的图像分类器。一般来说，您在模型架构中创建一些层，这些层具有权重和偏差的初始值。然后，您可以在训练数据集的帮助下调整权重和偏差。还有另一种方法，包括使用预训练模型(如 InceptionV3)对图像进行分类。您可以使用这种迁移学习方法，在预训练模型(参数值保持不变)的层之上添加一些层(其参数已被训练),以制作非常强大的分类器。

在这一章中，我将使用 TensorFlow 展示如何为各种计算机视觉应用开发卷积网络。将 CNN 架构表示为数据流图更容易。

CNN 模型为什么要 TensorFlow？

在 TensorFlow 中，图像可以表示为三维数组或形状的张量(高度、宽度和通道)。TensorFlow 提供了快速迭代的灵活性，允许您更快地训练模型，并使您能够运行更多的实验。将 TensorFlow 模型投入生产时，可以在大规模 GPU 和 TPU 上运行。

用于为 MNIST 数据构建图像分类器的 TensorFlow 代码

在本节中，我将带您通过一个示例来了解如何在 TensorFlow 中实现 CNN。

以下代码从 TensorFlow contrib 包中导入包含数字的 28×28 灰度图像的 MNIST 数据集，并加载所有必需的库。这里，目标是建立分类器来预测图像中给定的数字。

from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets
from tensorflow.python.framework import ops
import tensorflow as tf
import numpy as np

然后启动图形会话。

# Start a graph session
sess = tf.Session()

您加载 MNIST 数据并创建训练集和测试集。

# Load data
from keras.datasets import mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()

然后规范化训练和测试集特征。

# Z- score  or Gaussian Normalization
X_train = X_train - np.mean(X_train) / X_train.std()
X_test = X_test - np.mean(X_test) / X_test.std()

由于这是一个多类分类问题，因此最好使用输出类值的一次性编码。

# Convert labels into one-hot encoded vectors
num_class = 10
train_labels = tf.one_hot(y_train, num_class)
test_labels = tf.one_hot(y_test, num_class)

现在让我们设置模型参数，因为这些图像是灰度的。因此，图像(通道)的深度是 1。

# Set model parameters
batch_size = 784
samples =500
learning_rate = 0.03
img_width = X_train[0].shape[0]
img_height = X_train[0].shape[1]
target_size = max(train_labels) + 1
num_channels = 1 # greyscale = 1 channel
epoch = 200
no_channels = 1
conv1_features = 30
filt1_features = 5
conv2_features = 15
filt2_features = 3
max_pool_size1 = 2 # NxN window for 1st max pool layer
max_pool_size2 = 2 # NxN window for 2nd max pool layer
fully_connected_size1 = 150

让我们声明模型的占位符。可以为训练集和评估集更改输入数据特征、目标变量和批量大小。

# Declare model placeholders
x_input_shape = (batch_size, img_width, img_height, num_channels)
x_input = tf.placeholder(tf.float32, shape=x_input_shape)
y_target = tf.placeholder(tf.int32, shape=(batch_size))
eval_input_shape = (samples, img_width, img_height, num_channels)
eval_input = tf.placeholder(tf.float32, shape=eval_input_shape)
eval_target = tf.placeholder(tf.int32, shape=(samples))

让我们为输入层和隐藏层的神经元声明模型变量的权重和偏差值。

# Declare model variables
W1 = tf.Variable(tf.random_normal([filt1_features, filt1_features, no_channels, conv1_features]))
b1 = tf.Variable(tf.ones([conv1_features]))
W2 = tf.Variable(tf.random_normal([filt2_features, filt2_features, conv1_features, conv2_features]))
b2 = tf.Variable(tf.ones([conv2_features]))

让我们为完全连接的层声明模型变量，并为最后两层定义权重和偏差。

# Declare model variables for fully connected layers
resulting_width = img_width // (max_pool_size1 * max_pool_size2)
resulting_height = img_height // (max_pool_size1 * max_pool_size2)
full1_input_size = resulting_width * resulting_height * conv2_features
W3 = tf.Variable(tf.truncated_normal([full1_input_size, fully_connected_size1], stddev=0.1, dtype=tf.float32))
b3 = tf.Variable(tf.truncated_normal([fully_connected_size1], stddev=0.1, dtype=tf.float32))
W_out = tf.Variable(tf.truncated_normal([fully_connected_size1, target_size], stddev=0.1, dtype=tf.float32))
b_out = tf.Variable(tf.truncated_normal([target_size], stddev=0.1, dtype=tf.float32))

让我们创建一个助手函数来定义卷积层和最大池层。

# Define helper functions for the convolution and maxpool layers:
def conv_layer(x, W, b):
    conv = tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding="SAME")
    conv_with_b = tf.nn.bias_add(conv, b)
    conv_out = tf.nn.relu(conv_with_b)
    return conv_out
def maxpool_layer(conv, k=2):
    return tf.nn.max_pool(conv, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding="SAME")

神经网络模型由两个隐藏层和两个完全连接的层定义。整流线性单元被用作隐藏层和最终输出层的激活函数。

# Initialize Model Operations

def my_conv_net(input_data):
    # First Conv-ReLU-MaxPool Layer
    conv_out1 = conv_layer(input_data, W1, b1)
    maxpool_out1 = maxpool_layer(conv_out1)

    # Second Conv-ReLU-MaxPool Layer
    conv_out2 = conv_layer(maxpool_out1, W2, b2)
    maxpool_out2 = maxpool_layer(conv_out2)

    # Transform Output into a 1xN layer for next fully connected layer
    final_conv_shape = maxpool_out2.get_shape().as_list()
    final_shape = final_conv_shape[1] * final_conv_shape[2] * final_conv_shape[3]
    flat_output = tf.reshape(maxpool_out2, [final_conv_shape[0], final_shape])

    # First Fully Connected Layer
    fully_connected1 = tf.nn.relu(tf.add(tf.matmul(flat_output, W3), b3))
    # Second Fully Connected Layer
    final_model_output = tf.add(tf.matmul(fully_connected1, W_out), b_out)

    return(final_model_output)

model_output = my_conv_net(x_input)
test_model_output = my_conv_net(eval_input)

您将使用 softmax 交叉熵函数(更适用于多类分类)来定义作用于逻辑的损失。

# Declare Loss Function

(softmax cross entropy)
loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=model_output, labels=y_target))

让我们定义训练集和测试集的预测函数。

# Create a prediction function
prediction = tf.nn.softmax(model_output)
test_prediction = tf.nn.softmax(test_model_output)

为了确定每一批的模型精度，让我们定义精度函数。

# Create accuracy function
def get_accuracy(logits, targets):
    batch_predictions = np.argmax(logits, axis=1)
    num_correct = np.sum(np.equal(batch_predictions, targets))
    return(100\. * num_correct/batch_predictions.shape[0])

让我们声明训练步骤并定义优化器函数。

# Create an optimizer
my_optimizer = tf.train.AdamOptimizer(learning_rate, 0.9)
train_step = my_optimizer.minimize(loss)

让我们初始化前面声明的所有模型变量。

# Initialize Variables
varInit = tf.global_variables_initializer()
sess.run(varInit)

让我们开始训练模型，并随机循环处理这些数据。您希望在训练和测试集批次上评估模型，并记录损失和准确性。

# Start training loop

train_loss = []
train_acc = []
test_acc = []
for i in range(epoch):
    random_index = np.random.choice(len(X_train), size=batch_size)
    random_x = X_train[random_index]
    random_x = np.expand_dims(random_x, 3)
    random_y = train_labels[random_index]   

    train_dict = {x_input: random_x, y_target: random_y}

    sess.run(train_step, feed_dict=train_dict)
    temp_train_loss, temp_train_preds = sess.run([loss, prediction], feed_dict=train_dict)
    temp_train_acc = get_accuracy(temp_train_preds, random_y)

    eval_index = np.random.choice(len(X_test), size=evaluation_size)
    eval_x = X_test[eval_index]
    eval_x = np.expand_dims(eval_x, 3)
    eval_y = test_labels[eval_index]
    test_dict = {eval_input: eval_x, eval_target: eval_y}
    test_preds = sess.run(test_prediction, feed_dict=test_dict)
    temp_test_acc = get_accuracy(test_preds, eval_y)

模型的结果以下列格式记录并打印在输出中:

# Record and print results

train_loss.append(temp_train_loss)
train_acc.append(temp_train_acc)
test_acc.append(temp_test_acc)
print('Epoch # {}. Train Loss: {:.2f}. Train Acc : {:.2f} . temp_test_acc : {:.2f}'.format(i+1,temp_train_loss,temp_train_acc,temp_test_acc))

使用高级 API 构建 CNN 模型

TFLearn、TensorLayer、tflayers、TF-Slim、tf.contrib.learn、Pretty Tensor、keras 和 Sonnet 都是高级 TensorFlow APIs。如果您使用这些高级 API 中的任何一个，您都可以用几行代码构建 CNN 模型。因此，您可以探索这些 API 中的任何一个来更好地工作。

八、Keras CNN

本章将演示如何使用 Keras 建立 CNN 模型。CNN 模型可以帮助你建立一个可以预测和分类图像的图像分类器。一般来说，您在模型架构中创建一些层，这些层具有权重和偏差的初始值。然后，在训练数据集的帮助下，调整权重和偏差变量。在这种情况下，您将学习如何用 Keras 编码。还有另一种方法涉及使用预训练的模型，如 InceptionV3 和 ResNet50，这些模型可以对图像进行分类。

让我们定义一个 CNN 模型，并评估它的性能。您将使用带有卷积层的结构；然后，您将使用 max pooling 并展平网络以完全连接图层并进行预测。

为 Keras 中的 MNIST 数据构建影像分类器

在这里，我将演示使用流行的 MNIST 数据集构建手写数字分类器的过程。

这项任务对于玩神经网络来说是一个很大的挑战，但它可以在单台计算机上管理。

MNIST 数据库包含 60，000 幅训练图像和 10，000 幅测试图像。

首先导入 Numpy 并为计算机的伪随机数发生器设置一个种子。这允许您从脚本中重现结果。

import numpy as np
# random seed for reproducibility
np.random.seed(123)

接下来，从 Keras 导入顺序模型类型。这只是神经网络层的线性堆栈。

from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import Flatten
from keras.layers import Conv2D
from keras.layers import MaxPooling2d
#Now we will import some utilities
from keras.utils import np_utils
#Fixed dimension ordering issue
from keras import backend as K
K.set_image_dim_ordering('th')

#Load image data from MNIST

#Load pre-shuffled MNIST data into train and test sets
(X_train,y_train),(X_test, y_test)=mnist.load_data()

#Preprocess imput data for Keras

# Reshape input data.
# reshape to be [samples][channels][width][height]
X_train=X_train.reshape(X_train.shape[0],1,28,28)
X_test=X_test.reshape(X_test.shape[0],1,28,28)
# to convert our data type to float32 and normalize our database
X_train=X_train.astype('float32')
X_test=X_test.astype('float32')
print(X_train.shape)

# Z-scoring or Gaussian Normalization
X_train=X_train - np.mean(X_train) / X_train.std()
X_test=X_test – np.mean(X_test) / X_test.std()
#(60000, 1, 28, 28)

# convert 1-dim class arrays to 10 dim class metrices
#one hot encoding outputs
y_train=np_utils.to_categorical(y_train)
y_test-np_utils.to_categorical(y_test)
num_classes=y_test.shape[1]
print(num_classes)
#10

#Define a simple CNN model
print(X_train.shape)
#(60000,1,28,28)

定义网络结构

网络结构如下:

• 网络有一个卷积输入层，有 32 个大小为 5×5 的特征图。激活函数是整流线性单位。
• 最大池层的大小为 2×2。
• 辍学率设定为 30%。
• 您可以展平图层。
• 该网络具有 240 个单元的全连接层，并且激活函数是指数线性单元。
• 网络的最后一层是具有 10 个单元的全连接输出层，激活函数是 softmax。

然后，使用二元交叉熵作为损失函数，使用 adagrad 作为优化器来编译模型。

定义模型架构

该架构由卷积层和最大池化层以及最后的密集层组成。

# create a model

     model=Sequential()
     model.add(Conv2D(32, (5,5), input_shape=(1,28,28), activation="relu"))
     model.add(MaxPooling2D(pool_size=(2,2)))
     model.add(Dropout(0.3))      # Dropout, one form of regularization
     model.add(Flatten())
     model.add(Dense(240,activation='elu'))
     model.add(Dense(num_classes, activation="softmax"))
     print(model.output_shape)
     (None, 10)

# Compile the model

model.compile(loss='binary_crossentropy', optimizer="adagrad", matrices=['accuracy'])

然后，通过采用 200 的批量大小，使用训练数据集来拟合模型。该模型从训练数据集中取出前 200 个实例/行(从第 1 个到第 200 个),并训练网络。然后，该模型再次取第二个 200 个实例(从第 201 个到第 400 个)用于训练网络。这样，您可以通过网络传播所有实例。该模型需要较少的内存，因为每次训练的网络实例较少。但是小批量不能很好地估计梯度，因此调整重量和偏差是一个挑战。

一个时期意味着所有训练样本的一次向前传递和一次向后传递。完成一个历元需要多次迭代。

这里，你有 60，000 个训练样本，你的批量是 200 个，那么完成 1 个历元需要 300 次迭代。

# Fit the model
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=1, batch_size=200)

# Evaluate model on test data

     # Final evaluation of the model
     scores =model.evaluate(X_test, y_test, verbose=0)
     print("CNN error: % .2f%%" % (100-scores[1]*100))
     # CNN Error: 17.98%

     # Save the model
     # save model
     model_json= model.to_join()
     with open("model_json", "w") as json_file:
     json_file.write(model_json)
     # serialize weights to HDFS
     model.save_weights("model.h5")

利用 CIFAR-10 数据构建图像分类器

本节解释了如何使用 Keras CNN 模型构建一个分类器来对 CIFAR-10 数据集的 10 个标签进行分类。

Note

CIFAR-10 数据集由 10 类 60，000 幅 32×32 彩色图像组成，每类 6，000 幅图像。有 50，000 个训练图像和 10，000 个测试图像。

###########Building CNN Model with CIFAR10 data###################
# plot cifar10 instances
     from keras.datasets import cifar10
     from matplotlib import pyplot
     from scipy.misc import toimage
     import numpy
     from keras.models import Sequential
     from keras.layers import Dense
     from keras.layers import Dropout
     from keras.layers import Flatten
     from keras.layers import Conv2D
     from keras.layers import MaxPooling2d
     #Now we will import some utilities
     from keras.utils import np_utils
     from keras.layers.normalization import BatchNormalization

     #Fixed dimension ordering issue
     from keras import backend as K
     K.set_image_dim_ordering('th')

     # fix random seed for reproducibility
     seed=12
     numpy.random.seed(seed)
     #Preprocess imput data for Keras

     # Reshape input data.
     # reshape to be [samples][channels][width][height]
     X_train=X_train.reshape(X_train.shape[0],3,32,32).astype('float32')
     X_test=X_test.reshape(X_test.shape[0],3,32,32).astype('float32')

     # Z-scoring or Gaussian Normalization
     X_train=X_train - np.mean(X_train) / X_train.std()
     X_test=X_test – np.mean(X_test) / X_test.std()

     # convert 1-dim class arrays to 10 dim class metrices
     #one hot encoding outputs
     y_train=np_utils.to_categorical(y_train)
     y_test-np_utils.to_categorical(y_test)
     num_classes=y_test.shape[1]
     print(num_classes)
     #10

     #Define a simple CNN model
     print(X_train.shape)
     #(50000,3,32,32)

定义网络结构

网络结构如下:

• 卷积输入层有 32 个大小为 5×5 的特征映射，激活函数是一个校正的线性单元。
• 最大池层的大小为 2×2。
• 卷积层有 32 个大小为 5×5 的特征图，激活函数是一个校正的线性单元。
• 网络有批量归一化。
• 最大池层的大小为 2×2。
• 辍学率设定为 30%。
• 您可以展平图层。
• 全连接层有 240 个单元，激活函数是指数线性单元。
• 全连接输出层有十个单元，激活函数是 softmax。

然后，通过采用 200 的批量大小，使用训练数据集来拟合模型。从训练数据集中取出前 200 个实例/行(从第 1 个到第 200 个)来训练网络。然后你取第二个 200 个实例(从第 201 个到第 400 个)再次训练网络。这样，您可以通过网络传播所有实例。一个时期意味着所有训练样本的一次向前传递和一次向后传递。完成一个历元需要多次迭代。

这里，你有 50，000 个训练样本，你的批量是 200 个，那么完成 1 个历元需要 250 次迭代。

定义模型架构

使用卷积层和最大池层的组合创建顺序模型。随后，附着完全连接的致密层。

# create a model

     model=Sequential()
     model.add(Conv2D(32, (5,5), input_shape=(3,32,32), activation="relu"))
     model.add(MaxPooling2D(pool_size=(2,2)))
     model.add(Conv2D(32, (5,5), activation="relu", padding="same"))
     model.add(BatchNormalization())
     model.add(MaxPooling2D(pool_size=(2,2)))
     model.add(Dropout(0.3))      # Dropout, one form of regularization
     model.add(Flatten())
     model.add(Dense(240,activation='elu'))
     model.add(Dense(num_classes, activation="softmax"))
     print(model.output_shape)
     model.compile(loss='binary_crossentropy', optimizer="adagrad")
     # fit model
     model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=1, batch_size=200)

     # Final evaluation of the model
     scores =model.evaluate(X_test, y_test, verbose=0)
     print("CNN error: % .2f%%" % (100-scores[1]*100

预训练模型

在这一部分，我将展示如何使用预训练的模型，如 VGG 和 inception，来构建一个分类器。

Inception-V3 预训练模型可以检测/分类 22，000 个类别的对象。它可以检测/分类托盘，手电筒，雨伞和其他。

在许多场景中，我们需要根据自己需求构建分类器。为此，在我们使用预训练模型(用于特征提取)和多个神经网络的情况下，使用迁移学习。

九、RNN 和 LSTM

本章将讨论循环神经网络(RNNs)的概念及其修改版本，长短期记忆(LSTM)。LSTM 主要用于序列预测。您将了解各种序列预测，然后学习如何借助 LSTM 模型进行时间序列预测。

RNNs 的概念

循环神经网络是一种人工神经网络，最适合于识别数据序列中的模式，如文本、视频、语音、语言、基因组和时序数据。RNN 是一种非常强大的算法，可以对数据进行分类、聚类和预测，尤其是时间序列和文本。

RNN 可以看作是一个 MLP 网络，只是在体系结构上增加了环路。在图 9-1 中，可以看到有一个输入层(节点为 x1、x2 等)、一个隐藏层(节点为 h1、h2 等)、一个输出层(节点为 y1、y2 等)。这类似于 MLP 的建筑。不同之处在于隐藏层的节点是相互连接的。在普通(基本)RNN/LSTM 中，节点单向连接。这意味着 h2 依赖于 h1(和 x2)，h3 依赖于 h2(和 x3)。隐藏层中的节点由隐藏层中的前一个节点决定。

图 9-1

An RNN

这种架构确保 t=n 时的输出取决于 t=n、t=n-1、…、t=1 时的输入。换句话说，输出取决于数据的顺序而不是单个数据(图 9-2 )。

图 9-2

The sequence

图 9-3 显示了隐藏层的节点如何连接到输入层的节点。

图 9-3

The connections

在 RNN 中，如果序列很长，则在训练(反向传播)期间计算梯度(这对调整权重和偏差很重要)。它们要么消失(许多小于 1 的小值相乘)，要么爆炸(许多大于 1 的大值相乘)，导致模型训练非常缓慢。

LSTM 的概念

长短期记忆是一种改进的 RNN 体系结构，它解决了消失和爆炸梯度的问题，并解决了长序列训练和保持记忆的问题。所有的 rnn 在循环层都有反馈回路。反馈回路有助于将信息长时间保存在“记忆”中。但是，很难训练标准的 rnn 来解决需要学习长期时间依赖性的问题。由于损失函数的梯度随时间呈指数衰减(这种现象称为消失梯度问题)，因此很难训练典型的 rnn。这就是为什么 RNN 被修改为包括一个可以在存储器中长时间保存信息的存储单元。改良后的 RNN 更为人所知的名字是 LSTM。在 LSTM，一组门用于控制信息何时进入内存，这解决了消失或爆炸梯度问题。

循环连接给网络增加了状态或记忆，并允许它学习和利用输入序列中观察值的有序性质。内部存储器意味着网络的输出取决于输入序列中的最近上下文，而不是刚刚作为网络输入呈现的内容。

LSTM 模式

LSTM 可以有以下模式之一:

• 一对一模型
• 一对多模型
• 多对一模型
• 多对多模型

除了这些模式之外，同步的多对多模型也正在被使用，尤其是对于视频分类。

图 9-4 显示了多对一的 LSTM。这意味着在这个模型中许多输入产生一个输出。

图 9-4

Many-to-one LSTM

序列预测

LSTM 最适合序列数据。LSTM 可以预测、分类和生成序列数据。序列意味着一个观察顺序，而不是一组观察。序列的一个例子是测试系列，其中时间戳和值按照序列的顺序(按时间顺序)排列。另一个例子是视频，它可以被认为是图像序列或音频剪辑序列。

基于数据序列的预测称为序列预测。序列预测据说有四种类型。

• 序列数值预测
• 序列分类
• 序列生成
• 序列间预测

序列数值预测

序列数值预测是预测给定序列的下一个值。它的用例是股票市场预测和天气预报。这里有一个例子:

• 输入顺序:3，5，8，12
• 产量:17

序列分类

序列分类预测给定序列的类别标签。其用例是欺诈检测(使用交易序列作为输入来分类/预测账户是否被黑客攻击)和基于表现的学生分类(按时间顺序排列的过去六个月的考试分数序列)。这里有一个例子:

• 输入顺序:2，4，6，8
• 产出:“增加”

序列生成

序列生成是指生成一个新的输出序列，它与输入语料库中的输入序列具有相同的属性。它的用例是文本生成(给定博客的 100 行，生成博客的下一行)和音乐生成(给定音乐示例，生成新的音乐作品)。这里有一个例子:

• 输入序列:[3，5，8，12]，[4，6，9，13]
• 输出:[5，7，10，14]

序列间预测

序列间预测是指预测给定序列的下一个序列。它的用例是文档摘要和多步时间序列预测(预测一个数字序列)。这里有一个例子:

• 输入顺序:[3，5，8，12，17]
• 输出:[23，30，38]

如前所述，LSTM 用于商业中的时间序列预测。

让我们来看一个 LSTM 模型。假设给出了一个 CSV 文件，其中第一列是时间戳，第二列是值。它可以表示传感器(IoT)数据。

给定时间序列数据，你必须预测未来的值。

用 LSTM 模型进行时间序列预测

以下是 LSTM 时间序列预测的完整示例:

# Simple LSTM for a time series data
import numpy as np
import matplotlib.pyplot as plt
from pandas import read_csv
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error
import pylab

# convert an array of values into a timeseries data
def create_timeseries(series, ts_lag=1):
    dataX = []
    dataY = []
    n_rows = len(series)-ts_lag
    for i in range(n_rows-1):
        a = series[i:(i+ts_lag), 0]
        dataX.append(a)
        dataY.append(series[i + ts_lag, 0])

    X, Y = np.array(dataX), np.array(dataY)
    return X, Y
# fix random seed for reproducibility
np.random.seed(230)
# load dataset
dataframe = read_csv('sp500.csv', usecols=[0])
plt.plot(dataframe)
plt.show()

图 9-5 显示了数据的曲线图。

图 9-5

Plot of the data

下面是更多的代码:

# Changing datatype to float32 type
series = dataframe.values.astype('float32')

# Normalize the dataset
scaler = StandardScaler()
series = scaler.fit_transform(series)

# split the datasets into train and test sets
train_size = int(len(series) * 0.75)
test_size = len(series) - train_size
train, test = series[0:train_size,:], series[train_size:len(series),:]

# reshape the train and test dataset into X=t and Y=t+1
ts_lag = 1
trainX, trainY = create_timeseries(train, ts_lag)
testX, testY = create_timeseries(test, ts_lag)

# reshape input data to be [samples, time steps, features]
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))

# Define the LSTM model
model = Sequential()
model.add(LSTM(10, input_shape=(1, ts_lag)))
model.add(Dense(1))
model.compile(loss='mean_squared_logarithmic_error', optimizer="adagrad")

# fit the model
model.fit(trainX, trainY, epochs=500, batch_size=30)
# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)

# rescale predicted values
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])

# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
print('Test Score: %.2f RMSE' % (testScore))

# plot baseline and predictions
pylab.plot(trainPredictPlot)
pylab.plot(testPredictPlot)
pylab.show()

在图 9-6 中，您可以看到实际时间序列与预测时间序列的关系图。橙色部分是训练数据，蓝色部分是测试数据，绿色部分是预测输出。

图 9-6

Plot of actual versus predicted time series

到目前为止，我们已经学习了 RNN、LSTM 和 LSTM 模型时间序列预测的概念。

LSTM 已被用于文本分类。我们使用 LSTM(香草 LSTM 或双向 LSTM)来构建文本分类器。首先，通过使用 word2vec 或 glove 等单词(语义)嵌入将文本语料库转换为数字。然后，通过 LSTM 进行序列分类。这种方法提供了比典型的单词包或 tf-idf 后跟 ML 分类器(如 SVM、随机森林)更高的准确性。在第十一章中，我们可以看到 LSTM 是如何被用作量词的。