2019-04-14 12:08:52

docs/dl-keras/display-deep-learning-model-training-history-in-keras.md

@@ -109,9 +109,9 @@ plt.show()
 
 ![Plot of Model Accuracy on Train and Validation Datasets](img/aa735153796f8cda098d2fe7fb675e75.png)
 
-列车和验证数据集的模型精度图
+训练和验证数据集的模型精度图
 
-从损失图中，我们可以看到该模型在列车和验证数据集上都具有可比性（标记为测试）。如果这些平行的地块开始一致地离开，那么可能是在早期时期停止训练的迹象。
+从损失图中，我们可以看到该模型在训练和验证数据集上都具有可比性（标记为测试）。如果这些平行的地块开始一致地离开，那么可能是在早期时期停止训练的迹象。
 
 ![Plot of Model Loss on Training and Validation Datasets](img/429db1e26cf59719f9b941d5e8a7b919.png)
 

docs/dl-keras/evaluate-skill-deep-learning-models.md

@@ -44,11 +44,11 @@
 
 我们有一个有限的数据样本，我们需要发现最好的模型。
 
-### 使用列车测试拆分
+### 使用训练测试拆分
 
-我们通过将数据分成两部分来做到这一点，在数据的第一部分拟合模型或特定模型配置，并使用拟合模型对其余部分进行预测，然后评估这些预测的技能。这被称为列车测试分割，我们使用该技能估计模型在对新数据进行预测时在实践中的表现。
+我们通过将数据分成两部分来做到这一点，在数据的第一部分拟合模型或特定模型配置，并使用拟合模型对其余部分进行预测，然后评估这些预测的技能。这被称为训练测试分割，我们使用该技能估计模型在对新数据进行预测时在实践中的表现。
 
-例如，这里有一些用于使用列车测试分割来评估模型的伪代码：
+例如，这里有一些用于使用训练测试分割来评估模型的伪代码：
 
 ```py
 train, test = split(data)
@@ -57,7 +57,7 @@ predictions = model.predict(test.X)
 skill = compare(test.y, predictions)
 ```
 
-如果您有大量数据或非常慢的模型进行训练，列车测试分割是一种很好的方法，但由于数据的随机性（模型的方差），模型的最终技能分数会很嘈杂。 。
+如果您有大量数据或非常慢的模型进行训练，训练测试分割是一种很好的方法，但由于数据的随机性（模型的方差），模型的最终技能分数会很嘈杂。 。
 
 这意味着适合不同数据的相同模型将给出不同的模型技能分数。
 

docs/dl-keras/tutorial-first-neural-network-python-keras.md

@@ -167,7 +167,7 @@ model.fit(X, Y, epochs=150, batch_size=10)
 
 我们已经在整个数据集上训练了神经网络，我们可以在同一数据集上评估网络的表现。
 
-这只会让我们了解我们对数据集建模的程度（例如列车精度），但不知道算法在新数据上的表现如何。我们这样做是为了简化，但理想情况下，您可以将数据分成训练和测试数据集，以便对模型进行训练和评估。
+这只会让我们了解我们对数据集建模的程度（例如训练精度），但不知道算法在新数据上的表现如何。我们这样做是为了简化，但理想情况下，您可以将数据分成训练和测试数据集，以便对模型进行训练和评估。
 
 您可以使用模型上的 **evaluate（）**函数在训练数据集上评估模型，并将其传递给用于训练模型的相同输入和输出。
 

docs/dl-nlp/deep-learning-bag-of-words-model-sentiment-analysis.md

@@ -75,7 +75,7 @@
 2.  加载和清理数据以删除标点符号和数字。
 3.  定义首选词汇的词汇。
 
-### 分为火车和测试装置
+### 分为训练和测试装置
 
 我们假装我们正在开发一种系统，可以预测文本电影评论的情感是积极的还是消极的。
 
@@ -85,7 +85,7 @@
 
 话虽如此，我们将使用最近 100 次正面评论和最后 100 次负面评论作为测试集（100 条评论），其余 1,800 条评论作为训练数据集。
 
-这是 90％的列车，10％的数据分割。
+这是 90％的训练，10％的数据分割。
 
 通过使用评论的文件名可以轻松实现拆分，其中评论为 000 至 899 的评论用于训练数据，而评论为 900 以上的评论用于测试模型。
 
@@ -789,7 +789,7 @@ print('Test Accuracy: %f' % (acc*100))
 
 在测试数据集上评估模型，我们可以看到模型表现良好，达到 90％以上的准确率，完全在原始论文中看到的 80-80 年代中期。
 
-虽然，重要的是要注意这不是一个苹果对苹果的比较，因为原始论文使用 10 倍交叉验证来估计模型技能而不是单个列车/测试分裂。
+虽然，重要的是要注意这不是一个苹果对苹果的比较，因为原始论文使用 10 倍交叉验证来估计模型技能而不是单个训练/测试分裂。
 
 ```py
 ...
@@ -820,7 +820,7 @@ Keras API 中 Tokenizer 的 _texts_to_matrix（）_ 函数提供了 4 种不同
 
 我们可以使用 4 种支持的单词评分模式中的每一种来评估上一节中开发的模型的技能。
 
-这首先涉及开发一种函数，以基于所选择的评分模型来创建所加载文档的编码。该函数创建标记器，将其拟合到训练文档上，然后使用所选模型创建训练和测试编码。函数 _prepare_data（）_ 在给定列车和测试文档列表的情况下实现此行为。
+这首先涉及开发一种函数，以基于所选择的评分模型来创建所加载文档的编码。该函数创建标记器，将其拟合到训练文档上，然后使用所选模型创建训练和测试编码。函数 _prepare_data（）_ 在给定训练和测试文档列表的情况下实现此行为。
 
 ```py
 # prepare bag of words encoding of docs
@@ -840,7 +840,7 @@ def prepare_data(train_docs, test_docs, mode):
 
 因为神经网络是随机的，当相同的模型适合相同的数据时，它们可以产生不同的结果。这主要是因为随机初始权重和小批量梯度下降期间的模式混洗。这意味着任何一个模型评分都是不可靠的，我们应该根据多次运行的平均值来估计模型技能。
 
-下面的函数名为 _evaluate_mode（）_，它通过在火车上训练它并在测试集上估计技能 30 次来获取编码文档并评估 MLP，并返回所有这些精度得分的列表。运行。
+下面的函数名为 _evaluate_mode（）_，它通过在训练上训练它并在测试集上估计技能 30 次来获取编码文档并评估 MLP，并返回所有这些精度得分的列表。运行。
 
 ```py
 # evaluate a neural network model

docs/dl-nlp/develop-a-caption-generation-model-in-keras.md

@@ -425,7 +425,7 @@ def load_set(filename):
 
 接下来，我们需要将集合拆分为训练集和测试集。
 
-我们将首先通过对标识符进行排序来对它们进行排序，以确保我们始终在机器和运行中对它们进行一致的分割，然后将前 100 个用于列车，接下来的 100 个用于测试。
+我们将首先通过对标识符进行排序来对它们进行排序，以确保我们始终在机器和运行中对它们进行一致的分割，然后将前 100 个用于训练，接下来的 100 个用于测试。
 
 下面的 _train_test_split（）_ 函数将在加载的标识符集作为输入的情况下创建此拆分。
 
@@ -438,7 +438,7 @@ def train_test_split(dataset):
 	return set(ordered[:100]), set(ordered[100:200])
 ```
 
-现在，我们可以使用预定义的一组列车或测试标识符加载照片描述。
+现在，我们可以使用预定义的一组训练或测试标识符加载照片描述。
 
 下面是函数 _load_clean_descriptions（）_，它为来自' _descriptionss.txt_ '的已清除文本描述加载给定的一组标识符，并将标识符字典返回给文本。
 
@@ -557,7 +557,7 @@ test_features = load_photo_features('features.pkl', test)
 print('Photos: train=%d, test=%d' % (len(train_features), len(test_features)))
 ```
 
-运行此示例首先在开发数据集中加载 1,000 个照片标识符。选择火车和测试集并用于过滤一组干净的照片描述和准备好的图像特征。
+运行此示例首先在开发数据集中加载 1,000 个照片标识符。选择训练和测试集并用于过滤一组干净的照片描述和准备好的图像特征。
 
 我们快到了。
 
@@ -847,7 +847,7 @@ NLTK Python 库在 [_corpus_bleu（）_ 函数](http://www.nltk.org/api/nltk.tra
 
 理想情况下，我们会重复实验 30 次或更多次，但这对我们的小型测试工具来说需要很长时间。相反，将评估模型 3 次。它会更快，但平均分数会有更高的差异。
 
-下面定义了模型评估循环。在运行结束时，列车和测试集的 BLEU 分数的分布被保存到文件中。
+下面定义了模型评估循环。在运行结束时，训练和测试集的 BLEU 分数的分布被保存到文件中。
 
 ```py
 # run experiment
@@ -1195,7 +1195,7 @@ min    0.018522  0.026055
 max    0.058660  0.060624
 ```
 
-我们可以看到该运行获得了非常相似的均值和标准差 BLEU 分数。具体而言，在列车上的平均 BLEU 为 0.03 对 0.06，对于测试为 0.04 至 0.04。
+我们可以看到该运行获得了非常相似的均值和标准差 BLEU 分数。具体而言，在训练上的平均 BLEU 为 0.03 对 0.06，对于测试为 0.04 至 0.04。
 
 线束有点吵，但足够稳定，可以进行比较。
 
@@ -1207,7 +1207,7 @@ max    0.058660  0.060624
 
 重要的是，基线模型具有一定的能力，以便我们可以将基线的 BLEU 分数与产生什么样的描述质量的想法联系起来。
 
-让我们训练一个模型并从火车和测试集生成一些描述作为健全性检查。
+让我们训练一个模型并从训练和测试集生成一些描述作为健全性检查。
 
 将重复次数更改为 1，将运行名称更改为“ _baseline_generate_ ”。
 
@@ -1240,7 +1240,7 @@ def evaluate_model(model, descriptions, photos, tokenizer, max_length):
 
 重新运行示例。
 
-您应该看到列车的结果如下所示（具体结果将根据算法的随机性质而变化）：
+您应该看到训练的结果如下所示（具体结果将根据算法的随机性质而变化）：
 
 ```py
 Actual:    startseq boy bites hard into treat while he sits outside endseq
@@ -1429,7 +1429,7 @@ def define_model(vocab_size, max_length):
 model_name = 'size_sm_seq_model'
 ```
 
-运行这个例子，我们可以看到两列火车上的小凹凸和基线测试。这可能是小训练集大小的神器。
+运行这个例子，我们可以看到两列训练上的小凹凸和基线测试。这可能是小训练集大小的神器。
 
 ```py
           train      test
@@ -1473,7 +1473,7 @@ def define_model(vocab_size, max_length):
 model_name = 'size_lg_seq_model'
 ```
 
-运行此实验表明 BLEU 在列车和测试装置上都有不错的碰撞。
+运行此实验表明 BLEU 在训练和测试装置上都有不错的碰撞。
 
 ```py
           train      test
@@ -2124,7 +2124,7 @@ max    0.157885  0.049904
 
 我们还可以查看结果的分布。
 
-下面是一些代码，用于加载每个实验的保存结果，并在列车和测试集上创建结果的盒子和须状图以供审查。
+下面是一些代码，用于加载每个实验的保存结果，并在训练和测试集上创建结果的盒子和须状图以供审查。
 
 ```py
 from os import listdir
@@ -2212,6 +2212,6 @@ pyplot.show()
 
 你能想到什么实验？
 你还尝试了什么？
-您可以在火车和测试数据集上获得哪些最佳结果？
+您可以在训练和测试数据集上获得哪些最佳结果？
 
 请在下面的评论中告诉我。
\ No newline at end of file

docs/dl-nlp/develop-a-deep-learning-caption-generation-model-in-python.md

@@ -17,7 +17,7 @@
 
 *   如何准备用于训练深度学习模型的照片和文本数据。
 *   如何设计和训练深度学习字幕生成模型。
-*   如何评估列车标题生成模型并使用它来标注全新的照片。
+*   如何评估训练标题生成模型并使用它来标注全新的照片。
 
 **注**：摘录自：“[深度学习自然语言处理](https://machinelearningmastery.com/deep-learning-for-nlp/)”。
 看一下，如果你想要更多的分步教程，在使用文本数据时充分利用深度学习方法。
@@ -489,9 +489,9 @@ Vocabulary Size: 8,763
 
 我们将训练训练数据集中所有照片和标题的数据。在训练期间，我们将监控模型在开发数据集上的表现，并使用该表现来决定何时将模型保存到文件。
 
-列车和开发数据集已分别在 _Flickr_8k.trainImages.txt_ 和 _Flickr_8k.devImages.txt_ 文件中预定义，两者都包含照片文件名列表。从这些文件名中，我们可以提取照片标识符并使​​用这些标识符来过滤每组的照片和说明。
+训练和开发数据集已分别在 _Flickr_8k.trainImages.txt_ 和 _Flickr_8k.devImages.txt_ 文件中预定义，两者都包含照片文件名列表。从这些文件名中，我们可以提取照片标识符并使​​用这些标识符来过滤每组的照片和说明。
 
-下面的函数 _load_set（）_ 将在给定列车或开发集文件名的情况下加载一组预定义的标识符。
+下面的函数 _load_set（）_ 将在给定训练或开发集文件名的情况下加载一组预定义的标识符。
 
 ```py
 # load doc into memory
