2020-12-23 21:30:46

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

@@ -213,7 +213,7 @@ $ jupyter notebook
 
 ![Activity 3 – Exploring the Bitcoin Dataset and Preparing Data for Model](img/image02_20.jpg)
 
-图 8：笔记本的图像 Activity_3_Exploring_Bitcoin_Dataset.ipynb。 您现在可以与该笔记本进行交互并进行修改。
+图 8：笔记本的图像`Activity_3_Exploring_Bitcoin_Dataset.ipynb`。 您现在可以与该笔记本进行交互并进行修改。
 
 在打开我们的 Jupyter 笔记本电脑之后，现在让我们探索本课程提供的比特币数据。
 
@@ -249,7 +249,7 @@ $ jupyter notebook
 
 ![Activity 3 – Exploring the Bitcoin Dataset and Preparing Data for Model](img/image02_21.jpg)
 
-图 9：来自 close 变量的比特币收盘价的时间序列图。 重现此图，但在此图下面的新单元格中使用 volume 变量。
+图 9：来自`close`变量的比特币收盘价的时间序列图。 重现此图，但在此图下面的新单元格中使用`volume`变量。
 
 您肯定会注意到这两个变量在 2017 年都在激增。这反映了当前的现象，即比特币的价格和价值自该年年初以来一直在持续增长。
 
@@ -275,7 +275,7 @@ bitcoin_recent = bitcoin[bitcoin['date'] >= '2016-01-01']
 
 在包含本课程的同一目录中，我们放置了一个名为`normalizations.py`的脚本。 该脚本包含本课中描述的三种标准化技术。 我们将该脚本导入到 Jupyter 笔记本中，并将这些功能应用于我们的系列。
 
-导航到“为模型准备数据集”部分。 现在，使用`iso_week`变量使用 pandas 方法`groupby()`将给定一周中的全天观察分组。 现在，我们可以在一周内将归一化函数`normalizations.point_relative_normalization()`直接应用于该系列。 我们使用以下命令将该归一化的输出存储为同一Pandas数据框中的新变量：
+导航到“为模型准备数据集”部分。 现在，使用`iso_week`变量使用 pandas 方法`groupby()`将给定一周中的全天观察分组。 现在，我们可以在一周内将归一化函数`normalizations.point_relative_normalization()`直接应用于该系列。 我们使用以下命令将该归一化的输出存储为同一 Pandas 数据帧中的新变量：
 
 ```py
 bitcoin_recent['close_point_relative_normalization'] =
@@ -293,7 +293,7 @@ lambda x: normalizations.point_relative_normalization(x))
 
 ![Activity 3 – Exploring the Bitcoin Dataset and Preparing Data for Model](img/image02_25.jpg)
 
-图 13：显示归一化变量 close_point_relative_normalization 的序列的图
+图 13：显示归一化变量`close_point_relative_normalization`的序列的图
 
 为了评估模型的效果，我们需要对照其他数据测试其准确性。 为此，我们创建了两个数据集：训练集和测试集。 在本活动中，我们将使用 80% 的数据集训练 LSTM 模型，并使用 20% 的数据评估其性能。
 
@@ -403,7 +403,7 @@ model.predict(x=X_train)
 
 ![Model Components](img/image02_27.jpg)
 
-图 15：Keras 神经网络范例：A.设计神经网络架构，B.训练神经网络（或 Fit），以及 C.进行预测
+图 15：Keras 神经网络范例：A. 设计神经网络架构，B. 训练神经网络（或拟合），以及 C. 进行预测
 
 Keras 允许在每个步骤中进行更大的控制。 但是，其重点是使用户在尽可能短的时间内尽可能轻松地创建神经网络。 这意味着我们可以从一个简单的模型开始，然后在上述每个步骤中增加复杂性，以使初始模型的性能更好。
 
@@ -478,15 +478,15 @@ model.save('bitcoin_lstm_v0.h5')
 
 ![Training a Neural Network](img/image02_29.jpg)
 
-图 17：该表显示了从 train_d–ataset.csv 文件加载的训练数据集的前五行
+图 17：该表显示了从`train_d–ataset.csv`文件加载的训练数据集的前五行
 
 自 2016 年初以来，我们将使用变量`close_point_relative_normalization`的序列，该序列是变量`close`的归一化比特币收盘价序列。
 
-变量`close_point_relative_normalization`已每周标准化。 该周期间的每个观察值都是相对于该期间第一天收盘价的差额进行的。 标准化步骤很重要，将有助于我们的网络训练更快。
+变量`close_point_relative_normalization`已每周标准化。 该周的周期的每个观察值都是相对于该周期第一天收盘价的差额进行的。 标准化步骤很重要，将有助于我们的网络训练更快。
 
 ![Training a Neural Network](img/image02_25.jpg)
 
-> 图 18：显示归一化变量 close_point_relative_normalization 的序列的图。 此变量将用于训练我们的 LSTM 模型。
+> 图 18：显示归一化变量`close_point_relative_normalization`的序列的图。 此变量将用于训练我们的 LSTM 模型。
 
 ### 重塑时间序列数据
 
@@ -516,7 +516,7 @@ LSTM 网络使用三维张量。 这些维度中的每一个都代表了网络
 
 目前，来自变量`close_point_relative_normalization`的数据是一维向量，我们需要对其进行重塑以匹配这三个维度。
 
-我们将以一周的时间为。 因此，我们的期间长度为 7 天（期间长度= 7）。 我们的数据中有 77 个完整的星期可用。 在训练期间，我们将使用这周的最后一周来测试我们的模型。 这给我们留下了 76 个不同的星期（周期数= 76）。 最后，我们将在此网络中使用单个功能（功能数量= 1）-将来的版本中将包含更多功能。
+我们将以一周的时间为。 因此，我们的周期长度为 7 天（周期长度为 7）。 我们的数据中有 77 个完整的星期可用。 在训练期间，我们将使用这周的最后一周来测试我们的模型。 这给我们留下了 76 个不同的星期（周期数为 76）。 最后，我们将在此网络中使用单个功能（功能数量为 1）-将来的版本中将包含更多功能。
 
 我们如何重塑数据以匹配这些维度？ 我们将结合使用基本的 Python 属性和`numpy`库中的`reshape()`。 首先，我们使用纯 Python 创建 76 个不同的星期组，每个星期 7 天：
 
@@ -598,7 +598,7 @@ LSTM 是计算上昂贵的模型。 在现代计算机上，我们最多可能
 
     ![Activity 5 – Assembling a Deep Learning System](img/image02_32.jpg)
 
-    图 21：显示归一化变量 close_point_relative_normalization 的序列的图
+    图 21：显示归一化变量`close_point_relative_normalization`的序列的图
 
     ### 注意
 
@@ -618,7 +618,7 @@ LSTM 是计算上昂贵的模型。 在现代计算机上，我们最多可能
     train.head()
     ```
 
