Keras - 快速指南

Keras - 简介
深度学习是机器学习框架的主要子领域之一。机器学习是对算法设计的研究，其灵感来自于人脑模型。深度学习在机器人、人工智能（AI）、音频和视频识别以及图像识别等数据科学领域变得越来越流行。人工神经网络是深度学习方法的核心。深度学习受到 Theano、TensorFlow、Caffe、Mxnet 等各种库的支持，Keras 是最强大且易于使用的 Python 库之一，它构建在 TensorFlow、Theano 等流行的深度学习库之上。，用于创建深度学习模型。

Keras 概述

Keras 运行在 TensorFlow、Theano 或 Cognitive Toolkit (CNTK) 等开源机器库之上。Theano 是一个用于快速数值计算任务的 Python 库。TensorFlow 是最著名的符号数学库，用于创建神经网络和深度学习模型。TensorFlow 非常灵活，主要好处是分布式计算。CNTK是微软开发的深度学习框架。它使用 Python、C#、C++ 等库或独立的机器学习工具包。Theano 和 TensorFlow 是非常强大的库，但对于创建神经网络来说很难理解。

Keras 基于最小的结构，提供了一种干净、简单的方法来创建基于 TensorFlow 或 Theano 的深度学习模型。Keras 旨在快速定义深度学习模型。那么，Keras 是深度学习应用的最佳选择。

特征

Keras 利用各种优化技术使高级神经网络 API 变得更简单、性能更高。它支持以下功能 -

一致、简单且可扩展的 API。
最小的结构 - 无需任何装饰即可轻松实现结果。
它支持多个平台和后端。
它是一个用户友好的框架，可以在 CPU 和 GPU 上运行。
计算的高度可扩展性。

好处

Keras 是一个非常强大和动态的框架，具有以下优点 -

更大的社区支持。
易于测试。
Keras 神经网络是用 Python 编写的，这使得事情变得更简单。
Keras 支持卷积网络和循环网络。
深度学习模型是离散组件，因此可以以多种方式组合。

Keras - 安装

本章介绍如何在计算机上安装 Keras。在开始安装之前，让我们先了解一下 Keras 的基本要求。

先决条件

您必须满足以下要求 -

任何类型的操作系统（Windows、Linux 或 Mac）
Python 版本 3.5 或更高版本。

Python

Keras 是基于 python 的神经网络库，因此必须在您的计算机上安装 python。如果你的机器上正确安装了 python，那么打开你的终端并输入 python，你可以看到类似于下面指定的响应，

Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) 
[MSC v.1900 64 bit (AMD64)] on win32 
Type "help", "copyright", "credits" or "license" for more information. 
>>>

截至目前，最新版本是“3.7.2”。如果未安装 Python，请访问官方 python 链接 - www.python.org并根据您的操作系统下载最新版本并立即将其安装在您的系统上。

Keras安装步骤

Keras 安装非常简单。请按照以下步骤在您的系统上正确安装 Keras。

第1步：创建虚拟环境

Virtualenv用于管理不同项目的Python包。这将有助于避免破坏其他环境中安装的软件包。因此，始终建议在开发 Python 应用程序时使用虚拟环境。

Linux/Mac操作系统

Linux或Mac OS用户，进入您的项目根目录并输入以下命令来创建虚拟环境，

python3 -m venv kerasenv

执行上述命令后，将在安装位置创建包含bin、lib 和 include 文件夹的“kerasenv”目录。

Windows

Windows 用户可以使用以下命令，

py -m venv keras

第二步：激活环境

此步骤将在 shell 路径中配置 python 和 pip 可执行文件。

Linux/Mac操作系统

现在我们已经创建了一个名为“kerasvenv”的虚拟环境。移至该文件夹并键入以下命令，

$ cd kerasvenv kerasvenv $ source bin/activate

Windows

Windows 用户进入“kerasenv”文件夹并输入以下命令，

.\env\Scripts\activate

第 3 步：Python 库

Keras 依赖于以下 python 库。

麻木
pandas
Scikit-learn
Matplotlib
西皮
西博恩

希望您已在系统上安装了上述所有库。如果这些库都没有安装，那么使用下面的命令一一安装。

麻木

pip install numpy

您可以看到以下响应，

Collecting numpy 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
   numpy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

pandas

pip install pandas

我们可以看到以下响应，

Collecting pandas 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
pandas-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

绘图库

pip install matplotlib

我们可以看到以下响应，

Collecting matplotlib 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
matplotlib-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

scipy

pip install scipy

我们可以看到以下响应，

Collecting scipy 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8 
/scipy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

scikit学习

它是一个开源机器学习库。它用于分类、回归和聚类算法。在进行安装之前，需要以下内容 -