@@ -519,7 +519,7 @@ def load_set(filename):
 	return set(dataset)
 ```
 
-现在，我们可以使用预定义的一系列列车或开发标识符来加载照片和描述。
+现在，我们可以使用预定义的一系列训练或开发标识符来加载照片和描述。
 
 下面是函数 _load_clean_descriptions（）_，它为来自' _descriptionss.txt_ '的已清除文本描述加载给定的一组标识符，并将标识符字典返回给文本描述列表。
 
@@ -1151,7 +1151,7 @@ def create_sequences(tokenizer, max_length, desc_list, photo):
 
 我们现在拥有我们所需要的一切。
 
-注意，这是一个非常基本的数据生成器。它提供的大内存节省是在拟合模型之前不在存储器中具有列车和测试数据的展开序列，这些样本（例如来自 _create_sequences（）_ 的结果）是根据每张照片的需要创建的。
+注意，这是一个非常基本的数据生成器。它提供的大内存节省是在拟合模型之前不在存储器中具有训练和测试数据的展开序列，这些样本（例如来自 _create_sequences（）_ 的结果）是根据每张照片的需要创建的。
 
 一些关于进一步改进这种数据生成器的袖口想法包括：
 
@@ -1933,7 +1933,7 @@ startseq dog is running across the beach endseq
 
 *   如何准备照片和文本数据，为深度学习模型的训练做好准备。
 *   如何设计和训练深度学习字幕生成模型。
-*   如何评估列车标题生成模型并使用它来标注全新的照片。
+*   如何评估训练标题生成模型并使用它来标注全新的照片。
 
 你有任何问题吗？
 在下面的评论中提出您的问题，我会尽力回答。

docs/dl-nlp/develop-n-gram-multichannel-convolutional-neural-network-sentiment-analysis.md

@@ -87,7 +87,7 @@
 2.  加载和清理数据以删除标点符号和数字。
 3.  准备所有评论并保存到文件。
 
-### 分为火车和测试装置
+### 分为训练和测试装置
 
 我们假装我们正在开发一种系统，可以预测文本电影评论的情感是积极的还是消极的。
 
@@ -97,7 +97,7 @@
 
 话虽如此，我们将使用最近 100 次正面评论和最后 100 次负面评论作为测试集（100 条评论），其余 1,800 条评论作为训练数据集。
 
-这是 90％的列车，10％的数据分割。
+这是 90％的训练，10％的数据分割。
 
 通过使用评论的文件名可以轻松实现拆分，其中评论为 000 至 899 的评论用于训练数据，而评论为 900 以上的评论用于测试。
 
@@ -167,7 +167,7 @@ print(tokens)
 
 为此，我们将在下面开发一个名为 _process_docs（）_ 的新函数，它将遍历目录中的所有评论，清理它们并将它们作为列表返回。
 
-我们还将为函数添加一个参数，以指示函数是处理序列还是测试评论，这样可以过滤文件名（如上所述），并且只清理和返回所请求的那些列车或测试评论。
+我们还将为函数添加一个参数，以指示函数是处理序列还是测试评论，这样可以过滤文件名（如上所述），并且只清理和返回所请求的那些训练或测试评论。
 
 完整功能如下所列。
 
@@ -199,7 +199,7 @@ def process_docs(directory, is_trian):
 negative_docs = process_docs('txt_sentoken/neg', True)
 ```
 
-接下来，我们需要列车和测试文件的标签。我们知道我们有 900 份训练文件和 100 份测试文件。我们可以使用 Python 列表推导为列车和测试集的负（0）和正（1）评论创建标签。
+接下来，我们需要训练和测试文件的标签。我们知道我们有 900 份训练文件和 100 份测试文件。我们可以使用 Python 列表推导为训练和测试集的负（0）和正（1）评论创建标签。
 
 ```py
 trainy = [0 for _ in range(900)] + [1 for _ in range(900)]

docs/dl-nlp/develop-neural-machine-translation-system-keras.md

@@ -33,7 +33,7 @@
 
 1.  德语到英语翻译数据集
 2.  准备文本数据
-3.  列车神经翻译模型
+3.  训练神经翻译模型
 4.  评估神经翻译模型
 
 ### Python 环境
@@ -329,11 +329,11 @@ save_clean_data(train, 'english-german-train.pkl')
 save_clean_data(test, 'english-german-test.pkl')
 ```
 
-运行该示例将创建三个新文件： _english-german-both.pkl_ ，其中包含我们可用于定义问题参数的所有训练和测试示例，例如最大短语长度和词汇，以及火车和测试数据集的 _english-german-train.pkl_ 和 _english-german-test.pkl_ 文件。
+运行该示例将创建三个新文件： _english-german-both.pkl_ ，其中包含我们可用于定义问题参数的所有训练和测试示例，例如最大短语长度和词汇，以及训练和测试数据集的 _english-german-train.pkl_ 和 _english-german-test.pkl_ 文件。
 
 我们现在准备开始开发我们的翻译模型。
 
-## 列车神经翻译模型
+## 训练神经翻译模型
 
 在本节中，我们将开发神经翻译模型。
 
@@ -356,7 +356,7 @@ train = load_clean_sentences('english-german-train.pkl')
 test = load_clean_sentences('english-german-test.pkl')
 ```
 
-我们将使用“两者”或列车和测试数据集的组合来定义问题的最大长度和词汇。
+我们将使用“两者”或训练和测试数据集的组合来定义问题的最大长度和词汇。
 
 这是为了简单起见。或者，我们可以单独从训练数据集定义这些属性，并截断测试集中的例子，这些例子太长或者词汇不在词汇表中。
 
@@ -648,9 +648,9 @@ Epoch 00029: val_loss did not improve
 
 ## 评估神经翻译模型
 
-我们将评估列车上的模型和测试数据集。
+我们将评估训练上的模型和测试数据集。
 
-该模型应该在火车数据集上表现很好，并且理想情况下已被推广以在测试数据集上表现良好。
+该模型应该在训练数据集上表现很好，并且理想情况下已被推广以在测试数据集上表现良好。
 
 理想情况下，我们将使用单独的验证数据集来帮助在训练期间选择模型而不是测试集。您可以尝试将其作为扩展名。
 

docs/dl-nlp/develop-word-embedding-model-predicting-movie-review-sentiment.md

@@ -33,7 +33,7 @@
 
 1.  电影评论数据集
 2.  数据准备
-3.  火车嵌入层
+3.  训练嵌入层
 4.  训练 word2vec 嵌入
 5.  使用预先训练的嵌入
 
@@ -98,7 +98,7 @@
 2.  加载和清理数据以删除标点符号和数字。
 3.  定义首选词汇的词汇。
 
-### 分为火车和测试装置
+### 分为训练和测试装置
 
 我们假装我们正在开发一种系统，可以预测文本电影评论的情感是积极的还是消极的。
 
@@ -108,7 +108,7 @@
 
 话虽如此，我们将使用最近 100 次正面评论和最后 100 次负面评论作为测试集（100 条评论），其余 1,800 条评论作为训练数据集。
 
-这是 90％的列车，10％的数据分割。
+这是 90％的训练，10％的数据分割。
 
 通过使用评论的文件名可以轻松实现拆分，其中评论为 000 至 899 的评论用于训练数据，而评论为 900 以上的评论用于测试。
 

docs/dl-nlp/prepare-photo-caption-dataset-training-deep-learning-model.md

@@ -300,7 +300,7 @@ dump(features, open('features.pkl', 'wb'))
 
 - [框架图像描述作为排名任务：数据，模型和评估指标](https://www.jair.org/media/3994/live-3994-7274-jair.pdf)，2013。
 
-还有列车/测试拆分中使用的照片标识符列表，以便您可以比较报告中报告的结果。
+还有训练/测试拆分中使用的照片标识符列表，以便您可以比较报告中报告的结果。
 
 第一步是决定使用哪些字幕。最简单的方法是对每张照片使用第一个描述。
 

docs/dl-nlp/prepare-text-data-deep-learning-keras.md

@@ -192,7 +192,7 @@ print(t.word_index)
 print(t.word_docs)
 ```
 
-一旦 Tokenizer 适合训练数据，它就可用于编码列车或测试数据集中的文档。
+一旦 Tokenizer 适合训练数据，它就可用于编码训练或测试数据集中的文档。
 
 Tokenizer 上的 texts_to_matrix（）函数可用于为每个输入提供每个文档创建一个向量。向量的长度是词汇表的总大小。
 

docs/dl-ts/cnn-models-for-human-activity-recognition-time-series-classification.md

@@ -71,7 +71,7 @@
 
 从每个窗口提取在人类活动识别领域中常用的许多时间和频率特征。结果是 561 元素的特征向量。
 
-根据受试者的数据，将数据集分成训练（70％）和测试（30％）组。列车 21 个，测试 9 个。
+根据受试者的数据，将数据集分成训练（70％）和测试（30％）组。训练 21 个，测试 9 个。
 
 使用旨在用于智能手机的支持向量机（例如定点算术）的实验结果导致测试数据集的预测准确度为 89％，实现与未修改的 SVM 实现类似的结果。
 
@@ -110,7 +110,7 @@
 
 这意味着一行数据具有（128 * 9）或 1,152 个元素。这比前一节中 561 个元素向量的大小小一倍，并且可能存在一些冗余数据。
 
-信号存储在 train 和 test 子目录下的/ _Inertial Signals_ /目录中。每个信号的每个轴都存储在一个单独的文件中，这意味着每个列车和测试数据集都有九个要加载的输入文件和一个要加载的输出文件。在给定一致的目录结构和文件命名约定的情况下，我们可以批量加载这些文件。
+信号存储在 train 和 test 子目录下的/ _Inertial Signals_ /目录中。每个信号的每个轴都存储在一个单独的文件中，这意味着每个训练和测试数据集都有九个要加载的输入文件和一个要加载的输出文件。在给定一致的目录结构和文件命名约定的情况下，我们可以批量加载这些文件。
 
 输入数据采用 CSV 格式，其中列由空格分隔。这些文件中的每一个都可以作为 NumPy 数组加载。下面的 _load_file（）_ 函数在给定文件的文件路径的情况下加载数据集，并将加载的数据作为 NumPy 数组返回。
 
@@ -139,9 +139,9 @@ def load_group(filenames, prefix=''):
 	return loaded
 ```
 
-我们可以使用此功能加载给定组的所有输入信号数据，例如火车或测试。
+我们可以使用此功能加载给定组的所有输入信号数据，例如训练或测试。
 
-下面的 _load_dataset_group（）_ 函数使用列车和测试目录之间的一致命名约定加载单个组的所有输入信号数据和输出数据。
+下面的 _load_dataset_group（）_ 函数使用训练和测试目录之间的一致命名约定加载单个组的所有输入信号数据和输出数据。
 
 ```py
 # load a dataset group, such as train or test
@@ -162,11 +162,11 @@ def load_dataset_group(group, prefix=''):
 	return X, y
 ```
 
-最后，我们可以加载每个列车和测试数据集。
+最后，我们可以加载每个训练和测试数据集。
 
 输出数据定义为类号的整数。我们必须对这些类整数进行热编码，以使数据适合于拟合神经网络多类分类模型。我们可以通过调用 [to_categorical（）Keras 函数](https://keras.io/utils/#to_categorical)来实现。
 
-下面的 _load_dataset（）_ 函数实现了这种行为，并返回列车并测试 _X_ 和 _y_ 元素，以便拟合和评估定义的模型。
+下面的 _load_dataset（）_ 函数实现了这种行为，并返回训练并测试 _X_ 和 _y_ 元素，以便拟合和评估定义的模型。
 
 ```py
 # load the dataset, returns train and test X and y elements
@@ -423,7 +423,7 @@ def run_experiment(repeats=10):
 run_experiment()
 ```
 
-运行该示例首先打印已加载数据集的形状，然后打印列车和测试集的形状以及输入和输出元素。这确认了样本数，时间步长和变量，以及类的数量。
+运行该示例首先打印已加载数据集的形状，然后打印训练和测试集的形状以及输入和输出元素。这确认了样本数，时间步长和变量，以及类的数量。
 
 接下来，创建和评估模型，并为每个模型打印调试消息。
 

docs/dl-ts/evaluate-machine-learning-algorithms-for-human-activity-recognition.md

@@ -70,7 +70,7 @@
 
 从每个窗口提取在人类活动识别领域中常用的许多时间和频率特征。结果是 561 元素的特征向量。
 
-根据受试者的数据，将数据集分成训练（70％）和测试（30％）组。列车 21 个，测试 9 个。
+根据受试者的数据，将数据集分成训练（70％）和测试（30％）组。训练 21 个，测试 9 个。
 
 使用旨在用于智能手机的支持向量机（例如定点算术）的实验结果导致测试数据集的预测准确度为 89％，实现与未修改的 SVM 实现类似的结果。
 
@@ -100,7 +100,7 @@
 
 ### 加载数据集
 
-第一步是加载列车并测试输入（X）和输出（y）数据。
+第一步是加载训练并测试输入（X）和输出（y）数据。
 
 具体来说，以下文件：
 
@@ -120,7 +120,7 @@ def load_file(filepath):
 	return dataframe.values
 ```
 
-考虑到目录布局和文件名的相似性，我们可以调用此函数来加载给定列车或测试集组的 _X_ 和 _y_ 文件。下面的 _load_dataset_group（）_ 函数将为一个组加载这两个文件，并将 X 和 y 元素作为 NumPy 数组返回。然后，此函数可用于加载列车和测试组的 X 和 y 元素。
+考虑到目录布局和文件名的相似性，我们可以调用此函数来加载给定训练或测试集组的 _X_ 和 _y_ 文件。下面的 _load_dataset_group（）_ 函数将为一个组加载这两个文件，并将 X 和 y 元素作为 NumPy 数组返回。然后，此函数可用于加载训练和测试组的 X 和 y 元素。
 
 ```py
 # load a dataset group, such as train or test
@@ -369,7 +369,7 @@ results = evaluate_models(trainX, trainy, testX, testy, models)
 summarize_results(results)
 ```
 
-运行该示例首先加载列车和测试数据集，显示每个输入和输出组件的形状。
+运行该示例首先加载训练和测试数据集，显示每个输入和输出组件的形状。
 
 然后依次评估八个模型，打印每个模型的表现。
 
@@ -423,7 +423,7 @@ Name=bayes, Score=77.027
 
 这意味着一行数据具有 128 * 9 或 1,152 个元素。这比前一节中 561 个元素向量的大小小一倍，并且可能存在一些冗余数据。
 
