TensorFlow2 深度学习项目（一）

随笔3周前发布离

44 0 0

原文：Deep Learning Projects Using TensorFlow 2

协议：CC BY-NC-SA 4.0

一、入门：安装和故障排除

为了充分利用这本书，你需要满足以下先决条件:

安装 Python 3，Python 的最新版本
安装 Jupyter 笔记本
安装 TensorFlow 2.0
硬安装
安装 NumPy
安装科学软件
安装 Matplotlib
安装熊猫
安装 Scikit-Learn

本章将帮助你安装所有必要的软件包。它还针对安装过程中可能出现的一些常见错误提供了故障排除提示。

Note

为这些项目创建单独的虚拟环境是一种很好的做法。在安装这里提到的包之前，创建一个虚拟环境并激活它。

安装 Python 3

Python 是一种通用解释型、命令式、面向对象的高级编程语言。它是最古老的编程语言之一。然而，随着机器学习的出现，Python 获得了新生。它已经成为机器学习和深度学习的流行工具。目前，Python 有两个不同的版本——Python 2 和 Python 3。

本书所有项目都使用 Python 3，所以最好确保安装了。

方法 1:从 Python 官方网站直接安装

这种方法适用于 Windows、Linux 和 macOS X 系统。这是标准的安装方法，你可以直接从官方网站下载 Python，然后安装到你的系统上。

Go to https://www.python.org/ and select the Downloads tab. A drop-down menu will appear (see Figure 1-1).

图 1-1

Python 官方网站
在下拉菜单的右侧，您将看到适用于您的特定系统的最新 Python 版本。第一个按钮提供最新版本的 Python 3。一旦你点击它，下载将开始。
下载完成后，双击下载栏中的包。这将启动安装过程。
In the dialog box that pops up, select Continue (see Figure 1-2).

图 1-2

Python 安装的介绍窗口
In the new dialog box, you will be presented with important information regarding the changes made to Python (see Figure 1-3). Once again, select Continue.

图 1-3

Python 安装的自述窗口
Now you will be shown the license agreement for using Python. Select Continue (see Figure 1-4).

图 1-4

Python 安装的许可窗口
将出现一个迷你对话框，要求您同意列出的条款和条件。选择同意。
选择新 Python 安装的文件路径。
Select the type of installation. See Figure 1-5.

图 1-5

Python 安装的安装类型窗口
Finally, you will be told how much memory will be used on your system. Select Install (see Figure 1-6).

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig6_HTML.jpg&pos_id=img-JtknJFfr-1724151589566)

图 1-6

Python 安装的存储警告窗口
1
2
3
4
5

该对话框将显示一个进度条，指示安装完成了多少。这应该只需要几分钟，取决于您系统的内存和速度。
Once the installation is complete, you will be presented with a dialog box indicating that the installation was successful, as shown in Figure 1-7.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig7_HTML.jpg&pos_id=img-aZAni7Zo-1724151589566)

图 1-7

Python 安装的摘要窗口
1
2
3
4
5

To test the installation, open the terminal (see Figure 1-8), type python 3, and press Enter.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig8_HTML.jpg&pos_id=img-4A0QRnY4-1724151589566)

图 1-8

在终端中运行 Python
1
2
3
4
5

现在输入命令print ("Hello World!")并按回车键。
This will print the words 'Hello World!' in the terminal, as shown in Figure 1-9.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig9_HTML.jpg&pos_id=img-LwwyBtT0-1724151589566)

图 1-9

测试 Python 安装
1
2
3
4
5

故障排除提示

在 Linux 系统上，你可能会得到一个错误信息，说pip需要ssl，如图 1-10 所示。

TensorFlow2 深度学习项目（一）

图 1-10

PIP 需要 SSL 警告

要安装ssl，请使用以下命令:

sudo apt-get install libssl-dev openssl

1
2

完成后，使用以下命令:

sudo make install

1
2

Python 现在应该已经成功安装在您的系统上了。

在 Windows 系统上，请按照下列步骤操作:

打开终端测试安装。
键入python —version并按回车键。
Python 安装的版本应该会显示出来。

方法 2:使用 Anaconda

这种方法适用于 Windows 和 Linux 系统。Anaconda 是一个桌面图形用户界面(GUI ),允许您启动应用程序并轻松管理 conda 包、环境和通道，而无需使用命令行。

Download and install Anaconda from https://www.anaconda.com/distribution/. See Figure 1-11.

图 1-11

Anaconda 的官方网站
选择 Python 3 的图形安装程序，因为它是最容易使用的。
In the pop-up window, select Continue. See Figure 1-12.

图 1-12

Anaconda 安装的介绍窗口
Read the important information and click Continue. See Figure 1-13.

图 1-13

Anaconda 安装的“自述”窗口
Read the license and click Continue to accept it. See Figure 1-14.

图 1-14

Anaconda 安装的许可窗口
选择“仅为我安装”(除非您是为所有用户安装)，然后单击“下一步”。
Select a destination folder to install Anaconda and click the Next button. See Figure 1-15.

图 1-15

Anaconda 安装的“选择目标”窗口
In the dialog box, select Add Anaconda to My PATH Environment Variable, as this will automatically create the path in the bash file. See Figure 1-16.

图 1-16

Anaconda 安装的高级选项窗口
选择是否将 Anaconda 注册为默认 Python 版本。除非您计划安装和运行多个版本的 Anaconda，或者多个版本的 Python，否则请接受默认设置并选中此框。
Click the Install button. The installation will begin, as shown in Figure 1-17.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig17_HTML.jpg&pos_id=img-7sArWNFv-1724151589567)

图 1-17

Anaconda 安装的安装窗口
1
2
3
4
5

单击下一步按钮。
Once the installation is complete, click the Anaconda icon to run Anaconda.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig18_HTML.jpg&pos_id=img-yq4cNDnI-1724151589568)

图 1-18

蟒蛇图标
1
2
3
4
5

Create a new environment by clicking Environments, as shown in Figure 1-19.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig19_HTML.jpg&pos_id=img-9QbFlqCj-1724151589568)

图 1-19

环境按钮
1
2
3
4
5

Next, click the Create button, as shown in Figure 1-20.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig20_HTML.jpg&pos_id=img-HkEQHnrh-1724151589568)

图 1-20

“创建”按钮
1
2
3
4
5

Enter the name of the new environment and select Python 3.7 as the default language. See Figure 1-21.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig21_HTML.jpg&pos_id=img-esbAeytX-1724151589568)

图 1-21

选择 Python 3.7(本书出版时 Python 的最新版本)
1
2
3
4
5

To test the installation, type source activate vin in the terminal, where vin is the name of your environment. See Figure 1-22.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig22_HTML.jpg&pos_id=img-vbpesICm-1724151589568)

图 1-22

从终端激活新创建的环境
1
2
3
4
5

To test the Python installation, type python 3 and press Enter. See Figure 1-23.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig23_HTML.jpg&pos_id=img-3YNsX5if-1724151589568)

图 1-23

运行 Python
1
2
3
4
5

Now type "Hello World!" and press Enter. This will print the words 'Hello World!' in the terminal, as shown in Figure 1-24.

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgitee.com%2FOpenDocCN%2Fvkdoc-dl-zh%2Fraw%2Fmaster%2Fdocs%2Fdl-proj-tf2%2Fimg%2F488562_1_En_1_Fig24_HTML.jpg&pos_id=img-C3GgHQKR-1724151589568)

图 1-24

在终端中测试 Python
1
2
3
4
5

故障排除提示

确保您选择了创建路径参数的选项，因为您必须将 Python 和 conda 添加到您的环境变量中。如果您在安装过程中错过了这一步，您可以通过在命令提示符下键入setx命令来手动完成，如下所示:

类型SETX PATH "%PATH%; C: Usersuser_nameAnacondaScripts; C: Usersuser_nameAnaconda。
用您系统上的用户名替换user_name。
关闭当前的命令提示符并打开一个新的命令提示符。
尝试在命令提示符下键入python和conda来查看路径是否被保存。

请注意，直接安装方法适用于所有系统。如果从官方 Python 网站直接安装给你带来麻烦，使用brew作为替代方法:

Type $ brew update. See Figure 1-25.

图 1-25

在终端中更新 brew
Then type $ brew install python3. See Figure 1-26.

图 1-26

在终端中打开 Python

安装 Python 之后，您就可以安装 Jupyter Notebook 了，您将使用它来记录本书中的项目。

安装 Jupyter 笔记本电脑

Jupyter 笔记本是开源软件。这是一个机器学习的便捷工具。你可以把它用于工作中的项目，或者自己修改机器学习概念，因为它提供了一种很好的方式来记录你的工作，以便其他人可以轻松地理解和复制你的项目。在本书中，我们将使用 Jupyter 笔记本。

属国

python3

方法 1:使用 PIP 安装包

PIP 是 Python 包或模块的包管理器。Python 版及更高版本默认包含 PIP。

Open the terminal and type pip install jupyter notebook. See Figure 1-27.

图 1-27

使用终端安装 jupiter 笔记本
安装将需要几秒钟时间。
To test the installation, type jupyter notebook at the command prompt in the terminal. See Figure 1-28.

图 1-28

通过终端运行 Jupyter 笔记本
Information about the notebook will be shown in the terminal. Then the Jupyter Notebook dashboard will open in the browser. See Figure 1-29.

图 1-29

Jupyter 笔记本界面

故障排除提示

有时您可能需要在命令提示符下键入jupyter-notebook来启动它。

