Machine-Learning-Mastery-Keras-深度学习教程-一-

Machine Learning Mastery Keras 深度学习教程（一）

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

Keras 中神经网络模型的 5 步生命周期

原文： 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 ：添加了备用链接以下载数据集，因为原始图像已被删除。

图片Martin Stitchener 提供，并保留所属权利。

概述

下面概述了我们将要研究的 Keras 神经网络模型生命周期的 5 个步骤。

1. 定义网络
2. 编译网络
3. 拟合网络
4. 评估网络
5. 做出预测

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激活函数和一个神经元输出层。
• 多元分类（>2 类）：假设单热编码输出模式，Softmax 激活函数或softmax和每个神经元代表一个输出。

步骤 2. 编译网络

一旦我们定义了网络，我们就必须编译它。

编译是一个提升效率的步骤，它将我们定义的简单层序列转换为高效的矩阵变换系列，其格式应在 GPU 或 CPU 上执行，而这具体取决于 Keras 的配置方式。

可以将编译视为网络的预计算步骤。

定义模型后始终需要编译，这包括在使用优化方案训练之前以及从保存文件加载一组预先训练的权重的步骤之前，原因是编译过程处理了网络的有效表示，这也是利用硬件做出预测所必需的步骤。

编译需要指定许多参数，专门用于训练您的网络，具体地，用于训练网络的优化算法和用于评估由优化算法最小化的网络的损失函数。

例如，下面是编译定义模型并指定随机梯度下降（sgd）优化算法和均方误差（mse）损失函数的情况，通常用于回归类型的问题。

model.compile(optimizer='sgd', loss='mse')

预测模型问题的类型可以对使用的损失函数的类型施加约束。

例如，下面是不同预测模型类型的一些标准损失函数：

• 回归：均值平方误差或mse.
• 二分类（2 类）：对数损失，也称为交叉熵或binary_crossentropy.
• 多元分类（> 2 类）：多类对数损失或categorical_crossentropy .

您可以查看 Keras 支持的损失函数套件。

最常见的优化算法是随机梯度下降，但 Keras 还支持其他最先进的优化算法的套件。

使用最常用的优化算法可能是因为它们通常具有更好的表现：

• 随机梯度下降或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 函数将其转换为单个类输出预测。

端到端工作示例

让我们将所有这些与一个小例子结合起来。

这个例子将使用皮马印第安人发病的糖尿病二分类问题，即可以从 UCI 机器学习库下载（更新：从这里下载）。

该问题有 8 个输入变量和一个输出类变量，其输出整数值为 0 和 1。

我们将构建一个多层感知机神经网络，在可见层中有 8 个输入，隐藏层中有 12 个神经元，具有整流器激活函数，输出层中有 1 个神经元具有sigmod()激活函数。

我们将使用 ADAM 优化算法和对数损失函数对批量大小为 10 的 100 个迭代次数进行网络训练。

一旦拟合完成，我们将评估训练数据的模型表现，然后对训练数据进行单独预测，这是为了简洁起见，通常我们会在单独的测试数据集上评估模型表现并对新数据做出预测。

完整的代码清单如下。

# Sample Multilayer Perceptron Neural Network in Keras
from keras.models import Sequential
from keras.layers import Dense
import numpy
# 加载和预处理数据集
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
X = dataset[:,0:8]
Y = dataset[:,8]
# 1. 定义网络
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# 2. 编译网络
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# 3. 拟合网络
history = model.fit(X, Y, epochs=100, batch_size=10)
# 4. 评估网络
loss, accuracy = model.evaluate(X, Y)
print("\nLoss: %.2f, Accuracy: %.2f%%" % (loss, accuracy*100))
# 5. 做出预测
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 中的神经网络模型有任何疑问吗？在评论中提出您的问题，我会尽力回答。

Python 迷你课程中的应用深度学习

原文： machinelearningmastery.com/applied-deep-learning-in-python-mini-course/

深度学习是一个迷人的研究领域，这些技术在一系列具有挑战性的机器学习问题中取得了世界一流的成果。

深入学习可能很难开始。

您应该使用哪个库以及您应该关注哪些技术？

在这篇文章中，您将学习一个由 14 个 部分组成的 Python 深度学习速成课程，其中包含易于使用且功能强大的 Keras 库。

这个迷你课程适用于已经熟悉 SciPy 生态学机器学习的 Python 机器学习从业者。

让我们现在开始吧。

（提示：你可以收藏或者可以打印这个页面，以便于以后重新参考。）

• 更新 March / 2018 ：添加了备用链接以下载数据集，因为原始图像已被删除。

图片由 darkday 提供，并保留所属权利

这个迷你课程是为谁而准备的

在我们开始之前，让我们确保您处于合适的位置，以下列表提供了有关本课程设计对象的一般指导原则。

如果你没有完全匹配以下特点，请不要惊慌，你可能只需要在某一个领域更新您的知识，以便于开始学习这个课程。

• 开发人员且知道如何编写一些代码。这意味着使用 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
# 定义两个符号性浮点数
a = tensor.dscalar()
b = tensor.dscalar()
# 创建一个简单的表达式
c = a + b
# 将表达式转换为可调用的对象
# 计算输入值并将其赋值给输出变量 c
f = theano.function([a,b], c)

result = f(1.5, 2.5)
print(result)

您可以在 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
# 声明两个符号性浮点变量
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
# 创建一个简单的符号性表达式
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 主页上了解有关 TensorFlow 的更多信息。

第 03 课：Keras 简介

Theano 和 TensorFlow 的难点在于它可能需要大量代码来创建非常简单的神经网络模型。

这些库主要是作为研究和开发的平台而设计，而不是应用深度学习的实际问题。

Keras 库通过为 Theano 和 TensorFlow 提供封装来解决这些问题，它提供了简洁的 API，允许您在几行代码中定义和评估深度学习模型。

由于易于使用，并且因为它利用了 Theano 和 TensorFlow 的强大功能，Keras 很快成为应用深度学习的首选库。

Keras 的重点是模型的概念，模型的生命周期可归纳如下：

1. 定义您的模型，创建顺序模型并添加已配置的层；
2. 编译您的模型，指定损失函数和优化器，并在模型上调用compile()函数 函数。
3. 拟合您的模型，通过调用模型上的fir()函数，在数据样本上训练模型。
4. 作出预测，通过调用模型上的evaluate()或predict()等函数，使用该模型生成对新数据的预测。

您的本课目标是安装 Keras。

例如，您可以使用 pip 安装 Keras：

sudo pip install keras

现在开始熟悉一下 Keras 库，为即将到来的课程做好准备，我们将实现我们的第一个模型。

您可以在 Keras 主页上了解有关 Keras 库的更多信息。

课程 04：多层感知机中的速成课程

人工神经网络是一个迷人的研究领域，尽管它们刚开始时可能会令人生畏。

人工神经网络领域通常被称为神经网络或多层感知机之后可能是最有用的神经网络类型。

神经网络的构建块是人工神经元，这些是简单的计算单元，其具有加权输入信号并能使用激活函数产生输出信号。

神经元被排列成神经元网络。一行神经元称为层，一个网络可以有多个层，网络中神经元的架构通常称为网络拓扑。

神经网络配置完成后，需要在数据集上训练神经网络，神经网络经典且仍然最流行的的训练算法称为随机 梯度下降算法。

简单神经元的模型

您的本课目标是熟悉神经网络术语，深入研究神经元，权重，激活函数，学习率等等。

第 05 课：在 Keras 开发您的第一个神经网络

Keras 允许您在极少数代码行中开发和评估深度学习模型。

在本课程中，您的目标是使用 Keras 库开发您的第一个神经网络。

您可以使用来自 UCI 机器学习库的标准二进制（两类）分类数据集，如 Pima Indians 糖尿病或电离层数据集。

编写代码以实现以下目标：

1. 使用 NumPy 或 Pandas 加载数据集；
2. 定义您的神经网络模型并进行编译；
3. 拟合您的神经网络模型；
4. 评估模型在不可见的数据上的表现。

为了给您的学习带来较大帮助，下面是一个完整的工作示例，您可以将其作为您的学习起点。

您可以将 Pima Indians 数据集下载到您当前的工作目录中，文件名为 pima-indians-diabetes.csv （更新：从这里下载） 。

# 利用 keras 创建第一个神经网络
from keras.models import Sequential
from keras.layers import Dense
import numpy
# 设置随机种子
seed = 7
numpy.random.seed(seed)
#加载数据集
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# 将数据及分割为输入变量和输出变量
X = dataset[:,0:8]
Y = dataset[:,8]
# 创建模型
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'))
编译模型
model.compile(loss='binary_crossentropy' , optimizer='adam', metrics=['accuracy'])
# 拟合网络
model.fit(X, Y, nb_epoch=150, batch_size=10)
# 评估网络
scores = model.evaluate(X, Y)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))

现在，根据此示例，您可以在利用不同数据集开发不同的模型或者继续调整此模型。

您可以在Keras API 更多信息上了解有关用于简单模型开发的更多的知识。

第 06 课：使用 Scikit-Learn 的 Keras 模型

scikit-learn 库是一个基于 SciPy 构建的 Python 通用机器学习框架。

Scikit-learn 擅长仅在几行代码之内评估模型表现和完成优化模型超参数等任务。