-    如本课程中所述，LSTM 网络需要具有三个维度的张量。 这些维度是：期间长度，期间数和特征数。
+    如本课程中所述，LSTM 网络需要具有三个维度的张量。 这些维度是：周期长度，周期数和特征数。
 
     现在，继续创建每周组，然后重新排列结果数组以匹配这些尺寸。
 

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

@@ -214,9 +214,9 @@ Keras 提供了`model.evaluate(),`方法，该方法使针对测试集评估训
 
 我们的首先训练网络（`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 倍。 这意味着该模型在我们的测试数据中比在验证集中的性能要差得多。 这值得考虑。
+让我们再次看图 4。 我们知道，我们的 LSTM 模型在验证集中达到极低的值（约`2.9 * 10-6`），但在测试集中也达到极低的值。 但是，关键的区别在于规模。 我们的测试集中每周的 MSE 大约是测试集中平均水平的 4,000 倍。 这意味着该模型在我们的测试数据中比在验证集中的性能要差得多。 这值得考虑。
 
 但是，规模隐藏了我们 LSTM 模型的力量：即使在我们的测试集中表现更差，预测的 MSE 误差仍然非常非常低。 这表明我们的模型可能是从数据中学习模式。
 
@@ -237,7 +237,7 @@ Keras 提供了`model.evaluate(),`方法，该方法使针对测试集评估训
  predicted_weeks.append(B.predict(input_series))
 ```
 
-> 片段 5：使用 model.predict（）方法对测试数据集的所有星期进行预测的片段
+> 片段 5：使用`model.predict()`方法对测试数据集的所有星期进行预测的片段
 
 在前面的代码中，我们使用`model.predict(),`进行预测，然后将这些预测存储在`predicted_weeks`变量中。 然后，我们绘制结果预测，如下图所示：
 
