2020-12-22 14:23:55

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

@@ -119,7 +119,7 @@
 
 ### 注意
 
-[他们的模型识别出囚犯的准确率高达 89.5％](https://blog.keras.io/the-limitations-of-deep-learning.html)。
+[他们的模型识别出囚犯的准确率高达 89.5% ](https://blog.keras.io/the-limitations-of-deep-learning.html)。
 
 麻省理工学院技术评论，[《神经网络学习通过面孔识别犯罪分子》](https://blog.keras.io/the-limitations-of-deep-learning.html)。
 
@@ -403,7 +403,7 @@ CIFAR 数据集是机器学习数据集，其中包含按不同类别组织的
 
 利用这一刻来说明神经网络在训练过程中尽早达到高准确度的能力。
 
-我们可以看到，在大约 200 个纪元（或步骤）内，网络的准确性超过了 90％。 也就是说，网络正确获取了测试集中 90％的数字。 在训练到第 2000 步时，网络继续获得准确性，在此期间结束时达到 97％的准确性。
+我们可以看到，在大约 200 个纪元（或步骤）内，网络的准确性超过了 90%。 也就是说，网络正确获取了测试集中 90% 的数字。 在训练到第 2000 步时，网络继续获得准确性，在此期间结束时达到 97% 的准确性。
 
 现在，让我们也测试那些网络在看不见的数据下的性能。 我们将使用 Shafeen Tejani 创建的开源 Web 应用程序来探索受过训练的网络是否正确地预测了我们创建的手写数字。
 
@@ -461,9 +461,9 @@ $ tensorboard --logdir=mnist_example/
 
 准确性图衡量网络能够猜测测试集标签的准确性。 最初，网络猜测这些标签完全错误。 发生这种情况是因为我们已使用随机值初始化了网络的权重和偏差，因此其首次尝试只是一个猜测。 然后，网络将在第二次运行中更改其层的权重和偏差； 网络将继续通过改变其权重和偏见来投资于那些能带来积极成果的节点，并通过逐渐减少其对网络的影响（最终达到`0`）来惩罚那些没有结果的节点。 如您所见，这是一种非常有效的技术，可以快速产生出色的结果。
 
-让我们将注意力集中在**精度**图表上。 看看在大约 1,000 个纪元后，该算法如何达到很高的准确性（> 95％）？ 在 1,000 到 2,000 个时代之间会发生什么？ 如果我们继续训练更多的时期，它将变得更加准确吗？
+让我们将注意力集中在**精度**图表上。 看看在大约 1,000 个纪元后，该算法如何达到很高的准确性（> 95% ）？ 在 1,000 到 2,000 个时代之间会发生什么？ 如果我们继续训练更多的时期，它将变得更加准确吗？
 
-当网络的精度继续提高时，在 1,000 到 2,000 之间，但是的速率下降。 如果训练更多的时间段，网络可能会略有改善，但是在当前架构下，其精度不会达到 100％。
+当网络的精度继续提高时，在 1,000 到 2,000 之间，但是的速率下降。 如果训练更多的时间段，网络可能会略有改善，但是在当前架构下，其精度不会达到 100%。
 
 该脚本是 Google 官方脚本的修改版，旨在显示 TensorFlow 的工作方式。 我们将脚本分为易于理解的功能，并添加了许多注释来指导您的学习。 尝试通过修改脚本顶部的变量来运行该脚本：
 

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

@@ -295,9 +295,9 @@ lambda x: normalizations.point_relative_normalization(x))
 
 图 13：显示归一化变量 close_point_relative_normalization 的序列的图
 
-为了评估模型的效果，我们需要对照其他数据测试其准确性。 为此，我们创建了两个数据集：训练集和测试集。 在本活动中，我们将使用 80％的数据集训练 LSTM 模型，并使用 20％的数据评估其性能。
+为了评估模型的效果，我们需要对照其他数据测试其准确性。 为此，我们创建了两个数据集：训练集和测试集。 在本活动中，我们将使用 80% 的数据集训练 LSTM 模型，并使用 20% 的数据评估其性能。
 
-鉴于数据是连续的并且采用时间序列的形式，我们将可用周的最后 20％用作测试集，并将前 80％用作训练集：
+鉴于数据是连续的并且采用时间序列的形式，我们将可用周的最后 20% 用作测试集，并将前 80% 用作训练集：
 
 ![Activity 3 – Exploring the Bitcoin Dataset and Preparing Data for Model](img/image02_26.jpg)
 
@@ -586,7 +586,7 @@ LSTM 是计算上昂贵的模型。 在现代计算机上，我们最多可能
 
 ![Overfitting](img/image02_31.jpg)
 
-图 20：归一化后，我们的 LSTM 模型预测，到 2017 年 7 月下旬，比特币的价格将从 2200 美元增加到大约 2800 美元，一周内增长 30％
+图 20：归一化后，我们的 LSTM 模型预测，到 2017 年 7 月下旬，比特币的价格将从 2200 美元增加到大约 2800 美元，一周内增长 30% 
 
 ## 活动 5 –组装深度学习系统
 
@@ -677,7 +677,7 @@ LSTM 是计算上昂贵的模型。 在现代计算机上，我们最多可能
 
     ![Activity 5 – Assembling a Deep Learning System](img/image02_34.jpg)
 
-    图 23：Jupyter Notebook 部分，我们在其中预测了未来 7 天的比特币价格。 我们的预测表明价格将大幅上涨约 30％。
+    图 23：Jupyter Notebook 部分，我们在其中预测了未来 7 天的比特币价格。 我们的预测表明价格将大幅上涨约 30%。
 
     ![Activity 5 – Assembling a Deep Learning System](img/image02_35.jpg)
 

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

@@ -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 Machine Learning，*（Packt，2017 年）。
 
 在分类问题中，您会将数据和标签都作为相关但又不同的数据传递给神经网络。 然后，网络将了解数据与每个标签的关系。 在回归问题中，不是传递数据和标签，而是传递感兴趣的变量作为一个参数，传递用于学习模式的变量作为另一个参数。 Keras 通过`fit()`方法为这两种用例提供​​了接口。 有关示例，请参见“代码段 2”：
 
@@ -178,7 +178,7 @@ Keras 提供了`model.evaluate(),`方法，该方法使针对测试集评估训
 
 ## 评估比特币模型
 
-我们在“第 1 课”，“神经网络和深度学习简介”的活动期间创建了一个测试集。 该测试集具有 19 周的比特币每日价格观察，大约相当于原始数据集的 20％。
+我们在“第 1 课”，“神经网络和深度学习简介”的活动期间创建了一个测试集。 该测试集具有 19 周的比特币每日价格观察，大约相当于原始数据集的 20%。
 
 我们还在“第 2 课”，“模型结构”并将经过训练的网络存储在磁盘上（`bitcoin_lstm_v0).` 我们现在可以在测试集中的 19 周数据中的每一个中使用`evaluate()`方法，并检查第一个神经网络的性能。
 
@@ -301,7 +301,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 *   非规范化的 **RMSE**: 399.6 美元
 *   非规范化的 **MAPE**：8.4%
 
-这表明我们的预测与实际数据的平均差异约为 399 美元。 这意味着与实际比特币价格相差约 8.4％。
+这表明我们的预测与实际数据的平均差异约为 399 美元。 这意味着与实际比特币价格相差约 8.4%。
 
 这些结果有助于理解我们的预测。 我们将继续使用`model.evaluate()`方法来跟踪我们的 LSTM 模型的改进情况，但还将在模型的每个版本的完整系列中计算`rmse()`和`mape()`来解释其接近程度 我们将预测比特币价格。
 
@@ -412,7 +412,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
     每个功能都是使用 NumPy 的矢量方式操作实现的。 它们在相同长度的向量中效果很好。 它们旨在应用于完整的结果集。
 
-    使用`mape()`函数，我们现在可以了解到，我们的模型预测与测试集的价格相比，大约相差 8.4％。 这等效于约 399.6 美元的均方根误差（使用`rmse()`函数计算）。
+    使用`mape()`函数，我们现在可以了解到，我们的模型预测与测试集的价格相比，大约相差 8.4%。 这等效于约 399.6 美元的均方根误差（使用`rmse()`函数计算）。
 
     在继续下一部分之前，请回到笔记本电脑中，找到标题为 TensorBoard 的重新训练模型。 您可能已经注意到我们创建了一个名为`train_model()`的辅助函数。 该函数是模型的包装器，用于训练（使用`model.fit()`）模型，并将其各自的结果存储在新目录中。 然后，这些结果由 TensorBoard 用作判别器，以显示不同模型的统计信息。
 
@@ -438,7 +438,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
 ### 超参数优化
 
-我们已经训练了一个神经网络，以使用之前的 76 周价格来预测比特币价格的未来 7 天。 平均而言，该模型发出的预测与实际比特币价格相距约 8.4％。
+我们已经训练了一个神经网络，以使用之前的 76 周价格来预测比特币价格的未来 7 天。 平均而言，该模型发出的预测与实际比特币价格相距约 8.4%。
 
 本节描述了改善神经网络模型性能的常用策略：
 
@@ -451,7 +451,7 @@ return np.mean(np.abs((A - B) / A)) * 100
 
 #### 层和节点-添加更多层
 
-具有单个隐藏层的神经网络在许多问题上的表现都相当不错。 我们的第一个比特币模型（`bitcoin_lstm_v0`）是一个很好的例子：它可以使用单个 LSTM 层预测（根据测试集）未来七天的比特币价格（错误率约为 8.4％）。 但是，并非所有问题都可以用单层建模。
+具有单个隐藏层的神经网络在许多问题上的表现都相当不错。 我们的第一个比特币模型（`bitcoin_lstm_v0`）是一个很好的例子：它可以使用单个 LSTM 层预测（根据测试集）未来七天的比特币价格（错误率约为 8.4% ）。 但是，并非所有问题都可以用单层建模。
 
 您正在预测的功能越复杂，则需要添加更多图层的可能性就越高。 确定是否添加新层是一个好主意，这是了解它们在神经网络中的作用。
 
@@ -705,11 +705,11 @@ MAPE（整个系列）
 
  |
 | --- | --- | --- | --- | --- |
-| `bitcoin_lstm_v0` | - | 399.6 | 8.4％ | - |
-| `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_v0` | - | 399.6 | 8.4%  | - |
+| `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 秒 |
 
 > 表 2：所有模型的模型结果
 
@@ -717,7 +717,7 @@ MAPE（整个系列）
 
 ###### 活动 7 –优化深度学习模型
 
-在此活动中，我们对在“第 2 课”，“模型体系结构”（`bitcoin_lstm_v0`）中创建的模型实施不同的优化策略。 该模型在完整的反规范化测试集上获得了大约 8.4％的 MAPE 性能。 我们将努力缩小这一差距。
+在此活动中，我们对在“第 2 课”，“模型体系结构”（`bitcoin_lstm_v0`）中创建的模型实施不同的优化策略。 该模型在完整的反规范化测试集上获得了大约 8.4% 的 MAPE 性能。 我们将努力缩小这一差距。
 
 1.  在您的终端上，通过执行以下命令来启动 TensorBoard 实例：
 

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

@@ -127,7 +127,7 @@ Keras 功能模型
 
 模型摘要输出
 
-因此，您可以从中看到，首先将参数传递给图层，然后将图层本身传递以形成链。 那么，这些`Dropout`和`Flatten`层又如何呢？ `Dropout`参数本质上是一个技巧。 当我们设置`Dropout`参数（这里是`0.1`）时，我们告诉神经网络要做的是在每个训练周期中随机断开 10％的激活。 这是使神经网络学习概括。 这是真正的学习，而不是简单地记住输入数据。 `Flatten`层处理尺寸。 因为我们有一个二维的 28x28 像素输入图像，所以我们使用`Flatten`将其转换为`784`的长的一维数字字符串。 这被馈送到输出`softmax`层。
+因此，您可以从中看到，首先将参数传递给图层，然后将图层本身传递以形成链。 那么，这些`Dropout`和`Flatten`层又如何呢？ `Dropout`参数本质上是一个技巧。 当我们设置`Dropout`参数（这里是`0.1`）时，我们告诉神经网络要做的是在每个训练周期中随机断开 10% 的激活。 这是使神经网络学习概括。 这是真正的学习，而不是简单地记住输入数据。 `Flatten`层处理尺寸。 因为我们有一个二维的 28x28 像素输入图像，所以我们使用`Flatten`将其转换为`784`的长的一维数字字符串。 这被馈送到输出`softmax`层。
 
 打印出模型摘要是弄清参数大小和尺寸的好方法。 这最终成为使用 Keras 的棘手部分之一，例如当您有一组输入样本（在我们的示例中为 28x28 图像），并且您需要到那时将它们转换成包含十个可能输出值的单个数组 您进入`softmax`。 您可以看到形状在我们穿过每一层时如何变化。 最后，`Flatten`将每个样本的维数降低为一个维，然后将其转换为具有十个可能的输出值的维。
 
@@ -203,7 +203,7 @@ Keras 功能模型
 
 输出—最终得分
 
-您可以看到我们的分数不错：整体准确率为 96％。
+您可以看到我们的分数不错：整体准确率为 96%。
 
 # 概要
 

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

@@ -237,7 +237,7 @@ Y.shape
 (20000, 1)
 ```
 
-接下来，我们将训练和测试的数据划分为 75％的训练和 25％的测试比例：
+接下来，我们将训练和测试的数据划分为 75% 的训练和 25% 的测试比例：
 
 ```py
 x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=.25)
@@ -497,7 +497,7 @@ def get_data():
 X, Y = get_data("/home/sudarshan/sudarshan/Experiments/oneshot-audio/data/")
 ```
 
-接下来，我们将训练和测试的数据划分为 75％的训练和 25％的测试比例：
+接下来，我们将训练和测试的数据划分为 75% 的训练和 25% 的测试比例：
 
 ```py
 X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)

new/intel-proj-py/02.md

@@ -146,7 +146,7 @@ Softmax 将是表示输出层中不同类别的概率的最佳激活函数，而
 
 图 2.4：五个严重等级的等级密度
 
-从上图可以看出，将近 73％的训练数据属于 **0 级**，这代表没有糖尿病性视网膜病。 因此，如果我们碰巧将所有数据点标记为 **Class 0** ，那么我们将具有 73％的准确率。 在患者健康状况下这是不希望的。 我们宁愿有一个测试说患者没有时有某种健康状况（假阳性），而有一项测试却漏诊时没有发现某种健康状况（假阴性）。 如果模型学会将所有点分类为属于 **0 类**，则 73％的准确性可能毫无意义。
+从上图可以看出，将近 73% 的训练数据属于 **0 级**，这代表没有糖尿病性视网膜病。 因此，如果我们碰巧将所有数据点标记为 **Class 0** ，那么我们将具有 73% 的准确率。 在患者健康状况下这是不希望的。 我们宁愿有一个测试说患者没有时有某种健康状况（假阳性），而有一项测试却漏诊时没有发现某种健康状况（假阴性）。 如果模型学会将所有点分类为属于 **0 类**，则 73% 的准确性可能毫无意义。
 
 在*无严重等级*上，检测较高的严重等级比做好工作更为重要。 使用对数损失或交叉熵成本函数的分类模型的问题在于它偏爱多数类。 这是因为交叉熵误差是从最大似然原理中得出的，该似然原理倾向于将较高的概率分配给多数类别。 我们可以做两件事：
 
@@ -267,7 +267,7 @@ datagen = ImageDataGenerator(
                              rotation_range = 20)
 ```
 
-从定义的生成器中可以看到，我们启用了水平和垂直翻转，这仅是图像沿水平和垂直轴的反射。 同样，我们将沿宽度和高度的图像平移定义为沿这些方向的像素位置的 10％以内。 旋转范围限制为`20`度的角度，而比例因子定义为原始图像的`0.8`至`1.2`之内。
+从定义的生成器中可以看到，我们启用了水平和垂直翻转，这仅是图像沿水平和垂直轴的反射。 同样，我们将沿宽度和高度的图像平移定义为沿这些方向的像素位置的 10% 以内。 旋转范围限制为`20`度的角度，而比例因子定义为原始图像的`0.8`至`1.2`之内。
 
 # 网络架构
 
@@ -287,7 +287,7 @@ InceptionV3 论文链接如下：
 
 简而言之，`VGG16`是一个 16 层的 CNN，使用 3 x 3 滤波器和 2 x 2 接收场进行卷积。 整个网络使用的激活功能都是 ReLU。 由 Simonyan 和 Zisserman 开发的 VGG 架构是 2014 年 ILSVRC 竞赛的亚军。 `VGG16`网络由于其简单性而广受欢迎，它是从图像中提取特征的最受欢迎的网络。
 
-`ResNet50`是一种深层的 CNN，它实现了残余块的概念，与`VGG16`网络的概念完全不同。 经过一系列的卷积激活池操作之后，该块的输入再次被反馈到输出。 ResNet 体系结构是由 Kaiming He 等人开发的，尽管具有 152 层，但它不如 VGG 网络复杂。 该架构通过实现 3.57％的前五位错误率赢得了 2015 年 ILSVRC 竞赛，这比该竞赛数据集上的人类水平性能要好。 通过检查目标是否在概率最高的五类预测中来计算前五个错误率。 原则上，ResNet 网络尝试学习残差映射，而不是直接从输出映射到输入，如下面的残差框图所示：
+`ResNet50`是一种深层的 CNN，它实现了残余块的概念，与`VGG16`网络的概念完全不同。 经过一系列的卷积激活池操作之后，该块的输入再次被反馈到输出。 ResNet 体系结构是由 Kaiming He 等人开发的，尽管具有 152 层，但它不如 VGG 网络复杂。 该架构通过实现 3.57% 的前五位错误率赢得了 2015 年 ILSVRC 竞赛，这比该竞赛数据集上的人类水平性能要好。 通过检查目标是否在概率最高的五类预测中来计算前五个错误率。 原则上，ResNet 网络尝试学习残差映射，而不是直接从输出映射到输入，如下面的残差框图所示：
 
 ![](img/6e52be2c-3618-4411-8f03-b372b21e42c7.png)
 
@@ -299,7 +299,7 @@ InceptionV3 论文链接如下：
 
 图 2.9：InceptionV3 卷积模块
 
-Inception V1（GoogleNet）是 2014 年 ILSVRC 竞赛的获胜者。 它的最高 5％错误率非常接近人类水平的性能，为 6.67％。
+Inception V1（GoogleNet）是 2014 年 ILSVRC 竞赛的获胜者。 它的最高 5% 错误率非常接近人类水平的性能，为 6.67%。
 
 # VGG16 迁移学习网络
 
@@ -1213,7 +1213,7 @@ Processing Time 138.52878069877625 secs
 
 ```
 
-从前面的日志中可以看到，假设我们刚刚使用回归得分将模型映射到最接近的严重性条件，该模型可实现约 66％的不错的验证准确性和`0.466`的二次 Kappa 得分。 建议读者进行实验，看看是否基于预测的二级模型对进行评分，并且眼睛是左眼还是右眼比将朴素的评分映射到最近的严重性等级给出了更好的结果。
+从前面的日志中可以看到，假设我们刚刚使用回归得分将模型映射到最接近的严重性条件，该模型可实现约 66% 的不错的验证准确性和`0.466`的二次 Kappa 得分。 建议读者进行实验，看看是否基于预测的二级模型对进行评分，并且眼睛是左眼还是右眼比将朴素的评分映射到最近的严重性等级给出了更好的结果。
 
 # 概要
 

new/intel-proj-py/03.md

@@ -518,7 +518,7 @@ NMT 与其他传统方法相比的一些优点如下：
 
 ```
 
-我们在 80％的数据上训练模型，并将其余 20％的数据用于验证。 训练/测试拆分由以下定义的功能执行：
+我们在 80% 的数据上训练模型，并将其余 20% 的数据用于验证。 训练/测试拆分由以下定义的功能执行：
 
 ```py
 def train_test_split(self,num_recs,train_frac=0.8):

new/intel-proj-py/05.md

@@ -257,7 +257,7 @@ def get_clean_caption_data(self,text_path,feat_path):
         return data_train,data_test
 ```
 
-通常保留 20％的数据用于评估是一种公平的做法。
+通常保留 20% 的数据用于评估是一种公平的做法。
 
 # 建立模型
 

new/intel-proj-py/06.md

@@ -40,37 +40,37 @@
 
 # 基于潜在分解的推荐系统
 
-基于潜在因子分解的过滤器推荐方法尝试通过分解等级来发现潜在特征，以表示用户和项目资料。 与基于内容的过滤功能不同，这些潜在功能不可解释，可以表示复杂的功能。 例如，在电影推荐系统中，潜在特征之一可能以特定比例表示幽默，悬念和浪漫的线性组合。 通常，对于已经评分的商品，用户`i`对商品`j`的评分 *r <sub>ij</sub>* 可以表示为![](img/08ca7c40-3d15-4f76-9361-0ecf5097bba3.png)。 其中 *u <sub> i </sub>* 是基于潜在因子的用户配置文件矢量，而 *v <sub> i </sub>* 是基于相同潜在因子的项目矢量 ：
+基于潜在因子分解的过滤器推荐方法尝试通过分解等级来发现潜在特征，以表示用户和项目资料。 与基于内容的过滤功能不同，这些潜在功能不可解释，可以表示复杂的功能。 例如，在电影推荐系统中，潜在特征之一可能以特定比例表示幽默，悬念和浪漫的线性组合。 通常，对于已经评分的商品，用户`i`对商品`j`的评分`r[ij]`可以表示为![](img/08ca7c40-3d15-4f76-9361-0ecf5097bba3.png)。 其中`u[i]`是基于潜在因子的用户配置文件矢量，而`v[i]`是基于相同潜在因子的项目矢量 ：
 
 ![](img/719736b5-d23e-49ca-b6b2-bfcda9d9657a.png)
 
 图 6.3：基于潜在因子的过滤图
 
-上图（“图 6.3”）中说明了一种基于潜在因子的推荐方法，其中评级矩阵 *R <sub>mxn</sub>* 已分解为用户产品 配置文件矩阵 *U <sub>mxk</sub>* 和项目配置文件矩阵 *P <sub>nxk</sub>* 的转置，其中`k`是 模型的潜在因素。 基于这些配置文件，我们可以通过计算用户配置文件和项目配置文件的内部产品来推荐用户迄今为止尚未购买的项目。 内部产品给出了用户购买该产品时可能给出的暂定等级。
+上图（“图 6.3”）中说明了一种基于潜在因子的推荐方法，其中评级矩阵`R[mxn]`已分解为用户产品 配置文件矩阵`U[mxk]`和项目配置文件矩阵`P[nxk]`的转置，其中`k`是 模型的潜在因素。 基于这些配置文件，我们可以通过计算用户配置文件和项目配置文件的内部产品来推荐用户迄今为止尚未购买的项目。 内部产品给出了用户购买该产品时可能给出的暂定等级。
 
 创建这些用户和商品资料的一种方法是，在以某种形式的平均值填充缺失值之后，对评分矩阵执行**奇异值分解**（**SVD**） 用户和项目（视情况而定）。 根据 SVD，评级矩阵`R`可以分解如下：
 
 ![](img/7eb81448-228b-4859-a03a-7e499d84b422.png)
 
-我们可以将用户个人资料矩阵作为 *US <sup>1/2</sup>* ，然后将项目个人资料矩阵转置为 *S <sup>1/2</sup> V <sup>T</sup>* 形成潜在因子模型。 当在分级矩阵中缺少与用户未分级的电影相对应的条目时，您可能会遇到有关如何执行 SVD 的问题。 常见的方法是在执行 SVD 之前，通过用户的平均评分或总体评分的平均值来估算缺失的评分。
+我们可以将用户个人资料矩阵作为`US^(1/2)`，然后将项目个人资料矩阵转置为 `S^(1/2) V^T`形成潜在因子模型。 当在分级矩阵中缺少与用户未分级的电影相对应的条目时，您可能会遇到有关如何执行 SVD 的问题。 常见的方法是在执行 SVD 之前，通过用户的平均评分或总体评分的平均值来估算缺失的评分。
 
 # 深度学习以进行潜在因素协作过滤
 
 除了使用 SVD，您还可以利用深度学习方法来导出给定尺寸的用户和商品资料向量。
 
-对于每个用户 *i，*，您可以通过嵌入层定义用户矢量 *u <sub>i</sub> ∈R <sup>k</sup>* 。 同样，对于每个项目 *j，*，您可以通过另一个嵌入层定义项目向量 *v <sub>j</sub> ∈R <sup>k</sup>* 。 然后，用户`i`对项目`j`的等级 *r <sub>ij</sub>* 可以表示为 *u 的点积。 <sub>i</sub>* 和 *v <sub>j</sub>* ，如下所示：
+对于每个用户`i`，您可以通过嵌入层定义用户矢量`u[i] ∈ R^k`。 同样，对于每个项目`j`，您可以通过另一个嵌入层定义项目向量`v[j] ∈ R^k`。 然后，用户`i`对项目`j`的等级`r[ij]`可以表示为`u[i], v[j]`的点积，如下所示：
 
 ![](img/1c084aa4-07bd-45cb-bdc1-cbd02d52565c.png)
 
-您可以修改神经网络以为用户和项目添加偏见。 假设我们想要`k`潜在分量，则`m`用户的嵌入矩阵`U`的尺寸将是`m`x`k`。 类似地，`n`项的嵌入矩阵`V`的尺寸将为`n`x`k`。
+您可以修改神经网络以为用户和项目添加偏见。 假设我们想要`k`潜在分量，则`m`用户的嵌入矩阵`U`的尺寸将是`mxk`。 类似地，`n`项的嵌入矩阵`V`的尺寸将为`nxk`。
 
-在*基于深度学习的潜在因子模型*部分中，我们将使用这种嵌入方法基于`100K Movie Lens`数据集创建推荐系统。 数据集可以从`https://grouplens.org/datasets/movielens/`下载。
+在“基于深度学习的潜在因子模型”部分中，我们将使用这种嵌入方法基于`100K Movie Lens`数据集创建推荐系统。 数据集可以从`https://grouplens.org/datasets/movielens/`下载。
 
 我们将使用`u1.base`作为训练数据集，并使用`u1.test`作为保持测试数据集。
 
 # 基于深度学习的潜在因素模型
 
-*潜在合作过滤的深度学习*部分中讨论的基于深度学习的潜在因素模型可以如图 HTG2 图 6.4 所示进行设计：
+“潜在协同过滤的深度学习”部分中讨论的基于深度学习的潜在因素模型可以如图 HTG2 图 6.4 所示进行设计：
 
 ![](img/f686394a-db58-4ac8-937b-d66b473a96b7.png)
 
@@ -409,7 +409,7 @@ RBM 的参数是可见层单位`i`与隐藏层单位之间的广义权重连接
 
 # 处理输入
 
-每行中的输入评级文件记录包含字段`userId`，`movieId`，`rating`和`timestamp`。 我们处理每条记录以创建`numpy`数组形式的训练文件，其中三个维度分别与`userId`，`movieId`和`rating`有关。 从 1 到 5 的评级是一热编码的，因此沿评级维度的长度为 5。 我们使用 80％的输入记录创建培训数据，而其余 20％保留用于测试。 用户已评分的电影数量为`1682`。 培训文件包含`943`用户，因此培训数据的维度为`(943,1682,5)`。 培训文件中的每个用户都是 RBM 的培训记录，其中将包含用户已评分的几部电影和用户尚未评分的几部电影。 一些电影分级也已删除，将包含在测试文件中。 将对 RBM 进行可用分级的培训，在隐藏单元中捕获输入数据的隐藏结构，然后尝试从捕获的隐藏结构中为每个用户重建所有电影的输入分级。 我们还创建了两个字典，以将实际电影 ID 的交叉引用及其索引存储在训练/测试数据集中。 以下是用于创建培训和测试文件的详细代码：
+每行中的输入评级文件记录包含字段`userId`，`movieId`，`rating`和`timestamp`。 我们处理每条记录以创建`numpy`数组形式的训练文件，其中三个维度分别与`userId`，`movieId`和`rating`有关。 从 1 到 5 的评级是一热编码的，因此沿评级维度的长度为 5。 我们使用 80% 的输入记录创建培训数据，而其余 20% 保留用于测试。 用户已评分的电影数量为`1682`。 培训文件包含`943`用户，因此培训数据的维度为`(943,1682,5)`。 培训文件中的每个用户都是 RBM 的培训记录，其中将包含用户已评分的几部电影和用户尚未评分的几部电影。 一些电影分级也已删除，将包含在测试文件中。 将对 RBM 进行可用分级的培训，在隐藏单元中捕获输入数据的隐藏结构，然后尝试从捕获的隐藏结构中为每个用户重建所有电影的输入分级。 我们还创建了两个字典，以将实际电影 ID 的交叉引用及其索引存储在训练/测试数据集中。 以下是用于创建培训和测试文件的详细代码：
 
 ```py
 """
@@ -463,7 +463,7 @@ if __name__ == '__main__':
 
 ```
 
-训练文件是尺寸为 *mxnxk* 的`numpy`数组对象，其中`m`是用户总数，`n`是电影总数，并且`k`是离散额定值的数量（一到五个）。 要构建测试集，我们从训练数据集中随机选择 20％的 *m x n* 评分条目。 因此，测试集评级样本的所有`k`评级值在训练数据集中均标记为零。 在测试集中，我们不会将数据扩展为三维 numpy 数组格式，因此可以将其用于训练。 相反，我们只将`userid`，`movieid`和分配的等级保存在三列中。 请注意，存储在火车中的`userid`和`movieid`和测试文件不是原始评级数据文件`u.data`中的实际 ID。 它们被`1`偏移以适应从`0`而非`1`开始的 Python 和`numpy`索引
+训练文件是尺寸为`mxnxk`的`numpy`数组对象，其中`m`是用户总数，`n`是电影总数，并且`k`是离散额定值的数量（一到五个）。 要构建测试集，我们从训练数据集中随机选择 20% 的`m x n`评分条目。 因此，测试集评级样本的所有`k`评级值在训练数据集中均标记为零。 在测试集中，我们不会将数据扩展为三维 numpy 数组格式，因此可以将其用于训练。 相反，我们只将`userid`，`movieid`和分配的等级保存在三列中。 请注意，存储在火车中的`userid`和`movieid`和测试文件不是原始评级数据文件`u.data`中的实际 ID。 它们被`1`偏移以适应从`0`而非`1`开始的 Python 和`numpy`索引
 
 以下命令可用于调用数据预处理脚本：
 

new/intel-proj-py/10.md

@@ -289,7 +289,7 @@ python captcha_solver.py train --dest_train '/home/santanu/Downloads/Captcha Gen
 
 ```
 
-在仅`20`个训练时期内，该模型就可以使 CAPTCHA 的每个字符级别的验证准确性达到 98.3％，如以下输出日志所示：
+在仅`20`个训练时期内，该模型就可以使 CAPTCHA 的每个字符级别的验证准确性达到 98.3%，如以下输出日志所示：
 
 ```py
 Epoch 17/20
@@ -366,7 +366,7 @@ def evaluate(model_path,eval_dest,outdir,fetch_target=True):
 python captcha_solver.py evaluate  --model_path  /home/santanu/ML_DS_Catalog-/captcha/model/captcha_breaker.h5 --eval_dest '/home/santanu/Downloads/Captcha Generation/captcha_test/' --outdir /home/santanu/ML_DS_Catalog-/captcha/ --fetch_target True 
 ```
 
-在`4000` CAPTCHA 的测试数据集上实现的准确性约为 93％。 运行`evaluate`功能的输出如下：
+在`4000` CAPTCHA 的测试数据集上实现的准确性约为 93%。 运行`evaluate`功能的输出如下：
 
 ```py
 Accuracy: 0.9320972187421699 
@@ -657,7 +657,7 @@ python captcha_gan.py train --dest_train '/home/santanu/Downloads/train_32x32.ma
 | `dis_beta1` | `0.5` | `beta_1`是用于鉴别器的 Adam 优化器的参数。 |
 | `alpha` | `0.2` | 这是`LeakyReLU`激活的泄漏因子。 当`activation`功能的输入为负时，这有助于提供一个梯度（此处为`0.2`）。 它有助于解决垂死的`ReLU`问题。 如果输入小于或等于`0`，则 ReLU 函数的输出相对于其输入的梯度为`0`。 来自较后层的反向传播错误被此`0`乘以，尽管与该`ReLU.` ReLU 相关的神经元死亡，但没有错误传递至较早层。ReLU 已死亡，许多此类死亡`ReLUs`会影响训练 。 `LeakyReLU`通过甚至为负输入值提供小的梯度来克服了这个问题，从而确保训练不会由于缺乏梯度而停止。 |
 | `epochs` | `100` | 这是要运行的时期数。 |
-| `smooth_coef` | `0.1` | 设计该平滑系数的目的是减少真实样本对鉴别器的损失。 例如，`0.1`的`smooth_coef`可以将归因于真实图像的损失减少到原始损失的 90％。 这有助于 GAN 更好地融合。 |
+| `smooth_coef` | `0.1` | 设计该平滑系数的目的是减少真实样本对鉴别器的损失。 例如，`0.1`的`smooth_coef`可以将归因于真实图像的损失减少到原始损失的 90%。 这有助于 GAN 更好地融合。 |
 
 使用 GeForce GTX 1070 GPU，用这些参数训练 GAN 大约需要 3.12 小时。 建议读者使用 GPU 进行更快的培训。
 

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

@@ -311,7 +311,7 @@ def CMatrix(CM, labels=['pay', 'default']):
 
 前面的屏幕快照显示，随机森林模型更好，因为它位于逻辑回归曲线之上。 因此，对于`0.30`的精度，与逻辑回归模型相比，使用随机森林模型获得的召回率更高。
 
-要查看`RandomForestClassifier`方法的性能，我们更改了分类阈值。 例如，我们将分类阈值设置为`0.12`，那么我们将获得`30`的精度和`84`的召回率。 该模型将正确预测 84％的可能违约者，这对于金融机构将非常有用。 这表明增强模型对此优于逻辑回归模型。
+要查看`RandomForestClassifier`方法的性能，我们更改了分类阈值。 例如，我们将分类阈值设置为`0.12`，那么我们将获得`30`的精度和`84`的召回率。 该模型将正确预测 84% 的可能违约者，这对于金融机构将非常有用。 这表明增强模型对此优于逻辑回归模型。
 
 以下屏幕截图显示了代码和混淆矩阵：
 

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

@@ -295,7 +295,7 @@ y = diamonds[target_name]
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=123)
 ```
 
-执行并创建用于建模的对象后，我们执行`train_test_split`功能。 在前面的代码块中，我们将设置 0.1（10％）的数据进行测试，因此在调整超参数后，数据集的这一部分将用于模型评估。
+执行并创建用于建模的对象后，我们执行`train_test_split`功能。 在前面的代码块中，我们将设置 0.1（10% ）的数据进行测试，因此在调整超参数后，数据集的这一部分将用于模型评估。
 
 我们将使用以下参数调整`RandomForestRegressor`模型：
 
@@ -374,7 +374,7 @@ RF_tunned_test_mse = mean_squared_error(y_pred=RF_classifier.predict(X_test), y_
 
 ![](img/de47b18f-6727-4197-8078-2b10a3457512.png)
 
-在这里，经过调整的模型比未调整的模型提高了 4.6％，这实际上非常好。 在这些模型中，提高 1％-3％的百分比也可能具有巨大的实际意义。
+在这里，经过调整的模型比未调整的模型提高了 4.6%，这实际上非常好。 在这些模型中，提高 1% -3% 的百分比也可能具有巨大的实际意义。
 
 # 概要
 

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

@@ -21,11 +21,11 @@
 
 # 删除低方差的虚拟特征
 
-我们将学习的特征选择的第一种技术是删除方差低的虚拟特征。 到目前为止，我们一直在对特征进行的唯一转换是使用编码技术对分类特征进行转换。 如果我们采用一个分类特征并使用此编码技术，则会得到一组伪特征，将对其进行检查以查看它们是否具有可变性。 因此，方差非常低的特征可能对预测影响很小。 现在，为什么呢？ 假设您有一个具有性别特征的数据集，而 98％的观测值仅对应于女性。 此功能不会对预测产生任何影响，因为几乎所有情况都属于一个类别，因此变异性不足。 这些案例成为排定要消除的候选对象，应该更仔细地检查这些功能。 现在，看看以下公式：
+我们将学习的特征选择的第一种技术是删除方差低的虚拟特征。 到目前为止，我们一直在对特征进行的唯一转换是使用编码技术对分类特征进行转换。 如果我们采用一个分类特征并使用此编码技术，则会得到一组伪特征，将对其进行检查以查看它们是否具有可变性。 因此，方差非常低的特征可能对预测影响很小。 现在，为什么呢？ 假设您有一个具有性别特征的数据集，而 98% 的观测值仅对应于女性。 此功能不会对预测产生任何影响，因为几乎所有情况都属于一个类别，因此变异性不足。 这些案例成为排定要消除的候选对象，应该更仔细地检查这些功能。 现在，看看以下公式：
 
 ![](img/5fc96b69-e4fa-497c-9c96-25fc7005239d.png)
 
-您可以删除超过 x％的样本中所有为 0 或 1 的虚拟特征，或者可以为这些特征的方差建立最小阈值。 现在，可以使用前面的公式获得这些特征的方差，其中`p`是您的虚拟特征中`1`的数量或比例。 我们将在 Jupyter Notebook 中查看其工作原理。
+您可以删除超过 x% 的样本中所有为 0 或 1 的虚拟特征，或者可以为这些特征的方差建立最小阈值。 现在，可以使用前面的公式获得这些特征的方差，其中`p`是您的虚拟特征中`1`的数量或比例。 我们将在 Jupyter Notebook 中查看其工作原理。
 
 # 统计确定重要特征
 
@@ -199,13 +199,13 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 ![](img/e63ef069-1047-4913-b7d1-396f817af0df.png)
 
-读取此图的方式是，我们在这六个特征上执行的 PCA 的第一部分编码了所有六个特征的总方差的 90％以上。 第二个变量的变化很小，而第三，第四，第五和第六个分量的变化也很小。
+读取此图的方式是，我们在这六个特征上执行的 PCA 的第一部分编码了所有六个特征的总方差的 90% 以上。 第二个变量的变化很小，而第三，第四，第五和第六个分量的变化也很小。
 
 现在，我们可以在以下屏幕快照中所示的累积解释方差图中看到这一点：
 
 ![](img/ef93a131-19d8-4ce0-b10e-698b21ef1cfa.png)
 
-如您所见，第一个组件编码了我们使用的六个功能的 90％以上的方差。 因此，仅一项功能就可以获取 90％以上的信息。 因此，您可以仅使用一个功能而不是使用六个功能，而仍然获得 90％以上的方差。 或者，您可以使用前两个组件，并仅通过两个功能（此 PCA 的第一和第二个组件）获得六个功能所包含的全部信息的 95％以上。 因此，这就是实践中的工作方式，我们可以将其用作执行特征工程的一种技术。
+如您所见，第一个组件编码了我们使用的六个功能的 90% 以上的方差。 因此，仅一项功能就可以获取 90% 以上的信息。 因此，您可以仅使用一个功能而不是使用六个功能，而仍然获得 90% 以上的方差。 或者，您可以使用前两个组件，并仅通过两个功能（此 PCA 的第一和第二个组件）获得六个功能所包含的全部信息的 95% 以上。 因此，这就是实践中的工作方式，我们可以将其用作执行特征工程的一种技术。
 
 # 特征工程
 
@@ -344,7 +344,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 ![](img/af57d7ee-8abb-400f-b988-7d53e42ed206.png)
 
-如您在前面的屏幕截图中所见，我们使用的阈值为 0.2。 该模型生成`71.39`％的召回率和`37.38`的精度。 在这里，精度是相似的，但是，如前所述，召回率可能是我们应该关注的指标，因为与前一个指标略有不同。 我们对该模型有更好的回忆。 更改可能只是 2％或 3％，看起来似乎并不多，但是请记住，在这些财务应用程序中，实际上提高 1％或 2％可能意味着很多钱。 因此，使用这种小特征工程技术，我们对模型的预测能力有了一点改进。 让我们在以下屏幕截图中查看功能的重要性：
+如您在前面的屏幕截图中所见，我们使用的阈值为 0.2。 该模型生成`71.39`% 的召回率和`37.38`的精度。 在这里，精度是相似的，但是，如前所述，召回率可能是我们应该关注的指标，因为与前一个指标略有不同。 我们对该模型有更好的回忆。 更改可能只是 2% 或 3%，看起来似乎并不多，但是请记住，在这些财务应用程序中，实际上提高 1% 或 2% 可能意味着很多钱。 因此，使用这种小特征工程技术，我们对模型的预测能力有了一点改进。 让我们在以下屏幕截图中查看功能的重要性：
 
 ![](img/9225a3eb-041c-46f0-bc51-d6724b30d4f0.png)
 
@@ -377,7 +377,7 @@ RFE 是我们将使用`RandomForestClassifier`模型的第三种技术，请记
 
 ![](img/ba4c0671-5d52-4204-806c-85b9c4ecfcd9.png)
 
-现在，**不可约误差**项是该随机项的方差。 您对此词没有任何控制权。 总会有一个不可减少的错误成分。 因此，您的模型总是会出错； 无论您拥有多少个特征和数据点，您的模型都不能总是 100％正确的。 我们必须尝试使用​​更好和更复杂的方法来执行特征工程，并尝试将我们的估计近似为真实函数。 仅仅因为您使用的是更复杂的模型或您有更多的数据，您的模型就不会是完美的，并且您将无法准确预测`y`是什么，因为几乎所有过程都存在随机性 与您一起工作。 这是一个非常有趣的部分的结尾。
+现在，**不可约误差**项是该随机项的方差。 您对此词没有任何控制权。 总会有一个不可减少的错误成分。 因此，您的模型总是会出错； 无论您拥有多少个特征和数据点，您的模型都不能总是 100% 正确的。 我们必须尝试使用​​更好和更复杂的方法来执行特征工程，并尝试将我们的估计近似为真实函数。 仅仅因为您使用的是更复杂的模型或您有更多的数据，您的模型就不会是完美的，并且您将无法准确预测`y`是什么，因为几乎所有过程都存在随机性 与您一起工作。 这是一个非常有趣的部分的结尾。
 
 # 概要
 

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

@@ -138,15 +138,15 @@ y = tf.placeholder(tf.int64)
 
 在第 3 行中，我们初始化程序中的所有变量。 现在，在这里，我们没有任何明确的变量。 但是，内部的变量是完全连接的。 `fully_connected`函数是我们包含权重的所有隐藏层的地方。 这些就是变量，这就是为什么我们必须使用`global_ variables_initializer`对象初始化变量并运行此节点的原因。 对于每个时期，我们运行此循环 20 次。 现在，对于批次数量超过 80 的示例数量中的每次迭代，我们将获得要素和目标的值。 因此，每次迭代将有 80 个数据点。 然后，我们运行训练操作，并将通过`x`； 我们将传递特征值，在这里我们将传递目标值。 请记住，`x`和`y`是我们的占位符。 然后，我们评估训练的准确性，然后评估测试数据集中的准确性，从而获得测试数据集。 我们来自`mnist.test.images`，因此现在这些都是功能，`test.labels`是目标。 然后，在这两个循环完成之后，我们将打印两个精度。
 
-然后，我们为测试数据集中的前 15 张图像生成一些单独的预测。 运行此步骤后，我们获得了第一个纪元，其训练准确度为 86％，测试准确度为 88-89％。 以下屏幕截图显示了训练的结果以及不同时期的测试结果：
+然后，我们为测试数据集中的前 15 张图像生成一些单独的预测。 运行此步骤后，我们获得了第一个纪元，其训练准确度为 86%，测试准确度为 88-89%。 以下屏幕截图显示了训练的结果以及不同时期的测试结果：
 
 ![](img/16acb53f-7d10-4c38-9d16-273f6bd7b386.png)
 
-这些程序需要一点时间才能运行，但是经过 20 个星期之后，测试准确性几乎达到了 97％。 以下屏幕截图显示了实际标签和预测标签。 这些是网络所做的预测：
+这些程序需要一点时间才能运行，但是经过 20 个星期之后，测试准确性几乎达到了 97%。 以下屏幕截图显示了实际标签和预测标签。 这些是网络所做的预测：
 
 ![](img/affdeb3b-3f28-4b4b-a801-43210ca51816.png)
 
-因此，我们建立了第一个 DNN 模型，并且使用该程序能够以接近 97％的准确度对手写数字进行分类。
+因此，我们建立了第一个 DNN 模型，并且使用该程序能够以接近 97% 的准确度对手写数字进行分类。
 
 # 深度神经网络（DNN）的回归
 
@@ -324,8 +324,8 @@ y = tf.placeholder(y_train.dtype)
 
 # 生产用于建模的对象
 
-现在，我们生成用于建模的对象。 我们将使用 10％的测试
-和 90％的培训。 以下屏幕截图显示了
+现在，我们生成用于建模的对象。 我们将使用 10% 的测试
+和 90% 的培训。 以下屏幕截图显示了
 用于生成建模对象的代码行：
 
 ![](img/57d58fe3-2781-4cb0-b875-cbf1ef50ebcb.png) 
@@ -428,7 +428,7 @@ TensorFlow，`tf.nn.elu`中获得此功能，从中您可以获得许多功能
 
 ![](img/f23f3ebc-019f-4be1-a50d-dd44eaec977b.png)
 
-通过计算，我们得出的召回得分为`82.53`％，准确度为`34.02`％，准确度为`60.7`％。
+通过计算，我们得出的召回得分为`82.53`%，准确度为`34.02`%，准确度为`60.7`%。
 
 # 概要
 

new/whats-new-tf2/1.md

@@ -198,7 +198,7 @@ print(tf.add(x, y))
 <tf.RaggedTensor [[5, 5, 5, 5], [6, 8]]>
 ```
 
-另一个有趣的功能是为参差不齐的张量定义了运算符重载。 这意味着程序员可以像使用其他张量一样直观地使用+，-，*，/，/，％，**，＆，|，^，和> =等运算符。
+另一个有趣的功能是为参差不齐的张量定义了运算符重载。 这意味着程序员可以像使用其他张量一样直观地使用+，-，*，/，/，%，**，＆，|，^，和> =等运算符。
 
 以下代码块显示了使用重载运算符的参差张量的乘法：
 

new/whats-new-tf2/4.md

@@ -63,7 +63,7 @@ TensorFlow 建立深度学习模型并对其进行训练时的理念是，首先
 
 # 顺序 API
 
-顺序 API 是创建 TF 模型并提供大约 70-75％模型类型的最简单方法。 您需要创建一个`tf.keras.models.Sequential(...)` Python 类并将所需的层顺序添加到模型中-这也称为**层堆叠**。 这些层可能是密集，卷积甚至是递归层。 您可能需要提供第一层的输入形状。 以下是使用顺序 API 创建 TF 模型的步骤：
+顺序 API 是创建 TF 模型并提供大约 70-75% 模型类型的最简单方法。 您需要创建一个`tf.keras.models.Sequential(...)` Python 类并将所需的层顺序添加到模型中-这也称为**层堆叠**。 这些层可能是密集，卷积甚至是递归层。 您可能需要提供第一层的输入形状。 以下是使用顺序 API 创建 TF 模型的步骤：
 
 1.  创建一个`Sequential`模型类：