2020-12-22 21:59:16

new/begin-app-dev-tf-keras/2.md

@@ -237,15 +237,15 @@ $ jupyter notebook
 | `low` | 在给定的一天内实现的最低价值。 |
 | `close` | 交易日结束时的价值。 |
 | `volume` | 当天交换的比特币总量。 |
-| `market_capitalization` | 市值，由*市值=价格*循环供给*来解释。 |
+| `market_capitalization` | 市值，由`市值 = 价格 * 循环供给`来解释。 |
 
 > 表 2：比特币历史价格数据集中的可用变量（即列）
 
 现在使用打开的 Jupyter Notebook 实例，我们探索其中两个变量的时间序列：`close`和`volume`。 我们将从这些时间序列开始探讨价格波动模式。
 
-导航到 Jupyter Notebook `Activity_3_Exploring_Bitcoin_Dataset.ipynb`的打开的实例。 现在，执行标题 **Introduction** 下的所有单元格。 这将导入所需的库并将数据集导入内存。
+导航到 Jupyter Notebook `Activity_3_Exploring_Bitcoin_Dataset.ipynb`的打开的实例。 现在，执行标题`Introduction`下的所有单元格。 这将导入所需的库并将数据集导入内存。
 
-将数据集导入内存后，移至 **Exploration** 部分。 您将找到一个代码片段，该代码片段为`close`变量生成时间序列图。 您可以为`volume`变量生成相同的图吗？
+将数据集导入内存后，移至`Exploration`部分。 您将找到一个代码片段，该代码片段为`close`变量生成时间序列图。 您可以为`volume`变量生成相同的图吗？
 
 ![Activity 3 – Exploring the Bitcoin Dataset and Preparing Data for Model](img/image02_21.jpg)
 
@@ -263,7 +263,7 @@ $ jupyter notebook
 
 此外，我们注意到，多年来，比特币价格的波动幅度不如近年来。 尽管这些时间段可以被神经网络用来理解某些模式，但是我们将排除较早的观察结果，因为我们有兴趣预测不太遥远的时期的未来价格。 让我们仅过滤 2016 年和 2017 年的数据。
 
-导航至，**为模型**准备数据集部分。 我们将使用`pandas` API 过滤 2016 年和 2017 年的数据。Pandas 提供了直观的 API 来执行此操作：
+导航至，“为模型准备数据集”部分。 我们将使用`pandas` API 过滤 2016 年和 2017 年的数据。Pandas 提供了直观的 API 来执行此操作：
 
 ```py
 bitcoin_recent = bitcoin[bitcoin['date'] >= '2016-01-01']
@@ -271,11 +271,11 @@ bitcoin_recent = bitcoin[bitcoin['date'] >= '2016-01-01']
 
 变量`bitcoin_recent`现在具有我们原始比特币数据集的副本，但已过滤为更新或等于 2016 年 1 月 1 日的观测值。
 
-作为最后一步，我们现在使用*数据归一化*部分中介绍的点相对归一化技术对数据进行归一化。 我们将仅归一化两个变量（`close`和`volume`），因为这是我们正在努力预测的变量。
+作为最后一步，我们现在使用“数据归一化”部分中介绍的点相对归一化技术对数据进行归一化。 我们将仅归一化两个变量（`close`和`volume`），因为这是我们正在努力预测的变量。
 
 在包含本课程的同一目录中，我们放置了一个名为`normalizations.py`的脚本。 该脚本包含本课中描述的三种标准化技术。 我们将该脚本导入到 Jupyter Notebook 中，并将这些功能应用于我们的系列。
 
-导航到**为模型**准备数据集部分。 现在，使用`iso_week`变量使用 pandas 方法`groupby()`将给定一周中的全天观察分组。 现在，我们可以在一周内将归一化函数`normalizations.point_relative_normalization()`直接应用于该系列。 我们使用以下命令将该归一化的输出存储为同一熊猫数据框中的新变量：
+导航到“为模型准备数据集”部分。 现在，使用`iso_week`变量使用 pandas 方法`groupby()`将给定一周中的全天观察分组。 现在，我们可以在一周内将归一化函数`normalizations.point_relative_normalization()`直接应用于该系列。 我们使用以下命令将该归一化的输出存储为同一熊猫数据框中的新变量：
 
 ```py
 bitcoin_recent['close_point_relative_normalization'] =
@@ -303,7 +303,7 @@ lambda x: normalizations.point_relative_normalization(x))
 
 图 14：使用几周来创建培训和测试集
 
-最后，将导航到 **Storing Output** 部分，并将过滤后的变量保存到磁盘，如下所示：
+最后，将导航到`Storing Output`部分，并将过滤后的变量保存到磁盘，如下所示：
 
 ```py
 test_dataset.to_csv('data/test_dataset.csv', index=False)
@@ -387,7 +387,7 @@ X_train, Y_train,
 batch_size=32, epochs=epochs)
 ```
 
-> *代码段 2.1* ：`model.fit()`的用法
+> “代码段 2.1”：`model.fit()`的用法
 
 变量`X_train`和`Y_train`分别是用于训练的集合和用于评估损失函数（即测试网络预测数据的能力）的较小集合。
 