Keras 提供了一个封装类，允许您使用 scikit-learn 的深度学习模型，例如，Keras 中的 KerasClassifier 类的实例可以封装您的深度学习模型，并在 scikit-learn 中用作估计器。

使用 KerasClassifier 类时，必须指定该类可用于定义和编译模型的函数的名称。您还可以将其他参数传递给 KerasClassifier 类的构造函数，之后将传递给 model.fit() 调用，例如迭代次数和批量大小等。

在本课程中，您的目标是开发深度学习模型并使用 k 折交叉验证对其进行评估。

例如，您可以定义 KerasClassifier 的实例和自定义函数来创建模型，如下所示：

#  KerasClassifier 类中创建模型的函数
def create_model():
	# 创建模型
	model = Sequential()
	...
	# 编译模型
	model.compile(...)
	return model

# 使用 scikit-learn 创建分类器
model = KerasClassifier(build_fn=create_model, nb_epoch=150, batch_size=10)
# 在 scikit-learn 中使用 10 折交叉验证评估模型表现
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 的更多信息。

第 07 课：绘制模型训练历史

您可以通过观察模型整个训练期间的表现了解更多关于神经网络模型和深度学习更多的信息。

Keras 提供了在训练深度学习模型时注册回调的功能。

训练所有深度学习模型时注册的默认回调之一是历史回调，它记录每个迭代次数的训练指标，包括损失和精确度（对于分类问题）以及验证数据集的损失和精确度（如果已设置）。

历史对象通过调用fit()函数返回，度量标准保存在返回对象的历史成员的字典中。

您本课程的目标是研究历史对象，并绘制模型在训练期间的表现图像。

例如，您可以输出历史对象收集的指标列表，如下所示：

# 历史对象中的所有数据
history = model.fit(...)
print(history.history.keys())

您可以在 Keras 中了解有关 History 对象和回调 API 的更多信息。

第 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]
#拟合网络
model.fit(..., callbacks=callbacks_list)

了解有关在 Keras 中使用 ModelCheckpoint 回调的更多信息。

第 09 课：通过随机失活正则化减少过拟合

过度学习训练数据集是神经网络面临的一个大问题！

随机失活（Dropout） 是一种简单但非常有效的减少丢失的技术，并且已证明在大型深度学习模型中很有用。

随机失活是一种在训练过程中随机选择被忽略的神经元的技术，而这些神经元是随机选择的。这意味着它们对下游神经元激活的贡献在正向通道时暂时消除，并且任何权重参数的更新都不会应用于后向通过的的神经元。

您可以使用 Dropout 层类将随机失活层添加到深度学习模型中。

在本课程中，您的目标是尝试在神经网络的不同节点添加随机 dropout，并设置不同的 dropout 的概率值。

例如，您可以创建一个概率为 20％的随机失活层，并将其添加到您的模型中，如下所示：

from keras.layers import Dropout
...
model.add(Dropout(0.2))

你可以在 Keras 中了解更多关于的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 课程。

第 11 课：卷积神经网络中的速成课程

卷积神经网络是一种强大的人工神经网络技术。

他们通过使用小方块格式的输入数据学习其内部特征表示来期望并保持图像中像素之间的空间关系。

在整个图像中学习和使用特征，允许图像中的物体在场景中移动或平移，并且仍然可以被网络检测到，这就是为什么这种类型的网络对于照片不同方向中的物体识别，数字识别，人脸识别别等非常有用的原因。

卷积神经网络中的三种类型：

1. 卷积层: 由过滤器和特征图组成。
2. 池化层: 从特征图中下采样激活。
3. 完全连接层: 连接于模型的末端，可用于做出预测。

在本课中，您需要熟悉描述卷积神经网络时使用的术语。

这可能需要您自己进行一些研究，但是不要过分担心它们如何工作，只需学习这种网络中使用的各种层的术语和配置。

第 12 课：手写数字识别

手写数字识别是一类复杂的计算机视觉分类问题。

MNIST 数据集是用于评估手写数字识别问题的算法的标准问题。它包含可用于训练模型的 60,000 个数字图像，以及可用于评估其表现的 10,000 个图像，如下图所示：

使用卷积神经网络可以在 MNIST 问题上实现现有技术的结果，Keras 使得加载 MNIST 数据集变得更加容易。

在本课程中，您的目标是为 MNIST 问题开发一个非常简单的卷积神经网络，该模型由一个卷积层，一个池化层和一个用来预测的完全连接层组成。

您可以在 Keras 中加载 MNIST 数据集，如下所示：

from keras.datasets import mnist
...
(X_train, y_train), (X_test, y_test) = mnist.load_data()

将文件下载到您的计算机可能需要一些时间。

一个小提示：您 Keras Conv2D 作为您的第一个隐藏层，数据的格式为通道 x 宽 x 高的图像数据，其中 MNIST 数据集具有 1 个通道，因为图像是宽度和高度都是 28 像素的灰度级图像，您可以很容易的在代码中重新改变数据的格式，如下代码所示:

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 个物体中的一个，如猫，船或飞机等，如下所示：

与 MNIST 数据集一样，Keras 提供了一个方便的函数，您可以使用它来加载数据集，并在您第一次尝试加载数据集时将其下载到您的计算机，数据集为 163 MB，因此下载可能需要几分钟。

您在本课程中的目标是为 CIFAR-10 数据集开发一个深度卷积神经网络。考虑尝试随机失活和较长的训练时间，我建议您使用重复模式的卷积层和池化层。。

例如，您可以在 Keras 中加载 CIFAR-10 数据集并与卷积神经网络一起使用，如下所示：

from keras.datasets import cifar10
from keras.utils import np_utils
# 加载数据
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
# 正则化输出
X_train = X_train.astype('float32') X_test = X_test.astype('float32')
X_train = X_train / 255.0
X_test = X_test / 255.0
# 单热编码输出
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)

第 14 课：通过数据扩充改进泛化

使用神经网络和深度学习模型时，需要对数据进行预处理。

更复杂的对象识别任务也会导致越来越多的数据扩充，这是您使用随机翻转和移位修改数据集中的图像的位置的结果，这实质上会使您的训练数据集更大，并且有助于您的模型生成位置和方向信息。

Keras 提供了一个图像增强 API，可以及时在数据集中创建图像的修改版本， ImageDataGenerator 类可用于定义要执行的图像增强操作，这些操作可拟合数据集，然后在训练模型时用于代替数据集。

本课程的目标是使用您在上一课（如 MNIST 或 CIFAR-10）中熟悉的数据集来试验 Keras 图像增强 API。

例如，下面的示例在 MNIST 数据集中创建最多 90 度图像的随机旋转。

# 随机旋转
from keras.datasets import mnist
from keras.preprocessing.image import ImageDataGenerator
from matplotlib import pyplot
# 加载数据
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# 重新改变图像的数据格式
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
# 将整型数据转换为浮点型数据
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# 定义数据预处理
datagen = ImageDataGenerator(rotation_range=90)
# 从数据中拟合参数
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):
	# 创建一个 3×3 的网格图像
	for i in range(0, 9):
		pyplot.subplot(330 + 1 + i)
		pyplot.imshow(X_batch[i].reshape(28, 28), cmap=pyplot.get_cmap('gray'))
	# 显示突袭 iang
	pyplot.show()
	break

您可以了解有关 Keras 图像增强 API 的更多信息。

深度学习迷你课程评论

恭喜你，你做到了。做得好！

花点时间回顾一下你走了多远：

• 您在 python 中了解了深度学习库，包括可用于深度学习的强大的数值库 Theano 和 TensorFlow 以及易于使用的 Keras 库。
• 您使用 Keras 构建了第一个神经网络，并学习了如何使用 scikit-learn 的深度学习模型以及如何检索和绘制模型的训练历史记录。
• 您了解了更多高级技术，例如随机失活正则化和基于时间的学习率计划，以及如何在 Keras 中使用这些技术。
• 最后，您了解并开发了用于复杂计算机视觉任务的卷积神经网络，并了解了图像数据的增强的相关知识。

不要轻视这一点，你在很短的时间内走了很长的路，这只是您在 Python 中深入学习的旅程的开始。请继续练习和发展你的技能。

你喜欢这个迷你课程吗？你有任何问题或疑点可以发表评论！

用于分类的自编码器特征提取

原文：machinelearningmastery.com/autoencoder…

自编码器是一种神经网络，可用于学习原始数据的压缩表示。

自编码器由编码器和解码器子模型组成。编码器压缩输入，解码器尝试根据编码器提供的压缩版本重新创建输入。训练后，编码器模型被保存，解码器被丢弃。

然后，编码器可用作数据准备技术，对原始数据执行特征提取，该原始数据可用于训练不同的机器学习模型。

在本教程中，您将了解如何开发和评估用于分类预测建模的自编码器。

完成本教程后，您将知道:

• 自编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
• 如何在训练数据集上训练自编码器模型，并只保存模型的编码器部分。
• 训练机器学习模型时如何将编码器作为数据准备步骤？

我们开始吧。

如何开发分类自编码器 图片由贝恩德·泰勒提供，版权所有。

教程概述

本教程分为三个部分；它们是:

1. 用于特征提取的自编码器
2. 用于分类的自编码器
3. 编码器作为预测模型的数据准备

用于特征提取的自编码器

自编码器是一种神经网络模型，旨在学习输入的压缩表示。

自编码器是一个神经网络，它被训练成试图将其输入复制到其输出。