Python 3.5 或更高版本
NumPy 版本 1.11.0 或更高版本
SciPy 版本 0.17.0 或更高版本
joblib 0.11 或更高版本。

现在，我们使用以下命令安装 scikit-learn -

pip install -U scikit-learn

西博恩

Seaborn 是一个令人惊叹的库，可让您轻松可视化数据。使用以下命令进行安装 -

pip install seaborn

您可以看到类似如下所示的消息 -

Collecting seaborn 
   Downloading 
https://files.pythonhosted.org/packages/a8/76/220ba4420459d9c4c9c9587c6ce607bf56c25b3d3d2de62056efe482dadc 
/seaborn-0.9.0-py3-none-any.whl (208kB) 100% 
   |████████████████████████████████| 215kB 4.0MB/s 
Requirement already satisfied: numpy> = 1.9.3 in 
./lib/python3.7/site-packages (from seaborn) (1.17.0) 
Collecting pandas> = 0.15.2 (from seaborn) 
   Downloading 
https://files.pythonhosted.org/packages/39/b7/441375a152f3f9929ff8bc2915218ff1a063a59d7137ae0546db616749f9/ 
pandas-0.25.0-cp37-cp37m-macosx_10_9_x86_64.
macosx_10_10_x86_64.whl (10.1MB) 100% 
   |████████████████████████████████| 10.1MB 1.8MB/s 
Requirement already satisfied: scipy>=0.14.0 in 
./lib/python3.7/site-packages (from seaborn) (1.3.0) 
Collecting matplotlib> = 1.4.3 (from seaborn) 
   Downloading 
https://files.pythonhosted.org/packages/c3/8b/af9e0984f
5c0df06d3fab0bf396eb09cbf05f8452de4e9502b182f59c33b/ 
matplotlib-3.1.1-cp37-cp37m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64 
.macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 100% 
   |████████████████████████████████| 14.4MB 1.4MB/s 
...................................... 
...................................... 
Successfully installed cycler-0.10.0 kiwisolver-1.1.0 
matplotlib-3.1.1 pandas-0.25.0 pyparsing-2.4.2 
python-dateutil-2.8.0 pytz-2019.2 seaborn-0.9.0

使用 Python 安装 Keras

到目前为止，我们已经完成了 Kera 安装的基本要求。现在，使用与下面指定的相同过程安装 Keras -

pip install keras

退出虚拟环境

完成项目中的所有更改后，只需运行以下命令即可退出环境 -

deactivate

蟒蛇云

我们相信您已经在您的计算机上安装了 anaconda cloud。如果未安装anaconda，请访问官方链接www.anaconda.com/distribution，然后根据您的操作系统选择下载。

创建新的conda环境

启动 anaconda 提示符，这将打开 Anaconda 基础环境。让我们创建一个新的 conda 环境。这个过程和virtualenv类似。在 conda 终端中输入以下命令 -

conda create --name PythonCPU

如果需要，您也可以使用 GPU 创建和安装模块。在本教程中，我们遵循 CPU 指令。

激活conda环境

要激活环境，请使用以下命令 -

activate PythonCPU

安装spyder

Spyder 是一个用于执行 python 应用程序的 IDE。让我们使用以下命令在 conda 环境中安装此 IDE -

conda install spyder

安装Python库

我们已经知道keras所需的python库numpy、pandas等。您可以使用以下语法安装所有模块 -

句法

conda install -c anaconda <module-name>

例如，您想安装 pandas -

conda install -c anaconda pandas

同样的方法，自己尝试安装剩余的模块。

安装 Keras

现在，一切看起来都很好，因此您可以使用以下命令开始 keras 安装 -

conda install -c anaconda keras

启动间谍程序

最后，使用以下命令在 conda 终端中启动间谍程序 -

spyder

为了确保所有内容都正确安装，请导入所有模块，它将添加所有内容，如果出现任何问题，您将收到模块未找到错误消息。

Keras - 后端配置

本章详细介绍了 Keras 后端实现 TensorFlow 和 Theano。让我们一一过一遍每一个实现。

TensorFlow

TensorFlow 是 Google 开发的用于数值计算任务的开源机器学习库。Keras 是构建在 TensorFlow 或 Theano 之上的高级 API。我们已经知道如何使用 pip 安装 TensorFlow。

如果未安装，您可以使用以下命令进行安装 -

pip install TensorFlow

执行 keras 后，我们可以看到配置文件位于您的主目录中，并转到 .keras/keras.json。

keras.json

{ 
   "image_data_format": "channels_last", 
   "epsilon": 1e-07, "floatx": "float32", "backend": "tensorflow" 
}

这里，

image_data_format表示数据格式。
epsilon表示数值常数。它用于避免DivideByZero错误。
float x 表示默认数据类型float32。您还可以使用set_floatx()方法将其更改为float16或float64。
image_data_format表示数据格式。