@@ -397,7 +397,7 @@ batch_size=32, epochs=epochs)
 model.predict(x=X_train)
 ```
 
-> *片段 2.2* ：`model.predict()`的用法
+> “代码段 2.2”：`model.predict()`的用法
 
 前面的步骤介绍了使用神经网络的 Keras 范例。 尽管可以用非常不同的方式处理不同的体系结构，但是 Keras 通过使用以下三个组件简化了使用不同体系结构的界面：网络体系结构，适应性和预测性：
 
@@ -413,15 +413,15 @@ Keras 允许在每个步骤中进行更大的控制。 但是，其重点是使
 
 在此活动中，我们将使用 Keras 创建一个 LSTM 模型。
 
-Keras 用作较低级程序的接口； 在这种情况下，使用 TensorFlow。 当我们使用 Keras 设计神经网络时，该神经网络被*编译为*作为 TensorFlow 计算图。
+Keras 用作较低级程序的接口； 在这种情况下，使用 TensorFlow。 当我们使用 Keras 设计神经网络时，该神经网络被*编译为* TensorFlow 计算图。
 
-导航到 Jupyter Notebook `Activity_4_Creating_a_TensorFlow_Model_Using_Keras.ipynb`的打开的实例。 现在，执行标头**构建模型**下的所有单元格。 在该部分中，我们建立第一个参数化两个值的 LSTM 模型：训练观察的输入大小（一天相当于 1 个值）和预测期间的输出大小（在我们的情况下为 7 天）：
+导航到 Jupyter Notebook `Activity_4_Creating_a_TensorFlow_Model_Using_Keras.ipynb`的打开的实例。 现在，执行标题**构建模型**下的所有单元格。 在该部分中，我们建立第一个参数化两个值的 LSTM 模型：训练观察的输入大小（一天相当于 1 个值）和预测期间的输出大小（在我们的情况下为 7 天）：
 
 ![Activity 4 – Creating a TensorFlow Model Using Keras](img/image02_28.jpg)
 
 图 16：来自 Jupyter Notebook 实例的图像，我们在其中构建了 LSTM 模型的第一个版本
 
-使用 Jupyter Notebook `Activity_4_Creating_a_TensorFlow_Model_Using_Keras.ipynb`从*模型组件*部分构建相同的模型，对输入和输出的周期长度进行参数设置，以便进行实验。
+使用 Jupyter Notebook `Activity_4_Creating_a_TensorFlow_Model_Using_Keras.ipynb`从“模型组件”部分构建相同的模型，对输入和输出的周期长度进行参数设置，以便进行实验。
 
 编译模型后，我们将其作为`h5`文件存储在磁盘上。 优良作法是偶尔将模型的版本存储在磁盘上，以便将模型体系结构的版本与预测功能一起保留。
 
@@ -457,7 +457,7 @@ model.save('bitcoin_lstm_v0.h5')
 
 # 从数据准备到建模
 
-本节重点介绍深度学习系统的实现方面。 我们将使用*中的比特币数据，选择正确的模型体系结构*和*中的 Keras 知识，并使用 Keras 作为 TensorFlow 接口*将这两个组件组合在一起。 本节通过构建一个从磁盘读取数据并将其作为单个软件馈入模型的系统来结束本课程。
+本节重点介绍深度学习系统的实现方面。 我们将使用“选择正确的模型体系结构”中的比特币数据和 Keras 知识，并使用 Keras 作为 TensorFlow 接口将这两个组件组合在一起。 本节通过构建一个从磁盘读取数据并将其作为单个软件馈入模型的系统来结束本课程。
 
 ## 训练神经网络
 
@@ -490,11 +490,11 @@ model.save('bitcoin_lstm_v0.h5')
 
 ### 重塑时间序列数据
 
-神经网络通常使用向量和张量，这两个数学对象都可以在多个维度上组织数据。 用 Keras 实现的每个神经网络都将具有根据规范进行组织的向量或张量作为输入。 首先，了解如何将数据重整为给定层所需的格式可能会造成混淆。 为避免混淆，建议从尽可能少的组件开始，然后逐渐添加组件。 Keras 的官方文档（在 **Layers** 部分下）对于了解每种层的要求至关重要。
+神经网络通常使用向量和张量，这两个数学对象都可以在多个维度上组织数据。 用 Keras 实现的每个神经网络都将具有根据规范进行组织的向量或张量作为输入。 首先，了解如何将数据重整为给定层所需的格式可能会造成混淆。 为避免混淆，建议从尽可能少的组件开始，然后逐渐添加组件。 Keras 的官方文档（在“层”部分下）对于了解每种层的要求至关重要。
 
 ### 注意
 
-可在[这个页面](https://keras.io/layers/core/)上获得 Keras 官方文档。 该链接直接将您带到 **Layers** 部分。
+可在[这个页面](https://keras.io/layers/core/)上获得 Keras 官方文档。 该链接直接将您带到“层”部分。
 
 ### 注意
 
@@ -582,7 +582,7 @@ LSTM 是计算上昂贵的模型。 在现代计算机上，我们最多可能
 
 ### 过拟合
 
-当神经网络过度适合于验证集时，意味着它会学习训练集中存在的模式，但无法将其推广到看不见的数据（例如测试集）。 在下一课中，我们将学习如何避免过度拟合，并创建一个系统来评估我们的网络并提高其性能：
+当神经网络过度适合于验证集时，意味着它会学习训练集中存在的模式，但无法将其推广到看不见的数据（例如测试集）。 在下一课中，我们将学习如何避免过拟合，并创建一个系统来评估我们的网络并提高其性能：
 
 ![Overfitting](img/image02_31.jpg)
 

new/begin-app-dev-tf-keras/3.md

@@ -22,7 +22,7 @@
 
 # 模型评估
 
-在机器学习中，定义两个不同的术语是的共同点：**参数**和**超参数**。 参数是影响模型如何根据数据进行预测的属性。 超参数是指模型如何从数据中学习。 可以从数据中学习参数并进行动态修改。 超参数是高级属性，通常不会从数据中学习。 有关更详细的概述，请参阅 Sebastian Raschka 和 Vahid Mirjalili 撰写的书 *Python Machine Learning，*（Packt，2017 年）。
+在机器学习中，定义两个不同的术语是的共同点：**参数**和**超参数**。 参数是影响模型如何根据数据进行预测的属性。 超参数是指模型如何从数据中学习。 可以从数据中学习参数并进行动态修改。 超参数是高级属性，通常不会从数据中学习。 有关更详细的概述，请参阅 Sebastian Raschka 和 Vahid Mirjalili 撰写的书《Python 机器学习》。
 
 ## 问题类别
 
@@ -30,20 +30,20 @@
 
 这两个类别中的问题具有以下特性：
 
-*   **分类**：以类别为特征的问题。 类别可以不同，也可以不同。 它们也可能是关于二进制问题的。 但是，必须将它们明确分配给每个数据元素。 分类问题的一个示例是使用卷积神经网络将标签*汽车*或*而非汽车*分配给图像。 “第 1 课”，“神经网络和深度学习简介”中探讨的 MNIST 示例是分类问题的另一个示例。
+*   **分类**：以类别为特征的问题。 类别可以不同，也可以不同。 它们也可能是关于二进制问题的。 但是，必须将它们明确分配给每个数据元素。 分类问题的一个示例是使用卷积神经网络将标签*汽车*或*非汽车*分配给图像。 “第 1 课”，“神经网络和深度学习简介”中探讨的 MNIST 示例是分类问题的另一个示例。
 *   **回归**：以连续变量（即标量）为特征的问题。 这些问题的测量范围是，其评估考虑的是网络与实际值的接近程度。 一个示例是时间序列分类问题，其中使用循环神经网络预测未来温度值。 比特币价格预测问题是回归问题的另一个示例。
 
 虽然对于这两个问题类别，评估这些模型的总体结构是相同的，但我们采用了不同的技术来评估模型的表现。 在以下部分中，我们将探讨用于分类或回归问题的这些技术。
 
 ### 注意
 
-本课程中的所有代码段均在*活动 6 和 7* 中实现。 随时随地进行，但不要认为它是强制性的，因为在活动期间将对其进行更详细的重复。
+本课程中的所有代码段均在“活动 6 和 7”中实现。 随时随地进行，但不要认为它是强制性的，因为在活动期间将对其进行更详细的重复。
 
 ## 损失函数，准确性和错误率
 
 神经网络利用功能来测量与验证集相比网络的运行情况，也就是说，一部分数据被分离为，用作训练过程的一部分。 这些函数称为**损失函数**。
 
-损失函数评估神经网络预测的*错误*； 然后他们会将这些错误传播回去并调整网络，从而修改单个神经元的激活方式。 损失函数是神经网络的关键组成部分，选择正确的损失函数可能会对网络的性能产生重大影响。
+损失函数评估神经网络预测的*误差*； 然后他们会将这些错误传播回去并调整网络，从而修改单个神经元的激活方式。 损失函数是神经网络的关键组成部分，选择正确的损失函数可能会对网络的性能产生重大影响。
 
 错误如何传播到网络中的每个神经元？
 
@@ -53,7 +53,7 @@
 
 ### 注意
 
-有关反向传播数学的更多信息，请参阅 Ian Goodfellow 等的*深度学习*。 麻省理工学院出版社，2016 年。
+有关反向传播数学的更多信息，请参阅 Ian Goodfellow 等的《深度学习》。
 
 对于回归和分类问题，我们使用不同的损失函数。 对于分类问题，我们使用精度函数（即，预测正确的时间比例）。 对于回归问题，我们使用的错误率（即，预测值与观察值有多接近）。
 
@@ -106,7 +106,7 @@ TensorFlow 团队可使用 TensorFlow Playground 应用程序，以帮助我们
 
 > 图 2：TensorFlow Playground 应用程序的细节。 根据问题类型，将不同的颜色值分配给点。
 
-在单击播放按钮后，我们注意到**训练损耗**区域中的数字随着网络不断训练而不断下降。 在每个问题类别中，数字非常相似，因为损失函数在两个神经网络中都扮演相同的角色。 但是，用于每个类别的实际损失函数是不同的，并且根据问题类型进行选择。
+在单击播放按钮后，我们注意到**训练损失**区域中的数字随着网络不断训练而不断下降。 在每个问题类别中，数字非常相似，因为损失函数在两个神经网络中都扮演相同的角色。 但是，用于每个类别的实际损失函数是不同的，并且根据问题类型进行选择。
 
 ### 使用 TensorBoard
 
@@ -131,7 +131,7 @@ TensorBoard 擅长评估神经网络。 正如“第 1 课”，“神经网络
 
 有关更多信息，请参阅 [Keras 回调文档](https://keras.io/callbacks/)。
 
-实施 TensorBoard 回调后，`loss`函数指标现在可在 TensorBoard 接口中使用。 现在，您可以运行 TensorBoard 进程（使用`tensorboard --logdir=./logs`），并在使用`fit()`训练网络时保持运行状态。 要评估的主要图形通常称为*损耗*。 通过将已知指标传递给`fit()`函数中的`metrics`参数，可以添加更多指标； 这些将可以在 TensorBoard 中用于可视化，但不会用于调整网络权重。 交互式图形将继续实时更新，这使您可以了解每个时期发生的情况。
+实施 TensorBoard 回调后，`loss`函数指标现在可在 TensorBoard 接口中使用。 现在，您可以运行 TensorBoard 进程（使用`tensorboard --logdir=./logs`），并在使用`fit()`训练网络时保持运行状态。 要评估的主要图形通常称为*损失*。 通过将已知指标传递给`fit()`函数中的`metrics`参数，可以添加更多指标； 这些将可以在 TensorBoard 中用于可视化，但不会用于调整网络权重。 交互式图形将继续实时更新，这使您可以了解每个时期发生的情况。
 
 ![Using TensorBoard](img/image03_05.jpg)
 
@@ -143,7 +143,7 @@ TensorBoard 擅长评估神经网络。 正如“第 1 课”，“神经网络
 
 ### 注意
 
-没有确定如何划分训练，验证和测试数据集的明确规则。 通常的方法是将原始数据集分为 80% 的训练和 20% 的测试，然后再将训练数据集分为 80% 的训练和 20% 的验证。 有关此问题的更多信息，请参阅 Sebastian Raschka 和 Vahid Mirjalili 撰写的书 *Python Machine Learning，*（Packt，2017 年）。
+没有确定如何划分训练，验证和测试数据集的明确规则。 通常的方法是将原始数据集分为 80% 的训练和 20% 的测试，然后再将训练数据集分为 80% 的训练和 20% 的验证。 有关此问题的更多信息，请参阅 Sebastian Raschka 和 Vahid Mirjalili 撰写的书《Python 机器学习》。
 
 在分类问题中，您会将数据和标签都作为相关但又不同的数据传递给神经网络。 然后，网络将了解数据与每个标签的关系。 在回归问题中，不是传递数据和标签，而是传递感兴趣的变量作为一个参数，传递用于学习模式的变量作为另一个参数。 Keras 通过`fit()`方法为这两种用例提供​​了接口。 有关示例，请参见“代码段 2”：
 
@@ -212,9 +212,9 @@ Keras 提供了`model.evaluate(),`方法，该方法使针对测试集评估训
 
 ### 过拟合
 
-我们的首先训练网络（`bitcoin_lstm_v0`）可能正遭受一种称为*过度拟合*的现象。 过度拟合是指训练模型来优化验证集的方法，但是这样做会以我们有意预测的现象为基础，更笼统的模式为代价。 过度拟合的主要问题是模型学习了如何预测验证集，但无法预测新数据。
+我们的首先训练网络（`bitcoin_lstm_v0`）可能正遭受一种称为*过拟合*的现象。 过拟合是指训练模型来优化验证集的方法，但是这样做会以我们有意预测的现象为基础，更笼统的模式为代价。 过拟合的主要问题是模型学习了如何预测验证集，但无法预测新数据。
 
-在训练过程结束时，模型中使用的损失函数达到非常低的水平（约 2.9 * 10-6）。 不仅如此，而且这种情况发生得很早：用于预测我们数据最后一周的 MSE 损失函数在大约第 30 个时期下降到一个稳定的平台。这意味着我们的模型几乎可以完美地预测第 77 周的数据， 76 周。 这可能是过度拟合的结果吗？
+在训练过程结束时，模型中使用的损失函数达到非常低的水平（约 2.9 * 10-6）。 不仅如此，而且这种情况发生得很早：用于预测我们数据最后一周的 MSE 损失函数在大约第 30 个时期下降到一个稳定的平台。这意味着我们的模型几乎可以完美地预测第 77 周的数据， 76 周。 这可能是过拟合的结果吗？
 
 让我们再次看图 4。 我们知道，我们的 LSTM 模型在验证集中达到极低的值（约 2.9 * 10-6），但在测试集中也达到极低的值。 但是，关键的区别在于规模。 我们的测试集中每周的 MSE 大约是测试集中平均水平的 4,000 倍。 这意味着该模型在我们的测试数据中比在验证集中的性能要差得多。 这值得考虑。
 
@@ -245,7 +245,7 @@ Keras 提供了`model.evaluate(),`方法，该方法使针对测试集评估训
 
 > 图 5：测试集中每周的 MSE。 请注意，第 5 周的模型预测比其他任何一周都差。
 
-我们模型的结果（如图“图 5”所示）表明它的性能还不错。 通过观察*预测的*行的模式，您可以注意到该网络已识别出每周发生的波动模式，其中正常价格在一周中上调，然后在下周下跌。 结束。 除了为数不多的几周（最值得注意的是第 5 周，与我们之前的 MSE 分析相同）之外，大多数周都接近正确的值。
+我们模型的结果（如图“图 5”所示）表明它的性能还不错。 通过观察*预测*行的模式，您可以注意到该网络已识别出每周发生的波动模式，其中正常价格在一周中上调，然后在下周下跌。 结束。 除了为数不多的几周（最值得注意的是第 5 周，与我们之前的 MSE 分析相同）之外，大多数周都接近正确的值。
 
 现在让我们对预测进行反规范化，以便我们可以使用与原始数据相同的标度（即美元）调查预测值。 为此，我们可以实现一个反规范化功能，该功能使用来自预测数据的日索引来确定测试数据上的等效星期。 在确定了该周之后，该函数将采用该周的第一个值，并使用相同的点相对归一化技术，使用该值对预测值进行归一化，但取反：
 
@@ -347,7 +347,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
     现在让我们评估我们的模型如何针对测试数据执行。 我们使用 76 周的时间对模型进行了训练，以预测未来的一周-即接下来的 7 天。 建立第一个模型时，我们将原始数据集分为训练集和测试集。 现在，我们将两个数据集的合并版本（我们称为合并集）并移动 76 周的滑动窗口。 在每个窗口中，我们执行 Keras 的`model.evaluate()`方法来评估网络在特定星期的表现。
 
-8.  执行标题**下的单元格，评估 LSTM 模型**。 这些单元格的关键概念是在测试集中每个星期调用`model.evaluate()`方法。 这条线是最重要的：
+8.  执行标题**评估 LSTM 模型**下的单元格。 这些单元格的关键概念是在测试集中每个星期调用`model.evaluate()`方法。 这条线是最重要的：
 
     ```py
     $ result = model.evaluate(x=X_test, y=Y_test, verbose=0)
