keras安装与配置指南_Keras-快速指南

Baste · 发表于 2022-6-24 14:58

[img=403px,256px]https://img-blog.csdnimg.cn/img_convert/d92968972ba1a7762b06acfe1a237f05.png[/img]

keras安装与配置指南
Keras-快速指南 (Keras - Quick Guide)

Keras-简介 (Keras - Introduction )

Deep learning is one of the major subfield of machine learning framework. Machine learning is the study of design of algorithms, inspired from the model of human brain. Deep learning is becoming more popular in data science fields like robotics, artificial intelligence(AI), audio & video recognition and image recognition. Artificial neural network is the core of deep learning methodologies. Deep learning is supported by various libraries such as Theano, TensorFlow, Caffe, Mxnet etc., Keras is one of the most powerful and easy to use python library, which is built on top of popular deep learning libraries like TensorFlow, Theano, etc., for creating deep learning models.
深度学习是机器学习框架的主要子领域之一。机器学习是受人脑模型启发而进行的算法设计研究。深度学习在机器人，人工智能(AI)，音频和视频识别以及图像识别等数据科学领域正变得越来越流行。人工神经网络是深度学习方法的核心。深度学习受到Theano，TensorFlow，Caffe，Mxnet等各种库的支持，Keras是功能最强大且易于使用的python库之一，它基于流行的深度学习库如TensorFlow，Theano等构建。，用于创建深度学习模型。
Keras概述 (Overview of Keras)

Keras runs on top of open source machine libraries like TensorFlow, Theano or Cognitive Toolkit (CNTK). Theano is a python library used for fast numerical computation tasks. TensorFlow is the most famous symbolic math library used for creating neural networks and deep learning models. TensorFlow is very flexible and the primary benefit is distributed computing. CNTK is deep learning framework developed by Microsoft. It uses libraries such as Python, C#, C++ or standalone machine learning toolkits. Theano and TensorFlow are very powerful libraries but difficult to understand for creating neural networks.
Keras在TensorFlow，Theano或Cognitive Toolkit(CNTK)等开源机器库之上运行。 Theano是用于快速数值计算任务的python库。 TensorFlow是用于创建神经网络和深度学习模型的最著名的符号数学库。 TensorFlow非常灵活，主要优势是分布式计算。 CNTK是Microsoft开发的深度学习框架。它使用Python，C＃，C ++或独立的机器学习工具包之类的库。 Theano和TensorFlow是非常强大的库，但是对于创建神经网络却很难理解。
Keras is based on minimal structure that provides a clean and easy way to create deep learning models based on TensorFlow or Theano. Keras is designed to quickly define deep learning models. Well, Keras is an optimal choice for deep learning applications.
Keras基于最小的结构，它提供了一种干净，简便的方法来创建基于TensorFlow或Theano的深度学习模型。 Keras旨在快速定义深度学习模型。好吧，Keras是深度学习应用程序的最佳选择。
特征 (Features)

Keras leverages various optimization techniques to make high level neural network API easier and more performant. It supports the following features ?
Keras利用各种优化技术来简化高级神经网络API，并提高其性能。它支持以下功能-

好处 (Benefits)

Keras is highly powerful and dynamic framework and comes up with the following advantages ?
Keras是一个功能强大且动态的框架，具有以下优点-

Keras-安装 (Keras - Installation)

This chapter explains about how to install Keras on your machine. Before moving to installation, let us go through the basic requirements of Keras.
本章介绍了如何在计算机上安装Keras。在进行安装之前，让我们先了解Keras的基本要求。
先决条件 (Prerequisites)

You must satisfy the following requirements ?
您必须满足以下要求-

Python (Python)

Keras is python based neural network library so python must be installed on your machine. If python is properly installed on your machine, then open your terminal and type python, you could see the response similar as specified below,
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.
>>>

复制代码

As of now the latest version is ‘3.7.2’. If Python is not installed, then visit the official python link - www.python.org and download the latest version based on your OS and install it immediately on your system.
截至目前，最新版本为“ 3.7.2”。如果未安装Python，请访问官方python链接-www.python.org并根据您的操作系统下载最新版本，然后立即将其安装在系统上。
Keras安装步骤 (Keras Installation Steps)

Keras installation is quite easy. Follow below steps to properly install Keras on your system.
Keras的安装非常简单。请按照以下步骤在系统上正确安装Keras。
步骤1：创建虚拟环境 (Step 1: Create virtual environment)

Virtualenv is used to manage Python packages for different projects. This will be helpful to avoid breaking the packages installed in the other environments. So, it is always recommended to use a virtual environment while developing Python applications.
Virtualenv用于管理不同项目的Python软件包。这将有助于避免破坏在其他环境中安装的软件包。因此，始终建议在开发Python应用程序时使用虚拟环境。
Linux/Mac OS
Linux / Mac OS
Linux or mac OS users, go to your project root directory and type the below command to create virtual environment,
Linux或Mac OS用户，请转到您的项目根目录，然后键入以下命令以创建虚拟环境，

python3 -m venv kerasenv

复制代码

After executing the above command, “kerasenv” directory is created with bin,lib and include folders in your installation location.
执行上述命令后，将使用bin，lib创建“ kerasenv”目录，并在您的安装位置包含文件夹 。
Windows
视窗
Windows user can use the below command,
Windows用户可以使用以下命令，

py -m venv keras

复制代码

步骤2：激活环境 (Step 2: Activate the environment)

This step will configure python and pip executables in your shell path.
此步骤将在您的Shell路径中配置python和pip可执行文件。
Linux/Mac OS
Linux / Mac OS
Now we have created a virtual environment named “kerasvenv”. Move to the folder and type the below command,
现在，我们创建了一个名为“ kerasvenv”的虚拟环境。移至该文件夹并输入以下命令，

$ cd kerasvenv kerasvenv $ source bin/activate

复制代码

Windows
视窗
Windows users move inside the “kerasenv” folder and type the below command,
Windows用户进入“ kerasenv”文件夹，然后输入以下命令，

.\env\Scripts\activate

复制代码

步骤3：Python库 (Step 3: Python libraries)

Keras depends on the following python libraries.
Keras依赖于以下python库。

Hopefully, you have installed all the above libraries on your system. If these libraries are not installed, then use the below command to install one by one.
希望您已在系统上安装了上述所有库。如果未安装这些库，请使用以下命令逐一安装。
numpy
麻木

pip install numpy

复制代码

you could see the following response,
您会看到以下回复，

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

复制代码

We could see the following response,
我们可以看到以下回应，

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

复制代码

matplotlib
matplotlib

pip install matplotlib

复制代码

We could see the following response,
我们可以看到以下回应，

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

复制代码

We could see the following response,
我们可以看到以下回应，

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-learn
scikit学习
It is an open source machine learning library. It is used for classification, regression and clustering algorithms. Before moving to the installation, it requires the following ?
这是一个开放源代码的机器学习库。它用于分类，回归和聚类算法。进行安装之前，需要满足以下条件：

Now, we install scikit-learn using the below command ?
现在，我们使用以下命令安装scikit-learn-

pip install -U scikit-learn

复制代码

Seaborn
Seaborn
Seaborn is an amazing library that allows you to easily visualize your data. Use the below command to install ?
Seaborn是一个了不起的库，可让您轻松地可视化数据。使用以下命令安装-

pip pip install seaborninstall -U scikit-learn

复制代码

You could see the message similar as specified below ?
您可能会看到类似以下内容的消息-

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 (Keras Installation Using Python)

As of now, we have completed basic requirements for the installtion of Kera. Now, install the Keras using same procedure as specified below ?
到目前为止，我们已经完成了安装Kera的基本要求。现在，使用下面指定的相同步骤安装Keras-

pip install keras

复制代码

退出虚拟环境 (Quit virtual environment)

After finishing all your changes in your project, then simply run the below command to quit the environment ?
完成项目中的所有更改后，只需运行以下命令即可退出环境-

deactivate

复制代码

Python云 (Anaconda Cloud)

We believe that you have installed anaconda cloud on your machine. If anaconda is not installed, then visit the official link, www.anaconda.com/distribution and choose download based on your OS.
我们相信您已在计算机上安装了anaconda云。如果未安装anaconda，请访问官方链接www.anaconda.com/distribution ，然后根据您的操作系统选择下载。
创建一个新的conda环境 (Create a new conda environment)

Launch anaconda prompt, this will open base Anaconda environment. Let us create a new conda environment. This process is similar to virtualenv. Type the below command in your conda terminal ?
启动anaconda提示，这将打开基本的Anaconda环境。让我们创建一个新的conda环境。此过程类似于virtualenv。在conda终端中输入以下命令-

conda create --name PythonCPU

复制代码

If you want, you can create and install modules using GPU also. In this tutorial, we follow CPU instructions.
如果需要，您还可以使用GPU创建和安装模块。在本教程中，我们遵循CPU指令。
激活conda环境 (Activate conda environment)

To activate the environment, use the below command ?
要激活环境，请使用以下命令-

activate PythonCPU

复制代码

安装间谍 (Install spyder)

Spyder is an IDE for executing python applications. Let us install this IDE in our conda environment using the below command ?
Spyder是用于执行python应用程序的IDE。让我们使用以下命令在conda环境中安装此IDE-

conda install spyder

复制代码

安装python库 (Install python libraries)

We have already known the python libraries numpy, pandas, etc., needed for keras. You can install all the modules by using the below syntax ?
我们已经知道keras需要的python库numpy，pandas等。您可以使用以下语法安装所有模块-
Syntax
句法

conda install -c anaconda <module-name>

复制代码

For example, you want to install pandas ?
例如，您要安装熊猫-

conda install -c anaconda pandas

复制代码

Like the same method, try it yourself to install the remaining modules.
与相同的方法一样，请自己尝试安装其余模块。
安装Keras (Install Keras)

Now, everything looks good so you can start keras installation using the below command ?
现在，一切看起来都不错，因此您可以使用以下命令开始安装keras-

conda install -c anaconda keras

复制代码

发射间谍 (Launch spyder)

Finally, launch spyder in your conda terminal using the below command ?
最后，使用以下命令在conda终端中启动spyder-

spyder

复制代码

To ensure everything was installed correctly, import all the modules, it will add everything and if anything went wrong, you will get module not found error message.
为确保所有组件均已正确安装，请导入所有模块，它将添加所有组件，如果出现任何错误，您将收到未找到模块的错误消息。

Keras-后端配置 (Keras - Backend Configuration)

This chapter explains Keras backend implementations TensorFlow and Theano in detail. Let us go through each implementation one by one.
本章详细说明Keras后端实现TensorFlow和Theano。让我们逐一介绍每个实现。
TensorFlow (TensorFlow)

TensorFlow is an open source machine learning library used for numerical computational tasks developed by Google. Keras is a high level API built on top of TensorFlow or Theano. We know already how to install TensorFlow using pip.
TensorFlow是一个开源的机器学习库，用于Google开发的数值计算任务。 Keras是建立在TensorFlow或Theano之上的高级API。我们已经知道如何使用pip安装TensorFlow。
If it is not installed, you can install using the below command ?
如果尚未安装，则可以使用以下命令进行安装-

pip install TensorFlow

复制代码

Once we execute keras, we could see the configuration file is located at your home directory inside and go to .keras/keras.json.
执行keras后，我们可以看到配置文件位于您的主目录中，并转到.keras / keras.json。
keras.json (keras.json)

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

复制代码

Here,
这里，

image_data_format

epsilon

DivideByZero

epsilon

DivideByZero

float

float32

float16

float64

set_floatx()

float

float32

set_floatx()

float16

float64

image_data_format

Suppose, if the file is not created then move to the location and create using the below steps ?
假设，如果未创建文件，则移动到该位置并使用以下步骤创建-

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

复制代码

Remember, you should specify .keras as its folder name and add the above configuration inside keras.json file. We can perform some pre-defined operations to know backend functions.
请记住，您应该指定.keras作为其文件夹名称，并将上述配置添加到keras.json文件中。我们可以执行一些预定义的操作来了解后端功能。
茶野 (Theano)

Theano is an open source deep learning library that allows you to evaluate multi-dimensional arrays effectively. We can easily install using the below command ?
Theano是一个开源深度学习库，可让您有效地评估多维数组。我们可以使用以下命令轻松安装-

pip install theano

复制代码

By default, keras uses TensorFlow backend. If you want to change backend configuration from TensorFlow to Theano, just change the backend = theano in keras.json file. It is described below ?
默认情况下，keras使用TensorFlow后端。如果要将后端配置从TensorFlow更改为Theano，只需在keras.json文件中更改backend = theano。它在下面描述-
keras.json (keras.json)

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

复制代码

Now save your file, restart your terminal and start keras, your backend will be changed.
现在保存文件，重新启动终端并启动keras，您的后端将被更改。

>>> import keras as k
using theano backend.

复制代码

Keras-深度学习概述 (Keras - Overview of Deep learning)