假设，如果未创建文件，则移动到该位置并使用以下步骤创建 -

> cd home 
> mkdir .keras 
> vi keras.json

请记住，您应该指定 .keras 作为其文件夹名称，并将上述配置添加到 keras.json 文件中。我们可以执行一些预定义的操作来了解后端功能。

西阿诺

Theano 是一个开源深度学习库，可让您有效地评估多维数组。我们可以使用以下命令轻松安装 -

pip install theano

默认情况下，keras 使用 TensorFlow 后端。如果要将后端配置从 TensorFlow 更改为 Theano，只需更改 keras.json 文件中的 backend = theano 即可。描述如下 -

keras.json

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

现在保存您的文件，重新启动终端并启动 keras，您的后端将被更改。

>>> import keras as k 
using theano backend.

Keras - 深度学习概述

深度学习是机器学习的一个不断发展的子领域。深度学习涉及以逐层的方式分析输入，其中每一层逐步提取有关输入的更高级别的信息。

让我们看一个分析图像的简单场景。让我们假设您的输入图像被划分为矩形像素网格。现在，第一层抽象像素。第二层了解图像中的边缘。下一层从边缘构造节点。然后，下一步将从节点中找到分支。最后，输出层将检测完整的对象。在这里，特征提取过程从一层的输出进入下一层的输入。

通过使用这种方法，我们可以处理大量特征，这使得深度学习成为一个非常强大的工具。深度学习算法对于非结构化数据的分析也很有用。让我们在本章中回顾一下深度学习的基础知识。

人工神经网络

深度学习最流行和主要的方法是使用“人工神经网络”（ANN）。它们的灵感来自人脑模型，人脑是我们身体最复杂的器官。人类大脑由超过 900 亿个称为“神经元”的微小细胞组成。神经元通过称为“轴突”和“树突”的神经纤维相互连接。轴突的主要作用是将信息从一个神经元传输到与其连接的另一个神经元。

同样，树突的主要作用是接收与其连接的另一个神经元的轴突传输的信息。每个神经元处理一个小信息，然后将结果传递给另一个神经元，这个过程继续进行。这是我们人脑处理语音、视觉等大量信息并从中提取有用信息的基本方法。

基于这个模型，心理学家Frank Rosenblatt于 1958 年发明了第一个人工神经网络（ANN）。人工神经网络由多个类似于神经元的节点组成。节点紧密互连并组织成不同的隐藏层。输入层接收输入数据，数据依次经过一个或多个隐藏层，最后输出层预测有关输入数据的有用信息。例如，输入可能是图像，输出可能是图像中识别的事物，例如“猫”。

单个神经元（在人工神经网络中称为感知器）可以表示如下 -

这里，

多个输入和权重代表树突。
输入与激活函数的总和代表神经元。Sum实际上是所有输入的计算值，激活函数代表一个函数，它将Sum值修改为0、1或0到1。
实际输出代表轴突，输出将被下一层的神经元接收。

让我们在本节中了解不同类型的人工神经网络。

多层感知器

多层感知器是最简单的 ANN 形式。它由单个输入层、一个或多个隐藏层和最后一个输出层组成。一层由感知器的集合组成。输入层基本上是输入数据的一个或多个特征。每个隐藏层由一个或多个神经元组成，处理特征的某些方面并将处理后的信息发送到下一个隐藏层。输出层过程接收最后一个隐藏层的数据并最终输出结果。

卷积神经网络（CNN）

卷积神经网络是最流行的人工神经网络之一。广泛应用于图像、视频识别领域。它基于数学概念——卷积的概念。它几乎与多层感知器相似，只是它在全连接的隐藏神经元层之前包含一系列卷积层和池化层。它有三个重要的层 -

卷积层- 它是主要构建块，基于卷积函数执行计算任务。
池化层- 它布置在卷积层旁边，用于通过删除不必要的信息来减少输入的大小，以便可以更快地执行计算。
全连接层- 它被布置在一系列卷积层和池化层旁边，并将输入分类为各种类别。

一个简单的 CNN 可以表示如下 -

这里，

使用2系列卷积和池化层，它接收并处理输入（例如图像）。
使用单个全连接层并用于输出数据（例如图像分类）

循环神经网络 (RNN)

循环神经网络 (RNN) 可有效解决其他 ANN 模型中的缺陷。嗯，大多数人工神经网络不记得以前情况下的步骤，并学会根据训练中的上下文做出决策。同时，RNN 存储过去的信息，它的所有决策都是根据过去学到的知识做出的。