—第 502 页，深度学习，2016。

它们是一种无监督的学习方法，尽管从技术上来说，它们是使用有监督的学习方法训练的，称为自监督。

自编码器通常被训练为试图重建输入的更广泛模型的一部分。

例如:

• X =模型.预测(X)

自编码器模型的设计有目的地将架构限制在模型中点的瓶颈上，从而使这一点具有挑战性，输入数据的重建就是从这个瓶颈开始的。

自编码器有许多类型，它们的用途各不相同，但可能更常见的用途是作为一个学习或自动特征提取模型。

在这种情况下，一旦模型被拟合，模型的重建方面可以被丢弃，并且直到瓶颈点的模型可以被使用。瓶颈处模型的输出是一个固定长度的向量，它提供了输入数据的压缩表示。

通常，它们受到限制，只允许近似复制，并且只复制类似于训练数据的输入。因为模型被迫优先考虑应该复制输入的哪些方面，所以它经常学习数据的有用属性。

—第 502 页，深度学习，2016。

然后可以将来自域的输入数据提供给模型，并且瓶颈处的模型输出可以用作监督学习模型中的特征向量，用于可视化，或者更一般地用于降维。

接下来，让我们探索如何针对分类预测建模问题开发用于特征提取的自编码器。

用于分类的自编码器

在本节中，我们将开发一个自编码器来学习分类预测建模问题的输入特征的压缩表示。

首先，让我们定义一个分类预测建模问题。

我们将使用make _ classification()sci kit-learn 函数定义一个包含 100 个输入特征(列)和 1000 个示例(行)的合成二进制(2 类)分类任务。重要的是，我们将以这样的方式定义问题，即大多数输入变量是冗余的(100%或 90%中的 90%)，允许自编码器稍后学习有用的压缩表示。

下面的示例定义了数据集并总结了它的形状。

# synthetic classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=100, n_informative=10, n_redundant=90, random_state=1)
# summarize the dataset
print(X.shape, y.shape)

运行该示例定义数据集并打印数组的形状，确认行数和列数。

(1000, 100) (1000,)

接下来，我们将开发一个多层感知机(MLP)自编码器模型。

该模型将采用所有输入列，然后输出相同的值。它将学会精确地重新创建输入模式。

自编码器由两部分组成:编码器和解码器。编码器学习如何解释输入，并将其压缩为瓶颈层定义的内部表示。解码器获取编码器的输出(瓶颈层)，并尝试重新创建输入。

一旦自编码器被训练，解码器被丢弃，我们只保留编码器，并使用它将输入的例子压缩成瓶颈层输出的向量。

在第一个自编码器中，我们根本不会压缩输入，而是使用与输入大小相同的瓶颈层。这应该是一个简单的问题，模型将学习得近乎完美，并旨在确认我们的模型被正确实现。

我们将使用功能 API 定义模型；如果您不熟悉，我推荐本教程:

• 如何使用 Keras 函数 API 进行深度学习

在定义和拟合模型之前，我们将把数据分成训练集和测试集，并通过将值归一化到 0-1 的范围来缩放输入数据，这是 MLPs 的一个很好的实践。

...
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# scale data
t = MinMaxScaler()
t.fit(X_train)
X_train = t.transform(X_train)
X_test = t.transform(X_test)

我们将编码器定义为具有两个隐藏层，第一个具有两倍数量的输入(例如 200)，第二个具有相同数量的输入(100)，随后是具有与数据集相同数量的输入的瓶颈层(100)。

为了保证模型学习良好，我们将使用批处理规范化和泄漏 ReLU 激活。

...
# define encoder
visible = Input(shape=(n_inputs,))
# encoder level 1
e = Dense(n_inputs*2)(visible)
e = BatchNormalization()(e)
e = LeakyReLU()(e)
# encoder level 2
e = Dense(n_inputs)(e)
e = BatchNormalization()(e)
e = LeakyReLU()(e)
# bottleneck
n_bottleneck = n_inputs
bottleneck = Dense(n_bottleneck)(e)

解码器将以类似的结构来定义，尽管是相反的。

它将有两个隐藏层，第一个具有数据集中的输入数量(例如 100)，第二个具有两倍的输入数量(例如 200)。输出层的节点数将与输入数据中的列数相同，并将使用线性激活函数输出数值。

...
# define decoder, level 1
d = Dense(n_inputs)(bottleneck)
d = BatchNormalization()(d)
d = LeakyReLU()(d)
# decoder level 2
d = Dense(n_inputs*2)(d)
d = BatchNormalization()(d)
d = LeakyReLU()(d)
# output layer
output = Dense(n_inputs, activation='linear')(d)
# define autoencoder model
model = Model(inputs=visible, outputs=output)

考虑到重建是一种多输出回归问题，模型将使用随机梯度下降的有效 Adam 版本进行拟合，并最小化均方误差。

...
# compile autoencoder model
model.compile(optimizer='adam', loss='mse')

我们可以在自编码器模型中绘制图层，以了解数据如何在模型中流动。

...
# plot the autoencoder
plot_model(model, 'autoencoder_no_compress.png', show_shapes=True)

下图显示了自编码器的曲线图。

无压缩分类自编码器模型图

接下来，我们可以训练模型来重现输入，并在等待测试集上跟踪模型的表现。

...
# fit the autoencoder model to reconstruct input
history = model.fit(X_train, X_train, epochs=200, batch_size=16, verbose=2, validation_data=(X_test,X_test))

训练后，我们可以为训练集和测试集绘制学习曲线，以确认模型很好地学习了重建问题。

...
# plot loss
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()

最后，如果需要，我们可以保存编码器模型供以后使用。

...
# define an encoder model (without the decoder)
encoder = Model(inputs=visible, outputs=bottleneck)
plot_model(encoder, 'encoder_no_compress.png', show_shapes=True)
# save the encoder to file
encoder.save('encoder.h5')

作为保存编码器的一部分，我们还将绘制编码器模型，以获得瓶颈层输出的形状感觉，例如 100 元素向量。

下面提供了该图的示例。

无压缩分类编码器模型图

将所有这些结合在一起，下面列出了一个完整的自编码器示例，用于在瓶颈层没有任何压缩的情况下重建分类数据集的输入数据。

# train autoencoder for classification with no compression in the bottleneck layer
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import LeakyReLU
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.utils import plot_model
from matplotlib import pyplot
# define dataset
X, y = make_classification(n_samples=1000, n_features=100, n_informative=10, n_redundant=90, random_state=1)
# number of input columns
n_inputs = X.shape[1]
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# scale data
t = MinMaxScaler()
t.fit(X_train)
X_train = t.transform(X_train)
X_test = t.transform(X_test)
# define encoder
visible = Input(shape=(n_inputs,))
# encoder level 1
e = Dense(n_inputs*2)(visible)
e = BatchNormalization()(e)
e = LeakyReLU()(e)
# encoder level 2
e = Dense(n_inputs)(e)
e = BatchNormalization()(e)
e = LeakyReLU()(e)
# bottleneck
n_bottleneck = n_inputs
bottleneck = Dense(n_bottleneck)(e)
# define decoder, level 1
d = Dense(n_inputs)(bottleneck)
d = BatchNormalization()(d)
d = LeakyReLU()(d)
# decoder level 2
d = Dense(n_inputs*2)(d)
d = BatchNormalization()(d)
d = LeakyReLU()(d)
# output layer
output = Dense(n_inputs, activation='linear')(d)
# define autoencoder model
model = Model(inputs=visible, outputs=output)
# compile autoencoder model
model.compile(optimizer='adam', loss='mse')
# plot the autoencoder
plot_model(model, 'autoencoder_no_compress.png', show_shapes=True)
# fit the autoencoder model to reconstruct input
history = model.fit(X_train, X_train, epochs=200, batch_size=16, verbose=2, validation_data=(X_test,X_test))
# plot loss
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()
# define an encoder model (without the decoder)
encoder = Model(inputs=visible, outputs=bottleneck)
plot_model(encoder, 'encoder_no_compress.png', show_shapes=True)
# save the encoder to file
encoder.save('encoder.h5')

运行该示例符合模型，并报告沿途火车和测试集的损失。

注意:如果在创建模型的地块时遇到问题，可以注释掉导入，调用 plot_model() 函数。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们看到损耗变低了，但是在瓶颈层没有压缩的情况下，损耗没有达到零(正如我们可能预期的那样)。也许需要进一步调整模型架构或学习超参数。

...
42/42 - 0s - loss: 0.0032 - val_loss: 0.0016
Epoch 196/200
42/42 - 0s - loss: 0.0031 - val_loss: 0.0024
Epoch 197/200
42/42 - 0s - loss: 0.0032 - val_loss: 0.0015
Epoch 198/200
42/42 - 0s - loss: 0.0032 - val_loss: 0.0014
Epoch 199/200
42/42 - 0s - loss: 0.0031 - val_loss: 0.0020
Epoch 200/200
42/42 - 0s - loss: 0.0029 - val_loss: 0.0017

创建的学习曲线图表明，该模型在重构输入时获得了良好的拟合，在整个训练过程中保持稳定，而不是过度拟合。

无压缩训练自编码器模型的学习曲线

目前为止，一切顺利。我们知道如何开发一个没有压缩的自编码器。

接下来，让我们更改模型的配置，以便瓶颈层有一半的节点数量(例如 50 个)。