Deep learning is an evolving subfield of machine learning. Deep learning involves analyzing the input in layer by layer manner, where each layer progressively extracts higher level information about the input.
深度学习是机器学习的一个不断发展的子领域。深度学习涉及逐层分析输入，其中每一层逐步提取有关输入的更高级别的信息。
Let us take a simple scenario of analyzing an image. Let us assume that your input image is divided up into a rectangular grid of pixels. Now, the first layer abstracts the pixels. The second layer understands the edges in the image. The Next layer constructs nodes from the edges. Then, the next would find branches from the nodes. Finally, the output layer will detect the full object. Here, the feature extraction process goes from the output of one layer into the input of the next subsequent layer.
让我们以分析图像的简单场景为例。让我们假设您的输入图像被分成像素的矩形网格。现在，第一层提取像素。第二层了解图像中的边缘。下一步层从边缘构造节点。然后，下一个将从节点中找到分支。最后，输出层将检测到整个对象。在这里，特征提取过程从一层的输出转到下一个下一层的输入。
By using this approach, we can process huge amount of features, which makes deep learning a very powerful tool. Deep learning algorithms are also useful for the analysis of unstructured data. Let us go through the basics of deep learning in this chapter.
通过使用这种方法，我们可以处理大量功能，这使深度学习成为非常强大的工具。深度学习算法对于非结构化数据的分析也很有用。让我们在本章中学习深度学习的基础知识。
人工神经网络 (Artificial Neural Networks)

The most popular and primary approach of deep learning is using “Artificial neural network” (ANN). They are inspired from the model of human brain, which is the most complex organ of our body. The human brain is made up of more than 90 billion tiny cells called “Neurons”. Neurons are inter-connected through nerve fiber called “axons” and “Dendrites”. The main role of axon is to transmit information from one neuron to another to which it is connected.
深度学习最流行和最主要的方法是使用“人工神经网络”(ANN)。它们的灵感来自人类大脑的模型，这是人体最复杂的器官。人脑由超过900亿个称为“神经元”的微小细胞组成。神经元通过称为“轴突”和“树突”的神经纤维相互连接。轴突的主要作用是将信息从一个神经元传递到与其连接的另一神经元。
Similarly, the main role of dendrites is to receive the information being transmitted by the axons of another neuron to which it is connected. Each neuron processes a small information and then passes the result to another neuron and this process continues. This is the basic method used by our human brain to process huge about of information like speech, visual, etc., and extract useful information from it.
同样，树突的主要作用是接收与之相连的另一个神经元的轴突传递的信息。每个神经元处理少量信息，然后将结果传递给另一个神经元，此过程继续进行。这是人脑处理大量信息(如语音，视觉等)并从中提取有用信息的基本方法。
Based on this model, the first Artificial Neural Network (ANN) was invented by psychologist Frank Rosenblatt, in the year of 1958. ANNs are made up of multiple nodes which is similar to neurons. Nodes are tightly interconnected and organized into different hidden layers. The input layer receives the input data and the data goes through one or more hidden layers sequentially and finally the output layer predict something useful about the input data. For example, the input may be an image and the output may be the thing identified in the image, say a “Cat”.
基于此模型，心理学家Frank Rosenblatt于1958年发明了第一个人工神经网络。人工神经网络由类似于神经元的多个节点组成。节点紧密互连，并组织成不同的隐藏层。输入层接收输入数据，数据依次经过一个或多个隐藏层，最后输出层预测有关输入数据的有用信息。例如，输入可以是图像，而输出可以是图像中标识的东西，例如“猫”。
A single neuron (called as perceptron in ANN) can be represented as below ?
单个神经元(在ANN中称为感知器)可以表示如下-

Here,
这里，

Sum

Let us understand different types of artificial neural networks in this section.
让我们在本节中了解不同类型的人工神经网络。
多层感知器 (Multi-Layer Perceptron)

Multi-Layer perceptron is the simplest form of ANN. It consists of a single input layer, one or more hidden layer and finally an output layer. A layer consists of a collection of perceptron. Input layer is basically one or more features of the input data. Every hidden layer consists of one or more neurons and process certain aspect of the feature and send the processed information into the next hidden layer. The output layer process receives the data from last hidden layer and finally output the result.
多层感知器是ANN的最简单形式。它由一个输入层，一个或多个隐藏层以及最后一个输出层组成。一层由感知器集合组成。输入层基本上是输入数据的一个或多个特征。每个隐藏层由一个或多个神经元组成，并处理特征的某些方面，并将处理后的信息发送到下一个隐藏层。输出层进程从最后一个隐藏层接收数据，最后输出结果。

卷积神经网络(CNN) (Convolutional Neural Network (CNN))

Convolutional neural network is one of the most popular ANN. It is widely used in the fields of image and video recognition. It is based on the concept of convolution, a mathematical concept. It is almost similar to multi-layer perceptron except it contains series of convolution layer and pooling layer before the fully connected hidden neuron layer. It has three important layers ?
卷积神经网络是最流行的人工神经网络之一。它广泛应用于图像和视频识别领域。它基于数学概念卷积的概念。它几乎与多层感知器相似，不同之处在于它在完全连接的隐藏神经元层之前包含一系列卷积层和池化层。它具有三个重要的层-

Convolution layer

卷积层

Pooling layer

池层

Fully connected layer

完全连接的层

A simple CNN can be represented as below ?
一个简单的CNN可以表示如下-

Here,
这里，

递归神经网络(RNN) (Recurrent Neural Network (RNN))

Recurrent Neural Networks (RNN) are useful to address the flaw in other ANN models. Well, Most of the ANN doesn’t remember the steps from previous situations and learned to make decisions based on context in training. Meanwhile, RNN stores the past information and all its decisions are taken from what it has learnt from the past.
递归神经网络(RNN)对于解决其他ANN模型中的缺陷很有用。好吧，大多数ANN都不记得以前的情况，而是学会根据训练中的情境做出决策。同时，RNN存储了过去的信息，其所有决策都是从过去的经验中学到的。
This approach is mainly useful in image classification. Sometimes, we may need to look into the future to fix the past. In this case bidirectional RNN is helpful to learn from the past and predict the future. For example, we have handwritten samples in multiple inputs. Suppose, we have confusion in one input then we need to check again other inputs to recognize the correct context which takes the decision from the past.
该方法主要用于图像分类。有时，我们可能需要展望未来以修正过去。在这种情况下，双向RNN有助于从过去学习和预测未来。例如，我们有多个输入的手写样本。假设我们在一个输入中有混淆，然后我们需要再次检查其他输入以识别做出过去决定的正确上下文。
人工神经网络的工作流程 (Workflow of ANN)

Let us first understand the different phases of deep learning and then, learn how Keras helps in the process of deep learning.
首先让我们了解深度学习的不同阶段，然后了解Keras在深度学习过程中如何提供帮助。
收集所需数据 (Collect required data)

Deep learning requires lot of input data to successfully learn and predict the result. So, first collect as much data as possible.
深度学习需要大量输入数据才能成功学习和预测结果。因此，首先要收集尽可能多的数据。
分析数据 (Analyze data)

Analyze the data and acquire a good understanding of the data. The better understanding of the data is required to select the correct ANN algorithm.
分析数据并获得对数据的良好理解。选择正确的ANN算法需要对数据有更好的了解。
选择一种算法(模型) (Choose an algorithm (model))

Choose an algorithm, which will best fit for the type of learning process (e.g image classification, text processing, etc.,) and the available input data. Algorithm is represented by Model in Keras. Algorithm includes one or more layers. Each layers in ANN can be represented by Keras Layer in Keras.
选择一种最适合学习过程类型(例如图像分类，文本处理等)和可用输入数据的算法。算法由Keras中的模型表示。算法包括一层或多层。 ANN中的每个层都可以用Keras中的Keras层表示。

Prepare data

准备数据

Split data

拆分数据

Compile the model

编译模型

Fit the model

拟合模型

Predict result for unknown value

预测未知值的结果

Evaluate model

评估模型

Freeze, Modify or choose new algorithm

冻结，修改或选择新算法

The above steps can be represented using below flow chart ?
可以使用以下流程图表示以上步骤-

Keras-深度学习 (Keras - Deep learning)

Keras provides a complete framework to create any type of neural networks. Keras is innovative as well as very easy to learn. It supports simple neural network to very large and complex neural network model. Let us understand the architecture of Keras framework and how Keras helps in deep learning in this chapter.
Keras提供了一个完整的框架来创建任何类型的神经网络。 Keras具有创新性并且非常易于学习。它支持简单的神经网络到非常大和复杂的神经网络模型。在本章中，让我们了解Keras框架的体系结构以及Keras如何帮助深度学习。
凯拉斯的体系结构 (Architecture of Keras)

Keras API can be divided into three main categories ?
Keras API可以分为三个主要类别-

In Keras, every ANN is represented by Keras Models. In turn, every Keras Model is composition of Keras Layers and represents ANN layers like input, hidden layer, output layers, convolution layer, pooling layer, etc., Keras model and layer access Keras modules for activation function, loss function, regularization function, etc., Using Keras model, Keras Layer, and Keras modules, any ANN algorithm (CNN, RNN, etc.,) can be represented in a simple and efficient manner.
在Keras中，每个人工神经网络都由Keras模型表示。反过来，每个Keras模型都是Keras层的组成 ，代表了ANN层，例如输入层，隐藏层，输出层，卷积层，池化层等。Keras模型和层访问Keras模块，用于激活函数，损失函数，正则化函数，等等，使用Keras模型，Keras Layer和Keras模块，可以以简单有效的方式表示任何ANN算法(CNN，RNN等)。
The following diagram depicts the relationship between model, layer and core modules ?
下图描述了模型，层和核心模块之间的关系-

Let us see the overview of Keras models, Keras layers and Keras modules.
让我们看一下Keras模型，Keras图层和Keras模块的概述。
模型 (Model)

Keras Models are of two types as mentioned below ?
Keras模型有以下两种类型-
Sequential Model ? Sequential model is basically a linear composition of Keras Layers. Sequential model is easy, minimal as well as has the ability to represent nearly all available neural networks.
顺序模型 -顺序模型基本上是Keras层的线性组成。顺序模型简单，最小，并且能够表示几乎所有可用的神经网络。
A simple sequential model is as follows ?
一个简单的顺序模型如下-

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

复制代码

Where,
哪里，

Line 1

Sequential

1号线

顺序

Line 2

Dense

Activation

第2行

密集

激活

Line 4

Sequential

第4行

Sequential

Line 5

relu

第5行

relu

Sequential model exposes Model class to create customized models as well. We can use sub-classing concept to create our own complex model.
顺序模型公开了Model类，以创建自定义模型。我们可以使用子分类概念来创建我们自己的复杂模型。
Functional API ? Functional API is basically used to create complex models.
功能API-功能API基本上用于创建复杂的模型。
层 (Layer)

Each Keras layer in the Keras model represent the corresponding layer (input layer, hidden layer and output layer) in the actual proposed neural network model. Keras provides a lot of pre-build layers so that any complex neural network can be easily created. Some of the important Keras layers are specified below,
Keras模型中的每个Keras层代表实际提出的神经网络模型中的对应层(输入层，隐藏层和输出层)。 Keras提供了许多预构建层，因此可以轻松创建任何复杂的神经网络。下面指定了一些重要的Keras图层，

A simple python code to represent a neural network model using sequential model is as follows ?
使用顺序模型表示神经网络模型的简单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'))

复制代码

Where,
哪里，

Line 1

Sequential

1号线

顺序

Line 2

Dense

Activation

第2行

密集

激活

Line 4

Sequential

第4行

Sequential

Line 5

relu

第5行

relu

Line 6

第6行

Line 7

relu

第7行

relu

Line 8

第8行

Line 9

softmax

第9行

softmax

Keras also provides options to create our own customized layers. Customized layer can be created by sub-classing the Keras.Layer class and it is similar to sub-classing Keras models.
Keras还提供了创建我们自己的自定义图层的选项。可以通过对Keras.Layer类进行子类化来创建自定义图层，这类似于对Keras模型进行子类化。
核心模块 (Core Modules)

Keras also provides a lot of built-in neural network related functions to properly create the Keras model and Keras layers. Some of the function are as follows ?
Keras还提供了大量内置神经网络相关功能，以正确创建Keras模型和Keras层。一些功能如下-

Activations module

激活模块

Loss module

损失模块

Optimizer module

优化器模块

Regularizers

正则化器

Let us learn Keras modules in detail in the upcoming chapter.
让我们在下一章中详细学习Keras模块。
Keras-模块 (Keras - Modules)

As we learned earlier, Keras modules contains pre-defined classes, functions and variables which are useful for deep learning algorithm. Let us learn the modules provided by Keras in this chapter.
如前所述，Keras模块包含预定义的类，函数和变量，它们对于深度学习算法很有用。让我们学习本章中Keras提供的模块。
可用模块 (Available modules)

Let us first see the list of modules available in the Keras.
首先让我们看看Keras中可用的模块列表。

Initializers

layer chapter

初始化程序

初始化

层一章

Regularizers

Keras Layers

正则化器

Keras Layers

Constraints

Keras Layers

约束

Keras Layers

Activations

Keras Layers

激活

Keras Layers

Losses

Model Training

损失

模型培训”

Metrics

Model Training

指标

模型培训”

Optimizers

Model Training

优化器

模型培训”

Callback

EarlyStopping

回调

EarlyStopping