@@ -266,7 +266,7 @@ Keras 提供了`model.evaluate(),`方法，该方法使针对测试集评估训
  lambda x: denormalize(observed, x))
 ```
 
-> “代码段 6”：使用反向点相对归一化技术对数据进行归一化。 denormalize（）函数从测试的等效一周的第一天起收取第一个收盘价。
+> “代码段 6”：使用反向点相对归一化技术对数据进行归一化。 `denormalize()`函数从测试的等效一周的第一天起收取第一个收盘价。
 
 现在，我们的结果使用美元将预测值与测试集进行比较。 从“图 5”中可以看出，`bitcoin_lstm_v0` 模型在预测接下来的 7 天比特币价格时似乎表现良好。 但是，我们如何用可解释的术语衡量绩效呢？
 
@@ -321,7 +321,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
     ![Activity 6 – Creating an Active Training Environment](img/image03_13.jpg)
 
-    图 7：Jupyter 笔记本突出显示``评估 LSTM 模型''部分
+    图 7：Jupyter 笔记本突出显示“评估 LSTM 模型”部分
 
 3.  同样在您的终端机上，通过执行以下命令来启动 TensorBoard 实例：
 
@@ -357,7 +357,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
     ![Activity 6 – Creating an Active Training Environment](img/image03_07.jpg)
 
-    图 8：模型 set.evaluate（）方法对测试集每周的 MSE 结果
+    图 8：模型`set.evaluate()`方法对测试集每周的 MSE 结果
 
     正如我们在本课程中讨论的那样，MSE 损失函数很难解释。 为了促进我们对模型性能的理解，我们还每周在测试集中调用方法`model.predict()`，并将其预测结果与该集的值进行比较。
 
@@ -374,7 +374,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
     ![Activity 6 – Creating an Active Training Environment](img/image03_09.jpg)
 
-    图 9：绘制测试集每个星期从 model.predict（）返回的归一化值
+    图 9：绘制测试集每个星期从`model.predict()`返回的归一化值
 
     我们还将进行相同的比较，但使用非标准化值。 为了使我们的数据不规范，我们必须首先确定测试集和预测之间的等效周。 然后，我们获取该周的第一个价格值，并使用它来逆转“第 2 课，模型架构”中的点相对标准化方程。
 
@@ -390,7 +390,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
     ![Activity 6 – Creating an Active Training Environment](img/image03_11.jpg)
 
-    图 10：绘制测试集每个星期从 model.predict（）返回的归一化值
+    图 10：绘制测试集每个星期从`model.predict()`返回的归一化值
 
     LSTM 网络使用 MSE 值作为其损耗函数。 但是，正如课程中所讨论的，MSE 值难以解释。 为了解决这个问题，我们实现了两个功能（从脚本`utilities.py`加载），它们实现了功能 RMSE 和 MAPE。 这些函数通过返回与原始数据相同的比例尺的度量值，并比较比例尺的百分比差异，从而为我们的模型增加了可解释性。
 
@@ -461,7 +461,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
 ##### 添加更多节点
 
-图层所需的神经元数量与输入和输出数据的结构方式有关。 例如，如果您要将 4 x 4 像素图像分为两类之一，则可以从一个具有 12 个神经元的隐藏层（每个可用像素一个）和一个只有两个神经元的输出层开始（一个用于 每个预测的课程）。
+图层所需的神经元数量与输入和输出数据的结构方式有关。 例如，如果您要将`4 x 4`像素图像分为两类之一，则可以从一个具有 12 个神经元的隐藏层（每个可用像素一个）和一个只有两个神经元的输出层开始（一个用于 每个预测的课程）。
 
 通常在添加新层的同时添加新神经元。 然后，可以添加一层具有与前一层相同数量的神经元，或者是前一层的神经元数量的倍数的层。 例如，如果您的第一个隐藏层具有 12 个神经元，则可以尝试添加第二个具有 12、6 或 24 个层的神经元。
 
@@ -551,7 +551,7 @@ TensorFlow 和 Keras 提供了许多激活函数-偶尔会添加新的激活函
 
 ### 注意
 
-本部分的灵感来自 Avinash Sharma V 撰写的文章[《了解神经网络中的激活函数》](https://medium.com/the-theory-of-everything/understanding-activation-functions-in-neural-networks-9491262884e0)，该文章可从获得启发。
+本部分的灵感来自 Avinash Sharma 撰写的文章[《了解神经网络中的激活函数》](https://medium.com/the-theory-of-everything/understanding-activation-functions-in-neural-networks-9491262884e0)，该文章可从获得启发。
 
 ###### 线性（身份）
 
@@ -573,7 +573,7 @@ TensorFlow 和 Keras 提供了许多激活函数-偶尔会添加新的激活函
 
 ![Hyperbolic Tangent (Tanh)](img/image03_22.jpg)
 
-表示将连续评估它们对节点的影响。 同样，由于其非线性，可以使用此功能来更改一层如何影响链中的下一层。 使用非线性函数时，图层会以不同的方式激活神经元，从而使从数据中学习不同的表示更为容易。 但是，它们具有类似于 S 形的图案，可反复惩罚极端节点值，从而导致称为的问题，即消失梯度。 消失的梯度对网络的学习能力产生负面影响：
+表示将连续评估它们对节点的影响。 同样，由于其非线性，可以使用此功能来更改一层如何影响链中的下一层。 使用非线性函数时，图层会以不同的方式激活神经元，从而使从数据中学习不同的表示更为容易。 但是，它们具有类似于 Sigmoid 的图案，可反复惩罚极端节点值，从而导致称为的问题，即消失梯度。 消失的梯度对网络的学习能力产生负面影响：
 
 ![Hyperbolic Tangent (Tanh)](img/image03_24.jpg)
 
@@ -630,7 +630,7 @@ ReLU 具有非线性属性。 它们的定义是：
 
 神经网络特别容易过拟合。 当网络学习训练数据的模式但无法找到也可以应用于测试数据的可推广模式时，就会发生过拟合。
 
-正则化策略是指通过调整网络学习方式来解决过拟合问题的技术。 在本书中，我们讨论两种常见的策略：L2 和 Dropout。
+正则化策略是指通过调整网络学习方式来解决过拟合问题的技术。 在本书中，我们讨论两种常见的策略：L2 和丢弃。
 
 ###### L2 正则化
 
@@ -638,9 +638,9 @@ L2 正则化（或权重衰减）是用于处理过拟合模型的常见技术
 
 L2 正则化使用![L2 Regularization](img/image03_28.jpg)参数来确定对模型神经元的惩罚程度。 通常将其设置为一个非常低的值（即`0.0001`）； 否则，就有可能完全消除给定神经元的输入。
 
-###### 辍学
+###### 丢弃
 
-辍学是一种基于简单问题的正则化技术：如果一个节点随机地从层中删除一部分节点，那么另一个节点将如何适应？ 事实证明，其余的神经元会适应，学会代表先前由缺失的那些神经元处理过的模式。
+丢弃是一种基于简单问题的正则化技术：如果一个节点随机地从层中删除一部分节点，那么另一个节点将如何适应？ 事实证明，其余的神经元会适应，学会代表先前由缺失的那些神经元处理过的模式。
 
 退出策略易于实现，通常非常有效地避免过拟合。 这将是我们首选的正则化。
 
@@ -674,7 +674,7 @@ L2 正则化使用![L2 Regularization](img/image03_28.jpg)参数来确定对模
 
 > “代码段 11”：在此代码段中，我们将`Dropout()`步骤添加到模型`(bitcoin_lstm_v3)`中，使其设为`bitcoin_lstm_v4`
 
-可以使用 L2 正则化代替 Dropout。 为此，只需实例化`ActivityRegularization()`类，并将`L2`参数设置为较低的值（例如`0.0001,`）。 然后，将其放置在`Dropout()`类添加到网络的位置。 随时进行测试，只需将其添加到网络中，同时保持`Dropout()`的两个步骤，或者直接将所有`Dropout()`实例替换为`ActivityRegularization()`。
+可以使用 L2 正则化代替丢弃。 为此，只需实例化`ActivityRegularization()`类，并将`L2`参数设置为较低的值（例如`0.0001,`）。 然后，将其放置在`Dropout()`类添加到网络的位置。 随时进行测试，只需将其添加到网络中，同时保持`Dropout()`的两个步骤，或者直接将所有`Dropout()`实例替换为`ActivityRegularization()`。
 
 ###### 优化结果
 
@@ -709,7 +709,7 @@ MAPE（整个系列）
 | `bitcoin_lstm_v1` | 7.15*10-6 | 419.3 | 8.8%  | 49.3 秒 |
 | `bitcoin_lstm_v2` | 3.55*10-6 | 425.4 | 9.0%  | 1 分 13 秒 |
 | `bitcoin_lstm_v3` | 2.8*10-4 | 423.9 | 8.8%  | 1 分 19 秒 |
-| `bitcoin_lstm_v4` | 4.8*10-7 | 442.4 | 9.4%  | 1 分钟 20 秒 |
+| `bitcoin_lstm_v4` | 4.8*10-7 | 442.4 | 9.4%  | 1 分 20 秒 |
 
 > 表 2：所有模型的模型结果
 

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

@@ -27,7 +27,7 @@
 
 按照该建议，我们将使用两个类来帮助我们构建 Web 应用程序：`CoinMarketCap()`和`Model()`：
 
-*   `CoinMarketCap()`：此是[用于从以下网站获取比特币价格的类](http://www.coinmarketcap.com)。 这就是我们原始比特币数据来自的地方。 通过此类，可以轻松地定期检索该数据，并返回带有已解析记录和所有可用历史数据的 Pandas DataFrame。 `CoinMarketCap()`是我们的数据组件。
+*   `CoinMarketCap()`：此是[用于从以下网站获取比特币价格的类](http://www.coinmarketcap.com)。 这就是我们原始比特币数据来自的地方。 通过此类，可以轻松地定期检索该数据，并返回带有已解析记录和所有可用历史数据的 Pandas 数据帧。 `CoinMarketCap()`是我们的数据组件。
 *   `Model()`：此类将到目前为止已编写的所有代码实现为一个类。 该类提供了与我们先前训练的模型进行交互的工具，并且还允许使用非规范化数据进行预测，这更容易理解。 `Model()`类是我们的模型组件。
 
 这两个类在我们的示例应用程序中得到了广泛使用，并定义了数据和模型组件。
@@ -50,9 +50,9 @@
     r = requests.get(url)
 ```
 
