自动编码器——深度学习的比特和字节
百度研究院(Baidu Research)首席科学家吴恩达表示，可以将深度学习的作用理解为“A 到 B 的映射”。“您可以输入音频片段并输出文字记录。那就是语音识别。”他坚持认为，只要你有数据来训练软件，可能性是无限的。"你可以输入电子邮件，输出可能是:这是不是垃圾邮件？"他说，输入贷款申请，输出可能是客户偿还贷款的可能性。输入车队的使用模式，输出可以建议下一步把车送到哪里。
与其通过复杂的定义使事实变得复杂，不如将深度学习视为子集的子集。人工智能包含了广泛的技术和技巧，使计算机系统能够以至少表面上类似于思维的方式来解决问题。在这个范围内，有一整套神秘但重要的数学技术，驱动着通过经验学习的动机。这个子集被称为机器学习。最后，在机器学习中有一个更小的子类，称为深度学习(也称为深度结构化学习或分层学习)，这是人工神经网络(ann)在包含不止一个隐藏层的学习任务中的应用。
什么是自动编码器？
尽管它最初听起来有点神秘，但自动编码器是一个相当基本的机器学习模型。自动编码器(AE) 是一类输入与输出相同的神经网络。他们的工作原理是将输入压缩成一个潜在空间表示，然后从这个表示中重建输出。
Autoencoder architecture
更详细地说，自动编码是一种数据压缩算法，其中压缩和解压缩功能，
- **数据特定:**自动编码器只能压缩类似于它们被训练过的数据。一个经过人脸训练的自动编码器在处理现代建筑的图像时不会表现得很好。这弥补了自动编码器和 MP3 压缩算法之间的差异，MP3 压缩算法只对一般声音进行假设，而不对特定类型的声音进行假设。
- **有损:**这意味着与原始输入相比，解压缩后的输出质量会下降。就像你在 JPEG 或 MP3 中看到的一样。
- **从示例中自动学习:**如果您有适当的训练数据，很容易训练算法的特定实例，这些实例将对特定类型的输入执行良好。它不需要任何新的工程技术。
此外，在几乎所有使用术语“自动编码器”的上下文中，压缩和解压缩功能都是用神经网络实现的。
为什么选择自动编码器？
尽管事实上不久前自动编码器的实际应用相当罕见，但今天，数据去噪和数据可视化降维被认为是自动编码器的两个主要有趣的实际应用。通过适当的维度和稀疏性约束，自动编码器可以学习比 PCA 或其他基本技术更有趣的数据投影。
Performance comparison of Autoencoders and PCA
卷积自动编码器
在自动编码器的传统架构中，没有考虑到信号可以被视为其他信号的总和这一事实。另一方面，卷积自动编码器(CAE)使用卷积运算符来适应这种观察。卷积运算符允许对输入信号进行滤波，以便提取其内容的某一部分。他们学习将输入编码成一组简单的信号，然后尝试从这些信号中重建输入。
A convolution between a 4x4x1 input and a 3x3x1 convolutional filter.
The result is a 2x2x1 activation map. (Source)
参考这个关于卷积自动编码器的使用案例，有很好的例子解释。在这篇文章的后面，我们将看到 CAE 的一个实际例子。
构建自动编码器
我们将从我们能构建的最简单的自动编码器开始。在后一部分，我们将在真实的例子中研究自动编码器的更复杂的用例。
以下是使用 keras 作为平台的简单自动编码器的代码。keras 提供的 MNIST 数字用于示例中。
有了这个代码片段，我们将得到以下输出。
在上图中，顶行是原始数字，底行是重建的数字。正如您所看到的，在这个基本示例中，我们丢失了一些重要的细节。
由于我们的输入是图像，使用卷积神经网络作为编码器和解码器是有意义的。在实际设置中，应用于图像的自动编码器总是卷积自动编码器，因为它们的性能要好得多。
使用卷积自动编码器，我们将获得以下输入和重构输出。
自动编码器的实际应用:图像去噪
在本节中，我们将研究自动编码器在现实世界中的使用，用于图像去噪。我们将训练卷积自动编码器将有噪声的数字图像映射到干净的数字图像。
我们将通过应用高斯噪声矩阵来生成合成噪声数字，并在 0 和 1 之间裁剪图像。
当 autoencoder 被训练后，我们可以用它来去除添加到我们从未见过的图像中的噪声！这是输入和重建输出的样子。
结论
自动编码器是一种人工神经网络，用于高效编码的无监督学习。在现代，自动编码器已经成为一个新兴的研究领域，在许多方面，如在异常检测。在这篇文章中，我们期望提供一个关于自动编码器是什么、为什么和如何的基本理解。
参考
- https://hacker noon . com/auto encoders-deep-learning-bits-1-11731 e 200694
- 【https://blog.keras.io/building-autoencoders-in-keras.html 号
- 【https://www.technologyreview.com/s/513696/deep-learning/
自动编码器-TF 中的介绍和实现。
简介和概念:
自动编码器(AE) 是一个神经网络家族，其输入与输出相同(它们实现一个身份函数)。他们的工作原理是将输入压缩成一个潜在空间表示，然后从这个表示中重建输出。
自动编码器真正流行的用途是将它们应用于图像。的诀窍是用卷积层代替全连接层。这些图层与合并图层一起，将输入从宽宽和薄宽(假设 100 x 100 像素，3 个通道— RGB)转换为窄宽宽。这有助于网络从图像中提取视觉特征，从而获得更加准确的潜在空间表示。重建过程使用上采样和卷积。
由此产生的网络被称为卷积自动编码器 ( CAE )。
CAEs 的使用
示例:超基本图像重建
卷积自动编码器可以用于重建。例如，他们可以学习从图片中去除噪声，或者重建丢失的部分。
为此，我们不使用相同的图像作为输入和输出，而是使用噪声版本作为输入和干净版本作为输出。通过这个过程，网络学会填补图像中的空白。
让我们看看 CAE 能做什么来替换眼睛图像的一部分。假设有一个十字准线，我们想移除它。我们可以手动创建数据集，这非常方便。
现在我们的自动编码器已经训练好了，我们可以用它来移除我们从未见过的眼睛图片上的十字准线！
TF 中的实现:
让我们来看一个在 tensorflow 中使用 MNIST 数据集的示例实现。
网络体系结构
网络的编码器部分将是典型的卷积金字塔。每个卷积层后面都有一个最大池层，以减少各层的维数。解码器需要从窄的表示转换成宽的重建图像。
通常，你会看到转置卷积层用于增加层的宽度和高度。它们的工作原理与卷积层几乎完全相同，但方向相反。输入层中的步幅导致转置卷积层中的步幅更大。例如，如果您有一个 3x3 内核，输入层中的一个 3x3 补丁将减少到卷积层中的一个单元。相比之下，输入层中的一个单元将在转置卷积层中扩展为 3×3 路径。TensorFlow API 为我们提供了一种创建层的简单方法。
然而，转置卷积层会导致最终图像中出现伪影，例如棋盘图案。这是由于内核重叠造成的，可以通过将步幅和内核大小设置为相等来避免这种重叠。在这篇摘自 Augustus Odena，等人的文章中，作者展示了通过使用最近邻或双线性插值(上采样)后接卷积层来调整层的大小，可以避免这些棋盘状伪像。在 TensorFlow 中，这很容易用
[tf.image.resize_images](https://www.tensorflow.org/versions/r1.1/api_docs/python/tf/image/resize_images)完成，然后是卷积。Odena 等人声称最近邻插值最适合上采样
自动编码器仅通过在有噪声的图像上训练网络，就可以非常成功地用于图像去噪。我们可以通过向训练图像添加高斯噪声，然后将值剪切到 0 和 1 之间，来自己创建有噪声的图像。我们将使用噪声图像作为输入，原始的、干净的图像作为目标。
注意，我们使用 sigmoid _ cross _ entropy _ with _ logit 来表示损失。根据 TF 文档:它测量离散分类任务中的概率误差，其中每个类都是独立的，并且不互相排斥。例如，可以执行多标签分类，其中一幅图片可以同时包含一头大象和一只狗。
模型定义:
learning_rate = 0.001
inputs_ = tf.placeholder(tf.float32, (None, 28, 28, 1), name='inputs')
targets_ = tf.placeholder(tf.float32, (None, 28, 28, 1), name='targets')### Encoder
conv1 = tf.layers.conv2d(inputs=inputs_, filters=32, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 28x28x32
maxpool1 = tf.layers.max_pooling2d(conv1, pool_size=(2,2), strides=(2,2), padding='same')
# Now 14x14x32
conv2 = tf.layers.conv2d(inputs=maxpool1, filters=32, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 14x14x32
maxpool2 = tf.layers.max_pooling2d(conv2, pool_size=(2,2), strides=(2,2), padding='same')
# Now 7x7x32
conv3 = tf.layers.conv2d(inputs=maxpool2, filters=16, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 7x7x16
encoded = tf.layers.max_pooling2d(conv3, pool_size=(2,2), strides=(2,2), padding='same')
# Now 4x4x16### Decoder
upsample1 = tf.image.resize_images(encoded, size=(7,7), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
# Now 7x7x16
conv4 = tf.layers.conv2d(inputs=upsample1, filters=16, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 7x7x16
upsample2 = tf.image.resize_images(conv4, size=(14,14), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
# Now 14x14x16
conv5 = tf.layers.conv2d(inputs=upsample2, filters=32, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 14x14x32
upsample3 = tf.image.resize_images(conv5, size=(28,28), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
# Now 28x28x32
conv6 = tf.layers.conv2d(inputs=upsample3, filters=32, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 28x28x32logits = tf.layers.conv2d(inputs=conv6, filters=1, kernel_size=(3,3), padding='same', activation=None)
#Now 28x28x1# Pass logits through sigmoid to get reconstructed image
decoded = tf.nn.sigmoid(logits)# Pass logits through sigmoid and calculate the cross-entropy loss
loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=targets_, logits=logits)# Get cost and define the optimizer
cost = tf.reduce_mean(loss)
opt = tf.train.AdamOptimizer(learning_rate).minimize(cost)
培训:
sess = tf.Session()
epochs = 100
batch_size = 200
# Set's how much noise we're adding to the MNIST images
noise_factor = 0.5
sess.run(tf.global_variables_initializer())
for e in range(epochs):
for ii in range(mnist.train.num_examples//batch_size):
batch = mnist.train.next_batch(batch_size)
# Get images from the batch
imgs = batch[0].reshape((-1, 28, 28, 1))
# Add random noise to the input images
noisy_imgs = imgs + noise_factor * np.random.randn(*imgs.shape)
# Clip the images to be between 0 and 1
noisy_imgs = np.clip(noisy_imgs, 0., 1.)
# Noisy images as inputs, original images as targets
batch_cost, _ = sess.run([cost, opt], feed_dict={inputs_: noisy_imgs,
targets_: imgs})print("Epoch: {}/{}...".format(e+1, epochs),
"Training loss: {:.4f}".format(batch_cost))
学分:https://hacker noon . com/auto encoders-deep-learning-bits-1-11731 e 200694
自动编码器变得简单
什么是自动编码器？
自动编码器是一种用于无监督学习的生成模型。自动编码器学习图像的一些潜在表示，并使用它来重建图像。这种“潜在表征”是什么？这是图像隐藏特征的另一个花哨术语。自动编码器通过用不同图像训练的迭代过程，试图学习给定图像的特征，并从这些学习到的特征中重建期望的图像。
乍一看，自动编码器可能看起来像任何其他神经网络，但不像其他网络，它在中心有一个瓶颈。这个瓶颈用来学习图像的特征。自动编码器完成两项任务，它对图像进行编码，然后解码。
编码图像:
拍摄输入图像，通过一系列卷积，图像的大小被压缩成一个小矢量。这个压缩的矢量表示图像的特征，从该特征可以重建另一个图像
解码图像:
从压缩矢量，我们应用了一系列的反卷积层，放大图像的大小，并将其恢复到原来的大小。
自动编码器的用途是什么？
自动编码器可以用来消除噪声，执行图像着色和各种其他目的。有噪声的图像可以作为自动编码器的输入，去噪声的图像可以作为输出。自动编码器将通过学习图像的潜在特征来尝试对图像去噪声，并使用该特征来重建没有噪声的图像。重建误差可以作为输出图像和地面真实图像的像素值之间的距离的度量来计算。
缺点:
在重建图像时，自动编码器与生成式对抗网络相比效率并不高。随着图像复杂性的增加，自动编码器很难跟上，图像开始变得模糊。
代码:
下面的 python 代码代表了一个基本的自动编码器，它从 mnist 数字数据中学习特征，并重新构造它们。
依赖关系:
- 张量流
- 克拉斯
- Numpy
结论:
尽管自动编码器可能很难跟上 GANs，但它们在某些任务中效率很高，比如异常检测和其他任务。这仍然是神经网络的一个新兴领域。
AutoKeras:谷歌汽车的黑仔
想获得灵感？快来加入我的 超级行情快讯 。😎
谷歌人工智能终于发布了 AutoML 的测试版，有人说这项服务将完全改变我们进行深度学习的方式。
谷歌的 AutoML 是一个新的机器学习工具云软件套件。它基于谷歌在图像识别领域的最新研究，名为神经架构搜索 (NAS)。NAS 基本上是一种算法，在给定特定数据集的情况下，它会搜索最佳神经网络来对该数据集执行特定任务。AutoML 是一套机器学习工具，允许人们轻松训练高性能的深度网络，而不需要用户拥有任何深度学习或人工智能的知识；你需要的只是标签数据！Google 将使用 NAS 为您的特定数据集和任务找到最佳网络。他们已经展示了他们的方法如何能够实现比手工设计的网络更好的性能。
AutoML 完全改变了整个机器学习游戏，因为对于许多应用程序来说，不需要专门的技能和知识。很多公司只需要深度网络来完成更简单的任务，比如图像分类。在这一点上，他们不需要雇佣 5 个机器学习博士；他们只需要有人能够处理移动和组织他们的数据。
那么 AutoML 是不是一个让任何公司或个人都可以轻松做 AI 的漂亮银弹？！
….没那么快。
使用谷歌的 AutoML 进行计算机视觉，每小时要花费 20 美元。太疯狂了！你甚至不能确定你会得到比你自己亲手设计的网络更好的准确性，直到你付钱并试用它。有趣的是，在过去，无论是谷歌还是一般的人工智能社区，人们都喜欢开源，以便能够与每个人分享知识。
而这正是 Google 的 AutoML 会输的地方:开源。
进入 AutoKeras ，一个开源 python 包写的非常好用 深度学习库Keras*。AutoKeras 使用了 ENAS 的变体，这是一种有效的最新版本的神经架构搜索。您可以使用pip install autokeras快速轻松地安装软件包，瞧，您已经准备好在您自己的数据集上进行您自己的架构搜索… 免费。*
因为所有的代码都是开源的，如果你想做一些真正定制的东西，你甚至可以摆弄一些参数。这都是 Keras，所以代码很容易理解和深入，允许开发人员快速创建准确的模型，研究人员可以更深入地进行架构搜索。
AutoKeras 拥有一个伟大的开源项目应该拥有的一切:快速安装，易于运行，大量的例子，易于修改，您甚至可以看到 NAS 最终发现的网络模型！如果你更喜欢 TensorFlow 或 Pytorch，这里也有和这里也有！
我肯定会推荐尝试 AutoKeras 或任何其他实现，作为 AutoML 的可笑的廉价替代品。也许谷歌正在为 AutoML 做更多的事情，但鉴于 NAS 模型和手工设计的模型之间非常小的性能差异，我怀疑人们会获得足够大的收益，值得付出如此高昂的代价。
深度学习和人工智能是一项如此强大的技术，我们不应该试图将其隐藏在如此高的收费背后。是的，谷歌、亚马逊、苹果、脸书和微软都是需要赚钱来生存和竞争的企业。但像这样的事情，研究论文是公开的，我们有深度学习库可以快速复制这些方法，当它可以如此容易地公开时，试图阻止人们使用它是没有意义的。
这里还有一个潜在的更大的问题:知识本身被隐藏了。关于人工智能最近趋势的一件大事是，许多研究社区决定迅速将他们的工作公开发布在 Arxiv 等网站上，与社区分享并获得反馈。更有甚者，在 Github 上发布研究代码以供复制，以及在研究和现实世界应用中进一步使用这些算法，已经成为一种日益增长的趋势。然而在这里，我们仍然看到这样的研究被置于付费墙之后。
*分享科学有助于进步，增加每个人的常识。有一点是肯定的:*知识应该是开源的。对大家都好。
自动化枯燥的任务:企业软件中的聊天机器人
由于对任何形式的炒作都持怀疑态度，我对聊天机器人并不感兴趣。在投入另一场硅谷炒作之前，我需要理解它的价值。当我在 2017 年初加入思科超创新生活实验室(CHILL)时，机会来了。思科在企业软件领域与许多其他企业客户合作。这意味着他们拥有庞大的基础设施、工具集和客户支持流程，这些都是自动化的成熟产品。
虽然我不能谈论我在这里工作的项目，但它激起了我对聊天机器人、自然语言处理(NLP)和整体对话人工智能空间的兴趣。虽然之前我已经创建了基于规则的家庭自动化系统和语言转换软件，但这一次是我第一次使用实际的自然语言处理技术涉足企业规模的对话式人工智能。
我开始研究聊天机器人框架。回到 2017 年 5 月，思科收购了一家名为 MindMeld 的对话式人工智能初创公司。我开始使用 MindMeld NLP APIs 和它的对话式 AI 框架，更深入地研究了诸如 实体 、 意图 等概念。我继续深入研究，发现了rasa . AI——另一个企业级对话式人工智能框架。而且这次是开源的！很少有朋友还提到过chatter bot——一个开源的会话式对话引擎。随着我不断探索，我在消费者和企业领域遇到了许多其他对话式人工智能产品。由于我在 Backstage Capital 的 EIR 演出，我还发现了一些机器人分析产品。
在这一系列帖子中，我将深入探讨聊天机器人框架、对话式人工智能产品、机器人分析产品以及更多我感兴趣的产品。
在对话式人工智能框架中
为了构建一个聊天机器人，我最终研究了不同的对话机器人框架。 Botkit 和 Api.ai (现在的 Dialogflow)就是两个明显的例子。它们都支持思科的协作平台 Cisco Spark，也可以通过各自的 REST APIs 从 webapp 中使用。但很快我意识到了它们的局限性。
僵尸工具是一个基于规则的框架。在基于规则的框架中，开发人员需要创建交互逻辑——如何解释传入的聊天消息，以及典型的响应集是什么。所以本质上，僵尸工具本身并不提供任何机器学习能力。你必须不断地为简单的应用程序创建规则。这些类型框架适用于快速原型开发，但不适用于大型可伸缩系统。截至 2017 年 5 月，僵尸工具增加了将僵尸工具工作室与微软自然语言处理引擎 Microsoft LUIS 集成的功能。Botkit 和 LUIS 的整合服务于我的目的，即；使用真正的自然语言处理引擎，但这导致了下一个问题——使用基于云的 NLP 服务。
Api.ai，微软 LUIS，亚马逊 Lex 等。是基于云的对话式人工智能 NLP 服务。他们很快就能上手，不用太担心 NLP 或机器学习的细节。但是有几个原因我不想和他们一起去。首先，我不想把我的数据上传到那些云服务上。第二，我希望能够控制我在聊天机器人中使用的自然语言处理技术，最后，我希望能够更多地控制我的机器人的功能，而不是基于云的自然语言处理服务提供的常见功能。
那么我在找什么呢
简而言之，我在聊天机器人框架中寻找以下特征
- 不是基于规则或基于云的 NLP
- 有 web/REST API 支持，所以我可以从 webApp 上使用它，而不仅仅是在第三方平台上，如 Slack，脸书等。
- 支持 Python，但 Node.js 也很酷
- 允许我自定义
- 巨大的优势——开源
MindMeld 服务于上述大部分目的，我在思科的工作中使用它。但我也想看看外面还有什么。我偶然发现了rasa . ai——一个面向企业的开源对话式 AI。Rasa 似乎与 MindMeld 非常相似——尽管我需要更深入地了解 Rasa 的 NLP 功能。Rasa 让我着迷的是，它们是企业级开源解决方案——开发者的天堂！
我还遇到了聊天机器人。它似乎是一个基于规则的引擎，基于这个聊天机器人平台对照表。虽然 Chatterbot 有能力添加您自己的语料库来训练机器人。需要仔细观察才能决定它的 NLP 能力。
在那之前，敬请期待！
注:
我是旧金山的一名软件工程师，从事聊天机器人、自然语言处理方面的工作，最近获得了深度学习奖学金，成为杰瑞米·霍华德 fast.ai 课程的一部分。
这一系列帖子的名字是受了这本书的启发。特别感谢 Anastasia 和 Meighan 对这篇博客的快速回顾。感谢 Karthik 分享他对 MindMeld 平台的深刻见解。
自动化枯燥的任务:对话助手的视野
随着我不断构建对话助手，我每天都会面临一些问题。它是什么？我们为什么要关心它？有哪些不同的设计选择？你为什么选择一个平台而不是另一个？我们如何衡量我们的进步？我们还能做些什么来改进等等。这篇博文试图通过总结对话助手的发展来回答这些问题。
什么是会话助手？
根据维基百科，对话助手或聊天机器人
是一种计算机程序或人工智能，它通过听觉或文本方法进行对话。这种程序通常被设计成令人信服地模拟人类作为对话伙伴的行为
正如上面的定义中提到的，聊天机器人不一定需要采用人工智能技术。事实上，今天的大多数机器人都是简单的 if-then-else 程序，不一定采用人工智能技术。
为什么商家会在意？
据 Gartner 称，到 2020 年，55%的公司将部署聊天机器人[1]。2016 年，聊天机器人的全球市场规模达到 8800 万美元。预计到 2023 年，CAGR 市场将以 36%的速度增长，超过 10 亿美元[2]。除了数字之外，对话助手还能提供独特的价值，帮助企业在竞争中保持领先。
- 通过减少摩擦改善用户体验。例如，美国银行聊天机器人可以显示你的账户余额、银行帐号等。通过简单的语音或文本命令。你不需要在他们的网站上点击 10 个不同的链接。
- 通过全天候客户服务增加与客户的互动。举个例子——酒店的常春藤可以全天候回答任何与客房服务相关的问题。酒店不需要让员工在夜间凌晨值班！
- 更高的客户满意度——拥有成熟虚拟助理解决方案的企业客户看到的遏制率高达 90% [4]。包容意味着客户能够在第一次接触时解决问题的频率。提高容器数量意味着更高的客户满意度。
- 通过基于对话的情感分析，更好地洞察客户行为
- 成本降低
那些聊天机器人在哪里？
聊天机器人生活在不同的平台。他们可以是 Facebook Messenger、WhatsApp、Telegram 或 Kik 等消息平台的一部分；可以在 Slack 等企业协作平台；可以是 iPhone 或亚马逊 Echo 等硬件设备的一部分；可以在 web 应用程序中——例如我们在大多数网站中看到的客户服务聊天气泡；或者干脆作为手机 app 比如 Replika 。
虽然对话机器人可能会让我们想起 Siri 或 Alexa 他们不一定需要语音支持。聊天机器人可以只发送文本消息，也可以是文本和语音的结合，或者只发送语音。
Chatbot Ecosystem credit
产品前景
在一个博客中有太多的产品要介绍。我将把重点放在开发平台、测试和分析工具上，它们最终会导致构建一个大规模的企业产品
开发者平台:
在基于规则的框架中，Botkit 是开发人员最为熟知的。使用僵尸工具，开发人员需要创建交互逻辑——如何解释传入的聊天消息，以及典型的响应集是什么。所以本质上，僵尸工具本身并不提供任何机器学习能力。你必须不断地为简单的应用程序创建规则。这些类型框架适用于快速原型开发，但不适用于大型可伸缩系统。截至 2017 年 5 月，僵尸工具增加了将僵尸工具工作室与微软自然语言处理引擎 Microsoft LUIS 集成的功能。
接下来是基于云的开发者平台。DialogFlow，微软 LUIS，亚马逊 Lex 等。是基于云的对话式人工智能 NLP 服务。他们很快上手，不需要太担心 NLP 或机器学习的细节。
NanoRep(被 LogMeIn 收购)是另一个基于云的聊天机器人开发平台，它是专门为客户服务用例设计的。该平台有助于预测客户在网站上搜索商品或与客户支持人员聊天时试图做的事情，并减少到达网站所需的步骤[3]。
尽管这些基于云的 NLP 服务从一开始就很棒，并且更容易构建可扩展的解决方案，但是它们有两个主要的局限性。首先，你必须把你的数据保存在他们的云中。对于担心数据隐私和数据所有权的企业来说，这是一个特殊的问题。第二，开发人员受到这些平台支持的功能的限制，这对于需要在竞争中脱颖而出的企业来说是一个挑战。如果这两个是你关心的，你最好使用像 Rasa 或 MindMeld 这样的平台。
Rasa 是一个开源的企业级对话式 AI 平台。它以模块化的方式将自然语言理解(NLU)引擎( Rasa NLU )与对话管理引擎( Rasa 核心)分开。开发人员可以根据他们的特定需求混合搭配这些模块。例如——开发人员可能希望将 Rasa NLU 与僵尸工具一起使用(在这种情况下，僵尸工具将只处理对话管理)。你也可以用 Rasa 交互式训练你的对话模型。这个特性有助于根据人机对话重新训练对话引擎。
MindMeld (被思科收购)是另一个企业级对话式 AI 平台。与 Rasa 不同，他们不允许开发者模块化访问他们的 NLU 和对话管理引擎。此外，据我所知，没有像 Rasa 这样的交互式培训功能。
企业产品
在我看来，客户服务是企业对话助手可以提供巨大价值的最令人兴奋的用例——增加销售额、经常性收入、客户满意度等。企业也开始掌握它了。例如，ServiceNow 客户服务机器人可以帮助客户了解案例的状态，并自动处理其他客户服务请求。UPS 聊天机器人帮助客户面对物流运作。 Carla 帮助你计划商务旅行， Cinch 帮助那些不在拥有自己旅行管理系统的大公司工作的商务旅行者管理他们的旅行。AVA—Autodesk 虚拟助理可以帮助 Autodesk 客户完成注册、激活、安装、许可和帐户相关任务。好事达正在部署聊天机器人来帮助小企业客户完成保险流程。
Autodesk Virtual Assistant
有趣的是，有些聊天机器人开发平台是专门为客户服务用例设计的。例如 Reply.ai 帮助企业建立客户服务聊天机器人，并提供对客户情绪、偏好、好恶等的洞察。NanoRep(已被 LogMeIn 收购)的聊天机器人平台也是专门为企业客户服务而设计的，当客户询问机器人不知道的事情时，它会通知人类客户支持代理。
聊天机器人分析平台:
Dashbot 和 Botanalytics 是聊天机器人分析平台的几个例子。这些平台通过识别瓶颈、识别关键指标、细分对话和提供智能建议来帮助改善人与机器人的沟通。例如，下面的机器人分析仪表盘显示了人类顾客和聊天机器人之间对话的一些统计数据。这些统计数据将让我们更好地了解已部署聊天机器人的效率。例如— 平均会话长度可能表示企业解决客户问题的速度。
Botanalytics Dashboard showing analytics of the conversation between a human and a bot
Dashbot 使品牌和开发者能够通过可操作的数据和工具增加参与度、获取度和盈利。除了参与度和留存率等传统分析之外，Dashbot 还提供机器人和语音特定的指标，包括情绪分析、意图分析和完整的聊天会话记录。它使用户能够使用真人接管、广播消息和受众构建器等工具对数据采取行动。使用 Dashbot，聊天机器人开发人员可以找到并修复未处理的意图。
Finding and Fixing Unhandled Intent with Dashbot
聊天机器人测试方法和工具:
测试您的聊天机器人应用程序需要不同于您的典型软件应用程序的思维方式。测试过程中的一个关键阶段是测试对话流。机器人是否遵循了您希望它遵循的相同对话流程？如果人类不像我们预期的那样交谈呢。测试过程还需要考虑速度、准确性、用户体验等。与机器人对话。在聊天机器人的情况下，错误处理尤其有趣。如果机器人被要求做一些它没有被训练过的事情，它如何回答？
博特宁、戴蒙等。是一些聊天机器人测试平台，可以自动生成类似用户的对话。这些对话可用于测试聊天机器人的对话流程、速度、准确性和用户体验。 Botium ，一个开源聊天机器人测试平台，通过启动、交互和停止你的聊天机器人应用程序来自动化测试过程。另一个开源工具是 Chatbottest 。这个工具有一组问题，可以用来测试应用程序的对话流和 UX。他们还开发了一个机器人来测试你的机器人——Alma。目前，Alma 是一个 chrome 扩展，可用于在 Facebook Messenger 和 Telegram 中测试您的聊天机器人。
机器人商店:
与 App Store 概念类似，Slack 等平台也有自己的机器人商店，展示在其平台上构建的机器人。Cisco Webex Teams 是另一个协作平台，开发人员已经为企业客户构建了机器人。聊天瓶、聊天机器人列表和因此列出了世界上的聊天机器人应用。
一篇关于产品前景的综合文章总是一个移动的目标。我确信我已经错过了许多令人兴奋的产品。由于我关注的是企业产品，这篇文章有意忽略了消费者聊天机器人。请随时在评论区分享任何其他产品的信息。
参考:
- https://chatbotslife . com/the-chatbot-landscape-changes-for-2018-1 de 0 FB 7 f 88 a 1
- https://blog . key reply . com/the-chatbot-landscape-2017-edition-ff 2 e 3d 2 a 0 BDB
- https://TechCrunch . com/2017/08/01/logmein-acquisites-chatbot-and-ai-startup-nano rep-for-up-to-50m/
- http://connect . creative virtual . com/virtual-agent-improve-customer-service
- https://www.abetterlemonadestand.com/ecommerce-chatbots/
- https://www . 30 seconds tofly . com/ai-software/ultimate-travel-bot-list/
注:
我是旧金山思科超创新生活实验室(CHILL)的软件工程师。我从事聊天机器人、自然语言处理方面的工作，最近获得了深度学习奖学金，成为杰瑞米·霍华德 fast.ai 课程的一部分。
特别感谢 Ilker Koksal，机器人分析的联合创始人兼首席执行官。贾斯蒂娜·阮(Justina Nguyen)，Dashbot 的开发者传道者。
这一系列帖子的名字是受到了本书的启发。更早的帖子可以在这里找到。
用于预测建模的自动化特征工程
Source:Wikimedia Commons
使用 Python 和 FeatureTools 库预测哪些 NHL 比赛是季后赛。
我见过的数据科学家在构建数据产品时投入的主要时间之一是手动执行特征工程。虽然像 auto-sklearn 和 Auto-Keras 这样的工具已经能够在构建预测模型时自动完成大部分模型拟合过程，但确定将哪些特征用作拟合过程的输入通常是一个手动过程。我最近开始使用 FeatureTools 库，它使数据科学家也能够自动化特征工程。
用于自动化特征工程的开源 python 框架——feature tools/feature tools
github.com](https://github.com/Featuretools/featuretools)
FeatureTools 可用于浅层(经典)机器学习问题，其中数据以结构化格式提供。该库提供了用于执行深度要素合成的功能，这近似于数据科学家在执行要素工程时将探索的变换。使用此工具的结果是，您可以将数据从窄而深的表示转换为浅而宽的表示。
我发现，当每个项目有许多记录需要预测时，这种技术最有效。例如，如果您预测客户是否会流失，输入可以是每个客户的会话事件的集合。如果每个用户只有一条记录，那么深度特征合成不会非常有效。为了展示这种方法是如何工作的，我将使用 Kaggle 上的 NHL 数据集。这个数据集包括一个游戏记录表，以及一个更详细地描述每个游戏的游戏记录表。我正在建立的预测模型的目标是根据比赛中的打法来确定哪些比赛是季后赛。在没有应用领域知识的情况下，我能够建立一个逻辑回归分类器，以高准确度( 94% )预测比赛是季后赛。完整的 Python 笔记本可以在 github 这里获得。
这篇文章的剩余部分介绍了笔记本，展示了如何将提供的 Kaggle 表转换成我们可以用于 FeatureTools 库的输入。第一步是加载必要的库。我们将使用 pandas 加载表，使用 framequery 操作数据框，使用 hashlib 将字符串转换为整数，使用特征工具执行深度特征合成，使用 sklearn 进行模型拟合。
import pandas as pd
import framequery as fq
import hashlib
import featuretools as ft
from featuretools import Feature
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
接下来，我们将数据加载到 pandas 数据框中，并删除不会用于构建预测的字符串字段。结果是两个数据帧: game_df 指定一场比赛是常规比赛还是季后赛，而 plays_df 有关于每场比赛的细节。
**# game data** game_df = pd.read_csv("game.csv")**# play data** plays_df = pd.read_csv("game_plays.csv")**# drop some of the string type fields** plays_df = plays_df.drop(['secondaryType', 'periodType',
'dateTime', 'rink_side'], axis=1).fillna(0)**# convert the remaining strings to integer types via hashing** plays_df['event'] = plays_df['event'].apply(hash)
plays_df['description'] = plays_df['description'].apply(hash)
游戏数据是一种窄而深的格式，这意味着每个游戏都由许多不同的游戏组成，只有几个特征。我们的目标是将这些数据转换成一种浅而宽的格式，其中每个游戏都由具有数百种不同属性的单行来描述。这是输入数据集。
The data frames used as input: plays and games.
下一步是将 pandas 数据框转换为实体集表示，FeatureTools 将实体集表示用作执行深度要素合成的输入。实体集用于描述不同表之间的关系。在这种情况下，plays 事件是基本实体，而 games 是父实体。在描述这种关系之前，我们首先对事件和描述字段使用 1-hot 编码。这些开始是字符串字段，但是在执行编码之前被转换为哈希值。这是第一步，如下面的代码片段所示。第二步是使用带有 1-hot 编码的转换表作为实体集创建的输入数据帧，在实体集创建中，我们将游戏定义为游戏的集合。
Creating an entity set with encodings for the event and description fields.
这一步的输出是一个实体集，我们可以使用它来执行深度特征合成。得到的对象 es 具有以下属性。
Entityset: plays
Entities:
plays [Rows: 500638, Columns: 37]
games [Rows: 1529, Columns: 1]
Relationships:
plays.game_id -> games.game_id
一旦我们将数据帧编码为一个实体集，我们就可以使用 FeatureTools 中的 dfs 函数执行深度特征合成，如下所示。结果是特征数据集，它有数百个特征，每个游戏有一行。我们还使用 framequery 为每场比赛分配一个标签，其中季后赛的标签为 1，常规赛的标签为 0。
**# generate features for the data set** features,_ =ft.dfs(entityset=es,target_entity="games",max_depth=2)
features.reset_index(inplace=True)**# assign labels to the generated features** features = fq.execute("""
SELECT f.*, case when g.type = 'P' then 1 else 0 end as label
FROM features f
JOIN game_df g
on f.game_id = g.game_id
""")
这会产生一个浅而宽的数据框，如下所示。我们已经将事件字段从字符串转换为 1-hot 编码字段，现在应用了许多不同的聚合操作。数据现在以一种格式可用，其中单个记录描述每场比赛，我们可以训练一个模型来预测一场比赛是否是季后赛。
The generated features produced from deep feature synthesis.
最后一步是训练和测试模型。为了简单起见，我使用了 sklearn 的逻辑回归模型来拟合数据并评估结果。在下面的代码片段中，精度是在不使用维持集的情况下进行评估的。当我在笔记本中添加维持步骤时，模型的准确性为 94.0%，ROC AUC 为 0.984。
**# create inputs for sklearn** y = features['label']
X = features.drop(['label', 'game_id'], axis=1).fillna(0)**# train a classifier** lr = LogisticRegression()
model = lr.fit(X, y)
model.score(X, y)
这些结果看起来真的令人印象深刻，因为没有关于曲棍球的领域知识被用来训练模型。我没有手动提出特征并试图对曲棍球知识进行编码，而是使用深度特征合成来创建大量特征，作为模型拟合步骤的输入。自动化特征工程是数据科学向前迈出的一大步，使构建预测模型更加自动化。鲨鱼队加油。
本·韦伯是 Zynga 的首席数据科学家。我们正在招聘！
Python 中的自动化要素工程
如何自动创建机器学习特征
机器学习正越来越多地从手工设计的模型转向使用 H20 、 TPOT 和 auto-sklearn 等工具的自动优化流水线。这些库，以及随机搜索等方法，旨在通过在很少或没有人工干预的情况下为数据集找到最佳模型，来简化模型选择和机器学习的调整部分。然而，特征工程，机器学习管道中更有价值的方面，仍然几乎完全是人类的劳动。
特征工程，也称为特征创建，是从现有数据构建新特征来训练机器学习模型的过程。这一步可能比实际使用的模型更重要，因为机器学习算法只从我们给它的数据中学习，创建与任务相关的特征绝对至关重要(参见优秀论文“关于机器学习要知道的一些有用的事情”)。
通常，特征工程是一个耗时的手工过程，依赖于领域知识、直觉和数据操作。这个过程可能非常乏味，最终的特征将受到人的主观性和时间的限制。自动化特征工程旨在通过从数据集中自动创建许多候选特征来帮助数据科学家，可以从这些候选特征中选择最佳特征并用于训练。
在本文中，我们将通过一个使用自动化特征工程和特征工具 Python 库的例子。我们将使用一个示例数据集来展示基础知识(请继续关注未来使用真实数据的帖子)。本文的完整代码在 GitHub 上可以找到。
特征工程基础
功能工程是指从现有数据中构建额外的功能，这些数据通常分布在多个相关的表格中。特征工程要求从数据中提取相关信息，并将其放入单个表中，然后该表可用于训练机器学习模型。
构建要素的过程非常耗时，因为每个新要素通常需要几个步骤来构建，尤其是在使用多个表中的信息时。我们可以将特征创建的操作分为两类:转换和聚合。让我们来看几个例子，看看这些概念是如何运用的。
一个转换通过从一个或多个现有列中创建新的特性来作用于单个表(从 Python 的角度来看，表就是一个熊猫DataFrame)。例如，如果我们有下面的客户表
我们可以通过找到joined列的月份或获取income列的自然日志来创建特征。这两个都是转换，因为它们只使用一个表中的信息。
另一方面，聚合是跨表执行的，使用一对多关系对观察值进行分组，然后计算统计数据。例如，如果我们有另一个关于客户贷款信息的表，其中每个客户可能有多笔贷款，我们可以计算每个客户贷款的平均值、最大值和最小值等统计数据。
这个过程包括按客户机对 loans 表进行分组，计算聚合，然后将结果数据合并到客户机数据中。下面是我们如何使用熊猫的语言在 Python 中做到这一点。
这些操作本身并不难，但是如果我们有几百个变量分布在几十个表中，这个过程手工做是不可行的。理想情况下，我们希望有一个解决方案，能够自动执行跨多个表的转换和聚合，并将结果数据合并到单个表中。尽管熊猫是一个很好的资源，但是我们想要手工处理的数据却很有限！(关于手动特征工程的更多信息，请查阅优秀的 Python 数据科学手册)。
功能工具
幸运的是，featuretools 正是我们正在寻找的解决方案。这个开源 Python 库将从一组相关表中自动创建许多要素。Featuretools 基于一种被称为“深度特征合成的方法，这听起来比实际上更有气势(这个名字来自于堆叠多个特征，而不是因为它使用了深度学习！).
深度特征合成将多个转换和聚合操作(在 featuretools 的 vocab 中称为特征基元)堆叠在一起，从分布在多个表中的数据创建特征。像机器学习中的大多数想法一样，这是一种建立在简单概念基础上的复杂方法。通过一次学习一个构建模块，我们可以很好地理解这个强大的方法。
首先，让我们看看我们的示例数据。我们已经看到了上面的一些数据集，完整的表集合如下:
clients:信用社客户基本信息。每个客户端在该数据帧中只有一行
loans:对客户的贷款。每个贷款在此数据框架中只有自己的行，但客户可能有多个贷款。
payments:贷款付款。每笔付款只有一行，但每笔贷款将有多次付款。
如果我们有一个机器学习任务，例如预测客户是否会偿还未来的贷款，我们会希望将客户的所有信息合并到一个表中。这些表是相关的(通过client_id和loan_id变量),我们可以使用一系列的转换和聚合来手工完成这个过程。然而，我们很快就会看到，我们可以使用 featuretools 来自动化这个过程。
实体和实体集
featuretools 的前两个概念是实体和实体集。一个实体仅仅是一张桌子(或者一个DataFrame，如果你认为是熊猫的话)。一个 EntitySet 是表和它们之间关系的集合。可以把 entityset 想象成另一个 Python 数据结构，有自己的方法和属性。
我们可以使用以下方法在 featuretools 中创建一个空的 entityset:
import featuretools as ft# Create new entityset
es = ft.EntitySet(id = 'clients')
现在我们必须添加实体。每个实体必须有一个索引，它是一个包含所有唯一元素的列。也就是说，索引中的每个值在表中只能出现一次。clients数据帧中的索引是client_id，因为每个客户端在该数据帧中只有一行。我们使用以下语法将具有现有索引的实体添加到 entityset 中:
loans数据帧也有一个惟一的索引loan_id ，将它添加到 entityset 的语法与clients相同。然而，对于payments数据帧，没有唯一的索引。当我们将这个实体添加到 entityset 时，我们需要传入参数make_index = True并指定索引的名称。此外，尽管 featuretools 会自动推断实体中每一列的数据类型，但我们可以通过将列类型的字典传递给参数variable_types来覆盖这一点。
对于该数据帧，尽管missed是一个整数，但它不是一个数值变量，因为它只能取 2 个离散值，所以我们告诉 featuretools 将它视为一个分类变量。将数据帧添加到 entityset 后，我们检查其中的任何一个:
通过我们指定的修改，已经正确地推断出了列类型。接下来，我们需要指定 entityset 中的表是如何关联的。
表关系
考虑两个表之间的关系的最好方法是用父子关系的类比。这是一个一对多的关系:每个父母可以有多个孩子。在表的领域中，父表中每个父表都有一行，但是子表中可能有多行对应于同一父表的多个子表。
例如，在我们的数据集中，clients数据帧是loans数据帧的父数据帧。每个客户端在clients中只有一行，但在loans中可能有多行。同样，loans是payments的父代，因为每笔贷款都有多次支付。父母通过一个共享变量链接到他们的孩子。当我们执行聚合时，我们按照父变量对子表进行分组，并计算每个父变量的子表的统计数据。
为了在 featuretools 中形式化一个关系，我们只需要指定将两个表链接在一起的变量。clients和loans工作台通过client_id变量连接，loans和payments通过loan_id连接。创建关系并将其添加到 entityset 的语法如下所示:
entityset 现在包含三个实体(表)以及将这些实体链接在一起的关系。在添加实体和形式化关系之后，我们的 entityset 就完成了，我们可以开始创建特性了。
特征基元
在我们能够深入进行特征合成之前，我们需要理解特征原语。我们已经知道这些是什么，但是我们只是用不同的名字来称呼它们！这些只是我们用来形成新特征的基本操作:
- 聚合:在父子(一对多)关系中完成的操作，按父项分组并计算子项的统计数据。一个例子是通过
client_id对loan表进行分组，并找到每个客户的最大贷款金额。 - 转换:对单个表到一个或多个列的操作。例如，取一个表中两列的差值或一列的绝对值。
在 featuretools 中，使用这些图元单独或堆叠多个图元来创建新特征。下面是 featuretools 中一些特征原语的列表(我们也可以定义自定义原语):
Feature Primitives
这些图元可以单独使用，也可以组合使用来创建特征。为了用指定的图元制作特征，我们使用ft.dfs函数(代表深度特征合成)。我们传入entityset、target_entity，这是我们想要添加特性的表、选择的trans_primitives(转换)和agg_primitives(聚合):
结果是每个客户端的新特性的数据框架(因为我们让客户端成为了target_entity)。例如，我们有每个客户加入的月份，这是一个转换功能原语:
我们还有许多聚合原语，例如每个客户的平均支付金额:
尽管我们只指定了几个特征基元，featuretools 通过组合和堆叠这些基元创建了许多新的特征。
完整的数据框架有 793 列新功能！
深度特征合成
我们现在已经具备了理解深度特征合成(dfs)的所有要素。事实上，我们已经在前面的函数调用中执行了 dfs！深度特征是由多个图元堆叠而成的简单特征，而 dfs 是制造这些特征的过程的名称。深度特征的深度是制造该特征所需的基元数。
例如，MEAN(payments.payment_amount) 列是深度为 1 的深度特征，因为它是使用单个聚合创建的。深度为 2 的特征是LAST(loans(MEAN(payments.payment_amount)) 这是通过堆叠两个聚合实现的:最后一个(最近的)在平均值之上。这表示每个客户最近贷款的平均支付规模。
我们可以将特性堆叠到任何我们想要的深度，但是实际上，我从来没有超过 2 的深度。在这一点上，这些特征很难解释，但我鼓励任何感兴趣的人尝试“深入”。
我们不必手动指定特征原语，而是可以让 featuretools 自动为我们选择特征。为此，我们使用相同的ft.dfs函数调用，但不传递任何功能原语:
Featuretools 已经建立了许多新功能供我们使用。虽然这一过程确实会自动创建新功能，但它不会取代数据科学家，因为我们仍然需要弄清楚如何处理所有这些功能。例如，如果我们的目标是预测客户是否会偿还贷款，我们可以寻找与特定结果最相关的特征。此外，如果我们有领域知识，我们可以使用它来选择特定的特征基元或种子与候选特征的深度特征合成。
后续步骤
自动化特征工程解决了一个问题，但也产生了另一个问题:太多的特征。虽然在拟合模型之前很难说这些特征中的哪一个是重要的，但很可能不是所有的特征都与我们想要训练模型的任务相关。此外，拥有太多的特性会导致模型性能不佳，因为不太有用的特性淹没了那些更重要的特性。
太多特征的问题被称为维数灾难。随着特征数量的增加(数据维度的增长)，模型学习特征和目标之间的映射变得越来越困难。事实上，模型运行良好所需的数据量与特性数量成指数关系。
通过特征缩减(也称为特征选择)来对抗维数灾难:去除不相关特征的过程。这可以采取多种形式:主成分分析(PCA)、选择最佳、使用来自模型的特征重要性或者使用深度神经网络的自动编码。然而，特性缩减是另一篇文章的不同主题。现在，我们知道我们可以使用 featuretools 从许多表格中以最小的努力创建大量的特征！
结论
像机器学习中的许多主题一样，使用 featuretools 的自动化特征工程是一个建立在简单思想基础上的复杂概念。使用实体集、实体和关系的概念，featuretools 可以执行深度特征合成以创建新特征。深度特征合成反过来堆叠特征基元— **聚合、跨表之间的一对多关系起作用，以及转换、**应用于单个表中的一个或多个列的函数—以从多个表构建新特征。
在以后的文章中，我将展示如何在一个现实世界的问题上使用这种技术，这个问题就是目前在 Kaggle 上举办的家庭信用违约风险竞赛。敬请关注那篇文章，同时，请阅读这篇介绍，开始竞争！我希望您现在可以使用自动化特征工程作为数据科学管道中的辅助工具。我们的模型的好坏取决于我们提供给它们的数据，自动化特征工程有助于提高特征创建过程的效率。
有关 featuretools 的更多信息，包括高级用法，请查看在线文档。要了解 featuretools 在实践中是如何使用的，请阅读 Feature Labs 的工作，这是开源库背后的公司。
一如既往，我欢迎反馈和建设性的批评，可以通过 Twitter @koehrsen_will 联系。
使用文本特征为文本数据自动生成特征
Image Courtesy: https://pixabay.com/en/knowledge-book-library-glasses-1052010/
许多 Kaggle 竞赛的获胜者和数据科学家都强调一件事，那就是“特征工程”，它能让你在竞赛中名列前茅。不管你的模型有多复杂，好的特征总是会比其他的更好地帮助你的机器学习模型建立过程。
什么是特征工程？
功能只不过是列/维度，而功能工程是基于领域知识或统计原则创建新功能或预测器的过程。特征工程一直伴随着机器学习，但最新的是自动化特征工程，最近研究人员开始使用机器学习本身来创建有助于模型准确性的新特征。虽然大多数自动化工程解决的是数字数据，但文本数据由于其固有的非结构化性质，在这场竞争中总是被排除在外。我可以说，没有了。
textfeatures — R 包
密苏里大学的助理教授 Michael Kearney 在 R 社区以现代 twitter 包 rtweet 而闻名，他提出了一个新的 R 包，名为textfeatures，它基本上可以为你提供的任何文本数据生成一系列特性。在你梦想基于深度学习的自动化文本特征工程包之前，这不是。这使用非常简单的文本分析原理，并生成诸如大写字母的数量、标点符号的数量之类的特征——简单明了的东西，没有什么特别的，但非常有用。
装置
textfeatures可以直接从起重机上安装，开发版本可以从 github 上获得。
install.packages("textfeatures")
用例
在本帖中，我们将使用textfeatures包为来自英国的 Fifa 官方世界杯 ios 应用评论生成功能。我们将 R 包itunesr来提取评论和tidyverse进行数据操作和绘图。
加载所需的包:
让我们加载所有需要的包。
#install.packages("itunesr")
#install.packages("textfeatures")
#install.packages("tidyverse")library(itunesr)
library(textfeatures)
library(tidyverse)
提取最近的评论:
#Get UK Reviews of Fifa official world cup ios app
#https://itunes.apple.com/us/app/2018-fifa-world-cup-russia/id756904853?mt=8reviews1 <- getReviews(756904853,"GB",1)
reviews2 <- getReviews(756904853,"GB",2)
reviews3 <- getReviews(756904853,"GB",3)
reviews4 <- getReviews(756904853,"GB",4)#Combining all the reviews into one dataframe
reviews <- rbind(reviews1,
reviews2,
reviews3,
reviews4)
神奇开始了:
既然我们已经得到了评论，让我们让 textfeatures 发挥它的魔力吧。我们将使用函数textfeatures()来完成这项工作。
#Combining all the reviews into one dataframe
reviews <- rbind(reviews1,
reviews2,
reviews3,
reviews4)# generate text features
feat <- textfeatures(reviews$Review)# check what all features generated
glimpse(feat)
Observations: 200
Variables: 17
$ n_chars 149, 13, 263, 189, 49, 338, 210, 186, 76, 14, 142, 114, 242, ...
$ n_commas 1, 0, 0, 0, 0, 1, 2, 1, 1, 0, 1, 1, 0, 3, 0, 0, 1, 0, 3, 1, 0...
$ n_digits 0, 0, 6, 3, 0, 4, 1, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0...
$ n_exclaims 0, 0, 2, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0...
$ n_extraspaces 1, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 4, 0...
$ n_hashtags 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...
$ n_lowers 140, 11, 225, 170, 46, 323, 195, 178, 70, 12, 129, 106, 233, ...
$ n_lowersp 0.9400000, 0.8571429, 0.8560606, 0.9000000, 0.9400000, 0.9557...
$ n_mentions 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...
$ n_periods 2, 0, 5, 1, 0, 0, 3, 1, 2, 0, 2, 1, 1, 2, 0, 0, 4, 2, 0, 4, 0...
$ n_urls 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...
$ n_words 37, 2, 55, 45, 12, 80, 42, 41, 14, 3, 37, 28, 50, 16, 15, 8, ...
$ n_caps 4, 1, 12, 8, 2, 7, 3, 4, 2, 2, 6, 4, 6, 2, 3, 1, 6, 4, 29, 9,...
$ n_nonasciis 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...
$ n_puncts 2, 1, 7, 0, 1, 3, 4, 1, 1, 0, 4, 2, 2, 0, 1, 0, 1, 1, 0, 7, 2...
$ n_capsp 0.03333333, 0.14285714, 0.04924242, 0.04736842, 0.06000000, 0...
$ n_charsperword 3.947368, 4.666667, 4.714286, 4.130435, 3.846154, 4.185185, 4...
从上面可以看到，textfeatures 已经创建了 17 个新功能。请注意，这些功能对于任何文本数据都是一样的。
可视化结果:
对于这篇文章，我们不会建立一个机器学习模型，但这些特征可以很好地用于建立一个分类模型，如情感分类或类别分类。
但是现在，我们只是用一些特征来想象结果。
我们可以根据评论评分，查看字符数和每个单词的字符数之间是否有任何关系。一个假设可能是，给予好评的人不会写得太长或其他。我们不打算在这里验证它，只是用散点图可视化。
# merging features with original reviews
reviews_all %
ggplot(aes(n_charsperword, n_chars, colour = Rating)) + geom_point()
给出了这个图:
让我们用不同的情节从不同的角度来看同一个假设，但是要用一些单词而不是一些字符来比较。
reviews_all %>%
ggplot(aes(n_charsperword, n_words)) + geom_point() +
facet_wrap(~Rating) +
stat_smooth()
给出了这个图:
因此，您可以使用textfeatures自动生成新的特征，并更好地理解您的文本数据。希望这篇文章能帮助你开始使用这个漂亮的软件包，如果你想了解更多关于文本分析的知识，请查看由朱莉娅·西尔格撰写的这篇教程。这里使用的完整代码可以在我的 github 上获得。
本帖最初发表于 DS+
SageMaker 中的自动化超参数优化
注:代码示例在 我的博客 上呈现比在介质上好得多。
什么是超参数优化(HPO)？
因此，您已经构建了您的模型，并获得了合理的结果，现在准备尽可能多地挤出性能。一种可能是进行网格搜索，在那里你尝试超参数的每一种可能的组合，并选择最好的一个。如果您的选择数量相对较少，这种方法很有效，但是如果您有大量的超参数，并且有些是可能跨越几个数量级的连续值，那该怎么办呢？随机搜索可以很好地探索参数空间，而无需致力于探索所有的参数空间，但是在黑暗中随机探索是我们能做的最好的事情吗？
当然不是。贝叶斯优化是一种在进行顺序决策时优化功能的技术。在这种情况下，我们试图通过选择超参数值来最大化性能。这种顺序决策框架意味着，您为下一步选择的超参数将受到所有先前尝试的性能的影响。贝叶斯优化做出关于如何平衡探索参数空间的新区域和利用已知表现良好的区域的原则性决定。这就是说，使用贝叶斯优化通常比网格搜索和随机搜索更有效。
怎么做
好消息是 SageMaker 使这变得非常容易，因为该平台负责以下事项:
- 实施贝叶斯优化算法来处理分类、整数和浮点超参数
- 在给定一组来自 HPO 服务的超参数的情况下，协调模型的训练和评估
- 整合培训作业和 HPO 服务，后者会传达选定的超参数值，并在作业完成后报告绩效
先决条件
下面的代码将假设我们正在使用 TensorFlow 估计器模型，但是与 HPO 相关的部分应该扩展到任何 SageMaker 估计器。要以本示例所示的方式运行代码，您需要以下内容:
- 对 SageMaker 的工作原理有所了解。如果你想要一些这样的例子，在这个回购中有几个官方笔记本例子。你可能会发现 TensorFlow HPO 的例子特别相关。
- 有 SageMaker 的 Python SDK
- 已经配置了必要的 API 权限，或者正在 SageMaker 笔记本实例中运行
步骤 1-创建评估者
使用 SageMaker 运行 HPO 的一个关键要求是，您的模型需要:
- 预计超参数将从 SageMaker 传递
- 将性能指标写入日志
对于内置算法，这已经为您完成了。在使用 SageMaker 构建任意张量流模型的情况下，这意味着在model.py文件中正确配置东西，也称为“入口点”。这是 SageMaker 用来构建 TensorFlow 模型的文件，它希望定义符合特定输入/输出模式的某些函数。(有关您需要指定的功能的更多详细信息，请参见 TensorFlow 自述文件。)
让您的模型准备好接受 SageMaker 的超参数
为了动态地指定参数值，您的模型代码需要接受、解析和利用它们。在 TensorFlow 中，您允许 SageMaker 通过向需要在入口点文件中指定的函数添加hyperparameters参数来指定超参数。例如，对于model_fn中需要的超参数:
DEFAULT_LEARNING_RATE = 1e-3
def model_fn(features, labels, mode, hyperparameters=None):
if hyperparameters is None:
hyperparameters = dict()
# Extract parameters
learning_rate = hyperparameters.get('learning_rate', DEFAULT_LEARNING_RATE)
...
您可能还希望在train_input_fn中有一个超参数，例如指定训练时期的数量:
def train_input_fn(training_dir, hyperparameters=None):
# Extract parameters
if not hyperparameters:
hyperparameters = dict() epochs = hyperparameters.get('epochs', None)
...
如果指定了参数，这些示例提取参数，如果没有指定，则使用默认值。
将性能指标写入日志
将性能指标写入日志的第二个要求是 SageMaker 的一个实现细节:它通过从训练日志文本中提取模型性能来获得运行的模型性能。这些是发送回 HPO 引擎的值。
对于 TensorFlow，默认情况下，EstimatorSpec中指定的指标会写入日志。例如，这段代码是我的model_fn的一部分:
def model_fn(features, labels, model, hyperparameters=None)
...
if mode == tf.estimator.ModeKeys.EVAL:
eval_metric_ops = {
"roc_auc": tf.metrics.auc(
labels,
predictions,
summation_method='careful_interpolation'),
"pr_auc": tf.metrics.auc(
labels,
predictions,
summation_method='careful_interpolation',
curve='PR'),
}
else:
# e.g. in "training" mode
eval_metric_ops = {} return tf.estimator.EstimatorSpec(
mode=mode,
loss=loss,
train_op=train_op,
eval_metric_ops=eval_metric_ops,
)
在训练期间，模型将定期停止并评估测试集(这个过程的细节可以由您配置)。这些事件的日志如下所示:
*2018–10–02 17:23:40,657 INFO — tensorflow — Saving dict for global step 101: global_step = 101, loss = 0.45420808, pr_auc = 0.36799875, roc_auc = 0.6891242*
这是 SageMaker 将用来衡量任何特定培训工作的表现。
构建评估器
评估员通常用于开始一项培训工作。这使您能够告诉 SageMaker 在哪里存储输出，哪些实例用于训练…等等。既然入口点文件中的函数已经正确配置为接受超参数并将性能指标写入日志，您就可以创建 TensorFlow 估计器了:
from sagemaker.tensorflow import TensorFlow# The parameters that are constant and will not be tuned
shared_hyperparameters = {
'number_layers': 5,
}tf_estimator = TensorFlow(
entry_point='my/tensorflow/model.py',
role='<sagemaker_role_arn>',
train_instance_count=1,
train_instance_type='ml.p3.2xlarge',
training_steps=10000,
hyperparameters=shared_hyperparameters,
)
步骤 2 —定义绩效指标
在这一步，我们需要告诉 SageMaker 如何从日志中提取性能信息。这是通过指定一个正则表达式并将其分配给一个度量名称来实现的。尽管您可以指定多个表达式(AWS CloudWatch 会自动收集这些表达式以便于绘图/监控)，但需要挑出其中一个作为 HPO 的优化目标。您还需要指定是最大化还是最小化数量。注意，虽然正则表达式可能匹配多个日志条目，但是日志中的最后一个实例作为最终性能值返回。
objective_metric_name = 'PR-AUC'
objective_type = 'Maximize'
metric_definitions = [
{'Name': 'ROC-AUC', 'Regex': 'roc_auc = ([0-9\\.]+)'},
{'Name': 'PR-AUC', 'Regex': 'pr_auc = ([0-9\\.]+)'}
]
步骤 3-定义超参数搜索空间
我们现在需要指定我们的超参数被称为什么，它们是什么类型(连续、整数或分类)，以及它们的可能值是什么。下面是一个例子:
from sagemaker.tuner import (
IntegerParameter, CategoricalParameter,
ContinuousParameter, HyperparameterTuner)hyperparameter_ranges = {
"learning_rate": ContinuousParameter(1e-5, 1e-1),
"number_nodes": IntegerParameter(32, 512),
"optimizer": CategoricalParameter(['Adam', 'SGD'])
}
步骤 4-指定优化迭代的次数
最后，我们需要决定如何运行 HPO 作业。如果您并行运行许多作业，那么您可以同时探索大部分空间。然而，如果您只是并行运行一百万个作业，那么您实际上是在进行随机搜索。贝叶斯优化的顺序本质允许之前运行的结果通知未来的运行。
因此，我们需要决定总共运行多少个作业，以及在任何给定时间并行运行多少个作业。例如，我们可能运行 100 个作业，并行运行 5 个。总共有 20 次连续迭代，每次探索 5 个点。这里的选择将取决于参数空间的大小和预算。
现在你有了要求 SageMaker 管理 HPO 所需的一切:
tuner = HyperparameterTuner(
tf_estimator,
objective_metric_name,
hyperparameter_ranges,
metric_definitions,
max_jobs=100,
max_parallel_jobs=5,
objective_type=objective_type
)# The data configuration
channel = {
'training': 's3://<bucket_name>/my/training_file.csv',
'test': 's3://<bucket_name>/my/test_file.csv',
}tuner.fit(inputs=channel)
最终性能
您可以使用 sdk 来 pinging SageMaker 以获得状态报告，或者从 HPO 运行中获得最佳作业的统计数据。您还可以从 AWS SageMaker 控制台完成这项工作，它很好地显示了所有作业的性能摘要以及 HPO 作业配置。
如上所述，你可以在控制台中进入 CloudWatch，点击Browse Metrics，找到你在第二步metric_definitions的Name字段中定义的指标。
完成所有工作后，您只需发出以下命令即可部署最佳模型:
tuner.deploy(
initial_instance_count=1,
instance_type='ml.p3.2xlarge'
)
你可以在【blog.zakjost.com】找到我所有的内容并订阅
自动化机器学习:深度的不同概念
机器与人的关系是否达到了一个全新的水平？
Photo by Robin Joshua on Unsplash
计算机编程是自动化，机器学习是自动化自动化。那么，自动化机器学习就是自动化自动化的自动化。
——塞巴斯蒂安·拉什卡
自动机器学习已经在人工智能的雷达下好几年了。尽管像亚马逊和谷歌这样的大公司已经推出了他们的 AutoML 工具，但 ICML 的 AutoML 研讨会已经引起了人们的极大兴趣，研究朝着理解机器学习问题的本质迈出了重要的一步，AutoML 仍然是一个小众术语，为数据科学社区的先锋派保留。
可能被深度学习的狂热所掩盖，显然还没有成熟到让我们眼花缭乱的应用程序，AutoML 还没有被理解或明确定义。人机关系的下一步？对人工智能更深层次的理解？
重要的发现通常是事后承认的，因为社会需要经历、理解和评价它们。尤其是当涉及到人工智能时，很容易只见树木不见森林，因为事情正在变得更深——但是向哪个方向更深呢？
什么是 AutoML？
1。在训练机器学习模型中插入更多的自动化。
等等，机器学习模型不是已经自动训练好了吗？部分是的，这就是为什么我们称之为机器学习，因为算法根据我们给它们的数据自己“学习”。然而，最繁琐、最耗时的任务，那些传统上在发布惊人结果时被低估的任务，与模型的实际训练无关。
机器学习 75%是准备做机器学习……15%是你之后做的。
—里奇·卡鲁阿纳，ICML 2015
参与机器学习实验的任何人都认识到，好的结果很容易得到，但满意的结果需要时间、聪明的设计、该领域的经验，而且往往需要一点运气才能实现。卡鲁阿纳提到的实验的 90%是预处理、特征提取、超参数调整、算法选择、模型评估和 ML 流水线的其他可能步骤。
AutoML 主要关注的步骤是超参数调整，这通常是指为学习算法的超参数选择最佳值，这是它自己无法选择的。例如，神经网络自己学习最佳权重，但是对于 ML 实践者来说，定义层的数量、神经元的数量和学习速率是一项任务，并且是最乏味的任务。因为调优是一项定义明确的任务，所以它一直是 AutoML 工具的主要目标。
2。从 ML 实验的应用中收集元知识。
那么，一个人能从 ML 实验中得到什么呢？希望是个好模特。对数据的一些见解，可能。一个更有经验的数据科学家，可以说是唯一的长期收获。但是这种新获得的经验的实质是什么呢？数据科学家已经理解了 ML 问题的性质，已经下意识地认识到一些模式，并且当他在将来面对类似的问题时，他将能够重用他的知识并提供更快、更直接的解决方案。
这是元学习领域背后的本质:当解决一个不属于模型的 ML 问题时，创建元知识，但它足够一般化以用于其他情况。
从数据集中提取元特征是 AutoML 工具中经常使用的一种技术，用于初始化学习算法的超参数:如果您知道一些值在特定问题中工作得很好，为什么不在解决类似问题时从它们开始呢？正是在制定和量化数据集之间的相似性方面，元学习和人类经验的挑战仍然超过人工智能。
3。跨学习任务传递知识。
如果元学习与创造元知识有关，那么迁移学习就是寻找使用元知识的正确方法。你可能已经听说过成功使用迁移学习的应用:一个玩不同雅达利游戏的深度神经网络和一个为《我的世界》学习技能的代理，是少数几个例子。
迁移学习可以从简单的(简单地跨问题传递数据或训练模型)到更微妙的(重用良好的超参数化)到高度复杂的(机器学习算法不仅学习特定问题的好解决方案，还学习可以重用的技能)。
现在很明显，AutoML 的研究正专注于更高层次的机器学习:既然我们已经练习机器学习几十年了，我们是否已经达到了允许我们清楚地制定它并教给别人的理解水平？谁比机器更适合做学生呢？
那些知道的人会去做。理解的人，教导。
——亚里士多德
什么不是 AutoML？
1。更多的 GPU/CPU。
强大的计算能力意味着巨大的责任。说最近深度学习的突破只能归功于一些研究小组拥有的巨大计算能力是不公平的。这涉及到大量的直觉、经验和创造力，但准确地说，如果没有这种计算能力，深度学习是不可行的。
通过给一个简单的技术，如网格搜索，提供大量的资源来实现一个优秀的超参数化，不是 AutoML 。在1202 CPU 和176 GPU上训练得到好的模型不是 AutoML 。AutoML 是关于通过利用过去的经验做出明智的决策，以使机器学习更少暴力，更智能。从面向应用的深度学习到面向抽象的自动化需要研究社区在方法和工具上的转变，但这可能是唯一的？)超越我们在大多数应用程序中仍然存在的性能障碍的方法，如强化学习。
2。一个神奇的盒子，给出了一个很好的预测模型。
诚然，AutoML的短暂历史揭示了我们最初的希望是这样实现的:一个黑盒，它接收请求并返回可能的最佳模型。不需要数据科学家，不需要理解问题的性质，不需要透明的实验界面。纯自动化。
虽然我们不能确定这种方法失败是因为它总体上是错误的，还是因为我们的技术没有准备好支持它，但它确实感觉与我们迄今为止的人类经验形成了对比:自动化只有在深入理解一个问题之后才会出现。我们真的不知道强人工智能会是什么样子，但是黑匣子听起来像是一个不真实的(安静的赛博朋克)场景。
3。将导致数据科学家灭绝的陨石。
直到我们到达一个点，整个人类变得过时，生活在矩阵中，我们仍然需要数据科学家。无论我们的机器学习工具和一般技术变得多么先进，我们都需要一个人在回路中。事实上，一项技术变得越复杂，你就越需要更有经验、想象力和分析能力的科学家来掌握它。
AutoML 工具目前作为数据科学家的助手销售，可以承担和改进 ML 管道的一些步骤，但仍然需要人来协调和检查实验。只要你保持不断提高的技能、好奇心和对世界的独特视角，你就不是可有可无的——作为一名数据科学家、一名员工和一个普通人。
Data scientists in 10 years from now? Opinions differ. Original image credit: https://kevbrockschmidt.wordpress.com/tag/archive/
快速了解 AutoML
AutoML 是一个年轻的研究领域，所以通过研究相关的工具和思想，很容易很好地理解它。自然，这些想法都是老的，在不同的领域已经成熟。观察研究团体如何通过定义问题和融合这些想法来响应对 AutoML 的需求是令人兴奋的！(好吧，对于像我这样的计算机科学家来说，主观上是令人兴奋的。)
现金问题
AutoML 问题的第一个定义可能是由 AutoWEKA 团队提供的，他们试图将组合算法选择和超参数优化问题自动化。这个问题有一个优雅的数学公式，但是，简单地说，这个问题就是:
哪种 ML 算法(SVM？神经网络？)以及它的什么参数化(内核？层数？)在为数据集设计 ML 解决方案时，我应该使用什么？
没有免费的午餐定理
在选择最大似然算法时，所有数据科学家都有自己的偏好。神经网络引起了人们极大的兴趣，但是有各种各样的算法。因为决定通常是应用、品味和习惯的产物，所以很自然地会想:
有没有一种 ML 算法永远是最佳选择？
简短的答案是否定的。由《没有免费的午餐定理》的作者提供的长答案更具技术性，但主要归结为这样一个事实:如果我们在所有可能的数据集(生成数据的概率分布)上平均所有最大似然算法的性能，性能是相同的。因此，AutoML 无法将算法选择任务自动化到只有一种算法将用于所有应用的程度。
贝叶斯优化
那么，如何找到最佳算法及其参数化呢？嗯，这只不过是一个优化问题，我们目前一直在用众所周知的“试试看”的方法来解决这个问题。
由于这种方法对于大型搜索空间(比如深度神经网络)来说效率低下，数据科学家需要(指数级)更多的 GPU 或更好的优化方法。
贝叶斯优化是一种吸引了大量兴趣的技术(参见 auto-sklearn)，因为它是优化黑盒函数的有效方法:如果我们假设神经网络中的层数与其实现的性能之间存在关系，那么我们可以通过将它建模为概率分布来尝试近似这种关系。
贝叶斯优化从假设一个模型(通常是统一的模型)开始。然后，is 通过挑选若干层并实验性地评估性能来对搜索空间进行采样。在此之后，可以通过对样本拟合概率分布来更新模型，并且算法将基于当前模型挑选最有可能使性能最大化的值作为下一个样本。通过迭代这个过程，我们可以得到一个精确的模型和一个好的参数值。
Bayesian optimization: the yellowish line is the true model and the purple is the approximation, along with its confidence intervals, which we improve by sampling the search space. Original image credit and an in-depth explanation of Bayesian optimization: http://krasserm.github.io/2018/03/21/bayesian-optimization/
现有工具
AutoML 工具似乎遵循两个不同的指令:它们要么是以研究为导向的框架，专注于自动化 ML 管道的特定步骤，要么是成熟的市场产品。
Auto-sklearn 专注于现金问题。它采用贝叶斯优化和元学习来智能地搜索组合算法-超参数空间。Auto-sklearn 在 ChaLearn AutoML 和 KDnuggets 比赛中被证明非常有效，可能是因为它在模型形成问题中融入了集成学习。
HPO 图书馆，是一个超参数优化库，可以证明非常有用的研究目的，因为它提供了一个统一的接口，其他三个 AutoML 软件包:SMAC，留兰香和 TPE。不幸的是，它的开发已经停止。
r 也拥抱了自动化的精神。Caret 更像是一个接口，而不是一个自治的包，它通过提供一个简单的 ML 实验接口来解决众所周知的 R 包的多样性。Caret 主要自动化 ML 管道的形成，但是步骤仍然是常规的。
然后，是营销产品，数据科学家可以使用，但不能扩展。数据科学家或公司可以选择使用谷歌的 Cloud AutoML、微软的 Azure 或亚马逊的网络服务。这些工具提供了优雅的界面、强大的后端处理能力以及设计良好实验的有用提示。然而，市场还远未声称 AutoML 已经完善，因为这些工具不能被盲目信任来解决端到端的 ML 问题。
为什么你应该关心
AutoML 对于数据科学家来说是一个全新的工具。和所有的工具一样，它可以被珍视，被误用或者生锈。作为一名数据科学家，您可以选择使用 AutoML now 作为助手，将您从预处理数据或调整模型的繁琐任务中解放出来，从而提高您的工作效率。或者，你可以投入时间成为一名 AutoML 专家，并将其作为未来就业市场的战略武器，或者作为一个行业的挡箭牌，该行业将琐碎的事情自动化，但仍在努力解决智能的非平凡性——人工或非人工。
最后，作为不断发展与技术关系的人类社会的一部分，我们应该记住，问题不总是我们应该自动化什么，而是有时可能是:我们不应该自动化什么？
我们生活在一个奇怪的时代。我们可以去任何我们想去的地方旅行，甚至去其他星球。为了什么？日复一日地坐着，士气和希望都在下降。
― 菲利普·K·蒂克，高高城堡里的人
Python 中的自动机器学习超参数调整
Python 中使用贝叶斯优化进行自动超参数调优的完整演练
调整机器学习超参数是一项繁琐而又至关重要的任务，因为算法的性能可能高度依赖于超参数的选择。手动调整会占用机器学习管道中重要步骤的时间，如特征工程和解释结果。网格和随机搜索不需要手动操作，但是需要很长的运行时间，因为它们浪费时间评估搜索空间中没有希望的区域。越来越多的超参数调整是通过自动化方法完成的，这些方法旨在使用信息搜索在更短的时间内找到最佳超参数，除了初始设置之外，无需任何人工操作。
贝叶斯优化，一种基于模型的寻找函数最小值的方法，最近已经应用到机器学习超参数调整，结果表明这种方法可以在测试集上实现更好的性能，同时比随机搜索需要更少的迭代。此外，现在有许多 Python 库使得实现贝叶斯超参数调整对于任何机器学习模型都很简单。
在本文中，我们将使用 Hyperopt 库完成一个梯度增强机器的贝叶斯超参数调整的完整示例。在之前的一篇文章中，我概述了这个方法背后的概念，所以这里我们将坚持实现。像大多数机器学习主题一样，没有必要理解所有的细节，但知道基本思想可以帮助你更有效地使用技术！
本文的所有代码都可以从 GitHub 上的 Jupyter 笔记本中获得。
目录
贝叶斯优化方法
作为一个简短的引子，贝叶斯优化通过基于目标的过去评估结果建立代理函数(概率模型)来找到使目标函数最小化的值。与目标相比，代理的优化成本更低，因此要评估的下一个输入值是通过对代理应用一个标准来选择的(通常是预期改进)。贝叶斯方法不同于随机或网格搜索，因为它们使用过去的评估结果选择下一个值来评估。其概念是:通过基于过去表现良好的输入值选择下一个输入值，限制目标函数的昂贵评估。
在超参数优化的情况下，目标函数是使用一组超参数的机器学习模型的验证误差。目标是找到在验证集上产生最低误差的超参数，希望这些结果可以推广到测试集。评估目标函数是昂贵的，因为它需要用一组特定的超参数来训练机器学习模型。理想情况下，我们希望有一种方法能够探索搜索空间，同时限制对差的超参数选择的评估。贝叶斯超参数调整使用持续更新的概率模型，通过从过去的结果进行推理来“集中”于有希望的超参数。
Python 选项
Python 中有几个贝叶斯优化库，它们在目标函数的代理算法上有所不同。在本文中，我们将使用 Hyperopt，它使用了 Tree Parzen Estimator (TPE) 其他 Python 库包括 Spearmint (高斯过程代理)和 SMAC (随机森林回归)。在这个领域有很多有趣的工作在进行，所以如果你对一个库不满意，可以看看其他的库！一个问题的一般结构(我们将在这里遍历)在两个库之间转换，只有语法上的微小差异。关于 Hyperopt 的基本介绍，请参见本文。
最优化问题的四个部分
贝叶斯优化问题有四个部分:
- **目标函数:**我们想要最小化什么，在这种情况下，机器学习模型关于超参数的验证误差
- **域空间:**超参数值搜索结束
- **优化算法:**构建替代模型和选择下一个超参数值进行评估的方法
- **结果历史:**存储由超参数和验证损失组成的目标函数的评估结果
有了这四个部分，我们可以优化(找到最小值)任何返回一个实值的函数。这是一个强大的抽象，除了调优机器学习超参数之外，它还让我们解决了许多问题。
数据集
对于本例，我们将使用房车保险数据集，其目标是预测客户是否会购买保险。这是一个有 5800 个训练观测值和 4000 个测试点的监督分类问题。我们将使用曲线 (ROC AUC)下的接收器操作特征面积来评估性能，因为这是一个不平衡的分类问题。(ROC AUC 越高越好，1 分表示模型完美)。数据集如下所示:
Dataset (CARAVAN) is the label
因为远视需要一个最小化的值，我们将从目标函数返回 1-ROC AUC，从而提高 ROC AUC。
梯度推进模型
关于梯度提升机器 (GBM)的详细知识对于本文来说不是必需的，这里是我们需要理解的基础知识:GBM 是一种基于使用弱学习器(几乎总是决策树)的集成提升方法，这些弱学习器被顺序训练以形成强模型。在 GBM 中有许多超参数控制整个集合和个体决策树。选择树的数量(称为估计量)的最有效的方法之一是我们将使用的提前停止。 LightGBM 在 Python 中提供了一个快速简单的 GBM 实现。
关于 GBM 的更多细节，这里有一篇高级文章和一篇技术论文。
有了必要的背景知识之后，让我们来看一下为超参数调整编写贝叶斯优化问题的四个部分。
目标函数
目标函数是我们试图最小化的。它接受一组值——在本例中是 GBM 的超参数——并输出一个真实值以最小化交叉验证损失。Hyperopt 将目标函数视为一个黑盒，因为它只考虑什么进什么出。该算法不需要知道目标函数的内部，就可以找到使损失最小的输入值！在很高的层次上(用伪代码)，我们的目标函数应该是:
def objective(hyperparameters):
"""Returns validation score from hyperparameters"""
model = Classifier(hyperparameters)
validation_loss = cross_validation(model, training_data) return validation_loss
我们需要小心不要使用测试组的损失，因为当我们评估最终模型时，我们只能使用测试组一次。相反，我们在验证集上评估超参数。此外，我们使用 KFold 交叉验证，而不是将训练数据分离到不同的验证集中，这除了保留有价值的训练数据之外，还会给我们测试集上的误差估计带来更少的偏差。
超参数调整的目标函数的基本结构在各个模型中是相同的:该函数接受超参数并使用这些超参数返回交叉验证误差。虽然这个例子是特定于 GBM 的，但是该结构可以应用于其他方法。
使用提前停止的 10 倍交叉验证的梯度增强机器的完整目标函数如下所示。
主线是cv_results = lgb.cv(...)。为了实现带有提前停止的交叉验证，我们使用 LightGBM 函数cv，它接受超参数、一个训练集、用于交叉验证的折叠数和几个其他参数。我们将估计器的数量(num_boost_round)设置为 10000，但是实际上不会达到这个数量，因为当 100 个估计器的验证分数没有提高时，我们使用early_stopping_rounds来停止训练。早期停止是选择估计量数量的有效方法，而不是将其设置为另一个需要调整的超参数！
一旦交叉验证完成，我们得到最好的分数(ROC AUC)，然后，因为我们想要一个值最小化，我们取 1-最好的分数。然后这个值作为返回字典中的loss键返回。
这个目标函数实际上比它需要的要复杂一点，因为我们返回一个值的字典。对于 Hyperopt 中的目标函数，我们可以返回一个值，即 loss，或者返回一个至少有关键字"loss"和"status"的字典。返回超参数将让我们检查每组超参数导致的损失。
领域空间
域空间表示我们想要为每个超参数评估的值的范围。每次搜索迭代，贝叶斯优化算法将从域空间中为每个超参数选择一个值。当我们进行随机或网格搜索时，域空间是一个网格。在贝叶斯优化中，想法是相同的，除了这个空间对于每个超参数具有概率分布而不是离散值。
指定领域是贝叶斯优化问题中最棘手的部分。如果我们有机器学习方法的经验，我们可以通过在我们认为最佳值的地方放置更大的概率来使用它来通知我们对超参数分布的选择。然而，最佳模型设置将因数据集而异，并且对于高维度问题(许多超参数),可能很难弄清楚超参数之间的相互作用。在我们不确定最佳值的情况下，我们可以使用宽分布，让贝叶斯算法为我们进行推理。
首先，我们应该查看 GBM 中的所有超参数:
import lgb# Default gradient boosting machine classifier
model = lgb.LGBMClassifier()
model**LGBMClassifier(boosting_type='gbdt', n_estimators=100,
class_weight=None, colsample_bytree=1.0,
learning_rate=0.1, max_depth=-1,
min_child_samples=20,
min_child_weight=0.001, min_split_gain=0.0,
n_jobs=-1, num_leaves=31, objective=None,
random_state=None, reg_alpha=0.0, reg_lambda=0.0,
silent=True, subsample=1.0,
subsample_for_bin=200000, subsample_freq=1)**
我不确定世界上是否有人知道所有这些是如何相互作用的！其中一些我们不必调优(比如objective和random_state)，我们将使用提前停止来找到最好的n_estimators。但是，我们还有 10 个超参数需要优化！当第一次调优一个模型时，我通常会创建一个以默认值为中心的宽域空间，然后在后续的搜索中对其进行优化。
例如，让我们在 Hyperopt 中定义一个简单的域，GBM 中每棵树的叶子数量的离散均匀分布:
from hyperopt import hp# Discrete uniform distribution
num_leaves = {'num_leaves': hp.quniform('num_leaves', 30, 150, 1)}
这是一个离散均匀分布，因为叶子的数量必须是一个整数(离散的)，并且域中的每个值都是同等可能的(均匀的)。
分布的另一种选择是对数均匀分布，它在对数尺度上均匀分布数值。我们将对学习率使用统一的对数(从 0.005 到 0.2)，因为它在几个数量级之间变化:
# Learning rate log uniform distribution
learning_rate = {'learning_rate': hp.loguniform('learning_rate',
np.log(0.005),
np.log(0.2)}
因为这是对数均匀分布，所以这些值在指数(低)和指数(高)之间绘制。下方左侧的图显示离散均匀分布，右侧的图显示对数均匀分布。这些是内核密度估计图，所以 y 轴是密度而不是计数！
Domain for num_leaves (left) and learning_rate (right)
现在，让我们定义整个域:
这里我们使用了许多不同的域分布类型:
choice:分类变量quniform:离散均匀(间隔均匀的整数)uniform:连续均匀(浮动间隔均匀)loguniform:连续的均匀圆木(在圆木刻度上均匀分布的浮子)
(文档中还列出了其他发行版。)
当我们定义升压类型时，需要注意一个要点:
这里我们使用了一个条件域，这意味着一个超参数的值依赖于另一个超参数的值。对于增强类型"goss"，gbm 不能使用子采样(仅选择训练观察的 [subsample](https://astro.temple.edu/~msobel/courses_files/StochasticBoosting(gradient).pdf) 部分用于每次迭代)。因此，如果增强类型为"goss" ，则subsample比率设置为 1.0(无二次采样)，否则为 0.5–1.0。这是使用嵌套域实现的。
当我们使用具有完全独立参数的不同机器学习模型时，条件嵌套会很有用。条件允许我们根据 a choice的值使用不同的超参数集。
既然我们的领域已经定义好了，我们可以从中抽取一个例子来看看一个典型的样本是什么样子的。当我们采样时，因为subsample最初是嵌套的，我们需要将它赋给一个顶级键。这是使用 Python 字典get方法完成的，默认值为 1.0。
**{'boosting_type': 'gbdt',
'class_weight': 'balanced',
'colsample_bytree': 0.8111305579351727,
'learning_rate': 0.16186471096789776,
'min_child_samples': 470.0,
'num_leaves': 88.0,
'reg_alpha': 0.6338327001528129,
'reg_lambda': 0.8554826167886239,
'subsample_for_bin': 280000.0,
'subsample': 0.6318665053932255}**
(这种嵌套键的重新分配是必要的，因为梯度推进机器不能处理嵌套的超参数字典)。
最优化算法
尽管这是贝叶斯优化在概念上最困难的部分，但在 Hyperopt 中创建优化算法只需一行代码。要使用树 Parzen 估计器，代码为:
from hyperopt import tpe# Algorithm
tpe_algorithm = tpe.suggest
这就是全部了！Hyperopt 只有 TPE 选项和随机搜索，尽管 GitHub 页面说其他方法可能会出现。在优化过程中，TPE 算法根据过去的结果构建概率模型，并通过最大化期望的改善来决定下一组超参数以在目标函数中进行评估。
结果历史
跟踪结果并不是绝对必要的，因为 Hyperopt 会在算法内部跟踪结果。然而，如果我们想知道幕后发生了什么，我们可以使用一个Trials对象，它将存储基本的训练信息以及从目标函数返回的字典(包括loss和params)。制作一个试验对象只需一行代码:
from hyperopt import Trials# Trials object to track progress
bayes_trials = Trials()
另一个允许我们监控长时间训练过程的选项是在每次搜索迭代中向 csv 文件中写入一行。这也将所有的结果保存到磁盘上，以防灾难性的事情发生，我们丢失了试验对象(根据经验)。我们可以使用csv库来做到这一点。在培训之前，我们打开一个新的 csv 文件，并写入标题:
然后在目标函数中，我们可以在每次迭代中添加要写入 csv 的行(完整的目标函数在笔记本中):
写入 csv 意味着我们可以在训练时通过打开文件来检查进度(尽管不在 Excel 中，因为这会导致 Python 中的错误。使用 bash 中的tail out_file.csv查看文件的最后几行)。
最佳化
一旦我们有了这四个部分，就用fmin进行优化:
每次迭代，该算法从基于先前结果构建的替代函数中选择新的超参数值，并在目标函数中评估这些值。对于目标函数的MAX_EVALS评估，这是持续的，代理函数随着每个新的结果不断更新。
结果
从fmin返回的best对象包含在目标函数上产生最低损失的超参数:
**{'boosting_type': 'gbdt',
'class_weight': 'balanced',
'colsample_bytree': 0.7125187075392453,
'learning_rate': 0.022592570862044956,
'min_child_samples': 250,
'num_leaves': 49,
'reg_alpha': 0.2035211643104735,
'reg_lambda': 0.6455131715928091,
'subsample': 0.983566228071919,
'subsample_for_bin': 200000}**
一旦我们有了这些超参数，我们就可以使用它们在完整的训练数据上训练一个模型，然后在测试数据上进行评估(记住，我们只能使用测试集一次，当我们评估最终模型时)。对于估计数，我们可以使用在提前停止的交叉验证中返回最低损失的估计数。最终结果如下:
**The best model scores 0.72506 AUC ROC on the test set.
The best cross validation score was 0.77101 AUC ROC.
This was achieved after 413 search iterations.**
作为参考，随机搜索的 500 次迭代返回了一个在测试集上得到 0.7232 ROC AUC 和在交叉验证中得到 0.76850 的模型。没有优化的默认模型在测试集上的得分为 0.7143 ROC AUC 。
当我们查看结果时，需要记住一些重要的注意事项:
- 最佳超参数是那些在交叉验证中表现最好的超参数，而不一定是那些在测试数据中表现最好的超参数。当我们使用交叉验证时，我们希望这些结果可以推广到测试数据中。
- 即使使用 10 重交叉验证，超参数调整也会使过度适应训练数据。来自交叉验证的最好分数明显高于测试数据上的分数。
- 随机搜索可能仅仅凭借运气返回更好的超参数(重新运行笔记本可能会改变结果)。贝叶斯优化不能保证找到更好的超参数，并且可能陷入目标函数的局部最小值。
贝叶斯优化有效，但不会解决我们所有的调优问题。随着搜索的进行，算法从探索(尝试新的超参数值)切换到利用(使用导致最低目标函数损失的超参数值)。如果算法找到目标函数的局部最小值，它可以集中在局部最小值周围的超参数值上，而不是尝试位于域空间中远处的不同值。随机搜索没有这个问题，因为它不集中于任何值！
另一个要点是，超参数优化的好处将因数据集而异。这是一个相对较小的数据集(约 6000 个训练观察值)，调整超参数的回报很小(获取更多数据会更好地利用时间！).记住所有这些警告，在这种情况下，使用贝叶斯优化，我们可以得到:
- 测试集上更好的性能
- 调整超参数的迭代次数更少
贝叶斯方法可以(尽管不总是)产生比随机搜索更好的调优结果。在接下来的几节中，我们将研究贝叶斯超参数搜索的发展，并与随机搜索进行比较，以了解贝叶斯优化是如何工作的。
可视化搜索结果
绘制结果图是理解超参数搜索过程中发生的事情的直观方式。此外，比较贝叶斯优化和随机搜索是有帮助的，这样我们可以看到这两种方法有什么不同。要了解情节是如何制作的，随机搜索是如何实现的，请参见笔记本，但这里我们将浏览结果。(注意，精确的结果会随着迭代而变化，所以如果您运行笔记本，如果您得到不同的图像，请不要感到惊讶。所有这些图都是用 500 次迭代绘制的)。
首先，我们可以制作随机搜索和贝叶斯优化中采样的learning_rate的核密度估计图。作为参考，我们还可以显示抽样分布。垂直虚线显示了学习率的最佳值(根据交叉验证)。
我们将学习率定义为 0.005 到 0.2 之间的对数正态，贝叶斯优化结果看起来类似于采样分布。这告诉我们，我们定义的分布看起来适合这个任务，尽管最优值比我们放置最大概率的地方高一点。这可以用于通知域进行进一步的搜索。
另一个超参数是 boosting 类型，在随机搜索和贝叶斯优化过程中评估每种类型的条形图，如下所示。由于随机搜索不关注过去的结果，我们希望每种提升类型被使用的次数大致相同。
根据贝叶斯算法，gdbt助推式比dart或goss更有希望。同样，这可以帮助通知进一步的搜索，无论是贝叶斯方法或网格搜索。如果我们想进行更明智的网格搜索，我们可以使用这些结果来定义一个更小的网格，集中在超参数的最有希望的值周围。
既然我们已经有了它们，让我们看看来自参考分布、随机搜索和贝叶斯优化的所有数值超参数。垂直线再次指示每次搜索的超参数的最佳值:
在大多数情况下(除了subsample_for_bin)，贝叶斯优化搜索倾向于集中(放置更多概率)在交叉验证中产生最低损失的超参数值附近。这说明了使用贝叶斯方法进行超参数调优的基本思想:花更多的时间评估有希望的超参数值。
这里也有一些有趣的结果，可能会在将来定义搜索领域空间时对我们有所帮助。仅举一个例子，看起来reg_alpha和reg_lambda应该互补:如果一个高(接近 1.0)，另一个应该更低。不能保证这将适用于所有问题，但通过研究结果，我们可以获得可能应用于未来机器学习问题的见解！
搜索的演变
随着优化的进行，我们希望 Bayes 方法关注超参数中更有前途的值:那些在交叉验证中产生最低误差的值。我们可以绘制超参数值与迭代的关系图，看看是否有明显的趋势。
黑色星号表示最佳值。随着时间的推移，colsample_bytree和learning_rate会减少，这可以指导我们未来的搜索。
最后，如果贝叶斯优化有效，我们预计平均验证分数会随着时间的推移而增加(反之，损失会减少):
贝叶斯超参数优化的验证分数随着时间的推移而增加，表明该方法正在尝试“更好”的超参数值(应该注意的是，这些只是根据验证分数而变得更好)。随机搜索没有显示出迭代的改进。
继续搜索
如果我们对模型的性能不满意，我们可以使用 Hyperopt 从我们停止的地方继续搜索。我们只需要传入同一个 trials 对象，算法将继续搜索。
随着算法的发展，它会进行更多的开发——挑选过去表现良好的值——而较少的探索——挑选新值。因此，与其从搜索停止的地方继续，不如开始一个完全不同的搜索。如果第一次搜索的最佳超参数真的是“最优”的，我们会期望后续的搜索集中在相同的值上。考虑到问题的高维度，以及超参数之间的复杂相互作用，另一次搜索不太可能产生一组相似的超参数。
经过另外 500 次迭代训练，最终模型在测试集上的得分为 0.72736 ROC AUC 。(我们真的不应该在测试集上评估第一个模型，而是只依赖验证分数。理想情况下，测试集应该只使用一次，以便在新数据上部署时获得算法性能的度量。同样，由于数据集的规模较小，这个问题可能会对进一步的超参数优化产生递减的回报，并且最终会出现验证误差的平台期(由于未测量的隐藏变量和噪声数据，数据集上任何模型的性能都存在固有的限制，称为贝叶斯误差)。
结论
机器学习模型的自动超参数调整可以使用贝叶斯优化来完成。与随机搜索相比，贝叶斯优化以一种明智的方法选择下一个超参数，以花更多的时间评估有希望的值。与随机或网格搜索相比，最终结果可以是对目标函数更少的评估和对测试集更好的泛化性能。
在本文中，我们使用 Hyperopt 一步一步地介绍了 Python 中的贝叶斯超参数优化。我们能够改进梯度增强机器的测试集性能，使其超出基线和随机搜索，尽管我们需要小心避免过度拟合训练数据。此外，通过检查结果图，我们看到了随机搜索与贝叶斯优化的不同之处，结果图显示贝叶斯方法对超参数值赋予了更大的概率，从而导致了更低的交叉验证损失。
使用优化问题的四个部分，我们可以使用 Hyperopt 来解决各种各样的问题。贝叶斯优化的基本部分也适用于 Python 中实现不同算法的个库。从手动切换到随机或网格搜索是一小步，但要让你的机器学习更上一层楼，需要某种自动化形式的超参数调整。贝叶斯优化是一种既易于在 Python 中使用，又能返回比随机搜索更好的结果的方法。希望你现在有信心开始使用这个强大的方法来解决你自己的机器学习问题！
一如既往，我欢迎反馈和建设性的批评。可以通过 Twitter @koehrsen_will 找到我。
Python 中云上的自动机器学习
数据科学的未来介绍
数据科学领域最近出现了两个明显的趋势:
- 数据分析和模型训练是使用云资源完成的
- 机器学习管道是通过算法开发和优化的
本文将简要介绍这些主题，并展示如何实现它们，使用 Google Colaboratory 在 Python 中的云上进行自动机器学习。
使用 Google Colab 的云计算
最初，所有的计算都是在一台大型主机上完成的。你通过终端登录，并连接到一台中央机器，在那里用户同时共享一台大型计算机。然后，随着 T4 微处理器和个人电脑革命的到来，每个人都有了自己的电脑。笔记本电脑和台式机可以很好地完成日常任务，但随着最近数据集规模和运行机器学习模型所需的计算能力的增加，利用云资源对数据科学来说是必要的。
云计算一般指“通过互联网交付计算服务”。这涵盖了广泛的服务，从数据库到服务器到软件，但在本文中，我们将以 Jupyter 笔记本的形式在云上运行一个简单的数据科学工作负载。我们将使用相对较新的谷歌联合实验室服务:运行在谷歌服务器上的 Python 在线 Jupyter 笔记本，可以从任何有互联网连接的地方访问，免费使用，像任何谷歌文档一样可以共享。
Google Colab 让云计算的使用变得轻而易举。过去，我花了几十个小时来配置 Amazon EC2 实例，这样我就可以在云上运行 Jupyter 笔记本，并且必须按小时付费！幸运的是，去年，谷歌宣布你现在可以在他们的 Colab 服务器上运行 Jupyter 笔记本长达 12 小时，一次完全免费。(如果这还不够，谷歌最近开始让用户在笔记本上添加英伟达特斯拉 K80 GPU )。最棒的是，这些笔记本电脑预装了大多数数据科学软件包，并且可以轻松添加更多软件包，因此您不必担心在自己的机器上进行设置的技术细节。
要使用 Colab，你只需要一个互联网连接和一个谷歌账户。如果你只是想要一个介绍，前往colab.research.google.com并创建一个新的笔记本，或者探索谷歌开发的教程(称为Hello, Colaboratory)。要阅读这篇文章，请点击这里的获取笔记本。登录您的 Google 帐户，在 Colaboratory 中打开笔记本，单击文件>在驱动器中保存一份副本，然后您将拥有自己的版本进行编辑和运行。
First open the notebook in Colaboratory
Second, save a copy in your drive to edit
随着在线资源的丰富，数据科学变得越来越容易获得，而 Colab 项目大大降低了云计算的壁垒。对于那些以前在 Jupyter Notebooks 中做过工作的人来说，这是一个完全自然的过渡，对于那些没有做过的人来说，这是一个开始使用这种常用数据科学工具的绝佳机会！
使用 TPOT 的自动机器学习
自动化机器学习(缩写为 auto-ml)旨在通过算法设计和优化针对特定问题的机器学习管道。在这种情况下，机器学习管道包括:
- 特征预处理:插补、缩放和构建新特征
- 特征选择:降维
- 模型选择:评估许多机器学习模型
- 超参数调整:寻找最佳模型设置
这些步骤几乎有无数种组合方式，每个问题的最佳解决方案都会发生变化！设计机器学习管道可能是一个耗时且令人沮丧的过程，最终，你永远不会知道你开发的解决方案是否接近最优。 Auto-ml 可以帮助评估数以千计的可能管道，尝试为特定问题找到最佳(或接近最佳)的解决方案。
重要的是要记住，机器学习只是数据科学过程的一部分，自动化机器学习并不意味着取代数据科学家。相反，auto-ml 旨在解放数据科学家，使她能够从事过程中更有价值的方面，例如收集数据或解释模型。
有很多 auto-ml 工具——H20、 auto-sklearn 、Google Cloud AutoML——我们将重点介绍TPOT:Randy Olson 开发的基于树的管道优化工具。 TPOT(你的“数据科学助理”)使用遗传编程来寻找最佳的机器学习管道。
插曲:遗传编程
要使用 TPOT，其实并不需要知道遗传编程的细节，所以可以跳过这一节。对于那些好奇的人来说，在高层次上，用于机器学习的遗传编程工作如下:
- 从随机生成的机器学习管道的初始群体开始，比如说 100 个，每个管道都由用于特征预处理、模型选择和超参数调整的功能组成。
- 训练这些管道中的每一个(称为个体),并使用交叉验证对性能指标进行评估。交叉验证表现代表了个体的“适合度”。群体的每次训练称为一代。
- 经过一轮训练——第一代——通过繁殖、变异和交叉产生第二代 100 个个体。复制意味着在管道中保持相同的步骤，以与适应度分数成比例的概率进行选择。突变是指个体从一代到下一代在内的随机变化**。交叉是从一代到下一代的个体之间的随机变化。这三种策略合在一起将产生 100 个新的管道，每个都略有不同，但根据适应度函数最有效的步骤更有可能被保留。**
- 重复这个过程适当的世代数，每次通过繁殖、突变和交叉产生新的个体。
- 优化结束时，选择性能最佳的单个管道。
(关于基因编程的更多细节，请看这篇的短文。)
遗传编程对于构建机器学习模型的主要好处是探索。由于有限的知识和想象力，即使没有时间限制的人也不能尝试预处理、模型和超参数的所有组合。遗传编程没有显示出对任何特定的机器学习步骤序列的初始偏好，并且随着每一代，新的流水线被评估。此外，适应度函数意味着搜索空间中最有希望的区域比性能较差的区域被更彻底地探索。
把它放在一起:云上的自动机器学习
有了背景，我们现在可以在 Google Colab 笔记本中使用 TPOT 来自动设计机器学习管道。(跟着笔记本一起这里)。
我们的任务是一个监督回归问题:给定纽约市能源数据，我们想要预测一栋建筑的能源之星得分。在之前的一系列文章中(第一部分、第二部分、第三部分、GitHub 上的代码)，我们为这个问题构建了一个完整的机器学习解决方案。使用手动特征工程、降维、模型选择和超参数调整，我们设计了一个梯度推进回归器模型，在测试集上实现了 9.06 分的平均绝对误差(从 1 到 100 分)。
该数据包含几十个连续的数字变量(如能源使用和建筑面积)和两个一次性编码的分类变量(区和建筑类型),共有 82 个要素。
Raw data features
score是回归的目标。所有缺失的值都被编码为np.nan，并且没有对数据进行任何特征预处理。
首先，我们需要确保 TPOT 安装在 Google Colab 环境中。大多数数据科学包已经安装，但是我们可以使用系统命令(前面有一个！在 Jupyter):
!pip install TPOT
在读入数据后，我们通常会填充缺失值(插补)并将特征标准化为一个范围(缩放)。然而，除了特征工程、模型选择和超参数调整，TPOT 将自动估算缺失值并进行特征缩放！因此，我们的下一步是创建 TPOT 优化器:
TPOT 优化器的默认参数将评估 100 组管道，每组 100 代，总共 10，000 条管道。使用 10 重交叉验证，这代表 100，000 次训练运行！即使我们使用谷歌的资源，我们也没有无限的时间进行培训。为了避免在 Colab 服务器上耗尽时间(我们最多获得 12 小时的连续运行时间)，我们将评估时间设置为最多 8 小时(480 分钟)。 TPOT 被设计为运行几天，但是我们仍然可以从几个小时的优化中获得好的结果。
我们在对优化器的调用中设置了以下参数:
scoring = neg_mean_absolute error:我们的回归性能指标max_time_minutes = 480:评估时间限制为 8 小时n_jobs = -1:使用机器上所有可用的内核verbosity = 2:训练时显示有限的信息cv = 5:使用五重交叉验证(默认为 10)
还有其他参数控制着遗传编程方法的细节，但是在大多数情况下，将它们保留为缺省值就可以了。(如果您想使用参数，请查看文档。)
TPOT 优化器的语法被设计成与 Scikit-Learn 模型的语法相同，因此我们可以使用.fit方法训练优化器。
# Fit the tpot optimizer on the training data
tpot.fit(training_features, training_targets)
在培训过程中，我们会显示一些信息:
由于时间限制，我们的模型只能通过 15 代。对于 100 个群体，这仍然代表了被评估的 1500 个不同的单独管道，比我们手动尝试的要多得多！
一旦模型训练完毕，我们就可以使用tpot.fitted_pipeline_看到最佳的管道。我们还可以将模型保存到 Python 脚本中:
# Export the pipeline as a python script file
tpot.export('tpot_exported_pipeline.py')
由于我们是在 Google Colab 笔记本中，要从服务器将管道连接到本地机器，我们必须使用 Google Colab 库:
# Import file management
from google.colab import file# Download the pipeline for local use
files.download('tpot_exported_pipeline.py')
然后我们可以打开文件(此处可用和)并查看完成的管道:
我们看到优化器为我们估算了缺失的值，并构建了一个完整的模型管道！最后一个估计器是一个堆叠模型，这意味着它使用两个机器学习算法([LassoLarsCV](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LassoLarsCV.html)和[GradientBoostingRegressor](http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html))，其中第二个是根据第一个的预测进行训练的(如果你再次运行笔记本，你可能会得到一个不同的模型，因为优化过程是随机的)。这是一个复杂的方法，我自己可能无法开发！
现在，关键时刻到了:测试设备的性能。为了找到平均绝对误差，我们可以使用.score方法:
# Evaluate the final model
print(tpot.score(testing_features, testing_targets))**8.642**
在我们手动开发解决方案的系列文章中，经过数小时的开发，我们构建了一个梯度推进回归器模型，其平均绝对误差为 9.06。随着开发时间的大幅减少，自动机器学习在性能上有了显著的提高。
从这里开始，我们可以使用优化的管道并尝试进一步完善解决方案，或者我们可以继续进行数据科学管道的其他重要阶段。如果我们使用这个作为我们的最终模型，我们可以尝试并解释这个模型(比如通过使用LIME:Local Interpretable Model-Agnostic explaining)或者写一个文档化的报告。
结论
在这篇文章中，我们简要介绍了云和自动化机器学习的能力。只需一个谷歌账户和互联网连接，我们就可以使用谷歌实验室来开发、运行和共享机器学习或数据科学工作负载。使用 TPOT，我们可以通过特征预处理、模型选择和超参数调整来自动开发优化的机器学习管道。此外，我们看到 auto-ml 不会取代数据科学家，但它将允许她在工作流程中更高价值的部分花费更多的时间。
虽然作为早期采用者并不总是有回报，但在这种情况下，TPOT 足够成熟，易于使用，相对来说没有问题，但也足够新，学习它会让你走在曲线的前面。考虑到这一点，找到一个机器学习问题(也许通过 Kaggle )并尝试解决它！在 Google Colab 的笔记本上运行自动机器学习感觉就像是未来，进入门槛如此之低，这是开始的最佳时机！
一如既往，我欢迎反馈和讨论，可以通过 Twitter @koehrsen_will 联系。
使用上下文语义搜索的自动化调查处理
随着深度学习的最新进展，算法分析文本的能力有了很大提高。现在，分析数字和社交媒体不仅限于基本的情感分析和基于计数的指标。创造性地使用先进的人工智能技术可以成为进行深入研究的有效工具。我们认为，根据以下线索对客户关于某个品牌的对话进行分类非常重要:
- 顾客关心的品牌产品和服务的关键方面。
- 用户对这些方面的潜在意图和反应。
这些基本概念结合使用时，会成为一个非常重要的工具，用于以人类水平的准确性分析数百万次品牌对话。在这篇文章中，我们以优步为例，展示这是如何运作的。请继续阅读！
文本分类器——基本构件
1。情绪分析
情感分析是最常见的文本分类工具，它分析收到的消息，并判断潜在的情感是积极的、消极的还是中性的。你可以输入一个你选择的句子，并通过这里的演示来判断潜在的情绪。
情感分析
情感分析可以从任何文本数据中准确地检测出情感。人们在社交媒体、博客和论坛上表达他们的观点、反馈和评论。营销人员和客户支持人员可以利用情绪检测的能力来读取和分析文本数据附带的情绪。我们的情绪分析分类器是在我们专有的数据集上训练的，它可以告诉我们信息背后的潜在情绪是:快乐、悲伤、愤怒、恐惧、兴奋、有趣还是讽刺。
意图分析
意图分析通过分析信息背后的用户意图，并识别它是否与意见、新闻、营销、投诉、建议、赞赏或疑问相关，来加强游戏。
Analyzing intent of textual data
上下文语义搜索(CSS)
现在，事情变得非常有趣了。为了获得可行的见解，了解用户讨论的是品牌的哪个方面是很重要的。例如，Amazon 想要分离与延迟交付、账单问题、促销相关查询、产品评论等相关的消息。但是怎样才能做到呢？
我们引入了一种智能的智能搜索算法，称为上下文语义搜索(又名 CSS) 。CSS 的工作方式是，它将数千条消息和一个概念(如价格)作为输入，并过滤所有与给定概念紧密匹配的消息。下图展示了 CSS 如何代表了对业界使用的现有方法的重大改进。
过滤所有与价格相关的消息的传统方法是对价格和其他密切相关的词进行关键字搜索，如(定价、收费、$、已付)。然而，这种方法不是很有效，因为几乎不可能想到所有相关的关键字及其代表特定概念的变体。另一方面，CSS 只是将概念的名称( Price )作为输入，并过滤所有上下文相似的内容，即使没有提到概念关键字的明显变体。
对于好奇的人，我们想让他们看一下这是如何工作的。人工智能技术用于将每个单词转换为超空间中的特定点，这些点之间的距离用于识别上下文与我们正在探索的概念相似的消息。下面可以看到引擎盖下的可视化效果:
Visualizing contextually related Tweets
现在来看看 CSS 的作用以及它是如何处理下面的文本数据的:
该算法将消息分类为与称为 P rice 的概念上下文相关，即使消息中没有提到单词 Price 。
优步:深潜分析
我们分析了数字媒体上关于几个产品主题的在线对话:取消、支付、价格、安全和服务。
为了广泛覆盖数据来源，我们从优步官方脸书页面上的最新评论、提到优步的推文以及优步的最新新闻文章中获取数据。以下是所有渠道的数据点分布:
- 脸书:34173评论
- 推特:21603 条推特
- 新闻:第 4245 篇
分析用户对话的情感可以让你对整体品牌认知有所了解。但是，为了更深入地挖掘，借助上下文语义搜索进一步对数据进行分类是很重要的。
我们在同一个数据集上运行了上下文语义搜索算法，将上述类别纳入一个帐户(取消、支付、价格、安全和服务)。
脸谱网
情绪分析
Breakdown of Sentiment for Categories
值得注意的是，除了一个类别，所有类别的评论都有负面情绪。与价格相关的正面评论数量已经超过负面评论。为了更深入地挖掘，我们分析了这些评论的意图。脸书作为一个社交平台，评论是拥挤的随机内容、新闻分享、营销和推广内容以及垃圾邮件/垃圾/无关内容。看看脸书评论上的意图分析:
Intent analysis of Facebook comments
因此，我们删除了所有这些不相关的意图类别，并重现了结果:
Filtered Sentiment Analysis
对每个类别的看法都有明显的变化。尤其是在价格相关评论中，正面评论的数量从 46%下降到了 29%。
推特
情感分析
对抓取的推文也做了类似的分析。在最初的分析中，与支付和安全相关的推文让人喜忧参半。
Category wise sentiment analysis
为了了解真实的用户意见、投诉和建议，我们必须再次过滤不相关的推文(垃圾邮件、垃圾信息、营销、新闻和随机消息):
Filtered sentiment
与付款相关的推文数量明显减少。此外，针对类别安全(以及相关关键词)的正面推文数量大幅下降。)
像优步这样的品牌可以依靠这种洞察力，并针对最关键的话题采取行动。例如，服务相关推文的正面推文比例最低，负面推文比例最高。因此，优步可以分析这些推文，并根据它们采取行动，以提高服务质量。
新闻ˌ消息
Sentiment Analysis for News Headlines
可以理解的是，安全一直是新闻中谈论最多的话题。有趣的是，新闻情绪总体上是积极的，在每个类别中也是如此。
我们也根据新闻的受欢迎程度进行分类。流行度得分归因于文章在不同社交媒体渠道上的分享计数。以下是热门新闻文章列表:
- 优步首席执行官遭批评后将离开特朗普顾问委员会
- #DeleteUber:用户对特朗普穆斯林禁令废 app 感到愤怒
- 优步员工也讨厌他们自己的企业文化
- 每次我们获得优步奖，我们都在传播它的社会毒素
- 司机在抗议和罢工期间前往 JFK 机场后，愤怒的消费者删除了优步的应用程序
结论
随着技术的进步，从社交媒体数据中获得有意义见解的时代已经到来。优步的案例研究让你一瞥上下文语义搜索的威力。您的组织是时候超越总体情绪和基于计数的指标了。公司最近一直在利用数据的力量，但要获得最深层的信息，你必须利用人工智能、深度学习和智能分类器(如上下文语义搜索)的力量。
您还可以使用我们的 Excel 插件来分析调查，而无需编写任何代码。你可以从这里下载插件。
我们希望你喜欢这篇文章。请注册一个免费的 ParallelDots 账户，开始你的 AI 之旅。你也可以在这里查看 PrallelDots AI API的演示。
此处阅读原文。
使用机器学习的自动文本分类
Image credits: Moosend
数字化改变了我们处理和分析信息的方式。在线信息的可用性呈指数级增长。从网页到电子邮件，科学期刊、电子书、学习内容、新闻和社交媒体都充满了文本数据。其理念是快速创建、分析和报告信息。这是自动文本分类逐步升级的时候。
文本分类是将文本智能分类成类别。而且，使用机器学习来自动化这些任务，只会使整个过程超级快速和高效。人工智能和机器学习可以说是最近获得动力的最有益的技术。他们到处都能找到应用。正如杰夫·贝索斯在年度股东信中所说，
在过去的几十年里，计算机已经广泛地自动化了程序员可以用清晰的规则和算法描述的任务。现代机器学习技术现在允许我们在描述精确规则更加困难的任务中做同样的事情。
–杰夫·贝索斯
特别谈到自动文本分类，我们已经写了它背后的技术和它的应用。我们正在更新我们的文本分类器。在本帖中，我们将讨论与我们的自动文本分类 API 相关的技术、应用、定制和分段。
文本数据的意图、情感和情感分析是文本分类的一些最重要的部分。这些用例在机器智能爱好者中引起了巨大的反响。我们为每个类别开发了单独的分类器，因为它们的研究本身就是一个巨大的课题。文本分类器可以对各种文本数据集进行操作。您可以使用标记数据训练分类器，也可以对原始的非结构化文本进行操作。这两个类别本身都有许多应用。
监督文本分类
定义分类类别后，文本的监督分类就完成了。它的工作原理是训练和测试。我们将标记的数据提供给机器学习算法进行处理。该算法在标记的数据集上训练，并给出期望的输出(预定义的类别)。在测试阶段，算法被输入未观察到的数据，并根据训练阶段将它们分类。
电子邮件的垃圾邮件过滤是监督分类的一个例子。收到的电子邮件会根据其内容自动分类。语言检测、意图、情感和情绪分析都基于监督系统。它可以用于特殊的用例，例如通过分析数百万条在线信息来识别紧急情况。这是大海捞针的问题。我们提出了智能公共交通系统来识别这些情况。为了在数以百万计的在线对话中识别紧急情况，必须以高精度训练分类器。它需要特殊的损失函数，在训练时进行采样，以及建立一个多分类器堆栈等方法来解决这个问题，每个分类器都细化前一个分类器的结果。
监督分类基本上就是让计算机模仿人类。给定算法一组标记/分类的文本(也称为训练集)，基于这些文本，它们生成 AI 模型，当进一步给定新的未标记文本时，这些模型可以自动对它们进行分类。我们的几个API，是用监督系统开发的。文本分类器目前被训练用于一组通用的 150 个类别。
无监督文本分类
无监督分类是在不提供外部信息的情况下完成的。在这里，算法试图发现数据中的自然结构。请注意，自然结构可能不完全是人类认为的逻辑划分。该算法在数据点中寻找相似的模式和结构，并将它们分组到聚类中。数据的分类是基于形成的聚类来完成的。以网络搜索为例。该算法基于搜索词进行聚类，并将它们作为结果呈现给用户。
每个数据点都嵌入到超空间中，你可以在 TensorBoard 上看到它们。下图基于我们对印度电信公司 Reliance Jio 的 twitter 研究。
进行数据探索是为了基于文本相似性找到相似的数据点。这些相似的数据点形成了最近邻的聚类。下图显示了推文*“99 卢比的 reliance jio prime 会员资格:以下是如何获得 100 卢比返现……”的最近邻居*。
如你所见，附带的推文与标注的类似。这个集群是相似推文的一个类别。在从文本数据中获得洞察力时，无监督分类非常方便。它是高度可定制的，因为不需要标记。它可以对任何文本数据进行操作，而无需对其进行训练和标记。因此，无监督分类是语言不可知的。
自定义文本分类
很多时候，使用机器学习的最大障碍是数据集的不可用性。有许多人想用人工智能对数据进行分类，但这需要制作一个数据集，这就产生了类似于鸡生蛋还是鸡生蛋的问题。自定义文本分类是在没有任何数据集的情况下构建自己的文本分类器的最佳方式之一。
在 ParallelDots 的最新研究工作中，我们提出了一种在文本上进行零射击学习的方法，其中一种经过训练的算法可以在大型嘈杂的数据集上学习句子及其类别之间的关系，从而推广到新的类别甚至新的数据集。我们称这种模式为“一次训练，随处测试”。我们还提出了多种神经网络算法，可以利用这种训练方法并在不同的数据集上获得良好的结果。对于学习关系的任务，最好的方法是使用 LSTM 模型。这个想法是，如果一个人可以在句子和类之间建立“隶属”的概念模型，这些知识对于看不见的类甚至看不见的数据集都是有用的。
如何构建自定义文本分类器？
要构建你自己的定制文本分类器，你需要首先注册一个 ParallelDots 账户，然后登录到你的仪表盘。
您可以通过单击仪表板中的“+”图标来创建您的第一个分类器。接下来，定义一些您想要对数据进行分类的类别。请注意，为了获得最佳结果，请保持您的类别互斥。
您可以通过分析文本样本来检查分类的准确性，并在发布之前尽可能调整您的类别列表。一旦发布了类别，您将获得一个应用程序 id，它将允许您使用定制的分类器 API。
考虑到数据标记和准备可能是一个限制，自定义分类器可以是一个很好的工具来建立一个文本分类器，而不需要太多的投资。我们还相信，这将降低构建实用的机器学习模型的门槛，这些模型可以应用于各个行业，解决各种各样的用例。
作为一个人工智能研究小组，我们正在不断开发前沿技术，以使流程更简单、更快速。文本分类就是这样一种在未来有巨大潜力的技术。随着越来越多的信息被倾倒在互联网上，由智能机器算法来轻松地分析和表示这些信息。机器智能的未来无疑是令人兴奋的，订阅我们的时事通讯，在你的收件箱里获得更多这样的信息。
parallel dots AI API，是由 ParallelDots Inc 提供的深度学习支持的 web 服务，可以理解大量的非结构化文本和视觉内容，为您的产品提供支持。你可以查看我们的一些文本分析API并通过填写此处的表格联系我们或者给我们 apis@paralleldots.com 写信。
自动数据收集
Fetch some Data
提高图像识别模型性能的最佳方法之一是添加更多数据进行训练！向当前数据集即时添加更多数据的一些最流行的方法是尝试翻转图像，向图像添加一些噪点，或者添加颜色扭曲。一个有才华的机器学习工程师也可能尝试使用 GANs 向训练集添加数据。
然而，这只能到此为止，最终这些策略将会停滞不前，尤其是如果你只有 200 张图片的话。提高模型性能的最常见方法之一，尤其是在部署之后，是设置一个自动数据管道。
下面是本文中介绍的自动数据收集策略:
Classify new instance
If model_Output == .995 || model_Output == .005
save new instance to train data and label accordingly
我们最终可以加速这一过程，使模型在遇到新实例时显著增加数据集的大小。
然而，另一件需要担心的事情是最终的数据集大小。如果每次有人使用你的应用程序时你都保存 100 张新图片，你可能会得到一个巨大的数据集。根据您的数据存储环境和成本，这可能会有问题。出于这个原因，最好也将您的自动数据管道参数化，使其在收集到某个变量 X GBs 时停止。
此外，一旦有了更大的数据集，您可能会发现需要向模型中添加图层来学习更复杂的分类函数。
当然，这种策略可以扩展到图像识别领域之外的模型，但是，例如，如果您正在处理 csv 数据的记录，您可能不必考虑最大数据存储。
感谢阅读！希望这有助于您思考您的数据收集自动化过程。这真的会节省你很多时间，从长远来看会有巨大的回报！
CShorten
Connor Shorten 是佛罗里达大西洋大学计算机科学专业的学生。对数据科学、深度学习和软件工程感兴趣。主要用 Python，JavaScript，C++编码。请关注更多关于这些主题的文章。
使用深度学习和贝叶斯推理的自动特征工程
计算机视觉和综合金融交易数据的应用
我们将探索深度学习和贝叶斯推理在自动特征工程中的应用，特别是自动编码器。这个想法是从潜在的有噪声的原始数据中自动学习一组特征，这些数据在监督学习任务中是有用的，例如在计算机视觉和保险中。以这种方式，我们通过自动学习一组特征，即表示学习，避免了手工制作的特征工程的手动过程，这可以帮助解决某些任务，例如图像识别和保险损失风险预测。
计算机视觉
为此，我们将使用 MNIST 数据集，其中原始数据是每个图像的像素强度的二维张量。图像是我们的分析单位:我们将预测每个图像的每个类别的概率。这是一个多类分类任务，我们将使用准确度分数来评估模型在测试折叠中的性能。
2 dimensional tensor of pixel intensities per image.
计算机视觉任务的手工特征工程的一些例子可能使用 Gabor 滤波器。
保险
我们将使用合成数据集，其中原始数据是每个保单期组合的历史保单级别信息的二维张量:每个单位将是一个 4x 3 维张量，即 4 个历史时间段和 3 种交易类型。保单-期间组合是我们的分析单位:我们将预测未来期间 5 的损失概率—将此视为保单的潜在续保，我们需要预测它是否会为我们带来损失，从而影响我们是否决定续保和/或调整续保保费以考虑额外风险。这是一个二元类分类任务，我们将使用 AUROC 分数来评估模型性能。
2 dimensional tensor of transaction values per policy-period combination.
保险任务的手工特征工程的一些例子可能使用列或行平均值。
合成保险金融交易数据集是用 r 编写的，其余的工作都是用 Python 完成的。
请注意计算机视觉任务的原始数据和保险任务的原始数据之间的相似之处。我们在这里的主要目标是通过深度学习和贝叶斯推理，使用自动特征工程来学习这种原始数据的良好表示。
Scikit-learn、Keras 和 TensorFlow
我们将使用 Python 机器学习库 scikit-learn 进行数据转换和分类任务。请注意，我们将自动编码器编码为 scikit-learn 转换器，以便 scikit-learn 管道可以随时使用它们。深度学习者将使用 Keras 和 TensorFlow 后端进行编码。我们还在 MacBook Pro 上使用了外部 GPU，即 GTX 1070。
MNIST:没有自动编码器
我们在不使用自动编码器的情况下运行 MNIST 数据集。MNIST 图像的每个图像的像素强度的 2 维张量是 28 乘 28 的维度。我们将它们重塑为每个图像 784 维的 1 维张量。因此，对于每幅图像的监督学习任务，我们有 784 个特征。
结果
没有自动编码器的 MNIST 分类任务的准确度分数: 92.000000% 。
MNIST:认证机构
我们使用主成分分析过滤器，挑选出能够解释 99%变异的成分数量。
结果
使用主成分分析的 MNIST 分类任务的正确率得分: 91.430000% 。
MNIST:普通自动编码器
自动编码器是一种无监督学习技术，其目标是学习一组可用于重构输入数据的特征。
我们的输入数据是 X 。编码器功能 E 将其映射到一组 K 特征。解码器功能 D 使用一组 K 特征来重构输入数据。
让我们将重建的数据表示如下。
目标是学习编码和解码功能，使输入数据和重构数据之间的差异最小化。这个任务的目标函数的一个例子可以是均方误差(MSE)。
我们通过使用定义编码和解码函数的参数最小化 MSE 来学习编码和解码函数:使用链式法则(即反向传播)来计算 MSE 相对于参数的梯度，并将其用于通过诸如随机梯度下降(SGD)的优化算法来更新参数。
假设我们有一个单层自动编码器，它使用指数线性单元(ELU)激活函数、批量归一化、丢失和自适应矩(Adam)优化算法。 B 是批量， K 是特性数。
- **指数线性单元:**激活函数处处平滑，避免了输入为负时输出呈现负值的消失梯度问题。
- **批量标准化:**这个想法是把输入转换成一个隐藏层的激活函数。我们首先在每个特征的基础上使用均值和方差参数进行标准化或规范化，然后在转换数据的每个特征的基础上学习一组缩放和移动参数。下面的等式简洁地描述了这一层。
- **丢弃:**这种正则化技术简单地以一定的概率(比如 50%)丢弃来自输入和隐藏单元的输出。
- **Adam 优化算法:**这种自适应算法结合了 Momentum 和 RMSProp 优化算法的思想。目标是对过去的梯度有一些记忆，这可以指导将来的参数更新。下面的算法方程简明地描述了这种方法。
结果
使用自动编码器的 MNIST 分类任务的准确度分数: 96.940000% 。
MNIST:去噪自动编码器
这里的想法是向数据添加一些噪声，并尝试学习一组稳健的特征，这些特征可以从有噪声的数据中重建无噪声的数据。MSE 目标函数如下。
结果
使用去噪自动编码器的 MNIST 分类任务的准确度分数: 96.930000% 。
MNIST:一维卷积自动编码器
到目前为止，我们使用的是扁平化或整形的原始数据。每个图像的像素强度的这种 1 维张量可能没有考虑 2 维张量可能包含的有用的空间特征。为了克服这个问题，我们引入卷积滤波器的概念，首先考虑它们的一维版本，然后考虑它们的二维版本。
卷积滤波器背后的思想与手工特征工程密切相关:人们可以将手工特征简单地视为预定义卷积滤波器的结果，即没有基于手边的原始数据学习的卷积滤波器。
假设我们有每个分析单位的原始交易数据，即抵押贷款，这可能有助于我们将一个单位分类为违约或未违约。我们将保持这个例子简单，只允许交易值为$100 或$0。每单位的原始数据跨越 5 个时间段，而默认标签用于下一个时间段，即时间段 6。以下是一个特定单位的原始数据示例:
进一步假设，如果平均交易价值为 20 美元，那么我们将在第 6 期看到该特定抵押贷款单位的违约。除此之外，我们不会看到第 6 期出现违约。平均交易价值是手工制作的特征的一个例子:预先定义的手工制作的特征，没有以任何方式学习。它是通过信贷风险领域的知识得出的。将其表示为 H(x) 。
学习这种特征的想法是一维卷积滤波器的一个例子。如下所示:
假设 H(x) 是该监督学习任务的原始数据的正确表示，则通过用于上述定义的卷积滤波器的监督学习，或者可能是无监督学习，然后被转移到监督学习任务，即转移学习，学习的最佳参数集是[0.2，0.2，0.2，0.2，0.2]:
这是一个简单的例子，但是这清楚地说明了使用深度学习进行自动特征工程或表示学习背后的原理。以无监督的方式学习这种表示的主要好处之一是，相同的表示可以用于多个监督学习任务:迁移学习。这是从原始数据中学习表示的一种原则性方式。
总结一下，对于我们的简单示例，一维卷积滤波器定义为:
- x 为输入。
- 𝛼是内核。
- 输出 x * 𝛼被称为特征图，而*是卷积算子或滤波器。这是普通神经网络和卷积神经网络之间的主要区别:我们用卷积算子代替矩阵乘法算子。
- 根据手头的任务，我们可以有不同类型的卷积滤波器。
- 内核大小可以改变。在我们的例子中，内核大小是 5。
- 步幅大小可以改变。在我们的示例中，我们没有步长大小，但是假设步长大小为 1，内核大小为 2，即𝛼 = [𝛼 ，𝛼 ]，那么我们将在输入开始时应用内核𝛼，即[ x ， x ] * [𝛼 ，𝛼 ]，并将内核移动到输入的下一个区域，即[ x]【𝛼、𝛼 ]等等，直到我们得到由 4 个实数值组成的特征图。 这被称为有效卷积，而填充卷积，也就是说用零值填充卷积，将给出与输入大小相同的特征映射，即，在我们的例子中是 5 个实值。*
- 我们可以将激活函数应用于特征地图，例如前面提到的 ELU。
- 最后，我们可以通过在特征图的定义部分取最大值或平均值来总结特征图中包含的信息。例如，如果在使用有效卷积后，我们得到大小为 4 的特征图，然后应用大小为 4 的最大汇集操作，那么我们将取该特征图的最大值。结果是另一个特征图。
这自动化了特征工程，但是引入了架构工程，其中由各种卷积滤波器、激活函数、批量标准化层、丢弃层和汇集操作符组成的不同架构可以在流水线中堆叠在一起，以便学习原始数据的良好表示。人们通常创建这样的体系结构的集合。
卷积自动编码器的目标是使用卷积滤波器、激活函数、批量标准化层、丢弃层和汇集运算符来创建一个编码器函数，它将学习我们原始数据的良好表示。解码器还将使用与编码器类似的一组层来重建原始数据，但有一个例外:它将使用上采样运算符，而不是使用池运算符。上采样操作符背后的基本思想是将一个元素重复一定的次数，比如大小为 4:可以将其视为池操作符的逆操作符。池操作符本质上是一个下采样操作符，而上采样操作符在某种意义上只是它的逆操作。
结果
使用一维卷积自动编码器的 MNIST 分类任务的准确度分数: 97.570000% 。
MNIST:序列到序列自动编码器
鉴于我们的抵押贷款违约例子，一个潜在的更有用的深度学习架构可能是递归神经网络(RNN)，特别是他们的最先进的变体长期短期记忆(LSTM)网络。目标是明确考虑原始数据的顺序性质。
RNN 中的梯度取决于为模型定义的参数矩阵。简单地说，这些参数矩阵可能会被多次相乘，从而导致学习的两个主要问题:爆炸和消失梯度。如果参数矩阵的谱半径，即矩阵特征值的最大绝对值，大于 1，那么梯度可能变得足够大，即值爆炸，使得学习发散，并且类似地，如果谱半径小于 1，那么梯度可能变小，即值消失，使得参数的下一个最佳转变不能被可靠地计算。梯度的适当计算对于估计定义机器学习方法的最佳参数集是重要的，并且 LSTM 网络在普通 RNN 中克服了这些问题。我们现在将 LSTM 网络定义为 1 个时间步长，即 1 个存储单元。
我们计算输入门的值，在时间段 t 的存储单元状态的值，其中 f(x) 是某个激活函数，以及遗忘门的值:
遗忘门控制 LSTM 记忆的量，即在时间段 t-1 的存储单元状态的值，其中⨂是哈达玛乘积:
利用存储单元的更新状态，我们计算输出门的值，并最终计算输出值本身:
我们可以有各种各样的 LSTM 架构，例如卷积 LSTM，注意，我们用卷积运算符替换输入门、存储单元状态的初始估计、遗忘门和输出门中的矩阵乘法运算符:*
另一个流行的变体是窥视孔 LSTM，其中允许门窥视存储单元的状态:
序列到序列自动编码器的目标是使用 LSTM 作为编码器来创建原始数据的表示。这种表示将是从原始数据向量序列中学习的向量序列。表示的最后一个向量是我们的编码表示，也称为上下文向量。该上下文向量被重复与序列长度一样多的次数，使得它可以被用作解码器的输入，该解码器又是另一个 LSTM。解码器 LSTM 将使用该上下文向量来重建原始数据向量序列。如果上下文向量在重建任务中有用，那么它可以进一步用于其他任务，如预测违约风险，如我们的示例中所给出的。
结果
使用序列对序列自动编码器的 MNIST 分类任务的准确度分数: 97.600000% 。
MNIST:可变自动编码器
我们现在通过使用变分推理来训练自动编码器，从而将贝叶斯推理与深度学习相结合。这使我们转向了生成模型，它可以在半监督学习中有进一步的用例。使用贝叶斯推理进行训练的另一个好处是，我们可以对更高能力的深度学习者更加鲁棒。
- 假设 X 是我们的原始数据，而 Z 是我们学习过的表示。
- 我们对学习到的表征有一个先验的信念:
- 我们学习到的表征的后验分布是:
- 边际可能性 p(X) 通常是难以处理的，导致后验分布 p(Z|X) 难以处理:
- 因此，我们需要一个近似的后验分布，通过变分推理，可以处理棘手的问题。这另外还提供了处理大规模数据集的好处，因为通常马尔可夫链蒙特卡罗(MCMC)方法不太适合大规模数据集。人们也可以考虑拉普拉斯近似来近似后验分布，但是我们将坚持变分推理，因为与拉普拉斯近似相比，它允许更丰富的近似集。拉普拉斯近似简单地等同于找到增强似然优化的最大后验(MAP)估计，在 MAP 估计处取 Hessian 逆的负值以估计方差-协方差矩阵，并且最后使用具有多变量高斯分布或一些其他适当的多变量分布的方差-协方差矩阵。
- 假设我们的近似后验分布，也是我们的概率编码器，给出如下:
- 我们的概率解码器由下式给出:
- 给定以上关于编码器和解码器的设置，现在让我们写下优化问题:
- 请注意，KL 背离是非负的，因此这使得 ELBO 成为边际可能性的下限:
- 因此，我们可以改变优化问题，只关注 ELBO:
- 上述积分问题可以通过蒙特卡罗积分来解决，因为正则化项不是难以处理的。假设概率编码器是具有对角方差-协方差矩阵的多元高斯，我们使用重新参数化技巧从该分布中采样，比如说 M 次，以便计算 ELBO 优化问题中的期望项。这种特殊情况下的重新参数化技巧相当于从标准高斯分布中采样 M 次，将样本乘以𝞼并将 μ 加到样本上。
- μ 是我们用于原始数据重建的学习表示。如果学习到的表征是有用的，那么它也可以用于其他任务。
- 这是一种将贝叶斯推理与深度学习相结合的强大方式。以这种方式使用的变分推理可以应用于各种深度学习架构，并且与生成对抗网络(GAN)有进一步的联系。我们在另一篇论文中探讨了对抗性学习在表征学习中的应用。
结果
使用可变自动编码器的 MNIST 分类任务的准确度分数: 96.520000% 。
MNIST:二维卷积自动编码器
对于 2 维卷积滤波器，其思想与 1 维卷积滤波器相似。我们将坚持我们前面提到的银行例子来说明这一点。
在原始交易数据的二维张量中，现在我们有 5 个历史时间段，即行，和 3 个不同的交易类型，即列。我们将使用大小为 2 乘 3 的核从原始数据中提取有用的特征。选择这样一个内核意味着我们有兴趣找到一个跨越所有 3 种事务类型和 2 个历史时间段的特性图。我们将使用步长 1 和有效的卷积来提取原始数据的不同片上的特征。下面将说明这一点。
这些原理和思想适用于 2 维卷积滤波器，因为它们适用于 1 维卷积滤波器，这里我们不再重复。
结果
使用二维卷积自动编码器的 MNIST 分类任务的准确度分数: 98.860000% 。
保险:没有自动编码器
我们现在开始运行保险模型，没有任何手工制作或基于深度学习的特征工程:只有原始数据。
结果
没有自动编码器的保险分类任务的 AUROC 分数: 92.206261% 。
保险:PCA
我们现在继续运行保险模型，没有任何手工或基于深度学习的特征工程，但是使用 PCA 过滤器来挑选解释 99%变化的组件数量。
结果
使用 PCA 的保险分类任务的 AUROC 分数: 91.128859% 。
保险:手工制作的功能
在这种情况下，我们创建了一些手工制作的特征，我们认为这些特征为保险模型的原始数据提供了有用的表示。
结果
具有手工特征的保险分类任务的 AUROC 分数: 93.610635% 。
保险:手工制作的功能和 PCA
我们使用前面提到的手工制作的特征和 PCA 过滤器，该过滤器挑选解释 99%的变化的组件的数量。
结果
具有手工特征和 PCA 的保险分类任务的 AUROC 分数: 93.160377% 。
保险:普通自动编码器
在这种情况下，我们使用普通的自动编码器来学习原始数据的良好表示，以便我们可以根据 AUROC 获得监督学习任务的提升。
结果
使用自动编码器的保险分类任务的 AUROC 分数: 93.932247% 。
保险:去噪自动编码器
在这种情况下，我们使用去噪自动编码器来学习原始数据的良好表示，从而我们可以根据 AUROC 获得监督学习任务的提升。
结果
使用去噪自动编码器的保险分类任务的 AUROC 分数: 93.712479% 。
保险:序列到序列自动编码器
在这种情况下，我们使用序列对自动编码器进行排序，考虑原始交易数据的时间序列性质，即序列性质，以学习原始数据的良好表示，从而我们可以获得监督学习任务在 AUROC 方面的提升。
结果
使用序列对序列自动编码器的保险分类任务的 AUROC 分数: 91.418310% 。
保险:一维卷积自动编码器
在这种情况下，我们使用 1 维卷积自动编码器来学习原始数据的良好表示，以便我们可以获得 AUROC 方面的提升，用于监督学习任务。
结果
使用一维卷积自动编码器的保险分类任务的 AUROC 分数: 91.509434% 。
保险:二维卷积自动编码器
在这种情况下，我们使用二维卷积自动编码器来学习原始数据的良好表示，以便我们可以获得 AUROC 方面的提升，用于监督学习任务。
结果
使用二维卷积自动编码器的保险分类任务的 AUROC 分数: 92.645798% 。
保险:可变自动编码器
在这种情况下，我们使用变分自动编码器来学习原始数据的良好表示，以便我们可以根据 AUROC 获得监督学习任务的提升。
结果
使用可变自动编码器的保险分类任务的 AUROC 分数: 90.871569% 。
MNIST 结果:准确性得分
正如所料，这里达到的最好成绩是由一个二维卷积自动编码器。
没有自动编码器: 92.000000% 。
主成分分析: 91.430000% 。
自动编码器: 96.940000% 。
去噪自动编码器: 96.930000% 。
1 维卷积自动编码器: 97.570000% 。
序列间自动编码器: 97.600000% 。
变分自动编码器: 96.520000% 。
2 维卷积自动编码器: 98.860000% 。
保险结果:AUROC 分数
在这项任务上取得的最好成绩是由一个普通的自动编码器。这突出了通过深度学习实现特征工程的自动化:我相信伊恩·古德费勒说过，学习的表示比手工制作的表示更好。
请注意，序列到序列和卷积自动编码器在这项任务中表现不佳，仅仅是因为我生成合成事务数据的方式:如果数据来自更适合序列到序列或卷积自动编码器的过程，这些架构很可能会表现得更好。
不带自动编码器: 92.206261% 。
主成分分析: 91.128859% 。
手工特色: 93.610635% 。
手工特征和主成分分析: 93.160377% 。
自动编码器: 93.932247% 。
去噪自动编码器: 93.712479% 。
序列到序列自动编码器: 91.418310% 。
1 维卷积自动编码器: 91.509434% 。
2 维卷积自动编码器: 92.645798% 。
变分自动编码器: 90.871569% 。
GitHub 上的代码
我为本文写的代码可以在我的 GitHub 上找到:https://github.com/hamaadshah/autoencoders_keras
结论
我们已经展示了如何使用深度学习和贝叶斯推理来学习原始数据的良好表示，即，每个分析单位的 1 或 2 维张量，其然后可能被用于计算机视觉和保险领域中的监督学习任务。这使我们从手工制作的特征工程转向自动特征工程，即表示学习。这确实引入了架构工程，然而，也可以通过使用遗传算法或强化学习来实现自动化——这可能是另一篇论文的主题。
最后，我想强调的是，用于解决计算机视觉任务的代码也用于解决保险任务。在这两项任务中，通过深度学习的自动特征工程具有最佳性能，尽管事实上我们并没有明确地寻找艺术架构的最佳状态。这为我们提供了一种端到端自动化机器学习任务的强大方法。
参考
- 古德费勒，我，本吉奥，y 和库维尔(2016)。深度学习(麻省理工出版社)。
- Geron，A. (2017)。使用 Scikit-Learn & tensor flow(O ’ Reilly)进行机器学习实践。
- 金玛博士和韦林博士(2014 年)。自动编码变分贝叶斯(https://arxiv.org/abs/1312.6114)。
- Hosseini，s .，Lee，S. H .和 Cho，N. I. (2018 年)。为增强卷积神经网络的性能输入手工制作的特征(【https://arxiv.org/abs/1801.07848】T2)。
- *【http://scikit-learn.org/stable/# *
- https://towards data science . com/learning-rate-schedules-and-adaptive-learning-rate-methods-for-deep-learning-2c8f 433990 D1
- https://stack overflow . com/questions/42177658/how-to-switch-back end-with-keras-from-tensor flow-to-the ano
- https://blog.keras.io/building-autoencoders-in-keras.html
- https://keras.io
- https://www . cs . Cornell . edu/courses/cs 1114/2013 sp/sections/S06 _ convolution . pdf
- http://deeplearning.net/tutorial/lstm.html
使用生成对抗网络的自动特征工程
计算机视觉和综合金融交易数据的应用
深度学习的目的是使用一系列可微分函数(即几何变换)来学习高维度和噪声数据的表示，这或许可以用于监督学习任务以及其他任务。它在判别模型中取得了巨大的成功，而生成模型可能由于显式最大似然估计(MLE)的局限性而表现不佳。生成对抗网络(GAN)中提出的对抗学习旨在通过使用隐式最大似然法来克服这些问题。
我们将使用 MNIST 计算机视觉数据集和一个合成的金融交易数据集来完成这些使用 GANs 的实验的保险任务。与显式 MLE 相比，GANs 是一种非常不同的学习方法。我们的目的是展示 GAN 学习的表示可以用于监督学习任务，如图像识别和保险损失风险预测。以这种方式，我们通过自动学习一组特征，即表示学习，来避免手工特征工程的手动过程。
这篇文章可以看作是这篇文章的后续:https://goo.gl/TjB2v3
生成对抗网络
GAN 有两个主要组件，生成器和鉴别器，它们相互竞争。这样，发生器学习如何从噪声中创建真实的合成样本，即潜在空间 z ，而鉴别器学习如何区分真实样本和合成样本。
由鉴别器学习的表示可以用于其他监督学习任务，即自动特征工程或表示学习。这也可以从迁移学习的角度来看。GAN 还可以用于半监督学习，我们将在另一篇论文中讨论这一点，我们将研究为此目的使用变分自动编码器、梯形网络和敌对自动编码器。
计算机视觉
为此，我们将使用 MNIST 数据集，其中原始数据是每个图像的像素强度的二维张量。图像是我们的分析单位:我们将预测每个图像的每个类别的概率。这是一个多类分类任务，我们将使用准确度分数来评估模型在测试折叠中的性能。
2 dimensional tensor of pixel intensities per image.
计算机视觉任务的手工特征工程的一些例子可能使用 Gabor 滤波器。
保险
我们将使用合成数据集，其中原始数据是每个保单期组合的历史保单级别信息的二维张量:每个单位将是一个 4x 3 维张量，即 4 个历史时间段和 3 种交易类型。保单-期间组合是我们的分析单位:我们将预测未来期间 5 的损失概率—将此视为保单的潜在续保，我们需要预测它是否会为我们带来损失，从而影响我们是否决定续保和/或调整续保保费以考虑额外风险。这是一个二元类分类任务，我们将使用 AUROC 分数来评估模型性能。
2 dimensional tensor of transaction values per policy-period combination.
保险任务的手工特征工程的一些例子可能使用列或行平均值。
合成保险金融交易数据集是用 r 编写的，其余的工作都是用 Python 完成的。
请注意计算机视觉任务的原始数据和保险任务的原始数据之间的相似之处。我们的主要目标是通过 GANs 使用自动特征工程来学习这种原始数据的良好表示。
Scikit-learn、Keras 和 TensorFlow
我们将使用 Python 机器学习库 scikit-learn 进行数据转换和分类任务。我们将把 gan 编码为 scikit-learn 转换器，这样它们就可以很容易地被 scikit-learn 管道使用。gan 将使用 Keras 和 TensorFlow 后端进行编码。我们还在 MacBook Pro 上使用了外部 GPU，即 GTX 1070。
发电机
假设我们有一个关于潜在空间 z 在哪里的先验信念: p(z) 。给定一个来自这个潜在空间的抽取，生成器 G ，一个深度学习器，输出一个合成样本。
鉴别器
鉴别器 D 是另一个深度学习器，其目的是分类样本是真实的还是合成的，即样本是否来自真实数据分布，
或合成数据分布。
让我们将鉴别器 D 表示如下。
这里我们假设正例来自真实数据分布，而反例来自合成数据分布。
游戏:最优化
GAN 同时训练鉴别器以正确分类真实和合成示例，同时训练生成器以创建合成示例，使得鉴别器不正确地分类真实和合成示例。这个 2 人迷你最大游戏有以下目标函数。
请注意，上面的表达式基本上是判别器的目标函数。
从游戏的设置中可以清楚地看到，我们试图为 D 获得一个解，使其最大化 V(D，G) ，同时我们试图为 G 获得一个解，使其最小化 V(D，G) 。
我们不会同时训练 D 和 T2 G。我们交替训练它们:先训练 D ，然后在冷冻 D 的同时训练 G 。我们重复这一固定数量的步骤。
如果从发生器 G 获取的合成样本是真实的，那么我们已经隐含地了解了合成数据分布。换句话说，合成数据分布可以被视为真实数据分布的良好估计。最佳解决方案如下。
为了说明这一点，让我们找出给定生成器 G 和样本 x 的最佳鉴别器。
让我们仔细看看样本 x 的鉴别器目标函数。
我们已经找到了给定一个生成器的最佳鉴别器。现在让我们关注生成器的目标函数，它本质上是最小化鉴别器的目标函数。
我们将注意到生成器的上述目标函数中的 kull back-lei bler(KL)发散。
回想一下λ发散的定义。
如果λ取值为 0.5，这就称为詹森-香农(JS)散度。这种发散是对称的和非负的。
记住这一点，让我们再来看看生成器的目标函数。
从上述生成器的目标函数中可以清楚地看到，获得的全局最小值是 - log (4) ，这在以下条件成立时发生。
当上述成立时，真实数据分布和合成数据分布之间的詹森-香农散度将为零。因此我们证明了最优解如下。
游戏:融合
假设允许鉴别器在给定发电机的情况下达到其最佳值，则
可以证明收敛到
考虑下面的目标函数，该函数之前已经被证明是关于
因为我们发现全局最小值 at -log(4)。
给定最佳鉴别器，生成器使用梯度下降向全局最小值移动。我们将证明给定一个最佳鉴别器，即，
使得以下各项的会聚
到
有保证。
注意，下面是凸函数集合的上确界，其中集合由鉴别器索引:
记住上确界是最小上界。
让我们回忆一下关于梯度和次梯度的一些定义。一个向量
是函数的次梯度
一点处
如果
以下关系成立:
如果 f 是凸可微的，那么它在点 x 的梯度也是次梯度。最重要的是，即使 f 不可微，次梯度也可以存在。
一组凸函数的上确界的次梯度包括函数在达到上确界的点处的次梯度。如前所述，我们已经表明
是凸的。
发生器的梯度
用于对生成器的目标函数进行增量改进
给定一个最优鉴别器 D* 。因此，趋同
到
有保证。
结果
在这些实验中，我们展示了生成器为 MNIST 数据集和保险数据集创建真实合成示例的能力。我们使用二维潜在流形。
最后，我们表明，使用由鉴别器学习的表示，我们可以获得与使用用于 MNIST 数据集和保险数据集的其他表示学习方法相竞争的结果，例如本文中所示的各种各样的自动编码器:【https://goo.gl/TjB2v3】T2
生成新数据
有了图像数据，我们或许可以定性地判断生成的数据是否有意义。对于金融交易数据，这是不可能的。然而，让我们来看一个生成的事务网格的例子。请注意，所有金融交易数据都已转换为介于 0 和 1 之间的值。
如果我们使用应用于图像数据的相同 matplotlib 代码来绘制上面生成的事务网格，我们将得到下面的图像。我们可以看到，对于一个事务，我们有可能的最大值，即 1，它被着色为黑色，而对于一个事务，我们有可能的最小值，即 0，它被着色为白色。介于两者之间的交易值带有一些灰色。
最后，让我们比较实际和生成的事务网格的分布，看看生成的值是否与实际值相似。这是一个简单的健全性检查，看起来分布是相当相似的。
另一种方法可能是检查由鉴别器学习的特征对于监督学习任务是否有用。在我们的保险数据示例中似乎就是这种情况，特别是如果我们在这里将它们的性能与自动编码器的性能进行比较:【https://goo.gl/TjB2v3
用于表征学习的 GAN
使用 DCGAN 的 MNIST 分类任务的准确度分数: 98.350000% 。
具有更深 CGAN 的 MNIST 分类任务的准确度分数: 99.090000% 。
使用 DCGAN 的保险分类任务的 AUROC 分数: 92.795883% 。
将这些结果与使用自动编码器对相同的计算机视觉和保险任务进行表征学习进行比较:https://goo.gl/TjB2v3
GitHub 上的代码
我为本文写的代码可以在我的 GitHub 上找到:https://github.com/hamaadshah/gan_keras
结论
我们已经展示了如何使用 GANs 来学习原始数据的良好表示，即，每个分析单位的二维张量，然后可以用于计算机视觉和保险领域中的监督学习任务。这使我们从手工制作的特征工程转向自动特征工程，即表示学习。GANs 也许也可以用于半监督学习，这将是另一篇论文的主题。
参考
- 古德费勒，我，本吉奥，y 和库维尔(2016)。深度学习(麻省理工出版社)。
- Geron，A. (2017)。使用 Scikit-Learn & tensor flow(O ’ Reilly)进行机器学习实践。
- 拉德福德、卢克和钦塔拉(2015 年)。深度卷积生成对抗网络的无监督表示学习(https://arxiv.org/abs/1511.06434)。
- Goodfellow，I .、Pouget-Abadie，j .、Mirza，m .、Xu，b .、Warde-Farley，d .、Ozair，s .、a .、Bengio，Y. (2014 年)。生成敌对网络(【https://arxiv.org/abs/1406.2661】T2)。
- 【http://scikit-learn.org/stable/#
- https://towards data science . com/learning-rate-schedules-and-adaptive-learning-rate-methods-for-deep-learning-2c8f 433990 D1
- https://stack overflow . com/questions/42177658/how-to-switch-back end-with-keras-from-tensor flow-to-the ano
- https://blog.keras.io/building-autoencoders-in-keras.html
- https://keras.io
- https://github . com/fchollet/keras/blob/master/examples/mnist _ acgan . py # L24
- https://en.wikipedia.org/wiki/Kullback–莱布勒 _ 发散
- https://goo.gl/TjB2v3
- https://see . Stanford . edu/materials/lso coee 364 b/01-sub gradients _ notes . pdf
自动图形处理器
使用 Tensorflow 中的 GPU 在 GCloud 上快速启动和运行的可再现 R / Python 方法
“A high view of a sea of clouds covering a mountain valley in the Dolomites” by paul morris on Unsplash
背景
最近在 Coursera 上完成了谷歌优秀的 数据工程认证专业(我强烈推荐)，我认为在一个单一的 GCE 虚拟上获得自己的谷歌计算引擎(" GCE "或*# g cloud*)*实例既实用又有用——在 *Tensorflow 中使用 GPU，*使用 R 和 Python 像许多其他数据科学家一样，我经常使用两种语言，并且喜欢与谷歌计算平台(“GCP”)一起工作。希望您喜欢我方法的简单性，并从这次演练中获得一些收获！
带 R / Python 的 GPU 和 Tensorflow】
“A computer without the case showing the motherboard, cooling fans, graphics cards, and power supply mounted on a red-lit wall labeled ASUS in a gaming convention” by Maxime Rossignol on Unsplash
这些 GCE 机器是高度动态的，就像 AWS 实例一样，并且与张量处理单元(*“TPUs”是最近在 GCP 测试版上可用的 ASIC 卡)和图形处理单元(“GPU”*或用于“alt coin”挖掘、游戏和深度学习的“显卡”)一起工作。这篇文章将不包括自动 TPU 安装(也许这将是另一个有用的，当价格下降)。我们将运行一个简单的安装程序 *Tensorflow，*来检查 GPU 是否在工作，在运行一个 bash 脚本后，它首先完成所有繁重的工作。
最初，我尝试了许多与 GCloud 和 GPU 相关的不同演练，最终在 Medium 上找到了两个精彩的帖子，分别是这里的(Durgesh manke kar)和这里的(Luuk Derksen)。我的自动化脚本的一部分是基于上面的两篇文章，还有这个有用的要点(作者迈克尔·迪茨)以及无数其他来源。然而，其他帖子要么更适合 Jupyter 笔记本设置，要么在 CuDNN 驱动程序之前手动设置 NVIDIA Cuda，并且只测试 Python。坦率地说，考虑到最近的许多变化，我很难从其他演练中获得环境设置。
因此，我决定采取完全自动化的方法，不需要注册英伟达，登录，并下载特定操作系统的特定驱动程序。它假设用户可以用一个 bash 脚本再现下面的输出，给定一个 GCE 虚拟机的设置，该虚拟机具有任何当前可用的 g cloud GPU(NVIDIA:Tesla K80 或 P100)，在 Ubuntu 16.04 上至少 25Gb 的 HD，以及 2 个以上的内核，最少 7.5Gb 的 RAM，我们也将在下面逐步介绍。
预期方向
Photo by eberhard grossgasteiger on Unsplash
如果使用共享 GPU 正确设置，下面的内容将有望允许多用户 Jupyter 笔记本配置，我希望继续关注另一个博客，该博客将使用 *RStudio 服务器(易于在 GCloud 中设置密码登录)*或 JupyterLab(不那么容易)。此外，它使用 Anaconda 安装两个 R / Python，在同一个 conda 环境 ，应该支持多用户共享 GPU。
我们来看一下设置
我们将保持这一部分非常简单，没有太多的截屏(‘咳！嗯嗯……’)。谷歌赠送了为期 12 个月的 300 美元信用(T7)，让你开始在 GCP 工作。您将使用该配额为特定区域申请 GPU 配额，并在配额被允许后申请配额。
您首先需要创建一个项目；在这里，我从照片中突出显示的链接创建了ML-Test。使用+符号建立一个项目。您将在突出显示的左上方下拉列表中看到项目。
在您设置好项目之后，您会立即想要为 GPU 申请一个配额。事实上，谷歌很可能会要求你提供第二个参考项目，所以你只需建立另一个名为Project-Placeholder的项目，当谷歌发邮件给你时，你就可以用它来参考。
收到一封电子邮件大约需要 24 小时，您可以通过下拉左上方的“汉堡菜单”来参考Project-Placeholder的可用点数，以结算剩余的> >金额(对您来说大约是 300.00 美元)。顺便说一句，帮我设置的谷歌人员非常友好。礼貌地说，如果有人从谷歌上看到这个，我认为这一步可以自动化。
要访问配额页面，您需要首先进入ML-Test项目，然后下拉至 IAM > >配额，并编辑您的 GCE 以请求 GCE 的配额更新。
在您的用户信息(即，姓名、电子邮件和电话[确保使用您的帐户电子邮件[[我有过惨痛的教训]]])通过验证后，您将单击下一步(如上所示)。现在键入类似下面的内容。
提交。然后等待。谷歌友好的员工会在 24-48 小时内给你发邮件，希望ML-Test能准备好使用 GPU！
设置您的 GPU 实例
如果您想在没有 GPU 的情况下快速入门，同时使用 Python 和 R 在 GCE 上使用 Anaconda，您可以查看我最近在 Pepperdine 的一次演讲中创建的这些笔记。然而，如果您只对 GPU 感兴趣，并且您的配额得到批准，那么是时候启动 VM 了。
登录ML-Test后，点击汉堡栏计算> >计算引擎> >虚拟机实例。在那里，我们将单击“Create”。
现在创建实例…
在转到磁盘空间和操作系统之前，您需要配置前几个步骤来满足我们的最低要求。您将把虚拟机命名为gpu-vm，并匹配下面突出显示的最小设置。请注意，您的配额可能包括us-west1-b，但也可能包括特定 GPU 类型的其他区域。如果您使用一个不支持您的配额的区域，机器将会出错—这让我暂停了一段时间。
最后，在发布之前，为了进行复制，您需要通过点击“更改”来安装Ubuntu16.04和一个最低 25Gb 的硬盘(注意:您可以降低硬盘容量以避免存储费用，但发现这可能会改变 conda 环境中安装 R 时的环境最大存储容量)。
选择操作系统和存储设备后，您将使用Create按钮启动虚拟机。可选地，一旦您测试了这个模拟安装，您可能想要考虑这个虚拟机上的Pre-Emptible选项。这些可以节省高达 75%的每小时费用。然而，根据其他需求，它们可以在使用一个小时后关闭，我还没有在抢先模式下测试过这个安装。我认为在削减成本方面，这类似于 AWS 的保留实例机会。在创建菜单下的“管理、磁盘、网络、SSH 密钥”下，可以看到下面的可优先选项，红色，但是再次声明，现在让它保持“关闭”。
您的机器现在正在启动，一旦准备就绪(30 秒后)，您将看到带有绿色复选标记的gpu-vm。
注意:您现在正在接受计费，您将始终希望选中标记该机器，并在不使用时单击停止。当绿色的复选标记变成灰色的停止信号时，我通常只是确认机器已经关闭。
现在您将点击上面的 SSH 按钮。这将启动您到gpu-vm的 SSH 连接，并为您的虚拟机打开一个单独的选项卡。您还可以通过点击 SSH 按钮的左箭头来运行您的 SSH shell，并通过如下所示的View Gcloud Command进行访问。
点击RUN IN CLOUD SHELL，一个内嵌的云 Shell 将插入上面的命令，点击回车键，你将通过 SSH 进入你的虚拟机。在 Windows 上，这通常更好，因为 SSH 按钮会弹出一个浮动外壳，而在 Mac 上，它会打开一个新标签。
注意:在屏幕右上方的“激活谷歌云外壳”按钮下有一个免费的云外壳可供使用。GCloud 的另一个优点是在其环境中完全 SSH 安全，这意味着没有本地防火墙和 Putty。
让我们用自动脚本安装 GPU
您应该会看到类似这样的内容，但是在 VM 名称之前有您自己的用户名。
你已经准备好了，可以参加普通教育证书考试了。现在，您需要将下面的完整脚本复制到命令行中。它将执行，因为 NVIDIA 的 Cuda 还没有安装在 if 语句中。如果你对这里的任何一行有任何特殊的问题，不要犹豫，留下评论并提出来。我宁愿不去研究 Cuda——这么说吧，这使得这个过程更容易实现。该脚本已经过全面测试，可以保留路径、文件夹、删除下载的 zip 文件，并管理正确安装的环境，能够关闭该机器，并再次启动它，而不会破坏任何东西！
注意:这个 bash 脚本大约需要 10 分钟，并且一举安装 Cuda/cud nn/tensor flow-GPU/Python/R！
# Check for CUDA and try to install.
if ! dpkg-query -W cuda; then# Start Timer here
START=$(date +%s) # Time script# Install Cuda from NVIDIA
curl -O [http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64/cuda-repo-ubuntu1604_8.0.61-1_amd64.deb](http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64/cuda-repo-ubuntu1604_8.0.61-1_amd64.deb)
# Login as root
sudo dpkg -i ./cuda-repo-ubuntu1604_8.0.61-1_amd64.deb
rm -r cuda-repo-ubuntu1604_8.0.61-1_amd64.deb
sudo apt-get update
sudo apt-get -y install cuda-8.0# Install cuDNN v6.0
CUDNN_TAR_FILE="cudnn-8.0-linux-x64-v6.0.tgz"
wget [http://developer.download.nvidia.com/compute/redist/cudnn/v6.0/${CUDNN_TAR_FILE](http://developer.download.nvidia.com/compute/redist/cudnn/v6.0/${CUDNN_TAR_FILE)}
tar -xzvf ${CUDNN_TAR_FILE}
rm -r cudnn-8.0-linux-x64-v6.0.tgz
sudo cp -P cuda/include/cudnn.h /usr/local/cuda/include
sudo cp -P cuda/lib64/libcudnn* /usr/local/cuda/lib64/
sudo chmod a+r /usr/local/cuda/lib64/libcudnn*# Export Paths
echo 'export CUDA_HOME=/usr/local/cuda' >> ~/.bashrc
echo 'export PATH=$PATH:$CUDA_HOME/bin' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=$CUDA_HOME/lib64' >> ~/.bashrc
echo 'export PATH=$PATH:$HOME/anaconda3/bin' >> ~/.bashrc
source ~/.bashrc# Install Anaconda
mkdir Downloads
cd Downloads
wget "[https://repo.continuum.io/archive/Anaconda3-5.0.1-Linux-x86_64.sh](https://repo.continuum.io/archive/Anaconda3-5.0.1-Linux-x86_64.sh)" -O "Anaconda3-5.0.1-Linux-x86_64.sh"
chmod +x Anaconda3-5.0.1-Linux-x86_64.sh
sudo sh "Anaconda3-5.0.1-Linux-x86_64.sh" -b
cd $HOME
rm -r Downloads# Create conda environment to work with Python/R
# conda search python # Current Python packages hosted by Anaconda
# conda search r # Current R packages hosted by Anaconda
mkdir prog_env
source activate prog_env
sudo apt-get update
conda install -c anaconda --prefix=$HOME/prog_env python=3.6 -y
conda install -c anaconda tensorflow-gpu --prefix=$HOME/prog_env -y
conda install -c anaconda --prefix=$HOME/prog_env r=3.4 -y
source deactivate prog_env# Shows Cuda Info
nvidia-smi# End of timer
END=$(date +%s)
DIFF=$(( $END - $START ))
echo "It took $DIFF seconds"fi
等待…如果你看到这个，那么事情看起来很好！
在我们运行一次之后，在我们停止虚拟机之后，就不需要再运行一次了。事实上，如果我们尝试的话，for 循环会阻止我们再次运行它，因为 CUDA 已经安装在进程中了。如果我们幸运的话，您将会看到 CUDA 和 GPU 被认可的初步迹象，以及完成的时间(如下所述)。
现在让我们在 R 和 Python 上测试我们的 tensorflow-gpu 安装
首先，我们想熟悉一下新创建的 conda 环境，它安装了tensorflow-gpu Python 模块，以及安装在主目录prog_env(“程序环境”)中的最新版本的 R 和 Python 语言。
为了在 R 和 Python 中测试 Tensorflow 上的 GPU，我们将运行下面的代码，应该会得到与下面用#标记注释掉的结果完全相同的结果。
关于在 conda 环境中使用 Anaconda 的详细信息。
测试 Python:
## Source environment from home directory in linux
source activate prog_env## Now in program environment
(prog_env)$ python## Test GPU is working from Python
from tensorflow.python.client import device_lib
device_lib.list_local_devices() # Output should look like this
# name: "/device:CPU:0"
# device_type: "CPU"
# memory_limit: 268435456 # name: "/device:GPU:0" (Note: Confirmed GPU!)
# device_type: "GPU"
# memory_limit: 11326131405
quit("yes") # CTRL(or CMD) + Z
测试 R:
## While in program environment
(prog_env)$ R## From R command line
install.packages("tensorflow") # Run first time only
library(tensorflow)
install_tensorflow(version = "gpu") # To use GPUs
use_condaenv("r-tensorflow") # For running from conda env
sess = tf$Session() # Creates Tensorflow session # Confirms TeslaK80 GPU being used
# 2018-03-21 19:32:33.987396:
# tensorflow/core/common_runtime/gpu/gpu_device.cc:1120]
# Creating TensorFlow device (/device:GPU:0) ->
# (device: 0, name: Tesla K80, pci bus id: 0000:00:04.0,
# compute capability: 3.7) (Note: Confirmed GPU!)
GPUtest <- tf$constant('GPU is running!')
sess$run(GPUtest)
# "GPU is running!"
quit("yes") # CTRL(or CMD) + Z
给所有 R 和 Python 爱好者的总结
Photo by photo-nic.co.uk nic on Unsplash
就这样，我们做到了！你现在已经有了一台完整的机器，你可以用 R 和 Python 来进行 GPU 深度学习。期待听到这篇文章是否有帮助，以及你可以如何扩展它。期待一个多用户环境，登录，链接到 GPU，使用 GCloud 按分钟付费的可抢占性。
Note on DataLab Notebooks: With GCP’s newer product DataLab, a single user GCE, using a custom Jupyter Notebook interface, setup with GPUs, is as easy to get up and running with a single line of code. Unfortunately, aside from only being single-user, it also does not ship with an R kernel for connecting to GPUs and Tensorflow through the Jupyter interface; it also requires all interaction be ran through the notebook and not the command line, given it’s Docker configuration. For an excellent walkthrough of setting up a GPU enabled DataLab GCE notebook quickly, see this article posted by Kaz Sato (you can right click translate from Japanese to English in Chrome, if needed [for the most part 次に変更 ]).
扫一扫
3221
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