Text processing

文本处理

Image processing

图像处理

Sequence processing

顺序处理

Backend

TensorFlow

Theano

后端

TensorFlow

Theano

Utilities

实用程序

Let us see backend module and utils model in this chapter.
让我们在本章中了解后端模块和utils模型。
后端模块 (backend module)

backend module is used for keras backend operations. By default, keras runs on top of TensorFlow backend. If you want, you can switch to other backends like Theano or CNTK. Defualt backend configuration is defined inside your root directory under .keras/keras.json file.
后端模块用于keras后端操作。默认情况下，keras运行在TensorFlow后端之上。如果需要，可以切换到Theano或CNTK等其他后端。 Defualt后端配置在.keras / keras.json文件下的根目录中定义。
Keras backend module can be imported using below code
可以使用以下代码导入Keras 后端模块

>>> from keras import backend as k

复制代码

If we are using default backend TensorFlow, then the below function returns TensorFlow based information as specified below ?
如果我们使用默认后端TensorFlow ，则以下函数将返回基于TensorFlow的信息，如下所示-

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

复制代码

Let us understand some of the significant backend functions used for data analysis in brief ?
让我们简要地了解一些用于数据分析的重要后端功能-
get_uid() (get_uid())

It is the identifier for the default graph. It is defined below ?
它是默认图形的标识符。它定义如下-

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

复制代码

reset_uids (reset_uids)

It is used resets the uid value.
用于重置uid值。

>>> k.reset_uids()

复制代码

Now, again execute the get_uid(). This will be reset and change again to 1.
现在，再次执行get_uid() 。它将被重置并再次更改为1。

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

复制代码

占位符 (placeholder)

It is used instantiates a placeholder tensor. Simple placeholder to hold 3-D shape is shown below ?
用于实例化一个占位符张量。保持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)

复制代码

点 (dot)

It is used to multiply two tensors. Consider a and b are two tensors and c will be the outcome of multiply of ab. Assume a shape is (4,2) and b shape is (2,3). It is defined below,
它用于将两个张量相乘。考虑a和b是两个张量，而c是ab乘积的结果。假设形状为(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>
>>>

复制代码

那些 (ones)

It is used to initialize all as one value.
用于将所有值初始化为一个值。

>>> res = k.ones(shape = (2,2))
#print the value
>>> k.eval(res)
array([[1., 1.], [1., 1.]], dtype = float32)

复制代码

batch_dot (batch_dot)

It is used to perform the product of two data in batches. Input dimension must be 2 or higher. It is shown below ?
它用于批量执行两个数据的乘积。输入尺寸必须为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>

复制代码

变量 (variable)

It is used to initializes a variable. Let us perform simple transpose operation in this variable.
它用于初始化变量。让我们在此变量中执行简单的转置操作。

>>> 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.]]

复制代码

If you want to access from numpy ?
如果您想从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(张量) (is_sparse(tensor))

It is used to check whether the tensor is sparse or not.
用于检查张量是否稀疏。

>>> 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() (to_dense())

It is used to converts sparse into dense.
它用于将稀疏转换为密集。

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

复制代码

random_uniform_variable (random_uniform_variable)

It is used to initialize using uniform distribution concept.
它用于使用均匀分布概念进行初始化。

k.random_uniform_variable(shape, mean, scale)

复制代码

Here,
这里，

shape

形状

mean

均值

scale

标度

Let us have a look at the below example usage ?
让我们看看下面的示例用法-

>>> 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 module)

utils provides useful utilities function for deep learning. Some of the methods provided by the utils module is as follows ?
utils为深度学习提供了有用的实用程序功能。 utils模块提供的一些方法如下-
HDF5矩阵 (HDF5Matrix)

It is used to represent the input data in HDF5 format.
它用于以HDF5格式表示输入数据。

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

复制代码

to_categorical (to_categorical)

It is used to convert class vector into binary class matrix.
它用于将类向量转换为二进制类矩阵。

>>> 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]])

复制代码

print_summary (print_summary)

It is used to print the summary of the model.
它用于打印模型摘要。

from keras.utils import print_summary print_summary(model)

复制代码

plot_model (plot_model)

It is used to create the model representation in dot format and save it to file.
它用于以点格式创建模型表示并将其保存到文件中。

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

复制代码

This plot_model will generate an image to understand the performance of model.
此plot_model将生成一张图像以了解模型的性能。

Keras-图层 (Keras - Layers)

As learned earlier, Keras layers are the primary building block of Keras models. Each layer receives input information, do some computation and finally output the transformed information. The output of one layer will flow into the next layer as its input. Let us learn complete details about layers in this chapter.
如前所述，Keras图层是Keras模型的主要构建块。每层接收输入信息，进行一些计算，最后输出转换后的信息。一层的输出将流入下一层作为其输入。让我们在本章中了解有关图层的完整详细信息。
介绍 (Introduction)

A Keras layer requires shape of the input (input_shape) to understand the structure of the input data, initializer to set the weight for each input and finally activators to transform the output to make it non-linear. In between, constraints restricts and specify the range in which the weight of input data to be generated and regularizer will try to optimize the layer (and the model) by dynamically applying the penalties on the weights during optimization process.
Keras层需要输入的形状(input_shape)来了解输入数据的结构， 初始化器设置每个输入的权重，最后通过激活器将输出转换为非线性。在这两者之间，约束条件限制并指定了要生成的输入数据权重的范围，并且正则化程序将通过在优化过程中动态对权重施加惩罚来尝试优化图层(和模型)。
To summarise, Keras layer requires below minimum details to create a complete layer.
总而言之，Keras图层需要以下最低限度的细节才能创建完整的图层。

Let us understand the basic concept in the next chapter. Before understanding the basic concept, let us create a simple Keras layer using Sequential model API to get the idea of how Keras model and layer works.
让我们在下一章中了解基本概念。在理解基本概念之前，让我们使用顺序模型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))

复制代码

where,
哪里，

Line 1-5

1-5行

Line 7

第7行

Line 9

Dense

Input Shape, (16,)

第9行

Dense

密集

输入形状(16)

input_shape

kernel_initializer

he_uniform

kernel_initializer

he_uniform

kernel_regularizer

regularizer

kernel_regularizer

正则化

kernel_constraint

MaxNorm

kernel_constraint

MaxNorm

activation

激活

Line 10

Dense

relu

第10行

Dense

relu

Line 11

第11行

图层的基本概念 (Basic Concept of Layers)

Let us understand the basic concept of layer as well as how Keras supports each concept.
让我们了解层的基本概念以及Keras如何支持每个概念。
输入形状 (Input shape)

In machine learning, all type of input data like text, images or videos will be first converted into array of numbers and then feed into the algorithm. Input numbers may be single dimensional array, two dimensional array (matrix) or multi-dimensional array. We can specify the dimensional information using shape, a tuple of integers. For example, (4,2) represent matrix with four rows and two columns.
在机器学习中，所有类型的输入数据(例如文本，图像或视频)都将首先转换为数字数组，然后输入算法。输入数字可以是一维数组，二维数组(矩阵)或多维数组。我们可以使用shape (整数元组)指定尺寸信息。例如， (4,2)表示具有四行两列的矩阵。

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

复制代码

Similarly, (3,4,2) three dimensional matrix having three collections of 4x2 matrix (two rows and four columns).
类似地， (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.]]
]
>>>

复制代码

To create the first layer of the model (or input layer of the model), shape of the input data should be specified.
要创建模型的第一层(或模型的输入层)，应指定输入数据的形状。
初始化器 (Initializers)

In Machine Learning, weight will be assigned to all input data. Initializers module provides different functions to set these initial weight. Some of the Keras Initializer function are as follows ?
在机器学习中，权重将分配给所有输入数据。 Initializers模块提供了不同的功能来设置这些初始权重。 Keras初始化器的一些功能如下-
零点 (Zeros)

Generates 0 for all input data.
为所有输入数据生成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))

复制代码

Where, kernel_initializer represent the initializer for kernel of the model.
其中， kernel_initializer表示模型内核的初始化程序。
那些 (Ones)

Generates 1 for all input data.
为所有输入数据生成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))

复制代码

不变 (Constant)

Generates a constant value (say, 5) specified by the user for all input data.
生成用户为所有输入数据指定的常数值(例如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)
)

复制代码

where, value represent the constant value
其中，值代表常数
随机法线 (RandomNormal)

Generates value using normal distribution of input data.
使用输入数据的正态分布生成值。

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))

复制代码

where,
哪里，

mean

平均值

stddev

seed

种子

随机统一 (RandomUniform)

Generates value using uniform distribution of input data.
使用输入数据的均匀分布生成值。

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))

复制代码

where,
哪里，

minval

maxval

截断法线 (TruncatedNormal)

Generates value using truncated normal distribution of input data.
使用输入数据的截断正态分布生成值。

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))

复制代码

方差缩放 (VarianceScaling)

Generates value based on the input shape and output shape of the layer along with the specified scale.
根据图层的输入形状和输出形状以及指定的比例尺生成值。

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))

复制代码

where,
哪里，

scale

比例

mode

fan_in, fan_out

fan_avg

模式

fan_in，fan_out

fan_avg

distribution

normal

uniform

分布

正态分布

均匀

分布

方差缩放 (VarianceScaling)

It finds the stddev value for normal distribution using below formula and then find the weights using normal distribution,
它使用以下公式找到正态分布的stddev值，然后使用正态分布找到权重，

stddev = sqrt(scale / n)

复制代码

where n represent,
n代表

Similarly, it finds the limit for uniform distribution using below formula and then find the weights using uniform distribution,
同样，它使用以下公式找到均匀分布的极限，然后使用均匀分布找到权重，

limit = sqrt(3 * scale / n)

复制代码

lecun_normal (lecun_normal)

Generates value using lecun normal distribution of input data.
使用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))

复制代码

It finds the stddev using the below formula and then apply normal distribution
它使用以下公式找到stddev ，然后应用正态分布

stddev = sqrt(1 / fan_in)

复制代码

where, fan_in represent the number of input units.
其中， fan_in代表输入单元的数量。
lecun_uniform (lecun_uniform)

Generates value using lecun uniform distribution of input data.
使用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))

复制代码

It finds the limit using the below formula and then apply uniform distribution
它使用以下公式找到极限，然后应用均匀分布

limit = sqrt(3 / fan_in)

复制代码

where,
哪里，

fan_in

fan_out

glorot_normal (glorot_normal)

Generates value using glorot normal distribution of input data.
使用输入数据的正态分布生成值。

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)
)

复制代码

It finds the stddev using the below formula and then apply normal distribution
它使用以下公式找到stddev ，然后应用正态分布

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

复制代码

where,
哪里，

fan_in

fan_out

glorot_uniform (glorot_uniform)

Generates value using glorot uniform distribution of input data.
使用输入数据的全局均匀分布来生成值。

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))

复制代码

It finds the limit using the below formula and then apply uniform distribution
它使用以下公式找到极限，然后应用均匀分布

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

复制代码

where,
哪里，

fan_in

fan_out

他正常 (he_normal)

Generates value using he normal distribution of input data.
使用输入数据的正态分布生成值。

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))

复制代码

It finds the stddev using the below formula and then apply normal distribution.
它使用以下公式找到stddev ，然后应用正态分布。

stddev = sqrt(2 / fan_in)

复制代码

where, fan_in represent the number of input units.
其中， fan_in代表输入单元的数量。
he_uniform (he_uniform)

Generates value using he uniform distribution of input data.
使用输入数据的均匀分布来产生价值。

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))

复制代码

It finds the limit using the below formula and then apply uniform distribution.
它使用以下公式找到极限，然后应用均匀分布。

limit = sqrt(6 / fan_in)

复制代码

where, fan_in represent the number of input units.
其中， fan_in代表输入单元的数量。
正交的 (Orthogonal)

Generates a random orthogonal matrix.
生成随机正交矩阵。

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))

复制代码

where, gain represent the multiplication factor of the matrix.
其中，增益代表矩阵的乘法因子。
身分识别 (Identity)

Generates identity matrix.
生成单位矩阵。

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)

In machine learning, a constraint will be set on the parameter (weight) during optimization phase. <>Constraints module provides different functions to set the constraint on the layer. Some of the constraint functions are as follows.
在机器学习中，将在优化阶段对参数(权重)设置约束。 <>约束模块提供了不同的功能来设置图层上的约束。一些约束函数如下。
非负 (NonNeg)

Constrains weights to be non-negative.
将权重限制为非负数。

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)
)

复制代码

where, kernel_constraint represent the constraint to be used in the layer.
其中， kernel_constraint表示要在层中使用的约束。
单位范数 (UnitNorm)

Constrains weights to be unit norm.
将权重约束为单位范数。

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))

复制代码

最大规范 (MaxNorm)

Constrains weight to norm less than or equals to the given value.
将权重限制为小于或等于给定值的范数。

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))

复制代码

where,
哪里，

max_value

axis

轴

最小最大范数 (MinMaxNorm)

Constrains weights to be norm between specified minimum and maximum values.
将权重限制在指定的最小值和最大值之间。

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))

复制代码

where, rate represent the rate at which the weight constrain is applied.
其中， rate表示施加重量约束的速率。
正则化器 (Regularizers)