@@ -379,7 +379,7 @@ return np.mean(np.abs((A - B) / A)) * 100
     我们还将进行相同的比较，但使用非标准化值。 为了使我们的数据不规范，我们必须首先确定测试集和预测之间的等效周。 然后，我们获取该周的第一个价格值，并使用它来逆转“第 2 课，模型体系结构”中的点相对标准化方程。
 
 11.  导航到标题“非规范化预测”，然后执行该标题下的所有单元格。
-12.  在本节中，我们定义了函数`denormalize()`，该函数执行完整的反规范化过程。 与其他函数不同，此函数采用 Pandas 数据帧而不是 NumPy 数组。 我们这样做是为了将日期用作索引。 这是与该标头最相关的单元格块：
+12.  在本节中，我们定义了函数`denormalize()`，该函数执行完整的反规范化过程。 与其他函数不同，此函数采用 Pandas 数据帧而不是 NumPy 数组。 我们这样做是为了将日期用作索引。 这是与该标题最相关的单元格块：
 
     ```py
       predicted_close = predicted.groupby('iso_week').apply(
@@ -467,13 +467,13 @@ return np.mean(np.abs((A - B) / A)) * 100
 
 添加层和神经元可能具有明显的性能限制。 随意尝试添加层和节点。 通常从一个较小的网络（即具有少量层和神经元的网络）开始，然后根据其性能提升而增长。
 
-如果以上说法不准确，您的直觉是正确的。 引用 YouTube 视频分类的前负责人 AurélienGéron 的话*，找到完美数量的神经元仍然有些荒唐可笑*。
+如果以上说法不准确，您的直觉是正确的。 引用 YouTube 视频分类的前负责人 AurélienGéron 的话，*找到完美数量的神经元仍然有些荒唐可笑*。
 
 ### 注意
 
 《Scikit-Learn 和 TensorFlow 机器学习使用指南》，由 AureliénGéron 撰写，由 O'Reilly 于 2017 年 3 月发布。
 
-最后，请注意：您添加的层越多，您需要调整的超参数就越多，网络训练所需的时间也就越长。 如果您的模型运行良好且没有过度拟合数据，请在将新层添加到网络之前尝试本课中概述的其他策略。
+最后，请注意：您添加的层越多，您需要调整的超参数就越多，网络训练所需的时间也就越长。 如果您的模型运行良好且没有过拟合数据，请在将新层添加到网络之前尝试本课中概述的其他策略。
 
 ##### 层和节点-实施
 
@@ -515,7 +515,7 @@ batch_size = 1
 
 ##### 时代
 
-历元是网络响应于数据通过及其丢失功能而调整其权重的次数。 为更多时期运行模型可以使它从数据中学到更多，但同时也存在过度拟合的风险。
+历元是网络响应于数据通过及其丢失功能而调整其权重的次数。 为更多时期运行模型可以使它从数据中学到更多，但同时也存在过拟合的风险。
 
 训练模型时，最好以指数形式增加历时，直到损失函数开始趋于平稳。 在`bitcoin_lstm_v0`模型的情况下，其损失函数稳定在大约 100 个纪元。
 
@@ -559,7 +559,7 @@ TensorFlow 和 Keras 提供了许多激活功能-偶尔会添加新的激活功
 
 ![Linear (Identity)](img/image03_32.jpg)
 
-当 *c = 1* 时，神经元将按原样传递值，而无需激活功能进行修改。 使用线性函数的问题是，由于神经元是线性激活的，因此链接的层现在可以用作单个大层。 换句话说，一个人失去了构建多层网络的能力，其中一个人的输出会影响另一个人：
+当`c = 1`时，神经元将按原样传递值，而无需激活功能进行修改。 使用线性函数的问题是，由于神经元是线性激活的，因此链接的层现在可以用作单个大层。 换句话说，一个人失去了构建多层网络的能力，其中一个人的输出会影响另一个人：
 
 ![Linear (Identity)](img/image03_20.jpg)
 
@@ -628,13 +628,13 @@ ReLU 具有非线性属性。 它们的定义是：
 
 ###### 正则化策略
 
-神经网络特别容易过拟合。 当网络学习训练数据的模式但无法找到也可以应用于测试数据的可推广模式时，就会发生过度拟合。
+神经网络特别容易过拟合。 当网络学习训练数据的模式但无法找到也可以应用于测试数据的可推广模式时，就会发生过拟合。
 
-正则化策略是指通过调整网络学习方式来解决过度拟合问题的技术。 在本书中，我们讨论两种常见的策略：L2 和 Dropout。
+正则化策略是指通过调整网络学习方式来解决过拟合问题的技术。 在本书中，我们讨论两种常见的策略：L2 和 Dropout。
 
 ###### L2 正则化
 
-L2 正则化（或权重衰减）是用于处理过度拟合模型的常见技术。 在某些模型中，某些参数的变化幅度很大。 L2 正则化惩罚了这些参数，从而降低了这些参数对网络的影响。
+L2 正则化（或权重衰减）是用于处理过拟合模型的常见技术。 在某些模型中，某些参数的变化幅度很大。 L2 正则化惩罚了这些参数，从而降低了这些参数对网络的影响。
 
 L2 正则化使用![L2 Regularization](img/image03_28.jpg)参数来确定对模型神经元的惩罚程度。 通常将其设置为一个非常低的值（即`0.0001`）； 否则，就有可能完全消除给定神经元的输入。
 
@@ -642,7 +642,7 @@ L2 正则化使用![L2 Regularization](img/image03_28.jpg)参数来确定对模
 
 辍学是一种基于简单问题的正则化技术：如果一个节点随机地从层中删除一部分节点，那么另一个节点将如何适应？ 事实证明，其余的神经元会适应，学会代表先前由缺失的那些神经元处理过的模式。
 
-退出策略易于实现，通常非常有效地避免过度拟合。 这将是我们首选的正则化。
+退出策略易于实现，通常非常有效地避免过拟合。 这将是我们首选的正则化。
 
 ###### 正则化策略-实施
 
@@ -758,7 +758,7 @@ MAPE（整个系列）
 
     使用一些不同的历元参数训练模型。
 
-    此时，您有兴趣确保模型不会过度拟合训练数据。 您想避免这种情况，因为如果这样做，它将无法预测训练数据中表示的模式，但测试数据中具有不同的表示形式。
+    此时，您有兴趣确保模型不会过拟合训练数据。 您想避免这种情况，因为如果这样做，它将无法预测训练数据中表示的模式，但测试数据中具有不同的表示形式。
 
     在尝试了新纪元之后，请转到下一个优化技术：激活函数。
 

new/begin-app-dev-tf-keras/4.md

 # 第 4.章产品化
 
-本课程重点介绍如何*产生*深度学习模型。 我们使用“产品化”一词来定义可被其他人和应用程序使用的深度学习模型创建的软件产品。
+本课程重点介绍如何*产品化*深度学习模型。 我们使用“产品化”一词来定义可被其他人和应用程序使用的深度学习模型创建的软件产品。
 
 我们对在使用新数据时可用的模型，不断从新数据中学习模式并因此做出更好的预测的模型感兴趣。 我们研究了两种处理新数据的策略：一种重新训练现有模型，另一种创建全新模型。 然后，我们在比特币价格预测模型中实施后一种策略，以便它可以连续预测新的比特币价格。
 

new/handson-dl-img-tf/1.md

@@ -63,7 +63,7 @@ Docker 文件代码
 
 Docker 文件代码
 
-Anaconda 是一种方便的 Python 发行版，可用于机器学习和数据科学任务，因为它带有预构建的数学库，尤其是 Pandas，NumPy，SciPy 和 scikit-learn，它们是使用优化的 **Intel Math Kernal Libraries 构建的。** 。 这是因为，即使没有 GPU，使用 Anaconda 通常也可以获得更好的性能。 它还具有以下优点：不是以 root 身份或全局方式安装在系统下，而是安装在主目录中。 因此，您可以将其添加到现有系统上，而不必担心破坏可能依赖 Python 的系统组件，例如，在用户的`bin`中或由全局软件包管理器安装的组件。
+Anaconda 是一种方便的 Python 发行版，可用于机器学习和数据科学任务，因为它带有预构建的数学库，尤其是 Pandas，NumPy，SciPy 和 scikit-learn，它们是使用优化的**英特尔数学内核库**构建的。 这是因为，即使没有 GPU，使用 Anaconda 通常也可以获得更好的性能。 它还具有以下优点：不是以 root 身份或全局方式安装在系统下，而是安装在主目录中。 因此，您可以将其添加到现有系统上，而不必担心破坏可能依赖 Python 的系统组件，例如，在用户的`bin`中或由全局软件包管理器安装的组件。
 
 现在，我们将在名为 Keras 的容器上设置一个用户：
 

new/handson-dl-img-tf/2.md

@@ -26,7 +26,7 @@ Keras 实际上具有内置的 MNIST 数字作为数据集，因此我们将使
 
 Python 元组
 
-实际上，在机器学习中，将数据分为多个部分是很常见的约定。 您使用它来查看您的模型实际上是在使用训练集进行学习。 然后，您可以使用测试集来确保模型不会过度拟合，这实际上是在考虑模型是存储训练数据还是在实际学习中。
+实际上，在机器学习中，将数据分为多个部分是很常见的约定。 您使用它来查看您的模型实际上是在使用训练集进行学习。 然后，您可以使用测试集来确保模型不会过拟合，这实际上是在考虑模型是存储训练数据还是在实际学习中。
 
 现在，让我们看一下带有 NumPy 格式选项的快速设置。 当我们打印出数组时，我们将图像作为数组的数组循环遍历，然后打印出数据。 如您所见，图像实际上只是从`0`到`255`的数字：
 

new/handson-dl-img-tf/3.md

@@ -103,9 +103,9 @@ ReLu 非线性函数-大于零。
 
 加载.shape（测试）
 
-这些尺寸以适当的方式匹配非常重要。 因此，对于训练集，第一个维度必须与您的`x`和`y`值（您的输入和输出）匹配，并且在您的测试集上，同样必须正确。 但也请注意，训练和测试数据的第二和第三个维度`28`和`28`相同，而测试和训练数据的`10`（输出维度）相同。 准备信息时，最常见的错误之一就是不对这些数据集进行排序。 但为什么？！ 一言以蔽之：**过度拟合**。
+这些尺寸以适当的方式匹配非常重要。 因此，对于训练集，第一个维度必须与您的`x`和`y`值（您的输入和输出）匹配，并且在您的测试集上，同样必须正确。 但也请注意，训练和测试数据的第二和第三个维度`28`和`28`相同，而测试和训练数据的`10`（输出维度）相同。 准备信息时，最常见的错误之一就是不对这些数据集进行排序。 但为什么？！ 一言以蔽之：**过拟合**。
 
-过度拟合本质上是指您的机器学习模型存储一组输入时。 您可以将其视为一个非常复杂的哈希表，该哈希表已使用大量数字对输入和输出映射进行了编码。 但是，通过机器学习，即使我们可以轻松拥有一个哈希表，我们也不需要哈希表。 相反，我们希望有一个模型可以处理未知输入，然后预测适当的输出。 测试数据代表那些未知的输入。 当您跨训练数据训练模型并提供测试数据时，可以使用测试数据来验证您的机器学习模型可以处理和预测从未见过的数据。
+过拟合本质上是指您的机器学习模型存储一组输入时。 您可以将其视为一个非常复杂的哈希表，该哈希表已使用大量数字对输入和输出映射进行了编码。 但是，通过机器学习，即使我们可以轻松拥有一个哈希表，我们也不需要哈希表。 相反，我们希望有一个模型可以处理未知输入，然后预测适当的输出。 测试数据代表那些未知的输入。 当您跨训练数据训练模型并提供测试数据时，可以使用测试数据来验证您的机器学习模型可以处理和预测从未见过的数据。
 
 好吧，既然我们已经加载了培训和测试数据，我们将继续学习`Dropout`和`Flatten`，并建立一个实际的神经网络。
 

new/handson-meta-learn-py/01.md

 # 元学习导论
 
-元学习是当前人工智能领域最有前途和趋势的研究领域之一。 它被认为是获得**人工智能**（**AGI**）的垫脚石。 在本章中，我们将了解什么是元学习以及为什么元学习是当前人工智能中最令人振奋的研究。 我们将了解什么是少拍，单拍和零拍学习，以及如何在元学习中使用它。 我们还将学习不同类型的元学习技术。 然后，我们将探索学习通过梯度下降学习梯度下降的概念，其中我们了解如何使用元学习器来学习梯度下降优化。 继续进行，我们还将学习优化作为几次学习的模型，我们将了解如何在几次学习设置中将元学习器用作优化算法。
+元学习是当前人工智能领域最有前途和趋势的研究领域之一。 它被认为是获得**广义人工智能**（**AGI**）的垫脚石。 在本章中，我们将了解什么是元学习以及为什么元学习是当前人工智能中最令人振奋的研究。 我们将了解什么是少拍，单拍和零拍学习，以及如何在元学习中使用它。 我们还将学习不同类型的元学习技术。 然后，我们将探索学习通过梯度下降学习梯度下降的概念，其中我们了解如何使用元学习器来学习梯度下降优化。 继续进行，我们还将学习优化作为几次学习的模型，我们将了解如何在几次学习设置中将元学习器用作优化算法。
 
 在本章中，您将了解以下内容：
 
@@ -18,11 +18,11 @@
 
 深度学习真的是真正的 AI 吗？ 好吧，不是。 人类如何学习？ 我们将学习概括为多个概念并从中学习。 但是当前的学习算法仅能完成一项任务。 这就是元学习的用武之地。元学习产生了一个通用的 AI 模型，该模型可以学习执行各种任务，而无需从头开始进行培训。 我们使用很少的数据点在各种相关任务上训练我们的元学习模型，因此对于新的相关任务，它可以利用从先前任务中获得的学习知识，而不必从头开始进行训练。 许多研究人员和科学家认为，元学习可以使我们更接近实现 AGI。 在接下来的部分中，我们将确切学习元学习模型如何元学习过程。
 
-# 元学习和少拍
+# 元学习和少样本
 
-从较少的数据点中学习称为**少镜头学习**或 **K 镜头学习**，其中`k`表示每个数据点的数量 数据集中的类。 假设我们正在对猫和狗进行图像分类。 如果我们正好有一只狗和一只猫的图像，那么它被称为**单次学习**，也就是说，我们每个班级仅从一个数据点开始学习。 如果我们有 10 张狗的图像和 10 张猫的图像，则称为 10 次学习。 因此， K 镜头学习中的`k`意味着每个班级都有许多数据点。 还有**零击学习**，每个班级没有任何数据点。 等待。 什么？ 根本没有数据点时，我们如何学习？ 在这种情况下，我们将没有数据点，但是将获得有关每个类的元信息，并且将从元信息中学习。 由于我们的数据集中有两个类别，即狗和猫，因此可以将其称为双向学习`k`-shot learning； 因此`n`-way 表示我们在数据集中拥有的类的数量。
+从较少的数据点中学习称为**少样本学习**或 **K 次学习**，其中`k`表示每个数据点的数量 数据集中的类。 假设我们正在对猫和狗进行图像分类。 如果我们正好有一只狗和一只猫的图像，那么它被称为**单次学习**，也就是说，我们每个班级仅从一个数据点开始学习。 如果我们有 10 张狗的图像和 10 张猫的图像，则称为 10 次学习。 因此， K 次学习中的`k`意味着每个班级都有许多数据点。 还有**零次学习**，每个班级没有任何数据点。 等待。 什么？ 根本没有数据点时，我们如何学习？ 在这种情况下，我们将没有数据点，但是将获得有关每个类的元信息，并且将从元信息中学习。 由于我们的数据集中有两个类别，即狗和猫，因此可以将其称为双向学习`k`次学习； 因此`n`路表示我们在数据集中拥有的类的数量。
 
-为了使我们的模型从一些数据点中学习，我们将以相同的方式对其进行训练。 因此，当我们有一个数据集`D`时，我们从数据集中存在的每个类中采样一些数据点，并将其称为**支持集。** 同样，我们从每个类中采样一些不同的数据点，并将其称为**查询集。** 因此，我们使用支持集训练模型，并使用查询集进行测试。 我们以**情节形式**训练模型-也就是说，在每个情节中，我们从数据集中`D`中采样一些数据点，准备支持集和查询集，然后进行训练 在支持集上并在查询集上进行测试。 因此，在一系列情节中，我们的模型将学习如何从较小的数据集中学习。 我们将在接下来的章节中对此进行更详细的探讨。
+为了使我们的模型从一些数据点中学习，我们将以相同的方式对其进行训练。 因此，当我们有一个数据集`D`时，我们从数据集中存在的每个类中采样一些数据点，并将其称为**支持集**。 同样，我们从每个类中采样一些不同的数据点，并将其称为**查询集**。 因此，我们使用支持集训练模型，并使用查询集进行测试。 我们以**剧集形式**训练模型-也就是说，在每个剧集中，我们从数据集中`D`中采样一些数据点，准备支持集和查询集，然后进行训练 在支持集上并在查询集上进行测试。 因此，在一系列剧集中，我们的模型将学习如何从较小的数据集中学习。 我们将在接下来的章节中对此进行更详细的探讨。
 
 # 元学习的类型
 

new/handson-meta-learn-py/02.md

@@ -16,7 +16,7 @@
 
 但是，连体网络如何工作？ 连体网络基本上由两个对称的神经网络组成，它们共享相同的权重和结构，并且都使用能量函数`E`最终结合在一起。 我们的连体网络的目标是了解两个输入值是相似还是相异。 假设我们有两个图像`X[1]`和`X2`，我们想了解两个图像是相似还是相异。
 
-如下图所示，我们将图像`X[1]`馈送到**网络**`A`和图像`X[2]`到另一个**网络 B** 。 这两个网络的作用是为输入图像生成嵌入（特征向量）。 因此，我们可以使用任何可以嵌入我们的网络。 由于我们的输入是图像，因此我们可以使用卷积网络来生成嵌入，即用于提取特征。 请记住，CNN 在这里的作用仅仅是提取特征而不是进行分类。 我们知道这些网络应该具有相同的权重和架构，如果我们的**网络 A** 是三层 CNN，那么我们的**网络 B** 也应该是三层 CNN，我们 这两个网络必须使用相同的权重集。 因此，**网络 A** 和**网络 B** 将为我们提供输入图像`X[1]`和 **X <sub>的嵌入 2</sub>** 。 然后，我们会将这些嵌入信息提供给能量函数，从而告诉我们两个输入的相似程度。 能量函数基本上是任何相似性度量，例如欧几里得距离和余弦相似性。
+如下图所示，我们将图像`X[1]`馈送到网络`A`和图像`X[2]`到另一个网络`B`。 这两个网络的作用是为输入图像生成嵌入（特征向量）。 因此，我们可以使用任何可以嵌入我们的网络。 由于我们的输入是图像，因此我们可以使用卷积网络来生成嵌入，即用于提取特征。 请记住，CNN 在这里的作用仅仅是提取特征而不是进行分类。 我们知道这些网络应该具有相同的权重和架构，如果我们的网络`A`是三层 CNN，那么我们的网络`B`也应该是三层 CNN，我们 这两个网络必须使用相同的权重集。 因此，网络`A`和网络`B`将为我们提供输入图像`X[1]`和`X[2]`的嵌入。 然后，我们会将这些嵌入信息提供给能量函数，从而告诉我们两个输入的相似程度。 能量函数基本上是任何相似性度量，例如欧几里得距离和余弦相似性。
 
 ![](img/a7f1a41e-4291-4bec-87dd-fa6bc1d0c00b.png)
 
@@ -28,7 +28,7 @@
 
 ![](img/5b9384ce-2640-4df1-8d41-f668a5da1b79.png)
 
-如上图所示，连体网络由两个相同的网络组成，它们共享相同的权重和架构。 假设我们有两个输入，`X[1]`和`X[2]`。 我们将输入`X[1]`馈送到**网络 A** ，即 **f <sub>w</sub> （X <sub>1</sub> ）**，然后将输入的`X[2]`馈送到**网络 B** ，即 **f <sub>w</sub> （ X <sub>2</sub> ）**。 您会注意到，这两个网络的权重相同`w`，它们将为我们的输入`X[1]`和 **X 生成嵌入 <sub>2</sub>** 。 然后，我们将这些嵌入提供给能量函数`E`，这将使我们在两个输入之间具有相似性。
+如上图所示，连体网络由两个相同的网络组成，它们共享相同的权重和架构。 假设我们有两个输入，`X[1]`和`X[2]`。 我们将输入`X[1]`馈送到网络`A`，即`f[w](X[1])`，然后将输入的`X[2]`馈送到网络`B`，即`f[w](X[2])`。 您会注意到，这两个网络的权重相同`w`，它们将为我们的输入`X[1]`和`X[2]`生成嵌入。 然后，我们将这些嵌入提供给能量函数`E`，这将使我们在两个输入之间具有相似性。
 
 可以表示为：
 
@@ -36,9 +36,9 @@
 
 假设我们使用欧几里得距离作为能量函数，那么如果`X[1]`和`X[2]`相似。 如果输入值不相同，则`E`的值将很大。
 
-假设您有两个句子，句子 1 和句子 2。我们将句子 1 馈送到**网络 A** ，将句子 2 馈送到**网络 B** 。 假设我们的**网络 A** 和**网络 B** 都是 LSTM 网络，它们共享相同的权重。 因此，**网络 A** 和**网络 B** 将分别为句子 1 和句子 2 生成单词嵌入。 然后，我们将这些嵌入提供给能量函数，从而为我们提供两个句子之间的相似度得分。 但是我们如何训练我们的连体网络呢？ 数据应该如何？ 有哪些功能和标签？ 我们的目标功能是什么？
+假设您有两个句子，句子 1 和句子 2。我们将句子 1 馈送到网络`A`，将句子 2 馈送到网络`B`。 假设我们的网络`A`和网络`B`都是 LSTM 网络，它们共享相同的权重。 因此，网络`A`和网络`B`将分别为句子 1 和句子 2 生成单词嵌入。 然后，我们将这些嵌入提供给能量函数，从而为我们提供两个句子之间的相似度得分。 但是我们如何训练我们的连体网络呢？ 数据应该如何？ 有哪些功能和标签？ 我们的目标功能是什么？
 
-连体网络的输入应该成对出现**（X <sub>1</sub> ，X <sub>2</sub> ）**以及它们的二进制标签 **Y∈（0 ，1）**，指出输入对是真对（相同）还是非对（不同）。 正如您在下表中所看到的，我们将句子成对存在，并且标签暗示句子对是真实的（1）还是假的（0）：
+连体网络的输入应该成对出现`(X[1], X[2])`以及它们的二进制标签`Y ∈ (0, 1)`，指出输入对是真对（相同）还是非对（不同）。 正如您在下表中所看到的，我们将句子成对存在，并且标签暗示句子对是真实的（1）还是假的（0）：
 
 ![](img/be1f76a8-acc1-4eb3-8ff8-3111ce40625d.png)
 
@@ -80,7 +80,7 @@
 
 ![](img/adbe22c0-decf-4c78-803e-dbd84d4ef58b.png)
 
-一旦我们将数据与它们的标签配对在一起，就可以训练我们的连体网络。 从图像对中，我们将一个图像馈入网络 A，将另一个图像馈入网络 B。这两个网络的作用仅仅是提取特征向量。 因此，我们使用具有 **rec** **固定线性单位**（**ReLU**）激活的两个卷积层来提取特征。 一旦了解了特征，就将来自两个网络的合成特征向量馈入能量函数，以测量相似度。 我们使用欧几里得距离作为我们的能量函数。 因此，我们通过提供图像对来训练我们的网络，以了解它们之间的语义相似性。 现在，我们将逐步看到这一点。
+一旦我们将数据与它们的标签配对在一起，就可以训练我们的连体网络。 从图像对中，我们将一个图像馈入网络 A，将另一个图像馈入网络 B。这两个网络的作用仅仅是提取特征向量。 因此，我们使用具有**整流线性单元**（**ReLU**）激活的两个卷积层来提取特征。 一旦了解了特征，就将来自两个网络的合成特征向量馈入能量函数，以测量相似度。 我们使用欧几里得距离作为我们的能量函数。 因此，我们通过提供图像对来训练我们的网络，以了解它们之间的语义相似性。 现在，我们将逐步看到这一点。
 
 为了更好地理解，您可以检查完整的代码，该代码可以在 Jupyter Notebook 中找到，[并在此处进行解释](https://github.com/sudharsan13296/Hands-On-Meta-Learning-With-Python/blob/master/02.%20Face%20and%20Audio%20Recognition%20using%20Siamese%20Networks/2.4%20Face%20Recognition%20Using%20Siamese%20Network.ipynb)。
 

new/handson-meta-learn-py/10.md

@@ -3,7 +3,7 @@
 # 第 1 章：元学习简介
 
 1.  元学习产生了一种通用的 AI 模型，该模型可以学习执行各种任务，而无需从头开始进行培训。 我们使用几个数据点在各种相关任务上训练我们的元学习模型，因此对于新的但相关的任务，该模型可以利用从先前任务中学到的知识而不必从头开始进行训练。
-2.  从更少的数据点学习称为**少镜头学习**或 **k 镜头学习**，其中`k`表示在每个类别中数据点的数量 数据集。
+2.  从更少的数据点学习称为**少样本学习**或 **K 次学习**，其中`k`表示在每个类别中数据点的数量 数据集。
 3.  为了使我们的模型从一些数据点中学习，我们将以相同的方式对其进行训练。 因此，当我们有一个数据集`D`时，我们从数据集中存在的每个类中采样一些数据点，并将其称为支持集。
 4.  我们从与支持集不同的每个类中采样不同的数据点，并将其称为查询集。
 5.  在基于度量的元学习设置中，我们将学习适当的度量空间。 假设我们要找出两个图像之间的相似性。 在基于度量的设置中，我们使用一个简单的神经网络，该网络从两个图像中提取特征并通过计算这两个图像的特征之间的距离来查找相似性。

new/handson-rl-py/07.md

@@ -67,7 +67,7 @@
 
 ![](img/00166.gif)
 
-*   **ReLU 功能**：ReLU 也称为整流线性单位。 它是使用最广泛的激活功能之一。 ReLU 函数可以定义为`f(z) = max(0, z)`，即当`z`小于 0 且`f(z)`为 0。 当`z`大于或等于`0`时，等于`z`：
+*   **ReLU 功能**：ReLU 也称为整流线性单元。 它是使用最广泛的激活功能之一。 ReLU 函数可以定义为`f(z) = max(0, z)`，即当`z`小于 0 且`f(z)`为 0。 当`z`大于或等于`0`时，等于`z`：
 
 ![](img/00168.gif)
 

new/handson-rl-py/08.md

@@ -54,7 +54,7 @@ DQN 的第一层是卷积网络，网络的输入将是游戏屏幕的原始帧
 
 体验重播的关键思想是，我们使用从重播缓冲区采样的过渡来训练深度 Q 网络，而不是使用最后的过渡进行训练。 座席的经历一次相关，因此从重播缓冲区中随机选择一批训练样本将减少座席的经历之间的相关性，并有助于座席更好地从广泛的经验中学习。
 
-而且，神经网络将过度拟合相关经验，因此通过从答复缓冲区中选择随机的经验批次，我们将减少过度拟合。 我们可以使用统一采样来采样经验。 我们可以将体验重播视为队列而不是列表。 重播缓冲区将仅存储固定数量的最新体验，因此，当出现新信息时，我们将删除旧信息：
+而且，神经网络将过拟合相关经验，因此通过从答复缓冲区中选择随机的经验批次，我们将减少过拟合。 我们可以使用统一采样来采样经验。 我们可以将体验重播视为队列而不是列表。 重播缓冲区将仅存储固定数量的最新体验，因此，当出现新信息时，我们将删除旧信息：
 
 ![](img/00251.gif)
 

new/intel-proj-py/01.md

@@ -82,7 +82,7 @@
 
 # 神经激活单位
 
-取决于体系结构和当前的问题，在神经网络中使用了几种神经激活单元。 我们将讨论最常用的激活功能，因为它们在确定网络体系结构和性能方面起着重要作用。 线性和 S 形单位激活函数主要用于人工神经网络，直到 Hinton 等人发明的**整流线性单位**（**ReLUs**）彻底改变了神经网络的性能。
+取决于体系结构和当前的问题，在神经网络中使用了几种神经激活单元。 我们将讨论最常用的激活功能，因为它们在确定网络体系结构和性能方面起着重要作用。 线性和 S 形单位激活函数主要用于人工神经网络，直到 Hinton 等人发明的**整流线性单元**（**ReLUs**）彻底改变了神经网络的性能。
 
 # 线性激活单元
 
@@ -128,7 +128,7 @@ tanh 激活功能输出的值在[ **-1** ，`1`]范围内，如下图所示：
 
 需要注意的一件事是 S 型和 tanh 激活函数在很小的输入范围内都是线性的，超过该范围输出就会饱和。 在饱和区，激活函数（相对于输入）的梯度非常小或接近零； 这意味着它们非常容易消失梯度问题。 正如您将在后面看到的那样，神经网络将从反向传播方法中学习，在该方法中，层的梯度取决于后续层中直至最终输出层中激活单元的梯度。 因此，如果激活单元中的单元在饱和区域中工作，则将更少的误差反向传播到神经网络的早期层。 神经网络通过利用梯度来最小化预测误差，以学习权重和偏差（`W`）。 这意味着，如果梯度很小或消失为零，则神经网络将无法正确学习这些权重。
 
-# 整流线性单位（ReLU）
+# 整流线性单元（ReLU）
 
 当神经元的总输入大于零时，ReLU 的输出为线性，而当神经元的总输入为负时，ReLU 的输出为零。 这个简单的激活函数为神经网络提供了非线性，同时，它相对于总输入提供了一个恒定的梯度。 这个恒定的梯度有助于防止神经网络出现饱和或消失的梯度问题，如激活功能（如 S 型和 tanh 激活单元）所示。 ReLU 函数输出（如图“图 1.8”所示）可以表示如下：
 
@@ -478,7 +478,7 @@ Figure 1.14: GAN architecture
 
 通常，**迁移学习**是指使用在一个领域中获得的知识来解决另一领域中的相关问题的概念。 但是，在深度学习中，它专门指的是将针对特定任务训练的神经网络重新用于不同领域中的相似任务的过程。 新任务使用从先前任务中学到的特征检测器，因此我们不必训练模型就可以学习它们。
 
-由于不同层之间的连接模式的性质，深度学习模型倾向于具有大量参数。 要训​​练这么大的模型，需要大量的数据； 否则，模型可能会过度拟合。 对于许多需要深度学习解决方案的问题，将无法获得大量数据。 例如，在用于对象识别的图像处理中，深度学习模型提供了最新的解决方案。 在这种情况下，可以基于从现有的经过训练的深度学习模型中学习到的特征检测器，使用迁移学习来创建特征。 然后，这些功能可用于使用可用数据构建简单模型，以解决当前的新问题。 因此，新模型需要学习的唯一参数是与构建简单模型有关的参数，从而减少了过拟合的机会。 通常在大量数据上训练预训练的模型，因此，它们具有作为特征检测器的可靠参数。
+由于不同层之间的连接模式的性质，深度学习模型倾向于具有大量参数。 要训​​练这么大的模型，需要大量的数据； 否则，模型可能会过拟合。 对于许多需要深度学习解决方案的问题，将无法获得大量数据。 例如，在用于对象识别的图像处理中，深度学习模型提供了最新的解决方案。 在这种情况下，可以基于从现有的经过训练的深度学习模型中学习到的特征检测器，使用迁移学习来创建特征。 然后，这些功能可用于使用可用数据构建简单模型，以解决当前的新问题。 因此，新模型需要学习的唯一参数是与构建简单模型有关的参数，从而减少了过拟合的机会。 通常在大量数据上训练预训练的模型，因此，它们具有作为特征检测器的可靠参数。
 
 当我们在 CNN 中处理图像时，初始层会学会检测非常通用的特征，例如卷曲，边缘，颜色组成等。 随着网络的深入发展，更深层次的卷积层将学会检测与特定种类的数据集相关的更复杂特征。 我们可以使用预训练的网络，并选择不训练前几层，因为它们会学习非常通用的功能。 相反，我们可以只专注于训练最后几层的参数，因为它们将学习针对当前问题的复杂功能。 这样可以确保我们需要训练的参数较少，并且可以明智地使用数据，仅训练所需的复杂参数，而不训练通用特征。
 

new/intel-proj-py/02.md

@@ -333,9 +333,9 @@ def VGG16_pseudo(dim=224,freeze_layers=10,full_freeze='N'):
 
 # InceptionV3 迁移学习网络
 
-在以下代码块中定义了用于我们任务的`InceptionV3`网络。 需要注意的一件事是，由于`InceptionV3`是一个更深的网络，因此我们可以拥有更多的初始层。 在数据可用性方面，不训练每个模型中的所有层的想法还有另一个优势。 如果我们使用较少的数据训练，则整个网络的权重可能会导致过度拟合。 冻结层会减少要训练的权重数，因此提供了一种形式的规则化。
+在以下代码块中定义了用于我们任务的`InceptionV3`网络。 需要注意的一件事是，由于`InceptionV3`是一个更深的网络，因此我们可以拥有更多的初始层。 在数据可用性方面，不训练每个模型中的所有层的想法还有另一个优势。 如果我们使用较少的数据训练，则整个网络的权重可能会导致过拟合。 冻结层会减少要训练的权重数，因此提供了一种形式的规则化。
 
-由于初始层学习通用特征，而与问题的范围无关，因此它们是冻结的最佳层。 我们还在全连接层中使用了 dropout，以防止过度拟合：
+由于初始层学习通用特征，而与问题的范围无关，因此它们是冻结的最佳层。 我们还在全连接层中使用了 dropout，以防止过拟合：
 
 ```py
 def inception_pseudo(dim=224,freeze_layers=30,full_freeze='N'):