-信号存储在列车和测试子目录下的 _/ Inertial Signals /_ 目录中。每个信号的每个轴都存储在一个单独的文件中，这意味着每个列车和测试数据集都有九个要加载的输入文件和一个要加载的输出文件。在给定一致的目录结构和文件命名约定的情况下，我们可以批量加载这些文件。
+信号存储在训练和测试子目录下的 _/ Inertial Signals /_ 目录中。每个信号的每个轴都存储在一个单独的文件中，这意味着每个训练和测试数据集都有九个要加载的输入文件和一个要加载的输出文件。在给定一致的目录结构和文件命名约定的情况下，我们可以批量加载这些文件。
 
 首先，我们可以将给定组的所有数据加载到单个三维 NumPy 数组中，其中数组的维数为[样本，时间步长，特征]。为了更清楚，有 128 个时间步和 9 个特征，其中样本数是任何给定原始信号数据文件中的行数。
 
@@ -441,7 +441,7 @@ def load_group(filenames, prefix=''):
 	return loaded
 ```
 
-我们可以使用此功能加载给定组的所有输入信号数据，例如火车或测试。
+我们可以使用此功能加载给定组的所有输入信号数据，例如训练或测试。
 
 下面的 _load_dataset_group（）_ 函数使用目录之间的一致命名约定加载单个组的所有输入信号数据和输出数据。
 
@@ -464,13 +464,13 @@ def load_dataset_group(group, prefix=''):
 	return X, y
 ```
 
-最后，我们可以加载每个列车和测试数据集。
+最后，我们可以加载每个训练和测试数据集。
 
 作为准备加载数据的一部分，我们必须将窗口和特征展平为一个长向量。
 
 我们可以使用 NumPy 重塑功能执行此操作，并将[_ 样本，时间步长，特征 _]的三个维度转换为[_ 样本，时间步长*特征 _]的两个维度。
 
-下面的 _load_dataset（）_ 函数实现了这种行为，并返回列车并测试 _X_ 和 _y_ 元素，以便拟合和评估定义的模型。
+下面的 _load_dataset（）_ 函数实现了这种行为，并返回训练并测试 _X_ 和 _y_ 元素，以便拟合和评估定义的模型。
 
 ```py
 # load the dataset, returns train and test X and y elements

docs/dl-ts/exploratory-configuration-multilayer-perceptron-network-time-series-forecasting.md

@@ -118,7 +118,7 @@ Name: Sales, dtype: float64
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。
+这将通过训练和测试数据集的结构进行模拟。
 
 将收集关于测试数据集的所有预测，并计算错误分数以总结模型的技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 
@@ -463,17 +463,17 @@ def run():
 run()
 ```
 
-运行诊断程序打印最终列车并测试每次运行的 RMSE。更有趣的是创建的最终线图。
+运行诊断程序打印最终训练并测试每次运行的 RMSE。更有趣的是创建的最终线图。
 
-线图显示了每个训练时期之后的列车 RMSE（蓝色）和测试 RMSE（橙色）。
+线图显示了每个训练时期之后的训练 RMSE（蓝色）和测试 RMSE（橙色）。
 
-在这种情况下，诊断图显示在大约 400 个训练时期之后训练和测试 RMSE 几乎没有差异。火车和测试表现均接近平坦线。
+在这种情况下，诊断图显示在大约 400 个训练时期之后训练和测试 RMSE 几乎没有差异。训练和测试表现均接近平坦线。
 
 这种快速平衡表明模型正在达到容量，并且可以从滞后观察或额外神经元方面的更多信息中受益。
 
 ![Diagnostic Line Plot of Train and Test Performance of 400 Epochs on the Shampoo Sales Dataset](img/95474940827213c21c63294561b2a74d.jpg)
 
-火车诊断线图和洗发水销售数据集 1000 个时期的测试表现
+训练诊断线图和洗发水销售数据集 1000 个时期的测试表现
 
 ## 改变隐藏层神经元
 
@@ -572,7 +572,7 @@ def run():
 
 ![Diagnostic Line Plot of Train and Test Performance of 3 Hidden Neurons on the Shampoo Sales Dataset](img/f483fd406f5bb07ab05d0afad48bddfa.jpg)
 
-火车诊断线图和 3 个隐藏神经元在洗发水销售数据集上的测试表现
+训练诊断线图和 3 个隐藏神经元在洗发水销售数据集上的测试表现
 
 ## 具有滞后的变隐藏层神经元
 
@@ -711,13 +711,13 @@ def run():
 	pyplot.savefig('diagnostic_neurons_lag.png')
 ```
 
-运行诊断脚本会创建一个线图，显示在每个训练时期之后 10 次实验运行的列车和测试 RMSE。
+运行诊断脚本会创建一个线图，显示在每个训练时期之后 10 次实验运行的训练和测试 RMSE。
 
-结果表明在前 500 个时期内学习良好，并且可能在剩余的时期过度拟合，测试 RMSE 显示出增加的趋势，并且列车 RMSE 显示出下降趋势。
+结果表明在前 500 个时期内学习良好，并且可能在剩余的时期过度拟合，测试 RMSE 显示出增加的趋势，并且训练 RMSE 显示出下降趋势。
 
 ![Diagnostic Line Plot of Train and Test Performance of 3 Hidden Neurons and Lag Features on the Shampoo Sales Dataset](img/e82707712edc7aa1034e873eb9275227.jpg)
 
-火车诊断线图和 3 个隐藏神经元的测试表现和洗发水销售数据集的滞后特征
+训练诊断线图和 3 个隐藏神经元的测试表现和洗发水销售数据集的滞后特征
 
 ## 审查结果
 

docs/dl-ts/how-to-develop-a-probabilistic-forecasting-model-to-predict-air-pollution-days.md

@@ -158,9 +158,9 @@ pyplot.show()
 
 我们可以执行一些最小的数据准备。
 
-下面的示例加载数据集，用 0.0 替换缺失的观测值，将数据构建为监督学习问题（明天根据今天的观察结果预测臭氧），并根据大量天数将数据分成火车和测试集。两年。
+下面的示例加载数据集，用 0.0 替换缺失的观测值，将数据构建为监督学习问题（明天根据今天的观察结果预测臭氧），并根据大量天数将数据分成训练和测试集。两年。
 
-您可以探索替换缺失值的替代方法，例如输入平均值。此外，2004 年是一个闰年，因此将数据分成火车和测试集并不是一个干净的 5 - 2 年分裂，但是对于本教程来说足够接近。
+您可以探索替换缺失值的替代方法，例如输入平均值。此外，2004 年是一个闰年，因此将数据分成训练和测试集并不是一个干净的 5 - 2 年分裂，但是对于本教程来说足够接近。
 
 ```py
 # load and prepare
@@ -191,7 +191,7 @@ savetxt('train.csv', train, delimiter=',')
 savetxt('test.csv', test, delimiter=',')
 ```
 
-运行该示例将列车和测试集保存为 CSV 文件，并汇总两个数据集的形状。
+运行该示例将训练和测试集保存为 CSV 文件，并汇总两个数据集的形状。
 
 ```py
 (1803, 73) (730, 73)

docs/dl-ts/how-to-develop-a-skilful-time-series-forecasting-model.md

@@ -116,7 +116,7 @@ _ 你做什么的？_
 
 如果您正在寻找想法，下面是一个常见的时间序列预测模型评估方案：
 
-1.  将数据集拆分为火车和测试集。
+1.  将数据集拆分为训练和测试集。
 2.  在训练数据集上拟合候选方法。
 3.  直接对测试集进行预测或使用前向验证。
 4.  计算将预测与预期值进行比较的指标。
@@ -210,7 +210,7 @@ _ 你做什么的？_
 加快模型评估的一些想法包括：
 
 *   通过云硬件（例如 Amazon EC2）并行使用多台计算机。
-*   减小列车或测试数据集的大小，以使评估过程更快。
+*   减小训练或测试数据集的大小，以使评估过程更快。
 *   如果以后有时间，请使用更粗糙的超参数网格并圈回。
 *   也许不要为前进验证中的每个步骤重新设计模型。
 

docs/dl-ts/how-to-develop-an-autoregression-forecast-model-for-household-electricity-consumption.md

@@ -292,7 +292,7 @@ def split_dataset(data):
 	return train, test
 ```
 
-我们可以通过加载每日数据集并打印列车和测试集的第一行和最后一行数据来测试此功能，以确认它们符合上述预期。
+我们可以通过加载每日数据集并打印训练和测试集的第一行和最后一行数据来测试此功能，以确认它们符合上述预期。
 
 完整的代码示例如下所示。
 
@@ -322,9 +322,9 @@ print(test.shape)
 print(test[0, 0, 0], test[-1, -1, 0])
 ```
 
-运行该示例表明，列车数据集确实有 159 周的数据，而测试数据集有 46 周。
+运行该示例表明，训练数据集确实有 159 周的数据，而测试数据集有 46 周。
 
-我们可以看到，第一行和最后一行的列车和测试数据集的总有效功率与我们定义为每组标准周界限的特定日期的数据相匹配。
+我们可以看到，第一行和最后一行的训练和测试数据集的总有效功率与我们定义为每组标准周界限的特定日期的数据相匹配。
 
 ```py
 (159, 7, 8)

docs/dl-ts/how-to-develop-autoregressive-forecasting-models-for-multi-step-air-pollution-time-series-forecasting.md

@@ -157,11 +157,11 @@ Total Chunks: 208
 
 每个观察都有一行称为' _position_within_chunk_ '，从 1 到 192（8 天* 24 小时）不等。因此，我们可以将此列中值小于或等于 120（5 * 24）的所有行作为训练数据，将任何大于 120 的值作为测试数据。
 
-此外，任何在列车或测试分割中没有任何观察的块都可以被丢弃，因为不可行。
+此外，任何在训练或测试分割中没有任何观察的块都可以被丢弃，因为不可行。
 
-在使用朴素模型时，我们只对目标变量感兴趣，而不对输入的气象变量感兴趣。因此，我们可以删除输入数据，并使列车和测试数据仅包含每个块的 39 个目标变量，以及块和观察时间内的位置。
+在使用朴素模型时，我们只对目标变量感兴趣，而不对输入的气象变量感兴趣。因此，我们可以删除输入数据，并使训练和测试数据仅包含每个块的 39 个目标变量，以及块和观察时间内的位置。
 
-下面的 _split_train_test（）_ 函数实现了这种行为;给定一个块的字典，它将每个分成列车和测试块数据。
+下面的 _split_train_test（）_ 函数实现了这种行为;给定一个块的字典，它将每个分成训练和测试块数据。
 
 ```py
 # split each chunk into train/test sets
@@ -329,7 +329,7 @@ savetxt('AirQualityPrediction/naive_test.csv', test_rows, delimiter=',')
 
 运行该示例首先评论了从数据集中移除了块 69 以获得不足的数据。
 
-然后我们可以看到每个列车和测试集中有 42 列，一个用于块 ID，块内位置，一天中的小时和 39 个训练变量。
+然后我们可以看到每个训练和测试集中有 42 列，一个用于块 ID，块内位置，一天中的小时和 39 个训练变量。
 
 我们还可以看到测试数据集的显着缩小版本，其中行仅在预测前置时间。
 

docs/dl-ts/how-to-develop-baseline-forecasts-for-multi-site-multivariate-air-pollution-time-series-forecasting.md

@@ -206,11 +206,11 @@ Total Chunks: 208
 
 每个观察都有一行称为' _position_within_chunk_ '，从 1 到 192（8 天* 24 小时）不等。因此，我们可以将此列中值小于或等于 120（5 * 24）的所有行作为训练数据，将任何大于 120 的值作为测试数据。
 
-此外，任何在列车或测试分割中没有任何观察的块都可以被丢弃，因为不可行。
+此外，任何在训练或测试分割中没有任何观察的块都可以被丢弃，因为不可行。
 
-在使用朴素模型时，我们只对目标变量感兴趣，而不对输入的气象变量感兴趣。因此，我们可以删除输入数据，并使列车和测试数据仅包含每个块的 39 个目标变量，以及块和观察时间内的位置。
+在使用朴素模型时，我们只对目标变量感兴趣，而不对输入的气象变量感兴趣。因此，我们可以删除输入数据，并使训练和测试数据仅包含每个块的 39 个目标变量，以及块和观察时间内的位置。
 
-下面的 _split_train_test（）_ 函数实现了这种行为;给定一个块的字典，它将每个分成列车和测试块数据。
+下面的 _split_train_test（）_ 函数实现了这种行为;给定一个块的字典，它将每个分成训练和测试块数据。
 
 ```py
 # split each chunk into train/test sets
@@ -378,7 +378,7 @@ savetxt('AirQualityPrediction/naive_test.csv', test_rows, delimiter=',')
 
 运行该示例首先评论了从数据集中移除了块 69 以获得不足的数据。
 
-然后我们可以看到每个列车和测试集中有 42 列，一个用于块 ID，块内位置，一天中的小时和 39 个训练变量。
+然后我们可以看到每个训练和测试集中有 42 列，一个用于块 ID，块内位置，一天中的小时和 39 个训练变量。
 
 我们还可以看到测试数据集的显着缩小版本，其中行仅在预测前置时间。
 
@@ -1609,7 +1609,7 @@ pyplot.show()
 
 我们可以看到持久性策略优于所有其他方法，并且第二个最佳策略是使用一小时的每个系列的全局中位数。
 
-在该列车/测试分离数据集上评估的模型必须达到低于 0.520 的总体 MAE 才能被认为是熟练的。
+在该训练/测试分离数据集上评估的模型必须达到低于 0.520 的总体 MAE 才能被认为是熟练的。
 
 ![Bar Chart with Summary of Naive Forecast Methods](img/21d06aff1fb1e5cd7453455d560e8c1f.jpg)
 

docs/dl-ts/how-to-develop-convolutional-neural-networks-for-multi-step-time-series-forecasting.md

@@ -294,7 +294,7 @@ def split_dataset(data):
 	return train, test
 ```
 
-我们可以通过加载每日数据集并打印列车和测试集的第一行和最后一行数据来测试此功能，以确认它们符合上述预期。
+我们可以通过加载每日数据集并打印训练和测试集的第一行和最后一行数据来测试此功能，以确认它们符合上述预期。
 
 完整的代码示例如下所示。
 