In machine learning, regularizers are used in the optimization phase. It applies some penalties on the layer parameter during optimization. Keras regularization module provides below functions to set penalties on the layer. Regularization applies per-layer basis only.
在机器学习中，正则化器用于优化阶段。在优化过程中会对层参数施加一些惩罚。 Keras正则化模块提供以下功能来设置层上的惩罚。正则化仅适用于每层。
L1正则器 (L1 Regularizer)

It provides L1 based regularization.
它提供基于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))

复制代码

where, kernel_regularizer represent the rate at which the weight constrain is applied.
其中， kernel_regularizer表示施加权重约束的速率。
L2调节器 (L2 Regularizer)

It provides L2 based regularization.
它提供基于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 and L2 Regularizer)

It provides both L1 and L2 based regularization.
它提供了基于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))

复制代码

激活方式 (Activations)

In machine learning, activation function is a special function used to find whether a specific neuron is activated or not. Basically, the activation function does a nonlinear transformation of the input data and thus enable the neurons to learn better. Output of a neuron depends on the activation function.
在机器学习中，激活功能是一种特殊功能，用于查找特定神经元是否被激活。基本上，激活函数对输入数据进行非线性转换，从而使神经元学习得更好。神经元的输出取决于激活功能。
As you recall the concept of single perception, the output of a perceptron (neuron) is simply the result of the activation function, which accepts the summation of all input multiplied with its corresponding weight plus overall bias, if any available.
当您回想起单感知的概念时，感知器(神经元)的输出只是激活函数的结果，该函数接受所有输入的总和乘以其相应的权重加上总体偏差(如果有)。

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

复制代码

So, activation function plays an important role in the successful learning of the model. Keras provides a lot of activation function in the activations module. Let us learn all the activations available in the module.
因此，激活函数在模型的成功学习中起着重要作用。 Keras在激活模块中提供了很多激活功能。让我们学习该模块中所有可用的激活。
线性的 (linear)

Applies Linear function. Does nothing.
应用线性函数。什么也没做。

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

复制代码

Where, activation refers the activation function of the layer. It can be specified simply by the name of the function and the layer will use corresponding activators.
其中，激活是指该层的激活功能。可以简单地通过函数名称指定它，并且该层将使用相应的激活器。
lu (elu)

Applies Exponential linear unit.
应用指数线性单位。

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

复制代码

selu (selu)

Applies Scaled exponential linear unit.
应用比例指数线性单位。

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

复制代码

relu (relu)

Applies Rectified Linear Unit.
应用整流线性单位。

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

复制代码

softmax (softmax)

Applies Softmax function.
应用Softmax功能。

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

复制代码

softplus (softplus)

Applies Softplus function.
应用Softplus功能。

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

复制代码

softsign (softsign)

Applies Softsign function.
应用软件签名功能。

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

复制代码

tanh (tanh)

Applies Hyperbolic tangent function.
应用双曲正切函数。

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

复制代码

sigmod (sigmoid)

Applies Sigmoid function.
应用Sigmoid函数。

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

复制代码

硬sigmod (hard_sigmoid)

Applies Hard Sigmoid function.
应用硬Sigmoid函数。

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

复制代码

指数的 (exponential)

Applies exponential function.
应用指数函数。

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

复制代码

Sr.No	Layers & Description
1	Dense Layer Dense layer is the regular deeply connected neural network layer.
2	Dropout Layers *Dropout* is one of the important concept in the machine learning.
3	Flatten Layers Flatten is used to flatten the input.
4	Reshape Layers *Reshape* is used to change the shape of the input.
5	Permute Layers Permute is also used to change the shape of the input using pattern.
6	RepeatVector Layers *RepeatVector* is used to repeat the input for set number, n of times.
7	Lambda Layers *Lambda* is used to transform the input data using an expression or function.
8	Convolution Layers Keras contains a lot of layers for creating Convolution based ANN, popularly called as Convolution Neural Network (CNN).
9	Pooling Layer It is used to perform max pooling operations on temporal data.
10	Locally connected layer Locally connected layers are similar to Conv1D layer but the difference is Conv1D layer weights are shared but here weights are unshared.
11	Merge Layer It is used to merge a list of inputs.
12	Embedding Layer It performs embedding operations in input layer.

序号	图层和说明
1个	致密层密集层是规则的深度连接神经网络层。
2	辍学层辍学是机器学习中的重要概念之一。
3	展平层展平被用来压平的输入端。
4	重塑图层重塑是用来改变所述输入的形状。
5	置换层 Permute还用于使用模式更改输入的形状。
6	RepeatVector图层 *RepeatVector*用于将输入重复设置次数n次。
7	Lambda图层 *Lambda*用于使用表达式或函数来转换输入数据。
8	卷积层 Keras包含用于创建基于卷积的ANN的许多层，通常被称为卷积神经网络(CNN) 。
9	池化层它用于对时间数据执行最大池化操作。
10	本地连接层本地连接的图层与Conv1D图层相似，但区别在于Conv1D图层的权重是共享的，但此处的权重是不共享的。
11	合并层它用于合并输入列表。
12	嵌入层它在输入层中执行嵌入操作。

Keras-定制层 (Keras - Customized Layer)

Keras allows to create our own customized layer. Once a new layer is created, it can be used in any model without any restriction. Let us learn how to create new layer in this chapter.
Keras允许创建我们自己的定制层。一旦创建了新层，就可以在任何模型中使用它，而没有任何限制。让我们在本章中学习如何创建新层。
Keras provides a base layer class, Layer which can sub-classed to create our own customized layer. Let us create a simple layer which will find weight based on normal distribution and then do the basic computation of finding the summation of the product of input and its weight during training.
Keras提供了一个基础层类，即Layer，可以对其进行子分类以创建我们自己的自定义层。让我们创建一个简单的层，该层将根据正态分布查找权重，然后进行基本计算，以找到训练期间输入乘积及其权重的总和。
步骤1：导入必要的模块 (Step 1: Import the necessary module)

First, let us import the necessary modules ?
首先，让我们导入必要的模块-

from keras import backend as K
from keras.layers import Layer

复制代码

Here,
这里，

backend

dot

后端

点

Layer

图层

步骤2：定义图层类别 (Step 2: Define a layer class)

Let us create a new class, MyCustomLayer by sub-classing Layer class ?
让我们通过对Layer类进行子类化来创建一个新类MyCustomLayer-

class MyCustomLayer(Layer):
...

复制代码

步骤3：初始化图层类 (Step 3: Initialize the layer class)

Let us initialize our new class as specified below ?
让我们初始化我们的新类，如下所示：

def __init__(self, output_dim, **kwargs):
self.output_dim = output_dim
super(MyCustomLayer, self).__init__(**kwargs)

复制代码

Here,
这里，

Line 2

第2行

Line 3

init

第3行

init

步骤4：实施构建方法 (Step 4: Implement build method)

build is the main method and its only purpose is to build the layer properly. It can do anything related to the inner working of the layer. Once the custom functionality is done, we can call the base class build function. Our custom build function is as follows ?
build是主要方法，其唯一目的是正确构建图层。它可以做任何与图层内部工作有关的事情。完成自定义功能后，我们可以调用基类构建功能。我们的自定义构建函数如下-

def build(self, input_shape):
self.kernel = self.add_weight(name = 'kernel',
shape = (input_shape[1], self.output_dim),
initializer = 'normal', trainable = True)
super(MyCustomLayer, self).build(input_shape)

复制代码

Here,
这里，

Line 1

build

input_shape

第1行

input_shape

构建

Line 2

第2行

Line 6

build

第6行

build

步骤5：实现调用方法 (Step 5: Implement call method)

call method does the exact working of the layer during training process.
call方法会在训练过程中精确执行图层的工作。
Our custom call method is as follows
我们的自定义调用方法如下

def call(self, input_data):
return K.dot(input_data, self.kernel)

复制代码

Here,
这里，

Line 1

call

input_data

第1行

input_data

调用

Line 2

input_data

self.kernel

第2行

input_data

self.kernel

步骤6：实现compute_output_shape方法 (Step 6: Implement compute_output_shape method)

def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)

复制代码

Here,
这里，

Line 1

compute_output_shape

input_shape

第1

行

input_shape

compute_output_shape

Line 2

第2

Implementing the build, call and compute_output_shape completes the creating a customized layer. The final and complete code is as follows
实现build，call和compute_output_shape将完成创建自定义层。最终的完整代码如下

from keras import backend as K from keras.layers import Layer
class MyCustomLayer(Layer):
def __init__(self, output_dim, **kwargs):
self.output_dim = output_dim
super(MyCustomLayer, self).__init__(**kwargs)
def build(self, input_shape): self.kernel =
self.add_weight(name = 'kernel',
shape = (input_shape[1], self.output_dim),
initializer = 'normal', trainable = True)
super(MyCustomLayer, self).build(input_shape) #
Be sure to call this at the end
def call(self, input_data): return K.dot(input_data, self.kernel)
def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)

复制代码

使用我们的定制层 (Using our customized layer)

Let us create a simple model using our customized layer as specified below ?
让我们使用下面指定的定制层创建一个简单的模型-

from keras.models import Sequential
from keras.layers import Dense
model = Sequential()
model.add(MyCustomLayer(32, input_shape = (16,)))
model.add(Dense(8, activation = 'softmax')) model.summary()

复制代码

Here,
这里，

MyCustomLayer

(16,)

MyCustomLayer

(16，)

Running the application will print the model summary as below ?
运行应用程序将打印模型摘要，如下所示：

Model: "sequential_1"
_________________________________________________________________
Layer (type) Output Shape Param
#================================================================
my_custom_layer_1 (MyCustomL (None, 32) 512
_________________________________________________________________
dense_1 (Dense) (None, 8) 264
=================================================================
Total params: 776
Trainable params: 776
Non-trainable params: 0
_________________________________________________________________

复制代码

Keras-型号 (Keras - Models)

As learned earlier, Keras model represents the actual neural network model. Keras provides a two mode to create the model, simple and easy to use Sequential API as well as more flexible and advanced Functional API. Let us learn now to create model using both Sequential and Functional API in this chapter.
如前所述，Keras模型代表实际的神经网络模型。 Keras提供了两种创建模型的模式：简单易用的Sequential API以及更灵活，更高级的Functional API 。现在让我们学习本章中同时使用顺序 API和功能 API创建模型的方法。
顺序的 (Sequential)

The core idea of Sequential API is simply arranging the Keras layers in a sequential order and so, it is called Sequential API. Most of the ANN also has layers in sequential order and the data flows from one layer to another layer in the given order until the data finally reaches the output layer.
顺序API的核心思想是简单地按顺序排列Keras层，因此，它称为顺序API 。大部分的ANN还具有顺序排列的层，并且数据以给定的顺序从一层流到另一层，直到数据最终到达输出层。
A ANN model can be created by simply calling Sequential() API as specified below ?
可以通过简单地调用Sequential() API来创建ANN模型，如下所示：

from keras.models import Sequential
model = Sequential()

复制代码

添加图层 (Add layers)

To add a layer, simply create a layer using Keras layer API and then pass the layer through add() function as specified below ?
要添加层，只需使用Keras层API创建一个层，然后将该层通过add()函数传递，如下所示-

from keras.models import Sequential
model = Sequential()
input_layer = Dense(32, input_shape=(8,)) model.add(input_layer)
hidden_layer = Dense(64, activation='relu'); model.add(hidden_layer)
output_layer = Dense(8)
model.add(output_layer)

复制代码

Here, we have created one input layer, one hidden layer and one output layer.
在这里，我们创建了一个输入层，一个隐藏层和一个输出层。
访问模型 (Access the model)

Keras provides few methods to get the model information like layers, input data and output data. They are as follows ?
Keras提供了很少的方法来获取模型信息，例如图层，输入数据和输出数据。它们如下-

model.layers

model.layers-

>>> layers = model.layers
>>> layers
[
<keras.layers.core.Dense object at 0x000002C8C888B8D0>,
<keras.layers.core.Dense object at 0x000002C8C888B7B8>
<keras.layers.core.Dense object at 0x 000002C8C888B898>
]

复制代码

model.inputs

model.inputs-

>>> inputs = model.inputs
>>> inputs
[<tf.Tensor 'dense_13_input:0' shape=(?, 8) dtype=float32>]

复制代码

model.outputs

model.outputs-

>>> outputs = model.outputs
>>> outputs
<tf.Tensor 'dense_15/BiasAdd:0' shape=(?, 8) dtype=float32>]

复制代码

model.get_weights

model.get_weights-

model.set_weights(weight_numpy_array)

序列化模型 (Serialize the model)

Keras provides methods to serialize the model into object as well as json and load it again later. They are as follows ?
Keras提供了将模型序列化为对象以及json并在以后再次加载的方法。它们如下-

get_config()

config = model.get_config()

复制代码

from_config()

new_model = Sequential.from_config(config)

复制代码

to_json()