这种方法主要用于图像分类。有时，我们可能需要展望未来来解决过去的问题。在这种情况下，双向 RNN 有助于学习过去并预测未来。例如，我们在多个输入中有手写样本。假设我们对一个输入感到困惑，那么我们需要再次检查其他输入以识别从过去做出决定的正确上下文。

人工神经网络的工作流程

让我们首先了解深度学习的不同阶段，然后了解 Keras 在深度学习过程中如何提供帮助。

收集所需数据

深度学习需要大量输入数据才能成功学习和预测结果。因此，首先收集尽可能多的数据。

分析数据

分析数据并充分理解数据。选择正确的 ANN 算法需要更好地理解数据。

选择算法（模型）

选择最适合学习过程类型（例如图像分类、文本处理等）和可用输入数据的算法。算法在 Keras 中用Model来表示。算法包括一层或多层。ANN 中的每一层都可以用 Keras 中的Keras Layer来表示。

准备数据- 处理、过滤并仅从数据中选择所需的信息。
分割数据- 将数据分割为训练和测试数据集。测试数据将用于评估算法/模型的预测（一旦机器学习）并交叉检查学习过程的效率。
编译模型- 编译算法/模型，以便可以进一步用于通过训练学习并最终进行预测。这一步需要我们选择损失函数和优化器。损失函数和优化器用于在学习阶段找到误差（与实际输出的偏差）并进行优化，使误差最小化。
拟合模型- 实际的学习过程将在此阶段使用训练数据集完成。
未知值的预测结果- 预测未知输入数据的输出（现有训练和测试数据除外）
评估模型- 通过预测测试数据的输出并将预测与测试数据的实际结果进行交叉比较来评估模型。
冻结、修改或选择新算法- 检查模型评估是否成功。如果是，请保存算法以供将来预测之用。如果没有，则修改或选择新的算法/模型，最后再次训练、预测和评估模型。重复该过程，直到找到最佳算法（模型）。

上述步骤可以使用下面的流程图表示 -

Keras - 深度学习

Keras 提供了一个完整的框架来创建任何类型的神经网络。Keras 具有创新性并且非常容易学习。它支持简单的神经网络到非常大和复杂的神经网络模型。本章让我们了解 Keras 框架的架构以及 Keras 如何帮助深度学习。

Keras 的架构

Keras API 可以分为三个主要类别 -

模型
层
核心模块

在 Keras 中，每个 ANN 都由Keras 模型表示。反过来，每个 Keras 模型都是由Keras 层组成，代表 ANN 层，如输入、隐藏层、输出层、卷积层、池化层等，Keras 模型和层访问Keras 模块用于激活函数、损失函数、正则化函数、等，使用 Keras 模型、Keras Layer 和 Keras 模块，可以以简单高效的方式表示任何 ANN 算法（CNN、RNN 等）。

下图描述了模型、层和核心模块之间的关系 -

让我们看看 Keras 模型、Keras 层和 Keras 模块的概述。

模型

Keras 模型有两种类型，如下所述 -

序列模型- 序列模型基本上是 Keras 层的线性组合。序列模型简单、最小，并且能够表示几乎所有可用的神经网络。

一个简单的顺序模型如下 -

from keras.models import Sequential 
from keras.layers import Dense, Activation 

model = Sequential()  
model.add(Dense(512, activation = 'relu', input_shape = (784,)))

在哪里，

第 1 行从 Keras 模型导入Sequential模型
第2号线导入Dense层和Activation模块
第 4 行使用Sequential API创建一个新的顺序模型
第5行添加了带有relu激活（使用Activation模块）功能的密集层（Dense API）。

顺序模型也公开模型类来创建自定义模型。我们可以使用子类概念来创建我们自己的复杂模型。

功能 API - 功能 API 基本上用于创建复杂的模型。

层

Keras 模型中的每个 Keras 层代表实际提出的神经网络模型中的相应层（输入层、隐藏层和输出层）。Keras 提供了大量预构建层，以便可以轻松创建任何复杂的神经网络。下面指定了一些重要的 Keras 层，

核心层
卷积层
池化层
循环层

使用顺序模型表示神经网络模型的简单 python 代码如下 -

from keras.models import Sequential 
from keras.layers import Dense, Activation, Dropout model = Sequential() 