@@ -324,9 +324,9 @@ print(test.shape)
 print(test[0, 0, 0], test[-1, -1, 0])
 ```
 
-运行该示例表明，列车数据集确实有 159 周的数据，而测试数据集有 46 周。
+运行该示例表明，训练数据集确实有 159 周的数据，而测试数据集有 46 周。
 
-我们可以看到，第一行和最后一行的列车和测试数据集的总有效功率与我们定义为每组标准周界限的特定日期的数据相匹配。
+我们可以看到，第一行和最后一行的训练和测试数据集的总有效功率与我们定义为每组标准周界限的特定日期的数据相匹配。
 
 ```py
 (159, 7, 8)
@@ -1412,7 +1412,7 @@ cnn: [396.116] 414.5, 385.5, 377.2, 412.1, 371.1, 380.6, 428.1
 *   **输入大小**。探索用作模型输入的更多或更少天数，例如三天，21 天，30 天等。
 *   **模型调整**。调整模型的结构和超参数，并进一步平均提升模型表现。
 *   **数据缩放**。探索数据扩展（例如标准化和规范化）是否可用于改善任何 CNN 模型的表现。
-*   **学习诊断**。使用诊断，例如列车的学习曲线和验证损失以及均方误差，以帮助调整 CNN 模型的结构和超参数。
+*   **学习诊断**。使用诊断，例如训练的学习曲线和验证损失以及均方误差，以帮助调整 CNN 模型的结构和超参数。
 *   **不同的内核大小**。将多通道 CNN 与多头 CNN 结合使用，并为每个磁头使用不同的内核大小，以查看此配置是否可以进一步提高表现。
 
 如果你探索任何这些扩展，我很想知道。

docs/dl-ts/how-to-develop-deep-learning-models-for-univariate-time-series-forecasting.md

@@ -118,14 +118,14 @@ SARIMA 模型的表现可以衡量问题的良好模型。任何在过去 12 个
 
 本节分为以下几部分：
 
-1.  火车 - 测试分裂
+1.  训练 - 测试分裂
 2.  系列作为监督学习
 3.  前瞻性验证
 4.  重复评估
 5.  总结表现
 6.  工作示例
 
-### 火车 - 测试分裂
+### 训练 - 测试分裂
 
 第一步是将加载的系列分成训练和测试集。
 

docs/dl-ts/how-to-develop-lstm-models-for-multi-step-time-series-forecasting-of-household-power-consumption.md

@@ -322,7 +322,7 @@ def split_dataset(data):
 	return train, test
 ```
 
-我们可以通过加载每日数据集并打印列车和测试集的第一行和最后一行数据来测试此功能，以确认它们符合上述预期。
+我们可以通过加载每日数据集并打印训练和测试集的第一行和最后一行数据来测试此功能，以确认它们符合上述预期。
 
 完整的代码示例如下所示。
 
@@ -352,9 +352,9 @@ print(test.shape)
 print(test[0, 0, 0], test[-1, -1, 0])
 ```
 
-运行该示例表明，列车数据集确实有 159 周的数据，而测试数据集有 46 周。
+运行该示例表明，训练数据集确实有 159 周的数据，而测试数据集有 46 周。
 
-我们可以看到，第一行和最后一行的列车和测试数据集的总有效功率与我们定义为每组标准周界限的特定日期的数据相匹配。
+我们可以看到，第一行和最后一行的训练和测试数据集的总有效功率与我们定义为每组标准周界限的特定日期的数据相匹配。
 
 ```py
 (159, 7, 8)
@@ -1850,7 +1850,7 @@ lstm: [367.929] 416.3, 379.7, 334.7, 362.3, 374.7, 284.8, 406.7
 *   **输入大小**。探索用作模型输入的更多或更少天数，例如三天，21 天，30 天等。
 *   **模型调整**。调整模型的结构和超参数，并进一步平均提升模型表现。
 *   **数据缩放**。探索数据扩展（例如标准化和规范化）是否可用于改善任何 LSTM 模型的表现。
-*   **学习诊断**。使用诊断，例如列车的学习曲线和验证损失以及均方误差，以帮助调整 LSTM 模型的结构和超参数。
+*   **学习诊断**。使用诊断，例如训练的学习曲线和验证损失以及均方误差，以帮助调整 LSTM 模型的结构和超参数。
 
 如果你探索任何这些扩展，我很想知道。
 

docs/dl-ts/how-to-develop-machine-learning-models-for-multivariate-multi-step-air-pollution-time-series-forecasting.md

@@ -160,11 +160,11 @@ Total Chunks: 208
 
 每个观察都有一行称为' _position_within_chunk_ '，从 1 到 192（8 天* 24 小时）不等。因此，我们可以将此列中值小于或等于 120（5 * 24）的所有行作为训练数据，将任何大于 120 的值作为测试数据。
 
-此外，任何在列车或测试分割中没有任何观察的块都可以被丢弃，因为不可行。
+此外，任何在训练或测试分割中没有任何观察的块都可以被丢弃，因为不可行。
 
-在使用朴素模型时，我们只对目标变量感兴趣，而不对输入的气象变量感兴趣。因此，我们可以删除输入数据，并使列车和测试数据仅包含每个块的 39 个目标变量，以及块和观察时间内的位置。
+在使用朴素模型时，我们只对目标变量感兴趣，而不对输入的气象变量感兴趣。因此，我们可以删除输入数据，并使训练和测试数据仅包含每个块的 39 个目标变量，以及块和观察时间内的位置。
 
-下面的 _split_train_test（）_ 函数实现了这种行为;给定一个块的字典，它将每个分成列车和测试块数据。
+下面的 _split_train_test（）_ 函数实现了这种行为;给定一个块的字典，它将每个分成训练和测试块数据。
 
 ```py
 # split each chunk into train/test sets
@@ -332,7 +332,7 @@ savetxt('AirQualityPrediction/naive_test.csv', test_rows, delimiter=',')
 
 运行该示例首先评论了从数据集中移除了块 69 以获得不足的数据。
 
-然后我们可以看到每个列车和测试集中有 42 列，一个用于块 ID，块内位置，一天中的小时和 39 个训练变量。
+然后我们可以看到每个训练和测试集中有 42 列，一个用于块 ID，块内位置，一天中的小时和 39 个训练变量。
 
 我们还可以看到测试数据集的显着缩小版本，其中行仅在预测前置时间。
 
@@ -795,7 +795,7 @@ def data_prep(chunks, n_lag, n_vars=39):
 
 ### 完整的例子
 
-我们可以将所有内容组合在一起，并使用监督学习格式为机器学习算法准备列车和测试数据集。
+我们可以将所有内容组合在一起，并使用监督学习格式为机器学习算法准备训练和测试数据集。
 
 在预测每个预测提前期时，我们将使用先前 12 小时的滞后观测作为输入。
 
@@ -975,7 +975,7 @@ save('AirQualityPrediction/supervised_test.npy', test_data)
 
 运行示例可能需要一分钟。
 
-结果是包含列车和测试数据集的两个二进制文件，我们可以在以下部分加载这些文件，以便训练和评估问题的机器学习算法。
+结果是包含训练和测试数据集的两个二进制文件，我们可以在以下部分加载这些文件，以便训练和评估问题的机器学习算法。
 
 ## 模型评估测试线束
 

docs/dl-ts/how-to-develop-rnn-models-for-human-activity-recognition-time-series-classification.md

@@ -70,7 +70,7 @@
 
 从每个窗口提取在人类活动识别领域中常用的许多时间和频率特征。结果是 561 元素的特征向量。
 
-根据受试者的数据，将数据集分成训练（70％）和测试（30％）组。列车 21 个，测试 9 个。
+根据受试者的数据，将数据集分成训练（70％）和测试（30％）组。训练 21 个，测试 9 个。
 
 使用旨在用于智能手机的支持向量机（例如定点算术）的实验结果导致测试数据集的预测准确度为 89％，实现与未修改的 SVM 实现类似的结果。
 
@@ -109,7 +109,7 @@ LSTM 网络模型是一种循环神经网络，能够学习和记忆长输入数
 
 这意味着一行数据具有（128 * 9）或 1,152 个元素。这比前一节中 561 个元素向量的大小小一倍，并且可能存在一些冗余数据。
 
-信号存储在 train 和 test 子目录下的/ _Inertial Signals_ /目录中。每个信号的每个轴都存储在一个单独的文件中，这意味着每个列车和测试数据集都有九个要加载的输入文件和一个要加载的输出文件。在给定一致的目录结构和文件命名约定的情况下，我们可以批量加载这些文件。
+信号存储在 train 和 test 子目录下的/ _Inertial Signals_ /目录中。每个信号的每个轴都存储在一个单独的文件中，这意味着每个训练和测试数据集都有九个要加载的输入文件和一个要加载的输出文件。在给定一致的目录结构和文件命名约定的情况下，我们可以批量加载这些文件。
 
 输入数据采用 CSV 格式，其中列由空格分隔。这些文件中的每一个都可以作为 NumPy 数组加载。下面的 _load_file（）_ 函数在给定文件填充路径的情况下加载数据集，并将加载的数据作为 NumPy 数组返回。
 
@@ -138,7 +138,7 @@ def load_group(filenames, prefix=''):
 	return loaded
 ```
 
-我们可以使用此功能加载给定组的所有输入信号数据，例如火车或测试。
+我们可以使用此功能加载给定组的所有输入信号数据，例如训练或测试。
 
 下面的 _load_dataset_group（）_ 函数使用目录之间的一致命名约定加载单个组的所有输入信号数据和输出数据。
 
@@ -161,7 +161,7 @@ def load_dataset_group(group, prefix=''):
 	return X, y
 ```
 