-> “代码段 1”：`CoinMarketCap()`类中的`historic()`方法。 此方法从 CoinMarketCap 网站收集数据，对其进行解析，然后返回 Pandas DataFrame。
+> “代码段 1”：`CoinMarketCap()`类中的`historic()`方法。 此方法从 CoinMarketCap 网站收集数据，对其进行解析，然后返回 Pandas 数据帧。
 
-`historic()`类返回一个Pandas`DataFrame`，准备由`Model()`类使用。
+`historic()`类返回一个 Pandas `DataFrame`，准备由`Model()`类使用。
 
 当在其他模型中工作时，请考虑创建实现与`CoinMarketCap()`类相同功能的程序组件（例如 Python 类）。 也就是说，创建一个组件，该组件将从可用数据中获取数据，解析该数据，并以可用格式将其提供给您的建模组件。
 
@@ -191,7 +191,7 @@ M.train(model_data[i*7:7*(40 + i) + 7])
     $ historic_data = CoinMarketCap.historic()
     ```
 
-    现在，变量`historic_data`填充有一个 Pandas DataFrame，其中包含截至今天或昨天的数据。 这很棒，可以在有更多数据时更容易地重新训练模型。
+    现在，变量`historic_data`填充有一个 Pandas 数据帧，其中包含截至今天或昨天的数据。 这很棒，可以在有更多数据时更容易地重新训练模型。
 
     数据实际上包含了与我们之前的数据集相同的变量。 但是，许多数据来自较早时期。 与几年前的价格相比，最近的比特币价格已经大幅波动。 在模型中使用此数据之前，请确保将其过滤为 2017 年 1 月 1 日之后的日期。
 
@@ -201,7 +201,7 @@ M.train(model_data[i*7:7*(40 + i) + 7])
     $ model_data = # filter the dataset using pandas here
     ```
 