...
# bottleneck
n_bottleneck = round(float(n_inputs) / 2.0)
bottleneck = Dense(n_bottleneck)(e)

将这些联系在一起，完整的示例如下所示。

# train autoencoder for classification with with compression in the bottleneck layer
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import LeakyReLU
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.utils import plot_model
from matplotlib import pyplot
# define dataset
X, y = make_classification(n_samples=1000, n_features=100, n_informative=10, n_redundant=90, random_state=1)
# number of input columns
n_inputs = X.shape[1]
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# scale data
t = MinMaxScaler()
t.fit(X_train)
X_train = t.transform(X_train)
X_test = t.transform(X_test)
# define encoder
visible = Input(shape=(n_inputs,))
# encoder level 1
e = Dense(n_inputs*2)(visible)
e = BatchNormalization()(e)
e = LeakyReLU()(e)
# encoder level 2
e = Dense(n_inputs)(e)
e = BatchNormalization()(e)
e = LeakyReLU()(e)
# bottleneck
n_bottleneck = round(float(n_inputs) / 2.0)
bottleneck = Dense(n_bottleneck)(e)
# define decoder, level 1
d = Dense(n_inputs)(bottleneck)
d = BatchNormalization()(d)
d = LeakyReLU()(d)
# decoder level 2
d = Dense(n_inputs*2)(d)
d = BatchNormalization()(d)
d = LeakyReLU()(d)
# output layer
output = Dense(n_inputs, activation='linear')(d)
# define autoencoder model
model = Model(inputs=visible, outputs=output)
# compile autoencoder model
model.compile(optimizer='adam', loss='mse')
# plot the autoencoder
plot_model(model, 'autoencoder_compress.png', show_shapes=True)
# fit the autoencoder model to reconstruct input
history = model.fit(X_train, X_train, epochs=200, batch_size=16, verbose=2, validation_data=(X_test,X_test))
# plot loss
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()
# define an encoder model (without the decoder)
encoder = Model(inputs=visible, outputs=bottleneck)
plot_model(encoder, 'encoder_compress.png', show_shapes=True)
# save the encoder to file
encoder.save('encoder.h5')

运行该示例符合模型，并报告沿途火车和测试集的损失。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们看到，在没有压缩的情况下，损失变得与上面的示例类似低，这表明，在瓶颈只有一半大的情况下，模型的表现可能也一样好。

...
42/42 - 0s - loss: 0.0029 - val_loss: 0.0010
Epoch 196/200
42/42 - 0s - loss: 0.0029 - val_loss: 0.0013
Epoch 197/200
42/42 - 0s - loss: 0.0030 - val_loss: 9.4472e-04
Epoch 198/200
42/42 - 0s - loss: 0.0028 - val_loss: 0.0015
Epoch 199/200
42/42 - 0s - loss: 0.0033 - val_loss: 0.0021
Epoch 200/200
42/42 - 0s - loss: 0.0027 - val_loss: 8.7731e-04

创建了学习曲线的图，再次表明模型在重构输入时获得了良好的拟合，在整个训练过程中保持稳定，而不是过度拟合。

压缩训练自编码器模型的学习曲线

训练好的编码器保存到文件“ encoder.h5 ”中，我们以后可以加载使用。

接下来，让我们探索如何使用训练好的编码器模型。

编码器作为预测模型的数据准备

在本节中，我们将使用自编码器中经过训练的编码器来压缩输入数据，并训练不同的预测模型。

首先，让我们在这个问题上建立一个表现基线。这一点很重要，因为如果压缩编码不能提高模型的表现，那么压缩编码就不能增加项目的价值，就不应该使用。

我们可以直接在训练数据集上训练逻辑回归模型，并在保持测试集上评估模型的表现。

下面列出了完整的示例。

# baseline in performance with logistic regression model
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# define dataset
X, y = make_classification(n_samples=1000, n_features=100, n_informative=10, n_redundant=90, random_state=1)
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# scale data
t = MinMaxScaler()
t.fit(X_train)
X_train = t.transform(X_train)
X_test = t.transform(X_test)
# define model
model = LogisticRegression()
# fit model on training set
model.fit(X_train, y_train)
# make prediction on test set
yhat = model.predict(X_test)
# calculate accuracy
acc = accuracy_score(y_test, yhat)
print(acc)

运行该示例适合训练数据集上的逻辑回归模型，并在测试集上对其进行评估。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到该模型实现了大约 89.3%的分类准确率。

我们希望并期望逻辑回归模型适合输入的编码版本，以获得更好的准确性，使编码被认为是有用的。

0.8939393939393939

我们可以更新示例，首先使用上一节中训练的编码器模型对数据进行编码。

首先，我们可以从文件中加载训练好的编码器模型。

...
# load the model from file
encoder = load_model('encoder.h5')

然后，我们可以使用编码器将原始输入数据(例如 100 列)转换为瓶颈向量(例如 50 个元素向量)。

这个过程可以应用于训练和测试数据集。

...
# encode the train data
X_train_encode = encoder.predict(X_train)
# encode the test data
X_test_encode = encoder.predict(X_test)

然后，我们可以像以前一样，使用这些编码数据来训练和评估逻辑回归模型。

...
# define the model
model = LogisticRegression()
# fit the model on the training set
model.fit(X_train_encode, y_train)
# make predictions on the test set
yhat = model.predict(X_test_encode)

将这些联系在一起，完整的示例如下所示。

# evaluate logistic regression on encoded input
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from tensorflow.keras.models import load_model
# define dataset
X, y = make_classification(n_samples=1000, n_features=100, n_informative=10, n_redundant=90, random_state=1)
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# scale data
t = MinMaxScaler()
t.fit(X_train)
X_train = t.transform(X_train)
X_test = t.transform(X_test)
# load the model from file
encoder = load_model('encoder.h5')
# encode the train data
X_train_encode = encoder.predict(X_train)
# encode the test data
X_test_encode = encoder.predict(X_test)
# define the model
model = LogisticRegression()
# fit the model on the training set
model.fit(X_train_encode, y_train)
# make predictions on the test set
yhat = model.predict(X_test_encode)
# calculate classification accuracy
acc = accuracy_score(y_test, yhat)
print(acc)

运行该示例首先使用编码器对数据集进行编码，然后在训练数据集上拟合逻辑回归模型，并在测试集上对其进行评估。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到该模型实现了大约 93.9%的分类准确率。

这比在原始数据集上评估的相同模型具有更好的分类精确率，表明编码对我们选择的模型和测试工具有帮助。

0.9393939393939394

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

教程

• LSTM 自编码器简介
• 如何使用 Keras 函数 API 进行深度学习
• TensorFlow 2 教程:使用 tf.keras 开始深度学习

书

• 深度学习，2016 年。

蜜蜂

• sklearn . datasets . make _ classification API。
• sklearn . model _ selection . train _ test _ split API。

文章

• 自我编码，维基百科。

摘要

在本教程中，您发现了如何开发和评估用于分类预测建模的自编码器。

具体来说，您了解到:

• 自编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
• 如何在训练数据集上训练自编码器模型，并只保存模型的编码器部分。
• 训练机器学习模型时如何将编码器作为数据准备步骤？

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

用于回归的自编码器特征提取

原文：machinelearningmastery.com/autoencoder…

自编码器是一种神经网络，可用于学习原始数据的压缩表示。

自编码器由编码器和解码器子模型组成。编码器压缩输入，解码器尝试根据编码器提供的压缩版本重新创建输入。训练后，编码器模型被保存，解码器被丢弃。

然后，编码器可用作数据准备技术，对原始数据执行特征提取，该原始数据可用于训练不同的机器学习模型。

在本教程中，您将了解如何开发和评估用于回归预测的自编码器

完成本教程后，您将知道:

• 自编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
• 如何在训练数据集上训练自编码器模型，并只保存模型的编码器部分。
• 训练机器学习模型时如何将编码器作为数据准备步骤？

我们开始吧。

自编码器特征提取回归 照片作者西蒙·马津格，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 用于特征提取的自编码器
2. 回归自编码器
3. 自编码器作为数据准备

用于特征提取的自编码器

自编码器是一种神经网络模型，旨在学习输入的压缩表示。

自编码器是一个神经网络，它被训练成试图将其输入复制到其输出。

—第 502 页，深度学习，2016。

它们是一种无监督的学习方法，尽管从技术上来说，它们是使用有监督的学习方法训练的，称为自监督。它们通常被训练为试图重新创建输入的更广泛模型的一部分。

例如:

• X =模型.预测(X)

自编码器模型的设计有目的地将架构限制在模型中点的瓶颈上，从而使这一点具有挑战性，输入数据的重建就是从这个瓶颈开始的。

自编码器有许多类型，它们的用途各不相同，但可能更常见的用途是作为一个学习或自动特征提取模型。

在这种情况下，一旦模型被拟合，模型的重建方面可以被丢弃，并且直到瓶颈点的模型可以被使用。瓶颈处的模型输出是一个固定长度的向量，它提供了输入数据的压缩表示。

通常，它们受到限制，只允许近似复制，并且只复制类似于训练数据的输入。因为模型被迫优先考虑应该复制输入的哪些方面，所以它经常学习数据的有用属性。

—第 502 页，深度学习，2016。

然后可以将来自域的输入数据提供给模型，并且瓶颈处的模型输出可以用作监督学习模型中的特征向量，用于可视化，或者更一般地用于降维。

