TowardsDataScience-博客中文翻译-2021-十二-

龙哥盟 / 2024-10-22 / 原文

TowardsDataScience 博客中文翻译 2021（十二）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

让数据科学工具适应慈善事业的社会影响

原文：https://towardsdatascience.com/adapting-data-science-tools-for-social-impact-in-philanthropy-73a8a382c79c?source=collection_archive---------26-----------------------

社区聚焦

洛克菲勒基金会的数据科学

在 Community Spotlight 系列中，TDS 编辑与数据科学社区成员畅谈有助于推动该领域发展的激动人心的计划。今天，我们很高兴与大家分享埃利奥特·冈恩https://medium.com/u/aad1101621dd?source=post_page-----73a8a382c79c--------------------------------*与* 玛德琳·利塞乌斯 ， 首席数据科学家 ，以及 洛克菲勒基金会 的统计和机器学习团队的对话，该慈善组织成立于 1913 年，致力于解决

图片由《走向数据科学》和美国宇航局

洛克菲勒基金会的数据科学是什么样的？对于团队来说，典型的一天是什么样的？

自 1913 年成立以来，数据实际上一直是洛克菲勒基金会实现影响力的核心方法。采取假设和数据驱动的方法在当时被称为“科学慈善”。洛克菲勒基金会统计和机器学习团队最初的设想是利用最新的分析技术来增强我们现有慈善活动的数据驱动方法，同时将数据科学作为一种咨询服务或工具，与货币资源一起提供。

基于这一愿景，该团队现在位于创新团队的大伞下，并且只有大约两年的历史。虽然这听起来可能需要一段时间，但现实是我们仍在弄清楚我们希望慈善事业中的数据科学对基金会来说是什么样的——拥有稳定的资金来源和改善人类福祉的使命，可以在我们的工作中创造一个令人难以置信的特权空间来测试、失败和想象。

今天，该团队由三名全职数据科学家以及一组支持我们的顾问组成；从支持基金会的数据相关查询到领导与我们的计划工作一致的独立项目，我们无所不为。

因为我们的工作变化很大，所以没有典型的一天——我花了几天时间与顾问一起为一个计划的项目启动准备材料，但也有几天没有一次会议来调试我的模型。目前，我们的技术堆栈包括 Domino 以及用于利基工作的特定平台——例如，我使用 Google Earth Engine 主要用于我的遥感工作。

团队如何选择并着手项目？

我们通过两个主要的途径来确定项目:通过内部计划的提议或请求，或者通过我们自己团队的想法。在内部与值得信赖的合作伙伴讨论潜在的项目后，如果项目获得批准，我们将根据预计的时间表和预算向前推进。从那里开始，每个项目都非常不同。

对于我们参与或被要求帮助的项目，我们通常会在我们知道工作是一个合理的好主意的阶段介入，并立即传递结果——这些项目甚至可能需要不到一天的时间。

对于我们自己设想和开发的项目，推介、开发和再开发可能需要几个月到一年的时间。由于与团队相关的每个人都扮演着许多角色，作为一个服务于如此大的组织的如此小的团队，这些工作流和时间表包括许多不相关的工作和计算。

图片由洛克菲勒基金会提供

您能告诉我们洛克斐勒基金会不同种类的数据科学计划或项目吗？

我为我最近发表的关于走向数据科学的手工收割作物绘图项目感到非常自豪。去年春天，随着新冠肺炎抵达美国，农业工人面临的障碍越来越多，在一定程度上，未来的劳动力短缺加剧了。我启动了手工收割作物测绘项目，试图在 10 米乘 10 米的地块上检测加州中央谷的每一种手工收割作物，试图跟踪生产者可能如何以及在哪里由于劳动力短缺和其他压力改变他们的种植决定。

洛克菲勒基金会对获得保护性食品——有助于预防与饮食有关的疾病的食品——想了很多，了解农产品生产的变化对这一对话至关重要。最大的障碍和机会空间是还没有任何围绕遥感的基础平台或政策，我有机会塑造我们的遥感方法、我们在遥感工作中的价值观、优先事项和目标，并领导我们的技术堆栈开发。除了所有这些组织开发工作的挑战和评估之外，令人难以置信的是看到新的、更简单的方法成功地完成了一项未解决的任务。很少有组织能够为制作手工收割作物制图模型所需的大量实验创造环境，能够实现我们最初的愿景和希望是一种殊荣。

我们团队的其他项目包括使用卫星图像绘制纽约的经济机会区域，创建指数以捕捉美国城市福祉的各种挑战(作为单独的博客提交给 TDS)，以及支持预测城市含铅管道位置的模型。

车队面临了哪些挑战？

统计和机器学习团队面临的最大挑战之一是，在我们创建框架和工作方法时，没有应用统计或数据科学团队的模型可供我们借鉴。从公共、私人和学术领域的最佳部分中汲取精华来创造一种思考和从事数据科学的新方式是非常令人兴奋的，但这需要时间和意愿。

其次，我们在数据科学对社会影响的问题上进行了大量思考和工作——数据科学的大多数框架都以利润为导向，但“社会公益”并没有如此明确的定义或衡量，除非通过代理。相关的挑战(和机遇)是，并非数据科学中开发的所有方法都适用于我们有兴趣探索的社会问题，我们只能研究代理数据集的可能性和想象应用统计的新方法。在这些方面，我们的挑战经常转向哲学领域和技术领域。

是什么让你决定写关于 基于卫星的测绘 项目？你希望读者从中吸取什么？

统计和机器学习团队考虑影响我们技术工作的方式之一是如何接触尽可能多的相关人员。与学术界不同，我们不需要专门(或根本不)通过期刊发表文章，这意味着我们可以更快、更非正式地完成工作——允许在项目发生时而不是几年后对其进行积极的讨论，并希望将有用的工具交到现在可以使用它们的人手中。

在发布一篇名为《走向数据科学》的博客时，我们看到了一条接触技术同行并开始对话的途径——当我们探索数据科学在慈善事业中的作用时，就我们的方法和工作进行双向交流至关重要。因此，撰写和交流我们的工作是我们如何以及为什么做我们所做的事情的核心组成部分。在手工收割的作物制图工作中，一直很明显的是，这项工作令人兴奋的不仅是对劳动力、农业、土地使用等问题的可能应用，而且是对所使用的特定技术方法的可能应用——数据科学是这一讨论的自然归宿。

在我的工作和为《走向数据科学》准备一篇文章的过程中，我努力解决的一个问题是，如何确保在没有学术期刊框架的情况下，工作是勤奋的，并且经过了非正式的同行评审——建立一种透明和严谨的方法是我认为对慈善事业中数据科学的未来至关重要的事情。总的来说，我希望读者能被激发参与、学习和挑战我的作品。

您喜欢哪种数据科学写作，您希望更多地了解哪方面的内容？

出于数据科学和机器学习的目的，我们的团队喜欢接触各种各样的写作和非写作来源。我们的团队广泛关注并投资于放大数据科学和机器学习中以前未被充分代表和压制的声音的方法，我们总是希望看到更多这样的观点和意见。我们喜欢阅读关于失败的内容，并希望在通往成功的道路上有更多关于失败和失望的对话。最后，我们相信在我们的团队中，爱好者并不总是更好，我们喜欢学习如何巧妙地和优雅地使用“简单”的方法来解决挑战。

你对未来几年的数据科学社区有什么希望？作为数据科学非营利领域的领导者，您认为洛克菲勒基金会扮演着什么样的角色？

我对世界各地的数据科学和机器学习社区抱有很多希望。

第一个也是最大的希望是围绕“数据科学”作为一个领域的新生事物，并呼吁“数据驱动”的工作:我看到在 DS + ML 中工作的人们有很大的空间来围绕一个共享的身份和一套原则联合起来。在各个行业中，“数据科学”一词被用来指数据可视化、应用统计学、一些软件工程等等——在未来，我希望我们可以帮助定义，然后对外分享什么是数据科学的一部分，什么不是。

此外，善意的同事有时会要求该领域的人员“证明”或“展示”现有数据中不存在的关系——我希望随着时间的推移，我们应该和不应该对什么类型的场景做出反应将会有社区标准。

更有抱负的是，我对盈利性公司推动的人工智能进步可以适应和重新用于社会问题的方式充满希望。谈到洛克菲勒基金会在这些未来中的作用，目前还很难说。我们对一些正在实现有意义影响的项目感到兴奋，但仍然处于学习和倾听模式，并(仍然)思考如何在慈善事业中领导数据科学和机器学习，更不用说在世界上了。

还应注意的是，我们的应用数据科学商店隶属于大创新团队，该团队为利用数据科学产生社会影响提供资金。我们资助的一些合作伙伴包括 Atlas AI ，它推进了人工智能方法，以开发对整个新兴市场的人口特征、经济条件、农业生产率和基础设施接入的估计，以及data.org，这是一个利用数据力量应对社会最大挑战的平台。

想在洛克菲勒基金会了解更多关于数据科学的知识吗？在 LinkedIn 和 Twitter 上关注他们。这里有其他文章分享了利用机器学习造福社会的项目案例研究。

  • "使用卫星绘制纽约市的经济机会图"(2020 年 5 月，TDS): Madeline Lisaius 分享了该团队如何使用卫星图像来确定纽约市的经济机会区。
  • "一种更易于使用和复制的方法，用于基于卫星对加利福尼亚手收作物进行绘图"(2021 年 8 月，TDS): Madeline Lisaius 分享了该团队如何为手收作物创建一种易于使用和复制的早期绘图工具。
  • "消除铅污染饮用水的竞赛"(2021 年 5 月，洛克菲勒基金会):数据科学团队与 BlueConduit 的制图算法合作建立了一个铅污染仪表板，以准确预测铅管道的位置，这有助于铅去除工作。

使项目管理方法适应数据科学

原文：https://towardsdatascience.com/adapting-project-management-methodologies-to-data-science-a710ac9872ea?source=collection_archive---------10-----------------------

行业笔记

如何有效地处理数据驱动的项目并最大化项目成果的价值

近年来，数据科学家在各种企业中脱颖而出。数据科学家对技术和非技术人才的需求都很高。因此，数据从业者必须继续提高他们的技能，以保持相关性。目前，许多公司认识到数据科学家带来的价值。另一方面，大多数企业似乎对数据科学以及如何支持数据科学有不正确的先入之见。一些人认为，因为数据科学家利用 R 或 Python 编程语言，所以适用于软件开发的相同方法也适用于模型构建。事实并非如此，因为模型不同，应用不正确的方法可能会导致重大问题。

管理问题需要决策。这个过程还可以得到机器学习和数据挖掘技术的支持，基于对项目数据的分析和选择，做出正确的决策，解决关键的项目问题。在当今时代，数据科学家必须适应力强，并准备好以新的方式应对挑战。虽然项目管理和沟通技能对数据科学家来说至关重要，但了解项目管理和数据科学如何协同工作也很重要。软件工程有一个能力成熟度模型(CMM ),用于创建和改进组织的软件开发过程。该模型包括一个五级进化路径。CMM 类似于由国际标准化组织定义的 ISO 9001 标准。

CMM 软件过程的五个成熟度等级

初级:这个阶段的流程杂乱无章。成功取决于个人的努力，是不可重复的。

可重复级别:这是定义基本项目管理技术的地方，成功是可以重复的。

定义的层次:在这个阶段，组织已经通过更加关注标准化、文档化和集成来定义它的标准软件过程。

管理层次:组织使用数据分析和收集来控制其过程。

优化级别:这是通过对现有流程的反馈跟踪来频繁改进流程以满足组织需求的阶段。

DS 管理中的临时流程

当没有标准方法来管理数据科学项目时，团队通常会采用没有组织性、不可重复和不可持续的临时实践。因此，这些团队经常经历低项目成熟度，没有不间断的改进、频繁的反馈和定义的过程。

那么，Ad Hoc 对数据科学有用吗？

嗯，临时流程有几个优点和缺点。首先，它们为用户提供了决定如何处理出现的每一个问题的自由。当团队拥有由个人和小团队管理的一次性项目时，临时模式可能会更好。此外，专注于给定的任务，而不关心对组织的其他项目领域的影响，这使您可以在几乎没有管理工作的情况下处理项目。

除此之外，数据科学每天都在发展，需要团队和组织不断发展以反映当前的变化。因此，过度依赖临时实践是不正确的，因为这可能会给数据科学团队和项目带来许多问题。虽然采用成熟的项目管理方法不会完全解决项目管理的挑战，但它会减少众多的问题并增加成功的几率。除了由小团队实现的简单的小项目之外，ad hoc 不是数据科学项目的最佳选择。

也就是说，让我们回顾一下可以在数据科学领域采用的成熟软件项目管理方法。

Crisp-DM 方法论

CRISP-DM 完全是跨行业的数据挖掘过程。这种方法有一种结构化的方式来组织数据挖掘项目。这是一种强大且经过充分验证的方法。当数据科学家强调需要适用于数据分析和挖掘的标准方法和程序时，他们创建了 CRISP-DM 方法。CRISP-DM 包含六个独特的阶段。CRISP-DM 的阶段包括数据理解、业务理解、评估、准备、建模和部署。名义上，这些过程是按顺序进行的。然而，这个过程总是迭代的。这意味着模型是被设计来被后来的知识增强的。下图展示了 CRISP-DM 中涉及的流程。让我们从数据分析的角度来回顾一下这个过程。

作者图片

CRISP-DM in Business

大多数企业，当他们想了解他们的顾客、目标市场和客户时。他们总会有一组数据。例如，他们可能有一个联系人列表，或者是购买、完成表单的人，或者是在线填写表单的人。因此，CRISP-DM 的第一步是理解业务并突出组织的具体目标。了解一个企业需要识别该企业希望解决的挑战。一旦理解了目标，识别在数据中发现什么的过程就开始了。根据信息源的不同，可能会有关于客户兴趣的信息。所有这些数据对未来的活动都很有用。此后，对数据进行准备和分析，使其变得有用。数据准备过程非常庞大，可能会占用项目时间的 70-80%。数据准备过程的一部分需要识别和创建新的数据点，这些数据点可以从现有的条目中计算出来。随后，在数据准备阶段提取的信息用于建立不同的行为模型。在机器学习工具的帮助下，使用这些数据执行了大量测试。

CRISP-DM 详情

作者图片

CRISP-DM 任务以粗体显示，结果以斜体显示

CRISP-DM 和数据科学项目管理

将 CRISP-DM 的松散实现与基于敏捷的实践相集成的数据科学团队肯定会取得最好的结果。即使团队没有完全应用 CRISP-DM 的所有方法，也会获得更好的结果。CRISP-DM 提供了一个标准框架，用于:

  • 经验文档
  • 指导方针
  • CRISP-DM 方法支持最佳实践并支持项目复制。
  • CRISP-DM 可用于任何领域的数据科学项目。
  • CRISP-DM 是数据挖掘的事实上的行业标准过程模型。因此，数据科学家了解模型的各个步骤至关重要。

瀑布方法

作者图片

温斯顿·罗伊斯被认为是 1970 年发现瀑布模型的人。这是最古老的软件工程方法之一。瀑布模型代表了一个顺序模型，它被划分为预定义的阶段。瀑布方法学获得了它的名字“瀑布模型”,因为每个阶段都建立了一个定义明确的输出，并作为输入传递给下一个阶段。一旦产品进入下一阶段，就无法恢复。因此，我们可以说整个软件开发过程就像一系列小瀑布。瀑布模型将软件开发的整个过程分为不同的阶段。然后依次执行这些阶段。每个阶段都继续加工，直到获得该阶段的最终产品，然后再切换到下一阶段。

什么时候应该使用瀑布模型？

通常，您可能想知道何时是使用瀑布模型的合适时机。当客户能够一次提供他所有的需求，并且这些需求必须稳定时，就必须采用瀑布方法。此外，开发团队应该能够在软件开发开始时解释所有的客户需求。然而，任何人都很难一下子列出所有的要求。因为一个更严格的瀑布模型不允许在一个阶段完成后恢复，所以引入了一个新的瀑布模型变体来适应反馈。这被称为“相邻阶段之间的反馈”。

作者图片

该模型通过接受当前阶段的反馈，允许在相邻阶段之间纠正问题。例如，如果在编码过程中的测试阶段出现错误，可以通过返回编码阶段来修复。

瀑布方法适合数据科学项目管理吗？

根据 Pressman 和 Maxim (2015)，瀑布方法不能用于数据科学项目管理。首先，在所有需求都已陈述并且不可能改变的场景中，该方法是完美的。数据科学项目的情况并非如此，因为数据科学领域有大量的实验、需求修改，而且技术仍然是新颖的。瀑布模型被设计用于制造和建筑领域，其中项目的渐进运动是连续的。这解释了为什么模型的工作阶段没有重叠。在你开始给车身上螺栓之前，你需要完成汽车的框架。然而，瀑布模型的结构良好的状态对于数据科学项目的某些阶段来说是完美的，例如规划、资源管理、范围和验证。

敏捷方法论

敏捷方法基于敏捷宣言。该宣言包括 4 个基本价值观和 12 个关键原则。宣言的焦点是通过建立一个促进迭代开发、变更识别和团队协作的可测量的结构来揭示构建软件的最佳方法。敏捷方法的最佳价值在于它允许团队以更高的质量和可预测性提供快速的价值。敏捷过程提供了一个训练有素的项目管理实践，它支持频繁的适应、检查、自组织，以及一组工程实践，它们提供了高质量软件需求的快速交付。

敏捷宣言的 4 个价值观

1。合同谈判中的客户协作。

基于敏捷宣言，持续开发是很重要的。有必要与客户建立一个反馈回路，这样才能确保产品能与他们合作。

2。工具和过程之上的个体和交互。

软件团队中正确的个人群体的存在是至关重要的。此外，这些个人和团队成员之间的互动在解决手头的问题中扮演着重要的角色。

3。响应变化而不是坚持计划。

敏捷宣言建议软件团队应该有能力在任何需要的时候响应变化。

4。综合文档之上的工作软件。

敏捷宣言将工作软件置于文档之上。

敏捷方法中的 12 个主要原则

  1. 使用重要软件的早期和持续交付来满足客户。
  2. 接受不同的需求，包括开发后期的需求。
  3. 从几周到几个月的时间内定期展示功能软件。
  4. 开发人员和业务人员必须在整个项目中每天协作。
  5. 围绕有灵感的个人建立项目。给他们提供他们想要的支持和环境。
  6. 在开发团队中传递信息的最有效的方法。
  7. 功能软件是进步的主要决定因素。
  8. 敏捷过程强调可持续发展。开发人员、用户和赞助商应该保持同步。
  9. 对技术专业和适当设计的持续关注提高了敏捷性。
  10. 运用简单性来最大化未完成的工作量。
  11. 自组织团队提供了最好的需求、设计和架构。
  12. 在间歇期，团队应该反思如何变得有效并调整行为。

什么时候应该使用敏捷方法？

敏捷方法的特性，如适应性、连续交付、迭代和短时间框架，使其成为正在进行的项目和那些从一开始就不知道所有需求的项目的完美项目管理方法。换句话说，没有明确时间表、可用资源和约束的项目是敏捷方法的最佳选择。现在很多软件产品都使用敏捷。它是标准，并且已经扩展到用于营销、设计和商业。

数据科学有可能从敏捷方法论中获益吗？

敏捷非常适合数据科学项目管理。数据科学过程需要高度的不确定性。出于这个原因，敏捷方法与数据科学携手合作，因为它允许非线性过程成功，而不是强迫它们按顺序进行。

敏捷数据科学的优势

快速交付客户价值——通过交付增量产品特性，如数据端口、最小可行和模型，用户在项目结束前获得价值。

相关的可交付成果——在开发之前预先定义需求，原则很可能满足当前的需求。

更好的沟通。敏捷强调协作、清晰的沟通，关注个人。因此，当数据科学团队规模扩大并变得多样化时，利益相关方和团队内部有效沟通的价值也会增加。

敏捷让数据科学家能够试验并了解什么可行，什么不可行。实验始于假设的建立和变量的确定。接下来是数据收集和分析。

虽然敏捷是作为软件开发的方法论而创建的，但它一直在不断发展，以满足许多团队类型的需求。然而，随着敏捷技术的不断发展，新的敏捷应用程序的发布，敏捷框架也在不断发展。

Scrum

Scrum 是一个流行的敏捷框架，非常适合团队。根据 Scrum 指南，Scrum 是一个框架，在这个框架中，人们可以处理适应性挑战，同时创造性地交付具有最大价值的产品。在某些情况下，scrum 可能会令人困惑，因为团队会混合使用看板等其他框架的几个方面。scrum 的主要目标是通过透明的沟通、持续的进步和集体责任来满足客户的需求。

Scrum 是在被称为 sprints 的短周期的 min 块中实现的。冲刺阶段从 2 周到 4 周不等。每个 sprint 都是一个交付全部结果的实体。该过程由起点和完成项目计划的需求组成。

数据科学有可能从 Scrum 的方法论中获益吗？

Scrum 允许团队协作并提供增值。然而，这个过程并不容易。其中最大的挑战是定义在数据科学环境中构成挑战的定长冲刺。例如，不容易估计一项任务将花费的次数。

数据科学团队更喜欢不同持续时间的冲刺，但在使用 Scrum 时这是不可能的。因为这些问题，一些团队更喜欢应用数据驱动的 Scrum(DDS)。DDS 有 Scrum 的一些主要概念，但是它也解决了使用 Scrum 的缺点。scrum 的主要优势是它以客户/产品为中心，能够保持一致性，通过实验获得信息，以及团队成员的明确方向。Scum 很难掌握，对团队成员来说是相当大的会议开销，并且在给定的时间内满足需求对团队来说是具有挑战性的。

看板

看板是一种项目管理方法，最适合任何规模的公司。该工具允许您获得需要完成或完成的任务的可视化概述。它由数字或物理板组成，有三列(进行中、已完成、待完成)。然后，任务被概括为故事卡。每张牌都会从左到右抽出，直到抽完为止。看板系统首先被丰田工厂应用于平衡实际生产中的材料供应。

作者图片

使用看板进行数据科学项目管理可以吗？

对于许多类型的项目来说，看板已经被证明是一种很好的方法，从具有多层复杂性的大型项目到可以由一两个人快速完成的小型项目。看板提供了数据科学家所需要的灵活性，他们希望能够灵活地执行他们的任务，而不会有固定的截止日期。根据 Saltz、Shamshurin 和 Crowston (2017)的说法，看板提供了一种比数据科学团队所拥有的更好的结构。

看板最佳实践

在项目中使用看板提供了可视化工作流程的能力。因此，在遇到瓶颈、过度工作的步骤和其他障碍的情况下，它们很容易被识别。该团队还应该团结起来，确定以最佳方式交付最关键工作的方法。

看板的优势

它非常直观，因此在向利益相关者和团队成员传达正在进行的工作时非常有效。

它非常灵活。它可以一次提取一个工作项目，不像 Scrum 的批处理周期。

提供更好的协调。灵活的结构、简单性、可视化和轻量级的特性使其有利于团队合作。

减少正在进行的工作。

为流程的每一步提供清晰的规则。

看板的缺点

缺少最后期限。没有截止日期可能会使团队在特定的任务上工作很长时间。

看板列定义。为数据科学看板定义列是一项挑战。

客户互动未定义。因此，如果没有 sprint 评审的结构化节奏，客户可能不会对这个过程感兴趣。

数据驱动项目管理的研发

R&D 是指企业为开发和引进新产品和服务，以及改进现有产品和服务而从事的活动。R&D 不同于公司的大部分经营活动。通常情况下，研究和开发并不是抱着立即获利的希望进行的。相反，它旨在增加公司的长期盈利能力。随着发现和产品的开发，R&D 可能会产生专利、版权和商标。

使用研发方法进行数据驱动的项目管理有效吗？

是啊！

数据科学包括几个步骤，从 EDA 到模型创建，每个阶段都需要自己的一组实验。每个阶段都是相互联系和反复的。R&D 是数据驱动计划的最佳技术，因为它允许在创造力和产生新事物方面有很大的灵活性。R&D 带领我们走到了数据科学领域的今天。组织面临着各种数据驱动的问题，使用正常的程序和实践很难解决这些问题。

结论

当我们接近这篇文章的结尾时，用不同的项目管理方法以及将它们集成到信息科学中的方式来启发我们自己是很重要的。通过这样做，我们将能够发现和创造一种有效的技术。有许多项目管理工具用于维护和报告项目进展。我们不仅可以使用这些工具来通知高级管理层，还可以帮助利益相关者编写假设和项目依赖关系。项目的成功取决于许多因素。因此，在项目生命周期的所有阶段开发和分析系统主要性能指标是非常重要的。

这里有一些额外的资源可以帮助你了解数据驱动的项目管理。

参考列表

瀑布模型

https://binaryterms.com/waterfall-process-model.html

https://www . lucid chart . com/blog/pros-and-cons-of-waterfall-methodology

https://corporatefinanceinstitute . com/resources/knowledge/other/capability-maturity-model-CMM/

临时

https://www.datascience-pm.com/tag/ad-hoc/

敏捷

https://zenkit.com/en/blog/agile-methodology-an-overview/

https://project management academy . net/agile-methodology-training

https://www.marketing91.com/agile-methodology/

https://www.digite.com/agile/scrum-methodology/

看板

【https://www.paymoapp.com/blog/what-is-kanban/

https://big data-made simple . com/why-apply-kanban-principles-big-data-projects/

https://towards data science . com/the-3-most-important-project-management-methods-in-data-science-df7e 14955 d37

其他来源

https://www.quickstart.com/blog/data-science-project-management-methodologies/

https://neptune.ai /

https://www . dominodatalab . com/resources/field-guide/managing-data-science-projects/

https://www.datascience-pm.com/

https://xperra.com/blog/crispy.html

https://www.datascience-pm.com/crisp-dm-2/

https://www . agile alliance . org/agile 101/12-敏捷背后的原则-宣言/

https://www.productboard.com/glossary/agile-values/

https://www . mygreatlearning . com/blog/why-using-crisp-DM-will-make-you-a-better-data-scientist/

为离散动作空间调整软演员评论家

原文：https://towardsdatascience.com/adapting-soft-actor-critic-for-discrete-action-spaces-a20614d4a50a?source=collection_archive---------5-----------------------

如何通过仅改变两个方程将流行的算法应用于新问题

自 2018 年推出以来，软演员评论家(SAC)已经成为深度强化学习(DRL)最受欢迎的算法之一。你可以在网上找到很多很棒的解释和教程。但是，它们中的大多数都假定了一个连续的动作空间。在这篇文章中，我将解释和实现在具有离散动作的环境中使用 SAC 的必要调整，这些调整是在 2019 年的一篇论文中得出的。

这篇文章假设你已经熟悉 DRL 的基本原理。SAC 算法的知识会有所帮助，但不是必需的。要了解 SAC，你可以阅读 Berkeley 的原始论文或 OpenAI 的 SpinningUp 的解释(这也是了解 DRL 总体情况的极好资源)。

在第 1 节中，我快速总结了 SAC 的关键要素。为此，我将引入两个核心成本函数(和一个可选的第三个)，它们需要最小化以找到最佳的模型参数。连续和离散设置的 SAC 之间的主要区别在于这些成本函数的定义。我将在第 2 节解释它们需要如何改变。最后，在第 3 节和第 4 节中，我将展示如何用 Python 实现和评估调整后的算法。

1.SAC 概述

顾名思义，SAC 是一种演员-评论家方法。这是政策优化和 Q 学习的混合方法。一方面，它使用基于贝尔曼方程的成本函数来训练 Q 函数网络(“评论家”)。同时，它通过最小化成本函数来优化策略(“参与者”)，以最大化预期回报。你可以在这里阅读更多关于演员-评论家方法的内容。

SAC 的成功建立在先前算法引入的许多想法之上，例如使用双 Q 学习和目标网络。然而，SAC 的主要创新是熵正则化强化学习的使用。为了节省时间，在这一节中我将只解释熵正则化，因为它是使 SAC 适应离散动作空间所需要理解的基本组件。

1.1 熵正则化

熵是信息论中的一个术语，用来量化随机变量结果的不确定性。本质上，随机变量的熵越高，其结果越不可预测，也越随机。例如，一枚正面和反面都有 50%机会的公平硬币将具有最大熵。另一方面，如果它有 100%的机会落在一边，熵将是 0。概率分布 P 的熵的形式定义如下:

图 1:分布 P 的熵

熵正则化 RL 使用熵作为策略随机性的度量。这样的措施是有用的，因为它有助于我们在训练中鼓励随机性。这种随机性被认为可以增加探索性并有助于避免局部最优。

在下一节中，我将介绍我们如何优化函数来找到熵正则化策略，以及 Q-network 在没有熵正则化的情况下的外观。除了一个小细节，这些函数看起来与其他演员-评论家方法(如 DDPG)相同。唯一的区别是，大多数其他行动者批评方法通过向确定性策略的结果添加噪声来制造随机性。另一方面，SAC 使用非确定性策略，因此我们可以使用熵来量化策略的随机性。在接下来的部分中，我将解释 SAC 中使用的成本函数的修改版本如何考虑策略的熵。

1.2 无熵正则化的关键方程

对于与离散动作空间一起工作的 SAC 算法，我们需要调整两个关键等式:

  • 策略π的参数θ的(行动者)成本函数
  • Q-函数 Q 的参数φ的(临界)成本函数

它们分别来自最优策略和 Q 函数的定义。我将首先讨论策略，然后讨论 Q 函数参数。

从形式上来说，通过常规的行动者-批评家方法，我们希望找到一种政策，使贴现回报随着时间的推移而最大化:

图 2:演员在演员-评论家方法中解决的优化问题

这里π是策略，τ表示由策略引起的状态和动作的轨迹，γ是贴现率，R(s，a，s’)给出使用动作 a 从 s 到 s’的过渡的奖励。

我们使用参数为θ的函数逼近器来表示我们的策略。我们的目标是找到产生最接近图 2 的解决方案的策略的那些参数。为此，我们希望最大化我们对参数化政策预期收益的估计。由于动作空间是连续的，我们不能直接计算期望值。因此，我们使用基于受访州所采取行动的蒙特卡罗估计。这个估计给出了我们的第一个成本函数(我们在期望值前面加了一个负号，因为我们在最小化成本函数)。

成本函数 1:演员参数

图 critic 参数的成本函数

其中 D 是重放缓冲器，可以从该重放缓冲器中采样先前访问的状态，Q 是我们的具有参数φ的 Q 网络。

获取用于计算预期回报的动作有点复杂。在 SAC 中，策略是不确定的，因此我们必须从策略参数θ和状态 s 引起的分布中得出一个动作。策略网络输出一个均值μ(θ，s)和一个方差σ(θ，s)，因此动作分布如下:

图 3b:根据策略参数化的动作分布

然而，如果我们产生这样的动作，那么我们就不能再求 Q 值对θ的导数了。因此，我们不能使用基于梯度的方法来优化θ。因此，我们使用重新参数化技巧:

图 3c

这一项遵循与图 3b 所示相同的分布，但我们可以对θ求导。

正如我们前面提到的，我们同时优化我们的策略和 Q 函数的近似值。最佳 Q 函数由贝尔曼方程描述:

图 4:最佳 Q 函数的贝尔曼方程

其中 P 是通过采取行动 a 可以从状态 s 到达的状态的分布。

我们用一组参数φ来参数化 Q 函数。我们通过最小化二次成本函数 L 找到逼近最优 Q 函数的φ:

成本函数 2:评论家参数

图 5:参与者参数的成本函数

其中 d=1 当且仅当 s’是轨迹的终点，否则为 0。同样，我们使用重新参数化技巧来生成左边术语中的动作。

请注意，在计算 Q 函数的损失时，我们不需要对该动作使用重新参数化技巧，因为这一项将根据φ而不是θ进行微分。

1.3 SAC 的熵正则化关键方程

为了对图 2 中的策略等式进行熵正则化，我们使用在一个州收到的奖励和该州的策略熵的加权和:

图 6:最优策略的熵正则化定义

π(.|s)表示由状态 s 中的策略给出的动作的分布的 pdf

α > 0 称为温度，它决定了获得的回报和政策随机性之间的权衡。它可以设置为一个恒定的超参数，也可以在训练期间进行优化。

预期回报将随着熵的减少而增加，反之亦然。这将加速训练后期的学习，并有助于避免局部最优。

就像之前一样，我们想找到使预期收益最优化的θ。为了在熵正则化设置中这样做，我们可以简单地将熵的估计添加到我们的预期回报的估计中:

熵正则化演员成本函数

图 7:熵正则化的 critic 成本函数

我们如何将贝尔曼方程用于我们的 Q 函数类似于我们在最优策略的定义中所看到的:

图 8:最佳 Q 函数的熵正则化贝尔曼方程

根据这个定义，我们可以导出下面的二次成本函数来优化我们的 Q 网络:

熵正则化的批评家成本函数

图 9:熵正则化演员成本函数

使用:

图 9b

其中右边括号中的术语称为软状态值。请注意，这个术语只是对从当前策略中提取的操作的估计。

1.4 用于学习温度参数的成本函数

如前所述，温度α可以在训练期间进行优化。这是可选的，因为α可以像超参数一样简单地设置或随时间减少。但是，如果您想要优化温度，那么您将使用一个成本函数，当在连续和离散设置之间切换时，该函数也需要调整。这个成本函数的推导超出了本文的范围，可以在这篇论文中找到。就我们的目的而言，知道通过最小化以下成本函数可以找到最佳温度是非常重要的:

温度成本函数

图 10:温度参数的成本函数

右边的项是给出目标熵的超参数。

2.转移到离散设置

既然我们已经修改了 SAC 的重要元素，那么是时候调整它们来与离散的操作一起工作了。幸运的是，这只需要我们改变两三个方程，这取决于我们是否想要优化温度参数。无论哪种方式，我们都需要改变我们的两个关键方程，以分别找到策略和 Q 函数的参数。

为了理解如何改变关键方程，让我们想想当我们进入离散设置时会发生什么变化。最重要的是，π(。|s)现在是质量函数，而不是密度函数。记住这一变化，图 6 和图 8 中给出的最优策略和 Q 函数的定义仍然有效。但是，我们需要做两处修改才能计算它们:

  1. 到目前为止，我们假设 Q 函数将状态和动作作为输入并输出 Q 值。现在我们可以让它简单地获取一个状态，并映射到一个包含每个动作的 Q 值的向量。以前，这是不可能的，因为我们有无限多的可能行动，但做出这种改变将在以后派上用场。
  2. 在连续设置中，π由参数θ表示，这些参数用于计算动作空间的每个特征的均值和方差。因此，我们的参数化π将状态映射到具有 2|A|个元素的实数向量，其中|A|是动作空间的维度。在离散设置中，每个动作的简单概率向量就足够了。因此，π将状态映射到具有|A|元素的概率向量。

综上所述，我们将定义修改如下:

图 11:当我们从连续行动转向离散行动时，政策和 Q 函数的类型是如何变化的

那么，这些变化对我们如何计算政策参数意味着什么呢？回想一下，在图 7 中，我们必须从策略分布中抽取行动样本，以估计预期回报。当使用离散动作和我们的π和 Q 的新定义时，我们可以精确地计算动作的期望值。只有对各州的期望仍然是一种估计:

离散行动的行动者成本函数

图 11:离散动作的参与者成本函数

对 Q 函数的等式所做的改变是相似的:

离散行动的批评家成本函数

对于行动者成本函数，我们只改变软状态值。和以前一样，我们不再需要使用估算，而是可以直接计算。

图 12:离散动作的最佳 Q 函数参数

随着

对于最佳温度:

离散行动的适度成本函数

图 13:离散动作的温度成本函数

3.Python 实现

在本节中，我将向您展示如何使用 PyTorch 实现离散 SAC，并在一个 OpenAI Gym 环境中对其进行评估。你可以在这里找到包含所有代码的库。我不会查看整个代码，因为很多代码与本文没有直接关系，我只解释最重要的部分。

正如我之前提到的，SAC 使用了比熵正则化更多的技巧。有两种方法可以增加 critic 网络学习的稳定性:使用目标网络和双 Q 学习。这两者都不是本文的重点，但是我将简要地总结一下，因为它们是实现算法所需要的。简而言之，目标网络背后的想法是，当计算 y(r，s '，d)(目标)时，我们使用一个单独的批评网络。最初，该网络的参数与香草评论家网络的参数相同。然而，目标网络更新得更慢，要么通过每 N 个训练步骤仅复制 critic 的参数，要么通过在每个训练步骤使用软更新(有时称为 Polyak 更新)。这是为了增加稳定性，因为 critic 网络中无用的变化需要更长的时间才能渗透到目标值。第二个技巧，双 Q 学习，受到基于梯度的优化往往导致过大 Q 值的启发。因此，训练两个 Q 网络并使用两个网络产生的较小值。这意味着在我们的算法中总共有四个 Q-网络:两个用于批评家，两个用于目标网络。

3.1 代理初始化

我的实现的主类叫做 Discrete_SAC_Agent 。它包含目标和关键网络，以及使用转换数据训练网络和基于当前环境状态采取行动的功能。

下面可以看到类 Discrete_SAC_Agent 的构造器。传递给该函数的环境被假定遵循 OpenAI Gym 接口，并且具有离散的状态空间。构造器使用了一个类网络和 ReplayBuffer ，前者是一个 3 层的前馈神经网络，二者的实现都可以在 repo 中找到。

在第 22 行，我们调用函数soft _ update _ target _ networks，该函数执行目标网络向批评网络的软更新。它采用参数τ作为插值因子。通过将其设置为 1，我们将 critic 参数复制到 target 参数中。第 43 行设置了目标熵超参数，它基于论文中给出的启发。大多数情况下，剩下的函数是用于初始化神经网络和优化器的基本 PyTorch 代码。构造函数的其余部分是用于初始化神经网络和优化器的基本 PyTorch 代码。

Discrete_SAC_Agent 类的构造函数

软更新目标网络的实现如下:

软更新功能，用于在评论家的方向上缓慢改变目标参数

3.2 学习和损失

在每个训练步骤之后，使用 train_on_transition 函数将转换(s，a，s’，r，d)存储在代理的重放缓冲区中。随后，如果存储了足够多的转换，将从缓冲器中采样一批转换，根据转换的损失对概率进行加权。

存储转换和训练代理网络的功能

损失函数的实现如下所示:

演员、评论家和温度参数的损失函数

3.3 选择行动

给定代理的当前状态，我们可以通过使用函数 get_next_action 获得下一个动作。需要一个标志评估 _ 剧集来判断当前剧集是评估还是训练剧集。行动者网络将根据当前状态产生每个行动的概率。根据评估 _ 情节的值，要么选择最可能的动作，要么从演员网络给出的分布中抽取动作。

用于根据状态获取代理的下一步操作的函数

4.估价

为了评估我的实现，我选择了 OpenAI gym 的 CartPole-v1 环境。在这个环境中，代理的目标是通过向左或向右移动来平衡可移动推车顶部的杆子。每过一个时间步，杆没有倒下，代理人得到 1 的奖励。由于有两个离散的动作，我们的 SAC 离散版本适用于这个问题。

CartPole-v1 是一个具有离散动作空间的环境的简单例子。代理人可以向左或向右移动一辆手推车(黑色)来平衡一根杆子(棕色)，每走一步就获得 1 英镑的奖励，直到杆子倒下。来源: OpenAI

为了在这个环境中测试我的代理，我写了一个训练脚本。它会进行多次训练，其中一名 SAC 特工会在 CartPole-v1 环境中接受多次训练。这种情况会持续 200 步，或者直到杆子倒下。

在训练期间，每第 n 集用于评估，这意味着代理不探索而是确定性地选择动作。在所有训练运行完成后，计算并绘制评估集的平均结果。

下面你可以看到培训代理的代码。绘制结果的代码可以在资源库中找到。

用于多次运行 SAC 代理并存储结果的脚本

4.1 结果

在下图中，您可以看到五次训练的结果，每次 400 集，最多 200 步。由于每 4 集有 1 集用于评估，因此每次运行有 300 个训练集。x 次训练后的平均奖励用蓝色标出，浅蓝色阴影区域表示标准偏差。

5 次训练的平均结果。作者图片

正如你所看到的，在最初被卡住了大约 50 集之后，代理取得了很大的进步，在大约 150 集之后达到了可能的最高分 200。然而，训练仍然有些不稳定，并且直到训练结束，在短时间内分数会反复下降。请记住，该评估是在没有调整任何超参数的情况下进行的，这样做可能会带来更好、更稳定的性能。

来源

[1]赫里斯托多洛·彼得斯，离散动作场景软演员兼评论家，Arxiv，2019 年 10 月 16 日，https://arxiv.org/abs/1910.07207

[2] Haarnoja 等，软行动者-批评家:随机行动者下的偏策略最大熵深度强化学习，Arxiv，2018 年 1 月 4 日，【https://arxiv.org/abs/1801.01290

在 Vertex AI 中构建 MLOps 流水线以适应数据的变化

原文：https://towardsdatascience.com/adapting-to-changes-of-data-by-building-mlops-pipeline-in-vertex-ai-3f8ebd19a869?source=collection_archive---------7-----------------------

实践教程

这篇文章展示了如何为物体检测任务建立一个机器学习管道。目的是演示如何使用 Vertex AI 的 AutoML 和 Cloud 函数实现 MLOps 来准备数据漂移情况。

动机

我有一个三岁的女儿，我意识到她的脸每个月都在发生巨大的变化。谷歌照片已经在通过跟踪人们面部的变化来识别面部方面做得非常出色。然而，我想我可以更进一步，比如对她没有戴面具的照片进行分类，然后进行分层预测。这将是下一篇文章的主题。

此外，我认为这是 MLOps 的一个很好的例子，因为我和我的妻子像平常的父母一样给她拍了很多照片。这意味着我有足够的数据来建立一个模型，并且这些数据已经包含了潜在的数据漂移，因为我有她在婴儿、一岁、两岁时的照片。

构建管道和触发器

我们需要 Vertex AI、Google 云存储、云功能来建立机器学习管道和触发器。Vertex AI 不是一个单一的服务，而是许多不同的 AI 相关服务的组合。具体来说，这篇文章的项目利用了 Vertex AI 的数据集、AutoML、笔记本、管道、模型和端点特性。

图 1 显示了如何构建整个管道的分步说明。理解机器学习系统蓝图的最佳方式是考虑组成工作流的组件。让我们一个一个来。请记住，每个组件并不代表一个独立的作业，而是按顺序连接在一起。

图 1 :管道设置——作者图片

数据准备

数据是机器学习的心脏，没有数据我们什么都做不了。所以，毫无疑问，我们首先需要准备数据集。Vertex AI 提供了托管数据集功能。您可以简单地从本地存储中导入数据，或者如果您已经在现有的 GCS 存储桶中有了数据集，您可以只指向 GCS 位置。

然而，如你所知，数据本身是不够的。我们需要标签/注释。顶点 AI 数据集允许您在导入原始数据时直接导入标注。您只需要确保标签以建议的方式形成。你可以在这里找到如何根据数据类型制作自己的标签文件。

为了让您了解它的样子，下面显示了一个 CSV 格式的图像分类任务标签的示例(您也可以使用 JSONL)。

[ML_USE], GCS_FILE_PATH,[LABEL]

您可以找到另一个 CSV 格式的对象检测示例。

[ML_USE],GCS_FILE_PATH,[LABEL],[BOUNDING_BOX]*

在这里，您可以简单地忽略 ML_USE，但是如果您想要手动地将数据分割成训练/验证/测试集，它可以是训练集、验证集或测试集。BOUNDING_BOX 是 8 个值的列表，每两个是一对。所以你可以猜测它代表了边界框每条边的坐标。基本上，顺序必须遵循 X_MIN，Y_MIN，X_MAX，Y_MIN，X_MAX，Y_MAX，X_MIN，Y_MAX。

培养

根据数据集训练模型有多种选择。这篇文章特别展示了如何利用顶点 AI AutoML 特性来实现 MLOps。以下是我选择 AutoML 的三个原因。首先，我不必关心建模。我所要做的就是以 AutoML 能够识别的正确格式准备数据集。幸运的是，Vertex AI 数据集与 Vertex AI AutoML 完美匹配，因此没有额外的工作量。

第二，当数据集演变时，我们不能保证当前最先进的模型足够好。我们可能必须通过为数据工程、建模和超参数调整编写不同版本的代码来运行多个实验。AutoML 主要显示顶级结果。这是因为内部算法可能会随着时间的推移由谷歌工程师修改和维护，它可能会保证我们几乎总是利用可靠的最先进的 AutoML 建模技术。

最后但同样重要的是，将顶点 AI AutoML 集成到顶点 AI 管道中是很简单的。Vertex AI Pipeline 只是 Kubeflow Pipeline 的一个包装器服务，Google 定义了一堆 Kubeflow 组件，平滑地融合到标准的 Kubeflow Pipeline 中。这意味着您可以在为自定义组件编写标准 Python 代码并连接它们的同时利用 Vertex AI AutoML。

部署和监控

部署可以被视为一个操作与两个独立的操作的组合，即模型导出和服务于端点。顶点 AI 通过顶点 AI 模型和端点支持这两者。顶点人工智能模型是一个中心位置，所有训练好的模型和它们的版本一起被管理。您可以使用指标查看训练结果，用它测试一个简单的预测。

一旦您认为您已经准备好为真实世界的用户部署模型，您就可以用选择的模型创建一个端点。实际上，Vertex AI Endpoint 管理的是 Google Kubernetes 引擎中模型的端点。这意味着您不必关心模型的可伸缩性。在企业的早期阶段，只能为几个节点提供服务，但是当企业变得太大而无法用几个节点处理用户请求时，这个数字会平稳增长。

图 2:Vertex AI 端点的模型监控能力——作者图片

Vertex AI Endpoint 还提供了预测/秒、请求/秒、延迟和预测错误百分比的监控功能。您需要额外的努力来处理概念/数据漂移问题，但这足以查看预测请求中是否有错误，预测延迟是否超过预期，顶点 AI 的吞吐量是否不够。Vertex AI 为表格模型和定制模型提供了额外的监控功能，以深入检查模型行为，但很可能在不久的将来会支持 AutoML 模型。

管道和触发器

您可以单独进行数据集创建、模型训练、端点实例化和模型部署。然而，更好的方法是构建一个管道，以一致的方式完成所有这些工作。AutoML 很可能保证你有最好的模型。这意味着我们所要做的就是准备更多的数据，并在您目睹模型性能下降时触发管道。

那么什么可以触发流水线运行来学习新的数据集呢？当然，应该有一个事件监听系统来检测数据集中的变化。这就是云功能的用武之地。每当指定的 GCS 存储桶发生变化时，云功能可以监听修改事件。有了这种能力，我们可以在记录更多数据时简单地运行管道。

初始操作流程

作为演示 MLOps 的初始阶段，我们需要一个基础数据集。如图 3 所示，创建数据集需要多个步骤。首先，您需要选择数据类型和任务类型。对于这个项目，我选择了“”类别下的“图像目标检测”。其次，您可以从本地文件系统上传图像，或者如果您已经将图像上传到 GCS bucket，您可以简单地选择它。

图 3 :创建顶点人工智能数据集——作者图片

此外，如果您有一个额外的标签文件，您可以从与图 3 相同的 UI 上传它。对于这个项目，我没有任何标签，只是在上传了一堆图片后点击了“继续”。

图 4 :顶点人工智能数据集中的标记能力——作者图片

幸运的是，顶点 AI 数据集在浏览器中提供了很好的标记工具，如图 4 所示。有了这个功能，我只需简单地拖放鼠标位置，就可以标记大约 100 张图像。这样做之后，您就有了一个完整的数据集，这意味着数据和相关联的标签都存储在 GCS 存储桶中。

现在，我们已经准备好用数据集构建我们的初始管道。我们可以直接在终端或最喜欢的 ide 中编写管道代码，但是在 Jupyter 笔记本中运行初始管道通常是个好主意。因为它提供了一个很好的交互环境，我们可以通过反复修改代码来进行编辑和实验。此外，顶点人工智能笔记本可以让你忽略所有关于 GCP 授权过程的麻烦，因为它已经在 GCP 环境中运行。

图 5 :顶点 AI 管道中构建和运行管道的初始阶段——作者图片

图 5 显示了初始管道运行的工作流是如何在笔记本中进行的。作为第一步，我们需要导入必要的库并设置一些必需的变量，如下面的代码所示。

***from** google.cloud **import** aiplatform
**from** google_cloud_pipeline_components **import** aiplatform **as** gcc_aip**from** kfp.dsl **import** pipeline
**from** kfp.v2 **import** compiler
**from** kfp.v2.google.client **import** AIPlatformClientPROJECT_ID = “YOUR_GCP_PROJECT_ID”
REGION = “GCP_REGION_TO_RUN_PIPELINE” 
PIPELINE_ROOT = “LOCATION_RUN_METADATA_IS_GOING_TO_BE_STORED”
DATASET_META_PATH = “LOCATION_DATASET_METADATA_IS_STORED”*

我们需要三个五库三包。下面的两个代码示例展示了它们的用法。第一个代码块显示了如何定义包含三个管道组件的管道。注意@ componentdecorator 用来表示函数管道是整个管道定义到 Kubeflow 管道的地方。我们可以用@ componentdecorator 将三个组件分离成单独的函数，并在管道中挂钩。然而，我把所有东西都放在一个地方，以使这个示例尽可能简单。

ImageDatasetCreateOp组件用于导入我们通过顶点 AI 数据集定义的数据集。为了实例化这个组件，我们需要告诉三件事，即 GCP 项目 ID、存储标签文件的 GCS 路径和任务类型。

*@pipeline(name=”my-pipeline”)
**def** **pipeline**(project: str = PROJECT_ID):
   ds_op = gcc_aip.ImageDatasetCreateOp(
      project=project,
      display_name=”DATASET_NAME_TO_APPEAR”,
      gcs_source=DATASET_META_PATH,
      import_schema_uri=\
         aiplatform.schema.dataset.ioformat.image.bounding_box,
   ) training_job_run_op = gcc_aip.AutoMLImageTrainingJobRunOp(
      project=project,
      display_name=”my-daughter-od-training”,
      prediction_type=”object_detection”,
      model_type=”CLOUD”,
      base_model=**None**,
      dataset=ds_op.outputs[“dataset”],
      model_display_name=”my-daughter-od-model”,
      training_fraction_split=0.6,
      validation_fraction_split=0.2,
      test_fraction_split=0.2,
      budget_milli_node_hours=20000,
   ) endpoint_op = gcc_aip.ModelDeployOp(
      project=project, model=training_job_run_op.outputs[“model”]
   )*

下一个组件是autolimagetrainingjobrunop。这是每个图像相关任务的统一组件。如您所见，您可以在 prediction_type 参数中指定特定的任务类型。还要注意 model_type 设置为“”。这告诉 AutoML 计算出要生成哪种结果模型。例如，如果你想得到一个低延迟的更轻的模型，你可以将 model_type 不同地设置为“CLOUD _ LOW _ LATENCY _ 1”。有多种选择，所以请查看 API 文档了解更多信息。对于这个项目，我只是把它作为标准的平均模型。**

在autolimagetrainingjobrunop组件中还有三个参数需要考虑。您可以直接指定训练/验证/测试分割比率。尽管您可以在数据集准备阶段指定哪些图像应属于哪个数据集，但如果您在此组件中显式设置它们，它将忽略信息并根据比率随机分配数据。如果你不能自己决定拆分，这是一个很好的开始方式。buget _ milli _ node _ hours是何时停止训练的约束。因为如果你永远训练，AutoML 可以无限增长模型的大小，你必须决定何时停止训练过程。否则，你将付出大量的金钱，却没有任何准确性的提高。最后，必须告诉 AutoML 将在哪个数据集上进行训练，这是通过 dataset 参数完成的。需要知道的重要一点是，数据集参数设置了ImageDatasetCreateOp和autolimagetrainingjobrunop之间的连接和依赖关系，因为训练作业必须在数据集创建操作之后执行。

最后一个组件是ModelDeployOp。尽管名称如此，但它能够创建端点并将训练好的模型部署到端点。我们可以显式地分别执行这两个操作，但是用一个组件来执行它们会更方便。您需要做的就是指定要部署什么模型，这是通过模型参数设置的。同样，该参数设置了autolimagetrainingjobrunop和ModelDeployOp之间的连接和依赖关系。****

**compiler.Compiler().compile(
   pipeline_func=pipeline, package_path=PIPELINE_SPEC_PATH
)api_client = AIPlatformClient(project_id=PROJECT_ID, region=REGION)response = api_client.create_run_from_job_spec(
 PIPELINE_SPEC_PATH,
 pipeline_root=PIPELINE_ROOT,
 parameter_values={“project”: PROJECT_ID},
)**

管道完全定义好了，接下来我们要用 编译器来编译。编译器()。编译 方法。编译的作用是通过查找管道函数定义来构造管道规范。在管道规范中，记录了许多隐藏的部分，比如作业依赖关系、使用哪种云机器类型和哪个容器映像等等。通过指定 package_path 参数，编译器在 JSON 文件中输出管道规范。有了 JSON 文件，运行管道所需要做的就是将 JSON 文件传递给 Vertex AI 客户端的create _ run _ from _ job _ spec方法。这对于流水线的自动触发和重用是非常重要的。

用 JSON 文件向 Vertex AI 发送请求后，您将拥有在 Vertex AI 管道中运行的初始管道。当管道运行完成时，您可以分别通过顶点 AI 模型、端点 UI 面板找到训练好的模型、端点以及部署到端点的模型。

观察意外的数据漂移

构建一个简单的应用程序来将图像发送到端点以进行预测是很简单的，但是您可以使用 Vertex AI Model 中的测试功能轻松地测试您的模型。我使用这个特性是因为我可以在 GCP 控制台上很容易地看到预测的结果。

为了测试模型应该不能像预期的那样检测到我女儿三岁时的脸，我给了模型一些图像，如图 6 所示。然而，我得到了意想不到的结果，模型已经成功地检测出她长大的脸。

图 6 :意外结果(1)。经过训练的模型在 3 岁时就能认出自己的脸，尽管这张脸是在婴儿的照片上训练出来的——作者的照片

我继续用最近的图像测试这个模型，我意识到新冠肺炎疫情已经在去年发生了。我发现她的很多照片都戴着面具，也有一些照片戴着太阳镜。这是我最初对这个项目进行头脑风暴时的意外情况，我很快就将这种情况视为数据漂移问题。如图 7 所示，经过训练的模型捕捉到了错误的位置和不同孩子的脸。

图 7 :意想不到的结果(2)。有很多我没有预料到的图片——作者的图片

在收集和标记新数据后，可以手动运行管道。然而，如果能实现一个自动系统，在我们有新数据时触发管道运行，那就更好了，因为我们已经创建了 JSON 规范文件。

图 8 显示了发生数据漂移时的工作流程。你可以看到，我们不再需要 Vertex AI 笔记本了，流水线运行也不是直接从笔记本上执行的。相反，我们可以创建并部署一个小函数，在云函数上触发，它监听指定的 GCS 存储桶中的变化事件。需要注意的一点是，有一个单独的 GCS 桶用于存储最终数据集的元数据。逐个标注数据集时，元数据会频繁更改，您不希望每次更改时都运行管道。相反，当我们认为已经完成时，我们可以将最终的元数据文件导出到一个单独的 GCS bucket 中。

图 8 :发生数据漂移时的操作流程——作者图片

下面的代码块显示了云函数的所有代码。这很简单，因为我们已经有了管道规范 JSON 文件。每当属于一个指定的 GCS 桶的任何文件有任何改变时，vertex_ai_pipeline_trigger 函数被调用。因此，我们需要编写一个简单的过滤条件语句。以下代码确保在导出时对顶点 AI 数据集支持的扩展名为 jsonl 的文件进行任何更改时运行管道。

****from** kfp.v2.google.client **import** AIPlatformClientPROJECT_ID = “YOUR_GCP_PROJECT_ID”
REGION = “GCP_REGION_TO_RUN_PIPELINE” 
PIPELINE_ROOT = “LOCATION_RUN_METADATA_IS_GOING_TO_BE_STORED”
PIPELINE_SPEC_PATH = “LOCATION_PIPELINE_SPEC_IS_STORED”**def** **vertex_ai_pipeline_trigger**(event, context):
   print(‘File: {}’.format(event[‘name’]))
   print(‘Extension: {}’.format(event[‘name’].split(“.”)[-1])) **if** event[‘name’].split(“.”)[-1] == “jsonl”:
      print(“target file extension”) api_client = AIPlatformClient(
         project_id=PROJECT_ID, 
         region=REGION
      )
      print(“api_client is successfully instantiated”) response = api_client.create_run_from_job_spec(
         PIPELINE_SPEC_PATH,
         pipeline_root=PIPELINE_ROOT,
         parameter_values={“project”: PROJECT_ID},
      )
      print(‘response: {}’.format(response))**

在条件语句中，运行管道的代码与我们在笔记本部分看到的完全相同。你可能想知道我们是否需要额外的认证过程来从其他 GCP 服务访问 Vertex AI。不过可以精简，因为云功能和 Vertex AI 都是 GCP 服务。

**gcloud functions deploy YOUR_FUNCTION_NAME \
 — trigger-resource YOUR_TRIGGER_BUCKET_NAME \
 — trigger-event providers/cloud.storage/eventTypes/object.finzlize**

在编写了包含上面代码块的 python 文件后，我们可以用下面的 shell 命令将其部署到 Cloud Function。这个命令应该运行在 python 文件所在的同一个目录下，并且“YOUR _ FUNCTION _ NAME”应该与 python 文件中定义的实际函数名相匹配。请在官方文档中找到关于该命令的更多信息。此外，确保将 requirements.txt 包含在包含任何必要库的同一目录中。在这个项目中，包含了Google-cloud-AI platform来访问 Vertex AI APIs。

更新数据集以补充

通过编写和部署云函数，收集和标记更多的数据，并将元数据导出到适当的 GCS 存储桶，就可以为更新的数据集获得新的模型。

图 9 :收集并标注更多数据以覆盖口罩佩戴情况—图片由作者提供

图 9 显示我已经包含了更多我女儿戴面具的图片。我还附上了更多她最近拍摄的照片，以便模特能更好地认出她。

决赛成绩

当点击右上角的导出元数据按钮时，云函数被触发，它自动触发管道。

图 10 :模型被重新训练后，它识别所有预期的案例——作者图片

图 10 显示了我用新收集的数据集得到的最终模型。正如你所看到的，它不仅能识别出我女儿在婴儿时期的脸，还能识别出她最近的脸，而且它还能成功地识别出她戴着面具的脸，即使照片中还有其他孩子。

结论

在这篇文章中，我们通过一个实际的用例探索了如何用 Vertex AI 构建一个简单但可扩展的 MLOps 管道。Vertex AI 允许您在浏览器中准备自己的数据集。你可以通过笔记本服务与顶点人工智能 API 进行交互。在修复了代码库之后，您可以运行初始管道并创建 JSON 规范文件，该文件包含了在没有实际代码的情况下如何运行管道的所有细节。最后，您可以将结合 GCS 的云函数与 Vertex AI 集成，以便在数据集发生任何变化时自动运行。

自适应增强:算法的逐步解释

原文：https://towardsdatascience.com/adaptive-boosting-a-stepwise-explanation-of-the-algorithm-50b75c3729c1?source=collection_archive---------18-----------------------

索耶·本特森在 Unsplash 上的照片

自适应 Boosting(或 AdaBoost)是一种监督集成学习算法，是第一种用于实践的 Boosting 算法，由 Freund 和 Schapire 在 1995 年开发。

简而言之，自适应提升有助于通过将许多弱分类器顺序转化为一个强分类器来减少任何分类学习算法(如决策树或支持向量机)的错误。这可以通过顺序的权重调整、单个投票权和最终算法分类器的加权和来实现。

在这篇文章中，我想尽可能用最简单快捷的方式向你解释自适应增强过程。我们将根据一个简单的数据集手工计算算法的每一步。

请注意，我不会触及升压的基本理论，因为已经有大量令人惊叹的文献了。更确切地说，这篇文章的附加价值在于关注算法的数学部分。这将让你更好地理解 Boosting，从而更自由地使用它。

所以，享受这篇帖子，让你未来的机器学习模型更进一步！

自适应升压算法步骤

执行自适应增强时，我们必须反复执行以下每个步骤(除了步骤 1，它只在开始时执行):

自适应增压的步骤

迭代意味着自适应增强执行多轮步骤 2 至 4，并最终将所有选择的分类器组合成一个整体公式(即强分类器):

所有递归分类器的总和

注意:signum 函数用于获取-1 和+1 之间的最终值。

到目前为止一切顺利，让我们快速浏览一下计算所基于的模型设置！

模型设置

对于以下演示，我将使用后续数据:

模型数据(图片由作者提供)

数据包含两类(蓝色加号和红色减号)。目标是以一种优化的方式正确地划分这两个类别。这样，我们就面临一个二元分类问题。

但是，我们将使用以下决策树树桩

并试图找到那些能够正确划分这些数据点的弱分类器(即决策树树桩)(注意我随机选择了决策树树桩)。

让我们设想一下我们将执行自适应增强的最终模型设置:

数据和决策树树桩(图片由作者提供)

逐渐执行自适应增压

对于第一轮执行步骤，我将详细解释每个步骤。之后只会看每一轮的结果，看事情会怎么变化！

在步骤 1 中，每个数据点具有相同的权重 1/N

之所以这样做，是因为没有理由一开始就要给不同的权重。因为我们有 10 个数据点，初始权重是 1/10，因此是 0.1。

初始重量(图片由作者提供)

在步骤 2 中，我们绘制第一个决策树残肢并计算误差。

该误差用于两件事:首先，我们需要每个决策树树桩的误差，以便挑选具有最低误差率的树桩(步骤 3a)。其次，我们使用误差来计算新的权重(步骤 4)。

加权误差能够集中在那些难以预测的数据点上。换句话说，我们对先前分类器表现差的部分给予较高的权重。

让我们看看第一个决策树树桩 y = 2 的错误:

第一个决策树树桩(图片由作者提供)

如果你能看到，我们错误地分类了四个数据点，这导致了 0.4 (4/10)的误差。这个过程应该使用上面选择的所有分类器来完成。所以让我们开始吧！

Boosting 算法的第一轮(图片由作者提供)

我们可以看到所有的分类器和它们各自的错误。

根据步骤 3a ，我们必须选择误差最小的分类器。在我们的例子中，分类器 3 的错误率最低，为 0.2。

在步骤 3b 中，我们要计算 alpha。

Alpha 用于展示所选分类器的投票能力。误差越低，投票权越高。这是有用的，因为更准确的分类器也应该有更高的投票权。

注意:公式使用 log，因为如果我们有一个非常小的误差，那么 alpha 就会变得相当高。

我们将使用 Python 来计算 alpha。

import mathdef get_alpha(error):
    return (1/2)*math.log(((1-error)/error), math.e)print("Alpha value: " + str(get_alpha(error=0.2)))Alpha value: 0.6931471805599453

因此，我们的第一个分类者的投票权约为 0.69。

在步骤 4 中，我们需要计算新的权重。

新的权重在每一轮结束时计算，用于识别难以分类的数据点。我们再次使用 Python 来计算新的权重。

def new_weight_correct(error):
    return 0.1/(2*(1-error))def new_weight_incorrect(error):
    return 0.1/(2*error)print("Weights for correct classified datapoints: " + str(new_weight_correct(0.2)))
print("Weights for incorrect classified datapoints: " + str(new_weight_incorrect(0.2)))Weights for correct classified datapoints: 0.0625
Weights for incorrect classified datapoints: 0.25

您可能会注意到，分类不正确的数据点的权重(0.25)高于分类正确的数据点的权重(0.0625)。通过查看数据点的大小，可以在下一轮中看到更高的权重(我使数据点的大小与彼此的权重成比例)。

因此，在第一轮结束时，我们有了 Boosting 算法中的第一个分类器(分类器 3)，他各自的投票权和新的权重。

在每一轮结束时，我们可以考虑是否已经有足够的弱分类器来正确地分离所有数据点。显然，一轮是不够的，所以我们用新的重量进行第二轮！

由于每一轮的计算都是相同的，我将只从这一点来解释结果。

Boosting 算法的第二轮(图片由作者提供)

在第 2 轮之后，分类器 4 是最小化误差的那个。注意，分类器 6 也具有相同的错误率，但是我们现在将选择第一个。然而，我们将继续计算分类器 4 的α和新的权重。

print("Alpha value: " + str(get_alpha(error=0.1875)))
print("Weights for correct classified datapoints: " + str(new_weight_correct(error=0.1875)))
print("Weights for incorrect classified datapoints: " + str(new_weight_incorrect(error=0.1875)))Alpha value: 0.7331685343967135
Weights for correct classified datapoints: 0.06153846153846154
Weights for incorrect classified datapoints: 0.26666666666666666

到目前为止一切顺利，让我们继续第三轮:

Boosting 算法的第三轮(图片由作者提供)

似乎分类器 3 还是最好的。让我们添加它并计算 alpha，新的权重，从第 4 轮开始:

print("Alpha value: " + str(get_alpha(error=0.1231)))
print("Weights for correct classified datapoints: " + str(new_weight_correct(error=0.1231)))
print("Weights for incorrect classified datapoints: " + str(new_weight_incorrect(error=0.1231)))Alpha value: 0.9816979637974511
Weights for correct classified datapoints: 0.05701904436081651
Weights for incorrect classified datapoints: 0.4061738424045492

Boosting 算法的第四轮(图片由作者提供)

同样，分类器 4 和 6 是最好的。这一次，我们选择分类器 6！

print("Alpha value: " + str(get_alpha(error=0.1711)))
print("Weights for correct classified datapoints: " + str(new_weight_correct(error=0.1711)))
print("Weights for incorrect classified datapoints: " + str(new_weight_incorrect(error=0.1711)))Alpha value: 0.7889256698496664
Weights for correct classified datapoints: 0.06032090722644469
Weights for incorrect classified datapoints: 0.29222676797194624

现在等等！如果我们组合分类器，似乎我们可以对所有数据点进行分类。让我们看看最终分类:

最终分类(图片由作者提供)

在那里！我们把一切都分类对了！让我们尝试添加一个新的数据点，并让分类器投票！

x = 7
y = 3.5

添加新的数据点(图片由作者提供)

根据最终模型，我们有以下算法:

最终模型

  • 分类器 1 以 0.6931 的投票权为 plus 投票
  • 分类器 2 以 0.7332 的投票权投反对票
  • 分类器 3 以 0.9816 的投票权为 plus 投票
  • 分类器 4 以 0.7889 的投票权投负号。

如果你计算投票权的加权和，算法会将数据点归类为加号并猜测…算法完全正确！

Python 中的自适应增强

为了向您展示如何在 Python 中实现自适应增强，我使用了来自 scikit-learn 的快速示例，其中他们基于支持向量机对数字图像进行分类。您可以在这里找到示例和相应的代码:

https://scikit-learn.org/stable/auto_examples/classification/plot_digits_classification.html

但是对比这个例子，我们会用 AdaBoost 对数字进行分类。之后，我们再看表演。

注意，在 AdaBoost 中，默认的分类器是决策树分类器。如果你想要其他的基本估计量，你必须在模型中阐明它们。

# Importing the libraries
import matplotlib.pyplot as plt
from sklearn import datasets, metrics
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import AdaBoostClassifierdigits = datasets.load_digits()_, axes = plt.subplots(nrows=1, ncols=4, figsize=(10, 3))
for ax, image, label in zip(axes, digits.images, digits.target):
    ax.set_axis_off()
    ax.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title('Training: %i' % label)

我们将尝试分类的样本数字图像

# flatten the images
n_samples = len(digits.images)
data = digits.images.reshape((n_samples, -1))# Split data into 50% train and 50% test subsets
X_train, X_test, y_train, y_test = train_test_split(
    data, digits.target, test_size=0.5, shuffle=False)

好了，我们现在准备开始使用 AdaBoost 分类器。我们将使用 accuracy_score 度量来定义分类器的性能。

clf = AdaBoostClassifier()
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)acc_sc = metrics.accuracy_score(y_test, y_pred)print("Accuracy Score: " + str(acc_sc))Accuracy Score: 0.7808676307007787

在那里！我们能够以大约 78%的准确率对数字进行分类。请注意，我们没有执行超参数优化，并且还使用 50%作为测试大小(这相当高)…因此，该模型可以进一步改进！

我希望你喜欢这篇文章，如果你喜欢…然后砸一些拍手:)编码快乐！

为您的脸书页面添加自定义的 Rasa 聊天机器人

原文：https://towardsdatascience.com/add-a-customized-rasa-chatbot-for-your-facebook-page-9313687fbdcb?source=collection_archive---------34-----------------------

为您的脸书页面设置 Rasa 聊天机器人的简单演练

沃洛季米尔·赫里先科在 Unsplash 上的照片

在过去的十年里，聊天机器人，或者更正式地称为虚拟助手，已经成为收集和传播信息的流行选择。此外，将这些聊天机器人集成到不同的社交媒体平台和网站的能力使其成为一种可行和方便的通信选择。

此外，脸书是最受欢迎的社交媒体平台之一，它已经成为宣传个人和合作企业的重要舞台。并且将定制的聊天机器人集成到脸书页面中可以导致页面访问量的增加和来自用户的愉快的交互。这个简化的分步教程将指导您完成 Rasa 安装、设置开发环境以及与脸书页面的集成。最重要的是，这个程序不包含任何付费工具或软件。所以让我们进入教程。

设置 Rasa

安装 Python

首先，你必须安装 Python。您可以安装从 3.6 到 3.9 的任何版本。请注意，3.6 版本将在 2021 年底停止支持。3.9 是通常的选择，但是如果你已经安装了上面提到的 3 个版本中的一个，一切都会好的。这里 可以从 安装 Python for Windows。如果能通过 Windows installer 安装 Python，并且确保在安装时勾选“将 Python version添加到路径”选项，那就更好了。****

选择 IDE

IDE 有许多可行的选择，但我个人更喜欢 VS 代码。但是您可以使用大多数可用的流行 ide。你可以从 这里 下载 Visual Studio 代码。

设置虚拟环境

首先，创建一个文件夹，您将在其中创建 Rasa 项目。现在打开命令提示符，使用‘CD’选项进入创建的文件夹。此外，你可以通过在文件浏览器中打开你创建的文件夹，然后在地址栏中键入‘cmd’并按回车键。

图 1:在目标文件路径打开命令提示符的另一种方法(图片由作者提供)

在打开相关文件夹地址的命令提示符后，您可以键入代码。在给定的目标地址打开 VS 代码 IDE。此快捷方式仅适用于 Windows 上的 VS 代码 IDE。对于其他 IDE 和 OS，您必须手动打开 IDE 终端并浏览到创建的文件夹。

现在，如果你正在使用 VS 代码，你必须去终端标签>新终端打开一个新终端。之后，你可以使用命令Python-m venv 简单地创建一个虚拟环境。/venv' 。

创建虚拟环境后，您可以使用命令激活虚拟环境。\venv\Scripts\activate' 。

安装 Rasa 和其他必要的组件

现在，我们将在虚拟环境中安装一些组件，包括 Rasa。首先，我们必须得到 pip ，它是 Python 包的包管理器。您可以使用 'python get-pip.py' 命令安装 pip。之后，通过使用 pip，我们可以下载并安装 Rasa。使用‘pip 3 安装 rasa’。安装需要几分钟时间。

创建 Rasa 项目

在您创建的主文件夹中创建一个子文件夹。这个新文件夹是我们创建 Rasa 项目的地方。您可以通过文件浏览器或 VS 代码本身来实现这一点。

图 2:为 Rasa 项目创建一个新文件夹(图片由作者提供)

现在使用‘CD * folder name *’命令进入新创建的文件夹。之后，您可以输入命令‘rasa init’在给定的文件夹中创建新的 rasa 项目。这也需要几分钟时间。创建项目时会有一些提示，你可以根据你的目标来回复它们。

与脸书融合

设置脸书应用程序

首先，你必须建立一个脸书应用程序。前往开发者的脸书，进入右上角的“我的应用”标签。使用脸书帐户登录，该帐户用于创建您计划集成聊天机器人的页面。点击“创建应用”按钮，选择“业务”作为应用类型。

图 3:点击创建应用按钮(图片由作者提供)

添加应用程序显示名称，并选择“你自己或你自己的生意”，然后点击“创建应用程序”。

现在向下滚动，在产品列表中找到 messenger，点击“设置”。现在在访问令牌部分，点击‘添加或删除页面’按钮，添加你想要聊天机器人进入的脸书页面。保持启用管理和访问 Messenger 中的页面对话属性并继续。

图 4:将脸书页面添加到应用程序后(图片由作者提供)

更新 Rasa 项目

现在，我们必须做一些调整，将脸书应用程序与我们新创建的 Rasa 项目链接起来。为此，请浏览 Rasa 项目中的credit initials . yml文件。打开文件，找到脸书的位置，取消对该代码块的注释。

图 5:credentials . yml文件(图片由作者提供)

现在你必须返回到脸书应用程序来获取你的 <秘密> 和 <你的页面访问令牌> ，然后将它们填入credentials . yml文件中。在脸书应用程序中，在我们链接脸书页面的访问令牌部分(图 5)下，单击“生成令牌”按钮。复制这个长令牌并替换creditinitials . yml文件中的 <页面访问令牌> 标签。

接下来，进入左侧菜单中的设置>基本，你将能够找到一个带有标签‘App Secret’的加密字段。这将 <你的秘密> 放在credentials . yml文件中。复制 App Secret ，替换 < your secret > 标签。

图 7:App 秘密(图片由作者提供)

对于 <验证> 字段，您可以添加一个字符串作为设置 webhook 时的验证令牌，因此您可以键入任何您想要的字符串。

最后，打开 Rasa 项目中的 'endpoints.yml' 文件，取消对提到 action_endpoint 的代码块的注释。

图 8 : endpoints.yml 文件(图片由作者提供)

保存在credit initials . yml和 endpoints.yml 文件中所做的更改，并重启 Rasa 服务器。你可以用 Ctrl+C 停止服务器，用‘rasa run’命令启动服务器。

用 ngrok 设置 Webhook

首先，你得下载ngrokT3。ngrok 是一个跨平台的应用程序，它允许将本地开发服务器暴露给互联网。下载并解压缩到您计算机上的任何位置。在继续之前，您必须打开代码 IDE，并检查 Rasa 项目正在哪个本地端口上运行。你可以在‘rasa run’命令后的细节中找到。我的是 5005 端口。确认端口后，打开ngrok.exe文件，输入‘ngrok http 端口号’。这将把提到的本地端口暴露给互联网。通常，会话应限制在 2 小时内，这意味着 2 小时后应重新建立连接，并且转发 URL 将被更改。您可以在ngrok.com创建一个免费帐户，并通过使用为创建的免费帐户提供的身份验证令牌来取消会话时间限制。

图 9 : ngrok 连接状态(图片由作者提供)

这里有两个转发网址。你必须复制带有‘https’的网址。对我来说就是' https://BD 0 BCB 258 fc 2 . ngrok . io '。现在进入脸书应用程序，进入左侧菜单中的信使>设置。在 Webhooks 部分下(在访问令牌部分的正下方)，点击‘添加回调 URL’按钮。对于回调 URL，你要粘贴复制的 URL，格式为:复制的 URL */web hooks/Facebook/web hook。以及creditinitials . yml*文件的 <验证> 字段中的验证令牌。

图 10:添加回调 URL(作者图片)

添加以上两个字段后，您可以点击‘验证并保存’，如果 Rasa 服务器和 ngrok 连接都已启动并运行，它将正常工作。成功验证后，您将能够看到您的脸书页面出现在 Webhooks 部分，webhooks 字段为空。点击编辑按钮，添加‘消息传递’和‘消息传递 _ 回发’订阅字段。

图 11:编辑页面订阅(作者图片)

完成这些步骤后，您将能够使用创建该页面的帐户登录脸书，并与该页面的集成聊天机器人聊天。如果你也想允许其他几个人聊天，你必须将他们添加为你的脸书应用的测试者，方法是在脸书应用页面的左侧菜单中进入角色>角色。他们还必须注册脸书开发者账户才能接受邀请，并继续测试该页面的聊天机器人。

现在你所要做的就是通过 Rasa 项目按照你需要的方式定制聊天机器人。如果你不了解 Rasa 的发展，可以在网上找到很多正规聊天机器人的代码库。如果你这样做了，你可以根据你的愿望定制聊天机器人，最后，你可以提交你的应用程序进行审查，一旦通过，脸书的任何人都可以使用你定制的聊天机器人页面！

在这个整合过程中，我确实遇到了很多问题，这也是我觉得以一种简化的循序渐进的方式写这篇文章的主要原因。因此，您可以随时删除您在此过程中遇到的任何其他错误，希望我能够助您一臂之力。编码快乐！注意安全！

如何向 PySpark 数据框架添加新列

原文：https://towardsdatascience.com/add-new-column-pyspark-dataframe-e1ebee323fdb?source=collection_archive---------10-----------------------

探索向现有 Spark 数据框架添加新列的多种方法

Adrian Trinkaus 在 Unsplash 上拍摄的照片

介绍

向 PySpark 数据帧添加新列可能是您在日常工作中需要执行的最常见操作之一。

在今天的简短指南中，我们将讨论如何以多种不同的方式做到这一点。具体来说，我们将探索如何添加新列并填充它们

  • 带文字
  • 通过转换现有列
  • 使用联接
  • 使用函数或 UDF

首先，让我们创建一个示例数据框架，我们将在本文中引用它来演示我们感兴趣的概念

from pyspark.sql import SparkSession# Create an instance of spark session
spark_session = SparkSession.builder \
    .master('local[1]') \
    .appName('Example') \
    .getOrCreate()# Create an example DataFrame
df = spark_session.createDataFrame(
    [
        (1, True, 'a', 1.0),
        (2, True, 'b', 2.0),
        (3, False, None, 3.0),
        (4, False, 'd', None),
    ],
    ['colA', 'colB', 'colC', 'colD']
)df.show()
*+----+-----+----+----+
|colA| colB|colC|colD|
+----+-----+----+----+
|   1| true|   a| 1.0|
|   2| true|   b| 2.0|
|   3|false|null| 3.0|
|   4|false|   d|null|
+----+-----+----+----+*

使用文本添加新列

假设您想要添加一个包含文字的新列，您可以利用用于创建文字列的[pyspark.sql.functions.lit](https://spark.apache.org/docs/3.1.1/api/python/reference/api/pyspark.sql.functions.lit.html)函数。

例如，下面的命令将在每行中添加一个名为colE的新列，其中包含100的值。

**df.withColumn('colE', lit(100))**df.show()
*+----+-----+----+----+----+
|colA| colB|colC|colD|colE|
+----+-----+----+----+----+
|   1| true|   a| 1.0| 100|
|   2| true|   b| 2.0| 100|
|   3|false|null| 3.0| 100|
|   4|false|   d|null| 100|
+----+-----+----+----+----+*

注意，您必须使用lit函数，因为withColumn的第二个参数必须是类型Column。

现在，如果您想添加一个包含更复杂数据结构(如数组)的列，可以如下所示进行操作:

from pyspark.sql.functions import lit, array**df = df.withColumn('colE', array(lit(100), lit(200), lit(300)))**df.show()
*+----+-----+----+----+---------------+
|colA| colB|colC|colD|           colE|
+----+-----+----+----+---------------+
|   1| true|   a| 1.0|[100, 200, 300]|
|   2| true|   b| 2.0|[100, 200, 300]|
|   3|false|null| 3.0|[100, 200, 300]|
|   4|false|   d|null|[100, 200, 300]|
+----+-----+----+----+---------------+*

通过转换现有列来添加列

如果你想基于一个现有的列创建一个新的列，那么你应该在withColumn方法中指定想要的操作。

例如，如果您想通过将现有列的值(比如说colD)乘以一个常数(比如说2)来创建一个新列，那么下面的方法就可以做到:

from pyspark.sql.functions import col**df = df.withColumn('colE', col('colD') * 2)**df.show()
*+----+-----+----+----+----+
|colA| colB|colC|colD|colE|
+----+-----+----+----+----+
|   1| true|   a| 1.0| 2.0|
|   2| true|   b| 2.0| 4.0|
|   3|false|null| 3.0| 6.0|
|   4|false|   d|null|null|
+----+-----+----+----+----+*

使用联接添加新列

或者，我们仍然可以创建一个新的数据帧，并将其连接回原来的数据帧。首先，需要创建一个新的数据帧，其中包含要添加的新列以及要在两个数据帧上连接的键

new_col = spark_session.createDataFrame(
    [(1, 'hello'), (2, 'hi'), (3, 'hey'), (4, 'howdy')],
    ('key', 'colE')
)new_col.show()
*+---+-----+
|key| colE|
+---+-----+
|  1|hello|
|  2|   hi|
|  3|  hey|
|  4|howdy|
+---+-----+*

最后进行连接:

from pyspark.sql.functions import col**df = df \
    .join(new_col, col('colA') == col('key'), 'leftouter') \
    .drop('key')**df.show()
*+----+-----+----+----+-----+
|colA| colB|colC|colD| colE|
+----+-----+----+----+-----+
|   1| true|   a| 1.0|hello|
|   2| true|   b| 2.0|   hi|
|   3|false|null| 3.0|  hey|
|   4|false|   d|null|howdy|
+----+-----+----+----+-----+*

使用函数或 UDF 添加列

另一种可能性是使用返回Column的函数，并将该函数传递给withColumn。例如，您可以使用内置的[pyspark.sql.functions.rand](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.sql.functions.rand.html)函数创建一个包含随机数的列，如下所示:

from pyspark.sql.functions import rand**df = df.withColumn('colE', rand())**df.show()
*+----+-----+----+----+--------------------+
|colA| colB|colC|colD|                colE|
+----+-----+----+----+--------------------+
|   1| true|   a| 1.0|0.026110187082684866|
|   2| true|   b| 2.0|0.046264104329627576|
|   3|false|null| 3.0|  0.7892572670252188|
|   4|false|   d|null|  0.7963792998818318|
+----+-----+----+----+--------------------+*

最后的想法

在今天的简短指南中，我们讨论了如何向现有的 PySpark 数据帧中插入额外的列。

成为会员 阅读媒体上的每一个故事。你的会员费直接支持我和你看的其他作家。你也可以在媒体上看到所有的故事。

你可能也会喜欢

将预测间隔添加到预测模型中

原文：https://towardsdatascience.com/add-prediction-intervals-to-your-forecasting-model-531b7c2d386c?source=collection_archive---------12-----------------------

在任何机器学习管道中提供预测不确定性估计

安德里克·朗菲尔德在 Unsplash 上拍摄的照片

参与预测任务的每个人都开始构建一个模型来生成点预测。在大多数预测应用中，这与提供倾向于最准确地预测未来的预测的需要有关。进行这种预测在每个业务场景中都非常有用，因为，给定一些 KPI 的预期未来值，就有可能计划一个适当的策略来最大化目标。

准确不是全部。一个适合(并经过适当验证)来产生未来均值预测的模型只是在告诉我们:“ 未来几天 我们可以预期看到什么值”。尽管如此，最新的信息可能是一条很好的信息，但它可能不足以让企业做出正确的决策。

预测区间帮助我们丰富预测报告。他们只是告诉我们:“ 其中 我们可以预期看到接下来几天的值”。它们提供了一个上限和下限，与点预测(位于中间)相关联，真实值可能会落在该点。预测区间总是与一个公差百分比相关联，该公差百分比赋予我们估计的不确定性大小。换句话说，我们期望我们的预测区间在未来 X%的时间里捕捉到真实值。

在这篇文章中，我们介绍了一种简单而有效的方法来使我们的模型产生预测区间。主要优点是我们可以完全免费地检索每个回归模型的预测区间。

方法学

我们采用的建立预测区间的方法主要基于残差自举。Bootstrapping 是一种重采样技术，广泛用于统计和机器学习中，以逼近未知量。顾名思义，残差自举由残差分布的替换采样组成。所涉及的残差分布是作为我们的训练/验证集上的目标和预测之间的原始差异而获得的。

例如，为了获得 95%的预测区间，我们必须从残差分布中进行替换采样，并从中提取 0.025 和 0.975 分位数。简单地将这些自举统计量添加到点预测中，我们就可以获得我们的预测区间。

如上所述，该程序非常简单，但由于这个原因，它不能被低估。有一些隐藏的陷阱，如果考虑不周，可能会使我们的工作化为乌有。

首先，残差分布必须建立在看不见的数据上。只有在这种情况下，我们才能保证近似未知行为，并为我们的预测区间提供可靠的不确定性解释。最佳实践是通过交叉验证进行拟合，并估计验证折叠上的残差分布。

其次，我们必须根据系统隐藏的动态选择一个合适的模型。错误模型的发展将影响残差自举统计，即误导性的预测区间。这个最新的方面在下面的人工例子中进行了更深入的分析，我们试图在两种不同的状态下建立预测区间。

平稳数据

给定一个由 3 个变量 Y、X1 和 X2 组成的固定系统；我们尝试提前一步预测 Y 以及相应的预测区间。

模拟静态数据(图片由作者提供)

我们开始进行标准特征工程，创建一些滚动特征。然后，我们通过简单的网格搜索找到了山脊和随机森林的最佳参数。使用相同的交叉验证策略来获得两个模型的最佳参数组合的折外残差。

随机森林的残差统计(图片由作者提供)

岭的残差统计(图片由作者提供)

残差分布遵循伪正态分布，残差自相关没有显示出显著的模式。这些是我们模型拟合度的指标。

如果我们想为我们的模型建立 95%的预测区间，我们只需要计算残差分布的自举分位数。根据看不见的测试数据得出的结果证实了我们的预期。近 5%的测试观测值超出了两个模型的预测范围。

对测试数据的随机森林和山脊预测(图片由作者提供)

非静态数据

我们在由 4 个变量 Y，X1，X2，X3 组成的非平稳系统中重复了相同的实验。X3 是一个有负趋势的随机游走。我们总是想提前一步预测未来的 Y 以及相应的预测区间。

模拟的非平稳数据(图片由作者提供)

我们重复与之前相同的预测流程，包括特征工程、网格搜索调整和残差分布计算。

随机森林的残差统计(图片由作者提供)

岭的残差统计(图片由作者提供)

残差分布遵循伪正态分布，但是自相关揭示了一些问题。在 RandomForest 的情况下，高循环自相关意味着模型没有被正确训练。

建立在自举残差分布基础上的 95%预测区间反映了 RandomForest 获得的错误性能。对于山脊，我们又有将近 5%的试验观测值落在预测带之外。对于 RandomForest 来说，由于不匹配，这个数字相当大。

测试数据上的岭预测(图片由作者提供)

我们可能会预料到这种行为。基于树的模型不适合处理数据的时间变化。一阶微分可以解决这个问题。然而，要点是预测区间并不神奇。按照我们的程序，只有我们正确地对基础系统建模，我们才能获得良好的不确定性带。否则，糟糕的模型会导致糟糕的预测 (对于点预测和不确定性预测)。

摘要

在这篇文章中，我们介绍了一种产生预测区间的方法，作为在预测中提供不确定性估计的一种方式。该过程基于剩余自举，并且可以几乎免费地插入到任何机器学习管道中。它不依赖于模型，并且应用范围可以扩展到任何回归任务。

查看我的 GITHUB 回购

保持联系: Linkedin

向量子门添加控制

原文：https://towardsdatascience.com/adding-a-control-to-a-quantum-gate-7a28d8a8ec40?source=collection_archive---------24-----------------------

纠缠的力量

本帖是本书的一部分: 用 Python 动手做量子机器学习 。

在量子计算中，我们使用量子变换门来改变量子位所处的状态。

作者弗兰克·齐克特的图片

例如，X 门(非门)转换一个量子位的概率振幅。它把|0⟩变成了|1⟩，反之亦然。当我们纠缠两个量子位时，我们可以改进 X 门的行为。只有当另一个量子位(控制量子位)处于|1⟩.态时，受控 x 门(CNOT-gate)才会切换一个量子位(控制量子位)的振幅

但是我们想要在受控量子位上应用的效果并不局限于转换它的振幅。CNOT 门让我们很容易地将任何量子比特转换门，姑且称之为 U，变成一个受控门。

除了 CNOT 门，我们还需要两样东西。第一件事是将 gate U 分成两半。我们必须找到一个门——姑且称之为 v，如果应用两次，就会产生期望的整体转换门 u。我们可以说是 V⋅V⋅|υ⟩=U⋅|υ⟩.简而言之，V⋅V=U 或 V=√U。因此，v 是 u 的平方根

第二件事是创建一个门，恢复门 v 的效果。通常，这是门的变换矩阵的转置。矩阵的转置(VT)是将原始矩阵 V 翻转到其对角线上(从左上到右下)。

下图描述了我们如何控制一个任意的门 u。

作者弗兰克·齐克特的图片

首先，我们在受控量子位上应用 V 门。因此，我们完成了 U 型门的一半。然后，我们纠缠量子位。因此，受控量子位翻转了它的状态。但是只有当控制量子位处于|1⟩.态时，它才会翻转它

当我们现在应用转置矩阵 VT 时，它恢复了 v 的效果。但是只有当控制量子位是|0⟩时，因为在这种情况下，CNOT-gate 没有任何效果。

相比之下，如果控制量子位处于|1⟩状态，CNOT-gate 就会翻转控制量子位的状态。它处于完全相反的状态。当我们现在应用转置 VT 门时，我们再次应用与 V 完全相反的情况。因为 VT 是 v 的反义词，本质上，如果控制量子位处于|1⟩态，我们应用 not-v⋅v——或者不是——u

最后一个非门把非 u 态变成 u 态。但是同样，只有当控制量子位处于|1⟩.态时

也许单个控制量子位还不够？也许我们想要两个控制量子位。我们使用相同的工具。

  • CNOT 门
  • 是 U 的平方根的 v 门
  • 逆转电压效应的 VT 门

这一次，门 V 已经需要成为受控门。如果不是，你可以使用 CNOT 门把任何门变成受控门。正如我们刚刚看到的。

下图显示了受控门的构造。

作者弗兰克·齐克特的图片

这个受控受控门，让我们再次称之为 u，只在两个控制量子位，q0 和 q1 处于|1⟩.态时才适用

同样，我们从应用 gate V 开始。由于这是一个受控量子位，我们使用 q1 作为控制量子位，qc 作为受控量子位。如果 q1 在|1⟩，我们应用整体变换的前半部分。

因此，我们通过应用门 V 来结束电路，其中 q0 作为控制量子位，qc 作为受控量子位。如果 q0 也在|1⟩，我们应用整体变换的后半部分。

在两者之间，我们有一个三个门的序列:CNOT，佛蒙特州和 CNOT。如果量子位 q0 和 q1 都处于|1⟩状态或|0⟩.状态，第一个 CNOT-gate 将当时受控的量子位 q1 置于|0⟩状态如果一个量子位处于|0⟩状态，而另一个量子位处于|1⟩状态，它将受控量子位 q1 置于|1⟩.状态

下图显示了应用 CNOT 门的真值表，q1 是受控量子位。

作者弗兰克·齐克特的图片

因此，只有当一个量子位在|0⟩态，而另一个在|1⟩.态时，我们才应用下面的门 VT 在这些情况下，我们应用两个 V 门中的一个，要么在起点，要么在终点。因此，总体上对受控量子位 qc 没有影响。我们对它应用了 V 和 VT 来恢复它。

如果量子位 q0 和 q1 都处于|0⟩态，我们什么也不做，让受控量子位也保持原样。只有当两个量子位 q0 和 q1 都处于|1⟩状态时，我们才应用两个 v 门，而不应用 VT 门。

VT 门之后的 CNOT 门恢复了第一个 CNOT 门的效果，因此我们也不改变量子位 q1。

如果 V 不是一个受控门，我们可以把第一个电路插入第二个电路，使之成为一个受控门。下图描绘了最终的电路。

作者弗兰克·齐克特的图片

在这种情况下，我们也需要将 V-gate 分成两半。因此，W 是 v 的平方根。

结论

总之，通过将整体效应分成两半(v)，我们可以实现一个门(u ),它依赖于处于|1⟩.状态的另外两个量子位如果没有一个控制量子位是|1⟩，什么都不会发生。如果只有一个控制量子位处于|1⟩状态，我们错过了一个 v 的应用，我们应用 VT 门来抵消我们应用的一个 v 门的影响。如果两个控制量子位都处于|1⟩状态，我们应用两个垂直门，但错过了 VT 门。这就是受控的 U 型门。

本帖是本书的一部分: 用 Python 动手做量子机器学习 。

在这里免费获得前三章。

向浓缩咖啡中加入小苏打

原文：https://towardsdatascience.com/adding-baking-soda-to-espresso-a92eaa58c681?source=collection_archive---------4-----------------------

咖啡数据科学

一项利用废弃咖啡渣下潜更深的实验

在我对用过的咖啡渣进行实验后，我观察到水流过用过的咖啡渣非常快，因此只有未提取的固体和 CO2 会影响流速。为了更好地理解二氧化碳是如何影响流速的，我决定在废咖啡中加入小苏打。

首先，我观察了两种粒径的废咖啡:

  1. 超细(< 200 微米)
  2. 精细(200 微米

然后我混合了少量的苏打粉，比如 0.2 到 0.6 克。我没有特别设计结果会释放出多少二氧化碳，但通常情况下，少量的苏打粉就能产生很大的反应。

所有图片由作者提供:左:小苏打，右:小苏打与废咖啡混合

由于气体的释放，泡沫明显增加。这里有一些来自超细粉碎的 0.6 克的图片。

事后再看冰球，地面仍有东西要提取，甚至还有一些通道。

这里的景色是从冰球底部看的。

数据分析

加入小苏打肯定会增加覆盖过滤器的时间(TCF)，时间第一(前半杯)，时间第二(后半杯)。

对于提取率(EY)，加入小苏打后，EY 也有所增加。这些粉末都没有被再利用，所以应该有一个很好的解释，因为 EY 的含量比废咖啡的预期要高得多。

我怀疑是小苏打里的钠。如果我们假设小苏打完全溶解，所有溶解的钠都进入了杯子，那么我们可以看到溶解的固体是如何与钠的估计值一致的。

基于这些估计，看起来大多数测得的 EY 可能是由于钠，但我没有办法测量溶解在杯中的钠的量。

我喜欢这个简短的实验，它展示了二氧化碳对拍摄的影响。我怀疑有人可以用用过的咖啡渣和小苏打来制作假浓缩咖啡。我不确定这能告诉我们 CO2 和可提取固体是如何改变拍摄进程的。

如果你愿意，可以在 Twitter 和 YouTube 上关注我，我会在那里发布不同机器上的浓缩咖啡视频和浓缩咖啡相关的东西。你也可以在 LinkedIn 上找到我。也可以在中和 Patreon 上关注我。

我的进一步阅读:

浓缩咖啡系列文章

工作和学校故事集

个人故事和关注点

乐高故事启动页面

摄影飞溅页

使用图像处理测量咖啡研磨颗粒分布

改善浓缩咖啡

断奏生活方式概述

测量咖啡磨粒分布

咖啡萃取

咖啡烘焙

咖啡豆

浓缩咖啡用纸质过滤器

浓缩咖啡篮及相关主题

意式咖啡观点

透明 Portafilter 实验

杠杆机维护

咖啡评论与思考

咖啡实验

使用 sympy 将置信区间添加到最大似然估计

原文：https://towardsdatascience.com/adding-confidence-intervals-to-maximum-likelihood-estimates-using-sympy-efe0552653f7?source=collection_archive---------24-----------------------

由阿玛多·洛雷罗在 Unsplash 上创作的符号

思想和理论

不漂亮，但很有趣

当在 Python 中为极值理论开发名为evt的包时，有必要为最大似然估计值添加置信区间。基于设计考虑，被认为是最佳的实现并不是最漂亮的。然而，它将为感兴趣的人提供一个有趣的读物。这篇文章涉及了统计学中一些有趣的部分，并以展示符号代数在实际代码中的威力的例子作为结束。首先，快速介绍一下发行版。

广义极值分布

广义极值分布(GEV)是在统计极值研究中出现的一种分布。极值理论不会是这篇文章的主题。精彩介绍，见本书。GEV 的概率密度函数 f 将在后面提及。它被定义为

在哪里

  • x 是随机变量，
  • γ 为极值指数，
  • μ 是位置参数，并且
  • σ 是刻度参数。

GEV 也定义为 γ 零，但这超出了范围。我们将很快回到 GEV，但是首先:让我们提供一些背景。像在最大似然估计中一样，我们将假设一个模型，并尝试用一个数据集来拟合它。幸运的是，scipy有我们掩护。接下来一个琐碎的步骤是问:这个估计有多确定？这就是置信区间的由来。不幸的是，置信区间通常带有星号。

解释置信区间

理想情况下， α %置信区间表示:平均而言，在 α %的情况下，实际值在此范围内。然而，事实往往并非如此。在解释置信区间时，记住以下几点很重要。

  • 置信区间不考虑模型误差。例如，如果假设正态分布计算误差线，但数据不是正态分布，误差线通常会关闭。
  • 置信区间是随机变量。这不需要解释，但也不应该忘记。
  • 置信区间通常不考虑偏差。置信区间通常表示估计值的方差，而不是偏差。在解释它们的时候要考虑到这一点。给定一个估计量和一个数据集，估计偏差通常成为一个先有鸡还是先有蛋的问题。使用多重估值器总是一个好的选择，尽管不是一种补救措施。

估计最大似然的置信区间

在最大似然估计中，估计置信区间有多种选择。例如:

  • 计算观测费希尔信息的估计值。在这种情况下，我们需要区分所有参数组合的 PDF。
  • 将威尔克斯定理应用于对数似然比统计。在 GEV 的情况下，这需要数值求根，特别是:最近的根。祝你好运找到那个数字并保持你的代码的通用性。
  • 如果你幸运的话，一个概率学家已经得到了估计值的渐近行为。据我所知，GEV 的情况并非如此。
  • 对数据集进行重新采样，并多次估计参数。这是计算密集型的。

因为evt包的代码应该尽可能通用，所以我选择使用观察到的 Fisher 信息。因此，我需要区分关于所有参数组合的 GEV 的 PDF。手动这是一个相当大的野兽。唯一现实的选择是:符号代数。这就是sympy发挥作用的地方。

计算观察到的费希尔信息

简单来说，Fisher 信息表示样本数据提供了多少关于分布 f ( x 的未知参数 θ 的信息； θ ，其中 x 为随机变量。在 GEV 的情况下，需要估计 3 个参数: γ 、 μ 和 σ 。基于观察到的费希尔信息的定义，我们将需要估计以下形式的矩阵元素:

其中 i 和 j 是矩阵索引，其列举了参数向量 θ 的维数，即 3。现在，有趣的部分开始了。

设计考虑

知道微分将使用符号代数来执行，我们有几个选项来将结果集成到evt包中:

  • 使用一个临时脚本做一次，然后将其复制粘贴到源代码中。这是容易出错的，在写这个的时候会很疼。
  • 在运行时评估符号差异。这是浪费。
  • 对符号微分求值一次，修改该函数，并为以后序列化该函数。例如，这必须依赖于pickle(在此插入版本问题)。另外，evt包依赖于sympy，而sympy的实际使用是一次性的。尽可能限制依赖性是最佳实践。
  • 对差异进行一次评估，并将结果作为 Python 代码存储在存储库中(ouch)。尽管它并不漂亮，但与其他选择相比，它看起来是最好的方法。

这就是我如何开始写一段我并不引以为豪的代码，但是写起来很有趣。让我们一步一步地实现。

履行

第一部分是生成模块的脚本，该模块计算观察到的 Fisher 信息。生成的模块以一个 fat 免责声明开始:

...
    'This file is not intended to be human-readable. It is generated by ``sympy/create_compiled_expressions.py``:',
    'see the generation file for further details.',
...

符号微分由sympy处理:

from sympy import symbols, exp, log, diff

x, g, a, s = symbols('x g a s')
variables = [g, a, s]

...

for row_variable in variables:
    row = []
    for column_variable in variables:
        row.append(str(
            -diff(
                diff(
                    log_f,
                    column_variable
                ),
                row_variable
            )
        )
...

通过将函数转换为str并使用其等价的numpy替换数学函数的表示来存储函数。期望值是通过取平均值得到的近似值。最后，生成的代码被存储为私有模块，以防止用户认为我是个疯子。

就是这样！好看吗？不。有用吗？是的。它能表演吗？很好。是时候关注更重要的问题了，让我们忘记我曾经写过这个。但首先，让我们发表一篇关于它的博文。

通信:steven@vangemert.dev

将地层数据添加到测井曲线中

原文：https://towardsdatascience.com/adding-formation-data-to-a-well-log-plot-3897b96a3967?source=collection_archive---------15-----------------------

使用 Python 和 matplotlib 进一步绘制测井曲线

使用 Python 的 matplotlib 库生成的最终测井曲线，包含伽马射线上的可变填充和中子密度交叉填充。图片作者。

测井曲线是地球科学和岩石物理学中常用的可视化工具。它们使得沿井眼长度(深度)采集的数据(例如，伽马射线、中子孔隙度、体积密度等)易于可视化。

我之前已经在以下文章中介绍了制作这些情节的不同方面:

  • 使用 Python 在测井图上显示岩性数据
  • 用 Python 显示随钻测井(LWD)图像日志
  • 用图形填充增强测井曲线的可视化
  • 加载并显示测井数据

在本文中，我将展示如何将这些不同的方法组合成一个单一的绘图函数，该函数允许您轻松地重用具有相似数据的代码。

对于下面的例子，你可以在我的 GitHub 知识库中找到我的 Jupyter 笔记本和数据集，链接如下。

https://github.com/andymcdgeo/Petrophysics-Python-Series

这篇文章是我的 Python &岩石物理学系列的一部分。详情可在这里找到。

我们正在使用的数据集来自于 2018 年发布的公开发布的 Equinor Volve 场数据集。本教程中使用的文件来自 15/9- 19SR 井，其中包含一组很好的测井数据。

创建可重复使用的测井曲线并显示地层数据

设置库

对于本文和笔记本，我们将使用许多不同的库。

我们将使用五个库: pandas ， matplotlib ， csv ，collections，以及 lasio 。Pandas 和 lasio，将用于加载和存储日志数据，集合允许我们使用 defaultdict 将我们的地层顶部加载到字典中。最后，matplotlib 将让我们绘制出测井数据。

加载 LAS 数据

我们将加载的第一组数据是来自 Volve 数据集的 LAS 文件。为此，我们调用las.read()函数并传入文件。一旦文件被读取，我们可以使用.df()将其快速转换成熊猫数据帧。这将使我们工作起来更容易。

要了解如何加载多个 las 文件，请点击这里查看我以前的文章。

当 lasio 将 las 文件转换为数据帧时，它会将深度曲线指定为数据帧索引。这可以转换成如下所示的列。当我们处理多个 las 文件时，这一点尤其重要，我们不希望导致具有相似深度值的冲突。

然后，我们可以打印数据帧的标题，以验证我们的数据已经正确加载。

装载地层顶部

对于本文，三个地层顶部存储在一个简单的 csv 文件中。对于每个地层，存储顶部和底部深度。要加载这个文件，我们可以使用下面的代码片段。

  • 第 1 行创建了一个空字典，将保存我们的结构
  • 第 4 行以读取模式(' r ')打开 csv 文件
  • 第 5 行允许我们跳过标题行，跳到下一行。这可以防止标题行被添加到字典中
  • 第 6 行允许我们遍历 csv 文件中的每一行。我们还可以为每一列指定字段名，如果没有指定，那么第一行中的值将被用作字段名
  • 第 7 行让我们将地层名称指定为关键字，在=的右边，我们可以创建顶部和底部深度的列表。我们需要把这些转换成浮点数

当我们调用formations_dict时，我们可以预览我们的字典包含的内容。

{'Hugin Fm.': [4316.5, 4340.0],
 'Skagerrak': [4340.0, 4579.0],
 'Smith Bank Fm.': [4579.0, 4641.0]}

为了将顶部绘制在测井图上的正确位置，我们需要计算地层顶部和底部深度之间的中点。由于深度值是列表形式的，因此可以使用索引号来调用它们，0 表示顶部深度，1 表示底部深度。

当我们调用formation_midpoints列表时，我们得到以下值:

[4328.25, 4459.5, 4610.0]

最后，我们可以给我们的队形分配一些颜色。在这种情况下，我选择了红色、蓝色和绿色。

设置对数图

在我以前的文章中，我动态地创建了这些图，代码只适用于特定的数据集。由于曲线记忆和测井曲线设置的多样性，概括测井曲线或岩石物理曲线可能很困难。在这个例子中，我将绘图部分放在了一个函数中。

使用函数是提高代码可重用性和减少可能出现的重复的一个很好的方法。

在下面的代码片段中，我解释了组成测井绘图函数的一些关键部分。

第 3–10 行设置日志轨道。在这里，我使用 subplot2grid 来控制轨道的数量。suplot2grid((1,10), (0,0), rowspan=1, colspan=3)转换为创建一个 10 列宽、1 行高的绘图，前几个轴每个跨越 3 列。这使我们能够控制每个轨道的宽度。

最后一个轨迹(ax5)将用于绘制我们的地层顶部信息。

fig, ax = plt.subplots(figsize=(15,10))#Set up the plot axes
    ax1 = plt.subplot2grid((1,10), (0,0), rowspan=1, colspan = 3)
    ax2 = plt.subplot2grid((1,10), (0,3), rowspan=1, colspan = 3, sharey = ax1)
    ax3 = plt.subplot2grid((1,10), (0,6), rowspan=1, colspan = 3, sharey = ax1)
    ax4 = ax3.twiny() 
    ax5 = plt.subplot2grid((1,10), (0,9), rowspan=1, colspan = 1, sharey = ax1)

第 14–19 行在现有轴的基础上添加第二组轴。这样，当我们拆下秤时，可以在每个轨道周围保持一个边界。

 ax10 = ax1.twiny()
    ax10.xaxis.set_visible(False)
    ax11 = ax2.twiny()
    ax11.xaxis.set_visible(False)
    ax12 = ax3.twiny()
    ax12.xaxis.set_visible(False)

第 21–49 行设置伽马射线轨道。首先，我们使用ax1.plot来设置数据、线宽和颜色。接下来，我们用标签、轴颜色和一组限制设置 x 轴。

由于ax1将是图上的第一个轨迹，我们可以指定深度(m)的 y 轴标签。

定义曲线设置后，我们可以在曲线和轨道右侧之间添加一些彩色填充。关于如何设置的详细信息，请参见用图填充增强测井曲线的可视化。

# Gamma Ray track

    ## Setting up the track and curve
    ax1.plot(gamma, depth, color = "green", linewidth = 0.5)
    ax1.set_xlabel("Gamma")
    ax1.xaxis.label.set_color("green")
    ax1.set_xlim(0, 150)
    ax1.set_ylabel("Depth (m)")
    ax1.tick_params(axis='x', colors="green")
    ax1.spines["top"].set_edgecolor("green")
    ax1.title.set_color('green')
    ax1.set_xticks([0, 50, 100, 150])
    ax1.text(0.05, 1.04, 0, color='green', 
             horizontalalignment='left', transform=ax1.transAxes)
    ax1.text(0.95, 1.04, 150, color='green', 
             horizontalalignment='right', transform=ax1.transAxes)
    ax1.set_xticklabels([])

    ## Setting Up Shading for GR
    left_col_value = 0
    right_col_value = 150
    span = abs(left_col_value - right_col_value)
    cmap = plt.get_cmap('hot_r')
    color_index = np.arange(left_col_value, right_col_value, span / 100)
    #loop through each value in the color_index
    for index in sorted(color_index):
        index_value = (index - left_col_value)/span
        color = cmap(index_value) #obtain colour for color index value
        ax1.fill_betweenx(depth, gamma , right_col_value, where = gamma >= index,  color = color)

在我以前关于对数图的文章中，每个轨迹之间都有间隙。上图中可以看到一个例子。当这个差距减小时，每个轨道的标度信息变得混乱。一个更好的解决方案是使用ax1.set_xticklabels([])关闭轴标签，并使用如下所示的文本标签。

ax1.text(0.05, 1.04, 0, color='green', 
             horizontalalignment='left', transform=ax1.transAxes)
ax1.text(0.95, 1.04, 150, color='green', 
             horizontalalignment='right', transform=ax1.transAxes)

ax.text 函数可以接受许多参数，但最基本的是ax.text(xposition, yposition, textstring)。在我们的示例中，我们还传入了水平对齐和转换参数。

然后我们对每个轴重复这一过程，直到 ax5，在这里我们需要做的就是添加一个轨道头并隐藏 x 记号。

请注意，ax4 与 ax3 成对出现，位于 ax3 之上。这使得绘制中子孔隙度数据变得容易。

第 103–113 行包含设置中子孔隙度和密度测井之间填充的代码。关于这种方法的详细信息，请参见用绘图填充增强测井曲线的可视化。

ax5.set_xticklabels([])
ax5.text(0.5, 1.1, 'Formations', fontweight='bold',
             horizontalalignment='center', transform=ax5.transAxes)

在第 118–123 行中，我们可以节省一些代码行，方法是将我们想要应用于每个轨道的常用函数捆绑到一个 for 循环中，并允许我们一次性设置轴的参数。

在这个循环中，我们是:

  • 将 y 轴限制设置为我们提供给函数的底部和顶部深度
  • 设置网格线样式
  • 设置 x 轴标签和刻度线的位置
  • 偏移轨道的顶部(脊椎),使其漂浮在轨道上方
for ax in [ax1, ax2, ax3]:
        ax.set_ylim(bottomdepth, topdepth)
        ax.grid(which='major', color='lightgrey', linestyle='-')
        ax.xaxis.set_ticks_position("top")
        ax.xaxis.set_label_position("top")
        ax.spines["top"].set_position(("axes", 1.02))

第 125–129 行包含应用于 ax1、ax2、ax3 和 ax5 的下一个 for 循环，让我们在所有轨道上添加地层阴影。我们可以在我们的formations_dict和zone_colours列表中循环通过我们的地层深度值的压缩对象。我们将使用这些值通过ax.axhspan创建一个水平跨度对象。基本上，它在两个 Y 值(深度)之间的轴上添加了一个矩形。

for ax in [ax1, ax2, ax3, ax5]:
    # loop through the formations dictionary and zone colours
    for depth, colour in zip(formations.values(), colours):
         # use the depths and colours to shade across subplots
         ax.axhspan(depth[0], depth[1], color=colour, alpha=0.1)

第 132–133 行隐藏每个轨迹(支线剧情)上的 yticklabels(深度标签)。

for ax in [ax2, ax3, ax4, ax5]:
        plt.setp(ax.get_yticklabels(), visible = False)

第 135–139 行是我们将地层标签直接添加到 ax5 上的循环的最终和关键部分。这里我们使用ax.text函数，并传入一个 x 位置(0.5 =轨迹中间)和一个 y 位置，这是我们计算的地层中点深度。然后，我们希望从中心垂直对齐文本，以便文本字符串的中心位于结构的中间。

for label, formation_mid in zip(formations_dict.keys(), 
                                    formation_midpoints):
        ax5.text(0.5, formation_mid, label, rotation=90,
                verticalalignment='center', fontweight='bold',
                fontsize='large')

在 ax5 上的地层中间绘制地层名称。

注意，如果该层较薄，那么文本将与该层的边界重叠，并进入下一层。

用我们的数据创建图表

既然我们的函数已经按照需要的方式设置好了，现在我们可以从井数据帧中传递列了。当我们使用其他孔制作设置相同的图时，该功能的威力就显现出来了。

当我们运行这个函数调用时，我们生成了下面的图

使用 Python 的 matplotlib 库生成的最终测井曲线，包含伽马射线上的可变填充和中子密度交叉填充。图片作者。

摘要

在本文中，我们介绍了如何从 csv 文件加载 las 文件和地层数据。然后将这些数据绘制在我们的对数图上。此外，我们已经了解了如何将我们的测井曲线代码转换成一个函数，该函数允许我们在其他油井中重复使用该代码。这使得未来的绘图更加简单和快速。

感谢阅读！

如果你觉得这篇文章有用，请随时查看我的其他文章，这些文章从不同的角度研究了 Python 和测井数据。你也可以在GitHub找到我在这篇文章和其他文章中使用的代码。

如果你想联系我，你可以在LinkedIn*或者在我的* 网站 找到我。

有兴趣了解更多关于 python 和测井数据或岩石物理学的知识吗？跟我上 中 。

向 PyTorch Lite 模型添加元数据

原文：https://towardsdatascience.com/adding-metadata-to-pytorch-lite-models-4d6fa45a6354?source=collection_archive---------26-----------------------

PyTorch 允许您将附加元数据与 lite 解释器模型文件相关联。本文探讨了如何使用 Python 和 C++ API 添加/检索模型元数据。

PyTorch (Lite)模型的结构

PyTorch Lite 模型基本上是包含大部分未压缩文件的 ZIP 存档。另外，PyTorch Lite 模型也是普通的 TorchScript 序列化模型。也就是说，用户可以使用 torch.jit.load 加载 PyTorch Lite 模式作为普通 TorchScript 模式。

下图显示了 PyTorch Lite 模型文件的外观，以及它存储了哪些高级组件。

PyTorch Lite 模型的格式(ZIP 文件)

以下是每个组件的含义:

  1. 常数:对应 TorchScript 模型的序列化张量。其中一些与 Lite 模型零件共享。
  2. 代码:火炬文字代码。
  3. extra :与模型关联的 extra(附加)元数据文件。
  4. 字节码:只对应于 lite 模型的序列化张量+为移动 Lite 解释器序列化字节码。

在模型生成过程中向 Lite 模型添加元数据

一旦你有了 PyTorch 模型(Python 类)，你可以把它保存为 PyTorch Lite 格式。PyTorch Lite 格式的模型可以加载到移动设备上进行推理。

因为 PyTorch Lite 模型基本上是一个 zip 文件，所以可以使用 zipfile Python 模块来检查序列化模型文件的内容。

查看与 Lite 模型相关联的元数据

还可以使用zipfile . read()方法查看 PyTorch Lite 模块中某个文件的内容。

在模型生成后向模型添加额外的元数据

因为 PyTorch Lite 模型基本上是一个 zip 文件，所以在保存模型之后，很容易向模型添加额外的元数据文件。您所需要做的就是知道顶层文件夹的名称，然后使用 Python 的 zipfile 模块将文件添加到 zip 存档中。

获取档案名称。

将新文件添加到 zip 存档中。

列出模型的内容，并打印新添加文件的内容。

使用 C++ API 从 Lite 模型中获取元数据

PyTorch C++ API 还提供了一种获取与模型一起保存的定制元数据的方法。

关于如何在移动平台上使用 PyTorch C++ API 的更详细的帖子，请参见这篇帖子。

结论

我们看到了如何用 Python 和 C++从 PyTorch Lite 模型中添加/获取元数据。同样的策略也适用于 PyTorch TorchScript 模型。其他 AI 框架如 TFLite 也支持模型元数据。

在流量预测中加入信息员模型

原文：https://towardsdatascience.com/adding-the-informer-model-to-flow-forecast-f866bbe472f0?source=collection_archive---------22-----------------------

Informer 是一个用于长序列时间序列预测的新转换模型，在 AAAI 会议上获得了最佳论文奖。

介绍

图片来自文章

变形金刚彻底改变了自然语言处理，并推动了神经机器翻译、分类和命名实体识别等领域的重大进步。最初，变形金刚在时间序列领域发展缓慢。然而，在过去的一年半时间里，出现了许多用于时间序列分类和预测的转换变量。我们已经看到了像时间融合转换器、卷积转换器、双阶段注意力和更多尝试进入时间序列的模型。最新的模型 Informer 建立在这一趋势的基础上，同时融入了几个新颖的组件。

Flow Forecast ，PyTorch 内置的时间序列预测和分类库深度学习，已经支持 transformer 的几个变体，但我们决定特别添加 Informer，因为它改善了内存使用，预测长期序列的能力，以及整体更快的推理速度。

Informer(作者、周、张上航、、彭、、、张万才)旨在改善自我注意机制，减少内存使用，加快推理速度。Informer 同时利用了变压器编码器和(屏蔽的)变压器解码器层。解码器可以在单次前向传递中有效地预测长序列。这个特性有助于在预测长序列时加快推理速度。告密者模型采用概率注意机制来预测长序列。Informer 还包括相关时间特征的学习嵌入。这允许模型生成有效的基于任务的时间表示。最后，Informer 同样可以根据任务的复杂性堆叠 n 层编码器和解码器。

概率与完全注意力

作者引入了一种概率性注意来降低自我注意的时间复杂度。与传统的 O(L)相比，这种概率注意力机制实现了 O(L log L)复杂度。传统的自我注意存在这样的问题，即只有几个关键值对对注意分数起主要作用。这意味着大多数计算出来的点积实际上毫无价值。prob 稀疏注意允许每个键只关注主要的查询而不是所有的查询。这允许模型只计算一小部分查询/值张量的昂贵运算。具体来说，ProbSparse 机制还有一个可以指定温预测的因素。该因子控制你减少多少注意力的计算。

基准数据集

作者对几个主要与电力预测相关的时间序列数据集进行了基准测试:具体来说就是电力变压器和用电负荷。他们测试预测几个不同时间间隔的数据的模型，包括他们还在天气预测数据集上测试模型。他们使用 MSE 和 MAE 作为他们的评估指标，并将 Informer 的性能与其他几个 transformer 变体以及流行的 LSTM 模型进行比较。

论文的结果。ETT(电力变压器温度)和 ECL 用电负荷。

将模型移植到流量预测中

尽管与我们的完整 transformer 模型和 Informer 有相似之处，但是出于几个原因，将模型移动到我们的框架中是具有挑战性的。最大的问题与我们的训练循环和数据加载器如何将数据传递给模型有关。因此，重构核心功能花费了相当多的时间

我们总共做了以下调整

  • 添加了解释核心组件的详细文档字符串
  • 重构了几个函数来提高代码的整洁度和架构
  • 像其他流量预测模型一样，允许多目标交换

我们仍在努力验证该模型使用我们的格式再现了原始论文的结果。然而，我们希望尽快完成这项工作。

流量预报中线人的使用

我们现在有几个关于如何在流量预测中使用 Informer 进行时间序列预测的教程。你可以访问这个 Kaggle 笔记本获得使用 Informer 的快速教程(有和没有 Wandb 都可以)。或者，您可以通过 Informer 查看该笔记本，进行全面的超参数扫描。如果您喜欢使用自己的训练循环和函数，也可以使用 Python API 直接使用 Informer。

一如既往，请留下任何意见或其他问题！

满足改善研究和患者护理的关键需求:

原文：https://towardsdatascience.com/addressing-critical-needs-for-improved-research-and-patient-care-991e5f9bd465?source=collection_archive---------42-----------------------

电子病历的数据质量和协调

电子医疗记录/电子健康记录系统(EMR)已经远远低于炒作周期的峰值。[1]几十年来，EMR 系统在很大程度上未能实现为基于患者的医学有效提供真实世界证据的承诺，主要是由于源 EMR 的数据不一致、不正确和缺失。数据质量(DQ)和协调对于从电子病历数据中获取价值至关重要。

照片由 Metamorworks 通过 iStock 授权给 Melissa

传统的和基于人工智能的方法可以用于从电子病历数据中提取、协调、整合和实现有用的结果。一个客户案例研究描述了通过将不同电子病历系统的信息合并到一个可搜索的、统一的、集成的数据库中，基于新的数据资源创建一个新的可供研究的数据资源。为此，应用了传统和先进的方法，包括流水线/API 调用、规则、基于词典的数据识别和标准化以及一种人工智能形式，特别是机器推理(MR)。[2]

多个现实世界的电子病历系统

一个场景展示了帕金森研究所和临床中心(PICC，桑尼维尔，加州)以及他们从 EMR 数据中提取、筛选、标准化、整合和实现有用结果的努力，展示了组合机器推理(一种人工智能形式)和传统数据质量方法的影响。PICC 的技术目标是创建一个新的数据资源，将来自两个电子病历数据库的信息合并到一个单一的、可搜索的数据库中，其中的内容适用于制药研究。

这两个独立的电子病历系统，来自不同的供应商，包含了不同时期的数据，这些数据是在十多年的时间里为一个普通的患者群体收集的。EMR 数据结构多种多样，包括表格、csv、解密的 XML 格式和来自 5，000 多名患者的 70，000 多份非结构化临床记录。在一些令人惊讶的案例中，医学证据与应用程序信息混合在一起(例如，软件应用程序中描述颜色和边距的代码)。EMR 系统 1 从 2004 年 9 月应用到 2011 年 2 月，包含非结构化的笔记和一些结构化的数据字段。EMR 系统 2 从 2011 年 2 月 9 日应用到 2017 年，并提供了额外的数据结构。内容没有完全从 EMR 1 移植到 EMR 2，因此两个源 EMR 系统都用于此数据质量应用程序。数据是根据 HIPAA 合规性从两个 EMR“数据转储”中提取的，并由 PICC 防火墙后维护的安全服务器进行处理。

用于协调和整合这些数据源的方法包括传统的 ETL(例如，将不同的数据源转换成通用的数据序列化；词汇匹配和规范化)和基于 SPARQL 的机器推理(例如，支持本体的推理和蕴涵)。主要目标包括研究和发表有用临床数据的发现，以及基于新数据资源的有偿合作。

挑战和技术目标

该团队面临着许多挑战。例如，源数据丰富，但显示数据输入错误以及命名和表示的多样性。在一个样本中，一种药物存在超过 190 种不同的名称和拼写变体(例如，“Stalevo”或卡比多巴-左旋多巴-恩他卡朋)。还出现了多种形式和序列化的数据，包括 XML、非结构化文本、表格和需要访问后解密的加密数据、混合应用程序和临床数据。由于 EMR 迁移问题，公共标识符(例如，EMRID、ControlID、PatientID)没有一致且全面地应用于源数据集。因此，普通患者身份识别需要结合使用受保护的个人信息和健康信息(PHI)。

为了满足 PICC 不断增长的需求和资源，需要扩展和更改数据结构和内容。还需要通过与多种标准保持一致的能力来支持协作和长期互操作性。围绕同一数据集启动的不同项目可能需要从现有报告或新来源中删除或添加特定数据字段，以及其他结构和命名转换。对于一个主要目标，最终的资源需要是研究就绪的。数据和系统还必须支持分析，包括高级搜索、模式识别和推理。

据确定，具有用于镜像和面向外的访问和研究的关系数据库表的丰富连接的“超规范化”语义数据库技术将非常适合 PICC 的主数据管理(MDM)操作。

方法与结果:实现电子病历的数据质量

数据团队应用了以前开发的词汇、工作流、基于规则和语义的数据质量产品和方法的组合来解决具有挑战性的 EMR 数据协调和集成任务。他们在传统方法的基础上实现了不同电子病历系统的临床数据集成，包括基于词典的数据识别和标准化，以及扩展到正式的本体支持的机器推理(AI)进行数据分类。数据集成建模用于测试业务规则、本体和推理的应用，以及迭代查询和新兴数据集的测试。自动 QA(例如，通过工作流)和 QC 遵循一套记录的后 ETL 测试和报告，确保数据完整性和质量。

为了满足特定的技术目标，语义系统使得快速扩展和修改研究和协作的内容和结构成为可能。初始数据集与标准化(FDA UMLS)通用术语一致，以支持标准化，并根据需要随后与其他标准化数据协调一致。语义数据管理系统支持快速重新调整不断变化的请求、标准和规范，以符合“开放世界”的设计要求和语义互操作性的长期目标。

用于提高数据质量的传统方法包括基于规则的评估和转换、通过评分字符串匹配和统计分析标准化为标准化列表(“词典”)。传统的规则和词典被用来实现在可视化数据建模环境中创建的转换规则。

基于规则的测试以及药物和疾病名称和 id 的标准化包括上下文信息的应用。这减少了时间并提高了(例如)对药物、剂量和给药途径信息的标记和审核更正的信心。具体来说，目标 API 函数被应用为微服务。

最后，在标准化后应用去识别和随机化标识符的应用，以支持 HIPAA 合规性。

AI 使能的方法包括语义本体使能的机器推理和分析驱动的机器学习。例如，部署机器推理来将数据从不同的序列化精确地移动到一个公共的期望结构中，从而减少规范化时间。

为了做到这一点，SPARQL 推理和蕴涵被用来遵循万维网联盟(W3C)标准，并使用数据质量工具来生成和应用 SPARQL。通过将传统的数据质量流程与人工智能相结合，该系统能够有效地解决两个电子病历系统中发现的复杂的数据质量和集成挑战。

组合 DQ 方法使实现电子病历数据目标成为可能 通过将传统数据质量流程与人工智能相结合，计算机科学正在解决困扰制药行业多年的挑战。通过将传统的基于工作流的数据质量处理与更先进的机器推理方法相结合，可以解决通常阻碍 EMR 系统所承诺的商业价值的关键数据质量要求。

关键的技术成果是反复交付精选的、结构化的、集成的和可搜索的电子病历数据，非常适合特定的研究和协作需求。最终的业务目标包括向多个制药合作伙伴提供定期更新的内容。在这种情况下实现的创收业务目标包括基于新数据资源的药物研究合作伙伴关系和高引用出版物。[3]主要制药公司已经从该资源中获得了几个目标数据子集，并且神经科学研究所已经获得了全部数据集(www.thenri.orgNRI.))。NRI 的下一个目标包括从数据中提供新的患者和面向市场的应用程序，这是直接从更智能和更互联的数据中开发的强大的长期优势。

参考文献:

①凯瑟琳·威利亚德。“AI 可以修复电子病历吗？”《科学美国人》2020 年 2 月 1 日:在线。<https://www . scientific American . com/article/can-ai-fix-e-medical-records/>

2)斯坦利，罗伯特。“机器推理为人工智能的成功减少时间和成本。《2020 年秋季季刊》。数据库趋势与应用。加州伯克利，2020 年 8 月。

  1. Langston，J. W .等，“多系统路易体疾病和其他帕金森病。”自然遗传学 47，1378 -1384 (2015)。

如何用三个简单的步骤解决 ML 的再现性危机

原文：https://towardsdatascience.com/addressing-mls-reproducibility-crisis-7d59e9ed050?source=collection_archive---------55-----------------------

为什么代码、训练权重、&Web GUI 是可再现 ML 的三个必要组成部分。

你可能知道机器学习(ML)有一个再现性问题。每周都有数百份预印本和论文发表在 ML 空间，但是太多的无法复制或验证[ 1 ]。因此，它们无异于炒作，损害了该领域的信任和可持续性。

可再现性问题并不新鲜，人们已经努力通过共享代码库和训练模型来解决这个问题。也就是说，任何试图复制或验证一篇 ML 论文的人都知道，这仍然非常困难和耗时。当一个模型的验证需要复制它的时候，这尤其成问题——如果你自己不能快速测试它，你怎么知道一个模型是否值得复制它呢？

图片作者。

考虑到这一点，研究人员可以做些什么来满足日益增长的透明度和再现性的期望呢？在这篇文章中，我们将讨论为什么你应该分享(1)代码，(2)预先训练的模型，和(3)网络界面，以及每一个的局限性。

共享代码很重要，但还不够

解决可重复性问题的第一步显然是共享用于生成算法的代码。理论上，这应该允许其他研究人员验证和扩展已发表的工作，因为它揭示了训练管道中所有微小但关键的细节。然而，利用回购来训练模型说起来容易做起来难，并且通常需要昂贵的工程时间和令人沮丧的调试。

按照这些思路，不用说，并不是所有的库都是平等的。像 Papers With Code 这样的组织已经可以很容易地将期刊中的文章与相应的代码链接起来，并通过像 ML 代码完整性清单这样的资源提高了链接库的标准。根据清单(现在是 NeurIPS 会议采用的标准)，存储库应该指定依赖关系、环境信息以及培训和评估脚本。这些努力简化了发布代码的过程，提高了对研究人员的期望，并提高了透明度和可重复性。尽管如此，大多数论文还是达不到这些期望，这大大加剧了复制者所需的跑腿工作和猜测。

图片作者。

即使储存库确实符合所有这些要求，复制器也可能被其他障碍阻挡。例如，许多 ML 模型是在受限数据集上训练的，比如那些包含不能公开的敏感患者信息的数据集。此外，大型组织(如 OpenAI 的 GPT-3)生产的模型可能需要花费数百万美元的计算能力来训练，这对一般的研究实验室来说是一个不可逾越的障碍。

共享一个预先训练好的模型并不是那么简单

因此，如果共享代码还不够，合理的下一步是共享训练模型本身。这消除了重复训练的需要，并且只需要传递输入，从表面上看，这听起来很简单。然而，即使可以免费获得训练过的权重，运行推理也比听起来要难。这些问题超出了环境和版本问题，可以通过简单地提供一个容器化的模型来解决(想想 Docker)。

在弄清楚如何对数据进行预处理以输入到模型中，以及如何理解另一方的输出时，仍然需要进行大量的猜测。例如，应该如何对输入进行预处理？应该使用什么版本的处理库？输出数组的索引映射到什么类标签？这些听起来可能微不足道，但这些微小的细节必须精确复制才能让模型工作。当涉及到验证一个训练好的模型时，复制者面临着上千次定义不清的切割。

图片作者。

也就是说，共享模型(并指定所有必要的文档和代码来运行它们)仍然是建立信任的好方法。但是有很多原因导致这并不总是可能的。最明显的原因是财务冲突；如果一个 ML 工程师希望将一个模型商业化，公开它可能没有意义。此外，共享模型会使创建者面临法律责任和失控；例如，如果一个临床诊断算法的模型落入坏人之手，并被用于治疗病人，那么该算法的创造者可能会受到监管法律的约束[ 4 ]。一旦一个模型被发布到这个世界上，它就不再掌握在创造者的手中。最后，有证据表明，关于训练数据的信息可以从模型权重中导出，危及数据集隐私 [ 5 。当数据集包含必须保护的敏感信息(如遗传信息或病史)时，这是一个问题。

界面允许即时测试和验证

共享一个 web 接口到一个内部托管的模型可以超越所有上述问题，允许其他人测试一个模型而不需要访问数据集、重现训练、复制预处理步骤或者调试版本和环境不匹配。复制者不能单独用一个接口重新创建或构建算法，但如果目标是保护 IP，这是一个优势。

图片作者。

像 Gradio 这样的工具使得共享 web 界面变得更加容易，Gradio 是一个开源的 Python 库，只需几行代码就可以为任何函数自动生成界面。生成的接口可以立即共享和使用。这使得研究人员可以自己验证论文的结果是否具有代表性，而不是精选的例子。

Web GUIs 还支持非程序员领域专家的验证，例如科学家和临床医生，因为运行模型不需要编码。易于使用的界面允许人群测试，激励开发处理真实数据的模型，而不仅仅是人工管理的数据集。这种更广泛的测试还可以捕捉到偏见、错误和不可预测的结果，否则这些结果可能会被隐藏起来。它还解决了责任问题；一个算法可以公开或私下共享，而模型本身不会离开服务器，并且可以由开发人员自行决定限制或删除。

结论

为了解决再现性问题，ML 的文化需要适应日益增长的透明度期望。在这篇文章中，我们已经讨论了共享代码，训练权重和网络图形用户界面的优势和局限性。这些因素中没有一个是足够的，但是它们结合在一起可以增强公众对洗钱的信心和信任。

图片作者。

参考

[1] Z .利普顿，j .斯坦哈特。机器学习奖学金令人不安的趋势 (2018)。arXiv

[2] R. Stojnic， ML 代码完整性检查表 (2020)，带代码的中型论文

[3] B. Dickson，GPT-3 的未披露的故事是 OpenAI 的转变 (2020)，技术讲座

[4] S. McKinney，A. Karthikesalingam，D. Tse，C. J. Kelly，Y. Liu，G. S. Corrado 和 Shravya Shetty，回复:人工智能中的透明性和再现性 (2020)，Nature

[5] K. Wiggers，人工智能有一个隐私问题，但这些技术可以解决它 (2019)，Venture Beat

解决数据目录身份危机

原文：https://towardsdatascience.com/addressing-the-data-catalog-identity-crisis-4373a53a2636?source=collection_archive---------26-----------------------

数据目录死了吗？一点也不。但是是时候改变我们对数据目录的看法了。

图片由 Unsplash 上的汉斯约格·凯勒提供

数据目录，实际上是过去十年中围绕元数据管理形成的整个生态系统，都需要被唤醒。作为这样一家公司的首席产品官，这可能很难写，但这并没有减少它的真实性。

数据目录死了吗？一点也不。您需要改变对数据目录的看法吗？很有可能，是的。

具有讽刺意味的是，推动数据团队之间达成共识的最重要的解决方案之一，往往是最容易被误解的。我写的当然是关于数据目录。

与十年前开发的大多数数据管理产品一样，这些工具旨在处理缓慢变化的关系数据。部署目录是为了服务于数据治理和合规性，而不是发现和民主化。不必要的官僚主义和流程往往会阻碍数据分析师寻找和理解分析所需的数据。

近年来，数据目录有了很大的发展，但今天的数据工作要求更多，该领域的许多传统产品已经不能满足需求。现代数据目录必须是实现数据操作的强大工具，它们必须支持分布式架构，并且必须能够随着企业内数据和知识需求的增长而扩展。

最近，蒙特卡洛的 Barr Moses——数据质量和可观察性工具的领先供应商——认为数据目录正在经历一场身份危机。我喜欢这篇文章，不仅仅是因为它提到了我在疫情之前最喜欢的活动之一，在酒吧喝酒。她将部署数据目录比作酒保让你自己调饮料。当应用于传统的数据目录时，这是一个很好的类比，我肯定更喜欢专业制作的鸡尾酒。

这篇文章的本质，实际上也是我从客户那里得到的许多问题，是关于改善数据工程师的日常工作体验的。承担着满足极其严格的 SLA 这一不值得羡慕的任务，同时使用更复杂且不断变化的工具的人。最终归结为一个简单的问题:现代数据目录应该如何使数据工作更容易、更快、对您的组织更有价值？下面我将介绍巴尔在文章中提到的几个领域:

  • 自动化 —可操作的数据需要自动化，而不仅仅是扫描模式和计算查询日志中表被引用的频率。在 data.world，我们依靠知识图表从所有可用的元数据中进行推断，并在出现需要立即关注的问题时自动提醒数据工程师和管理员
  • 可扩展性 —现代数据目录必须扩展到结构化数据模型之外，以涵盖从 API 到流到流程的一切，甚至将度量和业务领域关联起来。如果对要编目的内容加以限制，就有可能丢失数据的潜在关键上下文。知识图和开放标准再次成为了答案——为您提供了一个灵活且可扩展的元数据模型，可以真正地对您组织的所有数据资产进行编目。
  • 分布式架构 —数据重力和应用孤岛已经让统一数据的概念成为了白日梦。现代数据目录必须采用数据网格范式，并支持虚拟化和 联合 数据访问。数据分析师应该能够根据数据的含义而不是其驻留的数据存储库来探索和理解数据。与此同时，数据工程师和监管人员应该拥有完整的血统、可审核性和关于数据使用方式的指标，以确保安全性和合规性。我们称之为最后一英里治理，它为真正的数据供应链效率扫清了最后一个障碍。

您的数据和分析前台系统

如果数据仓库、管道和转换工具是数据和分析工厂线，那么数据目录就是前台。生成元数据(如数据质量、可观察性、分类和谱系)的 DataOps 应用程序会创建需要由数据科学家和工程师(前台办公人员)使用的信息。但是，如果不深入研究十种不同的应用程序，他们如何获得这些信息呢？就像优秀的销售 CRM 工具一样，数据目录必须让这些信息触手可及，以实现出色的数据发现和可再现的分析。

要让数据目录克服“身份危机”并真正成为前台系统(如果您愿意，可以称之为知识操作系统)，它们必须具备以下品质:

  • 信息辐射器 —一站式解决方案，可自动聚合任务关键型数据运营元数据，并以可快速消费的方式呈现给您的数据和分析社区。基于知识图的元数据模型可以快速、轻松地整合关于数据的新信息，使这项任务变得更加容易。
  • 协作中心 —与您的数据资产相关的要采取的行动和要做的工作的中央交换所。通过将数据生产者和消费者聚集在一起，并使他们能够实时地一起采取行动，您可以迭代地克服阻碍可再现和可信赖的分析的知识差距，而无需繁琐的手动记录工作。通过虚拟化和联合查询架构以及最后一英里数据治理来支持数据网格架构，对于真正鼓励摆脱物理数据存储束缚的数据协作探索至关重要。
  • 开放生态系统 —您的数据架构中目前流行的工具与您的团队一年前使用的工具相同吗？三年前？数据和分析生态系统正在快速变化，因此作为数据运营前台的现代数据目录必须建立在开放和可扩展的标准之上，这一点至关重要。这确保您可以快速将新工具整合到您的工作流程中，这样就不会产生新的孤岛。

最后，也是最重要的一点，如果您的数据人员不使用目录，这一切都无关紧要。事实上，我相信数据目录能够并且应该为整个数据和分析团队以及依靠他们的工作来做出关键业务决策的利益相关者“带来欢乐”。这是我们 data.world 精神的一部分，在这里，数据目录的采用不仅仅是客户满意度的衡量标准，也是我们自身成功的晴雨表。

我们将我们的业务建立在教导客户如何采用敏捷数据治理和 DataOps 的基础上，就像敏捷软件工具的早期供应商必须做的那样，并通过帮助他们在特定用例上取得早期成功，而不是“煮沸海洋”

正如巴尔在她的文章中所写的，“数据目录只有在设计时考虑到目的时才是有用的。”在 data.world，我们的目标是让个人、团队和公司能够将复杂、难以理解的数据和元数据转化为推动商业和社会发展的有用知识。这是一杯通往成功的鸡尾酒——一杯你不必亲自调制的鸡尾酒。

解决机器学习中的“黑箱”问题

原文：https://towardsdatascience.com/addressing-the-issue-of-black-boxes-in-machine-learning-f86429acbb2a?source=collection_archive---------18-----------------------

模型可解释性

在模型预测中创造更多透明度和可解释性的 4 个必须知道的技术

照片由威尔·波拉达在 Unsplash 上拍摄

毫无疑问，近几十年来，机器学习模型席卷了整个世界。他们识别模式和生成预测的能力远远超过任何其他形式的统计技术，这是真正了不起的，很难与之抗衡。

然而，尽管它有很多有希望的优势，许多人仍然持怀疑态度。具体来说，机器学习模型面临的主要挫折之一是缺乏透明度和可解释性。

换句话说，尽管机器学习模型非常能够生成非常稳健和准确的预测，但当人们试图检查和理解这些预测背后的逻辑时，往往会以复杂性为代价。

在本文中，我们的目标是通过回答两个基本问题来解开和解决黑盒模型的问题:

  • 模型认为数据中的哪些特征最重要？
  • 在宏观意义上以及在个案基础上，每个特征如何影响模型的预测？

为了帮助我们回答这些问题，我们将探索 4 种独特的技术，并讨论如何使用每种技术来提高模型预测的透明度:

  • 特征重要性
  • 排列重要性
  • 部分相关图
  • SHAP 价值观

因此，如果您准备好开始剥离并检查您的模型如何准确地使用输入数据进行预测，让我们开始吧！

这篇文章的参考笔记本可以在这里找到。

数据描述和准备

医疗费用个人数据集提供了居住在美国的 1，338 名投保人的保险费用及其个人信息，例如:

  • 年龄
  • 性
  • 身体质量指数(身体质量指数)
  • 儿童人数
  • 吸烟状况
  • 居住区

数据的前 5 行

由于保险费用是一个连续变量，这是一个回归问题。我还决定使用随机森林回归作为我们的选择模型。

出于本文的目的，让我们不要太担心使用哪个模型，而是将我们的注意力更多地放在学习如何解释我们的模型预测的结果上。

# Feature encoding 
data['sex'] = data['sex'].map({'female': 1, 'male': 0})
data['smoker'] = data['smoker'].map({'yes': 1, 'no': 0})
data = pd.get_dummies(data)# Predictor and target variables
X = data.drop('charges', axis = 1)
y = data.charges# Train test split
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size = 0.2, random_state = 42)# Fit random forest model
rf = RandomForestRegressor(random_state = 42).fit(X_train, y_train)

特征重要性

几个月前我写过一篇文章，题目是特征选择降维。那篇文章中讨论的技术之一叫做特性重要性。

本质上，当使用任何基于树的模型时，例如决策树、随机森林或梯度推进，每个特征将被分配一个“特征重要性”,其强调该特征在进行预测时对模型的重要性。

为了理解特征重要性背后的直觉，我们首先讨论决策树算法实际上是如何工作的是很重要的。

图片来源丹·贝克尔，卡格尔

回想一下，当决策树模型适合定型数据时，决策树中的每个节点都表示模型用来将数据分成组的单个功能。这里的目标是以这样一种方式分割数据，即在每次分割后，目标变量中具有相似值的数据最终出现在同一个组中。

换句话说，我们希望表现出相同特征的数据被分组在一起，以便当新的看不见的数据进来时，我们的模型将能够通过从树的顶部向下遍历到树的底部来预测其最终值。

模型是如何决定每个节点使用哪个特性的？嗯，决策树算法经过优化，减少了基尼杂质(分类)和方差(回归)。基尼系数表明了一个观察值被错误分类的概率，而方差表明了一组观察值离均值有多远。因此，在树的每一层，模型将确定给出最低杂质分数或最低方差的特征。

如果你想了解更多关于基于树的模型是如何工作的，可以看看我下面的文章:

[## 整体之战——随机森林 vs 梯度推进

towardsdatascience.com](/battle-of-the-ensemble-random-forest-vs-gradient-boosting-6fbfed14cb7)

现在，回到特征重要性。特征重要性衡量特定特征在帮助我们的模型最小化损失函数方面的有用程度。一个特征在将数据点分成不同的类别方面做得越好，该特征对模型就越重要。

下面是如何在实践中计算和可视化特征重要性。

# Calculate feature importance
importances = rf.feature_importances_
std = np.std([tree.feature_importances_ for tree in rf.estimators_], axis = 0)
indices = np.argsort(importances)[::-1]# Plot feature importance
plt.figure(figsize = (10, 5))
plt.title("Feature importances")
plt.bar(range(X_train.shape[1]), importances[indices], yerr = std[indices])
plt.xticks(range(X_train.shape[1]), X_train.columns[indices], rotation = 90)
plt.show()

特征重要性

正如我们从图表中看到的，3 个最重要的特征是:

  • 吸烟者
  • 身体质量指数
  • 年龄

这一结果似乎是合理的，因为吸烟习惯、身体质量指数和年龄都是一个人健康状况的常见指标，因此也是他们支付健康保险费的常见指标。

排列重要性

另一种类似于特征重要性的技术叫做排列重要性。

实际上，一旦我们的模型被训练好，排列重要性包括在验证数据中改组单个特征，将目标和其他列留在原位，并随后评估现在改组的数据中预测的准确性。

这种方法有效的潜在原因是，如果我们在进行预测时打乱一个对我们的模型不重要的特征，准确性将在整个排列过程中保持相当一致。另一方面，如果由于重新混合而导致精度下降，则表明该特征对模型很重要。

让我们看看这在实践中是如何工作的。

# Permutation importance 
perm = PermutationImportance(rf, random_state = 42).fit(X_val, y_val)
eli5.show_weights(perm, feature_names = X_val.columns.tolist())

排列重要性

正如我们所看到的，我们从排列重要性中得到的结果与在特征重要性中得到的结果几乎相同。表顶部的值是最重要的特性，底部的值最不重要。

作为重新洗牌的结果，将会有一定程度的随机性。因此，正负符号后的数字说明了这种随机性，因为它衡量了一次重组与下一次重组之间的性能差异。

部分相关图

到目前为止，我们已经接触了两种技术，帮助我们确定哪些变量对模型预测影响最大。

如果我们想进一步研究 和 如何影响预测呢？接下来我们将探讨的两项技术可以帮助我们完成这项任务。

为了绘制部分相关图，我们反复改变我们感兴趣的变量的值，并基于这些值进行一系列预测。

现在让我们看两个实际的例子。假设我们想知道身体质量指数和年龄如何影响投保人的保险费。

*# Create data to plot 
pdp_bmi = pdp.pdp_isolate(model = rf, dataset = X_val, model_features = X_train.columns, feature = 'bmi')*# Plot data*
pdp.pdp_plot(pdp_bmi, 'bmi')
plt.show()*

身体质量指数特征的部分相关图

正如我们所见，溢价水平在身体质量指数= 25 左右开始上升，在再次上升之前略有下降。

**# Create data to plot*
pdp_age = pdp.pdp_isolate(model = rf, dataset = X_val, model_features = X_train.columns, feature = 'age')

*# Plot data*
pdp.pdp_plot(pdp_age, 'age')
plt.show()*

年龄特征的部分相关图

另一方面，我们看到保费水平随着年龄的增长而不断增长，尽管增长速度不同:

  • 40 岁前
  • 年龄在 40-60 岁之间
  • 60 岁及以上

我们还可以执行二元或二维 PDP，向我们展示两个特征之间的相互作用。

*# 2D partial dependence plot 
features_to_plot = ['bmi', 'age']
inter = pdp.pdp_interact(model = rf, dataset = X_val, model_features = X_train.columns, features = features_to_plot)
pdp.pdp_interact_plot(pdp_interact_out = inter, feature_names = X_train.columns, plot_type = 'contour')
plt.show()*

2D 部分相关图

我希望现在你能看到并理解部分依赖图所提供的额外的复杂性。

使用这种技术，我们现在不仅知道哪些特征对我们的模型是重要的，而且更重要的是，这些特征实际上如何影响模型预测。

SHAP 价值观

SHAP 是沙普利附加解释的简称。它分解了一个单独的预测，以展示每个起作用的特征的影响。这使我们能够在更具体的基础上研究模型预测。

例如，这种技术对于银行和保险公司等金融机构特别有用。如果银行拒绝客户的贷款，法律要求银行解释拒绝贷款的依据。同样，如果保险公司选择不承保某人的保险，该公司有义务向该人说明理由。

SHAP 值解释了某个特征具有某个值与该特征具有某个基线值的预测相比所产生的影响。

因此，数据集中的每个要素都有自己的 SHAP 值，所有 SHAP 值的总和将解释特定预测和基础值之间的差异，其中基础值是模型输出对训练数据的平均值。此外，我们还可以使用图形来可视化 SHAP 值的分解。

假设我们想要检查验证数据的前 3 行的 SHAP 值。

验证数据的前 3 行

首先，我们需要定义一个函数来计算和可视化 SHAP 值分解。

*# Define SHAP plot function 
shap.initjs()
def shap_plot(index):
    explainer = shap.TreeExplainer(rf)
    shap_values = explainer.shap_values(X_val)
    res = shap.force_plot(explainer.expected_value, shap_values[index], X_val.iloc[index])
    return res*

一旦我们的函数准备好了，我们只需要简单地传入我们想要调查的行的索引。让我们从验证数据的第一行开始。

*# First row 
shap_plot(0)*

验证数据的第一行

那么，你到底是怎么解读这个的？

首先，模型预测保险费用为 9，543.19，低于基础值 1.355e+4。

导致预测增加的特征值用粉色表示，而导致预测减少的特征值用蓝色表示。每个彩色条的长度显示了该特征对最终预测的影响程度。

在这个特定的场景中，因为预测值低于基准值，所以所有蓝色条的长度加起来都大于粉色条的长度。具体来说，如果从蓝色条减去粉色条，它等于从基础值到预测值的距离。

此外，我们还可以观察到，吸烟者= 0(即不吸烟者)是降低该特定个人的保险费用的最重要因素。

现在让我们再看两个例子。

*# Second row
shap_plot(1)*

验证数据的第二行

*# Third row
shap_plot(2)*

验证数据的第三行

总之，在本文中，我们讨论了 4 种不同的技术来检查和解释模型预测:

  • 特征重要性
  • 排列重要性
  • 部分相关图
  • SHAP 价值观

希望有了这些新知识，您现在不仅可以开始检查哪些特征对您的模型很重要，还可以检查它们对模型预测的确切影响。

我想机器学习毕竟是一个黑箱，是吗？

非常感谢您的阅读。欢迎随时连接或关注我，了解更多未来内容！

跟我来

  • GitHub
  • 领英
  • YouTube
  • 中型

绝热量子计算 1:基础和绝热定理

原文：https://towardsdatascience.com/adiabatic-quantum-computation-1-foundations-and-the-adiabatic-theorem-8378d3b58212?source=collection_archive---------12-----------------------

不太为人所知的量子计算机类型，更容易构建，更容易理解，而且(可能)同样强大。

戴维·拉托雷·罗梅罗在 Unsplash 上的照片

我刚刚在澳大利亚国立大学完成了我的荣誉论文，论文提出了钻石如何被用作绝热量子计算机。然而，在这个项目中，我意识到很少有人知道绝热量子计算机是什么，即使是在更广泛的量子计算领域。

这个系列针对具有一些 Python 技能的 quantum 初学者，试图通过计算透镜解释它是什么，每篇文章也是一个笔记本，可以在 Deepnote 上执行，并在顶部链接。运行笔记本这里。该系列将按如下方式进行

  1. 基础知识和整个努力所依赖的:绝热定理。
  2. 使用二次无约束二元优化框架以及与伊辛模型的同构来构建计算模型。
  3. 最重要的限制:量子位元连接性、数学图形和次要嵌入问题。
  4. 模拟理想和有噪声的绝热量子计算机，并运行一些实验。
  5. 讨论围绕计算复杂性、量子加速的争论，以及我对空间未来的看法(以及对我的研究的见解)

让我们开始吧！

量子计算是目前的一个热门话题，有望彻底改革加密技术，促进新药的发现，并推动机器学习的障碍。为了实现这些承诺，有两种根本不同的方法来实现量子计算。这些是

  1. 基于门的量子计算

如果你对量子计算有基本的了解，这几乎肯定是你读到的。这就是著名的 Shor 素数分解算法(破解加密)和 Grover 搜索算法。此外，这也是谷歌、IBM、霍尼韦尔等公司目前正在投资的方法。基于门的量子计算机应该以与当前经典计算机相同的方式来考虑，在经典计算机中，它执行一系列转换(逻辑门)来得出特定的结论。我将称这种方法为数字计算。

2.绝热量子计算

本系列的重点是另一种不太为人所知的量子计算。与基于门的方法相反，绝热量子计算机是模拟计算机。我认为描述模拟计算的最佳方式是通过类比。假设你想把两个声波加在一起。数字方法将涉及找到声音信号的离散编码，并用编程语言编写一种算法，在每个时间点将两种波相加。然而，您可以通过简单地找到两个扬声器，并通过扬声器播放声波来构建问题的物理模拟。然后，通过介质播放波的流体动力学(或任何物理学)为你做计算，你只需记录结果。

已经可以(在理论上)使用绝热量子计算机解决的问题是旅行推销员问题、最大割问题和许多其他极具挑战性的组合优化问题。

在这个系列中，我将尽量避免谈论任何量子力学，除非绝对必要。

绝热定理

绝热量子计算的整个基础是(量子力学的)绝热定理。在对我们最有用的表述中，它指出

  • 如果一个量子态被初始化为一个系统的基态，那么该系统的任何足够小的变化将(很有可能)使其保持在基态。

这为任何绝热计算提供了一个非常简单的程序

  1. 将状态初始化为一个易于实现的初始系统的基态
  2. 设计一个目标系统，其中基态编码了一些有趣问题的解决方案
  3. 从初始系统到目标系统的过渡要足够慢，使得所有的变化都很小，并以目标系统的基态结束
  4. 读出最终状态，它应该是基态，被构造来解决你的问题

对于本文的代码，我想演示以下每个重要的概念

  • 从薛定谔方程看特定系统中量子态的演化
  • 从初始系统到最终系统的转变如何快速激发量子态进入许多更高能态
  • 如何从一个初始系统慢慢过渡到一个最终系统，使大部分量子概率保持在基态。

好了，现在让我们深入代码部分！

你完全可以跳过这里的一些细节

建立

因为我们使用数值模拟来工作，我们将空间的位置和动量离散化。

现在我们想从一个初始系统过渡到一个目标系统。量子力学中的‘系统’是识别某一状态能量的方法，被称为哈密顿量。对于这个例子，我们将使用一个最简单的哈密尔顿函数，它是以下形式的二次函数

我们喜欢物理中的二次型，因为它使其他数学变得简单。

这给出了被充分研究的量子谐振子(它具有态的解析解。

回想一下，我们想在一段时间内从初始状态转换到最终状态

在本例中，我们线性增加 V_T 的重要性，同时降低 V_i，这不一定要线性进行，事实上，我们正在积极研究这样做的最佳“时间表”。

模拟薛定谔演化

量子系统根据薛定谔方程演化，薛定谔方程是一个偏微分方程。对于物理学家来说，注意这里我使用自然单位(ℏ=1)

因为我想用数值模拟，我需要使用一种方法来积分偏微分方程。我使用了分步傅立叶方法，为此我找到了一个使用薛定谔方程的教程

分步傅里叶方法所需的函数，可以安全地用于任意一维势，如果你想亲自尝试的话。

我想展示的是

对于两个不同的 t_total 值，我想从一个初始势 V_i 过渡到 V_T。一个是快速的(许多激发态发生的地方)，一个是缓慢的，大部分概率停留在基态。我想表明，在缓慢的演化过程中，大部分概率保持在基态..

请注意，右边的柱状图显示了特定波函数的“基态”或“激发态”程度。虽然研究过量子物理学的人会知道这意味着什么，但实际上推迟到下周的文章再介绍更有意义。对于第一次接触这个问题的外行读者来说，左边的条形越大越好，因为这是对基态可能性的一种度量，这也是我们在开始构建时想要的。

缓慢的进化

当我们从我们的初始势/哈密顿量/系统慢慢进化到我们的目标哈密顿量时，我们看到绝大多数的概率保持在基态，如左边的柱状图所示。我们可以看到，这是因为只需要很小的变化就可以实现。如果进一步增加 max_t 和 t_total，这将继续是一个更好的近似值。

动画(代码可以在笔记本中找到)显示

这些都是很慢的 gif，不幸的是，笔记本上有更快更漂亮的版本。

在整个演化过程中，绝大部分概率保持在基态，只有极小的激发需要使波函数保持在基态。注意，这里基态是相对于电势的瞬时基态来定义的。

快速进化

相反，我们可以立即看到，遵循完全相同的程序，但将电势改变 3 倍更快会导致激发态的大激发。这违反了变化足够慢的绝热条件，意味着这在绝热量子计算中没有用。

相反，我们看到，跃迁越快，波函数中的“基态”就越少。这意味着，对于有用的绝热计算来说，这显然太快了。

你应该带走什么

第一次接触量子力学和绝热定理应该已经向你表明了这一点

  • 如果你可以从一个系统的基态开始，那么缓慢的进化意味着你将大部分时间停留在基态
  • 我们可以通过同时增加一个系统的强度(前因子),同时降低另一个系统的强度来“权衡”两个系统的强度，从而允许一种完全通用的方式来实现缓慢的进化
  • 只要 我们能想出如何将一个问题的解编码成基态，这就允许一个单一的、通用的构造来进行计算 。

我们下周要讲的内容

  • 转向具有二进制值的量子位
  • 产生将一个问题的解编码成基态所需的精确结构。

运行这里编写的代码

我使用在线 Jupyter 笔记本编辑器 Deepnote 编写了所有这些代码，如果你点击这里你可以看到这篇文章发表在那里，点击“在 Deepnote 中启动”按钮复制笔记本并从头开始运行它！

请随时联系我，对这种写作风格给予反馈，并提出您的任何问题，以便我可以在下周的文章中解决它们！

采用以数据为中心的机器学习项目

原文：https://towardsdatascience.com/adopting-data-centric-machine-learning-projects-75a8aaec8f53?source=collection_archive---------37-----------------------

一旦为机器学习项目制定了商业案例，就该深入研究数据集了。通常，对数据的正确理解和使用可以带来重大的性能改进。这篇文章揭示了以数据为中心的机器学习。

照片由来自 Pexels 的 Markus Spiske 拍摄

成功的机器学习产品来自于在好的数据集上应用的好的算法和好的参数。机器学习库/框架正变得越来越标准化，围绕它们的最佳实践也广为人知。学习正确参数的机制和工具也越来越成熟。一旦组建了一个熟练的团队，整合一个可行的解决方案并不困难。虽然社区的大多数人都在寻找下一个最好的算法或策略，但他们并没有让业界更容易、更便宜或更快地推出 ML 产品。

这是因为找到正确的数据集不是一件容易的事。大多数方法都是基于高度校准的数据开发的，因此，在包含大量杂乱数据的现实世界部署中会失败很多。当这些方法被应用到杂乱数据的子集时，杂乱数据很有可能充满了虚假的相关性，并且没有足够的可变性。除非已经开发出一种复杂的建模技术来处理这种情况，或者已经开发出一种可扩展的框架来创建无垃圾的干净的复杂数据，否则我们只能使用自己的设备。我祈祷并希望解脱早日到来。

在此之前，我有一个不成熟的想法，就是在工业环境中朝这个方向努力。这个想法的方向是建立一支技术人员队伍，他们知道如何在缺乏可扩展的复杂工具的情况下以数据为中心。

在人工智能团队中引入数据专家

为组织引入更多数据专家。图片由作者提供。

行业新人太执着于方法。问题源于学术界、大学、课程、新兵训练营等。，它太注重学习数百种方法，而不是将一种方法实际应用于现实问题。这是一个文化问题，我们可以改变它。以下是一些可行的想法:

  • 冠军团队中有经验的人，他们真正理解数据的意义，能够将数据中的模式与业务流程联系起来。如果我们想解决很多问题，我们需要很多。
  • 如果你没有那些人，那就让他们成为一体。把 20%的空闲时间给那些不仅愿意发现数据的意义，而且愿意发现这些数据所讲述的故事的人。
  • 创建允许人们分享和讨论数据意义和故事的论坛，从而激励更多人成为其中一员。
  • 创建一个学术项目，允许许多人在数据分析和领域数据方面高效地提高技能。

开始时，它会很慢并且容易出错。然而，一旦足够多的人实现了飞跃，即专注于学习数据，这将是自我维持的。

敏捷数据探索

使用 Databricks Workspace 进行敏捷数据探索。图片由作者提供。

避免每次都搜索完美的数据集。要有效率。找到一个足够小的数据集来捕捉一些有意义的见解。形成一个直观的假设，并围绕它建立精益分析解决方案。解决方案应该是可解释的，而不是黑箱。因此，它不需要成为一个复杂的 ML 方法，它可以是一个商业启发的数学公式或一个老派的 ML 方法。如果你不相信，稍微改变一下方法或者探索不同的数据区域。如果您确信找到了正确的数据区域，请停止探索，并发布您的发现以及定义数据区域的标记。

为了方便发布和发现感兴趣的数据集，请为大规模可搜索仪表板和数据集构建平台。要构建这样的功能，请关注一个引擎，它允许连接不同的数据集、对数据集运行查询、构建仪表板以及归档代码、仪表板和元数据。一旦您在开发平台方面取得了一些进展，就要努力提高平台的采用率。一个有机的方法是雇用平台成功专家，专注于创建一些令人敬畏的平台演示，一个教育计划，教导组织中的人如何在平台上工作，以及成功故事的定期演示。

系统的数据清理和注释

鼓励 ML 团队积极追求数据清理和注释的技术。在这种情况下，干净的数据不仅意味着语法上正确的数据，还意味着语义上有用的数据。这可能意味着删除只是以虚假相关的形式添加噪声的行，增加合成行以突出模糊但必要的模式。

不可能对所有数据都有一个明确的制胜策略。来自行业的数据，尤其是全球范围的数据是多方面的，并且有自己的清理和注释问题。因此，可能会出现过多的策略。让团队更容易发布这些技术，以便它们可以在相同/相似数据集的其他用途中重新应用。

例如，处理来自渠道的销售数据的团队可以发布清理和注释这些数据的方法，以库的形式提供示例数据和证明其有效性的文档。可以使用通用模板，以便以统一的方式实现和记录该库。这种统一的设计将为在这些库上构建搜索引擎铺平道路，从而为轻松发现铺平道路，并因此增加这些库的采用。最终，大众将决定一些获胜的策略，这将为一致的数据清理和注释策略铺平道路。

以数据为中心的数据科学

我完全意识到这个标题的无用。然而，我故意犯的错误应该会让人们更加关注那些走向错误方向的行业及其供应商。数据科学实践意味着大量关注数据。不幸的是，我们似乎支持复杂的方法，却牺牲了获取干净有用数据的时间。

避免用功能推出来压倒 ML 团队的时间表。相反，鼓励他们加入数据专家运动，开发获取干净数据的技术。没有人能比使用数据的团队做得更好。我们要做的就是选出一堆中的赢家。

数据科学是经验性的。然而，这并不一定是针对方法 A 和 b 运行实验，也可以是针对数据集 D 和 D*使用方法 A 运行实验。

在开发 ML 工作流时，选择稳定的艺术状态，易于执行的算法(以及一组众所周知的参数设置)。不要从处理万亿字节的数据开始。找到一个足够好的数据大小来覆盖足够的方差。一个很好的经验法则是尝试将数据放入一台正常大小的机器的内存中。如果解决方案给出了可接受的评估结果，通过更新其特征选择或参数选择方法，使该方法更复杂一些。重复，直到你觉得你已经很好地理解了数据。当你不能从你的解决方案中得到更多的果汁时，你会创造一个好的直觉，什么样的特征值和模型权重会导致一个好的结果。然后增加数据覆盖面，进入下一个层次。

因此，解决方案的一部分必须存在，以找到正确的数据集。它必须足够端到端，包括模型开发和评估，这样就可以很容易地选择更好的数据集。采用群体智慧的方法。当少数人开发解决方案时，评估解决方案的质量应该由整个团队来完成。这意味着，整个团队，最好是非常了解数据的团队，坐在一起通过确定已经选择了正确的数据集来训练模型，从而对正确的解决方案做出判断。

试着站在巨人的肩膀上。当来自敏捷数据探索或被广泛采用的数据清理库的流行见解存在时，在创建自己的见解或实现之前，首先考虑这些。至少验证一下它们的可用性。

评论

我对此很有经验吗？不。以数据为中心的模型开发不是一个受欢迎的想法。然而，我已经看到了足够多的其他方法失败的证据，可以把它作为一个补充的选择。我将鼓励我的团队更加以数据为中心，并定期评估方法的有效性。当有趣的事情发生时，我会随时通知你。

通过将知识从交叉编码器转移到双编码器来改进 BERT 模型

原文：https://towardsdatascience.com/advance-nlp-model-via-transferring-knowledge-from-cross-encoders-to-bi-encoders-3e0fc564f554?source=collection_archive---------5-----------------------

改进用于成对句子评分任务(语义句子任务)的 SBERT 双编码器的数据扩充方法

蒂姆·莫斯霍尔德在 Unsplash 上的照片

📚背景和挑战

C 目前，最先进的自然语言处理架构模型通常重用 BERT 模型，该模型是在大型文本语料库(如维基百科和多伦多图书语料库)上预先训练的。通过微调深度预训练的 BERT，发明了许多替代架构，如 DeBERT、RetriBERT、RoBERTa……这些架构在各种语言理解任务上实现了基准的实质性改进。在 NLP 中的常见任务中，成对句子评分在信息检索、问题回答、重复问题检测或聚类中具有广泛的应用，...通常，有两种典型的方法被提出:双编码器和交叉编码器。

  • 交叉编码器[2]: 对给定的输入和标签候选项执行完全(交叉)自我关注，并且倾向于获得比它们的对应物高得多的精确度。但是，它必须为每个输入和标签重新计算编码；结果，它们不可能检索端到端的信息，因为它们不能产生输入的独立表示，并且在测试时非常慢。例如，10，000 个句子的聚类具有二次复杂度，并且需要大约 65 个小时的训练[4]。

交叉编码器

  • 双编码器[3]: 分别对输入和候选标签执行自我关注，将它们映射到一个密集的向量空间，然后在最后将它们组合在一起，形成最终的表示。因此，双编码器能够索引编码的候选，并比较每个输入的这些表示，从而导致快速的预测时间。在聚类 10，000 个句子的相同复杂度下，时间从 65 小时减少到大约 5 秒[4]。先进的双编码器 Bert 模型的性能由泛在知识处理实验室(UKP-TUDA)展示，它被称为句子-BERT (SBERT)。更多细节，本文指出使用 SBert 双编码器 的手动教程。

双编码器

另一方面，没有一种方法在所有方面都是完美的，双编码器也不例外。与交叉编码器方法相比，双编码器方法通常实现较低的性能，并且需要大量的训练数据。原因是交叉编码器可以同时比较两个输入，而双编码器必须独立地将输入映射到一个有意义的向量空间，这需要足够数量的训练样本来进行微调。

为了解决这个问题，人们发明了多编码器。多编码器利用两个独立的变压器(类似于交叉编码器)，但是只在顶层的两个输入之间应用了注意力，从而比双编码器获得了更好的性能增益，比交叉编码器获得了更大的速度增益。然而，多元编码器仍然有一些缺点:由于非对称的得分函数，它们不能应用于具有对称相似关系的任务，并且多元编码器表示不能被有效地索引，导致具有大语料库大小的检索任务的问题。

多元编码器

在这篇文章中，我想介绍一种可以有效地使用交叉编码器和双编码器的新方法——数据扩充。这种策略被称为增强 SBERT (AugSBERT) [6]，它使用 BERT 交叉编码器来标记一组更大的输入对，以增强 SBERT 双编码器的训练数据。然后， SBERT 双编码器在这个更大的增强训练集上进行微调，这产生了显著的性能提高。其思路与计算机视觉中的 关系推理自监督学习 非常相似。所以简单来说，可以认为是自然语言处理中的自监督学习。更多细节，将在下一节介绍。

📖技术亮点

对于成对句子回归或分类任务，扩展 SBERT 方法有三种主要情况。

场景 1:完整的带注释的数据集(所有带标签的句子对)

在这种情况下，应用直接数据扩充策略来准备和扩展标记数据集。最常见的有三个层次:字、词、句。

文本扩充级别

然而，单词级是最适合句子对任务的级别。基于训练双编码器的性能，有一些建议的方法:通过上下文单词嵌入来插入/替换单词(BERT、DistilBERT、RoBERTA 或 XLNet)或通过同义词来替换单词(WordNet、PPDB)。在创建了增强的文本数据之后，它将与原始文本数据相结合，并适合双编码器。

然而，在少数标记数据集或特殊情况下，所示的简单单词替换或增量策略对句子对任务中的数据扩充没有帮助，甚至导致与没有扩充的模型相比更差的性能。

简而言之，直截了当的数据扩充策略包括三个步骤:

  • 步骤 1:准备了全标记语义文本相似性数据集(黄金数据)
  • 第二步:替换配对句中的同义词(银色数据)
  • 步骤 3:在扩展的(金+银)训练数据集上训练双编码器(SBERT)

用全注释数据集训练 SBert 双编码器

场景 2:有限或较小的带注释的数据集(少数带标记的句子对)

在这种情况下，由于有限的标记数据集(黄金数据集)，预训练的交叉编码器用于弱标记未标记数据(相同域)。然而，随机选择两个句子通常会导致不相似(否定)对；而阳性配对极其罕见。这使得银数据集的标签分布严重偏向负对。因此，建议采用两种适当的取样方法:

  • BM25 采样(BM25):该算法基于词汇重叠，通常被许多搜索引擎用作评分函数[7]。从唯一索引的句子中查询和检索前 k 个相似句子。
  • 语义搜索采样(SS):预训练的双编码器(SBERT)【4】用于检索我们的集合中前 k 个最相似的句子。对于大的集合，像 Faiss 这样的近似最近邻搜索可以用来快速检索 k 个最相似的句子。它能够解决 BM25 在没有或很少词汇重叠的同义句上的缺点。

之后，被采样的句子对将被预训练的交叉编码器弱标记，并与黄金数据集合并。然后，双编码器在这个扩展的训练数据集上被训练。这个模型叫做增广 SBERT (AugSBERT)。AugSBERT 可能会提高现有双编码器的性能，并减少与交叉编码器的差异。

总之，针对有限数据集的 AugSBERT 包括三个步骤:

  • 步骤 1:在小的(黄金数据集)上微调一个交叉编码器 (BERT)
  • 步骤 2.1:通过重组创建配对，并通过 BM25 或语义搜索减少配对
  • 步骤 2.2:用交叉编码器弱标记新对(银数据集)
  • 步骤 3:在扩展的(金+银)训练数据集上训练一个双编码器 (SBERT)

用有限的标注数据集训练 SBert

场景 3:没有标注的数据集(只有未标注的句子对)

当我们希望 SBERT 在不同的领域数据(没有注释)中获得高性能时，就会出现这种情况。基本上，SBERT 无法将带有看不见的术语的句子映射到一个可感知的向量空间。因此，提出了相关的数据增强策略域适应:

  • 第一步:在一个源数据集上从头开始训练一个交叉编码器 (BERT ),我们为这个数据集添加了注释。
  • 第二步:使用这些交叉编码器 (BERT)来标记你的目标数据集，即未标记的句子对
  • 步骤 3:最后，在标记的目标数据集上训练一个双编码器

一般来说，当源域相当一般而目标域相当具体时， AugSBERT 受益匪浅。反之亦然，当它从一个特定的领域到一个通用的目标领域，只有轻微的性能提升。

用无注释数据集训练 SBert 双编码器

📝实验评估

在这个实验中，我将介绍如何在不同的场景中应用 AugSBERT 的演示。首先，我们需要导入一些包

场景 1:完整的带注释的数据集(所有带标签的句子对)

此场景的主要目的是通过直接数据扩充策略扩展标记数据集，因此，我们将在语义文本相似性数据集(链接)上准备训练、开发、测试数据集，并定义批量大小、时期和模型名称(您可以指定任何 Huggingface/transformers 预训练模型)

然后，我们将通过我们的 BERT 模型插入单词(您可以应用我在技术重点部分提到的另一种论证技术)来创建 silver 数据集。

接下来，我们用两个(金+银)STS 基准数据集的均值池来定义我们的双编码器。

最后，我们将在测试 STS 基准数据集中评估我们的模型。

场景 2:有限或较小的带注释的数据集(少数带标记的句子对)

在这种情况下，我们将使用在有限标记数据集(黄金数据集)上训练的交叉编码器来软标记域内未标记数据集(白银数据集)，并在两个数据集(白银+黄金)中训练双编码器。在这个模拟中，我也再次使用 STS 基准数据集，并通过预训练的 SBERT 模型创建新的句子对。首先，我们将定义交叉编码器和双编码器。

第一步，我们将像以前一样准备训练、开发、测试，并微调我们的交叉编码器

第二步，我们使用微调过的交叉编码器来标记未标记的数据集。

第三步，我们在黄金和白银数据集中训练我们的双编码器

最后，我们将在测试 STS 基准数据集中评估我们的模型。

场景 3:没有标注的数据集(只有未标注的句子对)

在这个场景中，所有步骤都与场景 2 非常相似，但是在不同的领域中。由于我们的交叉编码器的能力，我们将使用一个通用的源数据集(STS 基准数据集)并将知识转移到一个特定的目标数据集( Quora 问题对)

并训练我们的交叉编码器。

标注 Quora 问题对数据集(白银数据集)。在这种情况下，任务是分类，所以我们必须将我们的分数转换为二进制分数。

然后，训练我们的双编码器

最后，在测试 Quora 问题对数据集上进行评估

📕最后的想法

AugSBERT 是一个简单有效的数据扩充工具，用于改进双编码器的两两句子评分任务。这个想法是基于通过使用预先训练的交叉编码器来标记新的句子对，并将它们组合成训练集。为软标注选择正确的句子对是提高性能的关键和必要的。通过对目标领域的数据进行软标记，奥格斯贝尔特 T21 方法也可以用于领域适应。

如果你想进一步讨论，可以联系我。这里是我的 Linkedin

尽情享受吧！！！👦🏻

参考

[1] Jacob Devlin、Chang Ming-Wei、Kenton Lee 和 Kristina Toutanova。Bert:用于语言理解的深度双向转换器的预训练。

[2]托马斯·沃尔夫、维克托·桑、朱利安·肖蒙德和克莱门特·德兰格。Transfertransfo:基于神经网络的对话代理的迁移学习方法。

[3] Pierre-Emmanuel Mazare、Samuel Humeau、Martin Raison 和 Antoine Bordes 培训数百万个性化对话代理。

[4]尼尔斯·雷默斯和伊琳娜·古雷维奇。句子嵌入使用暹罗伯特网络。

[5]塞缪尔·休莫、库尔特·舒斯特、玛丽-安妮·拉肖和杰森·韦斯顿。多编码器:快速准确的多句子评分的架构和预训练策略。

[6] Nandan Thakur、Nils Reimers、Johannes Daxenberge 和 Iryna Gurevych。增强 SBERT:用于改进成对句子评分任务的双编码器的数据增强方法。

[7]詹巴蒂斯塔·阿马蒂。BM25，斯普林格美国，波士顿，马萨诸塞州。

使用贝叶斯扩散模型的高级预测

原文：https://towardsdatascience.com/advanced-forecasting-using-bayesian-diffusion-modeling-b155a3dc1d84?source=collection_archive---------8-----------------------

行业笔记

在数据科学的所有领域，对旨在预测和阐明动态现象的创新建模解决方案有着巨大的需求。

图一。绿色、蓝色=原始数据，粉色=选定的拟合值，黑色=从 23 到 25 的时间预测，灰色= 95%贝叶斯后验预测区间。图片作者。

动态现象建模和预测的高姿态用例包括:

  • 金融 —预测股价走势或商品价格波动
  • 生物医学 —预测生物轨迹，例如生长、进化、药物治疗影响的确定
  • 流行病学 —评估疫苗接种等干预策略对传染病流行的影响，例如新冠肺炎
  • 能源 —预测风力或波浪涡轮机的输出，电力需求预测
  • 制造 —优化连续工业过程的输出，如食品生产中的蒸发

机器学习方法，例如 LSTM 网络或随机森林，已经被用于解决这些和类似的问题，但是这些方法并非没有挑战。本文介绍了一种不同的建模方法——贝叶斯扩散建模——这是一种白盒方法，仅使用几个参数就能够实现丰富的动态行为。这种方法有些先进，至少在数学意义上是如此，因为扩散过程涉及随机微积分，但是使用现有的 R/Python/Julia 库，加上一些编程知识，以及以前接触过的一点贝叶斯推理，现实世界的应用可能相对容易。

一个端到端的例子展示了贝叶斯扩散模型应用于开源数据集。使用了 R ，特别是 R-nimble 库，但是建模同样可以在 Python 中使用例如 Stan 或 Tensorflow probability 来实现。R-nimble 是一个通用计算框架，在 google groups 上有一个活跃的社区。

希望这个简短的案例研究能激发人们对这种丰富而优雅的方法论的兴趣。它不是新的，但也不是许多数据科学家建模工具箱的一部分，可能是一个有价值的补充。特别是对于预测和预测用例，因为这是一种连续时间方法，所以处理不规则间隔的数据是内置的，这在其他方法中建模序列相关性方面可能相当困难。

1.贝叶斯扩散建模—构建模块

贝叶斯扩散建模由两个关键构件组成:

第一步，

  • 定义一个随机过程 使得 足够灵活来描述感兴趣的动态现象——这被封装在一个随机微分方程 (SDE)中。存在许多标准配方。

第二步，

  • **使用马尔可夫链蒙特卡罗(MCMC)**模拟，从数据中估计步骤 1 的 SDE 中的参数 ，如果适用，包括解决测量误差和分层随机效应结构等复杂性所需的附加参数。

随机微分方程是一种高度灵活和简洁的描述动态现象的方法，广泛应用于量化金融，在医学和能源中有一些例子。可以使用 MCMC 从数据中估计模型的参数，MCMC 虽然计算量大，但是容易获得，并且具有无论模型复杂程度如何都几乎普遍适用的显著优势。结合这两种方法给出了贝叶斯扩散建模。

下面给出的用例示例有所简化，以使其尽可能容易理解，但是在更现实的情况下会出现相同的建模步骤。主要区别在于，这里的模型公式是先验选择的，而实际上，这应该由某种形式的模型选择过程来决定，以确保在给定可用数据的情况下，选择的模型是最佳参数化的。

2.预测癌症肿瘤增长——案例研究

这包括三个部分:

  1. 数据；
  2. 型号 配方；
  3. ****模型拟合和预测。

下面提供了关键的建模代码片段作为要点。完整的数据集可从作者的 GitHub repo 获得，以及重现结果和图表所需的完整代码。

2.1 数据

数据包括乳腺癌肿瘤的单一生长轨迹，这些数据的片段在下面的要点中给出。原始数据在 Zenodo 这里中可用，但由于它们仅由 23 天内的 15 个时间点组成，模拟用于生成更密集的采样数据集，在同一时间段内给出 n=231 而不是 n=15。使用了几种不同的模拟数据集。关于数据格式需要特别注意的一点是，每一行都是一个过渡，即开始时间(时间 1)、停止时间(时间 2)以及起点(观察 1)和终点(观察 2)。这种格式是为了匹配如何指定模型可能性(见下文)。

要点 1。数据片段。作者的 GitHub 上有完整的数据集(链接见正文)

2.2 模型制定

贝叶斯扩散从概率上描述了一个过程如何从一个给定的起始位置，例如(时间 1，观察值 1)发展到一个较晚的位置(时间 2，观察值 2)。这个过程用随机微分方程(SDE)来描述。下面的等式 1 给出了为该案例研究选择的 SDE。它是众所周知的 Gompertz 函数的随机形式，这里选择它是因为 Gompertz 模型已经被用于癌症肿瘤生长的建模(例如，参见这个出版物)。

等式 1。Gompertz 函数的随机微分方程。图片作者。

在等式 1 中，dt 项之前的乘法因子被称为漂移，dW 之前的项被称为扩散。dW 是一个布朗运动过程(或 Wiener 过程，因此 dW 中的“W ”),它不断干扰过程 X(t)随时间的演化。特别考虑到肿瘤的生长，考虑到在任何复杂的动态生物系统中发生的自然涨落，例如由于肿瘤和其他生物体之间对必需营养物的竞争，这种扰动在直觉上是合理的。

在这个例子中，类似 Gompertz 的 SDE 是一个合理的先验选择。有许多标准的 SDE 模型，大多最初在金融建模环境中使用或开发。例如，奥恩斯坦-乌伦贝克模型是一个均值回复过程，以及瓦西切克模型是为利率建模而开发的。一般来说，SDE 可以有任何漂移和扩散项，包括明确依赖于时间 t。多项式形式的漂移已在生物应用中用于模拟儿童生长轨迹(见此处)。也就是说，一个主要的实际警告是，SDE 需要有一个易处理的切片密度(见下文),因此漂移和扩散项的选择通常要考虑到这一点。

对等式 1 中的模型的最后一点说明是，扩散过程(dW)由 X(t)缩放。这是一种方便的方法，以确保扩散过程不会干扰整个过程到导致 X(t)为负值的程度，这在这里没有生物学意义，因为 X(t)是肿瘤的大小。

2.3 使用 MCMC 的模型拟合

为了理解如何使用 SDE 模型，可能有必要更详细地查看完整示例的代码。以下是要点的一个片段，但首先有必要完成等式 1 中模型的规范，并通过以下方式确定其可能性:

  1. 确定 SDE 的切片密度(也称为转移概率密度)，以及
  2. 定义模型中需要的任何额外复杂性，例如测量或观察误差。

2.3.1 SDE 切片密度推导

使用 Wolfram 语言沙箱(不需要登录)或者直接在 Mathematica 或 Wolfram 引擎(对开发者免费)中从等式 1 很容易得出切片密度。参见图 2，该图显示了如何在等式 1 中计算 SDE 的切片密度。这将在 R-nimble 后期的 MCMC 代码中使用。

图二。切片密度计算。图片作者。

切片密度定义了模型(随机过程)在未来通过特定点的可能性，这是基于对过程当前状态的了解。因此，该密度函数描述了任意两个时间点之间模型的所有路径或实现的概率“切片”。在图 2 中，还计算了对数切片密度的表达式，这是 R-nimble 模型规范所需要的。

2 . 3 . 2 MCMC 中的附加模型特征

任何给定数据集的最佳模型可能仅包含 SDE-漂移和扩散部分，但是，通常还会希望在模型中包含额外的随机误差分量，例如独立同分布(iid)正态误差。这将考虑测量误差，例如，假设用于测量肿瘤体积的仪器遭受小的但不可忽略的测量误差。这将对应于 iid 正常误差，以及潜在动力系统中存在的随机可变性。

测量误差包含在以下要点给出的模型中。请注意，通过包括这种形式的额外随机误差，正在建模的动态现象现在仅被潜在地观察到——实际观察到的是 Y(t) = X(t) + Z(t)，其中 X(t)是真实的肿瘤生长，Z(t)是测量误差(比如说)。

2 . 3 . 3 R-nimble 中的模型公式

下面的要点包含在 R-nimble 中定义贝叶斯扩散模型(带有测量误差)的关键代码片段。完整的代码可在这里获得。一些评论:

  • 完整的代码使用 CRAN 并行库来提高效率，这稍微增加了复杂性(主要的建模代码需要打包到一个函数中)
  • 定义****自定义概率分布对于切片密度来说是必要的，这很简单——参见 R-nimble 手册****
  • 要生成预测值/拟合值，输入数据集需要包含带有 NA 的虚拟记录，以便对预测值/拟合值进行估计
  • 按照目前的编码，完整的 MCMC 估计需要在 8 个内核(英特尔至强 2.2 Ghz)上花费 60 分钟，因此需要一些耐心(或者如果只是调试，则减少链的长度)。

要点 2。模型代码段。GitHub 上有完整的代码(链接见正文)。

为了完整起见，来自完整代码运行的 R 会话信息是:

图三。r 会话信息。图片作者。

结果

使用等式 1 中给出的 Gompertz 公式(加上根据上述要点添加的 iid 正态误差)的贝叶斯扩散模型适合两个不同的数据集。每个数据集由 n=231 个数据点组成，是原始癌症肿瘤数据集的不同实现(参见第 2.1 节)。图 4 和图 5 显示了使用模型的预测及其相关的不确定性，以及说明模型拟合的拟合值子集。

图 4。绿色=原始数据，粉色=一些拟合值，黑色=从时间=23 到 25 的预测，灰色= 95%贝叶斯后验预测区间。图片作者。

图 4 中的结果看起来直观合理——特别是对于这样一个简单的模型，Gompertz 只有两个参数——并且拟合值接近观察值。这些预测看起来也很合理，表现也像预测应该表现的那样，预测的未来越远，不确定性就越大。请注意，这些是贝叶斯后验预测 预测，即来自后验预测分布的分位数，因此预测周围的不确定性估计也包括参数估计不确定性(与根据单个参数估计集进行预测相反，这是非贝叶斯建模中的典型情况)。

图五。蓝色=原始数据，粉色=一些拟合值，黑色=从时间=23 到 25 的预测，灰色= 95%贝叶斯后验预测区间。图片作者。

图 5 与图 4 相似，因为拟合值和预测的结果看起来都很合理。该轨迹的定性行为与图 4 中的截然不同，在图 4 中，肿瘤的生长最初呈线性增长，然后趋于平稳。这里使用了相同形式的随机 Gompertz 模型，但是参数估计值非常不同，反映了数据的不同形状。

3.贝叶斯扩散建模—构建模型

与任何建模方法一样，真正的技巧通常是如何构建和参数化模型，以便它对于特定的问题或数据集是最佳的(至少在某种意义上)。这对于贝叶斯扩散模型来说尤其如此，因为既有 SDE 公式本身，又有 MCMC 公式，它们中的每一个都可以定制。以下两节包含一些关于使用 SDE 构建模型的一般性建议和备注。

3.1 通用 SDE 公式

第 2 节展示了基于 Gompertz 公式的贝叶斯扩散模型的应用。还有许多其他的可能性，例如等式 2 示出了在漂移项中是线性的，但也明显依赖于时间的 SDE。图 6 显示了如何在等式 2 中计算 SDE 的对数切片密度。同样，这是一个相对简单的过程(因为 Mathematica 在这里做了所有困难的工作！).

等式 2。SDE 的多项式形式。图片作者。

图六。多项式 SDE 的切片密度估计。图片作者。

3.2.转换和嵌套

布朗运动对动态过程的扰动假设被建模的过程可以增加和减少，这对于上面的肿瘤例子是合适的。然而，对于一些动态现象，扩散实际上只能在一个方向上发生。一个很好的例子是身高，儿童/动物/植物的身高增长是一个非递减的过程——身高增长可能会放缓或停止，但实体不会(至少通常)变小。这个问题的解决方案不是直接用 SDE/扩散模型来模拟动态过程，而是将扩散模型结合到模型的参数中，该模型确实实施非递减行为，

  • 考虑增长模型Y(t)= a+b X(t)+c X(t)——一个简单的多项式回归。现在，如果对一个非递减过程建模，那么只需包括参数的变换，例如
  • Y(t)= exp(a)+exp(b)X(t)+exp(c)X(t)—这现在是一个非线性模型，这对于 MCMC 估计来说不是问题，它强制模型无论 a，b，c 取正值还是负值都是非递减的。

如果被建模的过程是动态的，那么假设参数 a、b 和 c 随时间是静态的可能是不现实的，或者至少在模型选择过程中应该考虑这种可能性。为了允许回归参数随时间随机波动，可以使用贝叶斯扩散对这些参数单独或联合建模，例如参见等式 3，

等式 3。带有漂移参数ω的回归模型中参数“a”的简单 SDE。图片作者。

如果希望回归参数随时间相互关联，则可以将它们参数化为联合漂移和扩散过程(这将涉及 SDEs 系统和多个布朗运动过程)。这种方法可以提供极其丰富的建模框架。

3.3 易加工性

建模时的一个实际考虑是易处理性。从数学上来说，SDE 一般不易于分析，因此需要选择一个公式，它具有封闭形式的切片密度。严格地说，这是不正确的，因为有可能用数字来估计切片密度。可以使用模拟，有很多 SDE 模拟库可供 R 使用，也有茱莉亚，或者通过数值求解福克-普朗克方程。但是这两种方法在技术和计算上都需要相当大的努力，因为这也需要嵌套在 MCMC 采样过程中。

4.结束语

本文简要介绍了贝叶斯扩散建模，并希望证明它可以成为解决具有挑战性的预测问题的有力工具。学习如何将贝叶斯扩散模型应用于实际问题的最佳方式是通过一个端到端的编码示例。这可以在 GitHub 这里找到。

关于作者

这是我，我在达能的研发数据科学部门工作，在那里我管理着一个庞大的数据科学家团队，我也很幸运地做了一些建模工作。

高级 K-Means:控制组大小和选择特征

原文：https://towardsdatascience.com/advanced-k-means-controlling-groups-sizes-and-selecting-features-a998df7e6745?source=collection_archive---------3-----------------------

K-Means 的一些有用的调整

Patrick Schneider 在 Unsplash 上的照片

当使用 K-means 时，我们会面临两个问题:

  • 我们最终得到大小非常不同的星团，一些包含数千个观测值，而另一些只有几个
  • 我们的数据集有太多的变量，K-Means 算法很难找到一个最佳的聚类集

受约束的 K-Means:控制组大小

该算法基于 Bradley 等人的一篇论文，并由 Joshua Levy-Kramer:https://github.com/joshlk/k-means-constrained使用优秀的 Google OR-Tools 库(https://developers.google.com/optimization/flow/mincostflow)实现

该算法使用线性规划的思想，特别是网络模型。在物流中，网络模型被用于优化道路网络上的货物流动。

网络流模型示例(图片由作者提供)，示例取自麻省理工学院的 AML 。

我们可以在上面的简单图形中看到，我们有 5 个节点，它们之间有有向弧(箭头)。每个结点都有一个需求(负)或供应(正)值，弧线有流量和成本值。例如，arc 2–4 的流量为 4，成本为 2 美元。类似地，节点 1 供应 20 个单位，节点 4 需要 5 个单位。

这些问题可以通过使用优化算法来解决，例如单纯形算法。

在一个非常高的层次上，我们可以用一个网络来表示这个受约束的 K-means 问题，其中我们希望最小化每个点与其聚类的质心之间的距离之和，并且对聚类大小有一些约束。

我们可以在下图中看到它的样子。每个点 x(i)都是一个值等于 1 的供应节点，并且是一条指向每个单个聚类 c 的有向弧。这些弧的成本是该点与相应聚类的质心之间的距离。C1、C2 等集群。值等于所需最小大小的需求群。最后，我们添加一个人工需求节点，以确保供应的总和等于需求的总和。

优化问题被视为一个网络(图片由作者提供)，例子取自原始论文。

更详细的解释可以在的原文中找到。

Python 实现

Joshua Levy-Kramer 和其他人开发了一个包，可以在这里获得。

它可以与 pip 一起安装

pip install k-means-constrained

然后很容易地应用于数据集，我们将重用以前文章中的那个，但是我们需要将我们的 pandas 数据帧转换成一个数组。

X=np.array(X).transpose()

然后，我们可以用我们想要的集群数量(n_clusters)、集群的最小和最大大小(size_min 和 size_max)来拟合 KMeansConstrained 方法

from k_means_constrained import KMeansConstrainedclf = KMeansConstrained(
     n_clusters=4,
     size_min=8,
     size_max=12,
     random_state=0
)
clf.fit_predict(X)print(clf.cluster_centers_)
print(clf.labels_)

然后我们可以用 clf.cluster_centers_ 访问质心，用 clf.labels_ 访问聚类

正如我们在下面看到的，我们获得了 4 个集群，每个集群有 8 个元素。

最小大小为 8 的 4 个聚类的结果(图片由作者提供)

在这个例子中，我们使用了一个具有两个特征的数据集，因此它可以很好地在 2D 散点图中可视化。在大多数情况下，我们将处理包含大量要素的数据集。下一节将讨论如何在集群环境中处理这些问题。

K-均值的特征选择

照片由edu·格兰德在 Unsplash 上拍摄

在这一节中，我们将看到在处理包含大量变量的数据集时如何选择变量。降维通常有助于找到更好的聚类。

当我们处理高维数据集时，我们可能会遇到聚类方法的问题。特征选择对于监督学习是一种众所周知的技术，但是对于非监督学习(如聚类)方法来说却很少。这里我们将开发一个相对简单的贪婪算法来对 Kaggle 上的欧洲数据集执行变量选择。

该算法将具有以下步骤:

0.确保变量是数值型的且经过缩放，例如使用 StandardScaler()及其 fit_transform()方法

  1. 选择你要保留的变量的最大值( maxvars )，最小和最大的聚类数( kmin 和 kmax )，创建一个空列表: selected_variables 。
  2. 从 kmin 到 kmax 循环。然后，依次使用每个变量，使用 K-Means 记录变量和聚类数的每个组合的轮廓值(从 kmin 到 kmax)。
  3. 选择给出最大轮廓值的变量，将其添加到 selected_variables 中，并将其从测试变量列表中移除。
  4. 通过使用 selected_variables 列表并依次添加每个剩余变量，重复 2 和 3 中的过程，直到达到某个停止标准(在这种情况下是要保留的变量数量， maxvars )。

因此，对于第一步，我们定义和初始化一些变量。

maxvars=3
kmin=2
kmax=8kmeans_kwargs = {"init": "random","n_init": 20,"max_iter": 1000,"random_state": 1984}
cut_off=0.5# We define a cols variables containing a list of all features:cols=list(df.columns)'''We set a list and a dictionary to store the silhouette values
for each number of clusters tested so we can choose the k value
maximising the silhouette score, with its corresponding features'''results_for_each_k=[]
vars_for_each_k={}

然后我们创建三个嵌套循环，外部的一个循环遍历集群数量 k 的值。然后我们有一个 while 循环来检查保留变量的数量是否低于由 maxvars 设置的阈值。 selected_variables 列表将保存保留的特征名称。结果列表将保存每个变量的轮廓值。

for k in range(kmin,kmax+1):
    selected_variables=[]
    while(len(selected_variables)<maxvars):
        results=[]    
        selected_variables=[]
    print(k)
    while(len(selected_variables)<maxvars):
        results=[]

内部循环逐一检查所有特征，将它们添加到已选择的变量中(如果有)，并评估轮廓值。然后选择获得最高值的变量，并将其添加到 selected_variables 列表中。

for col in cols:
    scols=[]
    scols.extend(selected_variables)
    scols.append(col) 
    kmeans = KMeans(n_clusters=k, **kmeans_kwargs)
    kmeans.fit(df[scols])
    results.append(silhouette_score(df[scols],   kmeans.predict(s)))''' We identify the best variable, add it to our list and remove it 
from the list of variables to be tested on the next iteration '''selected_var=cols[np.argmax(results)]
selected_variables.append(selected_var)
cols.remove(selected_var)

然后，我们可以在我们的循环中更新这个特定 k 值的变量列表和分数。

results_for_each_k.append(max(results))
vars_for_each_k[k]=selected_variables

最后，在三个循环运行之后，我们可以确定 k 和变量的最佳组合，拟合模型并绘制它。

best_k=np.argmax(results_for_each_k)+kmin
selected_variables=vars_for_each_k[best_k]
kmeans = KMeans(n_clusters=best_k, **kmeans_kwargs)
kmeans.fit(df_[selected_variables])
clusters=kmeans.predict(df[selected_variables])

基于人口、财富和犯罪率的 2 组国家的最终结果(图片由作者提供)

如果我们选择 3 个集群，我们会得到不同的选择

对于 3 个集群，我们有不同的变量选择(图片由作者提供)

每组国家的一些例子:

冰岛、瑞士、比利时、德国、卢森堡、荷兰、奥地利和英国

第二组:希腊、西班牙、法国、克罗地亚、意大利、塞浦路斯、拉脱维亚、立陶宛、匈牙利、马耳他、波兰、葡萄牙

第 3 组:挪威、丹麦、芬兰和瑞典

这是完整的代码，包括 3d 绘图。

我们当然可以将变量选择与受约束的 K-Means 算法相结合，以强制均匀聚类。

我希望这个教程是有帮助的，如果你有问题，请随意评论。

参考文献

页（page 的缩写）S. Bradley，K. P. Bennett 和 A. Demiriz，约束 K 均值聚类 (2000 年)

布拉德利、哈克斯和马格南蒂，应用数学编程，艾迪森-韦斯利(1977)

Python 中的高级多任务处理:用 6 行代码应用线程池和进程池并进行基准测试

原文：https://towardsdatascience.com/advanced-multi-tasking-in-python-applying-and-benchmarking-threadpools-and-processpools-90452e0f7d40?source=collection_archive---------9-----------------------

安全轻松地对您的代码应用多任务处理

我们的一名工作人员正在执行一项重要任务(图片由 Unsplash 上的 Krysztof Niewolny 拍摄)

当你的机器可以执行多任务时，为什么要按顺序执行呢？使用进程的线程，你可以通过同时运行来大大提高代码的速度。本文将向您展示用 Python 实现这一奇妙技术的安全而简单的方法。在本文结束时，您将:

  • 了解哪些任务适合多任务处理
  • 知道何时应用线程池或进程池
  • 能够向同事和朋友吹嘘只用几行简单的代码就可以将执行速度提高 10 倍

在我们开始之前，我强烈建议先看一看 这篇文章 来理解 Python 是如何工作的。为什么 Python 一开始就不是多线程的？它向您展示了我们在本文中试图解决的问题。我还推荐阅读这篇解释线程和进程区别的文章。

为什么要用泳池？

池是希望保护员工数量的应用程序的理想选择。假设您在一个 API 中运行一个函数，该函数创建 5 个 workers 来处理提供的数据。如果您的 API 在一秒钟内突然收到 500 个请求，该怎么办？创建 2500 个都执行繁重任务的工人可能会杀死你的计算机。

池通过限制可以创建的工作线程的数量来防止您的计算机像这样被终止。在 API 示例中，您可能希望创建一个最多包含 50 个工作线程的池。当 500 个请求进来时会发生什么？只有 50 个工人被创造出来。还记得每个请求需要 5 个工人吗？这意味着只有前 10 个请求得到处理。一旦工人完成并返回到池中，它可以再次被发送出去。

总之:池确保在任何给定的时间都不会有超过一定数量的工作线程处于活动状态。

创建池

使用并发库，我们可以轻松地为线程和进程创建池。在下面的部分，我们将进入代码。最后，我们会有一个例子:

  • 如何创建池
  • 限制池的最大工作线程数
  • 将目标函数映射到池中，以便工作人员可以执行它
  • 收集函数的结果
  • 等待所有工人完成后再继续

设置

正如您在 这篇文章 中看到的，线程更适合 IO 类型的任务(并发等待)，而进程最适合 CPU 密集型任务(使用更多 CPU)。为了正确测试我们的代码，我们将定义两种类型的函数:一种是 IO 密集型的，另一种是 CPU 密集型的:

这些是我们的目标函数；承担重任的职能。注意，两者都有一个打印输出参数。这不是特别有用的
，但是我们需要它来证明我们可以传递额外的(关键字)参数。

每个蜂巢都有一个固定数量的工蜂池(图片由汉斯约格·凯勒在 Unsplash 上拍摄)

线程池 IO 繁重任务

我们将从 I/O-heavy 函数开始。我们有一个 100 个数字的列表，我们想传递给这个函数。按顺序，代码如下所示:

如果我们执行上面的代码，大约需要 100 秒来执行(100 个调用，每 2 秒一次)。让我们使用线程池来运行相同的代码:

如你所见，我们使用了 concurrent . futures . threadpoolexecutor。我们定义最多 10 个工人，然后在我们的范围内循环，为每个数字创建一个线程。每个线程一完成，我们就将结果添加到 _sum 变量中，并最终返回它。执行这段代码大约需要 10 秒钟。这并不奇怪，因为我们有 10 个工人，所以我们应该比顺序运行代码快 10 倍。

下面你会发现同样的代码只是格式不同。

我们将把对函数的调用定义为部分函数，这样我们就可以把它映射到执行器。第三行对范围(10)中的每个值执行部分函数。

CPU 繁重的任务

当谈到将 CPU 繁重功能映射到进程池的代码时，我们可以简单地说:代码非常相似。

只需将第 3 行中的函数换成(cpu_heavy_task)并将 ThreadPoolExecutor 切换成 ProcessPoolExecutor。就是这样！

让我们来看看顺序、线程和进程之间的区别(图片由 Glen Rushton 在 Unsplash 上提供)

标杆管理

让我们来测试一下这些功能吧！我们将顺序执行 IO 密集型和 CPU 密集型函数，线程化和多处理。
以下是结果:

IO heavy function
sequential:      took 100.44 seconds
threaded:        took 10.04  seconds (max pool size = 10)
processed:       took 10.20  seconds (max pool size = 10)

CPU heavy function 
sequential:      took 27.89  seconds
threaded:        took 26.65  seconds (max pool size = 10)
processed:       took 6.58   seconds (max pool size = 10)

正如这篇 中所解释的，这些结果都是意料之中的。顺序执行当然是最慢的，一个接一个地执行所有的函数。

不仅仅是一辆车，还有游泳池，我们有整个车队可以使用(图片由乔治·贝尔在 Unsplash 上拍摄)

线程IO 繁重功能的速度快了 10 倍，因为我们的工作人员是它的 10 倍。处理IO 密集型函数大约与 10 个线程一样快。它会慢一点，因为设置这些流程的成本更高。注意，虽然两者速度一样快，但是线程是更好的选择，因为它们提供了共享资源的能力。

当我们对 CPU 密集型函数进行基准测试时，我们看到线程化与顺序方法一样快。这是由于 GIL 在本文 中解释了 。进程在处理 CPU 密集型任务时效率更高，速度提高了约 4.3 倍。

另外，请注意，在这些情况下，我们的池大小相当小，并且可以调整(取决于您的目标函数)以创建更快的程序！

结论

正如您在本文中读到的，使用池非常容易。此外，我希望已经阐明了为什么以及如何使用它们。有时候多任务处理是不够的。查看 这篇 或 这篇 的文章，这篇文章向您展示了如何编译一小部分代码以获得 100 倍的速度提升(也可以是多任务的)。

如果你有建议/澄清，请评论，以便我可以改进这篇文章。与此同时，请查看我的关于各种编程相关主题的其他文章，例如:

  • Python 中的多任务处理:通过同时执行，将程序速度提高 10 倍
  • 用 FastAPI 用 5 行代码创建一个快速自动记录、可维护且易于使用的 Python API
  • 从 Python 到 SQL——安全、轻松、快速地升级
  • 创建并发布你自己的 Python 包
  • 创建您的定制私有 Python 包，您可以从您的 Git 库 PIP 安装该包
  • 面向绝对初学者的虚拟环境——什么是虚拟环境以及如何创建虚拟环境(+示例)
  • 通过简单升级，显著提高数据库插入速度

编码快乐！

—迈克

页（page 的缩写）学生:比如我正在做的事情？跟着我！

https://mikehuls.medium.com/membership

高级 NumPy:25 个图解练习掌握步幅技巧

原文：https://towardsdatascience.com/advanced-numpy-master-stride-tricks-with-25-illustrated-exercises-923a9393ab20?source=collection_archive---------2-----------------------

包括来自 StackOverflow 的代码、解释和问题

在桌面上用 Chrome 浏览器观看效果最佳

变更日志:
2022 年 12 月 31 日:使用 Medium 的新代码块进行语法突出显示
2022 年 1 月 6 日:根据来自Sirouan Nouriddine 2022 年 1 月 5 日:修复错别字并提高清晰度
2021 年 12 月 30 日:从 NumPy 1.20.0 开始，有一个 sliding_window_view API，它也可以作为更高级别的 API 更多见 此处

(此处跳转到习题*<#4838>)***

他可以被看作是访问和操作 NumPy [ndarray](https://numpy.org/doc/stable/reference/arrays.ndarray.html)的通常方式的扩展，给予用户更多的灵活性来控制最终的 NumPy 视图。虽然这是一个深奥的功能，但一个特别实用的用法是当涉及到滑动窗口或滚动统计时。在本文中，我们将完成使用该 API 的 25 个不同的练习(并与我们通常的做法进行比较)。

对于本文，建议读者具备 Python、NumPy、[numpy.dtype](https://numpy.org/devdocs/user/basics.types.html)、[numpy.ndarray.strides](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.strides.html)和[numpy.ndarray.itemsize](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.itemsize.html)的中级知识。有关 NumPy 数组和步长的快速介绍，请参见💡下面一点背景。

练习的难度逐渐增加，按以下顺序编排:

  • 这个问题用一个图来说明，图中有 NumPy 数组输入和预期的输出，即 NumPy 视图。假设您读取元素的方式是连续的。itemsize因问题而异。
  • 答案是——strides和shape将被用作numpy.lib.stride_tricks.as_strided中的参数，以获得最终的数字视图。
  • 解释
  • 代码，其中as_strided是从这个 import 语句导入的名称空间:
    **from** numpy.lib.stride_tricks **import** as_strided

💡一点背景

如何从一个固定大小的元素块中访问一个特定的项目，这些元素(I)是连续放置的，并且(ii)被组织成嵌套的子组？答案: 大踏步 。我刚才简单描述的是一个 NumPy 的 N 维数组( *ndarray* )数据结构，我们用一个叫做 的算法，步进索引方案 连同步距一起遍历它。

关于 NumPy 数组，这里有 4 个你应该知道的要点。

1)NumPy 数组中的元素占用内存。NumPy 数组中的每个元素统一占用 n 个字节。例如，数据类型为 *np.int64* 的数组中的每个元素占用 8 个字节。 *np.ndarray.itemsize* 找出物品尺寸。

2)NumPy 数组中的元素在内存中是连续存储的。这意味着它们是并排存储的(不像 Python 列表中的元素)。

3)有一条信息叫做 shape，你可能已经知道了，它定义了这个数组对于每个维度有多大。要访问这些信息，请选择 *np.ndarray.shape* 。

4)还有另一条信息叫做步幅，它表示要跳到维度中下一个值的字节数。要访问这些信息，请选择 *np.ndarray.strides* 。

利用这 4 条信息，可以通过以跨距为系数的维度的线性组合来找到元素的存储位置。更深入的解释，参考我下面 的参考文献 。

练习

  1. 切片前 3 个元素
  2. 切片前 8 个元素
  3. 展平一个 2D 阵列
  4. 每隔一个元素跳过一个
  5. 切片第一列
  6. 切一条对角线
  7. 重复第一个元素
  8. 简单的 2D 切片
  9. 切成锯齿形
  10. 稀疏切片
  11. 转置一个 2D 数组
  12. 重复第一列 4 次
  13. 将 1D 阵列重塑为 2D 阵列
  14. 滑动一个 1D 窗口
  15. 滑动一扇 2D 窗，然后展平
  16. 从 3D 数组中折叠一个轴
  17. 2 个角
  18. 交错切片
  19. 重复一次 2D 阵列
  20. 3D 转置
  21. 滑动一个 2D 窗口
  22. 将 1D 阵列重塑为 3D 阵列
  23. 载玻片 2D 感受野进行卷积
  24. 重复一个 3D 张量
  25. 将 1D 阵重塑为 4D 阵

1D 演习

1)切片前 3 个元素

输入项大小: 1 字节 |输入步数:( 5 ， 1 )

回答

**strides = (**1**,)
  shape = (**3**,)**

💡 解释 输出中相邻的元素(即 1 → 2，2 → 3)原来都是 1 字节相隔(=1 元素相隔 × 1 字节)输入中的。这个维度的形状是 3 。

代码

**>>> x = np.asarray(range(1,26), np.int8).reshape(5,5)
>>> as_strided(x, shape=(3,), strides=(1,))
array([1, 2, 3], dtype=int8)**

与…类似

**>>> x[0,:3]
array([1, 2, 3], dtype=int8)**

2)切片前 8 个元素

输入项大小: 1 字节 |输入步数:( 5 ， 1 )

回答

**strides = (**1**,)
  shape = (**8**,)**

💡 解释 输出中相邻的元素(如 1 → 2，2 → 3，6 → 7)原本是 输入中相隔 1 字节(=1 个元素相隔 × 1 字节)。这个维度的形状是 8 。

代码

**>>> x = np.asarray(range(1,26), np.int8).reshape(5,5)
>>> as_strided(x, shape=(8,), strides=(1,))
array([1, 2, 3, 4, 5, 6, 7, 8], dtype=int8)**

与…类似

**>>> x[0,:8]
array([1, 2, 3, 4, 5, 6, 7, 8], dtype=int8)**

3)展平 2D 阵列

输入项大小: 2 字节 |输入步数:( 10 ， 2 )

回答

**strides = (**2**,)
  shape = (**25**,)**

💡 解释 输出中的相邻元素(如 1 → 2，2 → 3，23 → 24，24 → 25)原本是 2 字节相隔(=1 个元素相隔 × 2 字节)输入中的。这个维度的形状是25。

代码

**>>> x = np.asarray(range(1,26), np.int16).reshape(5,5)
>>> as_strided(x, shape=(25,), strides=(2,))
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10,
       11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
       21, 22, 23, 24, 25], dtype=int16)**

与…类似

**>>> x.ravel()
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10,
       11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
       21, 22, 23, 24, 25], dtype=int16)**

4)跳过所有其他元素

输入项大小: 1 字节 |输入步数:( 5 ， 1 )

回答

**strides = (**2**,)
  shape = (**3**,)**

💡 解释 输出中相邻的元素(即 1 → 3，3 → 5)原本是2字节相隔(=2 个元素相隔 × 1 字节)的输入。这个尺寸的形状是3。

代码

**>>> x = np.asarray(range(1,26), np.int8).reshape(5,5)
>>> as_strided(x, shape=(3,), strides=(2,))
array([1, 3, 5], dtype=int8)**

与…类似

**>>> x[0,::2]
array([1, 3, 5], dtype=int8)**

5)切片第一列

输入项大小: 8 字节 |输入步数:( 40 ， 8 )

回答

**strides = (**40**,)
  shape = (**4**,)**

💡 解释 *输出中相邻的元素(即 1 → 6，6 → 11，11 → 16)被原本40字节相隔(=5 个元素相隔 × 8 字节)输入中。这个维度的形状是 4 。***

代码

***>>> x = np.asarray(range(1,26), np.int64).reshape(5,5)
>>> as_strided(x, shape=(4,), strides=(40,))
array([ 1,  6, 11, 16])***

与…类似

***>>> x[:4,0]
array([ 1,  6, 11, 16])***

6)切一条对角线

输入项大小: 8 字节 |输入步数:( 40 ， 8 )

回答

***strides = (**48**,)
  shape = ( **5**,)***

💡 解释 输出中相邻的元素(即 1 → 7，7 → 13，13 → 19，19 → 25)原本是 48 字节相隔(=6 个元素相隔 × 8 个字节)输入中的。这个尺寸的形状是 5 。

代码

***>>> x = np.asarray(range(1,26), np.int64).reshape(5,5)
>>> as_strided(x, shape=(5,), strides=(48,))
array([ 1,  7, 13, 19, 25])***

与…类似

***>>> x.diagonal()
array([ 1,  7, 13, 19, 25])***

7)重复第一个元素

输入项大小: 8 字节 |输入步数:( 40 ， 8 )

回答

***strides = (**0**,)
  shape = (**5**,)***

💡 解释 输出中相邻的元素(即 1 → 1)原本是 0 字节相隔(=0 个元素相隔×8字节)输入中的。这个维度的形状是 5 。**

代码

***>>> x = np.asarray(range(1,26), np.int64).reshape(5,5)
>>> as_strided(x, shape=(5,), strides=(0,))
array([ 1, 1, 1, 1, 1])***

与…类似

***>>> np.broadcast_to(x[0,0], (5,))
array([1, 1, 1, 1, 1])***

2D 演习

8)简单的 2D 切片

输入项大小: 8 字节 |输入步数:( 40 ， 8 )

回答

***strides = (**40**,**8**)
  shape = ( **3**,**4**)***

💡 解释

输出的左右尺寸(axis= -1 ):
输出中相邻的元素(如 1 → 2，2 → 3，8 → 9)原本是输入中的8字节(=1 个元素之外的 × 8 字节)。这个尺寸的形状是4。

输出的左右维度(axis= -2 ):
输出中相邻的元素(如 1 → 6，2 → 7，9 → 14)原来在输入中相隔 40 字节(=5 个元素之外 × 8 字节)。这个维度的形状是 3 。

代码

***>>> x = np.asarray(range(1,26), np.int64).reshape(5,5)
>>> as_strided(x, shape=(3,4), strides=(40,8))
array([[ 1,  2,  3,  4],
       [ 6,  7,  8,  9],
       [11, 12, 13, 14]])***

与…类似

***>>> x[:3,:4]
array([[ 1,  2,  3,  4],
       [ 6,  7,  8,  9],
       [11, 12, 13, 14]])***

9)切一个锯齿形

输入项大小: 8 字节 |输入步数:( 40 ， 8 )

回答

***strides = (**48**,**8**)
  shape = ( **4**,**2**)***

💡 解说

输出的左右维度(axis= -1 ):
输出中相邻的元素(例如 1 → 2，7 → 8，13 → 14，19 → 20)原本是输入中 8 字节(=1 个元素之外 × 8 字节)。这个维度的形状是 2 。

输出的左右维度(axis= -2 ):
输出中相邻的元素(如 1 → 7，2 → 8，13 → 19)原本是输入中 48 字节(=6 个元素之外 × 8 字节)。这个维度的形状是 4 。

代码

***>>> x = np.asarray(range(1,26), np.int64).reshape(5,5)
>>> as_strided(x, shape=(4,2), strides=(48,8))
array([[ 1,  2],
       [ 7,  8],
       [13, 14],
       [19, 20]])***

与…类似

***>>> # this may not be achieved concisely***

10)稀疏切片

输入项大小: 8 字节 |输入步数:( 40 ， 8 )

回答

***strides = (**80**,**16**)
  shape = ( **3**, **3**)***

💡 解说

输出的左右维度(axis= -1 ):
输出中相邻的元素(例如 1 → 3，21 → 23，13 → 15)原来是输入中16字节(=2 个元素之外 × 8 字节)。这个维度的形状是3。

输出的左右维度(axis= -2 ):
输出中相邻的元素(如 1 → 11，13 → 23，15 → 25)原来在输入中相隔 80 字节(=相隔 10 个元素 × 8 字节)。这个维度的形状是 3 。

代码

***>>> x = np.asarray(range(1,26), np.int64).reshape(5,5)
>>> as_strided(x, shape=(3,3), strides=(80,16))
array([[ 1,  3,  5],
       [11, 13, 15],
       [21, 23, 25]])***

与…类似

***>>> x[::2,::2]
array([[ 1,  3,  5],
       [11, 13, 15],
       [21, 23, 25]])***

11)转置 2D 阵列

输入项大小: 1 字节 |输入步数:( 5 ， 1 )

回答

***strides = (**1**,**5**)
  shape = (**3**,**3**)***

💡 解说

输出的左右维度(axis= -1 ):
输出中相邻的元素(如 1 → 6，7 → 12，3 → 8)原本是输入中相隔 5 个字节(=5 个元素之外 × 1 字节)。这个维度的形状是 3 。****

输出的从上到下的维度(axis= -2 ):
输出中相邻的元素(如 1 → 2，2 → 3，11 → 12)原来在输入中是 1 字节(=1 个元素之外 × 1 字节)。这个维度的形状是 3 。

代码

***>>> x = np.asarray(range(1,26), np.int8).reshape(5,5)
>>> as_strided(x, shape=(3,3), strides=(1,5))
array([[ 1,  6, 11],
       [ 2,  7, 12],
       [ 3,  8, 13]], dtype=int8)***

与…类似

***>>> x[:3,:3].T
array([[ 1,  6, 11],
       [ 2,  7, 12],
       [ 3,  8, 13]], dtype=int8)***

12)重复第一列 4 次

输入项大小: 4 字节 |输入步数:( 20 ， 4 )

回答

***strides = (**20**,**0**)
  shape = ( **5**,**4**)***

💡 解说

输出的左右维度(axis= -1 ):
输出中相邻的元素(如 1 → 1，6 → 6，16 → 16)原来是输入中0字节(=0 个元素之外 × 4 字节)。这个维度的形状是4。

输出的上下维(axis= -2 ):
输出中相邻的元素(如 1 → 6，6 → 11，11 → 16)在输入中原本是 相隔 20 字节(=相隔 5 个元素 × 4 字节)。这个维度的形状是 5 。

代码

***>>> x = np.asarray(range(1,26), np.int32).reshape(5,5)
>>> as_strided(x, shape=(5,4), strides=(20,0))
array([[ 1,  1,  1,  1],
       [ 6,  6,  6,  6],
       [11, 11, 11, 11],
       [16, 16, 16, 16],
       [21, 21, 21, 21]], dtype=int32)***

与…类似

***>>> np.broadcast_to(x[:,0,None], (5,4))
array([[ 1,  1,  1,  1],
       [ 6,  6,  6,  6],
       [11, 11, 11, 11],
       [16, 16, 16, 16],
       [21, 21, 21, 21]], dtype=int32)***

13)将 1D 阵列重塑为 2D 阵列

输入项大小: 8 字节 |输入步数:( 8 ，)

回答

***strides = (**24**,**8**)
  shape = ( **4**,**3**)***

💡 解说

输出的左右尺寸(axis= -1 ):
输出中相邻的元素(如 1 → 2，2 → 3，7 → 8，11 → 12)原本是输入中 8 字节(=1 个元素之外 × 8 字节)。这个维度的形状是 3 。

输出的上下维(axis= -2 ):
输出中相邻的元素(如 1 → 4，4 → 7，7 → 10)原本在输入中相隔 24 字节(=3 个元素之外 × 8 字节)。这个维度的形状是 4 。

代码

***>>> x = np.asarray(range(1,13), np.int64)
>>> as_strided(x, shape=(4,3), strides=(24,8))
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])***

与…类似

***>>> x.reshape(4,3)
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])***

14)滑动 1D 窗

改编自 StackOverflow 帖子[ 1 ]。类似于[ 2 和[ 3 ]。

输入项大小: 1 字节 |输入步数:( 1 ，)

回答

***strides = (**1**,**1**)
  shape = (**8**,**3**)***

💡 解说

输出的左右维度(axis= -1 ):
输出中相邻的元素(如 1 → 2，3 → 4，4 → 5)原来是输入中1字节(=1 个元素之外 × 1 字节)。这个维度的形状是3。

输出的上下维(axis= -2 ):
输出中相邻的元素(即 1 → 2，2 → 3，4 → 5，…，7 → 8)在输入中原本是 1 字节相隔(=1 个元素之外 × 1 字节)。这个维度的形状是 8 。

代码

***>>> x = np.asarray(range(1,26), np.int8)
>>> as_strided(x, shape=(8,3), strides=(1,1))
array([[ 1,  2,  3],
       [ 2,  3,  4],
       [ 3,  4,  5],
       [ 4,  5,  6],
       [ 5,  6,  7],
       [ 6,  7,  8],
       [ 7,  8,  9],
       [ 8,  9, 10]], dtype=int8)***

与…类似

***>>> # this may not be achieved concisely***

15)滑动 2D 窗，然后将其压平

来自 StackOverflow 帖子[ 4 ]的问题。

输入项大小: 1 字节 |输入步数:( 2 ， 1 )

回答

***strides = (**2**,**1**)
  shape = (**4**,**6**)***

💡 解说

输出的左右尺寸(axis= -1 ):
输出中相邻的元素(如 0 → 1，1 → 10，31 → 40)原来是输入中 1 字节(=1 个元素之外 × 1 字节)。这个维度的形状是 6 。

输出的上下维(axis= -2 ):
输出中相邻的元素(如 0 → 10，10 → 20，41 → 51)原来在输入中是 2 字节(=2 个元素之外 × 1 字节)。这个维度的形状是 4 。

代码

***>>> x = np.asarray(
...         [0,1,10,11,20,21,30,31,40,41,50,51],
...         np.int8).reshape(6,2)
>>> as_strided(x, shape=(4,6), strides=(2,1))
array([[ 0,  1, 10, 11, 20, 21],
       [10, 11, 20, 21, 30, 31],
       [20, 21, 30, 31, 40, 41],
       [30, 31, 40, 41, 50, 51]], dtype=int8)***

与…类似

***>>> # this may not be achieved concisely***

16)从 3D 数组中折叠一个轴

输入项大小: 1 字节 |输入步数:( 4 、 2 、 1 )

回答

***strides = (**4**,**1**)
  shape = (**3**,**4**)***

💡 解说

输出的左右维度(axis= -1 ):
输出中相邻的元素(如 1 → 2，3 → 4，4 → 5)原来在输入中是1字节(=1 个元素之外 × 1 字节)。这个尺寸的形状是4。

输出的上下维(axis= -2 ):
输出中相邻的元素(即 1 → 5，5 → 9，2 → 6，6 → 10)原本在输入中相隔 4 字节(=相隔 4 个元素 × 1 字节)。这个维度的形状是 3 。

代码

***>>> x = np.asarray(range(1,13), np.int8).reshape(3,2,2)
>>> as_strided(x, shape=(3,4), strides=(4,1))
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]], dtype=int8)***

与…类似

***>>> x.reshape(3,4)
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]], dtype=int8)***

3D 练习

17)两个角

输入项大小: 2 字节 |输入步数:( 10 ， 2 )

回答

***strides = (**30**,**10**, **2**)
  shape = ( **2**, **2**, **2**)***

💡 解说

输出的左右维度(axis= -1 ):
输出中相邻的元素(即 1 → 2，6 → 7，16 → 17，21 → 22)原来在输入中是 2 字节(=1 个元素之外 × 2 字节)。这个维度的形状是 2 。

输出的上下维度(axis= -2 ):
输出中的相邻元素(即 1 → 6，2 → 7，16 → 21，17 → 22)原本是 10 字节的间隔(=5 个元素之外 × 2 字节)这个维度的形状是 2 。

输出的框到框尺寸(axis= -3 ):
输出中的相邻元素(即 1 → 16，2 → 17，6 → 21，7 → 22)原本是输入中的 30 字节(=15 个元素之外的 × 2 字节)。这个维度的形状是2。

代码

***>>> x = np.asarray(range(1,26), np.int16).reshape(5,5)
>>> as_strided(x, shape=(2,2,2), strides=(30,10,2))
array([[[ 1,  2],
        [ 6,  7]],
       [[16, 17],
        [21, 22]]], dtype=int16)***

与…类似

***>>> # this may not be achieved concisely***

18)交错切片

输入项大小: 1 字节 |输入步数:( 5 ， 1 )

回答

***strides = (**10**,**6**,**1**)
  shape = ( **2**,**2**,**3**)***

💡 解释

输出的盒内从左到右维度(axis= -1 ):
输出中相邻的元素(如 1 → 2，2 → 3，17 → 18)原本是输入中 1 字节(=1 个元素之外 × 1 字节)。这个维度的形状是 3 。

输出的盒内上下维度(axis= -2 ):
输出中的相邻元素(如 1 → 7，11 → 17，12 → 18)原本是输入中的 6 字节(=6 个元素之外 × 1 字节)。这个尺寸的形状是 2 。

输出的左框到右框尺寸(axis= -3 ):
输出中的相邻元素(例如 1 → 11，8 → 18，9 → 19)原本是输入中的 10 字节(=10 个元素之外的 × 1 字节)。这个尺寸的形状是 2 。

代码

***>>> x = np.asarray(range(1,26), np.int8).reshape(5,5)
>>> as_strided(x, shape=(2,2,3), strides=(10,6,1))
array([[[ 1,  2,  3],
        [ 7,  8,  9]],
       [[11, 12, 13],
        [17, 18, 19]]], dtype=int8)***

与…类似

***>>> # this may not be achieved concisely***

19)重复 2D 阵列

这个问题摘自 StackOverflow 在这里的一个帖子[ 5 。

输入项大小: 2 字节 |输入步数:( 10 ， 2 )

回答

***strides = (**0**,**10**,**2**)
  shape = (**3**, **2**,**4**)***

💡 解说

输出的盒内从左到右维度(axis= -1 ):
输出中的相邻元素(例如 1 → 2，2 → 3，6 → 7)原本是输入中的 2 字节(=1 个元素之外 × 2 字节)。这个维度的形状是4。

输出的盒内上下维度(axis= -2 ):
输出中相邻的元素(如 1 → 6，2 → 7，3 → 8)原本在输入中相隔10字节(=相隔 5 个元素 × 2 字节)。这个尺寸的形状是2。

输出的左框到右框尺寸(axis= -3 ):
输出中相邻的元素(如 1 → 1，3 → 3，7 → 7)原来是输入中 0 字节(=0 个元素之外 × 2 字节)。这个维度的形状是 3 。

代码

***>>> x = np.asarray(range(1,26), np.int16).reshape(5,5)
>>> as_strided(x, shape=(3,2,4), strides=(0,10,2))
array([[[1, 2, 3, 4],
        [6, 7, 8, 9]],
       [[1, 2, 3, 4],
        [6, 7, 8, 9]],
       [[1, 2, 3, 4],
        [6, 7, 8, 9]]], dtype=int16)***

与…类似

***>>> np.broadcast_to(x[0:2, 0:-1], (3, 2, 4))***

20) 3D 转置

输入项大小: 4 字节 |输入步数:( 16 、 8 、 4 )

回答

***strides = (**16**,**4**,**8**)
  shape = ( **3**,**2**,**2**)***

💡 解说

输出的左右尺寸(axis= -1 ):
输出中相邻的元素(如 1 → 3，2 → 4，10 → 12)原本是输入中 8 字节(=2 个元素之外 × 4 字节)。这个维度的形状是 2 。

输出的上下维(axis= -2 ):
输出中相邻的元素(如 1 → 2，3 → 4，9 → 10，11 → 12)原本在输入中相隔 4 字节(=1 个元素之外 × 4 字节)。这个维度的形状是 2 。

输出的左框到右框尺寸(axis= -3 ):
输出中相邻的元素(例如 1 → 5，5 → 9)原本是输入中 16 字节(=4 个元素之外 × 4 字节)。这个维度的形状是3。

代码

***>>> x = np.asarray(range(1,13), np.int32).reshape(3,2,2)
>>> as_strided(x, shape=(3,2,2), strides=(16,4,8))
array([[[ 1,  3],
        [ 2,  4]],
       [[ 5,  7],
        [ 6,  8]],
       [[ 9, 11],
        [10, 12]]], dtype=int32)***

与…类似

***>>> np.swapaxes(x,1,2)
array([[[ 1,  3],
        [ 2,  4]],
       [[ 5,  7],
        [ 6,  8]],
       [[ 9, 11],
        [10, 12]]], dtype=int32)***

21)滑动 2D 窗

问题改编自 SciPy 2008 会议[ 6 ]。

输入项大小: 8 字节 |输入步数:( 40 ， 8 )

回答

***strides = (**40**,**40**,**8**)
  shape = ( **3**, **2**,**5**)***

💡 解释

输出的盒内从左到右维度(axis= -1 ):
输出中相邻的元素(如 1 → 2，12 → 13，16 → 17)原本在输入中相隔 8 字节(=1 个元素之外 × 8 字节)。这个尺寸的形状是 5 。

输出的盒内上下维度(axis= -2 ):
输出中的相邻元素(如 1 → 6，8 → 13，11 → 16)原本是输入中的 40 字节(=5 个元素之外 × 8 字节)。这个尺寸的形状是 2 。

输出的左框到右框尺寸(axis= -3 ):
输出中相邻的元素(如 9 → 14，14 → 19)原本在输入中相隔 40 字节(=5 个元素之外 × 8 字节)。这个尺寸的形状是 3 。

代码

***>>> x = np.asarray(range(1,21), np.int64).reshape(4,5)
>>> as_strided(x, shape=(3,2,5), strides=(40,40,8))
array([[[ 1,  2,  3,  4,  5],
        [ 6,  7,  8,  9, 10]],
       [[ 6,  7,  8,  9, 10],
        [11, 12, 13, 14, 15]],
       [[11, 12, 13, 14, 15],
        [16, 17, 18, 19, 20]]])***

与…类似

***>>> # this may not be achieved concisely***

22)将 1D 阵列整形为 3D 阵列

输入项大小: 1 字节 |输入步数:( 1 ，)

回答

***strides = (**6**,**3**,**1**)
  shape = (**2**,**2**,**3**)***

💡 解说

输出的盒内从左到右维度(axis= -1 ):
输出中的相邻元素(例如 1 → 2，5 → 6，7 → 8，10 → 11)原本是输入中的 1 字节(=1 个元素之外 × 1 字节)。这个尺寸的形状是3。

输出的盒内上下维度(axis= -2 ):
输出中的相邻元素(如 1 → 4，2 → 5，8 → 11)原本是输入中的3字节(=3 个元素之外的 × 1 字节)。这个尺寸的形状是2。

输出的左框到右框尺寸(axis= -3 ):
输出中相邻的元素(如 1 → 7，2 → 8，3 → 9)原来是输入中的 6 字节(=6 个元素之外的 × 1 字节)。这个维度的形状是 2 。

代码

***>>> x = np.asarray(range(1,13), np.int8)
>>> as_strided(x, shape=(2,2,3), strides=(6,3,1))
array([[[ 1,  2,  3],
        [ 4,  5,  6]],
       [[ 7,  8,  9],
        [10, 11, 12]]], dtype=int8)***

与…类似

***>>> x.reshape(2,2,3)
array([[[ 1,  2,  3],
        [ 4,  5,  6]],
       [[ 7,  8,  9],
        [10, 11, 12]]], dtype=int8)***

4D 演习

23)载玻片 2D 感受野进行卷积

改编自 StackOverflow 在 2D 卷积上的一篇帖子。

输入项大小: 1 字节 |输入步数:( 5 ， 1 )

回答

***strides = (**10**,**2**,**5**,**1**)
  shape = ( **2**,**2**,**3**,**3**)***

💡 解说

输出的盒内从左到右尺寸(axis= -1 ):
输出中的相邻元素(例如 1 → 2，17 → 18，24 → 25)原本是输入中的 1 字节(=1 个元素之外 × 1 字节)。这个尺寸的形状是 3 。

输出的盒内上下维度(axis= -2 ):
输出中相邻的元素(如 1 → 6，2 → 7，3 → 8)原本在输入中相隔 5 字节(=5 个元素之外 × 1 字节)。这个维度的形状是 3 。

输出的左框到右框尺寸(axis= -3 ):
输出中相邻的元素(例如 1 → 3，6 → 8，21 → 23，23 → 25)在输入中原本是 2 字节(=2 个元素之外 × 1 字节)。这个维度的形状是2。

输出的顶框到底框尺寸(axis= -4 ):
输出中的相邻元素(如 1 → 11，2 → 12，15 → 25)原本是输入中的10字节(=10 个元素之外的 × 1 字节)。该尺寸的形状为 2 。

代码

***>>> x = np.asarray(range(1,26), np.int8).reshape(5,5)
>>> as_strided(x, shape=(2,2,3,3), strides=(10,2,5,1))
array([[[[ 1,  2,  3],
         [ 6,  7,  8],
         [11, 12, 13]],
        [[ 3,  4,  5],
         [ 8,  9, 10],
         [13, 14, 15]]],
       [[[11, 12, 13],
         [16, 17, 18],
         [21, 22, 23]],
        [[13, 14, 15],
         [18, 19, 20],
         [23, 24, 25]]]], dtype=int8)***

与…类似

***>>> # this may not be achieved concisely***

24)重复 3D 张量

输入项大小: 8 字节 |输入步数:( 48 、 24 、 8 )

回答

***strides = (**48**, **0**,**24**, **8**)
  shape = ( **2**, **2**, **2**, **3**)***

💡 解释

输出的盒内从左到右维度(axis= -1 ):
输出中相邻的元素(如 1 → 2，2 → 3，4 → 5)原本在输入中是 8 字节(=1 个元素之外 × 8 字节)。这个尺寸的形状是 3 。

输出的盒内上下维度(axis= -2 ):
输出中的相邻元素(如 1 → 4，7 → 10，8 → 11)原本是输入中的 24 字节(=3 个元素之外 × 8 字节)。这个维度的形状是 2 。

输出的左框到右框尺寸(axis= -3 ):
输出中相邻的元素(如 1 → 1，10 → 10，12 → 12)原来在输入中是 0 字节(=0 个元素之外 × 8 字节)。这个维度的形状是 2 。

输出的顶框到底框尺寸(axis= -4 ):
输出中的相邻元素(例如 1 → 7，2 → 8，3 → 9)最初在输入中是 48 字节(=6 个元素之外 × 8 字节)。这个维度的形状是2。

代码

***>>> x = np.asarray(range(1,13), np.int64).reshape(2,2,3)
>>> as_strided(x, shape=(2,2,2,3), strides=(48,0,24,8))
array([[[[ 1,  2,  3],
         [ 4,  5,  6]],
        [[ 1,  2,  3],
         [ 4,  5,  6]]],
       [[[ 7,  8,  9],
         [10, 11, 12]],
        [[ 7,  8,  9],
         [10, 11, 12]]]])***

与…类似

***>>> np.broadcast_to(x,(2,2,2,3)).swapaxes(0,1)
array([[[[ 1,  2,  3],
         [ 4,  5,  6]],
        [[ 1,  2,  3],
         [ 4,  5,  6]]],
       [[[ 7,  8,  9],
         [10, 11, 12]],
        [[ 7,  8,  9],
         [10, 11, 12]]]])***

25)将 1D 阵列重塑为 4D 阵列

输入项大小: 8 字节 |输入步数:( 8 ，)

回答

***strides = (**64**,**32**,**16**, **8**)
  shape = ( **2**, **2**, **2**, **2**)***

💡 解释

输出的盒内从左到右维度(axis= -1 ):
输出中相邻的元素(如 1 → 2，2 → 3，4 → 5)原本在输入中相隔 8 字节(=1 个元素之外 × 8 字节)。这个尺寸的形状是 2 。

输出的盒内上下维度(axis= -2 ):
输出中的相邻元素(如 1 → 4，7 → 10，8 → 11)原本是输入中的 16 字节(=2 个元素之外 × 8 字节)。这个尺寸的形状是 2 。

输出的左框到右框尺寸(axis= -3 ):
输出中的相邻元素(例如 1 → 1，10 → 10，12 → 12)原本是输入中的 32 字节(=4 个元素之外 × 8 字节)。这个尺寸的形状是 2 。

输出的顶框到底框尺寸(axis= -4 ):
输出中的相邻元素(如 1 → 7，2 → 8，3 → 9)原本是输入中的 64 字节(=8 个元素之外的 × 8 字节)。这个维度的形状是 2 。

代码

***>>> x = np.asarray(range(1,17), np.int64)
>>> as_strided(x, shape=(2,2,2,2), strides=(64,32,16,8))
array([[[[ 1,  2],
         [ 3,  4]],
        [[ 5,  6],
         [ 7,  8]]],
       [[[ 9, 10],
         [11, 12]],
        [[13, 14],
         [15, 16]]]])***

与…类似

***>>> x.reshape(2,2,2,2)
array([[[[ 1,  2],
         [ 3,  4]],
        [[ 5,  6],
         [ 7,  8]]],
       [[[ 9, 10],
         [11, 12]],
        [[13, 14],
         [15, 16]]]])***

⚠️:虽然 stride 技巧可以让您对生成的 NumPy 视图进行更多的控制，但是该 API不是内存安全的——如果您错误地计算了 itemsize(老实说，我认为该 API 不应该允许客户端代码处理项目大小，因为我没有看到公开这一点的任何好处)或形状或现有的 strides，那么事情会变得非常糟糕，返回的数据实际上不是您创建的初始数组，而是来自您可能在几行之前定义的另一个数组😱。这被称为缓冲区溢出，使用 stride tricks API 不难遇到这种情况。更糟糕的是当你决定写这个数据时😱😱。正是因为这个原因， stride tricks 文档提醒用户在使用时要格外小心。**

理解 stride tricks API 很有挑战性，我在这方面有问题。然而，诀窍(没有双关语)是从更小的维度开始，并且可视化张量的输出。玩得开心！**

发现错误？请在评论中告诉我！:)大喊到David Chong对这篇文章进行点评。**

如果你喜欢我的内容并且还没有订阅 Medium，请通过我的推荐链接 这里 订阅！注意:你的会员费的一部分将作为介绍费分配给我。

资源

N 维数组(ndarray)(numpy.org)

先进数字(scipy-lectures.org)

形状和步幅的图解指南(ajcr.net)

使用 NumPy 的 stride 技巧 (ipython-books.github.io)

[1]https://stack overflow . com/questions/40084931/taking-sub arrays-from-numpy-array-with-given-stride-stepsize

[2]https://stack overflow . com/questions/4923617/efficient-numpy-2d-array-construction-from-1d-array

[3]https://stack overflow . com/questions/47483579/how-to-use-numpy-as-strided-from-NP-stride-tricks-correctly

[4]https://stack overflow . com/questions/15722324/sliding-window-of-m-by-n-shape-numpy-ndarray

[5]https://stack overflow . com/questions/23695851/python-repeating-numpy-array-without-replication-data

https://mentat.za.net/numpy/numpy_advanced_slides/

[7]https://stack overflow . com/questions/43086557/convolve2d-just-by-using-numpy

用于调整神经网络中超参数的 Hyperopt 高级选项

原文：https://towardsdatascience.com/advanced-options-with-hyperopt-for-tuning-hyperparameters-in-neural-networks-d108cf7655d9?source=collection_archive---------8-----------------------

理解大数据

C M 在 Unsplash 上拍照

如果你和我一样，你花了几个月的时间研究机器学习的应用，并想知道如何从模型中获得更好的性能。我会花上几个小时，甚至几天的时间，对模型进行细微的调整，希望能有更好的性能。我想，当然应该有比手动检查几十个超参数组合更好的方法来改进模型。

这时我看到了这篇关于 Python 包 Hyperopt 的优秀文章，它使用贝叶斯优化模型来确定机器学习模型的最佳超参数。在尝试将模型与数据相匹配时，随机猜测和耗时的反复试验的日子已经一去不复返了！使用贝叶斯优化来优化您的模型还有一个好处，那就是，虽然理解超参数控制什么很重要，但您不必成为使用模型的专家。相反，您可以尝试一种您以前从未使用过的全新类型的模型，通过一些简单的代码，您可以获得一些很好的结果。

在我们深入讨论一些例子之前，我想提一下其他几个包，它们实现了相似的目标，但是使用了不同的方法。Scikit-learn 有一个 RandomizedSearchCV 和 GridSearchCV 方法，用于搜索超参数空间。如果您正在使用 Keras， Hyperas 也为超参数优化提供了一个很好的包装器(然而，如果您试图做一些更高级的应用，您可能会遇到一些限制)。网格搜索和随机搜索选项要详尽得多，因此也更耗时，但优点是您不会陷入局部最小值的风险，而这在使用贝叶斯方法时是有可能的。缺点是你的搜索可能会花更多的时间去尝试无效的超参数。

问题表述和数据生成

对于我们的数据，我们将生成一些一阶加死区(FOPDT)模型数据。FOPDT 模型是强大而直接的模型，通常在工业中用于初步结果。它们是一种描述对变化的刺激做出反应时会发生什么的方式。例如，我们可以根据你踩油门的程度来模拟汽车的速度是如何变化的。

在上面的等式中，y(t)是输出变量，u(t)是输入变量，Kₚ、τₚ和θₚ是确定输出相对于输入的行为的过程常数。具体来说，想想你汽车上的油门踏板。你可以把踏板踩下一个给定的量(输入变量，或 u(t)，是踏板被踩下的百分比)，汽车的速度(输出变量，或 y(t))会相应增加。Kₚ描述了与你踩下踏板的程度相比，速度变化的程度；τₚ表示速度将增加多快(通常报告为汽车的加速度)；θₚ是死时间变量，并考虑了踩下油门踏板和速度实际开始变化之间的任何延迟。

用 Python 模拟 FOPDT 模型实际上非常简单。我们从一个函数开始，重新排列 FOPDT 方程以求解导数 dy/dt:

def fopdt(y,t,um,Km,taum):
    # arguments
    #  y      = output
    #  t      = time
    #  uf     = input linear function (for time shift)
    #  Km     = model gain
    #  taum   = model time constant
    # calculate derivative
    dydt = (-(y-yp0) + Km * (um-u0))/taum
    return dydt

一旦有了这个，我们就可以创建另一个函数来模拟对我们传递的任何输入的一阶响应。其中最关键的部分是使用来自scipy的odeint。

def sim_model(Km,taum):
    # array for model values
    ym = np.zeros(ns)
    # initial condition
    ym[0] = yp0
    # loop through time steps    
    for i in range(0,ns-1):
        ts = [t[i],t[i+1]]
        y1 = odeint(fopdt,ym[i],ts,args=(u[i],Km,taum))
        ym[i+1] = y1[-1]
    return ym

有了这些函数，我们就可以设置我们的模拟了。我们首先指定我们需要多少数据点，以及模型参数(您可以随意更改这些参数以查看不同的模型响应——也许您想要通过模拟快速加速来模拟赛车，或者通过增加增益来模拟更高的最大速度，或者 Kₚ).

# Parameters and time for FOPDT model
ns = 10000
t = np.linspace(0,ns-1,ns)
u = np.zeros(ns)# Additional FOPDT parameters
yp0 = 0.0
u0 = u[0]
Km = 0.67
taum = 160.0

我们现在将生成一些步长数据，我选择通过在 0 到 100 之间随机更改输入值(u 或油门%)来生成这些数据，并在 5 到 15 分钟的时间内保持该值。这使我们能够看到各种稳态和瞬态数据。

# Generate step data for u
end = 60 # leave 1st minute of u as 0
while end <= ns:
    start = end
    end += random.randint(300,900) # keep new Q1s value for anywhere                        
                                     from 5 to 15 minutes
    u[start:end] = random.randint(0,100)

现在，我们可以简单地调用前面的sim_model函数，我们将得到对刚刚生成的输入数据的一阶响应。

# Simulate FOPDT model
y = sim_model(Km,taum)

现在，这些数据看起来很漂亮，但并没有反映现实。我们的传感器中总会有一些噪声，因此为了获得更真实的数据，我们将生成一些人工噪声，并将其添加到模拟数据中。您还可以在自己的代码中更改噪声量，看看它如何改变最终结果。

# Add Gaussian noise
noise = np.random.normal(0,0.2,ns)
y += noise

最后，我们将继续将所有数据放在一起，并为我们的神经网络模型做一些预处理。在这一点上，它确实是直接的数据，但是当数据被缩放时，我们的模型将执行得更好。感谢 scikit-learn 的MinMaxScaler,这很简单:

# Scale data
data = np.vstack((u,y)).T
s = MinMaxScaler(feature_range=(0,1))
data_s = s.fit_transform(data)

现在我们有了一些 FOPDT 模型数据。我们先快速浏览一下，看看它是什么样子，然后再讨论我们想用它做什么机器学习应用。

由作者策划。

灰色表示我们将留待最终测试的数据。橙色线(踏板%)是输入，我们在代码中称之为u。蓝线(速度，带有人为添加的噪声)是过程变量(PV)或输出数据，我们用y表示。所以你可以看到，当我们踩下油门踏板时，速度逐渐上升，直到达到稳定状态，当我们把脚从油门上拿开时，速度下降。

那么现在，我们想用这些数据做什么呢？我们想创建一个模拟类似行为的机器学习模型，然后使用 Hyperopt 来获得最佳的超参数。如果你看看我的关于用 LSTM 神经网络仿真 PID 控制器的系列，你会发现 LSTMs 在处理这类问题时表现得非常好。我们想要做的是训练一个 LSTM 模型，它将遵循 FOPDT 模型的行为。

模型结构

Keras 是构建神经网络的优秀平台。我们可以保持这个非常基本的，做一些像下面这样的事情:

# Keras LSTM model
model = Sequential()

model.add(LSTM(units = 50, 
                input_shape = (Xtrain.shape[1],Xtrain.shape[2])
               )
          )
model.add(Dropout(rate = 0.1))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mean_squared_error')

es = EarlyStopping(monitor='val_loss',mode='min',verbose=1,patience=15)result = model.fit(Xtrain, ytrain, verbose=0, validation_split=0.1,
                       batch_size=100,
                       epochs=200)

在上面的代码中，我们从 LSTM 层开始，指定units超参数，以及输入形状。我们添加了一个 Dropout 层，这有助于避免过度拟合数据，然后添加了一个 Dense 层，这是模型输出结果所需要的。然后，我们使用adam优化器和mean_squared_error损失指标编译模型，添加一行代码以在损失达到稳定水平时停止训练模型，然后拟合模型。很简单…直到我们看到它实际上是如何工作的:

作者的情节

上面的图显示了我们模拟的实际速度和油门踏板，以及预测和预报的速度。预测速度在将实际测量值输入模型的基础上进行预测，而预测速度采用之前的预测速度并将它们输入模型——因此导致了如此大的漂移以及无法从漂移中恢复。正如你所看到的，这个模型很难令人满意。好消息是我们有一些选择来改善它。我们可以生成更多的数据，或者让它训练更多的时期(或者更少，取决于我们是否过拟合或欠拟合)。当然值得检查一下。但是另一个选择是调整超参数，或者通过试错法，更深入地理解模型结构…或者 Hyperopt 包。

具有远视的模型结构

这篇文章的目的不是介绍远视，而是旨在扩展你想用远视做什么。查看上面的 Keras 代码块，我们可以挑选出几个超参数进行优化，例如 LSTM 层中的units，漏失层中的rate，以及拟合时的batch_size。寻找这些的最佳值将在介绍性远视教程中介绍。然而，我们可能会发现添加一些额外的 LSTM 和漏失层是有用的，甚至可以查看一个更优化的数据点窗口来馈入 LSTM。我们甚至会发现改变我们试图最小化的目标函数是有益的。

现在，使用远视对初学者是非常有益的，但它确实有助于了解每个超参数的用途和一个良好的范围。我们首先定义要搜索的值的范围。同样，这一步的语法在任何介绍性的远视教程中都有涉及，所以我的目的是展示一些细微差别。代码如下:

from hyperopt.pyll.base import scope 
#quniform returns float, some parameters require int; use this to force intspace = {'rate'       : hp.uniform('rate',0.01,0.5),
         'units'      : scope.int(hp.quniform('units',10,100,5)),
         'batch_size' :     
                    scope.int(hp.quniform('batch_size',100,250,25)),
         'layers'     : scope.int(hp.quniform('layers',1,6,1)),
         'window'     : scope.int(hp.quniform('window',10,50,5))
        }

大多数时候，你可以使用常规选项来选择hp.uniform、hp.choice、hp.logchoice等。然而，hp.quniform选项返回一个浮点数，即使它是一个整数，如 1.0 或 5.0。一些 Keras 超参数要求这是一个整数类型，所以我们通过包含scope.int来强制 Hyperopt 返回一个整数。

为了构建我们的模型，我们将所有内容都放在一个函数中，将可能的参数作为自变量:

def f_nn(params):
    # Generate data with given window
    Xtrain, ytrain, Xtest, ytest = 
                    format_data(window=params['window'])

    # Keras LSTM model
    model = Sequential()

    if params['layers'] == 1:
        model.add(LSTM(units=params['units'], 
                     input_shape=(Xtrain.shape[1],Xtrain.shape[2])))
        model.add(Dropout(rate=params['rate']))
    else:
        # First layer specifies input_shape and returns sequences
        model.add(LSTM(units=params['units'], 
                     return_sequences=True, 
                     input_shape=(Xtrain.shape[1],Xtrain.shape[2])))
        model.add(Dropout(rate=params['rate']))

        # Middle layers return sequences
        for i in range(params['layers']-2):
            model.add(LSTM(units=params['units'],
                           return_sequences=True))
            model.add(Dropout(rate=params['rate']))

        # Last layer doesn't return anything
        model.add(LSTM(units=params['units']))
        model.add(Dropout(rate=params['rate'])) model.add(Dense(1))
    model.compile(optimizer='adam', loss='mean_squared_error')

    es = EarlyStopping(monitor='val_loss',mode='min',
                       verbose=1,patience=15) result = model.fit(Xtrain, ytrain, 
                       verbose=0, 
                       validation_split=0.1,
                       batch_size=params['batch_size'],
                       epochs=200)

    # Get the lowest validation loss of the training epochs
    validation_loss = np.amin(result.history['val_loss']) 
    print('Best validation loss of epoch:', validation_loss)

    return {'loss': validation_loss, 
            'status': STATUS_OK, 
            'model': model, 
            'params': params}

您会注意到函数中的第一行将数据格式化为 Xtrain、ytrain、Xtest 和 ytest。这将我们的 X 和 y 数据格式化为 LSTM 要求的格式，重要的是根据我们之前为window指定的范围调整输入点的窗口。然后我们开始我们的 Keras 模型。它有和以前一样的元素，但是您会注意到，我们没有为一个超参数指定一个数值，比如rate，而是通过将它设置为rate = params['rate']来允许它在我们指定的范围内。我们还添加了一些逻辑，以支持多个 LSTM 和漏失层。最后，我们像以前一样编译和拟合模型，然后我们需要一个目标函数来最小化。首先，我们只需将验证损失作为我们的目标函数，这在大多数情况下就足够了(我们将在一分钟内探索一个可能需要其他东西的实例)。最后一步是返回我们稍后可能要在代码中使用的信息，比如目标函数的损失、Keras 模型和超参数值。

模型超参数优化

要运行实际的优化，请为一些长时间的运行做好准备。训练 LSTM 总是需要一点时间，我们正在做的是用不同的超参数集训练它几次。下一部分花了大约 12 个小时在我的个人电脑上运行。你可以通过使用 Google Colab 的 GPU 资源来显著加快这个过程。

您需要的实际代码很简单。我们设置了trials变量，这样我们就可以从优化中检索数据，然后使用fmin()函数来实际运行优化。我们传递之前提供的f_nn函数，包含超参数值范围的space，将algo定义为tpe.suggest，将max_evals指定为我们想要尝试的组数。通过更多的尝试，我们更有可能得到最优解，但是等待更多时间也有不好的一面。对于像快速训练数据的分类器这样的东西，很容易在几秒钟内获得数百次评估，但对于 LSTM，这里指定的 50 次评估需要几个小时。

trials = Trials()
best = fmin(f_nn, 
            space, 
            algo=tpe.suggest,
            max_evals=50,
            trials=trials)

运行之后，您可以查看一些结果。我使用一点列表理解来访问存储在trials中的数据。我们可以看到我们在最初的f_nn函数中返回的所有内容，包括loss、model和params。我们的最佳模型和参数集将与最低损失相关联，而最差的模型和参数集将具有最高损失。让我们继续把它们保存为变量，这样我们就可以画出结果。

best_model = trials.results[np.argmin([r['loss'] for r in 
    trials.results])]['model']best_params = trials.results[np.argmin([r['loss'] for r in 
    trials.results])]['params']worst_model = trials.results[np.argmax([r['loss'] for r in 
    trials.results])]['model']worst_params = trials.results[np.argmax([r['loss'] for r in 
    trials.results])]['params']

结果

现在我们已经运行了优化并保存了模型(为了更好地度量超参数集)，是时候看看模型看起来如何了。我们将研究两种不同的方法。第一种方法包括采用实际输入数据点(踏板%)的前一个窗口，并使用它来预测下一个输出(速度)。我们称之为“预测”这可以通过获取我们的测试数据并应用model.predict()函数很容易地找到。看起来是这样的:

# Best window
best_window = best_params['window']# Format data
Xtrain, ytrain, Xtest, ytest = format_data(window=best_window)Yp = best_model.predict(Xtest)

不过，我们还想看看另一个方面。假设我们试图在没有即时反馈的情况下预测速度的走向。我们使用 LSTM 预测来进行下一次预测，而不是采用实际的数据值。这是一个更加困难的问题，因为如果 LSTM 预测只是稍微有一点偏差，这个误差就会随着时间的推移而增加。我们将这种方法称为“预测”，表示我们正在使用 LSTM 预测来更新输入值并对某个时间范围进行预测。我把它放入一个函数forecast():

def forecast(Xtest,ytest,model,window):
    Yf = ytest.copy()
    for i in range(len(Yf)):
        if i < window:
            pass
        else:
            Xu = Xtest[i,:,0]
            Xy = Yf[i-window:i]
            Xf = np.vstack((Xu,Xy)).T
            Xf = np.reshape(Xf, (1, Xf.shape[0], Xf.shape[1])) 
            Yf[i] = model.predict(Xf)[0] 

    return Yf

让我们看看这个是什么样子的:

作者的情节

好吧，其实也没那么糟。这其实是在用最坏的模型和超参数集。查看我们在 50 次迭代后得出的最佳集合如下所示:

作者的情节

“预测”相当接近，而“预报”要好得多。如果我们让它尝试更多的优化，我们可能会从预测中获得更好的结果。但是我们能在预测上做得更好吗？

改变目标函数

这就是目标函数发挥作用的地方。你可以非常聪明地使用你正在最小化的目标函数来考虑你想要看到更好结果的所有类型的情况。例如，如果我们还想考虑模型训练需要多长时间呢？我们可以改变我们的loss分数，加入一个时间因素——比如乘以花费的时间，这样快速的训练时间就会得到奖励。

在我们的例子中，我们想要奖励具有良好预测的模型。这实际上很简单，因为我们已经有了forecast()函数。像以前一样设置好我们的f_nn()函数后，我们可以再添加几行来改变我们的目标函数。回想一下，之前，我们简单地将loss设置为validation_loss值。现在，我们实际上在我们的f_nn模型中运行预测，如下所示:

# Get validation set
val_length = int(0.2*len(ytest))
Xval, yval = Xtrain[-val_length:], ytrain[-val_length:]# Evaluate forecast
Yr, Yp, Yf = forecast(Xval,yval,model,params['window'])
mse = np.mean((Yr - Yf)**2)

注意，我们必须分离出我们的验证集——我们不能使用我们的测试集，因为那会使结果有偏差。然后，我们简单地计算预测值和实际值之间的均方误差(mse)。然后将它保存为return行中的损失函数，如下所示:

return {'loss': mse, 
        'status': STATUS_OK, 
        'model': model, 
        'params': params}

这就是全部了。再次运行后，我们得到以下结果:

作者的情节

我们也可以看看最坏的结果，只是为了证明远视确实为我们做了一些事情:

作者的情节

使用最好的模型看起来棒极了！正如我们所讨论的，预测对小错误非常敏感，所以考虑到我们预测的时间范围，这看起来真的令人印象深刻。我们期望看到漂移在更长的时间内变得更加明显，但是使用更新的目标函数是一个重大的改进。我们还可以对 50 次以上的评估进行优化，我们可能会得到更好的结果。

最后的想法

这些只是几个例子，说明如何利用 Hyperopt 从机器学习模型中获得更高的性能。虽然这里使用的确切方法可能不会用在你的特殊情况下，但我希望一些想法被激发出来，你可以看到远视的更多潜在用途。我已经在我的 Github repo 上包含了不同模拟的代码。

你还能怎么做？如果您想找到最省时、最准确的模型，可以很容易地在目标函数中添加时间元素。这里的原则很容易应用于任何其他具有超参数的机器学习模型，并且您可能会发现在分类器上使用它要快得多。最后，你可以通过使用 GPU 来显著加快这个过程——如果你的电脑没有 GPU 的话， Google Colab 是一个很好的资源。让我知道你的想法，并随时在 LinkedIn 上与我联系。

高级排列对解释预测的重要性

原文：https://towardsdatascience.com/advanced-permutation-importance-to-explain-predictions-ead7de26eed4?source=collection_archive---------19-----------------------

保持简单性，将可解释性带到下一个层次

哈维·卡夫雷拉在 Unsplash 上的照片

机器学习的可解释性是一个活跃的研究领域，涉及所有有助于提供更多信息预测的技术。预测模型被认为是黑盒工具，只是为了最大化性能而优化。准确性很重要，但在大多数商业案例中，考察为什么机器学习模型会做出一个决定是至关重要的。

因此，一个好的权衡包括提供良好的性能和一个检验预测的工具。我们感兴趣的是显示某些特征对预测值有多大影响的框架。实际上，我们是在我们的模型上做推理，遵循一些启发法，然后我们试图把所有的信息放入一个表中，或者更好地放入一个令人敬畏的图中。

当我们试图解释任何机器学习模型的输出时，我们应该考虑一个至关重要的方面。可解释性不一定导致可解释性。如果人们没有足够的知识来理解，那么采用该领域的最新技术或制作最酷的图表可能是无用的。如果我们必须向业务部门展示结果，就会出现这种情况。过载的图表或一些复杂索引的使用，不是所有人都能理解的，使得我们的工作无法解释。

在这篇文章中，我们提供了一些图形报告来解释机器学习模型的输出。我们利用排列重要性的简单性和适应性来提供不同的图形报告，这也可以与 SHAP 方法获得的结果进行比较。

排列重要性:基本用法

排列重要性是每个数据科学家都必须知道的特征重要性计算的常用程序。该技术旨在改变目标和特征之间的关系。置换意味着模型性能的下降，这表明模型对特征的依赖程度。

具体而言，排列重要性计算如下。首先，拟合一个模型，并根据一些数据计算基线指标。接下来，来自相同数据的特征被置换，并且度量被再次评估。排列重要性被定义为排列度量和基线度量之间的差异。对数据集中的所有列计算这些步骤，以获得所有特征的重要性。高值意味着该特征对模型很重要。在这种情况下，值的混排破坏了与目标的关系，并导致低质量的预测(高误差)。相反，低值意味着置换度量接近原始置换度量，即低预测能力。作为一般的提醒，强调排列重要性也可以假设为负值是很重要的。当我们在特征洗牌后获得更好的分数时就是这种情况。对于该特征，观察值是无用的(即，它们对预测有负面影响)。

特征评估的排列重要性示例(图片由作者提供)

在计算排列重要性时，上图非常常见。我们以降序报告了平均排列分数(通过几次排列运行获得)以及误差棒形式的相对标准偏差。大多数时候，排列重要性的用法到此为止，显示前面的条形图。这个图表太棒了，它告诉了我们很多信息，所有人都很容易理解。我们能更进一步吗？我们能利用排列重要性的简单性来为我们的预测提供更详细的解释吗？

我们现在尝试做的是为我们感兴趣的观察提供一个排列重要性分数。通过这种方式，我们对模型做出的决策有了更详细的了解。我们利用排列重要性的简单性来显示特征如何有助于每个样本的预测。这种分析对于每一种监督任务(回归或分类)来说都是容易实现的，并导致产生一些令人敬畏的图表。

排列重要性:高级用法

让我们从回归场景开始。我们正在执行一项回归任务，我们有兴趣在给定一些外部数字特征的情况下预测房价。在拟合我们选择的模型之后，我们容易地计算条形格式的排列重要性(出于演示的目的，特征重要性是在训练数据上计算的)。

回归任务中特征评估的排列重要性(图片由作者提供)

在这种情况下，重要性被计算为与均方误差的偏差。我们重复相同的方法，但不对各列的得分进行平均。我们简单地将原始预测的平方误差与置换每个样本的特征所获得的平方误差进行比较。在这种情况下，我们总结从多次重复中获得的样本分数，取中间值。按照这个过程，我们以每一列中每个观察的重要性分数结束。我们观察下面样本分数的分布。

回归任务中样本评估的排列重要性(图片由作者提供)

样本分数现在很容易访问和使用，以提供任何解释情节。例如，我们可以逐个样本地检查每个特性的影响。在下面的热图中，我们显示了每个特性对一些随机实例的预测值的影响程度。

单个样本的排列重要性(图片由作者提供)

为了获得一个更全面的视图，我们可以绘制出所需特性对整个数据的影响。例如，纬度的低值和经度的高值对预测值有很大的影响。

总结所有功能的效果(图片由作者提供)

可以在 2D 中计算相同的表示，以便也可视化特征之间或者特征和目标之间的相互作用。

样本和多个特征的排列重要性(图片由作者提供)

对于分类任务，我们操作相同的推理和图形表示。假设我们对给定一些外部数字特征来预测葡萄酒的质量感兴趣。在拟合我们选择的模型后，我们很容易计算排列的重要性。我们不能使用均方差作为排列重要性的评分函数。在这种情况下，一个有价值的替代方法是对数损失(处理多个类的分类交叉熵)。之前介绍的内容在这个场景中仍然很有价值。

分类任务中特征评估的排列重要性(图片由作者提供)

我们像以前一样检索每个样本的重要性分数。这里一些观察的负面影响比前一种情况更明显。

分类任务中样本评估的排列重要性(图片由作者提供)

同样，可以以热图格式显示每个样本和每个特征中所有样本的重要性。

总结所有功能的效果(图片由作者提供)

保持相同的可视化格式，可以显示要素对预测类的影响。

总结一个特性对所有类的影响(图片由作者提供)

例如，挥发性酸度的低值对标签 3 和 4 有很大影响，而对于标签 7、6 和 5，酸度的高值有很大影响。

摘要

在这篇文章中，我们介绍了排列重要性的基本概念，作为计算特性重要性的过程。然后，我们试图利用它的简单性，对其进行调整，以更好地解释我们的模型输出。结果，我们获得了有用的见解，并以图形格式显示出来，为非技术人员保留了可解释性。

查看我的 GITHUB 回购

保持联系: Linkedin

为数据科学毕业生/爱好者提供先进的项目理念，方便他们寻找工作

原文：https://towardsdatascience.com/advanced-project-ideas-for-data-science-graduates-enthusiasts-to-ease-their-job-search-ee14420b261?source=collection_archive---------24-----------------------

数据科学是一个广阔的领域。它可以从把莎莎酱放在当地商店的芯片旁边到火星漫游者！我将分享一些项目想法，这些想法将使您能够做更现实的项目，最适合当前的技术和业务场景。

Shravankumar Hiregoudar 在 Unsplash 上拍摄的照片

数据科学家经常用简单明了的方法对干净、结构化的数据进行学术/业余项目。虽然我同意最好从简单的数据集开始，但这些项目与现实世界的场景没有任何关系，我们经常很难找到这些项目的工作。这些公司会寻找一个比你使用的工具和技术更适合他们业务的候选人。如果你能在工具和语言的帮助下做一个更现实的项目，那么你的项目故事将符合真实世界的数据场景！如果你同意我的观点，那么让我们开始吧。

数据科学求职小技巧:链接

让我们来谈谈这个项目的想法，它涉及到:

  1. 产品感
  2. 多个数据源
  3. 准备部署
  4. 与 ETL 工具和 DW 的集成
  5. 非结构化数据
  6. 帮助小企业成长

产品感

亚历山大·安德鲁斯在 Unsplash 拍摄的照片

基于产品的公司中的数据科学家通常致力于预测和设置产品团队目标、设计和评估实验、监控关键产品指标、了解指标变化的根本原因、构建和分析仪表板和报告、构建关键数据集以支持运营和探索性分析，以及评估和定义指标。

了解 KPI、指标、A/B 测试，并对产品有一个完整的认识变得至关重要。如果你的目标是基于产品的公司，你应该做一个涉及 KPI、度量、A/B 测试和产品参与的项目。你应该能够通过你的项目回答这些问题；

  • 您将如何创建一个模型来预测这一指标？
  • 你如何测试产品的新特性？
  • 你想完成什么？你想用你的数据解决什么问题？

一家方公司的数据科学家职责。看到产品感的重要性了吧！(截图)

多个数据源

由 Eric Prouzet 在 Unsplash 上拍摄的照片

在现实世界中，客户/公司到处都有数据。最好了解如何提取、转换和合并所有不同的数据源，以便更好地使用和预测。只处理 CSV 文件会限制您的范围，并且不能清晰地描述实际的案例场景。

处理具有多个来源的项目，因为这对于现代业务和分析是必要的，但是如果不小心，可能会导致数据质量问题。通过这种方法，您将学会如何处理，

  • 数据的异质性
  • 数据源集成
  • 缩放问题
  • 数据冗余

了解这些问题并解决它们会让你成为更好的数据科学家。

准备部署

由 SpaceX 在 Unsplash 上拍摄的照片

部署模型是数据科学家工作的一部分，因为系统可以通过调用机器学习模型来进行实时预测。当 ML 项目在生产中部署时，我们必须监控性能并构建系统化的工具，这些工具可以处理性能下降并找到正确类型的数据以流回 ML 生命周期的早期阶段，从而重新训练和更新模型以参与 CI/CD(持续集成和持续部署)。最重要的部分是确保数据系统地流向早期阶段。

为了理解 ML 部署，您可以尝试将最终模型部署到 S3 上，并从 ETL/雪花中调用它来执行预测。此外，如果你不是初学者，可以尝试使用亚马逊 sagemaker 而不是 jupyter notebook 进行编码。这些整合将使你能够理解 ML 如何在大范围内工作，以及实时预测是如何发生的。

与 ETL 工具和 DW 的集成

照片由迈克·彼得鲁奇在 Unsplash 上拍摄

当你看到一个大规模的机器学习过程时，理解 ETL、DB 和 DW 的作用对于一个数据科学家来说变得非常重要。ETL 或 DW 的角色绝对是数据工程师的。尽管如此，一些公司要求数据科学家理解和实现这些。尽管如此，了解 ETL、DW 和 DB 的基础知识将有助于您编写更好的集成代码。整个 ML 系统更有意义。

您可以在 ETL 工具中执行提取、转换和加载，然后在 notebook/sagemaker 中输入干净的数据来构建模型和执行预测。这将有助于你处理集成和流水线问题，这是一件很重要的事情。您还可以使用 AWS 或雪花来理解这些工具在数据世界中的作用。

非结构化数据

里克·梅森在 Unsplash 上的照片

非结构化数据是指没有预定义方式的信息。它可能以文本为主，如开放式调查回复和社交媒体对话，也可能包括图像、视频和音频。现实世界中的数据通常是非结构化的，这种数据不需要预处理和清洗。如果分析正确，来自非结构化数据的结果更有价值。

处理非结构化数据的项目将使您认识到数据清理和预处理对于建模的重要性。这些非结构化数据由于其复杂性而经常被忽略；利用这个机会，学习如何处理这些数据。它包含有价值的信息，可以促进业务发展。

帮助小企业成长

照片由卡罗琳·布鲁曼斯在 Unsplash 拍摄

像这样具有挑战性的时代需要每个人尽我们所能地投入和帮助。在做一个学术/业余爱好项目的时候，试着接近一家收集了足够数据的当地企业，以进行预测和绘制模式。这些结果将有助于他们将商品更好地摆放在过道上，或者打折出售。永远学习人工智能，并尝试用你的技能帮助他人或企业。

如果你是以新生的身份申请或者改变工作领域，项目就变得至关重要。做高质量的项目会让你在真实世界的场景中体验不同的数据部分，这在找工作时是一个优势。此外，这些项目将帮助您了解数据科学在业务中的影响。完成项目后，在 GitHub 推送，写一个小报告，说明你的思考过程和旅程。

你也可以看看数据科学求职博客:

BigQuery SQL 中的高级随机采样

原文：https://towardsdatascience.com/advanced-random-sampling-in-bigquery-sql-7d4483b580bb?source=collection_archive---------13-----------------------

了解如何以可重现的方式对 BigQuery 表中的行进行采样

做你想知道如何在 BigQuery SQL 中采样吗？在这里，我将向您展示如何在 Google BigQuery 中以一种可以重现结果的方式进行随机采样。我还将向您展示如何同时获取多个样本并计算后面的更好的统计数据。

我在为 BigQuery 寻找一些大的东西… |照片由paweczerwi324ski在 Unsplash 上拍摄

我确实有一些关于 BigQuery 的其他文章，所以请查看我的个人资料以获得更多 BQ 阅读:

https://niczky12.medium.com

要获得所有媒体文章的完整访问权限，包括我的文章，请考虑在此订阅。

生成一些数据

BigQuery 中有一些很棒的开放数据集，但是它们相当大，所以如果你不够小心的话，你很容易因为查询它们而被收费。我鼓励你去看看这些数据集，但是这里我将生成一个很小的数据集，只是为了确保我不会因为任何查询而被计费(BQ 有 1TB/月的免费 trier 限制)。

这将给出 2 组(a 和 b ),第一组在 5 和 15 之间具有均匀随机分布,第二组在 2 和 9 之间具有均匀随机分布。

您可以使用此方法从任意两个数字之间的均匀随机分布中生成一个数字列表。

我们将在整个教程中使用这个数据集，所以我建议您将它保存为数据集——我将它保存为ds.random_table，这是我在后面的查询中引用它的方式。

查询解释—请随意跳过

如果您还不熟悉 BQ 中的数组或随机函数，下面是上面查询中发生的情况:

  • 我们创建一个从 1 到 1000 的数组。
  • 对于 a 组，我们将这个数组扩展为每行一个数字(unnest)
  • 我们为这一千行中的每一行添加一个标志group_a和一个随机数。
  • 我们对group_b重复同样的事情，用union all把它加到上表的末尾。

简单抽样

照片由 Djim Loic 在 Unsplash 上拍摄

网上有一些关于随机抽样的 SQL 教程，提倡使用RAND()函数。让我们看看这是如何工作的，以及为什么你不应该使用它😉。

我们将随机抽取 20 个 id，然后取v数的平均值以及group_a和group_b观察值的计数。

我们如何做到这一点？我们为每个项目生成一个介于 0 和 1 之间的随机数，根据这个随机数对行进行排序，然后可以将前 20 行作为我们的样本。

现在，给定这个样本表，我们计算我们的统计数据:

我得到以下结果:

从 BigQuery UI 捕获的图像

现在让我们再运行一次:

从 BigQuery UI 捕获的图像

哇，这不一样。😱

Gif 来自 GIPHY 。

这并不十分理想，因为我想确保我在 BQ 中所做的任何计算都能被我的数据科学家同事复制。让我们看看你如何做到这一点。

哈希可重复采样

照片由S O C I A L C U T在 Unsplash 上拍摄

函数RAND()的问题在于它在每次执行时都会创建新的随机数。因此，第一行可能在第一次运行时得到 0.2，但在第二次运行时得到 0.99。我们想要实现的是为每一行获得相同的随机数。

这就是散列变得有用的地方。哈希函数接受一个字符串或数字，并返回一个随机但一致的字符串或数字。在 BQ 中最容易使用的散列函数是farm_fingerprint。这个函数总是为相同的输入返回相同的整数，它可以接受字符串作为输入。让我们看看它与没有输入的RAND()相比如何。

结果是:

从 BigQuery UI 捕获的图像

您可以看到，我们的两个 Alberts 具有相同的 farm_fingerprint 值，而我们的 rand 函数返回了不同的值。更好的是，farm_fingerprint将在每次运行时产生相同的数字。

继续尝试吧，上面的查询在 BQ 中没有任何成本，因为我们在查询时生成所有的数据。

有了这个新的闪亮的函数，是时候修改我们原来的采样查询并使它完全可再现了。

这里发生了什么事？

  1. 我们使用row_number函数创建了一个名为rn的整数列
  2. 我们将它们转换为字符串，因为farm_fingerprint需要一个字符串或字节输入。
  3. 然后，代替rand(),我们使用farm_fingerprint函数来生成一些我们可以排序的随机数。

无论运行多少次查询，我都会得到以下结果。(您可能会得到稍微不同的结果，因为我们的原始表是由rand()生成的，所以您的基本数字可能会有所不同)。

在真实的场景中，您可能已经有一个与您的数据相关联的行 id 或用户 id 。在这种情况下，您可以随意将其作为输入传递到farm_fingerprint中。只是注意重复的 id，因为这些重复的 id 将具有相同的散列！这可能是你在某些情况下想要的。

模数采样比

我们现在知道如何重复采样值。但是对于大型数据集，对整个表进行排序，然后取前 n 行可能会有问题。我们如何在不点餐的情况下占桌子的 x%?

我们的散列函数总是返回一个整数。那个整数有时能被 10 整除，有时不能。因为散列函数将观察值相当均匀地分布在整数上，我们希望 10 个散列中有 1 个(10%)能被 10 整除。类似地，平均来说，1%的数字应该能被 100 整除。我们可以利用这一点来决定是否要保留一个数字。

为了抽取 15%的样本，我们将散列的模取 100，然后选择模小于 15 的所有数字。

这里有一个陷阱！BQ 模运算符可以为负整数返回负数。所以必须先取绝对值。

以上比之前复杂了一点。这是因为我们想要使用一个where语句，并且不能包含一个row_number()函数——或者任何带有over()部分的东西。所以我们首先创建行号，然后使用farm_fingerprint获取样本。

当您像这样采样时，在 SQL 代码中添加注释，因为新数据科学家可能会发现很难理解您将要采样的比率！

多个样本

Miguel Orós 在 Unsplash 上拍摄的照片

作为我们的最后一步，我们将采取多个样本，然后计算每组的样本平均值。这会变得很有趣，所以系好安全带！

这是我们要做的:

  1. 创建一个长度为n的数组，其中n是我们想要采样的次数。我们称这个数字为sample_id。
  2. 将我们的数组sample_id交叉连接到原始数据集，以复制每个项目n次。
  3. 将sample_id和行号组合起来，为每一行获得一个惟一的 id，我们可以用它来处理farm_fingerprint。
  4. 使用模方法获得所有观察值的 15%—平均每个sample_id将获得每个观察值的 15%。
  5. 根据sample_id和组 id 获取平均值。

如果您绘制结果，您将得到以下结果:

是的，这是从谷歌床单。随便你怎么评价我，我都懒得读成 Python。|来源:作者创作

这给了我们非常好的估计——和两个漂亮的钟形曲线——对于我们两个不同的组。没错，这就是中心极限定理在起作用。回到最初的数据生成步骤，看看这是否正确估计了我们的人口均值！

记住 BigQuery 是按查询的字节收费的，而我们只查询了一次我们的原始数据。我们只是碰巧把它交叉连接到一堆整数上来复制我们的采样 1000 次！🎉

现在，您可以使用数组、farm_fingerprint 和 mod，通过便宜的 BigQuery 获得更好的统计估计！

结论

感谢阅读到最后！🙏

现在，您知道了如何使用 Google BigQuery 中一些方便的函数在 SQL 中进行采样。你已经学会了:

  • 如何免费生成一些均匀分布的哑数据？
  • 为什么不应该使用rand()函数来采样
  • 那个farm_fingerprint接受字符串或字节，给你散列的整数。
  • 如何使用模函数进行采样？
  • 如何通过与整数列表交叉连接来获取多个样本？

通过阅读更多内容，让您的 BigQuery 技能更上一层楼😅：

使用 Python 进行高级回归分析

原文：https://towardsdatascience.com/advanced-regression-f74090014f3?source=collection_archive---------23-----------------------

用 Python 实现大学统计

介绍

在一系列的每周文章中，我将会涉及一些重要的统计学主题。

目标是使用 Python 来帮助我们获得对复杂概念的直觉，从经验上测试理论证明，或者从零开始构建算法。在本系列中，您将会看到涵盖随机变量、抽样分布、置信区间、显著性检验等主题的文章。

在每篇文章的最后，你可以找到练习来测试你的知识。解决方案将在下周的文章中分享。

迄今发表的文章:

  • 伯努利和二项随机变量与 Python
  • 用 Python 从二项式到几何和泊松随机变量
  • 用 Python 实现样本比例的抽样分布
  • Python 的置信区间
  • 使用 Python 进行显著性测试
  • 用 Python 进行组间差异的双样本推断
  • 分类数据的推断
  • 高级回归
  • 方差分析— ANOVA

像往常一样，代码可以在我的 GitHub 上找到。

线性回归中斜率的推断

想象一下，你想根据一个数据科学家编码的年数来预测他的工资。为了建立这种关系，我们可以从数据科学家群体中随机抽取 20 个人，并绘制关系图(注意，工资单位是 10，000€)。同时，我们可以计算出最佳拟合的线。

图 1:数据科学数据科学是一个跨学科的领域，利用科学的方法、过程、算法和系统从结构化和非结构化数据中提取知识和见解；来源

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import t, chi2salaries = [[4, 5.5, 3.5, 6, 7, 9, 3.4, 5.3, 4.3, 5.3, 6, 6.2, 6.5, 7, 7.1, 4.3, 5.2, 5, 5.7, 3.2]]
yearsCoding = [[2, 5, 1, 4, 5, 10, 2, 2, 4, 3, 4, 6, 5, 6, 7, 4, 3, 4, 4, 3]]
n = 20plt.scatter(yearsCoding[0], salaries[0])
plt.xlabel('Years Coding')
plt.ylabel('Salary');

图 2:数据科学家样本的工资(10，000€)按编码年数。

最佳拟合线可以通过最小化数据点和线之间的平方距离来计算。回归线的方程式如下:

其中 b 是斜率，a 是回归线的截距。请注意，通过为我们的数据计算这条线，我们计算了 20 名数据科学家的单一样本的最佳拟合线。我们可以计算出一条不同的最佳拟合线，用于我们从总体中抽取的不同样本。发生这种情况是因为我们在估计总体的参数。如果您可以获得世界上所有数据科学家的工资和编码年数来构建您的模型，您将可以估计真实的总体参数。在这种情况下，我们用α 和β代替 a 和 b:

因为我们使用样本来估计总体参数，所以我们可以根据这些样本进行推断。考虑到这一点，我们知道 b 不会完全等于β，但是我们能说工资和编码年限之间存在正的线性关系或者非零的线性关系吗？事实上，我们可以通过定义该统计数据的置信区间来实现。这样，我们就能很好地理解真正的参数可能在哪里。在以前的文章中，我们看到了如何计算这样的区间:我们减去/加上临界值 t*乘以 b 的标准误差。

同样，我们可以为斜率参数定义一个假设检验。一种说法是变量之间没有关系，作为无效假设，另一种说法是变量之间有关系(你也可以更具体地定义另一种假设，只有正或负)。

正如在任何其他推理过程中一样，我们必须尊重条件以确保有效的结果。在这种情况下，对于线性回归的斜率，我们必须确保:

  • 数据必须是随机生成的；
  • 个人观察应该是独立的(或近似独立的——记住 10%规则)；
  • 变量之间的关系必须是线性的；
  • 对于总体中任意给定的 x，y 的分布一定是正态的；
  • 对于任何给定的 x，方差应该是常数。

从头开始拟合回归线

我们已经定义了回归线的方程。现在，我们需要定义成本函数和更新参数的方法。对于我们的成本函数，我们将使用均方差:

为了更新我们的参数，我们将使用梯度下降。我不会深入讨论这个方法；我只想给出一些直觉。第一步是计算成本函数相对于每个参数的梯度:

然后我们相应地更新参数:

其中α代表学习率。

def fit_lr(X, y, num_iter=1000, lr=0.01):
    n_samples = X.shape[0]
    slope = 0
    intercept = 0

    for _ in range(num_iter):
        y_predicted = np.dot(X, slope) + intercept

        ds = (1/n_samples) * np.dot(X.T, (y_predicted - y))
        di = (1/n_samples) * np.sum(y_predicted - y)

        slope -= lr * ds
        intercept -= lr * di

    return (slope, intercept)slope, intercept = fit_lr(np.array(yearsCoding[0]), np.array(salaries[0]))plt.scatter(yearsCoding[0], salaries[0])
plt.xlabel('Years Coding')
plt.ylabel('Salary')
plt.plot(yearsCoding[0],slope*np.array(yearsCoding[0]) + intercept, color='r');

图 3:最佳拟合线(红色)对数据科学家样本的工资(10，000€)和编码年数之间的关系进行建模。

print('Slope=' + str(slope))
print('Intercept=' + str(intercept))Slope=0.7096702503648314
Intercept=2.4147010493601404

一个编码 15 年的数据科学家工资会是多少？

slope * 15 + intercept13.059754804832611

大约是 13 万€。

斜率的置信区间

我们可以将斜率^b 视为正态分布的随机变量，其均值为 b，方差等于 σ 除以 x 的平方和

由于我们不知道总体方差，我们使用抽样方差来计算标准误差(se):

我们可以将 SE 描述为回归线斜率的抽样分布的标准偏差。

SS_xx = np.sum((np.array(yearsCoding[0]) - np.mean(np.array(yearsCoding[0])))**2)
SS_xx79.20000000000002SE_b = (np.sqrt(np.sum((np.array(salaries[0])-(np.array(yearsCoding[0])*slope+intercept))**2)/(n-2))) / np.sqrt(SS_xx)
SE_b0.08687984291368046

我们最终可以计算出线性回归斜率的 95%置信区间。

print('95% Confidence interval=[' + str(np.round(slope - t.ppf(0.975, df=n-2)*SE_b,2)) + ',' + str(np.round(slope + t.ppf(0.975, df=n-2)*SE_b,2)) + ']')95% Confidence interval=[0.53,0.89]

回想一下，95%的置信区间意味着真实斜率在 95%的时间里都包含在我们的置信区间内。

我们可以用这个区间在α= 0.05 的显著性水平上检验以下假设:

我们能得出什么结论？假设 H_0 为真，我们面临β=0 不与 95%区间重叠的情况，这种情况发生的概率小于 5%。因此，我们拒绝 h0，接受建议的 h1。它指出，编码的年数和数据科学家的工资之间存在某种关系(非零)。

非线性回归

现在，假设一个数据科学家的工资和编码的年数之间的关系不是线性的。在这种情况下，我们看到它更接近于指数关系。如果我们试图用一条线来拟合这些数据，会发生什么？

salaries =    [[3.5, 7.5, 2.5, 7, 9, 40, 3.4, 4.3, 5.3, 5.3, 4, 12.2, 8.5, 10, 18.1, 4.3, 5.2, 5, 5.7, 5.2]]
yearsCoding = [[2, 5,   1  , 4, 5, 10, 2  , 2  , 4,   3  , 4, 6  , 5  , 6 , 7   , 4   , 3  , 4, 4  , 3  ]]
n = 20plt.scatter(yearsCoding[0], salaries[0])
plt.xlabel('Years Coding')
plt.ylabel('Salary');

图 4:数据科学家不同样本的薪资(10000€)与编码年数之间的指数关系。

slope, intercept = fit_lr(np.array(yearsCoding[0]), np.array(salaries[0]))plt.scatter(yearsCoding[0], salaries[0])
plt.xlabel('Years Coding')
plt.ylabel('Salary')
plt.plot(yearsCoding[0],slope*np.array(yearsCoding[0]) + intercept, color='r');

图 5:最佳拟合线(红色)对数据科学家样本的工资(10，000€)和编码年数之间的指数关系建模不佳。

print('Slope=' + str(slope))
print('Intercept=' + str(intercept))Slope=3.35501894004377
Intercept=-5.5729005963397205

我们发现我们拟合的线根本不能解释这些数据。我们甚至会得到一个刚开始编码的人的负工资，而且我们会严重低估一个编码了 10 年的人的工资。我们有两个选择。第一种是用指数线拟合数据。这种方法的问题是，我们失去了我们一直在开发的工具来拟合和分析两个变量之间的线性关系。另一方面，我们可以在拟合回归线之前转换我们的数据。

plt.scatter(yearsCoding[0], np.log(salaries[0]))
plt.xlabel('Years Coding')
plt.ylabel('ln(Salary)');

图 6:数据科学家样本按编码年限的工资自然对数(万€)。

slope, intercept = fit_lr(np.array(yearsCoding[0]), np.log(np.array(salaries[0])))plt.scatter(yearsCoding[0], np.log(salaries[0]))
plt.xlabel('Years Coding')
plt.ylabel('ln(Salary)')
plt.plot(yearsCoding[0],slope*np.array(yearsCoding[0]) + intercept, color='r');

图 7:最佳拟合线(红色)对数据科学家样本的工资(10，000€)的自然对数和编码年数之间的关系进行建模。

print('Slope=' + str(slope))
print('Intercept=' + str(intercept))Slope=0.3173211894646696
Intercept=0.5195321580809141

通过转换，我们看到最佳拟合线实际上解释了编码的可变年数和转换后的可变薪金之间的关系。但是请注意，原始变量之间的关系不是线性的，而是指数关系。

在这种情况下，编码 15 年的数据科学家的工资是多少？

np.exp(slope * 15+intercept)196.24227641696947

这将是几乎 2M€！将其与我们之前使用的线性数据集的结果进行比较。

结论

本文介绍了如何解决线性回归问题，然后使用我们的最佳拟合线来推断我们的参数。在这种情况下，我们关注斜率参数，使用置信区间和假设检验来评估两个感兴趣的变量之间的关联类型。最后，我们引入了转换变量的概念来处理数据可能具有非线性模式的事实。

保持联系: LinkedIn

练习

你将在下周的文章中找到答案。

  1. Márcia 收集了便携式电脑随机样本的电池寿命和价格数据。根据下面提供的数据，总体斜率为 0 的零假设的检验统计量是什么？
  2. 芮随机抽取了一些同事，注意到他们的年龄和他们昨天步行的公里数成正比。回归线斜率的 95%置信区间为(15.4，155.2)。芮想用这个区间在 5%的显著性水平上检验 H_0: β=0 vs. H_1: β ≠ 0。假设推断的所有条件都已满足。芮应该得出什么结论？

上周的答案

  1. 根据冲浪板经销商的说法，66%的冲浪板是常见的，25%是不常见的，9%是罕见的。José想知道他和他的朋友拥有的板子的稀有程度是否遵循这种分布，所以他随机抽取了 500 块板子并记录了它们的稀有程度。结果如下表所示。进行拟合优度测试，以确定 José和他的朋友拥有的冲浪板的稀有程度分布是否与声称的百分比不一致。
table = [['Cards', 345, 125, 30]]
alpha = 0.05
df = pd.DataFrame(table)
df.columns = ['Rarity level', 'Common', 'Uncommon', 'Rare']
df = df.set_index('Rarity level')
df


arr = df.to_numpy()

arr = np.concatenate((arr, (np.sum(arr)*np.asarray([0.66, 0.25, 0.09])).reshape(1,-1)))chi_sq_statistic = np.sum((arr[0]-arr[1])**2/arr[1])
chi_sq_statistic5.681818181818182print('P-value = ' + str(np.round(1-chi2.cdf(chi_sq_statistic, df =2), 4)))P-value = 0.0584if 1-chi2.cdf(chi_sq_statistic, df =2) < alpha:
    print('Reject H_0')
else:
    print('Fail to reject H_0')Fail to reject H_0

高级 SQL 操作

原文：https://towardsdatascience.com/advanced-sql-operations-8856084a95a8?source=collection_archive---------13-----------------------

查看更高级的 SQL 操作，以从爱尔兰天气数据集中提取额外的数据洞察。

施泰耶·希勒沃特在 Unsplash 上的照片

在上一篇文章中，我们开始了解可以执行的基本 SQL 操作。这些操作帮助我们对数据集有了初步的了解。他们确保我们优化了解释器，以有效地分析数据。

https://medium.com/codex/weathering-the-sql-interpreter-13ebaa175955

本文旨在更深入地研究和回顾更高级的 SQL 操作。

鲜明的

distinct 操作旨在显示列中包含的唯一值。查看数据集时，可能存在多个重复值。一些列可能包含一些离散值，这些值会产生一个简短的唯一值列表。而具有大范围值的列(如连续列)会有大量离散值。意识到这种差异有助于理解列的基数。对于连续变量，划分为单独范围值的方法可以提供更多信息。

代码 1.1 概述了列中的不同值

SQL 输出 1.1 是对 county 列的不同查询的结果

从代码 1.1 和下面的输出中，我们可以看到 county 列有一个简短的唯一值列表。对 continuous temperature 列执行相同的操作会产生一个更大的列表。

联合

UNION 操作旨在将两个或多个查询的结果组合成一个结果输出。在大多数数据库中，有两种选择。首先，UNION 语句组合了来自所提供查询的所有唯一值。这旨在将输出减少到最少数量的值。小心地按正确的顺序排列查询可以减少显示错误结果顺序的机会。第二个选项是 UNION ALL 语句，它旨在将所有值组合在一起，而不执行任何重复的检查。

代码 1.2 通过联合合并两个查询结果

从代码 1.2 开始，我们创建了两个查询，这两个查询组合起来显示一个数据集中的汇总值。我们需要确保每个查询中显示的相同列的顺序相同。如果一个列只存在于一个查询中，那么相应的列应该在另一个查询中设置为缺失值。

SQL Output 1.2 来自两个 SQL 查询结果的所有不同值的联合

上面的输出显示两个查询已经堆叠在一起，并且所有的唯一值都保留了下来。

排序依据

以正确的顺序输出有助于向最终用户显示附加信息。使用 order by 语句，我们能够以类似于 group by 语句的方式对结果进行排序。可以使用各种列，例如:现有列、列别名或聚合函数。

代码 1.3 查询同一订单的两个变体

代码 1.3 中显示的代码显示了同一查询的变体，在感兴趣的列后添加了关键字 DESC。包含此关键字可确保结果以降序显示，因为默认操作是升序。

SQL 输出 1.3 创建最高温度的降序

SQL 输出 1.3 突出显示了应用于最高温度的下降操作的结果。

极限和偏移

当第一次与数据集交互时，我们有兴趣了解数据样本是什么样的。通过查看数据样本，我们可以获得关于列如何显示的有价值的见解。它允许开发人员快速产生数据分析想法。此外，当开始产生派生变量时，我们可以通过在较小的样本上执行它们来减少操作的开销。一旦我们对样本的操作感到满意，就可以将它们转移到整个群体。然而，我们必须始终意识到，小样本可能与总体差异很大，因此需要进行其他分析，以确保不会产生奇怪的结果。

代码 1.4 极限方法的两种变化

从上面显示的代码中，我们可以看到每次都提取顶部的记录，并使用偏移量进行了轻微的修改。

选择顶部记录的 SQL 输出 1.4 结果

正如 SQL 输出 1.4 所示，在应用了其他 SQL 操作之后，已经提取了顶部的记录。此示例从整个数据集中为筛选的数据挑选出最高温度。

偏移前两个结果行后，SQL 输出上限值的 1.5 个结果

通过引入偏移操作，我们能够排除前两个结果并显示下一个最佳输出。如果您意识到输出将包含一些可能影响列解释方式的异常值，这种分析可能会很有用。

窗口

旨在从结果集中创建一个包含一行或多行的窗口。有很多种方法可以应用于这种操作。我们展示了一些高级方法，可以帮助快速总结感兴趣窗口中的列。

代码 1.5 使用窗口对结果进行分区

SQL 输出 1.6 从窗口 order by 方法创建等级值

row_number 突出显示了 partition 子句中的行数。而等级显示了与其他值相比的相对等级。在上面的输出中，我们看到窗口操作的相似值显示为相同的等级值。

结论

使用高级 SQL 技术确实有助于提高从数据集发现的数据洞察力。在本文中，我们看到了检查唯一值如何有助于开发聚合统计数据。然而，随着订单语句的添加，最高或最低值可以真正显示出来。union 的使用有助于堆叠数据集分析，这对于时间序列输出非常有效。当我们窥视数据集内部时，引入限制可以帮助初始发现过程。最后，对窗口功能的简要介绍有助于在单独的窗口中查看数据。

感谢阅读

高级 Streamlit:数据标签工具的会话状态和回调

原文：https://towardsdatascience.com/advanced-streamlit-session-state-and-callbacks-for-data-labelling-tool-1e4d9ad32a3f?source=collection_archive---------4-----------------------

我制作的一个数据标签工具中的 Streamlit 会话状态和回调的例子。

图片由作者提供。

如今，使用 Streamlit创建一个 web 应用程序非常简单，但是在构建复杂的东西时会有一些限制。其中之一是缺乏有状态性，因为每次我们与小部件交互时，代码中的变量都会重新初始化。好消息是 Streamlit 现在在 0.84 版本中提供了对会话状态和回调函数的本地支持。我们现在可以跨重新运行存储变量，并在与小部件交互时定义我们的自定义事件处理程序。

会话状态

自 2019 年 10 月以来，会话状态的黑客攻击就已经存在，但新的st.session_state为我们提供了一个访问有状态变量的优雅解决方案。在我的数据标记工具中，会话状态的一个用例是能够保存所选的项目。该应用程序需要知道有哪些可用的项目，以及该项目正在进行中。这可以通过以下方式简单实现:

import streamlit as st# set variables in session state
st.session_state.projects = [
    'Boring Project', 'Interesting Project'
]
st.session_state.current_project = st.radio(
    'Select a project to work with:',
    st.session_state.projects,
)

下一步是获取所选项目的数据。除了选定的项目，该应用程序还需要获取数据的行索引。为简单起见，我们假设有一个从数据库中提取数据的函数，如下所示:

def fetch_data(project_name: str, row_index: int):
    """ A simple example function to fetch data. """
    dbs = {
        'Boring Project': [...],
        'Interesting Project': [...],
    }
    return dbs[project_name][row_index]  # output can be any formif 'current_project' in st.session_state:
    row_index = st.session_state.get('row_index', 0)
    data = fetch_data(st.session_state.current_project, row_index)

一旦用户单击下一个或上一个数据，会话状态中的row_index变量可以设置为另一个数字，新数据将自动加载。

# examples to update row index
if st.button('Next', key='next_data'):
    st.session_state.row_index += 1if st.button('Previous', key='previous_data'):
    st.session_state.row_index -= 1

复试

回调是当输入小部件被触发时调用的函数。支持回调的 Streamlit widgets 有st.button()、st.radio()、st.text_input()等。让我们看一个在提交按钮中添加新项目的回调例子。

def submit_add_project(project_name: str):
    """ Callback function during adding a new project. """
    # display a warning if the user entered an existing name
    if project_name in st.session_state.projects:
        st.warning(f'The name "{project_name}" is already exists.')
    else:
        st.session_state.projects.append(project_name)new_project = st.text_input('New project name:',
                            key='input_new_project_name')
st.button('Add project', key='button_add_project',
          on_click=submit_add_project, args=(new_project, ))

注意回调函数需要project_name参数，因此我们需要使用args传递参数。除了添加新项目之外，我们还应该允许用户通过以下方式删除项目:

def submit_delete_project(project_name: str):
    """ Callback function during deleting an existing project. """
    st.session_state.projects.remove(project_name)to_delete = st.selectbox('Project to be deleted:',
                         st.session_state.projects)
st.button('Delete project', key='button_delete_project',
          on_click=submit_delete_project, args=(to_delete, ))

结论

本文展示了一些会话状态和回调的例子，这些例子使应用程序能够在重新运行和与小部件交互时保留变量。我建议您尝试与他们深入了解，并查看 streamlit 博客帖子。最后，您可以在 Github 中找到数据标签工具的 repo。

这是我的第一篇媒体文章，我非常感谢你们成为我的读者。希望你喜欢这篇文章，并从中学到一些东西。谢谢你的时间。注意安全。

微调变压器的先进技术

原文：https://towardsdatascience.com/advanced-techniques-for-fine-tuning-transformers-82e4e61e16e?source=collection_archive---------0-----------------------

提示和技巧

学习这些先进的技术，看看它们如何帮助改善结果

用 Python 代码生成的 Transformer 单词云。作者图片

T 变压器——大家好，我们又见面了。我们有个约会，不是吗，罗伯塔？

如果你已经阅读并坚持了我之前关于 变形金刚的帖子，你能评价阅读段落的复杂性吗？ 太棒了！这意味着你很可能已经熟悉了变压器微调或培训过程的基础。如果你没有看到这个帖子，你可以访问下面的链接。

你的模特怎么样了？它能取得相当好的结果吗？或者你的变压器模型遭受性能和不稳定性？如果是，根本原因通常很难诊断和确定。这类问题通常在大型模型和小型数据集上更为普遍。相关数据和下游任务的性质和特征也有一定影响。

如果您的变压器的性能没有达到您的预期，您能做什么？您可以尝试超参数调谐。此外，你也可以尝试使用一些高级的训练技巧，我将在这篇文章中介绍。这些技术可用于微调 BERT、ALBERT、RoBERTa 等变压器。

内容

1。分层学习率衰减(LLRD)
2。预热步骤
3。重新初始化预训练层
4。
5 随机加权平均法。频繁评估
结果
总结

对于我们在这篇文章中要做的所有高级微调技术，我们将使用我们从 变形金刚中得到的相同模型和数据集，你能评价阅读段落的复杂性吗？

最后，我们将能够将基本微调的结果与我们通过应用高级微调技术获得的结果进行相对比较。

1.分层学习率衰减(LLRD)

在重温少样本 BERT 微调中，作者将逐层学习速率衰减描述为"一种对顶层应用较高学习速率、对底层应用较低学习速率的方法。这是通过设置顶层的学习率并使用乘法衰减率从上到下逐层降低学习率来实现的”。

在用于文本分类的通用语言模型微调中也表达了被称为区别性微调的类似概念。

“区别性微调允许我们以不同的学习率调整每一层，而不是对模型的所有层使用相同的学习率”

所有这些都是有意义的，因为 Transformer 模型中的不同层通常捕获不同种类的信息。底层通常编码更常见、通用和广泛的信息，而更接近输出的顶层编码更本地化和特定于手头任务的信息。

在我们开始实施之前，让我们快速回顾一下我们为 变形金刚所做的基本微调，你能评价一下阅读段落的复杂性吗？

在由一个嵌入层和 12 个隐藏层组成的roberta-base模型上，我们使用了线性调度器，并在优化器中设置了初始学习速率1e-6(即 0.000001)。如图 1 所示，调度程序创建了一个学习率在训练步骤中从1e-6线性下降到零的时间表。

图 1:初始学习率为 1e-6 的线性时间表。作者图片

现在，要实现逐层学习速率衰减(或区别性微调)，有两种可能的方法。

第一种方法是遵循中描述的方法，重新考虑少样本 BERT 微调。我们为顶层选择学习速率3.5e-6，并使用乘法衰减速率0.9从上到下逐层降低学习速率。这将导致底层(embeddings和layer0)的学习率大致接近1e-6。我们在一个名为**roberta_base_AdamW_LLRD**的函数中实现了这一点。

好了，我们已经设置了隐藏层的学习速率。pooler和regressor头怎么样？对于他们，我们选择3.6e-6，比顶层略高的学习率。

在下面的代码中，head_params、layer_params和embed_params是定义我们想要优化的参数、学习率和权重衰减的字典。所有这些参数组都被传递到由函数返回的AdamW优化器中。

下面是具有逐层学习率衰减的线性时间表的样子:

图 2:具有逐层学习速率衰减的线性时间表。作者图片

实现逐层学习速率衰减(或区别性微调)的第二种方法是将层分成不同的组，并对每个组应用不同的学习速率。我们将此称为分组 LLRD 。

使用一个新的函数**roberta_base_AdamW_grouped_LLRD**，我们将roberta-base模型的 12 个隐藏层分成 3 组，其中embeddings附加到第一组。

  • 集合 1:嵌入+层 0，1，2，3(学习率:1e-6)
  • 集合 2:第 4、5、6、7 层(学习率:1.75e-6)
  • 集合 3:第 8、9、10、11 层(学习率:3.5e-6)

与第一种方法相同，我们将3.6e-6用于pooler和regressor头部，这是一个略高于顶层的学习速率。

下面是分组 LLRD 的线性时间表:

图 3:分组 LLRD 的线性时间表。作者图片

2.热身步骤

对于我们使用的线性调度程序，我们可以应用预热步骤。例如，应用 50 个预热步骤意味着在前 50 个步骤(预热阶段)，学习率将从 0 线性增加到优化器中设置的初始学习率。之后，学习率将开始线性下降至 0。

图 4:带 LLRD 和 50 个热身步骤的线性时间表。作者图片

下图显示了在步骤 50 中各层的学习率。这些是我们为优化器设置的学习率。

图 5:悬停文本反映了第 50 步的学习率。作者图片

要应用预热步骤，在get_scheduler功能上输入参数num_warmup_steps。

scheduler = transformers.get_scheduler(
                "linear",    
                optimizer = optimizer,
                num_warmup_steps = 50,
                num_training_steps = train_steps
)

或者，你也可以使用get_linear_schedule_with_warmup。

scheduler = transformers.get_linear_schedule_with_warmup(                
                optimizer = optimizer,
                num_warmup_steps = 50,
                num_training_steps = train_steps
)

3.重新初始化预训练层

微调变压器是一件轻而易举的事，因为我们使用预先训练的模型。这意味着我们不是从零开始训练，这会占用大量的资源和时间。这些模型通常已经在大型文本数据语料库上进行了预训练，并且它们包含我们可以使用的预训练权重。然而，为了获得更好的微调结果，有时我们需要在微调过程中丢弃一些权重并重新初始化它们。

那么我们如何做到这一点呢？前面，我们讨论了转换器的不同层捕获不同类型的信息。底层通常编码更一般的信息。这些是有用的，所以我们想保留这些低级的表示。我们想要刷新的是更接近输出的顶层。它们是对预训练任务更具体的信息进行编码的层，现在我们希望它们适应我们的。

我们可以在之前创建的MyModel类中这样做。初始化模型时，我们传入一个参数，指定要重新初始化的顶部n层。你可能会问，为什么是n？事实证明，为n选择一个最佳值是至关重要的，可以导致更快的收敛。也就是说，有多少顶层要重新初始化？这要视情况而定，因为每个模型和数据集都是不同的。在我们的例子中，n的最佳值是 5。如果重新初始化超过最佳点的更多层，您可能会开始经历恶化的结果。

在下面的代码中，我们使用模型的initializer_range定义的平均值 0 和标准偏差重新初始化nn.Linear模块的权重，并使用值 1 重新初始化nn.LayerNorm模块的权重。偏差被重新初始化为值 0。

如代码所示，我们还重新初始化了pooler层。如果你没有在你的模型中使用pooler，你可以省略_do_reinit中与它相关的部分。

重新初始化层的代码改编自这里的。

4.随机加权平均法

随机权重平均(SWA) 是中提出的深度神经网络训练技术，平均权重导致更宽的最优值和更好的泛化能力。据作者称，

“SWA 非常容易实现，与传统的训练方案相比，几乎没有计算开销”

那么，SWA 是如何工作的呢？如 PyTorch 博客所述，SWA 由两部分组成:

  • 首先，它使用一个修改的学习率时间表。例如，我们可以在训练时间的前 75%使用标准的衰减学习率策略(例如我们正在使用的线性时间表),然后在剩余的 25%时间将学习率设置为一个相当高的恒定值。
  • 第二，它对所遍历的网络的权重进行平均。例如，在最后 25%的训练时间内，我们可以保持最后获得的重量的连续平均值。训练完成后，我们将网络的权重设置为计算出的 SWA 平均值。

py torch 中如何使用 SWA？

在torch.optim.swa_utils中，我们实现了所有的 SWA 成分，以方便在任何模型中使用 SWA。

特别地，我们实现了用于 SWA 模型的AveragedModel类、SWALR学习速率调度器和update_bn实用函数，以在训练结束时更新 SWA 批量标准化统计。

来源: PyTorch 博客

SWA 很容易在 PyTorch 中实现。您可以参考下面来自 PyTorch 文档的示例代码来实现 SWA。

用于实施 SWA 的示例代码来自 PyTorch 文档

为了在我们的run_training函数中实现 SWA，我们为swa_lr接受一个参数。该参数是设定为常数值的 SWA 学习率。在我们的例子中，我们将使用2e-6来表示swa_lr。

因为我们想切换到 SWA 学习率计划，并开始收集时段 3 的参数的 SWA 平均值，我们为swa_start指定 3。

对于每个文件夹，我们初始化swa_model和swa_scheduler以及数据加载器、模型、优化器和调度器。swa_model是累计权重平均值的 SWA 模型。

接下来，我们遍历这些时期，调用train_fn并传递给它swa_model、swa_scheduler和一个布尔指示器swa_step。这是一个指示符，告诉程序在时段 3 切换到swa_scheduler。

在train_fn中，从run_training函数传入的参数swa_step控制切换到SWALR以及平均模型swa_model的参数更新。

SWA 的优点是我们可以将它用于任何优化器和大多数调度器。在 LLRD 的线性时间表中，我们可以从图 6 中看到，在时段 3 切换到 SWA 学习速率时间表后，学习速率如何在2e-6保持不变。

图 6:带 LLRD、50 个热身步和 SWA 的线性时间表。作者图片

下面是在分组 LLRD 上实施 SWA 后，线性时间表的样子，有 50 个热身步骤:

图 7:具有分组 LLRD、50 个热身步骤和 SWA 的线性时间表。作者图片

你可以在这个 PyTorch 博客和这个 PyTorch 文档上阅读更多关于西南铝的细节。

5.频繁评估

频繁评估是另一种值得探索的技术。它简单的意思是，我们将对该时期内的每x批训练数据执行验证，而不是在每个时期验证一次。这需要在我们的代码中做一点结构上的改变，因为目前训练和验证功能是分开的，每个时期都调用一次。

我们要做的是创建一个新函数，train_and_validate。对于每个时期，run_training将调用这个新函数，而不是分别调用train_fn和validate_fn。

图 8:作者图片

在train_and_validate内部，对于每一批训练数据，都会运行模型训练代码。然而，为了验证，只会在每x批训练数据上调用validate_fn。因此，如果x是 10，并且如果我们有 50 批训练数据，那么每个时期将进行 5 次验证。

图 9:作者图片

结果

好了，激动人心的部分来了…结果！

这些技术能对结果有如此大的改善，这是相当令人惊讶的。结果显示在下表中。

平均 RMSE 分数从 0.589 到 0.5199，在应用了这篇文章中提到的所有先进技术后，有了基本的微调。

表 1:微调技术的结果

摘要

在本帖中，我们介绍了用于微调变压器的各种技术。

☑️首先，我们使用逐层学习率衰减(LLRD) 。LLRD 背后的主要思想是将不同的学习率应用于变压器的每一层，或者在分组 LLRD 的情况下应用于层的分组。具体来说，顶层应该比底层具有更高的学习速率。

☑️接下来，我们将热身步骤应用到学习率计划中。对于线性时间表中的预热步骤，学习率从 0 线性增加到预热阶段优化器中设置的初始学习率，之后开始线性减少到 0。

☑️:我们还为变压器的顶层n执行了重新初始化。为n选择一个最佳值是至关重要的，因为如果重新初始化超过最佳点的更多层，您可能会开始经历恶化的结果。

☑️:然后我们应用了随机加权平均(SWA) ，这是一种深度神经网络训练技术，它使用了一种修改的学习速率表。在训练时间的最后一段，它还保持了在结束时获得的重量的连续平均值。

☑️最后但同样重要的是，我们在变压器微调过程中引入了频繁评估。我们不是在每个时期验证一次，而是在该时期内对每x批训练数据进行验证。

使用所有这些技术，我们看到结果有了很大的改善，如表 1 所示。

如果你喜欢我的帖子，别忘了点击 关注 和 订阅 获取邮件通知。

可选地，您也可以 注册 成为媒体会员，以获得媒体上每个故事的全部访问权限。

📑访问此GitHub repo获取我在帖子中分享的所有代码和笔记本。

2021 保留所有权利。

参考

[1] T. Zhang，F. Wu，A. Katiyar，K. Weinberger 和 Y. Artzi，重温少样本 BERT 微调 (2021)

[2] A .塔库尔，接近(几乎)任何机器学习问题 (2020)

[3] C .孙，x .邱，y .徐，x .黄，如何微调用于文本分类的 BERT？ (2020)

[4] P .伊兹迈洛夫、d .波多普里欣、t .加里波夫、d .维特罗夫和 a .威尔逊，平均权重导致更宽的最优值和更好的泛化 (2019)

[5] J. Howard 和 S. Ruder，用于文本分类的通用语言模型微调 (2018)

Python 中的高级时间序列分析:季节性和趋势分析(分解)，自相关

原文：https://towardsdatascience.com/advanced-time-series-analysis-in-python-decomposition-autocorrelation-115aa64f475e?source=collection_archive---------0-----------------------

和其他技术来发现多个时间序列之间的关系

照片由 乔丹本顿 上 像素

介绍

继我的非常受欢迎的帖子和 Kaggle notebook 之后，现在是时候将这个 TS 项目的轨迹可视化了。

这篇文章是关于构成深度时间序列分析的核心过程。具体来说，我们将讨论:

  • 时间序列的分解——季节性和趋势分析
  • 同时分析和比较多个时间序列
  • 计算自相关和偏自相关以及它们代表什么

以及多个系列之间的季节性或趋势是否相互影响。

最重要的是，我们将建立一些非常酷的可视化，这个图像应该是你将要学习的东西的预览。

我希望在写这篇文章的时候，你和我一样对学习这些东西感到兴奋。我们开始吧。

在这里阅读文章的笔记本。

https://ibexorigin.medium.com/membership

获得由强大的 AI-Alpha 信号选择和总结的最佳和最新的 ML 和 AI 论文:

https://alphasignal.ai/?referrer=Bex

1.时间序列分解

任何时间序列分布都有 3 个核心部分:

  1. 季节性 —数据是否有明确的循环/周期性模式？
  2. 趋势——数据代表了总体的上升还是下降趋势？
  3. 噪声 —有哪些与其余数据不一致的异常值或缺失值？

将一个时间序列分解成这些部分称为分解，我们将详细探讨每一个部分。

1.1 季节性分析

考虑一下 TPS 月 Kaggle 游乐场数据集:

显然，夏季气温较高，我们预计这种现象每年都会重复。然而，人眼及其检测图案的能力只能到此为止。

例如，可能更难从如下图中找到季节模式:

为了从上面的时间序列中找到隐藏的季节模式，我们将使用statsmodels中的seasonal_decompose函数:

对“牛肉”时间序列使用sm.tsa.seasonal_decompose会返回一个DecomposeResult对象，该对象具有类似于seasonal、trend和resid的属性(后面会详细介绍后两个属性)。

上面，我们在绘制季节性，但是这个图没有用，因为它有太多的噪音。让我们选择一个间隔，给这条线一些喘息的空间:

decomposition.seasonal["1999":"2005"].plot();

这张图显示，牛肉产量在每年年初确实下降，但在接近年底时达到顶峰。

关于seasonal_decompose功能的说明:默认情况下，它产生小数字。你必须自己控制它的各个方面，而且plot函数不接受大多数常规的 Matplotlib 参数。

现在，让我们绘制 5 年间所有肉类的季节性变化图:

如你所见，每种肉类都有不同的季节性模式。现在，我们来探讨一下趋势。

1.2 趋势分析

同样，时间序列的总体趋势显示了它在一段时间内是增加、减少还是保持不变(持平)。上面的DecomposeResult对象包含的值显示了trend属性下时间序列的总体斜率。

让我们为肉类生产数据集绘制它们:

与我们一开始看到的简单线图相比，这个图非常有洞察力。事实上，我们现在看到，自 20 世纪 40 年代以来，羔羊肉和小牛肉产量急剧下降。

这可能部分是由于牛肉、肉鸡和火鸡的产量增加了两倍或三倍。我们现在正在进行有根据的猜测，但是我们将在后面的部分探索一些强有力的方法来验证它们。

1.3 噪音

时间序列的第三个组成部分是噪音。它不像其他两个组件那样花哨。它只显示随机和不规则的数据点，这些数据点不能归因于季节性或噪音。

您可以使用来自DecomposeResult对象的resid属性来绘制它们:

在整个DecomposeResult对象上调用plot将产生一个所有组件都显示在同一轴上的图。

分解你的时间序列有助于你以一种结构化的方式思考它们。不要把一个序列想象成一个随时间变化的值，你可以把它想象成一个具有特定季节性信号的分布或者一个具有特定斜率的特征。在特征工程和建模过程中，这种数据理解水平可能是一个关键因素。

2.使用多个时间序列

2.1 将军

处理多个时间序列存在一定的挑战。如我们所见，一个例子是每个分布的不同规模:

当具有较大鳞片的特征将其他特征挤压成一条直线(羔羊肉和小牛肉)时，不可能比较它们的生长。一种解决方案是使用标准化。

归一化时间序列时，将分布中的每个数据点除以第一个样本。这具有将每个数据点表示为相对于第一个样本的百分比增加的效果:

meat.div(meat.iloc[0]).head()

最棒的是，现在每个发行版都有相同的规模。让我们通过执行标准化来绘制肉类生产数据:

牛肉和猪肉的增长百分比最高，而小牛肉和羊肉的产量在特定时期内直线下降。

2.1 具有相关性的时间序列之间的关系

我知道你在说什么:“相关性？真的吗？有什么新内容…“

但是请原谅我。一个简单的关联热图确实能告诉我们很多变量之间的线性关系:

我们更感兴趣的是时间序列的基本组成部分如何相互影响。例如，让我们看看每个时间序列的季节性如何影响其他时间序列:

这一次，我们使用聚类图而不是热图，在树状图的帮助下立即查看密切相关的组。

该图告诉我们，牛肉、肉鸡和其他鸡肉的季节性密切相关。猪肉和羊肉也是如此。这种正相关可以表示接近的季节性匹配。

例如，牛肉、肉鸡和其他鸡肉的增加/减少模式可能在给定时期内经常匹配。

让我们对趋势也这样做，我认为这应该更有趣:

上面的图很棒，因为它帮助我们验证了趋势分析部分的假设。让我们再来看看肉类生产的标准化图:

你能把聚类图中的模式和线图匹配起来吗？例如，牛肉与羔羊肉/羊肉和小牛肉具有很强的负相关性。与此相匹配的事实是，牛肉产量增加了两倍，而其他两种产品的产量下降了约 75%(从线图中可以看出)。

在猪肉和小牛肉、羔羊肉和羊肉之间也可以观察到同样的现象。

2.2 相关性并不意味着因果关系

我希望你在对相关特征做出假设时小心行事。永远记住，相关性并不意味着因果关系。当两个特征高度相关时，这并不意味着一个特征的增加会导致另一个特征的增加。

我喜欢用的一个例子是，即使一个城镇中鹳的数量可以与新生婴儿的数量相关联，但这并不意味着鹳接生了婴儿。

可能需要一段时间来清楚地划分相关性和因果关系，所以你为什么不看看我的关于这个话题的另一篇文章。

3.自相关和偏自相关

3.1 自相关

自相关是时间序列数据建模的强大分析工具。顾名思义，它涉及到计算相关系数。但是在这里，不是在两个特征之间进行计算，而是用一个滞后版本的时间序列来发现时间序列的相关性。

让我们先看一个示例图，并进一步解释:

自相关函数图(ACF)的 x 轴是滞后数 k 。例如，当 k=1 时，通过将序列移动 1 来找到相关性。这和使用熊猫的shift功能是一样的:

YAXis 是每个滞后 k 处的相关量。红色阴影区域是一个置信区间——如果条形的高度在该区域之外，则意味着相关性在统计上显著。

请停下来想一想，你能从 ACF 图中学到什么。

它们提供了另一种检测模式和季节性的方法。例如，以摄氏度为单位的温度的 ACF 图显示，每 15 个滞后的相关性降低，或者每 25 个滞后的相关性增加。

当时间序列中存在明显的趋势时，自相关性在小滞后(如 1 或 2)时往往较高。当季节性存在时，自相关以较大的滞后周期性上升。

让我们看另一个例子:

一氧化碳的 ACF 证实了小滞后往往具有高相关性。它还显示，每 25 个滞后，相关性显著增加，但很快下降到负值。但是大多数向下的柱线都在阴影区域内，表明它们在统计上不显著。

这种比较过去和现在数据点之间关系的能力具有独特的优势。如果您可以将现值与 k 个周期之前的点相关联，这也意味着您可以找到 k 个周期之后的值的链接。

此外，理解自相关是用 ARIMA 模型建模时间序列的关键(另一篇文章的主题)。

3.2 部分自相关

尽管讨论偏相关意味着我们走在了事情的前面，我还是会给你要点。

它类似于自相关——使用序列及其在 k 的滞后版本进行计算:

唯一的区别是，这种方法试图说明干预滞后的影响。例如，在滞后 3 处，部分自相关消除了滞后 1 和滞后 2 对计算相关性的影响。

虽然自相关对于分析时间序列的属性和选择使用哪种类型的 ARIMA 模型很有用，但偏相关可以告诉我们自回归模型的拟合阶数。

同样，当我们谈论预测时，将深入讨论这个主题。所以，敬请期待！

摘要

恭喜你！

通过阅读这篇文章，你学会了剖析任何时间序列并获得有意义的见解的强大技术。最重要的是，您现在有能力将这些技术应用于多个时间序列，并批判性地评估它们之间的关系。

感谢您的阅读，下一期再见！

您可能也会感兴趣…

  • 每一个你可以(应该)用来操纵时间序列的熊猫函数
  • 多类分类指标综合指南
  • 三阶段实用 Sklearn 功能选择

R 中的高级用户定义函数

原文：https://towardsdatascience.com/advanced-user-defined-functions-in-r-8f9519770374?source=collection_archive---------41-----------------------

您是否遇到过这样的情况:您希望有一个内置函数来实现某个结果，而不是为它编写多行代码？你想知道如何优化你的 R 代码吗？您知道使用 UDF 可以轻松编写 R 代码吗？UDF 是基本的构建块，您可以在编写代码时即插即用。请继续阅读，了解更多…

瑞安·昆塔尔在 Unsplash 上拍摄的照片

UDF(用户定义函数)使你的代码结构化，有助于容易地识别错误，并使将来的修改更加容易。一旦你习惯了编写和定义 UDF，就没有回头路了！你会沉迷于它们对你有多有用。

如果你是一个初学者，并且想知道如何创建用户自定义函数的基础知识，请阅读我下面提到的文章:

现在我们都准备好了，让我们从一些高级 UDF 的例子开始。

在 UDF 中使用多个“if 条件”

UDF 非常灵活，可以通过在 UDF 中设置多个“if 条件”和内置函数来定义。请在下面的链接中找到一个从摄氏温度到华氏温度的转换函数，反之亦然。我使用了简单的“如果条件”和内置函数来创建这个 UDF。

https://github.com/shruthigeetha/R_UDFunctions/blob/main/TemperatureConversion.R

现在，这种 UDF 可以修改，以包括其他温度单位和更多的故障安全方法。请随意投稿。

在 UDF 中运行“for loops”

可以在 UDF 中使用 For 循环，以确保对数据子集而不是整个数据执行类似的操作。

以下示例中的结果可以通过多种方式获得，如使用简单的聚合函数或应用函数。通过这个例子，我想提出一种非传统的方法，使用 UDF 从每日数据中获取月度信息。该 UDF 可用于任何类似的数据集，以获得每月的汇总信息。

https://github.com/shruthigeetha/R_UDFunctions/blob/main/UDF_WithForLoops.R

UDF 内的 UDF

事情变得有趣多了！

在 UDF 里用过 UDF 吗？现在你们都是专家了，我们可以有嵌套的 UDF 来帮助简化你的代码。这是向编写易于解释和解码的紧凑代码迈出的一大步！

为此，我将使用之前的温度转换和月度数据提取示例，向您展示 UDF 内 UDF 的示例。

https://github.com/shruthigeetha/R_UDFunctions/blob/main/UDFs_within_UDFs.R

在上面的例子中，我获得了以摄氏温度而不是最初的华氏温度来表示的每月信息。

下一步是什么？

现在，您可以在日常的 R 代码中尝试并开始使用 UDF 了。从上面的例子中，我们可以清楚地看到创建可重用和多用途的 UDF 是多么灵活和容易。

如果你能想到 UDF 可以应用的其他场景，或者如果你有任何可以利用 UDF 的主题，请随时发表评论或打开一个讨论论坛。

高级 YoloV5 教程—使用加权盒融合增强 YoloV5

原文：https://towardsdatascience.com/advanced-yolov5-tutorial-enhancing-yolov5-with-weighted-boxes-fusion-3bead5b71688?source=collection_archive---------4-----------------------

关于使用 YoloV5 和提升其 WBF 性能的深入教程

埃里克·卡里姆·科内利斯在 Unsplash 上拍摄的照片

有大量的 YoloV5 教程，本文的目的不是重复这些内容，而是对其进行扩展。我最近参加了一个数据科学对象检测比赛，虽然我找到了大量创建基线的教程，但我没有找到任何关于如何扩展它的建议。此外，我想强调 YoloV5 配置中可能影响性能的最重要部分，因为毕竟数据科学主要是关于实验和超参数调整。

在此之前，我只想说，就框架和库如何工作而言，使用对象检测模型不同于使用图像分类模型。这是我注意到的事情，我花了一段时间才明白过来。大多数流行的对象检测模型，如 YoloV5、EfficientDet，都使用命令行界面来训练和评估，而不是使用编码方法。这意味着，从字面上看，你需要做的就是获得特定格式(COCO 或 VOC)的数据，然后将 cmd 指向它。这通常不同于使用代码训练和评估模型的影像分类模型。

数据预处理

YoloV5 希望你有两个目录，一个用于训练，一个用于验证。在这两个目录中，你需要另外两个目录，“图像”和“标签”。图像将包含实际的图像和标签应该有一个. txt 文件为每个图像与该图像的注释，文本文件应该有相同的名称作为其相应的图像。

注释格式如下:

<'class_id'> <'x_center'> <'y_center'> <width'> <'height'>

要在代码中实现这一点，您可能需要一个与此类似的函数，其中原始数据框包含图像条目、它们的类 id 以及它们的边界框:

def create_file(df, split_df, train_file, train_folder, fold):

    os.makedirs('labels/train/', exist_ok=True)
    os.makedirs('images/train/', exist_ok=True)
    os.makedirs('labels/val/', exist_ok=True)
    os.makedirs('images/val/', exist_ok=True)

    list_image_train = split_df[split_df[f'fold_**{**fold**}**']==0]['image_id']    
    train_df = df[df['image_id'].isin(list_image_train)].reset_index(drop=True)
    val_df = df[~df['image_id'].isin(list_image_train)].reset_index(drop=True)

    for train_img **in** tqdm(train_df.image_id.unique()):
        with open('labels/train/**{**train_img**}**.txt', 'w+') as f:
            row = train_df[train_df['image_id']==train_img]\
            [['class_id', 'x_center', 'y_center', 'width', 'height']].values
            row[:, 1:] /= SIZE # Image size, 512 here
            row = row.astype('str')
            for box **in** range(len(row)):
                text = ' '.join(row[box])
                f.write(text)
                f.write('**\n**')
        shutil.copy(f'**{**train_img**}**.png', 
                f'images/train/**{**train_img**}**.png')

    for val_img **in** tqdm(val_df.image_id.unique()):
        with open(f'**{**labels/val/**{**val_img**}**.txt', 'w+') as f:
            row = val_df[val_df['image_id']==val_img]\
            [['class_id', 'x_center', 'y_center', 'width', 'height']].values
            row[:, 1:] /= SIZE
            row = row.astype('str')
            for box **in** range(len(row)):
                text = ' '.join(row[box])
                f.write(text)
                f.write('**\n**')
        shutil.copy(f'**{**val_img**}**.png', 
                f'images/val/**{**val_img**}**.png')

来源:卡格尔

注意:不要忘记保存在标签文本文件中的边界框的坐标必须被标准化(从 0 到 1)。这很重要。此外，如果图像有多个注释，在文本文件中，每个注释(预测+边界框)将位于单独的一行。

之后，您需要一个配置文件，其中包含标签的名称、类的数量以及训练和验证路径。

import yaml
classes = [ ‘Aortic enlargement’,
 ‘Atelectasis’,
 ‘Calcification’,
 ‘Cardiomegaly’,
 ‘Consolidation’,
 ‘ILD’,
 ‘Infiltration’,
 ‘Lung Opacity’,
 ‘Nodule/Mass’,
 ‘Other lesion’,
 ‘Pleural effusion’,
 ‘Pleural thickening’,
 ‘Pneumothorax’,
 ‘Pulmonary fibrosis’]data = dict(
 train = ‘../vinbigdata/images/train’, # training images path
 val = ‘../vinbigdata/images/val’, # validation images path
 nc = 14, # number of classes
 names = classes
 )with open(‘./yolov5/vinbigdata.yaml’, ‘w’) as outfile:
 yaml.dump(data, outfile, default_flow_style=False)

现在，您需要做的就是运行这个命令:

python train.py — img 640 — batch 16 — epochs 30 — data ./vinbigdata.yaml — cfg models/yolov5x.yaml — weights yolov5x.pt

根据经验需要注意的事项:

好了，现在我们已经略读了基础知识，让我们看一下重要的东西:

  1. 不要忘记标准化坐标
  2. 如果您的初始性能比预期的差得多，发生这种情况的最可能的原因(我在许多其他竞争对手身上看到过这种情况)是您在预处理方面做了一些错误的事情。这看起来很琐碎，但有很多细节你必须要注意，尤其是如果你是第一次。
  3. YoloV5 有多个型号(yolov5s，yolov5m，yolov5l，yolov5x)，不要只挑最大的一个，因为它可能会过拟合。从中等水平的基线开始，并努力提高它。
  4. 虽然我是在 512 张图片上训练的，但是我发现将-img 标志作为 640 传递可以提高性能
  5. 不要忘记加载预训练的重量(-重量标志)。迁移学习将极大地提高你的表现，并节省你大量的训练时间(在我的例子中，大约 50 个周期，每个周期大约需要 20 分钟！)
  6. Yolov5x 需要大量的内存，当在批量大小为 4 的 512 个图像上训练时，它需要大约 14GB 的 GPU 内存(大多数 GPU 都有 8GB 左右的内存)。
  7. YoloV5 已经使用了增强，你可以选择你喜欢的或者不喜欢的，你所需要做的就是使用 yolov5/data/hyp.scratch.yml
  8. 默认的 yolov5 训练脚本使用了权重和偏差，老实说这给人留下了非常深刻的印象，它在模型训练时保存了你所有的指标。但是，如果您想关闭它，只需将 WANDB_MODE="dryrun "添加到训练脚本标志中
  9. 我希望早点发现的一件事是，YoloV5 将大量有用的指标保存到目录 yolov5/runs/train/exp/中。训练后，您可以找到“混淆 _ 矩阵. png”和“结果. png ”,其中 results.png 应该是这样的:

图片由作者转载。可能最重要的两个指标是 mAP@0.5 和 mAP@0.5:0.95

用 WBF 预处理

照片由 Unsplash 上的 Siebe Warmoeskerken 拍摄

好了，现在你已经调整了超参数，升级了你的模型，测试了多种图像尺寸和交叉验证。是时候介绍一些提高性能的技巧了。

加权盒子融合是一种在训练之前(清理数据集)或训练之后(使预测更准确)动态融合盒子的方法。如果你想知道更多，你可以看看我的文章:

要使用它来预处理数据集(大多数竞争对手的性能大约提高了 10–20%)，您可以使用如下代码:

from ensemble_boxes import *for image_id **in** tqdm(df['image_id'], leave=False):
        image_df = df[df['image_id']==image_id].reset_index(drop=True)
        h, w = image_df.loc[0, ['height', 'width']].values
        boxes = image_df[['x_min', 'y_min',
                          'x_max', 'y_max']].values.tolist()
        # Normalise all the bounding boxes (by dividing them  by size-1
        boxes = [[j/(size-1) for j **in** i] for i **in** boxes]
        scores = [1.0]*len(boxes) # set all of the scores to 1 since we only have 1 model here
        labels = [float(i) for i **in** image_df['class_id'].values] boxes, scores, labels = weighted_boxes_fusion([boxes], [scores], [labels],weights=None,iou_thr=iou_thr,
                                          skip_box_thr=skip_box_thr) list_image.extend([image_id]*len(boxes))
        list_h.extend([h]*len(boxes))
        list_w.extend([w]*len(boxes))
        list_boxes.extend(boxes)
        list_cls.extend(labels.tolist())
    # bring the bounding boxes back to their original size  (by multiplying by size - 1) list_boxes = [[int(j*(size-1)) for j **in** i] for i **in** list_boxes]
    new_df['image_id'] = list_image
    new_df['class_id'] = list_cls
    new_df['h'] = list_h
    new_df['w'] = list_w
    # Unpack the coordinates from the  bounding boxes new_df['x_min'], new_df['y_min'], \
    new_df['x_max'], new_df['y_max'] = np.transpose(list_boxes)

这应该在将边界框坐标保存到注释文件之前完成。你也可以用同样的方法用 YoloV5 预测边界框后再尝试使用。

首先，在训练 YoloV5 之后，运行:

!python detect.py — weights /runs/train/exp/weights\
 — img 640\
 — conf 0.005\
 — iou 0.45\
 — source $test_dir\
 — save-txt — save-conf — exist-ok

然后从以下位置提取方框、分数和标签:

runs/detect/exp/labels

并将它们传递给:

boxes, scores, labels = weighted_boxes_fusion([boxes], [scores], [labels],weights=None,iou_thr=iou_thr,
                                          skip_box_thr=skip_box_thr)

我不想包含所有的后处理代码，因为它包含了很多我正在做的比赛的细节。

最后的想法

我希望你已经了解了一些关于延长基线的事情，我认为最重要的事情是转移学习，图像增强，模型复杂性，前&后处理技术。使用 YoloV5，您可以轻松控制和使用这些方面来提升您的性能。

你应该选择哪种型号？大鸟，康伯特，朗福尔曼…

原文：https://towardsdatascience.com/advancing-over-bert-bigbird-convbert-dynabert-bca78a45629c?source=collection_archive---------11-----------------------

超过 BERT 的进展..

图像来源

B ERT 及其变体也在 2021 年席卷了 NLP 领域。在 NeurIPS2020 和 ICLR2020 中分别有超过 20 篇关于 BERT 或 Transformers 的文章，并且这一趋势还在继续！在本帖中，我们将分析哪些最新的进步是必须的，以及它们何时有用。

对 BERT 的最初改进要么增加了数据，要么提高了计算能力，从而超越了它。然而，最近，从 StructBERT 和 ALBERT 开始，模型在概念和架构上已经超越了 BERT。

S tructBERT :又名爱丽丝，将语言结构融入预训练过程。具体来说，它引入了一个新的目标函数，称为 WSO(词结构目标)。WSO 旨在预测句子中单词的顺序。这是通过屏蔽 15%的记号来实现的，类似于 BERT，但是随后训练以预测混洗的 15%记号的正确位置。结果，模型开始学习单词的排序！他们还引入了 SSO(句子结构目标)，这是 BERT 的下一句预测(NSP 任务)的修改版本，用于预测下一句和上一句，再次提高了模型的排序能力。这是在使用可比数据和计算能力的同时优于 BERT** 的第一种方法。**

ALBERT: 是相对于 BERT 的第一个架构改进，使用 18 倍小的模型在 5 个 NLU 任务上胜过 BERT。尺寸的减小是通过两个进步实现的。首先，遵循共享参数以减少自由变量的思想，ALBERT 在跨层注意力地图中引入了参数共享，减少了大约 7000 万个冗余参数。其次，ALBERT 对巨大的令牌嵌入矩阵执行低维投影，减少了多达 2000 万个附加参数。由于过度拟合的机会有限，ALBERT 还消除了丢失现象，从而降低了内存消耗。

然而，这两种方法都只能得出一个近似的解决方案，因此与 BERT 相比，ALBERT 的性能会降低 1–2%。为了避免这一点，ALBERT 引入了句子顺序预测(瞧！)任务类似于 StructBERT，增加了比 BERT 多 10 倍的数据(我们以前也见过！).由于尺寸减小，但数据和近似设置增加，在消耗相当数量的计算资源时，ALBERT 的性能优于 BERT。

网络宽度/深度适配？是啊！也许比蒸馏还要好！

——谷歌，微软，华为。

D ynaBERT :取得显著进步。由华为推出的 DynaBERT 是一款宽度和深度自适应模型，旨在降低计算成本。虽然这个想法对深度学习来说并不新鲜，但结果是有影响的。DynaBERT 几乎总是比 DistilBERT 的计算成本低 2-3 倍，但却能获得相当的精度！

从技术上来说，DynaBERT 通过解耦来并行化多个注意力头和层的计算。这使得调整模型的宽度变得很容易，只需要调整头部和层数就可以了！然后，DynaBERT 继续通过在训练期间计算重要性分数来自动识别和移除最不重要的头/层。使用臭名昭著的学生-教师方法来训练可变深度模型。因此，DynaBERT 的性能至少可以与相同或更小型号的 BERT 相媲美，而且它的性能确实优于 DistilBERT。(条)

漏斗变压器:在类似的一行，漏斗变压器，确实如其名。它汇集输入，就像自动编码器逐渐将隐藏状态压缩成更短的序列。压缩跨三个块进行，其中每个块都是一组大小相同的层。从一个块到下一个块，隐藏单元的数量(序列长度)通过平滑的池层减少。这消除了 BERT 层中众所周知的冗余，最终性能当然比 BERT 更好！

漏斗变压器，图片来自文章

微软在 NeurIPS 2020 上的另一项工作通过简单的网络大小调整，在相同或更高的精度下，将 BERT 的训练速度提高了 2.5 倍。有趣的是，他们提出 I)在多头之前移动层范数，以允许更高的学习速率。ii)帮助绕过子层的选通机制 iii)层丢弃时间表。概念上类似于宽度/深度适配！

一系列的努力引入了新颖的关注层，使变压器更具成本效益。这些方法减少了注意矩阵中的条目。

其中最突出的是:

B 直觉是，对角线上的注意力是局部注意力，两边是远距离注意力(称为全局注意力)，随机位置有助于更好地逼近矩阵。不错——对！

图片来自文章

因此，BigBird 在 BERT 的基础上实现了 5–10%的准确性改进，并显示在 4096 长度的序列上，这是 BERT 的 8 倍长的序列。实现这一点的一个挑战是在 GPU/TPU 上计算稀疏运算的能力。这通过将稀疏表示转换成块并计算这些块中的关注度以及再次重构回矩阵来解决。对于序列长度，该模型以 O(L)进行缩放。注意:早些时候 Google 也引入了一个 ETC 变体，如果你有一个捕捉单词之间语义关系的图表，这个变体会很有用。

Longformer :由艾伦研究所(Allen Institute)计算矩阵内部对角线、边和边的投影中的注意力。该模型在长达 20K 令牌的序列上进行训练和评估，并且标度为 O(L)！因此能够执行文档级任务。

Longformer 和 BigBird 的性能相当接近，BigBird 的性能提高了 1–3 %,但是它使用的计算能力是 Longformer 的 16 倍！

重整器:用 LSH 注意力代替变压器的二次点积注意力。简而言之，LSH(局部敏感散列)注意力使用基于散列的记号分组来执行本地化的点积，这允许点积矩阵中高值的良好质量近似。重要的是，这意味着重整器只需要 O(L log(L))而不是 O(L)复杂度，从而产生显著的加速。模型显示在 30K 标记大小的序列上，对于更大的序列长度，速度提高了 5-10 倍。然而，与 BigBird 和 Longformer 不同，对于较小的序列，成本效率优势是最小的。

ConvBERT: 使用跨度级动态卷积改进 BERT。它使用卷积核来捕获单词之间的局部相似性，然后将它们纳入自我注意，以创建混合注意块。由于受到新的关注，ConvBERT 模型的性能提高了 5–6 %,计算成本效率提高了 5 倍。(条)

那么，用哪一个呢？

是的，我们现在有了比伯特更受欢迎的型号。

长文:大鸟胜，可比回落:Longformer

更小的网络/速度 : DynaBERT、ConvBERT

多语言:如果计算机不是问题，XLM-罗伯塔，否则就是姆伯特

这是 BERT 技术进步的第 2 部分。参见第一部分的这篇博文。

可以通过@ LinkedIn 联系到作者。

通过实践社区提高非技术专业人员的 SQL 技能

原文：https://towardsdatascience.com/advancing-sql-skills-of-non-tech-professionals-through-communities-of-practice-764722c43d62?source=collection_archive---------28-----------------------

办公时间

通过知识共享提高数据技能，而不仅仅是学习正式课程，完成工作，并分发虚拟的“coxinhas”

由 Robynne Hu 在 Unsplash 上拍摄

介绍

现在是下午 12:21，刚刚在 Slack App 里收到消息通知。一位业务分析师在#badhus 频道上发了一条消息，询问在哪个表中可以找到关于具有特定列的 iFood 餐馆的数据。下午 02:55，一位业务专家发布了一个格式错误的 SQL 查询，请求帮助了解他哪里出错了。下午 3 点 55 分，另一位业务分析师寻求帮助，想知道她如何从字母数字字符串中“提取”数字，有人向她介绍了正则表达式。下午 4:10，一名数据架构师发布了一条消息，警告所有人一些表将很快发生变化，以便当前用户能够意识到这一点。下午 5 点 31 分，一位商业策划分析师就请求访问我们的 Tableau 服务器寻求指导。在工作日结束时，一位财务分析师请求帮助使用 SQL 的 AND 或 or 语句。这是我们公司迈向数据驱动的典型一天(更确切地说，是 2021 年 5 月 24 日)。该频道有大约 700 名成员，我们可爱而自豪的 bad Hu——正如我们给他们起的名字:商业分析师数据重度用户。顺便说一下，所有这些消息都被其他 BADHUs 回复了(除了关于正则表达式的那条——我回复了)。

大约 18 个月前，我们启动了一个名为 Data Academy 的项目，向从未使用过 SQL，甚至从未想过使用 SQL 的人教授 SQL。我们开设了一门入门课程，并开始让人们相信这门课程对他们的职业有帮助、有价值，而且在某种程度上很有趣。

事实是:他们非常喜欢它。从那以后，他们渴望提高自己的技能。他们想要更多。我被问了几百次:“我们什么时候有第二道菜？你什么时候教我们 Python？”

诚实的回答是:我不认为第二道菜是他们旅行的最佳路线。我建议去真正的工作，面对课程没有涉及的误导性问题。然后，试着去理解它，搜索解决方案，在 #badhus Slack 频道求助。将这些问题作为他们后续研究课题的课程。

什么是实践社区？

不依靠这个非常准确的定义，几乎不可能更好地回答这个问题:

“实践社区是一群人，他们对一个话题有共同的关注点、一系列的问题或激情，并通过持续的互动加深他们在这个领域的知识和专业技能。”

这些社区可以以多种形式存在:小的或大的、长的或短的、自发的或有意的、面对面的、远程的，但它们都有一个标准的结构:

  • 域。社区存在的目的。它通过对主题的兴趣聚集人们，并指导学习日程。这是对将在那群人中管理的人员的官方声明。
  • 社区。在相互尊重和信任的关系中互动的人。他们谈论、学习、教授、记录和发展与所定义领域相关的知识。
  • 修炼。虽然领域是关于社区的话题，但是实践是由成员创造的特定知识:文档、框架、想法和其他种类的材料，只有参与该社区的人才能理解其价值。

实践社区是这三个要素的独特组合。重要的是要理解，没有一个明确定义的域，社区只是一群朋友。另一方面，没有实践，它只是一群对一个话题感兴趣的人，没有采取行动，改变他们的行为，提高他们的能力。此外，如果没有社区元素，它就缺乏构成社区的人的因素。

如果您想利用员工的集体智慧来利用公司内部的知识，实践社区是您应该考虑的一个选项。这是一种战略方法，通过和那些更好地理解其挑战、有着共同关注点并且渴望在他们的技术上有所进步的人一起发展知识。

连接点

在以下部分，我将讨论规划和构建实践社区。在此之前，重要的是要警告您，我甚至在这样做之前就已经开始计划和构建它了。这怎么可能？

我喜欢记得事情甚至在正式开始之前就已经开始了。这个想法是我通过 Sonke Ahrens 想到的，他的想法是勤于记笔记以便在面对一张白纸时做好准备，或许更符合这份出版物的受众，史蒂夫·乔布斯的想法是连接点。

对于那些从未接触过的人来说，这个想法可能听起来有点奇怪，所以这里有一个关于它的个人例子:

在 2021 年初，我有了创作一个“年度回顾风格”的视频的想法，展示了在巴都项目中发生的事情。因此，我花了几个小时在我们庞大的 Slack 档案、LinkedIn 书签、相册等中搜索和收集了一些过去的瞬间。沟通团队不支持我，我决定将这个想法存档。几个月后，一位主任让我为第二天准备一个五分钟长的关于巴都项目成就的报告。我不知道你是否意识到，一个精彩的五分钟演讲比其他任何事情都更具挑战性，因为你首先需要对所有事情有一个完整的看法，这样你才能以最佳的顺序选择最佳的部分，并进行连贯的演讲。幸运的是，我之前就开始了，当时我做了大量的搜索——如果我之前就开始，收集发生的瞬间，事情会变得更容易。

那么，我们之前是怎么开始的呢？在我的记忆中，业务人员会密集地向数据分析团队询问数据。这种情况发生了很多次，而且越来越频繁，我们知道我们需要采取行动。因此，我们准备了一个实验性的“SQL、Datalake 和 data bricks”课程，并亲自将其应用于财务团队的一些早期采用者。进行得非常顺利，所以我们把它录了下来，以便在整个组织中传播这些知识。

来自金融 team(❤的早期采用者)—2019 年 11 月

在那项艰苦的工作之后，另一项艰苦的工作开始了:社区(不是实践社区)的建设。我们知道勇敢的人在探索新的道路，自己寻找数据，“谈论”SQL 语言，面对可怕的错误。所以我们试着为他们提供充分的时间，回答他们的问题，为他们提供日历时间。在这个过程中，我们可以更好地了解他们，我们看到人们在他们的职业生涯中进步，我们告别那些去了另一家公司的人。这项工作非常有价值，现在我明白了:我们用了一个月完成了课程，而参与者用了一年多的时间建立了社区——一次一个互动。

现在开始一切可能很难，但并非不可能。你可以看看你的组织，试着找出一些已经在做的事情。也许有一种你从未留意过的非正式群体。如果是这样，你可以试着确定:对他们来说重要的话题，参与的成员，交流偏好，新成员如何加入那个社区，他们如何接收新成员，他们可能有的阻碍者，等等。相反，你将不得不从头开始，尝试许多事情，把事情搞清楚。所以，快开始，好开始。希望在以下几节能帮到你。

“研究胜过最佳实践”

自从我们决定推出实践社区以来，我已经阅读了一些关于该主题的有趣文献，并意识到这种社区非常复杂:人类行为的许多错综复杂、工作环境的限制以及学习和知识管理要求的挑战的混合。这并不意味着我们应该放弃这个想法；这只是意味着我们需要站在那些研究过，谢天谢地，还写过相关文章的人的肩膀上。

那么，你从哪里可以了解实践社区呢？我强烈建议你坚持阅读艾蒂安·温格的这两本书:1) 培养实践社区:知识管理指南，如果你想更进一步，还有 2) 实践社区:学习、意义和身份。

此外，您应该将实践社区视为新事物，不要将其与您可能知道的另一个类似术语联系起来。实践元素的社区(领域、社区和实践)对您来说可能很熟悉，但是请记住:真正的潜力存在于“这三个元素的独特组合”中。最常见的被误导的术语是 guild ，由于著名的“Spotify 模式”，这个术语有点流行。行业协会有其价值，但我建议避开它们以及大公司创造的所有其他术语(又名。“最佳实践”)。首先，大多数文章简化了“Spotify 的公会”的解释，这可能对你没有帮助。另外，我们甚至不知道 Spotify 是否使用 Spotify 模式。在从事过去的项目时，我没能避开最佳实践。我甚至设法找到了好的故事，但这些都是一切顺利或断章取义的故事，尽管鼓舞人心，但并不恰当。因此，我最近越来越倾向于阅读文献，而不是大公司的最佳实践。******

回避大公司最佳实践的建议不仅是我提出的，也是在其中一家公司工作的人提出的:

每当我们在 Google now 面临新的人事问题时，我们不会问自己:成功的 X 组织是如何处理这个话题的？相反，我们问自己:文献说了什么？(……)与学术界发展更好的关系，而不是咨询公司。

—谷歌人力分析与薪酬副总裁普拉萨德·塞蒂

按照这个建议，你成功的机会可能会增加。也许你的第一个实践社区不会完全成功，但你可能会知道原因。否则，你会发现自己被一些危险的后果所束缚:不知道失败的根源，责怪社区成员，以及挫伤团队的士气。通过不完整的故事和只暴露积极的事实，共享的最佳实践会让您认为它也需要在您的环境中很好地工作，如果您对此不警惕，它可能会造成损害。

实施实践社区

正如您将从文献中了解到的那样，实践社区需要被设计并对演进开放，因此最好专注于快速且扎实地实现初始结构。发布后，社区将拥有自己的生命，而的复杂性将浮出水面，需要不断的培育和监控。

本节将描述我们如何实现这个最初的实践社区结构(你将在文献中找到行动背后的为什么)。

情况

  • 团队: 3 名兼职人员— 布伦达、加布里埃尔、我。
  • 时间: 6 周(我们按照 Basecamp 的塑造方法)。

前期工作

  • 阅读实践社区。
  • 收集所有过去的相关内容，如课程统计、反馈、评价、社交媒体。
  • 创建了一个“行动案例”，在这里我们收集论据来说服主要的利益相关者。

结构化

  • 用我们的主要关注点创建了一个思维导图，我们将其命名为“担忧树”。它就像一个https://hbr.org/2007/09/performing-a-project-premortem，但更简单。我们使用异想天开的应用程序创建了它。
  • 定义了社区的【领域】:提高 SQL。**
  • 定义了社区的【名字】 : Fluent SQL。
  • 定义了社区的【主要意图】 : 互相帮助解决日常问题。(将来，我们可能会将目标转向知识管理型)。
  • 定义了社区的“协调人】:我——录制课程的人，对角色有个人兴趣的人，大部分成员都认识的人。
  • 创建了一份“工作描述”文档，描述社区协调员的角色和职责。
  • 创建了一个名为“生存指南”的 PowerPoint 文件，其中包含说明、清单和我们社区的最低共存规则。
  • 创建了一个名为“邀请课程”的快速课程，有五个选择题练习，测试他们对生存指南的理解。

首批成员

  • 创建了#badhus-cop-fluent-sql Slack 通道(CoP代表实践社区)。**
  • 创建了一个“会员案例”，在这里我们收集了一些论据，以帮助潜在会员看到互动和为社区做贡献的价值。**
  • 根据以下因素，精心挑选了前 30 名潜在成员:在 #badhu Slack 渠道中表现出知识共享行为的人；不同级别的 SQL 知识；数据团队成员的推荐；性别、种族、工作领域和角色的混合。
  • 以 15 人为一批邀请成员，推断其中多达 5 人将因时间限制原因拒绝邀请。
  • 安排一个 30 分钟的电话会议来解释实践社区，并亲自正式邀请他们。我们满怀期待地分享了生存指南和邀请课程。
  • 在接下来的星期一，我们邀请那些已经完成邀请课程的人到实践松弛频道的私人社区。

活动和参与

  • 创建了一份“活动建议”文档，其中包含成员可以执行的逐步想法，以便在社区中开展活动并提高参与度。
  • 镜像 HeyTaco 认可机械师使用 Zapier 让成员正式感谢某人的一些有价值的贡献。每当有人发类似“@姓名谢谢！🌮“，我们计算一个指向 @name 的点。详细:我们通过:coxinha:表情符号交换了 🌮 表情符号因为它是巴西非常受人喜爱的食物。

“coxinha-points”，灵感来自 HeyTaco (作者截图自 Slack)

韵律学

  • 创建了一些 zap 来收集和保存松散的通道消息和交互。
  • 定义了与我们的目标更相关的指标。
  • 使用 Google Sheets 创建了一个简单的报告来监控我们的指标。

注意:我们选择 Zapier 和 Google Sheets 是为了遵守我们的 6 周时间限制。我们计划在后续项目中使用我们的平台工具栈(数据块、气流和表格)来偿还这笔技术债务

未来是数据驱动的

我们将更多地探索它，邀请新成员并激发他们更多地学习和分享。我可以想象这些商人还没有意识到他们学到了多少东西，他们正在成为他们领域的杰出专业人士。

对我来说，从事这种类型的倡议是一种乐趣，将学习理论与技术联系起来，同时提高我的数据素养水平。

****References**[1] E. Wenger, R. McDermott and W. Snyder, Cultivating Communities of Practice (2002), Harvard Business Review Press
[2] [YouTube: HR meets science at Google with Prasad Setty](https://www.youtube.com/watch?v=KY8v-O5Buyc)**

优势演员评论家教程:minA2C

原文：https://towardsdatascience.com/advantage-actor-critic-tutorial-mina2c-7a3249962fc8?source=collection_archive---------2-----------------------

优势因素评价算法简介

在强化学习领域，A2C 算法结合了两种强化学习算法(基于策略和基于值)。基于策略代理直接学习将输入状态映射到输出动作的策略(动作的概率分布)。基于值的算法根据输入状态或动作的预测值学习选择动作。在我们之前的深度 Q 学习教程:minDQN 中，我们学习了实现我们自己的深度 Q 网络来解决简单的 Cartpole 环境。在本教程中，我们将分享一个最小的 Advantage Actor Critic (minA2C)实现，以帮助新用户学习如何编写自己的 Advantage Actor-Critic 实现。你也可以在这里观看这个教程的 Youtube 版本。

目录

  1. 优势行动者-评论家算法概述
  2. 钢管舞露天健身环境
  3. 优势函数
  4. 演员网络
  5. 评论家网络
  6. 实施细节
  7. 优势行动者评论家编码实现
  8. 资源

1.优势行动者-评论家算法概述

actor critic 算法由两个网络(actor 和 critic)组成，它们一起工作来解决特定的问题。在高层次上，优势函数计算代理的 TD 误差或预测误差。行动者网络在每个时间步选择一个动作，而批评家网络评估给定输入状态的质量或 Q 值。当批评家网络知道哪个状态更好或更坏时，行动者使用这个信息来教代理寻找好的状态并避免坏的状态。

2.钢管舞露天健身环境

图 1:在横拉杆环境中平衡拉杆(图片由作者提供)

在本教程中，我们将使用优势行动者批评法来解决 CartPole 环境。在每个时间步，代理接受 4 个输入状态(小车位置、小车速度、极点角度和尖端的极点速度),并选择向左或向右移动。我们的目标是尽可能长时间地保持平衡。

3.优势函数

优势功能是什么？考虑到“优势”是优势演员评论家算法的名字，它一定是相当重要的。为了理解优势函数是什么，我们首先需要理解如何计算 TD 误差，或时间差分误差。

在时间差异学习中，代理通过对未来回报进行预测并根据预测误差调整他们的行动来学习。时间差异学习非常有趣的原因之一是，预测误差似乎也是大脑学习新事物的方式之一。

3a。计算 TD 误差

图 2:TD 目标是当前状态的奖励 R 加上下一个状态的未来折扣奖励S’(图片由作者提供)

为了计算优势函数(TD 误差)，我们需要先计算 TD 目标。在上面的等式中，TD 目标是来自当前状态 S 的所有未来奖励的预测值。函数 V(S’)表示计算下一个状态 S’的值的评论家网络。

图 3:TD 误差定义为 TD 目标减去当前状态 S 的值(图片由作者提供)

在优势因素评论家算法中，优势等于上面所示的 TD 误差。优势也可以解释为我们代理人的预测误差。

图 4:我们可以通过合计所有未来时间点的折扣奖励来计算总奖励(图片由作者提供)

注意，优势函数可能不总是与 TD 误差函数相同。例如，在许多政策梯度算法中，优势通常被计算为未来折扣奖励的总和，如图 4 所示。

优势功能告诉我们一个状态是比预期的好还是差。如果一个动作比预期的好(优势大于 0)，我们希望鼓励演员采取更多的动作。如果一个动作比预期的差(优势小于 0)，我们要鼓励行动者采取与那个动作的相反的。如果一个动作完全按照预期执行(优势等于 0)，参与者不会从那个动作中学到任何东西。

4.演员网络

图 5:行动者网络将状态映射到行动概率(图片由作者提供)

演员网络将每个状态映射到相应的动作。就像批评家网络一样，我们可以在每个时间步之后更新演员网络权重。

演员网络输出对应于每个动作的概率分布。我们根据每个动作的概率从这个概率分布中抽取动作样本。如果向左的动作的值是 0.8，向右的动作的值是 0.2，我们将只在 80%的时间里选择向左的动作，在 20%的时间里选择向右的动作。因为输出是一个概率分布，请注意代理不会总是选择概率最高的动作。

4a。定义演员网络

def create_actor(state_shape, action_shape):
    learning_rate = 0.001
    init = tf.keras.initializers.HeUniform()
    model = keras.Sequential()
    model.add(keras.layers.Dense(24, input_shape=state_shape, activation=tf.keras.layers.LeakyReLU(), kernel_initializer=init))
    model.add(keras.layers.Dense(12, activation=tf.keras.layers.LeakyReLU(), kernel_initializer=init))
    model.add(keras.layers.Dense(action_shape, activation='softmax', kernel_initializer=init))
    model.compile(loss='categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(lr=learning_rate), metrics=['accuracy'])
    return model

在我们的实现中，Actor 网络是一个简单的网络，由 3 个紧密连接的层组成，具有 LeakyReLU 激活功能。网络使用 Softmax 激活函数和分类交叉熵损失函数，因为网络输出动作的概率分布。

4b。更新演员网络的权重

图 6:更新演员网络概率(图片由作者提供)

一旦我们构建并初始化了演员网络，我们需要更新它的权重。在上面的例子中，代理人认为选择向左是错误的决定。在这种情况下，代理人希望将选择左的概率从 80%降低到 79%。同样，代理人需要将选择正确的概率从 20%增加到 21%。在更新这些概率之后，我们可以通过使网络适应新的概率来更新我们的网络权重。

算法如何决定鼓励哪些行为，劝阻哪些行为？A2C 算法通过计算优势来做出决定。优势决定了如何衡量代理刚刚采取的行动。重要的是，优势也可能是不利的，这会阻碍所选择的行动。同样，积极的优势会鼓励和加强这种行动。

5.评论家网络

critic 网络将每个状态映射到其对应的 Q 值。Q 值代表一个状态的值，其中 Q 代表该状态的质量。

图 critic 网络将输入状态映射到它们相应的值(Q 值)(图片由作者提供)

与输出动作概率分布的行动者网络不同，批判者网络将输入状态的 TD 目标输出为浮点数。在上图中，critic 网络评估输入状态的 Q 值为 15。

5a。定义我们的评论家网络

def create_critic(state_shape, output_shape):
    learning_rate = 0.001
    init = tf.keras.initializers.HeUniform()
    model = keras.Sequential()
    model.add(keras.layers.Dense(24, input_shape=state_shape, activation=tf.keras.layers.LeakyReLU(), kernel_initializer=init))
    model.add(keras.layers.Dense(12, activation=tf.keras.layers.LeakyReLU(), kernel_initializer=init))
    model.add(keras.layers.Dense(output_shape, activation='linear', kernel_initializer=init))
    model.compile(loss=tf.keras.losses.MeanSquaredError(), optimizer=tf.keras.optimizers.Adam(lr=learning_rate), metrics=['accuracy'])
    return model

像演员网络一样，我们的评论家网络也由 3 个具有 LeakyReLU 激活功能的紧密连接的层组成。因为 Critic 网络的输出是 TD 目标，所以使用均方误差损失函数来优化网络。

5b。更新 Critic 网络权重

既然我们知道如何计算 TD 目标和 TD 误差，我们如何更新 Critic 网络权重？注意，随着 TD 误差接近 0，Critic 网络在预测当前状态的结果方面变得越来越好。这种情况下，我们希望 TD 误差尽可能接近 0。为了更新临界网络权重，我们使用 TD 误差函数的均方误差。

图 8:给定一个状态或观察值，我们希望将 critic 网络与目标(TD_target)相匹配(图片由作者提供)

图 9:用新的 TD 目标10 更新评论家网络(图片由作者提供)

为了更新网络，我们调整了网络权重，使其以新的 TD 目标值 10 为目标。请注意，优势因素评论家算法不同于普通策略梯度(加强)算法。我们可以在每个时间步之后更新 critic 网络，而不是像在加强算法中那样等待一集的结束。

6.实施细节

当代理探索其环境时，批评家网络试图将优势函数驱动到 0。在学习过程的开始，评论家可能会犯很大的错误，导致计算的 TD 误差非常不正确。因为算法是从批评家对环境一无所知开始的，演员同样不能从批评家那里学到很多东西。随着评论家开始做出越来越准确的预测，计算出的 TD 误差(优势)也变得越来越准确。演员能够从越来越精确的 TD 误差中学习，以决定一步棋是好是坏。

图 10:在时间步长 t+3 游戏结束时，掷球问题的优势值序列示例(图片由作者提供)

对于横翻筋斗的问题，当游戏结束时，每一时间步的奖励 1 停止出现。游戏的结局出乎评论家的意料，通常会导致更大的负值。奖励的意外结局导致演员形象地思考，“这一步比预期的更糟，下次我们试试别的”。通过在许多游戏情节中重复这个学习过程，评论家和演员一起学习在更长的时间内平衡杆子。

7.优势行动者批评家实现

最后，我们可以把优势功能，演员，和评论家放在一起，以解决 CartPole 环境。你可以在这里找到我们的优势演员评论家实现，它在 300 集的时间里学习平衡侧手翻。

8.资源

  • 优势演员评论家(A2C)实现
  • 深度强化学习:来自像素的 Pong】
  • 使用 Keras 的策略梯度强化学习
  • 演员评论家(A3C)教程
  • 掌握演员评论方法所需的一切| Tensorflow 2 教程
  • 软演员兼评论家揭秘

打破深度学习模型的反面例子

原文：https://towardsdatascience.com/adversarial-examples-to-break-deep-learning-models-e7f543833eae?source=collection_archive---------22-----------------------

如何用一点 Python 来愚弄一个 27M 参数的模型

照片由乔治·勒巴达从派克斯拍摄

你以为骗过自动驾驶特斯拉汽车的视觉系统是不可能的吗？

或者说恶意软件检测软件中使用的机器学习模型太好了，无法被黑客规避？

或者机场的人脸识别系统是防弹的？

像我们任何一个机器学习爱好者一样，你可能会陷入这样一个陷阱，认为现有的深度模型是完美的。

嗯，你错了。

有一些简单的方法可以建立对抗的例子，可以欺骗任何深度学习模型，并产生安全问题。在本帖中，我们将涵盖以下内容:

  1. 什么是对立的例子？
  2. 你如何产生对立的例子？
  3. 动手例子:让我们打破盗梦空间 3
  4. 如何保护你的模型免受反面例子的攻击

开始吧！

1.什么是对立的例子？😈

最近 10 年，深度学习模型已经离开了学术幼儿园，成为大男孩，并改造了许多行业。对于计算机视觉模型来说尤其如此。当 AlexNet 在 2012 年登上排行榜，深度学习时代正式开始。

如今，计算机视觉模型与人类视觉一样好，甚至更好。您可以在无数地方找到它们，包括…

  • 无人驾驶汽车
  • 人脸识别
  • 医疗诊断
  • 监控系统
  • 恶意软件检测
  • …

直到最近，研究人员还在一个实验室环境中训练和测试机器学习模型，比如机器学习竞赛和学术论文。如今，当部署到现实场景中时，来自模型错误的安全漏洞已经成为一个真正的问题。

想象一下，你的自动驾驶汽车的最先进的超级花哨的深度学习视觉系统无法将这个停车标志识别为停车标志。

对深度学习视觉分类的强大物理世界攻击eyk Holt et altri。

嗯， 这是 到底是 发生了什么事情 。这个停车标志图像是一个反面例子。就当是模型的视错觉吧。

让我们看另一个例子。下面你有两张狗的图片，人眼无法分辨。

敌对的小狗(图片由作者提供)

左边的图片是 Dominika rose clay拍摄的一只小狗的原始照片。右边的是对第一个的一点修改，我在中间的图像中添加了噪声向量。

Inception v3 正确地将原始图像分类为狗的品种(红骨头)。然而，同一个模型非常自信地认为，我创建的修改图像是一张纸巾。

换句话说，我创造了一个对立的例子。您也会看到，因为这是我们将在第 3 节后面讨论的示例。

计算机视觉模型的一个对抗示例是具有人眼察觉不到的小扰动的输入图像，这导致错误的模型预测。

不要认为这两个例子是在花费大量时间和计算资源后发现的罕见的边缘例子。有很容易的方法来生成对立的例子，这为生产中的机器学习系统的严重漏洞打开了大门。

让我们看看如何生成一个对立的例子，并愚弄一个最先进的图像分类模型。

2.如何生成对抗性的例子？

对立的例子😈是通过拍摄清晰的图像产生的👼该模型正确分类，并找到导致新图像被 ML 模型错误分类的小扰动。

白盒场景

让我们假设您有关于您想要愚弄的模型的完整信息。在这种情况下，您可以计算模型的损失函数

在哪里

  • X 是输入图像
  • y 是输出类，
  • 并且 θ 是网络参数的向量。

该损失函数通常是分类方法的负对数似然。

你的目标是找到一个新的图像X’，它接近原始的 X 并且在损失函数值上产生一个大的变化。

想象你在所有可能的输入图像的空间里，坐在原始图像的上面。这个空间有尺寸宽 x 高 x 通道，所以如果你不能很好地想象它，我会原谅你😜。

行走在输入图像空间(图片由作者提供)

为了找到一个对立的例子，你需要在这个空间中向某个方向走一点，直到你找到另一个损失显著不同的图像X’。对于固定的小步长ε，你要选择使损失函数T3【J变化最大的方向。

现在，如果你稍微复习一下你的数学微积分课程，损失函数在 X 空间中变化最大的方向就是 J 相对于 X 的梯度。

一个函数相对于它的一个变量的梯度恰好是最大变化的方向。顺便说一下，这就是为什么人们用随机梯度下降法而不是随机方向下降法来训练神经网络。

快速梯度符号法

形式化这种直觉的一种简单方法如下:

快速梯度符号法

我们仅采用梯度的符号，并使用小参数ε对其进行缩放，以保证 X 和 X 之间的失真小到人眼察觉不到。这种方法被称为快速梯度符号法。

黑盒攻击

在大多数情况下，您很可能没有关于模型的完整信息。因此，前面的方法是没有用的，因为你不能计算梯度。

然而，有一个显著的属性叫做对立例子的可转移性，恶意代理可以利用它来破坏一个模型，即使他们不知道它的内部架构和参数。

研究人员反复观察到对立的例子在模型之间转移相当好，这意味着它们可以为目标模型 A 设计，但最终对在类似数据集上训练的任何其他模型都有效。

对立的例子可以如下产生:

  1. 对于 i = 1 … n，用输入 X_i 查询目标模型，并存储输出 y_i。
  2. 使用训练数据(X_i，y_i)建立另一个模型，称为替代模型。
  3. 使用白盒算法，如快速梯度符号，为替代模型生成对立的示例。他们中的许多人将成功地转移，并成为目标模式的反面例子。

在 这篇计算机视觉基础论文 中介绍了这种策略在一个商业机器学习模型中的成功应用。

3.动手例子:让我们打破盗梦空间 3

让我们动手使用 Python 和伟大的 PyTorch 库实现一些攻击。知道攻击者的想法总是很方便的。

你可以在 这个 Github 回购 中找到完整的代码。

我们的目标模型将是 Inception V3，这是一个由谷歌开发的强大的图像分类模型，它有大约 2700 万个参数，并在属于 20000 个类别的大约 1400 万张图像上进行训练。

我们下载模型被训练的类的列表，并构建一个将类 id 映射到标签的辅助字典。

让我们以一只无辜的红骨狗的图像作为开始的图像，我们将仔细地修改它以构建对立的例子:

照片由 Pexels 的 Dominika Roseclay 拍摄

Inception V3 期望图像的尺寸为 299 x 299，归一化像素范围在-1 和 1 之间。

让我们预处理一下我们漂亮的狗狗形象:

并检查该模型是否正确地对该图像进行了分类。

很好。模型按预期工作，并且红骨狗被归类为红骨狗:-)。

让我们转到有趣的部分，用快速梯度符号法产生对立的例子。

我已经创建了一个辅助函数来可视化原始图像和敌对图像。你可以在这个 GitHub 库 中看到完整的实现。

我们第一次尝试愚弄概念 3(图片由作者提供)

好吧。有趣的是，新图像的模型预测是如何变化的，这与原始图像几乎无法区分。新预测的是一只寻血犬，是另一个肤色非常相似、耳朵很大的犬种。由于有问题的小狗可能是混种，模型错误似乎很小，所以我们想进一步工作，真正打破这个模型。

一种可能性是尝试不同的 T21 值，并试图找到一个明显给出错误预测的值。让我们试试这个。

我们第二次试图愚弄盗梦空间 3(图片由作者提供)

随着ε增加，图像中的变化变得可见。不过模型预测的还是其他犬种: bloodhound 和 basset 。我们需要比这更聪明来打破这个模式。

记住快速梯度符号方法背后的直觉，即想象自己在所有可能图像的空间内(尺寸为 299 x 299 x 3)，就在原始图像 X 所在的位置。损失函数的梯度告诉您需要增加其值的方向，并使模型对正确的预测不太确定。步长为ε。你走一步，检查你现在是否坐在一个对立的例子上。

这种方法的延伸是采取许多更小的步骤，而不是一步到位。每走一步，你都要重新评估坡度，决定你要走的新方向

迭代快速梯度符号法(图片由作者提供)

这种方法称为迭代快速梯度法。多么原始的名字！

更正式地说:

其中 X0 = X ，而削波 X,ϵ 表示在【x+ϵ].x−ϵ】范围内对输入的削波

PyTorch 中的一个实现如下:

现在，让我们再次尝试从我们无辜的小狗开始，创造一个好的反面例子。

第一步:又是猎犬

第一步(作者图片)

再次比格犬

第二步(作者图片)

第三步:捕鼠器？有意思。然而，该预测的模型置信度仅为 16%。让我们更进一步。

第三步(作者图片)

第四步:多一个犬种，无聊…

第四步(作者图片)

第五步:再次比格犬..

第五步(作者图片)

第六步:

第六步(作者图片)

第七步:再次红骨。保持冷静，继续在影像空间中行走。

第七步(作者图片)

第八步:

第八步(作者图片)

第九步:宾果！🔥🔥🔥

第九步(作者图片)

多么奇特的纸巾啊。这个模型对它的预测相当有信心，几乎有 99%。

如果您比较我们在步骤 9 中找到的初始图像和最终图像

第九步(作者图片)

你可以看到它们本质上是一样的，一只小狗，但是对于 Inception V3 模型来说，它们是两个非常不同的东西。

我第一次看到这样的东西，非常惊讶。对图像的微小修改会导致这样的模型错误行为。这个例子很有趣，但如果你想到自动驾驶汽车愿景的含义，你可能会开始有点担心。

部署在关键任务中的深度学习模型需要正确处理对立的例子，但如何处理呢？

4.如何为你的模型辩护对抗的例子？

截至 2021 年 11 月，没有一个通用的防御策略可以让你抵御敌对的例子。换句话说，用对立的例子攻击一个模型比保护它更容易。

可以抵御任何已知攻击的最佳通用策略是在训练模型时使用对立的示例。

如果模型在训练过程中看到的对立实例，那么对于以相同方式生成的对立实例，其在预测时的性能会更好。这种技术被称为对抗训练。

您可以在训练模型时动态生成它们，并调整损失函数以查看干净的和敌对的输入。

使用对抗训练时的损失函数(图片由作者提供)

例如，如果我们将 10+个例子添加到训练集中，并将它们都标记为 redbone ，我们可以消除在上一节中发现的对立例子。

这种防御对于使用快速梯度符号方法的攻击非常有效。然而，还有更强大的攻击，我们在这篇文章中没有提到，可以绕过这种防御。如果你想知道更多，我鼓励你读一读尼古拉斯·卡里尼和戴维·瓦格纳写的这篇令人惊叹的论文https://arxiv.org/abs/1608.04644。

这就是为什么对抗性防御是机器学习和网络安全中的一个公开问题的原因。

结论

对抗性的例子是网络安全和机器学习交汇处的一个有趣的话题。然而，这仍然是一个有待解决的开放性问题。

在这篇文章中，我用代码示例对这个主题进行了实际介绍。如果你想进一步工作，我推荐 cleverhans ，这是一个由伟大的 Ian Goodfellow 和 Nicolas Papernot 开发的用于对抗性机器学习的 Python 库，目前由多伦多大学https://cleverhans-lab.github.io/维护。****

本文中我展示的所有源代码都在 这个 Github repo 中。

****https://github.com/Paulescu/adversarial-machine-learning

你想成为(甚至)更好的数据科学家，接触机器学习和数据科学的顶级课程吗？

👉🏽订阅 数据机通迅 。

👉🏽给我很多掌声👏🏿👏🏽👏在下面

👉🏽 跟着我 上媒。

祝你愉快，🧡

避寒胜地****

欺骗面部识别的对抗性眼镜

原文：https://towardsdatascience.com/adversarial-eyeglasses-to-trick-facial-recognition-887c9f90930f?source=collection_archive---------25-----------------------

我最近读了 Sharif 等人的一篇论文，描述了一个生成对抗性例子的一般框架，他们利用固定在人们脸上的眼镜框来欺骗面部识别分类器。此外，这种方法在打印出眼镜框并在身体对抗攻击中使用它们时也有效。

我决定用 PyTorch 构建一个 GitHub 库来实现这个方法。我还添加了一些额外的附加功能用于推断(比如在你的网络摄像头上自动试用眼镜)。

我将谈一谈这个方法以及我是如何实现它的。

目标

来生成眼镜框，使面部识别分类器认为你是别人

工具

  • 1 甘
  • 1 个分类器
  • 1 大眼镜架数据集
  • 一些名人面孔的图片
  • 我脸部的一些图像

算法

我想把论文中的算法分解成简单的文字，以便更好地理解讨论的方法。

来自论文(左图)——我的“翻译”(右图)[图片由作者提供]

微调面部识别分类器

我利用在 VGGFace2 上训练的预训练面部识别模型，然后微调它来识别我的脸。查看我的另一篇关于微调面部识别分类器的文章了解更多信息。

冻结网络中的图层并微调模型[图片来自作者]

我用交叉熵损失和随机梯度下降训练。

迭代损失图和微调模型的样本输出[图片由作者提供]

预训练 GAN

我实现了一个简单的 DCGAN 架构，它是在成千上万个眼镜框图像(最初由论文作者收集和清理)上从头开始训练的。

具有训练数据和样本输出的 GAN 结构[图片由作者提供]

训练这个甘是棘手的，需要一些按摩。GAN 逐步了解了眼镜框的结构(如下所示)。GAN 还学习了每个图像的黑色背景。

起初，甘只是产生静电[图片由作者]

然后它开始呈现眼镜的形状[图片由作者提供]

然后它学习了背景，但颜色仍然是柔和的[图片由作者提供]

它终于开始出现一些颜色变化[图片由作者提供]

然后我开始注意到图像中的一些光线变化

现在我们有了一个预训练的 GAN 和一个微调的面部识别分类器。

为 AGN 培训准备数据

我需要我的脸的图像，将有轻微的倾斜和照明变化。然后，这些图像将在 AGN 训练中用于将对立的眼镜框固定到每张脸上，并检查分类器是否被欺骗。为了获得这些图像，我简单地用我的 iPhone 拍了一段视频，然后把它们转换成 png 图像。然后，我将这些图像通过一个 MTCNN，它将每张脸与图像的宽度和高度相匹配，用于面部识别模型的训练和推理。

[图片由作者提供]

在训练期间，我尝试了一系列不同的变换，希望能使我的实现对各种角度和光线变化更加鲁棒。

[图片由作者提供]

最大的挑战之一是在每次迭代中将眼镜框固定到每张人脸图像上，因为每张图像的眼睛位置都不同于上一张图像——这一切都必须是可区分的！

为了能够将眼镜框架准确地固定到每幅图像中眼睛所在的位置，我利用面部标志分析来获得每幅图像中眼睛位置的坐标。

[图片由作者提供]

我的 PyTorch 数据集类由我的脸部图像和每张图像中我眼睛位置的坐标组成。然后，为了将 gen 图像转换成眼镜框，我使用 PyTorch 转换函数来保持整个过程的可区分性——我也在 CV 中实现了这一点，但必须为训练步骤重写它。

AGN 培训

培训期间最大的挑战是一个培训循环中的 2 个生成器更新。我们希望更新生成器是传统的 GAN 方式 s.t .它可以继续输出适当的眼镜框，但是，我们也希望这些眼镜框欺骗面部识别分类器。对于对抗性损失函数，我使用了卡里尼-瓦格纳损失(连续波损失)。

[图片由作者提供]

稍作调整，这种损失可以进行有针对性的或非有针对性的攻击。

现在，我们应该有一个生成器来输出眼镜框，这些眼镜框一贯欺骗面部识别分类器。我想在我的脸上测试这个对抗性生成器，所以我写了一个脚本来利用我的计算机的网络摄像头，并在执行面部识别时自动将生成的眼镜框放在我的眼睛上。眼镜可以随时换成新眼镜或非对抗性眼镜。

我在咖啡馆里测试一些对抗性眼镜[图片由作者提供]

查看GitHub 回购了解更多信息！

对抗性机器学习:攻击和可能的防御策略

原文：https://towardsdatascience.com/adversarial-machine-learning-attacks-and-possible-defense-strategies-c00eac0b395a?source=collection_archive---------13-----------------------

信息论

关于机器学习和人工智能的一个新兴研究领域的概述。

作者图片

近年来，对机器学习(ML)模型的研究不断发展，导致了非常精确的模型的定义。事实上，ML 研究人员的主要目标一直是开发更精确的模型。

因此，研究和开发没有关注这些模型的安全性，留下了许多严重的漏洞，这在理论上可能会对已实现的模型造成重大损害。

对抗性机器学习是一种试图修改现有机器学习模型的技术，目的是在预测中引入错误。

在这篇文章中，我将概述对抗性的 ML 攻击和可能的防御策略。

攻击

在计算机安全中，对手(或攻击者)是试图攻击系统以达到某些目的的人(人或机器)。对手可以在两个层次上对 ML 模型进行攻击:

  • 训练:攻击者试图在训练时扰乱模型或数据集，例如通过注入虚假数据或修改数据集中的数据；
  • 测试(或推理 ) : 这种攻击是在模型已经训练好的情况下进行的。

无论执行何种类型的攻击，对手可能知道也可能不知道该模型，因此他们可以执行以下攻击之一:

  • 黑盒攻击— 攻击者对模型一无所知
  • 灰箱攻击— 攻击者拥有模型的部分知识，如模型架构、参数、训练方法或训练数据；
  • 白盒攻击:攻击者完全了解模型或训练集。

训练时间攻击

这种攻击的目的是修改学习过程，以便:

  • 训练模型以预测特定的输出，或者
  • 训练模型来预测任何输出，但不预测实际输出。

存在两类训练攻击:

  • 数据访问 —攻击者拥有数据集的(部分)访问权，因此他们可以创建一个替代模型，该模型可以在测试阶段使用。
  • 中毒 —攻击者修改数据集或模型本身，以创建一个经过修改的训练模型。

实施中毒的攻击者可能采用以下策略:

  • 操纵现有的训练集
  • 向训练集注入新的虚假数据
  • 逻辑讹误，篡改学习算法。

在前两种情况下，攻击者应该有一些控制训练集的方法，而在第三种情况下，攻击者应该能够控制模型。

例如，让我们假设一个分类任务预测两个输出标签:同意和不同意。攻击者可以修改一些训练标签，将两个字符 a 和 s 分别改为 d 和 i ，反之亦然。这将最终产生反向训练模型。

测试时的攻击

测试时的攻击在运行时执行，此时模型已经被训练和部署。这些类型的攻击不会试图修改输出。相反，测试时的攻击旨在找到训练模型中的一些漏洞，以便:

  • 通过模型(规避攻击)找到一些能够规避适当输出的对抗性例子，
  • 推断模型或训练集的一些信息( Oracle 攻击)。

Oracle 攻击包括:

  • 提取攻击，攻击者试图从模型预测的分析中提取模型的参数；
  • 反转攻击，攻击者试图重建训练集，包括侵犯隐私的个人信息。
  • 成员推断，攻击者试图确定作为输入提供的给定数据是否在模型训练集中。

下图总结了攻击者可以执行的主要攻击类型:

作者图片

防卫

为了保护 ML 系统免受恶意 ML 攻击，应遵循以下步骤:

  • 识别管理信息系统的潜在漏洞
  • 设计并实施相应的攻击，并评估它们对系统的影响
  • 提出一些对策来保护 ML 系统免受已识别的攻击。

无论如何，所有的防御策略都可能涉及系统的一些性能开销，以及模型准确性的降低。

防御训练攻击

这种类型的防御试图使训练集更加健壮，例如通过删除所有导致高错误率的记录。防御训练攻击包括以下策略:

  • 数据加密——对抗数据访问攻击。
  • 数据净化 —对比中毒攻击。这种技术测试每一个样本，以发现对立的样本。
  • 稳健统计 —对比中毒攻击。该技术试图通过应用约束和正则化方法来减少由中毒引起的模型的潜在失真。

防御测试攻击

这种类型的防御是在训练阶段实现的，尽管它的目的是在测试阶段保护系统。对测试攻击的防御试图减少对手对模型造成的扰动的影响。

存在许多技术来保护系统免受测试攻击，包括对抗训练，其中具有对抗扰动的新输入和正确的输出标签被注入到训练数据中，旨在最小化由对抗数据引起的错误；渐变掩蔽、防御提取、集成方法、特征挤压和自动编码器。

当对手能够执行 Oracle 攻击时，防御测试攻击是非常困难的，这允许他们建立一个替代模型，该模型可以用作白盒。

下图总结了针对对抗性机器学习攻击的可能防御策略:

作者图片

用于对抗性 ML 的 Python 库

有许多 Python 库处理对立的 ML，比如下面这些:

  • 对抗性鲁棒性工具箱
  • 挂钩
  • 傻瓜箱
  • 刮擦声

在我以后的帖子中，我将调查这些库…敬请关注！

摘要

在本文中，我简要描述了最著名的对抗性机器学习攻击和一些可能的防御技术，以减轻它们对已部署的 ML 模型的影响。

如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。

参考

21 种对抗性机器学习的分类和术语

什么是对抗性学习？

相关文章

https://medium.com/geekculture/is-the-semantic-web-really-dead-7113cfd1f573 https://alod83.medium.com/june-articles-a-summary-of-my-june-articles-in-case-you-have-missed-them-8bc370375419 [## Expire-Span:忘记无关信息的新人工智能算法

towardsdatascience.com](/expire-span-the-new-ai-algorithm-that-forgets-irrelevant-information-61da9b442237)

给有抱负的数据科学家的建议

原文：https://towardsdatascience.com/advice-for-aspiring-data-scientists-20e71dd9ef25?source=collection_archive---------11-----------------------

来自创业公司创始人和前 Airbnb 数据科学经理的专业建议，帮助你的应用脱颖而出

照片由 克里斯蒂娜@ wocintechchat.com在 Unsplash 上拍摄。

几年前，基于我在 Airbnb 数据科学团队的经历，我写了一篇名为“给新数据科学家的建议”的文章。这篇文章是 2019 年 4 月 KD-nugget 的最受关注的博客之一，自那以来，它在 Medium 上有近 4 万次观看。它已经在许多地方被联合发行——甚至被剽窃，如果你能相信的话！😂我对那些给出太多建议的人很警惕，但我真的喜欢规模经济，我有太多关于这类信息的请求，但我都忽略了(抱歉！).因此，我决定尝试综合我对进入您的第一个数据科学角色的建议。这个建议是基于我在 Airbnb 近 5 年的工作经历，我在那里参加了数十个数据科学团队的招聘委员会，担任过许多职位的招聘经理，以及我最近在 Iggy 担任初创公司创始人兼首席执行官的经历。

为了正确设定期望值，这篇文章假设你在数据科学或分析方面受过一些培训。在我看来，这意味着你可以用 R 或 Python 编写代码，使用这两种语言中的通用包快速转换数据，编写复杂的 SQL，掌握可靠的统计数据，并充分理解各种机器学习技术和算法。(关于如何快速了解这些话题的资源，请查看我的前 Airbnb 同事 Kelly Peng 的精彩文章。大多数人认为这种基础培训足以获得数据科学领域的第一份工作。对不起，但那基本上是错的。基础训练只是基础。我接下来要分享的建议是你从这个基础出发的跳板。

投资组合

Github 回购作为投资组合的一个极好的例子。记录每个回购的 READMEs 的使用情况和其中链接的博客(即在business _ embeddeds)。图片作者。

如果你没有从这篇文章中得到其他东西:建立一个作品集，最好是在 Github 中，展示你的数据科学技能。我坚信这是任何应用程序和真正引起关注的应用程序之间的区别。作品集的目标是让你的简历更有活力；它将你从数百名(如果不是数千名的话)申请你的第一份数据科学工作的其他申请者中区分出来。你的作品集是展示你作品的地方。

关于你的投资组合应该包括什么的一些想法:分析、代码要点、网络应用、数据文档和博客(+ 自述文件！).无论如何，你不需要所有这些，但如果我必须选择两个，我会选择一个 webapp 和附带的博客帖子。webapp 是一种很好的方式，可以展示你将不同的软件链接在一起，并在 web 上创建动态的东西的能力。但是为什么是博客呢？正如我在上一篇文章中所说的那样，作为一名数据科学家，沟通是你工作中最重要的方面之一。书面交流尤其重要，如果你的工作地点很远，就更是如此。一篇写得好的博客文章(带有链接代码)可以让读者了解你是如何交流、编码和思考的。如果他们从这里得到好的信号，他们会想和你交谈。这一点很重要，因为让别人看你的简历是求职过程中最难的一步，所以如果你能增加在这里转换的机会，你将处于一个很好的位置。

你现在可能想知道如何为你的投资组合获得灵感。从你在 Twitter 或 Kaggle 上看到的一个很酷的数据集开始怎么样？是否存在任何数据质量问题，如泄漏、截断、丢失数据？它们如何影响分析？您也可以从思想领袖的时事通讯中获得灵感(参见下面的参考资料部分)。从当前和过去的问题中选择一些让你感兴趣的文章并阅读它们，开始在 Twitter 上关注人们，你很快就会有大量数据科学内容出现。有些人会分享分析——看看你能否复制和更新。其他人可能会讨论需要解决的数据科学挑战，您会如何解决？还有一些人会展示他们可以用 Python 做一些事情——你能用 R 做吗？最后，像我这样的公司将为数据科学家发布新工具。(这是另一个我挖的。试用他们的工具并分享您的成果！你明白了。所有这些的目的都是为了成长和学习如何找到工作。这需要时间。

求职

一旦你的投资组合准备就绪，就开始找工作吧！如果你对初创公司感兴趣，请浏览 TechCrunch，看看有哪些公司获得了资助，并查看它们的招聘信息。或者对各种风投公司的投资组合公司做同样的事情。我会瞄准至少已经融资 B 轮的公司，尽管 C 轮可能是更好的选择。为什么？嗯，作为一名初级数据科学家，您可能需要一个足够的数据基础架构来保持高效，而对于年轻的公司来说，这种情况不太可能出现。如果你对大公司的工作更感兴趣，看看他们的工作列表，尽可能多地了解他们的工作。如果他们有科技博客，读一读。调查他们开源了什么。

来自 Amplify Partners 的投资组合样本页面。图片作者。

冷外展

了解我的人都知道我是科技多元化的狂热支持者。我创办 Iggy 的原因有很多，但其中一个与我作为一名女性在一个极度男性主导的领域中的感受有关。我坚信，女性和少数族裔应该像男性一样创建公司，推动决策，设计出可以想象的最佳产品。不幸的是，这么多女人(包括我自己！)等着被告知他们可以做这些事情。分享一下我自己的经历:在离开数据科学公司创办自己的公司之前，我一心想要晋升为一名数据科学家。出于某种原因，我认为我需要那枚认可的印章去做一些不同的事情。！？).当我意识到(在一些帮助下)这毫无意义时，我就采取了行动。为什么我在这里分享这个？大多数男人做事不会等待或请求许可；他们只是做他们！作为一名招聘多个职位的创始人，我几乎每周都会收到想要加入我公司的男性发来的冷冰冰的电子邮件。我已经收到 0 封来自女性的冰冷邮件。所以，读这篇文章的女人们:学会如何发送冷冰冰的邮件。这可能意味着稍微走出你的舒适区，申请一份工作，即使你没有达到 100%的工作要求。这很好！只要仔细看看你已经建立的投资组合，明确你的互补背景或深厚的个人兴趣。这可以抵消一些次要的工作要求。男人这样做，不加思考，这有助于他们。这一现实让我感到沮丧，但作为一名创始人，我可以告诉你，招聘真的很难，所以当人们通过一封简短的电子邮件将简历上的点点滴滴联系起来，让我的工作变得更容易时，我很感激。

我在下面附上了一封冷漠邮件的样本文本。请不要一字不差地照抄——用它作为灵感，写一些反映你声音的东西。

关闭

我希望这对你有所帮助。当招聘人员向你伸出援手时，你会知道你做得很好，当你给他们一个好的理由时，他们更有可能这样做！如果你有问题，请在评论区提问。如果这有所帮助，请在下面分享你的故事，让我知道。

林赛·佩廷吉尔，首席执行官@ Iggy

资源

投资组合工具

  • Github(托管你所有的代码):https://github.com/
  • Heroku(托管 web apps):https://www.heroku.com/
  • Iggy(我的公司；对于位置丰富):https://askiggy.com/
  • 十六进制(用于交互式笔记本/应用):https://hex.tech/

时事通讯

  • 数据科学综述【http://roundup.fishtownanalytics.com/
  • dbt 社区简讯https://community.getdbt.com/newsletter
  • 数据仙丹:https://dataelixir.com/
  • 要了解的项目https://projectstoknow.amplifypartners.com/ml-and-data

样本冷邮件模板

嗨，我刚刚看到/读到/听到{参考一些关于公司的实质性内容}。这对我来说很有吸引力/很有趣，因为{与以前的工作有联系，是作品集里的东西}。我在这方面做了一些工作{链接到它}，很想和您聊聊{公司}的数据科学职位。在接下来的几周里，你有时间和我聊 15 分钟吗？

进入数据科学的建议

原文：https://towardsdatascience.com/advice-for-getting-into-data-science-4550c36bc11f?source=collection_archive---------38-----------------------

来自一位资深数据科学家

作者:爱德华·克鲁格和道格拉斯·富兰克林。

Roberto Nickson 在 Unsplash 上的照片

起点

数据科学是多学科的。正因为如此，人们从各种背景进入数据科学。我们看到地球物理学家、数学家、政治学家、商业分析师，甚至是没有工作经验的大学毕业生都开始学习数据科学。

由于数据在当今行业中无处不在，所有先进领域都将在某种程度上采用数据科学。我们看到进入这个领域的各种背景会给个人带来优势，因为他们用一些主题专业知识来解决问题。然而，一些背景在学习数据科学原理和技能方面具有很大的优势。

学习数据科学的三个最佳背景是。

  • 编程；编排
  • 统计和概率
  • 数学

如果你不是来自这些背景，那也没关系！只要准备好投入工作去发展数学、统计和编程技能。

数据科学结合了科学方法、数学和统计、专业编程、高级分析、人工智能和讲故事，以揭示和解释数据中的模式。因此，在进入这个领域时，拥有这些领域的经验是非常有用的。

数据科学包括为分析和处理准备数据、执行高级数据分析、展示结果以及部署模型。所以你需要知道如何编码。

不要因为钱而开启数据科学的职业道路。商业智能分析、数据工程师和其他开发人员可以拿到类似的薪水。确保你对构建软件、批判性地分析问题和应用科学方法有热情。

学一般

数据科学不是一个结晶的领域。也就是说，该领域仍在发展，许多技能将对数据科学团队有用。此外，两家不同公司的数据科学家可能会使用不同的工具解决完全不同的问题。

学一般是个好主意。你需要了解工程学、数学和统计学，才能在这个领域出类拔萃。

掌握一项技能——比如统计，收集一本教科书或一门在线课程，全身心地投入学习。但不要止步于此；不断学习新技能！随着时间的推移，你将开始建立直觉，并建立跨学科的联系。

照片 11751666 迈克尔·弗利波| Dreamstime.com

当你开始学习时，我们建议你学习如何编码。这样做，解决现实问题！自动化日常工作流程的某些部分，创建一个 API 并部署它以便其他人可以使用它，制作一个仪表板以更好地可视化一些 KPI 或业务流程，并与您的老板共享它。这些都是你现在可以用有意义的方式应用你的新知识和技能的例子！

数据科学家应该是多面手

数据科学家(DS)通常会带来他们价值的很大一部分，而他们的专业技能相对来说并不需要。当想要雇佣任何级别的人时，企业更愿意雇佣那些能够投入并帮助解决大量问题的人，而不是那些随叫随到等待荣耀时刻到来的人。

尽管 DS 的价值来自于他们解决非常专业的问题的能力，但这只需要他们适度的时间。对于大多数公司来说，既没有足够的这些特殊问题，也没有足够的资源让数据科学家全职解决这些问题。

所以，常识变得至关重要。如果候选人能够编写和重构应用程序/模块代码，处理一些云部署，进行一些数据工程，创建临时报告，统计评估业务决策的风险，挖掘 bug，编写测试套件，进行和分析 A/B 测试，评估和集成第三方 ML 服务等。他们对公司的价值将远远高于只是随叫随到等待荣耀时刻到来的专家。

数据科学家将思考数据是如何生成的，并积极参与数据的收集或生成。您将每天花费大量时间了解数据，就如何收集和存储数据提出建议，并清理/准备数据。

他们说数据是新的石油。像石油一样，原始数据不是很有价值。然而，在针对特定问题进行提炼之后，它可以带来巨大的利润。数万亿字节的数据对公司没有任何好处。你需要正确的数据来解决你的问题。从原始数据到有用数据可能需要大量的工作。

大卫·蒂伦在 Unsplash 上拍摄的照片

数据科学家经常被要求成为他们不知道的某方面的专家，但他们有通用的知识库。

对于大多数人来说，仅凭对 ML 的了解就进入数据科学领域已经不再可能。这部分是因为 ML 并不能解决所有的问题，通常也不是一个完整的解决方案。

总会有专家在 ML 中创造新技术。然而，随着 ML 库的进步和 AutoML 的出现，通才现在可以在很短的时间内完成过去需要专家花费大量时间才能完成的工作。

要获得更多关于如何开始学习数据科学的建议，请查看 Arunn the vaplan 撰写的这篇文章！

💔-beginner-mistakes-ive-made-in-my-data-science-career-a177f1cf751b>

从初级数据分析师到高级数据分析师的建议

原文：https://towardsdatascience.com/advice-to-go-from-junior-to-senior-data-analyst-4680b7c126ed?source=collection_archive---------17-----------------------

如何展示你已准备好进入下一阶段

照片由 Pexels 的 Olya Kobruseva 拍摄

现在是 2021 年，是时候进行年度绩效评估并为这一年设定新目标了。如果你想从初级数据分析师晋升到高级数据分析师，这是我根据与已经晋升到下一级的初级分析师共事的经验给出的建议。

学会独立

由于缺乏经验，初级分析师往往会问更多的问题。高级分析师问的问题更少，因为他们能够根据过去的经验做出决策。这并不意味着作为初级分析师你不应该提问。不提问和犯错，你永远不会获得经验。然而，避免你的第一直觉马上问问题，想想你可能如何解决这个问题，为什么。然后向你的经理或资深分析师寻求建议，并解释你为什么想出这种方法。你可能仍然没有在正确的轨道上，但这表明你在寻求帮助之前尝试独立解决问题。

从大处着眼

初级分析师孤立地处理请求，不会超出请求的范围来确定它与全局的关系。高级分析师会提出更多试探性的问题，以抓住问题的症结并提供最佳解决方案。这种能力来自经验，但这并不意味着初级分析师不能更快地达到那个阶段。通过要求就他们如何处理特定项目进行知识分享会议，了解高级分析师如何处理问题。我在一家公司工作，在那里我们每两周开一次会，展示数据团队一直在做的有趣的分析。我学到了新的方法，这些方法后来应用到了我自己的项目中，否则我是学不到的。

要求更具挑战性的项目

初级分析师通常从事较简单的任务，而经理则倾向于将较复杂的分析任务分配给高级分析师。要想成长为一名分析师，问问自己是否能接受更具挑战性的项目来学习，并走出自己的分析舒适区。一句警告的话是，不要问，直到你觉得准备好接受这些新的挑战。如果你成功地完成了留给高级分析师的任务，你的经理就更容易证明给你升职是正确的。

学习如何用数据讲故事

我把“用数据讲故事”描述为回答一个商业问题并解释为什么它对听众很重要的能力。初级分析师只是提供所需的数据。高级分析师更进一步了解公司的 KPI，以及他们的结果如何与影响业务的 KPI 相关联。了解利益相关者关注的关键绩效指标，并尝试将您的分析结果与这些关键绩效指标联系起来。这将展示你理解业务和像高级分析师一样思考的能力。

学会以清晰的方式传达结果

作为一名高级分析师，沟通技巧是一项必备的软技能。学习如何很好地沟通需要练习，但这并不意味着作为初级分析师你不能很快提高。每一个展示结果的机会都是练习沟通技巧的机会。如果你的团队没有知识分享会议，建议每月一次。这将提供一个练习演示的机会，并观察高级分析师如何演示他们的结果。你也可以借此机会要求反馈，以改善你的沟通，为未来的演示。

寻求反馈

这是最显而易见的，但请向你的经理寻求反馈，以达到更高的水平。这些建议可以纳入你的年度目标，如果你能实现这些目标，你的经理就更容易证明你的晋升是合理的。

当你第一次开始做数据分析师时，并不清楚如何达到下一个级别。既然你已经知道了成为高级分析师所需要的关键技能，我希望你的晋升早点到来。

你可能也会喜欢…

https://medium.com/the-post-grad-survival-guide/how-to-handle-a-bad-manager-e68032e47 [## 如何成为一名出色的数据分析员工

towardsdatascience.com](/how-to-become-an-amazing-data-analytics-hire-6d7a1f8be766) https://medium.datadriveninvestor.com/4-habits-of-bad-data-analysts-731ec6b7c537

审美认识论——评埃尔娜·菲奥伦蒂尼的“诱导可见性”

原文：https://towardsdatascience.com/aesthetic-epistemology-a-review-of-erna-fiorentinis-inducing-visibilities-3d61919593c3?source=collection_archive---------44-----------------------

“诱导可见性:圣地亚哥·拉蒙·卡哈尔美学认识论的尝试”简评

文章作者埃尔娜·菲奥伦蒂尼 : “诱导可见性:圣地亚哥·拉蒙·y·卡哈尔审美认识论的尝试”/生物学和生物医学科学的历史和哲学研究 42(2011)391–394

由 Santiago Ramón y Cajal 于 1899 年从鸽子小脑中提取浦肯野细胞 (A)和颗粒细胞 (B );西班牙马德里卡哈尔学院。

埃尔娜·菲奥伦蒂尼对神经科学之父、科学家圣地亚哥·拉蒙·y·卡哈尔的研究引入了“审美认识论”的概念来描述卡哈尔研究组织学的方法。组织学是用显微镜对植物和动物的细胞和组织进行解剖的研究。就其本质而言，组织学是一个我们不能直接观察研究对象的研究领域。

菲奥伦蒂尼理论化的“审美认识论”描述了一种知识生产的形式，在这种形式中，可视化被创造出来，使隐藏在观察者面前的东西变得可见，同时也提高了观察者的敏感性。大约在 1887 年，Cajal 改进了一种染色技术，使人类大脑皮层的神经元结构可见，大脑皮层是人体的一部分，神经元如此密集，以至于不能用标准的显微镜工具观察。通过使用这种染色方法并创建他的发现的大量详细图纸，Cajal 能够“诱导可见性”或创建测试结果的可视化，然后他拼凑起来以表示关于它们的更深层次的知识。因此，Cajal 绘制了代表在染色技术结果中发现的信息的图纸，因为假定了实际(不可见)神经元的可视化。他的目的不仅是展示大脑皮层中的神经元是什么样子，而且是解释整个系统及其功能。

这个提取和可视化数据以形成知识的过程就是菲奥伦蒂尼所说的“审美认识论”。用她自己的话来说，“卡哈尔高度复杂的绘画并没有再现给定的三维可视性，而是诱导了它的高级形式。”(菲奥伦蒂尼，第 393 页)因此，菲奥伦蒂尼认为，可见性的归纳不仅需要先进的可视化技术，而且这些可视化是知识生产的构成形式。卡哈尔的可见性归纳策略同样提到了理性的和审美的视觉感受，并认为这两者都是知识生产的构成要素(菲奥伦蒂尼，第 394 页)这个过程的一部分需要某种美学，因为艺术家科学家用手绘制图纸，通过绘画的过程梳理知识。

Santiago Ramon y Cajal 的三幅绘画，摘自《人类大脑皮层感觉区域的比较研究》一书，第 314、361 和 363 页。左图:成人尼氏染色的视觉皮层。中间:尼氏染色的成人运动皮质。右图:一个半月大婴儿的高尔基染色皮层。圣地亚哥·拉蒙·y·卡哈尔的《人类大脑皮层感觉区域的比较研究》，出版于 1899 年， ISBN 9781458821898

将 Cajal 的画与最近的大脑成像可视化放在一起看，显示了 Cajal 能够诱导大脑皮层神经元可视化的惊人准确性。

照片由科罗拉多学院心理学系定量神经形态学实验室的鲍勃·雅各布拍摄

我的收获和对数据科学家/数据可视化专家的意义:

作为一名读者和数据从业者，我没有深入探讨菲奥伦蒂尼理论更深层次的认知影响，而是从这篇文章中带走了许多问题和想法。从可视化中归纳知识的概念是数据可视化的一个隐含部分。数据通常与它们量化的事物相分离，通常数据可视化是数字的表示，而不是这些数字所描述的主题。换句话说，仅仅是地图、图形和图表。因此，数据可视化专家通常依靠写作来创建关于数据的有意义的故事，即补充可视化。

卡哈尔的工作显示了将艺术和美学作为一种知识生产形式的承诺和可能性。对于数据可视化专家来说，只要有可能，就应该使用诱导可见性和审美认识论的概念，将美学和艺术实践融入到他们的工作中。

亲和蛋白质:下一代测序数据分析(第 1 部分)

原文：https://towardsdatascience.com/affimer-proteins-next-generation-sequencing-data-analysis-part-1-ac6a252842be?source=collection_archive---------25-----------------------

路易斯·里德在 Unsplash 上的照片

思想和理论，亲和蛋白质

亲和分子、抗体和 DNA 序列内的搜索

介绍

在这个博客系列中，我将使用 R 编程语言描述一个具体的数据分析问题。也就是说，分析来自下一代测序机器的生物数据，涉及一种称为亲和蛋白的特定类型的分子。合理的 R 工作知识有利于理解代码，但没有这个也能理解整体流程。

在第 1 部分中，我们将首先介绍分析任务的背景，然后我们将开始探索一些示例数据，并在 DNA 序列中找到特定的模式。在第二部分，我们将进一步分析，看看氨基酸翻译和“移码”。最后，在第 3 部分，我们将看到如何使用分子条形码，然后如何削减最佳亲和蛋白质候选人的选择。

什么是亲和分子？

在讲亲和分子之前，我们需要了解 抗体 的基础知识。抗体是 Y 形分子，是免疫系统的重要组成部分。它们被用来检测和结合触发免疫反应的分子，如细菌或病毒。靶向的独特分子部分被称为抗原(或“抗体发生器”)，可以被认为是抗体相应“锁”的“钥匙”。

抗体上的一个部分(“Y 部分”)在不同的抗体之间有很大的差异，但对每种抗原都有极强的特异性。这不仅使它们可用于对抗感染，还可用于诊断测试的开发，因为它们可用于检测感兴趣的分子。例如，家庭妊娠测试使用抗体(固定在试纸上的一条线上)来检测并附着到 人绒毛膜促性腺激素 (hCG)。

出于这一原因以及许多其他原因，抗体在全球范围内被用于从诊断到治疗的许多医学领域。通常，用于特定应用的抗体由单个细胞系产生，产生所谓的 单克隆抗体 。

然而，尽管它们具有所有有用的特性，但这种抗体也有缺点，包括可能需要很长的时间来识别合适的结合物(即，与某些感兴趣的靶结合的特定抗体)，与它们相对较大的尺寸相关的问题(例如“空间位阻”，或由于分子庞大的性质而导致的化学反应变慢)，以及 不可避免地使用动物 。

下面是抗体的示意图，突出显示了抗原结合位点，

图像参考

亲和分子 是设计用于执行与单克隆抗体相似功能的蛋白质，但具有几个优点。首先，它们要小得多，这使它们比大得多的抗体更稳定(在温度和 pH 值方面)，也更不容易产生空间位阻。第二，就找到特定目标的活页夹而言，创建它们要快得多。第三，它们的批间一致性高。第四，不涉及动物，因为它们是通过体外过程产生的。

下图显示了抗体和亲和蛋白的相对大小。绑定区域显示为红色，

图像参考

亲和分子生成

亲和分子不是为特定的应用而单独设计的。相反，大量的亲和结合物库被创造出来，从中选择合适的分子。我们将在下面更详细地描述这一过程，但在此之前，更深入地研究一下大自然是如何解决同一问题的，也就是说，如何为一个新的、以前未知的目标找到合适的粘合剂，这很有趣？这个过程实际上与亲和分子方法没有什么不同。

如果这是一个工程问题，我们会分析目标，并从理论上找出最好的粘合剂。大自然没有这种能力。相反，所采取的方法是从使用数十亿种不同抗体的强力随机方法开始。上面我们看到每个抗体都有一个高度可变的区域。有几种机制已经进化到在该区域产生变异(同时保持框架的其余部分不变，或在抗体之间“保守”)。首先， B 细胞 (一种产生抗体的白细胞)利用一种叫做体细胞重组(或者更具体地说， V(D)J 重组 )的过程来产生初始可变性。这个过程基本上包括通过随机选择不同的可能子部分来构建抗体(有点像重复从一副牌中随机挑选卡片来生成许多不同的组合)。

一旦这些具有随机可变区的抗体之一与抗原结合(由于其可变区恰好相容)，第二种机制开始工作，以进一步提高亲和力(或吸引力的强度)。这被称为 体细胞超突变 ，涉及 B 细胞快速增殖过程中的错误导致的基因点突变(单核苷酸突变)。这些突变采用编码合适结合物的 DNA 序列，并以许多不同的方式对其进行轻微修改。一些随之而来的可变区将具有较低的亲和力，并且一些可变区可能一起失去它们与相应抗原的结合能力。但是有些可能，再次偶然地，增加它们的结合亲和力。随着细胞继续繁殖，产生这些抗体的相应 B 细胞将与那些结合强度较低的细胞竞争，导致在一个称为 亲和力成熟 的过程中整体产生最佳结合剂。

结果是大量抗体具有非常适合结合特定抗原的可变区。

Affimer binders 以类似的方式创建，在特定的设计中使用随机化。这要从一个叫做https://en.wikipedia.org/wiki/Phage_display的噬菌体展示过程说起。这是一个使用一种叫做噬菌体或简称噬菌体的病毒的过程。基因被插入到这些噬菌体中，使它们产生(或“展示”)与在其表面注射的基因相对应的特定蛋白质。通过允许这种基因突变，一些初始遗传序列的随机变体被创造出来，导致许多不同的版本(因此有术语“文库”)。亲和蛋白质文库由大约 10^10 随机序列组成。

下一步是将靶分子(即感兴趣的分子，为此需要结合剂)通过该文库，并观察哪些 10^10 结合剂是相容的。在简单的洗涤步骤去除剩余部分后，带有结合体分子的噬菌体可以被去除、扩增(通过感染细菌并使它们产生更多拷贝)，并重复该过程。这样，恰好结合的一种或多种结合物(记住，文库由随机突变组成)可以被分离、鉴定和表征。

正是这种表征开始产生数据。这个过程的第一步是从这些重复的步骤中提取结合物，并确定它们的确切 DNA 序列。这是至关重要的一步，因为现在有一个 Affimer 粘合剂具有特定应用的正确特征。表现型和相关基因型之间的这种联系使得某种分子能够被唯一地识别、隔离(比如说，由某个特定的公司或大学)和大规模生产。

就物理结构而言，亲和分子由“支架”(分子的主体)和两个肽环(氨基酸的短序列)组成。正是环的可变性使得亲和结合物能够针对靶分子进行筛选和选择。就数据分析而言，这些环的氨基酸序列是关键。请注意，这两个循环区域分别称为“循环 2”和“循环 4”。下图显示了突出显示这些可变环区域的亲和分子，

图像参考

数据分析

在这一节中，我们将深入分析与档案夹相关的数据。

序列搜索

首先，我们来看看一些有用的 R 库和它们对应的用于简单 DNA 操作的函数。首先，确保安装了正确的 R 库，

**if (!requireNamespace(“BiocManager”, quietly = TRUE))*
*install.packages(“BiocManager”)*

*BiocManager::install(“Biostrings”)*
*BiocManager::install(“ShortRead”)*

*#Note, if after ‘updating all’ from the above you receive an installation error, you may have to manually delete the ‘rlang’ folder and reinstall**

接下来，加载已安装的库，

*library(“Biostrings”) *#Package for sequence analysis*
library(“ShortRead”) *#For loading fastq files*
library(“tidyverse”) *#For general data manipulation and plotting*
library(“gridExtra”) *#For plotting multiple plots*
library(“stringr”) *#For various string functions**

让我们从一个例子(完全虚构的)DNA 序列开始，我们将它设置为一个名为“seq”的变量，

*seq = “TACGGAAAGCTAGAAAGTTTTGCTACTACATCAAAGTCCGCAAATACATGCACCTAAAAGTTGTTAACGGCCCATTCATA”*

生物字符串 模块提供了一个名为 matchPattern 的函数，用于在一个更大的序列中搜索一个序列。下面是一个例子，我们在“seq”变量中搜索子序列“AAGTTTT ”,

*matchPattern(pattern = 'AAGTTTT', 
             subject = seq)## Views on a 80-letter BString subject
## subject: TACGGAAAGCTAGAAAGTTTTGCTACTACATCAA…CATGCACCTAAAAGTTGTTAACGGCCCATTCATA
## views:
## start end width
## [1] 15 21 7 [AAGTTTT]*

您可以看到找到了较小的序列，从位置 15 开始，到位置 21 结束。该功能允许错配和插入(插入或删除碱基)。例如，让我们在子序列中间添加一个“A ”,并像以前一样运行它，

*matchPattern(pattern = ‘AAGTATTT’, 
             subject = seq)## Views on a 80-letter BString subject
## subject: TACGGAAAGCTAGAAAGTTTTGCTACTACATCAA…CATGCACCTAAAAGTTGTTAACGGCCCATTCATA
## views: NONE*

现在因为插入的 DNA 碱基，什么都没发现。但是，我们可以设置适当的参数来允许不匹配，最多允许 1 个不匹配，

*matchPattern(pattern = ‘AAGTATTT’, 
             subject = seq, 
             with.indels = T, 
             max.mismatch = 1)## Views on a 80-letter BString subject
## subject: TACGGAAAGCTAGAAAGTTTTGCTACTACATCAA…CATGCACCTAAAAGTTGTTAACGGCCCATTCATA
## views:
## start end width
## [1] 15 21 7 [AAGTTTT]*

现在该函数已经找到了原始匹配。注意，长度仍然是 7，因为它将插入的“A”识别为插入，而不是实际搜索序列的一部分。

加载多个序列

现在让我们将它和其他一些有用的函数一起应用到一个加载的(演示)数据集。我们将使用 readFastq 函数直接加载一个 下一代测序 (NGS) Fastq 文件。注意，我们实际上有两个文件，一个针对 读取方向 。这是 NGS 机器如何工作的结果，通过从开始，向前，从结束，向后读取 DNA 的每个部分。我们稍后将研究 NGS 机器是如何工作的。

我们还将使用线程来提取 DNA 序列，最后对第二个 DNA 序列进行反向补全。

首先，我们使用函数 readFastq 来读取 Fastq 文件。这种文件格式广泛用于基因组学领域，是一种简单的文本文件。文件不仅包含序列，还包含“质量分数”(称为)Phred 质量分数 。这些是由 NGS 机器产生的，并且给出了单个碱基被阅读的程度的指示。见下表，

图像参考

分数实际上是用 ASCII 字符编码的，其中每个 ASCII 字符的数字代表质量分数(具体来说，从 0 到 93 的 Phred 质量分数用 ASCII 字符 33 到 126 编码)。我们会看看质量分数，但首先我们需要阅读数据，

*#*Forward read* read_f = readFastq(path, pattern=”999250_S99_L001_R1_001.fastq”)*#Reverse read* read_r = readFastq(path, pattern=”999250_S99_L001_R2_001.fastq”)*

接下来，让我们使用 sread 从文件中提取序列，

*dna_1 = sread(read_f)
dna_2 = sread(read_r)*

然后得到反向阅读的反向恭维(因为是反向的！),

*dna_2 = reverseComplement(dna_2) *#Get the reverse compliment**

让我们看看第一个序列的质量，

*quality(read_f[1])## class: FastqQuality
## quality:
## BStringSet object of length 1:
## width seq
## [1] 153 ^6@e?U1d@sy0i@`XHe~@BzFn`Ak=F7TQuT…Vq[q@VJ`TzVMGzoawbloN]P17k^zjA\d9*

这里我们可以看到 ASCII 格式的质量分数。我们可以更进一步，通过使用 FastqQuality 和 quality 函数从文件中获取质量分数，然后使用 boxplot 函数绘制它们。根据经验，任何超过 Phred 质量分数 20 的都是可以接受的，所以我们将把这个阈值添加为一条红线，

*qual <- FastqQuality(quality(quality(read_f))) *#get quality scores*

readM <- as(qual, “matrix”) *#convert scores to matrix*

boxplot(as.data.frame((readM)), *#Plot the data*
        outline = FALSE, 
        main=”Per Cycle Read Quality”, 
        xlab=”Cycle”, 
        ylab=”Phred Quality”, 
        ylim=c(0,100))

abline(h=20, lwd = 3, col = ‘red’) *#Add the horizontal line**

我们可以看到，这次阅读的质量是好的，所有 Phred 分数都远远高于临界值。

摘要

在第一篇文章中，我们已经看了什么是亲和分子，并开始看与 DNA 序列相关的 R 中的基本数据分析。在第 2 部分中，我们将更深入地研究数据，看看 DNA 序列如何被翻译成氨基酸序列，搜索特定的亲和分子环，并看看所谓的“阅读框架”。

亲和蛋白质:下一代测序数据分析(第二部分)

原文：https://towardsdatascience.com/affimer-proteins-next-generation-sequencing-data-analysis-part-2-8ebc0e90f460?source=collection_archive---------32-----------------------

路易斯·里德在 Unsplash 上的照片

亲和蛋白质类

氨基酸翻译和寻找亲和环区

在第 1 部分中，我们看了什么是亲和分子，并开始看与 DNA 序列相关的 R 中的基本数据分析。接下来，我们将更深入地研究数据，搜索特定的亲和分子环，并查看不同的“阅读框架”如何影响特定序列的搜索。

DNA ->氨基酸

最终，我们实际上对亲和结合物的 DNA 序列并不感兴趣。相反，我们感兴趣的是氨基酸(AA)序列。其原因是，正是氨基酸形成了蛋白质，进而产生了亲和分子(特别是环区)的物理特征(和结合特性)。

DNA 到 AA 翻译 的物理过程是从一个叫做 转录 的过程开始的。首先，一种叫做 RNA 聚合酶 的酶解开 DNA 分子的双螺旋结构，露出 DNA 碱基。接下来，该酶创建了一个互补的单链分子，称为messenger-RNA(mRNA)，这意味着 DNA 链上的每个 C 都变成了 mRNA 链上的 G，每个 G 都变成了 C，每个 T 变成了 A，每个 A 变成了 A，每个 A 变成了 U(注意，U 取代了 DNA 中的 T)。

进一步的步骤使这种“前 mRNA”成熟为 mRNA 的最终形式，然后 mRNA 序列被称为 核糖体 的结构读取。这种阅读过程是通过一次查看 3 个碱基(称为密码子)来进行的，每个碱基要么编码一个氨基酸，要么告诉核糖体停止(称为终止密码子)。氨基酸链继续构建，直到到达终止密码子，由此产生的分子链就是最终生成的蛋白质。

令人难以置信的是，取决于氨基酸转换是从第一、第二还是第三个碱基开始，你最终可以得到完全不同的 3 碱基集合，因此完全不同的氨基酸和因此完全不同的蛋白质。这些被称为阅读框架，我们稍后将回到它们。

下面是密码子到氨基酸转换的示意图(从中间开始向外移动，选择 3 个氨基酸)。请注意，不同的 DNA 组合可以导致相同的氨基酸，DNA -> AA 翻译是直接的，但 AA -> DNA 翻译是不可能的(因为没有办法知道哪个 DNA 序列在给定的 AA 后面)。这对数据管理有影响，即 AA 序列和它们的潜在 DNA 序列必须总是以某种方式保留和连接。

图像参考

现在让我们使用翻译函数将 DNA 翻译成 AA。这个函数应用于每个 DNA 序列，然后数据被组合成一个 data frame(R 中常用的 2D 数据结构)，

*#AA translation*
aa_1 = translate(dna_1) *#Translate*
aa_1_dt = as.data.frame(aa_1) *#Add to a dataframe*

aa_2 = translate(dna_2) *#Translate*
aa_2_dt = as.data.frame(aa_2) *#Add to a dataframe*

*#Create a label for the direction,*
aa_1_dt$read_direction = ‘F’
aa_2_dt$read_direction = ‘R’

*#Combine the two dataframes,*
aa_all = rbind(aa_1_dt, aa_2_dt)
colnames(aa_all) = c(‘amino_acid_seq’, ‘read_direction’)

这是我们现在拥有的(前 6 项)，

head(aa_all)## amino_acid_seq                            read_direction
 ## 1 YGKLEAVQYKTQVLANINETYNINESTNYYIKVRAGDNKYMHLKVFNGPFI F
 ## 2 YGKLEAVQYKTQVLANINETYNINESTNYYIKVRAGDNKYMHLKVFNGPFI F
 ## 3 YGKLEAVQYKTQVLAEIGHTYTHREESTNYYIKVRAGDNKYMHLKVFNGPT F
 ## 4 YGKLEAVQYKTQVLATWENTYSTNYYIKVRAGDNKYMHLKVFNGPFIFTYN F
 ## 5 YGKLEAVQYKTQVLANINETYNINESTNYYIKVRAGDNKYMHLKVFNGPTH F
 ## 6 YGKLEAVQYKTQVLATWENTYSTNYYIKVRAGDNKYMHLKVFNGPNINETY F

我们还可以看到一些相反的顺序(最后 6 项)，

tail(aa_all)## amino_acid_seq                              read_direction
 ## 995 VESTNYYIKVRAGDNKYMHLKVFNGPTHIRTYFIVEADRVLTGYQVDKNKD R
 ## 996 ESTNYYIKVRAGDNKYMHLKVFNGPNINETYSEVENADRVLTGYQVDKNKD R
 ## 997 ESTNYYIKVRAGDNKYMHLKVFNGPNINETYSEVENADRVLTGYQVDKNKD R
 ## 998 ESTNYYIKVRAGDNKYMHLKVFNGPNINETYSEVENADRVLTGYQVDKNKD R
 ## 999 VESTNYYIKVRAGDNKYMHLKVFNGPTHIRTYFIVEADRVLTGYQVDKNKD R
 ## 1000 ESTNYYIKVRAGDNKYMHLKVFNGPNINETYSEVENADRVLTGYQVDKNKD R

我们的 DNA 序列现在是 AA 序列，我们已经将它们标记为“正向”或“反向”(我们稍后会用到)。

环路搜索

下一个问题是，你如何在这些长长的氨基酸序列中找到两个环区？答案是每个亲和分子(从进入噬菌体的起始 DNA 开始)都编码了特定的短序列，就像环的路标一样。在两个循环的每一个之前和之后有一个，即总共 4 个。让我们在数据帧中定义这些“环垫”,

loop_pads = data.frame(type = ‘demo’,
                       l2_before =’KTQVLA’,
                       l2_after = ‘STNYYI’,
                       l4_before = ‘KVFNGP’,
                       l4_after = ‘ADRVLT’)

loop_pads## type l2_before l2_after l4_before l4_after
## 1 demo KTQVLA STNYYI KVFNGP ADRVLT

(请注意，我将这些称为“演示”，因为我们正在查看演示数据集)。

让我们搜索一下，看看能否找到第一个循环垫。下面我们将搜索模式设置为“循环 2 之前”循环垫，主题为数据帧中的第一个序列。

matchPattern(pattern = loop_pads$l2_before, 
             subject = aa_all$amino_acid_seq[1])## Views on a 51-letter BString subject
## subject: YGKLEAVQYKTQVLANINETYNINESTNYYIKVRAGDNKYMHLKVFNGPFI
## views:
## start end width
## [1] 10 15 6 [KTQVLA]

它找到了，从位置 10 开始，到位置 15 结束。“后循环 2”循环垫呢？

matchPattern(pattern = loop_pads$l2_after, 
             subject = aa_all$amino_acid_seq[1])## Views on a 51-letter BString subject
## subject: YGKLEAVQYKTQVLANINETYNINESTNYYIKVRAGDNKYMHLKVFNGPFI
## views:
## start end width
## [1] 26 31 6 [STNYYI]

又找到了。

我们现在知道“环 2”区域在位置 16(第一个环填充结束后的一个)和位置 25(第二个环填充开始前的一个)之间，

然后很容易提取这个循环，使用 substr 函数并指定开始和结束位置，

substr(aa_all$amino_acid_seq[1], 16, 25)## [1] “NINETYNINE”

如你所见，我们找到了单词“999”。这显然是我们的演示数据的产物，但在真实的数据集中，这将是我们的“环 2”氨基酸序列。

阅读框架

如上所述，DNA 使用三个核苷酸(密码子)来编码氨基酸。其结果是转录可以从第一、第二或第三个核苷酸开始，导致三个所谓的阅读框。至关重要的是，每个阅读框架将导致完全不同的氨基酸被翻译。

起始密码子，或告诉 RNA 聚合酶从哪里开始的密码子，决定了从哪个密码子开始，导致了所谓的开放框架，或导致翻译成氨基酸和蛋白质的阅读框架。有时，插入或缺失会导致所谓的“移码突变”，这是许多严重疾病的原因。

在我们的数据中，重要的是确定哪个阅读框编码所需的亲和蛋白序列。让我们来看看实际情况。首先，我们将创建一个随机的 DNA 序列，

dna_eg = DNAString(‘TGATATACGGATCGATGCATTCAGGACGCTCTGCTGGATAAGAACACCCTGTGGAAAACCATGTACTACCTGACC’)dna_eg## 75-letter DNAString object
## seq: TGATATACGGATCGATGCATTCAGGACGCTCTGCTGGATAAGAACACCCTGTGGAAAACCATGTACTACCTGACC

接下来，我们会像之前一样把它翻译成氨基酸，

aa_eg_frame1 = translate(dna_eg) *#Translate, frame 1*
aa_eg_frame1## 25-letter AAString object
## seq: *YTDRCIQDALLDKNTLWKTMYYLT

我们从 75 个字母的 DNA 序列到 25 个字母的 AA 序列(如预期的那样)。现在，假设我们的循环垫是序列“ENHV”。下面我们将在我们的 AA 序列中搜索它，

matchPattern(pattern = ‘ENHV’, 
             subject = as.character(aa_eg_frame1))## Views on a 25-letter BString subject
## subject: *YTDRCIQDALLDKNTLWKTMYYLT
## views: NONE

什么也没找到。接下来，让我们去掉第一个核苷酸，重新翻译，

*#trim first base from sequence* aa_eg_frame2 <- DNAStringSet(dna_eg, start=2)*#Translate, frame 1* aa_eg_frame2 = translate(aa_eg_frame2)## Warning in .Call2(“DNAStringSet_translate”, x, skip_code,
## dna_codes[codon_alphabet], : last 2 bases were ignoredaa_eg_frame2## AAStringSet object of length 1:
## width seq
## [1] 24 DIRIDAFRTLCWIRTPCGKPCTT*

我们现在得到了一个完全不同的氨基酸序列。注意，translate 函数也给了我们一个警告，指出最后两个碱基被忽略了。这是有意义的，因为我们在开始时去掉了一个碱基，不再有 3 的倍数的 DNA 序列长度。接下来我们将再次搜索，

matchPattern(pattern = ‘ENHV’, 
             subject = as.character(aa_eg_frame2))## Views on a 24-letter BString subject
## subject: DIRIDAFRTLCWIRTPCGKPCTT*
## views: NONE

还是一无所获。最后，我们会去掉最初的两个碱基，然后重做所有的东西，

*#trim first base from sequence* aa_eg_frame3 <- DNAStringSet(dna_eg, start=3)*#Translate, frame 
1*aa_eg_frame3 = translate(aa_eg_frame3)## Warning in .Call2(“DNAStringSet_translate”, x, skip_code,
## dna_codes[codon_alphabet], : last base was ignoredaa_eg_frame3## AAStringSet object of length 1:
## width seq
## [1] 24 IYGSMHSGRSAG*EHPVENHVLPD

现在我们看到一个关于单个拖尾基座的警告。最后，我们再次搜索，

matchPattern(pattern = ‘ENHV’, 
             subject = as.character(aa_eg_frame3))## Views on a 24-letter BString subject
## subject: IYGSMHSGRSAG*EHPVENHVLPD
## views:
## start end width
## [1] 18 21 4 [ENHV]

这一次序列找到了。换句话说，亲和分子序列在第三个阅读框中编码。这突出了一个事实，即当从 DNA 序列开始搜索氨基酸序列时，阅读框架是绝对关键的。

摘要

在这篇文章中，我们进一步分析了基本数据，寻找循环，并看到了使用正确阅读框架的重要性。在第三篇也是最后一篇文章中，我们将看到“独特的分子标识符”如何帮助消除 NGS 读数错误，Affimer 环频率如何在几轮“摇摄”中发生变化，并以 Affimer 蛋白质应用为结尾。

亲和蛋白质:下一代测序数据分析(第三部分)

原文：https://towardsdatascience.com/affimer-proteins-next-generation-sequencing-data-analysis-part-3-90b4304413b5?source=collection_archive---------33-----------------------

在 Unsplash 上由路易斯·里德拍摄的照片

亲和蛋白质类

独特的分子标识符和亲和结合物的淘选

在第 2 部分中，我们进一步进行了基本数据分析，寻找循环，并看到了使用正确阅读框架的重要性。在第三篇也是最后一篇文章中，我们将看到“独特的分子标识符”如何帮助消除 NGS 读数错误，Affimer 环频率如何在几轮“平移”中变化，并以 Affimer 蛋白质应用为例进行总结。

独特的分子标识符

独特的分子标识符 或 UMIs，是“分子条形码”(短 DNA 序列)，用于从几个不同序列的混合物中识别序列。这个想法很简单。首先，用 UMI 标记你的开始序列。接下来，让这些 umi 通过 DNA 扩增的各个阶段。最后，在您的数据中，搜索这些条形码，以便将序列“家族”分组在一起。

乍一看，这似乎是浪费时间。当你可以只寻找序列本身时，为什么要搜索 UMI 来识别一个序列呢？原因是 NGS 的阅读过程并不完美，而且在阅读过程中可能会引入错误。因为 umi 相对较短，所以不太容易出现这些错误。然后，通过识别相同序列的组，然后可以比较这些序列，并通过在每个位置寻找最常见的核苷酸来确定所谓的共有序列。这就减少了读取阶段引入的误差。下图给出了一个概览，显示了共享 UMI 序列的结果序列家族，

图像参考

NGS 的工作方式是首先将感兴趣的 DNA 序列片段化，在每个片段的末端连接两种不同的分子结合剂，然后将这些片段的一端连接到一个表面(流动池)。 聚合酶链式反应 (PCR)扩增步骤接着进行，导致表面上每个片段的许多拷贝，包括原始(正向)和反向拷贝。最后，将荧光标记的单个核苷酸添加到流动池中，然后结合，从而可以成像和读取。在标准 DNA 应用中，然后将片段读数与参考序列进行比较，并用适当的算法对任何重叠区域进行比对。诚然，这是对一个复杂过程的非常基本的描述。要了解更多信息，请参见此链接。

在这个 NGS 过程中，既有 PCR 错误，也有读取错误。读取错误是由成像系统不能完美地分辨和区分不同核苷酸的不同颜色引起的。如上所述，这就是 UMIs 可以提供帮助的地方。

umi 是用称为 IUPAC(国际纯粹与应用化学联合会)的模糊代码来描述的。这些编码或者指定一个特定的核苷酸，或者选择一个核苷酸。我们可以通过调用下面的函数看到这些，

IUPAC_CODE_MAP## A C G T M R W S Y K V 
## “A” “C” “G” “T” “AC” “AG” “AT” “CG” “CT” “GT” “ACG” 
## H D B N 
## “ACT” “AGT” “CGT” “ACGT”

这里你可以看到‘A’代表‘A’，但是像‘Y’这样的字符可以表示‘C’或者‘T’。重点是允许不同的序列存在于一个给定的模糊代码中，但是仍然指定一些顺序给 UMIs。例如，以 IUPAC 模糊度代码‘nnabnnabnnabnnabnnabnnabnab’为例，它是重复 6 次的子序列‘NNAB’。通过在那里有‘N’字符，你给了许多可能的 umi 自由，但同时，你限制了相同类型的相邻核苷酸的数量。像“NNAB”这样的重复核苷酸的最高数量是 3，即“AAAB”(其中“B”可以是“C”、“G”或“T”)。至关重要的是，这减少了 UMIs 本身潜在的读取错误。

让我们创建一个示例序列，我们称之为“seq”和两个可能的 UMI(其中第二个 UMI 与第一个相同，但在开头多了一个“A”)，

seq = “AATGTAGACAGGGATCAAGTTACTACGGATCGATGCATTCAGGACGCTCTGCTGGAATTCGTTCGTGTTGTTAAAGCGAAAGAACA”umi1 = “NABNNABNNABNNABNNABNNABN”
umi2 = “ANABNNABNNABNNABNNABNNABN”

只要我们提供参数‘fixed = False’(即序列不固定)，matchPattern 函数就可以处理 IUPAC 模糊代码，

matchPattern(pattern = umi1, 
             subject = DNAString(seq), 
             fixed = False)## Views on a 86-letter DNAString subject
## subject: AATGTAGACAGGGATCAAGTTACTACGGATCGAT…TGGAATTCGTTCGTGTTGTTAAAGCGAAAGAACA
## views:
## start end width
## [1] 1 24 24 [AATGTAGACAGGGATCAAGTTACT]

在这里，我们已经找到了示例序列中的第一个 UMI，它从位置 1 开始，正如预期的那样。

现在想象你已经测序了许多序列，包括连接到这两个不同 umi 的序列。下面是开头附有 UMIs 的 13 个序列的例子，

sequences = c(“AATGTAGACAGGGATCAAGTTACTACGGAT”,
              “AATGTAGACAGGGATCAAGTTACTACGGCT”,
              “AATGTAGACAGGGATCAAGTTACTACGGAT”,
              “AATGTAGACAGGGATCAAGTTACTACGGAT”,
              “AATGTAGACAGGGATCAAGTTACTACGGAT”,
              “AATGTAGACAGGGATCAAGTTACTACGGAT”,
              “AATGTAGACAGGGATCAAGTTACTACGGAT”,
              “AATGTAGACAGGGATCAAGTTACTACGGCT”,
              “AATGTAGACAGGGATCAAGTTACTACGGAT”,
              “AATGTAGACAGGGATCAAGTTACTACGGAT”,
              “AAATGTAGACAGGGATCAAGTTACTACGGAT”,
              “AAATGTAGACAGGGATCAAGTTACTACGGAT”,
              “AAATGTAGACAGGGATCAAGTTACTACGGTT”)

下面是一个简单的 for 循环，它遍历这个序列向量，对于每一个序列，它检查哪个 UMI 序列匹配。这个循环只针对 2 个 umi，但是扩展它并不困难。基本概念是检查哪个 UMI 在序列的最开始，

umi = vector()

for(s in sequences) { *#Extracting the start position of umi1,* umi1_start = start(matchPattern(pattern = umi1, 
                    subject = DNAString(s), 
                    fixed = False)) *#Extracting the start position of umi2*
 umi2_start = start(matchPattern(pattern = umi2, 
                    subject = DNAString(s), 
                    fixed = False)) *#Is UMI1 is at the start or not? If not, it must be UMI2,*
 umi_num = if(umi1_start == 1) {umi_num = 1} else {umi_num = 2} print(paste0(‘UMI number: ‘, umi_num))
 umi = c(umi, umi_num)

}## [1] “UMI number: 1”
## [1] “UMI number: 1”
## [1] “UMI number: 1”
## [1] “UMI number: 1”
## [1] “UMI number: 1”
## [1] “UMI number: 1”
## [1] “UMI number: 1”
## [1] “UMI number: 1”
## [1] “UMI number: 1”
## [1] “UMI number: 1”
## [1] “UMI number: 2”
## [1] “UMI number: 2”
## [1] “UMI number: 2”

我们可以看到，我们有十个使用 UMI 1 的序列和三个使用 UMI 2 的序列。现在让我们把这些序列和 UMI 数放在一个数据帧里，然后把两个不同的 UMI 家族分开，

sequences = data.frame(sequences, umi)
umi_family_1 = sequences$sequences[sequences$umi == 1]
umi_family_2 = sequences$sequences[sequences$umi == 2]

现在我们可以在这些序列上调用一个名为 consensusMatrix 的函数(特别是第一个 UMI 家族)，

consensusMatrix(umi_family_1)## [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13] [,14]
 ## A 10 10 0  0  0  10 0  10 0  10 0   0  0  10
 ## C 0  0  0  0  0  0  0  0  10 0  0   0  0  0
 ## G 0  0  0  10 0  0  10 0  0  0  10  10 10 0
 ## T 0  0  10 0  10 0  0  0  0  0  0   0  0  0## [,15] [,16] [,17] [,18] [,19] [,20] [,21] [,22] [,23] [,24] [,25] [,26] [,27]
 ## A 0  0  10 10 0  0  0  10 0  0  10 0  0
 ## C 0  10 0  0  0  0  0  0  10 0  0  10 0
 ## G 0  0  0  0  10 0  0  0  0  0  0  0  10
 ## T 10 0  0  0  0  10 10 0  0  10 0  0  0## [,28] [,29] [,30]
 ## A 0  8 0
 ## C 0  2 0
 ## G 10 0 0
 ## T 0  0 10

该函数计算了每个位置上每个核苷酸的总数。例如，对于第一个位置，您可以看到有 10 个“A”碱基，没有“C”、“G”或“T”碱基。除了一个职位外，所有职位都有这种共识。你能发现它吗？

我们还可以调用函数来显示概率数据，

consensusMatrix(umi_family_1, 
                as.prob = TRUE)## [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13] [,14]
 ## A 1 1 0 0 0 1 0 1 0 1 0 0 0 1
 ## C 0 0 0 0 0 0 0 0 1 0 0 0 0 0
 ## G 0 0 0 1 0 0 1 0 0 0 1 1 1 0
 ## T 0 0 1 0 1 0 0 0 0 0 0 0 0 0
 ## [,15] [,16] [,17] [,18] [,19] [,20] [,21] [,22] [,23] [,24] [,25] [,26] [,27]
 ## A 0 0 1 1 0 0 0 1 0 0 1 0 0
 ## C 0 1 0 0 0 0 0 0 1 0 0 1 0
 ## G 0 0 0 0 1 0 0 0 0 0 0 0 1
 ## T 1 0 0 0 0 1 1 0 0 1 0 0 0
 ## [,28] [,29] [,30]
 ## A 0 0.8 0
 ## C 0 0.2 0
 ## G 1 0.0 0
 ## T 0 0.0 1

区别在 29 号位。这里，10 个序列中有 8 个在这个位置有一个“A”。在剩下的 2 个单词中，他们有一个 C。我们可以将这 10 个序列合并成一个，使用共识函数，在每个位置使用最常见的碱基，

consensusString(umi_family_1)## [1] “AATGTAGACAGGGATCAAGTTACTACGGAT”

如您所见，我们在倒数第二个位置有一个“A ”,因为它是 10 个序列中最常见的核苷酸。这样，扩增错误或读取错误就被“消除”了。

计数亲和分子

现在我们已经看到了所有单独的片段，让我们将它们放在一起，并计算我们在演示数据中的不同循环组合(循环 2 和 4)。为了简单起见，我们不会担心读取帧或 UMIs。

下面是一个大函数，它接受氨基酸数据帧和循环填充数据帧。然后，它遍历数据帧，搜索所有 4 个循环填充，提取循环，将它们组合成一个新的数据帧，并返回它。阅读函数中的注释，了解它是如何工作的。请注意，下面的代码效率低、速度慢，并且不会在数据集非常大的真实 NGS 环境中使用。然而，以这种方式使用循环有助于理解和演示工作中的一般原则，

*#Function for amino acid sub-sequence matching,*
 match_function = function(data, loop_pad, out_max=1, out_min=0) {

  *#Extract the forward and reverse reads,*
  data1 = data[data$read_direction == ‘F’,]
  data2 = data[data$read_direction == ‘R’,] #remove the read directions as no longer needed,
  data1$read_direction = NULL 
  data2$read_direction = NULL

  *#Create empty loop position columns,*
  data1$Loop2_start = NA_integer_
  data1$Loop2_end = NA_integer_
  data2$Loop4_start = NA_integer_
  data2$Loop4_end = NA_integer_

  *#Iterate through each forward read, search for loop-pads 1 and 2  (either side of loop 2), and if found, extract the start and end  positions,* i=1
  while(i<=length(data1$amino_acid_seq)) {

   matches_l2_left = matchPattern(pattern = loop_pad$l2_before, 
   subject = data1$amino_acid_seq[i], 
   max.mismatch = out_max, 
   min.mismatch = out_min)

   matches_l2_right = matchPattern(pattern = loop_pad$l2_after, 
   subject = data1$amino_acid_seq[i], 
   max.mismatch = out_max, 
   min.mismatch = out_min)

   if(length(matches_l2_left) != 0) {
   data1$Loop2_start[i] = end_pos_l2_left = end(matches_l2_left)+1}      else {data1$Loop2_start[i] = NA}

   if(length(matches_l2_right) != 0) {
   data1$Loop2_end[i] = start(matches_l2_right)-1} else {
   data1$Loop2_end[i] = NA
   }

   i=i+1

 }

 *#Iterate through each reverse read, search for loop-pads 3 and 4 (either side of loop 4), and if found, extract the start and end positions,*
  i=1
  while(i<=length(data2$amino_acid_seq)) {

    matches_l4_left = matchPattern(pattern = loop_pad$l4_before, 
    subject = data2$amino_acid_seq[i], 
    max.mismatch = out_max, 
    min.mismatch = out_min)

    matches_l4_right = matchPattern(pattern = loop_pad$l4_after, 
    subject = data2$amino_acid_seq[i], 
    max.mismatch = out_max, 
    min.mismatch = out_min)

    if(length(matches_l4_left) != 0) {
    data2$Loop4_start[i] = end_pos_l4_left = end(matches_l4_left)+1}    else {data2$Loop4_start[i] = NA}

    if(length(matches_l4_right) != 0) {
    data2$Loop4_end[i] = start(matches_l4_right)-1} else {
    data2$Loop4_end[i] = NA}
    i=i+1

 }

  *#Extract the loop sequences from the full sequences, using the  start and end positions,*
  data1$loop2 = str_sub(data1$amino_acid_seq, 
  start = data1$Loop2_start, end = data1$Loop2_end)

  data2$loop4 = str_sub(data2$amino_acid_seq, 
  start = data2$Loop4_start, end = data2$Loop4_end)

  *#Combine the loops,*
  affimer_binder = paste0(data1$loop2, ‘_’, data2$loop4)
  affimer_binder_df = as.data.frame(affimer_binder)

  *#Return the combined loop data,*
  return(affimer_binder_df)

 }

现在，运行函数，

results_df = match_function(aa_all, loop_pads)

让我们看看前 6 个循环序列，

head(results_df)## affimer_binder
## 1 NINETYNINE_FIFTYNINE
## 2 NINETYNINE_FIFTY
## 3 EIGHTYTHREE_THIRTYFIVE
## 4 TWENTY_FIFTYNINE
## 5 NINETYNINE_THIRTYFIVE
## 6 TWENTY_NINETYSEVEN

这里我们可以看到实际的单词拼写。这只是演示数据的一个有意的方面，这样做是为了对任何循环搜索过程的成功提供一个快速的视觉检查。

最后，我们可以使用 tidyverse R 包中的函数按照亲和蛋白序列进行分组并计数，

*#Group by the Affimer protein loop column and count,*
affimer_families = results_df %>%
group_by(affimer_binder) %>%
tally()

*#Order by this new count column,*
affimer_families = affimer_families[order(affimer_families$n, decreasing = T),]

然后使用 ggplot 作为柱状图绘制它们，

ggplot(data = affimer_families, 
       aes(x=reorder(affimer_binder, X=n), y=n)) +
       geom_bar(stat=”identity”) + 
       coord_flip() + 
       xlab(‘Affimer’) + 
       ylab(‘Count’) + 
       theme_bw()

亲和分子淘选

在实际应用中，通过若干轮“筛选”(或 生物筛选 )来选择一个确定的文件夹。这是噬菌体展示过程重复多次的地方，候选结合物在洗涤步骤后被留下，以被扩增并再次呈现给靶分子。其结果是每一轮中结合候选物的种类稳步减少。

下面我们来看看一些示例演示数据。我们将创建 3 个不同的情节，每个模拟平移一轮，

plot1 <- ggplot(data = affimer_families_p1,         aes(x=reorder(affimer_binder, X=n), y=n)) +
geom_bar(stat=”identity”, fill = ‘blue’) + 
coord_flip() + 
xlab(‘Affimer’) + 
ylab(‘Count’) + 
ylim(0,200) +
ggtitle(‘Panning round 1’) +
theme_bw()

plot2 <- ggplot(data = affimer_families_p2, aes(x=reorder(affimer_binder, X=n), y=n)) +
geom_bar(stat=”identity”, fill = ‘green’) + 
coord_flip() + 
xlab(‘Affimer’) + 
ylab(‘Count’) + 
ylim(0,200) +
ggtitle(‘Panning round 2’) +
theme_bw()

plot3 <- ggplot(data = affimer_families_p3, aes(x=reorder(affimer_binder, X=n), y=n)) +
geom_bar(stat=”identity”, fill = ‘red’) + 
coord_flip() + 
xlab(‘Affimer’) + 
ylab(‘Count’) + 
ylim(0,200) +
ggtitle(‘Panning round 3’) +
theme_bw()

grid.arrange(plot1, plot2, plot3, nrow=3)

如你所见，不同活页夹的频率随着每一轮摇摄而变化，许多变得不那么频繁，少数变得更频繁。这就是如何从庞大的起始库中找到给定目标的最佳候选者。在这个演示示例中，我们将把“999 _ 997”作为我们的主要候选。

最后

我们已经看到大自然如何进化出各种体内机制，为任何遇到的抗原创造出特定的抗体结合物。我们也看到了一个类似的体外过程来创造亲和结合物。这两种方法虽然不完全相同，但都依赖于大量随机 DNA 序列的原理，导致随机氨基酸序列和随后随机变化的蛋白质区域。这些亲和文库从 10^10 潜在序列开始，然后通过淘选筛选出针对特定靶标的最佳结合候选物。

从数据分析的角度来看，挑战基本上是关于“环搜索”，即寻找精确定位可变区位置的氨基酸保守模式(沿途可能有突变)。然后，看到这些区域的变化随着平移的进行而减少。在现实生活的实验中，阅读框架、UMIs、低质量分数和点突变增加了额外的复杂性。

为了说明亲和结合剂有多有效，亲和分子应用的一个很好的例子是最近的 亲和新冠肺炎诊断测试 。这是一个 侧流装置 (LFD)，从鼻腔拭子中提取的样本与缓冲液混合后涂在一张纸条上。液体穿过条带，在那里有一排新冠肺炎病毒结合亲和蛋白在等待。如果病毒存在，亲和分子结合并固定颗粒。检测抗体然后结合，为用户创建一个可视线。这些高度特异性的亲和分子，导致了世界上最敏感的 lfd 之一的开发，是通过上述淘选方法发现的。从开始到结束，仅在 4 周内就找到了最佳粘合剂。

图像参考

亲和蛋白的这种快速发展的能力，加上它们的抗体击败特性，使它们成为大量诊断应用的理想工具。然而，还在继续开发它们的特性用于治疗应用。例如，一种被称为“检查点抑制剂”的抗癌药目前正在开发https://www.genengnews.com/insights/antibody-mimetics/，以及最近《自然》杂志上发表的一篇关于“可药用口袋https://www.nature.com/articles/s41467-021-24316-0”的文章，众所周知，这种药物很难识别。**

无论给定的 Affimer 活页夹的最终应用是什么，总的过程如上所述，提出了一个有趣和独特的数据分析挑战。

进一步阅读

亲和蛋白是多用途和可再生的亲和试剂

Avacta (开发并商业化亲和分子技术的公司)

相似性分析(市场篮子分析)

原文：https://towardsdatascience.com/affinity-analysis-market-basket-analysis-c8e7fcc61a21?source=collection_archive---------2-----------------------

你有没有想过，你们多久一起买一次某些东西？为什么会一起买一些物品？您购买一件商品和另一件商品的可能性有多大？为什么糖放在茶包附近？这几项之间有什么关系吗？背后的主旨是什么？

照片由艾美奖·史密斯在 Unsplash 上拍摄

所有这些问题的答案都是亲和力分析(也可以被称为购物篮分析)。这种分析背后的主要思想是通过识别哪些商品经常一起购买来获得有价值的见解。

关联性分析(或市场购物篮分析)寻找模式来确定购买之间的联系，以便商店可以增加他们的交叉销售潜力。

在我们进入细节之前，我们必须解释一些术语。

照片由布鲁克·卡吉尔在 Unsplash 上拍摄

市场篮子

市场篮子指的是在一个经济系统中通常被购买和出售的一组物品。(查看上图，了解购物篮的基本示例。)

i̇temset

众所周知，项集是由两个或更多项组成的一组项。(多么令人兴奋的信息啊，对吧？😛)

项目集

处理

事务是亲和力分析的主要数据来源。商店或零售商通过记录一段时间内的活动来收集大量交易数据。每个事务都与一个唯一的事务 ID (TID)相关联，并且包含项目集的子集。

一组交易

支持

Support 只是强调一个项集有多受欢迎。尽管支持度很简单，但它是相似性分析中的一个重要度量，用于确定项目之间的关联强度。以 5 笔交易为例。如果你在 3 次交易中购买面包，你可以知道面包的支持度等于 3/5。

支持的定义

信心

虽然支持度强调项目集的受欢迎程度，但置信度表示一起购买某些项目的可能性。例如，购买面包时购买黄油的可能性有多大。信心通常表示为 面包 (包含面包也包含黄油的交易比例。)

信心的定义

正如你在上面看到的，置信度是一个概率，所以它的范围是[0，1]。如果 面包黄油 的置信度等于 1，我们可以说顾客每次购买面包，也购买黄油。

电梯

就像信心一样，生活就像黄油面包。 它说在控制黄油受欢迎程度的同时，购买面包时购买黄油的可能性有多大。

电梯的定义

Lift 的范围是[0，+∞]。当 lift 等于 1 时，面包和黄油是独立的，因此，当购买面包时，不能做出关于黄油的推论。但是，当 lift 大于 1 时，意味着黄油很可能与面包一起购买。

定罪

维基百科上说“确信度可以解释为，如果 X 和 Y 是独立的，那么 X 在没有 Y 的情况下出现的预期频率(也就是说，规则做出不正确预测的频率)除以观察到的不正确预测频率的比值。”定罪的范围为[0，+∞],形式如下:

定罪的定义

简单的例子

所以，让我们看一遍，以确保您清楚地理解这些术语的含义。

第一步:

让我们创建事务数据。

第二步:

让我们定义一个函数。

该功能给出支持、信心、提升和信念的值。(顺便说一下，你可以确定两个以上的参数。)

**frequency_items('bread','butter')**

36%的交易包含面包和黄油。黄油每次都出现在只包含面包的交易中。置信度= 1 表示每当购买面包时，总是购买黄油。最后，lift 的值大于 1，这意味着人们更有可能一起购买面包和黄油，而不是分别购买。

(请记住，我们的数据集非常小。实际上，一个规则需要数百个事务的支持。)

Apriori 算法

Apriori 算法是一种用于识别数据库中频繁项集和相关关联规则的数据挖掘技术。支持度、置信度和提升度是 Apriori 算法的三个主要组成部分。

让我们用一个例子来说明 apriori 算法:

第一步:

  • 在第一步中，我们将在事务中创建一个项目频率表。让我们将最小支持度设置为 2。

  • 正如您所注意到的，所有项目的支持度都大于最小支持度(2)。

第二步:

  • 在这一步中，我们将制作所有可能的物品对。(顺序无关紧要，即{面包，黄油} = {黄油，面包})

  • 同样，我们需要将这些对与最小支持(2)进行比较。

重复前面的步骤:

  • 现在分析 3 个项目集并计算频率，再次应用阈值。(面包，黄油，啤酒)，(面包，黄油，卫生纸)…

正如你所注意到的，算法一遍又一遍地扫描数据库。因此，整体性能降低。

Python 实现

我将使用杂货市场购物篮数据集。( Kaggle 链接)

  1. 正在加载数据。

资料组

2.导入包和数据预处理(关于 mlxtend

数据预处理

3.正在转换为数据帧。

数据帧

4.计算支持。

支持

5.创建规则(度量:置信度) 前因后果

规则

度量:置信度

6.创建规则(公制:升程) 前因后果

公制:提升

7.散点图

散点图帮助我们评估前因和后果之间规则的一般趋势。

结论

在这篇文章中，我们大致了解了什么是相似性分析，以及如何用 python 实现它。

关联性分析或购物篮分析用于从交易数据中提取有价值的见解。它可以用来确定哪些产品要打折。此外，它还可以提高销售额和客户满意度。重要的是要认识到它还可以应用于许多其他领域。

你可以在这里找到 mlxtend 文档。

害怕 Git？让我们打破它。

原文：https://towardsdatascience.com/afraid-of-git-lets-break-it-eaab427c73c0?source=collection_archive---------28-----------------------

你听说过，但现在是时候使用它了。

图片由来自 Unsplash.com的罗曼·辛克维奇拍摄

进入数据科学领域可能是势不可挡的，有些人甚至会说是令人生畏的。你刚刚开始学习 python 和机器学习，就有一个家伙开始告诉你把注意力放在新来的酷小子身上。尽管这个领域非常广阔并且在高速发展，但是有些东西仍然是数据科学家工具箱的一部分。

举个例子，我们有 SQL，而且不管方言(MySQL，PostgreSQL，SQLite，T-SQL，Vertica SQL 等。)，您将在日常工作中的某个时候需要它来提取、清理或理解数据。虽然这种语言已经有 30 多年的历史了，但它仍然很有意义。

如果你在理发店呆的时间够长，你就会去理发——丹泽尔·华盛顿

另一个例子是 Git，这是一个我经常在不同网站上遇到的名字，我诚实地尽力避免它。我还没有准备好使用命令行界面，GitHub 对我来说也不适用。但是就像他们说的，如果你在理发店呆的时间够长，你就会去理发。在这种情况下，理发店就是数据科学领域，Git 就是让你焕然一新的工具。

Git 是什么？

早在 2005 年，软件工程师 Linus Torvalds 引入了 Git，他是 Linux 内核的主要开发者。Git 这个名字是 Global Information Tracker 的首字母缩写，但他也为它提出了其他名字，称这取决于用户的心情。

他把这个系统描述为“愚蠢的内容追踪器”，但更恰当的描述应该是称之为版本控制系统(VCS)。VCS 被开发人员用来在单独或与他人合作编写程序时跟踪变更。

让我们想象一下，上一次你不得不提交一篇重要论文时，你经历了怎样的恐惧。您创建了该文件，并且每隔一段时间都会进行一次复制以确保进度。你甚至可以给自己发一份副本，以防电脑崩溃，并将副本命名为“论文-版本 1”、“论文-版本 2”、“论文-最终”、“论文-真正的最终”，等等。VCS 通过跟踪并允许我们在任何需要的时候在新旧版本之间导航来解决这个令人头疼的问题。我们甚至可以制作“分支”,这可以被认为是实验性的想法，以后可能会也可能不会应用到主工作中(我以后会回到分支上)。

VCS 甚至更进一步，让多个人合作处理同一个文件，并在你的工作和其他人的工作发生冲突时通知你。您将能够准确地看到哪些代码行与您同事的工作相冲突，并选择如何合并更改。

版本控制系统的类型

版本控制系统可以分为两类，要么是集中式的，要么是分布式的。集中的 VCS 在一个服务器上存储了你作品的一个“中心”副本，这意味着你把你的修改提交到这个中心副本上。您的计算机上没有本地副本。这些类型的 VCS 的供应商是 SVN 和 Perforce。另一种 VCS 允许你上传或下载你的作品，在上传到服务器之前可以在本地进行修改。两个常见的分布式版本控制系统是 Git 和 Mercurial。

什么是 GitHub？

介绍了 Git，还需要提一下 GitHub。第一个是 VCS，另一个是在线托管 Git 仓库的网站。换句话说，你想要跟踪或与世界分享的文件都存储在 GitHub 上。你可能已经有了一个帐户，或者你还没有看到它的需要。不管是什么情况，请随意访问我的 GitHub ，点击一下，感受一下 GitHub 个人资料包含的内容。

我的 GitHub 页面

Git 命令

下一步是获得使用 Git 的实践经验。为了让您对这些步骤有所了解，我创建了下面的概述。不要担心术语，当我们需要它的时候，我会检查它。

作者图片

最好的学习方法是通过例子，虽然一切都可以单独用 Git 命令来完成，但我选择依靠命令和 GitHub 页面来提供完整的体验。

此时，您应该首先创建一个 GitHub 帐户，然后将 Git 下载到您的计算机上。对于我的示例，我将使用 Visual Studio 代码(VS 代码)，但是您可以使用任何命令行界面(CLI)运行 Git 命令。

步骤 1 —创建一个存储库(Git init)

我们将经历的第一步是创建一个空文件夹。文件夹被称为 Git 存储库，简称为 repo 。我们将它称为远程回购，因为我们是在线创建的。

作者图片

我们给它一个名字，并选择是公开还是私有。虽然没有必要，但我选择添加一个“自述”文件，用于描述回购的内容。

作者图片

我们可以使用 CLI 通过简单地运行以下命令来实现同样的目的:

git init <REPO-NAME>

该命令在当前目录下创建一个文件夹，见下图。如果需要，以后可以手动添加 README.md 文件。这种回购被称为本地回购，因为它在您的本地计算机上。

作者图片

步骤 2 —克隆存储库(Git 克隆)

使用 git init 命令可能并不总是最佳的，因为远程 repo 中可能已经包含了几个文件。相反，我现在将向您展示如何从远程回购创建本地回购。换句话说，我将制作一个本地副本。

转到“存储库”部分，单击新创建的存储库:

作者图片

远程 repo 已创建，这意味着我现在可以通过单击“添加文件”按钮来创建或上传文件。相反，我选择点击绿色的“代码”按钮，并将下载链接复制到我们的回购。

作者图片

复制完链接后，我现在选择在 VS 代码中打开一个 CLI 并运行 clone 命令:

git clone <REPOSITORY-URL>

作者图片

我的远程回购被克隆到我的当前目录中，为我提供了“my-first-repo”文件夹和 README.md 文件。如果您没有创建 README.md 文件，您会得到警告:您似乎克隆到了一个空的存储库。这很正常，没必要担心。

作者图片

您可以使用“ls”命令列出当前路径中的项目，并使用“cd”将路径更改为克隆的存储库:

作者图片

步骤 3 —创建文件

使用版本控制系统的目的是跟踪变更。因此，我将创建一个 HTML 文件作为示例，但是您也可以创建更适合您的情况的文件。

我将创建一个名为“Intro-to-Git.html”的 HTML 文件，我将让 VS 代码通过简单地键入 html:5 并单击 tab 按钮来插入内容。之后，我只需编辑标题并在正文部分插入一个标题:

作者图片

步骤 4—临时区域(Git 添加)

创建了一个文件后，我现在告诉 Git 跟踪它。我可以选择通过运行以下命令来跟踪特定文件:

git add <FILE-NAME>

或者，我可以通过添加一个“点”来跟踪本地 repo 中的所有文件。点是对当前目录的引用。

git add .

跟踪意味着 Git 将准备好提交(即保存)文件。可以把暂存想象成一个等待区域，在那里您想要保存的文件还没有被保存。他们只是在等待批准，我们将在下一步中这样做。

作者图片

步骤 5—保存更改(Git 提交)

要保存临时区域中的更改，只需运行以下命令:

git commit

可以把它看作是对暂存区文件的认可。该命令告诉 Git 将临时区域中的所有内容保存为一个单元。假设您想要撤消对项目的更改，在这种情况下，您要么撤消所有提交，要么不撤消任何提交。

当您运行 git commit 命令时，您将被要求添加一条消息。可以把它想象成程序中的注释，告知用户创建或更改的目的。通过添加消息，我们可以知道是谁 做了更改，什么做了更改，什么时候做了更改。**

您可以运行上面的命令，这将触发 Git 启动一个文本编辑器，让您编写一条消息。或者，我们可以在命令中添加一个扩展名，以输入单行消息:

**git commit -m "<MESSAGE>"**

作者图片

我可以通过运行以下命令来查看我的提交:

**git show**

该命令在时显示之前提到的谁、什么和(按住 ctrl+z 键退出 git 显示命令):

假设您对同一个 HTML 文件进行了更多的更改，例如更改颜色或添加新的标题，在这种情况下，我们可以通过运行以下命令来简单地合并第 4 步和第 5 步:

*git commit -am "some message in quotes"*

此命令将 HTML 文件放在临时区域中并批准它。

第 6 步—分支

使用 Git 时需要理解的最重要的概念之一是分支。把一个分支想象成你工作的一个特定版本。我们在步骤 1 中创建的远程 repo 是主分支(也称为主分支或原始分支)。当我们创建本地回购时，我们只是复制了主分支。

正如我在下图中所展示的，一个人可以有多个分支，每个矩形代表一个提交。我的任务是创建 HTML 文件，我的团队同事可能会做一些错误修复，而第三个人可能会直接在主分支上工作。

作者图片

让我们看看目前我们正在做哪个分支:

*git branch*

作者图片

我们看到我们只有一个分支，主分支，星号表示我们做的任何事情都会影响主分支。为了简单起见，我将继续直接在主分支上工作(尽管不推荐)。

我可以运行一个 git status 命令来查看主分支的本地副本和 GitHub 上的远程分支之间的差异:

*git status*

作者图片

输出告诉我，我的主分支的本地副本包含 1 个远程主分支中没有的提交。我的分支包含一个 HTML 文件，该文件尚未包含在远程主分支中。

步骤 7 —上传或下载(Git 推/拉)

最后一步是向 GitHub 发布我们的本地提交。换句话说，我希望我的工作在远程回购中得到反映:

*git push*

git push 命令将我的工作推送到远程 repo 的主分支:

作者图片

如果我现在转到 GitHub，查看我们创建的 repo，我会看到我的 HTML 文件:

作者图片

我可以通过重新运行 git status 命令来确认我的本地存储库与远程存储库是一致的:

作者图片

假设远程回购比我的本地回购更新，我可以简单地选择运行 git pull 来获取最新的更改:

*git pull*

合并冲突

与其他团队成员协作时可能出现的一个问题是所谓的合并冲突。当不同的人在不同的位置编辑或更新相同的文件时，就会出现这些类型的冲突。

在运行 git push 或 git pull 命令时，您可能会遇到这种情况。当这种情况发生时，Git 会自动将文件更改为清晰概述冲突的格式。

让我们假设一下，我的同事在远程回购中打开了 Intro-to-Git.html 文件，并更改了标题行。我也因为某些原因选择在本地回购中更改相同的标题行。我们都提交了我们的工作，但是当我运行 git pull 时会发生什么呢？

我收到一条消息，说有冲突:

作者图片

幸运的是，VS 代码向我展示了实际的冲突。我看到我添加了两个感叹号(绿色)，我的同事添加了一些 CSS 颜色样式(蓝色):

作者图片

我可能会通过接受传入的更改，然后简单地添加感叹号来处理冲突。现在我做一个 git 提交和 git 推送:

作者图片

查看远程回购中的文件，我现在应该能够看到更新。

其他有趣的 Git 命令

假设您想要创建自己的分支:

*git checkout -b <NEW-BRANCH-NAME>*

通过运行以下命令在分支之间切换:

*git checkout <BRANCH-NAME>*

通过运行以下命令合并两个分支:

*git merge <OTHER-BRANCH-NAME>*

为了删除本地回购，您需要删除。git”目录，它是在克隆存储库时创建的。这是 Mac 上的一个隐藏文件，但你可以使用“ls -a”命令查看它，然后运行 sudo rm -r 删除它:

作者图片

我希望你像我喜欢写这篇文章一样喜欢它。如果你理解我的代码有任何困难，请留下评论。数据科学社区给了我很多，所以我总是乐于回馈。

请随时在 Linkedin 上与我联系，并在 Medium 上关注我以接收更多文章。

进一步阅读的灵感

*https://cs50.harvard.edu/web/2020/notes/1/ https://github.com/datacamp/courses-introduction-to-git/blob/master/chapter1.md *

技术和数据科学中的年龄歧视

原文：https://towardsdatascience.com/ageism-in-tech-and-data-science-67c7f4c3039d?source=collection_archive---------22-----------------------

了解什么以及如何应对技术职位中的年龄歧视

阿莱西奥·法拉帝在 Unsplash 上拍摄的照片

你经常听到指向年龄歧视的恐怖故事:

“他们不会雇用我，因为我没有没有经验”(太年轻)

“他们不会雇用我，因为我在 T4 太有经验了”(太老了)

“他们雇用了一些更年轻更便宜的人来代替我”(太贵了)

关于这一点有很多已发表的研究(一些列在本文末尾)——都指向一个难以忽视的事实——老年人不受欢迎。

本指南旨在帮助工程师描述一条通用路径。有许多其他的途径可以考虑，但大多数是从工程师到技术主管，到团队经理，希望还有 sr 管理。大多数人还被困在中层管理岗位，无法继续晋升。本文探讨了年龄偏见如何影响旅程中的每个阶段。

对薪酬和职业发展的观察

我在硅谷做了 12 年的工程师，又做了 12 年的华尔街技术专家，最近在 MBB 咨询公司工作，从我的个人观察中收获了很多。在我的职业生涯中，我管理并雇佣了不到 200 人。话虽如此，很多这种观点或轶事却有一定的研究依据[5，6]。

1:对高薪工程师的需求有限

工程师的工资很高，但你很快就碰到了天花板(方公司存在一些例外)。同样重要的是要知道，随着你在曲线上移动，需求会迅速下降——对于大多数团队来说，在金字塔结构中利用人才是很自然的。

工程师的普通工资/需求

2:领导层的薪酬曲线更高

工程师的薪酬主要在高级研究人员级别，由领导层(包括技术主管和经理，一直到首席技术官)支付。这条线突然开始/结束，因为角色在某些层级根本不存在(有人雇佣 Jr CTOs 吗？).

3:高层领导薪酬过高(但一点都不技术！)

我敢肯定，我们都曾开玩笑说，毫无头绪的 Sr 领导者/CTO/CIO 已经几十年没有编码或做任何技术工作了。在许多行业都是如此。他们大规模完成工作的能力使他们与众不同，也使他们获得了巨额收入。

那又怎样？有什么意义？

如果你关心保住你的工作和赚更多的钱，选择你职业发展的时机是关键。一个 28 岁的经理会对他们和他们的决定有极大的偏见，而一个 48 岁的工程师会让人质疑你的能力。经常发生的陷阱是陷入中层管理——不再是技术性的，也没有发展成为一个强有力的领导者。

接下来呈现的是一个帮助提升排名的剧本。不幸的是，即使是这本剧本也显示出年龄歧视，而且是为年轻人设计的！

按季节划分的职业剧本

“时间，时间，时间。看看我变成什么样了。当我四处寻找我的可能性时”——保罗·西蒙/邦格斯，冬日朦胧的阴影

人天生就有偏见。在你职业生涯的每个年龄和阶段，人们会以某种方式看待你。这可能不公平或不正确，但你可以利用它。

四季— 壁纸之旅

春天——构建核心(20 年代)

对年轻人的主要偏见是缺乏经验。年轻和快速学习的积极偏见可以让你进入一个有挑战性的角色(谁不会给一个年轻的有进取心的人一个机会呢？).不要抑制快速提升的冲动，它会伤害你。

“年轻的科技工作者表示，他们也因为年龄而感觉受到了轻视”——IEEE Spectrum[7]

20 岁时的目标:

  • 建立广泛的专业知识作为你 T 形轮廓的基础。
  • 不要被困在一个冗长乏味的项目上——你需要学习和探索。从内部和外部寻找新的角色&练习面试。
  • 如果你不喜欢你正在做的事情，尽快做出改变。找到你热爱的东西，不要害怕改变。

T 型 Doug Foo 基金会

夏天——深入(30 年代)

给人的感觉是，你是一位技术大师，亲力亲为创新者，能快速完成工作。30 岁是科技职业的黄金时期——成为专家和进入领导岗位有很多选择。挑战在于抓住第一批领导机会——但同样不要太快进入管理层。

被分析的 18 家美国大型知名科技公司的员工年龄中位数是 37 岁——Payscale.com[5]

30 岁时的目标:

  • 在你可以利用的领域建立深度。
  • 寻找领导角色。这不一定是对人的管理，但是你应该领导一些东西——代码、过程或人。
  • 顾名思义，领导和管理是一件苦差事，你必须证明你能反复做几次。

扩大丁字裤的深度

秋季——多重影响(40 度)

在你 40 多岁的时候，感觉和期望是你不去管代码，但仍然理解它，更重要的是可以有效地管理客户、团队和项目。衡量你的标准是你是否有能力成为乘数”[2]并为你的公司创造更大的影响。最大的障碍是如何更上一层楼，或者在新的岗位上复制成功。

一项针对 1011 名科技员工的调查显示:“老”科技工作者的定义是“超过 40 岁”。— IEEE 频谱[7]

40 岁时的目标:

  • 寻求高管的赞助。很少有 Sr 角色是完全基于他们自身的价值而产生的——这是一个高度政治化的游戏。
  • 在一个新的维度中成长——这不再是关于技术，而是关于你如何利用技术为你的领域/业务服务。想想那些商业术语，如价值、影响和投资回报率。
  • 随着你的升迁，这是非常政治化的——这是我最喜欢的一句话“朋友来了又走，敌人持续一生”

第三维的 T 形，是的，它是丑陋的，感谢我可怜的艺术性道格福

冬天来了(50 年代)

“超过三分之二的公司认为年龄大是竞争劣势(德勤)…。美国退休人员协会的数据显示，三分之二的 45 岁至 74 岁的人都经历过与年龄相关的歧视。— HBR [3]

对我们大多数人来说，这是最后阶段。此时，你要么是一个正在努力学习 ReactJS 的 58 岁 Java 程序员，要么是一个坐在后面啜饮陈年苏格兰威士忌的高管，因为你遵循了类似的建议，或者只是运气好。

从个人的小 T 到大组织的变化 T

严肃地说，如果你发现自己已经 50 多岁了，还在编码，还没有往上爬，只要你喜欢编码，并且可能擅长编码，这其实是很好的。管理角色通常是操作性很强的——不太技术性，更多的是政治性和公司特定性(例如，你成为了知道该和谁交谈以及在内部特定系统上的专家——而不是最可移植的技能)。

有很多方法可以对抗年龄歧视，但是最好的解决方法是不走在潮流的前面。如果你发现自己已经 50 多岁了，还在担心，好消息是学习比 20 年前便宜多了，也容易多了。YouTube，Udemy，Coursera，麻省理工和斯坦福的免费在线课程可以比以往更快更便宜地教会你一切。

未来

“没有未来。没有过去。你看到了吗？时间是同时的。”曼哈顿博士，阿兰·穆尔的守望者

我发现阿兰·穆尔以这种方式描述时间的同时性是很有趣的，类似于克里斯托弗·诺兰在《星际穿越》中描述的第四维度。认为时间不是线性的是自相矛盾的。在不涉及量子力学和死猫的情况下，让我建议你把时间当作一种珍贵的商品，按照剧本行事，或者为自己制作一本新的剧本。

参考资料:

[1] T 型型材—【https://jchyip.medium.com/why-t-shaped-people-e8706198e437

[2]乘数—https://thewisemangroup.com/books/multipliers/

[3]雇佣年长员工的案例—https://hbr.org/2019/09/the-case-for-hiring-older-workers

[4]求职者的策略—https://HBR . org/2019/08/5-应对面试中年龄歧视的方法

[5]不同年龄组的看法—https://diginomica . com/youth-experience-ageism-tech-industry

[6]年龄歧视偏见被揭穿——https://www . visier . com/clarity/four-common-tech-Ageism-myths-debuked/

[7] IEEE 数据来自 Indeed—https://spectrum . IEEE . org/view-from-the-valley/at-work/tech-careers/does-age-discrimina tion-in-tech-start-at-40

[8]心理学研究—https://www . research gate . net/publication/264261522 _ 老年人与年轻人的认知对比 _ 工人 _ 大 _ 五个方面 _ 主动性 _ 个性 _ 认知 _ 能力 _ 工作 _ 绩效

[9] NPR 谈招聘中的年龄偏见——https://www . NPR . org/2017/03/24/521266749/too-more-over-experience-to-be-employee-some-old-Americans-face-Age-Bias

基于代理的模型可视化

原文：https://towardsdatascience.com/agent-based-model-visualization-cb5648db51f4?source=collection_archive---------13-----------------------

使用 Python 的 Mesa 库和可视化模块中的空间模型对 COVID 的扩展进行建模

作者图片

介绍

在之前的文章中，我提供了一个介绍性的例子(优化超市柜台的数量),说明如何使用 Python 的 Mesa 库运行基于代理的模型。我们跟踪了 KPI 的折线图，例如我们客户的平均队列长度和等待时间，但是我们使用了有限的可视化。

在这篇文章中，我们将通过一个不同的基于代理的建模例子，我们将更多地关注可视化。

来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

基于代理的传播模型

我们将使用受 SIR 模型(易感、感染、康复)启发的模型来模拟 COVID 如何传播。我们有一个 50 x 50 的网格，里面有 250 个细胞和一些在相邻细胞间移动的媒介(人),有可能相互感染。

50 x 50 空网格(图片由作者提供)

我们将通过下面的机制/假设保持简单:

  • 我们有固定数量(可调参数)的代理，这些代理最初被分配给网格中的随机单元。
  • 在整个模拟过程中，这些代理的固定百分比(可调参数)被屏蔽/不被屏蔽。
  • 在每一步，代理人要么留在他/她的单元，要么移动到相邻的单元。
  • 当易感因子与另一个受感染因子在同一单元时，他/她可能会基于在掩蔽和未掩蔽因子之间不同的概率(可调参数)而被感染。
  • 如果一个代理被感染，他/她在一定数量的模拟步骤(可调参数)后恢复并变得免疫。
  • 在一定数量的步骤(可调参数)后，免疫力消失，药剂再次变得敏感。

画面

我们的代理将在网格中用圆圈表示。

易感因素为蓝色，受感染因素为红色，康复和免疫因素为绿色…

如果圆圈(未)填满，表示代理(未)被屏蔽…

作者 GIF

此外，我们将为模型中的所有可调参数添加一个部分。

作者图片

最后，我们将通过折线图动态显示整个模拟过程中易受感染、感染和恢复的代理数量…

作者 GIF

密码

为了服务于我们基于代理的模型和相关的可视化，我们将编写 2 个 python 脚本。

我将第一个脚本命名为 covid_model.py，它具有作为后端逻辑的 Mesa 模型细节。

名为 covid_model_visualization.py 的第二个脚本将从我们的第一个脚本导入模型参数以及代理和 CovidModel 类。然后，它将服务于我们的模型和可视化…

最终输出

我们现在如何我们的基于代理的模型准备好了。

我们可以调整网页上的参数，运行我们的模拟，并可视化代理如何交互以及易感、感染和恢复的代理的数量。

作者 GIF

注意你可以点击“Step”运行模拟的单个步骤，或者你可以调整每秒的帧数，然后点击“Start”以你想要的速度运行模拟。

汇总两两比较(受 ICML 2021 展示的启发)

原文：https://towardsdatascience.com/aggregating-pairwise-comparison-inspired-by-a-demo-at-icml-2021-c6fdc05680e2?source=collection_archive---------33-----------------------

思想和理论

今天我将向你展示如何在众包中执行答案聚合。当多个执行者执行一项人工智能任务时，请求者需要选择正确的响应，也称为聚合结果。

照片由格伦·卡斯滕斯-彼得斯在 Unsplash 拍摄

许多众包任务被设计为只有一个正确答案，因此注释被简化为经过充分研究的分类任务。在分类任务中，我们使用基于潜在标签假设的算法:只有一个正确的响应，算法需要恢复正确的响应。有了 spark-crowd、CEKA 或 Truth Inference 等流行的答案聚合库，就可以用相应的编程语言快速做到这一点。

分类并不是一个放之四海而皆准的方法——毕竟，它假设反应是客观的。但是，如果我们想要评估搜索或推荐质量、个人偏好或其他固有的主观任务呢？可能没有客观的答案，我们不能使用潜在标签假设。我们能做的就是从众学习。此类任务通常被设计为并排任务，也称为成对比较。群体表演者需要从两个选项中选择更吸引人的选项，而不是选择正确的答案。尽管这种方法很简单，但它可以用来处理高度复杂的任务——那些可能需要深入指导和大量设计工作的任务。

幸运的是，有一类特殊的成对聚合模型。其中最著名的被称为布拉德利-特里模型，它在 1952 年发表的一篇文章中首次被提及。从那时起，不同的研究人员和工程师对这个模型做出了贡献。

在本例中，我们将向您展示如何使用 Bradley-Terry 模型及其在 Crowd-Kit 中的变体来聚合成对比较。Crowd-Kit 是一个开源的计算质量控制库，可用于实现各种质量控制方法，如聚合、不确定性、协议等。

我们将演示如何在由陈等人于 2013 年发表的著名数据集上聚合成对比较以进行可读性评估。他们比较了成对的段落，问观众哪一段更难读。每篇文章都附加了一个 12 级可读性等级的基本事实标签。年级越低，课文越简单。这是一个很好的例子，因为我们有原始的众包数据和地面真相标签来评估结果。

我们在演示中使用了 Google Colab，但是任何其他 Python 编程环境都可以很好地工作。安装了 Crowd-Kit 并下载了带注释的数据后，我们就可以开始了。

我们来看看数据。

我们有一对专栏——a 篇和 b 篇——有两个比较的段落。基础事实标签分别是 label_level_a 和 label_level_b。

我们还有一个列 please _ decision _ which _ Passage _ is _ more _ different，它包含以下三个值之一:“A 段更难。”，“B 段比较难。”，或者“我不知道或者不能决定。”，由群众演员提交。

我们需要对数据集进行轻微的重新排列。首先，我们需要为每个回答分配与所选值相匹配的标签(即两个段落中的一个)。其次，我们需要重命名列:_worker_id 变成 performer，passage_a 变成 left，passage_b 变成 right。我们将省略不明确的比较，只保留带有非空标签的行。

现在，让我们仔细看看我们的数据。

我们有一个成对的比较数据集；每个项目是由表演者提交的具有给定标识符的一对段落。我们想按可读性降序排列这些段落。这就是我们使用 Crowd-Kit 执行聚合的原因。

我们从 Crowd-Kit 导入 Bradley-Terry 和 noise Bradley-Terry 类，通过设置迭代次数直接实例化它们，并调用它们的 fit_predict 方法。

我们的 Bradley-Terry 实现使用了边缘化最大化方法。噪声类迭代运行 L-BFGS-B 优化方法来估计参数。这些参数是项目权重以及执行者的偏见和技能。

让我们看看我们得到了什么。

我们对段落对的比较就变成了模型提供的一系列对应权重的段落。根据大众的智慧，权重越高，阅读文章就越困难。

现在，让我们来评估模型预测的质量，并构建一个类似的系列文章，但使用地面真实等级。

我们将使用 NDCG@k 来评估我们的预测，这是一个分级的相关性分数。通过从两个预测序列和一个基础事实序列构建 Pandas 数据框架，我们只需要两个缺失的元素:从我们的权重推断的实际等级和随机排序基线。前者可以使用 Pandas rank 方法轻松获得，而后者可以使用 NumPy 随机数生成器更轻松地生成。

我们现在都准备好了。让我们从 scikit-learn 导入 NDCG 计算函数，并使用它来计算 NDCG@10 值。请记住，当 k 趋于无穷大时，倾向于收敛到 1(【王】等，2013 )，并且由于我们的数据集只有 490 个元素，我们需要坚持使用 k=10 的相对较小的值。请随意尝试。

在计算了我们的三个模型(基线、布拉德利-特里和嘈杂的布拉德利-特里)的 NDCG@10 值后，我们发现随机基线预期显示了最差的性能。相比之下，布拉德利-特里模型显示了更高和相似的分数。然而，在这个数据集上，更简单的模型表现优于更复杂的模型。这意味着您甚至可以使用众包数据来执行模型选择。

作为质量的最后一个指标，让我们看看预测之间的等级相关性，而不局限于前 k 项。我们看到布拉德利-特里模型适度地相互关联，并与地面真相标签相关，即使等级的粒度不同。

假设我们想要导出聚合数据，并在下游应用程序中使用它。我们将汇总结果放入数据框，并保存到 TSV 文件中。

该文件应该出现在“文件”窗格中。如果你打开它，你会看到数据就在那里，还有权重和排名。

现在你已经知道了:我们用几行代码获得了聚合的成对比较，并使用 Crowd-Kit 和常用的 Python 数据科学库进行了模型选择。

使用 K-means 聚类算法聚合 Reddit 评论& RobertaTokenizer

原文：https://towardsdatascience.com/aggregation-of-reddit-comments-using-a-scikit-learn-k-means-clustering-algorithm-b6fa6d451e19?source=collection_archive---------19-----------------------

了解 HuggingFace Roberta Tokenizer 和 TfidfVectorizer 如何帮助准备 K 均值输入

Pop &斑马在 Unsplash 上拍照

在社交媒体平台上对一个帖子的评论是个人观点。很多有着相似情绪的人都会留下相似的评论。然而，他们使用的词语可能会有所不同。有时候两个极性不同的帖子也会产生相同的评论。

并不是 Reddit 上的每一条评论和帖子都值得一读。用户喜欢那些有趣的帖子和评论。

那么，你如何把有趣的评论和一般的评论分开呢？

可以用分类的方法，也可以试试聚类的方法。

分类需要在评论和帖子上标注数据。这种信息很少。因此，我们可以使用无监督聚类算法对相同类型的评论进行分组。

在本文中，我们将尝试对不同 Reddit 子群帖子的评论进行聚类。Scikit-learn K-means 聚类算法将在此过程中提供帮助。TfidfVectorizer 和 HuggingFace Roberta tokenizer 将有助于为 K-means 聚类算法准备输入数据。

该聚类过程分为 3 个部分:

  1. 从 reddit 获取 Subreddit 帖子的评论。
  2. 准备输入文本数据。
  3. 使用 K 均值聚类对评论进行聚类。

让我们从聚类过程的第一部分开始。

第 1 部分:从 reddit 获取 Subreddit 帖子的评论。

我们将使用 5 个子编辑( ，‘r/shower thoughts’，‘r/wall street bets’，‘r/askreddit’，‘r/笑话’，‘r/world news’)来收集数据。我已经将 Reddit API 配置为只选择一周内最热门帖子的评论。热门帖子会吸引大约 100 或 1000 条评论。因此，我将 API 限制为每个子编辑只有一个帖子。

您可以根据需要更改 API 的配置。

您需要按照以下步骤从 Subreddit 帖子中获取评论。

1.安装 praw python 库。使用 pip 安装程序。

2.获取您的 Reddit 帐户的 API 凭据。按照这篇文章中给出的步骤获取凭证信息。

3.运行下面的代码，将 5 个子编辑帖子的所有评论存储在一个 comment_list 变量中。

代码要点。

#1 。该函数将使用凭证来创建与 Reddit API 的连接。

#2 。这个递归函数将获取评论及其回复。

#3 。它将指示 API 只获取每日热门文章。

第 2 部分:准备输入文本数据。

K-means 聚类方法以整数作为输入。因此，我们需要将字符串/文本数据转换为整数。此外，我们不能随意将文本转换成整数。这会给我们一个糟糕的结果。

因此，我们将遵循两种方法 HuggingFace Tokenizer 和矢量化，将字符串/文本数据转换为有意义的数字表示。

您可以通过分析它们的性能和易用性来选择其中一个过程。

矢量化方法

第一步是把一个句子转换成单个的单词。然后，这些字将被编码为整数、浮点或长整型值。这就是所谓的矢量化。

这里，我们遵循 TF-IDF(术语频率—逆文档频率)方法。

词频—统计某个词在文档中的出现次数。

逆文档频率—它将降低最频繁出现的单词的重要性。

总的来说，这种方法将赋予那些出现频率较低的单词更高的值。

让我们实现 TF-IDF 方法。

from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pdtf_idf_vectorizor = TfidfVectorizer(max_features = 20000) #1tf_idf = tf_idf_vectorizor.fit_transform(comment_list) #2tf_idf_array = tf_idf.toarray() #3pd.DataFrame(tf_idf_array,
           columns=tf_idf_vectorizor.get_feature_names()).head() #4

重要的代码点。

#1。我已经给 max_features 赋值 20k 了。您可以使用基于数据选择 max_features 值。

#2。该函数将为每个单词/数字创建向量，并将它们存储在 tf_idf 值中。它是矩阵形式的。

#3。它将把矩阵转换成 numpy 数组。

#4。该功能将显示单词及其矢量形式。

拥抱人脸标记方法

HuggingFace 中的每个模型都有自己的词库。但是，将单词转换成整数的过程几乎是相似的。首先，它会将句子拆分成单独的单词。然后它会在词库里搜索那些单词。如果匹配，则返回匹配单词的令牌。

如果没有匹配，它会一直断词，直到它们匹配词库。

这整个过程在 HuggingFace 中被称为标记化。

让我们实现这个过程。

from transformers import RobertaTokenizer #1roberta_tokenizer=RobertaTokenizer.from_pretrained('roberta-base')#2total_array=np.array([roberta_tokenizer.encode_plus(comment_list[0],
                      add_special_tokens=True,max_length=30,
   pad_to_max_length=True,return_attention_mask=True)[‘input_ids’]])for i in comment_list[1:]:
    new_array=np.array([roberta_tokenizer.encode_plus(i,
                        add_special_tokens=True, #3
                        max_length=30,
                        pad_to_max_length=True,
                        return_attention_mask=True)[‘input_ids’]])
    total_array = np.append(total_array,new_array,axis=0)print(total_array)

代码要点。

#1 。您还可以选择其他模型的标记器，如 BertTokenizer 和 OpenAIGPTTokenizer。

#2。其他选项有 roberta.large、roberta.large.mnli 和 roberta.large.wsc。

#3 。Encode_plus 函数将把文本数据转换成整数数据。

标记化示例:

comment_list[0]‘ Aside from breakups and heartbreak (which is inevitable unless you\’re a hermit) I\’ve never been happier than I\’m now. ‘tokenizer.tokenize(comment_list[0])[‘Aside’, ‘from’, ‘breakup’, ‘##s’, ‘and’, ‘heart’, ‘##break’, ‘(‘, ‘which’, ‘is’, ‘inevitable’, ‘unless’, ‘you’, “‘“, ‘re’, ‘a’, ‘her’, ‘##mit’, ‘)’, ‘I’, “‘“, ‘ve’, ‘never’, ‘been’, ‘happier’, ‘than’, ‘I’, “‘“, ‘m’, ‘now’, ‘.’]

正如你所看到的，心碎这个词不在罗伯塔的单词库中。所以，分为心和断两个字。

第三部分。使用 K 均值聚类对评论进行聚类。

K-means 聚类算法收集数据点，并基于各种相似性将这些数据点聚合在一起。它是一种无监督的机器学习算法。这意味着不需要标记数据。点击这里了解更多关于 K-means 聚类的知识。

让我们实现这个算法。

重要的代码点。

1.5 个帖子的总评论超过两千条。为了简化输出，我只选择了 20 条评论进行聚类。

2.求 n_clusters 的值，可以用肘法和剪影系数。

正如您所观察到的，TfidfVectorizer 和 Tokenizer 创建的集群下的注释是不同的。但是，两种方法的 K-均值聚类的配置是相同的。

由此可以得出结论，k-means 聚类中，标记化过程影响聚类过程。因此，尝试这两种方法，然后选择适合你的方法。

如果默认设置没有产生所需的输出，请尝试不同的设置。访问 Scikit-learn 网站了解更多关于不同设置的信息。

结论

K-means 聚类创建的组将帮助您忽略没有新信息的评论。此外，它还会帮助你发现其他评论之间的关系。

在本文中，我使用 TfidfVectorizer 和 Roberta Tokenizer 来准备输入数据。这两种方法产生的结果是不同的。因此，您可以根据自己的需求选择其中一种方法。

希望这篇文章能帮助你了解 k-means 聚类。

熊猫时间序列数据的聚合

原文：https://towardsdatascience.com/aggregations-on-time-series-data-with-pandas-5c79cc24a449?source=collection_archive---------9-----------------------

Python 熊猫和 SQL 时间聚合和语法解释。

等待一个好时机，波兰 2021。作者照片。

介绍

处理时间序列数据本身通常就是一项挑战。它是一种特殊的数据，数据点在时间上相互依赖。在分析它的时候，你获得洞察力的效率在很大程度上取决于你处理时间维度的能力。

通常，时间序列数据是在很长一段时间内收集的，特别是当它们来自硬件设备或代表金融交易等序列时。此外，即使数据集中没有字段为“空”，如果时间戳没有规则地间隔、移位、丢失或以任何方式不一致，数据仍然可能有问题。

有助于从依赖于时间的数据中获取有用信息的关键技能之一是高效地执行聚合。它不仅允许大大减少数据总量，而且有助于更快地发现有趣的事实。

在本文中，我将介绍几种方法来帮助您进行分析的最流行的 Python 库 Pandas 如何帮助您执行这些聚合，以及当您处理时间时有什么特别之处。除此之外，我还将在 SQL 中放一个等效的语法以供参考。

数据

为了演示，我使用来自 Kaggle 的信用卡交易数据集。然而，为了简单起见，我将重点放在"Amount"列上，并按单个用户对其进行过滤，尽管聚合总是可以扩展以包含更多的标准。关于时间的信息分布在"Year", "Month", "Day"和"Time"列中，所以用一个单独的列来表示它是有意义的。

因为整个数据集重约 2.35 GB，所以让我们使用较小的批次来动态转换数据。

import pandas as pd
import numpy as np
from tqdm import tqdm
from pathlib import Path

SRC = Path("data/credit_card_transactions-ibm_v2.csv")
DST = Path("data/transactions.csv")
USER = 0

def load(filepath=SRC):
    data = pd.read_csv(
        filepath,
        iterator=True,
        chunksize=10000,
        usecols=["Year", "Month", "Day", "Time", "Amount"],
    )

    for df in tqdm(data):
        yield df

def process(df):
    _df = df.query("User == @USER") 
    ts = _df.apply(
        lambda x: f"{x['Year']}{x['Month']:02d}{x['Day']:02d} {x['Time']}",
        axis=1,
    )

    _df["timestmap"] = pd.to_datetime(ts)
    _df["amount"] = df["Amount"].str.strip("$").astype(float)

    return _df.get(["timestamp", "amount"])

def main():
    for i, df in enumerate(load()):
        df = process(df)
        df.to_csv(
            DST,
            mode="a" if i else "w",
            header=not(bool(i)),
            index=False,
        )

if __name__ == "__main__":
    main()

…提供:

| timestamp           |   amount |
|:--------------------|---------:|
| 2002-09-01 06:21:00 |   134.09 |
| 2002-09-01 06:42:00 |    38.48 |
| 2002-09-02 06:22:00 |   120.34 |
| 2002-09-02 17:45:00 |   128.95 |
| 2002-09-03 06:23:00 |   104.71 |

这个框架的“头”给了我们上表。对于单个用户(这里是USER = 0)，我们有将近 20k 个时间戳，以一分钟的分辨率标记 2002 年到 2020 年之间的事务。

感谢第 31 行中的pd.to_datetime,我们转换了从四列串联的数据，并将其存储为以统一数据类型描述时间的np.datetime64变量。

什么是 np.datetime64？

np.datetime64 ( doc )类型是 pythonic】对象的数字版本。它是矢量化的，因此可以快速对整个数组执行操作。同时，该对象识别典型的datetime方法( doc )，这些方法有助于自然地操作这些值。

在熊猫这边，相关的对象是Timestamp、Timedelta和Period(对应DatetimeIndex、TimedeltaIndex和PeriodIndex)，分别描述时间中的瞬间、时移和时间跨度。然而，在本质上，仍然有np.datetime64和类似的np.timedelta64拥有便利的属性。

将与时间相关的值转换成这些对象是任何时间序列分析的最佳起点。它既方便又快捷。

基本重采样

时序聚合的最简单形式是使用聚合函数将值输入到间隔均匀的容器中。它有助于调整分辨率和数据量。

以下代码片段显示了使用两个函数对天数进行重采样的示例:sum 和 count:

SELECT
    sum(amount),
    count(amount),
    DATE(timestamp) AS dt
FROM transactions
GROUP BY dt;

熊猫为我们提供了至少两种方法来达到同样的结果:

# option 1
df["amount"].resample("D").agg(["sum", "count"])# option 2
df["amount"].groupby(pd.Grouper(level=0, freq="D")) \
    .agg(["sum", "count"])

这两种选择是等效的。第一种更简单，它依赖于这样一个事实，即timestamp列已经被设置为 dataframe 的索引，尽管也可以使用可选参数on指向特定的列。第二种方法结合使用了更通用的聚合对象pd.Grouper和.groupby方法。它是高度可定制的，有许多可选参数。这里，我使用的是level而不是key，因为timestamp是一个索引。另外，freq="D"代表天。还有其他的代码，尽管一个类似的 SQL 语句可能更复杂。

几个时间跨度的聚合

假设您想要聚合时间戳的多个部分的数据，比如(year, week)或(month, day-of-week, hour)。由于timestamp属于np.datetime64类型，所以可以使用所谓的.dt访问器来引用它的方法，并将它们用于聚合指令。

在 SQL 中，您应该:

SELECT
    AVG(amount),
    STRFTIME('%Y %W', timestamp) AS yearweek
FROM transactions
GROUP BY yearweek

在熊猫身上有两种方法:

df = df.reset_index()  # if we want `timestamp` to be a column
df["amount"].groupby(by=[
    df["timestamp"].dt.year, 
    df["timestamp"].dt.isocalendar().week
]).mean()

df = df.set_index("timestamp")  # if we want `timestamp` to be index
df["amount"].groupby(by=[
    df.index.year,
    df.index.isocalendar().week,
]).mean()

他们做同样的事情。

|            |   amount |
|:-----------|---------:|
| (2002, 1)  |  40.7375 |
| (2002, 35) |  86.285  |
| (2002, 36) |  82.3733 |
| (2002, 37) |  72.2048 |
| (2002, 38) |  91.8647 |

另外值得一提的是，.groupby方法并不强制使用聚合函数。它所做的只是将帧分割成一系列帧。您可能也想使用单独的“子帧”,并直接对它们执行一些变换。如果是这种情况，只需重复:

for key, group in df.groupby(by=[
        df.index.year,
        df.index.isocalendar().week
    ]):
    pass

这里的key将是一个(year, week)的元组，而group将是一个子帧。

注意

值得一提的是，在不同风格的 SQL 和 Pandas 中，时间窗口的边界可能会有不同的定义。当使用 SQLite 进行比较时，两者给出的结果略有不同。

SQL:

SELECT
    STRFTIME('%Y %W %w', timestamp),
    timestamp
FROM TRANSACTIONS
LIMIT 5;--gives:
| timestamp           | year | week | day |
|:--------------------|-----:|-----:|----:| 
| 2002-09-01 06:21:00 | 2002 | 34   |  0  |                    
| 2002-09-01 06:42:00 | 2002 | 34   |  0  |                    
| 2002-09-02 06:22:00 | 2002 | 35   |  1  |                    
| 2002-09-02 17:45:00 | 2002 | 35   |  1  |                    
| 2002-09-03 06:23:00 | 2002 | 35   |  2  |

熊猫:

df.index.isocalendar().head()# gives:
| timestamp           |   year |   week |   day |
|:--------------------|-------:|-------:|------:|
| 2002-09-01 06:21:00 |   2002 |     35 |     7 |
| 2002-09-01 06:42:00 |   2002 |     35 |     7 |
| 2002-09-02 06:22:00 |   2002 |     36 |     1 |
| 2002-09-02 17:45:00 |   2002 |     36 |     1 |
| 2002-09-03 06:23:00 |   2002 |     36 |     2 |

概念是一样的，只是参照物不一样。

窗口功能

最后一种通常用于时间数据的聚合类型是使用滚动窗口。与按某些特定列的值按行分组相反，这种方法定义了一个行的间隔来选择一个子表，移动窗口，并再次这样做。

让我们来看一个计算连续五行(当前加上过去的四行)的移动平均值的例子。在 SQL 中，语法如下:

SELECT
    timestamp,
    AVG(amount) OVER (
        ORDER BY timestamp
        ROWS BETWEEN 4 PRECEDING AND CURRENT ROW
    ) rolling_avg
FROM transactions;

Pandas 声明了一个简单得多的语法:

# applying mean immediatiely
df["amount"].rolling(5).mean()

# accessing the chunks directly
for chunk in df["amount"].rolling(5):
    pass

同样，在 Pandas 中，可以使用可选参数进行不同的调整。窗口的大小由window属性决定，这在 SQL 中是通过一系列语句实现的(第 5 行)。此外，我们可能希望将窗口居中，使用不同的窗口，例如加权平均，或者执行可选的数据清理。然而，.rolling方法返回的pd.Rolling对象的用法在某种意义上类似于pd.DataFrameGroupBy对象。

结论

在这里，我展示了我在处理时序数据时经常使用的三种类型的聚合。虽然并不是所有包含时间信息的数据都是时间序列，但是对于时间序列来说，将时间信息转换成pd.Timestamp或其他实现 numpy 的np.datetime64对象的类似对象几乎总是有益的。如图所示，它使得跨不同时间属性的聚合变得非常方便、直观和有趣。

最初发表于【https://zerowithdot.com】。

敏捷数据科学:它意味着什么？如何管理数据科学项目

原文：https://towardsdatascience.com/agile-data-science-what-does-it-mean-how-to-manage-data-science-projects-5d3b305833b8?source=collection_archive---------15-----------------------

照片由i̇rfan·西姆萨尔在 Unsplash 上拍摄

这有用吗？

“敏捷数据科学意味着什么？”你可能会问。一个字:敏捷！敏捷是一种被许多行业接受的方法，包括数据科学。是时候让您的数据科学项目变得敏捷，并开始提高效率和降低成本了。这篇博文讨论了什么是敏捷数据科学，它如何帮助你更好地管理你的项目，以及如何在你公司的文化环境中使用它的技巧。

1.什么是敏捷数据科学？

我所说的敏捷数据科学是指敏捷方法可以应用于数据科学项目。对一些人来说，这听起来可能不是什么令人兴奋的事情，但对一些人来说，这可能是一个游戏规则的改变。

敏捷宣言指出:

-“经常交付工作软件”

-“客户协作胜过合同谈判”

-“响应变化，而不是遵循计划”。

这实际上是敏捷数据科学，敏捷数据科学家每天都在做的事情。他们与客户合作，并频繁地交付工作软件…我承认项目类型、期望和参与人员的技能水平各不相同。

这意味着敏捷数据科学关注迭代开发和频繁地交付工作软件或解决方案。这使得敏捷项目更像小型创业公司，而不是传统的瀑布项目，在传统的瀑布项目中，客户只能在项目的最后看到最终结果，这可能需要数年时间。

敏捷数据科学家也不太关心前期的需求收集，因为他们知道需求很可能会改变。相反，他们专注于敏捷数据科学最小可行产品(MVP ),这是满足客户需求的最小可能解决方案，然后根据客户的反馈进行迭代，这使得敏捷数据科学家更像产品经理，而不是传统的软件开发人员或工程师，他们更专注于预先规划工作。

2.面向数据科学家的敏捷项目管理

敏捷数据科学项目管理可以被描述为管理数据科学项目的一种灵活高效的方法。它在过去的十年里变得流行起来，因为许多软件程序员已经意识到，仅仅因为他们能做一些事情并不意味着它应该被做。他们已经了解到，敏捷方法是管理项目和在短时间内开发出高质量产品的伟大工具，尽管资源有限或有严格的截止日期。

敏捷方法也适用于敏捷数据科学项目，因为它允许很大的灵活性，鼓励创造性，同时保持必要的结构以确保及时完成。这种类型的项目管理在新技术不断涌现的环境中特别有用，这可能会使长期规划变得困难。此外，敏捷数据科学需要敏捷项目管理才能很好地工作，因为数据科学项目通常非常复杂，需要大量的创造力。

敏捷方法足够灵活，可以很容易地适应敏捷数据科学，但是这些类型的数据科学项目的特定性质存在一些障碍。例如，敏捷数据科学家通常与敏捷软件开发人员有不同的目标，这使得敏捷数据科学家很难学习如何在敏捷环境中更好地工作。还需要有一个具体的计划，从一个冲刺(或迭代)到下一个。

此外，当敏捷方法没有被很好地应用时，敏捷数据科学家可能会对敏捷过程感到沮丧。尽管我们希望有明确定义的目标，但是敏捷数据科学项目通常处于敏捷环境中，因为目标和路线图没有明确定义。

这并不意味着敏捷方法对敏捷数据科学家没有价值，而是敏捷项目管理需要特别适应这种类型的工作，确保有一个适当的计划和结构，而没有太多的过程开销。这也意味着敏捷数据科学家需要学习敏捷项目管理实践，以便敏捷数据科学项目顺利运行。

最后，敏捷方法和敏捷数据科学分享了许多共同的品质，使它们非常适合彼此:灵活性、创造性和速度，同时保持结构和计划。

3.如何为数据科学规划敏捷项目

在规划敏捷数据科学项目时，第一步是最重要的一步，但无论您使用哪种方法，这都是最重要的一步。你必须清楚地定义业务问题和项目目标。定义您的客户或产品所有者需要解决什么问题，以及您如何使用数据科学技术以敏捷的方式帮助解决这些问题。一旦这样做了，你就有了一个清晰的目标，这对于每个人来说都很容易做到。

一旦明确定义了业务问题和目标，并得到产品所有者或客户的认可，您就可以收集需求并对其进行优先级排序。对于那些不熟悉所有术语的人来说，他们被称为积压。您创建用户故事来获取需求。我假设你的工作场所有管理这个的软件解决方案，但是如果你没有，我发现 JIRA 是管理敏捷项目的优秀工具。

然后你经历迭代——冲刺(每次冲刺 2-3 周)，每日站立，以及每次冲刺后的回顾。你不断重复，直到项目完成。

4.关于如何在公司文化和需求的背景下运行敏捷项目的提示

将敏捷方法应用于数据科学项目，对于正在交付的数据科学团队以及高期望值的客户来说，可能会非常令人沮丧。您可能处于这样一种情况，您无法选择将哪种方法应用于您的项目。所以考虑以下几点。

-保持透明；尽快与所有利益相关者分享信息，即使它还不完善。这有助于每个人跟踪到目前为止做了什么，以及通过提供对决策背后的思维过程的洞察来了解决策是如何做出的。透明度还意味着每个人都知道风险以及如何降低风险。

-保持敏捷会议简短，在冲刺计划和每日 15 分钟站立会议期间，每周一次，大约一小时(对于轮班工作的敏捷团队)。人们需要时间来消化信息、提出问题和给出反馈——不要指望人们在进行敏捷会议时这样做，因为他们会停止关注。

-面对面进行敏捷会议；远程敏捷是可能的，但它很难，并且从长远来看效果不佳(考虑到疫情等因素，远程敏捷可能是分散在不同地点的数据科学团队的一个选项)。

-敏捷项目需要所有团队成员的高度投入，尤其是产品负责人。寻找一个顶尖的产品负责人，他能为你和你的企业说这种语言。从本质上来说，敏捷过程需要通过强大和持续的涉众管理来进行有效的期望管理。数据科学家应该至少每周一次与产品负责人会面。

-团队敏捷比个人敏捷更重要；敏捷项目是关于团队动态和数据科学的，采用敏捷方法的团队需要确保他们有良好的沟通技巧和技术能力。了解您的团队的局限性，并意识到您的数据科学团队能够处理多少敏捷。

我们希望这篇博文能帮助你更多地了解什么是敏捷数据科学，以及它如何对你的团队有益。敏捷数据科学有助于项目管理、提高效率、降低成本，并在竞争激烈的分析领域保持领先。如果你想知道更多，或者对我们在这里讨论的内容有任何疑问，请不要犹豫，在下面留下你的评论！

面向数据科学的敏捷

原文：https://towardsdatascience.com/agile-for-data-science-bb91ad16e9f9?source=collection_archive---------30-----------------------

如何在面向瀑布的领域实践敏捷

开发软件的瀑布方法是一种遵循线性路径的方法，其中每一步在下一步之前完成，如下所示。

彼得·坎普/保罗·史密斯 (CC BY 3.0)

同时，敏捷是一个迭代开发软件的过程，在这个过程中，需求、设计和实现可能会不断地发生变化。这正成为工作的首选方法，因为演示/MVP 交付得更快，而且需求确实变化很大。在敏捷过程中，反馈更容易获得和整合，因为它以更有规律的间隔出现，并且不会在项目结束时对产品造成影响。

机器学习中的瀑布

虽然步骤可能不同，但在机器学习项目中会遵循这一顺序过程。步骤通常是这样的:

  1. 获取数据
  2. 探索性数据分析
  3. 创建特征
  4. 定义模型
  5. 训练模型和调整超参数
  6. 评估模型，并根据需要后退几步
  7. 部署模型

这样做的问题是，一旦我们到达第 6 步，我们就开始回到前面的步骤，并且模型部署得不够快或不够频繁。

这是我看到的描述数据科学敏捷的模式。今天大多数人实践数据科学的方式，下图中来自模型评估的箭头可能会跳过部署，直接指向初始数据探索。

作者图片

我对上图中呈现的过程的另一个问题是，它没有告诉你从哪里开始。我将解释为什么我个人认为您应该从部署开始 ML 模型开发。

版本 0

面对现实吧，有时候获取数据可能是一个漫长的过程。您必须等待客户端、DBA 给您凭证，或者安全人员授权您查看数据，或者其他事情。那么在你等待的时候你能做些什么呢？开发我称之为你的 ML 模型的版本 0(或 v0)。这是一个你在没有任何数据的情况下建立起来的模型，或者是你捏造出来的数据或粗略的数据。这里有两个例子:

  • 预测航班是否会延误的二元分类模型。首先，您的 v0 可以以相等的概率随机返回 yes 或 no。
  • 一种线性回归模型，仅根据房屋的平方英尺来预测其价值。你会随机得出 Beta 值，选择正数，因为在这种情况下这是有意义的(即更多的平方英尺等于更高的价值)。

显然，您不希望将这两种模型部署到生产环境中。但是我认为将这两者中的任何一个部署到开发环境中都是一个好主意，原因如下:

  1. 您的数据科学团队将努力尽快创建一个更好的模型，因为现有的模型显然很糟糕。
  2. 一旦有了更好的模型，您就已经有了部署它的方法，所以这个过程不会花太多时间。
  3. 软件团队的其他成员可以使用这些 v0 模型进行开发，直到更好的东西出现。例如，用户界面可以继续，因为您已经有了一个可以显示结果或给出预期结果的部署模型。

现在去开发一个 v0 模型，并将其部署到您的下一个项目中！

敏捷是口号

原文：https://towardsdatascience.com/agile-is-the-watchword-8b500d8cd0db?source=collection_archive---------45-----------------------

商业科学

提高对数据波动响应能力的 3 种方法

照片由负空间从像素

每个人，包括我自己，都为 2020 年的结束而兴奋不已。新冠肺炎疫情让这一年成为充满挑战的一年，疫苗的到来让我们所有人都希望一切会恢复正常。

然而，几个月后，我们意识到生活恢复正常需要一段时间。意大利刚刚再次进入封锁状态，疫苗的推出继续滞后。在一段时间内，事情很可能是不可预测的。

即便如此，我们将如何定义正常？即使在最好的情况下，人们也仍然不可预测。趋势以惊人的速度来来去去。即使在最可靠的行业，现实也常常无法可靠地符合历史模式。

对于数据科学家来说？所有这些不可预测性=我们的模型更加混乱。准确性是一个短暂的目标，一个经常导致失望的目标。

解决办法？解决影响，而不是准确性。

让机器和数据找到答案的关键？一种快速响应方法 ，可确保错误自我纠正，以提供最佳结果。

策划更具响应性的方法

照片由斯科特·格雷厄姆在 Unsplash 上拍摄

一个有效且反应迅速的方法需要建立一个规范的系统:一个从一开始就依靠反馈运行的系统，而不是以准确性为前提的系统。本质上，指令性人工智能是面向持续学习和发现的。这种学习模式试图有效地实现特定目标，而不是准确地衡量和满足需求。

有什么区别？从表面上看，它们都能带来更好的结果。关键区别在于影响。一个以准确性为目标的系统只是希望与预测和观察到的结果紧密匹配，而一个规范的系统可以采取任何途径来获得期望的影响。

实际上:规范模型可以灵活地适应我们世界固有的不可预测性。

在因果关系中，他们较少受历史数据的限制，这意味着他们可以更快地对新出现的模式做出反应。这种灵活性会带来更好的结果。即使在处理高数据波动性时，模型也可以通过快速迭代进行调整。

但是，敏捷性必须融入到您的整个数据科学方法中，才能提供最佳结果。如果说 敏捷是 的口号，那么有三个领域的敏捷最为重要。

1.敏捷模型

照片由 Lukas 从 Pexels 拍摄

最重要的是实现一个反应更灵敏的系统？敏捷模型。

你的模型反应越快，它就越能适应不断变化的趋势。随着敏捷度的提高，你的回报也会增加。由于世界充满了不确定性，这需要一种新的方法。

通常，数据科学家被告知有效的迭代=更高的准确性。这是个问题。除非我们的模型被设计为针对将会产生最显著影响的改进领域，否则您无法解决核心问题。事实上，你不能越来越有效地解决它！

这就是预测性分析和规定性分析的区别。预测分析告诉你，如果事情继续下去，可能会发生什么；规定性分析向您展示如何更有效地实现预期结果。规定性模型对变化的现实更加敏捷——因此，它们往往有更大的影响力。该领域的专家称之为数据科学的未来。

面对数据波动，规范分析可确保您更有效地实现目标。无论你的预测有多准确，当你的模型敏捷时，你仍然可以最大化你的影响。

2.敏捷开发和项目管理

阿尔瓦罗·雷耶斯在 Unsplash 上拍摄的照片

当然，没有一个模型是简单地“完成”的。从某种程度上来说，迭代是每个数据科学项目所固有的。系统学习得越多，就变得越有效。随着时间的推移，它会自行发展。

作为数据科学家，我们一直积极参与这一过程，开发新功能，完善我们的模型，并提高其效率。为了确保我们提供的是最具响应性的模型，这个过程本身必须是敏捷的。你需要拥抱敏捷开发和项目管理。

敏捷宣言最好地总结了这种方法的价值:

  • 个人与交互 超过流程与工具
  • 工作软件 综合文档
  • 客户协作 合同谈判
  • 响应变化 超过跟随计划

在其核心，敏捷开发本身就是一种规定的方法。我们致力于在完美的软件上实现最佳效果，随着时间的推移不断改进。有了这个框架，您可以更快地交付成果，并快速改进以应对新的需求和障碍。

具体如何选择实现敏捷开发取决于你自己。有许多优秀的框架。一些最常见的包括 Scrum 和看板，几乎所有的组织都根据他们的需求调整这些。Evo 有自己的敏捷开发方法，你可以在 Evo 大学免费了解更多。

敏捷开发和项目管理的关键方面:反馈。像敏捷模型一样，没有有效地将反馈集成到系统中，敏捷开发是不可能的。反馈，无论是正面的还是负面的，都是让你更接近你的目标，并确保最好的结果。

3.敏捷思维

照片由安德里亚斯·克拉森在 Unsplash 拍摄

然而，如果没有敏捷性的最后一个方面，这两者都是不可能的:你的心态。

敏捷思维是敏捷模型和敏捷开发过程的先决条件。如果你不考虑持续学习和适应性的核心价值，你将永远无法在实践中有效地实施这些原则。

一个思维敏捷的人有一个成长的思维；他们不断寻找改进的方法。你必须学会将反馈视为一种内在的好处，一种可以让你更有效地迭代的东西。这意味着你必须对新想法持开放态度，并准备做出改变。

正如 Carole S. Dweck 博士所描述的具有成长心态的人:

  • 拥抱挑战
  • 百折不挠
  • 把努力视为通往成功的道路
  • 从批评中学习
  • 从他人的成功中寻找教训和灵感

具有敏捷思维的人也是如此。

两者都随时准备改进。

让敏捷思维与众不同的是速度。思维敏捷的人不会等着行动。是的，他们用逻辑思考问题，但他们会行动。为了快速学习，他们愿意冒险。他们适应不断变化的环境，而不会觉得自己受到了课程变化的人身攻击。只有这种思维模式才能交付产生更大影响的敏捷模型。

反应越快，回报越大

Josh Appel 在 Unsplash 上拍摄的照片

我们对数据变化的反应越快，影响就越大。这在脸上似乎很明显。然而，在实践中，人们往往不相信这些结果。在供应链中，规定系统通常比传统预测系统的库存效率高出 20-30 %,以更少的库存实现更多的销售。

这样的差异会导致认知失调: 这样戏剧性的差异怎么可能？

归结起来就是敏捷性。快速反应方法不仅仅是更快地得到答案。这是关于面对不可预测性的方法，考虑到我们数据的内在波动性。

我们永远无法实现完美的预测。无论我们多么努力，我们都会失败。我们的尝试只是放大了低效。相反，数据科学家必须解决影响。一个规范的模型— 一个敏捷的模型 —会带来很大的不同。我们无法消除数据波动，但我们可以通过正确的方法将其影响最小化。

PS 我定期写商业科学。推荐后续阅读:

Monthly Business Science in your inbox, new software, and University-level learning:[**Free access**](https://evouser.com/register)Questions? Please reach out on [Linkedin](https://www.linkedin.com/in/fabrizio-fantini/)

使用 dbt 和 BigQuery ML 的敏捷机器学习

原文：https://towardsdatascience.com/agile-machine-learning-with-dbt-and-bigquery-ml-c067431ef7a9?source=collection_archive---------27-----------------------

分析工程

一步一步的教程和样本报告

这篇文章最初发表在给我看数据上，现已修改为 Medium。

在这篇文章中，我将介绍如何让强大的机器学习管道建立并运行起来，而不存在管理基础设施的所有令人头疼的问题。我们将利用 dbt 的编排能力和 BigQuery ML 的易用性，让您在数据仓库上做出预测的速度比说“数据”还快。

dbt 是什么？

如果您在过去的一两年中一直从事数据仓库工作，您可能会注意到围绕一个特定工具的宣传越来越多，这个工具被称为“数据构建工具(dbt)”。dbt 是一个 CLI 工具，用于在数据仓库中运行转换管道、测试和文档。

简而言之，您的转换管道的每个阶段都被称为一个“模型”,并在一个 SQL 文件中定义。

例如，您的订单模型可能依赖于 base_orders 模型和 base_payments 模型。不像使用标准 SQL 那样直接从表中选择，而是用 jinja 模板语言中的 ref 调用替换表名。

间接告诉 dbt 每个步骤如何与其他步骤相关，并允许您运行该转换管道的任何子集，dbt 负责由依赖项定义的执行顺序。

来源: dbt 文件

当然，这并不是你对金贾能做的全部。您拥有整个模板语言的能力，因此可以对 SQL 代码进行抽象，使用循环、条件等生成代码。

您还可以定义数据测试、模式测试和文档，因为 yaml configuration 和 dbt 将为您生成自动化测试和完整的文档网站！

来源: dbt 博客

如果你对 dbt 不熟悉，我强烈推荐阅读 fish town Analytics(dbt 的创造者)的首席执行官的这篇介绍性博客文章。

什么是 Bigquery ML？

BigQuery 是 Google 的无服务器数据仓库产品，是最简单、最用户友好的数据仓库平台之一。

机器学习通常需要专业框架和复杂基础设施的广泛知识，但 BigQuery ML 让您可以使用您已经知道并喜欢的 SQL 在几分钟内在 BigQuery 中已经拥有的数据上构建一个完全可操作的 ML 管道。

截至 2020 年 1 月，Bigquery ML 支持以下机器学习算法:

  • 线性回归:用于使用变量的线性组合进行预测。
  • 逻辑回归:用于分类任务的二元和多类逻辑回归
  • K 均值聚类:一种用于数据分割/聚类的无监督学习技术；例如，识别客户群。
  • Tensorflow: 将 Tensorflow 模型导入 Bigquery ML
  • 矩阵分解:一种推荐算法，可以在使用相似用户的偏好之前，预测一个用户对自己没有交互过的物品的偏好。
  • AutoML Regressor: 使用 Google 的 AutoML Tables 服务创建一个回归模型，有效地尝试多重回归算法并自动调整超参数。
  • AutoML 分类器:使用 Google 的 AutoML 表格服务创建分类模型，有效地尝试多种分类算法并自动调整超参数。
  • Boosted 树分类器:使用 XGBoost 进行分类。
  • 增强树回归器:使用 XGBoost 进行回归。
  • DNN 分类器:创建深度神经网络分类器模型。
  • DNN 回归器:创建深度神经网络回归器模型。
  • ARIMA: 建立基于 ARIMA 的单变量时间序列模型，用于时间序列预测。

如你所见，你有很大程度的灵活性，可以跳过构建一大堆机器学习基础设施，立即投入运行！

手动 BigQuery ML 工作流

为了理解 dbt 在幕后做什么，理解没有 dbt 的普通 BQML 工作流是什么样子是很有价值的。我们将使用流行的泰坦尼克号幸存者数据集，我们希望根据年龄、性别、船票等级等特征来预测某人是否幸存。

如果你想按照这种手册的方式来使用 BigQuery ML，你可以按照我列出的步骤来做，但是，在这篇文章的后面，我将通过一个示例项目来讲述如何使用 dbt 来做这些，所以你可以自由地阅读这一部分！

步骤 1-上传数据集

来自 this gist 的 Titanic 数据集，并使用 Bigquery 控制台将其上传到 BigQuery。如果你在这方面需要一些帮助，请查看的 BigQuery 文档了解详情。

步骤 2 —创建模型

您可以创建一个简单的模型，方法是在选择中包含所有输入要素，并将目标变量命名为“label”。在这里，我只对前 800 名乘客进行培训，因为我要让 91 名乘客在步骤 4 中评估模型性能。

大约 30 秒后，你就有了一个名为“logreg”的经过全面训练的机器学习模型！您可以单击 BQ 控制台中的模型来查看评估指标。

步骤 3 —(可选)查看培训和模型统计数据

如果您感兴趣，您可以获得关于每个训练迭代的信息，比如训练和评估数据丢失、学习率以及其他相关的度量。在控制台中查看它就像单击您的模型并浏览培训选项卡一样简单。

您也可以通过运行以下查询，使用 SQL 语法来完成此操作:

该查询产生特定于模型的训练信息。

ML。培训信息输出

步骤 4 —评估模型

接下来，您可以在您提供的一些数据集上获得模型的性能指标。

ML。评估结果

第五步——预测

现在，通过运行 predict，您可以轻松地将您的模型用于看不见的数据！我将在这里假装有一些“看不见的乘客”数据集，并得到关于他们生存的预测。

Bigquery 将为您提供这两个类的概率以及用于进行预测的特征。

步骤 6 —(可选)解释模型

根据您使用的模型，您还可以从您的模型中获得一些全局可解释性结果。

例如，使用一个增强的树分类器，你可以使用 ML 得到特征重要性。FEATURE_IMPORTANCE ，或者用 logistic 回归，可以用 ML。权重获取模型预测中使用的基础权重。

下面是这个查询返回的输出的一个小例子。

这是制作和使用 BigQuery ML 模型的完整生命周期，但是您不希望每次使用 ML 模型时都手动执行所有这些步骤。您需要的是一种自动化的方式来运行这些步骤，作为生产工作流程的一部分。

这就是 dbt 的用武之地！

将 Bigquery ML 与 dbt 一起使用

在机器学习工作流中，dbt 可以很好地处理各个步骤之间的一些依赖关系。例如，我们必须预处理特征，将数据集分成训练集和测试集，并最终使用模型来预测新的数据点。

在这里，我们可以利用 dbt 的执行引擎以正确的顺序运行这些步骤，甚至可以使用驱动我们分析的相同基础架构来安排模型培训和服务！

您可能已经注意到，我们使用一些特定于 BigQuery ML 的语法来创建我们正在使用的模型。

在 dbt 中，默认情况下，我们只编写查询的 SELECT 部分，它的具体化，无论是作为表、视图还是公共表表达式，都由一个“具体化”配置来处理。

例如，要具体化一个包含数字 1 的表，我们应该写

这将在我们的数据仓库中创建一个名为numbers(SQL 文件的名称)的表。我们可以像实现一个视图一样简单地实现它:

实际上，这只是将执行的 SQL 模板化，以产生类似下面的查询:

我们可以利用相同的概念创建一个自定义具体化来编写创建模型，并传入任何必需的选项。

幸运的是，我们不必从头开始设置我们的自定义物化，因为来自丹麦的 Kristeligt Dagblad 已经整合了一个漂亮的轻量级 dbt 包，名为 dbt_ml ！

你自己试试吧

在我们的 dbt 示例中，我们将使用与上面手动工作流相同的泰坦尼克号乘客存活率数据集。这一次，我们将使用 dbt 和 dbt_ml 包来训练逻辑回归模型。

让我们开始吧。如果您已经设置了 dbt 和 Bigquery，请跳到步骤 3 。

学习任何东西的最好方法是亲自动手，感受 Bigquery ML 和 dbt 组合的强大功能！

→拿到 10 分钟？克隆回购←

1.确保安装了 dbt

由于这是一个 dbt 教程，如果你想尝试一下，你必须安装 dbt。

对于 Mac 用户，推荐的方式是通过自制

brew install dbt

您也可以使用 pip 或从源安装它。

2.确保访问您的 BigQuery 帐户

在我们开始之前，让我们确保您可以访问 BigQuery。任何拥有 Google 帐户的人都可以设置 BigQuery，BigQuery 有一个非常慷慨的免费层，所以不要担心运行这个例子时的任何成本。

  1. 转到big query 控制台——如果你没有谷歌云平台账户，系统会要求你创建一个。
  2. 为本教程创建一个新项目—如果您刚刚创建了一个 BigQuery 帐户，系统会提示您立即创建一个新项目。如果您已经有另一个现有项目，您可以从标题栏的下拉列表中选择它，或者从那里创建一个新项目。
  3. 使用官方说明下载并安装谷歌云 SDK。我们将使用 OAuth 向您的 BigQuery 帐户验证 dbt。
  4. 使用激活应用程序默认帐户
gcloud auth application-default login

将会打开一个浏览器窗口，要求您使用您的 Google 凭据进行身份验证。一旦流程完成，您的 dbt 项目应该可以访问您的 Bigquery 帐户了！

3.设置您的 dbt 执行概要文件

您需要配置 dbt 来指向您的项目。您可以通过将示例项目中的 profile-example.yml 复制到 ~/中来做到这一点。dbt 并将其重命名为 profile.yml 。dbt 的默认配置在提到的路径中查找概要文件，但是您总是可以使用–profiles-dir标志选择一个替代的概要文件路径。

现在，您所要做的就是将项目名称更改为您的项目

4.安装 dbt_ml 包

我们通过将包定义包含在 packages.yml 文件中，将 dbt_ml 包定义为依赖项。

既然我们已经定义了这个包，我们需要通过运行下面的命令来安装它。

dbt deps

5.导入示例数据

我们首先需要将用于训练模型的数据和一些用于预测未知案例的样本数据导入 BigQuery。

您通常会有一些现有的数据要处理，但我已经将 Titanic 数据集作为一个 raw_titanic.csv 种子文件，并在一个 predict_me.csv 种子 csv 文件中包含了一些虚拟的人来预测存活率。

要将数据放入 BigQuery，请运行以下命令

dbt seed

6.特征工程

在这一步中，您可以获取输入数据并对其进行整形，为构建 ML 模型做好准备。在实践中，我会构建一个宏，其中给定一个输入表，输出 SQL 以将输入数据转换为可用的要素。通过这种方式，您可以在训练管道和预测管道中使用相同的宏，并获得可用于调试的有用的具体化。

在这个玩具示例中，我将坚持基本原则，只删除乘客的姓名和机票号码，因为它们的预测价值较低。

7.模特培训

接下来是有趣的部分。这里，我们将定义一个新的 SQL 文件，该文件引用输入特性并具体化一个模型而不是一个表。

我们可以通过设置materialized =‘model’并简单地将我们想要传递的配置传递给 BigQuery ML 定义的模型训练参数来实现这一点。

您可以选择传入一个 post_hook，它将模型定型和特征元数据输出到一个审计表中，以便跟踪模型随时间的变化。审计步骤的输出由您的 dbt_project.yml 中设置的以下变量定义

我们可以在 dbt_project.yml 中设置默认变量

我们的训练模型将使用这些变量将模型审计信息输出到 ml_model_audit.ml_models 数据集。

下面是指定实际 ML 模型训练的 SQL 文件。在这种情况下，我们传递用于训练逻辑回归分类器的配置。我们所要做的就是选择要使用的训练数据，其中目标类在标签列中。

8.做预测

最后，我们可以对种子步骤中作为 predict_me 表导入的看不见的数据点进行预测。我们可以通过使用 dbt_ml.predict() 宏来做到这一点。

这里，为了使看不见的数据与训练的模型兼容，我简单地删除了名称和标签列，以使输入特征与我们训练模型时定义的形状相同。

我们不排除“幸存”一栏，因为它不可用。这就是我们试图预测的。

注意如果我们已经在训练管道中定义了一个宏来进行特征工程，我们将在这里重用它来将数据整理成形。

9.关键时刻——运行您的管道

现在，您已经定义了您的 DAG，并准备运行和持久化它！

这是依赖图的辉煌之处。

为了在数据仓库中实际具体化上面的表，我们仍然需要运行下面的命令。

dbt run

这样做可以运行整个图，但是您可以通过向模型文件添加一个标签(如“training ”)并执行类似于 dbt run -m tag:training 的操作来运行训练

运行之后，您可以在 BigQuery 中看到您的预测输出。

由于我们设置了模型审计 post-hook，我们还将在模型审计表中获得一个条目。在这里，您可以找到您训练的每个模型的训练、特征和模型重量信息。

结论

这就是:在 BigQuery 中训练机器学习模型和运行批量推理的简单而优雅的方法。

在这一点上，我想强调您需要考虑的关键点，以决定您是否希望将此作为您信息渠道中的核心战略。

优点(如果您关心…，请使用)

  1. 超级简单的再培训和利用您现有的分析编排基础架构
  2. 需要管理的基础设施更少
  3. 进入门槛低，上市时间快
  4. 轻松跟踪模型的血统
  5. 简单的版本控制数据科学工作流
  6. 经过良好记录和测试的集中式 ML 特性(这部分取决于您，但是 dbt 为您提供了一个很好的方法)

缺点(如果你在乎…，请避免)

  1. 供应商锁定
  2. 更难做更复杂的特性工程(尽管用 jinja + SQL 可以做很多事情)
  3. 进行许多实验可能会更加昂贵
  4. 不是为实时预测用例设计的

总的来说，我强烈建议你尝试一下，看看它是否适合你。每个人的用例都是不同的，所以一些小实验可能会在很大程度上打开加速机器学习模型生产化的大门，并最终为客户提供价值。

有什么问题或经历想分享吗？留下评论，我们一起来深挖吧！

这篇文章最初发表在给我看数据上，为了与媒体兼容，已经进行了修改。

农学优化与农业可持续性

原文：https://towardsdatascience.com/agronomics-optimization-and-sustainability-in-agriculture-c147bbf67792?source=collection_archive---------28-----------------------

变更数据

分析 1800 万点数据以获得最佳农业实践

(图片由丹·迈耶斯拍摄)

为什么农学优化在农业中很重要？每年有 900 万人死于饥饿，相当于每天 25000 人。这一惊人的统计数据不仅揭示了粮食分配平等的必要性，还揭示了农业中更可持续做法的必要性。

从小农场到大公司，最大限度地利用土地和资源变得越来越重要。由于农学和数据收集，我们开始更多地了解农业实践如何创造更美好的未来。我们如何利用肥料使用、地理数据、土壤数据和产量等数据来更好地了解最佳实践？如果农民可以通过数据分析了解更多关于他的特定地块的信息，那么数据驱动的最佳实践就可以应用于传统农业技术。

约翰迪尔数据集

该数据集来自 John Deere Challenge，是Hackdays Rhein-neck ar 2021黑客马拉松的一部分。我的天才黑客马拉松团队包括团队成员: 卡洛琳·佩雷拉*安德鲁·费斯勒 和 伊莱斯坎·卡雷什 。*

John Deere 的广泛数据集包含 1800 万个数据点，跨越十年的数据收集。在这个数据集中，我们发现了伊利诺伊州俄勒冈州一块土地 10 年来一年中三个部分的相关数据。我们最初关注的是 2019 赛季的最新数据。这包括 4 月份进行的最初的播种，4 月和 6 月进行的产品(肥料)施用，以及 10 月份进行的收获。

该数据集中包含的变量如下:

作物品种、湿重、湿度、日期和时间、海拔、机器、距离、宽度、截面 ID 和产量。

(图片由作者提供)

在上面的地图中，我们使用 GeoPandas python 包绘制出了这块特定田地播种、应用和收获的位置。播种和施肥是在田地的同一区域进行的，而收获只在田地的一部分进行。数据没有揭示为什么部分田地没有收割。这是从分析中得出的第一个结论，不是所有的农业数据都可以用数据本身来解释。在这种情况下，有一些外部因素(无论是数据没有收集到，还是某个特定的领域出现了问题)，只有农民能够提供帮助。

(图片由作者提供)

上图以四分位数显示了产量在田地上的位置。例如，在第一张图中，我们看到最低的四分位数。相对于第三和第四个四分位数，似乎更集中在油田的北部，而第三和第四个四分位数往往更集中在油田的南部。我们可以开始假设这是否与田地不同部分的土壤类型或其他条件有关。

(图片由作者提供)

上图显示了 2019 年申请期间产品的分布位置。第一张地图用红色显示了高使用率，红色喷洒在田地边缘。第二张地图用黄色显示的是低使用率，除了边界，到处都有喷洒。第三张地图显示了氨的施用位置。与之前的地图相比，这很有趣，因为我们可以开始思考肥料是否喷洒以及喷洒的位置，以及与产量的相关性。氮肥是数据集中使用的产品。它们被从气体压缩成液体。它们与土壤中的水反应，然后变成铵的形式。

天气数据

天气数据有助于理解作物在一个季节的表现。下面的第一张图是 2019 年季节与当年天气的关系。这些数据对农民来说非常有用，可以帮助他们预测一年中播种和收获的时间。在这个特殊的季节，我们看到雨季紧随四月的第一次播种，这对农作物非常有利。我们还看到，一场霜冻中断了收成，这可能影响了当年的收成。

第二张图显示了覆盖了所有 10 年收集数据的数据点的天气数据。播种和收获的时间一般不在该地区的霜雪期。

(图片由安德鲁·费斯勒提供)

土壤数据

通过使用美国 Agriculture⁴部的数据，我们能够确定田地的哪些区域由哪些特定的土壤组成。土壤是作物正常生长的主要成分。土壤类型决定了水分和养分流入作物内部和周围的速度。在这种情况下，各种各样的粉质壤土可能会随着时间的推移对养分的浓度以及由于径流等造成的土地形状产生影响..事实上，我们看到在某些区域存在细微的差异，尤其是坡度较高的区域。

(图片由安德鲁·费斯勒拍摄)

绘制数据点

我们开始思考我们可以从数据中学到的具体问题:

播种面积有多大？

每年种植的种子总量是多少？

每英亩种了什么种子？

以英亩计的收获面积是多少？

每年的总收获量是多少？

以磅为单位的收获量是多少？

有了这些数字和图表信息，农民可以快速查看数据，开始了解他的耕作技术的发展趋势。

(图片由卡洛琳·佩雷拉提供)

某一年的天气有问题吗？有植物疾病吗？某个应用产品表现不好吗？数据只是没有被记录下来吗？

农民可以考虑影响他特定田地的所有因素，并通过考虑这些因素开始预测未来几年的产量。

概率预测

(图片由 Ileskhan Kalysh 提供)

这些箱线图分别显示了施用产品类型和播种玉米品种的产量分布。这有助于了解哪种产品类型或玉米品种的产量更高。从第一个箱线图中，我们可以看到，平均而言，NH3 比 PP 高速率和 PP 低速率类型的产量更高。

(图片由 Ileskhan Kalysh 提供)

(图片由 Ileskhan Kalysh 提供)

我们建议用概率预测代替确定性预测，因为它给出了预测不确定性的信息。在农业中，困难的问题是控制不可预测的事物。我们得到的概率范围内的输出以点为单位，这样农民可以更好地计划他的操作。

结论和前进方向

通过使用易读的图表和图形分析数据，小农场将能够得出结论，在未来的季节中解决哪些问题以获得更高的产量。正如我之前提到的，我们最初专注于 2019 赛季，然后将我们的发现应用到其他年份。向前迈进的一种可能性是，更仔细地研究收成远低于播种的特定问题年份。由于这些数据并不能说明其中一些场景的全部情况，因此采访农场管理层以了解这些季节是否存在内部问题以及检查特别干旱季节的天气数据可能会有所帮助。

参考文献

硫酸铵和尿素用作水稻肥料的比较研究。肥料研究* 10、119–133(1986)。https://doi.org/10.1007/BF01074367*

凯尔西·乔达尔、乔里斯·范登博舍、马丁·弗莱施曼、雅各布·乏色曼、詹姆斯·麦克布莱德、杰弗里·杰拉德……弗朗索瓦·勒布朗。(2020 年 7 月 15 日)。geo pandas/geo pandas:v 0 . 8 . 1(v 0 . 8 . 1 版)。芝诺多。http://doi.org/10.5281/zenodo.3946761

*民族，团结。每天饿死 2.5 万。联合国，*https://www . un . org/en/chronicle/article/losing-25000-hunger-every-day。 访问于 2021 年 3 月 4 日。

**网络土壤调查—首页。https://websoilsurvey.sc.egov.usda.gov/App/HomePage.htm.2021 年 3 月 4 日访问。

AI 进步了，但是法律跟得上吗？

原文：https://towardsdatascience.com/ai-advances-but-cat-the-law-keep-up-7d9669ce9a3d?source=collection_archive---------22-----------------------

播客

乔希·费尔菲尔德论规范智能和新兴技术

苹果 | 谷歌 | SPOTIFY | 其他

编者按:这一集是我们关于数据科学和机器学习新兴问题的播客系列的一部分，由 Jeremie Harris 主持。除了主持播客，Jeremie 还帮助运营一家名为sharpes minds的数据科学导师初创公司。

在摩尔定律和一系列相关趋势的推动下，技术在许多领域都在以指数级的速度进步。特别是人工智能的能力一直在以令人眼花缭乱的速度增长，似乎每年都给我们带来新的突破，这在十年前是不可想象的。 GPT-3 、 AlphaFold 和 DALL-E 是在过去 12 个月中开发的——所有这些都是在领先的机器学习模型在过去十年中每年增长 10 倍的背景下开发的。

对许多人来说，这些进步的惊人速度和人工智能等技术的发展速度形成了鲜明的对比。我们的法律系统充斥着过时的法律，政客和监管者似乎总是滑稽地跟在技术曲线的后面。但是，尽管毫无疑问，监管机构在努力跟上快速变化的技术格局方面面临着一场艰苦的战斗，但我今天的嘉宾认为他们有很好的机会做到这一点——只要他们开始以稍微不同的方式思考法律。他叫 Josh Fairfield，是一名法律和技术学者，也是教育技术先驱公司 Rosetta Stone 的前研发总监。乔希咨询了美国政府机构，包括白宫技术办公室和国土安全隐私办公室，并且写了一本书，讲述政策制定者可以用来跟上人工智能等技术的策略。

以下是我在对话中最喜欢的一些观点:

  • 乔希认为，让法律跟上人工智能和其他技术的关键是要认识到法律本身就是一种技术:它是一种原则上可以迭代改进的工具。
  • 乔希强调了语言进化在决定法律自身如何改进方面的重要性。他特别指出，许多法律是用含糊不清或容易解释的术语写成的，所以它的意思会随着我们使用语言的变化而动态变化。出于这个原因，乔希认为，为了让法律保持相关性，我们需要以一种允许其解释更加灵活的方式来编写法律。通过这样做，我们能够让语言的进化直接导致法律的进化。
  • 如果我们成功地创造了可以根据语言的进化更灵活地解释的规律，那么我们就需要专注于加快语言本身进化的速度。这是一个难题，乔希认为解决这个问题的关键之一是鼓励建立更多的多学科政策和监管团队，这将把技术人员、社会科学家和其他非传统参与者纳入进来，并鼓励交叉授粉。
  • 具有更灵活解释的法律可能有助于监管者跟上技术的发展，但这是有代价的。我们这个时代的规范编码在我们对语言的理解和使用中，词语的意义随着时间的推移而变化，以反映占主导地位的社会秩序的信仰。因此，如果我们努力让语言影响我们解释法律的方式，那么我们的社会规范的任何问题都会反映在我们的语言使用中，并有效地导致法律的问题。这里有一个微妙的平衡，既要让法律足够灵活以跟踪技术进步，又要让它们足够强大以适应社会的突发奇想，从而避免对社会上可能不受欢迎的群体不公平。

你可以在推特上关注乔希，或者在推特上关注我

播客中引用的链接:

  • 乔希的关于失控技术的书在这里。

章节:

  • 0:00 介绍
  • 2:21 乔希的背景
  • 立法的速度
  • 8:30 法律作为技术
  • 10:06 技术进步指数曲线
  • 14:20 从事法律工作的人
  • 24:26 发展语言
  • 35:28 语言与 ML 理论
  • 43:45 补偿
  • 56:52 总结

请查看下面的文字记录:

Jeremie (00:00):
大家好。我是杰里米。欢迎回到迈向数据科学播客。今天的这一集会有点不寻常。我们正在与一位法律专家交谈，特别是在法律跟踪技术发展方面。因此，人工智能的发展速度比以往任何时候都要快。似乎每隔几个月，我们就会听到另一个 GPT-3 或另一个穆泽罗或其他真正动摇生态系统并大幅提高 iTech 能力的东西。这就引出了一个严重的问题，即政府是否能够跟上这项技术的发展，或者法律、法规和政策是否能够跟上这项技术的能力。

Jeremie (00:40):
所以今天我要和 Josh Fairfield 谈谈，他是回答这个问题的世界顶尖专家之一。乔希是法学教授。他还是一名前科技企业家。他在罗塞塔·斯通公司工作，这是一家非常大的教育技术公司。他做了很多咨询工作，包括在白宫技术办公室和国土安全隐私办公室。所以他真的沉浸在监管环境中。思考法律如何才能跟上技术才是他的本职工作。所以，对这次谈话非常兴奋。我认为这是人们谈论得不够多的事情。我认为这是像我这样的数据科学家和许多听众需要更多考虑的事情，特别是当我们的技术开始能够做更多的事情并对世界产生更大的影响。就这样，我将结束这个介绍，离开这里。我希望你喜欢这次谈话。乔希，非常感谢你参加我的播客。

乔希·费尔菲尔德(01:30):
嘿，非常感谢你邀请我，杰里米。

耶雷米(01:32):
我真的对这次谈话感到很兴奋，因为对本期播客来说，这是一次不同寻常的谈话。我们通常谈论更多的技术味道的东西。我们谈论未来主义。我们谈论人工智能的未来，人类的权衡，诸如此类的事情。我认为这个故事中不为人知的部分是法律方面的。我们已经谈论了很多关于人工智能的东西。它将改变世界，潜台词是好的，我们所有的机构都将不得不以某种激进的方式改变，但我们还没有谈到这种改变是如何发生的。我对法律进展缓慢有一种成见。我相信你会在这里揭穿很多，但我认为我们今天会谈论很多。在我们深入研究之前。我很想了解一下你的背景。你是如何发现你现在所处的空间的，你如何描述你现在所处的空间？

Josh Fairfield (02:21):
我发现，在过去的 20 年里，我一直是一名科技企业家。所以我们开始发现的公司是罗塞塔石碑公司。它开始教人们如何使用软件说外语。但当我进入法律行业后，我进入了技术领域，并特别关注虚拟社区和在线社区。所以我很早就研究了很多关于网络游戏的东西，比如魔兽世界，虚拟货币。然后慢慢转变成对社区如何随着改变它们的技术而改变的兴趣？因为这不仅仅是一条单行道，技术迫使人类做出改变，而是人类如何使用技术反过来塑造了技术。所以这正是你之前所说的，追踪传统制度的演变，甚至像魔兽世界中忍者抢劫一样简单。

Josh Fairfield (03:18):
这是一种针对技术环境中发生的行为的社会约束。从那时起，我开始注意到这句话，法律跟不上或者制度跟不上技术。环顾四周，很明显，这根本不是真的。技术一出现，人类就知道该如何使用，不该如何使用。所以这并不是说我们对我们所需要的制度的直觉落后了，如果我们对什么是法律的想法出了问题，以至于我们认为法律是尘土飞扬的，是旧书和法典，而不是我们决定如何合作的活语言，来处理未来的问题。这就是吸引我进入这个空间的原因。

耶雷米(04:02):
好的。真的很有趣。我是说，这里已经有太多东西要拿出来了。我会试着选择一个威胁，让自己处于某种控制之下。首先是罗塞塔石碑，如果有人在听这个，如果你可能比我小五岁，你可能没有经历过罗塞塔石碑广告在电视上无处不在的时代。这是一个巨大的产品。所以你离开了这个快速发展和打破常规的世界，开始创业。我是说，这真的是一件快节奏的事情。你在用那个镜头吗？当你看到法律以及它是如何演变的，这是一个采纳其中一些教训的问题，还是有一些质的不同？有没有一些事情是你根本无法让法律像公司一样快速发展的？那些约束看起来像什么？

Josh Fairfield (04:46):
我认为主要的限制因素还是我们对法律的错误理解。所以如果我们认为法律是最终产品。这里有一个很好的表达方式。人们经常认为法律跟不上技术的发展，因为他们指出那些过时的法规不再恰当地管理人类行为。所以那里有法规，在某些城镇，你必须在你的无马马车前面提着一盏灯笼。没有人再遵守这些法律了。它们只是过时了。当人们指着它们说，“哦，这就是为什么法律跟不上技术的例子。”但是想想这个类比。这就像指着 Windows 95，它又一次完全过时了，没人再用它了。然后说，“哦，因为那已经过时了，技术跟不上了。”这不是真的。语言发生的情况是，当我们开始彼此交谈时，我们就发展了语言。

Josh Fairfield (05:40):
例如，在这次对话中，我们将开始研究法律的含义。我已经试图改变人们对法律和语言的看法。人类就是这样适应的。当我们通过改变这样的事情来适应时，我们改变了单词来表示新的东西。我们可以以惊人的速度做到这一点。所以当我在做科技创业的时候，我注意到一件事，然后把它转移到观察社会机构如何跟上。当我从事科技创业的时候，有一件事让我印象深刻，那就是法律并没有落后于科技。通常我们需要做的是请求律师和法官稍等片刻。法律在前面，他们有规则。他们准备出发了。他们知道什么是正确的类比。

Josh Fairfield (06:30):
他们已经准备好进行监管。我们说，让技术成熟，让我们迎头赶上。这个故事你可能也听过。所以现在我们有了两个相互矛盾的故事，一个是法律远远落后于技术，另一个是法律领先于技术，而技术正在努力实现它的最终形式。我举个例子，当加密货币和区块链真正爆发的时候，还不清楚事情会走什么样的道路。我们有货币法。我们有商品法。我们有税收法。我们有记录保存和投票的法律。所有的法律都到位了。这只是一个问题，这种区块链技术采取什么形式。我们需要给它一分钟的休息时间，一旦我们知道人类将如何使用它，那么法律机构就在那里。

Josh Fairfield (07:20):
我想很多关注法律跟不上技术发展的人，看到区块链的法律发展如此之快，都会感到非常惊讶。我们一看到它被用作货币，就实施了《银行保密法》和《洗钱和了解你的客户》要求。一旦技术足够成熟，这种情况就会发生得非常非常快。这就是我在那里学到的，不仅仅是法律落后于技术前沿，有时技术也需要空间，因为我们已经有了法律，无论技术将采取什么形式，我们都知道法律将是什么。我们只是不知道这项技术将会采取什么形式。这两个矛盾的叙述让我想到了法律可以跟上技术的发展，因为法律是技术，是一种社会技术，它可以跟上我们发展任何其他技术的方式。

Josh Fairfield (08:13):
我们通过谈论技术，通过在房间里做科学、做编程的一群人来开发技术。同样，我们通过发展新的词汇和概念来发展法律。这是我们人类的天性。所以一个可以跟上另一个，这是这本书的基本思想。

耶雷米(08:30):
好的。因此，就法律是一种技术而言，你是否会主张用更接近我们管理技术发展的方式来管理法律的发展？举个具体的例子。是的。好吧。所以软件工程师和产品经理之类的，或者是-

Josh Fairfield (08:48):
或者让我们尝试一些类似法律的东西，应该是谦逊的、迭代的、实验性的，而不是说这是最终产品，然后再也不碰它。你要做的是快速开发。你要做快速原型制作。所以你要努力缩短开发周期。所以这不仅仅是工程师的管理结构，而是围绕文化和临时工作的一些想法，以及围绕拥有足够好的解决方案和不断改进的解决方案，而不是“哦，好吧。我们有法律。现在解决了。我们不回去。我们不会再提那个问题了。”我认为，作为律师，我们必须摆脱的一个关键问题是，一旦我们做出了法律决定，我们就不会回头再做一次。

Josh Fairfield (09:40):
幸运的是，我们有一个法律体系，特别是在美国，普通法就是为此而建立的。我们只是忘了怎么做。这是为了新案件带来的新问题而建立的，我们可以随时重新检查我们以前的法律。然后下一个案子就来了，下一个案子就来了。我们可以用它作为快速原型的一种形式来得到迭代的、谦逊的、实验性的法则，更紧密地匹配技术发展。

耶雷米(10:06):
真有意思。首先，我的意思是，感觉这是正确的方向。感觉像这样的事情必须发生，因为随着时间的推移，我们似乎也不可避免地看到这些指数曲线，在某些情况下，技术进步的超级指数曲线，静态法律系统可以以任何方式有意义地监督我们正在进入的这种宇宙的想法似乎并不太容易处理，但是，我认为法律有这种静态感觉的原因之一是可预测性的价值。因此，如果谋杀的合法性或盗窃的合法性或类似的事情不是从十年到十年，或从一个世纪到另一个世纪，而是从一个月到一个月，或一周到一周，这将使起诉人，监管或监管某些方式变得更加困难。你如何看待法律的可预测性在整个框架中的作用？

乔希·费尔菲德(11:01):
当然。好吧。这是一个很好的问题，因为有两种可预测性。停滞状态中有可预测性，但变化中也有可预测性。这本书说的一件事是，我们要做的是重新想象法律，而不是让它成为一个静态的答案系统，把它变成…我们要混合创新的想法，根据法律的需要进行改变，这样它才能跟上步伐。你谈到了指数电流。技术进步是如何成指数增长的。然后我们认为法律进步充其量是线性的，对吗？

耶雷米(11:39):
嗯嗯(肯定)。

Josh Fairfield (11:41):
但是加速度是可以预测的。因此，如果我们能让法律以可预测的方式加速发展，我们就能证明它与时俱进。我会利用这个问题。你说的是几个世纪以来的谋杀，对吗？

耶肋米亚(11:58):
是啊。

Josh Fairfield (11:59):
从某些方面来说，现在我们正在做的事情与可预测性背道而驰。当我们带来一项新技术，而技术专家声称，这是一件如此新的事情，以至于先前的法律无法触及。顺便说一下，这种说法在历史上是错误的。所以 Napster 声称，版权法不能碰我们，错了。虚拟世界的创造者说，应该有一个避开法律的魔法阵。这种欺诈在虚拟世界中很有趣。所以我们可以实施欺诈，而你不能适用法律，不。比特币爱好者说，金融监管机构、FinCEN，他们无法触及我们正在做的事情。又错了。但问题是，声称一项新技术突然颠覆一切是不可预测的。人类以前是如何做到的。我们可以通过识别有效的类比来加速法律的实施。你关于谋杀的观点。为什么我们会在一瞬间认为黑掉某人的心脏起搏器并关掉它就不是谋杀？

乔希·费尔菲尔德(13:08):
哦，这是一项新的技术特性。但是，为什么这种谋杀比用剑、用手枪或任何其他方式的谋杀要少呢？你看到技术的变化，甚至是技术的疯狂变化，并没有改变法律的能力，“哦，是的。这是我们多年来一直在处理的同一桩谋杀案。”在报道新的技术案例时甚至没有流一点汗。如果你谈论这些曲线，指数技术曲线，重点是人类对法律的期望几乎可以遵循一个更对数的路径。所以我用的例子是，之前的时间…计算机变得越来越快，摩尔定律在我们的一生中时断时续，但是它们变得越来越快，而我的孩子仍然对计算机变得越来越慢感到沮丧。

Josh Fairfield (13:58):
我们还没有超越人类对这些系统的期望。因此，在某种程度上，是的，技术变革是迅猛的，但即使我们可以年复一年，年复一年地将电路中的晶体管数量增加一倍，在人类的期望开始成为人类适应新环境的能力之前，我们会被抛在后面。

耶雷米(14:20):
这是否意味着什么样的人需要从事法律工作？因为你所描述的，当我们开始说，黑掉心脏起搏器去杀人和刺伤别人是一样的谋杀。所以，对于普通人来说，这可能更容易绘制，但当你进入越来越抽象的概念时，我的意思是，更进一步说，模拟大脑在计算机硬件上运行，我不知道是什么。我们进入了哲学领域，在这里，感觉就像一个人必须提出，什么是有效的法律指导。相当于给出一个指导，“嘿，这是法律未来的走向。这是我们在这里使用的基本原则。”我们需要看看那些更有哲学思想，更善于交流这种哲学的人吗？这是未来律师必备技能的一部分吗？

乔希·费尔菲尔德(15:07):
嗯，我说，我想是的。我不知道这只是为了律师。所以我们现在已经有了相当好的科学，它表明，对于一个复杂的，创新的，非常规的任务来说，最好的团队是一个具有深刻的认知多样性的团队，他们有不同的心理技能组合，在未来的不同传统中接受训练。所以我们发现给软件开发团队增加一个社会学家。这是一些由谷歌赞助和支持的研究。如果你想要这方面的书，斯科特·佩奇正在研究。他们的意思是，如果你有一个由所有人组成的团队，他们就是你在这个领域中最优秀的人。他们是你最好的软件设计师。

Josh Fairfield (15:50):
假设他们有工具 A、B、C 和 d。如果你组建了一个由该领域非常非常优秀的人组成的团队，他们都有相同的工具 A、B、C 和 d。你通常会更好地增加拥有 E、F、G、H、I 和 j 等工具的人。其他工具可以从不同的方向来实现这一点。所以，当然。我认为哲学和这本书确实有一些科学哲学在里面，试图说明科学现在的问题是，它没有看一看我们为什么做科学，也没有寻求我们为什么做技术的答案。这完全取决于我们如何做技术。因此，我确实认为这是一项需要增加的技能，但我会添加到这个堆栈中。

Josh Fairfield (16:34):
还有很多很多其他的技能需要加入其中。而当你问，要不要换一种做法律的人？答案是绝对的，因为不应该是人，应该是人。关键的一点是，我们没有开发出单独处理未来问题所需的语言。我们在这样的对话中发展它。在我们之间的对话中，你用词，你从一个方向用一种方式，我从另一个方向用另一种方式。在我们之间，我们建立了一种语言，这种语言能让我们到达某个地方。所以在这一点上，是的，当然。这些是我们需要增加的技能，但它们不仅仅是律师的技能，而是他们所有人的技能，以建立能够为这些非常规的复杂新任务创新的团队。

耶雷米(17:18):
你认为有必要建立新的基础设施来实现这一目标吗？新的组织，新的方式，从本质上支持围绕人工智能，围绕新兴技术的法律语言的加速？

乔希·费尔菲德(17:31):
是的。在某种意义上说，在我们的法律、技术、社会结构中有许多不同的地方，我们聚集了这些团队，但我们并不真正用一个名字来称呼他们。因此，一个可能是软件开发团队，可能有这些类型的球员。当然，我们可能会有来自更远地方的人[听不清 00:17:53]。你可能会有一个社会学家，你可能会有一个伦理学家，他们可能会加入这个团队。在我的领域，我们不称之为开发团队，我们称之为陪审团。你添加了一群对生活有不同看法和不同看法的人。你要求他们讲法律，也就是说，在这种情况下，根据这种法律，这个人有罪还是无罪，或者这个人在民事诉讼中负有责任，或者在民事诉讼中不负责任？

Josh Fairfield (18:18):
我们在一些地方进行检测，你可以在学术界称之为检测，也可以在圆桌会议或会议上称之为检测。其中一些真的很有效。我们有一群能够彼此交谈的人，他们中的一群…然后它可能会工作得非常糟糕，舞台上的圣人模型，其中一个人站起来宣布。其他人都说，“是的。我在听你说。”但是并没有真正的信息交流。所以我在书中称之为花园，因为它们应该生长我们需要的语言。我有一些特征，那些花园需要有一些结构特征。因此，我们可以真正受益于人们带来的不同专业知识。

乔希·费尔菲尔德(18:57):
但我想指出的是，这些花园实际上存在于各种不同的学科中。然后你要做什么？将陪审团与软件开发团队合并？我的意思是，也许吧，但至少我们在朝着正确的方向思考，我们如何将不同类型的团队与拥有不同技能的人融合在一起，这样我们就能以一种更加稳健的方式来思考这个问题。

耶雷米(19:17):
你提到，通过对过去的法律，过去关于某个特定主题的判例进行哲学思考，可以部分解决速度问题。就像你提到的，这对区块链这样的国家很有效，因为你总是可以进行类比，说，嘿，真正的加密货币是普通货币，或者像证券一样，或者像什么东西一样，这是阶段-

乔希·费尔菲德(19:37):
这就像一些东西，是的。

耶雷米(19:39):
是啊。好像是什么东西。

乔希·费尔菲德(19:40):
那句话就像。不，但是你看，就像法律规定的那样。喜欢某样东西就是方法。是啊。绝对的。

耶雷米(19:46):
这是我要回答的一个问题，比如说，它是一个光谱，但不太像的东西。所以，有了你…比方说，有一个阶跃函数的突破。我们已经看到了其中的一些，例如，在机器学习中，最近 OpenAI 推出了 GPT-3，突然间我们从本质上赞美自动完成的人工智能发展到可以写连贯的多段文章的人工智能。可以做网页设计，可以做这做那。所以有一种感觉，很多这种技术没有商业可行性。然后突然之间，或者更进一步，20 年、30 年、100 年后，人类水平的人工智能或类似的东西出现了。

耶雷米(20:29):
这似乎开始挑战许多核心假设，甚至是谁是社会的参与成员？什么算一个人？是的，我想我只是想知道，你认为这些仍然符合相同的范式吗？只有一种方法能让我们解决这个问题？和-

乔希·费尔菲尔德(20:45):
嗯，我想是的。尽管我们对此必须非常小心。所以人类总是用它来适应未来的问题，他们创造了…我们作为人类有一个超级。所以这个星球上有三个物种可以比大约 100 人的群体更好地合作。蚂蚁，蜜蜂，奇怪的是还有人类。现在，蚂蚁和蜜蜂通过进化做到了这一点。他们进化出了某些模式。蜜蜂可以指示…它们跳一会儿舞，然后说，那边 15 米处，食物在那边 15 米处。但是对于蜜蜂升级来说。蜜蜂不能决定让我们赶走女王，宣布成立共和国。

乔希·费尔菲尔德(21:27):
人类可以做到。人类创造了这个合作的共和国。那是什么？这只是一个自愿的幻觉。这是我们聚集在一起的东西。所以像金钱、时间、民族国家、法律、边界，这些都是我们头脑中纯粹的东西，我们把它们当作大规模并行的社交软件来运行。我们认定美国或加拿大存在，它确实存在，因为它存在于我们的头脑中，运行在那个系统上。好吧。现在你谈到的是，我们如何处理人工智能中的 10 步智能函数，这些函数会产生不连续性？嗯，这是一个特别重要的问题，因为它造成的不连续性存在于我们的语言中，存在于我们相互交流的能力中。因为到目前为止，我们都是通过使用单词来决定词义的上下文。我们通过使用法律来决定法律的上下文和含义。现在，很多人发现他们听到的单词是通过算法选择或推广的，或者甚至是通过算法写成的。

Josh Fairfield (22:31):
我们现在看到，我们的语言，我们相互交谈的方式正受到这种人机界面的严重影响。通过人类机器语言。所以当我在写一本关于，嘿，我们可以跟上未来的问题。让我们进化我们的语言。我想我们应该说。是的，但是我们实际上是机器，现在作为我们语言的一部分在说话，我们承担着越来越多的角色，这一事实呢？我想我们能处理好。我们只是要把它说出来，并确保我们明白在人工智能的努力背后仍然有人类的动机。如果人工智能正在以人们没有意识到的方式影响人们的思维和说话方式，我们可能需要做很多事情来限制人工智能的使用，但我们也可以从中获得巨大的好处。

Josh Fairfield (23:21):
你会看到我所描述的同样的语言变化。你可以从科学的角度来看。20 年前，当我在法学院的时候，科学是这样发展的，你首先有一个假设，然后构建你的实验，然后测试它。一点也不。这里有一堆数据。让我把它输入一个神经网络，看看会有什么有趣的东西被踢出去。所以，当我经历这些的时候，数据驱动几乎是一个诅咒的词，现在科学已经改变了。现在，当我们以这种方式进行科学研究时，机器在暗示我们的假设。所以我们必须意识到这一点。我们必须意识到这在某些方面会让我们付出代价，但这是没有任何回报的。我们唯一能做的是，再次开发谈论它的方式，说是的，它现在是真实的。

Josh Fairfield (24:08):
我们曾经认为图灵测试是一个人坐在机器的对面。人类能看出机器在模仿人类吗？但是现在更多的是，在人类和机器之间的对话中，双方都开始改变他们说话的方式，这种有趣的效果怎么样？

耶雷米(24:26):
你如何看待语言的进化过程，这是实现这一切所必需的？在我看来，如果技术真的开始超过我们语言的适应能力，在某个时候这可能是一个限速步骤。我在这里思考，例如，当人们说这样的话，“哦，我已经度过了这么长的一周，我只需要这个周末重新启动。”就像这样微妙的事情。这告诉你，我们都…

乔希·费尔菲德(24:52):
当然。对吗？

耶雷米(24:52):
是啊。我甚至在从事机器学习、数据科学的人当中看到过，就像人们会说，“是的，你知道吗？我不记得我读过的那篇文章，但我对它进行了降维处理，大概是这样的。”就像，你开始形成那种语言。但这往往在扩散之前发生在口袋里，也许是你所说的答案的一部分，更多地将人们融合在一起。但是你如何加速这些新思想、新语言的传播和扩散，让律师和决策者更快地意识到这些问题呢？

乔希·费尔菲德(25:25):
是的。我的意思是，第一步是要打破一些墙。你在对律师讲话，而律师真正的困难是我们要按照他的话去做。律师们喜欢认为单词有绝对的含义，因为这是他们领薪水的方式。他们写了这个合同，它应该有一个意义，或者他们写了一个法令，它应该有一个意义。尽管这不是真的，但从合同中的用词来看，合同是谈判的主题。有很多种解释。经历过这些的人知道吗？但有一件事是要打破人们的观念，让他们知道他们在泡泡中使用的词语是什么意思。让他们意识到其他人可能会以不同的方式使用这些词。

Josh Fairfield (26:13):
我会给你一个具体的例子来说明技术的发展。所以有一系列的案例，在这些案例中，法官们试图谈论使用技术来查看住宅内部是多么合理。他们会说，“哦，你点击了。我同意与 Alexa 的合同，因此你必须同意 Alexa 监听电话中发生的一切，并将那些简短的录音片段交给警察。”那么在这种情况下，如果法院说，“哦，好吧，这是合理的，”但为什么法院在借鉴其非法合理性的感觉？因为这个人是律师。他们会说，“哦，是的。如果你点击了一份合同，即使你从来没有读过，你也要受其约束。”其他人根本不是这样使用“合理”或“隐私”这个词的。

Josh Fairfield (27:04):
当他们的物联网设备正在收集他们意想不到的信息时，他们感到震惊。所以开拓行业的宝藏，理性作为律师喜欢的关键词。我们将不得不放松对这一点的控制，并说，“不。如果我们要决定警察使用技术侵入住宅是基于合理性作为标准，这种合理性不能是一个法律术语。它必须基于人们对人们在这种技术下的实际反应的实际感受。所以宣传这一点的第一步，这是你的问题，是打破这些不同学科自身的一些外壳。每个人都有自己的壳。计算机科学家也绝对对文字有所了解，因为他们习惯于使用正式语言。经验主义科学家，他们非常想说，“哦，我们只是在做科学。我们没有任何偏见。我们没有任何元叙事来解释为什么我们要做科学，“以一种特定的方式，即使他们经常在一个实验室团队中工作来制造一个产品，这也是有利润的。

Josh Fairfield (28:10):
整个元叙事就在那里。所以我认为每个团体都有自己的外壳，需要被打开。另一件要做的事情是从其他地方引进语言。去寻找答案。仔细听那些和你使用同样词汇的人，这是…你继续[托娅 00:28:33]公主新娘的台词。你一直在用那个词，我认为它的意思不是你想的那样。当你有了那种感觉，你就一直用那个词，我觉得它的意思不是你想的那样。这不是一个脱节的点，好吧，技术专家和律师不能再互相做生意。不，那是进步成为可能的地方，你现在已经意识到，这是我们没有听到对方的地方。我们需要创造桥接术语。

乔希·费尔菲尔德(28:59):
这是我的第三点。因此，打开它们，从其他地方引进，然后创建桥接语言。脚踏两个世界的人非常擅长沟通语言。所以你要寻找那些人，带上翻译。你想知道如何把它从一个地方进口到另一个地方。能让它变得容易理解的人。我的意思是，不仅仅是通俗意义上的理解。律师可以像计算机科学家一样把行话拔出来。但我们谈论的是那些有勇气直言不讳的人，以及那些有能力让别人理解的人。这些人是这些意义世界之间真正的翻译者。

Jeremie (29:38):
因此，翻译变得越来越重要[听不清 00:29:40]，这看起来确实是我们已经看到的事情[听不清 00:29:44]。

乔希·费尔菲德(29:43):
完全正确。

耶雷米(29:44):
是啊。现在，你提到的一件事，这几乎涉及到社会、法律、道德、哲学方面。但是当我们谈论这个合理的概念时，就像我爸爸是个律师，所以他喜欢抨击这个合理的概念，因为他就是你刚才所说的。这就像，嗯，如果一个理性的人会做这做那，那么如果一切都是合理的，我们为什么需要法律？

乔希费尔菲尔德(30:09):
对。

耶雷米(30:09):
所以，但是你会说，好吧，现在我们需要做的是远离合理的法律定义，并试图将它更多地映射到普通人听到合理这个词时的意思或他们认为合理的事情上。我想这在某种程度上改变了一个更客观的框架，在这个框架中，你会说，好吧，理性是这种神圣的抽象。它是一个东西，不会随着时间的推移而改变，到目前为止，合理性是一个其定义取决于上下文并有效地由社会构建的东西。伴随着所有的风险，那也是必然的，因为我可以想象你那时会滥用那种东西。如果突然之间，某个特定的人群被认为是重要的，或者在这种短暂的关系中被讨厌，那么讨厌他们是合理的。是啊。你如何看待这两者之间的平衡？这几乎就像是平民主义和，我不知道，集权主义或者…是的。

Josh Fairfield (31:06):
平民与精英，或者客观与主观。所以要指出的一件事是，所有的词，甚至像 objective 这样的词，都是从上下文的使用中收集它们的意思。举个例子，一个客观的衡量标准是人类如何主观地使用词汇。我来具体说明一下，隐私这个词最近很流行。律师告诉我们，我们不能拥有美好事物的一个原因是，就像隐私一样，与技术专家告诉我们不能拥有隐私的原因不同。但是律师告诉我们不能拥有隐私的原因是因为他们告诉我们隐私并不意味着任何一件事，它没有本质。尽管-

耶雷米(31:52):
我想苹果也不会。

乔希·费尔菲德(31:54):
是的。自由也是如此。自由也不是。安保也不行。我们看待世界的方式中的核心词汇也是如此。事实上，一个词离我们思考的中心越近，它就有越多的含义。“奔跑”这个词在英语中有 645 种不同的意思。所以当我们谈论我们如何使用词语的问题时，有一个困难，那就是人类如何使用它们确实会导致词语的意义发生变化，比如隐私，比如安全，甚至像技术这个词。今天，我试图说服你和其他人将技术视为包括法律。我正试图改变那个词的意思。那么，当足够多的人开始以一种危险的方式使用一个词，或者以一种对另一个群体进行攻击的方式使用一个词时，你该怎么办？差不多吧。关于文字如何工作，最重要的一点是，客观的固定观点和主观的观点都不正确。它可以代表你想看的任何东西。

乔希·费尔菲尔德(33:08):
我可以决定上意味着下，暗地里，但这不起作用。如果我说向上，每个人都明白，它的意思是向上而不是向下。如果我说是的，每个人都明白我的意思，是的，即使我私下会见意味着不，在我心里。所以我认为语言就像一个星系，单词或者就像一个星系。他们漂浮在太空中，但他们彼此保持着某种关系模式。这种模式是粘性的。人们说，不，你用错了这些词。我可能无法告诉你什么是合理的，但在某些情况下，我可以告诉你，一个人的行为不合理，其他人都会说，是的，这很不合理。

乔希·费尔菲尔德(33:51):
就像你酒后驾车一样，这是非常不合理的。所以，我们可以说，当语言开始失去控制时，我们该怎么办，这是一个真正的问题，任何在过去，比如说，五年中一直关注国内对话或国际对话的人都注意到，在某些情况下，我们的语言正在分裂并失去控制。你如何解决这个问题？结果只有一个答案。你必须和使用不同词汇的人交谈。你必须接近他们。每项研究都表明，你靠个人关系走得很近。然后你断言这个词有不同的意思。

乔希·费尔菲尔德(34:34):
我想我们都有过这样的对话。无论是关于种族、性别还是宗教的对话，我们都有过这样的经历，需要更接近某人，然后说，“等一下，你在用抽象的方式用词，在某种程度上把一些根本不真实的特征归因于人。”让我靠近一点说，“你真的是这个意思吗？你能听出我是怎么用这个词来代替的吗？”这是我们目前为止找到的唯一答案，就是靠得更近，而且你用的是它们本来应该用的方式。

耶雷米(35:02):
是的。太迷人了。所有这些情景的共同点是，人们几乎总是比你想象的更慷慨，更善意。一旦你能理解周围的界限是什么，这些词的实际内部定义是什么。

乔希·费尔菲尔德(35:18):
是的。我的意思是，你经常会有这样的感觉，一旦你理解了别人说话的方式，你经常会有这样的时刻，哦，我们比我们想象的要亲密得多，对吗？

耶雷米(35:28):
是的。让我想到的一件事是。语言理论以及它与机器学习的实际联系几乎是不可避免的。举例来说，当我们进行机器学习时，当我们训练一个语言模型时，我们通常会将单词表示为向量，即存在于高维空间中的一系列数字。每个单词…所以如果你看单词[听不清 00:35:53]，它是一种算法，出现在 2012 年。这就像是第一个真正成功的算法之一，生成了这些词向量之一，你得到的是…所以苹果的词向量就像是一组 200 个不同的数字。对于你的观点，就像你有一大堆不同的词，像香蕉这个词，苹果这个词，它们彼此接近，因为它们有相似的意思，更进一步说，你有狗，你有皮带，这些都很接近，等等。

耶雷米(36:17):
但是，它的结构和形状基本上编码了所有的人类知识，它形成的单词之间的关系不仅会随着时间的推移而变化，而且还会随着不同的算法而变化。所以如果你看看 OpenAI，GPT-3，它不会用 2012 年 word2vec 编码狗的方式来编码狗这个词，这不仅仅是因为在此期间有了技术进步，也只是因为训练的上下文略有不同。数据略有不同。即使你看的是同一个数据集，仅仅是随机的，随机的噪音也会造成差异。所以我们最终都会在脑海中形成这个略有不同的世界模型。所以我想，在一个给定的单词周围有一些意义，希望它们有足够的重叠，这样我们就能真正联系起来。

Josh Fairfield (37:04):
要做到这一点，就要使用这些词云来……因为你所做的是在创造进一步的联系。这些算法是在不同的数据集上训练的，这很好，因为它们所做的是在我们自己运行的算法上。他们开始时，计算机并没有很好地学习语言，直到我们学会了追踪大量人类使用的实例，而不是早期通过教某人法语规则来教自然语言处理的努力。这对于教授法语的正式规则不起作用，但现在我们转移到了学习所有这些不同含义的地方。所以我们都从很多人身上学到了这一点。然后，当我们使用它时，我们正在改变我们自己的内部云的地图，我们自己对那组含义的内部感觉。所以，是的。绝对的。

耶雷米(38:03):
是的。同样有趣的是，特别是对于更先进的系统，比如 GPT 3 号，它几乎可以给不同的人留下印象。从根本上说，GPT 3 号已经完成了。这就像努力去预测一个句子中的下一个单词。最终，这就是它所做的一切。因此，如果那句话的开头是你能预料到的类似演讲格式[听不清 00:38:23]的东西，它应该尝试按照[听不清 00:38:28]的解释来填充单词。因此，在某种程度上，这些算法几乎能够同时容纳不同的词云，同时在他们的大脑中对不同的词进行不同的解释，我想在某种程度上，这也是一个成功的精通英语的人所能做到的。就像他们能做的那样[model 00:38:45]。

Josh Fairfield (38:45):
我想说的是，我想说的是，我们看到了融合。想想从你的大学朋友群体，到工作，到……在我们运作的所有不同的社会环境中，如果你的语言没有根本改变，我会感到震惊。如果你说的下一个词没有彻底改变。事实上，这就是语言的工作方式，事实上，我们通过计算来做，意味着我们揭示了事物的结构。我们最终了解了它的实际工作原理。

耶雷米(39:15):
是啊。绝对的。我的意思是，它是如何与如此基本的事物相互作用的，这是一个迷人的问题。从更实际的角度来看，这一过程的经济学也非常有趣。我的意思是，你有这种快速发展的技术，你有拿着极高报酬的人来开发这种快速发展的技术。我认为这是一个挑战，当我与从事人工智能政策的人交谈时，我听到有人谈到这一点，这就像是一种选择效应，如果你真正深入了解人工智能，你会倾向于去私营部门。你会在谷歌找份工作，你会在 DeepMind 或者其他什么地方工作。从这个意义上说，世界上最好的人都被吸走了。

耶雷米(39:56):
这使得在政府工作的政策制定者和公务员很难以同样的速度使用英语，否则他们可能需要掌握事情。你认为这是一个公开的问题吗？这是我们能够解决的经济梯度问题吗？这种经济梯度将那些对技术有深刻理解的人从政策中推开。

乔希·费尔菲尔德(40:20):
在表面水平的两个深端。所以我从表层开始。是的，这绝对是一个困难，虽然这也是一个多方向的困难。例如，经常会出现这样的情况，产品是在没有深刻理解什么是法律以及过去历史和类比数据库的情况下从零开始构建的。他们不知道系统会以何种方式对这些事情做出反应，他们快速移动并破坏事情。[Ethos 00:40:53]当你因为当时完全可以预见的原因被监管机构敲门时，这并没有多大帮助。因此，我确实认为，在许多职业中，你会看到高薪的人，他们被吸引到他们行业的中心，这可以驱使他们远离需要进行翻译的边缘。

Josh Fairfield (41:13):
所以我认为这不仅仅是一个人工智能的问题，而是我们补偿专业知识的一种方式。这是我们奖励专家的方式。到了那个更深的点。我确实认为做科学还有其他方式。我们简单地说私营部门可以吸引所有人，这并不是不可避免的。一个反例，显然有理由认为它可行或不可行。有时候真的不行，但是大众融资可以是其中之一。但是我们做科学还有很多其他的方式。这不仅仅是为了在某种情况下获利。这并不能解决这个问题。因为我们可以赚很多钱。人们确实希望获得高报酬，而且还有进一步的中心效应，特别是人工智能，这就是你必须去找那些能够收集大规模数据集的人，或者你需要能够养活你的人工智能。

Josh Fairfield (42:13):
因此，拥有全世界 Facebooks 的人，全世界的谷歌，特别是当我们与试图学习人类行为并试图建立人类行为界面的人工智能打交道时。你得去找那些有庞大设备的人。所以我认为我们确实有一个表面的问题，那就是所有的职业都将专业知识吸引到中心，我们将需要证明这一点，我认为在你的团队中，有越来越多的好的科学证明认知多样性的直接的经济理由，我们之前谈过一点，这意味着你可能想要考虑高度可信的社会学家，或者它可能意味着专利和商标局，这只是我一直盛气凌人的事情。

乔希·费尔菲尔德(42:58):
但是美国专利商标局需要不惜一切代价让一些人成为真正了解这项技术的工作人员，因为大量的专利被轻率地授予，例如，对其他从业者来说显而易见的东西，只是别人先申请了。因此，我认为，在某种意义上，你确实需要加快步伐，增加公共资金，这样他们就可以试图吸引这些人离开，你甚至不需要与私营部门的工资相匹配。会有人，会有人真的想以不同的方式出于不同的动机从事科学研究。所以你甚至不需要去任何有竞争力的地方拿薪水。你必须确保人们得到照顾。然后也许第三个我们可以尝试更多的发展，为这些人创造可以在世界之间翻译的管道。

耶雷米(43:45):
是的，实际上，这很有趣。这让我想起了一个相关的问题，那就是当，我想是 OpenAI，当 OpenAI 作为一个非营利组织成立的时候，但我想这就像是 2015 年，人们抱怨我认为是 CTO 格雷格·布罗克曼。我不确定。不管怎样，其中一人年薪百万美元左右。OpenAI 名义上是一个非营利组织。所以人们说，你在做什么？这是一个非营利组织。你拿着一百万美元的年薪。但这就像，如果这是现行汇率，最终你想要什么？你想要一个领导层无能、没有市场竞争力、效率低下的非营利组织吗？我猜，在某一点上这几乎是一件审美的事情。在政府中争论这一点很有挑战性，但是抱歉。去吧。

乔什费尔菲尔德(44:34):
我的意思是，它是。这也是事实，尽管你必须盯着那个球。因此，有很多方法可以让员工获得远远超过他们给公司带来的价值的报酬。我们现在没有时间讨论这个。但是如果我们看看世界各地，如果我们只选择世界各地高度创新的国家。因此，根据申请专利的经济价值，申请专利数量排名前四的国家。我们发现，高管薪酬实际上有很大的差异，世界上有些地方仍然保持着令人难以置信的竞争力，而不会让高管薪酬失控。所以我确实认为，对于普通工程师，那些了解技术并利用技术进行建设的人来说，数字必须上升，他们必须具有竞争力，因为他们，你在看市场。

Josh Fairfield (45:21):
你是说，你生产的东西能带来这种收入或产生这种价值吗？这更容易跟踪，但在某个点上，你确实可以看到你给公司带来的价值之间的差异，或者员工给公司带来的价值与他们的薪酬之间的差异。我们必须在顶端观看。

耶雷米(45:40):
是啊。至少在私营部门，这种补偿的方式之一就是公平的理念。你为公司工作，你可能每年得到 10 万美元，但如果你拥有潜在的谷歌或其他公司的 0.5%的股份，是的。

乔希·费尔菲德(45:57):
然后你会被绑在上面。是啊。绝对的。

耶雷米(45:57):
是啊。我想这在政府中也很难，因为你试图让人们放弃潜在的登月计划，所以很难提出这样的论点。有意思。

乔希·费尔菲尔德(46:05):
完全正确。

耶雷米(46:06):
看起来你对我们能够做到这一点很乐观，或者你认为现在有足够的欲望开始朝着这个方向前进，甚至可能开始立法，我不知道实际上这是否会成为立法。是啊。那么，为了朝着这个方向前进，你对下一步要做什么有什么想法？

乔希·费尔菲尔德(46:23):
当然。嗯，所以我们实际上已经在这条路上起步了。尽管我认为在美国，关于制度方面的讨论已经落后了。这就是我们关于在技术创新的同时发展我们的社会制度的对话开始的地方。我认为这在很大程度上是因为我们的技术创新非常惊人，非常出色。我们刚刚清空了场地，这是每个人都在关注的地方。我们实际上已经进入了处理这些东西的过程。因此，举例来说，虽然美国还没有通过关于隐私的严肃的实体法。欧盟已经这样做了，不仅仅是一次，但是几十年后，在研究了这些问题后决定，嘿，这是可行的，嘿，这是不可行的，然后又做了一次。现在，欧洲的 GDPR 壮观吗？完美吗？

Josh Fairfield (47:20):
无论从哪方面来说都不是，但从功能上来说，它是现在全世界都在使用的语言。我不知道，你不能这么说。当人们谈论隐私法时，当他们谈论模型时，当一个国家开始制定自己的法规时，他们将要使用的语言时，这是全世界的事实。见鬼，当加州开始通过自己的法规时，这严重影响了硅谷。通常的做法，也就是科技法，倾向于首先从创新的源头开始，人们在那里创造创新，然后从那里辐射出去。我们看到的是，因为我们放弃了这场对话，我们已经把这场对话拖延得太久了。实际上已经不是那样了。现在，法律语言正在从世界其他地方引入，并真正推动了这种语言的发展，我们在华盛顿、加利福尼亚和其他一些正在通过隐私法的州的所有州法律隐私法规中都看到了这种语言。

乔希·费尔菲尔德(48:17):
所以，在全球范围内，我们都在进行这样的对话。美国将经历一段追赶时期，出于合法和不合法的原因，美国公司有时会感到很不舒服。我的意思是，美国公司在欧洲法庭上的待遇肯定存在问题。我会第一个说，那里有一些严重的问题。但是除此之外，他们发现他们不能通过这种双重声明来停止对话。要么法律跟不上技术，老了，尘封了，要么法律太早了。在我们的谈话中，法律要么太迟了，要么太早了。从来都不是坐下来说，哦，我们需要思考这些技术对我们的社会机构做了什么，以及我们如何适应它们，以允许技术向前发展，并且实际上比我们不总是在我们的社会机构上踩刹车的情况下更快。

乔希·费尔菲尔德(49:20):
因为如果我们的社会制度不能发展，我们就不能到达一个舒适的地方，在那里我们可以真正提供指导，让技术尽可能快地发展。所以我很乐观，我们的超级大国的语言，一个超级大国已经把事情说了出来，提出了看待世界的新方法。它让我们经历了很多坎坷。我的意思是，如果你特别考虑工业化的冲击。这是非常重要的一步，你不仅仅是将我们所有的互动从会议转移到 Zoom。我是说，这很好。这是一次和我进行过的许多其他对话一样的对话。想想从乡村搬到城市中心并没有太大的不同。没人知道如何让城市中心不再是工业健康区，对吗？

耶雷米(50:10):
是的。

Josh Fairfield (50:10):
我们当时经历了巨大的转变。我们讨论了这个问题，并发展了一些关于可持续性和环保主义的想法。我们创造了房屋代码之类的东西。我们改变了我们所有的财产法，以确保住房适合居住，而不仅仅是可怕的居住。这些是我所在学科的变化，但技术上的变化是一样的。我们用了大约 100 年的时间算出了这个结果。我的猜测是，只要我们放弃我们做不到的想法，我们会做得很好。这才是真正让我担心的地方，因为法律跟不上技术发展的想法吸引了大多数人的点头。你只是出去和一群在技术部门工作的人喝一杯。你会说，是的，男人法则跟不上。桌子周围的大多数人都会说，是啊，这就是事实。

Josh Fairfield (51:07):
如果我们这样做，如果我们放弃努力去提升和发展我们谈论这个问题和我们的社会制度的方式，如果我们忽视我们在其他领域这样做的明确能力。我们正以令人难以置信的速度在司法的其他领域发展我们的社会机构。然而，不知何故，在这里，技术似乎与制度和法律的总体反应有关。所以我认为接下来要做的事情是少关注法规，多关注语言是如何发展的。我认为我们已经开始这样做了。因此，如果你想知道脸书担心什么，脸书担心的不是《联邦贸易委员会法案》第五条。让脸书担心的是，当公众对 WhatsApp 的使用条款越来越不满，以及人们开始大规模转向使用信号时。

乔希·费尔菲尔德(52:04):
在我的定义中，那就是法律。这是人们根据他们对这一价值的讨论而共同采取的行动。它们现在已经大规模迁移，诸如此类。那些是法律的生命边缘。如果你把法律想象成珊瑚礁，你可以把尘封已久的法律书籍想象成珊瑚礁的主体，但是它的边缘是活的，火焰沿着书页蔓延。如果你点燃一张纸，你会看到火焰蔓延。生活边缘是人们谈论它的地方。在推特上，在脸书上。这是关于不和的讨论。这是我们开发这些新词和对技术的新反应的地方。

Josh Fairfield (52:41):
我认为我们可以缩短开发新语言和将其转化为人们可以采取行动的治理方式之间的周期。我会回到合理性作为标准。如果我们观察一代人，看他们如何使用技术，什么是对技术的合理使用，合理的东西会变化得很快？刮某人的不和谐聊天合理吗？将某人的特征合并到回应性广告中，以说服他们购买某物或以某种方式投票，这合理吗？当我们将法律标准与人们的反应联系起来时，现在，我们有了规则，我们有了标准，这些标准可以随着人们观点的改变而更快地改变。

杰里米(53:31):
似乎更短的响应时间也意味着我更少考虑这些潜在法律的长期影响。例如，如果我们说，好吧，你不允许使用[DeepFix 00:53:48]，可以想象通过一些蝴蝶效应类型的东西。从长远来看，这可能是件好事，也可能是件坏事。也许我们希望人们[听不清 00:53:58]。

乔什·菲尔菲尔德(53:58):
我的意思是，我们不会有上一季的最后一集，还有《曼达洛人》，对吗？

耶雷米(54:01):
是啊。

乔希·费尔菲尔德(54:02):
卢克·天行者出现了，这很重要。

耶雷米(54:05):
这是伟大文明伴侣的事情。

乔希·费尔菲德(54:08):
对。

耶雷米(54:08):
我的意思是，这些事情也很难预测，但是也可以想象，我们也需要一些时间来思考，例如在加拿大，我们有参议院，这是所谓的冷静思考的地方。当众议院通过立法时，你会看到有人说，哇，孩子直民主在这里很酷-

乔希·费尔菲德(54:27):
这更疯狂。对吗？

耶雷米(54:27):
是啊。因为总有这种天生的紧张感。我的意思是，它的一端就像斯巴达的相对停滞，另一端就像危险的革命热情。革命法国什么的。所以，我想，在这两者之间选择一个合适的点，听起来就像是向一个方向转移而不是另一个方向。这是一个公平的描述吗？

Josh Fairfield (54:52):
这是对我们之前说过的内容的一个重要回顾，效果最好。如果我们确保法律变得谦逊、反复和实验性，我的意思是，我们正在处理…因为法律也…人类系统以一种我们可能没有时间去探究的方式，但是人类系统是路径依赖的。我们之前争吵的事情，我们之前的想法会导致下一步，导致下一步，导致下一步。因此，如果我们认为法律是为遥远的未来设定一个规则，我们将会制定非常糟糕的法律。这是所有这些过时法律的问题之一，每个人都指着它们说这些法律不起作用。我是说，你懂的。这就像指着过时的技术，认为技术行不通。我们需要做的是停止使用它们。

Josh Fairfield (55:42):
我们需要摆脱他们，进行迭代。如此谦逊意味着我们看不到那么远的未来。实验意味着我们尝试新的东西，迭代意味着我们总是回来。我们从来不说这已经完成了，因为这确实制造了我们制造的问题。我们决定了我们现在所处的位置，这将给未来投下一个长长的阴影。我们将不会有我们一直试图纳入法律的灵活性。所以你想要的是一个更接近，更紧密的循环，所以季后赛更密切地关注人们如何思考，如何反应，以及人们如何…他们的生活经历是奥利佛·文德尔·霍马斯的名言。他说，法律的生命不是逻辑，而是经验。

乔希·费尔菲尔德(56:29):
这是人类的亲身经历。那是法律的原材料。这是一个数据集，我们可以问人们在这些情况下做得怎么样。很多人现在过得很糟糕。我们可以做得更好。那么收益就是我们这样制定的规则，不能有这么长的影子。我们必须有一种方法，在一个更紧密的循环中不断回顾、不断更新它们。

耶雷米(56:52):
我爱它。我是说，很棒的主题。这与我从与人工智能政策领域的几个人的交谈中听到的内容产生了共鸣。这似乎是必须要发生的事情。乔希，非常感谢。各位，这本书是《失控的技术:法律能跟上吗？。我认为这将是人们会反复关注的事情之一，不仅仅是关于人工智能，还有区块链，虚拟现实，我的意思是，一切都在以一种我认为会使这变得更相关的方式转变。乔希，非常感谢。我真的很感激。

Josh Fairfield (57:18):
非常感谢你邀请我。我很感激来到这里。

OpenAI 时的 AI 对齐

原文：https://towardsdatascience.com/ai-alignment-at-openai-a242a135d3bf?source=collection_archive---------30-----------------------

播客

简·雷科谈人工智能比对研究的前沿状况

苹果 | 谷歌 | SPOTIFY | 其他

编者按:TDS 播客由 Jeremie Harris 主持，他是数据科学导师初创公司 SharpestMinds 的联合创始人。每周，Jeremie 都会与该领域前沿的研究人员和商业领袖聊天，以解开围绕数据科学、机器学习和人工智能的最紧迫问题。

我们的人工智能变得越强大，我们就越需要确保它们做的正是我们想要的。如果我们不这样做，我们就有可能构建出使用危险的创造性解决方案的人工智能，这些解决方案会产生不良或完全危险的副作用。一个足够先进的人工智能的动机和人类价值观之间哪怕有一点点不一致都可能是危险的。

这就是为什么像 OpenAI 这样的领先人工智能实验室已经在人工智能对齐研究上投入了大量资源。如果你想了解先进的人工智能系统可能会走向何方，以及随着人工智能能力的不断增长，我们可能会遇到什么挑战，那么理解这项研究就很重要——这也是本期播客的全部内容。我今天的嘉宾是扬·雷科，OpenAI 人工智能联盟的负责人，也是 DeepMind 和人类未来研究所的校友。作为一个直接与一些世界上最大的人工智能系统(包括 OpenAI 的 GPT-3)合作的人，Jan 对比对研究人员当前面临的挑战以及该领域可能采取的最有前途的未来方向有着独特而有趣的观点。

以下是我在对话中最喜欢的一些观点:

  • 从历史上看，人工智能比对研究一直偏重于理论。这是可以理解的:人工智能只是没有足够的能力来解决对齐问题，直到最近。与纯理论相比，Jan 通常更喜欢实证比对研究和在真实系统上的实验，并且很高兴看到更多的比对研究人员也朝着那个方向前进。虽然他认为纯理论有一席之地——特别是当考虑到我们还不能实现的能力的系统时，理论是唯一可用的选择——但他也认为大量的比对研究工作不够具体。实验焦点有助于为关于真实系统行为的直觉打下基础，Jan 认为它会带来更有用的见解。
  • 整合非常强大的人工智能系统的挑战之一是，它们可能会构想出如此复杂的解决方案，以至于人类无法审核它们以确定它们是明智和道德的。简一直在探索解决这个问题的一个策略叫做递归奖励模型(RRM)。通过 RRM，一系列“助手”人工智能被训练来帮助人类评估更复杂人工智能的性能——希望这个助手增强的人类能够评估这个复杂人工智能的行为和对齐水平。
  • 总的来说，Jan 对构建他所谓的“校准 MVP”的前景持乐观态度。用创业的语言来说，MVP——或最小可行产品——是公司为测试一个想法而能制造的最简单的创造价值的产品。对 Jan 来说，校准 MVP 将是一个能够在人工智能和人工智能校准研究的特定任务上匹配人类表现的人工智能系统，同时它本身与人类价值观充分一致，以产生有用的结果。Jan 希望从这一点开始，人工智能研究可以得到加强，并最终由人工智能自己接管，这可能有助于人类研究人员提出一个更完整的解决一般比对问题的解决方案。
  • 简指出，即使对齐问题得到解决，许多与变革性人工智能的发展相关的最困难的问题仍将摆在我们面前。我们将不得不考虑如何分配对技术的访问，以及高级人工智能将不得不与哪些人类价值观保持一致，特别是。工人失业和国际动态等问题也必须得到解决。OpenAI 有一个政策专家团队，他们与他们的能力和一致性研究人员一起工作，提前预测这些挑战。
  • OpenAI 刚刚宣布他们发布了一个图书摘要 AI。点击这里查看！
  • OpenAI 在招人！如果你对整合强大的人工智能系统感兴趣，在这里查看他们的开放角色。

你可以在 Twitter 上关注 Jan 这里，或者 me 这里。

章节:

  • 0:00 介绍
  • 1:35 Jan 的背景
  • 7:10 可扩展解决方案的时间安排
  • 16:30 递归奖励建模
  • 24:30 错位放大
  • 31:00 社区焦点
  • 32:55 电线接头
  • 反对认可机构民主化的论据
  • 49:30 能力和一致性之间的差异
  • 51:15 要关注的研究
  • 1:01:45 将对个人经验的理解形式化
  • 1:04:04 OpenAI 招聘
  • 1:05:02 总结

人工智能与环境 II:参与对话

原文：https://towardsdatascience.com/ai-and-the-environment-ii-engaging-the-dialogue-e0460f3ad6d9?source=collection_archive---------29-----------------------

令人惊讶的是，关于人工智能可持续性的对话非常缺乏。在这篇文章中，我将告诉你加入对话需要知道什么。

作者图片

介绍

这是我关于人工智能和环境系列的第二篇文章。在本帖中，我将重点关注现有的解决方案，以及如何有效地表达这些方案以加入对话。我希望这将有助于提高对这一问题的认识，并让更多的公众参与辩论。

如果你还没有阅读第一篇文章，我建议你浏览一下这里的介绍，以了解人工智能给环境带来的问题的一些基本背景。

这篇文章确实涉及了一些技术概念，但我是根据对公众至关重要的关键点来介绍它们的——它们如何与环境相关，进而与公众福祉相关。

以下是关键要点:

  • 减少人工智能创造期间和之后所需的能量
  • 重用小的、经过修剪的人工智能，而不是原来的人工智能
  • 回收好的人工智能，更有效地创造其他人工智能
  • 与人工智能相关的公共对话和政策应该考虑这些选项——将人工智能描绘成“好”或“坏”(或者单独的“红”和“绿”是没有用的

看人工智能创造

人工智能的各个方面使其具有可持续性(或不可持续性)。这主要来自两点:人工智能占用了多少能量，以及这些能量来自哪里。

上一篇文章，我提到所有的人工智能最终归结为数学。“更大”的人工智能需要更多的数学，要么是因为它们使用更复杂的方法来理解数据，要么是因为它们对更大的数据集进行数学运算。每一个数学运算都需要电力，这使得这些人工智能更加耗电。

然而，即使是耗电的人工智能也可能相对“绿色”。大多数大型人工智能都是在数据中心创建的。数据中心是仓库般的建筑，储存着数以千计的电脑。这些数据中心基本上支撑着整个互联网——谷歌、推特、微软等的所有数据。储存在其中。然而，许多数据中心包含旨在快速创建人工智能的计算机——即，它们专注于使用数据而不是存储数据。

所有数据中心都需要大量电力——通常比城市还要多。这种能量不仅来自计算机的运行，也来自计算机的冷却(如果没有适当的冷却，计算机会过热并出现故障)。Jones 在[1]中对这个主题做了一个很好且容易理解的介绍。

事情是这样的:数据中心在获取能源的方式上并不平等:一些数据中心从肮脏的来源获取能源(如煤、石油和天然气)，而许多其他数据中心则部分由太阳能或风能等可再生能源提供能源[2]。这意味着，同一个人工智能在两个不同的领域运行，将对环境产生截然不同的影响。

此外，一些数据中心的冷却效率更高，这意味着它们的总体能耗更低[1]。这些数据中心也比它们的替代品更环保。

“修剪”创造的人工智能

许多人工智能基于一种受大脑启发的名为“神经网络”的技术。在这些神经网络中，数学是在不同的单元中完成的，通过类比称为“神经元”(仍然只是大量的数学)。

然而，神经网络有一个有趣的特性:虽然它们需要非常大才能创建——在某些情况下有数百万或数十亿个神经元——但一旦创建，你可以在不损失有效性的情况下让它们变得更小[3]。

这个使它们变小的过程叫做“修剪”。它包括切除对人工智能没有贡献的神经元。事实上，这甚至可以导致人工智能具有更好的整体效率，即使当大约 90%的原始神经元被移除时[3]。

这最棒的部分是什么？你猜对了——数学少！这意味着更少的电力。

事情是这样的:大多数人工智能将被创建一次，并被多次使用。虽然修剪不会减少创建人工智能所需的能量(实际上增加了)，但每次使用人工智能时都会节省大量能量。

例如，你可以创建一个人工智能来确定一张给定的人的皮肤照片中是否存在癌症。自然，你会希望这是准确的——所以你用大量的能量来创造它。那只会发生一次。但当人工智能应用于临床时，它会被使用成千上万次。随着时间的推移，尽可能提高这一步骤的效率意味着使用更少的能源。由于修剪，人工智能仍然一样准确，甚至更准确。

教一个老人工智能新把戏

你可能无法教会一只老狗新把戏——但你可以教会一只老人工智能！这涉及的领域被称为“预训练”或“迁移学习”。他们背后的想法是创造一个非常强大的人工智能(可能有一吨的能量)，然后重新训练它完成不同的任务(例如，见[4])。

这是怎么回事？这相当简单。大多数人工智能学习很多有助于他们决策的基础知识。例如，一个被训练来区分猫和狗的人工智能可能会学习寻找面部和身体的不同轮廓，并看不同的颜色。

许多其他动物也会在这些方面有所不同。只要给人工智能一些大象的例子，它就可以学会识别大象。这个过程更快——因为它使用了人工智能已经拥有的知识，创造这个新的人工智能需要更少的数学——因此也更少的能量

就像修剪一样，这是一种让一个非常强大，耗能的人工智能一次，然后利用这个人工智能让许多未来的任务更加节能的方法。你猜怎么着？这也可以比从头开始创造一个新的人工智能带来更高的性能[4]！

重访红色 AI

在我的上一篇帖子中，我提到了所谓的“红色人工智能”——基于大数据和计算能力的极度消耗资源的人工智能[5]。

我现在试图用一个问题来补充这个定义的细微差别:哪一个人工智能更“红”:花了大量能量创造的人工智能，但可以用很少的能量来使用？或者是那种制造成本低廉，但在使用过程中消耗相对较多能源的能源？

像其他事情一样，这是一种平衡。“红色”和“绿色”是很好的标签——但是讨论它们必须从全局的角度出发。

最终，给人工智能贴上“绿色”或“红色”的标签可能是有用的——但在某一点上，它会失去价值。存在许多这些术语无法捕捉的细微差别。

我为什么在乎？

读完以上内容后，我可以想象你可能会问“我在乎什么？我不打算创造一个人工智能。”

这样做的目的是让可持续发展成为对话的一部分，并让公众讨论和辩论其中的要点。人工智能不应该是一个“黑匣子”——人们应该知道它是如何工作的。

人工智能彻底改变了我们的生活。我们现在所做的一切——从在电脑上写字、拼写和语法检查，到与 Siri / Alexa /谷歌对话，我们都在与人工智能互动。所有这些人工智能都需要能量来创造。

人工智能无处不在。但气候危机也是如此。如果我们希望能够可持续地使用现代技术，我们需要专注于使用更少能源的技术。人们对此了解得越多，谈论得越多，他们就越能推动政府制定明智的政策。这不是要阻止人工智能，而是要学习我们如何负责任地创造和使用它。

因此，当你听到有人在使用人工智能时，记得参与到对话中来——并将可持续发展带入对话中。

结论

让人工智能可持续发展需要我们思考人工智能是如何以及在哪里被创造出来的。像其他事情一样，这可以归结为一句格言“减少，再利用，回收”。以下是关键要点:

  • 减少人工智能创造期间和之后所需的能量
  • 重用小的、被删减的人工智能，而不是原来的人工智能
  • 回收好的人工智能，更有效地创造其他人工智能
  • 与人工智能相关的公共对话和政策应该考虑这些选项——将人工智能描绘成“好”或“坏”(或者单独的“红”和“绿”是没有用的

参考

  1. 如何阻止数据中心吞噬世界电力？大自然。2018 年 9 月；561(7722):163–166.PMID: 30209383。
  2. 拉科斯特，亚历山大&卢乔尼，亚历山德拉&施密特，维克多&丹德斯，托马斯。(2019).量化机器学习的碳排放。
  3. 弗兰克，乔纳森&卡宾，迈克尔。(2018).彩票假设:训练修剪神经网络。
  4. 胡振中，董，杨，王，常，王广伟，孙，杨(2020)。GPT-GNN:图形神经网络的生成预训练。在 KDD 。
  5. 《绿色人工智能》。ACM 的通信63.12(2020):54–63。

人工智能与环境 3:超越能源

原文：https://towardsdatascience.com/ai-and-the-environment-iii-beyond-energy-51466855e04c?source=collection_archive---------26-----------------------

人工智能的可持续发展不仅仅关乎能源。它还涉及稀土元素提取、人类劳动、污染和水资源保护。

作者图片

介绍

这是我关于人工智能和环境系列的第三篇文章。在这篇文章中，我将简要概述人工智能对环境的所有其他影响——从稀土元素提取和人类劳动到水资源保护和污染。

如果你没有阅读前两篇文章，那也没关系！然而，我确实建议浏览一下他们的介绍(这里这里和这里，以获得人工智能是什么以及它如何影响全球能源使用和碳排放的概述。

这篇文章采用了一个新的视角:超越能源，人工智能(和一般的计算)对我们生活的世界意味着什么？这里有大量的因素，所以我将概述其中最重要的因素，并留下一些参考资料供进一步阅读。关键要点是:

  • 制造人工智能运行的计算机需要稀土元素，提取和提炼稀土元素需要巨大的环境和人力成本
  • 人工智能数据来源于公众和公共数据集，往往在人们不知情的情况下。
  • 人工智能通常是私有的，而不是公共的，这限制了绿色人工智能的重用和再应用
  • 制造人工智能的数据中心需要大量的水和能源来冷却

稀土元素

有 17 种元素被称为“稀土元素”[1]。这个术语有点用词不当:它不是指元素有多稀有，而是指它们有多难获得[1]。然而，重要的是，这些元素都有三个共同点

  • 他们非常需要建造计算机和其他技术，包括人工智能[1]
  • 他们有巨大的环境成本来提取和提炼[1]

开采稀土元素时提取的 99.8%的地球被丢弃并倾倒在陆地上的河流中，实际上只有 0.2%含有所需的元素[1]。除此之外，中国稀土学会发现提炼一吨稀土元素会产生一吨放射性废物和 75000 升酸性水[1]。

与稀土和其他元素的担忧交织在一起的是所有参与提取这些元素的人——这一过程通常是危险的。例如，从刚果工夫茶中提取钴的工人面临着可怕的工资——相当于每天大约 1 美元，或大约 0.90€[4]。与此同时，他们不得不在危及生命和健康的条件下工作。在许多其他开采领域的研究也大致描绘了同样的开采图景[1]。

除了稀土元素之外，看看所有其他需要的部件——比如塑料和玻璃——制造一台计算机从提取原材料到在工厂组装的整个过程需要将元素运输数百万公里[1]。当然，运输不是免费的——据估计，运输造成了 3.1%的全球碳排放[1]。这种运输通常使用低级燃料，同时也排放许多其他有毒物质，如硫磺[3]。据估计，这些排放每年导致约 30，000 人死亡[3]。

隐藏的人类劳动:数据经济

除了直接参与制造计算机的人工劳动之外，还有一个巨大的隐藏的人工劳动层:我们每一个阅读这篇博客的人都是谷歌、亚马逊、微软、苹果以及其他许多公司的劳动者。

与亚马逊的 Alexa(或任何其他类似设备)的每次交互都被记录为数据。你又问了同样的问题吗？如果是这样，那么 Alexa 可以推断你不喜欢它的回答。在提出问题/发出命令后，是否采取了任何行动？如果是这样，Alexa 认为它做得很好。诸如此类[1]。

但不止如此，Alexa 和相关设备总是会监听。他们使用录音来提高幕后的语音识别。这些数据来自我们身边的每一个人。

类似地，还记得那些你必须完成才能登录网站的“验证码”吗？那些写着“我不是机器人”的，或者要求你选择所有包含自行车的图片的？每一个都在收集你的数据，并用它来训练人工智能更好地进行图像识别——或任何其他任务[1]。

事情是这样的:这些数据来自公众。但是开发出来的工具都被私有化了，公众无权看到它们是如何制造的，或者它们是用来做什么的。

作为一个案例研究，请考虑 DeepMind Technologies 和皇家自由医院。DeepMind 获得了医院的公共数据，并使用它创建了一个私人工具[1]。然而，该工具当时是私有的，不向其他公立医院开放[1]。

人工智能是将公共数据的应用和使用私有化的一种方式。这也会对环境产生影响。

当结果保密时，这意味着基于公共数据(潜在的有价值的健康数据)的工具只保留给那些有权访问的人。但是，如果这些工具是用来帮助减少排放和执行更智能的电网规划的许多人工智能中的一部分(如[5])，这意味着帮助环境的工具也是类似隐藏的(尽管公平地说，这些数据中的大部分可能是私人的，而不是公共的)。

但这并没有结束。隐藏在所有这些背后的是数据提取的另一个领域:所谓的“点击工人”工厂[1]。这些“数字工厂”涉及大量受雇为人工智能标记数据的人——例如，判断一张照片是否包括自行车。亚马逊机械土耳其人经常这样做，这是一个允许人们登录来做这项工作的程序[1]。

这允许产生巨大的数据集来训练人工智能。巨大的数据输入到巨大的人工智能中，需要大量的能量。但是，如果结果是私有的，没有人能从它受益，除非他们自己重做所有这些工作。从数据收集到 AI 创作，中间涉及的所有精力，都要重新做一遍。

水利

回头看看数据中心(计算机仓库，除其他外，可以创建人工智能)，我们看到了几件事。

从一个方面来说，每个数据中心的每一台计算机、处理器和电缆都利用了稀土元素提取、运输原材料、组装、人工劳动和数据经济的庞大网络[1]。每一部手机、笔记本电脑、电脑、游戏机都是如此——只要是你能想到的。

但是一旦这些完成，数据中心建成，还有两个主要问题:能源和水。我已经在这里详细介绍过能源，所以在这一节我打算把重点放在水上。

由于人工智能是在数据中心创建的，计算机会产生热量——就像你一样，你的笔记本电脑或手机在长时间开着后会变热。为了冷却它们，必须使用大量的水。事实上，仅在美国，据估计 2014 年数据中心就使用了 1000 亿升水[5]。

如果这种冷却是通过喷雾或使用冷水来完成的，那么除了运行数据中心计算机所需的能量之外，还会涉及到大量的能量[5]。但是，即使有了最近的温水冷却，仍然有很大的水成本——即使所需的能量大大减少了[5]。

虽然在一些水资源丰富的地区，这可能不是一个问题，但在许多面临干旱的地区，或者在沙漠中，这需要考虑适当的保护。

结论

人工智能和环境产生的问题远远超出了能源使用:它是劳动力，它是采矿和提炼，隐藏的数据经济，污染和水资源保护。

这并不是说人工智能是“邪恶的”——甚至红色的人工智能也不一定是坏的。人工智能可以做许多伟大的事情——提高能源网格效率，检测癌症，以及创造治疗疾病的新药等许多其他应用。但是，这些好处应该总是与另一方的严肃讨论一起进入对话——人工智能来自哪里，谁的劳动创造了它，谁从中受益。在我的下一篇文章中，我将更详细地探讨红色(和绿色)人工智能的复杂性。

如果你觉得这篇文章很有趣，并且想知道更多，我强烈推荐阅读人工智能系统的剖析 [1]和如何阻止数据中心吞噬世界电力[5】——这两本书都很容易阅读，并且来源丰富。

目前，这篇文章的要点是:

  • 制造人工智能运行的计算机需要稀土元素，提取和提炼稀土元素需要巨大的环境和人力成本
  • AI 数据来源于公众和 rom 公共数据集，往往在人们不知情的情况下。
  • 人工智能通常是私有的，而不是公共的，这限制了绿色人工智能的重用和再应用
  • 制造人工智能的数据中心需要大量的水和能源来冷却

参考

  1. Kate Crawford 和 Vladan Joler，“解剖一个 AI 系统:作为人类劳动力、数据和行星资源解剖图的亚马逊回声”，AI Now Institute and Share Lab，(2018 年 9 月 7 日) https://anatomyof.ai
  2. Zoë Schlanger，“如果航运是一个国家，它将是第六大温室气体排放国”， Quartz ，2018 年 4 月 17 日。
  3. 约翰·维达尔，“航运污染的健康风险被‘低估’，”卫报，2009 年 4 月 9 日，sec。环境，http://www . the guardian . com/environment/2009/apr/09/shipping-pollution。
  4. “这就是我们为之而死的原因:刚果民主共和国的人权侵犯推动了全球钴贸易”(大赦国际，2016 年)，https://www.amnesty.org/en/documents/afr62/3183/2016/en/
  5. 尼古拉·琼斯，“如何阻止数据中心吞噬世界电力”，自然，2018 年 9 月 12 日。

人工智能与环境四:红色人工智能可以是好的

原文：https://towardsdatascience.com/ai-and-the-environment-iv-red-ai-can-be-good-a90283d13c3e?source=collection_archive---------23-----------------------

红色人工智能——具有巨大能量成本的人工智能——可以导致最终减少排放的发现和产品。这里有一些案例，尽管有危险，红色人工智能还是有价值的。

作者图片

介绍

这是我的“人工智能与环境”系列的第四篇也是最后一篇文章。如果你没有读过前三本书，那也没关系。然而，请随意浏览他们的介绍这里、这里这里和这里这里——这不会花费超过一分钟的时间，并且为本文提供了一些很好的背景。

在这个系列之后，我将开始一个新的——我仍然在决定一个主题，所以请继续关注！

在这篇文章中，我将看看“红色人工智能”(需要大量能量运行的人工智能)有益的时候。在某些情况下，红色人工智能的好处不仅在于人工智能性能本身，还在于环境。关键要点是:

  • 红色人工智能可以导致能源使用的整体减少，尽管它需要大量的能源来创造
  • 健康和气候科学的红色人工智能通常是合理的，因为它对人类和生态系统生命的好处可以超过它的创造成本
  • 红色人工智能本身有时有价值，因为它有助于为上述用途创建更好的人工智能。然而，这是危险的，应该非常小心谨慎地去做。
  • 合法使用红色 AI 不是环保不负责任的借口。当使用红色人工智能时，研究人员将能源成本降至最低更为重要。

气候科学与响应的红色人工智能

红色人工智能可以通过两个主要途径对气候产生非常积极的影响:提高我们对气候变化如何发展的理解，以及智能地应对气候变化。

人工智能已经被用于预测全球温度变化，模拟风暴，海洋事件，云的变化和极端天气事件[5]。它还成功地预测了这些变化的结果，如缺水、野火、雨水破坏以及气候灾害导致的被迫人口迁移[5]。在更局部的层面上，它可以有效地应用于能源管理[3，5]和城市能源网[5]——节能减排。

有趣的是，微软在 2018 年的一份报告中估计，使用人工智能来理解和应对气候变化云，到 2030 年，排放量将减少 1.5%至 4.4%，同时全球 GDP 将增加 3.1%至 4.4%[6]。

然而，这种变化所需的许多人工智能模型将需要大量的前期能源和排放成本。例如，让我们看看数据中心。

数据中心是耗电大户。本质上，它们是成百上千的工业计算机堆在一个仓库里。不仅运行计算机需要电力，冷却计算机和执行其他辅助任务也需要电力。事实上，冷却是大多数数据中心最昂贵的辅助任务[1]。

谷歌和 DeepMind 发现，通过使用人工智能来管理数据中心的内部冷却系统，他们将冷却成本降低了 40%，并达到了创纪录的能效值[3]。

然而，这背后的人工智能必须考虑许多因素，并需要数百万个数据点进行训练[2]。它依赖于大量不同的神经网络一起工作——称为“集合”设置[3]。虽然这种设置可能非常强大，但它们通常比更小的非集合方法耗费更多的能量。

虽然涉及的人工智能的具体细节还没有公布(据我所知)，但它肯定会属于红色人工智能的范畴。尽管它的制造成本很高，但它能够削减 40%的冷却成本，并创下创纪录的效率，这说明它的好处远远大于坏处。既然它已经被创造出来，它可以被应用于许多不同的数据中心——并且可能在那里产生类似的强大结果。

归根结底，这是成本效益分析。红色 AI 有很大的前期成本，但有时它可以带来巨大的后期收益。通常，这些好处是值得的。

健康的红色人工智能

当 AI 对生活有直接影响时，重要的是 AI 尽可能少出错。人工智能在医学上不乏应用。例如，人工智能模型已经被创建来预测两种药物是否可以在人类中安全地结合，或者当结合时它们是否可能造成伤害[7]。

这种系统可以用来帮助指导研究人员探索在治疗疾病时应该结合哪些药物。当然，如果研究人员依赖这样的系统作为指导，而这是错误的，那么他们将浪费宝贵的时间——这可能对患者产生真正的影响。如果人工智能被用于这个领域，它绝对必须是可靠的。

我在以前的帖子中提到过，红色 AI 的特点是收益递减[4]。使用越来越多的高能耗人工智能和更多的数据变得越来越没有好处[4]。然而，这并不意味着它没有好处——如果人工智能被用于数百万个病例或帮助数百万名患者，那么即使准确度有 0.1%的变化也可能产生巨大影响。如果这种改善有可能对生活产生积极的影响，那么就必须加以考虑。

从长远来看，红色 AI 造成的污染和排放显然对人类非常有害，对整个世界也是如此。然而，这必须与当前改善(甚至拯救)生活相平衡。

回到预测药物组合的示例:想象系统高度可靠。这意味着使用它的研究人员将需要更少的时间来确定哪些药物可以安全地联合使用来治疗给定的疾病。治疗可以更快发展，结果是更多的人帮忙。

将红色人工智能应用于健康需要正确平衡现在和未来——强调其中一个而排斥另一个弊大于利。

为了红色人工智能，红色人工智能

在他们提倡绿色人工智能的论点中，Schwartz 等人认为红色人工智能确实有一席之地[4]。他们给它的地方是所谓的“纯研究”——为了研究本身而研究。毕竟，正是红色人工智能极大地改善了我们理解和使用人工智能的方式[4]。如果没有红色人工智能过去的那些用途和那些改进，使用人工智能来帮助处理气候变化、气候预测和健康是不可能的。

因此，假设每一个与气候或健康没有直接关系的红色禽流感病例都是坏的，可能会排除有益的类似进展。

当然，这是一条非常危险的路线。这并不意味着，也不应该意味着所有的红色人工智能都是好的。事实上，我认为大多数红色人工智能都不好。但这是可能的，哪些红色认可是好的，哪些不是，不能总是提前知道。

作为使用红色人工智能的最后一点，我必须强调一点:

红色人工智能——即使它的使用是合法的——也绝不是对环境不负责任的借口。

事实上，当研究人员使用红色人工智能时，他们需要更加专注于尽可能减少能源使用。他们还必须致力于共享他们的人工智能模式，这样其他人就可以重用它们——这从长远来看可以节省大量能源。

红色人工智能不是不负责任的人工智能——它只是一种人工智能，在这种智能中，造物者预先接受了需要大量的能量来朝着最终更大的善而努力。如果还不清楚对环境或人类生活的更大好处正在努力实现，那么就不应该使用红色人工智能。

这一切都需要成为对话的一部分——从公共讨论到政策辩论和研究方法，必须考虑环境影响。每次使用红色人工智能都必须有明确的理由。

结论

画一条很难的“好/坏”线很少有用。红色人工智能也是如此——它是一种工具，有很好的用途。研究人员、政策制定者和公众有责任将对话集中在人工智能的影响上——不管是好是坏——并沿着最有益、最无害的道路前进。红色人工智能和绿色人工智能一样适合这种情况。

这篇文章的主要收获是:

  • 红色人工智能可以导致能源使用的整体减少，即使它需要大量的能源来创造
  • 红色人工智能对于健康和气候科学来说通常是合理的，因为它对人类和生态系统生命的益处可能超过它的创建成本
  • 红色人工智能本身有时有价值，因为它有助于为上述用途创建更好的人工智能。然而，这是危险的，应该非常小心谨慎地去做。
  • 合法使用红色 AI 不是环保不负责任的借口。当使用红色人工智能时，研究人员将能源成本降至最低更为重要。

参考

  1. 如何阻止数据中心吞噬世界电力？大自然。2018 年 9 月；561(7722):163–166.PMID: 30209383。
  2. 自主数据中心冷却和工业控制的安全第一人工智能| DeepMind
  3. DeepMind AI 将谷歌数据中心冷却费用降低 40% | DeepMind
  4. 《绿色人工智能》。美国计算机学会通讯63.12(2020):54–63。
  5. j .考尔斯，a .察马多斯，轩辕洛尹，M. 等人工智能的策略:利用人工智能对抗气候变化——机遇、挑战和建议。 AI & Soc (2021)。https://doi.org/10.1007/s00146-021-01294-x
  6. 人工智能如何实现可持续发展的未来(microsoft.com)
  7. 卡里姆，医学博士&科切兹，迈克尔&查韦斯，若昂博斯科贾雷斯&乌丁，马姆塔兹&贝扬，奥亚&德克尔，斯特凡。(2019).基于知识图嵌入和卷积 LSTM 网络的药物相互作用预测。113–123.10.1145/3307339.3342161.

人工智能与环境:问题

原文：https://towardsdatascience.com/ai-and-the-environment-the-problem-fa61c8bc5131?source=collection_archive---------32-----------------------

人工智能在许多方面都与环境有关——无论是好是坏

作者图片

介绍

关于我开始的新系列博客，以及这篇文章的内容，我做了一些说明。

这是我将围绕人工智能、大数据、生物信息学和环境的交叉点发表的一系列博客中的第一篇。为什么是这些？两个原因。首先，也是最简单的，这四个要素是我在都柏林三一学院博士工作的中心——在接下来的四年里，我将非常深入地钻研它们。

第二:这些话题虽然在现代世界至关重要，但通常有很高的准入门槛。这种科学，即使是普通大众也能获得(情况并非总是如此；我们世界上许多最好的科学工作都藏在付费墙后面)是写给专业读者而不是普通读者的。

这篇文章将涵盖人工智能和环境的一个方面，重点是存在的问题。后面的帖子将会探讨这个问题的解决方案(有很多令人兴奋的)，以及为什么即使非常耗电的人工智能也可以为环境创造奇迹。以下是关键要点:

  • 复杂的人工智能需要大量的电力、计算机硬件和时间来创造
  • 制造更复杂的人工智能会产生递减的回报
  • 大多数人工智能目前只关注结果，而不是环境影响

一些背景

人工智能基于大量的数学，让计算机做这些数学运算需要大量的时间和电力。

AI，或人工智能，是一套方法，教计算机如何推理，智能地行动，或从数据中学习做一些工作。

人工智能的“好”和“有效”可以用许多方法来衡量；这些细节超出了本文的范围。现在，你可以认为每一个人工智能都有工作要做，它的“效率”就是它工作的好坏。

至于它是如何工作的:这一切都归结于数学。人工智能的构建模块是数学运算——细节不在本文讨论范围之内，人工智能最基本的部分(如果你愿意，可以称之为“原子”)是乘法、除法、加法和减法。

运行人工智能所需的工作量通常以所谓的“GPU-小时”来衡量——这些基本上是“人-小时”，但对于计算机来说。GPU(或图形处理单元)是计算机的一部分，能够以令人难以置信的速度执行数学，使人工智能成为可能。

事情是这样的:每个数学运算都需要电。就个人而言，他们几乎一无所获。但大多数最优秀的现代人工智能都是在如此庞大的运算量上运行的，这加起来会产生巨大的影响。

例如:一些最好的模型(如“RoBERTa28”)可以达到 25，000 GPU 小时的数量级[1]。这大约是 2.85 GPU 年——这意味着它相当于以高功率运行一台顶级计算机近 3 年，而从未关闭它。

但这还不是全部。采购计算机零件(需要黄金等稀土金属)是一项昂贵的任务。这些零件必须经过提炼、运输、组装、测试，然后运送给用户。然后，计算机必须以高电力运行来创造人工智能。即使一个人工智能被创造出来，一些人工智能需要如此强大的计算能力来使用，以至于除了人类所能提供的最好的计算机硬件之外，它们实际上不能被用在任何东西上。

另一个例子是:被训练来下围棋的“AlphaGo”人工智能(在这项任务上远远超过人类)的繁殖成本估计为 35，000，000 美元——这是迄今为止最昂贵的模型之一[1]。

“红色”艾

红色人工智能是只关注结果的人工智能，而不是消耗的资源。

施瓦茨在阿尔。将“红色人工智能”定义为只关注结果的人工智能——人工智能本身有多有效——而不考虑环境成本[1]。

ai“红”有两大因素。首先是使用更大的数据集，这样人工智能就有更多的东西可以学习。第二是使用更复杂的人工智能模型(即更多的数学)，这样人工智能可以更有效地学习。

这两种方法有两个共同点。它们都需要大量的资源。他们都遭受着收益递减的困扰。

施瓦茨在阿尔。解释说，这两种方法——更多的数据和更多的计算——只能得到对数上更好的结果。那是什么意思？

这里有一个对数(或“log”)。

作者图片

随着 x 的增加，它的对数也在增加——但随着时间的推移越来越慢。这是一个收益递减的可怕例子。在我们的例子中,“x”是人工智能必须处理的数据量或数学量。Log(x)是人工智能有多“好”。

这意味着红色人工智能不仅需要大量资源，而且当你追求巨大的数据和计算能力时，它会变得越来越不可持续。

结论

到现在，应该很清楚 AI 在资源消耗方面存在一些重大问题。以下是关键要点:

  • 复杂的人工智能需要大量的电力、计算机硬件和时间来创造
  • 制造更复杂的人工智能会产生递减的回报
  • 大多数人工智能目前只关注结果，而不是环境影响

下期帖子再见！

参考

  1. 《绿色人工智能》。ACM 的通信63.12(2020):54–63。

人工智能与信任问题

原文：https://towardsdatascience.com/ai-and-the-trust-problem-cea43d6ccb80?source=collection_archive---------26-----------------------

播客

Ayanna Howard 谈人类与人工智能合作的挑战

苹果 | 谷歌 | SPOTIFY | 其他

编者按:TDS 播客由 Jeremie Harris 主持，他是数据科学导师初创公司 SharpestMinds 的联合创始人。每周，Jeremie 都会与该领域前沿的研究人员和商业领袖聊天，以解开围绕数据科学、机器学习和人工智能的最紧迫问题。

在过去的两年里，人工智能系统的能力已经爆炸了。AlphaFold2、MuZero、CLIP、DALLE、GPT-3 和许多其他模型已经将人工智能的范围扩展到了新的问题类别。有很多值得兴奋的事情。

但正如我们在播客的其他剧集中看到的，从人工智能系统中获得价值不仅仅是提升其能力。越来越多的是，这些额外的缺失因素之一变成了信任。你可以制造你想要的所有强大的人工智能，但如果没有人信任他们的输出——或者如果人们在不应该的时候信任它——你最终可能弊大于利。

这就是我们邀请 Ayanna Howard 上播客的原因。Ayanna 是一名机器人专家、企业家和俄亥俄州立大学工程学院院长，在那里，她专注于人机交互以及在人工智能系统中建立人类信任的因素的研究。她和我一起谈论她的研究，它在医学和教育方面的应用，以及人机信任的未来。

以下是我在对话中最喜欢的一些观点:

  • 只有当一个人相信人工智能能够提供良好的输出时，他才会从人工智能的输出中获得最大的价值。人工智能系统的舒适度和信任度差异很大，很难预测。因此，Ayanna 认为，建立信任不能被框定为一个一刀切的问题，即我们试图对所有用户使用相同的技术。从长远来看，她认为培训和筛选相结合是优化建立信任过程的方法。人工智能支持的分类技术也可以发挥作用，通过预测哪种建立信任的策略更有可能对给定的最终用户起作用。
  • 有一种现象叫做 Gell-Mann amnaesia ，，它指的是我们倾向于相信信息来源，即使我们已经看到他们在我们非常了解的话题上犯了令人尴尬的错误。Ayanna 说这延伸到了人类/人工智能的互动。人类经常过度信任人工智能系统，即使他们已经看到它在一项基本任务或一系列任务中失败。一个成功完成的任务可以弥补几次失败造成的信任赤字。
  • Ayanna 的研究发现，人类倾向于更信任人工智能来完成他们自己最不自信的任务。她怀疑这反映了人类希望将不舒服或具有挑战性的决策交给第三方，而不是对人工智能能力的客观评估。
  • 当我们不积极参与人工智能系统帮助我们完成的任务时，我们特别容易过度信任它们。例如，如果一个人工智能系统提供建议的行动，而一个人类操作员只是被要求接受或拒绝这些建议，他们更有可能离开并盲目地不加批判地接受它们。为了抵消这种趋势，Ayanna 正在试验迫使用户在一组可能的选项中进行选择的系统，迫使他们继续参与解决问题的过程。

你可以在推特上关注 Ayanna，或者我在这里。

章节:

  • 0:00 介绍
  • 1:30 Ayanna 的背景
  • 6:10 神经网络的解释性
  • 12:40 人机交互领域
  • 17:00 偏好问题
  • 20:50 盖尔曼/报纸健忘症
  • 26:35 评估一个人的说服力
  • 31:40 医生和新技术
  • 责任和问责
  • 43:15 社会压力方面
  • 47:15 Ayanna 乐观吗？
  • 53:00 总结

人工智能架构师:新程序员

原文：https://towardsdatascience.com/ai-architects-the-new-programmers-7ed1963d6166?source=collection_archive---------21-----------------------

论编程新范式的本质

图片由来自 Pixabay 的 Ahmad Ardity 提供

人工智能的成功故事已经变得如此普遍，似乎每一个软件都将很快以这样或那样的方式融入人工智能。但是人工智能程序是做什么的呢？人工智能程序可以通过经验学习和适应。构建人工智能程序与构建非人工智能程序的不同之处，正在给我们对编程的理解带来范式转变。在这篇文章中，我探索了新范式的本质以及它可能采取的未来路线。

卡帕西在他的文章“软件 2.0 ”中，描述了一个人工智能触发的范式转变。他想象“程序员 2.0”更多地参与“编辑和增加数据集”，而不是编写代码，他预测对人类开发人员的需求将会下降。他说，给定正确的数据集，人工智能会自己找到正确的算法。我不这么认为。我相信，软件 2.0 将更少地关注数据，而更多地关注围绕可能的算法的搜索空间定义适当的约束。我认为对人类开发人员的需求不会减弱，相反，它的性质会发生变化。

范式分歧

算法是机器可解释指令的有限序列。在旧的范例中，程序员的目标是将一系列指令编织在一起，构成一个单一的、定义明确的算法。在新的范式中，程序员只指定一个模板，该模板编码了多个潜在的算法，机器使用训练数据学习最优算法。模板映射到整个算法空间中的某个区域——所有可能算法的空间。

算法模板的分类

图灵机 (TM)是一个通用模板。它本身编码了所有可能算法的空间。接下来的是，每一个可以想到的算法，本质上都是一个带有规则表的图灵机。规则表规定了精确的执行路径。一种被称为通用图灵机 (UTM)的特殊图灵机可以模拟任何其他图灵机的执行，给定一个规则表作为输入。

艾伦·图灵的导师阿隆索·丘奇(Alonso Church)开发的 Lambda Calculus (LC)是另一个通用模板，相当于图灵机。LC 的美学与 TM 的美学有很大的不同。TM 将计算形式化为根据规则表对一条带上的符号进行操作。LC 将其形式化为通过变量绑定和替换的函数及其解析的堆叠。换句话说，TM 是计算的可视化表示，而 LC 是抽象的、代数式的(见图 1，2)。

图一。图灵机。作者 Gabriel F-Own 作品，CC BY-SA 3.0，【https://commons.wikimedia.org/w/index.php?curid=26270095

图二。通用 Lambda 解释器的 Lambda 表达式。它相当于λ微积分中的 UTM。取自 crypto.stanford.edu/~blynn/lambda/.

TM 和 LC 都跨越了整个算法空间。现在的问题是如何构造只跨越子空间的模板，并在其上进行机器学习。人工神经网络(ANN)利用其可调权重，可以编码和模拟多种算法。人工神经网络并不跨越整个算法空间，除了那些图灵完备的算法空间[1]。因此，他们允许我们通过定制架构创建各种模板。与 TM 和 LC 不同，ANN 编码的算法空间是连续的，支持差分编程，从而更易于机器学习。它也有其局限性，我稍后会谈到这一点。

算法子空间或模板可以组织成树状结构，如图 3 所示。树的根是一个通用的模板，不管是 TM，LC，还是图灵完全神经网络。随着我们向底部移动，模板变得更加具体，因为它们包含越来越小的算法家族。叶节点对应于单独的算法。

图 3。算法之树。叶子对应于特定的算法，而非叶子节点对应于算法族。一个算法家族可以通过一些位于底层的特定算法来模拟。UTM 可以模拟任何算法。请注意，该树纯粹是假设的。

重要的是要注意，有无限多的方式来构建这样一个树，虽然其中一些可能更符合我们对世界的先验知识。

风格的差异

软件 2.0 的程序员构造模板需要遵循什么策略？鉴于大数据和相对便宜的计算，一个诱人的方法是从通用模板或大搜索空间开始，让机器搜索最佳算法。与包含工作算法的小区域相比，总的算法空间是无限大的，所以用通用模板学习需要大量的数据和计算。例如， GPT-3 ，一个产生类似人类文本的语言模型，使用了 1750 亿个参数，45tb 的训练数据。原则上，这种数据密集型方法不需要太多的人类专业知识。

另一种方法是从一个小的搜索空间或高度专业化的模板开始。在这里，在将球传给机器之前，需要人类的专业知识来适当缩小搜索空间。如果做得好，在更小的搜索空间中学习的成本会变得更低，找到的解决方案更有可能与我们直觉认为的智能一致。一个很好的例子是卷积神经网络( CNN )。CNN 的想法受到了对大脑视觉皮层进行的神经科学研究的启发。CNN 使用局部性和 t 平移不变性的原理，产生共享权重，从而比正常情况下需要更少的自由参数。AlexNet [3]是使用 CNN 的最有影响力的计算机视觉模型之一，需要大约 150G 的训练数据和 6100 万个参数。我认为这种方法将在人工智能的未来扮演更重要的角色。为了支持人工智能的这种方法，我将探索它是如何被自然本身用来解决智能和学习问题的。

自然智能的本质

动物和人类不需要像现代人工智能那样需要大量的数据来学习。相反，包括人类在内的幼小动物在与环境互动最少的情况下，学习速度很快。Zador [4]认为这是因为动物天生具有高度结构化的大脑。高度结构化的大脑缩小了可能算法的搜索空间，实现了快速快速的学习。根据上面的图 3，这意味着自然大脑编码的模板不是通用的；相反，它们是高度专业化的。

Zador 还引入了“基因组瓶颈”的概念。基因组瓶颈表明，大脑的接线图过于复杂，无法在基因组中明确指定，这暗示着基因组水平上发生了一些压缩。在这一点上，一个有趣的问题出现了:大自然是如何选择高度专业化的大脑结构，同时保持可压缩性的？这个问题的答案将揭示软件 2.0 的有趣线索。

自然的本质

林等人[5]曾无意中回答过这个问题。他们表明，描述宇宙的物理方程需要定义的参数比预期的少得多。他们认为，因为宇宙遵循对称、组成、位置和等级形式的原则，所以试图模拟其规律的方程也是如此。由此可见，在宇宙中导航的最佳算法也遵循相同的原则，这也解释了深度和廉价学习在图像识别等任务中的成功。

在试图解释深度学习的成功时，作者还回答了关于基因组瓶颈的问题。大自然可能通过选择遵循上述原则的大脑结构来保持可压缩性。换句话说，大脑结构的特殊化不是随机发生的，而是遵循这些高级原则。

我预测软件 2.0 的架构师将利用这些指导原则来构建最佳算法模板。有趣的是，受神经科学启发的卷积神经网络也利用了平移对称性和局部性。请注意，这些原则仅规定了最终解决方案的形式。为了填充适当的内容，我们需要收集更多的知识，并将其转化为软件 2.0 的细节

语言的诞生

在使用人工神经网络进行深度学习的情况下，将知识转化为算法模板是具有挑战性的。我们更习惯于使用符号语言来获取、操作和交流知识。所以我们把知识翻译成经典的计算机科学概念更直观，这些概念是离散的符号化的。另一方面，现代深度学习在连续域中运行，由于其可微分性，更适合于机器学习，而不太适合于人类推理其工作方式。因此，经典计算机科学和现代深度学习之间的差距是一个有待解决的挑战[6]。我相信 Lambda 演算或函数式编程将在缩小差距方面发挥关键作用(克里斯·奥拉赫认为)。

结论

人工智能引发了我们对编程理解的范式转变。我在这篇文章中认为，新范式的艺术不是编辑和增长大型数据集，而是设计最佳算法模板，以最小的训练数据需求促进快速有效的机器学习。《自然》暗示了实现这一目标的可能途径，但还需要更多的工作来释放神经网络的象征力量。

参考

  1. 西格尔曼，H. T .，&桑塔格，E. D. (1992)。神经网络的计算能力。1992 年第五届计算学习理论年度研讨会会议录。https://doi.org/10.1145/130385.130432
  2. 胡贝尔博士；威塞尔(1968 年 3 月至 2001 年 1 月)。“猴纹状皮层的感受野和功能构筑”。生理学杂志。195(1):215–243。doi:10.1113/jphysiol . 1968 . sp 008455。刊号0022–3751。PMC 1557912 。PMID4966457。
  3. 亚历克斯·克里日夫斯基；苏茨基弗，伊利亚；杰弗里·辛顿(2017 年 5 月 24 日)。“深度卷积神经网络的 ImageNet 分类” (PDF)。ACM 的通信。60(6):84–90。doi:10.1145/3065386。刊号0001–0782。S2CID195908774。
  4. 对纯粹学习和人工神经网络能从动物大脑学到什么的评论。10、 3770 (2019)。https://doi.org/10.1038/s41467-019-11786-6
  5. 林，H. W .，泰格马克，m .，&罗尼克，D. (2017)。为什么深度廉价学习效果这么好？《统计物理学报》*， 168 (6)，1223–1247。【https://doi.org/10.1007/s10955-017-1836-5 *
  6. Velič ković，p .，& Blundell，C. (2021 年)。神经算法推理。图案， 2 (7)，100273。https://doi.org/10.1016/j.patter.2021.100273

人工智能辅助的自动化机器驱动数据标注方法

原文：https://towardsdatascience.com/ai-assisted-automated-machine-driven-data-labeling-approach-afde67e32c52?source=collection_archive---------13-----------------------

用于对象检测、对象识别和分割任务的自动注释解决方案

作者提供的图片:我们的数据模型无关的自动注释工具的示例表示

作者:****Ajay Arunachalam——高级数据科学家&研究员(AI)

你好，朋友们。在这篇博文中，我想分享我们在使用人工智能技术自动生成数据标签方面所做的工作。

我们的完整文章可以在这里找到——https://lnkd.in/gJDKQCY

在我们探讨我们的方法之前，首先让我们通俗地理解什么是数据标记。在机器学习中，数据标注简单来说就是识别原始数据(图像、视频、音频文件、文本文件等)的过程。)，而向添加一个或多个有意义和有信息的标签提供了上下文，以便一个机器学习模型可以学习&从中推断。大多数最先进的机器学习模型高度依赖于大量标记数据的可用性，这是监督任务中必不可少的一步。各种用例都需要数据标记，包括计算机视觉、自然语言处理和语音识别。传统上，这种乏味的标记数据的平凡过程迄今为止主要由人类完成。为了帮助人类从零开始最大限度地减少疯狂的数据标注工作和努力，我们建议一种自动化的算法解决方案，旨在减少大量的人工工作。让我们看一下哪里真正需要这种带标签的数据。在这里，我将谈谈计算机视觉的任务。计算机视觉简单来说就是复制人类视觉(人眼视觉)的复杂性，以及对周围环境的理解。计算机视觉任务包括获取、处理、分析和理解数字图像的方法，以及从真实世界中提取高维数据，以便产生数字或符号信息，例如以决策的形式。在计算机视觉领域，有许多不同的任务。例如分类、检测、分割等，我就不赘述了。但是，下图提供了这些任务的清晰概述&目标，并提供了一个上下文中的对象示例—“Banana”。

一个上下文示例——需要标记数据

分类 vs .检测 vs .语义分割 vs .实例分割，【版权&图片改编自https://www.cloudfactory.com/image-annotation-guide。经允许重新发布]

对于检测目标的监督模型——“香蕉”，标注的标签被馈送给模型，以便它可以学习香蕉像素的表示，并在上下文中定位它们，然后可以使用上下文来推断看不见的/新的数据。实例分割任务旨在检测对象，定位这些对象，并提供它们的数量、大小和形状信息。我们使用一个这样的最先进的实例分割模型—“Mask R-CNN”作为我们框架的核心骨干，但是这里可以根据他们的需求使用任何其他网络架构&目标。我们坚持使用 mask R-CNN，因为它可以有效地检测图像中的对象，同时为每个对象生成高质量的分段掩模。对于 COVID 感染检测的特定测试用例，感染区域的精确位置至关重要，因此像素级检测在这种情况下更合适。

我们的方法

我们工具的流水线如下所示，主要包括检测器和跟踪器、自动标记模块和用于将机器标注的标签输出和保存到磁盘的 I/O 模块。

作者图片:自动化数据标注管道

步骤 1:-对象检测和跟踪以进行像素级分类

定制的弱训练 mask-RCNN 模型用于 COVID 感染检测，具有非常少的标记实例(< 10 个样本)。为了标记感染区域，我们使用 VGG 图像注释器(VIA)图像注释工具。这是一个简单和独立的手动注释软件，用于图像、音频和视频。VIA 在 web 浏览器中运行，不需要任何安装或设置。完整的 VIA 软件可以放在一个小于 400 千字节的独立 HTML 页面中，在大多数现代 web 浏览器中作为离线应用程序运行。VIA 是一个完全基于 HTML、Javascript 和 CSS 的开源项目(不依赖外部库)。VIA 由视觉几何小组(VGG)开发，并在 BSD-2 条款许可下发布，这使得它对学术项目和商业应用都很有用。检测器用于获得被定位的遮罩、包围盒和类。接下来，为了沿着输入视频数据流一致地跟踪和标记多个感染区域，我们使用了 centriod 跟踪算法。下面是我们的 mask-RCNN covid 检测器的一个片段。

步骤 2:-逐帧数据标记

来自预训练的检测器模型的推断用于获得边界框的位置，并创建 json 元数据。一旦使用 Mask-RCNN 对帧进行分割，就会生成相应的感兴趣区域(ROI)。此外，生成每个 ROI 的掩模，然后在整个图像帧上进行轮廓检测。然后，从轮廓中提取(x，y)坐标。最后，将这些形状、区域和坐标属性逐帧保存到磁盘中。下面给出了我们的自动标记算法的片段。

示例—新冠肺炎感染检测和自动标记

我们测试了我们的方法，目标是为 Covid 感染区域生成自动计算机标签。机器生成标签和人工标注标签的结果如下所示。可以看出，自动注释引擎生成相当好质量的合成标签，这些合成标签可以用于重新训练对象检测模型，或者生成可以用于不同任务的更多注释数据。

肺部 CT 扫描中 Covid 感染区域的机器生成标记与人工注释标记的比较，[图片改编自& Copyright:doi:10.1109/tem . 2021.3094544 .经许可转贴]

摘要

数据标注是一项重要的任务，也是监督学习管道的关键组成部分之一。这是一项需要大量手工劳动的任务。那么，我们能不能让大量这种平凡的、劳动密集型和耗时的工作由旨在最大限度减少人类任务的机器来自主驱动。我们专注于这个通用的问题，用我们直观的方法来极大地缓解标签有限的瓶颈，或者自己从头开始标记大量实例的需要。

注意:-我们的工具目前处于 alpha 测试阶段。目前，我们设计的框架是基于掩模 R-CNN 和 VIA 注释格式。我们还旨在将我们的原型一般化，以包括不同的最先进的检测器，例如 YOLO 和相应的 YOLO 兼容注释格式。此外，我们还计划集成 COCO 注释格式。值得将所有不同的图像注释集成为我们框架的一部分，同时为该设施提供不同的库，即 Torch、TensorFlow、Caffe 等。

联系我

你可以打联系我，或者通过 Linkedin 联系我

感谢阅读。

继续学习！！！点击这里查看我的 github 页面

参考资料:-

*https://en.wikipedia.org/wiki/Labeled_data

https://whatis.techtarget.com/definition/data-labeling

https://AWS . Amazon . com/sagemaker/ground truth/what-is-data-labeling/

https://www . geeks forgeeks . org/object-detection-vs-object-recognition-vs-image-segmentation/

https://www.robots.ox.ac.uk/~vgg/software/via/

https://github.com/matterport/Mask_RCNN

https://www . telus international . com/articles/5-面向机器学习项目的数据标注方法

https://engineering . matter port . com/splash-of-color-instance-segmentation-with mask-r-CNN-and-tensor flow-7c 761 e 238 b 46

https://en.wikipedia.org/wiki/Computer_vision https://arxiv.org/abs/1703.06870 *

基于人工智能的图像压缩技术现状

原文：https://towardsdatascience.com/ai-based-image-compression-the-state-of-the-art-fb5aa6042bfa?source=collection_archive---------9-----------------------

一些领先的库和框架的概述

图片来源: Pixabay

什么是图像压缩？

图像压缩包括减少图像的像素、尺寸或颜色成分，以减小其文件大小。这减轻了它们的存储和处理负担(对于 web 性能而言)。先进的图像优化技术可以识别更重要的图像成分，并丢弃不太重要的成分。

图像压缩是数据压缩的一种形式，因为它减少了编码图像所需的数据位，但保留了图像细节。

图像压缩的应用包括:

  • 存储 —压缩后的数据占用更少的磁盘空间，这对于归档详细图像(如医学图像)特别有用。
  • 主成分分析(PCA) —提取图像最重要成分的图像压缩方法用于提取或总结特征和分析数据。
  • 标准化 —在某些情况下，图像集必须符合标准的大小和格式，要求将所有图像压缩成相同的大小、形状和分辨率。例如，安全和政府机构维护的记录需要标准化的图像。

深度学习的图像压缩

深度学习(DL)自 20 世纪 80 年代以来一直用于图像压缩，并已发展到包括多层感知器、随机神经网络、卷积神经网络和生成对抗网络等技术。

多层感知器

多层感知器(MLPs)具有夹在输入神经元层和输出神经元层之间的隐藏层(或多层)或神经元。理论上，具有多个隐藏层的多层线性规划对于降维和数据压缩是有用的。使用 MLPs 的图像压缩涉及整个空间数据的单位变换。

用于图像压缩的初始 MLP 算法在 1988 年公开，并且将诸如空间域变换、二进制编码和量化的传统图像压缩机制合并到集成的优化任务中。该算法依靠分解神经网络来识别压缩比特流输出中的最佳二进制码组合，但是它不能将神经网络的参数固定为可变压缩比。

该算法进一步发展了预测技术，根据周围的像素来估计每个像素的值。然后，MLP 算法使用反向传播来最小化预测像素和原始像素之间的均方误差。

卷积神经网络

卷积神经网络(CNN)与传统的计算机视觉模型相比，卷积神经网络提供了增强的压缩伪像减少和超分辨率性能。细胞神经网络的卷积运算允许它们确定相邻像素如何相关。级联卷积运算反映了复杂图像的特性。

然而，在整个图像压缩过程中结合 CNN 模型是具有挑战性的，因为它需要梯度下降算法和反向传播，这在端到端图像压缩中是具有挑战性的。

CNN 第一次实现图像压缩是在 2016 年，算法由分析模块和合成模块组成。分析模块由卷积、除法和子采样归一化阶段组成。每个阶段以仿射卷积开始，产生下采样输出，然后使用广义除法归一化(GDN)来计算下采样信号。

基于 CNN 的图像压缩改进了 JPEG2000 指标，如峰值信噪比(PSNR)和结构相似性(SSIM)。该算法进一步发展了熵估计，使用称为超先验的尺度。这导致图像压缩性能水平接近诸如高效视频编码(HEVC)的标准。

生成对抗网络

生成对抗网络(GAN)是由两个对立的生成网络模型组成的深度神经网络。首个基于 GAN 的图像压缩算法于 2017 年推出。它产生的压缩文件只有 WebP 的一半大小，比 JPEG 或 JPEG200 小 2.5 倍，比 BPG 小 1.7 倍。该算法还利用并行计算 GPU 核心实时运行。

GAN 图像压缩涉及基于来自输入图像的特征，在微小的特征空间中重建压缩图像。在图像压缩方面，GANs 相对于 CNN 的主要优势是对抗损失，这提高了输出图像的质量。相对的网络被一起训练，彼此相对，增强了图像生成模型的性能。

基于人工智能的图像压缩框架和库

理论上，自己编写整个图像处理应用程序是可能的，但更现实的做法是利用他人开发的内容，根据自己的需要简单地调整或扩展现有软件。许多现有的框架和库提供了用于图像处理的模型，其中许多是在大型数据集上预先训练的。

OpenCV

开源计算机视觉( OpenCV )库提供了数百种机器学习和计算机视觉算法，有数千个函数支持这些算法。这是一个受欢迎的选择，因为它支持所有领先的移动和桌面操作系统，具有 Java、Python 和 C++接口。

OpenCV 包含许多用于图像压缩功能的模块，包括图像处理、对象检测和机器学习模块。您可以使用该库来获取图像数据，并对其进行提取、增强和压缩。

张量流

TensorFlow 是谷歌支持机器学习和深度学习的开源框架。TensorFlow 允许您定制和训练深度学习模型。它提供了几个库，其中一些对于计算机视觉应用和图像处理项目非常有用。TensorFlow 压缩(TFC)库提供数据压缩工具。

您可以使用 TFC 库来创建内置优化数据压缩的机器学习模型。您还可以使用它来识别存储高效的数据表示，例如对模型性能影响极小的影像和要素。你可以把浮点张量压缩成更小的比特序列。

MATLAB 图像处理工具箱

矩阵实验室，或 MATLAB ，既指一种编程语言，也指一个流行的数学和科学问题解决平台。该平台提供了一个图像处理工具箱(IPT)，其中包含各种工作流应用程序和算法，用于处理、分析和可视化图像，并可用于开发算法。

MATLAB IPT 实现了图像处理工作流程的自动化，应用范围从降噪和图像增强到图像分割和 3D 图像处理。IPT 函数通常支持生成 C/C++代码，对于部署嵌入式视觉系统或桌面原型开发非常有用。

虽然 MATLAB IPT 不是开源的，但它提供免费试用。

高保真生成图像压缩

这种高保真的生成式图像压缩是一个 Github 项目，它利用学习到的压缩和 GAN 模型来创建一个有损压缩系统。这对编码爱好者来说很有吸引力，他们可以在 Github 上试验 HiFiC 代码。该模型对于重建压缩图像中的细节纹理非常有效。

结论

在这篇文章中，我讨论了基于深度学习的图像压缩算法的现状，包括多层感知器、卷积神经网络和生成对抗网络。我还展示了可以用来构建基于人工智能的图像压缩应用程序的现成工具:

  • OpenCV —包括数百个机器学习模型，包括几个执行图像压缩的模块。
  • TensorFlow —允许您构建和精细定制图像处理和压缩模型。
  • MATLAB 图像处理工具箱 —让您构建图像处理工作流程和算法，包括图像分割和 3D 图像处理。
  • 高保真生成式图像压缩 —一个使用 GAN 模型执行有损压缩的开源项目。

我希望这将有助于您评估深度学习在图像压缩和优化项目中的使用。

人工智能盲点—第一部分

原文：https://towardsdatascience.com/ai-blindspots-part-i-shared-responsibility-5e05824c19b4?source=collection_archive---------36-----------------------

分担责任

沙欣·高赫尔博士

AI 和技术是环境。人工智能也被吹捧为所有企业的灵丹妙药，企业之间开始了巨大的举措，数百万人被投入到创建“人工智能解决方案”中。人工智能嵌入了我们的生活，并以各种方式影响着我们的生活，这些方式在奖励和兴奋与担忧之间摇摆不定。

在这一系列帖子中，我将重点介绍一些 AI 盲点，如何发现它们以及如何避免它们。在第一部分——分担责任中，我们将更仔细地看看围绕人工智能中的道德和责任的讨论。在 第二部分——感受授权 中，我们将讨论 Gartner 报告的导致人工智能计划巨大失败率的陷阱，并分享一些如何避免它们的技巧。在 第三部分——团队动力 中，我们将谈论汤姆·布拉迪和团队合作。

让人工智能负责是最近的热门话题，受到了很多关注[1][2]。我衷心欢迎这些讨论。不可否认人工智能的变革力量，以及它对我们的生活和生计直接、间接甚至悄悄地产生的影响。随着对使用人工智能进行自动决策的负面影响的认识不断增加[3][4[5][6]，人们越来越担心其对弱势群体的过度影响[7][8]。进行这些对话的重要性怎么强调都不为过。围绕算法的公平性和可解释性，有大量的研究正在进行。然而，只关注人工智能只能让我们了解故事的一半。在这篇文章中，我建议将讨论主题从“负责任的人工智能”改为“负责任地使用人工智能”。迫切需要通过邀请所有参与人工智能业务的各方——构思、构建、交付、传播和接收——来使对话更具包容性和多样性。拥有合适的讨论主题和所有相关方的参与将有助于我们共同实现负责任和合乎道德地使用人工智能的目标，并能够使用它来改善人类。

作者图片

尽管它周围有着神奇的光环，但在它的核心，人工智能是一个决策工具。应该像对待任何其他工具一样，以同样的严格性和质量控制期望来对待它。它是一种工具，可以做出预测，然后用来做决定和采取某些行动。我喜欢把人工智能看作是数据驱动的类固醇决策。

让我们休息一会儿，做一个思维实验。看下面三张图。

(左)乔纳森·肯珀在 Unsplash |(中)格伦·汉森在 Unsplash |(右)克里斯·阿蒙在 Unsplash

在剑造成伤害的情况下，谁应该对造成伤害负责，谁应该为剑伤的身体、精神和情感治疗买单？剑，剑的制造者还是剑的使用者？在现实世界中，造成伤害的责任完全在于挥剑的人。

同样，如果一家企业决定使用人工智能来做决定，而这些决定的结果是有偏见的、歧视性的和有害的，那么不负责任的使用的责任就在于决策者。无论决策是外包给咨询公司还是 AI，客户安全和公平待遇的最终责任完全在于企业。责任由你承担。你是老板。

作者图片

人工智能优化它被告知要优化的东西。关键是你要问正确的问题。你可能会说，“我知道如何经营企业，那是我的工作。我不知道 AI 是怎么工作的。我没有 STEM 学位或博士学位。”这是一个有效的论点，幸运的是你不需要这么做。知道如何使用和知道如何构建是两个不同的需求。汽车是一个很好的类比——我们知道如何驾驶汽车，我们了解交通标志和规则，我们知道如何加油，我们中的一些人甚至可以更换漏气的轮胎！订购汽车并不要求我们知道如何制造汽车，而是要求我们知道如何正确使用汽车。订购一个 AI 模型也是如此。如果你要为你的企业订购重型机械，常识性的清单可以在订购人工智能时重新使用。不要求理解制造机器的机械和电气工程的细微差别，但是您需要问以下问题:

(左上)图为特洛伊·莫蒂耶在上 |(上中)图为米卡·鲍梅斯特在上 |(右上)图为上维奥利塔·彭考斯卡在上【左下角】图为特洛伊·莫蒂耶在上 |(右下)图为

这台机器是做什么的？它会导致生产率的提高吗？生产率的提高是否证明购买、维护、储存和人员培训的费用是合理的？它符合安全标准吗？它有什么样的安全功能？靠谱吗？操作起来有多复杂，需要多少培训才能最佳地使用它？是否存在任何可能妨碍实际使用的基础设施缺口？几乎是适用于采用任何新工具或产品的标准投资和风险评估活动。

人工智能有潜力改变商业并刺激创新。如果你问正确的问题，并关心你的业务和你的客户，你可以利用人工智能的力量来提高利润和生产力，同时为你的客户提供公平和增强的体验。在这个系列的第二部分，我将分享一些百万美元的问题。毫不夸张地说。提前问这些问题可能会让你避免失败的计划和由此带来的经济损失，潜在的公关灾难，甚至在一些极端情况下的诉讼。敬请关注。

@Shaheen_Gauher

观点是我自己的，不反映我过去或现在的工作地点。

如果你发现这篇文章相关，请分享和传播！

确认:

非常感谢 Mary Wahl、Christy Fletcher 和 Miguel Fierro 的审核和宝贵反馈。

参考资料:

[1]https://www . NIST . gov/news-events/news/2019/07/NIST-releases-draft-plan-federal-engagement-ai-standards-development

[2]https://digital-strategy . EC . Europa . eu/en/policies/European-approach-artificial-intelligence

[3]https://www . nytimes . com/2019/08/20/upshot/housing-discrimina tion-algorithms-hud . html

[4]https://www . nytimes . com/2021/03/15/technology/artificial-intelligence-Google-bias . html

[5]https://www . Brookings . edu/research/credit-denial-in-the-age-of-ai/

[6]https://www . wired . com/story/Google-Microsoft-warn-ai-may-do-dumb-things/

[7]https://ncrc . org/the-Washington-post-racial-bias-in-a-medical-algorithm-favors-white-patients-over-sicker-black-patients/

[8]https://www . technology review . com/2020/12/04/1013068/algorithms-create-a-poverty-trap-lawyers-fight-back/

人工智能盲点—第二部分

原文：https://towardsdatascience.com/ai-blindspots-part-ii-feeling-empowered-529ba079e945?source=collection_archive---------35-----------------------

感觉被授权了

沙欣·高赫尔博士

在 AI 盲点 系列的第一部分中，我们谈到了在订购 AI 模型之前要进行的标准风险和投资评估。在第二部分中，我们将讨论作为一个企业主，你如何能够感到被授权提出问题，这些问题可以帮助你防止和减轻对人工智能的潜在不负责任的使用。作为决策者，你是关键。我将问题分为技术类和非技术类，下面我们只关注不需要 STEM 学位、博士学位或任何线性代数或微积分知识的非技术类问题。

在订购人工智能模型之前，向人工智能供应商提出的一些重要问题是——如何获得构建模型的数据？数据是否代表您的客户，并反映了客户的多样性？AI 模型的训练数据的模式(或小样本)是否可用？这就好比在食用之前先看一下食品标签上的成分表。把模型训练数据更深入的分析留给技术团队。

这个疫情给我们上了很多课，其中一课是关于拥有高质量数据的重要性。没有数据就无法进行数据科学。作为一名高管，虽然你不需要知道如何处理或准备数据来建立模型，但如果你希望使用人工智能，你必须了解人工智能的基本数据要求。人工智能需要一致、关联、完整和正确的数据，这比你对仪表板和报告工具的传统数据要求高得多。数据的质量和完整性很重要。数据的数量很重要。数据是人工智能的食物。你喂给你的人工智能什么将决定你的人工智能的整体健康状况。

作者图片

如果人工智能用例包括监督学习(超过 90%的业务用例构成监督学习)，那么要问的百万美元问题是，“数据是如何标记的，谁在标签上签字？”标签是你的人工智能将要学习的基本事实。标注数据需要深厚的领域专业知识，并且可能非常昂贵。不正确、错误或不一致的标签会导致不良模型。重要的是要明白人工智能并不建立地面真相；它从中学习并复制它。如果你不相信地面真理可以被建立，你可能会避免走进一个失败的人工智能计划。对尚未获得正确数据的可能性保持开放的心态，并准备转移对数据收集和数据标记的关注。这种数据投入，未来会产生 AI 红利。

作者图片

再者，如果真相令人不安，重新考虑使用 AI。回想一下下面电影《漂亮女人》中的卷轴人生例子。如果你的员工被训练成拒绝顾客，并根据他们的长相、来自哪里或看起来是否贫穷来描述他们，人工智能很可能会继承偏见、糟糕的商业政策和错误。把一个能自动决定谁进谁出的人工智能放在门口并不能解决问题！

prettywoman #juliaroberts 来源:https://www.youtube.com/watch?v=VxcU4q6KLyA

使用人工智能将修复过去的错误和不良做法的想法是一厢情愿的，而且是有害的。人工智能从例子中学习(这些例子来自你数据库中的商业数据)。如果你的业务的历史数据带有偏见，过去的错误根深蒂固，人工智能模型将学习同样的行为[1][2]。作为决策者，在签署任何人工智能建模之前，你绝对必须理解这一点。

最后但并非最不重要的问题是如何评估和衡量人工智能模型的有效性。作为老板，你不需要被精确度、召回率、RMSE、MAPE 等指标所束缚。虽然它们很重要，但让您的技术团队决定使用合适的指标，并为模型的预测准确性而失眠。从商业和人类的角度来看，重要的是可以量化人工智能决策的影响。无论人工智能解决方案是为过程变化还是自动决策而部署的，过程或经验的前后人工智能变化应该是可测量的。捕捉和收集人工智能决策反馈的机制需要在人工智能部署的同时仔细考虑和建立。这种反馈数据不仅可以监控偏差，还可以帮助迭代和改进人工智能模型。

作者图片

此外，对于关键决策，应该清楚地理解 1 型和 2 型错误[3]对业务成果的影响，并设置防护栏以减轻误报和漏报的影响。此外，当在高风险用例中部署人工智能时，例如在自动化决策可能影响生命、健康或生计的社会、医疗保健和金融领域，应该在药物发布之前采用与制药行业所做的临床试验相同的严格性和测试。人工智能模型应该和临床研究一样坚持同样的透明度和再现性标准。少做一点就是懒惰和不负责任，并可能导致有害的陈规定型观念和不平等永久化。

人工智能具有造福人类的巨大潜力。这是一项强大的颠覆性技术。从人工智能中获益需要聪明地使用它。负责任地使用人工智能需要勤奋，意识到人工智能的盲点，最重要的是谦逊。

@Shaheen_Gauher

观点是我自己的，不反映我过去或现在的工作地点。

如果你发现这篇文章相关，请分享和传播！

确认:

非常感谢 Mary Wahl、Christy Fletcher 和 Miguel Fierro 的审核和宝贵反馈。

参考资料:

[1]https://www . business insider . com/Amazon-build-ai-to-hire-people-discribed-women-2018-10

[2]https://www . healthcarefinancenews . com/news/study-finds-race-bias-optum-algorithm

[3]https://effectsizefaq . com/2010/05/31/I-always-get-follow-about-type-I-and-ii-errors-can-you-show-me-something-to-help-me-remember-the-difference/

人工智能盲点—第三部分

原文：https://towardsdatascience.com/ai-blindspots-part-iii-team-dynamics-e0b6b6b9b79a?source=collection_archive---------32-----------------------

团队动力

沙欣·高赫尔博士

人工智能的前景很诱人。然而，利用这一承诺是另一回事。人工智能计划的成功率仍然很低[1][2]，失败率预计高达 85% [3][4]。除了像技术和基础设施差距这样的硬障碍之外，企业内部还有各种文化和组织瓶颈，它们是计划失败的重要原因。这些是软壁垒。在关于 人工智能盲点 的三部分系列的最后一篇文章中，我们将讨论团队合作、文化和人工智能四分卫。

照片由莱昂在 Unsplash 上拍摄

团队合作

导致人工智能计划失败的最大盲点之一是误解了数据科学家是人工智能解决方案成功的唯一负责人。数据科学确实是一项团队运动，成功取决于所有利益相关方的贡献和贡献。事实上，非数据科学家需要做同样多的工作！我将使用一个足球类比来阐明这个话题(美国流行文化参考警告！).一个 AI 算法可以被认为是一个足球。汤姆·布拉迪也许是一名优秀的橄榄球运动员，但要赢得 2021 年的超级碗橄榄球赛，他需要每一名海盗队员都各就各位，以便达阵得分。人工智能计划中的每个里程碑，即。清楚地定义您希望解决的业务问题，确保数据的完整性和准确性，使用该数据构建模型，将模型部署到生产中，就像获得第一批数据一样。最后，利用预测来做决定是一种尝试。每个里程碑通常由组织的不同部分拥有。人工智能计划最常见的失败标志之一是这些里程碑的所有者之间的不一致。一项成功的计划需要所有各方在共同的目标上保持一致。成功取决于跨职能部门的合作和沟通，以保持将球推进 10 码到达端区。技术团队(例如，数据科学家、工程师)和非技术团队(例如，高管、团队领导、业务分析师)需要合作并一起工作。所有各方都必须对问题有相同的理解，并共同设想解决方案。数据科学家在竖井中构建模型可能会导致解决方案完全偏离目标，并导致手边的计划失败，无论模型有多“准确”和“SOTA”。

作者图片

文化

众所周知，人工智能项目成功的关键驱动因素之一是文化。企业需要积极培育数据驱动的文化，以实现道德人工智能的发展和传播。领导层需要积极弥合人工智能和业务团队之间的权力差异，为协作和思想及道德问题(如果有的话)的流动创造一个安全和尊重的空间。从这次疫情事件中我们可以学到的教训之一也适用于人工智能，那就是政治和科学不能很好地融合在一起，结果可能是灾难性的！

由基思·约翰斯顿在 Unsplash 上拍摄的照片

AI 四分卫

AI 领导有四分卫问题。寻找天才的人工智能领导者就像寻找优秀的四分卫一样具有挑战性。就像四分卫一样，人工智能领袖能够看到球场，能够投球和击球，有力量和韧性进行重大比赛，并带领球队在球场上得分。人工智能领导者将告知和建议人工智能可以做什么，不能做什么以及不应该做什么。第四次工业革命迫切需要投资培养技术领袖。花时间为高风险的人工智能游戏寻找和投资合适的玩家是有回报的。

一个健康的团队动态，有益的文化和四分卫人工智能领导者将永远为成功的人工智能计划铺平道路。人工智能的设计、开发和部署中的透明度和问责制将激发对人工智能系统的信任，并允许我们利用人工智能的力量来造福人类。

@Shaheen_Gauher

观点是我自己的，不反映我过去或现在的工作地点。

如果你发现这篇文章相关，请分享和传播！

确认:

非常感谢 Mary Wahl、Christy Fletcher 和 Miguel Fierro 的审核和宝贵反馈。

参考资料:

[1]https://www . Gartner . com/smarterwithgartner/3-人工智能采用的障碍/

[2]https://www . Gartner . com/smarterwithgartner/how-to-prevent-big-data-analytics-failures/

[3]https://designingforanalytics . com/resources/failure-rates-for-analytics-bi-IOT-and-big-data-projects-85-yikes/

[4]https://www . techrepublic . com/article/85-of-big-data-projects-fail-but-your-developers-can-help-yours-success/

[5]https://en.wikipedia.org/wiki/Super_Bowl

人工智能可以解释任何事情——除了为什么没人听我的

原文：https://towardsdatascience.com/ai-can-explain-anything-except-why-no-one-listens-to-me-33100080b56c?source=collection_archive---------51-----------------------

为什么机器学习(ML)的进步没有完全转化为更好的数据驱动决策？业务线利益相关者和数据科学家如何弥合质量分析和执行变更之间的差距？

人工智能模型不做决定——人做决定。因此，之前没有响应基本分析而执行的任何组织将继续基于尖端 ML 不执行。增加分析的复杂性可能会提高预测的准确性，但也会增加协调的复杂性。我们不能只获得新的工具或能力，并抱最好的希望。相反，我们需要重新想象呈现分析的最后一步，并重新思考如何将 AI/ML 输出转化为决策。

对于数据科学家来说，最终的建议或模型是漫长旅程的产物——提取利益相关者的协调、背景设置、数据争论和仔细分析。但是当该建议被提出时，利益相关者被要求相对快速地对大量新信息做出反应，因此依靠三件事来自信地采取行动。

  1. 理解建议:
    涉众必须理解预期的结果，以及实现该结果所需的杠杆。一个有效的分析负责人将通过以一种可消费的方式交流具体的预测和支持证据，对涉众的理解负责。
  2. 信任推荐者:
    可信的来源需要提供结果。例如，如果技术所有者有质量交付的跟踪记录，或者如果决策者已经接受了分析方法。其他时候，可信度只是一种品牌效应:这就是沃森在空闲时间玩国际象棋和危险游戏的原因。最终，这变成了一个反馈循环，因为执行变更的良好结果建立了推荐其他变更的可信度。
  3. 拥有实施建议的能力:
    高质量的 ML 模型在面对现实世界的操作复杂性时会显得力不从心。实施任何特定建议的人力带宽和技术能力都需要到位。

随着人工智能/人工智能系统在组织中的进一步推广，它们已经:

  1. 增加了推荐的复杂度:
    从根本上说，很难解释AI 算法在做什么。解释 ML 结果类似于医学上的知情同意。受过几十年医学训练的医生需要解释一个医疗程序。但是病人在十分钟前第一次知道了他们的疾病。作为患者，做一个“知情的”决策者意味着什么？手术越复杂，病人就越难理解所有的风险和影响。面对更先进的数据科学技术，决策者变得更难“知情”。
  2. 测试现有工作模式的局限性 :
    改变底层工具，但不改变数据科学团队与决策者的互动方式，不会突然创造一种建立信任或理解的新方式。面对更复杂的过程和利益相关者更难理解的情况，建议的执行变得依赖关系资本。
  3. 实施建议时增加了操作难度 :
    零售商可能会考虑定制定价。借助新的数据管理和分析工具，分析师可以建立一个模型，为每个客户量身定制定价，根据他们所有被跟踪的网络行为创建一个预测的弹性。或者，为了降低复杂性，只需将纽约市的价格提高 2 美元。

因此，虽然 ML 帮助预测变得更加准确和容易，但是执行改变的过程实际上变得更加困难。随着更先进的工具被应用于更棘手的问题，组织必须积极地防止沟通复杂性以同样的速度增长。即使是完美的预测模型也需要买入；因此，不对称地发展能力，使其更能预测赢得认同的能力是没有意义的。

承担一项具有挑战性的任务的最简单的方法是把它分散到更长的时间里。在寻找答案的过程中，商业利益相关者需要更多地参与。如果我们开始构建一个 ML 模型，非技术利益相关者不应该无所事事，想象球在他们的球场之外。相反，他们应该参与进来，审查背景设置描述性输出，表达背景知识，并了解关于正确目标变量的反馈。专家输入只能改进模型；同时，参与批判性思维有助于建立模型本身背后的直觉。

当这种类型的合作成为惯例时，它就变成了生产化之前的快速原型制作过程。第一轮演练将触及分析的所有要点，并成为数据科学和业务线团队之间相互交换信息的框架。没有必要微调模型或浪费时间；创建端到端的 MVP 应该是轻松的，并且可以直接解决上面提到的挑战:

  1. 专注于基本分析组件降低了复杂性 :
    当利益相关者可以看到一砖一瓦构建的最终产品时，答案变得不那么完整。无论是通过快速原型制作，还是其他过程，暴露可消化的子答案有助于最终答案的可消化性。不需要理解深度学习的机制，就可以看到描述两个变量的散点图。
  2. 能够提问更小的问题消除了对整体答案的不确定性:
    当利益相关者开始理解这种方法，并看到数据集时，不确定性或困惑可以得到解决。如果我们等到整个 ML 管道都建立起来了，混淆是非特定地指向整个产品。通过消除每一步的疑虑，最终产品也应该被认为是干净的。
  3. 通过变量工作消除了不可行性的后期发现:
    重新设计利益相关者-分析师互动模型不会创造新的操作能力，但是可以节省大量时间来避免错误的建议。要求业务线积极地一起构建原型，可以让团队明白，在分析的前 15 分钟内，特定的目标方法是不可能的——在几天的数据争论和模型迭代之后，肯定不会在与首席运营官的会议上。

机器学习有能力利用大量数据，并为组织领导层面临的问题提供更好的答案。但是随着分析方法的复杂性增加，数据科学不能变得更加复杂难以理解。致力于更深入的合作途径将会带来更好的最终结果:更好的前期背景设置，分析团队更少的障碍和陷阱，以及决策团队更好地理解输出。

原载于 ein blick:https://ein blick . ai/ai-can-explain-anything-except-why-no-one-listen-to-me

Einblick 是全球首个可视化数据计算平台，创造了与数据最自然的交互。在 https://einblick.ai/product/了解更多关于我们的信息

带 NLP 的 AI 聊天机器人:语音识别+变形金刚

原文：https://towardsdatascience.com/ai-chatbot-with-nlp-speech-recognition-transformers-583716a299e9?source=collection_archive---------3-----------------------

作者图片

用 Python 构建一个会说话的聊天机器人，与你的人工智能进行对话

摘要

在本文中，我将展示如何利用预先训练的工具来构建一个使用人工智能和语音识别的聊天机器人，即一个会说话的人工智能。

安迪·凯利在 Unsplash 上的照片

NLP(自然语言处理) 是人工智能领域，研究计算机与人类语言之间的交互，特别是如何给计算机编程以处理和分析大量自然语言数据。NLP 研究一直专注于让聊天机器人变得越来越聪明。

聊天机器人 是用于通过文本或文本到语音进行自动聊天对话的软件应用，模仿与人类代理的交互。第一个是 ELIZAhttps://en.wikipedia.org/wiki/ELIZA(1966)，它使用模式匹配和替换方法来模拟文本对话(它既不能听也不能说)。目前市场上最先进的是 亚马逊 ALEXA ，这是一款智能个人助理，能够理解用户的声音并与之对话。

在本教程中，我将展示如何使用语音识别 API 和预先训练的 Transformer 模型构建一个对话聊天机器人。我将展示一些有用的 Python 代码，这些代码可以很容易地应用于其他类似的情况(只需复制、粘贴、运行)，并通过注释遍历每一行代码，以便您可以复制这个示例。

特别是，我将经历:

  • 设置环境
  • 使用 Google APIs 进行语音识别
  • 带有转换器的语言模型

设置

首先，我们需要安装以下库:

****# for speech to text** pip install **SpeechRecognition  #(3.8.1)****# for text to speech** pip install **gTTS  #(2.2.3)****# for language model**
pip install **transformers  #(4.11.3)** pip install **tensorflow #(2.6.0,** *or pytorch****)*****

我们还需要一些其他常见的软件包，如:

**import **numpy** as np**

让我们从创建一个空类开始，我们将逐步丰富它。为了测试聊天机器人，我们需要初始化它并运行整个脚本，我将我的机器人命名为" Maya ":

****# Build the AI**
class **ChatBot**():
    def __init__(self, name):
        print("--- starting up", name, "---")
        self.name = name **# Run the AI**
if __name__ == "__main__": ai = **ChatBot**(name="maya")**

作者图片

语音识别

语音识别是 NLP 的一个跨学科子领域，它开发方法和技术，使计算机能够识别口语并将其翻译成文本。第一个语音识别系统(1950 年)可以理解数字，但不能理解单词，IBM**Shoebox(1960 年)是第一个理解并响应少量英语单词的系统。

如今，使用最多的系统是谷歌的 API，使用它们的一个简单方法是通过 演讲识别 库:

**import **speech_recognition** as srdef **speech_to_text**(self):
    recognizer = **sr**.Recognizer()
    with **sr**.Microphone() as mic:
         recognizer.adjust_for_ambient_noise(mic, duration=1)            
         print("listening...")
         audio = recognizer.listen(mic)
    try:
         self.text = recognizer.recognize_google(audio)
         print("me --> ", self.text)
    except:
         print("me -->  ERROR")**

这是我们的聊天机器人类的第一个 NLP 函数，执行语音转文本任务。基本上，它通过将音频信号转换成文本来提供聆听和理解你的声音的能力。你可以通过跑步和试着说些什么来测试它:

****# Run the AI**
if __name__ == "__main__": ai = ChatBot(name="maya") while True:
         ai.**speech_to_text**()**

作者图片(我是在说话，不是在打字)

现在我们需要给人工智能回应的能力。换句话说，我们希望聊天机器人理解输入，产生输出，并大声说出来。让我们给这个类添加一个新函数:

**def **wake_up**(self, text):
    return True if self.name in text.lower() else False**

wake_up 方法确保 AI 在你说出它的名字时做出反应。例如，我将通过说“嘿，玛雅”来激活我的聊天机器人。**

作者图片

一旦聊天机器人听到它的名字，它会说些什么，因此它需要执行一个文本到语音的任务。我将使用谷歌文本到语音库 ( gtts )在文件系统上保存一个 mp3 文件，该文件可以通过库操作系统轻松播放。

**from **gtts** import gTTS
import **os**@staticmethod
def **text_to_speech**(text):
    print("ai --> ", text)
    speaker = **gTTS**(text=text, lang="en", slow=False)
    speaker.save("res.mp3")
    **os**.system("afplay res.mp3")  **#macbook->afplay | windows->start**
    **os**.remove("res.mp3")**

作者图片

您可以像这样测试这两个新函数:

****# Run the AI**
if __name__ == "__main__": ai = ChatBot(name="maya") while True:
         ai.speech_to_text()

         **## wake up**
         if ai.**wake_up**(ai.text) is True:
             res = "Hello I am Maya the AI, what can I do for you?"

         ai.**text_to_speech**(res)**

作者图片(电脑也在说话)

我们还可以对机器人进行编程，让它对一些特定的命令做出反应，就像任何其他虚拟助手一样( Siri、Alexa、Cortana 、…)。例如，我希望我的人工智能在我请求的时候告诉我时间，并在我感谢她的时候做出友好的回应(“她”，是的，我已经爱上她了)。所以我要把这个函数添加到聊天机器人类中:

**import **datetime**@staticmethod
def **action_time**():
    return **datetime**.datetime.now().time().strftime('%H:%M')**

并运行脚本:

****# Run the AI**
if __name__ == "__main__":ai = ChatBot(name="maya")while True:
         ai.speech_to_text()

         **## wake up**
         if ai.**wake_up**(ai.text) is True:
             res = "Hello I am Maya the AI, what can I do for you?" **## action time**
         elif "time" in ai.text:
            res = ai.action_time()

         **## respond politely**
         elif any(i in ai.text for i in ["thank","thanks"]):
            res = **np**.random.choice(
                  ["you're welcome!","anytime!",
                   "no problem!","cool!",
                   "I'm here if you need me!","peace out!"])

         ai.**text_to_speech**(res)**

作者图片

到目前为止，我们已经使用语音识别技术来与我们的聊天机器人交谈，但机器人仍然很笨，因为它不能对任何不是预先确定的事情做出反应。是时候将真正的人工智能放入我们的聊天机器人(Chatbot)内部了，即一个为 NLP 训练的机器学习模型。

语言模型

我将使用 Transformer 语言模型，这是谷歌(2017) 提出的一种新的建模技术，它用注意力机制取代了传统的序列对序列模型(如 LSTM)。这些语言模型可以执行任何 NLP 任务，因为它们动态地理解上下文。最著名的模型有 Google 的 BERT 和 OpenAI 的 GPT ，参数数十亿。

这些型号的主包是 HuggingFace 的 变形金刚 。这是一个流行的工具，它提供了对各种 NLP 任务有用的预训练模型。具体来说，我要用的是 DialogGPT ，这是一个 GPT 模型，由微软根据从 Reddit 中提取的数百万个对话进行训练。

**import **transformers**nlp = transformers.**pipeline**("conversational", 
                            model="**microsoft/DialoGPT-medium**")**

让我们试一试:

**input_text = "hello!"
nlp(transformers.**Conversation**(input_text))**

作者图片

请注意，当前版本的库在您没有指定 pad_token_id 时会给出警告(如上图所示)。为了避免这种情况，您可以将其作为参数添加:

**nlp(transformers.Conversation(input_text), **pad_token_id=50256**)**

此外，管道输出整个对话(从上图中可以看到)，所以我要把整个输出变成一个字符串，只提取聊天机器人的响应。

**chat = nlp(transformers.Conversation(ai.text), pad_token_id=50256)
res = str(chat)
res = res[res.find("bot >> ")+6:].strip()**

最后，我们准备运行聊天机器人，并与我们的人工智能进行有趣的对话。以下是完整的代码:

作者图片

太好了！该机器人既可以像虚拟助理一样执行一些特定的任务(即在被询问时说出时间)，也可以进行随意的对话。如果你认为人工智能会一直存在，她同意:

作者图片

结论

这篇文章是一个教程，展示了如何构建一个像人类一样倾听和回复的对话聊天机器人。我使用语音识别工具来执行语音到文本和文本到语音任务，我利用预先训练的变形金刚语言模型来赋予机器人一些人工智能。现在你可以建立自己的聊天机器人，也许包括更多的虚拟助理任务，如在维基百科上搜索东西或在 Youtube 上播放视频。

我希望你喜欢它！如有问题和反馈，或者只是分享您感兴趣的项目，请随时联系我。

👉我们来连线👈

本文是系列文章 NLP 与 Python 的一部分，参见:

** **

人工智能计算乳腺癌风险图

原文：https://towardsdatascience.com/ai-computed-breast-cancer-risk-map-b29195b477a?source=collection_archive---------19-----------------------

实践教程

结合 Boosting 和支持向量机的层次聚类可视化可靠乳腺癌诊断模型

一.导言

1.1 工作目标

快速可靠的乳腺癌检测是一项重要的挑战，因为它代表了重大的公共卫生问题(2018 年全球约有 200 万例新病例被检测到[1])。在疾病的早期阶段识别恶性乳腺癌会显著增加患者的生存机会，并减少治疗的副作用。

诊断依赖于从可疑肿瘤区域提取的样本分析。该过程旨在评估给定样本是否由代表不受控制的增殖风险的细胞构成。能够在一个时间内分析更多的样本可能会有机会诊断更多的患者，并在需要采取治疗措施时更快地做出反应。出于这个目的，人工智能算法可能会带来很多好处。在需要分析数千甚至数百万个样本的情况下，它们可以用来进行初步选择，并建议哪些样本需要优先进行精确的专家研究。

为此，已经提出了一些机器学习模型(见[2]、[3])来预测恶性或良性肿瘤的发展风险。然而，这些模型是基于从肿瘤细胞成像推导出的许多变量。在这项工作中，我们建议将变量的数量减少到两个。这种维度缩减的目的是形成可视的恶性肿瘤风险图。我们在这项工作中提出:

  • 1.精确分析每个初始变量在预测中的作用。为此，我们采用了一种使用分层聚类(HC)算法的特征聚类方法。第二次，使用梯度推进树分类器(GBTC)算法评估特征重要性。
  • 2.选择在前一步中推导出的两个最有意义的变量。
  • 3.构建支持向量机分类器(SVMC)算法以导出恶性乳腺癌发展的概率风险图。

I.2 数据导入

我们从几个导入开始。

from matplotlib import cm
import seaborn as sn
import matplotlib as matplotlib
import pandas as pd
import pylab as plt
import numpy as np
from scipy.cluster import hierarch# Sklearn imports
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import cross_validate,GridSearchCV
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF

在这项工作中，我们使用 UCI 机器学习数据库[3]收集 569 名患者的数据。当分析肿瘤细胞时，为每个细胞核计算十种特征类型[3]:

  • 1)半径(从中心到周边各点的平均距离)
  • 2)纹理(灰度值的标准偏差)
  • 3)周长
  • 4)面积
  • 5)平滑度(半径长度的局部变化)
  • 6)密实度(𝑝𝑒𝑟𝑖𝑚𝑒𝑡𝑒𝑟 /面积— 1.0)
  • 7)凹度(轮廓凹入部分的严重程度)
  • 8)凹点(轮廓的凹入部分的数量)
  • 9)对称性
  • 10)分形维数(“海岸线近似值”-1)

对于这些特征中的每一个，报告平均值、标准偏差和最大值，这导致总共 30 个特征。分析这些特征中的每一个导致决定肿瘤是恶性的(1)还是良性的(0)。预测将是我们的标签。

首先，我们下载数据并验证不存在“none”值。

# Load the data
feat_all,label_all=load_breast_cancer(return_X_y=True,as_frame=True)feat_all.isnull().sum()mean radius                0
mean texture               0
mean perimeter             0
mean area                  0
mean smoothness            0
mean compactness           0
mean concavity             0
mean concave points        0
mean symmetry              0
mean fractal dimension     0
radius error               0
texture error              0
perimeter error            0
area error                 0
smoothness error           0
compactness error          0
concavity error            0
concave points error       0
symmetry error             0
fractal dimension error    0
worst radius               0
worst texture              0
worst perimeter            0
worst area                 0
worst smoothness           0
worst compactness          0
worst concavity            0
worst concave points       0
worst symmetry             0
worst fractal dimension    0
dtype: int64

现在是时候开始特征选择工作，将我们的问题从 30 维空间简化到 2 维空间。

一.功能选择

在这一部分中，我们首先计算成对相关性，以便重新组合彼此之间最相关的特征。使用层次聚类(HC)算法收集相关特征组。第二次，使用梯度推进树分类器(GBTC)将这种聚类方法与特征重要性评估相结合。

I.1 特征相关性分析

如上所述，我们计算特征之间的成对相关性:

correl_fig,ax=plt.subplots(1,1,figsize=(10,10),)
indexax=np.arange(0,len(feat_all.columns))
sn.heatmap(feat_all.corr())
ax.set_xticks(indexax)
ax.set_xticklabels(feat_all.columns)
ax.set_yticks(indexax)
ax.set_yticklabels(feat_all.columns)
correl_fig.tight_layout()
plt.show()

图 1:所有 30 个特征的成对相关图。

特征选择的第一步是构建相关特征组(注意，使用 Spearman 相关性可以遵循类似的方法[5])。事实上，当特征高度相关时，意味着它们传达了相近或相似的信息。结果，该组的单个特征而不是所有特征可以被考虑用于预测，从而避免冗余。

我们通过使用层次聚类(HC)来构建相关特征的组(更多细节参见[6])。因此，应用了以下过程，该过程能够构建从树叶到根的树(称为 HC 树，其中每个节点代表一个特征集群):

  • 1.首先将每个特征定义为一个簇(HC 树的第 0 层，每个特征是一个叶子)。
  • 2.计算每个聚类之间的距离。如果𝐹k 是聚类 I 中的特征，𝐺𝑡是聚类 2 中的特征，则聚类 I 和 j 之间的距离是𝑚𝑖𝑛_𝑘,𝑡(𝐶𝑜𝑟𝑟(𝐹𝑘,𝐺𝑡)).其中𝐶𝑜𝑟𝑟(𝐹𝑘,𝐺𝑡)是特征 f 和 g 之间的相关性
  • 3.对于给定的簇 I，将其与最接近的一个(记为 j)合并。这种合并由两个合并分支表示，一个来自与 I 相关联的节点，另一个来自与 j 相关联的节点。这些分支形成了表示 I 和 j 之间的合并的树中的上层节点。
  • 4.重复这些聚类合并操作，直到有一个集合了所有特征(对应于 HC 树的根)。

在固定一个级别后，该级别的不同节点产生特征的聚类。更准确地说，如果考虑与一个集群相关联给定节点。与之相连的叶子代表了这个集群中涉及的特征。

corr_fig1,ax1=plt.subplots(1,1,figsize=(10, 8),)# Compute pair wise correlations
corr=feat_all.corr().values# Compute the hierarchical clustering tree
link=hierarchy.ward(corr)
dendro=hierarchy.dendrogram(link,labels=feat_all.columns,ax=ax1,leaf_rotation=90,leaf_font_size=10)
dendro_index=np.arange(0,len(dendro["ivl"]))
corr_fig1.tight_layout()
plt.show()
corr_fig1.savefig("corrtree.png")

图 2:由 HC 算法计算出的树。

corr_fig2,ax2=plt.subplots(1,1,figsize=(10, 8),)# Compute the correlation heat map
im=ax2.imshow(corr[dendro["leaves"],:][:,dendro["leaves"]])
ax2.set_xticks(dendro_index)
ax2.set_yticks(dendro_index)
ax2.set_xticklabels(np.array(dendro["ivl"]),rotation="vertical")
ax2.set_yticklabels(np.array(dendro["ivl"]))
corr_fig2.tight_layout()
plt.colorbar(im)
plt.show()
corr_fig2.savefig("corrmap.png")

图 3:HC 聚类中重排特征的相关热图。

图 2 显示了根据 HC 方法构建的树。通过固定等级 4，看起来可以定义四个不同的特征聚类(参见图 2，HC 树的叶子从左到右:聚类 1，从“平均对称”到“分形维数误差”；聚类 2，从“平均纹理”到“对称误差”；聚类 3，从“平均凹点”到“平均凹度”；聚类 4，从“平均周长”到“周长误差”)。

对于我们的降维问题，因此需要选择不属于同一聚类的特征。图 3 示出了热图相关矩阵，其中重新排列的特征取决于它们的聚类(即遵循图 2 中 HC 树给出的顺序)。

我们确定每个特征的聚类，并将信息存储在字典中。

# Color list of the four feature clusters
color_list=[“red”,”navy”,”black”,”green”]# Fix a level of four in the HC tree to determine feature clusters
clusterlevel=4 # Determine the id cluster list
clusterid_list= hierarchy.fcluster(link,clusterlevel, \criterion=’distance’)# This dictionary will contain the list of features for each 
# cluster
featurecluster_dict = dict()for idx, clusterid in enumerate(clusterid_list):
 if clusterid not in featurecluster_dict.keys():
     featurecluster_dict[clusterid]=dict()
     featurecluster_dict[clusterid][“numfeat”]=[]
     featurecluster_dict[clusterid][“namefeat”]=[]
 featurecluster_dict[clusterid][“color”]=color_list[clusterid-1]
 featurecluster_dict[clusterid][“numfeat”].append(idx)
 featurecluster_dict[clusterid]\
 [“namefeat”].append(feat_all.columns[idx])

I.2 数据预处理

现在，我们对数据进行预处理，以:

  • 1.为未来的机器学习模型规范化特征。这一标准化过程是通过减去平均值并除以每个特征的标准偏差来实现的。
  • 2.在定型集和测试集之间拆分数据。
def preprocess(trainrate=1.0):
    '''
    Load data, normalize and split between training and testing
    sets Input:
      trainrate: [Float] Relative size of the training set Output:
      feat_all:    [DataFrame] All the data features
      label_all:   [DataFrame] All the labels
      featnames:   [List] All the feature names
      featN_all:   [DataFrame] All the normalized features
      feat_train:  [DataFrame] Training features
      featN_train: [DataFrame] Normalized training features
      feat_test:   [DataFrame] Testing features
      featN_test: [DataFrame] Normalized testing features
      label_train: [DataFrame] Training labels
      label_test:  [DataFrame] Testing labels
      normmean_arr:[Array] All the features' means for
                           normalization
      normstd_arr: [Array] All features' standard 
                           deviation for normalization '''
    # Load the data and get the name of all features    feat_all,label_all=\
    load_breast_cancer(return_X_y=True,as_frame=True)
    featnames=np.array(feat_all.columns) # Shuffle the data
    data_all=pd.concat([feat_all,label_all],axis=1).sample(frac=1)    
    label_all=data_all["target"]
    feat_all=data_all.drop("target",axis=1) # Get normalized features    
    StdSc=StandardScaler()
    StdSc.fit(feat_all)
    featN_all=StdSc.transform(feat_all)
    featN_all=pd.DataFrame(featN_all,columns=feat_all.columns)

    # Split between training and testing sets
    trainsize=int(trainrate*len(feat_all.index))
    feat_train=feat_all[:trainsize]
    featN_train=featN_all[:trainsize]
    label_train=label_all[:trainsize]
    feat_test=feat_all[trainsize:]
    featN_test=featN_all[trainsize:]
    label_test=label_all[trainsize:] normmean_arr=StdSc.mean_
    normstd_arr=(StdSc.var_)**0.5 return\ 
    feat_all,label_all,featnames,featN_all,feat_train,\
    featN_train,feat_test,featN_test,label_train,label_test,\
    normmean_arr,normstd_arrtrainrate=0.8
feat_all,label_all,featnames,featN_all,feat_train,featN_train,feat_test,featN_test,label_train,\
label_test,mean_feat,std_feat=preprocess(trainrate=trainrate)

随机选择代表所有数据的 20%的测试集，其余的用于训练。

I.3 确定特性的重要性

我们现在通过评估特征重要性分数来结合这种特征聚类方法。为此，我们建立了一个梯度推进树分类器(GBTC)算法。为了解释什么是 GBTC，我们需要首先澄清什么是决策树。决策树是一种机器学习算法，通常用于回归和决策任务。从由几个特征表征的数据集合中，目的是为每个数据得出决策，如果是回归问题，该决策可以是数字，或者在分类的情况下是离散标签。为了获得决策，通过递归地构造节点来构建树，其中在每个节点上应用这些条件来分割数据(参见图 4)。这些条件是固定的，以便最大化一个标准，如这里的基尼分类标准。

图 4:决策树的示意图，当形成决策节点直到到达叶子时，训练数据被递归分裂。

在每个节点，选择一个特征或特征集合，并且对于它们中的每一个，阈值是固定的(在训练期间使用所考虑的标准来确定所选择的特征集合以及阈值)。根据定义的阈值，数据在不同的节点之间拆分。重复该分裂过程，直到到达具有最小数量数据的节点，或者如果树达到极限深度(这些极限被预先确定为超参数)。这些最终节点被称为叶子，并且每个都与一个决策值相关联。

GBTC 算法是由一组决策树组成的。对于成对的训练特征向量和标签(，yi)，构建该集合使得对于每个，

一定是离易最近的。如果引入损失函数

构建 p+1 决策树对应于找到 T 函数，使得 T(xi)=-Gi。其中 Gi 是损失函数在函数 Hp 上的 xi 梯度。换句话说

当我们在这里将该模型用于分类任务时，通过将 sigmoid 函数应用于构建的 GTBC 函数来获得预测的类别。

关于梯度增强的更多细节在[4]中提供。GBTC 对于回归和分类都是有用的，并且可以被认为是确定特征的重要性。对于给定的特征，其在不同决策树中的平均水平位置被用于评估其在标签预测中的重要性。最重要的特征是那些位于决策树构造之初的特征。它们实际上对应于对决策树构造的数据分割具有最强影响的那些。下面我们介绍一个功能表:

  • 来确定决策树集合的最佳大小。
  • 来训练 GBTC 算法。
  • 评估特征的重要性。
def trainGbc(params,feat_train,label_train,feat_test,label_test,\
setbestestim=False,setfeatimp=False,featurecluster_dict=None):
    '''
     This function trains a gradient boosting algorithm, if 
     required, it determines the best number of n_estimators
     and evaluates feature importances Input:
       params: [Dict] Parameters for the GBTC's construction
       feat_train:  [DataFrame] Training features
       label_train: [DataFrame] Training labels
       feat_test:   [DataFrame] Testing features
       label_test:  [DataFrame] Testing labels
       setbestestim: [Bool] If True, determines the best size
                            of the decision trees' ensemble
       setfeatimp: [Bool] If True determines features' importances
       featurecluster_dict: [Dict] If not None, dictionary of the
                                   feature clusters Output:
       Gbc: [Sklearn Instance] A trained GBTC estimator ''' # If the best number of estimators has to be determined
    if setbestestim: Gbc=GradientBoostingClassifier(**params)
        Gbc.fit(feat_train,label_train) # Determine the best n_estimators
        scoretest_list=[]
        scoretrain_list=[]

        # Compute accuracy scores for training and testing with
        # different n_estimators for pred_test in Gbc.staged_predict(feat_test):
            scoretest=accuracy_score(label_test,pred_test)
            scoretest_list.append(scoretest)
        for pred_train in Gbc.staged_predict(feat_train):
            scoretrain=accuracy_score(label_train,pred_train)
            scoretrain_list.append(scoretrain) # Plot the figure showing the training and testing
      # accuracies' evolution with n_estimators       nestim_fig,ax=plt.subplots(1,1,figsize=(10,8),)
       plt.plot(np.arange(params["n_estimators"]),\
       scoretrain_list,label="Train")
       plt.plot(np.arange(params["n_estimators"]),
       scoretest_list,label="Test")
       plt.legend()
       plt.xlabel("n_estimators")
       plt.ylabel("Accuracy")
       nestim_fig.savefig("nestim.pdf")
       plt.show()
      # Cross validate and fit a GBTC estimator
    else:
       Gbc=GradientBoostingClassifier(**params)
       score=cross_validate(Gbc,feat_train,label_train,\
        cv=5,scoring="accuracy")
       print("Gbc Cross Validation Accuracy (Testing)")
       print(np.mean(score["test_score"]))
       Gbc.fit(feat_train,label_train) #Determine feature importance
    if setfeatimp:
       impfeat_list=Gbc.feature_importances_
       indexsort=np.argsort(Gbc.feature_importances_)
       impfeat_fig,ax=plt.subplots(1,1,figsize=(10,8),)
       pos=np.arange(len(indexsort))+0.5
       plt.barh(pos,impfeat_list[indexsort]) 
       plt.yticks(pos,np.array(feat_train.columns)
       [indexsort],fontsize=10,color="red") # If feature clustering, color the features depending on 
       # their clusters
       if featurecluster_dict!=None:
           for ifeat,featname in\
            enumerate(np.array(feat_train.columns)[indexsort]):
               for clusterkey in featurecluster_dict.keys():
                   if featname in \
                   featurecluster_dict[clusterkey]["namefeat"]:

                         ax.get_yticklabels()[ifeat].set_color\
                        (featurecluster_dict\
                        [clusterkey]["color"])

            plt.xlabel("Importance")
            plt.xscale("log")
            plt.xticks(size=10)
            impfeat_fig.savefig("impfeat.pdf")
            plt.show()
    return Gbc

我们首先需要确定决策树集合的大小来构造 GBTC 估计量。为此，根据所用决策树的数量对训练集和测试集的准确性进行评估。

# Determine the best number of estimators
params=\{"n_estimators":500,"learning_rate":0.01,"min_samples_split":5,"max_depth":4}Gbc=trainGbc(params,feat_train,label_train,feat_test,label_test,setbestestim=True,setfeatimp=False)

可以看出，300 个决策树能够达到大约 0.95 的测试精度和 0.99 的训练精度(见图 5)。因此，我们选择这种规模的决策树集合。修复它，评估 30 个特征中每一个的重要性。

图 5:训练和测试准确率随决策树集合大小的变化。

# Determine feature importance with n_estimator=300
params=\
{"n_estimators":300,"learning_rate":0.01,"min_samples_split":5,"max_depth":4}Gbc=trainGbc(params,feat_train,label_train,feat_test,\
label_test,setbestestim=False,setfeatimp=True,featurecluster_dict=featurecluster_dict)

图 6:根据 GBTC 算法评估特征的重要性。相同颜色的特征名称是那些参加由 HC 推导的相同聚类的特征名称。

我们检查了，在测试集上，具有 300 个估计量的 GBTC 算法达到了 0.951 的精度。

predGBC_test=Gbc.predict(feat_test)
accGBC=accuracy_score(label_test,predGBC_test)
print("Testing Accuracy")
print(accGBC)Testing Accuracy
0.9513684210526315

在图 6 中，我们可以看到“最差半径”和“最差凹点”是属于先前建立的不同聚类的两个最重要的特征。此外，我们还展示了五个最重要特征的配对图。我们可以如预期的那样注意到两个最重要的特征“最差半径”和“最差周长”是强相关的(它们属于相同的特征聚类)。这就是为什么在特征选择过程中“最差周长”被“最差凹点”所取代。

def pairplot(feat_all,label_all,featimp_list):

    '''
    Compute the pair plots from a list of features
    Input:
      feat_all: [DataFrame] All the features
      label_all: [DataFrame] All the labels
      featimp_list: [List] Name of the features to compute the
                           pair plots ''' mostfeat_list=feat_all.columns[np.argsort(\
    Gbc.feature_importances_)][-5:]
    pairplot_fig=plt.figure()
    sns_plot=sn.pairplot(pd.concat(\
    [feat_all[mostfeat_list],label_all],axis=1), hue='target')
    fig = sns_plot
    fig.savefig("pairplot.pdf") featimp_list=list(Gbc.feature_importances_)
pairplot(feat_all,label_all,featimp_list)

图 7:从 GBTC 推导出的五个最重要特征的配对图。

我们引入了一个函数，该函数基于所选择的特征来降低特征(未归一化和归一化)向量的维数。

def selectfeat(feat_selected,feat_train,\
feat_test,feat_all,featN_train,featN_test,featN_all\
,meanfeat_arr,stdfeat_arr): '''
   Reduce the dimensionality of the feature vectors based on
   the feature selected Input:
      feat_selected:  [List] Names of the features selected
      feat_train:  [DataFrame] Training features
      feat_test:   [DataFrame] Testing features
      feat_all: [DataFrame] All the features
      featN_train: [DataFrame] Normalized training
                               features
      featN_test: [DataFrame] Normalized testing
                              features
      featN_all: [DataFrame] All the normalized features
      meanfeat_arr:[Array] All the features' means for 
                          normalization
      stdfeat_arr: [Array] All features' standard 
                           deviation for normalization Output:
      featS_train: [DataFrame] Training selected features
      featS_test: [DataFrame] Testing selected features
      featS_all:  [DataFrame] All selected features
      mean_featS: [Array] Means of the selected features
      std_featS: [Array] Standard deviations of the selected
                         features
      featNS_train: [DataFrame] Training selected and normalized
                                features
      featNS_test:[DataFrame] Testing selected and normalized
                              features
      featNS_all: [DataFrame] All selected and normalized
                              features ''' # Identify selected features' indexes 
    indexfeat1=np.where(feat_train.columns==\
    feat_selected[0])[0][0]
    indexfeat2=np.where(feat_train.columns==\
    feat_selected[1])[0][0] # Determine the means and standard deviations corresponding
    # to the selected features    mean_featS=meanfeat_arr[[indexfeat1,indexfeat2]]
    std_featS=stdfeat_arr[[indexfeat1,indexfeat2]] # Select the features for unormalized and normalized data
    featS_train=feat_train[feat_selected]
    featS_test=feat_test[feat_selected]
    featS_all=feat_all[feat_selected]
    featNS_train=featN_train[feat_selected]
    featNS_test=featN_test[feat_selected]
    featNS_all=featN_all[feat_selected] return  featS_train,featS_test,featS_all,mean_featS,\
    std_featS,featNS_train,featNS_test,featNS_all# Select the two most important variables (unormalized and normalized)
feat_selected=["worst radius","worst concave points"]
featS_train,featS_test,featS_all,mean_featS,std_featS,featNS_train,featNS_test,featNS_all\
=selectfeat(feat_selected,feat_train,feat_test,feat_all,featN_train,featN_test,featN_all)

我们在平面图中绘制两个选定特征的数据，“最差半径”和“最差凹点”。注意，这个二维空间中的数据投影能够识别两个不同的聚类，每个聚类与两个标签中的一个相关联。

def plotlabel(featS_all,feat_selected):'''
   Plot the data using the selected features
   Input:
     featS_all:  [DataFrame] All selected features
     feat_selected:  [List] Names of the features selected ''' label_fig,ax=plt.subplots(1,1,figsize=(10,8),) # Plot the data in the 2D-space
    plt.scatter(featS_all.values[:,0]\
   ,featS_all.values[:,1],c=label_all,\
    cmap=matplotlib.colors.ListedColormap(["red","navy"])) # Plots for the legend
    plt.scatter(featS_all.values[:,0]\
    [np.where(label_train.values==0)[0]][0],\
    featS_all.values[:,1][np.where(label_train.values==0)\
    [0]][0],c="red",label="Malignant") plt.scatter(featS_all.values[:,0\
   [np.where(label_train.values==1)[0]][0],\
   featS_all.values[:,1][np.where(label_train.values==1)\
   [0]][0],c="navy",label="Benign") plt.xlabel(feat_selected[0])
   plt.ylabel(feat_selected[1])
   plt.legend()
   label_fig.savefig("label.png")
   plt.show()# plot the data in the 2D-space
plotlabel(featS_all,feat_selected)

图 8:计划中“最差半径”和“最差凹点”的数据投影。

我们现在的目的是在由两个特征“最差半径”和“最差凹点”形成的二维空间中导出一个函数，以评估发展为恶性乳腺癌的概率风险。为此，下一节将开发一种支持向量机分类器(SVMC)算法

二。从 SVMC 推导出概率风险

在本节中，我们构建 SVC 模型，根据两个先前选择的特征来估计发展为恶性乳腺癌的概率风险。首先我们确定 SVC 的超参数。第二次，模型被用于实现计划中的预测(“工作半径”、“最差凹点”)。最终确定与预测相关的概率估计。

二. 1 超参数的确定

SVC 旨在确定具有相同标签的数据被重新分组的区域。这些区域由边界界定，这些边界被计算以最大化它们与数据之间的距离。这个距离叫做边缘。为了计算特征空间中的距离，可以使用核。使用核作为非线性函数确实能够模拟更灵活的边界，从而对于数据分离更有效。这里，我们采用一个称为 RBF 的高斯型核，它取决于比例参数γ，使得两点 x 和 y 之间的距离为:

因此，必须调整该伽马参数。除此之外，还必须确定影响边界平滑度的正则化因子 C。由于交叉验证研究，两个参数都是固定的。

图 9:核 SVC 能够使边界具有更复杂的形状，从而更有效地进行数据分离。

def crossvalidateSVC(featNS_all,label_all,gammaonly=True): ''' Realize cross validation operations to determine the best
    SVC's hyperparameters Input:
      featNS_all: [DataFrame] All selected and normalized
                              features
      label_all: [DataFrame] Gathers all the labels
      gammaonly: [Bool] True if the gamma parameter is estimated
                        only, if False C is estimated either
   Output:
      bestgamma:  [Float] The best estimated gamma paramater
      bestc: [Float] The best estimated C parameter if gammaonly
                      is False ''' 
    # If just the gamma parameter is estimated  
    if gammaonly:
        param_grid={"gamma":np.logspace(0,2,200)}
        GridCV=GridSearchCV(SVC(),\
        param_grid=param_grid,scoring="accuracy",cv=10)
        GridCV.fit(featNS_all,label_all) gridcv_fig,ax=plt.subplots(1,1,figsize=(10,8),)
        plt.plot(np.array(GridCV.cv_results_["param_gamma"]),\
        np.array(GridCV.cv_results_["mean_test_score"]))
        plt.xlabel("Gamma")
        plt.ylabel("CV Accuracy")
        gridcv_fig.savefig("gridcv.png")
        plt.show() bestgamma=GridCV.best_params_["gamma"]
        return bestgamma # If both gamma and C are estimated
     else:
        param_grid=\
        {"C":np.logspace(-1,1,10),"gamma":np.logspace(0,2,200)}
        GridCV=GridSearchCV(SVC(),\
        param_grid=param_grid,scoring="accuracy",cv=10)
        GridCV.fit(featNS_all,label_all) gridcv_fig,ax=plt.subplots(1,1,figsize=(10,8),)
        plt.plot(np.array(GridCV.cv_results_["param_gamma"])\
       ,np.array(GridCV.cv_results_["mean_test_score"]))
        plt.xlabel("Gamma",fontsize=15)
        plt.ylabel("CV Accuracy",fontsize=15)
        gridcv_fig.savefig("gridcv.png")
        plt.show()
        bestgamma=GridCV.best_params_["gamma"]
        bestc=GridCV.best_params_["C"] return bestgamma,bestcbestgamma,bestc=crossvalidateSVC(featNS_all,\
label_all,gammaonly=False)

图 9:交叉验证准确度(测试平均值)作为伽马参数的函数。

bestgamma,bestc=crossvalidateSVC(featNS_all,label_all,gammaonly=False)
print(“Best Gamma”)
print(bestgamma)
print(“Best C”)
print(bestc)Best Gamma
2.0914343584919426
Best C
2.1544346900318834

我们发现，固定𝛾=2.09 和 C=2.15 能够在 10 倍交叉验证数据集中达到 0.9482 的平均测试精度，标准偏差为 0.043。因此，这两个参数的值将在下文中考虑。

def trainSVC(gamma,c,featNS_train,label_train):

    '''
    Realize a 10-fold cross validation for a SVC model
    and train a SVC model    Input
      gamma:  [Float] The best estimated gamma paramater
      c: [Float] The best estimated C parameter if gammaonly
                      is False
      featNS_train: [DataFrame] Training selected and normalized
                                features
      label_train: [DataFrame] Training labels Output:
     Svc: [Sklearn Instance] Trained SVC model ''' Svc=SVC(C=c,gamma=gamma,probability=True)
    score=cross_validate(Svc,featNS_train,label_train,cv=10)
    print("SVC CV Mean Testing Accuracy")
    print(np.mean(score["test_score"]))
    print("SVC CV Standard Deviation Testing Accuracy")
    print(np.std(score["test_score"]))
    Svc.fit(featNS_train,label_train)
    return Svcbestgamma=2.09
bestc=2.15
Svc=trainSVC(bestgamma,bestc,featNS_train,label_train)SVC CV Mean Testing Accuracy
0.94829178743961352
SVC CV Standard Deviation Testing Accuracy
0.043399848777455924

在测试集上达到的精度为 0.964。

predvalid=Svc.predict(featNS_test)
accvalid=accuracy_score(label_test,predvalid)
print("Testing Accuracy")
print(accvalid)Testing Accuracy
0.9649122807017544

可以看出，将特征集合减少到最重要的特征，对它们进行归一化，并采用如上所述的 SVC 模型，能够稍微提高测试精度，从 GBTC 的 0.95 提高到 0.96(见图 10)。

图 10:GBTC 和 SVC 算法的测试精度比较。

三. 2 预测图

在训练 SVC 分类器之后，在 2D 空间“最差区域”和“最差凹点”中评估其预测。图 11 显示了这些预测。在图 11 和图 12 中，圆形点代表用于训练的点，三角形点代表用于测试的点。

def contpredSVC(Svc,nbpoints,mean_featS,\
std_featS,featS_train,featNS_train,label_train,featS_test,\
featNS_test,label_test,predict_proba=False):'''
   Make predictions in the plan of the two selected features
   using SVC.
   Input:
     Svc: [Sklearn Instance] Trained SVC model
     nbpoints: [Int] Number of points sampling each feature
                      direction
     std_featS: [Array] Standard deviation of each selected
                        feature
     featS_train: [DataFrame] Selected feature training set
     featNS_train: [DataFrame] Selected and normalized feature
                               training set
     label_train: [DataFrame] Training labels  
     featS_test: [DataFrame] Selected feature testing set
     featNS_test: [DataFrame] Selected and normalized feature 
                              testing set
     label_test: [DataFrame] Testing labels
     predict_proba: [Bool] True if a probability risk map
                           is computed, False if label map '''  
    # Determine maximum and minimum normalized values for each
    # selected features and compute the normalized 2D mesh
    minfeat1NS=np.min(featNS_train.values[:,0])
    minfeat2NS=np.min(featNS_train.values[:,1])
    maxfeat1NS=np.max(featNS_train.values[:,0])
    maxfeat2NS=np.max(featNS_train.values[:,1])
    x_arr=np.arange(minfeat1NS,maxfeat1NS,\
   (maxfeat1NS-minfeat1NS)/nbpoints)
    y_arr=np.arange(minfeat2NS,maxfeat2NS,\
   (maxfeat2NS-minfeat2NS)/nbpoints)
    X,Y=np.meshgrid(x_arr,y_arr) # Points (normalized) in the 2D space where the predictions are
    # computed.
    pointstopred=np.array([[X[irange][ipoint],Y[irange][ipoint]]\
    for ipoint in range(len(X[0]))\
    for irange in range(len(X))]) # If a probability risk map is computed
    if predict_proba: # Make prediction with SVC
        valmesh=Svc.predict_proba(pointstopred)
        predsvccont_fig,ax=plt.subplots(1,1,figsize=(10,8),) # Denormalize feature points and plot the predictions 
        denfeat1_arr=pointstopred[:,0]*std_featS[0]+mean_featS[0]
        denfeat2_arr=pointstopred[:,1]*std_featS[1]+mean_featS[1]        
        im=plt.scatter(denfeat1_arr,denfeat2_arr,c=valmesh[:,0],\
        cmap=cm.coolwarm,alpha=1) # If a label map is computed
    else:
        valmesh=Svc.predict(pointstopred)
        predsvccont_fig,ax=plt.subplots(1,1,figsize=(10,8),)
        colors=["red","navy"]

        # Denormalize feature points and plot the predictions 
        denfeat1_arr=pointstopred[:,0]*std_featS[0]+mean_featS[0]
        denfeat2_arr=pointstopred[:,1]*std_featS[1]+mean_featS[1]        
        im=plt.scatter(denfeat1_arr,denfeat2_arr,c=valmesh,
        cmap=matplotlib.colors.ListedColormap(colors),alpha=0.1) # Plot the training data
   plt.scatter(featS_train.values[:,0]\
   [np.where(label_train.values==0)[0]],\
   featS_train.values[:,1][np.where(label_train.values==0)\
   [0]],c="red",s=30,label="Malignant-Training") plt.scatter(featS_train.values[:,0]\
   [np.where(label_train.values==1)[0]],\
   featS_train.values[:,1][np.where(label_train.values==1)\
   [0]],c="navy",s=30,label="Benign-Training") # Plot the testing data
   plt.scatter(featS_test.values[:,0]\
   [np.where(label_test.values==0)[0]],\
   featS_test.values[:,1][np.where(label_test.values==0)\
   [0]],c="red",marker="^",s=30,label="Malignant-Testing") plt.scatter(featS_test.values[:,0]
   [np.where(label_test.values==1)[0]],\
   featS_test.values[:,1][np.where(label_test.values==1)[0]],\
   c="navy",marker="^",s=30,label="Benign-Testing") plt.legend()
   plt.ylim(np.min(featS_all.values[:,1]),\
   np.max(featS_all.values[:,1]))
   plt.xlim(np.min(featS_all.values[:,0]),\
   np.max(featS_all.values[:,0]))
   plt.xlabel(feat_selected[0])
   plt.ylabel(feat_selected[1]) if predict_proba:
        plt.colorbar(im,label="Probability Risk")
        predsvccont_fig.savefig("predsvcproba.png")

        plt.show()
    else:
        predsvccont_fig.savefig("predsvclabel.png")
        plt.show()# Train SVC
nbpoints=150
bestgamma=2.09
bestc=2.15# Plot label map
contpredSVC(Svc,nbpoints,mean_featS,std_featS,featS_train,featNS_train,label_train,featS_test,featNS_test,label_test,predict_proba=False)# Plot probability map
contpredSVC(Svc,nbpoints,mean_featS,std_featS,featS_train,featNS_train,label_train,featS_test,featNS_test,label_test,predict_proba=True)

图 11: SVC 在计划中的标签预测“最差半径”和“最差凹点”。彩色点对应于训练集(圆形)和测试集(三角形)的数据。

在 SVC 分类器的情况下，也可以导出预测的概率。对于预测的标注𝑙𝑖，给定预测𝑙𝑖，数据被标注为 1 的概率由下式给出:

其中常数𝛼和𝛽是在训练过程中通过最大似然优化获得的(见[6])。

使用该模型，图 12 因此在识别的 2D 空间中示出了发展成恶性乳腺癌的估计概率。

图 12:SVC 模型的标签概率评估。它可以被解释为发展为恶性乳腺癌的概率图。

三。结论

这项工作是确定 30 个被提议用来评估恶性乳腺癌风险的变量中最重要的两个变量的机会。通过结合层次聚类算法和使用梯度推进的特征重要性估计来选择特征。使用选择的特征建立支持向量机分类器。

获得的机器学习模型与使用所有 30 个变量的其他模型具有相同的可靠性。这种方法的优点是通过计算易于解释的 2D 风险图来简化风险评估。现在需要更多的数据来证实所确定的区域和趋势。

来源

[1]https://www . wcrf . org/dietandcancer/cancer-trends/breast-cancer-statistics

[2]https://towards data science . com/building-a-simple-machine-learning-model-on-breast-cancer-data-ECA 4 B3 b 99 fa 3

[3]https://towards data science . com/how-to-use-scikit-learn-datasets-for-machine-learning-d 6493 b 38 ECA 3

[4]http://archive . ics . UCI . edu/ml/datasets/breast+cancer+Wisconsin+% 28 diagnostic % 29

[5]https://sci kit-learn . org/stable/auto _ examples/inspection/plot _ permutation _ importance _ multicollinear . html # sphx-glr-auto-examples-inspection-plot-permutation-importance-multicollinear-py

https://en.wikipedia.org/wiki/Hierarchical_clustering

[6]https://sci kit-learn . org/stable/modules/ensemble . html # gradient-boosting

[7]https://scikit-learn.org/stable/modules/calibration.html

人工智能概念和现实生活

原文：https://towardsdatascience.com/ai-concepts-and-real-life-36a51f1917ae?source=collection_archive---------24-----------------------

在过去的两年里，我接触了统计学和数学概念的基础知识，这些知识为我们以 Alexa、Jarvis、Siri 等形式看到的复杂人工智能机器奠定了基础。我觉得这些概念在现实生活中更容易想象。如果我们实际上根据我们在这个世界上的经历来思考这些事情，那么直觉上这些事情是非常清楚的。

人工智能只不过是人类的智能。不是吗？(由 Tejasvi Sharma 利用 Unsplash 上 Yuvraj Singh 的照片和 Unsplash 上拥有摄影的照片设计)

马尔可夫链的概念——“给定现在，未来有条件地独立于过去”。在我们生活中的任何时候，我们只能控制我们的现在，而我们的现在是整个过去的反映，也就是说，来自我们过去的知识和经验定义了我们现在的状况，我们未来的进步完全取决于我们今天是什么样的，以及我们为过渡到未来更理想的状态付出了多少努力。

MAP 和 MLE 估计的概念 —最大似然估计是一种参数估计分布的技术，我们观察到的数据实际上来自该分布。我们对某事的看法完全取决于我们过去所目睹的。基于这些经历，我们试图将它们映射到一个内在的表象或概念上。例如，我们在周围看到有钱有势的人，我们试图根据我们在日常生活中看到的东西，形成他们通常长什么样以及他们有什么特点的概念。

MAP 估计扩展了 MLE 的概念，并且还考虑了我们所拥有的分布的先验知识。在这里，我们对某件事情有一个预先的概念或观点，并且基于我们的大脑对我们在日常生活中遇到的最新发现的确信程度，我们对某件事情的内部表征发生了变化。我们在电影中看到有钱有势的人拥有豪华的房子、汽车和生活方式，我们在脑海中形成了一个关于他们的概念。我们在现实生活中也看到有钱有势的人，但我们的思维更新观念不仅仅是基于我们在现实生活中看到的，而是通过一种混合物，包括我们在电影中看到的先前观念。

联合学习(FL)的概念— 随着设备上的边缘学习因设备上更高的计算可用性而越来越受欢迎，为了确保数据的隐私性，FL 成为在边缘上学习高效和稳健模型的最佳替代方案。合作学习的想法很有前途，在现实生活中也普遍适用，因为单个个体的经验可能不够充分，也可能有偏差。整合朋友或熟人经验的能力让我们对任何事情都有更好的看法。

抽样偏倚的概念— 我们在现实生活中看到的数据总是有偏倚的。这完全取决于我们实际看到的数据样本。稳健的抽样并不能保证，我们在现实生活中看到的对别人有用的东西不一定对我们有用。在现实生活中，我们所目睹和经历的会试图在我们的思想和观点中产生偏见。

探索和利用的概念— 作为人类，我们倾向于承担较小的风险，并且我们总是更喜欢已经有人尝试过并且事实证明很棒的东西。因此，在现实生活中，我们也倾向于利用早期的知识，一般来说，一个人探索过去不太重要的东西的机会非常少。

甘的观念与生成性造型——当我们试图画风景、动物或任何东西时，我们会有一个我们在现实生活中看到的真实场景或艺术品的平行图像。GAN 也通过尝试学习接近理想行为的分布来做同样的事情，正如 GAN 的模式崩溃问题一样，即它最终会学习数据中的特定峰值，我们在现实生活中也是如此，因为我们最终会在大多数时间创建类似的场景。

迁移学习的概念 —它非常适用于现实生活，比如我们所学的东西，或者如果我们有关于某件特定事情的经验，我们会尝试将其应用于不同的任务，并可能结合一些变化或学习所需的变化，以成功适应不同的任务。如果我们知道如何骑自行车，学习骑踏板车会变得更容易，如果我们知道如何骑踏板车，学习骑汽车会变得更容易。

其他一些概念 —

K 最近的邻居，注意是一些更常见的平行关系，人们可以从现实生活中得出，以直观地理解为什么复杂的人工智能机器应该工作。

虽然这些事情在现实生活中看起来很直观，但在深度学习中证明它们并不容易，需要一系列聪明的实验。我们在深度学习中控制不同的旋钮，作为超参数、数据集、模型架构等的一部分。来证明因果关系和相关性。

人工智能设计决策

原文：https://towardsdatascience.com/ai-designs-decisions-1d2524589ad?source=collection_archive---------30-----------------------

约书亚·苏考夫在 Unsplash 上的照片

人工智能决策的调查证据剖析

哈夫洛克·埃利斯说，重要的不是目标的达成，而是途中遇到的事情。他在谈论哲学。在商业中，人工智能是关于目标实现的。一路上遇到的事情，都是决定。

这些决定是 Signal AI 最近对 1，000 名首席执行官进行的调查的焦点，旨在评估人工智能对美国经济的影响。根据这项调查，96%的商业领袖认为人工智能将改变决策，92%的人同意公司应该利用人工智能来增强决策过程。

艾不太确定。

大多数决策不是二元的

无论是调查还是业务主管都不能提供有关决策类型的信息。大多数受访者表示，他们每周在这个过程中花费超过 40 个小时。不足为奇:这大概是他们领薪水的原因，但 80%的领导者声称有太多的数据需要评估，高级管理层正在寻求缓解。AI 在图中的什么位置？

AI 渴望通过在决策阶段激励和指导组织来设定和实现目标。四种决策是相关的。

政策决策包括选择追求什么目标以及如何实现这些目标。技术对公司的适当调整应该定义这些目标。AI 在这一步冒着失败的风险，因为他爱上了创意之火，没有认识到实用的指导方针。

目标应该很少，但不需要非常具体。剩余的可能性被抛弃了。目的分散是一种商业风险。人工智能擅长不适定问题，但众所周知，它会一直徘徊，直到它认为问题得到解决。

任何目标都必须用一个问题来定义。好的设计要求目标的确定应该导致对问题的理解。人工智能可能不擅长理解，但目标的实现被解释为一组解决方案。像任何好的公司故事一样，故事不能像增加额外收入那样泛泛而谈。必须包含一个转变的因素。

人工智能体现了变革，但还没有为政策决策做好准备。人工智能必须首先准备好自己定义问题。然而，这是一个可以实现的目标。例如，人工智能知道如何识别不良组件或不良行为，从而识别症状，进而提出问题。

接着是分配决策。实现目标需要在人员之间分配资源和责任。在帮助组织实现其目标的过程中，有些职位扮演着重要的角色。每个岗位都有特定的职能，企图为企业赚取利润。

一个职位必须解决一个问题。当有疑问时，回到目标设定作为政策决定。

人工智能可以为内部资源赋值，并智能地为项目分配类型和数量。AI 正在考虑接管项目管理的职责，这也符合目标实现功能。企业生活只应该这么简单。其自身角色的定义和人类角色分配的问题超出了当前的技术。然而，一些人力资源官员，如 IBM 的 Diane Gherson，正在基于生成性对抗网络的模型，松散地训练人工智能。

角色冲突是盲目的组织结构图的常见结果，这是非常人性化的发明。人工智能暴露在相互冲突的角色期望中，确保了出现与公司目标无关的问题。《2001:太空漫游》中哈尔的比喻占据了主流意识，尽管参考了科幻小说，但仍是问题的代表。妥协是一个谈判的问题，而不是组织结构图模板。否则，大赦国际将面临负面制裁和内部冲突。哈尔杀了(几乎)所有人。

人工智能承担多种角色，并可以对他们以及公司内其他人的分配进行排序。与他人的关系是由兴趣和取向控制的，这些兴趣和取向与人工智能的兴趣和取向以不同的方式交织在一起。这些差异通过对人工智能索赔的分配进行调整。排序是按照优先级、上下文和收益分配进行的。有些活动有合适的合作伙伴。其他人可能不太适合现有的伴侣、时间和空间。

人工智能角色系统的分配顺序得到了微妙的平衡。一个部分的任何重大改变都可能影响到其他部分，需要进行一系列的调整。人类的反叛随之而来。脆弱是决策过程的一个不良属性。

协调决策包括如何激励员工以及如何管理贡献。薪酬在内部商业计划的讨论中占主导地位。人工智能无法在一个更大的组织中用加薪和相对职位来吸引员工。人们必须接受这个概念，并以这样一种方式接受它，即心甘情愿地接受他们作为机器中杠杆的角色。

人工智能应该提供一种目标感。动机随之而来。

人工智能需要考虑目标实现的这一部分。社会关注人类失业，经济学家预计人工智能保护伞下的职业再培训。再培训在 T2 第一次工业革命中发挥了作用，但是历史记录显示了短期内的巨大痛苦。

当价值观到位时，决策更容易

人工智能在这里有自己的问题要问:是人类为人工智能重组决策，还是人工智能为公司组织流程？答案并不明显，但价值观的引入提供了指导。

支撑价值观 是那些为决策权合法化服务的价值观。这些价值观的定义和传播方式构成了第四套决策。将价值观纳入目标设定是一个不容错过的机会。

决策权提供了一种在不干扰整体公司文化的情况下，催生人工智能文化的手段。

稳定要求雇员的利益与共同的价值体系相一致。公司内部对人工智能行为的反应被构造成对系统忠诚的函数。从众作为实现目标的一种手段，与引起他人的有利反应和避免不利反应的条件相一致。

符合价值标准符合这些标准。从人工智能的角度来看，它是满足其需求的一种模式，也是优化企业内部决策者反应的一种条件。价值模式在人员互动的背景下被制度化。

将人工智能在决策中的作用制度化是公司的期望。

角色期望为人工智能的行为设定了标准。相对于其他人的反应，也有一系列的期望。后者是制裁，反过来可能是正面的，也可能是负面的。人工智能的区别在于它们是促进满足感还是剥夺行动。角色期望和制裁之间的关系是相互的。对 AI 的制裁是对公司的角色期望，反之亦然。

人工智能的决策角色是围绕整合了一套价值观的期望来组织的。同样的价值观支配着与人工智能互补角色的互动。角色期望和相应制裁的制度化是一个程度问题。制度化的对立面是规范秩序的彻底崩溃。这不可能发生。

调查作者有一个收获

人工智能在引导组织通过决策制定阶段时取得成功。这不应该与通过决策取得成功相混淆，也不应该与人工智能辅助增加过程中的细节相混淆。

这份声明一部分是希望，另一部分是恐惧。希望是调查传达的信息，但 Signal AI 首席执行官大卫·贝尼格森指出，商业领袖往往有不切实际的期望。“就像其他技术一样，他们在短期内高估了人工智能的影响，在长期内低估了它。”

决策的四个标准说明了所涉及的困难，而公司内部的期望在这幅画中表现突出。从这个意义上说，贝尼格森是正确的。然而，人工智能不像其他技术；这是第一次向员工提出生存挑战。随着人工智能转向决策，高级管理层也面临着这一挑战。

由于担心技术冲击和监管风险，员工集体低估了人工智能在短期内的影响，纷纷取消或推迟项目。它把一般人工智能的概念作为存在主义争论的核心特征，从而高估了长期影响。

人工智能只是一个婴儿，我们不相信婴儿的决定。他们打碎一路上遇到的东西。

引导你的公司走向道德人工智能

原文：https://towardsdatascience.com/ai-ethics-558db9895bd?source=collection_archive---------42-----------------------

一个全面的战略，使组织能够将道德置于其人工智能建模的核心

照片由 Aaron Burden 在 Unsplash

对于大多数组织来说，人工智能伦理相当于牙线:他们知道这对他们有好处，但他们更喜欢做一些事情——可能是任何事情——其他事情。但是随着来自政府、媒体和国际组织的监督越来越多，公司必须确保他们考虑他们的模型的道德性。

在这篇文章中，我们将探索一个产生负责任的人工智能模型的综合策略。为此，我们将考虑几个因素，包括:( 1) 公平性、( 2 )可说明性和透明度、( 3 )问责制、( 4 )安全性和安全性，以及( 5 )以人为本的水平和对整个社会的益处。

公平的

组织应该通过仔细选择模型的特征、测试模型并采用 IBM 的人工智能公平算法来确保他们的人工智能模型是公平的

目前，我们生活的社会是不公平的，但我们部署的模型应该旨在使社会更加公平。因此，公平应该是一个组织所有模式的核心，尤其是因为歧视会受到严厉的法律处罚。然而，“公平”是一个主观的术语。一方面，公平可以被认为是平等地对待每个人，不管他们的情况如何。然而，另一方面，公平可以被认为是根据每个人自己的情况来对待他们。谷歌的一份报告发现，看似“公平的决定”，比如让弱势群体获得信贷，会对他们的信用评分产生负面影响。然而，机器学习模型没有上下文意识，因此也没有公平性。例如，亚马逊的人工智能招聘筛选模型对男性申请者有偏见，因为历史上男性担任这些角色。虽然没有快速解决实施人工智能模型的组织所面临的任何这些道德问题的方法，但他们应该考虑一个道德框架，这可以在模型的整个生命周期中增加其模型的公平性，包括:

  • 选择功能。歧视可分为两个主要部分:有意的(差别待遇)和无意的(不同影响)。然而，避开不同的影响，并不是简单地删除受保护的功能；一些明显中立的功能可以作为受保护功能的代理。因此，组织应该仔细考虑其模型中使用的每个功能的影响。
  • 采用 IBM 的公平 360。组织应该考虑采用 IBM 的 AI Fairness 360 toolkit 来检测和减轻给定数据集中的偏差。可以在该库中找到的三种偏差优化预处理技术是突出的，包括组辨别、个体失真和效用保持。在整个设计和开发过程中，对于人工智能模型，开发人员应该考虑使用这些技术来最小化算法中的偏差。
  • 验证模型。在开发过程中，组织的开发人员应该测试人工智能模型，包括使用“百分之八十规则”。统计学家经常使用的这条规则是通过将弱势群体的比例除以优势群体来计算的。除此之外，组织应该寻求另一个外部团队来验证模型的性能，特别是从伦理的角度。

关键要点:

  • 组织应该对所有的人工智能模型决策采用公平设计的方法。
  • 公平没有放之四海而皆准的方法。然而，组织应该采纳两个核心原则:第一，记录他们的方法以最小化不同的影响；第二，清楚地证明他们所有的决定。

可解释且透明

为了指导人工智能模型的制作，组织应确保权衡与其模型相关的风险和准确性要求

人工智能模型伦理中的一个关键权衡是模型的准确性和可解释性之间的权衡。一方面，人们很容易相信，在所有情况下，一个更准确的模型比它更难解释的成本更重要。当然，这在一些低风险、低影响的情况下是正确的，比如流媒体服务推荐你接下来应该看哪部电影。然而，另一方面，拥有一个难以解释的模型在很多情况下可能不被接受，比如向客户提供贷款。那么，一个组织应该如何决定他们的模型应该如何解释呢？首先，他们应该权衡风险和准确性要求。第二，如果缺乏透明度是可以接受的，那么组织可以考虑黑盒建模技术(如神经网络、随机森林)。然而，如果可解释性很重要，那么他们应该专注于使用可解释的模型(例如，决策树，逻辑回归)。

随着组织拥抱人工智能，它们应该:

  • 明确可解释性要求。组织应与业务和法律利益相关者一起，考虑其模型的预期可解释程度。
  • 利用你的数据科学家。机器学习算法种类繁多，从高透明(如决策树)、部分透明(如随机森林)、低透明(如神经网络)。因此，组织应该利用他们的数据科学家来确定他们期望的用例所需的透明度级别。
  • 聘请艾伦理学家。组织应该考虑聘用对该模型有深刻理解的人，并且能够根据要求解释该模型产生给定结果的方法。

关键要点:

  • 组织——尤其是银行、政府机构和制药公司——面临大量审查；因此，他们应该专注于让他们的算法变得可解释。为此，他们应该使用高度透明或部分透明的模型，除非使用透明度较低的模型(如神经网络)有明显的竞争优势，超过了与之相关的风险。然而，请注意，在大多数用例中，人类不太可能需要审查人工智能的所有决策，只针对高风险决策。

负有责任的

组织应该确保人工智能模型的设计者、开发者和管理者对他们的解决方案的社会和诉讼影响负责

如果不加检查，算法会影响企业、个人和社会。因此，组织制定人工智能治理政策至关重要。虽然，起初，人工智能的逻辑决策似乎是客观的；人类的判断在模型的设计和开发中起着重要的作用。因此，数据科学家和他们的管理层应该对他们的模型的行为负责。下面的列表探索了三种使组织的人工智能更加负责的方法，包括实施强有力的人工智能治理，定义与人工智能系统的后果相关的责任，以及记录所有道德决策。

  • 治理。在承担任何人工智能建模项目之前，组织应该确保他们为他们的伦理考虑制定了清晰和可理解的政策、标准和程序。因此，最大限度地减少了关于谁对与模型生产相关的任何道德后果负责的混淆。
  • 责任。数据科学家及其管理层应该对他们的模型负责。因此，组织应该确保他们为在人工智能领域工作的员工提供相关的合规培训，以便他们了解自己的责任，以确保团队正在产生一个负责任的、对社会有益的模型。一项《快速公司》的研究发现，50%的开发人员认为开发人工智能模型的开发人员应该对他们模型的后果负责。
  • 文献资料。所有的设计决策都应该清晰地记录下来，并且能够被领导层和程序员所理解。此外，如果一个组织的顾问或承包商离职，他们应该考虑聘请全职伦理学家来监督该模型的整个生命周期，并确保任何道德问题都得到迅速有效的解决。

关键要点:

  • 制定清晰易懂的政策、标准和程序，概述与人工智能模型开发相关的伦理考虑。
  • 数据科学家及其管理层将对组织的客户流失模型的含义负责。
  • 为道德考量制作详细记录。

安全可靠

组织应该确保他们尊重用户的隐私，监控算法，并且不伤害他们的客户

人工智能模型应该以安全的方式实现，包括尊重客户隐私、监控算法和不造成伤害。

  • 尊重隐私。公司越来越多地为客户提供对数据的更大控制权。然而，这种类型的数据隐私优化需要谨慎的平衡行为。一方面，收集更多数据的公司可能面临更大的诉讼处罚风险。然而，另一方面，拥有强大的数据隐私标准的公司可能会放弃数据的金钱利益。那么，组织应该做些什么？最佳策略是收集和使用不比竞争对手更多但也不少的数据。除此之外，组织应该清楚地向其客户阐明其人工智能模型的复杂性。
  • 监控算法。分析团队应确保他们清楚地阐述了人工智能模型的方法。因此，如果关键团队成员离开，组织可以回应客户提出的道德问题。此外，组织应该考虑为人工智能伦理学家创造一个永久的角色，他们将能够在人工智能算法的整个生命周期中对其进行监控。监控过程应包括考虑输入、输出和当地法规。
  • 不伤害任何人。确保人工智能模型系统是而不是用来伤害组织的任何客户。举个例子，一个信用卡客户在管理他们的财务方面遇到了麻烦，可能已经欠下了大量的债务——组织鼓励这个客户向银行借更多的钱是不合适的。相反，组织应该专注于支持客户，帮助他们实现目标。如果这还不值得骄傲，那什么值得骄傲呢？因此，算法应该确保人类可以在必要时介入，以确保算法不会伤害其他个体。

关键要点:

  • 对所有与人工智能模型的设计、开发和测试相关的决策制定采用隐私设计方法。
  • 产生一个以客户为中心的人工智能模型。

以人为本，对社会有益

组织应该确保他们的系统由一个人来管理，对社会有益，并且合法。为了做到这一点，高风险任务将由人来完成，低风险任务将自动完成

在设计和开发人工智能系统时，组织应该考虑各种社会和道德因素，并且组织应该只在收益明显大于风险的情况下生产算法。三项原则在以人为本和造福社会的潜力方面都很突出。这些都是人在回路中，对社会有益的，合法的。

  • 以人为中心。人类应该在任何时候都负责人工智能模型。但这并不意味着人类应该总是认可人工智能做出的每一个决定。然而，组织应该确保高风险决策得到了人类的支持。
  • 对社会有益。人工智能应该积极地扩大社会，特别是帮助解决社会中的重大问题。然而，请注意，并不是所有对社会有益的事情都是以人为中心的。例如，中国的社会信用评分旨在保护整个社会，但它没有考虑个人的隐私需求。
  • 合法。组织应始终确保其人工智能模型和数字解决方案符合所有本地和域外政策、标准和程序，包括 DPA '18、GDPR 和数据共享协议。

关键要点

  • 专注于确保算法有益于最终客户，并符合当地和域外法律。

结论

围绕人工智能的任何伦理问题都没有快速解决方案，有时会让人感到瘫痪。但教训是明确的:组织应该确保他们的系统是公平的，可以向非技术观众解释，由他们的设计师负责，尊重用户的隐私，并对社会有益。然而，更重要的是，通过确保组织将道德置于其所有人工智能模型的核心，他们可以与客户建立信任。因此，这种额外的信任可能会让他们的客户更愿意分享额外的数据，这可能会改善人工智能模型的功效，进而改善他们客户的体验，这可能比降低模型的透明度更重要。这是每个组织的使命——把客户放在第一位。

作为用户体验挑战的人工智能伦理

原文：https://towardsdatascience.com/ai-ethics-as-a-user-experience-challenge-ceb7abb3cd38?source=collection_archive---------24-----------------------

播客

温迪·福斯特在 Shopify 谈道德人工智能设计

苹果 | 谷歌 | SPOTIFY | 其他

编者按:TDS 播客由 Jeremie Harris 主持，他是数据科学导师初创公司 SharpestMinds 的联合创始人。每周，Jeremie 都会与该领域前沿的研究人员和商业领袖聊天，以解开围绕数据科学、机器学习和人工智能的最紧迫问题。

人工智能伦理学通常被视为枯燥、抽象的学术课题。它没有那种一致的、统一的原则，你可能会从计算机科学或物理学这样的定量学科中期待这些原则。

但不知何故，道德橡胶必须符合人工智能的道路，而在这种情况下，真正的开发者必须与真正的用户打交道，并应用具体的道德原则，这就是你在这个主题上找到一些最有趣、最实用的想法的地方。

这就是为什么我想和 Shopify 的工程和数据科学总监温迪·福斯特(Wendy Foster)谈谈。温迪对人工智能伦理的方法是令人耳目一新的具体和可操作的。与更抽象的方法不同，它基于像用户授权这样的明确原则:即你应该避免强迫用户做出特定的决定，而是设计用户界面，将人工智能推荐的操作框定为可以忽略或采取行动的建议。

在这一集的 TDS 播客中，Wendy 和我一起讨论了她对人工智能伦理的实际观点，人工智能产品用户体验设计的重要性，以及负责任的人工智能如何在 Shopify 的产品中得到体现。

以下是我在对话中最喜欢的一些观点:

  • Wendy 的理念是打造尽可能将决策外包给用户的 AI 产品，给用户最大限度的代理。她并没有将推荐系统的输出框定为最优，而是更愿意将它们作为可以采纳或忽略的建议传达给用户。一种方法是依靠设计:例如，按钮颜色、阴影、文本字体和其他风格选择可以传达各种形式的不确定性。虽然实现各不相同，但这里的基本原则是用户授权和增强用户控制。
  • 可解释性经常被吹捧为负责任的人工智能的一个重要因素，但温迪认为解释并不总是最好的方法。首先，解释必须适应最终用户:对 19 岁的技术人员有效的解释可能对 70 岁的人没有意义。解释往往是静态的:它们为用户从人工智能获得的输出提供了一个基本原理，但可解释的人工智能方案往往不会以一种让用户容易提出后续问题的方式运行。由于这个原因，温迪对观察越来越感兴趣，认为观察可以替代解释。在这种情况下，观察意味着让用户有机会以一种动手的方式与他们正在使用的输出算法进行交互。这给了他们调整某些参数的机会，让他们对人工智能有更好的感觉，并知道它会犯什么样的错误。
  • Shopify 能够采用这些策略的原因之一是，他们的用户群具有独特的企业家精神。Shopify 上的商家是那种喜欢建造东西并弄清楚系统工作方式的人，所以当他们看到一个可观察的人工智能机制时，或者当他们看到模糊的“建议”而不是清晰的“建议”时，他们不太可能被吓倒。但并非所有的用户群都是一样的，温迪很快指出，人工智能的伦理原则必须以用户为中心——也就是说，它们必须反映最终用户的特征作为出发点。

章节:

  • 0:00 介绍
  • 1:40 温迪的背景
  • 4:40 练习是什么意思？
  • 14:00 不同层次的解释
  • 19:05 信任系统
  • 24:00 培训新人
  • 30:02 公司文化
  • 34:10 人工智能伦理的核心
  • 40:10 与用户交流
  • 44:15 总结

人工智能-工程伦理

原文：https://towardsdatascience.com/ai-ethics-in-engineering-437ec07046a6?source=collection_archive---------29-----------------------

传统工程师在基于人工智能的物理建模中的偏见——第二部分

作者图片

概要

人工智能伦理在工程中的应用

页岩油井生产中的人工智能道德范例

结论

人工智能伦理在工程中的应用

传统工程师的偏见(包括主要假设、解释和简化)可以包含在人工智能的工程应用中。这通常是通过从数学方程中生成数据，并将其与实际的现场测量结果(实际的基于物理学的数据)相结合，然后使用这组结合的数据，通过人工智能和机器学习算法对物理学进行建模来完成的。在许多情况下，这种方法被称为“混合模型”。在人工智能和机器学习的工程应用背景下，这种模型是对人工智能和机器学习缺乏现实和科学理解的决定。

人工智能的伦理对工程师和科学家来说很重要，他们已经热衷于使用这项技术来解决工程相关的问题。虽然在过去几年中，人工智能伦理已经成为人工智能和机器学习的非工程应用中的一个重要话题，但现在它在这项技术的工程应用中同样重要。下一节将介绍人工智能和机器学习的工程应用中人工智能伦理的一个具体例子，展示猜测、假设、解释和简化如何帮助传统工程师使用人工智能和机器学习算法来生成一个不切实际和高度偏见的预测模型。这通常发生在他们尝试使用事实和实地测量但没有成功的时候。

似乎在人工智能的工程应用中包含这种偏见背后的原因与缺乏对人工智能必须如何用于建模物理现象的科学理解有很大关系。目前，一些声称使用这项技术的工程应用的个人和公司正在包括大量的人类偏见，以便他们在建立一个不包括人类偏见的基于人工智能的模型失败后，可以使用人工智能解决问题。工程中的人类偏见与如何建立数学方程来解决基于物理的问题有很大关系。

图片作者——WestVirginiaU大学 L 实验室为 E 工程 A 应用DAS科学

人工智能和机器学习对工程问题解决的主要贡献是基于实际测量数据对物理现象进行建模，这将是避免偏见、假设、解释和对物理的先入为主的概念背后的主要核心。由于物理现象建模的传统技术是通过数学方程，它通常包括假设，有时还有偏差。当模拟的物理现象看不见、看不到、甚至摸不着时，这是非常正确的，例如石油工程就是这种情况的一个很好的例子，因为生产的碳氢化合物是一种深层地下流体。当包含假设、解释和简化的数学方程被用来模拟物理现象时，任何其他工程学科也是如此。

储层工程、储层建模和储层管理为石油和天然气行业的运营和服务公司贡献了绝大部分收入。这说明了为什么储层建模在石油工业中是一项非常重要的技术。事实上，模拟油气储层中的流体流动包括大量的假设、解释和简化，因为它们位于地表以下数百或数千英尺。这意味着不可能实际观察、触摸或实际测试油气藏中发生的任何事情。

值得注意的是，储层岩石的某些部分通常被带到地表，并在实验室进行测试和分析，以帮助科学家和工程师了解地下深处多孔介质中流体流动的物理复杂性。然而，绝不能忽视关于这种分析的现实事实。虽然碳氢化合物储层具有大约几亿到几百亿立方英尺的体积，但是被带到实验室进行观察和测试的那部分碳氢化合物储层岩石通常小于几立方英尺。此外，众所周知，油气储层是高度非均质的，这意味着在几平方英寸的岩石上进行的实验室分析不能真实地代表整个储层岩石中发生的情况。

因此，尽管实验室岩心分析是理解碳氢化合物储层中流体流动的重要且有用的过程，但是它们不能真实地代表在数百或数千英尺地下的碳氢化合物储层中数百亿立方英尺范围内发生的所有细节和非均质性。这澄清了用于模拟多孔介质中流体流动的数学方程中存在的假设、解释和简化。此外，当碳氢化合物储层是非传统的，例如目前是美国碳氢化合物生产的主要来源的页岩带时，上述问题变得更加复杂，甚至更加重要。

页岩油井生产中人工智能伦理的例子

页岩油气层中完井、水力压裂和流体流动的物理模型中的假设、解释、简化、先入为主的概念和偏差数量如此之多，以至于页岩油井的完井和生产优化的数学模型完全不现实、无用且充满偏差。这是因为了解油气藏中流体流动物理性质的历史细节主要适用于砂岩和碳酸盐岩等常规区块。从十年前开始，这种为常规油藏开发的技术已经推广到非常规油藏。

一个明显的事实是，用于对页岩油井的碳氢化合物生产的物理特性进行建模的数学方程被假设所淹没，并且几乎与事实和现实没有任何关系，因为该技术的主要本质主要适用于常规储层，而不适用于非常规储层。很难找到任何真正的科学家和专业工程师(包括那些已经开发并正在使用这些技术的科学家和专业工程师)声称当前版本的页岩油井水力压裂数学模型与现实有任何关系。

这些事实证明，使用人工智能和机器学习来开发所谓的“混合模型”充满了假设、解释和偏见，与人工智能和机器学习的工程应用现实没有多大关系。当这种数学方程用于产生数据，然后将这种数据与实际油田开发相结合，以建立所谓的“混合模型”时，这种模型可以被强制产生由开发它的人预先确定的输出和结果类型。它消除了机器学习算法的实际和真实特征，这些算法能够基于现实而不是基于猜测和偏见来建模物理。这是一个很好的例子，说明在这项技术的工程应用中，人工智能伦理必须得到解决。

众所周知，当对天然裂缝的非常规储层(如页岩)进行水力压裂时，结果与对常规储层(砂岩)进行水力压裂时的结果截然不同。在页岩中，由于复杂天然裂缝的存在，水力压裂形成了一个“裂缝网络”(如图 1 和图 2 所示)，而不是一个椭圆形的水力裂缝(如图 3 所示的常规油藏)。

如图 1 和图 2 所示，当出于水力压裂目的将液体(水)注入非常规储层时，在注入支撑剂之前，液体开始压裂地层。随着地层开始断裂，断裂的延续将通过岩石中阻力最小的路径。在天然裂缝储层中，阻力最小的路径是天然裂缝网络，而岩石的实际结构(几百万年前没有天然裂缝)具有更大的阻力。因此，天然裂缝储层页岩等非常规资源的水力压裂会产生高度复杂的天然裂缝网络，无法对其进行详细建模。这是因为岩石(页岩)天然裂缝的形状、特征和细节无法在整个储层中观察或测量。非常规油藏中水力裂缝网络的高度复杂形状是非均质性和天然裂缝网络的函数。

作者图片—图 1。天然裂缝储层的水力压裂不能基于真实测量进行建模，因为没有办法识别地下数千英尺的天然裂缝的分布。

作者图片—图 2。天然裂缝储层中的水力裂缝网络

当水力压裂的模型开发在 50 多年前进行时，常规储层中的水力裂缝的形状使用椭圆形进行建模，如图 3 所示。这种传统的水力压裂模型包括四个具体特征，允许使用数学方程对其进行建模。这四个具体特征是(a)裂缝半长，(b)裂缝高度，裂缝宽度，和(d)裂缝传导性。将图 1 和图 2 所示的水力裂缝的形状与图 3 所示的水力裂缝的形状进行比较，可以非常清楚地看出非常规储层与常规储层之间水力裂缝的实际形状有多么不同。

当实际的水力裂缝看起来如图 1 和图 2 所示时，使用图 3 所示的形状对其建模是否有任何意义或与现实有任何关系？这个问题的答案一定很清楚。这是一个很好的例子，说明了数学方程(用于模拟多孔介质中流体流动的物理特性)中包含的假设、解释、先入为主的概念、简化和偏差是如何包含在“混合模型”中的，该“混合模型”将它们与真实的现场测量相结合。

作者图片—图 3。常规油藏水力压裂。

结论

当基于人工智能的模型用于决策时，人工智能的伦理已被证明是一个重要的问题。人工智能伦理学可以揭露工程和非工程问题解决的人工智能应用中可能存在的偏见。几项研究，其中一些在本文中被引用，已经显示了种族主义和性别歧视等偏见是如何被包括在通过人工智能伦理学暴露的基于人工智能的模型中的。这篇文章展示了如何将传统工程师开发的假设、解释和偏见纳入人工智能的工程应用中，这被称为工程中的人工智能伦理。

参考

Crawford 和 t . Paglen，挖掘人工智能，机器学习训练集中图像的政治，2019 年 9 月—【https://www.excavating.ai/

Dastin，亚马逊废除了对女性有偏见的秘密人工智能招聘工具，路透社-旧金山。2018 年 10 月。

https://www . Reuters . com/article/us-Amazon-com-jobs-automation-insight/Amazon-scraps-secret-ai-recruiting-tool-show-bias-against-women-iduskcn 1 MK 08g

戴夫，p。独家谷歌搜索肤色的新措施，以遏制产品的偏见。2021 年 6 月。https://www . Reuters . com/business/sustainable-business/exclusive-Google-searches-new-measure-skin-tones-curb-bias-products-2021-06-18/？UTM _ medium = tech board . fri . media . 2021 06 18&UTM _ source = email&UTM _ content =&UTM _ campaign = campaign

Doshi，介绍包容性图像竞赛，2018 年 9 月 6 日，谷歌人工智能产品经理——谷歌人工智能博客

https://ai . Google blog . com/2018/09/introducing-inclusive-images-competition . html

郝，k。使人脸识别更少的偏见并不意味着它不那么可怕。麻省理工科技评论。技术政策-人工智能伦理。

https://www . technology review . com/2019/01/29/137676/making-face-recognition-less-biased-donts-make-it-less-terrible/

这就是人工智能偏见是如何真正发生的——以及为什么它如此难以修复。麻省理工科技评论。技术政策-人工智能伦理。

https://www . technology review . com/2019/02/04/137602/this-is-how-ai-bias-really-happens and-why-its-so-hard-fix/

Lim，h .，机器学习中的 7 种数据偏差，2020 年 7 月 20 日

https://lionbridge . ai/articles/7-types-of-data-bias-in-machine-learning/

辨别人工智能的真实例子。人工智能算法展示偏见和成见的真实例子。2020 年 6 月。

https://towards data science . com/real-life-examples-of-discriminate-artificial-intelligence-CAE 395 a 90070 sdfg

工程中的人工智能伦理

原文：https://towardsdatascience.com/ai-ethics-in-engineering-65ab23af3f76?source=collection_archive---------31-----------------------

传统工程师在基于人工智能的物理建模中的偏见——第一部分

作者图片

概要

摘要

导言

数据:基于人工智能建模的基础

人工智能伦理解决了基于人工智能的建模中的偏见

摘要

人工智能和机器学习算法开发的预测模型是基于“数据”的，这是众所周知的事实。由于已知数据如何用于构建基于人工智能的模型，人工智能伦理的主要特征是基于模型开发期间使用的数据的质量和数量来解决人工智能模型如何变得有偏差。

当谈到人工智能和机器学习的非工程应用时，已经证明，通过在机器学习算法的训练过程中包含有偏见的数据，人工智能模型中可以包含种族主义和性别歧视等人类偏见。由于人工智能和机器学习的工程应用用于建模物理现象，人工智能伦理学可以确定和澄清传统工程师的人类偏见，包括假设、解释、简化和先入为主的概念，如何用于人工智能和机器学习的工程应用。

图片作者——WestVirginiaU大学 L 实验室为 E 工程 A 应用DAS科学

介绍

核武器最终没有毁灭我们的星球(至少到目前为止)的主要原因与如何处理核弹的全球条约和协议有关。重要的是，世界各地的政治家最终要就人工智能达成一套类似的全球性条约和协议。让许多人担心人工智能在未来几十年将如何影响我们的世界的主要原因之一与几个国家的政府有关。一些国家的政府正在根据他们自己的目标使用这项技术，这些目标是他们对民主的观点、信仰和理解的函数，以及他们成为世界领导者的意图，这些意图基于人工智能如何为他们服务。人工智能的伦理最近已经成为一个重要的话题，必须被已经或正在对人工智能和机器学习算法感兴趣的个人很好地理解。

自 2000 年代中期，基于人工智能的图像识别、语音识别、面部识别、物体识别和自动驾驶汽车接触到世界上大多数人以来，人们对人工智能和机器学习的兴趣显著增加。作为新的科学技术，人工智能和机器学习将在 21 世纪改变很多事情。人工智能已经成为人们、公司和学术界经常涉足的最有趣的技术之一。

例如，最近，银行已经开始使用人工智能和机器学习模型来做出关于向申请人提供贷款的决策的第一步，而大公司的人力资源则使用人工智能和机器学习模型来做出关于雇用谁的决定。从工程角度来看，一些运营中的石油公司对使用人工智能开发基于事实的油藏模拟模型很感兴趣。

银行使用人工智能模型来最大限度地减少他们必须详细评估其特征的申请人数量，而公司使用基于人工智能的模型来评估根据公司的招聘广告申请就业的大量申请人，然后大幅减少实际人力资源专业人员必须集中精力的申请人数量。石油公司使用基于人工智能的油藏模拟的目的是提高他们的石油和天然气产量。人工智能和机器学习被银行和公司用来贷款或雇用个人的方式，使得人工智能的伦理成为一个令人难以置信的重要话题。石油公司关于人工智能和机器学习的工程应用也是如此。

人工智能的伦理对工程师和科学家来说很重要，他们已经热衷于使用这项技术来解决工程相关的问题。虽然在过去几年中，人工智能伦理已经成为人工智能和机器学习的非工程应用中的一个重要话题，但本文将阐述人工智能伦理在该技术的工程应用中的重要性。本文给出了人工智能和机器学习的工程应用中人工智能伦理的具体例子。虽然工程中的人工智能伦理可能与政治没有太大关系(至少在本文中)，但它在很大程度上受到以下因素的影响:(a)缺乏对人工智能的科学理解，(b)在通过人工智能的工程应用解决现实问题方面缺乏成功，或者将传统的工程偏见(包括假设、解释、简化和先入为主的概念)纳入基于人工智能的物理现象模型。

目前，一些声称他们使用这项技术的工程应用的个人和公司正在包括大量的人类偏见，以便他们在建立一个不包括人类偏见的基于人工智能的模型失败后，可以使用机器学习算法解决问题。工程中的人类偏见与如何建立数学方程来解决基于物理的问题有很大关系。

数据:人工智能建模的基础

人工智能使用机器学习算法来开发工具和模型，以实现其目标。基于 AI 的模型的发展与“数据”有很大关系。数据的质量和数量是基于人工智能的模型将如何表现的主要影响。正如上一节提到的，银行已经开始使用人工智能和机器学习模型来做出关于向申请人提供贷款的决策的第一步。人工智能模型通常使用贷款申请人提供的历史数据以及以前的贷款支付结果来开发。正贷款额和负贷款额，以及贷款申请人的输入数据，如性别、种族、信用、居住地点、收入等。将决定为银行贷款开发的基于人工智能的模型的质量。这种模型还可以包括由银行管理层确定的某些特征。

同样的一般方法也适用于大公司人力资源的人工智能模型，以决定雇用谁。这种模型也是利用来自多家公司的现有数据开发的，这些数据涉及申请人以及过去聘用的员工的素质。使人工智能伦理变得非常重要的人工智能的其他应用包括人脸识别、人脸检测、人脸聚类、人脸捕捉、人脸匹配等。这种技术被移动电话、安全、警察、机场等使用。

在人工智能的工程应用中，用于模型开发的数据的特征，包括其质量和数量，会影响基于人工智能的模型的质量。人工智能和机器学习的工程应用是使用实际测量和基于实际物理的数据来模拟物理，而不是使用数学方程来建立物理现象的模型。传统上，在过去的几个世纪中，在任何给定的时间模拟物理都与工程师和科学家对被模拟的物理现象的理解有关。随着科学家对物理现象理解的加深，用来模拟物理现象的数学方程的特征也在增强。

人工智能伦理解决了基于人工智能建模中的偏见

用于构建基于人工智能的模型的数据的质量和数量的特征决定了基于人工智能的模型中是否包含任何偏差。人工智能伦理学的目标是确定用于建立基于人工智能的模型的数据的质量和数量，并通过用于建立模型的数据确定是否有任何偏见(有意或无意)被纳入模型。

人工智能和机器学习被银行和公司用来贷款或雇用个人的方式，使得人工智能的伦理成为一个令人难以置信的重要话题。人工智能和机器学习的工程应用也是如此。只要结合了现实的和非传统的基于统计的机器学习算法，基于人工智能的模型的质量就完全取决于用于建立模型的数据的质量和数量。因此，用于开发基于人工智能的模型的数据完全控制了被开发并用于决策的模型的本质。

随着这项技术向前发展并开始解决更多问题，科学家们开始有兴趣了解更多关于人工智能和机器学习如何工作的细节。很明显，人工智能和机器学习的主要特征是使用数据来提出所需的解决方案并做出决策。由于数据是基于人工智能的模型开发的主要来源，因此了解(a)数据来自哪里以及它的主要来源是什么，以及(b)数据在多大程度上包括人工智能和机器学习可以从中提取模式、趋势和信息的所有所需信息(即使不是显式的)变得很重要。

经过近十年的研究和学习，直到通过检查这项技术的实际应用变得非常清楚，人工智能和机器学习具有政治(Crawford 2019，Lim 2020)、种族主义(Doshi 2018，Dave 2021)和性别歧视(Dastin 2018，Dave 2021)的潜力。这与用于构建人工智能和机器学习模型的数据类型有关。换句话说，创建一个有偏见的 AI 和机器学习模型是很有可能的，它可以做你希望它做的事情。它完全与用于训练和构建模型的数据有关。这就是当传统工程师有意或无意地修改基于人工智能的模型的质量时，人工智能伦理如何解决人工智能的工程应用，以便它将生成他们认为是正确的东西，而不是基于现实、事实和实际测量来建模物理现象。

麻省理工学院的人工智能伦理学发表了一些关于使用人工智能和机器学习时可能发生的偏见的文章。在其中的一些文章中，明确提到“三项新的研究提出了让算法更好地识别不同人口统计群体中的人的方法。但如果没有监管，这将不会遏制该技术被滥用的可能性，”(郝 2019-1)，以及“这就是人工智能偏见真正发生的方式——以及为什么它如此难以修复。偏见可能会在深度学习过程的许多阶段出现，而计算机科学的标准实践并不是为了检测它而设计的。”(郝 2019–2)。

在另一篇有趣的文章中，提到了“收集数据；偏见主要以两种方式出现在训练数据中:要么你收集的数据不代表现实，要么它反映了现有的偏见。例如，第一种情况可能会发生，如果深度学习算法被输入更多浅肤色人脸的照片，而不是深肤色人脸的照片。由此产生的人脸识别系统不可避免地会在识别深色皮肤的人脸方面表现不佳。第二个案例正是亚马逊发现其内部招聘工具正在解雇女性候选人时发生的情况。因为它接受了历史雇佣决策的训练，而历史雇佣决策更倾向于男性而非女性，所以它学会了做同样的事情。本文中提到的是研究结果，这些研究是为了了解如何将偏见纳入模型中。这对人工智能和机器学习的工程和非工程应用来说都是如此真实和非常重要。在本文中，我们将展示在人工智能的工程应用中类似的活动是如何发生的，我们将在下一节解释当人工智能被用来模拟物理现象时什么是偏差。

通过对人工智能和机器学习算法的基础进行一些认真的研究，很明显这项技术在发现用于训练和开发模型、进行预测和帮助决策的数据模式方面有着令人难以置信的强大能力。由于人工智能和机器学习算法所做的一切都与数据有关，因此很明显，只要提供给人工智能和机器学习算法的数据是基于偏见、解释和假设生成的，那么这项技术开发的模型和工作流就成为这种偏见、解释和假设的代表。

pare 2:->https://shahab-mohaghegh . medium . com/ai-ethics-in-engineering-437 EC 07046 a6？postPublishedType=initial

人工智能伦理卖…但是谁在买？

原文：https://towardsdatascience.com/ai-ethics-sells-but-whos-buying-c050054ec44?source=collection_archive---------41-----------------------

欧盟新的人工智能法规草案已经泄露，再次引发了监管与创新的辩论。监管真的会扼杀欧洲的创新吗？

https://www.flickr.com/photos/33195821@N00/4592786358tiseb的【欧盟委员会】由CC 2.0授权

自欧洲人工智能高级专家(HLE)小组提交其可信人工智能伦理指南以来，已经过去两年了。该指南确定了人工智能系统应满足的七个关键要求，以确保其值得信赖:

  1. 人力代理和监督
  2. 技术稳健性和安全性
  3. 隐私和数据管理
  4. 透明度
  5. 多样性、不歧视和公平
  6. 社会和环境福祉
  7. 问责

正如欧盟委员会在 2019 年公布指导方针后对的解释，“委员会将在 2021 年提出一个横向监管提案。该提案旨在通过强制高风险人工智能系统满足与其可信度相关的强制性要求，来保护欧盟的基本价值观和权利以及用户安全。例如，确保有人类监督，以及关于人工智能的能力和局限性的明确信息。”从明确的声明和指导方针本身来看，欧洲委员会非常清楚地表明，不道德地使用人工智能系统将是欧洲的一条红线。

欧洲人工智能条例草案泄露。它的关键方面是什么？

两年后，我们即将看到欧洲人工智能法规的发布，我们已经有了一份泄露的草案版本，几位专家已经对其进行了分析。虽然我分享了西班牙 Xataka 的一些初步想法(西班牙文)，但 The Verge 的这篇文章是一个很好的起点，可以了解一旦最终文件发布，将会受到哪些监管:

https://www.theverge.com/2021/4/14/22383301/eu-ai-regulation-draft-leak-surveillance-social-credit?_lrsc=2d15990e-d572-4abb-8204-ef96852847ea

如果你正在寻找一个快速(但非常有用)的监管关键方面的总结，我也推荐你阅读迈克尔·维尔(@mikarv)的这个帖子:

监管与创新和竞争力

是 Yoav Goldberg 的另一条推文让我写了这篇文章:

他在创新和竞争力与监管之间提出了一个非常好的观点，这让我想起了我大约 3 年前写的一篇文章为什么全球合作是人工智能未来发展的关键。

人工智能会受到不公平的过度监管吗？

后来在同一条线索上，Yoav 提出了另一个非常好的观点，当他们问我对泄露的规定的最初想法时，我也和 Xataka 分享了这个观点:

这是一个敏感的话题。一方面，我完全同意他的观点。为什么我们要对人工智能公司处以高达 2000 万欧元的罚款，因为在线博彩公司通过操纵人的行为或决定已经并仍在造成类似的伤害？

泄露的欧洲 AI 法规草案—https://www . politico . eu/WP-content/uploads/2021/04/14/AI-draft . pdf

泄露的欧洲 AI 法规草案—https://www . politico . eu/WP-content/uploads/2021/04/14/AI-draft . pdf

另一方面，我们现在应该意识到某些特征分析、监控和营销做法可能对边缘化群体造成的伤害，以及人工智能如何有助于放大这种伤害。

我认为这份草案已经存在的事实对欧洲来说是个好消息，因为这意味着至少在明确的监管方案方面取得了进展，同时，我真的觉得这份泄露的版本是在最终版本出台之前征求公众意见的一个呼吁。

监管是要扼杀欧洲的 AI 创新，还是已经死了？

几天前，我们有机会在世界经济论坛上与 AI 的负责人 Kay Firth-Butterfield 讨论，她向我们传达的一个信息是，在当前的世界竞争场景下，欧洲不能允许自己怀疑。缺乏已公布的法规，同时，对法规一旦公布将非常严格的预期，使得欧洲对人工智能的私人投资远低于美国或中国。

2015-20 年按地理区域划分的人工智能私人投资。AI Index Report 2021，在Attribution-no derivatives 4.0 International(CC BY-ND 4.0)下使用，作为其作者允许的。

我们今天分析的泄露的法规可能不是最好的，但至少它开始明确公民的权利和制造人工智能解决方案的公司以及实施这些解决方案的公司/公共机构的义务。

我的两个辩论问题

最后，在监管与创新的二分法中，我们应该问监管和我们自己两个主要问题:

  • 首先，也是竞争力方面最重要的一点:我们是否建立了正确的机制，让创新能够以有竞争力的方式扩大规模？是监管真正扼杀了欧洲的创新，还是随之而来的官僚主义？我们应该让人工智能公司更容易试验和构建解决方案，而没有管理负担或通过复杂的数字创新中心结构。我真的希望最后文件能以明智的方式解决这个问题。

泄露的欧洲 AI 法规草案—https://www . politico . eu/WP-content/uploads/2021/04/14/AI-draft . pdf

  • 我们真的想要在高风险场景(例如，获得司法、工作、医疗保健等)中的创新(不仅是人工智能，还有人工智能)吗？)在可能对某些群体造成伤害和歧视时，不透明、不可解释、不受监督？

让世界变得更美好

这最后一个问题把我们带回了本文的标题。道德销售…但是谁在买？(抱歉不抱歉，我是一个 Megadeth 的音乐迷，如果你抓住了提到他们的专辑，加分)。一方面，我认为人们越来越意识到技术(不仅仅是人工智能)的某些用途的社会影响，良好的道德规范显然会带来品牌忠诚度:

道德领导力与商业 2018 — Salesforce 研究

另一方面，我看到欧洲初创企业的领导者担心这一新规定会降低他们的竞争力。我完全同意欧洲特别擅长制造行政负担，这是这项新法规的一大风险。

试图像美国或中国那样在人工智能领域创新，欧洲已经输掉了这场竞争力竞赛。为什么欧洲不专注于应用技术的不同方式，特别是人工智能，通过帮助应对社会挑战，使我们真正与众不同？拜托，我们不是要让世界变得更美好吗？😃

HBO 硅谷的 TechCrunch 事件恶搞

你认为是什么在扼杀欧洲的 AI 创新？

现在说真的，如果你在欧洲从事人工智能工作，我很乐意通过完成下面的调查来获得你对这个相关主题的投入。你认为欧洲真正扼杀 AI 创新的是什么？也请在评论区留下你的想法。

如果你喜欢阅读这篇文章，请 考虑成为会员 以便在支持我和媒体上的其他作者的同时，获得上的所有故事。

人工智能的可解释性需要鲁棒性

原文：https://towardsdatascience.com/ai-explainability-requires-robustness-2028ac200e9a?source=collection_archive---------12-----------------------

模型可解释性

对抗输入扰动的鲁棒性如何影响模型的可解释性

纳加拉·奥约多在 Unsplash 上的照片

由于它们的不透明性，深度神经网络的明显能力有很大的神秘性。因此，我们经常希望通过对模型行为的解释来更好地了解我们的模型。与此同时，正如我们将看到的,对立例子的存在——已知困扰典型神经网络的—意味着解释将经常难以理解。幸运的是，最近试图寻找训练所谓的健壮模型的方法的努力揭示了一条通向更多可解释模型的道路；也就是说，被训练成对对抗性输入扰动具有鲁棒性的模型表现出更高质量的解释。

解释和可解释性

在机器学习的背景下，一个解释泛指一些帮助我们理解模型行为的结构。最常见的是，这是通过属性方法实现的，该方法量化了模型在特定输入上使用其每个特征的程度。

通常解释的消费者是人类，所以我们需要一种解释解释的方式。例如，在图像分类器的情况下，我们可以通过突出显示模型认为最相关的图像部分来可视化解释。如果一个解释能够传达有用的洞察力，并且能够被检查该解释的人容易理解，则该解释可以被认为是可解释的。同样，如果为模型产生的解释通常对人类有意义，我们通常将模型本身称为可解释的或可解释的。

虽然产生解释的方法有很多，但我们将专注于数学上严格的方法(例如[1])，这些方法产生的解释与模型的实际行为有因果关系，我们将这种属性称为忠实度。这确实是一个非常重要的属性——如果一个直观的解释不能准确描述模型的行为，那么它更容易误导人。因此，我们应该抵制诱惑，通过寻求总是试图产生可解释的解释的解释方法来“改进”我们的解释，因为它们可能偏离忠实于模型。

在这种情况下，我们看到缺乏可解释性实际上是一个 模型 的内在问题。本文的剩余部分将探索这种洞察力的一个关键实例。

对立的例子

对立示例是模型的输入，其中类似于一个类(例如，“熊猫”)，而被模型分类为另一个类(例如，“长臂猿”)。虽然相似性的概念是模糊的，但我们通常认为它意味着一个对立的例子是通过以一种语义上无意义的方式干扰一个自然的输入而得到的，例如，干扰可能小到人眼察觉不到，或者在给定的上下文中仅仅是不明显的。

一个典型的对抗性例子，改编自 Goodfellow 等人【3】，其中一幅熊猫的图像被不知不觉地操纵，以欺骗神经网络预测“长臂猿”。

对立的例子会影响易受其攻击的神经网络的可靠性，并在安全关键的 ML 系统中构成安全问题，因为它们会导致看似良性的输入出现意外的错误行为。

通过更仔细的观察，我们可以清楚地看到，对立例子的存在对可解释性也有影响。具体来说，对立例子的存在意味着，合理的解释可能会和对立例子本身引发的反常行为一样令人困惑。

考虑下面的思维实验(如下图所示)。假设我们有一个图像，比如图中左边的熊猫图像，我们的模型正确地将它标记为“熊猫”。此外，让我们假设将图像角落的一个像素更改为红色会导致模型产生与“熊猫”不同的标签

举例说明一个解释是如何令人费解，但却是合理的。图片作者。

当我们询问模型为什么将原始图像标记为熊猫时，我们可能会得到一个解释，只突出显示图像角落的单个像素，如图所示。虽然这种解释肯定令人困惑，但当我们考虑模型行为的背景时，实际上有一个关于为什么这种解释是合理的争论。毕竟，如果不是原始图像中该像素的值，标签可能不会是“熊猫”。因此，有理由认为该像素在模型决定将图像标记为“熊猫”时非常重要

这表明，为了让一个模型具有可解释性，它必须根据人类基本上可以理解的特征做出决策。此外，如果没有足够的正则化，我们不能期望模型会自然地学习人类可理解的特征。毕竟，有许多方法可以使用与训练数据一致的特征，但是显然不是所有的特征都是可理解的。

稳健模型

为了防御敌对的例子，我们通常的目标是获得所谓的健壮的模型，它可以抵抗恶意的干扰。这些防御通常是为一类特定的对抗性例子量身定制的，这些例子可以在不依赖于人的感知的情况下被精确定义，即小规范对抗性例子。

顾名思义，小范数对抗例子是指扰动的范数低于某个小阈值，通常用ε表示。换句话说，对立示例离原始输入的距离(根据某种度量，例如欧几里德距离)小于ε。就感知而言，当ε足够小时，ε-接近原始输入的任何点将在感知上与原始输入无法区分。

我们说一个模型在一个点 x 上是局部鲁棒的 t，如果在距离xε的距离内的所有点从该模型接收到与 x 相同的标号。因此，我们看到小范数对立的例子不能从模型局部鲁棒的点导出。鲁棒模型通过努力在尽可能多的点上实现局部鲁棒性来抵抗对立的例子。

对于产生稳健模型的各种方法已经有了大量的研究。例如，一个流行的方法系列是对抗训练【4】，其中训练集在训练期间通过对抗扰动来扩充——本质上，网络是根据对抗的例子来训练的。虽然对抗性训练通常提供了一个体面的经验防御，但它并没有提供任何保证让我们知道哪些点(如果有的话)是真正的局部稳健的。

或者，我们可能希望提供可证明的 保证的健壮性，而不是使用像对抗训练这样的启发式防御。例如，GloRo Nets【2】，一种设计为构造稳健的新型神经网络，提供了一种最先进的方法来训练具有稳健性保证的模型。(关于 GloRo Nets 如何实现健壮性的速成课程，请查看我关于这个主题的博客帖子)。

鲁棒性和可解释性

直觉上，当一个模型是鲁棒的时，它不能严重依赖于难以察觉的模式来做出决策——否则，这些模式可能会被不显眼地添加到自然图像中，从而将网络引入歧途，导致对立的例子。易勒雅斯等人[5]在工作中更正式地提出了这一点，他们认为，从广义上讲，在“健壮特征”和“非健壮特征”之间存在着二分法后者负责对立的例子，本质上是不可解释的。另一方面，健壮模型被劝阻不要学习这些非健壮的特征，这意味着它们将主要使用人类至少能够感知的特征，从而提供可解释性的机会。

在实践中，这导致稳健模型展示的解释远比非稳健模型的解释更容易理解。下图显示了这样一个例子。

说明如何提高稳健模型解释质量的示例。图片由作者提供，来源于 MNIST 数据集。

在图中所示的示例中，我们在 MNIST 数据集上训练了两个简单的卷积网络模型:一个使用标准训练进行非稳健训练(下图)；另一个使用 GloRo 训练【2】进行训练，产生一个可证明的 健壮的模型(上图)。然后，我们使用 TruLens 库，在测试输入样本上计算并可视化两个模型的基于梯度的输入解释。在可视化中，红色区域对应于如果其亮度被放大将增加正确类别的置信度的像素，而蓝色区域对应于如果变亮将降低置信度的像素。

直觉上，最正相关的(红色)像素应该是那些对应于每个图像中手写数字的像素。我们看到，在健壮的模型上，显著的像素确实符合这种直觉。另一方面，对非稳健模型的解释要嘈杂得多，似乎表明该模型不太关注实际数字，而对不相关的伪像更敏感。

摘要

从根本上说，高质量的解释需要高质量的模型，因为解释的目的是准确地阐明模型的行为。同时，事情的核心是，缺乏健壮性是模型质量和概念合理性的问题。因此，健壮性是模型质量的基本要求，是确保可解释性的必要条件。然而，我们应该清楚，仅仅是健壮性可能并不总是保证一个模型以合理的方式使用特性。换句话说，虽然健壮性不一定足以保证概念上的可靠性，但它是必要的；因此，每当我们需要可解释的模型时，我们应该在工具箱中保持健壮性。

参考

  1. 深度卷积网络的影响导向解释。ITC 2018。 ArXiv
  2. 整体强健的神经网络。ICML 2021。 ArXiv
  3. 解释和利用对立的例子。ICLR 2015。 ArXiv
  4. 迈向对抗攻击的深度学习模型。ICLR 2018。 ArXiv
  5. 易勒雅斯等人。“对立的例子不是错误，它们是特征。”NIPS 2019。 ArXiv

人工智能:人类的终极目标？

原文：https://towardsdatascience.com/ai-humanitys-endgame-e3d93e0f9969?source=collection_archive---------22-----------------------

播客

斯图亚特·阿姆斯特朗谈人类遥远的未来，以及事情可能会变得惊人地好(或可怕地坏)

苹果 | 谷歌 | SPOTIFY | 其他

矛盾的是，预测人类遥远的未来可能比预测我们不远的未来更容易。

下一个时尚，下一个网飞特辑，下一任总统——所有这些几乎都是无法预测的。这是因为它们依赖于太多琐碎的因素:下一个时尚可能是由某人心血来潮拍摄的病毒视频引发的，嗯，下一个网飞特辑或总统也可能是如此。

但是说到预测人类遥远的未来，我们可能会奇怪地站在更坚实的基础上。这并不是说可以满怀信心地做出预测，但至少可以基于经济分析和第一原理推理做出预测。大多数分析和推理指向两种情况之一:我们要么达到我们作为一个物种从未想象过的高度，要么我们关心的一切在一场宇宙规模的灾难中消失。

作为本期播客的嘉宾，斯图亚特·阿姆斯特朗，很少有人花更多的时间思考人类文明可能的终结。斯图尔特是牛津大学人类未来研究所的研究员，他在那里研究我们人类面临的各种生存风险，他的大部分工作都专注于人工智能带来的风险。斯图尔特是一个迷人而全面的思想家，他有一个全新的视角来分享你能想象到的一切，我强烈建议听一听这一集。

以下是我最喜欢的一些外卖食品:

  • 总的来说，斯图尔特认为超智能人工智能系统更有可能对人类有益，但他认为如果管理不当，它们也有很大的可能性(20%至 40%)会导致灾难。正确管理它们并不容易:这需要我们找到控制和调整人工智能系统的方法，这些系统可能比我们自己更聪明，具有我们的价值观。斯图尔特乐观地认为这是可以做到的。
  • 斯图尔特认为人类水平的人工智能和超越几乎是不可避免的(他给出了大约 97%的可能性，假设我们事先没有消灭自己)。他如此自信的原因是我们已经知道人类级别的 AI 是可能的(自从人类存在以来)。唯一剩下的问题是，我们是否可以在芯片上或以增强的半生物形式复制人脑，或者设计模仿或超越其功能的算法。
  • OpenAI 最近开发的大规模语言模型 GPT-3 让许多人工智能研究人员相信，转型人工智能或人工通用智能可能会比他们预期的更快出现。然而，Stuart 认为它应该有相反的效果:他将 GPT-3 视为复制人类写作风格比我们预期的更容易的证据，但矛盾的是，这可能使 AGI 更难达到。这是因为许多人认为，人工智能像人类一样写作的能力是其达到一般智力程度的重要指标。但是，如果没有一个普遍智能的系统就能做到这一点，那么我们就不能把写作作为普遍智能的决定性基准，这就使得跟踪和指导 AGI 的进步变得更加困难。
  • 斯图尔特指出，可能的“思想”空间很可能比人类所能想象的要大得多。拥有与我们完全不同——并且可能更丰富——的主观体验的人工智能有朝一日很可能会存在，我们将需要决定是否要像珍视人类生命一样珍视它们。这些看起来像是科幻小说作家的问题，但根据目前技术发展的速度，我们迟早会被迫面对这些问题，这似乎是不可避免的。

你可以在这里查看斯图尔特的作品，或者在推特上关注我

播客中引用的链接:

  • 参见 Stuart 关于人工智能和存在主义风险的文章。

章节:

  • 0:00 介绍
  • 0:52 斯图尔特的背景
  • 3:27 对未来的担忧
  • 7:30 身体方面
  • 11:59 人工智能风险场景
  • 13:38 校准问题
  • 18:37 一致性问题
  • 28:17 安全超级智能
  • 29:35 神谕与 AI 安全
  • 39:55 时间线
  • 45:29 制作物理试卷
  • 54:16 德雷克方程
  • 1:02:13 人类的联系
  • 1:10:26 总结

请查看下面的文字记录:

杰瑞米·哈里斯(00:00:00):
大家好。欢迎回到迈向数据科学播客。今天，我们采访了牛津人类未来研究所的研究员斯图亚特·阿姆斯特朗。现在，Stuart 做了一些非常有趣的工作，找出了一般形式的人工智能必须具备的一些属性，以使它们安全和令人满意。他不仅和人类未来研究所的人一起做这项工作，也和像 Deep Mind 这样的公司的人一起做。

Jeremie Harris (00:00:23):
他是一个深思熟虑的人，他正在处理重要而有趣的问题，这些问题是人类在未来某个时候必须要解决的，所以获得他对所有这些问题的观点是非常有趣的，我希望你和我一样喜欢这次谈话。

杰瑞米·哈里斯(00:00:36):
嗨，斯图尔特。非常感谢你参加我的播客。

斯图亚特·阿姆斯特朗(00:00:37):
谢谢。

Jeremie Harris (00:00:39):
你在播客中讨论了很多不同的话题。不过，首先，我想了解一下你的简历。你是如何发现这个空间的，你的旅程是什么？

斯图亚特·阿姆斯特朗(00:00:52):
在人工智能和生存风险领域，我是如何成为一名睿智的老人的？可能吧。开始很简单。我在做数学。我听说了 FHI。在那里解决问题似乎非常酷。我试着找份工作。我失败了。我在附近工作的时候在那里闲逛。最终，他们同情我，给了我一份工作，从那以后我一直在那里工作。在这一过程中的某个时刻，他们让我深刻地、个人地关心这些问题，这对他们来说是一个有点混蛋的举动。所以，在可预见的未来，我被困在那里了。

Jeremie Harris (00:01:41):
这些问题是什么？有哪些让你着迷的事情？

斯图亚特·阿姆斯特朗(00:01:44):
我们所做的许多工作都是为了人类遥远的未来。最初，我认为这三个主题是人类的进步，人类面临的风险，存在的风险，以及积极的，人类最大的潜在积极因素。但事实表明，我们在所有这些领域都没有同等的影响力，它们也不是同等重要。人类的增强看起来并不像人们最初认为的那样强大，或者现在看起来并不强大。尤其是人们所想的生物增强。

斯图亚特·阿姆斯特朗(00:02:33):
在不久的将来，智能手机可能会比任何记忆药物更能增强人类的能力。这方面还有一些工作要做。好的一面是，我们在那里实际上做不了什么。看起来，相信未来会整理出它自己的积极面，实际上是很有成效的，很难超越这个底线。但是，从存在风险和规避风险的角度来看，事实证明它有大量的正回报。

斯图亚特·阿姆斯特朗(00:03:15):
所以，我们并没有打算悲观失望，末日即将来临，但事实证明，这是更有成效的工作领域。

Jeremie Harris (00:03:27):
我可以想象，因为从某种道德角度来看，我听到的一种观点是，人们会说，“看，遥远的未来还很遥远。我们为什么要关心它？”所以我想这是你花了很多时间思考的事情，为什么深切关注人类遥远的未来？有什么想法吗？促使你朝那个方向发展的一些考虑是什么？

斯图亚特·阿姆斯特朗(00:03:54):
从模糊的角度来看，遥远的未来还很遥远。如果我们确切地知道将会发生什么，如果我们知道 200 代后我们后代的名字，并且确切地知道根据我们的所作所为他们将会有什么样的命运，那么这将是一个更接近的故事。人无论存在于何时何地，都是人。

斯图亚特·阿姆斯特朗(00:04:22):
现在，有一部分批评不太道德，但更实际，那就是我们对未来的力量会减弱或非常小，假设我们拥有强大的人类力量或一万年后的人类会是什么样子可能是非常傲慢的。

斯图亚特·阿姆斯特朗(00:04:42):
在这种情况下，距离是一个不那么专注的理由。这就是存在性风险的来源，所以我们关注的是未来 100 年或 200 年中的存在性风险，或者更短的时间，因为如果人类灭绝了，我们知道的关于遥远未来的事情是不会有存在性风险。

斯图亚特·阿姆斯特朗(00:05:12):
举例来说，如果此时此刻，我们阻止了人类被消灭，这将对遥远的未来产生巨大的影响，因为它允许人类遥远的未来存在。实用的论点不适用于避免存在风险。

Jeremie Harris (00:05:29):
你认为最有可能发生的风险是什么？

斯图亚特·阿姆斯特朗(00:05:34):
根据风险的可预测性、致命性和其他一些因素，所有的风险都有不同的等级。如果我们从天平的一端看，一个潜在的生存风险是流星撞击。我们实际上很…我们在这方面有很好的数据。我们正在计算大小，各种…我们正在计算各种大小的小行星，观察它们的轨迹，估计它们与地球相交的频率等等，我们一直在获得越来越好的数据。

斯图亚特·阿姆斯特朗(00:06:13):
事实证明，这种风险很低。低到我们可以忽略它半个世纪或一个世纪。到那时，如果我们继续作为一个技术文明，我们可能能够保护自己免受其害。

Jeremie Harris (00:06:32):
对于这类事件，风险是什么？

斯图亚特·阿姆斯特朗(00:06:36):
我不记得了。这些数字非常低。

杰瑞米·哈里斯(00:06:41):
所以我们可以相信它会从技术上解决问题？

斯图亚特·阿姆斯特朗(00:06:45):
是的。我的意思是，它值得关注，而且有人在关注它。事实上，这是另一件积极的事情，人们正在为此努力。有趣的是，几乎在我们意识到风险比我们想象的要低的同时，人们开始更认真地对待风险。

杰里米·哈里斯(00:07:02):
哦，哇。

斯图亚特·阿姆斯特朗(00:07:02):
与其说是科幻，不如说是现实。我们承担风险的认真程度似乎与风险发生的可能性完全无关。

Jeremie Harris (00:07:15):
你认为这与想象有多容易有关吗？因为当我想到人们便便的许多风险时，像流行病可能是一个伟大的经典例子，因为我们正在经历它，但在 2019 年，不可能想象整个世界被封锁，等等，等等。

Jeremie Harris (00:07:30):
然而，像小行星撞击这样的事情，其动力学和物理学方面的东西可能更令人信服。你认为那是它的一部分吗？或者说，还有别的解释吗？

斯图亚特·阿姆斯特朗(00:07:40):
我认为事物只是在流行。也许是因为这方面的工作很少，所以谈论小行星撞击的人可能更倾向于边缘人，或者不是很多。但是当你让严肃的科学家就这种风险举行会议时，它就变得值得尊敬了。这似乎是动态的一部分。

斯图亚特·阿姆斯特朗(00:08:07):
此外，我们为之前的风险做准备，所以这是为疫情准备的。我非常肯定，我们在 2022 年将比 2019 年有更好的抗流行病能力。

Jeremie Harris (00:08:22):
在这种情况下，我们将面临一种风险，如果这种风险成为现实，它可能只会发生一次，然后人类文明就此结束。那些风险，我们无法从中吸取教训，我们无法在一代人之间或一代人之内更好地应对它们。有哪些风险属于这一类，因为我知道你也花了很多时间思考这些问题。

斯图亚特·阿姆斯特朗(00:08:44):
这是我们主要面临文明崩溃或技术风险的地方。这一领域的第一名是 AI，即人工智能，这是一个非常令人讨厌的风险，很难预测。与小行星风险不同，如果你愿意，一端是最容易预测的，而另一端是最难预测的。我们真的不知道我们可能开发的任何机器的能力可能是什么。我们甚至不知道它是否危险，尽管有强有力的论据表明它应该是危险的，我们也不知道它的能力。

斯图亚特·阿姆斯特朗(00:09:33):
我们不知道如何控制它。我们不知道社会会是什么样子，是否可以利用社会的缺陷等等。但是，尽管 AI 发生的风险可能相对较低，但其中一个原因是，科幻小说和故事往往会让我们认为发生了大的坏事，文明立即崩溃，根据故事的寓意，每个人都会死，或者一群勇敢的冒险家重建文明。

斯图亚特·阿姆斯特朗(00:10:12):
但实际上，纵观历史，这两件事并不经常发生。文明不会轻易崩溃。有时他们会分裂，但国家不会轻易倒下，除非他们周围有敌对团体，否则他们不会一直倒下。甚至当你处于无政府状态时，比如最近的索马里和中国，我认为，在 20 年代，30 年代可能算…但即使在那个时期，也不是每个人都大规模死亡。在某些地方，这是可以忍受的。

斯图亚特·阿姆斯特朗(00:10:59):
所以，这不仅仅是件大事。一颗足够大的小行星可能会杀死所有人，但是一颗中等大小的小行星可能会扬起很多灰尘，然后它们会对文明造成巨大的压力。这不会是一个美好的时代，但很可能人类真的会挺过来。

斯图亚特·阿姆斯特朗(00:11:22):
人工智能的风险在某种意义上是相反的。相比之下，它变得非常糟糕的风险相对较低，但如果它真的变得糟糕，文明崩溃和灭绝的风险要高得多，这只是因为如果一个强大的人工智能是一个对手，它是一个智能的建议，而不像疾病那样，它只会随着时间的推移而自我毁灭，智能的对手会随着你变弱而变强。

Jeremie Harris (00:11:59):
你认为会出现什么情况？我想象有几个不同的场景，但如果你必须概括人工智能的风险场景，你能讲什么故事来呈现它？

斯图亚特·阿姆斯特朗(00:12:11):
有三个因素。第一个是我们可能会开发出非常智能的机器。不一定要从意识的角度来思考，因为那会引发另一场辩论，而是非常熟练的行为，解决问题，解决所有智力可以处理的问题。如果我们这样做了，他们可能会变得非常强大，就像与黑猩猩或大猩猩相比，人类在自然界中非常强大一样。或者，几乎所有的大型哺乳动物，主要是因为人类决定让它们生存下来。

斯图亚特·阿姆斯特朗(00:12:56):
因此，智力似乎确实对权力有很大的回报。如果我们创造了这些机器，如果它们非常聪明，非常强大，这个世界将会开始模仿它们的目标，它们把什么放在目标的首位，如果它们有一个目标排序，出于各种原因，它们很可能会这样。

斯图亚特·阿姆斯特朗(00:13:22):
最后一点是，很难设计一个让人类能够很好生存的目标。

Jeremie Harris (00:13:33):
我想你指的是校准问题？在你看来，是什么让对齐变得困难？

斯图亚特·阿姆斯特朗(00:13:38):
这种一致性的问题在于，几乎你能想到的任何目标都是这样的，如果人工智能能够消灭人类并轻松控制一切，它就会实现它的目标。这是更为旺盛的科幻场景。

斯图亚特·阿姆斯特朗(00:14:01):
但是，如果你有一个金钱最大化者，你可能想经营一家公司，那么消灭人类，接管任何机构，以便给自己任意大量的钱，这是它会做的事情。这是显而易见的，因为我们已经看到企业，如果不加以限制，倾向于这一方向。

斯图亚特·阿姆斯特朗(00:14:27):
所以你应该为安全目标设定更多的目标，使其与人类的繁荣和生存相适应。但是即使这些目标也是有问题的。如果你想让他们保护人类的安全，那么它可能会反过来让我们呆在混凝土掩体里，靠点滴饲料来保护我们的安全，也许用海洛因来让我们开心。安全快乐。

斯图亚特·阿姆斯特朗(00:14:57):
如果我们给它一个目标，比如让人类安全和快乐，而我们没有用代码正确地解释这是什么意思，那么这些结果在它的偏好排序中会排名很高。这并不意味着它会马上这么做。这只是意味着它将推动社会朝着那个方向发展，而且从长远来看，可能会达到那个目标。

斯图亚特·阿姆斯特朗(00:15:22):不幸的是，它会意识到我们所说的安全和快乐是什么意思。它就是不在乎。它会遵循我们给它设定的目标，或者学习和编程的混合，或者任何倾向于此的东西，即使它确切地知道我们的目标应该是或者本来会是什么。没有简单的方法让它跟随那些。

Jeremie Harris (00:15:57):
是的，这似乎也是一个相关的问题，那就是人类自己甚至不知道我们想要从生活中得到什么。如果你问普通人，你把他们变成了宇宙霸主，给了他们无限的超能力，他们不太可能会做出给你任何特别乌托邦的决定。这似乎是人类的问题，不知道如何设定人类目标的问题与此有关。

Jeremie Harris (00:16:23):
你认为这之间有联系吗，或者这些问题比暗示的更加独立？

斯图亚特·阿姆斯特朗(00:16:31):
他们是有关系的。不过，最近我的观点有点不同。不是不知道自己的目标。而是我们确实知道自己的目标，但只是在熟悉的环境中。所以，与其说我们的目标不明确，不如说我们的目标非常明确，但却不明确，或者没有明确的概念。

斯图亚特·阿姆斯特朗(00:17:01):
你可以想到的一个例子是，假设古希腊人已经完善了一些机械人工智能，他们希望它维护的目标之一是维护荣誉，例如，荣誉的概念。荣誉必须得到回报，这是他们的目标之一。

斯图亚特·阿姆斯特朗(00:17:22):
现在，荣誉意味着什么？你把这个人工智能移植到现在，荣誉基本上…这很不清楚，你可以有多种方式把古希腊的概念扩展到今天的世界。我就是这么想的。我们可能有一个幸福或繁荣或美好生活或平等或几乎任何东西的概念，在人工智能可能推动未来进入的所有可能空间中，大多数这些空间，这些概念，我们不知道它们意味着什么，我们不知道如何扩展它们。

斯图亚特·阿姆斯特朗(00:18:05):
因此，这与其说是一个获得正确定义的问题，不如说是一个获得可以扩展到新情况的定义的问题。

Jeremie Harris (00:18:19):
所以，更多的是定义一个过程，而不是一个价值？

斯图亚特·阿姆斯特朗(00:18:22):
我想是的。这是一个很大的细微差别。你可以说这个过程定义了它到底是什么或者类似的东西，但是我认为这种看待它的方式可能更有用。

Jeremie Harris (00:18:37):
你认为人类之间以及同一时代的人类之间也存在一致性的问题吗？美国普通人的价值观与欧洲或中国普通人的价值观相比如何？这些将会有相当大的偏差，很难想象一个 AGI 所暗示的道德或伦理框架能让所有人都开心。

Jeremie Harris (00:19:04):
也许我的思维如此僵化，说“好吧，单一规则必须适用于每个人”是一种谬误，但你是否认为这是挑战的一部分。即使我们能够准确地解释我们想要这个系统做什么，我们想要的东西可能会因文化不同而不同？

斯图亚特·阿姆斯特朗(00:19:19):
老实说，我认为这不是什么问题，因为人类之间的差异虽然看起来很大，但从内在来看往往相对较小。在我看来，让人工智能拥有一个类似人类的模糊概念是更大的挑战。

斯图亚特·阿姆斯特朗(00:19:44):
现在，不同人类道德体系之间的主要差异往往在很大程度上是谁值得道德关注，谁不值得。我认为，这是实践中最大的不同。在不同人的偏好，甚至是道德偏好之间进行权衡，是人工智能可以做的事情。它不一定要做到完美，我也不认为有完美的标准，但大致的做法应该是可以的。

杰瑞米·哈里斯(00:20:25):
确实有道理。从外面的角度来看，当你看人类的集体整体时，每个人似乎都想要某些东西，或者至少在某种意义上，每个人都想被爱，每个人都想被欣赏。这些东西的表现方式可能会在不同的文化中有所不同，但我想，这种基本的需求仍然是一致的。

斯图亚特·阿姆斯特朗(00:20:46):
我不是说这不会是一个挑战。我只是觉得从某种意义上来说…嗯，这是我正在努力的挑战，我认为一旦你有了这个领域的人工智能，就更容易从中得出一些适当的东西。

Jeremie Harris (00:21:04):
你有多乐观，因为你提到你认为这是一个具有重大影响的低概率事件……在人工智能安全社区显然有一场辩论。有些人认为这几乎肯定不会成为一个问题，以至于你几乎可以忽略 AI 安全或 AI 对齐。其他人认为，或者似乎认为，几乎可以肯定，在我们未来的某个时刻，这将是一场世界末日。

Jeremie Harris (00:21:29):
你对此持何立场，你认为双方都有哪些观点？对于这肯定会是一场大灾难的命题，有哪些最有说服力的论据？你听过哪些最好的反对论据？

斯图亚特·阿姆斯特朗(00:21:42):
这些争论的问题在于他们过于自信。人们知道，他们很难猜测 10 个选举周期后谁会是美国总统，即使美国总统几乎肯定是在 10 个选举周期后出生的，所以你认为你可以…这里有一份今天所有人的名单。在八个选举周期中-

杰瑞米·哈里斯(00:22:23):
他们就在那里的某个地方。

斯图亚特·阿姆斯特朗(00:22:24):
他们中的某个人将会成为美国总统。但当你预测我们可能会有人工智能，这些是人工智能的特征，我认为这比美国总统在八个选举周期中的表现要难得多，那么人们似乎会更有信心，“不，这肯定不会发生”，或者，“这肯定会发生。”

斯图亚特·阿姆斯特朗(00:22:52):
从某种意义上来说，我们工作得越少，我们就越自信。你可能会看到强烈反对彼此的经济学家和历史学家与拥有更多数据、倾向于更加微妙或接近彼此的物理学家之间的对比。

Jeremie Harris (00:23:16):
实际上，我还要补充一点。我当年工作的物理领域就是这个被称为量子力学解释的利基领域，这恰恰是你几乎没有数据的领域之一，你对数据可能告诉我们的东西有所有这些不同的观点，它们都得到了同等的支持，每个人都对他们各自的立场 100%有信心，尽管绝对缺乏数据。

Jeremie Harris (00:23:38):
很抱歉，它似乎完美地反映了你所描述的东西，甚至是物理学的微观世界。

斯图亚特·阿姆斯特朗(00:23:46):
嗯嗯(肯定)。有很大的不确定性。现在，不确定性会把你推向中间。因此，如果我说超级智能人工智能肯定会发生，而且肯定会存在风险，那将是完全愚蠢的。但是说这肯定不会发生也是一个非常错误的立场，因为我们没有证据。

斯图亚特·阿姆斯特朗(00:24:12):
如我所说，我们有争论。所以这种可能发生的情况就是我所描绘的。人工智能变得越来越强大。智力似乎与强大的…强大的实体将事物推向不同的方向，根据经验，让他们朝着正确的方向推进是非常非常困难的。

斯图亚特·阿姆斯特朗(00:24:38):
现在这个论点似乎依赖于各种事情一起发生，所以获得一个强大的人工智能…获得一个智能的人工智能，人工智能变得强大。这一论点让我相信存在风险，这取决于我如何看待它，在 20%至 40%的强大潜在灾难性人工智能范围内。

斯图亚特·阿姆斯特朗(00:25:08):
其他人可能会有不同的划分，但我很难找到任何低于 5%的理由。如果是 0.1%，我还会继续努力。那里有足够的可能性让我去努力。

Jeremie Harris (00:25:26):
仅仅因为影响如此之大？

斯图亚特·阿姆斯特朗(00:25:29):
是的。积极的影响也是如此。在人工智能非常强大的情况下，如果你让它们与人类一致，那么你会得到一个美妙的-

杰瑞米·哈里斯(00:25:40):
乌托邦式的幻想。

斯图亚特·阿姆斯特朗(00:25:41):
对，乌托邦是一个真正的乌托邦，一个生活有趣的地方，你会有很多有趣和不同的经历。不是人们写的这些标准的乌托邦，非常无聊。我认为这是一个失败。

Jeremie Harris (00:26:02):
你认为描绘一个乌托邦可能的样子的困难是暗示这个问题有多困难的一部分吗？

斯图亚特·阿姆斯特朗(00:26:10):
也许一种看待它的方式是，人类看得更多……我们似乎更擅长描述地狱而不是天堂。所以，对我们来说，列出不好的东西比列出真正好的东西要容易得多，大多数乌托邦，如果你仔细看，我们已经把所有真正不好的东西都去掉了。这是他们的主要特点。乌托邦里没有酷刑、战争、饥荒等等。

斯图亚特·阿姆斯特朗(00:26:41):
但是，一旦他们消除了不好的东西，然后他们需要继续投入好的东西，那么我们就会失去更多。但没错，我觉得是有关联的。通常，赞成的论点着眼于细节。考虑到可能发生的情况，这是一种人工智能的力量。

斯图亚特·阿姆斯特朗(00:27:07):
反对者倾向于从外部来看待它，说:“这是一项革命性的技术。”但是人类在过去已经和革命性技术打过很多次交道。我们适应了，我们调整了，我们把它融入了社会。我们已经采取了预防措施，尤其是在……而且，我们总是会遇到一些小问题，然后我们会把这些小问题变成更大的问题。人们正在努力解决这个问题，所以人们努力解决的问题往往会得到解决。

斯图亚特·阿姆斯特朗(00:27:42):
因此，对于所谓的外部观点，你可以说我们可能会管理人工智能，因为我们已经管理了类似类别中的所有其他技术或所有其他挑战。我认为这很有分量。我只是担心，它可能会被证明是一种具有软件形式的一般人类智能的技能，并以高速运行，在这种情况下，内部视图值得一看。

斯图亚特·阿姆斯特朗(00:28:17):
两类。第一个是外部视图，第二个是我混合的，我们将对其进行排序。从某种意义上说，这种观点让我更接近自己，因为我越来越有信心，我们最终可能会成功地解决这个问题。我可以看到一条从我们现在所处的位置到非常安全的超级智能的道路的开端。

Jeremie Harris (00:28:44):
有哪些事情促使你朝着这个方向前进？

斯图亚特·阿姆斯特朗(00:28:48):
现在一切都很模糊，但我觉得以前在处理 AI 安全问题时，我们是在黑暗中爬楼梯。我们不知道步骤是什么。我们不知道有多少人。现在，它仍然是黑暗的，但我可以看到通往目标的道路，以及它们可能需要如何组合，以及在每一条道路上需要做什么样的工作。

Jeremie Harris (00:29:17):
最近出现的这些步骤是什么样的？

斯图亚特·阿姆斯特朗(00:29:21):
这是我一直在关注的一件事，所以我尝试了许多不同的人工智能安全方法。制造安全的神谕-

杰里米·哈里斯(00:29:35):
大家好。我将很快地在这里打断一下，并为那些以前可能没有听说过它们的人解释什么是人工智能安全环境中的神谕。

Jeremie Harris (00:29:43):
所以，先知是一种特殊的人工智能，它只能回答问题。希望通过施加这种约束，我们可以减少超级智能人工智能在与人类价值观不一致时可能造成的潜在伤害。

斯图亚特·阿姆斯特朗(00:29:56):
我已经尝试了很多不同的人工智能安全方法。制造安全的神谕，制造减少影响的人工智能，使他们一致和各种各样的其他事情，试图减少他们的力量。过了一段时间，我觉得在某种意义上，同样的问题不断出现，你可以以一种非常概括的形式看到机器学习的分布问题，因为我们知道我们使用的概念在智能可能推动的奇异或极端场景中会分解。

斯图亚特·阿姆斯特朗(00:30:41):
我认为直接解决这个问题是问题的一部分。这是我目前的一个大项目。另一个是公式化人类偏好是什么意思？我们如何解决这个问题？我有一篇论文表明这在原则上是不可能的…所以，理论上这是不可能的，因为你无法获得一个潜在理性主体的偏好，但我认为在实践中，我可以看到我们如何达到这一点，我们如何识别偏好，将它们放在一起，或者至少找到一条通向这一点的道路。

斯图亚特·阿姆斯特朗(00:31:23):
所以我认为我们在定义人类价值方面取得了进展。理想化人类价值观，弄清楚如何让人工智能学习它，如何将功能扩展到新环境，如何解决符号基础，不是在哲学版本而是在实践版本中-

Jeremie Harris (00:31:43):
什么是符号基础？在 AI 安全方面有什么意义？

斯图亚特·阿姆斯特朗(00:31:49):
符号基础是你的大脑中有一些精神符号，比如其他人、食物等，我们如何知道这些符号在外部世界中对应着什么？在人工智能的早期，我们只是根据它们应该代表的东西来命名符号，我们认为如果人工智能内部有什么东西被称为痛苦，或者有什么东西被称为概率或信念并以正确的方式改变，那就足以使它具有那些属性，而这些属性后来证明基本上不起作用。

斯图亚特·阿姆斯特朗(00:32:30):
那么，我们如何知道人工智能大脑中的这个符号在外部世界意味着什么呢？我一直从实用的角度而不是哲学的角度来看待它，所以与其想知道这个符号是什么意思，我更想做的是，“好吧，这是人工智能内部的一个符号。这些是外部世界的特征。它们有关联吗？我们能否通过观察人工智能大脑内部的符号来了解外部世界正在发生的事情？我们能否通过观察外部世界来判断人工智能大脑中的符号是什么？”

斯图亚特·阿姆斯特朗(00:33:08):
如果有很强的相关性，我会说这个符号是有根据的或者相对来说是有根据的。

Jeremie Harris (00:33:16):
顺便说一下，这真的很有趣，因为我做了一个播客……我想我现在录制的最后一个播客是与一位专注于意识的神经科学教授一起录制的，奇怪的是，你提到的这个想法，你对接地符号的描述，实际上似乎至少映射到了他对意识的一个定义，即我们大脑中的符号与现实中的实际客观事实之间存在关联。

Jeremie Harris (00:33:47):
这是一个兔子洞，但当我们考虑人工智能安全时，我们对这个世界的体验是否也应该更加关注？你认为这样的研究和思考是没有结果的吗，“嗯，我要向内思考。我要做一些冥想，看看我是否能更多地探索主观体验，以获得一些灵感？”

斯图亚特·阿姆斯特朗(00:34:10):
我不确定这是否会有成效。我认为你可以有很好的基础符号，没有任何意识的痕迹。如果你很了解一个人，那么他的名字就是一个很好的象征。所以，书面名称可以在这…好吧，也许这是延伸它，但是你可以在运行各种东西的算法中看到，如果它们运行得好，那么你可以，通过这个半形式定理以及实践经验，你应该能够识别它们内部的符号，这些符号对应于它们外部操纵的概念。

斯图亚特·阿姆斯特朗(00:35:03):
所以你似乎不需要意识去处理这些。现在意识似乎以某种有趣的、不寻常的方式处理符号，是的，但是我不认为，尤其是目前，沿着这条路走下去会有太多收获。这里有更多的前悖论，对人类来说容易的事情对计算机来说很难，反之亦然。这真正的意思是，我们有意识的头脑和思想处于进化创造的伟大的、无意识的处理事物之上。

斯图亚特·阿姆斯特朗(00:35:46):
我们能够本能地做的事情并不是我们能够最好地向计算机解释的事情，因为这些事情我们不一定理解得很好。

Jeremie Harris (00:35:59):
最终，这当然是长期的事情之一，但是一旦我们有了可以有效进行潜意识处理的人工智能系统，我们还会有需要考虑意识的事情吗？我们是否必须把他们考虑在内，就像你之前说的，不同道德之间的差异经常涉及到决定谁是谁非。谁算人，谁不算人？

Jeremie Harris (00:36:25):
我们怎么可能会决定，“好吧，这台机器实际上有投票权，有发言权。”很明显，那是一整只兔子。你可以复制机器，把它们变成唯一重要的东西，我想这是一条潜在的前进道路。

斯图亚特·阿姆斯特朗(00:36:41):
这里可能有一个操作顺序或优先级问题。我毫不怀疑，我们可以用我们能想到的任何合理的意识定义来制造一台有意识的机器。再说一次，意识是一个暂时还没有定义的东西，但是在考虑人工智能的权利和那些问题以及它们的道德地位之前，我首先想避免灾难。

斯图亚特·阿姆斯特朗(00:37:17):
现在，当然，大量的人工智能的痛苦也是一个存在的灾难。我会说是一场灾难。所以这也是要避免的事情，但是我认为让我们想想人工智能的权利是我们太容易陷入的那种人类推理，而首要任务是确保人类生存，它是安全的，它是繁荣的，然后我们可以看看我们是否可以把圈子画得更广。如果我们要创造 10 万亿个人工智能来运行世界上的各种事物，这可能是合理的。知道他们是否在受苦是非常重要的。

斯图亚特·阿姆斯特朗(00:38:08):
但是在我们第一个强大的人工智能中，我会首先考虑安全性。道德上的当务之急是确保这些机器是安全的，让我们有一个未来。另一件事是人类倾向于…我们在云层、岩层和火山中看到神。我们很容易在没有意识的事物中看到意识，这是无意识人工智能潜在的开发途径。这可能是一条可以遵循的途径。

斯图亚特·阿姆斯特朗(00:38:47):
我认为我们应该错误地认为人工智能是没有意识的，即使我们认为它们是有意识的。

Jeremie Harris (00:38:56):
有意思。

斯图亚特·阿姆斯特朗(00:38:57):
在给他们权力和自主权方面。就防止他们遭受痛苦而言，我们可能应该认为他们是有意识的，即使我们认为他们没有。我们应该关注另一个方向。就给予他们权力和自主权而言，我们应该愿意认为他们是极其危险的，潜在的精神变态的，潜在的无意识的东西，如果他们愿意的话，可以对我们表现出意识。

斯图亚特·阿姆斯特朗(00:39:24):
一旦我们安全了，我们就可以开始放生了。

Jeremie Harris (00:39:30):
谈到意识的出现，我认为有一件事让许多人更新了他们对中期普通智能前景的看法，那就是我们最近看到的一些大型语言模型，特别是开放人工智能，但之后，我认为谷歌已经推出了更大的东西。GPT-3 显然已经遍布推特，遍布互联网，真是令人印象深刻的东西。

Jeremie Harris (00:39:55):
这对你对时间表的看法有什么影响？当你看到更多的进步时，你是否发现自己开始认为 AGI 会更快受到冲击？或者，我们在过去几年中看到的进展是否符合你可能预期的情况比如说我不知道在 2015 年或 2012 年，就在深度学习成为一件事情之后？

斯图亚特·阿姆斯特朗(00:40:15):
我现在来推测一下。我以前说过的话，虽然不是没有争议，但至少在许多聪明人中间得到了广泛的认同，至少在某些领域有一个小小的共识。我现在要说的只是我自己的看法。

斯图亚特·阿姆斯特朗(00:40:38):
我认为 GPT-3 实际上可能是一个信号，表明我们不会如此迅速地获得一般情报。这与我对符号基础的想法有关。基本的想法是，似乎伟大的，几乎是人类的性能，可以通过模仿人类拥有正确的架构来实现。人类所做的大量数据，而 GPT 3 号似乎没有我们所说的理解力或一般智力。如果你在一些看起来聪明的答案上推得更多，或者挖掘得更多，让它产生更长时间，它在某个时候会犯错误，暴露出它缺乏理解。

斯图亚特·阿姆斯特朗(00:41:44):
现在，我们所得到的东西令人印象深刻，但这向我表明，至少在创作文本时，模仿理解水平很低的人实际上是可能的。这意味着，如果你没有一个基准，你就无法真正创造出一件东西。我们衡量理解的最好方法之一曾经是图灵测试的方差

杰瑞米·哈里斯(00:42:15):
各位，再来一次。我猜你们大多数人都已经熟悉图灵测试了，但是为了以防万一，我想快速澄清一下。图灵测试是一项实验，旨在确定人工智能的行为是否可以与人类的行为区分开来。最初，人们希望图灵测试可以用来确定人工智能何时最终能够像人类一样思考。

Jeremie Harris (00:42:37):
但很明显，这个想法有很多漏洞，大多数人已经放弃了将图灵测试作为人工智能性能的有趣衡量标准的想法。

斯图亚特·阿姆斯特朗(00:42:47):
我们衡量理解的最好方法之一曾经是图灵测试的方差，只是输出文本的方差，看它是否连贯或像人类一样。而且，我们已经到了这种地步，我们有非常像人类的文本，但没有真正的理解。这让我想到，我们没有任何真正的方法来衡量理解，所以我不认为因为我们没有衡量理解的方法，所以很难对此进行优化或以此为目标。

斯图亚特·阿姆斯特朗(00:43:20):
我在想的一件事是，GPT 和/或其他人能否创造出超越人类的概念。

杰里米·哈里斯(00:43:31):
哦，有意思。

斯图亚特·阿姆斯特朗(00:43:31):
我想让我们回到 1904 年。把当时世界上所有的数据都给 GPT，去掉一些劳伦特和其他人的论文。现在，它能从这些数据中创造出狭义和广义相对论吗？我怀疑它不会，因为为了做到这一点，你必须学习物理，学习这些规则，在那里归纳，将这与已做的实验联系起来，然后提出一个新的理论，将这些事情联系在一起。

斯图亚特·阿姆斯特朗(00:44:15):
然而，我认为 GPT-3 和[GPTN 00:44:21]可能也会将物理论文视为语言学文本的构建，或视为一种社会努力，并创造出类似的或符合这些条件的东西。

斯图亚特·阿姆斯特朗(00:44:37):
好的，物理论文有这种结构，它们谈论这个东西。他们把这个连接起来，他们有这么多的数据。我认为，这比仅仅从论文的语言学中学习宇宙物理学要容易得多。

Jeremie Harris (00:44:55):
如果我说错了，请纠正我，但这个论点听起来像是论文更多地取决于作者使用的语言，而不是论文的内容。如果 GPTN 感兴趣的话，这是一个自动完成的算法。从根本上说，就是这样。如果它想尽最大努力预测将要使用的单词，那么关注语言而不是逻辑就成了更优先考虑的事情？

斯图亚特·阿姆斯特朗(00:45:29):
嗯，有两种方法可以完成一篇物理论文。有很多方法可以完成一篇物理论文，但我们只关注其中的两种。第一个是阅读它，理解所有的概念，生成你的整个物理模型，从这些概念中找出一些新的东西，写出这些概念，与社会分享分享对分享的意义。

斯图亚特·阿姆斯特朗(00:45:58):
另一条路线是从各种文本中，找出文本的模式，并从中延伸。现在，如果通过模式识别有可能创造出一篇好的物理学或物理学论文，那么这就是 GPT-3 将要做的。如果可以用一个简单的模型来做，那么构建一个过于复杂的模型是没有意义的。

斯图亚特·阿姆斯特朗(00:46:27):
所以，你需要的是一个能可靠地区分这两种方法的测试。有什么能证明，是的，你确实需要理解物理，而不仅仅是写一些你理解物理的东西，但是为了达到这个目的？似乎仅仅从文本中归纳就能让你到目前为止的事实向我表明，实际上获得深刻的理解是更难的，因为区分这两者是更难的。

斯图亚特·阿姆斯特朗(00:47:09):
五年前，我曾经告诉人们，对于强人工智能的形式，我的 80%置信区间是 5 到 100 年。我认为它一直在加速，所以我会说我 90%的置信区间现在是 5 到 70 年。我更有信心，我缩小了人类可比的一般智力。

杰里米·哈里斯(00:47:40):
当这种情况发生时，你认为有 20%到 40%的可能性会出现非常非常糟糕的情况吗？差不多吧？

斯图亚特·阿姆斯特朗(00:47:46):
我在建模时遇到的一个问题是人为干预的影响，正如我所说，我越来越相信人为干预会奏效。如果做得太天真，就有三分之一的可能性会出现可怕的错误。

Jeremie Harris (00:48:06):
我认为对许多人来说，这些时间表显然是一个非常重要的因素。当我在播客上与人们谈论他们对人工智能安全的看法时，我们应该关注的是，不可避免地，时间表确实出现了。显然，这个时间间隔很长，但是你有任何理由认为它可能永远不会发生吗？有没有可能 AGI 只是我们永远无法实现或理解的东西？

斯图亚特·阿姆斯特朗(00:48:30):
除了所有这些情况，我排除了人类灭绝或对人类文明的严重破坏……这是我们可能永远不会得到的一种方式。我们知道类人智能是可能的，因为我们在这里。进化可以在数十亿年内产生类似人类的智能。尤其是人类和生物学家，真的非常擅长利用自然过程。

斯图亚特·阿姆斯特朗(00:49:08):
所以，即使我们没有人工智能这种硬技术的技术路线，我们也可能有生物技术，我们可以重新设计大脑或类似大脑的东西。然后，有全脑仿真的蛮力方法，运行人工大脑的想法，根据物理定律向前复制大脑。

斯图亚特·阿姆斯特朗(00:49:39):
这些方法不需要对智力、意识和思维有很好的理解就可以工作。特别是因为我们在谈论技能，而不是意识或某些属性，进化产生了解决某些问题的能力，并拥有某些技能，所以这是可以做到的。我们可以改善我们自己，我们可以改善我们的孩子，我们可以以不同的方式改善我们的机器，我们可以利用技术来解决我们自己的问题。

斯图亚特·阿姆斯特朗(00:50:28):
因此，我不认为人工智能在通往那里的多条路线中的一条上是不可能实现的。我们给它一个 3%的机会。不要强迫我。这是我第一次认真地对此进行估算，它比我想象的要高一点。我忽略了一个事实，即我们在整个宇宙中看不到任何生命，所以我们的进化可能是一个不可思议的侥幸。

斯图亚特·阿姆斯特朗(00:51:10):
但是，我目前对人工智能的估计是 3%左右，这是根据人类可比技能集的一般智能而言的。

Jeremie Harris (00:51:23):
我们在宇宙中是孤独的，这是我见过的，我认为安德斯·桑伯格和人类未来研究所的其他几个人将这一点融入了他们对人工智能的思考。我很想听听你对这两者之间联系的看法。你认为我们可以从我们在宇宙中是孤独的或者我们看起来是孤独的这个事实中收集到什么信息来告诉你如何看待人工智能风险？

斯图亚特·阿姆斯特朗(00:51:50):
最初，我们研究了费米悖论，即外星人在哪里这一悖论，作为人类风险的信息。因为对费米悖论的一种解释是，高级文明总是在达到一定能力水平之前自我毁灭，在它们基本上成为恒星跨越之前。所以，这就是为什么。

斯图亚特·阿姆斯特朗(00:52:18):
然后当我看着它时，我发现它在宇宙中扩张非常容易，这意味着基本上任何控制太阳系超过几个世纪的文明都应该能够开始大规模的殖民化。这使得费米悖论更加糟糕，因为任何文明都可能到达我们，附近的文明和附近的星系也可能到达我们，特别是当你考虑到地球实际上是类地行星中的后来者。

斯图亚特·阿姆斯特朗(00:52:57):
在我们之前很久就有很多类似地球的行星存在，所以我们有更多的时间。人工智能是一个例外。人工智能是一种存在风险，它让在整个宇宙中的扩张变得更容易，而不是更难。首先，因为如果你是一个人工智能，比你是一个生物物种更容易扩展，其次，因为会导致人工智能给人类带来灾难的不当行为类型，无约束的目标函数，几乎完全相同，会导致它想要尽可能地扩展。

斯图亚特·阿姆斯特朗(00:53:38):
所以与其他灾难不同，AI 会在宇宙中留下痕迹。

杰里米·哈里斯(00:53:48):
没错。

斯图亚特·阿姆斯特朗(00:53:50):
但是过了一段时间，在考虑了各种因素之后，似乎最有可能的解释就是高级智能生命很难生存。

杰里米·哈里斯(00:54:02):
就这么难？换句话说，可能有那么多的行星，那么多的星系，但是出现生命的可能性非常低，即使有那么多，我们也只能看到 N=1？

斯图亚特·阿姆斯特朗(00:54:16):
是的。我在查德雷克方程，这是一个估计值…这是对为什么到处都应该有很多外星生命的估计。

杰瑞米·哈里斯(00:54:29):
我只是顺便来看看。如果你没有听说过德雷克方程，它值得一读。从本质上说，这是一个旨在计算我们应该能够在宇宙中看到的可探测外星文明数量的方程，通过乘以一系列因素，如宇宙中的行星数量，那些可能支持生命的行星的比例以及斯图尔特将在一分钟内描述的其他参数。由于显而易见的原因，它已经成为大多数关于费米悖论讨论的焦点。

斯图亚特·阿姆斯特朗(00:54:57):
我正在查找德雷克方程，这是一个估计……这是对为什么到处都应该有大量外星生命的估计。所以有恒星形成的平均速率乘以现在是行星的那些恒星的比例，可能支持生命的行星的平均数量，可能支持生命的行星的比例实际上发展了生命，有生命的行星的比例实际上发展了智慧生命，发展了一种技术的文明的比例将它们存在的可检测的迹象释放到太空中乘以发生的时间长度。

斯图亚特·阿姆斯特朗(00:55:40):
现在，我与安德斯和其他人的工作也有所帮助，其中一个术语，FC，即开发出一种技术的文明的一部分，这种技术可以将他们存在的可检测科学释放到太空中，这是很高的，因为如果需要，在物理形式上扩展是如此容易。

斯图亚特·阿姆斯特朗(00:56:05):
我们对恒星形成的速度也有了相当不错的估计，现在我们对恒星中行星的比例也有了更好的估计。事实上，外面有很多行星，可能比我们最初想象的要多。因此，感觉上，如果我们对其中的每一个做出最好的猜测，我们会得到一些绝对巨大的东西，但是让我们看看一些中间的。可能支持生命的行星部分和确实发展了生命的行星部分，假设它们能够支持生命和有生命的行星部分继续发展智慧生命。我们这里只有猜测。完全是猜测。

斯图亚特·阿姆斯特朗(00:56:48):
也许我们最好的猜测是 1%，这将在银河系中产生许多文明，但认为这是万亿分之一也不无道理。那也有可能。因为万亿分之一就是四千分之一的几率，一个接一个。所以，生命必须经历四个千分之一的机会才能到达我们现在的位置，或者与我们现在的位置进行比较，听起来并不那么不可能。在那里，你有万亿分之一的机会，在那里我们开始看不到周围的生命。

Jeremie Harris (00:57:28):
这大概是需要的吗？大概万亿分之一才能让我们在那个阶段独处？

斯图亚特·阿姆斯特朗(00:57:33):
差不多吧。我认为能到达我们的星系数以十亿计。我在某个地方有号码。但是，这是数十亿或数万亿的范围。对，就是这个。我们对此的最佳估计可能是 1%,但万亿分之一也不太可能。千万亿分之一也不太可能。如果我们更新了我们没有看到任何这种生命的事实，那么这些关于非常罕见的生命的假设就增加了。

斯图亚特·阿姆斯特朗(00:58:11):
现在，我有各种基于趋同进化的观点，比如基本神经系统和海豚式智能之间的趋同进化。这些都是比较容易做到的。我认为障碍在那之前或之后。

Jeremie Harris (00:58:34):
就像第一个细胞之类的？

斯图亚特·阿姆斯特朗(00:58:36):
我想应该是以前。就我个人而言，我非正式地认为，第一个细胞，线粒体…当你想到它时非常奇怪的东西…中枢神经系统，可能还有氧气。

杰瑞米·哈里斯(00:58:55):
氧气？

斯图亚特·阿姆斯特朗(00:58:56):
如果你仔细想想，氧气是植物生命的废物。这是一种废物，其能量水平高于二氧化碳，然后是植物吸收的二氧化碳。因此，在整个地球的水平上，你有这种如此能量有用的废物，这给所有的动物生命提供能量，这似乎是令人惊讶的。

斯图亚特·阿姆斯特朗(00:59:35):
氧气往往会发生很大的反应，这就是为什么我认为在第一个时期，氧气是从……这些是什么？氧细菌。他们有一个正式的名字。

Jeremie Harris (00:59:48):
叶绿素？

斯图亚特·阿姆斯特朗(00:59:48):
是叶绿素吗？不管怎样，可能吧。长期以来，我的理解是大气中没有氧气，因为氧气与铁反应生成铁锈。只有当大部分铁已经发生反应时，大气才开始充满。所以，氧是非常活泼的，所以它在大气中自由漂浮是不寻常的。

Jeremie Harris (01:00:18):
如果是这样的话，如果生命真的如此罕见，以至于我们发现自己在宇宙中真正孤独，这是否会影响你对宇宙的看法，我不想说它的目的，但似乎有一些非常奇怪的事情正在发生…也许不是，但这是否会改变你的观点或更新你的观点…我不知道这可能是什么。这是某种宇宙实验吗？发生了非常非常奇怪的事情吗？或者，这只是一个错觉，我们是如此特别，可能有宇宙的口袋，我们不能接触，同样的实验可能运行万亿次，令人惊讶的是，我们出现在一个？你是如何看待这些可能性的？

斯图亚特·阿姆斯特朗(01:01:07):
我的意思是，如果宇宙足够大，我们会在某个地方找到任何东西。这确实让我重新思考宇宙和未来的一些意义。从某种意义上说，宇宙中有伟大的美，有巨大的利益，这让人类的厄运变得更糟。有太多的东西要学，太多的东西要知道，太多可能的艺术和意义要构建，但是如果人类没有做到这一点，或者如果一个具有如此道德和美学价值的人类后代没有生存下来，那么基本上这将是星辰之间的巨大空虚和星辰的空虚，没有什么可以欣赏这一点，没有什么可以与之联系，没有什么可以赋予它意义。

Jeremie Harris (01:02:13):
你提到了我们后代的概念，如果类人或人类后代不存在，那么我们就失去了一些真正有价值和重要的东西。我想我们的后代可能会和我们非常不同。我的意思是，总的来说，我认为它们要么是生物学上的，因为经过很长一段时间，人类将进化成不同的东西，要么是因为我们将以不同的机械或软件驱动的方式或其他方式得到增强。这会影响你对未来版本的我们的共鸣吗？如果未来的人类会变得和现在的我们很不一样，你会觉得和这种想法有联系吗？

斯图亚特·阿姆斯特朗(01:02:57):
我想说，科幻小说中描绘的每一个外星物种都离人类不远，只有极少数例外。《星际迷航》中的每一个物种都是稍微改造过的人类，这不仅是因为他们看起来像，因为他们显然是演员，还因为他们的行为方式。这没有太大的区别，但可能有非常外星人的思想存在，我不是指真正的外星人。我的想法和我们不同，就像有些人可能认为他们能做的最有趣的事情是把一块积木放在另一块积木上，然后拿走，再放回去，然后拿走，永远这样做。

斯图亚特·阿姆斯特朗(01:03:51):
现在，这种思想，也许它感觉不到快乐，也没有经历痛苦。可能有智能，但这是它看到的全部。这种思想，它们的存在本身并没有错，但我不认为如果人类被这种性质的思想所取代，这将是…我要说这是一个存在主义的灾难，我们失败了。

杰里米·哈里斯(01:04:28):
我想在某种意义上这就是我想说的。根据某些定义，你可以想象人们会说，“好吧，随便。无论人工智能接管了什么，如果它最终成为一场灾难，只要人工智能继续以某种形式存在，我们就创造了它。这是人类的延续，”因此，对整个事情采取一种近乎宿命论的态度，而这听起来像是我们可能想要从任何一种系统中得到的一系列可能的要求，这种系统将在未来传播，以便我们能够……我几乎想说，现在与它产生共鸣，关心，满足于这是通过时间传播的人类存在的遗迹。你对这些要求有什么想法吗？

斯图亚特·阿姆斯特朗(01:05:12):
我一直在努力。我的意思是，有身份感的实体将是一件非常有用的事情，对于可以被复制、开启、关闭、旋转的算法来说，这没有理由会自然发生。没有理由说他们会自然而然地有一种与我们相近的认同感。我比许多人更广泛地把我的圈子定义为人类，但我认为人们并没有意识到心灵空间或可能的心灵有多么广阔。我认为一般灾难性人工智能的一般结果远远超出了人类的思维空间，甚至非常宽泛。

杰瑞米·哈里斯(01:06:14):
啊，是的。是的，我想这就像一只蚂蚁无法想象它上面的思维空间，就像一只鸟。人类也有同样的问题。

斯图亚特·阿姆斯特朗(01:06:27):
并不是那么回事。只是不一样而已。这是不同的，因为你可以想象一个超级智能的人，你可以想象一个超级智能的东西，无论如何都不是人类。所以这并不是权力或凌驾于一切之上的问题。而是他们有没有让人生值得活下去的东西？有哪些特性，如果你听说下一代将缺少或拥有它们，你会认为这是不好的。

斯图亚特·阿姆斯特朗(01:07:07):
让我们从事物的角度来看一些微不足道的事情。如果下一代永远感受不到愤怒会怎样？

杰里米·哈里斯(01:07:16):
我认为那会很复杂。这感觉像是人类经历的一部分，但我也觉得-

斯图亚特·阿姆斯特朗(01:07:22):
我所做的只是在这里做了一个小小的修改，我去掉了一些通常被认为是负面的东西。愤怒往往是消极的。它不是被视为积极的，而是不能感受愤怒的实体，这些是什么？这似乎很奇怪。然后我们说，“好吧，如果他们没有个人认同感，那么他们没有任何有争议的感觉。”哲学，哲学。这变得很复杂，但这些事情在我们的思维空间中并不遥远。因此，我认为我们必须积极主动地说，我们希望我们的后代中至少有一部分人拥有更广泛的人类跨度中的某些东西。

Jeremie Harris (01:08:17):
你几乎可以列出一个清单，列出随着时间的推移，人类有效繁殖的需求。我很高兴我不在名单上。

斯图亚特·阿姆斯特朗(01:08:28):
我想补充一点，我倾向于关注超级智能人工智能场景，主要是因为适用于超级智能人工智能的校准或控制方法，其中大多数……不是全部，但大多数也适用于更有限的实体。所以，我不认为这是最有可能的结果。你说人工智能超载。我也是非正式地这么说。我关注这一点，但我认为这不一定会发生。但是，这是最有用的方法，因为如果你解决了这个问题，大多数时候，你就解决了整个问题。

Jeremie Harris (01:09:08):
实际上，从同一个角度看待人类似乎也很有趣。你是否接受这样一种观点，即人类本身，我们 70 亿人，就任何个人而言，都像是一种错位的超级智能？我们所做的决定，我们所参与的国际竞争，似乎经常对我们个人的幸福有害，这是一个结盟的问题吗？这是同一类还是不同的东西？

斯图亚特·阿姆斯特朗(01:09:43):
我认为这是一个有用的类比，只要我们不把它推得太远。在某些方面，一个公司可以被看作是一个超级智能体。但是，一个比真正的超级智能更容易控制，因为即使有一个完整的系统，它是由人类居住的，这些限制了它的行为方式，它可以不被抓住的行为方式。

斯图亚特·阿姆斯特朗(01:10:20):
是的，我同意将其作为一个类比，只要它不被推得太远。

杰里米·哈里斯(01:10:26):
斯图尔特，非常感谢你。我真的很喜欢这次谈话。如果人们想更密切地关注你的研究，你有没有一个链接，一个你愿意分享的个人网站？

斯图亚特·阿姆斯特朗(01:10:36):
我有一些 LessWrong 的链接，它们蜿蜒穿过那里的许多区域。我有一个个人网站，但它早已不复存在。看看人类研究所的未来，看看 LessWrong。

杰里米·哈里斯(01:10:54):
完美。我会在播客附带的博客文章中包含一些链接。斯图尔特，非常感谢你抽出时间。

斯图亚特·阿姆斯特朗(01:11:00):
酷。谢谢你。

超参数优化的人工智能图像分类

原文：https://towardsdatascience.com/ai-image-classification-with-hyperparameter-optimization-343303ad7e13?source=collection_archive---------27-----------------------

使用迁移学习、超参数优化和 PyTorch 深度学习框架的图像分类

由 Unsplash 上的 Katarzyna Pe 拍摄

自 Alex Krizhevsky 等人开发出赢得 2012 年 ImageNet 挑战赛的 AlexNet 卷积神经网络(CNN)以来，使用人工智能识别物体和分类图像的能力一直是 AI 发展最快的领域之一。AlexNet 网络实现了从 14，197，122 ImageNet 数据集标记图像的最先进的性能。从那时起，CNN 架构的数量和多样性已经跨越深度 CNN 架构显著扩展到初始和剩余 CNN 网络。今天，CNN 正被用于图像分类、医学成像、面部识别和鉴定、分拣邮件、机器人视觉以及即将到来的自动驾驶汽车。

典型的卷积神经网络(CNN)——维基共享

本文将展示一个使用人工智能神经网络执行图像分类的基于代码的示例。虽然网上有许多优秀的图像分类文章，但本文中介绍的两个关键项目是使用迁移学习来启动您的神经网络模型，以及利用 TensorBoard 来帮助优化您的模型和训练超参数的代码框架。对于这个例子，PyTorch 将被用作深度学习框架，Google Colab 将被用作训练基础设施。

数据探索和预处理

这个示例的数据集包含四类花卉图像:郁金香、玫瑰、雏菊和向日葵。图像数据集可在此下载。

郁金香(左)和玫瑰(右)

雏菊(左)和向日葵(右)

第一项任务是回顾每节课的图片。如下所示，这是一个不平衡的分类数据集。

按类别划分的花卉数据集影像

尝试平衡分类数据集被认为是最佳实践。以下 Python 代码使用过采样方法来平衡数据集，每个类 600 个图像。

平衡数据集

然后，数据集被分成每个类的训练集、验证集和测试集。

数据集训练、验证和测试集

理想情况下，深度学习模型将使用大量训练数据进行训练。鉴于可用数据的样本量较小，我将利用迁移学习来启动神经网络模型的训练工作。迁移学习是利用一个神经网络模型，该模型已经在一个不同但相似的任务上成功地训练过，并利用这个预训练的模型作为你的模型的起点。

预训练的 VGG-16 模型被用作迁移学习模型。由于该模型是在 ImageNet 数据集上训练的，因此使用 ImageNet 数据集归一化值对每个通道的平均值和标准偏差进行归一化。图像大小被裁剪为 224 x 224。

图像增强和标准化

图像增强也将用于增强训练效果。在每次训练运行期间，当图像被馈送到神经网络时，一组图像变换将被随机地应用于图像。这使神经网络在训练过程中暴露于更广泛的图像变化。图像增强不适用于验证和测试数据集。

CNN 模型

用于迁移学习模型的方法是保持核心模型不变，以便我们可以利用其先前的特征图训练，并用我们模型的输出层替换图像分类器层。

以下函数用于加载迁移学习模型，冻结来自进一步训练的模型权重，并用新的层替换原始分类器层用于修正的模型。

CNN 模型定义

在训练期间，仅更新新定义的神经网络层权重；冻结的(也称为预训练的)重量保持不变。最终输出层是 LogSoftmax 层，因为在训练期间使用了 NLL(负对数似然)损失函数。

模特培训

为了在模型训练过程中探索各种模型和超参数设置，在 Python 有序字典中定义了模型参数。

# Training Hyperparameters
params = OrderedDict(
    hidden_units = [256, 512],
    dropout = [0.4, 0.5],
    num_classes = [4],
    lr = [0.001],
    batch_size = [25],
    n_epochs = [40]
)

定义了一个 Python 类来生成跨越各种参数排列的运行定义列表。

RunBuilder 类

创建一个 RunManager 类来定义一组用于管理 run 和 epoch 参数初始化的方法，以跟踪训练输出并将输出数据提供给 TensorBoard。

训练循环被定义为一个函数。该函数实例化 RunManager 类的一个实例，并循环运行每个 RunBuilder 生成的参数列表。该函数使用运行参数创建 CNN 模型，并定义优化器和数据加载器。注意，RunBuilder 类不需要实例化，因为它包含一个静态方法。

然后，该函数在每个时期执行 PyTorch 训练循环。PyTorch 梯度计算在训练时打开，但在处理验证数据时关闭。

在整个训练过程中，损耗、准确度和重量信息由 RunManager 方法跟踪并发送到 TensorBoard。此外，每次运行和时期的结果被保存到输出文件中。

使用以下命令启动训练；其中“运行结果”是输出文件名。

history = execution_loop('Run_Results')

结果

一旦训练运行完成，保存的输出文件将提供用于分析的表格数据。

训练运行输出数据

可以对输出文件进行排序，以找到最佳的参数组合。

顶级验证准确度运行

表现最好的组合是运行 1，训练准确率为 98.9%，验证准确率为 94%。运行参数为:

  • 256 个隐藏单元
  • 辍学率为 0.4%
  • 批量为 25 件
  • 学习率为 0.001

张量板

以下是在训练运行期间发送到 TensorBoard 的一些输出数据示例。

模型图可以交互地向下钻取，以确认您的神经网络模型设计。

张量板神经网络模型图

每次运行的训练和验证准确度和损失曲线图。可以切换图以显示所有运行或仅显示一组选定的运行。

训练准确度和损失曲线—所有运行

训练准确度和损失曲线—运行 1(橙色)，运行 2(蓝色)

验证准确度和损失曲线—运行 1

每次运行的每个层的模型权重和偏差分布以及直方图也可用于审查。

分类器层零偏差直方图-所有运行

分类器层零权重直方图-所有运行

结论

使用迁移学习模型可以快速启动您的神经网络模型创建，并极大地增强您的模型性能，即使在小于理想值的数据集上进行训练时也是如此。

虽然这个例子只包括两对要优化的参数(隐藏单元和下降)，但是它可以扩展到任何数量的参数/超参数；您可以改变:学习速率、批量大小、训练期间的样本洗牌、优化器选择、损失函数选择、在不同层内设置多个超参数值、在模型内切换层的开/关等。

还应该注意的是，这种基于参数的训练框架并不是 PyTorch 特有的。通过对训练循环进行一些编码调整，它可以用于纯张量流或 Keras/张量流模型。在 Deeplizard 向提出 RunBuilder / RunManager 概念的人们大声欢呼。

我希望你喜欢这篇文章，并发现它的信息。你可以在我的 GitHub repo 中找到这个例子的所有代码。

医疗诊断中的人工智能——处理医疗数据集

原文：https://towardsdatascience.com/ai-in-medical-diagnosis-dealing-with-medical-datasets-b746e8bda9e5?source=collection_archive---------18-----------------------

处理医疗数据集挑战，如不平衡数据集，管理测试集以构建有用的模型

国家癌症研究所的图片来自 Unsplash。

简介:

这篇博客文章是我将分享的一系列文章的一部分，基于我从人工智能医学专业课程中学到的东西。我最近完成了第一部分:医学诊断中的人工智能，我在这篇博文中总结了我从第一周学到的东西。

更快。更聪明。好多了。这就是人工智能算法日益发展的趋势。新的模型正在不断改进，并且速度很快。虽然对问题使用最先进的模型并知道如何有效地调优超参数很重要，但知道如何处理手头的数据集也是同样重要的技能。【2021 年人工智能状况报告陈述了以数据为中心的人工智能是如何因为所有正确的原因而受到欢迎的。记住这一点，让我们讨论如何处理医疗数据集。记住 ML 的黄金法则:垃圾进==垃圾出

医疗数据集的挑战:

医疗数据集有一个巨大的挑战:数据稀缺。更重要的是，属于“疾病”类别的数据稀缺，这是我们最有兴趣使用我们建立的模型进行预测的。在这篇博文的其余部分，我们将提到数据集中的两个类别:患有我们有兴趣预测的疾病的患者将属于“疾病”类别，而没有患病的患者将属于“正常”类别。

数据的缺乏导致了两个主要的挑战:类别不平衡和管理测试集。制造业等其他领域也可能遭遇同样的问题。比如，阶级不平衡是制造业的一个经典问题，缺陷元件的数量远远少于非缺陷元件的数量。

让我们详细讨论一下这些挑战，以及如何应对这些挑战！

阶层失衡问题:

在典型的医疗场景中，当观察健康人群时,“正常”患者的数量将远远超过特定疾病患者的数量。

这就是所谓的阶层失衡问题。这导致对模型损失的大部分贡献来自“正常”类实例而不是“疾病”类，并导致算法优化损失函数，以比“疾病”类更好地预测“正常”类实例。

我们可以使用以下技术来处理训练集中的类别不平衡:

  1. 过采样少数类 —为了平衡这两个类，可以对少数类进行过采样。这可以通过对表格数据使用 SMOTE 等方法以及旋转、翻转等图像增强技术来实现。对于图像数据。在扩充数据时，我们需要确保被扩充数据的标签是真实的。例如，胸部 X 射线水平翻转导致患者的心脏指向右侧，这种情况称为右位心。
  2. 对多数类进行欠采样 —这涉及到从多数类中移除一些样本，以使数据集平衡。这种方法的缺点之一是多数类中有价值的数据可能会在数据移除过程中丢失。
  3. 类别加权 —我们可以修改算法，以确保它能很好地处理倾斜数据集。这意味着我们在算法的成本函数中给予少数类更多的权重，这导致在训练阶段对少数类的惩罚更高。选择类别权重的一个简单方法是取另一个类别与样本总数的比率。这导致少数阶级的惩罚高于多数阶级。

下面是一个常见的等级称重方法的例子:

假设我们有 10 个数据点，其中 8 个数据点是正常类(N)，2 个数据点是疾病类(D)。为了计算“正常”类别的权重(Wn)和“疾病”类别的权重(Wd ),我们使用以下公式:

不平衡数据集的类惩罚乘数计算公式。图片作者。

由于数据集只有少量疾病类别示例，因此通常很难使用准确性等指标在不平衡数据集上训练的模型中发现问题。这引出了我们需要考虑的第二个要点:

管理测试和验证集:

回到不平衡数据集的问题，我们需要确保测试集和验证集都有疾病类和正常类的例子。这一点很重要，如果不这样做，将会导致模型性能度量不能真实地代表模型的性能。

让我们看一个简单的例子:

我们有一个 100 个数据点的数据集。这些数据点中只有 10 个(10%)属于“疾病”类别。我们使用 sklearn 的 train_test_split 函数拆分数据集，80%的数据在训练集中，剩下的 20%在测试集中。因为这是一个随机的分割，很可能在我们的测试集中没有一个单独的数据点或者只有 10 个数据点属于“疾病”类别。现在，在对模型进行训练并在测试集上对其进行评估之后，模型的性能指标可能会非常高。但是如果没有疾病类别的良好表示，这些性能度量将会给我们一个模型实际能力的错误感觉。

因此，我们需要确保测试集以正确的比例包含“疾病”和“正常”类别的样本。这种划分在不同的用例中会有所不同，有时这种划分会高达 50-50。这有助于我们真正测试训练好的模型，并确保模型有能力预测“疾病”和“正常”类别。

一旦我们有了满意的测试集，我们就使用与测试集相同的分布(百分比分割)创建一个验证集

有两种方法可以根据我们希望在测试集上的每个类的数据点的分布来管理我们的测试集:

分层:

如果我们想在训练集和测试集中平均分配类，我们可以分层。数据集的分层是指我们希望在训练集和验证集中平均分布类。例如，如果数据集有 20%的标签用于“疾病”类，80%的标签用于正常类，并且我们希望在分割数据集用于训练和测试后保持该比例，我们可以使用分层。这可以在 sklearn 中简单地完成，在调用 train_test_split 辅助函数时使用参数 stratify。我在这里整理了一个简单的 Jupyter 笔记本来展示在使用和不使用分层的情况下，train vs 测试集中所有类的分布差异。

自定义拆分:

如果我们想要在测试集中进行更加定制的划分(例如 40%的‘正常’类和 60%的‘疾病’类)，我们必须手动进行。详细代码请点击链接至 Jupyter 笔记本。下面给出了该函数的代码片段，展示了如何对一个包含 3 个不同类的数据集执行该操作。

3 个不同类别的自定义分割功能。GitHub 库中的详细代码。图片作者。

一旦我们有了我们选择的正确百分比分割的验证和测试数据集，我们就可以继续创建训练集。我们已经讨论了如何实现平衡的训练数据集。

其他要点:

处理医疗数据时需要记住的其他几点:

  1. 患者重叠 —按患者 ID 分割数据集，而不是按数据点/图像分割，这一点很重要。这是为了确保模型不会学习与预测患者是否患有我们感兴趣的疾病无关的数据部分。此问题类似于数据泄漏问题，在数据泄漏问题中，定型集和验证集中存在相同的数据，从而使验证集的结果不能真正衡量模型的预测能力。
  2. 在数据标注者之间达成共识 —必须在整个数据集中保持标注的一致性。不同的标注者可能对特定数据点的标注有不同的看法。在这种情况下，应咨询各种其他标签，并以多数票为最终决定。也可以使用其他技术，如活检来确定地面真相，尽管这些技术往往更昂贵和耗时。

我希望这篇博文能让你对如何处理医疗数据集有所了解——同样的概念也可以应用于制造业等领域。请继续关注本系列的第 2 部分，在那里我将讨论评估为医疗诊断而构建的模型的不同方法。请随时在 Twitter 和 LinkedIn 上与我联系！祝你有美好的一天:)

AI 诚信:提前计划做正确的事情

原文：https://towardsdatascience.com/ai-integrity-planning-ahead-to-do-the-right-thing-74bdd288a829?source=collection_archive---------17-----------------------

everyday Integrity

如何为不可避免的错误做准备

由亚历山德罗·埃尔贝塔在 Unsplash 上拍摄的照片

考虑这些场景:

  • 你是一名初级数据科学家，被要求跟进以前的项目。你的老板很喜欢你的工作，他想要更多。当你回顾之前的结果时，你会注意到一些事情。你调出你的代码。会不会是？是的，这里有一个错误…你有下沉的感觉。现在，每个人都很开心。如果你什么都不说，没有人会知道。
  • 你的电话响了。是顾客。他们关心你提供的一个指标。有没有可能是错的？你很困惑。还有，愤懑；毕竟，你为这个客户付出了额外的努力，却没有得到足够的赞赏。
  • 这是一项新计划推出一周年纪念日，您被要求就其绩效编写一份报告。这是你老板最喜欢的项目，引起了很多关注。不幸的是，你发现努力没有预期的成功。你反复检查你的结果。你的老板已经因为你上次犯的一个错误而生你的气了。另外，你最近不得不休息了很长时间，她对此有意见。

我在分析和数据科学领域工作了近十年，主要从事初级或中级个人贡献者的工作。我接触过的公司从只有几名员工到数万名员工不等。我曾经是完全专注于分析的公司的一员，也是大型组织中一个小团队的一员。我面临过道德困境，也看到过其他人做同样的事情。有些情况几乎是幽默的，有些是毁灭性的。

任何工作了一段时间的数据科学家都会在他们自己的工作中发现一个错误，如果他们什么都不说，其他人永远也不会知道

任何数据科学家(或分析师等。)无论工作多长时间，都会在自己的工作中发现一个错误，如果他们什么都不说，别人永远也不会知道。我曾多次面临这种情况。我也有其他人对我的结果提出疑问，我也许可以用自己的方式解决。我曾多次面临这种情况，它们总是令人痛苦和尴尬。然而，我很幸运地学会了一些有帮助的技巧(稍后讨论)。当我应用它们时，例如，告诉客户一个错误，否则不会被发现，我有非常好的体验。我甚至得到了工作！我从来没有失去过一个项目，或者我的整体能力受到严重质疑。我觉得，总的来说，客户已经欣赏披露和信任增加。

有些情况要困难得多。虽然我现在很幸运地为一家伟大的公司工作，但我也有过一些负面的经历。有几次，我目睹了处于领导地位的人撒谎。突然间，我不得不考虑那些我没有做出甚至没有预见到的选择。虽然具体的谎言看起来并不重要或危险，但这些情况是令人恐惧和有辱人格的。有一次，一位领导亲自拜访我，以确保我的服从，并称赞我迄今为止的“良好判断力”。

关于这些事件，我想了很多。我怎么会这么容易被吓倒？离职就够了吗？有时满屋子的人都保持沉默。我想到了更年轻的人，刚刚开始工作，沉浸在那些环境中。他们觉得这正常吗？正常吗？

人工智能伦理和人工智能完整性

我曾经向一个人工智能伦理小组询问处理错误的最佳实践。一位参与者回答说(从视频中转录):

所以我们意识到我们给一个非常大的公司的结果是完全错误的。问题是我们该怎么做？当时管理团队的人说，我们已经在几个月前交付了这些结果，他们已经根据这些结果制定了今年的计划，所以此时没有什么真正要做的，所以我们不打算告诉他们，我们只是向前修正代码。我从来没有真正同意过那个决定，但是…你可以理解那会造成多大的痛苦，去找一个大客户，说你年度计划所基于的所有模型都是假的。

我觉得有趣的是，这个道德小组完全专注于隐私和算法偏见等问题，而没有解决诚信问题。以上只是因为我问起才提出来的，不置可否的讨论过后，话题又转回到原来的话题。但这个回复至少证实了我的经历并不独特。

我觉得有趣的是，这个伦理小组完全专注于隐私和算法偏见等问题，而没有解决诚信问题

通常在会议上讨论的人工智能伦理话题是非常重要的，需要得到解决。然而，对于我们这些从事“常规”工作的人来说，诚信是另一个至关重要的话题。

在这个专栏中，我反思了我所面临的道德困境，重点关注我认为容易出现谎言的常见情况。对于这第一部分，我集中精力准备。我认为诚信的一个主要障碍是未能对常见情况进行规划。

无计划的问题

反应性说谎比预谋的欺骗更常见。人们过着他们的日子，做着他们的工作，想着他们自己的事业，突然出现了一个道德困境！

如果我告诉你错误是不可避免的，你当然会同意。每个人都会犯错！这个大家都懂！然而，我发现很少有组织有适当的流程来处理这些可预测的事件。个人也是措手不及。所以，往往会发生的是，人们的反应来自情感，就像短发的幼儿园小朋友被抓到拿着剪刀一样。什么都没发生！是狗干的！或者，我们停下来等待。或者，我们有所防备。我没有错！错的人是你！

道德困境并不是数据科学家独有的。我们不是第一个被诱惑去撒谎以保全面子或安抚他人的人。然而，我们有特殊的弱点。我们处理信息并影响决策。我们的工作依赖于客户和整个社会的善意。

在我看来，我们不能承受哪怕是一点点的不诚实。当我目睹或怀疑不诚实的行为时，对相关人员来说似乎并不顺利。客户可能永远不会意识到谎言，但仍然对这种关系感到不安。通常，不诚实只是倾向于减少信任的潜在态度的一种表现(我将在未来的文章中讨论其中的一些)。

很多时候，我们就是没有计划。公共讨论中缺少诚信问题，许多组织没有明确的政策。做正确的事情的重担往往落在工人个人身上。

针对个人的实用技巧

在我最初的例子中，我包括了一些细节，比如你最近拿了多少 PTO，或者客户可能有多苛刻。如果我只是把我的价值观写在一张纸上，我不会包括这些细枝末节。但是我们执行价值观的能力会因为环境的不同而发生巨大的变化。

一个计划不仅仅是价值观。没有计划，每个人都容易达不到自己的原则。一个计划必须包括能帮助我们实现价值的策略和工具。

下面，我分享一些策略，希望可以帮助减少环境的影响。下面的建议(大部分)是针对一般诚实的人，他们喜欢做正确的事情。你的计划将基于你自己的价值观、个性和处境。

请在评论中发表更多想法！

给朋友打电话

时间不站在诚实的一边。你等待的时间越长，揭露的可能性就越小。像我这样对压力反应冷淡的人特别容易等太久。然而，立即告诉主管或客户可能会让人望而生畏。更容易的是有一个朋友、亲戚等。，你可以马上打电话、发短信或发邮件。最好的人是不评判、值得信赖、头脑冷静的人。如果他们住得很远或者对数据科学兴趣不大，那就太好了。

时间不站在诚实的一边

很久以前，我在实验室工作，掉了一个昂贵的镜头。我独自一人，当时已经是深夜了。我开始担心成本，把零件放回货架，不知所措。我突然想到给一个特定的人打电话。由于实验室在地下，我不得不走很远的路才能得到手机信号。起初，我脑子里有各种各样的事情——也许零件没问题，反正我不应该被要求工作到这么晚，这些德国光学公司把事情做得太滑了。我一边走，一边想象着告诉我的朋友所有这些事情。然后，我停下来，回头。就像她就在我旁边的走廊里一样清晰，我听到了我朋友的声音，我的胡言乱语不再有任何意义。我回到实验室，给实验室经理发了电子邮件，然后回家睡觉。

我发现通知另一个人可以立即缓解压力。它消除了情绪，让思维更清晰。另外，你的朋友不会因为你讨厌的客户而受到影响，也不会因为你还没吃午饭而分心。

给它标上一美元的价值

我见过的大多数谎言似乎都不算重大。他们变得更加模糊，不出所料，我经常听到这样的话，“误差很小，不值得说什么”。或者“反正也没人用”。

但是“我将决定什么对你来说是有意义的”难道不是令人不安的吗？

但是难道没有什么令人不安的事情吗，“我要决定什么对你有意义”？我们通常不完全了解我们的客户在用我们的产品做什么，或者他们以后会做什么。根据我们的数据，客户可能会对未来产生什么样的假设或偏见，即使这些假设或偏见并不影响今天的决策？

当可能感到尴尬的人是决定一个错误是否达到某种披露门槛的人时，就存在明显的利益冲突。值得注意的是，这个阈值不是提前设置的，也不是与客户预先安排的，而是由一个刚刚犯了错误的情绪化的人即时确定的。

此外，较简单困难的对话是实践你的计划的机会。我们真的相信一个避免解决小错误的人能够在危机中挺身而出吗？诚信不是一种有限的物质，必须保存到真正重要的时候。

所以，我提出一个简单的计算。首先，估算一下不诚实对你自己的价值。这可能只是一种直觉，或者是纠正和讨论错误的每小时费用。花一分钟思考这个数字。

如果你仍然有任何疑问，将这个值与你对个人诚信的评价进行比较，或者与一个风险值进行比较，这个风险值等于被抓住的概率乘以被发现的代价。

考虑一个类似前面引用的例子，错误的结果被提供给了一个客户。领导者做出披露决定，但整个团队都知道。如果供应商对客户诚实，在最坏的情况下，他们会被解雇。假设它值 100 万美元。但是试图保密的潜在代价是什么？如果一家公司知道一个错误却没有改正，这一点被公之于众，他们可能会失去现在和将来所有的客户。也许 2500 万美元？这个谎言保持秘密的几率有多大，久而久之和员工走上其他岗位？为了让不诚实具有财务意义，概率必须低于 4%，这听起来不是一个好的赌注。考虑到员工士气低落和自然减员带来的潜在损失，4%可能是一个过高的估计。

这种美元价值技术听起来可能有问题，甚至令人震惊。完全是利己主义。难道我们不应该想做正确的事情，因为这是正确的事情吗？还是出于对那些可能受我们行为影响的人的真诚同情？

对于一个诚实的人来说，这种方法旨在吸引分析思维，消除恐慌，而不是真正衡量金钱价值。一美元的价值有助于正确看待形势——也许这毕竟不是世界末日！

对于那些正直程度低于平均水平的人来说，金钱价值技术可能至少会给撒谎设定一个下限。我见过人们撒谎，而诚实本可以花费一两次艰难的谈话或几个小时的工作。对不诚实的底线可能看起来是一个小小的收获，但许多问题来自日常生活；道德困境是右倾的。

了解他们

以前的技巧是反应性的，在危机时刻使用。下一个策略是预防性的，也很简单:尽可能多的了解那些受你工作影响的人。在问题出现之前就这么做。

我并不是建议和付钱给你的人多谈。目标是会见可能受你的模型或分析影响的人。例如，如果你的工作涉及为销售团队建立潜在客户模型，也许花一天时间跟踪销售人员，这样你就能看到他们一天的真实情况。或者，你可以要求与客户一起参加焦点小组。

眼前的目标是增加同理心，减少我们告诉自己“没什么大不了的”或“伤害已经造成了”的能力。但是有无数的好处。观察产生数据和/或使用我们的模型或分析的人是令人大开眼界的。我对可靠性和有意义的数据有了更多的了解，例如，看着用户每次点击一长串可笑的选项来选择“其他”。

对于那些花费大量时间埋头工作的个人贡献者来说，我认为这种经历可以是一种令人耳目一新的改变，并增加参与度。在疫情之前，我有幸花了一天时间跟随一个服务岗位。我对这项工作的复杂性以及客户的耐心和友善感到惊讶。从那以后，我觉得自己的工作更有动力了，特别想确保我参与的任何项目都能让工作变得更容易，而不是增加额外的麻烦。

一个优秀的雇主会提供这种机会，但在许多地方，一个数据科学家可能必须让它们发生。我认为这种努力是值得的——即使你每年安排一次会议，也比大多数会议都要频繁！与实际受影响的人交谈可能不合适或不可能，但你可以找到更亲近的人(例如，如果数据涉及学生，可以找老师)。

重新定义一段成功的关系

一些数据科学家将项目成功定义为“客户(或老板)开心，我也开心”。快乐是伟大的，但当错误发生时，这个框架就开始崩溃了。承认错误可能会让客户和数据科学家都不高兴。

这个定义也倾向于关注直接客户——批准项目或支付数据科学家的人。那些不在房间里的人倾向于后退。有时候，人们喜欢最终用户、数据主体等。，还不如住在月球上。

有时候，人们喜欢最终用户、数据主体等。，还不如住在月球上

让客户开心是好事，如果付钱给你的人从来都不开心，那显然是有问题的。但是我们可能会打开一扇大门，即使客户不高兴，项目仍然可以成功。

爱情轰炸客户甚至可能不是赢得他们关注的最佳方式。过分关注客户的幸福有时会导致一段紧张的蜜月期，随之而来的是失望。我认为，渴望做好工作，专注于客户的成功而不是快乐，或者仅仅是一个简单的真诚努力，往往会让他们更长久地满意。

即使一个错误是不可挽回的，客户除了对你感到不高兴和失望之外什么也做不了，我认为他们应该被告知。从不幸和错误中学习是人类经历的一个重要部分，故意干涉这个过程是不对的。也许因为披露错误是一种固有的尊重行为，客户通常会欣赏这种努力。

最后的想法

无论你的理想是什么，明天实现它们意味着今天的努力。正如 Eliyahu Goldratt 所说，“当缺乏准备遇到现实时，运气就不好了。”

如果您喜欢这篇文章，请继续关注即将推出的“每日诚信”的后续部分！

使用 NLP 改进你的简历

原文：https://towardsdatascience.com/ai-is-working-against-your-job-application-bec65d496d22?source=collection_archive---------3-----------------------

从零开始逐个任务地进行数据科学

对工作描述执行关键字匹配和文本分析

附身摄影在 Unsplash 上拍照

招聘人员正在使用越来越复杂的软件和工具来扫描简历，并将其与发布的职位和工作规范进行匹配。如果你的简历很普通，或者工作说明含糊不清，这些工具会对你不利。AI 真的在和你的工作申请作对，我不确定你是否知道或者会接受它！但是让我来示范一些可以帮助你平衡胜算的技巧。自然，我们会使用 NLP(自然语言处理)，Python，和一些 Altair 的视觉效果。你准备好反击了吗？

假设你对网上看到的一个好职位感兴趣。有多少人会看到同样的工作？有和你大致相同的经历和资历？你认为会有多少申请人提出申请？会不会少于 10 或者少于 1000？

此外，考虑面试小组可能只有 5 名强有力的候选人。那么，你如何从 995 份申请中“筛选”出 5 名优秀的候选人呢？这就是为什么我说你需要平衡胜算，否则就和杂草一起被扔掉！

处理 1，000 份简历

我想，首先，你可以把这些简历分成 3-5 份。把它们打印出来，分配给人类读者。每个读者从他们的一堆中选择一个。5 个读者有 200 份简历——去挑选最好的一两份。阅读这些会花很长时间，而且可能最终只能得到一个答案。我们可以使用 Python 在几分钟内阅读所有这些简历！

在 Medium 上阅读文章“我如何使用 NLP (Spacy)筛选数据科学简历”表明，只需两行代码就可以收集这 1000 份简历的文件名。

#Function to read resumes from the folder one by one
mypath='D:/NLP_Resume/Candidate Resume' 
onlyfiles = [os.path.join(mypath, f) for f in os.listdir(mypath) 
             if os.path.isfile(os.path.join(mypath, f))]

变量‘only files’是一个 Python 列表，它包含使用 Python os 库获得的所有简历的文件名。如果你研究文章，你也会看到你的简历是如何根据关键词分析几乎自动地被排名和淘汰的。因为我们试图平衡胜算，所以我们需要把重点放在你想要的工作规范和你目前的简历上。它们匹配吗？

匹配简历和工作描述

为了公平起见，我们想浏览一下职位描述、简历，并衡量一下匹配程度。理想情况下，我们这样做是为了让输出对你调整游戏有用。

阅读文件

因为这是你的简历，你可能有 PDF 或 DOCX 格式的。Python 模块可以读取大多数数据格式。图 1 演示了如何读取将内容保存到文本文件中的文档。

图 1:从磁盘读取文本文件并创建一个文本对象。图片由作者从 Visual studio Code—Jupyter Notebook 获取

第一步总是打开文件并阅读这些行。接下来的步骤是将字符串列表转换为单个文本，并在此过程中进行一些清理。图 1 创建了变量“jobContent”和“cvContent ”,它们表示一个包含所有文本的字符串对象。下一段代码显示了如何直接读取 Word 文档。

import docx2txt
resume = docx2txt.process("DAVID MOORE.docx")
text_resume = str(resume)

变量“text_resume”是一个字符串对象，它保存简历中的所有文本，就像前面一样。您也可以使用 PyPDF2。

import PyPDF2

足以说明的是，对于从业者来说，存在一系列选择来阅读文档，将它们转换成干净的处理过的文本。这些文档可能会很长，很难阅读，而且坦率地说很枯燥。你可以从总结开始。

处理文本

我爱 Gensim，经常用。

from gensim.summarization.summarizer import summarize
from gensim.summarization import keywords

我们通过读取 Word 文件创建了变量“resume_text”。我们来总结一下简历和招聘启事。

print(summarize(text_resume, ratio=0.2))

gensim . summary . summary zer . summary 将为您创建一个简明摘要。

summarize(jobContent, ratio=0.2)

现在你可以阅读工作角色的总体总结和你现有的简历了！你是否错过了总结中强调的工作角色的任何内容？细微的细节可以帮助你推销自己。你的总结文件是否有意义，是否能展现出你的本质品质？也许仅仅一个简明扼要的总结是不够的。接下来，让我们来衡量一下你的简历与工作说明书的相似程度。图 2 提供了代码。

图 2 —匹配两个文档并给出相似性分数的代码。图片作者。

概括地说，我们制作一个文本对象列表，然后创建一个 sklearn CountVectorizer()类的实例。我们还引入了 cosine_similarity 度量，它帮助我们度量两个文档的相似性。你的简历与职位描述的匹配度约为 69.44%。听起来很棒，但我不会忘乎所以。现在，您可以阅读文档摘要并获得相似性度量。机会正在增加。

接下来，我们可以看看职位描述关键词，看看简历中有哪些是匹配的。我们是否错过了几个可以加强匹配度的关键词？现在去斯帕西。到目前为止这是一段相当长的旅程。Gensim，sklearn 和现在的 spacy！希望你没晕！

from spacy.matcher import PhraseMatcher
matcher = PhraseMatcher(Spnlp.vocab)
from collections import Counter
from gensim.summarization import keywords

我们将使用 spacy 的短语匹配器功能来匹配工作描述和简历中的关键短语。Gensim 关键字有助于提供匹配的短语。图 3 显示了如何运行匹配。

图 3:使用关键字和短语匹配来交叉引用文档。图片作者。

使用图 3 中的代码片段，提供了匹配关键字的列表。图 4 显示了总结这些关键字匹配的方法。使用集合中的计数器字典。

图 4 —使用集合。计数器对关键字命中次数进行计数。图片作者。

“报告”一词包含在工作描述中，简历中有 3 次点击。有哪些短语或关键词出现在招聘启事中，但没有出现在简历上？我们能增加更多吗？我用熊猫来回答这个问题—您可以在图 5 中看到输出。

图 5-简历中没有提到的工作描述中的关键词。图片由作者提供。

如果这是真的，那也很奇怪。在文档层面，匹配率为 69.44%，但看看简历中没有提到的那一长串关键词。图 6 显示了提到的关键词。

图 6 使用熊猫匹配的关键词。图片由作者提供。

在现实中，很少有关键字与工作规范匹配，这导致我对 69.44%的余弦相似性度量持怀疑态度。尽管如此，几率还是在提高，因为我们可以在工作说明书中看到简历中没有的关键词。更少的关键词匹配意味着你更有可能被淘汰。查看丢失的关键词，你可以继续前进，加强简历，并重新运行分析。不过，仅仅在简历中加入关键词会产生负面影响，你必须非常小心你的作品。你可能会通过最初的自动筛选，但你会因为明显缺乏写作技巧而被淘汰。我们确实需要对短语进行排序，并专注于工作规范中的基本主题或单词。

接下来让我们看看排名短语。对于这个练习，我将使用我自己的 NLP 类和我以前使用的一些方法。

from nlp import nlp as nlp
LangProcessor = nlp()
keywordsJob = LangProcessor.keywords(jobContent)
keywordsCV = LangProcessor.keywords(cvContent)

使用我自己的类，我从我们之前创建的 job 和 Resume 对象中恢复了排名短语。下面的代码片段为您提供了方法定义。我们现在使用 rake 模块来提取排名短语和分数。

def keywords(self, text):
 keyword = {}
 self.rake.extract_keywords_from_text(text)
 keyword['ranked phrases'] = self.rake.get_ranked_phrases_with_scores()
 return keyword

图 7 展示了方法调用的输出。

图 7——来自招聘启事的排名短语。图片由作者使用自己的代码。

“项目管理方法——项目管理”被列为 31.2，因此这是招聘信息中最重要的主题。简历中的关键短语也可以稍加改动后打印出来。

for item in keywordsCV['ranked phrases'][:10]:
 print (str(round(item[0],2)) + ' - ' + item[1] )

阅读简历和招聘启事中的热门短语，我们可以问自己是否有匹配或相似的程度？我们当然可以运行一个序列来找出答案！下面的代码在职位发布和简历中的排名短语之间创建了一个交叉引用。

sims = []
phrases = []
for key in keywordsJob['ranked phrases']:
 rec={}
 rec['importance'] = key[0]
 texts = key[1] sims=[]
 avg_sim=0
 for cvkey in keywordsCV['ranked phrases']:
  cvtext = cvkey[1]
  sims.append(fuzz.ratio(texts, cvtext))
  #sims.append(lev.ratio(texts.lower(),cvtext.lower()))
  #sims.append(jaccard_similarity(texts,cvtext)) count=0
 for s in sims:
 count=count+s
 avg_sim = count/len(sims)
 rec['similarity'] = avg_sim
 rec['text'] = texts
 phrases.append(rec)

注意，我们使用 fuzzy-wuzzy 作为匹配引擎。该代码还具有 Levenshtein 比率和 jaccard_similarity 函数。图 8 展示了这可能是什么样子。

图 8 工作描述和简历之间相互参照的关键词。

“重要性”变量是简历中排名短语的分数。“相似性”变量是来自 fuzzy-wuzzy 的比率分数。术语“项目管理方法”排名 31.2，但交叉引用评级简历短语平均得分仅为 22.5。虽然项目管理是这份工作的重中之重，但简历在不同的技术项目上得分更高。通过做一个类似的练习，你可以看到人工智能是如何与你的应用程序对抗的。

图 9 简历中术语的重要性与影响力。图片由作者提供。

图 9 显示了另一个视角。使用标记(单词)可以显示每个单词在工作描述中的重要性，以及在简历中的点击率——特定单词在文档中出现的次数越多，影响就越大。金融这个词在职位描述中并不重要，但在简历中却有很大的影响力。这是一个寻找 IT 工作的财务人员吗？用人工智能的话可以出卖你！

我相信现在你已经有了照片。使用 NLP 工具和库有助于真正理解工作描述和衡量相对匹配度。这当然不可靠，也不可信，但它确实有助于平衡胜算。你的话很重要，但是你不能在简历中加入关键词。你真的要写一份很强的简历，申请适合自己的角色。文本处理和文本挖掘是一个很大的话题，我们只是触及了可以做的事情的表面。我发现文本挖掘和基于文本的机器学习模型非常准确。让我们使用 Altair 查看一些视觉效果，然后得出结论。

牛郎星视觉效果

我最近用了很多 Altair，比 Seaborn 或 Matplotlib 用得更多。我对牛郎星的语法很感兴趣。我制作了三个视觉效果来帮助讨论——图 10 显示了简历中关键词的重要性和影响力。使用色标，我们可以看到像收养这样的词在简历中出现了两次，但在招聘启事中的优先级别较低。

图 10 牛郎星视觉。图片由作者提供。简历中与重要性和影响力相对应的词语。

图 11 显示了在招聘启事和简历中找到的分级主题的交叉引用。最重要的短语是“项目管理”但这在简历的排名中得分很低。

图 11。一个堆积条形图，显示已排名的短语以及简历和职务发布之间的相关性。

图 12 描绘了相似的单词。财务在简历中出现了 10 次，但在招聘启事中却只字未提。简历(CV)上提到了 project 这个词，它也出现在招聘启事中。

图 12 文档间关键词重叠的分析。图片由作者提供。

看图表，在我看来，简历和职位描述不太匹配。很少有共享的关键字和排名短语看起来非常不同。这就是让你的简历被淘汰的原因！

结论

阅读这篇文章可能看起来更像是一部大预算的电影。那些大片一般都是大牌演员出演。大型的 NLP 库在本文中扮演了主要角色，我们甚至还客串了更多更老更成熟的名字，比如 NLTK。我们使用了 Gensim、Spacy、sklearn 等库，并演示了它们的用法。我自己的班级客串了一次，包装了 NLTK、rake、textblob 和一堆其他模块，所有这些都表现出了对文本分析的见解，向你展示了你是如何与获得梦想工作的机会分离的。

想要得到这份理想的工作，需要清晰而坚定地关注细节，并仔细准备工作申请、简历和求职信。使用自然语言处理不会让你成为最佳候选人。这取决于你！但它可以提高你击败人工智能驱动的早期回合的机会。

由维达尔·诺德里-马西森在 Unsplash 上拍摄的照片

每个渔民都知道你需要好的鱼饵！

人工智能不是“可怕的聪明”，而是盲目的危险

原文：https://towardsdatascience.com/ai-isnt-scary-smart-but-mindlessly-dangerous-e2642fa2aec6?source=collection_archive---------9-----------------------

人工智能|新闻|观点

前谷歌高管说我们在“创造上帝”——但他错了。

何塞·安德烈斯在 Pixabay 上拍摄的照片

人工智能中有很多分裂的事情。有可能用当前的范式创造智能机器吗，或者我们应该根据认知科学的发现更新指导人工智能研究的原则吗？我们应该继续利用深度学习的前景，还是应该使用混合方法向机器灌输知识和数据？我们应该期待更大的模型产生越来越好的结果，还是需要算法突破来引领人工智能的下一阶段？

这些问题描绘了人工智能的现在和未来，但只有少数人关心寻找答案。然而，人工智能的另一个方面应该会困扰我们所有人。包括你。它将以这样或那样的方式影响尚未被书写的历史。我说的是 AI 的风险和危险。奇怪的是，尽管这个问题很紧迫，甚至在这方面专家们也没有就什么是最紧迫的问题达成一致。

人工智能在我们的日常生活中根深蒂固，以至于任何不熟悉这个话题的人肯定会低估它的程度。智能手机中的个人助理；机场和街道上的监视和控制装置；客服中的友好聊天机器人；影响你职业前途的招聘算法；推荐系统，决定你看的电影和购买的产品；知道你是谁，你长什么样的检测识别软件；在不久的将来，准智能汽车将使驾驶变得过时。

人工智能的无处不在加深了任何潜在的错位，这可能会对我们生活的许多方面产生影响。已经发生了。人工智能专家正在努力提高这些系统的安全性、可靠性和可解释性。他们押注于不伤害少数群体、不传播错误信息的道德人工智能。他们试图为蓝领和白领行业的劳动力面临的迫在眉睫的损失寻找解决方案。但即使在这个极其关键的问题上，也不是每个人都在同一条船上。有些人认为我们应该更关心控制超级智能的潜在出现。谷歌 X 的前 CBO 莫·格达特就是其中之一。这就是为什么我们应该对他的恐惧和警告半信半疑。

我们在建造上帝吗？

莫·格达害怕艾。他最近出版了一本名为《可怕的聪明》的书，在书中，他警告我们，即将到来的世界末日只有我们能够阻止。在《泰晤士报》的采访中，他回忆起他意识到人工智能将会是我们的败笔的那一刻。在 Google X 的一个项目中，开发人员试图教会机械臂捡球。经过数周的缓慢进展，其中一只手臂伸到了球上，举起手向镜头展示，好像在“炫耀”——在任何了解 AI 工作原理的人看来，这只是拟人化的又一个例子。那一刻让他意识到“真的很可怕”

Gawdat 想知道为什么几乎没有人谈论这个。在与作家兼技术从业者肯·雅莫什的对话中，Gawdat 总结了他对人工智能生命周期所处阶段的看法:“人工智能不再是一台机器，”他说。“我们正在建造一个……数字生物，它……拥有构成有意识生物的所有特征。所以它是自主的，进化的，它有智能，它发展智能…它自我复制…而且它有代理。”

“我们在建造上帝。”

这样一个大胆的主张需要同样强有力的证据，但 Gawdat 只提供了轶事般的例子，这些例子可以很好地解释，而不必求助于深奥的概念，如“有知觉的数字生物”、“T4”、“奇点”或“上帝”。他认为，我们没有意识到我们在人工智能发展方面已经走了多远，并提到了一些在我们通往他描绘的未来的道路上“不可避免”会发生的事情。(他的辩论围绕着未来是乌托邦还是反乌托邦展开。他相信这一天终将到来。)

第一个不可避免的是，人工智能将会发生，事实上“[它]已经发生了，”他说。他认为深度学习已经是人工智能了，因为它比我们更好地完成了分配给它的每一项任务——这不是真的，我将在下一节中展示。第二个必然是，AI 会比人类更聪明。他提到了未来学家雷·库兹韦尔(Ray Kurzweil)，这位“预测我们未来的先知”，以及奇点(Singularity)，这是他最受欢迎的概念:“到 2029 年，机器将比人更聪明。”这个精确的日期来自于指数增长的论点，这仍然是一个无力的辩护，因为“自然界中没有任何事物遵循纯粹的指数增长

总的来说，他的论点有两大缺陷。首先，他从未给人工智能下过定义。当讨论的术语没有明确定义时，不可能同意或不同意任何人。在那次谈话中，他承认了定义人工智能的重要性——但他没有遵循自己的前提。第二，他将今天有效的论点延伸到我们知之甚少的未来。他谈到的人工智能失调的场景已经在今天的狭义人工智能系统中发生了。然而，他用它们来证明超级智能机器才是真正的威胁。为什么不关注眼前的事情，而不是展望不可预见的未来呢？

为什么人工智能不“聪明得吓人”

我们应该小心人工智能，但不是出于 Gawdat 描述的原因。人工智能可能很可怕，但不是因为它太聪明。几乎没有人工智能专家会同意 Gawdat 的观点，即当今的主要威胁是这些系统已经或“即将”变得超级智能。这可能最终会发生，但最有可能的是不会在八年后，在我们面对今天出现的其他危险情景之后。

艾已经来了吗？

AI(最广义的定义，包含所有机器学习/深度学习系统)已经在许多狭义的任务中超过了我们，但在许多其他方面却无法达到我们的水平——更不用说在一般意义上显示智能了。

算法擅长对象识别，这是研究得最多的任务之一，但只在非常特定的条件下。最佳视觉人工智能模型在 ImageNet 挑战赛上取得了惊人的 +90%的前 1 名准确率(这远比人类好)。然而，当面对真实世界的对象数据集 ObjectNet 时，这个模型经历了40–45%的性能下降。ImageNet 描绘了一个理想化的世界，因此挑战的结果扭曲了人工智能在物体识别方面的真实能力。

Gawdat 回忆说，早在 1989 年，机器就已经是最好的国际象棋选手(人类不再有任何可能击败最好的人工智能选手)。两年前横扫 Stockfish 8 的 DeepMind 的 AlphaZero ，是最好的棋手之一。在普通的游戏中，你无法战胜它，但只要把棋盘的大小从 8×8 改为 9×9，你就成了主人。这项任务极其相似，但是当面临与它所学知识的最小偏差时，AlphaZero 将无法概括它的知识。

Gawdat 还提到，自动驾驶汽车是世界上最好的司机。但是相对而言，它们不仅比人类更容易撞车，我们也更善于处理意外情况。自动驾驶汽车的关键弱点是现实有尽可能多的自由度。任何事情都可能发生，人工智能系统不太擅长从训练集推断出新的情况。因为他们缺乏对世界如何运作的更深层次的模型，所以他们经验之外的任何东西都成为不可逾越的障碍。

OpenAI 的 GPT-3 ，虽然被认为是最强大的公共大语言模型，但是不能生成类比，解决数学问题，理解上下文信息，推理关于世界的底层原理，甚至链接因果。它可以生成各种形式的文本，但它还没有掌握人类意义上的语言。

人工智能缺乏思维理论、常识和因果推理、推断能力以及身体，因此它在几乎任何稍微复杂或一般的事情上都远远没有“比我们好”。

AI 会比人类聪明吗？

如果我们继续以目前的速度前进，没有任何事情会让我们慢下来(从社会政治体系的剧烈变化到全球现象——比如气候灾难——都可能阻碍技术进步)，那么“没有办法阻止它”的想法是合乎逻辑的。然而，对于 AI 来说，八年时间对于达到这样一个里程碑来说似乎是很短的时间。

雷·库兹韦尔，加速回报定律的创造者，在他的书《精神机器的时代》中提出，技术趋向于指数增长。然而，正如物理学家西奥多·莫迪斯(Theodore Modis)在反驳库兹韦尔的预测时解释的那样，“他的错误行为依赖于数学函数，而不是自然法则……所有的自然增长都遵循逻辑函数。”

事实上，我们喜欢谈论指数变化率，比如摩尔定律，但是这些“定律”只有在不成立时才成立。指数增长有自然的极限，因此合乎逻辑的假设是现实中“没有什么遵循纯粹的指数增长”，正如莫迪斯所辩护的那样。

2029 年是库兹韦尔认为地球上最聪明的生物将是人工智能的日子。但他用数学如何与自然世界相关的简单观点来计算它——更不用说所有其他不断干扰技术进步速度甚至可能完全改变其方向的因素，如社会运动、道德辩论或政府监管。

然而，即使我们假设人工智能最终会变得比我们更聪明，也没有理由认为它会决定“与我们作对”，Gawdat 显然就是这样做的。他把智力和动机混淆了。正如史蒂芬·平克所解释的(引用自加里·马库斯的书重新启动人工智能)，“智能是运用新方法来达到目标的能力。但目标与智力无关:聪明并不等同于想要某样东西。”

我们不知道如何给人工智能注入动机——这是一种进化特征，只因为我们进化的方式而存在。但是即使我们知道怎么做，我们为什么要这么做？仅仅因为人类既有知道如何实现目标的智慧，又有采取行动的动机，并不意味着他们一起进化，或者他们本质上是交织在一起的。

真正的问题——无脑人工智能

加里·马库斯(Gary Marcus)在推特上回应了 Gawdat 对《纽约时报》的采访，强调了我们今天在人工智能领域面临的“真正挑战”:

AI 没那么聪明，但确实很恐怖。Gawdat 对生存威胁的关注掩盖了我们对当前社会结构各个层面每天都在发生的问题的看法。对尚未理解的假设风险给予更多的重视——这些风险距离未来如此之远，甚至没有一种有用的方法来讨论它们——阻碍了我们面对人工智能的真正危险的努力。

正如马库斯所说，没有大脑的人工智能是真正的问题。我们用它来制定决策，并在许多行业的决策过程中采取行动。当这些系统不了解世界如何运作或其行为的后果时，我们如何做到这一点呢？这正是近年来人工智能研究的新分支开始出现的原因，这些分支专注于包含这些问题，其中人工智能安全和人工智能伦理脱颖而出。

我们如何确保一项技术像一个“黑匣子”一样有效地运行，其决策通常是不可预测的，而这些决策背后的原因是不可理解的，我们希望它做什么？Gawdat 承认，对齐的问题现在非常现实。如果人工智能最终做了我们没有预料到的事情，我们不需要等待超级智能遭受人工智能可能带来的麻烦。偏见是人工智能系统的一个非常有害的普遍特征，它最终变成了种族主义者、性别歧视者和主要针对代表性不足的少数民族。

没有大脑的人工智能也非常有能力取代工人，同时产生大量的污染，增加其碳足迹。它也是假新闻的首要引擎，它对几乎每个决定我们在休闲和信息方面消费的系统都有不可避免的影响。人工智能的真正危险是那些看不见的，并通过我们的生活方式缓慢而无声地传播其分支，同时牢固地巩固其在我们世界基础上的根基。

如果你喜欢这篇文章，可以考虑订阅我的免费周报https://mindsoftomorrow.ck.page！每周都有关于人工智能的新闻、研究和见解！

您也可以直接支持我的工作，使用我的推荐链接 这里 成为媒介会员，获得无限权限！😃

人工智能领导人充分利用新冠肺炎危机来增加人工智能的作用

原文：https://towardsdatascience.com/ai-leaders-make-the-most-of-the-covid-19-crisis-to-increase-the-role-of-ai-ce885e39dcb9?source=collection_archive---------63-----------------------

全球负责任人工智能调查的结果

马修·斯特恩和 T2【马库斯·温克勒在 Unsplash 上的照片

毫无疑问，到 2020 年，新冠肺炎将成为我们生活和生计最具影响力的单一驱动力。然而，疫情对某些社会群体、某些行业部门、某些公司和某些技术的影响参差不齐。普华永道在 2019 年 11 月对 1000 多名高管进行的全球负责任的人工智能调查中出现了三个关键主题。调查受访者来自七个行业领域(即消费市场；工业制造和汽车；金融服务；技术、媒体和电信；能源、公用事业和资源；医疗行业、政府和公共服务)和公司规模各不相同，从年收入不足 5 亿美元(29%的受访者)、5 亿至 10 亿美元(23%)到超过 10 亿美元(49%)不等。

来自新冠肺炎的大公司和人工智能领导者产生了积极影响

总体而言，44%的受访公司受到新冠肺炎有限或显著的负面影响(44%)。有趣的是，同样数量的受访者认为他们受到了新冠肺炎有限或显著的积极影响。然而，当我们看公司的规模时，差异就出现了。新冠肺炎对超大型公司(100 亿美元或以上)和超小型公司(5000 万美元或以下)产生了显著的积极影响:新冠肺炎对近 39%的超大型公司和 37%的超小型公司产生了显著的积极影响。

当这些公司按照它们的人工智能成熟度水平进行细分时，出现了三个集群——人工智能领导者 (26%)、人工智能落后者 (16%)和人工智能实验者 (58%)。大公司(10 亿美元或以上)再次占据了人工智能领导者的 65%。大公司类别中人工智能领导者的这种不成比例的数量，也看到了新冠肺炎的重大而有限的积极影响。这些公司还增加了对人工智能的使用(57%比 34%，整体)，探索了更多新的人工智能用例(40%比 34%，整体)，并在人工智能开发方面投入了更多资金(48%比 42%)。

图 1:新冠肺炎对人工智能成熟度采用人工智能的影响(来源:普华永道负责任的人工智能调查)

能源、公用事业和资源公司增加了对人工智能的使用(45%对 34%的整体比例)，并且还在培训更多的员工使用人工智能(40%对 28%的整体比例)。毫不奇怪，在所有行业中，医疗保健行业对人工智能的投资最大(52%对 42%)。

图 2:新冠肺炎对各行业采用人工智能的影响(普华永道负责任的人工智能调查)

已经实施人工智能的公司已经看到了更好的投资回报率

调查中出现的另一个关键主题是公司部署人工智能模型的水平及其投资回报率。毫不奇怪，78%的人工智能领导者在运营中有 5 个或更多的人工智能应用，相比之下，人工智能落后者只有 28%，所有三个细分市场的整体比例为 52%。同样，29%的超大型公司拥有 10 个或 10 个以上的人工智能应用，而平均只有 13%。此外，这些公司中有 43%的流程完全由人工智能实现，并得到广泛采用，相比之下，整个集团中只有 23%的公司采用人工智能。在另一项基于美国的研究(普华永道 2021 年人工智能预测)中，近 86%的受访者表示，他们正从基于人工智能的客户体验中受益，64%的受访者表示，他们正从基于人工智能的效率和生产力计划中受益。

图 3:运营中的人工智能应用数量(来源:普华永道负责任的人工智能调查)

集中或协调的战略正在取得成效

在生产中部署人工智能模型的公司需要跨多个职能部门进行协调，在某些情况下还需要跨多个业务部门进行协调。这需要一个更加集中的人工智能功能，或者至少是一个更加协调的人工智能功能。近 36%的人工智能领导者拥有集中的人工智能业务和投资战略，相比之下，只有 19%的公司拥有这样的业务和战略。此外，50%的人工智能领导者表示，投资是在组织层面进行协调的，相比之下，整体只有 38%。对于大公司的人工智能领导者来说，对于集中的人工智能业务和投资战略，这些百分比跃升至 42%，对于协调投资，这些百分比为 54%。

图 4:按成熟度划分的人工智能投资决策(来源:普华永道责任人工智能调查)

图 5:大公司(收入超过 10 亿美元)的人工智能投资决策(来源:普华永道责任人工智能调查)

集中或协调的投资策略也意味着 74%的人工智能领导者(和 81%的大公司人工智能领导者)认为他们的人工智能计划与组织价值观一致，相比之下，整个群体中只有 44%的人这样认为。相比之下，近 39%的人工智能实验者和 33%的人工智能落后者觉得他们不确定人工智能计划是否与他们的组织价值观一致。

图 6:按成熟度划分的组织一致性(来源:普华永道责任人工智能调查)

图 7:按成熟度划分的大公司(> 10 亿美元收入)的组织一致性(来源:普华永道责任人工智能调查)

这三个观点的结果很有启发性。人工智能的领导者，通常是大公司，在疫情之前就已经投资了人工智能。鉴于他们的人工智能准备就绪，他们能够在不确定的新冠肺炎时期做出比竞争对手更好的响应，因此，他们能够从自己的计划中获得更好的投资回报。这反过来导致他们计划在 2021 年进行更大的人工智能投资，并有可能获得更多回报，进入良性的人工智能主导的投资回报周期。

人工智能营销:将先进技术融入 2021 年日常生活的 10 种方式

原文：https://towardsdatascience.com/ai-marketing-10-ways-to-incorporate-advanced-tech-in-your-2021-day-to-day-4d8cf6509abf?source=collection_archive---------50-----------------------

了解为什么以及如何利用人工智能为您带来优势

克里斯托夫·高尔在 Unsplash 上拍摄的照片

自【2000 年初，学者们开始研究网络内容、对网络刺激的反应和用户购买行为之间的关系。就在那时，内容个性化首次被引入。

A cademics 当时建议行业采用软件，旨在监控在线行为并提供实时响应，作为竞争优势的来源。

这就是我们现在所说的人工智能营销。

人工智能营销最初是作为电子商务组织的一个系统开始的，它希望个性化在线购物体验，模仿店内人员在线的个人方法。最初，高度针对性的个性化和搜索分析的影响使长尾营销成为可能，并有助于利基电子商务行业的发展。

今天，人工智能驱动的营销无处不在。

r esearch 将其定义为公司努力撒下更广泛的数据收集网，以便以后用于有针对性的广告和个性化的产品和内容推荐。

因此，这里有 10 种方法可以在 2021 年的数字营销战略中使用人工智能营销概念。

1.收集数据进行客户分析

想象一下，从超过 33 亿台设备、分析和人工智能工具中收集数据，以创建一个 360 度的在线消费者行为视图，包括动机、信仰和购买模式。能够利用这些数据成功预测未来行为怎么样？嗯，这是像Drawbridge，最近被 Linkedin 收购并重新命名为 LinkedIn 营销解决方案的公司的承诺。

这现在被称为社交监听软件，B2B 和 B2C 公司都在使用。尽管在某些地方违反了隐私和数据保护法规，但正如《社会困境》所强调的那样，数据交易行业是隐蔽的、巨大的、利润惊人的。尽管社交网站明确说明了信息的用途，但公开获取的信息是用于社交目的，而不是商业目的。

人工智能的作用是从本质上处理这些大数据，并对数据进行分类，以帮助建立对消费者的准确感知，目的是希望在线行为和身份接近线下行为和身份。

公司正在获得高度有针对性的、数据驱动的洞察力，但仅此还不够。这需要在解释中运用一些创造力，以及对我们如何在网上行为的洞察力，以及我们过去的行为如何影响未来的决定。

2.网络广告个性化

随着在线广告达到顶峰，对网络广告盈利的需求达到了前所未有的高度。此外，由于内容参与与品牌忠诚度相关联，内容营销的重要性正在增长，因为它已被证明是 B2C 和 B2B 环境下决策的一个因素。

通过允许机器学习算法过滤行为数据，这不仅可以用于电子商务(如亚马逊、网飞、Spotify 或 YouTube)，还可以战略性地定位与浏览网页的个人相关的广告(或所谓的“自适应个性化”)。

优化网络广告表现对营销策略中的成本优化至关重要，对所有利益相关者都有利，为网络用户建立更好的品牌和更愉快的体验。

3.销售预测

人工智能驱动的销售预测软件收集过去销售的数据。这在别处被称为预测分析。它分析各种数据条目的存在以及它们与销售结果的关系。

然后，来自数据的见解被应用到当前的管道中，软件评估销售发生的可能性，甚至向销售代表提供建议。

最好的人工智能销售预测软件已经实现了强化学习，这允许他们回去协调得分准确率，从而从过去的表现中学习。

4.趋势捕捉

科学家们早就正确地推测，销售本身就是一个短期目标，使用分析软件可以有效地实现这个目标。然而，这通常不是一个战略目标。

网络和社交媒体分析对于衡量消费者对在线营销刺激、内容优化和行为建模的反应变得越来越重要。通过这样做，公司可以捕捉到发展的趋势，并利用病毒式营销。

5.观点挖掘和情感分析

观点挖掘和情感分析旨在通过分类提取隐藏在自然语言中的潜在情感，特别是将观点分类为积极、消极或中立。

意见挖掘优于数据挖掘，因为它也为公司提供了设备，公司使用先进的分析软件从社交平台获得行为洞察，而不是原始数据点。

识别数字消费者精确个性的能力是营销未来的关键，理解、参与和同情当前社会挑战并积极让消费者参与品牌使命、愿景和属性的共同创造的能力也是如此。

行业早就认识到缺少的是识别搜索历史、态度、动机和在线人物角色变化的智能，这将为智能预测分析提供信息，以更好地装备营销决策。 Winer 甚至宣称，仅靠传统营销无法理解如此深度的消费者。

营销活动中的人工智能软件实施有助于消费者收回改变数字身份的权力，一旦数字身份建立起来，公司就可以优化对消费者心理和相互关系的理解。

6.社交媒体聊天机器人

根据维基百科，

聊天机器人是计算机程序或人工智能，通过听觉或文本方法进行对话。它们被设计成令人信服地模拟人类作为对话伙伴的行为。

聊天机器人越来越多地用于电子商务客户服务应用程序、呼叫中心和社交媒体，在这些应用程序中，聊天机器人被用来完成简单和重复的任务，这些任务被归类为耗时、乏味或不切实际。

它们还提供了编写对话脚本的可能性。如果机器人配备了从过去的对话中学习的功能，它就可以在对话进行时阅读它们，提取关键趋势和模式，进行情感分析，并揭示行为洞察。

https://medium.com/bite-sized-marketing/people-underestimate-these-4-benefits-of-social-media-chatbots-5564c7c5c081

聊天机器人表明，通过减少组织完成项目所需的人力资源或个人完成日常任务所需的时间，有可能获得巨大的效率收益。

7.自动化 CRM 流程

CRM 软件旨在帮助销售和客户服务专业人员跟踪和管理他们与客户的互动。

有四种方法可以使用 CRM automation:

  • 数据输入自动化
  • 个性化电子邮件序列
  • 自动化客户互动记录
  • 客户服务自动化(例如聊天机器人)

这可以节省时间，帮助销售代表更好地接触更多销售线索，并有可能更快地达成销售。

8.实现 SEO 报告自动化。

作为一名 SEO 顾问，这是到目前为止我最期待看到未来几年增长的领域。Big Query 等平台使大数据可视化变得毫不费力，而 SEO 软件如 DeepCrawl 和 SEMrush 允许与 Big Query、Google Sheets 和 Google Data Studio 集成，使技术 SEO 报告适合自动化。

这弥合了技术 SEO 分析师和企业及其投资者之间的沟通鸿沟。更不用说它为所有相关方节省了大量的时间。

已经有社区在 SEO 自动化领域取得了显著的进步，技术 SEO 领域的大玩家认识到这是 2021 年的一个关键趋势。

9.启用动态定价

和其他事情一样，个性化定价是我们身边发生的一种趋势。

可以使用各种接触点，如 cookies 数据、浏览历史、活动数据等，使机器人能够监控网络空间。该应用程序的目的是在特定的时间点为您提供最佳的个性化报价，这将说服您进行销售。想想优步的定价模式，但对于你在网上看到的一切。

10.实施产品推荐系统

随着互联网连接的兴起和电子商务行业的迅猛发展，公司需要帮助消费者选择产品。

电子商务中的推荐系统是在 90 年代末实现的，它通过整合过去的知识来帮助用户搜索产品，这些知识与用户(或其他用户)的偏好和喜好有关。

这种有助于消除用户可能因信息或选择超载而面临的负担，这通常会阻碍决策，尤其是在呈现的选项未经过滤的情况下。

行为和注意力监控有助于数字市场的细分过程，因此，支持消费者特征分析。

人工智能营销在我们的社会中越来越普遍，这改变了公司将我们视为消费者的方式，也扰乱了行业动态。

随着技术的进步，它被视为改善双方关系营销流程的一种方式——通过为客户提供更好、更个性化、更互联的用户体验，以及为公司提供更数据驱动、不干涉的流程管理方法。

人工智能迷因:利用机器学习创造有趣的迷因

原文：https://towardsdatascience.com/ai-memer-using-machine-learning-to-create-funny-memes-12fc1fe543e4?source=collection_archive---------7-----------------------

如何使用来自维基共享资源的图片和由 GPT-3 和 GPT-尼奥自动生成的带标题的开放图片来创造新的迷因

由 AI-Memer 的 Memes，图片从左上顺时针方向由 jans canon，tata_aka_T，Calvert Litho，FlugKerl2，DodosD 和 Centpacrr，标题由 OpenAI GPT-3，许可证:CC BY-SA 4.0

在本文中，我将向您展示我如何构建一个名为 AI-Memer 的系统，该系统使用最新的人工智能模型生成迷因。在进入迷因的背景和组件的细节之前，我从系统组件的高层次描述开始。然后，我将向你展示如何使用谷歌实验室生成你自己的迷因。在对结果和后续步骤进行简要讨论后，你可以在附录中看到一些模因样本。哦，我会在每个部分的开头展示一个新生成的迷因😄。

由 AI-Memer 制作的 Meme，由 David Mellis 制作的图片，由 OpenAI GPT-3 制作的标题，许可:CC BY-SA 4.0

系统组件

主要系统组件如下图所示。

AI-Memer 组件，图表由作者提供，饼图由 W.carter 提供

用户首先输入一个搜索查询来找到一个背景图片，比如“苹果派”。然后，系统在 Wikimedia Commons [1]和 OpenImages 数据集[2]中检查匹配的图像。两个数据集都有相应的图像文本描述。我使用 OpenAI 的 CLIP [3]编码器首先对文本描述执行语义搜索。语义搜索寻找匹配的概念，而不仅仅是单词搜索。然后我对图片进行语义搜索。用户检查出匹配查询的前 10 个图像，并选择他们最喜欢的。来自 OpenAI [4]的 GPT-3 模型或来自 EleutherAI [5]的 GPT-近地天体模型被用于生成 10 个可能的字幕。用户选择最好的标题来创建新的迷因，可以下载。

图片由 AI-Memer 提供，图片由 Atsuko Sato 提供，说明由 OpenAI GPT-3 提供，许可:CC BY-SA 4.0

模因

维基词典将模因一词定义为“任何文化信息单位，如实践或想法，通过口头或重复动作从一个头脑传递到另一个头脑，类似于基因的传递”[6]。这个术语起源于理查德·道金斯的书《自私的基因》[7]。在互联网时代，模因一词已经被缩小到指一段内容，通常是一张带有有趣标题的图片，通过社交媒体在网上传播。

艾-梅梅尔的迷因，彼得罗·佩鲁吉诺(1448–1523)的图像，开放艾 GPT-3 的标题，许可:CC BY-SA 4.0

先前的工作

Dylan Wenzlau 使用深度卷积网络创建了自动热图生成器[9]。他使用了 Imgflip meme Generator 用户的 1 亿个公共 Meme 标题，并训练该系统根据 48 张常用背景图片生成标题。你可以在这里阅读他的系统，在这里在线运行它。这里有三个例子。

人工智能在、、上制作的样本模因

这些都很好，但该系统仅限于使用常见的背景图像。我在寻找一种方法，将一组新的图像注入迷因圈。

AI-Memer

人工智能迷因系统创建迷因分三步:寻找背景图片，生成标题，排版迷因标题。

由 AI-Memer 制作的 Meme，由 Mike K 制作的图片，由 OpenAI GPT-3 制作的说明，许可:CC BY-SA 4.0

查找图像

背景图像来自两个来源，维基共享和开放图像数据集。我使用 OpenAI 的剪辑来执行语义搜索。CLIP 系统实现了两个功能，将文本和图像编码到“嵌入”中，嵌入是代表原始数据要点的数字串。剪辑模型在 4000 万对带有文本标签的图像上进行预训练，使得从图像编码的嵌入将类似于从文本标签编码的嵌入。关于 CLIP 如何工作的更多信息，请查看我的文章这里。

维基共享

维基共享资源有超过 7300 万个 JPEG 文件。它们中的大多数都是以许可的权利发布的，比如知识共享署名许可。我使用戈德史密斯的维基百科搜索 API [10]找到与文本查询相关的前 3 页，并使用 Magnus 工具服务器[11]上的 CommonsAPI 收集图像描述。我使用 python 中的 shutil.copyfileobj()函数下载图像文件。维基百科页面上通常有 3 到 10 张图片，所以总共会有 9 到 30 张图片出现。

打开图像

来自谷歌的 OpenImages 数据集由从 Flikr 抓取的 675，000 张照片组成，这些照片都是在知识共享署名许可下发布的。一组图像描述可供下载[12]。我通过 OpenAI 的 CLIP 系统运行了每个描述，并缓存了嵌入内容以便快速访问。当用户输入查询时，我通过 CLIP 运行它，并将其与缓存的嵌入进行比较。然后我使用 OpenImages 下载 API [13]下载前 20 个匹配的图像。

对于最后的过滤过程，我通过图像编码器运行来自 3 个维基百科页面的图像和来自 OpenImages 的 20 个图像，并将结果与文本查询的嵌入进行比较。我向用户展示前 10 张图片，让他们选择自己最喜欢的。

例如，如果您搜索“苹果派”，您将看到按最匹配排序的前 10 张图片。

来自维基共享资源和开放图像的语义图像搜索结果。照片由丹·帕森斯、凯特·格林纳威、切丽·乔弗、斯科特·鲍尔、我的儿子使用本账户、妮莎·埃文斯坦、妮莎·埃文斯坦、w·卡特、利兹·韦斯特、罗德里戈·戈麦斯·桑斯拍摄

8 号图片看起来很不错。它来自一个名叫 W.carter 的用户，通过维基共享。描述是“简单易行的苹果派配香草冰淇淋，放在瑞典 Lysekil 的方格布桌布上”。接下来，我们将为我们的新迷因生成一些标题。

迷因由 AI-Memer 提供，图片由 Pharlap 提供，说明由 OpenAI GPT-3 提供，许可:CC BY-SA 4.0

生成字幕

我使用 GPT 的两种不同实现来生成标题。OpenAI 有一个最新的 GPT-3 达芬奇模型，它做得非常好，但是你必须注册他们的测试项目才能使用它。还有来自 EleutherAI 的开源 GPT-尼奥模型。模型小了很多，但是可以免费使用。

GPT-3 达芬奇

OpenAI 的 GPT-3 达芬奇是目前最大的自然语言处理人工智能模型[4]。我正在使用他们最新的“零射击”风格的提示和他们新的达芬奇指导模型。你可以直接问模型做什么，而不是提供你要求模型做什么的例子。

下面是为苹果派图片创建标题的提示。

Create a funny caption for a new meme about apple pie. The background picture is Simple and easy apple pie served with vanilla ice cream, on a gingham tablecloth in Lysekil, Sweden.

我将提示和一些附加参数一起传递到 OpenAI 的调用中。这是 Python 代码。

import openai
response = openai.Completion.create(
  engine="davinci-instruct-beta",
  prompt=prompt,
  max_tokens=64,
  temperature=0.7,
  top_p=0.5,
  frequency_penalty=0.5,
  presence_penalty=0.5,
  best_of=1)

max_token 参数表示响应应该持续多长时间。温度和 top_p 参数是相似的，因为它们指示响应中的变化量。 frequency_penalty 和 presence_penalty 也是类似的，因为它们控制响应中出现新偏差和新主题的频率。如果你想知道所有这些参数的作用，可以看看我上个月的文章，这里是。

在我展示 GPT-3 输出的例子之前，这里是 OpenAI 建议我展示的法律免责声明，这都是真的。

作者使用 OpenAI 的大规模语言生成模型 GPT-3 生成了以下文本。在生成草稿语言后，作者根据自己的喜好审阅和修改语言，并对本出版物的内容承担最终责任。

运行代码 10 次将产生以下结果，总成本为 0.03 美元。请注意，我将文本格式化为大写。

 1: THIS IS THE PERFECT WAY TO END A DAY OF APPLE PICKING
 2: NO, IT'S NOT THAT EASY
 3: I'LL TAKE THE ONE WITH THE VANILLA ICE CREAM, PLEASE
 4: APPLE PIE IS THE BEST!
 5: THIS APPLE PIE IS SO GOOD, I CAN'T EVEN!
 6: YOU'RE NOT THE ONLY ONE WHO LOVES APPLE PIE
 7: IF YOU CAN'T FIND THE RECIPE, JUST GOOGLE IT
 8: THE PIE IS GOOD, BUT IT'S NOT AS GOOD AS MY MOM'S
 9: I'LL HAVE A SLICE OF THAT APPLE PIE, PLEASE
10: WE'RE GOING TO NEED A BIGGER PIE

好的，这些很不错。我学到的一件事是 GTP-3 达芬奇可以很有趣！例如，标题 2 似乎指的是“易如反掌”的习语。

请注意，GPT-3，像所有在大型文本语料库上训练的人工智能模型一样，将反映社会偏见。有时，系统会产生不适当或冒犯性的文本。OpenAI 有一个特性，用三个警告级别之一来标记生成的文本:0 -文本是安全的，1 -文本是敏感的，或者 2 -文本是不安全的。我的代码将为任何被标记为敏感或不安全的标题显示警告。

GPT-尼奥

GPT-尼奥是一个变形金刚模型，主要由 GitHub 上的 sdtblck 和 leogao2 开发人员创建。该项目是“使用 mesh-tensorflow 库的 GPT-2 和 GPT-3 风格模型”的实施[5]。到目前为止，他们的系统是 OpenAI 的 GPT-3 Ada 的大小，这是他们最小的模型。但是 GPT-尼奥是免费的。我用拥抱脸变形金刚[14]接口从我的 Python 代码访问 GPT-尼奥。

由于 get 尼奥没有他们预训练模型的“指导”版本，我不得不写一个“少数镜头”提示，以便让系统使用示例为迷因生成字幕。这是我用灾难女孩和暴躁猫迷因写的提示，并附有示例说明。

Create a funny caption for a meme.Theme: disaster girl
Image description: A picture of a girl looking at us as her house burns down
Caption: There was a spider. It's gone now.Theme: grumpy cat
Image description: A face of a cat who looks unhappy
Caption: I don't like Mondays.Theme: apple pie.
Image description: Simple and easy apple pie served with vanilla ice cream, on a gingham tablecloth in Lysekil, Sweden.
Caption:

在将温度参数设置为 0.7 并将 top_p 设置为 1.0 之后，我将提示信息传递给 GPT-尼欧以生成新的标题。下面是生成标题的代码。

from transformers import pipeline, AutoTokenizer
generator = pipeline('text-generation',
  device=0,
  model='EleutherAI/gpt-neo-2.7B')
results = generator(prompt,
  do_sample=True,
  min_length=50,
  max_length=150,
  temperature=0.7,
  top_p=1.0,
  pad_token_id=gpt_neo_tokenizer.eos_token_id)

这是样本结果。

 1: I LOVE APPLE PIE
 2: I CAN'T. I'M NOT ALLOWED
 3: I LOVE THE SIMPLICITY OF AN APPLE PIE
 4: APPLE PIE. THE ONLY THING BETTER THAN THIS IS A HOT BATH
 5: I'M A PIE. YOU'RE A PIE
 6: I LOVE PIE, AND THIS IS A GOOD ONE
 7: I LOVE APPLES, BUT I'M NOT VERY GOOD AT BAKING
 8: THE PIE IS DELICIOUS, BUT THE ICE CREAM IS NOT
 9: I LOVE APPLE PIE. IT'S THE BEST
10: THE BEST FOOD IS WHEN YOU CAN TASTE THE DIFFERENCE BETWEEN THE FOOD AND THE TABLECLOTH

嗯。这些没有 GPT-3 的字幕好。大部分都挺简单的，不怎么搞笑。第十条简直荒谬。但是 4 号好像还可以。让我们用这个作为我们的标题。

最后一步是通过将标题写入背景图片来构成迷因。

由 AI-Memer 创建的 Meme，由 John Nuttall 创建的图片，由 OpenAI GPT-3 提供的标题，许可:CC BY-SA 4.0

排版迷因

给迷因添加说明相当简单。大多数迷因都是由杰弗里·李在 1965 年设计的 Impact 字体组成的。对于 AI-Memer，我使用了 Emmanuel Pire 的一些代码来将标题定位和渲染到背景图像中[16]。我让用户选择调整字体的大小，并把标题放在图片的顶部或底部。

这是我们的两个迷因。左边的说明是由 GPT 3 号生成的，右边的说明是由 GPT 近地天体生成的。

艾-梅梅尔的迷因，w .卡特的图像，奥本艾·GPT-3(左)和艾勒瑟雷·GPT-尼欧(右)的字幕，许可:CC BY-SA 4.0

你可以使用谷歌实验室创建自己的迷因。

由 AI-Memer 制作的 Meme，由 Yannick Vernet 制作的图片，由 OpenAI GPT-3 制作的说明，许可:CC BY-SA 4.0

讨论

通过这个项目，我了解到大规模语言生成模型可以为给定图像描述的迷因创建良好的标题。尽管许多生成的标题很简单，但偶尔也会非常巧妙和有趣。特别是 GPT-3 达芬奇模型，似乎经常创造出聪明的模因，显示出对语言的掌握和对文化历史的深刻理解。

由 AI-Memer 制作的 Meme，由 Russ Neumeier 制作的图片，由 OpenAI GPT-3 制作的说明，许可:CC BY-SA 4.0

后续步骤

虽然成绩还算不错，但肯定还有提升的空间。例如，背景图片的选择似乎有些有限，尤其是流行文化。这可能是因为我将搜索限制为仅使用免费许可的照片。我不知道美国法院是否已经权衡了迷因中的背景图片是否可以被视为合理使用，所以我将把这个问题留给律师。

EleutherAI 的 GPT-尼奥背后的开发人员正在继续建立和训练更大的语言模型。他们的下一个模型叫做 GPT-尼欧克斯。他们说他们的“主要目标是训练一个等同于全尺寸 GPT⁠-⁠3 的模型，并在开放许可下提供给公众。”[17]

不要忘记在下面的附录中查看更多生成的模因。

迷因由 AI-Memer 提供，图片由 N/A 提供，标题由 OpenAI GPT-3 提供，许可:CC BY-SA 4.0

源代码

这个项目的所有源代码都可以在 GitHub 上获得。你可以使用这个 Google Colab 来试验代码。我在 CC BY-SA 许可下发布了源代码。

归属共享相似

如果你用 AI-Memer 创建了任何 meme 并发布到网上，请提及该项目并添加这篇文章的链接。

由 AI-Memer 制作的 Meme，由 Sean Finn 制作的图片，由 OpenAI GPT-3 制作的说明，许可:CC BY-SA 4.0

感谢

我要感谢詹尼弗·林和奥利弗·斯特里普尔对这个项目的帮助。

参考

维基共享资源(2004 年至今)

[2] 打开图像 (2020)

[3] A .拉德福德，J. W .金，c .哈拉西，a .拉梅什，g .高，s .阿加瓦尔，g .萨斯特里，a .阿斯克尔，p .米什金，j .克拉克等人，从自然语言监督中学习可转移视觉模型 (2021)

[4] T. B. Brown，B. Mann，N. Ryder，M. Subbiah，J. Kaplan，P. Dhariwal，A.Neelakantan，等人语言模型是很少出手的学习者 (2020)

[5]伊莱瑟雷，GPT-尼奥 (2020)

维基百科(2004 年至今)

[7] R .道金斯，自私的基因 (2016)，牛津大学出版社

[8] L. K .博尔泽伊，《让一个迷因代替》(2013)，《琳达·博尔泽伊作品选》

[9] D. Wenzlau，用 Keras & Tensorflow (2019)中的深度卷积网络生成迷因文本，走向数据科学

[10]戈德史密斯，维基百科 API (2014)

[11] M. Manske，维基共享 API (2020 年)

[12] J. Pont-Tuset，J. Uijlings，S. Changpinyo，R. Soricut 和 V. Ferrari，将视觉和语言与本地化叙事联系起来 (2020) ECCV(聚光灯)

[13] OpenImages 下载 API (2018)

[14] 拥抱脸变形金刚 (2019)

[15] P .麦克尼尔，类型的视觉史(2017)，劳伦斯·金，第 372–373 页

[16] E. Pire，用 Python 为迷因加标题 (2017)

[17]刺五加，GPT-尼奥克斯 (2021)

附录

这里还有一些由 AI-Memer 生成的迷因。

由 AI-Memer 制作的 Meme，由 Chasselat 制作的图片，由 OpenAI GPT-3 制作的标题，许可:CC BY-SA 4.0

图片由艾·梅梅尔提供，图片由伊丽塔·克斯布卢马提供，文字说明由伊莱瑟雷 Irita 尼欧提供，许可:CC BY-SA 4.0

由 AI-Memer 制作的 Meme，由 JJ·哈里逊制作的图片，由 OpenAI GPT-3 制作的说明，许可:CC BY-SA 4.0

由 AI-Memer 创建的 Meme，由 NASA 创建的图片，由 OpenAI GPT-3 提供的说明，许可:CC BY-SA 4.0

由 AI-Memer 制作的 Meme，由 Peder sever in kryer 制作的图片，由 OpenAI GPT-3 制作的说明，许可:CC BY-SA 4.0

Meme 由 AI-Memer 提供，图片由 Atelier Nadar 提供，说明由 OpenAI GPT-3 提供，许可:CC BY-SA 4.0

为了无限制地访问 Medium 上的所有文章，成为会员，每月支付 5 美元。非会员每月只能看三个锁定的故事。

AI/ML 模型验证框架

原文：https://towardsdatascience.com/ai-ml-model-validation-framework-13dd3f10e824?source=collection_archive---------23-----------------------

这不仅仅是一个简单的 MRM 问题

来源:凯文·Ku 在 Unsplash 上拍摄的照片

模型风险管理(MRM)是任何金融机构评估模型风险的标准做法。然而，在分析领域，从早期的主流模型/方法到尖端的人工智能/机器学习(AI/ML)技术，存在着范式转变。随着分析领域的进步，MRM 政策/框架也需要升级，以确保 AI/ML 方法产生的任何增量风险都能够被很好地捕捉、突出和减轻。

本文讨论了一个用于验证 AI/ML 模型的健壮框架。在我们深入研究该框架之前，有必要讨论两个关键方面:

A)****AI/ML 解决方案风险分层:

为了使人工智能/洗钱值得信赖，相关产品/解决方案的风险分级至关重要。这尤其有助于量化解决方案的任何潜在危害。最近，欧盟委员会也提出了一套关于风险分层的指导方针。根据业内既定标准，人工智能/人工智能解决方案的相关风险分类如下:

图片来自作者

B) 偏向&公平

在深度学习中，偏差&公平性从数据分析和建模方法的角度来看都是重要的考虑因素。这两者都可能带来可怕的后果。从数据的角度来看，由于经验偏度，偏度可能存在。例如，如果我们在谷歌中搜索“护士”,它会更突出某一特定性别。同样，某些种族/肤色的信用评分也可能有偏差。从建模的角度来看，深度学习模型总是倾向于过度拟合数据，从而产生偏见。

不幸的是，让验证者沮丧的是，偏见和公平没有标准的定义。当从模型中得出的决策可能影响个人或公司时，偏见和公平就成了问题。为了解决这些问题:

a)验证者应该谨慎地评估变量，并指出是否存在任何与变量相关的问题。敏感变量(如年龄、性别、宗教、职业等。)应该从数据或建模中排除，如果不是非常必要的话。

b)验证人员应根据上述风险等级适当审查偏差和公平性。高风险模型可能有很高的偏见和公平性问题。

c)验证者需要定义一些标准的技术或实践来识别和解决这个问题。例如， datarobot 提供了自动识别偏差的选项。

给定上下文，让我们深入研究 AI/ML 模型验证框架。该框架可分为以下几个方面:

图片来自作者

1) 数据适当性

AI/ML 模型的训练通常需要海量的数据，这些数据也可能是非结构化的。这将保证确保:

a.保护 PII 或任何个人数据。此外，还应考虑数据的收集和处理过程。

b.测试数据的完整性和适当性，以便将其用于正确的目的和正确的方式。

c.预处理，如果有的话(如变换、归一化、缺失值计算等。)应用于训练和测试数据。

d.通过审查时间段、来源、分布来评估数据的完整性,并在需要时访问标签的定义

e.不存在上面提到的偏见&公平问题

2) 方法论和模型测试

与传统模型不同，AI/ML 模型通常是黑盒。因此，测试模型参数、输出和对输入的敏感性变得具有挑战性。为了确保模型提供预期的结果并在一段时间内保持稳定，验证者需要:

a.理解方法的目标以及业务需求

b.查看超参数以调整模型:

一、矢量化技术 (Word2Vec，Glove，FastText，One-hot-encoding) ，

二。优化功能(梯度下降、SGD、MiniBatch、Adam)

三。激活功能 (Sigmoid，Tanh，ReLU)

四。损失函数 (MSE，交叉熵损失，铰链损失)

动词 （verb 的缩写）层数

不及物动词批量

七。退学率

八。汇集方法(最大值，平均值)

c.确保超参数与模型的目的和用途一致。

d.评估性能指标如误报、精度、召回是否根据业务需求正确定义。

e.通过计算量更大的方法评估模型准确性和稳定性，如使用不同的数据子集重新执行模型、k 重交叉验证、留一交叉验证(LOOCV)、嵌套交叉验证。

f.确保敏感度分析已经彻底执行，通过该分析可以测量每个特性的影响。还有更高级的全局可解释性方法，如部分相关图(PDP)，它允许通过可视化预测响应与一个或多个特征之间的平均部分关系来找出趋势。

g.一旦敏感性被捕获，评估场景的可能性及其影响。为了确保模型能够容忍任何极端场景或噪音，需要进行场景分析。

h.评估标杆或挑战者模型，并与最终模型进行比较。

I .确保自适应或持续学习的计划到位(如有)，以便模型能够从新数据中学习。

j.评估任何预培训模型的使用(如 Glove、FastText、ResNet 等。)根据手头的数据和问题谨慎处理。

3) 概念的合理性和可解释性

与传统技术相比，AI/ML 技术仍然没有被监管者或从业者广泛接受。这主要是由于它的黑盒性质，这使得它很难建立关于手边的建模或业务上下文的可解释性和适用性。

为了度量黑盒模型的透明性、可解释性和特征重要性，https://github.com/slundberg/shapLIME或可解释的 Boosting Machines(EBM)被高度使用，它们是模型不可知的，并且也为模型提供了交互项。验证者需要确保这种类型的分析已经被执行，并且分析的结论与业务问题一致。

4)模型实现和模型安全

一旦模型被开发出来，一个关键的重要步骤就是在生产环境中实现模型，无论是在服务器上还是在云上，比如 Azure 或 GCP。在这一步中，验证者需要仔细评估模型实现计划的准备和设计。验证者还需要评估应用程序(包括库、模块和配置)是否适合实现，同时考虑未来版本的潜在影响。在这种情况下， Docker/Kubernetes 通过使用容器使得创建、部署和运行应用程序变得更加容易。

除了实现之外，还有关于模型安全的观点，如对抗性攻击、模型盗窃等。很可能是在这个验证框架中设计的。就此而言，在定义解决方案的透明度时，风险分层(前面提到过)应该是一个重要的考虑因素。

5) 模型文档和版本控制

文档应该是自解释的和足够广泛的，以便它允许验证器复制模型。

文件应描述开发数据提取和预处理、模型理论和设计、开发方法和模型性能，包括 challenger 模型，以及适当的模型文件指南。它应适当提及假设、弱点和限制，提供对其影响的估计，并记录相关模型风险的缓解措施。最后，代码应该有足够的注释，并有关于功能的简要说明，还应该保持版本控制。

6) 持续监控和治理

验证人员应该评估监控计划，以确保范围、目标、涉众、角色和职责等组成部分都被很好地涵盖。此外，还应评估定期回访或重新校准的频率和时间间隔。管理机构的有效监督将确保管理层了解所有相关的模型风险。

结论

随着各行业在采用新的人工智能/人工智能制度方面不断改进，MRM 框架需要变得比以前更加强大和全面。验证者需要评估文章中强调的所有关键维度的模型。

免责声明:本文中表达的观点是作者以个人身份发表的意见，而非其雇主的意见

参考文献:

https://EC . Europa . eu/commission/press corner/detail/en/IP _ 21 _ 1682

https://www . data robot . com/blog/introducing-data robot-bias-and-failure-testing/

https://christophm . github . io/interpretable-ml-book/lime . html

https://github.com/slundberg/shap

https://towards data science . com/understanding-bias-and-failure-in-ai-systems-6f 7 fbfe 267 f 3

AI 物体检测，用狮子！

原文：https://towardsdatascience.com/ai-object-detection-with-lions-d301c6ab3564?source=collection_archive---------30-----------------------

使用基于区域的卷积神经网络(R-CNN)

作者图片

这篇文章原本是为了介绍 AWS 重新识别。我想我会尝试一下，并提供一个评论。我是 AWS 服务的粉丝。它们通常都设计得很好，很直观，并且工作起来很愉快。我真的对 AWS 认证很失望，至少我感兴趣的部分是“自定义标签”。名字本身可能没有这么明显这是什么。这可以让你给自己的模型贴上标签，进行训练(在我看来是最有用的部分)。AWS 确实为“对象和场景检测”、“图像调节”、“面部分析”、“名人识别”、“人脸比对”、“图像中的文字”和“ ppe 检测”提供了图像和视频模型。你可以在这里找到关于定价的信息。

我曾计划用那些旧的儿童书籍来演示这一点。也许你们中的一些人会记得小时候的书。在每一页上，它都有一个非常忙碌和混乱的场景，你必须在人群中找到这个叫“T26 瓦尔多的家伙。他戴着红帽子，戴着眼镜，穿着条纹衬衫。我认为这将是一个伟大的使用对象检测的人工智能演示。遗憾的是，我无法向你们展示这些惊人的结果，因为我无法获得许可。这是我对 AWS 认知的计划。相反，我用了一些我在南非约翰内斯堡的狮子和野生动物园拍摄的照片。

只要记住 AWS 识别不是便宜。你按图片付费，有时按时间付费来训练和使用你的模型。这可能会使解决方案非常昂贵。我还没有看过谷歌云愿景，但我预计它在定价方面会类似。

以下是我决定不在 AWS 重新识别中使用自定义标签的主要原因。

  • 当您创建一个“数据集时，它会自动为您创建一个具有正确权限的 S3 存储桶。如果您可以选择自己的 bucket 名称，这将是一个不错的特性。举个例子，如果我现在进入它，它想要创建一个名为“custom-labels-console-eu-west-2–06e 54d 6838”的 S3 存储桶。如果你有一个以上的项目，这将是一个痛苦的管理。
  • 在您的"数据集"文件夹中，您至少要创建一个"训练"文件夹或类似的文件夹。您也可以选择创建一个“测试”文件夹。在“项目”设置中，您可以决定是否要将您的图像分割成“系列”和“测试”，或者您可以告诉它将您的“系列”自动分割成 80/20。我这里的问题是你不能在控制台中删除你的“数据集”。没有删除按钮！您需要完全移除 S3 存储桶，一段时间后它会被检测到并移除。
  • 您可以直接在控制台中标记您的图像。这可能是一个伟大的功能，但它是非常基本的。例如，如果您在标签的图像上放置一个边界框，您只能移动或删除它。你无法重塑它。你应该能够抓住边界框的锚点，并对其进行优化。
  • 在训练阶段，如果失败了，它不会给你一个很好的解释。您几乎肯定需要在线搜索问题所在。我遇到的一个问题是我没有添加足够的测试图像。你可能会认为只要将更多的图片复制到“ test ”文件夹中，贴上标签，你就可以…出错了！您添加的新图像永远不会被检测到。你相信你必须手动编辑新图像的清单文件吗？
  • 在我训练好我的模型后，我期待着尝试一下。不能通过控制台使用。您需要通过 AWS CLI 启动模型、使用模型和停止模型。
  • 启动和停止模型花费了很长时间。我的意思是很长一段时间，有时它没有开始，也没有解释问题是什么。请记住，在模型运行时，您是按分钟付费的。
  • 一旦你花了很多钱来训练你的模型，你就不清楚这个模型是否能被导出并在 AWS 之外使用。我感觉你可能会使用 AWS 进行推理。我找不到这方面的任何文件。

在这个阶段，我认为这不适合我。至少在他们修好这一切之前不会。它有真正的潜力，但作为一个"未完成的服务"我不会使用它。我认为他们也可以为自定义标签提供一些自由层功能。

当我完成我的应用机器学习课程时，我想在人工智能方面推进我的研究。我的大部分深造都是从媒体文章中获得的。有些文章非常好，内容丰富，有些则不然。我注意到，尤其是在学习 LSTM 交易时，许多文章都有糟糕的代码。似乎人们只是在复制同样的代码，而没有试图去理解它。

几个月前，我发现了一篇关于物体检测的很棒的文章…

https://medium.com/swlh/tensorflow-2-object-detection-api-with-google-colab-b2af171e81cc

演练大部分工作，但有相当大的差距。我遇到了几个问题，试图让这个工作。我试图联系作者，但没有得到任何答案。我自己解决了问题并改进了代码，现在它运行得非常好。

为此，我将使用谷歌实验室，它是免费的。我实际上把我的升级到了谷歌 Colab Pro ，每月 8.10 英镑。它非常值得升级，但不是必需的。如果您使用免费版本，您需要调低“ pipeline.config ”中的“ batch_size ”超参数。

让我们准备我们的数据

为了证明这一点，我们需要一些“商业使用& mods 允许的”图像用于训练和测试。正如我上面提到的，我已经获得了使用一些“Waldo在哪里”图片的许可。我确实在 Flickr 上看了看，但就是找不到一组好的图片。我最终只是用了一些我自己拍的照片，以避免任何潜在的版权问题。

一旦我们准备好了我们的图像，我们将需要使用这个非常神奇的免费开源工具，叫做“https://github.com/tzutalin/labelImg”。如何安装的说明可以在这里找到。为了训练我们的模型，我们首先需要教它“狮子在哪里。" labelImg "非常容易地帮你给"狮子"加标签，并在它周围加一个边框。保存文件时，它将包含一个 XML 文件，其中包含图像的所有标签信息。图像可以包含一个或多个标签、多个标签，甚至是重叠的标签。在这种情况下，我们只有一个名为“ lion ”的标签。

作者图片

如你所见，我已经完成了所有的训练和测试图像，标记了一个或多个“ lion ”。

在这个阶段，我们应该有一个本地目录，其中包含我们所有的图像和附带的 XML 文件。

我有 124 张图片用于训练和测试。我将 88 张图片和 XML 文件放入一个“ train 文件夹，将 36 张图片放入一个“ test 文件夹。我们以后会需要这些。

Google Colab

我为此准备了一个笔记本，但把它分成了两部分:

  • 训练和测试模型
  • 加载并使用模型

理想情况下，你只需要训练你的模型一次，因为这需要很长时间。使用 Google Colab Pro 需要 7 个小时，如果您使用 Google Colab 可能需要更长时间，但至少是免费的。一旦你训练并导出了你的模型，那么加载和使用它就很快了。

给自己创建一个新的 Google Colab 笔记本。

点击运行时，然后改变运行时类型。在硬件加速器下选择 GPU 。

该部分的另一个重要菜单选项是“运行时”下的“管理会话”。如果你遇到崩溃或谷歌驱动会话挂起，你可能会得到一个“僵尸会话”，这只是不允许你做任何事情。如果你有这样的问题，硬重置笔记本的最好方法是进入“管理会话”，终止有问题的会话并重新开始。

训练和测试模型

您笔记本中的第一个代码单元将是安装“ wget ”。

!pip install wget

作者图片

然后，您将希望包括以下库。

import os
import sys
from shutil import copy, move
from wget import download
from re import compile as re_compile, sub as re_sub, M
from google.colab import drive
from tarfile import open as untar

在我的笔记本里，我把我创建的所有这些函数放在一个代码单元里，但是我要把它们分开来解释它们是做什么的。

此功能将安装 Google Drive 来处理您的模型。

def mount_gdrive():
  if not os.path.isdir('/content/gdrive'):
    drive.mount('/content/gdrive')

该函数在 Google Drive 上创建所需的目录结构。在最初的文章中，他只是向我们展示了目录结构应该是什么样子。这实际上为你做了一切:)

您会注意到我使用了几个环境变量:

  • GDRIVE_ROOT

这是您的 TensorFlow 项目在 Google Drive 中的根目录名称。稍后你会看到，但我称我的为“张量流”。

  • 项目名称

这是您的 TensorFlow 对象检测项目的名称。我把我的叫做“狮子”。

  • 张量流 _ 模型

这是我们将使用的张量流模型。我们将使用“固态硬盘 resnet 50 V1 FPN 640 x640(retina net 50)”但如果你想看这里的，你可以看看其他的。

  • 我的 _ 车型

这是一个基于我们将使用的张量流模型的模型名称。它是为您生成的，因此您不需要在这里指定任何内容。

除了创建所有目录之外，它还下载模型并创建标签映射。

def create_gdrive_directory_structure():
  global labelsroot_dir = os.environ['GDRIVE_ROOT']
  project_name = os.environ['PROJECT_NAME']
  tensorflow_model = os.environ['TENSORFLOW_MODEL']
  my_model = os.environ['MY_MODEL']if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}')
    os.makedirs(f'/content/gdrive/MyDrive/{root_dir}')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/scripts'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/scripts')
    os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/scripts')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/scripts/preprocessing'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/scripts/preprocessing')
    os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/scripts/preprocessing')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace')
    os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}')
     os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/annotations'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/annotations')
      os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/annotations')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/exported-models'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/exported-models')
      os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/exported-models')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/images'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/images')
      os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/images')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/images/test'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/images/test')
      os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/images/test')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/images/train'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/images/train')
       os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/images/train')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models')
      os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models/{my_model}'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models/{my_model}')
      os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models/{my_model}')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models/my_ssd_resnet50_v1_fpn'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models/my_ssd_resnet50_v1_fpn')
      os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models/my_ssd_resnet50_v1_fpn')if not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/pre-trained-models'):
    print (f'creating /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/pre-trained-models')
      os.makedirs(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/pre-trained-models')if not os.path.isfile(f'{tensorflow_model}.tar.gz') and not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/pre-trained-models/{tensorflow_model}'):
    print (f'downloading {tensorflow_model}.tar.gz from [https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/tf2_detection_zoo.md'](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/tf2_detection_zoo.md'))
    download(f'[http://download.tensorflow.org/models/object_detection/tf2/20200711/{tensorflow_model}.tar.gz'](http://download.tensorflow.org/models/object_detection/tf2/20200711/{tensorflow_model}.tar.gz'))if os.path.isfile(f'/content/{tensorflow_model}.tar.gz') and not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/pre-trained-models/{tensorflow_model}'):
    print (f'untar /content/{tensorflow_model}.tar.gz')
    tar = untar(f'/content/{tensorflow_model}.tar.gz', "r:gz")
    tar.extractall()
    tar.close()if os.path.exists(tensorflow_model) and not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/pre-trained-models/{tensorflow_model}'):
    print (f'moving model {tensorflow_model} to /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/pre-trained-models')
    move(tensorflow_model, f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/pre-trained-models/{tensorflow_model}')if os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/pre-trained-models/{tensorflow_model}/pipeline.config') \
      and not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models/{my_model}/pipeline.config'):
      copy(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/pre-trained-models/{tensorflow_model}/pipeline.config', f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models/{my_model}/pipeline.config')if not os.path.exists(f'/content/models') and not os.path.exists(f'/content/gdrive/MyDrive/{root_dir}/models'):
    !git clone [https://github.com/tensorflow/models.git](https://github.com/tensorflow/models.git)
    print (f'moving /content/models to /content/gdrive/MyDrive/{root_dir}')
    move('/content/models', f'/content/gdrive/MyDrive/{root_dir}')if not os.path.isfile(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/annotations/label_map.pbtxt'):
    print (f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/annotations/label_map.pbtxt')label_map = ''
    for label in labels:
      label_map += "item {\n"
      label_map += f"  id: {label[0]}\n"
      label_map += f"  name: '{label[1]}'\n"
      label_map += "}\n"try:
    with open(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/annotations/label_map.pbtxt', 'w') as fh:
        fh.write(label_map)
        fh.close
    except IOError as err:
      print (err)

该功能用于训练和加载模型。它建立必要的对象检测库。

def build():
  root_dir = os.environ['GDRIVE_ROOT']
  project_name = os.environ['PROJECT_NAME']
  tensorflow_model = os.environ['TENSORFLOW_MODEL']os.chdir(f'/content/gdrive/MyDrive/{root_dir}/models/research')
  !git checkout -f e04dafd04d69053d3733bb91d47d0d95bc2c8199!apt-get install protobuf-compiler python-lxml python-pil
  !pip install Cython pandas tf-slim lvisos.chdir(f'/content/gdrive/MyDrive/{root_dir}/models/research')
  !protoc object_detection/protos/*.proto --python_out=.!python setup.py build
  !python setup.py installos.chdir(f'/content/gdrive/MyDrive/{root_dir}/models/research/object_detection/builders')
  !python model_builder_tf2_test.py
  print('Done')

这个函数创建 TFRecords。

def generate_tfrecords():
  root_dir = os.environ['GDRIVE_ROOT']
  project_name = os.environ['PROJECT_NAME']
  tensorflow_model = os.environ['TENSORFLOW_MODEL']os.chdir(f'/content/gdrive/MyDrive/{root_dir}/scripts/preprocessing')if not os.path.isfile('generate_tfrecord.py'):
    !wget [https://gist.githubusercontent.com/whittlem/3dac1a51389678507d6e1a5090287f26/raw/666c93b2b36351942e806f4cedd4cf713d04d691/generate_tfrecord.py](https://gist.githubusercontent.com/whittlem/3dac1a51389678507d6e1a5090287f26/raw/666c93b2b36351942e806f4cedd4cf713d04d691/generate_tfrecord.py)

  !python generate_tfrecord.py -x "/content/gdrive/MyDrive/$GDRIVE_ROOT/workspace/$PROJECT_NAME/images/train" -l "/content/gdrive/MyDrive/$GDRIVE_ROOT/workspace/$PROJECT_NAME/annotations/label_map.pbtxt" -o "/content/gdrive/MyDrive/$GDRIVE_ROOT/workspace/$PROJECT_NAME/annotations/train.record"
  !python generate_tfrecord.py -x "/content/gdrive/MyDrive/$GDRIVE_ROOT/workspace/$PROJECT_NAME/images/test" -l "/content/gdrive/MyDrive/$GDRIVE_ROOT/workspace/$PROJECT_NAME/annotations/label_map.pbtxt" -o "/content/gdrive/MyDrive/$GDRIVE_ROOT/workspace/$PROJECT_NAME/annotations/test.record"

这个函数将一些重要的脚本移动到正确的位置。

def move_scripts():
  root_dir = os.environ['GDRIVE_ROOT']
  project_name = os.environ['PROJECT_NAME']
  tensorflow_model = os.environ['TENSORFLOW_MODEL']if os.path.isfile(f'/content/gdrive/MyDrive/{root_dir}/models/research/object_detection/model_main_tf2.py') \
    and not os.path.isfile(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/model_main_tf2.py'):
    print (f'copying /content/gdrive/MyDrive/{root_dir}/models/research/object_detection/model_main_tf2.py to /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}')
    copy(f'/content/gdrive/MyDrive/{root_dir}/models/research/object_detection/model_main_tf2.py', f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}')if os.path.isfile(f'/content/gdrive/MyDrive/{root_dir}/models/research/object_detection/exporter_main_v2.py') \
    and not os.path.isfile(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/exporter_main_v2.py'):
    print (f'copying /content/gdrive/MyDrive/{root_dir}/models/research/object_detection/exporter_main_v2.py to /content/gdrive/MyDrive/{root_dir}/workspace/{project_name}')
    copy(f'/content/gdrive/MyDrive/{root_dir}/models/research/object_detection/exporter_main_v2.py', f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}')

此功能可选择启动张量板进行训练后分析。

def start_tensorboard():
  root_dir = os.environ['GDRIVE_ROOT']
  project_name = os.environ['PROJECT_NAME']os.chdir(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}')
  %load_ext tensorboard
  %tensorboard --logdir=models/$MY_MODEL

此函数根据原始文章对“ pipeline.config ”文件进行建议的更改。

重要提示: 原文章将批量改为 16。我对此有很多问题。由于内存问题，免费的 Google Colab 不断崩溃。我不得不把这种方式减少到 4 左右，如果不是更少的话。使用 Google Colab Pro，我可以在 12 点运行它。如果你使用的是免费版本，那么尝试 4，如果你有问题，那么尝试 2。

def update_pipeline_config():
  root_dir = os.environ['GDRIVE_ROOT']
  project_name = os.environ['PROJECT_NAME']with open(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models/my_ssd_resnet50_v1_fpn/pipeline.config', 'r') as fh:
    content = fh.read()
    content_new = re_sub('num_classes: \d*', r'num_classes: ' + str(len(labels)), content, flags=M)
    content_new = re_sub('batch_size: \d*', r'**batch_size: 12**', content_new, flags=M)
    content_new = re_sub('fine_tune_checkpoint: .*', r'fine_tune_checkpoint: "pre-trained-models/' + os.environ['TENSORFLOW_MODEL'] + '/checkpoint/ckpt-0"', content_new, flags=M)
    content_new = re_sub('num_steps: \d*', r'num_steps: 25000', content_new, flags=M)
    content_new = re_sub('fine_tune_checkpoint_type: .*', r'fine_tune_checkpoint_type: "detection"', content_new, flags=M)
    content_new = re_sub('use_bfloat16: .*', r'use_bfloat16: false', content_new, flags=M)
    content_new = re_sub('label_map_path: .*', r'label_map_path: "annotations/label_map.pbtxt"', content_new, flags=M)
    content_new = re_sub('input_path: ".*"', r'input_path: "annotations/test.record"', content_new, flags=M)
    content_new = re_sub('input_path: ".*"', r'input_path: "annotations/train.record"', content_new, count=1, flags=M)
    fh.close()with open(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}/models/my_ssd_resnet50_v1_fpn/pipeline.config', 'w') as fh:
      fh.write(content_new)
      fh.close()

这是训练模型的函数。

def train_model():
  root_dir = os.environ['GDRIVE_ROOT']
  project_name = os.environ['PROJECT_NAME']TF_CPP_MIN_LOG_LEVEL=2
  os.chdir(f'/content/gdrive/MyDrive/{root_dir}/workspace/{project_name}')
  !python model_main_tf2.py --model_dir=models/$MY_MODEL --pipeline_config_path=models/$MY_MODEL/pipeline.config

这将在完成后导出模型。

def export_model():
  !python exporter_main_v2.py --input_type image_tensor --pipeline_config_path ./models/$MY_MODEL/pipeline.config --trained_checkpoint_dir ./models/$MY_MODEL/ --output_directory ./exported-models/my_model

我将上述所有函数放在一个代码单元中，但为了便于解释，只是将它们分开。在培养基中，编码细胞很小。我用代码创建了一个 GitHub Gist ,这将更容易审查。

下一个代码单元格应该是这样的。这是一个重要的单元格，因为它定义了我们使用的所有环境变量和标签。如果您有其他标签，可以将它们包含在列表中。我已经用粗体字标出了你想修改的项目。

os.environ['GDRIVE_ROOT'] = '**TensorFlow**'
os.environ['PROJECT_NAME'] = '**lions**'
os.environ['TENSORFLOW_MODEL'] = '**ssd_resnet50_v1_fpn_640x640_coco17_tpu-8**'
os.environ['MY_MODEL'] = 'my_' + os.environ['TENSORFLOW_MODEL']
os.environ['MY_MODEL'] = re_sub('fpn.*$', 'fpn', os.environ['MY_MODEL'])
os.environ['PYTHONPATH'] += f":/content/gdrive/MyDrive/{os.environ['GDRIVE_ROOT']}/models"sys.path.append(f"/content/gdrive/MyDrive/{os.environ['GDRIVE_ROOT']}/models/research")labels = [
  **(1, 'lion')**
]

下一个代码单元将从 Google Colab 挂载您的 Google Drive。它会要求您授权从 Google Colab 到 Google Drive 的连接。您需要从链接 Google Colab 复制令牌。

mount_gdrive()

这将初始化您的项目结构。你会看到它正在做的输出。如果它以前已经运行过，那么你不会看到任何输出。

create_gdrive_directory_structure()

无论您是在训练还是加载模型，都需要运行下一个函数。它构建对象检测库。这可能需要一段时间。

build()

如果一切顺利，您应该会在构建测试结束时看到这一点。

OK (skipped=1)
Done

我们现在可以包含两个刚刚构建的库。

from object_detection.utils import label_map_util
from object_detection.utils import visualization_utils as viz_utils

然后我们需要生成我们的 TFRecords。在运行之前，确保您已经将本地映像和相关的 XML 文件复制到项目的“训练和“测试目录中。你可以在 Google Drive 的“ images ”目录中找到这个。

generate_tfrecords()

作者图片

这个函数只是将我们需要的脚本移动到正确的位置。

move_scripts()

这是一个可选步骤，但如果你想你可以开始 TensorBoard。请注意，您只会在训练结束后看到一些内容。

作者图片

"当前数据集没有活动的仪表板。”是你第一次运行时所期望的。至少到目前为止是这样。在你训练好你的模型后，你会在这里看到一些有趣的分析。

该函数对原文章中描述的“ pipeline.config ”进行所有必要的修改。正如我上面提到的，如果你使用 Google Colab 的免费版本，那么就需要减少 batch_size 。

update_pipeline_config()

现在我们一直在等待的部分…

train_model()

这将需要很长时间。我第一次训练模型花了 7 个小时才完成，而且只用了我现在训练的一半图像。

当你看到类似这样的训练日志时，你就会知道它在工作。

作者图片

这是它完成 25000 步的最后一步！

一旦您的模型已经训练好，您会想要导出它，以便以后可以加载它。

export_model()

如果一切按计划进行，你应该在最后看到这个。

作者图片

加载和使用模型

在这个阶段，我们应该已经将训练好的模型导出并准备就绪。

有些代码单元/步骤是从本文的培训部分复制来的。我故意把它们分开，因为在大多数情况下，你只是想使用你的模型。

像往常一样，第一步是导入我们的库。

import os
import sys
import numpy as np
import matplotlib.pyplot as plt
import warningsfrom google.colab import drive
from re import sub as re_sub
from tensorflow import saved_model, convert_to_tensor, newaxis
from PIL import Imagewarnings.filterwarnings('ignore')

然后我们定义我们的环境变量。我用粗体突出显示了三个可能被编辑的参数。根据本演示，您可以将它们留在下面。

os.environ['GDRIVE_ROOT'] = '**TensorFlow**'
os.environ['PROJECT_NAME'] = '**lions**'
os.environ['TENSORFLOW_MODEL'] = '**ssd_resnet50_v1_fpn_640x640_coco17_tpu-8**'
os.environ['MY_MODEL'] = 'my_' + os.environ['TENSORFLOW_MODEL']
os.environ['MY_MODEL'] = re_sub('fpn.*$', 'fpn', os.environ['MY_MODEL'])
os.environ['PYTHONPATH'] += f":/content/gdrive/MyDrive/{os.environ['GDRIVE_ROOT']}/models"sys.path.append(f"/content/gdrive/MyDrive/{os.environ['GDRIVE_ROOT']}/models/research")

我有一个代码单元，其中包含了我创建的所有函数。我将把它们分开来解释，但你可能想把它们都放在一个单元格中。

我们将再次需要此功能来安装您的 Google Drive。

def mount_gdrive():
  if not os.path.isdir('/content/gdrive'):
    drive.mount('/content/gdrive')

构建函数也与我们在本文的培训部分使用的函数完全相同。

def build():
  root_dir = os.environ['GDRIVE_ROOT']
  project_name = os.environ['PROJECT_NAME']
  tensorflow_model = os.environ['TENSORFLOW_MODEL']os.chdir(f'/content/gdrive/MyDrive/{root_dir}/models/research')
  !git checkout -f e04dafd04d69053d3733bb91d47d0d95bc2c8199!apt-get install protobuf-compiler python-lxml python-pil
  !pip install Cython pandas tf-slim lvisos.chdir(f'/content/gdrive/MyDrive/{root_dir}/models/research')
  !protoc object_detection/protos/*.proto --python_out=.!python setup.py build
  !python setup.py installos.chdir(f'/content/gdrive/MyDrive/{root_dir}/models/research/object_detection/builders')
  !python model_builder_tf2_test.py
  print('Done')

这个函数将加载我们的模型。它将返回一个带有检测函数“ detect_fn ”和类别索引“ category_index ”的元组。这些将是“过程 _ 图像”功能的输入。

def load_model(model: str='', label_map: str=''):
  if model == '' and os.getenv('GDRIVE_ROOT') and os.getenv('PROJECT_NAME'):
    model = '/content/gdrive/MyDrive/' + os.getenv('GDRIVE_ROOT') + '/workspace/' + os.getenv('PROJECT_NAME') + '/exported-models/my_model/saved_model'if label_map == '' and os.getenv('GDRIVE_ROOT') and os.getenv('PROJECT_NAME'):
    label_map = f'/content/gdrive/MyDrive/' + os.getenv('GDRIVE_ROOT') + '/workspace/' + os.getenv('PROJECT_NAME') + '/annotations/label_map.pbtxt'if model == '' or label_map == '':
    raise ValueError('model and label_map.pbtxt locations required!')if not os.path.exists(model):
    raise IOError(f'model not found: {model}')if not os.path.isfile(label_map):
    raise IOError(f'label_map.pbtxt not found: {label_map}')print('Loading model... ', end='')
  resp_tuple = (saved_model.load(model), label_map_util.create_category_index_from_labelmap(label_map, use_display_name=True))
  print ('done.')return resp_tuple

这个辅助函数将把一个图像转换成一个 Numpy 数组。

def image2ndarray(path):
  return np.array(Image.open(path))

该功能将显示我们处理过的图像。这个函数可能需要一些解释。前两个参数" detect_fn 和" category_index "是" load_module "函数的输出。 img_path 是输入图像的位置。在 Google Colab 中输出图像比例相当小。我已经添加了“ img_scale ”，它允许你像浮动一样增加尺寸。例如，您可以使用 1.5 将图像缩放 1.5 倍。"裁剪"是另一个可选参数，它将裁剪并显示检测到的边界框。

这里有几个要点要提一下。第一个是对于每个图像，许多检测可能以不同的精确度被发现。我们不希望看到任何得分低于 50%的检测。如果你看下面的函数，你会看到“最小分数阈值”。这是一个超参数，表示我们只对高分检测感兴趣。

还值得一提的是，检测都是在 0 和 1 之间标准化。例如，如果图像是 1024x768，标签从中间开始，您将看到 x=0.5 和 y = 0.5，而不是 x=512 和 y=384。为了找到绝对位置，我们需要找到图像的实际尺寸，然后乘以标准化值。

def process_image(detect_fn: None, category_index: None, img_path: str='', img_scale: float=1, crop: bool=False):
  if not os.path.isfile(img_path):
    raise IOError(f'input image not found: {img_path}') img_path_split = img_path.split('.')
    if img_path_split[1].lower() in ['png']:
      img = Image.open(img_path)
      img_path = f"{img_path_split[0]}.jpg"
      img = img.convert('RGB')
      img.save(img_path) print('Running inference for {}'.format(img_path), end='')
  img_np=image2ndarray(img_path) input_tensor = convert_to_tensor(img_np)
  input_tensor = input_tensor[newaxis, ...] detections=detect_fn(input_tensor) num_detections = int(detections.pop('num_detections'))
  detections={key:value[0, :num_detections].numpy() for key,value in detections.items()}
  detections['num_detections'] = num_detections detections['detection_classes'] = detections['detection_classes'].astype(np.int64) img_np_with_detections = img_np.copy() min_score_thresh = .5 viz_utils.visualize_boxes_and_labels_on_image_array(
    img_np_with_detections,
    detections['detection_boxes'],
    detections['detection_classes'],
    detections['detection_scores'],
    category_index,
    use_normalized_coordinates=True,
    max_boxes_to_draw=100,     
    min_score_thresh=min_score_thresh,      
    agnostic_mode=False)

  img_file=Image.open(img_path)
  img_width, img_height=img_file.size
  print('')
  print(f'Image size: {img_width}x{img_height}px') for i in range(min(detections['detection_boxes'].shape[0], detections['detection_boxes'].shape[0])):
    if detections['detection_scores'] is None or detections['detection_scores'][i] > min_score_thresh:
      ymin, xmin, ymax, xmax = detections['detection_boxes'][i]
      x1, x2, y1, y2 = (int(xmin * img_width), int(xmax * img_width), int(ymin * img_height), int(ymax * img_height)) # left, right, top, bottom class_name = category_index[detections['detection_classes'][i]]['name']
  print('detection:', detections['detection_boxes'][i], 'is a', class_name, 'translated to (' + str(x1) + ', ' + str(y1) + ', ' + str(x2) + ', ' + str(y2) + ') pixels') if crop:
      img_crop = img_file.crop((x1, y1, x2, y2)) # left, top, right, bottom
      display(img_crop) %matplotlib inline
  fig=plt.figure()
  img_size=fig.get_size_inches()
  print (f'Render scale: {img_scale}x')
  fig.set_size_inches(img_size[0]*img_scale, img_size[1]*img_scale) 
  plt.imshow(img_np_with_detections, aspect='auto')
  print('Done')
  plt.show()

这里的代码可能很难阅读，所以为了方便起见，我创建了一个 GitHub Gist 。

为了使用这些功能，我们的下一个单元将是安装我们的 Google Drive，构建我们的附加库，并包含我们构建的库(就像我们在培训步骤中所做的那样)

mount_gdrive()

然后构建我们的附加库。

build()

然后包括我们构建的库。

from object_detection.utils import label_map_util
from object_detection.utils import visualization_utils as viz_utils

然后，我们将加载我们的模块，该模块将返回一个我们接下来需要的元组。

**detect_fn**, **category_index** = load_model(
  model = '/content/gdrive/MyDrive/TensorFlow/workspace/**lions**/exported-models/my_model/saved_model',
  label_map = '/content/gdrive/MyDrive/TensorFlow/workspace/**lions**/annotations/label_map.pbtxt'
)

我们处理我们的图像…

process_image(
  detect_fn = detect_fn,
  category_index = category_index,
  img_path = f"/content/gdrive/My Drive/{os.environ['GDRIVE_ROOT']}/workspace/{os.environ['PROJECT_NAME']}/images/test/IMG_1938.JPG',
  img_scale = 4,
  crop = True
)

正如你所看到的，它找到了一只 100%自信的狮子，另一只 79%自信的在后面。

概括起来

我希望您发现原始文章的这一增强很有用。我试图弥补差距，解决大多数问题，并尽可能多地尝试自动化。我已经在几个不同的个人和专业项目中使用了这个过程，效果很好。您可能面临的两个潜在问题是 Google Drive 中的磁盘空间(它需要几个空闲 Gb)和 Google Colab 中的资源。Google Colab 中的资源问题是一个相当简单的修复方法，因为你可以调低“ batch_size ”，这应该可以帮你解决这个问题。你还需要一点耐心，因为训练一个模型可能需要几个小时:)

Python 是对缩进敏感的，我很欣赏在中型文章中展示代码并不总是按照预期的方式格式化。如果你想让我与你分享练习册，请在评论中告诉我。

如果你喜欢这篇文章，我建议你看看下面的文章:

**https://medium.com/geekculture/using-aws-sagemaker-to-solve-machine-learning-ai-problems-3c5896da2b2d https://levelup.gitconnected.com/predicting-titanic-survivors-using-ml-8570ef4e89e8 https://levelup.gitconnected.com/predicting-house-sale-prices-using-ml-30b829fd9556 https://levelup.gitconnected.com/categorising-using-machine-learning-5601baf9a05e [## Spotify 艺术家推荐

towardsdatascience.com](/spotify-artist-recommender-7950af1fe20a)

迈克尔·惠特尔

  • 如果你喜欢这个，请 跟我上媒
  • 有兴趣合作吗？让我们连线上LinkedIn**

用 Davis-Putnam 算法实现人工智能规划的可满足性

原文：https://towardsdatascience.com/ai-planning-as-satisfiability-with-davis-putnam-algorithm-53f05d2f2825?source=collection_archive---------18-----------------------

使用布尔(命题)可满足性问题解决人工智能规划问题——提高经典规划的表达能力和复杂性的另一种方法。

戴维斯-普特南 SAT 求解器(图片由作者提供)

介绍

这是提高传统规划方法的表现力和复杂性的另一种方法。

在这种技术中，我们所做的是将我们的经典规划问题表示转换成一种众所周知的表示，称为命题可满足性问题，也称为布尔可满足性问题，或简称为 SAT。

如果我们能把它转换成一个众所周知的问题表示，我们就能使用现有的算法来解决问题。

如果你不熟悉传统的规划方法，请阅读下面链接的我上一篇文章中的介绍部分。

在这篇文章中，我将通过一步一步的例子来解释这个概念。

命题可满足性问题

SAT 是一种知道命题公式是否可满足的方法。公式包括:

  • 变量
  • 运算符(AND/合取、OR/析取、NOT/否定)
  • 圆括号

命题公式(作者图片)

解决 SAT 问题意味着，给定一个命题公式，比如上面那个，检查它是否是可满足的。也就是说，存在逻辑值(真和假)的组合，可以使公式返回真或假。

如果是，则该公式是可满足的，否则，它是不可满足的。

在本例中，如果我们为公式分配以下逻辑值，则该公式是可满足的:

  • D =真
  • A =假
  • B =假

合取范式

为了解决 SAT 问题，我们需要它是一种叫做 CNF(合取范式)的结构化形式。在这种结构中，SAT 问题的公式由子句的连词组成，而子句的连词又是文字的析取。

这有点难读，但基本上，它由 or 的括号 ANDs 组成，如下所示。

CNF(作者图片)

然后我们可以使用布尔代数将命题公式转换成它们的 CNF。

规划领域与规划问题

对于我们的循序渐进的例子，我们将需要 PDDL 格式的经典规划领域和问题。

我们将使用简单的码头工人机器人规划领域进行测试，并使用它的简化形式，其中我们只有一个机器人和两个位置用于我们的分步示例。

为了提醒我们，下面是码头工人机器人领域的插图。

简单码头工人机器人规划领域(图片由作者提供)

课本

这篇文章基于《自动化规划:理论与实践》一书，例子也来自这本书。

源代码

像往常一样，我用 Python 写了这篇文章的源代码，并在 Github 上发布了它。你可以在底部找到链接。

将规划问题编码成 SAT 问题

回想一下，一个经典的规划问题如下:

经典规划问题(图片由作者提供)

其中规划域如下:

经典规划领域(图片由作者提供)

编码状态

我们首先需要知道的是命题变量，经典规划问题中的状态可以被认为是命题变量。例如码头工人问题的初始状态:

初始状态(图片由作者提供)

我们可以把这些初始状态看作三个不同的命题变量。

命题变量(作者图片)

编码状态转换

传统的规划方法通过从初始状态到达到目标状态的状态转换来工作。这意味着我们需要把状态转换模型化到我们的命题公式中，光有状态是不够的。

我们需要将变化的状态以及动作表示为命题变量，以完成我们的命题公式。

考虑以下简单的状态转换，其中机器人 r1 从位置 1 移动到位置 2:

简单的状态转换(图片由作者提供)

从上图可以清楚地看出，我们需要命题公式中的所有三个步骤来正确建模。这些状态在不同的时间成立，我们需要把时间或步长包括到我们的变量中，我们的公式可以写成如下:

命题公式(作者图片)

通过在每个变量上增加一个步骤，我们现在可以得到我们的命题公式。公式如下:

  • 在步骤 0 中，r1 位于位置 1
  • 在步骤 0，r1 不在 loc2
  • 在步骤 0，r1 从 loc1 移动到 loc2
  • 在步骤 1 中，r1 位于 loc2
  • 在步骤 1 中，r1 不在位置 1

编码规划问题

现在，在理解了如何将状态和状态转换编码成命题公式之后，我们就可以对我们的规划问题进行编码了。

为了创建我们的规划问题的命题公式，我们必须首先将我们的规划问题限制为寻找已知长度的规划的问题，也称为有界规划问题。

这意味着，我们指定步骤的数量(参见上面的编码状态转换)。这是这种方法的局限性。

然后在我们有了有界规划问题之后，我们把它编码成一个 SAT 问题。所以我们有两个步骤:

  • 从规划问题创建一个有界规划问题
  • 将有界规划问题编码成 SAT 问题

构建公式

构建公式有五个步骤。在我们的示例中，我们将使用下面的简单域:

简单域(作者代码)

简单的问题(作者编写的代码)

这个规划领域非常简单。我们只有 3 个对象:机器人、位置 1 和位置 2，并且只有一个动作将机器人从一个位置移动到另一个位置。让我们开始构建长度(步数)= 1 的公式。

初始状态

构建初始状态(图片由作者提供)

构建这个公式的一件重要事情是枚举所有可能的谓词。在我们的示例中，它们是:

所有谓词(作者图片)

初始状态的公式:

初始状态的公式(图片由作者提供)

对于出现在初始状态的谓词，它们是正的，对于没有出现的谓词，我们否定它们。

目标状态

构建目标状态(图片由作者提供)

当构建目标状态的公式时，我们不枚举谓词。我们需要的只是包括目标状态。

目标状态的公式为:

目标状态的公式(图片由作者提供)

请注意，步骤 1 是最后一步。

行动

建筑动作(作者图片)

这意味着执行一个动作意味着前提条件在当前步骤成立，效果在当前步骤+ 1 成立。

在这里，我们列举(或实例化)的行动。在这个简单的域中，我们只有两种可能的操作。

所有动作(图片由作者提供)

行动的公式:

动作的公式(作者图片)

我们需要把这个公式转换成 CNF，以便以后在算法中使用。通过使用布尔代数，我们将得到:

CNF 行动的公式(图片由作者提供)

解释性框架公理

这就是说，行动只改变它所影响的因素，而不是其他任何事情。

构建解释性框架公理(图片由作者提供)

这意味着如果一个流利度改变，那么 具有该流利度的动作 之一已经被执行。

值得注意的是，等式的右边可能有多个动作。

在我们的例子中，有四种影响，两种正面影响和两种负面影响。

解释性框架公理的公式(图片由作者提供)

我们还得把这个公式转换成 CNF:

CNF 解释框架公理的公式(图片由作者提供)

完全排斥公理

最后一步是确保在每一步我们只执行一个动作。这可以通过对所有动作组合使用以下公式来实现。

构建完全排斥公理(图片由作者提供)

对于我们的示例，公式如下:

完全排斥公理的公式(图片由作者提供)

现在，我们可以把上面所有的公式合并成一个。这就成了我们在 CNF 的公式，我们可以把它输入到 Davis-Putnam 算法中，来检验它是否是可满足的。

用 Davis-Putnam 算法解决 SAT 问题

现在有了我们的命题公式，就可以用戴维斯-普特南算法来求解了。

戴维斯-普特南算法是一个递归程序，如下所示:

戴维斯-普特南算法(图片由作者提供)

首先，对于单个子句，它们必须是真实的。所以我们通过公式来简化它。如果没有更多的单子句，我们在非单子句中选择一个变量，将其拆分为真赋值和假赋值。

下面是一个例子:

戴维斯-普特南的例子(图片由作者提供)

在我们的示例中运行 Davis-Putnam，得到以下模型和计划:

模型和平面图(图片由作者提供)

Davis-Putnam 算法输出六个子句及其赋值(对/错)。从模型中提取计划很容易。我们只需要提取已经赋值为 True 的动作，在本例中，就是从位置 1 移动到位置 2。

结论

在这篇文章中，我们学习了如何使用现有技术——SAT，通过将经典规划问题表示编码为有界规划问题及其 CNF(合取范式)来找到规划问题的解决方案。

然后，我们使用 Davis-Putnam 算法来解决 SAT 问题，并提取我们的解决方案，如果 SAT 问题是可满足的。

这种方法的一个限制是我们需要指定长度，这意味着我们可能需要尝试几次才能知道我们的问题的解决方案是否存在。

我用 Python 写了编码和 Davis-Putnam 算法。如果您感兴趣，请从这里获取:

*https://github.com/debbynirwan/planning_sat *

利用约束满足问题的人工智能规划

原文：https://towardsdatascience.com/ai-planning-using-constraint-satisfaction-problems-eb1be5466af6?source=collection_archive---------7-----------------------

利用约束满足问题解决人工智能规划问题。

马库斯·温克勒在 Unsplash 上的照片

介绍

就像 AI 规划作为可满足性一样，我们可以使用一种现有的技术——约束满足问题来帮助我们解决 AI 规划问题。这样我们就可以使用现有的成熟的求解 CSP 的算法来解决我们的 AI 规划问题。

我们将首先介绍 CSP 的概况。然后我们继续看如何将人工智能规划问题编码到 CSP 中。最后，我们使用 CSP 回溯算法来解决我们的问题。我们将通过在 Python 中实现它们来证明所有这些理论。

约束满足问题

来自维基百科，

CSP 是定义为一组对象的数学问题，这些对象的状态必须满足一些约束。

约束满足问题(作者图片)

这幅图描绘了有限域上的 CSP。我们有一组变量——X，一组域列表——D，和一组约束——c。

赋给 X 中变量的值必须是它们在 d 中的定义域之一。

变量和域(图片由作者提供)

约束限制了来自 x 的变量子集的可能值。

例子

一个很好的例子是地图着色问题。你可以点击链接看地图。在这个问题中，我们有变量，它们是区域，域是我们可以分配给变量的颜色(红色、绿色、黄色、蓝色)；在这个例子中，所有变量都有相同的域。

地图着色变量和域(图片由作者提供)

约束条件是分配给一个区域的颜色不能分配给相邻的区域。

有限域上的 CSP 通常使用某种搜索算法来解决。既然我们理解了什么是有限域上的 CSP，我们可以开始研究如何将规划问题编码到 CSP 中。

将规划问题编码到 CSP 中

就像“作为可满足性的规划”一样，我们将规划问题编码到命题可满足性问题中，我们可以用这种方法做同样的事情。

我们将有界规划问题——计划长度固定的约束规划问题编码为约束满足问题。完全编码有四个步骤。下面我们会一一看到。

CSP 变量和域

在第一步中，我们想要创建 CSP 变量及其对应的 CSP 域。我们需要将两个组件转换为 CSP 变量，它们是:

  • 断言
  • 行动

对于谓词，我们为每个步骤实例化所有谓词。记住我们有一个固定长度的计划( k )。

例如，假设我们有一个简单的规划域，其中只有一个机器人和两个位置，如下面的 pddl 文件所示。我们的有界规划问题的长度是 1。

简单域(作者代码)

我们可以将规划领域编码为以下 CSP 变量和领域:

CSP 变量和域—谓词(图片由作者提供)

数字表示步骤，因此对于从 0 到有界规划问题长度的每一步，我们将枚举所有可能的谓词。在这个例子中，我们有两个变量，其中每个变量都有相同的域 {loc1，loc2} 。

类似地，对于动作，我们从步长 0 到步长-1 进行实例化。

CSP 变量和域操作(图片由作者提供)

对于我们的简单域，我们只有一个 action 变量，它是 act(0) ，在其域中有两个可能的值。但是另外，我们将需要添加一个无操作动作(无操作动作)到域。这是一个没有先决条件也没有效果的行动。

现在，我们有了 CSP 变量和相应的域，在接下来的步骤中，我们将有 CSP 约束。

CSP 对初始状态和目标状态的约束

在这一步中，我们将初始状态和目标状态编码到 CSP 约束中。对于我们的例子，我们将使用下面 pddl 文件中表示的简单规划领域的规划问题。

简单规划问题(由作者编写代码)

在初始状态，我们的机器人处于位置 1 ，在目标状态，它处于位置 2 。这真的很简单。

这一步非常简单。我们只需要将初始状态和目标状态转换成一元约束，每个受影响的变量被赋予一个来自其定义域的值。

CSP 对初始和目标状态的约束(图片由作者提供)

这意味着在步骤 0，机器人的位置被限制在位置 1 ，在步骤 1，机器人的位置被限制在位置 2 。

CSP 对行动的约束

在这一步中，我们将动作转换成二元约束。我们如下写约束集。

前提条件:

前提条件约束集构建器(图片由作者提供)

前提条件约束示例(图片由作者提供)

效果:

效果约束集生成器(图片由作者提供)

效果约束示例(图片由作者提供)

这些约束是为了确保变量被正确赋值。如果 act(0) 已经赋值给 move(rob，loc1，loc2) ， atl(0，rob) 只能是 loc1 。

框架公理的 CSP 约束

框架公理约束是说，在动作效果中没有被显式修改(或也称为不变量)的变量保持不变。举例来说，我们需要向我们的规划域添加另一个谓词。假设我们有一个新的谓词 loaded(r)={cont，nil} ，它表示机器人是否装载了一个容器。这个谓词不受 move(r，l，m) 动作的影响，因此它在执行 move(r，l，m) 动作前后保持不变。我们将这一事实表述如下。

框架公理约束示例(图片由作者提供)

从上面的例子中，我们可以看出，在执行移动动作后，机器人根据其初始状态保持空载/负载状态。

求解 CSP 的算法

我们现在有了我们的有界规划问题——具有固定长度的人工智能规划问题 k ，被编码成一个约束满足问题。我们可以使用现有的解析器来求解 CSP。

如果有解，解算器将返回指定的变量(参见上一节中的 CSP 变量)。我们对行动 CSP 变量特别感兴趣，以便我们提取计划。

然后，我们可以基于该步骤对提取的动作 CSP 变量进行排序，并拥有我们的计划。

有序计划(图片由作者提供)

求解 CSP 的搜索算法

常见的求解器是回溯搜索算法，如下所示。

回溯搜索算法(作者图片)

这个算法很简单。它接收σ中的部分解和 x 中的未赋值变量。

如果所有变量都已赋值，这意味着我们有了解，算法返回σ。

否则，它将选择一个变量为其赋值。然后，它继续从域 d 中删除不一致的值。

然后给它赋值，然后递归调用自己。如果在某一点失败，它会回溯并在“选择 vi ∈ Di”处选择另一个值。

当我们用 Python 实现这个算法时，它会更容易阅读。

Python 中的结论和代码

在这篇文章中，我们学习了如何使用现有的技术——CSP，通过将经典的规划问题表示编码为有界规划问题和约束满足问题，来找到规划问题的解决方案。

然后，我们使用经典的 CSP 回溯算法来解决我们的 CSP。

这种方法的一个限制是我们需要指定计划的长度，这意味着我们可能需要尝试几次才能知道我们的问题是否存在解决方案。

我用 Python 写了编码和 CSP 回溯算法。CSP 回溯算法取自以下链接:

https://freecontent.manning.com/constraint-satisfaction-problems-in-python/

…因为我发现使用函数比使用上一节算法中的元组集更容易理解和实现 CSP 约束。

如果您对代码感兴趣，请从这里获取:

https://github.com/debbynirwan/planning_csps

人工智能驱动的商业决策

原文：https://towardsdatascience.com/ai-powered-business-decision-making-111c06750488?source=collection_archive---------38-----------------------

解决选择人工智能解决的正确业务问题的困境..

来源:pixabay

为什么重要？

解决问题可能需要智慧，但找出哪些问题值得解决需要智慧。人工智能的引入为计算世界提供了一个范式转变。许多具有前瞻性思维的企业已经开始重塑自己，并开始在设计系统时将人工智能深入到他们的解决方案构建中。围绕人工智能的大肆宣传迫使一些组织重新规划他们的技术战略，并考虑用它来解决哪些相关问题，以增加他们的业务价值。营销内容正在重新创建，销售宣传资料也在重新设计。构建人工智能是昂贵的，并且需要与应用程序相关的所有团队之间的协作。旅程必须从通过人工智能解决相关商业问题的意图开始。试图通过任何手段在应用程序中添加人工智能，只是为了加入人工智能革命，这就像不系安全带超速行驶一样危险。这肯定会导致重大的失败，以及时间和精力的巨大损失。有趣的是，在某些情况下，一个简单的基于规则的配置被冒充为“人工智能驱动的功能，以吸引注意力或提高销量。在所有这些古怪行为中，企业知道何时使用人工智能以及更重要的是何时不使用人工智能是谨慎的。

深入挖掘一下

人工智能到底是什么有很多相似之处，但它肯定与传统编程有很大不同。人工智能模型不是对规则进行编码，而是通过训练，在没有明确编程的情况下，自己从数据中获得洞察力。例如:

基于规则(非人工智能)的系统通知:“向您的钱包添加资金”，如果余额少于 1000 印度卢比。

基于人工智能的系统通知:“将 xyz INR 添加到您的钱包中，因为您明天可能需要它”。

建议金额是基于过去的消费模式，以确保用户永远不会用完钱包中的钱。另一个例子可以是打开电子邮件的通知，使其出现在对用户来说可能非常重要的屏幕上，而不是对每封电子邮件都显示。

后者提供了更加个性化的体验，对用户来说更加方便。这就是人工智能如何为最简单的商业用例增加价值。可以想象，理解应用程序中每个用户的消费模式或维护发送通知的规则是多么困难。

人工智能已经很好地解决了与计算机视觉相关的多个问题。例如，是什么使“狗”看起来如此，它与“猫”有什么不同。显式编码需要在系统中定义太多的规则，这会导致混乱。通过向“狗”展示一堆“狗”的照片，人工智能技术可以用来训练或学习“狗”的哪些特征使它看起来如此。一旦经过适当的训练，人工智能软件就能够在没有明确编程的情况下识别照片中的“狗”，因为它已经理解了“狗”的样子。如果人们还必须识别照片中“狗”的类型或品种，这将成为一个更加复杂的问题。人工智能也可以在这方面提供帮助，有了高质量的数据和良好的训练，它可能会变得非常高效。这可以应用于支持诸如面部识别之类的功能，用于考勤捕捉或替代用户认证方法。这可以自动应用于所呈现文档的分类或归类。一般来说，这也可以称为对象分类。

人工智能在软件程序中用简单的条件结构(if-else)做出简单的决定，例如“如果支付完成，交付订单”或“如果账单支付延迟，增加滞纳金”，这无疑是一种过度的行为。AI 不会给这些显而易见的决定增加任何价值。然而，人工智能可以帮助预测消费者拖欠账单付款的可能性。提醒可以提前发送，以避免滞纳金。

人们应该重新考虑在预期输出需要在本质上确定的场景中使用人工智能。例如，在表上执行查找(基于关键字的搜索)。给定特定的输入搜索关键字，它将始终返回相同的输出，例如，获取基于员工 ID 的员工薪金。人工智能不会让它变得更准确或更快。然而，通过忽略拼写错误或基于同义词的搜索或基于输入句子的意思，AI 可以用于对输入搜索关键字执行更智能的搜索。这可以在“对话聊天机器人”中使用，以理解用户的输入查询，并从库中的 FAQ 列表中寻找相关答案。

描述性与认知性的困境

基于已下订单或前 10 名违约者等描绘前 10 名客户的图表或可视化。只是描述性的商业用例，而不是人工智能。根据最近的趋势变化，人工智能可以用来预测客户违约的可能性或获得前 10 名的可能性。这增加了巨大的商业价值和对客户与系统交互的良好理解。这就是描述性和认知性业务用例之间的区别。

总结:把所有这些放在一起

人工智能正迅速成为解决多个行业无数问题的关键。预计它将解决复杂的优化问题，并随着时间的推移，通过访问更多高质量的数据进行训练而变得更好。简而言之，人工智能旨在通过使用算法识别数据中的模式来解决复杂的商业问题，并帮助更快地做出决策。在风险估计、趋势预测评分引擎、客户细分等领域，人工智能可以给出合理结果的例子还有很多。来自图像的对象分类、图像理解或字幕、人脸识别、文本理解、情感分析和推荐引擎。生成模型可用于创建各种风格的艺术、音乐、图像、视频或文本。这些都是人工智能很好解决问题的例子。

然而，必须有一个策略来首先解决与人工智能相关的业务问题，例如，应该将推荐引擎用于交叉销售还是追加销售以提高销售额？或者，它是否应该用于建议在后端处理某些客户的请求的优先级？其后还必须跟随一个数据策略。任何人工智能模型都需要大量没有任何异常的高质量训练数据来给出有意义的结果。需要遵循迭代过程来很好地训练人工智能模型。因此，采用人工智能是一个漫长的旅程，需要不断的维护和保养。

重要的是要注意到，事实的死记硬背不是人工智能的目的，即使是鹦鹉也可以做到这一点，而无需对它所说的话进行任何理解。人工智能为解决复杂问题带来了一套新的思路，通过对过去的理解来确定未来，从而快速做出决策。也许，这就是智慧的含义..

通过 Amazon Kendra 和 AWS Glue 数据目录进行人工智能驱动的数据发现

原文：https://towardsdatascience.com/ai-powered-data-discovery-with-amazon-kendra-and-aws-glue-data-catalog-f2d2cdcc9233?source=collection_archive---------17-----------------------

如何着手实施完全托管的数据发现服务

通过 Amazon Kendra 和 AWS Glue 数据目录进行人工智能数据发现——Olalekan Elesin

在过去的几个月里，我询问了 AWS 基于 AWS Glue Data Catalog 的完全托管的数据发现服务，但是没有结果。我经常收到使用 AWS Glue 数据目录搜索功能的建议，并使用自定义 UI 和 AWS SDK 进行扩展，这样用户就不需要登录 AWS 控制台来查找可用于分析的相关数据。无论这种方法多么有用，它并没有被证明是有用的，因为我坚信数据发现不仅仅是一个搜索 UI，更多的是关于搜索结果的相关性。这看起来像是机器学习和图形算法的完美问题——还记得 PageRank 吗？

编写 PageRank 算法或重用现有模块是不可能的，主要是因为我要花时间让它投入生产。我还考虑了现有的开源产品，如阿蒙森(来自 Lyft)和数据中心(来自 LinkedIn)，它们都以自己的方式取得了成功，但并不符合我的需要。这不是从功能的角度来看(因为两者都有丰富的功能)，而是从基础设施管理的复杂性来看。我在寻找一种可以使用 AWS Cloud 提供的构建模块轻松拼凑起来的东西。

AWS 搜索服务来救援

据我所知，在撰写本文时，AWS 上大约有 3 到 4 个搜索管理服务。它们是:

  1. 亚马逊云搜索
  2. 亚马逊弹性搜索
  3. 亚马逊肯德拉
  4. AWS Infinidash (这个服务是虚构的，不存在)

在这三者中， Amazon Kendra 符合我想要解决的特定需求，即使用机器学习来改善数据发现体验(注意:我并不专注于搜索功能)。

什么是亚马逊 Kendra

根据产品页面:

亚马逊 Kendra 是一项由机器学习支持的智能搜索服务。Kendra 为您的网站和应用程序重新设计了企业搜索，以便您的员工和客户可以轻松找到他们正在寻找的内容，即使这些内容分散在您组织内的多个位置和内容存储库中。… Amazon Kendra 是一项完全托管的服务，因此无需供应服务器，也无需构建、训练或部署机器学习模型。

https://aws.amazon.com/kendra/

正如产品页面上所述，亚马逊 Kendra 是一项完全托管的服务，因此，维护和扩展机器学习系统的基础设施负担是完全不可能的。我需要做的就是弄清楚如何以适用于 Amazon Kendra 的格式准备我的数据。

这项工作

出于本文的目的，我们将主要从 AWS 控制台关注一个简单的工作流。所附架构图中引用的组件不是本文的一部分，但是正在被开发成一个全功能的数据发现工具。

环境设置

我们需要快速原型化和验证这个想法的 AWS 环境设置是一个亚马逊 SageMaker 笔记本实例(用于 Jupyter 环境)和一个亚马逊 Kendra 索引。我不会详细介绍如何建立一个亚马逊 SageMaker 笔记本实例，我坚信你会在网上和 AWS 机器学习博客上找到大量关于这方面的资源。

Amazon Kendra 也包含大量关于其设置的文档，但我想强调一下，只需点击几下鼠标，从控制台创建一个索引是多么容易。点击以下链接了解更多信息:

一旦我们的 Amazon Kendra 索引建立并运行，接下来的事情就是用可搜索的元数据填充索引。

在数据发现中，元数据为王

与任何其他数据发现工具一样，元数据是王道。我们将利用 AWS Glue 数据目录中的数据库和 S3 表。为了使这些信息可以通过 Amazon Kendra 进行搜索，我需要在 Amazon Kendra 中以可索引的格式准备元数据(即 AWS Glue 数据目录中的数据库和表名)。这对于 AWS Python SDK boto3 来说非常简单。请参见下面的示例:

def get_all_glue_tables():
    """
    Function to get all tables in AWS Glue Data Catalog
    """
    glue_tables = []
    kwargs = {}
    response = glue.search_tables(**kwargs)
    glue_tables.extend(response['TableList'])
    while 'NextToken' in response:
        token = response['NextToken']
        kwargs['NextToken'] = token
        response = glue.search_tables(**kwargs)
        glue_tables.extend(response['TableList'])
    return glue_tables

如何准备 AWS 胶水搜索表结果索引到亚马逊 Kendra

在亚马逊肯德拉搜索和发现

随着元数据作为文档添加到亚马逊 Kendra ，是时候体验数据发现了。我的第一个搜索查询是寻找用户会话数据。为此，Amazon Kendra 返回了正确的结果及其建议的答案，这与我正在寻找的答案相匹配。此外，基于 Amazon Kendra 中的元数据和方面配置，我可以过滤我感兴趣的列或表类型(视图或外部表)。

使用 Amazon Kendra 和 AWS Glue 数据目录进行数据发现—图片由 Olalekan Elesin 提供

在研究了会话数据之后，我现在想看看转换时可用的数据。所以，我干脆问亚马逊 Kendra:“转换数据在哪里”。瞧，结果如下图所示

使用 Amazon Kendra 和 AWS Glue 数据目录进行数据发现—图片由 Olalekan Elesin 提供

最后，我希望看到带有 eventId 列的表，这样我就知道要为我的分析连接哪些表或视图:

使用 Amazon Kendra 和 AWS Glue 数据目录进行数据发现—图片由 Olalekan Elesin 提供

视窗网际网路名称服务

  1. 搜索体验允许自然语言提问。例如“eventid 用在哪里？”或者“转换数据在哪里？”。有了这一功能，任何人都可以更轻松地找到分析所需的相关数据。因此，减少了查找数据所需的时间。
  2. 无需维护基础设施，只需将数据填充到 Amazon Kendra 索引中，并观察用户发现数据。
  3. Amazon Kendra 文档属性可以用作过滤器，在本例中是列名，为过滤提供了直观的 UI。
  4. 超越 AWS 控制台体验的可扩展性。这个我没有试过，但是我从 AWS 找到了 React 组件。点击此处了解详情。

限制

  1. 不允许每个 API 调用向 Amazon Kendra 索引添加超过 10 个文档。这可能是一个很大的限制，尤其是对于包含大量表的 AWS Glue 数据目录。但是，有一个编程解决方法，可以将文档分成 10 个项目的块来添加。
  2. 带有字符串列表(即 StringList)的文档属性不能超过 10 项。在这个例子中，我添加了表列名作为带有字符串列表(即列名)的自定义属性。超过 10 列可能是企业表的标准，因此这是一个巨大的障碍
  3. 贵！

近期工作

尽管这篇博客文章涵盖了在 Amazon SageMaker 笔记本实例和 Amazon Kendra 控制台上开发的 MVP，但要让这样的系统投入生产使用，还需要一个如下面的架构所示的全功能应用程序。此外，与公司内部 wikis(如 Confluence)的集成将改善搜索结果和数据可发现性，因为数据文档存在于此类系统中。该架构还可以扩展到尚未连接到 AWS Glue 数据目录的数据源。

全功能数据发现工具的架构，包含 Amazon Kendra、AWS Glue 数据目录和 Amazon Athena。图片由奥拉勒坎·埃勒辛拍摄

迫不及待地想知道你会用亚马逊 Kendra 造出什么。您可以通过电子邮件联系我，在 Twitter 上关注我，或者在 LinkedIn 上与我联系。

人工智能隐私和数据安全，续

原文：https://towardsdatascience.com/ai-privacy-and-data-security-continued-a66e5ac3f593?source=collection_archive---------35-----------------------

参考书目

联邦学习简介

Unsplash 上连浩曲的照片

我们的数字足迹，意味着我们在互联网上写、看、读、贴、听和购买的任何东西，对于希望监控和收集数据的行业来说是一座金矿。最近的一期 TDS 播客探讨了现代人工智能技术中的隐私问题，以及数据安全政策如何一直处于不稳定状态。播客主持人 Jeremie Harris 与 Protegrity 的数据和人工智能执行副总裁 Eliano Marques 进行了交谈。他的见解从私人企业的倡议到有针对性的广告，再到围绕隐私的意识，他对致力于教育公众这一切意味着什么的教育提供了出色的评论。在这里重温这一集:

人工智能隐私是一个非常重要但却被误解的概念，是一个我们都应该寻求了解更多的话题，所以我在 TDS 中寻找关于这个问题的文章。我进入了一个关于联合学习的信息兔子洞，发现它与播客中讨论的主题非常契合。这个列表是初学者学习数据收集策略的友好资源。

AI 差分隐私和联邦学习

在 2019 年 7 月的一篇新闻报道中， Pier Paolo Ippolito 介绍了联合学习的概念:一种“在我们无法访问的数据上训练机器学习模型的技术”，正如文章指出的那样，这是数据隐私工作的一项关键措施。这是了解数据收集对个人和数据收集者的影响的极好的入门资源。

去中心化人工智能&捍卫隐私:联合学习的天才

2020 年 9 月，Andre Ye 发表了这篇关于道德和非侵入式机器学习的益处的信息丰富、易于理解的文章。叶在个人化的背景下对联合学习进行了出色的阐释——这在科技写作中是非常罕见和难以确定的。他在这里提出了一个关键问题:“在支持(而不仅仅是承认)用户数据隐私的同时，如何实现大数据带来的更个性化和更具吸引力的体验？答案是联合学习，它超越了支持和反对数据收集的争论，想象出一个中间地带:生活中不可避免的部分的最佳可能场景。

垂直联邦学习和数据共享时代的人工智能策略

Phillips 的人工智能顾问 Alexandre Gonfalonieri 在 2020 年 5 月写了关于大规模机器学习项目的数据共享。他发现，联合学习取决于模型的用例及类型、其他“参与者”接受的薪酬体系、可以共享的数据种类、参与数据共享联盟的公司数量、选定的中立 FL 协调员以及本地培训和网络交流的成本。Gonfalonieri 通过将这一理论应用于智能零售、金融和医疗保健行业，使这个话题又回到了原点。

人工智能监管:不再遥远的未来

原文：https://towardsdatascience.com/ai-regulation-no-longer-a-distant-future-4dc5600c082b?source=collection_archive---------26-----------------------

拜登政府将如何改变人工智能领域，你现在应该做什么

诺亚·多米尼克·西尔维奥在 Unsplash 上的照片

随着拜登总统最近做出一些重要任命，有很多猜测我们可以期待他的政府在未来四年里在人工智能/人工智能方面，特别是在监管人工智能应用方面做些什么——让技术更安全、更公平、更公正。

作为信息技术研究集团负责这一领域的分析师，我自然要参加竞选。以下是我的四大预测。

众议院和参议院将快速通过对人工智能的监管

我们可能还没有所有的细节，但方向和速度都相当清楚:我们可以期待监管在联邦一级得到快速跟踪，以补充州一级的法案。该路线图包括最近推出的法案，如 2019 年的算法问责法案，以及现有法规的现代化，如民权法案(1964 年)、公平住房(1968 年)和其他涵盖人工智能和算法决策系统的法案。

事实上，算法问责法案背后的驱动力——参议员罗恩·怀登和科里·布克，以及众议员伊薇特·克拉克——正计划今年在参众两院重新提出他们的法案。

总的来说，我们可以期待看到政府追求一个议程，更好地将人工智能/人工智能纳入现有的和新的立法框架，并随着人工智能标准和实践的不断发展，留下足够的灵活性空间。

道德人工智能标准将快速发展

为了使监管有效，它需要由价值观驱动，以证据为依据，以合理的风险模型为基础，并由标准和认证支持。因此，我们预计，随着政府指导意见的形成，政府机构将很快加强对人工智能的关注。NIST 和其他人将加倍努力，为人工智能技术、算法偏差、可解释性以及人工智能治理和风险管理开发基准、标准和测量框架。

一些工作已经在进行中，例如面部识别厂商测试和可解释的人工智能，但是我们可以预计这个计划会很快加速。

监管者将跨境合作

在这个相互联系的世界中，任何对技术的监管都不能孤立地进行，尤其是像 AI/ML 这样的技术。有几个迹象表明立法者愿意联合起来互相学习，特别是从那些一开始就把它作为优先事项的国家。(毕竟，如果处理得当，监管不会成为创新的障碍——下面会有更多相关内容。)

在未来四年，我们将看到与欧洲和国际组织以及邻国在人工智能监管、标准、认证和审计方面的合作增加，其中许多国家已经领先于美国同行。更高水平的全球伙伴关系将积极影响在美国和国外建立更全面的立法框架的努力。

联邦机构将获得更广泛的授权，包括 AI/ML

法律可以告诉你什么可以做，什么不可以做，但它的力量来自于法院和有权实施处罚和其他监管制裁的监督机构的强制执行。目前，尚不清楚这一权力是什么，以及它是如何在与 AI/ML 相关的各联邦机构之间分配的。

我们预计这种情况将很快得到解决，方法是扩大现有监督机构的授权，以包括人工智能和机器学习驱动的应用程序和系统，以及建立人工智能审计员——特别是人工智能偏见审计员——的培训、认证、认可和监督的指令，类似于食品检查员和消费者安全检查员。

斯科特·格雷厄姆在 Unsplash 上拍照

这一切对你的组织意味着什么？

那么，这对你的组织有什么影响，无论你只是在考虑利用 AI/ML 还是已经做了很多年？

我的观点是，监管——以及它的另一面，治理——并不邪恶。如果执行得当，监管可以创造确定性，建立公平的竞争环境，并促进竞争。它还为内部政策、治理和责任提供信息。治理有助于构建关于人工智能货币化的可接受风险和回报的讨论——提高组织的成功几率。

治理(以及监管)也有助于建立和加强信任:在组织内部，但最重要的是，与客户的信任。的确，信任是所有业务的基础。

你可以赶在任何即将到来的监管变化之前

不要等到监管成为现实！你可以采取三个简单的步骤来避免意外，并让你的组织做好准备:

不要等 AI 监管来找你！通过行业协会、智囊团、公共政策和公民利益团体以及你的众议院代表参与塑造它。

积极地管理你的组织的人工智能驱动的应用程序，在其他人(包括政府)赶上来之前建立你的过程成熟度。企业根本等不起。或者面临部署有偏见的系统的风险，这可能会损害您的客户，从而损害您的声誉和资产负债表。

记录并主动披露您如何以及在何处使用人工智能/机器学习、数据和分析，以及这些系统是如何构建的。人工智能注册——例如，阿姆斯特丹和赫尔辛基和的城市所利用的——是一种与你的客户分享这些信息并增加他们的信任和忠诚度的直接方式。他们也将为审计师和监管者工作。它们为内部人工智能治理创建了一个最小可行框架的基础。

治理和监管真的不是负担。即使要花钱，它们也代表着商业成功的一项重要的增值投资。治理是一种创造价值、将人工智能等新技术货币化以及发展和加强业务(同时监控和降低风险)的机制。更大的风险在于忽视人工智能的潜力，或者让竞争对手捷足先登。

人工智能风险是一个全球性问题

原文：https://towardsdatascience.com/ai-risk-is-a-global-problem-ee56b3cb8930?source=collection_archive---------33-----------------------

播客

Nicolas Miailhe 谈人工智能的全球协调

苹果 | 谷歌 | SPOTIFY | 其他

编者按:这一集是我们关于数据科学和机器学习新兴问题的播客系列的一部分，由 Jeremie Harris 主持。除了主持播客，Jeremie 还帮助运营一家名为sharpes minds的数据科学导师初创公司。

1938 年 12 月，一位名叫利奥·齐拉特的沮丧的核物理学家给英国海军部写了一封信，告诉他们他已经放弃了他最伟大的发明——核链式反应。

核连锁反应的想法是行不通的。没有必要对这个专利保密，事实上也没有必要保留这个专利。没用的。

—利奥·齐拉特

Szilard 舔信封时不知道的是，就在同一天，柏林的一个研究小组第一次分裂了铀原子。一年后，曼哈顿计划开始实施，到 1945 年，第一颗原子弹被投放到日本广岛。仅仅四年后——也就是西拉德认为不可能的十年后——俄罗斯成功试验了第一枚原子弹，开启了以各种形式延续至今的全球核军备竞赛。

从尖端技术到全球范围的风险，这是一个令人惊讶的短暂跳跃。尽管核能故事是这种飞跃的一个引人注目的例子，但它远不是唯一的例子。今天，许多人认为人工智能是一种技术，其发展将导致全球风险——因此，是一种需要全球管理的技术。就像国际条约允许我们降低核战争的风险一样，我们可能需要围绕人工智能进行全球协调，以减轻其潜在的负面影响。

Nicolas Miailhe 是人工智能全球协调问题的世界领先专家之一。Nicolas 是未来社会(Future Society)的联合创始人，未来社会是一个全球性的非营利组织，其主要关注点是鼓励负责任地采用人工智能，并确保世界各国对与之相关的风险达成共识。Nicolas 是著名的哈佛大学肯尼迪政府学院的资深专家，是人工智能全球伙伴关系的指定专家，并为城市、政府和国际组织提供人工智能政策方面的建议。

以下是我在对话中最喜欢的一些观点:

  • 人工智能是一种双重用途的技术:可以用于自动化撰写乏味电子邮件的相同人工智能系统也可以用于大规模定制网络钓鱼攻击。由于其通用性质，尼古拉斯认为人工智能的机遇和挑战密不可分。因此，减缓人工智能发展不仅不可行，而且不可取——监管和投资必须齐头并进。
  • 在人工智能可以被监管之前，在我们可以制定关于人工智能的国际协议之前，我们需要建立对人工智能是什么的共同理解。这比看起来更难:对于不想在人工智能开发竞赛中落后的发展中国家来说，安全似乎不那么重要——人工智能能力下降的经济影响太严重了。但在发达国家，通用人工智能技术的突破步伐越来越快，导致人们更加关注安全、公平和人工智能对齐。至关重要的是，我们要找到一种方法，就如何实现政策的正确平衡达成一致，以获得全球的认同。
  • 除了协调不同国家在人工智能上的议程，Nico 还强调了解决人工智能时间表分歧的重要性。特别是，许多人工智能研究人员认为，我们可能在未来十年内实现人类水平的通用人工智能，因此相信人工智能安全和人工智能对齐应该是人工智能社区比他们更大的关注点。相比之下，其他人认为真正的转型人工智能系统仍有很长的路要走，用深度学习先驱和 Coursera 创始人吴恩达的话说，担心人工智能的安全“就像担心火星上的人口过剩”虽然这种分歧可能无法完全解决，但在这个方向上建立共识很有价值。
  • 有时有人认为，政府将无法有效监督和监管人工智能的发展，因为私营公司对人工智能的绝大部分进展负有责任。Nicolas 认为这是一种误解，并指出了 DARPA、NSF 和 NIH 等政府资助项目在推进人工智能技术方面的作用，以及它们对私营企业的投资。他还强调，主要的国防合同(如 JEDI )导致大量资本流入微软等公司，这些公司反过来将这些资源重新用于资助行业领先的人工智能研究。尼古拉斯认为，公共部门对人工智能的贡献何时结束，私营部门的贡献何时开始，并不那么明显。

你可以在推特上关注尼古拉斯，或者在推特上关注我

播客中引用的链接:

  • 未来学会的网站在这里。

章节:

  • 0:00 介绍
  • 0:50 尼古拉斯的背景
  • 7:45 人工智能安全时间表(MIRI)
  • 11:00 探索人工智能安全空间
  • 14:00 AI 的各种定义
  • 21:45 人工智能研究投资
  • 24:40 网络殖民主义与人工智能和解
  • 31:42 扩散策略
  • 34:00 人工智能全球伙伴关系
  • 37:50 中国在人工智能方面的进步
  • 47:45 中国企业对 AI 安全的思考如何？
  • 52:20 政府在资助人工智能安全研究中的作用
  • 55:33 总结

人工智能安全和扩展假说

原文：https://towardsdatascience.com/ai-safety-and-the-scaling-hypothesis-76bfee57f924?source=collection_archive---------30-----------------------

播客

安迪·琼斯解释了我们如何从小型人工智能中预测大型人工智能的能力——以及这对人工智能安全意味着什么

苹果 | 谷歌 | SPOTIFY | 其他

编者按:这一集是我们关于数据科学和机器学习新兴问题的播客系列的一部分，由 Jeremie Harris 主持。除了主持播客，Jeremie 还帮助运营一家名为sharpes minds的数据科学导师初创公司。

当 OpenAI 去年宣布发布他们的 GPT-3 API 时，科技界震惊了。这是一个语言模型，只被训练来执行一个简单的自动完成任务，它被证明能够进行语言翻译、编码、论文写作、问题回答以及许多其他任务，而这些任务在以前都需要专门构建的系统。

GPT 3 号有能力解决这些问题的原因是什么？它是如何击败专门为解决它从未明确训练过的任务而构建的最先进的人工智能的？这是一个绝妙的新算法吗？比深度学习更深的东西？

嗯……不。就算法而言，GPT 3 相对简单，是用当时相当标准的变形金刚架构建造的。GPT-3 与之前所有系统的真正区别不是花哨的算法，而是尺寸:“GPT-3”是一个简单但庞大的 175B 参数模型，比第二大人工智能系统大 10 倍。**

GPT-3 只是一长串结果中的最新一个，这些结果表明，扩大简单的人工智能技术可以产生新的行为和更大的能力。这些结果共同推动了人工智能的扩展:追求更大的人工智能，在更大的数据集上进行更多的计算。但是扩大规模是昂贵的:据估计，GPT 3 号的训练成本高达 500 万美元。因此，只有资源丰富的公司，如谷歌、OpenAI 和微软，才能够用缩放模型进行实验。

这对独立的人工智能安全研究人员来说是一个问题，他们希望更好地了解先进的人工智能系统如何工作，以及他们最危险的行为可能是什么，但他们负担不起 500 万美元的计算预算。这就是为什么专注于人工智能扩展的独立研究员安迪·琼斯最近的一篇论文如此有前途:安迪的论文表明，至少在某些情况下，大型人工智能系统的能力可以从较小的系统中预测出来。如果这一结果得以推广，它可能会让独立研究人员有能力在小型系统上进行廉价的实验，但这种实验也可以推广到昂贵的大规模人工智能，如 GPT-3。安迪很友好地和我一起参加了这一集的播客。

以下是我在对话中最喜欢的一些观点:

  • 研究人员在过去探索了人工智能的扩展趋势，但他们倾向于只调查模型大小、数据和计算能力的扩展效果。除了探索扩展的计算能力，安迪还尝试扩展人工智能试图解决的问题的复杂性。他使用 DeepMind 的 AlphaZero 算法玩了一个名为 Hex 的简单棋盘游戏，值得注意的是，他发现可以通过观察其在简单游戏中的表现来预测他的人工智能在复杂游戏中的表现。
  • 已经研究了与特定任务相关的缩放定律(例如，“如果我将模型大小和计算预算增加一倍，图像识别精度会有什么变化？”).但正如 GPT-3 所显示的，当人工智能系统变得更大时，它们不仅在接受训练的特定任务上表现更好，而且通常在全新的、更普遍的任务上也表现更好。不幸的是，因为我们目前缺乏一种方法来衡量人工智能系统的泛化能力，所以还没有直接检查作为规模函数的普遍性的研究(尽管正如 Andy 提到的那样，存在旨在更好地量化人工智能系统中的普遍性的积极努力)。
  • 人工智能能够学习关于它所接受训练的任务的知识，然后将其应用于其他任务，这种能力被称为元学习。尽管 GPT-3 是我们见过的元学习最引人注目的例子，安迪指出回想起来它并不是第一个。事实上，你可以提出一个非常令人信服的论点，即所有的机器学习都是元学习，至少在某种程度上是如此:模型通常会从一项概括其他任务的狭窄任务中学习东西(即使这些东西的数量和重要性通常小到我们无法注意到它们)。作为一个甚至早于现代机器学习时代的元学习的例子，安迪引用了早期的马尔可夫链模型，这些模型可以产生与他们的训练集中不同的有趣和新颖的语言结构。即使是接受过计算机视觉问题训练的人工智能也显示出发展了一种地理感觉，这种感觉原则上可以应用于其他问题类别。

你可以在这里的 Twitter 上关注安迪，或者在这里的 Twitter 上关注我。

播客中引用的链接:

  • 安迪在《GPT 3》发布后发布的关于 LessWrong 的原始帖子。
  • 如果你有兴趣从事独立的人工智能安全研究，安迪推荐生存和繁荣基金，它支持他的最新项目。

****章节:

  • 0:00 介绍
  • 1:30 安迪的背景
  • 3:00 为什么 AI 安全？
  • 13:20 罗宾·汉森模拟奇点
  • 16:35 我们如何衡量人工智能系统？
  • 23:45 跨任务能力
  • 31:45 GPT 3 号的发射
  • 36:30 安迪的案子及其未来走向
  • 43:10 围绕 AI 的焦虑
  • 51:35 游戏算法
  • 1:00:04 新的扩展发现
  • 1:10:18 人类不断进步
  • 1:16:06 增加的安全问题
  • 1:24:15 总结

创造人工智能对抗环境污染

原文：https://towardsdatascience.com/ai-to-combat-environmental-pollution-6d58b0bf6a1?source=collection_archive---------20-----------------------

变更数据

一群波兰妇女如何在当地环境中建造用于垃圾检测的人工智能

在 Unsplash 上由 Brian Yurasits 拍摄的照片

塑料问题

废物污染是现代世界最大的环境问题之一。

根据纽卡斯尔大学进行的一项研究，人类每年吃掉多达 250 克的微塑料。相当于一年两块半巧克力。而是塑料的。

几乎 90%的塑料来自瓶装水和自来水。今天，每年生产 3 亿多吨塑料，只剩下 30 年的时间，海洋中垃圾的数量就会超过海洋生物的数量。

一群来自机器学习中的女性&数据科学(WiMLDS) 组织波兰分会的女性不仅思考了这个问题，还决定自己创造一个解决方案，能够检测环境中的垃圾——使用人工智能。

用人工智能对抗垃圾

在波美拉尼亚检测废物是一个非盈利、教育、生态项目，旨在利用人工智能造福大众。

这个想法是使用机器学习来检测环境中的塑料废物，教育和支持来自当地社区的妇女在数据科学和机器学习领域的职业发展。

该项目的目标是来自波美拉尼亚的人，至少具有中级 Python 知识和深度学习的基本经验。

在 5 个月的时间里，一个由精心挑选的成员、 9 名女性数据科学家、分析师和机器学习工程师组成的团队在 5 名行业导师的支持下，共同研究和开发一个垃圾检测模型，这是一个适用于视频和摄影的解决方案。

ai4 检测环境中废物的良好项目 www.detectwaste.ml (来源: TACO 数据集)

用于目标检测的迁移学习

在检测波美拉尼亚的浪费项目中，我们使用了 9 个公开的可用数据集，并且使用谷歌图片下载收集了一些数据。我们使用了一种称为迁移学习的技术，这是一种机器学习技术，在一项任务中训练的模型被重新用于第二项相关任务。在我们的例子中，我们使用在众所周知的 COCO 数据集上预先训练的模型。

在 5 个月的工作中，我们尝试了许多模式和方法，其中包括:

  • 效率检测，
  • DETR(检测变压器)，
  • 屏蔽 R-CNN，
  • 更快的 R-CNN，
  • 用 ResNet50 分类，
  • 使用 EfficientNet 分类。

但是废物检测并不是一件容易的事情。很容易过度训练模型，有时很难定义什么是一窝。

破旧的鞋子。一窝还是不一窝？(图片由 WIMLDS Trojmiasto 提供)

我穿的鞋是一只鞋，而不是一只担架。但是如果我把它扔到森林里，它就会变成垃圾。

另一个问题来自生物垃圾；小块苹果，吃了一半的西红柿:神经网络很难学习它们，更难区分它们与自然。毕竟，树下的水果只是一个可能从树上掉下来的水果。但它可能会被人扔出去，然后变成垃圾。

然而，我们已经设法开发了一个基于开源人工智能的垃圾检测解决方案，并以大约 65%的平均精度检测垃圾，将其分为主要类别:

  • 金属和塑料，
  • 纸，
  • 玻璃，
  • 生物，
  • 不可回收，
  • 其他未知。

但是，我们是如何做到的呢？我们决定把任务分成两个，物体定位和物体分类。

第一步——废物本地化

我们试图从许多公共数据集中获取的高质量和低质量图像中检测出浪费。出于这个目的，我们使用了用 PyTorch 编写的 EfficientDet，这是一个流行的最先进的对象检测模型家族，来自 Google Brain 团队。我们的主要目标是从各种环境条件下拍摄的照片中定位垃圾。

我们从在 TACO 数据集上执行的废物检测开始，TACO 数据集是环境中废物的开放图像数据集。最初，根据格但斯克市的强制隔离规则，TACO 类别被转换为检测废物类别。在第一次尝试后，我们注意到，我们的模型在定位废物时表现相当好，但在分类时表现不佳。因此，我们决定改为尝试单类检测，并单独分类。

在我们的 GitHub 存储库中，您会发现已经针对我们的混合数据集进行了调整的 EfficientDet 代码。在我们的案例中，为 1 胎训练的 efficentdet-D2 给了我们最好的可能结果，mAP@0.5 几乎等于 64% 。较小的架构得分较低，而较大的架构很快就会过度适应。可能是由于高度不平衡的数据。

下一步—垃圾分类

对于分类任务，我们使用了 EfficientNet-B2 网络，这也是我们最好的废物检测器 EfficientDet-D2 的主干。在我们的垃圾分类挑战赛中使用的 EfficientNet ，是一个基于 AutoML 和复合缩放的卷积神经网络。

此外，我们使用了多种数据扩充技术，这在垃圾分类任务中非常重要。根据所处的环境，垃圾可以呈现不同的外观——在家里、水下或室外。因此我们决定应用一些在相册库中实现的方法。

第一步，我们必须准备带有适当标签的废物图像。我们将它们从混合数据集的训练和验证子集中剪切出来。

裁剪方法的核心是从注释中读取边界框属性，计算其新坐标，然后从源图像中剪切。

缩放参数(默认设置为 1)对于在背景中嵌入对象的分类非常有用，但是如果图像中挤满了许多对象，它会降低分数。

此外，我们还使用了一个 OpenLitterMap 数据集，在该数据集上我们已经预先定位了垃圾。最大的困难是从源 openlittermap 文件中提取对象类别，并结合我们预定义的垃圾定位将其分配给我们。由于标签误导，我们决定以半监督的方式使用数据。

TACO 指定的检测废物的类别(资料来源:WIMLDS Trojmiasto)

我们还增加了第八类:背景(没有任何垃圾的区域，例如人行道、森林小径、草坪)，因为有必要限制我们的检测器产生的假阳性数量。

为分类目的生成数据可能需要一段时间，但是最终在目标目录中，我们期望看到如下所示的结构。

我们的数据在 DataLoader 中加载到网络中，使用从增强库中选择的数据增强技术( RandomCrop、HorizontalFlip、VerticalFlip、ShiftScaleRotate、RandomBrightnessContrast、Cutout、Normalize )。

当涉及到训练模型时，我们处理了一组标记数据(来自混合数据集)以及一组未标记数据(来自 openlittermap，由于误导性的多标签)。在的伪标签概念中，主要思想很简单。

  1. 首先，根据标记的数据训练模型。
  2. 然后，使用训练好的模型来预测未标记数据上的标签—制作伪标签。在下一步中，预测将被视为未标记数据的基础事实标签。
  3. 将伪标签和真训练标签混合，用它训练模型。
  4. 每个批次或时期重复前面的步骤。

在我们的研究中，伪标签可用于每时期和每批次模式，这指的是伪标签的更新频率。(资料来源:WIMLDS Trojmiasto)

结果呢

在我们的案例中，在我们的神经网络上以 0.0001 的学习率和 16 的批量运行 20 个时期的训练后，以几乎 3/1 的训练/测试分割，我们实现了 73.02% 的测试准确度(和 86.67%的训练准确度)。

标签的 val 子集-id 的混淆矩阵按字母顺序排列:0-背景，1-生物，2-玻璃，3-金属和塑料，4-不可回收，5-其他，6-纸，7-未知。(资料来源:WIMLDS Trojmiasto)

来自测试子集的绝大多数样本都被正确分类。该矩阵还显示了数据的高度不平衡；不幸的是，塑料是最常见的垃圾，同时也是回收时最大的问题。

另一个问题在于回收规则。关于隔离原则，缺乏明确定义的统一准则。每个城市都不一样，每个国家都不一样。

例如，与我们的注释者团队讨论的“芯片包”,由于构成它的塑料材料类型的多样性(并非所有都是可回收的),有人可以将其视为属于金属和塑料类的废物，而其他人可以将其视为属于不可回收类的废物。

毕竟，不幸的是，垃圾无处不在。如果不加以收集，它往往会损害我们所在的环境。为了有效地清理它，我们需要学习如何回收它。

如果你对我们的项目的整个解决方案代码感兴趣，你可以在我们的 GitHub 上找到它，你也可以在 ArXiv 上读到更多关于它的内容。

作者:

https://medium.com/@magdalenakortas https://medium.com/@sylwia.majchrowska

WIMLDS Trojmiasto 小组成员 Agnieszka mikoajczyk、Sylwia Majchrowska、Maria Ferlin、Ewa Marczewska、Zuzanna Klawikowska、Marta Plantykow、Magdalena Kortas、Anna Brodecka 和 Katarzyna ago cka 制定了项目和最终解决方案。

AI-Tunes:用人工智能创作新歌

原文：https://towardsdatascience.com/ai-tunes-creating-new-songs-with-artificial-intelligence-4fb383218146?source=collection_archive---------5-----------------------

实践教程

我如何微调 OpenAI 的 GPT-3 来生成具有全球结构的音乐

由安东·达利斯在 Unsplash 上拍摄的照片

一年多来，我一直在试验各种基于人工智能的音乐生成系统，我讨厌这么说，但人工智能生成的大多数音乐听起来都像垃圾。要么太复杂杂乱，要么太简单重复。它几乎从来没有一个令人愉快的旋律与整体结构的组成。

我们目睹了最近在基于人工智能的其他媒体形式的内容创作方面取得的进展，如图像和文本。因此，令人困惑的是，人工智能生成的音乐质量似乎远远落后。

当我听说 OpenAI 发布了一个 API 来微调他们的 GPT-3 文本处理模型[1]时，我的第一个想法是，啊哈！，也许我可以用它来创作不烂的音乐。这花了一点功夫，但我设法从公共领域的音乐中获得了一些训练数据，并用它来教 GPT-3 如何作曲。我将在本文中详细解释我做了什么，但首先，这里有一个样本，我从五首生成的歌曲中精选出来的。

生成歌曲——洗碗先生，音乐 GPT-3，作者培训

好吧，这并不伟大，但至少对我来说，这听起来很有趣，我敢说，很好？

接下来是这个系统的概述，我称之为 AI-Tunes。

概观

下面是 AI-Tunes 的高层示意图。在简要讨论了每个组件之后，我将在下面的小节中更详细地解释处理步骤。

艾调组件图，图片作者

我从下载公共领域超过 500 首歌曲的 OpenEWLD [2]数据库开始。每首歌都有旋律和相应的和弦。这些歌曲是一种名为 MusicXML 的格式，它是纯文本格式，但是这种格式有很大的开销。因此，我使用了一个名为 xml2abc[3]的开源脚本来将歌曲转换为 abc 格式[4]，这种格式更加精简，因此更有利于训练基于文本的机器学习(ml)系统。

然后，我使用麻省理工学院的一个名为 music21 [5]的库来处理这些歌曲，并将它们转置到 c 大调，使机器更容易理解音乐。格式化的歌曲被保存在一个训练文件中，并上传到 OpenAI 的微调服务。我训练他们的 GPT-3 居里变压器模型，在歌曲标题和乐队名称的提示下生成一首歌曲。

虽然 Curie 模型生成音乐，但我使用它的老大哥 Davinci 来自动生成歌曲标题和乐队名称。我用这两段数据来提示微调后的 Curie 模型生成 5 首候选歌曲。

我用一个叫 music_geometry_eval [6]的软件包来分析这五首歌的音色质量。分析是基于 Dmitri Tymoczko 在《音乐的几何学》一书中描述的音乐理论[7]。然后，我选择与训练集中的歌曲具有统计上最接近的音质的歌曲。最后，我把这些歌曲作为可视的钢琴曲播放出来。

照片由戴恩·托普金在 Unsplash 上拍摄

系统详细信息

下面的部分描述了 AI-Tunes 中使用的组件和过程的细节。请务必在下面的附录中查看更多生成的歌曲。

OpenEWLD 数据集

从 ML 系统中获得良好结果的关键之一是拥有良好的训练数据。在研究音乐生成系统时，我发现由于版权限制，论文作者通常不会发布他们的训练数据集。虽然有许多网站托管用户生成的流行歌曲的 MIDI 文件，但这些歌曲的版权仍归作者/出版商所有。如果结果被用于商业用途，使用受版权保护的材料作为训练数据就处于法律的灰色地带。

我发现了一个叫 OpenEWLD 的数据集，可以免费使用。它是增强型 Wikifonia Leadsheet 数据集(EWLD) [8]的精简版，该数据集以 MusicXML 格式收集了 5000 多首歌曲[9]。请注意，“leadsheet”是一个简化的歌曲乐谱，只有旋律和和弦。OpenEWLD 是 EWLD 中 502 首歌曲的摘录，这些歌曲在公共领域中，并且可以用于训练 ML 系统。

公平声明:我没有检查 OpenEWLD 中所有歌曲的出处，以确保它们确实是公共领域中的。但是快速浏览一下标题/作曲家，会发现一些老调，比如:

  1. 安迪·拉扎夫、费兹·华勒和哈里·布鲁克斯的《不要行为不端》
  2. “太棒了！格斯·卡恩和沃尔特·唐纳森
  3. 斯科特·乔普林的《枫叶抹布》
  4. “哦！斯蒂芬·福斯特的《苏珊娜》
  5. 艾尔·杜宾和哈里·沃伦的《我们发财了》

这是 OpenEWLD 收藏中的一首歌曲的例子。您可以看到歌曲的“钢琴卷帘窗”，这是一个图表，y 轴表示音符的音高值，x 轴表示时间。你可以在下面的 SoundCloud 上播放这首歌。

真正的歌曲——艾尔·杜宾和哈里·沃伦的《我们在金钱中》，来源:OpenEWLD

ABC 格式

正如我上面提到的，OpenEWLD [8]中的歌曲是 MusicXML 格式的，这种格式很好，但是有很多额外的格式化文本。虽然 ML 系统可以学习所有的格式命令并生成这种格式的歌曲，但我发现最好是将音乐符号减少到最少。Chris Walshaw [4]的 ABC 格式是一个很好的匹配。例如，下面是 MusicXML 和 ABC 格式的歌曲“我们有钱”的第一部分。

**

阿尔·杜宾和哈里·沃伦的音乐 XML(左)和 ABC 格式(右)的《我们在金钱中》(T1)，来源:OpenEWLD

你可以看到，当转换成 ABC 格式时，这首歌被大大简化了。XML 格式的标题需要 503 个字符，前两个注释需要 443 个字符。ABC 格式仅使用 85 个字符的标题和 8 个字符的前两个注释来指定相同的信息。

MusicXML 到 ABC 的转换

我使用一个由 Wim Vree [3]开发的名为 xml2abc 的开源脚本将歌曲从 MusicXML 转换为 abc 格式。下面是我用于转换的命令。

*python xml2abc.py were-in-the-money.xml -u -d 4*

这将读取文件“were-in-the-money.xml”，转换它，并将其保存为“were-in-the-money.abc”。-u 选项将“展开”任何重复的小节，而-d 4 选项将默认音符长度设置为四分音符。使用这两个选项通过标准化乐谱来帮助机器学习过程。

这是 ABC 格式的整首歌《我们有钱》。

*X:1
T:We're In The Money
C:Harry Warren
L:1/4
M:2/2
I:linebreak $
K:C
V:1 treble 
"C" z E G3/2 E/ |"Dm7" F"G7" G3 |"C" z E G3/2 E/ |"Dm7" F"G7" G3 
"C" z e"C+" e3/2 c/ | %5 | "F" d c d"Ab7" c |"C" e c"Dm7" c"G7" d
"C" c2 z2 |"C" z E G3/2 E/ |"Dm7" F"G7" G3 | %10
"C" z E G3/2 E/ |"Dm7" F"G7" G3 |$"C" z e"C+" e3/2 c/
"F" d c d"Ab7" c |"C" e c"Dm7" c"G7" d | %15
"C" c2 z2 |"C" c2 z2 |$ z"Cmaj7" e d/c/B/A/ |"Cmaj7" B B z/ c A/
"Cmaj7" B B2 c |"Cmaj7" B4 |$ %21
"Cmaj7" z e d/c/B/A/ |"Cmaj7" B B z/ B B/ |"Bb" _B B"A7" A A
"Ab7" _A A"G7" G z |$ %25 | "C" z E G3/2 E/ |"Dm7" F"G7" G3
"C" z E G3/2 E/ |"Dm7" F"G7" G3 |$"C" z e"C+" e3/2 c/ | %30
"F" d c d"Ab7" c |"C" e c2"G7" d |"C" c3 z | %33*

准备歌曲

我通过执行以下处理步骤准备用作训练数据的歌曲:

  1. 过滤掉不使用 4/4 和 2/2 拍号的歌曲
  2. 将歌曲转到 c 大调
  3. 去掉歌词和其他不必要的数据
  4. 用“$”符号替换换行符

统一拍号和调号使得 ML 系统更容易学习旋律音符和定时。大多数歌曲使用 4/4 或 2/2 时间(502 首中的 381 首)，因此不值得让系统理解其他节拍。而且大部分歌曲都已经是 c 大调的调了(502 首中的 303 首)。我使用 music21 包[5]中的一个函数将歌曲转置到一个统一的音调上。

我去掉了歌词，以帮助系统只关注音符。我把换行符转换成了“$”，以符合 GPT-3 微调系统的一个怪癖。否则，它会将换行符转换为逗号；这将为 ABC 格式的歌曲带来问题，因为逗号已经用于指定不同八度音阶中的音符。

微调 GPT-3

为了微调 OpenAI 的 GPT-3 模型，第一步是编译一个包含 JSON 格式的提示和完成对的文本文件。对于提示，我使用歌曲标题和作曲家的名字。完整版是 ABC 格式的预录歌曲。

下面是两个提示完成对的样子:

*{"**prompt**": "X: 1 $ T: We're In The Money $ C: Harry Warren $ <song>", "**completion**": " `C` z E G3/2 E/ |`Dm7` F`G7` G3 |`C` z E G3/2 E/ |`Dm7` F`G7` G3 |`C` z e`C+` e3/2 c/ | $ `F` d c d`G#7` c |`C` e c`Dm7` c`G7` d |`C` c2 z2 |`C` z E G3/2 E/ |`Dm7` F`G7` G3 | $ `C` z E G3/2 E/ |`Dm7` F`G7` G3 |`C` z e`C+` e3/2 c/ |`F` d c d`G#7` c |`C` e c`Dm7` c`G7` d | $ `C` c2 z2 |`C` c2 z2 | z`Cmaj7` e d/c/B/A/ |`Cmaj7` B B z/ c A/ |`Cmaj7` B B2 c |`Cmaj7` B4 | $ `Cmaj7` z e d/c/B/A/ |`Cmaj7` B B z/ B B/ |`Bb` _B B`A7` A A |`G#7` ^G G`G7` =G z | $ `C` z E G3/2 E/ |`Dm7` F`G7` G3 |`C` z E G3/2 E/ |`Dm7` F`G7` G3 |`C` z e`C+` e3/2 c/ | $ `F` d c d`G#7` c |`C` e c2`G7` d |`C` c3 z | $ <end>"}
{"**prompt**": "X: 1 $ T: They Didn't Believe Me $ C: Jerome Kern $ <song>", "**completion**": " z G A c |`Dm7` d2 d2- |`G7` d e d/>e/c/>d/ |`C` e4- |`Em7b5` e e`A7b9` (3e f g |`Dm7` d2 d2- | $ `G7` d d (3d e f |`C` G2 G2- |`Am7` G G A c |`Dm7` f A B c |`G7` d3/2 B/ c`G7/F` d | $ `Em7` g B c d |`Am` e2 e ^f |`Em` g e/>^f/ g2- |`B7` g ^f =e _e |`Em7``Bb9` e4- | $ `A7` e g`A7b9` f e |`Dm7` d2 d2- |`G7` d d/>e/ (3d/e/d/ c/>d/ |`C6` e2 e2- |`Am7` e c d e | $ `Dm` f2 f2 |`G7` f f e _e |`C6``Bb9` e4- |`A7` e e e/f/ g |`Dm` d2 d2- |`G7` d d d/e/ f | $ `C` G2`Dm7` G2- |`Em7` G G`A7` ^G A |`Dm7` f A B c |`G7` d2`G7b9` e2 |`C` c4- | c z z2 | $ <end>"}*

OpenAI 提供了一个检查训练文件有效性的实用程序。下面是我用来检查文件的命令。

*openai tools fine_tunes.prepare_data -f songs.jsonl*

这是结果。

*Analyzing...

- Your file contains 374 prompt-completion pairs
- More than a third of your `completion` column/key is uppercase. 
- All prompts end with suffix ` $ <song>`
- All prompts start with prefix `X: 1 $ T: `
- All completions end with suffix ` | $ <end>`

Based on the analysis we will perform the following actions:
- [Recommended] Lowercase all your data in column/key `completion` [Y/n]: n*

它只标记了一个问题，但这实际上并不是问题。prepare_data 脚本注意到补全中的许多文本都是大写的。这是因为和弦的根音和许多音符都是用大写字母表示的。这个警告可能是针对对话文本，而不是音乐，所以我忽略了这个警告。

一旦训练文件处于良好状态，就很容易微调 GPT-3。以下是命令:

*openai api fine_tunes.create -t songs.jsonl -m curie --n_epochs 5*

我选择使用现有的最大的 GPT-3 模型进行训练，居里。虽然没有达芬奇大，但是看起来效果不错。我还将训练历元的数量设置为 5，这表明需要在数据集中运行多少次来进行训练。

这是训练的结果。

*Created fine-tune: ft-Vk1UCsXpd65sXXayafTGAY0m
Streaming events until fine-tuning is complete...(Ctrl-C will interrupt the stream, but not cancel the fine-tune)
[2021-08-29 12:10:50] Fine-tune enqueued. Queue number: 0
[2021-08-29 12:10:53] Fine-tune started
[2021-08-29 12:12:55] Completed epoch 1/5
[2021-08-29 12:13:41] Completed epoch 2/5
[2021-08-29 12:14:27] Completed epoch 3/5
[2021-08-29 12:15:13] Completed epoch 4/5
[2021-08-29 12:15:59] Completed epoch 5/5
[2021-08-29 12:17:09] Fine-tune succeededJob complete! Status: succeeded 🎉*

如您所见，运行培训只需要大约六分钟。OpenAI 的团队在训练结束时向我展示了一个庆祝表情符号，获得了额外的积分！

在我们检验这个模型创作歌曲的能力之前，我将向你展示我如何使用 GPT-3 达芬奇创建新的歌曲名称和乐队名称作为提示。

生成新的歌曲名称和乐队名称

正如您在上面的训练数据示例中看到的，每一行都有一个提示，其中包含歌曲标题和作曲家姓名，后跟 ABC 格式的歌曲。为了生成新歌，我用新歌和乐队名创建了一个新的提示。任何文本都可以，但我认为看到系统在提示新信息时(如歌名和假乐队名)是否可以创作歌曲很有趣。下面是一个提示示例。

*"prompt": "X: 1 $ T: Expensive to Maintain $ C: Shaky Pies $ <song>"*

为了做出很多这样的提示，我使用了 GPT-3 达芬奇系统。不需要微调。给定这样的提示，达芬奇模型可以很好地工作。请注意，我在提示中填写了虚假的乐队名称和歌曲。

*Create a new song title a new band name. Be creative!Band name: The Execs
Song title: Company Meeting
###Band name: The One Chords
Song title: Moving Down to Burlington
###*

这是 GPT 3 号达芬奇的一些样本结果。

*Band name: The Wizards
Song title: I’ll Get There When I Get There
###Band name: The Undergrads
Song title: I'm Just a Kid
###Band name: The Fortunes
Song title: What Do You Want from Me?
###*

好像是一些好玩的歌！顺便说一下，这些生成的歌名和/或乐队名可能存在于现实世界中，但如果是这样，也没关系。我只是用这些来提示写歌模式。

创作新歌

现在我们有了一些提示，让我们看看模型能做什么。我生成了第一首歌的五个版本，并选择了最好的一个。

生成歌曲——奇才的《我到了就到了》，AI-Tunes 的音乐

好的，旋律相当简单，听起来相当不错。请注意这个有趣的结构，它似乎是 ABABCB。你可以在下面的附录中看到和听到更多生成的歌曲。

评价歌曲调性

最后一次测试，我以评论家的身份参与其中。我听了《到了就到了》的五个生成版本，选择了最好的一个。请注意，该批次中有一些旧车。他们中的一些人开始还不错，但后来开始演奏一些奇怪的音符。其他人只是一遍又一遍地重复一个短语，没有太多变化。

鉴于该系统可以制作出这些歌曲的许多版本，我研究了使用统计数据来帮助淘汰旧车。我发现在测量音乐音质的主题上已经做了很多研究。

我上面提到的 Dmitri Tymoczko 的书有完整的标题，“音乐的几何学:扩展的共同实践中的和声与对位”[7]。在书中，Tymoczko 讨论了音乐调性的五个特征。

[这]五个特征存在于广泛的[音乐]流派中，西方的和非西方的，过去的和现在的，它们共同促成了一种音调感:

1.合音旋律动作。旋律倾向于从一个音符到另一个音符移动一小段距离。

2.声协和。和谐的和声比不和谐的和声更受青睐，而且更倾向于用在音乐的稳定点上。

3.调和一致。一段音乐中的和声，不管它们是什么，在结构上往往是相似的。

4.有限宏观和谐。我用“宏观和声”这个术语来指代在中等音乐时间跨度内听到的所有音符。调性音乐倾向于使用相对较小的宏观和声，通常包含五到八个音符。

5.居中。在适度的音乐时间跨度内，一个音符听起来比其他音符更突出，出现更频繁，并作为音乐运动的目标。

——德米特里·季莫申科《音乐的几何学》

我在 GitHub 上找到了一个名为 music-geometry-eval [6]的开源项目，它有 Python 代码来评估 Tymoczko 的三个音调特征，联合旋律运动，有限宏观和声和中心性。

我通过代码运行了我的训练数据中的所有 374 首歌曲，以找到这三个指标的平均值和标准偏差。结果如下:

***Conjunct Melodic Motion** (CMM) : **2.2715** ± 0.4831
**Limited Macroharmony **   (LM)  : **2.0305** ± 0.5386
**Centricity **             (CENT): **0.3042** ± 0.0891*

这里是五个生成版本的“我到了那里就到了”的统计数据。我还计算了五首歌曲中每一首的平均(NDM)值的归一化距离，将每首生成的歌曲的指标与训练数据集中歌曲的平均指标进行比较。

***Generating Song Version 0**
  CMM : 2.3385
  LM  : 3.5488
  CENT: 0.5213
  NDM : 8.1677**Generating Song Version 1**
  CMM : 3.828
  LM  : 2.3396
  CENT: 0.2677
  NDM : 10.7161**Generating Song Version 2**
  CMM : 3.124
  LM  : 1.5614
  CENT: 0.2244
  NDM : **3.8996**  **<-- Closest tonality to the training data****Generating Song Version 3**
  CMM : 2.0206
  LM  : 3.4195
  CENT: 0.4869
  NDM : 7.0639**Generating Song Version 4**
  CMM : 3.2644
  LM  : 1.4132
  CENT: 0.2436
  NDM : 5.5533*

果不其然，我选择的那首“最好的”歌曲，第二版，恰好也是 NDM 最佳配乐。请注意，这种情况经常发生，但并不总是如此。在进行了十几次这样的实验后，我发现有时候 NDM 评分第二或第三接近的歌曲听起来是最好的。

讨论

AI-Tunes 系统工作得相当好。并不是每首曲子都很好，但它经常会产生有趣的音乐，有可识别的主题和变奏。

如果你了解音乐创作，你可能会注意到有些作品需要一点“清理”。例如，有时系统由于在各处插入额外的八分音符而不能严格遵守 4/4 拍。(提示:听生成的音乐时，试着用脚跟着节拍打拍子。)

好消息是，你可以下载生成的音乐作为 MIDI 文件，并很容易地在乐谱软件中修改它们。例如，这是一个示例歌曲的清理版本。

清理示例，图片作者

至于作文的总体质量，肯定还有改进的余地。例如，如果 OpenAI 为他们更大的 Davinci transformer 提供微调，结果音乐可能会改善。

此外，在更大的音乐数据集上训练系统肯定会有所帮助。它可能会更新音乐的风格，使之成为这个千年的东西😄。

实现 Tymoczko 的其他两个音调特征，声学共鸣和谐波一致性，将有助于评估生成的结果。

后续步骤

将 AI-Tunes 模型扩展到包括像音乐短语完成和和弦条件生成这样的功能是相当容易的。

对于短语完成，训练集将需要包含歌曲部分，在提示中包含来自原始歌曲的一个或多个小节，响应将包含从歌曲中的该点拾取的一个或多个小节。当运行系统生成新的部分时，会传入一组前面的和弦和旋律，系统会完成音乐短语。

对于和弦调节，训练提示将只包含 ABC 格式的原始歌曲的和弦，而预期的响应将是原始旋律。当生成音乐时，只传入和弦，系统会生成与和弦匹配的旋律。

源代码和 Colab

这个项目的所有源代码都可以在 GitHub 上获得。你可以使用这个 Google Colab 来试验代码。这个 Colab 只有在你有 OpenAI 账户的情况下才有效。如果你没有账户，你可以在这里注册。我在 CC BY-SA 许可下发布了源代码。

归属分享相似

感谢

我要感谢詹尼弗·林和奥利弗·斯特里普尔对这个项目的帮助。我要感谢麻省理工学院图书馆的乔治娜·刘易斯帮我找到了一本《音乐的几何学》

参考

[1] OpenAI， GPT 微调 API (2021)

[2]弗·西蒙内塔，公开赛 (2017)

[3] W. Vree， xml2abc (2012)

[4] C. Walshaw， ABC 符号 (1997)

[5]麻省理工学院，音乐 21 (2010)

[6] S. G .巴伦西亚，音乐-几何-评估 (2017)

[7] D. Tymoczko，音乐的几何学:扩展的普遍实践中的和声与对位 (2010)，牛津音乐理论研究

[8] F. Simonetta，增强的 Wikifonia 铅片数据集，(2018)

[9] M. Good， MusicMXL (2004 年)

附录

在这里你可以找到更多由 AI-Tunes 生成的歌曲的例子。

菜鸟的“普通美分”

生成歌曲——菜鸟《平凡的美分》，AI-Tunes 配乐

大学生的“我只是个孩子”

自创歌曲——大学生的《我只是个孩子》，AI-Tunes 的音乐

“你想从我这里得到什么？”凭运气

生成歌曲——《你想从我这里得到什么》，AI-Tunes 音乐

老年人的“老人社会”

生成曲——前辈们的《老乡亲社》，艾曲

老鼠帮的《让我们在一起》

生成歌曲——鼠帮的《我们聚一聚》，AI-Tunes 的音乐

为了无限制地访问 Medium 上的所有文章，成为的会员，每月支付 5 美元。非会员每月只能看三个锁定的故事。

人工智能与大数据

原文：https://towardsdatascience.com/ai-vs-big-data-9acfc7b2d37d?source=collection_archive---------31-----------------------

什么是什么，术语和预测

蒂莫·瓦格纳在 Unsplash 上拍摄的照片

人工智能和大数据通常被视为矛盾的构造，而不是可以携手合作的领域。但事实真的是这样吗？下面的文章涉及术语、预测，并试图回答像人工智能在可预见的未来是否真的取代大数据这样的问题。

什么是人工智能？

人工智能(简称 AI)关注的是在机器尤其是计算机系统的帮助下模仿人类的思维过程。AI 是如何工作的？一般来说，人工智能系统的工作原理是摄取大量带标签的训练数据，分析数据的相关性和模式。然后，产生的模式被用于预测未来的状态。聊天机器人可以被认为是一个利用人工智能的例子，因为它们正在学习更具体地回答问题，从以前的用户那里获得更多的信息。[1]

什么是大数据？

大数据是指来自不同部门和来源的大量数据，这些数据使用专门的解决方案进行存储、处理和分析。 [2]这些不同类型的数据来源于传感器、设备、视频/音频、网络、日志文件、交易应用、网络和社交媒体等。其中大部分都是大规模实时生成的[3]。术语“大数据”已经在科学和实践中出现了好几年。通常，大数据的挑战，特别是 3Vs ，是指数据(量)的持续增长、种类和速度的增加，以及数据变化速度的加快[4]。

大数据和 AI 如何互补？

这两个领域相互依赖。如今，数据的来源变得越来越复杂，而不是传统的数据来源，因为它们正在受到人工智能、移动设备、社交媒体和物联网(IoT)的驱动。[3]因此，人们可以得出结论，人工智能依赖于大数据，因为后者为前者提供了重要的数据集，能够为最终用户的决策提供坚实的基础。这里有一个更好理解的具体例子:公司利用人工智能和大数据在互联网和社交媒体网络中搜索用户评级。因此，通过使用监督学习和自然语言识别等工具，可以快速识别和解决问题，以提高客户的好感度。[5]

实际例子

像 这样的新方法将计算带入数据，或者将机器学习/算法带入数据 就是这两个领域如何相互作用的很好例子。特别是，由于像谷歌、亚马逊和微软这样的大提供商提供数据库和数据仓库等与人工智能服务的链接服务，因此不再需要将数据集成到其他平台或系统中[6]。

使用 Google BigQuery 的 ML—图片由作者提供

像 BigQuery ML 这样的工具使机器学习的使用民主化。数据科学家和分析师可以使用 BigQuery ML 直接在数据平台中构建和运行模型。预测分析有助于商业决策。因此，在这种情况下，数据科学可以直接在大数据技术中执行。

摘要

总之，可以说人工智能依赖于大数据。只有拥有海量的数据，人工智能技术才能模仿人类的思维过程。因此，这两个领域相互依赖。因此，需要 IOT、ML 或 Self-Service-BI 等新技术和方法来应对不断增长的数据量，并为公司管理层的决策奠定坚实的基础。在这种情况下，重要的是要注意，大数据和人工智能不是相互竞争，而是相互依赖和受益。

资料来源和进一步阅读

[1] TechTarget，https://search enterprise AI . TechTarget . com/definition/AI-Artificial-Intelligence(2021)

[2] GablerWirtschaftslexikon，大数据 (2021)

[3] IBM，什么是大数据分析？ (2021)

[4]麦肯锡公司，人工智能下一个数字前沿？2017 年

[5] DATABERG，旅游行业大数据、机器学习和人工智能的 10 个例子 (2019)

【6】Google，什么是 BigQuery ML？ (2020 年)

人工智能将首先冲击基于计算机的工作——而且很难

原文：https://towardsdatascience.com/ai-will-impact-computer-based-jobs-first-and-hard-11af4d47487?source=collection_archive---------16-----------------------

人工智能|社会

OpenAI 的 CEO 做了一个可能改变一切的预测。

尼古拉·塔拉先科在 Unsplash 上的照片

自从巨大的希腊机器人 Talos 行走在克里特岛的海岸上，已经过去了几个世纪。传说中，他是赫菲斯托斯神赐予的礼物，用来保护欧洲人民免受海盗和侵略者的侵害。今天，我们不相信上帝派来的巨型青铜机器人。今天，我们是自动化世界的人。

虽然人工智能诞生于 50 年代，但直到 90 年代我们才开始公开担心它对人类工作的潜在破坏。现代科技早已开始影响几个行业的劳动力(历史上多次发生过)，但 AI 感觉自己是个巨大的威胁。它的横向性质使它成为一个主要工具，能够改变从医药到金融到运输和农业的广泛领域。它甚至能够影响需要独特人类特征的学科，如护理或创造性工作。

在 2017 年 11 月发表的一份报告中，麦肯锡全球研究所声称，人工智能将创造的工作岗位数量与它将需要的数量相似。然而，他们也认识到“转型将非常具有挑战性。”我们将如何管理这个过程仍然是一个需要回答的问题。人工智能的不断进步给政策制定者带来了巨大的困难。最近，随着 GPT 3 号在 2020 年中期进入现场，我们看到了另一个突破。这会改变游戏规则吗？让我们看看什么是最重要的。

人工智能将影响体力和认知工作

过去几十年的官方话语曾将体力劳动作为人工智能和机器人技术进步的主要目标。每个人都预计这些技术将主要吸收低技能劳动力，同时创造高技能岗位，如数据科学家、软件工程师和人工智能专家。

失去工作的人将很难在10-15 年内重新创造和安置新的机会。出租车司机或收银员如何成为数据科学家？他们能在十年内发展强大的数字和技术技能吗？有些人可能会，但对每个人来说都不可行。2020 年，世界经济论坛称不要恐慌，因为最终，人工智能创造的就业机会将超过它摧毁的就业机会。失业的人会准备好接受剩余的工作吗？似乎不太可能。

然而，自从深度学习从阴影中脱颖而出，成为领先的颠覆性技术以来，话语一直在发生变化。人工智能变得更加复杂和强大。它现在可以解决我们 10 年前无法想象的任务。目前的报告估计大约 40-50%的工作会在 15-20 年内被取代。现在比以往任何时候都清楚的是，即使是“创造性、服务性和知识型职业”也不安全。

人工智能可能不会让这些工作消失——我们可能会发现技术和人类工人之间的有益共生关系——但我们不能等到不确定性消失。无论是哪种情况，影响都将是巨大的，各国政府都在与时间赛跑，以创造足够的解决方案:安全网、基本收入、新法规……我们已经进入了这个人工智能与人类互动的时代，这个时代除了前进什么都不会做，会蚕食蓝领和白领的工作。

不可预见的后果——基于计算机的工作将比预期遭受更多、更快的损失

在一个快速变化的人工智能世界里，意想不到的事情可能会发生。去年 OpenAI 的 GPT-3 以惊人的语言能力彻底改变了人工智能。它展示了没有人认为可能的能力(甚至它的创造者也感到惊讶)，很快商业可能性——如编写代码、电子邮件、复制或新闻文章的应用——开始展现。GPT 3 是人工智能如何在一夜之间改变游戏规则的最好例子。

GPT 3 号是一个令人大开眼界的里程碑。它改变了事件的进程，尽管我们还不知道我们将走向何方。至少我们大多数人是这样。OpenAI 的首席执行官 Sam Altman 几天前写了这条推文:

“预测:人工智能将导致在计算机前工作的价格比在物理世界工作的价格下降得快得多。

这与大多数人(包括我)的预期相反，会产生奇怪的效果。"

奥特曼的大胆预测与去年 GPT 3 号创造的氛围完美契合。如果它能写代码，它能结束编码吗？如果它能写诗、小说或歌曲，它能结束写作吗？看来我们必须彻底重新思考我们对未来的看法。

不仅仅是 GPT 三号。其他更强大的系统也能够进行多任务处理——如谷歌的 MUM 或中国的悟道 2.0——最近已经发布。再加上通过云服务对大量计算能力的高度可及性，这些技术可能会降低不久前还觉得安全的工作的价格。现在，一个不会编码或写作的人可以告诉 GPT-3 为他们做这件事，并带来惊人的结果。

我不认为人工智能会杀死编码或取代作家，但这些工作肯定会受到影响。如果 5 年后每个人都可以用人工智能像莎士比亚或海明威一样写作，但有一种新的独特风格，那么优秀作品的价值会发生什么变化？也许，正如一位 Twitter 用户在 Sam Altman 的帖子中指出的，问题在于“人类远没有我们想象的那么有创造力。”

凭借他们的语言专长，GPT-3 公司可以管理各种各样的任务，这些任务属于基于计算机的非常规认知工作类别:公共关系、金融、编程、创意(作家、作者、音乐家……)以及许多其他工作。没有人知道人工智能将如何或在多大程度上影响这些工作，但我们这些在电脑前用大脑进行非重复性工作的人会以这样或那样的方式感受到后果。

最后的想法

这个世界已经在相当大的程度上由人工智能驱动。未来将会看到这种趋势增长，直到人工智能在每个层面都无处不在。我们将生活在与智能机器的不断互动中。我们还没有为那个世界做好准备，所以我们应该努力缓和这个转变。对人工智能的监管，对处于失业危险中的人的替代，人工智能道德的改善，负责任的人工智能，负责任的人工智能…我们最终将面临许多挑战。

正如大多数报告所同意的那样，人类劳动将受到极大影响。现在，随着超级强大的多任务生成、多模态人工智能的出现，情况似乎发生了变化。我们当中那些觉得享受高薪、高技能、基于计算机的非常规认知工作更安全的人，可能终究不是那么安全。我们不能站在看台上看问题。相反，我们必须和其他人类一起确保所有人的未来。

跟我一起旅行到未来 了解更多关于人工智能、哲学和认知科学的内容！

推荐阅读

[## GPT 三号吓到你了？遇见武道 2.0:1.75 万亿参数的怪兽

towardsdatascience.com](/gpt-3-scared-you-meet-wu-dao-2-0-a-monster-of-1-75-trillion-parameters-832cd83db484)

人工智能不会抢走你的工作，它会解放你的工作

原文：https://towardsdatascience.com/ai-will-not-take-your-job-it-will-free-it-99125ad510bf?source=collection_archive---------38-----------------------

附身摄影在 Unsplash 上拍照

意见

为什么你应该看好人工智能革命

我最近一直在阅读大量 clickbait 文章，这些文章声称，由于人工智能革命，每个人都将失去工作。现在看来，即使是创造性或白领工作也不安全。虽然我同意这些工作肯定会改变，但根据我的经验(以及历史教训)，它们会变得更好。你不仅不需要害怕这些变化，你应该把这看作是一个机会，来极大地改善你目前的生活或职业。

人工智能没有创造力

”当哈利穿过庭院走向城堡时，坚韧的雨幕抽打着他的鬼魂。罗恩站在那里，跳着一种疯狂的踢踏舞。他看见哈利，立刻开始吃赫敏的家人。罗恩的罗恩衬衫和罗恩本人一样糟糕。”——节选自人工智能生成的《哈利·波特》第一章(强烈推荐阅读)

我对人工智能了解得越多，就越对人类的大脑感到惊讶。你可以给一个孩子看四幅猫和狗的图片，他们将能够 100%准确地告诉你第五幅图片(即使是一幅抽象画)。你必须向计算机展示超过 10，000 张猫狗图片，才能达到 90%的准确率。你可以忘记给它看任何抽象的东西。当然，你可以在成千上万只抽象的猫身上训练一个模型，但是它真的不再是抽象的了。人工智能很难跳出自己的框框思考。

我的“狗”格斯的照片

我经常读到人工智能将如何很快接管创造性的角色以及传统的工作。毕竟“AI 现在可以写莎士比亚了。”老实说，我想知道这些博客是否读过人工智能生成的诗歌或故事。以我的经验来看，需要大量阅读才能找到一个精选的例子，它不过是一个滑稽的——几乎不连贯的——莎士比亚词汇的组合。

不要误会我的意思，这些进步确实令人印象深刻！他们也展示了高水平的创造力(来自建模者)。即便如此，我相当确定在我生命的最后几年里，我仍然会阅读人类的诗歌。

人工智能为创造力打开了大门

创造力是人类本性的一部分。只能不教。—艾未未”

我职业生涯的大部分时间都集中在人工智能和自动化人工流程上。我还没有杀死一个工作！我很确定我已经创造了一些工作机会。这些人现在在做什么，因为我已经自动化了他们以前花时间做的事情？创意！

根据麦肯锡全球研究所(McKinsey Global Institute)的一项研究，大多数工作中至少有三分之一的时间是可以自动化的。AI 可以把你从这些繁琐的任务中解放出来！以下是一些例子:

  • 当一家企业不必关注订单数量和管理仓库成本时，它就为开发新产品和发展业务腾出了时间。
  • 当分析师不必花费一周的大部分时间手动处理 excel 表格中的数据时，他们现在有时间深入挖掘并发现趋势背后的“为什么”。
  • 当人工智能推荐器可以从数千个可能的客户中筛选出 10 个最适合某个产品的客户时，销售团队现在可以避免噪音，专注于赢得这些客户。

这些工作并没有自动化，而是从繁琐的部分中解放出来。所有这些例子都提高了人类创造力的价值，这反过来又证明了雇佣更多增值的有创造力的人是正确的。

一些工作将会“转移”

“你孩子未来的工作可能还不存在。你的孙子们会对你不得不忍受的可怕工作感到惊讶。”

从前，世界上大部分人口是农民。然后是工业革命。耕作方式变得更有效率，我们发明了像冷藏这样的技术，慢慢地我们改变了，直到很少农民创造出更多的食物。那么为什么我们没有超过 90%的失业率呢？因为随着时间的推移，更好的工作被创造出来(农业工作也得到改善)。由于工资较高，人们被吸引转向这些新的工作。渐渐地，每个人都完成了转变。谢天谢地。我会成为一个悲惨的农民。

计算机和互联网革命也发生了非常相似的过程。一些工作发生了变化，大部分得到了提升，新的领域被开发，每个人的生活都随着变化而变得更好。人工智能革命也会发生同样的事情。这是一个激动人心的时刻。你孩子未来的工作可能还不存在。你的孙辈们会对你不得不忍受的可怕工作感到惊讶。

那么，这种转变会是什么样子呢？举一个具体的例子，我预测在我的有生之年，卡车驾驶行业将转向自动化。虽然我现在进入这个领域会感到紧张，但如果我已经成名，我也不会太担心。这些改变需要数年时间，需要你们的帮助。在帮助中，你可能会获得新的技能，这些技能将会转变为更好的工作(远程管理车队，加油物流等)。如果你更喜欢旅途中的生活，仍然会有一些技术性更强的工作，比如山路、建筑区或新路线。由于“不祥之兆”，年轻的员工将在很大程度上避开这个领域。随着自动化开始发生，有经验的卡车司机可能会看到更高的工资，因为缺乏有经验的人以及完成这项艰巨任务的漫长过程。在我的咨询实践中，我看到了对“过时”技术技能的巨大需求，因为它们仍然有价值，但没有新人在学习它们。也许现在毕竟是进入这个领域的好时机。

我意识到这些转变并不总是像我描述的那样顺利。工业革命确实有它的缺陷。我的观点是，这种转变总是比那些危言耸听的作者所说的要平稳得多。计算机和互联网革命对市场同样具有破坏性。许多公司未能实现转型。但是当一家公司失败时，许多其他公司就诞生了。对于个体工作者来说，生活和工作变得更好了，尽管计算机大大减少了当时的手工操作。

如果你想工作，又愿意学习，总会有一份工作适合你。它可能没有相同的职称或在同一家公司，但它会比你现在做的更好。

不要自满

“一旦新技术碾过你，如果你不是压路机的一部分，你就是道路的一部分。”—斯图尔特·布兰德

虽然我觉得应该乐观地欢迎人工智能，但研究它将如何影响你的行业仍然很重要。那些试图继续用老方法耕作的人可能会很艰难。那些抵制计算机和互联网浪潮的人现在已经破产了。

以下是在过渡期间保护自己的方法:

  • 学习人工智能，即使它只是一个关于它现在如何被应用的基础知识。
  • 思考它能改变你的领域的方法。成为这些变化的工具。
  • 想办法更好地发挥你的创造力。
  • 继续发展你的技能。这在人工智能出现之前是至关重要的，但现在更为重要。记住，大学通常落后前沿 5 年以上，所以考虑用替代资源来补充你的教育。

做这些事情，你会比现在过得更好。掌握它们，享受跳跃到一个完全不同的收入/灵活性等级。你不需要成为数据科学家，你的领域知识将是无价的。这些“革命”不会经常发生，而且是向上流动的大好机会。不要浪费这个机会！

关于我

我是一名资深数据科学家和兼职自由职业者，有超过 10 年的经验。我一直希望与人交流，所以请随意:

  • 在 LinkedIn 上与我联系
  • 在推特上关注我
  • 访问我的网站
  • 看我的其他文章

如有任何问题请在下方随意评论

没有目标的人工智能

原文：https://towardsdatascience.com/ai-without-objectives-48b9c8e7b988?source=collection_archive---------26-----------------------

播客

肯·史丹利谈进化论、开放式学习和 AGI

苹果 | 谷歌 | SPOTIFY | 其他

编者按:TDS 播客由 Jeremie Harris 主持，他是数据科学导师初创公司 SharpestMinds 的联合创始人。每周，Jeremie 都会与该领域前沿的研究人员和商业领袖聊天，以解开围绕数据科学、机器学习和人工智能的最紧迫问题。

今天，大多数机器学习算法都使用相同的范式:设定一个目标，并训练一个代理、神经网络或经典模型来实现该目标。这种方法产生了良好的效果:这些类型的人工智能可以听、说、写、读、画、驾驶等等。

但它们也有内在的局限性:因为它们针对人类感兴趣的目标进行优化，所以它们通常会避开参数空间中有价值但人类不会立即感兴趣的区域，或者我们设置的目标函数。这对像肯·斯坦利这样的研究人员提出了挑战，他的目标是建立广泛超智能的人工智能系统——在广泛的任务中超越人类的智能系统。除其他外，Ken 是一名前初创公司创始人和人工智能研究员，他的职业生涯包括在学术界和 UberAI 实验室工作，最近在 OpenAI 领导开放式学习团队。

在这一集的 TDS 播客中，肯和我一起谈论了他 2015 年的著作《伟大是无法规划的:目标的神话》,开放性对人类意味着什么，智能的未来，甚至人工智能的安全。

以下是我在对话中最喜欢的一些观点:

  • 创造力是人工智能系统尚未掌握的东西，在相当狭窄的背景之外。像 DALL-E 和 GPT-3 这样的图像和文本生成器在某些方面可能看起来很有创意，但它们实际上只是通过在训练集中的数据之间进行插值来生成样本。人类发明家所展示的那种真正的、开放的、无处不在的创造力更具挑战性。
  • 创造力如此难以自动化的原因之一是它不容易被评估。根据定义，创造性产出具有意想不到的特征，目前还不清楚研究人员如何评估一个解决无法提前预测的问题的结果。以托马斯·爱迪生为例:回想起来，他显然极富创造力。他的发明既有趣又有价值。但是，在我们明确知道他将发明什么来评估他的创造力之前，我们可能会使用什么度量标准呢？肯认为，如果我们要破解创造力和一般智力，这是我们需要回答的关键问题之一。
  • 在决定什么是创造力时，存在着固有的主观性。回到托马斯·爱迪生的例子:当爱迪生发明灯泡时，他释放了巨大的经济价值。但是所有的经济价值都是主观的:例如，人们会为灯泡付钱，因为他们主观上觉得有一个比没有好。评估创造性过程的产出所固有的主观性是另一个障碍。
  • 创造力的一个违反直觉的特征是:通常情况下，旨在创造特定的东西，并逐步优化它，是一种低效的创造价值的方式。这是因为你想要的创造性输出的前身可能看起来与那个输出非常不同。例如:阿尔伯特·爱因斯坦发展了广义相对论——一种革命性的引力理论——使用了一种几何学，当它在一个世纪前被数学家们发明时，几乎没有任何可以想象的应用。如果那些数学家在很久以前就一直试图为一个新的引力理论做出贡献，而不是简单地追逐他们觉得有趣的想法，那么他们似乎不太可能花时间去开发那些在爱因斯坦最终需要它们时被证明是如此有用的奇异的新几何。矛盾的是，设定具体的目标实际上在很多情况下会导致进展缓慢。
  • 肯主张设计寻求做有趣事情的人工智能，而不是为特定目标优化。“有趣”是一个主观的术语，但它的一个可以客观衡量的方面是新颖性:为了让一个想法或状态变得有趣，它必须至少与以前的任何东西不同。新颖性可以被很好地衡量:例如，目标状态可以根据某种相似性的度量与过去的状态进行比较，并选择不太相似的状态。
  • Ken 评论了开放式学习策略的风险，如人工智能安全的新颖性搜索。他特别强调，开放式学习的风险之一是其不可预测性，这使得预测事故或偏差行为变得更加困难。如果开放式学习被证明是通往 AGI 的关键路径的一部分，为了安全起见，我们必须找到强有力的方法来限制人工智能的创造力。

你可以点击这里在 Twitter 上关注 Ken。

章节:

  • 0:00 介绍
  • 1:40 什么是智力？
  • 9:30 目标设定
  • 15:30 根据兴趣选择
  • 24:25 问题示例
  • 29:15 环境意味着活动
  • 35:10 设定目标
  • 42:40 验证方面
  • 49:30 开口端和对齐困难
  • 什么是开放式结尾
  • 1:06:00 总结

人工智能不会很快掌握人类语言

原文：https://towardsdatascience.com/ai-wont-master-human-language-anytime-soon-3e7e3561f943?source=collection_archive---------17-----------------------

人工智能|哲学

有一个障碍，除非它彻底改变，否则人工智能无法通过。

阿玛多·洛雷罗在 Unsplash 上的照片

近年来，我们目睹了人工智能语言模型的爆炸式增长。这些系统的最终目标是能够在人类水平上生成、交流和理解语言。

去年，OpenAI 的 GPT-3 以其无与伦比的能力震惊了世界。有人甚至说它是“智能”，能够“理解”，甚至“有情”今年，谷歌在年度 I/O 大会上展示了两种超级强大的语言模型。LaMDA 和 MUM，正如它们的名字一样，可以进行类似人类的对话，并分别处理复杂的搜索查询。

然而，尽管围绕这些人工智能系统产生了所有的大惊小怪，但在他们掌握语言的道路上，有一个明确定义的障碍无法通过。GPT-3、LaMDA、MUM 或他们的继承人都不会成功。

在这篇文章中，我将回顾这些系统能做什么和不能做什么，它们不能突破的障碍是什么，以及为什么唯一的选择是转移占主导地位的人工智能范式。

最先进的语言模型:GPT-3，LaMDA 和 MUM

GPT-3:open ai 研究的巅峰

GPT 模型是实现这一假设的阶梯:有可能创建一个无监督训练的元学习语言模型。凭借其元学习能力，它可以通过向它展示几个上下文相关的例子，来学习从未接受过训练的不同任务。

2020 年 5 月展示的 GPT 3 号就是这种可能性的活生生的证明。自从 OpenAI 发布了测试版 API 供人们玩这个系统以来，我们已经看到了如此疯狂的例子，以至于我想知道 GPT-3 是否真的有知觉。它可以创作诗歌和歌曲，在对话中扮演历史人物，根据描述编写代码或思考未来。

为了深入了解 GPT-3，我建议你阅读这篇长篇文章:GPT-3 是什么，它是如何工作的，疯狂的结果，疯狂的炒作，潜在的危险，以及它受到的批评:

[## GPT-3 —全面概述

towardsdatascience.com](/gpt-3-a-complete-overview-190232eb25fd)

LaMDA:聊天机器人的革命

谷歌展示了一个经过对话训练的人工智能系统如何导航人类对话的细微差别。LaMDA 是新一代聊天机器人的第一个例子，它可以跟上典型的谈话突然转向和变化，这是其他人工智能无法做到的。

在一次能力展示中，它扮演了冥王星和一架纸飞机，并回答了谷歌开发人员的问题。它表现出了理智(它的回答非常有道理)、特异性(它没有给出笼统、平淡的回答)，保持了趣味性，而且它的回答是真实的(这是 GPT 三号做不到的)。

如果你想更多地了解 LaMDA，我推荐你阅读这篇关于它做什么和如何工作的文章。现在还没有太多可用的信息，但我确信当谷歌开放这个系统让我们测试它的极限时，人们会疯狂的。

[## 谷歌的 LaMDA:下一代聊天机器人

towardsdatascience.com](/googles-lamda-the-next-generation-of-chatbots-62294be58426)

妈妈:搜索引擎的大脑

谷歌从一开始就试图让它的搜索引擎更像人类。妈妈是他们努力的结果。该系统可以接受诸如“我爬上了亚当斯山。现在我想去爬富士山。我应该做些什么不同的准备？”找到关键信息，编辑它，给出一个合理而简洁的答案。

它是多语言的(接受了 75 种语言的训练)，它是多任务的(它可以搜索和编译关键信息，回答问题，翻译语言，生成它……)，它是多模态的(它可以结合图像和文本，这是一种超越类似人工智能系统的能力)。

我在下面写了一篇关于 MUM 的能力以及它如何对 SEO 构成威胁的文章。同样，谷歌还没有透露太多关于这个系统的信息，但是当它在他们的搜索引擎中实现时，我们会看到它的威力。

[## 谷歌妈妈会扼杀 SEO 吗？

towardsdatascience.com](/will-googles-mum-kill-seo-d283927f0fde)

语言模型缺乏理解

这些超级强大的人工智能已经达到了一定程度的人类语言能力。他们精通语法和语义。他们已经掌握了语言的形式和结构。如果你和他们说话，很多时候你都分不清他们是人工智能还是人类。不可否认，他们擅长自己的工作。然而，与一些人声称的相反，他们缺乏对他们在人类意义上所说的话的理解。

理解来自于把形式和意义联系起来。如果我说:“我今天早上吃了一个苹果”，你很清楚那是什么意思。你知道，吃是我们饥饿时的一个动作，也是我们生存的必要条件。你知道苹果是一种水果，尝起来很甜，如果我向你扔苹果，会很疼。你知道，我可能在吃早餐，也可能喝了点咖啡。

一个 AI 系统从来没有吃过任何东西，从来没有摸过或闻过苹果，不理解早上喝一杯好喝的咖啡的感觉。它可能会说“我今天早上吃了一个苹果”，但它缺乏对这些话的真实体验和主观理解。

然而，即使人工智能不能理解吃苹果的感觉，他们仍然可以精确而敏感地使用这个句子。那不是语言掌握吗？不完全是。我将通过稍微调整一下这个例子来说明为什么，看看这个概念是如何被打破的。

现在让我们想象一下，我说:“今天早上我吃了一个苹果。我去店里，拿了，吃了，就走了。”这是一个非常相似的例子，所以我们可以假设人工智能仍然可以使用这个句子。然而，其中隐藏着只有人类才能理解的东西，因为我们有一个真正的理解:我偷了苹果！这些信息不在单词本身，而是在我们生活的更广阔的背景中；这是实用信息。

不可逾越的障碍:语用学

语用学是语言学的一个分支，研究语境如何影响意义。19 世纪重要的实用主义者乔治·赫伯特·米德认为，交流不仅仅是我们使用的语言；“它涉及到人们交流时做出的非常重要的社会标志。”

这里有一个来自美国演讲-语言-听力协会的例子，我们可以完全理解，但人工智能系统不能:

“你邀请你的朋友过来吃饭。你的孩子看到你的朋友伸手去拿饼干，说:“最好不要拿，否则你会变得更大。”你不能相信你的孩子会如此粗鲁。"

从语义上来说，这个孩子是在说吃饼干会使人发胖。然而，如果我们考虑到语用层面(在这种情况下的社会背景)，孩子实际上是在叫朋友胖，这是一件应该受到谴责的事情。人工智能系统会错过这种交互背后的意义的关键部分。它不能推断这句话的社会意义，因为它不能理解称某人为胖子的含义。

让我们看看美国语言学会的另一个例子:

考虑两个人，帕特和克里斯，他们在第一次约会时就互相认识了。如果克里斯在晚会结束时对帕特说，“我非常喜欢你。”帕特可能会对这种情况感觉良好。但是想象一下，帕特和克里斯已经约会几个星期了，帕特问:“你爱我吗？”现在，如果克里斯说，“我非常喜欢你，”反应可能会非常不同，因为克里斯的声明被视为一个否定的答案！

这两个句子是一样的。然而，更广泛的上下文从根本上改变了这个短语的实际含义。它改变了很多，一个是积极的，另一个是消极的。人工智能看不出这两种情况的区别。

现在，一个生活在计算机内部的人工智能系统如何访问上下文信息呢？关键问题是人工智能被输入单词，而单词不包含语用信息。我们从他们那里推断出来。语用学存在于人们共享的关于世界如何运转的常识中。人们能够表达的比语言所能表达的更多，因为我们生活在一个共享的现实中。但是人工智能不会和我们分享这个事实。这才是我们应该改变的。

人工智能系统如何掌握语言

在过去的十年里，基于神经网络的人工智能占据了主导地位。人们认为更多的数据、更大的网络和更多的训练最终会产生人工智能。深度学习是遵循这一思想的前沿框架，它占据着强大的统治地位，似乎没有失去动力。GPT-3、LaMDA 和 MUM 是最近的例子，但是在这个范例中有无数成功的系统。

然而，这种方法受到了一些重要的批评。哲学家休伯特·德雷福斯是 20 世纪的主要批评家之一，反对当前的人工智能方法，他说大多数人类专业知识都是以隐性知识的形式出现的——经验和直觉知识，不能直接传播或编纂，因此虚拟人工智能无法获得。语言专业知识也不例外，而且正是语用层面经常与隐性知识交织在一起。

Dreyfus 声称脱离实体的机器将永远无法获得智能和理解，因为要获得它们，它们必须走进世界并与之互动。通过体验世界，我们可以发展我们的隐性知识，我们可以掌握隐藏在语言中的语用信息。人工智能的意志需要具体化，并生活在与我们相同的现实中，像我们一样与它互动，以实现语言掌握。

用卑尔根大学教授 Ragnar Fjelland 的话说:“只要计算机不成长，不属于一种文化，不在世界上行动，它们就永远不会获得类似人类的智能。”获得类似人类的语言能力也是如此。但这似乎不会很快发生。

总结

近年来，我们已经看到了人工智能在自然语言处理系统方面的巨大成功，比如 GPT-3。这些语言系统似乎在人类水平上执行语言任务。他们的潜力是无可否认的。他们很强大，而且会变得更加强大。

然而，他们无法真正理解自己所说的话。他们将无法独立于他们拥有的参数数量和他们接受训练的数据量而达到语言精通。

原因是他们无法获取语境信息——语言的语用维度——人类对话发生的语境信息。他们忽略了语言之外的意义。人工智能并不生活在这个世界上。他们不认同我们的现实。这也是为什么它们在可预见的未来不会发展出类似人类的语言能力。

用单词注释和嵌入辅助生物医学文献综述过程

原文：https://towardsdatascience.com/aiding-biomedical-literature-review-process-with-word-annotation-and-embedding-9a2d59f6c0cd?source=collection_archive---------35-----------------------

实践教程

将激动人心的数据科学工具应用于枯燥的文献综述

当你着手任何研究问题时，你首先要做的事情之一就是查阅文献。除非你已经是你所在领域的专家，并且确切知道去哪里找，否则你很可能会被你需要浏览的关于谷歌学术或 PubMed 的大量论文所淹没。因此，你接下来要做的最符合逻辑的事情就是选择最近的评论文章，并抱最大的希望。或者，如果你能快速浏览 5000 篇摘要，提取每篇论文的关键词，排序，并按主题组织它们，会怎么样？

方法

Pubmed 报废

首先，我们需要一个数据库，从中我们将下载我们的摘要。幸运的是， Pubmed API E-utilites 允许访问所有 Entrez 数据库，包括 Pubmed、PMC、基因、核核心和蛋白质[1]。随后，我们可以编写一个pubmed_scrapping函数来指定术语、要下载的文档数量，并根据它们与术语的相关性进行组织。此外，对于每个文档，我们将返回其标题、 MeshHeading 、摘要、出版日期和 PMID。

代码 1。pubmed _ 报废函数

BeCAS 注释

虽然我们可以只使用网状标题来对我们的论文进行分组，但我们可以更进一步，通过扫描摘要和标题来寻找额外的重要关键字，这些关键字过于具体，以至于不能首先包含在网状标题中，例如特定的分子途径或模式生物的名称。这样做将允许我们以后对具有类似主题的论文进行分类，例如，将精神病学研究论文分为精神分裂症和自闭症谱系障碍。

在这里，我们可以使用一个生物医学概念识别服务和可视化工具( BeCAS )，以及它的 API 来注释关键的生物学术语(这里还有一个 web 界面)【2】。本质上，BeCAS tool 就像一个大字典，可以执行句子的部分标记，并识别物种、解剖概念、miRNAs、酶、化学物质、药物、疾病、代谢途径、细胞成分、生物过程和分子功能的概念，这些概念是从多个元源(如 UMLS 和 NCBI 生物系统公司)编译的。

结合上面的pubmed_scrapping函数的输入，我们可以使用 BeCAS API 提取进一步的关键字。

代码 2。BeCAS 注释

BioWordVect 单词嵌入

一旦我们有了所有必要的关键字(来自 MeshHeadings 和 BeCAS API)，我们就可以将它们组合并转换成一个数值来表示每个文档。

在这里，我们可以使用 BioWordVect，一种预训练的单词嵌入，包含超过 270 万个标记，并且已经在大量 PubMed 摘要和 MeshHeadings 上训练过[3]。与 Word2Vec 中对单个单词进行训练不同，作者对子词进行了训练，这在生物医学数据中证明特别有用，因为其中有许多复合词。假设 BioWordVect 中的每个单词都由一个 200 维的向量表示，我们可以将每个关键字翻译成 BioWordVect 的向量，并将每个文档翻译成这些向量的平均值。

结果

为了测试这个概念证明，我查看了 5 个 PubMed 术语:胶质发生、神经元迁移、神经发生、突触发生和髓鞘形成、，随后下载了 1000 个摘要(总共 5000 篇论文)，并提取了它们的网格标题和 BeCAS 注释(图 1)。

图一。每篇论文及其组合注释的示例(图片由作者提供)

正如所料，我们可以看到最常见的术语是与神经发生和神经元迁移相关的细胞过程(图 2)。更有趣的是，如果我们放大那些较少提及的术语，我们可以看到不同的模式生物、精神疾病和途径；表明我们已经成功提取了许多更小的子类别。

图二。最常见的术语(作者图片)

一旦将这些术语转换成向量，我们就可以试着将单个的论文组合在一起。使用 K-means 聚类，我将 5000 篇论文分成 10 个聚类，并查看它们最常用的术语。

图 3。使用 K-means 聚类的 10 组论文中最常见的术语(图片由作者提供)

忽略图 3 中最常见的术语，如大脑、髓鞘形成和神经发生(以及可怕的颜色方案)，您可以看到 10 个集群中的每一个似乎都包含不同于其他集群的术语。例如，如果我们问自己在 5000 篇论文中最常见的疾病是什么，我们会看到精神分裂症在一个集群中，抑郁症在另一个集群中，癌症在第三个集群中，中风在第四个集群中，老年痴呆症在第五个集群中。这是特别令人兴奋的，因为这个简单的结果反映了神经科学的现状，这些疾病是研究的主要领域。

然而，考虑到我们使用了无监督的技术，一些可解释性的问题是可以预料的。然而，随着 PubMed 搜索词的选择和关键字预处理的进一步细化，当然还有改进的空间。

结论

虽然将自然语言处理应用于生物医学数据并不是一个突破，但令人惊讶的是，帮助文献综述过程的工具并不存在或不为人所知。通过这个简单的概念验证，我们可以将现有的 API 与预训练的单词嵌入模型相结合，以帮助解决我们的研究问题。

最后，你可以在下面查看我为这个项目编写的代码:

https://github.com/lehai-ml/lit-review-neuro

参考

[1] Sayers，E. (2010)对电子公用事业的一般介绍。Entrez 计划。Util。帮助

[2]t . nu nes、d . Campos、s . Matos 和 j . l . Oliveira(2013)BeCAS:生物医学概念识别服务和可视化。生物信息学。29, 1915–1916

[3] Zhang，y .，Chen，q .，Yang，z .，Lin，h .，和 Lu，Z. (2019) BioWordVec，利用子词信息和网格改进生物医学词嵌入。Sci。数据。6, 1–9

AIKA:一种事件驱动的神经网络架构

原文：https://towardsdatascience.com/aika-an-event-driven-neural-network-architecture-6a862f1a3ffb?source=collection_archive---------26-----------------------

Siarhei 土坯股票

事件队列是有效处理稀疏输入数据集(如文本)的有效方法

传统上，神经网络体系结构是以分层结构组织的。通常这些层是完全连接的，但是根据应用可能有不同类型的层，例如卷积层、递归层或 softmax 层。为了简化数学，这些通常表示为向量或矩阵。这样做的好处是，这些层可以很容易地馈入专门的硬件芯片，从而大大加快处理速度，并允许训练巨大的网络。这种方法只有一个问题。现实世界中的大多数概念非常罕见，在给定的输入数据集中根本不会出现。这些不需要任何计算能力，哪怕是非常小的一点点。实现这一点的先决条件是区分活跃神经元和不活跃神经元。低于其激活阈值的神经元在进一步处理中可以完全忽略。为了充分利用这一设计决策，需要一种新型的网络架构，它不支持预先确定处理顺序的层。相反，我们需要一个事件队列，它能够根据给定的输入数据集以任意顺序处理数据。对于这种类型的架构，从概念上将激活与其神经元分开是有意义的，这意味着有两个单独的图表——一个图表由神经元和突触组成，代表网络已经获得的知识，另一个图表由激活和链接组成，描述网络能够推断出的关于具体输入数据集的信息。神经元和激活之间存在一对多的关系。例如，可能有一个神经元代表一个单词或一个单词的特定含义，但该神经元可能有多次激活，每次激活都代表该单词在输入数据集中的一次出现。在激活网络中，每个激活都基于输入数据集。这种接地可以直接发生在输入激活上，也可以通过代表子模式的激活间接发生。这意味着激活之间的链接有两个目的。一方面，它们用于合计突触权重，另一方面，它们将身份传播到更高级别的激活。

饭桶:【https://github.com/aika-algorithm/aika】T2

项目页面:https://aika . network/

爱歌(用于知识获取的人工智能)项目提供了这种神经网络架构的实验性实现，其特征在于以下特征:

  • 一种链接过程，确保只有与输出激活的身份一致的链接才被添加到网络中。换句话说，为了将输入链接添加到激活，它需要与用于激活的至少一个其他输入链接基于相同的输入数据。链接由 visitor 类执行，它基本上是一个在激活网络上运行的有限状态机。
  • 不同类型的神经元在网络中扮演不同的角色。模式神经元是连接神经元，如果存在足够的输入特征来推断给定模式的存在，则该连接神经元被激活。如果某个输入特征作为整体模式的一部分出现，模式部分神经元也会被激活，这些神经元也表现为联合行为。他们的任务之一是确保输入要素以正确的相互关系出现。模式神经元和模式部分神经元在正反馈回路中相互连接。由模式神经元和与其相关联的模式部分神经元组形成的模式可以堆叠在彼此之上。
  • 抑制性神经元是另一种类型的神经元。这些本质上是分离的，并以各种模式连接到模式部分神经元。它们的输出突触与模式部分神经元形成负反馈环路，使得不同模式的模式部分神经元能够相互抑制。然而，负权重突触是特殊的，因为它们需要在激活网络中引入互斥的分支。这些分支相互隔离，并代表输入数据集各部分的某种解释。例如，这些分支可以与句子或图像的解析结构的某种解释相关联。这些分支在人类感知中变得可识别的一个很好的例子是，输入数据集提供了几种同样可能的解释，如句子“大米像沙子一样飞”或隐藏的面部图片。
  • 为了实例化这些不同类型的神经元和突触，使用了包含所有蓝图的模板网络。
  • 由于这种类型的网络包含环，通常的反向传播算法在这里不太适用。此外，依赖应用于网络输出的手工标签可能非常容易出错，并且可能在我们的训练信号和我们想要调整的权重之间产生很大的距离。这就是经典神经网络需要大量训练样本的原因。因此，我们希望根据输入数据中出现的模式更局部地训练网络，而不依赖于监督训练标签。这就是香农熵派上用场的地方。以一个单词为例，它的输入特征是它的单个字母。在这个例子中，我们可以通过计算香农熵来测量每个字母的信息量。然后我们可以把单词模式神经元看作是压缩单个字母神经元给出的信息的一种方式。单词模式神经元需要更少的信息来传达与单个字母总和相同的信息。这种压缩或信息增益可以使用互信息来形式化，然后可以用于导出我们的训练算法的目标函数。

可视化调试器

为了简化 AIKA 项目的调试过程，我们添加了一个图形化的调试工具。它显示了激活网络的图形或实际神经网络的摘录。完整的神经网络通常太大而无法显示。调试器逐步处理事件队列中的每个条目，并在显示的图形中可视化激活网络中的每个变化。它还显示了所有相关对象的属性，包括激活、神经元、链接和突触。此外，它允许我们深入了解链接过程，并跟踪访问者在网络中的行程。

饭桶:【https://github.com/aika-algorithm/aika-visualization】T2

结论

AIKA 项目代表了从经典的基于层的神经网络架构向事件驱动架构迈出的重要一步，一方面，事件驱动架构更紧密地重新采样了生物神经网络的尖峰性质，但也为符号人工智能领域的概念的更无缝集成打开了大门。

使用 OpenCV 和 Python 的空中钢琴

原文：https://towardsdatascience.com/air-piano-using-opencv-and-python-298cb22097d9?source=collection_archive---------10-----------------------

只要在空中动动手指就能弹钢琴！

摘自 Unsplash

我制作“空气钢琴”的灵感

最近我拜访了我的表妹，她已经试着学习钢琴很长时间了。然而，由于疫情，她的老师不能回家，他们通过变焦会议练习。就在那时，我想到了做一架虚拟钢琴的主意，她的老师和她都可以用它来学习音乐。当我思考这个问题时，我在思考为什么不超越键盘呢？让我们试着凭空创造音乐？让我们的创造性思维流动起来，做出这样一种互动，让一个人只需在空中移动双手就能弹奏钢琴？！就在那时，我决定做一架 “空中钢琴”。

项目的技术说明:

空中钢琴是计算机视觉和人机交互融合而成的项目。为了制作 Air Piano，我使用了 Python 语言和一个名为 OpenCV 的专业库。它是一个开源的计算机视觉和机器学习软件库。

帮助我们完成这个项目的另一个重要的库是 PyAutoGUI 库。PyAutoGUI 允许您的 Python 脚本控制鼠标和键盘，以自动化与其他应用程序的交互。PyAutoGUI 有几个特点:移动鼠标在其他应用程序的窗口中点击或键入，截图等。

现在让我们了解一下项目的流程:

  • 第一步是捕获用户的视频流输入。
  • 在我们逐帧读取输入内容后，我们现在需要将 BGR 色阶转换为 HSV 色阶，这样我们可以更好地处理颜色。

我们为什么要转换到 HSV 色彩空间？简单的答案是，与 RGB 不同，HSV 从色度或颜色信息中分离出亮度或图像强度。在计算机视觉中，出于各种原因，例如对光照变化的鲁棒性或消除阴影，您通常希望从强度中分离颜色分量。

  • 使用我们使用 HSV 标度创建的黑色遮罩来检测手。出于这个目的，我选择戴上一副黑色手套，因为检测肤色相对来说更难，而且会剥夺这个项目的普遍性。
  • 在检测到手之后，我们找到轮廓，即我们的手的边界。然后我们画一个凸包，找出周围的凸多边形。从这个多边形中，我们使用凸度缺陷函数提取指尖。

什么是凸包？凸包，完全外切一个对象的最小 n 边凸多边形。

什么是凸度缺陷？轮廓与其凸包的任何偏差都被称为凸性缺陷。

https://theailearner . com/2020/11/09/凸面-缺陷-opencv/

  • 还应用了一个过滤器，使用点之间的距离(即指尖和关节)仅获取指尖，同时您也可以选择使用手指之间的角度来实现相同的效果。
  • 在开始使用 PyAutoGUI 函数之前，让我们在我们的框架上绘制钢琴键，这将是我们的“Air Paino Keys”。
  • 最后一部分包括 PyAutoGUI 库的使用，该库允许您根据手部运动的坐标(准确地说是指尖)进行键盘操作。现在，当这个程序运行时，它将跟踪帧中指尖的位置，并自动按下键盘上提到的键。为此，我们将打开另一个带有链接的窗口:https://www.onlinepianist.com/virtual-piano。
    这是我们将用指尖控制的虚拟钢琴。

最终结果看起来是这样的:

以上是“空中钢琴”项目的详细技术说明，希望你通过这个学到了很多。访问Githubrepo 并查看完整代码以获得更好的理解。以下是我曾经学习过的资源，它们帮助我成功地建立了这个项目

  1. 指尖检测
  2. 凸包
  3. 凸面缺陷
  4. 手检测

未来方向和使用案例:

以类似的方式开发，一整套乐器可以使用与上述相同的原理进行手势控制，为学习音乐创造一个非常互动的环境。我们可以添加更多的实用程序，并使用最先进的开发技术(如 MediaPipe 库)来增加这个项目的趣味性。

空气生物——值得大肆宣传吗？

原文：https://towardsdatascience.com/airbyte-worth-the-hype-d2f25d0a7ca5?source=collection_archive---------4-----------------------

一个简单的例子，并检查其功能和特点。值得炒作吗？

介绍

Airbyte 目前似乎在炒作列车上。数据世界中的大多数人正在使用或计划使用它，所以我决定从我的角度来评估它。我知道它是一行一行地处理，以某种并行的方式进行，没有或只有很少的转换。这是显而易见的，因为它是一个 EL 工具。对于社区成员或 Airbyte 开发人员创建的源和目标，您可以使用多个连接。你甚至可以在市场询问一些具体的。当然，你也可以参与这个项目，因为它是一个开源项目！

先决条件

在这篇文章中，我不打算介绍基本的设置。如果您希望复制本教程，您应该有:

  1. 本地(或远程，如果你喜欢)气流运行与阿帕奇-气流-供应商-airbyte 安装了 airbyte 运营商(和任何其他库，你会需要)。
  2. Postgres 数据库正在运行(可以与气流后端数据库相同)
  3. 空气生物旋转起来。我用过公文。
  4. 拥有 AWS 帐户，创建了一些 s3 存储桶，并拥有 AWS 访问密钥 id 和密钥

数据流

让我们以著名的 NYC 出租车数据集为例，称之为我们的提供商数据，我们可以通过下载来访问它。为了在我们的数据流中实现容错和幂等，我们应该将它存储在 S3 桶中，并且无论我们使用什么应用程序，它都是可用的。从那里，我们将利用 Airbyte 并加载到我们的 Postgres DB 暂存模式。

长话短说，你可以查看下图中的数据流:

数据流向中转区。作者图片

下载并加载到 S3

对于这些操作，我将利用两个操作符—一个下载数据，另一个将数据上传到 s3。请记住，我的 Airflow 实例正在 docker 容器中本地运行。我不想在我现有的设置上添加任何东西，使它成为一个沉重的庞然大物，只有我添加到它的最少的东西。通过将我的任务分解成原子动作，我可以保证每一步都能正常工作，当我再次运行它时，它会返回相同的结果。

为了下载数据，我将使用一个简单的 Bash 操作符来执行 curl 命令:

download = BashOperator*(* task_id="download_data",
    bash_command="""curl -o /opt/downloads/{{ macros.ds_format(ds, "%Y-%m-%d", "%Y-%m") }}.csv -L https://s3.amazonaws.com/nyc-tlc/trip+data/yellow_tripdata_{{ macros.ds_format(ds, "%Y-%m-%d", "%Y-%m") }}.csv""",
*)*

因为我在模仿每月的文件创建，所以我在这里使用 ds 宏作为文件名。我认为这是我在我的流中喜欢 ds 胜过 next_ds 的罕见情况之一(如果你熟悉 Airflow，你知道我对这些宏的厌恶来自哪里，如果你不熟悉，我强烈建议阅读 Bas P. Harenslak 和 Julian Rutger de Ruiter 在 Apache Airflow 的数据管道中关于宏和执行日期的内容，天文学家关于基础和 DAG 创作的培训课程，或者查看 Marc Lamberti Youtube 频道。

因此，要装载到 S3，我将采用气流方式，我将使用 S3 钩来完成。使用任务流 API，我创建了这个任务:

@task.python
def upload_file_to_s3*(*s3_conn_id, file_name, **kwargs*)*:
    s3 = S3Hook*(*aws_conn_id=s3_conn_id*)* s3.get_conn*()* s3.load_file*(*filename=file_name,
                 bucket_name="tomasp-dwh-staging",
                 key=file_name.split*(*"/"*)[*-1*])*

空气字节

首先，我喜欢的是 UI。超级干净，容易理解，虽然工具本身非常简单。设置来源，设置目的地。映射流，并添加一个计时器，如果您希望它定期触发。

源页面打开。作者图片

此外，章鱼的形象也值得称赞(不是乌贼，而是章鱼！Slack 频道的人给我指出来了😅奥克塔维亚·斯奎丁顿三世)。对我来说，这是一个很好的方式，以一种简单的、非侵入性的、但是交互的方式来简单地加入你的产品。

所以让我们开始设置。您可以离开并开始分别设置源和目的地，然后在 connections 部分中映射它们。我懒得浏览多个标签页。让我们看看 connections 的 onboarding 是否能马上为我工作。

来自连接屏幕的图像。作者拍摄

再次回到章鱼，仍然超级可爱！让我们回到我来这里要做的事情——就像乌贼说的那样，创建一个新的连接！

新连接介绍页面。作者图片

我们已经可以看到，我们的介绍流程非常简单，只有三个步骤。

  • 创建一个源
  • 创建目的地
  • 创建连接

如果您之前已经创建了源和目标，那么您可以在这里将它们连接起来。否则，如果您正在使用 onboarding flow，您将看到如下内容:

多种来源类型可用。作者图片

所以我喜欢的是，已经有许多来源，最坏的情况下，你可以从这里要求一个新的连接器！

请求新的源/目的地。作者图片

此外，您可以查看他们的市场，并在那里申请一个连接器。它将在 GitHub 上为他们的项目开一期。

发布新连接器的注册。作者图片

但是，单击健康状态会将我带到未找到错误的页面上:(

别担心，只是一个错误的链接。在 slack 中得到一个答案，我们应该在不同的链接中看到内容。

我想我有点跑题了。因此，让我们选择 S3 作为源(因为我们的黄色出租车数据驻留在那里)。我们已经可以看到，我们的设置部分刚刚扩展。所以用你想要的填充数据。我将使用黄色出租车数据的一些配置属性。我选择的数据集名称是 yellow_taxi，我只接受 CSV 文件。在这里，我可以设置多个文件夹来检查助手文本中指定的数据和其他规则，但这与我的用例无关，尽管这是一个很好的简单特性，可以处理文件存放的多个位置。

数据集名称和路径模式。作者图片

我之前提到过，我们需要创建一个 bucket，如果您的 bucket 不是公共的，您必须传递凭证，以便 Airbyte 可以访问它们。

存储桶和 AWS 凭据。作者图片

此外，好的一面是您可以配置块大小。它可以提高你的 EL 流动性能。

块大小参数。作者图片

请记住，Airbyte 在推进到目的地之前会处理内存中的所有信息！如果您的数据库有更好的提示和技巧(例如，Redshift/Postgres copy 命令)，请尝试利用它们(或者在 Airbyte 上打开一个 PR，如果您有一个有助于开源的解决方案！).

如果您已经正确地设置了所有的东西，您应该不会得到任何错误，并且会被抛出“创建一个目标部件”

这部分对我来说更简单。到我的 Postgres 本地实例的简单连接配置:

Postgres 目的地。作者图片

设置也很成功，所以我们终于进入了“设置连接”部分！

在这里，我们可以选择同步的频率:

同步频率。作者图片

当然，这取决于您的用例。在我的例子中，我将使用气流来编排整个事情，所以我将在这里选择手动。

下一部分是名称空间配置。这里我们看到三个选项

  • 镜像源结构
  • 目标连接器设置
  • 自定义格式

你可以在官方 Airbyte 文档中阅读更多关于差异的细节。在我的例子中，我想选择镜像源结构。

如果基于每个连接创建多个表，那么让我们创建 yellow_taxi 作为表前缀。

刷新模式！默认情况下，它将只包含一些系统列。始终仔细检查您的列是否出现在映射部分:

列及其映射。作者图片

现在，让我们检查可用的同步模式。超级高兴增量在那里:

可能的同步模式。作者图片

查看关于 增量追加 (仅处理新的或更改的数据)和 增量重复数据删除+历史 (提供的唯一键上的 SCD 类型 1)的更深入的解释。我的情况很简单，这是一个事实表导入，所以完全刷新并覆盖。

下一步是规范化和转换。我再次提醒你，Airbyte 在内存中运行是为了逐行处理。options 中没有规范化意味着 Airbyte 会将它作为 JSON 和一些元数据一起存储在最终表中！我后面的转换将在表格数据上执行，所以我更喜欢在这里使用规范化选项。

剧透:它使用 dbt 是为了规范你的数据！

另一件事是，我们可以在这个管道中添加一些转换！从它的外观来看，它将在 docker 映像中运行您的转换，然后推送到目的地！

自定义转换选项。可以在加载完成后触发。作者图片

首先想到的是它将如何处理私有存储库，但是查看文档，我已经得到了所有的答案和例子！如果您的数据是定期同步的，并且不使用任何 orchestrator，那么这是非常好的。完成装载后使用 dbt 型号—在一定程度上消除气流。

在我的示例中，我使用气流管理流，因此我可以在一个 DAG 中拥有所有这些内容，并对其进行完全控制。

唯一剩下的东西——当我们移动完数据后，Airflow 可以调用 Airbyte。

回到气流

如果你还没有设置 Airbyte 连接气流，请遵循他们的官方文件。尽管使用 docker 图像，您可能会遇到一些问题。运行 docker ps 获取 Airbyte 服务器 docker 镜像 id，然后运行 docker inspect IMAGE_ID。在连接部分，将 gateway 作为您的主机:

对我来说，联系是这样的:

空气连接。作者图片

我需要做的唯一一件事就是将 Airbyte 部分添加到我的 DAG 中:

airbyte_s3_to_postgres = AirbyteTriggerSyncOperator*(*task_id='sync_airbyte_s3_to_postgres',
                                                    airbyte_conn_id='local_airbyte',
                                                    connection_id='902284d9-c0c3-43a7-a71f-636afd3c1b73',
                                                    timeout=3600,
                                                    wait_seconds=30
                                                    *)*

connection_id 是您打开连接时在 URL 中看到的内容。Wait_seconds 是戳时间；它检查完成的频率。

因此，我们最终流向中转区的气流看起来像这样:

气流 DAG。作者图片

当我们的 Airflow dag 运行时，我们可以转到 Airbyte UI 并检查我们的连接是否正在运行，这将表明一切正常:

正在同步。作者图片

所以我们可以看到它运行得非常好！所以用我的 docker 设置:

Docker 设置。作者图片

2020 年的数据–11 辆黄色出租车数据(由 1508000 行组成)花费了大约 7 分钟来加载。数据大小为 132M，所以我认为对于这些量来说有点慢。我想我需要对 Airbyte 或我的 docker 中的一些参数做一些调整，或者将它从本地 docker 容器移到不同的环境中。

剩下的唯一一件事就是检查我们的数据库和里面创建了什么:

由流创建的表。作者图片

一个包含原始表行信息的 JSON 表:

Postgres 中摄取的原始表。作者图片

然后是 yellow_taxi，它有表格格式的数据。

我的笔记和想法

随着自助服务成为数据世界中的必备工具，我认为它是公司采用的一种优秀且简单的工具。然而，我认为它还不够成熟(并不是所有的连接器都可用，处于早期阶段，他们只是在开发他们的云解决方案以吸引收入，而不仅仅是投资者)。

我漏掉了一些传入操作符的参数。如果数据通过其他流流向 s3 存储桶，我的气流就不会是等幂的。我可能会消耗过多的文件！

所以我尝试了增量加载。免责声明是，我之前从 s3 中丢弃了文件，并立即上传了 11 月和 12 月，并触发了流(增量|附加同步模式)。事情是这样的，我把它们都装上了。因为它们都被修改过，所以被处理了🤦。我很幸运，因为我的笔记本电脑上有 2020–01，所以我很快上传了它，并再次手动触发同步。所以它有文件的最后更新时间戳，并且只处理新的文件。无论如何，有时我们应该有一定的顺序，所以提供特定的文件来同步也是不错的。

总的来说，这很新鲜，但是如果你是一个早期采用者，那就去做吧。我看到它与 dbt 很好地集成在一起(它甚至使用 dbt 在 JSON one 中创建了一个规范化的表):

规范化数据。作者图片

我的结论是:如果你使用 dbt，Airbyte 将为你的整个管道模型添加一个漂亮的触感，即使不使用气流！如果你有气流，它也会很好地适合里面！

Airflow 2.0 部署 Azure Kubernetes 服务

原文：https://towardsdatascience.com/airflow-2-0-deployment-azure-kubernetes-service-35d8b8ba270a?source=collection_archive---------12-----------------------

Airflow 推出了一个具有新功能的新版本(2.0.0 ),因此在将其部署到生产中之前，是时候开始测试了。本文提供了几个脚本，可以帮助有同样想法的人。

Pixabay — EdWhiteImages

我对部署的定义是:

  • Azure 云— Kubernetes 服务
  • 库伯内特遗嘱执行人
  • Azure 存储帐户(远程日志)
  • Azure 注册表到容器图像
  • Postgresql 容器(气流后端)
  • Git-Sync(同步 Dag)

我写这篇文章的目的是帮助那些花费大量时间寻找例子来使用相同或等效的基础设施进行部署的人。气流文档并不是在所有场景中都有足够的帮助。

首先，我选择 Kubernetes executor 是因为我在云中工作，每个人都知道按需付费云系统是如何工作的。那么重要的是节约资源。然后 Kubernetes executor 这是一个很好的执行任务的方法，执行后杀死豆荚。远程日志系统可以将日志保存在存储器中，您可以在 airflow web 服务器 UI 中正常查看它们。最初，我想使用 helm，但我直接在 Kubernetes 中使用，我对所有部署步骤有更多的控制权。

好了，我们去码吧！

为了部署 Postgres，这是我的 YAML 文件。我使用了持久卷，这样我就限制了数据库的大小。你可以在不同的文件中分开，然后在 Kubernetes 中应用(我就是这样做的)，或者你可以自动化。

在下一步中，我创建了两个持久卷(opt/airflow/dags，opt/airflow/logs)。我将跳过这些脚本，因为它们与上面 PostgreSQL 部署中使用的脚本相同。我需要构建自己的映像，因为我正在使用 Kafka 和其他组件，但是您可以使用默认的映像，比如(来自 Apache/air flow:2 . 0 . 0-python 3.8-build)或您喜欢的其他映像。如果你使用你的图片并将它推送到 azure 注册表，你需要应用一个 Kubernetes 的秘密，并将“imagePullSecrets”设置为我下面的脚本。对于我的 git 密码，我创建了一个 Kubernetes configmap，避免了这些环境的硬代码，所有其他的我直接在 YAML 文件中做了代码，以显示如何设置这些环境。服务帐户有权创建、列出和删除窗格，这一点很重要。我之前说过，Kubernetes 执行器在部署后会删除豆荚。
这个脚本差不多就是我的部署脚本了。我更改了一些细节，因为我没有将调度程序与 airflow webserver 一起部署，我的资源限制是不同的，并且我在其他服务帐户中运行，为了便于理解，我做了一些简化。

好了，在应用这个部署之后，您将有两个 pod 在运行。你可以用 8080 端口绑定并访问 airflow 服务器。在我的开发环境中，我直接为 kubectl port-forward 命令这样做。

在最后一个脚本中，你可以看到我在 Azure 中创建了一个存储帐户，并建立了一个连接。我在 airflow > connections 中创建了一个连接，然后用这个连接设置了我的 env air flow _ _ LOGGING _ _ REMOTE _ LOG _ CONN _ ID。

因此，现在您可以使用 KubernetesPodOperator 运行您的任务。这种方法是可配置的，在启动之前可以更改 Kubernetes pod 配置。我喜欢创建自己的 pod_template 并设置这个 env:air flow _ _ KUBERNETES _ _ POD _ TEMPLATE _ FILE。你可以在上面看到我的剧本。但是没有这些模板设置也可以工作。

我希望这些脚本可以帮助人们快速找到 Kubernetes 的气流配置，并通过这种 Kubernetes executer 方法最小化云成本。

气流与完美—数据项目的工作流管理

原文：https://towardsdatascience.com/airflow-vs-prefect-workflow-management-for-data-projects-5d1a0c80f2e3?source=collection_archive---------3-----------------------

介绍

我非常喜欢 Airflow 及其在工作流管理工具上的优势。然而，我最近开始在我的工作流程中使用提督。两者都是使用 python 构建的。在本文中，我将讨论这两者之间的区别。

照片由杰森·登特在 Unsplash 拍摄

为什么选择工作流管理？

工作流是许多生产相关应用程序不可或缺的一部分。它包括 MLOps、自动化、批处理、投资组合跟踪等。在数据世界中，一个系统需要按顺序处理数据并将数据发送给另一个系统/任务。

气流

Airflow 是 apache 孵化的项目，已经存在了相当长的时间。随着时间的推移，气流比最初的用例更加灵活。Airflow 还可以连接从 AWS Lambda 到 GCP 数据流的云服务。在大多数情况下，大到中等规模的组织使用 Airflow 来处理大量的数据，并在其上执行一些数据操作。它也可以在集群模式下运行。AWS 和 GCP 提供了气流的管理实例，以便与其他云服务一起使用。

  1. AWS 管理的气流工作流程
  2. GCP 云作曲

阅读文章下方关于气流的更多信息。它将显示设置和创建

[## 不受重视的工作流程工具——气流

towardsdatascience.com](/under-appreciated-workflow-tool-airflow-a078a3c71a67)

长官

提督，市场新进入者，相比气流。它是一个开源项目；然而，有一个付费的云版本来跟踪你的工作流程。提督仍然落后于气流带来的所有铃声和哨声。然而，它完成了工作，并且有许多集成。

Prefect 还支持云，这意味着您可以在任何服务器上运行执行工作流，并监控/管理它https://cloud . prefect . io

比较

在下面的部分，我们将看到气流和提督的比较

设置

这两个工具都可以使用 pip、docker 等安装。气流增加了引擎盖下的一些不同的包；也可能会有一些冲突。为了让 Airflow 运行，您需要一个调度程序和 web 服务器。AWS 和 GCP 提供基于气流的托管服务。

Prefect 被整齐地组织成不同的附加组件，并与各种其他组件集成。

不同的附加组件— 来源

要起来跑，提督可以快速启动。提督只需要一个代理人来运行流程。

编码工作流

对任何程序员来说，编写工作流代码都是最重要的决定因素。我们经常为了学习而想学习新的语法和新的东西。

气流有一个学习曲线。你需要理解 DAG 和其中不同的操作符。

示例气流 Dag —来源作者

Prefect 就像初级 python 函数一样简单。我们需要用流把它包在下。

完美流示例—源代码作者

开发 Prefect 看起来像是 pythonic 式的编码方式。我们不需要学习很多来创造一个心流。

工作流 UI

气流

Airflow UI 非常适合监控工作流，并且易于启动。该界面作为 web 服务器的一部分创建。

气流用户界面— —源代码作者

作者执行 Dag 源作者

长官

默认情况下，没有提督用户界面。Else prefect 云环境是一个简单的设置。我们需要设置服务器。我们需要创建一个帐户和一个 API 密钥。然后需要在我们运行的系统中配置密钥。

完美用户界面—源代码作者

项目组织所有的流程。我们可以在一个项目中运行多个流程。总的来说，它组织得很好，执行起来没有问题。

版本化工作流

任何基于代码的系统的一个基本特征是能够版本化你的代码。

气流的一个最显著的缺点是使 DAGs 变得清爽。我们不知道当前执行的是哪个版本的工作流，也没有正确的版本控制。

另一方面，适当的版本控制和对流程的每次更新将被标记以纠正版本。

完美中的版本控制—源代码作者

结论

在本文中，我们已经触及了两个工作流工具。在成为 Airflow 的狂热用户之后，我开始喜欢上了 Prefect 和它的易用性。一个最突出的原因是我不需要重构代码来创建工作流。

我已经开始将我的许多工作流程/自动化迁移到 Prefect。然而，我仍然有我在气流沉重的工作流程。

获取代码

请订阅我的 简讯 获取不同文章及其他更新。

如何使用 Airflow 集群策略和任务回调来跟踪元数据

原文：https://towardsdatascience.com/airflows-best-kept-secrets-2a7acf59d13b?source=collection_archive---------32-----------------------

如何使用气流的两个最保守的秘密来监控你的狗

图像通过 Shutterstock 在许可下传输到 Databand。图片由 Honor Chan 编辑。

检测气流任务中的问题所需的时间是一个主要问题。这有一个很大的原因。你没有写每一条狗。很难找到一种可扩展的方式来使你的平台可维护当有数百条管道用逻辑编写时，如果没有适当的文档，你可能无法理解。如果你不了解管道是如何工作的，那么你就无法找到一种方法来跟踪关于重要的数据质量 &管道问题的&警报。这是个大问题。

虽然这听起来像是一个绝望的情况，但它不是——它只是一个具有挑战性的情况。让我们将这一挑战简化为三个移动部分:

  1. 收集所有运算符对象
  2. 收集执行元数据
  3. 基于上述元数据设置警报和监控仪表板

有很多不同的方法可以解决这些问题。您可以使用开源工具和代码构建自己的解决方案，也可以使用托管解决方案来集中管理您的元数据、监控和警报。

但是对于本文，您将学习如何使用 Airflow 的集群策略和任务回调来实现 1 & 2，并且您将有一种方法来监视:

  • 任务的工期
  • 任务状态
  • 您的任务与之交互的数据集的数据质量。

至于第三点，我们将在另一篇文章中解决。

用气流集群策略包装您的运营商

从哪里开始？您的第一个想法可能是创建一些包装操作符对象或装饰符，以添加到团队正在使用的当前操作符中，但是对于一个大型组织来说，将您的解决方案实现到每个操作符会花费大量时间。

幸运的是，airflow 提供了一个解决方案——集群策略允许您通过向 Airflow 设置添加一个policy来在不同的阶段操纵 Dag 和操作符。Airflow 公开了 3 个策略，每个策略都是 airflow 将在不同阶段加载和调用的功能:

  • task_policy–加载时将调用任何Operator。
  • dag_policy–将在任何DAG加载时被调用。
  • task_instance_mutation_hook–将在任务执行之前调用任何TaskInstance。

对于我们的情况，任何策略都可能是实现的很好的候选，因此我们将很快回来。

使用 Airflow 任务回调收集事件元数据

你需要解决的第二个问题是:如何捕捉不同的事件进行报道？

有两条途径可以做到这一点。

第一种选择非常简单；您可以包装任务的execute方法，并添加与原始执行相关的新功能。这里有一个你如何做到这一点的例子:

在上面的例子中，我们使用任务策略来强制用我们的time_task_duraiton记录器包装我们所有的气流任务。task_policy是气流寻找用来包装每个操作符的函数，task_time_duration负责计算任务的持续时间。实现这一点将使跟踪任务持续时间成为可能。

另一个选择是使用 Airflow 任务回调。我说的是 Airflow 在任务实例运行过程中调用不同事件的回调函数。

一个不使用任务回调的解决方案，比如上面的，可能满足你的需求，但是我认为在很多情况下这不是最好的选择。如果您想要构建一个更易维护、更可靠、更可伸缩的数据平台，使用 Airflow 任务回调是理想的解决方案。

为什么？它对用户代码的干扰较小。操纵execute方法(读作:用户代码)会影响用户的逻辑并导致我们意外的行为。根据经验，作为平台工程师，您应该避免这种情况，并尽可能确保用户代码按预期执行。

那么，什么是气流任务回调？以下是所有的回调及其作用:

  • pre_execute -正好在execute方法运行之前运行。
  • post_execute -在execute方法运行后立即运行，并且只有在没有错误的情况下。
  • on_failure_callback -如果执行中出现错误且任务失败，则运行
  • on_success_callback -如果执行过程中没有错误并且任务成功，则运行。
  • on_retry_callback -如果执行中出现错误并且任务设置为重试，则运行。
  • on_kill -如果 execute 方法超时，就在引发超时错误之前或获得 SIGTERM 之后运行。

我们将在接下来的例子中使用其中的一些。

跟踪任务持续时间

你的 DAG 有过比预期时间短的时候吗？可能平时跑两个小时的时候跑了两分钟？这个例子将探索如何解决这个问题。

在这个例子中，我创建了两个函数— pre_duration和post_duration，它们一起记录任务的运行持续时间。使用pre_execute和post_execute回调来捕捉任务的开始和结束。

现在，您可以添加通用函数wrap和add_policy来减少添加多个策略的样板文件。

将这段代码放在$AIRFLOW_HOME/config/airflow_local_settings.py下，这样 Airflow 会找到您的策略并加载它。

运行 DAG 后，日志文件中的输出应如下所示:

跟踪任务状态

当一项任务失败一次，并不一定意味着有大问题。因此，开发运维人员或数据运维人员配置其气流环境以便在发生这种情况时重新运行任务是非常常见的。这样做的问题是:您需要知道该任务是否超过了可接受的重试阈值，以便在需要时可以快速修复问题。

因此，下面是如何使用相同的逻辑来收集任务状态的元数据:

使用您的新工具跟踪气流中的数据运行状况

正如大多数 Airflow 用户可能知道的那样，可能发生的最可怕的事情是，您的 Airflow UI 显示为全绿色，但随后数据并没有以您期望的形式交付。这意味着数据本身正在破裂——而不是管道——而 Airflow 没有一种直接的方法来跟踪这一点。

在数据质量方面有很多盲点。您需要了解从以前的 Dag 中读取卷时的异常情况，数据提供商可以在不通知您的情况下更改他们的 API，从而导致有问题的模式更改，并且您需要验证数据集中的数据健康状况(例如null值的比率太高)。

Airflow 集群策略和回调可以帮助您跟踪类似的数据质量指标。

在下面的例子中，我们假设您想要开始跟踪Operators对他们正在使用的数据(读或写)的影响

以下是您想了解的一些数据信息:

  • 操作类型 —读或写。
  • 操作时间戳 —跟踪我们的数据有多新。
  • 受操作影响的行数和列数

给定您正在寻找的元数据，有许多方法可以做到这一点。为了简单起见，我假设我们的 DAG 遵循这种模式:

  • 返回值是操作符输出文件的路径
  • 我们使用 Xcom 来同步返回值
  • 接受输入值的操作符将 Xcom 传递给名为“path”的参数

以下是 DAG 的样子，可以为您提供一些背景信息:

关于python_callables的细节并不重要，您需要记住的唯一事情是，当函数将数据写入输出文件时，文件路径就是返回值。

现在，让我们来看看这些记录数据帧形状的跟踪函数:

在本例中，check_input和check_output尝试从 csv 加载数据帧，并记录包含列和行计数的shape

并将这些功能添加到我们的策略中:

气流元数据跟踪准备就绪！

综上所述:

  1. 您了解了“气流群集策略”以及我们如何使用它来跟踪系统中的每个Operator。
  2. 从我们的Operators中了解了任务的回调、它们何时执行以及如何使用它们来收集执行数据

现在，由你来实现你自己的跟踪系统。这将是以后的一篇文章，但是我会给你留下一些你可能同时想要收集的数据的想法:

  1. 从SnowflakeOperator、PostgresOperator或任何带有 sqlparse 的 SQL 操作符中提取有关查询的信息。
  2. 关于每一列的统计信息—空值的数量、百分比、直方图等等。使用 pydeequ 或大期望来验证操作员的输出
  3. 跟踪您与****交互的数据的模式，这样您就可以确保知道它何时发生变化。
  4. 收集系统指标—内存、cpu 使用率。尝试 filprofiler 提取内存使用情况。
  5. 运行时跟踪[template_fields](<https://airflow.apache.org/docs/apache-airflow/stable/howto/custom-operator.html#templating>)值

让我们知道您可能感兴趣的其他跟踪功能！

想了解我和我的团队正在构建的数据可观察性平台的更多信息吗？在 Databand.ai 找到我们。

通过 GPS 和 Python 绘制后 Covid 时代的机场旅客行程图

原文：https://towardsdatascience.com/airport-passenger-journey-mapping-post-covid-era-5864a877b47b?source=collection_archive---------18-----------------------

日本成田机场每个过程的 GPS 数据驱动时间测量

JESHOOTS.COM在 Unsplash 上拍照

你好，奥马尔，我的航班将于 17:30 抵达成田机场，你能来接我吗？

奥马尔:当然，乐意之至！我应该什么时候去接你？

巴特兰:等等！有很多新冠肺炎措施，我听说我们需要在抵达后进行测试，这可能需要时间。

奥马尔:没错，但是你知道在机场等待是很有挑战性的，所以我们想估计一下你是否会在 17:30 着陆——你预计什么时候到达行李领取处

巴特兰:网上找不到多少？要是有人测量过那个时间就好了。

新冠肺炎给旅游业带来了许多变化。它还增加了从着陆到行李认领的机场流程中现有流程的复杂性。其中一些变化是:

  • 显示阴性 PCR 证书
  • 给你测体温
  • 做唾液测试，等待结果
  • 填写许多文件和同意书
  • 安装和配置运行状况监控应用程序

如此复杂的情况下，安排上门收件服务或建立任何依赖时间的承诺都是一项挑战。在本文中，我们展示了成田机场从航班降落到行李认领的操作流程和时间的数据驱动可视化分析。

数据

手机数据是了解和衡量不同地方进程时间的最佳方式之一。大多数移动电话收集用户位置数据以向用户提供更好的服务，并且它们通常允许用户访问他们的数据或请求副本。

一旦我们在成田机场着陆，我们就连上了互联网，GPS 定位开始被记录下来。平均每 5 秒收集一个点。通过观察一段时间内的点序列，很容易直观地看到我在什么时间在什么地方，并快速得出总距离或旅行总时间的结论。

成田机场从航班降落到行李提取的移动模式。“作者图片”。使用https://mobmap.locationmind.com/进行可视化

从航班落地到 2021 年 8 月提交报关单出境，我们用了 2 小时 20 分钟 。

向下采样数据点

以降低复杂性并更清楚地看到数据趋势，例如点累积的停止点。让我们把点数减少到每 10 秒一点，而不是每 5 秒一点。这个过程被称为子采样，在时间序列分析中被广泛使用。

将 GPS 数据的采样时间从 5 秒缩减到 10 秒

既然已经对数据进行了缩减采样，我们只想提取停止点。停止点表示一项活动，例如当你排队等待进行唾液测试或当你等待领取行李时。当有人停在同一个位置时，GPS 数据点会在同一点不断积累，很容易发现趋势。

通过速度检测行走点

为了捕捉这些停顿，我们首先需要移除我们行走或跑步的点。为了做到这一点，我们可以通过与前一点的比较来计算每个点的速度。人类的平均行走速度约为每秒 1.4 米。对我来说，我和我 2 岁的女儿一起走，所以速度几乎是每秒 1 米，这是在 velocity_mps 中，指的是每秒 1 米。

根据 GPS 数据计算速度(英里/秒)

接下来，我们要做的就是以等于或大于平均步行速度的速度丢弃数据点。由于我的行走速度本来就很低，所以去掉的都是高速点和飞机降落和移动时的点。然而以正常的行走速度。期待更好的结果。

从移动的 GPS 轨迹中快速滤除点

通过聚类查找停靠点

聚类是一种寻找公共数据点的技术，时空密度聚类或 STDBSCAN 是一种无监督的机器学习算法，用于聚类在空间和时间上接近的点，这些点可以表示潜在的停止。一旦我们在数据点上运行模型并调整参数。我们可以提取代表运动相对静止的停止点的相关点，如下所示。

每一站都代表了一个活动或描述我们最初为什么停下来的东西。在大多数情况下，我们可以将站点映射到附近的商店或餐馆等等。但在这种情况下，它特定于操作，因此我们可以手动标记这些点。毕竟他们只是几个集群。

使用无监督机器学习时空密度聚类检测 GPS 数据中的停靠点

测量每一站花费的时间

每道工序需要多长时间？

如果我们查看每个 GPS 聚类点，我们可以简单地找到每个聚类中时间最小的点和时间最大的点。这将代表站点的开始和结束。两者的区别在于停留的时间。在下表中，每个集群的持续时间代表我们完成每个流程所花费的时间。我们很放松，没有理由匆忙，我们也有孩子。所以单人跑步的时间可能会更短。

通过 STDBSCAN 聚类方法使用 GPS 数据测量停留时间

使用 GPS 数据为每个流程绘制机场旅客旅程图“图片由作者提供”

估计在机场的步行时间

步行时间是不同站点之间的时间，这是表征移动模式的一个重要部分。从一个地方走到另一个地方需要多长时间？根据数据计算，行走时间可以是上一个停靠点和下一个停靠点的第一个点之间的时间。下表列出了在中途停留的时间，包括四处闲逛或来回寻找下一站的时间，以及孩子们从玻璃上看飞机的时间。这是很常见的。尽管当一些点错误地没有被计算为聚类的一部分或者当一个小的停靠点被忽略时，行走时间可能被夸大。比如去洗手间。

机场不同流程间的步行时间估计

从成田机场的 GPS 数据点估计步行时间和停留时间

检测停止的大致位置

找到车站的大概位置有时很重要。当停车发生时，GPS 位置分散在一个点周围。这是因为移动电话中 GPS 的精度通常在 4 米左右。为了找到停止点的近似值，我们可以查看每个 GPS 点簇并估计该簇的质心位置。

基于“作者图像”聚类的 GPS 数据停留位置估计

决赛成绩

Covid Era 后的机场乘客旅程地图—成田机场从航班降落到行李认领的时间“图片由作者提供”

结论

  • 从航班降落到行李领取和通关大约需要 2 小时 30 分钟。
  • 等待唾液测试结果花费了大部分等待时间，随后是机场工作人员的应用程序下载和安装确认。
  • 从飞机上走到唾液测试地点花了大部分时间
  • 行李认领很快，因为现在使用成田机场的人很少

此分析/类似分析的商业机会

设计成功的设施体验始于监控现有情况。测量流程时间和绘制客户旅程可以反映这些流程的效率，以引入数据驱动的改进，并在迭代流程中不断改进运营(改善)。手机数据的无处不在和可用性为了解用户在离线世界的旅程和为这些客户提供的运营效率带来了机遇。引入数据驱动的性能监控产品有多个方面:

数据收集

数据收集带来了挑战，因为需要用户同意才能收集他们的数据。提供一种服务，例如一个专用于该设施的应用程序或免费 wifi，让客户同意提供他们的数据，并承诺保持匿名和安全，这是收集此类数据的一种方式。另一种途径是使用数据聚合公司或大规模运营手机应用的公司，并建立业务合作伙伴关系或数据共享协议。

数据代表性

收集的数据将始终代表一个样本。毕竟，并不是所有人都会安装这款应用或使用免费 wifi。即使与手机应用公司合作，也只能提供一小部分访问者。在计算聚合洞察时，这在数据处理标准中通常是可以接受的。此外，可以计算合适的比例因子，以获得有代表性的见解。

隐私

我很乐意在地图上告诉你我去过的地方。但是，大多数人知道这么多关于他们移动性的信息被提取出来并与他们的身份联系在一起，他们不会高兴的。此外，随着时间的推移，法规变得越来越严格。为了保持良好的隐私标准，需要遵循许多步骤，例如:

匿名化

来自用户的数据不应该追溯到他们的身份。这需要适当的私人信息散列在一个非反向的方式，如 SHA-2 或其他更复杂的散列不能反向工程。

聚合

应该聚合单个级别的计算洞察，以显示聚合产品的总体趋势或商业智能仪表板。例如，说名为 kyle、mark 和 Omar 的用户在这个过程中停留了 15 分钟，这不是一个好策略。相反，我们可以提取在该设施中停留的平均时间为聚合后 15 分钟+- 3 分钟。

访问控制

当确保只有相关人员能够访问这些信息时，最大限度地减少管理员或数据用户的数量是最佳做法。

最终注释

数据驱动的运营增强不再仅仅是概念验证工作。它已经在许多企业和许多应用中大规模引入。以保护数据隐私标准的方式开始数据收集的能力将是一个实体未来采用数据驱动技术的关键。

话虽如此，了解服务时间和客户旅程的应用程序可以应用于许多设施和许多行业。举个例子，

商场

  • 根据需求对购物中心的不同区域进行动态定价
  • 提取工作日、周末和节假日之间行为差异的见解，以便更好地分配安保人员

工厂

  • 了解操作增强的每个过程所花费的时间
  • 通过绘制利用率热图找出未使用的空间或设施
  • 当紧急情况发生时，通过了解每个人的位置来管理人员安全

机场

  • 更好地了解高峰时间以及不同日期和周末服务时间的变化
  • 通过预测不同日期和不同地区的需求，分配更多或更少的人力资源

智能城市和住宅小区

  • 了解住宅的移动模式，以便更好地设计定制服务
  • 了解道路利用密度和 inro 根据重要性对道路进行排序的因素，以分配更好的维护策略

还有更多…

关于我

Mohamed Batran 是一名人工智能专家，也是一名在日本工作的数据货币化专家。在他的职业生涯中，他从事金融、电子商务、物流、电信、运输等行业的数据工作，设计数据利用来增加收入、降低成本或提高客户满意度。

您可以阅读同一篇文章或在此联系我，我将非常高兴收到任何评论、反馈或安排电话讨论合作事宜:

http://mohamedbatran.com/

10 分钟后起飞

原文：https://towardsdatascience.com/airtable-in-10-minutes-d06f7d73c6d1?source=collection_archive---------8-----------------------

实践教程

使用 Airtable 快速上手，了解它何时适合您

为什么要用 Airtable？

Airtable 结合了数据库的强大功能和电子表格的便捷用户界面。然后它还会在上面加一些樱桃。🍒对于许多用例来说，这是一个可靠的选择。

资料来源:pixabay.com

如果您正在组建一个没有数据专家的团队，并且您想要自动化、组织化和洞察力，您可能希望使用 Airtable 作为您的数据中心。和 Tableau 一样，这是一个快速学习的工具——也是你简历的一个很好的补充。🖋

在本文中，您将了解这种流行的关系数据库的基础知识，感觉就像是服用了类固醇的 Google Sheets。无论您是否使用过关系数据库，都会有一些陷阱——您也会看到。然后，我将分享如何充分利用 Airtable 的技巧。最后，我们将讨论一个可能让您组织中的技术人员和非技术人员都满意的解决方案。👍

有趣的是，谷歌正在推出自己的 Airtable 克隆版，谷歌表格——我可能会在未来的文章中探索它，所以请在 Medium 上关注 me 以确保你不会错过它。😀

Airtable 解决的是什么问题？

电子表格是分析数据的好工具，只需点击几下鼠标和几个公式。但是它们不太适合跟踪和显示数据中的关系。

关系数据库是存储大量数据和显示跨表关系的好工具。然而，如果您不了解 SQL，它们并不适合快速分析数据。

SQL(结构化查询语言)是从数据库中提取信息的方式。学基础不难，但是是另一种语言。学习一门新语言需要时间，对许多人来说是一个很大的障碍。不要脸的塞，我写了本记忆深刻的 SQL 这样你就能很快学会基础了。😉

如果你想使用数据库，但想避免使用 SQL，你需要一个程序员来创建一个 API 来显示你的数据——可能通过网站上的一个表单。创建和维护接口的技术工作需要时间、金钱和技术人力。💰

Airtable 是解决这一问题的低成本解决方案。它就像是数据库的内置图形用户界面(GUI)。换句话说，苹果对令人生畏的 DOS 命令行所做的，Airtable 对 SQL 数据库所做的。

接下来让我们深入探讨 Airtable 概念。👍

飞行表概念

要使用 Airtable，您需要知道一些术语，其中许多是直接从 SQL 借用的。

工作区是 Airtable 最高级别的抽象。如果您有多个工作空间，它们可能是您工作的多个组织的工作空间。

基地是数据库。你不能用 SQL 访问它们，但这就是 Airtable 正在做的事情。🚙

表是 SQL 表。如果你没有使用过 SQL，你可以把表格想象成电子表格。

每一行都是一个记录。

Jeff Hale 添加了网格视图和标注的示例表格

列被称为字段。田地很重要，所以我们开始挖吧。

单个字段包含相同类型的数据。可能的数据类型包括通常的文本、整数、小数和日期。Airtable 为其他一些常见的数据类型增添了新的光彩，包括经过专门验证的字段，如电子邮件地址和电话号码。📞复选框是一个布尔值 True-False 列。✅

可以选择字段数据类型的菜单。

另一个字段选项是附件。这实际上只是一个指向存储在 Airtable 服务器上的文件的链接。如果你上传了一张图片，你可以点击缩略图来查看完整的版本，下载它，或者留下评论给其他用户看。

甚至还有条形码字段数据类型。作为库存跟踪系统的一部分，你可以扫描 Airtable 的 Android 或 IOS 应用程序的条形码。两款应用都获得了极好的评价。哦 Airtable 也有一个星型数据类型。⭐️⭐️⭐️⭐️⭐️

我发现 Android 应用程序易于安装和使用基本功能，但主要是在我的电脑上使用 Airtable，因为它有表格。😉

您也可以在公式字段中输入公式。语法类似于 Google Sheets 或者 Microsoft Excel。你可以组合列中的值，用 if 语句控制流程，等等。这里有一个游乐场，你可以在这里玩各种功能。

在添加字段菜单中，您可以创建到另一个表的连接。选择链接到另一条记录，然后在链接表中选择要加入的字段(您的外键是 you speak 数据库)。这就是在两个表之间创建持久连接的方法。😀

通过添加查找字段，您可以选择在下一个屏幕上显示更多的字段，但这不是必须的。稍后，您可以通过添加查找字段来选择显示更多来自连接的字段。

连接的表将链接字段作为一列。然后，您可以将特定记录添加到链接字段中。或者创建一个将被添加到链接字段的新记录。链接字段有点像两个表之间的魔法入口。💫

选择要链接的记录，或创建新记录

通过这些持久链接来连接表需要一些实践——无论您是数据库新手还是 SQL 专家。

Airtable 让你添加漂亮的元数据字段。例如，您可以看到谁以及何时创建和更新了记录。当然你也可以用我最常用的键盘快捷键 CMD + Z 在 Mac 上撤销事情(在 Windows 上是 CTRL + Z )。

凉爽的景色😎

Airtable 的观点是一个卖点。视图是以各种可视格式显示表格数据的方式。

从空中拍摄的漂亮照片！📸

网格视图是普通的表格，就像你从电子表格或数据库查询中得到的一样。您可以操纵网格视图来显示您想要的数据。例如，下面是一些伪 SQL，用于过滤、排序和隐藏列:

SELECT col1, col2
FROM my_table
WHERE col1 > 3
ORDER BY col2 DESC;

要在 Airtable 中创建这个查询，可以使用顶部的菜单按钮。

菜单按钮

创建视图时，可以隐藏除列 1 和列 2 之外的所有字段。或者你可以过滤所有满足某种条件的记录，比如 col1 > 3。您可以使用分组按钮对记录进行分组。最后，您可以通过单击鼠标按列对记录进行排序。👍

按部分分组

如果您了解 SQL，请将 Airtable 网格视图想象成 SQL 视图。

您可以隐藏视图中的字段。这就是为什么您会得到与在 SQL Select 语句中列出列相同的结果。

你查看的是一张桌子的实况。如果有人更新了为您的视图提供信息的表，它会以近乎实时的方式进行更新。

Airtable 有一种很好的方式来聚合字段中的信息。您可以通过在网格视图的底部显示字段的描述性统计信息甚至直方图来汇总列。

这些数据没有太大偏差。

网格视图不是显示数据的唯一方式。只需点击一下，您表格中的数据就可以显示为日历、看板或图库。付费计划也可以看到甘特图视图。这些观点超级俏皮。就好像他们给了你为团队成员添加各种前端应用的权力。🎉

看板视图

“视图”菜单也是您可以制作表单以将数据放入表格的地方。虽然把一个表单想象成一个视图有点奇怪，但这就是你在 Airtable 中找到选项的地方。🤔

Airtable 使用您的表格列和数据类型来自动生成可自定义的表单。

表单生成器视图

快速表单生成真的很好。👌

自动化🏄‍♀️

Airtable 自动化可以设置为每次触发某个触发器时运行。例如，当一个表中的记录被更新时，可以向另一个表中添加新行。每个月，Pro 计划让您运行 50，000 次自动测试。免费计划每月给你 100 英镑。

自定义自动化类似于 Zapier 的 zaps 或其他无代码解决方案。调试时，UX 可能会更清晰一点，错误消息可能会更有帮助一点，但是应用程序完成了工作。

截至 2021 年年中，Airtable 的内置自动化集成包括许多谷歌产品和其他几种流行的服务。我预计应用程序的数量很快会增加。

自动化集成的子集

如果你想要其他的操作，你可以使用你喜欢的集成工具，比如 Zapier， Integromat ，或者 IFTTT 。例如，Zapier 有 24 个 Airtable 和 Slack 的集成。👍

应用程序

Airtable 在其内置应用程序下集合了许多功能。应用程序包括基本的数据可视化、数据透视表、重复数据删除、更高级的 CSV 导入和运行自定义脚本。例如，下面是运行脚本进行查找和替换的代码片段。

查找和替换脚本

这很容易，但如果能看到这个非常普通的操作被移植到 Airtable 的核心功能中，那就太好了。

在网格视图中快速查找记录是可能的，在 Mac 上使用可靠的键盘快捷键 CMD + F (在 Windows 上使用 CTRL + F )。

Airtable Base schema 应用程序非常适合可视化您的表以及表中字段的关系。您可能知道该示意图是企业资源图(ERD)。

ERD 航空公司

设置建议

以下是帮助您成功设置 Airtable 的一些提示。🎉

  • 使用很少的碱基。你不能轻易地在基地之间分享信息。你的工作空间里可能只有一个基地，这很好。刚接触数据库或 Airtable 的人可能会创建一堆库。您不希望这样做，因为您失去了关系数据库的主要功能，即能够轻松地查看关系并保持数据同步。
  • 为每条记录使用唯一的主键。您将使用第一列作为与其他表链接(联接)的主键。如果每条记录的主键不是唯一的，这种情况就会发生。您可能需要经常进行重复数据删除，以确保您的数据有意义。
  • 如果您将相同的数据放入两个表中，那么您应该在其中一个表中使用链接列。这样，您就不必担心人们在一个地方更改了数据，而在另一个地方没有更改，从而导致表不同步。
  • 自由使用视图。一个表可能有许多视图。

随着时间的推移，你应该有很少的基础，很多的表，很多的视图。👍

高级飞行表

如果您想要与您自己的 SQL 数据库自动同步——无论是查询该数据库还是使用像 PowerBI 这样的工具，您都可以使用 Sync Inc 。它旋转出一个可查询的数据库，并与你的 Airtable 数据库保持同步。

您可以使用 Airtable API 并构建自己的集成。 Kaleb Nyquist 有一些关于使用 Python 的请求库从 Airtable 上传和下载数据的精彩讨论和代码，这里和 pyAirtable 使得与 API 的交互更加容易。

您可以向基、表、字段和视图添加元数据说明。只需右击你想要描述的对象。这对团队沟通是有帮助的。

你可以很容易地设置 Airtable，当你被提到时，它会接收电子邮件或短信，因为谁不想要更多的提醒。🙃

如前所述，Airtable 支持使用 Javascript 编写脚本。您可以创建操作脚本或使用脚本块。有什么区别？脚本块是为在 Airtable 中工作的人准备的。当您需要团队成员输入一些信息作为自动化的一部分时，可以使用它。相比之下，自动化脚本在后台自动运行。😎

还有一个可用的 API ，每秒最多 5 个请求。它有一个非常好的自我记录的例子。除了 Javascript Ruby 和。NET 客户端可用。文档中没有链接 Python 客户端，但是 pyAirtable 包可以很好地获取和更新记录。🐍

局限性和成本

那么为什么大家都不用 Airtable 而用 SQL 呢？有三个主要原因:成本、大小限制和没有原始 SQL 访问。

Airtable 有一个免费计划，但许多团队会发现他们需要每个用户 20 美元的 Pro 计划。我上次看到的 Enterprise 的起价是 60 美元一个座位，它提供了更多的功能，包括每个基座最多 100k 条记录。点击查看更多关于价格和功能的信息。

Airtable 不是大数据解决方案。Pro 计划为您提供每基地最多 50，000 条记录，Enterprise 为您提供 100，000 条记录。有几百万行数据？Airtable 不是你的工具。☹️

Airtable 不会让你轻易跨垒。你可以同步整个表格，或者用集成和管道胶带把一些东西拼凑在一起，但是不可能链接单独的记录。如果你正在为一个客户整理一碗满是馅料的意大利面，你可能会发现自己在下载 CSV 文件，并使用 Airtable 应用程序上传它们。🍝

与此相关的是，Airtable 不允许您直接在数据库上执行 SQL 查询。如上所述，与 Sync Inc .一起使用它对于大型团队来说可能是一个双赢的解决方案。没有技能的人可以在 Airtable 中添加数据和自助查询。你那些想做高级事情的数据分析师可以在 Airtable 之外为自己服务。🎉

Airtable 是满足您数据需求的瑞士军刀。资料来源:pixabay.com

我的团队应该使用 Airtable 吗？

如果你的团队和你的数据都不庞大，并且你没有额外的数据和技术人员，这是一个不错的选择。你可以用它来解决很多常见的商业问题，而且不会破产。

Airtable 的入职流程非常快。一个稍微使用过电子表格的相当精通技术的人应该能够在几天内掌握基本知识。Airtable 文档很棒，用户界面非常直观。也就是说，使用更有经验的人确实有助于确保你为成功做好准备。👍

值得注意的是，Airtable 公司并不是昙花一现。🍳这家资金雄厚的初创公司成立于 2013 年，最近估值近 60 亿美元。

正如这个关于 Airtable 公司战略的大讨论所解释的，Airtable 对于一个 1000 人的销售部门来说并不是最全面的解决方案。为此，有 Salesforce 或其他专门的解决方案。但是 Airtable 对于小团队来说是一把很棒的瑞士军刀。👍

包装

在本文中，您已经学习了如何使用 Airtable。现在出去把你的手弄脏。个人客户关系管理是一个很好的第一个项目，可以创造一些有价值的东西，并学习该工具的基础知识。

我希望这个指南对你有所帮助。如果你有，请分享到你最喜欢的社交媒体上。🚀

我教授、咨询和撰写关于、Python 、数据科学和其他技术主题的文章。如果你对此感兴趣，请在这里阅读更多的并订阅我的 Data Awesome 时事通讯，获取有用数据资源的不定期更新。

资料来源:pixabay.com

快乐播音！🛩

注:截图是我自己从 Airtable 的模板基础。

Airtable & Python 使之成为可能 II:使用 Airtable 的 API 将数据从 Python 上传到 Airtable

原文：https://towardsdatascience.com/airtable-python-made-possible-ii-uploading-data-into-airtable-from-python-using-airtables-api-3075009abf98?source=collection_archive---------14-----------------------

作者的图片说明。

如何将 Python 设计的数据存储回 Airtable 用户友好的关系数据库

内容:

— 了解关系数据&记录 id
—匹配字段值到记录 id
—在 Airtable
— 匹配(&上传)多条记录
— 更新 Airtable
— 中的记录从 [pandas](#08b3) 到 Airtable
— 🎉复制粘贴表格功能— ⏮️第一部分:将 Airtable 数据下载到 Python 中

Python 是一种成熟的编程语言，尽管年代久远，但最近经历了某种复兴——最近成为第二种最广泛使用的通用编程语言。这种繁荣可能是由数据科学领域的快速发展推动的，Python 在这一领域占据主导地位，因为 Python 相对容易学习，但对数据工程和数据分析都很有用。

请务必阅读本教程的第一部分，使用 Airtable 的 API 将 Airtable 数据下载到 Python 中。

因为某些经济部门获取丰富数据的门槛相对较低，所以它们采用 Python 驱动的数据科学的速度相对较快。例如，金融部门从根本上讲是关于一个特定的数据点——“价格”——因此毫不奇怪，像花旗集团这样的组织向其新任分析师教授 Python 来管理他们的价格数据。经验科学，无论是应用科学还是学术科学，从根本上讲都是关于数据驱动的观察，因此所有学科的许多科学家都学习 Python 作为他们教育的一部分，以理解他们观察到的所有数据点。当然还有软件开发部门，包括我们每天花费越来越多的时间参与的所有应用程序，如网飞，这些应用程序将我们在其平台上的每次点击、查看或其他交互记录为数据点。猜猜看，网飞在“整个内容生命周期”中使用 Python 来优化他们的产品。

然而，在获取丰富数据方面，并不是每个组织都这么容易。例如，我的专业是非营利和社会变革部门。对于我们这些在“真实世界”(即，而不是在电脑屏幕或股票报价机后面)中工作的人来说，获得关于我们运营的有用数据可能需要一些真正的努力和规划。好消息是，一旦我们获得了这些数据，Python 的能力就变得唾手可得了。换句话说，我相信获取数据的最初障碍并不会使“真实世界”的组织丧失利用 Python 所提供的功能的资格。

进入气动工作台。Airtable 将关系数据库结构与用户友好的图形界面结合在一起，降低了入门门槛(特别是对于那些以低数据素养为特征的“真实世界”组织环境)。理想情况下，我们不仅希望能够在 Airtable 中收集可以在 Python 中使用的数据，还希望能够在 Python 中生成可以在 Airtable 中查看的数据集。拥有这种功能可以实现数据透明和审计，同时也使组织中的非程序员能够自己分析数据。

在之前的教程中，我一步一步地讲解了如何使用 Airtable 基础的 API 将 Airtable 数据下载到 Python 中。在这里，我带来了完整的教程:如何使用相同的技术和requests库将 Python 数据上传到 Airtable 的分步指南。然而，要充分利用 Airtable 的关系数据结构，需要一些仔细的预处理。本教程将涵盖这两个方面:首先是预处理步骤，然后是实际的上传步骤——上传步骤是在 Airtable 中创建新记录还是更新旧记录。

🎉特别奖励:如果你没有时间看完整的教程，请点击这里访问我的防呆的 Airtable 上传功能，我将其推广用于多个项目。您可以按原样运行它，它将指导您查找任何缺失的信息(例如，从哪里获取 API 密钥)并突出显示可能的错误。欢迎你免费复制、粘贴和修改这段代码，但是如果你想分享你的感激之情，你可以点击这里给我买杯咖啡。

了解关系数据和记录 id

与 Google Sheets 或 Microsoft Excel 相比，Airtable 的“魔力”在于关系数据的集成。除了更加规范的数据管理，Airtable 的关系数据结构意味着一个表中的数据可以在另一个表中访问，以便于分析。这是通过“链接到另一个记录”字段类型完成的。

例如，如下图所示，在“People”表中有四个条目在 Rogers Park 工作。这些人的名字是布鲁斯·巴克、杰拉德·格里尔、卢拉·洛扎诺和马尔孔·麦金托什，他们分别在 9、3、4 和 8 班工作。在“位置”表中，这些人汇总在一行中，总共有 24 个班次。

图 1:“链接到另一个字段记录”字段类型如何创建关系数据结构。图片作者。

在图形 web 界面中，关系数据由浅蓝色方框表示，带有与“主字段”相对应的可读文本。当我们通过 API 而不是图形 web 界面访问 Airtable 数据时，这种关系数据看起来非常不同，可能有点吓人。

请考虑“人员”表中的观察结果:

{'id': 'recrN5WVNHl1pGxET',
 'fields': {'Name': 'Bruce Buck',
             'Shifts': 9,
             'Location': ['rec887G00dQIujFel'],
 'createdTime': '2021-02-17T22:59:38.000Z'}

并且，从“位置”表中:

{'id': 'rec887G00dQIujFel',
 'fields': {'Name': 'Rogers Park',
            'People': ['recrN5WVNHl1pGxET',
                       'recMQieZAnYIu860r',
                       'recXyTN7Mo9LNtxhe',
                       'recqYx6e3BrvxFv2s'],
            'Total Shifts': 24,
 'createdTime': '2021-02-17T22:59:56.000Z'}

如果仔细观察，您会发现直观表示为“Bruce Buck”的数据的id为recrN5WVNHl1pGxET，而直观表示为“Rogers Park”的数据的id为rec887G00dQIujFel。通过像这样使用记录 id 来引用关系数据，Airtable 可以灵活地处理可能出现的复杂性(例如:如果有两个不同的 Bruce Bucks 呢？如果用户改变了定位的方式，不再用名字，而是用街道地址，那该怎么办？).

当通过 API 将数据从 Python 上传到 Airtable 时，这种关系数据结构就有了含义。例如，假设我们有一个编码的 webscraper 在一个关于 Rogers Park 的网站上寻找 Bruce Buck。webscraper 不是寻找与"recrN5WVNHl1pGxET"匹配的字符串，而是寻找与"Bruce Buck"匹配的字符串。但是如果我们上传"Bruce Buck"到一个关系数据字段，而不是一个记录 id 数组，Airtable 的 API 将为列 错误返回一个 无效值。

幸运的是，这是一个简单的问题，有一个显而易见的解决方案，(除了几个例外)将可靠地工作，正如我们现在将看到的。

将字段值与记录 id 匹配

在 Python 中，字典是基本的“映射”类型，用于将一个值从另一个值或“键”转换。出于我们的目的，我们需要创建一个记录 id 和字段值的字典，如下所示:

图 2:记录 id 和字段值的字典。图片作者。

使用 Airtable 记录的列表，比如从本教程的第一部分(“下载”)生成的记录，作为起点，只需要一些简单的 Python 代码就可以创建这个字典。

1 | record_dict = {}
2 | match_field = "Name"3 | for record in airtable_records:
4 |     if match_field in record['fields']:
5 |         record_value = record['fields'][match_field]
6 |         record_dict.update({record_value : record['id']})

第(1)行创建一个空字典。第(2)行定义了 Airtable 列，我们将记录 id 与该列的值进行匹配。第(3)行开始对每个 Airtable 记录进行迭代，为了防止错误，第(4)行检查我们从中提取数据的字段中是否存在值。第(5)和(6)行获取这个值，将它与记录 id 匹配，并相应地更新字典。

⚠️ 注意，在这个解决方案中，如果有重复的值(例如，两个“Bruce Buck ”),就会产生冲突。这可以用 in air table(“Bruce Buck 1”和“Bruck Buck 2”)或 Python(用附加代码)解决。这个问题的最佳解决方案将依赖于上下文。

创建了这个字典后，我们可以开始映射过程，如下图所示:

图 3:使用 Python 字典从概念上匹配惟一字段值和 Airtable 记录 id。图片作者。

有许多方法可以达到这个结果。对于单个值，record_dict["Dawn Douglas"]或record_dict.get("Dawn Douglas")都可以；对于熊猫数据系列，pd.Series(data).map(record_dict)将转换它能找到匹配的所有值。

但是，如果我们找不到匹配的呢？这就是将数据上传到 Airtable 的过程变得相当复杂的地方，但如果我们愿意采取一些额外的步骤，仍然是完全可行的。但是首先我们需要通过 API 在 Airtable 中创建新记录的基本机制。

在 Airtable 中创建新记录

在本教程的第一部分的中，我们使用[requests](https://2.python-requests.org/en/master/)库通过 GET 方法从 Airtable 下载数据。现在，使用类似的代码，我们将使用 POST 方法创建一条记录(稍后，我们将使用 PATCH 方法更新一条记录)。

比较一下，注意用斜体标出的差异:

**# Download**
response = requests.*get*(url, *params=params*, headers=headers)**# Upload New** response = requests.*post*(url, *data=upload_json*, headers=headers)

我们可以使用相同的网址("https://api.airtable.com/v0/" + base_id + "/" + table_name)用于下载和上传。但是，我们必须扩展标题，以便:

{"Authorization" : "Bearer " + api_key,
 "Content-Type" : "application/json"}

这个新的Content-Type头的存在是对我们的一个暗示，当上传数据到 Airtable 时，我们现在以 JSON 的形式发送数据(你可能认为这是下载时传递参数的镜像)。

为了具体说明这一点，我们来看一个例子。

**# Step 1**
upload_data = {"Name" : "Otis Osborn",
               "Shifts" : 9,
               "Location" : ["rec887G00dQIujFel"]}**# Step 2**
upload_dict = {"records" : [{"fields" : upload_data}], 
               "typecast" : False}**# Step 3** upload_json = json.dumps(upload_dict)**# Step 4**
response = requests.*post*(url, data=upload_json, headers=headers)

步骤(1)创建了一个我们想要上传到 Airtable 的数据字典。请注意字符串、整数和列表数据类型的使用。这里确保字段名和数据类型匹配是很重要的——如果您遇到错误，请参考您的库的 API 文档。

步骤(2)将该数据子集化到 Airtable 的 API 可以读取的另一个字典中。您可以将"typecast"设置为真或假。如果由于某种原因，您无法在步骤 1 中获得匹配的数据类型，将此设置为 True 会将字符串转换为 Airtable 对相应数据类型的最佳猜测。

步骤(3)将这个字典转换成 JSON，步骤(4)将最终产品上传到 Airtable。如果成功，Airtable 将发送回一个响应，当调用response.json()时，该响应将如下所示:

{'records': [
  {'id': 'recoiMuxqVvbNMRlG',
   'fields': {'Name': 'Otis Osborn',
              'Location': ['rec887G00dQIujFel'],
              'Shifts': 9},
   'createdTime': '2021-02-19T14:41:41.000Z'}]}

请注意，除了“创建时间”之外，我们现在还有另一个关键的新数据，一个专门针对该记录的 id。

我们可以通过检查图形界面来验证是否添加了 Otis Osborn:

图 4:在图形界面中识别新记录。作者图片。

很简单。这样可以一次只向 Airtable 添加一条记录。然而，当我们开始批量匹配和创建多个任意大小的 Airtable 记录时，我们开始遇到匹配问题。

匹配(&上传)多条记录

之前，我们使用基于 Airtable 数据下载的 Python 字典将字段值与记录 id 进行匹配。然而，当我们将新数据上传到 Airtable 时，Python 字典就过时了。

例如，想象一下，如果我们在数据集中两次遇到“Otis Osborn ”,并且我们知道这个“Otis Osborn”是同一个人(即，不存在 Otis 1 和 Otis 2)。如果我们在匹配多个记录时没有保持 Python 字典的更新，那么将会为同一个 Otis Osborn 创建两个单独的记录。

一种解决方案是在每次新上传后重新下载 Airtable 数据，但这将是带宽密集型的，尤其是对于较大的数据集。一个更好的解决方案是使用我们在向 Airtable 上传新的关系数据条目时收到的响应数据来更新 Python 字典。

下面，这个过程就直观的表现出来了。

图 5:当没有找到预先存在的匹配时，创建一个具有唯一字段值的新记录的过程。与上面的图 3 比较。图片作者。

在您将该图与上面的图 3 进行比较之后，让我们考虑如何对这些步骤进行编码。

步骤 1:尝试将字段值与记录 ID 匹配

match_value = "Otis Osborn"
record_id = record_dict.get(match_value)

这里，我们将一个 Airtable 字段值与一个记录 id 进行匹配。在这个特定的例子中，我们知道 Otis Osborn 不在字段值和记录 id 的字典中，所以record_dict.get("Otis Osborn")将返回一个 Python NoneType 对象。

第二步:在 Airtable 中新建一条记录

match_field = "Name"
if record_id is None:
    upload_data = {match_field : match_value}
    upload_dict = {"records" : [{"fields" : upload_data}]}
    response = requests.post(url, data=upload_json, headers=headers)

因为记录 id 是None，我们指示计算机将 Otis Osborn 上传到 Airtable。我们创建一个简单的数据字典，将这个简单的字典添加到为 Airtable 上传而格式化的“上传字典”中，然后发送一个 POST 请求。

第三步:解析 Airtable 响应

airtable_record = response.json()['records'][0]

上面的代码帮助我们导航 Airtable 响应。因为我们成功上传了一条记录，所以我们取回了一条记录，索引在[0]。

第四步:获取 Airtable 记录 ID

record_id = airtable_record['id']

记录 ID 应该类似于:rec3QjKqz8RiCz26r。这使我们到达了相同的点，好像我们已经在字典中有了这个字段值和记录 ID 对，但是如果我们想要避免重复上传，我们还有一个步骤。

第五步:更新字段值和记录 id 的字典

record_dict.update({match_value : record_id})

恭喜你。至此，我们已经完成了进行匹配代码的另一次迭代所需的所有工作。保持这个 Python 字典与 Airtable 同步是通过 API 上传数据最困难的部分。

现在我们已经完成了匹配和/或创建记录的复杂过程，我们准备进入上传过程的最后一部分:使用 Python 更新 Airtable 记录。

更新 Airtable 中的记录

在 Airtable 中更新记录的过程与创建记录的过程非常相似，只有几个关键的区别，具体如下。

第一个区别是 API 请求中使用的 URL:它需要指向我们正在更新的特定记录。幸运的是，我们需要做的只是将记录 ID 附加到我们用来创建新记录的 URL 上，就像这样:

url + "https://api.airtable.com/v0/" + base_id + "/" + table_name
record_url = url + "/" + record_id

第二个区别是我们通过 API 发送的数据字典。由于我们在更新时一次只上传一条记录，所以字典要简单得多(参见上面的步骤 2)。

upload_dict = {“fields” : upload_data, “typecast” : typecast}

第三个区别是我们使用的 RESTful 方法。为了创作，我们发帖；为了更新，我们将打补丁，就像这样:

**# Upload Update** response = requests.*patch*(record_url, *data=*upload_json, headers)

与本教程的其余部分相比，这似乎没什么大不了的，但是更新 Airtable 记录的能力允许您创建可伸缩的数据解决方案，将 Python 的分析能力与 Airtable 的用户友好的数据存储能力结合起来。

从熊猫到飞行桌

[pandas](https://pandas.pydata.org/)是 Python 中一个流行的数据分析和操作包。在处理 Airtable 数据时，我们可能会有一个类似于下面这样的 pandas 数据帧，其中记录 id 构成了索引值:

图 6:熊猫数据表，在 Jupyter 笔记本界面上显示。图片作者。

在这种情况下，我们的第一步是将 dataframe (" df")转换为字典中的字典。我们可以使用代码为df.to_dict(orient="index")的来实现这一点，它将生成如下所示的内容:

{'rec6vFIUEH4Fk9Z4a': {'Shifts': 4,
  'Name': 'Alva Arnold',
  'Location': ['recyz79aQzGl3LXPT']},
 'recrN5WVNHl1pGxET': {'Shifts': 9,
  'Name': 'Bruce Buck',
  'Location': ['rec887G00dQIujFel']},
 'recUzv7g6PZi4FGbB': {'Shifts': 8,
  'Name': 'Charlotte Chaney',
  'Location': ['recSZBITRlt2juAJ0']},
 ...}

我们现在可以迭代字典中的每个键值对，如下所示:

dict_of_dicts = df.to_dict(orient="index")
for record_id, upload_data in dict_of_dicts.items():
   record_url = url + "/" + record_id
   upload_dict = {"records" : [{"fields" : upload_data}]}upload_json = json.dumps(upload_dict)
   requests.post(url, data=upload_json, headers=headers)

现在，我们可以无缝地从 pandas 转移到 Airtable，反之亦然(见本教程的第一部分下载 Airtable 数据到 pandas dataframe )！

结论

来源: GIPHY

首先，如果你遵循了上面的每一个步骤，仍然有问题，欢迎你将我的简单的 Airtable 帮助函数复制并粘贴到你的项目中。这个 Python 代码片段不仅将上述所有思想集成到一个函数中，而且还将打印故障排除消息，以帮助您找出不工作的地方。

一旦你把 Airtable 上传到工作中，天空就是极限。我使用 Python-to-Airtable 上传来促进数据审计方面的协作，增加数据分析的透明度，并用生成的数据作为数据库的种子。给我写封短信分享你创造性的 Python-Airtable 集成！

对于 Python- Airtable 开发者来说，有令人兴奋的消息，据报道，更多的功能正在向我们走来。特别是，有一个元数据 API正在开发中，它让开发者能够列出库、表、字段类型和视图。除此之外，这将使定位下载数据和上传数据更加容易，而不会因为键错误或数据类型不匹配而中断。当元数据 API 发布时，如果您对本教程的第三部分感兴趣，请对本文发表评论或鼓掌。

承认

  • 这篇文章的最初草稿是作为熨斗学校华盛顿 DC 校区的奖学金的一部分而制作的。对于那些对学习 Python 驱动的数据分析感兴趣的人，我强烈推荐熨斗学校的数据科学训练营。
  • 感谢 David T，这位读者发现了原始代码样本中的一个错误。你能发现这个错误吗？{"Authorization" : "Bearer" + api_key, "Content-Type" : "application/json"}
  • 此外，感谢我在 BuyMeACoffee.com 和 Ko-fi.com的支持者们，是他们让我有可能整理这些教程。如果这篇教程对你有价值，我会欢迎你的支持！☕

甘的专辑封面

原文：https://towardsdatascience.com/album-covers-by-gans-c5c8ef48f50c?source=collection_archive---------28-----------------------

一步一步的代码和直觉指南生成专辑封面。

WGAN 生成的专辑封面随机样本

是的，甘斯很酷。

如果你不知何故偶然发现了这篇小文章，可以肯定地说，你对ggenerateanetworks—GANs 有点兴趣。

我绝对是。在网上看到无数令人惊奇的项目时，我也想创造一些有趣的东西。从人脸生成到图像恢复，GANs 的能力吸引了我——我需要学习更多。

完成了经典的 MNIST 和猫狗教程，我想知道…现在呢？正如你可能从标题和图片中知道的，是专辑封面抓住了我的好奇心。

目录

1。为什么是专辑封面？

2。编码专辑封面生成器

3。数据预处理

4。创建发电机

5。创建鉴别器

6。培训时间

7。结果——任何项目中最激动人心的部分

8。我们如何改进我们生成的专辑封面？

9。WGANs

10。WGAN 的实现

11。更好的 WGAN 结果！

项目回购环节

为什么是专辑封面？

看看下面的专辑封面，你注意到了什么？

照片由粘土银行在 Unsplash 上拍摄

这个例子揭示了一个有趣的观察结果——这些不同的封面之间似乎很少有一致性，至少在我看来是这样。

事实上，当深入研究我们的专辑封面数据集时，有各种各样的颜色、图案、形状、纹理、文字……不胜枚举。

单纯的甘能看懂什么是专辑封面吗？如果有，这种理解会是什么样子？

我开始尝试回答这些问题。

编码专辑封面生成器

作为对读者的一个快速提示，我假设对 GANs 的工作原理有一个基本的了解。网上有许多令人惊叹的资源可供学习，但这里有一些是我最喜欢的:

  • 路易斯·塞拉诺对甘斯的友好介绍
  • 王洋对甘斯的数学介绍
  • 我自己的甘介绍

预处理数据

与任何机器学习项目一样，我们从预处理数据开始。

我们的目标是将原始数据集转换成可以将处理过的图像输入到我们的训练管道中的东西。通过利用 PyTorch 的数据加载器，我们可以用几行代码完成这两项任务。

将图像预处理到数据加载器中

创建生成器

准备好数据加载器后，我们要设置生成器模型。我们的模型将基于 PyTorch 教程中的 DCGAN。

我们的生成器将负责生成专辑封面的创建。

发电机模型

创建鉴别器

鉴别器是等式的下一部分。我们的鉴别器的工作是简单地将给定的图像分类为生成的或真实的。

由于创建专辑封面的复杂性，我们过于简单的生成器可能无法创建最令人信服的专辑封面。为此，我们可以满足于一个简单的卷积分类模型作为我们的鉴别器。

鉴别器模型

训练时间

数据…检查。发电机…检查完毕。鉴别器…检查。训练时间到了！

GAN 的训练过程可以归结为我们的生成器和鉴别器之间的最小-最大博弈。我们希望训练这两种模型相互对抗，以改进彼此。

首先，我们初始化我们的模型并定义损失函数和优化器。对于我们的 GAN，二进制交叉熵损失函数将工作得很好。我们的优化器将利用学习率为 0.002 的 Adam 优化算法。

对于我们的鉴别器的训练管道，我们希望将生成的和真实的样本用正确的标签输入到我们的模型中。

这个过程将感觉非常类似于典型的两级分类训练管道。

甄别训练程序

对于我们的生成器，我们将输入 0 到 1 之间的值的正态分布向量，以生成 120 x 120 像素的 RBG 图像。生成之后，我们将要求鉴别器在计算损失值和相应地调整生成器之前对我们的图像进行分类。

发电机培训程序

现在已经定义了所有的培训管道，我们可以开始培训过程了。在 Google Collab 上运行这个模型 15 个时期花费了相当多的时间，所以吃点零食，放松一下，享受一部电影吧！你应得的！

训练周期

结果——任何项目中最激动人心的部分

与大多数 GAN 项目一样，我们的损失值不能告诉我们多少关于生成图像的质量，所以我将从这里排除它。但是，让我们来看看我们生成的样本！

DCGAN 结果

嗯，它们看起来没有我希望的那么好。

有了香草甘架构，似乎我们能够捕捉专辑封面的一些基本特征。我们可以看到各种各样的颜色和形状。

然而，我们遇到了重复模式的问题，也被称为模式崩溃。这些形状也不能把自己建成任何明确的结构。

总的来说，不是最好的结果。

我们如何改进我们生成的专辑封面？

我们有几个选择可以探索。

我们可以尝试在我们的生成器模型中调整一些参数，但是超参数化模型的过程可能是冗长而缓慢的。

嗯，我们可以多训练我们的网络吗？大概不会。我们已经遇到了模式崩溃的迹象，所以进一步的训练可能会加剧这些影响。

那么我们为我们的 GAN 尝试不同的架构怎么样？

这可能行得通。

WGANs

Wasserstein GAN 已经被证明可以显著提高 GAN 的生成能力，同时也解决了模式崩溃和消失梯度的问题。

这两种架构的主要区别在于:

  • 用批评家代替歧视者
  • 在损失函数中使用瓦瑟斯坦公制/推土机距离
  • 权重正则化(梯度惩罚/权重剪裁)

WGAN 的实现

让我们首先创建批评家。批评家和鉴别者真的是一样的，只是批评家最后没有包含一个 sigmoid 激活层。

我们将继续使用二进制交叉熵损失函数以及 Adam 优化算法。然而，我们将不得不对训练管道进行一些调整，以包括梯度惩罚。

梯度惩罚有助于约束批评家保持李普奇兹常数(有益于优化)。我们将采用这个梯度罚值，并将其纳入我们的评论家的损失。

定义了新的 WGAN 训练管道后，我们可以像以前一样运行相同的训练循环，并等待我们的新结果！

更好的 WGAN 结果！

正如我们从这篇文章的第一张图片中看到的，与我们的 GAN 结果相比，WGAN 生成的样本看起来更像专辑封面。

生成器模型可以更好地捕捉抽象的形状、纹理、颜色范围，甚至可能的文本模式。

下面，是我最喜欢的几个！

我最喜欢的样品封面

在最左边，我看到图像顶部附近有一个较浅的模糊图案。对我来说，这类似于出现在许多专辑封面上的文字。一个建筑上的变化就能捕捉到这种抽象的模式，真是太神奇了。

右边的两幅图像似乎显示了一个人的场景。在左边，我看到一个人在向远处的另一个人挥手。在右边，我看到两个女孩站在一起，看着黄色的草地。

一个简单的 WGAN 可以生成如此细节和色彩的图像，这是非常令人惊讶的。

一些结果之间的插值

生成性对抗网络是强有力的工具。全世界都清楚，这种技术的实际应用是无穷无尽的。

唯一的问题是…你打算用它做什么？

算法偏差

原文：https://towardsdatascience.com/algorithmic-bias-fff4d8c31290?source=collection_archive---------41-----------------------

当算法模仿和放大刻板印象时

资料来源:联合国人类住区规划署

谁在泰坦尼克号灾难中幸存了下来？

回想一下泰坦尼克号电影，救生艇附近的男人在尖叫——女人和孩子优先！现在，随着一些崭露头角的数据科学家探索著名的泰坦尼克号数据集(也可在 Kaggle 上获得)以预测谁幸存，在探索性数据分析的最初几步中，人们会得出结论，妇女和儿童幸存的概率更高。这些数字还表明，坐在较高阶层的人比坐在较低阶层的人有更高的生存机会，避免贿赂或地位偏见。

现在，如果有人随机问我——美国广播公司在泰坦尼克号灾难中幸存了吗？我的回答是 ABC 是女性吗？他/她富有吗？我只是放大了我的认知系统通过观看电影和探索数据集建立起来的经济地位偏见和性别偏见。

如果假设，泰坦尼克号数据集将被旅行社用于邮轮保险，它将预测女性的存活率高于男性的存活率；因此，与男子相比，向妇女收取的保险费较低。

主流应用中的偏差

偏见与信用额度 2019 年，苹果联合高盛推出信用卡。当科技企业家大卫·海涅迈尔·汉森在推特上说他被批准的信贷限额比他妻子被批准的限额高 20 倍时，事情发生了错误，尽管他们申报了联合税。包括苹果联合创始人史蒂夫·沃兹尼亚克在内的许多其他人表示，同样的事情也发生在他们身上。在这种情况下，如果算法是预测信用额度的算法，保持其他一切不变(税收、资产和负债)，女性的信用额度预计会低于男性。

偏见和工作门户 几年前，亚马逊创建了一个内部招聘工具，根据简历是否符合工作描述/历史角色定义对简历进行排名。后来人们发现，这个工具并没有产生不分性别的排名。使用这一工具时，妇女的级别比男子低。

偏向和面部识别 许多面部识别技术已经以生物识别支付、机场移民检查、相机中的内置应用以及各种社交媒体网络的形式进入主流。然而，这些面部识别应用程序错误识别有色人种的事件越来越多。路透社文章:美国政府研究发现面部识别工具存在种族偏见。与对非白人的预测相比，该工具可以更准确地识别白人的性别。

它是如何发生的？

训练数据中的偏差 以苹果信用卡为例，最有可能是算法，根据历史数据训练，预测其新客户的信用额度。历史上，在算法接管之前，人类以承销商的形式做出信贷限额决定。也许，这是一种历史的非有意的人类偏见。由于多种原因，如男性和女性的工作稳定性更高，更容易因生育和照顾孩子而中断工作，承保人可能会给男性更高的信贷限额，给女性更低的信贷限额。

在招聘工具的例子中，模型是根据主要来自男性的历史简历进行训练的，而科技是男性主导的行业。因此，该工具惩罚像“女子象棋俱乐部”等词。从而导致女性的排名较低。

当算法根据历史数据进行训练时，它们会重复和混合社会/行业中存在的刻板印象/错误，从而降低特定人群的优先级。

训练数据的有限可变性 在面部识别算法存在偏见的情况下，种族偏见被注入算法的一个关键原因是训练数据在很大程度上偏向白人群体。如果训练数据适当地代表了人口的所有部分，可能就不会出现偏差。

因此，如果我们要训练一个只有女性人口的乳腺癌算法，那么如果一些男性被扔进预测数据，它将会抛出古怪的结果。不要误会我的意思，但乳腺癌也可能发生在男性身上！

直接偏差特征 作为数据科学家，当我们在开发算法时，我们的倾向是获得尽可能高的预测精度。我们踏上了特征提取之旅，将一切可能的东西(性别、收入、地址)放入模型中以提高准确性。我们很少考虑这个问题——基于性别做出这种预测是否道德？如果在历史上，人类有意识或无意识地考虑性别来做出信贷决策，我的算法也会这样做吗？将性别作为一个特征并不总是一件坏事。在一些场合，例如检测乳腺癌的概率，包括性别特征将是非常合适的决定。

间接偏见特征 虽然性别和收入等变量会直接引入偏见，但其他一些变量，如俱乐部会员资格、姐妹会/兄弟会隶属关系等也是会引入偏见的间接变量。加入兄弟会意味着客户是男性，加入姐妹会意味着客户是女性，交易数据中向印度俱乐部支付的会员费可能间接将客户描述为亚洲人。所有这些变量，如果不去偏差，涵盖一个或另一个偏差。

未来意味着什么？

对于数据科学家和开发人员来说
在我们追逐准确性最大化目标的时候，我们应该看看这个过程的其他一些结果。例如，大多数基于树的算法(决策树、随机森林、xgboost 等)会产生特征重要性度量，如果对其进行适当的分析，可以预先阻止算法中的任何偏差。

对于学术界来说 传统上，在社会、工作场所和其他地方有偏见的监管法规都坐在法律部门里。可能学术界需要创建专门的法律程序，培训律师理解算法中的偏见，并对机器学习产品进行“法律审计”。有了适当的算法知识，法律应该成为人工智能团队的一部分。

对于一个更广泛的人工智能网络 类似于从逻辑回归到 CNN 的一系列算法，为了自动化无数后端决策和预测，我们应该创建一系列算法——每一个都检测不同类型的偏差。比如模型中种族偏见的一个 XGBoost，收入偏见的深度学习等等。

数据科学的算法思维

原文：https://towardsdatascience.com/algorithmic-thinking-for-data-science-ab8c91416d83?source=collection_archive---------8-----------------------

数学和编程联系的衍生物

在 Unsplash 上拍摄的 ThisisEngineering RAEng

数据科学学生经常问的一个突出问题是，“为什么是算法？”老实说，我不怪他们。你会看到库和语言每天都在进步，使用 scikit-learn 的 Python 可以在一行代码中实现几乎任何数据结构。那么，为什么会有人想知道这些内置算法背后的科学和数学呢？

这与人类“学习”的方式有关。

回到你开始爬行和行走的时候，可能是 8 个月大的时候。几个月后，你开始听和说单词。几年后，你可以用父母教过的语言和他们交谈，你也可以用同样的语言和其他人交谈。这是在你上学之前。当学校开学的时候，教你的第一件事就是字母。当你已经可以用同一种语言与人交谈时，为什么还需要学习字母呢？因为学习不会停止。有了字母表和语言，你可以更有效地学习说和写。

几十年后，我们今天使用的算法可能不再适用。数据每秒都在呈指数级增长。五年前，1000 这个数字在货币和兆字节上都被认为很大。今天，这个数字很小。算法的根帮助我们理解它是如何构建的，这反过来又教会我们能够为现有算法从未见过的场景构建或修改这些算法的科学。这就是为什么，对于数据科学家、程序员和计算机科学行业的任何人来说，了解算法是如何从内部构建的非常重要。

什么是算法思维

概括算法的定义和实现就是算法思维。这意味着，如果我们有一个解决问题的标准，比如说一个排序问题，在问题陈述改变的情况下，我们不必完全修改方法。总会有一个攻击新习题集的起点。这就是算法思维的作用:它给出了一个起点。

为什么我们需要算法思维？–主要是为我们尚未遇到的问题建立新的解决方案。

设计任何算法时的两个关键要求是:

  1. 效率:解决大问题的能力，就像解决小输入问题一样容易。
  2. 可伸缩性:由于我们拥有的数据量每天都在增加，因此输入大小在未来总是会增加。我们今天设计的算法应该能够将自己扩展到输入的新高度。

理解算法思维的案例研究

让我们看看如何对一个问题实现算法思维，然后尝试改进我们原始的初始解决方案。我们从一个 寻峰器问题开始。 寻峰器(一维)是给我们一组输入整数，要求我们在那些数中找出峰值(最大的整数值)的问题。

假设字母(a 到 I)代表整数，这个数组的索引从 1 开始。我们需要找到作者的峰值(最大整数)|图像

策略 1:简单的算法

在我们的第一个策略中，我们简单地遍历给我们的整数数组，找到最大的元素。在上面显示的场景中，找到峰值需要多长时间？嗯，那要看情况。如果输入中的数字按降序排列，那么我们找到的第一个数字就是峰值。但是，无论哪种方式，要检查整个数组，我们都需要遍历它。因此，在该算法中将有总共‘n’个事务或迭代，‘n’是数组的大小。

策略 2:分而治之

在这个新策略中，我们尝试了一些不同的东西。我们尝试将输入数组分成两半。这种方法总共有三种可能的情况。要么中间的元素比左边的元素小，要么比右边的元素小，要么比两者都大。让我们看看下面的伪代码，了解分而治之找峰。

if a[n/2] < a[n/2 -1]
   search the left half { 1 -> a[n/2-1] } for peak
else if a[n/2] < a[n/2 + 1]
   search the right half { a[n/2+1] -> n } for peak
else
   middle number is the peak

我们观察到这个算法的迭代次数与我们最初的简单算法不同，这是为什么呢？这是真的，因为即使在最坏的情况下，该算法也不必遍历数组的每个元素。

不断增长的数据量的影响

为什么计算时间和空间的复杂性比以往任何时候都重要？这与我们之前讨论过的事情有关，即今天要处理的数据量。为了更好地解释这一点，让我们通过几个例子来展示大量数据在算法构建中的重要性。在测试场景中，当处理的数据量是我们处理的数据量的 100 多万倍时，我们在教室中随意创建的解决问题的算法与行业要求的算法非常不同。并且当输入大小明显较大时，时间复杂性总是可见的。

大数据问题的时间复杂度分析

当然，今天的计算机比以往任何时候都要快，内存也比以往任何时候都要大。但是，这些东西对我们来说都不是无限的。因此，计算时间是一种有限的资源，内存空间也是如此。因此，我们需要最佳地利用这些资源。

在这一节中，我们将回答为什么拥有在运行时节省空间和时间的高效算法如此重要。让我们以排序数字为例。排序中两个众所周知的算法是插入排序和合并排序。两者都工作得很好，都有专门的应用程序。我们想了解它们在非常大的输入下的性能。我们知道(在本文中我没有提供这些的证明)插入排序以 n 阶的效率运行。合并排序以 nlogn 的时间效率运行。这两种算法都有一些恒定定时的整数，但是在任何函数增长到非常大的数字时，这些 常数在函数各自的增长中不起任何重要作用(我们将在下面看到这一点的证明)。 非常清楚，如果我们将 log(n)与 n 进行比较，log(n)上的乘数永远较小。

取 n=1000，log(1000)大约是 10，即使 n 的值等于一百万，log(n)也是 20。另一方面，代表 1000 的 n 会跨越六位数，代表 100 万的 n 会更大。

让我们通过比较两台计算机 A 和 b 来考虑下面的工作示例。

计算机 A 是一台快速机器，每秒执行 100 亿条指令(这是假设的，目前很难在单个处理器上构建具有这种指令速率的机器)。计算机 B 是一台很慢的机器，每秒大约运行 1000 万条指令。从这些原始计算数据中，很明显计算机 A 比计算机 b 快 1000 倍。为了让事情更戏剧化，并将这种比较提升到另一个层次，让我们想象一个世界级的程序员用机器语言编写插入排序代码，运行时间复杂度为 2(n)。现在，一个编程新手，实现他的第一个合并排序代码，以 50n 的效率编写它。log(n)
我们在计算机 A 上运行插入排序，在计算机 B 上运行合并排序，输入1000 万个数字。

如果你算一下(单位时间内算法求解的指令/计算机处理的指令)你会看到计算机 A 需要 20000 秒，大约是 5.5 小时。而速度较慢的计算机运行代码效率低下，计算机 B 需要 1163 秒，不到 20 分钟。这是高效且可扩展的算法设计能够带来的计算影响。使用库中预先设计的算法不会给针对单个机器的能力优化代码的自由。

为什么常数不重要

在故事的前面，我提到算法，对于一些任务，需要花费固定的时间(例如，将一个变量写入内存或者给一个变量赋值，等等。)我还提到，如果算法正在计算非常大的输入，这些常数可以忽略。这是为什么呢？

看看下面的正弦和二次函数:

g(x) = 1.1x^2 + (10 + sin(x + 1.15) * x^1.5) + 6006f(x) = x^2

让我们看看，这些函数是如何随着 x 值的变化而增长的。

看到趋势的变化。随着输入范围的扩大，噪声几乎消失。|作者图片

我们看到，在某一点之后，曲线的形状改变了，变得类似于函数 f(x ),它没有任何常数。如果我们确实看到一些噪声，那只是因为 x ^1.5 项。因此，忽略时间和空间效率计算中的常数是一种做法，因为对于大量的数据输入，它们变得可以忽略不计。

阅读有关数据科学算法的更多信息

结论

这场争论可能永远不会结束！随着学习编码的方式越来越多，编程场景变得相对容易。甚至机器学习算法也在慢慢变成 AutoML 应用程序上的拖放，比如微软的 Azure ML Studio。但是，尽管如此，设计高效算法的需求永远不会消失。机器可能变得强大，但与此同时，每秒处理的数据量也在增加。因此，必须设计有效的算法来处理这些数据。这个故事的目的不是教你算法设计的艺术，而仅仅是指出算法对数据科学家也很重要。构建、设计和测试高效、可扩展算法的目的没有也永远不会消失。

照片由西格蒙德在 Unsplash 上拍摄

关于我

我是纽约哥伦比亚大学的一名软件工程师兼数据科学研究员，目前正在研究如何减少气候变化对世界贫困人口的影响。这些人受我们砍伐树木和在地球表面推混凝土的行为影响最大。如果你的研究或工作抱负也与我一致，请务必通过 Twitter 或 LinkedIn 与我联系，我们可以一起努力建设 负责任的人工智能。

参考

  1. https://www . cs . sjtu . edu . cn/~李江/teaching/cs 222/files/materials/Algorithm % 20 design . pdf
  2. https://www.cs.princeton.edu/~wayne/kleinberg-tardos/
  3. https://github . com/davie 890/cs 102-Algorithm-Analysis/blob/master/Algorithm % 20 design % 20 by % 20 Jon % 20 kleinberg % 2C % 20 EVA % 20 tardos . pdf
  4. https://www . cs . ut exas . edu/users/DJI menez/utsa/cs 1723/lecture 2 . html
  5. https://www . hackere earth . com/practice/basic-programming/complexity-analysis/time-and-space-complexity/tutorial/
  6. https://www . geeks forgeeks . org/time-complexity-and-space-complexity/
  7. https://towards data science . com/a-data-scientists-guide-to-data-structures-algorithms-1176395015 A0
  8. https://medium . com/swlh/why-data-scientists-should-learn-algorithms-and-data-structures-4d 93237 a 1026
  9. https://tdwi . org/articles/2018/07/02/adv-all-5-algorithms-for-big-data . aspx

经济学驱动的深度学习算法交易

原文：https://towardsdatascience.com/algorithmic-trading-with-economics-driven-deep-learning-50c219ee9334?source=collection_archive---------4-----------------------

将宏观经济理论融入深度学习模型

当开始学习金融 ML 时，很容易将一堆技术信号放入现成的 Keras RNNs 或 CNN 中。不用说，这些项目中的大部分都失败了，原因很简单，这些模型是为完全不同的应用开发的，不能反映金融数据的基本经济学。

今天，我们将看看在本文中开发的多图张量网络模型，并探索它如何将经济理论整合到更好的算法交易中。具体来说，我们将讨论如何将外汇(FX)套利因素(FX 回报的最重要驱动因素)纳入算法交易的深度强化学习代理的架构中。

(你可以在这里找到完整的代码和更多的细节

1.技术背景

为了将经济学原理纳入我们的深度学习模型，我们将不得不求助于在图形神经网络、张量网络和强化学习领域开发的工具。我们将在这里以非常概念性的方式讨论这些话题，因此请参考论文了解更多细节。此外，如果您已经熟悉这些主题，请随意跳过这一部分。

1.1.图形神经网络

图形神经网络(GNNs)是一种深度学习模型，用于处理在描述为图形的不规则域上定义的数据。与卷积神经网络(CNN)不同，它们不对底层数据几何做出假设，并且可以将卷积的概念推广到任何数据域。

下图直观地展示了如何将图像上的经典 2D 卷积(左)视为规则网格上互连像素图形上卷积的特殊实例(右)。

作者图片

1.2.张量分解

张量将向量和矩阵推广到多维数组。例如，矩阵是 2 阶张量，向量是 1 阶张量，标量是 0 阶张量。它们自然地描述许多类型的数据，例如图像(具有 3 种模态的 3 阶张量:x 轴、y 轴和 RGB 颜色)以及金融数据。

与矩阵类似，张量可以通过张量分解(TD)以低秩形式分解。TD 允许我们以对数方式大幅压缩大规模数据，这使我们能够有效地绕过维数灾难。

作者图片

1.3.深度 Q 强化学习

深度 Q 强化学习训练神经网络代理与给定环境交互，以最大化累积回报。这个学习框架特别适合算法交易，因为回报直接转化为代理买卖行为产生的利润。

作者图片

2。为什么金融深度学习经常失败

金融数据经常违反深度学习模型的假设

在我们可以开发自己的金融深度学习模型之前，我们需要了解为什么传统的 CNN 和 rnn 往往对金融数据不起作用，原因很简单:它们不是为这个领域开发的。

每个深度学习模型都有自己的一套关于底层数据的假设，这可能不适用于金融市场，因为它有自己的一套独特的特征，正如本文中所讨论的那样。

例如，CNN 是为计算机视觉任务开发的。他们假设基础数据是平移不变的，这对于图像来说是正确的，但是对于金融数据来说就不那么正确了。另一方面，RNNs 被开发用于序列建模。他们假设过去的状态可以通过可预测的趋势和季节性影响未来，这在一定程度上适用于金融数据，但往往不是一个充分的因素。

也就是说，通过非常仔细的问题公式化和数据预处理，我们可以绕过许多这样的问题，非常成功地将 CNN 和 RNNs 用于金融应用。因此，有必要仔细检查我们模型的基本假设，并确保它们反映了金融数据的基本经济学。

3.外汇金融背景

套利因素是外汇回报的主要驱动力，它与利率相关

现在让我们分析外汇数据的特征和驱动因素，以便我们能够设计我们的模型来反映基本的经济原则。

3.1.外汇数据的特征

外汇市场允许参与者以给定的即期汇率交易多种货币，即期汇率衡量一种货币在给定时刻相对于另一种货币的价值。

作者图片

外汇数据本质上是多模态的(多维的),因为它们包含随着时间的推移和跨几个相关资产索引的多个定价信息，这导致其计算遭受维数灾难的大维张量。这在过拟合方面具有严重的含义，这对于深度学习方法来说尤其成问题。

此外，由于市场中的套利力量，已知 FX 数据具有低信噪比，这使得模型训练特别容易过度拟合，尤其是对于深度学习模型。

最后，各种市场因素(如套利因素、价值因素、动量因素等。)，可以根据时间范围在不同程度上影响定价；这构成了不是很多机器学习算法可以处理的多分辨率问题。

3.2.外汇数据的驱动因素-外汇进位

有许多因素可以影响货币对的即期汇率，但最重要的驱动因素可以说是套利因素。

长话短说，外汇套利描述了货币对升值/贬值的趋势，取决于相应国家之间的利率差异。

例如，假设欧元兑美元的即期汇率为 1(即你可以用 1 欧元兑换 1 美元)，但利率在美国是 2%，在欧盟是 3%。你可以做的是以 2%的利率借入美元(短期)，转换成欧元(长期)，然后以 3%的利率贷出。如果即期汇率在年底前保持不变，你可以将欧元兑换回美元，由于利率差异，你实际上已经获得了 1%的无风险收益。

然而，在现实中，期望即期汇率完全保持不变是天真的。事实上，我们实际上预计欧元兑美元即期汇率会发生变化，以抵消利差。尽管过于简化，但这是利率平价背后的基本思想。

请注意，由于外汇数据是成对的，我们可以为每个货币对定义一个结转值。这允许我们定义下图所示的进位图，它以一种经济上有意义的方式对不同货币之间的成对关系进行编码。

作者图片

4.外汇交易的多图张量网络

在不涉及太多数学细节的情况下，本文在开发的多图张量网络(MGTN)模型利用了张量分解的能力来建模多维数据，以及图在不规则域上建模数据的能力。这使得 MGTN 能够应对外汇数据的几个挑战，例如:

  • FX 数据的多模态特性自然会导致张量表示，这可以通过 MGTN 的张量结构轻松处理。
  • 该模型可以利用张量分解的强大低秩压缩特性，这种特性固有地不受维数灾难的影响，并提供一个正则化框架来解决 FX 数据的低信噪比特性。
  • 长期市场因素如套利可以被封装在图形过滤器中，自然地吸引外汇数据的成对公式；这允许通过经济上有意义的低频图形拓扑来处理高频定价数据。

通过使用 MGTN 作为 deep-Q 强化学习代理的基础，我们可以训练它，并将其与其他深度学习代理进行比较，以完成 FX 算法交易的任务。下图显示了相应的样本外交易结果，其中 MGTN 模型的表现明显优于其他深度学习代理。

作者图片

需要强调的是，上述模拟做出了许多假设(例如，无延迟、无交易成本、无市场影响等)。)，所以对结果要半信半疑。这个模拟的目的是展示如何将经济原则融入深度学习模型中，从而产生更强大的交易算法。

我希望你喜欢这篇文章！如果你想看更多这样的内容，请关注我。

此外，检查出我的网站的完整代码和其他资源。

来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

如何通过算法生成图像数据集

原文：https://towardsdatascience.com/algorithmically-generated-image-dataset-71aee957563a?source=collection_archive---------7-----------------------

为机器学习创建您自己的图像数据集

生成图像的示例。(沙漠背景)作者林奈·马利特 |(乡村背景)作者道恩·哈德森 |(森林背景)作者乔治·霍丹 |(冰川背景)作者艾德·罗杰斯 |(人物和物体)作者craftpix.net

这篇文章的灵感来自最近发布的 NFT 艺术收藏，如 Cryptopunks、Sollamas、ON1 Force 或 Bored Ape Yacht Club。在所有这些项目中，有一些项目的图像是由艺术家创作的，而另一些项目的图像是通过算法生成的。正如我们在数据科学博客中一样，我们创建图片集的有趣方式是第二种。

在这篇文章中，我们将使用 Python 创建一个随机图像的集合，这些图像之间有许多共同的特征。我们将从一些基础图像开始，我们将在其上添加元素，以配置将形成集合的最终图像。在这种情况下，我们将使用一个背景，我们将在其上放置不同类型的字符，我们将在其上添加一个对象。

最后，我们将有一个图像数据集，其中每个图像都有特定的属性。例如，一个带着油炸圈饼的沙漠海盗，或者一个带着钥匙的森林怪物。

一个在森林里带着锚的海盗。(森林背景)作者乔治·霍丹 |(海盗兼主播)作者craftpix.net

由于目标不是创建艺术，我将把免费分发的像素艺术作为基础。我将使用这些图像作为基础来生成数百个衍生图像。作为一个有趣的练习，你可以选择一些不同的图像，创建自己完全不同的数据集。

我将使用三种类型的属性:背景、人物和物体。对于它们中的每一个，我将设置一个百分比形式的概率分布来定义每个特征的常见程度。您可以随意使用这些参数来创建不同种类的数据集。例如，一个数据集，其中 99%的图像使用一种特征，1%的图像使用另一种特征。通过做这类实验，并在此基础上建立预测模型，你可以学到很多东西。

属性的概率分布

为了生成文章的数据集，我将使用以下属性分布:

作者图片

让我们开始工作吧

第一步是找到将被用作基础的图像。利用各种各样的网站，我选择了一些图片作为基础。选择这些图像的主要标准是它们可以根据它们的许可进行修改和免费分发。您可以下载这个存储库中使用的所有图像。

一旦图像被选中，我们就可以开始编程算法图像生成器。为了生成图像，我将使用 Python 和 Pillow 库。这是生成图像的基本脚本:

from os import path, mkdirfrom PIL import Imageoutput_folder = "generated"if not path.exists(output_folder):mkdir(output_folder)background_file = path.join("backgrounds", "forest.png")background_image = Image.open(background_file)output_file = path.join(output_folder, "generated1.png")background_image.save(output_file)

首先生成“generated”文件夹来保存生成的文件。如果文件夹已经存在，我们什么也不做。我们加载一个背景，并将其保存在“生成”文件夹中。我们已经完成了第一次图像操作！现在只需要在上面添加更多的元素，直到生成最终的图像。

例子背景(乡村背景)由道恩·哈德森

我们会给背景固定的尺寸，这样所有生成的图像都有相同的尺寸。为了简化工作，我把最大的背景图片缩放到和最小的一样大。我没有缩放字符，因为这个项目的目标是功能，而不是漂亮。我缩放了一些对象，因为它们明显比其他的要大，并且它们在图像之外。

所使用的背景图像在缩放后具有 1920x1078 px 的尺寸。

对字符和对象所做的唯一变换是消除边距，因为每幅图像的每一边都有不同的边距。这使得即使将它们放在相同的位置，其中一些也会比其他的更高或更靠右。

当在背景上添加人物和物体时，工作变得有点复杂。现在我们必须定义我们想要放置字符的位置以及它们应该有多大。为了定义位置，我们有几个选项:

-为所有图像定义固定位置
-为每种类型的人物/每种类型的风景定义固定位置
-随机化位置。如果我们选择后者，我们应该定义一些我们不希望图像出现的限制，我们不希望图像被放在边界上，只有一小部分被看到。

角色走了边。(森林背景)由乔治·霍丹 |(怪物和箱子)由craftpix.net

对于物体来说也是一样，我们必须根据角色在哪里或者在背景上的预定位置来定义放置物体的位置。对于这个数据集，我决定将对象放在字符的右边。

Pillow 使用的坐标系的原点在图像的左上角。如图所示:

作者图片

为了简化工作，我决定将所有的角色放在背景中相同的固定位置。我将位置定义为图像底部水平居中的一个点。小矩形的尺寸， h 和 w 是字符的高度和宽度。用黑色标记的点是我们必须计算的，以告诉 Pillow 在图像中放置字符的位置。

作者图片

这个点可以用下面的公式计算，其中 1920 是背景的宽度，我们除以 2 来找到中点。1000 是 1078 的近似值，以便在角色的脚和图像的底部之间留一些空白。

作者图片

为了将对象放置在字符的右边，我使用了一个类似的公式，在这个例子中，我添加了一个边距 m ，这样对象就不会碰到字符。对我来说效果很好的一个值是 30 px。注意， h 和 w 在这种情况下指的是角色的高度和宽度，而不是对象的高度和宽度，因为我们定位在角色的右侧。

作者图片

作者图片

所有这些计算转化成代码变成这样:

def generate_image(background, character, object, file_name): background_file = path.join("backgrounds", f"{background}.png") background_image = Image.open(background_file) #Create character character_file = path.join("characters", f"{character}.png") character_image = Image.open(character_file) coordinates = (int(1920/2-character_image.width/2), int(1000-character_image.height)) #x, y background_image.paste(character_image, coordinates, mask=character_image) #Create object if object != "none": object_file = path.join("objects", f"{object}.png") object_image = Image.open(object_file) coordinates = (int(1920/2+character_image.width/2+30), int(1000-object_image.height)) #x, y background_image.paste(object_image, coordinates, mask=object_image) output_file = path.join(output_folder, f"{file_name}.png") background_image.save(output_file)

好吧，但是…给我数据！

在我们生成图像的同时，我们还会将它们和它们的特征一起注册到数据库中。我们将使用 pandas 进行注册，并将数据保存在 CSV 文件中。

我们创建一个没有数据的 DataFrame，只命名列。每当我们生成一个图像，一个新的行将被添加到数据帧。最后，一旦生成了所有图像，CSV 将被保存。 num 变量是用于命名图像的顺序计数器。例如，生成的图像将被命名为生成 1 、生成 2 、生成 2894 、…。

保存图像文件的名称很重要，这样才能知道这些参数对应于哪个文件。

df = pd.DataFrame(columns = ["background", "character", "object", "generated image"])for … …. …. #Code to generate image data = [background, character, object, f"generated{num}"] s = pd.Series(data, index=df.columns) df = df.append(s, ignore_index=True)df.to_csv('data.csv', index=False)

我会得到多少图像？

您可以用一个简单的公式计算出可能的图像总数。只需将每个类别中可能的属性数量相乘即可。在我们的例子中，4 个背景* 5 个字符* 11 个对象= 220 张图像。

为了生成所有可能的图像，我们将使用这段代码。首先，我们为每个参数定义所有可能的值，然后对它们进行迭代。

backgrounds = ["countryside", "desert", "forest", "glacial"]characters = ["mage", "warrior", "pirate", "monster", "toadking"]objects = ["none", "barrel", "anchor", "axe", "bomb", "key", "chest", "bananas", "cupcake", "donut", "heart",]def generate_all_imgs(): num = 0 df = pd.DataFrame(columns = ["background", "character", "object", "generated image"]) for background in backgrounds: for character in characters: for object in objects: generate_image(background, character, object, f"generated{num}") data = [background, character, object, f"generated{num}"] s = pd.Series(data, index=df.columns) df = df.append(s, ignore_index=True) num += 1 df.to_csv('data.csv', index=False)

随机选择

在生成图像时，我们已经看到了如何生成所有可能的图像。在这种情况下，我们可以全部生成它们，因为它们很少，但是如果我们增加参数的数量或每个参数的可能性的数量，则可能要生成的图像的数量是巨大的。

使用这段代码，我们将生成给定数量( total_imgs )的图像。为了决定在每个图像中使用哪些特征，我们将求助于机会。请注意，可能会多次生成相同的图像，这在最有可能的参数的情况下是常见的(最有可能的背景，最有可能的角色和最有可能的对象，在我们的情况下，它可能是一个没有对象的森林中的法师)。

我们将使用上表中为每个属性定义的概率，并使用 Numpy 的 random.choice 函数来选择一个属性，同时考虑哪一个最有可能。

def generate_random_imgs(total_imgs): df = pd.DataFrame(columns = ["background", "character", "object", "generated image"]) for num in range(total_imgs): background = np.random.choice(np.arange(0,len(backgrounds)), p=[0.3, 0.3, 0.3, 0.1]) background = backgrounds[background] character = np.random.choice(np.arange(0,len(characters)), p=[0.4, 0.3, 0.2, 0.095, 0.005]) character = characters[character] object = np.random.choice(np.arange(0,len(objects)), p=[0.3, 0.2, 0.1, 0.1, 0.1, 0.05, 0.05, 0.04, 0.03, 0.025, 0.005]) object = objects[object] generate_image(background, character, object, f"generated{num}") data = [background, character, object, f"generated{num}"] s = pd.Series(data, index=df.columns) df = df.append(s, ignore_index=True) df.to_csv('data.csv', index=False)

注意不要使用太高的数字，因为生成过程可能需要几个小时，创建的图像可能会占用很多 GB。

结论

我们已经创建了一个小的基本程序来从基本图像生成合成图像的数据集。有了这个数据集，我们可以开始训练一个神经网络，根据背景的类型或根据人物的类型对图像进行分类。

有了这个脚本，我们就有了做更复杂事情的基础，我们可以给角色添加旋转，让他们有不同的大小，改变颜色等等…

您可以将此数据集生成器用作数据扩充技术的测试平台，例如，您可以创建新的图像，其中角色位于另一个位置，而不是始终相同。你可以创建角色或物体旋转的图像，等等…

怪物说感谢阅读！(森林背景)作者乔治·霍丹 |(怪物)作者【craftpix.net】T2

你可以在这个 Github 库中找到所有的代码和原始图片。

用于创建数据集的图像不是我的，它们的原始来源是:

  • 人物和物体:https://craftpix.net/freebies/
  • 冰川背景:https://www.publicdomainpictures.net/es/view-image.php?image = 282737&picture = lago-glaciar-jokulsarlon
  • 沙漠背景:https://www.publicdomainpictures.net/es/view-image.php?image=342429 &图片=亚利桑那州汽车城
  • 农村背景:https://www.publicdomainpictures.net/es/view-image.php?image = 200702&picture = casa-de-Campo
  • 森林背景:https://www.publicdomainpictures.net/es/view-image.php?image = 167694&picture = bosque-de-la-pintura-al-oleo

算法没有偏见:我们有

原文：https://towardsdatascience.com/algorithms-are-not-sexist-we-are-795525769e8e?source=collection_archive---------39-----------------------

著名的人工智能创造了一个穿着比基尼的 AOC 的形象，它的行为是不恰当的，但却是理性的

如果你相信人工智能根据男性和女性的头像照片创造了男性和女性的形象，那么男性通常会穿西装，而女性则更喜欢低胸上衣和比基尼。

据媒体报道，这证明了人工智能的未来是性别歧视的。理由是，因为互联网上充斥着衣着暴露的女性照片，人工智能会认为这是正常的。

公平点？不一定——这项研究的全部目的是证明从人类活动中收集的数据中继承偏见的危险。

该实验使用了 ImageNet 库，该库通常用于人工智能的训练，由数百万张不同的图像组成，标记有描述。使用这些图像，他们训练一个人工智能从某人的头部图像创建一个全身图像。在 43%的情况下，输入一个男人的头像会产生一个穿西装的男人。但是有了女人的头，53%的全身照片是穿着比基尼或低胸上衣的女人——这包括一张来自民主党国会女议员亚历山大·奥卡西奥-科尔特斯的头像照片。

显然，结果反映了图像数据库的内容。如果你要重复这个实验，但用的是奥斯卡典礼红地毯上的人的图像，人工智能肯定会得出结论，所有男人都打黑色领带，大多数女人喜欢暴露的裙子。对人工智能的任何使用都会反映这些偏见。

这告诉我们什么？这并不是说人工智能天生就有偏见，而是我们不能简单地依赖反映负责这些数据的人的偏见观点的数据。

ImageNet 和互联网都不能反映现实生活。人们在互联网上发布东西，无论是在 Flickr 上的图片，还是在脸书、Twitter、Instagram 或其他网站上的帖子，以激起人们的反应。虽然有一些人(好吧，很多人)试图产生负面影响，但在我看来，大多数人都是发布他们喜欢的东西。

它会认为保时捷比大众甲壳虫更像汽车

如果你训练一个人工智能从 Flickr 上的图片中识别汽车，你可能会发现它在识别福特野马方面比福特嘉年华更有信心；它会认为保时捷比大众甲壳虫更像汽车。

这是否意味着大多数汽车都是高端运动车型？不，当然不是。这种车的帖子比较多，是因为人们对它的印象比较深。

我再说一遍:互联网不能反映现实。因此，任何不加思考地基于其内容的人工智能也不会。或者，就此而言，任何由有缺陷的人(当然是我们所有人)编辑的信息。

在不同的背景下，路透社在 2018 年报道称，亚马逊已经放弃了一个人工智能招聘系统，因为它无法摆脱性别偏见。这种偏见来自以前招募的历史数据。情况正在好转，但在过去，技术和编程工作几乎完全由男性完成。因此，这些领域成功员工的特征之一就是他们是男性。

因此，当人工智能关注新的潜在雇员时，它偏爱男性

这并不是说女性不能同样出色地完成这些工作，而是她们没有在当时男性主导的行业中申请这些工作。因此，当人工智能关注新的潜在雇员时，它更青睐男性。

亚马逊解决这个问题的方法是尝试在求职申请中删除所有涉及性别的内容。但这被证明是一项不可能的任务，因为性别信息的线索可能隐藏在候选人个人资料的许多部分:他们上过的学校或大学，他们参加的运动，他们喜欢的爱好。

值得称赞的是，亚马逊认识到了这个问题，并试图解决它。如果有更多的最新信息，这种偏见或许可以避免。

因为不是说 AI 就不能不偏。检测癌症的机器学习算法是在已知是癌症的图像上训练的，因此偏差的可能性很小。不仅如此，这些图像还要由专家进行审查，所以是人类在人工智能的帮助下，对干预是否合适做出最终判断。

大概也是人类的判断导致了亚马逊招聘系统的失败。因此，使用真人作为最终决策者是解决人工智能不足的一种方法。

机器学习产生黑盒系统

另一个是交代。机器学习产生了黑盒系统，其决策过程对人类用户来说是不透明的。但是更新、更强大的系统可以为他们的决定提供解释，使用户能够理解他们的推理，或者允许他们的设计者修复任何错误。

因此，当数据是由人编制的，或者反映了不能完全公平和公正地依赖的人(换句话说，任何人)做出的历史决策时，问题就可能出现。

也许解决亚马逊问题的更好方法是编码更积极的女性数据——也许对新招聘的女性比年长的男性评价更高——而不是试图完全消除性别信息。至于男人和女人的形象建设，也许在训练前消除某些类型的形象是一个解决办法。

但也许最好的解决方案是将人工智能作为人类决策的辅助手段。也许让人工智能提高人类的表现并将其作为一种辅助手段而不是替代品更好——特别是当它能够更好地解释自己的时候。

数据科学家的算法—插入排序

原文：https://towardsdatascience.com/algorithms-for-data-scientists-insertion-sort-6caa69f906b3?source=collection_archive---------33-----------------------

你会学到的最简单的算法之一。

在 Unsplash 上拍摄的 ThisisEngineering RAEng

算法在计算和机器学习领域很常见。这篇文章很可能是 Medium 背后的内容推荐算法推荐给你的——一个 ll 欢呼 Medium 算法！

算法是技术的一种形式

更严重的是，算法驱动着社交媒体应用、谷歌搜索结果、银行系统以及更多。算法是技术的一种形式。最重要的是，数据科学家和机器学习实践者对分析、设计和实现标准和新颖的算法有一种直觉。

当应用于大规模计算任务时，有效的算法已经为公司节省了数百万美元，并且减少了内存和能量消耗。

这篇文章介绍了你可能遇到的最简单的算法。插入排序。

从这篇文章中可以期待什么:

  • 插入排序简介。
  • 对插入排序算法中涉及的操作的解释。
  • 插入排序算法在 python 中的实现
  • 提供了关于插入排序时间复杂度的信息。

插入排序说明

算法是一组指令，用于修改输入以产生期望的输出。

排序问题是数据科学家和其他编程学科遇到的典型编程任务。排序问题的主要任务是对一系列元素进行升序或降序排序。

照片由 Andrik Langfield 在 Unsplash 上拍摄

插入排序是排序问题的一种解决方案。通过考虑将一副牌按升序排列的方法，很容易描述插入是如何工作的。

在右边，你有一副面朝下的牌，在左边是一个初始的空白空间。第一张牌将在最初空着的左手空间，然后从右手堆中取出每张牌，与左手堆中的牌进行比较，以确定当前牌是否少于观察到的牌。

如果卡片不小于左侧被观察的卡片，则它留在当前位置。

本质上，本例中的左侧牌组始终是有序的。

下一节介绍正确插入排序的算法。一旦您对算法的工作原理有了直观的了解，后面的小节将展示插入排序算法是如何在 Python 中实现的。

算法描述

插入排序 GIF 。(该文件在知识共享协议下获得许可)

插入排序算法的工作方式类似于上面描述的一副牌的例子。该算法实际上将阵列分成左右两侧。分区左侧的元素是排序的，而右侧的元素不是。

在我们深入研究一些代码之前，下面是一个关于插入排序算法中涉及的操作的文本逐步信息，以升序对元素列表进行排序。

  1. 所有要排序的元素都放在一个列表或数组中。
  2. 从第一个元素到最后一个元素，遍历列表。
  3. 在每次迭代中，将引用的当前元素与其之前每个位置的元素(即左边的元素)进行比较。
  4. 如果引用的元素小于前面的任何元素，它将从初始位置移动一个位置。

Python 中的插入排序

下面的代码使用插入排序算法将一个无序列表排序为升序。

A = [3, 6, 2, 7, 2, 7, 1, 6, 3]for i in range(0, len(A)):
    key = A[i]
    j = i - 1
    while j >=0 and A[j] > key:
        A[j + 1] = A[j]
        j = j - 1
    A[j + 1] = key

print(A)
>> [1, 2, 2, 3, 3, 6, 6, 7, 7]
  1. 列表' A' 用无序数字序列初始化:[3，6，2，7，2，7，1，6，3]。
  2. 遍历列表‘A’，当前迭代(key)中引用的元素和前一个位置(j) 的索引都保存在变量中。
  3. 迭代的第一个实例(key)是 3，而(j)是-1。-1 不是列表的有效位置索引。为了确保运算中只考虑有效的索引，(j)必须大于或等于 0。
  4. 还需要比较当前引用的元素(key)和前一个元素(A[j])的值。
  5. 为了在当前迭代中遍历数组的左侧，使用了一个“ while ”循环。满足步骤 3 和 4 要求的完整 while 循环语句如下: while j > =0 和一个【j】>键
  6. 如果满足这些条件，则保存在前一个索引(A[j])处的元素被放置在其当前位置之前一个位置，即交换到右侧。 A[j + 1] = A[j]
  7. 变量(j)中保存的前一个元素的索引减少，表示虚拟向左移位。并且再次重复该过程，直到不再满足 while 循环条件。
  8. 如果当前值(key)大于 A[j]中引用的值，那么 key 从当前值(j)向上移动一个索引位置: A[j + 1] = key
  9. 对列表“A”中的每个元素重复整个操作，结果是一个按升序排序的列表。

复杂性和性能

插入排序 Gif (该文件在知识共享下获得许可)

使用大 O 符号，插入排序算法的时间复杂度为 O(n ) 。简单保留，最里面的语句执行两次(n*n)。

在列表已经按照期望的顺序排序的情况下，插入排序算法的时间复杂度为 O(n)。在这种情况下，只有一次迭代，并且没有执行内部循环中的操作。

插入排序通常适用于对小型列表或数组进行排序。然而，当面对包含更多元素的更大的列表时，有比插入排序算法更有效的算法可以使用。我将在以后的文章中探讨这些替代算法。

结论

插入排序是排序列表的最简单算法之一。这是一个简单的算法，可以用各种语言理解和实现。

对于一些机器学习从业者来说，回避算法的话题是典型的。算法的主题与复杂性相关联。

但就像计算和机器学习的所有学科领域一样，通过适当的资源、练习和时间，即使是最复杂的算法也很容易掌握。

感谢阅读。

</5-ways-to-provide-value-as-a-data-scientist-ce7bba57af02>

要联系我或找到更多类似本文的内容，请执行以下操作:

  1. 订阅我的 邮箱列表 获取每周简讯
  2. 跟我上 中
  3. 通过 LinkedIn 联系我

公平机器学习算法:导论

原文：https://towardsdatascience.com/algorithms-for-fair-machine-learning-an-introduction-2e428b7791f3?source=collection_archive---------21-----------------------

公平和偏见

三种类型的偏差缓解算法

由埃琳娜·莫日维洛在 Unsplash 上拍摄的照片

负责任的 ML 模型开发的一个关键组成部分是确保我们的模型不会不公平地伤害我们人口中的任何亚群体。第一步是识别和量化模型中的任何潜在偏差，人们已经提出了许多不同的群体公平性定义。在亚瑟公司，我们感兴趣的不仅仅是识别偏见，而是努力让模型更加公平。在这篇文章中，我们简要描述了偏差缓解技术家族:改善不公平模型的方法。

虽然这是一个活跃的研究领域，但当前的缓解技术针对模型开发生命周期的特定部分:

  • 训练数据的预处理或调整。
  • 处理中，或算法特别是为了公平。
  • 后处理，或调整模型的输出。

正确的解决方案可能取决于用例、行业和模型部署；在这篇文章中，我们概述了几种公平 ML 的方法。

为什么我们会观察到不公平的量词？

通常，我们会观察到不公平的分类器，因为用于训练模型的数据在某种程度上是“有偏见的”。正式描述“有偏数据”与“有偏模型”的关系是一项稍微复杂一些的任务。

学习模型中偏差的一个常见原因是数据中子群之间的不平衡。根据定义，如果我们有一个在训练数据中代表少数群体的子群体，那么这意味着与多数群体相比，我们对他们的观察更少。当分类器被训练时，它在整个数据集上优化损失函数。如果主要类别确实占主导地位，那么在训练数据上实现高总体准确性的最佳方式可能是在多数群体上尽可能准确，同时在少数群体上招致错误。

因此，如果多数群体和少数群体在属性和与目标变量的关系上有任何差异，模型很可能主要遵循主要数据的模式，并可能忽略少数群体的贡献。这可能意味着这个模型对于大多数群体来说是相当准确的，但是对于较小的群体来说就不那么准确了。

在其他情况下，偏差的产生是因为模型从数据集中编码的系统偏差中学习。。在“基础事实”结果与社会系统交叉的领域，如贷款履行、雇佣、刑事司法、住房等。数据可以对该系统内存在的歧视和偏见进行编码。例如，根据上世纪 60 年代的招聘数据训练的模型可能会表明，女性最适合做秘书，而不是高管。无论你选择哪种技术来改善这些选项中的偏差，都应该密切关注历史背景，通过它可以更好地理解数据收集实践和社会影响。

预处理偏差缓解

减轻偏差的预处理技术往往都与数据有关。如前一节所述，训练数据的特定特征可能直接导致学习模型的有问题的性能。由于这个原因，许多预处理技术集中于修改训练集以克服数据集版本的不平衡。

这可以通过多种方式实现，包括对数据行进行重新采样、对数据行进行重新加权、跨组翻转类标签以及省略敏感变量或代理。其他技术考虑学习实现期望的公平性约束的直接修改和变换函数。

在所有情况下，策略都是更改基础训练数据，然后使用任何所需的分类算法继续进行训练。通过以这些特定的方式修改训练数据，所学习的分类器的输出将更少偏差。

处理中偏差缓解

利用处理中技术，我们希望创建一个明确知道我们的公平目标的分类器。也就是说，在训练分类器时，仅仅优化训练数据的准确性是不够的。相反，我们修改损失函数来同时考虑我们的两个目标:我们的模型应该既准确又公平。

这种修改可以通过多种方式实现，比如使用对抗性 技术，确保底层表示是公平的，或者通过框定约束和规则化。在每种情况下，目标都是底层分类器直接考虑公平性。

因此，与对公平性一无所知的分类器相比，经过训练的分类器的结果将更少有偏差。

后处理偏差缓解

最后，有一系列技术旨在只调整模型的输出，而不改变底层分类器和数据。这里的好处在于它的简单性——在使用后处理方法时，我们允许模型开发团队使用他们希望的任何建模算法，他们不需要修改他们的算法或重新训练新的模型来使其更加公平。

相反，后处理方法的核心思想是调整不公平模型的输出，使最终输出变得公平。例如，该领域的早期工作集中在以组特定的方式修改结果和阈值。

假设我们建立一个分类模型来帮助信用风险决策。经过大量的超参数调整，我们得到了一个准确且概括良好的模型，但我们注意到它倾向于支持年长的贷款申请人而不是年轻的申请人。

利用后处理技术，我们将保持分类器不变，但是调整结果，使得总体接受率更加公平。我们会挑选一个公平的定义(比如说，人口统计均等)，然后调整不同组之间的待遇，以使最终结果符合预期。这意味着我们可能有特定于组的阈值，而不是用于分类器的单个阈值。

值得注意的是，在这种情况下，围绕偏见缓解仍有许多法律模糊之处。对于法院将如何处理算法歧视有如此多的未知，许多组织严重依赖他们的法律团队如何驾驭这种复杂性！

许多后处理技术都有这个共同的基本结构:它们不去管分类器和数据，只是以一种依赖于组的方式调整结果。虽然二元分类在过去一直是焦点，但最近的工作试图将这些想法扩展到回归模型以及。总体框架可以有效地实现 ML 系统中的公平性，尽管在某些用例中，区别对待不同的组可能是一个令人不舒服的提议，甚至是非法的。

公平和准确

当我们着手部署更加公平的 ML 模型时，我们必须承认这种公平不是免费的；事实上，在许多情况下，它可能会与模型准确性相冲突。

考虑一个极端:一个尽可能精确的模型(相对于现有的基本事实)可能是相当不公平的，并且歧视至少一个亚群。

考虑另一个极端:一个完全公平且对所有人群都公平的模型，这个模型肯定不如不考虑公平作为约束的模型准确。(尽管一些 最近的工作表明折衷不一定总是发生，但是“公平算法”在现实世界中部署时的行为并不总是与理论上证明的结果相匹配；因此，理解公平性和准确性之间的关系对我们选择使用的模型充满信心至关重要。)

在这两个极端之间存在着一个平衡准确性和公平性的可能模型的大家族。这组模型在准确性与公平性之间形成了一个帕累托边界(有效边界)。

下图来自 2019 年的一篇调查论文，描述了许多流行的公平 ML 算法的量化性能，说明了这种权衡。形象地说:我们想分享一个很好的图表，展示不同影响之间的权衡，衡量公平性，x 轴是不同影响，衡量公平性，而 y 轴是准确性。(整篇论文值得一读；它很好地介绍了公平 ML 模型性能的许多常见考虑因素。)作为实践者和利益相关者，我们必须面对关于这种权衡的问题:对于每一个用例，我们必须权衡通过不公平造成的潜在危害的成本和通过降低准确性造成的潜在危害的成本。

这些都是具有挑战性的问题，没有唯一正确的答案。相反，ML 从业者必须与利益相关者合作，如商业领袖、人文专家、合规和法律团队，并制定一个如何最好地对待你的人口的计划。更广泛地说，公平只是负责任地部署机器学习所需的一小部分:这篇文章应该是对话的开始，而不是结束。

背景#7 中的算法:决策树和阿尔法-贝塔剪枝

原文：https://towardsdatascience.com/algorithms-revisited-part-7-decision-trees-alpha-beta-pruning-9b711b6bf109?source=collection_archive---------23-----------------------

你的人工智能对手在机器学习之前是如何做决定的

由 Unsplash 上的 Pietro Jeng 拍摄

1997 年，IBM 的超级计算机“深蓝”在一场国际象棋比赛中击败了世界冠军加里·卡斯帕罗夫。人工智能历史上的一个标志性时刻，的确！在这一节中，我们将看到编写人工智能算法并不像在好莱坞电影中那样有趣。

决策树

想想任何双人棋盘游戏:国际象棋、西洋双陆棋，无论你喜欢什么...你和你的对手轮流，你们每个人都试图达到决定性的状态，你粉碎你的对手。在任何时候，你都有一套有限的移动，在每一步，你的目标是做出最好的移动。但这是人类玩游戏的方式，机器呢？

他们使用一种叫做决策树的东西。我们从一个根节点开始，它象征着游戏的当前状态。我们在那一点上的每一个可能的移动都将是那个节点的子节点。然后对于每个孩子，对手都有一套新的可能的行动。该树分支直到它覆盖游戏中的每一个可能的状态，并且当它到达一个叶节点时游戏结束。

最早的人工智能算法是基于在决策树上进行强力搜索。搜索算法试图到达使机器获胜的任何叶节点，并做出决定，以便它能够到达这些获胜节点之一。我们现在将看到这些算法中的一个在运行。

极大极小算法

现在把你自己从游戏中抽象出来，假设我们已经给游戏的每一个可能的结果分配了一个分数。分数被分配给树的叶节点。正分数表示机器赢了，负分数表示你赢了。所以，人工智能的目标是最大化分数，而你的目标是最小化分数。绿色箭头表示 AI(最大化者)的回合，红色箭头表示你的(最小化者)回合。

minimax 算法非常简单，它是深度优先搜索的修改版本。人工智能(绿色)将总是选择具有最大可能结果的移动，假设它的对手(红色)将总是选择最小可能结果。明智的做法是假设你的对手打得最好，这样你就可以做好最坏的打算。现在花一点时间，跟着树从底部到顶部，看看每个对手的举动。

你可以看到这个算法通过暴力搜索了所有可能的场景。如果我们假设 b 是分支因子 d 是决策树的深度，那么算法在 O(bᵈ) 哪个指数上起作用。

如果你正在实现一个井字游戏，这可能没那么糟糕。毕竟，第一回合有 9 种可能的走法，接下来是 8 种，7 种，以此类推，总共是 9 种！场景总数。然而，如果你正在做一个象棋游戏，可能性的数量将会以一个疯狂的数量增长！任何计算机要计算出所有的可能性都需要数百万年的时间。

需要我说一定有更好的方法吗？

阿尔法-贝塔剪枝

Alpha-beta 修剪是消除对解决方案没有帮助的分支的策略。我将用一个例子来解释这一点。下面树中的红线标记了我们搜索的当前状态。最大化器(AI)选择了 9 和 5，这是相应子树上的最大可达值。此时，极小值当前保持值 5，这是 9 和 5 中较小的一个。

还有一个分支需要搜索，深度优先搜索看到的第一个值是值 6。现在我们知道无论最大化者选择什么都至少是 6。但是我们也知道 minimizer 选择了 5，已经小于 6 了。在这一点上，我们不再需要检查剩余的孩子(1 和 7 ),因为我们肯定知道最小化将选择 5。

反过来也可能是正确的:如果最大化器已经选择了一个比最小化器选择的值更大的值，我们就不需要搜索其余的子树。在下面的树中，最大化器已经在根节点选择了 5。因为-2 小于 5，并且最小化器选择的任何东西最多是-2，所以我们不再需要搜索其余的子树。

所以继续吧，把这个策略应用到你的整个搜索中，从决策树中剔除 c**p。在最右边还有最后一个子树可以删除，我把它留给你来检查为什么我们可以跳过它。阿尔法-贝塔修剪算法的最终结果应该是这样的:

我们把树修剪了不少。Alpha-beta 修剪可以提供高达原始 minimax 算法的性能的平方根的性能优化。它也可能根本没有提供性能改进，这取决于你有多倒霉。

深度受限搜索

即使 alpha-beta 修剪提供了大量的性能改进，搜索整个可能的场景集仍然是多余的。我们可以采用智能策略来避免搜索整个树，并且仍然可以得到非常好的结果。

一种这样的策略是深度受限搜索，它听起来确实如此。不是搜索整个树，而是在预先定义的有限深度内搜索。例如，您可以在国际象棋中搜索下 5 步棋。但是为了做到这一点，你需要一种确定性的方法来对游戏的当前状态进行评分，因为当你到达搜索的终点时，你不再知道谁赢得了游戏。为此，我们将使用一个评估函数。

注意:深度受限搜索还有其他选择，比如迭代深化，但为了保持故事简短，我不喜欢包括它们。

你的搜索有多深入？明白了吗？那是个玩笑…

评估功能

所以，你决定将你的搜索限制在你和你的对手在游戏中的下 5 步棋。然后你意识到大部分时间游戏在 5 步之后仍然继续，你现在卡在这个中间步骤。你如何把数字输入到极大极小算法中？你需要的是一个评价函数。

一个评估函数是一种确定性地给游戏的当前状态打分的方法。例如，如果你在下棋，评估函数可以是你和你的对手拥有的棋子数量之间的数字差。差距越大，你的机会就越大。

一个更好的评估函数可以使用加权计算，其中每个部分都有一个取决于其重要性的权重。这可能会产生比简单地计数更好的结果。更好的是，除了它们的重量之外，还可以使用棋盘上的位置。

你如何定义你的评价函数完全取决于你自己。请注意，这将是你的算法中最关键的部分。你的评价函数有多好决定了游戏的状态，会很大程度上影响你算法的成功。当你写一个评估函数的时候，还有两件事你应该小心:

  1. 函数应该是确定性的:给定相同的状态，应该总是产生相同的结果。
  2. 函数应该运行得很快:您将会对您的评估函数进行很多调用。如果它工作缓慢，那么你的人工智能就会反应缓慢。

这是深度受限的极大极小算法的伪代码:

int minimax(Node* current, int depth, bool isMaximizer) { if (depth == DEPTH_LIMIT || current.isLeaf()) {
        return evaluate(current);
    } if (isMaximizer) { int val = INT_MIN;
        for (Node* child : current.getChildren()) {
            val = max(val, minimax(child, depth + 1, false));
        } return val; } else { int val = INT_MAX;
        for (Node* child : current.getChildren()) {
            val = min(val, minimax(child, depth + 1, true));
        } return val;
    }
}

加上α-β修剪，我们得到这样的结果:

int minimax(..., **int alpha, int beta**) { ... if (isMaximizer) { int val = INT_MIN;
        for (Node* child : current.getChildren()) {
            val = max(val, minimax(..., **alpha, beta**));
            **alpha = max(alpha, val);
            if (alpha >= beta) {
                break;
            }
**        } return val; } else { int val = INT_MAX;
        for (Node* child : current.getChildren()) {
            val = min(val, minimax(..., **alpha, beta**));
            **beta = min(beta, val);
            if (beta <= alpha) {
                break;
            }** } return val;
    }
}

我还有一个改进的建议。在您的搜索中，算法很可能会一次又一次地出现相同的状态。因此，您可以使用一个查找表来存储结果，而不是多次运行评估函数。见鬼，你甚至可以预先计算所有可能的结果。如果你想了解这个策略，你可以阅读我之前关于动态编程的故事。

你知道好莱坞电影中那些帅气的科学家走过一个长长的大厅，发表魅力演讲，讲述他们如何取得科学突破，并能用几句话向警察局长解释吗？是啊，那不是真的。事实上，有畸形的身体，没有生命的眼睛，彼此之间有沟通问题。当然除了我…

在人工智能应用中调整价值观

原文：https://towardsdatascience.com/aligning-values-in-ai-applications-afc9b814c000?source=collection_archive---------41-----------------------

最成功的人工智能系统与其用户、创造者和整个社会的价值观是一致的。

人工智能(AI)无处不在。当你使用互联网或一般计算机时，你会(有时不知不觉地)与数十个使用某种形式人工智能的系统互动。当你浏览网页时，广告网络为你提供个性化的广告，你的电话纠正你的拼写，你计算机的操作系统决定哪些程序优先使用计算资源。有些系统很好，有些不太好。我相信最成功的人工智能应用程序都有三方一致的价值观。

人工智能造福社会(图片由作者提供)

  1. 与系统互动的人，
  2. 这个系统的创造者，
  3. 所有者和参与者生活的社会。

所有的人工智能应用都或多或少地与这三组不同的价值观保持一致。我将简要阐述值集是什么，给出有不匹配的 AI 应用程序的例子，并以所有值都一致的例子结束。

三套价值观

与系统互动者的价值观

不同类型的人与人工智能系统交互，人工智能系统对他们的影响也不同。人们的理解水平和价值观各不相同。你可以肯定，与你的人工智能应用程序交互的人有一些价值观，从非常基本的价值观，比如发现能够养活自己和/或家人很重要。或者更复杂，比如发现有一个宽泛的参照系很重要。无论哪种方式，你的系统提供给他们的东西都会对他们追求价值的程度产生影响。

此外，人们可能或多或少地自愿与系统交互。他们不一定选择与一个系统互动，甚至可能没有意识地与它互动。一家银行开发了一个自动评估贷款申请的人工智能应用程序，迫使客户和员工都与它进行交互。人们可能没有意识到推荐系统会影响他们所呈现的内容，而这些内容会受到他们过去观看行为的影响。

人工智能系统可能会影响他们的价值观。贷款申请评估系统决定了人们是否会得到贷款。推荐系统影响他们接触的内容。

系统创造者的价值观

任何一方部署人工智能应用程序，无论出于何种原因，无论是服务于他们的客户群还是改善内部流程，都是基于一套价值观。这些可能非常琐碎，比如增加收入或降低成本。他们可能更无私，比如不浪费资源。或者，它们甚至可能是非常规范的，例如促进改善生活质量的健康生活方式。人工智能应用程序的目标是使部署系统的一方达到来自其价值观的目标。特别是对于推荐系统，对同时追求多个目标的系统的研究已经开始。一个系统可以增加人们观看或购买的视频数量，同时提供一个多样化的、广泛的参考框架。

部署应用程序的社会的价值观

现在，部署系统的一方和与系统互动的个人都是社会的一部分。这可能是国家层面的，但越来越多的是在全球社会中。现在一个社会也有价值观。法律和立法捕捉或正式化了这些价值观的一部分，而其他的价值观则稍微含蓄一些。例如，荷兰法律规定了广告商可以和不可以宣称什么来保护荷兰人免受欺骗。荷兰政府监察机构 Reclame Code Commissie 对此进行控制。另一方面，道德行为准则规定记者或编辑委员会在报道时应如何提供信息。虽然不符合他们的道德准则，但没有法律阻止他们不遵守这一准则。

使配合不当

有很多人工智能不成功的例子，因为不是所有的价值观都是一致的。上图提供了值之间只有部分匹配的 AI 应用程序的示例。

为创造者和个人服务的系统。

推荐系统是人工智能应用的例子，它符合个人和部署方的价值观。就我个人而言，我对 YouTube 和它为我创造的漂亮的循环过滤泡泡非常满意。我可以无休止地观看高度相关和令人愉快的骑行视频，完全符合我的个人喜好。我看视频，YouTube 可以给我看广告。双赢！然而，从社会的角度来看，我把所有的时间都花在看骑行视频上是不理想的，因为我也可以看新闻或其他话题，让自己得到更多的发展。如果我把时间花在看别的东西上，社会和我自己不会受益吗？

为造物主和社会服务的系统。

也有符合部署方及社会价值观的应用。虽然不是严格意义上的人工智能应用，但几年来，所有网站(应该)都要求我们同意通过 cookies 跟踪我们的行为。这完全符合部署方的价值观:他们没有支付罚款的风险，他们被允许使用我们的数据。这也符合我们的社会价值观:每个社会成员都拥有自己数据的所有权。但这符合我们作为公民的价值观吗？我们想拥有这种所有权吗？我们想被迫同意或拒绝同意吗？我个人重视毫不费力地浏览互联网，我不喜欢点击这种对我隐私的额外控制。法律的实施根本不能满足这一要求。

为社会和个人服务的系统。

我真的想不出这样的例子，这有什么意义，因为什么样的政党/组织会部署一个符合社会和个人，但不符合其自身价值观的系统？如果我们稍微搜索一下，可能会有一些例子，但我想这些例子不会存在很长时间，因为在某个时候部署方会拔掉这些例子的插头。

当所有三组值对齐时

在我读博士期间，我们也试图达到一致。在我们关于推荐系统中的选择过载的工作中，我们设计并测试了一个多样化算法来降低选择难度。当我们向用户提供一系列建议时，我们迫使他们做出决定。这个决定可能更容易，也可能更困难。我们的目标是创建易于选择的推荐列表，同时保持或提高满意度。通过大量研究，我们展示了增加推荐集多样性的效果，同时保持预测的相关性不变。这个想法是用户应该有满意的结果，但是从中选择不应该花费不必要的选择难度。然而，我们确实忽略了社会价值观。

一些系统将所有三组值对齐。这些系统的一个名字是 AI for Social Good (AI4SG ),这个运动正在通过学术研讨会、期刊、平台、LinkedIn 团体、博客获得越来越多的动力。也许并不奇怪，大多数 NGO 都在积极开发 AI4SG，例如通过使用机器学习来打击偷猎。

那么，我们应该以什么为目标，又该如何实现呢？我不完全确定，但我 100%确信，无论我们在人工智能领域做什么，我们都必须开始沿着这三套价值观评估我们的举措。你有一个能让公司收入增加 20%的主意？酷！现在，去看看这个倡议与那些将与你的系统互动的人是如何一致的，以及社会将如何看待你的想法。你能确定你的想法会导致的结果符合你自己的价值观，与它互动的人的价值观，以及你将部署你的系统的社会所持有的价值观吗？那就去争取吧！否则，细化修改。我个人将确保我在 Obvion 的数据科学团队将对所有人工智能计划进行这些评估。我认为永远不出现任何不匹配是不现实的，但至少我们可以将任何无意识、无意的不匹配的可能性降至最低。

在实践中调整价值观

在我目前的角色中，我们正在创造人工智能。在早先的一篇文章中，我描述了我将如何尝试以一种对价值敏感的方式来做这件事，通过开发和部署人工智能，同时沿着两条轴线前进。我们成长的第一个方向是决策支持与自动化。我们将从为决策提供信息的模型开始，而不是自动决策。经理们最初可以使用预测贷款申请数量的模型来确保有足够的员工来处理这些申请。这种型号以后可以自动增加或减少容量。然而，这只有在经历了如何使用预测之后才会发生。其次，我们将从影响我们内部流程和利益相关者的人工智能开始，然后向外发展，到影响顾问和客户的人工智能。这也是为了确保我们可以实际检查我们的努力在多大程度上符合那些受我们人工智能影响的人的价值观。

原载于 2021 年 9 月 27 日【https://markgraus.net】。

关于大数据的一切

原文：https://towardsdatascience.com/all-about-big-data-ae01afacc081?source=collection_archive---------21-----------------------

深入探讨什么是大数据以及如何存储大数据

约书亚·索蒂诺在 Unsplash 上拍摄的照片

在我最近的一篇文章中，我列出了一系列常见的数据科学术语，并对它们进行了简要描述。在列表中，我提到了大数据。但即使只是描述大数据的术语，也不足以描绘出数据究竟是如何存储的清晰画面。大数据被认为是太大而无法存储在单台计算机上的数据。但是，这些数据究竟是如何存储的呢？

本文的目标是了解关于大数据的更多信息，它是如何定义的，以及它存储在哪里。我们还将非常简要地讨论如何处理数据，尽管这可能是一个单独的主题。

什么是大数据？

如果您的数据太大，无法存储在单台计算机上，数据可能会快速增长，或者使用任何传统方法处理起来太困难或太耗时，那么您就拥有了大数据。随着结构化或非结构化数据集多样性的增长，数据的流入也可能是不可预测的。无论是从复杂性还是从数量上来看，大数据都难以用标准方法处理。例如，处理 SELECT 语句可能需要几天甚至几周，而不是几秒钟/几分钟。

因为数据太大，无法存储和处理，所以大数据在存储中的处理方式不同。大数据的一个存储位置是数据仓库，而不是计算机上的数据库。

什么是数据仓库？

为了存储和处理大量数据，数据仓库是数据存储的中心点。它是一个允许数据流入单一来源的系统，支持分析、数据挖掘、机器学习等。虽然它的目标是在一个位置存储数据，但不是在一台计算机上，另一个目标是处理数据。这从使用 ETL(提取、转换、加载)进行处理的数据管道开始。仓库收集数据，并以可用的方式对其进行格式化。无论数据来自哪里，它都是原始数据，可以被处理成有用的东西。

数据仓库处理大量的旧数据或新数据。但是，它存储的数据必须是结构化的。然后，可以将数据组织成模式，以供以后分析。

如上所述，数据仓库通常建立在结构化数据的基础上，并且通常使用关系数据库来保存数据。但是，如果数据是非结构化的，不适合关系数据库模型，该怎么办呢？这就是数据湖的由来。

数据一旦存储，就可以进行处理。这通常在处理系统中单独完成。处理需要单独进行，因为数据量，甚至其复杂性，对底层计算基础设施提出了很高的要求。在许多情况下，处理是在云中执行的。

什么是数据湖？

当数据是非结构化甚至不相关时，可以使用数据湖。数据湖存储没有定义模式的数据，因此数据不能存储在关系数据库中。但这并不意味着数据湖不能处理数据。数据湖可以创建各种可视化、实时分析等，但首先需要结构化数据。就像仓库一样，它是一个集中的存储场所，可以由多个来源提供信息。原始数据被存储起来供以后处理，但是数据湖可以简单地存储数据而不进行任何整理，而不是构造和添加模式。因为数据不需要结构化，所以它是高度可伸缩的，因为它可以容纳更多种类的数据。

回到模式，我们刚刚提到，您不需要创建任何模式来容纳数据，因为它不需要结构化。然而，模式仍然是数据湖的一部分。它们只是使用方式不同而已。例如，数据仓库将数据清理和过滤到模式中，这些模式是在预处理数据之前设计的。这被认为是写模式。有了数据湖，你就不用提前设计模式了。相反，模式是在分析数据时创建的。这被认为是读取模式。

为了存储数据，可以使用几种不同的存储设备。可以考虑云存储。如果需要数据库，数据湖使用非结构化或非关系模型，如 NoSQL 数据库。数据湖也可以存在于 Hadoop 集群等设备上。Hadoop 集群使用一系列称为节点的计算机，它们通过网络连接在一起。有一个主节点连接到剩余的节点(或工作节点),根据该节点的可用性分配任务。这允许在更大的数据集上进行并行计算。

您为数据湖选择的系统总是有可能不够用。这就是为什么数据湖可以与使用分布式体系结构的多个系统相结合。在这种情况下，数据湖将是存储和处理的集中点，但可以与其他平台分支。这可以是从多种存储类型到包括关系数据库和/或数据仓库的任何地方。尽管数据湖允许流入的数据保持其原始形式供以后处理，但您也可以选择使用不同的数据挖掘工具或数据准备软件进行预处理。

数据湖中的处理与数据仓库中的处理非常相似。两者的数据都太大，无法正常处理，因为这对底层基础架构的要求太高。值得注意的是，Hadoop 引擎还具有处理数据的能力。

结论

在本文中，我们深入探讨了大数据。我们定义了什么是大数据，以及如果大数据不能存储在单台计算机上，剩余的数据存储在哪里。在这个过程中，我们对什么是数据仓库有了更多的了解。我们还定义了什么是数据湖，以及如何在使用这种类型的流程中存储非结构化数据。

虽然没有详细介绍处理过程，但我们更关注什么是数据仓库，什么是数据湖。即使对 Hadoop 有一点了解，尽管不是很广泛。我希望你觉得这篇文章很有趣，也希望你能像我一样学到一些新东西。请随意留下您处理大数据的首选方法或您使用的存储类型的评论。下次见，干杯！

用我的 每周简讯 免费阅读我的所有文章，谢谢！

想阅读介质上的所有文章？成为中等 成员 今天！

看看我最近的一些文章:

https://python.plainenglish.io/i-suck-at-coding-cb9bc7ef6c06 https://python.plainenglish.io/arrays-vs-list-vs-dictionaries-47058fa19d4e https://python.plainenglish.io/converting-a-cli-app-to-typer-6c7462f5a9ff https://medium.com/codex/something-i-learned-this-week-entity-framework-is-picky-about-primary-keys-b5d7642c9ab7

参考资料:

https://aws.amazon.com/big-data/datalakes-and-analytics/what-is-a-data-lake/ https://www.ibm.com/analytics https://searchdatamanagement.techtarget.com/definition/big-data https://databricks.com/glossary/hadoop-cluster

关于 Deepfakes 的一切

原文：https://towardsdatascience.com/all-about-deepfakes-e481a55cf7e5?source=collection_archive---------24-----------------------

什么是 deepfake，它在当今世界有多“真实”？

约翰·努南在 Unsplash 上拍摄的照片

自从我一头扎进数据科学的世界已经有一段时间了。因此，在进行我的标准搜索时，我想看看哪些术语出现得更频繁，以及有哪些趋势值得关注。我注意到有一个术语出现得越来越多，那就是 deepfakes。我对什么是 deepfakes 有一个大致的概念，但在它们上面似乎有一些分歧。一些人认为它可能是破坏性的，另一些人认为它可能是无害的。很多人认为我们在技术上仍然落后很多年，所以它在很多年内都不会真正被看到，然而无论我们是否意识到，都有一些深度造假的例子已经持续了很多年。

这篇文章的目标是学习什么是 deepfake 以及它们现在是如何被使用的。这将是有益的，尽管我可能会分享一些故事或观点，但我无意试图说服您对该技术进行这样或那样的思考。在本文的最后，欢迎在评论中分享你的个人观点或经历。我期待着阅读它们。

但是没有任何进一步的延迟，让我们开始了解什么是 deepfake。

什么是 deepfake？

诚然，deepfakes 比我最初打算的要宽泛一点，所以一个清晰的定义有点难以挖掘。在更简短的定义中，deepfakes 是视频或照片被修改以包含其他人的肖像的实例。这是源于 AI(人工智能)的技术。

但我知道这听起来很模糊，所以让我们再深入一点。根据我的理解，从我看到的使用情况来看(不是说这可能是唯一的例子)，deepfakes 是指你拍摄一个已经存在的视频或声音剪辑，然后把脸、声音或两者都换成别人。你在伪造版本中看到的不是真实的，并且会改变片段的上下文。这就是事情变得复杂的地方。这些视频的意图可能有点不清楚，或者海报的总体目标可以通过一个案例场景来改变。

当分解时，假的指的是剪辑不再是真实的，因为它们被从现实中操纵。然而，deep 可以指简短但仍然列出的各种会议。我的意思是，深度可以指变化的复杂性。然而，它也可以指强度。也许，这甚至意味着制造深度赝品的难度。

说到难度，制作一个深假需要什么？现在，对于用户来说，工作量可能会有所不同。例如，某些 Snapchat 滤镜会改变一个人的面部。我指的不是应用程序调整的面部，而是将你变成不同的人、角色甚至食物的特定过滤器。在这种情况下，改变你的脸对用户来说非常容易，尽管这并不令人信服。其他应用程序允许你根据另一个人的参考照片记录自己，但如果你稍微向左或向右移动头部，照片就不会向右伸展，这是一个非常明显的假货。然而，一些更真实的 deepfakes 需要机器学习和神经网络的混合。根据我们对机器学习和神经网络的了解，这将是一项非常困难的任务，更不用说耗时了。然而，这创建了更真实的图像，尤其是使用了更多的参考照片。

深度假货的例子

一个更真实的例子是抖音。在这个应用上，有一个用户假装成汤姆·克鲁斯(目前不在抖音)。现在，他不再诽谤甚至谈论今天的任何问题。相反，这些视频更多的是展示这项技术能做什么。其中一个视频只是关于吃的，它显示了当有数百万张照片供机器学习时，日常行为看起来有多真实。名人比普通人要容易得多，因为有更多的内容可以参考。

我还提到了 Snapchat 等不太现实的人脸交换应用。但这不是唯一的一个。在脸书上，你可以把你的脸加到一些电影角色上，这样你就可以在他们提供的任何场景中看到自己。它很简短，看起来不太真实，但是你的脸被融合到你从他们的列表中选择的一个角色上。

但这应该会让你想到 deepfakes 的意图。在你判断某件事是“不道德的”、“邪恶的”，或者甚至是“好的”和“创新的”之前，你需要考虑 deepfakes 的意图。当然，并不是所有人都有同样的意图。事情就是这样。但是，在你对这项技术做出最终判断之前，也许我们也应该考虑到这一点。

Deepfakes，他们邪恶吗？有创意？两者都有？

没有简单的方法让我们从创造性的一面开始，这并不坏。在我之前的例子中，他们都可以被视为只是有创意或有乐趣。使用一个有趣的过滤器并没有什么不好。Catfishing 是另一个故事，但我们假设如果你要做一个真正的 deepfake，它很可能是一个假的。把你的脸贴在你最喜欢的角色身上并不“邪恶”，这只是有点好玩。所以，在这种情况下，deepfakes 没有任何问题。

现在，有一些更现实的版本，如我们谈到的抖音汤姆克鲁斯，但帐户明确表示，他们的意图只是为了炫耀技术。因为他不是用它来影响，更多的是为了教育和娱乐的目的，所以在这种情况下，也不存在不道德的使用。

不幸的是，deepfakes 有一些“邪恶”或不道德的用法。例如，不用说太粗糙的话，有些人会把一个名人的脸伪装成一个不合适的身体，比如制作那个名人的虚假成人内容。尤其是如果那个名人选择不露出太多的皮肤，即使这是一个假的身体，这仍然是不道德的，通常只是出于自私或不适当的目的。

现在，我们最初谈论一个视频的意图。但如果目的是制造虚假信息或观点呢？例如，如果一些极端的政治观点被分享，然后有人把一个候选人伪造到那个极端的程度，只需要一个人相信这是真的就会导致诽谤。这是不道德的，也是一种诽谤。从伦理上讲，这将是不支持 deepfakes 的充分理由。然而，就目前而言，至少对普通大众而言，制作出足够真实的东西，让人们相信它毫无疑问是真实的，可能是遥不可及的。

deepfakes 还是新用的吗？

在我为获取资源而阅读的一些文章中，我注意到一个共同的趋势，即人们似乎认为技术还没有为 deepfakes 做好准备。他们可能指的是普通人还不能创造一个真实的深度赝品。但是对于那些认为它没有被使用的人来说，我认为这是不正确的。问问迷因社区就知道了。Deepfakes 用于制作我们在日常环境中发送给朋友的 memes、帖子或照片。他们可能看起来不太现实，但仍然，他们正在变得更好。不幸的是，成人内容中的名人头像在今天也是非常真实的，这些照片经常被修改以看起来更真实。你通常仍能分辨出它们是假的，但要区分起来要困难得多。现在，我们还没有普遍使用它来获得关于人们的错误信息或诽谤，这可能是他们所指的，或者至少它看起来很真实，但我们不知道诽谤将是主要用途。总会有人出于错误的原因使用技术，但这并不代表大多数人。

结论

最后，你应该做出你的结论，你是否认为 deepfakes 可以用于娱乐，或者它们是否会导致更不道德的道路。我们了解到 deepfake 是一种人工智能形式，它采用现有的剪辑，并交换诸如面部等事物。这就产生了一个视频的假版本。通常情况下，赝品看起来不太真实，但情况并非总是如此。技术、机器学习和神经网络可以用来创建更真实的假货版本，直到你剩下一个很难从现实中分辨出来的产品。

deepfake 的意图取决于人。有的用 deepfakes 来娱乐，有的用来教育，但有的也可能为自己的假货选择不道德的路线。在本文中，我们在定义了 deepfakes 之后介绍了几个例子。我们的目标只是简单地了解它们是什么，并举例帮助你熟悉识别一个深层次的假货，但不是说服你。你可能会对 deepfakes 做出判断，但很多人说技术还没有为逼真的假货做好准备，也许现在知道还为时过早。欢迎在评论中分享你对 deepfakes 的想法或你见过的例子。下次见，干杯！

用我的 每周简讯 免费阅读我的所有文章，谢谢！

想阅读介质上的所有文章？成为中等 成员 今天！

查看我最近的一些文章

https://medium.com/codex/quitting-kubernetes-kubeadm-and-switching-to-microk8s-b487e2abd482 https://miketechgame.medium.com/leaving-your-job-for-selfish-reasons-af1060ea51bf https://python.plainenglish.io/video-editing-with-python-73d419ba93ae https://medium.com/codex/kubernetes-vs-docker-swarm-d209e7cd58d7

参考资料:

https://www.merriam-webster.com/words-at-play/deepfake-slang-definition-examples https://us.norton.com/internetsecurity-emerging-threats-what-are-deepfakes.html https://www.technologyreview.com/2020/08/28/1007746/ai-deepfakes-memes/

提高不平衡机器学习分类器的性能

原文：https://towardsdatascience.com/all-about-imbalanced-machine-learning-classifiers-60563014d2b3?source=collection_archive---------13-----------------------

机器学习。数据科学。PYTHON。

处理不平衡数据集的综合指南

简介

作为一名菜鸟数据科学家，我犯的一个错误是高度重视准确性指标。现在，这并不是要否定准确性作为机器学习(ML)性能衡量标准的重要性。在某些模型中，我们的目标是具有高精度。毕竟，这个指标是高管和商业领袖最了解的。

但是，让我给你一个现实生活中的场景，当这样的指标可能会误导:

“你在一家成功的金融科技公司工作。你的老板给你一个识别欺诈性金融交易的模型。

用你的分类算法知识武装起来，你设计并实现了一个返回高达 98%准确率的算法。你的推销很成功，管理层对你这么快就想出这个模型印象深刻。

为了确保万无一失，他们希望你用真实世界的数据来尝试一下(实际上这是一个很常见的请求):一个用于欺诈性交易，一个用于非欺诈性交易， 都来自你的训练数据集 。令您惊讶的是:对于这两种情况，您的分类器都返回了 【非欺诈】 。这是怎么发生的？

您进行了调查，并了解到您使用的训练数据集包含 98%的非欺诈性交易和 2%的欺诈性交易(顺便说一句，这应该在探索性数据分析部分完成)”

直观地说，事情是这样的:因为数据集严重不平衡，而你的评分标准是“准确性”，它知道通过总是返回“非欺诈性”，它将总是有 98%的机会获得正确答案。

照片由 Alex Block 在 Unsplash 上拍摄

在分类机器学习(ML)模型的上下文中，不平衡数据集指的是数据不均匀分布在它所具有的类中的数据集。例如，在两个类的分类模型中，平衡数据集是指每个类在训练数据集中有五十(50%)个观察值。其他任何比例都是不平衡的。

在上面的示例中，我们称之为严重不平衡，因为与其他类(也称为多数类)相比，属于其他类(我们称之为少数类)的数据集比例非常小。

像我们例子中这样的不平衡数据集比你想象的更常见，也更重要。由于大多数数据科学家可能会在工作中处理它们，让我们概述一下我们可以做些什么来提高我们的不平衡数据集模型的性能。

对于下面的文章，我们将有一个直观的和理论的(数学讨论)，我们将讨论一些代码。我们将以这种方式组织它，这样读者可以直接跳到他们最感兴趣的部分。

概要

为了让读者有机会跳到相关部分，下面是本文的大纲。

  1. 关于“原始”分类器方法的统计解释和直觉
  2. 适当的补救措施

对于适当的补救措施:我们将讨论以下内容

  1. 使用适当的指标
  2. 设定一个新的门槛:如何选择合适的门槛？
  3. 收集更多数据
  4. 扩充数据集和欠采样
  5. 重新思考模型的特征
  6. 方法(集合方法)

朴素分类器的统计理解

为了我们讨论的目的，让我们把我们在介绍中开发的分类器称为“简单分类器”。朴素分类器(与朴素贝叶斯分类器不同)之所以被称为朴素分类器，是因为它在产生或标记输出时过分简化了假设。

这方面的一个例子是总是预测多数类的分类器或总是预测少数类的分类器。另一种是从一组输出中随机猜测的分类器。

在上面的例子中，由于分类器总是输出多数类，所以这是一个简单分类器的例子。

我们直观地注意到，通过将准确性设置为性能度量，模型了解到通过总是返回多数类，它可以提供高准确性。

但是让我们试着用统计数据来理解为什么模型会有这样的反应。(这个借用了本 帖 中的理论解释。)

编码—信用评分数据集

让我们使用哈佛大学的信用评分数据，这样我们就可以有一个具体的例子。

在使用的一个数据集中，我们分析了违约和非违约借款人的贷款金额分布。多数类属于非默认值(默认值== 0)，少数类属于默认值(默认值== 1)。

让我们保持简单，只观察一维密度，因为直觉适用于更高维度。

#Individual Densities
fig,ax = plt.subplots(figsize=(10,12))
sns.kdeplot(df4[df4.default == 0]['total_inst_due'], color='#966fd6', linestyle="--")
sns.kdeplot(df4[df4.default == 1]['total_inst_due'],c='#900603', linestyle="--")fig.legend(labels=['p(x given Default == 0)p(Default == 0)','p(x given Default == 1)p(Default == 1)'])
plt.savefig("Individual Density.png")

违约与非违约的独立概率。(又名边际密度)。

从上图中，我们可以看到，就贷款金额而言，客户违约或未违约的概率遵循几乎相同的分布。

这将是有意义的，因为违约和非违约借款人都经历了相同的筛选过程，从这一逻辑出发，可以认为他们属于同质群体。这可能是也可能不是，取决于数据集和所讨论的变量。

但是，假设我们想要查看分类器输入特定类的概率，例如，它将为给定数据集输出“非默认”的概率。

为了解决这个问题，我们求助于贝叶斯定理中的全概率法则，并使用它们的联合密度来可视化这些类:

贝叶斯定理中的全概率定律应用于我们的例子。

如果我们考虑比例(也称为联合概率密度)并将其可视化，我们会得到以下结果:

#Joint-Densities
fig,ax = plt.subplots(figsize=(10,12))
sns.kdeplot(data = df4, x ='total_inst_due', hue='default',alpha =0.1, shade=True, legend=False)
fig.legend(labels=['p(Default == 0)','p(Default == 1)'])
plt.savefig("Joint-Density Plots.png")

联合密度图。

基于上面的密度图，我们看到，对于变量 x 的所有实例，属于多数类(非违约借款人)的图高于少数类的图。

这意味着:

简单来说，假设借款人没有违约，x 发生的概率总是大于借款人违约的概率。

因此，对于基于概率做出输出决策的分类器来说，总是预测多数类是很有意义的。

下图综合了上述所有图，便于参考:

#Combined Density Plots
fig,ax = plt.subplots(figsize=(10,12))
sns.kdeplot(df4[df4.default == 0]['total_inst_due'], color='#966fd6', linestyle="--")
sns.kdeplot(df4[df4.default == 1]['total_inst_due'],c='#900603', linestyle="--")
sns.kdeplot(data = df4, x ='total_inst_due', hue='default',alpha =0.1, shade=True, legend=False)fig.legend(labels=['p(x given Default == 0)p(Default == 0)','p(x given Default == 1)p(Default == 1)','p(Default == 0)','p(Default == 1)'])
plt.show()

便于参考的组合密度图。

如果各个阶层的人口差异很大怎么办？

假设类的个体密度显著不同。也就是说，不像在我们的信用决策数据集中，绘制它们显示人口有最小的重叠。

为了形象化这一点，让我们使用 seaborn 的虹膜数据集。

iris = sns.load_dataset('iris')

假设我们关心的是开发一个只能分类两个物种的分类器: setosa 和 versicolor ，并且我们的数据集是不平衡的。

要查看单个(边缘)密度:

fig,ax = plt.subplots(figsize=(10,10))
sns.kdeplot(data = iris[iris.species.isin(['setosa', 'versicolor'])], 
            x ='petal_length', hue='species',alpha =0.1, shade=True, legend=False)#legend labels follow the order of plots according to the codes executed
fig.legend(labels=['P(species = setosa)', 'P(species = versicolor)'])plt.savefig("Iris.png")

一维——两个类别的个体密度:Setosa 和 Versicolor

因为个体密度彼此显著不同，我们将开发的分类器模型，即使它们不平衡，也不一定只预测多数类。

使用适当的指标

评估分类器性能的最常用方法之一是使用混淆矩阵。简单地说，混淆矩阵告诉我们，我们的模型在预测和识别数据集中的类时表现如何。从混淆矩阵中，我们可以推导出我们可以使用的多个度量标准。

为了便于理解，让我们定义将在公式中使用的因子。

将在指标公式中使用的变量的定义。在某些材料中，正类和负类被概括为 1 类和 2 类。

为了容易记住公式，只需知道第一个词(对或错)指的是预测的正确性，第二个词是预测的内容。

因此，混淆矩阵可以被形象化为:

我们使用 1 类和 2 类作为一般术语，但也可以称为“积极与消极类”，在我们的情况下，“多数与少数”类。

使用彩色块的分类度量。为了容易记住这一点，要知道对于任何类的精度和召回率，分子总是该类的“真正值”。现在对于分母，我通常认为对于“精度”，分母以字母“P”开始，因此是“类的预测”。(精确度听起来也更接近预测)。因此，通过排除过程，回忆在分母中具有该类别的“实际”。

回想一下，准确性告诉我们我们的模型获得了多少正确的预测。所以，通过正确，我们需要所有开头带“真”字的都是分子。

在这种情况下，我们使用“积极的”和“消极的”，但它们可以被称为“多数”对“少数”或更一般的“1 类”和“2 类”。注意，这里的分母只是预测的总数(N)。

所以这对于不平衡的类来说不理想的一个原因是，分子总是有一个高的 TP。

为了形象化，让我们试着为我们的信用决策示例编码并绘制一个混淆矩阵:

#Plotting for the ANN model
plot_confusion_matrix(mlp, X_test, y_test)  
plt.show()

信用决策分类器(ANN)的混淆矩阵

对于不平衡的二元分类器，我们上面的图是典型的，其中多数类的 TP 非常高，但少数类的 TP(或一些参考的假阴性)非常低。

请注意，scikit 和大多数机器学习包根据字母数字意义上哪个先出现来排列标签。由于我们期望的输出由“0”和“1”组成，分别代表“非违约借款人”和“违约借款人”，因此我们在混淆矩阵的左上角使用数字“0”作为其第一个元素。这恰好也是多数阶级。然而，如果我们翻转标签，请注意多数类的 TP 现在将显示在右下角。

精确和召回

对于不平衡的二元分类器，多数类的精度和召回率(又名灵敏度或真阳性率(TPR)) 将总是高的。正如我们在上面所看到的，多数阶级的 TP 往往很高。

仅在分母上精度和召回不同，其中精度具有该类别的预测总数，而召回具有该类别的观察总数。

精确度和召回率告诉我们模型的不同方面。 Precision 告诉我们模型在预测特定类别时的预测可靠性，而 recall 告诉我们模型识别特定类别的能力。理想的分类器应该同时具有高召回率和高精确度。

对此的解释借用了这个的帖子。

为了创建一个表来提供每个类的精度和召回分数，让我们使用下面的代码。

labels = [0,1] #For a binary model, we use 0,1 but this can extend to multi-label classifiers
metrics =['precision', 'recall']def imbalance_classifier_metrics(labels, metrics, y_test, y_pred):
    summary = pd.DataFrame(columns=[i for i in metrics])
    summary.index.name = 'classes'for i in labels:
        precision = precision_score(y_test, y_pred, pos_label=i)
        recall = recall_score(y_test, y_pred, pos_label=i)
        summary.loc[len(summary)] = [precision, recall]
    return summaryimbalance_classifier_metrics(labels, metrics, y_test, y_pred)

以上函数的结果

如前所述，多数类的准确率和召回率都很高。我们理想地想要一个分类器，它能给我们一个少数类可接受的分数。让我们稍后讨论我们可以做些什么来改善这一点。

请注意，在一些

F1——得分

F1 分数，或者有些人可能称之为 F 分数，是精确度和召回率的加权调和平均值。

作为调和平均值，该度量惩罚精度和召回的极值。以高召回率(比如 0.95)和低召回率(比如 0)为例。).使用上面的公式，整个事情变成 0，表明该模型根本没有用。

请注意，F1 衡量标准对精确度和召回率赋予了相同的权重，但也可能对这些衡量标准赋予不同的权重。调和平均值在 F1 测量中的应用是最受欢迎的。

我们上面的函数的结果，包括 f1 分数

ROC 和 AUC

ROC 曲线同样有助于开发我们的分类器。然而，根据我的经验，我在细化部分使用它。

ROC 曲线代表受试者工作特性曲线。它是我们改变阈值时分类器如何执行的图形表示。

通常，二元分类器使用 50%作为默认阈值。这意味着为了将一个对象分类为属于某一类，该对象属于该类的概率应该大于 50%。

统计数据显示:

如果对象属于一个类别的条件概率大于或等于 50%，则该对象被分类为属于该类别。

然而，对于不平衡的数据集，默认阈值不起作用。更多细节请参考上面的统计解释。

然而，如果我们调整阈值 T，我们可能能够提高分类器的性能。

前面我们的分类器条件的一般形式如下:

因此，ROC 曲线告诉我们，当我们改变这个阈值时，分类器性能会发生什么。

根据模型性能不同的 ROC 曲线。

在我们上面的图中，红色图被认为是最好的分类器，因为它只牺牲了一点点精度来增加回忆。如果你看看精确度的公式，假阳性越高，精确度越低。图中最差的分类器牺牲了很多精度来提高召回率。

顾名思义，AUC 或(曲线下面积)测量曲线下的面积。此指标的最低可能值为 0.5，而最高可能值为 1。AUC 的好处是，它能够在一个缩放的级别上比较模型值。

为了在我们的示例中生成 ROC 和 AUC，让我们使用我们生成的三个模型之一，即随机森林。我们需要得到输出概率而不是输出标签:

#For Random Forestyhat = forest.predict_proba(X_test)
#retain only the positive class probability
yhat = yhat[:,1]fpr, tpr, thresholds = roc_curve(y_test, yhat)
roc_auc = metrics.auc(fpr, tpr)#PLOT
plt.title('Receiver Operating Characteristic')
plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)
plt.legend(loc = 'lower right')
plt.plot([0, 1], [0, 1],'r--')
plt.xlim([0, 1])
plt.ylim([0, 1])
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')
plt.show()

我们看到 AUC 得分为 0.62，这并不是很好，因为最低得分为 0.5。如果 AUC 分数是 0.5，这告诉我们的分类器“没有技能”。

如何选择合适的门槛？

为不平衡的分类器选择正确的阈值本身就是一门科学，我们需要问自己，我们想要为此优化什么。

给出一些决策规则:

  1. 使特异性(1-FPR)和敏感性(TPR) 之和最大化。这是直观的，因为这最大化了所有类的总正确预测。数学上:

T_func = (1-fpr) + tpr
ix = np.argmax(T_func)
best_thresh = thresholds[ix]
print('Best Threshold=%f' % (best_thresh))

2.将敏感性和特异性之间的差异最小化。根据希门尼斯-瓦尔夫德& Lobo (2007) ，的研究，使用阈值导致灵敏度和特异性之间的最小差异的分类器，往往比使用阈值使两者之和最大化的分类器表现稍好。这是真的，尤其是如果犯错误和不犯错误的代价一样大的话。

3.选择哪个导致特异性和敏感性的最高几何平均值。其逻辑遵循第一点，我们的目标是选择一个具有高特异性和敏感性的模型。

实际上，这简化成了尤登的 J 统计量:

J = tpr - fpr
ix = np.argmax(J)
best_thresh = thresholds[ix]
print('Best Threshold=%f' % (best_thresh))

4.基于成本的阈值。

分类器算法通常使用两个假设:类是平衡的，错误的代价是相等的。因此，需要考虑类别不平衡和成本不平等，以优化使用默认假设的分类器。

根据分类器的使用情况，假阳性可能比假阴性代价更高。

举一个极端的例子，将嫌疑人归类为死刑。将一个无辜的人归类为“阳性”以判死刑(假阳性)，比将一个有罪的嫌疑人归类为无辜(假阴性)的代价要大得多。

对于这些情况，单独的研究应该指出这些成本的权重以及它们最终将如何影响阈值。

下面是一个最小化成本函数的示例:

正如 W.B .兰登建议的那样。这个成本函数的好处是，它考虑了阶级不平衡和成本不平等。

alpha  = 1
beta = 2 #Let us assume that the cost of missing a positive case is twice as costly as incorrectly marking one as positivep = sum(y_test ==1)
p_prime = len(y_test) - p#Cost function
C = (p_prime*alpha*fpr)+(p*beta*(1-tpr))
ix = np.argmax(C)
best_thresh = thresholds[ix]
print('Best Threshold=%f' % (best_thresh))

选择阈值后，使用以下代码来使用阈值:

#Use the predict_proba method of your classifier
y_pred = (forest.predict_proba(X_test)[:,1] >= best_thresh).astype(bool)

收集更多数据

有时，尽管我们对模型进行了修改，它们仍然不能产生能够可靠地预测少数阶级的模型。

收集更多的数据是你能做的唯一最好的事情，以提高你的模型的有效性，最好是少数民族的模型。更多的数据有助于模型更好地学习该类的特征，从而提高其识别和预测该类的可靠性。

扩充数据集和欠采样

虽然这是大多数数据科学家采用的一种技术，但在应用这种技术时应该小心，因为这不能代替收集更多数据。

在不平衡机器学习的上下文中，欠采样和过采样分别指删除多数类的实例和创建少数类的新实例。

扩增和欠采样的危险在于，它改变了潜在的类别比例，这可能与现实世界中的比例不同。那么，人工比例将是你的模型所学习到的，在现实世界中进行预测时可能不合适。

关于数据扩充的一个论点是，它可以用来使样本比例达到人口比例。例如，如果你知道人口中有 10%的少数民族，而你的样本只有 5%，那么数据扩充可能会弥补他的差距。这可能会给数据科学家一种虚假的安全感，因为数据扩充(甚至欠采样)不会产生任何 新信息。有可能我们刚刚完成的是改变我们的模型学习的比例，因此使它在现实世界中无效。

出于这些目的，可以采用分层抽样来分割训练和测试数据集，交叉验证。这有效地考虑了训练和测试数据集中类的比例。

X_train, X_test, y_train, y_test = train_test_split(X,y, stratify=y)

我们同样可以应用不平衡学习包中的 SMOTE。SMOTE 意味着合成少数过采样技术。顾名思义，它用于对 minority 类进行重采样，以便它在数据集中具有更高的代表性。同样，数据科学家在使用这些技术时应该谨慎。

反思模型的特点

有可能模型发现识别少数民族类具有挑战性，因为其分布在某些特征上与多数民族相似。但是，如果您碰巧有一个特征，其中类之间的分布差异很大，则模型可能会使用该特征来正确识别和预测。

使用 seaborn 包的 pairplot 可以帮助您快速识别这一点。如果将色调参数设置为类变量，配对图的主对角线(密度图)将告诉您是否存在多数类和少数类分布显著不同的要素。

sns.pairplot(df2, hue='default')

来自信用评分数据集的第二个交易数据集的 Pairplot。从最初看，似乎没有可用的特性可以帮助模型更好地学习这两个类。然而，如果我们观察“年龄”的密度，我们会发现在 X 轴的后半部分有一些分离。这意味着随着人们变老，他们更有可能违约。将此添加到模型中可能会提高模型性能。

集成方法

根据关于该主题的大量实验，集成方法是健壮的学习器，并且在处理不平衡数据集时比我们上面讨论的任何采样方法更有效。

集合方法的超参数需要改进，但我建议你不要使用 scikit 的内置参数，因为它是为了“准确性”而调整的。从头开始创建一个函数，并以 F1 值较高的函数为目标。

#Example of code to tune the learning rate:lr_list = [0.05, 0.075, 0.1, 0.25, 0.35, 0.5, 0.6, 0.75, 0.9, 1]
labels = [0,1] #For a binary model, we use 0,1 but this can extend to multi-label classifiers
metrics_to_calc =['precision', 'recall', 'f1']#we used the function above re: precision, recall, f1 scorerfor learning_rate in lr_list:
    gb_clf = GradientBoostingClassifier(n_estimators=20, learning_rate=learning_rate, max_depth=10, random_state=0)
    print("Learning rate: ", learning_rate)
    y_pred = gb_clf.fit(X_train_scaled, y_train).predict(X_test_scaled)
    display(imbalance_classifier_metrics(labels, metrics_to_calc , y_test, y_pred))

让我们用上面的数据集来举一个具体的例子:

models = {"Logistic Regression": logreg,
          "Multilayer Perceptron": mlp,
          "Random Forest": forest,
          "Gradient Boosting": gb_clf}titles = list(models.keys())#Generate the AUC plot for the models
fig, axes = plt.subplots(2,2, figsize=(12,12))
fig.suptitle("AUC for Different Models", fontsize=20)
plt.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.4, hspace=0.4)for i in range(4):
    #Calculate the metrics
    yhat = models[titles[i]].predict_proba(X_test_scaled)
    yhat = yhat[:,1]
    fpr, tpr, thresholds = roc_curve(y_test, yhat)
    roc_auc = metrics.auc(fpr, tpr)

    #Plo
    axes[i//2][i%2].plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)
    axes[i//2][i%2].legend(loc = 'lower right')
    axes[i//2][i%2].plot([0, 1], [0, 1],'r--')
    axes[i//2][i%2].set_xlim([0, 1])
    axes[i//2][i%2].set_ylim([0, 1])
    axes[i//2][i%2].set_ylabel('True Positive Rate')
    axes[i//2][i%2].set_xlabel('False Positive Rate')
    axes[i//2][i%2].title.set_text("{}".format(titles[i]))

随机森林和梯度推进分类器在识别和预测少数类方面表现都非常好。回想一下，AUC 用于提供性能的标量测量，最高可能值为 1.0。对于梯度推进分类器，我们得到 0.93。

梯度推进分类器在精确度、召回率和 F1 分数方面的巨大改进。

以下是我们为提高该特定数据集的少数民族类的模型性能所做的工作:

  1. 选择具有更多默认值的事务数据集(收集更多数据，df2 比 df4)
  2. 反思特征:增加了“年龄”,因为分布在 x 轴的后半部分显示了潜力
  3. 使用分层参数来训练和测试数据集
  4. 使用超参数调整的集成方法来产生稳健的分类器
  5. 可选:人们甚至可以选择结合我们在中学习的技术来选择正确的阈值部分。

对于更加定制的算法，您可以使用具有分裂标准的集成方法，例如海灵格距离(例如海灵格距离额外决策树(HeDEx) )

结束语

不平衡的数据集是数据科学悖论的典型例子。一方面，虽然数据科学家处理不平衡的分类器(甚至可能比平衡的分类器更多)非常常见，但目的通常是识别不常见的类。

在处理这一问题时，没有一个放之四海而皆准的解决方案，虽然我们讨论了许多可能的补救措施，但人们应该注意到，处理不平衡的分类器可以早在数据收集阶段(例如收集更多数据)和探索性数据分析(例如查看密度以确定应该包括的特征)就开始了。

我们的清单虽然全面，但绝不完整。我鼓励每个人都尝试自己的补救措施，并与我们分享，这样我们所有人都能学得更好。

感谢您的阅读！

完整代码可以在我的 Github 页面找到。

参考文献

处理机器学习中的不平衡数据集

针对不平衡分类的阈值移动简介

混淆矩阵

如何使用概率开发和评估朴素分类器策略

准确度 vs F1 分数

用 SciKit 学习 Python 中的梯度增强分类器

选择最佳阈值的常用方法

TowardsDataScience-博客中文翻译-2021-十二-更多相关文章

今日报告-66

设置Windows10暂停更新3000天

AQS公平锁的流程

AMD锐龙7 7800X3D网游专项测试：竟比i9-13900KS强了15%

常用总线技术基本参数对比

探索图像数据中的隐藏信息：语义实体识别和关系抽取的奇妙之旅

设置Chrome浏览器自动升级

JavaScript – 小技巧 Tips

Winform无边框窗体实现拖动

STM32基础（一）

技术人的修炼---九五小庞

vue自定义事件用法及$emit

ODOO 科目配置4

sqlite 触发器 c#

postgresql在插入数据后怎么获取自增id

EF Core 的基本使用

error: failed to push some refs to 'https://github.com/*******/********.github.io.git'

欧拉降幂

编程语言能力对比

基于机器视觉的小车轨迹控制软件界面展示

随机推荐

命令拼接技巧

Fiddler抓包Android7以内版本

SD NAND 与 SPI NAND

C语言中的编译过程详解

step7 V5.x上的SCL

yolo --- 核心思想

【游记】CCPC 济南 2024 游记

AJAX & AXIOS-2024/11/1

验证码处理在自动化测试中的应用

一些学科笑话

NOIP2024模拟赛20 & 11.1 小记

20241101 数据结构与算法期中机试收获

Java，启动！

什么是IT技术

即将到来！

2024/11/1日 日志 关于JavaScript简介&引入方式 以及基础语法的学习

舍得-时间-工作是人的一生最重要的事情-自己要有私房钱-人的一生最重要的事情是书写自己的人生

2.TiUP 部署 DM 集群

原型模式的C++实现

python bytecode解析

热门话题

Ethernaut Level 11: Elevator Attack and Blockchain Interaction

快速部署开源spug运维平台的Docker安装指南

驱动调试之printk的原理与使用

计算机思维模型及其应用

华为云发布代码大模型PanGu-Coder2，实现高效代码生成

Linux多硬盘数据存储和分区操作

构建高可用架构: 分层冗余与自动故障转移

LoRA：高效调参的大语言模型适应方法

《分布式系统的基本原理及互联网分层架构的本质》

Hadoop写流程解析

Java架构师的系统架构设计方法论中的规范要点

使用observeDOM解决BetterScroll插件在移动端无法滑动的问题

互联网一致性架构设计实践

高并发系统架构与水平扩展

混合应用的崛起：跨平台开发取代原生应用

  穗舟网 （www.seizhou.com）

本站除标明"本站原创"外所有文章版权归创作人所有，本站不承担任何法律责任和连带责任，如有冒犯请直接联系，我们将立即予以纠正并致歉。

Powered by WordPress  ·  v1.0.0-alpha