model.add(Dense(512, activation = 'relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2)) 
model.add(Dense(num_classes, activation = 'softmax'))

在哪里，

第 1 行从 Keras 模型导入Sequential模型
第2号线导入Dense层和Activation模块
第 4 行使用Sequential API创建一个新的顺序模型
第5行添加了带有relu激活（使用Activation模块）功能的密集层（Dense API）。
第 6 行添加了一个 dropout 层（Dropout API）来处理过度拟合。
第 7 行添加了另一个带有relu激活（使用 Activation 模块）功能的密集层（Dense API）。
第 8 行添加了另一个 dropout 层（Dropout API）来处理过度拟合。
第 9 行添加了带有softmax激活（使用激活模块）功能的最终密集层（Dense API）。

Keras 还提供了创建我们自己的自定义层的选项。可以通过对Keras.Layer类进行子类化来创建自定义层，这与对 Keras 模型进行子类化类似。

核心模块

Keras 还提供了很多内置的神经网络相关函数来正确创建 Keras 模型和 Keras 层。一些功能如下 -

激活模块- 激活函数是 ANN 中的一个重要概念，激活模块提供了许多激活函数，如 softmax、relu 等，
损失模块- 损失模块提供损失函数，如mean_squared_error、mean_absolute_error、poisson等，
优化器模块- 优化器模块提供优化器功能，如 adam、sgd 等，
正则化器- 正则化器模块提供 L1 正则化器、L2 正则化器等功能，

让我们在下一章详细学习 Keras 模块。

Keras - 模块

正如我们之前了解到的，Keras 模块包含对深度学习算法有用的预定义类、函数和变量。本章我们来学习Keras提供的模块。

可用模块

让我们首先看看 Keras 中可用的模块列表。

初始化器- 提供初始化器函数列表。我们可以在Keras层章节详细学习。在机器学习的模型创建阶段。
正则化器- 提供正则化器功能列表。我们可以在Keras Layers章节中详细了解它。
约束- 提供约束函数列表。我们可以在Keras Layers章节中详细了解它。
激活- 提供激活器功能列表。我们可以在Keras Layers章节中详细了解它。
损失- 提供损失函数列表。我们可以在模型训练章节详细了解。
指标- 提供指标函数列表。我们可以在模型训练章节详细了解。
优化器- 提供优化器功能列表。我们可以在模型训练章节详细了解。
回调- 提供回调函数列表。我们可以在训练过程中使用它来打印中间数据以及根据某些条件停止训练本身（ EarlyStopping方法）。
文本处理- 提供将文本转换为适合机器学习的 NumPy 数组的函数。我们可以在机器学习的数据准备阶段使用它。
图像处理- 提供将图像转换为适合机器学习的 NumPy 数组的函数。我们可以在机器学习的数据准备阶段使用它。
序列处理- 提供从给定输入数据生成基于时间的数据的功能。我们可以在机器学习的数据准备阶段使用它。
Backend - 提供后端库的功能，如TensorFlow和Theano。
实用程序- 提供许多在深度学习中有用的实用函数。

让我们在本章中看看后端模块和utils模型。

后端模块

backend模块用于 keras 后端操作。默认情况下，keras 在 TensorFlow 后端运行。如果需要，您可以切换到其他后端，例如 Theano 或 CNTK。默认后端配置在根目录中的 .keras/keras.json 文件下定义。

可以使用以下代码导入Keras后端模块

>>> from keras import backend as k

如果我们使用默认后端TensorFlow，则以下函数将返回基于TensorFlow的信息，如下所示 -

>>> k.backend() 
'tensorflow'
>>> k.epsilon() 
1e-07
>>> k.image_data_format() 
'channels_last'
>>> k.floatx() 
'float32'

让我们简要了解一些用于数据分析的重要后端函数 -

获取uid()

它是默认图表的标识符。它的定义如下 -

>>> k.get_uid(prefix='') 
1 
>>> k.get_uid(prefix='') 2

重置用户ID

它用于重置 uid 值。

>>> k.reset_uids()

现在，再次执行get_uid()。这将被重置并再次更改为 1。

>>> k.get_uid(prefix='') 
1

占位符

它用于实例化占位符张量。保存 3D 形状的简单占位符如下所示 -

>>> data = k.placeholder(shape = (1,3,3)) 
>>> data 
<tf.Tensor 'Placeholder_9:0' shape = (1, 3, 3) dtype = float32> 

If you use int_shape(), it will show the shape. 

>>> k.int_shape(data) (1, 3, 3)

点

它用于将两个张量相乘。考虑 a 和 b 是两个张量，c 将是 ab 相乘的结果。假设a形状为(4,2)，b形状为(2,3)。它的定义如下，

>>> a = k.placeholder(shape = (4,2)) 
>>> b = k.placeholder(shape = (2,3)) 
>>> c = k.dot(a,b) 
>>> c 
<tf.Tensor 'MatMul_3:0' shape = (4, 3) dtype = float32> 
>>>

那些

它用于将所有内容初始化为一个值。

>>> res = k.ones(shape = (2,2)) 

#print the value 

>>> k.eval(res) 
array([[1., 1.], [1., 1.]], dtype = float32)

批处理点

用于批量执行两个数据的乘积。输入维度必须为 2 或更高。如下所示 -

>>> a_batch = k.ones(shape = (2,3)) 
>>> b_batch = k.ones(shape = (3,2)) 
>>> c_batch = k.batch_dot(a_batch,b_batch) 
>>> c_batch 
<tf.Tensor 'ExpandDims:0' shape = (2, 1) dtype = float32>

多变的

它用于初始化变量。让我们对此变量执行简单的转置操作。

>>> data = k.variable([[10,20,30,40],[50,60,70,80]]) 
#variable initialized here 
>>> result = k.transpose(data) 
>>> print(result) 
Tensor("transpose_6:0", shape = (4, 2), dtype = float32) 
>>> print(k.eval(result)) 
   [[10. 50.] 
   [20. 60.] 
   [30. 70.] 
   [40. 80.]]

如果你想从 numpy 访问 -

>>> data = np.array([[10,20,30,40],[50,60,70,80]]) 

>>> print(np.transpose(data)) 
   [[10 50] 
   [20 60] 
   [30 70] 
   [40 80]] 

>>> res = k.variable(value = data) 
>>> print(res) 
<tf.Variable 'Variable_7:0' shape = (2, 4) dtype = float32_ref>

is_sparse（张量）

它用于检查张量是否稀疏。

>>> a = k.placeholder((2, 2), sparse=True) 

>>> print(a) SparseTensor(indices =       
   Tensor("Placeholder_8:0", 
   shape = (?, 2), dtype = int64), 
values = Tensor("Placeholder_7:0", shape = (?,), 
dtype = float32), dense_shape = Tensor("Const:0", shape = (2,), dtype = int64)) 

>>> print(k.is_sparse(a)) True

to_dense()

它用于将稀疏转换为密集。

>>> b = k.to_dense(a) 
>>> print(b) Tensor("SparseToDense:0", shape = (2, 2), dtype = float32) 
>>> print(k.is_sparse(b)) False

随机均匀变量

它用于使用均匀分布概念进行初始化。

k.random_uniform_variable(shape, mean, scale)

这里，

shape - 表示元组格式的行和列。
平均值- 均匀分布的平均值。
尺度- 均匀分布的标准差。

让我们看一下下面的示例用法 -

>>> a = k.random_uniform_variable(shape = (2, 3), low=0, high = 1) 
>>> b = k. random_uniform_variable(shape = (3,2), low = 0, high = 1) 
>>> c = k.dot(a, b) 
>>> k.int_shape(c) 
(2, 2)

实用程序模块

utils为深度学习提供了有用的实用函数。utils模块提供的一些方法如下 -

HDF5矩阵

它用于表示 HDF5 格式的输入数据。

from keras.utils import HDF5Matrix data = HDF5Matrix('data.hdf5', 'data')

分类

它用于将类向量转换为二进制类矩阵。

>>> from keras.utils import to_categorical 
>>> labels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> to_categorical(labels) 
array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]], dtype = float32)
>>> from keras.utils import normalize 
>>> normalize([1, 2, 3, 4, 5]) 
array([[0.13483997, 0.26967994, 0.40451992, 0.53935989, 0.67419986]])

