TowardsDataScience 2023 博客中文翻译（四十四）

于 2024-09-21 07:56:37 发布
阅读量2.8k 收藏 28
点赞数 20
分类专栏： MLM 文章标签： MLM
License CC BY-NC-SA 4.0 / 自豪地采用谷歌翻译
本文链接：https://blog.csdn.net/wizardforcel/article/details/142410121
版权

原文：TowardsDataScience

协议：CC BY-NC-SA 4.0

无监督学习中的关联规则挖掘

原文：towardsdatascience.com/association-rule-mining-in-unsupervised-learning-df86170160de

数据挖掘中的模式发现术语和概念

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 Kay Jan Wong

·发表于 Towards Data Science ·5 分钟阅读·2023 年 1 月 25 日

–

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Kier… in Sight 在 Unsplash 的照片

模式发现试图揭示大数据集中的模式，这为许多数据挖掘任务奠定了基础，如关联分析、相关性分析和因果分析、聚类分析等。

本文介绍了关联规则挖掘中的常见术语，并随后讲解了频繁模式和序列模式的关联规则挖掘技术。

目录

频繁模式

序列模式

术语

  • 支持度：项X出现的概率，表示为P(X)，衡量项的受欢迎程度

  • 置信度：在获取项Y后获取项X的条件概率，表示为P(X|Y)

  • 提升度：置信度除以支持度，表示为P(X|Y)/P(X)，衡量项的独立性以及在添加项Y到购物车后，项X被购买的可能性更高

  • 杠杆度：两项的支持度之差与两项独立时的预期支持度之差，表示为P(XUY)-P(X)P(Y)，衡量项的独立性

  • 置信度：支持度除以置信度，记作 (1-P(X))/(1-P(X|Y))，衡量项的独立性，高置信度是 Y->X 强置信度和 X 低支持度的组合。

Apriori 算法

水平广度优先搜索算法

Apriori 算法通过指定最低置信度阈值来识别关联。关联的直觉在于对一个后继项在一个前驱项被选择后被选择的信心，记作 P(consequent|antecedent)。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图 1：事务数据示例 — 作者提供的图片

例如，在图 1 中，Confidence(A->C) = P(C|A) = 0.75，因为项 C 在 A 后被购买的次数为 4 次中的 3 次。如果此置信度高于最低置信度阈值（例如 0.5），则可以得出 A->C 的关联。

通过应用向下封闭原则来加速频繁项集的搜索，而不是计算每个项集之间的置信度。向下封闭原则指出，任何频繁项集的子集必须也是频繁的，例如，如果项集 A, B, C 是频繁的，则它的子集项集 A, B 也必须是频繁的。

Apriori 算法的缺点是必须反复扫描数据以计算每个项或项集的支持度和置信度。

等价类转换（ECLAT）

使用集合交集的垂直深度优先搜索算法

在 Apriori 算法中，数据被视为水平事务级数据，其中每个事务包含一个或多个项。在 ECLAT 中，数据被转换为垂直项级数据，每个项具有一个包含其出现的事务 ID 的集合（称为 TIDset）。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图 2：垂直项级数据示例 — 作者提供的图片

根据图 1 中的事务数据示例，可以将其重新排列为垂直项级数据，如图 2 所示。例如，项 B 出现在事务 1、2 和 3 中，这将导致 TIDset {1, 2, 3}。

项的支持度和置信度计算可以通过 TIDset 之间的集合交集完成。ECLAT 算法比 Apriori 算法更节省内存和计算，因为它使用深度优先搜索，不需要多次扫描数据以获取每个项的支持度。

频繁模式增长（FP-Growth）

使用 Trie 数据结构的垂直深度优先搜索算法

FP-Growth 的直觉是找到频繁单项，并根据每个这样的项对数据库进行分区，然后递归地为每个分区数据库增长频繁模式。这些操作通过 Trie 数据结构（FP-树）有效完成。

数据被扫描两次 — 第一次是查找单项频繁模式（满足最低支持度），第二次是构建 FP-树。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图 3：频繁模式的样本 Trie 数据结构 — 图片来源于作者

根据图 1 中的交易数据示例，可以创建如图 3 所示的 FP 树。交易 1 和 2 路径为 A-B-C-D，交易 3 路径为 A-B-D，交易 4 路径为 A-C。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图 4：条件模式基 — 图片来源于作者

从这个 FP 树中，我们可以轻松计算条件模式基（图 4），例如项 C 与 {A, B} 一起出现两次，与 {A} 一次 — 无需重新扫描数据。

广义序列模式（GSP）

基于 Apriori 的序列模式挖掘，广度优先搜索

GSP 与 Apriori 算法类似，其中数据首先扫描单项序列并筛选频繁序列。然后，数据会不断扫描和筛选以检索更长的子序列。需要注意的是，项在子序列中不必连续，模式可以包含重复的项。

其他基于 Apriori 的序列模式挖掘包括 使用等效类的序列模式发现（SPADE）算法，该算法类似于 ECLAT 算法。

前缀投影序列模式挖掘（PrefixSpan）

基于模式增长的序列模式挖掘，深度优先搜索

PrefixSpan 将条目分为前缀和后缀。捕获频繁的前缀，并将前缀的投影作为后缀。

PrefixSpan 通过一次扫描数据来查找长度为 1 的序列模式，并递归扩展频繁的长度为 1 的序列模式。扩展是通过将长度为 1 的模式作为前缀，并将以长度为 1 的模式开头的其余项作为后缀（称为投影数据库）来完成的，并递归地增加前缀的长度。每次迭代后，投影数据库会缩小，因为后缀的长度减少。

该算法速度较慢，但可以通过伪投影优化，使用指针代替物理复制后缀。

其他基于模式增长的序列模式挖掘包括 频繁模式投影序列模式挖掘（FreeSpan），其效率不如 PrefixSpan。

与聚类相比，聚类是另一种无监督学习的主题，我觉得关联规则挖掘在统计学上更有基础，使其更具挑战性。不过，希望这篇文章对一些流行的关联规则挖掘技术提供了一个概述！

相关链接

论文

LangChain 和 LLMs 的异步处理

原文：towardsdatascience.com/async-calls-for-chains-with-langchain-3818c16062ed?source=collection_archive---------0-----------------------#2023-07-10

如何使 LangChain 链与异步调用的 LLMs 一起工作，从而加快运行顺序长链的时间

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 Gabriel Cassimiro

·

关注 发布于 Towards Data Science ·6 分钟阅读·2023 年 7 月 10 日

–

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片由hp koch提供，Unsplash

在本文中，我将介绍如何使用异步调用 LLMs 来处理长工作流，使用 LangChain。我们将通过一个完整代码的示例进行讲解，并比较顺序执行与异步调用的差异。

这里是内容概览。如果你愿意，可以跳转到你感兴趣的部分：

  1. 基础知识：什么是 LangChain

  2. 如何使用 LangChain 运行同步链

  3. 如何运行单个异步链与 LangChain

  4. 长工作流程中的实用技巧与异步链。

所以让我们开始吧！

基础知识：什么是 LangChain

LangChain 是一个基于语言模型开发应用程序的框架。这就是 LangChain 的官方定义。这个框架是最近创建的，已经被用作建立由 LLM 支持的工具的行业标准。

它是开源的，并且在非常快的时间框架内发布新功能。

官方文档可以在这里找到，GitHub 存储库可以在这里找到。

我们在这个库中遇到的一个缺点是，由于这些功能是新的，我们不能有效地使用 Chat GPT 来帮助构建新的代码。这意味着我们必须以“古老”的方式阅读文档、论坛和教程来工作。

LangChain 的文档确实很好，但是关于某些特定事物的例子并不多。

我在异步长链方面遇到了这个问题。

这是我用来了解更多关于这个框架的主要资源：

  1. 深度学习 AI 课程：LangChain Chat with your data；

  2. 官方文档；

  3. YouTube 频道。

（附注：它们都是免费的）

如何运行 LangChain 的同步链

所以让我说明我遇到的问题：我有一个包含大量行的数据框架，对于每一行，我需要运行多个提示（链）到一个 LLM，并将结果返回到我的数据框架中。

当你有多个行时，比如 1 万行，每个行运行 3 个提示，并且每个响应（如果服务器没有超载）大约需要 3-5 秒，你最终会等待数天才能完成工作流程。

下面我将展示主要步骤和构建同步链的代码，并在数据子集上计时。

对于这个例子，我将使用数据集Wine Reviews，许可证。这里的目标是从书面评论中提取一些信息。

我想提取一份评论摘要、主要情感以及每种葡萄酒的前五个特征。

为此，我创建了两个链，一个用于摘要和情感，另一个使用摘要作为输入来提取特征。

这是运行它的代码：

运行时间（10 个示例）：

摘要链（顺序执行）在 22.59 秒内执行完毕。

特征链（顺序执行）在 22.85 秒内执行完毕。

如果你想更深入地了解我使用的组件，我真的推荐观看深度学习 AI 课程。

这段代码的主要收获是链的构建模块、如何以顺序方式运行它，以及完成此循环所需的时间。需要记住的是，对于 10 个示例，大约需要 45 秒，而完整的数据集包含 130K 行。因此，异步实现是以合理时间运行的“新希望”。

因此，既然问题已经设置并且基线已经确定，我们来看看如何优化这段代码以便更快地运行。

如何使用 LangChain 运行单个异步链

为此，我们将使用一种叫做异步调用的资源。为了说明这一点，我将首先简要解释代码的作用以及哪些地方的时间消耗过长。

在我们的示例中，我们遍历数据框的每一行，从行中提取一些信息，将它们添加到提示中，然后调用 GPT API 获取响应。收到响应后，我们解析它并将其重新添加到数据框中。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片由作者提供

主要的瓶颈在于调用 GPT API，因为我们的计算机必须在等待该 API 响应时闲置（大约 3 秒）。其余的步骤都很快，可以继续优化，但这不是本文的重点。

那么，既然不需要闲等响应，我们为什么不同时发送所有 API 请求呢？这样我们只需等待一个响应，然后处理所有响应。这就是所谓的异步 API 调用。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片由作者提供

这样，我们可以顺序地进行预处理和后处理，但对 API 的调用不必等到上一个响应回来后再发送下一个请求。

下面是异步链的代码：

在这段代码中，我们使用了 Python 的 async 和 await 语法。LangChain 也提供了运行异步链的代码，使用 arun() 函数。因此，开始时我们首先顺序处理每一行（可以优化），并创建多个“任务”来并行等待 API 响应，然后顺序处理响应以达到最终所需格式（也可以优化）。

运行时间（10 个示例）：

摘要链（异步）执行时间为 3.35 秒。

特征链（异步）执行时间为 2.49 秒。

与顺序执行相比：

摘要链（顺序）执行时间为 22.59 秒。

特征链（顺序）执行时间为 22.85 秒。

我们可以看到运行时间几乎提高了 10 倍。因此，对于大型工作负载，我强烈推荐使用这种方法。此外，我的代码中充满了可以进一步优化的 for 循环，以提升性能。

本教程的完整代码可以在这个 Github Repo 中找到。

使用异步链的长工作流的实际建议。

当我运行这些代码时，遇到了一些限制和障碍，我想和你们分享一下。

笔记本电脑不支持异步操作

在 Jupyter 笔记本中运行异步调用时，你可能会遇到一些问题。然而，只需询问 Chat GPT，它可能会帮助你解决这些问题。我编写的代码是为了在.py 文件中运行大工作负载，所以在笔记本中运行时可能需要一些修改。

输出的键太多了

第一个问题是我的链有多个输出键，而当时的 arun()只接受具有一个输出键的链。为了解决这个问题，我不得不将链拆分成两个独立的链。

不是所有链都可以异步处理

我在提示中使用了一个向量数据库进行示例和比较的逻辑，这需要将示例按顺序比较并添加到数据库中。这使得在整个链中使用异步处理变得不可行。

内容不足

针对这个特定的问题，我找到的最好内容是官方异步文档，并根据我的用例进行构建。所以如果你运行后发现新东西，记得与大家分享！

结论

LangChain 是一个非常强大的工具，用于创建基于 LLM 的应用程序。我强烈推荐学习这个框架并参加上述提到的课程。

对于运行链的具体主题，对于高工作负载，我们看到异步调用的潜在改进，所以我的建议是花时间理解代码在做什么，并拥有一个模板类（如我提供的代码中），并以异步方式运行它！

对于小型工作负载或仅需要一次 API 调用的应用程序，通常不需要异步处理，但如果你有一个模板类，可以添加一个同步函数，以便于使用其中任何一个。

感谢阅读。

完整代码可以在这里找到。

如果你喜欢这些内容并且想支持我，你可以请我喝咖啡：

## Gabriel Cassimiro 是一位分享免费内容的 数据科学家

嗨👋 我刚创建了一个页面。你现在可以请我喝咖啡了！

在这里购买咖啡

这里有一些你可能感兴趣的其他文章：

## 使用深度强化学习解决 Unity 环境问题

带有 PyTorch 实现深度强化学习代理的端到端项目代码。

在这里购买咖啡 ## 使用 Tensorflow 模型和 OpenCV 进行目标检测

使用训练好的模型来识别静态图像和实时视频中的对象