>>> json_string = model.to_json()
>>> json_string '{"class_name": "Sequential", "config":
{"name": "sequential_10", "layers":
[{"class_name": "Dense", "config":
{"name": "dense_13", "trainable": true, "batch_input_shape":
[null, 8], "dtype": "float32", "units": 32, "activation": "linear",
"use_bias": true, "kernel_initializer":
{"class_name": "Vari anceScaling", "config":
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "conf
ig": {}}, "kernel_regularizer": null, "bias_regularizer": null,
"activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}},
{" class_name": "Dense", "config": {"name": "dense_14", "trainable": true,
"dtype": "float32", "units": 64, "activation": "relu", "use_bias": true,
"kern el_initializer": {"class_name": "VarianceScaling", "config":
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initia lizer": {"class_name": "Zeros",
"config": {}}, "kernel_regularizer": null, "bias_regularizer": null,
"activity_regularizer": null, "kernel_constraint" : null, "bias_constraint": null}},
{"class_name": "Dense", "config": {"name": "dense_15", "trainable": true,
"dtype": "float32", "units": 8, "activation": "linear", "use_bias": true,
"kernel_initializer": {"class_name": "VarianceScaling", "config":
{"scale": 1.0, "mode": "fan_avg", "distribution": " uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "config": {}},
"kernel_regularizer": null, "bias_regularizer": null, "activity_r egularizer":
null, "kernel_constraint": null, "bias_constraint":
null}}]}, "keras_version": "2.2.5", "backend": "tensorflow"}'
>>>

复制代码

model_from_json()

from keras.models import model_from_json
new_model = model_from_json(json_string)

复制代码

to_yaml()

>>> yaml_string = model.to_yaml()
>>> yaml_string 'backend: tensorflow\nclass_name:
Sequential\nconfig:\n layers:\n - class_name: Dense\n config:\n
activation: linear\n activity_regular izer: null\n batch_input_shape:
!!python/tuple\n - null\n - 8\n bias_constraint: null\n bias_initializer:\n
class_name : Zeros\n config: {}\n bias_regularizer: null\n dtype:
float32\n kernel_constraint: null\n
kernel_initializer:\n cla ss_name: VarianceScaling\n config:\n
distribution: uniform\n mode: fan_avg\n
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense_13\n
trainable: true\n units: 32\n
use_bias: true\n - class_name: Dense\n config:\n activation: relu\n activity_regularizer: null\n
bias_constraint: null\n bias_initializer:\n class_name: Zeros\n
config : {}\n bias_regularizer: null\n dtype: float32\n
kernel_constraint: null\n kernel_initializer:\n class_name: VarianceScalin g\n
config:\n distribution: uniform\n mode: fan_avg\n scale: 1.0\n
seed: null\n kernel_regularizer: nu ll\n name: dense_14\n trainable: true\n
units: 64\n use_bias: true\n - class_name: Dense\n config:\n
activation: linear\n activity_regularizer: null\n
bias_constraint: null\n bias_initializer:\n
class_name: Zeros\n config: {}\n bias_regu larizer: null\n
dtype: float32\n kernel_constraint: null\n
kernel_initializer:\n class_name: VarianceScaling\n config:\n
distribution: uniform\n mode: fan_avg\n
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense _15\n
trainable: true\n units: 8\n
use_bias: true\n name: sequential_10\nkeras_version: 2.2.5\n'
>>>

复制代码

model_from_yaml()

from keras.models import model_from_yaml
new_model = model_from_yaml(yaml_string)

复制代码

总结模型 (Summarise the model)

Understanding the model is very important phase to properly use it for training and prediction purposes. Keras provides a simple method, summary to get the full information about the model and its layers.
理解模型是正确使用模型进行训练和预测的非常重要的阶段。 Keras提供了一种简单的方法，即摘要以获取有关模型及其层的完整信息。
A summary of the model created in the previous section is as follows ?
上一节中创建的模型的摘要如下-

>>> model.summary() Model: "sequential_10"
_________________________________________________________________
Layer (type) Output Shape Param
#================================================================
dense_13 (Dense) (None, 32) 288
_________________________________________________________________
dense_14 (Dense) (None, 64) 2112
_________________________________________________________________
dense_15 (Dense) (None, 8) 520
=================================================================
Total params: 2,920
Trainable params: 2,920
Non-trainable params: 0
_________________________________________________________________
>>>

复制代码

训练和预测模型 (Train and Predict the model)

Model provides function for training, evaluation and prediction process. They are as follows ?
模型为训练，评估和预测过程提供功能。它们如下-

compile

编译

fit

拟合

evaluate

评估

predict

预测

功能性API (Functional API)

Sequential API is used to create models layer-by-layer. Functional API is an alternative approach of creating more complex models. Functional model, you can define multiple input or output that share layers. First, we create an instance for model and connecting to the layers to access input and output to the model. This section explains about functional model in brief.
顺序API用于逐层创建模型。功能API是创建更复杂模型的替代方法。在功能模型中，您可以定义共享图层的多个输入或输出。首先，我们为模型创建一个实例，并连接到图层以访问模型的输入和输出。本节简要介绍功能模型。
建立模型 (Create a model)

Import an input layer using the below module ?
使用以下模块导入输入层-

>>> from keras.layers import Input

复制代码

Now, create an input layer specifying input dimension shape for the model using the below code ?
现在，使用以下代码创建一个输入层，指定模型的输入尺寸形状-

>>> data = Input(shape=(2,3))

复制代码

Define layer for the input using the below module ?
使用以下模块为输入定义层-

>>> from keras.layers import Dense

复制代码

Add Dense layer for the input using the below line of code ?
使用下面的代码行为输入添加密集层-

>>> layer = Dense(2)(data)
>>> print(layer)
Tensor("dense_1/add:0", shape =(?, 2, 2), dtype = float32)

复制代码

Define model using the below module ?
使用以下模块定义模型-

from keras.models import Model

复制代码

Create a model in functional way by specifying both input and output layer ?
通过指定输入和输出层以功能方式创建模型-

model = Model(inputs = data, outputs = layer)

复制代码

The complete code to create a simple model is shown below ?
创建简单模型的完整代码如下所示-

from keras.layers import Input
from keras.models import Model
from keras.layers import Dense
data = Input(shape=(2,3))
layer = Dense(2)(data) model =
Model(inputs=data,outputs=layer) model.summary()
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_2 (InputLayer) (None, 2, 3) 0
_________________________________________________________________
dense_2 (Dense) (None, 2, 2) 8
=================================================================
Total params: 8
Trainable params: 8
Non-trainable params: 0
_________________________________________________________________

复制代码

Keras-模型编译 (Keras - Model Compilation)

Previously, we studied the basics of how to create model using Sequential and Functional API. This chapter explains about how to compile the model. The compilation is the final step in creating a model. Once the compilation is done, we can move on to training phase.
以前，我们研究了如何使用顺序和功能API创建模型的基础知识。本章介绍如何编译模型。编译是创建模型的最后一步。编译完成后，我们可以进入训练阶段。
Let us learn few concepts required to better understand the compilation process.
让我们学习一些概念，以更好地理解编译过程。
失利 (Loss)

In machine learning, Loss function is used to find error or deviation in the learning process. Keras requires loss function during model compilation process.
在机器学习中，损失功能用于发现学习过程中的错误或偏差。 Keras在模型编译过程中需要损失函数。
Keras provides quite a few loss function in the losses module and they are as follows ?
Keras在损失模块中提供了很多损失函数，它们如下-

All above loss function accepts two arguments ?
以上所有损失函数都接受两个参数-

y_true

y_pred

y_true

y_pred

y_true

Import the losses module before using loss function as specified below ?
在使用以下指定的损失函数之前，请导入损失模块-

from keras import losses

复制代码

优化器 (Optimizer)

In machine learning, Optimization is an important process which optimize the input weights by comparing the prediction and the loss function. Keras provides quite a few optimizer as a module, optimizers and they are as follows:
在机器学习中，优化是通过比较预测函数和损失函数来优化输入权重的重要过程。 Keras提供了许多优化器作为模块，这些优化器如下：
SGD ? Stochastic gradient descent optimizer.
SGD-随机梯度下降优化器。

keras.optimizers.SGD(learning_rate = 0.01, momentum = 0.0, nesterov = False)

复制代码

RMSprop ? RMSProp optimizer.
RMSprop -RMSProp优化器。

keras.optimizers.RMSprop(learning_rate = 0.001, rho = 0.9)

复制代码

Adagrad ? Adagrad optimizer.
Adagrad -Adagrad优化器。

keras.optimizers.Adagrad(learning_rate = 0.01)

复制代码

Adadelta ? Adadelta optimizer.
Adadelta -Adadelta优化器。

keras.optimizers.Adadelta(learning_rate = 1.0, rho = 0.95)

复制代码

Adam ? Adam optimizer.
Adam -Adam优化器。

keras.optimizers.Adam(
learning_rate = 0.001, beta_1 = 0.9, beta_2 = 0.999, amsgrad = False
)

复制代码

Adamax ? Adamax optimizer from Adam.
Adamax -Adam的Adamax优化器。

keras.optimizers.Adamax(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

复制代码

Nadam ? Nesterov Adam optimizer.
Nadam -Nesterov Adam优化器。

keras.optimizers.Nadam(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

复制代码

Import the optimizers module before using optimizers as specified below ?
如下所示使用优化器之前，请导入优化器模块-

from keras import optimizers

复制代码

指标 (Metrics)

In machine learning, Metrics is used to evaluate the performance of your model. It is similar to loss function, but not used in training process. Keras provides quite a few metrics as a module, metrics and they are as follows
在机器学习中，指标用于评估模型的性能。它类似于损失函数，但未在训练过程中使用。 Keras提供了很多度量作为模块，这些度量如下：

Similar to loss function, metrics also accepts below two arguments ?
与损失函数类似，指标还接受以下两个参数-

y_true

y_pred

y_true

y_pred

y_true

Import the metrics module before using metrics as specified below ?
在使用指标之前，请导入指标模块，如下所示：

from keras import metrics

复制代码

编译模型 (Compile the model)

Keras model provides a method, compile() to compile the model. The argument and default value of the compile() method is as follows
Keras模型提供了一种方法compile()来编译模型。 compile()方法的参数和默认值如下

compile(
optimizer,
loss = None,
metrics = None,
loss_weights = None,
sample_weight_mode = None,
weighted_metrics = None,
target_tensors = None
)

复制代码

The important arguments are as follows ?
重要的论据如下-

A sample code to compile the mode is as follows ?
编译模式的示例代码如下-

from keras import losses
from keras import optimizers
from keras import metrics
model.compile(loss = 'mean_squared_error',
optimizer = 'sgd', metrics = [metrics.categorical_accuracy])

复制代码

where,
哪里，

mean_squared_error

sgd

metrics.categorical_accuracy

模型训练 (Model Training)

Models are trained by NumPy arrays using fit(). The main purpose of this fit function is used to evaluate your model on training. This can be also used for graphing model performance. It has the following syntax ?
NumPy数组使用fit()训练模型。该拟合函数的主要目的是用于评估训练模型。这也可以用于绘制模型性能。它具有以下语法-

model.fit(X, y, epochs = , batch_size = )

复制代码

Here,
这里，

X, y

X，y-

epochs

时期

batch_size

batch_size-

Let us take a simple example of numpy random data to use this concept.
让我们举一个简单的numpy随机数据示例来使用此概念。
建立资料 (Create data)

Let us create a random data using numpy for x and y with the help of below mentioned command ?
让我们借助下面提到的命令使用numpy为x和y创建随机数据-

import numpy as np
x_train = np.random.random((100,4,8))
y_train = np.random.random((100,10))

复制代码

Now, create random validation data,
现在，创建随机验证数据，

x_val = np.random.random((100,4,8))
y_val = np.random.random((100,10))

复制代码

建立模型 (Create model)

Let us create simple sequential model ?
让我们创建简单的顺序模型-

from keras.models import Sequential model = Sequential()

复制代码

添加图层 (Add layers)

Create layers to add model ?
创建图层以添加模型-

from keras.layers import LSTM, Dense
# add a sequence of vectors of dimension 16
model.add(LSTM(16, return_sequences = True))
model.add(Dense(10, activation = 'softmax'))

复制代码

编译模型 (compile model)

Now model is defined. You can compile using the below command ?
现在定义模型。您可以使用以下命令进行编译-

model.compile(
loss = 'categorical_crossentropy', optimizer = 'sgd', metrics = ['accuracy']
)

复制代码

套用fit() (Apply fit())

Now we apply fit() function to train our data ?
现在我们应用fit()函数来训练我们的数据-

model.fit(x_train, y_train, batch_size = 32, epochs = 5, validation_data = (x_val, y_val))

复制代码

创建多层感知器ANN (Create a Multi-Layer Perceptron ANN)

We have learned to create, compile and train the Keras models.
我们已经学会了创建，编译和训练Keras模型。
Let us apply our learning and create a simple MPL based ANN.
让我们运用我们的学习知识，创建一个基于MPL的简单ANN。
数据集模块 (Dataset module)

Before creating a model, we need to choose a problem, need to collect the required data and convert the data to NumPy array. Once data is collected, we can prepare the model and train it by using the collected data. Data collection is one of the most difficult phase of machine learning. Keras provides a special module, datasets to download the online machine learning data for training purposes. It fetches the data from online server, process the data and return the data as training and test set. Let us check the data provided by Keras dataset module. The data available in the module are as follows,
在创建模型之前，我们需要选择一个问题，需要收集所需的数据并将数据转换为NumPy数组。收集数据后，我们可以准备模型并使用收集的数据进行训练。数据收集是机器学习最困难的阶段之一。 Keras提供了一个特殊的模块，即数据集，用于下载在线机器学习数据以进行培训。它从在线服务器获取数据，处理数据，并将数据作为训练和测试集返回。让我们检查Keras数据集模块提供的数据。模块中可用的数据如下，

Let us use the MNIST database of handwritten digits (or minst) as our input. minst is a collection of 60,000, 28x28 grayscale images. It contains 10 digits. It also contains 10,000 test images.
让我们使用手写数字 (或最低)的MNIST数据库作为输入。 minst是60,000张28x28灰度图像的集合。它包含10位数字。它还包含10,000个测试图像。
Below code can be used to load the dataset ?
以下代码可用于加载数据集-

from keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

复制代码

where
哪里

Line 1

minst

第1

行

minst

Line 3

load_data

(x_train, y_train)

(number_sample, 28, 28)

(number_samples, )

(x_test, y_test)

第3行

load_data

(x_train，y_train)

(number_sample，

28，28)

(number_samples，)

(x_test，y_test)

Other dataset can also be fetched using similar API and every API returns similar data as well except the shape of the data. The shape of the data depends on the type of data.
还可以使用类似的API来获取其他数据集，并且每个API都返回相似的数据，但数据的形状除外。数据的形状取决于数据的类型。
建立模型 (Create a model)

Let us choose a simple multi-layer perceptron (MLP) as represented below and try to create the model using Keras.
让我们选择一个简单的多层感知器(MLP)，如下所示，并尝试使用Keras创建模型。

The core features of the model are as follows ?
该模型的核心特征如下-

Dense

Dropout

categorical_crossentropy

RMSprop()

accuracy

准确性

Step 1 ? Import the modules
步骤1-导入模块
Let us import the necessary modules.
让我们导入必要的模块。

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
import numpy as np

复制代码

Step 2 ? Load data
第2步-加载数据
Let us import the mnist dataset.
让我们导入mnist数据集。

(x_train, y_train), (x_test, y_test) = mnist.load_data()

复制代码

Step 3 ? Process the data
步骤3-处理数据
Let us change the dataset according to our model, so that it can be feed into our model.
让我们根据我们的模型更改数据集，以便可以将其输入到我们的模型中。

x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

复制代码

Where
哪里

reshape

to_categorical

Step 4 ? Create the model
步骤4-创建模型
Let us create the actual model.
让我们创建实际的模型。

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(10, activation = 'softmax'))

复制代码

Step 5 ? Compile the model
第5步-编译模型
Let us compile the model using selected loss function, optimizer and metrics.
让我们使用选定的损失函数，优化器和指标来编译模型。

model.compile(loss = 'categorical_crossentropy',
optimizer = RMSprop(),
metrics = ['accuracy'])

复制代码

Step 6 ? Train the model
步骤6-训练模型
Let us train the model using fit() method.
让我们使用fit()方法训练模型。

history = model.fit(
x_train, y_train,
batch_size = 128,
epochs = 20,
verbose = 1,
validation_data = (x_test, y_test)
)

复制代码

最后的想法 (Final thoughts)

We have created the model, loaded the data and also trained the data to the model. We still need to evaluate the model and predict output for unknown input, which we learn in upcoming chapter.
我们已经创建了模型，加载了数据，并将数据训练到了模型中。我们仍然需要评估模型并预测未知输入的输出，这将在下一章中学习。

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
import numpy as np
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
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(10, activation = 'softmax'))
model.compile(loss = 'categorical_crossentropy',
optimizer = RMSprop(),
metrics = ['accuracy'])
history = model.fit(x_train, y_train,
batch_size = 128, epochs = 20, verbose = 1, validation_data = (x_test, y_test))

复制代码

Executing the application will give the below content as output ?
执行应用程序将给出以下内容作为输出-

Train on 60000 samples, validate on 10000 samples Epoch 1/20
60000/60000 [==============================] - 7s 118us/step - loss: 0.2453
- acc: 0.9236 - val_loss: 0.1004 - val_acc: 0.9675 Epoch 2/20
60000/60000 [==============================] - 7s 110us/step - loss: 0.1023
- acc: 0.9693 - val_loss: 0.0797 - val_acc: 0.9761 Epoch 3/20
60000/60000 [==============================] - 7s 110us/step - loss: 0.0744
- acc: 0.9770 - val_loss: 0.0727 - val_acc: 0.9791 Epoch 4/20
60000/60000 [==============================] - 7s 110us/step - loss: 0.0599
- acc: 0.9823 - val_loss: 0.0704 - val_acc: 0.9801 Epoch 5/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0504
- acc: 0.9853 - val_loss: 0.0714 - val_acc: 0.9817 Epoch 6/20
60000/60000 [==============================] - 7s 111us/step - loss: 0.0438
- acc: 0.9868 - val_loss: 0.0845 - val_acc: 0.9809 Epoch 7/20
60000/60000 [==============================] - 7s 114us/step - loss: 0.0391
- acc: 0.9887 - val_loss: 0.0823 - val_acc: 0.9802 Epoch 8/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0364
- acc: 0.9892 - val_loss: 0.0818 - val_acc: 0.9830 Epoch 9/20
60000/60000 [==============================] - 7s 113us/step - loss: 0.0308
- acc: 0.9905 - val_loss: 0.0833 - val_acc: 0.9829 Epoch 10/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0289
- acc: 0.9917 - val_loss: 0.0947 - val_acc: 0.9815 Epoch 11/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0279
- acc: 0.9921 - val_loss: 0.0818 - val_acc: 0.9831 Epoch 12/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0260
- acc: 0.9927 - val_loss: 0.0945 - val_acc: 0.9819 Epoch 13/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0257
- acc: 0.9931 - val_loss: 0.0952 - val_acc: 0.9836 Epoch 14/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0229
- acc: 0.9937 - val_loss: 0.0924 - val_acc: 0.9832 Epoch 15/20
60000/60000 [==============================] - 7s 115us/step - loss: 0.0235
- acc: 0.9937 - val_loss: 0.1004 - val_acc: 0.9823 Epoch 16/20
60000/60000 [==============================] - 7s 113us/step - loss: 0.0214
- acc: 0.9941 - val_loss: 0.0991 - val_acc: 0.9847 Epoch 17/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0219
- acc: 0.9943 - val_loss: 0.1044 - val_acc: 0.9837 Epoch 18/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0190
- acc: 0.9952 - val_loss: 0.1129 - val_acc: 0.9836 Epoch 19/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0197
- acc: 0.9953 - val_loss: 0.0981 - val_acc: 0.9841 Epoch 20/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0198
- acc: 0.9950 - val_loss: 0.1215 - val_acc: 0.9828

复制代码

Keras-模型评估和模型预测 (Keras - Model Evaluation and Model Prediction)

This chapter deals with the model evaluation and model prediction in Keras.
本章介绍Keras中的模型评估和模型预测。
Let us begin by understanding the model evaluation.
让我们首先了解模型评估。
模型评估 (Model Evaluation)

Evaluation is a process during development of the model to check whether the model is best fit for the given problem and corresponding data. Keras model provides a function, evaluate which does the evaluation of the model. It has three main arguments,
评估是在模型开发期间检查模型是否最适合给定问题和相应数据的过程。 Keras模型提供了评估模型的功能。它有三个主要论点，

Let us evaluate the model, which we created in the previous chapter using test data.
让我们评估在上一章中使用测试数据创建的模型。

score = model.evaluate(x_test, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

复制代码

Executing the above code will output the below information.
执行以上代码将输出以下信息。

0

复制代码

The test accuracy is 98.28%. We have created a best model to identify the handwriting digits. On the positive side, we can still scope to improve our model.
测试精度为98.28％。我们创建了一个最佳模型来识别手写数字。从积极的方面来看，我们仍然可以扩大模型的范围。
模型预测 (Model Prediction)

Prediction is the final step and our expected outcome of the model generation. Keras provides a method, predict to get the prediction of the trained model. The signature of the predict method is as follows,
预测是模型生成的最后一步，也是我们预期的结果。 Keras提供了一种预测得到训练模型预测的方法。预测方法的特征如下：

predict(
x,
batch_size = None,
verbose = 0,
steps = None,
callbacks = None,
max_queue_size = 10,
workers = 1,
use_multiprocessing = False
)

复制代码

Here, all arguments are optional except the first argument, which refers the unknown input data. The shape should be maintained to get the proper prediction.
在这里，除第一个参数(该参数引用未知的输入数据)外，所有参数都是可选的。应该保持形状以获得正确的预测。
Let us do prediction for our MPL model created in previous chapter using below code ?
让我们使用以下代码对在上一章中创建的MPL模型进行预测-

pred = model.predict(x_test)
pred = np.argmax(pred, axis = 1)[:5]
label = np.argmax(y_test,axis = 1)[:5]
print(pred)
print(label)

复制代码

Here,
这里，

Line 1

第1行

Line 2

第2行

Line 3

第3行

Line 5 - 6

第5-6行

The output of the above application is as follows ?
上述应用程序的输出如下-

[7 2 1 0 4]
[7 2 1 0 4]

复制代码

The output of both array is identical and it indicate that our model predicts correctly the first five images.
两个数组的输出相同，这表明我们的模型可以正确预测前五个图像。
Keras-卷积神经网络 (Keras - Convolution Neural Network)

Let us modify the model from MPL to Convolution Neural Network (CNN) for our earlier digit identification problem.
让我们针对早期的数字识别问题，将模型从MPL修改为卷积神经网络(CNN) 。
CNN can be represented as below ?
CNN可以表示如下-

The core features of the model are as follows ?
该模型的核心特征如下-

Conv2D

MaxPooling

阈值

MaxPooling的

Flatten

平化

Dense

密集

Dropout

categorical_crossentropy

Adadelta()

accuracy

准确性

Step 1 ? Import the modules
步骤1-导入模块
Let us import the necessary modules.
让我们导入必要的模块。

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
import numpy as np

复制代码

Step 2 ? Load data
第2步-加载数据
Let us import the mnist dataset.
让我们导入mnist数据集。

(x_train, y_train), (x_test, y_test) = mnist.load_data()

复制代码

Step 3 ? Process the data
步骤3-处理数据
Let us change the dataset according to our model, so that it can be feed into our model.
让我们根据我们的模型更改数据集，以便可以将其输入到我们的模型中。

img_rows, img_cols = 28, 28
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

复制代码

The data processing is similar to MPL model except the shape of the input data and image format configuration.
除了输入数据的形状和图像格式配置外，数据处理与MPL模型相似。
Step 4 ? Create the model
步骤4-创建模型
Let us create tha actual model.
让我们创建实际模型。

model = Sequential()
model.add(Conv2D(32, kernel_size = (3, 3),
activation = 'relu', input_shape = input_shape))
model.add(Conv2D(64, (3, 3), activation = 'relu'))
model.add(MaxPooling2D(pool_size = (2, 2)))
model.add(Dropout(0.25)) model.add(Flatten())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation = 'softmax'))

复制代码

Step 5 ? Compile the model
第5步-编译模型
Let us compile the model using selected loss function, optimizer and metrics.
让我们使用选定的损失函数，优化器和指标来编译模型。

model.compile(loss = keras.losses.categorical_crossentropy,
optimizer = keras.optimizers.Adadelta(), metrics = ['accuracy'])

复制代码

Step 6 ? Train the model
步骤6-训练模型
Let us train the model using fit() method.
让我们使用fit()方法训练模型。

model.fit(
x_train, y_train,
batch_size = 128,
epochs = 12,
verbose = 1,
validation_data = (x_test, y_test)
)

复制代码

Executing the application will output the below information ?
执行应用程序将输出以下信息-

Train on 60000 samples, validate on 10000 samples Epoch 1/12
60000/60000 [==============================] - 84s 1ms/step - loss: 0.2687
- acc: 0.9173 - val_loss: 0.0549 - val_acc: 0.9827 Epoch 2/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0899
- acc: 0.9737 - val_loss: 0.0452 - val_acc: 0.9845 Epoch 3/12
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0666
- acc: 0.9804 - val_loss: 0.0362 - val_acc: 0.9879 Epoch 4/12
60000/60000 [==============================] - 81s 1ms/step - loss: 0.0564
- acc: 0.9830 - val_loss: 0.0336 - val_acc: 0.9890 Epoch 5/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0472
- acc: 0.9861 - val_loss: 0.0312 - val_acc: 0.9901 Epoch 6/12
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0414
- acc: 0.9877 - val_loss: 0.0306 - val_acc: 0.9902 Epoch 7/12
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0375
-acc: 0.9883 - val_loss: 0.0281 - val_acc: 0.9906 Epoch 8/12
60000/60000 [==============================] - 91s 2ms/step - loss: 0.0339
- acc: 0.9893 - val_loss: 0.0280 - val_acc: 0.9912 Epoch 9/12
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0325
- acc: 0.9901 - val_loss: 0.0260 - val_acc: 0.9909 Epoch 10/12
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0284
- acc: 0.9910 - val_loss: 0.0250 - val_acc: 0.9919 Epoch 11/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0287
- acc: 0.9907 - val_loss: 0.0264 - val_acc: 0.9916 Epoch 12/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0265
- acc: 0.9920 - val_loss: 0.0249 - val_acc: 0.9922

复制代码

Step 7 ? Evaluate the model
步骤7-评估模型
Let us evaluate the model using test data.
让我们使用测试数据评估模型。

score = model.evaluate(x_test, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

复制代码

Executing the above code will output the below information ?
执行上面的代码将输出以下信息-

Test loss: 0.024936060590433316
Test accuracy: 0.9922

复制代码

The test accuracy is 99.22%. We have created a best model to identify the handwriting digits.
测试精度为99.22％。我们创建了一个最佳模型来识别手写数字。
Step 8 ? Predict
步骤8-预测
Finally, predict the digit from images as below ?
最后，从图像预测位数，如下所示：

pred = model.predict(x_test)
pred = np.argmax(pred, axis = 1)[:5]
label = np.argmax(y_test,axis = 1)[:5]
print(pred)
print(label)

复制代码

The output of the above application is as follows ?
上述应用程序的输出如下-

[7 2 1 0 4]
[7 2 1 0 4]

复制代码

The output of both array is identical and it indicate our model correctly predicts the first five images.
两个数组的输出相同，这表明我们的模型正确预测了前五个图像。
Keras-使用MPL进行回归预测 (Keras - Regression Prediction using MPL)

In this chapter, let us write a simple MPL based ANN to do regression prediction. Till now, we have only done the classification based prediction. Now, we will try to predict the next possible value by analyzing the previous (continuous) values and its influencing factors.
在本章中，让我们编写一个基于MPL的简单ANN进行回归预测。到目前为止，我们仅完成了基于分类的预测。现在，我们将尝试通过分析先前(连续)的值及其影响因素来预测下一个可能的值。
The Regression MPL can be represented as below ?
回归MPL可以表示如下-

The core features of the model are as follows ?
该模型的核心特征如下-

Dense

mse

RMSprop

accuracy

准确性

Step 1 ? Import the modules
步骤1-导入模块
Let us import the necessary modules.
让我们导入必要的模块。

import keras
from keras.datasets import boston_housing
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import RMSprop
from keras.callbacks import EarlyStopping
from sklearn import preprocessing
from sklearn.preprocessing import scale

复制代码

Step 2 ? Load data
第2步-加载数据
Let us import the Boston housing dataset.
让我们导入波士顿住房数据集。

(x_train, y_train), (x_test, y_test) = boston_housing.load_data()

复制代码

Here,
这里，
boston_housing is a dataset provided by Keras. It represents a collection of housing information in Boston area, each having 13 features.
boston_housing是Keras提供的数据集。它代表了波士顿地区的住房信息收集，每个都有13个特征。
Step 3 ? Process the data
步骤3-处理数据
Let us change the dataset according to our model, so that, we can feed into our model. The data can be changed using below code ?
让我们根据模型更改数据集，以便可以将其输入模型。可以使用以下代码更改数据-

x_train_scaled = preprocessing.scale(x_train)
scaler = preprocessing.StandardScaler().fit(x_train)
x_test_scaled = scaler.transform(x_test)

复制代码

Here, we have normalized the training data using sklearn.preprocessing.scale function. preprocessing.StandardScaler().fit function returns a scalar with the normalized mean and standard deviation of the training data, which we can apply to the test data using scalar.transform function. This will normalize the test data as well with the same setting as that of training data.
在这里，我们使用sklearn.preprocessing.scale函数对训练数据进行了标准化 。 preprocessing.StandardScaler()。fit函数返回具有训练数据的标准化均值和标准偏差的标量，我们可以使用scalar.transform函数将其应用于测试数据。这也将使用与训练数据相同的设置来标准化测试数据。
Step 4 ? Create the model
步骤4-创建模型
Let us create the actual model.
让我们创建实际的模型。

model = Sequential()
model.add(Dense(64, kernel_initializer = 'normal', activation = 'relu',
input_shape = (13,)))
model.add(Dense(64, activation = 'relu')) model.add(Dense(1))

复制代码

Step 5 ? Compile the model
第5步-编译模型
Let us compile the model using selected loss function, optimizer and metrics.
让我们使用选定的损失函数，优化器和指标来编译模型。

model.compile(
loss = 'mse',
optimizer = RMSprop(),
metrics = ['mean_absolute_error']
)

复制代码

Step 6 ? Train the model
步骤6-训练模型
Let us train the model using fit() method.
让我们使用fit()方法训练模型。

history = model.fit(
x_train_scaled, y_train,
batch_size=128,
epochs = 500,
verbose = 1,
validation_split = 0.2,
callbacks = [EarlyStopping(monitor = 'val_loss', patience = 20)]
)

复制代码

Here, we have used callback function, EarlyStopping. The purpose of this callback is to monitor the loss value during each epoch and compare it with previous epoch loss value to find the improvement in the training. If there is no improvement for the patience times, then the whole process will be stopped.
在这里，我们使用了回调函数EarlyStopping 。此回调的目的是监视每个时期的损失值，并将其与以前的时期损失值进行比较，以找到训练方面的改进。如果耐心时间没有改善，则整个过程将停止。
Executing the application will give the below information as output ?
执行应用程序将给出以下信息作为输出-

Train on 323 samples, validate on 81 samples Epoch 1/500 2019-09-24 01:07:03.889046: I
tensorflow/core/platform/cpu_feature_guard.cc:142]
Your CPU supports instructions that this
TensorFlow binary was not co mpiled to use: AVX2 323/323
[==============================] - 0s 515us/step - loss: 562.3129
- mean_absolute_error: 21.8575 - val_loss: 621.6523 - val_mean_absolute_erro
r: 23.1730 Epoch 2/500
323/323 [==============================] - 0s 11us/step - loss: 545.1666
- mean_absolute_error: 21.4887 - val_loss: 605.1341 - val_mean_absolute_error
: 22.8293 Epoch 3/500
323/323 [==============================] - 0s 12us/step - loss: 528.9944
- mean_absolute_error: 21.1328 - val_loss: 588.6594 - val_mean_absolute_error
: 22.4799 Epoch 4/500
323/323 [==============================] - 0s 12us/step - loss: 512.2739
- mean_absolute_error: 20.7658 - val_loss: 570.3772 - val_mean_absolute_error
: 22.0853 Epoch 5/500
323/323 [==============================] - 0s 9us/step - loss: 493.9775
- mean_absolute_error: 20.3506 - val_loss: 550.9548 - val_mean_absolute_error: 21.6547
..........
..........
..........
Epoch 143/500
323/323 [==============================] - 0s 15us/step - loss: 8.1004
- mean_absolute_error: 2.0002 - val_loss: 14.6286 - val_mean_absolute_error:
2. 5904 Epoch 144/500
323/323 [==============================] - 0s 19us/step - loss: 8.0300
- mean_absolute_error: 1.9683 - val_loss: 14.5949 - val_mean_absolute_error:
2. 5843 Epoch 145/500
323/323 [==============================] - 0s 12us/step - loss: 7.8704
- mean_absolute_error: 1.9313 - val_loss: 14.3770 - val_mean_absolute_error: 2. 4996

复制代码

Step 7 ? Evaluate the model
步骤7-评估模型
Let us evaluate the model using test data.
让我们使用测试数据评估模型。

score = model.evaluate(x_test_scaled, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

复制代码

Executing the above code will output the below information ?
执行上面的代码将输出以下信息-

Test loss: 21.928471583946077 Test accuracy: 2.9599233234629914

复制代码

Step 8 ? Predict
步骤8-预测
Finally, predict using test data as below ?
最后，使用以下测试数据进行预测-

prediction = model.predict(x_test_scaled)
print(prediction.flatten())
print(y_test)

复制代码

The output of the above application is as follows ?
上述应用程序的输出如下-

[ 7.5612316 17.583357 21.09344 31.859276 25.055613 18.673872 26.600405 22.403967 19.060272 22.264952
17.4191 17.00466 15.58924 41.624374 20.220217 18.985565 26.419338 19.837091 19.946192 36.43445
12.278508 16.330965 20.701359 14.345301 21.741161 25.050423 31.046402 27.738455 9.959419 20.93039
20.069063 14.518344 33.20235 24.735163 18.7274 9.148898 15.781284 18.556862 18.692865 26.045074
27.954073 28.106823 15.272034 40.879818 29.33896 23.714525 26.427515 16.483374 22.518442 22.425386
33.94826 18.831465 13.2501955 15.537227 34.639984 27.468002 13.474407 48.134598 34.39617
22.8503124.042334 17.747198 14.7837715 18.187277 23.655672 22.364983 13.858193 22.710032 14.371148
7.1272087 35.960033 28.247292 25.3014 14.477208 25.306196 17.891165 20.193708 23.585173 34.690193
12.200583 20.102983 38.45882 14.741723 14.408362 17.67158 18.418497 21.151712 21.157492 22.693687
29.809034 19.366991 20.072294 25.880817 40.814568 34.64087 19.43741 36.2591 50.73806 26.968863 43.91787
32.54908 20.248306 ] [ 7.2 18.8 19. 27. 22.2 24.5 31.2 22.9 20.5 23.2 18.6 14.5 17.8 50. 20.8 24.3 24.2
19.8 19.1 22.7 12. 10.2 20. 18.5 20.9 23. 27.5 30.1 9.5 22. 21.2 14.1 33.1 23.4 20.1 7.4 15.4 23.8 20.1
24.5 33. 28.4 14.1 46.7 32.5 29.6 28.4 19.8 20.2 25. 35.4 20.3 9.7 14.5 34.9 26.6 7.2 50. 32.4 21.6 29.8
13.1 27.5 21.2 23.1 21.9 13. 23.2 8.1 5.6 21.7 29.6 19.6 7. 26.4 18.9 20.9 28.1 35.4 10.2 24.3 43.1 17.6
15.4 16.2 27.1 21.4 21.5 22.4 25. 16.6 18.6 22. 42.8 35.1 21.5 36. 21.9 24.1 50. 26.7 25. ]

复制代码

The output of both array have around 10-30% difference and it indicate our model predicts with reasonable range.
两种阵列的输出相差约10-30％，这表明我们的模型在合理范围内进行了预测。
Keras-使用LSTM RNN的时间序列预测 (Keras - Time Series Prediction using LSTM RNN)

In this chapter, let us write a simple Long Short Term Memory (LSTM) based RNN to do sequence analysis. A sequence is a set of values where each value corresponds to a particular instance of time. Let us consider a simple example of reading a sentence. Reading and understanding a sentence involves reading the word in the given order and trying to understand each word and its meaning in the given context and finally understanding the sentence in a positive or negative sentiment.
在本章中，让我们编写一个简单的基于RSTM的长期短期记忆(LSTM)进行序列分析。序列是一组值，其中每个值对应于特定的时间实例。让我们考虑一个简单的阅读句子的例子。阅读和理解句子包括按照给定的顺序阅读单词，并尝试在给定的上下文中理解每个单词及其含义，最后以积极或消极的态度理解句子。
Here, the words are considered as values, and first value corresponds to first word, second value corresponds to second word, etc., and the order will be strictly maintained. Sequence Analysis is used frequently in natural language processing to find the sentiment analysis of the given text.
在此，将单词视为值，第一个值对应于第一个单词，第二个值对应于第二个单词等，并且将严格保持顺序。 序列分析经常用于自然语言处理中，以查找给定文本的情感分析。
Let us create a LSTM model to analyze the IMDB movie reviews and find its positive/negative sentiment.
让我们创建一个LSTM模型来分析IMDB电影评论并找到其正面/负面情绪。
The model for the sequence analysis can be represented as below ?
序列分析的模型可以表示如下-

The core features of the model are as follows ?
该模型的核心特征如下-

Dense

binary_crossentropy

adam

亚当

accuracy

准确性

步骤1：导入模块 (Step 1: Import the modules)

Let us import the necessary modules.
让我们导入必要的模块。

from keras.preprocessing import sequence
from keras.models import Sequential
from keras.layers import Dense, Embedding
from keras.layers import LSTM
from keras.datasets import imdb

复制代码

步骤2：载入资料 (Step 2: Load data)

Let us import the imdb dataset.
让我们导入imdb数据集。

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words = 2000)

复制代码

Here,
这里，

imdb

num_words

步骤3：处理资料 (Step 3: Process the data)

Let us change the dataset according to our model, so that it can be fed into our model. The data can be changed using the below code ?
让我们根据我们的模型更改数据集，以便可以将其输入到我们的模型中。可以使用以下代码更改数据-

x_train = sequence.pad_sequences(x_train, maxlen=80)
x_test = sequence.pad_sequences(x_test, maxlen=80)

复制代码

Here,
这里，
sequence.pad_sequences convert the list of input data with shape, (data) into 2D NumPy array of shape (data, timesteps). Basically, it adds timesteps concept into the given data. It generates the timesteps of length, maxlen.
sequence.pad_sequences将形状为(data)的输入数据列表转换为形状(data，timesteps)的 2D NumPy数组。基本上，它将时间步概念添加到给定数据中。它生成长度maxlen的时间步长。
步骤4：建立模型 (Step 4: Create the model)

Let us create the actual model.
让我们创建实际的模型。

model = Sequential()
model.add(Embedding(2000, 128))
model.add(LSTM(128, dropout = 0.2, recurrent_dropout = 0.2))
model.add(Dense(1, activation = 'sigmoid'))

复制代码

Here,
这里，
We have used Embedding layer as input layer and then added the LSTM layer. Finally, a Dense layer is used as output layer.
我们已经使用嵌入层作为输入层，然后添加了LSTM层。最后， 密集层用作输出层。
步骤5：编译模型 (Step 5: Compile the model)

Let us compile the model using selected loss function, optimizer and metrics.
让我们使用选定的损失函数，优化器和指标来编译模型。

model.compile(loss = 'binary_crossentropy',
optimizer = 'adam', metrics = ['accuracy'])

复制代码

步骤6：训练模型 (Step 6: Train the model)

LLet us train the model using fit() method.
让我们使用fit()方法训练模型。

model.fit(
x_train, y_train,
batch_size = 32,
epochs = 15,
validation_data = (x_test, y_test)
)

复制代码

Executing the application will output the below information ?
执行应用程序将输出以下信息-

Epoch 1/15 2019-09-24 01:19:01.151247: I
tensorflow/core/platform/cpu_feature_guard.cc:142]
Your CPU supports instructions that this
TensorFlow binary was not co mpiled to use: AVX2
25000/25000 [==============================] - 101s 4ms/step - loss: 0.4707
- acc: 0.7716 - val_loss: 0.3769 - val_acc: 0.8349 Epoch 2/15
25000/25000 [==============================] - 95s 4ms/step - loss: 0.3058
- acc: 0.8756 - val_loss: 0.3763 - val_acc: 0.8350 Epoch 3/15
25000/25000 [==============================] - 91s 4ms/step - loss: 0.2100
- acc: 0.9178 - val_loss: 0.5065 - val_acc: 0.8110 Epoch 4/15
25000/25000 [==============================] - 90s 4ms/step - loss: 0.1394
- acc: 0.9495 - val_loss: 0.6046 - val_acc: 0.8146 Epoch 5/15
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0973
- acc: 0.9652 - val_loss: 0.5969 - val_acc: 0.8147 Epoch 6/15
25000/25000 [==============================] - 98s 4ms/step - loss: 0.0759
- acc: 0.9730 - val_loss: 0.6368 - val_acc: 0.8208 Epoch 7/15
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0578
- acc: 0.9811 - val_loss: 0.6657 - val_acc: 0.8184 Epoch 8/15
25000/25000 [==============================] - 97s 4ms/step - loss: 0.0448
- acc: 0.9850 - val_loss: 0.7452 - val_acc: 0.8136 Epoch 9/15
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0324
- acc: 0.9894 - val_loss: 0.7616 - val_acc: 0.8162Epoch 10/15
25000/25000 [==============================] - 100s 4ms/step - loss: 0.0247
- acc: 0.9922 - val_loss: 0.9654 - val_acc: 0.8148 Epoch 11/15
25000/25000 [==============================] - 99s 4ms/step - loss: 0.0169
- acc: 0.9946 - val_loss: 1.0013 - val_acc: 0.8104 Epoch 12/15
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0154
- acc: 0.9948 - val_loss: 1.0316 - val_acc: 0.8100 Epoch 13/15
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0113
- acc: 0.9963 - val_loss: 1.1138 - val_acc: 0.8108 Epoch 14/15
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0106
- acc: 0.9971 - val_loss: 1.0538 - val_acc: 0.8102 Epoch 15/15
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0090
- acc: 0.9972 - val_loss: 1.1453 - val_acc: 0.8129
25000/25000 [==============================] - 10s 390us/step

复制代码

步骤7-评估模型 (Step 7 ? Evaluate the model)

Let us evaluate the model using test data.
让我们使用测试数据评估模型。

score, acc = model.evaluate(x_test, y_test, batch_size = 32)
print('Test score:', score)
print('Test accuracy:', acc)

复制代码

Executing the above code will output the below information ?
执行上面的代码将输出以下信息-

Test score: 1.145306069601178
Test accuracy: 0.81292

复制代码

Keras-应用 (Keras - Applications)

Keras applications module is used to provide pre-trained model for deep neural networks. Keras models are used for prediction, feature extraction and fine tuning. This chapter explains about Keras applications in detail.
Keras应用程序模块用于为深度神经网络提供预训练的模型。 Keras模型用于预测，特征提取和微调。本章详细介绍了Keras应用程序。
预训练模型 (Pre-trained models)

Trained model consists of two parts model Architecture and model Weights. Model weights are large file so we have to download and extract the feature from ImageNet database. Some of the popular pre-trained models are listed below,
训练后的模型由架构和权重两部分组成。模型权重是大文件，因此我们必须从ImageNet数据库下载并提取特征。下面列出了一些流行的预训练模型，

载入模型 (Loading a model)

Keras pre-trained models can be easily loaded as specified below ?
Keras预训练模型可以轻松加载，如下所示：

import keras
import numpy as np
from keras.applications import vgg16, inception_v3, resnet50, mobilenet
#Load the VGG model
vgg_model = vgg16.VGG16(weights = 'imagenet')
#Load the Inception_V3 model
inception_model = inception_v3.InceptionV3(weights = 'imagenet')
#Load the ResNet50 model
resnet_model = resnet50.ResNet50(weights = 'imagenet')
#Load the MobileNet model mobilenet_model = mobilenet.MobileNet(weights = 'imagenet')

复制代码

Once the model is loaded, we can immediately use it for prediction purpose. Let us check each pre-trained model in the upcoming chapters.
加载模型后，我们可以立即将其用于预测目的。让我们在接下来的章节中检查每个预先训练的模型。
使用ResNet模型进行实时预测 (Real Time Prediction using ResNet Model)

ResNet is a pre-trained model. It is trained using ImageNet. ResNet model weights pre-trained on ImageNet. It has the following syntax ?
ResNet是一个预先训练的模型。它使用ImageNet进行培训。在ImageNet上预训练的ResNet模型权重。它具有以下语法-

keras.applications.resnet.ResNet50 (
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000
)

复制代码

Here,
这里，

include_top

weights

权重

input_tensor

input_shape

input_shape表示

classes

类

Let us understand the model by writing a simple example ?
让我们通过写一个简单的例子来理解模型-
步骤1：导入模块 (Step 1: import the modules)

Let us load the necessary modules as specified below ?
让我们加载以下指定的必要模块-

>>> import PIL
>>> from keras.preprocessing.image import load_img
>>> from keras.preprocessing.image import img_to_array
>>> from keras.applications.imagenet_utils import decode_predictions
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> from keras.applications.resnet50 import ResNet50
>>> from keras.applications import resnet50

复制代码

步骤2：选择输入 (Step 2: Select an input)

Let us choose an input image, Lotus as specified below ?
让我们选择一个输入图像， Lotus如下所示-

>>> filename = 'banana.jpg'
>>> ## load an image in PIL format
>>> original = load_img(filename, target_size = (224, 224))
>>> print('PIL image size',original.size)
PIL image size (224, 224)
>>> plt.imshow(original)
<matplotlib.image.AxesImage object at 0x1304756d8>
>>> plt.show()

复制代码

Here, we have loaded an image (banana.jpg) and displayed it.
在这里，我们加载了图像(banana.jpg)并显示了它。
步骤3：将图片转换成NumPy数组 (Step 3: Convert images into NumPy array)

Let us convert our input, Banana into NumPy array, so that it can be passed into the model for the purpose of prediction.
让我们将输入Banana转换为NumPy数组，以便可以将其传递到模型中以进行预测。

>>> #convert the PIL image to a numpy array
>>> numpy_image = img_to_array(original)
>>> plt.imshow(np.uint8(numpy_image))
<matplotlib.image.AxesImage object at 0x130475ac8>
>>> print('numpy array size',numpy_image.shape)
numpy array size (224, 224, 3)
>>> # Convert the image / images into batch format
>>> image_batch = np.expand_dims(numpy_image, axis = 0)
>>> print('image batch size', image_batch.shape)
image batch size (1, 224, 224, 3)
>>>

复制代码

步骤4：模型预测 (Step 4: Model prediction)

Let us feed our input into the model to get the predictions
让我们将输入信息输入模型以获取预测

>>> prepare the image for the resnet50 model >>>
>>> processed_image = resnet50.preprocess_input(image_batch.copy())
>>> # create resnet model
>>>resnet_model = resnet50.ResNet50(weights = 'imagenet')
>>> Downloavding data from https://github.com/fchollet/deep-learning-models/releas
es/download/v0.2/resnet50_weights_tf_dim_ordering_tf_kernels.h5
102858752/102853048 [==============================] - 33s 0us/step
>>> # get the predicted probabilities for each class
>>> predictions = resnet_model.predict(processed_image)
>>> # convert the probabilities to class labels
>>> label = decode_predictions(predictions)
Downloading data from https://storage.googleapis.com/download.tensorflow.org/
data/imagenet_class_index.json
40960/35363 [==================================] - 0s 0us/step
>>> print(label)

复制代码

输出量 (Output)

[
[
('n07753592', 'banana', 0.99229723),
('n03532672', 'hook', 0.0014551596),
('n03970156', 'plunger', 0.0010738898),
('n07753113', 'fig', 0.0009359837) ,
('n03109150', 'corkscrew', 0.00028538404)
]
]

复制代码

Here, the model predicted the images as banana correctly.
在此，模型正确地将图像预测为香蕉。

Keras-预训练模型 (Keras - Pre-Trained Models)

In this chapter, we will learn about the pre-trained models in Keras. Let us begin with VGG16.
在本章中，我们将学习Keras中的预训练模型。让我们从VGG16开始。
VGG16 (VGG16)

VGG16 is another pre-trained model. It is also trained using ImageNet. The syntax to load the model is as follows ?
VGG16是另一种预训练模型。它还使用ImageNet进行了培训。加载模型的语法如下-

keras.applications.vgg16.VGG16(
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000
)

复制代码

The default input size for this model is 224x224.
该模型的默认输入大小为224x224。
MobileNetV2 (MobileNetV2)

MobileNetV2 is another pre-trained model. It is also trained uing ImageNet.
MobileNetV2是另一种预先训练的模型。它还使用ImageNet进行了培训。
The syntax to load the model is as follows ?
加载模型的语法如下-

keras.applications.mobilenet_v2.MobileNetV2 (
input_shape = None,
alpha = 1.0,
include_top = True,
weights = 'imagenet',
input_tensor = None,
pooling = None,
classes = 1000
)

复制代码

Here,
这里，
alpha controls the width of the network. If the value is below 1, decreases the number of filters in each layer. If the value is above 1, increases the number of filters in each layer. If alpha = 1, default number of filters from the paper are used at each layer.
alpha控制网络的宽度。如果该值小于1，则减少每层中的过滤器数量。如果该值大于1，则增加每层中的过滤器数量。如果alpha = 1，则在每一层使用纸张的默认过滤器数量。
The default input size for this model is 224x224.
该模型的默认输入大小为224x224 。
盗版ResNetV2 (InceptionResNetV2)

InceptionResNetV2 is another pre-trained model. It is also trained using ImageNet. The syntax to load the model is as follows ?
InceptionResNetV2是另一个预先训练的模型。它还使用ImageNet进行了培训。加载模型的语法如下-

keras.applications.inception_resnet_v2.InceptionResNetV2 (
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000)

复制代码

This model and can be built both with ‘channels_first’ data format (channels, height, width) or ‘channels_last’ data format (height, width, channels).
此模型可以使用“ channels_first”数据格式(通道，高度，宽度)或“ channels_last”数据格式(高度，宽度，通道)构建。
The default input size for this model is 299x299.
该模型的默认输入大小为299x299 。
盗梦空间V3 (InceptionV3)

InceptionV3 is another pre-trained model. It is also trained uing ImageNet. The syntax to load the model is as follows ?
InceptionV3是另一个预先训练的模型。它还使用ImageNet进行了培训。加载模型的语法如下-

keras.applications.inception_v3.InceptionV3 (
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000
)

复制代码

Here,
这里，
The default input size for this model is 299x299.
该模型的默认输入大小为299x299 。
结论 (Conclusion)

Keras is very simple, extensible and easy to implement neural network API, which can be used to build deep learning applications with high level abstraction. Keras is an optimal choice for deep leaning models.
Keras是非常简单，可扩展且易于实现的神经网络API，可用于构建具有高级抽象的深度学习应用程序。 Keras是深层倾斜模型的最佳选择。

翻译自: https://www.tutorialspoint.com/keras/keras_quick_guide.htm

keras安装与配置指南

<div id="marketingBox" class="marketing-box"><div class="marketing-content">

CSDN 社区图书馆，开张营业！

深读计划，写书评领图书福利~

		自动登录	找回密码
密码			立即注册

keras安装与配置指南_Keras-快速指南

本帖子中包含更多资源