作为文本分类或聚类问题的作者分析
你知道吗？J.K .罗琳被指控盗用了“麻瓜”一词，《达芬奇密码》的作者丹·布朗被指控侵犯了非文字版权，有人推测 1983 年的《希特勒日记》是阿道夫·希特勒本人写的，但有证据表明并非如此。
许多这样的“文学”难题都经过了语言专家的检验，因为对话语进行分析和分类是相当复杂的，具有特定领域和高度多维性。
自然语言处理的最新研究领域之一是作者身份分析，它试图利用大数据和人工智能的计算能力，结合语言学和认知心理学，对文本的自动分类进行编码，识别作者简介并解决作者身份冲突。本文试图介绍作者分析的概念，它的应用领域和与之相关的主要子任务。
简介:
通过识别作者的个性特征并检查他们撰写的文章来区分作者写作风格的艺术和科学被称为作者身份分析。因此，它还旨在根据与个人相关的*【可用信息】*确定个人的传记特征，如年龄、性别、母语和认知心理特征。
Authorship Analysis is a combination of Artificial Intelligence, Linguistics and Cognitive Psychology
在本文中，*“可用信息”*仅指作者身份分析上下文中的文本数据，然而，此上下文中的信息可能超出文本格式，因为它可能还涉及多模态观察的使用。多模态观察捕捉个人的特征，例如声音、语调、手势、身体姿势和其他身体行为方面。所有这些特征的组合反映了一个人的个性，因此有助于描述这个人。此外，在基于内容的分析中，位置、教育水平、社会地位和作者职业等社会经济变量的信息也至关重要。
作者身份分析任务的类型:
作者身份分析涉及的三个主要任务是*作者归属、作者验证和作者简介。*他们各自的目标解决了作者分析中的各种挑战。这些任务及其目的总结如下:
*i)作者归属:*作者归属是在调查来自多个具有明确作者身份的作者的集合文本之后，确定未预见的文本是否由特定个人所写。这在理想情况下是一个闭集多类文本分类问题。[2]
Author Attribution
*ii)作者验证:*该任务通过研究同一作者的语料库来确定个人是否已经创作了一段文本。这是一个二元单标签文本分类问题陈述。尽管这个任务看起来很简单，但作者验证实际上是一个复杂得多的过程。
Author Verification
*iii)作者简介:*作者简介也可以被认为是通过研究所创作的文本而对作者进行的个性识别。这包括通过检查作者的写作风格来预测他们的人口统计学特征，如性别、年龄、母语和个性特征。作者特征分析可以看作是一个多类多标签的文本分类和聚类问题。这是一个潜在的聚类问题，因为我们的目标是识别同质的写作风格，并将它们聚类在一起，以便在给定的语料库中进行相似性分析。
Author Profiling
这些任务中的每一个都是可扩展的，这取决于它们在现实世界中用于哪种问题陈述。有时，这些任务的目标相互重叠。
这些任务不限于英语作为自动作者身份分析的语言。正在研究和开发其他语言的计算机化应用程序，如希腊语、法语、荷兰语、西班牙语、阿拉伯语、葡萄牙语和意大利语。[2, 3, 5]
应用领域:
为什么作者分析很重要？它在法医分析和犯罪调查中起着至关重要的作用。此外，社交媒体和开放的网络资源引发了广泛的网络犯罪——虚假个人资料创建、机器人虚假评论、剽窃、黑暗网站促进网络化和有组织的恐怖活动、识别恐怖主义宣言、通过社交媒体消息进行骚扰和恐吓等等。[1]
了解消费者概况和反馈分析对市场分析至关重要，并打算调查匿名反馈作者的人口统计数据。作者分析任务有助于建立消费者档案，识别虚假评论和客户细分。
其他应用领域包括解决小说著作权纠纷、剽窃检测、文件年代测定、审查社会经济因素和心理健康检查。
参考资料:
[1] Reddy、T. Raghunadha、B. Vishnu Vardhan 和 P. Vijaypal Reddy。"作者简介技术综述."国际应用工程研究杂志11.5(2016):3092–3102。
[2] Stamatatos，Efstathios 等，“PAN 2014 年作者识别任务综述” CLEF 2014 年评估实验室和研讨会工作笔记论文，英国谢菲尔德，2014 年。2014.
[3] Stamatatos，Efstathios 等人，“pan/clef 2015 评估实验室概述”欧洲语言跨语言评估论坛国际会议。施普林格，查姆，2015。
[4] Rangel，Francisco 等，“PAN 2013 年作者特征分析任务概述” CLEF 多语言多模式信息获取评估会议。CELCT，2013 年。
[5] Rangel，Francisco 等，“pan 2017 第五次作者特征分析任务概述:twitter 中的性别和语言变体识别。”谱号工作笔记论文 (2017)。
自动编码器:它是什么？它是用来做什么的？(第一部分)
Photo by Tomas Sobek on Unsplash
对自动编码器及其 Python 代码的一些常见用例的简单介绍
背景:
Autoencoder 是一个无监督的人工神经网络，它学习如何有效地压缩和编码数据，然后学习如何将数据从简化编码表示重建回尽可能接近原始输入的表示。****
根据设计，Autoencoder 通过学习如何忽略数据中的噪声来降低数据维数。
以下是从 MNIST 数据集到自动编码器的输入/输出图像示例。
Autoencoder for MNIST
自动编码器组件:
自动编码器由 4 个主要部分组成:
1- 编码器:其中模型学习如何减少输入维度，并将输入数据压缩成编码的表示。
2- 瓶颈:包含输入数据的压缩表示的层。这是输入数据的最低可能维度。
3- 解码器:其中模型学习如何从编码表示中重建数据，以尽可能接近原始输入。
4- 重建 损失:这是一种衡量解码器性能以及输出与原始输入接近程度的方法。
然后，训练包括使用反向传播，以最小化网络的重建损失。
你一定想知道为什么我要训练一个神经网络来输出一个和输入完全一样的图像或数据！本文将涵盖 Autoencoder 最常见的用例。让我们开始吧:
自动编码器架构:
根据使用情况，自动编码器的网络架构可以在简单前馈网络、LSTM 网络或卷积神经网络之间变化。我们将在接下来的几行中探索其中的一些架构。
1-用于异常检测的自动编码器:
有许多方法和技术可以检测异常和异常值。我在下面的另一篇文章中谈到了这个话题:
[## 每个数据科学家都应该知道的 5 种检测异常值的方法(Python 代码)
检测异常对任何企业都至关重要，无论是通过识别故障还是采取主动。这篇文章讨论了…
towardsdatascience.com](/5-ways-to-detect-outliers-that-every-data-scientist-should-know-python-code-70a54335a623)
但是，如果您有相关的输入数据，则自动编码器方法将非常适用，因为编码操作依赖于相关的要素来压缩数据。
假设我们已经在 MNIST 数据集上训练了一个自动编码器。使用简单的前馈神经网络，我们可以通过构建如下简单的 6 层网络来实现这一点:
上面代码的输出是:
Train on 60000 samples, validate on 10000 samples
Epoch 1/10
60000/60000 [==============================] - 6s 103us/step - loss: 0.0757 - val_loss: 0.0505
Epoch 2/10
60000/60000 [==============================] - 6s 96us/step - loss: 0.0420 - val_loss: 0.0355
Epoch 3/10
60000/60000 [==============================] - 6s 95us/step - loss: 0.0331 - val_loss: 0.0301
Epoch 4/10
60000/60000 [==============================] - 6s 96us/step - loss: 0.0287 - val_loss: 0.0266
Epoch 5/10
60000/60000 [==============================] - 6s 95us/step - loss: 0.0259 - val_loss: 0.0244
Epoch 6/10
60000/60000 [==============================] - 6s 96us/step - loss: 0.0240 - val_loss: 0.0228
Epoch 7/10
60000/60000 [==============================] - 6s 95us/step - loss: 0.0226 - val_loss: 0.0216
Epoch 8/10
60000/60000 [==============================] - 6s 97us/step - loss: 0.0215 - val_loss: 0.0207
Epoch 9/10
60000/60000 [==============================] - 6s 96us/step - loss: 0.0207 - val_loss: 0.0199
Epoch 10/10
60000/60000 [==============================] - 6s 96us/step - loss: 0.0200 - val_loss: 0.0193
正如您在输出中看到的，验证集的最后重建损失/误差是 0.0193，这非常好。现在，如果我传递 MNIST 数据集中的任何正常图像，重建损失将非常低(< 0.02)，但如果我尝试传递任何其他不同的图像(异常值或异常值)，我们将获得较高的重建损失值，因为网络无法重建被视为异常的图像/输入。
请注意，在上面的代码中，您可以仅使用编码器部分来压缩一些数据或图像，也可以仅使用解码器部分通过加载解码器层来解压缩数据。
现在，让我们做一些异常检测。下面的代码使用两个不同的图像来预测异常分数(重建误差),使用我们上面训练的自动编码器网络。第一幅图像来自 MNIST，结果是 5.43209。这意味着图像不是异常。我使用的第二个图像是一个完全随机的图像，不属于训练数据集，结果是:6789.4907。这个高误差意味着图像是异常的。同样的概念适用于任何类型的数据集。
2-图像去噪:
Image denoising
去噪或降噪是从信号中去除噪声的过程。这可以是图像、音频或文档。您可以训练自动编码器网络来学习如何消除图片中的噪声。为了测试这个用例，让我们重新使用著名的 MNIST 数据集，并在数据集中创建一些合成噪声。下面的代码将简单地给数据集添加一些噪声，然后绘制一些图片以确保我们已经成功地创建了它们。
上面代码的输出是下图，非常嘈杂和模糊:
在本例中，让我们构建一个卷积自动编码器神经网络。我将介绍构建网络的每一个步骤:
首先，我们定义输入层和输入数据的维度。MNIST 数据集包含尺寸调整为 28 X 28 的影像。因为图像是灰度的，所以图像的颜色通道是 1，所以形状是(28，28，1)。
第二层是卷积层，该层创建卷积核，卷积核与层输入卷积以产生输出张量。32 是卷积中输出滤波器的数量,( 3，3)是内核大小。
在每个卷积层之后，我们使用最大池函数来降低维数。(28，28，32)减少了两倍，因此在第一次最大池化之后是(14，14，32)，然后在第二次最大池化之后是(7，7，32)。这是图像的编码表示。
input_img = Input(shape=(28, 28, 1))
nn = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img)
nn = MaxPooling2D((2, 2), padding='same')(nn)
nn = Conv2D(32, (3, 3), activation='relu', padding='same')(nn)
encoded = MaxPooling2D((2, 2), padding='same')(nn)
下面的代码是原始数字的重建部分。这是网络实际学习如何从输入图像中去除噪声的地方。我们使用上采样功能将图像重建到原始尺寸(28，28)
nn = Conv2D(32, (3, 3), activation='relu', padding='same')(encoded)
nn = UpSampling2D((2, 2))(nn)
nn = Conv2D(32, (3, 3), activation='relu', padding='same')(nn)
nn = UpSampling2D((2, 2))(nn)
decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(nn)
现在，剩下的最后一步是创建模型，编译它，然后开始训练。我们通过运行以下命令来实现这一点:
autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer='adadelta',loss='binary_crossentropy')
autoencoder.fit(x_train_noisy, x_train,
epochs=50,
batch_size=256,
validation_data=(x_test_noisy, x_test))
训练完成后，我尝试通过网络传递一幅有噪声的图像，结果令人印象深刻，噪声被完全消除了:
如果您缩放上面的 ConvNet，您可以使用它来消除任何类型的图像、音频或扫描文档的噪声。
在文章的这一部分，我介绍了自动编码器的两个重要用例，并构建了两个不同的神经网络架构——CNN 和前馈。在第 2 部分中，我将介绍自动编码器的另外两个重要用例。第一个是如何通过构建 LSTM 网络将 autoencoder 与一系列数据结合使用，第二个用例是一种称为变分 Autoencoder (VAE)的用例，主要用于生成模型和生成数据或图像。敬请期待！
使用 Python Dash、主题分析和 Reddit Praw API 自动生成常见问题
使用快速虚线可视化进行主题建模概述
Dash Topic Modelling with Reddit API and Python
问题陈述
“该死，在我离开 3 天后，我已经失去了我的 Slack 组中的重要内容”
“应该可以快速访问最相关的帖子，并让我快速更新”
同行评审或论坛的最大问题是网站上的大量可用信息。很多时候，我们对大量与他们搜索的内容无关的评论感到沮丧。以这个 Reddit 为例，在这里，我们的主页上有很多帖子。所有的信息都很难跟踪。
These Reddit Posts show how much clutters a forum could bring just by a few days of inactivity
在本文中，我们将了解更多关于如何使从 Reddit 这样的论坛中提取信息更容易、更直观。一种方法是构建一个仪表板页面，用于从论坛中提取关键主题，并将它们打包在一个可过滤的仪表板中以进行快速概述——我将这称为自动生成的常见问题解答,因为它会遍历文本语料库，提取主题以形成趋势和模式，从而创建一个常见问题解答(FAQ)/帖子。这将帮助我们在正确的时间与正确的信息保持联系。
免责声明:本免责声明告知读者，文中表达的观点、想法和意见仅属于作者，不一定属于作者的雇主、组织、委员会或其他团体或个人。参考文献是从列表中挑选的，与其他作品的任何相似之处纯属巧合
这篇文章是从作者的论文中摘录的，是佐治亚理工学院计算机科学硕士期末作业的一部分。
为什么自动生成常见问题？
虽然总是有搜索引擎让我们在这些论坛上找到我们需要的信息，但功能是有限的，特别是对于那些不活跃或落后于讨论流程的用户。最终，搜索引擎会对我们有用，因为我们已经知道他们应该寻找什么(例如最新的机器学习论文)。然而，它的功能可能对我们这些想要对一个趋势话题做出贡献或者想要发现与一个话题相关的新想法/信息的人没有用。
考虑以下知识矩阵
Matrix of Knowledge and the solutions in between
在学习过程中存在四个知识领域。第一种涉及已知的知识，即已知的和容易获得的知识，以帮助解决一个人熟悉的问题。接下来是已知的未知，或者是一个人目前不知道但可以获得的知识。一个例子是寻找关于 python 编程语法的信息，而我目前对此一无所知。第三种形式是未知的已知。这被定义为一个人知道存在但不知道如何访问/获得的知识。一个例子是完成一个不知道如何开始/研究的任务。最后一种情况是未知的未知，一个人不知道的知识。在这种情况下，一个人实际上对正在发生的事情一无所知，也不知道知道什么是重要的。当一个人工作太忙而忘记了论坛中的讨论流程时，可能会发生这种情况。
我们的解决方案将有助于 C 和 D 领域，在那里用户可能不知道在给定的时间什么是重要的主题。我们的目标是为用户提供一个知识仪表板，以便快速浏览论坛讨论。
用途和 Github 代码
本概念证明(POC)的目的是作为佐治亚理工学院计算机科学硕士作业提交的一部分创建的，作者目前正在管理该作业。本文中的部分内容经过修改，以更好地反映一般读者的需求。请参考我们的论文这里。
我们的目标是用 Python 和 Flask/Dash 将这个应用程序构建成一个网页应用程序。用于版本控制的其他工具如 Github 也将被实现。请参考我们的 Github 代码这里
工作流程
现在让我们把手弄脏吧。创建自动生成常见问题时，我们需要考虑 3 个步骤
The workflow of creating Auto-Gen FAQ
使用 Praw Python 库提取 Reddit
我们如何提取 Reddit 语料库？
身份验证从使用 Reddit 的 praw 库开始。我不会详细谈论如何准备好您的身份验证，因为有许多可用的资源。请随意访问这里
Reddit praw code to input authorization profiles
然后，我们将获得子编辑信息，该信息将被导出到。
Reddit Code to gain a certain subreddit channel
然后我们可以打开这个 hot_python，它显示了带有以下元数据的 JSON 数据
Metadata retrieved after extracting posts from Reddit Praw
主题抽取
本节说明了如何用 Python 进行近似主题建模
我们将使用一种称为非负指标因子分解(NMF)的技术，这种技术用于从单词包(单词列表)中寻找提取主题。NMF 引入了一种确定性算法，使用文本语料库创建单一表示。由于这个原因，NMF 被表征为最大似然算法。
有关 NMF 和其他主题建模技术的更多信息，请参考本研究论文此处
Using sklearn Count Vectorizer to vectorize words
这将在 topics.csv 中的 1115 个帖子上返回 500 个单词。
我们将使用 NMF 获得一个文档-主题矩阵(这里的主题也称为“组件”)和每个主题的热门词汇列表。我们将通过使用相同的变量名:doctopic 和 topic_words 来进行类比
doctopic and topic words created
然后，我们将生成如下主题和可视化
DocTopic Created
这将创建 5 个主题的可视化，每个主题将根据 NMF 管理的欧几里德距离将 5 个密切相关的单词分组在一起。在给定主题长度的情况下追加 argmax 的计算还帮助我们为语料库中的每个文档定义潜在的主导主题。
以下是找到的 5 个主题
主题 1: omscs 项目学生工作课程
主题 2:计算机科学本科学位非评论
主题 3:乔治亚理工学院在线硕士项目
主题 4:课程班级学期学生新
话题 5:工作提供承诺的时间
主题分析的分析和可视化
然后，我们尝试将主题映射到每个相关的帖子，我们将计算与某些主题相关的帖子的数量，并以饼状图和折线图的形式显示它们。第一个饼图是基于每个帖子的主要话题的投票。
分析
从这里我们可以看到，热门话题谈论硕士和非硕士学生的工作机会。其次是对 omscs 学生的时间承诺。然后是项目和本科课程。
分析
1.在五月和八月，我们可以看到关于硕士研究生的工作和工作机会的话题越来越多
2.10 月，OMSCS 学生对时间和工作量的兴趣呈上升趋势(可能是由于新的 sems 的开始)
3.对于整体活动，我们可以看到 4 月份有所下降，但 10 月份有所上升
Dash 可视化
我们将使用 Dash Python，它是构建在 Plotly 和 Flask 之上的 Python 数据可视化框架。这将是我们在本地可视化和部署的基础。请查看我们的演示和演示下面的一个更生动的应用程序视图。
通过我们的应用程序，用户将能够选择最近最重要的主题，对它们进行过滤，并显示时间表。此外，下表将展示给定其所选主题的最相关的帖子。因此，用户不必点击所有可用的帖子，只需快速浏览一下这个仪表板，就可以了解关于某些主题的讨论。
只需点击几下鼠标，即可过滤所选主题并显示相关帖子。
Dash Python Visualization
调查:我们的应用程序有用吗？
在构建了以下原型之后，我们构建了一个调查来表明确认应用程序的有用性。从这个结果中，我们发现 93%的受访者认为该应用程序非常有用。用户还发现该应用程序非常直观，可以节省手动搜索未分类帖子的时间。这标志着我们的应用程序成功地为论坛访问者增加了价值。
应用程序的有用性
建议的改进
演示
Demo for Auto Generated FAQ for Online Master of Computer Science Educational Tech
结论和未来工作
这个项目让我们有机会解决一个实际的相关问题，这个问题我们很多人似乎都在 Reddit 等论坛上遇到过。我们可以添加许多功能和用户体验来改进该应用程序，但目前，该应用程序已经成功处理了上述核心问题，即从杂乱帖子的论坛中提取相关主题和趋势。
感谢
我们要感谢我们的同学和我的导师郄佳朝·范·奥肯，感谢他们对我们最终完成这篇论文的工作成果的支持和有益的评论。最后是 Ranon Sim，他负责该工具的总体项目管理
最后…
咻…就是这样，关于我的想法，我把它写成了文字。我真的希望这对你们来说是一个伟大的阅读。我希望我的想法能成为你发展和创新的灵感来源。
请通过我的 LinkedIn 联系我，并订阅我的 Youtube 频道
请在下面留言，寻求建议和反馈。
快乐编码:)
奥塔伊:秘制调味酱
加速你的人工智能之路
让数据科学家的生活更轻松
在最近一次预测消费者信贷风险的竞赛中，AutoAI 击败了 90%的参赛数据科学家。
AutoAI 是一种新工具，它利用复杂的训练功能来自动化许多复杂而耗时的功能工程和构建机器学习模型的任务，而无需成为数据科学专家。
下一个视频显示了“自动”工具的预览。今天的 UI 与视频中的有点不同，视频中的 UI 将很快推出。今天你可以试试这里的。
Re-create Example Following This Tutorial
人工智能的智能自动化
AutoAI 自动准备数据，应用算法，并构建最适合您的数据和用例的模型管道。它结合了 IBM 的研究方法和 Watson Studio 的能力。
AutoAI 包括自动:
- 型号选择
- 特征工程和
- 超参数优化
型号选择
为了有效地选择最佳模型，AutoAI 针对数据的小子集运行估计器。数据的样本逐渐增加，在这个迭代过程中消除了估计量。这种方法确保选择最佳估计器，同时节省计算时间和存储。高达 31 倍的加速。
Results from paper¹ of applying Model Selection method (DAUB) vs full training.
特征工程
提出正确的功能集是机器学习项目中最耗时的步骤之一。AutoAI 的自动特征工程结合了以下两种技术:
- 模式学习从成千上万的数据集中提取最常见的转换。这一步离线进行。
- 一种有效剪枝特征空间的强化学习方法。奖励函数是在新特征空间评估的质量度量和在原始特征空间评估的质量度量之间的差异。
超参数优化
自动超参数调整背后的方法针对高成本的函数评估进行了优化，例如使用大数据集训练函数。它改进了最佳性能的流水线，同时收敛到搜索最佳参数时所涉及的非线性问题的良好解决方案。
过去需要几天或几周的事情，只需要几分钟。
为什么 AutoAI 不同于其他 AutoML 库？
- 灵活。结果管道可以部署为 web 服务或导出为 Python 脚本。
- 过度拟合是在训练模型中观察到的最常见问题之一。过度拟合的模型无法在新的看不见的数据上表现良好。AutoAI 采用基于交叉验证的稳健方法来避免过度拟合。
- 易用性。选择要预测的数据和列是用户需要的唯一操作。
- 不断进步。几个团队正在同时改进 AutoAI 工具的性能。敬请关注新的贡献！
你愿意重现视频中的例子吗？
对于如何建立视频示例的一步一步的方向，请按照这个链接。
[1]萨穆洛维兹、特索罗和萨巴瓦尔。“通过增量数据分配选择接近最优的学习者”，人工智能 AAAI 会议，2016 年。http://www . cs . Toronto . edu/~ horst/cog robo/papers/moment-aaai 2016 . pdf
[2] Khurana、Samulowitzb 和 Turaga。“使用强化学习的预测模型的特征工程.”，2018 年人工智能 AAAI 大会。https://www . aaai . org/OCS/index . PHP/AAAI/aaai 18/paper/view/16564/16719
[3]科斯塔和南尼奇尼。" RBFOpt:一个用于黑盒优化的开源库，具有昂贵的函数求值."，数学规划计算，2018。https://link.springer.com/article/10.1007/s12532-018-0144-7
特别感谢 Jean-Fran ois Puget 和 Horst Samulowitz 的宝贵反馈。特别感谢阿历克斯·斯温和迈克尔·塞斯塔克👏对视频的贡献。
Twitter:@ castan LinkedIn:@jorgecasta
用于无标记数据集异常检测的自动编码神经网络
问题—解决方案
在大多数你想用人工智能解决的实际问题中，你可能没有一个带标签的数据集。特别是在预测异常值时，可能你有数百万的历史数据，其中也包括异常值。如果您试图从这样一个未标记的数据集中检测那些异常值/异常，并且担心没有标记的数据集，那么这里有一个有趣的解决方案。
这些天来，每当你遇到不平衡的数据集时，训练一个模型并使其合适应该是一个很大的麻烦。但现在这正是我们所需要的。你所需要的只是一个包含近 1%异常的不平衡数据集。
自动编码器神经网络
The architecture of autoencoder neural network (Source — deep-autoencoders)
与典型的神经网络相反，在典型的神经网络中，您给出许多输入并得到一个或多个输出，自动编码器神经网络在输出层中具有与输入层相同数量的神经元。这基本上意味着数字输入和输出是相同的。不仅是计数，就连它试图预测的输出也与输入相同。是的，autoencoder 神经网络的工作是将数据编码成一个小代码(压缩)并解码回来以再现输入(解压缩)。在上图中，你也可以看到输出向量是输入向量的近似值。这个特殊的属性使我们能够将它用于未标记的数据集。
自动编码器神经网络通常用于从计算机视觉到自然语言处理的降维。要了解更多关于自动编码器神经网络的信息，请阅读这个维基百科页面。
对于一个未标记的数据集，这怎么可能呢？
由于我们试图用该模型再现输入，最适合的损失函数是均方误差(MSE)。在训练模型时，它试图做的是最小化 MSE。为了最小化 MSE，它应该尝试尽可能地适应数据集(即，它应该尝试尽可能地再现许多数据)。在我们的案例中，由于数据集包含 99%的正常数据和仅 1%的异常数据，因此在训练时，模型会遗漏一小部分数据，并拟合其余 99%的数据，因此 MSE 非常非常小。这是背后的核心逻辑，这使得即使对于未标记的数据集，也可以使用它来预测异常。
如何预测异常现象？
在训练模型时，它会学习正常数据的特征外观，并将其压缩为一个小元素，然后将其解码为带有小误差的输入。当通过模型发送异常时，它将无法再现它，因为它被训练为仅再现正常数据，并且将以较大的 MSE 结束。我们需要做的是计算输出与输入相比的 MSE，并通过检查输出来正确区分异常，我们需要根据我们的需要设置 MSE 的阈值，以便它以良好的精度和召回率进行预测。
这还不是全部
大多数时候，通过不断调整超参数并检查输出以得出最佳阈值，很难获得完全令人满意的结果。但是我们有更多的选择。
Two neural networks stacked together to improve both recall and precision
高级召回者
即使我们用成千上万的数据训练它，我们得到的异常也只有几百个。因此，现在人类可以手动检查异常输出，并将其中一些标记为误报。因此，我们可以让我们的自动编码器神经网络模型作为一个高召回器。这意味着保持低阈值，以便几乎所有的实际异常都被检测到(高召回率)以及其他假阳性异常(低精度)。
现在，我们有一个小数据集，可以手动标记为假，其余的保持为真。对于这个人工标注的数据集，我们来介绍一个新的人工神经网络模型。
假阳性减少器
有了现在的数据集，我们可以选择神经网络或基于复杂性，甚至随机森林或任何其他典型的 ML 模型，我们可以简单地训练它。这使得我们能够通过消除最终输出中的假阳性来准确预测我们想要预测的实际异常。
实时预测
我们现在需要做的就是堆叠这些模型，以便在实时预测中，那些被高调用模型(自动编码器神经网络)预测为异常的模型通过假阳性减少模型(人工神经网络)发送。这种神经网络的结合为我们提供了一个具有高召回率和高精确度的深度神经网络模型。
自动编码器神经网络:什么和如何？
关于如何在 Keras 中为初学者建立一个自动编码器网络的清晰、基本的说明
前言
我将通过使用 Keras 和 Python 创建一个自动编码器。首先，我将说明什么是自动编码器，以及我们如何实现它。然后，我将通过步骤实际创建一个。可能会用 MNIST ，因为它很普通也很简单。
简介:什么是自动编码器？
自动编码器接受任何输入，将其分割成某种压缩版本，并使用它来重建输入内容。所以基本上，输入 x 进入隐藏层 h， h = f(x)， 出来就是重构r = g(h)。*当 r 接近 *x、或输出看起来像输入时，自动编码器是好的。
那么，拥有一个精确输出输入内容的神经网络是一件好事吗？在许多情况下，并不是真的，但他们经常被用于其他目的。一个共同的目标是，隐藏层 h 应该有一些限制，以便它提取关于 x 的重要细节，而实际上不需要保留 x 提供的所有信息，从而充当一种有损压缩，并且它应该根据示例自动完成此操作，而不是由人类设计来识别显著特征( Chollet ，2016)。**
为什么是 tho？
通常，当人们编写自动编码器时，希望中间层 h 以某种压缩格式呈现有用的属性。在这里，我们将建立一个叫做的不完全自动编码器*，这基本上意味着我们缩小隐藏层，这样它就无法存储输入给我们的相同数量的信息，我们试图从中获得一个良好的重建。构建这样的模型会迫使 autoencoder 找到您提供给它的数据的最显著的特征。在现实生活中，它可以用于降低数据集的维数，这有助于数据可视化，或潜在的去噪数据。*
零件清单
这是我们需要创建的东西的基本列表。
- 输入数据——什么被编码和解码？
- 编码功能——需要有一个接收输入并对其进行编码的层。
- 解码功能——需要有一个层来接收编码输入并对其进行解码。
- 损失函数—当解码版本的输出非常接近原始输入数据(损失很小)时，自动编码器为好*，当解码版本看起来与原始输入一点也不像时，自动编码器为差。*
进场
最简单的自动编码器大概是这样的:x → h → r，其中函数 f(x) 产生 h ，函数 g(h) 产生 r 。我们将使用神经网络，所以我们不需要计算实际的函数。
从逻辑上来说，步骤 1 将是获取一些数据。我们将从 Keras 数据集库中获取 MNIST。它由 60，000 个训练样本和 10，000 个手写数字 0-9 的测试样本组成。接下来，我们将做一些基本的数据准备，以便我们可以将其作为输入集输入到我们的神经网络中， x.
*然后在**步骤 2 中，*我们将建立基本的神经网络模型，从 x. 中给我们隐藏层 h
- 我们将把一个单一的密集的隐藏层与一个 ReLU 激活层放在一起，它将 x 作为输入。
- 接下来，我们将把这一层的输出传递到另一个密集层，并通过一个 sigmoid 激活层运行输出。
一旦我们有了模型，我们将能够在步骤 3 中训练它，然后在步骤 4 中，我们将可视化输出。
我们把它放在一起:
首先，我们不要忘记必要的导入来帮助我们创建我们的神经网络(keras)，做标准矩阵数学(numpy)，绘制我们的数据(matplotlib)。我们称之为步骤 0 。
*# Importing modules to create our layers and model.
from keras.layers import Input, Dense
from keras.models import Model# Importing standard utils
import numpy as np
import matplotlib.pyplot as plt*
第一步。导入我们的数据，做一些基础的数据准备。因为我们不打算在这里使用标签，我们只关心 x 值。
*from keras.datasets import mnist(train_xs, _), (test_xs, _) = mnist.load_data()*
接下来，我们将在 0 和 1 之间对它们进行归一化。因为它们是灰度图像，值在 0 到 255 之间，我们将输入表示为 float32 并除以 255。这意味着如果值是 255，它将被规范化为 255.0/255.0 或 1.0，以此类推。
*# Note the '.' after the 255, this is correct for the type we're dealing with. It means do not interpret 255 as an integer.
train_xs = train_xs.astype('float32') / 255.
test_xs = test_xs.astype('float32') / 255.*
现在想一想，我们有 28 x 28 的图像，值在 0 和 1 之间，我们想把它们作为输入向量传递到神经网络层。我们做什么呢我们可以使用卷积神经网络，但在这个简单的例子中，我们只使用密集层。那我们怎么把它放进去？我们将把每个图像展平成一个 784 x 1 值的一维向量(28 x 28 = 784)。
*train_xs = train_xs.reshape((len(train_xs), np.prod(train_xs.shape[1:])))test_xs = test_xs.reshape((len(test_xs), np.prod(test_xs.shape[1:])))*
***第二步。*我们来拼凑一个基本网络。我们将简单地创建一个编码层和一个解码层。我们将把它们放在一起，形成一个名为 autoencoder 的模型。我们还将减小编码的大小，这样我们就可以得到一些数据压缩。为了简单起见，这里我们用 36。
*# Defining the level of compression of the hidden layer. Basically, as the input is passed through the encoding layer, it will come out smaller if you want it to find salient features. If I choose 784 for my encoding dimension, there would be a compression factor of 1, or nothing.
encoding_dim = 36
input_img = Input(shape=(784, ))# This is the size of the output. We want to generate 28 x 28 pictures in the end, so this is the size we're looking for.
output_dim = 784encoded = Dense(encoding_dim, activation='relu')(input_img)
decoded = Dense(output_dim, activation='sigmoid')(encoded)*
现在创建一个模型，接受 input_img 作为解码器层的输入和输出。然后编译模型，在这种情况下用 adadelta 作为优化器，用 binary_crossentropy 作为损失。
*autoencoder = Model(input_img, decoded)autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')*
***第三步。*我们的模特已经准备好训练了。你不需要图形处理器就能运行这个，不会花很长时间。我们将在我们创建的 autoencoder 模型上调用 fit，为 15 个时期的输入和输出传递 x 值，使用相对较大的批处理大小(256)。这将有助于它训练得更快。我们将启用 shuffle 来防止每个批次中出现同质数据，然后我们将使用测试值作为验证数据。注意:如果你想在不过度拟合的情况下训练更长时间，稀疏和正则化可能会被添加到你的模型中。
*autoencoder.fit(train_xs, train_xs, epochs=15, batch_size=256, shuffle=True, validation_data=(test_xs, test_xs)*
就是这样。自动编码器完成。你会看到它应该有大约 0.69 的损失，这意味着我们创建的重建通常相当好地代表了来自高度压缩版本的输入。但是我们不能自己去看一下吗？
***第四步。*为此，我们将进行一些推理，从输入数据中获取我们的重构，然后我们将使用 matplotlib 显示它们。为此，我们想使用预测方法。
思维过程是这样的:获取我们的测试输入，通过 autoencoder.predict 运行它们，然后显示原始数据和重建数据。
*# Run your predictions and store them in a decoded_images list.
decoded_images = autoencoder.predict(test_xs)*
The top row is the inputs, and the bottom row is the reconstruction from our autoencoder model.
下面是你如何得到上面的图像:
*# We'll plot 10 images.
n = 10
plt.figure(figsize=(16, 3))
for i in range(n):
# Show the originals
ax = plt.subplot(2, n, i + 1)
plt.imshow(test_xs[i].reshape(28, 28))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)# Show the reconstruction
ax = plt.subplot(2, n, i + 1 + n)
plt.imshow(decoded_imgs[i].reshape(28, 28))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)plt.show()*
就是这样。这是最基本的自动编码器。非常感谢Fran ois Chollet，我从他的文章中学到了这一点，并启发了本教程的基础知识，并感谢 Goodfellow 等人将深度学习作为无价的参考。
如果你喜欢这个教程或者有什么建议，请在下面留言。
编辑:我在这里添加了查看隐藏层的功能，这绝对很有趣。你可以看到，从这些 6 x 6 的图像中，神经网络能够重建原始输入。你开始明白为什么这可能有用了吗？
The top row is the input, the middle row is the hidden encoding, and from that the bottom row is reconstructed.
我们如何得到中间一排？这很简单，我们用第一个隐藏层创建一个模型。为什么？我们这样做是为了运行预测功能，并将其结果添加到 python 中的列表中。
*# Create a Model from the layer.
encoder = Model(input_img, encoded)# Save the results to encoded_imgs. This must be done after the autoencoder model has been trained in order to use the trained weights.
encoded_imgs = encoder.predict(test_xs)*
然后，我们稍微修改一下 matplotlib 指令，以包含新的图像:
*# We'll plot 10 images.
n = 10
plt.figure(figsize=(14, 4))
for i in range(n):
# Show the originals
ax = plt.subplot(3, n, i + 1)
plt.imshow(test_xs[i].reshape(28, 28))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False) # Show the middle layer
ax = plt.subplot(3, n, i + 1 + n)
plt.imshow(encoded_imgs[i].reshape(6, 6))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False) # Show the reconstruction
ax = plt.subplot(3, n, i + 1 + n * 2)
plt.imshow(decoded_imgs[i].reshape(28, 28))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)plt.show()*
暂时就这样吧！我希望这篇教程能帮助你理解一些自动编码器背后的思维过程，以及如何在你的神经网络中使用它们。
降维自动编码器
对表格数据应用自动编码器的一个例子
在特征工程过程中，特别是在一些比赛中，一种常见的情况是，一个人穷尽地尝试所有类型的特征组合，最终得到太多难以选择的特征。为了避免过度拟合，可以选择具有最高重要性的特征子集，或者应用一些降维技术。
我依稀记得有一次 Kaggle 比赛，一等奖的解决方案是在降维中使用 autoencoder。因此，在这篇文章中，让我们来谈谈 autoencoder 以及如何将它应用于一般的表格数据。结构如下:
- 通过一个简单的例子来理解自动编码器的概念
- 对竞赛数据应用自动编码器
自动编码器的一个好例子
这里有一个关于自动编码器的很好的解释。让我们从最基本的例子开始，说明 autoencoder 如何工作，然后将其应用于竞争数据中的一般用例。
最基本的自动编码器遵循以下结构:
请注意，输入和输出具有相同的维数(事实上，输入被用作输出的“标签”)，而隐藏层具有较少的维数，因此它包含输入层的压缩信息，这就是为什么它充当原始输入的降维。从隐藏层，神经网络能够解码信息到它的原始维度。从input_layer -> hidden_layer开始叫编码，hidden_layer -> output_layer叫解码。
从某种意义上说，Autoencoder 是一种无监督学习，因为它不需要外部标签。编码和解码过程都发生在数据集内。
自动编码器是从数据示例中自动学习的，这是一个有用的特性:这意味着很容易训练算法的专门实例，这些实例将在特定类型的输入上表现良好。它不需要任何新的工程，只需要适当的训练数据。
让我们通过一个例子来理解 autoencoder 的机制。
我们将使用著名的 MNIST 数据来看看图像是如何被压缩和恢复的。
建立网络
这个例子来自 Keras 博客。
我们的网络非常简单:大小为 784 的输入图像将通过密集层，并被编码为大小为 32 的图像，解码层将从该层恢复到大小为 784 的原始尺寸。结构简单如:
为了得到自动编码器的中间结果，我们还记录了encoded。
准备数据集和培训
数据被标准化为 0 和 1，并传递到我们的自动编码器。注意，输入和输出都是 **x_train** ，我们的想法是希望我们的编码层足够丰富，以恢复尽可能多的信息。
想象结果
将原始图像与从我们的编码层恢复的图像进行比较。
请注意，我们的 32 维隐藏层能够恢复 784 维的图像，并能够很好地捕捉信息。
现在让我们将这种降维技术应用于一个竞争数据集。
表格数据的自动编码器
在帖子这里中，我们应用了一些通用特征工程技术，在数据集上生成了 170 多个特征。让我们试着降低它的维度。
我们在训练和验证中拆分数据，训练数据如下所示，有 171 列:
现在我们使用同样的技术，把维数减少到 40，
encoder将在以后用于降维。
现在让我们对降维后的维度进行预测，
为了进行比较，我们仍然应用 lightgbm 进行预测，结果是 0.595，只有 40 个特征，而之前是 0.57，有 171 个特征。虽然降维模型并没有优于上一个，但我相信我们看到了 autoencoder 的优势。(代码)
结论
这里介绍的自动编码器是最基本的，在此基础上可以扩展到深度自动编码器和去噪自动编码器等。
autoencoder 在竞争中的另一个优势是，人们可以基于训练和测试数据来构建 autoencoder，这意味着编码层也将包含来自测试数据的信息！我在 Kaggle 竞赛中读到的一等奖解决方案的帖子使用了去噪 autoencoder，方法是在原始特征中添加一些噪声，以使他的网络更加健壮，同时，他还将测试数据用于他的模型中，我相信这也是他获胜的原因。
参考:
[1]https://blog.keras.io/building-autoencoders-in-keras.html
自动编码器:深度学习与 TensorFlow 的热切执行
We are so deep. Source: Pixabay.
深度学习在过去几年中彻底改变了机器学习场景。我们能把它应用到图像压缩中吗？深度学习算法重建小猫照片的能力有多强？什么是自动编码器？
今天我们将找到所有这些问题的答案。
图像压缩:所有关于模式
我之前讲过无监督学习:应用机器学习在未标记数据中发现模式。
在图像压缩的情况下，假设大多数图像是而不是完全随机的是很有意义的。
用更恰当的话来说，可以有把握地假设大多数图像并不完全由噪声(就像你打开一台旧电视时的静电噪声)构成，而是遵循一些 底层结构。
如果我们知道所有的图像都有共同点，那就更好了。进行图像压缩的最基本的方法之一是找到重复的像素流，给它们分配一个(较亮的)标签，并用该标签替换它们。
理想情况下，如果两个图像几乎相同，压缩程序可以存储两个图像，占用的空间不会比其中任何一个图像多。这应该也适用于图像的一部分。最后，我猜像无监督学习这样的模式发现机器应该擅长这个。
出于这项工作的目的，我们将使用我从 Kaggle 下载的小猫图片数据集。这将保证大多数图片有一些共同的结构。
这里是 GitHub 项目今天的代码和数据，如果你想跟进的话。然而，像往常一样，我将在这里添加最重要的片段。
但是在我们用代码弄脏我们的手之前，是时候学习一些深度学习了！
自动编码器:无监督式深度学习
尽管我们称自动编码器为“无监督学习”，但它们实际上是一种伪装的监督学习算法。我知道，我也很震惊！
然而，它们有一个非常特殊的属性，这使得它们从普通的分类器中脱颖而出:它们的输入和输出是相同的。
训练自动编码器
当我们训练一个自动编码器时，我们实际上是在训练一个人工神经网络
- 取一个输入向量 X 。
- 应用一些数学知识(我现在不会进入深度学习的细节，但这是我用来学习这些科目的书)。
- 返回另一个向量。在这种特殊情况下，我们希望它还是 X，或者尽可能接近 X。
然而，有一个技巧:在前馈过程(从输入到输出)中，神经网络会降低输入的维度，并在返回最后一层之前再次增加它。
维度的诅咒
自动编码器接受一个向量 X 作为输入，可能有很多分量。例如，对于具有 48×48 分辨率的 3 通道—RGB—图像， X 将具有 6912 个分量。即使它们中的每一个都只是一个浮点数，那也是 27Kb 的数据(非常小！)形象。这增加得很快。对如此多的元素进行所有数学运算所花费的时间也非常相关。
因此，我们必须将这个向量映射到一个更小的空间。在这个特殊的例子中，我试着把它缩小到原来的一半。然而，我们打算保留大部分数据。
自动编码器的体系结构
我们称降低输入向量维度的网络层为编码器，因为它将数据编码成一个更小的向量。
然后，我们对这个更小的向量进行操作，在我们的例子中，它的维数又减少了 2 倍。如果我们正在设计一个实际的图像压缩器，这将是我们将存储的输入版本，节省 75%的空间。然而在训练期间，这只是解码之前的一个中间步骤。
最后，使用减少的向量，自动编码器将不得不尽可能好地重建原始图像。
为了做到这一点，它将首先使其通过一个解码器层，该层再次将减少的向量映射到一个具有输入向量一半尺寸的向量。最后一层，我们得到一个与原始图像尺寸相同的矢量，希望非常相似。
Autoencoder 的层架构如下所示:
Source: Medium
使用自动编码器的结果
训练自动编码器会有很多效果:
- 重建的图像不会与原始图像完全相似。
- 我们将能够保存更轻的简化向量，然后使用重建，只要它足够好(无论我们如何定义)，而不是原始图像。
- 我们现在将有一个神经网络，它已经学习了小猫图片中的一些潜在模式。
这最后一个是最有价值的结果。
自动编码器的一些行业应用包括:
- 有监督的深度学习模型的特征工程:我们不会直接向它们提供数据，而是通过自动编码器的隐藏层来提供数据。
- 异常检测:自动编码器在重建狗、风景或虫子的图片方面非常糟糕。这给了我们一种自动检查图片是否是一只小猫的方法。
现在你知道了我们为什么要做我们正在做的事情，让我们用一些实际的代码来实践一下吧！
使用 Tensorflow 训练自动编码器
在本教程中，我们将使用 Tensorflow 的热切执行 API。我不得不说，这比以前的会话要直观得多，以至于我不会介意性能是否有所下降(我没有察觉)。
我们的数据集包含超过 8000 张小猫的图片，大小和颜色各不相同，位置也各不相同。你可以在 GitHub 项目中看到它，以及加载它的代码。
由于 PyPlot 处理 numpy 浮点数组的方式，并且为了加速网络的收敛，图像被加载为范围从 0 到 1 的浮点数组，而不是从 0 到 255。
设计自动编码器
在 Tensorflow 吞下 Keras 变得渴望之前，用它写一个神经网络是相当繁琐的。现在，它的 API 已经变得直观了。
这是我用 Tensorflow 的 Keras API 设计的第一个自动编码器。
然而，这个模型有一些重大缺陷！首先，它收敛得太慢，即使学习率很高(我们会达到这一步)。其次，它返回了一个大小合适的向量…除了一些元素大于 1！这既不符合 PyPlot 的图形，也不符合我们的输入先验——每个像素有三个介于 0 和 1 之间的值。
我通过用 sigmoid 激活函数替换最后一层的 ReLu 来解决这个问题，所以它总是返回 0 到 1 之间的数字。
然而，仍然存在收敛速度的因素。我能做些什么来解决这个问题？幸运的是，我到处看过一些深度学习论文，有一个我用过几次的东西叫做批量规范化。它应该有自己的文章，所以我不会深入研究它。
批量标准化
简而言之，批处理规范化层为当前一批训练实例计算前一层的平均值和标准偏差。然后减去平均值并除以标准偏差，从而归一化图层的输出(对于批处理)。在训练后的前馈中，该层将使用从整个训练数据集估计的参数开始归一化。
这使得模型收敛得更快，因为它对输入或隐藏层的分布变化不太敏感。它还将对投入的自然分布变化更加稳健，在生产环境中更具长期可持续性。
这样，解码器只需要学习如何解码方差为 1 的中心变量，而不是任何随机的东西。同样的事情适用于编码器。仅这个变化就使得模型在前 5 或 6 个时期开始收敛。
训练自动编码器
这是我们期待已久的时刻！是时候训练我们的自动编码器了！
Tensorflow 的急切执行要求我们首先编译模型。这意味着我们要定义一个优化器(我用的是 Adam，它很快)，一个损失(在这种情况下是均方差，这是一种非常标准的测量重建误差的方法)，以及监控指标。最重要的是，这里是我们选择模型学习率的地方。
最后，我们开始训练模型。
这将开始培训(并使我的笔记本电脑听起来像维多利亚时代的火炉)并打印如下消息:
Epoch 2/2 7373/7373 [==============================] - 59s 8ms/sample - loss: 0.0183 - mean_squared_error: 0.0183 - val_loss: 0.0350 - val_mean_squared_error: 0.0350
如果验证数据集中的 MSE 值 val_mean_squared_error 保持向 0 收敛，我们将知道模型正在学习。如果训练损失持续下降，但验证损失稳定，或者更糟，上升，那么这意味着模型过度拟合。那我们该怎么办？我们能
- 添加更多数据，
- 减小压缩量，或者
- 提高学习率。
这不是我经常遇到的问题。
另一方面，培训损失可能很糟糕。
有多糟糕？如果我们从 0 到 1 之间的随机数中取样，我们得到的值大约是 25%，因为这是 1/2 的平方，也就是平均随机误差。
对于我尝试的大多数配置，这是长时间的训练损失(例如，没有使用批处理规范化，或者当我采样的数据少于一半时)。
如果发生这种情况，我们应该降低学习率(以避免收敛到局部最小值)，增加训练数据集的大小，或者降低目标，减少数据压缩。
我第一次尝试压缩到原来重量的九分之一，而不是四分之一，网络不可能知道。
结果呢
最后，这里是一些结果！
这个模型特别适合黑猫或白猫，可能是因为它们有最强烈的对比和最极端的颜色。
当我试图将输入压缩到原始大小的九分之一时，就会发生这种情况:
它基本上只得到正确的轮廓，而且只对黑色或深灰色的猫有效。
结论
我对结果感到惊讶:将图像压缩到其大小的四分之一，猫仍然可以被识别，这意味着分类器可能会告诉照片中有一只猫。
Tensorflow 现在的 API 比旧的舒服直观了很多，很高兴终于可以不用想着 sessions 和 graphs 做深度学习了。
我认为批量规范化被证明在加速训练方面非常有效，这是一个我应该经常使用的工具。
最后，将来我想尝试不同的图像压缩算法。k-意味着基于聚类的，可能是卷积自动编码器。然而，这是另一篇文章的想法。
你呢？你认为你能为这个数据集训练一个更好的自动编码器吗？我应该做得更好的 1000 件事情中的一些是什么，或者我忘记调整的超参数，可以极大地提高模型的性能？请在评论中告诉我，我仍在不断学习。
我希望你觉得这篇文章有趣或有帮助，也许你已经学到了一些东西。
如果你希望了解更多关于深度学习的知识，并成为这方面的专业人士，那么 Goodfellow 和 Bengio 的深度学习书籍绝对不会错。
它的第一章让深度学习最终为我点击，自动编码器上的那一章是纯金的。
关注我上 中*dev . to或Twitter获取更多机器学习教程。*
原载于 2019 年 4 月 20 日http://www . data stuff . tech*。*
股票市场时间序列压缩的自动编码器
用 Pythonic 探索不同的神经网络自动编码器来降低比特币价格时间序列的维度
摘要
股票市场数据空间是高度多维的，因此，试图利用价格形成中的潜在模式或结构的算法可能会遭受所谓的“维数灾难”。在这篇短文中，我们将探讨 4 种不同类型的自动编码器在较低和可追踪维度空间中捕捉股票市场价格动态信息的潜力。为此，我们将使用 Python 编程语言，并且作为示例，我们将把这些算法应用于比特币价格时间序列的压缩。构建神经网络模型的代码(使用 Keras 库)和所用的完整 Jupyter 笔记本可在文章末尾找到。
自动编码器的基础知识
自动编码器是一种输入和输出数据相同的神经网络。因此，它是所谓的无监督学习或自我监督学习的一部分，因为与监督学习不同，它不需要人工干预，如数据标记。正如我们将看到的，自动编码器的架构可能会有所不同，但一般来说，它包括一个编码器和一个解码器，前者将输入转换为低维表示，后者试图从低维表示中重建原始输入。因此，这些模型在中间存在某种“瓶颈”,迫使网络学习如何在低维空间中压缩数据。当训练这些算法时，目标是能够以最小量的信息损失来重建原始输入。一旦模型被训练，我们就可以通过只使用 autoencoder 的编码器组件随意压缩数据。
A representation of a basic autoencoder: an encoder maps the input X to a compressed representation in the bottleneck and a decoder tries to map the compressed representation to X’, which is the original input with a certain amount of information loss.
数据和目标
我们要使用的数据是从 2015 年 1 月 1 日开始到今天的 Coindesk 比特币价格指数的 1 小时烛台收盘价格组成的比特币时间序列。具体来说，我们将使用前 93%的数据作为训练数据集，最后 7%的数据作为测试数据集。比特币价格将被转换为对数回报(即价格 x+1 和价格 x 之间差额的对数)，并将产生 10 个连续回报的窗口。这些连续回报窗口中的每一个都将使用一个最小最大缩放器归一化到范围[0，1]。
不同自动编码器模型的目标是能够将 10 维输入压缩到 3 维潜在空间。这构成了一个 3.3 的缩减系数，它应该具有相当好的精度。
对于每个尝试的模型，我们将显示模型的摘要、在训练时期的每个阶段训练和测试数据集的损失，以及最后从测试数据集提取的 10 个随机选择的价格回报窗口的自动编码器的输入和输出(即模型没有看到这些数据点)。所选择的测试窗口将有意地在所有模型中保持相同，以便能够比较每个模型可能正在学习哪种特征。
第一个模型:一个简单的多层 percepetron (MLP)自动编码器
Layer (type) Output Shape Param #
=================================================================
input_2 (InputLayer) (None, 10) 0
_________________________________________________________________
dense_3 (Dense) (None, 3) 33
_________________________________________________________________
dense_4 (Dense) (None, 10) 40
=================================================================
Total params: 73
Trainable params: 73
Non-trainable params: 0
所使用的模型非常简单，但是输入和输出之间的比较揭示了网络提取一些重要特征(例如峰值和低谷)的能力。有趣的是，我们可以看到，尽管输入相当不同，但有些输出彼此几乎完全相同。
第二种模式:深度自动编码器
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_3 (InputLayer) (None, 10) 0
_________________________________________________________________
dense_5 (Dense) (None, 6) 66
_________________________________________________________________
batch_normalization_1 (Batch (None, 6) 24
_________________________________________________________________
dense_6 (Dense) (None, 3) 21
_________________________________________________________________
dense_7 (Dense) (None, 6) 24
_________________________________________________________________
batch_normalization_2 (Batch (None, 6) 24
_________________________________________________________________
dense_8 (Dense) (None, 10) 70
=================================================================
Total params: 229
Trainable params: 205
Non-trainable params: 24
尽管多了几个参数，但在考虑训练/测试损失时，我们似乎达到了类似的精度。然而，输入/输出示例显示了不同类型的图，其中大多数包含一个单独的低峰或高峰，这与之前的结果不同，之前的结果在中间范围内变化更大。
第三种模式:1D 卷积自动编码器
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_4 (InputLayer) (None, 10, 1) 0
_________________________________________________________________
conv1d_1 (Conv1D) (None, 10, 16) 64
_________________________________________________________________
max_pooling1d_1 (MaxPooling1 (None, 5, 16) 0
_________________________________________________________________
conv1d_2 (Conv1D) (None, 5, 1) 49
_________________________________________________________________
max_pooling1d_2 (MaxPooling1 (None, 3, 1) 0
_________________________________________________________________
conv1d_3 (Conv1D) (None, 3, 1) 4
_________________________________________________________________
up_sampling1d_1 (UpSampling1 (None, 6, 1) 0
_________________________________________________________________
conv1d_4 (Conv1D) (None, 5, 16) 48
_________________________________________________________________
up_sampling1d_2 (UpSampling1 (None, 10, 16) 0
_________________________________________________________________
conv1d_5 (Conv1D) (None, 10, 1) 49
=================================================================
Total params: 214
Trainable params: 214
Non-trainable params: 0
第三个模型变得有点有趣。在这个模型中，我们使用内核大小为 3 的卷积，其思想是这些卷积应该查看出现在 3 个返回组中的模式。结果令我吃惊。在大多数情况下，我们可以看到主要的“事件”被很好地表现出来，而整体重建非常平滑，因为我们对回报应用了移动平均。
第四款:LSTM 自动编码器
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_5 (InputLayer) (None, 10, 1) 0
_________________________________________________________________
lstm_1 (LSTM) (None, 3) 60
_________________________________________________________________
repeat_vector_1 (RepeatVecto (None, 10, 3) 0
_________________________________________________________________
lstm_2 (LSTM) (None, 10, 1) 20
=================================================================
Total params: 80
Trainable params: 80
Non-trainable params: 0
虽然诸如长短期记忆(LSTM)模型等递归神经网络特别适合处理时间序列，但我们可以看到，它们作为自动编码器的性能非常差。Goodfellow 等人在他们的著作《深度学习》中简明扼要地解释了这一点:
当递归网络被训练来执行需要从过去预测未来的任务时，网络通常学习使用 h(t)[压缩表示]作为一种对过去输入序列直到 t 的任务相关方面的有损汇总。这种汇总通常必然是有损的，因为它将任意长度的序列映射到固定长度的向量 h(t)。
[…]
最苛刻的情况是当我们要求 h(t)足够丰富以允许近似恢复序列时，如在自动编码器框架中。
好处:深度自动编码器+合成数据
自动编码器背后的思想是将原始的高维度降低到较低的维度。在我们的例子中，由于我们正在应用的规范化方案，这个高维空间的值在 0 和 1 之间是连续的。然而，人们可能会认为，如果我们将这个 0 到 1 的范围离散化为 10 个箱，突然之间，我们会将整个 0 到 1 的范围划分为 10 个简单的类别。现在，如果我们的窗口有 10 个返回长度，使用这个“离散化的”连续空间，我们可以很容易地生成 10 的 10 次方个不同的现有组合或“离散化的时间序列”。这个“合成”数据集可以用作训练数据集，几乎事实上丰富了我们的模型，并教会它理解比特币时间序列中欠采样的价格空间部分。多好的主意，不是吗？
或者……是吗？结果是苦乐参半。一些进展有了很大的改善(例如，将第一列与以前的模型进行比较)，但其他的进展非常糟糕(例如，第六列)。这让我想到，或许对整个可能性空间进行等概率采样并不是一个最佳的想法。通过对整个空间进行均等采样，我们正在迫使网络学会均等地压缩整个空间，而不管该空间是否实际上与代表比特币或股票价格相关。我们必须记住，像所有的神经网络一样，自动编码器是一个函数逼近器，因此它试图全局逼近我们在训练中使用的所有数据点。这种全局优化本质上意味着，为了更好地逼近某些值，在逼近其他值时必然会损失性能。这表明，为了使这个想法可行，我们应该找到更聪明的方法，只对相关空间进行采样，以便网络只在相关压缩时达到最佳状态。
未来工作
我们已经看到，自动编码器可以用来压缩股票收益的时间序列。如果目标仅仅是压缩数据，那么尝试其他经典的降维算法会很有意思，比如 PCA，它很可能在这个特定的任务中表现得更好。
然而，使用自动编码器的优点是，它的一些组件，如编码器，可以在几个独立的股票市场回报上单独训练，然后在其他端到端神经网络中重用，同时仍然保持通过反向传播进行全局优化的潜力。
我接下来想尝试的一些想法是:
- 使用来自非常不同的股票市场工具(例如，非加密货币或其他加密货币)和不同年份时间跨度的数据训练本文中描述的相同自动编码器，以查看在这里评估的完全相同的任务(比特币数据压缩)下性能是否提高。
- 将经过训练的编码器直接插入专门用于未来价格回报预测或 x+1 上涨/下跌价格预测的其他神经网络，并将其性能与直接接受原始价格回报而不是压缩表示的网络进行比较。
Jupyter 笔记本
像往常一样，这里的朱庇特笔记本重现了我的作品:
这个项目是我们在cryptodatum . io研究的一部分，这是一个加密货币数据 API，旨在提供即插即用的数据集来训练机器学习算法。如果您喜欢我们在本文中展示的数据，您可以在https://cryptodatum . io获得免费的 API 密钥并亲自使用它
自动编码器的直观解释
深度学习
以及如何在 Keras 中实现它们
Photo by Aditya Chinchure on Unsplash
动机
最近的许多深度学习模型依赖于从数据中提取复杂的特征。目标是将输入从其原始格式转换成由神经网络计算的另一种表示。该表示包含描述输入的隐藏唯一特征的要素。
考虑一个人脸数据集，其中每个输入都是一个人的图像。原始格式的图像表示太复杂，机器无法使用。相反，为什么不让神经网络自动计算每张脸的重要特征，比如:眼睛类型、鼻子类型、两眼之间的距离、鼻子位置等。嗯，这听起来很有趣…使用这些功能，我们可以很容易地比较两张脸，找到相似的脸，生成新的脸，以及许多其他有趣的应用。
这个概念被称为编码，因为我们正在生成数据的编码版本。在本文中，我们将了解更多关于编码的内容，如何使用自动编码器计算它们，以及最终如何在 Keras 中实现它们。
自动编码器
一个自动编码器是一个奇怪的神经网络，因为它的输入和输出是相同的。所以，它是一个试图自我学习的网络！我知道这很疯狂，但是你会明白为什么这很有用。
假设我们有以下神经网络:
- 有 100 个神经元的输入层
- 具有 3 个神经元的隐藏层
- 具有 100 个神经元的输出层(与输入层相同)
Image by Author
现在，如果我们让神经网络接受输入，并试图预测输出中的相同值，会发生什么？这不就意味着网络学会了如何只用 3 维*(隐藏层中的神经元数量)*来表示 100 维输入，然后再次重建相同的输入吗？此外，这些三维或特征似乎足以表示输入值所描述的内容。这很有趣。这就像压缩文件一样。我们减小了文件大小，但我们可以再次解压缩它，并获得相同的数据。事实上，在自动编码器中数据并不完全相同，因为它们是有损耗的，但是你明白了。
目标
我们将使用著名的 MNIST 数字数据集来演示这个想法。目标是从给定的 28*28 图像生成 2D 编码。因此，我们正在使用自动编码器实现一个降维算法！酷吧？让我们开始…
编码时间
首先，我们导入数据集:
from keras.datasets import mnist
(data, labels), (_, _) = mnist.load_data()
需要重塑和调整:
data = data.reshape(-1, 28*28) / 255.
是时候定义网络了。我们需要三层:
- 大小为 28*28 的输入层
- 大小为 2 的隐藏层
- 大小为 28*28 的输出图层
Image by Author
from keras import models, layers
input_layer = layers.Input(shape=(28*28,))
encoding_layer = layers.Dense(2)(input_layer)
decoding_layer = layers.Dense(28*28) (encoding_layer)
autoencoder = models.Model(input_layer, decoding_layer)
让我们编译和训练…我们将使用像素值之间的二元交叉熵损失来拟合模型:
autoencoder.compile('adam', loss='binary_crossentropy')
autoencoder.fit(x = data, y = data, epochs=5)
你注意到这个窍门了吗？ X =数据和 y =数据也是如此。
在拟合模型之后，网络应该学习如何计算隐藏编码。但我们还是要提取出对此负责的那一层。在下文中，我们定义了一个新模型，其中我们删除了最后一层，因为我们不再需要它:
encoder = models.Model(input_layer, encoding_layer)
现在，我们不再预测最终输出，而是只预测隐藏的表示。看看我们如何使用它:
encodings = encoder.predict(data)
就是这样！现在你的编码变量是一个(n，m)数组，其中 n 是例子的数量，m 是维数。第一列是第一个特征，第二列是第二个特征。但是那些特征是什么呢？事实上，我们不知道。我们只知道它们是每个输入值的良好代表。
让我们把它们画出来，看看我们会得到什么。
import matplotlib.pyplot as plt
plt.scatter(encodings[:, 0], encodings[:, 1], c=labels)
plt.colorbar()
Image by Author
漂亮！看看神经网络是如何学习隐藏特征的。显然，它学会了每个数字的不同特征，以及它们在 2D 空间中的分布。现在，我们可以将这些功能用于可视化、聚类或任何其他目的…
最终想法
在这篇文章中，我们学习了自动编码器以及如何应用它们进行降维。自动编码器非常强大，并在许多现代神经网络架构中使用。在以后的文章中，您将了解更复杂的编码器/解码器网络。
如果你喜欢这篇文章，请点击“鼓掌”按钮，我将不胜感激👏所以可能会传染给他人。也可以在 推特 ， 脸书 ， 上关注我直接发邮件给我 或者在LinkedIn上找我。
自动编码器与 PCA:何时使用？
降维需求
在机器学习项目中，我们经常遇到维数灾难问题，其中数据记录的数量不是特征数量的重要因素。这通常会导致问题，因为这意味着使用稀缺的数据集训练大量的参数，这很容易导致过度拟合和泛化能力差。高维数也意味着非常大的训练时间。因此，降维技术通常被用来解决这些问题。尽管特征空间存在于高维空间中，但它通常具有低维结构。
两种非常常见的降低特征空间维数的方法是 PCA 和自动编码器。我将只提供对这些的简要介绍，更多理论性的比较请看这篇的帖子。
PCA
PCA 本质上学习将数据投影到另一个空间的线性变换，其中投影的向量由数据的方差定义。通过将维度限制到占数据集方差大部分的特定数量的组件，我们可以实现维度减少。
自动编码器
自动编码器是神经网络，可用于通过堆叠多个非线性变换(层)将数据减少到低维潜在空间。他们有一个编码器-解码器架构。编码器将输入映射到潜在空间，解码器重构输入。使用反向传播对它们进行训练，以精确重建输入。在潜在空间具有比输入更低的维数时，自动编码器可以用于维数减少。凭直觉，这些低维潜变量应该编码输入的最重要的特征，因为它们能够重构输入。
对比
- PCA 本质上是线性变换，但是自动编码器能够模拟复杂的非线性函数。
- PCA 特征彼此完全线性不相关，因为特征是到正交基的投影。但是自动编码的特征可能具有相关性，因为它们只是为了精确重建而被训练的。
- PCA 比自动编码器速度更快，计算成本更低。
- 具有线性激活功能的单层自动编码器非常类似于 PCA。
- 由于参数数量太多，自动编码器容易过拟合。(尽管规范化和精心设计可以避免这种情况)
什么时候用哪个？
除了对计算资源的考虑，技术的选择取决于特征空间本身的性质。如果这些特征彼此之间具有非线性关系，那么 autoencoder 将能够更好地将信息压缩到低维潜在空间中，利用其模拟复杂非线性函数的能力。特征具有非线性关系意味着什么？让我们做几个简单的实验来回答这些问题，并阐明这两种技术的相对有用性。
实验 2D
这里，我们构建二维特征空间(x 和 y 是两个特征),它们之间具有线性和非线性关系(具有一些附加噪声)。我们将比较自动编码器和 PCA 在将输入投影到潜在空间后准确重建输入的能力。PCA 是具有明确定义的逆变换的线性变换，并且来自 autoencoder 的解码器输出给我们重构的输入。我们对 PCA 和自动编码器都使用一维潜在空间。
显然，如果在特征空间中存在非线性关系(或曲率),自动编码的潜在空间可以用于更精确的重建。其中由于 PCA 仅保留到第一主分量上的投影，任何垂直于它的信息都丢失了。让我们看看下表中由均方误差(MSE)测量的重建成本。
实验 3D
进行类似的 3D 实验。我们创建两个三维特征空间。一个是存在于 3D 空间中的 2D 平面，另一个是 3D 空间中的曲面。
我们可以看到，在平面的情况下，数据具有清晰的二维结构，具有两个分量的 PCA 可以解释数据的 100%的方差，因此可以实现完美的重建。在曲面的情况下，二维 PCA 不能解释所有的变化，因此丢失了信息。覆盖大部分方差的到平面的投影被保留，而其他信息丢失，因此重建不是那么精确。另一方面，autoencoder 能够使用二维潜在空间精确地重建平面和曲面。因此，在自动编码器的情况下，2D 潜在空间能够编码更多的信息，因为它能够非线性建模。下表提供了重建成本。
随机数据实验
这里我们创建一个没有任何共线性的随机数据。所有特征都是从均匀分布中独立采样的，彼此之间没有关系。我们对 PCA 和自动编码器都使用二维潜在空间。
我们看到，PCA 能够以最大的方差保留在平面上的投影，并且丢失了许多信息，因为随机数据不具有基本的 2 维结构。Autoencoder 也表现不佳，因为功能之间没有潜在的关系。
结论
为了使降维有效，在特征空间中需要有底层的低维结构。即这些特征应该彼此具有某种关系。
如果在低亮度结构中存在非线性或曲率，则自动编码器可以使用更少的维度来编码更多的信息。因此，在这些情况下，它们是更好的降维技术。
实验的所有代码都可以在这里找到:
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/muaz-urwa/PCA-vs-AutoEncoders)
自动增长:深度学习自动
用 3 行 Python 代码实现最先进的结果
作者:*、乔纳斯·穆勒、* 杭张 、巴拉吉·卡马科蒂
感谢亚伦·马卡姆、李牧、马蒂亚斯·西格、塔利亚·乔普拉和盛扎的早期反馈和编辑。
引入自动旋转
autoglon是一个新的开源 AutoML 库，它为涉及图像、文本和表格数据集的真实世界应用程序自动化深度学习(DL)和机器学习(ML)。无论您是 ML 新手还是经验丰富的从业者，AutoGluon 都会简化您的工作流程。有了 AutoGluon，您只需使用几行 Python 代码就可以开发和改进最先进的 DL 模型。在这篇文章中，我们解释了自动增长的好处，演示了如何在 Linux 上安装它，并开始使用自动增长在几分钟内以最先进的性能解决现实世界的问题。
动机和主要特征
从历史上看，实现最先进的 ML 性能需要广泛的背景知识、经验和人力。数据准备、特征工程、验证分割、缺失值处理和模型选择只是 ML 应用中必须解决的许多任务中的一部分。一个特别困难的任务是超参数的选择。
*超参数表示用户在构建模型时必须做出的许多选择，例如数据处理步骤、神经网络体系结构和训练期间使用的优化器。每个超参数都以不透明的方式影响最终模型的预测性能，而更强大的模型(如深度神经网络)需要调整的超参数越来越多。轻微的超参数修改可能会显著改变模型质量。由于通常不清楚如何做出这些决定，开发人员通常手动调整他们的 ML 管道的各个方面，以便在实践中实现强大的预测性能，这可能需要许多迭代和艰苦的人力努力。AutoGluon 自动执行前面提到的所有任务，创造一种真正脱离方向盘的体验。您不必花费宝贵的时间来管理这些实验或首先学习如何做这些实验，您可以简单地指定您希望何时准备好训练好的模型，AutoGluon 将利用可用的计算资源在其分配的运行时间内找到最强的 ML 方法。
autoglon 使您能够在图像分类、对象检测、文本分类和使用表格数据集的监督学习等任务上自动实现一流的性能。每个任务的超参数是使用高级调整算法自动选择的，如贝叶斯优化、超带和强化学习。有了 AutoGluon，您不需要对底层模型有任何了解，因为所有的超参数都将在默认范围内自动调整，这些范围对于特定的任务和模型来说是已知的。
对于专业的 ML 从业者来说，自动生成允许这个过程被容易地定制。例如，您可以为某些超参数指定要考虑的值范围，还可以使用自动优化来自动调整您自己的定制模型的各个方面。如果您可以访问多台机器，AutoGluon 可以轻松地在它们之间分配计算，以便更快地返回训练好的模型。*
通过实例自动增长
装置
*在训练模型之前，你必须安装自动旋翼。Linux 支持自动登录，MacOS 和 Windows 支持即将推出。可以通过遵循此处的安装说明[来安装自动旋翼。
本演示使用了一台带 GPU 的 Linux 机器。要安装支持 GPU 的 Linux 版 AutoGluon，请在“终端”中运行以下命令，或者参考安装 wiki 中的仅 CPU 安装:](https://auto.gluon.ai/stable/index.html#installation)*
*# CUDA 10.0 and a GPU for object detection is recommended
# We install MXNet to utilize deep learning models
pip install --upgrade mxnet-cu100
pip install autogluon*
对象检测示例
我们以目标检测任务为例，展示了 AutoGluon 的简单接口。在目标检测中，不仅要识别图像中的目标，还要用包围盒来定位它们。
我们将使用自动旋翼在一个为演示目的而创建的小玩具数据集上训练一个物体检测器(以确保快速运行)。该数据集是使用 VOC 数据集 [1]的摩托车类别生成的。在下面的 Python 代码中，我们首先导入 AutoGluon，将对象检测指定为感兴趣的任务(ObjectDetection as task)，将数据下载到我们的机器上，最后将其加载到 Python 中:
*import autogluon as ag
from autogluon import ObjectDetection as taskurl = '[https://autogluon.s3.amazonaws.com/datasets/tiny_motorbike.zip](https://autogluon.s3.amazonaws.com/datasets/tiny_motorbike.zip)'
data_dir = ag.unzip([ag.download](http://ag.download/)(url))
dataset = task.Dataset(data_dir, classes=('motorbike',))*
接下来，我们可以通过简单地调用fit()函数来使用自动旋转训练检测器模型:
*detector = task.fit(dataset)*
在这个对fit()的单次调用中，AutoGluon 在不同的网络配置和优化超参数下训练了许多模型，选择其中最好的作为最终返回的检测器。在没有任何用户输入的情况下，对fit()的调用也自动利用了最先进的深度学习技术，如预训练的 YOLOv3 网络的迁移学习。我们可以使用predict()方法在新图像上测试训练过的检测器:
*url = '[https://autogluon.s3.amazonaws.com/images/object_detection_example.png](https://autogluon.s3-us-west-2.amazonaws.com/images/object_detection_example.png)'
filename = ag.download(url)
index, probabilities, locations = detector.predict(filename)*
AutoGluon 的预测功能会自动加载测试图像，并输出每个检测到的对象的预测对象类别、类别概率和边界框位置。如上所示，可视化图像被自动生成。我们可以看到，尽管只在非常小的数据集上训练我们的检测器，但摩托车还是以合理的精度被检测和定位。有关使用自动旋转进行物体检测的完整教程，请访问自动旋转网站。
表格数据示例
最常见的数据形式是表格数据集。这些由通常在逗号分隔文件(CSV)或数据库中找到的结构化数据组成。在表格数据集中，每列代表某个变量的测量值(又名特性*)，行代表单个数据点。自动增长可用于训练模型，这些模型根据同一行中的其他列来预测特定列的值，并且能够推广到以前看不到的示例。
我们将要训练的数据集是成人收入分类数据集【2】。该数据集包含约 48，000 人的信息，包括年龄等数字特征和职业等分类特征。数据集通常用于预测个人收入。在本例中，我们将预测个人年收入是否超过 50，000 美元。我们将使用 80%的数据来训练自旋转，20%的数据来测试产生的自旋转预测器。使用自动引导，不需要指定验证数据。AutoGluon 将使用提供的训练数据以最佳方式分配验证集。
作为一个例子，我们提供了 Python 代码，该代码首先导入自动登录并指定一个task，在这里我们将使用TabularPrediction处理表格数据。然后，我们从位于 S3 的 CSV 文件中加载Dataset。只需对fit()进行一次调用，AutoGluon 就会处理数据，并训练一个称为“预测器”的多样化 ML 模型集合，该模型能够预测该数据中的“类别”变量。它将使用其他列作为预测特征，如个人的年龄、职业和教育。这个模型集合包括在 ML 竞争社区中因其质量、鲁棒性和速度而闻名的经过验证和测试的算法，如 LightGBM 、 CatBoost ，以及持续优于更传统的 ML 模型(如逻辑回归)的深度神经网络。
注意，我们不需要做任何数据处理、特征工程，甚至不需要声明预测问题的类型。AutoGluon 自动准备数据，推断我们的问题是回归还是分类(包括是二元还是多类)。经过训练的预测器模型将保存到 task.fit()调用中指定的位置。*
*from autogluon import TabularPrediction as task
train_path = 'https://autogluon.s3.amazonaws.com/datasets/AdultIncomeBinaryClassification/train_data.csv'
train_data = task.Dataset(file_path=train_path)
predictor = task.fit(train_data=train_data, label='class', output_directory='ag-example-out/')*
现在我们的预测模型已经训练好了，我们将对以前看不到的测试数据进行预测。我们既可以直接使用返回的预测值，也可以从我们指定的输出目录中加载它。
*predictor = task.load('ag-example-out/')
test_path = 'https://autogluon.s3.amazonaws.com/datasets/AdultIncomeBinaryClassification/test_data.csv'
test_data = task.Dataset(file_path=test_path)
y_test = test_data['class']
test_data_nolabel = test_data.drop(labels=['class'],axis=1)
y_pred = predictor.predict(test_data_nolabel)
y_pred_proba = predictor.predict_proba(test_data_nolabel)
print(list(y_pred[:5]))
print(list(y_pred_proba[:5]))*
*[’ <=50K’, ‘ <=50K’, ‘ > 50K ‘，’<=50K’, ‘ <=50K’]
[0.077471，0.0093894，0.973065，0.0021249，0.001387]
现在我们来看看车型排行榜:*
*leaderboard = predictor.leaderboard(test_data)*
AutoGluon’s model leaderboard
*该排行榜显示了由 AutoGluon 训练的每个模型，它们在测试和验证数据上的分数，以及以秒为单位的训练时间。可以看出，weighted_ensemble在验证和测试集上表现最好，达到了 87.76%的准确率，对于这个问题来说是一个非常强的结果 [3]。
有关使用自动增长对表格数据进行监督学习的完整教程，请参见自动增长表格预测教程。*
了解更多并做出贡献
在这篇文章中，我们介绍了 AutoGluon，这是我们为给 ML 专家和新人提供最好的 ML 和深度学习体验而做出的微薄努力。该库不仅易于使用，而且能够在各种应用中实现优于其他 ML 方法的高质量模型。虽然这篇文章关注的是使用表格数据进行对象检测和预测，但自动生成也可以轻松应用于其他任务，包括文本和图像分类。AutoGluon 甚至可以用于细化涉及定制模型的任意 ML 任务(在 MXNet 和 PyTorch 中)。我们欢迎社区参与我们的旅程。前往autoglon GitHub 库开始，并查看autoglon 网站上的教程，在您的应用中快速尝试复杂的 AutoML 解决方案。我们渴望听到您的结果和反馈！
引文
[1] Everingham，Mark 等人，“pascal 视觉对象类挑战:回顾”国际计算机视觉杂志111.1(2015):98–136。
[2]杜瓦和格拉夫(2019)。UCI 机器学习知识库[http://archive . ics . UCI . edu/ml]。加州欧文:加州大学信息与计算机科学学院。
[3]华金·范肖伦、扬·范里恩、贝恩德·比什尔和路易斯·托戈。OpenML:机器学习中的网络科学。SIGKDD 探索 15(2)，第 49–60 页，2013 年。
资源
autoglon 网站
autoglon Github 资源库
潜入深度学习
MXNet 胶子
通过无监督学习自动清理数据
为您的 NLP 项目清理文本从未如此有趣和容易！
Photo by Karim MANJRA on Unsplash
我喜欢处理文本数据。至于计算机视觉，现在 NLP 中有很多现成的资源和开源项目，我们可以直接下载或使用。其中一些很酷，允许我们加快速度，把我们的项目带到另一个水平。
最重要的是，我们不能忘记，所有这些工具都不是魔法。他们中的一些人宣称有很高的表现，但如果我们不允许他们做到最好，他们就什么都不是。这是一个严酷的事实，尤其是在 NLP 领域，我们经常面临数据中很难去除的高水平噪声(比处理图像更困难)。
在这篇文章中，我提出了我的解决方案来提高我所掌握的文本数据的质量。我开发了一个工作流程，旨在以无人监管的方式自动清理数据。我说*‘自动’*是因为如果我们不得不一直手动检查数据以理解模型输出的内容，那么遵循无监督的方法是没有用的。我们需要确定性，不想浪费时间。
数据集
在这里，我的目标是“清洗”研究论文。在这种情况下，清理意味着保留文本的相关部分，丢弃不包含有价值信息的部分。在机器学习论文的子集中，我认为文本句子是相关的部分，而包含大多数代数和符号的部分是无用的。直接访问这些片段可以简化诸如主题建模、摘要、聚类等任务。
我在 Kaggle 上找到了 NIPS 2015 论文’数据集。我直接下载 Paper.csv. 这个数据集包含了 NIPS 2015 ( 神经信息处理系统)的 403 篇论文；世界顶级机器学习会议之一，主题涵盖从深度学习和计算机视觉到认知科学和强化学习)。
Topic Modelling on NIPS papers by Kaggle
工作流程
- 选择一篇论文，应用基本的预处理将它分成句子/段落
- 创建句子的加权嵌入
- 嵌入空间中句子的无监督模型化
- 噪声文本的检测和表示
这种能力是通过使用预训练的单词嵌入模型及其相对较深的词汇表来提供的。
预处理
我计算了一个标准的预处理，从感兴趣的单个文件中删除数字，而不是字母数字字符和停用词。这里的要点是通过句子/段落的创建来提供的。有一些软件包提供这种功能；我试过了，但是他们并没有说服我。因此，当我处理来自整个文档的文本语料库时，我自己编写了更好地满足我需要的简单函数。
from nltk.corpus import stopwords
from gensim.parsing.preprocessing import *stop_words = set(stopwords.words('english'))def create_sentence(text):
output = []
for s in re.split('\.\n|\.\r\n|\. ', text):
output.extend(re.split('\n\n|\r\n\r\n', s))
return outputdef clean_sentence(sentence):
sentence = strip_numeric(strip_non_alphanum(sentence))
sentence = sentence.lower().split()
return [w for w in sentence if w not in stop_words]
句子嵌入
一个好的句子的数字表示是整个程序成功的基础。我们希望有意义的句子在嵌入空间中彼此相似且更近，同时我们希望有噪声的句子远离有意义的句子，并且它们之间也相似。为了实现这一关键步骤，我们使用了强大的预训练单词嵌入，我选择了 GloVe。
我们创建句子嵌入作为单个单词嵌入的加权平均值。通过计算由句子组成的论文语料库上的 TfIdf 来给出权重。在组合期间，对于特定句子中的每个单词，我们选择相对手套嵌入(如果存在)并将其乘以 TfIdf 单词权重。每个句子中加权单词嵌入的总和被归一化，除以句子中 TfIdf 单词权重的总和。
emb_dim = 300
model = KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin', binary=True)tfidf = TfidfVectorizer()
tfidf.fit(list(map(' '.join, cleaned_corpus)))
为了让这个过程变得简单和轻松，我选择了 Gensim 来加载和操作手套。Gensim 需要*。手套的 bin* 格式(此处有和其他文件格式)；随意使用你喜欢的阅读方法。
def calculate_emb(clean_text, original_text):
tfidf_feat = tfidf.get_feature_names()
tfidf_emb = tfidf.transform(list(map(' '.join, clean_text)))
final_sent_emb = []
final_sent = []
for row, sent in enumerate(tqdm(clean_text)):
sent_vec = np.zeros(emb_dim)
weight_sum = 0
for word in sent:
try:
vec = model[word]
tfidf_score = tfidf_emb[row, tfidf_feat.index(word)]
sent_vec += (vec * tfidf_score)
weight_sum += tfidf_score
except:
passif sum(sent_vec)!=0:
sent_vec /= weight_sum
final_sent.append(original_text[row])
final_sent_emb.append(sent_vec)
final_sent_emb = np.asarray(final_sent_emb)
final_sent = np.asarray(final_sent)
return final_sent_emb, final_sent
用这种方法计算句子嵌入，我们已经自由地得出了第一个重要的结果。手套词汇中不存在的单词(3000000 个唯一单词)不被考虑在内(如果不在手套中它就不存在)，即它们是非常不常见的术语，我们可以将它们视为噪音。现在想象一个全是不常见符号的句子，它以全零的嵌入结束，我们可以立即排除它。
无监督模型化和表示
如上所述，为语料库中的每个句子计算句子嵌入的创建。我们以一个维数为(N，300)的数组结束，其中 N 是句子的数量，300 是手套嵌入维数。为了便于管理，我们用主成分分析法对它们进行降维，并在降维后的空间上应用无监督异常检测算法。我们的异常点显然位于远离密度中心的地方。
2D representation of sentence embeddings
这些异常点(句子)的检测对于隔离林来说是一项完美的任务。这个集合模型在子群中操作空间的划分:将一个样本从其他样本中分离出来所需的分裂次数越少，这个观察结果成为异常的概率就越高。
pca = PCA(n_components=2)
X = pca.fit_transform(final_sent_emb)IF = IsolationForest(contamination=0.3, behaviour='new')
IF.fit(X)plt.figure(figsize=(8,6))
plt.scatter(X.T[0], X.T[1], c=IF.predict(X), cmap='viridis')
Isolation Forest at work on sentence embeddings
我们的工作已经完成，我们只需要检查结果！黄色部分是有价值的句子和嘈杂的文字部分。为了达到这个结果，我们只需要设置“污染参数”,它告诉我们丢弃信息的严重程度。下面我附上了我刚刚分析的论文中的一个例子。第一个片段显示了有价值的句子，其中包含有用的信息。
Good sentences
第二个片段是一个句子的集合，其中可能包含很多噪音。
Bad sentences
摘要
在这篇文章中，我开发了一个自动清理文本数据的解决方案。给定一个文本语料库，我们能够选择最有价值的句子，扔掉嘈杂的文本部分。这种解决方案的目标是计算成本不高；我们使用了预先训练的单词嵌入，并拟合了一个简单的异常句子检测算法。整个工作流程可以扩展到文本语料库的收集，始终遵循无监督的方法。
保持联系: Linkedin
为您的模型自动调整超参数
Photo by Marcin Nowak on Unsplash
因为你的时间比机器更重要
当我们创建我们的机器学习模型时，我们面临的一个常见任务是如何调整它们。
人们最终采取不同的手动方法。有些有效，有些无效，大量时间花在预测和一遍又一遍地运行代码上。
这就给我们带来了一个本质问题:我们能自动化这个过程吗？
不久前，我正在参加 Coursera 课程的 【如何赢得数据科学竞赛】 的一次课堂竞赛。学到了很多新东西，其中之一就是 Hyperopt——一个贝叶斯参数调整框架。
我很惊讶。晚上我把我的 Mac 和远视留在一起了。早上我拿到了结果。这太棒了，我确实避免了很多尝试。
这个帖子是关于自动化超参数调优的，因为我们的时间比机器更重要。
那么，什么是远视呢？
从 Hyperopt 网站:
Hyperopt 是一个 Python 库，用于对笨拙的搜索空间进行串行和并行优化，搜索空间可能包括实值、离散和条件维度
简单来说，这意味着我们得到了一个可以最小化/最大化任何函数的优化器。 例如，我们可以用这个来最小化日志损失或最大化准确性。
我们都知道网格搜索或随机网格搜索是如何工作的。
网格搜索逐个遍历参数，而随机搜索随机遍历参数。
因此，Hyperopt 旨在以一种明智的方式搜索参数空间。
细节我就不多说了。但是如果你想知道更多关于它是如何工作的，看看 J Bergstra 的这篇 论文 。下面是来自 Github 的 文档 。
我们的数据集
为了解释 hyperopt 是如何工作的，我将处理来自 UCI 的心脏数据集，因为它是一个简单的数据集。除了产生利润之外，为什么不利用数据科学做些好事呢？
给定一些变量，该数据集预测心脏病的存在。
这是数据集的快照:
目标分布如下所示:
远视循序渐进
因此，在尝试运行 hyperopt 时，我们需要创建两个 Python 对象:
- 一个目标函数: 目标函数以超参数空间为输入，返回损失。这里我们称我们的目标函数为
objective - 一个超参数的字典: 我们将通过使用变量
space来定义一个超参数空间，这个变量实际上只是一个字典。我们可以为不同的超参数值选择不同的分布。
最后，我们将使用 hyperopt 包中的fmin功能，通过space最小化我们的objective。
你可以跟随这个 Kaggle 内核中的代码。
1.创建目标函数
这里，我们创建一个目标函数，它将一个超参数空间作为输入:
- 我们首先定义一个分类器，在本例中是 XGBoost。试着看看我们如何从空间获取参数。例如
space[‘max_depth’] - 我们使分类器适合训练数据，然后在交叉验证集上进行预测。
- 我们计算想要最大化或最小化的所需指标。
- 因为我们只在 hyperopt 中最小化使用
fmin,如果我们想最小化logloss,我们只发送我们的度量。如果我们想最大限度地提高精度，我们将尽量减少-accuracy
2.为您的分类器创建空间
现在，我们 为分类器创建超参数 的搜索空间。
为此，我们最终使用了许多定义各种分布的 hyperopt 内置函数。
正如您在下面的代码中看到的，我们对subsample超参数使用 0.7 到 1 之间的均匀分布。我们还给出了子样本参数x_subsample的标签。您需要为您定义的每个超参数提供不同的标签。我通常在我的参数名前添加一个x_来创建这个标签。
你也可以定义很多其他的发行版。hyperopt 优化算法目前认可的一些最有用的随机表达式是:
hp.choice(label, options)—返回选项之一，应为列表或元组。hp.randint(label, upper)—返回范围[0，上限]内的随机整数。hp.uniform(label, low, high)—统一返回一个介于low和high之间的值。hp.quniform(label, low, high, q)—返回一个类似 round(uniform(low，high) / q) * q 的值hp.normal(label, mu, sigma)—返回一个正态分布的实数值，其平均值为μ，标准差为σ。
还有很多其他发行版。你可以点击查看。
3.最后，运行 Hyperopt
一旦我们运行这个，我们就能得到模型的最佳参数。事实证明，我们在这个问题上做到了 90%的准确率。
现在我们可以用这些最佳参数重新训练我们的 XGboost 算法，我们完成了。
结论
运行上面的程序给我们的学习算法提供了很好的超参数。这让我节省了很多时间去思考各种其他的假设并测试它们。
我倾向于在调优我的模型时大量使用这个。 根据我的经验，整个过程中最关键的部分是建立超参数空间，这需要经验和对模型的了解。
所以，Hyperopt 是一个非常棒的工具，但是千万不要忘记理解你的模型是做什么的。从长远来看，这是很有帮助的。
你可以在这个 Kaggle 内核中获得完整的代码。
继续学习
如果你想了解更多关于实用数据科学的知识，请看看 Coursera 的 “如何赢得数据科学竞赛” 课程。从这个课程中学到了很多新的东西，这个课程是由最多产的卡格勒教授的。
还有另一个叫做 Optuna 的框架，你可以用它来代替 Hyperopt。在这里阅读。
谢谢你的阅读。将来我也会写更多初学者友好的帖子。在关注我或者订阅我的 博客 了解他们。一如既往，我欢迎反馈和建设性的批评，可以通过 Twitter @mlwhiz 联系。
此外，一个小的免责声明-在这篇文章中可能会有一些相关资源的链接，因为分享知识从来都不是一个坏主意。
使用 Prisma Media Plan 和 Python 为媒体机构实现网站服务报告自动化
Photo by Franck V. on Unsplash
为了拥有有效的媒体，媒体计划必须利用多种分销渠道(即数字显示、电视、 OOH )。有研究表明，开展跨渠道营销活动可以显著提升业绩。这些营销计划的一个关键组成部分是使用出版商自己跟踪广告，而不是通过广告服务器。在行业中，由发布者手动跟踪的广告被标记为“站点服务”。在这些情况下，代理商依赖于出版商提供与这些广告相关的相关数据(印象、点击等)。
从我的经验来看，从出版商收集这些数据的过程通常遵循这些特定的步骤:为特定的出版商制定网站服务布局的子集媒体计划，创建具有所有所需指标(印象、视频观看等)的 excel 报告模板，将 excel 模板发送给出版商填写，出版商发回数据。传统上，这是一个高度手工的过程，通常由媒体购买者自己进行。本文的范围集中在将模板发送给出版商之前的所有步骤的自动化上。我们将使用 python 作为我们的首选语言。这是自动化站点服务报告系列的第 1 部分，共 2 部分。第 2 部分将介绍如何在电子邮件中发送模板。
我们从导入这个项目所需的包开始。由于大多数 excel 电子表格的表格性质，在我们的例子中是媒体计划，Pandas 包的 DataFrame 将是在 python 环境中操作数据的绝佳选择。xlsxwriter 是一个包，它允许我们将数据帧写入 excel 工作表。虽然我们可以通过简单的 Pandas 来实现，但是 xlsxwriter 允许更深入的 excel 操作。
import pandas as pd
import xlsxwriter
我还假设你的媒体计划有某种级别的清理数据(放置级别的粒度，如果需要，请阅读这篇文章作为参考)。
#Read in Prisma Media Plan file
mp = pd.read_excel(‘Media Plan File’)"""Create day level of granularity"""#Create date range of placements
mp[‘Date Range’] = (pd.to_datetime(mp[‘End Date’]) — pd.to_datetime(mp[‘Start Date’])).dt.days#Use Date Range to repeat placement
mp = mp.reindex(mp.index.repeat(mp[‘Date Range’]))#Filter out placements that are site served
mp = mp['Placement Name'].str.contains('_SiteServed_')
在对媒体计划进行一些简单的操作后，我们需要按出版商对媒体计划进行分组，因为每个出版商只负责他们的广告投放。在那里，我们使用列表理解来划分出版者和他们各自的内容。
SiteGroup = mp.groupby(‘Site’)vendorList= [contents for vendor, contents in SiteGroup]
计算机编程最好的方面之一是能够有效地循环函数，利用计算机的能力来做它们最擅长的事情:计算。因此，在本例中，我们将遍历 vendorList 列表，以便为每个供应商创建模板。
for vendor in vendorList:
#Creating the export excelName; setting by the first Campaign name and Supplier value
请注意，以下所有代码都将嵌套在前一个循环中。在这一步中，我们将从我们的 vendorList 列表中获取活动和出版商的名称，用于命名我们的 excel 模板文件。
campaignName = vendor[‘Campaign Name’].iloc[0]
supplierName = vendor[‘Site’].iloc[0]
string = (‘{0}_{1}’+’.xlsx’).format(campaignName, supplierName)
现在我们开始实际创建 excel 模板。我们首先调用一个带有熊猫数据帧的实例，用 xlsxwriter 作为引擎。然后，我们从 vendorList 列表中取出我们的供应商变量，并将该数据插入到我们的 writer 实例中，从而用数据填充 excel 表格。之后，我们创建一个工作簿和工作表实例来与 excel 工作表交互。我们将 excel 表格命名为“站点”。
writer = pd.ExcelWriter(string, engine=’xlsxwriter’)
vendor.to_excel(writer, sheet_name=’SITE’,index=False)
workbook = writer.book
worksheet = writer.sheets[‘SITE’]
与发布者处理网站服务报告的一个关键问题是，他们有时会修改我们提供的模板，以包含其他可能有帮助的指标。然而，如果由于某种原因这造成了障碍，我们可以应用一个宏来防止对我们的 excel 模板的任何修改。这是通过我们附加到工作表实例上的 protect 属性实现的。但是因为我们确实需要发布者在 excel 模板中输入数据，所以我们创建了一个允许解锁某些列的格式，从而允许输入数据。
worksheet.protect()
unlocked = workbook.add_format({‘locked’: 0})
在我们修改的下一段代码中，将出现在模板中的列。我们创建了文本换行格式，以确保单元格中的所有文本都能正确显示。然后，我们为发布者输入数据的地方标记四个列标题。然后我们解锁这些列，以允许使用我们之前创建的解锁格式输入数据。
text_format = workbook.add_format({‘text_wrap’: True})worksheet.write(‘F1’,’Publisher Impressions’)
worksheet.write(‘G1’,’Publisher Clicks’)
worksheet.write(‘H1’,’Video: Starts’)
worksheet.write(‘L1’,’Video: 100% Complete’)#where the vendors will input data
worksheet.set_column(‘F2:O2’,25,unlocked)
在电子表格中看到任何文本被未展开的单元格截断，这可能是 MS excel 中最难看的事情之一。因此，在接下来的几行中，我们调整列以显示适当的长度来容纳全文。
worksheet.set_column(‘A:B’,vendor[‘Campaign Name’].map(len).max(),text_format)
worksheet.set_column(‘C:C’,vendor[‘Placement’].map(len).max(),text_format)worksheet.set_column(‘D:D’,15)
worksheet.set_column(‘E:Z’,25)
我们最后关闭工作簿并保存 excel 模板。
workbook.close()
writer.save()
完整代码见下文
回顾一下，我们已经编写了一个 python 脚本，解析出媒体计划中的现场投放，并为发布者创建一个 excel 模板，然后填写以满足报告需求。在项目实施过程中可能出现的问题包括广告位的命名惯例、广告位的突然变更但未反映在媒体计划中，以及许多其他微小的变化。
该项目的下一步将是自动化与发送 excel 模板给出版商相关的电子邮件。
在一个理想的世界(以媒体代理为中心的世界)，网站服务将被取消，所有的交易将通过你选择的广告服务器(可能是 DCM，实际上最有可能是 DCM…)完成。然而，在我看来，下一个最好的事情是在出版商之间统一一个 API，我们可以手动调用他们的服务器来获取印象和其他指标。但目前我们所能做的最好的事情是尽量减少错误，并使出版商和代理商之间的数据移交过程标准化。
如有疑问、意见或担忧(或突出的问题)，请通过 LinkedInhttps://www.linkedin.com/in/harrychaw/联系我
Python 中的自动化堆栈
如何在节省时间的同时提高性能
介绍
当谈到将机器学习算法推向新的高度时，利用堆叠(堆叠概括)是一个非常热门的话题。例如，现在大多数获奖的 Kaggle 提交文件都使用了某种形式的堆叠或其变体。戴维·沃伯特在 1992 年的论文中首次介绍了叠加泛化*，它们的主要目的是减少泛化误差。根据沃伯特的说法，它们可以被理解为“交叉验证的更复杂版本”。虽然沃伯特本人当时指出，大部分堆叠概括是“黑色艺术”，但似乎构建越来越大的堆叠概括会战胜较小的堆叠概括。然而，随着这些模型的规模不断增加，它们的复杂性也在增加。自动化构建不同架构的过程将大大简化这一过程。本文的剩余部分将处理我最近遇到的包 vecstack ，它正在尝试这个 。*
Source: https://giphy.com/gifs/funny-food-hRsayJrDAx8WY
堆叠式概化看起来像什么？
堆叠概化结构背后的主要思想是使用一个或多个一级模型，使用这些模型进行预测，然后使用这些预测作为要素来拟合一个或多个二级模型。为了避免过度拟合，通常使用交叉验证来预测训练集的 OOF(折叠外)部分。该套件中有两种不同的变体，但我将在本段中描述“变体 A”。为了得到这个变量的最终预测，我们取所有预测的平均值或众数。可以使用 vecstacks 文档中的这张 GIF 来可视化整个过程:
用例:构建用于分类的堆叠式概化
看了文档之后，是时候自己尝试使用这个包了，看看它是如何工作的。为此，我决定使用 UCI 机器学习库中的葡萄酒数据集。这个数据集的问题陈述是使用 13 个特征，它们都代表了葡萄酒的不同方面，来预测葡萄酒来自意大利的三个栽培品种中的哪一个。
首先，让我们导入我们的项目需要的包:
**import pandas as** pd
**from** **sklearn.datasets** **import** load_iris
**from** **sklearn.model_selection** **import** train_test_split
**from** **sklearn.metrics** **import** accuracy_score
**from sklearn.neighbors import** KNeighborsClassifier
**from** **sklearn.ensemble** **import** RandomForestClassifier
**from** **xgboost** **import** XGBClassifier
**from** **vecstack** **import** stacking
现在，我们准备导入数据并查看它，以便更好地理解它的样子:
**link** = '[https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data'](https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data')
**names** = ['Class', 'Alcohol', 'Malic acid', 'Ash',
'Alcalinity of ash' ,'Magnesium', 'Total phenols',
'Flavanoids', 'Nonflavanoid phenols', 'Proanthocyanins', 'Color intensity', 'Hue', 'OD280/OD315 of diluted wines',
'Proline']**df** = **pd**.**read_csv**(link, header=None, names=names)
**df**.**sample**(5)
运行上面的代码块给我们带来了:
注意我用的是**。样()**改为 if 。head() 避免由于假设整个数据集具有前五行的结构而被误导。幸运的是，这个数据集没有任何缺失值，所以我们可以很容易地使用它来测试我们的包，而不需要任何通常需要的数据清理和准备。
接下来，我们将从输入变量中分离出响应，并按照 vecstacks 文档中的示例执行 80:20 的训练测试分割。
**y** = df[['Class']]
**X** = df.iloc[:,1:]**X_train, X_test, y_train, y_test** = train_test_split(X, y, test_size=0.2, random_state=0)
我们越来越接近有趣的部分了。还记得之前的 GIF 吗？现在是时候为我们的堆叠概括定义一些第一级模型了。这一步绝对值得单独写一篇文章，但是为了简单起见，我们将使用三个模型:KNN 分类器、随机森林分类器和 XGBoost 分类器。
**models** = [
**KNeighborsClassifier**(n_neighbors=5,
n_jobs=-1),
**RandomForestClassifier**(random_state=0, n_jobs=-1,
n_estimators=100, max_depth=3),
**XGBClassifier**(random_state=0, n_jobs=-1, learning_rate=0.1,
n_estimators=100, max_depth=3)
]
这些参数在设置之前没有被调优，因为本文的目的是测试这个包。如果你要优化性能，你不应该只是复制和粘贴这些。
从文档中取出下一部分代码，我们实际上是使用第一级模型进行预测来执行 GIF 的第一部分:
**S_train, S_test** = **stacking**(models,
X_train, y_train, X_test,
regression=False,
mode='oof_pred_bag',
needs_proba=False,
save_dir=None,
metric=accuracy_score,
n_folds=4,
stratified=True,
shuffle=True,
random_state=0,
verbose=2)
堆叠函数接受几个输入:
- 车型 :我们前面定义的第一级车型
- X_train，y_train，X_test :我方数据
- 回归 :布尔值，表示是否要使用函数进行回归。在我们的例子中设置为 False，因为这是一个分类
- 模式: 使用前面描述的出叠方式进行交叉验证
- needs_proba :布尔值，表示是否需要类别标签的概率
- save_dir :将结果保存到目录 Boolean
- 度量 :使用什么评估度量(我们一开始导入了 accuracy_score)
- n_folds :交叉验证使用多少个折叠
- :是否使用分层交叉验证
- 洗牌 :是否洗牌
- random_state :设定再现性的随机状态
- 详细 : 2 这里是指打印所有信息
这样，我们得到以下输出:
*task: [classification]
n_classes: [3]
metric: [accuracy_score]
mode: [oof_pred_bag]
n_models: [4]model 0: [KNeighborsClassifier]
fold 0: [0.72972973]
fold 1: [0.61111111]
fold 2: [0.62857143]
fold 3: [0.76470588]
----
MEAN: [0.68352954] + [0.06517070]
FULL: [0.68309859]model 1: [ExtraTreesClassifier]
fold 0: [0.97297297]
fold 1: [1.00000000]
fold 2: [0.94285714]
fold 3: [1.00000000]
----
MEAN: [0.97895753] + [0.02358296]
FULL: [0.97887324]model 2: [RandomForestClassifier]
fold 0: [1.00000000]
fold 1: [1.00000000]
fold 2: [0.94285714]
fold 3: [1.00000000]
----
MEAN: [0.98571429] + [0.02474358]
FULL: [0.98591549]model 3: [XGBClassifier]
fold 0: [1.00000000]
fold 1: [0.97222222]
fold 2: [0.91428571]
fold 3: [0.97058824]
----
MEAN: [0.96427404] + [0.03113768]
FULL: [0.96478873]*
再一次，参考 GIF，现在剩下要做的就是在我们的预测上拟合我们选择的第二层模型，以做出我们的最终预测。在我们的例子中，我们将使用 XGBoost 分类器。这一步与 sklearn 中的常规拟合和预测没有显著不同，除了这样一个事实，即我们不是使用 X_train 来训练我们的模型，而是使用我们的预测 S_train。
***model** = **XGBClassifier**(random_state=0, n_jobs=-1, learning_rate=0.1,
n_estimators=100, max_depth=3)
**model** = model.fit(**S_train**, y_train)**y_pred** = model.predict(S_test)print('Final prediction score: [%.8f]' % accuracy_score(y_test, y_pred))Output: Final prediction score: [0.97222222]*
结论
使用 vecstacks 的堆叠自动化，我们成功预测了正确的葡萄酒品种，准确率约为 97.2%！如您所见，该 API 与 sklearn API 并不冲突，因此可以在尝试加速堆叠工作流时提供一个有用的工具。
一如既往，如果您有任何反馈或发现错误，请随时联系我。
参考文献:
[1]戴维·h·沃尔波特，(1992)，神经网络
[2]伊戈尔·伊万诺夫， Vecstack (2016)，GitHub
[3] M. Forina 等人，葡萄酒数据集 (1991)，UCI 机器学习知识库
用 Python 中的 PyAutoGUI 实现自动化 UI 测试
回归测试你的用户界面的一个快速简单的方法
当没有必要的安全措施来保证质量控制时，发布一个新版本的产品可能是一个令人紧张的经历。假设您的产品有一个用户界面(UI)，那么在每次发布之前进行 UI 测试是明智的。
当然，您已经准备好了集成测试，并且您确信系统将端到端地工作，包括 UI。然而，根据您所在的行业以及您的应用程序的重要性，您可能需要确保并证明它是可行的。鉴于这是您每次发布应用程序时都想要重复的事情，您可能想要自动化这种类型的测试。
一种快速简单的方法是利用一个名为 PyAutoGUI 的 Python 库，它将允许您执行自动化的 UI 测试。
Photo by Med Badr Chemmaoui on Unsplash
简介 PyAutoGUI
PyAutoGUI 本质上是一个 Python 包，可以跨 Windows、MacOS X 和 Linux 工作，它提供了模拟鼠标光标移动和点击以及键盘按钮按压的能力。
你可以在他们的主页上找到关于这个包的更多信息，包括下面显示的快速概览:
import pyautogui
screenWidth, screenHeight = pyautogui.size()
currentMouseX, currentMouseY = pyautogui.position()
pyautogui.moveTo(100, 150)
pyautogui.click()
pyautogui.moveRel(None, 10) # move mouse 10 pixels down
pyautogui.doubleClick()
pyautogui.moveTo(500, 500, duration=2, tween=pyautogui.easeInOutQuad) # use tweening/easing function to move mouse over 2 seconds.
pyautogui.typewrite('Hello world!', interval=0.25) # type with quarter-second pause in between each key
pyautogui.press('esc')
pyautogui.keyDown('shift')
pyautogui.press(['left', 'left', 'left', 'left', 'left', 'left'])
pyautogui.keyUp('shift')
pyautogui.hotkey('ctrl', 'c')
用法示例
为了了解这在实践中是如何工作的，让我们快速构建一个示例 python 脚本。我们首先假设我们的应用程序 Firefox(作为一个例子)已经部署到一台测试 Windows 10 的机器上，我们希望自动测试 UI 的某些方面。
要做的第一件事，是导入包并捕捉我们屏幕的大小。我们也可以假设 Windows 任务栏总是在屏幕的底部，所以我们可以继续启动开始菜单按钮。
import pyautogui as gui, time
screenWidth, screenHeight = gui.size()
gui.moveTo(0,screenHeight)
gui.click()
一旦执行了上面的代码，我们就可以搜索 Firefox，然后启动它。
gui.typewrite('Firefox', interval=0.25)
gui.press('enter')
我增加了每个字母的打字间隔，以适应较慢的机器。然后，我们需要确保窗口最大化到屏幕上。windows 的快捷键是 Alt + Space，然后是 x。
time.sleep(2) #give 2 seconds for firefox to launch
gui.keyDown('alt')
gui.press(' ')
gui.press('x')
gui.keyUp('alt')
此时，我们可以开始添加我们希望工具测试的特性。例如，我们可能想测试打开一个新标签页并在网站中键入内容。为此，我们想知道屏幕上的某些位置。为了识别它们，我们可以在后台运行以下脚本，当我们将鼠标悬停在我们想要的位置上时，可以看到位置输出:
import pyautogui as gui, time
def identifyloc():
while True:
currentMouseX, currentMouseY = gui.position()
print(currentMouseX,currentMouseY)
time.sleep(3)
identifyloc()
使用这个，我发现“新标签”按钮在位置(250，22)，地址栏在(371，51)。因此，我可以使用下面的代码:
gui.click(250,22)
gui.click(371,51)
gui.typewrite('https://medium.com/financeexplained')
gui.press('enter')
然后我们可以继续添加尽可能多的测试场景。当然，在执行完所有这些之后，仍然需要有人查看日志和 UI，以确保我们没有遇到任何错误。
将所有这些放在一起:
import pyautogui as gui, time
def testfirefox():
screenWidth, screenHeight = gui.size()
gui.moveTo(0,screenHeight)
gui.click()
gui.typewrite('Firefox', interval=0.25)
gui.press('enter')
time.sleep(2)
gui.keyDown('alt')
gui.press(' ')
gui.press('x')
gui.keyUp('alt')
gui.click(250,22)
gui.click(371,51)
gui.typewrite('[https://medium.com/financeexplained'](https://medium.com/financeexplained'))
gui.press('enter')def identifyloc():
while True:
currentMouseX, currentMouseY = gui.position()
print(currentMouseX,currentMouseY)
time.sleep(3)testfirefox()
在你走之前，我经常写关于金融和技术的博客。如果你想了解我的文章，别忘了关注我！
使用 Python 中的 AutoML 自动调整和选择 ML 模型
在同一数据集上测试不同的 ML 方法以评估模型性能可能是一项单调乏味的任务。此外，正确调整深度学习模型可能需要几个小时，如果不是几天的话。幸运的是，在过去的十年中，人们一直在努力开发自动化 ML 模型选择和调整的方法。虽然目前可用的开源解决方案并不是银弹(也不应该这样对待！)，在构建 ML 或 DL 模型时使用 AutoML 可以节省大量的时间，至少可以为您指出最佳模型的正确方向。在这篇文章中，我回顾了 Python 中目前可用的一些 AutoML 实现，并提供了具体的例子(包括代码！).
Python 中目前可用于自动化模型选择和调优的一些选项如下( 1 ):
- H2O 一揽子计划
- auto-sklearn 包
- TPOT 一揽子计划
在本帖中，我们将回顾 H2O 包和 TPOT 包中的 AutoML 功能。可惜 auto-sklearn 只在 Linux 操作系统上可用(我没有)，所以就不覆盖了。
数据
在这篇文章中，我们将使用通过 UCI 机器学习知识库获得的一个众所周知的数据集，乳腺癌数据集，根据各种因素对癌症是否复发进行分类(二进制结果为 0 或 1)。潜在的预测变量包括患者的年龄(分类变量——分箱),患者是否已经绝经(分类变量),以及肿瘤大小(分类变量——分箱)等。数据集的快照如下所示:
Snapshot of the breast cancer data, available via the UCI repository
在我们通过任何 autoML 函数运行数据之前，让我们稍微清理一下。主要是，我们使用 sklearn 的 LabelEncoder()函数将所有的分类变量转换成数字(使用标签编码对 H2O 来说不是必需的，但对 TPOT 来说是必需的):
Data after being label-encoded
现在我们有了一个干净的数据集，可以使用了，让我们对它运行 AutoML。
H20 的汽车
H20 是一个开源的 ML 库，允许用户快速构建、测试和生产 ML 模型。H2O 的 AutoML 功能可以自动为训练数据集选择最佳 ML 或 DL 模型。该软件包非常通用和强大。
下载 H20
这个链接包含了为 Python 下载 H20 的说明。该软件包需要一些必须预先安装的依赖项。提供了使用 Anaconda 和普通 Python 进行安装的指导。
在我们的数据集上运行 H2O 的 AutoML
我们使用以下代码对数据集执行 H2O AutoML:
A snapshot of the leaderboard for H2O’s AutoML results
如上图所示，控制台中会出现最合适型号的排行榜。根据排行榜的结果，我们表现最好的模型是一般线性模型(GLM)，其次是梯度增强模型(GBM)。我们可以通过 H2O 的 model_performance()函数运行我们的测试数据来衡量 GLM 的性能，其中 aml.leader 是性能最好的模型:
Confusion matrix for test predictions, generated via H2O’s model_performance() function
基于上述混淆矩阵，该模型的总体准确率约为 83%，召回率约为 73%，准确率为 87.5%。考虑到我们在通过 AutoML 运行数据集之前实际上没有对其进行预处理，这是一个惊人的结果。
TPOT 汽车公司
TPOT，或基于树的流水线优化工具，是最早开发的 AutoML 方法之一。兰德尔·奥尔森博士在宾夕法尼亚大学计算遗传学实验室工作时开发了 TPOT。TPOT 的主要目标是通过基因编程实现 ML 流水线的自动化。TPOT 自动化流程图如下所示( 3 ):
The ML pipeline as automated by the TPOT package (3)
正如你在上面的示意图中看到的，TPOT 的 AutoML 功能可以自动完成 ML 管道后数据清理。流水线中的具体自动化步骤包括特征选择和预处理、模型选择和参数优化。
为 Python 下载 TPOT
TPOT 的功能依赖于 scikit-learn，所以你需要安装 sklearn(如果你还没有)和 TPOT 来使用 TPOT 的 AutoML 功能:
pip install sklearn
pip install tpot
使用 TPOT 的 AutoML 函数
我们将使用 H2O 汽车公司示例中使用的相同癌症数据集，再次预测癌症是否会复发(“类别”列)。我们通过 run_tpot_automl()函数运行标签编码的数据集:
该代码输出一个名为 tpot_classifier_pipeline.py 的 python 文件。该文件包含模型的优化 ML 管道:
我们对自动输出文件进行了一些编辑，并返回预测的测试结果以及相关的混淆矩阵:
Confusion matrix of test outputs.
在检查所选 AutoML 模型的结果时，一个额外的树分类器(一个随机森林的变体)，总的模型精度是 83%。模型召回率为 75%，准确率约为 84%。与 H2O AutoML 模型的结果几乎完全相同，但精度得分较低。
不同的包装如何堆叠
如果您正在对一个模型进行 AutoML 采样，我建议尝试这两个包，因为您的结果可能与本文中的结果不同。就每个方案而言，以下是我观察到的利弊:
H2O 汽车
优点:
- 易于下载
- 几乎不需要数据预处理(标签编码是不必要的，因为它与 TPOT)
- 结果很容易解释
- 选择最佳型号时，对各种 ML 和 DL 类型进行采样
缺点:
- Spyder 是我的首选 IDE(可以通过 Anaconda 发行版获得)，它不会显示 H2O 输出。H2O 必须在 Jupyter 笔记本或同等电脑上运行，才能显示排行榜结果。
TPOT 汽车
优点:
- 结果是高度可解释的，并且生成包含最佳 ML 管道的自动化文件。
- 易于下载。
缺点:
- 需要进行更多的数据预处理，才能将数据集转换成可接受的格式来运行 AutoML。
- 至少在这个例子中，不如 H2O 的 AutoML 精确。然而，这可能是一次性的，当使用其他数据集进行采样时，结果可能会有所不同。
我的 Python AutoML 包教程到此结束。感谢阅读！本教程的完整代码可通过我的个人 Github repo 获得:https://Github . com/kperry 2215/automl _ examples/blob/master/automl _ example _ code . py
看看我的其他一些机器学习文章:
包括示例 Python 代码！在这篇文章中，我将介绍一些我最喜欢的检测时间序列中异常值的方法…
techrando.com](https://techrando.com/2019/08/23/unsupervised-machine-learning-approaches-for-outlier-detection-in-time-series/) [## 使用 Python - Tech Rando 进行变化点检测简介
我的很多工作都大量涉及时间序列分析。我使用的一个很棒但不太为人所知的算法是…
techrando.com](https://techrando.com/2019/08/14/a-brief-introduction-to-change-point-detection-using-python/)
来源
- AutoML。从 https://www.ml4aad.org/automl/取回
- AutoML:关于自动机器学习的信息。从 http://automl.info/tpot/取回
- TPOT:一个 Python 自动机器学习工具，使用遗传编程优化机器学习管道。从 https://github.com/EpistasisLab/tpot取回
原载于 2019 年 10 月 21 日 https://techrando.com**T21。
使用任务调度器自动化您的 Python 脚本
数据专业人员权威指南
Windows 任务计划程序抓取替代数据
Credit: Stocksnap
每天运行我的 Python 脚本太麻烦了。
我需要一种定期自动运行我的 Python 脚本的方法
想象一下，你的经理让你半夜醒来运行一个脚本。这将是你最大的噩梦。你过早醒来，暴露在可怕的蓝光下，每天午夜都不能好好睡觉。
作为任何数据专业人员，您可能需要运行多个脚本来生成报告或部署分析管道。因此，你需要了解一下计划者来避免破坏你的周末。
每个数据工程师和科学家在某个时间点都需要运行定期任务。
根据定义，周期性任务是指在没有或很少人工干预的情况下，按照一定的时间间隔重复执行的任务。在数据和技术快速发展的时期，你需要运行脚本来开发数据库备份、Twitter 流等。
幸运的是，有了任务调度器，您现在可以根据需要每天/每周/每月/每年运行 Python 脚本来执行定期任务。
在本教程中，您将学习如何运行任务调度程序来从 Lazada (电子商务)网站的网页抓取数据，并将其转储到 SQLite RDBMS 数据库中。
这是自动运行您的脚本的快速一瞥！
Running Web Scraping Scripts with Task Scheduler then append it to SQLite Disk
我们开始吧！
这些方法
在本教程中，我们将使用 Windows 任务计划程序运行 bat 脚本，该脚本将触发 Python 脚本。要执行这些脚本，我们有两个简单的步骤:
- 创建 Python 可执行文件(bat 文件)
- 在 Windows 任务计划程序中配置任务
但是，如果您是 Linux 用户，并且没有可用的 Windows 任务调度程序，您应该使用 cron 调度程序。
创建 Windows 可执行 bat 文件以运行 Python
一个 BAT 文件是一个 DOS 批处理文件用来执行 Windows 命令提示符(cmd.exe)下的命令。它包含一系列通常可能在 DOS 命令提示符下输入的行命令。 BAT 文件最常用于在 Windows 中启动程序和运行维护实用程序。—fileinfo.com
使用 bat 文件作为我们的可执行文件，我们将运行脚本存储在一个文件中，然后双击 bat 文件，在 cmd(命令提示符)上执行命令来运行 python 脚本。
你需要做的就是创建一个新的 bat 文件(例如:web-scraping.bat)并编写可执行脚本，格式为 <你的 Python.exe 位置> <你的 python 脚本位置> 。可以添加暂停命令，避免执行后关闭命令提示符。
C:\new_software\finance\Scripts\python.exe "C:/new_software/Web Scraping/Web-Scraping/Selenium Web Scraping/scraping-lazada.py"
pause
一旦你双击这个 bat 文件，Windows 将打开你的命令提示符并运行网页抓取工具。为了调度这个双击/执行，我们将把我们的任务调度器挂接到 bat 文件。
在 Windows 任务计划程序中配置任务
Windows 任务调度器是一个默认的 Windows 应用程序，用于管理任务以响应基于事件或基于时间的触发。例如，你可以建议某个点击和计算机动作(比如重启)，甚至建议像每个财政季度第一天的这样的时间来执行任务。
从更大的角度来看，这个任务将包含脚本和元数据，以定义将执行什么操作以及如何执行操作。您可以在参数中添加特定的安全上下文，并控制调度程序将在何处运行程序。Windows 将把所有这些任务序列化为**。作业文件放在一个叫做任务文件夹**的特殊文件夹中。
The process flow of Task Scheduler to automate application’s web scraping
在本教程中，我们将设置一个基于时间的事件来运行我们的应用程序，并将数据转储到 SQLite 中。总共有多少
- 点击开始窗口，搜索任务计划程序，并打开它。
- 单击右侧窗口中的创建基本任务
- 选择你的触发时间。
- 为我们之前的选择选择准确的时间。
- 开始一项计划
- 在之前保存 bat 文件的地方插入程序脚本。
- 单击完成。
我们开始吧！
- 点击开始窗口，搜索任务调度器，打开。
Task Scheduler Windows
2.在右侧窗口点击创建基本任务。
你应该把你的任务名称(如:网页抓取)和描述(如:网页抓取和 SQLite 转储自动每天下午 6 点)
3.选择您的触发时间。
你可以选择每天，每周，甚至每月触发时间。从逻辑上讲，这种选择很大程度上取决于您希望刷新数据源中的值的频率。例如，如果您的任务是收集 MarketWatch 股票资产负债表，您应该在每个财务季度运行这些脚本。
4.为我们之前的选择选择准确的时间。
我们将选择一月、四月、七月和九月来表示所有早期财务季度。
5.启动程序
在这里，您将能够启动 Python 脚本，发送电子邮件，甚至显示消息。请随意选择你最喜欢的。但是，您应该小心，因为有一些不推荐使用的任务将在后续补丁中删除。
6.在之前保存 bat 文件的地方插入程序脚本。
这将自动运行 Python 脚本的任务调度程序。确保在应用程序文件夹的位置包含 Start in，以便访问所有相关的元素(Selenium Browser 可执行文件/ SQLite 磁盘)
7.点击完成。
您可以在任务计划程序的首页查看您创建的任务计划。
祝贺您，您已经在 Windows 中设置了第一个自动计划程序。
结果
下面是 gif 动画，供大家参考。请注意调度程序是如何自己运行 Python 脚本的。一旦脚本运行完毕，它会将提取的值转储到 SQLite 数据库中。将来，该应用程序将在每次满足触发条件时运行，并将更新后的值追加到 SQLite 中。
Running Web Scraping Scripts with Task Scheduler then append it to SQLite Disk
Data appended into SQLite using Task Scheduler
最后…
Boy laughing while reading a book, source: Unsplash
我真的希望这是一本很棒的读物，是你发展和创新的灵感来源。
请在下面评论出来建议和反馈。
如果你真的喜欢它，请查看我的个人资料。还有更多关于数据分析和 Python 项目的文章会让你感兴趣。
快乐编码:)
关于作者
Vincent Tatan 是一名数据和技术爱好者，拥有在 Visa Inc .和 Lazada 实施微服务架构、商业智能和分析管道项目的相关工作经验。
Vincent 是土生土长的印度尼西亚人，在解决问题方面成绩斐然，擅长全栈开发、数据分析和战略规划。
他一直积极咨询 SMU BI & Analytics Club，指导来自不同背景的有抱负的数据科学家和工程师，并为企业开发他们的产品开放他的专业知识。
请通过 LinkedIn ，Medium或 Youtube 频道 联系文森特
自动化和可管理的管道:数据科学工厂的关键组成部分
数据科学可能是一项棘手的工作，来自无数来源的原始数据不断涌入不断发展的管道，试图满足不断变化的期望。为了利用所有这些混乱的潜力，企业努力创建数据科学工厂，在减少低效的同时简化流程；然而，数据不会等着公司赶上来。在处理大量数据的同时生产一个高功能的数据科学工厂就像试图制造一架飞机并驾驶它一样。
构建有效的数据科学工厂的关键是在流程的每个步骤中实施智能自动化和评分管道，以便为业务合作伙伴和客户生成分析产品，如 API、评分文件和数据丰富。每个组件都必须产生合理的结果，以使操作具有可伸缩性并产生可靠的见解。让我们来看看起作用的组件以及如何最大化每一个组件。
三种类型的管道
**数据管道:**数据从起点到它在美丽的图形中的最终归宿，或者最终到数据仓库，有一个漫长而痛苦的旅程。数据管道软件将数据从一个点移动到另一个点，并且在该过程中经常涉及转换。高效的数据管道减少了手动步骤，每个步骤都依赖于自动化:提取、清理、转换、组合、验证和加载以供进一步分析。传输数据会增加损坏和潜在延迟的风险，在小范围内降低风险的努力越多，当流程扩展时，输出的质量就越高。
**机器学习评分管道:**干净、准备好的数据准备好被输入到机器学习评分算法中，在那里生成通知商业决策的分数。有效的 ML 评分管道在很大程度上依赖于其模型的质量。
**反馈和响应管道:**由 ML 管道产生的规定决策必须被记录并通过反馈和响应管道被返回用于进一步学习。这一过程既可以实时进行，如网站产品推荐，也可以要求对购买周期较长的产品进行潜在响应，如抵押贷款申请或人寿保险报价。
数据管道的三种速度
数据管道可以以三种不同的速度进行处理，每种方式都有独特的优势和局限性。
**批处理:**批处理是处理大量数据的有效方式。在一段时间内收集的交易作为一批进行处理。这种方法通常用于建模预测分析，因为大量的数据可确保更准确的结果和更强的洞察力。
**实时:**许多数字操作需要立即行动，因此当代数据科学家经常依赖实时数据处理。这种方法需要不断的输入、处理和输出。流媒体创造了快速数据现象，许多企业提供关键的实时服务，如欺诈检测、语音识别和推荐。
**事件驱动:**为了节省资源和限制冗余，一些管道应用事件驱动处理。事件可以是指示特定温度、时间段的智能机器，或者与库存相关的销售点通知。事件驱动的管道被优化以产生实时结果，但是仅在特定的、预先确定的情况下。
高度可扩展管道的关键要素
1。底层基础设施
基础设施是指产生机器学习算法所需的技术栈。成功的运营需要密封的解决方案和坚实的基础设施。难以控制的管道系统会导致不可收回的技术债务，这一直是 ML 开发中的一个问题,或者使结果和工作流不可能重现的纠缠不清的“管道丛林”。
2。自动化质量控制
人工智能正在彻底改变各行各业的质量控制，但同样重要的是，该技术可以监控自身输出的质量。实施在线和超时自动质量控制解决方案可确保更可靠的结果，并减少手动检查受损数据所花费的时间。
3。自动化漂移和异常检测
概念漂移是机器学习中的一种常见现象，会导致不准确的结果；然而，目标变量的变化可以被自动标记，触发重新训练以保护模型的完整性。此外，当数据点超出预测模式时，自动异常检测可以触发适当的操作或进一步的调查。
4。为数据治理和自我记录管道集成现代数据目录
人们越来越认识到数据对公司来说是无价的，这使得数据的管理、存储和监管成为重中之重。能够自我记录的管道增加了未来项目的功能和价值，集成现代数据目录提高了任何算法预测的相关性。
5。实施强大的日志记录和诊断功能
正如古老的英国谚语所说:*及时一针可省九针。*一旦数据移动，调试就变得非常困难。在开发和部署阶段建立日志记录和诊断功能是非常重要的，以避免在过程的后期进行数据修复。
建立期望
1790 年，塞缪尔·斯莱特建立了美国第一家生产加工棉花的工厂。新摘的棉花收了进去；加工棉花出来了。近 230 年后，随着数据成为世界上最有价值的资源,“工厂”的概念也随之演变。单一静态输入的时代已经成为历史，新的标准是找出如何将每天产生的 2.5 万亿字节的数据转化为可操作的见解。构建高效的数据科学工厂需要持续的工作进展，即使是在企业的最高级别。虽然不可能交流所涉及的无数动态变量，但是集成这些基本组件是朝着正确方向迈出的一步。
关于高功能数据科学工厂的更多组件，阅读关于特性存储库。
本帖最初发表于 Quickpath 的博客 。
自动化 Aspen HYSYS 建模
以及为什么所有过程工程师都应该担心这个问题
Aspen HYSYS snapshot of an oil and gas plant
Aspen HYSYS 是最著名的过程建模软件之一，大多数过程(化学)工程师都知道并使用它。在这篇博客中，我将回顾我们如何利用现实生活中的业务问题实现 it 自动化的 3 种方法。在我开始解释这些方法之前，让我详细解释一下为什么我认为这很重要。
Image from freepik.com
重要性: 随着人工智能的到来和计算机技术的进步，你可能会听到这样的说法:在未来 10 年内，人类将几乎没有工作。这听起来很可怕，而且目前与你无关。让我们想想它会怎样发生。
从自动化任务开始，这在过去几年中在所有工作方面都有显著扩展。我观察到无论是大公司还是小公司都鼓励他们的员工将所有重复性的工作投入自动化模式。工程软件开始从基于电子表格转变为基于专有工具，自动将 HYSYS 直接链接到软件。作为一名经验丰富的工艺工程师，我们在设备选型和工艺计算方面投入的精力越来越少。我无法想象在不久的将来，年轻的工程师怎么可能会有我过去的那种“脏手”经历，因为他们可能一无所知，而软件将为他/她做几乎所有的事情。迟早你会发现这一点，所以让我们作为第一步开始学习如何自动化它吧！
本文的目标是记录和分享我在项目中尝试自动化 HYSYS 建模的内容。也许，这可能对和我有类似问题的人有益。下表是我在 HYSYS 的一个设备处理方案中运行各种案例的目的。需要该汇总表来确定选择哪种情况来建立设备选型的 H&MB 和操作范围。
Various cases of HYSYS simulation required to complete this work
背景: 在我的过程工程职业生涯中，我经常发现的一个问题是需要考虑的操作案例数量非常多。这通常来自地下储层预测的不确定性、生产混合策略的变化以及许多其他原因。例如，低输入温度(低海底温度)的情况将导致最高的原油热交换器负荷，另一方面，高海底温度的情况通常决定压缩机功率大小。作为主要的工厂设计工程师，我们将需要仔细确定所有的操作参数，以涵盖这些情况，以确保我们不会遇到任何情况，我们将不得不操作和生活，但设备不是为其设计的。
业务案例: 具体到我的项目，从探井数据和自然界中各种各样的储层来看，不同气体成分的混合、凝析油 API、来自天然气平台的凝析油气比(CGR)、石油成分、来自石油平台的各种气油比、CO2 含量和海底温度的变化都会以某种方式影响设备设计。这些因素的综合结果是，如下表所示，总共需要考虑 64 个 HYSYS 模拟案例。
在过去，我们通常试图通过使用一些工程判断来减少案例的数量。例如，人们可能会假设高 API 凝析油情况会与高 API 油情况同时发生。然而，我认为减少案例数量可能不是正确的方法，因为成分混合的结果不容易预见，并且可能导致忽略一些重要操作案例的问题。另一方面，如果这些耗时的任务可以自动化，就可以建立一个更健壮的系统方法。
自动化选项: 我在这部作品中考虑了三个选项:
1。使用石油专家解析软件
2。使用 Python GUI 控件包
3。使用 Excel Visual Basic for Applications 和 HYSYS 类型库外接程序
我选择实施的最终解决方案是#2 和#3 的组合。
对于第一个选项，PetEx RESOLVE 软件提供了 HYSYS 与其他软件(如 Excel、Pipesim 或 GAP)之间的良好交互。探索了一段时间后，我觉得这个选项看起来不适合我的问题。主要是，该软件更侧重于全局优化(从油井到加工设施的建模)和基于给定时间段预测各种生产率的结果。用 RESOLVE 构建的交互模块需要在不同的时间输入案例。虽然我可以在不同的时间设置不同的案例名称，但看起来软件内置的曲线绘制或软件之间的自动导入/导出功能对我的案例没有用。相互作用主要集中在流量、压力、温度和简单的油/水/气重力。对于除此之外的其他属性，它需要额外的编码，如下图所示。
Example of Petroleum Expert RESOLVE snapshot
应注意，在 RESOLVE 中，为了让 HYSYS 显示正确的入口和出口流，子系统中的所有流都应显示在主页上。
Example of Petroleum Expert RESOLVE snapshot (2)
如上所述，这个输入解算器和预测并不完全符合我的需求，所以我尝试了其他方法。
对于第二个选项，我尝试使用 Python GUI 包来控制和自动化任务。Python 是一种免费的开源且广泛使用的编程语言。我们可以安装和使用大量的免费软件包。如果你不知道如何开始使用 Python，我推荐你阅读我的第一篇博客。我发现的一个很酷的功能是可以控制鼠标和键盘到屏幕上你想要的任何地方或者输入任何东西。它像人一样直接在软件上交互控制。该选项需要安装 pyautogui 或 pywinauto 之类的软件包。安装后，我们可以使用“Ctrl”+“F”功能打开 HYSYS 中的搜索菜单，在 HYSYS 中导航并更改选定的流。然后，我们可以使用“Tab”和其他键盘快捷命令来定位并更改我们想要的案例属性。但是，我发现仅使用键盘功能来调整 HYSYS stream 并不完全符合我的需求。我需要一些鼠标控制，每次打开软件时，当我用笔记本电脑屏幕和显示器打开软件或重新启动 HYSYS 时，HYSYS 中的设备操作项目不会出现在屏幕上的相同位置。因此，我意识到这可能不是自动化 HYSYS 建模案例的最佳方法。虽然它有一些有用的功能，比如截图保存，或者在案例完成运行并收敛后保存 HYSYS 文件的能力，但是调整流组成和属性以匹配我的问题案例才是真正的问题。
Snapshot of coding in python to define some custom function for this work
HYSYS Object Navigator command screen after pressing ‘CTRL’ + ‘F’
然后，我尝试了第三个选项—使用 Excel Visual Basic for Application 添加 HYSYS 类型库。在这种方法中，我可以直接导航到每个 HYSYS 工艺流程、设备操作，并使用内置功能调整操作。它的工作效率很高，因为可以在 Excel 中清楚地定义案例，一旦提供了编码，就可以执行导入/导出功能。我发现的唯一一个遗留问题是当我们改变入口流条件时 HYSYS 模拟的收敛状态。在写这篇文章的时候，除了手动检查，我仍然找不到任何更好的解决方案。
HYSYS type 10 library that can be added in Excel >> VBA >> Tools >> References
Some VBA code used in this project
最后，我得出的结论是，最好的办法可能是通过以下步骤将方案 2 和方案 3 结合起来:
1 .运行 Python 代码打开 HYSYS 文件和 Excel 文件
2。在每种情况下运行 Excel 宏来改变 HYSYS 入口条件
3。手动检查仿真结果是否收敛，并且没有出现奇怪的现象
4。运行 Excel 宏将 HYSYS 流属性导出到 Excel 表
5。继续下一个 Python 代码以保存 HYSYS 截图，将 HYSYS 文件保存为新案例，并为下一个案例重复步骤#2。
Final program interface that I used
在尝试了 3 种方法后，我总结了它们的利弊…
我已经把我所有的代码放在这个 GIT 里了。请随意阅读/使用，如果您觉得有用，请给我反馈您的意见。下次见。
参考资料:
加工和处理工程师可以更好地利用过程模拟的结果，通过自动导出…
www.chemengonline.com](https://www.chemengonline.com/using-excel-vba-process-simulator-data-extraction/) [## Hysys Excel 自动化
打开如何将 Hysys 仿真链接到 Excel？Example1.HSC。该文件在 Aspen Hysys V7.1 中生成，可能无法在…
hysyssimulations.blogspot.com](http://hysyssimulations.blogspot.com/)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
