2022-01-15 23:47:03

trans/appml/different-results-each-time-in-machine-learning.md

@@ -58,7 +58,7 @@
 
 监督机器学习意味着我们有输入和输出变量(列)的例子(行)。我们不能编写代码来预测给定输入的输出，因为这太难了，所以我们使用机器学习算法来学习如何从给定历史示例的输入中预测输出。
 
-这被称为[函数逼近](https://machinelearningmastery.com/neural-networks-are-function-approximators/)，我们正在学习或搜索一个函数，该函数在我们的特定预测任务上将输入映射到输出，以使其具有技能，这意味着映射的性能优于随机的，理想情况下优于我们尝试过的所有其他算法和算法配置。
+这被称为[函数近似](https://machinelearningmastery.com/neural-networks-are-function-approximators/)，我们正在学习或搜索一个函数，该函数在我们的特定预测任务上将输入映射到输出，以使其具有技能，这意味着映射的性能优于随机的，理想情况下优于我们尝试过的所有其他算法和算法配置。
 
 *   **监督学习**:自动学习从输入示例到输出示例的映射函数。
 
@@ -196,7 +196,7 @@
 
 *   [拥抱机器学习中的随机性](https://machinelearningmastery.com/randomness-in-machine-learning/)
 
-然后，您可以将这些模型(算法管道)的性能总结为具有平均预期误差或精度以及标准偏差的分布。
+然后，您可以将这些模型(算法管道)的性能总结为具有平均预期误差或精确率以及标准偏差的分布。
 
 然后，您可以通过在数据集上拟合多个最终模型，并在需要对新数据进行预测时对它们的预测进行平均，来确保实现模型的平均性能。
 
@@ -236,7 +236,7 @@ k 折叠交叉验证过程包括将数据集划分为 k 个不重叠的分区，
 
 *   [统计采样和重采样的简单介绍](https://machinelearningmastery.com/statistical-sampling-and-resampling/)
 
-因此，确定性机器学习算法的每个评估，像线性回归或逻辑回归，可以给出不同的误差或精度估计。
+因此，确定性机器学习算法的每个评估，像线性回归或逻辑回归，可以给出不同的误差或精确率估计。
 
 ### 我该怎么办？
 

trans/appml/training-validation-test-split-and-cross-validation-done-right.md

@@ -54,7 +54,7 @@ scikit-learn 的[指标页面有一个较长但并非详尽的列表，列出了
 
 但是，有一个问题；对于样本数据集，我们只评估了模型一次。假设我们正确地将数据集分为训练集和测试集，并在用测试集评估时用训练集拟合模型，那么我们只获得了用一个测试集评估的单个样本点。我们如何确定它是一个准确的评价，而不是一个偶然的过低或过高的值？如果我们有两个模型，并且根据评价发现一个模型比另一个模型好，我们怎么知道这也不是偶然的呢？
 
-我们关注这一点的原因是，为了避免在将来，当模型被部署和使用在一个全新的数据上，而不是我们获得的数据上时，出现令人惊讶的低精度。
+我们关注这一点的原因是，为了避免在将来，当模型被部署和使用在一个全新的数据上，而不是我们获得的数据上时，出现令人惊讶的低精确率。
 
 ## 样本外评估
 

trans/keras/autoencoder-for-classification.md

-# 自动编码器特征提取分类
+# 用于分类的自编码器特征提取
 
 > 原文：<https://machinelearningmastery.com/autoencoder-for-classification/>
 
-**自动编码器**是一种神经网络，可用于学习原始数据的压缩表示。
+**自编码器**是一种神经网络，可用于学习原始数据的压缩表示。
 
-自动编码器由编码器和解码器子模型组成。编码器压缩输入，解码器尝试根据编码器提供的压缩版本重新创建输入。训练后，编码器模型被保存，解码器被丢弃。
+自编码器由编码器和解码器子模型组成。编码器压缩输入，解码器尝试根据编码器提供的压缩版本重新创建输入。训练后，编码器模型被保存，解码器被丢弃。
 
 然后，编码器可用作数据准备技术，对原始数据执行特征提取，该原始数据可用于训练不同的机器学习模型。
 
-在本教程中，您将了解如何开发和评估用于分类预测建模的自动编码器。
+在本教程中，您将了解如何开发和评估用于分类预测建模的自编码器。
 
 完成本教程后，您将知道:
 
-*   自动编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
-*   如何在训练数据集上训练自动编码器模型，并只保存模型的编码器部分。
+*   自编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
+*   如何在训练数据集上训练自编码器模型，并只保存模型的编码器部分。
 *   训练机器学习模型时如何将编码器作为数据准备步骤？
 
 我们开始吧。
 
 ![How to Develop an Autoencoder for Classification](img/738aea1b3ed188d654bad74e8f245f5d.png)
 
-如何开发分类自动编码器
+如何开发分类自编码器
 图片由[贝恩德·泰勒](https://www.flickr.com/photos/bernd_thaller/23727171246/)提供，版权所有。
 
 ## 教程概述
 
 本教程分为三个部分；它们是:
 
-1.  用于特征提取的自动编码器
-2.  用于分类的自动编码器
+1.  用于特征提取的自编码器
+2.  用于分类的自编码器
 3.  编码器作为预测模型的数据准备
 
-## 用于特征提取的自动编码器
+## 用于特征提取的自编码器
 
-自动编码器[是一种神经网络模型，旨在学习输入的压缩表示。](https://en.wikipedia.org/wiki/Autoencoder)
+自编码器[是一种神经网络模型，旨在学习输入的压缩表示。](https://en.wikipedia.org/wiki/Autoencoder)
 
-> 自动编码器是一个神经网络，它被训练成试图将其输入复制到其输出。
+> 自编码器是一个神经网络，它被训练成试图将其输入复制到其输出。
 
 —第 502 页，[深度学习](https://amzn.to/3kV7gdV)，2016。
 
 它们是一种无监督的学习方法，尽管从技术上来说，它们是使用有监督的学习方法训练的，称为自监督。
 
-自动编码器通常被训练为试图重建输入的更广泛模型的一部分。
+自编码器通常被训练为试图重建输入的更广泛模型的一部分。
 
 例如:
 
 *   X =模型.预测(X)
 
-自动编码器模型的设计有目的地将架构限制在模型中点的瓶颈上，从而使这一点具有挑战性，输入数据的重建就是从这个瓶颈开始的。
+自编码器模型的设计有目的地将架构限制在模型中点的瓶颈上，从而使这一点具有挑战性，输入数据的重建就是从这个瓶颈开始的。
 
-自动编码器有许多类型，它们的用途各不相同，但可能更常见的用途是作为一个学习或自动特征提取模型。
+自编码器有许多类型，它们的用途各不相同，但可能更常见的用途是作为一个学习或自动特征提取模型。
 
 在这种情况下，一旦模型被拟合，模型的重建方面可以被丢弃，并且直到瓶颈点的模型可以被使用。瓶颈处模型的输出是一个固定长度的向量，它提供了输入数据的压缩表示。
 
@@ -59,15 +59,15 @@
 
 然后可以将来自域的输入数据提供给模型，并且瓶颈处的模型输出可以用作监督学习模型中的特征向量，用于可视化，或者更一般地用于降维。
 
-接下来，让我们探索如何针对分类预测建模问题开发用于特征提取的自动编码器。
+接下来，让我们探索如何针对分类预测建模问题开发用于特征提取的自编码器。
 
-## 用于分类的自动编码器
+## 用于分类的自编码器
 
-在本节中，我们将开发一个自动编码器来学习分类预测建模问题的输入特征的压缩表示。
+在本节中，我们将开发一个自编码器来学习分类预测建模问题的输入特征的压缩表示。
 
 首先，让我们定义一个分类预测建模问题。
 
-我们将使用[make _ classification()sci kit-learn 函数](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_classification.html)定义一个包含 100 个输入特征(列)和 1000 个示例(行)的合成二进制(2 类)分类任务。重要的是，我们将以这样的方式定义问题，即大多数输入变量是冗余的(100%或 90%中的 90%)，允许自动编码器稍后学习有用的压缩表示。
+我们将使用[make _ classification()sci kit-learn 函数](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_classification.html)定义一个包含 100 个输入特征(列)和 1000 个示例(行)的合成二进制(2 类)分类任务。重要的是，我们将以这样的方式定义问题，即大多数输入变量是冗余的(100%或 90%中的 90%)，允许自编码器稍后学习有用的压缩表示。
 
 下面的示例定义了数据集并总结了它的形状。
 
@@ -86,15 +86,15 @@ print(X.shape, y.shape)
 (1000, 100) (1000,)
 ```
 
-接下来，我们将开发一个多层感知器(MLP)自动编码器模型。
+接下来，我们将开发一个多层感知器(MLP)自编码器模型。
 
 该模型将采用所有输入列，然后输出相同的值。它将学会精确地重新创建输入模式。
 
-自动编码器由两部分组成:编码器和解码器。编码器学习如何解释输入，并将其压缩为瓶颈层定义的内部表示。解码器获取编码器的输出(瓶颈层)，并尝试重新创建输入。
+自编码器由两部分组成:编码器和解码器。编码器学习如何解释输入，并将其压缩为瓶颈层定义的内部表示。解码器获取编码器的输出(瓶颈层)，并尝试重新创建输入。
 
-一旦自动编码器被训练，解码器被丢弃，我们只保留编码器，并使用它将输入的例子压缩成瓶颈层输出的向量。
+一旦自编码器被训练，解码器被丢弃，我们只保留编码器，并使用它将输入的例子压缩成瓶颈层输出的向量。
 
-在第一个自动编码器中，我们根本不会压缩输入，而是使用与输入大小相同的瓶颈层。这应该是一个简单的问题，模型将学习得近乎完美，并旨在确认我们的模型被正确实现。
+在第一个自编码器中，我们根本不会压缩输入，而是使用与输入大小相同的瓶颈层。这应该是一个简单的问题，模型将学习得近乎完美，并旨在确认我们的模型被正确实现。
 
 我们将使用功能 API 定义模型；如果您不熟悉，我推荐本教程:
 
@@ -162,7 +162,7 @@ model = Model(inputs=visible, outputs=output)
 model.compile(optimizer='adam', loss='mse')
 ```
 
-我们可以在自动编码器模型中绘制图层，以了解数据如何在模型中流动。
+我们可以在自编码器模型中绘制图层，以了解数据如何在模型中流动。
 
 ```py
 ...
@@ -170,11 +170,11 @@ model.compile(optimizer='adam', loss='mse')
 plot_model(model, 'autoencoder_no_compress.png', show_shapes=True)
 ```
 
-下图显示了自动编码器的曲线图。
+下图显示了自编码器的曲线图。
 
 ![Plot of Autoencoder Model for Classification With No Compression](img/89172eec95c45fb8cabffc5340956d15.png)
 
-无压缩分类自动编码器模型图
+无压缩分类自编码器模型图
 
 接下来，我们可以训练模型来重现输入，并在等待测试集上跟踪模型的性能。
 
@@ -214,7 +214,7 @@ encoder.save('encoder.h5')
 
 无压缩分类编码器模型图
 
-将所有这些结合在一起，下面列出了一个完整的自动编码器示例，用于在瓶颈层没有任何压缩的情况下重建分类数据集的输入数据。
+将所有这些结合在一起，下面列出了一个完整的自编码器示例，用于在瓶颈层没有任何压缩的情况下重建分类数据集的输入数据。
 
 ```py
 # train autoencoder for classification with no compression in the bottleneck layer
@@ -286,7 +286,7 @@ encoder.save('encoder.h5')
 
 **注意**:如果在创建模型的地块时遇到问题，可以注释掉导入，调用 *plot_model()* 函数。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们看到损耗变低了，但是在瓶颈层没有压缩的情况下，损耗没有达到零(正如我们可能预期的那样)。也许需要进一步调整模型架构或学习超参数。
 
@@ -309,9 +309,9 @@ Epoch 200/200
 
 ![Learning Curves of Training the Autoencoder Model Without Compression](img/b470c287235ed252447631fa702b9b4f.png)
 
-无压缩训练自动编码器模型的学习曲线
+无压缩训练自编码器模型的学习曲线
 
-目前为止，一切顺利。我们知道如何开发一个没有压缩的自动编码器。
+目前为止，一切顺利。我们知道如何开发一个没有压缩的自编码器。
 
 接下来，让我们更改模型的配置，以便瓶颈层有一半的节点数量(例如 50 个)。
 
@@ -392,7 +392,7 @@ encoder.save('encoder.h5')
 
 运行该示例符合模型，并报告沿途火车和测试集的损失。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们看到，在没有压缩的情况下，损失变得与上面的示例类似低，这表明，在瓶颈只有一半大的情况下，模型的性能可能也一样好。
 
@@ -415,7 +415,7 @@ Epoch 200/200
 
 ![Learning Curves of Training the Autoencoder Model With Compression](img/f5eddc1854392afed6eebbbb40402f49.png)
 
-压缩训练自动编码器模型的学习曲线
+压缩训练自编码器模型的学习曲线
 
 训练好的编码器保存到文件“ *encoder.h5* ”中，我们以后可以加载使用。
 
@@ -423,7 +423,7 @@ Epoch 200/200
 
 ## 编码器作为预测模型的数据准备
 
-在本节中，我们将使用自动编码器中经过训练的编码器来压缩输入数据，并训练不同的预测模型。
+在本节中，我们将使用自编码器中经过训练的编码器来压缩输入数据，并训练不同的预测模型。
 
 首先，让我们在这个问题上建立一个性能基线。这一点很重要，因为如果压缩编码不能提高模型的性能，那么压缩编码就不能增加项目的价值，就不应该使用。
 
@@ -461,7 +461,7 @@ print(acc)
 
 运行该示例适合训练数据集上的逻辑回归模型，并在测试集上对其进行评估。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到该模型实现了大约 89.3%的分类准确率。
 
@@ -544,11 +544,11 @@ print(acc)
 
 运行该示例首先使用编码器对数据集进行编码，然后在训练数据集上拟合逻辑回归模型，并在测试集上对其进行评估。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到该模型实现了大约 93.9%的分类准确率。
 
-这比在原始数据集上评估的相同模型具有更好的分类精度，表明编码对我们选择的模型和测试工具有帮助。
+这比在原始数据集上评估的相同模型具有更好的分类精确率，表明编码对我们选择的模型和测试工具有帮助。
 
 ```py
 0.9393939393939394
@@ -560,7 +560,7 @@ print(acc)
 
 ### 教程
 
-*   [LSTM 自动编码器简介](https://machinelearningmastery.com/lstm-autoencoders/)
+*   [LSTM 自编码器简介](https://machinelearningmastery.com/lstm-autoencoders/)
 *   [如何使用 Keras 函数 API 进行深度学习](https://machinelearningmastery.com/keras-functional-api-deep-learning/)
 *   [TensorFlow 2 教程:使用 tf.keras 开始深度学习](https://machinelearningmastery.com/tensorflow-tutorial-deep-learning-with-tf-keras/)
 
@@ -579,12 +579,12 @@ print(acc)
 
 ## 摘要
 
-在本教程中，您发现了如何开发和评估用于分类预测建模的自动编码器。
+在本教程中，您发现了如何开发和评估用于分类预测建模的自编码器。
 
 具体来说，您了解到:
 
-*   自动编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
-*   如何在训练数据集上训练自动编码器模型，并只保存模型的编码器部分。
+*   自编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
+*   如何在训练数据集上训练自编码器模型，并只保存模型的编码器部分。
 *   训练机器学习模型时如何将编码器作为数据准备步骤？
 
 **你有什么问题吗？**

trans/keras/autoencoder-for-regression.md

-# 回归自动编码器特征提取
+# 用于回归的自编码器特征提取
 
 > 原文：<https://machinelearningmastery.com/autoencoder-for-regression/>
 
-自动编码器是一种神经网络，可用于学习原始数据的压缩表示。
+自编码器是一种神经网络，可用于学习原始数据的压缩表示。
 
-自动编码器由编码器和解码器子模型组成。编码器压缩输入，解码器尝试根据编码器提供的压缩版本重新创建输入。训练后，编码器模型被保存，解码器被丢弃。
+自编码器由编码器和解码器子模型组成。编码器压缩输入，解码器尝试根据编码器提供的压缩版本重新创建输入。训练后，编码器模型被保存，解码器被丢弃。
 
 然后，编码器可用作数据准备技术，对原始数据执行特征提取，该原始数据可用于训练不同的机器学习模型。
 
-在本教程中，您将了解如何开发和评估用于回归预测的自动编码器
+在本教程中，您将了解如何开发和评估用于回归预测的自编码器
 
 完成本教程后，您将知道:
 
-*   自动编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
-*   如何在训练数据集上训练自动编码器模型，并只保存模型的编码器部分。
+*   自编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
+*   如何在训练数据集上训练自编码器模型，并只保存模型的编码器部分。
 *   训练机器学习模型时如何将编码器作为数据准备步骤？
 
 我们开始吧。
 
 ![Autoencoder Feature Extraction for Regression](img/f4491cf5b76d166d0ecc472b82ccec72.png)
 
-自动编码器特征提取回归
+自编码器特征提取回归
 照片作者[西蒙·马津格](https://www.flickr.com/photos/simonmatzinger/16693660849/)，保留部分权利。
 
 ## 教程概述
 
 本教程分为三个部分；它们是:
 
-1.  用于特征提取的自动编码器
-2.  回归自动编码器
-3.  自动编码器作为数据准备
+1.  用于特征提取的自编码器
+2.  回归自编码器
+3.  自编码器作为数据准备
 
-## 用于特征提取的自动编码器
+## 用于特征提取的自编码器
 
-自动编码器[是一种神经网络模型，旨在学习输入的压缩表示。](https://en.wikipedia.org/wiki/Autoencoder)
+自编码器[是一种神经网络模型，旨在学习输入的压缩表示。](https://en.wikipedia.org/wiki/Autoencoder)
 
-> 自动编码器是一个神经网络，它被训练成试图将其输入复制到其输出。
+> 自编码器是一个神经网络，它被训练成试图将其输入复制到其输出。
 
 —第 502 页，[深度学习](https://amzn.to/3kV7gdV)，2016。
 
@@ -45,9 +45,9 @@
 
 *   X =模型.预测(X)
 
-自动编码器模型的设计有目的地将架构限制在模型中点的瓶颈上，从而使这一点具有挑战性，输入数据的重建就是从这个瓶颈开始的。
+自编码器模型的设计有目的地将架构限制在模型中点的瓶颈上，从而使这一点具有挑战性，输入数据的重建就是从这个瓶颈开始的。
 
-自动编码器有许多类型，它们的用途各不相同，但可能更常见的用途是作为一个学习或自动特征提取模型。
+自编码器有许多类型，它们的用途各不相同，但可能更常见的用途是作为一个学习或自动特征提取模型。
 
 在这种情况下，一旦模型被拟合，模型的重建方面可以被丢弃，并且直到瓶颈点的模型可以被使用。瓶颈处的模型输出是一个固定长度的向量，它提供了输入数据的压缩表示。
 
@@ -57,15 +57,15 @@
 
 然后可以将来自域的输入数据提供给模型，并且瓶颈处的模型输出可以用作监督学习模型中的特征向量，用于可视化，或者更一般地用于降维。
 
-接下来，让我们探索如何针对回归预测建模问题开发用于特征提取的自动编码器。
+接下来，让我们探索如何针对回归预测建模问题开发用于特征提取的自编码器。
 
-## 回归自动编码器
+## 回归自编码器
 
-在本节中，我们将开发一个自动编码器来学习回归预测建模问题的输入特征的压缩表示。
+在本节中，我们将开发一个自编码器来学习回归预测建模问题的输入特征的压缩表示。
 
 首先，让我们定义一个回归预测建模问题。
 
-我们将使用[make _ revolution()sci kit-learn 函数](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_regression.html)定义一个包含 100 个输入特征(列)和 1000 个示例(行)的合成回归任务。重要的是，我们将以这样的方式定义问题，即大多数输入变量是冗余的(100%或 90%中的 90%)，允许自动编码器稍后学习有用的压缩表示。
+我们将使用[make _ revolution()sci kit-learn 函数](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_regression.html)定义一个包含 100 个输入特征(列)和 1000 个示例(行)的合成回归任务。重要的是，我们将以这样的方式定义问题，即大多数输入变量是冗余的(100%或 90%中的 90%)，允许自编码器稍后学习有用的压缩表示。
 
 下面的示例定义了数据集并总结了它的形状。
 
@@ -84,15 +84,15 @@ print(X.shape, y.shape)
 (1000, 100) (1000,)
 ```
 
-接下来，我们将开发一个多层感知器(MLP)自动编码器模型。
+接下来，我们将开发一个多层感知器(MLP)自编码器模型。
 
 该模型将采用所有输入列，然后输出相同的值。它将学会精确地重新创建输入模式。
 
-自动编码器由两部分组成:编码器和解码器。编码器学习如何解释输入，并将其压缩为瓶颈层定义的内部表示。解码器获取编码器的输出(瓶颈层)，并尝试重新创建输入。
+自编码器由两部分组成:编码器和解码器。编码器学习如何解释输入，并将其压缩为瓶颈层定义的内部表示。解码器获取编码器的输出(瓶颈层)，并尝试重新创建输入。
 
-一旦自动编码器被训练，解码就被丢弃，我们只保留编码器，并使用它将输入的例子压缩成瓶颈层输出的向量。
+一旦自编码器被训练，解码就被丢弃，我们只保留编码器，并使用它将输入的例子压缩成瓶颈层输出的向量。
 
-在第一个自动编码器中，我们根本不会压缩输入，而是使用与输入大小相同的瓶颈层。这应该是一个简单的问题，模型将学习得近乎完美，并旨在确认我们的模型被正确实现。
+在第一个自编码器中，我们根本不会压缩输入，而是使用与输入大小相同的瓶颈层。这应该是一个简单的问题，模型将学习得近乎完美，并旨在确认我们的模型被正确实现。
 
 我们将使用功能性应用编程接口来定义模型。如果您不熟悉，我推荐本教程:
 
@@ -153,7 +153,7 @@ model.compile(optimizer='adam', loss='mse')
 model.compile(optimizer='adam', loss='mse')
 ```
 
-我们可以在自动编码器模型中绘制图层，以了解数据如何在模型中流动。
+我们可以在自编码器模型中绘制图层，以了解数据如何在模型中流动。
 
 ```py
 ...
@@ -161,11 +161,11 @@ model.compile(optimizer='adam', loss='mse')
 plot_model(model, 'autoencoder.png', show_shapes=True)
 ```
 
-下图显示了自动编码器的曲线图。
+下图显示了自编码器的曲线图。
 
 ![Plot of the Autoencoder Model for Regression](img/b976de4a69e541ca481f0219784ca67e.png)
 
-回归的自动编码器模型图
+回归的自编码器模型图
 
 接下来，我们可以训练模型来重现输入，并跟踪模型在保持测试集上的性能。该模型针对 400 个时期和 16 个实例的批量进行训练。
 
@@ -205,7 +205,7 @@ encoder.save('encoder.h5')
 
 无压缩回归的编码器模型图
 
-将所有这些结合在一起，下面列出了一个完整的自动编码器示例，用于在瓶颈层没有任何压缩的情况下重建回归数据集的输入数据。
+将所有这些结合在一起，下面列出了一个完整的自编码器示例，用于在瓶颈层没有任何压缩的情况下重建回归数据集的输入数据。
 
 ```py
 # train autoencoder for regression with no compression in the bottleneck layer
@@ -268,7 +268,7 @@ encoder.save('encoder.h5')
 
 **注意**:如果在创建模型的地块时遇到问题，可以注释掉导入，调用 *plot_model()* 函数。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们看到，在瓶颈层没有压缩的情况下，损耗变低，但不会归零(正如我们可能预期的那样)。也许需要进一步调整模型架构或学习超参数。
 
@@ -296,17 +296,17 @@ Epoch 400/400
 
 ![Learning Curves of Training the Autoencoder Model for Regression Without Compression](img/709ae0116a83ca3ae41bf1363fd01ed7.png)
 
-无压缩回归自动编码器模型训练的学习曲线
+无压缩回归自编码器模型训练的学习曲线
 
-目前为止，一切顺利。我们知道如何开发一个没有压缩的自动编码器。
+目前为止，一切顺利。我们知道如何开发一个没有压缩的自编码器。
 
 训练好的编码器保存到文件“ *encoder.h5* ”中，我们以后可以加载使用。
 
 接下来，让我们探索如何使用训练好的编码器模型。
 
-## 自动编码器作为数据准备
+## 自编码器作为数据准备
 
-在本节中，我们将使用自动编码器模型中经过训练的编码器模型来压缩输入数据并训练不同的预测模型。
+在本节中，我们将使用自编码器模型中经过训练的编码器模型来压缩输入数据并训练不同的预测模型。
 
 首先，让我们在这个问题上建立一个性能基线。这一点很重要，因为如果压缩编码不能提高模型的性能，那么压缩编码就不能增加项目的价值，就不应该使用。
 
@@ -357,7 +357,7 @@ print(score)
 
 运行该示例适合训练数据集上的支持向量回归模型，并在测试集上对其进行评估。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型实现了大约 89 的平均绝对误差(MAE)。
 
@@ -451,7 +451,7 @@ print(score)
 
 运行该示例首先使用编码器对数据集进行编码，然后在训练数据集上拟合一个支持向量回归模型，并在测试集上对其进行评估。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型实现了大约 69 的 MAE。
 
@@ -467,7 +467,7 @@ print(score)
 
 ### 教程
 
-*   [LSTM 自动编码器简介](https://machinelearningmastery.com/lstm-autoencoders/)
+*   [LSTM 自编码器简介](https://machinelearningmastery.com/lstm-autoencoders/)
 *   [如何使用 Keras 函数 API 进行深度学习](https://machinelearningmastery.com/keras-functional-api-deep-learning/)
 *   [TensorFlow 2 教程:使用 tf.keras 开始深度学习](https://machinelearningmastery.com/tensorflow-tutorial-deep-learning-with-tf-keras/)
 
@@ -486,12 +486,12 @@ print(score)
 
 ## 摘要
 
-在本教程中，您发现了如何开发和评估用于回归预测建模的自动编码器。
+在本教程中，您发现了如何开发和评估用于回归预测建模的自编码器。
 
 具体来说，您了解到:
 
-*   自动编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
-*   如何在训练数据集上训练自动编码器模型，并只保存模型的编码器部分。
+*   自编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
+*   如何在训练数据集上训练自编码器模型，并只保存模型的编码器部分。
 *   训练机器学习模型时如何将编码器作为数据准备步骤？
 
 **你有什么问题吗？**

trans/keras/autokeras-for-classification-and-regression.md

-# 如何使用 AutoKeras 进行分类和回归
+# 如何将 AutoKeras 用于分类和回归
 
 > 原文：<https://machinelearningmastery.com/autokeras-for-classification-and-regression/>
 
@@ -291,7 +291,7 @@ model.save('model_sonar.h5')
 
 然后在搁置测试数据集上评估性能最佳的模型。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到该模型实现了大约 82.6%的分类准确率。
 
@@ -482,7 +482,7 @@ model.save('model_insurance.h5')
 
 然后在搁置测试数据集上评估性能最佳的模型。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型实现了大约 24 的 MAE。
 

trans/keras/choose-an-activation-function-for-deep-learning.md

@@ -389,7 +389,7 @@ print(outputs.sum())
 
 具体来说，被预测的变量的类型。
 
-例如，您可以将预测问题分为两大类，预测分类变量(*分类*)和预测数值变量(*回归*)。
+例如，您可以将预测问题分为两大类，预测类别变量(*分类*)和预测数值变量(*回归*)。
 
 如果你的问题是一个回归问题，你应该使用线性激活函数。
 

trans/keras/deep-learning-competence.md

-# 3 级深度学习能力
+# 深度学习能力的三个层次
 
 > 原文：<https://machinelearningmastery.com/deep-learning-competence/>
 
@@ -162,7 +162,7 @@
 
 *   输入相同比例的变量。
 *   不同尺度的输入变量。
-*   数字和分类变量的混合。
+*   数字和类别变量的混合。
 *   缺少值的变量。
 *   具有冗余输入特征的数据。
 

trans/keras/deep-learning-models-for-multi-output-regression.md

-# 多输出回归的深度学习模型
+# 用于多输出回归的深度学习模型
 
 > 原文：<https://machinelearningmastery.com/deep-learning-models-for-multi-output-regression/>
 
@@ -207,7 +207,7 @@ print('MAE: %.3f (%.3f)' % (mean(results), std(results)))
 
 运行该示例报告每个折叠和每个重复的 MAE，以给出评估进度的想法。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 最后，报告了平均和标准差。在这种情况下，该模型显示的 MAE 约为 8.184。
 
@@ -263,7 +263,7 @@ print('Predicted: %s' % yhat[0])
 
 运行该示例符合模型，并对新行进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 正如预期的那样，预测包含多输出回归任务所需的三个输出变量。
 

trans/keras/develop-a-neural-network-for-woods-mammography-dataset.md

@@ -164,7 +164,7 @@ Class='-1', Count=10923, Percentage=97.675%
 Class='1', Count=260, Percentage=2.325%
 ```
 
-这是有帮助的，因为如果我们使用分类精度，那么任何达到低于约 97.7%的精度的模型都没有这个数据集的技能。
+这是有帮助的，因为如果我们使用分类精确率，那么任何达到低于约 97.7%的精确率的模型都没有这个数据集的技能。
 
 现在我们已经熟悉了数据集，让我们探索如何开发一个神经网络模型。
 
@@ -227,7 +227,7 @@ model.compile(optimizer='adam', loss='binary_crossentropy')
 history = model.fit(X_train, y_train, epochs=300, batch_size=32, verbose=0, validation_data=(X_test,y_test))
 ```
 
-在训练结束时，我们将评估模型在测试数据集上的性能，并将性能报告为分类精度。
+在训练结束时，我们将评估模型在测试数据集上的性能，并将性能报告为分类精确率。
 
 ```py
 ...
@@ -252,7 +252,7 @@ pyplot.legend()
 pyplot.show()
 ```
 
-将所有这些结合起来，下面列出了在癌症生存数据集上评估我们的第一个 MLP 的完整示例。
+将所有这些结合起来，下面列出了在癌症存活数据集上评估我们的第一个 MLP 的完整示例。
 
 ```py
 # fit a simple mlp model on the mammography and review learning curves
@@ -299,9 +299,9 @@ pyplot.legend()
 pyplot.show()
 ```
 
-运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告分类精度。
+运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到该模型比无技能模型表现得更好，假设准确率在大约 97.7%以上，在这种情况下达到大约 98.8%的准确率。
 
@@ -323,7 +323,7 @@ Accuracy: 0.988
 
 k 倍交叉验证程序可以提供更可靠的 MLP 性能估计，尽管它可能非常慢。
 
-这是因为 k 模型必须被拟合和评估。当数据集规模较小时，例如癌症生存数据集，这不是问题。
+这是因为 k 模型必须被拟合和评估。当数据集规模较小时，例如癌症存活数据集，这不是问题。
 
 我们可以使用[stratifiedfold](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.StratifiedKFold.html)类手动枚举每个折叠，拟合模型，对其进行评估，然后在程序结束时报告评估分数的平均值。
 
@@ -396,11 +396,11 @@ for train_ix, test_ix in kfold.split(X, y):
 print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 ```
 
-运行该示例会报告评估程序每次迭代的模型性能，并在运行结束时报告分类精度的平均值和标准偏差。
+运行该示例会报告评估程序每次迭代的模型性能，并在运行结束时报告分类精确率的平均值和标准偏差。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-在这种情况下，我们可以看到 MLP 模型获得了大约 98.7%的平均精度，这与我们在前面部分中的粗略估计非常接近。
+在这种情况下，我们可以看到 MLP 模型获得了大约 98.7%的平均精确率，这与我们在前面部分中的粗略估计非常接近。
 
 这证实了我们的预期，即对于这个数据集，基本模型配置可能比简单模型工作得更好
 
@@ -525,7 +525,7 @@ print('Predicted: %s' % (yhat[0]))
 
 运行该示例使模型适合整个数据集，并对单行新数据进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型为输入行预测了一个“-1”标签。
 

trans/keras/how-to-calculate-precision-recall-f1-and-more-for-deep-learning-models.md

-# 如何计算深度学习模型的精度、召回率、F1 等
+# 如何计算深度学习模型的精确率、召回率、F1 等
 
 > 原文：<https://machinelearningmastery.com/how-to-calculate-precision-recall-f1-and-more-for-deep-learning-models/>
 
@@ -12,7 +12,7 @@
 
 我经常被问到的问题，比如:
 
-> 如何计算模型的精度和召回率？
+> 如何计算模型的精确率和召回率？
 
 以及:
 
@@ -24,7 +24,7 @@
 
 *   如何使用 scikit-learn metrics API 评估深度学习模型？
 *   如何用 scikit-learn API 要求的最终模型进行类和概率预测。
-*   如何用 scikit-learn API 为一个模型计算精度、召回率、F1-评分、ROC AUC 等。
+*   如何用 scikit-learn API 为一个模型计算精确率、召回率、F1-评分、ROC AUC 等。
 
 **用我的新书[用 Python 深度学习](https://machinelearningmastery.com/deep-learning-with-python/)来启动你的项目**，包括*分步教程*和所有示例的 *Python 源代码*文件。
 
@@ -34,7 +34,7 @@
 
 ![How to Calculate Precision, Recall, F1, and More for Deep Learning Models](img/e7ad4c9b8f5fcd6d2ce46c6c547024d2.png)
 
-如何计算深度学习模型的精度、召回率、F1 和更多信息[约翰](https://www.flickr.com/photos/shebalso/358533824/)摄，版权所有。
+如何计算深度学习模型的精确率、召回率、F1 和更多信息[约翰](https://www.flickr.com/photos/shebalso/358533824/)摄，版权所有。
 
 ## 教程概述
 
@@ -109,7 +109,7 @@ model.add(Dense(100, input_dim=2, activation='relu'))
 model.add(Dense(1, activation='sigmoid'))
 ```
 
-模型将使用二元交叉熵损失函数进行拟合，我们将使用有效的[亚当版本的随机梯度下降](https://machinelearningmastery.com/adam-optimization-algorithm-for-deep-learning/)。该模型还将监控分类精度度量。
+模型将使用二元交叉熵损失函数进行拟合，我们将使用有效的[亚当版本的随机梯度下降](https://machinelearningmastery.com/adam-optimization-algorithm-for-deep-learning/)。该模型还将监控分类精确率度量。
 
 ```py
 # compile model
@@ -123,7 +123,7 @@ model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']
 history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=300, verbose=0)
 ```
 
-在训练结束时，我们将在训练和测试数据集上再次评估最终模型，并报告分类精度。
+在训练结束时，我们将在训练和测试数据集上再次评估最终模型，并报告分类精确率。
 
 ```py
 # evaluate the model
@@ -131,7 +131,7 @@ _, train_acc = model.evaluate(trainX, trainy, verbose=0)
 _, test_acc = model.evaluate(testX, testy, verbose=0)
 ```
 
-最后，模型在列车上的性能和在训练期间记录的测试集将使用线图来绘制，损失和分类精度各一个。
+最后，模型在列车上的性能和在训练期间记录的测试集将使用线图来绘制，损失和分类精确率各一个。
 
 ```py
 # plot loss during training
@@ -192,7 +192,7 @@ pyplot.show()
 
 在中央处理器上运行该示例非常快速地符合模型(不需要图形处理器)。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 对该模型进行了评估，报告在列车和测试集上的分类准确率分别约为 83%和 85%。
 
@@ -212,7 +212,7 @@ Train: 0.838, Test: 0.850
 
 也许你需要使用 [Keras 度量 API](https://keras.io/metrics/) 不支持的额外度量来评估你的深度学习神经网络模型。
 
-Keras 度量 API 是有限的，您可能想要计算诸如精度、召回率、F1 等度量。
+Keras 度量 API 是有限的，您可能想要计算诸如精确率、召回率、F1 等度量。
 
 计算新度量的一种方法是在 Keras API 中自己实现它们，并让 Keras 在模型训练和模型评估期间为您计算它们。
 
@@ -224,13 +224,13 @@ Keras 度量 API 是有限的，您可能想要计算诸如精度、召回率、
 
 一个更简单的替代方法是使用您的最终模型对测试数据集进行预测，然后使用 [scikit-learn metrics API](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.metrics) 计算您想要的任何度量。
 
-除了分类精度之外，二元分类问题的神经网络模型通常还需要三个指标:
+除了分类精确率之外，二元分类问题的神经网络模型通常还需要三个指标:
 
 *   精确
 *   回忆
 *   F1 分数
 
-在本节中，我们将使用 scikit-learn metrics API 计算这三个指标以及分类精度，我们还将计算三个不太常见但可能有用的附加指标。它们是:
+在本节中，我们将使用 scikit-learn metrics API 计算这三个指标以及分类精确率，我们还将计算三个不太常见但可能有用的附加指标。它们是:
 
 *   科恩的卡帕
 *   中华民国
@@ -424,7 +424,7 @@ matrix = confusion_matrix(testy, yhat_classes)
 print(matrix)
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例准备数据集，拟合模型，然后计算并报告在测试数据集上评估的模型的度量。
 
@@ -474,7 +474,7 @@ ROC AUC: 0.923739
 
 *   如何使用 scikit-learn metrics API 评估深度学习模型？
 *   如何用 scikit-learn API 要求的最终模型进行类和概率预测。
-*   如何用 scikit-learn API 为一个模型计算精度、召回率、F1-score、ROC、AUC 等。
+*   如何用 scikit-learn API 为一个模型计算精确率、召回率、F1-score、ROC、AUC 等。
 
 你有什么问题吗？
 在下面的评论中提问，我会尽力回答。
\ No newline at end of file

trans/keras/how-to-prepare-categorical-data-for-deep-learning-in-python.md

-# 深度学习分类变量的 3 种编码方式
+# 深度学习类别变量的 3 种编码方式
 
 > 原文：<https://machinelearningmastery.com/how-to-prepare-categorical-data-for-deep-learning-in-python/>
 
@@ -15,8 +15,8 @@
 完成本教程后，您将知道:
 
 *   使用机器学习和深度学习模型时处理分类数据的挑战。
-*   如何对建模的分类变量进行整数编码和热编码？
-*   如何学习嵌入分布式表示作为分类变量神经网络的一部分。
+*   如何对建模的类别变量进行整数编码和热编码？
+*   如何学习嵌入分布式表示作为类别变量神经网络的一部分。
 
 **用我的新书[用 Python 深度学习](https://machinelearningmastery.com/deep-learning-with-python/)来启动你的项目**，包括*分步教程*和所有示例的 *Python 源代码*文件。
 
@@ -39,7 +39,7 @@
 
 ## 分类数据的挑战
 
-分类变量是其值具有标签值的变量。
+类别变量是其值具有标签值的变量。
 
 例如，变量可以是“*颜色*”，可以取值“*红色*”、“*绿色*”和“*蓝色*
 
@@ -49,7 +49,7 @@
 
 这意味着分类数据必须编码成数字，然后我们才能使用它来拟合和评估模型。
 
-有许多方法可以为建模编码分类变量，尽管最常见的有以下三种:
+有许多方法可以为建模编码类别变量，尽管最常见的有以下三种:
 
 1.  **整数编码**:每个唯一的标签映射到一个整数。
 2.  **一个热编码**:每个标签映射到一个二进制向量。
@@ -334,9 +334,9 @@ print('Accuracy: %.2f' % (accuracy*100))
 
 在任何现代硬件(不需要图形处理器)上运行该示例只需几秒钟即可适应该模型。
 
-在每个训练时期结束时报告模型的损失和精度，最后报告模型在测试数据集上的精度。
+在每个训练时期结束时报告模型的损失和精确率，最后报告模型在测试数据集上的精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型在测试数据集上达到了大约 70%的准确率。
 
@@ -368,7 +368,7 @@ Accuracy: 70.53
 
 单一热编码适用于类别之间不存在关系的分类数据。
 
-它包括用二进制向量表示每个分类变量，每个唯一标签有一个元素，用 1 标记类标签，所有其他元素为 0。
+它包括用二进制向量表示每个类别变量，每个唯一标签有一个元素，用 1 标记类标签，所有其他元素为 0。
 
 例如，如果我们的变量是“ *color* ”，标签是“ *red* ”、“ *green* ”和“ *blue* ”，我们将这些标签中的每一个编码为三元素二进制向量，如下所示:
 
@@ -376,7 +376,7 @@ Accuracy: 70.53
 *   绿色:[0，1，0]
 *   蓝色:[0，0，1]
 
-然后，数据集中的每个标签将被替换为一个向量(一列变成三列)。这是对所有分类变量进行的，因此在乳腺癌数据集的情况下，我们的九个输入变量或列变为 43。
+然后，数据集中的每个标签将被替换为一个向量(一列变成三列)。这是对所有类别变量进行的，因此在乳腺癌数据集的情况下，我们的九个输入变量或列变为 43。
 
 scikit-learn 库提供了 [OneHotEncoder](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html) 来自动对一个或多个变量进行热编码。
 
@@ -457,11 +457,11 @@ print('Accuracy: %.2f' % (accuracy*100))
 
 示例 one hot 对输入分类数据进行了编码，标签也对目标变量进行了编码，就像我们在上一节中所做的那样。然后在准备好的数据集上拟合相同的神经网络模型。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，模型表现相当好，达到了大约 72%的准确率，接近上一节看到的结果。
 
-更公平的比较是将每个配置运行 10 或 30 次，并使用平均精度来比较性能。回想一下，在本教程中，我们更关注如何对分类数据进行编码，而不是在这个特定的数据集上获得最佳分数。
+更公平的比较是将每个配置运行 10 或 30 次，并使用平均精确率来比较性能。回想一下，在本教程中，我们更关注如何对分类数据进行编码，而不是在这个特定的数据集上获得最佳分数。
 
 ```py
 ...
@@ -505,7 +505,7 @@ Accuracy: 72.63
 
 *   [如何使用单词嵌入层对 Keras 进行深度学习](https://machinelearningmastery.com/use-word-embedding-layers-deep-learning-keras/)
 
-每个分类变量需要一个嵌入层，嵌入期望类别是有序编码的，尽管类别之间没有关系。
+每个类别变量需要一个嵌入层，嵌入期望类别是有序编码的，尽管类别之间没有关系。
 
 每个嵌入还需要用于分布式表示(向量空间)的维数。在自然语言应用程序中，使用 50、100 或 300 维是很常见的。对于我们的小例子，我们将维数固定为 10，但这是任意的；你应该用其他价值观来做实验。
 
@@ -684,7 +684,7 @@ print('Accuracy: %.2f' % (accuracy*100))
 
 运行该示例如上所述准备数据，拟合模型，并报告性能。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，模型表现相当好，与我们在前面部分看到的一个热编码相匹配。
 
@@ -716,7 +716,7 @@ Accuracy: 72.63
 
 [![Plot of the Model Architecture With Separate Inputs and Embeddings for each Categorical Variable](img/e0573e236a4131666d033bd273a655f4.png)](https://machinelearningmastery.com/wp-content/uploads/2019/09/Plot-of-the-Model-Architecture-with-Separate-Inputs-and-Embeddings-for-each-Categorical-Variable.png)
 
-每个分类变量有单独输入和嵌入的模型架构图
+每个类别变量有单独输入和嵌入的模型架构图
 点击放大。
 
 ## 常见问题
@@ -777,8 +777,8 @@ Accuracy: 72.63
 具体来说，您了解到:
 
 *   使用机器学习和深度学习模型时处理分类数据的挑战。
-*   如何对建模的分类变量进行整数编码和热编码？
-*   如何学习嵌入分布式表示作为分类变量神经网络的一部分。
+*   如何对建模的类别变量进行整数编码和热编码？
+*   如何学习嵌入分布式表示作为类别变量神经网络的一部分。
 
 你有什么问题吗？
 在下面的评论中提问，我会尽力回答。
\ No newline at end of file

trans/keras/multi-label-classification-with-deep-learning.md

-# 深度学习多标签分类
+# 深度学习的多标签分类
 
 > 原文：<https://machinelearningmastery.com/multi-label-classification-with-deep-learning/>
 
@@ -144,7 +144,7 @@ def get_model(n_inputs, n_outputs):
 
 考虑到这一点，我们将使用 10 倍和 3 倍重复的重复 k 倍交叉验证来评估多输出回归任务的 MLP 模型。
 
-默认情况下，MLP 模型将预测每个类别标签的概率。这意味着它将为每个样本预测三种概率。通过将这些值舍入为 0 或 1，可以将其转换为清晰的类标签。然后，我们可以计算清晰类别标签的分类精度。
+默认情况下，MLP 模型将预测每个类别标签的概率。这意味着它将为每个样本预测三种概率。通过将这些值舍入为 0 或 1，可以将其转换为清晰的类标签。然后，我们可以计算清晰类别标签的分类精确率。
 
 ```py
 ...
@@ -251,9 +251,9 @@ print('Accuracy: %.3f (%.3f)' % (mean(results), std(results)))
 
 运行该示例会报告每个折叠和每个重复的分类准确性，从而给出评估进度的想法。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-最后，报告了平均值和标准偏差的准确性。在这种情况下，模型显示达到了大约 81.2%的精度。
+最后，报告了平均值和标准偏差的准确性。在这种情况下，模型显示达到了大约 81.2%的精确率。
 
 您可以使用此代码作为模板，在自己的多标签分类任务中评估 MLP 模型。模型中节点和图层的数量可以根据数据集的复杂性轻松调整和定制。
 

trans/keras/neural-network-for-banknote-authentication.md

@@ -199,7 +199,7 @@ model.compile(optimizer='adam', loss='binary_crossentropy')
 history = model.fit(X_train, y_train, epochs=50, batch_size=32, verbose=0, validation_data=(X_test,y_test))
 ```
 
-在训练结束时，我们将评估模型在测试数据集上的性能，并将性能报告为分类精度。
+在训练结束时，我们将评估模型在测试数据集上的性能，并将性能报告为分类精确率。
 
 ```py
 ...
@@ -273,11 +273,11 @@ pyplot.legend()
 pyplot.show()
 ```
 
-运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告分类精度。
+运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-在这种情况下，我们可以看到模型达到了 100%的高精度或完美精度。这可能表明预测问题很容易，和/或神经网络很适合这个问题。
+在这种情况下，我们可以看到模型达到了 100%的高精确率或完美精确率。这可能表明预测问题很容易，和/或神经网络很适合这个问题。
 
 ```py
 Accuracy: 1.000
@@ -373,11 +373,11 @@ for train_ix, test_ix in kfold.split(X, y):
 print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 ```
 
-运行该示例会报告评估程序每次迭代的模型性能，并在运行结束时报告分类精度的平均值和标准偏差。
+运行该示例会报告评估程序每次迭代的模型性能，并在运行结束时报告分类精确率的平均值和标准偏差。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-在这种情况下，我们可以看到 MLP 模型达到了大约 99.9%的平均精度。
+在这种情况下，我们可以看到 MLP 模型达到了大约 99.9%的平均精确率。
 
 这证实了我们的期望，即基本模型配置对于这个数据集非常有效，并且实际上模型非常适合这个问题，并且这个问题可能很难解决。
 
@@ -506,7 +506,7 @@ print('Predicted: %s' % (yhat[0]))
 
 运行该示例使模型适合整个数据集，并对单行新数据进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型为输入行预测了一个“0”标签。
 

trans/keras/neural-network-for-cancer-survival-dataset.md

-# 为癌症生存数据集开发神经网络
+# 为癌症存活数据集开发神经网络
 
 > 原文：<https://machinelearningmastery.com/neural-network-for-cancer-survival-dataset/>
 
@@ -8,11 +8,11 @@
 
 该过程可用于开发用于分类和回归预测建模问题的有效神经网络模型。
 
-在本教程中，您将发现如何为癌症生存二元分类数据集开发多层感知器神经网络模型。
+在本教程中，您将发现如何为癌症存活二元分类数据集开发多层感知器神经网络模型。
 
 完成本教程后，您将知道:
 
-*   如何加载和总结癌症生存数据集，并使用结果建议数据准备和模型配置使用。
+*   如何加载和总结癌症存活数据集，并使用结果建议数据准备和模型配置使用。
 *   如何探索数据集上简单 MLP 模型的学习动态。
 *   如何对模型性能进行稳健的估计，调整模型性能并对新数据进行预测。
 
@@ -20,19 +20,19 @@
 
 ![Develop a Neural Network for Cancer Survival Dataset](img/79ccd8569f154da92b3b3e8b26672a47.png)
 
-为癌症生存数据集开发神经网络
+为癌症存活数据集开发神经网络
 图片由[贝恩德·泰勒](https://flickr.com/photos/bernd_thaller/47315883761/)提供，保留部分权利。
 
 ## 教程概述
 
 本教程分为 4 个部分；它们是:
 
-1.  哈贝曼乳腺癌生存数据集
+1.  哈贝曼乳腺癌存活数据集
 2.  神经网络学习动力学
 3.  稳健模型评估
 4.  最终模型和做出预测
 
-## 哈贝曼乳腺癌生存数据集
+## 哈贝曼乳腺癌存活数据集
 
 第一步是定义和探索数据集。
 
@@ -50,7 +50,7 @@
 
 因此，除了数据集中可用的情况之外，我们无法控制组成数据集的情况或在这些情况下使用的要素的选择。
 
-尽管数据集描述了乳腺癌患者的生存率，但鉴于数据集规模较小，并且数据基于几十年前的乳腺癌诊断和手术，因此任何基于该数据集构建的模型都不可一概而论。
+尽管数据集描述了乳腺癌患者的存活率，但鉴于数据集规模较小，并且数据基于几十年前的乳腺癌诊断和手术，因此任何基于该数据集构建的模型都不可一概而论。
 
 **注:说得再清楚不过**了，我们是不是“*解决乳腺癌*”。我们正在探索一个标准的分类数据集。
 
@@ -67,8 +67,8 @@
 
 您可以在此了解有关数据集的更多信息:
 
-*   [哈贝曼生存数据集(haberman.csv)](https://github.com/jbrownlee/Datasets/blob/master/haberman.csv)
-*   [哈贝曼生存数据集详情(哈贝曼. name)](https://github.com/jbrownlee/Datasets/blob/master/haberman.names)
+*   [哈贝曼存活数据集(haberman.csv)](https://github.com/jbrownlee/Datasets/blob/master/haberman.csv)
+*   [哈贝曼存活数据集详情(哈贝曼. name)](https://github.com/jbrownlee/Datasets/blob/master/haberman.names)
 
 我们可以直接从网址将数据集加载为熊猫数据帧；例如:
 
@@ -136,7 +136,7 @@ max     83.000000   69.000000   52.000000    2.000000
 
 ![Histograms of the Haberman Breast Cancer Survival Classification Dataset](img/eac089342cd334e5b9ecb1b6c9e94021.png)
 
-哈贝曼乳腺癌生存分类数据集的直方图
+哈贝曼乳腺癌存活分类数据集的直方图
 
 我们可以看到两个类之间的例子分布有些偏斜，这意味着分类问题是不平衡的。这是不平衡的。
 
@@ -166,7 +166,7 @@ for k,v in counter.items():
 
 运行该示例总结了数据集的类分布。
 
-我们可以看到生存类 1 在 225 处有最多的例子，大约占数据集的 74%。我们可以看到非存活类 2 的例子更少，只有 81 个，约占数据集的 26%。
+我们可以看到存活类 1 在 225 处有最多的例子，大约占数据集的 74%。我们可以看到非存活类 2 的例子更少，只有 81 个，约占数据集的 26%。
 
 阶级分布是倾斜的，但并不严重不平衡。
 
@@ -175,7 +175,7 @@ Class=1, Count=225, Percentage=73.529%
 Class=2, Count=81, Percentage=26.471%
 ```
 
-这是有帮助的，因为如果我们使用分类精度，那么任何达到低于约 73.5%精度的模型都不具备在这个数据集上的技能。
+这是有帮助的，因为如果我们使用分类精确率，那么任何达到低于约 73.5%精确率的模型都不具备在这个数据集上的技能。
 
 现在我们已经熟悉了数据集，让我们探索如何开发一个神经网络模型。
 
@@ -239,7 +239,7 @@ model.compile(optimizer='adam', loss='binary_crossentropy')
 history = model.fit(X_train, y_train, epochs=200, batch_size=16, verbose=0, validation_data=(X_test,y_test))
 ```
 
-在训练结束时，我们将评估模型在测试数据集上的性能，并将性能报告为分类精度。
+在训练结束时，我们将评估模型在测试数据集上的性能，并将性能报告为分类精确率。
 
 ```py
 ...
@@ -264,7 +264,7 @@ pyplot.legend()
 pyplot.show()
 ```
 
-将所有这些结合起来，下面列出了在癌症生存数据集上评估我们的第一个 MLP 的完整示例。
+将所有这些结合起来，下面列出了在癌症存活数据集上评估我们的第一个 MLP 的完整示例。
 
 ```py
 # fit a simple mlp model on the haberman and review learning curves
@@ -311,7 +311,7 @@ pyplot.legend()
 pyplot.show()
 ```
 
-运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告分类精度。
+运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告分类精确率。
 
 **用我的新书[机器学习的数据准备](https://machinelearningmastery.com/data-preparation-for-machine-learning/)启动你的项目**，包括*分步教程*和所有示例的 *Python 源代码*文件。
 
@@ -327,7 +327,7 @@ Accuracy: 0.765
 
 ![Learning Curves of Simple Multilayer Perceptron on Cancer Survival Dataset](img/4520a0264ac7035bbb20444496ffe4b9.png)
 
-癌症生存数据集上简单多层感知器的学习曲线
+癌症存活数据集上简单多层感知器的学习曲线
 
 现在，我们已经对数据集上的简单 MLP 模型的学习动态有了一些了解，我们可以考虑对数据集上的模型性能进行更稳健的评估。
 
@@ -335,7 +335,7 @@ Accuracy: 0.765
 
 k 倍交叉验证程序可以提供更可靠的 MLP 性能估计，尽管它可能非常慢。
 
-这是因为 k 模型必须被拟合和评估。当数据集规模较小时，例如癌症生存数据集，这不是问题。
+这是因为 k 模型必须被拟合和评估。当数据集规模较小时，例如癌症存活数据集，这不是问题。
 
 我们可以使用[stratifiedfold](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.StratifiedKFold.html)类手动枚举每个折叠，拟合模型，对其进行评估，然后在程序结束时报告评估分数的平均值。
 
@@ -408,11 +408,11 @@ for train_ix, test_ix in kfold.split(X, y):
 print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 ```
 
-运行该示例会报告评估程序每次迭代的模型性能，并在运行结束时报告分类精度的平均值和标准偏差。
+运行该示例会报告评估程序每次迭代的模型性能，并在运行结束时报告分类精确率的平均值和标准偏差。
 
 **用我的新书[机器学习的数据准备](https://machinelearningmastery.com/data-preparation-for-machine-learning/)启动你的项目**，包括*分步教程*和所有示例的 *Python 源代码*文件。
 
-在这种情况下，我们可以看到 MLP 模型获得了大约 75.2%的平均精度，这与我们在前面部分中的粗略估计非常接近。
+在这种情况下，我们可以看到 MLP 模型获得了大约 75.2%的平均精确率，这与我们在前面部分中的粗略估计非常接近。
 
 这证实了我们的预期，即对于这个数据集，基本模型配置可能比简单模型工作得更好
 
@@ -555,7 +555,7 @@ Predicted: 1
 
 ### 教程
 
-*   [如何建立乳腺癌患者生存概率模型](https://machinelearningmastery.com/how-to-develop-a-probabilistic-model-of-breast-cancer-patient-survival/)
+*   [如何建立乳腺癌患者存活概率模型](https://machinelearningmastery.com/how-to-develop-a-probabilistic-model-of-breast-cancer-patient-survival/)
 *   [如何开发预测电离层扰动的神经网络](https://machinelearningmastery.com/predicting-disturbances-in-the-ionosphere/)
 *   [标准机器学习数据集的最佳结果](https://machinelearningmastery.com/results-for-standard-classification-and-regression-machine-learning-datasets/)
 *   [TensorFlow 2 教程:使用 tf.keras 开始深度学习](https://machinelearningmastery.com/tensorflow-tutorial-deep-learning-with-tf-keras/)
@@ -563,11 +563,11 @@ Predicted: 1
 
 ## 摘要
 
-在本教程中，您发现了如何为癌症生存二元分类数据集开发多层感知器神经网络模型。
+在本教程中，您发现了如何为癌症存活二元分类数据集开发多层感知器神经网络模型。
 
 具体来说，您了解到:
 
-*   如何加载和总结癌症生存数据集，并使用结果建议数据准备和模型配置使用。
+*   如何加载和总结癌症存活数据集，并使用结果建议数据准备和模型配置使用。
 *   如何探索数据集上简单 MLP 模型的学习动态。
 *   如何对模型性能进行稳健的估计，调整模型性能并对新数据进行预测。
 

trans/keras/neural-network-models-for-combined-classification-and-regression.md

@@ -225,7 +225,7 @@ print('MAE: %.3f' % error)
 
 运行该示例将准备数据集，拟合模型，并报告模型误差的估计值。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型实现了大约 1.5(环)的误差。
 
@@ -288,7 +288,7 @@ model.add(Dense(n_class, activation='softmax'))
 model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')
 ```
 
-如前所述，在将模型拟合到训练数据集上之后，我们可以通过计算保持测试集上的分类精度来评估模型的性能。
+如前所述，在将模型拟合到训练数据集上之后，我们可以通过计算保持测试集上的分类精确率来评估模型的性能。
 
 ```py
 ...
@@ -342,7 +342,7 @@ print('Accuracy: %.3f' % acc)
 
 运行该示例将准备数据集，拟合模型，并报告模型误差的估计值。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型达到了大约 27%的准确率。
 
@@ -482,7 +482,7 @@ error = mean_absolute_error(y_test, yhat1)
 print('MAE: %.3f' % error)
 ```
 
-第二阵列可用于通过分类精度评估分类预测。
+第二阵列可用于通过分类精确率评估分类预测。
 
 ```py
 ...
@@ -551,7 +551,7 @@ print('Accuracy: %.3f' % acc)
 
 运行该示例将准备数据集，拟合模型，并报告模型误差的估计值。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 创建多输出模型的图，清楚地显示连接到模型的第二个隐藏层的回归(左)和分类(右)输出层。
 
@@ -559,7 +559,7 @@ print('Accuracy: %.3f' % acc)
 
 用于组合回归和分类预测的多输出模型图
 
-在这种情况下，我们可以看到该模型实现了大约 1.495(环)的合理误差和大约 25.6%的类似精度。
+在这种情况下，我们可以看到该模型实现了大约 1.495(环)的合理误差和大约 25.6%的类似精确率。
 
 ```py
 ...

trans/keras/neural-networks-are-function-approximators.md

-# 神经网络是函数逼近算法
+# 神经网络是函数近似算法
 
 > 原文：<https://machinelearningmastery.com/neural-networks-are-function-approximators/>
 
 最后更新于 2020 年 8 月 27 日
 
-机器学习中的监督学习可以用函数逼近来描述。
+机器学习中的监督学习可以用函数近似来描述。
 
 给定一个由输入和输出组成的数据集，我们假设有一个未知的底层函数，它在目标域中将输入映射到输出并生成数据集时是一致的。然后我们使用监督学习算法来近似这个函数。
 
-神经网络是有监督的机器学习算法的一个例子，也许在函数逼近的背景下最容易理解。这可以通过神经网络逼近简单的一维函数的例子来证明，这有助于培养对模型所学内容的直觉。
+神经网络是有监督的机器学习算法的一个例子，也许在函数近似的背景下最容易理解。这可以通过神经网络近似简单的一维函数的例子来证明，这有助于培养对模型所学内容的直觉。
 
-在本教程中，您将发现神经网络作为函数逼近算法背后的直觉。
+在本教程中，您将发现神经网络作为函数近似算法背后的直觉。
 
 完成本教程后，您将知道:
 
 *   在数据上训练神经网络近似于从输入到输出的未知底层映射函数。
-*   一维输入输出数据集为开发函数逼近的直观性提供了有用的基础。
-*   如何开发和评估用于函数逼近的小型神经网络？
+*   一维输入输出数据集为开发函数近似的直观性提供了有用的基础。
+*   如何开发和评估用于函数近似的小型神经网络？
 
 **用我的新书[用 Python 深度学习](https://machinelearningmastery.com/deep-learning-with-python/)来启动你的项目**，包括*分步教程*和所有示例的 *Python 源代码*文件。
 
@@ -24,28 +24,28 @@
 
 ![Neural Networks are Function Approximators](img/2bef59c836a3ea770b2973a3062fed73.png)
 
-神经网络是函数逼近算法
+神经网络是函数近似算法
 图片由[达维宁](https://flickr.com/photos/daveynin/6281062965/)提供，版权所有。
 
 ## 教程概述
 
 本教程分为三个部分；它们是:
 
-1.  什么是函数逼近
+1.  什么是函数近似
 2.  简单函数的定义
-3.  逼近简单函数
+3.  近似简单函数
 
-## 什么是函数逼近
+## 什么是函数近似
 
-[函数逼近](https://en.wikipedia.org/wiki/Function_approximation)是一种使用来自域的历史或可用观测值来估计未知基础函数的技术。
+[函数近似](https://en.wikipedia.org/wiki/Function_approximation)是一种使用来自域的历史或可用观测值来估计未知基础函数的技术。
 
-人工神经网络学习逼近一个函数。
+人工神经网络学习近似一个函数。
 
 在监督学习中，数据集由输入和输出组成，监督学习算法学习如何最好地将输入示例映射到输出示例。
 
-我们可以把这个映射看作是由一个数学函数支配的，这个函数叫做**映射函数**，监督学习算法试图最好地逼近的就是这个函数。
+我们可以把这个映射看作是由一个数学函数支配的，这个函数叫做**映射函数**，监督学习算法试图最好地近似的就是这个函数。
 
-神经网络是监督学习算法的一个例子，它试图逼近你的数据所代表的函数。这是通过计算预测输出和预期输出之间的误差并在训练过程中最小化该误差来实现的。
+神经网络是监督学习算法的一个例子，它试图近似你的数据所代表的函数。这是通过计算预测输出和预期输出之间的误差并在训练过程中最小化该误差来实现的。
 
 > 最好将前馈网络视为功能近似机器，旨在实现统计泛化，偶尔从我们对大脑的了解中获得一些见解，而不是将其视为大脑功能的模型。
 
@@ -53,16 +53,16 @@
 
 我们说“*近似*”是因为虽然我们怀疑这样的映射函数存在，但我们对此一无所知。
 
-将输入映射到输出的真实函数是未知的，通常被称为**目标函数**。这是学习过程的目标，也是我们试图仅使用可用数据来近似的功能。如果我们知道目标函数，我们就不需要近似它，也就是说，我们不需要有监督的机器学习算法。因此，当底层目标映射函数未知时，函数逼近只是一个有用的工具。
+将输入映射到输出的真实函数是未知的，通常被称为**目标函数**。这是学习过程的目标，也是我们试图仅使用可用数据来近似的功能。如果我们知道目标函数，我们就不需要近似它，也就是说，我们不需要有监督的机器学习算法。因此，当底层目标映射函数未知时，函数近似只是一个有用的工具。
 
 我们所拥有的只是来自包含输入和输出示例的领域的观察。这意味着数据的大小和质量；例如:
 
 *   我们拥有的例子越多，我们就越能理解映射函数。
-*   观测中的噪声越小，我们对映射函数的逼近就越清晰。
+*   观测中的噪声越小，我们对映射函数的近似就越清晰。
 
-那么为什么我们喜欢用神经网络进行函数逼近呢？
+那么为什么我们喜欢用神经网络进行函数近似呢？
 
-原因是他们是**通用逼近器**。理论上，它们可以用来逼近任何函数。
+原因是他们是**通用近似器**。理论上，它们可以用来近似任何函数。
 
 > ……通用近似定理指出，具有线性输出层和至少一个具有任何“挤压”激活函数(如逻辑 sigmoid 激活函数)的隐藏层的前馈网络可以用任何期望的非零误差量近似从一个有限维空间到另一个有限维空间的任何[…]函数，前提是网络被给予足够的隐藏单元
 
@@ -70,7 +70,7 @@
 
 回归预测建模包括预测给定输入的数值。分类预测建模包括预测给定输入的类别标签。
 
-这两个预测建模问题都可以看作是函数逼近的例子。
+这两个预测建模问题都可以看作是函数近似的例子。
 
 为了使这一点具体化，我们可以回顾一个工作的例子。
 
@@ -78,7 +78,7 @@
 
 ## 简单函数的定义
 
-我们可以定义一个具有一个数值输入变量和一个数值输出变量的简单函数，并以此作为理解函数逼近的神经网络的基础。
+我们可以定义一个具有一个数值输入变量和一个数值输出变量的简单函数，并以此作为理解函数近似的神经网络的基础。
 
 我们可以定义一个数字域作为我们的输入，比如从-50 到 50 的浮点值。
 
@@ -121,7 +121,7 @@ pyplot.show()
 
 接下来，我们可以假装忘记我们知道映射函数是什么，并使用神经网络来重新学习或重新发现映射函数。
 
-## 逼近简单函数
+## 近似简单函数
 
 我们可以在输入和输出的例子上拟合神经网络模型，看看该模型是否能够学习映射函数。
 
@@ -179,7 +179,7 @@ model.add(Dense(1))
 
 我们将使用均方损失来拟合模型，并使用随机梯度下降的有效 adam 版本来优化模型。
 
-这意味着模型在试图逼近映射函数时，将寻求最小化预测值和预期输出值( *y* )之间的均方误差。
+这意味着模型在试图近似映射函数时，将寻求最小化预测值和预期输出值( *y* )之间的均方误差。
 
 ```py
 ...
@@ -301,7 +301,7 @@ pyplot.show()
 
 然后在数据集上拟合和评估模型。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到均方误差约为 1，300，单位为平方。如果我们计算平方根，这就给出了以原始单位表示的均方根误差(RMSE)。我们可以看到平均误差在 36 个单位左右，这是可以的，但不是很大。
 
@@ -318,7 +318,7 @@ MSE: 1300.776
 
 这两个数据系列之间的区别在于映射函数近似的误差。我们可以看出近似是合理的；它捕捉到了大致的形状。我们可以看到有错误，尤其是在 0 输入值附近。
 
-这表明还有很大的改进空间，例如使用不同的激活函数或不同的网络架构来更好地逼近映射函数。
+这表明还有很大的改进空间，例如使用不同的激活函数或不同的网络架构来更好地近似映射函数。
 
 ![Scatter Plot of Input vs. Actual and Predicted Values for the Neural Net Approximation](img/0ec7fad50c41d4d749a88b73c00364ce.png)
 
@@ -338,17 +338,17 @@ MSE: 1300.776
 
 #### 文章
 
-*   [函数逼近，维基百科](https://en.wikipedia.org/wiki/Function_approximation)。
+*   [函数近似，维基百科](https://en.wikipedia.org/wiki/Function_approximation)。
 
 ## 摘要
 
-在本教程中，您发现了神经网络作为函数逼近算法背后的直觉。
+在本教程中，您发现了神经网络作为函数近似算法背后的直觉。
 
 具体来说，您了解到:
 
 *   在数据上训练神经网络近似于从输入到输出的未知底层映射函数。
-*   一维输入输出数据集为开发函数逼近的直观性提供了有用的基础。
-*   如何开发和评估用于函数逼近的小型神经网络？
+*   一维输入输出数据集为开发函数近似的直观性提供了有用的基础。
+*   如何开发和评估用于函数近似的小型神经网络？
 
 你有什么问题吗？
 在下面的评论中提问，我会尽力回答。
\ No newline at end of file

trans/keras/predicting-car-insurance-payout.md

@@ -245,7 +245,7 @@ pyplot.show()
 
 运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告 MAE。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型实现了大约 33.2 的 MAE，这是一个很好的性能基线，我们可能可以在此基础上进行改进。
 
@@ -323,7 +323,7 @@ pyplot.show()
 
 运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告 MAE。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到 MAE 略有提高，约为 27.9，尽管列车/测试分割的高方差意味着这种评估不可靠。
 
@@ -441,7 +441,7 @@ pyplot.show()
 
 运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告 MAE。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，该模型获得了合理的 MAE 分数，尽管比以前报告的性能差。我们将暂时忽略模型性能。
 
@@ -530,7 +530,7 @@ print('Mean MAE: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 运行该示例会报告评估程序每次迭代的模型性能，并在运行结束时报告 MAE 的平均值和标准偏差。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到 MLP 模型实现了大约 38.913 的 MAE。
 
@@ -612,7 +612,7 @@ print('Mean MAE: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 运行报告运行结束时的平均和标准偏差。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到 MLP 模型实现了大约 35.384 的 MAE，这比基线模型实现了大约 38.913 的 MAE 稍好。
 
@@ -685,7 +685,7 @@ print('Mean MAE: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 运行报告运行结束时的平均和标准偏差。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到 MLP 模型实现了大约 37.371 的 MAE，比基线模型好，但并不比更深的基线模型好。
 
@@ -776,7 +776,7 @@ print('Mean MAE: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 运行报告运行结束时的平均和标准偏差。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到 MLP 模型实现了大约 30.388 的 MAE，这比我们迄今为止尝试的任何其他配置都要好。
 
@@ -918,7 +918,7 @@ print('f(%s) = %.3f' % (row, yhat[0]))
 
 运行该示例使模型适合整个数据集，并对单行新数据进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到输入 13 导致输出 62(千瑞典克朗)。
 

trans/keras/predicting-disturbances-in-the-ionosphere.md

@@ -188,7 +188,7 @@ model.compile(optimizer='adam', loss='binary_crossentropy')
 history = model.fit(X_train, y_train, epochs=200, batch_size=32, verbose=0, validation_data=(X_test,y_test))
 ```
 
-在训练结束时，我们将评估模型在测试数据集上的性能，并将性能报告为分类精度。
+在训练结束时，我们将评估模型在测试数据集上的性能，并将性能报告为分类精确率。
 
 ```py
 ...
@@ -260,9 +260,9 @@ pyplot.legend()
 pyplot.show()
 ```
 
-运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告分类精度。
+运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型达到了大约 88%的准确率，这是一个很好的性能基线，我们或许可以在此基础上进行改进。
 
@@ -340,9 +340,9 @@ pyplot.plot(history.history['val_loss'], label='val')
 pyplot.legend()
 ```
 
-运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告精度。
+运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到准确率略有提高，约为 93%，尽管训练/测试分割的高方差意味着该评估不可靠。
 
@@ -427,9 +427,9 @@ pyplot.legend()
 pyplot.show()
 ```
 
-运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告精度。
+运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，模型获得了更好的准确性分数，其值约为 94%。我们将暂时忽略模型性能。
 
@@ -522,11 +522,11 @@ for train_ix, test_ix in kfold.split(X, y):
 print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 ```
 
-运行该示例会报告评估程序每次迭代的模型性能，并在运行结束时报告分类精度的平均值和标准偏差。
+运行该示例会报告评估程序每次迭代的模型性能，并在运行结束时报告分类精确率的平均值和标准偏差。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-在这种情况下，我们可以看到 MLP 模型达到了大约 93.4%的平均精度。
+在这种情况下，我们可以看到 MLP 模型达到了大约 93.4%的平均精确率。
 
 我们将使用这个结果作为我们的基线，看看我们是否可以实现更好的性能。
 
@@ -614,7 +614,7 @@ print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 运行报告运行结束时分类准确度的平均值和标准偏差。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到，有辍学的 MLP 模型取得了更好的结果，准确率约为 94.6%，而没有辍学的准确率为 93.4%
 
@@ -687,7 +687,7 @@ print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 运行报告运行结束时分类准确度的平均值和标准偏差。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到，带有脱落的 MLP 模型获得了稍好的结果，准确率约为 94.9%。
 
@@ -815,7 +815,7 @@ print('Predicted: %s' % (yhat[0]))
 
 运行该示例使模型适合整个数据集，并对单行新数据进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型为输入行预测了一个“g”标签。
 

trans/keras/prediction-intervals-for-deep-learning-neural-networks.md

@@ -264,7 +264,7 @@ print('MAE: %.3f' % mae)
 
 运行该示例加载和准备数据集，在训练数据集上定义和拟合 MLP 模型，并在测试集上评估其性能。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到，该模型实现了大约 2.3 的平均绝对误差，这优于天真模型，并接近最佳模型。
 
@@ -506,7 +506,7 @@ print('True value: %.3f' % y_test[0])
 
 运行该示例依次适合每个集成成员，并在等待测试集上报告其估计性能；最后，作出并报告具有预测区间的单一预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到每个模型的性能略有不同，这证实了我们对模型确实不同的预期。
 

trans/keras/pytorch-tutorial-develop-deep-learning-models.md

@@ -564,13 +564,13 @@ print('Predicted: %.3f (class=%d)' % (yhat, yhat.round()))
 
 运行该示例首先报告训练和测试数据集的形状，然后拟合模型并在测试数据集上对其进行评估。最后，对单行数据进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 **你得到了什么结果？**
 **能不能换个模式做得更好？**
 将你的发现发布到下面的评论中。
 
-在这种情况下，我们可以看到模型达到了大约 94%的分类精度，然后预测一行数据属于类别 1 的概率为 0.99。
+在这种情况下，我们可以看到模型达到了大约 94%的分类精确率，然后预测一行数据属于类别 1 的概率为 0.99。
 
 ```py
 235 116
@@ -756,7 +756,7 @@ print('Predicted: %s (class=%d)' % (yhat, argmax(yhat)))
 
 运行该示例首先报告训练和测试数据集的形状，然后拟合模型并在测试数据集上对其进行评估。最后，对单行数据进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 **你得到了什么结果？
 能不能换个型号做得更好？**
@@ -783,7 +783,7 @@ Predicted: [[9.5524162e-01 4.4516966e-02 2.4138369e-04]] (class=0)
 
 这是一个涉及预测单个数值的回归问题。因此，输出层只有一个节点，并使用默认或线性激活函数(无激活函数)。拟合模型时，均方误差(mse)损失最小。
 
-回想一下，这是回归，不是分类；因此，我们无法计算分类精度。有关这方面的更多信息，请参见教程:
+回想一下，这是回归，不是分类；因此，我们无法计算分类精确率。有关这方面的更多信息，请参见教程:
 
 *   [机器学习中分类和回归的区别](https://machinelearningmastery.com/classification-versus-regression-in-machine-learning/)
 
@@ -941,7 +941,7 @@ print('Predicted: %.3f' % yhat)
 
 运行该示例首先报告训练和测试数据集的形状，然后拟合模型并在测试数据集上对其进行评估。最后，对单行数据进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 **你得到了什么结果？
 能不能换个型号做得更好？**
@@ -1158,7 +1158,7 @@ print('Accuracy: %.3f' % acc)
 
 运行该示例首先报告训练和测试数据集的形状，然后拟合模型并在测试数据集上对其进行评估。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 **你得到了什么结果？
 能不能换个型号做得更好？**

trans/keras/softmax-activation-function-with-python.md

@@ -193,7 +193,7 @@ print(result)
 print(sum(result))
 ```
 
-运行该示例会报告大致相同的数字，但精度略有差异。
+运行该示例会报告大致相同的数字，但精确率略有差异。
 
 ```py
 [0.09003057 0.66524096 0.24472847]
@@ -215,7 +215,7 @@ print(result)
 print(sum(result))
 ```
 
-再次运行该示例，我们得到了非常相似的结果，但精度差异很小。
+再次运行该示例，我们得到了非常相似的结果，但精确率差异很小。
 
 ```py
 [0.09003057 0.66524096 0.24472847]
@@ -263,7 +263,7 @@ model.add(Dense(3, activation='softmax'))
 
 它表示用于在监督学习下校正模型的每个类的期望多项式概率分布。
 
-softmax 函数将为每个类别标签输出类别成员的概率，并尝试为给定的输入最好地逼近预期目标。
+softmax 函数将为每个类别标签输出类别成员的概率，并尝试为给定的输入最好地近似预期目标。
 
 例如，如果在一个示例中需要整数编码的类 1，那么目标向量将是:
 

trans/keras/tensorflow-tutorial-deep-learning-with-tf-keras.md

-# TensorFlow 2 教程:使用 tf.keras 开始深度学习
+# TensorFlow 2 教程：使用`tf.keras`开始深度学习
 
 > 原文：<https://machinelearningmastery.com/tensorflow-tutorial-deep-learning-with-tf-keras/>
 
@@ -518,7 +518,7 @@ print('Predicted: %.3f' % yhat)
 
 运行该示例首先报告数据集的形状，然后拟合模型并在测试数据集上对其进行评估。最后，对单行数据进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 **你得到了什么结果？**能不能换个型号做得更好？
 将你的发现发布到下面的评论中。
@@ -588,7 +588,7 @@ print('Predicted: %s (class=%d)' % (yhat, argmax(yhat)))
 
 运行该示例首先报告数据集的形状，然后拟合模型并在测试数据集上对其进行评估。最后，对单行数据进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 **你得到了什么结果？**能不能换个型号做得更好？
 将你的发现发布到下面的评论中。
@@ -614,7 +614,7 @@ Predicted: [[0.8680804 0.12356871 0.00835086]] (class=0)
 
 这是一个涉及预测单个数值的回归问题。因此，输出层只有一个节点，并使用默认或线性激活函数(无激活函数)。拟合模型时，均方误差(mse)损失最小。
 
-回想一下，这是回归，不是分类；因此，我们无法计算分类精度。有关这方面的更多信息，请参见教程:
+回想一下，这是回归，不是分类；因此，我们无法计算分类精确率。有关这方面的更多信息，请参见教程:
 
 *   [机器学习中分类和回归的区别](https://machinelearningmastery.com/classification-versus-regression-in-machine-learning/)
 
@@ -657,7 +657,7 @@ print('Predicted: %.3f' % yhat)
 
 运行该示例首先报告数据集的形状，然后拟合模型并在测试数据集上对其进行评估。最后，对单行数据进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 **你得到了什么结果？**能不能换个型号做得更好？
 将你的发现发布到下面的评论中。
@@ -774,7 +774,7 @@ print('Predicted: class=%d' % argmax(yhat))
 
 运行该示例首先报告数据集的形状，然后拟合模型并在测试数据集上对其进行评估。最后，对单个图像进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 **你得到了什么结果？**能不能换个型号做得更好？
 将你的发现发布到下面的评论中。
@@ -895,7 +895,7 @@ print('Predicted: %.3f' % (yhat))
 
 运行该示例首先报告数据集的形状，然后拟合模型并在测试数据集上对其进行评估。最后，对一个实例进行了预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 **你得到了什么结果？**能不能换个型号做得更好？
 将你的发现发布到下面的评论中。

trans/linalg/principal-component-analysis-for-visualization.md

@@ -110,7 +110,7 @@ plt.show()
 
 ![](img/6f31f6d34775255afb14d78a6401d221.png)
 
-由于 PCA 对尺度敏感，如果我们通过`StandardScaler`对每个特征进行归一化，可以看到更好的结果。这里不同的阶层更有特色。通过查看此图，我们确信像 SVM 这样的简单模型可以高精度地对该数据集进行分类。
+由于 PCA 对尺度敏感，如果我们通过`StandardScaler`对每个特征进行归一化，可以看到更好的结果。这里不同的阶层更有特色。通过查看此图，我们确信像 SVM 这样的简单模型可以高精确率地对该数据集进行分类。
 
 将这些放在一起，下面是生成可视化的完整代码:
 
@@ -294,7 +294,7 @@ print(pca.explained_variance_ratio_)
 
 这里我们可以看到，第一个分量解释了 92.5%的方差，第二个分量解释了 5.3%的方差。如果我们去掉前两个主成分，剩余的方差只有 2.2%，因此从视觉上看，去掉两个成分后的图看起来像一条直线。事实上，当我们查看上面的图时，我们不仅看到点被粉碎，而且当我们移除组件时，x 轴和 y 轴的范围也变小了。
 
-在机器学习方面，我们可以考虑在这个数据集中只使用一个单一的特征进行分类，即第一主成分。使用全套功能时，我们应期望达到不低于 90%的原始精度:
+在机器学习方面，我们可以考虑在这个数据集中只使用一个单一的特征进行分类，即第一主成分。使用全套功能时，我们应期望达到不低于 90%的原始精确率:
 
 ```py
 ...

trans/lstm/learn-echo-random-integers-long-short-term-memory-recurrent-neural-networks.md

@@ -148,7 +148,7 @@ decoded = one_hot_decode(encoded)
 print(decoded)
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例首先打印 25 个随机整数的列表，然后是序列中所有整数的二进制表示的截断视图，每行一个向量，然后是解码后的序列。
 
@@ -214,7 +214,7 @@ def generate_data():
 
 输出层是一个完全连接的层(密集层)，对于可能输出的 100 个可能的整数，有 100 个神经元。输出层使用 softmax 激活函数，允许网络学习并输出可能输出值的分布。
 
-该网络在训练时将使用对数损失函数，适用于多类分类问题，以及高效的 ADAM 优化算法。精度度量将在每个训练时期报告，以便除了损失之外，还能了解模型的技能。
+该网络在训练时将使用对数损失函数，适用于多类分类问题，以及高效的 ADAM 优化算法。精确率度量将在每个训练时期报告，以便除了损失之外，还能了解模型的技能。
 
 ```py
 # define model
@@ -300,7 +300,7 @@ print('Predicted: %s' % one_hot_decode(yhat))
 
 运行该示例会打印每个时期的日志丢失和准确性。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 网络有点过了，内存单元和训练时期比这么简单的问题需要的多，你可以从网络很快达到 100%的准确率这一事实看出这一点。
 
@@ -432,7 +432,7 @@ for i in range(len(X)):
 
 运行该示例会打印问题框架的 X 和 y 部分。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 我们可以看到，考虑到冷启动，第一种模式对于网络来说很难(不可能)学会。我们可以通过数据看到 yhat(t)= X(t-1)的预期模式。
 
@@ -545,9 +545,9 @@ print('Predicted: %s' % one_hot_decode(yhat))
 
 运行这个例子给出了一个令人惊讶的结果。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-该问题无法学习，训练以模型结束，该模型以 0%的精度回应序列中的最后一个观察。
+该问题无法学习，训练以模型结束，该模型以 0%的精确率回应序列中的最后一个观察。
 
 ```py
 ...
@@ -797,7 +797,7 @@ print('Predicted: %s' % one_hot_decode(yhat))
 
 运行实例表明，该网络能够拟合问题，并正确地学习在 5 个先验观测值的背景下将 X(t-1)观测值作为预测值返回。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 输出示例如下。
 

trans/sklearn/auto-sklearn-for-automated-machine-learning-in-python.md

@@ -249,7 +249,7 @@ print("Accuracy: %.3f" % acc)
 
 考虑到我们对运行施加的硬性限制，运行该示例大约需要五分钟。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行结束时，会打印一份摘要，显示评估了 1，054 个模型，最终模型的估计性能为 91%。
 
@@ -364,7 +364,7 @@ print("MAE: %.3f" % mae)
 Target Algorithm returned NaN or inf as quality. Algorithm run is treated as CRASHED, cost is set to 1.0 for quality scenarios. (Change value through "cost_for_crash"-option.)
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行结束时，会打印一份摘要，显示评估了 1，759 个模型，最终模型的估计性能为 29 的 MAE。
 

trans/sklearn/calculate-the-bias-variance-trade-off.md

@@ -101,7 +101,7 @@
 
 因此，尽管我们可能能够将可约误差压缩到非常小的接近零的值，或者在某些情况下甚至为零，但我们也会有一些不可约误差。它定义了问题性能的下限。
 
-> 重要的是要记住，不可约误差总是为我们对 y 的预测精度提供一个上限。这个上限在实践中几乎总是未知的。
+> 重要的是要记住，不可约误差总是为我们对 y 的预测精确率提供一个上限。这个上限在实践中几乎总是未知的。
 
 —第 19 页，[R](https://amzn.to/2RC7ElX)中应用的统计学习介绍，2014。
 
@@ -187,7 +187,7 @@ print('Variance: %.3f' % var)
 
 运行该示例会报告估计误差以及模型误差的估计偏差和方差。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型具有高偏差和低方差。鉴于我们使用的是线性回归模型，这是可以预期的。我们还可以看到，估计的均值和方差之和等于模型的估计误差，例如 20.726 + 1.761 = 22.487。
 

trans/sklearn/gaussian-processes-for-classification-with-python.md

@@ -154,7 +154,7 @@ print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 鉴于学习算法的随机性，您的具体结果可能会有所不同。考虑运行这个例子几次。
 
-在这种情况下，我们可以看到模型实现了大约 79.0%的平均精度。
+在这种情况下，我们可以看到模型实现了大约 79.0%的平均精确率。
 
 ```py
 Mean Accuracy: 0.790 (0.101)
@@ -259,7 +259,7 @@ for mean, param in zip(means, params):
 
 鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。
 
-在这种情况下，我们可以看到*比率二次*内核以大约 91.3%的精度提升了性能，而上一节中的径向基函数内核达到了 79.0%。
+在这种情况下，我们可以看到*比率二次*内核以大约 91.3%的精确率提升了性能，而上一节中的径向基函数内核达到了 79.0%。
 
 ```py
 Best Mean Accuracy: 0.913

trans/sklearn/how-to-configure-k-fold-cross-validation.md

@@ -100,9 +100,9 @@ scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
 print('Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 ```
 
-运行该示例会创建数据集，然后使用 10 倍交叉验证对其进行逻辑回归模型评估。然后报告数据集的平均分类精度。
+运行该示例会创建数据集，然后使用 10 倍交叉验证对其进行逻辑回归模型评估。然后报告数据集的平均分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到该模型实现了大约 85.0%的估计分类准确率。
 
@@ -138,7 +138,7 @@ k-fold 交叉验证的关键配置参数是 k，它定义了分割给定数据
 
 相反，我们可以使用[省去一个交叉验证(LOOCV)](https://machinelearningmastery.com/loocv-for-evaluating-machine-learning-algorithms/) 来模拟这种情况，这是一个计算量很大的交叉验证版本，其中 *k=N* ，而 *N* 是训练数据集中的示例总数。也就是说，训练集中的每个样本都给出了一个单独用作测试评估数据集的示例。它很少用于大型数据集，因为它的计算成本很高，尽管在给定可用数据的情况下，它可以很好地估计模型性能。
 
-然后，我们可以将不同 k 值的平均分类精度与同一数据集上来自 LOOCV 的平均分类精度进行比较。分数之间的差异为 k 值接近理想模型评估测试条件的程度提供了一个粗略的代表。
+然后，我们可以将不同 k 值的平均分类精确率与同一数据集上来自 LOOCV 的平均分类精确率进行比较。分数之间的差异为 k 值接近理想模型评估测试条件的程度提供了一个粗略的代表。
 
 让我们探索如何实现 k 倍交叉验证的敏感性分析。
 
@@ -164,7 +164,7 @@ def get_model():
 
 接下来，您可以定义一个函数来评估给定测试条件下数据集上的模型。测试条件可以是配置了给定 k 值的 KFold 的实例，也可以是代表我们理想测试条件的 LeaveOneOut 的实例。
 
-该函数返回平均分类精度以及折叠的最小和最大精度。我们可以用最小值和最大值来总结分数的分布。
+该函数返回平均分类精确率以及折叠的最小和最大精确率。我们可以用最小值和最大值来总结分数的分布。
 
 ```py
 # evaluate the model using a given test condition
@@ -292,7 +292,7 @@ pyplot.show()
 
 运行该示例首先报告 LOOCV，然后报告评估的每个 k 值的平均值、最小值和最大值。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到 LOOCV 结果约为 84%，略低于 85%的 k=10 结果。
 
@@ -536,9 +536,9 @@ pyplot.ylabel('Mean Accuracy (LOOCV)')
 pyplot.show()
 ```
 
-运行该示例会报告通过每个测试线束计算出的每个算法的平均分类精度。
+运行该示例会报告通过每个测试线束计算出的每个算法的平均分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 您可能会看到一些可以安全忽略的警告，例如:
 
@@ -546,7 +546,7 @@ pyplot.show()
 Variables are collinear
 ```
 
-我们可以看到，对于某些算法，与 LOOCV 相比，测试工具高估了精度，而在其他情况下，它低估了精度。这是意料之中的。
+我们可以看到，对于某些算法，与 LOOCV 相比，测试工具高估了精确率，而在其他情况下，它低估了精确率。这是意料之中的。
 
 在运行结束时，我们可以看到两组结果之间的相关性被报告。在这种情况下，我们可以看到报告了 0.746 的相关性，这是一个很好的强正相关。结果表明，10 倍交叉验证确实为该数据集上的 LOOCV 测试工具提供了一个很好的近似，这是用 18 种流行的机器学习算法计算的。
 

trans/sklearn/how-to-connect-model-input-data-with-predictions-for-machine-learning.md

@@ -91,7 +91,7 @@ print(X.shape, y.shape)
 
 接下来，通过调用 *fit()* 函数并传入训练数据集，在训练数据集上拟合模型。
 
-最后，我们可以对模型进行评估，首先使用它通过调用 *predict()* 对训练数据集进行预测，然后将预测与期望的类标签进行比较并计算精度。
+最后，我们可以对模型进行评估，首先使用它通过调用 *predict()* 对训练数据集进行预测，然后将预测与期望的类标签进行比较并计算精确率。
 
 下面列出了完整的示例。
 
@@ -113,9 +113,9 @@ acc = accuracy_score(y, yhat)
 print(acc)
 ```
 
-运行该示例使模型适合训练数据集，然后打印分类精度。
+运行该示例使模型适合训练数据集，然后打印分类精确率。
 
-在这种情况下，我们可以看到该模型在训练数据集上具有 100%的分类精度。
+在这种情况下，我们可以看到该模型在训练数据集上具有 100%的分类精确率。
 
 ```py
 1.0

trans/sklearn/how-to-save-a-numpy-array-to-file-for-machine-learning.md

@@ -75,7 +75,7 @@ savetxt('data.csv', data, delimiter=',')
 0.000000000000000000e+00,1.000000000000000000e+00,2.000000000000000000e+00,3.000000000000000000e+00,4.000000000000000000e+00,5.000000000000000000e+00,6.000000000000000000e+00,7.000000000000000000e+00,8.000000000000000000e+00,9.000000000000000000e+00
 ```
 
-我们可以看到，数据被正确地保存为一行，数组中的浮点数以全精度保存。
+我们可以看到，数据被正确地保存为一行，数组中的浮点数以全精确率保存。
 
 ### 1.2 从 CSV 文件加载 NumPy 数组的示例
 

trans/sklearn/hyperopt-for-automated-machine-learning-with-scikit-learn.md

@@ -37,7 +37,7 @@ HyperOpt 是一个面向大规模 AutoML 的开源库，HyperOpt-Sklearn 是 Hyp
 
 该库明确用于优化机器学习管道，包括数据准备、模型选择和模型超参数。
 
-> 我们的方法是展示如何根据超参数计算性能指标(例如，验证示例的分类精度)的底层表达式图，这些超参数不仅控制如何应用各个处理步骤，甚至还控制包括哪些处理步骤。
+> 我们的方法是展示如何根据超参数计算性能指标(例如，验证示例的分类精确率)的底层表达式图，这些超参数不仅控制如何应用各个处理步骤，甚至还控制包括哪些处理步骤。
 
 ——[做模型搜索的科学:视觉架构的数百维超参数优化](https://dl.acm.org/doi/10.5555/3042817.3042832)，2013。
 
@@ -295,7 +295,7 @@ print(model.best_model())
 
 运行结束时，在保持数据集上评估性能最佳的模型，并打印发现的管道供以后使用。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到选择的模型在保持测试集上达到了大约 85.5%的准确率。管道涉及没有预处理的梯度增强模型。
 
@@ -402,7 +402,7 @@ print(model.best_model())
 
 在运行结束时，在保持数据集上评估性能最佳的模型，并打印发现的管道供以后使用。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到选择的模型在保持测试集上实现了大约 0.883 的 MAE，这看起来很巧妙。管道包含一个没有预处理的*xgbreversor*模型。
 

trans/sklearn/hyperparameter-optimization-with-random-search-and-grid-search.md

@@ -63,7 +63,7 @@
 
 *   **搜索空间**:每个维度代表一个超参数，每个点代表一个模型配置的待搜索体积。
 
-搜索空间中的一个点是一个向量，每个超参数值都有一个特定的值。优化过程的目标是找到一个学习后模型性能最好的向量，如最大精度或最小误差。
+搜索空间中的一个点是一个向量，每个超参数值都有一个特定的值。优化过程的目标是找到一个学习后模型性能最好的向量，如最大精确率或最小误差。
 
 可以使用一系列不同的优化算法，尽管最简单和最常见的两种方法是随机搜索和网格搜索。
 
@@ -109,7 +109,7 @@ search = GridSearchCV(..., cv=cv)
 
 两个超参数优化类还提供了一个“*评分*”参数，该参数采用一个指示要优化的度量的字符串。
 
-度量必须是最大化的，这意味着更好的模型导致更高的分数。对于分类，这可能是“*精度*”。对于回归，这是负误差度量，例如负版本的平均绝对误差的“ *neg_mean_absolute_error* ”，其中更接近零的值表示模型的预测误差更小。
+度量必须是最大化的，这意味着更好的模型导致更高的分数。对于分类，这可能是“*精确率*”。对于回归，这是负误差度量，例如负版本的平均绝对误差的“ *neg_mean_absolute_error* ”，其中更接近零的值表示模型的预测误差更小。
 
 ```py
 ...
@@ -286,7 +286,7 @@ print('Best Hyperparameters: %s' % result.best_params_)
 
 鉴于优化过程的随机性，您的具体结果会有所不同。试着运行这个例子几次。
 
-在这种情况下，我们可以看到最佳配置实现了大约 78.9%的精度，这是公平的，并且用于实现该分数的*求解器*、*惩罚*和 *C* 超参数的具体值。
+在这种情况下，我们可以看到最佳配置实现了大约 78.9%的精确率，这是公平的，并且用于实现该分数的*求解器*、*惩罚*和 *C* 超参数的具体值。
 
 ```py
 Best Score: 0.7897619047619049
@@ -356,7 +356,7 @@ print('Best Hyperparameters: %s' % result.best_params_)
 
 鉴于优化过程的随机性，您的具体结果会有所不同。试着运行这个例子几次。
 
-在这种情况下，我们可以看到最佳配置实现了大约 78.2%的精度，这也是公平的，并且用于实现该分数的*求解器*、*惩罚*和 *C* 超参数的具体值。有趣的是，结果与通过随机搜索找到的结果非常相似。
+在这种情况下，我们可以看到最佳配置实现了大约 78.2%的精确率，这也是公平的，并且用于实现该分数的*求解器*、*惩罚*和 *C* 超参数的具体值。有趣的是，结果与通过随机搜索找到的结果非常相似。
 
 ```py
 Best Score: 0.7828571428571429

trans/sklearn/hyperparameters-for-classification-machine-learning-algorithms.md

@@ -108,7 +108,7 @@ for mean, stdev, param in zip(means, stds, params):
     print("%f (%f) with: %r" % (mean, stdev, param))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例将打印最佳结果以及所有评估组合的结果。
 
@@ -172,7 +172,7 @@ for mean, stdev, param in zip(means, stds, params):
     print("%f (%f) with: %r" % (mean, stdev, param))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例将打印最佳结果以及所有评估组合的结果。
 
@@ -243,7 +243,7 @@ for mean, stdev, param in zip(means, stds, params):
     print("%f (%f) with: %r" % (mean, stdev, param))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例将打印最佳结果以及所有评估组合的结果。
 
@@ -309,7 +309,7 @@ for mean, stdev, param in zip(means, stds, params):
     print("%f (%f) with: %r" % (mean, stdev, param))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例将打印最佳结果以及所有评估组合的结果。
 
@@ -373,7 +373,7 @@ for mean, stdev, param in zip(means, stds, params):
     print("%f (%f) with: %r" % (mean, stdev, param))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例将打印最佳结果以及所有评估组合的结果。
 
@@ -436,7 +436,7 @@ for mean, stdev, param in zip(means, stds, params):
     print("%f (%f) with: %r" % (mean, stdev, param))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例将打印最佳结果以及所有评估组合的结果。
 
@@ -504,7 +504,7 @@ for mean, stdev, param in zip(means, stds, params):
     print("%f (%f) with: %r" % (mean, stdev, param))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例将打印最佳结果以及所有评估组合的结果。
 

trans/sklearn/linear-discriminant-analysis-with-python.md

@@ -126,7 +126,7 @@ print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 鉴于学习算法的随机性，您的具体结果可能会有所不同。考虑运行这个例子几次。
 
-在这种情况下，我们可以看到模型实现了大约 89.3%的平均精度。
+在这种情况下，我们可以看到模型实现了大约 89.3%的平均精确率。
 
 ```py
 Mean Accuracy: 0.893 (0.033)

trans/sklearn/loocv-for-evaluating-machine-learning-algorithms.md

@@ -188,7 +188,7 @@ print('Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 运行该示例会自动估计合成数据集上随机森林分类器的性能。
 
-所有折叠的平均分类精度与我们之前的手动估计相匹配。
+所有折叠的平均分类精确率与我们之前的手动估计相匹配。
 
 ```py
 Accuracy: 0.990 (0.099)
@@ -299,7 +299,7 @@ print('Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 运行该示例首先加载数据集，并确认输入和输出元素中的行数。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 然后使用 LOOCV 对模型进行评估，当对新数据进行预测时，估计的性能具有大约 82.2%的准确性。
 
@@ -412,7 +412,7 @@ print('MAE: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 运行该示例首先加载数据集，并确认输入和输出元素中的行数。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 该模型使用 LOOCV 进行评估，在对新数据进行预测时，该模型的性能平均绝对误差约为 2.180(千美元)。
 

trans/sklearn/multinomial-logistic-regression-with-python.md

@@ -104,7 +104,7 @@ model = LogisticRegression(multi_class='multinomial', solver='lbfgs')
 
 使用[重复分层 k 重交叉验证](https://machinelearningmastery.com/repeated-k-fold-cross-validation-with-python/)来评估分类模型是一个很好的做法。分层确保每个交叉验证文件夹在每个类中的示例分布与整个训练数据集大致相同。
 
-我们将使用 10 倍的三个重复，这是一个很好的默认值，并使用分类精度来评估模型性能，假设类是平衡的。
+我们将使用 10 倍的三个重复，这是一个很好的默认值，并使用分类精确率来评估模型性能，假设类是平衡的。
 
 下面列出了评估多类分类的多项逻辑回归的完整示例。
 
@@ -128,11 +128,11 @@ n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
 print('Mean Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
 ```
 
-运行该示例会报告评估过程中所有折叠和重复的平均分类精度。
+运行该示例会报告评估过程中所有折叠和重复的平均分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-在这种情况下，我们可以看到，在我们的综合分类数据集上，具有默认惩罚的多项式逻辑回归模型实现了大约 68.1%的平均分类精度。
+在这种情况下，我们可以看到，在我们的综合分类数据集上，具有默认惩罚的多项式逻辑回归模型实现了大约 68.1%的平均分类精确率。
 
 ```py
 Mean Accuracy: 0.681 (0.042)
@@ -196,7 +196,7 @@ print('Predicted Probabilities: %s' % yhat[0])
 
 运行该示例首先在所有可用数据上拟合模型，然后定义一行数据，提供给模型以预测类概率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到类 1(例如，数组索引被映射到类整数值)具有大约 0.50 的最大预测概率。
 
@@ -306,9 +306,9 @@ pyplot.boxplot(results, labels=names, showmeans=True)
 pyplot.show()
 ```
 
-运行该示例会报告沿途每个配置的平均分类精度。
+运行该示例会报告沿途每个配置的平均分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到，C 值为 1.0 的最佳分数约为 77.7%，这与不使用达到相同分数的惩罚相同。
 

trans/sklearn/nearest-shrunken-centroids-with-python.md

@@ -138,11 +138,11 @@ scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
 print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 ```
 
-运行该示例评估合成数据集上的最近收缩质心算法，并报告 10 倍交叉验证的三次重复的平均精度。
+运行该示例评估合成数据集上的最近收缩质心算法，并报告 10 倍交叉验证的三次重复的平均精确率。
 
 鉴于学习算法的随机性，您的具体结果可能会有所不同。考虑运行这个例子几次。
 
-在这种情况下，我们可以看到模型达到了大约 71%的平均精度。
+在这种情况下，我们可以看到模型达到了大约 71%的平均精确率。
 
 ```py
 Mean Accuracy: 0.711 (0.055)
@@ -272,7 +272,7 @@ print('Config: %s' % results.best_params_)
 
 鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。
 
-在这种情况下，我们可以看到，使用无收缩和曼哈顿代替欧几里德距离测量，我们获得了略好的 75%的精度。
+在这种情况下，我们可以看到，使用无收缩和曼哈顿代替欧几里德距离测量，我们获得了略好的 75%的精确率。
 
 ```py
 Mean Accuracy: 0.750

trans/sklearn/nested-cross-validation-for-machine-learning-with-python.md

@@ -259,15 +259,15 @@ print('Accuracy: %.3f (%.3f)' % (mean(outer_results), std(outer_results)))
 
 运行该示例使用合成分类数据集上的嵌套交叉验证来评估[随机森林](https://machinelearningmastery.com/random-forest-ensemble-in-python/)。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 您可以使用该示例作为起点，并对其进行调整以评估不同的算法超参数、不同的算法或不同的数据集。
 
-外部交叉验证过程的每一次迭代都报告最佳性能模型的估计性能(使用 3 倍交叉验证)和被发现表现最佳的超参数，以及保持数据集的精度。
+外部交叉验证过程的每一次迭代都报告最佳性能模型的估计性能(使用 3 倍交叉验证)和被发现表现最佳的超参数，以及保持数据集的精确率。
 
 这是有见地的，因为我们可以看到，实际和估计的准确性是不同的，但在这种情况下，类似的。我们还可以看到，每次迭代都会发现不同的超参数，这表明这个数据集上的好的超参数取决于数据集的细节。
 
-然后报告最终的平均分类精度。
+然后报告最终的平均分类精确率。
 
 ```py
 >acc=0.900, est=0.932, cfg={'max_features': 4, 'n_estimators': 100}
@@ -318,9 +318,9 @@ scores = cross_val_score(search, X, y, scoring='accuracy', cv=cv_outer, n_jobs=-
 print('Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-运行示例在随机森林算法上执行嵌套交叉验证，达到了与我们的手动过程相匹配的平均精度。
+运行示例在随机森林算法上执行嵌套交叉验证，达到了与我们的手动过程相匹配的平均精确率。
 
 ```py
 Accuracy: 0.927 (0.019)

trans/sklearn/overfitting-machine-learning-models.md

@@ -69,7 +69,7 @@
 
 *   [如何利用学习曲线诊断机器学习模型性能](https://machinelearningmastery.com/learning-curves-for-diagnosing-machine-learning-model-performance/)
 
-在学习曲线图上可以看到过度拟合的常见模式，其中训练数据集上的模型性能持续改善(例如，损失或误差持续下降或精度持续上升)，测试或验证集上的性能改善到一定程度，然后开始变差。
+在学习曲线图上可以看到过度拟合的常见模式，其中训练数据集上的模型性能持续改善(例如，损失或误差持续下降或精确率持续上升)，测试或验证集上的性能改善到一定程度，然后开始变差。
 
 如果观察到这种模式，那么训练应该停止在增量学习算法的测试或验证集性能变差的地方
 
@@ -219,9 +219,9 @@ pyplot.show()
 
 运行该示例适合并评估列车上的决策树和每个树深度的测试集，并报告准确性分数。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-在这种情况下，我们可以看到一种趋势，即随着树的深度达到 19-20 层深度附近的一个点，训练数据集的精度会提高，在这个点上树与训练数据集完全匹配。
+在这种情况下，我们可以看到一种趋势，即随着树的深度达到 19-20 层深度附近的一个点，训练数据集的精确率会提高，在这个点上树与训练数据集完全匹配。
 
 我们还可以看到，测试集上的准确性随着树的深度而提高，直到大约八到九个级别的深度，之后准确性随着树深度的每次增加而开始变差。
 
@@ -252,7 +252,7 @@ pyplot.show()
 >20, train: 1.000, test: 0.913
 ```
 
-还创建了一个图形，显示了列车上模型精度的线图和具有不同树深的测试集。
+还创建了一个图形，显示了列车上模型精确率的线图和具有不同树深的测试集。
 
 该图清楚地表明，在早期阶段增加树的深度会导致训练集和测试集的相应改进。
 
@@ -260,7 +260,7 @@ pyplot.show()
 
 ![Line Plot of Decision Tree Accuracy on Train and Test Datasets for Different Tree Depths](img/21cdcc763b68052b728d47feb26b905d.png)
 
-不同树深的训练和测试数据集上决策树精度的线图
+不同树深的训练和测试数据集上决策树精确率的线图
 
 这个分析很有意思。它显示了为什么当“ *max_depth* ”设置为大值时，模型的保持测试集性能更差。
 
@@ -322,13 +322,13 @@ pyplot.show()
 
 运行该示例适合并评估列车上的 KNN 模型和每个邻居的测试集，并报告准确性分数。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 回想一下，我们正在寻找一种模式，在这种模式下，测试集的性能会提高，然后开始变得更差，而训练集的性能会继续提高。
 
 我们看不到这种模式。
 
-相反，我们看到训练数据集的精度从完美的精度开始，几乎随着邻居数量的每一次增加而下降。
+相反，我们看到训练数据集的精确率从完美的精确率开始，几乎随着邻居数量的每一次增加而下降。
 
 我们还看到，模型在保持测试中的性能提高到大约五个邻居的值，保持水平，并在此之后开始下降趋势。
 
@@ -385,13 +385,13 @@ pyplot.show()
 >50, train: 0.934, test: 0.929
 ```
 
-还创建了一个图形，显示了列车上模型精度的线图和具有不同邻居数量的测试集。
+还创建了一个图形，显示了列车上模型精确率的线图和具有不同邻居数量的测试集。
 
 情节使情况变得更清楚了。看起来训练集的线图正在下降以与测试集的线收敛。事实上，这正是正在发生的事情。
 
 ![Line Plot of KNN Accuracy on Train and Test Datasets for Different Numbers of Neighbors](img/4684c84ac0ea10cb76c3636eeb6be6fd.png)
 
-不同邻居数的训练和测试数据集上 KNN 精度的线图
+不同邻居数的训练和测试数据集上 KNN 精确率的线图
 
 现在，回想一下 KNN 是如何工作的。
 

trans/sklearn/perceptron-algorithm-for-classification-in-python.md

@@ -60,7 +60,7 @@ Python 中分类的感知器算法
 
 当模型产生的误差降至较低水平或不再改善，或者执行了最大数量的时期时，停止训练。
 
-模型权重的初始值被设置为小的随机值。此外，训练数据集在每个训练时期之前被打乱。这是通过设计来加速和改进模型训练过程。因此，学习算法是随机的，每次运行时可能会获得不同的结果。因此，使用重复评估和报告平均分类精度来总结算法在数据集上的性能是一种很好的做法。
+模型权重的初始值被设置为小的随机值。此外，训练数据集在每个训练时期之前被打乱。这是通过设计来加速和改进模型训练过程。因此，学习算法是随机的，每次运行时可能会获得不同的结果。因此，使用重复评估和报告平均分类精确率来总结算法在数据集上的性能是一种很好的做法。
 
 学习速率和训练时期的数量是算法的超参数，可以使用试探法或超参数调整来设置。
 
@@ -311,7 +311,7 @@ for mean, param in zip(means, params):
 
 鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。
 
-在这种情况下，我们可以看到 10 到 10，000 个纪元导致了大约相同的分类精度。一个有趣的例外是探索同时配置学习速率和训练时期的数量，看看是否能取得更好的结果。
+在这种情况下，我们可以看到 10 到 10，000 个纪元导致了大约相同的分类精确率。一个有趣的例外是探索同时配置学习速率和训练时期的数量，看看是否能取得更好的结果。
 
 ```py
 Mean Accuracy: 0.857

trans/sklearn/plot-a-decision-surface-for-machine-learning.md

@@ -138,7 +138,7 @@ model.fit(X, y)
 yhat = model.predict(X)
 ```
 
-可以使用分类精度来评估预测。
+可以使用分类精确率来评估预测。
 
 ```py
 ...
@@ -169,7 +169,7 @@ print('Accuracy: %.3f' % acc)
 
 运行该示例符合模型，并对每个示例进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到该模型实现了大约 97.2%的性能。
 

trans/sklearn/pycaret-for-machine-learning.md

@@ -172,7 +172,7 @@ grid = setup(data=df, target=df.columns[-1], html=False, silent=True, verbose=Fa
 
 接下来，我们可以通过调用 *compare_models()* 函数来比较标准机器学习模型。
 
-默认情况下，它将使用 10 倍交叉验证来评估模型，根据分类精度对结果进行排序，并返回单个最佳模型。
+默认情况下，它将使用 10 倍交叉验证来评估模型，根据分类精确率对结果进行排序，并返回单个最佳模型。
 
 这些都是不错的违约，我们不需要改变什么。
 
@@ -210,7 +210,7 @@ print(best)
 
 运行该示例将加载数据集，配置 PyCaret 库，评估一套标准模型，并报告为数据集找到的最佳模型。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到“*额外树分类器*”在数据集上具有最好的准确性，得分约为 86.95%。
 
@@ -282,7 +282,7 @@ grid = setup(data=df, target=df.columns[-1], html=False, silent=True, verbose=Fa
 
 该函数将模型的一个实例作为输入进行调整，并知道自动调整哪些超参数。执行模型超参数的随机搜索，并且可以通过“ *n_iter* ”参数控制评估的总数。
 
-默认情况下，该功能将优化“*精度*”，并将使用 10 倍交叉验证来评估每个配置的性能，尽管这个合理的默认配置可以更改。
+默认情况下，该功能将优化“*精确率*”，并将使用 10 倍交叉验证来评估每个配置的性能，尽管这个合理的默认配置可以更改。
 
 我们可以对额外的树分类器执行如下随机搜索:
 
@@ -321,9 +321,9 @@ print(best)
 
 运行该示例首先加载数据集并配置 PyCaret 库。
 
-然后执行网格搜索，报告跨 10 倍交叉验证的最佳配置性能和平均精度。
+然后执行网格搜索，报告跨 10 倍交叉验证的最佳配置性能和平均精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到，随机搜索找到了一个准确率约为 75.29%的配置，这并不比上一部分的默认配置好，后者的得分约为 86.95%。
 

trans/sklearn/radius-neighbors-classifier-algorithm-with-python.md

@@ -150,7 +150,7 @@ print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 
 鉴于学习算法的随机性，您的具体结果可能会有所不同。考虑运行这个例子几次。
 
-在这种情况下，我们可以看到模型达到了大约 75.4%的平均精度。
+在这种情况下，我们可以看到模型达到了大约 75.4%的平均精确率。
 
 ```py
 Mean Accuracy: 0.754 (0.042)
@@ -244,7 +244,7 @@ print('Config: %s' % results.best_params_)
 
 鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。
 
-在这种情况下，我们可以看到，使用 0.8 的半径获得了更好的结果，精度约为 87.2%，而前面示例中的半径为 1.0，精度约为 75.4%。
+在这种情况下，我们可以看到，使用 0.8 的半径获得了更好的结果，精确率约为 87.2%，而前面示例中的半径为 1.0，精确率约为 75.4%。
 
 ```py
 Mean Accuracy: 0.872

trans/sklearn/regression-metrics-for-machine-learning.md

@@ -6,7 +6,7 @@
 
 回归是指涉及预测数值的预测建模问题。
 
-它不同于涉及预测类别标签的分类。与分类不同，您不能使用分类精度来评估回归模型所做的预测。
+它不同于涉及预测类别标签的分类。与分类不同，您不能使用分类精确率来评估回归模型所做的预测。
 
 相反，您必须使用专门为评估回归问题预测而设计的误差度量。
 
@@ -40,11 +40,11 @@
 
 预测建模是使用历史数据开发模型的问题，以便在我们没有答案的情况下对新数据进行预测。
 
-预测建模可以描述为从输入变量(X)到输出变量(y)近似映射函数(f)的数学问题。这就是所谓的函数逼近问题。
+预测建模可以描述为从输入变量(X)到输出变量(y)近似映射函数(f)的数学问题。这就是所谓的函数近似问题。
 
 建模算法的工作是在给定可用时间和资源的情况下，找到我们能找到的最佳映射函数。
 
-有关应用机器学习中逼近函数的更多信息，请参见文章:
+有关应用机器学习中近似函数的更多信息，请参见文章:
 
 *   [机器学习算法如何工作](https://machinelearningmastery.com/how-machine-learning-algorithms-work/)
 
@@ -75,7 +75,7 @@
 
 准确性(例如分类准确性)是分类的一种度量，而不是回归。
 
-**我们无法计算回归模型**的精度。
+**我们无法计算回归模型**的精确率。
 
 回归模型的技巧或性能必须作为这些预测中的错误报告。
 

trans/sklearn/repeated-k-fold-cross-validation-with-python.md

@@ -98,9 +98,9 @@ scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
 print('Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 ```
 
-运行该示例会创建数据集，然后使用 10 倍交叉验证对其进行逻辑回归模型评估。然后报告数据集的平均分类精度。
+运行该示例会创建数据集，然后使用 10 倍交叉验证对其进行逻辑回归模型评估。然后报告数据集的平均分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到该模型实现了大约 86.8%的估计分类准确率。
 
@@ -178,9 +178,9 @@ scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
 print('Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
 ```
 
-运行该示例会创建数据集，然后使用具有三次重复的 10 倍交叉验证对数据集的逻辑回归模型进行评估。然后报告数据集的平均分类精度。
+运行该示例会创建数据集，然后使用具有三次重复的 10 倍交叉验证对数据集的逻辑回归模型进行评估。然后报告数据集的平均分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型实现了大约 86.7%的估计分类准确率，这低于之前报告的 86.8%的单次运行结果。这可能表明单次运行结果可能是乐观的，三次重复的结果可能是对真实均值模型性能的更好估计。
 
@@ -248,9 +248,9 @@ pyplot.boxplot(results, labels=[str(r) for r in repeats], showmeans=True)
 pyplot.show()
 ```
 
-运行该示例使用不同重复次数的 10 倍交叉验证来报告平均和标准误差分类精度。
+运行该示例使用不同重复次数的 10 倍交叉验证来报告平均和标准误差分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到，与其他结果相比，一个重复的默认值似乎是乐观的，准确率约为 86.80%，而不是 86.73%，并且随着重复次数的不同而降低。
 

trans/sklearn/results-for-standard-classification-and-regression-machine-learning-datasets.md

@@ -198,7 +198,7 @@ scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv,
 model = DummyClassifier(strategy='most_frequent')
 ```
 
-分类模型的标准评估是分类精度，尽管这对于不平衡和一些多类问题并不理想。尽管如此，不管是好是坏，这个分数将被使用(现在)。
+分类模型的标准评估是分类精确率，尽管这对于不平衡和一些多类问题并不理想。尽管如此，不管是好是坏，这个分数将被使用(现在)。
 
 准确性报告为 0 (0%或无技能)和 1 (100%或完美技能)之间的分数。
 
@@ -256,7 +256,7 @@ m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1,
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -303,7 +303,7 @@ m_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, er
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -354,7 +354,7 @@ m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1,
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -406,7 +406,7 @@ m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1,
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -458,7 +458,7 @@ m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1,
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -518,7 +518,7 @@ m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1,
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -568,7 +568,7 @@ m_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, er
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -620,7 +620,7 @@ m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1,
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -671,7 +671,7 @@ m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1,
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -742,7 +742,7 @@ m_scores = absolute(m_scores)
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -797,7 +797,7 @@ m_scores = absolute(m_scores)
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -854,7 +854,7 @@ m_scores = absolute(m_scores)
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 
@@ -912,7 +912,7 @@ m_scores = absolute(m_scores)
 print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 ```
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 运行该示例，您应该会看到以下结果。
 

trans/sklearn/scikit-optimize-for-hyperparameter-tuning-in-machine-learning.md

@@ -149,7 +149,7 @@ print('Accuracy: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))
 
 运行该示例首先加载和准备数据集，然后对数据集评估 SVM 模型。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到具有默认超参数的 SVM 实现了大约 93.7%的平均分类准确率，这是熟练的，并且接近 94%的问题上的最高性能。
 
@@ -175,7 +175,7 @@ Scikit-Optimize 库可用于调整机器学习模型的超参数。
 *   **次**，用于多项式核。
 *   **γ**，用于大多数其他内核。
 
-对于数值超参数 *C* 和*γ*，我们将定义一个对数标度，在 1e-6 和 100 的小值之间进行搜索。*度*是一个整数，我们将搜索 1 到 5 之间的值。最后，*内核*是一个具有特定命名值的分类变量。
+对于数值超参数 *C* 和*γ*，我们将定义一个对数标度，在 1e-6 和 100 的小值之间进行搜索。*度*是一个整数，我们将搜索 1 到 5 之间的值。最后，*内核*是一个具有特定命名值的类别变量。
 
 我们可以为这四个超参数定义搜索空间，它们是来自 skopt 库的数据类型列表，如下所示:
 
@@ -193,7 +193,7 @@ search_space.append(Real(1e-6, 100.0, 'log-uniform', name='gamma'))
 
 然后，我们可以定义一个将由搜索过程调用的函数。这是优化过程稍后期望的函数，它获取模型和模型的特定超参数集，对其进行评估，并返回超参数集的分数。
 
-在我们的案例中，我们希望在电离层数据集上使用重复的分层 10 倍交叉验证来评估模型。我们希望最大化分类精度，例如，找到给出最佳精度的模型超参数集。默认情况下，该过程最小化从该函数返回的分数，因此，我们将返回 1 减去准确性，例如，完美技能将是(1–准确性)或 0.0，最差技能将是 1.0。
+在我们的案例中，我们希望在电离层数据集上使用重复的分层 10 倍交叉验证来评估模型。我们希望最大化分类精确率，例如，找到给出最佳精确率的模型超参数集。默认情况下，该过程最小化从该函数返回的分数，因此，我们将返回 1 减去准确性，例如，完美技能将是(1–准确性)或 0.0，最差技能将是 1.0。
 
 下面的 *evaluate_model()* 函数实现了这一点，并获取了一组特定的超参数。
 
@@ -294,7 +294,7 @@ UserWarning: The objective has been evaluated at this point before.
 
 运行结束时，会报告性能最佳的配置。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到，按照搜索空间列表的顺序报告的配置是适度的 *C* 值、径向基函数*核*、2 的*度*(被径向基函数核忽略)和适度的*γ*值。
 
@@ -396,7 +396,7 @@ UserWarning: The objective has been evaluated at this point before.
 
 运行结束时，会报告性能最佳的配置。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到，该模型的性能高于表现最好的模型，平均分类准确率约为 95.2%。
 

trans/sklearn/seaborn-data-visualization-for-machine-learning.md

@@ -188,7 +188,7 @@ pyplot.show()
 
 ![Bar Chart Plot of Age Range Categorical Variable](img/05611c0729adcb500beff7b0ac9bed8a.png)
 
-年龄范围分类变量的条形图
+年龄范围类别变量的条形图
 
 我们可能还想针对类标签绘制一个变量的每个类别的计数，例如第一个变量。
 
@@ -220,7 +220,7 @@ pyplot.show()
 
 ![Bar Chart Plot of Age Range Categorical Variable by Class Label](img/55fbe671157530ed6f75103ec0bfcfa4.png)
 
-按类别标签划分的年龄范围分类变量的条形图
+按类别标签划分的年龄范围类别变量的条形图
 
 有关使用 Seaborn 绘制条形图的更多示例，请参见:[使用分类数据绘制](https://seaborn.pydata.org/tutorial/categorical.html)。
 
@@ -314,7 +314,7 @@ pyplot.show()
 
 孕次数值变量的盒须图
 
-我们可能还想对照类标签，为分类变量(如第一个变量)的每个值绘制数字变量的分布。
+我们可能还想对照类标签，为类别变量(如第一个变量)的每个值绘制数字变量的分布。
 
 这可以通过调用 *boxplot()* 函数，将类变量作为 x 轴传递，将数值变量作为 y 轴传递来实现。
 

trans/sklearn/semi-supervised-learning-with-label-propagation.md

@@ -134,7 +134,7 @@ model = LogisticRegression()
 model.fit(X_train_lab, y_train_lab)
 ```
 
-然后，该模型可用于对整个搁置测试数据集进行预测，并使用分类精度进行评估。
+然后，该模型可用于对整个搁置测试数据集进行预测，并使用分类精确率进行评估。
 
 ```py
 ...
@@ -172,13 +172,13 @@ score = accuracy_score(y_test, yhat)
 print('Accuracy: %.3f' % (score*100))
 ```
 
-运行该算法使模型适合标记的训练数据集，并在保持数据集上对其进行评估，并打印分类精度。
+运行该算法使模型适合标记的训练数据集，并在保持数据集上对其进行评估，并打印分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到该算法实现了大约 84.8%的分类准确率。
 
-我们期望一种有效的半监督学习算法能获得比这更好的精度。
+我们期望一种有效的半监督学习算法能获得比这更好的精确率。
 
 ```py
 Accuracy: 84.800
@@ -252,7 +252,7 @@ model = LabelPropagation()
 model.fit(X_train_mixed, y_train_mixed)
 ```
 
-接下来，我们可以使用该模型对保持数据集进行预测，并使用分类精度评估该模型。
+接下来，我们可以使用该模型对保持数据集进行预测，并使用分类精确率评估该模型。
 
 ```py
 ...
@@ -297,9 +297,9 @@ score = accuracy_score(y_test, yhat)
 print('Accuracy: %.3f' % (score*100))
 ```
 
-运行该算法使模型适合整个训练数据集，并在保持数据集上对其进行评估，并打印分类精度。
+运行该算法使模型适合整个训练数据集，并在保持数据集上对其进行评估，并打印分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到标签传播模型实现了大约 85.6%的分类准确率，这略高于仅在实现了大约 84.8%准确率的标签训练数据集上的逻辑回归拟合。
 
@@ -377,11 +377,11 @@ score = accuracy_score(y_test, yhat)
 print('Accuracy: %.3f' % (score*100))
 ```
 
-运行该算法将半监督模型拟合到整个训练数据集上，然后将监督学习模型拟合到具有推断标签的整个训练数据集上，并在保持数据集上对其进行评估，打印分类精度。
+运行该算法将半监督模型拟合到整个训练数据集上，然后将监督学习模型拟合到具有推断标签的整个训练数据集上，并在保持数据集上对其进行评估，打印分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-在这种情况下，我们可以看到，半监督模型跟随监督模型的这种分层方法在保持数据集上实现了大约 86.2%的分类精度，甚至优于单独使用的半监督学习，后者实现了大约 85.6%的精度。
+在这种情况下，我们可以看到，半监督模型跟随监督模型的这种分层方法在保持数据集上实现了大约 86.2%的分类精确率，甚至优于单独使用的半监督学习，后者实现了大约 85.6%的精确率。
 
 ```py
 Accuracy: 86.200

trans/sklearn/semi-supervised-learning-with-label-spreading.md

@@ -142,7 +142,7 @@ model = LogisticRegression()
 model.fit(X_train_lab, y_train_lab)
 ```
 
-然后，该模型可用于对整个保持测试数据集进行预测，并使用分类精度进行评估。
+然后，该模型可用于对整个保持测试数据集进行预测，并使用分类精确率进行评估。
 
 ```py
 ...
@@ -180,13 +180,13 @@ score = accuracy_score(y_test, yhat)
 print('Accuracy: %.3f' % (score*100))
 ```
 
-运行该算法使模型适合标记的训练数据集，并在保持数据集上对其进行评估，并打印分类精度。
+运行该算法使模型适合标记的训练数据集，并在保持数据集上对其进行评估，并打印分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到该算法实现了大约 84.8%的分类准确率。
 
-我们期望一种有效的半监督学习算法能获得比这更好的精度。
+我们期望一种有效的半监督学习算法能获得比这更好的精确率。
 
 ```py
 Accuracy: 84.800
@@ -260,7 +260,7 @@ model = LabelSpreading()
 model.fit(X_train_mixed, y_train_mixed)
 ```
 
-接下来，我们可以使用该模型对保持数据集进行预测，并使用分类精度评估该模型。
+接下来，我们可以使用该模型对保持数据集进行预测，并使用分类精确率评估该模型。
 
 ```py
 ...
@@ -305,11 +305,11 @@ score = accuracy_score(y_test, yhat)
 print('Accuracy: %.3f' % (score*100))
 ```
 
-运行该算法使模型适合整个训练数据集，并在保持数据集上对其进行评估，并打印分类精度。
+运行该算法使模型适合整个训练数据集，并在保持数据集上对其进行评估，并打印分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-在这种情况下，我们可以看到标签传播模型实现了大约 85.4%的分类精度，这略高于仅在实现了大约 84.8%的精度的标签训练数据集上的逻辑回归拟合。
+在这种情况下，我们可以看到标签传播模型实现了大约 85.4%的分类精确率，这略高于仅在实现了大约 84.8%的精确率的标签训练数据集上的逻辑回归拟合。
 
 ```py
 Accuracy: 85.400
@@ -385,11 +385,11 @@ score = accuracy_score(y_test, yhat)
 print('Accuracy: %.3f' % (score*100))
 ```
 
-运行该算法将半监督模型拟合到整个训练数据集上，然后将监督学习模型拟合到具有推断标签的整个训练数据集上，并在保持数据集上对其进行评估，打印分类精度。
+运行该算法将半监督模型拟合到整个训练数据集上，然后将监督学习模型拟合到具有推断标签的整个训练数据集上，并在保持数据集上对其进行评估，打印分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-在这种情况下，我们可以看到，半监督模型跟随监督模型的分层方法在保持数据集上实现了大约 85.8%的分类精度，略好于单独使用的半监督学习算法，该算法实现了大约 85.6%的精度。
+在这种情况下，我们可以看到，半监督模型跟随监督模型的分层方法在保持数据集上实现了大约 85.8%的分类精确率，略好于单独使用的半监督学习算法，该算法实现了大约 85.6%的精确率。
 
 ```py
 Accuracy: 85.800

trans/sklearn/sensitivity-analysis-of-dataset-size-vs-model-performance.md

@@ -116,7 +116,7 @@ print('Mean Accuracy: %.3f (%.3f)' % (scores.mean(), scores.std()))
 
 运行该示例会创建数据集，然后使用所选的测试工具来评估模型在问题上的性能。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到平均分类准确率约为 82.7%。
 
@@ -296,9 +296,9 @@ pyplot.show()
 
 运行该示例会报告数据集大小和估计模型性能的状态。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-在这种情况下，我们可以看到平均模型性能随着数据集大小的增加而增加，而使用分类精度的标准偏差测量的模型方差减少的预期趋势。
+在这种情况下，我们可以看到平均模型性能随着数据集大小的增加而增加，而使用分类精确率的标准偏差测量的模型方差减少的预期趋势。
 
 我们可以看到，在估计大约 10，000 或 50，000 行的模型性能时，可能存在收益递减点。
 

trans/sklearn/tpot-for-automated-machine-learning-in-python.md

@@ -42,7 +42,7 @@ TPOT 使用基于树的结构来表示预测建模问题的模型管道，包括
 
 然后执行优化过程，以找到对给定数据集表现最佳的树结构。具体地说，是一种遗传编程算法，用于对表示为树的程序进行随机全局优化。
 
-> TPOT 使用一个版本的遗传编程来自动设计和优化一系列数据转换和机器学习模型，试图最大化给定监督学习数据集的分类精度。
+> TPOT 使用一个版本的遗传编程来自动设计和优化一系列数据转换和机器学习模型，试图最大化给定监督学习数据集的分类精确率。
 
 ——[评估用于自动化数据科学的基于树的管道优化工具](https://dl.acm.org/doi/10.1145/2908812.2908918)，2016 年。
 
@@ -97,7 +97,7 @@ cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
 model = TPOTRegressor(... scoring='neg_mean_absolute_error', cv=cv)
 ```
 
-或者是一个[重复的 stratifiedfold](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.RepeatedStratifiedKFold.html)进行回归，用*精度*度量进行分类:
+或者是一个[重复的 stratifiedfold](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.RepeatedStratifiedKFold.html)进行回归，用*精确率*度量进行分类:
 
 ```py
 ...
@@ -223,7 +223,7 @@ model.export('tpot_sonar_best_model.py')
 
 运行该示例可能需要几分钟时间，您将在命令行上看到一个进度条。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 高性能模型的准确性将在过程中报告。
 
@@ -408,7 +408,7 @@ model.export('tpot_insurance_best_model.py')
 
 运行该示例可能需要几分钟时间，您将在命令行上看到一个进度条。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 高性能模型的 MAE 将会一路被报道。
 

trans/sklearn/train-test-split-for-evaluating-machine-learning-algorithms.md

@@ -350,7 +350,7 @@ model = RandomForestClassifier(random_state=1)
 model.fit(X_train, y_train)
 ```
 
-然后使用拟合模型进行预测，并使用分类精度性能度量来评估预测。
+然后使用拟合模型进行预测，并使用分类精确率性能度量来评估预测。
 
 ```py
 ...
@@ -391,7 +391,7 @@ print('Accuracy: %.3f' % acc)
 
 运行该示例首先加载数据集，并确认输入和输出元素中的行数。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 数据集被分成训练集和测试集，我们可以看到有 139 行用于训练，69 行用于测试集。
 
@@ -504,7 +504,7 @@ print('MAE: %.3f' % mae)
 
 运行该示例首先加载数据集，并确认输入和输出元素中的行数。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 数据集被分成训练集和测试集，我们可以看到有 339 行用于训练，167 行用于测试集。
 

trans/sklearn/types-of-classification-in-machine-learning.md

@@ -57,7 +57,7 @@
 
 关于如何将算法映射到问题类型上，没有好的理论；相反，通常建议从业者使用受控实验，并发现对于给定的分类任务，哪种算法和算法配置导致最佳性能。
 
-基于分类预测建模算法的结果对其进行评估。分类精度是一种流行的度量标准，用于基于预测的类标签来评估模型的性能。[分类准确率并不完美](https://machinelearningmastery.com/failure-of-accuracy-for-imbalanced-class-distributions/)但是对于很多分类任务来说是一个很好的起点。
+基于分类预测建模算法的结果对其进行评估。分类精确率是一种流行的度量标准，用于基于预测的类标签来评估模型的性能。[分类准确率并不完美](https://machinelearningmastery.com/failure-of-accuracy-for-imbalanced-class-distributions/)但是对于很多分类任务来说是一个很好的起点。
 
 代替类标签，一些任务可能需要预测每个例子的类成员的[概率。这为应用程序或用户可以解释的预测提供了额外的不确定性。评估预测概率的一个流行诊断是](https://machinelearningmastery.com/probability-metrics-for-imbalanced-classification/) [ROC 曲线](https://machinelearningmastery.com/roc-curves-and-precision-recall-curves-for-classification-in-python/)。
 

trans/start/a-gentle-introduction-to-sigmoid-function.md

@@ -103,7 +103,7 @@ sigmoid 函数在任何地方都是单调的、连续的和可微的，加上它
 
 *   [作用中的微积分:神经网络](https://machinelearningmastery.com/calculus-in-action-neural-networks/)
 *   [缓步介绍梯度下降程序](https://machinelearningmastery.com/a-gentle-introduction-to-gradient-descent-procedure)
-*   [神经网络是函数逼近算法](https://machinelearningmastery.com/neural-networks-are-function-approximators/)
+*   [神经网络是函数近似算法](https://machinelearningmastery.com/neural-networks-are-function-approximators/)
 *   [如何选择深度学习的激活函数](https://machinelearningmastery.com/choose-an-activation-function-for-deep-learning/)
 
 ### **资源**

trans/start/types-of-learning-in-machine-learning.md

@@ -213,17 +213,17 @@
 
 ——[自监督视觉表征学习的缩放和对标](https://arxiv.org/abs/1905.01235)，2019。
 
-自监督学习算法的一般例子是[自动编码器](https://machinelearningmastery.com/lstm-autoencoders/)。这是一种神经网络，用于创建输入样本的紧凑或压缩表示。他们通过一个模型来实现这一点，该模型有一个编码器和一个解码器元件，它们被一个瓶颈分隔开，该瓶颈表示输入的内部紧凑表示。
+自监督学习算法的一般例子是[自编码器](https://machinelearningmastery.com/lstm-autoencoders/)。这是一种神经网络，用于创建输入样本的紧凑或压缩表示。他们通过一个模型来实现这一点，该模型有一个编码器和一个解码器元件，它们被一个瓶颈分隔开，该瓶颈表示输入的内部紧凑表示。
 
-> 自动编码器是一个神经网络，它被训练成试图将其输入复制到其输出。在内部，它有一个隐藏层 *h* ，描述了用于表示输入的代码。
+> 自编码器是一个神经网络，它被训练成试图将其输入复制到其输出。在内部，它有一个隐藏层 *h* ，描述了用于表示输入的代码。
 
 —第 502 页，[深度学习](https://amzn.to/34OHNfi)，2016。
 
-这些自动编码器模型是通过向模型提供输入作为输入和目标输出来训练的，要求模型通过首先将其编码为压缩表示，然后将其解码回原始表示来再现输入。一旦经过训练，解码器就被丢弃，编码器根据需要被用来创建输入的紧凑表示。
+这些自编码器模型是通过向模型提供输入作为输入和目标输出来训练的，要求模型通过首先将其编码为压缩表示，然后将其解码回原始表示来再现输入。一旦经过训练，解码器就被丢弃，编码器根据需要被用来创建输入的紧凑表示。
 
-虽然自动编码器是使用监督学习方法训练的，但是它们解决了无监督学习问题，即，它们是一种用于降低输入数据的维数的投影方法。
+虽然自编码器是使用监督学习方法训练的，但是它们解决了无监督学习问题，即，它们是一种用于降低输入数据的维数的投影方法。
 
-> 传统上，自动编码器用于降维或特征学习。
+> 传统上，自编码器用于降维或特征学习。
 
 —第 502 页，[深度学习](https://amzn.to/34OHNfi)，2016。
 
@@ -380,7 +380,7 @@ GAN 模型通过单独的鉴别器模型进行间接训练，该模型将来自
 
 主动学习是监督学习的一种类型，并寻求实现与所谓的“T0”被动监督学习相同或更好的性能，尽管在模型收集或使用什么数据方面效率更高。
 
-> 主动学习背后的关键思想是，如果允许机器学习算法选择它学习的数据，它可以用更少的训练标签获得更高的精度。主动学习者可以提出查询，通常是以未标记的数据实例的形式由甲骨文(例如，人类注释者)标记。
+> 主动学习背后的关键思想是，如果允许机器学习算法选择它学习的数据，它可以用更少的训练标签获得更高的精确率。主动学习者可以提出查询，通常是以未标记的数据实例的形式由甲骨文(例如，人类注释者)标记。
 
 ——[主动学习文献调查](https://minds.wisconsin.edu/handle/1793/60660)，2009 年。
 

trans/start/what-is-a-hypothesis-in-machine-learning.md

@@ -4,7 +4,7 @@
 
 最后更新于 2020 年 9 月 4 日
 
-监督机器学习通常被描述为逼近将输入映射到输出的目标函数的问题。
+监督机器学习通常被描述为近似将输入映射到输出的目标函数的问题。
 
 该描述的特征在于从假设空间中搜索和评估候选假设。
 
@@ -85,7 +85,7 @@
 
 机器学习，特别是监督学习，可以描述为使用可用数据来学习将输入最佳映射到输出的函数的愿望。
 
-从技术上来说，这是一个叫做函数逼近的问题，我们正在逼近一个未知的目标函数(我们假设它存在)，这个函数可以根据问题域中所有可能的观察结果，最好地将输入映射到输出。
+从技术上来说，这是一个叫做函数近似的问题，我们正在近似一个未知的目标函数(我们假设它存在)，这个函数可以根据问题域中所有可能的观察结果，最好地将输入映射到输出。
 
 在机器学习中，一个近似目标函数并执行输入到输出映射的模型的例子被称为假设。
 

trans/stat/hypothesis-test-for-comparing-machine-learning-algorithms.md

@@ -92,7 +92,7 @@ t, p = paired_ttest_5x2cv(estimator1=model1, estimator2=model2, X=X, y=y)
 
 p 值必须使用 alpha 值来解释，这是您愿意接受的重要级别。
 
-如果 p 值小于或等于所选的α，我们拒绝零假设，即模型具有相同的平均性能，这意味着差异可能是真实的。如果 p 值大于α，我们不能拒绝零假设，即模型具有相同的平均性能，任何观察到的平均精度差异都可能是统计上的侥幸。
+如果 p 值小于或等于所选的α，我们拒绝零假设，即模型具有相同的平均性能，这意味着差异可能是真实的。如果 p 值大于α，我们不能拒绝零假设，即模型具有相同的平均性能，任何观察到的平均精确率差异都可能是统计上的侥幸。
 
 alpha 值越小越好，常用值为 5%(0.05)。
 
@@ -134,7 +134,7 @@ print(X.shape, y.shape)
 
 我们将在这个数据集上比较两种线性算法的性能。具体来说，一个[逻辑回归](https://machinelearningmastery.com/logistic-regression-tutorial-for-machine-learning/)算法和一个[线性判别分析](https://machinelearningmastery.com/linear-discriminant-analysis-for-machine-learning/) (LDA)算法。
 
-我喜欢的程序是使用重复的分层 k-fold 交叉验证，重复 10 次和 3 次。我们将使用此过程来评估每个算法，并返回和报告平均分类精度。
+我喜欢的程序是使用重复的分层 k-fold 交叉验证，重复 10 次和 3 次。我们将使用此过程来评估每个算法，并返回和报告平均分类精确率。
 
 下面列出了完整的示例。
 
@@ -165,9 +165,9 @@ pyplot.boxplot([scores1, scores2], labels=['LR', 'LDA'], showmeans=True)
 pyplot.show()
 ```
 
-运行该示例首先报告每个算法的平均分类精度。
+运行该示例首先报告每个算法的平均分类精确率。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，结果表明，如果我们只看平均分数，线性判别分析的性能更好:逻辑回归为 89.2%，线性判别分析为 89.3%。
 
@@ -244,7 +244,7 @@ else:
 
 运行这个例子，我们首先评估之前的算法，然后报告统计假设检验的结果。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到 p 值约为 0.3，比 0.05 大得多。这导致我们无法拒绝零假设，这表明算法之间的任何观察到的差异可能都不是真实的。
 
@@ -261,7 +261,7 @@ Algorithms probably have the same performance
 
 回想一下，我们在报告绩效时使用的程序(3×10 CV)与统计测试中用于评估绩效的程序(5×2 CV)不同。如果我们使用五次重复的双重交叉验证来看分数，结果可能会有所不同？
 
-更新以下示例，以使用 5×2 CV 报告每个算法的分类精度。
+更新以下示例，以使用 5×2 CV 报告每个算法的分类精确率。
 
 ```py
 # use 5x2 statistical hypothesis testing procedure to compare two machine learning algorithms
@@ -296,9 +296,9 @@ else:
 	print('Algorithms probably have the same performance')
 ```
 
-运行该示例会报告两种算法的平均精度以及统计测试的结果。
+运行该示例会报告两种算法的平均精确率以及统计测试的结果。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到两种算法的平均性能差异甚至更大，89.4%对 89.0%支持逻辑回归，而不是我们在 3×10 CV 中看到的 LDA。
 

trans/ts/random-forest-for-time-series-forecasting.md

@@ -351,7 +351,7 @@ pyplot.show()
 
 运行该示例会报告测试集中每个步骤的预期值和预测值，然后是所有预测值的 MAE。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 我们可以看到，该模型比持久性模型表现得更好，实现了大约 5.9 次出生的 MAE，而不是 6.7 次出生。
 

trans/xgb/gentle-introduction-xgboost-applied-machine-learning.md

@@ -102,7 +102,7 @@ XGBoost 的基准性能，取自[基准随机森林实现](http://datascience.la
 
 从他的实验中，他评论道:
 
-> 我还尝试了 xgboost，这是一个流行的增强库，它也能构建随机森林。它速度快，内存效率高，精度高
+> 我还尝试了 xgboost，这是一个流行的增强库，它也能构建随机森林。它速度快，内存效率高，精确率高
 
 — Szilard Pafka，[基准测试随机森林实现](http://datascience.la/benchmarking-random-forest-implementations/)。
 

trans/xgb/tune-xgboost-performance-with-learning-curves.md

@@ -167,7 +167,7 @@ evalset = [(X_train, y_train), (X_test,y_test)]
 model.fit(X_train, y_train, eval_metric='logloss', eval_set=evalset)
 ```
 
-一旦模型被拟合，我们可以评估它的性能作为测试数据集上的分类精度。
+一旦模型被拟合，我们可以评估它的性能作为测试数据集上的分类精确率。
 
 ```py
 ...
@@ -238,9 +238,9 @@ pyplot.show()
 
 运行该示例符合 XGBoost 模型，检索计算出的指标，并绘制学习曲线。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-首先，报告模型性能，表明该模型在等待测试集上实现了约 94.5%的分类精度。
+首先，报告模型性能，表明该模型在等待测试集上实现了约 94.5%的分类精确率。
 
 ```py
 Accuracy: 0.945
@@ -312,9 +312,9 @@ pyplot.show()
 
 运行示例拟合和评估模型，并绘制模型性能的学习曲线。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-我们可以看到，更多的迭代导致精度从大约 94.5%提升到大约 95.8%。
+我们可以看到，更多的迭代导致精确率从大约 94.5%提升到大约 95.8%。
 
 ```py
 Accuracy: 0.958
@@ -372,7 +372,7 @@ pyplot.show()
 
 运行示例拟合和评估模型，并绘制模型性能的学习曲线。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 我们可以看到，学习率越小，准确率越差，从 95.8%左右下降到 95.1%左右。
 
@@ -430,7 +430,7 @@ pyplot.show()
 
 运行示例拟合和评估模型，并绘制模型性能的学习曲线。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 我们可以看到，更多的迭代给了算法更大的改进空间，达到了 96.1%的准确率，是目前为止最好的。
 
@@ -492,9 +492,9 @@ pyplot.show()
 
 运行示例拟合和评估模型，并绘制模型性能的学习曲线。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
-我们可以看到，正则化的加入导致了进一步的改进，碰撞精度从大约 96.1%提高到大约 96.6%。
+我们可以看到，正则化的加入导致了进一步的改进，碰撞精确率从大约 96.1%提高到大约 96.6%。
 
 ```py
 Accuracy: 0.966

trans/xgb/xgboost-for-regression.md

@@ -256,7 +256,7 @@ print('Mean MAE: %.3f (%.3f)' % (scores.mean(), scores.std()) )
 
 运行该示例评估住房数据集上的 XGBoost 回归算法，并报告 10 倍交叉验证的三次重复的平均 MAE。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型实现了大约 2.1 的 MAE。
 
@@ -306,7 +306,7 @@ print('Predicted: %.3f' % yhat)
 
 运行该示例符合模型，并对新的数据行进行预测。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 在这种情况下，我们可以看到模型预测的值约为 24。
 

trans/xgb/xgboost-for-time-series-forecasting.md

@@ -388,7 +388,7 @@ pyplot.show()
 
 运行该示例会报告测试集中每个步骤的预期值和预测值，然后是所有预测值的 MAE。
 
-**注**:考虑到算法或评估程序的随机性，或数值精度的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
+**注**:考虑到算法或评估程序的随机性，或数值精确率的差异，您的[结果可能会有所不同](https://machinelearningmastery.com/different-results-each-time-in-machine-learning/)。考虑运行该示例几次，并比较平均结果。
 
 我们可以看到，该模型比持久性模型表现得更好，实现了大约 5.9 次出生的 MAE，而不是 6.7 次出生。