将 Keras 用于深度学习的图像增强
原文：
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 图像增谦 API
与 Keras 的其他部分一样，图像增强 API 简单而强大。
Keras 提供 ImageDataGenerator 类，用于定义图像数据准备和扩充的配置。这包括以下功能：
- 样本标准化。
- 特征标准化。
- 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 的更多信息。
图像增强的比较点
既然您已了解 Keras 中的图像增强 API 的工作原理，那么让我们看一些示例。
我们将在这些示例中使用 MNIST 手写数字识别任务。首先，让我们看一下训练数据集中的前 9 个图像。
# 绘制图像
from keras.datasets import mnist
from matplotlib import pyplot
# 加载数据
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# 创建一个 3×3 的网格图像
for i in range(0, 9):
pyplot.subplot(330 + 1 + i)
pyplot.imshow(X_train[i], cmap=pyplot.get_cmap('gray'))
# 显示图像
pyplot.show()
运行此示例提供了以下图像，可以将以下示例中的图像处理和增强当作一个比较点。
示例 MNIST 图像
特征标准化
还可以标准化整个数据集中的像素值，这称为特征标准化，并反映了通常对表格数据集中的每列执行的标准化类型。
您可以通过在 ImageDataGenerator 类上设置 featurewise_center 和 featurewise_std_normalization 参数来执行特征标准化。实际上，默认情况下这些参数设置为 True，并且创建没有参数的 ImageDataGenerator 实例将具有相同的效果。
# 标准化图像数据集，均值为 0，方差为 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')
# 加载数据
(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)
# 将 int 类型转化为 float 型
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# 定义数据处理
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):
# 创建 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'))
# 绘制图像
pyplot.show()
break
运行此示例，您可以看到效果不同，看似变暗并使不同的数字变亮。
标准化特征 MNIST 图像
ZCA 白化
图像的白化变换是线性代数运算，其减少了像素图像矩阵中的冗余。
图像中较少的冗余旨在更好地突出图像中的结构和特征并应用到学习算法。
通常，使用主成分分析（PCA）技术执行图像白化。最近，一种名为 ZCA 的替代方案（在本技术报告的附录 A 中了解更多）显示了更好的结果和结果，在转换后的图像中保留了所有原始尺寸，与 PCA 不同，变换后的图像看起来仍然像他们的原件。
您可以通过将 zca_whitening 参数设置为 True 来执行 ZCA 白化转换。
# ZCA 白化
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')
# 加载数据集
(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)
# 将 int 类型转化为 float 型
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# 定义数据处理
datagen = ImageDataGenerator(zca_whitening=True)
# 从数据中拟合参数
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'))
# 显示图像
pyplot.show()
break
运行该示例，您可以在图像中看到相同的一般结构，以及如何突出显示每个数字的轮廓。
ZCA 白化 MNIST 图像
随机旋转
有时，样本数据中的图像可能在不同场景中具有不同的角度。
您可以训练模型，以便在训练期间通过人工和随机旋转数据集中的图像来更好地处理图像旋转。
下面的示例通过设置 rotation_range 参数创建最多 达 90 度的 MNIST 数字的随机旋转。
# 随机旋转
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')
# 加载数据
(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)
# 将 int 类型转化为 float 类型
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'))
# 显示图像
pyplot.show()
break
运行该示例，您可以看到图像已经发生了旋转，并且最大角度达到了 90 度，这对具有标准方向的 MINIST 的数字来说，可能意义不大，但是当学习的照片中物体具有不同的方向时，这种变换可能会有所帮助。
MNIST 图像的随机旋转
随机移位
图像中的物体可能无法在框架中居中。他们可能以各种不同的方式偏离中心。
您可以通过人工创建训练数据的移位版本来训练您的深度学习网络以期望并且当前处理偏离中心的对象。 Keras 通过 width_shift_range 和 height_shift_range 参数支持训练数据的水平移位或者垂直移位。
# 随机移位
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')
# 加载数据集
(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)
# 将数据集从 int 类型转化为 float 类型
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# 定义数据处理
shift = 0.2
datagen = ImageDataGenerator(width_shift_range=shift, height_shift_range=shift)
# 从数据中拟合参数
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'))
# 显示图像
pyplot.show()
break
运行此示例会创建数字的移位版本，同样，这不是 MNIST 所必需的，因为手写数字已经居中，但您可以看到这种操作对于更复杂的问题有何帮助。
随机移位的 MNIST 图像
随机翻转
另一种可以提高大型复杂问题表现的图像数据增强函数是在训练数据中创建随机翻转的图像。
Keras 支持使用 vertical_flip 和 horizontal_flip 参数沿垂直轴和水平轴进行随机翻转。
# 随机翻转
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')
# 加载数据集
(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)
# 将 int 类型转化为 float 类型
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# 定义数据处理
datagen = ImageDataGenerator(horizontal_flip=True, vertical_flip=True)
# 从数据中拟合参数
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'))
# 显示图像
pyplot.show()
break
运行此示例，您可以看到翻转的数字，翻转的图像对于总是有正确左右方向的数据可能没有用，但这对于场景中可以具有不同方向的物体的照片的问题可能是有所帮助的
随机翻转 MNIST 图像
将增强图像保存到文件
数据准备和增强由 Keras 及时执行。
这在内存方面很有效，但您可能需要在训练期间使用的确切图像，例如，您可能希望稍后将它们与不同的软件包一起使用，或者仅生成一次并在多个不同的深度学习模型或配置中使用它们。
Keras 允许您保存训练期间生成的图像，可以在训练之前将目录，文件名前缀和图像文件类型指定给flow()函数，然后，在训练期间，生成的图像将会被写入文件。
下面的示例演示了这一点，并将 9 个图像写入“images”子目录，前缀为“aug”，文件类型为 PNG。
# 将增强之后的图像保存到文件中
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')
# 加载数据集
(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)
# 将 int 类型转换为 float 类型
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# 定义数据处理
datagen = ImageDataGenerator()
# 从数据中拟合参数
datagen.fit(X_train)
# 配置批大小并且保存一个批大小的图像数量
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'):
# 创建一个 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'))
# 显示图像
pyplot.show()
break
运行该示例，您可以看到图像仅在生成时写入。
增强的 MNIST 图像保存到文件
使用 Keras 增强图像数据的技巧
图像数据的独特之处在于，您可以查看数据和转换的数据副本，并快速了解模型如何感知模型。
以下是一些从图像数据准备和深度学习扩充中获取最多的技巧。
- 审查数据集：花些时间详细检查您的数据集，看看图片，记下可能有益于模型训练过程的图像处理和扩充，例如需要处理场景中对象的不同移位，旋转或翻转。
- 审查增补：在执行增强后查看样本图像，在理智上知道您正在使用的图像变换是一回事，看一些例子是一件非常不同的事情，使用您正在使用的单个扩充以及您计划使用的全部扩充来查看图像，您可能会看到简化或进一步增强模型训练流程的方法。
- 评估变换套件：尝试多个图像数据准备和增强方案，通常，您可能会对您认为不会有益的数据处理方案的结果感到惊讶。
摘要
在这篇文章中，您学习了图像数据的处理和扩充。
您发现了一系列技术，您可以在 Python 中轻松使用 Keras 进行深度学习模型。你了解到：
- Keras 中的 ImageDataGenerator API 用于及时生成转换后的图像。
- 样本和特征的像素标准化。
- ZCA 白化。
- 随机旋转，移位和翻转图像。
- 如何将转换后的图像保存到文件中以供以后重用。
您对图像数据增加或此帖有任何疑问吗？在评论中提出您的问题，我会尽力回答。
8 个深度学习的鼓舞人心的应用
原文：
machinelearningmastery.com/inspirational-applications-deep-learning/
如果说深度学习是在一系列复杂问题中实现最先进的结果，这种说法是有些夸张的。
目前，人工智能，机器学习和深度学习方面有在很多问题得处理上取得了令人兴奋的结果，这也是进入一些真正强大的技术底层的绝佳机会。
我努力说服朋友，同事和学生开始深入学习，如上所述的大胆陈述是不够的。它需要故事，图片和研究论文。
在这篇文章中，您将了解一些深度学习方面近期令人激动的应用，这些应用能够有效激励您深入了解深度学习。
开始深度学习并不一定意味着去研究未来 2-3 年的方程，这只可能意味着下载 Keras 并开始在 5 分钟内运行你的第一个模型。开始应用深度学习，构建事物，并将其转化为系统和代码，这是一件令人兴奋的事情。
最近，我一直想写这篇文章，让我们开始吧!
照片由 Nick Kenrick 提供，并保留所属权利。
概述
以下是我们将在本文中看到的具体示例列表。
并非所有的示例都是需要“黄金时间”的准备的技术，但可以保证，它们都是一些令你激动的的例子。
如果你已经深入了解了一些深度学习的知识，那么这些例子似乎会有一些简单，但是，事实上，在更广法的范围内，这些例子仍然令人印象深刻
坦率地说，对于像我这样的老 AI 黑客，认为其中的一些例子在未来几十年不可能得到解决，但是深度学习的出现啪啪打脸！
我将重点放在视觉示例上，因为我们可以查看屏幕截图和视频以立即了解算法的作用，但是自然语言中包含文本和音频数据的示例（如果没有更多的话）的数量就不多了。
本篇文章中，我们会了解以下示例：
- 黑白图像的着色。
- 为无声电影添加声音。
- 自动机器翻译。
- 照片中的物体分类。
- 自动手写生成。
- 字符文本生成。
- 图像标题生成。
- 自动游戏。
1.黑白图像的自动着色
图像着色是向黑白照片添加颜色的问题。
传统上这是手工完成，因为这是一项艰巨的任务。
深度学习可用于在照片中使用对象及其背景信息来为图像着色，就像人类操作员一样会解决问题。
令人印象深刻的视觉壮举。
此功能利用了为 ImageNet 训练并被选为图像着色问题的高质量和超大型卷积神经网络。
通常，该方法涉及使用非常大的卷积神经网络和监督层，其通过添加颜色来重建图像。
黑白照片的着色
图片取自 Richard Zhang，Phillip Isola 和 Alexei A. Efros 。
令人印象深刻的是，相同的方法可用于着色黑白电影的静止帧
进一步阅读
文件
- 深色着色 [pdf]，2015
- 彩色图像着色pdf，2016
- 自动着色的学习表示 [pdf]（网站），2016
- 深度卷积神经网络的图像着色 [pdf]，2016
2.自动为无声电影添加声音
在此任务中，系统必须合成声音以匹配静音视频。
该系统使用 1000 个视频示例进行训练，其中鼓棒的声音撞击不同的表面并产生不同的声音。深度学习模型将视频帧与预先重新录制的声音数据库相关联，以便选择与场景中发生的最佳匹配的声音。
然后使用图像测试设置评估系统，其中人类必须确定哪个视频具有真实或假（合成）声音。
卷积神经网络和 LSTM 递归神经网络能实现非常酷的应用。
进一步阅读
文件
3.自动机器翻译
这是一种给定的单词，短语或句子在一种语言中，自动将其翻译成另一种语言的任务。
自动机器翻译已经存在了很长时间，但深度学习在两个特定领域取得了最佳成果：
- 文本的自动翻译。
- 图像的自动翻译。
可以在不对序列进行任何预处理的情况下执行文本转换，从而允许算法学习单词之间的依赖关系以及它们与新语言的映射，通常使用大型 LSTM 递归神经网络的堆叠网络来执行该转换。
正如您所料，卷积神经网络用于识别具有字母的图像以及字母在场景中的位置，识别后，可以将它们转换为文本，翻译并使用翻译后的文本重新创建图像，这通常被称为即时视觉翻译。
即时视觉翻译
即时视觉翻译示例，取自 Google 博客。
进一步阅读
在这个例子中很难找到好的资源，如果你知道的话，可以发表评论。
文件
- 用神经网络进行序列学习的序列 [pdf]，2014
- 使用 RNN 编解码器进行统计机器翻译的学习短语表示 [pdf]，2014
- 机器翻译中的深度神经网络：概述 [pdf]，2015
4.照片中的物体分类和检测
该任务需要将照片内的对象分类为一组先前已知的对象之一。
使用非常大的卷积神经网络，已经在该问题的基准示例上获得了最新的结果，关于 ImageNet 分类问题 AlexNet 的结果，Alex Krizhevsky 等人在此问题上取得了突破。
使用深度卷积神经网络从 ImageNet 分类中获取的对象分类示例
该任务的更复杂的变体是物体检测涉及具体识别照片场景内的一个或多个物体并在它们周围画出边框。
Photogaphs 中的物体检测示例
取自 Google 博客。
进一步阅读
文件
- 具有深度卷积神经网络的 ImageNet 分类 [pdf]，2012
- 基于深度卷积神经网络的图像分类的一些改进 [pdf]，2013
- 使用深度神经网络的可扩展物体检测 [pdf]，2013
- 用于物体检测的深度神经网络 [pdf]，2013
5.自动手写生成
这是给定一个手写示例语料库，为给定的单词或短语生成新的手写字体的任务。
手写体是作为创建手写样本时笔使用的坐标序列提供的，从该语料库中学习笔移动和字母之间的关系，可以生成新的示例。
令人着迷的是，可以学习不同的风格，然后模仿，我很乐意看到这项工作与一些法医手写分析专业知识相结合。
自动手写生成示例
进一步阅读
文件
- 使用递归神经网络生成序列 [pdf]，2013
6.自动文本生成
这是一项学习了文本语料库，并且从该模型逐字或逐字符地生成新文本的任务。
该模型能够学习如何拼写，标点，形成感知，甚至捕捉语料库中文本的样式。
大型递归神经网络用于学习输入字符串序列中的项之间的关系，然后生成文本。最近，LSTM 循环神经网络使用基于字符的模型在这个问题上取得了巨大的成功，并且该模型一次生成一个字符。
Andrej Karpathy 在他关于该主题的热门博客文章中提供了许多例子，包括：
- 保罗格雷厄姆散文
- 莎士比亚
- 维基百科文章（包括标记）
- 代数几何（带 LaTeX 标记）
- Linux 源代码
- 宝贝名字
莎士比亚的自动文本生成示例
摘自 Andrej Karpathy 博客文章
进一步阅读
文件
- 使用递归神经网络生成文本 [pdf]，2011
- 使用递归神经网络生成序列 [pdf]，2013
7.图像自动生成标题
自动生成图像标题是给定图像内容，系统必须生成描述图像内容的标题的任务。
2014 年，深度学习算法爆炸式增长，在此问题上取得了令人印象深刻的成果，利用顶级模型的工作进行目标分类和照片中的目标检测。
一旦您可以检测照片中的对象并为这些对象生成标签，您就会发现下一步是将这些标签转换为连贯的句子描述图像内容。
这是那些让我震惊不已的结果之一。 确实非常令人印象深刻。
通常，该系统涉及使用非常大的卷积神经网络用于照片中的物体检测，然后使用像 LSTM 那样的递归神经网络将标签生成连贯的句子。
自动图像标题生成
样本取自 Andrej Karpathy，李飞飞
这些技术也已扩展为自动生成视频标题。
进一步阅读
文件
- 用于生成图像描述的深层视觉语义对齐 [pdf]（和网站），2015
- 用多模式回归神经网络解释图像 [pdf，2014]
- 用于视觉识别和描述的长期循环卷积网络 [pdf]，2014
- 用多模态神经语言模型统一视觉语义嵌入 [pdf]，2014
- 序列到序列 - 视频到文本 [pdf]，2015
8.自动游戏
这是一个模型学习如何仅根据屏幕上的像素来玩电脑游戏的任务。
这是一个深度强化模型的领域非常困难的任务，并且 DeepMind （现在是谷歌的一部分）因实现该问题的突破性进展而闻名。
这项工作得到了扩展，并在谷歌 DeepMind 的 AlphaGo 中达到顶峰，该游戏在 Go 游戏中击败了世界大师。
进一步阅读
文件
- 使用深度强化学习 [pdf]，2013 年播放 Atari
- 通过深度强化学习进行人类控制，2015 年
- 用深度神经网络和树搜索掌握 Go 游戏，2016
其他例子
以下是上面列出的一些其他示例。
- 自动语音识别。
- 用于语音识别中声学建模的深度神经网络 [pdf]，2012
- 自动语音理解。
- 采用递归神经网络进行端到端语音识别 [pdf]，2014
- 自动将注意力集中在图像中的目标上。
- 视觉注意的复发模型 [pdf]，2014
- 自动回答有关照片中对象的问题。
- 探索图像问答的模型和数据 [pdf]，2015
- 自动将手稿转换为照片。
- 卷积手稿反演 [pdf]，2016
- 从粗略手稿自动创建风格化图像。
从草图自动创建样式图像
由 NeuralDoodle 提供图像
更多资源
有很多很棒的资源，会谈和更多帮助你对深度学习的能力和潜力感到兴奋。
以下是一些额外的资源，可以帮助您激动。
- 深度学习的不合理效果，Yann LeCun 在 2014 年的演讲
- 令人敬畏的深度视觉顶级深度学习计算机视觉论文列表
- 可以学习的计算机的精彩和恐怖的含义，Jeremy Howard 的 TED 演讲
- 哪种算法取得了最佳效果，计算机视觉数据集的最佳结果列表
- 神经网络如何真正起作用，Geoffrey Hinton 2016
摘要
在这篇文章中，您了解了 8 个深度学习应用程序，旨在激励您能够深入了解深度学习。
这种展示而不是说出的方法有望突破夸张，使您对深度学习技术的当前和未来功能有一个更清晰的了解。
您是否知道这里没有列出任何深度学习的鼓舞人心的例子？ 在评论中让我知道。
Python 深度学习库 Keras 简介
原文：
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 的示例。
Python 深度学习库 Keras 简介
照片由 Dennis Jarvis 拍摄，保留一些权利。
什么是 Keras？
Keras 是一个用于深度学习的极简主义 Python 库，可以在 Theano 或 TensorFlow 之上运行。
它的开发旨在使深度学习模型的研究和开发尽可能快速简便地实现。
它运行在 Python 2.7 或 3.5 上，并且可以在给定底层框架的情况下在 GPU 和 CPU 上无缝执行。它是在许可的 MIT 许可下发布的。
Keras 由FrançoisChollet开发和维护，他是一位 Google 工程师，使用四个指导原则：
- 模块性：模型可以理解为单独的序列或图形。深度学习模型的所有关注点都是可以以任意方式组合的离散组件。
- 极简主义：该库提供了足够的结果，没有多余的装饰和最大化的可读性。
- 可扩展性：新组件有意在框架内轻松添加和使用，供研究人员试用和探索新想法。
- Python ：没有自定义文件格式的单独模型文件。一切都是原生 Python。
如何安装 Keras
如果您已经拥有可用的 Python 和 SciPy 环境，那么 Keras 的安装将相对简单。
您还必须在系统上安装 Theano 或 TensorFlow。
您可以在此处查看两个平台的安装说明：
- Theano 的安装说明
- TensorFlow 的安装说明
使用 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 使用的后端。
最简单的方法是在主目录中添加或编辑 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 的核心是模型(model)的概念。
主要类型的模型称为序列(Sequential)模型，它由多个网络层(layer)线性堆叠。
您可以按照希望执行计算的顺序来创建序列并向其添加层。
一旦定义完成，您就可以配置模型，该模型将利用底层基础框架来优化计算。在此，您可以指定损失函数和所要使用的优化器。
模型配置完成后，必须使用适合数据来训练模型。可以一次完成一批数据，也可以通过启动整个模型训练方案来完成。这是所有计算发生的地方。
完成训练后，您可以使用模型对新数据做出预测。
我们可以总结一下 Keras 深度学习模型的构建过程如下：
- 定义模型。创建序列并添加层。
- 配置模型。指定损失函数和优化器。
- 训练模型。使用数据训练模型。
- 模型预测。使用该模型生成对新数据的预测。
Keras 资源
下面的列表提供了一些其他资源，您可以通过它们来了解有关 Keras 的更多信息。
您是否正在寻找一个良好的深度学习教程来开启学习之旅，请看看：
摘要
在这篇文章中，您了解了用于深度学习研究和开发的 Keras Python 库。
知晓 Keras 专为极简主义和模块化而设计，允许您快速定义深度学习模型并以 Theano 或 TensorFlow 作为后端运行它们。
你对 Keras 或这篇文章有任何疑问吗？请在评论中提出您的问题，我会尽力回答。
Python 深度学习库 TensorFlow 简介
原文：
machinelearningmastery.com/introduction-python-deep-learning-library-tensorflow/
TensorFlow 是一个用于 Google 创建和发布的快速数值计算的 Python 库。
它是一个基础库，可用于直接创建深度学习模型，或使用包装库来简化在 TensorFlow 之上构建的过程。
在这篇文章中，您将学习用于深度学习的 TensorFlow 库。
在我的新书中，通过 18 个渐进式的教程和 9 个项目，探索如何用几行代码为一系列预测性建模问题开发深度学习模型。
让我们开始吧。
Python 深度学习库简介 TensorFlow
摄影： Nicolas Raymond ，保留权利。
什么是 TensorFlow？
TensorFlow 是一个用于快速数值计算的开源库。
它由 Google 创建并维护，并在 Apache 2.0 开源许可下发布。虽然可以访问底层的 C ++ API，但 API 名义上是用于 Python 编程语言的。
与 Theano 等深度学习中使用的其他库不同，TensorFlow 设计用于研究和开发以及企业生产环境系统，尤其是 谷歌搜索 RankBrain 项目 和有趣的DeepDream 项目 ]。
它可以在单 CPU 系统，GPU 以及移动设备和数百台机器的大规模分布式系统上运行。
如何安装 TensorFlow
如果您已经拥有 Python SciPy 环境，那么 TensorFlow 的安装非常简单。
TensorFlow 适用于 Python 2.7 和 Python 3.3+。您可以按照 TensorFlow 网站上的下载和设置说明进行操作。通过 PyPI 进行安装可能是最简单的，并且下载和设置网页上有用于 Linux 或 Mac OS X 平台的 pip 命令的特定说明。
只有 Linux 系统支持 GPU,并且还需要安装 Cuda 工具包。
使用 TensorFlow 创建第一个示例
根据有向图的结构中的数据流和操作来描述计算。
- 节点：节点执行计算并具有零个或多个输入和输出。在节点之间移动的数据称为张量，它是实数值的多维数组。
- 边界 ：该图定义了数据流，分支，循环和状态更新。特殊边缘可用于同步图形中的行为，例如等待完成多个输入的计算。
- 操作：一个操作是一个命名的抽象计算，它可以获取输入属性并产生输出属性。例如，您可以定义加法或乘法操作。
使用 TensorFlow 计算
第一个示例是 TensorFlow上的示例的修改版本。它向你展示了如何创建一个 session，在这个 session 中定义常量并使用常量进行计算。
import tensorflow as tf
sess = tf.Session()
a = tf.constant(10)
b = tf.constant(32)
print(sess.run(a+b))
运行此示例显示：
42
使用 TensorFlow 进行线性回归
第二个示例来自 TensorFlow 教程的介绍。
此示例显示了如何定义变量（例如 W 和 b）以及变量（y）接收结果输出。
我们对 TensorFlow 有一定的了解，它将计算的定义和声明与 session 中的执行和运行调用分开。
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))
您可以在基本使用指南中了解有关 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 小批量 skip-gram 模型。
- 多线程 word2vec 全量 skip-gram 模型。
- CNN CIFAR-10 网络。
- 简单，端到端，类似 LeNet-5 的卷积 MNIST 模型示例。
- Seq2seq 模型。
还要检查 examples 目录，因为它包含使用 MNIST 数据集的示例。
在 TensorFlow 主网站上还有一个很全好的教程列表。它们展示了如何使用不同的网络类型，不同的数据集以及如何以各种不同的方式使用框架。
最后，有 TensorFlow 实验室，您可以在 Web 浏览器中试验小型网络。
TensorFlow 资源
更多资源
摘要
在这篇文章中，您发现了用于深度学习的 TensorFlow Python 库。
您了解到它是一个快速数值计算库，专门为大型深度学习模型的开发和评估所需的操作类型而设计。
您对 TensorFlow 或者这篇文章有任何疑问吗？在评论中提出您的问题，我会尽力回答。
Python 深度学习库 Theano 简介
原文：
machinelearningmastery.com/introduction-python-deep-learning-library-theano/
Theano 是一个用于快速数值计算的 Python 库，可以在 CPU 或 GPU 上运行。
它是 Python 中深度学习的关键基础库，您可以直接使用它来创建深度学习模型或包装库，从而大大简化过程。
在这篇文章中，您将发现 Theano Python 库。
Python 深度学习库 Theano
照片由 Kristoffer Trolle 拍摄，保留一些权利。
什么是 Theano？
Theano 是一个根据 BSD 许可发布的开源项目，由加拿大魁北克省蒙特利尔大学（现为 Yoshua Bengio 的所在地）的 LISA（现为 MILA ）小组开发。它以希腊数学家的名字命名。
在它的核心 Theano 是 Python 中数学表达式的编译器。它知道如何使用您的结构并将它们转换为非常有效的代码，使用 NumPy，高效的本机库（如 BLAS 和本机代码（C ++））在 CPU 或 GPU 上尽可能快地运行。
它使用大量巧妙的代码优化来尽可能地从硬件中获取尽可能多的表现。如果你深入研究代码中数学优化的细节，请查看这个有趣的列表。
Theano 表达式的实际语法是象征性的，这可能不适合初学者用于正常的软件开发。具体而言，表达式在抽象意义上定义，编译后实际用于进行计算。
它专门用于处理深度学习中使用的大型神经网络算法所需的计算类型。它是同类中最早的库之一（2007 年开始开发），被认为是深度学习研究和开发的行业标准。
如何安装 Theano
Theano 为主要操作系统提供了广泛的安装说明：Windows，OS X 和 Linux。阅读适合您平台的安装 Theano 指南。
Theano 假设使用 SciPy 工作的 Python 2 或 Python 3 环境。有一些方法可以使安装更容易，例如使用 Anaconda 在您的机器上快速设置 Python 和 SciPy 以及使用 Docker 图像。
使用 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 或 Mac OS X 的 GPU 指南设置 Theano 使用 GPU 和使用 GPU 指南如何测试是否可以工作中。
简单的 Theano 例子
在本节中，我们将演示一个简单的 Python 脚本，它为您提供了 Theano 的味道。
它取自 Theano 概览指南。在这个例子中，我们定义了两个符号浮点变量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 库为创建深度学习模型提供了便利类，但仍希望您了解并使用 Theano 语法。这对于知道或愿意学习一点 Theano 的初学者来说也是有益的。
- 另一个例子是 Keras 完全隐藏 Theano 并提供了一个非常简单的 API 来创建深度学习模型。它很好地隐藏了 Theano，它实际上可以作为另一个流行的基础框架 TensorFlow 的包装器运行。
我强烈建议您直接尝试使用 Theano，然后选择一个包装库来学习和练习深度学习。
有关在 Theano 上构建的库的完整列表，请参阅 Theano Wiki 上的相关项目指南。
更多 Theano 资源
在 Theano 寻找更多资源？看看下面的一些内容。
- Theano 官方主页
- Theano GitHub 存储库
- Theano：Python 中的 CPU 和 GPU 数学编译器（2010）（PDF）
- 在 Theano 上建立的库名单
- Theano 配置选项列表
Theano 和深度学习教程
获得 Theano 的帮助
摘要
在这篇文章中，您发现了 Theano Python 库，用于高效的数值计算。
您了解到它是一个用于深度学习研究和开发的基础库，它可以直接用于创建深度学习模型，或者通过基于它的便利库（如 Lasagne 和 Keras）。
您对 Theano 或 Python 中的深度学习有任何疑问吗？在评论中提出您的问题，我会尽力回答。
如何将 Keras 函数式 API 用于深度学习
原文：
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 个部分;他们是：
- Keras 顺序模型
- Keras 功能模型
- 标准网络模型
- 共享层模型
- 多种输入和输出模型
- 最佳实践
- 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
_________________________________________________________________
还会创建模型图的图并将其保存到文件中。
多层感知机网络图
卷积神经网络
在本节中，我们将定义用于图像分类的卷积神经网络。
该模型接收黑白 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
_________________________________________________________________
还会创建模型图的图并将其保存到文件中。
卷积神经网络图
递归神经网络
在本节中，我们将定义一个用于序列分类的长期短期记忆递归神经网络。
该模型需要 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
_________________________________________________________________
还会创建模型图的图并将其保存到文件中。
递归神经网络图
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
____________________________________________________________________________________________________
还会创建模型图的图并将其保存到文件中。
具有共享输入的神经网络图
共享特征提取层
在本节中，我们将使用两个并行子模型来解释 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
____________________________________________________________________________________________________
还会创建模型图的图并将其保存到文件中。
共享特征提取层的神经网络图
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
____________________________________________________________________________________________________
还会创建模型图的图并将其保存到文件中。
多输入神经网络图
多输出模型
在本节中，我们将开发一个模型，该模型可以进行两种不同类型的预测。给定一个特征的 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
____________________________________________________________________________________________________
还会创建模型图的图并将其保存到文件中。
具有多个输出的神经网络图
6.最佳实践
在本节中，我想给您一些提示，以便在定义自己的模型时充分利用功能 API。
- 一致的变量名称。对输入（可见）和输出层（输出）使用相同的变量名称，甚至可能使用隐藏层（hidden1，hidden2）。它将有助于将事物正确连接在一起。
- 审查层摘要。始终打印模型摘要并查看层输出，以确保模型按预期连接在一起。
- 审查图形图。始终创建模型图的图并对其进行检查，以确保按照您的意图将所有内容放在一起。
- 命名层。您可以为查看模型图的摘要和图时使用的层指定名称。例如：Dense（1，name =‘hidden1’）。
- 单独的子模型。考虑分离子模型的开发并在最后将子模型组合在一起。
使用功能 API 时，您有自己的最佳实践技巧吗？
请在评论中告诉我。
7.关于 Functional API Python 语法的注释
如果您是 Python 的新手或新手，功能 API 中使用的语法可能会令人困惑。
例如，给定：
...
dense1 = Dense(32)(input)
...
双括号语法有什么作用？
这是什么意思？
它看起来很混乱，但它不是一个特殊的 python 东西，只有一行做两件事。
第一个括号“（32）”通过类构造函数创建层，第二个括号“（输入）”是一个没有通过 __call __ 实现名称的函数（ ） 功能，调用时会连接各层。
__call __（）函数是所有可以被覆盖的 Python 对象的默认函数，用于“_ 调用 _”实例化对象。就像 __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)
进一步阅读
如果您要深入了解，本节将提供有关该主题的更多资源。
摘要
在本教程中，您了解了如何使用 Keras 中的功能 API 来定义简单和复杂的深度学习模型。
具体来说，你学到了：
- Sequential 和 Functional API 之间的区别。
- 如何使用功能 API 定义简单的多层感知机，卷积神经网络和递归神经网络模型。
- 如何使用共享层和多个输入和输出定义更复杂的模型。
你有任何问题吗？
在下面的评论中提出您的问题，我会尽力回答。
Keras 深度学习库的多分类教程
原文：
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 激活，更大隐藏层，默认权重初始化的示例。
Keras 深度学习库的多分类教程
houroumono 的照片，保留一些权利。
1.问题描述
在本教程中，我们将使用称为虹膜花数据集的标准机器学习问题。
这个数据集经过深入研究，是在神经网络上实践的一个很好的问题，因为所有 4 个输入变量都是数字的，并且具有相同的厘米尺度。每个实例描述观察到的花测量的属性，输出变量是特定的虹膜种类。
这是一个多类别的分类问题，意味着有两个以上的类需要预测，实际上有三种花种。这是用神经网络练习的一个重要问题类型，因为三个类值需要专门的处理。
虹膜花数据集是一个充分研究的问题，我们可以期望在 95％至 97％的范围内实现模型准确率。这为开发我们的模型提供了一个很好的目标。
您可以从 UCI 机器学习库下载虹膜花数据集，并将其放在当前工作目录中，文件名为“iris.csv”。
2.导入类和函数
我们可以从导入本教程中需要的所有类和函数开始。
这包括我们需要 Keras 的功能，还包括 pandas 的数据加载以及 scikit-learn 的数据准备和模型评估。
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.编码输出变量
输出变量包含三个不同的字符串值。
在使用神经网络对多分类问题进行建模时，最好将包含每个类值的值的向量的输出属性重新整形为一个矩阵，每个类值都有一个布尔值，以及给定的实例是否具有该值是否有类值。
这称为单热编码或从分类变量创建虚拟变量。
例如，在这个问题中，三个类值是 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 或此帖的深度学习有任何疑问吗？
在下面的评论中提出您的问题，我会尽力回答。
深度学习的多标签分类
原文：https://machinelearningmastery.com/multi-label-classification-with-deep-learning/
最后更新于 2020 年 8 月 31 日
多标签分类包括预测零个或多个类别标签。
与类别标签互斥的正常分类任务不同，多标签分类需要支持预测多个互斥类别或“标签”的专门机器学习算法。
深度学习神经网络是原生支持多标签分类问题的算法的一个例子。使用 Keras 深度学习库可以轻松定义和评估用于多标签分类任务的神经网络模型。
在本教程中，您将发现如何为多标签分类开发深度学习模型。
完成本教程后，您将知道:
- 多标签分类是一项预测建模任务，涉及预测零个或多个互斥的类别标签。
- 可以为多标签分类任务配置神经网络模型。
- 如何评价多标签分类的神经网络并对新数据进行预测？
我们开始吧。
深度学习多标签分类
图片由特雷弗·马龙提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 多标签分类
- 多标签神经网络
- 用于多标签分类的神经网络
多标签分类
分类是一个预测建模问题，它涉及输出给定输入的类标签
它不同于涉及预测数值的回归任务。
通常，分类任务包括预测单个标签。或者，它可能涉及预测跨越两个或更多类别标签的可能性。在这些情况下，类是互斥的，这意味着分类任务假设输入只属于一个类。
一些分类任务需要预测多个类别标签。这意味着类标签或类成员并不相互排斥。这些任务被称为多标签分类，简称多标签分类。
在多标签分类中，每个输入样本需要零个或多个标签作为输出，并且同时需要输出。假设输出标签是输入的函数。
我们可以使用 Sklearn 库中的make _ multi label _ classification()函数创建一个合成的多标签分类数据集。
我们的数据集将有 1000 个样本和 10 个输入要素。对于每个样本，数据集将有三个类别标签输出，每个类别将有一个或两个值(0 或 1，例如存在或不存在)。
下面列出了创建和总结合成多标签分类数据集的完整示例。
# example of a multi-label classification task
from sklearn.datasets import make_multilabel_classification
# define dataset
X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
# summarize dataset shape
print(X.shape, y.shape)
# summarize first few examples
for i in range(10):
print(X[i], y[i])
运行该示例将创建数据集并总结输入和输出元素的形状。
我们可以看到，正如预期的那样，有 1000 个样本，每个样本有 10 个输入特征和 3 个输出特征。
对前 10 行输入和输出进行了汇总，我们可以看到该数据集的所有输入都是数字，并且输出类标签在三个类标签中各有 0 或 1 个值。
(1000, 10) (1000, 3)
[ 3\. 3\. 6\. 7\. 8\. 2\. 11\. 11\. 1\. 3.] [1 1 0]
[7\. 6\. 4\. 4\. 6\. 8\. 3\. 4\. 6\. 4.] [0 0 0]
[ 5\. 5\. 13\. 7\. 6\. 3\. 6\. 11\. 4\. 2.] [1 1 0]
[1\. 1\. 5\. 5\. 7\. 3\. 4\. 6\. 4\. 4.] [1 1 1]
[ 4\. 2\. 3\. 13\. 7\. 2\. 4\. 12\. 1\. 7.] [0 1 0]
[ 4\. 3\. 3\. 2\. 5\. 2\. 3\. 7\. 2\. 10.] [0 0 0]
[ 3\. 3\. 3\. 11\. 6\. 3\. 4\. 14\. 1\. 3.] [0 1 0]
[ 2\. 1\. 7\. 8\. 4\. 5\. 10\. 4\. 6\. 6.] [1 1 1]
[ 5\. 1\. 9\. 5\. 3\. 4\. 11\. 8\. 1\. 8.] [1 1 1]
[ 2\. 11\. 7\. 6\. 2\. 2\. 9\. 11\. 9\. 3.] [1 1 1]
接下来，让我们看看如何为多标签分类任务开发神经网络模型。
多标签神经网络
一些机器学习算法本身支持多标签分类。
神经网络模型可以被配置为支持多标签分类，并且可以根据分类任务的具体情况表现良好。
只要将问题中的目标标签数量指定为输出层中的节点数量，神经网络就可以直接支持多标签分类。例如，具有三个输出标签(类)的任务将需要在输出层中具有三个节点的神经网络输出层。
输出层的每个节点都必须使用 sigmoid 激活。这将预测标签的类成员概率，一个介于 0 和 1 之间的值。最后，模型必须符合二元交叉熵损失函数。
总之，要配置用于多标签分类的神经网络模型，具体如下:
- 输出图层中的节点数与标签数相匹配。
- 输出层每个节点的 Sigmoid 激活。
- 二元交叉熵损失函数
我们可以使用 Keras 深度学习库来演示这一点。
我们将为上一节中定义的多标签分类任务定义一个多层感知机(MLP)模型。
每个样本有 10 个输入和 3 个输出；因此，网络需要一个输入层，该输入层期望通过第一个隐藏层中的“ input_dim ”参数指定的 10 个输入和输出层中的三个节点。
我们将使用隐藏层中流行的 ReLU 激活函数。隐藏层有 20 个节点，是经过反复试验选择的。我们将使用二元交叉熵损失和随机梯度下降的亚当版本来拟合模型。
下面列出了多标签分类任务的网络定义。
# define the model
model = Sequential()
model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))
model.add(Dense(n_outputs, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
您可能希望将此模型用于您自己的多标签分类任务；因此，我们可以创建一个函数来定义和返回模型，其中输入和输出变量的数量作为参数提供。
# get the model
def get_model(n_inputs, n_outputs):
model = Sequential()
model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))
model.add(Dense(n_outputs, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
return model
现在我们已经熟悉了如何定义多标签分类的 MLP，让我们来探索如何评估这个模型。
用于多标签分类的神经网络
如果数据集很小，最好在同一数据集上重复评估神经网络模型，并报告重复的平均表现。
这是因为学习算法的随机性。
此外，在对新数据进行预测时，最好使用 k 倍交叉验证代替数据集的训练/测试分割，以获得模型表现的无偏估计。同样，只有在没有太多数据的情况下，这个过程才能在合理的时间内完成。
考虑到这一点，我们将使用 10 倍和 3 倍重复的重复 k 倍交叉验证来评估多输出回归任务的 MLP 模型。
默认情况下，MLP 模型将预测每个类别标签的概率。这意味着它将为每个样本预测三种概率。通过将这些值舍入为 0 或 1，可以将其转换为清晰的类标签。然后，我们可以计算清晰类别标签的分类精确率。
...
# make a prediction on the test set
yhat = model.predict(X_test)
# round probabilities to class labels
yhat = yhat.round()
# calculate accuracy
acc = accuracy_score(y_test, yhat)
收集分数，并通过报告所有重复和交叉验证折叠的平均值和标准偏差进行汇总。
下面的 evaluate_model() 函数获取数据集，对模型进行评估，并返回评估分数列表，在本例中是准确性分数。
# evaluate a model using repeated k-fold cross-validation
def evaluate_model(X, y):
results = list()
n_inputs, n_outputs = X.shape[1], y.shape[1]
# define evaluation procedure
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# enumerate folds
for train_ix, test_ix in cv.split(X):
# prepare data
X_train, X_test = X[train_ix], X[test_ix]
y_train, y_test = y[train_ix], y[test_ix]
# define model
model = get_model(n_inputs, n_outputs)
# fit model
model.fit(X_train, y_train, verbose=0, epochs=100)
# make a prediction on the test set
yhat = model.predict(X_test)
# round probabilities to class labels
yhat = yhat.round()
# calculate accuracy
acc = accuracy_score(y_test, yhat)
# store result
print('>%.3f' % acc)
results.append(acc)
return results
然后，我们可以加载数据集，评估模型，并报告平均表现。
将这些联系在一起，完整的示例如下所示。
# mlp for multi-label classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_multilabel_classification
from sklearn.model_selection import RepeatedKFold
from keras.models import Sequential
from keras.layers import Dense
from sklearn.metrics import accuracy_score
# get the dataset
def get_dataset():
X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
return X, y
# get the model
def get_model(n_inputs, n_outputs):
model = Sequential()
model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))
model.add(Dense(n_outputs, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
return model
# evaluate a model using repeated k-fold cross-validation
def evaluate_model(X, y):
results = list()
n_inputs, n_outputs = X.shape[1], y.shape[1]
# define evaluation procedure
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# enumerate folds
for train_ix, test_ix in cv.split(X):
# prepare data
X_train, X_test = X[train_ix], X[test_ix]
y_train, y_test = y[train_ix], y[test_ix]
# define model
model = get_model(n_inputs, n_outputs)
# fit model
model.fit(X_train, y_train, verbose=0, epochs=100)
# make a prediction on the test set
yhat = model.predict(X_test)
# round probabilities to class labels
yhat = yhat.round()
# calculate accuracy
acc = accuracy_score(y_test, yhat)
# store result
print('>%.3f' % acc)
results.append(acc)
return results
# load dataset
X, y = get_dataset()
# evaluate model
results = evaluate_model(X, y)
# summarize performance
print('Accuracy: %.3f (%.3f)' % (mean(results), std(results)))
运行该示例会报告每个折叠和每个重复的分类准确性，从而给出评估进度的想法。
注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
最后，报告了平均值和标准偏差的准确性。在这种情况下，模型显示达到了大约 81.2%的精确率。
您可以使用此代码作为模板，在自己的多标签分类任务中评估 MLP 模型。模型中节点和图层的数量可以根据数据集的复杂性轻松调整和定制。
...
>0.780
>0.820
>0.790
>0.810
>0.840
Accuracy: 0.812 (0.032)
一旦选择了模型配置，我们就可以使用它来拟合所有可用数据的最终模型，并对新数据进行预测。
下面的示例演示了这一点，首先在整个多标签分类数据集上拟合 MLP 模型，然后在保存的模型上调用 predict() 函数，以便对新的数据行进行预测。
# use mlp for prediction on multi-label classification
from numpy import asarray
from sklearn.datasets import make_multilabel_classification
from keras.models import Sequential
from keras.layers import Dense
# get the dataset
def get_dataset():
X, y = make_multilabel_classification(n_samples=1000, n_features=10, n_classes=3, n_labels=2, random_state=1)
return X, y
# get the model
def get_model(n_inputs, n_outputs):
model = Sequential()
model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))
model.add(Dense(n_outputs, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
return model
# load dataset
X, y = get_dataset()
n_inputs, n_outputs = X.shape[1], y.shape[1]
# get model
model = get_model(n_inputs, n_outputs)
# fit the model on all data
model.fit(X, y, verbose=0, epochs=100)
# make a prediction for new data
row = [3, 3, 6, 7, 8, 2, 11, 11, 1, 3]
newX = asarray([row])
yhat = model.predict(newX)
print('Predicted: %s' % yhat[0])
运行该示例符合模型，并对新行进行预测。正如预期的那样，预测包含多标签分类任务所需的三个输出变量:每个类别标签的概率。
Predicted: [0.9998627 0.9849341 0.00208042]
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
- 多标签分类，维基百科。
- sklearn . datasets . make _ multi label _ classification API。
- 硬主页 。
- sklearn.model_selection。重复的策略应用编程接口。
摘要
在本教程中，您发现了如何为多标签分类开发深度学习模型。
具体来说，您了解到:
- 多标签分类是一项预测建模任务，涉及预测零个或多个互斥的类别标签。
- 可以为多标签分类任务配置神经网络模型。
- 如何评价多标签分类的神经网络并对新数据进行预测？
你有什么问题吗？
在下面的评论中提问，我会尽力回答。
开发钞票鉴别的神经网络
原文：https://machinelearningmastery.com/neural-network-for-banknote-authentication/
最后更新于 2021 年 10 月 22 日
为新数据集开发神经网络预测模型可能具有挑战性。
一种方法是首先检查数据集，并为哪些模型可能起作用提出想法，然后探索数据集上简单模型的学习动态，最后利用强大的测试工具为数据集开发和调整模型。
该过程可用于开发用于分类和回归预测建模问题的有效神经网络模型。
在本教程中，您将发现如何为钞票二进制分类数据集开发多层感知机神经网络模型。
完成本教程后，您将知道:
- 如何加载和汇总钞票数据集，并使用结果建议数据准备和模型配置以供使用。
- 如何探索数据集上简单 MLP 模型的学习动态。
- 如何对模型表现进行稳健的估计，调整模型表现并对新数据进行预测。
我们开始吧。
- 2021 年 10 月更新:已弃用 predict _ classes()语法
开发用于钞票鉴别的神经网络
图片由莱尼·K 摄影拍摄，保留部分权利。
教程概述
本教程分为 4 个部分；它们是:
- 钞票分类数据集
- 神经网络学习动力学
- 稳健模型评估
- 最终模型和做出预测
钞票分类数据集
第一步是定义和探索数据集。
我们将使用“钞票”标准二进制分类数据集。
钞票数据集包括预测给定钞票是否是真实的，给定从照片中获得的多个度量。
数据集包含 1，372 行 5 个数值变量。这是一个有两类的分类问题(二元分类)。
下面提供了数据集中五个变量的列表。
- 小波变换图像的方差(连续的)。
- 小波变换图像的偏斜度(连续)。
- 小波变换图像的峰度(连续的)。
- 图像熵(连续的)。
- 类(整数)。
下面是数据集前 5 行的示例
3.6216,8.6661,-2.8073,-0.44699,0
4.5459,8.1674,-2.4586,-1.4621,0
3.866,-2.6383,1.9242,0.10645,0
3.4566,9.5228,-4.0112,-3.5944,0
0.32924,-4.4552,4.5718,-0.9888,0
4.3684,9.6718,-3.9606,-3.1625,0
...
您可以在此了解有关数据集的更多信息:
我们可以直接从网址将数据集加载为熊猫数据帧；例如:
# load the banknote dataset and summarize the shape
from pandas import read_csv
# define the location of the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/banknote_authentication.csv'
# load the dataset
df = read_csv(url, header=None)
# summarize shape
print(df.shape)
运行该示例直接从 URL 加载数据集，并报告数据集的形状。
在这种情况下，我们可以确认数据集有 5 个变量(4 个输入和 1 个输出)，并且数据集有 1，372 行数据。
对于神经网络来说，这不是很多行的数据，这表明一个小的网络，也许带有正则化，将是合适的。
它还建议使用 k 倍交叉验证将是一个好主意，因为它将给出比训练/测试分割更可靠的模型表现估计，并且因为单个模型将在几秒钟内适合最大数据集，而不是几小时或几天。
(1372, 5)
接下来，我们可以通过查看汇总统计数据和数据图来了解更多关于数据集的信息。
# show summary statistics and plots of the banknote dataset
from pandas import read_csv
from matplotlib import pyplot
# define the location of the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/banknote_authentication.csv'
# load the dataset
df = read_csv(url, header=None)
# show summary statistics
print(df.describe())
# plot histograms
df.hist()
pyplot.show()
运行该示例首先加载之前的数据，然后打印每个变量的汇总统计信息。
我们可以看到，数值随着不同的平均值和标准偏差而变化，也许在建模之前需要一些规范化或标准化。
0 1 2 3 4
count 1372.000000 1372.000000 1372.000000 1372.000000 1372.000000
mean 0.433735 1.922353 1.397627 -1.191657 0.444606
std 2.842763 5.869047 4.310030 2.101013 0.497103
min -7.042100 -13.773100 -5.286100 -8.548200 0.000000
25% -1.773000 -1.708200 -1.574975 -2.413450 0.000000
50% 0.496180 2.319650 0.616630 -0.586650 0.000000
75% 2.821475 6.814625 3.179250 0.394810 1.000000
max 6.824800 12.951600 17.927400 2.449500 1.000000
然后为每个变量创建直方图。
我们可以看到，也许前两个变量具有类高斯分布，后两个输入变量可能具有偏斜高斯分布或指数分布。
我们在每个变量上使用幂变换可能会有一些好处，以便使概率分布不那么偏斜，这可能会提高模型表现。
钞票分类数据集的直方图
现在我们已经熟悉了数据集，让我们探索如何开发一个神经网络模型。
神经网络学习动力学
我们将使用张量流为数据集开发一个多层感知机(MLP)模型。
我们无法知道什么样的学习超参数的模型架构对这个数据集是好的或最好的，所以我们必须实验并发现什么是好的。
假设数据集很小，小批量可能是个好主意，例如 16 或 32 行。开始时使用亚当版本的随机梯度下降是一个好主意，因为它会自动调整学习速率，并且在大多数数据集上运行良好。
在我们认真评估模型之前，最好回顾学习动态，调整模型架构和学习配置，直到我们有稳定的学习动态，然后看看如何从模型中获得最大收益。
我们可以通过对数据进行简单的训练/测试分割并查看学习曲线的曲线来做到这一点。这将有助于我们了解自己是学习过度还是学习不足；然后我们可以相应地调整配置。
首先，我们必须确保所有输入变量都是浮点值，并将目标标签编码为整数值 0 和 1。
...
# ensure all data are floating point values
X = X.astype('float32')
# encode strings to integer
y = LabelEncoder().fit_transform(y)
接下来，我们可以将数据集分成输入和输出变量，然后分成 67/33 训练集和测试集。
...
# split into input and output columns
X, y = df.values[:, :-1], df.values[:, -1]
# split into train and test datasets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)
我们可以定义一个最小 MLP 模型。在这种情况下，我们将使用一个具有 10 个节点的隐藏层和一个输出层(任意选择)。我们将使用隐藏层中的 ReLU 激活函数和 he_normal 权重初始化，作为一个整体，它们是一个很好的实践。
模型的输出是用于二进制分类的 sigmoid 激活，我们将最小化二进制交叉熵损失。
...
# determine the number of input features
n_features = X.shape[1]
# define model
model = Sequential()
model.add(Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(n_features,)))
model.add(Dense(1, activation='sigmoid'))
# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy')
我们将使模型适合 50 个训练时期(任意选择)，批量大小为 32，因为它是一个小数据集。
我们正在原始数据上拟合模型，我们认为这可能是一个好主意，但这是一个重要的起点。
...
# fit the model
history = model.fit(X_train, y_train, epochs=50, batch_size=32, verbose=0, validation_data=(X_test,y_test))
在训练结束时，我们将评估模型在测试数据集上的表现，并将表现报告为分类精确率。
...
# predict test set and convert to class label
ypred = model.predict(X_test)
yhat = (ypred > 0.5).flatten().astype(int)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Accuracy: %.3f' % score)
最后，我们将绘制训练和测试集上交叉熵损失的学习曲线。
...
# plot learning curves
pyplot.title('Learning Curves')
pyplot.xlabel('Epoch')
pyplot.ylabel('Cross Entropy')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='val')
pyplot.legend()
pyplot.show()
综上所述，下面列出了在钞票数据集上评估我们的第一个 MLP 的完整示例。
# fit a simple mlp model on the banknote and review learning curves
from pandas import read_csv
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
from matplotlib import pyplot
# load the dataset
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/banknote_authentication.csv'
df = read_csv(path, header=None)
# split into input and output columns
X, y = df.values[:, :-1], df.values[:, -1]
# ensure all data are floating point values
X = X.astype('float32')
# encode strings to integer
y = LabelEncoder().fit_transform(y)
# split into train and test datasets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)
# determine the number of input features
n_features = X.shape[1]
# define model
model = Sequential()
model.add(Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(n_features,)))
model.add(Dense(1, activation='sigmoid'))
# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy')
# fit the model
history = model.fit(X_train, y_train, epochs=50, batch_size=32, verbose=0, validation_data=(X_test,y_test))
# predict test set and convert to class label
ypred = model.predict(X_test)
yhat = (ypred > 0.5).flatten().astype(int)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Accuracy: %.3f' % score)
# plot learning curves
pyplot.title('Learning Curves')
pyplot.xlabel('Epoch')
pyplot.ylabel('Cross Entropy')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='val')
pyplot.legend()
pyplot.show()
运行该示例首先在训练数据集上拟合模型，然后在测试数据集上报告分类精确率。
注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到模型达到了 100%的高精确率或完美精确率。这可能表明预测问题很容易，和/或神经网络很适合这个问题。
Accuracy: 1.000
然后创建列车和测试集上的损耗线图。
我们可以看到，模型似乎收敛得很好，没有任何过度拟合或拟合不足的迹象。
钞票数据集上简单多层感知机的学习曲线
我们第一次尝试就做得非常好。
现在，我们已经对数据集上的简单 MLP 模型的学习动态有了一些了解，我们可以考虑对数据集上的模型表现进行更稳健的评估。
稳健模型评估
k 倍交叉验证程序可以提供更可靠的 MLP 表现估计，尽管它可能非常慢。
这是因为 k 模型必须被拟合和评估。当数据集尺寸较小时，例如钞票数据集，这不是问题。
我们可以使用stratifiedfold类手动枚举每个折叠，拟合模型，对其进行评估，然后在程序结束时报告评估分数的平均值。
...
# prepare cross validation
kfold = KFold(10)
# enumerate splits
scores = list()
for train_ix, test_ix in kfold.split(X, y):
# fit and evaluate the model...
...
...
# summarize all scores
print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
我们可以使用这个框架，利用我们的基本配置，甚至利用一系列不同的数据准备、模型架构和学习配置，来开发 MLP 模型表现的可靠估计。
重要的是，在使用 k 倍交叉验证估计表现之前，我们首先了解了模型在前面部分的数据集上的学习动态。如果我们开始直接调整模型，我们可能会得到好的结果，但如果没有，我们可能不知道为什么，例如，模型过度或拟合不足。
如果我们再次对模型进行大的更改，最好返回并确认模型正在适当收敛。
下面列出了评估前一节中的基本 MLP 模型的框架的完整示例。
# k-fold cross-validation of base model for the banknote dataset
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.model_selection import StratifiedKFold
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
from matplotlib import pyplot
# load the dataset
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/banknote_authentication.csv'
df = read_csv(path, header=None)
# split into input and output columns
X, y = df.values[:, :-1], df.values[:, -1]
# ensure all data are floating point values
X = X.astype('float32')
# encode strings to integer
y = LabelEncoder().fit_transform(y)
# prepare cross validation
kfold = StratifiedKFold(10)
# enumerate splits
scores = list()
for train_ix, test_ix in kfold.split(X, y):
# split data
X_train, X_test, y_train, y_test = X[train_ix], X[test_ix], y[train_ix], y[test_ix]
# determine the number of input features
n_features = X.shape[1]
# define model
model = Sequential()
model.add(Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(n_features,)))
model.add(Dense(1, activation='sigmoid'))
# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy')
# fit the model
model.fit(X_train, y_train, epochs=50, batch_size=32, verbose=0)
# predict test set and convert to class label
ypred = model.predict(X_test)
yhat = (ypred > 0.5).flatten().astype(int)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('>%.3f' % score)
scores.append(score)
# summarize all scores
print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
运行该示例会报告评估程序每次迭代的模型表现，并在运行结束时报告分类精确率的平均值和标准偏差。
注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到 MLP 模型达到了大约 99.9%的平均精确率。
这证实了我们的期望，即基本模型配置对于这个数据集非常有效，并且实际上模型非常适合这个问题，并且这个问题可能很难解决。
这(对我来说)令人惊讶，因为我本以为需要一些数据扩展，或许还需要一次电源转换。
>1.000
>1.000
>1.000
>1.000
>0.993
>1.000
>1.000
>1.000
>1.000
>1.000
Mean Accuracy: 0.999 (0.002)
接下来，让我们看看如何拟合最终模型并使用它进行预测。
最终模型和做出预测
一旦我们选择了一个模型配置，我们就可以在所有可用的数据上训练一个最终模型，并使用它来对新数据进行预测。
在这种情况下，我们将使用具有脱落和小批量的模型作为最终模型。
我们可以像以前一样准备数据并拟合模型，尽管是在整个数据集上，而不是数据集的训练子集上。
...
# split into input and output columns
X, y = df.values[:, :-1], df.values[:, -1]
# ensure all data are floating point values
X = X.astype('float32')
# encode strings to integer
le = LabelEncoder()
y = le.fit_transform(y)
# determine the number of input features
n_features = X.shape[1]
# define model
model = Sequential()
model.add(Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(n_features,)))
model.add(Dense(1, activation='sigmoid'))
# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy')
然后，我们可以使用这个模型对新数据进行预测。
首先，我们可以定义一行新数据。
...
# define a row of new data
row = [3.6216,8.6661,-2.8073,-0.44699]
注意:我从数据集的第一行提取了这一行，预期的标签是“0”。
然后我们可以做一个预测。
...
# make prediction and convert to class label
ypred = model.predict([row])
yhat = (ypred > 0.5).flatten().astype(int)
然后反转预测上的转换，这样我们就可以使用或解释正确标签中的结果(对于这个数据集，它只是一个整数)。
...
# invert transform to get label for class
yhat = le.inverse_transform(yhat)
在这种情况下，我们将简单地报告预测。
...
# report prediction
print('Predicted: %s' % (yhat[0]))
将所有这些结合起来，下面列出了为钞票数据集拟合最终模型并使用它对新数据进行预测的完整示例。
# fit a final model and make predictions on new data for the banknote dataset
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Dropout
# load the dataset
path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/banknote_authentication.csv'
df = read_csv(path, header=None)
# split into input and output columns
X, y = df.values[:, :-1], df.values[:, -1]
# ensure all data are floating point values
X = X.astype('float32')
# encode strings to integer
le = LabelEncoder()
y = le.fit_transform(y)
# determine the number of input features
n_features = X.shape[1]
# define model
model = Sequential()
model.add(Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(n_features,)))
model.add(Dense(1, activation='sigmoid'))
# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy')
# fit the model
model.fit(X, y, epochs=50, batch_size=32, verbose=0)
# define a row of new data
row = [3.6216,8.6661,-2.8073,-0.44699]
# make prediction and convert to class label
ypred = model.predict([row])
yhat = (ypred > 0.5).flatten().astype(int)
# invert transform to get label for class
yhat = le.inverse_transform(yhat)
# report prediction
print('Predicted: %s' % (yhat[0]))
运行该示例使模型适合整个数据集，并对单行新数据进行预测。
注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
在这种情况下，我们可以看到模型为输入行预测了一个“0”标签。
Predicted: 0.0
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
摘要
在本教程中，您发现了如何为钞票二进制分类数据集开发多层感知机神经网络模型。
具体来说，您了解到:
- 如何加载和汇总钞票数据集，并使用结果建议数据准备和模型配置以供使用。
- 如何探索数据集上简单 MLP 模型的学习动态。
- 如何对模型表现进行稳健的估计，调整模型表现并对新数据进行预测。
你有什么问题吗？
在下面的评论中提问，我会尽力回答。
扫一扫
1493
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