打印摘要

它用于打印模型的摘要。

from keras.utils import print_summary print_summary(model)

绘图模型

它用于创建点格式的模型表示并将其保存到文件中。

from keras.utils import plot_model 
plot_model(model,to_file = 'image.png')

该plot_model将生成图像以了解模型的性能。

Keras - 层

如前所述，Keras 层是 Keras 模型的主要构建块。每层接收输入信息，进行一些计算，最后输出转换后的信息。一层的输出将流入下一层作为其输入。让我们在本章中了解有关层的完整详细信息。

介绍

Keras 层需要输入的形状 (input_shape)来理解输入数据的结构，需要初始化器来设置每个输入的权重，最后需要激活器来转换输出以使其非线性。在两者之间，约束限制并指定要生成的输入数据的权重的范围，并且正则化器将在优化过程中通过动态地对权重应用惩罚来尝试优化层（和模型）。

总而言之，Keras 层需要以下最少的细节来创建完整的层。

输入数据的形状
层中神经元/单元的数量
初始化器
正则化器
约束条件
激活

让我们在下一章中了解基本概念。在了解基本概念之前，让我们使用 Sequential 模型 API 创建一个简单的 Keras 层，以了解 Keras 模型和层的工作原理。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
from keras import regularizers 
from keras import constraints 

model = Sequential() 

model.add(Dense(32, input_shape=(16,), kernel_initializer = 'he_uniform', 
   kernel_regularizer = None, kernel_constraint = 'MaxNorm', activation = 'relu')) 
model.add(Dense(16, activation = 'relu')) 
model.add(Dense(8))

在哪里，