-    您应该能够通过使用 date 变量作为过滤索引来做到这一点。 在继续之前，请确保已过滤数据。
+    您应该能够通过使用日期变量作为过滤索引来做到这一点。 在继续之前，请确保已过滤数据。
 
     类`Model()`编译到目前为止我们在所有活动中编写的所有代码。 在本活动中，我们将使用该类来构建，训练和评估我们的模型。
 
@@ -272,7 +272,7 @@ M.train(model_data[i*7:7*(40 + i) + 7])
 
 ###### 将模型部署为 Web 应用程序
 
-在此部分中，我们将模型部署为 Web 应用程序。 我们将使用一个名为“ `cryptonic`”的示例 Web 应用程序来部署我们的模型，探索其架构，以便将来进行修改。 目的是让您将此应用程序用作更复杂应用程序的入门程序； 可以正常工作的启动器，可以根据需要扩展。
+在此部分中，我们将模型部署为 Web 应用程序。 我们将使用一个名为`cryptonic`的示例 Web 应用程序来部署我们的模型，探索其架构，以便将来进行修改。 目的是让您将此应用程序用作更复杂应用程序的入门程序； 可以正常工作的启动器，可以根据需要扩展。
 
 除了熟悉 Python 外，本主题还假定您熟悉创建 Web 应用程序。 具体来说，我们假设您对 Web 服务器，路由，HTTP 协议和缓存有所了解。 无需广泛了解这些主题，您就可以在本地部署演示的密码应用程序，但是学习这些主题将使将来的开发变得更加容易。
 
@@ -282,26 +282,13 @@ M.train(model_data[i*7:7*(40 + i) + 7])
 
 为了部署我们的 Web 应用程序，我们将使用“表 1”中描述的工具和技术。 Flask 是关键，因为它有助于我们为模型创建 HTTP 接口，从而使我们能够访问 HTTP 端点（例如`/predict`）并以通用格式接收数据。 之所以使用其他组件，是因为它们是开发 Web 应用程序时的流行选择：
 
-<colgroup class="calibre28"><col class="calibre29"> <col class="calibre29"> <col class="calibre29"></colgroup> 
-| 
-
-工具或技术
-
- | 
-
-描述
-
- | 
-
-角色
-
- |
+| 工具或技术 |  描述 |  角色 |
 | --- | --- | --- |
