翻译校正，格式角度

0461c61e · ElamDavies · 64f2dab6 · 0461c61e · 0461c61e
2 changed file
--- a/docs/dl-keras/5-step-life-cycle-neural-network-models-keras.md
+++ b/docs/dl-keras/5-step-life-cycle-neural-network-models-keras.md
 # Keras 中神经网络模型的 5 步生命周期
 > 原文： [https://machinelearningmastery.com/5-step-life-cycle-neural-network-models-keras/](https://machinelearningmastery.com/5-step-life-cycle-neural-network-models-keras/)
 使用 Keras 在 Python 中创建和评估深度学习神经网络非常容易，但您必须遵循严格的模型生命周期。
-在这篇文章中，您将发现在 Keras 中创建，训练和评估深度学习神经网络的逐步生命周期，以及如何使用训练有素的模型进行预测。
+在这篇文章中，您将了解在 Keras 中创建，训练和评估深度学习神经网络的逐步生命周期，以及如何使用训练好的模型进行预测。
 阅读这篇文章后你会知道：
 *   如何在 Keras 中定义，编译，拟合和评估深度学习神经网络。
 *   如何为回归和分类预测建模问题选择标准默认值。
 *   如何将它们结合在一起，在 Keras 开发和运行您的第一个多层感知器网络。
-让我们开始吧。
+让我们现在开始吧。
 *   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
 *   **更新 March / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。
 ![Deep Learning Neural Network Life-Cycle in Keras](img/ba26805ccbbb3318546dbf2663ddbef9.png)
-Keras 的深度学习神经网络生命周期
-[Martin Stitchener](https://www.flickr.com/photos/dxhawk/6842278135/) 的照片，保留一些权利。
+图片[Martin Stitchener](https://www.flickr.com/photos/dxhawk/6842278135/) 提供，并保留所属权利。
-## 概观
+## 概述
 下面概述了我们将要研究的 Keras 神经网络模型生命周期的 5 个步骤。
-1.  定义网络。
+1.  定义网络
-2.  编译网络。
+2.  编译网络
-3.  适合网络。
+3.  拟合网络
-4.  评估网络。
+4.  评估网络.
-5.  作出预测。
+5.  做出预测.
 ![5 Step Life-Cycle for Neural Network Models in Keras](img/2996eabdf1f9d9a0bc2b5e1c62d6b4e5.png)
 Keras 中神经网络模型的 5 步生命周期
-## 步骤 1.定义网络
+## 步骤 1. 定义网络
 第一步是定义您的神经网络。
-神经网络在 Keras 中定义为层序列。这些层的容器是 Sequential 类。
+神经网络在 Keras 中定义为层序列，这些层的容器是 Sequential 类。
-第一步是创建 Sequential 类的实例。然后，您可以创建层并按照它们应连接的顺序添加它们。
+第一步是创建 Sequential 类的实例，然后，您可以创建层并按照它们应当连接的顺序添加它们。
 例如，我们可以分两步完成：
 ```py
 model = Sequential()
 model.add(Dense(2))
 ```
 但是我们也可以通过创建一个层数组并将其传递给 Sequential 的构造函数来一步完成。
 ```py
 layers = [Dense(2)]
 model = Sequential(layers)
 ```
-网络中的第一层必须定义预期的输入数量。指定它的方式可能因网络类型而异，但对于 Multilayer Perceptron 模型，这由 input_dim 属性指定。
+网络中的第一层必须定义预期的输入数量,指定它的方式可能因网络类型而异，但对于 Multilayer Perceptron 模型，这由`input_dim`属性指定。
-例如，一个小的多层感知器模型，在可见层中有 2 个输入，隐藏层中有 5 个神经元，输出层中有一个神经元，可以定义为：
+例如，一个较小的多层感知器模型，在可见层中有 2 个输入，隐藏层中有 5 个神经元，输出层中有一个神经元，可以定义为：
 ```py
 model = Sequential()
 model.add(Dense(5, input_dim=2))
 model.add(Dense(1))
 ```
-将序列模型视为管道，将原始数据输入底部，并将预测输出到顶部。
+可以将将序列模型视为管道，将原始数据输入底部，并将预测输出到顶部。
-这在 Keras 中是一个有用的概念，因为传统上与层相关的关注点也可以拆分并作为单独的层添加，清楚地显示它们在从输入到预测的数据转换中的作用。例如，可以提取转换来自层中每个神经元的求和信号的激活函数，并将其作为称为激活的层状对象添加到 Sequential 中。
+这在 Keras 中是一个容易理解的概念，因为传统上与层相关的关注点也可以拆分并作为单独的层添加，清楚地显示它们在从输入到预测的数据转换中的作用。例如，可以提取转换来自层中每个神经元的求和信号的激活函数，并将其作为激活函数的层状对象添加到 Sequential 中。
 ```py
 model = Sequential()
 model.add(Dense(5, input_dim=2))
 model.add(Activation('relu'))
 model.add(Dense(1))
 model.add(Activation('sigmoid'))
 ```
 激活函数的选择对于输出层是最重要的，因为它将定义预测将采用的格式。
 例如，下面是一些常见的预测建模问题类型以及可以在输出层中使用的结构和标准激活函数：
-*   **回归**：线性激活函数或'线性'和与输出数匹配的神经元数。
+*   **回归**：线性激活函数或和与输出数线性匹配的神经元数。
-*   **二元分类（2 级）**：Logistic 激活函数或'sigmoid'和一个神经元输出层。
+*   **二元分类（2 级）**：`Logistic` 激活函数或`sigmoid`激活函数和一个神经元输出层。
-*   **多类分类（＆gt; 2 类）**：假设单热编码输出模式，Softmax 激活函数或'softmax'和每类值一个输出神经元。
+*   **多元分类（>2 类）**：假设单热编码输出模式，`Softmax` 激活函数或`softmax`和每个神经元代表一个输出。
-## 第 2 步。编译网络
+## 步骤2. 编译网络
 一旦我们定义了网络，我们就必须编译它。
-编译是一个效率步骤。它将我们定义的简单层序列转换为高效的矩阵变换系列，其格式应在 GPU 或 CPU 上执行，具体取决于 Keras 的配置方式。
+编译是一个提升效率的步骤，它将我们定义的简单层序列转换为高效的矩阵变换系列，其格式应在 GPU 或 CPU 上执行，而这具体取决于 Keras 的配置方式。
-将编译视为网络的预计算步骤。
+可以将编译视为网络的预计算步骤。
-定义模型后始终需要编译。这包括在使用优化方案训练之前以及从保存文件加载一组预先训练的权重之前。原因是编译步骤准备了网络的有效表示，这也是对硬件进行预测所必需的。
+定义模型后始终需要编译，这包括在使用优化方案训练之前以及从保存文件加载一组预先训练的权重的步骤之前，原因是编译过程处理了网络的有效表示，这也是利用硬件进行预测所必需的步骤。
-编译需要指定许多参数，专门用于训练您的网络。具体地，用于训练网络的优化算法和用于评估由优化算法最小化的网络的损失函数。
+编译需要指定许多参数，专门用于训练您的网络，具体地，用于训练网络的优化算法和用于评估由优化算法最小化的网络的损失函数。
-例如，下面是编译定义模型并指定随机梯度下降（sgd）优化算法和均方误差（mse）损失函数的情况，用于回归类型问题。
+例如，下面是编译定义模型并指定随机梯度下降（sgd）优化算法和均方误差（mse）损失函数的情况，通常用于回归类型的问题。
 ```py
 model.compile(optimizer='sgd', loss='mse')
 ```
-预测建模问题的类型对可以使用的损失函数的类型施加约束。
+预测模型问题的类型可以对使用的损失函数的类型施加约束。
 例如，下面是不同预测模型类型的一些标准损失函数：
-*   **回归**：均值平方误差或' _mse_ '。
+*   **回归**：均值平方误差或` _mse_ `.
-*   **二元分类（2 类）**：对数损失，也称为交叉熵或' _binary_crossentropy_ '。
+*   **二元分类（2 类）**：对数损失，也称为交叉熵或` _binary_crossentropy_ `.
-*   **多类分类（＆gt; 2 类）**：多类对数损失或'_ 分类 _ 交响曲 _'。
+*   **多元分类（> 2 类）**：多类对数损失或`categorical_crossentropy `.
 您可以查看 Keras 支持的[损失函数套件。](http://keras.io/objectives/)
 最常见的优化算法是随机梯度下降，但 Keras 还支持其他最先进的优化算法的[套件。](http://keras.io/optimizers/)
-也许最常用的优化算法因为它们通常具有更好的表现：
+使用最常用的优化算法可能是因为它们通常具有更好的性能：
-*   **随机梯度下降**或' _sgd_ '，需要调整学习速度和动量。
+*   **随机梯度下降**或` _sgd_ `，需要调整学习速度和动量。
-*   **ADAM** 或' _adam_ '需要调整学习率。
+*   **ADAM** 或` _adam_ `需要调整学习率。
-*   **RMSprop** 或' _rmsprop_ '需要调整学习率。
+*   **RMSprop** 或` _rmsprop_ `需要调整学习率。
-最后，除了损失函数之外，您还可以指定在拟合模型时收集的度量标准。通常，要收集的最有用的附加度量标准是分类问题的准确性。要收集的度量标准由数组中的名称指定。
+最后，除了损失函数之外，您还可以指定在拟合模型时收集的度量标准，通常，要收集的最有用的附加度量标准是分类问题的精确度，要收集的度量标准由可以由数组中的名称指定。
 例如：
 ```py
 model.compile(optimizer='sgd', loss='mse', metrics=['accuracy'])
 ```
-## 步骤 3.适合网络
+## 步骤 3. 拟合网络
-一旦网络被编译，它就可以适合，这意味着在训练数据集上调整权重。
+一旦网络被编译完成之后，它就可以被拟合，这意味着需要在训练数据集上调整权重参数。
-安装网络需要指定训练数据，输入模式矩阵 X 和匹配输出模式 y 的阵列。
+拟合网络需要指定训练数据，输入模式矩阵 X 和匹配输出模式数组Y。
 使用反向传播算法训练网络，并根据编译模型时指定的优化算法和损失函数进行优化。
-反向传播算法要求网络训练指定数量的时期或暴露于训练数据集。
+反向传播算法要求神经网络训练指定的迭代次数或训练数据集的曝光。
-每个迭代可以被划分为称为批次的输入 - 输出模式对的组。这定义了在一个迭代内更新权重之前网络所暴露的模式数。它也是一种效率优化，确保一次不会将太多输入模式加载到内存中。
+每个迭代可以被划分为称为批次的输入-输出模式对的组，这定义了在一个迭代内更新权重之前网络所暴露的模式数。它也是一种效率优化方式，确保一次不会将太多输入模式加载到内存中。
 拟合网络的最小例子如下：
 ```py
 history = model.fit(X, y, batch_size=10, epochs=100)
 ```
-适合后，将返回历史对象，该对象提供训练期间模型表现的摘要。这包括损失和编译模型时指定的任何其他指标，记录每个迭代。
+拟合后，将返回历史对象，该对象提供训练期间模型表现的摘要，这包括损失和编译模型过程中每个迭代所记录的的任何其他指标。
-## 第 4 步。评估网络
+## 步骤4. 评估网络
-一旦网络被训练，就可以对其进行评估。
+一旦网络被训练完成，就可以对其进行评估。
-可以在训练数据上评估网络，但是这不会提供作为预测模型的网络表现的有用指示，因为它之前已经看到了所有这些数据。
+可以在训练数据上评估网络，但是这不会提供作为预测模型的网络性能的有效指标，因为训练网络时已经使用过这些数据。
-我们可以在测试期间看不到的单独数据集上评估网络的表现。这将提供对网络表现的估计，以便对未来看不见的数据进行预测。
+我们可以在测试期间不可见的单独数据集上评估网络的性能。这将提供对整个网络性能的估计参数，以便对未来不可见的数据进行预测。
-该模型评估所有测试模式的损失，以及编译模型时指定的任何其他指标，如分类准确性。返回评估指标列表。
+该模型评估所有测试模式的损失，以及编译模型时指定的任何其他指标，如分类的精确度，返回评估指标的列表。
-例如，对于使用精度度量编制的模型，我们可以在新数据集上对其进行评估，如下所示：
+例如，对于使用精度度量制的模型，我们可以在新数据集上对其进行评估，如下所示：
 ```py
 loss, accuracy = model.evaluate(X, y)
 ```
-## 第 5 步。做出预测
+## 步骤5. 做出预测
-最后，一旦我们对拟合模型的表现感到满意，我们就可以用它来预测新数据。
+最后，一旦我们对拟合模型的性能感到满意，我们就可以用它来预测新的数据。
-这就像使用新输入模式数组调用模型上的 predict（）函数一样简单。
+这就像使用新输入模式数组调用模型上的 `predict()`函数一样简单。
 例如：
 ```py
 predictions = model.predict(x)
 ```
-预测将以网络输出层提供的格式返回。
+预测将以网络输出层提供的数据格式返回。
-在回归问题的情况下，这些预测可以是直接问题的格式，由线性激活函数提供。
+在回归问题的情况下，这些预测可以是直接问题的形式，该形式由线性激活函数提供。
-对于二元分类问题，预测可以是第一类的概率数组，其可以通过舍入转换为 1 或 0。
+对于二元分类问题，预测可以是第一类的概率数组，其可以通过舍入转换为 1 或 0 的整形数表示。
-对于多类分类问题，结果可以是概率数组的形式（假设一个热编码输出变量），可能需要使用 [argmax 函数](http://docs.scipy.org/doc/numpy/reference/generated/numpy.argmax.html)将其转换为单个类输出预测。
+对于多元分类问题，结果可以是概率数组的形式（假设一个热编码输出变量），可能需要使用 [argmax 函数](http://docs.scipy.org/doc/numpy/reference/generated/numpy.argmax.html)将其转换为单个类输出预测。
 ## 端到端工作示例
 让我们将所有这些与一个小例子结合起来。
 这个例子将使用皮马印第安人发病的糖尿病二元分类问题，即可以从 UCI 机器学习库下载[（更新：](https://archive.ics.uci.edu/ml/datasets/Pima+Indians+Diabetes)[从这里下载](https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv)）。
-该问题有 8 个输入变量和一个输出类变量，其整数值为 0 和 1。
+该问题有 8 个输入变量和一个输出类变量，其输出整数值为 0 和 1。
-我们将构建一个多层感知器神经网络，在可见层中有 8 个输入，隐藏层中有 12 个神经元，具有整流器激活功能，输出层中有 1 个神经元具有 S 形激活功能。
+我们将构建一个多层感知器神经网络，在可见层中有 8 个输入，隐藏层中有 12 个神经元，具有整流器激活函数，输出层中有 1 个神经元具有`sigmod()`激活函数。
-我们将使用 ADAM 优化算法和对数损失函数对批量大小为 10 的 100 个时期进行网络训练。
+我们将使用 ADAM 优化算法和对数损失函数对批量大小为 10 的 100 个迭代次数进行网络训练。
-一旦适合，我们将评估训练数据的模型，然后对训练数据进行独立预测。这是为了简洁起见，通常我们会在单独的测试数据集上评估模型并对新数据进行预测。
+一旦拟合完成，我们将评估训练数据的模型性能，然后对训练数据进行单独预测，这是为了简洁起见，通常我们会在单独的测试数据集上评估模型性能并对新数据进行预测。
 完整的代码清单如下。
 ```py
 # Sample Multilayer Perceptron Neural Network in Keras
 from keras.models import Sequential
 from keras.layers import Dense
 import numpy
-# load and prepare the dataset
+# 加载和预处理数据集
 dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
 X = dataset[:,0:8]
 Y = dataset[:,8]
-# 1\. define the network
+# 1. 定义网络
 model = Sequential()
 model.add(Dense(12, input_dim=8, activation='relu'))
 model.add(Dense(1, activation='sigmoid'))
-# 2\. compile the network
+# 2. 编译网络
 model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
-# 3\. fit the network
+# 3. 拟合网络
 history = model.fit(X, Y, epochs=100, batch_size=10)
-# 4\. evaluate the network
+# 4. 评估网络
 loss, accuracy = model.evaluate(X, Y)
 print("\nLoss: %.2f, Accuracy: %.2f%%" % (loss, accuracy*100))
-# 5\. make predictions
+# 5. 做出预测
 probabilities = model.predict(X)
 predictions = [float(round(x)) for x in probabilities]
 accuracy = numpy.mean(predictions == Y)
 print("Prediction Accuracy: %.2f%%" % (accuracy*100))
 ```
 运行此示例将生成以下输出：
 ```py
 ...
 768/768 [==============================] - 0s - loss: 0.5219 - acc: 0.7591
 Epoch 99/100
 768/768 [==============================] - 0s - loss: 0.5250 - acc: 0.7474
 Epoch 100/100
 768/768 [==============================] - 0s - loss: 0.5416 - acc: 0.7331
 32/768 [>.............................] - ETA: 0s
 Loss: 0.51, Accuracy: 74.87%
 Prediction Accuracy: 74.87%
 ```
 ## 摘要
 在这篇文章中，您使用 Keras 库发现了深度学习神经网络的 5 步生命周期。
 具体来说，你学到了：
 *   如何在 Keras 中为神经网络定义，编译，拟合，评估和预测。
 *   如何为分类和回归问题选择激活函数和输出层配置。
 *   如何在 Keras 开发和运行您的第一个多层感知器模型。
 您对 Keras 中的神经网络模型有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
--- a/docs/dl-keras/binary-classification-tutorial-with-the-keras-deep-learning-library.md
+++ b/docs/dl-keras/binary-classification-tutorial-with-the-keras-deep-learning-library.md
 # Keras 深度学习库的二元分类教程
 > 原文： [https://machinelearningmastery.com/binary-classification-tutorial-with-the-keras-deep-learning-library/](https://machinelearningmastery.com/binary-classification-tutorial-with-the-keras-deep-learning-library/)
 Keras 是一个用于深度学习的 Python 库，它包含了高效的数值库 TensorFlow 和 Theano。
 Keras 允许您快速简单地设计和训练神经网络和深度学习模型。
-在这篇文章中，您将逐步完成二元分类项目，了解如何在机器学习项目中有效使用 Keras 库。
+在这篇文章中，您将逐步完成二元分类项目并了解如何在机器学习项目中高效使用 Keras 库。
 完成本教程后，您将了解：
 *   如何加载训练数据并将其提供给 Keras。
-*   如何设计和训练表格数据的神经网络。
+*   如何设计和训练表格数据形式的神经网络。
-*   如何评估 Keras 神经网络模型在看不见的数据上的表现。
+*   如何评估 Keras 神经网络模型在不可见的数据上的性能。
-*   如何在使用神经网络时进行数据准备以提高技能。
+*   如何在使用神经网络时进行数据预处理以提升性能。
 *   如何调整 Keras 中神经网络的拓扑和配置。
-让我们开始吧。
+让我们现在开始吧。
 *   **2016 年 10 月更新**：更新了 Keras 1.1.0 和 scikit-learn v0.18 的示例。
 *   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
 ![Binary Classification Worked Example with the Keras Deep Learning Library](img/813384c9d73f15abe34aa5f55bd5ddfa.png)
-使用 Keras 深度学习库的二元分类工作示例
-[Mattia Merlo](https://www.flickr.com/photos/h_crimson/9405280189/) 的照片，保留一些权利。
+图片由[Mattia Merlo](https://www.flickr.com/photos/h_crimson/9405280189/) 提供，并保留所属权利。
 ## 1.数据集的描述
 我们将在本教程中使用的数据集是 [Sonar 数据集](https://archive.ics.uci.edu/ml/datasets/Connectionist+Bench+(Sonar,+Mines+vs.+Rocks))。
-这是一个描述声纳啁啾返回弹跳不同服务的数据集。 60 个输入变量是不同角度的回报强度。这是一个二元分类问题，需要一个模型来区分岩石和金属圆柱。
+这是一个描述声纳啁啾返回弹跳不同服务的数据集，60 个输入变量是不同角度的回报强度。这是一个二元分类问题，需要构建一个模型来区分岩石和金属。
 您可以在 [UCI 机器学习库](https://archive.ics.uci.edu/ml/datasets/Connectionist+Bench+(Sonar,+Mines+vs.+Rocks))上了解有关此数据集的更多信息。您可以[免费下载数据集](https://archive.ics.uci.edu/ml/machine-learning-databases/undocumented/connectionist-bench/sonar/sonar.all-data)并将其放在工作目录中，文件名为 sonar.csv。
-这是一个众所周知的数据集。所有变量都是连续的，通常在 0 到 1 的范围内。输出变量是我的字符串“M”和摇滚的“R”，需要将其转换为整数 1 和 0。
+这是一个众所周知的数据集。所有变量都是连续的，通常在 0 到 1 的范围内。输出变量是代表矿石的字符“M”和代表岩石的字符“R”
-使用此数据集的好处是它是标准基准问题。这意味着我们对一个好模型的预期技能有所了解。使用交叉验证，神经网络[应该能够实现 84％左右的表现](http://www.is.umk.pl/projects/datasets.html#Sonar)，定制模型的准确度上限约为 88％。
+使用此数据集的好处是它是一个标准的基准问题，这意味着我们对构建一个较好模型的预期技巧有所了解。使用交叉验证，神经网络[应该能够达到 84％左右的性能](http://www.is.umk.pl/projects/datasets.html#Sonar)，定制模型的精确度上限约为 88％。
-## 2.基线神经网络模型表现
+## 2.基线神经网络模型性能
 让我们为这个问题创建一个基线模型和结果。
 我们将首先导入我们需要的所有类和函数。
 ```py
 import numpy
 import pandas
 from keras.models import Sequential
 from keras.layers import Dense
 from keras.wrappers.scikit_learn import KerasClassifier
 from sklearn.model_selection import cross_val_score
 from sklearn.preprocessing import LabelEncoder
 from sklearn.model_selection import StratifiedKFold
 from sklearn.preprocessing import StandardScaler
 from sklearn.pipeline import Pipeline
 ```
-接下来，我们可以初始化随机数生成器，以确保在执行此代码时始终获得相同的结果。如果我们正在调试，这将有所帮助。
+接下来，我们可以初始化随机数生成器，以确保在执行此代码时始终获得相同的结果。如果我们正在调试模型，这将对我们有所帮助。
 ```py
-# fix random seed for reproducibility
+# 固定随机种子的在线性
 seed = 7
 numpy.random.seed(seed)
 ```
-现在我们可以使用 [pandas](http://pandas.pydata.org/) 加载数据集，并将列拆分为 60 个输入变量（X）和 1 个输出变量（Y）。我们使用 pandas 来加载数据，因为它可以轻松处理字符串（输出变量），而尝试使用 NumPy 直接加载数据会更加困难。
+现在我们可以使用 [pandas](http://pandas.pydata.org/) 加载数据集，并将列拆分为 60 个输入变量（X）和 1 个输出变量（Y），我们使用 pandas 来加载数据，因为它可以轻松处理字符串（输出变量），如果尝试使用 NumPy 直接加载数据会比较困难。
 ```py
-# load dataset
+# 加载数据集
 dataframe = pandas.read_csv("sonar.csv", header=None)
 dataset = dataframe.values
-# split into input (X) and output (Y) variables
+# 将数据集分割为输入变量和输出变量
 X = dataset[:,0:60].astype(float)
 Y = dataset[:,60]
 ```
-输出变量是字符串值。我们必须将它们转换为整数值 0 和 1。
+输出变量是字符串值，我们必须将它们转换为整数值 0 和 1。
-我们可以使用 scikit-learn 中的 LabelEncoder 类来完成此操作。此类将通过 fit（）函数使用整个数据集对所需的编码进行建模，然后应用编码以使用 transform（）函数创建新的输出变量。
+我们可以使用 scikit-learn 中的 LabelEncoder 类来完成此操作。此类将通过 `fit()`函数使用整个数据集对所需的编码进行建模，然后应用编码以使用`transform()`函数创建新的输出变量。
 ```py
-# encode class values as integers
+# 转换字符编码
 encoder = LabelEncoder()
 encoder.fit(Y)
 encoded_Y = encoder.transform(Y)
 ```
 我们现在准备使用 Keras 创建我们的神经网络模型。
-我们将使用 scikit-learn 来使用分层 k 折交叉验证来评估模型。这是一种重采样技术，可以提供模型表现的估计。它通过将数据分成 k 部分来实现这一点，在所有部分上训练模型，除了作为测试集的一部分以评估模型的表现。该过程重复 k 次，并且所有构建的模型的平均分数被用作表现的稳健估计。它是分层的，这意味着它将查看输出值并尝试平衡属于数据 k 分裂中每个类的实例数。
+我们将使用 scikit-learn 来使用分层 k 折交叉验证来评估模型，这是一种重采样技术，可以提供模型性能的估计。它通过将数据集分成 k 个部分来实现这一点，除了作为测试集的一部分用以评估模型的性能外，在其他所有训练数据上训练模型，该过程重复 k 次，并且所有构建的模型的平均分数被用作模型性能的稳健估计，因为它是分层的设计，这意味着它将查看输出值并尝试平衡属于数据 k 分裂中每个类的实例数。
-要将 Keras 模型与 scikit-learn 一起使用，我们必须使用 KerasClassifier 包装器。该类采用创建并返回神经网络模型的函数。它还会将参数传递给 fit（）调用，例如迭代数和批量大小。
+要将 Keras 模型与 scikit-learn 一起使用，我们必须使用 KerasClassifier封装器。该类采用创建并返回神经网络模型的函数，将参数传递给 `fit()`调用，例如迭代数和批量大小。
-让我们从定义创建基线模型的函数开始。我们的模型将具有单个完全连接的隐藏层，其具有与输入变量相同数量的神经元。这是创建神经网络时的一个很好的默认起点。
+让我们从定义创建基线模型的函数开始,我们的模型将具有单个完全连接的隐藏层，其具有与输入变量相同数量的神经元,这是创建神经网络时的一个很好的默认起点。
-使用小的高斯随机数初始化权重。使用整流器激活功能。输出层包含单个神经元以进行预测。它使用 sigmoid 激活函数，以产生 0 到 1 范围内的概率输出，可以轻松自动地转换为清晰的类值。
+使用较小的高斯随机数初始化权重参数，使用整流器激活函数，输出层包含单个神经元以进行预测，它使用 `sigmod()`激活函数，以产生 0 到 1 范围内的概率输出，可以轻松地转换为清晰的类值（如0和1）。
-最后，我们在训练期间使用对数损失函数（binary_crossentropy），这是二元分类问题的首选损失函数。该模型还使用有效的 Adam 优化算法进行梯度下降，并在训练模型时收集精度度量。
+最后，我们在训练期间使用对数损失函数（binary_crossentropy），这是二元分类问题的首选损失函数。该模型还使用高效的 Adam 优化算法进行梯度下降，并在训练模型时收集精度度量指标。
 ```py
-# baseline model
+# 基线模型
 def create_baseline():
-	# create model
+	# 创建模型
 	model = Sequential()
 	model.add(Dense(60, input_dim=60, kernel_initializer='normal', activation='relu'))
 	model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
-	# Compile model
+	# 编译模型
 	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
 	return model
 ```
-现在是时候在 scikit-learn 框架中使用分层交叉验证来评估这个模型。
+现在可以在在 scikit-learn 框架中使用分层交叉验证来评估这个模型。
-我们再次使用合理的默认值将训练时期的数量传递给 KerasClassifier。假设模型将被创建 10 次以进行 10 次交叉验证，也会关闭详细输出。
+我们再次使用合理的默认值将训练时期的数量传递给 KerasClassifier，设定00模型将被创建 10 次以进行 10 次交叉验证，并且关闭详细输出选项（即参数`verbose = 0`）。
 ```py
 # evaluate model with standardized dataset
 estimator = KerasClassifier(build_fn=create_baseline, epochs=100, batch_size=5, verbose=0)
 kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
 results = cross_val_score(estimator, X, encoded_Y, cv=kfold)
 print("Results: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
 ```
-运行此代码将生成以下输出，显示模型在未见数据上的估计精度的平均值和标准差。
+运行此代码将生成以下输出，显示模型在不可见数据上的估计精度的平均值和标准差。
 ```py
 Baseline: 81.68% (7.26%)
 ```
 这是一个很好的分数，没有做任何艰苦的工作。
-## 3.使用数据准备重新运行基线模型
+## 3.使用数据预处理并重新运行基线模型
-在建模之前准备数据是一种很好的做法。
+在建模之前进行数据预处理是一种很好的做法。
-神经网络模型尤其适用于在规模和分布方面具有一致的输入值。
+神经网络模型尤其适用于在数据规模和分布方面具有一致性的输入值。
-建立神经网络模型时表格数据的有效数据准备方案是标准化。这是重新调整数据的位置，使得每个属性的平均值为 0，标准偏差为 1.这保留了高斯和高斯类分布，同时规范了每个属性的中心趋势。
+建立神经网络模型时表格数据的有效数据chuli1方案是标准化，这是重新调整数据，使得数据每个属性的平均值为 0，标准偏差为 1.这种处理方法保留了高斯和高斯类分布，同时规范了数据每个属性的中心趋势。
 我们可以使用 scikit-learn 使用 [StandardScaler](http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) 类来执行 Sonar 数据集的标准化。
-优化的做法是在交叉验证运行的过程中对训练数据进行标准化过程，并使用经过训练的标准化来准备“看不见的”测试折叠，而不是对整个数据集执行标准化。这使得标准化成为交叉验证过程中模型准备的一个步骤，并且它阻止算法在评估期间具有“看不见的”数据的知识，可以从数据准备方案传递的知识，如更清晰的分布。
+优化算法的方法是在交叉验证运行的过程中对训练数据进行标准化处理，并使用经过训练的标准化数据来预处理“不可见”的测试折叠，而不是对整个数据集执行标准化。这使得标准化成为交叉验证过程中模型预处理的一个必要步骤，并且能够阻止算法在评估期间具有从数据预处理过程中传递的“不可见”信息，如更清晰的分布。
+我们可以使用 [Pipeline](http://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html) 在 scikit-learn 中实现这一点，此管道是一个包装器，它在交叉验证过程的传递中执行一个或多个模型。在这里，我们可以使用 StandardScaler 定义管道，然后将其应用于我们的神经网络模型。
-我们可以使用 [Pipeline](http://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html) 在 scikit-learn 中实现这一点。管道是一个包装器，它在交叉验证过程的传递中执行一个或多个模型。在这里，我们可以使用 StandardScaler 定义管道，然后使用我们的神经网络模型。
+```py
-```py
+# 使用标准数据集评估基线模型
-# evaluate baseline model with standardized dataset
+numpy.random.seed(seed)
-numpy.random.seed(seed)
+estimators = []
-estimators = []
+estimators.append(('standardize', StandardScaler()))
-estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasClassifier(build_fn=create_baseline, epochs=100, batch_size=5, verbose=0)))
-estimators.append(('mlp', KerasClassifier(build_fn=create_baseline, epochs=100, batch_size=5, verbose=0)))
+pipeline = Pipeline(estimators)
-pipeline = Pipeline(estimators)
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
-kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
-results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
+print("Standardized: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
-print("Standardized: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+```
-```
+运行此示例结果如下所示，我们确实看到精度值有一个较小的提升。
-运行此示例提供以下结果。我们确实看到一个小而非常好的升力平均精度。
+```py
-```py
+Standardized: 84.56% (5.74%)
-Standardized: 84.56% (5.74%)
+```
-```
+## 4.调整模型中的层和神经元数量
-## 4.调整模型中的层和神经元数量
+在神经网络上需要设置很多东西，例如权重初始化，激活函数，优化过程等。
-在神经网络上需要调整很多东西，例如权重初始化，激活函数，优化过程等。
+具有超大的影响方面的的网络本身被称为网络拓扑，在本节中，我们将看一下关于网络结构的两个实验：将其缩小和将其放大。
-可能具有特大效应的一个方面是网络本身的结构，称为网络拓扑。在本节中，我们将看一下关于网络结构的两个实验：将其缩小并使其更大。
+这些实验能够在调节神经网络的问题上给予你帮助。
-这些是在针对您的问题调整神经网络时执行的良好实验。
+### 4.1. 评估较小的网络
-### 4.1。评估较小的网络
+我认为描述声纳数据集的输入变量有较大的冗余。
-我怀疑这个问题的输入变量有很多冗余。
+数据描述了来自不同角度的相同信号。也许其中一些角度比其他角度更有意义。我们可以通过限制第一个隐藏层中的表示空间来强制网络进行特征提取。
-数据描述了来自不同角度的相同信号。也许其中一些角度比其他角度更有意义。我们可以通过限制第一个隐藏层中的表示空间来强制网络进行一种特征提取。
+在这个实验中，我们将采用隐藏层中有 60 个神经元的基线模型，并将其减少一半到 30 个。这将在训练期间对网络施加压力，以挑选输入数据中最重要的结构进行建模。
-在这个实验中，我们采用隐藏层中 60 个神经元的基线模型，并将其减少一半到 30 个。这将在训练期间对网络施加压力，以挑选输入数据中最重要的结构进行建模。
+我们还将在数据准备的前一个实验中对数据进行标准化，并尝试利用数据标准化后性能较小的提升。
-我们还将在数据准备的前一个实验中对数据进行标准化，并尝试利用表现的小提升。
+```py
-```py
+# 更小的模型
-# smaller model
+def create_smaller():
-def create_smaller():
+	# 创建模型
-	# create model
+	model = Sequential()
-	model = Sequential()
+	model.add(Dense(30, input_dim=60, kernel_initializer='normal', activation='relu'))
-	model.add(Dense(30, input_dim=60, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
-	model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
+	# 编译模型
-	# Compile model
+	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
-	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
-	return model
+estimators = []
-estimators = []
+estimators.append(('standardize', StandardScaler()))
-estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasClassifier(build_fn=create_smaller, epochs=100, batch_size=5, verbose=0)))
-estimators.append(('mlp', KerasClassifier(build_fn=create_smaller, epochs=100, batch_size=5, verbose=0)))
+pipeline = Pipeline(estimators)
-pipeline = Pipeline(estimators)
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
-kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
-results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
+print("Smaller: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
-print("Smaller: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+```
-```
+运行此示例结果如下所示，我们可以看到，我们对平均估计精度有一个非常小的提高，并且模型的精度分数的标准偏差（平均分布）显着降低。
-运行此示例提供以下结果。我们可以看到，我们对平均估计精度有一个非常小的提升，并且模型的精度分数的标准偏差（平均分布）显着降低。
+这是一个很好的结果，因为我们在网络规模减半的情况下做得更好一些，而这仅需要一半的时间来训练。
-这是一个很好的结果，因为我们在网络尺寸减半的情况下做得稍微好一些，而这只需要一半的时间来训练。
+```py
-```py
+Smaller: 86.04% (4.00%)
-Smaller: 86.04% (4.00%)
+```
-```
+### 4.2. 评估更大的网络
-### 4.2。评估更大的网络
+具有更多层的神经网络拓扑为网络提供了更多机会来提取关键特征并以更有用的非线性方式重新组合它们。
-具有更多层的神经网络拓扑为网络提供了更多机会来提取关键特征并以有用的非线性方式重新组合它们。
+我们可以通过对用于创建模型的函数进行另一个小的调整来评估是否向网络添加更多层以轻松地改善性能。在这里，我们向网络添加一个新层（一行），即也就是在第一个隐藏层之后引入另一个隐藏层，其中包含 30 个神经元。
-我们可以通过对用于创建模型的函数进行另一个小调整来评估是否向网络添加更多层可以轻松改善表现。在这里，我们向网络添加一个新层（一行），在第一个隐藏层之后引入另一个隐藏层，其中包含 30 个神经元。
+我们的网络现在具有拓扑结构：
-我们的网络现在具有拓扑结构：
+```py
-```py
+60 inputs -> [60 -> 30] -> 1 output
-60 inputs -> [60 -> 30] -> 1 output
+```
-```
+这里的方法是，网络有机会在瓶颈之前对所有输入变量进行建模，并被强制将表示能力减半，就像我们在上书的缩小网络拓扑的实验中所做的那样。
-这里的想法是，网络有机会在瓶颈之前对所有输入变量进行建模，并被迫将表示能力减半，就像我们在上面的小网络实验中所做的那样。
+我们有一个额外的隐藏层来实现这个过程，而不是压缩输入层本身的表示。
-我们有一个额外的隐藏层来帮助这个过程，而不是压缩输入本身的表示。
+```py
-```py
+# 更大的模型
-# larger model
+def create_larger():
-def create_larger():
+	# 创建模型
-	# create model
+	model = Sequential()
-	model = Sequential()
+	model.add(Dense(60, input_dim=60, kernel_initializer='normal', activation='relu'))
-	model.add(Dense(60, input_dim=60, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(30, kernel_initializer='normal', activation='relu'))
-	model.add(Dense(30, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
-	model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
+	# Compile model
-	# Compile model
+	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
-	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
-	return model
+estimators = []
-estimators = []
+estimators.append(('standardize', StandardScaler()))
-estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasClassifier(build_fn=create_larger, epochs=100, batch_size=5, verbose=0)))
-estimators.append(('mlp', KerasClassifier(build_fn=create_larger, epochs=100, batch_size=5, verbose=0)))
+pipeline = Pipeline(estimators)
-pipeline = Pipeline(estimators)
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
-kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
-results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
+print("Larger: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
-print("Larger: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+```
-```
+运行此示例将生成以下结果。我们可以看到，我们在模型表现方面并没有得到提升，这可能是统计噪音或需要进一步训练的迹象。
-运行此示例将生成以下结果。我们可以看到，我们在模型表现方面没有得到提升。这可能是统计噪音或需要进一步训练的迹象。
+```py
-```py
+Larger: 83.14% (4.52%)
-Larger: 83.14% (4.52%)
+```
-```
+通过进一步调整诸如优化算法和训练时期的数量之类的方面，预期结果可以进一步提升。您可以在此数据集上获得的最佳分数是多少？
-通过进一步调整诸如优化算法和训练时期的数量之类的方面，预期可以进一步改进。您可以在此数据集上获得的最佳分数是多少？
+## 摘要
-## 摘要
+在这篇文章中，您了解了 Python 中的 Keras 深度学习库。
-在这篇文章中，您发现了 Python 中的 Keras 深度学习库。
+您了解了如何使用 Keras 逐步完成二元分类问题，具体如下：
-您了解了如何使用 Keras 逐步完成二元分类问题，具体如下：
+*   如何加载和准备在 Keras 中使用的数据。
-*   如何加载和准备在 Keras 中使用的数据。
+*   如何创建基线神经网络模型。
-*   如何创建基线神经网络模型。
+*   如何使用 scikit-learn 和分层 k 折交叉验证来评估 Keras 模型。
-*   如何使用 scikit-learn 和分层 k 折交叉验证来评估 Keras 模型。
+*   数据预处理方案如何提升模型的性能。
-*   数据准备方案如何提升模型的表现。
+*   调整网络拓扑的实验如何提升模型性能。
-*   调整网络拓扑的实验如何提升模型表现。
 您对 Keras 的深度学习或此帖子有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file