接下来，让我们探索如何针对回归预测建模问题开发用于特征提取的自编码器。

回归自编码器

在本节中，我们将开发一个自编码器来学习回归预测建模问题的输入特征的压缩表示。

首先，让我们定义一个回归预测建模问题。

我们将使用make _ revolution()sci kit-learn 函数定义一个包含 100 个输入特征(列)和 1000 个示例(行)的合成回归任务。重要的是，我们将以这样的方式定义问题，即大多数输入变量是冗余的(100%或 90%中的 90%)，允许自编码器稍后学习有用的压缩表示。

下面的示例定义了数据集并总结了它的形状。

# synthetic regression dataset
from sklearn.datasets import make_regression
# define dataset
X, y = make_regression(n_samples=1000, n_features=100, n_informative=10, noise=0.1, random_state=1)
# summarize the dataset
print(X.shape, y.shape)

运行该示例定义数据集并打印数组的形状，确认行数和列数。

(1000, 100) (1000,)

接下来，我们将开发一个多层感知机(MLP)自编码器模型。

该模型将采用所有输入列，然后输出相同的值。它将学会精确地重新创建输入模式。

自编码器由两部分组成:编码器和解码器。编码器学习如何解释输入，并将其压缩为瓶颈层定义的内部表示。解码器获取编码器的输出(瓶颈层)，并尝试重新创建输入。

一旦自编码器被训练，解码就被丢弃，我们只保留编码器，并使用它将输入的例子压缩成瓶颈层输出的向量。

在第一个自编码器中，我们根本不会压缩输入，而是使用与输入大小相同的瓶颈层。这应该是一个简单的问题，模型将学习得近乎完美，并旨在确认我们的模型被正确实现。

我们将使用功能性应用编程接口来定义模型。如果您不熟悉，我推荐本教程:

• 如何使用 Keras 函数 API 进行深度学习

在定义和拟合模型之前，我们将把数据分成训练集和测试集，并通过将值归一化到 0-1 的范围来缩放输入数据，这是 MLPs 的一个很好的实践。

...
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# scale data
t = MinMaxScaler()
t.fit(X_train)
X_train = t.transform(X_train)
X_test = t.transform(X_test)

我们将定义编码器有一个隐藏层，其节点数与输入数据中的节点数相同，具有批处理规范化和 ReLU 激活。

随后是瓶颈层，其节点数与输入数据中的列数相同，例如没有压缩。

...
# define encoder
visible = Input(shape=(n_inputs,))
e = Dense(n_inputs*2)(visible)
e = BatchNormalization()(e)
e = ReLU()(e)
# define bottleneck
n_bottleneck = n_inputs
bottleneck = Dense(n_bottleneck)(e)

解码器将以相同的结构定义。

它将有一个带有批处理规范化和 ReLU 激活的隐藏层。输出层的节点数将与输入数据中的列数相同，并将使用线性激活函数输出数值。

...
# define decoder
d = Dense(n_inputs*2)(bottleneck)
d = BatchNormalization()(d)
d = ReLU()(d)
# output layer
output = Dense(n_inputs, activation='linear')(d)
# define autoencoder model
model = Model(inputs=visible, outputs=output)
# compile autoencoder model
model.compile(optimizer='adam', loss='mse')

考虑到重建是一种多输出回归问题，模型将使用随机梯度下降的有效 Adam 版本进行拟合，并最小化均方误差。

...
# compile autoencoder model
model.compile(optimizer='adam', loss='mse')

我们可以在自编码器模型中绘制图层，以了解数据如何在模型中流动。

...
# plot the autoencoder
plot_model(model, 'autoencoder.png', show_shapes=True)

下图显示了自编码器的曲线图。

回归的自编码器模型图

接下来，我们可以训练模型来重现输入，并跟踪模型在保持测试集上的表现。该模型针对 400 个时期和 16 个实例的批量进行训练。

...
# fit the autoencoder model to reconstruct input
history = model.fit(X_train, X_train, epochs=400, batch_size=16, verbose=2, validation_data=(X_test,X_test))

训练后，我们可以为训练集和测试集绘制学习曲线，以确认模型很好地学习了重建问题。

...
# plot loss
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()

最后，如果需要，我们可以保存编码器模型供以后使用。

...
# define an encoder model (without the decoder)
encoder = Model(inputs=visible, outputs=bottleneck)
plot_model(encoder, 'encoder.png', show_shapes=True)
# save the encoder to file
encoder.save('encoder.h5')

作为保存编码器的一部分，我们还将绘制模型，以获得瓶颈层输出的形状感觉，例如 100 元素向量。

下面提供了该图的示例。

无压缩回归的编码器模型图

将所有这些结合在一起，下面列出了一个完整的自编码器示例，用于在瓶颈层没有任何压缩的情况下重建回归数据集的输入数据。

# train autoencoder for regression with no compression in the bottleneck layer
from sklearn.datasets import make_regression
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import ReLU
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.utils import plot_model
from matplotlib import pyplot
# define dataset
X, y = make_regression(n_samples=1000, n_features=100, n_informative=10, noise=0.1, random_state=1)
# number of input columns
n_inputs = X.shape[1]
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# scale data
t = MinMaxScaler()
t.fit(X_train)
X_train = t.transform(X_train)
X_test = t.transform(X_test)
# define encoder
visible = Input(shape=(n_inputs,))
e = Dense(n_inputs*2)(visible)
e = BatchNormalization()(e)
e = ReLU()(e)
# define bottleneck
n_bottleneck = n_inputs
bottleneck = Dense(n_bottleneck)(e)
# define decoder
d = Dense(n_inputs*2)(bottleneck)
d = BatchNormalization()(d)
d = ReLU()(d)
# output layer
output = Dense(n_inputs, activation='linear')(d)
# define autoencoder model
model = Model(inputs=visible, outputs=output)
# compile autoencoder model
model.compile(optimizer='adam', loss='mse')
# plot the autoencoder
plot_model(model, 'autoencoder.png', show_shapes=True)
# fit the autoencoder model to reconstruct input
history = model.fit(X_train, X_train, epochs=400, batch_size=16, verbose=2, validation_data=(X_test,X_test))
# plot loss
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()
# define an encoder model (without the decoder)
encoder = Model(inputs=visible, outputs=bottleneck)
plot_model(encoder, 'encoder.png', show_shapes=True)
# save the encoder to file
encoder.save('encoder.h5')

运行该示例符合模型，并报告沿途火车和测试集的损失。

注意:如果在创建模型的地块时遇到问题，可以注释掉导入，调用 plot_model() 函数。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们看到，在瓶颈层没有压缩的情况下，损耗变低，但不会归零(正如我们可能预期的那样)。也许需要进一步调整模型架构或学习超参数。

...
Epoch 393/400
42/42 - 0s - loss: 0.0025 - val_loss: 0.0024
Epoch 394/400
42/42 - 0s - loss: 0.0025 - val_loss: 0.0021
Epoch 395/400
42/42 - 0s - loss: 0.0023 - val_loss: 0.0021
Epoch 396/400
42/42 - 0s - loss: 0.0025 - val_loss: 0.0023
Epoch 397/400
42/42 - 0s - loss: 0.0024 - val_loss: 0.0022
Epoch 398/400
42/42 - 0s - loss: 0.0025 - val_loss: 0.0021
Epoch 399/400
42/42 - 0s - loss: 0.0026 - val_loss: 0.0022
Epoch 400/400
42/42 - 0s - loss: 0.0025 - val_loss: 0.0024

创建的学习曲线图表明，该模型在重构输入时获得了良好的拟合，在整个训练过程中保持稳定，而不是过度拟合。

无压缩回归自编码器模型训练的学习曲线

目前为止，一切顺利。我们知道如何开发一个没有压缩的自编码器。

训练好的编码器保存到文件“ encoder.h5 ”中，我们以后可以加载使用。

接下来，让我们探索如何使用训练好的编码器模型。

自编码器作为数据准备

在本节中，我们将使用自编码器模型中经过训练的编码器模型来压缩输入数据并训练不同的预测模型。

首先，让我们在这个问题上建立一个表现基线。这一点很重要，因为如果压缩编码不能提高模型的表现，那么压缩编码就不能增加项目的价值，就不应该使用。

我们可以直接在训练数据集上训练支持向量回归模型，并在保持测试集上评估模型的表现。

作为良好的实践，我们将在拟合和评估模型之前缩放输入变量和目标变量。

下面列出了完整的示例。

# baseline in performance with support vector regression model
from sklearn.datasets import make_regression
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.svm import SVR
from sklearn.metrics import mean_absolute_error
# define dataset
X, y = make_regression(n_samples=1000, n_features=100, n_informative=10, noise=0.1, random_state=1)
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# reshape target variables so that we can transform them
y_train = y_train.reshape((len(y_train), 1))
y_test = y_test.reshape((len(y_test), 1))
# scale input data
trans_in = MinMaxScaler()
trans_in.fit(X_train)
X_train = trans_in.transform(X_train)
X_test = trans_in.transform(X_test)
# scale output data
trans_out = MinMaxScaler()
trans_out.fit(y_train)
y_train = trans_out.transform(y_train)
y_test = trans_out.transform(y_test)
# define model
model = SVR()
# fit model on the training dataset
model.fit(X_train, y_train)
# make prediction on test set
yhat = model.predict(X_test)
# invert transforms so we can calculate errors
yhat = yhat.reshape((len(yhat), 1))
yhat = trans_out.inverse_transform(yhat)
y_test = trans_out.inverse_transform(y_test)
# calculate error
score = mean_absolute_error(y_test, yhat)
print(score)