@@ -977,7 +977,7 @@ if __name__ == '__main__':
 
 # 执行回归而不是分类
 
-我们在“损失函数公式”部分中讨论的一件事是，类别标签不是独立的分类类别，但随着糖尿病性视网膜病变情况的严重性增加，它们确实具有序数意义。 因此，值得通过定义的迁移学习网络进行回归，而不是进行分类，并观察结果如何。 我们唯一需要更改的是输出单位，从 softmax 到线性单位。 实际上，我们将其更改为 ReLU，因为我们希望避免出现负分数。 以下代码块显示了回归网络的`InceptionV3`版本：
+我们在“损失函数公式”部分中讨论的一件事是，类别标签不是独立的分类类别，但随着糖尿病性视网膜病变情况的严重性增加，它们确实具有序数意义。 因此，值得通过定义的迁移学习网络进行回归，而不是进行分类，并观察结果如何。 我们唯一需要更改的是输出单位，从 softmax 到线性单元。 实际上，我们将其更改为 ReLU，因为我们希望避免出现负分数。 以下代码块显示了回归网络的`InceptionV3`版本：
 
 ```py
 def inception_pseudo(dim=224,freeze_layers=30,full_freeze='N'):

new/intel-proj-py/06.md

@@ -228,7 +228,7 @@ test_ratings_df[test_ratings_df['userID'] == 1].sort_values(['rating','predictio
 
 `I[ij]`是一种指标函数，如果用户`i`具有额定项目`j`，则该函数为 1；否则为零。
 
-相对于用户参数和项目资料，成本最小化。 通常，这种优化会导致过度拟合，因此，将用户的规范和物料配置文件用作成本函数的正则化，如下所示：
+相对于用户参数和项目资料，成本最小化。 通常，这种优化会导致过拟合，因此，将用户的规范和物料配置文件用作成本函数的正则化，如下所示：
 
 ![](img/49b382af-40f5-4518-a77f-e04a3c6ad7cc.png)
 
@@ -263,7 +263,7 @@ data = Dataset.load_builtin('ml-100k')
 trainset, testset = train_test_split(data, test_size=.2)
 ```
 