[towardsdatascience.com

从对齐中获得的注意力，实际解释

原文：towardsdatascience.com/attention-from-alignment-practically-explained-548ef6588aa4

学习重要的东西，忽略无关的东西。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 Daniel Warfield

·发布于Towards Data Science ·阅读时间 11 分钟·2023 年 7 月 19 日

–

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片由Armand Khoury提供，Unsplash

注意力机制，由Attention Is All You Need (2017)的开创性论文普及开来，可以说是目前机器学习中最重要的架构趋势。最初用于序列到序列建模的注意力机制，现已扩展到几乎所有的机器学习子学科。

本文将描述一种在变压器风格的注意力之前的特定注意力形式。我们将讨论它的工作原理及其用途。我们还将回顾一些文献，并提供一个在 PyTorch 中实现这种注意力形式的教程。通过阅读本文，你将对注意力这一概念有更深入的理解，这对探索更前沿的应用非常有用。

注意力机制的原因

注意力机制最初由Neural Machine Translation by Jointly Learning to Align and Translate (2014)推广，这也是本文的指导参考。该论文采用了一个编码器-解码器架构用于英语到法语的翻译。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

编码器-解码器架构的简要介绍，用于法语到英语的翻译任务

这是一种非常常见的架构，但具体细节可能会因实现而异。例如，一些早期的序列到序列编码器-解码器文献使用的是递归网络，这些网络逐步“构建”然后“解构”嵌入。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

一个简单的序列到序列递归编码器-解码器的信息流概念化。编码器逐步将英语单词一个一个地嵌入到嵌入空间中，然后由解码器进行解构。在此图中，圆圈表示编码器中的嵌入（红色）、中间嵌入空间（白色）以及解码器中的嵌入（蓝色）。在这种情况下，嵌入是长且复杂的向量，包含抽象内容，人类难以直观理解。

这个概念及其小的变体曾经是几年的前沿技术。然而，这种方法的一个问题是整个输入序列必须嵌入到嵌入空间中，这通常是一个固定大小的向量。因此，这些模型很容易忘记过长序列中的内容。注意力机制旨在缓解将整个输入序列适应到嵌入空间的问题。它通过告诉模型哪些输入与哪些输出相关来实现这一点。 换句话说，注意力机制允许模型专注于输入的相关部分，忽略其余部分。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

基于注意力的思考过程的一个例子。在法语中，“je”与“我”完全相同。“Suis”是动词“etre”（“to be”）的一个变位形式，并根据主语“I”和动词“am”变成“suis”。“directeur”的选择与“manager”关系密切，但也与该词使用的上下文相关。选择哪些输入与哪些输出相关是注意力机制的任务。

从高层次来看注意力是如何工作的

实际上，我们将讨论的注意力机制最终成为一个称为“对齐”分数的矩阵。这些对齐分数编码了输入序列中的一个单词与输出序列中的一个单词之间的关系程度。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

两个注意力矩阵的示例，针对两个不同的英语到法语的例子，来自 神经机器翻译：通过联合学习对齐和翻译(2014)。这篇论文只是间接提到了“注意力”一词，并实际上称之为“对齐模型”。“注意力”这一术语似乎是在事后被普及的。

对齐评分可以通过多种方式计算。我们将坚持使用 2014 年的论文，详细分析其特定的对齐函数：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

从《通过联合学习对齐和翻译的神经机器翻译》（2014 年）中计算对齐评分。这不是唯一存在的对齐函数，但这是我们将重点关注的函数。“Ua”和“Wa”表示对先前输出嵌入向量（si-1）和特定输入嵌入向量（hj）的可学习变换，而“va”表示将总嵌入向量减少到最终对齐标量的可学习变换。

在计算第 i 个输出的对齐时，这种方法使用解码器的前一个嵌入状态（s_i-1）、一个输入词的嵌入（h_j）以及可学习的参数 W_a、U_a 和 v_a，以计算第 i 个输出与第 j 个输入的对齐。tanh 激活函数被包含以添加非线性，这在训练模型以理解复杂关系时至关重要。

换句话说，上述函数计算了下一个输出词与单个输入词之间的分数，表示输入词对当前输出的相关性。该函数在所有输入词（h_j）上运行，以根据当前输出计算所有输入词的对齐评分。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

一个关于如何计算给定预测（词 8）的对齐的概念图。对齐函数在解码器的前一个输出嵌入向量与所有输入之间计算，以计算当前输出的注意力。改编自《通过联合学习对齐和翻译的神经机器翻译》（2014 年）

对所有计算出的对齐评分应用 softmax 函数，将其转化为概率。这在文献中被称为“soft-search”或“soft-alignment”。

注意力的具体使用方式可以因实现而异。在《通过联合学习对齐和翻译的神经机器翻译》（2014 年）中，注意力机制决定了向解码器提供哪些输入嵌入向量。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

一个图示说明了提出的模型尝试生成第 t 个目标词 yt，给定一个源句子（x1, x2, . . . , xT）。每个输入嵌入向量乘以其相应的对齐评分，然后将它们加在一起形成上下文向量，用于当前解码器输出步骤。来自《通过联合学习对齐和翻译的神经机器翻译》（2014 年）。

这个选择过程通过加权和来完成。所有的输入嵌入向量都乘以它们各自的对齐评分（实际上，大多数对齐评分的值为零，而一个或两个可能的值是 0.8 和 0.2），然后这些加权后的嵌入向量被加在一起，形成特定输出的上下文向量。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

用于第 i 次解码步骤的上下文向量 ci。这是基于对齐得分的所有输入嵌入的加权总和。来自 Neural Machine Translation by Jointly Learning to Align and Translate(2014)。

上下文向量是所有与当前输出相关的输入的组合。

下图展示了注意力如何融入整体结构：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

特定输出的信息流的分解。

  1. 输入被嵌入到一些初始的向量表示中（例如，使用 word2vect）。

  2. 这些通过双向 LSTM 进行处理，以在嵌入之间创建一定的上下文意识。

  3. 使用前一个解码器嵌入和对齐函数中的学习参数来计算每个输入的对齐得分。

  4. 经过 soft-max 处理的对齐结果会与每个输入相乘，汇总在一起，并用于构建上下文向量。

  5. 解码器使用前一个解码器的隐藏状态以及上下文向量来生成当前单词的预测。

在下一部分，我们将实现这个注意力机制的 PyTorch 版本。

PyTorch 中的注意力。

虽然我最初计划实现整个英语到法语的示例，但显然实现过程将过于冗长，并且包含许多与注意力机制解释无关的复杂性。因此，我创建了一个玩具问题，该问题模拟了英语到法语翻译的语法方面，以专门展示注意力机制，而无需实现 LSTM、嵌入、辅助令牌、批处理、掩码和其他特定问题的组件。

完整代码可以在 这里 找到，供感兴趣的人参考。

如前所述，英语到法语的翻译可以被认为是两个子问题：对齐和翻译。编码器和解码器中的各种网络翻译值，而注意力机制则重新定位这些向量。换句话说，注意力完全依赖于对齐。 为了模拟英语到法语翻译中的对齐问题，定义了以下玩具问题：

给定一些打乱的值输入。

[[ 0\.  1.], [17\. 18.], [10\. 11.], [13\. 14.], [14\. 15.], [ 2\.  3.] ... ]

将它们组织成顺序输出：

[[0\. 1.], [1\. 2.], [ 2\.  3.], [ 3\.  4.], [ 4\.  5.], [ 5\.  6.] ...]

实际上，给定之前的输出向量，提出给注意力机制的问题是：在给定的可能输出中，下一个应该出现哪个输出？ 这与英语到法语翻译中的语法问题非常相似，即：给定先前的输出单词，哪些输入与下一个输出相关？ 因此，通过解决这个玩具问题，我们可以展示注意力机制的强大功能，而不会过于深入细节。

定义对齐函数。

回顾对齐函数。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

上述讨论的对齐函数，来自于《通过共同学习对齐和翻译的神经机器翻译》(2014)。

这个函数本质上决定了给定前一个输出(si-1)的输入(hj)的权重(α)。这可以直接在 PyTorch 中实现：

"""
Implimenting the alignment function.

The whole idea is that, given an embedding for the encoder and decoder, the
alignment func outputs a scalar raiting the alignment. So, the shapes of
v, W, and U should be such that the output is a scalar.
"""

import torch
import torch.nn.functional as F

#defining the size of the input and output vectors of the attention mechanism
EMBED_DIM = 100

#these need to be sized in such a way that matrix multiplication yields a scalar
#otherwise, they're just general learnable parameters. Different alignment
#functions might have different parameters. For instance, "attention is all you
#need" uses a projection head that generates a query, key, and value, which are
#used in a different self-alignment function. this can allign vectors of different
#lengths
encoder_embedding_dim = EMBED_DIM*2
decoder_embedding_dim = EMBED_DIM

U_attention = torch.rand(EMBED_DIM, encoder_embedding_dim)
W_attention = torch.rand(decoder_embedding_dim, EMBED_DIM)
v_attention = torch.rand(1,EMBED_DIM)

def alignment_func(s, h, W=W_attention, U=U_attention, v=v_attention):
    """
    s: si-1, from the paper, the previous decoder state
    h: hj, from the paper, an input embedding
    W,U,v: trainable parameters

    calculates v*tanh(W*s + U*h), should return the scalar alpha
    """

    v1 = torch.matmul(W,s)
    v2 = torch.matmul(U,h)
    v3 = F.tanh(v1+v2)

    return torch.matmul(v, v3)

#testing the alignment function between one embedded word and another
#dividing by value to get them in a good range for tanh
s = torch.rand(decoder_embedding_dim)/50
h = torch.rand(encoder_embedding_dim)/50
alignment_func(s, h)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

对齐函数的示例输出。一个标量，对应于特定的输入输出对。

定义注意机制

对于给定的前一个输出，注意机制的任务是计算应关注哪些输入。这可以通过计算所有输入的对齐度，并将该对齐向量通过 softmax 来完成。

"""
defining attention, wich is a list of softmaxed alignment scores for all input
embeddings (hj) given the previous decoder embedding (si-1). This is equivilent
to a row of the attention matrix, hence the name of the function.
"""

def compute_attention_row(s, hs, W=W_attention, U=U_attention, v=v_attention):
    """
    computes alignments for all h values given s

    s is a vector of length embedding size
    hs is a tensor of shape (sequence length, embedding size)
    the output is a vector of sequence length
    """
    return F.softmax(torch.cat([alignment_func(s, h, W, U, v) for h in hs]),0)

#testing the computation of an allignment row between the previous decoder
#embedding and all encoder embeddings
compute_attention_row(torch.rand(decoder_embedding_dim)/50, torch.rand(10,encoder_embedding_dim)/50)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

给定输出位置的单个注意向量。

定义一个可学习的注意模块

现在我们需要将前面的函数封装到 PyTorch nn.Module中。这是以一种计算注意机制产生可追踪梯度的方式实现的，允许通过反向传播更新 U、W 和 V 参数。

此模块还支持不同的编码器和解码器嵌入，这可能在将此模块适应不同应用时非常有用。

"""
Defining the attention module
"""

from torch import nn

#defining the input dimension from the encoder (h) and decoder (s)
encoder_embedding_dim = 10
decoder_embedding_dim = 20

#defining an example sequence length
sequence_length = 15

class Attention(nn.Module):
    """
    -computes an alignment for all encoder embeddings
    -constructs a context vector using those embeddings
    -outputs that context vector
    """

    def __init__(self, embed_dim=EMBED_DIM, encoder_embedding_dim=encoder_embedding_dim, decoder_embedding_dim=decoder_embedding_dim):
        super(Attention, self).__init__()

        #learnable attention parameters
        self.U = nn.Parameter(torch.rand(embed_dim, encoder_embedding_dim), requires_grad=True )
        self.W = nn.Parameter(torch.rand(embed_dim, decoder_embedding_dim), requires_grad=True )
        self.v = nn.Parameter(torch.rand(1,embed_dim), requires_grad=True )
        self.encoder_embedding_dim = encoder_embedding_dim

        if torch.cuda.is_available():
            self.cuda()

    def forward(self, s, hn):
        """
        computes a batch of context vectors given a current the all encoder
        embeddings and the current decoder embedding
        """
        #defining a tensor consisting of a context vector for each batch
        weights = compute_attention_row(s, hn, W=self.W, U=self.U, v=self.v)

        return torch.sum(hn * weights[:, None], axis=0)

print('==== Testing Attention ====')
#testing if the attention mechanism can support different sequence lengths
#and embedding dimensions
test_attention = Attention()

#defining previous decoder state
s = torch.rand(decoder_embedding_dim)/50
#defining input embeddings
hn = torch.rand(sequence_length, encoder_embedding_dim)/50

test_attention(s, hn).shape

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

创建长度为 10 的上下文向量。这是合理的，因为输入嵌入的长度为 10，这种注意技术的输出是一个上下文向量，即所有输入嵌入的加权和。

训练

现在我们可以训练注意模块来解决玩具问题。这是通过生成 X/Y 对（一个相应的混洗和未混洗的集合），然后迭代每个输出应该是什么，并在模型错误时调整权重来完成的。

""" Training Attention

Essentially, this generates random X/Y pairs, and trains the model to predict
each output given the previous correct output and all of the inputs.

This is a proof of concept. In reality using minibatches, better initializations, and
stochastically providing the true previous output occasionally would probably improve
convergence and generalizability.
"""

import random
from tqdm import tqdm
import numpy as np
import matplotlib.pyplot as plt

min_len = 5
max_len = 20

test_attention = Attention(20,2,2)
loss_fn = nn.MSELoss()
optimizer = torch.optim.SGD(test_attention.parameters(), lr=1e-3, momentum=0.9)
lr_phase = 0

#training on some number of random sequences
batch_losses = []
for i in tqdm(range(800)):

    #generating x and y
    y = []
    x = []
    for j in range(random.randint(min_len,max_len)):
        y.append([j+1, j+2])
        x.append([j+1,j+2])
    random.shuffle(x)
    x = np.array([[0,1]] + x).astype(np.float32)
    y = np.array([[0,1]] + y).astype(np.float32)
    x = torch.from_numpy(x)
    y = torch.from_numpy(y)

    #iterating over all training examples (given s predict s+1)
    s_in = x[0]
    sample_losses = []
    for j in range(2,len(x)):

        y_this = y[j]

        optimizer.zero_grad()
        s_out = test_attention(s_in, x)

        loss = loss_fn(s_out, y_this)
        sample_losses.append(loss.detach())

        loss.backward(retain_graph=True)
        optimizer.step()

        s_in = torch.clone(y_this).detach()

    batch_loss = np.mean(sample_losses)
    batch_losses.append(batch_loss)

    #hacking together a simple learning rate scheduler
    if batch_loss<0.05 and lr_phase == 0:
        optimizer = torch.optim.SGD(test_attention.parameters(), lr=1e-4, momentum=0.9)
        lr_phase+=1

    #stopping training when loss is good enough
    if batch_loss<0.03:
        break

plt.plot(batch_losses)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

训练损失。如实现中所述，训练过程可以显著改进，以促进更好的收敛，但这对于我们的示例来说已足够。

结果

使用以下代码，我们可以生成一个随机混洗的序列，并让我们的注意模型对其进行排序。

"""
Visualizing alignment
"""

#generating x
x = []
for j in range(1, random.randint(min_len,max_len)):
    x.append([j,j+1])
random.shuffle(x)

x = np.array([[0,1]] + x).astype(np.float32)
x = torch.from_numpy(x)

#Extracting learned parameters for generating alignment visual
W = test_attention.W
U = test_attention.U
v = test_attention.v

s = x[0]
y_hat = []
rows = []

#predicting the next element in the sequence.
#skipping over the trivia first, and not predicting one after the last.
for _ in range(0,len(x)-1):

    #computing attention weights for this output, for visualization purposes
    row = list(compute_attention_row(s, x, W=W, U=U, v=v).detach().numpy())
    rows.append(row)

    #predicting what should be in this location.
    with torch.no_grad():
        s = torch.round(test_attention(s, x))

    y_hat.append(list(s))

#converting to numpy arrays
y_hat = np.array(y_hat)
x_p = np.array(x)

#printing intputs and predicted outputs
print('input: ')
print(x_p)
print('output: ')
print(y_hat)

#generating attention matrix plot
from matplotlib.ticker import MaxNLocator
alignments = np.array(rows)
plt.pcolormesh(alignments, edgecolors='k', linewidth=2)
ax = plt.gca()
ax.set_aspect('equal')
ax.yaxis.set_major_locator(MaxNLocator(integer=True))
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
plt.title('Algnment scores used in attention')
plt.ylabel('output index (each row is attention for an output)')
plt.xlabel('input index')
plt.show()

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

混洗后的输入、模型输出和对齐分数。

基于输出处理方式的一些伪影，但正如你所见，注意机制正确地将输入解混洗！

讨论

我们创建了一个通用的对齐模块，可以在更大的网络中使用，以关注关键信息。这直接受到用于英法翻译的模块的启发，但可以应用于各种应用场景。

关注更多！

在未来的文章中，我还将描述机器学习领域的几篇里程碑论文，重点是实际和直观的解释。变换器中使用的注意机制与这个注意机制有些不同，我会在未来的帖子中详细讲解。

请点赞、分享并关注。作为独立作者，你的支持确实能产生巨大的影响！

署名： 本文档中的所有图片均由丹尼尔·沃菲尔德创作，除非另有来源说明。你可以将本文中的任何图片用于你的非商业目的，只要你引用这篇文章，danielwarfield.dev，或两者都引用。

使用 Python 进行深度学习的音频分类

原文：towardsdatascience.com/audio-classification-with-deep-learning-in-python-cf752b22ba07

Kaggle 蓝图

调整图像模型以应对领域迁移和类别不平衡，使用 PyTorch 和 torchaudio 处理音频数据

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 Leonie Monigatti

·发表在Towards Data Science ·阅读时间 10 分钟·2023 年 4 月 4 日

–

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

使用机器学习对声音景观中的鸟鸣进行分类（图片由作者绘制）

欢迎来到另一期的“Kaggle 蓝图”，在这里我们将分析Kaggle比赛的获胜解决方案，以寻找可以应用于我们自己数据科学项目的经验教训。

本期将回顾“BirdCLEF 2022”比赛中的技术和方法，该比赛于 2022 年 5 月结束。

问题陈述：具有领域迁移的音频分类

“BirdCLEF 2022”比赛的目标是通过声音识别夏威夷鸟类。参赛者提供了单个鸟鸣的短音频文件，并要求预测特定鸟类是否出现在更长的录音中。

[## BirdCLEF 2022

在声音景观中识别鸟鸣

www.kaggle.com](https://www.kaggle.com/competitions/birdclef-2022/?source=post_page-----cf752b22ba07--------------------------------)

与普通的音频分类问题相比，此次比赛增加了以下挑战：

  • 领域偏移 — 训练数据由单一鸟类叫声的干净音频录音组成，且没有其他声音（几秒钟，长度不同）。然而，测试数据则由“在野外”录制的较长（1 分钟）“不干净”录音组成，并包含了除了鸟叫声之外的其他声音（例如风、雨、其他动物等）。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

音频数据中的领域偏移

  • 类别不平衡/少样本学习 — 由于某些鸟类比其他鸟类更为稀有，我们面临长尾类别分布的问题，其中一些鸟类只有一个样本。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

长尾类别分布

在这里插入你的数据！ — 为了跟随本文，你的数据集应如下所示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

在这里插入你的数据：你的音频数据集数据框应该如何格式化

将音频分类视为图像分类问题，并使用深度学习方法

竞争对手们在解决这个音频分类问题时，通常会采用以下方法：

  1. 将音频分类问题转换为图像分类问题，方法是将音频从波形转换为梅尔谱图，并应用深度学习模型

  2. 对波形和谱图中的音频数据应用数据增强，以应对领域偏移和类别不平衡

  3. 微调预训练图像分类模型，以应对类别不平衡

本文将使用 PyTorch（版本 1.13.0）作为深度学习框架，以及 [torchaudio](https://pytorch.org/audio/stable/index.html)（版本 0.13.0）和 [librosa](https://librosa.org/doc/main/index.html)（版本 0.10.0）进行音频处理。此外，我们还将使用 [timm](https://timm.fast.ai/)（版本 0.6.12）进行预训练图像模型的微调。

# Deep Learning framework
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.optim import lr_scheduler
from torch.utils.data import Dataset, DataLoader

# Audio processing
import torchaudio
import torchaudio.transforms as T
import librosa

# Pre-trained image models
import timm

准备工作：熟悉音频数据

在开始解决音频分类问题之前，让我们首先熟悉处理音频数据。你可以使用 torchaudio 库或 librosa 库中的 .load() 方法从不同的文件格式（例如 .wav、.ogg 等）加载音频及其采样率。

PATH = "audio_example.wav"

# Load a sample audio file with torchaudio
original_audio, sample_rate = torchaudio.load(PATH)

# Load a sample audio file with librosa
original_audio, sample_rate = librosa.load(PATH, 
                                           sr = None) # Gotcha: Set sr to None to get original sampling rate. Otherwise the default is 22050

如果你想直接在 Jupyter notebook 中收听加载的音频进行探索，可以使用以下代码提供音频播放器。

# Play the audio in Jupyter notebook
from IPython.display import Audio

Audio(data = original_audio, rate = sample_rate)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

在 Jupyter notebook 中显示加载数据的音频播放器

[librosa](https://librosa.org/doc/main/index.html) 库还提供了各种方法来快速显示音频数据以供探索。如果你使用 [torchaudio](https://pytorch.org/audio/stable/index.html) 加载音频文件，请确保将张量转换为 NumPy 数组。

import librosa.display as dsp
dsp.waveshow(original_audio, sr = sample_rate);

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

“Speech Commands” 数据集中的单词“stop”原始音频数据（波形）[0]

步骤 1：将音频分类问题转换为图像分类问题

一种使用深度学习模型对音频数据建模的流行方法是将 “计算机听觉” 问题转化为 计算机视觉 问题 [2]。具体来说，波形音频被转换为 Mel 频谱图（这是一种图像），如下所示。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

将音频文件从波形（时域）转换为 Mel 频谱图（频域）

通常，你会使用快速傅里叶变换（FFT）来计算性地将音频信号从时域（波形）转换到频域（频谱图）。

然而，FFT 会给出整个音频信号时间序列的整体频率成分。因此，在将音频数据从时域转换到频域时，你会丢失时间信息。

除了 FFT，你还可以使用短时傅里叶变换（STFT）来保留时间信息。STFT 是 FFT 的一种变体，通过使用滑动时间窗口将音频信号分成更小的部分。它对每个部分进行 FFT，然后将它们组合起来。

  • n_fft — 滑动窗口的长度（默认值：2048）

  • hop_length — 窗口滑动的样本数（默认值：512）。hop_length 将直接影响生成图像的大小。如果你的音频数据具有固定长度，并且你希望将波形转换为固定图像大小，你可以设置 hop_length = audio_length // (image_size[1] — 1)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

短时傅里叶变换（STFT）

接下来，你将把幅度转换为分贝，并根据 Mel 频率尺度对频率进行分箱。为此，n_mels 是频带数量（Mel 频带）。这将决定生成的频谱图的高度。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

将幅度转换为分贝并对频谱应用 Mel 分箱

关于 Mel 频谱图的详细解释，我推荐这篇文章：

[## 了解 Mel 频谱图

（以及信号处理中的其他主题）

medium.com](https://medium.com/analytics-vidhya/understanding-the-mel-spectrogram-fca2afa2ce53?source=post_page-----cf752b22ba07--------------------------------)

下面你可以看到一个示例 PyTorch Dataset，它加载一个音频文件，并在经过一些预处理步骤后将波形转换为 Mel 频谱图。

class AudioDataset(Dataset):
    def __init__(self, 
                df, 
                target_sample_rate= 32000, 
                audio_length
                wave_transforms=None,
                spec_transforms=None):
        self.df = df
        self.file_paths = df['file_path'].values
        self.labels = df[['class_0', ..., 'class_N']].values
        self.target_sample_rate = target_sample_rate
        self.num_samples = target_sample_rate * audio_length
        self.wave_transforms = wave_transforms
        self.spec_transforms = spec_transforms

    def __len__(self):
        return len(self.df)

    def __getitem__(self, index):

        # Load audio from file to waveform
        audio, sample_rate = torchaudio.load(self.file_paths[index])

        # Convert to mono
        audio = torch.mean(audio, axis=0)

        # Resample
        if sample_rate != self.target_sample_rate:
            resample = T.Resample(sample_rate, self.target_sample_rate)
            audio = resample(audio)

        # Adjust number of samples
        if audio.shape[0] > self.num_samples:
            # Crop
            audio = audio[:self.num_samples]
        elif audio.shape[0] < self.num_samples:
            # Pad
            audio = F.pad(audio, (0, self.num_samples - audio.shape[0]))

        # Add any preprocessing you like here 
        # (e.g., noise removal, etc.)
        ...

        # Add any data augmentations for waveform you like here
        # (e.g., noise injection, shifting time, changing speed and pitch)
        ...

        # Convert to Mel spectrogram
        melspectrogram = T.MelSpectrogram(sample_rate = self.target_sample_rate, 
                                        n_mels = 128, 
                                        n_fft = 2048, 
                                        hop_length = 512)
        melspec = melspectrogram(audio)

        # Add any data augmentations for spectrogram you like here
        # (e.g., Mixup, cutmix, time masking, frequency masking)
        ...

        return {"image": torch.stack([melspec]), 
                "label": torch.tensor(self.labels[index]).float()}

你生成的数据集在喂给神经网络之前应产生类似这样的样本：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

音频数据集中的样本结构

步骤 2：对音频数据应用增强

针对本次竞赛的领域转换和类别不平衡挑战，采用了对训练数据应用数据增强的技术 [5, 8, 10, 11]。你可以对波形和谱图的音频数据应用数据增强。[torchaudio](https://pytorch.org/audio/stable/index.html) 库已经提供了许多不同的音频数据增强方法。

在**波形（时间域）**中流行的音频数据增强技术有：

  • 噪声注入，如白噪声、有色噪声或背景噪声 ([AddNoise](https://pytorch.org/audio/stable/generated/torchaudio.transforms.AddNoise.html#torchaudio.transforms.AddNoise))

  • 时间转换

  • 改变速度 ([Speed](https://pytorch.org/audio/stable/generated/torchaudio.transforms.Speed.html#torchaudio.transforms.Speed)；或者使用 [TimeStretch](https://pytorch.org/audio/stable/generated/torchaudio.transforms.TimeStretch.html#torchaudio.transforms.TimeStretch) 频率域)

  • 改变音高 ([PitchShift](https://pytorch.org/audio/stable/generated/torchaudio.transforms.PitchShift.html#torchaudio.transforms.PitchShift))

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

不同音频增强技术概述：噪声注入（白噪声、有色噪声、背景噪声）、时间转换、速度和音高变化

在**谱图（频率域）**中流行的音频数据增强技术有：

  • 像 Mixup [13] 或 Cutmix [3] 这样的流行图像增强技术

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

用于谱图的数据增强：Mixup [13]

  • SpecAugment [7] ([FrequencyMasking](https://pytorch.org/audio/stable/generated/torchaudio.transforms.FrequencyMasking.html#torchaudio.transforms.FrequencyMasking) 和 [TimeMasking](https://pytorch.org/audio/stable/generated/torchaudio.transforms.TimeMasking.html#torchaudio.transforms.TimeMasking))

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

用于谱图的数据增强：SpecAugment [7]

如你所见，虽然提供了很多音频增强方法，[torchaudio](https://pytorch.org/audio/stable/index.html) 并未提供所有提议的数据增强方法。

因此，如果你想注入特定类型的噪声、时间转换，或应用 Mixup [13] 或 Cutmix [12] 数据增强，你必须 编写自定义数据增强代码（PyTorch）。你可以参考这个 音频数据增强技术集合 以了解它们的实现：

## Python 中的音频数据增强技术

如何用 librosa、numpy 和 PyTorch 对波形（时间域）和谱图（频率域）进行音频增强

towardsdatascience.com

在之前的 PyTorch Dataset 类示例中，你可以按照以下方式应用数据增强：

class AudioDataset(Dataset):
    def __init__(self, 
                df, 
                target_sample_rate= 32000, 
                audio_length):
        self.df = df
        self.file_paths = df['file_path'].values
        self.labels = df[['class_0', ..., 'class_N']].values
        self.target_sample_rate = target_sample_rate
        self.num_samples = target_sample_rate * audio_length

    def __len__(self):
        return len(self.df)

    def __getitem__(self, index):

        # Load audio from file to waveform
        audio, sample_rate = torchaudio.load(self.file_paths[index])

        # Add any preprocessing you like here 
        # (e.g., converting to mono, resampling, adjusting size, noise removal, etc.)
        ...

        # Add any data augmentations for waveform you like here
        # (e.g., noise injection, shifting time, changing speed and pitch)
        wave_transforms = T.PitchShift(sample_rate, 4)
        audio = wave_transforms(audio)

        # Convert to Mel spectrogram
        melspec = ...

        # Add any data augmentations for spectrogram you like here
        # (e.g., Mixup, cutmix, time masking, frequency masking)
        spec_transforms = T.FrequencyMasking(freq_mask_param=80)
        melspec = spec_transforms(melspec)

        return {"image": torch.stack([melspec]), 
                "label": torch.tensor(self.labels[index]).float()}

第 3 步：针对少样本学习微调预训练的图像分类模型

在这次比赛中，我们面临着类别不平衡的问题。由于一些类别只有一个样本，我们正在处理少样本学习问题。Nakamura 和 Harada [6] 在 2019 年表明，微调可能是少样本学习的有效方法。

很多竞争者[2, 5, 8, 10, 11]微调了常见的预训练图像分类模型，例如

  • EfficientNet（例如，tf_efficientnet_b3_ns）[9]，

  • SE-ResNext（例如，se_resnext50_32x4d）[3]，

  • NFNet（例如，eca_nfnet_l0）[1]

你可以使用[timm](https://timm.fast.ai/)库加载任何预训练的图像分类模型进行微调。确保将in_chans = 1设置为 1，因为我们处理的是 1 通道 Mel 谱图而不是 3 通道图像。

class AudioModel(nn.Module):
    def __init__(self, 
                model_name = 'tf_efficientnet_b3_ns',
                pretrained = True, 
                num_classes):
        super(AudioModel, self).__init__()

        self.model = timm.create_model(model_name, 
                                       pretrained = pretrained, 
                                       in_chans = 1)
        self.in_features = self.model.classifier.in_features
        self.model.classifier = nn.Sequential(
              nn.Linear(self.in_features, num_classes)
          )

    def forward(self, images):
        logits = self.model(images)
        return logits

其他竞争者报告了在类似音频分类问题上微调预训练模型的成功[4, 10]。

微调使用余弦退火学习率调度器（[CosineAnnealingLR](https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.CosineAnnealingLR.html#torch.optim.lr_scheduler.CosineAnnealingLR)）进行几个周期[2, 8]。

scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer,
                              T_max = ..., # Maximum number of iterations.
                              eta_min = ...) # Minimum learning rate.

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

PyTorch 余弦退火/衰减学习率调度器（图像由作者提供，原文发表于“PyTorch 学习率调度器视觉指南”）

你可以在这个深度学习模型微调指南中找到更多提示和最佳实践：

## 中级深度学习与迁移学习

这是一本实用指南，介绍了用于计算机视觉和自然语言处理的深度学习模型微调。

towardsdatascience.com

总结

从 Kagglers 在“BirdCLEF 2022”比赛期间创建的学习资源中，我们可以学到更多经验。这类问题陈述也有许多不同的解决方案。

在这篇文章中，我们集中讨论了许多竞争者中流行的一般方法：

  1. 通过将音频从波形转换为 Mel 谱图并应用深度学习模型，将音频分类问题转化为图像分类问题

  2. 将数据增强应用于波形和谱图中的音频数据以应对领域迁移和类别不平衡

  3. 微调预训练的图像分类模型以应对类别不平衡

享受这个故事了吗？

免费订阅 以便在我发布新故事时获得通知。

[## 当 Leoni Monigatti 发布时，获取电子邮件通知。

当 Leoni Monigatti 发布时，获取电子邮件通知。通过注册，你将创建一个 Medium 账户（如果你还没有的话）…

medium.com](https://medium.com/@iamleonie/subscribe?source=post_page-----cf752b22ba07--------------------------------)

在 LinkedIn、Twitter 和 Kaggle 上找到我！

参考文献

数据集

由于原始比赛数据不允许商业使用，示例使用了以下数据集。

[0] Warden P. Speech Commands: 一个用于单词语音识别的公共数据集，2017。可从 download.tensorflow.org/data/speech_commands_v0.01.tar.gz 获取

许可证：CC-BY-4.0

图像参考

除非另有说明，所有图像均由作者创建。

网络与文献

[1] Brock, A., De, S., Smith, S. L., & Simonyan, K. (2021 年 7 月). 高性能大规模图像识别，无需归一化。在 国际机器学习会议 (第 1059–1071 页)。PMLR。

[2] Chai Time Data Science (2022). BirdCLEF 2022: 第 11 位 Pos Gold 解决方案 | Gilles Vandewiele (访问日期：2023 年 3 月 13 日)

[3] Hu, J., Shen, L., & Sun, G. (2018). Squeeze-and-excitation 网络。在 IEEE 计算机视觉与模式识别会议论文集 (第 7132–7141 页)。

[4] Kramarenko Vladislav (2022). 第四名 在 Kaggle 讨论中 (访问日期：2023 年 3 月 13 日)

[5] LeonShangguan (2022). [公共 #1 私人 #2] + [私人 #7/8 (潜在)] 解决方案。主持人获胜。 在 Kaggle 讨论中 (访问日期：2023 年 3 月 13 日)

[6] Nakamura, A., & Harada, T. (2019). 重新审视少样本学习的微调。arXiv 预印本 arXiv:1910.00216。

[7] Park, D. S., Chan, W., Zhang, Y., Chiu, C. C., Zoph, B., Cubuk, E. D., & Le, Q. V. (2019). Specaugment: 一种用于自动语音识别的简单数据增强方法。arXiv 预印本 arXiv:1904.08779。

[8] slime (2022). 第三名解决方案 在 Kaggle 讨论中 (访问日期：2023 年 3 月 13 日)

[9] Tan, M., & Le, Q. (2019 年 5 月). Efficientnet: 重新思考卷积神经网络的模型缩放。在国际机器学习会议（第 6105–6114 页）。PMLR。

[10] Volodymyr (2022). 第一名解决方案模型（这不是全部 BirdNet） 在 Kaggle 讨论区（访问日期：2023 年 3 月 13 日）

[11] yokuyama (2022). 第五名解决方案 在 Kaggle 讨论区（访问日期：2023 年 3 月 13 日）

[12] Yun, S., Han, D., Oh, S. J., Chun, S., Choe, J., & Yoo, Y. (2019). Cutmix: 一种用于训练强分类器的正则化策略，具有可定位特征。在IEEE/CVF 国际计算机视觉会议论文集（第 6023–6032 页）。

[13] Zhang, H., Cisse, M., Dauphin, Y. N., & Lopez-Paz, D. (2017) mixup: 超越经验风险最小化。arXiv 预印本 arXiv:1710.09412。

音频数据占据中心舞台

原文：towardsdatascience.com/audio-data-takes-center-stage-21b32366abcd?source=collection_archive---------9-----------------------#2023-01-26

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 TDS Editors

·

关注 发表于Towards Data Science ·作为 Newsletter 发送 ·3 分钟阅读·2023 年 1 月 26 日

–

机器学习的一个子领域致力于文本数据（你好，自然语言处理），而视觉数据则推动了计算机视觉和图像生成应用的巨大增长。这两种数据类型都在 AI 工具的崛起中引起了我们的集体想象力，比如 ChatGPT、Midjourney 和 Stable Diffusion。

有时很容易忘记音频数据也是创新繁荣的领域，研究人员和行业参与者都在我们理解、处理和创造声音的方式上取得了重大进展。本周，我们将转向音频和音乐世界，重点介绍我们的作者最近探索的项目和工作流。

  • 打造一个属于自己的音乐播放器。 亚历山德拉·玛 的首篇 TDS 文章是一项有趣且原创的尝试：她试图打造一个专门（部分）播放 AI 生成的 lo-fi 嘻哈曲目的音乐播放器。在这个过程中，我们了解到很多关于使用 midi 文件进行模型训练的挑战——最后，我们也能享受一些酷炫、柔和的节拍。

  • 下一个作曲伙伴可能是… ChatGPT？ 过去几年里，罗伯特·A·冈萨尔维斯一直在尝试人类与 AI 之间的各种创意合作模式。最近，ChatGPT 的出现（你可能已经听说过）开启了一些新的可能性，在他最新的项目中，罗伯特利用这一工具为他提供特定类型的和弦进程和歌曲标题。（是的，你也可以听到这些结果！）

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片由 安娜·扎哈尔诺娃 拍摄，来源于 Unsplash

  • 识别口语的复杂艺术。 “多处理音频可能会使任何机器学习任务变得复杂，” 多里安·赫雷曼斯 说——但考虑到语音识别技术的迅速发展，这项努力非常值得。多里安的逐步教程邀请读者卷起袖子：跟随教程在 PyTorch 中构建一个神经网络，直接输入音频文件，然后将其转换为可以精细调整的声谱图。

  • 音频数据不够？增加已有数据。 从昂贵的计算资源到版权限制，马克斯·希尔斯多夫 认识到启动音频数据项目的困难。他接着介绍了数据增强的方法，帮助我们最大限度地利用现有音频，并解释了为什么你应该将 Spotify 的 Pedalboard 库加入你的工具包。

别急着走——我们还有几篇精彩的推荐阅读。这些内容特别适合搭配一些 AI 生成的 lo-fi 嘻哈音乐（或者波尔卡！每个人有不同的喜好）。

  • 正如Richmond Alake在他最新的文章中坚持的那样，数据讲故事是一项你可以（而且应该）培养的技能。他介绍的详尽路线图是早期职业从业者的一个很好的起点。

  • 我们很高兴分享的另一个适合初学者的指南是Hennie de Harder的线性编程和单纯形算法入门。

  • Louis Chan 发布了一个一站式资源，供任何人了解 SHAP 及其使用方法来解释你的模型输出。

  • 从干净的代码到稳固的组织，Jo Stichbury 鼓励数据从业者借鉴软件工程原则以确保你的协作项目顺利推进。

  • 如果你还没有尝试过合成数据，并且想要尝试一下，Zolzaya Luvsandorj的简明教程提出了生成模拟表格数据的几种方法。

  • 将他对数据分析和长跑这两个热情结合起来，barrysmyth 带来了关于塑造马拉松备赛模式的引人入胜的深度探讨。

如果你想支持我们发布的工作，最直接有效的方法是成为 Medium 会员。希望你考虑一下。

直到下一个变量，

TDS 编辑部

AudioGPT — 探索未来音乐创作的前景

原文：towardsdatascience.com/audiogpt-a-glimpse-into-the-future-of-creating-music-9e8e0c65069e

研究论文分析和解释

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 Max Hilsdorf

·发布于 Towards Data Science ·阅读时间 10 分钟·2023 年 5 月 2 日

–

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片来自 Pixabay。

随着 MusicLM 于 2023 年 1 月发布，音乐家和数据科学家都清楚了：AI 正在颠覆我们制作音乐的方式。就在几天前，下一代大型音频 AI 模型发布了。在这篇文章中，我们将探讨为什么我认为 这个模型可能是音乐制作重大技术变革的基础。

本文解决了以下问题：

  • 什么是 AudioGPT？

  • 它是如何工作的？

  • 它的能力和限制是什么？

  • 这对未来的音乐制作意味着什么？

什么是 AudioGPT？

AudioGPT 是由一群中美研究人员于 2023 年 4 月发布的研究项目 [1]。但它实际做了什么，它与 GPT 模型有什么关系？好吧，让我们问问它吧！

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

AudioGPT 回答了“什么是 AudioGPT？”的问题。图像由作者提供。

AudioGPT 是一个对话助手

从截图中可以看出，AudioGPT 可以在类似于 ChatGPT 的聊天界面中使用。实际上，对于大多数对话应用，它的工作方式与 ChatGPT 完全相同。AudioGPT 的一个独特功能是，除了文本外，聊天机器人还可以处理语音输入，先将音频转录为文本。因此，这是真正的对话助手，你可以根据需求与之对话或书写。

AudioGPT 能够执行各种音频任务

AudioGPT 的对话能力仅仅是一个支持功能。它的真正目的在于提供一个统一的体验来解决音频分析和生成领域中的多种任务。以下是它可以处理的一些任务的精选：

  • 音频标题： 使用文本描述音频信号的内容

  • 源分离： 将音频信号拆分成不同的事件（声音、噪音等）

  • 图像转音频： 生成符合图像内容的音频

  • 分数转音频： 根据文本、音符和音符时值生成歌声

  • 更多任务 我们稍后会讨论！

有趣的是，与 ChatGPT 相比，AudioGPT 能够接收和发送音频文件。例如，当我要求 AudioGPT 为我生成特定的声音时，它创建了这些声音，将其导出为 wav 文件，并将导出文件的位置发送给我。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

AudioGPT 被要求生成“狮子吼叫的声音，背景有赛车声”。图片由作者提供。

在我们能够理解这项技术对未来音乐创作的意义之前，让我首先向你展示 AudioGPT 实际上是如何工作的，以及它的优势和局限性。

AudioGPT 是如何实现的？

尽管 AudioGPT 对用户来说可能像一个典型的 AI 聊天机器人，但实际上在幕后还有更多复杂的工作。事实上，聊天机器人 AI（ChatGPT）仅作为用户请求与其他 AI 模型之间的翻译器。这种方法在图像（TaskMatrix）或文本（LangChain）等其他领域已经存在。让我们看看作者在他们的论文中提供的 AudioGPT 工作流程的插图 [1]。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

AudioGPT 的内部工作流程。图片来源于 Huang, Li, Yang, Shit 等（2023）[1]。

如你所见，工作流程被分为四个不同的步骤。让我们简要地了解一下所有步骤。

步骤 1：模态转换

AudioGPT 被设计用于处理语音和文本输入。因此，第一步是检查用户是通过文本还是语音与系统互动。如果输入是语音，则由类似于 Alexa 或 Siri 的语音识别系统将其转录并转换为文本。对用户而言，这个转换步骤应该是无缝的。

步骤 2：任务分析

在这个文本输入下，ChatGPT 接管并尝试理解用户的请求。无论你说“生成一个雷声效果的 wav 文件”还是“给我一个雷声”：ChatGPT 擅长理解相同问题的不同表述，并将请求映射到特定任务——在这种情况下是文本到音频的声音生成。

步骤 3：模型分配

一旦 ChatGPT 理解了请求，它会从系统中目前包含的 17 个模型中选择一个合适的模型。这 17 个模型中的每一个都以非常特定的方式处理特定任务。因此，ChatGPT 理解请求、找到正确模型并以模型可以处理的方式呈现用户请求至关重要。

步骤 4：响应生成

一旦找到并运行了合适的模型，它将生成一个输出。这个输出可以有各种不同的形式（音频、文本、图像、视频）。这时 ChatGPT 再次发挥作用。它收集模型输出并以用户可以理解和解释的方式展示给用户。例如，文本输出可能直接传递给用户，而音频输出将被导出，用户将收到一个指向导出音频的文件路径。

内存与聊天历史

解决一个任务是很棒的。然而，这种聊天机器人方法真正突出的地方在于，AudioGPT 可以查看整个对话历史。这意味着你总是可以引用之前对话中的请求、问题或输出，并让 AudioGPT 对其进行操作。在某种意义上，它感觉就像 ChatGPT，但具有接收和发送音频文件的能力。

AudioGPT 能做些什么？

在这一部分，我想给你一些来自论文的例子，展示 AudioGPT 能做什么。当然，这不是一个全面的列表，而只是一些有趣的亮点。

图像到音频生成

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图像到音频生成示例来自 Huang, Li, Yang, Shit 等（2023）[1]。

在这个例子中，AudioGPT 被要求生成与猫的图像相匹配的音频。系统随后会响应导出音频文件的位置和音频波形的可视化。我们不能听到这篇论文中的示例，但响应很可能是类似于猫的嘶嘶声或咕噜声。在后台，首先对图像进行描述，然后将图像描述合成成音频信号。这对于音乐家来说可能非常有帮助，只需输入他们所寻找的图像，就可以为音乐创建样本。

歌唱声音生成

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

歌唱声音生成示例来自 Huang, Li, Yang, Shit 等（2023）[1]。

现在，这对于音乐家来说非常相关！如果我们给模型提供文本以及音符和音符时长的信息，它会合成一个歌声并将音频发送给你。在后台，应用了最先进的语音合成模型（DiffSinger [2]，VISinger [3]）。很容易想象，这种技术可以直接应用在数字音频工作站（DAW）中，例如，为嘻哈节拍或甚至背景人声创建歌唱样本。

声音提取

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

声音提取示例来自 Huang, Li, Yang, Shit 等（2023）[1]。

基于文本提示，AudioGPT 识别音频信号中发生特定事件的位置，并为用户剪切掉无关的音频部分。仅使用语言提示来剪切样本或声音可能对音乐家极为有用。我们可能很快就能告诉我们的 DAW“提取这个样本中最具情感的部分并将其剪切为一小节”，而无需自己做任何机械工作。

来源分离

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

来源分离示例来自 Huang, Li, Yang, Shit 等（2023）[1]。

在这里，要求 AudioGPT 从音频信号中分离出两个说话者，并分别返回这两个提取出的说话者。目前，该系统中没有包括音乐源分离工具。然而，可以很容易地想象，我们可以通过聊天机器人界面在我们的 DAW 中直接提取特定的乐器或乐器组。

AudioGPT 的局限性是什么？

尽管这些例子展示了 AudioGPT 如何为未来的突破性技术奠定基础，但它仍然有很多局限性。

它不是为音乐而构建的

在本帖的背景下，需要注意的是，AudioGPT 尚不是一个很好的音乐分析或生成工具。目前唯一真正专用的音乐模型是歌唱声音合成模型。其他一些模型能够产生音乐声音，但主要是为语音和声音而非音乐构建的。

然而，这并不是系统本身的局限性。而主要是因为开发人员没有决定在该工具中包含更多专用音乐 AI 模型。在当前 AudioGPT 作为基础的状态下，将更多音频模型纳入该系统或构建一个独立的音乐专用系统是可行的。

这是一个正在进行中的工作

根据我使用 AudioGPT 的有限经验，我已经可以看出任务分配过程的效果不如我所希望的那样。许多时候，我的请求被误解，调用了错误的模型，导致完全无用的输出。似乎仍需要进行一些优化，以使该系统在理解用户需求方面越来越有能力。

此外，整体音频 AI 的现状仍远远落后于文本 AI。例如，AudioGPT 中包含的 17 个模型大多数运作尚可，但存在明显的局限性。因此，即使 AudioGPT 的任务分配完美，系统仍将受制于底层模型的能力。

这对音乐意味着什么？

AI 作曲/制作助手

目前，AudioGPT 对音乐家的工作和生活并没有真正的影响。然而，我估计这种情况在不久的将来会发生变化。要使这些系统在这个领域真正具有变革性，需要采取以下两个步骤：

  1. 扩展 AudioGPT 的音乐模型（源分离、标记、去噪、音频效果等）或构建一个专注于这些特定任务的独立 MusicGPT 模型。

  2. 开发插件，使音乐家能够通过聊天界面在他们的 DAW 中访问 AudioGPT（或 MusicGPT）。

显然，这不是一项容易的任务。特别是第二步可能是一个巨大的障碍。然而，在 DAW 中实现这样的聊天机器人可能是像苹果（Logic）、Ableton 或 Image-Line（FL Studio）这样的公司巨大的竞争优势。一个完善、领域特定且良好集成的 AudiGPT 版本可以显著提高创建音乐的效率、创造自由度和乐趣。

如果系统将当前项目中的所有音频和 MIDI 事件都存储在内存中，你可以随时使用简单的语音或文本命令来移动、编辑、组合、删除或增强这些事件。此外，创作过程中的一些事情很容易用语言表达，但手动执行却很困难。假设你想让你的歌曲听起来更加“放松”和“悠闲”。你是调整乐器选择、混音器、效果链和母带设置中的数百个旋钮，还是简单地告诉你的 AI 助手为你调整旋钮？我梦想有一个 DAW 插件，它允许我们在一个直观的聊天机器人界面内生成声音、应用效果、混音/母带处理我们的曲目、分离乐器、分析和标记音乐，以及更多。这种系统无疑能使我们在音乐创作流程中更加高效和富有创造力。

增强，而非替代

在过去几个月中，像 MusicLM 这样的生成模型引发了许多艺术家的生存恐惧。虽然无可争议的是 AI 将显著颠覆音乐产业，但我认为 AudioGPT 是一个很好的例子，说明这些技术可以增强而不是取代我们的音乐工作。聊天机器人界面对创建、编辑和重新安排声音非常有帮助，但它不作为一个自主的代理。作曲家或制作人的创造力、意图和情感才是赋予最终产品价值和意义的关键。

从长远来看，人类创作的音乐总是比 AI 创作的音乐对人类更有价值。这是因为音乐本质上是社会性的，是人们之间的一种沟通方式。对我们大多数人来说，音乐是否是用仅仅是声学乐器“手工制作”的并不重要。真正重要的是，无论在创作过程中使用了什么技术，都是由人类以受控的方式和作为个人创意表达的手段来利用这些工具。从这个角度看，扩展 AudioGPT 的功能并将其集成到音乐创作工具中，让我们能够从加速或提升创意的技术中获益，同时保持作为作曲家的价值和目的。

我该如何使用 AudioGPT？

作为程序员

作为程序员，你可以简单地克隆 AudioGPT GitHub 仓库，安装所有使用的模型，输入你的 OpenAI API 密钥，然后开始使用。这将允许你使用论文中展示的所有功能。

作为一个非技术人员

如果你不是程序员，你仍然可以在这个 HuggingFace 网络应用中有限度地使用 AudioGPT。要使用该系统，你需要一个 OpenAI API 密钥。这里 是如何获取密钥的教程。根据 OpenAI 目前的使用条款，你可能需要输入你的信用卡信息才能使用该令牌。这个密钥是必需的，因为 AudioGPT 在后台使用 ChatGPT。使用 ChatGPT 并不昂贵（截至 4 月 23 日，每 ~700 字约 0.002 美分。见 文档）。不过，如果你决定将此密钥用于 AudioGPT，建议在你的 OpenAI 账户中监控系统产生的费用。

不幸的是，这个 HuggingFace 网络应用对我来说一直运行不太好。当我上传文件时，通常会出现错误。音频输出有时完全错误，尽管我的请求似乎被理解了……如果你已经有了 OpenAI API 密钥，绝对应该尝试一下。如果没有，我不确定这个网络应用是否值得你去创建账户和密钥的努力。

参考文献

[1] 黄、李、杨、石等（2023）。《AudioGPT：理解与生成语音、音乐、声音和谈话头像》。arXiv:2304.12995v1

[2] 刘等（2021）。《DiffSinger：通过浅层扩散机制进行歌声合成》。arXiv:2105.02446

[3] 张等（2021）。《VISinger：使用对抗学习进行端到端歌声合成的变分推断》。arXiv:2110.08813

如果你喜欢这篇文章，可以看看我关于 MusicLM 的文章，即 Google 的突破性音乐生成模型：MusicLM：Google 解决了 AI 音乐生成问题吗？

利用大语言模型（LLMs）完善推荐知识图谱

原文：towardsdatascience.com/augmenting-intelligence-leveraging-llms-to-complete-recommendation-knowledge-graphs-a0585e311d3f

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 安东尼·阿尔卡拉兹

·发布于 Towards Data Science ·6 分钟阅读·2023 年 11 月 6 日

–

人工智能软件被用来提升本文文本的语法、流畅性和可读性。

随着互联网和在线平台的快速增长，用户面临的选择变得琳琅满目。推荐系统在预测用户偏好和推荐相关内容方面变得至关重要，从而帮助用户应对信息过载。然而，提供准确和个性化的推荐仍然是一个持久的挑战。

问题的关键在于通过建模用户行为来理解用户的真实兴趣和意图。推荐系统依赖于从用户数据中提取的模式，如浏览历史、购买记录、评分和互动。然而，现实世界中的用户数据通常是稀疏和有限的，缺乏捕捉用户意图细微差别所需的重要上下文信号。

因此，推荐模型无法学习全面的用户和项目表示。它们的建议最终往往过于笼统、重复或无关。冷启动问题使得新用户在活动历史较少的情况下问题更加复杂。企业也因客户体验不佳而遭受损失，导致收入损失。

这需要找到能够从用户数据中挖掘更深层次洞见的解决方案。一种新兴的方法是使用知识图谱来封装事实和实体之间的连接。构建良好的知识图谱在解决推荐系统中的关键挑战方面具有巨大的潜力。

知识图谱不仅仅是对用户-项目交互的建模。它们编码了跨多个实体的各种上下文元数据、属性和关系。这种多维度的链接结构模拟了人类记忆存储世界知识的方式。

通过在这些互联的知识上训练专门的图神经网络模型，推荐系统可以学习更具信息量的用户行为和项目特征的表示。丰富的理解导致了针对细化用户需求和场景的建议。

然而，这一愿景面临的障碍是现实世界的知识图谱远非完美。它们存在不完整性，缺少关键的连接和细节。这阻碍了推荐模型真正把握用户的上下文和意图。

幸运的是，语言模型的最新进展带来了希望。像 GPT-3 这样的预训练模型展示了卓越的自然语言生成能力，这得益于其广泛的世界知识。早期利用这种模型进行上下文学习以增强知识图谱的探索显示出很大的前景（Wei et al., 2023）。

在本文中，我们将深入探讨语言模型的增强智能如何转变知识图谱。我们将探讨像 GPT-3 这样的模型驱动的关系预测和属性丰富化等技术。通过综合实例，我们将展示语言模型增强的知识图谱如何解锁智能推荐系统的下一个层级。

知识图谱 — 编码连接

知识图谱将实体（用户、产品）表示为节点，将它们的关系表示为边。将用户与他们的兴趣、人口统计信息、购买历史等连接起来，可以让推荐系统学习更好的表示方式。

然而，基于用户数据的现实世界知识图谱通常存在稀疏性和不完整性。许多潜在的连接被简单地忽略，这限制了系统真正理解用户意图的能力。

这是大型语言模型（LLMs）承诺带来突破的地方。

LLMs — 增强智能

LLMs 因其生成出色的类人文本能力而获得了巨大的受欢迎程度。但更令人印象深刻的是，它们通过在大量文本语料库上进行预训练而编码的大量知识。

最近的研究探讨了利用这些知识来改进由图神经网络（GNNs）驱动的推荐系统。关键思想是使用 LLMs 增强现有的知识图谱，通过强化边缘和增强节点属性来实现。

LLMs 强化图连接

LLMs 可以预测用户和项目之间可能存在但在源数据中未明确出现的潜在连接。例如，通过分析用户的购买历史，它们可以建议用户可能感兴趣的相关产品。

这些 LLM 预测的链接有助于稠密化稀疏图谱，为偏好建模提供关键信号。强化边缘增强了邻域，并允许协作模式的出现。

LLMs 增强节点属性

知识图谱中的节点代表诸如用户和项目等实体。LLMs 可以基于与这些节点相关的文本数据增强其属性。

例如，产品描述和评论可以通过 LLMs 处理，以提取缺失的规格或标签。用户评论和帖子也可以类似地分析，以填补稀疏的个人资料信息。

这导致节点具有丰富的特征向量，克服了冷启动问题。增强的属性改善了语义，从而提供更好的推荐。

改进的建模与增强图谱

通过在 LLM 增强的知识图谱上训练图神经网络，推荐系统可以学习到更优的用户和项目表示。

改进的结构和节点特征导致了捕获细微偏好和项目特征的嵌入。这解决了许多推荐引擎面临的稀疏性和冷启动等关键挑战。

研究显示，通过在将图谱输入 GNN 架构之前使用 LLMs 增强图谱，可以显著提高召回率和降低延迟。

LLMRec 技术：

使用逐步方程增强知识图谱的 LLMRec 技术：

第 1 步：为 LLM 构建提示

首先，我们需要创建提供背景的提示，以便 LLM 生成有用的增强数据。

用于增强用户-项目连接：

PUI = {D, H, C, F}

其中：

  • PUI: 用户-项目交互提示

  • D: 任务描述

  • H: 用户的历史交互

  • C: 候选项

  • F: 所需的输出格式

用于增强节点属性：

PA = {D, E, F)

其中：

  • PA: 属性增强提示

  • D: 任务描述

  • E: 可用实体属性

  • F: 缺失属性的输出格式

第 2 步：从 LLM 获取增强数据

现在我们可以使用这些提示从 LLM 获取增强数据：

EA = LLM(PUI) 
AA = LLM(PA)

其中：

  • EA: 增强的用户-项目交互

  • AA: 增强的属性

  • LLM(): 语言模型（例如 GPT-3）

第 3 步：纳入增强

增强数据可以作为以下内容纳入：

E' = E + EA
A' = A + AA

其中：

  • E’: 原始交互和增强交互的联合

  • A’: 原始属性和增强属性的联合

第 4 步：训练增强推荐系统

推荐模型随后在改进后的图上进行训练：

θ* = argmaxθ P(θ|A', E')

其中：

  • θ*: 优化的模型参数

  • P(): 后验概率

数据稳健化技术

LLMRec 中用于处理增强数据噪声的去噪数据稳健化技术：

嘈杂用户-项目交互修剪

  • 在每次训练迭代后，将使用增强的用户-项目对计算的损失值按升序排序。

  • 修剪或丢弃一定比例的损失值最高的对。这些很可能对应于噪声或不可靠的样本。

  • 仅保留损失最小的最可靠对，以便在下一次迭代中进行训练。

  • 数学上，通过对损失张量进行排序和切片来实现：

Lsorted = SortAscend(L) 
Lpruned = Lsorted[0:N]

其中 N 是修剪后保留的样本数量。

通过 MAE 增强增强特征

  • 使用[MASK]标记掩盖图中部分增强的节点特征。

  • 使用掩码自编码器从掩码版本中重建原始特征。

  • 原始特征与掩码特征之间的特征重建损失作为正则化手段，以提高特征质量。

  • 从数学角度看，损失计算公式如下：

LFR = 1/|V| Σ (1 - f⋅f' / ||f||⋅||f'|| )

其中，f 是原始特征，f’是掩码特征，V 是掩码节点的集合。

这些技术共同作用，修剪不可靠的增强内容，并施加约束，以确保噪声人工数据不会降低性能。这导致使用高质量增强图谱的干净、稳健的训练过程。

无限可能性与 LLMs

知识图谱代表了构建更智能、更具上下文理解的下一代推荐系统的一个极具潜力的方向。通过编码多方面的实体连接，它们可以捕捉到细微的用户行为模式和项目关系。

然而，现实世界的知识图谱通常面临如稀疏性和不完整性等关键问题，这限制了它们的有效性。这正是大型语言模型通过预测缺失的连接和生成缺失的描述性属性提供颠覆性机会的地方。

正如我们通过详细的示例所见，像关系强化和属性增强这样的技术，借助 LLMs 可以显著增强现有的知识图谱。增强的智能如同缺失的拼图碎片，将各部分连接起来，创建一个更完整的图景。

在这种丰富的表示上训练图神经网络，释放了知识图谱的全部潜力。这使得学习复杂的用户和项目嵌入成为可能，从而捕捉细微和语义信息。

结果是能够真正理解用户上下文和意图的推荐系统。LLM 驱动的知识图谱为智能助手铺平了道路，这些助手可以满足细致的用户需求和场景。

随着语言模型的不断进化，它们的知识增强能力也将不断提升。通过因果推理和对话互动等进展，它们可能帮助构建解释性图谱，将推荐与用户行为和理由联系起来。

大规模应用确实需要解决计算开销和可能出现的算法偏差等挑战。但这些可能性使得这是未来推荐系统中最有前景的方向之一。

知识就是力量。在推荐系统领域，语言模型补充的知识图谱看似将释放这种力量。这标志着智能推荐的新纪元的开始。在这个时代，系统不仅仅是模式匹配，而是表现出对用户上下文和需求的更深刻理解，从而提供有针对性的建议。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

用 RAG 增强 LLM

原文：towardsdatascience.com/augmenting-llms-with-rag-f79de914e672

查看一个大型语言模型（LLM）模型如何回答 Amazon SageMaker 相关问题的端到端示例

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 Ram Vegiraju

·发表于 Towards Data Science ·9 分钟阅读·2023 年 10 月 10 日

–

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片来源 Unsplash

我在 Medium 上写了不少关于不同技术主题的博客，特别是关于 在 Amazon SageMaker 上托管机器学习（ML）模型。最近，我也对日益增长的生成式 AI/大型语言模型生态系统产生了兴趣（就像行业中的其他人一样，哈哈）。

这两个不同的领域让我产生了一个有趣的问题。我的 Medium 文章在教授 Amazon SageMaker 方面表现如何？ 为了回答这个问题，我决定实现一个利用 检索增强生成（RAG） 的生成式 AI 解决方案，并访问我的一些文章，以查看它能够多好地回答一些与 SageMaker 相关的问题。

在这篇文章中，我们将构建一个端到端的生成式 AI 解决方案，并利用一些流行的工具来实现这个工作流：

  • LangChain: LangChain 是一个流行的 Python 框架，通过提供现成的模块来帮助简化生成式 AI 应用程序，这些模块有助于提示工程、RAG 实现和 LLM 工作流编排。

  • OpenAI: LangChain 将负责我们生成式 AI 应用程序的编排，但大脑仍然是模型。在这种情况下，我们使用了 OpenAI 提供的 LLM，但 LangChain 也可以与不同的模型源集成，如 SageMaker 端点、Cohere 等。

注意：本文假设读者具有中级 Python 了解和对 LangChain 的基本了解。我建议参考这篇 文章 来更好地理解 LangChain 和构建生成性 AI 应用。

免责声明：我在 AWS 担任机器学习架构师，我的观点仅代表我个人。

问题概述

大型语言模型（LLMs）本身非常强大，通常可以在不依赖微调或额外知识/上下文的情况下回答许多问题。

然而，当你需要访问其他特定的数据源，尤其是最新数据时，这可能会成为瓶颈。例如，虽然 OpenAI 已经在大量数据语料库上进行了训练，但它并不知道我最近在 Medium 上写的文章。

在这种情况下，我们想要检查我的 Medium 文章在回答关于 Amazon SageMaker 的问题方面能提供多大的帮助。OpenAI 的模型已经从它们训练过的语料库中获得了一些关于 Amazon SageMaker 的知识。我们想要看到的是，通过让这些大型语言模型（LLMs）访问我的 Medium 文章，我们能提升多少性能。这些文章几乎可以作为一个为已经拥有大量知识库的 LLMs 提供的速查表。

我们如何为这些 LLMs 提供访问这些额外知识和信息的途径？

为什么我们需要 RAG

这就是 检索增强生成（RAG） 发挥作用的地方。通过 RAG，我们提供了一个信息检索系统，使我们能够访问所需的额外数据。这将帮助我们回答更高级的 SageMaker 问题，并增强我们的 LLM 知识库。要实现一个基本的 RAG 系统，我们需要几个组件：

  • 嵌入模型：对于我们提供访问的数据，这些数据不能仅仅是一些文本或图像，而是需要以数值/向量格式进行捕捉，以便所有自然语言处理模型（包括 LLMs）能够理解。为了转换我们的数据，我们利用了 OpenAI 嵌入模型，但也有多种不同的选择，如 Cohere、Amazon Titan 等，你可以评估它们的性能。

  • 向量存储：一旦我们拥有了嵌入，我们需要利用一个向量数据存储，不仅存储这些向量，还提供一种高效的方式来索引和检索相关数据。当用户有查询时，我们希望返回包含与该输入相似性的任何相关上下文。这些向量存储大多数由 KNN 和其他最近邻算法提供支持，以为初始问题提供相关上下文。在这个解决方案中，我们使用了 Facebook 的 FAISS 库，该库可用于高效的相似性搜索和向量聚类。

  • LLM 模型：在这种情况下，我们有两个模型，一个是用于创建嵌入的嵌入模型，但我们仍然需要主要的 LLM，它接收这些嵌入和用户输入以返回输出。在这种情况下，我们也使用默认的 ChatOpenAI 模型。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

RAG 流程（作者创建）

从本质上讲，你可以将 RAG 视为 LLM 的性能增强器，通过提供基础 LLM 可能尚未拥有的额外知识。在下一部分中，我们将探讨如何利用 LangChain 和 OpenAI 实现这些概念。

生成式 AI 应用与示例推理

要开始，你需要一个 OpenAI API 密钥，你可以在以下 链接 找到并安装。注意费用和 API 限制，以便了解定价结构。对于开发，我们在 SageMaker Classic Notebook 实例 中工作，但任何安装了 OpenAI 和 LangChain 的环境都应足够。

import os
os.environ['OPENAI_API_KEY'] = 'Enter your API Key here'

# necessary langchain imports
import langchain
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.embeddings.cache import CacheBackedEmbeddings
from langchain.vectorstores import FAISS
from langchain.storage import LocalFileStore
from langchain.document_loaders import PyPDFDirectoryLoader
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI

设置 LangChain 和 OpenAI 后，我们创建一个本地目录，存储十篇我的热门 Medium 文章作为 PDF。这将是我们为 LLM 提供的额外数据/信息。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Medium 文章（作者截图）

下一步，我们需要能够加载这些数据，并创建一个目录以存储我们生成的嵌入。LangChain 提供了许多工具，可以自动加载并拆分/切块你的数据。 切块 尤其重要，因为我们不希望生成的嵌入数据集过大。数据越大，可能引入的噪声也越多。

在这种情况下，我们使用 LangChain 提供的 PDF 加载器 来加载和拆分我们的数据。

# where our embeddings will be stored
store = LocalFileStore("./cache/")

# instantiate a loader: this loads our data, use PDF in this case
loader = PyPDFDirectoryLoader("sagemaker-articles/")

# by default the PDF loader both loads and splits the documents for us
pages = loader.load_and_split()
print(len(pages))

然后，我们实例化我们的 OpenAI 嵌入模型。我们使用嵌入模型创建我们的嵌入，并填充我们创建的本地缓存目录。

# instantiate embedding model
embeddings_model = OpenAIEmbeddings()

embedder = CacheBackedEmbeddings.from_bytes_store(
    embeddings_model,
    store
)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

嵌入生成（作者截图）

然后我们创建了 FAISS 向量存储并推送了嵌入的文档。

# create vector store, we use FAISS in this case
vector_store = FAISS.from_documents(pages, embedder)

然后我们使用检索问答链来将这些移动部件汇聚在一起。我们指定了上面创建的向量存储，并将 ChatOpenAI 默认 LLM 作为模型，该模型将接收输入和相关文档以获取上下文。

# this is the entire retrieval system
medium_qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(),
    retriever=vector_store.as_retriever(),
    return_source_documents=True,
    verbose=True
)

然后我们可以通过传入相同的提示并观察结果，比较模型在没有 RAG 的情况下与基于 RAG 的链的性能。让我们运行一系列不同难度的示例提示。

sample_prompts = ["What does Ram Vegiraju write about?",
                 "What is Amazon SageMaker?",
                 "What is Amazon SageMaker Inference?",
                 "What are the different hosting options for Amazon SageMaker?",
                 "What is Serverless Inference with Amazon SageMaker?",
                 "What's the difference between Multi-Model Endpoints and Multi-Container Endpoints?",
                 "What SDKs can I use to work with Amazon SageMaker?"]

for prompt in sample_prompts:

    #vanilla OpenAI Response
    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=prompt,
        max_tokens = 500)

    # RAG Augmented Response
    response_rag = medium_qa_chain({"query":prompt})

我们可以看到第一个问题本身非常具体于我的写作。我们知道 OpenAI 模型没有访问或了解我的文章，因此它给出的描述非常随机且不准确。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

OpenAI 回应（作者截图）

另一方面，我们的 RAG 链接访问了一些我的 Medium 文章，并生成了对我写作内容的相当准确的总结。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

RAG 回应（作者截图）

我们可以通过提出一些 SageMaker 相关的问题来测试这两种方法。我们从一个非常基本的问题开始：什么是 Amazon SageMaker？由于 OpenAI LLM 对此有了解，它会给出一个相当准确并且可以与我们基于 RAG 的方法相媲美的回答。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

OpenAI 与 RAG 回应（作者截图）

当问题开始变得更加具体和困难时，我们开始看到 RAG 的真正好处。一个例子是比较两种高级托管选项的提示：多模型端点 (MME) 和 多容器端点 (MCE)。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

MME 与 MCE（作者截图）

在这里我们看到，Vanilla OpenAI 的回答给出了一个完全不准确的答案，它对这两个最近的功能没有了解。然而，我的关于 MCE 与 MME 的具体 Medium 文章为模型提供了这些功能的背景，因此它能够准确回答查询。

借助 RAG，我们可以扩展我们 LLM 已经掌握的关于 SageMaker 的基础知识。在下一部分，我们可以查看不同的方法来改进我们所构建的原型。

我们如何提高性能？

虽然这是一个很好的解决方案，但还有很多改进空间以便于扩展。你可以用来改进基于 RAG 的性能的一些潜在方法包括以下几点：

  • 数据大小和质量：在这个案例中，我们仅提供了十篇 Medium 文章，仍然看到了良好的性能。为了提升效果，我们还可以提供我所有 Medium 文章的访问权限，或者任何带有“ SageMaker”标签的内容。我们还直接复制了我的文章而没有任何格式化，PDF 本身也非常无结构，清理数据格式可以帮助更好地分块，从而优化性能。注意： 使用的数据也必须仅依赖于你被允许用于目的的资源/文章。在这个例子中，以我的 Medium 文章作为来源没有问题，但始终确保你以授权的方式使用数据。

  • 向量存储优化：在这个案例中，我们使用了默认的 FAISS 向量存储设置。你可以调整的项包括向量存储索引的速度，以及检索和提供给 LLM 的文档数量。

  • 微调与 RAG：虽然 RAG 有助于获得领域特定的知识，但微调也是帮助 LLM 获得特定知识集的另一种方法。你需要在这里评估你的使用案例，以确定是微调更有意义，还是两者的结合。一般来说，如果你有优质的数据，微调表现非常出色。在这种情况下，我们甚至没有对数据进行格式化或调整，但仍能取得良好的结果。对于微调，数据的可用性和质量至关重要。有关这两种选项的详细分析，请参阅以下文章。

附加资源与结论

[## LangChain-Samples/Medium-SageMaker-Analyzer 在 master · RamVegiraju/LangChain-Samples]

示例展示了如何将 LangChain 与 GenAI 集成。通过创建一个…贡献于 RamVegiraju/LangChain-Samples 的开发。

github.com](https://github.com/RamVegiraju/LangChain-Samples/tree/master/Medium-SageMaker-Analyzer?source=post_page-----f79de914e672--------------------------------)

整个示例的代码可以在上述链接中找到。这是一个有趣的项目，用于评估我的文章的价值，同时展示如何将 RAG 集成到你的生成式 AI 应用程序中。在接下来的文章中，我们将继续探索更多生成式 AI 和 LLM 驱动的功能。

一如既往，感谢你的阅读，欢迎随时留下反馈。

如果你喜欢这篇文章，请随时通过 LinkedIn 与我联系，并订阅我的 Medium 新闻通讯。

八月刊：数据科学家的夏季读物

原文：towardsdatascience.com/august-edition-summer-reads-for-data-scientists-52d5ad64835b?source=collection_archive---------8-----------------------#2023-08-02

月刊

寻找一些启发性、引人入胜、发人深省的文章？你来对地方了

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 TDS 编辑

·

关注 发表在 Towards Data Science ·4 min read·2023 年 8 月 2 日

–

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片来源：Hari Nandakumar 在 Unsplash

现在是重新评估什么算作引人入胜的夏季阅读材料的时候了吗？我们认为是时候了。传统观念（以及许多市场部门）会让我们相信，温暖的天气和较慢的节奏要求低投入、低回报的娱乐活动：如果你愿意的话，可以把它看作是知识上的冰棒。

我们的作者们有不同看法。在过去几周中，我们分享了许多聪明而发人深省的文章，他们找到了愿意探讨复杂主题的接受者。成功的关键可能在于执行：如果一篇文章有吸引力的语调，并帮助我们扩展对当前数据科学和机器学习场景的认知，那么它就可以成为泳池边、火车上或者露营中的消遣。

我们希望您喜欢我们八月份那些富有启发性且易于阅读的选择。在我们深入探讨之前，我们还想感谢您的支持，特别向那些愿意通过成为 Medium 会员做出有意义贡献的人致以特别的感谢。

谈到Medium：这个平台对社区和讲故事的庆祝即将到来，TDS 的作家和读者都受到热烈邀请。Medium Day 将于 8 月 12 日举行，注册仍在进行中（免费）。到时见？

TDS 编辑

TDS 编辑精选

  • 到底女性都在哪里？（2023 年 7 月，10 分钟）

    最近几个月来，我们看到了许多关于大型语言模型输出中偏见的片段性报道。Yennie Jun的一项启发性研究采用了系统化方法，展示了语言模型在性别平等方面的深层问题。该研究强调，在 AI 工具完全普及到教育领域之前，解决这些偏见的重要性。

  • 普遍生成 AI 的环境影响（2023 年 7 月，15 分钟）

    “如果数十亿人开始每天广泛使用生成 AI，环境影响会如何？”也许我们离 AI 像那样普及的时刻还很远，但Kasper Groes Albin Ludvigsen现在就推动我们考虑技术对气候的影响，现在还有机会塑造其未来方向。

  • 全球数据晴雨表：世界上开放数据的当前状态是什么？（2023 年 7 月，8 分钟）

    政府发布的公开数据集的快速增长可能会让一些人认为我们正处于一个开放数据的黄金时代。迪亚·巴尔多希对数据可访问性和治理的概述采用全球视角，描绘了一个更复杂的故事：尽管取得了很大进展，但仍面临许多挑战（这些挑战往往在各地区和国家之间分布不均）。

  • ChatGPT 真的智能吗？（2023 年 7 月，11 分钟）

    如果你对夏季阅读的定义包括一个大而引人注目的问题和一个细致而深思的答案，你会喜欢蓝楚的最新文章。ChatGPT 等工具的当前和未来能力引发了激烈的争论，蓝楚的深度探讨是理解这些工具如何工作——以及为什么它们仍然远未具备类似人类的理解（更不用说意识）——的有用资源。

  • 迈布里奇德比：用人工智能赋予动物运动照片生命（2023 年 7 月，16 分钟）

    爱德华·迈布里奇的马的运动照片序列标志着 19 世纪后半叶新兴电影技术的到来；罗伯特·A·冈萨尔维斯利用这些动态图像展示了最近创新——生成性人工智能——在需求驱动下产生迷人视觉效果的力量。

  • 数据科学能找到大脚怪吗？（2023 年 5 月，14 分钟）

    对于数据科学家来说，利用核心工作流——如探索性数据分析、聚类和可视化——来追踪世界上最著名的神秘生物之一，还有什么比这更有趣的呢？布拉德利·斯蒂芬·肖以半开玩笑的方式尝试寻找大脚怪，展示了即使从最不可能的来源中也可以挖掘出有趣的见解。

原创特色

探索我们最新的资源和阅读推荐。

  • 关注 TDS 列表，发现我们最好的文章 充分利用我们最近推出（并频繁更新）的 Medium 列表，找到我们推荐的所有文章。

  • 让数据团队获得成功的决策 我们精心策划的文章集合，关于那些帮助数据团队脱颖而出、执行良好并产生可持续结果的选择。

热门文章

如果你错过了这些，这里是上个月 TDS 最受欢迎的文章。

  • Pandas 2.0：数据科学家的游戏规则改变者？ 作者：Miriam Santos

  • ChatGPT 代码解释器：它如何为我节省了数小时的工作 作者：Soner Yıldırım

  • 在本地使用 CPU 推理运行 Llama 2 进行文档问答 作者：Kenneth Leung

  • 用三种难度级别解释向量数据库 作者：Leonie Monigatti

  • 在 Colab 笔记本中微调你自己的 Llama 2 模型 作者：Maxime Labonne

  • 从分析到实际应用：客户生命周期价值的案例 作者：Katherine Munro

我们非常高兴在 6 月迎来了新一批 TDS 作者——他们包括维亚切斯拉夫·朱可夫、库洛德·艾拉米、赫特·特里维迪、迈克·琼斯、费利克斯·范·德伦、沙哈尔·戴维森、布雷克·阿特金森、安娜·维亚、杰克·布兰丁、索拉诺·托德斯基尼、埃伦·加布里利扬、帕特里克·米久拉博士和扬·坎蒂·米尔切克、达科塔·史密斯、维吉·巴拉戈帕拉克里希南、马克·德尔贝尔、马蒂亚斯·敏德、阿什利·张、戴夫·林、莉亚·阮、达莎·赫尔曼诺娃博士、约翰·梁和汉斯·范·达姆。如果你有有趣的项目或想法与我们分享，我们很乐意听取你的意见!

下个月见。

作者使用条款和条件

原文：towardsdatascience.com/author-terms-and-conditions-of-use-b9b3935ff999

最后更新于 2024 年 9 月

了解 TDS 发布的规则和细节

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 TDS Editors

·发表于 Towards Data Science ·阅读时间 1 分钟 ·2023 年 3 月 7 日

–

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片由 Leone Venter 提供，来源于 Unsplash

我们是一个利用 Medium 平台的出版机构，致力于帮助成千上万的数据专业人士分享他们的想法、知识和专长。

TDS 在不断发展和演变中也改变了与贡献者之间的关系条款。您可以在这里找到最新版本的条款：作者使用条款和条件——2024 年 9 月。

链接文档中的条款不会以任何方式更改、修改或替代您与 Medium 之间的关系，该关系受 Medium 服务条款 的约束。

如果您是当前或潜在的作者，并且对向 TDS 贡献有任何疑问，我们在 这里 解释了如何与我们联系。您还可以阅读我们作者使用条款和条件的先前版本：2023 年 8 月、2023 年 3 月、2022 年 8 月、2020 年 7 月。

Auto-Sklearn：如何通过自动化机器学习提升性能和效率

原文：towardsdatascience.com/auto-sklearn-how-to-boost-performance-and-efficiency-through-automated-machine-learning-2db116eafc8

了解如何利用 AutoML 来最大化你的机器学习工作流的结果

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 Thomas A Dorfer

·发布于 数据科学前沿 ·阅读时间 6 分钟·2023 年 4 月 11 日

–

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片由作者提供。

由于选择合适的机器学习模型以完成特定的预测任务的挑战，模型数量众多 让我们感到熟悉。除此之外，我们还需要找到最佳的超参数，以最大化模型的性能。

这些挑战可以通过自动化机器学习，即AutoML，在很大程度上得到解决。我说在很大程度上是因为，尽管名字中有“自动”一词，这个过程并不是完全自动化的，仍然需要用户进行一些手动调整和决策。

实质上，AutoML 使用户摆脱了数据预处理、模型选择、超参数优化和集成构建这些繁琐且耗时的任务。因此，这个工具包不仅节省了专家的宝贵时间，还使非技术用户能够进入机器学习领域。正如作者所说：

自动化机器学习提供了使机器学习对非机器学习专家可用的方法和过程，旨在提高机器学习的效率并加速机器学习领域的研究。

尽管市面上有许多 AutoML 包，例如 AutoWEKA、Auto-PyTorch 或 MLBoX，本文将重点关注 Auto-Sklearn —— 一个基于流行的 scikit-learn 包的库。

什么是 Auto-Sklearn？

Auto-Sklearn 是一个基于 Python 的开源库，它自动化了诸如数据和特征预处理、算法选择、超参数优化和集成构建等机器学习过程。为了实现这种高程度的自动化，该库利用了贝叶斯优化的最新进展，并考虑了在类似数据集上的过去表现。

更具体地说，它在三个关键方面改进了之前的方法。首先，它引入了贝叶斯优化 Bayesian optimization 的概念，该概念通过利用从之前运行中获得的信息，允许在多个数据集上高效地调整超参数。此外，它还使自动 集成构建成为可能，这些模型通过贝叶斯优化被考虑，从而进一步提高模型性能。最后，Auto-Sklearn 配备了一个高度参数化的机器学习框架，集成了来自 scikit-learn 的高性能分类器和预处理器，允许灵活且可定制的模型构建。

总的来说，Auto-Sklearn 包含 16 种分类器、14 种特征预处理方法和大量的数据预处理方法，这些方法共同形成了一个拥有 122 个超参数的假设空间。这些数字随着新版本的发布而不断变化。

这个库的实现非常简单。事实上，最棘手的部分是其 安装，因为它与 Windows 不兼容，并且在 Mac 上也报告了一些问题。因此，建议在 Linux 操作系统上运行它（提示： Google Colab 运行在 Linux 上，你可以将其作为实验的平台）。

安装完成后，Auto-Sklearn 只需四行代码即可运行：

import autosklearn.classification

clf = autosklearn.classification.AutoSklearnClassifier()
clf.fit(X_train, y_train)
predictions = clf.predict(X_test)

然而，仍然建议进行一些手动调整和参数化，以使用户的意图与模型的输出保持一致。现在让我们看看 Auto-Sklearn 在实践中的使用方法。

实际示例

在这个例子中，我们将比较一个使用默认参数的单一分类器——在这种情况下，我选择了一个 决策树分类器——与 Auto-Sklearn 的分类器性能。为此，我们将使用公开的 手写数字光学识别 数据集，每个样本由一个 8x8 的数字图像组成——因此，维度是 64。总的来说，这个数据集包含 1797 个样本，这些样本被分配到 10 个独特的类别（每个类别约 180 个样本）。

以下是这个数据集的一些样本：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片由作者提供。数据使用的许可信息：CC BY 4.0。

数据集可以加载到 Python 中，并按照以下方式划分为训练集和测试集：

from sklearn import datasets
from sklearn.model_selection import train_test_split

X, y = datasets.load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

基准：决策树分类器

首先，让我们在这个数据集上训练一个具有默认参数的简单决策树，并查看在这些条件下它的表现如何。

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

clf = DecisionTreeClassifier().fit(X_train, y_train)
y_pred = clf.predict(X_test)
accuracy_score(y_test, y_pred)

这个简单的方法得到了 86.67%的准确率——还不错，但并不特别出色。让我们看看是否可以用 Auto-Sklearn 超越这个结果。

Auto-Sklearn

在运行之前，让我们先定义一些参数：

  • time_left_for_this_task：搜索总时长的时间限制（以秒为单位）。这个限制越高，找到更好模型的机会就越大。默认值为 3600，表示 1 小时。

  • per_run_time_limit：对机器学习模型单次调用的时间限制。如果算法超过这个限制，模型拟合将被终止。

  • ensemble_size：添加到集成中的模型数量。如果不需要集成拟合，可以设置为 1。

现在我们可以使用 Auto-Sklearn 拟合一个模型。我们将让任务运行 3 分钟，并将单次模型调用的时间限制设为 30 秒：

import autosklearn.classification
from sklearn.metrics import accuracy_score

automl = autosklearn.classification.AutoSklearnClassifier(
    time_left_for_this_task = 3*60,
    per_run_time_limit = 30
)
automl.fit(X_train, y_train)
y_pred = automl.predict(X_test)
accuracy_score(y_test, y_pred)

这给了我们 98.67%的准确率——比我们简单的基准测试有了显著提升。

我们可以通过sprint.statistics()方法获取对训练过程的进一步见解：

print(automl.sprint_statistics())

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

截图由作者提供。

例如，我们可以看到我们最佳的验证得分为 98.88%，其中 30 个算法中有 23 个成功运行，6 个超时，1 个超出了内存限制。基于此，我们可以增加时间限制参数，看看是否能进一步提高性能。

使用leaderboard()方法，我们还可以可视化所有评估模型的结果表（供参考：该表格在一张棒棒糖图中可视化，这也是本文的特色图片）：

print(automl.leaderboard())

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

截图由作者提供。

关于进入集成模型的各个单独模型的更多细节，可以通过show_models()函数获取：

from pprint import pprint
pprint(automl.show_models(), indent=2)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这里只展示了 15 个模型中的 2 个。截图由作者提供。

注意： 尽管集成模型确实可以提升模型的性能和鲁棒性，但它们也有一些缺点，如复杂性增加、训练时间增加以及缺乏可解释性。可以通过以下方式停用集成拟合：ensemble_size=1。

Auto-Sklearn 2.0 —— 有什么新变化？

去年，Auto-Sklearn 进行了多项改进，并发布了一篇名为 “Auto-Sklearn 2.0: 通过元学习实现无干预 AutoML” 的论文。主要改进包括 (1) 早期停止，提高了效率并确保即使训练超时也能得到结果，(2) 改进的模型选择策略，包括多种方法来近似泛化误差以及添加 贝叶斯优化和 Hyperband (BOHB)，这是一种用于大规模超参数优化的多功能工具，以及 (3) 通过元学习进行的自动策略选择，免除了用户选择 AutoML 系统配置的烦恼。

结论

总结来说，Auto-Sklearn 是一个强大且用户友好的库，免除了用户在数据和特征预处理、模型选择、超参数调整及（如果需要）集成构建中的繁琐和耗时的任务。这已被证明可以显著提高各种机器学习任务的性能和效率。尽管需要 一些 用户输入，Auto-Sklearn 仍然相当自动化，因此也允许新手和非技术用户用几行代码实现复杂的机器学习解决方案。

想自己尝试一下吗？查看由 AutoML 社区提供的众多示例。

更多资源

喜欢这篇文章吗？

让我们联系吧！你可以在 Twitter、LinkedIn 和 Substack 上找到我。

如果你想支持我的写作，可以通过 Medium 会员进行，这样你可以访问我的所有故事以及 Medium 上其他成千上万位作家的作品。

[## 通过我的推荐链接加入 Medium - Thomas A Dorfer

阅读 Thomas A Dorfer（以及 Medium 上成千上万位作家的）每一个故事。你的会员费用直接支持…

medium.com

深度神经网络部署的自动调整

原文：towardsdatascience.com/auto-tuning-for-deep-neural-network-deployment-ff2324cb41d

什么，为什么，最重要的是……如何？

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 Federico Peccia

·发表于 Towards Data Science ·阅读时间 7 分钟·2023 年 9 月 1 日

–

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片由 S. Tsuchiya 提供，发布在 Unsplash。

介绍

比较不同神经网络（NN）架构的指标之一是训练所需的时间。需要几个小时？几天？几周？通常，通过更新训练所用的硬件可以改善这一点。用更强大的 GPU 替换性能较差的 GPU，将训练过程并行化到多个 GPU 上等。推理步骤也会发生类似的情况。我们是否将训练好的网络部署到嵌入式设备上，如微控制器？还是运行在移动设备上？也许网络太大了，我们需要嵌入式 GPU 或甚至服务器级 GPU 才能执行。

让我们选择其中一个。我们将神经网络编译为我们的设备，并测试其运行速度。哦，不！它没有达到我们的延迟要求！我们需要神经网络的运行时间小于 1 秒，而我们的神经网络却需要 2 秒！现在有什么选择？

  • 用更强大的设备替换当前设备： 这可能会非常麻烦，特别是在存在严格应用约束的情况下。也许你只能使用特定的、已认证的硬件。或者你有难以满足的能源约束。

  • 减少神经网络的复杂性： 这可能也很困难，因为如果不小心，可能会损失神经网络的质量指标。

  • 为你的特定硬件自动调整神经网络。

等等，这是什么？你所说的自动调优是什么意思？好吧，这就是本文的主题。继续阅读，了解这种令人着迷的技术。在这篇文章中，我将尝试从高层次的角度解释这个话题。如果你跟着我直到文章结束，你将会找到可以用来优化你的 NN 的软件框架示例，并附有它们教程的链接。

自动…为什么？

如果你阅读了我上一篇文章，你可能记得对计算机架构的一个非常简单的解释。在其中，我讨论了两个元素：计算单元和内存单元。

为了执行神经网络的一层，需要将数据在内存层次结构中传输，直到它到达计算单元。然后，计算单元将执行所需的数学操作，结果将存储在内存层次结构的某个级别。

我们将执行一个神经网络（NN）层的成本定义为表示推理质量的指标。例如，最常见的指标之一是延迟，即完成层执行所需的时间。另一个指标可能是能耗。

现在，有两个不同的方面会影响这个指标：

  • 实际执行数学操作的成本

  • 跨内存层次结构移动数据的成本

根据可用的硬件，计算单元可以非常复杂，也可以非常简单，或者在同一硬件上甚至可以有不同的计算单元。例如，第一个类型的例子是一个脉动阵列，它是一个复杂的数字电路，能够并行执行多个数学操作（如果你对这个话题感兴趣，可以查看我的文章）。一个简单的例子是一个算术逻辑单元（ALU），它能够在每个时间步长中仅执行两个元素之间的一个数学操作（例如，加法或乘法）。因此，第一个方面是选择在每个时间步长中需要插入到每个计算单元中的数据。

另一个方面是将数据从内存移动到计算单元。从最后一级内存级别到更接近的内存级别移动的数据越少越好。因此，主要的思想是尽可能少地移动数据，然后尽可能多地重用它。

让我们看一个例子来说明这一点，好吗？现在，我们想在这个硬件上执行以下数学操作，这被称为 1D 卷积：

如动画所示，基本思想是我们将滤波器叠加在输入上，每个时间步，我们将滤波器向右移动。在每个时间步，我们逐元素地将输入与滤波器相乘，并将结果累加在一起。这是一个典型的操作，在其 2D 版本中是卷积神经网络（CNN）中使用的基础操作。

我将提出一个理论硬件，仅用于说明目的，具有以下元素和成本（参考 1D 卷积所需的基本数学操作）：

  • 计算单元 1：成本为 5。

  • 计算单元 2：成本为 2。

  • 内存级别 1：读取和写入每个元素的成本为 1，但我们只能在此处同时存储 8 个元素。

  • 内存级别 2：读取和写入每个元素的成本为 4，我们可以在此处存储层所需的所有元素。

我们如何在这种理论硬件上运行 1D 卷积？例如，我们可以使用选项 A：

但我们也可以使用选项 B：

如你所见，我们可以以不同的方式映射相同的操作，从而获得不同的成本。选项 B 成本较低，不仅因为它使用了计算单元 2，还因为我改变了内存级别 1 中数据的重用方式。

自动…什么？

但如果没有硬件模型来获得成本，或者硬件太复杂而无法进行这种手动分析怎么办？我们需要一种方法来自动化特定操作在特定硬件上的最佳映射的搜索。这被称为 自动调优。这是一个我们自动化这种搜索的过程。

这对于整个神经网络如何工作？我们从预训练模型开始，并从中提取所有需要执行的不同操作。然后，对于每个操作，我们在主机计算机上运行搜索过程，方法是：

  1. 为选定的数学操作生成新的映射提议

  2. 为我们想运行推理的特定硬件编译映射提议

  3. 将编译映射发送到硬件，在那里我们将测量其成本

  4. 执行提议的编译映射

  5. 读取执行成本

  6. 选择下一个要测试的映射，并返回第 2 步

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图片由作者提供。自动调优过程的示意图

这里一个有趣的点是：我们如何实际选择下一步测试的映射（第 6 点）？嗯，可以尝试网格搜索方法，测试所有可能的映射。但这通常太慢，因为可能的映射提议的搜索空间可能太大，无法测试所有的映射。

另一种可能性是使用某种算法来指导选择下一个要测试的映射提案，而不是盲目地测试所有内容。主要目标是减少实际执行的映射提案数量，并尽量使用最少的测量次数找到最佳解决方案。这可以通过使用遗传算法或强化学习等方法来实现，从过去的测量中学习并预测未来测量的性能，从而能够舍弃可能不好的映射提案，仅尝试最有前景的。等一下，我们是在用 AI 优化 AI 吗？是的！这不是很棒吗？

自动……怎么做？

好的，这听起来很有前途，但我们实际上该怎么做呢？我们需要一种软件，允许我们定义需要对操作应用的不同转换，以获取不同的映射提案。我们需要自己编写这个搜索程序吗？

当然不是！有很多论文提出了建模技术和方法来解决自动调优过程，这是一个非常活跃的研究领域。像 Bolt [1]、Lorien [2]、Ansor [3] 或 Chameleon [4] 等作品就是解决这个问题的例子。

如果你正在寻找一些实用的框架，这些框架建立在类似的工作基础上，并提供如何运行此过程的教程和文档，我建议你查看以下内容：

  • TVM [5]: 一个端到端的编译器，接受来自不同框架的模型作为输入（PyTorch、Tensorflow Lite、Tensorflow、Keras、ONNX 等），并能够优化和部署网络以支持越来越多的目标（GPU、微控制器、自定义加速器等）。可以使用其 AutoTVM 或 AutoScheduler 模块来优化程序。

  • TensorComprehensions [6]: 提供基于遗传算法的自动调优器，并与 PyTorch 集成。

  • Tiramisu [7]: 一个多面体编译器，能够针对 NVIDIA GPU、Xilinx FPGA 和多核 x86 CPU。教程可以在 这里 找到。

结论

如果你的神经网络在资源受限的硬件上未能达到所需的性能，不要放弃！有一些技术可以提高其性能，例如本文中描述的自动调优方法。这并不是仅在科学论文中出现的神秘技术；一些提供的软件框架已经包括了几乎即插即用的教程。

试试看，如果你觉得有用，请在评论中告诉我！

欢迎在LinkedIn上关注我，并告诉我你对这篇文章的看法，或者如果你真的喜欢这篇文章，可以请我喝咖啡！

感谢阅读！

参考文献

使用 GitHub Actions 自动化机器学习部署

原文：towardsdatascience.com/automate-machine-learning-deployment-with-github-actions-f752766981b1

更快的市场推出时间和提高效率

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 Khuyen Tran

·发表于 Towards Data Science ·8 分钟阅读·2023 年 4 月 16 日

–

动机

设想这样一种情况：每个月都会开发出更准确的机器学习模型，并将其添加到主分支中。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

要部署模型，你必须将其下载到你的机器上，打包，并进行部署。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

然而，由于你可能还有其他责任，完成部署可能需要几天甚至几周，这会减缓发布过程，并占用本可以用于其他任务的宝贵时间。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

如果每次将新版本推送到主分支时，模型能够自动部署到生产环境，那该有多好呢？这就是持续部署派上用场的地方。

什么是持续部署？

在上一篇文章中，我们讨论了如何使用持续集成（CI）来测试代码更改，以便在合并到主分支之前进行验证。

## 使用持续集成构建可靠的机器学习管道

使用持续集成自动化机器学习工作流

towardsdatascience.com

在代码和模型经过成功测试后，可以利用持续部署（CD）自动将新模型部署到生产环境。自动化模型部署可以提供许多好处，包括：

  1. 更快的市场推出时间：持续部署减少了将新的机器学习模型发布到生产环境所需的时间。

  2. 提高效率：自动化部署过程减少了将机器学习模型部署到生产环境所需的资源。

本文将向你展示如何为机器学习项目创建一个 CD 管道。

随意在这里试玩和分叉本文的源代码：

[## GitHub - khuyentran1401/cicd-mlops-demo: 机器学习项目中的 CI/CD 演示]

CI/CD（持续集成/持续部署）是任何软件开发项目中的一个重要实践……

github.com](https://github.com/khuyentran1401/cicd-mlops-demo/?source=post_page-----f752766981b1--------------------------------)

构建 CD 管道

要构建 CD 管道，我们将执行以下步骤：

  1. 保存模型对象和模型元数据

  2. 上传模型到远程存储

  3. 设置一个平台以部署你的模型

  4. 创建一个 GitHub 工作流，将模型部署到生产环境

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

让我们详细探讨每一个步骤。

保存模型

我们将使用 MLEM，一个开源工具，来保存和部署模型。

使用 MLEM 保存实验的模型时，首先调用其 save 方法。

from mlem.api import save
...

# instead of joblib.dump(model, "model/svm")
save(model, "model/svm", sample_data=X_train)

完整脚本。

运行此脚本将创建两个文件：一个模型文件和一个元数据文件。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

元数据文件记录了模型对象的各种信息，包括：

  • 模型工件，例如模型的大小和哈希值，这些对于版本控制非常有用

  • 模型方法，如predict和predict_proba

  • 输入数据模式

  • 用于训练模型的 Python 需求

artifacts:
  data:
    hash: ba0c50b412f6b5d5c5bd6c0ef163b1a1
    size: 148163
    uri: svm
call_orders:
  predict:
  - - model
    - predict
object_type: model
processors:
  model:
    methods:
      predict:
        args:
        - name: X
          type_:
            columns:
            - ''
            - fixed acidity
            - volatile acidity
            - citric acid
            - residual sugar
            - ...
            dtypes:
            - int64
            - float64
            - float64
            - float64
            - float64
            - ...
            index_cols:
            - ''
            type: dataframe
        name: predict
        returns:
          dtype: int64
          shape:
          - null
          type: ndarray
        varkw: predict_params
    type: sklearn_pipeline
requirements:
- module: numpy
  version: 1.24.2
- module: pandas
  version: 1.5.3
- module: sklearn
  package_name: scikit-learn
  version: 1.2.2

查看元数据文件。

将模型推送到远程存储

通过将模型推送到远程存储，我们可以将我们的模型和数据存储在一个集中位置，GitHub 工作流可以访问该位置。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

我们将使用 DVC 来进行模型管理，因为它提供了以下好处：

  1. 版本控制：DVC 使得跟踪模型和数据的变化变得容易，方便回滚到之前的版本。

  2. 存储：DVC 可以将模型和数据存储在不同类型的存储系统中，例如 Amazon S3、Google Cloud Storage 和 Microsoft Azure Blob Storage。

  3. 可重复性：通过对数据和模型进行版本控制，实验可以使用完全相同的数据和模型版本轻松重现。

[## DVC 介绍：机器学习项目的数据版本控制工具]

就像 Git，但有数据！

towardsdatascience.com

要将 DVC 与 MLEM 集成，我们可以使用 DVC pipeline。通过 DVC pipeline，我们可以在 dvc.yaml 文件中指定创建某些输出所需的命令、依赖项和参数。

stages:
  train:
    cmd: python src/train.py
    deps:
      - data/intermediate
      - src/train.py
    params:
      - data
      - model
      - train
    outs:
      - model/svm
      - model/svm.mlem:
          cache: false

查看完整文件。

在上述示例中，我们在 outs 字段下指定了 model/svm 和 model/svm.mlem 作为输出。具体来说，

  • model/svm 被缓存，因此会上传到 DVC 远程存储，但不会提交到 Git。这确保了大型二进制文件不会减慢仓库的性能。

  • mode/svm.mlem 没有被缓存，因此不会上传到 DVC 远程存储，但会提交到 Git。这使我们能够跟踪模型的变化，同时保持仓库的大小较小。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

要运行管道，请在终端中输入以下命令：

$ dvc exp run

Running stage 'train':                                                                                                                          
> python src/train.py

接下来，在文件 .dvc/config 中指定模型将被上传到的远程存储位置：

['remote "read"']
    url = https://winequality-red.s3.amazonaws.com/
['remote "read-write"']
    url = s3://your-s3-bucket/

要将修改后的文件推送到名为“read-write”的远程存储位置，只需运行：

dvc push -r read-write

设置一个平台来部署你的模型

接下来，让我们找一个平台来部署我们的模型。MLEM 支持将模型部署到以下平台：

  • Docker

  • Heroku

  • Fly.io

  • Kubernetes

  • Sagemaker

该项目选择了 Fly.io 作为部署平台，因为它易于入门且便宜。

要在 GitHub 工作流中创建 Fly.io 应用程序，你需要一个访问令牌。以下是如何获取一个的步骤：

  1. 注册一个 Fly.io 账户（你需要提供信用卡信息，但在超出免费额度之前，他们不会收费）。

  2. 登录后，点击右上角的“账户”按钮下的“访问令牌”。

  3. 创建一个新的访问令牌并复制以备后用。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

创建一个 GitHub 工作流

现在进入激动人心的部分：创建一个 GitHub 工作流来部署你的模型！如果你对 GitHub 工作流不熟悉，我推荐阅读 这篇文章 以快速了解。

我们将在文件 .github/workflows/publish.yaml 中创建一个名为 publish-model 的工作流：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

文件内容如下：

name: publish-model

on:
  push:
    branches:
        - main
    paths:
        - model/svm.mlem

jobs:
  publish-model:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout 
        uses: actions/checkout@v2

      - name: Environment setup
        uses: actions/setup-python@v2
        with:
          python-version: 3.8

      - name: Install dependencies
        run: pip install -r requirements.txt

      - name: Download model
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        run: dvc pull model/svm -r read-write

      - name: Setup flyctl
        uses: superfly/flyctl-actions/setup-flyctl@master

      - name: Deploy model
        env:
          FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
        run: mlem deployment run flyio svm-app --model model/svm

on 字段指定了管道在推送到主分支时触发。

publish-model 任务包括以下步骤：

  • 检出代码

  • 设置 Python 环境

  • 安装依赖

  • 使用 DVC 从远程存储位置拉取模型

  • 设置 flyctl 以使用 Fly.io

  • 将模型部署到 Fly.io

请注意，为了使工作正常运行，需要以下内容：

  • 用于拉取模型的 AWS 凭证

  • 用于部署模型的 Fly.io 访问令牌

为了确保在我们的仓库中安全存储敏感信息，并使 GitHub Actions 能够访问这些信息，我们将使用 加密密钥。

要创建加密的密钥，点击“设置” -> “操作” -> “新建仓库密钥”。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

就这样！现在让我们尝试一下这个项目，看看它是否按预期工作。

试用

按照 这个 GitHub 仓库中的说明来试用项目。

一旦在仓库中创建了拉取请求，将启动一个 GitHub 工作流来对代码和模型进行测试。所有测试成功通过后，拉取请求将被合并。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

一旦更改被合并，将会触发一个 CD 管道来部署 ML 模型。

要查看工作流运行情况，点击工作流，然后点击publish-model任务。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

点击“部署模型”步骤下方的链接，以查看模型部署到的网站。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

这是网站的样子。点击“试用”来在样本数据集上测试模型。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

作者提供的图片

查看网站。

结论

恭喜！你刚刚学会了如何创建一个 CD 管道来自动化你的机器学习工作流。将 CD 与 CI 结合，可以让你的公司更早发现错误，降低成本，并缩短上市时间。

我喜欢写关于数据科学的概念和玩各种数据科学工具。你可以在 LinkedIn 和 Twitter 上与我联系。

如果你想查看我写的文章的代码，请给 这个仓库 点个星。关注我在 Medium 上的最新数据科学文章：

[## GitHub Actions 在 MLOps 中：自动检查和部署你的 ML 模型

使用 GitHub Actions 自动化你的 ML 管道

验证你的 pandas DataFrame 使用 Pandera [## 使用 Pandera 验证你的 pandas DataFrame]

确保你的数据符合预期

验证你的 pandas DataFrame 使用 Pandera [## 创建可观察且可复现的笔记本使用 Hex]

如何将笔记本集成到你的数据管道中

在 BigQuery 上使用 Fugue 和 Python 简化数据科学工作流程 [## 简化数据科学工作流程]

加快迭代速度并降低计算成本

在 BigQuery 上使用 Fugue 和 Python 简化数据科学工作流程

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值