方法 2:使用 Anaconda

如果你安装了 Anaconda，Jupyter 笔记本已经为你安装好了。您可以使用以下步骤打开 Anaconda 来启动 Jupyter Notebook:

打开 Anaconda Navigator 仪表板。
Click Jupyter Notebook. See Figure 1-30.

图 1-30

巨蟒之灾中的朱庇特笔记本

将打开一个新的 web 浏览器，其中包含 Jupyter 仪表板。

故障排除提示

确保 Anaconda 目录PATH已经正确地添加到环境变量部分。如果没有添加这个路径，您需要定位 Anaconda 目录/文件路径，并手动将其添加到环境变量。

现在你已经安装了 Jupyter 笔记本，你准备安装 TensorFlow 2.0。

安装 TensorFlow 2.0

TensorFlow 是一个面向研究和生产的开源机器学习库，由 Google 开发。它有一个陡峭的学习曲线，但随着目前处于测试阶段的 2.0 版本的推出，TensorFlow 变得更加用户友好。本书中的所有项目我们都将使用 TensorFlow 2.0。

属国

python3

方法 1:使用 PIP 安装包

PIP 提供了一种简单的方法，用一行代码就可以安装 TensorFlow。

Open the terminal and type pip install tensorflow==2.0.0. See Figure 1-31.

图 1-31

通过终端安装 TensorFlow 2.0
安装将需要几秒钟时间。
在 Jupyter 中打开一个新笔记本。
To test the installation, type import tensorflow in a new cell, as shown in Figure 1-32.

图 1-32

通过 Jupyter 笔记本测试 TensorFlow 2.0 安装
现在输入tensorflow.__version__。
运行手机。
TensorFlow 安装的版本将显示在单元格下。

故障排除提示

建议为 TensorFlow 创建一个新的虚拟环境。我们可以使用 virtualenv 或 Anaconda 来创建一个新环境。

方法 2:使用 Anaconda

Open the terminal and type conda create -n tf_env tensorflow. See Figure 1-33.

图 1-33

使用 Anaconda 安装 TensorFlow 2.0
设置需要几秒钟。
Now type conda activate tf_env. See Figure 1-34.

图 1-34

用 TensorFlow 2.0 激活新创建的环境

故障排除提示

使用 Anaconda 时，确保新的 conda 环境安装了 Python 和 TensorFlow 2.0。

现在，您已经安装了 TensorFlow 2.0，可以安装 Keras 了。

安装 Keras

Keras 是一个高级神经网络 API，用 Python 编写，能够运行在 TensorFlow 之上。TensorFlow 2.0 中的更新使其严重依赖 Keras。

属国

python3
TensorFlow 2.0

使用 PIP 安装包

我们使用 PIP 来安装 Keras，因为它可以在任何系统上工作，并且只需要一行代码。

Open the terminal and type pip install keras. See Figure 1-35.

图 1-35

通过终端安装 Keras
安装将需要几秒钟时间。
在 Jupyter 中打开一个新笔记本。
要测试安装，请在新的单元格中键入import keras。
Now type pip list | grep Keras and run the cell. See Figure 1-36.

图 1-36

通过 Jupyter 笔记本测试 Keras 安装
Keras 安装的版本将显示在单元格下。

故障排除提示

如果 TensorFlow 不是 Keras 安装的默认后端，您可以通过以下步骤手动更改它:

在您的系统上找到keras.backend.__init__.py文件。
注释环境变量import。

既然已经安装了 Keras，就可以安装基本的 Python 库了。

安装 Python 库

在本书中，我们将使用基本的 Python 库进行数据预处理。轻松安装所有 Python 库的最佳方式是使用 PIP。

安装 NumPy

NumPy 是 Python 编程语言的一个库。它增加了对大型多维数组和矩阵的支持，以及对这些数组进行操作的大量高级数学函数和工具。它是用 Python 和 C 写的，由 BSD 分发。

属国

python3

使用 PIP 安装包

Open the terminal and type pip install numpy. See Figure 1-37.

图 1-37

通过终端安装 NumPy
安装将需要几秒钟时间。
在 Jupyter 中打开一个新笔记本。
要测试安装，请在新的单元格中键入import numpy。
Now type numpy.version.version and run the cell. See Figure 1-38.

图 1-38

通过 Jupyter 笔记本测试 NumPy
您的 NumPy 安装版本将显示在单元格下。

故障排除提示

如果出现错误信息，请尝试sudo pip install -U numpy命令。
使用 pip3。

既然已经安装了 NumPy，就可以安装 SciPy 了。

安装 SciPy

SciPy 是一个用于科学和技术计算的免费开源 Python 库。SciPy 包含用于优化、线性代数、积分、插值、特殊函数、FFT(快速傅立叶变换)、信号和图像处理、ODE 求解器以及科学和工程中常见的其他任务的模块。它是用 Python、Fortran、C 和 C++编写的，并在 BSD-new 许可下发布。

属国

python3
NumPy

使用 PIP 安装包

Open the terminal and type pip install scipy. See Figure 1-39.

图 1-39

通过终端安装 SciPy
安装将需要几秒钟时间。
在 Jupyter 中打开一个新笔记本。
要测试安装，请在新的单元格中键入import scipy。
Now type scipy.version.version and run the cell. See Figure 1-40.

图 1-40

通过 Jupyter 笔记本测试 SciPy 安装
SciPy 安装的版本将显示在单元格下。

故障排除提示

如果出现错误信息，请尝试sudo pip install -U scipy命令。
使用 pip3。

既然已经安装了 SciPy，就可以安装 Matplotlib 了。

安装 Matplotlib

Matplotlib 是 Python 编程语言和 NumPy 数字数学扩展的绘图库。Matplotlib 提供了一个面向对象的 API，用于使用通用 GUI 工具包将绘图嵌入到应用程序中。

属国

python3
NumPy
我的天啊

使用 PIP 安装包

Open the terminal and type pip install matplotlib. See Figure 1-41.

图 1-41

通过终端安装 Matplotlib
安装将需要几秒钟时间。
在 Jupyter 中打开一个新笔记本。
要测试安装，请在新的单元格中键入import matplotlib。
Now type matplotlib.version.version and run the cell. See Figure 1-42.

图 1-42

通过 Jupyter 笔记本测试 Matplotlib 安装
Matplotlib 安装的版本将显示在单元格下。

故障排除提示

如果出现错误信息，请尝试sudo pip install -U matplotlib命令。
使用 pip3。

现在您已经安装了 Matplotlib，您可以开始安装 Pandas 了。

安装熊猫

Pandas 是一个为 Python 编程语言编写的软件库，用于数据操作和分析。它提供数据结构和操作来操作数字表和时间序列。

它是在三条款 BSD 许可下发布的自由软件。它是用 Python 和 C 写的，原作者是 Wes McKinney。

属国

python3
NumPy
我的天啊
Matplotlib

使用 PIP 安装包

Open the terminal and type pip install pandas. The installation will take a few seconds. See Figure 1-43.

图 1-43

通过终端的熊猫装置
在 Jupyter 中打开一个新笔记本。
要测试安装，请在新的单元格中键入import pandas。
Now type pandas.__version__ and run the cell. See Figure 1-44.

图 1-44

通过 Jupyter 笔记本测试熊猫
Pandas 安装的版本将显示在单元格下。

故障排除提示

如果出现错误信息，请尝试sudo pip install -U pandas命令。
使用 pip3。

现在您已经安装了 Pandas，您已经准备好安装 Scikit- Learn 了。

安装 Scikit-学习

Scikit-Learn 是 Python 编程语言的免费软件机器学习库。它具有各种分类、回归和聚类算法，包括支持向量机。

它适用于 Linux、macOS 和 Windows，并在 BSD 许可下发布。

属国

python3
NumPy
我的天啊
Matplotlib
熊猫

使用 PIP 安装包

Open the terminal and type pip install sklearn. See Figure 1-45.

图 1-45

通过终端安装 Scikit-Learn
安装将需要几秒钟时间。
在 Jupyter 中打开一个新笔记本。
要测试安装，请在新的单元格中键入import sklearn。
Now type sklearn.__version__ and run the cell. See Figure 1-46.

图 1-46

通过 Jupyter 笔记本测试 Scikit-Learn 安装
该单元格下将显示sklearn安装的版本。

故障排除提示

如果出现错误信息，请尝试sudo pip install -U sklearn命令。
使用 pip3。

安装 Scikit-Learn 后，您就可以使用 TensorFlow 2.0 学习深度学习的基础知识了。

摘要

在本章中，您学习了如何安装所有必要的软件包，以便在后面的章节中学习。

二、感知器

在我们开始深度学习并讨论如何使用神经网络之前，我们需要了解什么是神经网络。特别是，我们需要了解神经网络的最基本单元，感知器。一个感知器是神经网络的基本单元，其建模方式与人脑中的神经元非常相似。

生物神经元

生物神经元是人工神经元的灵感来源。通过模仿生物神经元的工作方式，人类已经使机器能够独立思考。生物神经元是人类神经系统的基本结构和功能单位(见图 2-1 )。人脑中大约有 860 亿个神经元，约占所有脑细胞的 10%。它们相互连接形成一个网络，参与处理和传输化学和电子信号。细胞核处理从树突接收的信息。轴突是神经元用来发送信息的电缆。每个神经元都由以下部分组成:

TensorFlow2 深度学习项目（一）

图 2-1

基本神经元结构