-| 码头工人 | Docker 是一种用于处理以容器形式打包的应用程序的技术。 Docker 是一种越来越流行的用于构建 Web 应用程序的技术。 | 打包 Python 应用程序和 UI。 |
-| 烧瓶 | Flask 是用于用 Python 构建 Web 应用程序的微框架。 | 创建应用程序路由。 |
+| Docker | Docker 是一种用于处理以容器形式打包的应用程序的技术。 Docker 是一种越来越流行的用于构建 Web 应用程序的技术。 | 打包 Python 应用程序和 UI。 |
+| Flask | Flask 是用于用 Python 构建 Web 应用程序的微框架。 | 创建应用程序路由。 |
 | Vue.js | JavaScript 框架通过根据来自后端的数据输入在前端动态更改模板来工作。 | 呈现用户界面。 |
-| Nginx 的 | 可轻松配置 Web 服务器，以将流量路由到 Dockerized 应用程序并处理 HTTPS 连接的 SSL 证书。 | 在用户和 Flask 应用程序之间路由流量。 |
-| 雷迪斯 | 键值数据库。 由于其简单性和速度，它是实现缓存系统的流行选择。 | 缓存 API 请求。 |
+| Nginx | 可轻松配置 Web 服务器，以将流量路由到 Dockerized 应用程序并处理 HTTPS 连接的 SSL 证书。 | 在用户和 Flask 应用程序之间路由流量。 |
+| Redis | 键值数据库。 由于其简单性和速度，它是实现缓存系统的流行选择。 | 缓存 API 请求。 |
 
 > “表 1”：用于部署深度学习 Web 应用程序的工具和技术
 
@@ -317,7 +304,7 @@ M.train(model_data[i*7:7*(40 + i) + 7])
 
 ###### 部署和使用加密
 
-`cryptonic`是作为 Dockerized 应用程序开发的。 用 Docker 术语来说，意味着可以将应用程序构建为 Docker 映像，然后在开发或生产环境中将其部署为 Docker 容器。
+`cryptonic`是作为 Docker 化应用程序开发的。 用 Docker 术语来说，意味着可以将应用程序构建为 Docker 映像，然后在开发或生产环境中将其部署为 Docker 容器。
 
 Docker 使用名为`Dockerfile`的文件来描述如何构建映像的规则以及将该映像作为容器部署时会发生什么。 以下代码提供了 Cryptonic 的 Dockerfile：
 
@@ -347,7 +334,7 @@ Docker 使用名为`Dockerfile`的文件来描述如何构建映像的规则以
                --detach cryptonic:latest
 ```
 
-> 片段 8：在终端中执行 docker run 命令的示例
+> 片段 8：在终端中执行`docker run`命令的示例
 
 `--publish`标志将`localhost`上的端口`5000`绑定到 Docker 容器上的端口`5000`，并且`--detach`在后台将容器作为守护程序运行。
 
@@ -379,15 +366,15 @@ Docker 使用名为`Dockerfile`的文件来描述如何构建映像的规则以
 
 ```
 
-> “代码段 9”：docker-compose.yml 文件，包括环境变量
+> “代码段 9”：`docker-compose.yml`文件，包括环境变量
 
-部署`cryptonic`的最简单方法是使用 Snippet 9 中的`docker-compose.yml`文件。此文件包含应用程序运行所必需的所有规范，包括有关如何与 Redis 缓存连接以及什么环境的说明 要使用的变量。 导航到`docker-compose.yml`文件的位置后，可以使用命令`docker-compose up`启动`cryptonic`，如以下代码所示：
+部署`cryptonic`的最简单方法是使用代码段 9 中的`docker-compose.yml`文件。此文件包含应用程序运行所必需的所有规范，包括有关如何与 Redis 缓存连接以及什么环境的说明 要使用的变量。 导航到`docker-compose.yml`文件的位置后，可以使用命令`docker-compose up`启动`cryptonic`，如以下代码所示：
 
 ```py
 $ docker-compose up -d
 ```
 
-> “代码段 10”：使用 docker-compose 启动 Docker 应用程序。 标志-d 在后台执行应用程序。
+> “代码段 10”：使用`docker-compose`启动 Docker 应用程序。 标志`-d`在后台执行应用程序。
 
 部署后，可以通过 Web 浏览器在端口`5000`上访问`cryptonic`。 该应用程序具有一个简单的用户界面，该用户界面带有一个时序图，描绘了真实的历史价格（换句话说，观察到的）和来自深度学习模型的预测未来价格（换句话说，预测的）。 您还可以在文本中读取使用`Model().evaluate()`方法计算出的 RMSE 和 MAPE：
 