运行该示例适合训练数据集上的支持向量回归模型，并在测试集上对其进行评估。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到模型实现了大约 89 的平均绝对误差(MAE)。

我们希望并期望 SVR 模型适合输入的编码版本，以实现被认为有用的编码的较低误差。

89.51082036130629

我们可以更新示例，首先使用上一节中训练的编码器模型对数据进行编码。

首先，我们可以从文件中加载训练好的编码器模型。

...
# load the model from file
encoder = load_model('encoder.h5')

然后，我们可以使用编码器将原始输入数据(例如 100 列)转换为瓶颈向量(例如 100 个元素向量)。

这个过程可以应用于训练和测试数据集。

...
# encode the train data
X_train_encode = encoder.predict(X_train)
# encode the test data
X_test_encode = encoder.predict(X_test)

然后，我们可以像以前一样，使用这些编码数据来训练和评估 SVR 模型。

...
# define model
model = SVR()
# fit model on the training dataset
model.fit(X_train_encode, y_train)
# make prediction on test set
yhat = model.predict(X_test_encode)

将这些联系在一起，完整的示例如下所示。

# support vector regression performance with encoded input
from sklearn.datasets import make_regression
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.svm import SVR
from sklearn.metrics import mean_absolute_error
from tensorflow.keras.models import load_model
# define dataset
X, y = make_regression(n_samples=1000, n_features=100, n_informative=10, noise=0.1, random_state=1)
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# reshape target variables so that we can transform them
y_train = y_train.reshape((len(y_train), 1))
y_test = y_test.reshape((len(y_test), 1))
# scale input data
trans_in = MinMaxScaler()
trans_in.fit(X_train)
X_train = trans_in.transform(X_train)
X_test = trans_in.transform(X_test)
# scale output data
trans_out = MinMaxScaler()
trans_out.fit(y_train)
y_train = trans_out.transform(y_train)
y_test = trans_out.transform(y_test)
# load the model from file
encoder = load_model('encoder.h5')
# encode the train data
X_train_encode = encoder.predict(X_train)
# encode the test data
X_test_encode = encoder.predict(X_test)
# define model
model = SVR()
# fit model on the training dataset
model.fit(X_train_encode, y_train)
# make prediction on test set
yhat = model.predict(X_test_encode)
# invert transforms so we can calculate errors
yhat = yhat.reshape((len(yhat), 1))
yhat = trans_out.inverse_transform(yhat)
y_test = trans_out.inverse_transform(y_test)
# calculate error
score = mean_absolute_error(y_test, yhat)
print(score)

运行该示例首先使用编码器对数据集进行编码，然后在训练数据集上拟合一个支持向量回归模型，并在测试集上对其进行评估。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到模型实现了大约 69 的 MAE。

这是一个比在原始数据集上评估的相同模型更好的 MAE，表明编码对我们选择的模型和测试工具有帮助。

69.45890939600503

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

教程

• LSTM 自编码器简介
• 如何使用 Keras 函数 API 进行深度学习
• TensorFlow 2 教程:使用 tf.keras 开始深度学习

书

• 深度学习，2016 年。

蜜蜂

• sklearn . datasets . make _ revolution API。
• sklearn . model _ selection . train _ test _ split API。

文章

• 自我编码，维基百科。

摘要

在本教程中，您发现了如何开发和评估用于回归预测建模的自编码器。

具体来说，您了解到:

• 自编码器是一种神经网络模型，可用于学习原始数据的压缩表示。
• 如何在训练数据集上训练自编码器模型，并只保存模型的编码器部分。
• 训练机器学习模型时如何将编码器作为数据准备步骤？

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

如何将 AutoKeras 用于分类和回归

原文：machinelearningmastery.com/autokeras-f…

最后更新于 2020 年 9 月 6 日

AutoML 指的是自动发现给定数据集的最佳模型的技术。

当应用于神经网络时，这涉及发现模型架构和用于训练模型的超参数，通常称为神经架构搜索。

AutoKeras 是一个开源库，用于为深度学习模型执行 AutoML。通过 TensorFlow tf.keras API 使用所谓的 Keras 模型执行搜索。

它提供了一种简单有效的方法，可以自动为各种预测建模任务找到表现最佳的模型，包括表格或所谓的结构化分类和回归数据集。

在本教程中，您将发现如何使用 AutoKeras 为分类和回归任务找到良好的神经网络模型。

完成本教程后，您将知道:

• AutoKeras 是 AutoML 的一个实现，用于使用神经架构搜索的深度学习。
• 如何使用 AutoKeras 为二进制分类数据集找到表现最佳的模型。
• 如何使用 AutoKeras 为回归数据集查找表现最佳的模型。

我们开始吧。

• 更新 2020 年 9 月:更新 AutoKeras 版本和安装说明。

如何使用 AutoKeras 进行分类和回归 图片由 kanu101 提供，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 深度学习自动课程
2. 用于分类的自动分类器
3. 回归的自动 Keras

深度学习自动课程

自动机器学习，简称 AutoML，是指为预测建模问题自动寻找数据准备、模型和模型超参数的最佳组合。

AutoML 的好处是允许机器学习从业者以很少的输入快速有效地处理预测建模任务，例如“开火并忘记”。

随着机器学习技术的广泛应用，自动机器学习已经成为一个非常重要的研究课题。AutoML 的目标是让机器学习背景知识有限的人能够轻松使用机器学习模型。

——Auto-keras:一个高效的神经架构搜索系统，2019。

AutoKeras 是 AutoML 的一个实现，用于使用 Keras API 的深度学习模型，特别是 TensorFlow 2 提供的 tf.keras API。

它使用搜索神经网络架构的过程来最好地解决建模任务，更一般地称为神经架构搜索，简称 NAS。

……基于我们提出的方法，我们开发了一个被广泛采用的开源 AutoML 系统，即 Auto-Keras。它是一个开源的 AutoML 系统，可以在本地下载和安装。

——Auto-keras:一个高效的神经架构搜索系统，2019。

本着 Keras 的精神，AutoKeras 为不同的任务提供了一个易于使用的界面，例如图像分类、结构化数据分类或回归等等。用户只需要指定数据的位置和要尝试的模型数量，并返回一个在该数据集上获得最佳表现(在配置的约束下)的模型。

注意 : AutoKeras 提供的是 TensorFlow 2 Keras 模型(例如 tf.keras)，而不是 Standalone Keras 模型。因此，该库假设您安装了 Python 3 和 TensorFlow 2.3.0 或更高版本。

在编写时，您需要手动安装名为 keras-tuner 的必备库。您可以按如下方式安装此库:

sudo pip install git+https://github.com/keras-team/keras-tuner.git@1.0.2rc1

如果情况再次发生变化，就像快速移动的开源项目经常发生的那样，请参见这里的官方安装说明:

• AutoKeras 安装说明

现在我们可以安装 AutoKeras 了。

要安装 AutoKeras，可以使用 Pip，如下所示:

sudo pip install autokeras

您可以确认安装成功，并按如下方式检查版本号:

sudo pip show autokeras

您应该会看到如下输出:

Name: autokeras
Version: 1.0.8
Summary: AutoML for deep learning
Home-page: http://autokeras.com
Author: Data Analytics at Texas A&M (DATA) Lab, Keras Team
Author-email: jhfjhfj1@gmail.com
License: MIT
Location: ...
Requires: tensorflow, packaging, pandas, Sklearn
Required-by: 

一旦安装完成，您就可以应用 AutoKeras 为您的预测建模任务找到一个好的或很棒的神经网络模型。

我们将看两个常见的例子，在这些例子中，您可能希望对表格数据(所谓的结构化数据)使用 AutoKeras、分类和回归。

用于分类的自动分类器

AutoKeras 可用于发现表格数据分类任务的良好或伟大模型。

回想一下，表格数据是由行和列组成的数据集，如表格或您在电子表格中看到的数据。

在本节中，我们将为声纳分类数据集开发一个模型，用于将声纳回波分类为岩石或地雷。该数据集由 208 行数据组成，包含 60 个输入要素，目标类别标签为 0(岩石)或 1(矿山)。

一个简单的模型可以通过重复的 10 倍交叉验证达到大约 53.4%的分类准确率，这提供了一个下限。一个好的模型可以达到 88.2%左右的准确率，提供一个上限。

您可以在此了解有关数据集的更多信息:

• 声纳数据集(声纳. csv)
• 声纳数据集描述(声纳.名称)

不需要下载数据集；作为示例的一部分，我们将自动下载它。

首先，我们可以下载数据集，并将其分成随机选择的训练集和测试集，其中 33%用于测试，67%用于训练。

下面列出了完整的示例。

# load the sonar dataset
from pandas import read_csv
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
dataframe = read_csv(url, header=None)
print(dataframe.shape)
# split into input and output elements
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)
# basic data preparation
X = X.astype('float32')
y = LabelEncoder().fit_transform(y)
# separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

运行该示例首先下载数据集并汇总形状，显示预期的行数和列数。

