dl keras

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 开发和运行您的第一个多层感知器网络。
+
+让我们开始吧。
+
+*   **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.jpg)
+
+Keras 的深度学习神经网络生命周期
+[Martin Stitchener](https://www.flickr.com/photos/dxhawk/6842278135/) 的照片，保留一些权利。
+
+## 概观
+
+下面概述了我们将要研究的 Keras 神经网络模型生命周期的 5 个步骤。
+
+1.  定义网络。
+2.  编译网络。
+3.  适合网络。
+4.  评估网络。
+5.  作出预测。
+
+![5 Step Life-Cycle for Neural Network Models in Keras](img/2996eabdf1f9d9a0bc2b5e1c62d6b4e5.jpg)
+
+Keras 中神经网络模型的 5 步生命周期
+
+## 步骤 1.定义网络
+
+第一步是定义您的神经网络。
+
+神经网络在 Keras 中定义为层序列。这些图层的容器是 Sequential 类。
+
+第一步是创建 Sequential 类的实例。然后，您可以创建图层并按照它们应连接的顺序添加它们。
+
+例如，我们可以分两步完成：
+
+```
+model = Sequential()
+model.add(Dense(2))
+```
+
+但是我们也可以通过创建一个图层数组并将其传递给 Sequential 的构造函数来一步完成。
+
+```
+layers = [Dense(2)]
+model = Sequential(layers)
+```
+
+网络中的第一层必须定义预期的输入数量。指定它的方式可能因网络类型而异，但对于 Multilayer Perceptron 模型，这由 input_dim 属性指定。
+
+例如，一个小的多层感知器模型，在可见层中有 2 个输入，隐藏层中有 5 个神经元，输出层中有一个神经元，可以定义为：
+
+```
+model = Sequential()
+model.add(Dense(5, input_dim=2))
+model.add(Dense(1))
+```
+
+将序列模型视为管道，将原始数据输入底部，并将预测输出到顶部。
+
+这在 Keras 中是一个有用的概念，因为传统上与图层相关的关注点也可以拆分并作为单独的图层添加，清楚地显示它们在从输入到预测的数据转换中的作用。例如，可以提取转换来自层中每个神经元的求和信号的激活函数，并将其作为称为激活的层状对象添加到 Sequential 中。
+
+```
+model = Sequential()
+model.add(Dense(5, input_dim=2))
+model.add(Activation('relu'))
+model.add(Dense(1))
+model.add(Activation('sigmoid'))
+```
+
+激活函数的选择对于输出层是最重要的，因为它将定义预测将采用的格式。
+
+例如，下面是一些常见的预测建模问题类型以及可以在输出层中使用的结构和标准激活函数：
+
+*   **回归**：线性激活函数或'线性'和与输出数匹配的神经元数。
+*   **二进制分类（2 级）**：Logistic 激活函数或'sigmoid'和一个神经元输出层。
+*   **多类分类（＆gt; 2 类）**：假设单热编码输出模式，Softmax 激活函数或'softmax'和每类值一个输出神经元。
+
+## 第 2 步。编译网络
+
+一旦我们定义了网络，我们就必须编译它。
+
+编译是一个效率步骤。它将我们定义的简单图层序列转换为高效的矩阵变换系列，其格式应在 GPU 或 CPU 上执行，具体取决于 Keras 的配置方式。
+
+将编译视为网络的预计算步骤。
+
+定义模型后始终需要编译。这包括在使用优化方案训练之前以及从保存文件加载一组预先训练的权重之前。原因是编译步骤准备了网络的有效表示，这也是对硬件进行预测所必需的。
+
+编译需要指定许多参数，专门用于培训您的网络。具体地，用于训练网络的优化算法和用于评估由优化算法最小化的网络的损失函数。
+
+例如，下面是编译定义模型并指定随机梯度下降（sgd）优化算法和均方误差（mse）损失函数的情况，用于回归类型问题。
+
+```
+model.compile(optimizer='sgd', loss='mse')
+```
+
+预测建模问题的类型对可以使用的损失函数的类型施加约束。
+
+例如，下面是不同预测模型类型的一些标准损失函数：
+
+*   **回归**：均值平方误差或' _mse_ '。
+*   **二进制分类（2 类）**：对数损失，也称为交叉熵或' _binary_crossentropy_ '。
+*   **多类分类（＆gt; 2 类）**：多类对数损失或'_ 分类 _ 交响曲 _'。
+
+您可以查看 Keras 支持的[损失函数套件。](http://keras.io/objectives/)
+
+最常见的优化算法是随机梯度下降，但 Keras 还支持其他最先进的优化算法的[套件。](http://keras.io/optimizers/)
+
+也许最常用的优化算法因为它们通常具有更好的性能：
+
+*   **随机梯度下降**或' _sgd_ '，需要调整学习速度和动量。
+*   **ADAM** 或' _adam_ '需要调整学习率。
+*   **RMSprop** 或' _rmsprop_ '需要调整学习率。
+
+最后，除了损失函数之外，您还可以指定在拟合模型时收集的度量标准。通常，要收集的最有用的附加度量标准是分类问题的准确性。要收集的度量标准由数组中的名称指定。
+
+例如：
+
+```
+model.compile(optimizer='sgd', loss='mse', metrics=['accuracy'])
+```
+
+## 步骤 3.适合网络
+
+一旦网络被编译，它就可以适合，这意味着在训练数据集上调整权重。
+
+安装网络需要指定训练数据，输入模式矩阵 X 和匹配输出模式 y 的阵列。
+
+使用反向传播算法训练网络，并根据编译模型时指定的优化算法和损失函数进行优化。
+
+反向传播算法要求网络训练指定数量的时期或暴露于训练数据集。
+
+每个纪元可以被划分为称为批次的输入 - 输出模式对的组。这定义了在一个纪元内更新权重之前网络所暴露的模式数。它也是一种效率优化，确保一次不会将太多输入模式加载到内存中。
+
+拟合网络的最小例子如下：
+
+```
+history = model.fit(X, y, batch_size=10, epochs=100)
+```
+
+适合后，将返回历史对象，该对象提供训练期间模型性能的摘要。这包括损失和编译模型时指定的任何其他指标，记录每个纪元。
+
+## 第 4 步。评估网络
+
+一旦网络被训练，就可以对其进行评估。
+
+可以在训练数据上评估网络，但是这不会提供作为预测模型的网络性能的有用指示，因为它之前已经看到了所有这些数据。
+
+我们可以在测试期间看不到的单独数据集上评估网络的性能。这将提供对网络性能的估计，以便对未来看不见的数据进行预测。
+
+该模型评估所有测试模式的损失，以及编译模型时指定的任何其他指标，如分类准确性。返回评估指标列表。
+
+例如，对于使用精度度量编制的模型，我们可以在新数据集上对其进行评估，如下所示：
+
+```
+loss, accuracy = model.evaluate(X, y)
+```
+
+## 第 5 步。做出预测
+
+最后，一旦我们对拟合模型的性能感到满意，我们就可以用它来预测新数据。
+
+这就像使用新输入模式数组调用模型上的 predict（）函数一样简单。
+
+例如：
+
+```
+predictions = model.predict(x)
+```
+
+预测将以网络输出层提供的格式返回。
+
+在回归问题的情况下，这些预测可以是直接问题的格式，由线性激活函数提供。
+
+对于二元分类问题，预测可以是第一类的概率数组，其可以通过舍入转换为 1 或 0。
+
+对于多类分类问题，结果可以是概率数组的形式（假设一个热编码输出变量），可能需要使用 [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 个输入，隐藏层中有 12 个神经元，具有整流器激活功能，输出层中有 1 个神经元具有 S 形激活功能。
+
+我们将使用 ADAM 优化算法和对数损失函数对批量大小为 10 的 100 个时期进行网络训练。
+
+一旦适合，我们将评估训练数据的模型，然后对训练数据进行独立预测。这是为了简洁起见，通常我们会在单独的测试数据集上评估模型并对新数据进行预测。
+
+完整的代码清单如下。
+
+```
+# 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
+model = Sequential()
+model.add(Dense(12, input_dim=8, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+# 2\. compile the network
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+# 3\. fit the network
+history = model.fit(X, Y, epochs=100, batch_size=10)
+# 4\. evaluate the network
+loss, accuracy = model.evaluate(X, Y)
+print("\nLoss: %.2f, Accuracy: %.2f%%" % (loss, accuracy*100))
+# 5\. make predictions
+probabilities = model.predict(X)
+predictions = [float(round(x)) for x in probabilities]
+accuracy = numpy.mean(predictions == Y)
+print("Prediction Accuracy: %.2f%%" % (accuracy*100))
+```
+
+运行此示例将生成以下输出：
+
+```
+...
+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

docs/dl-keras/SUMMARY.md

++   [Keras 中神经网络模型的 5 步生命周期](5-step-life-cycle-neural-network-models-keras.md)
++   [在 Python 迷你课程中应用深度学习](applied-deep-learning-in-python-mini-course.md)
++   [Keras 深度学习库的二进制分类教程](binary-classification-tutorial-with-the-keras-deep-learning-library.md)
++   [如何用 Keras 构建多层感知器神经网络模型](build-multi-layer-perceptron-neural-network-models-keras.md)
++   [如何在 Keras 中检查深度学习模型](check-point-deep-learning-models-keras.md)
++   [10 个用于 Amazon Web Services 深度学习的命令行配方](command-line-recipes-deep-learning-amazon-web-services.md)
++   [机器学习卷积神经网络的速成课程](crash-course-convolutional-neural-networks.md)
++   [如何在 Python 中使用 Keras 进行深度学习的度量](custom-metrics-deep-learning-keras-python.md)
++   [深度学习书籍](deep-learning-books.md)
++   [深度学习课程](deep-learning-courses.md)
++   [你所知道的深度学习是一种谎言](deep-learning-for-developers.md)
++   [如何设置 Amazon AWS EC2 GPU 以培训 Keras 深度学习模型（分步）](develop-evaluate-large-deep-learning-models-keras-amazon-web-services.md)
++   [神经网络中批处理和历元之间的区别是什么？](difference-between-a-batch-and-an-epoch.md)
++   [在 Keras 展示深度学习模式培训历史](display-deep-learning-model-training-history-in-keras.md)
++   [基于 Keras 的深度学习模型中的辍学规律化](dropout-regularization-deep-learning-models-keras.md)
++   [评估 Keras 中深度学习模型的性能](evaluate-performance-deep-learning-models-keras.md)
++   [如何评价深度学习模式的技巧](evaluate-skill-deep-learning-models.md)
++   [微型批量梯度下降的简要介绍以及如何配置批量大小](gentle-introduction-mini-batch-gradient-descent-configure-batch-size.md)
++   [在 Keras 中获得深度学习帮助的 9 种方法](get-help-with-keras.md)
++   [如何使用 Keras 进行 Python 中深度学习模型的网格搜索超参数](grid-search-hyperparameters-deep-learning-models-python-keras.md)
++   [用 Keras 在 Python 中使用卷积神经网络进行手写数字识别](handwritten-digit-recognition-using-convolutional-neural-networks-python-keras.md)
++   [如何用 Keras 进行预测](how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras.md)
++   [用 Keras 进行深度学习的图像增强](image-augmentation-deep-learning-keras.md)
++   [8 深度学习的鼓舞人心的应用](inspirational-applications-deep-learning.md)
++   [使用 Keras 介绍 Python 深度学习](introduction-python-deep-learning-library-keras.md)
++   [Python 深度学习库 TensorFlow 简介](introduction-python-deep-learning-library-tensorflow.md)
++   [Python 深度学习库 Theano 简介](introduction-python-deep-learning-library-theano.md)
++   [如何使用 Keras Functional API 进行深度学习](keras-functional-api-deep-learning.md)
++   [Keras 深度学习库的多类分类教程](multi-class-classification-tutorial-keras-deep-learning-library.md)
++   [多层感知器神经网络速成课程](neural-networks-crash-course.md)
++   [基于卷积神经网络的 Keras 深度学习库中的目标识别](object-recognition-convolutional-neural-networks-keras-deep-learning-library.md)
++   [流行的深度学习图书馆](popular-deep-learning-libraries.md)
++   [用深度学习预测电影评论的情绪](predict-sentiment-movie-reviews-using-deep-learning.md)
++   [使用 Python 中的 Keras 深度学习库进行回归教程](regression-tutorial-keras-deep-learning-library-python.md)
++   [如何使用 Keras 获得可重现的结果](reproducible-results-neural-networks-keras.md)
++   [如何在 Linux 服务器上运行深度学习实验](run-deep-learning-experiments-linux-server.md)
++   [保存并加载您的 Keras 深度学习模型](save-load-keras-deep-learning-models.md)
++   [用 Keras 逐步开发 Python 中的第一个神经网络](tutorial-first-neural-network-python-keras.md)
++   [用 Keras 理解 Python 中的有状态 LSTM 循环神经网络](understanding-stateful-lstm-recurrent-neural-networks-python-keras.md)
++   [在 Python 中使用 Keras 深度学习模型和 Scikit-Learn](use-keras-deep-learning-models-scikit-learn-python.md)
++   [如何使用预训练的 VGG 模型对照片中的物体进行分类](use-pre-trained-vgg-model-classify-objects-photographs.md)
++   [使用 Keras 在 Python 中使用学习速率计划进行深度学习模型](using-learning-rate-schedules-deep-learning-models-python-keras.md)
++   [如何在 Keras 中可视化深度学习神经网络模型](visualize-deep-learning-neural-network-model-keras.md)
++   [什么是深度学习？](what-is-deep-learning.md)
++   [何时使用 MLP，CNN 和 RNN 神经网络](when-to-use-mlp-cnn-and-rnn-neural-networks.md)
++   [为什么用随机权重初始化神经网络？](why-initialize-a-neural-network-with-random-weights.md)
\ No newline at end of file

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 中神经网络的拓扑和配置。
+
+让我们开始吧。
+
+*   **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.jpg)
+
+使用 Keras 深度学习库的二进制分类工作示例
+[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 个输入变量是不同角度的回报强度。这是一个二元分类问题，需要一个模型来区分岩石和金属圆柱。
+
+您可以在 [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。
+
+使用此数据集的好处是它是标准基准问题。这意味着我们对一个好模型的预期技能有所了解。使用交叉验证，神经网络[应该能够实现 84％左右的性能](http://www.is.umk.pl/projects/datasets.html#Sonar)，定制模型的准确度上限约为 88％。
+
+## 2.基线神经网络模型性能
+
+让我们为这个问题创建一个基线模型和结果。
+
+我们将首先导入我们需要的所有类和函数。
+
+```
+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
+```
+
+接下来，我们可以初始化随机数生成器，以确保在执行此代码时始终获得相同的结果。如果我们正在调试，这将有所帮助。
+
+```
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+```
+
+现在我们可以使用 [pandas](http://pandas.pydata.org/) 加载数据集，并将列拆分为 60 个输入变量（X）和 1 个输出变量（Y）。我们使用 pandas 来加载数据，因为它可以轻松处理字符串（输出变量），而尝试使用 NumPy 直接加载数据会更加困难。
+
+```
+# 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。
+
+我们可以使用 scikit-learn 中的 LabelEncoder 类来完成此操作。此类将通过 fit（）函数使用整个数据集对所需的编码进行建模，然后应用编码以使用 transform（）函数创建新的输出变量。
+
+```
+# encode class values as integers
+encoder = LabelEncoder()
+encoder.fit(Y)
+encoded_Y = encoder.transform(Y)
+```
+
+我们现在准备使用 Keras 创建我们的神经网络模型。
+
+我们将使用 scikit-learn 来使用分层 k 折交叉验证来评估模型。这是一种重采样技术，可以提供模型性能的估计。它通过将数据分成 k 部分来实现这一点，在所有部分上训练模型，除了作为测试集的一部分以评估模型的性能。该过程重复 k 次，并且所有构建的模型的平均分数被用作性能的稳健估计。它是分层的，这意味着它将查看输出值并尝试平衡属于数据 k 分裂中每个类的实例数。
+
+要将 Keras 模型与 scikit-learn 一起使用，我们必须使用 KerasClassifier 包装器。该类采用创建并返回神经网络模型的函数。它还会将参数传递给 fit（）调用，例如纪元数和批量大小。
+
+让我们从定义创建基线模型的函数开始。我们的模型将具有单个完全连接的隐藏层，其具有与输入变量相同数量的神经元。这是创建神经网络时的一个很好的默认起点。
+
+使用小的高斯随机数初始化权重。使用整流器激活功能。输出层包含单个神经元以进行预测。它使用 sigmoid 激活函数，以产生 0 到 1 范围内的概率输出，可以轻松自动地转换为清晰的类值。
+
+最后，我们在训练期间使用对数损失函数（binary_crossentropy），这是二进制分类问题的首选损失函数。该模型还使用有效的 Adam 优化算法进行梯度下降，并在训练模型时收集精度度量。
+
+```
+# 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 框架中使用分层交叉验证来评估这个模型。
+
+我们再次使用合理的默认值将训练时期的数量传递给 KerasClassifier。假设模型将被创建 10 次以进行 10 次交叉验证，也会关闭详细输出。
+
+```
+# 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))
+```
+
+运行此代码将生成以下输出，显示模型在未见数据上的估计精度的平均值和标准差。
+
+```
+Baseline: 81.68% (7.26%)
+```
+
+这是一个很好的分数，没有做任何艰苦的工作。
+
+## 3.使用数据准备重新运行基线模型
+
+在建模之前准备数据是一种很好的做法。
+
+神经网络模型尤其适用于在规模和分布方面具有一致的输入值。
+
+建立神经网络模型时表格数据的有效数据准备方案是标准化。这是重新调整数据的位置，使得每个属性的平均值为 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 定义管道，然后使用我们的神经网络模型。
+
+```
+# evaluate baseline model with standardized dataset
+numpy.random.seed(seed)
+estimators = []
+estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasClassifier(build_fn=create_baseline, epochs=100, batch_size=5, verbose=0)))
+pipeline = Pipeline(estimators)
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
+print("Standardized: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+```
+
+运行此示例提供以下结果。我们确实看到一个小而非常好的升力平均精度。
+
+```
+Standardized: 84.56% (5.74%)
+```
+
+## 4.调整模型中的层和神经元数量
+
+在神经网络上需要调整很多东西，例如权重初始化，激活函数，优化过程等。
+
+可能具有特大效应的一个方面是网络本身的结构，称为网络拓扑。在本节中，我们将看一下关于网络结构的两个实验：将其缩小并使其更大。
+
+这些是在针对您的问题调整神经网络时执行的良好实验。
+
+### 4.1。评估较小的网络
+
+我怀疑这个问题的输入变量有很多冗余。
+
+数据描述了来自不同角度的相同信号。也许其中一些角度比其他角度更有意义。我们可以通过限制第一个隐藏层中的表示空间来强制网络进行一种特征提取。
+
+在这个实验中，我们采用隐藏层中 60 个神经元的基线模型，并将其减少一半到 30 个。这将在训练期间对网络施加压力，以挑选输入数据中最重要的结构进行建模。
+
+我们还将在数据准备的前一个实验中对数据进行标准化，并尝试利用性能的小提升。
+
+```
+# smaller model
+def create_smaller():
+	# create model
+	model = Sequential()
+	model.add(Dense(30, 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
+estimators = []
+estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasClassifier(build_fn=create_smaller, epochs=100, batch_size=5, verbose=0)))
+pipeline = Pipeline(estimators)
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
+print("Smaller: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+```
+
+运行此示例提供以下结果。我们可以看到，我们对平均估计精度有一个非常小的提升，并且模型的精度分数的标准偏差（平均分布）显着降低。
+
+这是一个很好的结果，因为我们在网络尺寸减半的情况下做得稍微好一些，而这只需要一半的时间来训练。
+
+```
+Smaller: 86.04% (4.00%)
+```
+
+### 4.2。评估更大的网络
+
+具有更多层的神经网络拓扑为网络提供了更多机会来提取关键特征并以有用的非线性方式重新组合它们。
+
+我们可以通过对用于创建模型的函数进行另一个小调整来评估是否向网络添加更多层可以轻松改善性能。在这里，我们向网络添加一个新层（一行），在第一个隐藏层之后引入另一个隐藏层，其中包含 30 个神经元。
+
+我们的网络现在具有拓扑结构：
+
+```
+60 inputs -> [60 -> 30] -> 1 output
+```
+
+这里的想法是，网络有机会在瓶颈之前对所有输入变量进行建模，并被迫将表示能力减半，就像我们在上面的小网络实验中所做的那样。
+
+我们有一个额外的隐藏层来帮助这个过程，而不是压缩输入本身的表示。
+
+```
+# larger model
+def create_larger():
+	# create model
+	model = Sequential()
+	model.add(Dense(60, input_dim=60, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(30, 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
+estimators = []
+estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasClassifier(build_fn=create_larger, epochs=100, batch_size=5, verbose=0)))
+pipeline = Pipeline(estimators)
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
+print("Larger: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+```
+
+运行此示例将生成以下结果。我们可以看到，我们在模型性能方面没有得到提升。这可能是统计噪音或需要进一步培训的迹象。
+
+```
+Larger: 83.14% (4.52%)
+```
+
+通过进一步调整诸如优化算法和训练时期的数量之类的方面，预期可以进一步改进。您可以在此数据集上获得的最佳分数是多少？
+
+## 摘要
+
+在这篇文章中，您发现了 Python 中的 Keras 深度学习库。
+
+您了解了如何使用 Keras 逐步完成二进制分类问题，具体如下：
+
+*   如何加载和准备在 Keras 中使用的数据。
+*   如何创建基线神经网络模型。
+*   如何使用 scikit-learn 和分层 k 折交叉验证来评估 Keras 模型。
+*   数据准备方案如何提升模型的性能。
+*   调整网络拓扑的实验如何提升模型性能。
+
+您对 Keras 的深度学习或此帖子有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file

docs/dl-keras/build-multi-layer-perceptron-neural-network-models-keras.md

+# 如何用 Keras 构建多层感知器神经网络模型
+
+> 原文： [https://machinelearningmastery.com/build-multi-layer-perceptron-neural-network-models-keras/](https://machinelearningmastery.com/build-multi-layer-perceptron-neural-network-models-keras/)
+
+用于深度学习的 Keras Python 库专注于将模型创建为一系列层。
+
+在这篇文章中，您将发现可用于创建神经网络的简单组件和使用 Keras 的简单深度学习模型。
+
+让我们开始吧。
+
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+
+![How To Build Multi-Layer Perceptron Neural Network Models with Keras](img/1ff32d002f02ee2ec7be1f308faffc6b.jpg)
+
+如何使用 Keras 建立多层感知器神经网络模型
+照片由 [George Rex](https://www.flickr.com/photos/rogersg/13316350364/) ，保留一些权利。
+
+## Keras 中的神经网络模型
+
+Keras 库的重点是模型。
+
+最简单的模型在 Sequential 类中定义，它是一个层的线性堆栈。
+
+您可以创建一个 Sequential 模型并定义构造函数中的所有图层，例如：
+
+```
+from keras.models import Sequential
+model = Sequential(...)
+```
+
+更有用的习惯是创建一个 Sequential 模型并按照您希望执行的计算顺序添加图层，例如：
+
+```
+from keras.models import Sequential
+model = Sequential()
+model.add(...)
+model.add(...)
+model.add(...)
+```
+
+## 模型输入
+
+模型中的第一层必须指定输入的形状。
+
+这是输入属性的数量，由 input_dim 参数定义。这个参数需要一个整数。
+
+例如，您可以按照 Dense 类型图层的 8 个输入定义输入，如下所示：
+
+```
+Dense(16, input_dim=8)
+```
+
+## 模型层
+
+不同类型的层是一些共同的属性，特别是它们的权重初始化和激活函数的方法。
+
+### 重量初始化
+
+用于层的初始化类型在 init 参数中指定。
+
+一些常见的层初始化类型包括：
+
+*   “_ 均匀 _”：将权重初始化为 0 到 0.05 之间的小的均匀随机值。
+*   “_ 正常 _”：将权重初始化为小高斯随机值（零均值和标准差 0.05）。
+*   “_ 为零 _”：所有权重都设置为零。
+
+您可以在[初始化用法](http://keras.io/initializations/)页面上看到完整的初始化技术列表。
+
+### 激活功能
+
+Keras 支持一系列标准神经元激活功能，例如：softmax，整流器，tanh 和 S 形。
+
+您通常会指定激活参数中图层使用的激活函数的类型，该函数采用字符串值。
+
+您可以在[激活用法](http://keras.io/activations/)页面上查看 Keras 支持的完整激活功能列表。
+
+有趣的是，您还可以创建一个 Activation 对象，并在图层之后将其直接添加到模型中，以将该激活应用于图层的输出。
+
+### 图层类型
+
+标准神经网络有大量的核心层类型。
+
+您可以选择的一些常见且有用的图层类型是：
+
+*   **密集**：完全连接的层和多层感知器模型上使用的最常见的层。
+*   **Dropout** ：将 dropout 应用于模型，将输入的一小部分设置为零，以减少过拟合。
+*   **合并**：将多个模型的输入组合到一个模型中。
+
+您可以在[核心层](http://keras.io/layers/core/)页面上了解核心 Keras 层的完整列表
+
+## 模型编译
+
+一旦定义了模型，就需要编译它。
+
+这将创建底层后端（Theano 或 TensorFlow）使用的有效结构，以便在训练期间有效地执行您的模型。
+
+您使用 compile（）函数编译模型，它接受三个重要属性：
+
+1.  模型优化器。
+2.  损失功能。
+3.  指标。
+
+```
+model.compile(optimizer=, loss=, metrics=)
+```
+
+### 1.模型优化器
+
+优化程序是用于更新模型中权重的搜索技术。
+
+您可以创建优化器对象并通过优化器参数将其传递给编译函数。这允许您使用自己的参数（例如学习速率）配置优化过程。例如：
+
+```
+sgd = SGD(...)
+model.compile(optimizer=sgd)
+```
+
+您还可以通过为优化程序参数指定优化程序的名称来使用优化程序的默认参数。例如：
+
+```
+model.compile(optimizer='sgd')
+```
+
+您可能想要选择的一些流行的梯度下降优化器包括：
+
+*   **SGD** ：随机梯度下降，支持动量。
+*   **RMSprop** ：Geoff Hinton 提出的自适应学习速率优化方法。
+*   **Adam** ：自适应力矩估计（Adam），也使用自适应学习率。
+
+您可以在 [Usage of optimizers](http://keras.io/optimizers/) 页面上了解 Keras 支持的所有优化器。
+
+您可以在 Sebastian Ruder 的帖子[的](http://sebastianruder.com/optimizing-gradient-descent/index.html)[梯度下降优化算法部分](http://sebastianruder.com/optimizing-gradient-descent/index.html#gradientdescentoptimizationalgorithms)上了解有关不同梯度下降方法的更多信息。梯度下降优化算法概述。
+
+### 2.模型损失函数
+
+损失函数，也称为目标函数，是评估优化器用于导航权重空间的模型。
+
+您可以通过 loss 参数指定要用于编译函数的 loss 函数的名称。一些常见的例子包括：
+
+*   ' _mse_ '：表示均方误差。
+*   ' _binary_crossentropy_ '：用于二进制对数损失（logloss）。
+*   ' _categorical_crossentropy_ '：用于多类对数损失（logloss）。
+
+您可以在[目标用途](http://keras.io/objectives/)页面上了解更多关于 Keras 支持的损失功能。
+
+### 3.模型指标
+
+在训练期间，模型评估度量标准。
+
+目前仅支持一个指标，这就是准确性。
+
+## 模特训练
+
+例如，使用 fit（）函数在 NumPy 数组上训练模型
+
+```
+model.fit(X, y, epochs=, batch_size=)
+```
+
+训练都指定了训练的时期数和批量大小。
+
+*   Epochs（nb_epoch）是模型暴露给训练数据集的次数。
+*   批量大小（batch_size）是在执行权重更新之前向模型显示的训练实例的数量。
+
+拟合函数还允许在训练期间对模型进行一些基本评估。您可以设置 validation_split 值以阻止训练数据集的一小部分，以便在每个时期评估验证，或者提供要评估的（X，y）数据的 validation_data 元组。
+
+拟合模型返回历史对象，其中包含为每个时期的模型计算的详细信息和指标。这可用于绘制模型性能。
+
+## 模型预测
+
+培训完模型后，可以使用它来预测测试数据或新数据。
+
+您可以从训练模型中计算出许多不同的输出类型，每种输出类型都是使用模型对象上的不同函数调用计算的。例如：
+
+*   _model.evaluate（）_：计算输入数据的损失值。
+*   _model.predict（）_：为输入数据生成网络输出。
+*   _model.predict_classes（）_：为输入数据生成类输出。
+*   _model.predict_proba（）_：为输入数据生成类概率。
+
+例如，在分类问题上，您将使用 predict_classes（）函数对测试数据或新数据实例进行预测。
+
+## 总结模型
+
+一旦您对您的模型感到满意，您就可以完成它。
+
+您可能希望输出模型的摘要。例如，您可以通过调用摘要函数来显示模型的摘要，例如：
+
+```
+model.summary()
+```
+
+您还可以使用 get_config（）函数检索模型配置的摘要，例如：
+
+```
+model.get_config()
+```
+
+最后，您可以直接创建模型结构的图像。例如：
+
+```
+from keras.utils.vis_utils import plot_model
+plot(model, to_file='model.png')
+```
+
+## 资源
+
+您可以使用以下资源了解有关如何在 Keras 中创建简单神经网络和深度学习模型的更多信息：
+
+*   [开始使用 Keras 顺序模型](http://keras.io/getting-started/sequential-model-guide/)。
+*   [关于 Keras 型号](http://keras.io/models/about-keras-models/)。
+*   [顺序模型 API](http://keras.io/models/sequential/) 。
+
+## 摘要
+
+在这篇文章中，您发现了可用于创建人工神经网络和深度学习模型的 Keras API。
+
+具体来说，您了解了 Keras 模型的生命周期，包括：
+
+*   构建模型。
+*   创建和添加图层，包括权重初始化和激活。
+*   编译模型包括优化方法，损失函数和度量。
+*   适合包括时代和批量大小的模型
+*   模型预测。
+*   总结模型。
+
+如果您对 Keras for Deep Learning 或本文有任何疑问，请在评论中提问，我会尽力回答。
\ No newline at end of file

docs/dl-keras/check-point-deep-learning-models-keras.md

+# 如何在 Keras 中检查深度学习模型
+
+> 原文： [https://machinelearningmastery.com/check-point-deep-learning-models-keras/](https://machinelearningmastery.com/check-point-deep-learning-models-keras/)
+
+深度学习模型可能需要数小时，数天甚至数周才能进行训练。
+
+如果意外停止运行，则可能会丢失大量工作。
+
+在这篇文章中，您将了解如何使用 Keras 库在 Python 培训期间检查您的深度学习模型。
+
+让我们开始吧。
+
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+*   **更新 March / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。
+
+![How to Check-Point Deep Learning Models in Keras](img/299672cd2b9efa26d634b06c4df2e751.jpg)
+
+如何在 Keras 检查深度学习模型
+照片由 [saragoldsmith](https://www.flickr.com/photos/saragoldsmith/2353051153/) ，保留一些权利。
+
+## 检验点神经网络模型
+
+[应用程序检查点](https://en.wikipedia.org/wiki/Application_checkpointing)是一种容错技术，适用于长时间运行的进程。
+
+这是一种在系统出现故障时采用系统状态快照的方法。如果出现问题，并非全部丢失。检查点可以直接使用，或者用作新运行的起点，从中断处开始。
+
+在训练深度学习模型时，检查点是模型的权重。这些权重可用于按原样进行预测，或用作持续培训的基础。
+
+Keras 库通过回调 API 提供[检查点功能。](http://keras.io/callbacks/#modelcheckpoint)
+
+ModelCheckpoint 回调类允许您定义检查模型权重的位置，文件应如何命名以及在何种情况下创建模型的检查点。
+
+API 允许您指定要监控的度量标准，例如培训或验证数据集的丢失或准确性。您可以指定是否在最大化或最小化分数时寻求改进。最后，用于存储权重的文件名可以包含诸如纪元号或度量的变量。
+
+然后，在模型上调用 fit（）函数时，可以将 ModelCheckpoint 传递给训练过程。
+
+注意，您可能需要安装 [h5py 库](http://www.h5py.org/)以输出 HDF5 格式的网络权重。
+
+## 检查点神经网络模型改进
+
+检查点的良好用途是每次在训练期间观察到改进时输出模型权重。
+
+下面的例子为皮马印第安人糖尿病二元分类问题创建了一个小型神经网络。该示例假设 _pima-indians-diabetes.csv_ 文件位于您的工作目录中。
+
+您可以从此处下载数据集：
+
+*   [皮马印第安人糖尿病数据集](https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv)
+
+该示例使用 33％的数据进行验证。
+
+只有在验证数据集（monitor ='val_acc'和 mode ='max'）的分类准确性有所提高时，才会设置检验点以保存网络权重。权重存储在一个文件中，该文件包含文件名中的分数（权重改进 - {val_acc = .2f} .hdf5）。
+
+```
+# Checkpoint the weights when validation accuracy improves
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.callbacks import ModelCheckpoint
+import matplotlib.pyplot as plt
+import numpy
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load pima indians dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+# split into input (X) and output (Y) variables
+X = dataset[:,0:8]
+Y = dataset[:,8]
+# create model
+model = Sequential()
+model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='relu'))
+model.add(Dense(8, kernel_initializer='uniform', activation='relu'))
+model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
+# Compile model
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+# checkpoint
+filepath="weights-improvement-{epoch:02d}-{val_acc:.2f}.hdf5"
+checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')
+callbacks_list = [checkpoint]
+# Fit the model
+model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10, callbacks=callbacks_list, verbose=0)
+```
+
+运行该示例将生成以下输出（为简洁起见，将其截断）：
+
+```
+...
+Epoch 00134: val_acc did not improve
+Epoch 00135: val_acc did not improve
+Epoch 00136: val_acc did not improve
+Epoch 00137: val_acc did not improve
+Epoch 00138: val_acc did not improve
+Epoch 00139: val_acc did not improve
+Epoch 00140: val_acc improved from 0.83465 to 0.83858, saving model to weights-improvement-140-0.84.hdf5
+Epoch 00141: val_acc did not improve
+Epoch 00142: val_acc did not improve
+Epoch 00143: val_acc did not improve
+Epoch 00144: val_acc did not improve
+Epoch 00145: val_acc did not improve
+Epoch 00146: val_acc improved from 0.83858 to 0.84252, saving model to weights-improvement-146-0.84.hdf5
+Epoch 00147: val_acc did not improve
+Epoch 00148: val_acc improved from 0.84252 to 0.84252, saving model to weights-improvement-148-0.84.hdf5
+Epoch 00149: val_acc did not improve
+```
+
+您将在工作目录中看到许多文件，其中包含 HDF5 格式的网络权重。例如：
+
+```
+...
+weights-improvement-53-0.76.hdf5
+weights-improvement-71-0.76.hdf5
+weights-improvement-77-0.78.hdf5
+weights-improvement-99-0.78.hdf5
+```
+
+这是一个非常简单的检查点策略。如果验证准确度在训练时期上下移动，则可能会创建大量不必要的检查点文件。然而，它将确保您拥有在运行期间发现的最佳模型的快照。
+
+## 仅限检查点最佳神经网络模型
+
+更简单的检查点策略是将模型权重保存到同一文件中，当且仅当验证准确度提高时。
+
+这可以使用上面相同的代码轻松完成，并将输出文件名更改为固定（不包括分数或纪元信息）。
+
+在这种情况下，只有当验证数据集上模型的分类精度提高到目前为止最佳时，模型权重才会写入文件“weights.best.hdf5”。
+
+```
+# Checkpoint the weights for best model on validation accuracy
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.callbacks import ModelCheckpoint
+import matplotlib.pyplot as plt
+import numpy
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load pima indians dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+# split into input (X) and output (Y) variables
+X = dataset[:,0:8]
+Y = dataset[:,8]
+# create model
+model = Sequential()
+model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='relu'))
+model.add(Dense(8, kernel_initializer='uniform', activation='relu'))
+model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
+# Compile model
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+# checkpoint
+filepath="weights.best.hdf5"
+checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')
+callbacks_list = [checkpoint]
+# Fit the model
+model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10, callbacks=callbacks_list, verbose=0)
+```
+
+运行此示例提供以下输出（为简洁起见，将其截断）：
+
+```
+...
+Epoch 00139: val_acc improved from 0.79134 to 0.79134, saving model to weights.best.hdf5
+Epoch 00140: val_acc did not improve
+Epoch 00141: val_acc did not improve
+Epoch 00142: val_acc did not improve
+Epoch 00143: val_acc did not improve
+Epoch 00144: val_acc improved from 0.79134 to 0.79528, saving model to weights.best.hdf5
+Epoch 00145: val_acc improved from 0.79528 to 0.79528, saving model to weights.best.hdf5
+Epoch 00146: val_acc did not improve
+Epoch 00147: val_acc did not improve
+Epoch 00148: val_acc did not improve
+Epoch 00149: val_acc did not improve
+```
+
+您应该在本地目录中看到权重文件。
+
+```
+weights.best.hdf5
+```
+
+这是一个方便的检查点策略，在您的实验中始终使用。它将确保为运行保存最佳模型，以便您以后使用。它避免了您需要在训练时包含代码以手动跟踪和序列化最佳模型。
+
+## 加载检查指向神经网络模型
+
+现在您已经了解了如何在培训期间检查您的深度学习模型，您需要查看如何加载和使用检查点模型。
+
+检查点仅包括模型权重。它假设您了解网络结构。这也可以序列化为 JSON 或 YAML 格式的文件。
+
+在下面的示例中，模型结构是已知的，最佳权重从上一个实验加载，存储在 weights.best.hdf5 文件的工作目录中。
+
+然后使用该模型对整个数据集进行预测。
+
+```
+# How to load and use weights from a checkpoint
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.callbacks import ModelCheckpoint
+import matplotlib.pyplot as plt
+import numpy
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# create model
+model = Sequential()
+model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='relu'))
+model.add(Dense(8, kernel_initializer='uniform', activation='relu'))
+model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
+# load weights
+model.load_weights("weights.best.hdf5")
+# Compile model (required to make predictions)
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+print("Created model and loaded weights from file")
+# load pima indians dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+# split into input (X) and output (Y) variables
+X = dataset[:,0:8]
+Y = dataset[:,8]
+# estimate accuracy on whole dataset using loaded weights
+scores = model.evaluate(X, Y, verbose=0)
+print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
+```
+
+运行该示例将生成以下输出：
+
+```
+Created model and loaded weights from file
+acc: 77.73%
+```
+
+## 摘要
+
+在这篇文章中，您已经发现了深度学习模型在长时间训练中的重要性。
+
+您学习了两个检查点策略，您可以在下一个深度学习项目中使用它们：
+
+1.  检查点模型改进。
+2.  Checkpoint 最佳型号。
+
+您还学习了如何加载检查点模型并进行预测。
+
+您对深度学习模型或此帖的检查点有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file

docs/dl-keras/command-line-recipes-deep-learning-amazon-web-services.md

+# 10 个用于 Amazon Web Services 深度学习的命令行配方
+
+> 原文： [https://machinelearningmastery.com/command-line-recipes-deep-learning-amazon-web-services/](https://machinelearningmastery.com/command-line-recipes-deep-learning-amazon-web-services/)
+
+在 Amazon Web Services EC2 上运行大型深度学习流程是学习和开发模型的一种廉价而有效的方法。
+
+只需几美元，您就可以访问数十 GB 的 RAM，数十个 CPU 内核和多个 GPU。我强烈推荐它。
+
+如果您不熟悉 EC2 或 Linux 命令行，那么在云中运行深度学习脚本时，您会发现一组命令非常宝贵。
+
+在本教程中，您将发现我每次使用 EC2 来适应大型深度学习模型时使用的 10 个命令的私有列表。
+
+阅读这篇文章后，你会知道：
+
+*   如何将数据复制到 EC2 实例和从 EC2 实例复制数据。
+*   如何将脚本设置为安全地运行数天，数周或数月。
+*   如何监控进程，系统和 GPU 性能。
+
+让我们开始吧。
+
+**注意**：从工作站执行的所有命令都假定您运行的是 Linux 类型的环境（例如 Linux，OS X 或 cygwin）。
+
+**你有在 EC2 上运行模型的任何其他提示，技巧或喜欢的命令吗？**
+请在下面的评论中告诉我。
+
+![10 Command Line Recipes for Deep Learning on Amazon Web Services](img/2ff0956a0537ec5bd319693e3ac5b79a.jpg)
+
+10 亚马逊网络服务深度学习命令行方案
+[chascar](https://www.flickr.com/photos/chascar/6480093119/) 的照片，保留一些权利。
+
+## 概观
+
+本文中提供的命令假定您的 AWS EC2 实例已在运行。
+
+为保持一致性，还做了一些其他假设：
+
+*   您的服务器 IP 地址是 _54.218.86.47_ ;将其更改为服务器实例的 IP 地址。
+*   您的用户名是 _ec2-user_ ;将其更改为您实例上的用户名。
+*   您的 SSH 密钥位于 _〜/ .ssh /_ 中，文件名为 _aws-keypair.pem_ ;将其更改为 SSH 密钥位置和文件名。
+*   您正在使用 Python 脚本。
+
+如果您需要帮助来设置和运行基于 GPU 的 AWS EC2 实例以进行深度学习，请参阅教程：
+
+*   [如何使用亚马逊网络服务上的 Keras 开发和评估大型深度学习模型](http://machinelearningmastery.com/develop-evaluate-large-deep-learning-models-keras-amazon-web-services/)
+
+## 1.从您的工作站登录到服务器
+
+您必须先登录服务器才能执行任何有用的操作。
+
+您可以使用 SSH 安全 shell 轻松登录。
+
+我建议将 SSH 密钥存储在 _〜/ .ssh /_ 目录中，并使用有用的名称。我使用名称 _aws-keypair.pem_ 。请记住：文件必须具有权限 600。
+
+以下命令将使您登录到服务器实例。请记住将用户名和 IP 地址更改为相关的用户名和服务器实例 IP 地址。
+
+```
+ssh -i ~/.ssh/aws-keypair.pem ec2-user@54.218.86.47
+```
+
+## 2.将文件从工作站复制到服务器
+
+使用安全副本（scp）将文件从工作站复制到服务器实例。
+
+以下示例在您的工作站上运行，将工作站本地目录中的 _script.py_ Python 脚本复制到您的服务器实例。
+
+```
+scp -i ~/.ssh/aws-keypair.pem script.py ec2-user@54.218.86.47:~/
+```
+
+## 3.在服务器上运行脚本作为后台进程
+
+您可以将 Python 脚本作为后台进程运行。
+
+此外，您可以以这样的方式运行它，它将忽略来自其他进程的信号，忽略任何标准输入（stdin），并将所有输出和错误转发到日志文件。
+
+根据我的经验，所有这些都是长期运行脚本以适应大型深度学习模型所必需的。
+
+```
+nohup python /home/ec2-user/script.py >/home/ec2-user/script.py.log </dev/null 2>&1 &
+```
+
+这假设您正在运行位于 _/ home / ec2-user /_ 目录中的 _script.py_ Python 脚本，并且您希望将此脚本的输出转发到文件 _script.py.log_ 位于同一目录中。
+
+调整你的需求。
+
+如果这是你第一次体验 nohup，你可以在这里了解更多：
+
+*   维基百科上的 [nohup](https://en.wikipedia.org/wiki/Nohup)
+
+如果这是您第一次重定向标准输入（stdin），标准输出（标准输出）和标准错误（sterr），您可以在此处了解更多信息：
+
+*   维基百科上的[重定向](https://en.wikipedia.org/wiki/Redirection_(computing))
+
+## 4.在服务器上的特定 GPU 上运行脚本
+
+如果您的 AWS EC2 实例可以针对您的问题处理它，我建议您同时运行多个脚本。
+
+例如，您选择的 EC2 实例可能有 4 个 GPU，您可以选择在每个实例上运行一个脚本。
+
+使用 CUDA，您可以指定要与环境变量 _CUDA_VISIBLE_DEVICES_ 一起使用的 GPU 设备。
+
+我们可以使用上面相同的命令来运行脚本并指定要使用的特定 GPU 设备，如下所示：
+
+```
+CUDA_VISIBLE_DEVICES=0 nohup python /home/ec2-user/script.py >/home/ec2-user/script.py.log </dev/null 2>&1 &
+```
+
+如果您的实例上有 4 个 GPU 设备，则可以将 _CUDA_VISIBLE_DEVICES = 0_ 指定为 _CUDA_VISIBLE_DEVICES = 3。_
+
+我希望这可以用于 Theano 后端，但我只测试了用于 Keras 的 TensorFlow 后端。
+
+您可以在帖子中了解有关 _CUDA_VISIBLE_DEVICES_ 的更多信息：
+
+*   [CUDA Pro 提示：使用 CUDA_VISIBLE_DEVICES 控制 GPU 可见性](https://devblogs.nvidia.com/parallelforall/cuda-pro-tip-control-gpu-visibility-cuda_visible_devices/)
+
+## 5.监视服务器上的脚本输出
+
+您可以在脚本运行时监视脚本的输出。
+
+如果您在每个时期或每个算法运行后输出分数，这可能很有用。
+
+此示例将列出脚本日志文件的最后几行，并在脚本中添加新行时更新输出。
+
+```
+tail -f script.py.log
+```
+
+如果屏幕暂时没有获得新输出，亚马逊可能会积极关闭您的终端。
+
+另一种方法是使用 watch 命令。我发现亚马逊将保持这个终端开放：
+
+```
+watch "tail script.py.log"
+```
+
+我发现 python 脚本的标准输出（粗壮）似乎没有经常更新。
+
+我不知道这是 EC2 还是 Python 的东西。这意味着您可能无法经常更新日志中的输出。当缓冲区达到固定大小或运行结束时，它似乎被缓冲并输出。
+
+你对此有更多了解吗？
+请在下面的评论中告诉我。
+
+## 6.监视服务器上的系统和进程性能
+
+监控 EC2 系统性能是个好主意。特别是你正在使用和剩下的 RAM 量。
+
+您可以使用将每隔几秒更新一次的 top 命令来执行此操作。
+
+```
+top -M
+```
+
+如果您知道其进程标识符（PID），还可以监视系统和进程。
+
+```
+top -p PID -M
+```
+
+## 7.监控服务器上的 GPU 性能
+
+密切关注 GPU 性能是一个好主意。
+
+如果您计划并行运行多个脚本并使用 GPU RAM，请再次关注运行 GPU 的 GPU 利用率。
+
+您可以使用 _nvidia-smi_ 命令来关注 GPU 的使用情况。我喜欢使用 _watch_ 命令来保持终端打开并清除每个新结果的屏幕。
+
+```
+watch "nvidia-smi"
+```
+
+## 8.检查服务器上仍在运行哪些脚本
+
+密切关注哪些脚本仍在运行也很重要。
+
+您可以使用 _ps_ 命令执行此操作。
+
+同样，我喜欢使用 watch 命令来保持终端打开。
+
+```
+watch "ps -ef | grep python"
+```
+
+## 9.编辑服务器上的文件
+
+我建议不要在服务器上编辑文件，除非你真的需要。
+
+不过，您可以使用 _vi_ 编辑器编辑文件。
+
+下面的示例将在 vi 中打开您的脚本。
+
+```
+vi ~/script.py
+```
+
+当然，您可以使用自己喜欢的命令行编辑器，如 emacs;如果您是 Unix 命令行的新手，本说明非常适合您。
+
+如果这是您第一次接触 vi，您可以在此处了解更多信息：
+
+*   维基百科上的 [vi](https://en.wikipedia.org/wiki/Vi)
+
+## 10.从您的工作站下载服务器中的文件
+
+我建议将模型以及任何结果和图表明确保存到新脚本和单独文件中作为脚本的一部分。
+
+您可以使用安全副本（scp）将这些文件从服务器实例下载到工作站。
+
+以下示例从您的工作站运行，并将所有 PNG 文件从您的主目录复制到您的工作站。
+
+```
+scp -i ~/.ssh/aws-keypair.pem ec2-user@54.218.86.47:~/*.png .
+```
+
+## 其他提示和技巧
+
+本节列出了在 AWS EC2 上进行大量工作时的一些其他提示。
+
+*   **一次运行多个脚本**。我建议选择具有多个 GPU 并一次运行多个脚本的硬件以充分利用该平台。
+*   **仅在工作站上编写和编辑脚本**。将 EC2 视为伪生产环境，并且只在那里复制脚本和数据才能运行。在您的工作站上进行所有开发并编写代码的小测试，以确保它能按预期工作。
+*   **将脚本输出显式保存到文件**。将结果，图形和模型保存到文件中，以后可以将这些文件下载到工作站进行分析和应用。
+*   **使用 watch 命令**。亚马逊积极地杀死没有活动的终端会话。您可以使用 watch 命令密切关注事物，该命令可以足够频繁地发送数据以保持终端打开。
+*   **从工作站**运行命令。打算在服务器上运行的上述任何命令也可以通过在命令前添加“ _ssh -_ i _〜/ .ssh /_ aws _ 来运行工作站-keypair。_ pem _ec2-user@54.218.86.47_ “并引用您要运行的命令。这对于全天检查流程非常有用。
+
+## 摘要
+
+在本教程中，您发现了我每次使用 GPU 在 AWS EC2 实例上训练大型深度学习模型时使用的 10 个命令。
+
+具体来说，你学到了：
+
+*   如何将数据复制到 EC2 实例和从 EC2 实例复制数据。
+*   如何将脚本设置为安全地运行数天，数周或数月。
+*   如何监控进程，系统和 GPU 性能。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file

docs/dl-keras/crash-course-convolutional-neural-networks.md

+# 机器学习卷积神经网络的速成课程
+
+> 原文： [https://machinelearningmastery.com/crash-course-convolutional-neural-networks/](https://machinelearningmastery.com/crash-course-convolutional-neural-networks/)
+
+卷积神经网络是一种强大的人工神经网络技术。
+
+这些网络保留了问题的空间结构，并且是为诸如手写数字识别之类的对象识别任务而开发的。它们很受欢迎，因为人们在困难的计算机视觉和自然语言处理任务上取得了最先进的成果。
+
+在这篇文章中，您将发现用于深度学习的卷积神经网络，也称为 ConvNets 或 CNN。完成本速成课程后，您将了解：
+
+*   CNN 中使用的构建块，例如卷积层和池层。
+*   如何将构建块与一个简短的工作示例结合在一起。
+*   在您自己的对象识别任务上配置 CNN 的最佳实践。
+*   适用于复杂机器学习问题的最新网络参考。
+
+让我们开始吧。
+
+![Crash Course in Convolutional Neural Networks for Machine Learning](img/28a944c830ffc6a1fd896c1df6c953e5.jpg)
+
+用于机器学习的卷积神经网络的崩溃课程
+照片由 [Bryan Ledgard](https://www.flickr.com/photos/ledgard/7772964384/) ，保留一些权利。
+
+## 卷积神经网络的案例
+
+给定灰度图像的数据集，其标准化尺寸各为 32×32 像素，传统的前馈神经网络将需要 1024 个输入权重（加上一个偏差）。
+
+这是公平的，但是像素的图像矩阵平坦化为像素值的长矢量会丢失图像中的所有空间结构。除非所有图像都完美地调整大小，否则神经网络将很难解决问题。
+
+卷积神经网络通过使用小方块输入数据学习内部特征表示来期望并保持像素之间的空间关系。在整个图像中学习和使用特征，允许图像中的对象在场景中被移位或平移，并且仍然可以被网络检测到。
+
+这就是为什么网络对于照片中的对象识别，选择具有不同方向的数字，面部，对象等非常有用的原因。
+
+总之，以下是使用卷积神经网络的一些好处：
+
+*   与完全连接的网络相比，它们使用更少的参数（权重）来学习。
+*   它们被设计为对场景中的物体位置和失真不变。
+*   它们会自动学习并概括输入域中的功能。
+
+## 卷积神经网络的构建模块
+
+卷积神经网络中有三种类型的层：
+
+1.  卷积层。
+2.  汇集图层。
+3.  完全连接的图层。
+
+### 1.卷积层
+
+卷积层由滤波器和特征映射组成。
+
+#### 过滤器
+
+过滤器是层的“神经元”。有输入权重并输出一个值。输入大小是一个固定的方块，称为补丁或感知字段。
+
+如果卷积层是输入层，则输入补丁将是像素值。如果网络架构中的更深层，则卷积层将从前一层的特征映射中获取输入。
+
+#### 功能图
+
+要素图是应用于上一层的一个过滤器的输出。
+
+在整个前一层上绘制给定的滤镜，一次移动一个像素。每个位置导致神经元的激活，并且输出被收集在特征图中。您可以看到，如果将感知字段从激活移动到激活一个像素，则该字段将与之前激活的（字段宽度 - 1）输入值重叠。
+
+#### 零填充
+
+过滤器在每次激活时从前一层的输入移动的距离称为步幅。
+
+如果前一层的大小不能被过滤器接收场的大小和步幅的大小完全整除，那么接收场可能会尝试读取输入特征图的边缘。在这种情况下，可以使用诸如零填充之类的技术来发明用于读取的感知字段的模拟输入。
+
+### 2.合并图层
+
+池化图层对先前的图层要素图进行下采样。
+
+池化层遵循一个或多个卷积层的序列，旨在合并在先前层的特征映射中学习和表达的特征。因此，池化可以被认为是压缩或概括特征表示的技术，并且通常减少模型对训练数据的过度拟合。
+
+它们也有一个感受野，通常比卷积层小得多。此外，为每次激活移动感受野的输入的步幅或数量通常等于感受野的大小以避免任何重叠。
+
+池化层通常非常简单，取输入值的平均值或最大值以创建自己的特征映射。
+
+### 3.完全连接的图层
+
+完全连接的层是正常的平坦前馈神经网络层。
+
+这些层可以具有非线性激活函数或 softmax 激活，以便输出类预测的概率。
+
+在卷积和池化层执行特征提取和合并之后，在网络末端使用完全连接的层。它们用于创建最终的非线性特征组合，并用于通过网络进行预测。
+
+## 卷积神经网络的工作实例
+
+您现在知道卷积，池和完全连接的层。让我们通过研究如何将这三个层连接在一起来使这个更具体。
+
+### 1.图像输入数据
+
+假设我们有一个灰度图像的数据集。每个图像具有 32 像素宽和 32 像素高的相同尺寸，并且像素值在 0 到 255 之间，例如。一个 32x32x1 或 1024 像素值的矩阵。
+
+图像输入数据表示为宽度*高度*通道的三维矩阵。如果我们在我们的示例中使用彩色图像，我们将有 3 个通道用于红色，绿色和蓝色像素值，例如 32x32x3。
+
+### 2.卷积层
+
+我们定义了一个卷积层，其中包含 10 个滤波器和一个 5 像素宽，5 像素高，步长为 1 的感知域。
+
+因为每个滤波器一次只能从（即“看”）5×5（25）像素输入，我们可以计算每个滤波器需要 25 + 1 个输入权重（偏置输入加 1）。
+
+在步幅宽度为 1 的情况下在输入图像数据上拖动 5×5 感受野将导致每个图像具有 28×28 个输出值或 784 个不同激活的特征图。
+
+我们有 10 个滤镜，因此将为一个图像创建 10 个不同的 28×28 特征映射或 7,840 个输出。
+
+最后，我们知道每个滤波器有 26 个输入，10 个滤波器和 28×28 输出值来计算每个滤波器，因此我们的卷积层总共有 26x10x28x28 或 203,840 个“连接”，我们想用传统的神经元来表达它网络命名法。
+
+卷积层还利用非线性传递函数作为激活的一部分，整流器激活函数是常用的默认值。
+
+### 3.池层
+
+我们定义了一个具有感知字段的池层，其宽度为 2 个输入，高度为 2 个输入。我们还使用 2 的步幅来确保没有重叠。
+
+这导致特征映射的大小是输入要素映射的一半。从 10 个不同的 28×28 特征映射作为输入到 10 个不同的 14×14 特征映射作为输出。
+
+我们将对每个感知字段使用 max（）操作，以便激活是最大输入值。
+
+### 4.完全连接的层
+
+最后，我们可以将方形特征映射平坦化为传统的平坦完全连接层。
+
+我们可以用 200 个隐藏的神经元定义完全连接的层，每个神经元具有 10x14x14 输入连接，或者每个神经元具有 1960 + 1 个权重。这一层共有 392,200 个连接和权重。
+
+我们可以使用 sigmoid 或 softmax 传递函数直接输出类值的概率。
+
+## 卷积神经网络最佳实践
+
+现在我们已经了解了卷积神经网络的构建块以及这些层如何挂在一起，我们可以回顾一下应用它们时要考虑的一些最佳实践。
+
+*   **输入感受野维度**：图像的默认值为 2D，但可以是 1D，例如句子中的单词或添加时间维度的视频的 3D。
+*   **接收字段大小**：补丁应尽可能小，但大到足以“看到”输入数据中的功能。通常在小图像上使用 3×3，在较大图像尺寸上使用 5×5 或 7×7 或更多。
+*   **步幅宽度**：使用默认步幅 1.这很容易理解，并且您不需要填充来处理从图像边缘掉落的感受野。对于较大的图像，这可以增加到 2 或更大。
+*   **滤波器数量**：滤波器是特征检测器。通常在输入层使用较少的滤波器，并且在较深层使用的滤波器越来越多。
+*   **填充**：设置为零并在读取非输入数据时调用零填充。当您不能或不想标准化输入图像大小或想要使用不能整齐划分输入图像大小的感知字段和步幅大小时，这非常有用。
+*   **汇集**：汇集是一种破坏性或泛化过程，以减少过度拟合。接收场几乎总是设置为 2×2，步幅为 2，以丢弃前一层输出的 75％激活。
+*   **数据准备**：考虑标准化输入数据，包括图像尺寸和像素值。
+*   **模式体系结构**：通常在网络体系结构中对图层进行模式化。这可能是一个，两个或一些卷积层，后面是池化层。然后可以重复该结构一次或多次。最后，完全连接的层通常仅在输出端使用，并且可以堆叠一个，两个或更多个深度。
+*   **辍学**：CNN 有一种过度拟合的习惯，即使是汇集层也是如此。应该使用 Dropout，例如在完全连接的层之间，也可以在池化之后。
+
+您是否了解使用 CNN 的更多最佳做法？
+
+请在评论中告诉我。
+
+## 进一步阅读卷积神经网络
+
+你只能在卷积神经网络上划伤表面。该领域正在快速发展，并且一直在讨论和使用新的有趣的架构和技术。
+
+如果您正在寻找对该技术的更深入理解，请查看 LeCun 等。 al 的开创性论文题为“[基于梯度的学习应用于文档识别](http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf)”[PDF]。他们将 [LeNet](http://yann.lecun.com/exdb/lenet/) 应用于手写数字识别，并仔细解释各层以及网络连接方式。
+
+网络上有很多关于 CNN 的教程和讨论。下面列出了一些选择示例。就个人而言，我发现帖子中的解释性图片只有在理解了网络如何挂起之后才有用，许多解释令人困惑，如果有疑问，请将您推迟到 LeCun 的论文中。
+
+*   [DeepLearning4J 中的卷积网络](http://deeplearning4j.org/convolutionalnets.html)
+*   [斯坦福 CS231n 课程中的卷积网络模型](https://cs231n.github.io/convolutional-networks/ https://cs231n.github.io/)
+*   [卷积网络与视觉应用](http://yann.lecun.com/exdb/publis/pdf/lecun-iscas-10.pdf) [PDF]
+*   [Michael Nielsen 开放式深度学习书](http://neuralnetworksanddeeplearning.com/chap6.html)第 6 章
+*   [VGG 卷云神经网络实用于牛津](http://www.robots.ox.ac.uk/~vgg/practicals/cnn/)
+*   [了解 Denny Britz](http://www.wildml.com/2015/11/understanding-convolutional-neural-networks-for-nlp/) 对 NLP 的卷积神经网络的理解
+
+## 摘要
+
+在这篇文章中，您发现了卷积神经网络。你了解到：
+
+*   为什么需要 CNN 来保留输入数据中的空间结构及其提供的好处。
+*   CNN 的构建块包括卷积，池化和完全连接的层。
+*   CNN 中的图层如何挂在一起。
+*   将 CNN 应用于您自己的问题时的最佳做法。
+
+你对卷积神经网络或这篇文章有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file

docs/dl-keras/custom-metrics-deep-learning-keras-python.md

+# 如何在 Python 中使用 Keras 进行深度学习的度量
+
+> 原文： [https://machinelearningmastery.com/custom-metrics-deep-learning-keras-python/](https://machinelearningmastery.com/custom-metrics-deep-learning-keras-python/)
+
+Keras 库提供了一种在训练深度学习模型时计算和报告一套标准指标的方法。
+
+除了为分类和回归问题提供标准指标外，Keras 还允许您在培训深度学习模型时定义和报告您自己的自定义指标。如果您想要跟踪在训练期间更好地捕获模型技能的性能度量，这将特别有用。
+
+在本教程中，您将了解如何使用内置指标以及如何在 Keras 中培训深度学习模型时定义和使用您自己的指标。
+
+完成本教程后，您将了解：
+
+*   Keras 指标的工作原理以及在训练模型时如何使用它们。
+*   如何使用 Keras 中的回归和分类指标与工作示例。
+*   如何使用工作示例在 Keras 中定义和使用您自己的自定义指标。
+
+让我们开始吧。
+
+![Metrics and How to Use Custom Metrics for Deep Learning with Keras in Python](img/659eb8361ecfc07bb1b54bbb96a44de5.jpg)
+
+度量标准以及如何在 Python 中使用 Keras 进行深度学习的自定义度量标准
+[Indi Samarajiva](https://www.flickr.com/photos/indi/6901400708/) 的照片，保留一些权利。
+
+## 教程概述
+
+本教程分为 4 个部分;他们是：
+
+1.  Keras Metrics
+2.  Keras 回归指标
+3.  Keras 分类指标
+4.  Keras 的自定义指标
+
+## Keras Metrics
+
+Keras 允许您列出在模型培训期间要监控的指标。
+
+您可以通过指定“ _metrics_ ”参数并为模型上的 _compile（）_ 函数提供函数名称列表（或函数名称别名）来完成此操作。
+
+例如：
+
+```
+model.compile(..., metrics=['mse'])
+```
+
+您列出的特定指标可以是 Keras 函数的名称（如 _mean_squared_error_ ）或这些函数的字符串别名（如' _mse_ '）。
+
+度量值记录在训练数据集的每个历元的末尾。如果还提供了验证数据集，则还会为验证数据集计算记录的度量标准。
+
+所有度量都以详细输出和从调用 _fit（）_ 函数返回的历史对象中报告。在这两种情况下，度量函数的名称都用作度量值的键。对于验证数据集的度量标准，将“ _val__ ”前缀添加到密钥。
+
+损失函数和明确定义的 Keras 指标都可用作训练指标。
+
+## Keras 回归指标
+
+以下是您可以在 Keras 中用于回归问题的指标列表。
+
+*   **均方误差**：mean_squared_error，MSE 或 mse
+*   **平均绝对误差**：mean_absolute_error，MAE，mae
+*   **平均绝对百分比误差**：mean_absolute_percentage_error，MAPE，mape
+*   **Cosine Proximity** ：cosine_proximity，余弦
+
+下面的示例演示了这个简单的人为回归问题的 4 个内置回归指标。
+
+```
+from numpy import array
+from keras.models import Sequential
+from keras.layers import Dense
+from matplotlib import pyplot
+# prepare sequence
+X = array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
+# create model
+model = Sequential()
+model.add(Dense(2, input_dim=1))
+model.add(Dense(1))
+model.compile(loss='mse', optimizer='adam', metrics=['mse', 'mae', 'mape', 'cosine'])
+# train model
+history = model.fit(X, X, epochs=500, batch_size=len(X), verbose=2)
+# plot metrics
+pyplot.plot(history.history['mean_squared_error'])
+pyplot.plot(history.history['mean_absolute_error'])
+pyplot.plot(history.history['mean_absolute_percentage_error'])
+pyplot.plot(history.history['cosine_proximity'])
+pyplot.show()
+```
+
+运行该示例将在每个纪元的末尾打印度量标准值。
+
+```
+...
+Epoch 96/100
+0s - loss: 1.0596e-04 - mean_squared_error: 1.0596e-04 - mean_absolute_error: 0.0088 - mean_absolute_percentage_error: 3.5611 - cosine_proximity: -1.0000e+00
+Epoch 97/100
+0s - loss: 1.0354e-04 - mean_squared_error: 1.0354e-04 - mean_absolute_error: 0.0087 - mean_absolute_percentage_error: 3.5178 - cosine_proximity: -1.0000e+00
+Epoch 98/100
+0s - loss: 1.0116e-04 - mean_squared_error: 1.0116e-04 - mean_absolute_error: 0.0086 - mean_absolute_percentage_error: 3.4738 - cosine_proximity: -1.0000e+00
+Epoch 99/100
+0s - loss: 9.8820e-05 - mean_squared_error: 9.8820e-05 - mean_absolute_error: 0.0085 - mean_absolute_percentage_error: 3.4294 - cosine_proximity: -1.0000e+00
+Epoch 100/100
+0s - loss: 9.6515e-05 - mean_squared_error: 9.6515e-05 - mean_absolute_error: 0.0084 - mean_absolute_percentage_error: 3.3847 - cosine_proximity: -1.0000e+00
+```
+
+然后创建训练时期上的 4 个度量的线图。
+
+![Line Plot of Built-in Keras Metrics for Regression](img/7be6d7bf030fac7196c7ff7c227cc0c1.jpg)
+
+用于回归的内置 Keras 度量的线图
+
+注意，使用字符串别名值指定度量[' _mse_ '，' _mae_ '，' _mape_ '，' _cosine_ ' ]并使用其扩展函数名称作为历史对象上的键值引用。
+
+我们还可以使用其扩展名称指定指标，如下所示：
+
+```
+model.compile(loss='mse', optimizer='adam', metrics=['mean_squared_error', 'mean_absolute_error', 'mean_absolute_percentage_error', 'cosine_proximity'])
+```
+
+如果将函数名称导入脚本，我们也可以直接指定它们。
+
+```
+from keras import metrics
+model.compile(loss='mse', optimizer='adam', metrics=[metrics.mean_squared_error, metrics.mean_absolute_error, metrics.mean_absolute_percentage_error, metrics.cosine_proximity])
+```
+
+您还可以将损失函数用作指标。
+
+例如，您可以使用均方对数误差（ _mean_squared_logarithmic_error_ ， _MSLE_ 或 _msle_ ）损失函数作为度量，如下所示：
+
+```
+model.compile(loss='mse', optimizer='adam', metrics=['msle'])
+```
+
+## Keras 分类指标
+
+以下是您可以在 Keras 中用于分类问题的指标列表。
+
+*   **二进制准确度**：binary_accuracy，acc
+*   **分类准确度**：categorical_accuracy，acc
+*   **稀疏分类准确度**：sparse_categorical_accuracy
+*   **前 k 个分类准确度**：top_k_categorical_accuracy（要求你指定一个 k 参数）
+*   **稀疏顶部 k 分类精度**：sparse_top_k_categorical_accuracy（需要指定 k 参数）
+
+准确性很特殊。
+
+无论您的问题是二元分类还是多类分类问题，您都可以指定' _acc_ '指标来报告准确性。
+
+下面是一个二进制分类问题的示例，其中显示了内置的精度指标。
+
+```
+from numpy import array
+from keras.models import Sequential
+from keras.layers import Dense
+from matplotlib import pyplot
+# prepare sequence
+X = array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
+y = array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
+# create model
+model = Sequential()
+model.add(Dense(2, input_dim=1))
+model.add(Dense(1, activation='sigmoid'))
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc'])
+# train model
+history = model.fit(X, y, epochs=400, batch_size=len(X), verbose=2)
+# plot metrics
+pyplot.plot(history.history['acc'])
+pyplot.show()
+```
+
+运行该示例报告每个训练时期结束时的准确性。
+
+```
+...
+Epoch 396/400
+0s - loss: 0.5934 - acc: 0.9000
+Epoch 397/400
+0s - loss: 0.5932 - acc: 0.9000
+Epoch 398/400
+0s - loss: 0.5930 - acc: 0.9000
+Epoch 399/400
+0s - loss: 0.5927 - acc: 0.9000
+Epoch 400/400
+0s - loss: 0.5925 - acc: 0.9000
+```
+
+创建精确度超过纪元的线图。
+
+![Line Plot of Built-in Keras Metrics for Classification](img/cf206a9fc0040edff578d8bec2c9cb16.jpg)
+
+用于分类的内置 Keras 度量的线图
+
+## Keras 的自定义指标
+
+您还可以定义自己的度量标准，并在调用 _compile（）_ 函数时在“ _metrics_ ”参数的函数列表中指定函数名称。
+
+我经常想要跟踪的度量是均方根误差或 RMSE。
+
+您可以通过检查现有指标的代码来了解如何编写自定义指标。
+
+例如，下面是 Keras 中 [mean_squared_error 损失函数和度量的代码。](https://github.com/fchollet/keras/blob/master/keras/losses.py)
+
+```
+def mean_squared_error(y_true, y_pred):
+    return K.mean(K.square(y_pred - y_true), axis=-1)
+```
+
+K 是 Keras 使用的后端。
+
+从该示例和损失函数和度量的其他示例，该方法是在后端使用标准数学函数来计算感兴趣的度量。
+
+例如，我们可以编写自定义指标来计算 RMSE，如下所示：
+
+```
+from keras import backend
+
+def rmse(y_true, y_pred):
+	return backend.sqrt(backend.mean(backend.square(y_pred - y_true), axis=-1))
+```
+
+您可以看到该函数与 MSE 的代码相同，并添加了 _sqrt（）_ 包装结果。
+
+我们可以在我们的回归示例中对此进行如下测试。请注意，我们只是直接列出函数名称，而不是将其作为 Keras 要解析的字符串或别名提供。
+
+```
+from numpy import array
+from keras.models import Sequential
+from keras.layers import Dense
+from matplotlib import pyplot
+from keras import backend
+
+def rmse(y_true, y_pred):
+	return backend.sqrt(backend.mean(backend.square(y_pred - y_true), axis=-1))
+
+# prepare sequence
+X = array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
+# create model
+model = Sequential()
+model.add(Dense(2, input_dim=1, activation='relu'))
+model.add(Dense(1))
+model.compile(loss='mse', optimizer='adam', metrics=[rmse])
+# train model
+history = model.fit(X, X, epochs=500, batch_size=len(X), verbose=2)
+# plot metrics
+pyplot.plot(history.history['rmse'])
+pyplot.show()
+```
+
+运行该示例在每个训练时期结束时报告自定义 RMSE 度量标准。
+
+```
+...
+Epoch 496/500
+0s - loss: 1.2992e-06 - rmse: 9.7909e-04
+Epoch 497/500
+0s - loss: 1.2681e-06 - rmse: 9.6731e-04
+Epoch 498/500
+0s - loss: 1.2377e-06 - rmse: 9.5562e-04
+Epoch 499/500
+0s - loss: 1.2079e-06 - rmse: 9.4403e-04
+Epoch 500/500
+0s - loss: 1.1788e-06 - rmse: 9.3261e-04
+```
+
+在运行结束时，将创建自定义 RMSE 度量标准的折线图。
+
+![Line Plot of Custom RMSE Keras Metric for Regression](img/029826d677dd0afb9af83862a1eabd0e.jpg)
+
+用于回归的自定义 RMSE Keras 度量的线图
+
+您的自定义度量函数必须在 Keras 内部数据结构上运行，根据所使用的后端可能会有所不同（例如 _tensorflow.python.framework.ops.Tensor_ 使用 tensorflow 时）而不是 raw yhat 和 y 值直接。
+
+出于这个原因，我建议尽可能使用后端数学函数来保持一致性和执行速度。
+
+## 进一步阅读
+
+如果您要深入了解，本节将提供有关该主题的更多资源。
+
+*   [Keras Metrics API 文档](https://keras.io/metrics/)
+*   [Keras 指标源代码](https://github.com/fchollet/keras/blob/master/keras/metrics.py)
+*   [Keras Loss API 文档](https://keras.io/losses/)
+*   [Keras 损耗源代码](https://github.com/fchollet/keras/blob/master/keras/losses.py)
+
+## 摘要
+
+在本教程中，您了解了在训练深度学习模型时如何使用 Keras 指标。
+
+具体来说，你学到了：
+
+*   Keras 指标的工作原理以及如何配置模型以在培训期间报告指标。
+*   如何使用 Keras 内置的分类和回归指标。
+*   如何在培训深度学习模型的同时有效地定义和报告自己的自定义指标。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file

docs/dl-keras/deep-learning-books.md

+# 深度学习书籍
+
+> 原文： [https://machinelearningmastery.com/deep-learning-books/](https://machinelearningmastery.com/deep-learning-books/)
+
+目前关于深度学习的书籍并不多，因为它是一个如此年轻的学习领域。
+
+虽然有一些书籍可供使用，还有一些非常有趣的书籍可以通过早期访问购买。
+
+在这篇文章中，您将发现现在可用于深度学习的书籍。
+
+让我们开始吧。
+
+![Deep Learning Books](img/9226be57337d5beb79c53462cb99daad.jpg)
+
+深度学习书籍（我希望）
+摄影： [Indi Samarajiva](https://www.flickr.com/photos/indi/4259120807/) ，保留一些权利。
+
+## 深度学习教科书
+
+有一本深入学习的教科书已经开发了几年，简称[深度学习](http://www.deeplearningbook.org/)。
+
+它由顶级深度学习科学家 [Ian Goodfellow](https://www.linkedin.com/in/ian-goodfellow-b7187213) ， [Yoshua Bengio](https://www.linkedin.com/in/yoshuabengio) 和 [Aaron Courville](https://www.linkedin.com/in/aaron-courville-53a63459) 撰写，包括该领域所有主要算法的报道甚至一些练习。
+
+我认为它将成为在该领域阅读的主要文本，主要是因为他们免费赠送（很像[统计学习要素](http://www.amazon.com/dp/0387848576?tag=inspiredalgor-20)是机器学习中必读的）。
+
+其中很多已经完成，我强烈建议阅读它以获得深度学习算法的背景理论。
+
+[![Amazon Image](img/ee355a2aacdc70cce857b65c712bb041.jpg)](http://www.amazon.com/dp/0262035618?tag=inspiredalgor-20)
+
+目前的工作目录如下：
+
+*   第一部分：应用数学和机器学习基础
+    *   线性代数
+    *   概率论与信息论
+    *   数值计算
+    *   机器学习基础
+*   第二部分：现代实用的深度网络
+    *   深度前馈网络
+    *   正则
+    *   深度模型训练的优化
+    *   卷积网络
+    *   序列建模：循环网络和递归网络
+    *   实用方法论
+    *   应用
+*   第三部分：深度学习研究
+    *   线性因子模型
+    *   自动编码
+    *   表征学习
+    *   深度学习的结构化概率模型
+    *   蒙特卡罗方法
+    *   面对分区功能
+    *   近似推论
+    *   深度生成模型
+
+## 来自 O'Reilly 的深度学习书籍
+
+目前有两本来自 O'Reilly 的书正在筹备中，我很兴奋：
+
+*   [深度学习：从业者的方法](http://www.amazon.com/dp/1491914254?tag=inspiredalgor-20)
+*   [深度学习基础：设计下一代机器智能算法](http://www.amazon.com/dp/1491925612?tag=inspiredalgor-20)
+
+### 深度学习：从业者的方法
+
+这是由 DeepLearning4J 的两个创作者编写的应用书： [Adam Gibson](https://www.linkedin.com/in/agibsonccc) 和 [Josh Patterson](https://www.linkedin.com/in/joshlpatterson) 。 [DeepLearning4J](http://deeplearning4j.org/) （或 DL4J）是 Java 应用程序的深度学习框架。
+
+本书是实用的，为 Java 开发人员和数据科学家编写，我只能假设它提供了使用 DL4J 框架的示例。
+
+这本书将于 2016 年 5 月出版，目前没有目录（我能找到）。
+
+[![Amazon Image](img/717ae728128d92f139938bd1c4c3b457.jpg)](http://www.amazon.com/dp/1491914254?tag=inspiredalgor-20)
+
+### 深度学习的基础知识：设计下一代机器智能算法
+
+这是 [Nikhil Buduma](https://www.linkedin.com/in/nikhilbuduma) 编写的另一本 Python 应用书。它涵盖了深度学习概念和示例。您可以尽早访问本书，撰写本文时共有 5 章。
+
+本书目前的工作目录如下：
+
+*   神经网络
+*   训练前馈神经网络
+*   在 TensorFlow 中实现神经网络
+*   超越梯度下降
+*   卷积神经网络：
+*   嵌入和表示学习
+*   序列分析的深度学习模型
+*   记忆增强的深度学习模型
+*   生成性深度学习模型
+*   深度强化学习
+*   走向一般无监督学习
+*   训练极深度神经网络
+
+我很高兴能得到这本书。
+
+[![Amazon Image](img/7b1c3b4ef1fa6b37c0eb0bd04b82eb26.jpg)](http://www.amazon.com/dp/1491925612?tag=inspiredalgor-20)
+
+## Packt Publishing 的深度学习
+
+数据包发布 2016 年 5 月出版了一本书，由 [Yusuke Sugomori](https://www.linkedin.com/in/yusugomori) 撰写，题为[深度学习与 Java](http://www.amazon.com/dp/1785282190?tag=inspiredalgor-20) 。它还针对 Java 开发人员和数据科学家，并将使用 DeepLearning4J 框架提供示例。
+
+似乎没有可用于本书的目录，但我相信你可以[尽早获得它](https://www.packtpub.com/big-data-and-business-intelligence/deep-learning-java)。
+
+[![Amazon Image](img/bc688ef2476b30e081706f5cb16dd727.jpg)](http://www.amazon.com/dp/1785282190?tag=inspiredalgor-20)
+
+## C ++和 CUDA C 中的深信仰网
+
+[Timothy Masters](https://www.linkedin.com/in/tim-masters-82a58739) 多年来撰写了许多关于人工神经网络的书籍。 2015 年，他用 C ++和 CUDA 写了两本关于 Deep Belief Networks 的书。
+
+这些书提供了示例，主要关注他的软件 DEEP。您可以在[网页](http://www.timothymasters.info/Deep_learning.html)上了解有关其软件的更多信息。
+
+这两本书是：
+
+[Deep Belief Nets in C++ and CUDA C: Volume 1: Restricted Boltzmann Machines and Supervised Feedforward Networks](http://www.amazon.com/dp/1507751478?tag=inspiredalgor-20)
+
+本书的目录是：
+
+*   监督前馈网络
+*   受限制的玻尔兹曼机器
+*   贪心训练
+*   DEEP 操作手册
+
+[Deep Belief Nets in C++ and CUDA C: Volume II: Autoencoding in the Complex Domain](http://www.amazon.com/dp/1514365995?tag=inspiredalgor-20)
+
+本书的目录是：
+
+*   嵌入式类标签
+*   信号预处理
+*   图像预处理
+*   Autoencoding
+*   DEEP 操作手册
+
+## 人工智能
+
+[Jeff Heaton](https://www.linkedin.com/in/jeffheaton) 是一本关于人工智能的三本书系列的研究员和作者：
+
+*   [人类智能，第 1 卷：基本算法](http://www.amazon.com/dp/1493682229?tag=inspiredalgor-20)
+*   [人类智能，第 2 卷：自然启发算法](http://www.amazon.com/dp/1499720572?tag=inspiredalgor-20)
+*   [人工智能，第 3 卷：深度学习和神经网络](http://www.amazon.com/dp/1505714346?tag=inspiredalgor-20)
+
+该系列的第三本书涵盖了人工神经网络，并有一些关于深度学习技术的章节。
+
+[![Amazon Image](img/f2b08c4eb571d1dc15ee278519741cbe.jpg)](http://www.amazon.com/dp/1505714346?tag=inspiredalgor-20)
+
+目录如下：
+
+*   神经网络基础知识
+*   自组织地图
+*   Hopfield 和 Boltzmann 机器
+*   前馈神经网络
+*   培训和评估
+*   反向传播训练
+*   其他传播培训
+*   NEAT，CPNN 和 HyperNEAT
+*   深度学习
+*   卷积神经网络
+*   修剪和模型选择
+*   辍学和正规化
+*   时间序列和循环网络
+*   构建神经网络
+*   可视化
+*   用神经网络建模
+
+一般来说，杰夫是一个很好的沟通者，他的书得到了社区的关注，因为他[在创作过程中使用了 KickStarter](https://www.kickstarter.com/projects/jeffheaton/artificial-intelligence-for-humans-vol-3-deep-lear) 。如果你正在寻找神经网络的介绍并发现深度学习适合的地方，他的系列的第三部分可能是一个很好的阅读。
+
+## R 的深度学习
+
+N. D. Lewis 有一系列关于统计学和机器学习的书籍，包括有关神经网络的书籍。 2016 年初，他发表了一本关于深度学习的书，名为：[深度学习轻松学习 R：数据科学的温和介绍。](http://www.amazon.com/dp/B01AEXMX34?tag=inspiredalgor-20) 。
+
+[![Amazon Image](img/a73a28eb8d953d02fd5d02416b785c78.jpg)](http://www.amazon.com/dp/B01AEXMX34?tag=inspiredalgor-20)
+
+目录如下：
+
+*   深度神经网络
+*   Elman 神经网络
+*   Jordan 神经网络
+*   自动编码器的秘密
+*   坚果壳中的堆叠自动编码器
+*   受限制的玻尔兹曼机器
+*   深信仰网络
+
+## 更新：更多书籍
+
+本节列出了撰写本文后已发布（或预计将发布）的附加书籍。
+
+*   [神经网络与深度学习](http://neuralnetworksanddeeplearning.com/index.html)
+*   [Grokking 深度学习](http://www.amazon.com/dp/1617293709?tag=inspiredalgor-20)
+*   [使用 TensorFlow 进行机器学习](http://www.amazon.com/dp/1617293873?tag=inspiredalgor-20)
+*   [TensorFlow 机器学习手册](http://www.amazon.com/dp/1786462168?tag=inspiredalgor-20)
+*   [TensorFlow 入门](http://www.amazon.com/dp/B01H1JD6JO?tag=inspiredalgor-20)
+*   [Scikit-Learn 和 TensorFlow 实践机器学习：构建智能系统的概念，工具和技术](http://www.amazon.com/dp/1491962291?tag=inspiredalgor-20)
+
+## 摘要
+
+在这篇文章中，您将发现现在可用于深度学习的书籍。
+
+您是否购买或阅读过其中一本书？发表评论，让我知道你对它的看法。
+
+还有更多关于深度学习的书籍，你知道它们已经或已经在这里吗？请在评论中告诉我。
\ No newline at end of file

docs/dl-keras/deep-learning-for-developers.md

+# 你所知道的深度学习是一种谎言
+
+> 原文： [https://machinelearningmastery.com/deep-learning-for-developers/](https://machinelearningmastery.com/deep-learning-for-developers/)
+
+开始深度学习是一项艰巨的任务。
+
+这是一场斗争，因为学者 _ 为 _ 学者教授深度学习 _。_
+
+**如果您是开发人员（或从业者），那就不同了。**
+**你想要的结果。**
+
+从业者学习新技术的方式是开发能够快速实现价值的原型。
+
+这是一种自上而下的学习方法，但这并不是深度学习的方式。
+
+还有另一种方式。一种适用于像你这样的自上而下的从业者的方式。
+
+在这篇文章中，您将发现另一种方式。
+
+_（我教这种方法并帮助超过 1,145 名开发人员
+开始深入学习 python，[点击了解更多](http://machinelearningmastery.com/deep-learning-with-python/)_ ）
+
+您会相信通过应用深度学习取得成功是可能的。我希望它能激励你迈出实现这一目标的第一步。
+
+让我们潜入。
+
+![What You Think You Know About Deep Learning Is A Lie](img/a88ebb815922dc1277b935534416294a.jpg)
+
+你认为你所知道的深度学习是一种谎言
+照片由 [Simon Matzinger](https://www.flickr.com/photos/simonmatzinger/14598379523/) 拍摄，保留一些权利。
+
+## 你想在深度学习中开始......
+但你却与众不同
+
+你没有硕士或博士学位。在高级数学。
+
+你不是机器学习专家。
+
+你是一个有兴趣并且渴望开始使用[深度学习](http://machinelearningmastery.com/what-is-deep-learning/)的专业人士或学生。
+
+### 也许你是开发人员
+
+*   您想知道如何应用深度学习来解决复杂问题。
+*   您需要深度学习技能来改善您的工作前景。
+*   您希望利用深度学习作为进入数据科学家（或类似）职位的杠杆。
+
+### 也许你是一名数据科学家
+
+*   您希望在未来的项目中使用深度学习。
+*   您有一个棘手的问题，您认为深度学习可以提供帮助。
+*   您需要深度学习技能才能保持相关性并掌控您的领域。
+
+### 也许你是学生
+
+*   您需要深度学习技能来改善您的工作前景。
+*   你有一个有趣的问题，你认为深度学习是一个很好的选择。
+*   你想要发现为什么深度学习如此受欢迎。
+
+**其中一个原因适合你吗？**
+请在评论中告诉我，我很想听听你的理由吗？
+
+**你有进入深度学习的不同理由吗？**
+请在评论中告诉我，我会给你个人建议。
+
+进入深度学习领域的原因是多种多样的。
+
+无论如何，你和其他人一样对待你。像一个学者。
+
+![Deep Learning Is NOT Just For The Academics](img/a6423d666cd09de47bcf0660509102c6.jpg)
+
+深度学习不仅仅适用于学者
+[Breyten Ernsting](https://www.flickr.com/photos/breyten/6424263261/) 的照片，保留一些权利。
+
+## 深度学习是为了学者......谎言
+
+深度学习是一个学术研究领域。
+
+这种方式已经有很长一段时间了。该领域曾用于研究小型人工神经网络。现在，重点是更大的网络和更奇特的网络架构。该领域的突破仍然来自学术界。这个领域很年轻，这是可以预期的。
+
+这意味着深度学习的大部分信息都是由学者撰写的。它是为其他学者编写的，如研究人员，硕士和博士。学生们。
+
+它不是像我们这样为开发人员编写的。
+
+这就是你看到如下错误建议的原因：
+
+> 你需要博士学位才​​能深入学习。
+
+或者评论如下：
+
+> 在进入深度学习之前，您需要 3 年的高级数学。
+
+垃圾！
+
+这就是为什么开始深度学习是一场如此艰难的斗争。这是一个挑战，开发人员认为他们只能通过回到学校，债务和投资 3 至 7 年的生活来解决。
+
+疯狂！
+
+您可以在几分钟内完成深度学习教程。您可以开始构建可用于展示您在该领域不断增长的技能的投资组合。你可以从今天开始。
+
+## 编程仅适用于计算机科学家（不是）
+
+编程过去很难和理论上的。
+
+在有计算机之前，你需要了解很多数学知识才能理解编程。
+
+[可计算性](https://en.wikipedia.org/wiki/Computability)和[完备性​​定理](https://en.wikipedia.org/wiki/G%C3%B6del%27s_completeness_theorem)之类的东西。
+
+在编程的早期阶段，您必须定义自己的数据结构和基本算法。这是在定义算法和数据结构的所有低成果之前。这需要很好地理解离散数学。
+
+像[复杂性理论](https://en.wikipedia.org/wiki/Computational_complexity_theory)这样的东西。
+
+这些理论主题可以帮助您成为更好的程序员和工程师。他们仍然在计算机科学课程中教授。
+
+但是你和我都知道你不需要他们开始编程。如果您在大多数编程工作中工作，您甚至不需要这些主题。
+
+**您调用排序例程，**
+**您没有从第一原则派生出新的排序操作。**
+
+我们可以将这个类比扩展到深度学习吗？
+
+您是否需要从第一原理推导出反向传播方程并从头开始实现？相反，我们可以在深度学习 API 上调用 model.fit（）。
+
+## 等等......顶级工程师怎么样？
+
+是的，顶级工程师可以推导出一种新的算法。
+
+事实上，他们经常被雇用来做这件事。这是他们的工作。他们可以做简单的事情和更难的事情。他们可以调用 sort 例程并为业务数据派生一个新的排序方法，该方法太大而无法容纳到内存中。
+
+我的观点是，这些功能不必先出现，它们可以在以后出现。
+
+自顶向下。而不是自下而上。
+
+这是关键。
+
+就像现实世界中的实际编程一样。
+
+## 自上而下的程序员（... _ 获得结果 _）
+
+编程很有趣。
+
+你学习这个功能。你学习了那个 API。您将自己的程序拼接在一起，发现您可以用自己的想法解决问题。
+
+你很早就开始工作，只是随着时间的推移变得更有成效。您可以深入研究理论，以解决更具挑战性的问题。由你决定。
+
+尽早提高工作效率有两个原因：
+
+1.  它让你保持动力，让你保持参与。
+2.  它可以让您尽早交付价值，从而提供动力。
+
+**停下来太容易了。**
+**放弃太容易了。**
+
+这是超级大国。知道你可以写一个程序来解决一个特定的问题。然后有信心实际实施和部署。
+
+首先，代码和设计将变得糟糕。很难维护。不适合长期使用。但是代码随着经验，导师和不断学习而变得更好。
+
+这就是大多数 IT 运营的方式。自顶向下。不是自下而上的。
+
+您没有参加计算机语言理论的大学课程来学习 Ruby on Rails，以用于您的下一个 Web 开发项目。您通过一些教程，犯了一些错误并熟悉平台。
+
+重复下一个框架，下一个库。一次又一次。
+
+重复深度学习。
+
+## 深度学习不仅仅适用于学者
+
+您可以从下至上学习深度学习。
+
+这可能需要很多年和更高的学位，但你会对深度学习技术的理论有很多了解。
+
+即使经过所有这些努力，您可能会或可能不知道如何在实践中将它们应用于实际数据。他们通常不会在大学教授实践或职业技能。
+
+学术教科书，视频课程和期刊论文是一个很好的资源。他们是思想的金矿。在开始深度学习时，它们不是开始的地方。
+
+![Deep Learning Is For Academics, The Lie](img/99ef23d86f8af9e053b6b74255fdab0f.jpg)
+
+深度学习是为学者，谎言
+照片由 [Quinn Dombrowski](https://www.flickr.com/photos/quinndombrowski/7622139752/) ，保留一些权利。
+
+## 专注于通过深度学习提供价值
+
+深入学习商业和其他研究领域的价值在于可靠的预测。
+
+了解如何使用深度学习来模拟问题。
+
+开发（或窃取）用于处理预测建模问题的系统过程。然后再次应用它，一次又一次，直到你真正擅长提供这个价值。
+
+**善于应用深度学习。**
+**我们都喜欢我们擅长的东西。**
+
+如果你能做得很好而且可靠，那么你将拥有市场所需的宝贵技能。
+
+您会发现自己正在深入研究解析希腊字母和发送电子邮件或致电作者的学术论文。所有这些都可以提取您可以用来在下一个项目中获得更好模型性能的金块。
+
+## 是时候通过深度学习获得成功
+
+现在，希望你相信你可以开始并善于应用深度学习。
+
+现在是采取行动的时候了。现在是开始深度学习的时候了。
+
+### 1.选择一个框架
+
+我推荐 [Keras 平台](http://machinelearningmastery.com/introduction-python-deep-learning-library-keras/)。它支持 Python。这意味着您可以利用 scikit-learn 和整个 SciPy 生态系统进行深度学习项目。
+
+这个很重要。
+
+您基本上可以免费获得数据准备，模型评估和超参数优化。
+
+Keras 还提供了从业者友好的 API（即简单直观）。它包含了 [Theano](http://machinelearningmastery.com/introduction-python-deep-learning-library-theano/) 和 [TensorFlow](http://machinelearningmastery.com/introduction-python-deep-learning-library-tensorflow/) 库的功效（以及不必要的复杂性）。它为您提供了前沿框架的速度和效率，而无需使用数十或数百行代码来完成某些工作。
+
+我在 Keras 上有一些[教程，以及一个免费的 14 天迷你课程，请参阅：](http://machinelearningmastery.com/category/deep-learning)
+
+*   [在 Python 迷你课程中应用深度学习](http://machinelearningmastery.com/applied-deep-learning-in-python-mini-course/)
+
+### 2.选择一个流程
+
+保持简单，但选择一个强大的骨架，您可以添加和定制您喜欢的技术和问题类型。
+
+我喜欢在预测建模项目中使用的一组很好的一般步骤是：
+
+1.  **定义问题**：您试图解决的问题以及解决问题所需的数据和框架。
+2.  **准备数据**：转换为应用于数据的内容，以创建最能将预测问题的结构暴露给模型的视图。
+3.  **评估算法**：用于建模问题的技术，以及从不良解决方案中过滤好的指标。
+4.  **改进结果**：使用什么参数调整甚至整体方法来充分利用正在工作的东西。
+5.  **当前结果**：您取得的成果，经验教训以及您可以直接使用的已保存模型或预测集。
+
+有关处理预测建模问题的过程的更多信息，请参阅：
+
+*   [处理机器学习问题的过程](http://machinelearningmastery.com/process-for-working-through-machine-learning-problems/)
+
+### 3.选择一个问题
+
+你需要练习。很多练习。
+
+如果您对使用图像数据进行预测建模感兴趣，请查找图像数据的所有标准机器学习问题并按照它们的方式进行操作。
+
+文字数据？视频数据？使用相同的方法。
+
+**了解如何使用您的流程获得结果。**
+**然后学习如何获得好成绩。
+然后是世界级的结果。**
+
+标准机器学习数据集的好处是你有一个基准分数来比较你的结果。
+
+还不确定你的偏好吗？从 UCI 机器学习库的标准数据集开始使用多层感知器（[这是一个教程](http://machinelearningmastery.com/tutorial-first-neural-network-python-keras/)）。然后在标准物体识别问题上尝试卷积神经网络（[这里是一个教程](http://machinelearningmastery.com/object-recognition-convolutional-neural-networks-keras-deep-learning-library/)）。在简单的时间序列问题上转向 Recurrent Neural Networks（[这是一个教程](http://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/)）。
+
+后来，毕业于像 Kaggle 那样的机器学习竞赛中使用的更复杂的问题。进一步研究定义自己的问题并从创意共享中收集数据。
+
+您的目标是开发已完成项目的组合。
+
+当您处理大型且更具挑战性的项目时，此组合将成为您可以利用的资源。它也可以是一种资源，您可以通过深入学习和提供价值的能力来展示您不断增长的技能。
+
+有关开发机器学习组合的更多信息，请参阅帖子：
+
+*   [建立机器学习组合](http://machinelearningmastery.com/build-a-machine-learning-portfolio/)
+
+## 摘要
+
+你发现你所知道的深度学习是“_ 对学术界的深刻学习 _”。不是“_ 深入学习开发人员 _”。
+
+您现在知道，有一整套图书馆和教程专为您和像您这样的开发人员而设计。
+
+您发现了一个简单的 3 步流程，您可以将其用作开发人员深度学习的成功，总结如下：
+
+1.  选择一个框架（如 Keras）。
+2.  选择一个流程（如上面列出的流程）。
+3.  选择一个问题（然后开发一个投资组合）。
+
+**这改变了你对深度学习的看法吗？**
+发表评论让我知道。
+
+您可能希望阅读的更多深度学习帖子包括：
+
+*   [用 Keras 逐步开发 Python 中的第一个神经网络](http://machinelearningmastery.com/tutorial-first-neural-network-python-keras/)
+*   [8 深度学习的鼓舞人心的应用](http://machinelearningmastery.com/inspirational-applications-deep-learning/)
+*   [多层感知器神经网络崩溃课程](http://machinelearningmastery.com/crash-course-recurrent-neural-networks-deep-learning/)
\ No newline at end of file

docs/dl-keras/develop-evaluate-large-deep-learning-models-keras-amazon-web-services.md

+# 如何设置 Amazon AWS EC2 GPU 以培训 Keras 深度学习模型（分步）
+
+> 原文： [https://machinelearningmastery.com/develop-evaluate-large-deep-learning-models-keras-amazon-web-services/](https://machinelearningmastery.com/develop-evaluate-large-deep-learning-models-keras-amazon-web-services/)
+
+Keras 是一个 Python 深度学习库，可以轻松方便地访问功能强大的数据库 Theano 和 TensorFlow。
+
+大型深度学习模型需要大量的计算时间才能运行。您可以在 CPU 上运行它们，但可能需要数小时或数天才能获得结果。如果您可以访问桌面上的 GPU，则可以大大加快深度学习模型的培训时间。
+
+在本文中，您将了解如何使用 Amazon Web Service（AWS）基础结构访问 GPU 以加速深度学习模型的培训。每小时不到 1 美元，通常便宜很多，您可以使用工作站或笔记本电脑上的这项服务。
+
+让我们开始吧。
+
+*   **2016 年 10 月更新**：更新了 Keras 1.1.0 的示例。
+*   **2017 年 3 月更新**：更新后使用新的 AMI，Keras 2.0.2 和 TensorFlow 1.0。
+*   **2002 年 2 月更新**：更新后使用新的“深度学习 AMI”并建议使用更快的“p3.2xlarge”实例类型。
+
+![Amazon Web Services](img/756b3d773ebebb0faba54b7006da3120.jpg)
+
+亚马逊网络服务
+摄影： [Andrew Mager](https://www.flickr.com/photos/mager/3183272133/) ，保留一些权利
+
+## 教程概述
+
+这个过程非常简单，因为大部分工作已经为我们完成了。
+
+以下是该过程的概述。
+
+1.  设置您的 AWS 账户。
+2.  启动您的 AWS 实例。
+3.  登录并运行您的代码。
+4.  关闭您的 AWS 实例。
+
+**注意，在 Amazon** 上使用虚拟服务器实例需要花钱。临时模型开发的成本很低（例如每小时不到一美元），这就是为什么它如此吸引人，但它不是免费的。
+
+服务器实例运行 Linux。虽然不需要知道如何导航 Linux 或类似 unix 的环境，但这是可取的。我们只是运行我们的 Python 脚本，因此不需要高级技能。
+
+## 1.设置您的 AWS 账户
+
+您需要在 Amazon Web Services 上拥有一个帐户。
+
+*   1.您可以通过[亚马逊网络服务门户](https://aws.amazon.com/)创建一个帐户，然后单击“登录到控制台”。从那里，您可以使用现有的亚马逊帐户登录或创建新帐户。
+
+![AWS Sign-in Button](img/827f7a153d004f35332b92fb724b1b92.jpg)
+
+AWS 登录按钮
+
+*   2.您需要提供您的详细信息以及亚马逊可以收取的有效信用卡。如果您已经是亚马逊客户并且已将您的信用卡存档，那么此过程会快得多。
+
+![AWS Sign-In Form](img/5bb2f88423069cc64dda533c02cb29d3.jpg)
+
+AWS 登录表单
+
+拥有帐户后，您可以登录 Amazon Web Services 控制台。
+
+您将看到一系列可以访问的不同服务。
+
+## 2.启动您的 AWS 实例
+
+现在您已拥有 AWS 账户，您想要启动可以运行 Keras 的 EC2 虚拟服务器实例。
+
+启动实例就像选择要加载和启动虚拟服务器的映像一样简单。值得庆幸的是，已经有一个可用的图像几乎所有我们需要它被称为[深度学习 AMI（亚马逊 Linux）](https://aws.amazon.com/marketplace/pp/B077GF11NF)，并由亚马逊创建并维护。我们将它作为一个实例启动。
+
+*   1.如果您尚未登录 [AWS 控制台](https://console.aws.amazon.com/console/home)，请登录。
+
+![AWS Console](img/3aa11a0f106d6a9d26e5ff0f0928e835.jpg)
+
+AWS 控制台
+
+*   2.单击 EC2 以启动新的虚拟服务器。
+*   3.从右上角的下拉列表中选择“US West Oregon”。这很重要，否则您将无法找到我们计划使用的图像。
+*   4.单击“启动实例”按钮。
+*   5.单击“社区 AMI”。 AMI 是亚马逊机器映像。它是服务器的冻结实例，您可以在新虚拟服务器上进行选择和实例化。
+
+![Community AMIs](img/55f115adb23074958d7ba0cc5e9d3806.jpg)
+
+社区 AMI
+
+*   6.在“搜索社区 AMI”搜索框中输入“**深度学习 AMI** ”，然后按 Enter 键。
+
+![Deep Learning AMI](img/945bc23e6b2a065508c17f058c6a7992.jpg)
+
+深度学习 AMI
+
+*   7.单击“选择”以在搜索结果中选择 AMI。
+*   8.现在您需要选择运行映像的硬件。向下滚动并选择“ **p3.2xlarge** ”硬件（我以前推荐 g2 或 [g3 实例](https://aws.amazon.com/ec2/instance-types/g3/)和 [p2 实例](https://aws.amazon.com/ec2/instance-types/p2/)，但 [p3 实例](https://aws.amazon.com/ec2/instance-types/p3/)更新更快。这包括一个 Tesla V100 GPU，我们可以用它来显着提高我们模型的训练速度。它还包括 8 个 CPU 内核，61GB 内存和 16GB GPU 内存。注意：使用此实例将花费约 3 美元/小时。
+
+![p3.2xlarge EC2 Instance](img/a56adc566715868c4b9c5b56941c5a53.jpg)
+
+p3.2xlarge EC2 实例
+
+*   9.单击“查看并启动”以完成服务器实例的配置。
+*   10.单击“启动”按钮。
+*   11.选择您的密钥对。
+    *   如果您之前使用过 EC2，则选择“选择现有密钥对”并从列表中选择密钥对。然后检查“我”确认......“。
+    *   如果您没有密钥对，请选择“创建新密钥对”选项并输入“密钥对名称”，例如 keras-keypair。单击“下载密钥对”按钮。
+
+![Select Your Key Pair](img/01f3d67c5792b6695bbc5759d32f9ad4.jpg)
+
+选择您的密钥对
+
+*   12.打开终端并将目录更改为您下载密钥对的位置。
+*   13.如果尚未执行此操作，请限制密钥对文件的访问权限。这需要作为对服务器的 SSH 访问的一部分。例如：
+
+```
+cd Downloads
+chmod 600 keras-aws-keypair.pem
+```
+
+*   14.单击“启动实例”。如果这是您第一次使用 AWS，亚马逊可能必须验证您的请求，这可能需要长达 2 个小时（通常只需几分钟）。
+*   15.单击“查看实例”以查看实例的状态。
+
+![Deep Learning AMI Status](img/bf480c56be39c466c39ef7c081ee2e4f.jpg)
+
+深度学习 AMI 状态
+
+您的服务器现在正在运行，可以登录。
+
+## 3.登录，配置和运行
+
+现在您已经启动了服务器实例，现在可以登录并开始使用它了。
+
+*   1.如果您还没有，请单击 Amazon EC2 控制台中的“查看实例”。
+*   2.将“公共 IP”（在“描述”中的屏幕底部）复制到剪贴板。在此示例中，我的 IP 地址是 54.186.97.77。 **请勿使用此 IP 地址**，您的 IP 地址会有所不同。
+*   3.打开终端并将目录更改为您下载密钥对的位置。使用 SSH 登录您的服务器，例如：
+
+```
+ssh -i keras-aws-keypair.pem ec2-user@54.186.97.77
+```
+
+*   4.出现提示时，键入“ _yes_ ”并按 Enter 键。
+
+您现在已登录到您的服务器。
+
+![Terminal Login to Deep Learning AMI](img/e2e01130306ad5b55ef570cb81af36ab.jpg)
+
+终端登录深度学习 AMI
+
+该实例将询问您希望使用的 Python 环境。我建议使用：
+
+*   **TensorFlow（+ Keras2）与 Python3（CUDA 9.0 和英特尔 MKL-DNN）**
+
+您可以键入以下内容来激活此虚拟环境：
+
+```
+source activate tensorflow_p36
+```
+
+这只需要一分钟。
+
+您现在可以开始训练深度学习神经网络模型了。
+
+想要尝试新实例，请参阅本教程：
+
+*   [用 Keras 逐步开发 Python 中的第一个神经网络](http://machinelearningmastery.com/tutorial-first-neural-network-python-keras/)
+
+## 4.关闭您的 AWS 实例
+
+完成工作后，您必须关闭实例。
+
+请记住，您需要按照使用该实例的时间收费。它很便宜，但如果你不使用它，你不想留下实例。
+
+*   1.在终端注销您的实例，例如您可以输入：
+
+```
+exit
+```
+
+*   2.使用 Web 浏览器登录 AWS 账户。
+*   3.单击 EC2。
+*   4.单击左侧菜单中的“Instances”。
+
+![Review Your List of Running Instances](img/1d019ff799ebac1cbdf3559f9ffaba1e.jpg)
+
+查看运行实例列表
+
+*   5.从列表中选择正在运行的实例（如果您只有一个正在运行的实例，则可能已选中该实例）。
+
+![Select Your Running AWS Instance](img/b30037d88d3bce9c780e5eae957be293.jpg)
+
+选择您正在运行的 AWS 实例
+
+*   6.单击“操作”按钮并选择“实例状态”，然后选择“终止”。确认您要终止正在运行的实例。
+
+实例可能需要几秒钟才能关闭并从实例列表中删除。
+
+## 在 AWS 上使用 Keras 的提示和技巧
+
+以下是在 AWS 实例上充分利用 Keras 的一些提示和技巧。
+
+*   **设计一套预先运行的实验**。实验可能需要很长时间才能运行，而您需要为使用时间付费。花时间设计一批在 AWS 上运行的实验。将每个文件放在一个单独的文件中，并依次从另一个脚本调用它们。这将允许您从一个长期回答多个问题，也许是一夜之间。
+*   **运行脚本作为后台进程**。这样您就可以在实验运行时关闭终端并关闭计算机。
+
+您可以轻松地执行以下操作：
+
+```
+nohup /path/to/script >/path/to/script.log 2>&1 < /dev/null &
+```
+
+然后，您可以稍后在 script.log 文件中检查状态和结果。 [了解有关 nohup 的更多信息](https://en.wikipedia.org/wiki/Nohup)。
+
+*   **在实验结束时始终关闭您的实例**。您不希望对非常大的 AWS 账单感到惊讶。
+*   **尝试使用更便宜但不太可靠的选项**的现场实例。亚马逊以更便宜的价格在硬件上出售未使用的时间，但代价可能是您的实例在任何时候关闭。如果您正在学习或实验并不重要，这可能是您的理想选择。您可以从 EC2 Web 控制台左侧菜单中的“竞价型实例”选项访问竞价型实例。
+
+有关在 AWS 上使用的命令行重新复制的更多帮助，请参阅帖子：
+
+*   [10 个亚马逊网络服务深度学习命令行方案](https://machinelearningmastery.com/command-line-recipes-deep-learning-amazon-web-services/)
+
+## 更多有关 AWS 深度学习的资源
+
+以下是有关 AWS 的更多信息以及在云中构建深度学习的资源列表。
+
+*   [亚马逊弹性计算云（EC2）](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html)的介绍如果您是所有这些的新手
+*   [亚马逊机器图像（AMI）简介](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html)
+*   [AMI 市场上的深度学习 AMI（亚马逊 Linux）。](https://aws.amazon.com/marketplace/pp/B077GF11NF)
+*   [P3 EC2 实例](https://aws.amazon.com/ec2/instance-types/p3/)
+
+## 摘要
+
+在这篇文章中，您了解了如何使用 Amazon Web Service 上的 GPU 在 Keras 中开发和评估您的大型深度学习模型。你了解到：
+
+*   使用 Elastic Compute Cloud 的 Amazon Web Services 提供了一种在 GPU 硬件上运行大型深度学习模型的经济实惠方式。
+*   如何为深度学习实验设置和启动 EC2 服务器。
+*   如何更新服务器上的 Keras 版本并确认系统正常运行。
+*   如何在 AWS 实例上批量运行 Keras 实验作为后台任务。
+
+您对在 AWS 或此帖子上运行模型有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file

docs/dl-keras/difference-between-a-batch-and-an-epoch.md

+# 神经网络中批处理和历元之间的区别是什么？
+
+> 原文： [https://machinelearningmastery.com/difference-between-a-batch-and-an-epoch/](https://machinelearningmastery.com/difference-between-a-batch-and-an-epoch/)
+
+随机梯度下降是一种学习算法，具有许多超参数。
+
+两个经常让初学者感到困惑的超参数是批量大小和时代数。它们都是整数值，似乎做同样的事情。
+
+在这篇文章中，您将发现随机梯度下降中批次和时期之间的差异。
+
+阅读这篇文章后，你会知道：
+
+*   随机梯度下降是一种迭代学习算法，它使用训练数据集来更新模型。
+*   批量大小是梯度下降的超参数，在模型的内部参数更新之前控制训练样本的数量。
+*   时期数是梯度下降的超参数，其控制通过训练数据集的完整遍数。
+
+让我们开始吧。
+
+![What is the Difference Between a Batch and an Epoch in a Neural Network?](img/1f3275bfb5407176028269720f3a11da.jpg)
+
+神经网络中批处理和历元之间的区别是什么？
+[Graham Cook](https://www.flickr.com/photos/grazza123/9754438586/) 的照片，保留一些权利。
+
+## 概观
+
+这篇文章分为五个部分;他们是：
+
+1.  随机梯度下降
+2.  什么是样品？
+3.  什么是批次？
+4.  什么是大纪元？
+5.  Batch 和 Epoch 有什么区别？
+
+## 随机梯度下降
+
+随机梯度下降（Stochastic Gradient Descent，简称 SGD）是一种用于训练机器学习算法的优化算法，最值得注意的是深度学习中使用的人工神经网络。
+
+该算法的工作是找到一组内部模型参数，这些参数在某些性能测量中表现良好，例如对数损失或均方误差。
+
+优化是一种搜索过程，您可以将此搜索视为学习。优化算法称为“_ 梯度下降 _”，其中“_ 梯度 _”是指误差梯度或误差斜率的计算，“下降”是指沿着该斜率向下移动朝着某种最低程度的错误。
+
+该算法是迭代的。这意味着搜索过程发生在多个不连续的步骤上，每个步骤都希望略微改进模型参数。
+
+每个步骤都涉及将模型与当前内部参数集一起使用，以对某些样本进行预测，将预测与实际预期结果进行比较，计算误差，并使用误差更新内部模型参数。
+
+该更新过程对于不同的算法是不同的，但是在人工神经网络的情况下，使用[反向传播](https://en.wikipedia.org/wiki/Backpropagation)更新算法。
+
+在我们深入研究批次和时代之前，让我们来看看样本的含义。
+
+了解有关渐变下降的更多信息：
+
+*   [机器学习的梯度下降](https://machinelearningmastery.com/gradient-descent-for-machine-learning/)
+
+## 什么是样品？
+
+样本是单行数据。
+
+它包含输入算法的输入和用于与预测进行比较并计算错误的输出。
+
+训练数据集由许多行数据组成，例如，很多样品。样本也可以称为实例，观察，输入向量或特征向量。
+
+现在我们知道样本是什么，让我们定义一个批处理。
+
+## 什么是批次？
+
+批量大小是一个超参数，用于定义在更新内部模型参数之前要处理的样本数。
+
+将批处理视为对一个或多个样本进行迭代并进行预测的循环。在批处理结束时，将预测与预期输出变量进行比较，并计算误差。从该错误中，更新算法用于改进模型，例如，沿误差梯度向下移动。
+
+训练数据集可以分为一个或多个批次。
+
+当所有训练样本用于创建一个批次时，学习算法称为批量梯度下降。当批量是一个样本的大小时，学习算法称为随机梯度下降。当批量大小超过一个样本且小于训练数据集的大小时，学习算法称为小批量梯度下降。
+
+*   **批量梯度下降**。批量大小=训练集的大小
+*   **随机梯度下降**。批量大小= 1
+*   **Mini-Batch Gradient Descent** 。 1＆lt;批量大小＆lt;训练集的大小
+
+在小批量梯度下降的情况下，流行的批量大小包括 32,64 和 128 个样本。您可能会在文献和教程中看到这些值在模型中使用。
+
+**如果数据集不能按批量大小均匀分配怎么办？**
+
+在训练模型时，这可能并且确实经常发生。它只是意味着最终批次的样品数量少于其他批次。
+
+或者，您可以从数据集中删除一些样本或更改批处理大小，以便数据集中的样本数按批次大小均匀划分。
+
+有关这些梯度下降变化之间差异的更多信息，请参阅帖子：
+
+*   [微量批量梯度下降的简要介绍以及如何配置批量大小](https://machinelearningmastery.com/gentle-introduction-mini-batch-gradient-descent-configure-batch-size/)
+
+批处理涉及使用样本更新模型;接下来，让我们来看一个时代。
+
+## 什么是大纪元？
+
+时期数是一个超参数，它定义了学习算法在整个训练数据集中的工作次数。
+
+一个时期意味着训练数据集中的每个样本都有机会更新内部模型参数。时期由一个或多个批次组成。例如，如上所述，具有一批的时期称为批量梯度下降学习算法。
+
+您可以考虑在每个循环在训练数据集上进行的时期数量的 for 循环。在这个 for 循环中是另一个嵌套的 for 循环，它遍历每批样本，其中一个批次具有指定的“批量大小”样本数。
+
+历元的数量传统上很大，通常是数百或数千，允许学习算法运行直到模型的误差被充分最小化。您可能会看到文献和教程设置为 10,100,500,1000 和更大的时期数量的示例。
+
+通常创建线图，其显示沿 x 轴的时期作为时间以及模型在 y 轴上的误差或技能。这些图有时称为学习曲线。这些图可以帮助诊断模型是否已经过度学习，学习不足或是否适合训练数据集。
+
+有关使用 LSTM 网络学习曲线的诊断信息，请参阅帖子：
+
+*   [如何诊断 LSTM 模型的过度拟合和欠拟合](https://machinelearningmastery.com/diagnose-overfitting-underfitting-lstm-models/)
+
+如果仍然不清楚，让我们看看批次和时代之间的差异。
+
+## Batch 和 Epoch 有什么区别？
+
+批量大小是在更新模型之前处理的多个样本。
+
+时期数是通过训练数据集的完整传递次数。
+
+批量的大小必须大于或等于 1 且小于或等于训练数据集中的样本数。
+
+时期数可以设置为 1 和无穷大之间的整数值。您可以根据需要运行算法，甚至可以使用除固定数量的历元之外的其他标准来停止算法，例如模型错误随时间的变化（或缺少更改）。
+
+它们都是整数值，并且它们都是学习算法的超参数，例如，学习过程的参数，而不是学习过程中找到的内部模型参数。
+
+您必须为学习算法指定批次大小和时期数。
+
+如何配置这些参数没有神奇的规则。您必须尝试不同的值，看看哪种方法最适合您的问题。
+
+### 工作示例
+
+最后，让我们用一个小例子来具体化。
+
+假设您有一个包含 200 个样本（数据行）的数据集，并且您选择的批量大小为 5 和 1,000 个纪元。
+
+这意味着数据集将分为 40 个批次，每个批次有 5 个样本。每批五个样品后，模型权重将更新。
+
+这也意味着一个时代将涉及 40 个批次或 40 个模型更新。
+
+有 1000 个时期，模型将暴露或传递整个数据集 1,000 次。在整个培训过程中总共有 40,000 批次。
+
+## 进一步阅读
+
+如果您希望深入了解，本节将提供有关该主题的更多资源。
+
+*   [机器学习的梯度下降](https://machinelearningmastery.com/gradient-descent-for-machine-learning/)
+*   [微量批量梯度下降的简要介绍以及如何配置批量大小](https://machinelearningmastery.com/gentle-introduction-mini-batch-gradient-descent-configure-batch-size/)
+*   [如何诊断 LSTM 模型的过度拟合和欠拟合](https://machinelearningmastery.com/diagnose-overfitting-underfitting-lstm-models/)
+*   [维基百科上的随机梯度下降](https://en.wikipedia.org/wiki/Stochastic_gradient_descent)
+*   [维基百科上的反向传播](https://en.wikipedia.org/wiki/Backpropagation)
+
+## 摘要
+
+在这篇文章中，您发现了随机梯度下降中批次和时期之间的差异。
+
+具体来说，你学到了：
+
+*   随机梯度下降是一种迭代学习算法，它使用训练数据集来更新模型。
+*   批量大小是梯度下降的超参数，在模型的内部参数更新之前控制训练样本的数量。
+*   时期数是梯度下降的超参数，其控制通过训练数据集的完整遍数。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file

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

+# 在 Keras 展示深度学习模式培训历史
+
+> 原文： [https://machinelearningmastery.com/display-deep-learning-model-training-history-in-keras/](https://machinelearningmastery.com/display-deep-learning-model-training-history-in-keras/)
+
+您可以通过观察他们在训练期间随时间的表现来学习很多关于神经网络和深度学习模型的知识。
+
+Keras 是一个功能强大的 Python 库，它提供了一个干净的界面来创建深度学习模型，并包含更技术性的 TensorFlow 和 Theano 后端。
+
+在本文中，您将了解如何在使用 Keras 进行 Python 培训期间查看和可视化深度学习模型的性能。
+
+让我们开始吧。
+
+*   **2017 年 3 月更新：**更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 **的示例。**
+*   **更新 March / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。
+
+![Display Deep Learning Model Training History in Keras](img/8f6199089c1bc957ea5e0a9d478c098a.jpg)
+
+在 Keras 中展示深度学习模型培训历史
+照片由 [Gordon Robertson](https://www.flickr.com/photos/gordon_robertson/5620659988/) 拍摄，保留一些权利。
+
+## Keras 中的访问模型培训历史
+
+Keras 提供了在训练深度学习模型时注册回调的功能。
+
+训练所有深度学习模型时注册的默认回调之一是[历史回调](http://keras.io/callbacks/)。它记录每个时期的培训指标。这包括损失和准确性（对于分类问题）以及验证数据集的损失和准确性（如果已设置）。
+
+历史对象从调用返回到用于训练模型的 fit（）函数返回。度量标准存储在返回对象的历史成员中的字典中。
+
+例如，您可以在训练模型后使用以下代码段列出历史记录对象中收集的指标：
+
+```
+# list all data in history
+print(history.history.keys())
+```
+
+例如，对于使用验证数据集训练分类问题的模型，这可能会产生以下列表：
+
+```
+['acc', 'loss', 'val_acc', 'val_loss']
+```
+
+我们可以使用历史对象中收集的数据来创建绘图。
+
+这些图可以提供有关模型训练的有用信息的指示，例如：
+
+*   它是时代（坡度）的收敛速度。
+*   模型是否已经收敛（线的高原）。
+*   模式是否可能过度学习训练数据（验证线的变形）。
+
+和更多。
+
+## 可视化 Keras 中的模型培训历史
+
+我们可以从收集的历史数据中创建绘图。
+
+在下面的例子中，我们创建了一个小型网络来模拟皮马印第安人糖尿病二元分类问题。这是一个可从 UCI 机器学习库获得的小型数据集。您可以[下载数据集](http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data)并将其保存为当前工作目录中的 _pima-indians-diabetes.csv_ （更新：[从此处下载](https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv)）。
+
+该示例收集从训练模型返回的历史记录并创建两个图表：
+
+1.  训练时期训练和验证数据集的准确性图。
+2.  训练和验证数据集在训练时期的损失图。
+
+```
+# Visualize training history
+from keras.models import Sequential
+from keras.layers import Dense
+import matplotlib.pyplot as plt
+import numpy
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load pima indians dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+# split into input (X) and output (Y) variables
+X = dataset[:,0:8]
+Y = dataset[:,8]
+# create model
+model = Sequential()
+model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='relu'))
+model.add(Dense(8, kernel_initializer='uniform', activation='relu'))
+model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
+# Compile model
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+# Fit the model
+history = model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10, verbose=0)
+# list all data in history
+print(history.history.keys())
+# summarize history for accuracy
+plt.plot(history.history['acc'])
+plt.plot(history.history['val_acc'])
+plt.title('model accuracy')
+plt.ylabel('accuracy')
+plt.xlabel('epoch')
+plt.legend(['train', 'test'], loc='upper left')
+plt.show()
+# summarize history for loss
+plt.plot(history.history['loss'])
+plt.plot(history.history['val_loss'])
+plt.title('model loss')
+plt.ylabel('loss')
+plt.xlabel('epoch')
+plt.legend(['train', 'test'], loc='upper left')
+plt.show()
+```
+
+下面提供了这些情节。验证数据集的历史记录按惯例标记为测试，因为它确实是模型的测试数据集。
+
+从准确度的图表中我们可以看出，模型可能会受到更多的训练，因为两个数据集的准确度趋势在最后几个时期仍在上升。我们还可以看到该模型尚未过度学习训练数据集，在两个数据集上显示出相似的技能。
+
+![Plot of Model Accuracy on Train and Validation Datasets](img/aa735153796f8cda098d2fe7fb675e75.jpg)
+
+列车和验证数据集的模型精度图
+
+从损失图中，我们可以看到该模型在列车和验证数据集上都具有可比性（标记为测试）。如果这些平行的地块开始一致地离开，那么可能是在早期时期停止训练的迹象。
+
+![Plot of Model Loss on Training and Validation Datasets](img/429db1e26cf59719f9b941d5e8a7b919.jpg)
+
+关于培训和验证数据集的模型损失情节
+
+## 摘要
+
+在这篇文章中，您发现了在深度学习模型培训过程中收集和检查指标的重要性。
+
+您了解了 Keras 中的历史回调以及它是如何从调用 fit（）函数返回以训练模型的。您学习了如何根据培训期间收集的历史数据创建绘图。
+
+您对模特训练历史或这篇文章有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file

docs/dl-keras/dropout-regularization-deep-learning-models-keras.md

+# 基于 Keras 的深度学习模型中的辍学规律化
+
+> 原文： [https://machinelearningmastery.com/dropout-regularization-deep-learning-models-keras/](https://machinelearningmastery.com/dropout-regularization-deep-learning-models-keras/)
+
+神经网络和深度学习模型的简单而强大的正则化技术是辍学。
+
+在这篇文章中，您将发现 dropout 正则化技术以及如何将其应用于使用 Keras 的 Python 模型。
+
+阅读这篇文章后你会知道：
+
+*   辍学正则化技术如何工作。
+*   如何在输入图层上使用 dropout。
+*   如何在隐藏图层上使用 dropout。
+*   如何调整问题的辍学水平。
+
+让我们开始吧。
+
+*   **2016 年 10 月更新**：更新了 Keras 1.1.0，TensorFlow 0.10.0 和 scikit-learn v0.18 的示例。
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+
+![Dropout Regularization in Deep Learning Models With Keras](img/79c8df17f76c38e054a8760b935e6ed9.jpg)
+
+使用 Keras 的深度学习模型中的辍学正规化
+照片由 [Trekking Rinjani](https://www.flickr.com/photos/trekkingrinjani/4930552641/) ，保留一些权利。
+
+## 神经网络的丢失正则化
+
+Dropout 是 Srivastava 等人提出的神经网络模型的正则化技术。在他们的 2014 年论文[辍学：一种防止神经网络过度拟合的简单方法](http://jmlr.org/papers/v15/srivastava14a.html)（[下载 PDF](http://jmlr.org/papers/volume15/srivastava14a/srivastava14a.pdf) ）。
+
+辍学是一种在训练过程中忽略随机选择的神经元的技术。他们随机“辍学”。这意味着它们对下游神经元激活的贡献在正向通过时暂时消除，并且任何重量更新都不会应用于向后通过的神经元。
+
+当神经网络学习时，神经元权重在网络中的上下文中进行。针对特定特征调整神经元的权重，从而提供一些特化。相邻神经元变得依赖于这种专业化，如果采取太多可能导致脆弱的模型太专门于训练数据。这在培训期间依赖于神经元的背景被称为复杂的共同适应。
+
+你可以想象，如果神经元在训练过程中随机掉出网络，那么其他神经元将不得不介入并处理对缺失神经元进行预测所需的表示。这被认为导致网络学习多个独立的内部表示。
+
+其结果是网络对神经元的特定权重变得不那么敏感。这反过来导致网络能够更好地概括并且不太可能过度拟合训练数据。
+
+## 科拉斯的辍学规范化
+
+通过以每个权重更新周期的给定概率（例如 20％）随机选择要丢弃的节点，可以容易地实现丢失。这就是在卡拉斯实施 Dropout 的方式。 Dropout 仅在模型训练期间使用，在评估模型的技能时不使用。
+
+接下来，我们将探讨在 Keras 中使用 Dropout 的几种不同方法。
+
+这些示例将使用 [Sonar 数据集](http://archive.ics.uci.edu/ml/datasets/Connectionist+Bench+(Sonar,+Mines+vs.+Rocks))。这是一个二元分类问题，其目标是从声纳啁啾返回中正确识别岩石和模拟地雷。它是神经网络的一个很好的测试数据集，因为所有输入值都是数字的并且具有相同的比例。
+
+数据集可以是从 UCI 机器学习库下载的[。您可以将声纳数据集放在当前工作目录中，文件名为 sonar.csv。](http://archive.ics.uci.edu/ml/machine-learning-databases/undocumented/connectionist-bench/sonar/sonar.all-data)
+
+我们将使用带有 10 倍交叉验证的 scikit-learn 来评估开发的模型，以便更好地梳理结果中的差异。
+
+有 60 个输入值和一个输出值，输入值在用于网络之前已标准化。基线神经网络模型具有两个隐藏层，第一个具有 60 个单元，第二个具有 30 个。随机梯度下降用于训练具有相对低的学习速率和动量的模型。
+
+下面列出了完整的基线模型。
+
+```
+# Baseline Model on the Sonar Dataset
+import numpy
+from pandas import read_csv
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import Dropout
+from keras.wrappers.scikit_learn import KerasClassifier
+from keras.constraints import maxnorm
+from keras.optimizers import SGD
+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
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load dataset
+dataframe = 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]
+# encode class values as integers
+encoder = LabelEncoder()
+encoder.fit(Y)
+encoded_Y = encoder.transform(Y)
+
+# baseline
+def create_baseline():
+	# create model
+	model = Sequential()
+	model.add(Dense(60, input_dim=60, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(30, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
+	# Compile model
+	sgd = SGD(lr=0.01, momentum=0.8, decay=0.0, nesterov=False)
+	model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy'])
+	return model
+
+numpy.random.seed(seed)
+estimators = []
+estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasClassifier(build_fn=create_baseline, epochs=300, batch_size=16, verbose=0)))
+pipeline = Pipeline(estimators)
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
+print("Baseline: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+```
+
+运行该示例可生成 86％的估计分类准确度。
+
+```
+Baseline: 86.04% (4.58%)
+```
+
+## 在可见图层上使用 Dropout
+
+Dropout 可以应用于称为可见层的输入神经元。
+
+在下面的示例中，我们在输入（或可见图层）和第一个隐藏图层之间添加一个新的 Dropout 图层。辍学率设置为 20％，这意味着每个更新周期中将随机排除五分之一输入。
+
+此外，正如 Dropout 原始论文中所建议的那样，对每个隐藏层的权重施加约束，确保权重的最大范数不超过值 3.这可以通过在密集上设置 kernel_constraint 参数来完成。构造图层时的类。
+
+学习率提高了一个数量级，动量增加到 0.9。原始 Dropout 论文中也推荐了这些学习率的提高。
+
+继续上面的基线示例，下面的代码使用输入丢失来运行相同的网络。
+
+```
+# dropout in the input layer with weight constraint
+def create_model():
+	# create model
+	model = Sequential()
+	model.add(Dropout(0.2, input_shape=(60,)))
+	model.add(Dense(60, kernel_initializer='normal', activation='relu', kernel_constraint=maxnorm(3)))
+	model.add(Dense(30, kernel_initializer='normal', activation='relu', kernel_constraint=maxnorm(3)))
+	model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
+	# Compile model
+	sgd = SGD(lr=0.1, momentum=0.9, decay=0.0, nesterov=False)
+	model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy'])
+	return model
+
+numpy.random.seed(seed)
+estimators = []
+estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasClassifier(build_fn=create_model, epochs=300, batch_size=16, verbose=0)))
+pipeline = Pipeline(estimators)
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
+print("Visible: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+```
+
+运行该示例至少在单次测试运行中提供了分类精度的小幅下降。
+
+```
+Visible: 83.52% (7.68%)
+```
+
+## 在隐藏图层上使用 Dropout
+
+Dropout 可以应用于网络模型体内的隐藏神经元。
+
+在下面的示例中，Dropout 应用于两个隐藏层之间以及最后一个隐藏层和输出层之间。再次使用 20％的辍学率，以及对这些层的权重约束。
+
+```
+# dropout in hidden layers with weight constraint
+def create_model():
+	# create model
+	model = Sequential()
+	model.add(Dense(60, input_dim=60, kernel_initializer='normal', activation='relu', kernel_constraint=maxnorm(3)))
+	model.add(Dropout(0.2))
+	model.add(Dense(30, kernel_initializer='normal', activation='relu', kernel_constraint=maxnorm(3)))
+	model.add(Dropout(0.2))
+	model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
+	# Compile model
+	sgd = SGD(lr=0.1, momentum=0.9, decay=0.0, nesterov=False)
+	model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy'])
+	return model
+
+numpy.random.seed(seed)
+estimators = []
+estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasClassifier(build_fn=create_model, epochs=300, batch_size=16, verbose=0)))
+pipeline = Pipeline(estimators)
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
+print("Hidden: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+```
+
+我们可以看到，针对此问题以及所选网络配置，在隐藏层中使用丢失并未提升性能。事实上，表现比基线差。
+
+可能需要额外的训练时期或者需要进一步调整学习速率。
+
+```
+Hidden: 83.59% (7.31%)
+```
+
+## 使用 Dropout 的提示
+
+关于 Dropout 的原始论文提供了一套标准机器学习问题的实验结果。因此，在实践中使用辍学时，他们提供了许多有用的启发式方法。
+
+*   通常，使用 20％-50％神经元的小辍学值，20％提供良好的起点。概率太低具有最小的影响而且值太高会导致网络的学习不足。
+*   使用更大的网络。当在较大的网络上使用 dropout 时，您可能会获得更好的性能，从而为模型提供更多学习独立表示的机会。
+*   在传入（可见）和隐藏单位上使用 dropout。在网络的每一层应用丢失已经显示出良好的结果。
+*   使用具有衰减和大动量的大学习率。将学习率提高 10 到 100 倍，并使用 0.9 或 0.99 的高动量值。
+*   限制网络权重的大小。较大的学习速率可能导致非常大的网络权重。对网络权重的大小施加约束，例如大小为 4 或 5 的最大范数正则化已被证明可以改善结果。
+
+## 关于辍学的更多资源
+
+以下是一些资源，您可以用它们来了解有关神经网络和深度学习模型中的丢失的更多信息。
+
+*   [辍学：一种防止神经网络过度拟合的简单方法](http://jmlr.org/papers/v15/srivastava14a.html)（原始论文）。
+*   [通过阻止特征检测器的共同适应来改善神经网络](http://arxiv.org/abs/1207.0580)。
+*   [辍学方法如何在深度学习中发挥作用？ Quora 上的](https://www.quora.com/How-does-the-dropout-method-work-in-deep-learning)。
+
+## 摘要
+
+在这篇文章中，您发现了深度学习模型的丢失正则化技术。你了解到：
+
+*   辍学是什么以及如何运作。
+*   如何在自己的深度学习模型中使用 dropout。
+*   在您自己的模型上从辍学中获得最佳结果的提示。
+
+您对辍学或这篇文章有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file

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

+# 评估 Keras 中深度学习模型的性能
+
+> 原文： [https://machinelearningmastery.com/evaluate-performance-deep-learning-models-keras/](https://machinelearningmastery.com/evaluate-performance-deep-learning-models-keras/)
+
+Keras 是一个易于使用且功能强大的 Python 库，用于深度学习。
+
+在设计和配置深度学习模型时，需要做出很多决定。大多数决策必须通过试验和错误凭经验解决，并根据实际数据进行评估。
+
+因此，有一种强大的方法来评估神经网络和深度学习模型的性能至关重要。
+
+在这篇文章中，您将发现使用 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 的示例。
+*   **更新 March / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。
+
+![Evaluate the Performance Of Deep Learning Models in Keras](img/e1c3b3955f7f82b7e5b64209a3825ab4.jpg)
+
+评估 Keras 中深度学习模型的性能
+照片由 [Thomas Leuthard](https://www.flickr.com/photos/thomasleuthard/7273077758/) 拍摄，保留一些权利。
+
+## 根据经验评估网络配置
+
+在设计和配置深度学习模型时，必须做出无数决定。
+
+其中许多决策可以通过复制其他人的网络结构并使用启发式方法来解决。最终，最好的技术是实际设计小型实验并使用实际数据凭经验评估选项。
+
+这包括高级决策，例如网络中图层的数量，大小和类型。它还包括较低级别的决策，如损失函数的选择，激活函数，优化过程和时期数。
+
+深度学习通常用于具有非常大的数据集的问题。那就是数万或数十万个实例。
+
+因此，您需要拥有一个强大的测试工具，可以让您估计给定配置在看不见的数据上的性能，并可靠地将性能与其他配置进行比较。
+
+## 数据拆分
+
+大量数据和模型的复杂性需要非常长的训练时间。
+
+因此，通常使用简单的数据分离到训练和测试数据集或训练和验证数据集中。
+
+Keras 提供了两种方便的方式来评估您的深度学习算法：
+
+1.  使用自动验证数据集。
+2.  使用手动验证数据集。
+
+### 使用自动验证数据集
+
+Keras 可以将训练数据的一部分分离为验证数据集，并在每个时期评估模型在该验证数据集上的性能。
+
+您可以通过将 **fit** （）函数上的 **validation_split** 参数设置为训练数据集大小的百分比来完成此操作。
+
+例如，20％的合理值可能是 0.2 或 0.33，或者为了验证而保留的培训数据的 33％。
+
+下面的示例演示了如何在小二进制分类问题上使用自动验证数据集。本文中的所有实例均使用[皮马印第安人糖尿病数据集](http://archive.ics.uci.edu/ml/datasets/Pima+Indians+Diabetes)。您可以[从 UCI 机器学习库下载](http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data)，并使用文件名 **pima-indians-diabetes.csv** 将数据文件保存到当前工作目录中（更新：[从这里](https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv)）。
+
+```
+# MLP with automatic validation set
+from keras.models import Sequential
+from keras.layers import Dense
+import numpy
+# fix random seed for reproducibility
+numpy.random.seed(7)
+# load pima indians dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+# split into input (X) and output (Y) variables
+X = dataset[:,0:8]
+Y = dataset[:,8]
+# create model
+model = Sequential()
+model.add(Dense(12, input_dim=8, activation='relu'))
+model.add(Dense(8, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+# Compile model
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+# Fit the model
+model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10)
+```
+
+运行该示例，您可以看到每个时期的详细输出显示了训练数据集和验证数据集的损失和准确性。
+
+```
+...
+Epoch 145/150
+514/514 [==============================] - 0s - loss: 0.5252 - acc: 0.7335 - val_loss: 0.5489 - val_acc: 0.7244
+Epoch 146/150
+514/514 [==============================] - 0s - loss: 0.5198 - acc: 0.7296 - val_loss: 0.5918 - val_acc: 0.7244
+Epoch 147/150
+514/514 [==============================] - 0s - loss: 0.5175 - acc: 0.7335 - val_loss: 0.5365 - val_acc: 0.7441
+Epoch 148/150
+514/514 [==============================] - 0s - loss: 0.5219 - acc: 0.7354 - val_loss: 0.5414 - val_acc: 0.7520
+Epoch 149/150
+514/514 [==============================] - 0s - loss: 0.5089 - acc: 0.7432 - val_loss: 0.5417 - val_acc: 0.7520
+Epoch 150/150
+514/514 [==============================] - 0s - loss: 0.5148 - acc: 0.7490 - val_loss: 0.5549 - val_acc: 0.7520
+```
+
+### 使用手动验证数据集
+
+Keras 还允许您手动指定在训练期间用于验证的数据集。
+
+在这个例子中，我们使用 Python [scikit-learn](http://scikit-learn.org/stable/index.html) 机器学习库中的方便 [train_test_split](http://scikit-learn.org/stable/modules/generated/sklearn.cross_validation.train_test_split.html) （）函数将我们的数据分成训练和测试数据集。我们使用 67％用于培训，剩余 33％用于验证。
+
+可以通过 **validation_data** 参数将验证数据集指定给 Keras 中的 **fit** （）函数。它需要输入和输出数据集的元组。
+
+```
+# MLP with manual validation set
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.model_selection import train_test_split
+import numpy
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load pima indians dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+# split into input (X) and output (Y) variables
+X = dataset[:,0:8]
+Y = dataset[:,8]
+# split into 67% for train and 33% for test
+X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=seed)
+# create model
+model = Sequential()
+model.add(Dense(12, input_dim=8, activation='relu'))
+model.add(Dense(8, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+# Compile model
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+# Fit the model
+model.fit(X_train, y_train, validation_data=(X_test,y_test), epochs=150, batch_size=10)
+```
+
+与之前一样，运行该示例提供了详细的训练输出，其中包括模型在每个时期的训练和验证数据集上的丢失和准确性。
+
+```
+...
+Epoch 145/150
+514/514 [==============================] - 0s - loss: 0.4847 - acc: 0.7704 - val_loss: 0.5668 - val_acc: 0.7323
+Epoch 146/150
+514/514 [==============================] - 0s - loss: 0.4853 - acc: 0.7549 - val_loss: 0.5768 - val_acc: 0.7087
+Epoch 147/150
+514/514 [==============================] - 0s - loss: 0.4864 - acc: 0.7743 - val_loss: 0.5604 - val_acc: 0.7244
+Epoch 148/150
+514/514 [==============================] - 0s - loss: 0.4831 - acc: 0.7665 - val_loss: 0.5589 - val_acc: 0.7126
+Epoch 149/150
+514/514 [==============================] - 0s - loss: 0.4961 - acc: 0.7782 - val_loss: 0.5663 - val_acc: 0.7126
+Epoch 150/150
+514/514 [==============================] - 0s - loss: 0.4967 - acc: 0.7588 - val_loss: 0.5810 - val_acc: 0.6929
+```
+
+## 手动 k-fold 交叉验证
+
+机器学习模型评估的黄金标准是 [k 倍交叉验证](https://en.wikipedia.org/wiki/Cross-validation_(statistics))。
+
+它提供了对未见数据模型性能的可靠估计。它通过将训练数据集分成 k 个子集并在所有子集上轮流训练模型（除了一个被保持的外部）并在所保持的验证数据集上评估模型性能来实现这一点。重复该过程，直到所有子集都有机会成为保持的验证集。然后在所有创建的模型中对性能度量进行平均。
+
+由于计算费用较高，交叉验证通常不用于评估深度学习模型。例如，k 倍交叉验证通常使用 5 或 10 倍。因此，必须构建和评估 5 或 10 个模型，这大大增加了模型的评估时间。
+
+然而，当问题足够小或者你有足够的计算资源时，k-fold 交叉验证可以让你对模型的性能进行较少的偏差估计。
+
+在下面的例子中，我们使用来自 [scikit-learn](http://scikit-learn.org/stable/index.html) Python 机器学习库的方便的 [StratifiedKFold](http://scikit-learn.org/stable/modules/generated/sklearn.cross_validation.StratifiedKFold.html) 类将训练数据集分成 10 倍。折叠是分层的，这意味着算法试图平衡每个折叠中每个类的实例数。
+
+该示例使用 10 个数据分割创建和评估 10 个模型，并收集所有分数。通过将 verbose = 0 传递给模型上的 **fit（）**和 **evaluate（）**函数来关闭每个纪元的详细输出。
+
+为每个型号打印性能并将其存储。然后在运行结束时打印模型性能的平均值和标准偏差，以提供模型精度的稳健估计。
+
+```
+# MLP for Pima Indians Dataset with 10-fold cross validation
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.model_selection import StratifiedKFold
+import numpy
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load pima indians dataset
+dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
+# split into input (X) and output (Y) variables
+X = dataset[:,0:8]
+Y = dataset[:,8]
+# define 10-fold cross validation test harness
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+cvscores = []
+for train, test in kfold.split(X, Y):
+  # create model
+	model = Sequential()
+	model.add(Dense(12, input_dim=8, activation='relu'))
+	model.add(Dense(8, activation='relu'))
+	model.add(Dense(1, activation='sigmoid'))
+	# Compile model
+	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+	# Fit the model
+	model.fit(X[train], Y[train], epochs=150, batch_size=10, verbose=0)
+	# evaluate the model
+	scores = model.evaluate(X[test], Y[test], verbose=0)
+	print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
+	cvscores.append(scores[1] * 100)
+print("%.2f%% (+/- %.2f%%)" % (numpy.mean(cvscores), numpy.std(cvscores)))
+```
+
+运行该示例将花费不到一分钟，并将产生以下输出：
+
+```
+acc: 77.92%
+acc: 68.83%
+acc: 72.73%
+acc: 64.94%
+acc: 77.92%
+acc: 35.06%
+acc: 74.03%
+acc: 68.83%
+acc: 34.21%
+acc: 72.37%
+64.68% (+/- 15.50%)
+```
+
+## 摘要
+
+在这篇文章中，您发现了使用一种强大的方法来估计深度学习模型在看不见的数据上的表现的重要性。
+
+您发现了三种使用 Keras 库在 Python 中估计深度学习模型性能的方法：
+
+*   使用自动验证数据集。
+*   使用手动验证数据集。
+*   使用手动 k-fold 交叉验证。
+
+您对 Keras 或此帖的深度学习有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file

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

+# 如何评价深度学习模式的技巧
+
+> 原文： [https://machinelearningmastery.com/evaluate-skill-deep-learning-models/](https://machinelearningmastery.com/evaluate-skill-deep-learning-models/)
+
+我经常看到从业者对如何评估深度学习模型表示困惑。
+
+从以下问题中可以看出这一点：
+
+*   我应该使用什么随机种子？
+*   我需要随机种子吗？
+*   为什么我在后续运行中得不到相同的结果？
+
+在这篇文章中，您将发现可用于评估深度学习模型的过程以及使用它的基本原理。
+
+您还将发现有用的相关统计数据，您可以计算这些统计数据以显示模型的技能，例如标准偏差，标准误差和置信区间。
+
+让我们开始吧。
+
+![How to Evaluate the Skill of Deep Learning Models](img/8e1689ec640a31d8358af77078ac6bfb.jpg)
+
+如何评估深度学习模型的技巧
+照片由 [Allagash Brewing](https://www.flickr.com/photos/allagashbrewing/14612890354/) ，保留一些权利。
+
+## 初学者的错误
+
+您将模型拟合到训练数据并在测试数据集上进行评估，然后报告技能。
+
+也许您使用 k 折交叉验证来评估模型，然后报告模型的技能。
+
+这是初学者犯的错误。
+
+看起来你做的是正确的事情，但有一个关键问题是你没有考虑到：
+
+**深度学习模型是随机的。**
+
+人工神经网络在适应数据集时使用随机性，例如随机初始权重和随机梯度下降期间每个训练时期的数据随机混洗。
+
+这意味着每次相同的模型适合相同的数据时，它可能会给出不同的预测，从而具有不同的整体技能。
+
+## 估算模型技能
+（_ 模型方差控制 _）
+
+我们没有所有可能的数据;如果我们这样做，我们就不需要做出预测。
+
+我们有一个有限的数据样本，我们需要发现最好的模型。
+
+### 使用列车测试拆分
+
+我们通过将数据分成两部分来做到这一点，在数据的第一部分拟合模型或特定模型配置，并使用拟合模型对其余部分进行预测，然后评估这些预测的技能。这被称为列车测试分割，我们使用该技能估计模型在对新数据进行预测时在实践中的表现。
+
+例如，这里有一些用于使用列车测试分割来评估模型的伪代码：
+
+```
+train, test = split(data)
+model = fit(train.X, train.y)
+predictions = model.predict(test.X)
+skill = compare(test.y, predictions)
+```
+
+如果您有大量数据或非常慢的模型进行训练，列车测试分割是一种很好的方法，但由于数据的随机性（模型的方差），模型的最终技能分数会很嘈杂。 。
+
+这意味着适合不同数据的相同模型将给出不同的模型技能分数。
+
+### 使用 k-fold 交叉验证
+
+我们通常可以收紧这一点，并使用 k-fold 交叉验证等技术获得更准确的模型技能估算。这是一种系统地将可用数据分成 k 重折叠，将模型拟合在 k-1 折叠上，在保持折叠上进行评估，并对每个折叠重复此过程的技术。
+
+这导致 k 个不同的模型具有 k 个不同的预测集合，并且反过来具有 k 个不同的技能分数。
+
+例如，这里有一些使用 k 折交叉验证评估模型的伪代码：
+
+```
+scores = list()
+for i in k:
+	train, test = split_old(data, i)
+	model = fit(train.X, train.y)
+	predictions = model.predict(test.X)
+	skill = compare(test.y, predictions)
+	scores.append(skill)
+```
+
+技能分数更有用，因为我们可以采用均值并报告模型的平均预期性能，这可能更接近实际模型的实际性能。例如：
+
+```
+mean_skill = sum(scores) / count(scores)
+```
+
+我们还可以使用 mean_skill 计算标准偏差，以了解 mean_skill 周围的平均分数差异：
+
+```
+standard_deviation = sqrt(1/count(scores) * sum( (score - mean_skill)^2 ))
+```
+
+## 估计随机模型的技能
+（_ 控制模型稳定性 _）
+
+随机模型，如深度神经网络，增加了一个额外的随机源。
+
+这种额外的随机性使得模型在学习时具有更大的灵活性，但可以使模型更不稳定（例如，当在相同数据上训练相同模​​型时的不同结果）。
+
+这与模型方差不同，当在不同数据上训练相同模​​型时，模型方差给出不同的结果。
+
+为了得到随机模型技能的可靠估计，我们必须考虑这个额外的方差来源;我们必须控制它。
+
+### 修复随机种子
+
+一种方法是每次模型拟合时使用相同的随机性。我们可以通过修复系统使用的随机数种子然后评估或拟合模型来做到这一点。例如：
+
+```
+seed(1)
+scores = list()
+for i in k:
+	train, test = split_old(data, i)
+	model = fit(train.X, train.y)
+	predictions = model.predict(test.X)
+	skill = compare(test.y, predictions)
+	scores.append(skill)
+```
+
+当每次运行代码时需要相同的结果时，这对于教程和演示很有用。
+
+这很脆弱，不建议用于评估模型。
+
+看帖子：
+
+*   [在机器学习中拥抱随机性](http://machinelearningmastery.com/randomness-in-machine-learning/)
+*   [如何使用 Keras](http://machinelearningmastery.com/reproducible-results-neural-networks-keras/) 获得可重现的结果
+
+### 重复评估实验
+
+更强大的方法是重复多次评估非随机模型的实验。
+
+例如：
+
+```
+scores = list()
+for i in repeats:
+	run_scores = list()
+	for j in k:
+		train, test = split_old(data, j)
+		model = fit(train.X, train.y)
+		predictions = model.predict(test.X)
+		skill = compare(test.y, predictions)
+		run_scores.append(skill)
+	scores.append(mean(run_scores))
+```
+
+注意，我们计算估计的平均模型技能的平均值，即所谓的[宏均值](https://en.wikipedia.org/wiki/Grand_mean)。
+
+这是我推荐的估算深度学习模型技能的程序。
+
+因为重复通常> = 30，所以我们可以很容易地计算出平均模型技能的标准误差，即模型技能得分的估计平均值与未知的实际平均模型技能的差异（例如，mean_skill 可能有多差）
+
+```
+standard_error = standard_deviation / sqrt(count(scores))
+```
+
+此外，我们可以使用 standard_error 来计算 mean_skill 的置信区间。这假设结果的分布是高斯分布，您可以通过查看直方图，Q-Q 图或对收集的分数使用统计检验来检查。
+
+例如，95％的间隔是平均技能周围的（1.96 *标准误差）。
+
+```
+interval = standard_error * 1.96
+lower_interval = mean_skill - interval
+upper_interval = mean_skill + interval
+```
+
+与使用大均值的标准误差相比，还有其他可能更加统计上更稳健的计算置信区间的方法，例如：
+
+*   计算[二项式比例置信区间](https://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval)。
+*   使用自举到[估计经验置信区间](https://en.wikipedia.org/wiki/Bootstrapping_(statistics)#Deriving_confidence_intervals_from_the_bootstrap_distribution)。
+
+## 神经网络有多不稳定？
+
+这取决于您的问题，网络和配置。
+
+我建议进行敏感性分析以找出答案。
+
+在同一数据上多次（30,100 或数千）评估相同的模型，只改变随机数生成器的种子。
+
+然后检查所产生技能分数的均值和标准差。标准偏差（平均得分与平均得分的平均距离）将让您了解模型的不稳定程度。
+
+### 多少重复？
+
+我建议至少 30，也许 100，甚至数千，仅限于你的时间和计算机资源，以及递减的回报（例如，mean_skill 上的标准错误）。
+
+更严格的是，我建议进行一项实验，研究估计模型技能对重复次数的影响和标准误差的计算（平均估计性能与真实潜在人口平均值的差异）。
+
+## 进一步阅读
+
+*   [在机器学习中拥抱随机性](http://machinelearningmastery.com/randomness-in-machine-learning/)
+*   [如何训练最终机器学习模型](http://machinelearningmastery.com/train-final-machine-learning-model/)
+*   [比较不同种类的交叉验证](http://appliedpredictivemodeling.com/blog/2014/11/27/vpuig01pqbklmi72b8lcl3ij5hj2qm)
+*   [人工智能的经验方法](http://www.amazon.com/dp/0262032252?tag=inspiredalgor-20)，Cohen，1995。
+*   维基百科上的[标准错误](https://en.wikipedia.org/wiki/Standard_error)
+
+## 摘要
+
+在这篇文章中，您发现了如何评估深度学习模型的技能。
+
+具体来说，你学到了：
+
+*   初学者在评估深度学习模型时常犯的错误。
+*   使用重复 k 倍交叉验证来评估深度学习模型的基本原理。
+*   如何计算相关的模型技能统计数据，例如标准差，标准误差和置信区间。
+
+您对估算深度学习模型的技能有任何疑问吗？
+在评论中发表您的问题，我会尽力回答。
\ No newline at end of file

docs/dl-keras/gentle-introduction-mini-batch-gradient-descent-configure-batch-size.md

+# 微型批量梯度下降的简要介绍以及如何配置批量大小
+
+> 原文： [https://machinelearningmastery.com/gentle-introduction-mini-batch-gradient-descent-configure-batch-size/](https://machinelearningmastery.com/gentle-introduction-mini-batch-gradient-descent-configure-batch-size/)
+
+随机梯度下降是用于训练深度学习模型的主要方法。
+
+梯度下降有三种主要变体，可能会混淆哪一种使用。
+
+在这篇文章中，您将发现一般应该使用的一种梯度下降以及如何配置它。
+
+完成这篇文章后，你会知道：
+
+*   什么梯度下降以及它如何从高层起作用。
+*   什么批次，随机和小批量梯度下降以及每种方法的优点和局限性。
+*   这种小批量梯度下降是首选方法，以及如何在您的应用程序上配置它。
+
+让我们开始吧。
+
+*   **Update Apr / 2018** ：添加了额外的参考，以支持批量大小为 32。
+
+![A Gentle Introduction to Mini-Batch Gradient Descent and How to Configure Batch Size](img/e95bf53e34f94fbb07da8860454b1e2a.jpg)
+
+微型批量梯度下降和如何配置批量大小的温和介绍
+照片由 [Brian Smithson](https://www.flickr.com/photos/smithser/6269720226/) ，保留一些权利。
+
+## 教程概述
+
+本教程分为 3 个部分;他们是：
+
+1.  什么是梯度下降？
+2.  对比 3 种类型的梯度下降
+3.  如何配置 Mini-Batch Gradient Descent
+
+## 什么是梯度下降？
+
+梯度下降是一种优化算法，通常用于查找机器学习算法的权重或系数，例如人工神经网络和逻辑回归。
+
+它的工作原理是让模型对训练数据进行预测，并使用预测误差来更新模型，以减少错误。
+
+该算法的目标是找到最小化训练数据集上的模型的误差的模型参数（例如，系数或权重）。它通过对模型进行更改来实现此目的，该模型将其沿着梯度或误差斜率向下移动到最小误差值。这使算法的名称为“梯度下降”。
+
+下面的伪代码草图总结了梯度下降算法：
+
+```
+model = initialization(...)
+n_epochs = ...
+train_data = ...
+for i in n_epochs:
+	train_data = shuffle(train_data)
+	X, y = split(train_data)
+	predictions = predict(X, model)
+	error = calculate_error(y, predictions)
+	model = update_model(model, error)
+```
+
+有关更多信息，请参阅帖子：
+
+*   [机器学习的梯度下降](http://machinelearningmastery.com/gradient-descent-for-machine-learning/)
+*   [如何利用 Python 从头开始随机梯度下降实现线性回归](http://machinelearningmastery.com/implement-linear-regression-stochastic-gradient-descent-scratch-python/)
+
+## 对比 3 种类型的梯度下降
+
+梯度下降可以根据用于计算误差的训练模式的数量而变化;而这又用于更新模型。
+
+用于计算误差的模式数包括用于更新模型的梯度的稳定性。我们将看到计算效率的梯度下降配置和误差梯度的保真度存在张力。
+
+梯度下降的三种主要风格是批量，随机和小批量。
+
+让我们仔细看看每一个。
+
+### 什么是随机梯度下降？
+
+随机梯度下降（通常缩写为 SGD）是梯度下降算法的变体，其计算误差并更新训练数据集中每个示例的模型。
+
+每个训练样例的模型更新意味着随机梯度下降通常被称为[在线机器学习算法](https://en.wikipedia.org/wiki/Online_machine_learning)。
+
+#### 上升空间
+
+*   频繁更新可立即深入了解模型的性能和改进速度。
+*   这种梯度下降的变体可能是最容易理解和实现的，特别是对于初学者。
+*   增加的模型更新频率可以更快地学习某些问题。
+*   噪声更新过程可以允许模型避免局部最小值（例如，早熟收敛）。
+
+#### 缺点
+
+*   如此频繁地更新模型在计算上比其他梯度下降配置更昂贵，在大型数据集上训练模型需要更长的时间。
+*   频繁更新可能导致噪声梯度信号，这可能导致模型参数并且反过来模型误差跳跃（在训练时期上具有更高的方差）。
+*   沿着误差梯度的噪声学习过程也可能使算法难以确定模型的最小误差。
+
+### 什么是批量梯度下降？
+
+批量梯度下降是梯度下降算法的变体，其计算训练数据集中每个示例的误差，但仅在评估了所有训练样本之后更新模型。
+
+整个训练数据集的一个周期称为训练时期。因此，经常说批量梯度下降在每个训练时期结束时执行模型更新。
+
+#### 上升空间
+
+*   对模型的更新较少意味着这种梯度下降变体在计算上比随机梯度下降更有效。
+*   降低的更新频率导致更稳定的误差梯度，并且可以在一些问题上导致更稳定的收敛。
+*   预测误差的计算与模型更新的分离使算法成为基于并行处理的实现。
+
+#### 缺点
+
+*   更稳定的误差梯度可能导致模型过早收敛到不太理想的参数组。
+*   训练时期结束时的更新需要在所有训练样例中累积预测误差的额外复杂性。
+*   通常，批量梯度下降以这样的方式实现，即它需要存储器中的整个训练数据集并且可用于算法。
+*   对于大型数据集，模型更新以及训练速度可能变得非常慢。
+
+### 什么是 Mini-Batch Gradient Descent？
+
+小批量梯度下降是梯度下降算法的变体，其将训练数据集分成小批量，用于计算模型误差和更新模型系数。
+
+实现可以选择对小批量的梯度求和或者取梯度的平均值，这进一步减小了梯度的方差。
+
+小批量梯度下降试图在随机梯度下降的稳健性和批量梯度下降的效率之间找到平衡。它是深度学习领域中最常用的梯度下降实现。
+
+#### 上升空间
+
+*   模型更新频率高于批量梯度下降，这允许更稳健的收敛，避免局部最小值。
+*   与随机梯度下降相比，批量更新提供了计算上更有效的过程。
+*   批处理允许在内存和算法实现中不具有所有训练数据的效率。
+
+#### 缺点
+
+*   小批量需要为学习算法配置额外的“小批量大小”超参数。
+*   错误信息必须在批量梯度下降等小批量培训示例中累积。
+
+## 如何配置 Mini-Batch Gradient Descent
+
+对于大多数应用，小批量梯度下降是梯度下降的推荐变体，特别是在深度学习中。
+
+为简洁起见，通常称为“批量大小”的小批量大小通常被调整到正在执行实现的计算体系结构的一个方面。例如 2 的幂，适合 GPU 或 CPU 硬件的内存要求，如 32,64,128,256 等。
+
+批量大小是学习过程中的滑块。
+
+*   较小的值使学习过程在训练过程中以噪声成本快速收敛。
+*   较大的值使学习过程缓慢收敛，并准确估计误差梯度。
+
+**提示 1：批量大小的良好默认值可能是 32\.**
+
+> ... [批量大小]通常在 1 到几百之间选择，例如， [批量大小] = 32 是一个很好的默认值，其值大于 10，利用了矩阵 - 矩阵乘积相对于矩阵矢量乘积的加速。
+
+- [深层架构基于梯度的训练的实用建议](https://arxiv.org/abs/1206.5533)，2012
+
+**更新 2018** ：这是支持批量大小为 32 的另一篇论文，这里是引用（m 是批量大小）：
+
+> 所呈现的结果证实，对于给定的计算成本，在大范围的实验中使用小批量尺寸实现了最佳的训练稳定性和泛化性能。在所有情况下，已经获得了最佳结果，批量大小 m = 32 或更小，通常小到 m = 2 或 m = 4。
+
+- [重新审视深度神经网络的小批量培训](https://arxiv.org/abs/1804.07612)，2018 年。
+
+**提示 2：在调整批量大小时，最好在不同批量大小的情况下查看模型验证错误与训练时间的学习曲线。**
+
+> ...在选择了其他超参数（学习率除外）之后，通过比较训练曲线（训练和验证误差与训练时间量），可以分别优化其他超参数。
+
+**提示 3：在调整所有其他超参数后调整批量大小和学习率。**
+
+> ... [批量大小]和[学习率]可能会与其他超参数稍微交互，因此两者都应在最后重新优化。一旦选择[批量大小]，通常可以固定，而其他超参数可以进一步优化（动量超参数除外，如果使用的话）。
+
+## 进一步阅读
+
+如果您要深入了解，本节将提供有关该主题的更多资源。
+
+### 相关文章
+
+*   [机器学习的梯度下降](http://machinelearningmastery.com/gradient-descent-for-machine-learning/)
+*   [如何利用 Python 从头开始随机梯度下降实现线性回归](http://machinelearningmastery.com/implement-linear-regression-stochastic-gradient-descent-scratch-python/)
+
+### 补充阅读
+
+*   [维基百科上的随机梯度下降](https://en.wikipedia.org/wiki/Stochastic_gradient_descent)
+*   [维基百科上的在线机器学习](https://en.wikipedia.org/wiki/Online_machine_learning)
+*   [梯度下降优化算法概述](http://sebastianruder.com/optimizing-gradient-descent/index.html)
+*   [深层架构基于梯度的培训的实用建议](https://arxiv.org/abs/1206.5533)，2012
+*   [随机优化的高效小批量培训](http://www.cs.cmu.edu/~muli/file/minibatch_sgd.pdf)，2014 年
+*   [在深度学习中，为什么我们不使用整个训练集来计算梯度？ Quora 上的](https://www.quora.com/In-deep-learning-why-dont-we-use-the-whole-training-set-to-compute-the-gradient)
+*   [大规模机器学习的优化方法](https://arxiv.org/abs/1606.04838)，2016
+
+## 摘要
+
+在这篇文章中，您发现了梯度下降算法以及您应该在实践中使用的版本。
+
+具体来说，你学到了：
+
+*   什么梯度下降以及它如何从高层起作用。
+*   什么批次，随机和小批量梯度下降以及每种方法的优点和局限性。
+*   这种小批量梯度下降是首选方法，以及如何在您的应用程序上配置它。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file

docs/dl-keras/get-help-with-keras.md

+# 在 Keras 中获得深度学习帮助的 9 种方法
+
+> 原文： [https://machinelearningmastery.com/get-help-with-keras/](https://machinelearningmastery.com/get-help-with-keras/)
+
+Keras 是一个 Python 深度学习库，可以使用高效的 Theano 或 TensorFlow 符号数学库作为后端。
+
+Keras 非常易于使用，您可以在几分钟内开发出您的第一个[多层感知器](http://machinelearningmastery.com/tutorial-first-neural-network-python-keras/)，[卷积神经网络](http://machinelearningmastery.com/handwritten-digit-recognition-using-convolutional-neural-networks-python-keras/)或 [LSTM 递归神经网络](http://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/)。
+
+当您开始使用 Keras 时，您可能会遇到技术问题。你可能需要一些帮助。
+
+在这篇文章中，您将发现 9 个地方，您可以在使用 Keras 开发深度学习模型时提出问题并获得帮助。
+
+让我们潜入。
+
+## 如何最好地使用这些资源
+
+知道在哪里获得帮助是第一步，但您需要知道如何充分利用这些资源。
+
+以下是您可以使用的一些提示：
+
+*   将您的问题简化为最简单的形式。例如。不是“_ 我的模型不起作用 _”或“ _x 如何工作 _”。
+*   在提问之前搜索答案。
+*   提供尽可能小的工作示例来演示您的问题。
+
+## 1\. Keras 用户 Google Group
+
+![Keras Users Google Group](img/1370ade3cc9bd5feb94a1be0c1c87369.jpg)
+
+Keras 用户 Google Group
+
+也许向 Keras 社区提问的最直接的地方是 Google 群组（旧的 usenet）上的 Keras Users 群组。
+
+你不需要收到电子邮件;你可以在线参加，我推荐。
+
+*   [Keras 用户谷歌集团](https://groups.google.com/forum/#!forum/keras-users)
+
+## 2\. Keras Slack Channel
+
+![Keras Slack Channel](img/07aad7228d9e13432d15e81820ae2199.jpg)
+
+Keras Slack 频道
+
+也许直接聊聊 Keras 和相关问题的最佳地点是 Keras 松弛频道。
+
+这基本上取代了 IM 和 IIRC。
+
+您必须先提交要加入的申请。
+
+*   [Keras Slack 加入表格](https://keras-slack-autojoin.herokuapp.com/)
+*   [Keras Slack Channel](https://kerasteam.slack.com/)
+
+## 凯特在吉特
+
+![Keras Gitter Group](img/95f6701c22073478af5f7e8f88aaf8b5.jpg)
+
+Keras Gitter 集团
+
+另一个聊聊 Keras 的好地方是 Keras Gitter。
+
+这就像懈怠，仍然有很多人。
+
+潜入。
+
+*   [Keras Gitter 集团](https://gitter.im/Keras-io/Lobby#)
+
+## 4\. StackOverflow 上的 Keras 标记
+
+![Keras tag on StackOverflow](img/30e6e1be6cd09de3ce9d725b9ca33188.jpg)
+
+StackOverflow 上的 Keras 标记
+
+StackOverflow 是一个致力于编程的问答网站。
+
+关于深度学习和 Keras 有很多问题或与之相关。
+
+我建议搜索并询问使用“ _keras_ ”标签的问题。
+
+*   StackOverflow 上的 [Keras 标签](https://stackoverflow.com/questions/tagged/keras)
+
+## 5.交叉验证的 Keras 标签
+
+![Keras tag on CrossValidated](img/6074ebf72c384434cedd2411d8a7f962.jpg)
+
+交叉验证的 Keras 标签
+
+CrossValidated 是一个致力于机器学习的问答网站。
+
+关于 Keras 的问题仍然存在很多问题，但它们可能有更多的理论上的弯曲，而不是关注代码和编程。
+
+同样，我建议搜索并询问使用“ _keras_ ”标签的问题。
+
+*   交叉验证上的 [Keras 标签](https://stats.stackexchange.com/questions/tagged/keras)
+
+## 6.数据科学上的 Keras 标签
+
+![Keras tag on DataScience Stack Exchange](img/e0d34ef7b223c8edb1e2ec490aa2c563.jpg)
+
+数据科学堆栈交换中的 Keras 标记
+
+支持 StackOverflow 和 CrossValidated 的 StackExchange 网络也有一个专用于 DataScience 的站点。
+
+它仍处于测试阶段，尚未成为该网络的正式成员。尽管如此，网站上还有很多关于 Keras 的问题。
+
+与其他两个站点不同，这些问题可能具有更多的流程方向。
+
+同样，我建议搜索并询问使用“ _keras_ ”标签的问题。
+
+*   [数据科学堆栈交换中的 Keras 标签](https://datascience.stackexchange.com/questions/tagged/keras)
+
+## 7\. Quora 上的 Keras 主题
+
+![Keras topic on Quora](img/1f56d629c36a38157a077936baca1aee.jpg)
+
+关于 Quora 的 Keras 主题
+
+Quora 是一个大型的通用问答网站。
+
+虽然它是通用的，但在技术主题方面存在很多问题，包括 Keras 和深度学习。
+
+问题的焦点更多是基于文本和说明性的。您可能会获得有关技术的更多详细信息，而不是实现细节。
+
+我建议在“ _Keras_ ”主题中搜索和提问。
+
+*   关于 Quora 的 [Keras 主题](https://www.quora.com/topic/Keras)
+
+## 8\. Keras Github 问题
+
+![Keras Github Issues](img/f1e85b455ad088df5051e012c2c57db8.jpg)
+
+Keras Github 问题
+
+Keras 是一个在 GitHub 上托管的开源项目。
+
+GitHub 提供了一个基本的问题管理系统，Keras 项目报告了很多问题。虽然问题应该仅限于代码的技术问题，但在这些问题上对 Keras 的讨论却令人惊讶。
+
+我建议搜索 Keras 问题，但只有在发现错误或有新功能请求时才发布问题（[请参阅指南](https://github.com/fchollet/keras/blob/master/CONTRIBUTING.md)）。
+
+*   [Keras Github 问题](https://github.com/fchollet/keras/issues)
+
+## 9\. Keras 在 Twitter 上
+
+![Keras hash tag on Twitter](img/dcf7adb1cfb7d2e4d2acfe7acb62f171.jpg)
+
+Twitter 上的 Keras 哈希标签
+
+您可以在 Twitter 上快速获得一次性 Keras 问题的答案。
+
+我建议先使用 Twitter 搜索并搜索“ _keras_ ”。
+
+我还建议使用“ _keras_ ”标签进行搜索和发布。
+
+*   Twitter 上的 [Keras 话题标签](https://twitter.com/hashtag/keras)
+
+您也可以通过关注 Keras 背后的创造者和首席开发人员，[FrançoisChollet](https://twitter.com/fchollet)来获得洞察力。
+
+## 其他 Keras 目的地
+
+以下是其他 Keras 网站，您可以在那里找到帮助。
+
+*   [Keras 官方博客](https://blog.keras.io/)
+*   [Keras API 文档](https://keras.io/)
+*   [Keras 源代码项目](https://github.com/fchollet/keras)
+
+### 摘要
+
+在这篇文章中，您在网络上发现了 9 个不同的地方，您可以在这些地方获得答案，并就 Keras 进行深入学习提问。
+
+你有没有使用过这些资源？
+你是怎么做到的？
+
+您是否有兴趣在 Keras 寻求帮助的地方？
+请在下面的评论中告诉我。
\ No newline at end of file

docs/dl-keras/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras.md

+# 如何用 Keras 进行预测
+
+> 原文： [https://machinelearningmastery.com/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/](https://machinelearningmastery.com/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/)
+
+一旦您在 Keras 中选择并适合最终的深度学习模型，您就可以使用它来对新数据实例进行预测。
+
+初学者对如何做到这一点有一些困惑。我经常看到以下问题：
+
+> 如何在 Keras 中使用我的模型进行预测？
+
+在本教程中，您将了解如何使用 Keras Python 库通过最终的深度学习模型进行分类和回归预测。
+
+完成本教程后，您将了解：
+
+*   如何最终确定模型以便为预测做好准备。
+*   如何对 Keras 中的分类问题进行类和概率预测。
+*   如何在 Keras 中进行回归预测。
+
+让我们开始吧。
+
+![How to Make Classification and Regression Predictions for Deep Learning Models in Keras](img/f0f15aa8316dd7ee6c7b1361b8727f8a.jpg)
+
+如何对 Keras 中的深度学习模型进行分类和回归预测
+[mstk east](https://www.flickr.com/photos/120248737@N03/16306796118/) 的照片，保留一些权利。
+
+## 教程概述
+
+本教程分为 3 个部分;他们是：
+
+1.  完成模型
+2.  分类预测
+3.  回归预测
+
+## 1.完成模型
+
+在进行预测之前，必须训练最终模型。
+
+您可能使用 k 折交叉验证或训练/测试分割数据来训练模型。这样做是为了让您估算模型中样本数据的技能，例如：新数据。
+
+这些模型已达到目的，现在可以丢弃。
+
+您现在必须在所有可用数据上训练最终模型。您可以在此处了解有关如何训练最终模型的更多信息：
+
+*   [如何训练最终机器学习模型](https://machinelearningmastery.com/train-final-machine-learning-model/)
+
+## 2.分类预测
+
+分类问题是模型学习输入要素和作为标签的输出要素之间的映射的问题，例如“_ 垃圾邮件 _”和“_ 不垃圾邮件 _”。
+
+下面是 Keras 中针对简单的两类（二元）分类问题开发的最终神经网络模型的示例。
+
+如果在 Keras 中开发神经网络模型对您来说是新的，请参阅帖子：
+
+*   [用 Keras 逐步开发 Python 中的第一个神经网络](https://machinelearningmastery.com/tutorial-first-neural-network-python-keras/)
+
+```
+# example of training a final classification model
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.datasets.samples_generator import make_blobs
+from sklearn.preprocessing import MinMaxScaler
+# generate 2d classification dataset
+X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
+scalar = MinMaxScaler()
+scalar.fit(X)
+X = scalar.transform(X)
+# define and fit the final model
+model = Sequential()
+model.add(Dense(4, input_dim=2, activation='relu'))
+model.add(Dense(4, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+model.compile(loss='binary_crossentropy', optimizer='adam')
+model.fit(X, y, epochs=200, verbose=0)
+```
+
+完成后，您可能希望将模型保存到文件，例如通过 Keras API。保存后，您可以随时加载模型并使用它进行预测。有关此示例，请参阅帖子：
+
+*   [保存并加载您的 Keras 深度学习模型](https://machinelearningmastery.com/save-load-keras-deep-learning-models/)
+
+为简单起见，我们将跳过本教程中的示例。
+
+我们可能希望使用最终模型进行两种类型的分类预测;它们是阶级预测和概率预测。
+
+### 阶级预测
+
+给出最终模型和一个或多个数据实例的类预测，预测数据实例的类。
+
+我们不知道新数据的结果类。这就是我们首先需要模型的原因。
+
+我们可以使用 _predict_classes（）_ 函数在 Keras 中使用我们最终的分类模型来预测新数据实例的类。请注意，此功能仅适用于 _Sequential_ 型号，而不适用于使用功能 API 开发的型号。
+
+例如，我们在名为 _Xnew_ 的数组中有一个或多个数据实例。这可以传递给我们模型上的 _predict_classes（）_ 函数，以便预测数组中每个实例的类值。
+
+```
+Xnew = [[...], [...]]
+ynew = model.predict_classes(Xnew)
+```
+
+让我们通过一个例子来具体化：
+
+```
+# example making new class predictions for a classification problem
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.datasets.samples_generator import make_blobs
+from sklearn.preprocessing import MinMaxScaler
+# generate 2d classification dataset
+X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
+scalar = MinMaxScaler()
+scalar.fit(X)
+X = scalar.transform(X)
+# define and fit the final model
+model = Sequential()
+model.add(Dense(4, input_dim=2, activation='relu'))
+model.add(Dense(4, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+model.compile(loss='binary_crossentropy', optimizer='adam')
+model.fit(X, y, epochs=500, verbose=0)
+# new instances where we do not know the answer
+Xnew, _ = make_blobs(n_samples=3, centers=2, n_features=2, random_state=1)
+Xnew = scalar.transform(Xnew)
+# make a prediction
+ynew = model.predict_classes(Xnew)
+# show the inputs and predicted outputs
+for i in range(len(Xnew)):
+	print("X=%s, Predicted=%s" % (Xnew[i], ynew[i]))
+```
+
+运行该示例预测三个新数据实例的类，然后将数据和预测一起打印。
+
+```
+X=[0.89337759 0.65864154], Predicted=[0]
+X=[0.29097707 0.12978982], Predicted=[1]
+X=[0.78082614 0.75391697], Predicted=[0]
+```
+
+如果您只有一个新的数据实例，则可以将其作为包含在数组中的实例提供给 _predict_classes（）_ 函数;例如：
+
+```
+# example making new class prediction for a classification problem
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.datasets.samples_generator import make_blobs
+from sklearn.preprocessing import MinMaxScaler
+from numpy import array
+# generate 2d classification dataset
+X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
+scalar = MinMaxScaler()
+scalar.fit(X)
+X = scalar.transform(X)
+# define and fit the final model
+model = Sequential()
+model.add(Dense(4, input_dim=2, activation='relu'))
+model.add(Dense(4, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+model.compile(loss='binary_crossentropy', optimizer='adam')
+model.fit(X, y, epochs=500, verbose=0)
+# new instance where we do not know the answer
+Xnew = array([[0.89337759, 0.65864154]])
+# make a prediction
+ynew = model.predict_classes(Xnew)
+# show the inputs and predicted outputs
+print("X=%s, Predicted=%s" % (Xnew[0], ynew[0]))
+```
+
+运行该示例将打印单个实例和预测类。
+
+```
+X=[0.89337759 0.65864154], Predicted=[0]
+```
+
+### 关于类标签的注释
+
+请注意，在准备数据时，您将把域中的类值（例如字符串）映射到整数值。您可能使用过 _[LabelEncoder](http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.LabelEncoder.html#sklearn.preprocessing.LabelEncoder)_ 。
+
+此 _LabelEncoder_ 可用于通过 _inverse_transform（）_ 函数将整数转换回字符串值。
+
+因此，您可能希望在拟合最终模型时保存（pickle）用于编码 _y_ 值的 _LabelEncoder_ 。
+
+### 概率预测
+
+您可能希望进行的另一种类型的预测是数据实例属于每个类的概率。
+
+这被称为概率预测，其中，给定新实例，模型将每个结果类的概率返回为 0 和 1 之间的值。
+
+您可以通过调用 _predict_proba（）_ 函数在 Keras 中进行这些类型的预测;例如：
+
+```
+Xnew = [[...], [...]]
+ynew = model.predict_proba(Xnew)
+```
+
+在两类（二进制）分类问题的情况下，通常在输出层中使用 S 形激活函数。预测概率被视为观察属于类 1 的可能性，或被反转（1-概率）以给出类 0 的概率。
+
+在多类分类问题的情况下，通常在输出层上使用 softmax 激活函数，并且将每个类的观察的可能性作为向量返回。
+
+以下示例对数据实例的 _Xnew_ 数组中的每个示例进行概率预测。
+
+```
+# example making new probability predictions for a classification problem
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.datasets.samples_generator import make_blobs
+from sklearn.preprocessing import MinMaxScaler
+# generate 2d classification dataset
+X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
+scalar = MinMaxScaler()
+scalar.fit(X)
+X = scalar.transform(X)
+# define and fit the final model
+model = Sequential()
+model.add(Dense(4, input_dim=2, activation='relu'))
+model.add(Dense(4, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+model.compile(loss='binary_crossentropy', optimizer='adam')
+model.fit(X, y, epochs=500, verbose=0)
+# new instances where we do not know the answer
+Xnew, _ = make_blobs(n_samples=3, centers=2, n_features=2, random_state=1)
+Xnew = scalar.transform(Xnew)
+# make a prediction
+ynew = model.predict_proba(Xnew)
+# show the inputs and predicted outputs
+for i in range(len(Xnew)):
+	print("X=%s, Predicted=%s" % (Xnew[i], ynew[i]))
+```
+
+运行实例会进行概率预测，然后打印输入数据实例以及属于类 1 的每个实例的概率。
+
+```
+X=[0.89337759 0.65864154], Predicted=[0.0087348]
+X=[0.29097707 0.12978982], Predicted=[0.82020265]
+X=[0.78082614 0.75391697], Predicted=[0.00693122]
+```
+
+如果您想向用户提供专家解释的概率，这在您的应用程序中会有所帮助。
+
+## 3.回归预测
+
+回归是一种监督学习问题，在给定输入示例的情况下，模型学习到适当输出量的映射，例如“0.1”和“0.2”等。
+
+下面是用于回归的最终 Keras 模型的示例。
+
+```
+# example of training a final regression model
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.datasets import make_regression
+from sklearn.preprocessing import MinMaxScaler
+# generate regression dataset
+X, y = make_regression(n_samples=100, n_features=2, noise=0.1, random_state=1)
+scalarX, scalarY = MinMaxScaler(), MinMaxScaler()
+scalarX.fit(X)
+scalarY.fit(y.reshape(100,1))
+X = scalarX.transform(X)
+y = scalarY.transform(y.reshape(100,1))
+# define and fit the final model
+model = Sequential()
+model.add(Dense(4, input_dim=2, activation='relu'))
+model.add(Dense(4, activation='relu'))
+model.add(Dense(1, activation='linear'))
+model.compile(loss='mse', optimizer='adam')
+model.fit(X, y, epochs=1000, verbose=0)
+```
+
+我们可以通过在最终模型上调用 _predict（）_ 函数来使用最终的回归模型预测数量。
+
+_predict（）_ 函数采用一个或多个数据实例的数组。
+
+下面的示例演示了如何对具有未知预期结果的多个数据实例进行回归预测。
+
+```
+# example of making predictions for a regression problem
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.datasets import make_regression
+from sklearn.preprocessing import MinMaxScaler
+# generate regression dataset
+X, y = make_regression(n_samples=100, n_features=2, noise=0.1, random_state=1)
+scalarX, scalarY = MinMaxScaler(), MinMaxScaler()
+scalarX.fit(X)
+scalarY.fit(y.reshape(100,1))
+X = scalarX.transform(X)
+y = scalarY.transform(y.reshape(100,1))
+# define and fit the final model
+model = Sequential()
+model.add(Dense(4, input_dim=2, activation='relu'))
+model.add(Dense(4, activation='relu'))
+model.add(Dense(1, activation='linear'))
+model.compile(loss='mse', optimizer='adam')
+model.fit(X, y, epochs=1000, verbose=0)
+# new instances where we do not know the answer
+Xnew, a = make_regression(n_samples=3, n_features=2, noise=0.1, random_state=1)
+Xnew = scalarX.transform(Xnew)
+# make a prediction
+ynew = model.predict(Xnew)
+# show the inputs and predicted outputs
+for i in range(len(Xnew)):
+	print("X=%s, Predicted=%s" % (Xnew[i], ynew[i]))
+```
+
+运行该示例会进行多次预测，然后并排打印输入和预测以供审阅。
+
+```
+X=[0.29466096 0.30317302], Predicted=[0.17097184]
+X=[0.39445118 0.79390858], Predicted=[0.7475489]
+X=[0.02884127 0.6208843 ], Predicted=[0.43370453]
+```
+
+可以使用相同的函数来对单个数据实例进行预测，只要它适当地包装在周围的列表或数组中即可。
+
+例如：
+
+```
+# example of making predictions for a regression problem
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.datasets import make_regression
+from sklearn.preprocessing import MinMaxScaler
+from numpy import array
+# generate regression dataset
+X, y = make_regression(n_samples=100, n_features=2, noise=0.1, random_state=1)
+scalarX, scalarY = MinMaxScaler(), MinMaxScaler()
+scalarX.fit(X)
+scalarY.fit(y.reshape(100,1))
+X = scalarX.transform(X)
+y = scalarY.transform(y.reshape(100,1))
+# define and fit the final model
+model = Sequential()
+model.add(Dense(4, input_dim=2, activation='relu'))
+model.add(Dense(4, activation='relu'))
+model.add(Dense(1, activation='linear'))
+model.compile(loss='mse', optimizer='adam')
+model.fit(X, y, epochs=1000, verbose=0)
+# new instance where we do not know the answer
+Xnew = array([[0.29466096, 0.30317302]])
+# make a prediction
+ynew = model.predict(Xnew)
+# show the inputs and predicted outputs
+print("X=%s, Predicted=%s" % (Xnew[0], ynew[0]))
+```
+
+运行该示例进行单个预测并打印数据实例和预测以供审阅。
+
+```
+X=[0.29466096 0.30317302], Predicted=[0.17333156]
+```
+
+## 进一步阅读
+
+如果您希望深入了解，本节将提供有关该主题的更多资源。
+
+*   [如何训练最终机器学习模型](https://machinelearningmastery.com/train-final-machine-learning-model/)
+*   [保存并加载您的 Keras 深度学习模型](https://machinelearningmastery.com/save-load-keras-deep-learning-models/)
+*   [用 Keras 逐步开发 Python 中的第一个神经网络](https://machinelearningmastery.com/tutorial-first-neural-network-python-keras/)
+*   [Keras 中长期短期记忆模型的 5 步生命周期](https://machinelearningmastery.com/5-step-life-cycle-long-short-term-memory-models-keras/)
+*   [如何用 Keras 中的长短期记忆模型进行预测](https://machinelearningmastery.com/make-predictions-long-short-term-memory-models-keras/)
+
+## 摘要
+
+在本教程中，您了解了如何使用 Keras Python 库通过最终的深度学习模型进行分类和回归预测。
+
+具体来说，你学到了：
+
+*   如何最终确定模型以便为预测做好准备。
+*   如何对 Keras 中的分类问题进行类和概率预测。
+*   如何在 Keras 中进行回归预测。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file