第 1-5 行导入必要的模块。
第 7 行使用 Sequential API 创建一个新模型。
第 9 行创建一个新的Dense层并将其添加到模型中。Dense是 Keras 提供的入门级层，它接受神经元或单元的数量 (32) 作为其所需参数。如果该层是第一层，那么我们还需要提供输入形状（16，）。否则，前一层的输出将用作下一层的输入。所有其他参数都是可选的。
- 第一个参数表示单元（神经元）的数量。
- input_shape表示输入数据的形状。
- kernel_initializer表示要使用的初始化程序。he_uniform函数设置为值。
- kernel_regularizer表示要使用的正则化器。没有设置为值。
- kernel_constraint表示要使用的约束。MaxNorm函数设置为值。
- 激活代表要使用的激活。relu 函数设置为值。
第 10 行创建了包含 16 个单元的第二个Dense层，并将relu设置为激活函数。
第 11 行创建了包含 8 个单元的最终 Dense 层。

层的基本概念

让我们了解层的基本概念以及 Keras 如何支持每个概念。

输入形状

在机器学习中，所有类型的输入数据（例如文本、图像或视频）将首先转换为数字数组，然后输入算法。输入数字可以是一维数组、二维数组（矩阵）或多维数组。我们可以使用shape（整数元组）来指定维度信息。例如，(4,2)表示四行两列的矩阵。

>>> import numpy as np 
>>> shape = (4, 2) 
>>> input = np.zeros(shape) 
>>> print(input) 
[
   [0. 0.] 
   [0. 0.] 
   [0. 0.] 
   [0. 0.]
] 
>>>

类似地，(3,4,2)三维矩阵具有三个 4x2 矩阵的集合（两行四列）。

>>> import numpy as np 
>>> shape = (3, 4, 2) 
>>> input = np.zeros(shape) 
>>> print(input)
[
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]] 
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]] 
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
]
>>>

要创建模型的第一层（或模型的输入层），应指定输入数据的形状。

初始化器

在机器学习中，权重将分配给所有输入数据。Initializers模块提供了不同的函数来设置这些初始权重。Keras 初始化程序的一些函数如下 -

零点

为所有输入数据生成0 。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Zeros() 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

其中，kernel_initializer表示模型内核的初始化程序。

那些

为所有输入数据生成1 。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Ones() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

持续的

