diff --git a/docs/dl-keras/5-step-life-cycle-neural-network-models-keras.md b/docs/dl-keras/5-step-life-cycle-neural-network-models-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..f4f93a12e5c033fd33f298566b4824175142d02b
--- /dev/null
+++ b/docs/dl-keras/5-step-life-cycle-neural-network-models-keras.md
@@ -0,0 +1,258 @@
+# 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
diff --git a/docs/dl-keras/SUMMARY.md b/docs/dl-keras/SUMMARY.md
new file mode 100644
index 0000000000000000000000000000000000000000..c3ab940f92a22050e58097071d67830db88327b1
--- /dev/null
+++ b/docs/dl-keras/SUMMARY.md
@@ -0,0 +1,46 @@
++   [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
diff --git a/docs/dl-keras/applied-deep-learning-in-python-mini-course.md b/docs/dl-keras/applied-deep-learning-in-python-mini-course.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac7a77b96f04edc1621eba387d8a148098ee6f19
--- /dev/null
+++ b/docs/dl-keras/applied-deep-learning-in-python-mini-course.md
@@ -0,0 +1,538 @@
+# 在 Python 迷你课程中应用深度学习
+
+> 原文： [https://machinelearningmastery.com/applied-deep-learning-in-python-mini-course/](https://machinelearningmastery.com/applied-deep-learning-in-python-mini-course/)
+
+深度学习是一个迷人的研究领域，这些技术在一系列具有挑战性的机器学习问题中取得了世界一流的成果。
+
+深入学习可能很难开始。
+
+您应该使用哪个库以及您应该关注哪些技术？
+
+在这篇文章中，您将发现一个由 14 部分组成的 Python 深度学习速成课程，其中包含易于使用且功能强大的 Keras 库。
+
+这个迷你课程适用于已经熟悉 SciPy 生态学机器学习的蟒蛇机器学习从业者。
+
+让我们开始吧。
+
+（**提示**：_ 你可能想打印或书签这个页面，这样你以后可以再参考它。_）
+
+*   **更新 March / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。
+
+![Applied Deep Learning in Python Mini-Course](img/2f778185ceac552e5d1ee21c4cdd45b1.jpg)
+
+在 Python 迷你课程中应用深度学习
+照片由 [darkday](https://www.flickr.com/photos/drainrat/15783392494/) 拍摄，保留一些权利。
+
+## 这个迷你课程是谁？
+
+在我们开始之前，让我们确保您在正确的位置。以下列表提供了有关本课程设计对象的一般指导原则。
+
+如果你没有完全匹配这些点，请不要惊慌，你可能只需要在一个或另一个区域刷新以跟上。
+
+*   **开发人员知道如何编写一些代码**。这意味着使用 Python 完成任务并了解如何在工作站上设置 SciPy 生态系统（先决条件）对您来说并不是什么大问题。它并不意味着你是一个向导编码器，但它确实意味着你不怕安装软件包和编写脚本。
+*   **知道一点机器学习的开发人员**。这意味着您了解机器学习的基础知识，如交叉验证，一些算法和偏差 - 方差权衡。这并不意味着你是一个机器学习博士，只是你知道地标或知道在哪里查找它们。
+
+这个迷你课程不是深度学习的教科书。
+
+它将使您从熟悉 Python 的小机器学习的开发人员到能够获得结果并将深度学习的强大功能带入您自己的项目的开发人员。
+
+## 迷你课程概述（期待什么）
+
+这个迷你课程分为 14 个部分。
+
+每节课的目的是让普通开发人员大约 30 分钟。你可能会更快完成一些，而另一些你可能会选择更深入并花更多时间。
+
+您可以根据需要快速或慢速完成每个部分。舒适的时间表可能是在两周的时间内每天完成一节课。强烈推荐。
+
+您将在接下来的 14 节课中讨论的主题如下：
+
+*   **第 01 课**：Theano 简介。
+*   **第 02 课**：TensorFlow 简介。
+*   **第 03 课**：Keras 简介。
+*   **第 04 课**：多层感知器中的速成课程。
+*   **第 05 课**：在 Keras 开发您的第一个神经网络。
+*   **第 06 课**：使用带 Scikit-Learn 的 Keras 模型。
+*   **第 07 课**：绘制模型培训历史。
+*   **第 08 课**：使用检查点在训练期间保存最佳模型。
+*   **第 09 课**：通过降压正则化减少过度拟合。
+*   **第 10 课**：通过学习率计划提升绩效。
+*   **第 11 课**：卷积神经网络中的崩溃课程。
+*   **第 12 课**：手写数字识别。
+*   **第 13 课**：小照片中的物体识别。
+*   **第 14 课**：通过数据增强改进泛化。
+
+这将是一件很有趣的事情。
+
+你将不得不做一些工作，一点点阅读，一点研究和一点点编程。你想学习深度学习吗？
+
+（**提示**：_ 这些课程的所有答案都可以在这个博客上找到，使用搜索功能 _）
+
+如有任何问题，请在下面的评论中发布。
+
+在评论中分享您的结果。
+
+挂在那里，不要放弃！
+
+## 第 01 课：Theano 简介
+
+Theano 是一个用于快速数值计算的 Python 库，有助于深度学习模型的开发。
+
+在它的核心 Theano 是 Python 中数学表达式的编译器。它知道如何使用您的结构并将它们转换为非常有效的代码，使用 NumPy 和高效的本机库在 CPU 或 GPU 上尽可能快地运行。
+
+Theano 表达式的实际语法是象征性的，这对于习惯于正常软件开发的初学者来说可能是不合适的。具体而言，表达式在抽象意义上定义，编译后实际用于进行计算。
+
+在本课程中，您的目标是安装 Theano 并编写一个小例子来演示 Theano 程序的符号性质。
+
+例如，您可以使用 pip 安装 Theano，如下所示：
+
+```
+sudo pip install Theano
+```
+
+下面列出了一个可以用作起点的 Theano 程序的小例子：
+
+```
+import theano
+from theano import tensor
+# declare two symbolic floating-point scalars
+a = tensor.dscalar()
+b = tensor.dscalar()
+# create a simple expression
+c = a + b
+# convert the expression into a callable object that takes (a,b)
+# values as input and computes a value for c
+f = theano.function([a,b], c)
+# bind 1.5 to 'a', 2.5 to 'b', and evaluate 'c'
+result = f(1.5, 2.5)
+print(result)
+```
+
+在 [Theano 主页](http://deeplearning.net/software/theano/)上了解有关 Theano 的更多信息。
+
+## 课程 02：TensorFlow 简介
+
+TensorFlow 是一个用于 Google 创建和发布的快速数值计算的 Python 库。与 Theano 一样，TensorFlow 旨在用于开发深度学习模型。
+
+在谷歌的支持下，也许在谷歌 DeepMind 研究小组的某些生产系统中使用它，它是一个我们不能忽视的平台。
+
+与 Theano 不同，TensorFlow 确实拥有更多的生产重点，能够在 CPU，GPU 甚至非常大的集群上运行。
+
+在本课程中，您的目标是安装 TensorFlow，熟悉 TensorFlow 程序中使用的符号表达式的语法。
+
+例如，您可以使用 pip 安装 TensorFlow：
+
+```
+sudo pip install TensorFlow
+```
+
+下面列出了一个可以用作起点的 TensorFlow 程序的小例子：
+
+```
+import tensorflow as tf
+# declare two symbolic floating-point scalars
+a = tf.placeholder(tf.float32)
+b = tf.placeholder(tf.float32)
+# create a simple symbolic expression using the add function
+add = tf.add(a, b)
+# bind 1.5 to ' a ' , 2.5 to ' b ' , and evaluate ' c '
+sess = tf.Session()
+binding = {a: 1.5, b: 2.5}
+c = sess.run(add, feed_dict=binding)
+print(c)
+```
+
+在 [TensorFlow 主页](https://www.tensorflow.org/)上了解有关 TensorFlow 的更多信息。
+
+## 第 03 课：Keras 简介
+
+Theano 和 TensorFlow 的难点在于它可能需要大量代码来创建甚至非常简单的神经网络模型。
+
+这些图书馆主要是作为研究和开发的平台而设计，而不是应用深度学习的实际问题。
+
+Keras 库通过为 Theano 和 TensorFlow 提供包装来解决这些问题。它提供了一个简洁的 API，允许您在几行代码中定义和评估深度学习模型。
+
+由于易于使用，并且因为它利用了 Theano 和 TensorFlow 的强大功能，Keras 很快成为应用深度学习的首选图书馆。
+
+Keras 的重点是模型的概念。模型的生命周期可归纳如下：
+
+1.  定义您的模型。创建顺序模型并添加已配置的图层。
+2.  编译您的模型。指定损失函数和优化器，并在模型上调用 compile（）
+    函数。
+3.  适合你的模特。通过调用
+    模型上的 fit（）函数，在数据样本上训练模型。
+4.  作出预测。通过调用模型上的 evaluate（）或 predict（）等函数，使用该模型生成对新数据的预测。
+
+您的本课目标是安装 Keras。
+
+例如，您可以使用 pip 安装 Keras：
+
+```
+sudo pip install keras
+```
+
+开始熟悉 Keras 库，为即将到来的课程做好准备，我们将实施我们的第一个模型。
+
+您可以在 [Keras 主页](http://keras.io/)上了解有关 Keras 库的更多信息。
+
+## 课程 04：多层感知器中的崩溃课程
+
+人工神经网络是一个迷人的研究领域，尽管它们刚开始时可能会令人生畏
+。
+
+人工神经网络领域通常被称为神经网络或多层
+Perceptrons 之后可能是最有用的神经网络类型。
+
+神经网络的构建块是人工神经元。这些是简单的计算
+单元，其具有加权输入信号并使用激活功能产生输出信号。
+
+神经元被排列成神经元网络。一行神经元称为层，一个
+网络可以有多个层。网络中神经元的体系结构通常称为网络拓扑。
+
+配置完成后，需要在数据集上训练神经网络。用于神经网络的经典且仍然优选的训练算法称为随机
+梯度下降。
+
+![Model of a Simple Neuron](img/498ab2d8740c6a44a78ade60a46c95a9.jpg)
+
+简单神经元的模型
+
+您的本课目标是熟悉神经网络术语。
+
+深入研究神经元，权重，激活函数，学习率等等。
+
+## 第 05 课：在 Keras 开发您的第一个神经网络
+
+Keras 允许您在极少数代码行中开发和评估深度学习模型。
+
+在本课程中，您的目标是使用 Keras 库开发您的第一个神经网络。
+
+使用来自 UCI 机器学习库的标准二进制（两类）分类数据集，如 [Pima Indians 糖尿病](https://archive.ics.uci.edu/ml/datasets/Pima+Indians+Diabetes)或[电离层数据集](https://archive.ics.uci.edu/ml/datasets/Ionosphere)。
+
+拼凑代码以实现以下目标：
+
+1.  使用 NumPy 或 Pandas 加载数据集。
+2.  定义您的神经网络模型并进行编译。
+3.  使模型适合数据集。
+4.  估计模型在看不见的数据上的性能。
+
+为了给您一个大规模的启动，下面是一个完整的工作示例，您可以将其作为起点。
+
+它假设您[将 Pima Indians 数据集](https://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)） 。
+
+```
+# Create first network with Keras
+from keras.models import Sequential
+from keras.layers import Dense
+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
+model.fit(X, Y, nb_epoch=150, batch_size=10)
+# evaluate the model
+scores = model.evaluate(X, Y)
+print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
+```
+
+现在，在不同的数据集上开发自己的模型，或者调整此示例。
+
+了解有关用于简单模型开发的 [Keras API 的更多信息](http://keras.io/models/sequential/)。
+
+## 第 06 课：使用 Scikit-Learn 的 Keras 模型
+
+scikit-learn 库是一个基于 SciPy 构建的 Python 通用机器学习框架。
+
+Scikit-learn 擅长评估模型性能和仅在几行代码中优化模型超参数等任务。
+
+Keras 提供了一个包装类，允许您使用 scikit-learn 的深度学习模型。例如，Keras 中的 KerasClassifier 类的实例可以包装您的深度学习模型，并在 scikit-learn 中用作 Estimator。
+
+使用 KerasClassifier 类时，必须指定该类可用于定义和编译模型的函数的名称。您还可以将其他参数传递给 KerasClassifier 类的构造函数，稍后将传递给 _model.fit（）_ 调用，例如纪元数和批量大小。
+
+在本课程中，您的目标是开发深度学习模型并使用 k 折交叉验证对其进行评估。
+
+例如，您可以定义 KerasClassifier 的实例和自定义函数来创建模型，如下所示：
+
+```
+# Function to create model, required for KerasClassifier
+def create_model():
+	# Create model
+	model = Sequential()
+	...
+	# Compile model
+	model.compile(...)
+	return model
+
+# create classifier for use in scikit-learn
+model = KerasClassifier(build_fn=create_model, nb_epoch=150, batch_size=10)
+# evaluate model using 10-fold cross validation in scikit-learn
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(model, X, Y, cv=kfold)
+```
+
+在 Sciki-Learn API 网页的 [Wrappers 上了解有关使用 Keras 深度学习模型和 scikit-learn 的更多信息。](http://keras.io/scikit-learn-api/)
+
+## 第 07 课：绘制模型培训历史
+
+您可以通过观察他们在训练期间随时间的表现来学习很多关于神经网络和深度学习模型的知识。
+
+Keras 提供了在训练深度学习模型时注册回调的功能。
+
+训练所有深度学习模型时注册的默认回调之一是历史回调。它记录每个时期的培训指标。这包括损失和准确性（对于分类问题）以及验证数据集的损失和准确性（如果已设置）。
+
+历史对象从调用返回到用于训练模型的 fit（）函数返回。度量标准存储在返回对象的历史成员中的字典中。
+
+您本课程的目标是调查历史对象并在培训期间创建模型性能图。
+
+例如，您可以打印历史记录对象收集的指标列表，如下所示：
+
+```
+# list all data in history
+history = model.fit(...)
+print(history.history.keys())
+```
+
+您可以在 Keras 中了解有关 [History 对象和回调 API 的更多信息。](http://keras.io/callbacks/#history)
+
+## 第 08 课：使用检查点在培训期间保存最佳模型
+
+应用程序检查点是一种适用于长时间运行过程的容错技术。
+
+Keras 库通过回调 API 提供检查点功能。 ModelCheckpoint
+回调类允许您定义检查模型权重的位置，文件应该如何命名
+以及在什么情况下创建模型的检查点。
+
+如果训练运行过早停止，则检查点可用于跟踪模型权重。跟踪训练期间观察到的最佳模型也很有用。
+
+在本课程中，您的目标是使用 Keras 中的 ModelCheckpoint 回调来跟踪训练期间观察到的最佳模型。
+
+您可以定义 ModelCheckpoint，每次观察到改进时，都会将网络权重保存到同一文件中。例如：
+
+```
+from keras.callbacks import ModelCheckpoint
+...
+checkpoint = ModelCheckpoint('weights.best.hdf5', monitor='val_acc', save_best_only=True, mode='max')
+callbacks_list = [checkpoint]
+# Fit the model
+model.fit(..., callbacks=callbacks_list)
+```
+
+了解有关在 Keras 中使用 [ModelCheckpoint 回调的更多信息。](http://keras.io/callbacks/#modelcheckpoint)
+
+## 第 09 课：通过压差正规化减少过度拟合
+
+神经网络的一个大问题是它们可以过度学习训练数据集。
+
+Dropout 是一种简单但非常有效的减少丢失的技术，并且已证明在大型深度学习模型中很有用。
+
+辍学是一种在训练过程中忽略随机选择的神经元的技术。他们 _ 随机掉落 _。这意味着它们对下游神经元激活的贡献在正向通过时暂时消除，并且任何重量更新都不会应用于向后通过的神经元。
+
+您可以使用 Dropout 图层类将深度学图层添加到深度学习模型中。
+
+在本课程中，您的目标是尝试在神经网络的不同点添加辍学，并设置不同的辍学值概率。
+
+例如，您可以创建一个概率为 20％的辍学图层，并将其添加到您的模型中，如下所示：
+
+```
+from keras.layers import Dropout
+...
+model.add(Dropout(0.2))
+```
+
+你可以在 Keras 中了解更多关于辍学的[。](http://keras.io/layers/core/#dropout)
+
+## 第 10 课：通过学习率计划提升绩效
+
+通过使用学习率计划，您通常可以提高模型的性能。
+
+通常称为自适应学习率或退火学习率，这是一种技术，其中随机梯度下降使用的学习率在训练模型时发生变化。
+
+Keras 具有基于时间的学习速率计划，该计划内置于 SGD 类中的随机梯度下降算法的实现中。
+
+构建类时，您可以指定衰减，即您的学习率（也指定）将减少每个时期的量。当使用学习率衰减时，你应该提高你的初始学习率并考虑增加一个大的动量值，如 0.8 或 0.9。
+
+您在本课程中的目标是尝试 Keras 内置的基于时间的学习率计划。
+
+例如，您可以指定从 0.1 开始的学习率计划，每个时期下降 0.0001，如下所示：
+
+```
+from keras.optimizers import SGD
+...
+sgd = SGD(lr=0.1, momentum=0.9, decay=0.0001, nesterov=False)
+model.compile(..., optimizer=sgd)
+```
+
+您可以在此处了解更多关于 Keras 的 [SGD 课程](http://keras.io/optimizers/#sgd)。
+
+## 第 11 课：卷积神经网络中的崩溃课程
+
+卷积神经网络是一种强大的人工神经网络技术。
+
+他们通过使用小方块输入数据学习内部特征表示来期望并保持图像中像素之间的空间关系。
+
+在整个图像中学习和使用特征，允许图像中的对象在场景中移动或平移，并且仍然可以被网络检测到。这就是为什么这种类型的网络对于照片中的对象识别，以不同方向挑选数字，面部，对象等非常有用的原因。
+
+卷积神经网络中有三种类型的层：
+
+1.  **卷积层**由滤镜和特征图组成。
+2.  **合并图层**，从特征图中下采样激活。
+3.  **完全连接的层**，它插在模型的末端，可用于进行预测。
+
+在本课中，您将熟悉描述卷积神经网络时使用的术语。
+
+这可能需要您代表一点研究。
+
+不要过分担心它们如何工作，只需学习这种网络中使用的各种层的术语和配置。
+
+## 第 12 课：手写数字识别
+
+手写数字识别是一种困难的计算机视觉分类问题。
+
+MNIST 数据集是用于评估手写数字识别问题的算法的标准问题。它包含可用于训练模型的 60,000 个数字图像，以及可用于评估其性能的 10,000 个图像。
+
+![Example MNIST images](img/256dfb575d54b2eec4be14c906ce2c11.jpg)
+
+示例 MNIST 图像
+
+使用卷积神经网络可以在 MNIST 问题上实现现有技术的结果。 Keras 使得加载 MNIST 数据集变得容易。
+
+在本课程中，您的目标是为 MNIST 问题开发一个非常简单的卷积神经网络，该问题由一个卷积层，一个最大池层和一个密集层组成，以进行预测。
+
+例如，您可以在 Keras 中加载 MNIST 数据集，如下所示：
+
+```
+from keras.datasets import mnist
+...
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+```
+
+将文件下载到您的计算机可能需要一些时间。
+
+作为提示，您将用作第一个隐藏层的 Keras [Conv2D](http://keras.io/layers/convolutional/) 层需要格式为 x 宽 x 高的格式的图像数据，其中 MNIST 数据具有 1 个通道，因为图像是灰度级的宽度和高度为 28 像素。您可以轻松地重塑 MNIST 数据集，如下所示：
+
+```
+X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
+X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
+```
+
+您还需要对输出类值进行单热编码，Keras 还提供了一个方便的辅助函数来实现：
+
+```
+from keras.utils import np_utils
+...
+y_train = np_utils.to_categorical(y_train)
+y_test = np_utils.to_categorical(y_test)
+```
+
+作为最后的提示，这里是一个模型定义，您可以将其作为起点：
+
+```
+model = Sequential()
+model.add(Conv2D(32, (3, 3), padding='valid', input_shape=(1, 28, 28),
+activation='relu'))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+model.add(Flatten())
+model.add(Dense(128, activation='relu'))
+model.add(Dense(num_classes, activation='softmax'))
+model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+```
+
+## 第 13 课：小照片中的物体识别
+
+对象识别是一个问题，您的模型必须指出照片中的内容。
+
+深度学习模型使用深度卷积神经网络在该问题中实现最先进的结果。
+
+用于评估此类问题模型的流行标准数据集称为 CIFAR-10。它包含 60,000 张小照片，每张照片都是 10 个物体中的一个，如猫，船或飞机。
+
+![Small Sample of CIFAR-10 Images](img/def90f3b9b58bf30829a905ae7da3e0d.jpg)
+
+CIFAR-10 图像的小样本
+
+与 MNIST 数据集一样，Keras 提供了一个方便的功能，您可以使用它来加载数据集，并在您第一次尝试加载数据集时将其下载到您的计算机。数据集为 163 MB，因此下载可能需要几分钟。
+
+您在本课程中的目标是为 CIFAR-10 数据集开发一个深度卷积神经网络。我建议重复模式的卷积和池图层。考虑尝试辍学和长训练时间。
+
+例如，您可以在 Keras 中加载 CIFAR-10 数据集并准备与卷积神经网络一起使用，如下所示：
+
+```
+from keras.datasets import cifar10
+from keras.utils import np_utils
+# load data
+(X_train, y_train), (X_test, y_test) = cifar10.load_data()
+# normalize inputs from 0-255 to 0.0-1.0
+X_train = X_train.astype('float32') X_test = X_test.astype('float32')
+X_train = X_train / 255.0
+X_test = X_test / 255.0
+# one hot encode outputs
+y_train = np_utils.to_categorical(y_train)
+y_test = np_utils.to_categorical(y_test)
+```
+
+## 第 14 课：通过数据扩充改进泛化
+
+使用神经网络和深度学习模型时，需要进行数据准备。
+
+更复杂的对象识别任务也需要越来越多的数据增加。这是您使用随机翻转和移位修改数据集中的图像的位置。这实质上使您的训练数据集更大，并帮助您的模型推广图像中对象的位置和方向。
+
+Keras 提供了一个图像增强 API，可以及时在数据集中创建图像的修改版本。 [ImageDataGenerator](http://keras.io/preprocessing/image/) 类可用于定义要执行的图像增强操作，这些操作可适合数据集，然后在训练模型时用于代替数据集。
+
+本课程的目标是使用您在上一课（如 MNIST 或 CIFAR-10）中熟悉的数据集来试验 Keras 图像增强 API。
+
+例如，下面的示例在 MNIST 数据集中创建最多 90 度图像的随机旋转。
+
+```
+# Random Rotations
+from keras.datasets import mnist
+from keras.preprocessing.image import ImageDataGenerator
+from matplotlib import pyplot
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# reshape to be [samples][pixels][width][height]
+X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
+X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
+# convert from int to float
+X_train = X_train.astype('float32')
+X_test = X_test.astype('float32')
+# define data preparation
+datagen = ImageDataGenerator(rotation_range=90)
+# fit parameters from data
+datagen.fit(X_train)
+# configure batch size and retrieve one batch of images
+for X_batch, y_batch in datagen.flow(X_train, y_train, batch_size=9):
+	# create a grid of 3x3 images
+	for i in range(0, 9):
+		pyplot.subplot(330 + 1 + i)
+		pyplot.imshow(X_batch[i].reshape(28, 28), cmap=pyplot.get_cmap('gray'))
+	# show the plot
+	pyplot.show()
+	break
+```
+
+您可以了解有关 [Keras 图像增强 API](http://keras.io/preprocessing/image/) 的更多信息。
+
+## 深度学习迷你课程评论
+
+恭喜你，你做到了。做得好！
+
+花点时间回顾一下你走了多远：
+
+*   您在 python 中发现了深度学习库，包括强大的数据库 Theano 和 TensorFlow 以及易于使用的 Keras 库，用于应用深度学习。
+*   您使用 Keras 构建了第一个神经网络，并学习了如何使用 scikit-learn 的深度学习模型以及如何检索和绘制模型的训练历史记录。
+*   您了解了更多高级技术，例如辍学正则化和学习速率时间表，以及如何在 Keras 中使用这些技术。
+*   最后，您进行了下一步，了解并开发了用于复杂计算机视觉任务的卷积神经网络，并了解了图像数据的增强。
+
+不要轻视这一点，你在很短的时间内走了很长的路。这只是您在 Python 中深入学习的旅程的开始。继续练习和发展你的技能。
+
+你喜欢这个迷你课吗？你有任何问题或疑点吗？
+发表评论让我知道。
\ No newline at end of file
diff --git a/docs/dl-keras/binary-classification-tutorial-with-the-keras-deep-learning-library.md b/docs/dl-keras/binary-classification-tutorial-with-the-keras-deep-learning-library.md
new file mode 100644
index 0000000000000000000000000000000000000000..6806f617c2254cdd95f0741484eaede86448047b
--- /dev/null
+++ b/docs/dl-keras/binary-classification-tutorial-with-the-keras-deep-learning-library.md
@@ -0,0 +1,267 @@
+# 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
diff --git a/docs/dl-keras/build-multi-layer-perceptron-neural-network-models-keras.md b/docs/dl-keras/build-multi-layer-perceptron-neural-network-models-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..d9c9681b534b203926d40b44d7e0e4d8c39b5aaf
--- /dev/null
+++ b/docs/dl-keras/build-multi-layer-perceptron-neural-network-models-keras.md
@@ -0,0 +1,226 @@
+# 如何用 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
diff --git a/docs/dl-keras/check-point-deep-learning-models-keras.md b/docs/dl-keras/check-point-deep-learning-models-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..03c9be66d2ceb044c8e7132d309f5747f08224f0
--- /dev/null
+++ b/docs/dl-keras/check-point-deep-learning-models-keras.md
@@ -0,0 +1,238 @@
+# 如何在 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
diff --git a/docs/dl-keras/command-line-recipes-deep-learning-amazon-web-services.md b/docs/dl-keras/command-line-recipes-deep-learning-amazon-web-services.md
new file mode 100644
index 0000000000000000000000000000000000000000..553f821a28a56a521d7a12a1dab7e0bfe6977a87
--- /dev/null
+++ b/docs/dl-keras/command-line-recipes-deep-learning-amazon-web-services.md
@@ -0,0 +1,234 @@
+# 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
diff --git a/docs/dl-keras/crash-course-convolutional-neural-networks.md b/docs/dl-keras/crash-course-convolutional-neural-networks.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a0127e9bb7adb3339cb7866e1373b3c75b24dc4
--- /dev/null
+++ b/docs/dl-keras/crash-course-convolutional-neural-networks.md
@@ -0,0 +1,169 @@
+# 机器学习卷积神经网络的速成课程
+
+> 原文： [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
diff --git a/docs/dl-keras/custom-metrics-deep-learning-keras-python.md b/docs/dl-keras/custom-metrics-deep-learning-keras-python.md
new file mode 100644
index 0000000000000000000000000000000000000000..d72f61600744b8e264a08f2670cdbf1f7e8bffcf
--- /dev/null
+++ b/docs/dl-keras/custom-metrics-deep-learning-keras-python.md
@@ -0,0 +1,291 @@
+# 如何在 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
diff --git a/docs/dl-keras/deep-learning-books.md b/docs/dl-keras/deep-learning-books.md
new file mode 100644
index 0000000000000000000000000000000000000000..aa8de8268bf84f480c87493514663197c3b724d7
--- /dev/null
+++ b/docs/dl-keras/deep-learning-books.md
@@ -0,0 +1,196 @@
+# 深度学习书籍
+
+> 原文： [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
diff --git a/docs/dl-keras/deep-learning-courses.md b/docs/dl-keras/deep-learning-courses.md
new file mode 100644
index 0000000000000000000000000000000000000000..b7096c89e3ba31f7ca9fbdc4180ade779f0eafc1
--- /dev/null
+++ b/docs/dl-keras/deep-learning-courses.md
@@ -0,0 +1,302 @@
+# 深度学习课程
+
+> 原文： [https://machinelearningmastery.com/deep-learning-courses/](https://machinelearningmastery.com/deep-learning-courses/)
+
+深入学习可能很难开始。
+
+值得庆幸的是，许多大学免费开设了深度学习课程材料，当您希望更好地理解深度学习的基础时，这可能是一个很好的启动。
+
+在这篇文章中，您将发现深度学习课程，您可以浏览和工作，以发展和巩固您对该领域的理解。
+
+这是一篇很长的帖子，可以深入链接到很多视频。它旨在为您提供书签，浏览和跨课程的特定主题，而不是选择一门课程并完成端到端的课程。
+
+让我们开始吧。
+
+## 概观
+
+我们将快速浏览以下 6 个深度学习课程。
+
+1.  牛津深度学习
+2.  谷歌深度学习 Udacity
+3.  蒙特利尔深度学习暑期学校
+4.  斯坦福大学自然语言处理的深度学习
+5.  斯坦福大学视觉识别的卷积神经网络
+6.  舍布鲁克大学的神经网络课程
+
+最后还有一个“其他课程”部分，以收集其他视频课程，这些课程不是免费的，破碎的或更小的范围，并不完全适合本摘要评审。
+
+## 课程提示和如何使用这篇文章
+
+那里有很多课程和很多很棒的免费材料。
+
+我最好的建议是：
+
+> 不要选择一门课程并通过端到端的方式完成。
+
+这与大多数人的建议相反。
+
+你的冲动将是“_ 变得严肃 _”并选择“_ 最好 _”课程并完成所有材料。你几乎肯定会失败。
+
+材料很难，你需要花时间在每个主题上获得不同的观点。
+
+真正进入这一材料的最好方法是逐个主题地学习，并从所有课程中抽取，直到你真正理解一个主题，然后再进入下一个主题。
+
+您无需了解所有主题，也无需使用单一来源来理解单个主题。
+
+将此页面添加为书签，然后在您需要时浏览，采样并深入了解您需要的材料，同时学习如何使用 [Keras](http://machinelearningmastery.com/tutorial-first-neural-network-python-keras/) 等平台在代码中实现真正的真实深度学习模型。
+
+## 牛津深度学习
+
+这是一个机器学习课程，侧重于 Nando de Freitas 在牛津大学教授的深度学习。
+
+我真的很喜欢这门课程。我在双倍时间观看了所有视频并做了笔记。它提供了理论上的良好基础，涵盖了现代深度学习主题，如 LSTM。代码示例显示在 Torch 中。
+
+&lt;iframe allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/videoseries?list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu" width="500"&gt;&lt;/iframe&gt;
+
+我注意到教学大纲与实际可用的视频讲座不同，YouTube 播放列表列出了无序的讲座，因此以下是 2015 年视频讲座的顺序。
+
+*   [深度学习讲座 1：简介](https://www.youtube.com/watch?v=PlhFWT7vAEw&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu&index=16)
+*   [深度学习讲座 2：线性模型](https://www.youtube.com/watch?v=DHspIG64CVM&index=5&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)
+*   [深度学习讲座 3：最大可能性和信息](https://www.youtube.com/watch?v=kPrHqQzCkg0&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu&index=6)
+*   [深度学习第 4 讲：正则化，模型复杂性和数据复杂性（第 1 部分）](https://www.youtube.com/watch?v=VR0W_PNwLGw&index=7&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)
+*   [深度学习第五讲：正则化，模型复杂性和数据复杂性（第 2 部分）](https://www.youtube.com/watch?v=qz9bKfOqd0Y&index=8&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)
+*   [深度学习第六讲：优化](https://www.youtube.com/watch?v=0qUAb94CpOw&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu&index=9)
+*   [深度学习第 7 讲：逻辑回归，火炬方法](https://www.youtube.com/watch?v=FYgsztDxSvE&index=11&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)
+*   [深度学习第 8 讲：模块化反向传播，逻辑回归和火炬](https://www.youtube.com/watch?v=-YRB0eFxeQA&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu&index=10)
+*   [深度学习讲座 9：Torch 中的神经网络和模块化设计](https://www.youtube.com/watch?v=NUKp0c4xb8w&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu&index=12)
+*   [深度学习讲座 10：卷积神经网络](https://www.youtube.com/watch?v=bEUX_56Lojc&index=13&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)
+*   [深度学习讲座 11：最大边缘学习，转移和记忆网络](https://www.youtube.com/watch?v=jCGplSKrl2Y&index=15&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)
+*   [深度学习讲座 12：递归神经网络和 LSTM](https://www.youtube.com/watch?v=56TYLaQN4N8&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu&index=14)
+*   [深度学习讲座 13：Alex Graves 关于 RNNs 的幻觉](https://www.youtube.com/watch?v=-yX1SYeDHbg&index=4&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)
+*   [深度学习第 14 讲：关于变分自动编码器和图像生成的 Karol Gregor](https://www.youtube.com/watch?v=P78QYjWh5sM&index=3&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)
+*   [深度学习讲座 15：深度强化学习 - 政策检索](https://www.youtube.com/watch?v=kUiR0RLmGCo&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu&index=2)
+*   [深度学习第 16 讲：强化学习和神经动态规划](https://www.youtube.com/watch?v=dV80NAlEins&index=1&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)
+
+对我来说，最重要的是 [Alex Graves](http://www.cs.toronto.edu/~graves/) 关于 RNN 的讨论（[第 13 讲](https://www.youtube.com/watch?v=-yX1SYeDHbg&index=4&list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)）。一个聪明的人做伟大的工作。我在观看这个视频的时候正在阅读很多亚历克斯的论文，所以我可能会有偏见。
+
+### 资源
+
+*   [YouTube 播放列表](https://www.youtube.com/playlist?list=PLE6Wd9FR--EfW8dtjAuPoTuPcqmOV53Fu)
+*   [课程总结和材料](http://www.cs.ox.ac.uk/teaching/courses/2014-2015/ml/)
+*   [Nando de Freitas 主页](http://www.cs.ubc.ca/~nando/)
+
+## 谷歌深度学习 Udacity
+
+这是来自 Udacity 的 [Arpan Chakraborty](https://www.linkedin.com/in/arpan-chakraborty-17688012) 和 Google 的首席科学家 [Vincent Vanhoucke](https://www.linkedin.com/in/vanhoucke) 之间的一个小型课程合作。
+
+该课程是免费的，托管在 Udacity 上，专注于 TensorFlow。它是 Udacity 上托管的[机器学习工程师 Nanodegree 的一小部分](https://www.udacity.com/course/machine-learning-engineer-nanodegree-by-google--nd009)。
+
+&lt;iframe allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/X_B9NADf2wk?feature=oembed" width="500"&gt;&lt;/iframe&gt;
+
+您必须注册 Udacity，但一旦您登录，您就可以免费访问此课程。
+
+所有课程视频都在 YouTube 上，但（有意）很难找到不良的命名和链接。如果有人知道所有视频的盗版播放列表，请在评论中发布。
+
+该课程分为 4 课：
+
+*   第 1 课：从机器学习到深度学习
+*   第 2 课：深度神经网络
+*   第 3 课：卷积神经网络
+*   第 4 课：文本和序列的深层模型
+
+该课程很短，但分为许多短视频和 Udacity 界面很好。 Vincent 似乎出现在我看过的所有视频中（这很棒），视频也显示在 YouTube 界面中。
+
+还有一个讨论表格，您可以通过光滑的[话语软件](https://www.discourse.org/)来提问和回答问题。
+
+我倾向于深入了解我感兴趣的视频，而不是完成整个课程或完成任何课程作业。
+
+### 资源
+
+*   [Udacity 深度学习课程](https://www.udacity.com/course/deep-learning--ud730)
+*   [Google 博客上的课程公告](https://research.googleblog.com/2016/01/teach-yourself-deep-learning-with.html)
+
+## 蒙特利尔深度学习暑期学校
+
+2015 年在蒙特利尔大学举办了深度学习晚餐学校。
+
+根据该网站，暑期学校的目标是研究生和工业工程师以及已经掌握机器学习基础知识的研究人员。
+
+在从入门材料到最新研究的一系列主题的深度学习领域，至少有 30 场演讲（有 30 个视频）来自着名研究人员。
+
+![Deep Learning Summer School at Montreal](img/65a7874651021d24638d4636aa14a1d4.jpg)
+
+蒙特利尔深度学习暑期学校
+
+这些视频是真正的宝库。花点时间仔细挑选您的主题。所有视频都在 VideoLectures.net 网站上托管，该网站具有足够好的界面，但不如 YouTube 干净。
+
+许多（所有？）谈话都在视频下方链接了 PDF 幻灯片，更多信息可从官方网站的日程页面获得。
+
+以下是讲座主题的完整列表，其中包含视频链接。我试图将相关视频列在一起（例如，第 1 部分，第 2 部分）。
+
+*   [机器学习简介](http://videolectures.net/deeplearning2015_vincent_machine_learning/)
+*   [深度学习：理论动机](http://videolectures.net/deeplearning2015_bengio_theoretical_motivations/)
+*   [多层神经网络](http://videolectures.net/deeplearning2015_bottou_neural_networks/)
+*   [训练深度神经网络](http://videolectures.net/deeplearning2015_larochelle_neural_networks/)
+*   [多层神经网络](http://videolectures.net/deeplearning2015_bottou_multilayer_networks/)
+*   [深度学习分布估计](http://videolectures.net/deeplearning2015_larochelle_deep_learning/)
+*   [无向图形模型](http://videolectures.net/deeplearning2015_courville_graphical_models/)
+*   [受限制的玻尔兹曼机器](http://videolectures.net/deeplearning2015_lee_boltzmann_machines/)
+*   [在歧管和自动编码器](http://videolectures.net/deeplearning2015_vincent_autoencoders/)上
+*   [视觉特征：从傅立叶到 Gabor](http://videolectures.net/deeplearning2015_memisevic_fourier_gabor/)
+*   [视觉特征 II](http://videolectures.net/deeplearning2015_memisevic_visual_features/)
+*   [卷积网络](http://videolectures.net/deeplearning2015_lee_convolutional_networks/)
+*   [学习比较](http://videolectures.net/deeplearning2015_taylor_learning_compare/)
+*   [NLP 和深度学习 1：人类语言＆amp;单词向量](http://videolectures.net/deeplearning2015_manning_language_vectors/)
+*   [NLP 和深度学习 2：成分深度学习](http://videolectures.net/deeplearning2015_manning_deep_learning/)
+*   [看到深度学习的人](http://videolectures.net/deeplearning2015_taylor_deep_learning/)
+*   [深度学习](http://videolectures.net/deeplearning2015_salakhutdinov_deep_learning/)
+*   [深度学习 2](http://videolectures.net/deeplearning2015_salakhutdinov_deep_learning_2/)
+*   [语音识别和深度学习](http://videolectures.net/deeplearning2015_coates_speech_recognition/)
+*   [神经网络优化问题教程](http://videolectures.net/deeplearning2015_goodfellow_network_optimization/)
+*   [深度学习（希望更快）](http://videolectures.net/deeplearning2015_coates_deep_learning/)
+*   [对抗性实例](http://videolectures.net/deeplearning2015_goodfellow_adversarial_examples/)
+*   [从语言建模到机器翻译](http://videolectures.net/deeplearning2015_blunsom_machine_translation/)
+*   [深 NLP 递归神经网络](http://videolectures.net/deeplearning2015_socher_deep_nlp/)
+*   [Deep NLP 应用程序和动态内存网络](http://videolectures.net/deeplearning2015_socher_nlp_applications/)
+*   [记忆，阅读和理解](http://videolectures.net/deeplearning2015_blunsom_memory_reading/)
+*   [平滑，有限和凸优化深度学习暑期学校](http://videolectures.net/deeplearning2015_schmidt_smooth_finite/)
+*   [非平滑，非有限和非凸优化](http://videolectures.net/deeplearning2015_schmidt_nonsmooth_nonfinite/)
+*   [变分自动编码器和扩展](http://videolectures.net/deeplearning2015_courville_autoencoder_extension/)
+*   [深度生成模型](http://videolectures.net/deeplearning2015_bengio_generative_models/)
+
+选择一个主题并潜入。非常好！
+
+看起来[会有一个 2016 暑期学校](https://sites.google.com/site/deeplearningsummerschool2016/)，希望会有视频。
+
+### 资源
+
+*   [深度学习暑期学校官方网站](https://sites.google.com/site/deeplearningsummerschool/schedule)
+*   [深度学习暑期学校视频](http://videolectures.net/deeplearning2015_montreal/)
+
+## 斯坦福大学自然语言处理的深度学习
+
+这是一个深度学习课程，重点是斯坦福大学 [Richard Socher](http://www.socher.org/) 教授的自然语言处理（NLP）。
+
+一个有趣的说明是，您可以访问 PDF 版本的学生报告，这些工作可能会激发您的灵感或给您提供想法。
+
+&lt;iframe allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/videoseries?list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q" width="500"&gt;&lt;/iframe&gt;
+
+YouTube 播放列表的文件名称很差，而且有些缺少讲座。 2016 年的视频尚未全部上传。以下是 2015 年讲座和视频链接的列表。只是跳进一个特定主题就容易多了。
+
+*   [讲座 1：NLP 和深度学习简介](https://www.youtube.com/watch?v=sU_Yu_USrNc&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=1)
+*   [第 2 讲：简单的单词矢量表示：word2vec，GloVe](https://www.youtube.com/watch?v=T8tQZChniMk&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=2)
+*   [第 3 讲：高级单词矢量表示：语言模型，softmax，单层网络](https://www.youtube.com/watch?v=T1j2Q9_FgTM&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=3)
+*   [第 4 讲：词窗分类和神经网络](https://www.youtube.com/watch?v=MRH9ABxCUZ0&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=4)
+*   [第五讲：项目建议，神经网络和反支柱（全部详细信息）](https://www.youtube.com/watch?v=I2TfdXfSOfc&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=5)
+*   [第六讲：实用技巧：梯度检查，过度拟合，正则化，激活功能，细节](https://www.youtube.com/watch?v=DTbI7XisZcQ&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=6)
+*   [第 7 讲：用于语言建模和其他任务的循环神经网络](https://www.youtube.com/watch?v=rFVYTydGLr4&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=7)
+*   [第 7 讲（8！？）：用于机器翻译的 GRU 和 LSTM](https://www.youtube.com/watch?v=OFCuW8VA7A4&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=8)
+*   [第 9 讲：解析](https://www.youtube.com/watch?v=DJHvaGU9SW8&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=9)的递归神经网络
+*   [第 10 讲：针对不同任务的递归神经网络（例如情绪分析）](https://www.youtube.com/watch?v=sVXp0UwheXw&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=10)
+*   [第 11 讲：期中考试](https://www.youtube.com/watch?v=HYLZCCX4q5o&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=13)
+*   [第 13 讲：用于句子分类的卷积神经网络](https://www.youtube.com/watch?v=EevTPpQvxiU&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=11)
+*   [第 15 讲：DL 对 NLP 的应用](https://www.youtube.com/watch?v=BVbQRrrsJo0&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=12)
+*   [与 Andrew Maas 的客座讲座：语音识别](https://www.youtube.com/watch?v=6D8_4GkEWUg&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=14)
+*   [与杰森韦斯顿的客座讲座：记忆网络](https://www.youtube.com/watch?v=Xumy3Yjq4zk&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=15)
+*   [与 Elliot 英语的客座讲座：高效的实现和 GPU](https://www.youtube.com/watch?v=8Uxe8umUDYA&list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q&index=16)
+
+如果您正在深入学习 NLP 这是一个非常优秀的领域，这是一个很好的材料。
+
+### 资源
+
+*   [CS224d：自然语言处理的深度学习主页](http://cs224d.stanford.edu/)
+*   [课程大纲](http://cs224d.stanford.edu/syllabus.html)
+*   [2015 年课程视频播放列表](https://www.youtube.com/playlist?list=PLmImxx8Char8dxWB9LRqdpCTmewaml96q)
+*   [2016 年课程视频播放列表](https://www.youtube.com/playlist?list=PLXqezZ11Vm4pzLnhV3bZflqaNNBm9uFUb)
+
+## 斯坦福大学视觉识别的卷积神经网络
+
+本课程重点介绍使用卷积神经网络对计算机视觉应用进行深度学习。
+
+这是斯坦福大学的另一门课程，这次由 Andrej Karpathy 和其他人讲授。
+
+不幸的是，课程视频被删除了，但是一些聪明的人已经找到了将它们放回其他地方的方法。请参阅下面资源部分中的播放列表。
+
+> 我很遗憾地告诉我们，由于法律问题，我们被迫删除了 CS231n 视频。只有 1/4 百万的社会观点受益
+> 
+> - Andrej Karpathy（@karpathy） [2016 年 5 月 3 日](https://twitter.com/karpathy/status/727618058471112704)
+
+另一个很棒的课程
+
+以下是 2016 年课程的视频讲座，但我不确定这些链接会持续多长时间。发表评论让我知道如果你发现链接变坏了我会解决它们。
+
+*   [第 1 讲引言及历史背景](https://www.youtube.com/watch?v=F-g0-6_RRUA&index=1&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [第 2 讲数据驱动方法，kNN，线性分类 1](https://www.youtube.com/watch?v=ZM4umP6F1Jc&index=2&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [第 3 讲线性分类 2，优化](https://www.youtube.com/watch?v=Q_UWHTY_TEQ&index=4&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [讲座 4 反向传播，神经网络 1](https://www.youtube.com/watch?v=jhUZ800C650&index=5&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [第 5 讲神经网络第 2 部分](https://www.youtube.com/watch?v=jhUZ800C650&index=5&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [讲座 6 神经网络第 3 部分卷入介绍](https://www.youtube.com/watch?v=egPTd9zZzec&index=6&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [讲座 7 卷积神经网络](https://www.youtube.com/watch?v=sHyIqu_S5Ks&index=7&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [第 8 讲定位和检测](https://www.youtube.com/watch?v=sHyIqu_S5Ks&index=7&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [第 9 讲可视化，深度梦想，神经风格，对抗性实例](https://www.youtube.com/watch?v=ASdbG_7KMhc&index=9&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [讲座 10 回归神经网络，图像字幕，LSTM](https://www.youtube.com/watch?v=R1rXkuJ5w20&index=10&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [第 11 讲实践中的讲座](https://www.youtube.com/watch?v=G3m6HusAJTg&index=11&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [第 12 讲深度学习图书馆](https://www.youtube.com/watch?v=b6RntuTiKQo&index=12&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [第 13 讲分段，软注意，空间变换器](https://www.youtube.com/watch?v=yCrkzVFsEX0&index=13&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [讲座 14 视频和无监督学习](https://www.youtube.com/watch?v=k645B_f4a6Y&index=14&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [第 15 讲由 Jeff Dean 邀请演讲](https://www.youtube.com/watch?v=qtm4JgbxuEc&index=15&list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+
+### 资源
+
+*   [用于视觉识别的卷积神经网络主页](http://cs231n.stanford.edu/)
+*   [课程大纲](http://cs231n.stanford.edu/syllabus.html)（以及 [2015 年教学大纲](http://cs231n.stanford.edu/syllabus_winter2015.html)）
+*   [Archive.org 上的课程视频](https://archive.org/details/cs231n-CNNs)
+*   [YouTube 上的课程视频](https://www.youtube.com/playlist?list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)
+*   [课程示例代码](https://github.com/cs231n/cs231n.github.io)
+
+## 舍布鲁克大学的神经网络课程
+
+这是由魁北克舍布鲁克大学的 Hugo Larochelle 教授的神经网络课程。
+
+有大量的材料。一吨。
+
+视频是一对一而不是讲座，每个主题都有许多小视频，而不是大型的一小时信息转储。
+
+&lt;iframe allowfullscreen="" frameborder="0" height="375" src="https://www.youtube.com/embed/videoseries?list=PL6Xpj9I5qXYEcOhn7TqghAJ6NAPrNmUBH" width="500"&gt;&lt;/iframe&gt;
+
+我认为这可能是比传统讲座更好的格式，但我还没有完全胜过。困难的是有 92 个视频（!!!）可供浏览，很难找到要观看的特定视频。
+
+教材包括 10 个主题：
+
+*   主题 1：前馈神经网络
+*   主题 2：训练神经网络
+*   主题 3：条件随机字段
+*   主题 4：训练条件随机字段
+*   主题 5：受限制的玻尔兹曼机器
+*   主题 6：自动编码器
+*   主题 7：深度学习
+*   主题 8：稀疏编码
+*   主题 9：计算机视觉
+*   主题 10：自然语言处理
+
+我的建议是使用主菜单主页浏览主题，然后将这些链接用于特定视频。 YouTube 播放列表中有太多视频无法浏览和理解。选择的悖论会杀了你。
+
+### 资源
+
+*   [课程主页](http://info.usherbrooke.ca/hlarochelle/neural_networks/content.html)
+*   [YouTube 视频播放列表](https://www.youtube.com/playlist?list=PL6Xpj9I5qXYEcOhn7TqghAJ6NAPrNmUBH)
+
+## 其他课程
+
+以下是一些非免费，难以访问或范围较小的视频课程。
+
+*   [CILVR Lab @ NYU](http://cilvr.cs.nyu.edu/doku.php?id=deeplearning:slides:start) 的深度学习课程（断开的链接？）
+*   [Udemy](https://www.udemy.com/courses/search/?q=deep+learning&lang=en) 的小型深度学习课程
+*   [CMU 的深度学习](http://deeplearning.cs.cmu.edu/)
+*   [用于深度学习的 Nvidia 自学课程](https://developer.nvidia.com/deep-learning-courses)
+*   [多伦多大学 Coursera 机器学习神经网络](https://www.coursera.org/learn/neural-networks)（太棒了，但不再免费）
+    *   **更新**：[您可以在这里免费观看所有视频](https://www.youtube.com/playlist?list=PLoRl3Ht4JOcdU872GhiYWf6jwrk_SNhz9)。
+*   [研究生暑期学校：深度学习，特色学习](http://www.ipam.ucla.edu/programs/summer-schools/graduate-summer-school-deep-learning-feature-learning/?tab=schedule)，2012
+
+## 摘要
+
+在这篇文章中，您发现了许多关于深度学习的世界级视频课程，包括理论，理论，计算机视觉，自然语言处理等。
+
+注意这篇文章顶部的建议。
+
+按主题浏览并深入讲座，不要尝试整个课程。学习一件事，而不是尝试学习一切。
+
+花点时间，为此页面添加书签，以便您可以回来，享受乐趣。
+
+你知道我还没有列出其他深度学习的视频课程吗？
+请在评论中告诉我，我会更新清单。
\ No newline at end of file
diff --git a/docs/dl-keras/deep-learning-for-developers.md b/docs/dl-keras/deep-learning-for-developers.md
new file mode 100644
index 0000000000000000000000000000000000000000..f70925b9d02190df78b1d3fa4c8b1f9c7ff4ff2c
--- /dev/null
+++ b/docs/dl-keras/deep-learning-for-developers.md
@@ -0,0 +1,276 @@
+# 你所知道的深度学习是一种谎言
+
+> 原文： [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
diff --git a/docs/dl-keras/develop-evaluate-large-deep-learning-models-keras-amazon-web-services.md b/docs/dl-keras/develop-evaluate-large-deep-learning-models-keras-amazon-web-services.md
new file mode 100644
index 0000000000000000000000000000000000000000..ebcca9f557a1d5fb726101b106c64e4eb2dfc860
--- /dev/null
+++ b/docs/dl-keras/develop-evaluate-large-deep-learning-models-keras-amazon-web-services.md
@@ -0,0 +1,226 @@
+# 如何设置 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
diff --git a/docs/dl-keras/difference-between-a-batch-and-an-epoch.md b/docs/dl-keras/difference-between-a-batch-and-an-epoch.md
new file mode 100644
index 0000000000000000000000000000000000000000..a5f2204ef672f060fc2b2f018f6edf94187ee979
--- /dev/null
+++ b/docs/dl-keras/difference-between-a-batch-and-an-epoch.md
@@ -0,0 +1,159 @@
+# 神经网络中批处理和历元之间的区别是什么？
+
+> 原文： [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
diff --git a/docs/dl-keras/display-deep-learning-model-training-history-in-keras.md b/docs/dl-keras/display-deep-learning-model-training-history-in-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..45c3404475753560f2502a12b5428836fa9d1dcb
--- /dev/null
+++ b/docs/dl-keras/display-deep-learning-model-training-history-in-keras.md
@@ -0,0 +1,126 @@
+# 在 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
diff --git a/docs/dl-keras/dropout-regularization-deep-learning-models-keras.md b/docs/dl-keras/dropout-regularization-deep-learning-models-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..019df6f5575145121b78ae5cadd74643f3bf74df
--- /dev/null
+++ b/docs/dl-keras/dropout-regularization-deep-learning-models-keras.md
@@ -0,0 +1,218 @@
+# 基于 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
diff --git a/docs/dl-keras/evaluate-performance-deep-learning-models-keras.md b/docs/dl-keras/evaluate-performance-deep-learning-models-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..efaa241925e4927cfc3cbd5a7014a586b2c9c21a
--- /dev/null
+++ b/docs/dl-keras/evaluate-performance-deep-learning-models-keras.md
@@ -0,0 +1,227 @@
+# 评估 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
diff --git a/docs/dl-keras/evaluate-skill-deep-learning-models.md b/docs/dl-keras/evaluate-skill-deep-learning-models.md
new file mode 100644
index 0000000000000000000000000000000000000000..64609af46f4654b7965973f5e64cdf5b140c4842
--- /dev/null
+++ b/docs/dl-keras/evaluate-skill-deep-learning-models.md
@@ -0,0 +1,208 @@
+# 如何评价深度学习模式的技巧
+
+> 原文： [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)。
+
+这是我推荐的估算深度学习模型技能的程序。
+
+因为重复通常&gt; = 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
diff --git a/docs/dl-keras/gentle-introduction-mini-batch-gradient-descent-configure-batch-size.md b/docs/dl-keras/gentle-introduction-mini-batch-gradient-descent-configure-batch-size.md
new file mode 100644
index 0000000000000000000000000000000000000000..3816294b40336dc6eb85a602c13276a4747cb629
--- /dev/null
+++ b/docs/dl-keras/gentle-introduction-mini-batch-gradient-descent-configure-batch-size.md
@@ -0,0 +1,189 @@
+# 微型批量梯度下降的简要介绍以及如何配置批量大小
+
+> 原文： [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
diff --git a/docs/dl-keras/get-help-with-keras.md b/docs/dl-keras/get-help-with-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..2b980ff2b8ffe6aab62e6aef43e7f9fdfab0516b
--- /dev/null
+++ b/docs/dl-keras/get-help-with-keras.md
@@ -0,0 +1,172 @@
+# 在 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
diff --git a/docs/dl-keras/grid-search-hyperparameters-deep-learning-models-python-keras.md b/docs/dl-keras/grid-search-hyperparameters-deep-learning-models-python-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..b63cd5b9c43f1a0516c13731e0b6c869aeadaa22
--- /dev/null
+++ b/docs/dl-keras/grid-search-hyperparameters-deep-learning-models-python-keras.md
@@ -0,0 +1,724 @@
+# 如何使用 Keras 进行 Python 中深度学习模型的网格搜索超参数
+
+> 原文： [https://machinelearningmastery.com/grid-search-hyperparameters-deep-learning-models-python-keras/](https://machinelearningmastery.com/grid-search-hyperparameters-deep-learning-models-python-keras/)
+
+超参数优化是深度学习的重要组成部分。
+
+原因是神奇网络众所周知难以配置，并且需要设置许多参数。最重要的是，单个模型的训练速度可能非常慢。
+
+在这篇文章中，您将了解如何使用 scikit-learn python 机器学习库中的网格搜索功能来调整 Keras 深度学习模型的超参数。
+
+阅读这篇文章后你会知道：
+
+*   如何包装 Keras 模型用于 scikit-learn 以及如何使用网格搜索。
+*   如何网格搜索常见的神经网络参数，如学习率，辍学率，时期和神经元数量。
+*   如何在自己的项目中定义自己的超参数调整实验。
+
+让我们开始吧。
+
+*   **2016 年 11 月更新**：修复了在代码示例中显示网格搜索结果的小问题。
+*   **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 的示例。
+*   **2017 年 9 月更新**：更新了使用 Keras 2“epochs”代替 Keras 1“nb_epochs”的示例。
+*   **更新 March / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。
+
+![How to Grid Search Hyperparameters for Deep Learning Models in Python With Keras](img/4ae90ba8e51222dd47048dad32a96128.jpg)
+
+如何使用 Keras 网格搜索 Python 中深度学习模型的超参数
+照片由 [3V Photo](https://www.flickr.com/photos/107439982@N02/10635372184/) ，保留一些权利。
+
+## 概观
+
+在这篇文章中，我想向您展示如何使用 scikit-learn 网格搜索功能，并为您提供一组示例，您可以将这些示例复制并粘贴到您自己的项目中作为起点。
+
+以下是我们将要讨论的主题列表：
+
+1.  如何在 scikit-learn 中使用 Keras 模型。
+2.  如何在 scikit-learn 中使用网格搜索。
+3.  如何调整批量大小和训练时期。
+4.  如何调整优化算法。
+5.  如何调整学习率和动力。
+6.  如何调整网络权重初始化。
+7.  如何调整激活功能。
+8.  如何调整退出正则化。
+9.  如何调整隐藏层中的神经元数量。
+
+## 如何在 scikit-learn 中使用 Keras 模型
+
+Keras 模型可以通过使用 **KerasClassifier** 或 **KerasRegressor** 类包装来用于 scikit-learn。
+
+要使用这些包装器，您必须定义一个创建并返回 Keras 顺序模型的函数，然后在构造 **KerasClassifier** 类时将此函数传递给 **build_fn** 参数。
+
+例如：
+
+```
+def create_model():
+	...
+	return model
+
+model = KerasClassifier(build_fn=create_model)
+```
+
+**KerasClassifier** 类的构造函数可以使用传递给 **model.fit（）**的调用的默认参数，例如纪元数和批量大小。
+
+例如：
+
+```
+def create_model():
+	...
+	return model
+
+model = KerasClassifier(build_fn=create_model, epochs=10)
+```
+
+**KerasClassifier** 类的构造函数也可以获取可以传递给自定义 **create_model（）**函数的新参数。这些新参数也必须在 **create_model（）**函数的签名中使用默认参数进行定义。
+
+例如：
+
+```
+def create_model(dropout_rate=0.0):
+	...
+	return model
+
+model = KerasClassifier(build_fn=create_model, dropout_rate=0.2)
+```
+
+您可以在 Keras API 文档中了解有关 [scikit-learn 包装器的更多信息。](http://keras.io/scikit-learn-api/)
+
+## 如何在 scikit-learn 中使用网格搜索
+
+网格搜索是一种模型超参数优化技术。
+
+在 scikit-learn 中，这种技术在 **GridSearchCV** 类中提供。
+
+构造此类时，必须提供一个超参数字典，以便在 **param_grid** 参数中进行评估。这是模型参数名称的映射和要尝试的值数组。
+
+默认情况下，精度是优化的分数，但其他分数可以在 **GridSearchCV** 构造函数的**得分**参数中指定。
+
+默认情况下，网格搜索仅使用一个线程。通过将 **GridSearchCV** 构造函数中的 **n_jobs** 参数设置为-1，该进程将使用计算机上的所有核心。根据您的 Keras 后端，这可能会干扰主要的神经网络训练过程。
+
+然后， **GridSearchCV** 过程将为每个参数组合构建和评估一个模型。交叉验证用于评估每个单独的模型，并使用默认的 3 倍交叉验证，尽管可以通过指定 **GridSearchCV** 构造函数的 **cv** 参数来覆盖它。
+
+下面是定义简单网格搜索的示例：
+
+```
+param_grid = dict(epochs=[10,20,30])
+grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
+grid_result = grid.fit(X, Y)
+```
+
+完成后，您可以在 **grid.fit（）**返回的结果对象中访问网格搜索的结果。 **best_score_** 成员提供对优化过程中观察到的最佳分数的访问， **best_params_** 描述了获得最佳结果的参数组合。
+
+您可以在 scikit-learn API 文档中了解有关 [GridSearchCV 类的更多信息。](http://scikit-learn.org/stable/modules/generated/sklearn.grid_search.GridSearchCV.html#sklearn.grid_search.GridSearchCV)
+
+## 问题描述
+
+既然我们知道如何使用 scras 模型学习 keras 模型以及如何在 scikit-learn 中使用网格搜索，那么让我们看看一堆例子。
+
+所有例子都将在一个名为 [Pima Indians 糖尿病分类数据集](http://archive.ics.uci.edu/ml/datasets/Pima+Indians+Diabetes)的小型标准机器学习数据集上进行演示。这是一个包含所有数字属性的小型数据集，易于使用。
+
+1.  [下载数据集](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)）。
+
+在我们继续本文中的示例时，我们将汇总最佳参数。这不是网格搜索的最佳方式，因为参数可以交互，但它有利于演示目的。
+
+### 并行化网格搜索的注意事项
+
+所有示例都配置为使用并行性（ **n_jobs = -1** ）。
+
+如果您收到如下错误：
+
+```
+INFO (theano.gof.compilelock): Waiting for existing lock by process '55614' (I am process '55613')
+INFO (theano.gof.compilelock): To manually release the lock, delete ...
+```
+
+终止进程并更改代码以不并行执行网格搜索，设置 **n_jobs = 1** 。
+
+## 如何调整批量大小和时期数量
+
+在第一个简单的例子中，我们考虑调整批量大小和适合网络时使用的时期数。
+
+[迭代梯度下降](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Iterative_method)中的批量大小是在更新权重之前向网络显示的模式数。它也是网络训练的优化，定义了一次读取多少个模式并保留在内存中。
+
+时期数是训练期间整个训练数据集显示给网络的次数。一些网络对批量大小敏感，例如 LSTM 递归神经网络和卷积神经网络。
+
+在这里，我们将评估一套不同的迷你批量大小，从 10 到 100，步长为 20。
+
+完整的代码清单如下。
+
+```
+# Use scikit-learn to grid search the batch size and epochs
+import numpy
+from sklearn.model_selection import GridSearchCV
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+# Function to create model, required for KerasClassifier
+def create_model():
+	# create model
+	model = Sequential()
+	model.add(Dense(12, input_dim=8, activation='relu'))
+	model.add(Dense(1, activation='sigmoid'))
+	# Compile model
+	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load 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 = KerasClassifier(build_fn=create_model, verbose=0)
+# define the grid search parameters
+batch_size = [10, 20, 40, 60, 80, 100]
+epochs = [10, 50, 100]
+param_grid = dict(batch_size=batch_size, epochs=epochs)
+grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
+grid_result = grid.fit(X, Y)
+# summarize results
+print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
+means = grid_result.cv_results_['mean_test_score']
+stds = grid_result.cv_results_['std_test_score']
+params = grid_result.cv_results_['params']
+for mean, stdev, param in zip(means, stds, params):
+    print("%f (%f) with: %r" % (mean, stdev, param))
+```
+
+运行此示例将生成以下输出。
+
+```
+Best: 0.686198 using {'epochs': 100, 'batch_size': 20}
+0.348958 (0.024774) with: {'epochs': 10, 'batch_size': 10}
+0.348958 (0.024774) with: {'epochs': 50, 'batch_size': 10}
+0.466146 (0.149269) with: {'epochs': 100, 'batch_size': 10}
+0.647135 (0.021236) with: {'epochs': 10, 'batch_size': 20}
+0.660156 (0.014616) with: {'epochs': 50, 'batch_size': 20}
+0.686198 (0.024774) with: {'epochs': 100, 'batch_size': 20}
+0.489583 (0.075566) with: {'epochs': 10, 'batch_size': 40}
+0.652344 (0.019918) with: {'epochs': 50, 'batch_size': 40}
+0.654948 (0.027866) with: {'epochs': 100, 'batch_size': 40}
+0.518229 (0.032264) with: {'epochs': 10, 'batch_size': 60}
+0.605469 (0.052213) with: {'epochs': 50, 'batch_size': 60}
+0.665365 (0.004872) with: {'epochs': 100, 'batch_size': 60}
+0.537760 (0.143537) with: {'epochs': 10, 'batch_size': 80}
+0.591146 (0.094954) with: {'epochs': 50, 'batch_size': 80}
+0.658854 (0.054904) with: {'epochs': 100, 'batch_size': 80}
+0.402344 (0.107735) with: {'epochs': 10, 'batch_size': 100}
+0.652344 (0.033299) with: {'epochs': 50, 'batch_size': 100}
+0.542969 (0.157934) with: {'epochs': 100, 'batch_size': 100}
+```
+
+我们可以看到，20 和 100 个时期的批量大小达到了 68％准确度的最佳结果。
+
+## 如何调整训练优化算法
+
+Keras 提供一套不同的最先进的优化算法。
+
+在此示例中，我们调整用于训练网络的优化算法，每个算法都使用默认参数。
+
+这是一个奇怪的例子，因为通常您会先选择一种方法，而是专注于调整问题的参数（例如，参见下一个例子）。
+
+在这里，我们将评估 Keras API 支持的[优化算法套件。](http://keras.io/optimizers/)
+
+完整的代码清单如下。
+
+```
+# Use scikit-learn to grid search the batch size and epochs
+import numpy
+from sklearn.model_selection import GridSearchCV
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+# Function to create model, required for KerasClassifier
+def create_model(optimizer='adam'):
+	# create model
+	model = Sequential()
+	model.add(Dense(12, input_dim=8, activation='relu'))
+	model.add(Dense(1, activation='sigmoid'))
+	# Compile model
+	model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
+	return model
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load 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 = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
+# define the grid search parameters
+optimizer = ['SGD', 'RMSprop', 'Adagrad', 'Adadelta', 'Adam', 'Adamax', 'Nadam']
+param_grid = dict(optimizer=optimizer)
+grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
+grid_result = grid.fit(X, Y)
+# summarize results
+print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
+means = grid_result.cv_results_['mean_test_score']
+stds = grid_result.cv_results_['std_test_score']
+params = grid_result.cv_results_['params']
+for mean, stdev, param in zip(means, stds, params):
+    print("%f (%f) with: %r" % (mean, stdev, param))
+```
+
+运行此示例将生成以下输出。
+
+```
+Best: 0.704427 using {'optimizer': 'Adam'}
+0.348958 (0.024774) with: {'optimizer': 'SGD'}
+0.348958 (0.024774) with: {'optimizer': 'RMSprop'}
+0.471354 (0.156586) with: {'optimizer': 'Adagrad'}
+0.669271 (0.029635) with: {'optimizer': 'Adadelta'}
+0.704427 (0.031466) with: {'optimizer': 'Adam'}
+0.682292 (0.016367) with: {'optimizer': 'Adamax'}
+0.703125 (0.003189) with: {'optimizer': 'Nadam'}
+```
+
+结果表明 ADAM 优化算法是最好的，准确度大约为 70％。
+
+## 如何调整学习率和动量
+
+通常预先选择优化算法来训练您的网络并调整其参数。
+
+到目前为止，最常见的优化算法是普通的老式[随机梯度下降](http://keras.io/optimizers/#sgd)（SGD），因为它非常清楚。在这个例子中，我们将研究优化 SGD 学习速率和动量参数。
+
+学习率控制在每批结束时更新权重的程度，并且动量控制让先前更新影响当前重量更新的程度。
+
+我们将尝试一套小的标准学习率和 0.2 到 0.8 的动量值，步长为 0.2，以及 0.9（因为它在实践中可能是一个受欢迎的价值）。
+
+通常，在这样的优化中也包括时期的数量是个好主意，因为每批学习量（学习率），每个时期的更新数量（批量大小）和数量之间存在依赖关系。时代。
+
+完整的代码清单如下。
+
+```
+# Use scikit-learn to grid search the learning rate and momentum
+import numpy
+from sklearn.model_selection import GridSearchCV
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+from keras.optimizers import SGD
+# Function to create model, required for KerasClassifier
+def create_model(learn_rate=0.01, momentum=0):
+	# create model
+	model = Sequential()
+	model.add(Dense(12, input_dim=8, activation='relu'))
+	model.add(Dense(1, activation='sigmoid'))
+	# Compile model
+	optimizer = SGD(lr=learn_rate, momentum=momentum)
+	model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
+	return model
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load 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 = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
+# define the grid search parameters
+learn_rate = [0.001, 0.01, 0.1, 0.2, 0.3]
+momentum = [0.0, 0.2, 0.4, 0.6, 0.8, 0.9]
+param_grid = dict(learn_rate=learn_rate, momentum=momentum)
+grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
+grid_result = grid.fit(X, Y)
+# summarize results
+print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
+means = grid_result.cv_results_['mean_test_score']
+stds = grid_result.cv_results_['std_test_score']
+params = grid_result.cv_results_['params']
+for mean, stdev, param in zip(means, stds, params):
+    print("%f (%f) with: %r" % (mean, stdev, param))
+```
+
+运行此示例将生成以下输出。
+
+```
+Best: 0.680990 using {'learn_rate': 0.01, 'momentum': 0.0}
+0.348958 (0.024774) with: {'learn_rate': 0.001, 'momentum': 0.0}
+0.348958 (0.024774) with: {'learn_rate': 0.001, 'momentum': 0.2}
+0.467448 (0.151098) with: {'learn_rate': 0.001, 'momentum': 0.4}
+0.662760 (0.012075) with: {'learn_rate': 0.001, 'momentum': 0.6}
+0.669271 (0.030647) with: {'learn_rate': 0.001, 'momentum': 0.8}
+0.666667 (0.035564) with: {'learn_rate': 0.001, 'momentum': 0.9}
+0.680990 (0.024360) with: {'learn_rate': 0.01, 'momentum': 0.0}
+0.677083 (0.026557) with: {'learn_rate': 0.01, 'momentum': 0.2}
+0.427083 (0.134575) with: {'learn_rate': 0.01, 'momentum': 0.4}
+0.427083 (0.134575) with: {'learn_rate': 0.01, 'momentum': 0.6}
+0.544271 (0.146518) with: {'learn_rate': 0.01, 'momentum': 0.8}
+0.651042 (0.024774) with: {'learn_rate': 0.01, 'momentum': 0.9}
+0.651042 (0.024774) with: {'learn_rate': 0.1, 'momentum': 0.0}
+0.651042 (0.024774) with: {'learn_rate': 0.1, 'momentum': 0.2}
+0.572917 (0.134575) with: {'learn_rate': 0.1, 'momentum': 0.4}
+0.572917 (0.134575) with: {'learn_rate': 0.1, 'momentum': 0.6}
+0.651042 (0.024774) with: {'learn_rate': 0.1, 'momentum': 0.8}
+0.651042 (0.024774) with: {'learn_rate': 0.1, 'momentum': 0.9}
+0.533854 (0.149269) with: {'learn_rate': 0.2, 'momentum': 0.0}
+0.427083 (0.134575) with: {'learn_rate': 0.2, 'momentum': 0.2}
+0.427083 (0.134575) with: {'learn_rate': 0.2, 'momentum': 0.4}
+0.651042 (0.024774) with: {'learn_rate': 0.2, 'momentum': 0.6}
+0.651042 (0.024774) with: {'learn_rate': 0.2, 'momentum': 0.8}
+0.651042 (0.024774) with: {'learn_rate': 0.2, 'momentum': 0.9}
+0.455729 (0.146518) with: {'learn_rate': 0.3, 'momentum': 0.0}
+0.455729 (0.146518) with: {'learn_rate': 0.3, 'momentum': 0.2}
+0.455729 (0.146518) with: {'learn_rate': 0.3, 'momentum': 0.4}
+0.348958 (0.024774) with: {'learn_rate': 0.3, 'momentum': 0.6}
+0.348958 (0.024774) with: {'learn_rate': 0.3, 'momentum': 0.8}
+0.348958 (0.024774) with: {'learn_rate': 0.3, 'momentum': 0.9}
+```
+
+我们可以看到相对 SGD 在这个问题上不是很好，但是使用 0.01 的学习率和 0.0 的动量以及约 68％的准确度获得了最佳结果。
+
+## 如何调整网络权重初始化
+
+神经网络权重初始化过去很简单：使用小的随机值。
+
+现在有一套不同的技术可供选择。 [Keras 提供清单](http://keras.io/initializations/)。
+
+在此示例中，我们将通过评估所有可用技术来调整网络权重初始化的选择。
+
+我们将在每一层使用相同的权重初始化方法。理想情况下，根据每层使用的激活函数，使用不同的权重初始化方案可能更好。在下面的示例中，我们使用整流器作为隐藏层。我们使用 sigmoid 作为输出层，因为预测是二进制的。
+
+完整的代码清单如下。
+
+```
+# Use scikit-learn to grid search the weight initialization
+import numpy
+from sklearn.model_selection import GridSearchCV
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+# Function to create model, required for KerasClassifier
+def create_model(init_mode='uniform'):
+	# create model
+	model = Sequential()
+	model.add(Dense(12, input_dim=8, kernel_initializer=init_mode, activation='relu'))
+	model.add(Dense(1, kernel_initializer=init_mode, activation='sigmoid'))
+	# Compile model
+	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load 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 = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
+# define the grid search parameters
+init_mode = ['uniform', 'lecun_uniform', 'normal', 'zero', 'glorot_normal', 'glorot_uniform', 'he_normal', 'he_uniform']
+param_grid = dict(init_mode=init_mode)
+grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
+grid_result = grid.fit(X, Y)
+# summarize results
+print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
+means = grid_result.cv_results_['mean_test_score']
+stds = grid_result.cv_results_['std_test_score']
+params = grid_result.cv_results_['params']
+for mean, stdev, param in zip(means, stds, params):
+    print("%f (%f) with: %r" % (mean, stdev, param))
+```
+
+运行此示例将生成以下输出。
+
+```
+Best: 0.720052 using {'init_mode': 'uniform'}
+0.720052 (0.024360) with: {'init_mode': 'uniform'}
+0.348958 (0.024774) with: {'init_mode': 'lecun_uniform'}
+0.712240 (0.012075) with: {'init_mode': 'normal'}
+0.651042 (0.024774) with: {'init_mode': 'zero'}
+0.700521 (0.010253) with: {'init_mode': 'glorot_normal'}
+0.674479 (0.011201) with: {'init_mode': 'glorot_uniform'}
+0.661458 (0.028940) with: {'init_mode': 'he_normal'}
+0.678385 (0.004872) with: {'init_mode': 'he_uniform'}
+```
+
+我们可以看到，使用均匀重量初始化方案实现了最佳结果，实现了约 72％的性能。
+
+## 如何调整神经元激活功能
+
+激活功能控制各个神经元的非线性以及何时触发。
+
+通常，整流器激活功能是最流行的，但它曾经是 sigmoid 和 tanh 功能，这些功能可能仍然更适合于不同的问题。
+
+在这个例子中，我们将评估 Keras 中可用的[不同激活函数套件。我们将仅在隐藏层中使用这些函数，因为我们在输出中需要 sigmoid 激活函数以用于二进制分类问题。](http://keras.io/activations/)
+
+通常，将数据准备到不同传递函数的范围是一个好主意，在这种情况下我们不会这样做。
+
+完整的代码清单如下。
+
+```
+# Use scikit-learn to grid search the activation function
+import numpy
+from sklearn.model_selection import GridSearchCV
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+# Function to create model, required for KerasClassifier
+def create_model(activation='relu'):
+	# create model
+	model = Sequential()
+	model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation=activation))
+	model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
+	# Compile model
+	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load 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 = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
+# define the grid search parameters
+activation = ['softmax', 'softplus', 'softsign', 'relu', 'tanh', 'sigmoid', 'hard_sigmoid', 'linear']
+param_grid = dict(activation=activation)
+grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
+grid_result = grid.fit(X, Y)
+# summarize results
+print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
+means = grid_result.cv_results_['mean_test_score']
+stds = grid_result.cv_results_['std_test_score']
+params = grid_result.cv_results_['params']
+for mean, stdev, param in zip(means, stds, params):
+    print("%f (%f) with: %r" % (mean, stdev, param))
+```
+
+运行此示例将生成以下输出。
+
+```
+Best: 0.722656 using {'activation': 'linear'}
+0.649740 (0.009744) with: {'activation': 'softmax'}
+0.720052 (0.032106) with: {'activation': 'softplus'}
+0.688802 (0.019225) with: {'activation': 'softsign'}
+0.720052 (0.018136) with: {'activation': 'relu'}
+0.691406 (0.019401) with: {'activation': 'tanh'}
+0.680990 (0.009207) with: {'activation': 'sigmoid'}
+0.691406 (0.014616) with: {'activation': 'hard_sigmoid'}
+0.722656 (0.003189) with: {'activation': 'linear'}
+```
+
+令人惊讶的是（至少对我而言），“线性”激活功能获得了最佳结果，准确度约为 72％。
+
+## 如何调整辍学规范化
+
+在这个例子中，我们将研究调整正则化的辍学率，以限制过度拟合并提高模型的推广能力。
+
+为了获得良好的结果，辍学最好与权重约束相结合，例如最大范数约束。
+
+有关在 Keras 深度学习模型中使用 dropout 的更多信息，请参阅帖子：
+
+*   [具有 Keras 的深度学习模型中的丢失正则化](http://machinelearningmastery.com/dropout-regularization-deep-learning-models-keras/)
+
+这涉及拟合辍学率和权重约束。我们将尝试 0.0 到 0.9 之间的丢失百分比（1.0 没有意义）和 0 到 5 之间的 maxnorm 权重约束值。
+
+完整的代码清单如下。
+
+```
+# Use scikit-learn to grid search the dropout rate
+import numpy
+from sklearn.model_selection import GridSearchCV
+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
+# Function to create model, required for KerasClassifier
+def create_model(dropout_rate=0.0, weight_constraint=0):
+	# create model
+	model = Sequential()
+	model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='linear', kernel_constraint=maxnorm(weight_constraint)))
+	model.add(Dropout(dropout_rate))
+	model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
+	# Compile model
+	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load 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 = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
+# define the grid search parameters
+weight_constraint = [1, 2, 3, 4, 5]
+dropout_rate = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
+param_grid = dict(dropout_rate=dropout_rate, weight_constraint=weight_constraint)
+grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
+grid_result = grid.fit(X, Y)
+# summarize results
+print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
+means = grid_result.cv_results_['mean_test_score']
+stds = grid_result.cv_results_['std_test_score']
+params = grid_result.cv_results_['params']
+for mean, stdev, param in zip(means, stds, params):
+    print("%f (%f) with: %r" % (mean, stdev, param))
+```
+
+运行此示例将生成以下输出。
+
+```
+Best: 0.723958 using {'dropout_rate': 0.2, 'weight_constraint': 4}
+0.696615 (0.031948) with: {'dropout_rate': 0.0, 'weight_constraint': 1}
+0.696615 (0.031948) with: {'dropout_rate': 0.0, 'weight_constraint': 2}
+0.691406 (0.026107) with: {'dropout_rate': 0.0, 'weight_constraint': 3}
+0.708333 (0.009744) with: {'dropout_rate': 0.0, 'weight_constraint': 4}
+0.708333 (0.009744) with: {'dropout_rate': 0.0, 'weight_constraint': 5}
+0.710937 (0.008438) with: {'dropout_rate': 0.1, 'weight_constraint': 1}
+0.709635 (0.007366) with: {'dropout_rate': 0.1, 'weight_constraint': 2}
+0.709635 (0.007366) with: {'dropout_rate': 0.1, 'weight_constraint': 3}
+0.695312 (0.012758) with: {'dropout_rate': 0.1, 'weight_constraint': 4}
+0.695312 (0.012758) with: {'dropout_rate': 0.1, 'weight_constraint': 5}
+0.701823 (0.017566) with: {'dropout_rate': 0.2, 'weight_constraint': 1}
+0.710938 (0.009568) with: {'dropout_rate': 0.2, 'weight_constraint': 2}
+0.710938 (0.009568) with: {'dropout_rate': 0.2, 'weight_constraint': 3}
+0.723958 (0.027126) with: {'dropout_rate': 0.2, 'weight_constraint': 4}
+0.718750 (0.030425) with: {'dropout_rate': 0.2, 'weight_constraint': 5}
+0.721354 (0.032734) with: {'dropout_rate': 0.3, 'weight_constraint': 1}
+0.707031 (0.036782) with: {'dropout_rate': 0.3, 'weight_constraint': 2}
+0.707031 (0.036782) with: {'dropout_rate': 0.3, 'weight_constraint': 3}
+0.694010 (0.019225) with: {'dropout_rate': 0.3, 'weight_constraint': 4}
+0.709635 (0.006639) with: {'dropout_rate': 0.3, 'weight_constraint': 5}
+0.704427 (0.008027) with: {'dropout_rate': 0.4, 'weight_constraint': 1}
+0.717448 (0.031304) with: {'dropout_rate': 0.4, 'weight_constraint': 2}
+0.718750 (0.030425) with: {'dropout_rate': 0.4, 'weight_constraint': 3}
+0.718750 (0.030425) with: {'dropout_rate': 0.4, 'weight_constraint': 4}
+0.722656 (0.029232) with: {'dropout_rate': 0.4, 'weight_constraint': 5}
+0.720052 (0.028940) with: {'dropout_rate': 0.5, 'weight_constraint': 1}
+0.703125 (0.009568) with: {'dropout_rate': 0.5, 'weight_constraint': 2}
+0.716146 (0.029635) with: {'dropout_rate': 0.5, 'weight_constraint': 3}
+0.709635 (0.008027) with: {'dropout_rate': 0.5, 'weight_constraint': 4}
+0.703125 (0.011500) with: {'dropout_rate': 0.5, 'weight_constraint': 5}
+0.707031 (0.017758) with: {'dropout_rate': 0.6, 'weight_constraint': 1}
+0.701823 (0.018688) with: {'dropout_rate': 0.6, 'weight_constraint': 2}
+0.701823 (0.018688) with: {'dropout_rate': 0.6, 'weight_constraint': 3}
+0.690104 (0.027498) with: {'dropout_rate': 0.6, 'weight_constraint': 4}
+0.695313 (0.022326) with: {'dropout_rate': 0.6, 'weight_constraint': 5}
+0.697917 (0.014382) with: {'dropout_rate': 0.7, 'weight_constraint': 1}
+0.697917 (0.014382) with: {'dropout_rate': 0.7, 'weight_constraint': 2}
+0.687500 (0.008438) with: {'dropout_rate': 0.7, 'weight_constraint': 3}
+0.704427 (0.011201) with: {'dropout_rate': 0.7, 'weight_constraint': 4}
+0.696615 (0.016367) with: {'dropout_rate': 0.7, 'weight_constraint': 5}
+0.680990 (0.025780) with: {'dropout_rate': 0.8, 'weight_constraint': 1}
+0.699219 (0.019401) with: {'dropout_rate': 0.8, 'weight_constraint': 2}
+0.701823 (0.015733) with: {'dropout_rate': 0.8, 'weight_constraint': 3}
+0.684896 (0.023510) with: {'dropout_rate': 0.8, 'weight_constraint': 4}
+0.696615 (0.017566) with: {'dropout_rate': 0.8, 'weight_constraint': 5}
+0.653646 (0.034104) with: {'dropout_rate': 0.9, 'weight_constraint': 1}
+0.677083 (0.012075) with: {'dropout_rate': 0.9, 'weight_constraint': 2}
+0.679688 (0.013902) with: {'dropout_rate': 0.9, 'weight_constraint': 3}
+0.669271 (0.017566) with: {'dropout_rate': 0.9, 'weight_constraint': 4}
+0.669271 (0.012075) with: {'dropout_rate': 0.9, 'weight_constraint': 5}
+```
+
+我们可以看到，20％的辍学率和 4 的最大权重约束导致最佳准确度约为 72％。
+
+## 如何调整隐藏层中的神经元数量
+
+层中神经元的数量是调整的重要参数。通常，层中的神经元的数量控制网络的表示能力，至少在拓扑中的那个点处。
+
+此外，通常，足够大的单层网络可以近似于任何其他神经网络，[至少在理论上](https://en.wikipedia.org/wiki/Universal_approximation_theorem)。
+
+在这个例子中，我们将研究调整单个隐藏层中的神经元数量。我们将以 5 的步长尝试 1 到 30 的值。
+
+较大的网络需要更多的训练，并且至少批量大小和时期数应理想地用神经元的数量来优化。
+
+完整的代码清单如下。
+
+```
+# Use scikit-learn to grid search the number of neurons
+import numpy
+from sklearn.model_selection import GridSearchCV
+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
+# Function to create model, required for KerasClassifier
+def create_model(neurons=1):
+	# create model
+	model = Sequential()
+	model.add(Dense(neurons, input_dim=8, kernel_initializer='uniform', activation='linear', kernel_constraint=maxnorm(4)))
+	model.add(Dropout(0.2))
+	model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
+	# Compile model
+	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load 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 = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
+# define the grid search parameters
+neurons = [1, 5, 10, 15, 20, 25, 30]
+param_grid = dict(neurons=neurons)
+grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
+grid_result = grid.fit(X, Y)
+# summarize results
+print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
+means = grid_result.cv_results_['mean_test_score']
+stds = grid_result.cv_results_['std_test_score']
+params = grid_result.cv_results_['params']
+for mean, stdev, param in zip(means, stds, params):
+    print("%f (%f) with: %r" % (mean, stdev, param))
+```
+
+运行此示例将生成以下输出。
+
+```
+Best: 0.714844 using {'neurons': 5}
+0.700521 (0.011201) with: {'neurons': 1}
+0.714844 (0.011049) with: {'neurons': 5}
+0.712240 (0.017566) with: {'neurons': 10}
+0.705729 (0.003683) with: {'neurons': 15}
+0.696615 (0.020752) with: {'neurons': 20}
+0.713542 (0.025976) with: {'neurons': 25}
+0.705729 (0.008027) with: {'neurons': 30}
+```
+
+我们可以看到，在隐藏层中具有 5 个神经元的网络实现了最佳结果，精度约为 71％。
+
+## 超参数优化提示
+
+本节列出了调整神经网络超参数时要考虑的一些方便提示。
+
+*   **k 倍交叉验证**。您可以看到本文中示例的结果显示出一些差异。使用默认的交叉验证 3，但是 k = 5 或 k = 10 可能更稳定。仔细选择交叉验证配置以确保结果稳定。
+*   **回顾整个网格**。不要只关注最佳结果，检查整个结果网格并寻找支持配置决策的趋势。
+*   **并行化**。如果可以的话，使用你所有的核心，神经网络训练很慢，我们经常想尝试很多不同的参数。考虑搞砸很多 [AWS 实例](http://machinelearningmastery.com/develop-evaluate-large-deep-learning-models-keras-amazon-web-services/)。
+*   **使用数据集样本**。因为网络训练很慢，所以尝试在训练数据集的较小样本上训练它们，只是为了了解参数的一般方向而不是最佳配置。
+*   **从粗网格**开始。从粗粒度网格开始，一旦缩小范围，就可以缩放到更细粒度的网格。
+*   **不转移结果**。结果通常是特定于问题的。尝试在您看到的每个新问题上避免喜欢的配置。您在一个问题上发现的最佳结果不太可能转移到您的下一个项目。而是寻找更广泛的趋势，例如层数或参数之间的关系。
+*   **再现性是一个问题**。虽然我们在 NumPy 中为随机数生成器设置种子，但结果不是 100％可重复的。当网格搜索包裹 Keras 模型时，重复性要高于本文中提供的内容。
+
+## 摘要
+
+在这篇文章中，您了解了如何使用 Keras 和 scikit-learn 在 Python 中调整深度学习网络的超参数。
+
+具体来说，你学到了：
+
+*   如何包装 Keras 模型用于 scikit-learn 以及如何使用网格搜索。
+*   如何为 Keras 模型网格搜索一套不同的标准神经网络参数。
+*   如何设计自己的超参数优化实验。
+
+你有调整大型神经网络超参数的经验吗？请在下面分享您的故事。
+
+您对神经网络的超参数优化还是关于这篇文章有什么疑问？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/handwritten-digit-recognition-using-convolutional-neural-networks-python-keras.md b/docs/dl-keras/handwritten-digit-recognition-using-convolutional-neural-networks-python-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..0ca22f2eb92f34dee1c1f35aed9d91be14b43031
--- /dev/null
+++ b/docs/dl-keras/handwritten-digit-recognition-using-convolutional-neural-networks-python-keras.md
@@ -0,0 +1,457 @@
+# 用 Keras 在 Python 中使用卷积神经网络进行手写数字识别
+
+> 原文： [https://machinelearningmastery.com/handwritten-digit-recognition-using-convolutional-neural-networks-python-keras/](https://machinelearningmastery.com/handwritten-digit-recognition-using-convolutional-neural-networks-python-keras/)
+
+深度学习技术能力的流行演示是图像数据中的对象识别。
+
+用于机器学习和深度学习的对象识别的“hello world”是用于手写数字识别的 MNIST 数据集。
+
+在这篇文章中，您将了解如何使用 Keras 深度学习库开发深度学习模型，以便在 Python 中使用 MNIST 手写数字识别任务实现近乎最先进的性能。
+
+完成本教程后，您将了解：
+
+*   如何在 Keras 中加载 MNIST 数据集。
+*   如何开发和评估 MNIST 问题的基线神经网络模型。
+*   如何实现和评估一个简单的 MNIST 卷积神经网络。
+*   如何实现接近最先进的 MNIST 深度学习模型。
+
+让我们开始吧。
+
+*   **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 的示例。
+
+![Handwritten Digit Recognition using Convolutional Neural Networks in Python with Keras](img/299fb4248be9f10daf6e16e3069a834d.jpg)
+
+使用 Keras
+在 Python 中使用卷积神经网络进行手写数字识别 [Jamie](https://www.flickr.com/photos/jamiesrabbits/5947373341/) ，保留一些权利。
+
+## MNIST 手写数字识别问题的描述
+
+[MNIST](http://yann.lecun.com/exdb/mnist/) 问题是由 Yann LeCun，Corinna Cortes 和 Christopher Burges 开发的用于评估手写数字分类问题的机器学习模型的数据集。
+
+该数据集由许多可从[国家标准与技术研究所](http://www.nist.gov/)（NIST）获得的扫描文档数据集构建。这是数据集的名称来源，作为 Modified NIST 或 MNIST 数据集。
+
+数字图像取自各种扫描文档，标准化并居中。这使其成为评估模型的优秀数据集，使开发人员能够专注于机器学习，只需要很少的数据清理或准备。
+
+每个图像是 28 乘 28 像素的正方形（总共 784 个像素）。数据集的标准吐出用于评估和比较模型，其中 60,000 个图像用于训练模型，并且单独的 10,000 个图像集用于测试它。
+
+这是一项数字识别任务。因此，有 10 个数字（0 到 9）或 10 个类来预测。使用预测误差报告结果，预测误差仅仅是反向分类精度。
+
+优异的结果实现了小于 1％的预测误差。使用大型卷积神经网络可以实现约 0.2％的最先进预测误差。有一份最新的结果列表，以及有关 MNIST 和 [Rodrigo Benenson 网页](http://rodrigob.github.io/are_we_there_yet/build/classification_datasets_results.html#4d4e495354)上其他数据集的相关论文的链接。
+
+## 在 Keras 中加载 MNIST 数据集
+
+Keras 深度学习库提供了一种加载 MNIST 数据集的便捷方法。
+
+第一次调用此函数时会自动下载数据集，并将其作为 15MB 文件存储在〜/ .keras / datasets / mnist.pkl.gz 的主目录中。
+
+这对于开发和测试深度学习模型非常方便。
+
+为了演示加载 MNIST 数据集是多么容易，我们将首先编写一个小脚本来下载和可视化训练数据集中的前 4 个图像。
+
+```
+# Plot ad hoc mnist instances
+from keras.datasets import mnist
+import matplotlib.pyplot as plt
+# load (downloaded if needed) the MNIST dataset
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# plot 4 images as gray scale
+plt.subplot(221)
+plt.imshow(X_train[0], cmap=plt.get_cmap('gray'))
+plt.subplot(222)
+plt.imshow(X_train[1], cmap=plt.get_cmap('gray'))
+plt.subplot(223)
+plt.imshow(X_train[2], cmap=plt.get_cmap('gray'))
+plt.subplot(224)
+plt.imshow(X_train[3], cmap=plt.get_cmap('gray'))
+# show the plot
+plt.show()
+```
+
+您可以看到下载和加载 MNIST 数据集就像调用 mnist.load_data（）函数一样简单。运行上面的示例，您应该看到下面的图像。
+
+![Examples from the MNIST dataset](img/2501396e3f59ad04cd824226eeae9ede.jpg)
+
+MNIST 数据集中的示例
+
+## 具有多层感知器的基线模型
+
+我们真的需要像卷积神经网络这样的复杂模型来获得 MNIST 的最佳结果吗？
+
+使用具有单个隐藏层的非常简单的神经网络模型，您可以获得非常好的结果。在本节中，我们将创建一个简单的多层感知器模型，其错误率为 1.74％。我们将使用它作为比较更复杂的卷积神经网络模型的基线。
+
+让我们从导入我们需要的类和函数开始。
+
+```
+import numpy
+from keras.datasets import mnist
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import Dropout
+from keras.utils import np_utils
+```
+
+将随机数生成器初始化为常量始终是一个好主意，以确保脚本的结果是可重现的。
+
+```
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+```
+
+现在我们可以使用 Keras 辅助函数加载 MNIST 数据集。
+
+```
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+```
+
+训练数据集被构造为实例，图像宽度和图像高度的三维阵列。对于多层感知器模型，我们必须将图像缩小为像素矢量。在这种情况下，28×28 大小的图像将是 784 像素输入值。
+
+我们可以使用 NumPy 数组上的 [reshape（）函数](http://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.reshape.html)轻松地进行转换。我们还可以通过强制像素值的精度为 32 位来降低我们的内存需求，这是 Keras 使用的默认精度。
+
+```
+# flatten 28*28 images to a 784 vector for each image
+num_pixels = X_train.shape[1] * X_train.shape[2]
+X_train = X_train.reshape(X_train.shape[0], num_pixels).astype('float32')
+X_test = X_test.reshape(X_test.shape[0], num_pixels).astype('float32')
+```
+
+像素值是 0 到 255 之间的灰度级。在使用神经网络模型时，执行输入值的某些缩放几乎总是一个好主意。因为比例是众所周知的并且表现良好，所以我们可以通过将每个值除以最大值 255 来非常快速地将像素值标准化到 0 和 1 的范围。
+
+```
+# normalize inputs from 0-255 to 0-1
+X_train = X_train / 255
+X_test = X_test / 255
+```
+
+最后，输出变量是 0 到 9 之间的整数。这是一个多类分类问题。因此，优良作法是使用类值的一个热编码，将类整数的向量转换为二进制矩阵。
+
+我们可以使用 Keras 中内置的 np_utils.to_categorical（）辅助函数轻松完成此操作。
+
+```
+# one hot encode outputs
+y_train = np_utils.to_categorical(y_train)
+y_test = np_utils.to_categorical(y_test)
+num_classes = y_test.shape[1]
+```
+
+我们现在准备创建我们简单的神经网络模型。我们将在函数中定义我们的模型。如果您想稍后扩展示例并尝试获得更好的分数，这将非常方便。
+
+```
+# define baseline model
+def baseline_model():
+	# create model
+	model = Sequential()
+	model.add(Dense(num_pixels, input_dim=num_pixels, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(num_classes, kernel_initializer='normal', activation='softmax'))
+	# Compile model
+	model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
+```
+
+该模型是一个简单的神经网络，其中一个隐藏层具有与输入相同数量的神经元（784）。整流器激活功能用于隐藏层中的神经元。
+
+在输出层上使用 softmax 激活函数将输出转换为类似概率的值，并允许选择 10 中的一个类作为模型的输出预测。对数损失用作损失函数（在 Keras 中称为 categorical_crossentropy），并且使用有效的 ADAM 梯度下降算法来学习权重。
+
+我们现在可以拟合和评估模型。该模型适用于 10 个时期，每 200 个图像更新一次。测试数据用作验证数据集，允许您在训练时查看模型的技能。详细值为 2 用于将每个训练时期的输出减少到一行。
+
+最后，测试数据集用于评估模型并打印分类错误率。
+
+```
+# build the model
+model = baseline_model()
+# Fit the model
+model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200, verbose=2)
+# Final evaluation of the model
+scores = model.evaluate(X_test, y_test, verbose=0)
+print("Baseline Error: %.2f%%" % (100-scores[1]*100))
+```
+
+在 CPU 上运行时运行该示例可能需要几分钟。您应该看到下面的输出。在极少数代码行中定义的这种非常简单的网络实现了 1.91％的可观错误率。
+
+```
+Train on 60000 samples, validate on 10000 samples
+Epoch 1/10
+8s - loss: 0.2797 - acc: 0.9209 - val_loss: 0.1413 - val_acc: 0.9576
+Epoch 2/10
+8s - loss: 0.1117 - acc: 0.9677 - val_loss: 0.0919 - val_acc: 0.9702
+Epoch 3/10
+8s - loss: 0.0718 - acc: 0.9796 - val_loss: 0.0782 - val_acc: 0.9774
+Epoch 4/10
+8s - loss: 0.0505 - acc: 0.9858 - val_loss: 0.0758 - val_acc: 0.9762
+Epoch 5/10
+8s - loss: 0.0374 - acc: 0.9892 - val_loss: 0.0670 - val_acc: 0.9792
+Epoch 6/10
+8s - loss: 0.0268 - acc: 0.9929 - val_loss: 0.0630 - val_acc: 0.9803
+Epoch 7/10
+8s - loss: 0.0210 - acc: 0.9945 - val_loss: 0.0604 - val_acc: 0.9815
+Epoch 8/10
+8s - loss: 0.0140 - acc: 0.9969 - val_loss: 0.0620 - val_acc: 0.9808
+Epoch 9/10
+8s - loss: 0.0107 - acc: 0.9978 - val_loss: 0.0598 - val_acc: 0.9812
+Epoch 10/10
+7s - loss: 0.0080 - acc: 0.9985 - val_loss: 0.0588 - val_acc: 0.9809
+Baseline Error: 1.91%
+```
+
+## 用于 MNIST 的简单卷积神经网络
+
+现在我们已经看到如何加载 MNIST 数据集并在其上训练一个简单的多层感知器模型，现在是开发更复杂的卷积神经网络或 CNN 模型的时候了。
+
+Keras 确实为[创建卷积神经网络](http://keras.io/layers/convolutional/)提供了很多功能。
+
+在本节中，我们将为 MNIST 创建一个简单的 CNN，演示如何使用现代 CNN 实现的所有方面，包括卷积层，池化层和丢失层。
+
+第一步是导入所需的类和函数。
+
+```
+import numpy
+from keras.datasets import mnist
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import Dropout
+from keras.layers import Flatten
+from keras.layers.convolutional import Conv2D
+from keras.layers.convolutional import MaxPooling2D
+from keras.utils import np_utils
+from keras import backend as K
+K.set_image_dim_ordering('th')
+```
+
+同样，我们总是将随机数生成器初始化为恒定的种子值，以便重现结果。
+
+```
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+```
+
+接下来，我们需要加载 MNIST 数据集并对其进行整形，以便它适合用于训练 CNN。在 Keras 中，用于二维卷积的层期望像素值具有[像素] [宽度] [高度]的尺寸。
+
+在 RGB 的情况下，对于红色，绿色和蓝色分量，第一维像素将是 3，并且对于每个彩色图像将具有 3 个图像输入。在 MNIST 中像素值是灰度级的情况下，像素尺寸设置为 1。
+
+```
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# reshape to be [samples][pixels][width][height]
+X_train = X_train.reshape(X_train.shape[0], 1, 28, 28).astype('float32')
+X_test = X_test.reshape(X_test.shape[0], 1, 28, 28).astype('float32')
+```
+
+和以前一样，最好将像素值标准化为 0 和 1 范围，并对输出变量进行热编码。
+
+```
+# normalize inputs from 0-255 to 0-1
+X_train = X_train / 255
+X_test = X_test / 255
+# one hot encode outputs
+y_train = np_utils.to_categorical(y_train)
+y_test = np_utils.to_categorical(y_test)
+num_classes = y_test.shape[1]
+```
+
+接下来我们定义我们的神经网络模型
+
+卷积神经网络比标准的多层感知器更复杂，因此我们将首先使用一个简单的结构，使用所有元素来获得最先进的结果。下面总结了网络架构。
+
+1.  第一个隐藏层是卷积层，称为 Convolution2D。该层具有 32 个特征图，其大小为 5×5，并具有整流器激活功能。这是输入图层，期望图像的结构轮廓高于[像素] [宽度] [高度]。
+2.  接下来，我们定义一个池化层，它采用最大的 MaxPooling2D。配置池大小为 2×2。
+3.  下一层是使用 Dropout 的正规化层，称为 Dropout。它被配置为随机排除层中 20％的神经元以减少过度拟合。
+4.  接下来是将 2D 矩阵数据转换为名为 Flatten 的向量的图层。它允许输出由标准的完全连接层处理。
+5.  接下来是具有 128 个神经元和整流器激活功能的完全连接层。
+6.  最后，输出层有 10 个类的 10 个神经元和 softmax 激活函数，为每个类输出类似概率的预测。
+
+如前所述，使用对数损失和 ADAM 梯度下降算法训练模型。
+
+```
+def baseline_model():
+	# create model
+	model = Sequential()
+	model.add(Conv2D(32, (5, 5), input_shape=(1, 28, 28), activation='relu'))
+	model.add(MaxPooling2D(pool_size=(2, 2)))
+	model.add(Dropout(0.2))
+	model.add(Flatten())
+	model.add(Dense(128, activation='relu'))
+	model.add(Dense(num_classes, activation='softmax'))
+	# Compile model
+	model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
+```
+
+我们使用多层感知器以与以前相同的方式评估模型。 CNN 适用于 10 个时期，批量为 200。
+
+```
+# build the model
+model = baseline_model()
+# Fit the model
+model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200, verbose=2)
+# Final evaluation of the model
+scores = model.evaluate(X_test, y_test, verbose=0)
+print("CNN Error: %.2f%%" % (100-scores[1]*100))
+```
+
+运行该示例，在每个时期打印训练和验证测试的准确性，并且在分类错误率的末尾打印。
+
+时期可能需要大约 45 秒才能在 GPU 上运行（例如在 AWS 上）。您可以看到网络的错误率达到 1.03，这比我们上面的简单多层感知器模型要好。
+
+```
+Train on 60000 samples, validate on 10000 samples
+Epoch 1/10
+60000/60000 [==============================] - 120s - loss: 0.2346 - acc: 0.9334 - val_loss: 0.0774 - val_acc: 0.9762
+Epoch 2/10
+60000/60000 [==============================] - 42s - loss: 0.0716 - acc: 0.9782 - val_loss: 0.0454 - val_acc: 0.9856
+Epoch 3/10
+60000/60000 [==============================] - 42s - loss: 0.0520 - acc: 0.9842 - val_loss: 0.0429 - val_acc: 0.9853
+Epoch 4/10
+60000/60000 [==============================] - 42s - loss: 0.0406 - acc: 0.9868 - val_loss: 0.0369 - val_acc: 0.9876
+Epoch 5/10
+60000/60000 [==============================] - 42s - loss: 0.0331 - acc: 0.9898 - val_loss: 0.0345 - val_acc: 0.9884
+Epoch 6/10
+60000/60000 [==============================] - 42s - loss: 0.0265 - acc: 0.9917 - val_loss: 0.0323 - val_acc: 0.9905
+Epoch 7/10
+60000/60000 [==============================] - 42s - loss: 0.0220 - acc: 0.9931 - val_loss: 0.0337 - val_acc: 0.9894
+Epoch 8/10
+60000/60000 [==============================] - 42s - loss: 0.0201 - acc: 0.9934 - val_loss: 0.0316 - val_acc: 0.9892
+Epoch 9/10
+60000/60000 [==============================] - 42s - loss: 0.0163 - acc: 0.9947 - val_loss: 0.0281 - val_acc: 0.9908
+Epoch 10/10
+60000/60000 [==============================] - 42s - loss: 0.0135 - acc: 0.9956 - val_loss: 0.0327 - val_acc: 0.9897
+CNN Error: 1.03%
+```
+
+## 用于 MNIST 的较大卷积神经网络
+
+现在我们已经看到了如何创建一个简单的 CNN，让我们来看看能够接近最新结果的模型。
+
+我们导入类和函数，然后加载和准备数据与前一个 CNN 示例相同。
+
+```
+# Larger CNN for the MNIST Dataset
+import numpy
+from keras.datasets import mnist
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import Dropout
+from keras.layers import Flatten
+from keras.layers.convolutional import Conv2D
+from keras.layers.convolutional import MaxPooling2D
+from keras.utils import np_utils
+from keras import backend as K
+K.set_image_dim_ordering('th')
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# reshape to be [samples][pixels][width][height]
+X_train = X_train.reshape(X_train.shape[0], 1, 28, 28).astype('float32')
+X_test = X_test.reshape(X_test.shape[0], 1, 28, 28).astype('float32')
+# normalize inputs from 0-255 to 0-1
+X_train = X_train / 255
+X_test = X_test / 255
+# one hot encode outputs
+y_train = np_utils.to_categorical(y_train)
+y_test = np_utils.to_categorical(y_test)
+num_classes = y_test.shape[1]
+```
+
+这次我们定义了一个大型 CNN 架构，其中包含额外的卷积，最大池化层和完全连接的层。网络拓扑可以总结如下。
+
+1.  具有 30 个大小为 5×5 的特征图的卷积层。
+2.  汇集层最多超过 2 * 2 补丁。
+3.  具有 15 个尺寸为 3×3 的特征图的卷积层。
+4.  汇集层最多超过 2 * 2 补丁。
+5.  辍学层的概率为 20％。
+6.  展平图层。
+7.  完全连接的层有 128 个神经元和整流器激活。
+8.  完全连接的层有 50 个神经元和整流器激活。
+9.  输出层。
+
+```
+# define the larger model
+def larger_model():
+	# create model
+	model = Sequential()
+	model.add(Conv2D(30, (5, 5), input_shape=(1, 28, 28), activation='relu'))
+	model.add(MaxPooling2D(pool_size=(2, 2)))
+	model.add(Conv2D(15, (3, 3), activation='relu'))
+	model.add(MaxPooling2D(pool_size=(2, 2)))
+	model.add(Dropout(0.2))
+	model.add(Flatten())
+	model.add(Dense(128, activation='relu'))
+	model.add(Dense(50, activation='relu'))
+	model.add(Dense(num_classes, activation='softmax'))
+	# Compile model
+	model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
+```
+
+与前两个实验一样，该模型适用于 10 个时期，批量大小为 200。
+
+```
+# build the model
+model = larger_model()
+# Fit the model
+model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200)
+# Final evaluation of the model
+scores = model.evaluate(X_test, y_test, verbose=0)
+print("Large CNN Error: %.2f%%" % (100-scores[1]*100))
+```
+
+运行该示例可在每个纪元和最终分类错误率的训练和验证数据集上打印准确度。
+
+该模型每个时期运行大约需要 100 秒。这个略大的模型实现了 0.89％的可观分类错误率。
+
+```
+Train on 60000 samples, validate on 10000 samples
+Epoch 1/10
+60000/60000 [==============================] - 45s - loss: 0.3912 - acc: 0.8798 - val_loss: 0.0874 - val_acc: 0.9726
+Epoch 2/10
+60000/60000 [==============================] - 43s - loss: 0.0944 - acc: 0.9713 - val_loss: 0.0603 - val_acc: 0.9800
+Epoch 3/10
+60000/60000 [==============================] - 43s - loss: 0.0697 - acc: 0.9781 - val_loss: 0.0377 - val_acc: 0.9880
+Epoch 4/10
+60000/60000 [==============================] - 44s - loss: 0.0558 - acc: 0.9819 - val_loss: 0.0331 - val_acc: 0.9885
+Epoch 5/10
+60000/60000 [==============================] - 44s - loss: 0.0480 - acc: 0.9852 - val_loss: 0.0300 - val_acc: 0.9900
+Epoch 6/10
+60000/60000 [==============================] - 44s - loss: 0.0430 - acc: 0.9862 - val_loss: 0.0293 - val_acc: 0.9897
+Epoch 7/10
+60000/60000 [==============================] - 44s - loss: 0.0385 - acc: 0.9877 - val_loss: 0.0260 - val_acc: 0.9911
+Epoch 8/10
+60000/60000 [==============================] - 44s - loss: 0.0349 - acc: 0.9895 - val_loss: 0.0264 - val_acc: 0.9910
+Epoch 9/10
+60000/60000 [==============================] - 44s - loss: 0.0332 - acc: 0.9898 - val_loss: 0.0222 - val_acc: 0.9931
+Epoch 10/10
+60000/60000 [==============================] - 44s - loss: 0.0289 - acc: 0.9908 - val_loss: 0.0226 - val_acc: 0.9918
+Large CNN Error: 0.82%
+```
+
+这不是优化的网络拓扑。最近的论文也没有复制网络拓扑。您可以通过很多机会调整和改进此模型。
+
+您可以达到的最佳错误率分数是多少？
+
+在评论中发布您的配置和最佳分数。
+
+## 关于 MNIST 的资源
+
+MNIST 数据集得到了很好的研究。以下是您可能希望了解的一些其他资源。
+
+*   [官方 MNIST 数据集网页](http://yann.lecun.com/exdb/mnist/)。
+*   [Rodrigo Benenson 的网页列出了最新的结果](http://rodrigob.github.io/are_we_there_yet/build/classification_datasets_results.html#4d4e495354)。
+*   [使用此数据集](https://www.kaggle.com/c/digit-recognizer)的 Kaggle 竞赛（查看脚本和论坛部分以获取示例代码）
+*   [在 MNIST 上训练的只读模型，您可以在浏览器中测试](http://myselph.de/neuralNet.html)（非常酷）
+
+## 摘要
+
+在这篇文章中，您发现了 MNIST 手写数字识别问题和使用 Keras 库在 Python 中开发的深度学习模型，这些模型能够获得出色的结果。
+
+通过本教程，您了解到：
+
+*   如何在 Keras 中加载 MNIST 数据集并生成数据集的图。
+*   如何重塑 MNIST 数据集并开发一个简单但性能良好的多层感知器模型来解决这个问题。
+*   如何使用 Keras 为 MNIST 创建卷积神经网络模型。
+*   如何为具有近乎世界级成果的 MNIST 开发和评估更大的 CNN 模型。
+
+您对深度学习或此帖的手写识别有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras.md b/docs/dl-keras/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..4e43fb15f19d6d2b932bb29992db3c23331173f4
--- /dev/null
+++ b/docs/dl-keras/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras.md
@@ -0,0 +1,369 @@
+# 如何用 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
diff --git a/docs/dl-keras/image-augmentation-deep-learning-keras.md b/docs/dl-keras/image-augmentation-deep-learning-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..b5831a8621966bffe8f3f886d977eeaf4f01756c
--- /dev/null
+++ b/docs/dl-keras/image-augmentation-deep-learning-keras.md
@@ -0,0 +1,378 @@
+# 用 Keras 进行深度学习的图像增强
+
+> 原文： [https://machinelearningmastery.com/image-augmentation-deep-learning-keras/](https://machinelearningmastery.com/image-augmentation-deep-learning-keras/)
+
+使用神经网络和深度学习模型时，需要进行数据准备。更复杂的对象识别任务也需要越来越多的数据增加。
+
+在本文中，您将了解如何在使用 Keras 开发和评估 Python 中的深度学习模型时，使用数据准备和数据增强与图像数据集。
+
+阅读这篇文章后，你会知道：
+
+*   关于 Keras 提供的图像增强 API 以及如何将其与模型一起使用。
+*   如何执行功能标准化。
+*   如何对图像执行 ZCA 白化。
+*   如何使用随机旋转，移位和翻转来增加数据。
+*   如何将增强的图像数据保存到磁盘。
+
+让我们开始吧。
+
+*   **更新**：本文中的示例已针对最新的 Keras API 进行了更新。 datagen.next（）函数已被删除。
+*   **2016 年 10 月更新**：更新了 Keras 1.1.0，TensorFlow 0.10.0 和 scikit-learn v0.18 的示例。
+*   **2017 年 1 月更新**：更新了 Keras 1.2.0 和 TensorFlow 0.12.1 的示例。
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+
+## Keras Image Augmentation API
+
+与 Keras 的其他部分一样，图像增强 API 简单而强大。
+
+Keras 提供 [ImageDataGenerator](http://keras.io/preprocessing/image/) 类，用于定义图像数据准备和扩充的配置。这包括以下功能：
+
+*   样本标准化。
+*   功能标准化。
+*   ZCA 美白。
+*   随机旋转，移位，剪切和翻转。
+*   尺寸重新排序。
+*   将增强的图像保存到磁盘。
+
+可以如下创建增强图像生成器：
+
+```
+datagen = ImageDataGenerator()
+```
+
+API 不是在内存中对整个图像数据集执行操作，而是通过深度学习模型拟合过程进行迭代，为您及时创建增强的图像数据。这可以减少内存开销，但在模型培训期间会增加一些额外的时间成本。
+
+创建并配置 **ImageDataGenerator** 后，必须将其放在数据上。这将计算实际执行图像数据转换所需的任何统计信息。您可以通过调用数据生成器上的 **fit（）**函数并将其传递给训练数据集来完成此操作。
+
+```
+datagen.fit(train)
+```
+
+数据生成器本身实际上是一个迭代器，在请求时返回批量的图像样本。我们可以通过调用 **flow（）**函数来配置批量大小并准备数据生成器并获取批量图像。
+
+```
+X_batch, y_batch = datagen.flow(train, train, batch_size=32)
+```
+
+最后我们可以使用数据生成器。我们必须调用 **fit_generator（）**函数并传入数据生成器和所需的时间长度以及总数，而不是在我们的模型上调用 **fit（）**函数。要训​​练的时代数。
+
+```
+fit_generator(datagen, samples_per_epoch=len(train), epochs=100)
+```
+
+您可以在 Keras 文档中了解有关 Keras 图像[数据生成器 API 的更多信息。](http://keras.io/preprocessing/image/)
+
+## 图像增强的比较点
+
+既然您已了解 Keras 中的图像增强 API 的工作原理，那么让我们看一些示例。
+
+我们将在这些示例中使用 MNIST 手写数字识别任务。首先，让我们看一下训练数据集中的前 9 个图像。
+
+```
+# Plot images
+from keras.datasets import mnist
+from matplotlib import pyplot
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# create a grid of 3x3 images
+for i in range(0, 9):
+	pyplot.subplot(330 + 1 + i)
+	pyplot.imshow(X_train[i], cmap=pyplot.get_cmap('gray'))
+# show the plot
+pyplot.show()
+```
+
+运行此示例提供了以下图像，我们可以将其用作与下面示例中的图像准备和扩充进行比较的点。
+
+![Example MNIST images](img/256dfb575d54b2eec4be14c906ce2c11.jpg)
+
+示例 MNIST 图像
+
+## 特征标准化
+
+还可以标准化整个数据集中的像素值。这称为特征标准化，并反映了通常对表格数据集中的每列执行的标准化类型。
+
+您可以通过在 ImageDataGenerator 类上设置 featurewise_center 和 featurewise_std_normalization 参数来执行功能标准化。实际上，默认情况下这些设置为 True，并且创建没有参数的 ImageDataGenerator 实例将具有相同的效果。
+
+```
+# Standardize images across the dataset, mean=0, stdev=1
+from keras.datasets import mnist
+from keras.preprocessing.image import ImageDataGenerator
+from matplotlib import pyplot
+from keras import backend as K
+K.set_image_dim_ordering('th')
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# reshape to be [samples][pixels][width][height]
+X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
+X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
+# convert from int to float
+X_train = X_train.astype('float32')
+X_test = X_test.astype('float32')
+# define data preparation
+datagen = ImageDataGenerator(featurewise_center=True, featurewise_std_normalization=True)
+# fit parameters from data
+datagen.fit(X_train)
+# configure batch size and retrieve one batch of images
+for X_batch, y_batch in datagen.flow(X_train, y_train, batch_size=9):
+	# create a grid of 3x3 images
+	for i in range(0, 9):
+		pyplot.subplot(330 + 1 + i)
+		pyplot.imshow(X_batch[i].reshape(28, 28), cmap=pyplot.get_cmap('gray'))
+	# show the plot
+	pyplot.show()
+	break
+```
+
+运行此示例，您可以看到效果不同，看似变暗并使不同的数字变亮。
+
+![Standardized Feature MNIST Images](img/c12075af40bf983d4677a85b12ff92c2.jpg)
+
+标准化特征 MNIST 图像
+
+## ZCA 美白
+
+图像的[白化变换](https://en.wikipedia.org/wiki/Whitening_transformation)是线性代数运算，其减少了像素图像矩阵中的冗余。
+
+图像中较少的冗余旨在更好地突出图像中的结构和特征到学习算法。
+
+通常，使用主成分分析（PCA）技术执行图像白化。最近，一种名为 [ZCA](http://ufldl.stanford.edu/wiki/index.php/Whitening) 的替代方案（[在本技术报告](http://www.cs.toronto.edu/~kriz/learning-features-2009-TR.pdf)的附录 A 中了解更多）显示了更好的结果和结果，在转换后的图像中保留了所有原始尺寸，与 PCA 不同，变换后的图像看起来仍然像他们的原件。
+
+您可以通过将 zca_whitening 参数设置为 True 来执行 ZCA 白化转换。
+
+```
+# ZCA whitening
+from keras.datasets import mnist
+from keras.preprocessing.image import ImageDataGenerator
+from matplotlib import pyplot
+from keras import backend as K
+K.set_image_dim_ordering('th')
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# reshape to be [samples][pixels][width][height]
+X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
+X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
+# convert from int to float
+X_train = X_train.astype('float32')
+X_test = X_test.astype('float32')
+# define data preparation
+datagen = ImageDataGenerator(zca_whitening=True)
+# fit parameters from data
+datagen.fit(X_train)
+# configure batch size and retrieve one batch of images
+for X_batch, y_batch in datagen.flow(X_train, y_train, batch_size=9):
+	# create a grid of 3x3 images
+	for i in range(0, 9):
+		pyplot.subplot(330 + 1 + i)
+		pyplot.imshow(X_batch[i].reshape(28, 28), cmap=pyplot.get_cmap('gray'))
+	# show the plot
+	pyplot.show()
+	break
+```
+
+运行该示例，您可以在图像中看到相同的一般结构，以及如何突出显示每个数字的轮廓。
+
+![ZCA Whitening MNIST Images](img/23bddb450fa7cd93bad158899043b4ee.jpg)
+
+ZCA 美白 MNIST 图像
+
+## 随机旋转
+
+有时，样本数据中的图像可能在场景中具有不同的旋转。
+
+您可以训练模型，以便在训练期间通过人工和随机旋转数据集中的图像来更好地处理图像旋转。
+
+下面的示例通过设置 rotation_range 参数创建最多 90 度的 MNIST 数字的随机旋转。
+
+```
+# Random Rotations
+from keras.datasets import mnist
+from keras.preprocessing.image import ImageDataGenerator
+from matplotlib import pyplot
+from keras import backend as K
+K.set_image_dim_ordering('th')
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# reshape to be [samples][pixels][width][height]
+X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
+X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
+# convert from int to float
+X_train = X_train.astype('float32')
+X_test = X_test.astype('float32')
+# define data preparation
+datagen = ImageDataGenerator(rotation_range=90)
+# fit parameters from data
+datagen.fit(X_train)
+# configure batch size and retrieve one batch of images
+for X_batch, y_batch in datagen.flow(X_train, y_train, batch_size=9):
+	# create a grid of 3x3 images
+	for i in range(0, 9):
+		pyplot.subplot(330 + 1 + i)
+		pyplot.imshow(X_batch[i].reshape(28, 28), cmap=pyplot.get_cmap('gray'))
+	# show the plot
+	pyplot.show()
+	break
+```
+
+运行该示例，您可以看到图像已经左右旋转到 90 度的限制。这对此问题没有帮助，因为 MNIST 数字具有标准化方向，但是当从对象可能具有不同方向的照片进行学习时，这种变换可能会有所帮助。
+
+![Random Rotations of MNIST Images](img/c74159d0c08a16f4d34d423625015f83.jpg)
+
+MNIST 图像的随机旋转
+
+## 随机移位
+
+图像中的对象可能无法在框架中居中。他们可能以各种不同的方式偏离中心。
+
+您可以通过人工创建训练数据的移位版本来训练您的深度学习网络以期望并且当前处理偏离中心的对象。 Keras 通过 width_shift_range 和 height_shift_range 参数支持训练数据的单独水平和垂直随机移位。
+
+```
+# Random Shifts
+from keras.datasets import mnist
+from keras.preprocessing.image import ImageDataGenerator
+from matplotlib import pyplot
+from keras import backend as K
+K.set_image_dim_ordering('th')
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# reshape to be [samples][pixels][width][height]
+X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
+X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
+# convert from int to float
+X_train = X_train.astype('float32')
+X_test = X_test.astype('float32')
+# define data preparation
+shift = 0.2
+datagen = ImageDataGenerator(width_shift_range=shift, height_shift_range=shift)
+# fit parameters from data
+datagen.fit(X_train)
+# configure batch size and retrieve one batch of images
+for X_batch, y_batch in datagen.flow(X_train, y_train, batch_size=9):
+	# create a grid of 3x3 images
+	for i in range(0, 9):
+		pyplot.subplot(330 + 1 + i)
+		pyplot.imshow(X_batch[i].reshape(28, 28), cmap=pyplot.get_cmap('gray'))
+	# show the plot
+	pyplot.show()
+	break
+```
+
+运行此示例会创建数字的移位版本。同样，这不是 MNIST 所必需的，因为手写数字已经居中，但您可以看到这对于更复杂的问题域有何用处。
+
+![Random Shifted MNIST Images](img/a1c44e0b21366d4a6326b44bd4e31679.jpg)
+
+随机移位的 MNIST 图像
+
+## 随机翻转
+
+另一种可以提高大型复杂问题性能的图像数据增强功能是在训练数据中创建随机翻转的图像。
+
+Keras 支持使用 vertical_flip 和 horizo​​ntal_flip 参数沿垂直轴和水平轴进行随机翻转。
+
+```
+# Random Flips
+from keras.datasets import mnist
+from keras.preprocessing.image import ImageDataGenerator
+from matplotlib import pyplot
+from keras import backend as K
+K.set_image_dim_ordering('th')
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# reshape to be [samples][pixels][width][height]
+X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
+X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
+# convert from int to float
+X_train = X_train.astype('float32')
+X_test = X_test.astype('float32')
+# define data preparation
+datagen = ImageDataGenerator(horizontal_flip=True, vertical_flip=True)
+# fit parameters from data
+datagen.fit(X_train)
+# configure batch size and retrieve one batch of images
+for X_batch, y_batch in datagen.flow(X_train, y_train, batch_size=9):
+	# create a grid of 3x3 images
+	for i in range(0, 9):
+		pyplot.subplot(330 + 1 + i)
+		pyplot.imshow(X_batch[i].reshape(28, 28), cmap=pyplot.get_cmap('gray'))
+	# show the plot
+	pyplot.show()
+	break
+```
+
+运行此示例，您可以看到翻转的数字。翻转数字没有用，因为它们总是具有正确的左右方向，但这对于场景中可以具有不同方向的对象的照片的问题可能是有用的。
+
+![Randomly Flipped MNIST Images](img/a054ee10ec3175a6e81b8a511f36da6d.jpg)
+
+随机翻转 MNIST 图像
+
+## 将增强图像保存到文件
+
+数据准备和增强由 Keras 及时执行。
+
+这在内存方面很有效，但您可能需要在训练期间使用的确切图像。例如，您可能希望稍后将它们与不同的软件包一起使用，或者仅生成一次并在多个不同的深度学习模型或配置中使用它们。
+
+Keras 允许您保存训练期间生成的图像。可以在训练之前将目录，文件名前缀和图像文件类型指定给 flow（）函数。然后，在训练期间，生成的图像将被写入文件。
+
+下面的示例演示了这一点，并将 9 个图像写入“images”子目录，前缀为“aug”，文件类型为 PNG。
+
+```
+# Save augmented images to file
+from keras.datasets import mnist
+from keras.preprocessing.image import ImageDataGenerator
+from matplotlib import pyplot
+import os
+from keras import backend as K
+K.set_image_dim_ordering('th')
+# load data
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+# reshape to be [samples][pixels][width][height]
+X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
+X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
+# convert from int to float
+X_train = X_train.astype('float32')
+X_test = X_test.astype('float32')
+# define data preparation
+datagen = ImageDataGenerator()
+# fit parameters from data
+datagen.fit(X_train)
+# configure batch size and retrieve one batch of images
+os.makedirs('images')
+for X_batch, y_batch in datagen.flow(X_train, y_train, batch_size=9, save_to_dir='images', save_prefix='aug', save_format='png'):
+	# create a grid of 3x3 images
+	for i in range(0, 9):
+		pyplot.subplot(330 + 1 + i)
+		pyplot.imshow(X_batch[i].reshape(28, 28), cmap=pyplot.get_cmap('gray'))
+	# show the plot
+	pyplot.show()
+	break
+```
+
+运行该示例，您可以看到图像仅在生成时写入。
+
+![Augmented MNIST Images Saved To File](img/411af1874839fc85236ad1da133db167.jpg)
+
+增强的 MNIST 图像保存到文件
+
+## 使用 Keras 增强图像数据的技巧
+
+图像数据的独特之处在于，您可以查看数据和转换的数据副本，并快速了解模型如何感知模型。
+
+以下是一些从图像数据准备和深度学习扩充中获取最多的技巧。
+
+*   **审查数据集**。花些时间详细检查您的数据集。看看图片。记下可能有益于模型训练过程的图像准备和扩充，例如需要处理场景中对象的不同移位，旋转或翻转。
+*   **审查增补**。在执行增强后查看样本图像。知识分子知道您正在使用的图像变换是一回事，看一些例子是一件非常不同的事情。使用您正在使用的单个扩充以及您计划使用的全套扩充来查看图像。您可能会看到简化或进一步增强模型培训流程的方法。
+*   **评估变换套件**。尝试多个图像数据准备和增强方案。通常，您可能会对您认为不会有益的数据准备方案的结果感到惊讶。
+
+## 摘要
+
+在这篇文章中，您发现了图像数据准备和扩充。
+
+您发现了一系列技术，您可以在 Python 中轻松使用 Keras 进行深度学习模型。你了解到：
+
+*   Keras 中的 ImageDataGenerator API 用于及时生成转换后的图像。
+*   采样和功能明智的像素标准化。
+*   ZCA 美白变换。
+*   随机旋转，移位和翻转图像。
+*   如何将转换后的图像保存到文件中以供以后重用。
+
+您对图像数据增加或此帖有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/img/01f3d67c5792b6695bbc5759d32f9ad4.png b/docs/dl-keras/img/01f3d67c5792b6695bbc5759d32f9ad4.png
new file mode 100644
index 0000000000000000000000000000000000000000..84f0db1b999cf92e2bf4cb051e13e0c3f10f277a
Binary files /dev/null and b/docs/dl-keras/img/01f3d67c5792b6695bbc5759d32f9ad4.png differ
diff --git a/docs/dl-keras/img/029826d677dd0afb9af83862a1eabd0e.png b/docs/dl-keras/img/029826d677dd0afb9af83862a1eabd0e.png
new file mode 100644
index 0000000000000000000000000000000000000000..87730c8d14c589b48adf82d466449de6f4a95fec
Binary files /dev/null and b/docs/dl-keras/img/029826d677dd0afb9af83862a1eabd0e.png differ
diff --git a/docs/dl-keras/img/070851788dabfc54104852fe22f56b44.png b/docs/dl-keras/img/070851788dabfc54104852fe22f56b44.png
new file mode 100644
index 0000000000000000000000000000000000000000..ea6c9717ba54a6f9c8201c03d8ffd4097bd3713b
Binary files /dev/null and b/docs/dl-keras/img/070851788dabfc54104852fe22f56b44.png differ
diff --git a/docs/dl-keras/img/07aad7228d9e13432d15e81820ae2199.png b/docs/dl-keras/img/07aad7228d9e13432d15e81820ae2199.png
new file mode 100644
index 0000000000000000000000000000000000000000..6599684cfd386250feb0001ea637722555ccb093
Binary files /dev/null and b/docs/dl-keras/img/07aad7228d9e13432d15e81820ae2199.png differ
diff --git a/docs/dl-keras/img/1370ade3cc9bd5feb94a1be0c1c87369.png b/docs/dl-keras/img/1370ade3cc9bd5feb94a1be0c1c87369.png
new file mode 100644
index 0000000000000000000000000000000000000000..ce6ace21005e4deefbacbe27e7fa267b3ab66105
Binary files /dev/null and b/docs/dl-keras/img/1370ade3cc9bd5feb94a1be0c1c87369.png differ
diff --git a/docs/dl-keras/img/17428dfdb9702ab6ce021befb3d7b812.png b/docs/dl-keras/img/17428dfdb9702ab6ce021befb3d7b812.png
new file mode 100644
index 0000000000000000000000000000000000000000..1ad7b19fa23dfdf38448fab0d59c8051a192c9d7
Binary files /dev/null and b/docs/dl-keras/img/17428dfdb9702ab6ce021befb3d7b812.png differ
diff --git a/docs/dl-keras/img/18af9b56f22eba68918a4ceaa17405a2.png b/docs/dl-keras/img/18af9b56f22eba68918a4ceaa17405a2.png
new file mode 100644
index 0000000000000000000000000000000000000000..1b7a811dd5e836c5b77d6f7454dd4d84d313f82e
Binary files /dev/null and b/docs/dl-keras/img/18af9b56f22eba68918a4ceaa17405a2.png differ
diff --git a/docs/dl-keras/img/1a156e687268e204c213d96733179234.png b/docs/dl-keras/img/1a156e687268e204c213d96733179234.png
new file mode 100644
index 0000000000000000000000000000000000000000..eae85faca82f1fa0882a771b3a6c07b4c82c0da2
Binary files /dev/null and b/docs/dl-keras/img/1a156e687268e204c213d96733179234.png differ
diff --git a/docs/dl-keras/img/1d019ff799ebac1cbdf3559f9ffaba1e.png b/docs/dl-keras/img/1d019ff799ebac1cbdf3559f9ffaba1e.png
new file mode 100644
index 0000000000000000000000000000000000000000..2ecbe92cdba92e4a0a1415d5b456dd55a66b3f67
Binary files /dev/null and b/docs/dl-keras/img/1d019ff799ebac1cbdf3559f9ffaba1e.png differ
diff --git a/docs/dl-keras/img/1f3275bfb5407176028269720f3a11da.png b/docs/dl-keras/img/1f3275bfb5407176028269720f3a11da.png
new file mode 100644
index 0000000000000000000000000000000000000000..5e900d0339658a3e49376381d40c74cc6290799c
Binary files /dev/null and b/docs/dl-keras/img/1f3275bfb5407176028269720f3a11da.png differ
diff --git a/docs/dl-keras/img/1f56d629c36a38157a077936baca1aee.png b/docs/dl-keras/img/1f56d629c36a38157a077936baca1aee.png
new file mode 100644
index 0000000000000000000000000000000000000000..bbb2f3f1491a3af8287af3ea2bda028f0b6e045d
Binary files /dev/null and b/docs/dl-keras/img/1f56d629c36a38157a077936baca1aee.png differ
diff --git a/docs/dl-keras/img/1ff32d002f02ee2ec7be1f308faffc6b.png b/docs/dl-keras/img/1ff32d002f02ee2ec7be1f308faffc6b.png
new file mode 100644
index 0000000000000000000000000000000000000000..171521b40081789fb71b5c19c7211e39e290e0ba
Binary files /dev/null and b/docs/dl-keras/img/1ff32d002f02ee2ec7be1f308faffc6b.png differ
diff --git a/docs/dl-keras/img/23bddb450fa7cd93bad158899043b4ee.png b/docs/dl-keras/img/23bddb450fa7cd93bad158899043b4ee.png
new file mode 100644
index 0000000000000000000000000000000000000000..b6d3af83b3b1419d59df7e977be7b53ea3269ca3
Binary files /dev/null and b/docs/dl-keras/img/23bddb450fa7cd93bad158899043b4ee.png differ
diff --git a/docs/dl-keras/img/2501396e3f59ad04cd824226eeae9ede.png b/docs/dl-keras/img/2501396e3f59ad04cd824226eeae9ede.png
new file mode 100644
index 0000000000000000000000000000000000000000..6c5daeb6b5d6a0f46d93367764e5188e3b331451
Binary files /dev/null and b/docs/dl-keras/img/2501396e3f59ad04cd824226eeae9ede.png differ
diff --git a/docs/dl-keras/img/256dfb575d54b2eec4be14c906ce2c11.png b/docs/dl-keras/img/256dfb575d54b2eec4be14c906ce2c11.png
new file mode 100644
index 0000000000000000000000000000000000000000..30a48dc38a5e30deef5fd0a5a4506252208be6ca
Binary files /dev/null and b/docs/dl-keras/img/256dfb575d54b2eec4be14c906ce2c11.png differ
diff --git a/docs/dl-keras/img/265192f5c88c8a78da52ecabd638aaa9.png b/docs/dl-keras/img/265192f5c88c8a78da52ecabd638aaa9.png
new file mode 100644
index 0000000000000000000000000000000000000000..1c96106d9aa62fcbc2a2b615693a2e349f86eeb7
Binary files /dev/null and b/docs/dl-keras/img/265192f5c88c8a78da52ecabd638aaa9.png differ
diff --git a/docs/dl-keras/img/28a944c830ffc6a1fd896c1df6c953e5.png b/docs/dl-keras/img/28a944c830ffc6a1fd896c1df6c953e5.png
new file mode 100644
index 0000000000000000000000000000000000000000..168e7b14c9447095dd24856afeb4a92b761535e5
Binary files /dev/null and b/docs/dl-keras/img/28a944c830ffc6a1fd896c1df6c953e5.png differ
diff --git a/docs/dl-keras/img/299672cd2b9efa26d634b06c4df2e751.png b/docs/dl-keras/img/299672cd2b9efa26d634b06c4df2e751.png
new file mode 100644
index 0000000000000000000000000000000000000000..3046a9b2f7d8b8edd53cfbedec4749e4e7a090b9
Binary files /dev/null and b/docs/dl-keras/img/299672cd2b9efa26d634b06c4df2e751.png differ
diff --git a/docs/dl-keras/img/2996eabdf1f9d9a0bc2b5e1c62d6b4e5.png b/docs/dl-keras/img/2996eabdf1f9d9a0bc2b5e1c62d6b4e5.png
new file mode 100644
index 0000000000000000000000000000000000000000..455bb92e0b7ae525982b72bd1cfc20bdc1a50a39
Binary files /dev/null and b/docs/dl-keras/img/2996eabdf1f9d9a0bc2b5e1c62d6b4e5.png differ
diff --git a/docs/dl-keras/img/299fb4248be9f10daf6e16e3069a834d.png b/docs/dl-keras/img/299fb4248be9f10daf6e16e3069a834d.png
new file mode 100644
index 0000000000000000000000000000000000000000..4533348dd2f09ab4a787747202781c62d93bc62b
Binary files /dev/null and b/docs/dl-keras/img/299fb4248be9f10daf6e16e3069a834d.png differ
diff --git a/docs/dl-keras/img/2dae7dc453b9ee9eecf2783612250927.png b/docs/dl-keras/img/2dae7dc453b9ee9eecf2783612250927.png
new file mode 100644
index 0000000000000000000000000000000000000000..afde92c2f76635797327dacb62edba1c4ee3ca6c
Binary files /dev/null and b/docs/dl-keras/img/2dae7dc453b9ee9eecf2783612250927.png differ
diff --git a/docs/dl-keras/img/2f778185ceac552e5d1ee21c4cdd45b1.png b/docs/dl-keras/img/2f778185ceac552e5d1ee21c4cdd45b1.png
new file mode 100644
index 0000000000000000000000000000000000000000..1b835c93d731a55b806a2441d574b0b28bfa2368
Binary files /dev/null and b/docs/dl-keras/img/2f778185ceac552e5d1ee21c4cdd45b1.png differ
diff --git a/docs/dl-keras/img/2ff0956a0537ec5bd319693e3ac5b79a.png b/docs/dl-keras/img/2ff0956a0537ec5bd319693e3ac5b79a.png
new file mode 100644
index 0000000000000000000000000000000000000000..80ba6a0928000fdb8e8108ceda5272e7c71cf684
Binary files /dev/null and b/docs/dl-keras/img/2ff0956a0537ec5bd319693e3ac5b79a.png differ
diff --git a/docs/dl-keras/img/30e6e1be6cd09de3ce9d725b9ca33188.png b/docs/dl-keras/img/30e6e1be6cd09de3ce9d725b9ca33188.png
new file mode 100644
index 0000000000000000000000000000000000000000..42425939f1c2eb57f77e8891524cb4aae02035a4
Binary files /dev/null and b/docs/dl-keras/img/30e6e1be6cd09de3ce9d725b9ca33188.png differ
diff --git a/docs/dl-keras/img/33d8cdc3cb4fecc654bce247b69af0bc.png b/docs/dl-keras/img/33d8cdc3cb4fecc654bce247b69af0bc.png
new file mode 100644
index 0000000000000000000000000000000000000000..c5b4c55b18f20e8d8a26ab1c0d3a5750928c051b
Binary files /dev/null and b/docs/dl-keras/img/33d8cdc3cb4fecc654bce247b69af0bc.png differ
diff --git a/docs/dl-keras/img/37f8b123630baa4ea9ced3b21e1ebed6.png b/docs/dl-keras/img/37f8b123630baa4ea9ced3b21e1ebed6.png
new file mode 100644
index 0000000000000000000000000000000000000000..f0c294e36f5f6802d7691090e660e1dd9483a727
Binary files /dev/null and b/docs/dl-keras/img/37f8b123630baa4ea9ced3b21e1ebed6.png differ
diff --git a/docs/dl-keras/img/3aa11a0f106d6a9d26e5ff0f0928e835.png b/docs/dl-keras/img/3aa11a0f106d6a9d26e5ff0f0928e835.png
new file mode 100644
index 0000000000000000000000000000000000000000..63ee10545c136e19595ded479f3393e76068f903
Binary files /dev/null and b/docs/dl-keras/img/3aa11a0f106d6a9d26e5ff0f0928e835.png differ
diff --git a/docs/dl-keras/img/3e261540d96ebda34701ebd35f653fd5.png b/docs/dl-keras/img/3e261540d96ebda34701ebd35f653fd5.png
new file mode 100644
index 0000000000000000000000000000000000000000..1aed49a095b758d0f88dcde0f4bebc9f39848f50
Binary files /dev/null and b/docs/dl-keras/img/3e261540d96ebda34701ebd35f653fd5.png differ
diff --git a/docs/dl-keras/img/3e7ff435faae5d295db3318aa75ce44e.png b/docs/dl-keras/img/3e7ff435faae5d295db3318aa75ce44e.png
new file mode 100644
index 0000000000000000000000000000000000000000..2aea18fe18bbd66656efb3e214cb5a4f53a229bb
Binary files /dev/null and b/docs/dl-keras/img/3e7ff435faae5d295db3318aa75ce44e.png differ
diff --git a/docs/dl-keras/img/411af1874839fc85236ad1da133db167.png b/docs/dl-keras/img/411af1874839fc85236ad1da133db167.png
new file mode 100644
index 0000000000000000000000000000000000000000..1f1d865d6d215b055f0db9b6db9ee8af67ed9731
Binary files /dev/null and b/docs/dl-keras/img/411af1874839fc85236ad1da133db167.png differ
diff --git a/docs/dl-keras/img/429db1e26cf59719f9b941d5e8a7b919.png b/docs/dl-keras/img/429db1e26cf59719f9b941d5e8a7b919.png
new file mode 100644
index 0000000000000000000000000000000000000000..cf1f048fa4c03a2b75be471115eff8eeb52d5968
Binary files /dev/null and b/docs/dl-keras/img/429db1e26cf59719f9b941d5e8a7b919.png differ
diff --git a/docs/dl-keras/img/498ab2d8740c6a44a78ade60a46c95a9.png b/docs/dl-keras/img/498ab2d8740c6a44a78ade60a46c95a9.png
new file mode 100644
index 0000000000000000000000000000000000000000..1c82a917f8a6f530c5c3a3b2175c336b153dbe2e
Binary files /dev/null and b/docs/dl-keras/img/498ab2d8740c6a44a78ade60a46c95a9.png differ
diff --git a/docs/dl-keras/img/4ae1e83ece36ea618e1ec2f6cbbbeb1f.png b/docs/dl-keras/img/4ae1e83ece36ea618e1ec2f6cbbbeb1f.png
new file mode 100644
index 0000000000000000000000000000000000000000..1a78cf48b5a3716a7a9cd6ee0e3bf7bec7430f2e
Binary files /dev/null and b/docs/dl-keras/img/4ae1e83ece36ea618e1ec2f6cbbbeb1f.png differ
diff --git a/docs/dl-keras/img/4ae90ba8e51222dd47048dad32a96128.png b/docs/dl-keras/img/4ae90ba8e51222dd47048dad32a96128.png
new file mode 100644
index 0000000000000000000000000000000000000000..88f6d409640efeac2e1b90bb1ccf251388cbae11
Binary files /dev/null and b/docs/dl-keras/img/4ae90ba8e51222dd47048dad32a96128.png differ
diff --git a/docs/dl-keras/img/55f115adb23074958d7ba0cc5e9d3806.png b/docs/dl-keras/img/55f115adb23074958d7ba0cc5e9d3806.png
new file mode 100644
index 0000000000000000000000000000000000000000..0f90fbe7b987462733ae94193adb3db492fed330
Binary files /dev/null and b/docs/dl-keras/img/55f115adb23074958d7ba0cc5e9d3806.png differ
diff --git a/docs/dl-keras/img/5b3d95a2ac65cd8206b3a11433959297.png b/docs/dl-keras/img/5b3d95a2ac65cd8206b3a11433959297.png
new file mode 100644
index 0000000000000000000000000000000000000000..0ee3fb199cad9043e6f43f7b1d3f5161f360e7e8
Binary files /dev/null and b/docs/dl-keras/img/5b3d95a2ac65cd8206b3a11433959297.png differ
diff --git a/docs/dl-keras/img/5bb2f88423069cc64dda533c02cb29d3.png b/docs/dl-keras/img/5bb2f88423069cc64dda533c02cb29d3.png
new file mode 100644
index 0000000000000000000000000000000000000000..011c49bb00fc892dcb60cf697ef916f63ba98251
Binary files /dev/null and b/docs/dl-keras/img/5bb2f88423069cc64dda533c02cb29d3.png differ
diff --git a/docs/dl-keras/img/5c59c425196cb23cb43afa5a74345b1e.png b/docs/dl-keras/img/5c59c425196cb23cb43afa5a74345b1e.png
new file mode 100644
index 0000000000000000000000000000000000000000..95b19c9861be8c68a6ae12eba586bfe5d1e749c2
Binary files /dev/null and b/docs/dl-keras/img/5c59c425196cb23cb43afa5a74345b1e.png differ
diff --git a/docs/dl-keras/img/5c9247c398565f2d0ac41322dac602d7.png b/docs/dl-keras/img/5c9247c398565f2d0ac41322dac602d7.png
new file mode 100644
index 0000000000000000000000000000000000000000..b0c2dc6f0747ffebb1a2a658679999a904934e41
Binary files /dev/null and b/docs/dl-keras/img/5c9247c398565f2d0ac41322dac602d7.png differ
diff --git a/docs/dl-keras/img/6074ebf72c384434cedd2411d8a7f962.png b/docs/dl-keras/img/6074ebf72c384434cedd2411d8a7f962.png
new file mode 100644
index 0000000000000000000000000000000000000000..eb4af54e207db76741d1f85d553f20e5adfe0692
Binary files /dev/null and b/docs/dl-keras/img/6074ebf72c384434cedd2411d8a7f962.png differ
diff --git a/docs/dl-keras/img/659eb8361ecfc07bb1b54bbb96a44de5.png b/docs/dl-keras/img/659eb8361ecfc07bb1b54bbb96a44de5.png
new file mode 100644
index 0000000000000000000000000000000000000000..35db60e1957d1fd46b03ed8c82bca7fa82ec68be
Binary files /dev/null and b/docs/dl-keras/img/659eb8361ecfc07bb1b54bbb96a44de5.png differ
diff --git a/docs/dl-keras/img/65a7874651021d24638d4636aa14a1d4.png b/docs/dl-keras/img/65a7874651021d24638d4636aa14a1d4.png
new file mode 100644
index 0000000000000000000000000000000000000000..2ca6a121f59dae1f6cb68854d1cd4ab3c52641cf
Binary files /dev/null and b/docs/dl-keras/img/65a7874651021d24638d4636aa14a1d4.png differ
diff --git a/docs/dl-keras/img/662da48b47adc3aaeccc61fa6245b2a0.png b/docs/dl-keras/img/662da48b47adc3aaeccc61fa6245b2a0.png
new file mode 100644
index 0000000000000000000000000000000000000000..4aedc1ab08772ff14e2799647c7bf9a4b149792d
Binary files /dev/null and b/docs/dl-keras/img/662da48b47adc3aaeccc61fa6245b2a0.png differ
diff --git a/docs/dl-keras/img/6d16e08f6dc1ca8376aec45e7f10e5ac.png b/docs/dl-keras/img/6d16e08f6dc1ca8376aec45e7f10e5ac.png
new file mode 100644
index 0000000000000000000000000000000000000000..16c14f0ae65a3ca6e2eb2597cd6e58f6ea45e961
Binary files /dev/null and b/docs/dl-keras/img/6d16e08f6dc1ca8376aec45e7f10e5ac.png differ
diff --git a/docs/dl-keras/img/717ae728128d92f139938bd1c4c3b457.png b/docs/dl-keras/img/717ae728128d92f139938bd1c4c3b457.png
new file mode 100644
index 0000000000000000000000000000000000000000..a0695086641df3b59fb70a265f8b4819345e0cf8
Binary files /dev/null and b/docs/dl-keras/img/717ae728128d92f139938bd1c4c3b457.png differ
diff --git a/docs/dl-keras/img/756b3d773ebebb0faba54b7006da3120.png b/docs/dl-keras/img/756b3d773ebebb0faba54b7006da3120.png
new file mode 100644
index 0000000000000000000000000000000000000000..0f946d04789c8d02de8ab093339e7f2a83ee35ba
Binary files /dev/null and b/docs/dl-keras/img/756b3d773ebebb0faba54b7006da3120.png differ
diff --git a/docs/dl-keras/img/79c8df17f76c38e054a8760b935e6ed9.png b/docs/dl-keras/img/79c8df17f76c38e054a8760b935e6ed9.png
new file mode 100644
index 0000000000000000000000000000000000000000..759073f8d976d36731d2a98f087654d422e2cfaa
Binary files /dev/null and b/docs/dl-keras/img/79c8df17f76c38e054a8760b935e6ed9.png differ
diff --git a/docs/dl-keras/img/7a15249820eaff950ac0e36a690b5b32.png b/docs/dl-keras/img/7a15249820eaff950ac0e36a690b5b32.png
new file mode 100644
index 0000000000000000000000000000000000000000..f41d9c9c00446c0f56bcc4c192203c32059d7c28
Binary files /dev/null and b/docs/dl-keras/img/7a15249820eaff950ac0e36a690b5b32.png differ
diff --git a/docs/dl-keras/img/7b1c3b4ef1fa6b37c0eb0bd04b82eb26.png b/docs/dl-keras/img/7b1c3b4ef1fa6b37c0eb0bd04b82eb26.png
new file mode 100644
index 0000000000000000000000000000000000000000..f5fe2dad96642a82d217cafdd8bf189cb68237f9
Binary files /dev/null and b/docs/dl-keras/img/7b1c3b4ef1fa6b37c0eb0bd04b82eb26.png differ
diff --git a/docs/dl-keras/img/7be6d7bf030fac7196c7ff7c227cc0c1.png b/docs/dl-keras/img/7be6d7bf030fac7196c7ff7c227cc0c1.png
new file mode 100644
index 0000000000000000000000000000000000000000..293a556d84a85efdec79f98f1244a69705a6c7f3
Binary files /dev/null and b/docs/dl-keras/img/7be6d7bf030fac7196c7ff7c227cc0c1.png differ
diff --git a/docs/dl-keras/img/7c82a23fe9ca5ce16ae054ff7260f3f0.png b/docs/dl-keras/img/7c82a23fe9ca5ce16ae054ff7260f3f0.png
new file mode 100644
index 0000000000000000000000000000000000000000..54f6c246e82cf4746c533adaf1c0747b21df345a
Binary files /dev/null and b/docs/dl-keras/img/7c82a23fe9ca5ce16ae054ff7260f3f0.png differ
diff --git a/docs/dl-keras/img/7e971b08f1a9d6b073c9659bc13010e5.png b/docs/dl-keras/img/7e971b08f1a9d6b073c9659bc13010e5.png
new file mode 100644
index 0000000000000000000000000000000000000000..57cd4259420d797e5ff2c708fdc01ffbf9bba713
Binary files /dev/null and b/docs/dl-keras/img/7e971b08f1a9d6b073c9659bc13010e5.png differ
diff --git a/docs/dl-keras/img/813384c9d73f15abe34aa5f55bd5ddfa.png b/docs/dl-keras/img/813384c9d73f15abe34aa5f55bd5ddfa.png
new file mode 100644
index 0000000000000000000000000000000000000000..3f7af48cb0915e3d109c242e020c083ff701d4e8
Binary files /dev/null and b/docs/dl-keras/img/813384c9d73f15abe34aa5f55bd5ddfa.png differ
diff --git a/docs/dl-keras/img/81ba8599de669cbdd390ffde16096c83.png b/docs/dl-keras/img/81ba8599de669cbdd390ffde16096c83.png
new file mode 100644
index 0000000000000000000000000000000000000000..2e3b4acd0433ac9bf3c4a247f750c7cecac53674
Binary files /dev/null and b/docs/dl-keras/img/81ba8599de669cbdd390ffde16096c83.png differ
diff --git a/docs/dl-keras/img/827f7a153d004f35332b92fb724b1b92.png b/docs/dl-keras/img/827f7a153d004f35332b92fb724b1b92.png
new file mode 100644
index 0000000000000000000000000000000000000000..4deecb7f9f460583affb8acffed1151215b2c860
Binary files /dev/null and b/docs/dl-keras/img/827f7a153d004f35332b92fb724b1b92.png differ
diff --git a/docs/dl-keras/img/8d5c11180494f5fb0ec35218148e7d7b.png b/docs/dl-keras/img/8d5c11180494f5fb0ec35218148e7d7b.png
new file mode 100644
index 0000000000000000000000000000000000000000..61d10780dbb038e98c090dbfd15585552ae8f419
Binary files /dev/null and b/docs/dl-keras/img/8d5c11180494f5fb0ec35218148e7d7b.png differ
diff --git a/docs/dl-keras/img/8e1689ec640a31d8358af77078ac6bfb.png b/docs/dl-keras/img/8e1689ec640a31d8358af77078ac6bfb.png
new file mode 100644
index 0000000000000000000000000000000000000000..61e269ea9b1671f7555303bc4617f83a1cd1cdc0
Binary files /dev/null and b/docs/dl-keras/img/8e1689ec640a31d8358af77078ac6bfb.png differ
diff --git a/docs/dl-keras/img/8f6199089c1bc957ea5e0a9d478c098a.png b/docs/dl-keras/img/8f6199089c1bc957ea5e0a9d478c098a.png
new file mode 100644
index 0000000000000000000000000000000000000000..1944bef3279c10146c54d83df1d3f0228c5e957a
Binary files /dev/null and b/docs/dl-keras/img/8f6199089c1bc957ea5e0a9d478c098a.png differ
diff --git a/docs/dl-keras/img/9226be57337d5beb79c53462cb99daad.png b/docs/dl-keras/img/9226be57337d5beb79c53462cb99daad.png
new file mode 100644
index 0000000000000000000000000000000000000000..bb39a7a66a135d1553d29bda1217d6e11f4036d8
Binary files /dev/null and b/docs/dl-keras/img/9226be57337d5beb79c53462cb99daad.png differ
diff --git a/docs/dl-keras/img/945bc23e6b2a065508c17f058c6a7992.png b/docs/dl-keras/img/945bc23e6b2a065508c17f058c6a7992.png
new file mode 100644
index 0000000000000000000000000000000000000000..5eca770a38bca940912b7e5907098ea550436cc4
Binary files /dev/null and b/docs/dl-keras/img/945bc23e6b2a065508c17f058c6a7992.png differ
diff --git a/docs/dl-keras/img/95f6701c22073478af5f7e8f88aaf8b5.png b/docs/dl-keras/img/95f6701c22073478af5f7e8f88aaf8b5.png
new file mode 100644
index 0000000000000000000000000000000000000000..bc643936d46643e4d71c600fe298fc233b9ba176
Binary files /dev/null and b/docs/dl-keras/img/95f6701c22073478af5f7e8f88aaf8b5.png differ
diff --git a/docs/dl-keras/img/97a5a2d7ca50d98d6dd0d2787ea7bd18.png b/docs/dl-keras/img/97a5a2d7ca50d98d6dd0d2787ea7bd18.png
new file mode 100644
index 0000000000000000000000000000000000000000..7f19fb2d2660666e64d9bc6702ce14ef90b8f3e7
Binary files /dev/null and b/docs/dl-keras/img/97a5a2d7ca50d98d6dd0d2787ea7bd18.png differ
diff --git a/docs/dl-keras/img/98d0e7f8e58b0a5cb817d172e0256fe0.png b/docs/dl-keras/img/98d0e7f8e58b0a5cb817d172e0256fe0.png
new file mode 100644
index 0000000000000000000000000000000000000000..a3adf07041f995ad66314fea76cccf756265a6eb
Binary files /dev/null and b/docs/dl-keras/img/98d0e7f8e58b0a5cb817d172e0256fe0.png differ
diff --git a/docs/dl-keras/img/99ef23d86f8af9e053b6b74255fdab0f.png b/docs/dl-keras/img/99ef23d86f8af9e053b6b74255fdab0f.png
new file mode 100644
index 0000000000000000000000000000000000000000..9b1b738b2a0062e048a5882e1ced3d2df2dc6e61
Binary files /dev/null and b/docs/dl-keras/img/99ef23d86f8af9e053b6b74255fdab0f.png differ
diff --git a/docs/dl-keras/img/9cf44410774b0c5f0b4c55ecc97e2692.png b/docs/dl-keras/img/9cf44410774b0c5f0b4c55ecc97e2692.png
new file mode 100644
index 0000000000000000000000000000000000000000..46a83316276f3fbbb76ed533ab91e836d4998587
Binary files /dev/null and b/docs/dl-keras/img/9cf44410774b0c5f0b4c55ecc97e2692.png differ
diff --git a/docs/dl-keras/img/a054ee10ec3175a6e81b8a511f36da6d.png b/docs/dl-keras/img/a054ee10ec3175a6e81b8a511f36da6d.png
new file mode 100644
index 0000000000000000000000000000000000000000..661942ebc766745274da747f35ab84a4f5f5fed5
Binary files /dev/null and b/docs/dl-keras/img/a054ee10ec3175a6e81b8a511f36da6d.png differ
diff --git a/docs/dl-keras/img/a1a0554742400bb687dd331e6f95e77b.png b/docs/dl-keras/img/a1a0554742400bb687dd331e6f95e77b.png
new file mode 100644
index 0000000000000000000000000000000000000000..e54495c7d3f122d65db7b28ab5c667e68bb337d1
Binary files /dev/null and b/docs/dl-keras/img/a1a0554742400bb687dd331e6f95e77b.png differ
diff --git a/docs/dl-keras/img/a1c44e0b21366d4a6326b44bd4e31679.png b/docs/dl-keras/img/a1c44e0b21366d4a6326b44bd4e31679.png
new file mode 100644
index 0000000000000000000000000000000000000000..4daa2b237e5a260e14bc89a939df405d09335c73
Binary files /dev/null and b/docs/dl-keras/img/a1c44e0b21366d4a6326b44bd4e31679.png differ
diff --git a/docs/dl-keras/img/a56adc566715868c4b9c5b56941c5a53.png b/docs/dl-keras/img/a56adc566715868c4b9c5b56941c5a53.png
new file mode 100644
index 0000000000000000000000000000000000000000..6e50adafa7be6e894ab80c33ec64552164e42ead
Binary files /dev/null and b/docs/dl-keras/img/a56adc566715868c4b9c5b56941c5a53.png differ
diff --git a/docs/dl-keras/img/a6423d666cd09de47bcf0660509102c6.png b/docs/dl-keras/img/a6423d666cd09de47bcf0660509102c6.png
new file mode 100644
index 0000000000000000000000000000000000000000..af473ebc8000fca471ea8bbdc5bc59df88946e8d
Binary files /dev/null and b/docs/dl-keras/img/a6423d666cd09de47bcf0660509102c6.png differ
diff --git a/docs/dl-keras/img/a73a28eb8d953d02fd5d02416b785c78.png b/docs/dl-keras/img/a73a28eb8d953d02fd5d02416b785c78.png
new file mode 100644
index 0000000000000000000000000000000000000000..b38ddfeb21e721fd7f82e644681441fbece6db75
Binary files /dev/null and b/docs/dl-keras/img/a73a28eb8d953d02fd5d02416b785c78.png differ
diff --git a/docs/dl-keras/img/a88ebb815922dc1277b935534416294a.png b/docs/dl-keras/img/a88ebb815922dc1277b935534416294a.png
new file mode 100644
index 0000000000000000000000000000000000000000..ae8bcee02dbb4a2271e5f57f38b4649ea6d49a61
Binary files /dev/null and b/docs/dl-keras/img/a88ebb815922dc1277b935534416294a.png differ
diff --git a/docs/dl-keras/img/a996a23eabeb4945e5ff491773bcb951.png b/docs/dl-keras/img/a996a23eabeb4945e5ff491773bcb951.png
new file mode 100644
index 0000000000000000000000000000000000000000..7d6ab84258ff4d2391fbd6b72ebb41a49f0f58f8
Binary files /dev/null and b/docs/dl-keras/img/a996a23eabeb4945e5ff491773bcb951.png differ
diff --git a/docs/dl-keras/img/aa735153796f8cda098d2fe7fb675e75.png b/docs/dl-keras/img/aa735153796f8cda098d2fe7fb675e75.png
new file mode 100644
index 0000000000000000000000000000000000000000..9f3f442a991e571c8470e239aae34155cfc14a96
Binary files /dev/null and b/docs/dl-keras/img/aa735153796f8cda098d2fe7fb675e75.png differ
diff --git a/docs/dl-keras/img/ae4bbe3728d2ae14a8486fd00fc87a8b.png b/docs/dl-keras/img/ae4bbe3728d2ae14a8486fd00fc87a8b.png
new file mode 100644
index 0000000000000000000000000000000000000000..2ddeaa8e0f2275983c26579f03bf1fda83005dd3
Binary files /dev/null and b/docs/dl-keras/img/ae4bbe3728d2ae14a8486fd00fc87a8b.png differ
diff --git a/docs/dl-keras/img/b146789c05a7cd65c9b0afcfc33dcd5e.png b/docs/dl-keras/img/b146789c05a7cd65c9b0afcfc33dcd5e.png
new file mode 100644
index 0000000000000000000000000000000000000000..b99c932eed681717ff33fa8dd65aa5d42bb2f265
Binary files /dev/null and b/docs/dl-keras/img/b146789c05a7cd65c9b0afcfc33dcd5e.png differ
diff --git a/docs/dl-keras/img/b30037d88d3bce9c780e5eae957be293.png b/docs/dl-keras/img/b30037d88d3bce9c780e5eae957be293.png
new file mode 100644
index 0000000000000000000000000000000000000000..0032f1cde880b5642c95bbd8b08f526cfa4c5c08
Binary files /dev/null and b/docs/dl-keras/img/b30037d88d3bce9c780e5eae957be293.png differ
diff --git a/docs/dl-keras/img/ba26805ccbbb3318546dbf2663ddbef9.png b/docs/dl-keras/img/ba26805ccbbb3318546dbf2663ddbef9.png
new file mode 100644
index 0000000000000000000000000000000000000000..f415159ba55f398287c18732e2b093ea53aa2628
Binary files /dev/null and b/docs/dl-keras/img/ba26805ccbbb3318546dbf2663ddbef9.png differ
diff --git a/docs/dl-keras/img/bb63b33d778d9f3aa7c05ecc5ef6f642.png b/docs/dl-keras/img/bb63b33d778d9f3aa7c05ecc5ef6f642.png
new file mode 100644
index 0000000000000000000000000000000000000000..9bc0117942a7bda116825f12ef60fa7f5905ee3e
Binary files /dev/null and b/docs/dl-keras/img/bb63b33d778d9f3aa7c05ecc5ef6f642.png differ
diff --git a/docs/dl-keras/img/bb8620c8c9ed94e3f29dd3ac43cd7ed1.png b/docs/dl-keras/img/bb8620c8c9ed94e3f29dd3ac43cd7ed1.png
new file mode 100644
index 0000000000000000000000000000000000000000..242f0d578acf8e363fe1cdbd6043ee082a445217
Binary files /dev/null and b/docs/dl-keras/img/bb8620c8c9ed94e3f29dd3ac43cd7ed1.png differ
diff --git a/docs/dl-keras/img/bc688ef2476b30e081706f5cb16dd727.png b/docs/dl-keras/img/bc688ef2476b30e081706f5cb16dd727.png
new file mode 100644
index 0000000000000000000000000000000000000000..c33a92b2057ee0f4db4e0f01fe3d4dcc9636b0a4
Binary files /dev/null and b/docs/dl-keras/img/bc688ef2476b30e081706f5cb16dd727.png differ
diff --git a/docs/dl-keras/img/bedb451b4ae753eecb4b2f2f5ddf01b5.png b/docs/dl-keras/img/bedb451b4ae753eecb4b2f2f5ddf01b5.png
new file mode 100644
index 0000000000000000000000000000000000000000..92e449da318c76f8b9be03050958448643cb8779
Binary files /dev/null and b/docs/dl-keras/img/bedb451b4ae753eecb4b2f2f5ddf01b5.png differ
diff --git a/docs/dl-keras/img/bf480c56be39c466c39ef7c081ee2e4f.png b/docs/dl-keras/img/bf480c56be39c466c39ef7c081ee2e4f.png
new file mode 100644
index 0000000000000000000000000000000000000000..cd6302388cb0c6fe55a61a668ad0cd52fcf10ce2
Binary files /dev/null and b/docs/dl-keras/img/bf480c56be39c466c39ef7c081ee2e4f.png differ
diff --git a/docs/dl-keras/img/c12075af40bf983d4677a85b12ff92c2.png b/docs/dl-keras/img/c12075af40bf983d4677a85b12ff92c2.png
new file mode 100644
index 0000000000000000000000000000000000000000..7de1a23f0ffc12c4b2727b3f4c0aaa8248b22deb
Binary files /dev/null and b/docs/dl-keras/img/c12075af40bf983d4677a85b12ff92c2.png differ
diff --git a/docs/dl-keras/img/c39b32bb7b7d10578b913aa8aa00ba34.png b/docs/dl-keras/img/c39b32bb7b7d10578b913aa8aa00ba34.png
new file mode 100644
index 0000000000000000000000000000000000000000..66ac6bb5ab99099bee4702f24afd7dfe03475eb7
Binary files /dev/null and b/docs/dl-keras/img/c39b32bb7b7d10578b913aa8aa00ba34.png differ
diff --git a/docs/dl-keras/img/c4d3dd994ea7c141153c92bb593e506e.png b/docs/dl-keras/img/c4d3dd994ea7c141153c92bb593e506e.png
new file mode 100644
index 0000000000000000000000000000000000000000..e3ddb93b3da8bb30c894ce0c9d01534f9dc05fe8
Binary files /dev/null and b/docs/dl-keras/img/c4d3dd994ea7c141153c92bb593e506e.png differ
diff --git a/docs/dl-keras/img/c62790dc095057645ed694f0c187f31f.png b/docs/dl-keras/img/c62790dc095057645ed694f0c187f31f.png
new file mode 100644
index 0000000000000000000000000000000000000000..ea3e960cd0e42de0fb8140d2debcaf94df16e1de
Binary files /dev/null and b/docs/dl-keras/img/c62790dc095057645ed694f0c187f31f.png differ
diff --git a/docs/dl-keras/img/c74159d0c08a16f4d34d423625015f83.png b/docs/dl-keras/img/c74159d0c08a16f4d34d423625015f83.png
new file mode 100644
index 0000000000000000000000000000000000000000..a78dda3a3c045b2be73aa293e414e43d27f46ca7
Binary files /dev/null and b/docs/dl-keras/img/c74159d0c08a16f4d34d423625015f83.png differ
diff --git a/docs/dl-keras/img/c8df59efd05bb76c2e64afcaaa4b406e.png b/docs/dl-keras/img/c8df59efd05bb76c2e64afcaaa4b406e.png
new file mode 100644
index 0000000000000000000000000000000000000000..f3de823ff23651dc6f835bbcf848a4287021107b
Binary files /dev/null and b/docs/dl-keras/img/c8df59efd05bb76c2e64afcaaa4b406e.png differ
diff --git a/docs/dl-keras/img/cd2ea0cb6ea3f16f73d52c1580d22310.png b/docs/dl-keras/img/cd2ea0cb6ea3f16f73d52c1580d22310.png
new file mode 100644
index 0000000000000000000000000000000000000000..2f995ca6c300b23d649f03842fee276755e4e402
Binary files /dev/null and b/docs/dl-keras/img/cd2ea0cb6ea3f16f73d52c1580d22310.png differ
diff --git a/docs/dl-keras/img/cf206a9fc0040edff578d8bec2c9cb16.png b/docs/dl-keras/img/cf206a9fc0040edff578d8bec2c9cb16.png
new file mode 100644
index 0000000000000000000000000000000000000000..bc79d6a3fde119be64f47039b28cbfd242982b1d
Binary files /dev/null and b/docs/dl-keras/img/cf206a9fc0040edff578d8bec2c9cb16.png differ
diff --git a/docs/dl-keras/img/d767349f43cecc391f31806440729f12.png b/docs/dl-keras/img/d767349f43cecc391f31806440729f12.png
new file mode 100644
index 0000000000000000000000000000000000000000..2d13a41c168d668bac9ddd16cf6c6e5132a2e6d6
Binary files /dev/null and b/docs/dl-keras/img/d767349f43cecc391f31806440729f12.png differ
diff --git a/docs/dl-keras/img/d901ddd6726290886da25ffca5932512.png b/docs/dl-keras/img/d901ddd6726290886da25ffca5932512.png
new file mode 100644
index 0000000000000000000000000000000000000000..697333fbb08a073e01018b87c90683c59d26f625
Binary files /dev/null and b/docs/dl-keras/img/d901ddd6726290886da25ffca5932512.png differ
diff --git a/docs/dl-keras/img/d9484ee640bb568aed750a19dbeb9547.png b/docs/dl-keras/img/d9484ee640bb568aed750a19dbeb9547.png
new file mode 100644
index 0000000000000000000000000000000000000000..c390534c4b17e45630e1b0abb4f3e8f20d10b2b1
Binary files /dev/null and b/docs/dl-keras/img/d9484ee640bb568aed750a19dbeb9547.png differ
diff --git a/docs/dl-keras/img/dcf7adb1cfb7d2e4d2acfe7acb62f171.png b/docs/dl-keras/img/dcf7adb1cfb7d2e4d2acfe7acb62f171.png
new file mode 100644
index 0000000000000000000000000000000000000000..d6e5f832f210cdad59e5f21a7396cf40e08c4719
Binary files /dev/null and b/docs/dl-keras/img/dcf7adb1cfb7d2e4d2acfe7acb62f171.png differ
diff --git a/docs/dl-keras/img/def90f3b9b58bf30829a905ae7da3e0d.png b/docs/dl-keras/img/def90f3b9b58bf30829a905ae7da3e0d.png
new file mode 100644
index 0000000000000000000000000000000000000000..692d9b60b499afffa91b77b72527595c43601824
Binary files /dev/null and b/docs/dl-keras/img/def90f3b9b58bf30829a905ae7da3e0d.png differ
diff --git a/docs/dl-keras/img/e0d34ef7b223c8edb1e2ec490aa2c563.png b/docs/dl-keras/img/e0d34ef7b223c8edb1e2ec490aa2c563.png
new file mode 100644
index 0000000000000000000000000000000000000000..791136e449df7cfc05353fc068a07744e328d125
Binary files /dev/null and b/docs/dl-keras/img/e0d34ef7b223c8edb1e2ec490aa2c563.png differ
diff --git a/docs/dl-keras/img/e1c3b3955f7f82b7e5b64209a3825ab4.png b/docs/dl-keras/img/e1c3b3955f7f82b7e5b64209a3825ab4.png
new file mode 100644
index 0000000000000000000000000000000000000000..f9962ee8b1e550653abf1a11e234f3736c3f5fff
Binary files /dev/null and b/docs/dl-keras/img/e1c3b3955f7f82b7e5b64209a3825ab4.png differ
diff --git a/docs/dl-keras/img/e2e01130306ad5b55ef570cb81af36ab.png b/docs/dl-keras/img/e2e01130306ad5b55ef570cb81af36ab.png
new file mode 100644
index 0000000000000000000000000000000000000000..5dd932fb7a1446cd74b0ac8bc7cb60af175c2f61
Binary files /dev/null and b/docs/dl-keras/img/e2e01130306ad5b55ef570cb81af36ab.png differ
diff --git a/docs/dl-keras/img/e3200de987f26f28e740ba476e06d3e3.png b/docs/dl-keras/img/e3200de987f26f28e740ba476e06d3e3.png
new file mode 100644
index 0000000000000000000000000000000000000000..d2cde99ae3f3c6e54443100e35fd681e8b866518
Binary files /dev/null and b/docs/dl-keras/img/e3200de987f26f28e740ba476e06d3e3.png differ
diff --git a/docs/dl-keras/img/e5ce13a85212886909aaee57125f4cab.png b/docs/dl-keras/img/e5ce13a85212886909aaee57125f4cab.png
new file mode 100644
index 0000000000000000000000000000000000000000..79a2c8d278c2d335f9313444446c62411815a2d1
Binary files /dev/null and b/docs/dl-keras/img/e5ce13a85212886909aaee57125f4cab.png differ
diff --git a/docs/dl-keras/img/e95bf53e34f94fbb07da8860454b1e2a.png b/docs/dl-keras/img/e95bf53e34f94fbb07da8860454b1e2a.png
new file mode 100644
index 0000000000000000000000000000000000000000..8c8dd29ebdd1fb56e61eff682bc835c885ecd436
Binary files /dev/null and b/docs/dl-keras/img/e95bf53e34f94fbb07da8860454b1e2a.png differ
diff --git a/docs/dl-keras/img/ee355a2aacdc70cce857b65c712bb041.png b/docs/dl-keras/img/ee355a2aacdc70cce857b65c712bb041.png
new file mode 100644
index 0000000000000000000000000000000000000000..f498ba4dcb970f9e806562af960543270a8a5070
Binary files /dev/null and b/docs/dl-keras/img/ee355a2aacdc70cce857b65c712bb041.png differ
diff --git a/docs/dl-keras/img/efb0b72bb3c64da47744e0d5c7a8aeac.png b/docs/dl-keras/img/efb0b72bb3c64da47744e0d5c7a8aeac.png
new file mode 100644
index 0000000000000000000000000000000000000000..a3adf07041f995ad66314fea76cccf756265a6eb
Binary files /dev/null and b/docs/dl-keras/img/efb0b72bb3c64da47744e0d5c7a8aeac.png differ
diff --git a/docs/dl-keras/img/f0f15aa8316dd7ee6c7b1361b8727f8a.png b/docs/dl-keras/img/f0f15aa8316dd7ee6c7b1361b8727f8a.png
new file mode 100644
index 0000000000000000000000000000000000000000..319b8900bda2c3e5fe2dda71dc8833b5c83b96ca
Binary files /dev/null and b/docs/dl-keras/img/f0f15aa8316dd7ee6c7b1361b8727f8a.png differ
diff --git a/docs/dl-keras/img/f12c1bb681a84a2372eacda56b1aeadc.png b/docs/dl-keras/img/f12c1bb681a84a2372eacda56b1aeadc.png
new file mode 100644
index 0000000000000000000000000000000000000000..0c0ff0d7387f825394e53b492b65e4d216087f5e
Binary files /dev/null and b/docs/dl-keras/img/f12c1bb681a84a2372eacda56b1aeadc.png differ
diff --git a/docs/dl-keras/img/f1e85b455ad088df5051e012c2c57db8.png b/docs/dl-keras/img/f1e85b455ad088df5051e012c2c57db8.png
new file mode 100644
index 0000000000000000000000000000000000000000..1816d64ee35803c0d91d2576dafa465236017c4c
Binary files /dev/null and b/docs/dl-keras/img/f1e85b455ad088df5051e012c2c57db8.png differ
diff --git a/docs/dl-keras/img/f2b08c4eb571d1dc15ee278519741cbe.png b/docs/dl-keras/img/f2b08c4eb571d1dc15ee278519741cbe.png
new file mode 100644
index 0000000000000000000000000000000000000000..3a5a1cc61542adc21d3162cfba68518ad650e883
Binary files /dev/null and b/docs/dl-keras/img/f2b08c4eb571d1dc15ee278519741cbe.png differ
diff --git a/docs/dl-keras/img/f2dd8ae07b918bba4062a5725937285e.png b/docs/dl-keras/img/f2dd8ae07b918bba4062a5725937285e.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b08faf73b472ed47680a3513760b1cf02dddc63
Binary files /dev/null and b/docs/dl-keras/img/f2dd8ae07b918bba4062a5725937285e.png differ
diff --git a/docs/dl-keras/img/f73add12895695350fadc1995b8d77e9.png b/docs/dl-keras/img/f73add12895695350fadc1995b8d77e9.png
new file mode 100644
index 0000000000000000000000000000000000000000..f64e36dfc0b70fd16e317a10b29791f7a6cf868f
Binary files /dev/null and b/docs/dl-keras/img/f73add12895695350fadc1995b8d77e9.png differ
diff --git a/docs/dl-keras/img/f7c8bf23f866c7d1a641e25ab2c1e6cd.png b/docs/dl-keras/img/f7c8bf23f866c7d1a641e25ab2c1e6cd.png
new file mode 100644
index 0000000000000000000000000000000000000000..abbb0ca5d765512aae010704a84b5684d89476ff
Binary files /dev/null and b/docs/dl-keras/img/f7c8bf23f866c7d1a641e25ab2c1e6cd.png differ
diff --git a/docs/dl-keras/img/faed449c22db6586e71129af66aef2a5.png b/docs/dl-keras/img/faed449c22db6586e71129af66aef2a5.png
new file mode 100644
index 0000000000000000000000000000000000000000..c90f85cf167960cc91fcbc3d7ec7c1f7b77be4bb
Binary files /dev/null and b/docs/dl-keras/img/faed449c22db6586e71129af66aef2a5.png differ
diff --git a/docs/dl-keras/img/fba7c01fd78761e808c4f093eff4ccd1.png b/docs/dl-keras/img/fba7c01fd78761e808c4f093eff4ccd1.png
new file mode 100644
index 0000000000000000000000000000000000000000..7b58c8f70ae8b2fdb4219b0d3a76a1a4baa3d23c
Binary files /dev/null and b/docs/dl-keras/img/fba7c01fd78761e808c4f093eff4ccd1.png differ
diff --git a/docs/dl-keras/img/fe8f0396c0f9d7b02308150c33abe2da.png b/docs/dl-keras/img/fe8f0396c0f9d7b02308150c33abe2da.png
new file mode 100644
index 0000000000000000000000000000000000000000..ae5cdc77f381f39ed73285877debfce526872b61
Binary files /dev/null and b/docs/dl-keras/img/fe8f0396c0f9d7b02308150c33abe2da.png differ
diff --git a/docs/dl-keras/inspirational-applications-deep-learning.md b/docs/dl-keras/inspirational-applications-deep-learning.md
new file mode 100644
index 0000000000000000000000000000000000000000..5ede99754f0e94373c0ce4403ca07f78a00e0062
--- /dev/null
+++ b/docs/dl-keras/inspirational-applications-deep-learning.md
@@ -0,0 +1,310 @@
+# 8 深度学习的鼓舞人心的应用
+
+> 原文： [https://machinelearningmastery.com/inspirational-applications-deep-learning/](https://machinelearningmastery.com/inspirational-applications-deep-learning/)
+
+说深度学习是在一系列困难问题领域实现最先进的结果，这是夸张的。事实上，也是夸张。
+
+目前，人工智能，机器学习和深度学习方面有很多令人兴奋的事情。在一些非常强大的技术的底层，这也是一个绝佳的机会。
+
+我努力说服朋友，同事和学生开始深入学习，如上所述的大胆陈述是不够的。它需要故事，图片和研究论文。
+
+在这篇文章中，您将发现深度学习的惊人和近期应用，这将激励您开始深入学习。
+
+开始深度学习并不一定意味着去研究未来 2 - 3 年的方程，这可能意味着[下载 Keras 并开始在 5 分钟内运行你的第一个模型](http://machinelearningmastery.com/tutorial-first-neural-network-python-keras/)。开始应用深度学习。建东西。兴奋并将其转化为代码和系统。
+
+我一直想写这篇文章一段时间。让我们开始吧。
+
+![Inspirational Applications of Deep Learning](img/e5ce13a85212886909aaee57125f4cab.jpg)
+
+深度学习的鼓舞人心的应用
+照片由 [Nick Kenrick](https://www.flickr.com/photos/zedzap/12093300505/) 拍摄，保留一些权利。
+
+## 概观
+
+以下是我们将在本文中看到的具体示例列表。
+
+并非所有的例子都是准备好黄金时间的技术，但保证，它们都是令你兴奋的例子。
+
+如果你已经在场上呆了一段时间，有些例子似乎很吵。在更广泛的背景下，他们并没有哼唱。一点也不。
+
+坦率地说，对于像我这样的老 AI 黑客，其中一些例子是一记耳光。如果有的话，我根本不认为我们可以解决几十年的问题。
+
+我专注于视觉示例，因为我们可以查看截图和视频，以便立即了解算法正在做什么，但是在自然语言中有很多（如果不是更多）示例，其中未列出文本和音频数据。
+
+这是清单：
+
+1.  黑白图像的着色。
+2.  为无声电影添加声音。
+3.  自动机器翻译。
+4.  照片中的对象分类。
+5.  自动手写生成。
+6.  字符文本生成。
+7.  图像标题生成。
+8.  自动游戏。
+
+## 1.黑白图像的自动着色
+
+图像着色是向黑白照片添加颜色的问题。
+
+传统上这是[手工完成](https://en.wikipedia.org/wiki/Hand-colouring_of_photographs)，因为这是一项艰巨的任务。
+
+深度学习可用于在照片中使用对象及其上下文来为图像着色，就像人类操作员可能会解决问题一样。
+
+视觉和令人印象深刻的壮举。
+
+这种能力利用了为 ImageNet 训练的高质量和非常大的卷积神经网络，并且增加了图像着色的问题。
+
+通常，该方法涉及使用非常大的卷积神经网络和监督层，其通过添加颜色来重建图像。
+
+![Colorization of Black and White Photographs](img/33d8cdc3cb4fecc654bce247b69af0bc.jpg)
+
+黑白照片的着色
+图片取自 [Richard Zhang，Phillip Isola 和 Alexei A. Efros](http://richzhang.github.io/colorization/) 。
+
+令人印象深刻的是，相同的方法可用于着色黑白电影的静止帧
+
+&lt;iframe allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/_MJU8VK2PI4?feature=oembed" width="500"&gt;&lt;/iframe&gt;
+
+### 进一步阅读
+
+*   [自动着色](http://tinyclouds.org/colorize/)
+*   [灰度图像自动着色](https://news.developer.nvidia.com/automatic-image-colorization-of-grayscale-images/)
+
+### 文件
+
+*   [深色着色](http://www.cs.cityu.edu.hk/~qiyang/publications/iccv-15.pdf) [pdf]，2015
+*   [彩色图像着色](http://arxiv.org/pdf/1603.08511.pdf) [pdf]（[网站](http://richzhang.github.io/colorization/)），2016
+*   [自动着色的学习表示](http://arxiv.org/pdf/1603.06668.pdf) [pdf]（[网站](http://people.cs.uchicago.edu/~larsson/colorization/)），2016
+*   [深度卷积神经网络的图像着色](http://cs231n.stanford.edu/reports2016/219_Report.pdf) [pdf]，2016
+
+## 2.自动为无声电影添加声音
+
+在此任务中，系统必须合成声音以匹配静音视频。
+
+该系统使用 1000 个视频示例进行训练，其中鼓棒的声音撞击不同的表面并产生不同的声音。深度学习模型将视频帧与预先重新录制的声音数据库相关联，以便选择与场景中发生的最佳匹配的声音。
+
+然后使用图像测试设置评估系统，其中人类必须确定哪个视频具有真实或假（合成）声音。
+
+卷积神经网络和 LSTM 递归神经网络的非常酷的应用。
+
+&lt;iframe allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/0FW99AQmMc8?feature=oembed" width="500"&gt;&lt;/iframe&gt;
+
+### 进一步阅读
+
+*   [人工智能产生逼真的愚弄人类的声音](http://news.mit.edu/2016/artificial-intelligence-produces-realistic-sounds-0613)
+*   [机器可以产生愚弄人类的声音效果](https://www.engadget.com/2016/06/13/machines-can-generate-sound-effects-that-fool-humans)
+
+### 文件
+
+*   [视觉指示声音](http://arxiv.org/pdf/1512.08512.pdf)（[网页](http://vis.csail.mit.edu/)），2015
+
+## 3.自动机器翻译
+
+这是一种任务，其中给定的单词，短语或句子在一种语言中，自动将其翻译成另一种语言。
+
+自动机器翻译已经存在了很长时间，但深度学习在两个特定领域取得了最佳成果：
+
+*   文本的自动翻译。
+*   图像的自动翻译。
+
+可以在不对序列进行任何预处理的情况下执行文本转换，从而允许算法学习单词之间的依赖关系以及它们与新语言的映射。使用大型 LSTM 递归神经网络的堆叠网络来执行该转换。
+
+正如您所料，卷积神经网络用于识别具有字母的图像以及字母在场景中的位置。识别后，可以将它们转换为文本，翻译并使用翻译后的文本重新创建图像。这通常被称为即时视觉翻译。
+
+![Instant Visual Translation](img/3e7ff435faae5d295db3318aa75ce44e.jpg)
+
+即时视觉翻译
+即时视觉翻译示例，取自 [Google 博客](https://research.googleblog.com/2015/07/how-google-translate-squeezes-deep.html)。
+
+### 进一步阅读
+
+在这个例子中很难找到好的资源，如果你知道的话，可以发表评论。
+
+*   [谷歌翻译如何将深度学习压缩到手机上](https://research.googleblog.com/2015/07/how-google-translate-squeezes-deep.html)
+
+### 文件
+
+*   [用神经网络进行序列学习的序列](http://arxiv.org/pdf/1409.3215v3.pdf) [pdf]，2014
+*   [使用 RNN 编码器 - 解码器进行统计机器翻译的学习短语表示](http://arxiv.org/pdf/1406.1078v3.pdf) [pdf]，2014
+*   [机器翻译中的深度神经网络：概述](http://www.nlpr.ia.ac.cn/cip/ZongPublications/2015/IEEE-Zhang-8-5.pdf) [pdf]，2015
+
+## 4.照片中的物体分类和检测
+
+该任务需要将照片内的对象分类为一组先前已知的对象之一。
+
+使用非常大的卷积神经网络已经在该问题的基准示例上实现了最先进的结果。 Alex Krizhevsky 等人在这个问题上取得了突破。结果出现了名为 AlexNet 的 ImageNet 分类问题。
+
+![Example of Object Classification](img/18af9b56f22eba68918a4ceaa17405a2.jpg)
+
+使用深度卷积神经网络从 [ImageNet 分类中获取的对象分类示例](http://www.cs.toronto.edu/~fritz/absps/imagenet.pdf) 
+
+该任务的更复杂的变体称为物体检测涉及具体识别照片场景内的一个或多个物体并在它们周围画一个盒子。
+
+![Automatic Object Detection](img/c8df59efd05bb76c2e64afcaaa4b406e.jpg)
+
+Photogaphs 中的物体检测示例
+取自 [Google 博客](https://research.googleblog.com/2014/09/building-deeper-understanding-of-images.html)。
+
+### 进一步阅读
+
+*   [加深对图像的理解](https://research.googleblog.com/2014/09/building-deeper-understanding-of-images.html)
+*   [AlexNet](https://github.com/BVLC/caffe/tree/master/models/bvlc_alexnet)
+*   [ConvNetJS：CIFAR-10 演示](http://cs.stanford.edu/people/karpathy/convnetjs/demo/cifar10.html)
+
+### 文件
+
+*   [具有深度卷积神经网络的 ImageNet 分类](http://www.cs.toronto.edu/~fritz/absps/imagenet.pdf) [pdf]，2012
+*   [基于深度卷积神经网络的图像分类的一些改进](http://arxiv.org/pdf/1312.5402v1.pdf) [pdf]，2013
+*   [使用深度神经网络的可扩展物体检测](http://www.cv-foundation.org/openaccess/content_cvpr_2014/papers/Erhan_Scalable_Object_Detection_2014_CVPR_paper.pdf) [pdf]，2013
+*   [用于物体检测的深度神经网络](http://papers.nips.cc/paper/5207-deep-neural-networks-for-object-detection.pdf) [pdf]，2013
+
+## 5.自动手写生成
+
+这是一个任务，其中给定一个手写示例语料库，为给定的单词或短语生成新的手写。
+
+手写是作为创建手写样本时笔使用的坐标序列提供的。从该语料库中学习笔移动和字母之间的关系，并且可以临时生成新的示例。
+
+令人着迷的是，可以学习不同的风格，然后模仿。我很乐意看到这项工作与一些法医手写分析专业知识相结合。
+
+![Sample of Automatic Handwriting Generation](img/e3200de987f26f28e740ba476e06d3e3.jpg)
+
+自动手写生成示例
+
+### 进一步阅读
+
+*   [交互式手写生成演示](http://www.cs.toronto.edu/~graves/handwriting.html)
+
+### 文件
+
+*   [使用递归神经网络生成序列](http://arxiv.org/pdf/1308.0850v5.pdf) [pdf]，2013
+
+## 6.自动文本生成
+
+这是一项有趣的任务，其中学习了文本语料库，并且从该模型生成新文本，逐字或逐字符地生成。
+
+该模型能够学习如何拼写，标点，形成感知，甚至捕捉语料库中文本的样式。
+
+大型递归神经网络用于学习输入字符串序列中的项之间的关系，然后生成文本。最近，LSTM 循环神经网络使用基于字符的模型在这个问题上取得了巨大的成功，并且在时间上产生了一个字符。
+
+Andrej Karpathy 在他关于该主题的热门博客文章中提供了许多例子，包括：
+
+*   保罗格雷厄姆散文
+*   莎士比亚
+*   维基百科文章（包括标记）
+*   代数几何（带 LaTeX 标记）
+*   Linux 源代码
+*   宝贝名字
+
+![Automatic Text Generation Example of Shakespeare](img/f2dd8ae07b918bba4062a5725937285e.jpg)
+
+莎士比亚的自动文本生成示例
+摘自 [Andrej Karpathy 博客文章](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)
+
+### 进一步阅读
+
+*   [回归神经网络的不合理有效性](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)
+*   [使用递归神经网络自动生成 Clickbait](https://larseidnes.com/2015/10/13/auto-generating-clickbait-with-recurrent-neural-networks/)
+
+### 文件
+
+*   [使用递归神经网络生成文本](http://www.cs.utoronto.ca/~ilya/pubs/2011/LANG-RNN.pdf) [pdf]，2011
+*   [使用递归神经网络生成序列](http://arxiv.org/pdf/1308.0850v5.pdf) [pdf]，2013
+
+## 7.自动图像标题生成
+
+自动图像字幕是给定图像的任务，系统必须生成描述图像内容的标题。
+
+2014 年，深度学习算法爆炸式增长，在此问题上取得了令人印象深刻的成果，利用顶级模型的工作进行对象分类和照片中的对象检测。
+
+一旦您可以检测照片中的对象并为这些对象生成标签，您就会发现下一步是将这些标签转换为连贯的句子描述。
+
+这是结果之一，打破了我的袜子，仍然。非常令人印象深刻
+
+通常，该系统涉及使用非常大的卷积神经网络用于照片中的物体检测，然后使用像 LSTM 那样的递归神经网络将标签变成连贯的句子。
+
+![Automatic Image Caption Generation](img/265192f5c88c8a78da52ecabd638aaa9.jpg)
+
+自动图像标题生成
+样本取自 [Andrej Karpathy，李飞飞](http://cs.stanford.edu/people/karpathy/deepimagesent/)
+
+这些技术也已扩展为自动标题视频。
+
+### 进一步阅读
+
+*   [一张图片胜过一千个（连贯的）字：构建图像的自然描述](https://research.googleblog.com/2014/11/a-picture-is-worth-thousand-coherent.html)
+*   [自动图像字幕的快速进展](https://blogs.technet.microsoft.com/machinelearning/2014/11/18/rapid-progress-in-automatic-image-captioning/)
+
+### 文件
+
+*   [用于生成图像描述的深层视觉语义对齐](http://cs.stanford.edu/people/karpathy/cvpr2015.pdf) [pdf]（[和网站](http://cs.stanford.edu/people/karpathy/deepimagesent/)），2015
+*   [用多模式回归神经网络解释图像](http://arxiv.org/pdf/1410.1090v1.pdf) [pdf，2014]
+*   [用于视觉识别和描述的长期循环卷积网络](http://arxiv.org/pdf/1411.4389v4.pdf) [pdf]，2014
+*   [用多模态神经语言模型统一视觉语义嵌入](http://arxiv.org/pdf/1411.2539v1.pdf) [pdf]，2014
+*   [序列到序列 - 视频到文本](http://arxiv.org/pdf/1505.00487v3.pdf) [pdf]，2015
+
+## 8.自动游戏
+
+这是一个模型学习如何仅根据屏幕上的像素来玩电脑游戏的任务。
+
+这个非常困难的任务是深度强化模型的领域，并且是 [DeepMind](https://en.wikipedia.org/wiki/Google_DeepMind) （现在是谷歌的一部分）因实现而闻名的突破。
+
+&lt;iframe allowfullscreen="" frameborder="0" height="375" src="https://www.youtube.com/embed/TmPfTpjtdgg?feature=oembed" width="500"&gt;&lt;/iframe&gt;
+
+这项工作得到了扩展，并在谷歌 DeepMind 的 [AlphaGo](https://en.wikipedia.org/wiki/AlphaGo) 中达到顶峰，该游戏在 Go 游戏中击败了世界大师。
+
+### 进一步阅读
+
+*   [深层强化学习](https://www.deepmind.com/blog)
+*   [DeepMind YouTube 频道](https://www.youtube.com/channel/UCP7jMXSY2xbc3KCAE0MHQ-A)
+*   [深度学习演示](https://cs.stanford.edu/people/karpathy/convnetjs/demo/rldemo.html)
+*   [DeepMind 的 AI 现在是 Atari 游戏专业版](http://www.wired.co.uk/article/google-deepmind-atari)
+
+### 文件
+
+*   [使用深度强化学习](http://arxiv.org/pdf/1312.5602v1.pdf) [pdf]，2013 年播放 Atari
+*   [通过深度强化学习](http://www.nature.com/nature/journal/v518/n7540/full/nature14236.html)进行人类控制，2015 年
+*   [用深度神经网络和树搜索](http://www.nature.com/nature/journal/v529/n7587/full/nature16961.html)掌握 Go 游戏，2016
+
+## 其他例子
+
+以下是上面列出的一些其他示例。
+
+*   自动语音识别。
+    *   [用于语音识别中声学建模的深度神经网络](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/38131.pdf) [pdf]，2012
+*   自动语音理解。
+    *   [采用递归神经网络进行端到端语音识别](http://www.jmlr.org/proceedings/papers/v32/graves14.pdf) [pdf]，2014
+*   自动将注意力集中在图像中的对象上。
+    *   [视觉注意的复发模型](http://arxiv.org/pdf/1406.6247v1.pdf) [pdf]，2014
+*   自动回答有关照片中对象的问题。
+    *   [探索图像问答的模型和数据](http://arxiv.org/pdf/1505.02074v4.pdf) [pdf]，2015
+*   自动将草图转换为照片。
+    *   [卷积草图反演](https://arxiv.org/abs/1606.03073) [pdf]，2016
+*   从粗略草图自动创建风格化图像。
+    *   [神经涂鸦](https://github.com/alexjc/neural-doodle)
+
+![Automatically Create Styled Image From Sketch](img/a1a0554742400bb687dd331e6f95e77b.jpg)
+
+从草图自动创建样式图像
+从 [NeuralDoodle](https://github.com/alexjc/neural-doodle) 拍摄图像
+
+## 更多资源
+
+有很多很棒的资源，会谈和更多帮助你对深度学习的能力和潜力感到兴奋。
+
+以下是一些额外的资源，可以帮助您激动。
+
+*   [深度学习的不合理效果](https://www.youtube.com/watch?v=sc-KbuZqGkI)，Yann LeCun 在 2014 年的演讲
+*   [令人敬畏的深度视觉](https://github.com/kjw0612/awesome-deep-vision)顶级深度学习计算机视觉论文列表
+*   [可以学习](https://www.youtube.com/watch?v=t4kyRyKyOpo)的计算机的精彩和恐怖含义，Jeremy Howard 的 TED 演讲
+*   [哪种算法取得了最佳效果](http://rodrigob.github.io/are_we_there_yet/build/)，计算机视觉数据集的最佳结果列表
+*   [神经网络如何真正起作用](https://www.youtube.com/watch?v=l2dVjADTEDU)，Geoffrey Hinton 2016
+
+&lt;iframe allowfullscreen="" frameborder="0" height="281" src="https://www.youtube.com/embed/t4kyRyKyOpo?feature=oembed" width="500"&gt;&lt;/iframe&gt;
+
+## 摘要
+
+在这篇文章中，您发现了 8 个深度学习应用程序，旨在激励您。
+
+这 _ 显示 _ 而不是 _ 告诉 _ 方法预计会切断夸张，让您更清楚地了解深度学习技术的当前和未来能力。
+
+你知道这里没有列出深度学习的任何鼓舞人心的例子吗？请在评论中告诉我。
\ No newline at end of file
diff --git a/docs/dl-keras/introduction-python-deep-learning-library-keras.md b/docs/dl-keras/introduction-python-deep-learning-library-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..8f195d300af717d72d0fbe20728136e567a8477d
--- /dev/null
+++ b/docs/dl-keras/introduction-python-deep-learning-library-keras.md
@@ -0,0 +1,160 @@
+# 使用 Keras 介绍 Python 深度学习
+
+> 原文： [https://machinelearningmastery.com/introduction-python-deep-learning-library-keras/](https://machinelearningmastery.com/introduction-python-deep-learning-library-keras/)
+
+Python 中两个为深度学习研究和开发提供基础的顶级数字平台是 Theano 和 TensorFlow。
+
+两者都是非常强大的库，但两者都难以直接用于创建深度学习模型。
+
+在这篇文章中，您将发现 Keras Python 库，它提供了一种在 Theano 或 TensorFlow 上创建一系列深度学习模型的简洁方便的方法。
+
+让我们开始吧。
+
+**2016 年 10 月更新**：更新了 Keras 1.1.0，Theano 0.8.2 和 TensorFlow 0.10.0 的示例。
+
+![Introduction to the Python Deep Learning Library Keras](img/faed449c22db6586e71129af66aef2a5.jpg)
+
+Python 深度学习库 Keras 简介
+照片由 [Dennis Jarvis](https://www.flickr.com/photos/archer10/2216602404/) 拍摄，保留一些权利。
+
+## 什么是 Keras？
+
+Keras 是一个用于深度学习的极简主义 Python 库，可以在 Theano 或 TensorFlow 之上运行。
+
+它的开发旨在使研究和开发尽可能快速简便地实施深度学习模型。
+
+它运行在 Python 2.7 或 3.5 上，并且可以在给定底层框架的情况下在 GPU 和 CPU 上无缝执行。它是在许可的 MIT 许可下发布的。
+
+Keras 由[FrançoisChollet](https://www.linkedin.com/in/fchollet)开发和维护，他是一位 Google 工程师，使用四个指导原则：
+
+*   **模块性**：模型可以理解为单独的序列或图形。深度学习模型的所有关注点都是可以以任意方式组合的离散组件。
+*   **极简主义**：该库提供了足够的结果，没有多余的装饰和最大化的可读性。
+*   **可扩展性**：新组件有意在框架内轻松添加和使用，供研究人员试用和探索新想法。
+*   **Python** ：没有自定义文件格式的单独模型文件。一切都是原生 Python。
+
+## 如何安装 Keras
+
+如果您已经拥有可用的 Python 和 SciPy 环境，那么 Keras 的安装相对简单。
+
+您还必须在系统上安装 Theano 或 TensorFlow。
+
+您可以在此处查看两个平台的安装说明：
+
+*   [Theano 的安装说明](http://deeplearning.net/software/theano/install.html#install)
+*   [TensorFlow](https://github.com/tensorflow/tensorflow#download-and-setup) 的安装说明
+
+使用 [PyPI](https://pypi.python.org/pypi) 可以轻松安装 Keras，如下所示：
+
+```
+sudo pip install keras
+```
+
+在撰写本文时，Keras 的最新版本是 1.1.0 版。您可以使用以下代码段在命令行上检查您的 Keras 版本：
+
+您可以使用以下代码段在命令行上检查您的 Keras 版本：
+
+```
+python -c "import keras; print keras.__version__"
+```
+
+运行上面的脚本你会看到：
+
+```
+1.1.0
+```
+
+您可以使用相同的方法升级 Keras 的安装：
+
+```
+sudo pip install --upgrade keras
+```
+
+## 针对 Keras 的 Theano 和 TensorFlow 后端
+
+假设您同时安装了 Theano 和 TensorFlow，则可以配置 Keras 使用的[后端](http://keras.io/backend/)。
+
+最简单的方法是在主目录中添加或编辑 Keras 配置文件：
+
+```
+~/.keras/keras.json
+```
+
+其格式如下：
+
+```
+{
+    "image_dim_ordering": "tf", 
+    "epsilon": 1e-07, 
+    "floatx": "float32", 
+    "backend": "tensorflow"
+}
+```
+
+在此配置文件中，您可以将“_ 后端 _”属性从“ _tensorflow_ ”（默认值）更改为“ _theano_ ”。然后 Keras 将在下次运行时使用该配置。
+
+您可以在命令行上使用以下代码段确认 Keras 使用的后端：
+
+```
+python -c "from keras import backend; print backend._BACKEND"
+```
+
+使用默认配置运行此选项，您将看到：
+
+```
+Using TensorFlow backend.
+tensorflow
+```
+
+您还可以通过指定 KERAS_BACKEND 环境变量在命令行上指定 Keras 使用的后端，如下所示：
+
+```
+KERAS_BACKEND=theano python -c "from keras import backend; print(backend._BACKEND)"
+```
+
+运行此示例打印：
+
+```
+Using Theano backend.
+theano
+```
+
+## 使用 Keras 构建深度学习模型
+
+Keras 的重点是模型的概念。
+
+主要类型的模型称为序列，它是层的线性堆栈。
+
+您可以按照希望执行计算的顺序创建序列并向其添加图层。
+
+一旦定义，您就可以编译模型，该模型利用底层框架来优化模型执行的计算。在此，您可以指定损失函数和要使用的优化程序。
+
+编译后，模型必须适合数据。这可以一次完成一批数据，也可以通过启动整个模型培训制度来完成。这是所有计算发生的地方。
+
+经过培训，您可以使用模型对新数据进行预测。
+
+我们可以总结一下 Keras 深度学习模型的构建如下：
+
+1.  **定义你的模型**。创建序列并添加图层。
+2.  **编译你的模型**。指定损失函数和优化器。
+3.  **适合您的型号**。使用数据执行模型。
+4.  **做出预测**。使用该模型生成对新数据的预测。
+
+## Keras 资源
+
+下面的列表提供了一些其他资源，您可以使用它们来了解有关 Keras 的更多信息。
+
+*   [Keras 官方主页](http://keras.io/)（文档）
+*   [GitHub 上的 Keras 项目](https://github.com/fchollet/keras)
+*   [Keras 用户组](https://groups.google.com/forum/#!forum/keras-users)
+
+您是否正在寻找一个良好的深度学习教程来开始，请看看：
+
+*   [用 Keras 逐步开发 Python 中的第一个神经网络](http://machinelearningmastery.com/tutorial-first-neural-network-python-keras/)
+
+## 摘要
+
+在这篇文章中，您发现了用于深度学习研究和开发的 Keras Python 库。
+
+您发现 Keras 专为极简主义和模块化而设计，允许您快速定义深度学习模型并在 Theano 或 TensorFlow 后端运行它们。
+
+你对 Keras 或这篇文章有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/introduction-python-deep-learning-library-tensorflow.md b/docs/dl-keras/introduction-python-deep-learning-library-tensorflow.md
new file mode 100644
index 0000000000000000000000000000000000000000..b7438221b7143f9f0a794a4d6e1d0b806db576a7
--- /dev/null
+++ b/docs/dl-keras/introduction-python-deep-learning-library-tensorflow.md
@@ -0,0 +1,173 @@
+# Python 深度学习库 TensorFlow 简介
+
+> 原文： [https://machinelearningmastery.com/introduction-python-deep-learning-library-tensorflow/](https://machinelearningmastery.com/introduction-python-deep-learning-library-tensorflow/)
+
+TensorFlow 是一个用于 Google 创建和发布的快速数值计算的 Python 库。
+
+它是一个基础库，可用于直接创建深度学习模型，或使用包装库来简化在 TensorFlow 之上构建的过程。
+
+在这篇文章中，您将发现用于深度学习的 TensorFlow 库。
+
+让我们开始吧。
+
+![Introduction to the Python Deep Learning Library TensorFlow](img/fe8f0396c0f9d7b02308150c33abe2da.jpg)
+
+Python 深度学习库简介 TensorFlow
+摄影： [Nicolas Raymond](https://www.flickr.com/photos/82955120@N05/15932303392/) ，保留一些权利。
+
+## 什么是 TensorFlow？
+
+TensorFlow 是一个用于快速数值计算的开源库。
+
+它由 Google 创建并维护，并在 Apache 2.0 开源许可下发布。虽然可以访问底层的 C ++ API，但 API 名义上是用于 Python 编程语言的。
+
+与 Theano 等深度学习中使用的其他数值库不同，TensorFlow 设计用于研究和开发以及生产系统，尤其是谷歌搜索中的 [RankBrain 和有趣的](https://en.wikipedia.org/wiki/RankBrain) [DeepDream 项目](https://en.wikipedia.org/wiki/DeepDream) ]。
+
+它可以在单 CPU 系统，GPU 以及移动设备和数百台机器的大规模分布式系统上运行。
+
+## 如何安装 TensorFlow
+
+如果您已经拥有 Python SciPy 环境，那么 TensorFlow 的安装非常简单。
+
+TensorFlow 适用于 Python 2.7 和 Python 3.3+。您可以按照 TensorFlow 网站上的[下载和设置说明](https://www.tensorflow.org/versions/r0.8/get_started/os_setup.html)进行操作。通过 PyPI 进行安装可能是最简单的，并且下载和设置网页上有用于 Linux 或 Mac OS X 平台的 pip 命令的特定说明。
+
+如果您愿意，还可以使用 [virtualenv](http://docs.python-guide.org/en/latest/dev/virtualenvs/) 和[泊坞窗图像](https://www.docker.com/)。
+
+要使用 GPU，只支持 Linux，它需要 Cuda Toolkit。
+
+## 你在 TensorFlow 中的第一个例子
+
+根据有向图的结构中的数据流和操作来描述计算。
+
+*   **节点**：节点执行计算并具有零个或多个输入和输出。在节点之间移动的数据称为张量，它是实数值的多维数组。
+*   **Edges** ：该图定义了数据流，分支，循环和状态更新。特殊边缘可用于同步图形中的行为，例如等待完成多个输入的计算。
+*   **操作**：一个操作是一个命名的抽象计算，它可以获取输入属性并产生输出属性。例如，您可以定义添加或乘法操作。
+
+### 用 TensorFlow 计算
+
+第一个示例是 [TensorFlow 网站](https://github.com/tensorflow/tensorflow)上的示例的修改版本。它显示了如何使用会话创建会话，定义常量和使用这些常量执行计算。
+
+```
+import tensorflow as tf
+sess = tf.Session()
+a = tf.constant(10)
+b = tf.constant(32)
+print(sess.run(a+b))
+```
+
+运行此示例显示：
+
+```
+42
+```
+
+### 使用 TensorFlow 进行线性回归
+
+下一个例子来自 [TensorFlow 教程](https://www.tensorflow.org/versions/r0.8/get_started/index.html)的介绍。
+
+此示例显示了如何定义变量（例如 W 和 b）以及作为计算结果的变量（y）。
+
+我们对 TensorFlow 有一定的了解，它将计算的定义和声明与会话中的执行和运行调用分开。
+
+```
+import tensorflow as tf
+import numpy as np
+
+# Create 100 phony x, y data points in NumPy, y = x * 0.1 + 0.3
+x_data = np.random.rand(100).astype(np.float32)
+y_data = x_data * 0.1 + 0.3
+
+# Try to find values for W and b that compute y_data = W * x_data + b
+# (We know that W should be 0.1 and b 0.3, but Tensorflow will
+# figure that out for us.)
+W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
+b = tf.Variable(tf.zeros([1]))
+y = W * x_data + b
+
+# Minimize the mean squared errors.
+loss = tf.reduce_mean(tf.square(y - y_data))
+optimizer = tf.train.GradientDescentOptimizer(0.5)
+train = optimizer.minimize(loss)
+
+# Before starting, initialize the variables.  We will 'run' this first.
+init = tf.initialize_all_variables()
+
+# Launch the graph.
+sess = tf.Session()
+sess.run(init)
+
+# Fit the line.
+for step in xrange(201):
+    sess.run(train)
+    if step % 20 == 0:
+        print(step, sess.run(W), sess.run(b))
+
+# Learns best fit is W: [0.1], b: [0.3]
+```
+
+运行此示例将输出以下输出：
+
+```
+(0, array([ 0.2629351], dtype=float32), array([ 0.28697217], dtype=float32))
+(20, array([ 0.13929555], dtype=float32), array([ 0.27992988], dtype=float32))
+(40, array([ 0.11148042], dtype=float32), array([ 0.2941364], dtype=float32))
+(60, array([ 0.10335406], dtype=float32), array([ 0.29828694], dtype=float32))
+(80, array([ 0.1009799], dtype=float32), array([ 0.29949954], dtype=float32))
+(100, array([ 0.10028629], dtype=float32), array([ 0.2998538], dtype=float32))
+(120, array([ 0.10008363], dtype=float32), array([ 0.29995731], dtype=float32))
+(140, array([ 0.10002445], dtype=float32), array([ 0.29998752], dtype=float32))
+(160, array([ 0.10000713], dtype=float32), array([ 0.29999638], dtype=float32))
+(180, array([ 0.10000207], dtype=float32), array([ 0.29999897], dtype=float32))
+(200, array([ 0.1000006], dtype=float32), array([ 0.29999971], dtype=float32))
+```
+
+您可以在[基本使用指南](https://www.tensorflow.org/versions/r0.8/get_started/basic_usage.html)中了解有关 TensorFlow 机制的更多信息。
+
+## 更多深度学习模型
+
+您的 TensorFlow 安装附带了许多深度学习模型，您可以直接使用它们进行试验。
+
+首先，您需要找出系统上 TensorFlow 的安装位置。例如，您可以使用以下 Python 脚本：
+
+```
+python -c 'import os; import inspect; import tensorflow; print(os.path.dirname(inspect.getfile(tensorflow)))'
+```
+
+例如，这可能是：
+
+```
+/usr/lib/python2.7/site-packages/tensorflow
+```
+
+切换到此目录并记下 models 子目录。包括许多深度学习模型，包含类似教程的注释，例如：
+
+*   多线程 word2vec 迷你批量跳过克模型。
+*   多线程 word2vec unbatched skip-gram 模型。
+*   CNN 用于 CIFAR-10 网络。
+*   简单，端到端，类似 LeNet-5 的卷积 MNIST 模型示例。
+*   具有注意机制的序列到序列模型。
+
+还要检查 examples 目录，因为它包含使用 MNIST 数据集的示例。
+
+在 TensorFlow 主网站上还有一个很棒的[教程列表](https://www.tensorflow.org/versions/r0.8/tutorials/index.html)。它们展示了如何使用不同的网络类型，不同的数据集以及如何以各种不同的方式使用框架。
+
+最后，有 [TensorFlow 游乐场](http://playground.tensorflow.org/)，您可以在 Web 浏览器中试验小型网络。
+
+## TensorFlow 资源
+
+*   [TensorFlow 官方主页](https://www.tensorflow.org/)
+*   [GitHub 上的 TensforFlow 项目](https://github.com/tensorflow/tensorflow)
+*   [TensorFlow 教程](https://www.tensorflow.org/versions/r0.7/tutorials/index.html)
+
+### 更多资源
+
+*   [关于 Udacity 的 TensorFlow 课程](https://www.udacity.com/course/deep-learning--ud730)
+*   [TensorFlow：异构分布式系统上的大规模机器学习](http://download.tensorflow.org/paper/whitepaper2015.pdf)（2015）
+
+## 摘要
+
+在这篇文章中，您发现了用于深度学习的 TensorFlow Python 库。
+
+您了解到它是一个快速数值计算库，专门为大型深度学习模型的开发和评估所需的操作类型而设计。
+
+您对 TensorFlow 或者这篇文章有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/introduction-python-deep-learning-library-theano.md b/docs/dl-keras/introduction-python-deep-learning-library-theano.md
new file mode 100644
index 0000000000000000000000000000000000000000..856a5f159e74f41717ccf69ba4396dc4dc4d4e77
--- /dev/null
+++ b/docs/dl-keras/introduction-python-deep-learning-library-theano.md
@@ -0,0 +1,133 @@
+# Python 深度学习库 Theano 简介
+
+> 原文： [https://machinelearningmastery.com/introduction-python-deep-learning-library-theano/](https://machinelearningmastery.com/introduction-python-deep-learning-library-theano/)
+
+Theano 是一个用于快速数值计算的 Python 库，可以在 CPU 或 GPU 上运行。
+
+它是 Python 中深度学习的关键基础库，您可以直接使用它来创建深度学习模型或包装库，从而大大简化过程。
+
+在这篇文章中，您将发现 Theano Python 库。
+
+![Introduction to the Python Deep Learning Library Theano](img/97a5a2d7ca50d98d6dd0d2787ea7bd18.jpg)
+
+Python 深度学习库 Theano
+照片由 [Kristoffer Trolle](https://www.flickr.com/photos/kristoffer-trolle/17088729869/) 拍摄，保留一些权利。
+
+## 什么是 Theano？
+
+Theano 是一个根据 BSD 许可发布的开源项目，由加拿大魁北克省蒙特利尔大学（现为 [Yoshua Bengio](http://www.iro.umontreal.ca/~bengioy/yoshua_en/index.html) 的所在地）的 LISA（现为 [MILA](http://mila.umontreal.ca/) ）小组开发。它以[希腊数学家](https://en.wikipedia.org/wiki/Theano_(philosopher))的名字命名。
+
+在它的核心 Theano 是 Python 中数学表达式的编译器。它知道如何使用您的结构并将它们转换为非常有效的代码，使用 NumPy，高效的本机库（如 [BLAS](http://www.netlib.org/blas/) 和本机代码（C ++））在 CPU 或 GPU 上尽可能快地运行。
+
+它使用大量巧妙的代码优化来尽可能地从硬件中获取尽可能多的性能。如果你深入研究代码中数学优化的细节，[请查看这个有趣的列表](http://deeplearning.net/software/theano/optimizations.html#optimizations)。
+
+Theano 表达式的实际语法是象征性的，这可能不适合初学者用于正常的软件开发。具体而言，表达式在抽象意义上定义，编译后实际用于进行计算。
+
+它专门用于处理深度学习中使用的大型神经网络算法所需的计算类型。它是同类中最早的图书馆之一（2007 年开始开发），被认为是深度学习研究和开发的行业标准。
+
+## 如何安装 Theano
+
+Theano 为主要操作系统提供了广泛的安装说明：Windows，OS X 和 Linux。阅读适合您平台的[安装 Theano 指南](http://deeplearning.net/software/theano/install.html)。
+
+Theano 假设使用 [SciPy](https://www.scipy.org/) 工作的 Python 2 或 Python 3 环境。有一些方法可以使安装更容易，例如使用 [Anaconda](https://www.continuum.io/downloads) 在您的机器上快速设置 Python 和 SciPy 以及使用 [Docker 图像](http://deeplearning.net/software/theano/install.html#docker-images)。
+
+使用 Python 和 SciPy 环境，安装 Theano 相对简单。来自 PyPI 使用 pip，例如：
+
+```
+pip install Theano
+```
+
+在撰写本文时，Theano 的最后一个正式版本是在 2016 年 3 月 21 日发布的 0.8 版本。
+
+可能会发布新版本，您需要更新以获取任何错误修复和效率改进。您可以使用 pip 升级 Theano，如下所示：
+
+```
+sudo pip install --upgrade --no-deps theano
+```
+
+您可能想要使用直接从 Github 检查的最新版本的 Theano。
+
+对于一些使用前沿 API 更改的包装器库，可能需要这样做。您可以直接从 Github 结帐安装 Theano，如下所示：
+
+```
+pip install --upgrade --no-deps git+git://github.com/Theano/Theano.git
+```
+
+您现在已准备好在 CPU 上运行 Theano，这对于小型模型的开发来说非常好。
+
+大型号可能在 CPU 上运行缓慢。如果你有一个 Nvidia GPU，你可能想要配置 Theano 来使用你的 GPU。阅读[使用适用于 Linux](http://deeplearning.net/software/theano/install.html#using-the-gpu) 或 [Mac OS X 的 GPU 指南设置 Theano 使用 GPU](http://deeplearning.net/software/theano/install.html#gpu-macos) 和[使用 GPU 指南](http://deeplearning.net/software/theano/tutorial/using_gpu.html)如何测试是否可以工作中。
+
+## 简单的 Theano 例子
+
+在本节中，我们将演示一个简单的 Python 脚本，它为您提供了 Theano 的味道。
+
+它取自 [Theano 概览指南](http://deeplearning.net/software/theano/introduction.html)。在这个例子中，我们定义了两个符号浮点变量 _a_ 和 _b_ 。
+
+我们定义了一个使用这些变量 _（c = a + b）_ 的表达式。
+
+然后我们使用 Theano 将这个符号表达式编译成一个函数，我们稍后可以使用它。
+
+最后，我们使用我们的编译表达式，插入一些实际值并使用高效的编译 Theano 代码执行计算。
+
+```
+import theano
+from theano import tensor
+# declare two symbolic floating-point scalars
+a = tensor.dscalar()
+b = tensor.dscalar()
+# create a simple expression
+c = a + b
+# convert the expression into a callable object that takes (a,b)
+# values as input and computes a value for c
+f = theano.function([a,b], c)
+# bind 1.5 to 'a', 2.5 to 'b', and evaluate 'c'
+assert 4.0 == f(1.5, 2.5)
+```
+
+运行该示例不提供任何输出。 _1.5 + 2.5 = 4.0_ 的断言是正确的。
+
+这是一个有用的示例，因为它为您提供了如何定义，编译和使用符号表达式的风格。您可以看到这可以扩展到深度学习所需的大向量和矩阵运算。
+
+## Theano 的扩展和包装
+
+如果您不熟悉深度学习，则不必直接使用 Theano。
+
+实际上，我们强烈建议您使用许多流行的 Python 项目之一，这些项目使 Theano 更容易用于深度学习。
+
+这些项目提供 Python 中的数据结构和行为，专门用于快速可靠地创建深度学习模型，同时确保由 Theano 创建和执行快速高效的模型。
+
+库提供的 Theano 语法的数量各不相同。
+
+*   例如， [Lasagne 库](http://lasagne.readthedocs.org/en/latest/)为创建深度学习模型提供了便利类，但仍希望您了解并使用 Theano 语法。这对于知道或愿意学习一点 Theano 的初学者来说也是有益的。
+*   另一个例子是 [Keras](http://keras.io/) 完全隐藏 Theano 并提供了一个非常简单的 API 来创建深度学习模型。它很好地隐藏了 Theano，它实际上可以作为另一个流行的基础框架 [TensorFlow](https://www.tensorflow.org/) 的包装器运行。
+
+我强烈建议您直接尝试使用 Theano，然后选择一个包装库来学习和练习深度学习。
+
+有关在 Theano 上构建的库的完整列表，请参阅 Theano Wiki 上的[相关项目指南](https://github.com/Theano/Theano/wiki/Related-projects)。
+
+## 更多 Theano 资源
+
+在 Theano 寻找更多资源？看看下面的一些内容。
+
+*   [Theano 官方主页](http://deeplearning.net/software/theano/)
+*   [Theano GitHub 存储库](https://github.com/Theano/Theano/)
+*   [Theano：Python 中的 CPU 和 GPU 数学编译器](http://www.iro.umontreal.ca/~lisa/pointeurs/theano_scipy2010.pdf)（2010）（PDF）
+*   [在 Theano 上建立的图书馆名单](https://github.com/Theano/Theano/wiki/Related-projects)
+*   [Theano 配置选项列表](http://deeplearning.net/software/theano/library/config.html)
+
+### Theano 和深度学习教程
+
+*   [Theano 教程](http://deeplearning.net/software/theano/tutorial/index.html)
+*   [Theano 教程的深度学习](http://www.deeplearning.net/tutorial/)
+
+### 获得 Theano 的帮助
+
+*   [Theano 用户 Google Group](http://groups.google.com/group/theano-users?pli=1)
+
+## 摘要
+
+在这篇文章中，您发现了 Theano Python 库，用于高效的数值计算。
+
+您了解到它是一个用于深度学习研究和开发的基础库，它可以直接用于创建深度学习模型，或者通过基于它的便利库（如 Lasagne 和 Keras）。
+
+您对 Theano 或 Python 中的深度学习有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/keras-functional-api-deep-learning.md b/docs/dl-keras/keras-functional-api-deep-learning.md
new file mode 100644
index 0000000000000000000000000000000000000000..500379a2c6a5cea6629e66472402fbb237a94053
--- /dev/null
+++ b/docs/dl-keras/keras-functional-api-deep-learning.md
@@ -0,0 +1,701 @@
+# 如何使用 Keras Functional API 进行深度学习
+
+> 原文： [https://machinelearningmastery.com/keras-functional-api-deep-learning/](https://machinelearningmastery.com/keras-functional-api-deep-learning/)
+
+Keras Python 库使创建深度学习模型变得快速而简单。
+
+顺序 API 允许您逐层创建模型以解决大多数问题。它的局限性在于它不允许您创建共享图层或具有多个输入或输出的模型。
+
+Keras 中的功能 API 是创建模型的另一种方式，它提供了更多的灵活性，包括创建更复杂的模型。
+
+在本教程中，您将了解如何使用 Keras 中更灵活的功能 API 来定义深度学习模型。
+
+完成本教程后，您将了解：
+
+*   Sequential 和 Functional API 之间的区别。
+*   如何使用功能 API 定义简单的多层感知器，卷积神经网络和递归神经网络模型。
+*   如何使用共享层和多个输入和输出定义更复杂的模型。
+
+让我们开始吧。
+
+*   **2017 年 11 月更新**：更新关于仅影响 1D 输入的输入图层悬挂尺寸的注释，感谢 Joe。
+*   **更新了 Nov / 2018** ：为 CNN 添加了缺失的展平层，感谢 Konstantin。
+*   **更新 Nov / 2018** ：添加了功能 API Python 语法的描述。
+
+## 教程概述
+
+本教程分为 7 个部分;他们是：
+
+1.  Keras 顺序模型
+2.  Keras 功能模型
+3.  标准网络模型
+4.  共享图层模型
+5.  多种输入和输出模型
+6.  最佳实践
+7.  **NEW** ：关于 Functional API Python 语法的注释
+
+## 1\. Keras 顺序模型
+
+作为评论，Keras 提供了 Sequential 模型 API。
+
+这是一种创建深度学习模型的方法，其中创建了 Sequential 类的实例并创建了模型层并将其添加到其中。
+
+例如，可以定义图层并将其作为数组传递给 Sequential：
+
+```
+from keras.models import Sequential
+from keras.layers import Dense
+model = Sequential([Dense(2, input_dim=1), Dense(1)])
+```
+
+图层也可以分段添加：
+
+```
+from keras.models import Sequential
+from keras.layers import Dense
+model = Sequential()
+model.add(Dense(2, input_dim=1))
+model.add(Dense(1))
+```
+
+Sequential 模型 API 非常适合在大多数情况下开发深度学习模型，但它也有一些局限性。
+
+例如，定义可能具有多个不同输入源的模型，生成多个输出目标或重用层的模型并不简单。
+
+## 2\. Keras 功能模型
+
+Keras 功能 API 为定义模型提供了更灵活的方式。
+
+它特别允许您定义多个输入或输出模型以及共享图层的模型。更重要的是，它允许您定义 ad hoc 非循环网络图。
+
+通过创建图层实例并将它们成对地直接相互连接来定义模型，然后定义一个模型，该模型指定用作模型输入和输出的图层。
+
+让我们依次看看 Keras 功能 API 的三个独特方面：
+
+### 1.定义输入
+
+与 Sequential 模型不同，您必须创建并定义一个指定输入数据形状的独立输入层。
+
+输入层采用 shape 参数，该参数是指示输入数据的维度的元组。
+
+当输入数据是一维的时，例如对于多层感知器，形状必须明确留出空间，以便在训练网络时分割数据时使用的小批量大小的形状。因此，当输入是一维（2，）时，形状元组总是用挂起的最后一个维度定义，例如：
+
+```
+from keras.layers import Input
+visible = Input(shape=(2,))
+```
+
+### 2.连接图层
+
+模型中的图层成对连接。
+
+这是通过在定义每个新图层时指定输入的来源来完成的。使用括号表示法，使得在创建层之后，指定从其输入当前层的层。
+
+让我们用一个简短的例子来说明这一点。我们可以像上面那样创建输入层，然后创建一个隐藏层作为 Dense，它只接收来自输入层的输入。
+
+```
+from keras.layers import Input
+from keras.layers import Dense
+visible = Input(shape=(2,))
+hidden = Dense(2)(visible)
+```
+
+注意创建 Dense 层之后的（可见），该层将输入层输出连接为密集隐藏层的输入。
+
+正是这种逐层连接层的方式为功能 API 提供了灵活性。例如，您可以看到开始定义图层的特殊图形是多么容易。
+
+### 3.创建模型
+
+创建所有模型图层并将它们连接在一起后，必须定义模型。
+
+与 Sequential API 一样，模型是您可以汇总，拟合，评估和用于进行预测的模型。
+
+Keras 提供了一个 Model 类，您可以使用它从创建的图层创建模型。它要求您只指定输入和输出图层。例如：
+
+```
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Dense
+visible = Input(shape=(2,))
+hidden = Dense(2)(visible)
+model = Model(inputs=visible, outputs=hidden)
+```
+
+现在我们已经了解了 Keras 功能 API 的所有关键部分，让我们通过定义一套不同的模型并使用它来构建一些实践。
+
+每个示例都是可执行的，并打印结构并创建图表。我建议您为自己的模型执行此操作，以明确您已定义的内容。
+
+我希望这些示例在您希望将来使用功能 API 定义自己的模型时为您提供模板。
+
+## 3.标准网络模型
+
+在开始使用功能 API 时，最好先了解一些标准神经网络模型的定义。
+
+在本节中，我们将研究定义一个简单的多层感知器，卷积神经网络和递归神经网络。
+
+这些示例将为以后更详细的示例提供基础。
+
+### 多层感知器
+
+在本节中，我们定义了用于二进制分类的多层 Perceptron 模型。
+
+该模型具有 10 个输入，3 个具有 10,20 和 10 个神经元的隐藏层，以及具有 1 个输出的输出层。在每个隐藏层中使用校正的线性激活函数，并且在输出层中使用 S 形激活函数，用于二进制分类。
+
+```
+# Multilayer Perceptron
+from keras.utils import plot_model
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Dense
+visible = Input(shape=(10,))
+hidden1 = Dense(10, activation='relu')(visible)
+hidden2 = Dense(20, activation='relu')(hidden1)
+hidden3 = Dense(10, activation='relu')(hidden2)
+output = Dense(1, activation='sigmoid')(hidden3)
+model = Model(inputs=visible, outputs=output)
+# summarize layers
+print(model.summary())
+# plot graph
+plot_model(model, to_file='multilayer_perceptron_graph.png')
+```
+
+运行该示例将打印网络结构。
+
+```
+_________________________________________________________________
+Layer (type)                 Output Shape              Param #
+=================================================================
+input_1 (InputLayer)         (None, 10)                0
+_________________________________________________________________
+dense_1 (Dense)              (None, 10)                110
+_________________________________________________________________
+dense_2 (Dense)              (None, 20)                220
+_________________________________________________________________
+dense_3 (Dense)              (None, 10)                210
+_________________________________________________________________
+dense_4 (Dense)              (None, 1)                 11
+=================================================================
+Total params: 551
+Trainable params: 551
+Non-trainable params: 0
+_________________________________________________________________
+```
+
+还会创建模型图的图并将其保存到文件中。
+
+![Multilayer Perceptron Network Graph](img/a996a23eabeb4945e5ff491773bcb951.jpg)
+
+多层感知器网络图
+
+### 卷积神经网络
+
+在本节中，我们将定义用于图像分类的卷积神经网络。
+
+该模型接收黑白 64×64 图像作为输入，然后具有两个卷积和池化层的序列作为特征提取器，接着是完全连接的层来解释特征，输出层具有用于两类预测的 S 形激活。
+
+```
+# Convolutional Neural Network
+from keras.utils import plot_model
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Dense
+from keras.layers import Flatten
+from keras.layers.convolutional import Conv2D
+from keras.layers.pooling import MaxPooling2D
+visible = Input(shape=(64,64,1))
+conv1 = Conv2D(32, kernel_size=4, activation='relu')(visible)
+pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
+conv2 = Conv2D(16, kernel_size=4, activation='relu')(pool1)
+pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
+flat = Flatten()(pool2)
+hidden1 = Dense(10, activation='relu')(flat)
+output = Dense(1, activation='sigmoid')(hidden1)
+model = Model(inputs=visible, outputs=output)
+# summarize layers
+print(model.summary())
+# plot graph
+plot_model(model, to_file='convolutional_neural_network.png')
+```
+
+运行该示例总结了模型层。
+
+```
+_________________________________________________________________
+Layer (type)                 Output Shape              Param #   
+=================================================================
+input_1 (InputLayer)         (None, 64, 64, 1)         0         
+_________________________________________________________________
+conv2d_1 (Conv2D)            (None, 61, 61, 32)        544       
+_________________________________________________________________
+max_pooling2d_1 (MaxPooling2 (None, 30, 30, 32)        0         
+_________________________________________________________________
+conv2d_2 (Conv2D)            (None, 27, 27, 16)        8208      
+_________________________________________________________________
+max_pooling2d_2 (MaxPooling2 (None, 13, 13, 16)        0         
+_________________________________________________________________
+flatten_1 (Flatten)          (None, 2704)              0         
+_________________________________________________________________
+dense_1 (Dense)              (None, 10)                27050     
+_________________________________________________________________
+dense_2 (Dense)              (None, 1)                 11        
+=================================================================
+Total params: 35,813
+Trainable params: 35,813
+Non-trainable params: 0
+_________________________________________________________________
+```
+
+还会创建模型图的图并将其保存到文件中。
+
+![Convolutional Neural Network Graph](img/8d5c11180494f5fb0ec35218148e7d7b.jpg)
+
+卷积神经网络图
+
+### 递归神经网络
+
+在本节中，我们将定义一个用于序列分类的长期短期记忆递归神经网络。
+
+该模型需要 100 个时间步长作为输入。该模型具有单个 LSTM 隐藏层以从序列中提取特征，随后是完全连接的层以解释 LSTM 输出，接着是用于进行二元预测的输出层。
+
+```
+# Recurrent Neural Network
+from keras.utils import plot_model
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Dense
+from keras.layers.recurrent import LSTM
+visible = Input(shape=(100,1))
+hidden1 = LSTM(10)(visible)
+hidden2 = Dense(10, activation='relu')(hidden1)
+output = Dense(1, activation='sigmoid')(hidden2)
+model = Model(inputs=visible, outputs=output)
+# summarize layers
+print(model.summary())
+# plot graph
+plot_model(model, to_file='recurrent_neural_network.png')
+```
+
+运行该示例总结了模型层。
+
+```
+_________________________________________________________________
+Layer (type)                 Output Shape              Param #
+=================================================================
+input_1 (InputLayer)         (None, 100, 1)            0
+_________________________________________________________________
+lstm_1 (LSTM)                (None, 10)                480
+_________________________________________________________________
+dense_1 (Dense)              (None, 10)                110
+_________________________________________________________________
+dense_2 (Dense)              (None, 1)                 11
+=================================================================
+Total params: 601
+Trainable params: 601
+Non-trainable params: 0
+_________________________________________________________________
+```
+
+还会创建模型图的图并将其保存到文件中。
+
+![Recurrent Neural Network Graph](img/c39b32bb7b7d10578b913aa8aa00ba34.jpg)
+
+递归神经网络图
+
+## 4.共享图层模型
+
+多个图层可以共享一个图层的输出。
+
+例如，可以存在来自输入的多个不同的特征提取层，或者用于解释来自特征提取层的输出的多个层。
+
+让我们看看这两个例子。
+
+### 共享输入层
+
+在本节中，我们定义了具有不同大小内核的多个卷积层来解释图像输入。
+
+该模型采用尺寸为 64×64 像素的黑白图像。有两个共享此输入的 CNN 特征提取子模型;第一个内核大小为 4，第二个内核大小为 8.这些特征提取子模型的输出被平展为向量并连接成一个长向量，并传递到完全连接的层以进行解释，然后最终输出层生成二进制分类。
+
+```
+# Shared Input Layer
+from keras.utils import plot_model
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Dense
+from keras.layers import Flatten
+from keras.layers.convolutional import Conv2D
+from keras.layers.pooling import MaxPooling2D
+from keras.layers.merge import concatenate
+# input layer
+visible = Input(shape=(64,64,1))
+# first feature extractor
+conv1 = Conv2D(32, kernel_size=4, activation='relu')(visible)
+pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
+flat1 = Flatten()(pool1)
+# second feature extractor
+conv2 = Conv2D(16, kernel_size=8, activation='relu')(visible)
+pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
+flat2 = Flatten()(pool2)
+# merge feature extractors
+merge = concatenate([flat1, flat2])
+# interpretation layer
+hidden1 = Dense(10, activation='relu')(merge)
+# prediction output
+output = Dense(1, activation='sigmoid')(hidden1)
+model = Model(inputs=visible, outputs=output)
+# summarize layers
+print(model.summary())
+# plot graph
+plot_model(model, to_file='shared_input_layer.png')
+```
+
+运行该示例总结了模型层。
+
+```
+____________________________________________________________________________________________________
+Layer (type)                     Output Shape          Param #     Connected to
+====================================================================================================
+input_1 (InputLayer)             (None, 64, 64, 1)     0
+____________________________________________________________________________________________________
+conv2d_1 (Conv2D)                (None, 61, 61, 32)    544         input_1[0][0]
+____________________________________________________________________________________________________
+conv2d_2 (Conv2D)                (None, 57, 57, 16)    1040        input_1[0][0]
+____________________________________________________________________________________________________
+max_pooling2d_1 (MaxPooling2D)   (None, 30, 30, 32)    0           conv2d_1[0][0]
+____________________________________________________________________________________________________
+max_pooling2d_2 (MaxPooling2D)   (None, 28, 28, 16)    0           conv2d_2[0][0]
+____________________________________________________________________________________________________
+flatten_1 (Flatten)              (None, 28800)         0           max_pooling2d_1[0][0]
+____________________________________________________________________________________________________
+flatten_2 (Flatten)              (None, 12544)         0           max_pooling2d_2[0][0]
+____________________________________________________________________________________________________
+concatenate_1 (Concatenate)      (None, 41344)         0           flatten_1[0][0]
+                                                                   flatten_2[0][0]
+____________________________________________________________________________________________________
+dense_1 (Dense)                  (None, 10)            413450      concatenate_1[0][0]
+____________________________________________________________________________________________________
+dense_2 (Dense)                  (None, 1)             11          dense_1[0][0]
+====================================================================================================
+Total params: 415,045
+Trainable params: 415,045
+Non-trainable params: 0
+____________________________________________________________________________________________________
+```
+
+还会创建模型图的图并将其保存到文件中。
+
+![Neural Network Graph With Shared Inputs](img/c4d3dd994ea7c141153c92bb593e506e.jpg)
+
+具有共享输入的神经网络图
+
+### 共享特征提取层
+
+在本节中，我们将使用两个并行子模型来解释 LSTM 特征提取器的输出以进行序列分类。
+
+模型的输入是 1 个特征的 100 个时间步长。具有 10 个存储器单元的 LSTM 层解释该序列。第一个解释模型是浅单个完全连接层，第二个是深 3 层模型。两个解释模型的输出被连接成一个长向量，该向量被传递到用于进行二进制预测的输出层。
+
+```
+# Shared Feature Extraction Layer
+from keras.utils import plot_model
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Dense
+from keras.layers.recurrent import LSTM
+from keras.layers.merge import concatenate
+# define input
+visible = Input(shape=(100,1))
+# feature extraction
+extract1 = LSTM(10)(visible)
+# first interpretation model
+interp1 = Dense(10, activation='relu')(extract1)
+# second interpretation model
+interp11 = Dense(10, activation='relu')(extract1)
+interp12 = Dense(20, activation='relu')(interp11)
+interp13 = Dense(10, activation='relu')(interp12)
+# merge interpretation
+merge = concatenate([interp1, interp13])
+# output
+output = Dense(1, activation='sigmoid')(merge)
+model = Model(inputs=visible, outputs=output)
+# summarize layers
+print(model.summary())
+# plot graph
+plot_model(model, to_file='shared_feature_extractor.png')
+```
+
+运行该示例总结了模型层。
+
+```
+____________________________________________________________________________________________________
+Layer (type)                     Output Shape          Param #     Connected to
+====================================================================================================
+input_1 (InputLayer)             (None, 100, 1)        0
+____________________________________________________________________________________________________
+lstm_1 (LSTM)                    (None, 10)            480         input_1[0][0]
+____________________________________________________________________________________________________
+dense_2 (Dense)                  (None, 10)            110         lstm_1[0][0]
+____________________________________________________________________________________________________
+dense_3 (Dense)                  (None, 20)            220         dense_2[0][0]
+____________________________________________________________________________________________________
+dense_1 (Dense)                  (None, 10)            110         lstm_1[0][0]
+____________________________________________________________________________________________________
+dense_4 (Dense)                  (None, 10)            210         dense_3[0][0]
+____________________________________________________________________________________________________
+concatenate_1 (Concatenate)      (None, 20)            0           dense_1[0][0]
+                                                                   dense_4[0][0]
+____________________________________________________________________________________________________
+dense_5 (Dense)                  (None, 1)             21          concatenate_1[0][0]
+====================================================================================================
+Total params: 1,151
+Trainable params: 1,151
+Non-trainable params: 0
+____________________________________________________________________________________________________
+```
+
+还会创建模型图的图并将其保存到文件中。
+
+![Neural Network Graph With Shared Feature Extraction Layer](img/1a156e687268e204c213d96733179234.jpg)
+
+共享特征提取层的神经网络图
+
+## 5.多种输入和输出模型
+
+功能 API 还可用于开发具有多个输入的更复杂模型，可能具有不同的模态。它还可用于开发产生多个输出的模型。
+
+我们将在本节中查看每个示例。
+
+### 多输入模型
+
+我们将开发一种图像分类模型，该模型将图像的两个版本作为输入，每个版本具有不同的大小。特别是黑白 64×64 版和 32×32 版。单独的特征提取 CNN 模型对每个模型进行操作，然后将两个模型的结果连接起来进行解释和最终预测。
+
+请注意，在创建 Model（）实例时，我们将两个输入层定义为数组。特别：
+
+```
+model = Model(inputs=[visible1, visible2], outputs=output)
+```
+
+下面列出了完整的示例。
+
+```
+# Multiple Inputs
+from keras.utils import plot_model
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Dense
+from keras.layers import Flatten
+from keras.layers.convolutional import Conv2D
+from keras.layers.pooling import MaxPooling2D
+from keras.layers.merge import concatenate
+# first input model
+visible1 = Input(shape=(64,64,1))
+conv11 = Conv2D(32, kernel_size=4, activation='relu')(visible1)
+pool11 = MaxPooling2D(pool_size=(2, 2))(conv11)
+conv12 = Conv2D(16, kernel_size=4, activation='relu')(pool11)
+pool12 = MaxPooling2D(pool_size=(2, 2))(conv12)
+flat1 = Flatten()(pool12)
+# second input model
+visible2 = Input(shape=(32,32,3))
+conv21 = Conv2D(32, kernel_size=4, activation='relu')(visible2)
+pool21 = MaxPooling2D(pool_size=(2, 2))(conv21)
+conv22 = Conv2D(16, kernel_size=4, activation='relu')(pool21)
+pool22 = MaxPooling2D(pool_size=(2, 2))(conv22)
+flat2 = Flatten()(pool22)
+# merge input models
+merge = concatenate([flat1, flat2])
+# interpretation model
+hidden1 = Dense(10, activation='relu')(merge)
+hidden2 = Dense(10, activation='relu')(hidden1)
+output = Dense(1, activation='sigmoid')(hidden2)
+model = Model(inputs=[visible1, visible2], outputs=output)
+# summarize layers
+print(model.summary())
+# plot graph
+plot_model(model, to_file='multiple_inputs.png')
+```
+
+运行该示例总结了模型层。
+
+```
+____________________________________________________________________________________________________
+Layer (type)                     Output Shape          Param #     Connected to
+====================================================================================================
+input_1 (InputLayer)             (None, 64, 64, 1)     0
+____________________________________________________________________________________________________
+input_2 (InputLayer)             (None, 32, 32, 3)     0
+____________________________________________________________________________________________________
+conv2d_1 (Conv2D)                (None, 61, 61, 32)    544         input_1[0][0]
+____________________________________________________________________________________________________
+conv2d_3 (Conv2D)                (None, 29, 29, 32)    1568        input_2[0][0]
+____________________________________________________________________________________________________
+max_pooling2d_1 (MaxPooling2D)   (None, 30, 30, 32)    0           conv2d_1[0][0]
+____________________________________________________________________________________________________
+max_pooling2d_3 (MaxPooling2D)   (None, 14, 14, 32)    0           conv2d_3[0][0]
+____________________________________________________________________________________________________
+conv2d_2 (Conv2D)                (None, 27, 27, 16)    8208        max_pooling2d_1[0][0]
+____________________________________________________________________________________________________
+conv2d_4 (Conv2D)                (None, 11, 11, 16)    8208        max_pooling2d_3[0][0]
+____________________________________________________________________________________________________
+max_pooling2d_2 (MaxPooling2D)   (None, 13, 13, 16)    0           conv2d_2[0][0]
+____________________________________________________________________________________________________
+max_pooling2d_4 (MaxPooling2D)   (None, 5, 5, 16)      0           conv2d_4[0][0]
+____________________________________________________________________________________________________
+flatten_1 (Flatten)              (None, 2704)          0           max_pooling2d_2[0][0]
+____________________________________________________________________________________________________
+flatten_2 (Flatten)              (None, 400)           0           max_pooling2d_4[0][0]
+____________________________________________________________________________________________________
+concatenate_1 (Concatenate)      (None, 3104)          0           flatten_1[0][0]
+                                                                   flatten_2[0][0]
+____________________________________________________________________________________________________
+dense_1 (Dense)                  (None, 10)            31050       concatenate_1[0][0]
+____________________________________________________________________________________________________
+dense_2 (Dense)                  (None, 10)            110         dense_1[0][0]
+____________________________________________________________________________________________________
+dense_3 (Dense)                  (None, 1)             11          dense_2[0][0]
+====================================================================================================
+Total params: 49,699
+Trainable params: 49,699
+Non-trainable params: 0
+____________________________________________________________________________________________________
+```
+
+还会创建模型图的图并将其保存到文件中。
+
+![Neural Network Graph With Multiple Inputs](img/bb8620c8c9ed94e3f29dd3ac43cd7ed1.jpg)
+
+多输入神经网络图
+
+### 多输出模型
+
+在本节中，我们将开发一个模型，该模型可以进行两种不同类型的预测。给定一个特征的 100 个时间步长的输入序列，该模型将对序列进行分类并输出具有相同长度的新序列。
+
+LSTM 层解释输入序列并返回每个时间步的隐藏状态。第一个输出模型创建堆叠 LSTM，解释特征并进行二元预测。第二输出模型使用相同的输出层对每个输入时间步进行实值预测。
+
+```
+# Multiple Outputs
+from keras.utils import plot_model
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Dense
+from keras.layers.recurrent import LSTM
+from keras.layers.wrappers import TimeDistributed
+# input layer
+visible = Input(shape=(100,1))
+# feature extraction
+extract = LSTM(10, return_sequences=True)(visible)
+# classification output
+class11 = LSTM(10)(extract)
+class12 = Dense(10, activation='relu')(class11)
+output1 = Dense(1, activation='sigmoid')(class12)
+# sequence output
+output2 = TimeDistributed(Dense(1, activation='linear'))(extract)
+# output
+model = Model(inputs=visible, outputs=[output1, output2])
+# summarize layers
+print(model.summary())
+# plot graph
+plot_model(model, to_file='multiple_outputs.png')
+```
+
+运行该示例总结了模型层。
+
+```
+____________________________________________________________________________________________________
+Layer (type)                     Output Shape          Param #     Connected to
+====================================================================================================
+input_1 (InputLayer)             (None, 100, 1)        0
+____________________________________________________________________________________________________
+lstm_1 (LSTM)                    (None, 100, 10)       480         input_1[0][0]
+____________________________________________________________________________________________________
+lstm_2 (LSTM)                    (None, 10)            840         lstm_1[0][0]
+____________________________________________________________________________________________________
+dense_1 (Dense)                  (None, 10)            110         lstm_2[0][0]
+____________________________________________________________________________________________________
+dense_2 (Dense)                  (None, 1)             11          dense_1[0][0]
+____________________________________________________________________________________________________
+time_distributed_1 (TimeDistribu (None, 100, 1)        11          lstm_1[0][0]
+====================================================================================================
+Total params: 1,452
+Trainable params: 1,452
+Non-trainable params: 0
+____________________________________________________________________________________________________
+```
+
+还会创建模型图的图并将其保存到文件中。
+
+![Neural Network Graph With Multiple Outputs](img/5c9247c398565f2d0ac41322dac602d7.jpg)
+
+具有多个输出的神经网络图
+
+## 6.最佳实践
+
+在本节中，我想给您一些提示，以便在定义自己的模型时充分利用功能 API。
+
+*   **一致的变量名称**。对输入（可见）和输出图层（输出）使用相同的变量名称，甚至可能使用隐藏图层（hidden1，hidden2）。它将有助于将事物正确连接在一起。
+*   **审查图层摘要**。始终打印模型摘要并查看图层输出，以确保模型按预期连接在一起。
+*   **审查图形图**。始终创建模型图的图并对其进行检查，以确保按照您的意图将所有内容放在一起。
+*   **命名图层**。您可以为查看模型图的摘要和图时使用的图层指定名称。例如：Dense（1，name ='hidden1'）。
+*   **单独的子模型**。考虑分离子模型的开发并在最后将子模型组合在一起。
+
+使用功能 API 时，您有自己的最佳实践技巧吗？
+请在评论中告诉我。
+
+## 7.关于 Functional API Python 语法的注释
+
+如果您是 Python 的新手或新手，功能 API 中使用的语法可能会令人困惑。
+
+例如，给定：
+
+```
+...
+dense1 = Dense(32)(input)
+...
+```
+
+**双括号语法有什么作用？**
+
+**这是什么意思？**
+
+它看起来很混乱，但它不是一个特殊的 python 东西，只有一行做两件事。
+
+第一个括号“_（32）_”通过类构造函数创建图层，第二个括号“_（输入）_”是一个没有通过 ___call __ 实现名称的函数（ ）_ 功能，调用时会连接各层。
+
+[__call __（）](https://docs.python.org/3/reference/datamodel.html#object.__call__)函数是所有可以被覆盖的 Python 对象的默认函数，用于“_ 调用 _”实例化对象。就像 [__init __（）](https://docs.python.org/3/reference/datamodel.html#object.__init__)函数是在实例化一个对象以初始化它之后调用的所有对象上的默认函数。
+
+我们可以用两行来做同样的事情：
+
+```
+# create layer
+dense1 = Dense(32)
+# connect layer to previous layer
+dense1(input)
+```
+
+我想我们也可以明确地调用对象上的 ___call __（）_ 函数，虽然我从未尝试过：
+
+```
+# create layer
+dense1 = Dense(32)
+# connect layer to previous layer
+dense1.__call_(input)
+```
+
+## 进一步阅读
+
+如果您要深入了解，本节将提供有关该主题的更多资源。
+
+*   [顺序模型 API](https://keras.io/models/model/)
+*   [Keras 顺序模型入门](https://keras.io/models/model/)
+*   [Keras 功能 API 入门](https://keras.io/models/model/)
+*   [模型类功能 API](https://keras.io/models/model/)
+
+## 摘要
+
+在本教程中，您了解了如何使用 Keras 中的功能 API 来定义简单和复杂的深度学习模型。
+
+具体来说，你学到了：
+
+*   Sequential 和 Functional API 之间的区别。
+*   如何使用功能 API 定义简单的多层感知器，卷积神经网络和递归神经网络模型。
+*   如何使用共享层和多个输入和输出定义更复杂的模型。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/multi-class-classification-tutorial-keras-deep-learning-library.md b/docs/dl-keras/multi-class-classification-tutorial-keras-deep-learning-library.md
new file mode 100644
index 0000000000000000000000000000000000000000..79e379e47317e21128f1ceff5ce4162151bf6a9b
--- /dev/null
+++ b/docs/dl-keras/multi-class-classification-tutorial-keras-deep-learning-library.md
@@ -0,0 +1,198 @@
+# Keras 深度学习库的多类分类教程
+
+> 原文： [https://machinelearningmastery.com/multi-class-classification-tutorial-keras-deep-learning-library/](https://machinelearningmastery.com/multi-class-classification-tutorial-keras-deep-learning-library/)
+
+Keras 是一个深度学习的 Python 库，它包含了高效的数值库 Theano 和 TensorFlow。
+
+在本教程中，您将了解如何使用 Keras 开发和评估多类分类问题的神经网络模型。
+
+完成本分步教程后，您将了解：
+
+*   如何从 CSV 加载数据并使其可供 Keras 使用。
+*   如何用神经网络建立多类分类数据进行建模。
+*   如何用 scikit-learn 评估 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 的示例。
+*   **2017 年 6 月更新**：更新了在输出层使用 softmax 激活，更大隐藏层，默认权重初始化的示例。
+
+![Multi-Class Classification Tutorial with the Keras Deep Learning Library](img/2dae7dc453b9ee9eecf2783612250927.jpg)
+
+Keras 深度学习库的多类分类教程
+[houroumono](https://www.flickr.com/photos/hourou/8922014724/) 的照片，保留一些权利。
+
+## 1.问题描述
+
+在本教程中，我们将使用称为[虹膜花数据集](http://archive.ics.uci.edu/ml/datasets/Iris)的标准机器学习问题。
+
+这个数据集经过深入研究，是在神经网络上实践的一个很好的问题，因为所有 4 个输入变量都是数字的，并且具有相同的厘米尺度。每个实例描述观察到的花测量的属性，输出变量是特定的虹膜种类。
+
+这是一个多类别的分类问题，意味着有两个以上的类需要预测，实际上有三种花种。这是用神经网络练习的一个重要问题类型，因为三个类值需要专门的处理。
+
+虹膜花数据集是一个充分研究的问题，我们可以[期望在 95％至 97％的范围内实现模型精度](http://www.is.umk.pl/projects/rules.html#Iris)。这为开发我们的模型提供了一个很好的目标。
+
+您可以[从 UCI 机器学习库下载虹膜花数据集](http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data)，并将其放在当前工作目录中，文件名为“ _iris.csv_ ”。
+
+## 2.导入类和函数
+
+我们可以从导入本教程中需要的所有类和函数开始。
+
+这包括我们需要 Keras 的功能，还包括 [pandas](http://pandas.pydata.org/) 的数据加载以及 [scikit-learn](http://scikit-learn.org/) 的数据准备和模型评估。
+
+```
+import numpy
+import pandas
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+from keras.utils import np_utils
+from sklearn.model_selection import cross_val_score
+from sklearn.model_selection import KFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.pipeline import Pipeline
+```
+
+## 3.初始化随机数生成器
+
+接下来，我们需要将随机数生成器初始化为常量值（7）。
+
+这对于确保我们可以再次精确地实现从该模型获得的结果非常重要。它确保可以再现训练神经网络模型的随机过程。
+
+```
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+```
+
+## 4.加载数据集
+
+可以直接加载数据集。因为输出变量包含字符串，所以最简单的方法是使用 pandas 加载数据。然后我们可以将属性（列）拆分为输入变量（X）和输出变量（Y）。
+
+```
+# load dataset
+dataframe = pandas.read_csv("iris.csv", header=None)
+dataset = dataframe.values
+X = dataset[:,0:4].astype(float)
+Y = dataset[:,4]
+```
+
+## 5.编码输出变量
+
+输出变量包含三个不同的字符串值。
+
+在使用神经网络对多类分类问题进行建模时，最好将包含每个类值的值的向量的输出属性重新整形为一个矩阵，每个类值都有一个布尔值，以及给定的实例是否具有该值是否有类值。
+
+这称为[一个热编码](https://en.wikipedia.org/wiki/One-hot)或从分类变量创建虚拟变量。
+
+例如，在这个问题中，三个类值是 Iris-setosa，Iris-versicolor 和 Iris-virginica。如果我们有观察结果：
+
+```
+Iris-setosa
+Iris-versicolor
+Iris-virginica
+```
+
+我们可以将其转换为每个数据实例的单热编码二进制矩阵，如下所示：
+
+```
+Iris-setosa,	Iris-versicolor,	Iris-virginica
+1,		0,			0
+0,		1, 			0
+0, 		0, 			1
+```
+
+我们可以通过首先使用 scikit-learn 类 LabelEncoder 将字符串一致地编码为整数来完成此操作。然后使用 Keras 函数 to_categorical（）将整数向量转换为一个热编码。
+
+```
+# encode class values as integers
+encoder = LabelEncoder()
+encoder.fit(Y)
+encoded_Y = encoder.transform(Y)
+# convert integers to dummy variables (i.e. one hot encoded)
+dummy_y = np_utils.to_categorical(encoded_Y)
+```
+
+## 6.定义神经网络模型
+
+Keras 库提供了包装类，允许您在 scikit-learn 中使用 Keras 开发的神经网络模型。
+
+Keras 中有一个 KerasClassifier 类，可以用作 scikit-learn 中的 Estimator，它是库中基本类型的模型。 KerasClassifier 将函数的名称作为参数。该函数必须返回构建的神经网络模型，为训练做好准备。
+
+下面是一个函数，它将为虹膜分类问题创建一个基线神经网络。它创建了一个简单的完全连接的网络，其中一个隐藏层包含 8 个神经元。
+
+隐藏层使用整流器激活功能，这是一种很好的做法。因为我们对虹膜数据集使用了单热编码，所以输出层必须创建 3 个输出值，每个类一个。具有最大值的输出值将被视为模型预测的类。
+
+这个简单的单层神经网络的网络拓扑可以概括为：
+
+```
+4 inputs -> [8 hidden nodes] -> 3 outputs
+```
+
+请注意，我们在输出层使用“ _softmax_ ”激活功能。这是为了确保输出值在 0 和 1 的范围内，并且可以用作预测概率。
+
+最后，网络使用具有对数损失函数的高效 Adam 梯度下降优化算法，在 Keras 中称为“ _categorical_crossentropy_ ”。
+
+```
+# define baseline model
+def baseline_model():
+	# create model
+	model = Sequential()
+	model.add(Dense(8, input_dim=4, activation='relu'))
+	model.add(Dense(3, activation='softmax'))
+	# Compile model
+	model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+	return model
+```
+
+我们现在可以创建我们的 KerasClassifier 用于 scikit-learn。
+
+我们还可以在构造 KerasClassifier 类中传递参数，该类将传递给内部用于训练神经网络的 fit（）函数。在这里，我们将时期数传递为 200，批量大小为 5，以便在训练模型时使用。通过将 verbose 设置为 0，在训练时也会关闭调试。
+
+```
+estimator = KerasClassifier(build_fn=baseline_model, epochs=200, batch_size=5, verbose=0)
+```
+
+## 7.使用 k-fold 交叉验证评估模型
+
+我们现在可以在训练数据上评估神经网络模型。
+
+scikit-learn 具有使用一套技术评估模型的出色能力。评估机器学习模型的黄金标准是 k 折交叉验证。
+
+首先，我们可以定义模型评估程序。在这里，我们将折叠数设置为 10（一个很好的默认值）并在分区之前对数据进行洗牌。
+
+```
+kfold = KFold(n_splits=10, shuffle=True, random_state=seed)
+```
+
+现在我们可以使用 10 倍交叉验证程序（kfold）在我们的数据集（X 和 dummy_y）上评估我们的模型（估计器）。
+
+评估模型仅需要大约 10 秒钟，并返回一个对象，该对象描述了对数据集的每个分割的 10 个构建模型的评估。
+
+```
+results = cross_val_score(estimator, X, dummy_y, cv=kfold)
+print("Baseline: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
+```
+
+结果总结为数据集上模型精度的均值和标准差。这是对看不见的数据的模型性能的合理估计。对于这个问题，它也属于已知的最佳结果范围。
+
+```
+Accuracy: 97.33% (4.42%)
+```
+
+## 摘要
+
+在这篇文章中，您发现了如何使用 Keras Python 库开发和评估神经网络以进行深度学习。
+
+通过完成本教程，您了解到：
+
+*   如何加载数据并使其可用于 Keras。
+*   如何使用一个热编码准备多类分类数据进行建模。
+*   如何使用 Keras 神经网络模型与 scikit-learn。
+*   如何使用 Keras 定义神经网络进行多类分类。
+*   如何使用带有 k-fold 交叉验证的 scikit-learn 来评估 Keras 神经网络模型
+
+您对 Keras 或此帖的深度学习有任何疑问吗？
+
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/neural-networks-crash-course.md b/docs/dl-keras/neural-networks-crash-course.md
new file mode 100644
index 0000000000000000000000000000000000000000..672542a652683085cafb5e3a8459c493eb7b83dd
--- /dev/null
+++ b/docs/dl-keras/neural-networks-crash-course.md
@@ -0,0 +1,177 @@
+# 多层感知器神经网络速成课程
+
+> 原文： [https://machinelearningmastery.com/neural-networks-crash-course/](https://machinelearningmastery.com/neural-networks-crash-course/)
+
+人工神经网络是一个迷人的研究领域，尽管它们在刚开始时可能会令人生畏。
+
+在描述该领域中使用的数据结构和算法时，使用了许多专门术语。
+
+在这篇文章中，您将获得在多层感知器人工神经网络领域中使用的术语和过程的速成课程。阅读这篇文章后你会知道：
+
+*   神经网络的构建块，包括神经元，权重和激活函数。
+*   如何在层中使用构建块来创建网络。
+*   如何从示例数据中训练网络。
+
+让我们开始吧。
+
+![Crash Course In Neural Networks](img/9cf44410774b0c5f0b4c55ecc97e2692.jpg)
+
+神经网络中的速成课程
+摄影： [Joe Stump](https://www.flickr.com/photos/joestump/2357729981/) ，保留一些权利。
+
+## 速成课程概述
+
+我们将在这篇文章中很快介绍很多内容。以下是对未来发展的看法：
+
+1.  多层感知。
+2.  神经元，重量和激活。
+3.  神经元网络。
+4.  培训网络。
+
+我们将从概述多层感知器开始。
+
+## 1.多层感知器
+
+人工神经网络领域通常被称为神经网络或多层感知器，可能是最有用的神经网络类型。感知器是单个神经元模型，是较大神经网络的前身。
+
+这是一个研究生物大脑的简单模型如何用于解决困难计算任务的领域，例如我们在机器学习中看到的预测建模任务。目标不是创建大脑的真实模型，而是开发可用于模拟难题的稳健算法和数据结构。
+
+神经网络的力量来自于他们学习训练数据中的表示以及如何将其与您想要预测的输出变量最佳联系的能力。从这个意义上说，神经网络学习映射。在数学上，它们能够学习任何映射函数，并且已经被证明是一种通用的近似算法。
+
+神经网络的预测能力来自网络的分层或多层结构。数据结构可以选择（学会表示）不同比例或分辨率的特征，并将它们组合成更高阶的特征。例如，从线条到线条到形状的集合。
+
+## 2.神经元
+
+神经网络的构建块是人工神经元。
+
+这些是具有加权输入信号并使用激活功能产生输出信号的简单计算单元。
+
+![Model of a Simple Neuron](img/498ab2d8740c6a44a78ade60a46c95a9.jpg)
+
+简单神经元的模型
+
+### 神经元重量
+
+您可能熟悉线性回归，在这种情况下，输入上的权重非常类似于回归方程中使用的系数。
+
+像线性回归一样，每个神经元也有一个偏差，可以认为它是一个总是具有 1.0 值的输入，它也必须加权。
+
+例如，神经元可能有两个输入，在这种情况下它需要三个权重。每个输入一个，偏差一个。
+
+虽然可以使用更复杂的初始化方案，但是权重通常被初始化为小的随机值，例如 0 到 0.3 范围内的值。
+
+与线性回归一样，较大的权重表明复杂性和脆弱性增加。期望将网络中的权重保持较小并且可以使用正则化技术。
+
+### 激活
+
+加权输入相加并通过激活函数，有时称为传递函数。
+
+激活函数是求和加权输入与神经元输出的简单映射。它被称为激活函数，因为它控制神经元激活的阈值和输出信号的强度。
+
+使用历史上简单的步骤激活函数，其中如果求和输入高于阈值，例如 0.5，则神经元将输出值 1.0，否则将输出 0.0。
+
+传统上使用非线性激活函数。这允许网络以更复杂的方式组合输入，从而在他们可以建模的功能中提供更丰富的功能。使用非线性函数，如 logistic 函数，也称为 sigmoid 函数，输出 0 到 1 之间的值，具有 s 形分布，双曲正切函数也称为 tanh，在-1 到+1 范围内输出相同的分布。
+
+最近，整流器激活功能已被证明可提供更好的结果。
+
+## 3.神经元网络
+
+神经元被排列成神经元网络。
+
+一行神经元称为层，一个网络可以有多个层。网络中神经元的体系结构通常称为网络拓扑。
+
+![Model of a Simple Network](img/efb0b72bb3c64da47744e0d5c7a8aeac.jpg)
+
+简单网络的模型
+
+### 输入或可见图层
+
+从数据集获取输入的底层称为可见层，因为它是网络的公开部分。通常，神经网络使用可见层绘制，每个输入值或数据集中的列具有一个神经元。这些不是如上所述的神经元，而是简单地将输入值传递到下一层。
+
+### 隐藏层
+
+输入图层之后的图层称为隐藏图层，因为它们不直接暴露给输入。最简单的网络结构是在隐藏层中有一个直接输出值的神经元。
+
+鉴于计算能力和高效库的增加，可以构建非常深的神经网络。深度学习可以指神经网络中有许多隐藏层。它们很深，因为它们在历史上训练起来会非常缓慢，但可能需要几秒钟或几分钟才能使用现代技术和硬件进行训练。
+
+### 输出层
+
+最后的隐藏层称为输出层，它负责输出与问题所需格式相对应的值或值向量。
+
+输出层中激活函数的选择受到您正在建模的问题类型的严格限制。例如：
+
+*   回归问题可能具有单个输出神经元，并且神经元可能没有激活功能。
+*   二进制分类问题可能有一个输出神经元，并使用 sigmoid 激活函数输出 0 到 1 之间的值，以表示预测类 1 的值的概率。这可以通过使用阈值转换为清晰的类值 0.5 和小于阈值的捕捉值为 0，否则为 1。
+*   多类分类问题可能在输出层中具有多个神经元，每个类一个（例如，着名的[虹膜花分类问题](https://en.wikipedia.org/wiki/Iris_flower_data_set)中的三个类别的三个神经元）。在这种情况下，softmax 激活函数可用于输出网络预测每个类值的概率。选择具有最高概率的输出可用于产生清晰的类别分类值。
+
+## 4.培训网络
+
+配置完成后，需要在数据集上训练神经网络。
+
+### 数据准备
+
+您必须首先准备数据以进行神经网络的培训。
+
+数据必须是数字，例如实数值。如果您有分类数据，例如值为“male”和“female”的性别属性，则可以将其转换为称为[一个热编码](https://en.wikipedia.org/wiki/One-hot)的实值表示。这是为每个类值添加一个新列的位置（在男性和女性的性别情况下为两列），并且每行添加 0 或 1，具体取决于该行的类值。
+
+对于具有多个类的分类问题，可以在输出变量上使用相同的热编码。这将从单个列创建一个二进制向量，该向量很容易直接与网络输出层中神经元的输出进行比较，如上所述，将为每个类输出一个值。
+
+神经网络要求输入以一致的方式缩放。您可以将其重新调整到 0 到 1 之间的范围，称为标准化。另一种流行的技术是将其标准化，使每列的分布均值为零，标准偏差为 1。
+
+缩放也适用于图像像素数据。诸如单词的数据可以被转换为整数，诸如数据集中的单词的流行度等级以及其他编码技术。
+
+### 随机梯度下降
+
+用于神经网络的经典且仍然优选的训练算法称为随机梯度下降。
+
+这是一行数据作为输入一次暴露给网络的地方。当网络最终产生输出值时，网络处理输入向上激活神经元。这称为网络上的前向传递。它是在训练网络之后使用的传递类型，以便对新数据进行预测。
+
+将网络输出与预期输出进行比较，并计算误差。然后，该错误通过网络传播回来，一次一层，并根据它们对错误的贡献量来更新权重。这个聪明的数学运算称为[反向传播算法](https://en.wikipedia.org/wiki/Backpropagation)。
+
+对训练数据中的所有示例重复该过程。更新整个训练数据集的网络之一称为纪元。可以训练网络数十，数百或数千个时期。
+
+### 重量更新
+
+可以从针对每个训练示例计算的误差更新网络中的权重，这称为在线学习。它可能导致网络快速但又混乱的变化。
+
+或者，可以在所有训练示例中保存错误，并且最后可以更新网络。这称为批量学习，通常更稳定。
+
+通常，因为数据集如此之大并且由于计算效率，批量的大小，在更新之前显示网络的示例的数量通常减少到少量，例如数十或数百个示例。
+
+更新权重的数量由称为学习速率的配置参数控制。它也称为步长，控制给定错误对网络权重的步骤或更改。通常使用小的重量尺寸，例如 0.1 或 0.01 或更小。
+
+可以使用您可以设置的其他配置项补充更新等式。
+
+*   动量是一个术语，它包含先前重量更新的属性，以允许权重在相同方向上继续变化，即使计算的误差较少。
+*   学习速率衰减用于降低时期上的学习速率，以允许网络在开始时对权重进行大的改变，并且在训练时间表中稍后进行较小的微调改变。
+
+### 预测
+
+一旦神经网络被训练，它就可以用于进行预测。
+
+您可以对测试或验证数据进行预测，以便估计模型对未见数据的技能。您还可以在操作上部署它并使用它来连续进行预测。
+
+您需要从模型中保存网络拓扑和最终权重集。通过向网络提供输入并执行前向传递来进行预测，从而允许它生成可用作预测的输出。
+
+## 更多资源
+
+关于人工神经网络的主题有数十年的论文和书籍。
+
+如果您是该领域的新手，我建议您阅读以下资源：
+
+*   [Neural Smithing：前馈人工神经网络中的监督学习](http://www.amazon.com/dp/0262527014?tag=inspiredalgor-20)
+*   [模式识别神经网络](http://www.amazon.com/dp/0198538642?tag=inspiredalgor-20)
+*   [神经网络简介](http://www.amazon.com/dp/1857285034?tag=inspiredalgor-20)
+
+## 摘要
+
+在这篇文章中，您发现了用于机器学习的人工神经网络
+
+阅读本文后，您现在知道：
+
+*   神经网络如何不是大脑的模型，而是解决复杂机器学习问题的计算模型。
+*   神经网络由具有权重和激活功能的神经元组成。
+*   网络被组织成神经元层，并使用随机梯度下降进行训练。
+*   在训练神经网络模型之前准备数据是个好主意。
+
+你对神经网络或这篇文章有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/object-recognition-convolutional-neural-networks-keras-deep-learning-library.md b/docs/dl-keras/object-recognition-convolutional-neural-networks-keras-deep-learning-library.md
new file mode 100644
index 0000000000000000000000000000000000000000..9b76b419025b10afc00a3c735e46974160284e90
--- /dev/null
+++ b/docs/dl-keras/object-recognition-convolutional-neural-networks-keras-deep-learning-library.md
@@ -0,0 +1,341 @@
+# 基于卷积神经网络的 Keras 深度学习库中的目标识别
+
+> 原文： [https://machinelearningmastery.com/object-recognition-convolutional-neural-networks-keras-deep-learning-library/](https://machinelearningmastery.com/object-recognition-convolutional-neural-networks-keras-deep-learning-library/)
+
+Keras 是一个用于深度学习的 Python 库，它包含强大的数值库 Theano 和 TensorFlow。
+
+传统神经网络衰落的一个难题是物体识别。这是模型能够识别图像中的对象的地方。
+
+在这篇文章中，您将了解如何开发和评估 Keras 中用于对象识别的深度学习模型。完成本教程后，您将了解：
+
+*   关于 CIFAR-10 对象识别数据集以及如何在 Keras 中加载和使用它。
+*   如何创建一个简单的卷积神经网络进行对象识别。
+*   如何通过创建更深层次的卷积神经网络来提升性能。
+
+让我们开始吧。
+
+*   **2016 年 10 月更新**：更新了 Keras 1.1.0 和 TensorFlow 0.10.0 的示例。
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+
+## CIFAR-10 问题描述
+
+由于物体，位置，照明等几乎无限多的排列，因此难以自动识别照片中的物体。这是一个非常难的问题。
+
+这是计算机视觉中一个经过充分研究的问题，最近也是深度学习能力的重要证明。 [加拿大高级研究所（CIFAR）](https://en.wikipedia.org/wiki/Canadian_Institute_for_Advanced_Research)开发了针对该问题的标准计算机视觉和深度学习数据集。
+
+[CIFAR-10 数据集](http://www.cs.toronto.edu/~kriz/cifar.html)由 60,000 张照片组成，分为 10 个类别（因此命名为 CIFAR-10）。课程包括飞机，汽车，鸟类，猫等常见物品。数据集以标准方式分割，其中 50,000 个图像用于训练模型，剩余的 10,000 个用于评估其性能。
+
+这些照片的颜色为红色，绿色和蓝色，但很小，尺寸为 32 x 32 像素。
+
+使用非常大的卷积神经网络实现了现有技术的结果。您可以在 Rodrigo Benenson 的网页上了解 [CIFAR-10 的结果状态。模型性能以分类准确度报告，非常好的性能超过 90％，人类在该问题上的表现为 94％，而在撰写本文时，最先进的结果为 96％。](http://rodrigob.github.io/are_we_there_yet/build/classification_datasets_results.html#43494641522d3130)
+
+有一个 [Kaggle 比赛使用了 CIFAR-10 数据集](https://www.kaggle.com/c/cifar-10)。这是一个加入讨论开发问题的新模型，并以模型和脚本为起点的好地方。
+
+## 在 Keras 中加载 CIFAR-10 数据集
+
+CIFAR-10 数据集可以轻松加载到 Keras 中。
+
+Keras 可以自动下载 CIFAR-10 等标准数据集，并使用 cifar10.load_data（）函数将它们存储在〜/ .keras / datasets 目录中。此数据集很大，为 163 兆字节，因此下载可能需要几分钟。
+
+下载后，对该函数的后续调用将加载准备好使用的数据集。
+
+数据集存储为酸洗训练和测试集，准备在 Keras 中使用。每个图像表示为三维矩阵，具有红色，绿色，蓝色，宽度和高度的尺寸。我们可以使用 [matplotlib](http://matplotlib.org/) 直接绘制图像。
+
+```
+# Plot ad hoc CIFAR10 instances
+from keras.datasets import cifar10
+from matplotlib import pyplot
+from scipy.misc import toimage
+# load data
+(X_train, y_train), (X_test, y_test) = cifar10.load_data()
+# create a grid of 3x3 images
+for i in range(0, 9):
+	pyplot.subplot(330 + 1 + i)
+	pyplot.imshow(toimage(X_train[i]))
+# show the plot
+pyplot.show()
+```
+
+运行代码可创建 3×3 的照片。图像已经从 32×32 的小尺寸放大，但你可以清楚地看到卡车马和汽车。您还可以在一些强制为方形宽高比的图像中看到一些失真。
+
+![Small Sample of CIFAR-10 Images](img/def90f3b9b58bf30829a905ae7da3e0d.jpg)
+
+CIFAR-10 图像的小样本
+
+## CIFAR-10 的简单卷积神经网络
+
+使用卷积神经网络（CNN）可以最好地解决 CIFAR-10 问题。
+
+我们可以通过定义本例中需要的所有类和函数来快速入门。
+
+```
+# Simple CNN model for CIFAR-10
+import numpy
+from keras.datasets import cifar10
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import Dropout
+from keras.layers import Flatten
+from keras.constraints import maxnorm
+from keras.optimizers import SGD
+from keras.layers.convolutional import Conv2D
+from keras.layers.convolutional import MaxPooling2D
+from keras.utils import np_utils
+from keras import backend as K
+K.set_image_dim_ordering('th')
+```
+
+好的做法是，我们接下来用常数初始化随机数种子，以确保结果可重复。
+
+```
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+```
+
+接下来，我们可以加载 CIFAR-10 数据集。
+
+```
+# load data
+(X_train, y_train), (X_test, y_test) = cifar10.load_data()
+```
+
+对于红色，绿色和蓝色通道中的每一个，像素值在 0 到 255 的范围内。
+
+使用标准化数据是一种很好的做法。因为输入值很好理解，所以我们可以通过将每个值除以最大值 255 来轻松归一化到 0 到 1 的范围。
+
+注意，数据作为整数加载，因此我们必须将其转换为浮点值才能执行除法。
+
+```
+# normalize inputs from 0-255 to 0.0-1.0
+X_train = X_train.astype('float32')
+X_test = X_test.astype('float32')
+X_train = X_train / 255.0
+X_test = X_test / 255.0
+```
+
+输出变量定义为每个类从 0 到 1 的整数向量。
+
+我们可以使用一个热编码将它们转换为二进制矩阵，以便最好地对分类问题进行建模。我们知道这个问题有 10 个类，所以我们可以期望二进制矩阵的宽度为 10。
+
+```
+# one hot encode outputs
+y_train = np_utils.to_categorical(y_train)
+y_test = np_utils.to_categorical(y_test)
+num_classes = y_test.shape[1]
+```
+
+让我们首先将一个简单的 CNN 结构定义为基线，并评估它对问题的执行情况。
+
+我们将使用具有两个卷积层的结构，然后进行最大池化并将网络展平为完全连接的层以进行预测。
+
+我们的基线网络结构可归纳如下：
+
+1.  卷积输入层，32 个大小为 3×3 的特征映射，整流器激活函数和最大范数的权重约束设置为 3。
+2.  辍学率设定为 20％。
+3.  卷积层，32 个特征映射，大小为 3×3，整流器激活函数和最大范数的权重约束设置为 3。
+4.  Max Pool 图层，大小为 2×2。
+5.  展平图层。
+6.  完全连接的层具有 512 个单元和整流器激活功能。
+7.  辍学率设定为 50％。
+8.  完全连接的输出层，10 个单元和 softmax 激活功能。
+
+对数损失函数与随机梯度下降优化算法一起使用，该算法配置有大动量和重量衰减开始，学习率为 0.01。
+
+```
+# Create the model
+model = Sequential()
+model.add(Conv2D(32, (3, 3), input_shape=(3, 32, 32), padding='same', activation='relu', kernel_constraint=maxnorm(3)))
+model.add(Dropout(0.2))
+model.add(Conv2D(32, (3, 3), activation='relu', padding='same', kernel_constraint=maxnorm(3)))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+model.add(Flatten())
+model.add(Dense(512, activation='relu', kernel_constraint=maxnorm(3)))
+model.add(Dropout(0.5))
+model.add(Dense(num_classes, activation='softmax'))
+# Compile model
+epochs = 25
+lrate = 0.01
+decay = lrate/epochs
+sgd = SGD(lr=lrate, momentum=0.9, decay=decay, nesterov=False)
+model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
+print(model.summary())
+```
+
+我们可以将这个模型与 25 个时期和 32 个批量大小相匹配。
+
+选择了少量的时代来帮助保持本教程的发展。通常，对于该问题，时期的数量将是一个或两个数量级。
+
+一旦模型适合，我们在测试数据集上对其进行评估并打印出分类准确度。
+
+```
+# Fit the model
+model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=epochs, batch_size=32)
+# Final evaluation of the model
+scores = model.evaluate(X_test, y_test, verbose=0)
+print("Accuracy: %.2f%%" % (scores[1]*100))
+```
+
+运行此示例提供以下结果。首先总结网络结构，确认我们的设计是正确实施的。
+
+```
+_________________________________________________________________
+Layer (type)                 Output Shape              Param #   
+=================================================================
+conv2d_1 (Conv2D)            (None, 32, 32, 32)        896       
+_________________________________________________________________
+dropout_1 (Dropout)          (None, 32, 32, 32)        0         
+_________________________________________________________________
+conv2d_2 (Conv2D)            (None, 32, 32, 32)        9248      
+_________________________________________________________________
+max_pooling2d_1 (MaxPooling2 (None, 32, 16, 16)        0         
+_________________________________________________________________
+flatten_1 (Flatten)          (None, 8192)              0         
+_________________________________________________________________
+dense_1 (Dense)              (None, 512)               4194816   
+_________________________________________________________________
+dropout_2 (Dropout)          (None, 512)               0         
+_________________________________________________________________
+dense_2 (Dense)              (None, 10)                5130      
+=================================================================
+Total params: 4,210,090.0
+Trainable params: 4,210,090.0
+Non-trainable params: 0.0
+_________________________________________________________________
+```
+
+在训练和测试数据集的每个时期打印分类准确度和损失。该模型在测试装置上进行评估，达到 70.85％的准确度，这并不是很好。
+
+```
+...
+Epoch 20/25
+50000/50000 [==============================] - 143s - loss: 0.2858 - acc: 0.9011 - val_loss: 1.0091 - val_acc: 0.7063
+Epoch 21/25
+50000/50000 [==============================] - 143s - loss: 0.2693 - acc: 0.9067 - val_loss: 1.0122 - val_acc: 0.7069
+Epoch 22/25
+50000/50000 [==============================] - 143s - loss: 0.2544 - acc: 0.9119 - val_loss: 1.0240 - val_acc: 0.7097
+Epoch 23/25
+50000/50000 [==============================] - 143s - loss: 0.2399 - acc: 0.9168 - val_loss: 1.0680 - val_acc: 0.7077
+Epoch 24/25
+50000/50000 [==============================] - 143s - loss: 0.2285 - acc: 0.9197 - val_loss: 1.0702 - val_acc: 0.7119
+Epoch 25/25
+50000/50000 [==============================] - 143s - loss: 0.2177 - acc: 0.9238 - val_loss: 1.0686 - val_acc: 0.7085
+Accuracy: 70.85%
+```
+
+我们可以通过创建更深入的网络来显着提高准确性。这是我们将在下一节中看到的内容。
+
+## 用于 CIFAR-10 的更大卷积神经网络
+
+我们已经看到一个简单的 CNN 在这个复杂的问题上表现不佳。在本节中，我们将着眼于扩大模型的大小和复杂性。
+
+让我们设计上面简单 CNN 的深层版本。我们可以引入额外的一轮卷积以及更多的特征映射。我们将使用相同的 Convolutional，Dropout，Convolutional 和 Max Pooling 图层模式。
+
+使用 32,64 和 128 个要素贴图将重复此模式 3 次。效果是在给定最大池层的情况下，越来越多的特征图具有越来越小的尺寸。最后，将在网络的输出端使用额外的更大的 Dense 层，以尝试更好地将大量要素图转换为类值。
+
+我们可以总结一个新的网络架构如下：
+
+*   卷积输入层，32 个大小为 3×3 的特征映射和整流器激活功能。
+*   辍学层为 20％。
+*   卷积层，32 个特征映射，大小为 3×3，具有整流器激活功能。
+*   Max Pool 图层，大小为 2×2。
+*   卷积层，64 个特征映射，大小为 3×3，具有整流器激活功能。
+*   辍学层为 20％。
+*   卷积层，64 个特征映射，大小为 3×3，具有整流器激活功能。
+*   Max Pool 图层，大小为 2×2。
+*   卷积层，128 个特征图，大小为 3×3，具有整流器激活功能。
+*   辍学层为 20％。
+*   卷积层，128 个特征图，大小为 3×3，具有整流器激活功能。
+*   Max Pool 图层，大小为 2×2。
+*   展平图层。
+*   辍学层为 20％。
+*   完全连接的层具有 1024 个单元和整流器激活功能。
+*   辍学层为 20％。
+*   完全连接的层具有 512 个单元和整流器激活功能。
+*   辍学层为 20％。
+*   完全连接的输出层，10 个单元和 softmax 激活功能。
+
+我们可以很容易地在 Keras 中定义这种网络拓扑，如下所示：
+
+```
+# Create the model
+model = Sequential()
+model.add(Conv2D(32, (3, 3), input_shape=(3, 32, 32), activation='relu', padding='same'))
+model.add(Dropout(0.2))
+model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
+model.add(Dropout(0.2))
+model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+model.add(Conv2D(128, (3, 3), activation='relu', padding='same'))
+model.add(Dropout(0.2))
+model.add(Conv2D(128, (3, 3), activation='relu', padding='same'))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+model.add(Flatten())
+model.add(Dropout(0.2))
+model.add(Dense(1024, activation='relu', kernel_constraint=maxnorm(3)))
+model.add(Dropout(0.2))
+model.add(Dense(512, activation='relu', kernel_constraint=maxnorm(3)))
+model.add(Dropout(0.2))
+model.add(Dense(num_classes, activation='softmax'))
+# Compile model
+epochs = 25
+lrate = 0.01
+decay = lrate/epochs
+sgd = SGD(lr=lrate, momentum=0.9, decay=decay, nesterov=False)
+model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
+print(model.summary())
+```
+
+我们可以使用与上述相同的程序和相同数量的时期来拟合和评估该模型，但是通过一些小的实验发现更大的批量大小为 64。
+
+```
+numpy.random.seed(seed)
+model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=epochs, batch_size=64)
+# Final evaluation of the model
+scores = model.evaluate(X_test, y_test, verbose=0)
+print("Accuracy: %.2f%%" % (scores[1]*100))
+```
+
+运行此示例将在每个时期打印训练和测试数据集的分类准确性和损失。最终模型的分类精度估计值为 80.18％，比我们的简单模型好近 10 个点。
+
+```
+# 50000/50000 [==============================] - 34s - loss: 0.4993 - acc: 0.8230 - val_loss: 0.5994 - val_acc: 0.7932
+# Epoch 20/25
+# 50000/50000 [==============================] - 34s - loss: 0.4877 - acc: 0.8271 - val_loss: 0.5986 - val_acc: 0.7932
+# Epoch 21/25
+# 50000/50000 [==============================] - 34s - loss: 0.4714 - acc: 0.8327 - val_loss: 0.5916 - val_acc: 0.7959
+# Epoch 22/25
+# 50000/50000 [==============================] - 34s - loss: 0.4603 - acc: 0.8376 - val_loss: 0.5954 - val_acc: 0.8003
+# Epoch 23/25
+# 50000/50000 [==============================] - 34s - loss: 0.4454 - acc: 0.8410 - val_loss: 0.5742 - val_acc: 0.8024
+# Epoch 24/25
+# 50000/50000 [==============================] - 34s - loss: 0.4332 - acc: 0.8468 - val_loss: 0.5829 - val_acc: 0.8027
+# Epoch 25/25
+# 50000/50000 [==============================] - 34s - loss: 0.4217 - acc: 0.8498 - val_loss: 0.5785 - val_acc: 0.8018
+# Accuracy: 80.18%
+```
+
+## 扩展以提高模型性能
+
+我们在这个非常困难的问题上取得了很好的成绩，但我们仍然是实现世界级成果的好方法。
+
+以下是您可以尝试扩展模型并提高模型性能的一些想法。
+
+*   **培养更多时代**。每个模型都训练了极少数的时代，25。通常训练大型卷积神经网络数百或数千个时代。我希望通过大幅提高培训时期的数量来实现绩效提升。
+*   **图像数据增强**。图像中的对象位置不同。通过使用一些数据增强可以实现模型性能的另一个提升。诸如标准化和随机移位以及水平图像翻转的方法可能是有益的。
+*   **更深入的网络拓扑**。呈现的较大网络很深，但可以针对该问题设计更大的网络。这可能涉及更接近输入的更多特征图，并且可能涉及较不积极的池。另外，可以采用并评估已经显示有用的标准卷积网络拓扑结构。
+
+## 摘要
+
+在这篇文章中，您发现了如何在 Keras 中创建深度学习模型，以便在照片中进行对象识别。
+
+完成本教程后，您了解到：
+
+*   关于 CIFAR-10 数据集以及如何在 Keras 中加载它并从数据集中绘制特殊示例。
+*   如何训练和评估一个简单的卷积神经网络的问题。
+*   如何将简单的卷积神经网络扩展为深度卷积神经网络，以提高对难题的性能。
+*   如何使用数据扩充来进一步推动困难的对象识别问题。
+
+您对对象识别或此帖有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/popular-deep-learning-libraries.md b/docs/dl-keras/popular-deep-learning-libraries.md
new file mode 100644
index 0000000000000000000000000000000000000000..6282363ee704c977be0e511e53c1cf06d7d3f958
--- /dev/null
+++ b/docs/dl-keras/popular-deep-learning-libraries.md
@@ -0,0 +1,152 @@
+# 流行的深度学习图书馆
+
+> 原文： [https://machinelearningmastery.com/popular-deep-learning-libraries/](https://machinelearningmastery.com/popular-deep-learning-libraries/)
+
+有很多深度学习库可供选择。
+
+哪些是值得学习的优秀专业图书馆，哪些是侧面项目，应该避免。很难分辨出来。
+
+在这篇文章中，您将发现您应该考虑在自己的深度学习项目中学习和使用的顶级深度学习库。
+
+让我们开始吧。
+
+![Popular Deep Learning Libraries](img/d901ddd6726290886da25ffca5932512.jpg)
+
+流行的深度学习图书馆
+照片由 [Nikki](https://www.flickr.com/photos/nikkis_pikkis/1112212508/) 拍摄，保留一些权利。
+
+## 概观
+
+在这篇文章中，您将发现以下深度学习库。所有这些都是使用各种不同的许可许可证的开源。
+
+*   Theano
+*   火炬
+*   咖啡
+*   DeepLearning4J
+
+还有许多其他优秀的库和平台。一些更值得尊敬的提及包括 Google 的 [TensorFlow](https://www.tensorflow.org/) ，R 中的 [darch](http://cran.um.ac.ir/web/packages/darch/index.html) ，JavaScript 中的 [Convnet.js](http://cs.stanford.edu/people/karpathy/convnetjs/) （用于学习）， [Mocha](https://github.com/pluskid/Mocha.jl) 在 Julia ， [CNTK](https://github.com/Microsoft/CNTK) 由微软和 [H2O](http://www.h2o.ai/) Web API。
+
+## Theano
+
+Theano 是由 LISA 集团（现为 [MILA](http://mila.umontreal.ca/en/) ）开发的 Python 框架，由蒙特利尔大学的 [Yoshua Bengio](http://www.iro.umontreal.ca/~bengioy/yoshua_en/index.html) 运营，用于研究和开发最先进的深度学习算法。
+
+它更好地描述为一个数学表达式编译器，您可以在其中象征性地定义您想要的内容，并且框架使您的程序符合您在 GPU 或 CPU 上高效运行的程序。
+
+它不仅仅是一个深度学习库，也是一个研究平台。你必须自己做很多工作来创建你想要的模型。例如，没有神经网络类。
+
+然而，有一个优秀的深度学习教程，向您展示如何为深度学习创建类和函数。例如，它提供了创建以下深度学习算法的分步示例：
+
+*   [深度卷积网络](http://deeplearning.net/tutorial/lenet.html)
+*   [堆叠去噪自动编码器](http://deeplearning.net/tutorial/SdA.html)
+*   [深信仰网络](http://deeplearning.net/tutorial/DBN.html)
+
+在线查看[整个教程](http://deeplearning.net/tutorial/contents.html)或下载 [PDF 版](http://deeplearning.net/tutorial/deeplearning.pdf)
+
+Theano 实际上是一个生态系统，在实践中你不会直接使用 Theano。在 Theano 之上构建了一个[长的库列表，提供了方便的包装 API。一些更受欢迎的项目包括：](https://github.com/Theano/Theano/wiki/Related-projects)
+
+*   [Keras](http://keras.io/)
+*   [烤宽面条](https://github.com/Lasagne/Lasagne)
+*   [阻止](https://github.com/mila-udem/blocks)
+*   [Pylearn2](http://deeplearning.net/software/pylearn2/) （已解散）
+
+这些项目本身就变成了非常大的项目，为底层的 Theano 平台提供了有用的 API，大大加快了将模型组合在一起的速度。
+
+如果您是 Python 开发人员并且对更广泛的深度学习或研究感兴趣，那么这就是您的平台。
+
+### 资源
+
+*   [Theano 网页](http://deeplearning.net/software/theano/)
+*   [Theano 用户组](https://groups.google.com/forum/#!forum/theano-users)（谷歌集团）
+*   [Theano Github 项目](https://github.com/Theano/Theano/)
+
+## 火炬
+
+Torch（使用奇数版本编号称为 Torch7）是由 [Ronan Collobert](https://www.linkedin.com/in/ronan-collobert-b110aa8) ， [Clement Farabet](https://www.linkedin.com/in/clementfarabet) 和 [Koray Kavukcuoglu](https://uk.linkedin.com/in/koray-kavukcuoglu-0439a720) 开发的 Lua 深度学习框架，用于深入研究和开发学习算法。它由纽约大学的 [CILVR 实验室](http://cilvr.nyu.edu/doku.php?id=start)（ [Yann LeCun](https://www.linkedin.com/in/yann-lecun-0b999) 的家）使用和推广。
+
+使用 Torch 并由 Facebook AI 实验室，Google DeepMind，Twitter 和其他许多人进一步开发。
+
+在幕后，Torch 使用 C / C ++库以及 GPU 的 CUDA。它的目标是加速使用 C 友好语言 Lua 来提供一个不那么令人生畏的界面。
+
+> Torch 的目标是在构建科学算法的过程中获得最大的灵活性和速度，同时使过程变得非常简单
+
+有很多文档，但它是一团糟。 Torch 的流行应用是用于卷积神经网络的监督图像问题，以及具有深度强化学习的更复杂领域的代理。
+
+如果您主要对强化学习感兴趣，Torch 可能是您的平台。
+
+### 资源
+
+*   [火炬官方主页](http://torch.ch/)
+*   [Github 上的火炬计划](https://github.com/torch/torch7)
+*   [Torch 文档和 Cheatsheet](https://github.com/torch/torch7/wiki/Cheatsheet) （社区 Wiki）
+
+## 咖啡
+
+Caffe 是由 [Yangqing Jia](https://www.linkedin.com/in/yangqing-jia-a67037b) 在伯克利远景和学习中心开发的用于监督计算机视觉问题的 Python 深度学习库。
+
+主要关注的是卷积神经网络，它可能是世界领先者。
+
+该库的一大好处是可以从 [Caffe Model Zoo](http://caffe.berkeleyvision.org/model_zoo.html) 下载并立即使用的预训练网络数量。这包括可以在标准计算机视觉数据集上实现世界级结果的最先进模型。
+
+例如，这里有一些世界级模型的教程：
+
+*   [Alex 的 CIFAR-10 教程与 Caffe](http://caffe.berkeleyvision.org/gathered/examples/cifar10.html)
+*   [用 Caffe](http://caffe.berkeleyvision.org/gathered/examples/mnist.html) 在 MNIST 上训练 LeNet
+*   [ImageNet 与 Caffe](http://caffe.berkeleyvision.org/gathered/examples/imagenet.html)
+
+如果您主要对卷积神经网络和图像问题感兴趣，那么 Caffe 可能就是您的平台。
+
+### 资源
+
+*   [Caffe 主页](http://caffe.berkeleyvision.org/)
+*   [Caffe Github 项目](https://github.com/BVLC/caffe)
+
+## DeepLearning4J
+
+DeepLearning4J（简称 DL4J）是由 [Adam Gibson](https://www.linkedin.com/in/agibsonccc) 用于商业深度学习项目的 Java（和 JVM 语言）开发的深度学习框架。
+
+> DL4J 是一个基于 JVM，以行业为中心，商业支持的分布式深度学习框架，旨在解决在合理时间内涉及大量数据的问题
+
+DeepLearning4J 是一个灵活的平台，它提供了一套最先进的深度学习算法，不仅限于：
+
+*   深信仰网络
+*   堆叠去噪自动编码器
+*   卷积神经网络
+*   长短期记忆单位
+*   递归神经网络
+
+[文档](http://deeplearning4j.org/documentation)非常好，涵盖了一系列主题，包括算法本身的一些理论和代码示例。
+
+它具有与整个 Java 生态系统一起使用的优势，这是商业软件开发中的主要平台，包括 JVM 上的其他语言（例如 Scala）和大数据平台（Hadoop 和 Spark）。
+
+### 资源
+
+*   [DeepLearning4J 主页](http://deeplearning4j.org/)
+*   [GitHub 上的 DeeplLearning4J](https://github.com/deeplearning4j/deeplearning4j)
+*   [支持 DeepLearning4J](http://skymind.io/)
+
+## 深度学习工具综述
+
+很多人已经完成了深度学习库和工具的总结。本节列出了一些可用于深入学习深度学习工具的总结和其他资源。
+
+*   KDDNuggets 有一个深度学习工具，名为[流行深度学习工具 - 评论](http://www.kdnuggets.com/2015/06/popular-deep-learning-tools.html)，其中包括 2015 年调查的结果。看起来像 Pylearn2 和 Theano 是最受欢迎的。
+*   DL4J 比较了所有名为 [DL4J 与 Torch vs. Theano vs. Caffe vs. TensorFlow](http://deeplearning4j.org/compare-dl4j-torch7-pylearn.html) 的顶级工具。
+*   Quora 帖子[目前阶段处理大数据的最佳深度学习库是什么？](https://www.quora.com/What-is-the-best-deep-learning-library-at-the-current-stage-for-working-on-large-data) 作为概述非常有见地。
+*   Teglor 有一个很好的回合标题为[语言深度学习库](http://www.teglor.com/b/deep-learning-libraries-language-cm569/)
+*   DeepLearning.net 有一个很好的[深度学习软件列表](http://deeplearning.net/software_links/)。
+*   在 reddit 上有一个很棒的讨论题为[深度神经网络的最佳框架](https://www.reddit.com/r/MachineLearning/comments/2c9x0s/best_framework_for_deep_neural_nets/)？
+*   名为 [100 Best GitHub：深度学习](http://meta-guide.com/software-meta-guide/100-best-github-deep-learning)的开源深度学习项目清单。
+
+## 摘要
+
+在这篇文章中，您将发现最受欢迎的深度学习工具和库。
+
+具体来说，您了解到：
+
+*   Theano
+*   火炬
+*   咖啡
+*   DeepLearning4J
+
+您是否使用过一种或多种这些工具？请在评论中告诉我您对它们的看法。
+
+您对本文中列出的深度学习或库有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/predict-sentiment-movie-reviews-using-deep-learning.md b/docs/dl-keras/predict-sentiment-movie-reviews-using-deep-learning.md
new file mode 100644
index 0000000000000000000000000000000000000000..863d1dadfc74e703d46a1022908c13826d00b808
--- /dev/null
+++ b/docs/dl-keras/predict-sentiment-movie-reviews-using-deep-learning.md
@@ -0,0 +1,343 @@
+# 用深度学习预测电影评论的情绪
+
+> 原文： [https://machinelearningmastery.com/predict-sentiment-movie-reviews-using-deep-learning/](https://machinelearningmastery.com/predict-sentiment-movie-reviews-using-deep-learning/)
+
+[情感分析](https://en.wikipedia.org/wiki/Sentiment_analysis)是一种自然语言处理问题，其中理解文本并预测潜在意图。
+
+在这篇文章中，您将了解如何使用 Keras 深度学习库在 Python 中预测电影评论的积极或消极情绪。
+
+阅读这篇文章后你会知道：
+
+*   关于自然语言处理的 IMDB 情绪分析问题以及如何在 Keras 中加载它。
+*   如何在 Keras 中使用单词嵌入来解决自然语言问题。
+*   如何开发和评估 IMDB 问题的多层感知器模型。
+*   如何为 IMDB 问题开发一维卷积神经网络模型。
+
+让我们开始吧。
+
+*   **2016 年 10 月更新**：更新了 Keras 1.1.0 和 TensorFlow 0.10.0 的示例。
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+
+![Predict Sentiment From Movie Reviews Using Deep Learning](img/5c59c425196cb23cb43afa5a74345b1e.jpg)
+
+使用深度学习预测电影评论的情绪
+[SparkCBC](https://www.flickr.com/photos/25031050@N06/3407720762/) 的照片，保留一些权利。
+
+## IMDB 电影评论情绪问题描述
+
+数据集是[大型电影评论数据集](http://ai.stanford.edu/~amaas/data/sentiment/)，通常称为 IMDB 数据集。
+
+大型电影评论数据集（通常称为 IMDB 数据集）包含 25,000 个用于培训的高极移动评论（好的或坏的）以及用于测试的相同数量。问题是确定给定的移动评论是否具有正面或负面情绪。
+
+这些数据由斯坦福大学的研究人员收集并用于 [2011 年论文](http://ai.stanford.edu/~amaas/papers/wvSent_acl2011.pdf) [PDF]，其中 50/50 的数据用于训练和测试。准确度达到 88.89％。
+
+该数据还被用作 2014 年底至 2015 年初名为“[袋子爆米花袋](https://www.kaggle.com/c/word2vec-nlp-tutorial/data)”的 Kaggle 比赛的基础。获胜者达到 99％时，准确率达到 97％以上。
+
+## 使用 Keras 加载 IMDB 数据集
+
+Keras 可以访问内置的 [IMDB 数据集。](http://keras.io/datasets/)
+
+keras.datasets.imdb.load_data（）允许您以可用于神经网络和深度学习模型的格式加载数据集。
+
+单词已被整数替换，表示数据集中单词的绝对流行度。因此，每个评论中的句子由一系列整数组成。
+
+第一次调用 imdb.load_data（）会将 IMDB 数据集下载到您的计算机并将其作为 32 兆字节文件存储在〜/ .keras / datasets / imdb.pkl 下的主目录中。
+
+有用的是，imdb.load_data（）提供了额外的参数，包括要加载的顶部字的数量（其中具有较低整数的字在返回的数据中标记为零），要跳过的顶部字的数量（以避免“该”的）以及支持的最大评论期限。
+
+让我们加载数据集并计算它的一些属性。我们将首先加载一些库并将整个 IMDB 数据集作为训练数据集加载。
+
+```
+import numpy
+from keras.datasets import imdb
+from matplotlib import pyplot
+# load the dataset
+(X_train, y_train), (X_test, y_test) = imdb.load_data()
+X = numpy.concatenate((X_train, X_test), axis=0)
+y = numpy.concatenate((y_train, y_test), axis=0)
+```
+
+接下来，我们可以显示训练数据集的形状。
+
+```
+# summarize size
+print("Training data: ")
+print(X.shape)
+print(y.shape)
+```
+
+运行此代码段，我们可以看到有 50,000 条记录。
+
+```
+Training data:
+(50000,)
+(50000,)
+```
+
+我们还可以打印唯一的类值。
+
+```
+# Summarize number of classes
+print("Classes: ")
+print(numpy.unique(y))
+```
+
+我们可以看到，这是一个二元分类问题，在评论中有好的和坏的情绪。
+
+```
+Classes:
+[0 1]
+```
+
+接下来，我们可以了解数据集中唯一单词的总数。
+
+```
+# Summarize number of words
+print("Number of words: ")
+print(len(numpy.unique(numpy.hstack(X))))
+```
+
+有趣的是，我们可以看到整个数据集中只有不到 100,000 个单词。
+
+```
+Number of words:
+88585
+```
+
+最后，我们可以了解平均审核长度。
+
+```
+# Summarize review length
+print("Review length: ")
+result = [len(x) for x in X]
+print("Mean %.2f words (%f)" % (numpy.mean(result), numpy.std(result)))
+# plot review length
+pyplot.boxplot(result)
+pyplot.show()
+```
+
+我们可以看到，平均评论不到 300 字，标准差超过 200 字。
+
+```
+Review length:
+Mean 234.76 words (172.911495)
+```
+
+我们可以看到一个指数分布的盒子和胡须图，我们可以看到一个指数分布，我们可以覆盖分布的质量，剪切长度为 400 到 500 字。
+
+![Review Length in Words for IMDB Dataset](img/f73add12895695350fadc1995b8d77e9.jpg)
+
+查看 IMDB 数据集的单词长度
+
+## Word 嵌入
+
+自然语言处理领域的最新突破称为[字嵌入](https://en.wikipedia.org/wiki/Word_embedding)。
+
+这是一种在高维空间中将单词编码为实值向量的技术，其中单词之间的意义相似性转换为向量空间中的接近度。
+
+离散词被映射到连续数的向量。当使用神经网络处理自然语言问题时这很有用，深度学习模型我们需要数字作为输入。
+
+Keras 提供了一种方便的方法，可以将单词的正整数表示转换为[嵌入层](http://keras.io/layers/embeddings/)的单词嵌入。
+
+该层采用定义映射的参数，包括也称为词汇量大小的预期词的最大数量（例如，将被视为整数的最大整数值）。该图层还允许您为每个单词向量指定维度，称为输出维度。
+
+我们想为 IMDB 数据集使用单词嵌入表示。
+
+假设我们只对数据集中前 5,000 个最常用的单词感兴趣。因此我们的词汇量将为 5,000。我们可以选择使用 32 维向量来表示每个单词。最后，我们可以选择将最大审核长度限制为 500 字，将评论截断时间缩短，并将填充评论缩短为 0 值。
+
+我们将加载 IMDB 数据集，如下所示：
+
+```
+imdb.load_data(nb_words=5000)
+```
+
+然后，我们将使用 Keras 实用程序使用 sequence.pad_sequences（）函数将数据集截断或填充到每个观察的长度 500。
+
+```
+X_train = sequence.pad_sequences(X_train, maxlen=500)
+X_test = sequence.pad_sequences(X_test, maxlen=500)
+```
+
+最后，稍后，我们模型的第一层将是使用 Embedding 类创建的单词嵌入层，如下所示：
+
+```
+Embedding(5000, 32, input_length=500)
+```
+
+对于给定的复习训练或整数格式的测试模式，该第一层的输出将是大小为 32×500 的矩阵。
+
+既然我们知道如何在 Keras 中加载 IMDB 数据集以及如何为它使用单词嵌入表示，那么让我们开发并评估一些模型。
+
+## 用于 IMDB 数据集的简单多层感知器模型
+
+我们可以从开发一个具有单个隐藏层的简单多层感知器模型开始。
+
+嵌入表示这个词是一个真正的创新，我们将通过一个相对简单的神经网络展示 2011 年被认为是世界级的结果。
+
+让我们首先导入此模型所需的类和函数，并将随机数生成器初始化为常量值，以确保我们可以轻松地重现结果。
+
+```
+# MLP for the IMDB problem
+import numpy
+from keras.datasets import imdb
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import Flatten
+from keras.layers.embeddings import Embedding
+from keras.preprocessing import sequence
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+```
+
+接下来，我们将加载 IMDB 数据集。我们将简化数据集，正如单词嵌入一节中所讨论的那样。只会加载前 5,000 个单词。
+
+我们还将使用 50％/ 50％的数据集拆分进行培训和测试。这是一种很好的标准拆分方法。
+
+```
+# load the dataset but only keep the top n words, zero the rest
+top_words = 5000
+(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
+```
+
+我们将以 500 字的方式绑定评论，截断更长的评论和零填充更短的评论。
+
+```
+max_words = 500
+X_train = sequence.pad_sequences(X_train, maxlen=max_words)
+X_test = sequence.pad_sequences(X_test, maxlen=max_words)
+```
+
+现在我们可以创建我们的模型。我们将使用嵌入层作为输入层，将词汇表设置为 5,000，将字矢量大小设置为 32 维，将 input_length 设置为 500.第一层的输出将是 32×500 大小的矩阵，如上一节所述。
+
+我们将嵌入层输出展平为一维，然后使用一个 250 单位的密集隐藏层和整流器激活功能。输出层有一个神经元，并将使用 sigmoid 激活输出 0 和 1 的值作为预测。
+
+该模型使用对数损失，并使用有效的 ADAM 优化程序进行优化。
+
+```
+# create the model
+model = Sequential()
+model.add(Embedding(top_words, 32, input_length=max_words))
+model.add(Flatten())
+model.add(Dense(250, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+print(model.summary())
+```
+
+我们可以适应模型并在训练时使用测试集作为验证。这个模型很快就会过度使用，因此我们将使用很少的训练时期，在这种情况下只需 2 个。
+
+有很多数据，所以我们将使用 128 的批量大小。在训练模型后，我们评估其在测试数据集上的准确性。
+
+```
+# Fit the model
+model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=2, batch_size=128, verbose=2)
+# Final evaluation of the model
+scores = model.evaluate(X_test, y_test, verbose=0)
+print("Accuracy: %.2f%%" % (scores[1]*100))
+```
+
+运行此示例适合模型并总结估计的性能。我们可以看到，这个非常简单的模型获得了近 86.94％的分数，这是在原始论文的附近，只需很少的努力。
+
+```
+Train on 25000 samples, validate on 25000 samples
+Epoch 1/2
+39s - loss: 0.5160 - acc: 0.7040 - val_loss: 0.2982 - val_acc: 0.8716
+Epoch 2/2
+37s - loss: 0.1897 - acc: 0.9266 - val_loss: 0.3143 - val_acc: 0.8694
+Accuracy: 86.94%
+```
+
+我确信如果我们训练这个网络，我们可以做得更好，也许使用更大的嵌入并添加更多的隐藏层。让我们尝试不同的网络类型。
+
+## IMDB 数据集的一维卷积神经网络模型
+
+设计卷积神经网络以尊重图像数据中的空间结构，同时对场景中学习对象的位置和方向具有鲁棒性。
+
+该相同原理可用于序列，例如电影评论中的一维单词序列。使 CNN 模型对于学习识别图像中的对象具有吸引力的相同属性可以帮助学习单词段落中的结构，即对于特征的特定位置的技术不变性。
+
+Keras 分别支持 Conv1D 和 MaxPooling1D 类的一维卷积和池化。
+
+再次，让我们导入此示例所需的类和函数，并将随机数生成器初始化为常量值，以便我们可以轻松地重现结果。
+
+```
+# CNN for the IMDB problem
+import numpy
+from keras.datasets import imdb
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import Flatten
+from keras.layers.convolutional import Conv1D
+from keras.layers.convolutional import MaxPooling1D
+from keras.layers.embeddings import Embedding
+from keras.preprocessing import sequence
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+```
+
+我们也可以像以前一样加载和准备我们的 IMDB 数据集。
+
+```
+# load the dataset but only keep the top n words, zero the rest
+top_words = 5000
+(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
+# pad dataset to a maximum review length in words
+max_words = 500
+X_train = sequence.pad_sequences(X_train, maxlen=max_words)
+X_test = sequence.pad_sequences(X_test, maxlen=max_words)
+```
+
+我们现在可以定义我们的卷积神经网络模型。这次，在嵌入输入层之后，我们插入一个 Conv1D 层。该卷积层具有 32 个特征映射，并且一次读取嵌入的单词表示 3 个向量元素的嵌入单词嵌入。
+
+卷积层之后是 1D max pooling layer，其长度和步幅为 2，使卷积层的特征映射的大小减半。网络的其余部分与上面的神经网络相同。
+
+```
+# create the model
+model = Sequential()
+model.add(Embedding(top_words, 32, input_length=max_words))
+model.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu'))
+model.add(MaxPooling1D(pool_size=2))
+model.add(Flatten())
+model.add(Dense(250, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+print(model.summary())
+```
+
+我们也像以前一样适应网络。
+
+```
+# Fit the model
+model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=2, batch_size=128, verbose=2)
+# Final evaluation of the model
+scores = model.evaluate(X_test, y_test, verbose=0)
+print("Accuracy: %.2f%%" % (scores[1]*100))
+```
+
+运行该示例，我们首先会看到网络结构的摘要。我们可以看到我们的卷积层保留了 32 维输入的嵌入输入层的维度，最多 500 个字。池化层通过将其减半来压缩该表示。
+
+运行该示例对上述神经网络模型提供了一个小但令人欢迎的改进，准确率接近 87.79％。
+
+```
+Train on 25000 samples, validate on 25000 samples
+Epoch 1/2
+38s - loss: 0.4451 - acc: 0.7640 - val_loss: 0.3107 - val_acc: 0.8660
+Epoch 2/2
+39s - loss: 0.2373 - acc: 0.9064 - val_loss: 0.2909 - val_acc: 0.8779
+Accuracy: 87.79%
+```
+
+同样，存在很多进一步优化的机会，例如使用更深和/或更大的卷积层。一个有趣的想法是将最大池化层设置为使用 500 的输入长度。这会将每个要素图压缩为单个 32 长度向量，并可以提高性能。
+
+## 摘要
+
+在这篇文章中，您发现了用于自然语言处理的 IMDB 情绪分析数据集。
+
+您学习了如何为情绪分析开发深度学习模型，包括：
+
+*   如何加载和查看 Keras 中的 IMDB 数据集。
+*   如何开发一个用于情感分析的大型神经网络模型。
+*   如何开发一种用于情感分析的一维卷积神经网络模型。
+
+您对情绪分析或此帖有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/regression-tutorial-keras-deep-learning-library-python.md b/docs/dl-keras/regression-tutorial-keras-deep-learning-library-python.md
new file mode 100644
index 0000000000000000000000000000000000000000..06f12fdb0c63b610ccd9740841ddc0d63c60ec64
--- /dev/null
+++ b/docs/dl-keras/regression-tutorial-keras-deep-learning-library-python.md
@@ -0,0 +1,258 @@
+# 使用 Python 中的 Keras 深度学习库进行回归教程
+
+> 原文： [https://machinelearningmastery.com/regression-tutorial-keras-deep-learning-library-python/](https://machinelearningmastery.com/regression-tutorial-keras-deep-learning-library-python/)
+
+Keras 是一个深度学习库，包含高效的数字库 Theano 和 TensorFlow。
+
+在这篇文章中，您将了解如何使用 Keras 开发和评估神经网络模型以获得回归问题。
+
+完成本分步教程后，您将了解：
+
+*   如何加载 CSV 数据集并使其可供 Keras 使用。
+*   如何使用 Keras 创建一个回归问题的神经网络模型。
+*   如何使用 scras-learn 与 Keras 一起使用交叉验证来评估模型。
+*   如何进行数据准备以提高 Keras 模型的技能。
+*   如何使用 Keras 调整模型的网络拓扑。
+
+让我们开始吧。
+
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+*   **更新 Mar / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。
+*   **Update Apr / 2018** ：将 nb_epoch 参数更改为 epochs。
+
+![Regression Tutorial with Keras Deep Learning Library in Python](img/4ae1e83ece36ea618e1ec2f6cbbbeb1f.jpg)
+
+使用 Python 中的 Keras 深度学习库的回归教程
+[Salim Fadhley](https://www.flickr.com/photos/salimfadhley/130295135/) 的照片，保留一些权利。
+
+## 1.问题描述
+
+我们将在本教程中看到的问题是[波士顿房价数据集](https://archive.ics.uci.edu/ml/datasets/Housing)。
+
+您可以下载此数据集并将其保存到当前工作中，直接使用文件名 _housing.csv_ （更新：[从此处下载数据](https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.data)）。
+
+该数据集描述了波士顿郊区房屋的 13 个数字属性，并涉及以数千美元模拟这些郊区房屋的价格。因此，这是回归预测建模问题。输入属性包括犯罪率，非经营业务占地比例，化学品浓度等。
+
+这是机器学习中经过深入研究的问题。使用起来很方便，因为所有输入和输出属性都是数字的，并且有 506 个实例可供使用。
+
+使用均方误差（MSE）评估的模型的合理性能约为 20 平方千美元（如果取平方根则为 4,500 美元）。这是一个很好的目标，旨在与我们的神经网络模型。
+
+## 2.开发基线神经网络模型
+
+在本节中，我们将为回归问题创建基线神经网络模型。
+
+让我们从包含本教程所需的所有函数和对象开始。
+
+```
+import numpy
+import pandas
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasRegressor
+from sklearn.model_selection import cross_val_score
+from sklearn.model_selection import KFold
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import Pipeline
+```
+
+我们现在可以从本地目录中的文件加载数据集。
+
+事实上，数据集在 UCI 机器学习库中不是 CSV 格式，而是用空格分隔属性。我们可以使用 pandas 库轻松加载它。然后我们可以分割输入（X）和输出（Y）属性，以便使用 Keras 和 scikit-learn 更容易建模。
+
+```
+# load dataset
+dataframe = pandas.read_csv("housing.csv", delim_whitespace=True, header=None)
+dataset = dataframe.values
+# split into input (X) and output (Y) variables
+X = dataset[:,0:13]
+Y = dataset[:,13]
+```
+
+我们可以使用 Keras 库提供的方便的包装器对象创建 Keras 模型并使用 scikit-learn 来评估它们。这是可取的，因为 scikit-learn 在评估模型方面表现优异，并且允许我们使用强大的数据准备和模型评估方案，只需很少的代码。
+
+Keras 包装器需要一个函数作为参数。我们必须定义的这个函数负责创建要评估的神经网络模型。
+
+下面我们定义用于创建要评估的基线模型的函数。它是一个简单的模型，它有一个完全连接的隐藏层，与输入属性具有相同数量的神经元（13）。网络使用良好的实践，例如隐藏层的整流器激活功能。没有激活函数用于输出层，因为它是回归问题，我们有兴趣直接预测数值而不进行变换。
+
+使用有效的 ADAM 优化算法并且优化均方误差损失函数。这将与我们用于评估模型性能的指标相同。这是一个理想的指标，因为通过取平方根给出了一个误差值，我们可以在问题的背景下直接理解（数千美元）。
+
+```
+# define base model
+def baseline_model():
+	# create model
+	model = Sequential()
+	model.add(Dense(13, input_dim=13, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(1, kernel_initializer='normal'))
+	# Compile model
+	model.compile(loss='mean_squared_error', optimizer='adam')
+	return model
+```
+
+用于 scikit-learn 作为回归估计器的 Keras 包装器对象称为 KerasRegressor。我们创建一个实例并将其传递给函数的名称以创建神经网络模型以及一些参数以便稍后传递给模型的 fit（）函数，例如时期数和批量大小。这两个都设置为合理的默认值。
+
+我们还使用常量随机种子初始化随机数生成器，我们将为本教程中评估的每个模型重复该过程。这是为了确保我们一致地比较模型。
+
+```
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# evaluate model with standardized dataset
+estimator = KerasRegressor(build_fn=baseline_model, epochs=100, batch_size=5, verbose=0)
+```
+
+最后一步是评估此基线模型。我们将使用 10 倍交叉验证来评估模型。
+
+```
+kfold = KFold(n_splits=10, random_state=seed)
+results = cross_val_score(estimator, X, Y, cv=kfold)
+print("Results: %.2f (%.2f) MSE" % (results.mean(), results.std()))
+```
+
+运行此代码可以估算出模型在看不见的数据问题上的表现。结果报告了均方误差，包括交叉验证评估的所有 10 倍的平均值和标准偏差（平均方差）。
+
+```
+Baseline: 31.64 (26.82) MSE
+```
+
+## 3.建模标准化数据集
+
+波士顿房价数据集的一个重要问题是输入属性的尺度各不相同，因为它们测量的数量不同。
+
+在使用神经网络模型对数据进行建模之前准备数据几乎总是好的做法。
+
+继续上述基线模型，我们可以使用输入数据集的标准化版本重新评估相同的模型。
+
+我们可以使用 scikit-learn 的 [Pipeline](http://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html) 框架在模型评估过程中，在交叉验证的每个折叠内执行标准化。这确保了每个测试集交叉验证折叠中没有数据泄漏到训练数据中。
+
+下面的代码创建了一个 scikit-learn Pipeline，它首先标准化数据集，然后创建和评估基线神经网络模型。
+
+```
+# evaluate model with standardized dataset
+numpy.random.seed(seed)
+estimators = []
+estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasRegressor(build_fn=baseline_model, epochs=50, batch_size=5, verbose=0)))
+pipeline = Pipeline(estimators)
+kfold = KFold(n_splits=10, random_state=seed)
+results = cross_val_score(pipeline, X, Y, cv=kfold)
+print("Standardized: %.2f (%.2f) MSE" % (results.mean(), results.std()))
+```
+
+运行该示例可提供比基线模型更高的性能，而无需标准化数据，从而丢弃错误。
+
+```
+Standardized: 29.54 (27.87) MSE
+```
+
+此部分的进一步扩展将类似地对输出变量应用重新缩放，例如将其归一化到 0-1 的范围，并在输出层上使用 Sigmoid 或类似的激活函数，以将输出预测缩小到相同的范围。
+
+## 4.调整神经网络拓扑
+
+有许多问题可以针对神经网络模型进行优化。
+
+也许最大的杠杆点是网络本身的结构，包括层数和每层神经元的数量。
+
+在本节中，我们将评估另外两种网络拓扑，以进一步提高模型的性能。我们将研究更深入和更广泛的网络拓扑。
+
+### 4.1。评估更深入的网络拓扑
+
+提高神经网络性能的一种方法是添加更多层。这可能允许模型提取并重新组合数据中嵌入的高阶特征。
+
+在本节中，我们将评估向模型添加一个隐藏层的效果。这就像定义一个新函数一样简单，这个函数将创建这个更深层次的模型，从上面的基线模型中复制出来。然后我们可以在第一个隐藏层之后插入一个新行。在这种情况下，神经元的数量约为一半。
+
+```
+# define the model
+def larger_model():
+	# create model
+	model = Sequential()
+	model.add(Dense(13, input_dim=13, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(6, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(1, kernel_initializer='normal'))
+	# Compile model
+	model.compile(loss='mean_squared_error', optimizer='adam')
+	return model
+```
+
+我们的网络拓扑现在看起来像：
+
+```
+13 inputs -> [13 -> 6] -> 1 output
+```
+
+我们可以采用与上述相同的方式评估此网络拓扑，同时还使用上面显示的数据集的标准化来提高性能。
+
+```
+numpy.random.seed(seed)
+estimators = []
+estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasRegressor(build_fn=larger_model, epochs=50, batch_size=5, verbose=0)))
+pipeline = Pipeline(estimators)
+kfold = KFold(n_splits=10, random_state=seed)
+results = cross_val_score(pipeline, X, Y, cv=kfold)
+print("Larger: %.2f (%.2f) MSE" % (results.mean(), results.std()))
+```
+
+运行此模型确实表明性能从 28 降至 24,000 平方美元进一步改善。
+
+```
+Larger: 22.83 (25.33) MSE
+```
+
+### 4.2。评估更广泛的网络拓扑
+
+增加模型的表示能力的另一种方法是创建更广泛的网络。
+
+在本节中，我们将评估保持浅层网络架构的效果，并使一个隐藏层中的神经元数量几乎翻倍。
+
+同样，我们需要做的就是定义一个创建神经网络模型的新函数。在这里，与 13 到 20 的基线模型相比，我们增加了隐藏层中神经元的数量。
+
+```
+# define wider model
+def wider_model():
+	# create model
+	model = Sequential()
+	model.add(Dense(20, input_dim=13, kernel_initializer='normal', activation='relu'))
+	model.add(Dense(1, kernel_initializer='normal'))
+	# Compile model
+	model.compile(loss='mean_squared_error', optimizer='adam')
+	return model
+```
+
+我们的网络拓扑现在看起来像：
+
+```
+13 inputs -> [20] -> 1 output
+```
+
+我们可以使用与上面相同的方案评估更广泛的网络拓扑：
+
+```
+numpy.random.seed(seed)
+estimators = []
+estimators.append(('standardize', StandardScaler()))
+estimators.append(('mlp', KerasRegressor(build_fn=wider_model, epochs=100, batch_size=5, verbose=0)))
+pipeline = Pipeline(estimators)
+kfold = KFold(n_splits=10, random_state=seed)
+results = cross_val_score(pipeline, X, Y, cv=kfold)
+print("Wider: %.2f (%.2f) MSE" % (results.mean(), results.std()))
+```
+
+建立模型的确看到误差进一步下降到大约 2.1 万平方美元。对于这个问题，这不是一个糟糕的结果。
+
+```
+Wider: 21.64 (23.75) MSE
+```
+
+很难想象更广泛的网络在这个问题上会胜过更深层次的网络。结果证明了在开发神经网络模型时经验测试的重要性。
+
+## 摘要
+
+在这篇文章中，您发现了用于建模回归问题的 Keras 深度学习库。
+
+通过本教程，您学习了如何开发和评估神经网络模型，包括：
+
+*   如何加载数据和开发基线模型。
+*   如何使用标准化等数据准备技术提升性能。
+*   如何针对问题设计和评估具有不同变化拓扑的网络。
+
+您对 Keras 深度学习库或这篇文章有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/reproducible-results-neural-networks-keras.md b/docs/dl-keras/reproducible-results-neural-networks-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..ec762b2d7d39026441c56de356a0bb6db8a65cb5
--- /dev/null
+++ b/docs/dl-keras/reproducible-results-neural-networks-keras.md
@@ -0,0 +1,348 @@
+# 如何使用 Keras 获得可重现的结果
+
+> 原文： [https://machinelearningmastery.com/reproducible-results-neural-networks-keras/](https://machinelearningmastery.com/reproducible-results-neural-networks-keras/)
+
+神经网络算法是随机的。
+
+这意味着它们利用随机性，例如初始化为随机权重，反过来，在相同数据上训练的相同网络可以产生不同的结果。
+
+这可能会让初学者感到困惑，因为算法似乎不稳定，实际上它们是设计的。随机初始化允许网络学习正在学习的函数的良好近似。
+
+然而，有时候每次在相同的数据上训练相同的网络时，您需要完全相同的结果。比如教程，或者可能是操作上的。
+
+在本教程中，您将了解如何为随机数生成器设定种子，以便每次都可以从同一网络中获取相同数据的相同结果。
+
+让我们开始吧。
+
+![How to Get Reproducible Results from Neural Networks with Keras](img/7c82a23fe9ca5ce16ae054ff7260f3f0.jpg)
+
+如何从 Keras 的神经网络获得可重现的结果
+照片由 [Samuel John](https://www.flickr.com/photos/samueljohn/6129216625/) ，保留一些权利。
+
+## 教程概述
+
+本教程分为 6 个部分。他们是：
+
+1.  为什么每次都会得到不同的结果？
+2.  证明不同的结果
+3.  解决方案
+4.  种子随机数与 Theano 后端
+5.  种子随机数与 TensorFlow 后端
+6.  如果我仍然得到不同的结果怎么办？
+
+### 环境
+
+本教程假定您已安装 Python SciPy 环境。您可以在此示例中使用 Python 2 或 3。
+
+本教程假设您使用 TensorFlow（v1.1.0 +）或 Theano（v0.9 +）后端安装了 Keras（v2.0.3 +）。
+
+本教程还假设您安装了 scikit-learn，Pandas，NumPy 和 Matplotlib。
+
+如果您在设置 Python 环境时需要帮助，请参阅以下帖子：
+
+*   [如何使用 Anaconda 设置用于机器学习和深度学习的 Python 环境](http://machinelearningmastery.com/setup-python-environment-machine-learning-deep-learning-anaconda/)
+
+## 为什么每次都会得到不同的结果？
+
+这是我从初学者到神经网络和深度学习领域的常见问题。
+
+这种误解也可能以下列问题的形式出现：
+
+*   _ 如何获得稳定的结果？_
+*   _ 如何获得可重复的结果？_
+*   _ 我应该使用什么种子？_
+
+神经网络通过设计使用随机性，以确保它们有效地学习与问题近似的函数。使用随机性是因为这类机器学习算法比没有它更好。
+
+神经网络中最常用的随机形式是网络权重的随机初始化。虽然随机性可用于其他领域，但这里只是一个简短的列表：
+
+*   初始化中的随机性，例如权重。
+*   正则化中的随机性，例如辍学。
+*   图层中的随机性，例如单词嵌入。
+*   优化中的随机性，例如随机优化。
+
+这些随机性来源等等意味着当您在完全相同的数据上运行完全相同的神经网络算法时，您可以保证得到不同的结果。
+
+有关随机算法背后原因的更多信息，请参阅帖子：
+
+*   [在机器学习中拥抱随机性](http://machinelearningmastery.com/randomness-in-machine-learning/)
+
+## 证明不同的结果
+
+我们可以用一个小例子来证明神经网络的随机性。
+
+在本节中，我们将开发一个多层感知器模型，以学习从 0.0 到 0.9 增加 0.1 的短序列。给定 0.0，模型必须预测 0.1;给定 0.1，模型必须输出 0.2;等等。
+
+下面列出了准备数据的代码。
+
+```
+# create sequence
+length = 10
+sequence = [i/float(length) for i in range(length)]
+# create X/y pairs
+df = DataFrame(sequence)
+df = concat([df.shift(1), df], axis=1)
+df.dropna(inplace=True)
+# convert to MLPfriendly format
+values = df.values
+X, y = values[:,0], values[:,1]
+```
+
+我们将使用一个输入的网络，隐藏层中的 10 个神经元和 1 个输出。网络将使用均方误差丢失函数，并将使用有效的 ADAM 算法进行训练。
+
+网络需要大约 1000 个时代来有效地解决这个问题，但我们只会训练它 100 个时代。这是为了确保我们得到一个在进行预测时出错的模型。
+
+在训练网络之后，我们将对数据集进行预测并打印均方误差。
+
+网络代码如下所示。
+
+```
+# design network
+model = Sequential()
+model.add(Dense(10, input_dim=1))
+model.add(Dense(1))
+model.compile(loss='mean_squared_error', optimizer='adam')
+# fit network
+model.fit(X, y, epochs=100, batch_size=len(X), verbose=0)
+# forecast
+yhat = model.predict(X, verbose=0)
+print(mean_squared_error(y, yhat[:,0]))
+```
+
+在该示例中，我们将创建网络 10 次并打印 10 个不同的网络分数。
+
+完整的代码清单如下。
+
+```
+from pandas import DataFrame
+from pandas import concat
+from keras.models import Sequential
+from keras.layers import Dense
+from sklearn.metrics import mean_squared_error
+
+# fit MLP to dataset and print error
+def fit_model(X, y):
+	# design network
+	model = Sequential()
+	model.add(Dense(10, input_dim=1))
+	model.add(Dense(1))
+	model.compile(loss='mean_squared_error', optimizer='adam')
+	# fit network
+	model.fit(X, y, epochs=100, batch_size=len(X), verbose=0)
+	# forecast
+	yhat = model.predict(X, verbose=0)
+	print(mean_squared_error(y, yhat[:,0]))
+
+# create sequence
+length = 10
+sequence = [i/float(length) for i in range(length)]
+# create X/y pairs
+df = DataFrame(sequence)
+df = concat([df.shift(1), df], axis=1)
+df.dropna(inplace=True)
+# convert to MLP friendly format
+values = df.values
+X, y = values[:,0], values[:,1]
+# repeat experiment
+repeats = 10
+for _ in range(repeats):
+	fit_model(X, y)
+```
+
+运行该示例将在每行中打印不同的精度。
+
+您的具体结果会有所不同。下面提供了一个示例输出。
+
+```
+0.0282584265697
+0.0457025913022
+0.145698137198
+0.0873461454407
+0.0309397604521
+0.046649185173
+0.0958450337178
+0.0130660263779
+0.00625176026631
+0.00296055161492
+```
+
+## 解决方案
+
+这是两个主要的解决方案。
+
+### 解决方案＃1：重复您的实验
+
+解决此问题的传统和实用方法是多次运行您的网络（30+）并使用统计数据来总结模型的性能，并将您的模型与其他模型进行比较。
+
+我强烈推荐这种方法，但由于某些型号的培训时间很长，因此并不总是可行。
+
+有关此方法的更多信息，请参阅：
+
+*   [如何评估深度学习模型的技巧](http://machinelearningmastery.com/evaluate-skill-deep-learning-models/)
+
+### 解决方案＃2：为随机数生成器播种
+
+或者，另一种解决方案是使用固定种子作为随机数发生器。
+
+使用伪随机数生成器生成随机数。随机数生成器是一种数学函数，它将生成一个长序列的数字，这些数字足够随机用于通用目的，例如机器学习算法。
+
+随机数生成器需要种子来启动进程，并且通常在大多数实现中使用当前时间（以毫秒为单位）作为默认值。这是为了确保每次运行代码时都会生成不同的随机数序列，默认情况下。
+
+也可以使用特定数字（例如“1”）指定此种子，以确保每次运行代码时都生成相同的随机数序列。
+
+只要每次运行代码时，特定的种子值都无关紧要。
+
+设置随机数生成器的具体方法因后端而异，我们将在 Theano 和 TensorFlow 中查看如何执行此操作。
+
+## 种子随机数与 Theano 后端
+
+通常，Keras 从 NumPy 随机数生成器获得随机源。
+
+在大多数情况下，Theano 后端也是如此。
+
+我们可以通过从随机模块调用 [seed（）函数](https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.seed.html)来播种 NumPy 随机数生成器，如下所示：
+
+```
+from numpy.random import seed
+seed(1)
+```
+
+导入和调用种子函数最好在代码文件的顶部完成。
+
+这是[最佳实践](https://github.com/fchollet/keras/issues/439)，因为即使在直接使用它们之前，当各种 Keras 或 Theano（或其他）库作为初始化的一部分导入时，可能会使用某些随机性。
+
+我们可以将两行添加到上面示例的顶部并运行两次。
+
+每次运行代码时都应该看到相同的均方误差值列表（可能由于不同机器上的精度而有一些微小的变化），如下所示：
+
+```
+0.169326527063
+2.75750621228e-05
+0.0183287291562
+1.93553737255e-07
+0.0549871087449
+0.0906326807824
+0.00337575114075
+0.00414857518259
+8.14587362008e-08
+0.0522927019639
+```
+
+您的结果应与我的匹配（忽略精确度的微小差异）。
+
+## 种子随机数与 TensorFlow 后端
+
+Keras 确实从 NumPy 随机数生成器获得随机源，因此无论您使用的是 Theano 还是 TensorFlow 后端，都必须播种。
+
+必须通过在任何其他导入或其他代码之前调用文件顶部的 [seed（）函数](https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.seed.html)来播种。
+
+```
+from numpy.random import seed
+seed(1)
+```
+
+此外，TensorFlow 还有自己的随机数生成器，必须通过在 NumPy 随机数生成器之后立即调用 [set_random_seed（）函数](https://www.tensorflow.org/api_docs/python/tf/set_random_seed)来播种，如下所示：
+
+```
+from tensorflow import set_random_seed
+set_random_seed(2)
+```
+
+为了清楚起见，代码文件的顶部必须在任何其他文件之前有以下 4 行;
+
+```
+from numpy.random import seed
+seed(1)
+from tensorflow import set_random_seed
+set_random_seed(2)
+```
+
+您可以为两种或不同的种子使用相同的种子。我不认为随机性来源进入不同的过程会产生很大的不同。
+
+将这 4 行添加到上面的示例将允许代码在每次运行时生成相同的结果。您应该看到与下面列出的相同的均方误差值（由于不同机器上的精度，可能会有一些微小的变化）：
+
+```
+0.224045112999
+0.00154879478823
+0.00387589994044
+0.0292376881968
+0.00945528404353
+0.013305765525
+0.0206255228201
+0.0359538356108
+0.00441943512128
+0.298706569397
+```
+
+您的结果应与我的匹配（忽略精确度的微小差异）。
+
+## 如果我仍然得到不同的结果怎么办？
+
+要重新迭代，最有效的报告结果和比较模型的方法是多次重复实验（30+）并使用汇总统计。
+
+如果无法做到这一点，您可以通过为代码使用的随机数生成器播种获得 100％可重复的结果。上述解决方案应涵盖大多数情况，但不是全部。
+
+如果您遵循上述说明并仍然在相同数据上获得相同算法的不同结果，该怎么办？
+
+您可能还有其他未考虑的随机性来源。
+
+### 来自第三方图书馆的随机性
+
+也许你的代码使用了一个额外的库，它使用了一个也必须种子的不同随机数生成器。
+
+尝试将代码切换回所需的最低要求（例如，一个数据样本，一个训练时期等）并仔细阅读 API 文档，以便缩小引入随机性的其他第三方库。
+
+### 使用 GPU 的随机性
+
+以上所有示例均假设代码在 CPU 上运行。
+
+当使用 GPU 训练模型时，后端可能被配置为使用复杂的 GPU 库堆栈，其中一些可能会引入他们自己或可能无法解释的随机源。
+
+例如，有一些证据表明，如果您在堆栈中使用 [Nvidia cuDNN](https://developer.nvidia.com/cudnn) ，则[可能会引入其他随机源](https://github.com/fchollet/keras/issues/2479#issuecomment-213987747)并阻止您的结果的完全重现性。
+
+### 来自复杂模型的随机性
+
+由于您的模型的复杂性和培训的平行性，您可能会得到不可重复的结果。
+
+这很可能是由后端库产生的效率引起的，也许是因为无法跨核心使用随机数序列。
+
+我自己没有看到这个，但看到一些 GitHub 问题和 StackOverflow 问题的迹象。
+
+您可以尝试降低模型的复杂性，看看这是否会影响结果的可重复性，只是为了缩小原因。
+
+我建议您阅读后端如何使用随机性，看看是否有任何选项可供您使用。
+
+在 Theano，请参阅：
+
+*   [随机数](http://deeplearning.net/software/theano/sandbox/randomnumbers.html)
+*   [友好的随机数](http://deeplearning.net/software/theano/library/tensor/shared_randomstreams.html)
+*   [使用随机数](http://deeplearning.net/software/theano/tutorial/examples.html#using-random-numbers)
+
+在 TensorFlow 中，请参阅：
+
+*   [常数，序列和随机值](https://www.tensorflow.org/api_guides/python/constant_op)
+*   [tf.set_random_seed](https://www.tensorflow.org/api_docs/python/tf/set_random_seed)
+
+此外，请考虑搜索具有相同问题的其他人以获得进一步的洞察力。一些很棒的搜索地点包括：
+
+*   [GrasHub 上的 Keras 问题](https://github.com/fchollet/keras/issues)
+*   [The On 对 Github 的问题](https://github.com/Theano/Theano/issues)
+*   [GitHub 上的 TensorFlow 问题](https://github.com/tensorflow/tensorflow/issues)
+*   [StackOverflow 通用编程 Q＆amp; A](http://stackoverflow.com/)
+*   [CrossValidated 机器学习 Q＆amp; A](https://stats.stackexchange.com/)
+
+## 摘要
+
+在本教程中，您了解了如何在 Keras 中获得可重现的神经网络模型结果。
+
+具体来说，你学到了：
+
+*   神经网络在设计上是随机的，并且可以固定随机源以使结果可重复。
+*   您可以在 NumPy 和 TensorFlow 中播种随机数生成器，这将使大多数 Keras 代码 100％可重现。
+*   在某些情况下，存在其他随机源，并且您有关于如何寻找它们的想法，也许也可以修复它们。
+
+本教程有帮助吗？
+在评论中分享您的经验。
+
+您是否仍然可以通过 Keras 获得无法重现的结果？
+分享您的经验;也许这里的其他人可以帮忙。
\ No newline at end of file
diff --git a/docs/dl-keras/run-deep-learning-experiments-linux-server.md b/docs/dl-keras/run-deep-learning-experiments-linux-server.md
new file mode 100644
index 0000000000000000000000000000000000000000..aeae1575c8c9d06ea0035593e5b073d5978c43e4
--- /dev/null
+++ b/docs/dl-keras/run-deep-learning-experiments-linux-server.md
@@ -0,0 +1,119 @@
+# 如何在 Linux 服务器上运行深度学习实验
+
+> 原文： [https://machinelearningmastery.com/run-deep-learning-experiments-linux-server/](https://machinelearningmastery.com/run-deep-learning-experiments-linux-server/)
+
+编写代码后，必须在具有大量 RAM，CPU 和 GPU 资源的大型计算机上运行深度学习实验，通常是云中的 Linux 服务器。
+
+最近，我被问到这个问题：
+
+> “你如何进行深度学习实验？”
+
+这是一个我喜欢回答的好问题。
+
+在这篇文章中，您将发现我用于在 Linux 上运行深度学习实验的方法，命令和脚本。
+
+阅读这篇文章后，你会知道：
+
+*   如何设计建模实验以将模型保存到文件。
+*   如何运行单个 Python 实验脚本。
+*   如何从 shell 脚本顺序运行多个 Python 实验。
+
+让我们开始吧。
+
+![How to Run Deep Learning Experiments on a Linux Server](img/5b3d95a2ac65cd8206b3a11433959297.jpg)
+
+如何在 Linux 服务器上运行深度学习实验
+[Patrik Nygren](https://www.flickr.com/photos/lattefarsan/10538489333/) 的照片，保留一些权利。
+
+## 1\. Linux 服务器
+
+我在工作站上编写了所有建模代码，并在远程 Linux 服务器上运行所有代码。
+
+目前，我的偏好是在 EC2 上使用[亚马逊深度学习 AMI](https://aws.amazon.com/marketplace/pp/B01M0AXXQB) 。有关为自己的实验设置此服务器的帮助，请参阅帖子：
+
+*   [如何使用亚马逊网络服务上的 Keras 开发和评估大型深度学习模型](https://machinelearningmastery.com/develop-evaluate-large-deep-learning-models-keras-amazon-web-services/)
+
+## 2.建模代码
+
+我编写代码，以便每个 python 文件有一个实验。
+
+大多数情况下，我正在处理大型数据，如图像字幕，文本摘要和机器翻译。
+
+每个实验都适合模型，并将整个模型或权重保存到 [HDF5 文件](http://www.h5py.org/)，以便以后重复使用。
+
+有关将模型保存到文件的更多信息，请参阅以下帖子：
+
+*   [保存并加载您的 Keras 深度学习模型](https://machinelearningmastery.com/save-load-keras-deep-learning-models/)
+*   [如何在 Keras 检查深度学习模型](https://machinelearningmastery.com/check-point-deep-learning-models-keras/)
+
+我尝试准备一套实验（通常是 10 个或更多）以便在一个批次中运行。我还尝试将数据准备步骤分离为首先运行的脚本，并创建可随时加载和使用的训练数据集的 pickle 版本。
+
+## 3.运行实验
+
+每个实验可能会在训练期间输出一些诊断信息，因此，每个脚本的输出都会重定向到特定于实验的日志文件。如果事情失败，我也会重定向标准错误。
+
+在运行时，Python 解释器可能不会经常刷新输出，尤其是在系统负载不足的情况下。我们可以使用 Python 解释器上的 _-u_ 标志强制将输出刷新到日志中。
+
+运行单个脚本（ _myscript.py_ ）如下所示：
+
+```
+python -u myscript.py >myscript.py.log 2>&1
+```
+
+我可以创建一个“_ 模型”_ 和一个“_ 结果”_ 目录，并更新要保存到这些目录的模型文件和日志文件，以保持代码目录清晰。
+
+## 4.运行批处理实验
+
+每个 Python 脚本都按顺序运行。
+
+创建一个 shell 脚本，按顺序列出多个实验。例如：
+
+```
+#!/bin/sh
+
+# run experiments
+python -u myscript1.py >myscript1.py.log 2>&1
+python -u myscript2.py >myscript2.py.log 2>&1
+python -u myscript3.py >myscript3.py.log 2>&1
+python -u myscript4.py >myscript4.py.log 2>&1
+python -u myscript5.py >myscript5.py.log 2>&1
+```
+
+该文件将保存为“ _run.sh”_，与代码文件放在同一目录中并在服务器上运行。
+
+例如，如果所有代码和 run.sh 脚本都位于“ _ec2-user_ ”主目录的“ _experiments_ ”目录中，则脚本将按如下方式运行：
+
+```
+nohup /home/ec2-user/experiments/run.sh > /home/ec2-user/experiments/run.sh.log </dev/null 2>&1 &
+```
+
+该脚本作为后台进程运行，无法轻易中断。我还捕获了这个脚本的结果，以防万一。
+
+您可以在本文中了解有关在 Linux 上运行脚本的更多信息：
+
+*   [10 个亚马逊网络服务深度学习命令行方案](https://machinelearningmastery.com/command-line-recipes-deep-learning-amazon-web-services/)
+
+就是这样。
+
+## 进一步阅读
+
+如果您希望深入了解，本节将提供有关该主题的更多资源。
+
+*   [源代码深度学习 AMI（CUDA 8，亚马逊 Linux）](https://aws.amazon.com/marketplace/pp/B01M0AXXQB)
+*   [保存并加载您的 Keras 深度学习模型](https://machinelearningmastery.com/save-load-keras-deep-learning-models/)
+*   [如何在 Keras 检查深度学习模型](https://machinelearningmastery.com/check-point-deep-learning-models-keras/)
+*   [10 个亚马逊网络服务深度学习命令行方案](https://machinelearningmastery.com/command-line-recipes-deep-learning-amazon-web-services/)
+*   [如何使用亚马逊网络服务上的 Keras 开发和评估大型深度学习模型](https://machinelearningmastery.com/develop-evaluate-large-deep-learning-models-keras-amazon-web-services/)
+
+## 摘要
+
+在这篇文章中，您发现了我用于在 Linux 上运行深度学习实验的方法，命令和脚本。
+
+具体来说，你学到了：
+
+*   如何设计建模实验以将模型保存到文件。
+*   如何运行单个 Python 实验脚本。
+*   如何从 shell 脚本顺序运行多个 Python 实验。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/save-load-keras-deep-learning-models.md b/docs/dl-keras/save-load-keras-deep-learning-models.md
new file mode 100644
index 0000000000000000000000000000000000000000..29907ae1c1e17977278c81a50ee305fd580c708b
--- /dev/null
+++ b/docs/dl-keras/save-load-keras-deep-learning-models.md
@@ -0,0 +1,372 @@
+# 保存并加载您的 Keras 深度学习模型
+
+> 原文： [https://machinelearningmastery.com/save-load-keras-deep-learning-models/](https://machinelearningmastery.com/save-load-keras-deep-learning-models/)
+
+Keras 是一个简单而强大的 Python 库，用于深度学习。
+
+鉴于深度学习模型可能需要数小时，数天甚至数周才能进行训练，因此了解如何从磁盘保存和加载它们非常重要。
+
+在这篇文章中，您将了解如何将 Keras 模型保存到文件中并再次加载它们以进行预测。
+
+让我们开始吧。
+
+*   **2017 年 3 月更新**：添加了先安装 h5py 的说明。在每个示例中的最终打印语句中添加了缺少括号。
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+*   **更新 March / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。
+
+![Save and Load Your Keras Deep Learning Models](img/f7c8bf23f866c7d1a641e25ab2c1e6cd.jpg)
+
+保存并加载您的 Keras 深度学习模型
+照片由 [art_inthecity](https://www.flickr.com/photos/art_inthecity/6346545268/) 保留，保留一些权利。
+
+## 教程概述
+
+Keras 将保存模型架构和保存模型权重的问题分开。
+
+模型权重保存为 [HDF5 格式](http://www.h5py.org/)。这是一种网格格式，非常适合存储多维数字数组。
+
+可以使用两种不同的格式描述和保存模型结构：JSON 和 YAML。
+
+在这篇文章中，我们将看两个保存模型并将其加载到文件的示例：
+
+*   将模型保存为 JSON。
+*   将模型保存到 YAML。
+
+每个示例还将演示如何将模型权重保存并加载到 HDF5 格式的文件中。
+
+这些例子将使用在 Pima Indians 糖尿病二元分类数据集开始时训练的相同简单网络。这是一个包含所有数字数据的小型数据集，易于使用。您可以[下载此数据集](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)）。
+
+确认您安装了最新版本的 Keras（截至 2017 年 3 月的 v1.2.2）。
+
+注意：您可能需要先安装 _h5py_ ：
+
+```
+sudo pip install h5py
+```
+
+## 将您的神经网络模型保存为 JSON
+
+JSON 是一种用于分层描述数据的简单文件格式。
+
+Keras 提供了使用带有 _to_json（）_ 函数的 JSON 格式描述任何模型的功能。这可以保存到文件中，然后通过 _model_from_json（）_ 函数加载，该函数将根据 JSON 规范创建新模型。
+
+使用 _save_weights（）_ 函数直接从模型保存权重，然后使用对称 _load_weights（）_ 函数加载。
+
+以下示例训练和评估 Pima Indians 数据集上的简单模型。然后将模型转换为 JSON 格式并写入本地目录中的 model.json。网络权重写入本地目录中的 _model.h5_ 。
+
+从保存的文件加载模型和重量数据，并创建新模型。在加载模型使用之前编译它是很重要的。这样使用该模型进行的预测可以使用 Keras 后端的适当有效计算。
+
+以相同的方式评估模型，打印相同的评估分数。
+
+```
+# MLP for Pima Indians Dataset Serialize to JSON and HDF5
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.models import model_from_json
+import numpy
+import os
+# 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, 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
+model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
+# evaluate the model
+scores = model.evaluate(X, Y, verbose=0)
+print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
+
+# serialize model to JSON
+model_json = model.to_json()
+with open("model.json", "w") as json_file:
+    json_file.write(model_json)
+# serialize weights to HDF5
+model.save_weights("model.h5")
+print("Saved model to disk")
+
+# later...
+
+# load json and create model
+json_file = open('model.json', 'r')
+loaded_model_json = json_file.read()
+json_file.close()
+loaded_model = model_from_json(loaded_model_json)
+# load weights into new model
+loaded_model.load_weights("model.h5")
+print("Loaded model from disk")
+
+# evaluate loaded model on test data
+loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
+score = loaded_model.evaluate(X, Y, verbose=0)
+print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))
+```
+
+运行此示例提供下面的输出。
+
+```
+acc: 78.78%
+Saved model to disk
+Loaded model from disk
+acc: 78.78%
+```
+
+该模型的 JSON 格式如下所示：
+
+```
+{  
+   "keras_version":"2.0.2",
+   "backend":"theano",
+   "config":[  
+      {  
+         "config":{  
+            "dtype":"float32",
+            "bias_regularizer":null,
+            "activation":"relu",
+            "bias_constraint":null,
+            "use_bias":true,
+            "bias_initializer":{  
+               "config":{  
+
+               },
+               "class_name":"Zeros"
+            },
+            "kernel_regularizer":null,
+            "activity_regularizer":null,
+            "kernel_constraint":null,
+            "trainable":true,
+            "name":"dense_1",
+            "kernel_initializer":{  
+               "config":{  
+                  "maxval":0.05,
+                  "minval":-0.05,
+                  "seed":null
+               },
+               "class_name":"RandomUniform"
+            },
+            "batch_input_shape":[  
+               null,
+               8
+            ],
+            "units":12
+         },
+         "class_name":"Dense"
+      },
+      {  
+         "config":{  
+            "kernel_regularizer":null,
+            "bias_regularizer":null,
+            "activation":"relu",
+            "bias_constraint":null,
+            "use_bias":true,
+            "bias_initializer":{  
+               "config":{  
+
+               },
+               "class_name":"Zeros"
+            },
+            "activity_regularizer":null,
+            "kernel_constraint":null,
+            "trainable":true,
+            "name":"dense_2",
+            "kernel_initializer":{  
+               "config":{  
+                  "maxval":0.05,
+                  "minval":-0.05,
+                  "seed":null
+               },
+               "class_name":"RandomUniform"
+            },
+            "units":8
+         },
+         "class_name":"Dense"
+      },
+      {  
+         "config":{  
+            "kernel_regularizer":null,
+            "bias_regularizer":null,
+            "activation":"sigmoid",
+            "bias_constraint":null,
+            "use_bias":true,
+            "bias_initializer":{  
+               "config":{  
+
+               },
+               "class_name":"Zeros"
+            },
+            "activity_regularizer":null,
+            "kernel_constraint":null,
+            "trainable":true,
+            "name":"dense_3",
+            "kernel_initializer":{  
+               "config":{  
+                  "maxval":0.05,
+                  "minval":-0.05,
+                  "seed":null
+               },
+               "class_name":"RandomUniform"
+            },
+            "units":1
+         },
+         "class_name":"Dense"
+      }
+   ],
+   "class_name":"Sequential"
+}
+```
+
+## 将您的神经网络模型保存到 YAML
+
+此示例与上述 JSON 示例大致相同，只是 [YAML](https://en.wikipedia.org/wiki/YAML) 格式用于模型规范。
+
+使用 YAML 描述模型，保存到文件 model.yaml，然后通过 _model_from_yaml（）_ 函数加载到新模型中。权重的处理方式与上面 HDF5 格式相同，如 model.h5。
+
+```
+# MLP for Pima Indians Dataset serialize to YAML and HDF5
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.models import model_from_yaml
+import numpy
+import os
+# 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
+model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
+# evaluate the model
+scores = model.evaluate(X, Y, verbose=0)
+print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
+
+# serialize model to YAML
+model_yaml = model.to_yaml()
+with open("model.yaml", "w") as yaml_file:
+    yaml_file.write(model_yaml)
+# serialize weights to HDF5
+model.save_weights("model.h5")
+print("Saved model to disk")
+
+# later...
+
+# load YAML and create model
+yaml_file = open('model.yaml', 'r')
+loaded_model_yaml = yaml_file.read()
+yaml_file.close()
+loaded_model = model_from_yaml(loaded_model_yaml)
+# load weights into new model
+loaded_model.load_weights("model.h5")
+print("Loaded model from disk")
+
+# evaluate loaded model on test data
+loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
+score = loaded_model.evaluate(X, Y, verbose=0)
+print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))
+```
+
+运行该示例将显示以下输出：
+
+```
+acc: 78.78%
+Saved model to disk
+Loaded model from disk
+acc: 78.78%
+```
+
+以 YAML 格式描述的模型如下所示：
+
+```
+backend: theano
+class_name: Sequential
+config:
+- class_name: Dense
+  config:
+    activation: relu
+    activity_regularizer: null
+    batch_input_shape: !!python/tuple [null, 8]
+    bias_constraint: null
+    bias_initializer:
+      class_name: Zeros
+      config: {}
+    bias_regularizer: null
+    dtype: float32
+    kernel_constraint: null
+    kernel_initializer:
+      class_name: RandomUniform
+      config: {maxval: 0.05, minval: -0.05, seed: null}
+    kernel_regularizer: null
+    name: dense_1
+    trainable: true
+    units: 12
+    use_bias: true
+- class_name: Dense
+  config:
+    activation: relu
+    activity_regularizer: null
+    bias_constraint: null
+    bias_initializer:
+      class_name: Zeros
+      config: {}
+    bias_regularizer: null
+    kernel_constraint: null
+    kernel_initializer:
+      class_name: RandomUniform
+      config: {maxval: 0.05, minval: -0.05, seed: null}
+    kernel_regularizer: null
+    name: dense_2
+    trainable: true
+    units: 8
+    use_bias: true
+- class_name: Dense
+  config:
+    activation: sigmoid
+    activity_regularizer: null
+    bias_constraint: null
+    bias_initializer:
+      class_name: Zeros
+      config: {}
+    bias_regularizer: null
+    kernel_constraint: null
+    kernel_initializer:
+      class_name: RandomUniform
+      config: {maxval: 0.05, minval: -0.05, seed: null}
+    kernel_regularizer: null
+    name: dense_3
+    trainable: true
+    units: 1
+    use_bias: true
+keras_version: 2.0.2
+```
+
+## 进一步阅读
+
+*   [如何保存 Keras 型号？ Keras 文档中的](https://keras.io/getting-started/faq/#how-can-i-save-a-keras-model)。
+*   [关于 Keras 文档中的 Keras 型号](https://keras.io/models/about-keras-models/)。
+
+## 摘要
+
+在这篇文章中，您了解了如何序列化您的 Keras 深度学习模型。
+
+您学习了如何将训练过的模型保存到文件中，然后加载它们并使用它们进行预测。
+
+您还了解到，使用 HDF5 格式可以轻松存储模型权重，并且网络结构可以以 JSON 或 YAML 格式保存。
+
+您对保存深度学习模型或此帖子有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/tutorial-first-neural-network-python-keras.md b/docs/dl-keras/tutorial-first-neural-network-python-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..7c461234f2d7ed5e728095e77e12ba9e35733125
--- /dev/null
+++ b/docs/dl-keras/tutorial-first-neural-network-python-keras.md
@@ -0,0 +1,324 @@
+# 用 Keras 逐步开发 Python 中的第一个神经网络
+
+> 原文： [https://machinelearningmastery.com/tutorial-first-neural-network-python-keras/](https://machinelearningmastery.com/tutorial-first-neural-network-python-keras/)
+
+Keras 是一个功能强大且易于使用的 Python 库，用于开发和评估[深度学习](http://machinelearningmastery.com/what-is-deep-learning/)模型。
+
+它包含了高效的数值计算库 Theano 和 TensorFlow，允许您在几行代码中定义和训练神经网络模型。
+
+在这篇文章中，您将了解如何使用 Keras 在 Python 中创建第一个神经网络模型。
+
+让我们开始吧。
+
+*   **2017 年 2 月更新**：更新了预测示例，因此在 Python 2 和 Python 3 中可以进行舍入。
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+*   **更新 Mar / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。
+
+![Tour of Deep Learning Algorithms](img/b146789c05a7cd65c9b0afcfc33dcd5e.jpg)
+
+使用 Keras 逐步开发 Python 中的第一个神经网络
+Phil Whitehouse 的照片，保留一些权利。
+
+## 教程概述
+
+不需要很多代码，但我们会慢慢跨过它，以便您知道将来如何创建自己的模型。
+
+您将在本教程中介绍的步骤如下：
+
+1.  加载数据。
+2.  定义模型。
+3.  编译模型。
+4.  适合模型。
+5.  评估模型。
+6.  把它绑在一起。
+
+本教程有一些要求：
+
+1.  您已安装并配置了 Python 2 或 3。
+2.  您已安装并配置了 SciPy（包括 NumPy）。
+3.  您安装并配置了 Keras 和后端（Theano 或 TensorFlow）。
+
+如果您需要有关环境的帮助，请参阅教程：
+
+*   [如何使用 Anaconda 设置用于机器学习和深度学习的 Python 环境](http://machinelearningmastery.com/setup-python-environment-machine-learning-deep-learning-anaconda/)
+
+创建一个名为 **keras_first_network.py** 的新文件，然后在您输入时将代码输入或复制并粘贴到文件中。
+
+## 1.加载数据
+
+每当我们使用使用随机过程（例如随机数）的机器学习算法时，最好设置随机数种子。
+
+这样您就可以反复运行相同的代码并获得相同的结果。如果您需要演示结果，使用相同的随机源比较算法或调试代码的一部分，这非常有用。
+
+您可以使用您喜欢的任何种子初始化随机数生成器，例如：
+
+```
+from keras.models import Sequential
+from keras.layers import Dense
+import numpy
+# fix random seed for reproducibility
+numpy.random.seed(7)
+```
+
+现在我们可以加载我们的数据。
+
+在本教程中，我们将使用 Pima Indians 糖尿病数据集。这是来自 UCI 机器学习库的标准机器学习数据集。它描述了皮马印第安人的患者病历数据，以及他们是否在五年内患有糖尿病。
+
+因此，它是二元分类问题（糖尿病发作为 1 或不为 0）。描述每个患者的所有输入变量都是数字的。这使得它可以直接用于期望数字输入和输出值的神经网络，是我们在 Keras 的第一个神经网络的理想选择。
+
+*   [数据集文件](https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv)
+*   [数据集详情](https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.names)
+
+下载数据集并将其放在本地工作目录中，与 python 文件相同。使用文件名保存：
+
+```
+pima-indians-diabetes.csv
+```
+
+您现在可以使用 NumPy 函数 **loadtxt（）**直接加载文件。有八个输入变量和一个输出变量（最后一列）。加载后，我们可以将数据集拆分为输入变量（X）和输出类变量（Y）。
+
+```
+# 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]
+```
+
+我们初始化了随机数生成器，以确保我们的结果可重现并加载我们的数据。我们现在准备定义我们的神经网络模型。
+
+请注意，数据集有 9 列，范围 0：8 将选择 0 到 7 之间的列，在索引 8 之前停止。如果这对您来说是新的，那么您可以在此帖子中了解有关数组切片和范围的更多信息：
+
+*   [如何在 Python 中为机器学习索引，切片和重塑 NumPy 数组](https://machinelearningmastery.com/index-slice-reshape-numpy-arrays-machine-learning-python/)
+
+## 2.定义模型
+
+Keras 中的模型被定义为层序列。
+
+我们创建一个 Sequential 模型并一次添加一个层，直到我们对网络拓扑感到满意为止。
+
+要做的第一件事是确保输入层具有正确数量的输入。当使用 **input_dim** 参数创建第一层并为 8 个输入变量将其设置为 8 时，可以指定此项。
+
+我们如何知道层数及其类型？
+
+这是一个非常难的问题。我们可以使用启发式方法，通常通过试验和错误实验的过程找到最好的网络结构。通常，如果有任何帮助，您需要一个足够大的网络来捕获问题的结构。
+
+在此示例中，我们将使用具有三个层的完全连接的网络结构。
+
+完全连接的层使用 Dense 类定义。我们可以指定层中神经元的数量作为第一个参数，初始化方法作为 **init** 指定第二个参数，并使用**激活**参数指定激活函数。
+
+在这种情况下，我们将网络权重初始化为从均匀分布（' **uniform** '）生成的小随机数，在这种情况下介于 0 和 0.05 之间，因为这是 Keras 中的默认均匀权重初始化。对于从高斯分布产生的小随机数，另一种传统的替代方案是'**正常'**。
+
+我们将在前两层使用[整流器](https://en.wikipedia.org/wiki/Rectifier_(neural_networks))（' **relu** '）激活函数，在输出层使用 sigmoid 函数。过去，所有层都优先选择 sigmoid 和 tanh 激活函数。目前，使用整流器激活功能可以获得更好的性能。我们在输出层使用 sigmoid 来确保我们的网络输出介于 0 和 1 之间，并且很容易映射到 1 级概率或者使用默认阈值 0.5 捕捉到任一类的硬分类。
+
+我们可以通过添加每一层将它们拼凑在一起。第一层有 12 个神经元，需要 8 个输入变量。第二个隐藏层有 8 个神经元，最后，输出层有 1 个神经元来预测类别（是否发生糖尿病）。
+
+```
+# 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'))
+```
+
+## 3.编译模型
+
+既然定义了模型，我们就可以编译它。
+
+编译模型使用封面下的高效数字库（所谓的后端），如 Theano 或 TensorFlow。后端自动选择最佳方式来表示网络以进行训练并使预测在硬件上运行，例如 CPU 或 GPU 甚至分布式。
+
+编译时，我们必须指定培训网络时所需的一些其他属性。记住训练网络意味着找到最佳权重集来预测这个问题。
+
+我们必须指定用于评估一组权重的损失函数，用于搜索网络的不同权重的优化器以及我们希望在培训期间收集和报告的任何可选指标。
+
+在这种情况下，我们将使用对数损失，对于二进制分类问题，在 Keras 中定义为“ **binary_crossentropy** ”。我们还将使用有效的梯度下降算法“ **adam** ”，因为它是一个有效的默认值。在“ [Adam：随机优化方法](http://arxiv.org/abs/1412.6980)”一文中了解有关 Adam 优化算法的更多信息。
+
+最后，因为它是一个分类问题，我们将收集并报告分类准确度作为指标。
+
+```
+# Compile model
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+```
+
+## 4.适合模型
+
+我们已经定义了我们的模型并将其编译为高效计算。
+
+现在是时候在一些数据上执行模型了。
+
+我们可以通过调用模型上的 **fit（）**函数来训练或拟合我们的加载数据模型。
+
+训练过程将通过名为 epochs 的数据集进行固定次数的迭代，我们必须使用 **nepochs** 参数指定。我们还可以设置在执行网络中的权重更新之前评估的实例数，称为批量大小并使用 **batch_size** 参数进行设置。
+
+对于这个问题，我们将运行少量迭代（150）并使用相对较小的批量大小 10.再次，这些可以通过试验和错误通过实验选择。
+
+```
+# Fit the model
+model.fit(X, Y, epochs=150, batch_size=10)
+```
+
+这是工作在 CPU 或 GPU 上发生的地方。
+
+此示例不需要 GPU，但如果您对如何在云中廉价地在 GPU 硬件上运行大型模型感兴趣，请参阅此帖子：
+
+*   [如何使用亚马逊网络服务上的 Keras 开发和评估大型深度学习模型](https://machinelearningmastery.com/develop-evaluate-large-deep-learning-models-keras-amazon-web-services/)
+
+## 5.评估模型
+
+我们已经在整个数据集上训练了神经网络，我们可以在同一数据集上评估网络的性能。
+
+这只会让我们了解我们对数据集建模的程度（例如列车精度），但不知道算法在新数据上的表现如何。我们这样做是为了简化，但理想情况下，您可以将数据分成训练和测试数据集，以便对模型进行培训和评估。
+
+您可以使用模型上的 **evaluate（）**函数在训练数据集上评估模型，并将其传递给用于训练模型的相同输入和输出。
+
+这将为每个输入和输出对生成预测并收集分数，包括平均损失和您配置的任何指标，例如准确性。
+
+```
+# evaluate the model
+scores = model.evaluate(X, Y)
+print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
+```
+
+## 6.将它们结合在一起
+
+您刚刚看到了如何在 Keras 中轻松创建第一个神经网络模型。
+
+让我们将它们组合成一个完整的代码示例。
+
+```
+# Create your first MLP in Keras
+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, epochs=150, batch_size=10)
+# evaluate the model
+scores = model.evaluate(X, Y)
+print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
+```
+
+运行此示例，您应该看到 150 个历元中的每个历元记录每个历史记录的丢失和准确性的消息，然后对训练数据集上的训练模型进行最终评估。
+
+在带有 Theano 后端的 CPU 上运行的工作站上执行大约需要 10 秒钟。
+
+```
+...
+Epoch 145/150
+768/768 [==============================] - 0s - loss: 0.5105 - acc: 0.7396
+Epoch 146/150
+768/768 [==============================] - 0s - loss: 0.4900 - acc: 0.7591
+Epoch 147/150
+768/768 [==============================] - 0s - loss: 0.4939 - acc: 0.7565
+Epoch 148/150
+768/768 [==============================] - 0s - loss: 0.4766 - acc: 0.7773
+Epoch 149/150
+768/768 [==============================] - 0s - loss: 0.4883 - acc: 0.7591
+Epoch 150/150
+768/768 [==============================] - 0s - loss: 0.4827 - acc: 0.7656
+ 32/768 [>.............................] - ETA: 0s
+acc: 78.26%
+```
+
+**注意**：如果您尝试在 IPython 或 Jupyter 笔记本中运行此示例，则可能会出错。原因是训练期间的输出进度条。您可以通过在 **model.fit（）**的调用中设置 **verbose = 0** 来轻松关闭它们。
+
+请注意，您的模型的技能可能会有所不同。
+
+神经网络是一种随机算法，意味着相同数据上的相同算法可以训练具有不同技能的不同模型。这是一个功能，而不是一个 bug。您可以在帖子中了解更多相关信息：
+
+*   [在机器学习中拥抱随机性](https://machinelearningmastery.com/randomness-in-machine-learning/)
+
+我们确实尝试修复随机种子以确保您和我获得相同的模型，因此得到相同的结果，但这并不总是适用于所有系统。我在这里写了更多关于使用 Keras 模型再现结果的[问题](https://machinelearningmastery.com/reproducible-results-neural-networks-keras/)。
+
+## 7.奖金：做出预测
+
+我被问到的头号问题是：
+
+> 在训练我的模型后，如何使用它来预测新数据？
+
+好问题。
+
+我们可以调整上面的示例并使用它来生成训练数据集的预测，假装它是我们以前从未见过的新数据集。
+
+进行预测就像调用 **model.predict（）**一样简单。我们在输出层使用 sigmoid 激活函数，因此预测将在 0 到 1 之间的范围内。我们可以通过舍入它们轻松地将它们转换为这个分类任务的清晰二元预测。
+
+下面列出了为训练数据中的每条记录进行预测的完整示例。
+
+```
+# Create first network with Keras
+from keras.models import Sequential
+from keras.layers import Dense
+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, init='uniform', activation='relu'))
+model.add(Dense(8, init='uniform', activation='relu'))
+model.add(Dense(1, init='uniform', activation='sigmoid'))
+# Compile model
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+# Fit the model
+model.fit(X, Y, epochs=150, batch_size=10,  verbose=2)
+# calculate predictions
+predictions = model.predict(X)
+# round predictions
+rounded = [round(x[0]) for x in predictions]
+print(rounded)
+```
+
+现在运行此修改示例将打印每个输入模式的预测。如果需要，我们可以直接在我们的应用程序中使用这些预测
+
+```
+[1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0]
+```
+
+如果您对使用经过训练的模型进行预测有更多疑问，请参阅此帖子：
+
+*   [如何用 Keras 进行预测](https://machinelearningmastery.com/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/)
+
+## 摘要
+
+在这篇文章中，您发现了如何使用功能强大的 Keras Python 库创建第一个神经网络模型以进行深度学习。
+
+具体来说，您学习了使用 Keras 创建神经网络或深度学习模型的五个关键步骤，包括：
+
+1.  如何加载数据。
+2.  如何在 Keras 中定义神经网络。
+3.  如何使用高效的数字后端编译 Keras 模型。
+4.  如何训练数据模型。
+5.  如何评估数据模型。
+
+您对 Keras 或本教程有任何疑问吗？
+在评论中提出您的问题，我会尽力回答。
+
+### 相关教程
+
+您是否正在寻找使用 Python 和 Keras 的更多深度学习教程？
+
+看看其中一些：
+
+*   [Keras 神经网络模型的 5 步生命周期](http://machinelearningmastery.com/5-step-life-cycle-neural-network-models-keras/)
+*   [如何使用 Keras 网格搜索 Python 中的深度学习模型的超参数](http://machinelearningmastery.com/grid-search-hyperparameters-deep-learning-models-python-keras/)
+*   [Keras 中深度学习的时间序列预测](http://machinelearningmastery.com/time-series-prediction-with-deep-learning-in-python-with-keras/)
+*   [Keras 深度学习库的多类分类教程](http://machinelearningmastery.com/multi-class-classification-tutorial-keras-deep-learning-library/)
+*   [使用 Python 中的 Keras 深度学习库进行回归教程](http://machinelearningmastery.com/regression-tutorial-keras-deep-learning-library-python/)
\ No newline at end of file
diff --git a/docs/dl-keras/understanding-stateful-lstm-recurrent-neural-networks-python-keras.md b/docs/dl-keras/understanding-stateful-lstm-recurrent-neural-networks-python-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..75838b46b37828335bce78f7efa2734b2c357255
--- /dev/null
+++ b/docs/dl-keras/understanding-stateful-lstm-recurrent-neural-networks-python-keras.md
@@ -0,0 +1,993 @@
+# 用 Keras 理解 Python 中的有状态 LSTM 循环神经网络
+
+> 原文： [https://machinelearningmastery.com/understanding-stateful-lstm-recurrent-neural-networks-python-keras/](https://machinelearningmastery.com/understanding-stateful-lstm-recurrent-neural-networks-python-keras/)
+
+强大且流行的递归神经网络是长期短期模型网络或 LSTM。
+
+它被广泛使用，因为该体系结构克服了困扰所有递归神经网络的消失和暴露梯度问题，允许创建非常大且非常深的网络。
+
+与其他递归神经网络一样，LSTM 网络维持状态，并且在 Keras 框架中如何实现这一点的具体细节可能会令人困惑。
+
+在这篇文章中，您将通过 Keras 深度学习库确切了解 LSTM 网络中的状态。
+
+阅读这篇文章后你会知道：
+
+*   如何为序列预测问题开发一个天真的 LSTM 网络。
+*   如何通过 LSTM 网络批量管理状态和功能。
+*   如何在 LSTM 网络中手动管理状态以进行状态预测。
+
+让我们开始吧。
+
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+*   **更新 Aug / 2018** ：更新了 Python 3 的示例，更新了有状态示例以获得 100％的准确性。
+*   **更新 Mar / 2019** ：修正了有状态示例中的拼写错误。
+
+![Understanding Stateful LSTM Recurrent Neural Networks in Python with Keras](img/37f8b123630baa4ea9ced3b21e1ebed6.jpg)
+
+使用 Keras 了解 Python 中的有状态 LSTM 回归神经网络
+[Martin Abegglen](https://www.flickr.com/photos/twicepix/7923674788/) 的照片，保留一些权利。
+
+## 问题描述：学习字母表
+
+在本教程中，我们将开发和对比许多不同的 LSTM 递归神经网络模型。
+
+这些比较的背景将是学习字母表的简单序列预测问题。也就是说，给定一个字母表的字母，预测字母表的下一个字母。
+
+这是一个简单的序列预测问题，一旦理解就可以推广到其他序列预测问题，如时间序列预测和序列分类。
+
+让我们用一些 python 代码来准备问题，我们可以从示例到示例重用这些代码。
+
+首先，让我们导入我们计划在本教程中使用的所有类和函数。
+
+```
+import numpy
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import LSTM
+from keras.utils import np_utils
+```
+
+接下来，我们可以为随机数生成器播种，以确保每次执行代码时结果都相同。
+
+```
+# fix random seed for reproducibility
+numpy.random.seed(7)
+```
+
+我们现在可以定义我们的数据集，即字母表。为了便于阅读，我们用大写字母定义字母表。
+
+神经网络模型编号，因此我们需要将字母表的字母映射为整数值。我们可以通过创建字符索引的字典（map）来轻松完成此操作。我们还可以创建反向查找，以便将预测转换回字符以便以后使用。
+
+```
+# define the raw dataset
+alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+# create mapping of characters to integers (0-25) and the reverse
+char_to_int = dict((c, i) for i, c in enumerate(alphabet))
+int_to_char = dict((i, c) for i, c in enumerate(alphabet))
+```
+
+现在我们需要创建输入和输出对来训练我们的神经网络。我们可以通过定义输入序列长度，然后从输入字母序列中读取序列来完成此操作。
+
+例如，我们使用输入长度 1.从原始输入数据的开头开始，我们可以读出第一个字母“A”和下一个字母作为预测“B”。我们沿着一个角色移动并重复直到我们达到“Z”的预测。
+
+```
+# prepare the dataset of input to output pairs encoded as integers
+seq_length = 1
+dataX = []
+dataY = []
+for i in range(0, len(alphabet) - seq_length, 1):
+	seq_in = alphabet[i:i + seq_length]
+	seq_out = alphabet[i + seq_length]
+	dataX.append([char_to_int[char] for char in seq_in])
+	dataY.append(char_to_int[seq_out])
+	print(seq_in, '->', seq_out)
+```
+
+我们还打印出输入对以进行健全性检查。
+
+将代码运行到此点将产生以下输出，总结长度为 1 的输入序列和单个输出字符。
+
+```
+A -> B
+B -> C
+C -> D
+D -> E
+E -> F
+F -> G
+G -> H
+H -> I
+I -> J
+J -> K
+K -> L
+L -> M
+M -> N
+N -> O
+O -> P
+P -> Q
+Q -> R
+R -> S
+S -> T
+T -> U
+U -> V
+V -> W
+W -> X
+X -> Y
+Y -> Z
+```
+
+我们需要将 NumPy 阵列重新整形为 LSTM 网络所期望的格式，即[_ 样本，时间步长，特征 _]。
+
+```
+# reshape X to be [samples, time steps, features]
+X = numpy.reshape(dataX, (len(dataX), seq_length, 1))
+```
+
+一旦重新整形，我们就可以将输入整数归一化到 0 到 1 的范围，即 LSTM 网络使用的 S 形激活函数的范围。
+
+```
+# normalize
+X = X / float(len(alphabet))
+```
+
+最后，我们可以将此问题视为序列分类任务，其中 26 个字母中的每一个代表不同的类。因此，我们可以使用 Keras 内置函数 **to_categorical（）**将输出（y）转换为一个热编码。
+
+```
+# one hot encode the output variable
+y = np_utils.to_categorical(dataY)
+```
+
+我们现在准备适应不同的 LSTM 模型。
+
+## 用于学习 One-Char 到 One-Char 映射的 Naive LSTM
+
+让我们从设计一个简单的 LSTM 开始，学习如何在给定一个字符的上下文的情况下预测字母表中的下一个字符。
+
+我们将问题框架化为单字母输入到单字母输出对的随机集合。正如我们将看到的那样，这是 LSTM 学习问题的难点框架。
+
+让我们定义一个具有 32 个单元的 LSTM 网络和一个具有 softmax 激活功能的输出层，用于进行预测。因为这是一个多类分类问题，我们可以使用日志丢失函数（在 Keras 中称为“ **categorical_crossentropy** ”），并使用 ADAM 优化函数优化网络。
+
+该模型适用于 500 个时期，批量大小为 1。
+
+```
+# create and fit the model
+model = Sequential()
+model.add(LSTM(32, input_shape=(X.shape[1], X.shape[2])))
+model.add(Dense(y.shape[1], activation='softmax'))
+model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+model.fit(X, y, epochs=500, batch_size=1, verbose=2)
+```
+
+在我们拟合模型之后，我们可以评估和总结整个训练数据集的性能。
+
+```
+# summarize performance of the model
+scores = model.evaluate(X, y, verbose=0)
+print("Model Accuracy: %.2f%%" % (scores[1]*100))
+```
+
+然后，我们可以通过网络重新运行训练数据并生成预测，将输入和输出对转换回原始字符格式，以便直观地了解网络如何了解问题。
+
+```
+# demonstrate some model predictions
+for pattern in dataX:
+	x = numpy.reshape(pattern, (1, len(pattern), 1))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	result = int_to_char[index]
+	seq_in = [int_to_char[value] for value in pattern]
+	print(seq_in, "->", result)
+```
+
+下面提供了整个代码清单，以确保完整性。
+
+```
+# Naive LSTM to learn one-char to one-char mapping
+import numpy
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import LSTM
+from keras.utils import np_utils
+# fix random seed for reproducibility
+numpy.random.seed(7)
+# define the raw dataset
+alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+# create mapping of characters to integers (0-25) and the reverse
+char_to_int = dict((c, i) for i, c in enumerate(alphabet))
+int_to_char = dict((i, c) for i, c in enumerate(alphabet))
+# prepare the dataset of input to output pairs encoded as integers
+seq_length = 1
+dataX = []
+dataY = []
+for i in range(0, len(alphabet) - seq_length, 1):
+	seq_in = alphabet[i:i + seq_length]
+	seq_out = alphabet[i + seq_length]
+	dataX.append([char_to_int[char] for char in seq_in])
+	dataY.append(char_to_int[seq_out])
+	print(seq_in, '->', seq_out)
+# reshape X to be [samples, time steps, features]
+X = numpy.reshape(dataX, (len(dataX), seq_length, 1))
+# normalize
+X = X / float(len(alphabet))
+# one hot encode the output variable
+y = np_utils.to_categorical(dataY)
+# create and fit the model
+model = Sequential()
+model.add(LSTM(32, input_shape=(X.shape[1], X.shape[2])))
+model.add(Dense(y.shape[1], activation='softmax'))
+model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+model.fit(X, y, epochs=500, batch_size=1, verbose=2)
+# summarize performance of the model
+scores = model.evaluate(X, y, verbose=0)
+print("Model Accuracy: %.2f%%" % (scores[1]*100))
+# demonstrate some model predictions
+for pattern in dataX:
+	x = numpy.reshape(pattern, (1, len(pattern), 1))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	result = int_to_char[index]
+	seq_in = [int_to_char[value] for value in pattern]
+	print(seq_in, "->", result)
+```
+
+运行此示例将生成以下输出。
+
+```
+Model Accuracy: 84.00%
+['A'] -> B
+['B'] -> C
+['C'] -> D
+['D'] -> E
+['E'] -> F
+['F'] -> G
+['G'] -> H
+['H'] -> I
+['I'] -> J
+['J'] -> K
+['K'] -> L
+['L'] -> M
+['M'] -> N
+['N'] -> O
+['O'] -> P
+['P'] -> Q
+['Q'] -> R
+['R'] -> S
+['S'] -> T
+['T'] -> U
+['U'] -> W
+['V'] -> Y
+['W'] -> Z
+['X'] -> Z
+['Y'] -> Z
+```
+
+我们可以看到这个问题对于网络来说确实很难学习。
+
+原因是，糟糕的 LSTM 单位没有任何上下文可以使用。每个输入 - 输出模式以随机顺序显示给网络，并且在每个模式（每个批次包含一个模式的每个批次）之后重置网络状态。
+
+这是滥用 LSTM 网络架构，将其视为标准的多层 Perceptron。
+
+接下来，让我们尝试不同的问题框架，以便为网络提供更多的顺序来学习。
+
+## Naive LSTM 用于三字符特征窗口到单字符映射
+
+为多层 Perceptrons 添加更多上下文数据的流行方法是使用 window 方法。
+
+这是序列中的先前步骤作为网络的附加输入功能提供的地方。我们可以尝试相同的技巧，为 LSTM 网络提供更多上下文。
+
+在这里，我们将序列长度从 1 增加到 3，例如：
+
+```
+# prepare the dataset of input to output pairs encoded as integers
+seq_length = 3
+```
+
+这创建了以下培训模式：
+
+```
+ABC -> D
+BCD -> E
+CDE -> F
+```
+
+然后，序列中的每个元素作为新的输入特征提供给网络。这需要修改数据准备步骤中输入序列的重新形成方式：
+
+```
+# reshape X to be [samples, time steps, features]
+X = numpy.reshape(dataX, (len(dataX), 1, seq_length))
+```
+
+在演示模型的预测时，还需要修改样本模式的重新整形方式。
+
+```
+x = numpy.reshape(pattern, (1, 1, len(pattern)))
+```
+
+下面提供了整个代码清单，以确保完整性。
+
+```
+# Naive LSTM to learn three-char window to one-char mapping
+import numpy
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import LSTM
+from keras.utils import np_utils
+# fix random seed for reproducibility
+numpy.random.seed(7)
+# define the raw dataset
+alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+# create mapping of characters to integers (0-25) and the reverse
+char_to_int = dict((c, i) for i, c in enumerate(alphabet))
+int_to_char = dict((i, c) for i, c in enumerate(alphabet))
+# prepare the dataset of input to output pairs encoded as integers
+seq_length = 3
+dataX = []
+dataY = []
+for i in range(0, len(alphabet) - seq_length, 1):
+	seq_in = alphabet[i:i + seq_length]
+	seq_out = alphabet[i + seq_length]
+	dataX.append([char_to_int[char] for char in seq_in])
+	dataY.append(char_to_int[seq_out])
+	print(seq_in, '->', seq_out)
+# reshape X to be [samples, time steps, features]
+X = numpy.reshape(dataX, (len(dataX), 1, seq_length))
+# normalize
+X = X / float(len(alphabet))
+# one hot encode the output variable
+y = np_utils.to_categorical(dataY)
+# create and fit the model
+model = Sequential()
+model.add(LSTM(32, input_shape=(X.shape[1], X.shape[2])))
+model.add(Dense(y.shape[1], activation='softmax'))
+model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+model.fit(X, y, epochs=500, batch_size=1, verbose=2)
+# summarize performance of the model
+scores = model.evaluate(X, y, verbose=0)
+print("Model Accuracy: %.2f%%" % (scores[1]*100))
+# demonstrate some model predictions
+for pattern in dataX:
+	x = numpy.reshape(pattern, (1, 1, len(pattern)))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	result = int_to_char[index]
+	seq_in = [int_to_char[value] for value in pattern]
+	print(seq_in, "->", result)
+```
+
+运行此示例提供以下输出。
+
+```
+Model Accuracy: 86.96%
+['A', 'B', 'C'] -> D
+['B', 'C', 'D'] -> E
+['C', 'D', 'E'] -> F
+['D', 'E', 'F'] -> G
+['E', 'F', 'G'] -> H
+['F', 'G', 'H'] -> I
+['G', 'H', 'I'] -> J
+['H', 'I', 'J'] -> K
+['I', 'J', 'K'] -> L
+['J', 'K', 'L'] -> M
+['K', 'L', 'M'] -> N
+['L', 'M', 'N'] -> O
+['M', 'N', 'O'] -> P
+['N', 'O', 'P'] -> Q
+['O', 'P', 'Q'] -> R
+['P', 'Q', 'R'] -> S
+['Q', 'R', 'S'] -> T
+['R', 'S', 'T'] -> U
+['S', 'T', 'U'] -> V
+['T', 'U', 'V'] -> Y
+['U', 'V', 'W'] -> Z
+['V', 'W', 'X'] -> Z
+['W', 'X', 'Y'] -> Z
+```
+
+我们可以看到性能上的小幅提升可能是也可能不是真实的。这是一个简单的问题，即使使用窗口方法，我们仍然无法用 LSTM 学习。
+
+同样，这是对问题的不良框架的 LSTM 网络的滥用。实际上，字母序列是一个特征的时间步长，而不是单独特征的一个时间步长。我们已经为网络提供了更多的上下文，但没有像预期的那样更多的序列。
+
+在下一节中，我们将以时间步长的形式为网络提供更多上下文。
+
+## 用于单字符映射的三字符时间步长窗口的朴素 LSTM
+
+在 Keras 中，LSTM 的预期用途是以时间步长的形式提供上下文，而不是像其他网络类型那样提供窗口化功能。
+
+我们可以采用我们的第一个例子，只需将序列长度从 1 更改为 3。
+
+```
+seq_length = 3
+```
+
+同样，这会创建输入 - 输出对，如下所示：
+
+```
+ABC -> D
+BCD -> E
+CDE -> F
+DEF -> G
+```
+
+不同之处在于输入数据的重新整形将序列作为一个特征的时间步长序列，而不是多个特征的单个时间步长。
+
+```
+# reshape X to be [samples, time steps, features]
+X = numpy.reshape(dataX, (len(dataX), seq_length, 1))
+```
+
+这是为 Keras 中的 LSTM 提供序列上下文的正确用途。完整性代码示例如下所示。
+
+```
+# Naive LSTM to learn three-char time steps to one-char mapping
+import numpy
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import LSTM
+from keras.utils import np_utils
+# fix random seed for reproducibility
+numpy.random.seed(7)
+# define the raw dataset
+alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+# create mapping of characters to integers (0-25) and the reverse
+char_to_int = dict((c, i) for i, c in enumerate(alphabet))
+int_to_char = dict((i, c) for i, c in enumerate(alphabet))
+# prepare the dataset of input to output pairs encoded as integers
+seq_length = 3
+dataX = []
+dataY = []
+for i in range(0, len(alphabet) - seq_length, 1):
+	seq_in = alphabet[i:i + seq_length]
+	seq_out = alphabet[i + seq_length]
+	dataX.append([char_to_int[char] for char in seq_in])
+	dataY.append(char_to_int[seq_out])
+	print(seq_in, '->', seq_out)
+# reshape X to be [samples, time steps, features]
+X = numpy.reshape(dataX, (len(dataX), seq_length, 1))
+# normalize
+X = X / float(len(alphabet))
+# one hot encode the output variable
+y = np_utils.to_categorical(dataY)
+# create and fit the model
+model = Sequential()
+model.add(LSTM(32, input_shape=(X.shape[1], X.shape[2])))
+model.add(Dense(y.shape[1], activation='softmax'))
+model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+model.fit(X, y, epochs=500, batch_size=1, verbose=2)
+# summarize performance of the model
+scores = model.evaluate(X, y, verbose=0)
+print("Model Accuracy: %.2f%%" % (scores[1]*100))
+# demonstrate some model predictions
+for pattern in dataX:
+	x = numpy.reshape(pattern, (1, len(pattern), 1))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	result = int_to_char[index]
+	seq_in = [int_to_char[value] for value in pattern]
+	print(seq_in, "->", result)
+```
+
+运行此示例提供以下输出。
+
+```
+Model Accuracy: 100.00%
+['A', 'B', 'C'] -> D
+['B', 'C', 'D'] -> E
+['C', 'D', 'E'] -> F
+['D', 'E', 'F'] -> G
+['E', 'F', 'G'] -> H
+['F', 'G', 'H'] -> I
+['G', 'H', 'I'] -> J
+['H', 'I', 'J'] -> K
+['I', 'J', 'K'] -> L
+['J', 'K', 'L'] -> M
+['K', 'L', 'M'] -> N
+['L', 'M', 'N'] -> O
+['M', 'N', 'O'] -> P
+['N', 'O', 'P'] -> Q
+['O', 'P', 'Q'] -> R
+['P', 'Q', 'R'] -> S
+['Q', 'R', 'S'] -> T
+['R', 'S', 'T'] -> U
+['S', 'T', 'U'] -> V
+['T', 'U', 'V'] -> W
+['U', 'V', 'W'] -> X
+['V', 'W', 'X'] -> Y
+['W', 'X', 'Y'] -> Z
+```
+
+我们可以看到模型完美地学习了问题，如模型评估和示例预测所证明的那样。
+
+但它已经学到了一个更简单的问题。具体来说，它学会了从字母表中的三个字母序列预测下一个字母。它可以显示字母表中任意三个字母的随机序列，并预测下一个字母。
+
+它实际上不能枚举字母表。我希望更大的多层感知网络可以使用窗口方法学习相同的映射。
+
+LSTM 网络是有状态的。他们应该能够学习整个字母顺序，但默认情况下，Keras 实现会在每个训练批次之后重置网络状态。
+
+## 批量生产中的 LSTM 状态
+
+LSTM 的 Keras 实现在每批之后重置网络状态。
+
+这表明，如果我们的批量大小足以容纳所有输入模式，并且如果所有输入模式都是按顺序排序的，那么 LSTM 可以使用批处理中序列的上下文来更好地学习序列。
+
+我们可以通过修改学习一对一映射的第一个示例并将批量大小从 1 增加到训练数据集的大小来轻松演示这一点。
+
+此外，Keras 在每个训练时期之前对训练数据集进行混洗。为确保训练数据模式保持连续，我们可以禁用此改组。
+
+```
+model.fit(X, y, epochs=5000, batch_size=len(dataX), verbose=2, shuffle=False)
+```
+
+网络将使用批内序列学习字符映射，但在进行预测时，网络将无法使用此上下文。我们可以评估网络随机和按顺序进行预测的能力。
+
+完整性代码示例如下所示。
+
+```
+# Naive LSTM to learn one-char to one-char mapping with all data in each batch
+import numpy
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import LSTM
+from keras.utils import np_utils
+from keras.preprocessing.sequence import pad_sequences
+# fix random seed for reproducibility
+numpy.random.seed(7)
+# define the raw dataset
+alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+# create mapping of characters to integers (0-25) and the reverse
+char_to_int = dict((c, i) for i, c in enumerate(alphabet))
+int_to_char = dict((i, c) for i, c in enumerate(alphabet))
+# prepare the dataset of input to output pairs encoded as integers
+seq_length = 1
+dataX = []
+dataY = []
+for i in range(0, len(alphabet) - seq_length, 1):
+	seq_in = alphabet[i:i + seq_length]
+	seq_out = alphabet[i + seq_length]
+	dataX.append([char_to_int[char] for char in seq_in])
+	dataY.append(char_to_int[seq_out])
+	print(seq_in, '->', seq_out)
+# convert list of lists to array and pad sequences if needed
+X = pad_sequences(dataX, maxlen=seq_length, dtype='float32')
+# reshape X to be [samples, time steps, features]
+X = numpy.reshape(dataX, (X.shape[0], seq_length, 1))
+# normalize
+X = X / float(len(alphabet))
+# one hot encode the output variable
+y = np_utils.to_categorical(dataY)
+# create and fit the model
+model = Sequential()
+model.add(LSTM(16, input_shape=(X.shape[1], X.shape[2])))
+model.add(Dense(y.shape[1], activation='softmax'))
+model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+model.fit(X, y, epochs=5000, batch_size=len(dataX), verbose=2, shuffle=False)
+# summarize performance of the model
+scores = model.evaluate(X, y, verbose=0)
+print("Model Accuracy: %.2f%%" % (scores[1]*100))
+# demonstrate some model predictions
+for pattern in dataX:
+	x = numpy.reshape(pattern, (1, len(pattern), 1))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	result = int_to_char[index]
+	seq_in = [int_to_char[value] for value in pattern]
+	print(seq_in, "->", result)
+# demonstrate predicting random patterns
+print("Test a Random Pattern:")
+for i in range(0,20):
+	pattern_index = numpy.random.randint(len(dataX))
+	pattern = dataX[pattern_index]
+	x = numpy.reshape(pattern, (1, len(pattern), 1))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	result = int_to_char[index]
+	seq_in = [int_to_char[value] for value in pattern]
+	print(seq_in, "->", result)
+```
+
+运行该示例提供以下输出。
+
+```
+Model Accuracy: 100.00%
+['A'] -> B
+['B'] -> C
+['C'] -> D
+['D'] -> E
+['E'] -> F
+['F'] -> G
+['G'] -> H
+['H'] -> I
+['I'] -> J
+['J'] -> K
+['K'] -> L
+['L'] -> M
+['M'] -> N
+['N'] -> O
+['O'] -> P
+['P'] -> Q
+['Q'] -> R
+['R'] -> S
+['S'] -> T
+['T'] -> U
+['U'] -> V
+['V'] -> W
+['W'] -> X
+['X'] -> Y
+['Y'] -> Z
+Test a Random Pattern:
+['T'] -> U
+['V'] -> W
+['M'] -> N
+['Q'] -> R
+['D'] -> E
+['V'] -> W
+['T'] -> U
+['U'] -> V
+['J'] -> K
+['F'] -> G
+['N'] -> O
+['B'] -> C
+['M'] -> N
+['F'] -> G
+['F'] -> G
+['P'] -> Q
+['A'] -> B
+['K'] -> L
+['W'] -> X
+['E'] -> F
+```
+
+正如我们所料，网络能够使用序列内上下文来学习字母表，从而实现训练数据的 100％准确性。
+
+重要的是，网络可以对随机选择的字符中的下一个字母进行准确的预测。非常令人印象深刻。
+
+## 用于单字符到单字符映射的有状态 LSTM
+
+我们已经看到，我们可以将原始数据分解为固定大小的序列，并且这种表示可以由 LSTM 学习，但仅用于学习 3 个字符到 1 个字符的随机映射。
+
+我们还看到，我们可以通过批量大小来为网络提供更多序列，但仅限于培训期间。
+
+理想情况下，我们希望将网络暴露给整个序列，让它学习相互依赖关系，而不是在问题框架中明确定义这些依赖关系。
+
+我们可以在 Keras 中通过使 LSTM 层有状态并在时期结束时手动重置网络状态来执行此操作，这也是训练序列的结束。
+
+这确实是如何使用 LSTM 网络的。
+
+我们首先需要将 LSTM 层定义为有状态。这样，我们必须明确指定批量大小作为输入形状的维度。这也意味着，当我们评估网络或进行预测时，我们还必须指定并遵守相同的批量大小。现在这不是一个问题，因为我们使用批量大小为 1.当批量大小不是一个时，这可能会在进行预测时带来困难，因为需要批量和按顺序进行预测。
+
+```
+batch_size = 1
+model.add(LSTM(50, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))
+```
+
+训练有状态 LSTM 的一个重要区别是我们一次手动训练一个时期并在每个时期后重置状态。我们可以在 for 循环中执行此操作。同样，我们不会改变输入，保留输入训练数据的创建顺序。
+
+```
+for i in range(300):
+	model.fit(X, y, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)
+	model.reset_states()
+```
+
+如上所述，我们在评估整个训练数据集的网络性能时指定批量大小。
+
+```
+# summarize performance of the model
+scores = model.evaluate(X, y, batch_size=batch_size, verbose=0)
+model.reset_states()
+print("Model Accuracy: %.2f%%" % (scores[1]*100))
+```
+
+最后，我们可以证明网络确实学会了整个字母表。我们可以用第一个字母“A”播种它，请求预测，将预测反馈作为输入，并一直重复该过程到“Z”。
+
+```
+# demonstrate some model predictions
+seed = [char_to_int[alphabet[0]]]
+for i in range(0, len(alphabet)-1):
+	x = numpy.reshape(seed, (1, len(seed), 1))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	print(int_to_char[seed[0]], "->", int_to_char[index])
+	seed = [index]
+model.reset_states()
+```
+
+我们还可以看到网络是否可以从任意字母开始进行预测。
+
+```
+# demonstrate a random starting point
+letter = "K"
+seed = [char_to_int[letter]]
+print("New start: ", letter)
+for i in range(0, 5):
+	x = numpy.reshape(seed, (1, len(seed), 1))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	print(int_to_char[seed[0]], "->", int_to_char[index])
+	seed = [index]
+model.reset_states()
+```
+
+下面提供了整个代码清单，以确保完整性。
+
+```
+# Stateful LSTM to learn one-char to one-char mapping
+import numpy
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import LSTM
+from keras.utils import np_utils
+# fix random seed for reproducibility
+numpy.random.seed(7)
+# define the raw dataset
+alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+# create mapping of characters to integers (0-25) and the reverse
+char_to_int = dict((c, i) for i, c in enumerate(alphabet))
+int_to_char = dict((i, c) for i, c in enumerate(alphabet))
+# prepare the dataset of input to output pairs encoded as integers
+seq_length = 1
+dataX = []
+dataY = []
+for i in range(0, len(alphabet) - seq_length, 1):
+	seq_in = alphabet[i:i + seq_length]
+	seq_out = alphabet[i + seq_length]
+	dataX.append([char_to_int[char] for char in seq_in])
+	dataY.append(char_to_int[seq_out])
+	print(seq_in, '->', seq_out)
+# reshape X to be [samples, time steps, features]
+X = numpy.reshape(dataX, (len(dataX), seq_length, 1))
+# normalize
+X = X / float(len(alphabet))
+# one hot encode the output variable
+y = np_utils.to_categorical(dataY)
+# create and fit the model
+batch_size = 1
+model = Sequential()
+model.add(LSTM(50, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))
+model.add(Dense(y.shape[1], activation='softmax'))
+model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+for i in range(300):
+	model.fit(X, y, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)
+	model.reset_states()
+# summarize performance of the model
+scores = model.evaluate(X, y, batch_size=batch_size, verbose=0)
+model.reset_states()
+print("Model Accuracy: %.2f%%" % (scores[1]*100))
+# demonstrate some model predictions
+seed = [char_to_int[alphabet[0]]]
+for i in range(0, len(alphabet)-1):
+	x = numpy.reshape(seed, (1, len(seed), 1))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	print(int_to_char[seed[0]], "->", int_to_char[index])
+	seed = [index]
+model.reset_states()
+# demonstrate a random starting point
+letter = "K"
+seed = [char_to_int[letter]]
+print("New start: ", letter)
+for i in range(0, 5):
+	x = numpy.reshape(seed, (1, len(seed), 1))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	print(int_to_char[seed[0]], "->", int_to_char[index])
+	seed = [index]
+model.reset_states()
+```
+
+运行该示例提供以下输出。
+
+```
+Model Accuracy: 100.00%
+A -> B
+B -> C
+C -> D
+D -> E
+E -> F
+F -> G
+G -> H
+H -> I
+I -> J
+J -> K
+K -> L
+L -> M
+M -> N
+N -> O
+O -> P
+P -> Q
+Q -> R
+R -> S
+S -> T
+T -> U
+U -> V
+V -> W
+W -> X
+X -> Y
+Y -> Z
+New start:  K
+K -> B
+B -> C
+C -> D
+D -> E
+E -> F
+```
+
+我们可以看到网络完全记住了整个字母表。它使用了样本本身的上下文，并学习了预测序列中下一个字符所需的依赖性。
+
+我们还可以看到，如果我们用第一个字母为网络播种，那么它可以正确地敲击字母表的其余部分。
+
+我们还可以看到，它只是从冷启动中学习了完整的字母序列。当被要求预测来自“K”的下一个字母时，它预测“B”并且重新回到整个字母表的反刍。
+
+为了真实地预测“K”，需要将网络的状态反复加热，将字母从“A”加到“J”。这告诉我们，通过准备以下训练数据，我们可以通过“无状态”LSTM 实现相同的效果：
+
+```
+---a -> b
+--ab -> c
+-abc -> d
+abcd -> e
+```
+
+输入序列固定为 25（a-to-y 预测 z）并且模式以零填充为前缀。
+
+最后，这提出了使用可变长度输入序列训练 LSTM 网络以预测下一个字符的问题。
+
+## 具有可变长度输入到单字符输出的 LSTM
+
+在上一节中，我们发现 Keras“有状态”LSTM 实际上只是重放第一个 n 序列的捷径，但并没有真正帮助我们学习字母表的通用模型。
+
+在本节中，我们将探索“无状态”LSTM 的变体，它可以学习字母表的随机子序列，并努力构建一个可以给出任意字母或字母子序列的模型，并预测字母表中的下一个字母。
+
+首先，我们正在改变问题的框架。为简化起见，我们将定义最大输入序列长度并将其设置为小值，如 5，以加快训练速度。这定义了为训练绘制的字母表子序列的最大长度。在扩展中，如果我们允许循环回到序列的开头，这可以设置为完整字母表（26）或更长。
+
+我们还需要定义要创建的随机序列的数量，在本例中为 1000.这也可能更多或更少。我希望实际上需要更少的模式。
+
+```
+# prepare the dataset of input to output pairs encoded as integers
+num_inputs = 1000
+max_len = 5
+dataX = []
+dataY = []
+for i in range(num_inputs):
+	start = numpy.random.randint(len(alphabet)-2)
+	end = numpy.random.randint(start, min(start+max_len,len(alphabet)-1))
+	sequence_in = alphabet[start:end+1]
+	sequence_out = alphabet[end + 1]
+	dataX.append([char_to_int[char] for char in sequence_in])
+	dataY.append(char_to_int[sequence_out])
+	print(sequence_in, '->', sequence_out)
+```
+
+在更广泛的上下文中运行此代码将创建如下所示的输入模式：
+
+```
+PQRST -> U
+W -> X
+O -> P
+OPQ -> R
+IJKLM -> N
+QRSTU -> V
+ABCD -> E
+X -> Y
+GHIJ -> K
+```
+
+输入序列的长度在 1 和 **max_len** 之间变化，因此需要零填充。这里，我们使用左侧（前缀）填充和 **pad_sequences（）**函数中内置的 Keras。
+
+```
+X = pad_sequences(dataX, maxlen=max_len, dtype='float32')
+```
+
+在随机选择的输入模式上评估训练的模型。这可能很容易成为新的随机生成的字符序列。我也相信这也可以是一个带有“A”的线性序列，输出 fes 作为单个字符输入。
+
+完整性代码清单如下所示。
+
+```
+# LSTM with Variable Length Input Sequences to One Character Output
+import numpy
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import LSTM
+from keras.utils import np_utils
+from keras.preprocessing.sequence import pad_sequences
+from theano.tensor.shared_randomstreams import RandomStreams
+# fix random seed for reproducibility
+numpy.random.seed(7)
+# define the raw dataset
+alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+# create mapping of characters to integers (0-25) and the reverse
+char_to_int = dict((c, i) for i, c in enumerate(alphabet))
+int_to_char = dict((i, c) for i, c in enumerate(alphabet))
+# prepare the dataset of input to output pairs encoded as integers
+num_inputs = 1000
+max_len = 5
+dataX = []
+dataY = []
+for i in range(num_inputs):
+	start = numpy.random.randint(len(alphabet)-2)
+	end = numpy.random.randint(start, min(start+max_len,len(alphabet)-1))
+	sequence_in = alphabet[start:end+1]
+	sequence_out = alphabet[end + 1]
+	dataX.append([char_to_int[char] for char in sequence_in])
+	dataY.append(char_to_int[sequence_out])
+	print(sequence_in, '->', sequence_out)
+# convert list of lists to array and pad sequences if needed
+X = pad_sequences(dataX, maxlen=max_len, dtype='float32')
+# reshape X to be [samples, time steps, features]
+X = numpy.reshape(X, (X.shape[0], max_len, 1))
+# normalize
+X = X / float(len(alphabet))
+# one hot encode the output variable
+y = np_utils.to_categorical(dataY)
+# create and fit the model
+batch_size = 1
+model = Sequential()
+model.add(LSTM(32, input_shape=(X.shape[1], 1)))
+model.add(Dense(y.shape[1], activation='softmax'))
+model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+model.fit(X, y, epochs=500, batch_size=batch_size, verbose=2)
+# summarize performance of the model
+scores = model.evaluate(X, y, verbose=0)
+print("Model Accuracy: %.2f%%" % (scores[1]*100))
+# demonstrate some model predictions
+for i in range(20):
+	pattern_index = numpy.random.randint(len(dataX))
+	pattern = dataX[pattern_index]
+	x = pad_sequences([pattern], maxlen=max_len, dtype='float32')
+	x = numpy.reshape(x, (1, max_len, 1))
+	x = x / float(len(alphabet))
+	prediction = model.predict(x, verbose=0)
+	index = numpy.argmax(prediction)
+	result = int_to_char[index]
+	seq_in = [int_to_char[value] for value in pattern]
+	print(seq_in, "->", result)
+```
+
+运行此代码将生成以下输出：
+
+```
+Model Accuracy: 98.90%
+['Q', 'R'] -> S
+['W', 'X'] -> Y
+['W', 'X'] -> Y
+['C', 'D'] -> E
+['E'] -> F
+['S', 'T', 'U'] -> V
+['G', 'H', 'I', 'J', 'K'] -> L
+['O', 'P', 'Q', 'R', 'S'] -> T
+['C', 'D'] -> E
+['O'] -> P
+['N', 'O', 'P'] -> Q
+['D', 'E', 'F', 'G', 'H'] -> I
+['X'] -> Y
+['K'] -> L
+['M'] -> N
+['R'] -> T
+['K'] -> L
+['E', 'F', 'G'] -> H
+['Q'] -> R
+['Q', 'R', 'S'] -> T
+```
+
+我们可以看到，尽管模型没有从随机生成的子序列中完美地学习字母表，但它确实做得很好。该模型未经过调整，可能需要更多培训或更大的网络，或两者兼而有之（为读者练习）。
+
+这是“_ 所有顺序输入示例中每个批次 _”字母模型的一个很好的自然扩展，它可以处理即席查询，但这次任意序列长度（最大长度） 。
+
+## 摘要
+
+在这篇文章中，您发现了 Keras 中的 LSTM 循环神经网络以及它们如何管理状态。
+
+具体来说，你学到了：
+
+*   如何为一个字符到一个字符的预测开发一个天真的 LSTM 网络。
+*   如何配置一个天真的 LSTM 来学习样本中跨时间步的序列。
+*   如何通过手动管理状态来配置 LSTM 以跨样本学习序列。
+
+您对管理 LSTM 州或此帖有任何疑问吗？
+在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/use-keras-deep-learning-models-scikit-learn-python.md b/docs/dl-keras/use-keras-deep-learning-models-scikit-learn-python.md
new file mode 100644
index 0000000000000000000000000000000000000000..0f64de2c956bf8fe23bc67f6dd103e4e871a0866
--- /dev/null
+++ b/docs/dl-keras/use-keras-deep-learning-models-scikit-learn-python.md
@@ -0,0 +1,205 @@
+# 在 Python 中使用 Keras 深度学习模型和 Scikit-Learn
+
+> 原文： [https://machinelearningmastery.com/use-keras-deep-learning-models-scikit-learn-python/](https://machinelearningmastery.com/use-keras-deep-learning-models-scikit-learn-python/)
+
+Keras 是用于研究和开发的 Python 中最受欢迎的深度学习库之一，因为它简单易用。
+
+[scikit-learn](http://machinelearningmastery.com/a-gentle-introduction-to-scikit-learn-a-python-machine-learning-library/) 库是 Python 中一般机器学习最受欢迎的库。
+
+在这篇文章中，您将了解如何使用 Keras 中的深度学习模型和 Python 中的 scikit-learn 库。
+
+这将允许您利用 scikit-learn 库的功能来完成模型评估和模型超参数优化等任务。
+
+让我们开始吧。
+
+*   **更新**：有关使用 Keras 调整超参数的更大示例，请参阅帖子：
+    *   [如何使用 Keras 网格搜索 Python 中的深度学习模型的超参数](http://machinelearningmastery.com/grid-search-hyperparameters-deep-learning-models-python-keras/)
+*   **2016 年 10 月更新**：更新了 Keras 1.1.0 和 scikit-learn v0.18 的示例。
+*   **2017 年 1 月更新**：修正了打印网格搜索结果的错误。
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+*   **更新 Mar / 2018** ：添加了备用链接以下载数据集，因为原始图像已被删除。
+
+![Use Keras Deep Learning Models with Scikit-Learn in Python](img/7a15249820eaff950ac0e36a690b5b32.jpg)
+
+使用 Keras 深度学习模型与 Scikit-Learn 在 Python
+照片由 [Alan Levine](https://www.flickr.com/photos/cogdog/7519589420/) ，保留一些权利。
+
+## 概观
+
+Keras 是一个用于 Python 深度学习的流行库，但该库的重点是深度学习。事实上，它致力于极简主义，只关注您需要快速简单地定义和构建深度学习模型。
+
+Python 中的 scikit-learn 库建立在 SciPy 堆栈之上，用于高效的数值计算。它是一个功能齐全的通用机器学习库，提供许多有助于开发深度学习模型的实用程序。不少于：
+
+*   使用重新取样方法（如 k-fold 交叉验证）评估模型。
+*   高效搜索和评估模型超参数。
+
+Keras 库为深度学习模型提供了一个方便的包装器，可用作 scikit-learn 中的分类或回归估计器。
+
+在接下来的部分中，我们将介绍使用 KerasClassifier 包装器的示例，该包装器用于在 Keras 中创建并用于 scikit-learn 库的分类神经网络。
+
+测试问题是[皮马印第安人发病的糖尿病分类数据集](http://archive.ics.uci.edu/ml/datasets/Pima+Indians+Diabetes)。这是一个包含所有数字属性的小型数据集，易于使用。 [下载数据集](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)）。
+
+以下示例假设您已成功安装 Keras 和 scikit-learn。
+
+## 使用交叉验证评估深度学习模型
+
+Keras 中的 KerasClassifier 和 KerasRegressor 类接受一个参数 **build_fn** ，它是要调用以获取模型的函数的名称。
+
+您必须定义一个名为您定义模型的函数，编译并返回它。
+
+在下面的示例中，我们定义了一个函数 **create_model（）**，它为问题创建了一个简单的多层神经网络。
+
+我们通过 **build_fn** 参数将此函数名称传递给 KerasClassifier 类。我们还传递了 **nb_epoch = 150** 和 **batch_size = 10** 的其他参数。它们会自动捆绑并传递给 **fit（）**函数，该函数由 KerasClassifier 类在内部调用。
+
+在这个例子中，我们使用 scikit-learn [StratifiedKFold](http://scikit-learn.org/stable/modules/generated/sklearn.cross_validation.StratifiedKFold.html) 来执行 10 倍分层交叉验证。这是一种重采样技术，可以提供对机器学习模型在看不见的数据上的性能的可靠估计。
+
+我们使用 scikit-learn 函数 **cross_val_score（）**来使用交叉验证方案评估我们的模型并打印结果。
+
+```
+# MLP for Pima Indians Dataset with 10-fold cross validation via sklearn
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+from sklearn.model_selection import StratifiedKFold
+from sklearn.model_selection import cross_val_score
+import numpy
+
+# Function to create model, required for KerasClassifier
+def create_model():
+	# 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'])
+	return model
+
+# 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 = KerasClassifier(build_fn=create_model, epochs=150, batch_size=10, verbose=0)
+# evaluate using 10-fold cross validation
+kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
+results = cross_val_score(model, X, Y, cv=kfold)
+print(results.mean())
+```
+
+运行该示例显示每个纪元的模型技能。创建和评估总共 10 个模型，并显示最终的平均精度。
+
+```
+0.646838691487
+```
+
+## 网格搜索深度学习模型参数
+
+前面的例子展示了从 Keras 包装深度学习模型并将其用于 scikit-learn 库的函数是多么容易。
+
+在这个例子中，我们更进一步。在创建 KerasClassifier 包装器时，我们为 **build_fn** 参数指定的函数可以使用参数。我们可以使用这些参数来进一步自定义模型的构造。另外，我们知道我们可以为 **fit（）**函数提供参数。
+
+在此示例中，我们使用网格搜索来评估神经网络模型的不同配置，并报告提供最佳估计性能的组合。
+
+**create_model（）**函数被定义为采用两个参数 optimizer 和 init，两者都必须具有默认值。这将允许我们评估为我们的网络使用不同的优化算法和权重初始化方案的效果。
+
+创建模型后，我们为要搜索的参数定义值数组，具体如下：
+
+*   用于搜索不同重量值的优化器。
+*   用于使用不同方案准备网络权重的初始化器。
+*   用于训练模型的时期，用于对训练数据集进行不同次数的曝光。
+*   用于在重量更新之前改变样本数量的批次。
+
+选项被指定到字典中并传递给 [GridSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.grid_search.GridSearchCV.html) scikit-learn 类的配置。该类将针对每个参数组合评估我们的神经网络模型的版本（对于优化器，初始化，时期和批次的组合，2 x 3 x 3 x 3）。然后使用默认的 3 倍分层交叉验证评估每种组合。
+
+这是很多模型和大量的计算。这不是一个你想要轻松使用的方案，因为它需要时间。您可以使用较小的数据子集设计小型实验，这些实验将在合理的时间内完成。在这种情况下，这是合理的，因为网络较小且数据集较小（少于 1000 个实例和 9 个属性）。
+
+最后，显示最佳模型的性能和配置组合，然后显示所有参数组合的性能。
+
+```
+# MLP for Pima Indians Dataset with grid search via sklearn
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.wrappers.scikit_learn import KerasClassifier
+from sklearn.model_selection import GridSearchCV
+import numpy
+
+# Function to create model, required for KerasClassifier
+def create_model(optimizer='rmsprop', init='glorot_uniform'):
+	# create model
+	model = Sequential()
+	model.add(Dense(12, input_dim=8, kernel_initializer=init, activation='relu'))
+	model.add(Dense(8, kernel_initializer=init, activation='relu'))
+	model.add(Dense(1, kernel_initializer=init, activation='sigmoid'))
+	# Compile model
+	model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
+	return model
+
+# 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 = KerasClassifier(build_fn=create_model, verbose=0)
+# grid search epochs, batch size and optimizer
+optimizers = ['rmsprop', 'adam']
+init = ['glorot_uniform', 'normal', 'uniform']
+epochs = [50, 100, 150]
+batches = [5, 10, 20]
+param_grid = dict(optimizer=optimizers, epochs=epochs, batch_size=batches, init=init)
+grid = GridSearchCV(estimator=model, param_grid=param_grid)
+grid_result = grid.fit(X, Y)
+# summarize results
+print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
+means = grid_result.cv_results_['mean_test_score']
+stds = grid_result.cv_results_['std_test_score']
+params = grid_result.cv_results_['params']
+for mean, stdev, param in zip(means, stds, params):
+	print("%f (%f) with: %r" % (mean, stdev, param))
+```
+
+在 CPU（而不是 CPU）上执行的工作站上可能需要大约 5 分钟才能完成。运行该示例显示以下结果。
+
+我们可以看到，网格搜索发现使用统一初始化方案，rmsprop 优化器，150 个历元和 5 个批处理大小在此问题上实现了大约 75％的最佳交叉验证分数。
+
+```
+Best: 0.752604 using {'init': 'uniform', 'optimizer': 'adam', 'batch_size': 5, 'epochs': 150}
+0.707031 (0.025315) with: {'init': 'glorot_uniform', 'optimizer': 'rmsprop', 'batch_size': 5, 'epochs': 50}
+0.589844 (0.147095) with: {'init': 'glorot_uniform', 'optimizer': 'adam', 'batch_size': 5, 'epochs': 50}
+0.701823 (0.006639) with: {'init': 'normal', 'optimizer': 'rmsprop', 'batch_size': 5, 'epochs': 50}
+0.714844 (0.019401) with: {'init': 'normal', 'optimizer': 'adam', 'batch_size': 5, 'epochs': 50}
+0.718750 (0.016573) with: {'init': 'uniform', 'optimizer': 'rmsprop', 'batch_size': 5, 'epochs': 50}
+0.688802 (0.032578) with: {'init': 'uniform', 'optimizer': 'adam', 'batch_size': 5, 'epochs': 50}
+0.657552 (0.075566) with: {'init': 'glorot_uniform', 'optimizer': 'rmsprop', 'batch_size': 5, 'epochs': 100}
+0.696615 (0.026557) with: {'init': 'glorot_uniform', 'optimizer': 'adam', 'batch_size': 5, 'epochs': 100}
+0.727865 (0.022402) with: {'init': 'normal', 'optimizer': 'rmsprop', 'batch_size': 5, 'epochs': 100}
+0.736979 (0.030647) with: {'init': 'normal', 'optimizer': 'adam', 'batch_size': 5, 'epochs': 100}
+0.739583 (0.029635) with: {'init': 'uniform', 'optimizer': 'rmsprop', 'batch_size': 5, 'epochs': 100}
+0.717448 (0.012075) with: {'init': 'uniform', 'optimizer': 'adam', 'batch_size': 5, 'epochs': 100}
+0.692708 (0.036690) with: {'init': 'glorot_uniform', 'optimizer': 'rmsprop', 'batch_size': 5, 'epochs': 150}
+0.697917 (0.028940) with: {'init': 'glorot_uniform', 'optimizer': 'adam', 'batch_size': 5, 'epochs': 150}
+0.727865 (0.030647) with: {'init': 'normal', 'optimizer': 'rmsprop', 'batch_size': 5, 'epochs': 150}
+0.747396 (0.016053) with: {'init': 'normal', 'optimizer': 'adam', 'batch_size': 5, 'epochs': 150}
+0.729167 (0.007366) with: {'init': 'uniform', 'optimizer': 'rmsprop', 'batch_size': 5, 'epochs': 150}
+0.752604 (0.017566) with: {'init': 'uniform', 'optimizer': 'adam', 'batch_size': 5, 'epochs': 150}
+0.662760 (0.035132) with: {'init': 'glorot_uniform', 'optimizer': 'rmsprop', 'batch_size': 10, 'epochs': 50}
+...
+```
+
+## 摘要
+
+在这篇文章中，您了解了如何包装 Keras 深度学习模型并在 scikit-learn 通用机器学习库中使用它们。
+
+您可以看到，使用 scikit-learn 进行标准机器学习操作（如模型评估和模型超参数优化）可以节省大量时间来自行实施这些方案。
+
+包装模型允许您利用 scikit 中的强大工具学习，使您的深度学习模型适合您的一般机器学习过程。
+
+您是否有任何关于在 scikit-learn 或此帖子中使用 Keras 模型的问题？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/use-pre-trained-vgg-model-classify-objects-photographs.md b/docs/dl-keras/use-pre-trained-vgg-model-classify-objects-photographs.md
new file mode 100644
index 0000000000000000000000000000000000000000..5a696ca413a315b4bf7e635d34ae717332f3cd80
--- /dev/null
+++ b/docs/dl-keras/use-pre-trained-vgg-model-classify-objects-photographs.md
@@ -0,0 +1,378 @@
+# 如何使用预训练的 VGG 模型对照片中的物体进行分类
+
+> 原文： [https://machinelearningmastery.com/use-pre-trained-vgg-model-classify-objects-photographs/](https://machinelearningmastery.com/use-pre-trained-vgg-model-classify-objects-photographs/)
+
+卷积神经网络现在能够在某些计算机视觉任务上胜过人类，例如分类图像。
+
+也就是说，给定物体的照片，回答照片显示的 1000 个特定物体中的哪一个的问题。
+
+牛津大学研究人员的 VGG 模型是一项竞争获胜的模型。除了能够对照片中的物体进行分类之外，这个模型的重要之处在于模型权重是免费提供的，可以在您自己的模型和应用程序中加载和使用。
+
+在本教程中，您将发现用于图像分类的 VGG 卷积神经网络模型。
+
+完成本教程后，您将了解：
+
+*   关于 ImageNet 数据集和竞争以及 VGG 获奖模型。
+*   如何在 Keras 中加载 VGG 模型并总结其结构。
+*   如何使用加载的 VGG 模型对特定照片中的对象进行分类。
+
+让我们开始吧。
+
+## 教程概述
+
+本教程分为 4 个部分;他们是：
+
+1.  ImageNet
+2.  牛津 VGG 模型
+3.  在 Keras 中加载 VGG 模型
+4.  开发简单的照片分类器
+
+## ImageNet
+
+[ImageNet](http://www.image-net.org/) 是一个研究项目，用于开发带有注释的大型图像数据库，例如：图像及其描述。
+
+自 2010 年以来，这些图像及其注释已成为称为 [ImageNet 大规模视觉识别挑战](http://www.image-net.org/challenges/LSVRC/)或 ILSVRC 的图像分类挑战的基础。结果是研究组织在预先定义的数据集上进行战斗，以查看谁具有用于对图像中的对象进行分类的最佳模型。
+
+> ImageNet 大规模视觉识别挑战是对象类别分类和检测数百个对象类别和数百万图像的基准。从 2010 年到现在每年都在进行挑战，吸引了来自 50 多个机构的参与。
+
+- [ImageNet 大规模视觉识别挑战](https://arxiv.org/abs/1409.0575)，2015 年。
+
+对于分类任务，图像必须分为 1,000 个不同类别中的一个。
+
+在过去几年中，已经使用非常深度的卷积神经网络模型来赢得这些挑战，并且任务的结果已超过人类的表现。
+
+![Sample of Images from the ImageNet Dataset used in the ILSVRC Challenge](img/bedb451b4ae753eecb4b2f2f5ddf01b5.jpg)
+
+来自“ImageNet 大规模视觉识别挑战”的 ILSVRC 挑战
+中使用的 ImageNet 数据集的图像样本，2015 年。
+
+## 牛津 VGG 模型
+
+来自[牛津视觉几何组](http://www.robots.ox.ac.uk/~vgg/)（简称 VGG）的研究人员参与了 ILSVRC 的挑战。
+
+2014 年，由 VGG [开发的卷积神经网络模型（CNN）赢得了图像分类任务](http://image-net.org/challenges/LSVRC/2014/results)。
+
+![ILSVRC Results in 2014 for the Classification task](img/3e261540d96ebda34701ebd35f653fd5.jpg)
+
+ILSVRC 2014 年的分类任务结果
+
+比赛结束后，参与者在论文中写下了他们的发现：
+
+*   [用于大规模图像识别的非常深的卷积网络](https://arxiv.org/abs/1409.1556)，2014 年。
+
+他们还在线提供了他们的模型和学习重量 [](http://www.robots.ox.ac.uk/~vgg/research/very_deep/) 。
+
+这使得其他研究人员和开发人员可以在自己的工作和程序中使用最先进的图像分类模型。
+
+这有助于推动一系列转移学习工作，其中使用预先训练的模型，对全新的预测建模任务进行微小修改，利用经过验证的模型的最先进的特征提取功能。
+
+> ......我们提出了更加精确的 ConvNet 架构，它不仅可以实现 ILSVRC 分类和定位任务的最先进精度，而且还适用于其他图像识别数据集，即使在用作相对简单的管道的一部分（例如，由线性 SVM 分类的深度特征，没有微调）。我们发布了两个表现最佳的模型，以促进进一步的研究。
+
+- [用于大规模图像识别的非常深的卷积网络](https://arxiv.org/abs/1409.1556)，2014 年。
+
+VGG 发布了两种不同的 CNN 模型，特别是 16 层模型和 19 层模型。
+
+有关这些型号的完整详细信息，请参阅本文。
+
+VGG 模型不再仅仅是几个百分点的最新技术。然而，它们是非常强大的模型，既可用作图像分类器，也可用作使用图像输入的新模型的基础。
+
+在下一节中，我们将看到如何在 Keras 中直接使用 VGG 模型。
+
+## 在 Keras 中加载 VGG 模型
+
+可以在 Keras 深度学习库中加载和使用 VGG 模型。
+
+Keras 提供[应用程序界面](https://keras.io/applications/)，用于加载和使用预先训练的模型。
+
+使用此界面，您可以使用 Oxford 组提供的预训练权重创建 VGG 模型，并将其用作您自己模型中的起点，或者将其用作模型直接用于分类图像。
+
+在本教程中，我们将重点介绍使用 VGG 模型对新图像进行分类的用例。
+
+Keras 通过 VGG16 和 VGG19 类提供 16 层和 19 层版本。让我们关注 VGG16 模型。
+
+可以按如下方式创建模型：
+
+```
+from keras.applications.vgg16 import VGG16
+model = VGG16()
+```
+
+而已。
+
+第一次运行此示例时，Keras 将从 Internet 下载权重文件并将其存储在 _〜/ .keras / models_ 目录中。
+
+**注意**权重约为 528 兆字节，因此下载可能需要几分钟，具体取决于您的 Internet 连接速度。
+
+权重仅下载一次。下次运行示例时，权重将在本地加载，模型应该可以在几秒钟内使用。
+
+我们可以使用标准的 Keras 工具来检查模型结构。
+
+例如，您可以打印网络层的摘要，如下所示：
+
+```
+from keras.applications.vgg16 import VGG16
+model = VGG16()
+print(model.summary())
+```
+
+你可以看到模型很大。
+
+您还可以看到，默认情况下，模型要求图像作为输入，大小为 224 x 224 像素，具有 3 个通道（例如颜色）。
+
+```
+_________________________________________________________________
+Layer (type)                 Output Shape              Param #
+=================================================================
+input_1 (InputLayer)         (None, 224, 224, 3)       0
+_________________________________________________________________
+block1_conv1 (Conv2D)        (None, 224, 224, 64)      1792
+_________________________________________________________________
+block1_conv2 (Conv2D)        (None, 224, 224, 64)      36928
+_________________________________________________________________
+block1_pool (MaxPooling2D)   (None, 112, 112, 64)      0
+_________________________________________________________________
+block2_conv1 (Conv2D)        (None, 112, 112, 128)     73856
+_________________________________________________________________
+block2_conv2 (Conv2D)        (None, 112, 112, 128)     147584
+_________________________________________________________________
+block2_pool (MaxPooling2D)   (None, 56, 56, 128)       0
+_________________________________________________________________
+block3_conv1 (Conv2D)        (None, 56, 56, 256)       295168
+_________________________________________________________________
+block3_conv2 (Conv2D)        (None, 56, 56, 256)       590080
+_________________________________________________________________
+block3_conv3 (Conv2D)        (None, 56, 56, 256)       590080
+_________________________________________________________________
+block3_pool (MaxPooling2D)   (None, 28, 28, 256)       0
+_________________________________________________________________
+block4_conv1 (Conv2D)        (None, 28, 28, 512)       1180160
+_________________________________________________________________
+block4_conv2 (Conv2D)        (None, 28, 28, 512)       2359808
+_________________________________________________________________
+block4_conv3 (Conv2D)        (None, 28, 28, 512)       2359808
+_________________________________________________________________
+block4_pool (MaxPooling2D)   (None, 14, 14, 512)       0
+_________________________________________________________________
+block5_conv1 (Conv2D)        (None, 14, 14, 512)       2359808
+_________________________________________________________________
+block5_conv2 (Conv2D)        (None, 14, 14, 512)       2359808
+_________________________________________________________________
+block5_conv3 (Conv2D)        (None, 14, 14, 512)       2359808
+_________________________________________________________________
+block5_pool (MaxPooling2D)   (None, 7, 7, 512)         0
+_________________________________________________________________
+flatten (Flatten)            (None, 25088)             0
+_________________________________________________________________
+fc1 (Dense)                  (None, 4096)              102764544
+_________________________________________________________________
+fc2 (Dense)                  (None, 4096)              16781312
+_________________________________________________________________
+predictions (Dense)          (None, 1000)              4097000
+=================================================================
+Total params: 138,357,544
+Trainable params: 138,357,544
+Non-trainable params: 0
+_________________________________________________________________
+```
+
+我们还可以在 VGG 模型中创建图层，如下所示：
+
+```
+from keras.applications.vgg16 import VGG16
+from keras.utils.vis_utils import plot_model
+model = VGG16()
+plot_model(model, to_file='vgg.png')
+```
+
+同样，因为模型很大，情节有点太大，也许不可读。然而，它在下面提供。
+
+![Plot of Layers in the VGG Model](img/bb63b33d778d9f3aa7c05ecc5ef6f642.jpg)
+
+VGG 模型中的图层图
+
+_VGG（）_ 类需要一些参数，如果您希望在自己的项目中使用该模型，可能只会感兴趣。转学习。
+
+例如：
+
+*   **include_top** （ _True_ ）：是否包含模型的输出层。如果您根据自己的问题拟合模型，则不需要这些。
+*   **权重**（' _imagenet_ '）：要加载的权重。如果您有兴趣从头开始训练模型，则可以指定“无”以不加载预先训练的权重。
+*   **input_tensor** （_ 无 _）：如果您打算在不同大小的新数据上拟合模型，则为新输入层。
+*   **input_shape** （_ 无 _）：如果更改输入图层，模型应采用的图像大小。
+*   **汇集**（_ 无 _）：训练一组新输出图层时要使用的池类型。
+*   **类**（ _1000_ ）：模型的类数（例如输出向量的大小）。
+
+接下来，让我们看一下使用加载的 VGG 模型对特定照片进行分类。
+
+## 开发简单的照片分类器
+
+让我们开发一个简单的图像分类脚本。
+
+### 1.获取样本图像
+
+首先，我们需要一个可以分类的图像。
+
+你可以在这里从 Flickr [下载咖啡杯的随机照片。](https://www.flickr.com/photos/jfanaian/4994221690/)
+
+![Coffee Mug](img/c62790dc095057645ed694f0c187f31f.jpg)
+
+咖啡杯
+摄影： [jfanaian](https://www.flickr.com/photos/jfanaian/4994221690/) ，保留一些权利。
+
+下载图像并将其保存到当前工作目录，文件名为“ _mug.jpg_ ”。
+
+### 2.加载 VGG 模型
+
+加载 VGG-16 型号的重量，就像我们在上一节中所做的那样。
+
+```
+from keras.applications.vgg16 import VGG16
+# load the model
+model = VGG16()
+```
+
+### 3.加载并准备图像
+
+接下来，我们可以将图像作为像素数据加载并准备将其呈现给网络。
+
+Keras 提供了一些帮助完成此步骤的工具。
+
+首先，我们可以使用 _load_img（）_ 函数加载图像并将其大小调整为所需的 224×224 像素大小。
+
+```
+from keras.preprocessing.image import load_img
+# load an image from file
+image = load_img('mug.jpg', target_size=(224, 224))
+```
+
+接下来，我们可以将像素转换为 NumPy 数组，以便我们可以在 Keras 中使用它。我们可以使用 _img_to_array（）_ 函数。
+
+```
+from keras.preprocessing.image import img_to_array
+# convert the image pixels to a numpy array
+image = img_to_array(image)
+```
+
+网络期望一个或多个图像作为输入;这意味着输入数组需要是 4 维的：样本，行，列和通道。
+
+我们只有一个样本（一个图像）。我们可以通过调用 _reshape（）_ 并添加额外的维度来重新整形数组。
+
+```
+# reshape data for the model
+image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
+```
+
+接下来，需要以与准备 ImageNet 训练数据相同的方式准备图像像素。具体来说，从论文：
+
+> 我们唯一的预处理是从每个像素中减去在训练集上计算的平均 RGB 值。
+
+- [用于大规模图像识别的非常深的卷积网络](https://arxiv.org/abs/1409.1556)，2014 年。
+
+Keras 提供了一个名为 _preprocess_input（）_ 的函数来为网络准备新的输入。
+
+```
+from keras.applications.vgg16 import preprocess_input
+# prepare the image for the VGG model
+image = preprocess_input(image)
+```
+
+我们现在准备对我们加载和准备好的图像进行预测。
+
+### 4.进行预测
+
+我们可以在模型上调用 _predict（）_ 函数，以便预测属于 1000 种已知对象类型中的每一种的图像的概率。
+
+```
+# predict the probability across all output classes
+yhat = model.predict(image)
+```
+
+几乎在那里，现在我们需要解释概率。
+
+### 5.解释预测
+
+Keras 提供了解释称为 _decode_predictions（）_ 的概率的函数。
+
+它可以返回类列表及其概率，以防您想要呈现照片中可能存在的前 3 个对象。
+
+我们将报告第一个最可能的对象。
+
+```
+from keras.applications.vgg16 import decode_predictions
+# convert the probabilities to class labels
+label = decode_predictions(yhat)
+# retrieve the most likely result, e.g. highest probability
+label = label[0][0]
+# print the classification
+print('%s (%.2f%%)' % (label[1], label[2]*100))
+```
+
+就是这样。
+
+### 完整的例子
+
+将所有这些结合在一起，下面列出了完整的示例：
+
+```
+from keras.preprocessing.image import load_img
+from keras.preprocessing.image import img_to_array
+from keras.applications.vgg16 import preprocess_input
+from keras.applications.vgg16 import decode_predictions
+from keras.applications.vgg16 import VGG16
+# load the model
+model = VGG16()
+# load an image from file
+image = load_img('mug.jpg', target_size=(224, 224))
+# convert the image pixels to a numpy array
+image = img_to_array(image)
+# reshape data for the model
+image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
+# prepare the image for the VGG model
+image = preprocess_input(image)
+# predict the probability across all output classes
+yhat = model.predict(image)
+# convert the probabilities to class labels
+label = decode_predictions(yhat)
+# retrieve the most likely result, e.g. highest probability
+label = label[0][0]
+# print the classification
+print('%s (%.2f%%)' % (label[1], label[2]*100))
+```
+
+运行该示例，我们可以看到图像被正确分类为“_ 咖啡杯 _”，可能性为 75％。
+
+```
+coffee_mug (75.27%)
+```
+
+## 扩展
+
+本节列出了一些扩展您可能希望探索的教程的想法。
+
+*   **创建一个函数**。更新示例并添加一个给定图像文件名的函数，加载的模型将返回分类结果。
+*   **命令行工具**。更新示例，以便在命令行上给出图像文件名，程序将报告图像的分类。
+*   **报告多个类**。更新示例以报告给定图像的前 5 个最可能的类及其概率。
+
+## 进一步阅读
+
+如果您要深入了解，本节将提供有关该主题的更多资源。
+
+*   [ImageNet](http://www.image-net.org/)
+*   [维基百科上的 ImageNet](https://en.wikipedia.org/wiki/ImageNet)
+*   [用于大规模图像识别的非常深的卷积网络](https://arxiv.org/abs/1409.1556)，2015 年。
+*   [用于大规模视觉识别的非常深的卷积网络](http://www.robots.ox.ac.uk/~vgg/research/very_deep/)，位于牛津大学。
+*   [使用非常少的数据建立强大的图像分类模型](https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html)，2016。
+*   [Keras Applications API](https://keras.io/applications/)
+*   [Keras 重量文件](https://github.com/fchollet/deep-learning-models/releases/)
+
+## 摘要
+
+在本教程中，您发现了用于图像分类的 VGG 卷积神经网络模型。
+
+具体来说，你学到了：
+
+*   关于 ImageNet 数据集和竞争以及 VGG 获奖模型。
+*   如何在 Keras 中加载 VGG 模型并总结其结构。
+*   如何使用加载的 VGG 模型对特定照片中的对象进行分类。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/using-learning-rate-schedules-deep-learning-models-python-keras.md b/docs/dl-keras/using-learning-rate-schedules-deep-learning-models-python-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..f7d4fe1cacccd4656ca2927c87ba6cf517ae81af
--- /dev/null
+++ b/docs/dl-keras/using-learning-rate-schedules-deep-learning-models-python-keras.md
@@ -0,0 +1,262 @@
+# 使用 Keras 在 Python 中使用学习速率计划进行深度学习模型
+
+> 原文： [https://machinelearningmastery.com/using-learning-rate-schedules-deep-learning-models-python-keras/](https://machinelearningmastery.com/using-learning-rate-schedules-deep-learning-models-python-keras/)
+
+训练神经网络或大型深度学习模型是一项困难的优化任务。
+
+训练神经网络的经典算法称为[随机梯度下降](http://machinelearningmastery.com/gradient-descent-for-machine-learning/)。已经确定，通过使用在训练期间发生变化的学习速率，您可以在某些问题上实现更高的性能和更快的训练。
+
+在这篇文章中，您将了解如何使用 Keras 深度学习库在 Python 中为神经网络模型使用不同的学习速率计划。
+
+阅读这篇文章后你会知道：
+
+*   如何配置和评估基于时间的学习速率计划。
+*   如何配置和评估基于丢弃的学习速率计划。
+
+让我们开始吧。
+
+*   **2017 年 3 月更新**：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
+
+![Using Learning Rate Schedules for Deep Learning Models in Python with Keras](img/6d16e08f6dc1ca8376aec45e7f10e5ac.jpg)
+
+使用 Keras
+在 Python 中使用深度学习模型的学习速率计划[哥伦比亚 GSAPP](https://www.flickr.com/photos/gsapponline/17050523800/) ，保留一些权利。
+
+## 培训模型的学习率表
+
+调整随机梯度下降优化程序的学习速率可以提高性能并缩短培训时间。
+
+有时这称为学习率退火或自适应学习率。在这里，我们将此方法称为学习速率计划，默认计划是使用恒定学习速率来更新每个训练时期的网络权重。
+
+在训练期间最简单且可能最常用的学习率调整是随时间降低学习率的技术。当使用较大的学习速率值时，这些具有在训练过程开始时进行大的改变的益处，并且降低学习速率，使得在训练过程中稍后对权重进行较小的速率并因此进行较小的训练更新。
+
+这具有早期快速学习良好权重并稍后对其进行微调的效果。
+
+两个流行且易于使用的学习率表如下：
+
+*   根据时代逐渐降低学习率。
+*   在特定时期使用间断大滴，降低学习率。
+
+接下来，我们将看看如何使用 Keras 依次使用这些学习率计划。
+
+## 基于时间的学习费率表
+
+Keras 内置了基于时间的学习率计划。
+
+SGD 类中的随机梯度下降优化算法实现具有称为衰减的参数。该参数用于基于时间的学习率衰减调度方程如下：
+
+```
+LearningRate = LearningRate * 1/(1 + decay * epoch)
+```
+
+当衰减参数为零（默认值）时，这对学习速率没有影响。
+
+```
+LearningRate = 0.1 * 1/(1 + 0.0 * 1)
+LearningRate = 0.1
+```
+
+当指定衰减参数时，它将使学习速率从前一个纪元减少给定的固定量。
+
+例如，如果我们使用 0.1 的初始学习率值和 0.001 的衰减，前 5 个时期将调整学习率如下：
+
+```
+Epoch	Learning Rate
+1	0.1
+2	0.0999000999
+3	0.0997006985
+4	0.09940249103
+5	0.09900646517
+```
+
+将其延伸到 100 个时期将产生以下学习率（y 轴）与时期（x 轴）的关系图：
+
+![Time-Based Learning Rate Schedule](img/81ba8599de669cbdd390ffde16096c83.jpg)
+
+基于时间的学习费率表
+
+您可以通过设置衰减值来创建一个不错的默认计划，如下所示：
+
+```
+Decay = LearningRate / Epochs
+Decay = 0.1 / 100
+Decay = 0.001
+```
+
+以下示例演示了在 Keras 中使用基于时间的学习速率适应计划。
+
+它在[电离层二元分类问题](http://archive.ics.uci.edu/ml/datasets/Ionosphere)上得到证实。这是一个小型数据集，您可以从 UCI 机器学习库下载[。使用文件名 ionosphere.csv 将数据文件放在工作目录中。](http://archive.ics.uci.edu/ml/machine-learning-databases/ionosphere/ionosphere.data)
+
+电离层数据集适用于使用神经网络进行实践，因为所有输入值都是相同比例的小数值。
+
+构建一个小型神经网络模型，其中一个隐藏层具有 34 个神经元并使用整流器激活函数。输出层具有单个神经元并使用 S 形激活函数以输出类似概率的值。
+
+随机梯度下降的学习率已设定为 0.1 的较高值。模型训练 50 个时期，衰减参数设置为 0.002，计算为 0.1 / 50。此外，在使用自适应学习速率时使用动量可能是个好主意。在这种情况下，我们使用动量值 0.8。
+
+下面列出了完整的示例。
+
+```
+# Time Based Learning Rate Decay
+from pandas import read_csv
+import numpy
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.optimizers import SGD
+from sklearn.preprocessing import LabelEncoder
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load dataset
+dataframe = read_csv("ionosphere.csv", header=None)
+dataset = dataframe.values
+# split into input (X) and output (Y) variables
+X = dataset[:,0:34].astype(float)
+Y = dataset[:,34]
+# encode class values as integers
+encoder = LabelEncoder()
+encoder.fit(Y)
+Y = encoder.transform(Y)
+# create model
+model = Sequential()
+model.add(Dense(34, input_dim=34, kernel_initializer='normal', activation='relu'))
+model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
+# Compile model
+epochs = 50
+learning_rate = 0.1
+decay_rate = learning_rate / epochs
+momentum = 0.8
+sgd = SGD(lr=learning_rate, momentum=momentum, decay=decay_rate, nesterov=False)
+model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy'])
+# Fit the model
+model.fit(X, Y, validation_split=0.33, epochs=epochs, batch_size=28, verbose=2)
+```
+
+该模型在 67％的数据集上进行训练，并使用 33％的验证数据集进行评估。
+
+运行该示例显示分类准确度为 99.14％。如果没有学习率下降或动量，这高于 95.69％的基线。
+
+```
+...
+Epoch 45/50
+0s - loss: 0.0622 - acc: 0.9830 - val_loss: 0.0929 - val_acc: 0.9914
+Epoch 46/50
+0s - loss: 0.0695 - acc: 0.9830 - val_loss: 0.0693 - val_acc: 0.9828
+Epoch 47/50
+0s - loss: 0.0669 - acc: 0.9872 - val_loss: 0.0616 - val_acc: 0.9828
+Epoch 48/50
+0s - loss: 0.0632 - acc: 0.9830 - val_loss: 0.0824 - val_acc: 0.9914
+Epoch 49/50
+0s - loss: 0.0590 - acc: 0.9830 - val_loss: 0.0772 - val_acc: 0.9828
+Epoch 50/50
+0s - loss: 0.0592 - acc: 0.9872 - val_loss: 0.0639 - val_acc: 0.9828
+```
+
+## 基于丢弃的学习率计划
+
+与深度学习模型一起使用的另一种流行的学习率计划是在训练期间的特定时间系统地降低学习率。
+
+通常，通过将学习速率降低每个固定数量的历元的一半来实现该方法。例如，我们可能具有 0.1 的初始学习率并且每 10 个时期将其降低 0.5。前 10 个训练时期将使用 0.1 的值，在接下来的 10 个时期中将使用 0.05 的学习率，依此类推。
+
+如果我们将此示例的学习率绘制到 100 个时期，您将得到下图，显示学习率（y 轴）与时期（x 轴）。
+
+![Drop Based Learning Rate Schedule](img/d9484ee640bb568aed750a19dbeb9547.jpg)
+
+基于丢弃的学习率计划
+
+在拟合模型时，我们可以使用 [LearningRateScheduler](http://keras.io/callbacks/) 回调在 Keras 中实现此功能。
+
+LearningRateScheduler 回调允许我们定义一个调用函数，该函数将纪元号作为参数，并返回用于随机梯度下降的学习速率。使用时，忽略随机梯度下降指定的学习率。
+
+在下面的代码中，我们在 Ionosphere 数据集上的单个隐藏层网络之前使用相同的示例。定义了一个新的 step_decay（）函数来实现等式：
+
+```
+LearningRate = InitialLearningRate * DropRate^floor(Epoch / EpochDrop)
+```
+
+其中，InitialLearningRate 是初始学习率，例如 0.1，DropRate 是每次更改学习率时修改的量，例如 0.5，Epoch 是当前的纪元号，EpochDrop 是改变学习率的频率，例如 10 。
+
+请注意，我们将 SGD 类中的学习速率设置为 0，以清楚地表明它未被使用。不过，如果您想在此学习率计划中使用动量，则可以设置新元的动量项。
+
+```
+# Drop-Based Learning Rate Decay
+import pandas
+from pandas import read_csv
+import numpy
+import math
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.optimizers import SGD
+from sklearn.preprocessing import LabelEncoder
+from keras.callbacks import LearningRateScheduler
+
+# learning rate schedule
+def step_decay(epoch):
+	initial_lrate = 0.1
+	drop = 0.5
+	epochs_drop = 10.0
+	lrate = initial_lrate * math.pow(drop, math.floor((1+epoch)/epochs_drop))
+	return lrate
+
+# fix random seed for reproducibility
+seed = 7
+numpy.random.seed(seed)
+# load dataset
+dataframe = read_csv("ionosphere.csv", header=None)
+dataset = dataframe.values
+# split into input (X) and output (Y) variables
+X = dataset[:,0:34].astype(float)
+Y = dataset[:,34]
+# encode class values as integers
+encoder = LabelEncoder()
+encoder.fit(Y)
+Y = encoder.transform(Y)
+# create model
+model = Sequential()
+model.add(Dense(34, input_dim=34, kernel_initializer='normal', activation='relu'))
+model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
+# Compile model
+sgd = SGD(lr=0.0, momentum=0.9, decay=0.0, nesterov=False)
+model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy'])
+# learning schedule callback
+lrate = LearningRateScheduler(step_decay)
+callbacks_list = [lrate]
+# Fit the model
+model.fit(X, Y, validation_split=0.33, epochs=50, batch_size=28, callbacks=callbacks_list, verbose=2)
+```
+
+运行该示例会导致验证数据集的分类准确率达到 99.14％，这也是问题模型基线的改进。
+
+```
+...
+Epoch 45/50
+0s - loss: 0.0546 - acc: 0.9830 - val_loss: 0.0634 - val_acc: 0.9914
+Epoch 46/50
+0s - loss: 0.0544 - acc: 0.9872 - val_loss: 0.0638 - val_acc: 0.9914
+Epoch 47/50
+0s - loss: 0.0553 - acc: 0.9872 - val_loss: 0.0696 - val_acc: 0.9914
+Epoch 48/50
+0s - loss: 0.0537 - acc: 0.9872 - val_loss: 0.0675 - val_acc: 0.9914
+Epoch 49/50
+0s - loss: 0.0537 - acc: 0.9872 - val_loss: 0.0636 - val_acc: 0.9914
+Epoch 50/50
+0s - loss: 0.0534 - acc: 0.9872 - val_loss: 0.0679 - val_acc: 0.9914
+```
+
+## 使用学习率计划的提示
+
+本节列出了在使用神经网络学习速率计划时要考虑的一些提示和技巧。
+
+*   **提高初始学习率**。因为学习率很可能会降低，所以从较大的值开始减少。较大的学习率将导致权重的更大变化，至少在开始时，允许您稍后从微调中受益。
+*   **使用大动量**。当您的学习速率缩小到较小值时，使用较大的动量值将有助于优化算法继续在正确的方向上进行更新。
+*   **尝试不同的时间表**。目前还不清楚使用哪种学习速率计划，因此请尝试使用不同的配置选项，看看哪种方法最适合您的问题。还可以尝试以指数方式更改的计划，甚至可以计划响应模型在训练或测试数据集上的准确性的计划。
+
+## 摘要
+
+在这篇文章中，您发现了用于训练神经网络模型的学习率计划。
+
+阅读这篇文章后，您了解到：
+
+*   如何在 Keras 中配置和使用基于时间的学习费率表。
+*   如何在 Keras 开发自己的基于 drop 的学习率计划。
+
+您对神经网络或此帖子的学习速率表有任何疑问吗？在评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/visualize-deep-learning-neural-network-model-keras.md b/docs/dl-keras/visualize-deep-learning-neural-network-model-keras.md
new file mode 100644
index 0000000000000000000000000000000000000000..3c06f6e5c0c1f1e55eda847a9b1bac39f4fbfd07
--- /dev/null
+++ b/docs/dl-keras/visualize-deep-learning-neural-network-model-keras.md
@@ -0,0 +1,157 @@
+# 如何在 Keras 中可视化深度学习神经网络模型
+
+> 原文： [https://machinelearningmastery.com/visualize-deep-learning-neural-network-model-keras/](https://machinelearningmastery.com/visualize-deep-learning-neural-network-model-keras/)
+
+Keras Python 深度学习库提供了可视化和更好地理解您的神经网络模型的工具。
+
+在本教程中，您将发现如何在 Keras 中总结和可视化您的深度学习模型。
+
+完成本教程后，您将了解：
+
+*   如何创建深度学习模型的文本摘要。
+*   如何创建深度学习模型的图形图。
+*   在 Keras 开发深度学习模型时的最佳实践技巧。
+
+让我们开始吧。
+
+![How to Visualize a Deep Learning Neural Network Model in Keras](img/ae4bbe3728d2ae14a8486fd00fc87a8b.jpg)
+
+如何在 Keras 中可视化深度学习神经网络模型
+照片由 [Ed Dunens](https://www.flickr.com/photos/blachswan/14990404869/) ，保留一些权利。
+
+## 教程概述
+
+本教程分为 4 个部分;他们是：
+
+1.  示例模型
+2.  总结模型
+3.  可视化模型
+4.  最佳实践技巧
+
+## 示例模型
+
+我们可以从 Keras 中定义一个简单的多层感知器模型开始，我们可以将其用作摘要和可视化的主题。
+
+我们将定义的模型有一个输入变量，一个带有两个神经元的隐藏层，以及一个带有一个二进制输出的输出层。
+
+例如：
+
+```
+[1 input] -> [2 neurons] -> [1 output]
+```
+
+下面提供了该网络的代码清单。
+
+```
+from keras.models import Sequential
+from keras.layers import Dense
+model = Sequential()
+model.add(Dense(2, input_dim=1, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+```
+
+## 总结模型
+
+Keras 提供了一种总结模型的方法。
+
+摘要是文本性的，包括以下信息：
+
+*   层和它们在模型中的顺序。
+*   每层的输出形状。
+*   每层中的参数（权重）数。
+*   模型中的参数（权重）总数。
+
+可以通过调用模型上的 _summary（）_ 函数来创建摘要，该函数返回可以打印的字符串。
+
+下面是打印已创建模型摘要的更新示例。
+
+```
+from keras.models import Sequential
+from keras.layers import Dense
+model = Sequential()
+model.add(Dense(2, input_dim=1, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+print(model.summary())
+```
+
+运行此示例将打印下表。
+
+```
+_________________________________________________________________
+Layer (type)                 Output Shape              Param #
+=================================================================
+dense_1 (Dense)              (None, 2)                 4
+_________________________________________________________________
+dense_2 (Dense)              (None, 1)                 3
+=================================================================
+Total params: 7
+Trainable params: 7
+Non-trainable params: 0
+_________________________________________________________________
+```
+
+我们可以清楚地看到每层的输出形状和权重数量。
+
+## 可视化模型
+
+摘要对于简单模型很有用，但对于具有多个输入或输出的模型可能会造成混淆。
+
+Keras 还提供了创建网络神经网络图的功能，可以使更复杂的模型更容易理解。
+
+Keras 中的 _plot_model（）_ 功能将创建您的网络图。这个函数有一些有用的参数：
+
+*   _ 型号 _ :(必填）您想要绘制的模型。
+*   _to_file_ :(必需）要保存绘图的文件的名称。
+*   _show_shapes_ :(可选，默认为 _False_ ）是否显示每个图层的输出形状。
+*   _show_layer_names_ :(可选，默认为 _True_ ）是否显示每个图层的名称。
+
+下面是绘制创建模型的更新示例。
+
+注意，该示例假设您已安装 [graphviz 图形库](http://www.graphviz.org/)和 [Python 接口](https://pypi.python.org/pypi/graphviz)。
+
+```
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.utils.vis_utils import plot_model
+model = Sequential()
+model.add(Dense(2, input_dim=1, activation='relu'))
+model.add(Dense(1, activation='sigmoid'))
+plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
+```
+
+运行该示例将创建文件 _model_plot.png_ ，其中包含已创建模型的图。
+
+![Plot of Neural Network Model Graph](img/cd2ea0cb6ea3f16f73d52c1580d22310.jpg)
+
+神经网络模型图的绘制
+
+## 最佳实践技巧
+
+我通常建议始终在 Keras 中创建神经网络模型的摘要和图表。
+
+我推荐这个有几个原因：
+
+*   **确认图层顺序**。使用顺序 API 以错误的顺序添加图层或使用功能 API 错误地将它们连接在一起很容易。图表图可以帮助您确认模型是否按照您预期的方式连接。
+*   **确认每层的输出形状**。在定义复杂网络（如卷积和递归神经网络）的输入数据形状时，常常会遇到问题。摘要和图表可以帮助您确认网络的输入形状是否符合您的预期。
+*   **确认参数**。一些网络配置可以使用更少的参数，例如在编码器 - 解码器递归神经网络中使用 _TimeDistributed_ 包裹的密集层。查看摘要可以帮助发现使用远远超出预期的参数的情况。
+
+## 进一步阅读
+
+如果您希望深入了解，本节将提供有关该主题的更多资源。
+
+*   [模型可视化 Keras API](https://keras.io/visualization/)
+*   [Graphviz - 图形可视化软件](http://www.graphviz.org/)
+*   [Graphviz 的简单 Python 接口](https://pypi.python.org/pypi/graphviz)
+
+## 摘要
+
+在本教程中，您了解了如何在 Keras 中总结和可视化您的深度学习模型。
+
+具体来说，你学到了：
+
+*   如何创建深度学习模型的文本摘要。
+*   如何创建深度学习模型的图形图。
+*   在 Keras 开发深度学习模型时的最佳实践技巧。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/what-is-deep-learning.md b/docs/dl-keras/what-is-deep-learning.md
new file mode 100644
index 0000000000000000000000000000000000000000..e9c040311100d47e3d769699f9d884ad5ae0fc41
--- /dev/null
+++ b/docs/dl-keras/what-is-deep-learning.md
@@ -0,0 +1,189 @@
+# 什么是深度学习？
+
+> 原文： [https://machinelearningmastery.com/what-is-deep-learning/](https://machinelearningmastery.com/what-is-deep-learning/)
+
+深度学习是机器学习的一个子领域，涉及受大脑结构和功能激发的算法，称为人工神经网络。
+
+如果你刚刚开始深度学习领域，或者你曾经有过神经网络的经验，你可能会感到困惑。我知道我最初很困惑，许多同事和朋友在 20 世纪 90 年代和 21 世纪初学习和使用神经网络也是如此。
+
+该领域的领导者和专家对深度学习的观点有所了解，这些具体而细微的观点为深度学习的内容提供了很多依据。
+
+在这篇文章中，您将通过听取该领域的一系列专家和领导者的确切了解深度学习的内容。
+
+让我们潜入。
+
+![What is Deep Learning?](img/17428dfdb9702ab6ce021befb3d7b812.jpg)
+
+什么是深度学习？
+[Kiran Foster](https://www.flickr.com/photos/rueful/7885846128/) 的照片，保留一些权利。
+
+## 深度学习是大型神经网络
+
+[来自百度研究院 Coursera 和首席科学家的 Andrew Ng](https://en.wikipedia.org/wiki/Andrew_Ng) 正式成立了 [Google Brain](https://en.wikipedia.org/wiki/Google_Brain) ，最终导致了大量 Google 服务中深度学习技术的产品化。
+
+他已经说了很多关于深度学习的内容并写了很多，并且是一个很好的起点。
+
+在深度学习的早期讨论中，安德鲁描述了传统人工神经网络背景下的深度学习。在 2013 年题为“[深度学习，自学习和无监督特征学习](https://www.youtube.com/watch?v=n1ViNeWhC24)”的演讲中，他将深度学习的理念描述为：
+
+> 使用大脑模拟，希望：
+> 
+> - 使学习算法更好，更容易使用。
+> 
+> - 在机器学习和人工智能方面取得革命性进展。
+> 
+> 我相信这是我们迈向真正人工智能的最好机会
+
+后来他的评论变得更加细致入微了。
+
+根据安德鲁的深度学习的核心是我们现在拥有足够快的计算机和足够的数据来实际训练大型神经网络。在讨论为什么现在是 2015 年 ExtractConf 在深度学习的时候，题为“[科学家应该了解的关于深度学习](https://www.youtube.com/watch?v=O0VN0pGgBZM)的数据”，他评论说：
+
+> 我们现在拥有的非常大的神经网络......以及我们可以访问的大量数据
+
+他还评论了关于规模的重要观点。当我们构建更大的神经网络并用越来越多的数据训练它们时，它们的性能会不断提高。这通常与其他在性能上达到稳定水平的机器学习技术不同。
+
+> 对于旧代学习算法的大多数风格......性能将达到稳定水平。 ......深度学习......是第一类算法......可扩展。 ...随着您提供更多数据，性能会不断提高
+
+他在幻灯片中提供了一个漂亮的卡通片：
+
+![Why Deep Learning?](img/7e971b08f1a9d6b073c9659bc13010e5.jpg)
+
+为何深度学习？
+滑动 [Andrew Ng](http://www.slideshare.net/ExtractConf) ，保留所有权利。
+
+最后，他清楚地指出，我们在实践中看到的深度学习的好处来自有监督的学习。从 2015 年的 ExtractConf 演讲中，他评论道：
+
+> 今天深度学习的几乎所有价值都是通过有监督的学习或从标记数据中学习
+
+早些时候，斯坦福大学在 2014 年的一次题为“[深度学习](https://www.youtube.com/watch?v=W15K9PegQt0)”的演讲中，他做了类似的评论：
+
+> 深度学习像疯了一样起飞的一个原因是因为它在监督学习中很棒
+
+安德鲁经常提到我们应该并且会看到更多的好处来自轨道的无人监督的一面，因为该领域已经成熟，可以处理大量未标记的数据。
+
+[Jeff Dean](https://en.wikipedia.org/wiki/Jeff_Dean_(computer_scientist)) 是 Google 的系统和基础设施小组的向导和谷歌高级研究员，并参与并可能部分负责 Google 内部深度学习的扩展和采用。 Jeff 参与了 Google Brain 项目以及大型深度学习软件 DistBelief 和后来的 TensorFlow 的开发。
+
+在 2016 年题为“[建立智能计算机系统深度学习](https://www.youtube.com/watch?v=QSaZGT4-6EY)”的演讲中，他以类似的方式发表评论，深度学习实际上是关于大型神经网络的。
+
+> 当你听到深度学习这个词的时候，就想想一个大的深度神经网络。深度指的是典型的层数，因此这种流行术语在印刷机中被采用。我认为它们通常是深度神经网络。
+
+他已经多次发表过这个演讲，并且在[改进的幻灯片中为同一个演讲](http://static.googleusercontent.com/media/research.google.com/en//people/jeff/BayLearn2015.pdf)，他强调了神经网络的可扩展性，表明随着更多的数据和更大的模型，结果会变得更好更多计算训练。
+
+![Results Get Better With More Data, Larger Models, More Compute](img/f12c1bb681a84a2372eacda56b1aeadc.jpg)
+
+结果更好，更多数据，更大型号，更多计算
+滑动 [Jeff Dean](http://static.googleusercontent.com/media/research.google.com/en//people/jeff/BayLearn2015.pdf) ，保留所有权利。
+
+## 深度学习是分层特征学习
+
+除了可扩展性之外，深度学习模型的另一个经常被引用的好处是它们能够从原始数据执行自动特征提取，也称为[特征学习](https://en.wikipedia.org/wiki/Feature_learning)。
+
+[Yoshua Bengio](https://en.wikipedia.org/wiki/Yoshua_Bengio) 是深度学习的另一个领导者，尽管他开始对大型神经网络能够实现的自动特征学习产生浓厚的兴趣。
+
+他描述了使用特征学习发现和学习良好表示的算法能力方面的深度学习。在 2012 年题为“[深度学习无监督和转移学习的表达](http://www.jmlr.org/proceedings/papers/v27/bengio12a/bengio12a.pdf)”的论文中，他评论道：
+
+> 深度学习算法试图利用输入分布中的未知结构，以便通常在多个级别上发现良好的表示，并使用较低级别的特征定义更高级别的学习特征
+
+他在 2009 年的技术报告“[为 AI](http://www.iro.umontreal.ca/~lisa/publications2/index.php/publications/show/239) 学习深层架构”中提供了深入学习的详细视角，其中强调了特征学习中层次结构的重要性。
+
+> 深度学习方法旨在学习具有来自较低级别特征的组成所形成的较高级别的层级的特征的特征层级。在多个抽象级别自动学习功能允许系统学习直接从数据将输入映射到输出的复杂功能，而不完全依赖于人工制作的功能。
+
+在即将出版的名为“[深度学习](http://www.deeplearningbook.org)”的书中，他与 Ian Goodfellow 和 Aaron Courville 合着，他们根据模型的架构深度来定义深度学习。
+
+> 概念的层次结构允许计算机通过用简单的概念构建它们来学习复杂的概念。如果我们绘制一个图表来显示这些概念是如何相互构建的，那么图表很深，有很多层。出于这个原因，我们将这种方法称为 AI 深度学习。
+
+这是一本重要的书，有可能在一段时间内成为该领域的权威资源。本书继续描述多层感知器作为深度学习领域中使用的算法，给出了深度学习已包含在人工神经网络中的观点。
+
+> 深度学习模型的典型例子是前馈深度网络或多层感知器（MLP）。
+
+[Peter Norvig](https://en.wikipedia.org/wiki/Peter_Norvig) 是谷歌研究部主任，以其题为“[人工智能：现代方法](http://www.amazon.com/dp/0136042597?tag=inspiredalgor-20)”的人工智能教科书而闻名。
+
+在 2016 年的一次演讲中，他给出了题为“[深度学习和可理解性与软件工程和验证](https://www.youtube.com/watch?v=X769cyzBNVw)”的内容，他以与 Yoshua 非常相似的方式定义了深度学习，重点关注使用更深层网络结构所允许的抽象功能。
+
+> 一种学习，你形成的表示有几个抽象层次，而不是输出的直接输入
+
+## 为什么称它为“深度学习”？
+为什么不只是“人工神经网络”？
+
+[Geoffrey Hinton](https://en.wikipedia.org/wiki/Geoffrey_Hinton) 是人工神经网络领域的先驱，并共同发表了关于[反向传播](https://en.wikipedia.org/wiki/Backpropagation)算法的第一篇论文，用于训练多层感知器网络。
+
+他可能已经开始引入措辞“ _deep_ ”来描述大型人工神经网络的发展。
+
+他在 2006 年共同撰写了一篇题为“[深度信念网快速学习算法](http://www.mitpressjournals.org/doi/pdf/10.1162/neco.2006.18.7.1527)”的论文，其中描述了一种训练“深度”（如在多层网络中）受限制的 Boltzmann 机器的方法。
+
+> 使用互补先验，我们推导出一种快速，贪婪的算法，可以一次一层地学习深层定向信念网络，前提是前两层形成一个无向联想记忆。
+
+本文和 Geoff 在一个无向深度网络上共同撰写的题为“ [Deep Boltzmann Machines](http://www.jmlr.org/proceedings/papers/v5/salakhutdinov09a/salakhutdinov09a.pdf) ”的相关论文得到了社区的好评（现已引用数百次），因为它们是贪婪层的成功例子 - 明智的网络培训，在前馈网络中允许更多层。
+
+在科学的一篇题为“[用神经网络降低数据维度](https://www.cs.toronto.edu/~hinton/science.pdf)”的共同撰写的文章中，他们坚持使用相同的“深度”描述来描述他们开发网络的方法，这些网络的层数比以前更多。
+
+> 我们描述了一种初始化权重的有效方法，它允许深度自动编码器网络学习低维度代码，这些代码比主成分分析更好地作为减少数据维度的工具。
+
+在同一篇文章中，他们发表了一篇有趣的评论，与 Andrew Ng 关于最近计算能力的提高以及对大型数据集的访问的评论相互关联，这些数据集在大规模使用时释放了神经网络尚未开发的能力。
+
+> 自 20 世纪 80 年代以来，显而易见的是，通过深度自动编码器的反向传播对于非线性降维是非常有效的，只要计算机足够快，数据集足够大，并且初始权重足够接近良好的解决方案。现在满足所有这三个条件。
+
+在 2016 年皇家学会题为“[深度学习](https://www.youtube.com/watch?v=VhmE_UXDOGs)”的演讲中，Geoff 评论说深度信念网络是 2006 年深度学习的开始，并且这一新的深度学习浪潮的首次成功应用是 2009 年的语音识别标题为“[声学建模使用深度信念网络](http://www.cs.toronto.edu/~asamir/papers/speechDBN_jrnl.pdf)”，实现了最先进的结果。
+
+结果使语音识别和神经网络社区注意到，使用“深度”作为先前神经网络技术的差异因素，可能导致名称改变。
+
+皇家学会谈话中对深度学习的描述非常反向传播，正如您所期望的那样。有趣的是，他提出了为什么反向传播（读“深度学习”）在上世纪 90 年代没有起飞的 4 个原因。前两点与安德鲁·吴（Andrew Ng）的评论相符，关于数据集太小而计算机太慢。
+
+![What Was Actually Wrong With Backpropagation in 1986?](img/fba7c01fd78761e808c4f093eff4ccd1.jpg)
+
+1986 年背向传播实际上是错误的？
+滑动 [Geoff Hinton](https://www.youtube.com/watch?v=VhmE_UXDOGs) ，保留所有权利。
+
+## 深度学习作为跨域的可扩展学习
+
+深度学习在输入（甚至输出）是模拟的问题域上表现优异。意思是，它们不是表格格式的少量数量，而是像素数据，文本数据文档或音频数据文件的图像。
+
+[Yann LeCun](https://en.wikipedia.org/wiki/Yann_LeCun) 是 Facebook Research 的主管，是网络架构之父，擅长图像数据中的对象识别，称为[卷积神经网络（CNN）](http://machinelearningmastery.com/crash-course-convolutional-neural-networks/)。这种技术看起来非常成功，因为像多层感知器前馈神经网络一样，该技术可以根据数据和模型大小进行扩展，并且可以通过反向传播进行训练。
+
+这使他对深度学习的定义偏向于非常大的 CNN 的发展，这些 CNN 在照片中的对象识别方面取得了巨大成功。
+
+在劳伦斯利弗莫尔国家实验室 2016 年的一次题为“[加速理解：深度学习，智能应用和 GPU](https://www.youtube.com/watch?v=Qk4SqF9FT-M) ”的演讲中，他将深度学习描述为学习层次表示，并将其定义为构建对象识别系统的可扩展方法：
+
+> 深度学习[是] ...所有可训练的模块管道。 ......因为在识别一个物体的过程中有多个阶段，所有这些阶段都是训练的一部分“
+
+![Deep Learning = Learning Hierarchical Representations](img/662da48b47adc3aaeccc61fa6245b2a0.jpg)
+
+深度学习=学习等级表示
+滑动 [Yann LeCun](https://www.youtube.com/watch?v=Qk4SqF9FT-M) ，保留所有权利。
+
+[Jurgen Schmidhuber](https://en.wikipedia.org/wiki/J%C3%BCrgen_Schmidhuber) 是另一种流行算法的父亲，它像 MLP 和 CNN 一样也可以根据模型大小和数据集大小进行扩展，并且可以通过反向传播进行训练，而是针对学习序列数据进行定制，称为 [Long 短期记忆网络（LSTM）](http://machinelearningmastery.com/crash-course-recurrent-neural-networks-deep-learning/)，一种递归神经网络。
+
+我们确实看到在该领域的措辞中存在一些混淆，即“深度学习”。在 2014 年题为“[神经网络中的深度学习：概述](http://arxiv.org/pdf/1404.7828v4.pdf)”的论文中，他对该领域的问题命名以及深度与浅层学习的区分进行了评论。他还有趣地描述了问题复杂性的深度，而不是用于解决问题的模型。
+
+> Shallow Learning 在哪个问题深度结束，深度学习开始了？与 DL 专家的讨论尚未对这一问题作出结论性回应。 [...]，让我只为此概述的目的定义：深度问题＆gt; 10 需要非常深度学习。
+
+[Demis Hassabis](https://en.wikipedia.org/wiki/Demis_Hassabis) 是 [DeepMind](https://deepmind.com/) 的创始人，后来被谷歌收购。 DeepMind 突破了将深度学习技术与强化学习相结合，以处理复杂的学习问题，如玩游戏，在玩 Atari 游戏和游戏 Go with Alpha Go 时出类拔萃。
+
+为了与命名保持一致，他们将他们的新技术称为深度 Q 网络，将深度学习与 Q-Learning 结合起来。他们还将更广泛的研究领域命名为“深层强化学习”。
+
+在他们的 2015 年自然论文题为“[通过深度强化学习](http://www.nature.com/nature/journal/v518/n7540/full/nature14236.html)进行人类控制”中，他们评论了深度神经网络在突破中的重要作用，并强调了对分层抽象的需求。
+
+> 为了实现这一目标，我们开发了一种新型代理，一种深度 Q 网络（DQN），它能够将强化学习与一类称为深度神经网络的人工神经网络相结合。值得注意的是，深度神经网络的最新进展使得人工神经网络可以直接从原始传感数据中学习诸如对象类别之类的概念，其中使用若干层节点来逐渐建立数据的抽象表示。
+
+最后，在可能被认为是该领域的定义论文中，Yann LeCun，Yoshua Bengio 和 Geoffrey Hinton 在自然界发表了一篇题为“[深度学习](http://www.nature.com/nature/journal/v521/n7553/full/nature14539.html)”的论文。在其中，他们打开了一个清晰的深度学习定义，突出了多层次的方法。
+
+> 深度学习允许由多个处理层组成的计算模型来学习具有多个抽象级别的数据表示。
+
+后来，在表示学习和抽象方面描述了多层方法。
+
+> 深度学习方法是具有多个表示级别的表示学习方法，通过组合简单但非线性的模块获得，每个模块将表示在一个级别（从原始输入开始）转换为更高，稍微更抽象级别的表示。 [...]深度学习的关键方面是这些功能层不是由人类工程师设计的：它们是使用通用学习程序从数据中学习的。
+
+这是一个很好的通用描述，可以很容易地描述大多数人工神经网络算法。这也是一个很好的结束。
+
+## 摘要
+
+在这篇文章中，您发现深度学习只是对更多数据的非常大的神经网络，需要更大的计算机。
+
+虽然 Hinton 和合作者发表的早期方法侧重于贪婪的分层训练和无监督方法，如自动编码器，但现代最先进的深度学习主要集中在使用反向传播算法训练深层（多层）神经网络模型。最流行的技术是：
+
+*   多层感知器网络。
+*   卷积神经网络。
+*   长短期记忆回归神经网络。
+
+我希望这已经清除了深层学习的内容以及领导定义如何在一个保护伞下融合在一起。
+
+如果您对深度学习或此帖有任何疑问，请在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/when-to-use-mlp-cnn-and-rnn-neural-networks.md b/docs/dl-keras/when-to-use-mlp-cnn-and-rnn-neural-networks.md
new file mode 100644
index 0000000000000000000000000000000000000000..dd406eed1653885a37b6e743e73d58cd5a6f6c7e
--- /dev/null
+++ b/docs/dl-keras/when-to-use-mlp-cnn-and-rnn-neural-networks.md
@@ -0,0 +1,222 @@
+# 何时使用 MLP，CNN 和 RNN 神经网络
+
+> 原文： [https://machinelearningmastery.com/when-to-use-mlp-cnn-and-rnn-neural-networks/](https://machinelearningmastery.com/when-to-use-mlp-cnn-and-rnn-neural-networks/)
+
+**什么神经网络适合您的预测建模问题？**
+
+对于初学者来说，深度学习领域很难知道要使用什么类型的网络。有许多类型的网络可供选择，每天都会发布和讨论新的方法。
+
+更糟糕的是，大多数神经网络足够灵活，即使在使用错误类型的数据或预测问题时也可以工作（进行预测）。
+
+在这篇文章中，您将发现三种主要类型的人工神经网络的建议用法。
+
+阅读这篇文章后，你会知道：
+
+*   在处理预测建模问题时要关注哪种类型的神经网络。
+*   何时使用，不使用，并可能尝试在项目中使用 MLP，CNN 和 RNN。
+*   在选择模型之前，要考虑使用混合模型并清楚了解项目目标。
+
+让我们开始吧。
+
+![When to Use MLP, CNN, and RNN Neural Networks](img/070851788dabfc54104852fe22f56b44.jpg)
+
+何时使用 MLP，CNN 和 RNN 神经网络
+照片由 [PRODAVID S. FERRY III，DDS](https://www.flickr.com/photos/drdavidferry/15365735518/) ，保留一些权利。
+
+## 概观
+
+这篇文章分为五个部分;他们是：
+
+1.  什么神经网络要关注？
+2.  何时使用多层感知器？
+3.  何时使用卷积神经网络？
+4.  何时使用递归神经网络？
+5.  混合网络模型
+
+## 什么神经网络要关注？
+
+[深度学习](https://machinelearningmastery.com/what-is-deep-learning/)是使用现代硬件的人工神经网络的应用。
+
+它允许开发，训练和使用比以前认为可能更大（更多层）的神经网络。
+
+研究人员提出了数千种类型的特定神经网络，作为对现有模型的修改或调整。有时是全新的方法。
+
+作为一名从业者，我建议您等到模型出现后普遍适用。很难从每天或每周发布的大量出版物的噪音中梳理出一般效果良好的信号。
+
+有三类人工神经网络我建议您一般关注。他们是：
+
+*   多层感知器（MLP）
+*   卷积神经网络（CNN）
+*   递归神经网络（RNN）
+
+这三类网络提供了很大的灵活性，并且经过数十年的证明，它们在各种各样的问题中都是有用和可靠的。他们还有许多子类型来帮助他们专注于预测问题和不同数据集的不同框架的怪癖。
+
+现在我们知道要关注哪些网络，让我们看看何时可以使用每一类神经网络。
+
+## 何时使用多层感知器？
+
+多层感知器（简称 MLP）是经典类型的神经网络。
+
+它们由一层或多层神经元组成。数据被馈送到输入层，可能存在提供抽象级别的一个或多个隐藏层，并且在输出层（也称为可见层）上进行预测。
+
+有关 MLP 的更多详细信息，请参阅帖子：
+
+*   [多层感知器神经网络速成课程](https://machinelearningmastery.com/neural-networks-crash-course/)
+
+![Model of a Simple Network](img/98d0e7f8e58b0a5cb817d172e0256fe0.jpg)
+
+简单网络的模型
+
+MLP 适用于分类预测问题，其中输入被分配类或标签。
+
+它们也适用于回归预测问题，其中在给定一组输入的情况下预测实值数量。数据通常以表格格式提供，例如您可以在 CSV 文件或电子表格中看到。
+
+**使用 MLP：**
+
+*   表格数据集
+*   分类预测问题
+*   回归预测问题
+
+它们非常灵活，通常可用于学习从输入到输出的映射。
+
+这种灵活性允许它们应用于其他类型的数据。例如，图像的像素可以减少到一行长数据并馈送到 MLP 中。文档的单词也可以缩减为一行长数据并馈送到 MLP。甚至对时间序列预测问题的滞后观察也可以减少为长行数据并馈送到 MLP。
+
+因此，如果您的数据采用的不是表格数据集，例如图像，文档或时间序列，我建议至少测试一个 MLP 来解决您的问题。结果可用作比较的基线点，以确认可能看起来更适合的其他模型增加价值。
+
+**试用 MLP：**
+
+*   图像数据
+*   文本数据
+*   时间序列数据
+*   其他类型的数据
+
+## 何时使用卷积神经网络？
+
+卷积神经网络（CNN）被设计用于将图像数据映射到输出变量。
+
+事实证明它们非常有效，它们是涉及图像数据作为输入的任何类型的预测问题的首选方法。
+
+有关 CNN 的更多详细信息，请参阅帖子：
+
+*   [用于机器学习的卷积神经网络的速成课程](https://machinelearningmastery.com/crash-course-convolutional-neural-networks/)
+
+使用 CNN 的好处是它们能够开发二维图像的内部表示。这允许模型在数据中的变体结构中学习位置和比例，这在处理图像时很重要。
+
+**使用 CNN：**
+
+*   图像数据
+*   分类预测问题
+*   回归预测问题
+
+更一般地，CNN 与具有空间关系的数据一起工作良好。
+
+CNN 输入传统上是二维的，场或矩阵，但也可以改变为一维，允许它开发一维序列的内部表示。
+
+这允许 CNN 更普遍地用于具有空间关系的其他类型的数据。例如，文本文档中的单词之间存在顺序关系。在时间序列的时间步长中存在有序关系。
+
+虽然不是专门为非图像数据开发的，但 CNN 在诸如情绪分析中使用的文档分类和相关问题等问题上实现了最先进的结果。
+
+**尝试打开 CNN：**
+
+*   文字数据
+*   时间序列数据
+*   序列输入数据
+
+## 何时使用递归神经网络？
+
+回归神经网络（RNN）被设计用于处理序列预测问题。
+
+序列预测问题有多种形式，最好用支持的输入和输出类型来描述。
+
+序列预测问题的一些例子包括：
+
+*   **一对多**：作为输入的观察映射到具有多个步骤作为输出的序列。
+*   **多对一**：作为输入映射到类或数量预测的多个步骤的序列。
+*   **多对多**：作为输入的多个步骤的序列映射到具有多个步骤作为输出的序列。
+
+多对多问题通常被称为序列到序列，或简称为 seq2seq。
+
+有关序列预测问题类型的更多详细信息，请参阅帖子：
+
+*   [回归神经网络序列预测模型的简要介绍](https://machinelearningmastery.com/models-sequence-prediction-recurrent-neural-networks/)
+
+传统的神经网络传统上难以训练。
+
+长短期内存或 LSTM 网络可能是最成功的 RNN，因为它克服了训练经常性网络的问题，并且反过来已经用于广泛的应用。
+
+有关 RNN 的更多详细信息，请参阅帖子：
+
+*   [深度学习的回归神经网络崩溃课程](https://machinelearningmastery.com/crash-course-recurrent-neural-networks-deep-learning/)
+
+一般而言，RNNs 和 LSTM 在处理单词和段落序列时最为成功，通常称为自然语言处理。
+
+这包括以时间序列表示的文本序列和口语序列。它们还用作生成模型，需要序列输出，不仅需要文本，还需要生成手写等应用程序。
+
+**使用 RNN：**
+
+*   文字数据
+*   语音数据
+*   分类预测问题
+*   回归预测问题
+*   生成模型
+
+正如您在 CSV 文件或电子表格中看到的那样，递归神经网络不适用于表格数据集。它们也不适合图像数据输入。
+
+**请勿使用 RNN：**
+
+*   表格数据
+*   图像数据
+
+RNN 和 LSTM 已经在时间序列预测问题上进行了测试，但结果却很差，至少可以说。自回归方法，甚至线性方法通常表现得更好。 LSTM 通常优于应用于相同数据的简单 MLP。
+
+有关此主题的更多信息，请参阅帖子：
+
+*   [关于长短期记忆网络对时间序列预测的适用性](https://machinelearningmastery.com/suitability-long-short-term-memory-networks-time-series-forecasting/)
+
+然而，它仍然是一个活跃的领域。
+
+**也许尝试使用 RNN：**
+
+*   时间序列数据
+
+## 混合网络模型
+
+CNN 或 RNN 模型很少单独使用。
+
+这些类型的网络在更广泛的模型中用作层，其也具有一个或多个 MLP 层。从技术上讲，这些是混合类型的神经网络架构。
+
+也许最有趣的工作来自将不同类型的网络混合在一起成为混合模型。
+
+例如，考虑使用一堆层的模型，其中输入为 CNN，中间为 LSTM，输出为 MLP。像这样的模型可以读取一系列图像输入，例如视频，并生成预测。这被称为 [CNN LSTM 架构](https://machinelearningmastery.com/cnn-long-short-term-memory-networks/)。
+
+网络类型也可以堆叠在特定的体系结构中以解锁新功能，例如可重复使用的图像识别模型，这些模型使用非常深的 CNN 和 MLP 网络，可以添加到新的 LSTM 模型并用于字幕照片。此外，编码器 - 解码器 LSTM 网络可用于具有不同长度的输入和输出序列。
+
+重要的是要先清楚地了解您和您的利益相关者对项目的要求，然后寻找满足您特定项目需求的网络架构（或开发一个）。
+
+有关帮助您考虑数据和预测问题的良好框架，请参阅帖子：
+
+*   [如何定义机器学习问题](https://machinelearningmastery.com/how-to-define-your-machine-learning-problem/)
+
+## 进一步阅读
+
+如果您希望深入了解，本节将提供有关该主题的更多资源。
+
+*   [什么是深度学习？](https://machinelearningmastery.com/what-is-deep-learning/)
+*   [多层感知器神经网络速成课程](https://machinelearningmastery.com/neural-networks-crash-course/)
+*   [用于机器学习的卷积神经网络的速成课程](https://machinelearningmastery.com/crash-course-convolutional-neural-networks/)
+*   [深度学习的回归神经网络崩溃课程](https://machinelearningmastery.com/crash-course-recurrent-neural-networks-deep-learning/)
+*   [回归神经网络序列预测模型的简要介绍](https://machinelearningmastery.com/models-sequence-prediction-recurrent-neural-networks/)
+*   [如何定义机器学习问题](https://machinelearningmastery.com/how-to-define-your-machine-learning-problem/)
+
+## 摘要
+
+在这篇文章中，您发现了三种主要人工神经网络的建议用法。
+
+具体来说，你学到了：
+
+*   在处理预测建模问题时要关注哪种类型的神经网络。
+*   何时使用，不使用，并可能尝试在项目中使用 MLP，CNN 和 RNN。
+*   在选择模型之前，要考虑使用混合模型并清楚了解项目目标。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file
diff --git a/docs/dl-keras/why-initialize-a-neural-network-with-random-weights.md b/docs/dl-keras/why-initialize-a-neural-network-with-random-weights.md
new file mode 100644
index 0000000000000000000000000000000000000000..8e2f63df5cc81811c581d5459db59a275b41a686
--- /dev/null
+++ b/docs/dl-keras/why-initialize-a-neural-network-with-random-weights.md
@@ -0,0 +1,231 @@
+# 为什么用随机权重初始化神经网络？
+
+> 原文： [https://machinelearningmastery.com/why-initialize-a-neural-network-with-random-weights/](https://machinelearningmastery.com/why-initialize-a-neural-network-with-random-weights/)
+
+必须将人工神经网络的权重初始化为小的随机数。
+
+这是因为这是用于训练模型的随机优化算法的期望，称为随机梯度下降。
+
+要理解这种解决问题的方法，首先必须了解非确定性和随机算法的作用，以及随机优化算法在搜索过程中利用随机性的必要性。
+
+在这篇文章中，您将发现为什么必须随机初始化神经网络权重的完整背景。
+
+阅读这篇文章后，你会知道：
+
+*   关于针对具有挑战性的问题的非确定性和随机算法的需求。
+*   在随机优化算法中初始化和搜索期间使用随机性。
+*   随机梯度下降是随机优化算法，需要随机初始化网络权重。
+
+让我们开始吧。
+
+![Why Initialize a Neural Network with Random Weights?](img/d767349f43cecc391f31806440729f12.jpg)
+
+为什么用随机权重初始化神经网络？
+照 [lwtt93](https://www.flickr.com/photos/37195641@N03/7086827121/) ，保留一些权利。
+
+## 概观
+
+这篇文章分为 4 部分;他们是：
+
+1.  确定性和非确定性算法
+2.  随机搜索算法
+3.  神经网络中的随机初始化
+4.  初始化方法
+
+## 确定性和非确定性算法
+
+经典算法是确定性的。
+
+一个例子是对列表进行排序的算法。
+
+给定一个未排序的列表，排序算法，比如冒泡排序或快速排序，将系统地对列表进行排序，直到您有一个有序的结果。确定性意味着每次给出相同的列表时，它将以完全相同的方式执行。它将在程序的每个步骤中进行相同的移动。
+
+确定性算法很棒，因为它们可以保证最佳，最差和平均运行时间。问题是，它们不适合所有问题。
+
+有些问题对计算机来说很难。也许是因为组合的数量;也许是因为数据的大小。它们非常难，因为确定性算法不能用于有效地解决它们。该算法可能会运行，但会继续运行直到宇宙的热量死亡。
+
+另一种解决方案是使用[非确定性算法](https://en.wikipedia.org/wiki/Nondeterministic_algorithm)。这些是在算法执行期间做出决策时使用[随机性](https://en.wikipedia.org/wiki/Randomized_algorithm)元素的算法。这意味着当在相同数据上重新运行相同的算法时，将遵循不同的步骤顺序。
+
+他们可以迅速加快获得解决方案的过程，但解决方案将是近似的，或“_ 好 _”，但往往不是“_ 最佳 _。”不确定性算法往往不能强保证运行时间或找到的解决方案的质量。
+
+这通常很好，因为问题非常严重，任何好的解决方案通常都会令人满意。
+
+## 随机搜索算法
+
+搜索问题通常非常具有挑战性，需要使用大量使用随机性的非确定性算法。
+
+算法本身并不是随机的;相反，他们会谨慎使用随机性。它们在一个边界内是随机的，被称为[随机算法](https://en.wikipedia.org/wiki/Stochastic_optimization)。
+
+搜索的增量或逐步性质通常意味着过程和算法被称为从初始状态或位置到最终状态或位置的优化。例如，随机优化问题或随机优化算法。
+
+一些例子包括遗传算法，模拟退火和随机梯度下降。
+
+搜索过程是从可能的解决方案空间的起点到一些足够好的解决方案的增量。
+
+它们在使用随机性方面具有共同特征，例如：
+
+*   在初始化期间使用随机性。
+*   在搜索过程中使用随机性。
+
+我们对搜索空间的结构一无所知。因此，为了消除搜索过程中的偏差，我们从随机选择的位置开始。
+
+随着搜索过程的展开，我们有可能陷入搜索空间的不利区域。在搜索过程中使用随机性可能会导致失败并找到更好的最终候选解决方案。
+
+陷入困境并返回不太好的解决方案的想法被称为陷入局部最优。
+
+这两个元素在搜索过程中随机初始化和随机性一起工作。
+
+如果我们将搜索找到的任何解决方案视为临时或候选，并且搜索过程可以多次执行，它们可以更好地协同工作。
+
+这为随机搜索过程提供了多个机会来启动和遍历候选解决方案的空间，以寻找更好的候选解决方案 - 即所谓的全局最优解。
+
+候选解决方案空间的导航通常使用山脉和山谷的一个或两个景观的类比来描述（例如像[健身景观](https://en.wikipedia.org/wiki/Fitness_landscape)）。如果我们在搜索过程中最大化得分，我们可以将景观中的小山丘视为当地的最佳山峰，将最大的山丘视为全球最佳山峰。
+
+这是一个迷人的研究领域，我有一些背景。例如，看我的书：
+
+*   [聪明的算法：自然启发的编程食谱](http://cleveralgorithms.com/nature-inspired/index.html)
+
+## 神经网络中的随机初始化
+
+使用称为随机梯度下降的随机优化算法训练人工神经网络。
+
+该算法使用随机性，以便为正在学习的数据中的输入到输出的特定映射函数找到足够好的权重集。这意味着每次运行训练算法时，特定训练数据的特定网络将适合具有不同模型技能的不同网络。
+
+这是一个功能，而不是一个 bug。
+
+我在帖子中更多地写了这个问题：
+
+*   [在机器学习中拥抱随机性](https://machinelearningmastery.com/randomness-in-machine-learning/)
+
+如前一节所述，诸如随机梯度下降的随机优化算法在选择搜索的起始点和搜索的进展中使用随机性。
+
+具体而言，随机梯度下降要求将网络的权重初始化为小的随机值（随机，但接近零，例如[0.0,0.1]）。在搜索过程中，在每个时期之前的训练数据集的混洗中也使用随机性，这反过来导致每个批次的梯度估计的差异。
+
+您可以在这篇文章中了解更多关于随机梯度下降的信息：
+
+*   [微量批量梯度下降的简要介绍以及如何配置批量大小](https://machinelearningmastery.com/gentle-introduction-mini-batch-gradient-descent-configure-batch-size/)
+
+搜索或学习神经网络的进展称为收敛。发现次优解或局部最优被称为早熟收敛。
+
+> 用于深度学习模型的训练算法本质上通常是迭代的，因此需要用户指定开始迭代的一些初始点。此外，训练深度模型是一项非常困难的任务，大多数算法都会受到初始化选择的强烈影响。
+
+- 第 301 页，[深度学习](https://amzn.to/2H5wjfg)，2016 年。
+
+评估神经网络配置技能的最有效方法是多次重复搜索过程，并报告模型在这些重复上的平均性能。这为配置提供了从多个不同初始条件集搜索空间的最佳机会。有时这称为多次重启或多次重启搜索。
+
+您可以在这篇文章中了解有关神经网络有效评估的更多信息：
+
+*   [如何评估深度学习模型的技巧](https://machinelearningmastery.com/evaluate-skill-deep-learning-models/)
+
+### 为什么不将权重设置为零？
+
+每次我们训练网络时，我们都可以使用相同的权重集;例如，您可以对所有权重使用 0.0 的值。
+
+在这种情况下，学习算法的方程将无法对网络权重进行任何更改，并且模型将被卡住。重要的是要注意，每个神经元中的偏差权重默认设置为零，而不是一个小的随机值。
+
+具体地，在连接到相同输入的隐藏层中并排的节点必须具有用于学习算法的不同权重以更新权重。
+
+这通常被称为在训练期间需要打破对称性。
+
+> 也许唯一已知完全确定的属性是初始参数需要在不同单元之间“打破对称性”。如果具有相同激活功能的两个隐藏单元连接到相同的输入，则这些单元必须具有不同的初始参数。如果它们具有相同的初始参数，则应用于确定性成本和模型的确定性学习算法将以相同方式不断更新这两个单元。
+
+- 第 301 页，[深度学习](https://amzn.to/2H5wjfg)，2016 年。
+
+### 何时初始化为相同权重？
+
+每次训练网络时，我们都可以使用相同的随机数。
+
+在评估网络配置时，这没有用。
+
+在生产环境中使用模型的情况下，给定训练数据集训练相同的最终网络权重集可能是有帮助的。
+
+您可以在此文章中了解有关修复使用 Keras 开发的神经网络的随机种子的更多信息：
+
+*   [如何使用 Keras](https://machinelearningmastery.com/reproducible-results-neural-networks-keras/) 获得可重现的结果
+
+## 初始化方法
+
+传统上，神经网络的权重被设置为小的随机数。
+
+神经网络权重的初始化是一个完整的研究领域，因为网络的仔细初始化可以加速学习过程。
+
+现代深度学习库，例如 Keras，提供了许多网络初始化方法，所有这些都是用小随机数初始化权重的变体。
+
+例如，在为所有网络类型编写时，Keras 中提供了当前的方法：
+
+*   **Zeros** ：生成张量初始化为 0 的初始值设定项。
+*   **Ones** ：生成张量初始化为 1 的初始值设定项。
+*   **常量**：生成张量初始化为常量值的初始值设定项。
+*   **RandomNormal** ：生成具有正态分布的张量的初始化器。
+*   **RandomUniform** ：生成具有均匀分布的张量的初始化器。
+*   **TruncatedNormal** ：生成截断正态分布的初始化程序。
+*   **VarianceScaling** ：初始化程序，能够使其比例适应权重的形状。
+*   **Orthogonal** ：生成随机正交矩阵的初始化器。
+*   **Identity** ：生成单位矩阵的初始化程序。
+*   **lecun_uniform** ：LeCun 统一初始化器。
+*   **glorot_normal** ：Glorot 正常初始化器，也称为 Xavier 正常初始化器。
+*   **glorot_uniform** ：Glorot 统一初始化器，也叫 Xavier 统一初始化器。
+*   **he_normal** ：他正常的初始化程序。
+*   **lecun_normal** ：LeCun 正常初始化程序。
+*   **he_uniform** ：他统一方差缩放初始化器。
+
+有关详细信息，请参阅[文档](https://keras.io/initializers/)。
+
+出于兴趣，Keras 开发人员为不同的图层类型选择的默认初始值设定项如下：
+
+*   **致密**（例如 MLP）： _glorot_uniform_
+*   **LSTM** ： _glorot_uniform_
+*   **CNN** ： _glorot_uniform_
+
+您可以在本文中了解更多关于“ _glorot_uniform_ ”，也称为“ _Xavier normal_ ”，以 Xavier Glorot 方法的开发人员命名：
+
+*   [了解深度前馈神经网络训练的难度](http://proceedings.mlr.press/v9/glorot10a.html)，2010。
+
+没有单一的最佳方法来初始化神经网络的权重。
+
+> 现代初始化策略简单且具有启发性。设计改进的初始化策略是一项艰巨的任务，因为神经网络优化还不是很清楚。 [...]我们对初始点如何影响泛化的理解特别原始，几乎没有为如何选择初始点提供指导。
+
+- 第 301 页，[深度学习](https://amzn.to/2H5wjfg)，2016 年。
+
+这是一个超级参数，供您探索，测试和试验您的特定预测建模问题。
+
+你有一个最喜欢的重量初始化方法吗？
+请在下面的评论中告诉我。
+
+## 进一步阅读
+
+如果您希望深入了解，本节将提供有关该主题的更多资源。
+
+### 图书
+
+*   [深度学习](https://amzn.to/2H5wjfg)，2016 年。
+
+### 用品
+
+*   维基百科上的[非确定性算法](https://en.wikipedia.org/wiki/Nondeterministic_algorithm)
+*   [维基百科上的随机算法](https://en.wikipedia.org/wiki/Randomized_algorithm)
+*   [维基百科上的随机优化](https://en.wikipedia.org/wiki/Stochastic_optimization)
+*   [维基百科上的随机梯度下降](https://en.wikipedia.org/wiki/Stochastic_gradient_descent)
+*   [维基百科上的健身景观](https://en.wikipedia.org/wiki/Fitness_landscape)
+*   [神经网络常见问题](ftp://ftp.sas.com/pub/neural/FAQ.html)
+*   [Keras 重量初始化](https://keras.io/initializers/)
+*   [了解深度前馈神经网络训练的难度](http://proceedings.mlr.press/v9/glorot10a.html)，2010。
+
+### 讨论
+
+*   [神经网络中有哪些好的初始权重？](https://stats.stackexchange.com/questions/47590/what-are-good-initial-weights-in-a-neural-network)
+*   [为什么神经网络的权重应该初始化为随机数？](https://stackoverflow.com/questions/20027598/why-should-weights-of-neural-networks-be-initialized-to-random-numbers)
+*   [神经网络中有哪些好的初始权重？](https://www.quora.com/What-are-good-initial-weights-in-a-neural-network)
+
+## 摘要
+
+在这篇文章中，您发现了为什么必须随机初始化神经网络权重。
+
+具体来说，你学到了：
+
+*   关于针对具有挑战性的问题的非确定性和随机算法的需求。
+*   在随机优化算法中初始化和搜索期间使用随机性。
+*   随机梯度下降是随机优化算法，需要随机初始化网络权重。
+
+你有任何问题吗？
+在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file