然后数据集被分成输入和输出元素，然后这些元素被进一步分成训练和测试数据集。

(208, 61)
(208, 60) (208,)
(139, 60) (69, 60) (139,) (69,)

我们可以使用 AutoKeras 为这个数据集自动发现一个有效的神经网络模型。

这可以通过使用 StructuredDataClassifier 类并指定要搜索的模型数量来实现。这定义了要执行的搜索。

...
# define the search
search = StructuredDataClassifier(max_trials=15)

然后，我们可以使用加载的数据集执行搜索。

...
# perform the search
search.fit(x=X_train, y=y_train, verbose=0)

这可能需要几分钟时间，并将报告搜索进度。

接下来，我们可以在测试数据集上评估模型，看看它在新数据上的表现。

...
# evaluate the model
loss, acc = search.evaluate(X_test, y_test, verbose=0)
print('Accuracy: %.3f' % acc)

然后，我们使用该模型对新的数据行进行预测。

...
# use the model to make a prediction
row = [0.0200,0.0371,0.0428,0.0207,0.0954,0.0986,0.1539,0.1601,0.3109,0.2111,0.1609,0.1582,0.2238,0.0645,0.0660,0.2273,0.3100,0.2999,0.5078,0.4797,0.5783,0.5071,0.4328,0.5550,0.6711,0.6415,0.7104,0.8080,0.6791,0.3857,0.1307,0.2604,0.5121,0.7547,0.8537,0.8507,0.6692,0.6097,0.4943,0.2744,0.0510,0.2834,0.2825,0.4256,0.2641,0.1386,0.1051,0.1343,0.0383,0.0324,0.0232,0.0027,0.0065,0.0159,0.0072,0.0167,0.0180,0.0084,0.0090,0.0032]
X_new = asarray([row]).astype('float32')
yhat = search.predict(X_new)
print('Predicted: %.3f' % yhat[0])

我们可以检索最终的模型，它是 TensorFlow Keras 模型的一个实例。

...
# get the best performing model
model = search.export_model()

然后我们可以总结模型的结构，看看选择了什么。

...
# summarize the loaded model
model.summary()

最后，我们可以将模型保存到文件中以备后用，可以使用 TensorFlow load_model()函数进行加载。

...
# save the best performing model to file
model.save('model_sonar.h5')

将这些联系在一起，下面列出了应用 AutoKeras 为声纳数据集找到有效神经网络模型的完整示例。

# use autokeras to find a model for the sonar dataset
from numpy import asarray
from pandas import read_csv
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from autokeras import StructuredDataClassifier
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
dataframe = read_csv(url, header=None)
print(dataframe.shape)
# split into input and output elements
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)
# basic data preparation
X = X.astype('float32')
y = LabelEncoder().fit_transform(y)
# separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)
# define the search
search = StructuredDataClassifier(max_trials=15)
# perform the search
search.fit(x=X_train, y=y_train, verbose=0)
# evaluate the model
loss, acc = search.evaluate(X_test, y_test, verbose=0)
print('Accuracy: %.3f' % acc)
# use the model to make a prediction
row = [0.0200,0.0371,0.0428,0.0207,0.0954,0.0986,0.1539,0.1601,0.3109,0.2111,0.1609,0.1582,0.2238,0.0645,0.0660,0.2273,0.3100,0.2999,0.5078,0.4797,0.5783,0.5071,0.4328,0.5550,0.6711,0.6415,0.7104,0.8080,0.6791,0.3857,0.1307,0.2604,0.5121,0.7547,0.8537,0.8507,0.6692,0.6097,0.4943,0.2744,0.0510,0.2834,0.2825,0.4256,0.2641,0.1386,0.1051,0.1343,0.0383,0.0324,0.0232,0.0027,0.0065,0.0159,0.0072,0.0167,0.0180,0.0084,0.0090,0.0032]
X_new = asarray([row]).astype('float32')
yhat = search.predict(X_new)
print('Predicted: %.3f' % yhat[0])
# get the best performing model
model = search.export_model()
# summarize the loaded model
model.summary()
# save the best performing model to file
model.save('model_sonar.h5')

运行该示例将报告大量关于搜索进度的调试信息。

模型和结果都保存在当前工作目录中名为“结构化数据分类器的文件夹中。

...
[Trial complete]
[Trial summary]
 |-Trial ID: e8265ad768619fc3b69a85b026f70db6
 |-Score: 0.9259259104728699
 |-Best step: 0
 > Hyperparameters:
 |-classification_head_1/dropout_rate: 0
 |-optimizer: adam
 |-structured_data_block_1/dense_block_1/dropout_rate: 0.0
 |-structured_data_block_1/dense_block_1/num_layers: 2
 |-structured_data_block_1/dense_block_1/units_0: 32
 |-structured_data_block_1/dense_block_1/units_1: 16
 |-structured_data_block_1/dense_block_1/units_2: 512
 |-structured_data_block_1/dense_block_1/use_batchnorm: False
 |-structured_data_block_1/dense_block_2/dropout_rate: 0.25
 |-structured_data_block_1/dense_block_2/num_layers: 3
 |-structured_data_block_1/dense_block_2/units_0: 32
 |-structured_data_block_1/dense_block_2/units_1: 16
 |-structured_data_block_1/dense_block_2/units_2: 16
 |-structured_data_block_1/dense_block_2/use_batchnorm: False

然后在搁置测试数据集上评估表现最佳的模型。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到该模型实现了大约 82.6%的分类准确率。

Accuracy: 0.826

接下来，报告表现最佳的模型的体系结构。

我们可以看到一个模型有两个隐藏层，分别是 drop 和 ReLU 激活。

Model: "model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         [(None, 60)]              0
_________________________________________________________________
categorical_encoding (Catego (None, 60)                0
_________________________________________________________________
dense (Dense)                (None, 256)               15616
_________________________________________________________________
re_lu (ReLU)                 (None, 256)               0
_________________________________________________________________
dropout (Dropout)            (None, 256)               0
_________________________________________________________________
dense_1 (Dense)              (None, 512)               131584
_________________________________________________________________
re_lu_1 (ReLU)               (None, 512)               0
_________________________________________________________________
dropout_1 (Dropout)          (None, 512)               0
_________________________________________________________________
dense_2 (Dense)              (None, 1)                 513
_________________________________________________________________
classification_head_1 (Sigmo (None, 1)                 0
=================================================================
Total params: 147,713
Trainable params: 147,713
Non-trainable params: 0
_________________________________________________________________

回归的自动 Keras

AutoKeras 也可以用于回归任务，即预测数值的预测建模问题。

我们将使用汽车保险数据集，该数据集包括根据索赔总数预测总付款。数据集有 63 行，一个输入变量和一个输出变量。

使用重复的 10 倍交叉验证，一个简单的模型可以获得大约 66 的平均绝对误差(MAE)，提供了预期表现的下限。一个好的模型可以达到 28 左右的 MAE，提供一个表现上限。

您可以在此了解有关此数据集的更多信息:

• 车险数据集(auto-insurance.csv)
• 汽车保险数据集(汽车保险.名称)

我们可以加载数据集并将其分成输入和输出元素，然后训练和测试数据集。

下面列出了完整的示例。

# load the sonar dataset
from pandas import read_csv
from sklearn.model_selection import train_test_split
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'
dataframe = read_csv(url, header=None)
print(dataframe.shape)
# split into input and output elements
data = dataframe.values
data = data.astype('float32')
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)
# separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

运行该示例加载数据集，确认行数和列数，然后将数据集拆分为训练集和测试集。

(63, 2)
(63, 1) (63,)
(42, 1) (21, 1) (42,) (21,)

可以使用 StructuredDataRegressor 类将自动 Keras 应用于回归任务，并为要试用的模型数量进行配置。

...
# define the search
search = StructuredDataRegressor(max_trials=15, loss='mean_absolute_error')

然后可以运行搜索并保存最佳模型，就像在分类案例中一样。

...
# define the search
search = StructuredDataRegressor(max_trials=15, loss='mean_absolute_error')
# perform the search
search.fit(x=X_train, y=y_train, verbose=0)

然后，我们可以使用表现最好的模型，并在等待数据集上对其进行评估，对新数据进行预测，并总结其结构。

...
# evaluate the model
mae, _ = search.evaluate(X_test, y_test, verbose=0)
print('MAE: %.3f' % mae)
# use the model to make a prediction
X_new = asarray([[108]]).astype('float32')
yhat = search.predict(X_new)
print('Predicted: %.3f' % yhat[0])
# get the best performing model
model = search.export_model()
# summarize the loaded model
model.summary()
# save the best performing model to file
model.save('model_insurance.h5')

将这些联系在一起，下面列出了使用 AutoKeras 为汽车保险数据集发现有效神经网络模型的完整示例。

# use autokeras to find a model for the insurance dataset
from numpy import asarray
from pandas import read_csv
from sklearn.model_selection import train_test_split
from autokeras import StructuredDataRegressor
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'
dataframe = read_csv(url, header=None)
print(dataframe.shape)
# split into input and output elements
data = dataframe.values
data = data.astype('float32')
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)
# separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)
# define the search
search = StructuredDataRegressor(max_trials=15, loss='mean_absolute_error')
# perform the search
search.fit(x=X_train, y=y_train, verbose=0)
# evaluate the model
mae, _ = search.evaluate(X_test, y_test, verbose=0)
print('MAE: %.3f' % mae)
# use the model to make a prediction
X_new = asarray([[108]]).astype('float32')
yhat = search.predict(X_new)
print('Predicted: %.3f' % yhat[0])
# get the best performing model
model = search.export_model()
# summarize the loaded model
model.summary()
# save the best performing model to file
model.save('model_insurance.h5')