细胞体(又称细胞体
树突
轴突

这让我们清楚地了解了生物神经元是如何工作的。现在，让我们比较一下生物神经元和人工神经元的工作方式。

人工神经元

一个人工神经元是一个数学函数，模仿生物神经元的工作。每个神经元接受输入，分别加权，求和，然后通过一个非线性函数产生输出。每个神经元都有一种叫做*激活信号的内部状态。*每个神经元通过连接链路连接到另一个神经元。

人工神经元的组件包括以下内容:

输入信号
砝码
偏见
净投入
激活功能
输出信号

最简单的人工神经元叫做感知器。我们来详细看看感知器。

感觉

感知器是一种算法，用于二进制分类器的监督学习。感知器算法学习输入信号的权重，以便绘制线性决策边界。

这是一种分类算法，它基于将一组权重与特征向量相结合的线性预测函数来进行所有预测。

有两种类型的感知器:

单层感知器，处理能力有限。
多层感知器或前馈神经网络具有更强的处理能力，因为它们包含两层或更多层。

为了更好地了解感知器是如何工作的，让我们来讨论一下感知器学习规则。

感知机学习规则

感知器学习规则规定，算法将自动学习最佳权重系数。感知器接收多个输入信号，如果输入信号的总和超过某个阈值，它要么发送信号，要么不返回输出。在监督学习和分类的情况下，这可以用于预测样本的类别。

在我们开始创建感知机之前，我们需要知道如何“激活”它，以帮助它正确处理数据并获得有用的输出。让我们来看看基本的激活功能。

激活功能的类型

为了简单起见，我们在本章中介绍了三个最常用的激活功能:

Sigmoid 函数
ReLU 函数
Softmax 函数

Sigmoid 激活函数

Sigmoid 函数是具有 Sigmoid 曲线的数学函数，也称为“S”曲线(见图 2-2 )。这是逻辑函数的一种特殊情况，导致值的概率在 0 和 1 之间。

TensorFlow2 深度学习项目（一）

图 2-2

S 形曲线

当我们希望关注概率映射而不是输入参数的精确值时，这是一个有用的激活函数。

Sigmoid 函数的优点如下:

它特别适用于我们必须预测概率作为输出的模型。既然任何事物的概率只存在于 0 到 1 的范围内，那么 Sigmoid 就是正确的选择。
我们可以在任意两点找到 s 形曲线的斜率。这意味着函数是可微的。
这个函数是单调的，但它的导数不是。这意味着函数以这样一种方式变化，它要么从不减少，要么从不增加，但 Sigmoid 函数的导数不是单调的。

Sigmoid 函数的限制如下:

对于高度负输入，Sigmoid 输出接近于零。
这可能是神经网络训练中的一个问题，并且可能导致学习缓慢以及模型在训练期间陷入局部最小值。
由于消失梯度问题，Sigmoid 函数不能用于多层网络。

ReLU 函数

整流器或 ReLU(整流线性单元)允许我们消除人工神经网络中的负值，因为它是分段线性函数。如果为正，则直接输出输入；否则将给出0作为输出(见图 2-3 )。

TensorFlow2 深度学习项目（一）

图 2-3

ReLU 激活功能

ReLU 函数的优点包括:

允许在大型和复杂数据集上更快和有效地训练深度神经架构。
神经网络中仅约 50%单元的稀疏激活(因为负值被消除)。
有效的梯度传播，这意味着没有消失或爆炸梯度问题。
只有比较、加法或乘法的高效计算。
伸缩性好。

ReLU 功能的限制包括:

在零点不可微。这意味着接近零的值可能会产生不一致或难以处理的结果。
非零居中。这造成了数据的不对称性(因为只处理正值)，导致数据处理不均衡。
输出值没有限制，并且在传递大值时会导致计算问题。
当学习率太高时，ReLU 神经元会变得不活跃并“死亡”

Softmax 函数

Softmax 或归一化指数函数是逻辑函数的推广，它输出结果属于某个类集的概率。它将任意实值的 K 维向量转换为范围(0，1)内加起来等于 1 的 K 维实值向量(见图 2-4 )。它类似于神经网络末端的分类逻辑。

TensorFlow2 深度学习项目（一）

图 2-4

Softmax 激活功能

Softmax 功能的优点包括:

突出显示最大值。
抑制明显低于最大值的值。
训练和预测都很快。

Softmax 功能的缺点包括:

它不支持空拒绝，所以如果需要的话，我们需要用一个特定的空类来训练算法。

现在你已经知道什么是感知器，并介绍了它所需的激活功能，让我们看看感知器是如何工作的。

行动中的感知

感知器过程由四个阶段组成(见图 2-5 )。接下来的几节将逐一讨论。

TensorFlow2 深度学习项目（一）

图 2-5

感知器处理输入

阶段 1:输入的前向传播

感知器接受特征形式的输入，并对其进行处理以预测输出。将该输出与标签进行比较，以测量误差。这被称为正向传播。

图中感知器的输入由[x1,x2......x (n)]表示，其中x代表特征值，n代表特征总数。在图 2-5 中，我们取 1 为常数，这样它可以乘以偏差而不改变其值。

接下来，计算净输入。

第二阶段:净投入的计算

砝码

权重是训练模型时随时间计算的值。我们用[w1,w2,.....w(n)]来表示感知器的权重。

感知器算法的权重是使用梯度下降从训练数据中估计的。

偏见

在代数术语中，偏差允许分类器在指定的方向上将其决策边界向左或向右平移一个恒定的距离。这种偏差有助于更快、更好地训练模型。

在图 2-5 所示的例子中，偏置用w₀表示。

净投入

净输入是连续发生的两次计算的结果:

首先是每个权重[w(n)]与其相关特征值[x(n)]的乘积。
然后将偏差[w ₀ ]添加到乘积中。

现在我们有了网络输入，是时候应用激活函数了。

第三阶段:激活功能

激活函数为感知器提供非线性。在当前示例中，我们使用 Sigmoid 函数作为激活函数。Sigmoid 函数是为实输入值定义的，并且在每个点上具有非负导数。输出介于 0 和 1 之间。

Sigmoid 函数表示为f(x) = 1/1+e^-x。

至此，前向传播完成，但感知器和人工神经元的美妙之处通常在于反向传播过程，在此过程中会发生重新计算。

阶段 4:反向传播

误差反向传播有时简称为 back-propagation 。它是一种用于使用梯度下降的人工神经网络的监督学习的机制。

梯度下降是一种优化算法，用于找到使成本函数最小化的函数参数值。该方法计算误差函数相对于神经网络权重的梯度。误差计算是通过比较输出和标签来完成的。

预测过程接受输入，并根据其过去的“训练经验”，使用内部状态生成最可能的输出在每次迭代期间计算损失函数，并使用优化函数将其最小化，直到实现收敛。损失函数是对模型计算中的误差的计算。最优化是最小化损失的方法。

梯度的计算通过网络反向进行。这意味着首先计算神经网络最后一层输出的梯度，最后计算第一层的梯度。

来自一个层的梯度的部分计算被重新用于计算前一层的梯度。这种反向信息流允许有效计算每层的梯度。

这种优化算法的工作方式是每次向模型显示一个训练实例。该模型对训练实例进行预测，计算误差，并且更新该模型以便减少下一次预测的误差。该过程可用于找到模型中的一组权重，该组权重导致模型在训练数据上的最小误差。偏差以类似的方式更新，只是没有输入，因为它与特定的输入值无关。

让我们通过使用 TensorFlow 2.0 创建我们自己的感知器来更好地理解感知器的工作原理。

项目描述

在本教程中，我们将使用感知器对结构化数据进行分类。这些是在我们的感知机中会发生的步骤:

特征和权重被视为矩阵并相乘。
然后将矩阵乘法的乘积加到偏差上。
使用损失函数计算误差，并进行优化。

图 2-6 提供了一个简单的例子来帮助显示个人感知机是如何工作的。

TensorFlow2 深度学习项目（一）

图 2-6

感知器流程图

重要术语

**目标/标签:**函数的预期输出。
**损失函数:**计算每次迭代的误差。误差计算为预期输出值和预测值之间的差值。
**优化器:**它最小化损失函数。
**迭代:**要进行训练的次数。
**混淆矩阵:**它将预测值与目标值进行比较，用一个矩阵表示正确和不正确观测值的个数。

必需的库

我们将与以下库合作:

TensorFlow 2.0
硬
NumPy
我的天啊
熊猫
Matplotlib
Scikit-Learn

程序

在本教程中，我们将通过使用 TensorFlow 分类结构化数据来实现感知器。

第一步。导入库

首先导入必要的库。

import numpy as np
import pandas as pd
import tensorflow as tf

from tensorflow import feature_column #reformats structured data for ease in calculations
from tensorflow.keras import layers #to create the layer in the neural network.
from sklearn.model_selection import train_test_split #splits the data for us

from sklearn.metrics import confusion_matrix #calculates the confusion matrix
from sklearn.metrics import accuracy_score #calculates the accuracy score

import matplotlib.pyplot as plt
%matplotlib inline
#so that plots remain within the cell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

第二步。声明参数

在本教程中，我们将两个特征作为输入。这里，units表示当前层中存在的神经元的数量。

Number_of_features=2
Number_of_units=1 #indicates number of neurons

1
2
3

第三步。宣布权重和偏差

使用tf.Variable()初始化权重变量，并将其命名为weights。使用tf.zeros()将weights变量设置为0。接下来，使用tf.Variable()初始化偏差变量，并将其命名为bias。使用tf.zeros()将bias变量设置为0。

weight=tf.Variable(tf.zeros([Number_of_features,Number_of_units])) #initializing to zero
bias=tf.Variable(tf.zeros([Number_of_units]))#Initializing to zero

1
2
3

第四步。定义感知器函数

使用def perceptron(x)定义感知器功能。在函数内部，I使用tf.matmul(x,weight)计算x和权重的矩阵乘积，然后使用tf.add(bias)将乘积加到偏差上。tf.sigmoid(I)使用 Sigmoid 激活函数计算输出。

def perceptron(x):
   I=tf.add(tf.matmul(x,weight),bias)
   output=tf.sigmoid(I)
   return output

1
2
3
4
5

第五步。定义损失函数和优化器

个体损失函数被计算为标签y的 Sigmoid 交叉熵的缩减平均值，其中对数是perceptron(x)函数的输出。

Sigmoid 交叉熵用于量化两个概率分布之间的差异，在这种情况下，0和1。使用tf.optimizers.Adam(.01)初始化optimizer并使用 Adam 优化器:

individual_loss=lambda: abs(tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=y,logits=perceptron(x))))