@@ -414,7 +401,7 @@ $ docker-compose up -d
   }
 ```
 
-> 片段 11：/ predict 端点的示例 JSON 输出
+> 片段 11：`/predict`端点的示例 JSON 输出
 
 现在，应用程序可以部署在远程服务器中，并用于持续预测比特币价格。
 
@@ -423,7 +410,7 @@ $ docker-compose up -d
 在此活动中，我们将模型作为本地 Web 应用程序部署。 这使我们可以使用浏览器连接到 Web 应用程序，或者通过应用程序的 HTTP API 使用另一个应用程序。 在继续之前，请确保您已经安装了以下应用程序，并且在计算机中可用：
 
 *   Docker（社区版）17.12.0-ce 或更高版本
-*   Docker Compose（docker-compose）1.18.0 或更高版本
+*   Docker Compose（`docker-compose`）1.18.0 或更高版本
 
 可以从[以下网站](https://www.docker.com/)下载上述两个组件并将其安装在所有主要系统中。 这些对于完成此活动至关重要。 继续前进之前，请确保这些在系统中可用。
 

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

@@ -109,7 +109,7 @@ ReLu 非线性函数-大于零。
 
 好吧，既然我们已经加载了培训和测试数据，我们将继续学习`Dropout`和`Flatten`，并建立一个实际的神经网络。
 
-# 辍学和扁平化
+# 丢弃和扁平化
 
 在本节中，我们将实际构建神经网络模型，并使用`Dropout`和`Flatten`创建完整的神经网络。
 

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

@@ -503,7 +503,7 @@ X, Y = get_data("/home/sudarshan/sudarshan/Experiments/oneshot-audio/data/")
 X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)
 ```
 
-现在我们已经成功地生成了数据，我们就建立了连体网络。 我们定义了用于特征提取的基本网络，我们使用了三个密集层，中间有一个辍学层：
+现在我们已经成功地生成了数据，我们就建立了连体网络。 我们定义了用于特征提取的基本网络，我们使用了三个密集层，中间有一个丢弃层：
 
 ```py
 def build_base_network(input_shape):

new/intel-proj-py/08.md

@@ -385,7 +385,7 @@ python chatbot.py --max_vocab_size 50000 --max_seq_len 30 --embedding_dim 100 --
 | `hidden_state_dim` | LSTM 的隐藏状态![](img/f61bdf8c-d378-4af5-b4d5-8e1dde87a0bc.png)尺寸 | `100` |
 | `embedding_dim` | 词嵌入的维度 | `100` |
 | `learning rate` | 用于优化程序的起始学习率 | `0.0001` |
-| `dropout` | 辍学用于正则化目的 | `0.3` |
+| `dropout` | 丢弃用于正则化目的 | `0.3` |
 | `Mode` | 训练/推理 | 对于训练，请使用`train`；对于推理，请使用`inference` |
 
 # 对某些输入推文的推断结果

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

@@ -76,7 +76,7 @@
 
 让我们通过使用不同的集成学习模型对钻石价格进行实际预测。 [我们将使用钻石数据集（可在此处找到）](https://www.kaggle.com/shivam2503/diamonds)。 除其他功能外，该数据集的价格接近 54,000 钻石。 以下是此数据集中的功能：
 
-*   **特征信息**：具有 53,940 行和 10 个变量的数据框
+*   **特征信息**：具有 53,940 行和 10 个变量的数据帧
 *   **价格**：美元价格
 
 以下是九种预测功能：
@@ -128,7 +128,7 @@ import pandas as pd
 
 # 训练不同的回归模型
 
-以下屏幕快照显示了我们将用于记录这些模型的指标和性能指标的数据框。 由于这是一项回归任务，因此我们将使用均方误差。 在这里的列中，我们将使用四个模型。 我们将使用`KNN`，`Bagging`，`RandomForest`和`Boosting`变量：
+以下屏幕快照显示了我们将用于记录这些模型的指标和性能指标的数据帧。 由于这是一项回归任务，因此我们将使用均方误差。 在这里的列中，我们将使用四个模型。 我们将使用`KNN`，`Bagging`，`RandomForest`和`Boosting`变量：
 
 ![](img/7372d44f-c895-45b9-8bce-e90ee96cd9a7.png)
 
@@ -243,7 +243,7 @@ def CMatrix(CM, labels=['pay', 'default']):
 
 # 训练不同的回归模型
 
-下面的屏幕快照显示了一个我们要保存性能的数据框。 我们将运行四个模型，即逻辑回归，装袋，随机森林和增强：
+下面的屏幕快照显示了一个我们要保存性能的数据帧。 我们将运行四个模型，即逻辑回归，装袋，随机森林和增强：
 
 ![](img/c745a454-b945-46c8-9d98-ab5ee3142f24.png)
 
@@ -261,11 +261,11 @@ def CMatrix(CM, labels=['pay', 'default']):
 
 ![](img/6d069752-6b15-482d-9354-c6589c2ca984.png)
 
-稍后，我们将把它们保存到我们刚刚创建的`pandas`数据框中。
+稍后，我们将把它们保存到我们刚刚创建的`pandas`数据帧中。
 
 # 套袋模型
 
-使用集成学习技术中的方法训练装袋模型涉及使用 Logistic 回归方法导入装袋分类器。 为此，我们将拟合其中的 10 个逻辑回归模型，然后使用装袋将 10 个单独的预测合并为一个预测。 之后，我们将其保存到指标数据框中。
+使用集成学习技术中的方法训练装袋模型涉及使用 Logistic 回归方法导入装袋分类器。 为此，我们将拟合其中的 10 个逻辑回归模型，然后使用装袋将 10 个单独的预测合并为一个预测。 之后，我们将其保存到指标数据帧中。
 
 以下屏幕截图显示了代码和混淆矩阵作为输出：
 

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

@@ -120,7 +120,7 @@ from sklearn.model_selection import cross_validate
 
 *   我们提供了一组我们要评估的模型和数据集指标。 在这种情况下，使用`mean_squared_error`函数和`r2`指标进行评估，如前面的代码所示。 在这里，我们在`cv`中传递`k`的值。 因此，在这种情况下，我们将进行十倍交叉验证。
 
-我们从此`cross_validate`函数获得的输出将是带有相应矩阵的字典。 为了更好地理解，将输出转换为数据帧。 以下屏幕快照显示了用于可视化数据框和数据框输出中的分数的代码：
+我们从此`cross_validate`函数获得的输出将是带有相应矩阵的字典。 为了更好地理解，将输出转换为数据帧。 以下屏幕快照显示了用于可视化数据帧和数据帧输出中的分数的代码：
 
 ![](img/9856da4f-8d3d-476e-a72e-661065f019ad.png)
 

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

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

new/whats-new-tf2/4.md

@@ -163,7 +163,7 @@ self.num_filters = 32
         self.mp_layer = tf.keras.layers.MaxPooling2D(pool_size=self.pool_size)
 ```
 