生成用户为所有输入数据指定的常量值（例如5 ）。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Constant(value = 0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

其中，value代表常数值

随机正态

使用输入数据的正态分布生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.RandomNormal(mean=0.0, 
stddev = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

在哪里，

Mean表示要生成的随机值的平均值
stddev表示要生成的随机值的标准差
种子代表生成随机数的值

随机均匀

使用输入数据的均匀分布生成值。

from keras import initializers 

my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

在哪里，

minval表示要生成的随机值的下限
maxval表示要生成的随机值的上限

截断法线

使用输入数据的截断正态分布生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.TruncatedNormal(mean = 0.0, stddev = 0.05, seed = None
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

方差缩放

根据图层的输入形状和输出形状以及指定的比例生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.VarianceScaling(
   scale = 1.0, mode = 'fan_in', distribution = 'normal', seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   skernel_initializer = my_init))

在哪里，

scale表示缩放因子
mode表示fan_in、fan_out和fan_avg值中的任何一个
分布代表正态分布或均匀分布

方差缩放

它使用以下公式查找正态分布的stddev值，然后使用正态分布查找权重，

stddev = sqrt(scale / n)

其中n代表，

mode 的输入单元数量 = fan_in
模式的输出单元数 = fan_out
模式的输入和输出单元的平均数量 = fan_avg

类似地，它使用以下公式找到均匀分布的极限，然后使用均匀分布找到权重，

limit = sqrt(3 * scale / n)

lecun_正常

使用输入数据的 lecun 正态分布生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

它使用以下公式找到stddev，然后应用正态分布

stddev = sqrt(1 / fan_in)

其中，fan_in表示输入单元的数量。

lecun_制服

使用输入数据的 lecun 均匀分布生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.lecun_uniform(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

它使用以下公式找到极限，然后应用均匀分布

limit = sqrt(3 / fan_in)

在哪里，

fan_in表示输入单元的数量
fan_out表示输出单元的数量

glorot_正常

使用输入数据的 glorot 正态分布生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.glorot_normal(seed=None) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

它使用以下公式找到stddev，然后应用正态分布

stddev = sqrt(2 / (fan_in + fan_out))

在哪里，

fan_in表示输入单元的数量
fan_out表示输出单元的数量

glorot_制服

使用输入数据的 glorot 均匀分布生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.glorot_uniform(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

它使用以下公式找到极限，然后应用均匀分布

limit = sqrt(6 / (fan_in + fan_out))

在哪里，

fan_in表示输入单元的数量。
fan_out表示输出单元的数量

他_正常

使用输入数据的正态分布生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

它使用以下公式查找stddev，然后应用正态分布。

stddev = sqrt(2 / fan_in)

其中，fan_in表示输入单元的数量。

他_制服

使用输入数据的均匀分布生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.he_normal(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

它使用以下公式找到极限，然后应用均匀分布。

limit = sqrt(6 / fan_in)

其中，fan_in表示输入单元的数量。

正交

生成随机正交矩阵。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Orthogonal(gain = 1.0, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

其中，gain表示矩阵的乘法因子。

身份

生成单位矩阵。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Identity(gain = 1.0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

约束条件

在机器学习中，优化阶段会对参数（权重）设置约束。<>Constraints模块提供了不同的函数来设置图层上的约束。一些约束函数如下。

非负

将权重限制为非负数。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Identity(gain = 1.0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init)
)

其中，kernel_constraint表示要在该层中使用的约束。

单位标准

将权重限制为单位范数。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 

my_constrain = constraints.UnitNorm(axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

最大范数

将权重限制为小于或等于给定值的范数。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 

my_constrain = constraints.MaxNorm(max_value = 2, axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

在哪里，

max_value代表上限
axis表示要应用约束的维度。例如，在形状 (2,3,4) 中，轴 0 表示第一维，1 表示第二维，2 表示第三维

最小最大范数

将权重限制为指定最小值和最大值之间的范数。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 

my_constrain = constraints.MinMaxNorm(min_value = 0.0, max_value = 1.0, rate = 1.0, axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

其中，rate表示应用权重约束的速率。

正则化器

在机器学习中，正则化器用于优化阶段。它在优化期间对层参数施加一些惩罚。Keras 正则化模块提供以下函数来设置层上的惩罚。正则化仅适用于每层。

L1正则化器

它提供基于 L1 的正则化。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 

my_regularizer = regularizers.l1(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_regularizer = my_regularizer))

其中，kernel_regularizer表示应用权重约束的速率。

L2正则化器

它提供基于 L2 的正则化。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 

my_regularizer = regularizers.l2(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_regularizer = my_regularizer))

L1 和 L2 正则化器

它提供基于 L1 和 L2 的正则化。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 

my_regularizer = regularizers.l2(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,),
   kernel_regularizer = my_regularizer))

激活

在机器学习中，激活函数是一种特殊函数，用于确定特定神经元是否被激活。基本上，激活函数对输入数据进行非线性变换，从而使神经元能够更好地学习。神经元的输出取决于激活函数。

当您回想起单一感知的概念时，感知器（神经元）的输出只是激活函数的结果，它接受所有输入乘以相应权重加上总体偏差（如果有）的总和。

result = Activation(SUMOF(input * weight) + bias)

因此，激活函数对于模型的成功学习起着重要作用。Keras 在激活模块中提供了很多激活函数。让我们了解该模块中所有可用的激活。

线性

应用线性函数。什么也没做。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'linear', input_shape = (784,)))

其中，激活指的是该层的激活函数。可以简单地通过函数名称来指定，并且该层将使用相应的激活器。

埃卢

应用指数线性单位。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'elu', input_shape = (784,)))

塞卢

应用缩放指数线性单位。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'selu', input_shape = (784,)))

雷卢

应用修正线性单位。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,)))

软最大

应用 Softmax 函数。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))

软加

应用 Softplus 功能。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))

软签名

应用软签名功能。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))

正值

应用双曲正切函数。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))

乙状结肠

应用 Sigmoid 函数。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))

硬乙状结肠

应用硬 Sigmoid 函数。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'hard_sigmoid', input_shape = (784,)))

指数

应用指数函数。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))

先生编号	图层和描述
1	致密层密集层是常规的深度连接的神经网络层。
2	漏失层 *Dropout*是机器学习中的重要概念之一。
3	展平图层 Flatten用于压平输入。
4	重塑图层 *Reshape*用于更改输入的形状。
5	排列层排列还用于使用模式更改输入的形状。
6	重复向量层 *RepeatVector*用于将输入重复设定次数 n 次。
7	Lambda 层 *Lambda*用于使用表达式或函数转换输入数据。
8	卷积层 Keras 包含许多用于创建基于卷积的 ANN 的层，通常称为卷积神经网络 (CNN)。
9	池化层它用于对时态数据执行最大池化操作。
10	局部连接层局部连接层与 Conv1D 层类似，但不同之处在于 Conv1D 层权重是共享的，但这里权重是不共享的。
11	合并层它用于合并输入列表。
12	嵌入层它在输入层执行嵌入操作。

Keras - 定制层

Keras 允许创建我们自己的自定义层。一旦创建了新层，它就可以在任何模型中使用，没有任何限制。让我们学习如何创造新的l