optimizer=tf.keras.optimizers.Adam(.01)

1
2
3
4

第六步。读入数据

使用pd.read_csv('data.csv')读入数据。然后使用dataframe.head()查看数据帧的前几行，检查数据是否被正确读取。

dataframe = pd.read_csv('data.csv')
dataframe.head()

1
2
3

第七步。标签的可视化

为了熟悉这些数据，您可以使用plt.scatter()对标记的数据进行快速可视化。

plt.scatter(dataframe.x1,dataframe.x2,c=dataframe.label)

1
2

输出如图 2-7 所示。

TensorFlow2 深度学习项目（一）

图 2-7

标签散点图

第八步。准备输入

使用.as_matrix()将输入数据x_input格式化为矩阵，使用.as_matrix()将标签y_label格式化为矩阵。这将从数据集中分离出输入和标注。

x_input=dataframe[['x1','x2']].as_matrix()
y_label=dataframe[['label']].as_matrix()

#View the input matrix
x_input

1
2
3
4
5
6

第九步。初始化变量

使用tf.Variable()将x初始化为变量。和 dataframe 对象x_input。

#Initialize the variable x
x=tf.Variable(x_input)

1
2
3

使用x=tf.cast()将x的datatype更改为float32。

#Change the datatype of x to 'float32'
x=tf.cast(x,tf.float32)

1
2
3

使用tf.Variable()和 dataframe 对象y_label将y初始化为变量。

#Create the variable y
y=tf.Variable(y_label)

1
2
3

使用tf.cast()将y的datatype更改为float32。

#Change the datatype of y to 'float32'
y=tf.cast(y,tf.float32)

1
2
3

第十步。训练模型

使用for循环训练模型。使用in range(1000):将迭代次数设置为1000。使用optimizer.minimize(individual_loss,[weight,bias])将损耗降至最低。

for i in range(1000):
   optimizer.minimize(individual_loss,[weight,bias])

1
2
3

第十一步。权重和偏差的新值

通过使用tf.print(weight,bias)打印它们的值，查看新的重量和偏差。

tf.print(weight,bias)

1
2

以下是输出:

 [[-2..42329407]
 [1.85045445]] [1.74988687]]

1
2
3

第十二步。查看最终损失

通过使用以下公式计算来查看最终损失:

final_loss=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=y,logits=perceptron(x)))

1
2

现在使用tf.print(final_loss)打印最终损失的值。

final_loss=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=y,logits=perceptron(x)))

tf.print(final_loss)

1
2
3
4

以下是输出:

0.534005582

1
2

第十三步。使用训练好的模型进行预测

使用ypred=perceptron(x)和ypred=tf.round(ypred)四舍五入输出值，使其成为1或0。

ypred=perceptron(x)
ypred=tf.round(ypred) #Round off the output value to 1 or 0, to make the comparison with the target easier.

1
2
3

第十四步。评估模型

使用accuracy_score(y, ypred)计算准确度分数。这表明在将预测输出与目标进行比较后，模型的准确性。

accuracy_score(y, ypred)

1
2

以下是输出:

使用confusion_matrix(y, ypred)生成混淆矩阵。如果所有的观察值都落在矩阵的对角线内，其余的值都是0，那么这个模型就是 100%准确的。

confusion_matrix(y, ypred)

1
2

Note

在 TensorFlow 中初始化变量时，始终使用大写V。

现在你知道感知器是如何工作的了。在下一章，你将学习一组感知器如何以人工神经网络的形式一起工作。

摘要

以下是您在本章中学到的内容:

人工神经元是模仿生物神经元的数学函数。
感知器是神经网络的基本单元，某些计算使用它来检测输入数据中的功能或商业智能。它映射其输入x，该输入乘以学习的权重系数，并生成输出值f(x)。
感知器学习规则规定，算法将自动学习最佳权重系数。
多层感知器，或具有两层或更多层的前馈神经网络，具有更强的处理能力，也可以处理非线性模式。
感知器接受特征作为输入。
每个感知器都有权重和偏差。
当输入在输入层被馈送并被连续处理直到它们到达输出层时，发生正向传播。
当计算最后一层的梯度时，发生反向传播，并且每个部分计算被馈送到前一层，直到到达神经网络的第一层。
常用的激活函数有 Sigmoid、ReLU 和 Softmax。
加权求和是每个权重相乘后得到的值的总和。
Sigmoid 函数是具有 Sigmoid 曲线的数学函数。
整流器，或 ReLU(整流线性单元)，允许我们消除人工神经网络中的负值。
Softmax 或标准化指数函数是逻辑函数的推广。
在本章的项目中，您学习了如何对二元分类问题进行预测，如何优化一组权重，如何计算准确度得分，以及如何查看混淆矩阵。

三、神经网络

这里有一些值得思考的问题:如果单个神经元足够强大，可以执行二进制分类，就像你在上一章看到的那样，那么神经元的集合会强大多少？这就是我们在本章将要发现的。几个神经元一起构成了一个神经网络。在本教程中，我们将创建一个多层神经元，然后用它对 MNIST 数据集进行分类。在 Keras 中，一次迭代被称为一个时期。让我们更详细地研究神经网络。

什么是神经网络？

神经网络也称为人工神经网络(ANN)。它包含被称为神经元的互连节点层。神经网络利用一系列算法来检测数据集中的潜在关系。神经网络适应内部和外部参数。网络生成最佳可能输出，而不必修改输出标准。神经网络基于自适应学习。他们使用几个原则，包括基于梯度的训练、模糊逻辑和贝叶斯方法。人工神经网络用于序列和模式识别系统、数据处理、机器人以及许多其他系统。

神经网络组件

神经网络由以下主要组件组成:

**输入层:**输入到神经网络的输入。
**隐藏层:**包含任意数量的神经元，取决于我们想要达到的目标。
**输出层:**得到的最终输出。

神经网络的优势

神经网络具有以下优势:

当神经网络的一个元素失效时，它将继续发挥作用。这是由于它的并行性。
神经网络不需要为看不见的数据重新编程，因为它是一个自适应的智能系统。
神经网络擅长解决复杂的问题。
神经网络比传统网络具有更强的容错能力。在不丢失存储数据的情况下，网络可以在其任何组件中再生故障。

神经网络的缺点

神经网络有以下挫折:

大型神经网络需要大量的处理时间。
神经网络的架构不同于微处理器的架构和历史，所以它们必须被仿真。
增加中子的数量会增加网络的复杂性。
成功训练网络需要最佳的数据量。
确定层数以及每层神经元的数量需要一些反复试验。这很费时间。

我们在理论上知道什么是神经网络，但是在实践中呢？让我们来看看神经网络是如何工作的。

神经网络如何工作

正如你在前一章看到的，神经元内发生的过程是:

正向传播

输入➤计算净输入➤激活函数应用➤输出
反向传播

输出➤激活函数应用于净输入➤输入的➤计算

现在让我们将这个过程扩展到神经网络中的大量神经元。

让我们以一个有十个神经元的浅层神经网络为例。在这种类型的网络中，只有一个隐藏层(见图 3-1 )。

TensorFlow2 深度学习项目（一）

图 3-1

使用 MNIST 的浅层神经网络示例

正向传播

输入被馈送到隐藏层中的每个神经元。这意味着在隐藏层中，每个神经元都有自己的一套权重和一个偏好。整个过程是正向的，因此称为正向传播。以下是这三层的细分:

**输入层:**根据图 3-1 ，有四个输入。这里，x1、xn-1 和 xn 是变量。我们把一个作为常数，这样它就不会影响偏差。
**隐含层:**在图 3-1 中，有四个输入，所以每个神经元有四个权值和单个偏置。激活函数应用于每个神经元的净输入。根据图表，我们从隐藏层得到十个输出。每个神经元都有一个。在这种情况下，我们使用 Softmax 激活函数。
**输出层:**我们得到十个类别，每个类别对应一个数字，y1，y2…… y10。

Note

根据预期输出的数量，隐藏层可以具有 Sigmoid 函数或 Softmax 函数。如果需要两个输出，则使用 Sigmoid。如果预期有两个以上的输出，则使用 Softmax。

对于具有多个隐藏层的神经网络，在层之间使用的最流行的激活函数是 ReLU 函数。

一旦输入被馈入并被正向处理，就该检查并调整它们，以便通过反向传播获得更好的结果。

反向传播

我们在前一章看到，反向传播发生在神经网络的每一层。每层中每个神经元的权重和偏置被调整，直到实现收敛。该过程从输出层移动到隐藏层，最后移动到输入层。