-并添加一个辍学：
+并添加一个丢弃：
 
 ```py
         self.do_layer = tf.keras.layers.Dropout(0.5)
@@ -507,7 +507,7 @@ TensorBoard 的图形仪表板提供可视化和检查 TensorFlow 模型的功
 
 # 超参数调优
 
-建立良好的深度学习模型最重要的部分之一就是选择最佳超参数来训练模型本身。 超参数是工程师在模型训练之前设置的参数。 一些常见的超参数包括辍学率，学习率和所用优化器的类型。 超参数的优化是一个耗时的过程，其中涉及对具有不同超参数的模型进行多次训练以找到最佳模型，因为目前尚无关于如何选择超参数的见解。
+建立良好的深度学习模型最重要的部分之一就是选择最佳超参数来训练模型本身。 超参数是工程师在模型训练之前设置的参数。 一些常见的超参数包括丢弃率，学习率和所用优化器的类型。 超参数的优化是一个耗时的过程，其中涉及对具有不同超参数的模型进行多次训练以找到最佳模型，因为目前尚无关于如何选择超参数的见解。
 
 这样，TF 2.0 提供了一种智能执行超参数调优的工具，它可以协助确定执行最佳实验和尝试最有前途的超参数的过程。
 

new/whats-new-tf2/7.md

@@ -269,7 +269,7 @@ class CustomLayer(tf.keras.layers.Layer):
 前面的代码创建了一个名为`CustomLayer`的类，该类继承了`tf.keras.layers.Layer`类的属性。 此技术允许在`tf.keras`模型内部使用任何类型的低级代码，而不管它是使用`Sequential` API 还是`functional` API 的模型。 此类中有两种方法：
 
 *   `build()`：此方法修改继承的类的默认生成方法。 在这种方法中，应该创建模型所需的所有变量。 尽管可以在模型的`the __init__()`方法中完成此操作，但建议使用`build()`，以便在正确的最佳时间构建变量。 可以使用`self.add_weight`函数完成此操作，以使 Keras 跟踪变量和正则化损失。
-*   `call()`：在输入张量上调用模型时，将运行此方法。 此方法通常采用两个参数：`inputs`和`training`。 尽管`inputs`参数是不言自明的，但`training`参数可能不会一直使用，但是对于在该层中使用批量规范化和辍学的情况而言是必不可少的。 该功能由`tf.function`装饰器批注，以实现签名，基于图的优点以及自动控件的依赖关系。
+*   `call()`：在输入张量上调用模型时，将运行此方法。 此方法通常采用两个参数：`inputs`和`training`。 尽管`inputs`参数是不言自明的，但`training`参数可能不会一直使用，但是对于在该层中使用批量规范化和丢弃的情况而言是必不可少的。 该功能由`tf.function`装饰器批注，以实现签名，基于图的优点以及自动控件的依赖关系。
 
 写入此自定义层后，即可在`tf.keras`模块中的任何位置使用它。 对于此转换，将使用`Sequential` API：