-最后，我们可以加载每个列车和测试数据集。
+最后，我们可以加载每个训练和测试数据集。
 
 输出数据定义为类号的整数。我们必须对这些类整数进行热编码，以使数据适合于拟合神经网络多类分类模型。我们可以通过调用 [to_categorical（）Keras 函数](https://keras.io/utils/#to_categorical)来实现。
 
@@ -410,7 +410,7 @@ def run_experiment(repeats=10):
 run_experiment()
 ```
 
-运行该示例首先打印已加载数据集的形状，然后打印列车和测试集的形状以及输入和输出元素。这确认了样本数，时间步长和变量，以及类的数量。
+运行该示例首先打印已加载数据集的形状，然后打印训练和测试集的形状以及输入和输出元素。这确认了样本数，时间步长和变量，以及类的数量。
 
 接下来，创建和评估模型，并为每个模型打印调试消息。
 

docs/dl-ts/how-to-grid-search-deep-learning-models-for-time-series-forecasting.md

@@ -110,14 +110,14 @@ pyplot.show()
 
 本节分为以下几部分：
 
-1.  火车 - 测试分裂
+1.  训练 - 测试分裂
 2.  系列作为监督学习
 3.  前瞻性验证
 4.  重复评估
 5.  总结表现
 6.  工作示例
 
-### 火车 - 测试分裂
+### 训练 - 测试分裂
 
 第一步是将加载的系列分成训练和测试集。
 

docs/dl-ts/how-to-grid-search-triple-exponential-smoothing-for-time-series-forecasting-in-python.md

@@ -109,7 +109,7 @@ def exp_smoothing_forecast(history, config):
 	return yhat[0]
 ```
 
-接下来，我们需要建立一些函数，通过[前向验证](https://machinelearningmastery.com/backtest-machine-learning-models-time-series-forecasting/)重复拟合和评估模型，包括将数据集拆分为火车和测试集并评估一步预测。
+接下来，我们需要建立一些函数，通过[前向验证](https://machinelearningmastery.com/backtest-machine-learning-models-time-series-forecasting/)重复拟合和评估模型，包括将数据集拆分为训练和测试集并评估一步预测。
 
 我们可以使用给定指定大小的分割的切片来分割列表或 NumPy 数据数组，例如，从测试集中的数据中使用的时间步数。
 

docs/dl-ts/how-to-load-and-explore-a-standard-human-activity-recognition-problem.md

@@ -603,7 +603,7 @@ CNN LSTM 可用于 CNN 学习观察子序列的表示，然后 LSTM 学习这些
 
 ### 模型评估
 
-我不认为窗口的重叠是有用的，并且实际上如果在交叉验证期间跟踪数据的部分在列车和测试数据集中都可用，则实际上可能导致轻微的误导性结果。然而，它会增加训练数据的数量。
+我不认为窗口的重叠是有用的，并且实际上如果在交叉验证期间跟踪数据的部分在训练和测试数据集中都可用，则实际上可能导致轻微的误导性结果。然而，它会增加训练数据的数量。
 
 我认为重要的是将数据暴露给模型，同时保持观察的时间顺序。对于给定主题，来自单个活动的多个窗口可能看起来相似，并且随机改组和分离窗口以训练测试数据可能导致误导结果。
 

docs/dl-ts/how-to-load-visualize-and-explore-a-complex-multivariate-multistep-time-series-forecasting-dataset.md

@@ -1425,7 +1425,7 @@ LSTM 旨在处理序列数据，并可通过屏蔽直接支持丢失的数据。
 
 一种反映竞争中使用的朴素方法可能最适合评估模型。
 
-也就是说，将每个块分成列车和测试集，在这种情况下使用前五天的数据进行训练，其余三个用于测试。
+也就是说，将每个块分成训练和测试集，在这种情况下使用前五天的数据进行训练，其余三个用于测试。
 
 通过在整个数据集上进行训练并将预测提交给 Kaggle 网站以评估所保持的测试数据集，最终确定模型可能是有趣的。
 

docs/dl-ts/how-to-model-human-activity-from-smartphone-data.md

@@ -111,7 +111,7 @@
 
 从每个窗口提取在人类活动识别领域中常用的许多时间和频率特征。结果是 561 元素的特征向量。
 
-根据受试者的数据，将数据集分成训练（70％）和测试（30％）组。列车 21 个，测试 9 个。
+根据受试者的数据，将数据集分成训练（70％）和测试（30％）组。训练 21 个，测试 9 个。
 
 这表明问题的框架，其中一系列运动活动被用作输入来预测当前正在进行的活动的部分（2.56 秒），其中使用已知受试者训练的模型来预测新受试者的运动活动。 。
 
@@ -263,9 +263,9 @@ print(total_acc.shape)
 (7352, 128, 3)
 ```
 
-最后，我们可以使用到目前为止开发的两个函数来加载列车和测试数据集的所有数据。
+最后，我们可以使用到目前为止开发的两个函数来加载训练和测试数据集的所有数据。
 
-给定列车和测试文件夹中的并行结构，我们可以开发一个新函数来加载给定文件夹的所有输入和输出数据。该函数可以构建要加载的所有 9 个数据文件的列表，将它们作为一个具有 9 个特征的 NumPy 数组加载，然后加载包含输出类的数据文件。
+给定训练和测试文件夹中的并行结构，我们可以开发一个新函数来加载给定文件夹的所有输入和输出数据。该函数可以构建要加载的所有 9 个数据文件的列表，将它们作为一个具有 9 个特征的 NumPy 数组加载，然后加载包含输出类的数据文件。
 
 下面的 _load_dataset（）_ 函数实现了这种行为。它可以被称为“ _train_ ”组或“ _test_ ”组，作为字符串参数传递。
 
@@ -337,7 +337,7 @@ print(testX.shape, testy.shape)
 
 运行该示例将加载训练和测试数据集。
 
-我们可以看到测试数据集有 2,947 行窗口数据。正如预期的那样，我们可以看到列车和测试装置中的窗口大小匹配，并且每个列车和测试用例中的输出（y）大小与样本数量相匹配。
+我们可以看到测试数据集有 2,947 行窗口数据。正如预期的那样，我们可以看到训练和测试装置中的窗口大小匹配，并且每个训练和测试用例中的输出（y）大小与样本数量相匹配。
 
 ```py
 (7352, 128, 9) (7352, 1)
@@ -373,7 +373,7 @@ def class_breakdown(data):
 		print('Class=%d, total=%d, percentage=%.3f' % (i+1, counts[i], percent))
 ```
 
-总结列车和测试数据集中类的细分以确保它们具有类似的细分可能是有用的，然后将结果与组合数据集的细分进行比较。
+总结训练和测试数据集中类的细分以确保它们具有类似的细分可能是有用的，然后将结果与组合数据集的细分进行比较。
 
 下面列出了完整的示例。
 
@@ -424,7 +424,7 @@ class_breakdown(combined)
 
 测试集和两个数据集上的结果看起来非常相似。
 
-使用数据集可能是安全的，假设每个列车和测试集以及每个主题可以平衡类的分布。
+使用数据集可能是安全的，假设每个训练和测试集以及每个主题可以平衡类的分布。
 
 ```py
 Train Dataset
@@ -1027,7 +1027,7 @@ subX, suby = data_for_subject(trainX, trainy, sub_map, sub_id)
 plot_activity_histograms(subX, suby)
 ```
 
-运行该示例将创建包含六个子图的图，每个子图用于列车数据集中第一个主题的每个活动。总加速度数据的 x，y 和 z 轴中的每一个分别具有蓝色，橙色和绿色直方图。
+运行该示例将创建包含六个子图的图，每个子图用于训练数据集中第一个主题的每个活动。总加速度数据的 x，y 和 z 轴中的每一个分别具有蓝色，橙色和绿色直方图。
 
 我们可以看到每个活动都有不同的数据分布，大运动（前三个活动）与固定活动（最后三个活动）之间存在显着差异。前三个活动的数据分布看起来是高斯的，可能有不同的均值和标准偏差。后一活动的分布看起来是多模态的（即多个峰值）。
 
@@ -1239,7 +1239,7 @@ plot_activity_durations_by_subject(X, y, sub_map)
 
 ![Boxplot of activity durations per subject on train set](img/ecd2d7ec902c9f547e5b006036f581d3.jpg)
 
-火车组上每个受试者的活动持续时间的箱线图
+训练组上每个受试者的活动持续时间的箱线图
 
 我们可以使用以下附加行为训练数据创建类似的箱线图。
 

docs/dl-ts/how-to-predict-room-occupancy-based-on-environmental-factors.md

@@ -63,7 +63,7 @@
 这三个文件如下：
 
 *   **datatest.txt** （测试）：从 2015-02-02 14:19:00 到 2015-02-04 10:43:00
-*   **datatraining.txt** （火车）：从 2015-02-04 17:51:00 到 2015-02-10 09:33:00
+*   **datatraining.txt** （训练）：从 2015-02-04 17:51:00 到 2015-02-10 09:33:00
 *   **datatest2.txt** （val）：从 2015-02-11 14:48:00 到 2015-02-18 09:19:00
 
 最初显而易见的是，数据中的分割在时间上并不是连续的，并且存在差距。
@@ -140,10 +140,10 @@ pyplot.show()
 运行该示例会为每个数据集创建一个具有不同颜色的绘图：
 
 *   _datatest.txt_ （测试）：蓝色
-*   _datatraining.txt_ （火车）：橙色
+*   _datatraining.txt_ （训练）：橙色
 *   _datatest2.txt_ （val）：绿色
 
-我们可以看到测试和训练集之间的小差距以及列车和验证集之间的较大差距。
+我们可以看到测试和训练集之间的小差距以及训练和验证集之间的较大差距。
 
 我们还可以看到每个变量的系列中相应的结构（峰值）和房间占用率。
 
@@ -155,7 +155,7 @@ pyplot.show()
 
 我们可以通过保留数据的时间一致性并将所有三个集合连接成一个数据集来简化数据集，删除“ _no_ ”列。
 
-这将允许临时测试问题的简单直接框架（在下一部分中），该临时框架可以在临时一致的方式上使用特殊列车/测试装置尺寸进行测试。
+这将允许临时测试问题的简单直接框架（在下一部分中），该临时框架可以在临时一致的方式上使用特殊训练/测试装置尺寸进行测试。
 
 **注意**：这种简化不考虑数据中的时间间隙，并且依赖于先前时​​间步骤的一系列观察的算法可能需要不同的数据组织。
 

docs/dl-ts/how-to-predict-whether-eyes-are-open-or-closed-using-brain-waves.md

@@ -305,13 +305,13 @@ Final Score: 0.975
 
 ## 用时间顺序训练分裂训练
 
-我们可以做的第一个测试是评估 KNN 模型的技能，当数据集被洗牌时，以及当数据集不是时，列车/测试分割。
+我们可以做的第一个测试是评估 KNN 模型的技能，当数据集被洗牌时，以及当数据集不是时，训练/测试分割。
 
 在分割之前对数据进行混洗的情况下，我们期望结果类似于上一节中的交叉验证结果，特别是如果测试集是数据集的 10％。
 
 如果关于时间排序和基于实例的方法在未来使用相邻示例的重要性的理论是正确的，那么我们期望在拆分之前数据集未被洗牌的测试更糟糕。
 
-首先，下面的示例将数据集拆分为列车/测试拆分，分别为 90％/ 10％的数据。在拆分之前对数据集进行洗牌。
+首先，下面的示例将数据集拆分为训练/测试拆分，分别为 90％/ 10％的数据。在拆分之前对数据集进行洗牌。
 
 ```py
 # knn for predicting eye state

docs/dl-ts/instability-online-learning-stateful-lstm-time-series-forecasting.md

@@ -138,7 +138,7 @@ Name: Sales, dtype: float64
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。
+这将通过训练和测试数据集的结构进行模拟。
 
 将收集关于测试数据集的所有预测，并计算错误分数以总结模型的技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 

docs/dl-ts/multi-step-time-series-forecasting-long-short-term-memory-networks-python.md

@@ -154,7 +154,7 @@ Sep,	Oct, Nov, Dec
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。
+这将通过训练和测试数据集的结构进行模拟。
 
 将收集关于测试数据集的所有预测并计算错误分数以总结每个预测时间步骤的模型技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 
@@ -292,7 +292,7 @@ print(test)
 print('Train: %s, Test: %s' % (train.shape, test.shape))
 ```
 
-首先运行该示例将打印整个测试数据集，即最后 10 行。还打印了列车测试数据集的形状和大小。
+首先运行该示例将打印整个测试数据集，即最后 10 行。还打印了训练测试数据集的形状和大小。
 
 ```py
 [[ 342.3  339.7  440.4  315.9]

docs/dl-ts/multi-step-time-series-forecasting-with-machine-learning-models-for-household-electricity-consumption.md

@@ -292,7 +292,7 @@ def split_dataset(data):
 	return train, test
 ```
 
-我们可以通过加载每日数据集并打印列车和测试集的第一行和最后一行数据来测试此功能，以确认它们符合上述预期。
+我们可以通过加载每日数据集并打印训练和测试集的第一行和最后一行数据来测试此功能，以确认它们符合上述预期。
 
 完整的代码示例如下所示。
 
@@ -322,9 +322,9 @@ print(test.shape)
 print(test[0, 0, 0], test[-1, -1, 0])
 ```
 
-运行该示例表明，列车数据集确实有 159 周的数据，而测试数据集有 46 周。
+运行该示例表明，训练数据集确实有 159 周的数据，而测试数据集有 46 周。
 
-我们可以看到，第一行和最后一行的列车和测试数据集的总有效功率与我们定义为每组标准周界限的特定日期的数据相匹配。
+我们可以看到，第一行和最后一行的训练和测试数据集的总有效功率与我们定义为每组标准周界限的特定日期的数据相匹配。
 
 ```py
 (159, 7, 8)

docs/dl-ts/multivariate-time-series-forecasting-lstms-keras.md

@@ -279,7 +279,7 @@ test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))
 print(train_X.shape, train_y.shape, test_X.shape, test_y.shape)
 ```
 
-运行此示例打印列车的形状并测试输入和输出集，其中大约 9K 小时的数据用于训练，大约 35K 小时用于测试。
+运行此示例打印训练的形状并测试输入和输出集，其中大约 9K 小时的数据用于训练，大约 35K 小时用于测试。
 
 ```py
 (8760, 1, 8) (8760,) (35039, 1, 8) (35039,)
@@ -440,7 +440,7 @@ rmse = sqrt(mean_squared_error(inv_y, inv_yhat))
 print('Test RMSE: %.3f' % rmse)
 ```
 
-首先运行该示例创建一个图表，显示训练期间的火车和测试损失。
+首先运行该示例创建一个图表，显示训练期间的训练和测试损失。
 
 有趣的是，我们可以看到测试损失低于训练损失。该模型可能过度拟合训练数据。在训练期间测量和绘制 RMSE 可能会对此有所了解。
 
@@ -448,7 +448,7 @@ print('Test RMSE: %.3f' % rmse)
 
 训练期间多变量 LSTM 的训练线路和试验损失
 
-列车和测试损失在每个训练时期结束时打印。在运行结束时，将打印测试数据集上模型的最终 RMSE。
+训练和测试损失在每个训练时期结束时打印。在运行结束时，将打印测试数据集上模型的最终 RMSE。
 
 我们可以看到该模型实现了 26.496 的可观 RMSE，低于使用持久性模型找到的 30 的 RMSE。
 
@@ -649,11 +649,11 @@ Epoch 50/50
 1s - loss: 0.0144 - val_loss: 0.0149
 ```
 
-绘制了在时期上的列车和测试损失的图。
+绘制了在时期上的训练和测试损失的图。
 
 ![Plot of Loss on the Train and Test Datasets](img/b0483faab77f135fd4f690e151595898.jpg)
 
-列车和测试数据集损失情节
+训练和测试数据集损失情节
 
 最后，测试 RMSE 被打印出来，至少在这个问题上并没有真正显示出技能上的任何优势。
 

docs/dl-ts/naive-methods-for-forecasting-household-electricity-consumption.md

@@ -289,7 +289,7 @@ def split_dataset(data):
 	return train, test
 ```
 
-我们可以通过加载每日数据集并打印列车和测试集的第一行和最后一行数据来测试此功能，以确认它们符合上述预期。
+我们可以通过加载每日数据集并打印训练和测试集的第一行和最后一行数据来测试此功能，以确认它们符合上述预期。
 
 完整的代码示例如下所示。
 
@@ -319,9 +319,9 @@ print(test.shape)
 print(test[0, 0, 0], test[-1, -1, 0])
 ```
 
-运行该示例表明，列车数据集确实有 159 周的数据，而测试数据集有 46 周。
+运行该示例表明，训练数据集确实有 159 周的数据，而测试数据集有 46 周。
 
-我们可以看到，第一行和最后一行的列车和测试数据集的总有效功率与我们定义为每组标准周界限的特定日期的数据相匹配。
+我们可以看到，第一行和最后一行的训练和测试数据集的总有效功率与我们定义为每组标准周界限的特定日期的数据相匹配。
 
 ```py
 (159, 7, 8)

docs/dl-ts/seed-state-lstms-time-series-forecasting-python.md

@@ -140,7 +140,7 @@ Name: Sales, dtype: float64
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。我们将以一次性方法进行所有预测。
+这将通过训练和测试数据集的结构进行模拟。我们将以一次性方法进行所有预测。
 
 将收集关于测试数据集的所有预测，并计算错误分数以总结模型的技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 

docs/dl-ts/stateful-stateless-lstm-time-series-forecasting-python.md

@@ -113,7 +113,7 @@ Name: Sales, dtype: float64
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。
+这将通过训练和测试数据集的结构进行模拟。
 
 将收集关于测试数据集的所有预测，并计算错误分数以总结模型的技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 
@@ -718,7 +718,7 @@ pyplot.show()
 
 种子实验的平均结果表明，在对测试数据集进行预测之前，对训练数据集进行预测的播种 LSTM 状态是中性的，如果不是导致表现稍差。
 
-在列车和测试装置上的每次预测之后重置状态似乎导致稍微更好的表现，而在训练或测试期间不重置状态似乎导致最佳表现。
+在训练和测试装置上的每次预测之后重置状态似乎导致稍微更好的表现，而在训练或测试期间不重置状态似乎导致最佳表现。
 
 关于播种的这些结果令人惊讶，但我们应该注意，平均值都在 5 个月洗发水销售的测试 RMSE 内，并且可能是统计噪声。
 

docs/dl-ts/time-series-forecasting-long-short-term-memory-network-python.md

@@ -622,7 +622,7 @@ def forecast(model, batch_size, row):
 *   为简洁起见，缩放和反缩放行为已移至函数 _scale（）_ 和 _invert_scale（）_。
 *   使用缩放器在训练数据上的拟合来缩放测试数据，这是确保测试数据的最小值/最大值不影响模型所需的。
 *   调整数据变换的顺序以便于首先使数据静止，然后是监督学习问题，然后进行缩放。
-*   为了方便起见，在分成列车和测试集之前对整个数据集执行差分。我们可以在前进验证过程中轻松收集观察结果，并在我们前进时区分它们。为了便于阅读，我决定反对它。
+*   为了方便起见，在分成训练和测试集之前对整个数据集执行差分。我们可以在前进验证过程中轻松收集观察结果，并在我们前进时区分它们。为了便于阅读，我决定反对它。
 
 下面列出了完整的示例。
 

docs/dl-ts/time-series-prediction-lstm-recurrent-neural-networks-python-keras.md

@@ -203,7 +203,7 @@ testX, testY = create_dataset(test, look_back)
 
 LSTM 网络期望输入数据（X）以以下形式提供特定的阵列结构： _[样本，时间步长，特征]_ 。
 
-目前，我们的数据形式为：[_ 样本，特征 _]，我们将问题定为每个样本的一个时间步长。我们可以使用 **numpy.reshape（）**将准备好的列车和测试输入数据转换为预期结构，如下所示：
+目前，我们的数据形式为：[_ 样本，特征 _]，我们将问题定为每个样本的一个时间步长。我们可以使用 **numpy.reshape（）**将准备好的训练和测试输入数据转换为预期结构，如下所示：
 
 ```py
 # reshape input to be [samples, time steps, features]
@@ -224,7 +224,7 @@ model.compile(loss='mean_squared_error', optimizer='adam')
 model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
 ```
 
-一旦模型拟合，我们就可以估计模型在列车和测试数据集上的表现。这将为我们提供新模型的比较点。
+一旦模型拟合，我们就可以估计模型在训练和测试数据集上的表现。这将为我们提供新模型的比较点。
 
 请注意，我们在计算错误分数之前反转预测，以确保以与原始数据相同的单位报告表现（每月数千名乘客）。
 
@@ -244,7 +244,7 @@ testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
 print('Test Score: %.2f RMSE' % (testScore))
 ```
 
-最后，我们可以使用模型为列车和测试数据集生成预测，以获得模型技能的直观指示。
+最后，我们可以使用模型为训练和测试数据集生成预测，以获得模型技能的直观指示。
 
 由于数据集的准备方式，我们必须改变预测，使它们在 x 轴上与原始数据集对齐。准备好后，绘制数据，以蓝色显示原始数据集，以绿色显示训练数据集的预测，以及以红色显示未见测试数据集的预测。
 

docs/dl-ts/time-series-prediction-with-deep-learning-in-python-with-keras.md

@@ -160,7 +160,7 @@ model.compile(loss='mean_squared_error', optimizer='adam')
 model.fit(trainX, trainY, epochs=200, batch_size=2, verbose=2)
 ```
 
-一旦模型拟合，我们就可以估计模型在列车和测试数据集上的表现。这将为我们提供新模型的比较点。
+一旦模型拟合，我们就可以估计模型在训练和测试数据集上的表现。这将为我们提供新模型的比较点。
 
 ```py
 # Estimate model performance
@@ -170,9 +170,9 @@ testScore = model.evaluate(testX, testY, verbose=0)
 print('Test Score: %.2f MSE (%.2f RMSE)' % (testScore, math.sqrt(testScore)))
 ```
 
-最后，我们可以使用模型为列车和测试数据集生成预测，以获得模型技能的直观指示。
+最后，我们可以使用模型为训练和测试数据集生成预测，以获得模型技能的直观指示。
 
-由于数据集是如何准备的，我们必须改变预测，以便它们在 x 轴上与原始数据集一致。准备好后，绘制数据，以蓝色显示原始数据集，以绿色显示火车数据集的预测，以红色显示未见测试数据集的预测。
+由于数据集是如何准备的，我们必须改变预测，以便它们在 x 轴上与原始数据集一致。准备好后，绘制数据，以蓝色显示原始数据集，以绿色显示训练数据集的预测，以红色显示未见测试数据集的预测。
 
 ```py
 # generate predictions for training

docs/dl-ts/tune-lstm-hyperparameters-keras-time-series-forecasting.md

@@ -112,7 +112,7 @@ Name: Sales, dtype: float64
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。我们将以一次性方法进行所有预测。
+这将通过训练和测试数据集的结构进行模拟。我们将以一次性方法进行所有预测。
 
 将收集关于测试数据集的所有预测，并计算错误分数以总结模型的技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 
@@ -136,11 +136,11 @@ Name: Sales, dtype: float64
 
 诊断方法将用于研究模型配置。这是创建和研究模型技能随时间变化的线图（称为时期的训练迭代），以深入了解给定配置如何执行以及如何调整以获得更好的表现。
 
-在每个时期结束时，将在列车和测试数据集上评估模型，并保存 RMSE 分数。
+在每个时期结束时，将在训练和测试数据集上评估模型，并保存 RMSE 分数。
 
-打印每个方案结束时的列车和测试 RMSE 分数，以指示进度。
+打印每个方案结束时的训练和测试 RMSE 分数，以指示进度。
 
-一系列列车和测试 RMSE 得分在运行结束时绘制为线图。火车得分为蓝色，考试成绩为橙色。
+一系列训练和测试 RMSE 得分在运行结束时绘制为线图。训练得分为蓝色，考试成绩为橙色。
 
 让我们深入研究结果。
 
@@ -297,7 +297,7 @@ def run():
 run()
 ```
 
-运行实验在 10 次实验运行的每一次结束时打印列车的 RMSE 和测试集。
+运行实验在 10 次实验运行的每一次结束时打印训练的 RMSE 和测试集。
 
 ```py
 0) TrainRMSE=63.495594, TestRMSE=113.472643
@@ -312,7 +312,7 @@ run()
 9) TrainRMSE=71.749335, TestRMSE=126.396615
 ```
 
-还创建了在每个训练时期之后列车和测试集上的一系列 RMSE 得分的线图。
+还创建了在每个训练时期之后训练和测试集上的一系列 RMSE 得分的线图。
 
 ![Diagnostic Results with 500 Epochs](img/d31b96331b0a1d029333ff3432b836b1.jpg)
 
@@ -336,7 +336,7 @@ run()
 n_epochs = 1000
 ```
 
-运行该示例为最后一个时期的列车和测试集打印 RMSE。
+运行该示例为最后一个时期的训练和测试集打印 RMSE。
 
 ```py
 0) TrainRMSE=69.242394, TestRMSE=90.832025
@@ -359,7 +359,7 @@ n_epochs = 1000
 
 我们可以看到模型误差的下降趋势确实继续并且似乎变慢。
 
-火车和测试案例的线条变得更加横向，但仍然普遍呈下降趋势，尽管变化率较低。测试误差的一些示例显示可能的拐点大约 600 个时期并且可能显示出上升趋势。
+训练和测试案例的线条变得更加横向，但仍然普遍呈下降趋势，尽管变化率较低。测试误差的一些示例显示可能的拐点大约 600 个时期并且可能显示出上升趋势。
 
 值得进一步延长时代。我们对测试集中的平均表现持续改进感兴趣，这可能会持续下去。
 
@@ -375,7 +375,7 @@ n_epochs = 1000
 n_epochs = 2000
 ```
 
-运行该示例为最后一个时期的列车和测试集打印 RMSE。
+运行该示例为最后一个时期的训练和测试集打印 RMSE。
 
 ```py
 0) TrainRMSE=67.292970, TestRMSE=83.096856
@@ -396,7 +396,7 @@ n_epochs = 2000
 
 2000 年的诊断结果
 
-正如人们可能已经猜到的那样，在列车和测试数据集的额外 1000 个时期内，误差的下降趋势仍在继续。
+正如人们可能已经猜到的那样，在训练和测试数据集的额外 1000 个时期内，误差的下降趋势仍在继续。
 
 值得注意的是，大约一半的案例一直持续减少到运行结束，而其余案件则显示出增长趋势的迹象。
 
@@ -416,7 +416,7 @@ n_epochs = 2000
 n_epochs = 4000
 ```
 
-运行该示例为最后一个时期的列车和测试集打印 RMSE。
+运行该示例为最后一个时期的训练和测试集打印 RMSE。
 
 ```py
 0) TrainRMSE=58.889277, TestRMSE=99.121765
@@ -702,7 +702,7 @@ n_batch = 1
 
 还创建了每个时期的测试和训练 RMSE 得分的线图。
 
-该图表明测试 RMSE 随时间变化的可变性更大，并且可能是火车 RMSE 比较大的批量大小更快稳定。测试 RMSE 的可变性增加是可以预期的，因为对网络进行的大量更改会给每次更新提供如此少的反馈。
+该图表明测试 RMSE 随时间变化的可变性更大，并且可能是训练 RMSE 比较大的批量大小更快稳定。测试 RMSE 的可变性增加是可以预期的，因为对网络进行的大量更改会给每次更新提供如此少的反馈。
 
 该图还表明，如果配置提供更多的训练时期，RMSE 的下降趋势可能会继续。
 
@@ -867,7 +867,7 @@ n_neurons = 3
 
 运行此配置将打印每次运行的最后一个时期的 RMSE 分数。
 
-结果与上一节类似;我们没有看到 2 或 3 个神经元的最终时期测试分数之间有太大的差异。最终的火车得分看起来似乎低于 3 个神经元，可能表现出过度拟合的加速。
+结果与上一节类似;我们没有看到 2 或 3 个神经元的最终时期测试分数之间有太大的差异。最终的训练得分看起来似乎低于 3 个神经元，可能表现出过度拟合的加速。
 
 训练数据集中的拐点似乎比 2 个神经元实验更早发生，可能在 300-400 时代。
 

docs/dl-ts/update-lstm-networks-training-time-series-forecasting.md

@@ -115,7 +115,7 @@ Name: Sales, dtype: float64
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。
+这将通过训练和测试数据集的结构进行模拟。
 
 将收集关于测试数据集的所有预测，并计算错误分数以总结模型的技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 

docs/dl-ts/use-dropout-lstm-networks-time-series-forecasting.md

@@ -117,7 +117,7 @@ Name: Sales, dtype: float64
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。
+这将通过训练和测试数据集的结构进行模拟。
 
 将收集关于测试数据集的所有预测，并计算错误分数以总结模型的技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 
@@ -481,11 +481,11 @@ def run():
 run()
 ```
 
-运行诊断程序打印最终列车并测试每次运行的 RMSE。更有趣的是创建的最终线图。
+运行诊断程序打印最终训练并测试每次运行的 RMSE。更有趣的是创建的最终线图。
 
-线图显示了每个训练时期之后的列车 RMSE（蓝色）和测试 RMSE（橙色）。
+线图显示了每个训练时期之后的训练 RMSE（蓝色）和测试 RMSE（橙色）。
 
-在这种情况下，诊断图显示列车和测试 RMSE 稳定下降到大约 400-500 个时期，此后似乎可能发生一些过度拟合。这表现为列车 RMSE 的持续下降和测试 RMSE 的增加。
+在这种情况下，诊断图显示训练和测试 RMSE 稳定下降到大约 400-500 个时期，此后似乎可能发生一些过度拟合。这表现为训练 RMSE 的持续下降和测试 RMSE 的增加。
 
 ![Diagnostic Line Plot of the Baseline Model on the Shampoo Sales Daset](img/71241dc27d1854fe4b9daedfd2d2436c.jpg)
 
@@ -664,9 +664,9 @@ def run():
 	pyplot.savefig('diagnostic_dropout_input.png')
 ```
 
-运行更新的诊断会在每个训练时期之后创建列车图并测试模型的 RMSE 表现以及输入丢失。
+运行更新的诊断会在每个训练时期之后创建训练图并测试模型的 RMSE 表现以及输入丢失。
 
-结果显示在列车上明显增加了凸起并测试了 RMSE 轨迹，这在测试 RMSE 分数上更为明显。
+结果显示在训练上明显增加了凸起并测试了 RMSE 轨迹，这在测试 RMSE 分数上更为明显。
 
 我们还可以看到过度拟合的症状已经通过测试 RMSE 在整个 1000 个时期内持续下降来解决，这可能表明需要额外的训练时期来利用这种行为。
 
@@ -843,7 +843,7 @@ def run():
 	pyplot.savefig('diagnostic_dropout_recurrent.png')
 ```
 
-运行更新的诊断会在每个训练时期之后创建列车图并测试模型的 RMSE 表现以及输入丢失。
+运行更新的诊断会在每个训练时期之后创建训练图并测试模型的 RMSE 表现以及输入丢失。
 
 该图显示了测试 RMSE 迹线上增加的凸起，对训练 RMSE 迹线几乎没有影响。该图还表明，在大约 500 个时期之后，如果不是测试 RMSE 的增加趋势，则该平台也是如此。
 

docs/dl-ts/use-features-lstm-networks-time-series-forecasting.md

@@ -110,7 +110,7 @@ Name: Sales, dtype: float64
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。
+这将通过训练和测试数据集的结构进行模拟。
 
 将收集关于测试数据集的所有预测，并计算错误分数以总结模型的技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 
@@ -527,7 +527,7 @@ max    133.270446  204.260072  242.186747  288.907803  335.595974
 
 本节列出了您可能考虑探索的一些进一步调查的领域。
 
-*   **诊断运行图**。对于给定的实验，在多次运行的情况下查看列车和测试 RMSE 的图可能是有帮助的。这可能有助于梳理过度拟合或过度拟合是否正在发生，反过来又是解决它的方法。
+*   **诊断运行图**。对于给定的实验，在多次运行的情况下查看训练和测试 RMSE 的图可能是有帮助的。这可能有助于梳理过度拟合或过度拟合是否正在发生，反过来又是解决它的方法。
 *   **增加重复次数**。使用 10 次重复导致相对少量的测试 RMSE 结果。将重复增加至 30 或 100（或甚至更高）可能导致更稳定的结果。
 
 你有没有探索过这些扩展？

docs/dl-ts/use-timesteps-lstm-networks-time-series-forecasting.md

@@ -110,7 +110,7 @@ Name: Sales, dtype: float64
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。
+这将通过训练和测试数据集的结构进行模拟。
 
 将收集关于测试数据集的所有预测，并计算错误分数以总结模型的技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 
@@ -451,7 +451,7 @@ max     126.581011   226.396127   156.019616   171.570206   208.030615
 本节列出了您可能考虑探索的一些进一步调查的领域。
 
 *   **作为特征**。使用滞后观测作为时间步长也提出了滞后观测是否可以用作输入特征的问题。目前尚不清楚 Keras LSTM 实施是否在内部以相同的方式处理时间步骤和特征。
-*   **诊断运行图**。对于给定的实验，在多次运行的情况下查看列车和测试 RMSE 的图可能是有帮助的。这可能有助于梳理过度拟合或过度拟合是否正在发生，反过来又是解决它的方法。
+*   **诊断运行图**。对于给定的实验，在多次运行的情况下查看训练和测试 RMSE 的图可能是有帮助的。这可能有助于梳理过度拟合或过度拟合是否正在发生，反过来又是解决它的方法。
 *   **增加训练时期**。第二组实验中 LSTM 中神经元的增加可受益于训练时期数量的增加。这可以通过一些后续实验来探索。
 *   **增加重复次数**。使用 10 次重复导致相对少量的测试 RMSE 结果。将重复增加至 30 或 100（或甚至更高）可能导致更稳定的结果。
 

docs/dl-ts/use-weight-regularization-lstm-networks-time-series-forecasting.md

@@ -118,7 +118,7 @@ Name: Sales, dtype: float64
 
 这模仿了一个真实世界的场景，每个月都会有新的洗发水销售观察结果，并用于下个月的预测。
 
-这将通过列车和测试数据集的结构进行模拟。
+这将通过训练和测试数据集的结构进行模拟。
 
 将收集关于测试数据集的所有预测，并计算错误分数以总结模型的技能。将使用均方根误差（RMSE），因为它会对大错误进行处罚，并产生与预测数据相同的分数，即每月洗发水销售额。
 

docs/linalg/index-slice-reshape-numpy-arrays-machine-learning-python.md

@@ -329,9 +329,9 @@ print(y)
 [33 66 99]
 ```
 
-#### 拆分列车和测试行
+#### 拆分训练和测试行
 
-将加载的数据集拆分为单独的列车和测试集是很常见的。
+将加载的数据集拆分为单独的训练和测试集是很常见的。
 
 这是行的分割，其中一些部分将用于训练模型，剩余部分将用于估计训练模型的技能。
 

docs/linalg/introduction-to-tensors-for-machine-learning.md

@@ -424,7 +424,7 @@ print(C)
 
 ### 其他
 
-*   [Tensor 列车格式中大规模数据分析的基本张量操作](https://arxiv.org/abs/1405.7786)，2016。
+*   [Tensor 训练格式中大规模数据分析的基本张量操作](https://arxiv.org/abs/1405.7786)，2016。
 *   张量积，直接和，[量子力学 I](http://hitoshi.berkeley.edu/221a/tensorproduct.pdf) ，2006。
 *   [Tensorphobia 和外部产品](https://jeremykun.com/2016/03/28/tensorphobia-outer-product/)，2016 年。
 *   [Tensor 产品](https://jmanton.wordpress.com/2011/10/12/the-tensor-product/)，2011

docs/ml-start/discover-the-methodology-and-mindset-of-a-kaggle-master-an-interview-with-diogo-ferreira.md

@@ -257,7 +257,7 @@ Process Mining，我的研究领域，与商业智能和数据挖掘领域相关
 
 使用绘图扩展 Bradley-Terry 模型不起作用。尽管阅读了很多关于它（其他作者的工作）并实施它，尽管国际象棋结果受到抽奖的困扰，但使用 Bradley-Terry 模型并结合抽签的可能性对我来说并不适用。我认为这是因为，总而言之，我们所拥有的训练数据对于这一目的来说相对稀缺。
 
-**杰森**：您在准备私人交叉验证火车/测试数据集时遇到了哪些问题？
+**杰森**：您在准备私人交叉验证训练/测试数据集时遇到了哪些问题？
 
 我尝试了几个交叉验证数据集，因为我不确定哪一个与实际测试数据最相似，我担心我的参数调整会过度拟合到交叉验证数据集并且在实际测试数据。
 

docs/ml-start/how-to-go-from-working-in-a-bank-to-hired-as-senior-data-scientist-at-target.md

@@ -94,7 +94,7 @@ Santhosh Sharma 顶级选手 Kaggle Kernel
 
 #### 数据统计
 
-*   火车和测试数据集的形状
+*   训练和测试数据集的形状
 *   偷看 - 眼球数据
 *   描述 - 每列的最小值，最大值，平均值等
 *   歪斜 - 每个数字列的偏斜，以检查是否需要进行修正

docs/ml-start/work-on-machine-learning-problems-that-matter-to-you.md

@@ -39,7 +39,7 @@
 我想到的五个例子是：
 
 *   **个人理财**：您可以为个人理财的某些方面建模。这可能类似于每周支出预测或大量购买预测。如果这是你的事情，它也可能与你的投资组合有关。
-*   **运输**：您可以为个人交通工具的某些方面建模。这可能是您在某一天通勤的火车或公共汽车，通勤时间或工作到达时间预测或燃料消耗等细节。
+*   **运输**：您可以为个人交通工具的某些方面建模。这可能是您在某一天通勤的训练或公共汽车，通勤时间或工作到达时间预测或燃料消耗等细节。
 *   **食物**：你可以对你消费的食物进行建模。这可能是数量，卡路里，零食预测或您在给定的一周内需要购买的模型。
 *   **媒体**：您可以为媒体消费建模，例如电视，电影，书籍，音乐或网站。一种显而易见的方法是将其建模为推荐问题，还要考虑消费量模型，例如消费时消耗的量以及您可以预测的其他相关模式。
 *   **健身**：你可以模拟个人健身的某些方面。这可能是体重，BMI，身体测量或耐力方面，如仰卧起坐次数或完成日常工作的时间。如何建模你是否会在某一天去健身房（输入是什么？）。

docs/sklearn/evaluate-performance-machine-learning-algorithms-python-using-resampling.md

@@ -50,7 +50,7 @@
 
 我们将从称为 Train 和 Test Sets 的最简单方法开始。
 
-## 1.分成火车和测试装置
+## 1.分成训练和测试装置
 
 我们可以用来评估机器学习算法表现的最简单方法是使用不同的训练和测试数据集。
 
@@ -94,7 +94,7 @@ Accuracy: 75.591%
 
 ## 2\. K 折交叉验证
 
-交叉验证是一种可用于估计机器学习算法表现的方法，其方差小于单个列车测试集拆分。
+交叉验证是一种可用于估计机器学习算法表现的方法，其方差小于单个训练测试集拆分。
 
 它的工作原理是将数据集分成 k 部分（例如 k = 5 或 k = 10）。每次分割数据称为折叠。该算法在 k-1 折叠上进行训练，其中一个被扣住并在保持的背部折叠上进行测试。重复这一过程，以便数据集的每个折叠都有机会成为阻碍测试集。
 
@@ -168,9 +168,9 @@ Accuracy: 76.823% (42.196%)
 
 k 折交叉验证的另一个变化是创建数据的随机分割，如上面描述的训练/测试分裂，但重复多次分割和评估算法的过程，如交叉验证。
 
-这具有使用列车/测试分割的速度以及 k 倍交叉验证的估计表现的方差的减少。您也可以根据需要重复此过程。不利的一面是，重复可能包括列车中的大部分相同数据或从运行到运行的测试拆分，从而在评估中引入冗余。
+这具有使用训练/测试分割的速度以及 k 倍交叉验证的估计表现的方差的减少。您也可以根据需要重复此过程。不利的一面是，重复可能包括训练中的大部分相同数据或从运行到运行的测试拆分，从而在评估中引入冗余。
 
-下面的示例将数据拆分为 67％/ 33％的列车/测试拆分，并重复该过程 10 次。
+下面的示例将数据拆分为 67％/ 33％的训练/测试拆分，并重复该过程 10 次。
 
 ```
 # Evaluate using Shuffle Split Cross Validation

docs/sklearn/introduction-machine-learning-scikit-learn.md

@@ -137,7 +137,7 @@ Mark 指出，构建有监督的机器学习模型的目标是推广到样本数
 
 <iframe allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/0pP4EwWJgIU?feature=oembed" width="500"></iframe>
 
-该视频开始研究使用单个数据集估算模型表现的方法，从测试精度开始，然后查看使用列车/测试分割并查看测试精度。
+该视频开始研究使用单个数据集估算模型表现的方法，从测试精度开始，然后查看使用训练/测试分割并查看测试精度。
 
 ## 视频 6：Python 中的数据科学：pandas 和 scikit-learn
 
@@ -160,11 +160,11 @@ Mark 指出，构建有监督的机器学习模型的目标是推广到样本数
 
 该视频通过使用 k-fold 交叉验证，深入研究了用于评估机器学习算法在看不见的数据上的表现的标准方法。
 
-马克指出，单独使用训练精度会过度拟合已知数据，模型不会很好地概括。在列车/测试拆分中单独使用测试数据将具有高差异，这意味着它将对列车和测试集的细节敏感。他建议交叉验证可以在这些问题之间取得良好的平衡。
+马克指出，单独使用训练精度会过度拟合已知数据，模型不会很好地概括。在训练/测试拆分中单独使用测试数据将具有高差异，这意味着它将对训练和测试集的细节敏感。他建议交叉验证可以在这些问题之间取得良好的平衡。
 
 该视频包含以下主题：
 
-*   使用列车/测试拆分程序进行模型评估有什么缺点？
+*   使用训练/测试拆分程序进行模型评估有什么缺点？
 *   K-fold 交叉验证如何克服这一限制？
 *   如何使用交叉验证来选择调整参数，在模型之间进行选择以及选择要素？
 *   交叉验证有哪些可能的改进？

docs/sklearn/machine-learning-in-python-step-by-step.md

@@ -448,7 +448,7 @@ X_train, X_validation, Y_train, Y_validation = model_selection.train_test_split(
 
 我们将使用 10 倍交叉验证来估计准确性。
 
-这会将我们的数据集分成 10 个部分，在 9 上训练并在 1 上进行测试，并重复列车测试分割的所有组合。
+这会将我们的数据集分成 10 个部分，在 9 上训练并在 1 上进行测试，并重复训练测试分割的所有组合。
 
 ```
 # Test options and evaluation metric

docs/sklearn/spot-check-machine-learning-algorithms-in-python.md

@@ -1123,7 +1123,7 @@ XGBoost 分类问题前 10 个抽样检验算法的箱线图
 
 或者，您可能希望调整框架，使模型评估方案更好地匹配您打算用于特定问题的模型评估方案。
 
-例如，在评估诸如袋装或增强决策树之类的随机算法时，最好在相同的列车/测试集（称为重复）上多次运行每个实验，以便考虑学习算法的随机性质。
+例如，在评估诸如袋装或增强决策树之类的随机算法时，最好在相同的训练/测试集（称为重复）上多次运行每个实验，以便考虑学习算法的随机性质。
 
 我们可以更新 _evaluate_model（）_ 函数来重复给定模型的 n 次评估，每次都有不同的数据分割，然后返回所有分数。例如，10 次交叉验证的三次重复将导致每次 30 分，以计算模型的平均表现。
 

docs/ts-intro/backtest-machine-learning-models-time-series-forecasting.md

@@ -7,14 +7,14 @@
 
 时间序列预测的目标是对未来做出准确的预测。
 
-我们在机器学习中依赖的快速而强大的方法，例如使用列车测试分割和 k 折交叉验证，在时间序列数据的情况下不起作用。这是因为它们忽略了问题中固有的时间成分。
+我们在机器学习中依赖的快速而强大的方法，例如使用训练测试分割和 k 折交叉验证，在时间序列数据的情况下不起作用。这是因为它们忽略了问题中固有的时间成分。
 
 在本教程中，您将了解如何使用 Python 评估时间序列数据的机器学习模型。在时间序列预测领域，这称为回测或后报。
 
 完成本教程后，您将了解：
 
 *   传统的机器学习模型评估方法的局限性以及为什么需要在样本数据之外评估模型。
-*   如何在 Python 中创建用于模型评估的时间序列数据的列车测试拆分和多列车测试拆分。
+*   如何在 Python 中创建用于模型评估的时间序列数据的训练测试拆分和多训练测试拆分。
 *   前瞻性验证如何在时间序列数据上提供最真实的机器学习模型评估。
 
 让我们开始吧。
@@ -43,7 +43,7 @@
 
 我们可以通过拆分我们可用的数据来做到这一点。我们使用一些来准备模型，我们阻止一些数据并要求模型对该时期进行预测。对这些预测的评估将为我们在操作上使用它时模型的执行方式提供良好的代理。
 
-在应用机器学习中，我们经常将数据分成火车和测试集：用于准备模型的训练集和用于评估模型的测试集。我们甚至可以使用 k-fold 交叉验证，通过系统地将数据分成 k 个组来重复这个过程，每个组都有机会成为一个坚持的模型。
+在应用机器学习中，我们经常将数据分成训练和测试集：用于准备模型的训练集和用于评估模型的测试集。我们甚至可以使用 k-fold 交叉验证，通过系统地将数据分成 k 个组来重复这个过程，每个组都有机会成为一个坚持的模型。
 
 **这些方法不能直接用于时间序列数据。**
 
@@ -122,7 +122,7 @@ Name: Sunspots, dtype: float64
 
 太阳黑子数据集的情节
 
-## 火车 - 测试分裂
+## 训练 - 测试分裂
 
 您可以将数据集拆分为训练和测试子集。
 
@@ -147,7 +147,7 @@ print('Training Observations: %d' % (len(train)))
 print('Testing Observations: %d' % (len(test)))
 ```
 
-运行该示例将打印已加载数据集的大小以及从拆分创建的列车和测试集的大小。
+运行该示例将打印已加载数据集的大小以及从拆分创建的训练和测试集的大小。
 
 ```py
 Observations: 2820
@@ -178,15 +178,15 @@ pyplot.show()
 
 太阳黑子数据集训练 - 测试分裂
 
-使用列车测试分割方法来评估机器学习模型的速度很快。准备数据简单直观，只创建和评估一个模型。
+使用训练测试分割方法来评估机器学习模型的速度很快。准备数据简单直观，只创建和评估一个模型。
 
 当您拥有大量数据时，它非常有用，因此训练集和测试集都能代表原始问题。
 
 接下来，我们将重复多次重复此过程。
 
-## 多次列车测试拆分
+## 多次训练测试拆分
 
-我们可以重复将时间序列分成多次列车和测试集的过程。
+我们可以重复将时间序列分成多次训练和测试集的过程。
 
 这将需要训练和评估多个模型，但是这种额外的计算开销将提供对所选方法和配置对未见数据的预期表现的更稳健的估计。
 
@@ -194,7 +194,7 @@ pyplot.show()
 
 或者，scikit-learn 库在 _TimeSeriesSplit_ 对象中为我们提供了这种功能。
 
-您必须指定要创建的拆分数量，并指定 _TimeSeriesSplit_ 以返回列车的索引并测试每个请求拆分的观测值。
+您必须指定要创建的拆分数量，并指定 _TimeSeriesSplit_ 以返回训练的索引并测试每个请求拆分的观测值。
 
 每次拆分迭代（ _i_ ）计算训练和测试观察的总数如下：
 
@@ -207,7 +207,7 @@ test_size = n_samples / (n_splits + 1)
 
 让我们以一个例子来具体化。假设我们有 100 个观察值，我们想要创建 2 个分割。
 
-对于第一次拆分，列车和测试尺寸将计算为：
+对于第一次拆分，训练和测试尺寸将计算为：
 
 ```py
 train = i * n_samples / (n_splits + 1) + n_samples % (n_splits + 1)
@@ -243,11 +243,11 @@ test = 33.3 or 33
 
 该数据集有 2,820 个观测值。让我们为数据集创建 3 个拆分。使用上面相同的算法，我们期望创建以下训练和测试分裂：
 
-*   **拆分 1** ：705 列车，705 测试
-*   **拆分 2** ：1,410 列车，705 测试
-*   **拆分 3** ：2,115 次列车，705 次测试
+*   **拆分 1** ：705 训练，705 测试
+*   **拆分 2** ：1,410 训练，705 测试
+*   **拆分 3** ：2,115 次训练，705 次测试
 
-与前面的示例一样，我们将使用单独的颜色绘制火车和测试观测值。在这种情况下，我们将有 3 个拆分，因此这将是 3 个单独的数据图。
+与前面的示例一样，我们将使用单独的颜色绘制训练和测试观测值。在这种情况下，我们将有 3 个拆分，因此这将是 3 个单独的数据图。
 
 ```py
 from pandas import Series
@@ -271,9 +271,9 @@ for train_index, test_index in splits.split(X):
 pyplot.show()
 ```
 
-运行该示例将打印每个拆分的列车和测试集的数量和大小。
+运行该示例将打印每个拆分的训练和测试集的数量和大小。
 
-我们可以看到每个分组的每个列车和测试集中的观测数量与使用上述简单算法计算的预期相匹配。
+我们可以看到每个分组的每个训练和测试集中的观测数量与使用上述简单算法计算的预期相匹配。
 
 ```py
 Observations: 1410
@@ -291,11 +291,11 @@ Testing Observations: 705
 
 ![Sunspot Dataset Multiple Train-Test Split](img/0883f2116e3a6e919f817273b36b6a86.jpg)
 
-太阳黑子数据集多列车 - 测试分裂
+太阳黑子数据集多训练 - 测试分裂
 
-使用多个列车测试分割将导致更多模型被训练，并且反过来，更准确地估计模型对未见数据的表现。
+使用多个训练测试分割将导致更多模型被训练，并且反过来，更准确地估计模型对未见数据的表现。
 
-列车测试分割方法的局限性在于，训练模型在测试集中的每个评估中进行评估时保持固定。
+训练测试分割方法的局限性在于，训练模型在测试集中的每个评估中进行评估时保持固定。
 
 这可能不太现实，因为可以重新训练模型，因为可以获得新的每日或每月观察结果。这个问题将在下一节中讨论。
 
@@ -335,7 +335,7 @@ for i in range(n_train, n_records):
 	print('train=%d, test=%d' % (len(train), len(test)))
 ```
 
-运行该示例只会打印创建的训练和测试集的大小。我们可以看到列车设置扩展了教学时间步骤，测试装置一步一步固定。
+运行该示例只会打印创建的训练和测试集的大小。我们可以看到训练设置扩展了教学时间步骤，测试装置一步一步固定。
 
 在循环中，您将训练和评估您的模型。
 
@@ -376,7 +376,7 @@ train=2819, test=1
 具体来说，你学到了：
 
 *   关于评估模型在看不见或样本外数据上的表现的重要性。
-*   如何创建时间序列数据的列车测试分割，以及如何自动创建多个这样的分割。
+*   如何创建时间序列数据的训练测试分割，以及如何自动创建多个这样的分割。
 *   如何使用前瞻性验证来为评估模型提供最真实的测试工具。
 
 您对评估时间序列模型或本教程有任何疑问吗？

docs/ts-intro/develop-arch-and-garch-models-for-time-series-forecasting-in-python.md

@@ -192,7 +192,7 @@ pyplot.show()
 2.  适合模型
 3.  做一个预测。
 
-在拟合和预测之前，我们可以将数据集拆分为列车和测试集，以便我们可以将模型拟合到列车上并评估其在测试集上的表现。
+在拟合和预测之前，我们可以将数据集拆分为训练和测试集，以便我们可以将模型拟合到训练上并评估其在测试集上的表现。
 
 ```py
 # split into train/test

docs/ts-intro/model-residual-errors-correct-time-series-forecasts-python.md

@@ -104,7 +104,7 @@ dataframe.columns = ['t-1', 't+1']
 
 接下来，数据集分为训练集和测试集。共有 66％的数据用于训练，其余 34％用于测试集。持久性模型不需要训练;这只是一种标准的测试工具方法。
 
-拆分后，列车和测试装置将分为输入和输出组件。
+拆分后，训练和测试装置将分为输入和输出组件。
 
 ```py
 # split into train and test sets
@@ -227,7 +227,7 @@ Lag=15, Coef=[ 0.10120699 -0.84940615 -0.77783609 -0.73345006 -0.68902061 -0.592
 
 这是一个前瞻性预测或滚动预测模型。
 
-我们最终得到了来自列车数据集的残差预测误差的时间序列以及测试数据集上的预测残差。
+我们最终得到了来自训练数据集的残差预测误差的时间序列以及测试数据集上的预测残差。
 
 我们可以绘制这些图并快速了解模型在预测残差方面的巧妙程度。下面列出了完整的示例。
 

docs/ts-intro/persistence-time-series-forecasting-with-python.md

@@ -32,7 +32,7 @@
 在为预测问题建立表现基线之前，必须开发测试工具。这包括：
 
 1.  您打算用于训练和评估模型的**数据集**。
-2.  您打算使用**重新采样**技术来估算技术的表现（例如，列车/测试拆分）。
+2.  您打算使用**重新采样**技术来估算技术的表现（例如，训练/测试拆分）。
 3.  您打算用于评估预测的**表现指标**（例如均方误差）。
 
 准备好之后，您需要选择一种朴素的技术，您可以使用该技术进行预测并计算基准表现。
@@ -156,7 +156,7 @@ print(dataframe.head(5))
 
 我们将保留前 66％的“训练”观察结果，其余 34％用于评估。在拆分期间，我们小心地排除具有 NaN 值的第一行数据。
 
-在这种情况下不需要训练;这只是习惯。然后将每个列车和测试集分成输入和输出变量。
+在这种情况下不需要训练;这只是习惯。然后将每个训练和测试集分成输入和输出变量。
 
 ```py
 # split into train and test sets

docs/ts-intro/time-series-forecast-case-study-python-monthly-armed-robberies-boston.md

@@ -208,7 +208,7 @@ train_size = int(len(X) * 0.50)
 train, test = X[0:train_size], X[train_size:]
 ```
 
-接下来，我们可以迭代测试数据集中的时间步长。火车数据集存储在 Python 列表中，因为我们需要在每次迭代时轻松附加新的观察结果，并且 Numpy 数组连接感觉有点矫枉过正。
+接下来，我们可以迭代测试数据集中的时间步长。训练数据集存储在 Python 列表中，因为我们需要在每次迭代时轻松附加新的观察结果，并且 Numpy 数组连接感觉有点矫枉过正。
 
 由于结果或观察被称为 _y_ 和 _，_（a' _y []，所以该模型所做的预测被称为 _yhat_ 。带有上述标记的 HTG7]是用于预测 _y_ 变量的数学符号。_
 

docs/ts-intro/time-series-forecast-study-python-annual-water-usage-baltimore.md

@@ -204,7 +204,7 @@ train_size = int(len(X) * 0.50)
 train, test = X[0:train_size], X[train_size:]
 ```
 
-接下来，我们可以迭代测试数据集中的时间步长。火车数据集存储在 Python 列表中，因为我们需要在每次迭代时轻松附加新的观察结果，并且 NumPy 数组连接感觉有点矫枉过正。
+接下来，我们可以迭代测试数据集中的时间步长。训练数据集存储在 Python 列表中，因为我们需要在每次迭代时轻松附加新的观察结果，并且 NumPy 数组连接感觉有点矫枉过正。
 
 由于结果或观察被称为 _y_ 和 _，_（a' _y []，所以该模型所做的预测被称为 _yhat_ 。带有上述标记的 HTG7]是用于预测 _y_ 变量的数学符号。_
 

docs/ts-intro/time-series-forecast-study-python-monthly-sales-french-champagne.md

@@ -208,7 +208,7 @@ train_size = int(len(X) * 0.50)
 train, test = X[0:train_size], X[train_size:]
 ```
 
-接下来，我们可以迭代测试数据集中的时间步长。火车数据集存储在 Python 列表中，因为我们需要在每次迭代时轻松附加新的观察结果，并且 NumPy 数组连接感觉有点矫枉过正。
+接下来，我们可以迭代测试数据集中的时间步长。训练数据集存储在 Python 列表中，因为我们需要在每次迭代时轻松附加新的观察结果，并且 NumPy 数组连接感觉有点矫枉过正。
 
 由于结果或观察被称为 _y_ 和 _，_（a' _y []，所以该模型所做的预测被称为 _yhat_ 。带有上述标记的 HTG7]是用于预测 _y_ 变量的数学符号。_
 

docs/ts-intro/time-series-forecasting.md

@@ -158,7 +158,7 @@ y = level + trend + seasonality + noise
 *   每天预测股票的收盘价。
 *   每年预测一个城市所有医院的出生率。
 *   预测商店每天销售的产品销售额。
-*   每天预测通过火车站的乘客数量。
+*   每天预测通过训练站的乘客数量。
 *   每个季度预测一个州的失业率。
 *   每小时预测服务器上的利用率需求。
 *   预测每个繁殖季节的兔子种群数量。

docs/ts-intro/visualize-time-series-residual-forecast-errors-with-python.md

@@ -102,7 +102,7 @@ dataframe.columns = ['t-1', 't+1']
 
 接下来，数据集分为训练集和测试集。共有 66％的数据用于训练，其余 34％用于测试集。持久性模型不需要训练;这只是一种标准的测试工具方法。
 
-拆分后，列车和测试装置将分为输入和输出组件。
+拆分后，训练和测试装置将分为输入和输出组件。
 
 ```py
 # split into train and test sets

docs/xgboost/avoid-overfitting-by-early-stopping-with-xgboost-in-python.md

@@ -197,7 +197,7 @@ pyplot.title('XGBoost Classification Error')
 pyplot.show()
 ```
 
-运行此代码会报告每个纪元的列车和测试数据集的分类错误。我们可以通过在 **fit（）**函数的调用中设置 **verbose = False** （默认值）来关闭它。
+运行此代码会报告每个纪元的训练和测试数据集的分类错误。我们可以通过在 **fit（）**函数的调用中设置 **verbose = False** （默认值）来关闭它。
 
 创建了两个图。第一个显示了训练和测试数据集中每个时期的 XGBoost 模型的对数损失。
 

docs/xgboost/evaluate-gradient-boosting-models-xgboost-python.md

@@ -35,7 +35,7 @@
 
 这种技术的缺点是它可能具有很大的差异。这意味着训练和测试数据集的差异可能导致模型精度估计的有意义差异。
 
-我们可以使用 scikit-learn 库中的 **train_test_split（）**函数将数据集拆分为火车和测试集。例如，我们可以将数据集拆分为 67％和 33％的分组，用于训练和测试集，如下所示：
+我们可以使用 scikit-learn 库中的 **train_test_split（）**函数将数据集拆分为训练和测试集。例如，我们可以将数据集拆分为 67％和 33％的分组，用于训练和测试集，如下所示：
 
 ```py
 # split data into train and test sets
@@ -76,7 +76,7 @@ Accuracy: 77.95%
 
 ## 使用 k-fold 交叉验证评估 XGBoost 模型
 
-交叉验证是一种可用于估计机器学习算法表现的方法，其方差小于单个列车测试集拆分。
+交叉验证是一种可用于估计机器学习算法表现的方法，其方差小于单个训练测试集拆分。
 
 它的工作原理是将数据集分成 k 部分（例如 k = 5 或 k = 10）。每次分割数据称为折叠。该算法在 k-1 折叠上进行训练，其中一个被扣住并在保持的背部折叠上进行测试。重复这一过程，以便数据集的每个折叠都有机会成为阻碍测试集。
 
@@ -167,6 +167,6 @@ Accuracy: 76.95% (5.88%)
 
 *   如何将数据集拆分为训练和测试子集以进行训练和评估模型的表现。
 *   如何在数据集的不同子集上创建 k XGBoost 模型并平均得分以获得更稳健的模型表现估计。
-*   启发式帮助您在问题中选择列车测试拆分和 k 折交叉验证。
+*   启发式帮助您在问题中选择训练测试拆分和 k 折交叉验证。
 
 您对如何评估 XGBoost 模型或该帖子的表现有任何疑问吗？在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file