介绍可观察的、自我记录的 ELT
Virevol ai 是一款协同视觉购物 app。我们经营一个远程优先的精益团队，已经有 2 年多了。为了施展我们的魔法，我们带着大量的数据畅游。
我们每天从数百个数据源中获取数百万行数据，在这些数据上运行我们的模型，并以各种方式为它们提供服务。我们在谷歌堆栈上，有 GCP 云功能、服务、容器，你能想到的都有。它们触发关于文件丢弃、队列消息、挂钩和时间表的其他事件。一切都是基于事件的，只是及时供应(我们很吝啬)。
我们的头脑中有太多的数据路径需要保留。
有了可观察的 ELT，我们可以通过匹配日志、输入、涉及它的每个作业的版本，追踪数据的来源，直到每一行。我们可以用美元做 ELT 会计，这是大多数 CTO 的白日梦。这使我们能够返工花费更多的管道部分，而不是所有遗留代码。
这就是我们保持理智的方法。我们如何在保持数据质量的同时快速发货？
数据如何移动
ETL 是一系列批处理作业。当一个完成时，下一个被触发。有时是两个，有时是 Y 形连接成一个。
你会得到一个有向图。图表很简单。
图表从上到下排列(如果您愿意，也可以从左到右排列)。
当中间的某个步骤中断或花费太长时间时，复杂性就产生了。想想鲁布·戈德堡机器。
或者更糟，如果什么都没发生。你会在理解数据的过程中发现错误。
为了管理这种复杂的管道协调，人们使用了各种各样的工具——Luigi、dbt、Airflow 等。
这是一种非常自上而下的乐器演奏方式。
最终用户只关心最后一步。如果报告需要在上午 9 点发出，而数据还没有准备好，你会接到电话。那是你的 SLA。
如果一项服务需要每 10 分钟为用户更新一次推荐，这就是您的 SLA。
遗憾的是，最终用户对 Dag 或花哨的工具不感兴趣。
当事情发生时，一个泪流满面的初级开发人员试图在凌晨 3 点调试“为什么”。她加入公司是为了涉足神经网络。但是被引诱，转而做 ETL。更糟糕的是，它被一些人称为“数据看门人的工作”，而不是它应该有的“数据 Lorax”。
她费力地翻阅一些本该发生的事情的文件。如果写这个的人还在那里工作，那就有点懈怠了。然后查看日志来搞清楚事情。如果她真的幸运的话，甚至可能会有一份关于这份工作的最新手册。她从 Pagerduty 跳到 JIRA，跳到 wiki，跳到 github，跳到日志。
鸟儿在远处歌唱，迎接黎明的到来。
可观察的 ELT
我们引入了一个新概念，叫做全局跟踪标识符，简称 tid。
每个将转换数据的函数、批处理作业或服务都需要获得一个特定运行的 tid。
它提供所有旧的 tid、其版本和实例变量(例如 X-AppEngine-QueueName、X-Appengine-Taskname)。这些记录在 service_tracker 表的 BigQuery 中。
下面是 python 中调用的样子
它必须用这个 tid 记录运行。
完成后，它必须将该行的 last_tid 列追加到这个。如果它是一个新行，它还必须将 tid 列填充到该行。向下滚动到“渐变尺寸”部分进行优化。
这是已经部署的 Google 功能，它可以满足我们的所有需求。
它是如何工作的？
让我们画一张图来概括这些情况:
这里 A，B，C，…F，都是不同的过程。各取一物，醒来，发一物，关机。但是我们不需要任何地方都有这样的记录图表。
那么我们如何产生它呢？
从插入到 D 末尾的表行的角度来看，我们有 A 的 tid，D 的 last_tid 跟踪到[B]，B 跟踪到[A]。
所以我们知道，A -> B -> D ->这一行。我们可以跟踪这里的每一行，以及生成它的代码版本。
我们来做一个更复杂的案例。
从插入到 F 末尾的表行的角度来看，我们有 A 的 tid 和 last_tid F，它们跟踪到[E，D]的 tid。我们可以追踪列表中提到的每一个 tid 来反转图表。
当有东西损坏(F)时，我们不会在数据仓库中为它获得一行。我们无畏的开发人员可以看看前面的运行，它将 F 引用为 prev_tid(它们有时间戳)。然后，她可以直接调试 F 运行的日志，并会在 e。
她可以做所有这些事情而不需要问任何人。你仍然需要服务 F 的操作手册，就在 github 里。
她从 pagerduty 转到 Google logging 和 github 寻找代码和问题。如果她发现服务有问题，她可以从那里更新并推送代码，这将触发 CI/CD 测试。
她可以用代码记录下来，并指出帮助她找到问题的 tid。该代码是最好的“当前”文档。该表是指向它的指针的时间序列。
我们还可以做更多的事情，我们可以审计每张桌子生产需要多长时间，以及生产链中的哪些工作导致了这种情况。我们可以计算出链何时改变(ML 作业 C 被插入到组合中)。
我们可以通过查看每个服务每次运行的成本来确定哪些遗留代码需要返工。这提供了一种新的优化方法。我们的优化不仅仅是通过“感觉”哪个代码最让我们厌烦，而是通过一个目标函数——成本。
把它想象成剖析一个程序，除了你看到的是函数和美元，而不是子程序计时。
我们来谈谈小而重要的细节，以获得更好的结果。
ELT not ETL
因为你的数据在云中，移动数据是你的账单中最大的份额。尽可能用 ELT 代替 ETL。数据将直接在服务器上转换并保存下来，只需要最少的传输。
因为另一个原因，它会更快。BigQuery 和大多数现代数据仓库正在它们的大型服务器集群上为您进行 map-reduce。您必须加快 k8s 实例的速度，才能在大负载下获得相同级别的性能。
为了获得最大的收益，请使用特定于数据库的 SQL，而不是抽象来转换数据。在这种情况下，编写 SQL 是合适的工具。克服它。
SQL 能有多复杂？作为一个练习，这里的是用 SQL 计算 tf-idf，只是为了好玩(实际上你可以使用类似 spaCy 的东西，因为你可能需要更多的步骤)。您也可以从示例中获得使 SQL 令人愉快的样式技巧。
对于可观察的 ELT，使用 Google 函数获取 tid 并从字典中运行参数化的 SQL。
类似这样的事情，
如果可以在 SQL 中全部完成，那么直接使用 merge 语句会更快(参见示例)。
哦，确保你有测试用例来测试你现在所有的 SQL。
渐变尺寸
我们用另外三个细节来美化生活。
一种是将每个表包装在视图后面。所以一个名为‘学生’的表就变成了‘v _ 学生’。这使得重构变得容易。这是我在租跑道的时候发现的，并保存了下来。
二是用一个版本的 SCD type 2 。
对于大多数重要的表，每一行都只是被追加，并按时间分区。顶部的视图使用 added_ts 上的 rank()给出了该表的最新版本。
这可能看起来很浪费，但它让我们保持理智，存储成本也没有人们想象的那么高。当旧分区变得太大时，我们总是可以丢弃它。
最后，每份工作都可以重新开始。这通常是大多数成熟数据团队的标准，我就不赘述了。
对于可观察的 ELT，我们必须发明一些新工具，但是我们不需要任何其他外部工具来进行协调。它与 Google Cloud 任务队列、Pub/Sub 和 Apache Beam pipes 共存。
到目前为止，我们很开心。一旦我们有了一个稍微大一点的团队为 10 亿客户服务，我们会让你知道我们是否还在。
这些想法也可以扩展到日志记录。我们最近在日志记录上看到了这个主题，并且很高兴尝试一下。
如果这给了你任何关于你自己的 ETL 流程的想法，我们很乐意听到你的意见。这种分散的方法应该有助于您更快地发货。
如果你喜欢解决具有挑战性的问题，并且是非传统的思考者，请联系。
引入明显无代码的机器学习解决方案
最佳数据科学自动化。
几天前，来自apparent . ai的几个人联系我，介绍他们的服务——一个完全无代码的机器学习自动化工具。起初我有点怀疑，因为我总是对所谓的全自动解决方案持怀疑态度，但我决定试一试。我将在本文中分享我的想法，并讨论服务是否值得一试。
由埃克托尔·j·里瓦斯在 Unsplash 上拍摄的照片
我发现很难看到像这样的工具自动化机器学习，并减少中小型公司对机器学习工程师的需求。原因有很多，但最大的原因是机器学习的目的是自动化其他职业，但我们已经成功地用机器学习自动化了机器学习。干得好。
这并不完全是一件坏事，因为我们现在可以专注于更重要的事情，而不是一个接一个地拟合算法，目的是挤压额外的 0.15%的精度。
那么，什么是明显的 AI 呢？
他们的主页上的英雄部分解释得很好:
一次单击即可构建 ML 算法、解释结果和预测结果的整个过程。
在玩了一会儿之后，我必须说它确实有用。*那么，这里面有什么蹊跷？*好问题。在这个时代，我们已经习惯了昂贵的解决方案，显然 AI 也不例外。它有一个非常不错的免费计划，仅限于不超过 50，000 行的 CSV 文件。这对于基础探索来说绰绰有余了。
我目前在免费计划中，对我的需求来说已经足够了。我们现在将通过一个具体的例子，用这项服务训练一个机器学习模型，你会看到整个事情是多么愚蠢简单。
在我们开始之前，我想做一个简短的免责声明。尽管的人显然要求我审查他们的服务，但我与他们没有任何关系，我也不会试图说服你转而使用付费账户。我说的一切纯粹基于免费版。
注册和设置
就在这一步，第一件怪事发生了。我已经打开了注册页面，并被提示输入一个电子邮件。奇怪的是，我的个人 Gmail 账户没有资格注册。
一个商业电子邮件帐户是必须的。
我有一个公司的商业电子邮件账户，所以这不是问题，但对你们中的一些人来说可能是一个障碍。我无法证实其他电子邮件提供商是否发生了同样的事情，但 Gmail 目前无法工作。奇怪。
然而，我已经完成了注册过程并验证了电子邮件地址，然后我看到了一个漂亮的仪表板:
有一些内置的样本数据集，但我想这些工作完美无缺。我们不会将这些用于我们的机器学习任务，而是将使用一个众所周知的葡萄酒数据集。让我们在下一部分建立一个模型。
建立模型
如前所述，这一步非常简单。首先要做的是上传数据集。我们将使用侧边栏上的添加数据集按钮来完成此操作:
单击后，应该会出现一个模态，我们可以在上面拖放(或单击以上传)数据集。记住这些约束(免费版):
- 文件大小必须小于 25MB
- 必须至少有 1000 行
- 必须至少有 5 列
我们的葡萄酒数据集通过了所有这些条件，所以我们可以上传它:
上传完成后，我们将进入这个展示良好的探索模式:
从这里开始，我们只需要按照说明。让我们点击用于预测按钮。我们几乎完成了准备工作。在下一个模态窗口中，我们只需要选择目标变量:
就是这样！服务抱怨我们应该减少目标变量中唯一值的数量，但是我们可以忽略这一点。要完成，只需点击开始预测按钮。你要做的就是这些。
模型被训练。完成了。就这么简单。
这并不意味着这个模型是好的，所以我们将在下一节探讨它的表现。
模型评估
一旦模型经过训练，我们就会看到报告仪表板。它由几个部分组成:
- 司机
- 人物角色
- 出口预测
- 高级分析
- 技术规格
我们将在这里探索其中的几个，第一个是驱动区域。
司机区
简单地说，这个区域告诉我们哪些变量对预测最重要，因此哪些变量的预测能力最强。在我们的例子中，变量density、alcohol和free_sulfur_dioxide是前 3 个:
格式美观，易于理解。我们继续吧。
导出预测区域
如果不对新的、以前看不见的数据进行预测，机器学习就没有意义。不幸的是，这正是免费版的不足之处。我们可以通过上传以前未见过的数据的 CSV 来进行预测——只有属性，没有目标变量。
免费版提供的就这些。对你来说可能已经足够了，但我期待看到更多。
付费版本得到的是 REST API 形式的模型的部署版本，这使得从任何编程语言进行预测都容易得多:
不幸的是，免费版不支持这个选项，但是你能责怪他们吗？
技术规格区
此区域显示有关模型的一些基本信息，例如使用了哪种算法，训练、测试和验证子集的准确度如何，等等:
这是一个很好的部分，可以让你对你的模型有一个基本的了解，但仅此而已。
显然，这篇介绍性文章到此就差不多了。让我们在下一部分总结一下。
在你走之前
简而言之，显然很棒，也是一个值得推荐的简单服务。对于中小型企业，我甚至可以将它视为唯一的数据科学解决方案，由一个或多个软件开发人员维护，他们通过几次点击来训练模型，并通过 API 调用来进行预测。
当然，数据科学团队可以提供更好的解决方案，但该团队可能每月花费数万美元，而该解决方案最昂贵的选项每月不到 200 美元。你算算。
从一开始就很明显，数据科学将成为软件工程的另一种风格，但正是像这样的服务改变了即使是最顽固的个人的想法。
*你有什么想法？你试过了吗？*欢迎在评论区留下你的想法。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
简介 Profiler，作者:Auptimizer:为您的目标设备选择最佳的人工智能模型——无需部署
剖析器 是一个用于剖析机器学习(ML)模型脚本性能的模拟器。探查器可以在开发管道的训练和推断阶段使用。它对于评估部署到边缘设备的模型和脚本的脚本性能和资源需求特别有用。Profiler 是au optimizer的一部分。您可以从auoptimizer GitHub 页面 获取 Profiler，或者通过 pip 安装 auoptimizer。
我们为什么要建立 Profiler
在过去几年里，云中训练机器学习模型的成本大幅下降。虽然这种下降将模型开发推到了云上，但是仍然有重要的原因来训练、适应和部署模型到设备上。性能和安全性是两大因素，但成本节约也是一个重要的考虑因素，因为传输和存储数据的成本以及为数百万台设备构建模型的成本往往会增加。毫不奇怪，尽管云计算变得更加便宜，但针对边缘设备或边缘人工智能的机器学习继续成为主流。
为边缘开发模型为从业者带来了有趣的问题。
- 型号选择现在包括考虑这些型号的资源需求。
- 由于在回路中有一个设备，训练-测试周期变得更长，因为现在需要在设备上部署模型来测试其性能。只有当有多个目标设备时，这个问题才会被放大。
目前，有三种方法可以缩短型号选择/部署周期:
- 使用在开发机器上运行的特定于设备的模拟器，不需要部署到设备上。*警告:*模拟器通常不能跨设备通用。
- 使用目标设备自带的分析器。*警告:*他们需要将模型部署到目标设备上进行测量。
- 使用 FLOPS 或乘加(MAC)运算等方法来给出资源使用的近似度量。*警告:*模型本身只是整个管道(还包括数据加载、增强、特征工程等)的一部分(有时是无关紧要的)。)
在实践中，如果您想要选择一个能够在目标设备上高效运行的模型，但是无法访问专用的模拟器，那么您必须通过在所有目标设备上部署来测试每个模型。
Profiler 有助于缓解这些问题。 Profiler 允许您在开发机器上模拟您的训练或推理脚本将如何在目标设备上执行。使用 Profiler，您可以了解 CPU 和内存的使用情况，以及目标设备上模型脚本的运行时间。
探查器的工作原理
Profiler 将模型脚本、它的需求和相应的数据封装到 Docker 容器中。它使用用户输入的计算、内存和框架约束来构建相应的 Docker 映像，因此脚本可以独立运行，不依赖外部。然后，可以轻松地对该映像进行缩放和移植，以简化未来的开发和部署。当模型脚本在容器中执行时，分析器跟踪并记录各种资源利用率统计信息，包括平均 CPU 利用率、内存利用率、网络 I/O 和块 I/O 。记录器还支持设置采样时间，以控制 Profiler 从 Docker 容器中采样利用率统计信息的频率。
获取分析器:单击此处
探查器如何帮助
我们的结果表明，Profiler 可以帮助用户为许多流行的图像/视频识别模型建立良好的模型运行时间和内存使用估计。我们在三种不同的设备上进行了 300 多次实验，这些设备包括各种型号(InceptionV3、SqueezeNet、Resnet18、mobilenet v2–0.25 x、-0.5x、-0.75x、-1.0x、3D-SqueezeNet、3D-shuffle net v2–0.25 x、-1.0x、-1.5x、-2.0x、3D-mobilenet v2–0.25 x、-0.5x、-0.75x、-1.0x、-2.0x)您可以在这里找到全套实验结果以及如何在您的设备上进行类似实验的更多信息。
Profiler 的加入使 Auptimizer 更接近一种工具的愿景，这种工具可以帮助机器学习科学家和工程师为边缘设备建立模型。au optimizer 的超参数优化(HPO)功能有助于加快模型发现。Profiler 有助于选择正确的部署模型。它在以下两种情况下特别有用:
- 在模型之间做出决定——使用开发机器上的 Profiler 测量的模型脚本的运行时间和内存使用情况的排名表明了它们在目标设备上的排名。例如，如果在开发机器上使用 Profiler 测量时，Model1 比 Model2 快，那么在设备上 Model1 将比 Model2 快。只有当 CPU 满负荷运行时，这个排名才有效。
- 预测设备上的模型脚本性能—一个简单的线性关系将使用开发机器上的探查器测量的运行时间和内存使用情况与使用目标设备上的本机分析工具测量的使用情况联系起来。换句话说，如果一个模型在使用 Profiler 测量时运行时间为 x，那么它在目标设备上的运行时间大约为(a*x+b)(其中 a 和 b 可以通过使用本机分析工具分析设备上的几个模型来发现)。这种关系的强度取决于模型之间的架构相似性，但是，通常，为相同任务设计的模型在架构上是相似的，因为它们由相同的一组层组成。这使得 Profiler 成为选择最适合的模型的有用工具。
展望未来
分析器在不断发展。到目前为止，我们已经在选定的移动和边缘平台上测试了它的功效，用于运行流行的图像和视频识别模型进行推理，但还有更多需要探索。探查器可能对某些型号或设备有限制，可能会导致探查器输出和设备上的测量值不一致。我们的实验页面提供了更多关于如何使用 Profiler 设置您的实验以及如何解释结果中潜在的不一致的信息。确切的用例因用户而异，但我们相信 Profiler 适用于任何在设备上部署模型的人。我们希望 Profiler 的评估功能能够为资源受限的设备提供更精简、更快速的模型开发。我们很乐意听到(通过 github)您是否在部署期间使用 Profiler。
作者: Samarth Tripathi、Junyao Guo、Vera Serdiukova、Unmesh Kurup 和 Mohak Shah——LG 电子美国公司高级人工智能
PyLathe 简介:使用 Julia 在 Python 中使用车床
什么是语言界限？
使用 PyLathe
Py 车床 0.1.0 已经在 Github 和 Python 包索引(PyPi)中正式发布。)当然，PyLathe 通过它将车床的美妙舒适带入了 Python，但也有一些警告，希望这些问题能在模型的未来版本中得到解决。要安装 PyLathe，就像使用 Pip 一样简单:
sudo pip(3) install PyLathe
注意:这个模块与 Python 2 不兼容。
在 0.1.0 之前的几次迭代中，您必须实例化您的 Lathe 包，并包含一个用于将添加到您的环境中的 Lathe 源文件的目录。所有这些都使得安装非常复杂，谢天谢地，现在已经改变了。从模块中，我们将需要一个名为“ClassicEnvironment”的类，来自库“Runtime”。
环境
环境是 Python 和 Lathe 之间面向对象的桥梁。“ClassicEnvironment”是一个使用系统范围的 Julia 环境来实例化 Julia 包的环境。虽然目前没有其他可用的环境，但在未来，虚拟环境和多环境都将可用。虚拟环境将在后端为 Julia 运行时即时创建一个虚拟环境。另一方面，多环境将允许在虚拟环境之间切换，包括全局环境。
营造环境
创建我们的环境的第一步是确保我们有正确的包。PyLathe 唯一依赖的 Python 包是 julia.py，所以我们需要它。好消息是包管理器 Pip 应该为您处理所有这些事情。也就是说，基于 Debian/Ubuntu 的发行版中的 julia.py 包有一个已知的缺陷。由于我使用 Fedora，这不会影响我，通过一些实验，它可能会得到解决。该问题源于 Debian 上的 Apt 包管理器将 Julia 可执行文件放在了与预期不同的目录中。
当然，安装 Julia 也是至关重要的，最好安装了车床和数据框架(车床依赖于它)。好消息是，如果你不知道如何做，或者不想做这一步，你不必做！只要能够找到 Julia 可执行文件，该模块就应该可以加载，并且会在初始化时安装车床。所以让我们
来自车床。运行时导入经典环境
应该注意的是，在这个包的早期版本中，没有测试，也没有异常处理，这是使用这个包最大的潜在障碍。
现在，我们可以像构建其他变量一样构建我们的环境:
在加载和初始化方面，就是这样！我们的环境已经完全加载完毕，随时可以运行！
构建工具
从这个环境中，我们现在可以通过首先为 Julia 构造一个包管理器(Pkg)来导入我们可能需要的任何 Julia 包。)这也很简单，代码如下:
pacman = env.pacman
然后我们可以像使用 Pkg 一样使用 pacman 变量，方法如下
Pkg.add()
虽然这是一个基本的、原始的版本，但是这种通过 Python 访问 Julia 的面向对象的方法无疑是非常酷的，并且在未来的虚拟环境中具有很好的可伸缩性。
为了导入一个车床模块，我们可以使用 import__()功能:
但是机器学习呢？
机器学习
处理数据
机器学习在 PyLathe 中的工作方式是完全正确的，很少有问题会危及这一点。这些问题中的一些可能会不时暴露出来，但在大多数情况下，并不是什么大不了的事情。关于使用 PyLathe 的好消息是现在**我们在 Python 中，**这带来了 Python 的巨大优势！
包装
这是一个正式的自由世界，因为现在我们不必自己写所有的东西。
所以我决定引进熊猫，并着手获取一个数据帧
df = pd.read_csv("path/to/my/csv")
如果你想使用这个数据集，或者像往常一样下载这个笔记本，这里有一个链接！
这就是熊猫更好的原因。
我喜欢在一个新的数据帧上做的第一件事，特别是像这样的快速拟合，是得到一个空计数。幸运的是，对于熊猫来说，这很容易:
df.isnull()。总和()
数据科学家的任务之一就是明智地处理未定义的值。考虑到这并不严重，我认为没有必要去填补这些缺失的值。幸运的是，眼尖的人可能已经意识到我的空值只在一列中。一部经典的新秀电影应该是
df = df.dropna()
但是不要那么做。如果我们现在放弃未定义的值，我们将丢失 517 个观察值。相反，我们可以删除该列，如下所示:
或者你可以像我一样，创建一个全新的数据框架:
统计数据
我决定从 Lathe.stats 执行一个简单的 f 检验，只是为了看看我假设可能相关的两个特征是否确实相关。首先，我使用条件掩码根据温度中心分离数据，然后应用它:
# This will create a boolean mask that
# we can use to apply a filter to our
# df
lowtemp = df['Temperature (C)'] <= 0
# Now we filter our dataframe:
temp_test_df = df[lowtemp]
然后通过我的环境导入统计数据:
stats = env.importStats()
然后应用 f 检验，看看我们在处理什么样的显著性。
测试/训练分离
在没有任何信心的情况下，我尝试通过从环境中导入来使用来自 Lathe.preprocess 的 TestTrainSplit 函数，没有人会感到惊讶:
它不起作用
当然，这是因为熊猫数据帧是 Python 构造的对象，而不是数据。为了解决这个问题，我试着使用字典:
那也失败了
当然有办法解决这个问题，通过构造一个 Julia DataFrames.jl DataFrame，然后通过函数传递它，唯一的问题是它将返回两个 DataFrames.jl DataFrames，而不是两个 Pandas DataFrames。所以，有了路障，
还是用 Sklearn 吧！
我还冒昧地设置了我们的 X 和 Y，这是很容易理解的(因为这对初学者来说不一定)。)我会说要小心数组形状，因为 Python 处理类型的方式可能有点不可靠，而车床是用 Julia 编写的，所以当然不遵守这一约束。例如，一个系列是一个列表(一个数组)，但是可能需要被重新整形为一维数组，以便为 Sklearn 工作。
不要这样对皮拉思。
模型拟合
为了适应模型，我们需要从我们的环境中导入车床模型。我们用和其他人一样的方法做这件事，
# Import models into our environment
models = env.importModels()
我决定应用 Z 分数归一化算法，也称为标准标量。我们可以用最简单明了的方式在 Python 的两个 X 上调用它:
# Let's apply a standard scaler from Lathe.preprocess, as well:
trainX = preprocess.StandardScalar(trainX)
# (To both X's)
testX = preprocess.StandardScalar(testX)
如果你已经知道车床，我想这将是非常自然的。
现在使用 Lathe.models: predict 和 Lathe.models: LinearRegression，我们可以将我们的模型构造为一个 Python 对象，然后在没有 yhat 的情况下将其插入预测方法。
这个数据的方差看起来并没有那么高，但是这个模型确实是正确的。
最后的想法
首先，PyLathe——非常酷。虽然它还处于早期阶段，但是将不同的语言视为相同的语言绝对是非常棒的。我希望看到的未来改进包括:
- 虚拟环境！
- 速度——与运行本地 Julia 相比，调用 Julia 相当慢，这正是未来的计划。
- 灵活性——进一步使用包管理器来利用更多的包与车床一起使用。
总的来说，虽然将来会有改进，但我真的很喜欢 PyLathe。PyLathe 很棒，因为它完全由 Julia 模块版本本身维护，并且无论在什么情况下都可以使用 Julia 的模块版本。如果您想了解车床的所有“特色”，包括正在开发的 Lathe.lisp 和未来的车床。r 包，这些链接可以在车床内部找到。
有关发布画布的信息，请访问项目选项卡 Lathe.jl 是用于预测建模的一体化软件包…
github.com](https://github.com/emmettgb/Lathe.jl/tree/Unstable)
介绍 Python 的 Functools 模块
处理高阶函数和可调用对象
阿里安·达尔维什在 Unsplash 上拍摄的照片
介绍
functools 模块是 Python 标准库的一部分，它提供了一些有用的特性，使得使用高阶函数(返回一个函数或接受另一个函数作为参数的函数)变得更加容易。有了这些特性，您可以重用或扩展函数或可调用对象的效用，而无需重写它们。这使得编写可重用和可维护的代码变得非常简单。
根据当前的稳定版本，即 Python 3.8 系列，functools 模块包含 11 个函数，其中一些可能不可用，或者在早期或后期版本中工作方式不同。它们包括:
- 减少()
- lru_cache()
- 偏()
- partialmethod()
- singledispatch()
- singledispatchmethod()
- cached_property()
- total_ordering()
- 更新 _ 包装()
- wrapps()
- cmp_to_key()
我们将简要讨论每一个，然后借助例子，说明它们的用法和功能。
1.减少()
首先我们有一个经典。 reduce(function，sequence) 函数接收两个参数，一个函数和一个 iterable。它从左到右对 iterable 的所有元素累积应用 argument 函数，然后返回一个值。
简单地说，它首先将参数函数应用于 iterable 的前两个元素，第一次调用返回的值成为函数的第一个参数，iterable 的第三个元素成为第二个参数。重复这个过程，直到可迭代次数用完。
例如，reduce()可用于轻松计算列表的总和或乘积。
在第一个例子中 reduce(lambda a，b: a + b，[1，2，3，4]) 计算((1+2)+3)+4)并返回列表的总和 10。
2.lru_cache()
lru_cache()是一个 decorator，它用一个 memoizing callable 来包装一个函数，该函数用于保存一个函数调用的结果，如果用相同的参数再次调用该函数，则返回存储的值。当使用相同的参数定期调用昂贵的或 I/O 受限的函数时，它可以节省时间。
本质上，它使用两种数据结构，一个字典将函数的参数映射到结果，一个链表跟踪函数的调用历史。
在全 LRU 缓存中，代表最近最少使用的缓存，指的是在达到最大条目大小时丢弃最近最少使用的元素的缓存。如果 maxsize 设置为 None，则禁用 LRU 功能；如果 typed 为 True，则分别缓存不同数据类型的参数，例如， f(3) 和 f(3.0) 将被明确缓存。
lru_cache()实用程序的一个例子可以在优化生成数字阶乘的代码中看到
在没有 @lru_cache 的情况下，阶乘函数需要大约 1.46 s 来运行，而另一方面，使用 *@lru_cache，*该函数只需要 158 ns。这相当于性能提高了近 100，000 倍——太神奇了！对吗？
通常，仅当您想要重用之前计算的值时，才应使用 LRU 缓存。因此，缓存需要在每次调用时创建不同可变对象的函数是没有意义的。此外，由于使用字典来缓存结果，函数的位置和关键字参数必须是可哈希的。
3.部分()
部分函数是具有一些预先分配的输入参数的派生函数。例如，如果一个函数有两个参数，比如" a" 和" b" “，那么可以从它创建一个分部函数，将” a" 作为预填充的参数，然后可以使用" b" 作为唯一的参数来调用它。Functool 的 partial()用于创建分部函数/对象，这是一个有用的特性，因为它允许:
- 复制已经传入了一些参数的现有函数。
- 以记录良好的方式创建现有功能的新版本。
让我们考虑一个简单的例子来说明这一点
我们首先基于 math.perm() 函数创建一个分部对象。在这种情况下，我们将 9 设置为第一个参数。因此，新创建的 permutation_of_nine 函数的行为就像我们调用 math.perm() 并将 9 设置为默认参数一样。在我们的例子中， permutation_of_nine(2) 与 math.perm(9，2)做同样的事情。
需要注意的是， name 和 doc 属性是由程序员指定的，因为它们不是自动创建的
partial 函数还带有一些重要的属性，这些属性在跟踪 partial 函数/对象时非常有用。其中包括:
- partial . args—返回预先分配给分部函数的位置参数。
- partial . keywords—返回预先分配给分部函数的关键字参数。
- partial.func —返回父函数的名称及其地址。
让我们看另一个说明这些特征的例子
偏旁非常有用。例如，在函数调用的管道序列中，一个函数的返回值是传递给下一个函数的参数。
4.partialmethod()
partialmethod() 返回一个新的 partialmethod 描述符，其行为类似于 partial ，只是它被设计为用作方法定义，而不是可直接调用的。你可以把它看作是方法的 partial() 。
也许一个例子最适合说明这一点。
我们首先创建一个动物类，它有一个属性物种和一个实例方法 _set_species() 来设置动物的物种。接下来，我们创建两个 partialmethod 描述符 set_dog() 和 set_rabbit() ，分别用“狗”或“兔子”调用 _set_species() 。这允许我们创建动物类的一个新实例，调用 set_dog() 将动物的种类改为 dog，最后打印新的属性。
5.singledispatch()
在我们讨论这个函数之前，我们首先要弄清楚两个重要的概念，这很重要:
- 第一个是通用函数，它是由对不同类型实现相同操作的多个函数组成的函数。呼叫期间使用的实现由调度算法决定。
- 第二种是单一分派，这是一种通用函数分派的形式，根据单一参数的类型选择实现。
考虑到这一点，functool 的 singledispatch 是一个装饰器，它将一个简单函数转换成一个通用函数，其行为取决于其第一个参数的类型。用简单的语言来说，它用于函数重载
让我们来看一个实际例子。
我们首先定义一个函数 divide() ，它接受两个参数 a 和 b ，并返回 a/b 的值。然而，分割字符串会导致一个 类型错误 ，为了处理这个问题，我们定义了 _ functions，它指定了 divide() 的行为，如果它是由字符串提供的话。注意，重载的实现是使用通用函数的 register() 属性注册的
6.singledispatchmethod()
它是一个装饰器，做的事情和 @singledispatch 完全一样，但是它是为方法而不是函数指定的。
考虑下面的例子。
Product 类的 prod 方法被重载以返回一个列表或集合的元素的乘积，但是如果提供了不同的类型，默认情况下，它会引发一个notimplementererror。
7.cached _ property()
顾名思义， cached_property() 是一个装饰器，它将一个类方法转换成一个属性，该属性的值只计算一次，然后作为实例生命周期中的一个普通属性进行缓存。它类似于 @property ，除了它的缓存功能。这对于实例的计算开销很大的属性很有用，否则这些属性实际上是永久的。
在上面的例子中，我们有一个数据集类，它保存了一个观察值列表，并实现了计算方差和标准差的方法。问题是，每次调用这些方法时，都必须重新计算方差和标准差，这可能证明是非常昂贵的，尤其是对于大型数据集。 @cached_property 通过只计算和存储一次值来缓解这个问题，如果该方法被同一个实例再次调用，则返回该值。
8.total_ordering()
给定一个定义了一个或多个富比较排序方法即 _ lt_()、le()、_ _ gt _ _()或 eq() (对应 <、< =、>、> = 、=)。您可以定义一些比较方法， @total_ordering 会根据给定的定义自动提供其余的方法。重要的是，该类应该提供一个 eq() 方法。
例如，如果您想创建一个比较不同数字的类。您可能需要实现所有丰富的比较方法。然而，这可能是相当繁琐和多余的，要解决这个问题，你只能实现 _ eq_ 和 gt 方法，并使用 @total_ordering 来自动填充其余的。
不过有一个限制，使用 @total_ordering 会增加的开销导致执行速度变慢。此外，派生比较方法的堆栈跟踪更加复杂。因此，如果您需要高效的代码，明智的做法是自己显式地实现比较方法
9.更新包装器()
它更新包装函数的元数据，使之看起来像被包装的函数。例如，对于分部函数，update _ wrapper(partial，parent) 将更新分部函数的文档( doc )和名称( name )以匹配父函数。
10.换行()
这是一个方便调用 update_wrapper() 到修饰函数的函数。相当于运行partial(update _ wrapper，wrapped=wrapped，assigned=assigned，updated=updated) 。
举个例子，
11.cmp_to_key()
它将旧式的比较函数转换为关键函数。比较函数是任何可调用的函数，它接受两个参数，对它们进行比较，返回负数表示小于，返回零表示等于，返回正数表示大于。键函数是一个可调用函数，它接受一个参数并返回另一个值以用作排序键，一个例子是***operator . item getter()***键函数。***sorted()******min()******max()******ITER tools . group by()***等工具中都用到关键函数。
cmp_to_key() 主要用作 Python 2 编写的支持比较函数的程序的转换工具。
让我们举一个例子，说明如何使用比较函数根据首字母对字符串列表进行排序，以说明 cmp_to_key() 的用法
结论
在本文中，我们已经学习了 functools 模块，希望您现在已经了解了如何使用它来实现高阶函数，并编写高度健壮、可读和可重用的代码。
祝你好运，编码愉快，愿 bug 在你的力量面前颤抖。
由 meme-arsenal 制作的图像
PyTorch 预测简介
PyTorch 预测示例
最先进的神经网络预测变得简单
我很高兴地宣布开源 Python 包 PyTorch 预测。对于数据科学从业者和研究人员来说，它使得用神经网络进行时间序列预测变得简单。
为什么准确预测如此重要？
预测时间序列在许多情况下都很重要，并且与机器学习实践者高度相关。举个例子，需求预测是许多用例的来源。几乎每个制造商都会受益于更好地了解对其产品的需求，从而优化生产数量。生产不足，你会损失收入，生产过度，你将被迫折价出售多余的产品。与此密切相关的是定价，它本质上是一种需求预测，特别关注价格弹性。定价几乎与所有公司都相关。
对于大量额外的机器学习应用，时间是至关重要的:预测性维护、风险评分、欺诈检测等。—你说吧。事件的顺序和它们之间的时间对于创建可靠的预测至关重要。
事实上，虽然时间序列预测可能不像图像识别或语言处理那样耀眼，但它在工业中更常见。这是因为图像识别和语言处理对该领域来说相对较新，通常用于推动新产品，而预测已经存在了几十年，是许多决策(支持)系统的核心。采用高精度机器学习模型，如 PyTorch 预测 中的模型，可以更好地支持决策制定，甚至使其自动化，往往会直接带来数百万美元的额外利润。
深度学习成为一种强大的预测工具
深度学习(神经网络)只是在最近才在时间序列预测方面超过传统方法，而且与图像和语言处理相比，差距较小。事实上，在预测纯时间序列(这意味着没有协变量，例如，价格对需求)时，深度学习仅在两年前就已经超越了传统的统计方法 [1]。然而，随着该领域的快速发展，与神经网络相关的准确性优势变得显著，这使得它们在时间序列预测中的应用越来越多。例如，最新的架构 N-BEATS 在 M4 竞赛数据集上显示，与下一个最好的非基于神经网络的方法(即统计方法的集合)相比，sMAPE 减少了 11%。这个网络也在 PyTorch 预报中实现。
此外，即使与其他流行的机器学习算法(如梯度提升树)相比，深度学习也有两个优势。首先，神经网络架构可以设计为具有对时间的固有理解，即它们自动在时间上接近的数据点之间建立连接。因此，它们可以捕捉复杂的时间依赖关系。相反，传统的机器学习模型需要手动创建时间序列特征，例如过去 x 天的平均值。这削弱了这些传统机器学习算法对时间依赖性建模的能力。第二，大多数基于树的模型通过设计输出阶跃函数。因此，它们不能预测投入变化的边际影响，而且，众所周知，在域外预测中它们是不可靠的。例如，如果我们只观察到 30 欧元和 50 欧元的价格，则基于树的模型无法评估价格从 30 欧元变为 35 欧元对需求的影响。因此，它们通常不能直接用于优化投入。然而，这通常是创建机器学习模型的全部目的——价值在于协变量的优化。与此同时，神经网络采用连续激活函数，尤其擅长高维空间的插值，即它们可用于优化输入，如价格。
什么是 PyTorch 预测？
PyTorch Forecasting 旨在通过神经网络简化现实世界案例和研究的时间序列预测。它通过提供最先进的时间序列预测架构来做到这一点，这些架构可以通过 pandas 数据框架轻松训练。
- 这个高级 API 极大地减少了用户的工作量，因为不需要具体的知识来准备使用 PyTorch 进行训练的数据集。
TimeSeriesDataSet类负责变量转换、缺失值、随机子采样、多历史长度等。您只需要提供 pandas 数据框架，并指定模型应该学习哪些变量。 BaseModel类提供了通用的可视化，比如显示预测与实际值和部分依赖图。培训进度以指标和示例的形式自动记录在 tensorboard 中。- 国家的最先进的网络实施预测有和没有协变量。它们还带有专用的内置翻译功能。例如，时态融合转换器 [3]在基准测试中击败了亚马逊的 DeepAR 36–69 %,提供了变量和时间重要性测量。在下面的例子中可以看到更多。
- 存在许多多时段时间序列指标来评估多个预测时段的预测。
- 为了实现可扩展性，网络被设计为与 PyTorch Lightning 一起工作，后者允许对 CPU 和单个及多个(分布式)GPU 进行开箱即用的培训。Ranger 优化器用于更快的模型训练。
- 为了便于实验和研究，增加网络是很简单的。代码是专门为 PyTorch 专家设计的。他们会发现即使是复杂的想法也很容易实现。事实上，为了立即启用日志和解释功能，只需从
BaseModel类继承并遵循 forward 方法输入和输出的约定。
首先，文档展示了端到端工作流中的详细教程。我还将在本文后面讨论一个具体的例子。
我们为什么需要这个包？
PyTorch 预测 **有助于克服深度学习用法的重要障碍。**虽然深度学习已经在图像和语言处理中占据主导地位，但在时间序列预测中却不那么重要。该领域仍由传统的统计方法(如 ARIMA)和机器学习算法(如梯度推进)占据主导地位，贝叶斯模型例外。深度学习尚未成为时间序列预测主流的原因有两个，所有这些都已经可以克服:
- 训练神经网络几乎总是需要 GPU，而 GPU 并不总是容易获得。硬件需求通常是一个重要的障碍。然而，通过将计算转移到云中，这个障碍是可以克服的。
- 神经网络比传统方法更难使用。时间序列预测尤其如此。缺少一个与流行框架协同工作的高级 API，如脸书的 PyTorch 或谷歌的 Tensorflow。对于传统的机器学习，sci-kit learn 生态系统的存在为从业者提供了一个标准化的界面。
这第三个障碍在深度学习社区被认为是至关重要的，因为它的用户友好性需要大量的软件工程。下面的推文总结了许多人的情绪:
深度学习实践者的典型观点
有些人甚至认为该声明微不足道:
简单来说， PyTorch 预测 旨在做fast . ai**为图像识别和自然语言处理所做的事情。**这极大地促进了神经网络从学术界向现实世界的扩散。 PyTorch Forecasting 试图通过为 PyTorch 提供一个可以直接使用 pandas dataframes 的高级 API 来做时间序列预测的等效工作。为了便于学习，与 fast.ai 不同，该软件包没有创建一个全新的 API，而是建立在成熟的 PyTorch 和py torch LightningAPI 的基础上。
如何使用 PyTorch 预测？
这个小例子展示了这个包的强大功能及其最重要的抽象。我们将
- 创建训练和验证数据集，
- 训练时间融合变压器【2】。这是一个由牛津大学和谷歌开发的架构，在基准测试中击败了亚马逊的 DeepAR 36–69 %,
- 检查验证集的结果并解释训练好的模型。
注:以下代码仅适用于 PyTorch 预报 0.4.1 版和 PyTorch 闪电 0.9.0 版。运行最新版本只需很少的修改。最新代码的完整教程可以在这里找到。
创建用于训练和验证的数据集
首先，我们需要将时间序列转换成 pandas 数据框架，其中每一行都可以用时间步长和时间序列来标识。幸运的是，大多数数据集已经是这种格式了。对于本教程，我们将使用来自 Kaggle 的 Stallion 数据集来描述各种饮料的销售。我们的任务是对库存单位(SKU)的销售量进行六个月的预测，即由代理机构(即商店)销售的产品。大约有 21 000 个月的历史销售记录。除了历史销售额之外，我们还有销售价格、代理机构的位置、特殊日子(如节假日)以及整个行业的销售量等信息。
from pytorch_forecasting.data.examples import get_stallion_datadata = get_stallion_data() # load data as pandas dataframe
数据集的格式已经正确，但缺少一些重要的功能。最重要的是，我们需要添加一个时间索引，每个时间步长递增 1。此外，添加日期特性是有益的，在这种情况下，这意味着从日期记录中提取月份。
# add time index
data["time_idx"] = data["date"].dt.year * 12 + data["date"].dt.monthdata["time_idx"] -= data["time_idx"].min()# add additional features
# categories have to be strings
data["month"] = data.date.dt.month.astype(str).astype("category")
data**[**"log_volume"**]** **=** np**.**log**(**data**.**volume **+** **1e-8)**
data**[**"avg_volume_by_sku"**]** **=** (
data
**.**groupby**([**"time_idx"**,** "sku"**],** observed**=True)
.**volume**.**transform**(**"mean"**)** )
data**[**"avg_volume_by_agency"**]** **=** (
data
**.**groupby**([**"time_idx"**,** "agency"**],** observed**=True)
.**volume**.**transform**(**"mean"**)
)**# we want to encode special days as one variable and
# thus need to first reverse one-hot encoding
special_days = [
"easter_day", "good_friday", "new_year", "christmas",
"labor_day", "independence_day", "revolution_day_memorial",
"regional_games", "fifa_u_17_world_cup", "football_gold_cup",
"beer_capital", "music_fest"
]data[special_days] = (
data[special_days]
.apply(lambda x: x.map({0: "-", 1: x.name}))
.astype("category")
)# show sample data
data.sample(10, random_state=521)
来自数据帧的随机行样本
下一步是将数据框架转换成 PyTorch 预测数据集。除了告诉数据集哪些特征是分类的，哪些是连续的，哪些是静态的，哪些是随时间变化的，我们还必须决定如何归一化数据。这里，我们分别对每个时间序列进行标准标度，并指出值总是正的。
我们还选择使用过去六个月作为验证集。
from pytorch_forecasting.data import (
TimeSeriesDataSet,
GroupNormalizer
)max_prediction_length = 6 # forecast 6 months
max_encoder_length = 24 # use 24 months of history
training_cutoff = data["time_idx"].max() - max_prediction_lengthtraining = TimeSeriesDataSet(
data[lambda x: x.time_idx <= training_cutoff],
time_idx="time_idx",
target="volume",
group_ids=["agency", "sku"],
min_encoder_length=0, # allow predictions without history
max_encoder_length=max_encoder_length,
min_prediction_length=1,
max_prediction_length=max_prediction_length,
static_categoricals=["agency", "sku"],
static_reals=[
"avg_population_2017",
"avg_yearly_household_income_2017"
],
time_varying_known_categoricals=["special_days", "month"],
# group of categorical variables can be treated as
# one variable
variable_groups={"special_days": special_days},
time_varying_known_reals=[
"time_idx",
"price_regular",
"discount_in_percent"
],
time_varying_unknown_categoricals=[],
time_varying_unknown_reals=[
"volume",
"log_volume",
"industry_volume",
"soda_volume",
"avg_max_temp",
"avg_volume_by_agency",
"avg_volume_by_sku",
],
target_normalizer=GroupNormalizer(
groups=["agency", "sku"], coerce_positive=1.0
), # use softplus with beta=1.0 and normalize by group
add_relative_time_idx=True, # add as feature
add_target_scales=True, # add as feature
add_encoder_length=True, # add as feature
)# create validation set (predict=True) which means to predict the
# last max_prediction_length points in time for each series
validation = TimeSeriesDataSet.from_dataset(
training, data, predict=True, stop_randomization=True
)# create dataloaders for model
batch_size = 128
train_dataloader = training.to_dataloader(
train=True, batch_size=batch_size, num_workers=0
)
val_dataloader = validation.to_dataloader(
train=False, batch_size=batch_size * 10, num_workers=0
)
训练时间融合转换器
现在是时候创建我们的模型了。我们用 PyTorch 闪电训练模型。在培训之前，您可以使用学习率查找器确定最佳学习率(参见文档中的示例)。
import pytorch_lightning as pl
from pytorch_lightning.callbacks import (
EarlyStopping,
LearningRateLogger
)
from pytorch_lightning.loggers import TensorBoardLogger
from pytorch_forecasting.metrics import QuantileLoss
from pytorch_forecasting.models import TemporalFusionTransformer# stop training, when loss metric does not improve on validation set
early_stop_callback = EarlyStopping(
monitor="val_loss",
min_delta=1e-4,
patience=10,
verbose=False,
mode="min"
)
lr_logger = LearningRateLogger() # log the learning rate
logger = TensorBoardLogger("lightning_logs") # log to tensorboard# create trainer
trainer = pl.Trainer(
max_epochs=30,
gpus=0, # train on CPU, use gpus = [0] to run on GPU
gradient_clip_val=0.1,
early_stop_callback=early_stop_callback,
limit_train_batches=30, # running validation every 30 batches
# fast_dev_run=True, # comment in to quickly check for bugs
callbacks=[lr_logger],
logger=logger,
)# initialise model
tft = TemporalFusionTransformer.from_dataset(
training,
learning_rate=0.03,
hidden_size=16, # biggest influence network size
attention_head_size=1,
dropout=0.1,
hidden_continuous_size=8,
output_size=7, # QuantileLoss has 7 quantiles by default
loss=QuantileLoss(),
log_interval=10, # log example every 10 batches
reduce_on_plateau_patience=4, # reduce learning automatically
)
tft.size() # 29.6k parameters in model# fit network
trainer.fit(
tft,
train_dataloader=train_dataloader,
val_dataloaders=val_dataloader
)
在我的 Macbook 上，训练大约需要三分钟，但对于更大的网络和数据集，可能需要几个小时。在训练过程中，我们可以监控张量板，它可以用tensorboard --logdir=lightning_logs旋转起来。例如，我们可以监控训练集和验证集上的示例预测。如下图所示，预测看起来相当准确。如果你想知道，灰线表示模型在进行预测时对不同时间点的关注程度。这是时间融合转换器的一个特殊功能。
显示训练示例的 Tensorboard 面板
评估已训练的模型
训练之后，我们可以评估验证数据集和几个示例上的指标，以查看模型的表现如何。鉴于我们只对 21 000 个样本进行研究，结果非常令人放心，可以与梯度助推器的结果相媲美。
from pytorch_forecasting.metrics import MAE# load the best model according to the validation loss (given that
# we use early stopping, this is not necessarily the last epoch)
best_model_path = trainer.checkpoint_callback.best_model_path
best_tft = TemporalFusionTransformer.load_from_checkpoint(best_model_path)# calculate mean absolute error on validation set
actuals = torch.cat([y for x, y in iter(val_dataloader)])
predictions = best_tft.predict(val_dataloader)MAE(predictions, actuals)
从 sMAPE 的角度来看最差的表现，可以让我们了解模型在可靠预测方面的问题。这些例子可以为如何改进模型提供重要的指导。这种实际值与预测值的对比图适用于所有模型。
from pytorch_forecasting.metrics import SMAPE# calculate metric by which to display
predictions, x = best_tft.predict(val_dataloader)
mean_losses = SMAPE(reduction="none")(predictions, actuals).mean(1)
indices = mean_losses.argsort(descending=True) # sort lossesraw_predictions, x = best_tft.predict(val_dataloader, mode="raw, return_x**=True)**# show only two examples for demonstration purposes
for idx in range(2):
best_tft.plot_prediction(
x,
raw_predictions,
idx=indices[idx],
add_loss_to_title=SMAPE()
)
验证集上两个最差的预测。白线表示变压器对给定时间点的关注程度。
类似地，我们也可以从我们的模型中看到随机的例子。PyTorch 预测的另一个特点是对训练好的模型进行解释。例如，所有的模型都允许我们容易地计算部分相关图。然而，为了简洁起见，我们将在这里展示时间融合转换器的一些内置解释功能。它通过设计神经网络来实现可变的重要性。
interpretation = best_tft.interpret_output(
raw_predictions, reduction="sum"
)best_tft.plot_interpretation(interpretation)
不出所料，过去观察到的音量特征作为编码器中的首要变量和价格相关变量是解码器中的首要预测因素。也许更有趣的是，该机构在静态变量中仅排名第五。然而，考虑到第二个和第三个变量与位置有关，如果这两个变量不包括在模型中，我们可以预计代理机构的排名会高得多。
摘要
用 PyTorch Forecasting 训练一个模型并洞察其内部运作是非常容易的。作为从业者，您可以使用这个包来训练和解释开箱即用的最新模型。与 PyTorch Lightning 集成训练和预测是可扩展的。作为一名研究人员，您可以利用该包为您的架构获得自动跟踪和自省功能，并将其无缝地应用于多个数据集。
代码、文档和如何投稿
本教程的代码可以在本笔记本中找到:https://github . com/jdb 78/py torch-forecasting/blob/master/docs/source/tutorials/stallion . ipynb
安装 PyTorch 预测和
pip install pytorch-forecasting
或者
conda install -c conda-forge pytorch-forecasting
GitHub 库:https://github.com/jdb78/pytorch-forecasting
文档(包括教程):https://py torch-forecasting . readthedocs . io
该软件包在允许商业使用的 MIT 许可下是开源的。非常欢迎投稿！请提前阅读投稿指南，以确保您的投稿被迅速合并。
相关著作
亚马逊的 Gluon-TS 旨在提供类似的界面，但与 PyTorch 预测相比有两个明显的缺点。首先，该包的后端是 MXNet ，一个受欢迎程度落后于 PyTorch 和 Tensorflow 的深度学习框架。第二，尽管它是一个强大的框架，但由于其复杂的对象继承结构和组件的紧密耦合，它可能很难掌握和修改。
参考
[1] S. Smyl 、 J .阮冈纳赞和 A .帕斯夸、 M4 预测赛:引入全新混合 ES-RNN 车型 (2018)、https://eng.uber.com/m4-forecasting-competition
[2] B. N. Oreshkin 等人，N-BEATS: 可解释时间序列预测的神经基础扩展分析 (2020)，学习表征国际会议
[3] B. Lim，S. O. Arik，N. Loeff 和 T. Pfister，用于可解释的多时段时间序列预测的时间融合变换器 (2019)，arXiv:1912.09363
引入递归神经网络
堆叠感知器不适合顺序任务。而是使用 RNNs。
作者图片
人工智能(AI)正在弥合技术和人类之间的差距，让机器自动从数据中学习东西，变得更加‘像人’；因此，变得更加“聪明”。在这种情况下，智能可以被认为是处理信息的能力，这些信息可以用来为未来的决策提供信息。这是理想的，因为人类可以通过识别旧的模式、发展新的联系，并以新的视角感知他们所学的东西来开发新的有效的过程，从而自发地将信息整合在一起。当与机器的计算能力相结合时，可以获得巨大的成果。
自动学习和计算效率的结合可以用深度学习来最好地描述。这是人工智能和机器学习(ML)的一个子集，其中算法用于确定数据中的模式，并开发一个目标函数，该函数将输入变量 x 最佳映射到目标变量 y 。这里的目标是自动提取未来决策所需的最有用的信息。深度学习模型非常强大，可以用来解决各种各样的问题；从预测学生通过课程的可能性，到使用 Face ID 识别个人的面部来解锁他们的 iPhones。
作者图片
深度学习模型建立在“神经网络”的思想之上，这就是允许模型从原始数据中学习的东西。简单来说，深度神经网络是通过堆叠感知器创建的，感知器是单个神经元。通过具有一组输入 x ，信息通过该系统向前传播，并且每个输入具有相应的权重 w 。输入还应包括独立于 x 的“偏置项”。给定手边的问题，偏差项用于相应地移动所使用的函数。然后将每个对应的输入和权重相乘，并计算乘积之和。然后，该和通过非线性激活函数，并且产生输出 y，。
然而，这种“前馈”类型的模型并不总是适用的，并且它们的基本架构使得很难将它们应用于某些场景。例如，考虑一个模型，该模型被设计成在给定一个飞行物体的快照的情况下，预测该飞行物体接下来将去往何处。这是一个顺序问题，因为对象将随着时间的推移覆盖一段距离，并且对象的当前位置将取决于对象先前的位置。如果没有给出该物体之前位置的信息，那么预测该物体下一步的位置也不过是一个随机的猜测。
作者图片
让我们考虑另一个简单但重要的问题:预测下一个单词。这样做的模型现在很常见，因为它们被用在诸如自动填充和自动更正的应用程序中，并且它们通常被认为是理所当然的。这是一个连续的任务，因为最合适的“下一个单词”取决于之前的单词。前馈网络不适合这项任务，因为它需要一个具有特定长度的句子作为输入，然后预测下一个单词。但是，这是一个问题，因为我们不能保证每次输入的长度都相同，这样模型的性能就会受到负面影响。
解决这个问题的一个潜在方法是只查看这个输入句子的一个子部分，比如最后两个单词 maybe。这解决了可变长度输入的问题，因为不管总输入长度如何，模型将仅使用句子的最后两个单词来预测下一个单词。但这仍不理想，因为该模型现在无法考虑长期依赖关系。也就是说，考虑这样一句话“我在柏林长大，一年前才搬到纽约。我能说流利的……”。如果只考虑最后两个词，每种语言的可能性都是一样的。但是当考虑整个句子时，德语是最有可能的。
作者图片
克服这些问题的最好方法是拥有一个全新的网络结构；一个可以随时更新信息的系统。这是一个递归神经网络 (RNN)。这类似于感知机，随着时间的推移，信息通过一组输入在系统中转发， x ，每个输入都有一个权重， w 。然后将每个相应的输入和权重相乘，并计算乘积的总和。该和然后通过非线性激活函数，并且产生输出 y，。
不同之处在于，除了输出，网络还产生内部状态更新， u 。然后在分析下一组输入信息时使用该更新，并提供也依赖于先前信息的不同输出。这很理想，因为信息会随着时间的推移在整个网络中持续存在。顾名思义，这个更新函数本质上是一个发生在顺序过程的每一步的递归关系，其中 u 是前一个 u 和当前输入 x 的函数。
作者图片
随着时间的推移，在 RNN 系统中循环的概念可能有点抽象，难以理解。另一种思考 RNN 的方式是随着时间的推移展开这个系统。也就是说，把 RNN 想象成一组奇异的前馈模型，其中每个模型通过内部状态更新链接在一起。像这样观察 RNN 可以真正提供一些关于为什么这种结构适合顺序任务的见解。在序列的每一步，都有一个输入、对该输入执行的某个过程和一个相关的输出。对于序列的下一步，前一步必须有一些影响不影响输入但影响相关输出。
如果我们回到飞行物体场景或单词预测场景，并使用展开的 RNN 来考虑它们，我们将能够更好地理解解决方案。在飞行物体的每个先前位置，我们可以预测一条可能的路径。预测路径随着模型接收到关于对象先前位置的更多信息而更新，并且该信息自我更新，然后馈入模型的未来序列。类似地，当句子场景中的每个新单词被输入到模型中时，就会生成新的可能单词组合。
作者图片
神经网络是人工智能和人工智能的重要组成部分，因为它们允许模型自动从数据中学习，并且它们将人类学习的一个版本与强大的计算能力相结合。然而，将非顺序结构应用于顺序任务将导致模型性能不佳，并且神经网络的真正能力将得不到利用。rnn 是人工学习系统，它基于以前的信息在内部更新自己，以便随着时间的推移预测最准确的结果。
参考文献:
DSpace . MIT . edu/bitstream/handle/1721.1/113146/1018306404-MIT . pdf？序列=1
Stanford . edu/~ sher vine/teaching/cs-230/cheat sheet-recurrent-neural-networks
wild ml . com/2015/09/recurrent-neural-networks-tutorial-part-1-introduction-to-rnns/
karpathy.github.io/2015/05/21/rnn-effectiveness/
其他有用的素材:
neuralnetworksanddeeplearning.com/
towardsdatascience.com/what-is-deep-learning-adf5d4de9afc
towards data science . com/the-mathematics-behind-deep-learning-f 6 c 35 a 0 Fe 077
引入简化共享
免费部署、管理和共享您的 Streamlit 应用
机器学习和数据科学代码易于共享，但难以使用。GitHub 充斥着模型、算法和数据集。但是代码是静态的。你能和模特一起玩吗？看到算法了吗？与数据互动？这样做需要遵循复杂的指令、安装包或阅读密集的代码片段。对此感到沮丧，我们决定我们需要一个简单的、可共享的“播放”按钮来播放机器学习代码。
这里有两个挑战。第一个是开发应用，让数据科学和机器学习代码互动。第二是分享这些应用程序，这样世界就可以体验你的工作。
一年前，我们通过发布 Streamlit 解决了第一个挑战— 创建— ，这是一个开源库，允许您将 Python 脚本转换为交互式应用。Streamlit 让您可以轻松演示算法、玩模型、操作数据，并将所有这些超能力结合到漂亮的应用程序中。反响是巨大的。我们刚刚完成了第一百万次下载。世界各地已经创建了成千上万的 Streamlit 应用程序。但是创建优秀的应用程序只能解决一半的问题。
轻松部署和共享您的简化应用
今天，我们通过宣布一个全新的 Streamlit 共享平台来应对第二个挑战— 共享。Streamlit 共享让您可以部署、管理和共享您的应用程序，这一切都是免费的！如果你有一个在 GitHub 上公开托管的 Streamlit 应用程序，你现在只需点击一下就可以与全世界分享它。
GitHub 和 Streamlit——一起更好
Streamlit 共享结合了 Streamlit 的精华和 GitHub 的精华。从 Streamlit 你可以得到一个简单的框架来创建极其丰富和有用的应用程序。从 GitHub 你继承了一个不可思议的社会协作框架。将你的 GitHub 链接粘贴到 Streamlit 的共享平台上，几乎立刻你就有了一个实时应用。或者，点击任何 live app 的菜单，在 GitHub 上查看其源代码。只需分叉和编辑代码即可免费协作。这是全球性的、可共享的、可分叉的、协作的数据科学！
无限的可能性
结合在一起，Streamlit 和 GitHub 实现了一个极其丰富多样的有用应用生态系统——从仪表盘到深度网络等等！(作为前卡耐基梅隆大学的学生，我们特别自豪的是，参加互动数据科学课程的学生现在使用 Streamlit 共享提交作业🤗)这里有一些很棒的共享 Streamlit 应用程序的例子，你现在就可以玩。
虽然这篇文章关注的是开源应用程序，但是 Streamlit 也被成千上万的公司用来构建复杂的内部数据工具。例如，优步在整个公司范围内部署了 Streamlit，使数据科学家能够在整个公司内共享他们的工作。 Streamlit for Teams 扩展 Streamlit 的共享平台，在您的企业中实现安全、无缝的应用部署、管理和协作*。如果你感兴趣，请注册团队的 Streamlit 测试版。*
获得简化共享的邀请
为了庆祝发布，我们将发布 1，000 份 Streamlit 共享邀请 — 随着我们服务器容量的增长，会有更多的邀请。如果您的收件箱中还没有邀请，请请求邀请，我们将很快为您发送邀请。
Streamlit 播放按钮
这种新的共享能力完成了 Streamlit 循环——从创建到共享，然后再返回。所以创造吧！与世界分享！让别人看到你的工作，分叉，合并，促成知识创造的循环。本着这种精神，我们提供最后一件礼物:这是我们的“播放”按钮。
这个全新的徽章帮助其他人找到并使用您的 Streamlit 应用程序。将它嵌入到 GitHub readme.md中，如下所示:
[](https://share.streamlit.io/yourGitHubName/yourRepo/yourApp/)
谢谢你们用你们令人惊叹的创作激励了我们。我们很高兴看到你的建设和分享。🎈
我们细流 it 的所有人非常感谢社区中的所有人，特别是细流 it 的创始人，AshishCharlyfani lojos杰西还要特别感谢所有 launch app 的创作者，Alex、Dan、Ines | Explosion，最后还有 Tyler，他不仅创作了**Goodreads app，还创作了一个很棒的分享教程。******
介绍 Text 2 summary:Android 上的文本摘要(使用 TF-IDF)
📱移动机器学习
一个简单易用的库，用于在 Android 上生成文本摘要
互联网充斥着大量的数据。如果我们只谈论文本数据，这包括在线新闻、博客、故事和其他信息库。这里是文本摘要出现的地方。文本摘要模型的最终目标是以一种潜在的形式表现文本信息，这种潜在的形式损害了文本的语义。抱着这个想法，我开发了 Text2Summary ，一个 Android 应用的文本摘要器。
[## Shu bham 0204/text 2 summary-Android
Text2Summary API 使用设备上的方法在 Android 应用程序上执行文本摘要。它使用摘录文本…
github.com](https://github.com/shubham0204/Text2Summary-Android)
在这个故事中，我们讨论了 Text2Summary 的需求、安装和使用。
Text2Summary 有什么特别之处？
如果你想总结应用程序用户选择的大量文本，你面前有两个选择。要么创建一个抽象的文本摘要模型，要么创建一个提取的文本摘要模型。
在这里你可以理解上述方法的区别。简单明了地说，抽象模型就像一个人阅读给定的内容，然后自己写摘要。一个精挑细选的模特是一个只配有荧光笔的人，他会突出重要的句子，并对它们进行总结。
如果你有机器学习的背景，你可能想从 Seq2Seq NN 中创建一个抽象模型。如果你不是来自机器学习背景，Seq2Seq 可能会令人害怕。
这里是 Text2Summary，
Text2Summary 使用提取模型，这意味着它使用提供给它的文本的句子创建摘要。它使用一种 TF-IDF 算法从文本中获取最有意义的句子。这个算法比上图简单，并且在计算能力有限的 Android 设备上高效运行(与那些 GPU/TPU 马相比！).
听起来很酷。如何在我的 Android 项目中添加 Text2Summary？
首先，我们进入项目级的build.gradle文件。添加下面的 JitPack 仓库，
allprojects {
repositories {
// Other dependencies
maven { url 'https://jitpack.io' }
}
}
注意到最新发布的 Text2Summary 后，在你的 app 级build.gradle文件中添加依赖关系，
dependencies {
// Other dependencies
implementation 'com.github.shubham0204:Text2Summary-Android:alpha-02'
}
仅此而已。我们准备使用 Text2Summary！
如何在我的应用程序中使用 Text2Summary？
首先，获取您希望以String形式总结的文本。然后，使用Text2Summary.summarize()方法开始使用 API，
var summary = Text2Summary.summarize( text , compressionRate = 0.7 )
上面的
**compressionRate**是什么？它是文本的一部分，长度等于摘要长度。例如，如果您希望创建原始文本的 3/4 摘要，请使用 0.75 的压缩率。
您可能想从用户存储器上的File中读取文本，
val bufferedReader: BufferedReader = File( "poems.txt" ).bufferedReader()
val text = bufferedReader.use{ it.readText() }
val summary = Text2Summary.summarize( text , 0.7 )
从这里你应该能最大程度地了解 Text2Summary。但是等等。有没有遇到 UI 线程堵塞的情况？打Text2Summary.summarize()的时候活动是不是停了一会儿？
Text2Summary 需要执行各种操作，包括ArrayList和Hashmap。如果文本很大，UI 线程会停止一段时间。为了解决这个问题，使用summarizeAsync()执行文本摘要，
val callback = object : Text2Summary.SummaryCallback {
override fun onSummaryProduced(summary: String) {
// The summary is ready!
}
}
Text2Summary.summarizeAsync( someLongText , 0.7f , callback )
一些其他有用的资源
结束了
我希望你喜欢Text2Summary.在你的 Android 应用中使用它，并分享你的问题和建议。谢谢！
Neo4j 图形数据科学插件的预览，包含“图形算法:Apache Spark 和 Neo4j 中的实用示例”一书中的示例
在过去的几年里，数据科学领域获得了很大的发展。它已经成为商业和学术研究的重要组成部分。结合日益流行的图形和图形数据库， Neo4j 的人们决定发布图形数据科学 (GDS)插件。它是图形算法插件的继承者，即将被弃用。然而，这仍然是 GDS 的预览版，正式发布将在未来几周内进行。
那些熟悉图形算法插件的人会注意到，为了更平滑的过渡，语法没有太大的变化。为了展示所发生的变化，我准备了迁移指南，形式为 Apache Zeppelin 笔记本，可以在 GitHub 上找到。
Apache Zeppelin 的 Neo4j 连接器由 Andrea Santurbano 开发，他还设计了这个项目的漂亮主页笔记本，并帮助他出主意。在迁移指南中，我们使用了来自图算法的例子:由 Mark Needham 和 Amy Hodler 撰写的 Apache Spark 和 Neo4j 书中的实际例子。由于这本书还演示了图算法的 Apache Spark 实现，我们决定也包括它们是合适的。在建立 Apache Spark 环境时，我遇到了与这本书的合著者相同的问题，他写了一篇关于这个问题的博文。大声喊马克！
以下是你可以从这个项目中期待的:
- 16 本单图算法笔记本，包含 Apache Spark 中的实现以及到 GDS 的迁移指南
- 《移植到 GDS》中的链接预测分析
Neo4j 图形数据科学和图形算法插件不兼容，因此它们不会在 Neo4j 的单个实例上协同工作。在这个项目中，我们使用了两个 Neo4j 实例来演示新旧语法。
为了更好地了解笔记本所提供的功能，我们现在将浏览 PageRank 示例笔记本。你将在这篇博文中看到的所有引文都是从上述书中摘录的。
PageRank 算法简介
每个图形算法都有一个主笔记本，其中包括算法及其用例的简短介绍。以下是对 PageRank 算法的介绍:
PageRank 是以谷歌联合创始人拉里·佩奇的名字命名的，他创建了 Page rank 来对谷歌搜索结果中的网站进行排名。基本的假设是，一个有更多传入和更有影响力的传入链接的页面更有可能是一个可信的来源。PageRank 测量节点的传入关系的数量和质量，以确定对该节点重要性的估计。在网络上具有更大影响力的节点被认为具有来自其他有影响力的节点的更多传入关系。
在主笔记本的底部，您会找到 Neo4j 和/或 Apache Spark 算法实现的链接。
Neo4j 中的 PageRank 实现
在实际的笔记本中，你会发现图形算法和图形数据科学算法的例子。尽管如此，为了这篇博文的清晰，我决定只展示新的 GDS 语法。
加载示例图表:
GitHub 上的示例图是一个 CSV 文件，可以使用LOAD CSV cypher 语句轻松获取。
// import nodes
WITH “[https://raw.githubusercontent.com/neo4j-graph-analytics/book/master/data/social-nodes.csv](https://raw.githubusercontent.com/neo4j-graph-analytics/book/master/data/social-nodes.csv)"
AS uri
LOAD CSV WITH HEADERS FROM uri AS row
MERGE (:User {id: row.id});// import relationships
WITH “[https://raw.githubusercontent.com/neo4j-graph-analytics/book/master/data/social-relationships.csv](https://raw.githubusercontent.com/neo4j-graph-analytics/book/master/data/social-relationships.csv)"
AS uri
LOAD CSV WITH HEADERS FROM uri AS row
MATCH (source:User {id: row.src})
MATCH (destination:User {id: row.dst})
MERGE (source)-[:FOLLOWS]->(destination);
我们可以通过使用下面的 cypher 语句来可视化 Zeppelin 中的示例图:
MATCH p=(:User)-[:FOLLOWS]->(:User)
RETURN p;
结果
Apache Zeppelin 中可视化的示例图
图形数据科学插件
创建预加载的命名图
推荐使用 GDS 库的方法是预加载命名图。投影图可以存储在内存中，以后可以通过任何图形算法使用其名称进行检索。这允许更有效的图形分析管道，其中我们在同一个内存图形上按顺序运行许多图形算法。
一般语法是:
CALL gds.graph.create('nameOfGraph','NodeLabel','RelationshipType')
在本例中，我们将使用以下 cypher 语句将图形加载到内存中:
CALL gds.graph.create(‘pagerank_example’, ‘User’, ‘FOLLOWS’);
流式传输算法的结果
算法结果流的一般语法是:
CALL gds.<algorithm>.stream()
对于 PageRank 示例，cypher 过程如下所示:
CALL gds.pageRank.stream(‘pagerank_example’,
{maxIterations: 20, dampingFactor: 0.85}) YIELD nodeId, score
RETURN gds.util.asNode(nodeId).id AS name, score
ORDER BY score DESC LIMIT 10
结果
Neo4j 页面排名结果
正如我们所料，Doug 拥有最高的 PageRank，因为在他的子图中，所有其他用户都跟随他。虽然马克只有一个追随者，这个追随者就是
道格，所以马克在这个图中也被认为是重要的。重要的不仅仅是关注者的数量，还有那些关注者的重要性。
写回算法的结果
有时候，我们想把算法的结果写回图中，而不是流出来。写回算法的一般语法是:
CALL gds.<algorithm>.write({writeProperty:'pagerank'})
其中如果您想写回结果，参数writeProperty是强制的。这是为了防止对图形进行任何不必要的写入。
在我们的 PageRank 示例中，我们使用:
CALL gds.pageRank.write(‘pagerank_example’,
{maxIterations: 20, dampingFactor: 0.85,
writeProperty:’pageRank’})
从内存中释放加载的图形
完成图形分析后，我们想使用下面的 cypher 语句从内存中释放 GDS 图。
CALL gds.graph.drop(‘pagerank_example’);
用 Apache Spark 实现的 PageRank
如前所述，这本书还提供了 Apache Spark 中图形算法的实现，所以我只是将它们复制到笔记本上。
加载示例图表:
在这个例子中，我们使用 GraphFrames 库来加载图表并计算 PageRank 中心性。
def create_social_graph():
nodes = spark.read.csv(“spark-warehouse/social-nodes.csv”, header=True)
relationships = spark.read.csv(“spark-warehouse/social-relationships.csv”, header=True)
return GraphFrame(nodes, relationships)g = create_social_graph()
迭代次数固定的 PageRank
让我们看一个固定迭代方法的例子。
注意在 Spark 中，阻尼因子更直观地被称为
重置概率，具有相反的值。换句话说，本例中 reset
Probability=0.15 相当于 Neo4j 中的 dampingFactor:0.85。
results = g.pageRank(resetProbability=0.15, maxIter=20)
results.vertices.sort(“pagerank”, ascending=False).show()
结果
具有固定迭代次数的 Spark PageRank
结果类似于 Neo4j 的结果。
PageRank 的实现各不相同，因此即使排序相同，它们也会产生不同的
得分。Neo4j 使用值 1 减去阻尼因子来初始化节点
，而 Spark 使用值 1 初始化
。在这种情况下，相对排名(Pag 的目标是
eRank)是相同的，但是用于达到
这些结果的基础分值是不同的。
PageRank 直到收敛
现在，让我们尝试运行 PageRank 的收敛实现，直到它在设定的容差范围内逼近一个解决方案:
results = g.pageRank(resetProbability=0.15, tol=0.01)
results.vertices.sort(“pagerank”, ascending=False).show()
结果
带收敛策略的 Spark PageRank
每个人的 PageRank 分数与固定迭代次数变量略有不同，但正如我们所料，他们的顺序保持不变。
个性化页面排名
我们可以通过传入 sourceId 参数来计算给定节点的个性化 PageRank 分数。以下代码计算道格的 PPR:
me = “Doug”
results = g.pageRank(resetProbability=0.15, maxIter=20, sourceId=me)
people_to_follow = results.vertices.sort(“pagerank”, ascending=False)already_follows = list(g.edges.filter(“src = ‘{me}’”).toPandas()[“dst”])
people_to_exclude = already_follows + [me]people_to_follow[~people_to_follow.id.isin(people_to_exclude)].show()
结果
Spark 个性化页面排名
这个查询的结果可以用来为道格应该关注的人提供建议。请注意，我们还确保从我们的最终结果中排除道格已经关注的人以及他自己。
爱丽丝是道格应该追随的最佳人选，但我们也可以推荐迈克尔和布里奇特。
结论
再次感谢 Amy 和 Mark 编写了这本优秀的书，感谢 Neo4j 图表数据科学团队提供了如此出色的工具来帮助我们在图表中找到更多见解。正如我在这篇博文的介绍中提到的，目前这仍然是 GDS 插件的预览版，正式发布将在接下来的几周内进行。自己试试图形数据科学插件，请分享任何评论、反馈或建议。
一如既往，你可以在 GitHub 上找到这些笔记本。
介绍“向后走”:一种预测未来的新方法
受够了及时验证！“向后走”使预测模型更加准确和可靠
“永远不要做预测，尤其是对未来的预测。”(k·k·斯坦克)
- 这幅画描绘的是马还是车？
- 该顾客在下周购买该商品的可能性有多大？
- 这个人会在下一年无法偿还贷款吗？
- 这句话怎么翻译成西班牙语？
这些问题或许可以用机器学习来回答。但是，问题 1 和问题 4 关注的是已经存在的事物(一张图片，一个句子)，而问题 2 和问题 3 关注的是未来的事件，即尚未发生的事件。这有关系吗？的确如此。
事实上，我们都知道——首先作为人类，然后作为数据科学家——预测未来是很难的。
从技术角度来看，这是由于概念漂移，这是一个非常直观的概念:现象随着时间而变化。由于我们想要预见的现象在不断变化，使用一个模型(基于过去的经验)来预测未来带来了额外的挑战。
在这篇文章中，我将描述三种可能用于预测未来的机器学习方法，以及它们如何应对这些挑战。
- 及时:最常采用的方式。就结构而言，它深受概念漂移之苦。
- 向前走:在金融等一些领域常见，但在机器学习中还是不那么常见。它克服了及时的一些弱点，但代价是引入了其他缺点。
- 向后行走:一种新颖的方法，结合了及时行走和向前行走的优点，同时减少了它们的缺点。我在真实的、庞大的、杂乱的数据上试了试，结果证明效果非常好。
在文章的第一部分，我们将介绍这三种方法。在第二部分中，我们将在数据上尝试它们，看看哪一个效果最好。
第一种方法:“及时”
假设今天是 2020 年 10 月 1 日，你想预测下一个月(即从今天到 10 月 31 日)你公司客户流失的概率。
下面是大多数数据科学项目如何解决这个问题:
及时的方法。
注意:包含在 X 中的信息可以无限回溯(但是，在所有的图中，为了直观起见，只能回溯 4 个月)。
这种方法被称为“实时”，因为所有数据集(训练、验证和测试)都来自同一个时间点(在这种情况下，是 9 月)。通过培训、验证和测试，我们打算:
- Train set(X _ Train和 y_train ):模型将要学习的数据。
- 验证集(X _ Validation和 y_validation ):用于提前停止的数据。在训练阶段，在每次迭代中，都会计算验证性能。当这种性能停止改善时，意味着模型已经开始过度拟合，因此训练停止。
- 测试集 ( X_test 和 y_test ):训练阶段从未使用过的数据。仅用于评估您的模型在未来的实际表现。
现在您已经收集了数据，您可以在训练集(9 月)上拟合一个预测模型(假设是 Xgboost)。在测试集上的性能如下:准确率为 50%，召回率为 60%。既然您对这个结果感到满意，您决定将这个结果传达给利益相关者，并在 10 月份进行预测。
一个月后，你去检查你的模型在十月份的实际表现。一场噩梦。准确率 20%，召回率 25%。这怎么可能呢？你做的一切都是对的。你验证了你的模型。然后你测试了它。为什么测试性能和观察性能相差如此之大？
过时了
问题是及时方法完全忽略了概念漂移。事实上，这个假设是含蓄地提出的:
时间背后的本质:参数(θ)不随时间变化。
在这个框架中，当模型被训练时实际上并不重要，因为 f(θ) 被假定为随时间恒定。不幸的是，现实中发生的事情是不同的。事实上，概念漂移使得 f(θ) 随着时间而变化。在公式中，这将转化为:
一个更一般(也更现实)的假设:参数取决于时间。
为了考虑这种影响，我们需要将我们的思维模式从及时转变为不及时。
第二种方法:“向前走”
超时的一种形式——主要用于金融——被称为“漫步”(阅读罗杰·斯坦的这篇文章以了解更多)。这个名字来源于这样一个事实，即模型是根据用于训练的数据在时间上向前验证和/或测试的。视觉上:
向前走的方法。
这种配置的优点是它模拟了模型的实际使用。其实模型是在t(8 月)进行训练，在t+1(9 月)进行评估。因此，这是 9 月份训练和 10 月份预测的一个很好的代理。
然而，当我在真实数据上尝试这种方法时，我注意到它有一些主要缺点:
- 如果您使用 8 月份训练的模型来预测 10 月份的情况，您将使用一个 2 个月前的模型！因此，十月份的性能会比使用 In-Time 时更差。实际上，这是因为最新的数据被“浪费”在测试上。
- 或者，如果您在 9 月重新培训模型，您将再次陷入及时。而且，最后估计 10 月份车型的预期表现也不会很容易。这样你就能回到起点。
总而言之，我喜欢超越时间的想法，但在我看来，步行前进是不值得的。
第三种方法:“向后走”
然后，这个想法出现在我的脑海中:有没有可能概念漂移在某种程度上随着时间的推移是“不变的”？换句话说，预测 1 个月的未来或 1 个月的未来会导致相同的表现吗？
如果是这样的话，我会一石二鸟(不，等等，三只鸟)。事实上，我会保留以下好处:
- 使用最新数据进行训练(如及时发生的，但不是提前发生的)；
- 对模型在下个月的表现做出可靠的估计(如在 Walk-Forward 中发生的，但不是在 In-Time 中)；
- 只训练一个模型(在实时中发生，但在步行中不发生)。
简而言之，我会保留每种方法的优点，同时消除它们的缺点。这就是我如何得到以下配置的:
向后走的方法。注:使用不同的时间窗口进行训练、测试和验证(即使是对相同的观测值)没有方法上的问题，只要预测窗口(在这种情况下，y _ train，y _ validation和y _ test*)不重叠。*
我称之为“向后走”,因为它与向前走正好相反:训练基于最新的数据，而验证和测试基于以前的时间窗口。
我知道在 9 月份训练一个模型(并在 7 月份验证它)，然后在 8 月份检查它的表现，甚至期望这是对它在 10 月份表现的一个很好的估计，这可能看起来很疯狂！这可能看起来像是我们乘坐德罗宁在时间上来回穿梭，但我保证我有一个很好的解释。
如果你喜欢哲学…
…然后是为什么倒着走有意义的哲学解释。我们来分解一下。
- 对于每组(训练、验证和测试)，最好使用不同预测窗口。这对于避免验证数据或测试数据对模型的表现给出过于乐观的估计是必要的。
- 给定点 1。，9 月训练模特( t )是唯一合理的选择。这是因为该模型应该“学习一个与我们想要预测的世界尽可能相似的世界”。九月的世界( t )可能比过去任何一个月( t-1 、 t-2 、…)更类似于十月的世界( t+1 )。
- 在这一点上，我们有一个 9 月份训练的模型，并想知道它在 10 月份的表现如何。应该选择哪个月作为测试集？八月是最佳选择。事实上，八月的世界( t-1 )与九月的世界( t )是“不同的”，正如十月的世界( t+1 )与九月的世界( t ) )是“不同的”。发生这种情况的原因很简单:十月和八月离九月同样遥远。
- 给分 1。, 2.第三。，使用 July ( t-2 )作为验证集是唯一的必然结果。
如果你不喜欢哲学…
…那么，也许，你喜欢数字。在这种情况下，我可以向您保证:我在一个真实的用例上尝试了这种方法，与及时和向前行走相比，向后行走获得了:
- 预测精度更高y _ future；
- 在 y_test 和 y_future 上的性能差异较小(即 8 月观察到的精度是对 10 月实际获得的精度的更可靠估计)；
- 在 y_train 和 y_test 上的性能差异较小(即过拟合较少)。
基本上，数据科学家能要求的一切。
“我还是不相信你！”
没关系，我也是个多疑的人！这就是为什么我们会在一些数据上尝试及时、向前和向后，看看哪一个表现最好。
为此，我们将使用模拟数据。模拟数据是“在实验室”重现概念漂移并使结果可复制的一种便捷方式。这样，就有可能在更普遍的情况下检验向后行走的优越性是否得到了证实。
在实验室重现概念漂移
我们取 12 个时间点(2020 年 1 月到 2020 年 12 月的月度数据)。假设每个月有 50 个特征在 5000 个人身上被观察到。这意味着 12 个数据帧(x1，…，x12)，每个数据帧具有 5000 行和 50 列。为了简单起见，这些列是根据正态分布生成的:
一旦 X 可用，我们就需要*(因变量，或目标变量)。出于简单起见， y 将是一个连续变量(但是结果可以很容易地扩展到 y 是离散的情况)。*
假定 X 与 y 之间为线性关系:
β s 由 t 索引，因为参数随时间不断变化。这就是我们如何在简化版的世界中解释概念漂移的。
特别是 β s 根据 ARMA 过程变化。这意味着**【β(I)的波动不是完全随机的:它们取决于【β(I)**本身的过去值。
ARMA 系数(和误差)的选择是基于一个保守的假设，即月与月之间的波动不是很大(注意，一个更激进的假设会更倾向于过时的方法)。特别的，我们假设 ar 系数为-0.3，MA 系数为 0.3，误差的标准差为 0.5。这些是前 6 个(50 个中的) β 的结果轨迹。
时间轨迹: β(1) 到β(6)**。**
这就是目标变量( y )的样子:
y 的分布。虚线分别代表第 25、50 和 75 百分位。
结果
现在我们有了数据，可以比较这三种方法。
由于这是一个回归问题( y 为连续变量)，所以选择了平均绝对误差(MAE)作为度量。
为了使结果更加可靠，每种方法都在所有时间点上执行(以“滑动窗口”的方式)。然后，对所有时间点的结果进行平均。
这是结果:
实验的结果。绿色:所选 KPI 的最佳结果。红色:所选 KPI 的最差结果。
通常，预测模型好坏的最重要指标是在 y_future 观察到的性能。从这个角度来看，后退是最好的方法，因为它提供了最好的 MAE (3.98) 。
但不止如此。看一下 In-Time: MAE( 测试)平均 2.91，MAE( 未来)4.20。因此，在现实世界的用例中，您将向涉众传达您期望您的模型交付 2.91 的 MAE。但是一个月后你会观察到的实际表现是平均 4.19。这是一个巨大的差异(和巨大的失望)！
实际上，测试性能和未来性能之间的绝对差异，对于及时测试来说，平均是回溯测试的三倍(1.28 比 0.43)。因此，从这个角度来看，倒着走是目前为止最好的方法。
注意，在现实世界的用例中，这个方面可能比性能本身更重要。事实上，能够预测模型的实际性能——而不必等到下一阶段结束——对于分配资源和规划行动至关重要。
结果完全可重复。Python 代码在本笔记本中有。
作者通过 matplotlib (用于绘图)或 codecogs (用于乳胶配方)创建的所有图像。
感谢您的阅读！我希望这篇文章对你有用。
我感谢反馈和建设性的批评。如果你想谈论这篇文章或其他相关话题，你可以发短信给我我的 Linkedin 联系人。
Adagradient & RMSprop 的介绍与实现
不同维度上的自适应学习率
在上一篇文章中，我们介绍了随机梯度下降和动量项，SGD 在传统梯度下降中增加了一些随机性，动量项有助于加速这一过程。然而，这两种方法都设定了固定的学习率:
上面显示了带有动量项的梯度下降，其中lr实际上对于不同维度上的所有参数都是固定的。对于频繁出现的参数，它可以很好地工作，这些参数也可以通过迭代频繁更新，但是对于与不频繁出现的特征相关联的参数，它将导致更新不足以达到最优。
与不经常出现的特征相关联的参数仅在这些特征出现时接收有意义的更新。给定一个递减的学习速率，我们可能会在这样一种情况下结束，其中共同特征的参数相当快地收敛到它们的最优值，而对于不频繁的特征，我们仍然不能在它们的最优值能够被确定之前足够频繁地观察它们。换句话说，对于频繁出现的特征，学习速率降低得太慢，或者对于不频繁出现的特征，学习速率降低得太慢。
Adagradient
Adagradient 是为解决上述问题而开发的，它根据每个参数的梯度和频率以不同的速度更新不同的参数。让我们看看这个公式:
您可能已经注意到，关键的区别是这里添加了s_t术语。对于不常见的特征或梯度较小的特征，它们的s_t会很小，但lr/sqrt(s_t + ϵ)会很大，这导致更新的步长较大。这为不同的参数给出了不同的更新速度，解决了统一学习率带来的弊端。
现在让我们实现它并将其应用到一个实际问题中。
我们要解决的问题和我们之前说过的一样，
其中我们试图找到a, b的最佳值，以最小化y和f(x)之间的差异损失，并且上面计算了a, b的梯度。adagradient 的实现将是:
其中X, Y的输入值由下式得出:
实现应该是直接的，我们将s_a, s_b初始化为 0，为了绘制学习过程，我将中间值保存在列表中。
参数更新过程如下:
参数更新
学习率是这样的:
学习率更新
这里的lr/sqrt(s + ϵ)被认为是修正的学习率。
RMSprop
adagrad 的一个问题是，随着梯度随着时间的推移而累积，项s可能会变得无限长，这可能会导致学习步骤的急剧减少，并导致参数最终几乎不变。
RMSprop 旨在通过简单地对术语进行标准化来解决这一问题:
注意这里过去的梯度s_{t-1}被一个额外的参数γ所限制，其中γ通常取值 0.9。
除了s的更新，实现与 adagrad 类似。更新过程将是这样的:
参数更新
学习率是这样的:
学习率更新
这里我们看到a, b的学习率是振荡的，而不是单调下降的(你可以在这里检查的实现)。
到目前为止，我们已经学习了几种在优化过程中应用的技术。接下来，让我们将它们集合起来，衍生出另一个强大的工具— Adam 。
参考:
- http://d2l.ai/chapter_optimization/rmsprop.html
- https://ruder . io/optimizing-gradient-descent/index . html # stochasticgradientdescence
TensorFlow 2.0 简介
Tensorflow 2.0 的一些功能的软介绍
来源:Keep-calm.net
在这篇文章中，我将介绍我在探索 TensorFlow 时的一些发现，这个想法将与 TensorFlow 一起围绕图像分类建立和监控 ML 模型，以及比我几周前建立的汽车数据集更好的数据集。
TensorFlow kezako？
TensorFlow 是 Google Brain 在 2011 年开始的一个研究项目，多年来在 Alphabet group 中非常受欢迎。该框架因其高度灵活的架构而在机器学习社区中广受欢迎，该架构可以利用不同类型的处理单元，如 CPU 、 GPU 或 TPU 来执行计算，而无需对运行代码进行大的修改。
该框架自 2015 年以来一直是开源的，似乎在世界各地都非常受欢迎，下载量超过 76 00 万次。Google 提供了多种 API 来与框架交互，如 Python、Javascript、C++、Java 和 Go。
TensorFlow 拥有多种工具来开发机器学习系统:
- 张量流 (dah)
- TensorFlow.js
- TensorFlow lite 在嵌入式系统中部署机器学习模型
- TensorFlow 将扩展到产品化机器学习管道
- TensorFlow Quantum 一个“混合量子经典 ML 模型快速原型库”
这套工具非常广泛，我真的建议你看一下上面的不同文档，这会给你一个很好的工具概述。
我只是想谈谈 TensorFlow，但我计划在几周内看看 Lite 和。js 工具(我订购了一个设备，在上面做了一些测试😉)
TensorFlow，如何建立 ML 模型？
为了与 TensorFlow 进行交互，最流行的 API 之一是 Python API(老实说，这是我更喜欢的一个)，但是有两种途径可以与这个 API 进行交互:
- 初学者使用一个叫做 Keras 的用户友好的顺序 API
- 使用子类 API 的专家更加 pythonic 化
我附上你的两个 API 格式的例子快照
来源:张量流概述
对我来说，我真的建议使用 Keras，对于非 python 专家来说，它可能更容易阅读。这个 API 最初在 TensorFlow 1.x 版本中不是本地 API(因为 2.0 是本地的)，必须单独安装才能访问它。
Keras 是一个 API，可以运行在各种 ml 框架之上，如 TensorFlow、CNTK 和 Theano，以帮助人们轻松地重用函数来构建层、求解器等，而无需深入 ML 框架(某种程度上是抽象层)。
让我们构建一些模型来测试这个框架。
模型构建
在这一部分中，我不打算解释我将要使用的模型的架构(可能在一篇特定的文章中)。要开始构建模型，我首先需要将框架与数据连接起来。
数据被划分到与训练集、验证集和测试集相关的文件夹中，在每个文件夹中，每个类别都有一个子文件夹，用于预测将用于该过程的所有图片。有一个图表来表示训练集中每类图片的分布。
验证和测试集中的类的重新划分与具有更少数据的训练集中的相同(训练 80%，验证 10%和测试 10%的完整数据集)。
为了使用模型中的数据，可以像在 TensorFlow 的教程中一样使用数据生成器，这里有代码的快速快照。
该代码的想法是:
- 正常化图片(RGB 从 0–255 到 0–1 之间的值转换)
- 调整图片大小
- 为培训建立不同的批次
它需要应用于所有的文件夹，但在此之后，一切都准备好开始模型的训练。
在模型方面，我重用了 TensorFlow 教程的模型设计，并应用到了其他一些资源上。这些模型可以在以下列表中找到:
- TensorFlow 的 CNN 教程
- 奥雷连·杰龙的 MLP 在他的书的第十章中用 Scikit-Learn、Keras 和 TensorFlow 动手操作机器学习
- Sebastian Raschka 和 Vahid Mirjalil 的 CNN 在他们的书 Python 机器学习的第 15 章中
该模型的输入和输出已被修改以适应我的需要，但大部分代码来自所列的各种资源。再一次，这些模型只是用来测试框架的，它们对我的问题来说并不是最优的(还需要很多改进)。
通过执行数据生成和模型构建，几分钟后模型就准备好了。
现在让我们看看 TensorFlow 的监控组件。
模型监控
要监控您的模型，TensorFlow 有两种途径(对我而言):
- 使用模型拟合操作的历史来访问已经计算的各种度量(在这种情况下是损失和准确性)
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']loss=history.history['loss']
val_loss=history.history['val_loss']
例如，使用 matplotlib，可以非常容易地使用历史的输出来绘制图形。
另一种方法是使用一个名为 Tensorboard 的组件，它是一个与 TensorFlow 相关的包，能够在跑步过程中实时收集各种指标，以构建模型(cf gif)，可视化架构和数据等。
来源: Tensorboard 文档
最近，谷歌宣布能够通过 tensorboard.dev 计划与每个人共享仪表盘，例如，你可以在这个链接中找到一个与我在这个项目中的一些跑步相关的 tensorboard。
Tensorboad 是一个有趣的计划，他们在上次 TensorFlow 开发峰会上宣布了许多新功能，但老实说，我不是一个非常有经验的深度学习实践者，所以我不太支持这个对我来说看起来很复杂的组件，但我认为它可能是与 mlflow 相关联的数据科学工具箱的一个非常好的工具。
最后，我想介绍另一个组件 TensorFlow hub。
与 TensorFlow hub 共享模型
TensorFlow hub 诞生于 Google 的一个简单情况是，我正在阅读一篇关于神经网络架构的非常好的文章，这篇文章看起来非常有前途，但在调查过程中可能会出现许多问题，例如:
- 如何才能重现这篇文章？
- (以文中的回购为例)是模型的最后版本吗？
- 数据在哪里？
- (以文中的回购为例)使用这段代码安全吗？
TensorFlow hub 希望人们能够限制所有这些问题，并在 ML 开发上给予更多透明度。
TensorFlow hub 的一个非常有趣的功能是帮助人们用著名的健壮模型的组件来建立机器学习模型，这种方法是重用另一个模型的模型权重，它被称为迁移学习。
使用 TensorFlow hub，您可以非常容易地重用另一个模型的几行代码组件，在下面的要点中，有一个我构建的代码示例，用于重用一个名为 Mobilenetv2 的模型的特征提取器，该模型在对象分类方面非常流行(主要受 TensorFlow 教程的启发)。
现在让我们总结一下这个分析
反馈
这第一次动手 TensorFlow 非常好，我发现教程做得很好，很容易理解，你可以很容易地用框架的 Keras API 建立神经网络。有很多组件我还没有测试，就像在这张截图上看到的那样
来源:张量流文档
我添加了一个机会来看看 TensorFlow Extended ( TFX )，这是谷歌建立机器学习管道的方法，我添加了一个 AWS EC2 实例的尝试，但该教程在某个点上崩溃了，但我邀请你观看罗伯特·克罗的精彩演讲，该演讲更详细地介绍了该工具。
这种方法看起来很有前景，我真的很好奇 TFX 和 Kubeflow (谷歌基于 Kubernetes 的另一个 ML 管道)之间将会存在什么样的互动。
我对 TensorFlow 唯一的担心/疑问是处理单元的使用，在我的测试中，我在 CPU 和 GPU 之间交替使用，但我对处理的监控没有显示处理单元充分发挥潜力(但我可能只是个新手)。
增加 TensorFlow 效率的另一个路径是使用 tfRecords ，但似乎数据管理仍然是一个热门话题(从我周围听到的)，我发现了一个真正有趣的 Pydata 对话围绕着用 TensorFlow 管理 parquet 文件。
我围绕深度学习的下一个任务是:
- 对脸书的 Pytorch 做一个简单的介绍，它似乎是 TensorFlow 的克星，这个框架在研究领域赢得了很多关注
- 加速深度学习算法，以建立一个像样的汽车分类器
- 了解这些深度学习模型在生产中的部署(数据管理、服务等)
3D 视觉简介
找到你的智能手机的焦距(像素)
在计算机视觉(CV)的世界里，有很多有趣的概念。在过去十年中，深度卷积神经网络在很大程度上主导了许多 CV 任务。在某些领域，CNN 在图像分类、物体检测和图像分割等方面比人类表现得更好。CNN 的最大优势是它们可以大规模运行，因此可以很好地利用个人和公司收集的大量图像数据！最近，变形金刚也在探索 CV 任务。然而，在这篇文章中，我们将关注计算机视觉的一个更“老派”的方面:3D 视觉。我确信 3D 视觉是我们在日常生活中遇到的东西——我的意思是，我们的眼睛基本上是利用这个原理工作的。本帖旨在介绍其背后的一些基本概念！
3D 视觉的关键功能之一是捕捉深度信息。对于单个相机，我们只有关于特定场景的 2D 信息，因此至少需要 2 个相机！(例如我们的眼睛！).在这个系列中，我将演示如何用智能手机摄像头完成 3 个简单的任务:
- 找到你的智能手机相机的焦距
- 使用两张照片恢复物体的深度
- 从同一个地点拍摄同一场景的两张照片时，找出相机的旋转角度。
寻找焦距
相机的焦距如下图所示。这是照相机和镜头内部工作原理的简化。我们不难看出，通过测量一个物体的实高、实距和像高，就可以求出焦距。这些量通过以下公式相关联:
如果你记得你的高中物理课，这可能看起来很熟悉。现在，我们将比理论更进一步，尝试找出我们智能手机的焦距！可以按照步骤，自己尝试一下。
- 找一个已知高度的物体， H 。利用你的朋友/家人，或者你可以利用墙上的两点来测量距离。
- 从一定距离拍摄一张照片， D 远离物体。
我卧室的照片，墙上有两个画得很漂亮的十字架。
3.测量物体的图像高度， h 。你可以使用任何常见的图像编辑工具或图像浏览器，我在微软画图。用笔刷工具将鼠标悬停在十字上，我们可以得到下图左下方显示的图像坐标。
4.使用毕达哥拉斯定理从两点计算图像高度。对于我的照片，点是(1849，291)，(1782，2954)，计算的高度是 2664 像素。
5.使用上面的等式计算 f ！确保 H 和 D 的单位相同(我和世界上大多数人一样使用米)。
6.我用一加 6T 智能手机得到了 3566 像素的焦距。请在下面评论分享您的结果和手机型号！
结论/讨论
这是一个简短的帖子，描述了任何人如何通过抓拍照片来计算智能手机的焦距。这是一个很好的信息，因为我们可以交叉检查实际焦距与手机销售商/制造商给出的规格！此外，知道像素的焦距将允许我们做这个系列中的一些其他任务。
你也可以在不同的距离对不同的物体重复这个实验，拍多张照片。最后计算平均 f 值以减少误差。本系列的后续帖子将解释其他可以在智能手机上轻松完成的动手项目，敬请关注！
8 种基本数据结构介绍
数据结构
了解最常见的数据结构背后的基本概念
Patrick Robert Doyle 在 Unsplash 上拍摄的背景照片
作为程序员，我们对数据结构的理解大多局限于在编程语言的更高抽象层次上使用它们。虽然我们知道如何使用特定的编程语言从不同的数据结构中存储和检索数据，但我们大多数人并不试图去解开这些数据结构的底层实现中发生了什么。
在大多数情况下，数据结构的表面知识足以以某种方式完成我们的工作。但是，在为给定任务选择最佳数据结构时，理解不同数据结构在较低级别的行为是至关重要的。在这篇文章中，我们将探究 8 种不同的数据结构，看看它们是如何处理数据的。
排列
数组数据结构存储固定数量的单一数据类型的数据。数组中的元素(项目)存储在一块连续的内存槽中。因此，数组中的元素被赋予连续的数字，从 0 或 1 开始，作为它们的“索引”。
人们可以使用唯一的索引随机访问存储在数组中的单个元素。使用索引访问元素的时间复杂度为θ(1)。以这种方式可以容易地实现读取或更新数组元素。因为数组元素的位置是连续的，所以与大多数其他数据结构相比，数组遍历更快。
向数组中插入数据或从数组中删除数据是一项相当复杂和耗时的任务。插入时，当前数组中的所有元素都被复制到一个新创建的大小增加的数组中，新元素被添加到新数组的末尾。删除也以类似的方式实现，以减小数组大小。
应用:
数组可以是多维的(数组的数组)。这使得数组成为存储矩阵和向量的好选择。数组经常用于实现其他数据结构，如列表、堆、栈和队列。
长队
队列数据结构类似于我们日常生活中看到的队列:第一个进入队列的人是第一个获得下一个退出队列机会的人。在编程世界版本的队列中，添加到队列中的每个新数据元素都存储在后端，从队列中移除的每个元素都从前端取出——基于先进先出的原则。
队列操作
- 入队:将元素插入到队列的末尾。新添加的元素成为队列的最后一个元素。
- 出列:从队列的前面删除一个元素。入队和出队操作的时间复杂度都是θ(1)。
- Peek:读取队列前面的元素，而不删除或修改它。
应用程序
队列用于实现缓冲区。多线程使用队列来管理等待线程执行的任务。
堆
堆栈与队列非常相似，但是它们是基于后进先出而不是先进先出来实现的。想象一堆菜，其中最后添加的菜是第一个要移除的菜。
堆栈操作
- Push:在栈顶插入一个新元素。新添加的元素成为新的顶部元素。
- 从栈顶移除一个元素。推送和弹出操作的时间复杂度均为θ(1)。
- Peek:读取堆栈顶部的元素，而不删除或修改它。
应用程序
堆栈用于处理和评估数学表达式。它们也用于使用回溯过程的算法中。在递归编程中处理递归函数调用是另一个应用。
链表
链表是一种动态数据结构。这意味着存储在链表中的数据项的数量可以很容易地增加或减少。与固定大小的数组相比，这给了链表更多的灵活性。链表通过将每个项目存储为一个单独的对象来实现这种动态特性。
链表中的元素不必存储在连续的内存槽中，相反，每个元素(称为节点)存储一个指向下一个节点位置的指针。这些指针维护着与链表中独立节点的连接。除了指向下一个节点的指针，一个节点还存储一个数据字段。
链表中有两个重要的节点:头和尾。
- Head:链表的第一个节点。
- Tail:链表的最后一个节点。Tail 的指针值被设置为 null。
当向链表中插入新元素时，新的数据字段存储在内存中的特定位置，并且更新前一个节点中的指针以指向新节点。新节点存储先前存储在前一节点中的指针。
删除节点时，被删除节点之前的节点被赋予先前存储在被删除节点中的指针。
然而，对于链表，如果不从头开始遍历链表，就不能直接访问单个数据项。这使得访问操作的时间复杂度为θ(n)。
链接列表类型
- 单链表:上面例子中显示的链表都是单链表。一个节点只包含一个指向下一个节点的指针。
- 双向链表:双向链表中的节点包含指向给定节点前后节点的指针。可以在向前和向后两个方向上遍历列表。
- 循环链表:尾部的指针指向头部而不是空。本质上，循环链表没有尾巴，只有一个头。
应用程序
链表用于实现数据结构，如堆栈、队列和图形。当执行多项式代数运算时，链表用于存储常数。
图表
一个图由有限数量的数据项组成，称为顶点(V) 。这些顶点中的一些对通过边(E) 相互链接。由一条边连接的两个顶点是彼此相邻的**。**
可以使用不同的属性对图形进行分类。其中一种分类是有向图和无向图。
- 在有向图中，连接两个顶点的边有一个起点和一个终点。当遍历图时，只能从起始顶点到结束顶点穿过边。
- 在无向图中，一条边可以在两个方向上无限制地遍历。
应用
像脸书这样的社交媒体应用程序使用图表来表示用户的顶点和他们的友谊的边。谷歌页面排名算法使用图形来表示网页和连接它们的链接。谷歌地图使用图表来表示其交通系统中的道路网络。
二叉树
二叉树与有向图有一些相似之处。两者的区别在于，在二叉树中，数据存储在分层结构中，上层节点称为父节点，下层节点称为子节点。二叉树中的一个节点只能有一个父节点和最多两个子节点。
让我们来看几个与二叉树相关的术语。
- 根:树顶部的节点。它没有父节点。
- 叶子:树底部的一个节点。它没有子节点。
- Key:存储在节点中的数据值。
- 子树:由一个节点的所有后代组成的树
有许多特殊的二叉树，如二叉查找树树、Treap 树、二叉树和堆树。
二叉查找树
二叉查找树按排序顺序存储数据值。二叉查找树中节点左侧子节点的值必须小于父节点，右侧子节点的值必须大于父节点。
顾名思义，BST 的主要优点是能够快速搜索存储的数据。在 BST 中搜索存储元素的时间复杂度是 O(log n)。
应用程序
- 二分搜索法树用于在编程语言中实现地图和集合对象
- 二进制尝试用于存储路由表。
- Treaps 用于无线网络。
许多
堆是二叉树的另一个特例。在堆中，根的键与其子的键进行比较，以特定的方式排列它们。有两种类型的堆。
- 最大堆:父项的键大于或等于子项的键。根节点存储给定数据集中的最大值。
- 最小堆:父级的键小于或等于子级的键。根节点存储给定数据集中的最小值。
假设我们得到了整数值(33，24，45，12，90，78，23，53)作为数据集。我们可以从这些数据中构造一个单独的最大堆和最小堆。
最小堆
最大堆
在堆中插入、删除和提取最大(或最小)函数的时间复杂度为 O(log n)。但是求最大值(或最小值)只有 O(1)的时间复杂度。
应用程序
堆用于实现堆排序算法。堆也用于实现优先级队列，因为堆的第一个元素总是存储具有最高(或最低)优先级的值。
哈希表
当我们希望保持在大型数据集上搜索和插入操作的速度时，哈希表是我们可以使用的最有效的数据结构之一。存储在哈希表中的每个数据值都与一个键相关联，如果我们知道这个键，就可以快速访问存储的值。设想一个学生注册系统，其中每个学生都有一个唯一的学号，可以用它作为一个键将他们的数据存储在一个散列表中。
哈希表使用数组来存储数据值。该键用于在存储值的数组中查找索引。但是哈希表如何将这些键和它们的值映射起来呢？
可以使用的方法之一是直接寻址。它使用一对一的映射:每个键指向其数据存储的确切位置。但是这种方法不能有效地使用内存，特别是当键-值对的数量增加并且键变得更大时。因此，哈希表使用哈希函数。
散列函数
哈希表使用哈希函数将数据值映射到它们的键。它将一定范围的键值转换为一定范围的数组索引。将密钥传递给哈希函数所生成的索引或值称为哈希值。下面是一个哈希函数的例子。
h(k) = k % m
- h 是哈希函数
- h(k) 是密钥 k 对应的哈希值
- k 是关键
- m 是哈希表的大小。对于 m 来说，一个好的选择是一个不接近 2 的幂的质数。
让我们考虑几个键的哈希值。考虑 m=20。
- k=1001，h(k) = 1001%20 = 1
- k=1055，h(k) = 1055%20 = 15
- k=20123，h(k) = 20123%20 = 3
对于 k 值 1001、1055 和 20123，它们的关联值分别存储在哈希表中的索引 1、15 和 3 处。
考虑密钥 2021 的散列值，它是 1。我们之前看到，与键 1001 相关联的值存储在哈希表中的索引 1 处。当两个键生成的哈希值相似时，我们称之为碰撞。哈希表使用链接和开放寻址等技术来解决这种冲突问题。
哈希表的搜索和插入时间复杂度为 O(1)。
应用程序
哈希表用于实现数据库索引。编译器使用哈希表来识别编程语言中的关键字。计算机使用哈希表来链接文件名和它们的路径。
结论
本文提供了对我们作为程序员每天都要接触的 8 种数据结构的底层逻辑的基本介绍。了解了不同数据结构的独特属性后，从今天起，您在为您的编程任务选择最合适的数据结构时就可以更加小心了。但是记住，这只是一个基本的介绍。关于数据结构，你还可以做更多的事情，你也应该学习。
主动学习导论
什么是主动学习？
这篇文章的目标是帮助揭开主动学习的神秘面纱，并展示它与标准的监督机器学习有何不同。
一、什么是主动学习？主动学习是一种机器学习框架，其中学习算法可以交互式地询问用户(教师或 oracle)以用真正的标签标记新的数据点。主动学习的过程也称为最优实验设计。
主动学习的动机是我们拥有大量未标记数据的场景。考虑训练一个图像分类模型来区分猫和狗的问题。每一个都有数百万张图片，但并不是所有的图片都需要用来训练一个好的模型。一些图像可能比其他图像提供更多的清晰度和信息。另一个类似的应用是对 Youtube 视频的内容进行分类，其中的数据本来就很密集，而且存在很多。
被动学习是一种标准框架，其中大量标记数据被传递给算法，这需要在标记整个数据集方面付出大量努力。
被动机器学习。
通过使用主动学习，我们可以有选择地利用像众包这样的系统，让人类专家有选择地标记数据集中的一些项目，但不必标记全部。该算法基于某种价值度量迭代地选择信息最丰富的示例，并将这些未标记的示例发送给标记 oracle，Oracle 将这些查询到的示例的真实标签返回给算法。
主动机器学习。鸣谢:受张懿主动学习的启发幻灯片
在某些情况下，主动学习比随机抽样表现得更好。下图展示了主动学习相对于随机选择的一个激励性的例子。整组数据点(红色三角形和绿色圆圈的集合)不是线性可分的。
鸣谢:图片来自 Burr Settles 主动学习幻灯片。
主动学习的动机是理解到并非所有标记的例子都同样重要。通过对所有示例进行统一的随机采样，学习到的模型并不完全代表类别之间的划分。然而，主动学习选择靠近类边界的例子，并且能够找到更有代表性的分类器。先前的研究还表明，对于多类图像分类等任务，主动学习比标准随机选择有所改进[1，2，3，4]。
主动学习框架将数据的选择简化为确定数据集中哪些数据点信息量最大的问题。在主动学习中，信息量最大的数据点通常是模型最不确定的数据点。这需要各种度量来量化和比较示例的不确定性。
不同的主动学习框架
主动学习被认为是一种半监督学习方法，介于无监督使用 0%的学习样本和完全监督使用 100%的样本之间。通过迭代地增加我们的标记训练集的大小，我们可以实现更好的性能，接近完全监督的性能，而使用所有数据进行训练的成本或时间只有一小部分。
基于池的主动学习
在基于池的采样中，训练样本是从大量未标记的数据中选择的。从该库中选择的训练样本由 oracle 标记。
基于流的主动学习
在基于流的主动学习中，所有训练样本的集合作为流呈现给算法。每个示例都被单独发送给算法进行考虑。该算法必须立即决定是否标记该示例。从该池中选择的训练样本被 oracle 标记，并且在显示下一个样本以供考虑之前，该标签被算法立即接收。
不确定性度量
选择信息量最大的数据点的决定取决于选择中使用的不确定性度量。在基于池的采样中，主动学习算法选择信息最丰富的样本添加到不断增长的训练集中。
信息量最大的例子是分类器最不确定的例子。
这里的直觉是，模型最不确定的例子可能是最困难的例子——特别是位于类边界附近的例子。学习算法将通过观察困难的例子获得关于类边界的最多信息。
下面是在主动学习中使用的四种常见的不确定性测量方法，用于选择最有信息量的例子。
1.最小边际不确定性
最小边际不确定性是最佳与次佳不确定性的比较。最小边缘不确定性(SMU)是最可能类别的分类概率减去第二可能类别的分类概率[1]。这种度量背后的直觉是，如果最可能的类的概率明显大于第二最可能的类的概率，那么分类器对该示例的类成员关系更加确定。同样，如果最有可能的类的概率不比第二个最有可能的类的概率大多少，则分类器对该示例的类成员关系不太确定。主动学习算法将选择具有最小 SMU 值的例子。
2.最小置信不确定性
最小置信不确定性(LCU)是选择分类器对所选类别最不确定的例子。LCU 选择只查看最可能的类别，并选择分配给该类别的概率最低的示例。
3.熵减少
熵是随机变量不确定性的度量。在这个实验中，我们使用香农熵。香农熵具有几个基本性质，包括(1)均匀分布具有最大不确定性，(2)不确定性对于独立事件是可加性的，(3)添加零概率的结果没有影响，以及(4)具有特定结果的事件没有影响[6，7]。将类别预测视为结果，我们可以测量预测类别概率的香农熵。
熵值越高，表明概率分布的不确定性越大[1]。在每个主动学习步骤中，对于训练集中的每个未标记的示例，主动学习算法计算预测类概率的熵，并选择具有最高熵的示例。具有最高熵的例子是分类器对其类成员关系最不确定的例子。
4.最大边际不确定性
最大边际不确定性是最佳与最差不确定性的比较[5]。最大边缘不确定性(LMU)是最可能类别的分类概率减去最不可能类别的分类概率。这种度量背后的直觉是，如果最可能的类的概率明显大于最不可能的类的概率，那么分类器对该示例的类成员关系更加确定。同样，如果最可能类的概率不比最不可能类的概率大多少，那么分类器对该示例的类成员关系就不太确定。主动学习算法将选择具有最小 LMU 值的例子。
算法
下面的算法是一个基于池的主动学习[8]。基于流的主动学习可以类似地编写。
大规模分类任务中的一个主要瓶颈是训练分类器所需的大量训练样本。使用主动学习，我们可以通过有策略地选择特定的例子来减少教授分类器所需的训练例子的数量。
参考
[1] A. J. Joshi，F. Porikli 和 N. Papanikolopoulos，“用于图像分类的多类主动学习”， 2009 年 IEEE 计算机视觉和模式识别会议，佛罗里达州迈阿密，2009 年，第 2372–2379 页。
[2]郭，冼，雍睿，唐金辉，，“二维主动学习在图像分类中的应用”， 2008 年 IEEE 计算机视觉与模式识别会议，美国阿拉斯加州安克雷奇，2008，第 1-8 页。
[3]张怡园、汤绍清、吴国光和张振聪。“基于支持向量机概念的图像检索主动学习”， IEEE 多媒体汇刊，2005。
[4] A. Kapoor，K. Grauman，R. Urtasun 和 T. Darrell，“使用高斯过程进行对象分类的主动学习”， 2007 年 IEEE 第 11 届国际计算机视觉会议，里约热内卢，2007 年，第 1–8 页。
[5]https://becoming human . ai/accelerate-machine-learning-with-active-learning-96 ce a4 b 72 fdb
[6]https://towards data science . com/entropy-is-a-measure-of-an-determinance-e2c 000301 C2C
[7] L. M. Tiwari，S. Agrawal，S. Kapoor 和 A. Chauhan，“熵作为排队系统中不确定性的度量”， 2011 年全国研究生会议，吉隆坡，2011 年，第 1–4 页。
[8]https://towards data science . com/active-learning-tutorial-57c 3398 e34d
异常检测简介
哈雷戴维森在 Unsplash 上的照片
你有没有想过当某人的社交媒体账户、银行账户或任何其他账户/个人资料被黑客攻击时会发生什么？一些系统如何自动检测此类活动并通知相关机构或立即暂停帐户？这主要是通过称为异常检测(又名异常检测)的过程来完成的。事实上，上述特定示例被称为欺诈检测，它是异常检测在许多领域中的一个流行应用。因此，让我们深入了解异常检测术语。
异常检测或异常值检测是识别罕见项目、观察值、模式、异常值或与正常项目或模式显著不同的异常的过程。异常有时被称为离群值、新奇值、噪音、偏差或例外。根据一些文献，存在三类异常检测技术。分别是监督异常检测、非监督异常检测、和半监督异常检测。
监督与非监督异常检测
异常检测最常见的版本是使用无监督的方法。在那里，我们使用未标记的数据集训练一个机器学习模型来适应正常行为。在这个过程中，我们做了一个重要的假设，即训练集中的大多数数据都是正常示例。但是其中可以有一些异常的数据点(比例很小)。那么任何明显不同于正常行为的数据点将被标记为异常。在监督异常检测中，将使用被标记为“正常”和“异常”的数据集来训练分类器。当一个新的数据点到来时，这将是一个典型的分类应用。这两种方法各有利弊。有监督的异常检测过程需要大量的正反例。获得这样的数据集将非常困难，因为异常的例子很少。即使您获得了这样的数据集，您也只能对收集的数据集中的异常模式进行建模。然而，在任何领域都有许多不同类型的异常，而且未来的异常可能与迄今为止看到的例子完全不同。任何算法都很难从异常的例子中学习；异常点是什么样子的。这就是无监督方法流行的原因。捕捉正常行为比捕捉许多不同类型的异常要容易得多。
异常检测背后的术语
现在让我们深入探讨无监督异常检测背后的想法。在整篇文章中，该过程将被称为异常检测，而不是无监督的异常检测。在开始讨论异常检测算法之前，有一个叫做高斯(正态)分布的东西，这是整个算法的基础。在统计学中，高斯或正态分布是实值随机变量的一种连续概率分布形式。使用下面的公式计算概率函数。𝝁是平均值，𝝈^2 是方差。
概率分布关于其平均值是对称的，并且在整个实线上非零。正态分布有时被称为钟形曲线，因为密度图看起来像一个钟。
异常检测的基本思想是找到一个概率函数来捕捉正常行为，并发现一个概率阈值，使得远离该阈值的数据点被视为异常。考虑概率函数为 p(x ),阈值为ε，这可以描述如下。数据点用十字表示。
在基本的异常检测算法中，我们假设每个特征根据其自身的高斯分布分布，具有一些均值和方差。因此，使用训练数据集，我们针对特征 x1，x2，…，xn 拟合一组参数𝝁1，𝝁2，…，𝝁n 和𝝈12，𝝈22，…，𝝈n^2。然后概率函数 p(x)被计算为 x1 的概率乘以 x2 的概率乘以 x3 的概率，以此类推直到 xn 的概率。这就是异常检测的机器学习模型。当一个新的数据点进来时，我们简单地计算概率 p(x ),如果概率小于ε，就将其标记为异常。找到ε的正确值是一个优化目标，我不打算在本文中解释。
关于异常检测的更多信息
一个重要的事实是选择一组指示异常的特征。也就是选择一组特征，其中这些特征在出现异常时可能呈现异常大或异常小的值。另一方面，可能会有一些缺点，因为我们必须手动创建特征。此外，该算法只能检测少数异常情况。例如，当数据分布如下时，我们如何检测异常。
如您所见，使用高斯分布的早期模型将一些正常数据点标记为异常，将一些异常示例标记为正常数据点(上图中的蓝色边界)。事实上，我们需要为这种数据分布设置一个高级的边界(也许是紫色的边界)。使用多元高斯分布解决了这个特殊问题。在这里，不是将每个要素建模为各自的高斯分布并乘以概率，而是将所有要素建模为一个称为多元高斯分布的公共分布。
流行技法
今天，当实现异常检测算法时，您不必担心上述细节。像 scikit-learn(python)这样的流行库提供了更简单的方法来实现异常检测算法。下面是一些用于异常检测的流行技术。
- 基于密度的技术(KNN、局部异常因子、隔离森林等)
- 基于聚类分析的技术(KMeans、DBSCAN 等)
- 贝叶斯网络
- 神经网络、自动编码器、LSTM 网络
- 支持向量机
- 隐马尔可夫模型
- 基于模糊逻辑的异常检测
一些应用
- 欺诈检测(例如:网络、制造、信用卡欺诈等)
- 入侵检测
- 探伤
- 系统健康监控
- 检测生态系统干扰
- 产品质量异常检测
结论
异常检测是一种发现罕见项目或数据点的技术，这些项目或数据点将与其余数据显著不同。尽管异常检测背后的术语使用了概率论和一些统计学，但有许多技术可以轻松实现异常检测算法。
BigQuery 中数组的介绍
实际用例:字数统计
Joshua Sortino 在 Unsplash 上的照片
我每天都在使用 BigQuery，不得不说它的速度和易用性令人惊叹。
我为什么喜欢 BigQuery？三个原因:
- 它无需服务器，完全受管理。除了我的疑问，我什么都不用想。
- 由于高效的压缩柱状存储，它的速度非常快。
- 它有一个现代化的用户界面:我可以从浏览器做任何事情，没有笨重的安装。
为了举例说明性能，这里有一个 18.5M 行的表:
让我们对它运行一个简单的正则表达式查询，提取所有问题的标题和正文，其中标题提到了以下编程语言之一:python、rstats、sql:
select title, body
from `bigquery-public-data.stackoverflow.posts_questions`
where regexp_contains(title, r"\b(python|rstats|sql)\b")
以下是输出结果:
我不知道你，但 21 秒处理 26.9 GB…我印象深刻。想知道那要花多少钱吗？BigQuery 每处理一 TB 收费 5 美元，因此查询成本为 26.9 / 1000 * 5 = 0.1345 美元。
至此，让我们直接开始使用 BigQuery 中的数组。
在 BigQuery 中使用数组
现在你可能已经猜到了，我们将会统计 StackOverflow 问题中出现的单词。但是在我们开始实际的例子之前，我想先介绍一下在 BigQuery 中使用数组的基础知识。
1.创建数组
在原型开发阶段，创建小的数组会很有用。例如:
select
'Engineering' as role, 'Mike' as name, ['Java', 'C#'] as languages union all select 'Data science' as role, 'Vlad' as name, ['python', 'SQL', 'R'] as languages union all select 'Front-end' as role, 'Guillaume' as name, ['javascript', 'C#', 'HTML', 'CSS'] as languages
这为我们提供了以下输出:
注意数组是如何垂直嵌套在每行中的。
2.展平数组
如果我们想把这个嵌套结构变成一个普通的平面表，我们需要取消嵌套数组:
with T0 as
(select 'Engineering' as role, 'Mike' as name, ['Java', 'C#'] as languages union all select 'Data science' as role, 'Vlad' as name, ['python', 'SQL', 'R'] as languages union all select 'Front-end' as role, 'Guillaume' as name, ['javascript', 'C#', 'HTML', 'CSS'] as languages) SELECT role, name, languages
from T0
CROSS JOIN UNNEST(T0.languages) as languages
CROSS JOIN UNNEST代码执行所谓的关联连接，这意味着它跟踪每个数组与哪一行相关联，这样就不会不必要地执行完全的交叉连接。
我们现在得到了更熟悉的扁平和重复结构:
3.索引数组
假设我们想知道每个程序员最后的语言是什么。BigQuery 中数组的索引有两种方式:基于 0 的索引(python 风格)用OFFSET或者基于 1 的索引(R 风格)用ORDINAL。
我们将以ORDINAL为例，和ARRAY_LENGTH一起检索每个数组的长度。使用与上面相同的 T0 定义:
SELECT role, name, languages[ORDINAL(ARRAY_LENGTH(languages))] as last_language from T0
使用 BigQuery 统计单词
基础知识讲完了，让我们进入一个具体的数组用例。
我们希望有一种方法来统计问题标题中每个单词的频率，如果可能的话，还有一种方法来捕捉单词和问题标签之间的相关性。
将字符串转换成单词数组的一个关键函数是split函数。这里有一个例子:
select title, tags, split(title, ' ') as words
from `bigquery-public-data.stackoverflow.posts_questions` limit 10
有趣的是，我们在上图中看到我们有一串标签。让我们把它也变成一个数组:
select
title,
split(tags, '|') as tags,
split(title, ' ') as words
from `bigquery-public-data.stackoverflow.posts_questions` limit 10
所以每行包含两个数组:
现在我们将交叉连接/取消嵌套两个数组，并过滤掉不感兴趣的单词，即长度小于 2 个字符的单词和一些常见的停用词:
with t0 as (select
id,
title,
split(tags, '|') as tags,
split(title, ' ') as words
from `bigquery-public-data.stackoverflow.posts_questions`) select
id,
tag,
word
from t0
cross join unnest(t0.words) as word
cross join unnest(t0.tags) as tag
where length(word) > 1
and lower(word) not in ('me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', 'your', 'yours', 'yourself', 'yourselves', 'he', 'him', 'his', 'himself', 'she', 'her', 'hers', 'herself', 'it', "it's", 'its', 'itself', 'they', 'them', 'their', 'theirs', 'themselves', 'what', 'which', 'who', 'whom', 'this', 'that', 'these', 'those', 'am', 'is', "isn't", 'are', 'was','were', "aren't", "wasn't", "weren't", 'be', 'been', 'being', 'have', 'has', 'had', 'having', 'do', 'does', 'did', 'doing', 'an', 'the', 'and', 'but', 'if', 'or', 'because', 'as', 'until', 'while', 'of', 'at', 'by', 'for', 'with', 'about', 'against', 'between', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'to', 'from', 'up', 'down', 'in', 'out', 'on', 'off', 'over', 'under', 'again', 'further', 'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all', 'any', 'both', 'each', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very', 'can', "can't", 'will', "won't", 'just', "don't", 'should', "shouldn't", 'now', 'get')
这个查询运行了 24 秒，就这样，我们获得了所有相关标签和单词的笛卡尔积:
现在我们可以很容易地问，对于一个给定的标签，例如python(假设上一步的输出已经保存在表so中，在数据集temp内)，哪些单词最能被表示出来:
select
word,
count(*) as frequency
from `temp.so` where tag='python'
group by word order by frequency desc
这是我们得到的结果:
或者我们可以反过来问什么标签与一个特定的单词相关联，例如flask:
select
tag,
count(*) as frequency
from temp.so
where word = 'flask'
group by tag order by frequency desc
我们得到了:
更进一步
在这里，tf-idf 分析将有助于挑选出 python 相对于其他标记真正特有的内容。虽然超出了本文的范围，但这将是一个很好的副业。
数组构成了 BigQuery 的一个重要特性，我还期待着写一些其他的好东西。在我看来，BigQuery 是最令人印象深刻的大数据分析工具之一！
人工神经网络导论
莫里茨·金德勒在 Unsplash 上拍摄的照片
人工智能，顾名思义，就是通过让机器像人一样思考或行动，让机器具备人工智能。它正在快速前进，深度学习是其中的主要贡献者之一。
深度学习
它是机器学习的一个子领域，处理受大脑结构和功能启发的算法，称为人工神经网络。这些类似于中枢神经系统的结构，其中每个神经元相互连接。
图片来源:geospatialworld.net
英国数学家、乐购俱乐部卡的设计者克莱夫·亨比创造了一个短语**数据是新的石油。**如果数据是新的石油，数据库和仓库被认为是将数据推入互联网的石油钻塔，那么你可以想象深度学习是将原油转化为所有有用产品的炼油厂。我们不会耗尽数据，因为在互联网上做任何事情都会产生数据。
吴恩达幻灯片，版权所有
深度学习的一些应用包括:
- 人脸检测和识别
- 自动驾驶汽车
- 语言翻译
- 虚拟助手
履行
它是使用人工神经网络实现的。让我们详细探讨一下神经网络。
这是一种计算模型，其灵感来自人脑中生物神经网络处理信息的方式。深度神经网络的示例如下所示:
图片来源:sciencedirect.com
输入层
输入层由独立变量的输入组成。这些输入可以从外部源加载，如 web 服务或 CSV 文件。简单来说，这些变量被称为特征，例如，卧室的数量，房子的面积，离城市的距离被认为是你在购买房子时的特征。我们随机初始化接近零但不为零的权重。
砝码
权重在神经网络中起着重要的作用，每个节点/神经元都有一定的权重。神经网络通过权重进行学习，通过调整权重，神经网络决定某些特征是否重要。
隐蔽层
它们位于输入层和输出层之间。在这一层，神经元接受一组加权输入，并在激活函数的帮助下产生一个输出。
**第一步:**在这一步中，输入值和权重相乘，加上偏差，并一起求和。
步骤 2: 在该步骤中，我们应用激活函数，激活函数用于向神经网络引入非线性。这些神经元对输入数据应用不同的变换。深度学习中使用了许多激活函数，其中一些包括 ReLU、阈值函数、Sigmoid 和整流器函数。
**第三步:**在这一步中，它通过所有的隐藏层，然后传递到输出层。
输出层
这是神经网络的最后一层，从隐藏层的最后一个节点接收输入。该层可以是
- 连续(股票价格)
- 二进制(0 或 1)
- 分类(猫、狗或鸭)
神经网络是如何工作的？
有两种方法可以让程序做你想做的事情
- 一种是硬编码，你告诉程序一些特定的规则和你想要的结果。
- 第二个是神经网络，你为程序或算法创建一个设施，使其能够理解自己需要做什么。
神经网络循环有两个阶段，一个是训练阶段，一个是预测阶段。寻找权重和偏差值的过程发生在训练阶段。神经网络处理我们的输入以产生预测的过程属于预测阶段。
我们可以认为神经网络的学习过程是一个传递和返回的迭代过程。传递是信息向前传播的过程，返回是信息向后传播的过程。
图片来源:slideshare.net
在前向传播中，网络暴露给数据。给定一些数据，我们计算输入值与指定权重的点积，然后将所有这些值相加，并将激活函数应用于隐藏层中的结果。
我们应用激活函数将非线性引入到网络中，以便它可以容易地映射数据。该节点充当下一层的输入层。如此重复，直到我们得到最终的输出向量 y ，它被认为是神经网络的预测。
获得的输出值称为预测值。为了了解模型的表现，我们将预测值与实际值进行比较，我们得到的差异称为误差，即成本函数。
损失函数与精度成反比，代价函数越少，精度越高，我们的目标是使损失函数最小。损失函数的公式可以描述如下
价值函数
计算损失函数后，我们将该信息反馈给神经网络，在神经网络中，该信息通过权重返回，权重被更新，这种方法被称为反向传播。这个过程重复几次，以便机器理解数据，并且将根据偏好分配特征的权重，最后，我们将处于通过最小化成本函数来实现我们的预测的阶段。
图片来源:slideshare.net
梯度下降
它是一种优化技术，用于通过最小化成本函数来改进基于神经网络的模型。这个过程发生在反向传播步骤中。它允许我们调整特征的权重以达到全局最小值。
图片来源:quantaneo.com
一些梯度下降算法是
- 批量梯度下降
- 随机梯度下降
- 小批量梯度下降
总结整个概念
- 我们需要初始化随机接近零但不是零的权重。
- 将第一次观察输入到输入层。
- 在这里，前向传播发生在神经元被激活的地方，并且向作为输出层的预测传播。
- 我们使用损失函数比较实际值和预测值，误差值再次反馈给神经网络
- 反向传播发生在误差值被反馈并反向传递的情况下，并且权重被更新以便最小化损失函数，这导致更好的预测。
- 对数据集中的所有观测值重复上述步骤，或者在一批观测值之后进行更新。
- 当整个数据集通过神经网络时，产生一个时期，执行更多的时期。
这就是现在，希望你喜欢阅读关于神经网络。在我的下一篇博客中，我将向你解释卷积神经网络。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