有了这些关于神经网络的知识，让我们看看最常见的神经网络类型。

神经网络的类型

在前面的例子中，我们学习了什么是浅层神经网络。现在，让我们快速看一下神经网络是如何大致分类的。

每个神经网络都有几种变体和组合。所以，实际上有几种神经网络可用。对于本书中的项目，我们主要关注人工神经网络的大类。

前馈神经网络

在前馈神经网络中，数据仅在一个方向上从第一层向前移动，直到到达输出节点(见图 3-2 )。这也称为波前传播波，通常通过使用分类激活函数来实现。没有反向传播，它可以有一个单一的层或多个隐藏层。

前馈神经网络的用途包括:

TensorFlow2 深度学习项目（一）

图 3-2

样本前馈神经网络(HC 表示隐藏单元)

人脸识别
计算机视觉

卷积神经网络

卷积神经网络(CNN)是多层神经元的正则化版本，包含一个或多个卷积层(见图 3-3 )。这些层可以完全互连，也可以汇集在一起。卷积层对输入使用卷积运算。

CNN 的用途包括:

TensorFlow2 深度学习项目（一）

图 3-3

样本卷积神经网络(K 表示核，C/P 表示卷积或池，HC 表示隐藏单元)

图像和视频识别
自然语言处理
推荐系统

循环神经网络(RNN)

循环神经网络(RNN)保存特定层的输出，并将其作为输入进行反馈。循环神经网络过程在第一层之后的层中开始。每个节点在计算和执行操作时充当一个存储单元，因此在反向传播期间，它可以将以前的值与新值进行比较(见图 3-4 )。rnn 将在第九章中详细讨论。

RNN 的用途包括文本到语音转换技术。

TensorFlow2 深度学习项目（一）

图 3-4

样本循环神经网络(RC 表示递归细胞)

径向基函数神经网络

RBNN 考虑任意点相对于中心的距离。它应用径向基函数作为其激活函数(见图 3-5 )。有两层。在内层，特征与径向基函数相结合。那么当在下一时间步中计算相同的输出时，考虑这些特征的输出。这样，它实现了线性可分性。

RBNN 的用途包括电力恢复系统。

TensorFlow2 深度学习项目（一）

图 3-5

样本径向基函数神经网络(HC 表示隐藏单元)

现在你知道了神经网络的基本类别。当我们在本书的项目中工作时，我们将使用神经网络，它们属于这里讨论的子类。

项目描述

在这个项目中，我们使用单层神经网络对一组手写数字进行分类。我们首先将二维矩阵中的数据展平为一维数组。然后我们用 Softmax 激活函数把它输入神经网络。输出是一个从 0 到 9 的数字。图 3-6 显示了该过程的流程图。

TensorFlow2 深度学习项目（一）

图 3-6

对 MNIST 数据使用简单神经网络的流程图

扁平化数据

MNIST 的数据完全由手写数字的二维图像组成。这意味着数据是二维矩阵的形式。这对于神经网络来说不容易处理。所以我们通过把它转换成一维数据来“扁平化”。二维矩阵被转换成一维数组。这样，神经网络可以更好地处理数据，并给出更好的结果。参见图 3-7 。

TensorFlow2 深度学习项目（一）

图 3-7

拼合 MNIST 数据

关于数据集

名称: MNIST 数据库

**内容:**手写数字的 MNIST 数据库具有 60，000 个样本的训练集和 10，000 个样本的测试集。它是可从 MNIST 获得的更大集合的子集。数字已经过大小标准化，并在固定大小的图像中居中。

来源: http://yann.lecun.com/exdb/mnist/

必需的库

我们的项目需要以下库:

硬
TensorFlow 2.0

神经网络体系结构

我们将使用一个简单的神经网络架构，由以下部分组成:

**输入层:**数据作为特征输入到输入层。神经元计算网络输入函数。
**输出层:**这一层包含十个神经元，用于数据的每个可能类别。
激活功能: Softmax
**损失函数:**稀疏分类交叉熵
**优化器:**亚当
**度量:**准确度

程序

按照以下步骤创建一个多层神经元:

导入库。使用import命令导入 TensorFlow 2.0 和 Keras。
读入数据。Keras 加载了一组数据集。MNIST 是其中之一。所以可以直接从 Keras 加载。然后将数据分成两组，分别用于测试和训练。

#import libraries.
import keras
import tensorflow as tf

1
2
3
4

mnist=tf.keras.datasets.mnist

#split data
(x_train, y_train), (x_test, y_test) = mnist.load_data()

1
2
3
4
5

我们的输出应该是这样的。

数据处理。MNIST 数据集由二维图像组成。为了方便起见，将它们展平成一维图像。

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

1
2
3

创建神经网络。使用Sequential模块创建一个单独的隐藏层。这个隐藏层有十个神经元。我们将使用的激活函数是 Softmax。接下来，您可以定义优化器。我们将使用 Adam 优化器，因为我们只是对数据进行基本的分类。我们将损失函数定义为稀疏分类交叉熵，因为输出只能是十个可能类别中的一个。为了测试这个模型的能力，使用accuracy指标。

x_train, x_test = x_train / 255.0, x_test / 255.0

1
2

训练模型。使用fit模块，训练新创建的模型。设置模型的迭代。首先，将其设置为三个历元，并检查准确度分数。

digit = tf.keras.models.Sequential([
   tf.keras.layers.Flatten(input_shape=(28, 28)),
   tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])

#compile model
digit.compile(optimizer='adam',
             loss='sparse_categorical_crossentropy',
             metrics=['accuracy'])

1
2
3
4
5
6
7
8
9
10

digit.fit(x_train, y_train, epochs=3)

1
2

我们的输出应该如下所示:

评估模型。使用evaluate模块，测试模型。测试完成后，检查准确度分数。只需三次迭代，您就可以获得 92%的准确率。

Train on 60000 samples
Epoch 1/3
60000/60000 [==============================] - 3s 47us/sample - loss: 0.4670 - acc: 0.8788
Epoch 2/3
60000/60000 [==============================] - 3s 44us/sample - loss: 0.3036 - acc: 0.9151
Epoch 3/3
60000/60000 [==============================] - 3s 45us/sample - loss: 0.2834 - acc: 0.9204
<tensorflow.python.keras.callbacks.History at 0x7f8709047358>

1
2
3
4
5
6
7
8
9

digit.evaluate(x_test, y_test)

1
2

输出应该类似于以下内容:

进一步的实验。尝试更改历元数，看看它如何影响精确度。

10000/10000 [==============================] - 0s 26us/sample - loss: 0.2765 - acc: 0.9229
[0.2764906617820263, 0.9229]

1
2
3

摘要

以下是您在本章中学到的所有内容的回顾:

神经网络也称为人工神经网络(ANN)。
神经网络基于自适应学习。
神经网络使用几种原理，包括基于梯度的训练、模糊逻辑和贝叶斯方法。
神经网络具有并行性。
在不丢失存储数据的情况下，网络能够在其任何组件中再生故障。
大型神经网络需要大量的处理时间。
增加中子的数量会增加网络的复杂性。
成功训练网络需要最佳的数据量。
确定层数以及每层神经元的数量需要一些反复试验。这很费时间。
根据预期输出的数量，隐藏层可以具有 Sigmoid 函数或 Softmax 函数。如果有两个预期输出，则使用 Sigmoid。如果有两个以上的预期输出，则使用 Softmax。
前馈神经网络是一种 ANN，其中节点之间的连接不形成循环。
循环神经网络应用反向传播。
RBNN 是一个单层神经网络，其激活函数是径向基函数。它实现了线性分离。
数据扁平化包括将其从一种格式转换为另一种格式。例如，在这个项目中，我们通过将 MNIST 数据从二维矩阵转换为一维数组来将其扁平化。
通过第一个项目，您学习了如何处理大型数据集，如何将数据集拆分为测试数据集和定型数据集，以及如何为模型准备数据。
您现在应该很清楚如何构造一个简单的神经网络，如何使用训练数据对其进行训练，以及如何使用测试数据对其进行测试。

参考

本章中使用的资源如下:

www.linkedin.com/pulse/artificial-neural-networks-advantages-disadvantages-maad-m-mijwel/优缺点:
神经网络的类型: www.digitalvidya.com/blog/types-of-neural-networks/

四、情感分析

在前一章中，我们学习了不同类型的神经网络。在这一章中，我们学习长短期记忆(LSTM)神经网络。本章中的项目旨在简化，以帮助我们适应 TensorFlow 2.0。我们将首先了解什么是 LSTM 以及我们为什么需要它。然后我们将看看 LSTM 是如何工作的。之后，我们将学习什么是情感分析及其各种类型。我们还将学习如何保存一个训练好的模型并重新加载它，这样我们就可以保存模型并在将来的项目中重用它们。请记住，我们只在这个项目中介绍保存和重新加载一个训练好的模型的过程；但是，您在本书或您自己的书中处理的任何项目都可以保存和重新加载。

LSM 评论

让我们从理论上了解什么是 LSTM 开始。LSTM 能够学习长期依赖关系。它保持一个相对恒定的误差，允许递归网络通过多个步骤继续学习，以远程链接原因和结果。该误差通过时间和层反向传播。图 4-1 显示了一个基本的 LSTM，其中 M 表示存储单元。第一列神经元是输入层，最后一列神经元是输出层。

TensorFlow2 深度学习项目（一）

图 4-1

基本 LSTM 结构

LSTM 包含门控细胞中循环网络正常流动之外的信息。它本质上是一个存储单元，可以存储、写入或读取信息。