-接下来，我们将对数据进行`5`折叠交叉验证，并查看交叉验证结果。 我们为随机梯度下降选择了`0.008`的学习率。 为了防止过度拟合，我们为 L1 和 L2 正则化选择了正则化常数`0.1`。 这些代码行的详细信息如下：
+接下来，我们将对数据进行`5`折叠交叉验证，并查看交叉验证结果。 我们为随机梯度下降选择了`0.008`的学习率。 为了防止过拟合，我们为 L1 和 L2 正则化选择了正则化常数`0.1`。 这些代码行的详细信息如下：
 
 ```py
 #Perform 5 fold cross validation with all data 

new/intel-proj-py/07.md

@@ -207,7 +207,7 @@ records_processed 50000
 
 # 建立模型
 
-我们将构建一个简单的 LSTM 版本的循环神经网络，在输入层之后有一个嵌入层。 使用预训练的尺寸为 100 的 Glove 向量初始化嵌入层字向量，并将该层定义为`trainable`，以便字向量嵌入可以根据训练数据进行更新。 隐藏状态和单元状态的维数也保持为`100`。 使用二进制交叉熵损失训练模型。 为避免过度拟合，将脊正则化添加到损失函数中。 **Adam 优化器** ***，*** 用于训练模型。
+我们将构建一个简单的 LSTM 版本的循环神经网络，在输入层之后有一个嵌入层。 使用预训练的尺寸为 100 的 Glove 向量初始化嵌入层字向量，并将该层定义为`trainable`，以便字向量嵌入可以根据训练数据进行更新。 隐藏状态和单元状态的维数也保持为`100`。 使用二进制交叉熵损失训练模型。 为避免过拟合，将脊正则化添加到损失函数中。 **Adam 优化器** ***，*** 用于训练模型。
 
 以下代码段显示了用于在 TensorFlow 中构建模型的函数：
 

new/intel-proj-py/09.md

@@ -117,9 +117,9 @@ Q 值表也通过迭代`t`进行索引，因为代理只能查看到目前为止
 
 图 9.4B：双重深度 Q 学习的图示
 
-在上图中，我们可以看到两个网络：**网络 A** ，可以学习预测给定状态下的实际 Q 值；以及**网络 B** ，可以帮助计算目标 Q 值。 **网络 A** 通过最小化目标的损失函数和预测的 Q 值来进行改进。 由于 Q 值通常本质上是连续的，因此一些有效的损失函数为`mean squared error`，`mean absolute error`，`Huber Loss`和`log-cosh loss`等。
+在上图中，我们可以看到两个网络：网络`A`，可以学习预测给定状态下的实际 Q 值；以及网络`B`，可以帮助计算目标 Q 值。 网络`A`通过最小化目标的损失函数和预测的 Q 值来进行改进。 由于 Q 值通常本质上是连续的，因此一些有效的损失函数为`mean squared error`，`mean absolute error`，`Huber Loss`和`log-cosh loss`等。
 
-**网络 B** 基本上是**网络 A** 的副本，因此它们共享相同的体系结构。 通常以指定的时间间隔将**网络 A** 的权重复制到**网络 B** 。 这是为了确保不使用同一组网络权重来预测 Q 值，也不会制定目标 Q 值，因为这会导致不稳定的训练。 给定单个训练元组`(s[t] = s, a[t] = a, r[r] = r, s[t + 1] = s')`，**网络 A** 对所有可能的动作给出状态`s[t] = s`。 由于我们知道实际动作`a[t] = a`，因此我们选择 Q 值`Q[t](s[t] = a, a[t] = a)`。 这将充当我们的预测 Q 值![](img/def6bacb-9f53-4d6f-9766-5f4a67d24943.png)。
+网络`B`基本上是网络`A`的副本，因此它们共享相同的体系结构。 通常以指定的时间间隔将网络`A`的权重复制到网络`B`。 这是为了确保不使用同一组网络权重来预测 Q 值，也不会制定目标 Q 值，因为这会导致不稳定的训练。 给定单个训练元组`(s[t] = s, a[t] = a, r[r] = r, s[t + 1] = s')`，网络`A`对所有可能的动作给出状态`s[t] = s`。 由于我们知道实际动作`a[t] = a`，因此我们选择 Q 值`Q[t](s[t] = a, a[t] = a)`。 这将充当我们的预测 Q 值![](img/def6bacb-9f53-4d6f-9766-5f4a67d24943.png)。
 
 现在，计算目标要困难一些，因为它涉及到两个网络。 我们知道在步骤`t`的任何状态`s[t]`的候选 Q 值是时间`t`的即时奖励`r[t]`，加上给定新状态`s[t + 1]`的在下一步`t + 1`的最大 Q 值。 候选 Q 值可以表示为：
 
@@ -127,8 +127,8 @@ Q 值表也通过迭代`t`进行索引，因为代理只能查看到目前为止
 
 当![](img/3324a291-28b5-4821-920a-394f71f7e4fe.png)是恒定折扣因子时就是这种情况。 奖励`r`已经是训练元组的一部分。 因此，我们唯一需要计算目标的是动作`a'`，该动作给出最大 Q 值，并将相应的 Q 值赋予相应的动作`a'`。 这个计算问题![](img/b1ae24ef-b42e-46c8-9bba-d3868b2e37ed.png)分为两个部分：
 
-*   **网络 A** 确定动作`a'`，该动作在状态`s'`下给出最大 Q 值。 但是，我们**不会**从网络 A 中获取与`a'`和状态`s'`对应的 Q 值。
-*   **网络 B** 用于提取 Q 值`Q[tk](s', a')`对应于状态`s'`和动作`a'`。
+*   网络`A`确定动作`a'`，该动作在状态`s'`下给出最大 Q 值。 但是，我们**不会**从网络 A 中获取与`a'`和状态`s'`对应的 Q 值。
+*   网络`B`用于提取 Q 值`Q[tk](s', a')`对应于状态`s'`和动作`a'`。
 
 与基本的`DQN`相比，这导致稳定得多的训练。
 

new/master-pred-anal-sklearn-tf/3.md

@@ -153,7 +153,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 *   它可以简化模型，从而使模型更易于理解和解释。 如果要处理成千上万的功能，可能需要一些计算方面的考虑。 减少功能部件数量以节省计算资源可能是一个好主意。
 *   另一个原因是要避免“维数的诅咒”。 现在，这是一个技术术语，在处理高维数据时会出现一系列问题。
-*   这也有助于我们最大程度地减少过度拟合，因为如果您包含许多不相关的特征来预测目标，则您的模型可能会过度拟合该噪声。 因此，删除不相关的功能将帮助您进行过度拟合。
+*   这也有助于我们最大程度地减少过拟合，因为如果您包含许多不相关的特征来预测目标，则您的模型可能会过拟合该噪声。 因此，删除不相关的功能将帮助您进行过拟合。
 
 在本章前面看到的特征选择可以认为是降维的一种形式。 当您具有一组紧密相关甚至冗余的功能时，PCA 将是使用较少功能对相同信息进行编码的首选技术。 那么，什么是 PCA？ 这是一种统计过程，将一组可能相关的变量的观测值转换为一组线性无关的变量，称为**主成分**。 我们不要讨论有关 PCA 发生了什么的数学细节。
 

new/master-pred-anal-sklearn-tf/4.md

@@ -108,7 +108,7 @@
 *   **优化算法**：这是用于学习网络权重的算法。 您选择的每种算法都有不同的超参数，建模者需要您选择它们​​。 训练这些网络的最基本算法是**梯度下降**。 但是，梯度下降的速度可能很慢并且存在一些问题，因此研究人员提出了其他算法，例如**动量优化器**， **AdaGrad** ， **RMSProp** 和 **亚当**矩算法。 在 TensorFlow 中，我们可以选择很多算法，包括亚当矩算法，而这实际上是我们将在示例中使用的算法。
 *   **损失函数**：此函数将产生将由优化器最小化的数量。 损失函数的选择取决于问题。 如果我们正在做回归问题，则可以选择均方误差或均对均方误差。 对于分类问题，有更多选择，例如交叉熵，平方损失和铰链损失。 这类似于反复试验。 有时候，一个损失函数会解决您的问题，有时却不会。 因此，这就是为什么您必须考虑许多不同的损失函数的原因。 但是，请记住，损失函数将产生数量，该数量将用于优化算法，以调整将成为网络一部分的不同感知器的不同权重。 因此，这是将产生数量的函数，优化器的目标是使该数量尽可能小。
 *   **权重初始化策略**：必须使用一些值来初始化网络中每个感知器的权重，并且优化算法将逐步更改这些值以最大程度地减少损失。 您可以通过多种方式初始化这些值。 您可以用全零初始化。 多年来，研究人员习惯于使用随机正态分布进行初始化，但近年来，研究人员提出了更好的选择，包括 Xavier 初始化和 He 初始化。
-*   **正则化策略**：这是一项可选功能，但强烈建议您使用该功能，因为深度学习模型由于计算出的参数数量过多，往往会过度拟合数据。 您可以使用许多选择，包括 L1 正则化，L2 正则化和辍学正则化策略。 在本书中，我们不会在示例中使用正则化，但请记住，如果您要构建真正有效的深度学习模型，则很有可能需要正则化策略。
+*   **正则化策略**：这是一项可选功能，但强烈建议您使用该功能，因为深度学习模型由于计算出的参数数量过多，往往会过拟合数据。 您可以使用许多选择，包括 L1 正则化，L2 正则化和辍学正则化策略。 在本书中，我们不会在示例中使用正则化，但请记住，如果您要构建真正有效的深度学习模型，则很有可能需要正则化策略。
 
 *   **训练策略**：训练策略是指将数据呈现给训练算法的方式。 这不是模型本身的一部分，但是会影响模型的结果和性能。 在谈论训练深度学习模型时，您会听到“ epoch”一词。 一个时期是所有训练实例通过网络的第一步。 在这些深度学习模型中，您将不得不多次将数据呈现给网络，以便网络可以为模型学习最佳参数。 这里还有另一个概念：批量大小。 这是同时显示给训练算法的元素数量。 因此，在深度学习模型的情况下，我们不向模型提供整个训练数据集。 我们要做的是呈现数据集的批次，并且在每批次中，我们仅发送几个示例，也许是 100 或 50，这就是我们训练深度学习模型的方式。 现在，您可以使用时期和批处理大小来计算模型中的迭代次数，这就是训练步骤数，这是优化算法对模型权重进行调整的次数。 因此，例如，如果您有 1,000 个训练示例，并且将使用的批处理大小为 100，则将需要 10 次迭代才能完成一个纪元。 您可以使用以下公式获得迭代总数：
 

new/master-pred-anal-sklearn-tf/5.md

@@ -270,11 +270,11 @@ y = tf.placeholder(y_train.dtype)
 
 # DNN 分类
 
-为了了解 DNN 的分类，我们首先必须了解指数线性单位函数的概念和模型的元素。
+为了了解 DNN 的分类，我们首先必须了解指数线性单元函数的概念和模型的元素。
 
-# 指数线性单位激活函数
+# 指数线性单元激活函数
 
-**指数线性单位**（**ELU**）函数是 ReLU 函数的相对较新的修改。 它看起来与 ReLU 函数非常相似，但是具有非常不同的数学特性。 以下屏幕截图显示了 ELU 功能：
+**指数线性单元**（**ELU**）函数是 ReLU 函数的相对较新的修改。 它看起来与 ReLU 函数非常相似，但是具有非常不同的数学特性。 以下屏幕截图显示了 ELU 功能：
 
 ![](img/1e4604f6-28a4-4da0-9faa-de706a4da045.png)