运行该示例将报告大量关于搜索进度的调试信息。

模型和结果都保存在当前工作目录中名为“structured _ data _ reversor”的文件夹中。

...
[Trial summary]
|-Trial ID: ea28b767d13e958c3ace7e54e7cb5a14
|-Score: 108.62509155273438
|-Best step: 0
> Hyperparameters:
|-optimizer: adam
|-regression_head_1/dropout_rate: 0
|-structured_data_block_1/dense_block_1/dropout_rate: 0.0
|-structured_data_block_1/dense_block_1/num_layers: 2
|-structured_data_block_1/dense_block_1/units_0: 16
|-structured_data_block_1/dense_block_1/units_1: 1024
|-structured_data_block_1/dense_block_1/units_2: 128
|-structured_data_block_1/dense_block_1/use_batchnorm: True
|-structured_data_block_1/dense_block_2/dropout_rate: 0.5
|-structured_data_block_1/dense_block_2/num_layers: 2
|-structured_data_block_1/dense_block_2/units_0: 256
|-structured_data_block_1/dense_block_2/units_1: 64
|-structured_data_block_1/dense_block_2/units_2: 1024
|-structured_data_block_1/dense_block_2/use_batchnorm: True

然后在搁置测试数据集上评估表现最佳的模型。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到模型实现了大约 24 的 MAE。

MAE: 24.916

接下来，报告表现最佳的模型的体系结构。

我们可以看到一个带有两个隐藏层的模型，带有 ReLU 激活。

Model: "model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         [(None, 1)]               0
_________________________________________________________________
categorical_encoding (Catego (None, 1)                 0
_________________________________________________________________
dense (Dense)                (None, 64)                128
_________________________________________________________________
re_lu (ReLU)                 (None, 64)                0
_________________________________________________________________
dense_1 (Dense)              (None, 512)               33280
_________________________________________________________________
re_lu_1 (ReLU)               (None, 512)               0
_________________________________________________________________
dense_2 (Dense)              (None, 128)               65664
_________________________________________________________________
re_lu_2 (ReLU)               (None, 128)               0
_________________________________________________________________
regression_head_1 (Dense)    (None, 1)                 129
=================================================================
Total params: 99,201
Trainable params: 99,201
Non-trainable params: 0
_________________________________________________________________

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

• 自动机器学习，维基百科。
• 神经架构搜索，维基百科。
• 自动贩卖机主页。
• AutoKeras GitHub 项目。
• Auto-keras:一个高效的神经架构搜索系统，2019。
• 标准分类和回归机器学习数据集的结果

摘要

在本教程中，您发现了如何使用 AutoKeras 为分类和回归任务找到良好的神经网络模型。

具体来说，您了解到:

• AutoKeras 是 AutoML 的一个实现，用于使用神经架构搜索的深度学习。
• 如何使用 AutoKeras 为二进制分类数据集找到表现最佳的模型。
• 如何使用 AutoKeras 为回归数据集查找表现最佳的模型。

你有什么问题吗？ 在下面的评论中提问，我会尽力回答。

Keras 深度学习库的二分类教程

原文： 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 的示例。

图片由Mattia Merlo 提供，并保留所属权利。

1.数据集的描述

我们将在本教程中使用的数据集是 Sonar 数据集。

这是一个描述声纳啁啾返回弹跳不同服务的数据集，60 个输入变量是不同角度的回报强度。这是一个二分类问题，需要构建一个模型来区分岩石和金属。

您可以在 UCI 机器学习库上了解有关此数据集的更多信息。您可以免费下载数据集并将其放在工作目录中，文件名为 sonar.csv。

这是一个众所周知的数据集。所有变量都是连续的，通常在 0 到 1 的范围内。输出变量是代表矿石的字符“M”和代表岩石的字符“R”

使用此数据集的好处是它是一个标准的基准问题，这意味着我们对构建一个较好模型的预期技巧有所了解。使用交叉验证，神经网络应该能够达到 84％左右的表现，定制模型的精确度上限约为 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

接下来，我们可以初始化随机数生成器，以确保在执行此代码时始终获得相同的结果。如果我们正在调试模型，这将对我们有所帮助。

# 固定随机种子的在线性
seed = 7
numpy.random.seed(seed)

现在我们可以使用 pandas 加载数据集，并将列拆分为 60 个输入变量（X）和 1 个输出变量（Y），我们使用 pandas 来加载数据，因为它可以轻松处理字符串（输出变量），如果尝试使用 NumPy 直接加载数据会比较困难。

# 加载数据集
dataframe = pandas.read_csv("sonar.csv", header=None)
dataset = dataframe.values
# 将数据集分割为输入变量和输出变量
X = dataset[:,0:60].astype(float)
Y = dataset[:,60]

输出变量是字符串值，我们必须将它们转换为整数值 0 和 1。

我们可以使用 scikit-learn 中的 LabelEncoder 类来完成此操作。此类将通过 fit()函数使用整个数据集对所需的编码进行建模，然后应用编码以使用transform()函数创建新的输出变量。

# 转换字符编码
encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)

我们现在准备使用 Keras 创建我们的神经网络模型。

我们将使用 scikit-learn 来使用分层 k 折交叉验证来评估模型，这是一种重采样技术，可以提供模型表现的估计。它通过将数据集分成 k 个部分来实现这一点，除了作为测试集的一部分用以评估模型的表现外，在其他所有训练数据上训练模型，该过程重复 k 次，并且所有构建的模型的平均分数被用作模型表现的稳健估计，因为它是分层的设计，这意味着它将查看输出值并尝试平衡属于数据 k 分裂中每个类的实例数。

要将 Keras 模型与 scikit-learn 一起使用，我们必须使用 KerasClassifier 封装器。该类采用创建并返回神经网络模型的函数，将参数传递给 fit()调用，例如迭代数和批量大小。

让我们从定义创建基线模型的函数开始,我们的模型将具有单个完全连接的隐藏层，其具有与输入变量相同数量的神经元,这是创建神经网络时的一个很好的默认起点。

使用较小的高斯随机数初始化权重参数，使用整流器激活函数，输出层包含单个神经元以做出预测，它使用 sigmod()激活函数，以产生 0 到 1 范围内的概率输出，可以轻松地转换为清晰的类值（如 0 和 1）。

最后，我们在训练期间使用对数损失函数（binary_crossentropy），这是二分类问题的首选损失函数。该模型还使用高效的 Adam 优化算法进行梯度下降，并在训练模型时收集精度度量指标。

# 基线模型
def create_baseline():
	# 创建模型
	model = Sequential()
	model.add(Dense(60, input_dim=60, kernel_initializer='normal', activation='relu'))
	model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
	# 编译模型
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model

现在可以在在 scikit-learn 框架中使用分层交叉验证来评估这个模型。

我们再次使用合理的默认值将训练时期的数量传递给 KerasClassifier，设定 00 模型将被创建 10 次以进行 10 次交叉验证，并且关闭详细输出选项（即参数verbose = 0）。

# 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.使用数据预处理并重新运行基线模型

在建模之前进行数据预处理是一种很好的做法。

神经网络模型尤其适用于在数据规模和分布方面具有一致性的输入值。

建立神经网络模型时表格数据的有效数据 chuli1 方案是标准化，这是重缩放数据，使得数据每个属性的平均值为 0，标准偏差为 1.这种处理方法保留了高斯和高斯类分布，同时规范了数据每个属性的中心趋势。

我们可以使用 scikit-learn 使用 StandardScaler 类来执行 Sonar 数据集的标准化。

优化算法的方法是在交叉验证运行的过程中对训练数据进行标准化处理，并使用经过训练的标准化数据来预处理“不可见”的测试折叠，而不是对整个数据集执行标准化。这使得标准化成为交叉验证过程中模型预处理的一个必要步骤，并且能够阻止算法在评估期间具有从数据预处理过程中传递的“不可见”信息，如更清晰的分布。 我们可以使用 Pipeline 在 scikit-learn 中实现这一点，此管道是一个包装器，它在交叉验证过程的传递中执行一个或多个模型。在这里，我们可以使用 StandardScaler 定义管道，然后将其应用于我们的神经网络模型。

# 使用标准数据集评估基线模型
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 个。这将在训练期间对网络施加压力，以挑选输入数据中最重要的结构进行建模。

我们还将在数据准备的前一个实验中对数据进行标准化，并尝试利用数据标准化后表现较小的提升。

# 更小的模型
def create_smaller():
	# 创建模型
	model = Sequential()
	model.add(Dense(30, input_dim=60, kernel_initializer='normal', activation='relu'))
	model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
	# 编译模型
	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

这里的方法是，网络有机会在瓶颈之前对所有输入变量进行建模，并被强制将表示能力减半，就像我们在上书的缩小网络拓扑的实验中所做的那样。

我们有一个额外的隐藏层来实现这个过程，而不是压缩输入层本身的表示。

# 更大的模型
def create_larger():
	# 创建模型
	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 的深度学习或此帖子有任何疑问吗？在评论中提出您的问题，我会尽力回答。