该单元通过模拟门决定存储什么以及何时允许读和写特权。这些门通过 Sigmoids 的逐元素乘法来实现，这些乘法都在 0-1 的范围内。模拟具有可微分的优点，这使得它适合于反向传播。

通过进行猜测、反向传播误差和通过梯度下降调整权重的迭代过程，单元学习何时允许数据进入、离开或删除。

这是“消失梯度”问题的完美解决方案。当我们尝试使用基于梯度的优化技术来训练神经网络模型时，会出现消失梯度问题。

在反向传播过程中，梯度随着通过神经网络向后移动而减小。这意味着初始层中的神经元与后面层中的神经元相比学习非常慢。网络中的初始层是训练最慢的。训练过程花费非常长的时间，并且模型的预测精度降低。

LSTM 通过在遗忘之门激活和梯度计算之间建立联系来解决这个问题。这种连接为信息流创建了一条通过遗忘门的路径，从而确保信息不会被遗忘。

LSTM 的应用包括:

手写识别
语音识别
疾病预测
音乐创作

现在您已经知道了什么是 LSTM，以及它在现实生活中的应用，让我们来看看 LSTM 中的过程。

LSTM 是如何工作的

理解 LSTM 的最好方式是把它想象成一个链状结构，有两个非重复模块和一个重复模块。(参见图 4-2 )。在这种结构中，重复模块有三个门。它们是*输入门、输出门、和遗忘门。*细胞状态以最小的线性相互作用连接整个链。

LSTMs 使用一种称为门的结构来调节进出单元的数据流。它们的工作方式类似于条件门(and、or、xor等)。).基于一组条件，他们决定允许哪些信息通过大门。这些条件由 LSTM 决定，不需要明确编程。

**遗忘门:**遗忘门的输出通过将矩阵中的一个位置乘以零来告诉单元状态要遗忘哪些信息。如果遗忘门的输出为1，则信息保持在单元状态。
**输入门:**该门决定哪些信息应该进入单元格状态。这里重要的组件是激活函数。输入门有一个范围为[0,1]的 Sigmoid 函数。单元状态的等式是先前单元状态之间的求和，因此 Sigmoid 函数本身只会增加存储器，而不能移除存储器。如果您只能在[0,1]之间添加一个浮点数，则该数字永远不会为零。这使得它无法忘记。这就是输入调制门具有tanh激活功能的原因。tanh有一个[-1, 1]范围，允许细胞状态遗忘记忆。
**输出门:**该门考虑了所有可能的值，并利用一个 Sigmoid 激活函数来决定哪些信息应该进入下一个隐藏状态。

LSTM 的输入是三维数组的形式。其中第一维表示批量大小，第二维表示我们输入序列的时间步数，第三维表示一个输入序列中的单元数。

TensorFlow2 深度学习项目（一）

图 4-2

对 LSTM 运作的内部观察

S _(t-1) 是细胞状态
f _(gt) 是忘年门
i _(gt) 是输入门
o _(gt) 是输出门

阶段 1:LSTM 决定从小区状态中丢弃什么信息。这个决定是由使用 Sigmoid 激活函数的遗忘门层做出的。这意味着将分配一个在0和1之间的值。值1代表“存储”，值0代表“丢弃”

假设权重为W _fg ，偏差为b _fg 。现在根据图表，我们有两个输入— n _(t-1) 和a。两个值都将乘以权重(W _fg )，然后结果乘积将被添加到偏差(b _fg )。最后，Sigmoid 激活函数将应用于结果。

它可以用数学方法推导如下:

f _gt =乙状结肠(W _fg 。[n _(t-1) ，a] + b _fg

阶段 2:根据剩余的信息，LSTM 决定在单元状态中存储什么新信息。这分两步完成:

输入门图层使用 Sigmoid 函数来决定哪些值将被更新。假设权重为W _ig ，偏差为b _ig 。

i _gt =乙状结肠(W _ig 。[n _(t-1) ，a] + b _ig
一个tanh层创建了一个新值的矢量。假设权重为W _c ，偏差为b _c 。

S _?? = tanh( W _c 。[n _(t-1) ，a] + b _c

阶段 3:我们现在结合这两个步骤的结果来创建单元状态的更新。旧的单元格状态S _(t-1) 乘以f _gt 。然后我们把结果加到(i_gt* S_??)的乘积上。

S_??=(f_gt* S_t-1)+(I_gt* S_??

阶段 4:最后，LSTM 决定输出。这分两步完成:

输出层使用 Sigmoid 层来决定单元状态的哪些部分将作为输出。假设权重为W _c ，偏差为b _c :

o _gt = Sigmoid( W _og 。[n _(t-1) 、a] + b _og
结果通过一个tanh激活函数，得到-1和1之间的值。然后将结果乘以 Sigmoid 门的输出。

n_t= o_gtS_t

LSTM 中的图层

为了设计有效的 LSTM，仅仅知道 LSTM 是如何工作的是不够的。我们还需要了解哪些图层可用于设计 LSTM。它可以有以下类型的层:

**嵌入层:**用于为进来的词创建词向量。它位于输入层和 LSTM 层之间。嵌入层的输出是 LSTM 层的输入。
**LSTM 层:**循环神经网络层，将序列作为输入，可以返回序列或矩阵。
**剔除层:**一种正则化技术，包括在训练期间的每次更新时将输入单元的一部分设置为0，以防止过拟合。
**密集层:**全连接层，其中每个输入节点连接到每个输出节点。
**激活层:**决定 LSTM 使用哪个激活函数来计算节点的输出。

既然您已经了解了 LSTM 的工作原理，您就可以在项目中将其付诸实践了。

项目描述

在这个项目中，我们将使用亚马逊评论上的 LSTM 来识别句子中的情感，并确定它们的极性。本质上，我们会发现一个评论是积极的还是消极的。深度学习模型需要数字数据作为输入。由于我们正在进行文本分类，我们需要将文本数据转换成数字向量。为此，我们将使用一种叫做单词嵌入的方法。这种方法将每个单词编码成一个 n 维稠密向量，其中相似的单词会有相似的编码。为此，我们将使用 Keras 嵌入层。

我们首先只取总评论的 20%,并创建我们将使用的主要数据框架。这是为了避免我们的系统过载，并可能导致系统崩溃。然后，我们通过删除标点符号和数字、将所有大写字母转换为小写字母以及删除单个字符来清理数据。为了准备模型的数据，我们将其分为 70%用于训练集，30%用于测试集。在此之后，我们将新清理的数据转换为数组，并使用标记器来帮助模型理解每个单词。为了避免数组大小的不兼容问题，我们使用填充。我们继续创建模型并训练它。最后，我们通过检查模型的准确性来评估模型的性能。该过程如图 4-3 所示。

TensorFlow2 深度学习项目（一）

图 4-3

LSTM 情绪分析项目工作流程

关于数据集

名称: Amazon_Review_Polarity

内容: 656MB (688，340，758 字节)亚马逊上负面、正面和中性评论的压缩档案

来源 : https://drive.google.com/open?id=0Bz8a_Dbh9QhbaW12WVVZS2drcnM

创作人 : 张翔

Note

建议您为所有项目创建一个粗略的流程图，甚至是您自己正在做的项目，以帮助您更好地组织项目。

理解情感分析

情感分析(见图 4-4 )是文本的上下文挖掘，识别和提取源材料中的主观信息。然而，社交媒体流的分析通常仅限于基本的情感分析和基于计数的指标。

TensorFlow2 深度学习项目（一）

图 4-4

情感分析是在各种在线资源上进行的

情感分析是分析文本数据并将观点分类为消极、积极或中立的自动化过程。情感分析是最常用的文本分类工具；其应用包括:

社交媒体监控
品牌监控
客户之声(VoC)
客户服务
市场调查
自动分析调查回复、产品评论和社交媒体评论

我们可以提取表达式的其他属性，例如:

极性:当说话者表达肯定或否定的意见时
话题:正在谈论的事情
**意见持有人:**表达意见的个人或实体

情感分析可以应用于不同层次的范围:

文档级情感分析获取完整文档或段落的情感。
句子级情感分析获取单个句子的情感。
子句子级情感分析获取句子内子表达的情感。

在我们开始我们的项目之前，我们需要理解一些概念，比如不同类型的情感分析以及它们在现实生活中的应用。然后，我们需要理解一次性编码，因为我们将把它应用到我们的数据集。一旦我们设计了我们的模型，我们还需要测试它以确保它表现良好。

情感分析的类型

有许多类型的情绪分析和 SA 工具，从关注极性(积极、消极、中性)的系统到检测感觉和情绪(愤怒、快乐、悲伤等)的系统。)或者识别意图。

细粒度情感分析

通过将情绪的基本类别(积极、中立或消极意见)扩展到以下类别，我们可以更精确地了解意见的极性水平:

非常积极
积极的
中立的
否定
非常消极

这通常被称为细粒度情感分析。

情感检测

情绪检测旨在检测快乐、沮丧、愤怒、悲伤等情绪。许多情绪检测系统求助于词典(即单词列表和它们传达的情绪)或复杂的机器学习算法。求助于词汇的一个缺点是，人们表达情感的方式千差万别。一些通常表达愤怒的词也可能表达快乐。

基于方面的情感分析

通常，当分析受试者的情绪时，我们可能不仅对人们谈论产品时是正面、中性还是负面感兴趣，还会对人们谈论产品的哪些特定方面或特征感兴趣。

意图分析

意图分析主要检测人们想对文本做什么，而不是人们对文本说什么(见图 4-5 )。有时，可以从文本中推断出意图动作，但其他时候，推断意图需要上下文知识。

TensorFlow2 深度学习项目（一）

图 4-5

一个对 tweet 进行意图分析的简单例子

多语言情感分析

多语言情感分析是一项艰巨的任务。它涉及大量的数据预处理。这些资源中的大部分可以在线获得(例如，情感词典)，但是许多其他资源必须被创建(例如，翻译的语料库或噪声检测算法)。可用资源的使用需要大量的编码经验，并且可能需要很长时间来实现。

另一种方法是自动检测语言，然后为我们选择的语言训练一个定制模型(如果文本不是用英语写的)，最后执行分析。

情感分析算法

有许多方法和算法来实现情感分析系统，并且它们可以被分类如下:

基于规则的系统根据一组手工制作的规则执行情感分析。通常，基于规则的方法定义了一组识别主观性、极性或观点主题的规则。这些规则可以使用各种输入，例如:
- 传统的自然语言处理技术，如词干提取、标记化、词性标注和语法分析。
- 其他资源，如词典(即单词和短语列表)。这个系统非常幼稚，因为它没有考虑单词在序列中是如何组合的。
自动系统依靠机器学习技术从数据中学习。
混合系统结合了基于规则和自动化的方法。

用于评估的情感分析指标

一旦我们设计了我们的模型，我们需要测试它，看看它对情感分析的效果如何。我们可以通过使用下面几节中描述的某些指标来做到这一点。

交叉验证

这包括将训练数据分成一定数量的训练折叠(75%的训练数据)和相同数量的测试折叠(25%的训练数据)。然后，我们使用训练折叠来训练分类器，并对照测试折叠对其进行测试，以获得性能指标。该过程重复多次，并计算每个指标的平均值。

如果我们的测试集总是相同的，我们可能会过度适应该测试集，这意味着我们可能会根据给定的数据集调整我们的分析，以至于我们无法正确地分析不同的数据集。

精确

这度量了在*被预测(正确和不正确)*属于给定类别的所有文本中，该文本被预测为属于该类别的程度。

回忆

这测量文本如何在所有文本中被正确地预测为属于给定类别，其中应该被预测为属于该类别的。我们输入分类器的数据越多，召回率就越高。

准确

这度量了从语料库中的文本中正确预测了多少文本(包括属于某个类别和不属于该类别)。

最常见的是，精确度和召回率被用来衡量性能，因为精确度本身并不能说明一个分类器的好坏。

混合方法

当我们将各种情感分析方法和技术结合在一起时，我们得到了混合的情感分析方法和技术。

影响模型性能的参数

影响我们模型性能的因素是参数，下面讨论最常见的参数。

主观性和语气

主客观文本的检测与分析其语气同样重要。事实上，所谓的客观文本并不包含明确的情感。所有的谓词(形容词、动词和一些名词)在创造情感的方式上不应该被同等对待。

背景和极性

所有的话语都是在语境中产生的。脱离上下文分析情感变得相当困难。然而，如果没有明确提到上下文，机器就无法学习上下文。如果我们要考虑文本产生的至少一部分上下文，就需要大量的预处理或后处理。

讽刺和挖苦

字面意思和预期意思(即反语)之间的差异以及更具侮辱性或荒谬性的反语(即讽刺)通常会将积极情绪转变为消极情绪，而消极或中性情绪可能会转变为积极情绪。然而，发现讽刺和挖苦需要对文本产生的背景进行大量的分析，因此，很难自动完成。

比较

情感分析仍然不够先进，不足以理解比较。这类陈述容易出错。

定义中性情绪

定义我们的类别——在这种情况下，是中立的标签——是这个问题最重要的部分之一。由于标记数据要求标记标准一致，因此必须对问题进行良好的定义。

中性标签可能包含:

客观文本
无关信息
包含愿望的文本

Tokenizer

记号赋予器用于对文本语料库(我们正在处理的文本数据)进行矢量化，方法是将文本转换为整数序列(每个整数都是字典中记号的索引)或向量，其中每个记号的系数可以是二进制的或基于字数的。

Note

0是一个保留索引，不会分配给任何单词。

通过将verbose设置为0、1或2，您可以决定如何显示每个时期的训练进度。

verbose=0什么都不会给你看(沉默)。
verbose=1会显示一个动画进度条，如下所示:

TensorFlow2 深度学习项目（一）

verbose=2会提到这样的历元数:

TensorFlow2 深度学习项目（一）

H5 文件

为了保存我们的模型，我们需要将重量存储在 H5 文件中。它是以分层数据格式(HDF)保存的数据文件。它包含科学数据的多维数组。

JSON 文件

当保存我们的模型时，JSON 文件存储了关于层的信息和每个层使用的数量，以便可以很容易地重新加载。JSON 文件以 JavaScript Object Notation (JSON)格式存储简单的数据结构和对象，这是一种标准的数据交换格式。它主要用于在 web 应用程序和服务器之间传输数据。JSON 文件是轻量级的、基于文本的、可读的，并且可以使用文本编辑器进行编辑。

你现在应该对这个项目有一个清晰的了解，并且已经学习了一些新的术语。我们可以开始了。

必需的库

对于这个项目，您将使用在本书第一章中安装的基本库。此外，还有一些我们需要的其他库。以下是该项目所需的所有库的列表:

NumPy(安装说明见第一章)
TensorFlow(安装说明见第一章)
熊猫(安装说明见第一章)
Keras(安装说明见第一章)
Scikit-Learn(安装说明见第一章)
re(内置 Python 库)

看起来我们已经拥有了这个项目所需要的所有库。让我们把重点放在我们的项目中想要使用的层的类型和每种类型的层的数量上。

LSM 体系结构

我们将在这个项目中使用的模型是一个简单的 LSTM。我们希望专注于识别基本情绪，包括积极的情绪(高兴、兴奋等)。)和消极(难过、担心等。).我们不会陷入被动攻击或类似的复杂情绪。图 4-6 是该 LSTM 结构的直观表示。

TensorFlow2 深度学习项目（一）

图 4-6

用于情感分析的 LSTM 架构

为了更好地理解我们的模型是如何工作的，让我们来看看 LSTM 的“蓝图”。我们只处理了 20%的数据集，所以我们的模型不需要太复杂。我们的模型将包括以下内容:

嵌入层- 1
LSM 层- 1
密集层- 1

我们将使用 Keras 嵌入层来训练我们自己的自定义单词嵌入模型。该层用随机权重初始化，并被定义为网络的第一个隐藏层。LSTM 层分别学习什么是积极情绪和消极情绪。然后，它存储这些信息，这样它就可以识别数据并将其分类为积极情绪或消极情绪。最后，密集层是一个完全连接的层，确保模型学习良好并提高其准确性。

**激活函数:**我们将使用 Softmax 函数，因为它可以识别情绪并进行分类。
**损失函数:**模型通过损失函数进行学习。这是一种评估特定算法对给定数据的处理效果的方法。如果预测与实际结果偏离太多，损失函数就会很大。如果偏差较小，损失函数将较小。我们将使用*二进制交叉熵，*也称为 Sigmoid 交叉熵损失。它是 Sigmoid 激活和交叉熵损失的组合。它独立于每个矢量分量(类)，这意味着为每个输出矢量分量计算的损耗不受其他分量值的影响。这使得它非常适合多标签分类，在这种分类中，属于某个类的元素不应该影响另一个类的决策。它被称为二元交叉熵损失，因为它为每个类建立了一个二元分类问题。
优化器:Adam 优化器是大多数项目的理想选择。本章中的项目相当简单，所以 Adam 优化器很好。
**度量:**为了检查我们的模型是如何工作的，我们现在只测量准确性。

我们已经规划好了我们的架构。剩下的就是实现模型了。

程序

让我们回顾一下我们将在这个项目中使用的代码。

第一步。导入库

首先为这个项目导入必要的库。

import tensorflow as tf
import numpy as np
import pandas as pd
import re
import keras
from keras import Model
from tensorflow.keras.layers import Flatten,LSTM, Dense, Flatten, Embedding
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import Sequential
from keras_preprocessing.text import Tokenizer
from keras.initializers import glorot_uniform
from sklearn import model_selection

1
2
3
4
5
6
7
8
9
10
11
12
13
14

第二步。加载数据

加载数据，数据为.csv格式。然后使用file.readlines()阅读评论中的每一行。

#Read in data
with open('train.csv', 'r') as file:
   text = file.readlines()

1
2
3
4

现在您使用 Pandas 创建一个名为x_train的空数据帧。这将用于仅存储分析所需的数据。

#create empty dataframe
x_train = pd.DataFrame()

1
2
3

您需要初始化两个列表。列表将评论中的所有单词存储为字符串。使用一个for循环，你可以指出单词被一个空格分开。然后，循环检测评论中的单词，并将它们存储为字符串。最后，这些列表被转换成序列，准备存储在数据帧中。第一个系列命名为consumer_review，第二个系列命名为polarity_label。此时，数据已经加载到系统中。现在是为模型准备数据的时候了。

# fill in dataframe
word=[]
label=[]
for n in text:
   n=n.split()
   label.append(1) if n[0] =="__label__2" else label.append(0)
   word.append(" ".join(n[1:]))
x_train['consumer_review'] = word
x_train['polarity_label'] = label
#view dataframe
x_train

1
2
3
4
5
6
7
8
9
10
11
12

第三步。准备数据

正如项目描述中提到的，我们现在只使用总数据的 20%。因此，您使用sklearn中的model_selection.train_test_split函数来表明，在整个数据集中，您只希望使用其中的 20%。

#use only 20% of data to avoid overloading your system. You can reduce or increase this number according to your convenience.
_, x_set,_, y_set = 
   model_selection.train_test_split(x_train['consumer_review'],
                                    x_train['polarity_label'], test_size=0.02)

1
2
3
4
5

第四步。清理数据

计算机不能像人类那样阅读文本。因此，您需要重新格式化数据集中的评论，使它们更易于系统理解。这意味着您需要删除大写、标点和冠词(a、an 和 the)。为此，您将定义一个自定义函数。

#data cleaning function
def data_prep(in_tex):
   # Remove punctuations and numbers
   out_tex = re.sub('[^a-zA-Z]', ' ', in_tex)
   # Convert upper case to lower case
   out_tex="".join(list(map(lambda x:x.lower(),out_tex)))
   # Remove single character
   out_tex= re.sub(r"s+[a-zA-Z]s+", ' ', out_tex)
   return out_tex

1
2
3
4
5
6
7
8
9
10

将这个新清理的数据集存储在名为text_set的新列表中:

#create new list with clean data
text_set=[]
for reviews in list(x_set):
   text_set.append(data_prep(reviews))

1
2
3
4
5

现在，您创建一个新的数据帧来存储干净的数据。如果您使用与以前相同的数据帧，原始数据将被干净的数据覆盖。

x_train= pd.DataFrame()
x_train['consumer_review'] = text_set
x_train['polarity_label'] = list(y_set)

1
2
3
4

这些数据是干净的，但是仍然需要更多的预处理。首先将其分为 70%用于训练数据集，30%用于测试数据集。您像以前一样使用来自sklearn的相同的split函数。

#split data into 70% train and 30% test
x_train, x_test, y_train, y_test = 
   model_selection.train_test_split(x_train['consumer_review'],
                                    x_train['polarity_label'], test_size=0.30)

1
2
3
4
5

为了应用标记器，您需要将列表转换成数组。这样更容易处理。

#convert to array
x_train=np.array(x_train.values.tolist())
x_test=np.array(x_test.values.tolist())
y_train=np.array(y_train.values.tolist())
y_test=np.array(y_test.values.tolist())

1
2
3
4
5
6

应用记号赋予器。

#tokenizer
tokenizer = Tokenizer()
tokenizer.fit_on_texts(x_train)
word_index=tokenizer.word_index
total_size = len(word_index)+1

print(total_size)

1
2
3
4
5
6
7
8

输出:

将文本输入转换为序列。这是模型最容易处理的形式。

#text to sequence
x_train = tokenizer.texts_to_sequences(x_train)
x_test = tokenizer.texts_to_sequences(x_test)

1
2
3
4

为了避免由于数组大小造成的不兼容性，您必须向数据添加填充。

#add padding to ensure the same length
max_length = 100
x_train = pad_sequences(x_train, padding="post", maxlen=max_length)
x_test = pad_sequences(x_test, padding="post", maxlen=max_length)

1
2
3
4
5

第五步。构建模型

使用 Keras 嵌入层、LSTM 层和密集层构建模型。

#Create Model
model = Sequential()
model.add(Embedding(total_size, 20, input_length=max_length))
model.add(LSTM(32,dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(1, activation="sigmoid"))

1
2
3
4
5
6

第六步。编译模型

接下来，您指定要使用的优化器是 Adam，损失函数是二进制交叉熵，您想要关注的度量是准确性。

#compile
model.compile(optimizer='adam', loss="binary_crossentropy", metrics=['acc'])
print(model.summary())

1
2
3
4

第七步。训练模型

现在，通过将批处理大小设置为 128，将时期设置为 5，将详细设置为 1 来训练模型。这些设置可以微调，以获得更好的效果。

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

1
2

第八步。保存模型(可选)

如果需要，可以保存模型的当前状态以备将来使用。

model.save("model.h5")

1
2

第九步。导入预训练模型(可选)

此代码用于重新加载您训练的模型，以便您可以在相同或不同的数据集上使用它。

model = keras.models.load_model("model.h5")

1
2

您已经成功完成了情感分析。精确度相当不错，但是如果你想把它投入使用，这个模型肯定需要更多的训练。

进一步测试

你在这个项目里做的情感分析真的很简单。它有很大的实验空间。以下是一些修改和通过这个项目学习更多的想法:

添加更多 LSTM 图层
添加更密集的层
尝试不同的优化功能

解决纷争

以下是一些可能会出现但很容易修复的常见错误:

"Warning: No read.me file"。这表明package.json文件丢失。package.json文件跟踪项目的依赖关系。在安装模块之前，首先使用npm init，因为它会为您创建package.json文件。
"Error: Missing DLL"。此错误消息可能意味着以下情况之一:"Cannot execute binary file"。有两种方法可以解决此错误:
- 您的 Windows 版本没有更新。您必须确保您使用的是最新版本的 Windows。
- 该项目没有对C:Users\AppDataLocalMicrosoftWindows or C:Users\AppDataLocalTemp文件夹的完全访问权限。最好使用admin帐户，它拥有对所有文件的完全访问权限，或者向管理员请求访问权限。
- 通过将-s选项传递给ln命令，后跟目标文件和链接名称，创建一个符号链接。
- 不要用apt-get安装，因为这不是一回事。
"npm WARN package.json chat@4.5.0 No repository field"。

npm WARN package.json chat@4.5.0 No README data
npm ERR! Windows_NT 6.1.7600
node_modules\npm\bin\npm-cli.js" "install"
npm ERR! node v4.5.0
npm ERR! npm v2.15.9
npm ERR! code ENOENT
npm ERR! errno ENOENT
npm ERR! syscall getaddrinfo
npm ERR! enoent getaddrinfo ENOENT registry.npmjs.org:443
npm ERR! enoent This is most likely not a problem with npm itself
npm ERR! enoent and is related to npm not being able to find a file.
npm ERR! enoent
npm ERR! Please include the following file with any support request:
npm ERR! C:xampphtdocschat
pm-debug.log. "

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这些错误表明您已经安装了 NodeJS。如果 Keras Tokenizer 导致问题，请使用以下替代方法:

from keras.preprocessing import text
tokenizer = text.Tokenizer(...)

1
2
3

Note

不导入也不暴露文本子模块。所以有时候可能会导致错误。但是，可以使用本节中讨论的修复方法来处理此错误。

摘要

以下是您在本章中学到的所有内容的快速回顾:

LSTM 能够学习长期依赖关系。LSTM 的应用包括手写识别、语音识别、疾病预测和音乐创作。
模拟具有可微分的优点，这使得它适合于反向传播。
LSTMs 是“消失梯度”问题的完美解决方案，当我们试图使用基于梯度的优化技术来训练神经网络模型时，就会出现这种问题。
LSTM 中的门是遗忘门、输入门和输出门。
LSTM 决定从单元状态中丢弃什么信息。这个决定是由“忘记门层”做出的，它使用了一个 Sigmoid 激活函数。
准确性是衡量我们的机器学习模型在预测给定观察的正确类别方面有多好的一个指标。不要在不平衡的问题上使用准确性。
该模型通过损失函数进行学习。这是一种评估特定算法对给定数据的处理效果的方法。如果预测与实际结果偏离太多，损失函数就很大。如果偏差小，损失函数也小。
情感分析是文本的上下文挖掘，从源材料中识别和提取主观信息。然而，社交媒体流的分析通常局限于基本的情感分析和基于计数的指标。情感分析是分析文本数据并将观点分类为消极、积极或中立的自动化过程。这是最常见的文本分类工具。
通过细粒度的情感分析，我们可以更精确地了解意见的极性水平，方法是将积极、中立和消极意见的基本类别扩展到以下类别:非常积极、积极、中立、消极和非常消极。
有许多方法和算法来实现情感分析系统，并且它们被分类为基于规则的、自动的和混合的。
交叉验证包括将训练数据分成一定数量的训练折叠(75%的训练数据)和相同数量的测试折叠(25%的训练数据)。然后，使用训练折叠来训练分类器，并根据测试折叠对其进行测试，以获得性能指标。该过程重复多次，并计算每个指标的平均值。如果测试集总是相同的，您将冒过度适应该测试集的风险，这意味着您可能会根据给定的数据集调整您的分析，以至于无法分析不同的数据集。
精度衡量*被预测(正确和不正确)*属于给定类别的所有文本中，该文本被正确预测为属于该类别的程度。
召回衡量在所有文本中应该被预测属于给定类别的文本被正确预测为属于该类别的程度。我们输入分类器的数据越多，召回率就越高。

参考

本章中使用的资源如下:

情绪分析: https://monkeylearn.com/sentiment-analysis/
硬标记器： https://keras.io/preprocessing/text/

进一步阅读

你有兴趣了解本章中的一些主题吗？这里有一些很棒的链接可以查看:

关于 LSTM: https://colah.github.io/posts/2015-08-Understanding-LSTMs/
用 Keras 嵌入单词: https://machinelearningmastery.com/use-word-embedding-layers-deep-learning-keras/
极性和基于主题的情感分析的区别: https://blog.bitext.com/polarity-topic-sentiment-analysis
文字的极性和强度: www.aclweb.org/anthology/W18-3306/
情感分析极性: www.kdnuggets.com/2018/08/emotion-sentiment-analysis-practitioners-guide-nlp-5.html
保存和加载预训练模型: www.tensorflow.org/tutorials/keras/save_and_load