TowardsDataScience-博客中文翻译-2020-十八-

TowardsDataScience 博客中文翻译 2020（十八）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

人工智能

原文：https://towardsdatascience.com/artificial-intelligence-d1e45efc99b4?source=collection_archive---------65-----------------------

简明的概念介绍

在 Unsplash 上由托马斯 M 拍摄的照片。

要谈人工智能，首先要对智能有一个合理的定义。在他最近的论文《 关于智力的衡量》 》中 Chollet 描述了主导文献的两种不同的智力定义:

  • 智力是特定任务技能的集合:强调实现目标的能力。
  • 作为一般学习能力的智力:强调一般性和适应性。

无论采用哪种定义，智力在许多自然系统中都是一种属性。生命形式以各种方式呈现智能，描述和解释这一现象的挑战性任务是所谓认知科学的核心。除此之外，自 1956 年的创立大会以来，人类建造智能机器的长期努力一直被贴上人工智能(AI)的标签。从一开始，关于如何制造智能人工系统的主要想法就围绕着两种方法:

  • 向专家学习:专注于将知识提炼为规则集或其他显式表示的方法，并将这些描述加载到机器中。通常把这个传统上的方法称为符号 AI。
  • 从数据中学习:通过例子来关注教学机器。允许计算机直接从数据中学习的核心思想由命名这种范式的总括术语来表达:机器学习。

由于技术上的挑战和在符号方面的有限成功，许多这样的方法被废弃不用，导致这种范式通常被称为优秀的老式人工智能(GOFAI)。此外，在过去几十年中，计算能力和数据的可用性不断增长，这将机器学习推向了人工智能研究的前沿。如果今天有人在谈论 AI，那很可能是在谈论机器学习。

重要的是要注意到，当机器学习作为一个研究领域出现时，“从数据中学习”的方法已经是另一个学科的主题:统计学。多年来，统计和机器学习之间的这种重叠已经引起了一些争论，Breiman 的论文'Statistical modeling:the two culture'是开始讨论这个问题的一个很好的参考。简而言之，论点如下:

  • 统计:通过假设一个随机模型并估计其参数来对数据建模。拟合优度测试和残差检验评估模型质量。
  • 机器学习:通过假设模型复杂且未知来对数据进行建模。它对保留数据集的预测能力评估模型的质量，例如交叉验证。

由于这两种传统提出的各种解决方案在技术上的细微差别，很难将每种技术归类为属于一种或另一种方法。也许更有用的是承认这两种“文化”是一个谱系中的两个对立的极端，其中每种传统提出的工具都处于以推理为中心的方法和以预测为中心的方法之间的连续体中。

现在，记住这个背景，让我们继续机器学习解决方案的复杂性。即使我们将关于人工智能的讨论集中在机器学习上，要涉猎围绕该领域的丰富术语仍然不是一件容易的事情。当谈到这样一个系统时，我发现将每个机器学习解决方案想象成由五个有点独立的抽象层组成是很有用的。

机器学习解决方案的五个层次

机器学习解决方案的五个重叠抽象层。

技术

每个解决方案都依赖于计算基础设施。

  • 存储:取决于数据集大小、数据类型、所需延迟等。
  • 计算:取决于所需的处理单元，如 CPU 和 GPU，以及处理是集中式还是分布式。
  • 开发:依赖于团队专业知识、工具集成熟度等。

此外，像任何其他计算系统一样，对每个主题的决策都必须考虑其他问题，如预算限制、可伸缩性和可维护性。这一层有许多选项，从将数据存储在硬盘中并在本地 Jupyter 笔记本上处理的小型系统，到多云环境中的大规模管道。

数据

表格、文本或图像构成了最常见的数据集。

这似乎是显而易见的，但值得一提的是:所有机器学习解决方案都依赖于数据。知道哪种类型的数据将被系统处理，将允许系统设计者作出关于适当建模技术的明智决定，以实现期望的结果。当谈到数据时，关注点通常是:

  • 数据类型:信息呈现给系统的方式。它可能在桌子上，文本上，图像上，声音上，等等。每种数据类型都有独特的挑战，需要特定的工具和方法来应对。
  • 数据集大小:可用数据的数量会影响技术和模型层的决策。一些模型依赖于大量数据，而另一些则适用于小数据集。
  • 相关性:了解数据集中的每个数据点是否独立，或者是否存在某种相关性结构，例如时间序列和图表，在选择适当的建模技术时会产生很大的影响。

模型

在选择模型时有许多选择。

选择模型就是选择函数空间或假设集，我们将在其中搜索最佳拟合模型。之前各层的特征已经在某些方面影响了这一决策，例如，深度学习模型可能需要更大的数据集和专门的硬件来训练。此外，这一层还有一个特别的核心特征:

  • 可解释性:解释预测或模型中变量关系的需求是模型选择的一个关键方面。

对线性模型上的系数或决策树上的阈值的直接评估可以给我们关于数据集上变量之间关系的信息。其他模型，如随机森林或深度神经网络，很难直接评估，可能需要额外的工具来深入了解其内部工作。

方法

机器学习的三种主要方法。

方法，或学习方法，是我们定义如何使用数据来寻找一个好的模型。这在很大程度上取决于我们正在解决的问题的类型:聚类、分类、回归、控制等。大多数关于机器学习这方面的论述倾向于强调三种主要方法:

  • 无监督学习:我们没有特定的目标变量。处理分割和关联任务的常用方法。
  • 监督学习:我们有一个特定的目标变量。处理分类和回归问题的常用方法。
  • 强化学习:智能体学习如何通过与环境的直接交互来实现目标。

虽然学习方法表征看起来可能只是一种形式，但它是机器学习系统设计的一个关键定义。针对给定问题的适当学习方法的规范将指导所有模型训练设置，包括其评估方法、学习度量和预期结果。

值得记住的是，这三种方法并不是唯一可用的方法。尽管如此，一旦你清楚地了解了它们的特点，就会更容易理解其他的学习变体，比如半监督学习、在线学习、对抗学习等。

应用

每个应用程序解决一个特定的问题。

应用程序是为解决问题而设计的，与底层技术无关。应用程序是机器学习系统设计的最终产品。如今依赖机器学习的一些众所周知的应用是推荐系统、贷款分类器、异常检测器和自动驾驶汽车。

重要的是要记住，实际上，任何这些应用程序都可以使用硬编码的规则来构建。记住这一点可以作为对在给定解决方案中使用机器学习技术的真正必要性的现实检查。软件工程本身就有很多复杂性，依靠机器学习来构建应用程序增加了另一层复杂性，这可能导致技术债务积压的显著增加。

结论

人工智能是一个复杂的研究领域，对于处理这项技术的人来说，拥有一个清晰的整体图景非常有用，如果不是必需的话。下次你面对一个使用机器学习构建的应用程序时，尝试解开它的每个抽象层，以理解设计师在每个抽象层中的选择，这可能会提高你对它的理解。最后，我希望这个概念性的介绍可以作为一个简单的地图，帮助你在这个广阔的领域导航。对于那些想知道如何更深入地挖掘这个主题的人，当有疑问时，我总是会回到罗素和诺维格的优秀著作《人工智能:一种现代方法》。’。

人工智能伦理和十诫？

原文：https://towardsdatascience.com/artificial-intelligence-ethics-and-the-10-commandments-620a1d90c29e?source=collection_archive---------46-----------------------

将人工智能伦理问题映射到 10 条戒律

雅典学校

这篇文章探讨了我们可以将不同背景的想法汇集在一起的方法，以帮助减少我们在当今行业中看到的偏见。所以，在这篇文章的最后，我将把一些人工智能伦理问题映射到 10 条戒律上，看看它们是如何叠加的。

也许在认识到我们的偏见并向机器传授我们的共同价值观的过程中，我们可能会比人工智能提高更多。我们可以提高自己。— IBM

一段时间以来，我一直在思考如何将圣经中的十诫作为构建人工智能原则伦理框架的良好起点。我对此不予理会，因为我觉得这有点奇怪。然而，在看到 2020 年 2 月微软、IBM 和罗马天主教会关于人工智能伦理的的不寻常的合作关系 后，我意识到我的想法终究不是那么疯狂！

首先，让我们定义什么是伦理:

伦理被定义为一套管理一个人的行为或一项活动的进行的道德原则。— 维基百科

今天，伦理在社会和文化中发挥着重要作用。它有助于确定在一个社会中什么是合法的或非法的，并且通常作为一个国家的法律和秩序的基础。例如，当探索西方的伦理和道德时，你会发现宗教，尤其是基督教，在提供指导方针方面发挥了重要作用。尽管西方文明已经在很大程度上摆脱了它的宗教根源，但是基督教在西方文明形成中的重要性是不可否认的。然而，本文的重点不在这方面。

为什么是 AI 伦理？

人工智能可以提供非凡的好处，但它也可能产生负面影响，除非它得到负责任的构建和使用。深度学习(机器学习的子集)模型在不同的应用中有时会超过人类水平的性能。

来源

以 AlphaGo 为例，一个由 DeepMind 开发、后来被谷歌收购的深度学习计算机程序，学习如何下围棋。AlphaGo 没有像典型的程序一样将围棋规则输入其中，相反，开发人员让 AlphaGo 通过与业余和职业选手进行数千场比赛来学习游戏，使用一种 奖励系统 ，有点像人类的学习方式。这最终导致它成为第一个打败职业围棋手的计算机程序。这非常令人印象深刻，因为围棋被认为是人工智能领域最具挑战性的经典游戏，因为它在单个游戏中有大量的变化，从而使游戏中的策略非常复杂！

显而易见，这种技术可以用来为更大的利益建立人类知识的独创性。然而，为了防止臭名昭著的反乌托邦所谓的 技术奇点——运行人工通用智能的计算机程序自我改进成为超越人类智能的超级智能代理——我们必须建立一个道德框架来防止不必要和不可预见的情况。

一、机器人电影— 来源

十诫是什么？

十诫，也被称为十诫，是一套关于伦理和崇拜的圣经原则，在亚伯拉罕宗教中扮演着重要的角色——维基百科

下面你会发现写出来的十诫，我们现在将尝试把它们映射到我们今天面临的一些常见的人工智能伦理问题。(A 还要注意，这不是一个详尽的列表，而是一个在你的系统中构建人工智能道德原则的建议。显然，任何 AI 系统的伦理都将在很大程度上取决于其创造者的伦理。

来源

弥合差距

  1. 在我之前，你不会有其他神(又名:责任/可追溯性):今天，人工智能系统面临的一个问题是责任和透明度。任何特定的人工智能系统都需要对一个权威——系统的创造者——负责，这个权威可以是个人也可以是组织。 例如，亚马逊开发了一个 招聘算法 ，意在从世界各地招聘顶尖候选人。该程序有效，但算法已经学会将女性排除在候选人名单之外，因此对简历中有“女性”的人进行降分。由于问责制，亚马逊承担了责任，并最终在推广到更大的群体之前取消了该计划。这里还有一个场景，如果一辆自动驾驶汽车(AV)撞死了人，谁应该负责？人工智能驱动的 AV 还是系统的创造者？我喜欢工程和物理科学研究委员会(EPSRC)在“机器人的 5 条伦理规则”中的表述。第五条规则规定“应该可以找出谁对任何机器人负责(在我们的例子中是 AI)”。人工智能不应该在法律上对它的决定负责，它是一个工具，创造者应该承担唯一的责任。因此，对创造者的可追溯性是可信的人工智能系统的关键。
  2. 你不应该制造偶像:这和第一点非常相似，所以我们现在可以跳过这一点。
  3. 不可妄称耶和华你神的名(又名:滥用权力):这个命令是为了防止滥用/误用神的名。所以本质上，人工智能系统不应该滥用它被赋予的权力。这可能是一个很难检测的问题，因为大多数人工智能系统并不为它们的决定提供解释。 我来举个例子。ToTok 是一款已经被下载了数百万次的阿联酋消息应用程序，据称被政府用来跟踪该应用程序用户的对话、位置和其他数据。虽然 ToTok 在他们的网站上否认了这一点，但希望这不是真的。然而，人工智能(机构)不应该滥用或利用用户赋予他们的权力和信任。

Google Playstore 上的 ToTok 警告消息(来源)

4.记住安息日并保持它的神圣(又名:维护/可靠性):安息日的目的在信奉亚伯拉罕宗教的人们中一直有争论，但它通常被认为是休息日。有鉴于此，重要的是抽出时间定期维护一个人工智能系统，以确保它没有偏见、错误、故障和安全漏洞，并确保最佳性能。该系统应在其整个生命周期内进行持续测试，以保证其可靠性。

5 。尊重你的父母(又名:如果需要，允许人类干预并强制遵守人类法律):人工智能系统应该遵守现有法律&基本权利&自由，包括隐私。这些系统还应该允许人类在需要时接管它们。回到自动驾驶汽车(AV)的例子，在一个事故不可避免的场景中，一组科学家设计了一种将决定权交给人类乘客的方法，并将其称为“伦理旋钮”。这允许乘客决定在这种情况下 AV 应该做出什么样的道德选择。像这样的灵活性可以为您的系统增加另一层信任。

6 。你不应该杀人(又名:AI 不应该杀人):这是一条被全世界普遍一致认为在道德上是错误的规则，除了自卫的情况。一般来说，如果人类有生存的权利，那么道德会说，“你不能杀死一个人”。可以说，让一台机器在没有人类干预的情况下判断是否要夺走一个人的生命，对社会是有害的。例如，在 2007 年，一个军用火炮机器人发生故障，开火，造成 9 名士兵死亡，14 人受伤。这是一个悲剧，但值得庆幸的是，许多国家和组织已经签署了一项承诺，禁止在致命的自主武器中使用人工智能。取人性命的决定在任何情况下都不应该交给人工智能系统，这个决定应该总是委托给人类。

7 。你不应该通奸(又名:忠诚/安全):这是一个有趣的地图，但随着人工智能系统变得越来越强大，确保它们(特别是像武装无人机或甚至州级能源管理系统这样的关键任务系统)不会落入坏人手中，然后被用于恶意目的是很重要的。 这意味着系统应具备强大的访问控制措施，以防止未经授权的访问。 网络安全已经并将继续在人工智能解决方案的可靠性中发挥关键作用，因此请确保从第一天起就将这种安全性构建到您的程序中。

8 。不得窃取(又名:数据保护):再次引用世界人权宣言、 任何人的财产’都不得被任意剥夺，这包括他/她的数据。因此，人工智能系统不应在未经用户明确同意的情况下窃取或欺骗性地收集用户数据。像 GDPR 这样的法规已经在这方面有所帮助。剑桥分析公司和脸书丑闻是脸书允许第三方开发者仅仅为了收集数据而设计应用程序的一个例子。开发者能够利用一个漏洞，不仅收集使用该应用的人的信息，而且在他们不知情的情况下收集他们所有朋友的信息。应该不惜一切代价避免这种做法。因此，我们将确保您的系统符合 GDPR 政策或您的系统将运行的任何地区的任何类似法规。

来源: Vox

9 。你不应该对你的邻居做伪证(又名:真实性/欺骗例如:深度假证):深度假证的缺点令人困扰。在 Deepfakes 中很难看到“好”的一面，但是在特效行业中，这是非常有益的。看看这个大卫·贝克汉姆说 9 种语言的视频，感谢 Deepfakes 合成的力量。

也就是说，确保人工智能不被用来通过提供真实的幻觉来剥削用户是至关重要的。你的人工智能应该为用户提供一种方式来了解系统所呈现的信息的真实性。

10.你不应贪图(又名:失业和财富不平等):据麦肯锡全球研究所报告，到 2030 年，大约 8 亿人将因人工智能驱动的机器人而失业。这些数字令人担忧，距离 2030 年只有 10 年了！为此，这里可以考虑“T4”的概念，即每砍伐一棵树，就种植更多的树。本质上，人们应该考虑作为人工智能系统开发的结果而创造的创造性的新工作/技能。例如，机器学习工程师可以开始教放射科医生如何重新训练癌症检测 AI 程序。这将赋予放射科医生新的技能，并确保人工智能系统将只是一个增加他们工作的工具，而不是一个夺走工作的工具。

就是这样！我希望这些要点对你的下一个人工智能项目有所帮助和实用。

其他资源:

人工智能:世界各地的事件(7 月 4 日)

原文：https://towardsdatascience.com/artificial-intelligence-events-around-the-world-jul-4-93ac52154dee?source=collection_archive---------50-----------------------

本周，我们已经看到一个受欢迎的图像数据集被下线，更多与数据相关的职位空缺，以及机器人在食物银行抗击新冠肺炎病毒的传播

在人工智能的世界里，每天都有很多事情发生。事件发生的频率使得跟上事件的发展相当具有挑战性。我读过一些标题和文章，把人工智能描绘成一幅不太正面的画面。

一个机器学习相关项目和研究中的管道和过程受到监控和监管的世界正在成为可能的现实。

本周报道的文章:

  • 更多与数据相关的职位空缺，即使是在当前的疫情
  • 由于种族和性别偏见，麻省理工学院撤销了数据集
  • 数据科学角色的未来
  • 负责给食物银行消毒的机器人。

包括文章的封面图片

未来的数据科学工作会是什么样子？5 职业趋势。[西雅图时报]

当前技术和人工智能的出现催生了对数据的不可满足的需求，因此，理解数据的个人需要确保人工智能系统正常运行。

《西雅图时报》的这篇文章探讨了围绕数据相关角色的趋势:数据科学家和数据分析师。

数据科学和分析是一个独特的工作角色，跨越各种行业和部门。凭借你的数据科学技能，你可以在医疗行业和石油行业工作，实际上你的职业发展和潜力是无限的。本文探讨了基于数据的角色的一个基本事实，即每个行业都需要理解数据的个人。

除了工业领域的趋势之外，这篇文章还提到了学术趋势。许多拥有技术技能的人很可能会回到大学，专攻与数据相关的高级学位。这句话非常正确，因为我在做了几年 Web 开发人员后，又回去获得了机器学习的硕士学位。我相信在未来的几年里会有更多的专业人士效仿。

本文包含的一个趋势是将数据素养规范化为每个专业人员的必备技能。这篇文章关注的是数据科学工作，但这一趋势适用于每一个现代工作角色；每个人只需要理解系统产生的数据。被视为正常的数据理解或读写水平并不复杂，但对数据的基本理解和解释对每个人来说都有很大帮助。

文章探讨并详述了更多的趋势；下面是原文的链接。

[## 未来的数据科学工作会是什么样子？5 个职业趋势|由东北大学提供…

回想一下您上次登录流媒体服务或音乐订阅服务的时间。仪表板是否有…

www.seattletimes.com](https://www.seattletimes.com/sponsored/what-will-data-science-jobs-look-like-in-the-future-5-career-trends/)

旅行者雇佣了 500 名技术专家来支持现代化工作。【华尔街日报】

在当前的全球气候下，对许多人来说，工作保障是最重要的议题。但看起来机器学习和软件开发角色可能不会受到当前失业浪潮的影响。

保险公司 Travelers 希望在一段时间内雇佣一批软件和机器学习专业人员。这一招聘热潮旨在帮助该公司实现数字化转型。

新员工将参与与机器学习领域相关的项目，如计算机视觉、自然处理、语音识别和数据科学。

更具体地说，该公司正在寻求开发一种可以从语音中进行情绪分析的系统，甚至可以从图像中检查财产损失的系统。

Travelers 总部位于纽约，因此对于该地区的机器学习从业者来说，这是一个进入人工智能领域或改变职业生涯的绝佳机会。

以下链接提供了更多信息:

[## 旅行者雇佣 500 名技术专家支持现代化工作

旅行者 Cos。正在竞相填补 500 个技术岗位，包括许多人工智能相关的职位，由…

www.wsj.com](https://www.wsj.com/articles/travelers-hiring-500-tech-specialists-to-support-modernization-effort-11593600230?mod=djemAIPro&ns=prod/accounts-wsj)

麻省理工学院道歉，永久下线了教导人工智能系统使用种族主义、厌恶女性的诽谤的庞大数据集。[登记册]

这篇文章的许多读者可能已经用公开可用的数据集训练了机器学习模型。你使用的数据集之一可能是广泛使用的“微小图像”，一个由麻省理工学院创建和发布的数据集。微小的图像数据集包含 8000 万张图像，这些图像都标有定义图像内容的描述。

原来数据集包含了一些相当不恰当的描述。麻省理工学院已经关闭了数据集，甚至发布了一份声明，可以在这里找到。

该数据集创建于 2006 年，主要通过使用互联网搜索引擎进行填充，对数据集的内容没有任何监督。由于数据集规模庞大，无法识别数据集中的所有图像，麻省理工学院已将其离线，该数据集无法再利用。

微小的图像数据集很受欢迎，我敢肯定许多计算机视觉系统会在数据集上进行训练，甚至可能在互联网上散布着副本。

当前的事件揭示了人工智能系统因其训练数据而产生的偏见，我相信未来我们可能会在几个机器学习项目和研究中看到更受监控和更严格的数据收集过程。

[## 麻省理工学院道歉，永久下线教人工智能系统使用种族歧视的大量数据…

特别报道麻省理工学院已经使其被高度引用的数据集离线，该数据集训练人工智能系统来潜在地描述人…

www.theregister.com](https://www.theregister.com/2020/07/01/mit_dataset_removed/?mod=djemAIPro)

麻省理工学院机器人开始为大波士顿食物银行消毒。[TechCrunch]

你如何在食物银行减缓新冠肺炎病毒的传播？你拿一个智能移动机器人，在它头上放四把光剑。

图片来源:艾丽莎·皮尔森——麻省理工学院 CSAIL

艾娃机器人公司与麻省理工学院的计算机科学和人工智能实验室(CSIL)合作，创建了一个机器人系统，可以对大波士顿食品银行(GBFB)内的表面进行消毒。机器人系统的另一个组成部分旨在根除新冠肺炎气溶胶。这个机器人看起来和听起来一样令人印象深刻。

该机器人可以在其环境中导航，由内部绘图系统引导，该系统包含待消毒区域的标记。

Techcrunch 提供了更多信息:

[## 为了抗击新冠肺炎，麻省理工学院的机器人开始为大波斯顿食物银行消毒

麻省理工学院的计算机科学和人工智能实验室(CSAIL)已经将其研究项目之一投入工作，提供…

techcrunch.com](https://techcrunch.com/2020/06/29/in-effort-to-fight-covid-19-mit-robot-gets-to-work-disinfecting-the-greater-boston-food-bank/?mod=djemAIPro&guccounter=1)

我希望这篇文章对你有用。

要联系我或找到更多类似本文的内容，请执行以下操作:

  1. 订阅我的 YouTube 频道 视频内容即将上线 这里
  2. 跟着我上 中
  3. 通过 LinkedIn 联系我

用于内部审计和风险管理的人工智能

原文：https://towardsdatascience.com/artificial-intelligence-for-internal-audit-and-risk-management-94e509129d49?source=collection_archive---------11-----------------------

审计图。人工智能文本分析平台

将评估拖进现代

照片由像素通过像素 (CC0)拍摄

目录
1。摘要:为什么人工智能适用于内部审计和风险管理？
2。简介
3。当代内部审计挑战
4。 AuditMap.ai:审计增强的平台
5。局限与前进的道路
6。参考文献

1。摘要:为什么人工智能用于内部审计和风险管理？

大型组织内的内部审计任务会因为大量的文档而变慢。缓慢的审核响应时间、基于抽样的审核计划以及对关键字搜索的依赖都表明需要自动化来加速内部审核任务。当相关差距或风险没有及时向利益相关者披露时，审计质量也会受到影响。这项工作概述了一个名为 AuditMap.ai 的工作流自动化解决方案。该解决方案包含几个人工智能模型，可以读入数以千计的各种语言的审计报告，以持续识别和组织其中的相关文本。 AuditMap.ai 不是取代审计员，而是协助以人为中心的审计规划和执行过程。

2。简介

组织的内部审计职能面临着交付结果以满足利益相关方的保证需求以及保护组织免受新出现的威胁的压力。考虑到组织中存在的大量报告，保持全局观点是困难的。这项工作概述了一个解决方案，它读取数千个审计报告，对报告中的相关文本进行分类和组织。

内部审计师提供了一道防线，防止可预防的错误和遗漏，这些错误和遗漏可能会降低质量，损害公司的声誉和可信度，错过机会，或导致直接的财务损失。内部审计的主要作用是发现低效率、不合规和防止损失。这些活动通过基于风险的评估和与董事会委员会沟通的方式进行，而财务审计则侧重于发现交易记录中的潜在重大问题，并不时进行纠正。换句话说，在财务审计中发现的损失已经发生，而内部审计的工作结果突出了合规、质量和其他方面的差距。为了确定这些差距，内部审计操作需要跟踪组织的计划所面临的每个风险领域的结果。这种跟踪需要上下文和快速的结果，而不是向审计委员会提交年度总结报告。

内部审计在公司结构中具有独特的保证地位。它在财务审计中有着历史渊源，并已发展到提供更大范围的保证。内部审计在实践中与财务审计有很大不同。而现代财务审计评估交易及其记录以支持财务报表的准确性(有时使用复式记账软件)；内部审计的基于绩效的评估旨在向审计委员会和高级管理层报告其组织的治理、流程、程序、风险、控制、案例报告等状况。此外，在上市公司以及医疗保健和金融等特定部门，法律要求进行内部审计活动和风险披露【2】。

3.当代内部审计挑战

内部报告已经进入大数据时代，这将导致整个企业的信息过载。由于大量的报告数据，一种数据丰富信息贫乏的情况正在审计领域蔓延【3】。这种情况的特点是，一个组织在假设许多指标保证质量的情况下跟踪这些指标，但遗漏了新出现的风险，因为手头的信息没有用任何被跟踪的指标来衡量。答案必然是将数据转化为可操作信息的更好技术。技术是内部审计职能【4】中效率和生产力的关键驱动力。引用 2017 年《内部审计专业实务国际标准》:“内部审计人员必须对关键信息技术风险和控制以及可用的基于技术的审计技术有足够的了解，以执行其分配的工作”【5】。正如 2019 年布里登报告【6】中所概述的那样，审计领域的格局也正在朝着加强审计师与客户分离的方向转变，这促使公司以更高的比率轮换其担保提供商。此外，该报告还指出，“人们似乎普遍认为，自动化现有数据相关的审计任务正在进行中，其扩展不可避免。”

照片由 geralt (Gerd Altmann) 通过 pixabay (CC0)拍摄

内部报告的大量私人文本数据集已经压倒了审计师的传统角色。比如说。在高度管控的领域(例如，飞机制造业)拥有 100，000 名员工的组织在 10 年内可能会生成数百万份文档。将这些仔细记录的报告数据形成理论和评估计划非常耗时，然而这些评估的结果可能对时间极其敏感。管理层迫切需要知道周二的风险在哪里，但审计部门倾向于每季度和每年发布报告 [7] 。此外，风险管理面临越来越大的压力，需要向外寻找新出现的风险。除了快速交付的压力，报告中讨论的评估通常基于样本，导致缺乏全面覆盖。使用关键字选择要采样的报告是很常见的，这可能会导致遗漏陈述相似概念但没有使用指定关键字的关键文档。错过跨时间的报告之间的联系也是常见的，例如重复的风险、不断增加的控制和其他基于时间的现象。

除了在评估大型数据集时需要自动化之外，人为因素也要求额外的审计流程自动化。人类审计员承受着低估实质性弱点的压力【8】。将算法集成到分析过程中可以在一定程度上使审计人员免受这些压力。此外，人类聚集和理解大型数据集的能力有限。不幸的是，使用电子表格和文字处理程序作为基于团队的工作产品的引擎受到人类理解大量数据集的能力的限制。基于文本的工作产品和报告阻碍了治理度量的创建和计划活动的交付。从根本上来说，规划现代内部审计是管理信息过载。审查大型企业控制环境既昂贵又耗时。尽管报告大部分是数字化的，但对于任何人类团队来说，完整地阅读和理解报告仍然是一项艰巨的任务。在与感知的财务风险联系不那么紧密的审计领域，项目覆盖面往往会变薄。此外，主题之间不明显的联系可以忽略，因为低风险领域获得的审计资源较少。内部审计和风险管理职能部门发现自己高估了一些业务领域，而忽略了其他很少审计的领域。为了应对这些挑战，近年来，主要审计组织已经采取了重大的人工智能和数据分析采用计划【9】【10】【11】。对于大多数企业来说，获得核心治理计划的可量化概览的目标仍然遥不可及，因为人工智能技术尚未在审计公司中得到广泛采用。文献中提出了人工智能在审计流程中的一些应用，但很少被主要的审计公司应用【12】【13】。

财务审计学术文献中已经提出了【14】等预测模型，这项工作自然会导致审计工作流程中类似的预测和自动化创新。人工智能正在进入内部审计和风险管理职能，并将为公司治理转型带来新的机遇。

公开披露是正确和及时识别风险至关重要的一个领域，并且通常是法律强制要求的。在公共关系危机中，确定报告中的相关信息以便随后公开披露非常重要，而且具有时效性。这些信息通常不会在风险登记簿或质量管理系统中进行跟踪，因为所讨论的风险可能是新的或意想不到的。监管风险披露也可能是时间紧迫的，因为申报日期有时可能不灵活。公司文件中的风险披露增加了投资者的风险认知【15】，因此，或许不足为奇的是，公司文件中有用的风险披露很少。披露风险的法律要求是主观的，因此使用一般声明【15】【16】【17】并不难规避。然而，研究揭示了年度备案和 SEC 意见函【18】之间的关系，即如果(1)公司认为不披露可能导致 SEC 的调查结果，或(2)在 SEC 向公司发布 SEC 调查结果后，公司更有可能披露风险。鉴于季度和年度申报中风险披露的重要性，显然非常需要一种能够及时检测风险的解决方案来促进披露流程，尤其是在时间紧迫的情况下。更一般地说，评估质量管理的强弱是内审员必须具备的重要能力【19】【20】。

在 AuditMap.ai 发布之前，机器学习已经应用于风险披露文件的各种应用，如年报分析评估相似性【21】、内部财务控制【22】、IT 安全【23】【24】。审计领域中机器学习的这些和类似应用代表了向数字化转型和预测审计的更大目标迈进的举措。相对于法律和会计等其他领域，内部审计在采用自然语言处理和机器学习方面的滞后可以解释为制度惰性、缺乏培训数据集、顾问的报销模式、理解多语言文档的要求以及不同的报告标准。这些阻碍这一领域发展的各种因素现在正在发生变化，这为利用机器学习实现审计自动化带来了重大机遇【11】。更详细地评估这些因素，专业服务公司的时薪结构可能会阻碍减少计费时数的创新。此外，对审计过程进行建模所需的数据也是严格保密的公司机密，因此标记的报告数据必须由主题专家精心收集和标记。报告中的文本数据类型在一个组织内的不同团队之间有很大的不同。国家风险等评估可以完全侧重于外部文件，而内部控制可以完全侧重于内部文件。阻碍人工智能在审计中采用的另一个因素是缺乏多种语言的数据，如英语、法语、德语和阿拉伯语。此外，与新闻报道和书籍等标准文本语料库相比，审计报告的特征是不同寻常的。具体来说，审计报告表达了比典型文档更高的语言水平，因为它们需要抽象复杂的问题模式。此外，还有许多内部审计标准和风险管理框架，它们的采用因地区而异。例如，ISO 31000 病毒在欧洲更流行，而 COSO 病毒在美国更流行。其他重要的框架包括 COBIT【27】、TSC【28】、NIST【29】。内部审计员使用这些框架来确保最佳实践，并且这些框架是高质量审计再现性的关键。

审计质量、速度和效率竞争是人工智能采用的驱动因素。例如，及时发现差距或风险并将其披露给利益相关者的需要与公司业绩密切相关。采用还将涉及审计人员教育和监测人工智能性能的科学测试制度。利用公开披露的公司报告，应该在今后的工作中以多种语言制定这种业绩评估的基准。应该用这些基准测试每个模型的召回率、精确度和偏差。

关于即将到来的变化的性质，在保险行业或学术文献中没有广泛的共识。一些评估得出结论，人工智能创新将取代审计师【10】。这可能是不正确的。相反，未来很可能是审计师与人工智能合作，就像他们采用电子表格和文字处理来通过数字自动化增强工作流程一样。这项工作的立场是通过应用许多专门模型的增量改进将为审计团队提供自动化的初始推动。从长远来看，用技术广泛取代审计是不太可能的。

审计人员可能会保持现有的流程，同时更频繁地执行这些流程，并通过人工智能解决方案实现更高的覆盖率。未来是辅助性的，而不是规定性的。在这种观点下，人工智能不会取代审计师的决策、判断或评估面试。相反，创新加速了与纠正和预防措施相关的计划和执行活动。关键成果应该是提高审计质量和速度，朝着持续审计的方向发展。

4.AuditMap.ai:审计增强平台

AuditMap.ai 是审计团队的解决方案，可以帮助他们理解大量的文档。风险经理也可以用它来发现新出现的风险。该解决方案使审计团队能够快速检索和处理上传文档中的文本。使用 AuditMap.ai 执行的活动是内部审计职能的战略和战术规划活动的一部分。该解决方案自动执行活动，以支持内部审计师的信息密集型任务。下面的图 1 总结了审计人员利用该解决方案的过程。

审计团队通过定义业务目标开始使用该平台。然后，他们开始定义组织的首选审计主题。团队还通过手动上传或提取、转换和加载(ETL)任务将他们的审计报告和其他文档上传到平台(图 1 (a))。该平台包括一个数据集概念，用于跨客户端管理文档集。在摄取期间，平台内的机器学习模型根据定义的审计主题对上传的文档进行分类。模型架构基于最先进的机器学习模型【30】【31】【32】，在专有训练数据集上训练。其他机器学习模型执行语言实体的自动提取，提取实体关系，语句相似性的跨文档分析，以及关键语句的分类-那些指示企业风险、缓解措施以及那些指示关键见解的语句。执行进一步的处理，以便评估文档片段与普遍接受的企业风险管理框架的相关性(图 1 (b))。通过系统的用户门户提供从文档摄取和自动化分析中得出的结果，这是一个 web 应用程序，允许审计人员通过基于角色的访问控制对内容执行技术辅助审查。当探索机器学习过程的结果时，审计人员可以观察程序或主题内随时间推移的趋势，并可以标记特定的风险或控制，以进行更深入的分析和段落或文档级上下文，或进行重新标记(图 1 (c))。最后，该解决方案包括一个交互式工作台，用于快速创建和导出工作底稿。

该平台为审计员和风险经理提供了一种简化的、自我导向的能力，通过减少在文档数据集中识别信息和将其添加到工作工件之间的步骤，来手动包括研究期间发现的信息(图 1 (d))。向涉众交付工作项目是通过导出来完成的(图 1 (e))。

图 2 显示了审计人员使用的一些用户界面组件。该平台能够缩小关注范围。例如，在一个包含 35 份报告中的 17，571 个句子的选定数据集中，只有 418 个句子被突出显示为指示风险。有些不是“真正的”句子，因为它们可能是句子片段，如目录条目或表格数据。考虑到这一点，AuditMap 能够减少 97.6%的待分析数据。确定了 9800 个实体。以下是在公开报告中发现的表明存在风险的有趣句子的一些例子(圆括号中的数字表示分类置信度):

  • (98.4%) “我们注意到，没有记录优先化工作以确定首先进行哪些工作危害分析，我们也没有看到根据最近的事件或操作风险优先进行工作危害分析的证据。”【33】
  • (52.8%) “鉴于在过去的审计中发现了类似的结果，我们建议[实体]要求所有区域 SCC 使用打印机代码从共享网络打印机中检索打印的[身份数据]信函。”【34】
  • (99.3%) “根据所进行的访谈，发现【部门 1】过去使用备份来选择性地修复三个应用系统的问题；但是，它不必执行完整的数据库恢复。”【35】
  • (86.1%) “与安装和审批管理有关的档案，不包括与审计统一文件相关的附件”【36】
  • (73.7%)“EFK 的寄生虫在德国的传播”【37】

5.局限性和前进的道路

审计和风险管理行业采用 AuditMap.ai 人工智能可能会改变结果。这很可能会改变保险本身的性质。然而，在审计中采用人工智能必须伴随着对技术局限性的定量评估，以及强调技术局限性的员工培训。如果人工智能失败，盲目采用可能会导致声誉风险。因此，谨慎的做法是意识到机器学习在保证方面的功能限制，并评估这些限制的可接受性。

AuditMap.ai 中应用的两种类型的机器学习是用于分类的监督学习和用于上下文表示和相似性评估的非监督学习。应用于专有客户数据的监督学习模型不太可能具有完美的召回率和精确度。这意味着一些风险和控制会被算法遗漏，一些语句会被错误分类。对于审计人员来说，理解这些限制，并在工作流中轻松地获得能够动态地重新标记语句的纠正功能是至关重要的。AuditMap.ai 确实有这个能力。

监督学习也容易受到来自数据的学习偏差的影响，如果它在任意客户端数据上被训练，因此 AuditMap.ai 模型在部署到审计员的环境之前，在解决这个问题的专有主数据集上被训练。尽管偏见可能会在初始部署中得到解决，但这是一个需要衡量和评估的问题，尤其是在进行模型再培训时。

无监督学习同样受限于它所接触到的环境。当面对全新的环境时，技术容易出错。在某些情况下，监督模型依赖于使用非监督学习创建的表示，而更改非监督模型的训练分布可能会破坏监督模型的预测能力。例如，AuditMap.ai 中的模型经过训练，可以对审计报告中的文本进行分类，并且从未接触过电子邮件或短信。将此类数据输入模型会导致相似性理解不佳，因为它们的写作风格和词汇与训练数据完全不同。因此，在部署之前考虑技术采用中包含的数据范围非常重要。

缺失信息是另一个需要考虑的关键问题。审计报告和工作底稿数据集之外的信息经常存在，这些信息只能通过进入现实世界并通过内部审计过程收集数据来获得。假设从内部审计数据集中提取的信息(例如，关系图、风险、缓解措施、见解)完全涵盖了组织的状态，这肯定是错误的。审计人员需要保持好奇，并就遗漏的风险、遗漏的程序提出尖锐的问题，并大体了解内部审计在内部评估方面的薄弱环节。AuditMap.ai 有助于审计团队识别信息可能缺失的地方。然而，填补空白的主动权仍然属于内部审计团队。能够访问大图视图使审计团队能够考虑按主题或按时间可能遗漏了什么信息。

审计员必须问采用这种不完善的近似技术是否比现状更好，是否提高了审计的质量和速度。当审计人员考虑采用 AuditMap.ai 技术时，他们应该定量地、冷静地评估该技术的采用情况。我们正在举办一系列网络研讨会，与审计和风险管理专业人员交流，展示平台，并安排试点。

网站将很快发布一个链接指向即将到来的网络研讨会。如果你喜欢这篇文章，那么看看我过去在 AI for internal audit 上的一些文章吧，“Audit map . AI 如何改善内部审计”和“用人工智能改善内部审计”我也要感谢渥太华大学的米奥德拉·博利奇教授对这项工作的反馈。有没有注意到 AuditMap.ai 有了新网站？嘿，通过网站加入时事通讯！

下次见！

丹尼尔

6.参考

[1] United States Public Law: Quality System Regulation. 21 CFR part 820 (1996)
[2] United States Public Law: Prospectus summary, risk factors, and ratio of earnings to fixed charges (Item 503). 17 CFR part 229.503 (2011)
[3] Goodwin, S.: Data rich, information poor (drip) syndrome: is there a treatment? Radiology management 18(3) (1996) 45–49
[4] Eulerich, M., Masli, A.: The use of technology based audit techniques in the internal audit function–is there an improvement in efficiency and effectiveness? Available at SSRN 3444119 (2019)
[5] Institute of Internal Auditors: International standards for the professional practice of internal auditing. Institute of Internal Auditors (2017)
[6] Sir Donald Brydon, CBE: Assess, Assure And Inform: Improving Audit Quality And Effectiveness; Report Of The Independent Review Into The Quality And Effectiveness Of Audit. The Crown (2019) Accessed on Jan 2, 2020 https://assets.publishing.service.gov.uk/government/uploads/system/uploads/attachment%5Fdata/file/852960/brydon-review-final-report.pdf.
[7] Chan, D.Y., Vasarhelyi, M.A.: Innovation and practice of continuous auditing. International Journal of Accounting Information Systems 12(2) (2011) 152–160
[8] Cowle, E., Rowe, S.P.: Don’t make me look bad: How the audit market penalizes auditors for doing their job. (September 2019) Available at SSRN: https://ssrn.com/abstract=3228321.
[9] Kokina, J., Davenport, T.H.: The emergence of artificial intelligence: How automation is changing auditing. Journal of Emerging Technologies in Accounting 14(1)(2017) 115–122
[10] Alina, C.M., Cerasela, S.E., Gabriela, G., et al.: Internal audit role in artificial intelligence. Ovidius University Annals, Economic Sciences Series 18(1) (2018) 441–445
[11] Sun, T., Vasarhelyi, M.A., et al.: Embracing textual data analytics in auditing with deep learning. (2018) Universidad de Huelva.
[12] Sun, T., Vasarhelyi, M.A.: Deep learning and the future of auditing: How an evolving technology could transform analysis and improve judgment. CPA Journal 87(6) (2017)
[13] Appelbaum, D.A., Kogan, A., Vasarhelyi, M.A.: Analytical procedures in external auditing: A comprehensive literature survey and framework for external audit analytics. Journal of Accounting Literature 40 (2018) 83–101
[14] Kuenkaikaew, S., Vasarhelyi, M.A.: The predictive audit framework. The International Journal of Digital Accounting Research 13(19) (2013) 37–71
[15] Kravet, T., Muslu, V.: Textual risk disclosures and investors’ risk perceptions. Review of Accounting Studies 18(4) (2013) 1088–1122
[16] Schrand, C.M., Elliott, J.A.: Risk and financial reporting: A summary of the discussion at the 1997 aaa/fasb conference. Accounting Horizons 12(3) (1998) 271
[17] Jorgensen, B.N., Kirschenheiter, M.T.: Discretionary risk disclosures. The Accounting Review 78(2) (2003) 449–469
[18] Brown, S.V., Tian, X., Wu Tucker, J.: The spillover effect of sec comment letters on qualitative corporate disclosure: Evidence from the risk factor disclosure. Contemporary Accounting Research 35(2) (2018) 622–656
[19] Bhattacharya, U., Rahut, A., De, S.: Audit maturity model. Computer Science Information Technology 4 (12 2013)
[20] Thabit, T.: Determining the effectiveness of internal controls in enterprise risk management based on COSO recommendations. In: International Conference on Accounting, Business Economics and Politics. (2019)
[21] Fan, J., Cohen, K., Shekhtman, L.M., Liu, S., Meng, J., Louzoun, Y., Havlin, S.: A combined network and machine learning approaches for product market forecasting. arXiv preprint arXiv:1811.10273 (2018)
[22] Boskou, G., Kirkos, E., Spathis, C.: Assessing internal audit with text mining. Journal of Information & Knowledge Management 17(02) (2018) 1850020
[23] Boxwala, A.A., Kim, J., Grillo, J.M., Ohno-Machado, L.: Using statistical and machine learning to help institutions detect suspicious access to electronic health records. Journal of the American Medical Informatics Association 18(4) (2011) 498–505
[24] Endler, D.: Intrusion detection. applying machine learning to Solaris audit data. In: Proceedings 14th Annual Computer Security Applications Conference (Cat. №98EX217), IEEE (1998) 268–279
[25] International Organization for Standardization: Risk management — Guidelines. Standard, ISO 31000:2018, Geneva, CH (February 2018)
[26] Committee of Sponsoring Organizations of the Treadway Commission and others: Internal Control — Integrated Framework. (2013)
[27] Information Systems Audit and Control Association: Cobit 5: Implementation. ISACA (2012)
[28] American Institute of Certified Public Accountants: Trust Services Criteria. AICPA (2017) Accessed on Jan 15, 2020https://www.aicpa.org/content/dam/aicpa/interestareas/frc/assuranceadvisoryservices/downloadabledocuments/trust-services-criteria.pdf.
[29] Bowen, P., Hash, J., Wilson, M.: Information security handbook: a guide for managers. In: NIST Special Publication 800–100, National Institute of Standards and Technology. (2007)
[30] Devlin, J., Chang, M., Lee, K., Toutanova, K.: BERT: pre-training of deep bidirectional transformers for language understanding. CoRR abs/1810.04805 (2018)
[31] Yang, Z., Dai, Z., Yang, Y., Carbonell, J., Salakhutdinov, R., Le, Q.V.: Xlnet: Generalized autoregressive pretraining for language understanding. arXiv preprint arXiv:1906.08237 (2019)
[32] Kim, Y.: Convolutional neural networks for sentence classification. arXiv preprint arXiv:1408.5882 (2014)
[33] Internal Audit and Program Evaluation Directorate: Audit of Occupational Health and Safety, March 2019. Technical report, Canada Border Services Agency, Ottawa, CA (March 2019)
[34] Internal Audit Services Branch: Audit of the Management and Delivery of the Social Insurance Number Program, December 2015. Technical report, Employment and Social Development Canada, Ottawa, CA (December 2015)
[35] Internal Audit Services Branch: Audit of the Departmental Information System and Technology Controls — Phase 1– Application Controls, 2014. Technical report, Employment and Social Development Canada, Ottawa, CA (November 2014)
[36] Audit interne: Achats et marchés, Novembre 2018 Rapport d’audit interne. Technical report, Bureau du surintendant des institutions financieres, Ottawa, CA (November 2018)
[37] Swiss Federal Audit Office: Prüfung der IT-Plattform NOVA für den öffentlichen Verkehr — Schweizerische Bundesbahnen. Technical report, Switzerland, Bern, Switzerland (July 2019)

降低银行业风险的人工智能:当前用途

原文：https://towardsdatascience.com/artificial-intelligence-for-risk-reduction-in-banking-current-uses-799445a4a152?source=collection_archive---------14-----------------------

银行如何使用人工智能进行欺诈检测、合规性和网络安全

克里斯汀·罗伊在 Unsplash 上的照片

银行正在大力投资人工智能以降低风险，即欺诈检测、合规性和网络安全。用机器学习的术语来说，这些是异常检测技术的应用。

我们将了解三家银行——汇丰银行、摩根大通银行和丹斯克银行如何使用人工智能来打击欺诈、遵守反洗钱(AML)法规以及抵御网络威胁。然后，我们看看用于异常检测的特定机器学习技术。最后，我们考虑负责实施基于人工智能的风险降低工具的银行高管的关键要点。

银行优先考虑降低风险

聊天机器人和面向客户的人工智能项目受到了大量的炒作。银行经常发布新闻稿，宣传他们最新最棒的聊天机器人。然而，新闻稿是品牌建设练习，并不一定表明实际的人工智能投资或开发。

银行在异常检测方面至关重要的人工智能投资很少受到关注，即使这是资金的去向。研究表明在银行领域人工智能供应商筹集的 30 亿美元中，超过 50%是由专门从事欺诈、网络安全、合规性和风险管理的供应商筹集的。

作者图片

优先考虑人工智能降低风险有三个原因。首先，未能发现欺诈和洗钱成本高昂。2019 年，美国和英国监管机构对反洗钱违规行为开出了总计 81.4 亿美元的罚单。

其次，良好的风险检测系统让银行客户放心，并提高银行的声誉。例如，客户更有可能选择那些在防范网络攻击方面有良好记录的银行。

第三，通过使用人工智能来自动化某些合规性、欺诈检测和网络安全活动，银行将实现显著的时间和成本节约。如今，这需要大量的人工努力，而当前基于规则的异常检测系统还有许多不足之处(稍后将详细介绍)。

虽然银行拥有内部数据科学团队，并且不总是公布内部人工智能计划，但他们也与第三方人工智能供应商合作，开发量身定制的异常检测解决方案。我们可以看看银行如何与这些供应商合作，以了解他们如何使用人工智能来对抗风险。

合规:汇丰利用人工智能打击洗钱

汇丰银行与机器学习软件公司 Ayasdi 合作，开发人工智能反洗钱(AML)解决方案。

该软件由汇丰内部 IT 团队和 Ayasdi 的数据科学家合作开发，用于识别历史数据中可能存在洗钱的模式。当输入当前支付数据时，它可以识别欺诈模式，并提醒员工阻止这些支付。该软件分析支付的来源和目的地以及其他因素，以识别与正常行为的偏差。

汇丰的 IT 人员帮助 Ayasdi 了解内部反洗钱数据，汇丰的建模团队帮助 Ayasdi 创建准确的客户行为模型。这种合作意味着汇丰可以轻松地使用 Ayasdi 的模型并将其集成到自己的业务实践中，从而克服插入供应商产品的常见挑战。

传统的基于规则的检测系统通常会产生误报警报，将无辜的交易错误地标记为可疑交易。对工作人员来说，调查这些警报非常耗时。Ayasdi 声称他们的软件已经帮助汇丰减少了 20%的假阳性调查，而没有放松合规标准。

网络安全:摩根大通开发网络钓鱼和恶意软件预警系统

摩根大通的研究人员利用深度学习和其他人工智能技术开发了一个检测恶意软件、特洛伊木马和网络钓鱼活动的“早期预警”系统。据称，这种检测系统在网络钓鱼邮件实际发送给员工之前很久就能识别出可疑行为。

用于异常检测的深度学习技术可以学习什么构成了正常行为，并识别以前没有见过的异常活动。研究人员表示，通常情况下，一个特洛伊木马入侵公司网络需要大约 101 天的时间。早期检测系统将在实际攻击发生之前提供充分的警告。

据报道，该系统可以识别通过域生成算法创建的大规模网络钓鱼活动。它还可以通过将恶意 URL 与已知的可疑流量模式、混乱的 URL 和网络钓鱼活动特有的拼写错误进行比较，来识别恶意 URL。

虽然该系统是使用钓鱼网址的公共数据集进行训练的，但研究人员在的一篇论文中声称，其深度学习算法使其能够比传统安全系统更好地检测威胁。它还可以提醒银行的网络安全团队，因为黑客准备向员工发送带有恶意软件的钓鱼电子邮件来感染网络。

欺诈检测:丹斯克银行使用深度学习来打击欺诈

丹麦最大的银行 Danske Bank 与分析公司 Teradata 合作，实施了一个基于深度学习的欺诈检测系统。

根据 Teradata 的案例研究，Danske 银行旧的基于规则的欺诈检测系统只有 40%的成功率，并且每天产生 1200 个误报。此外，该银行调查的 99.5%的可疑案件证明不是欺诈。这些没有结果的调查需要时间和资源，而这些时间和资源本可以用来打击实际的欺诈行为。

Danske Bank 与 Teradata 合作实施了一个深度学习工具，该工具将欺诈检测能力提高了 50%，将误报率降低了 60%。该系统还自动化了许多决策，同时将一些案例发送给人类分析师进行进一步检查。

案例研究提到，该系统使用“冠军/挑战者”方法来检测异常。每个模型(挑战者)学习指示欺诈的交易特征，并被馈送客户位置等附加数据以提高准确性。当一个模型击败其他模型时，它就成为“冠军”，并帮助训练其他模型。这种改善过程可能会重复。

用于异常检测的机器学习技术

银行及其首选供应商很少宣传其异常检测工具背后的特定机器学习技术。然而，我们可以推断他们使用了以下技术的组合。这并不意味着详尽的分析，而是一些相关技术的概述。

分类

分类算法将记录标记为属于特定类别。例如，当应用于异常检测时，算法可以将交易标记为“可疑”或“合法”。

【KNN】是一种流行的异常检测分类技术。它使用数据集中最相似的记录(即最近邻)对交易记录进行分类。如果新交易与先前已知的可疑交易具有相同的特征，则该交易也被归类为可疑交易。相似性由图表上两个数据点之间的距离决定，相似的记录靠得更近。

KNN 易于实现，并且在给定大量训练数据的情况下表现良好。然而，随着更多数据的引入，它变得更慢且计算量更大。这个缺点使得单独使用 KNN 进行快速分类不切实际，例如需要在成千上万的输入交易中检测欺诈。因此，银行可能会将 KNN 与其他算法结合起来。

逻辑回归是另一种流行的分类技术。它是一个二元分类器，将观察结果标记为属于具有一定概率的两个组之一(例如欺诈/合法)。例如，它可以用来检测可疑的网络流量和恶意软件。

使聚集

聚类技术将记录分组到“簇”中，使得一个簇中的记录彼此之间比其他簇中的记录更相似。k-Means是一种流行的聚类技术，将记录聚类成“k”个组。不属于这些组的记录被标记为可疑。

其他用于异常检测的聚类技术包括 DBSCAN 和高斯混合模型 。

聚类技术特别强大，因为它们是无监督的学习方法。与分类技术不同，在分类技术中，人们必须将训练数据标记为属于一个类别或另一个类别，而聚类技术则根据相似性自动将数据点分组。这允许聚类算法识别人类分析师可能看不到的关系。

神经网络

神经网络试图模仿人脑对物体进行分类和检测模式的方法。当用于异常检测时，神经网络可以将金融交易或网络流量模式分类为“正常”或“可疑”。

神经网络的基本结构包含一个输入层、一个或多个处理层和一个输出层。深度学习指的是具有许多处理层的神经网络，因为更多的层能够解决更复杂的问题。

基本自动编码器结构(图片由作者提供)

自动编码器 是一种人工神经网络。他们获取输入数据，解构它，学习构成数据的关键维度，然后使用这种简化的理解来重构它。

当输入常规(非欺诈性)交易数据时，自动编码器会准确地重建初始交易数据，因为它了解常规交易的结构和组成部分。当美联储进行不规则(欺诈性)交易时，重建将会有缺陷，从而提醒分析师调查可疑交易。

其他神经网络和深度学习技术，如卷积神经网络也可以用于欺诈检测。

决策树

决策树使用一系列 IF-ELSE 语句对记录进行分类或预测结果。

用于异常检测的决策树结构(图片由作者提供)

在众多决策树技术中，我们将研究用于异常检测的隔离森林和 XGBoost 树算法。

隔离森林 类似于随机森林，构建很多决策树，取单个树中最常出现的分类。然而，隔离森林是使用二元决策树的集合来识别异常而不是剖析常规观察来构建的。它们可以处理包含许多变量的大型数据集，这使它们有助于识别金融交易中的异常情况。

XGBoost是一种强大的决策树技术，旨在提高速度、效率和性能。它允许使用所有 CPU 内核构建并行树，同时优化硬件使用。它还处理缺失值，避免过度拟合，并在不牺牲分类能力的情况下减少树长度。****

最终结果是强大的预测能力加上相对较短的训练时间，这使得 XGBoost 成为在非常大的交易数据集中检测欺诈或异常的良好选择。

机器学习库

Luminol 是一个用于时间序列分析的 Python 库。它查找异常原因，确定异常发生的时间窗口，并随着时间的推移跟踪异常。例如，这对于分析交易流和网络数据流非常有用。

Apache Spark 机器学习库( MLlib )包含可用于异常检测的算法，如决策树和聚类算法。Spark 可以很好地处理大型数据集，可以在 Scala、Java、Python 和 R 中使用，这使得它成为大公司的热门选择。

给银行高管的建议

银行不能在欺诈检测、合规性和网络安全方面走捷径。未能发现洗钱行为的处罚很高，而且被黑客攻击造成的声誉损失也很大。

随着不良行为者使用越来越复杂的技术，主要银行正在采用人工智能来提高其异常检测能力。目标是在最大限度减少人工干预的同时实现高精度。然后，可以将人力投入到更有利可图或非常规的活动中。

建还是买？

银行应该建立自己的人工智能工具，还是从供应商那里购买一个平台？虽然内部构建需要时间和专门的数据科学人才，但最终产品是根据银行的需求量身定制的。从供应商处购买可能更快更便宜，但是产品可能与银行的流程和数据不完全兼容。创建新的流程和映射数据以适应系统也是一项繁重的工作。

混合方法更有意义。银行可以与供应商合作构建定制的解决方案，就像上面例子中汇丰银行与 Ayasdi 的合作一样。这将加快实施速度，同时仍能创造出符合银行需求的产品。最终，银行可能会选择使用自己的数据科学家、开发人员和研究团队在内部开发产品。

无论银行选择哪条道路，它们都有充分的理由投资人工智能，以更好地应对合规、欺诈和网络风险。

机械工程中的人工智能

原文：https://towardsdatascience.com/artificial-intelligence-in-mechanical-engineering-a9dd94adc492?source=collection_archive---------7-----------------------

一个深度学习实现的示例，为数据科学和人工智能领域的初学者或爱好者的机械工程师提供了非常基本的解释。这个项目是在尼泊尔的 Pro-mech Minds 进行的。

图片来自 123rf.com的安德烈·苏斯洛夫

人工智能和机器学习似乎是当前的流行语，因为每个人似乎都在进入这个主题。人工智能似乎在所有科学领域都有作用。根据《大英百科全书》，“人工智能(AI) ，被广泛定义为数字计算机或计算机控制的机器人执行通常与智能生物相关的任务的能力。”智慧生物基本上是指人类…但也许不是所有的人类…所以无论如何，
它通常被分为如下所示的三个子集。

人工智能及其子集(来源:Edureka

人工智能是配合机器学习的一个更广泛的术语。机器学习使用统计方法来让机器随着经验而改进。

深度学习也是机器学习的子集，它使用模拟人脑的多层神经网络，可以利用足够的数据学习难以置信的困难任务。

我们要讲的是深度学习方法及其在机械工程领域可能发挥的作用。一些常见的例子有异常检测(机器学习)和基于图像的零件分类(深度学习)。重点将放在基于图像的零件分类器以及我们为什么需要它们。

首先，什么是图像分类器？应该会想到曾经著名的识别猫狗图片的人工智能。这里有一个链接到这样一个程序的代码。使用的数据集包含猫和狗的图像，算法从中学习，然后能够以 97%的准确率猜测随机显示的图像是猫还是狗。

猫还是狗？(来源:中条)

我们将尝试类似的代码，但使用螺母，螺栓，垫圈和定位销作为我们的猫和狗…..因为机械工程。

螺栓还是螺母还是定位销还是垫圈？人工智能能够辨别吗？

那么它是如何工作的呢？一种算法能够通过使用称为卷积神经网络(CNN)的机器学习算法(一种用于深度学习的方法)来(有效地)对图像进行分类。我们将使用这个模型的一个简单版本，称为序列，让我们的模型区分图像为四类螺母，螺栓，垫圈和定位销。该模型将通过“观察”一组训练图像来学习。在学习之后，我们将会看到它能多准确地预测一幅图像(它还没有见过的)是什么。

使用神经网络模型对螺母和螺栓的图像进行训练的机器学习算法的流程图。(原图: pngfind )

直接转到 github 中的代码

数据集

我们从互联网上的各种零件库中下载了 4 类共 238 个零件(总共 238 x 4 = 952)。然后我们给每个部分拍了 8 张不同的等轴图像。这样做是为了增加可用的数据，因为每个部分只有 238 个图像不足以训练一个好的神经网络。一个类现在有 1904 个图像(238 个部分的 8 个等轴图像),总共 7616 个图像。每幅图像都是 224 x 224 像素。

4 个类的图像。1 部分有 8 个图像。每个图像都被视为单个数据。

然后我们用数字 0，1，2，3 来标记，每个数字对应一个特定的图像，意味着它属于某个类别

#Integers and their corresponding classes
{0: 'locatingpin', 1: 'washer', 2: 'bolt', 3: 'nut'}

在对上面的图像进行训练之后，我们将会看到我们的模型预测一个它没有见过的随机图像的效果。

方法论

这个过程分 7 步进行。我们稍后将讨论细节。简要总结是

  1. 数据收集:从互联网上的各种标准件库中收集各类数据。
  2. 数据准备:从每幅图像中截取 8 张等轴视图截图，并缩小至 224 x 224 像素。
  3. 模型选择:选择顺序 CNN 模型，因为它简单且适合于图像分类
  4. 训练模型:在我们的 7616 幅图像的数据上用 80/20 训练测试分割来训练模型
  5. 评估模型:评估模型的结果。它对班级的预测有多好？
  6. 超参数调整:该过程用于调整超参数，以获得更好的结果。在这种情况下，我们已经调整了我们的模型
  7. 做预测:检查它对真实世界数据的预测有多好

数据收集

我们从互联网上的不同零件库中下载了各种螺母和螺栓的零件数据。这些网站有来自不同制造商的不同文件格式的标准零件的大量 3D 模型。因为我们将使用 FreeCAD API 来提取图像，所以我们下载了中性格式的文件(步骤)。

CAD 模型下载流程图

如前所述，4 个类中的每个类有 238 个部分被下载，总共有 952 个部分。

数据准备

然后，我们使用 FreeCAD API 运行了一个程序，该程序自动拍摄了每个部分 224 x 224 像素的 8 个等距截图。FreeCAD 是一个免费开源的通用参数化 3D 计算机辅助设计建模器，它是用 Python 编写的。

数据是如何创建的流程图

如上所述，每个数据创建 8 个 224 x 224 像素的图像。所以我们现在从 4 个类中的每一个类总共有 1904 个图像，因此总共有 7616 个图像。即使 8 幅图像来自同一个零件，每幅图像也被视为单独的数据。

8 个 a 2 螺栓的等距图像。每一行代表不同的部分。

这些图像按照它们的类别被保存在不同的文件夹中。即我们有四个文件夹螺母、螺栓、垫圈和定位销。

接下来，这些图像中的每一个都被转换成一个数组，其像素值为灰度。像素值的范围从 0(黑色)到 255(白色)。所以实际上有 255 种灰度。

转换为像素值数组的图像示例。(来源: openframeworks.cc )

现在我们的每个图像都变成了一个 224 x 224 的数组。因此，我们的整个数据集是一个 7616 x 224 x 224 维的 3D 数组。
7616 ( 图像数量 ) x 224 x 224 ( 每个图像的像素值)

使用 matplot.lib 可视化我们的像素阵列

类似地，我们创建一个标签数据集，将下面所示类的整数值赋给数据集中相应的索引。如果数据集(X)中的第 5 个(索引)数据是一个定位销，标签集(Y)中的第 5 个数据将具有值 0。

#integers and the corresponding classes as already mentioned above
{0: 'locatingpin', 1: 'washer', 2: 'bolt', 3: 'nut'}

型号选择

由于这是一个图像识别问题，我们将使用卷积神经网络(CNN)。CNN 是一种处理图像数据特别好的神经网络。神经网络是一种机器学习算法，其学习方式类似于人脑。

基本的神经网络。(来源:媒体文章作者康纳·麦克唐纳

卷积神经网络。我们的算法将如何工作的基本可视化(原始图像来源:文章由阿迪特·德什潘德

下面的代码是我们 CNN 的样子。不懂也不用担心。这个想法是来自我们每个数据的 224 x 224 特征将通过这些网络并给出一个答案。该模型将相应地调整其权重，并在多次迭代后能够预测随机图像的类别。

#Model description
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_1 (Conv2D)            (None, 222, 222, 128)     1280      
_________________________________________________________________
activation_1 (Activation)    (None, 222, 222, 128)     0         
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 111, 111, 128)     0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 109, 109, 128)     147584    
_________________________________________________________________
activation_2 (Activation)    (None, 109, 109, 128)     0         
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 54, 54, 128)       0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 373248)            0         
_________________________________________________________________
dense_1 (Dense)              (None, 64)                23887936  
_________________________________________________________________
dense_2 (Dense)              (None, 4)                 260       
_________________________________________________________________
activation_3 (Activation)    (None, 4)                 0         
=================================================================
Total params: 24,037,060
Trainable params: 24,037,060
Non-trainable params: 0

这里是 Mark Rober(美国宇航局机械工程师)在 YouTube 上的一段视频，他解释了神经网络如何在很少编码的情况下工作。

模特培训

现在终于到了使用我们的 7616 张图像的数据集来训练模型的时候了。因此，我们的[X]是一个 7616 x 224 x224 的 3D 数组，而[y]标签集是一个 7616 x 1 的数组。为了所有的训练目的，数据必须被分成至少两部分:训练和验证(测试)集(当只涉及 2 个集时，测试和验证可以互换使用)。

数据被分成训练集和测试集。(来源:researchgate.net)

训练集是模型看到并训练的数据。这是它调整权重和学习的数据。我们的模型在这个集合上的精度就是训练精度。一般高于验证精度。

验证数据通常来自与定型集相同的分布，并且是模型尚未看到的数据。模型根据训练集进行训练后，它将尝试预测验证集的数据。它预测的准确程度，就是我们验证的准确性。这比训练精度更重要。它显示了模型的泛化能力。

在实际应用中，通常将其分成三部分。培训、验证和测试。

对于我们的例子，我们将只把它分成训练集和测试集。这将是一个 80-20 的分裂。80 %的图像将用于训练，20%将用于测试。即在 6092 个样本上训练，在总共 7616 个样本中的 1524 个样本上测试。

模型训练的可视化。(原图片来源:媒体文章作者虞凤峰

对于我们的模型，我们训练了 15 个时期，批次大小为 64。

历元数是一个超参数，它定义了学习算法在整个训练数据集中工作的次数。

一个时期意味着训练数据集中的每个样本都有机会更新内部模型参数。一个时期由一个或多个批次组成。

您可以将 for 循环想象为遍历多个历元，其中每个循环遍历训练数据集。在这个 for 循环中是另一个嵌套的 for 循环，它迭代每批样本，其中一批具有指定的“批量大小”数量的样本。[2]

也就是说，我们的模型将总共 15 次(历元)遍历我们的全部 7616 个样本，并且每次都调整其权重，因此每次预测都更加准确。在每个历元中，它将遍历 7616 个样本，一次 64 个样本(批量大小)。

评估模型

该模型不断更新其权重，以使成本(损失)最小化，从而为我们提供最佳精度。成本是模型在预测图像类别时的不准确性的度量。成本函数用于估计模型的表现有多差。简而言之，成本函数是衡量模型在估计 X 和 y 之间关系的能力方面有多差的一种方法

如果算法预测错误，则成本增加，如果预测正确，则成本降低。

经过 15 个时期的训练，我们可以看到下面的损失和准确性的图表。(在我们的案例中，成本和损失可以互换使用)

从 matplot.lib 生成的图表显示了我们模型的训练和验证损失

模型训练次数越多，损失越小。它可以更好地对每个时期的图像进行分类。该模型不能在验证集上提高太多的性能。

从 matplot.lib 生成的图表显示了我们模型的训练和验证准确性

随着模型在每个时期的训练，精确度增加了。它在图像分类方面变得更好。验证集的准确性低于训练集，因为它没有直接在其上训练。最终值为 97.64%，还不错。

超参数调谐

下一步将是改变超参数、学习率、时期数、数据大小等。来改进我们的模型。在机器学习中，超参数是一个参数，其值用于控制学习过程。相比之下，其他参数(通常是节点权重)的值是通过训练获得的。[3]

出于我们的目的，在撰写本文之前，我们已经修改了这些参数，以获得在本文上显示的最佳性能。我们增加了数据集的大小和历元的数量，以提高精确度。

超参数影响参数并最终影响最终得分(准确性)。(来源:deepai.org)

做预测

对模型进行调整后的最后一步是使用将用于该模型的实际数据进行预测。如果模型在这方面表现不佳，可以开始进一步的超参数调整。

机器学习是一个相当迭代和经验性的过程，因此超参数的调整经常被比作艺术而不是科学，因为尽管我们知道通过改变某些超参数会发生什么变化，但我们不能确定这一点。

机器学习算法流程图(原图: pngfind )

应用程序

这种对机械零件进行分类的能力使我们能够仅根据客户提供的图像或 CAD 模型从标准库中推荐零件。目前，要从标准库中搜索所需的零件，您必须浏览目录，并能够根据可用选项和您对目录的了解来判断您想要哪个零件。需要记住序列号，因为单个数字或字母的变化可能意味着不同类型的零件。

来自 TOREX 网站的零件号示例。

如果一幅图像可以用来从标准库中获得所需的零件，我们需要做的只是制作一个粗略的 CAD 模型，然后通过我们的算法发送出去。该算法将决定哪些部分是最好的，并帮助缩小我们的搜索范围。

推荐算法如何工作的可视化

如果分类方法足够详细和精细，它应该能够详细分类您想要的零件类型。缩小搜索范围可以节省大量时间。这在有数千个相似零件的库中特别有用。

结论

深度学习(人工智能)是一个具有巨大可能性的研究领域，因为它使我们能够从原始数据中提取大量知识。其核心仅仅是数据分析。在这个互联网时代，数据无处不在，如果我们能够有效地提取数据，就可以完成很多事情。

这个领域在机械工程领域也有很多可能的应用。由于几乎所有深度学习的研究都需要领域专家，因此建议所有对数据分析感兴趣的工程师，即使他们没有主修计算机科学，也要学习数据科学、机器学习并研究其可能性。该领域的知识加上数据分析的技能将真正帮助我们在自己的领域中脱颖而出。

承认

我很感谢亲械甲怪的头脑让我这样做，特别是它的数据科学团队，包括 Gopal Kisi，Bishesh Shakya 和系列 Chikanbanjar，他们对这个项目的巨大帮助。pro-Mech Minds & Engineering Services 是尼泊尔一家在工程领域同时提供机械和 IT 解决方案的公司。这个想法是结合设计工程和数据科学的一次尝试。最后但同样重要的是，我要特别感谢 Saugat K.C .担任我们数据科学团队的导师。

来源

链接到 github 中的代码

参考

[1] 康纳·麦克唐纳，机器学习基础(一):成本函数与梯度下降(2017) ，走向数据科学

[2] 杰森·布朗利， 神经网络中批次与历元的区别( 2018)，machinelearningmastery.com

[3] 超参数 _(机器学习)，维基百科

[4]吴恩达，深度学习的卷积神经网络，deeplearning.ai(未注明)。检索自 Coursera

医疗保健行业中的人工智能

原文：https://towardsdatascience.com/artificial-intelligence-in-the-healthcare-industry-3aea245bce93?source=collection_archive---------76-----------------------

人工智能如何引领诊断和药物发现的未来

Jair Lázaro 在 Unsplash 上的照片

人工智能是推动医疗保健未来发展的技术之一。人工智能并不打算(也不可能)完全自动化医疗保健流程。人工智能机器人医生和护士不是这里的目标。相反，与人工智能并肩工作的医疗保健专业人员将开创一个前所未有的病人护理效率的新时代。在这篇文章中，我们将回顾人工智能如何改善当前围绕患者诊断和药物发现的系统，并考虑阻止人工智能在医疗保健中实施的障碍。

诊断

目前，误诊是一个巨大的问题:仅在美国，估计每年就有 1200 万人遭受诊断错误，每年在美国医院中估计有 40，000 到 80，000 人因误诊而死亡(来源:【激烈医疗】)。通过 AI，特别是卷积神经网络(CNN)，可以更准确地从医学成像中诊断疾病。在我们讨论 CNN 如何诊断疾病之前，让我们先了解一下 CNN 是什么。

来源:技术运行【CC BY 4.0】

人工神经网络模仿人脑的生物神经网络，并可以基于过去数据中识别的模式进行预测。CNN 是一种神经网络，通常包括卷积层和最大池层。卷积将滤镜应用于构成输入图像的像素集合。这导致激活。这种过滤器的重复应用产生了一种称为特征图的激活图，它本质上告诉计算机关于图像的信息。卷积层之后是最大池层。在 max-pooling 层中，图像上的过滤器检查每个部分中的最大像素值(部分的大小由程序员指定)，然后使用最大像素值创建一个新的更小的图像。这些较小的图像有助于计算机更快地运行模型。当卷积层和最大池层连接到神经网络的输入和输出层时，该模型能够使用过去的标记数据来预测新图像。

来源:门德利【CC BY 4.0】

上面这些 x 光图像描绘了一个正常人、一个细菌性肺炎患者和一个病毒性肺炎患者的肺部。带有每个条件的标记图像的数据集将用于训练 CNN。在训练模型之后，我们可以将患者的 x 射线输入模型，它会将 x 射线分类为指示健康的人或感染了细菌性肺炎或病毒性肺炎的人。

实现人工智能来诊断疾病似乎非常有前途:研究发现，在正确诊断疾病方面，模型的表现与人类专业人员不相上下。最近，斯坦福机器学习小组开发了一个模型，可以在短短 10 秒内诊断肺炎！在未来，将人工智能与诊断医生结合在一起可以减少误诊的机会。

药物发现

由亚当·尼格西奥鲁克在 Unsplash 上拍摄的照片

药物研发是人工智能似乎准备颠覆的另一个医疗保健领域。由于所涉及的高度复杂性，将新药推向市场既耗时(> 10 年)又昂贵(平均花费 26 亿美元)。此外，一种药物获得 FDA 批准的可能性不到 12%(来源: PhRMA )。通过利用神经网络寻找新药，制药公司的目标是同时减少这一过程所需的时间和金钱。

神经网络由输入层、隐藏层和输出层组成。输入层是输入数据的地方，隐藏层是具有权重和偏差的神经元执行计算的地方，输出层中的激活函数给出最终输出。当神经网络在大的标记数据集上训练时，它们的预测输出与实际输出进行比较，并且误差函数用于更新权重/偏差(反向传播)。神经网络利用大量信息快速学习和预测的能力使其成为药物发现的理想选择。

在药物发现过程的第一步，研究人员寻求在分子水平上理解人类疾病。一旦研究人员形成一个想法，他们就专注于确定一个药物靶点，当药物化合物与其相互作用时，该靶点可以治疗或预防疾病。随着药物靶标的确定，研究人员筛选大量的化合物，直到他们找到最终可能成为药物的少数化合物。仅这一过程就需要三到六年。神经网络可以大大加快这个速度；例如，人工智能药物发现公司 twoXAR 已经将这一过程缩短到仅三个月左右。

挑战

同样重要的是要记住，人工智能在医疗保健领域的应用将面临各种障碍。

  • AI 在某些情况下难免会出现诊断错误；与人为错误相比，患者可能会对人工智能错误表现出更多的关注。根据医疗事故法，医生可以因误诊而被起诉，但目前不存在因人工智能误诊而提起的诉讼。
  • 对大数据集的需求给医疗保健领域采用人工智能带来了一些挑战。医疗数据不容易获得，这使得开发有效的人工智能模型变得很困难。此外，从患者那里收集数据会引发隐私问题。一个潜在的解决方案是通过区块链分类账匿名存储病人。
  • 偏见是另一个需要注意的重要问题。人工智能中的偏见是一个存在于医疗保健应用之外的问题，并扩展到对整个技术的广泛关注。由于人工智能模型根据它们在训练数据集中所学的知识进行预测，如果训练数据偏向于具有特定种族、性别、位置等的患者，它们可能无法推广到所有患者。因此，确保在训练数据集中代表不同的人群是至关重要的。

参考

[1] PhRMA，生物制药研究&开发，PhRMA 手册

[2]英特尔人工智能，人工智能如何革新药物发现，福布斯

[3] W. Nicholson Price II，医疗保健中人工智能的风险和补救措施，布鲁金斯

感谢阅读！

我是 Roshan，16 岁，对人工智能的应用充满热情。如果你对人工智能更感兴趣，可以看看我关于新冠肺炎推文情感分析的文章。

在 Linkedin 上联系我:https://www.linkedin.com/in/roshan-adusumilli/

人工智能是一个超级计算问题

原文：https://towardsdatascience.com/artificial-intelligence-is-a-supercomputing-problem-4b0edbc2888d?source=collection_archive---------29-----------------------

人工智能超级计算— 01

人工智能从业者不能回避我们的责任

Marenostrum 超级计算机—巴塞罗纳超级计算中心(图片来自 BSC

【本帖将在大师课程 超级计算机体系结构atUPC 巴塞罗那理工 的支持下BSC

下一代人工智能应用提出了新的要求苛刻的计算基础设施。支持人工智能的计算机系统怎么样？我们是怎么到这里的？谁有权访问这些系统？我们作为人工智能从业者的责任是什么？

对于人工智能来说，这是一个激动人心的时刻。我们在巴塞罗那超级计算中心拥有令人印象深刻的科学数据分析系统，涉及基因组学、生物信息学、天文学以及其他许多领域。这些系统可以做出几年前我们认为不可能的惊人之举。

此外，对于通用应用程序，我们进展非常快。例如，在视频分析中，我们在 UPC & BSC 的研究小组通过引用表达式获得了有价值的视频对象分割结果。给定一个视频和一个语言短语，我们展示如何为短语所指的对象生成二进制掩码。

图片由作者根据来自 RefVOS 的图片制作:参考 VOS、M. Bellver 等人的表述。

触发人工智能爆炸

问题是，为什么是现在？人工智能从上世纪中叶就有了。约翰·麦卡锡在 20 世纪 50 年代创造了人工智能一词，与马文·明斯基一起成为人工智能的创始人之一。此外，在 1958 年，弗兰克·罗森布拉特建立了一个原型神经元网络，他称之为感知器。此外，用于计算机视觉的深度学习神经网络的关键思想在 1989 年就已经为人所知；此外，对于时间序列的深度学习的基本算法，例如 LSTM，在 1997 年就已经开发出来了。那么，为什么现在会出现这种人工智能热潮呢？

让我们试着找出一个引发 AI 大爆发的导火索。** Oriol Vinyals 表示，根据他最近的一条推文，数据集发挥了重要作用:**

https://Twitter . com/OriolVinyalsML/status/1253053130411032576

显然，大数据集的可用性有助于深度学习的算法效率，在 7 年的时间里，每 16 个月翻一番:

图片来源:https://openai.com/blog/ai-and-efficiency/

这意味着，在 2012 年至 2019 年期间，训练分类器在 ImageNet 上达到 AlexNet 级别性能所需的操作减少了 44 倍。

在麻省理工学院的这个精彩演讲中，Oriol Vinyals 还补充了大公司和大学在这个方向上的重要贡献，如 TensorFlow、Pytorch、MXNet 等开源项目。这些 DL 框架允许我们现在访问大量基本上最先进的组件，帮助研究人员专注于核心算法组件，我们认为这些组件可能过于关注实现的细节，这有助于加快算法的进展。

大数据集和开源 DL 框架在创建“大”算法中扮演着重要角色。但目前的兴奋是由于另一个关键因素，这在 2012 年 AlexNet 赢得 ImageNet 之前并不存在。除了数据和算法，现在还有哪些东西是可用的？

我不想拒绝奥里奥尔·维尼亚的肯定；他是这个领域的老大！！！还有我们课题组的好朋友！；-)

答案是大型计算机。“计算能力是人工智能进步的关键组成部分。如今，深度学习或强化学习是混合这三个组件的结果:

作者图片

计算如何进化以满足人工智能的需求？

看看这张来自 OpenAI 的图，它已经变得非常流行:

图片作者(数据源)

自 2012 年以来，生成人工智能模型所需(或可用)的计算量呈指数增长(Y 轴是对数轴)。

一个petaflop/s-day(PFS-day)由一天内每秒执行 10 到 15 次运算组成，即总共约 10 到 20 次运算。

此外，在此期间，这些用于训练模型的计算需求增长了 300，000 多倍。在最大的人工智能训练中使用的计算量以 3.4 倍的月倍增时间呈指数增长。

摩尔定律的终结

让我们回顾一下，看看计算是如何发展的。计算机性能的大部分改进来自几十年来计算机部件的小型化。你们都听说过摩尔定律。对吗？

1975 年，英特尔创始人戈登·摩尔预测了这种小型化趋势的规律性，现在被称为摩尔定律，直到最近，计算机芯片上的晶体管数量每两年翻一倍。

原创论文:摩尔，g。数字集成电子学的进展。在国际电子设备会议的记录中(华盛顿特区，12 月)。IEEE，纽约， 1975 ，1113。

虽然摩尔定律持续了几十年，但它在 2000 年左右开始放缓，到 2018 年，摩尔的预测和当前能力(英特尔等公司制造的处理器)之间出现了大约 15 倍的差距。目前的预期是，随着 CMOS 技术接近基本极限，这一差距将继续扩大！

可悲的是，就在我们需要快得多的机器进行深度学习的时候，摩尔定律开始变慢了！

事实上，在计算机架构社区中还出现了其他重要的观察结果，这些观察结果伴随着摩尔定律: Dennard Scaling 是 Robert Dennard 的一项预测，指出随着晶体管密度的增加，每个晶体管的功耗将会下降，因此每平方毫米硅的功耗将接近恒定。根据摩尔定律，每平方毫米硅片的计算能力随着每一代新技术的发展而提高，计算机将变得更加节能。然而，Dennard 缩放预测在 2007 年开始明显放缓，其好处在 2010 年左右消失。

随着 Dennard 扩展的结束，增加芯片上的内核数量可以使功率以大约相同的速度增加。但是进入处理器的能量也必须以热量的形式带走。所以多核处理器受限于散热能力。

简而言之，应用所有这些观察的结果可以总结在下图中，该图基于最初的图“计算机性能的增长”，由 Hennessy 和 Patterson 创建:

图片作者(数据源)

在这张图中，我们可以看到，在 20 世纪 80 年代和 90 年代，当所有这些定律和观察结果都存在时，我们正在将晶体管变成快速计算机，因此当时大约每 18 个月性能就翻一番。

多好的时光啊！多么渴望啊！。现在，我们大约每 20 年才有同样的进步。综上所述，从每 18 个月因子 2 到每 18 个月因子 1.05。

从一个非常普遍的角度来看，从来自伯克利的扬·斯托伊察教授在射线峰会上的演讲中得到的想法，我们可以在前面的图表中直观地表示计算性能增长的影响(大约)。可以看出，考虑到我们正在对数 Y 轴上移动，在任何情况下，都不允许我们响应 AI 算法的需求。

作者图片

嗯，虽然摩尔定律可能已经终结，但对计算能力增长的需求并没有终结。所以，一个问题出现了，没有摩尔定律怎么得到更快的机器？

专门的硬件呢？

为了应对这一挑战，计算机架构师们将注意力集中在构建特定领域的处理器上，以通用性换取性能。背后的理念是，“不要试图做所有的事，只是例外地做几件事”。各公司竞相打造专门的处理器，如 Nvidia 的 GPU 和谷歌的 TPUs

图片来源:谷歌和英伟达

我们说的“破例做几件事”是什么意思？例如，GPU 包含数百个在 4x4 矩阵上操作的张量核，这大大加速了深度学习中基本操作的计算，例如数据矩阵乘以权重矩阵，然后是偏差的和。

但是最终，专门的硬件是不够的。与此同时，像 GPU 和 TPU 这样的加速器为桌面带来了更多的计算能力，它们本质上有助于将摩尔定律进一步延长到未来，而不是从根本上提高改进的速度。

一般来说，使用同一个 OpenAI 图，我们可以直观地表示与 CPU 相关的专用架构的性能改进的影响。但是，可以看出，在任何情况下，都不允许响应深度学习和强化学习应用的需求:

作者图片

并行性:不止一个特定于域的处理器

也许我们可以让多个特定领域的处理器协同工作？。让我们来看一个具体的例子，我们在 BSC 中使用了 4 个能够并行工作的 GPU:

图片来源: https://bsc.es

这台服务器由 IBM 提供，有两个 CPU，power 9，和 4 个 NVIDIA V100 GPU。现在，我们如何利用这些资源来提高计算速度呢？在深度学习的情况下，我们通常有两种并行方法可以用来实现这一目的:

  • 模型并行性
  • 数据并行性

在第一种方法中，我们将网络的不同层分布在不同的设备上；同时，在第二种方法中，我们在每一个 GPU 中都有相同的模型，但它们都在处理独立的数据片段，即小批量的独立部分。

作者图片

当我们有一个可能不适合单个 GPU 内存的大型模型时，模型并行性非常有用。

然而，数据并行性是大多数从业者通常用来扩大深度学习模型的训练过程的，因为他们有一个如此庞大的数据集，以至于在单个 GPU 上完成一个时期可能需要非常长的时间，可能是几个小时、几天甚至几周。

因此，当有可能共享数据集以加速训练时，我们会这样做，只要模型可以容忍更大的批量。

我们可以使用框架作为 Pytorch 的 TensorFlow 来编写多 GPU 训练。要并行化模型的训练，只需要在 PyTorch 中用[torch.nn.parallel.DistributedDataParallel](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html)包装模型，在 TensorFlow 中用[tf.distribute.MirroredStrategy](https://www.tensorflow.org/api_docs/python/tf/distribute/MirroredStrategy)包装模型。非常容易！

TensorFlow 和 PyTorch 需要一个软件堆栈，其中包括作为 Python 包安装在执行环境中的不同软件层。此外，NVIDIA 的[cuDNN](https://developer.nvidia.com/cudnn)库帮助我们挤压所有加速器的能力，例如使用我提到的张量核。

例如，当我在我们的超级计算机中执行深度学习代码时，我需要用module load 命令加载这里列出的所有模块:

**$ module load** python/3.7.4_ML cudnn/7.6.4 cuda/10.2 nccl/2.4.8tensorrt/6.0.1 openmpi/4.0.1 atlas/3.10.3 scalapack/2.0.2fftw/3.3.8 szip/2.1.1 ffmpeg/4.2.1 opencv/4.1.1 gcc/8.3.0

一个巨大的世界，我部分致力于此，并且非常重要，对于像你这样的深度学习用户来说通常是透明的。

但最终，4 个 GPU 无法满足深度学习或强化学习中出现的挑战的需求:

作者图片

我们在服务器中可以放置的 GPU 数量非常有限；在我们讨论的 Power 9 服务器的情况下，我们最多可以达到 6 个 GPU。

多服务器:分布式计算

公司必须解决这个问题的方法是将许多这样的服务器放在一起！这就是我们在 BSC 所做的，利用这个研究平台，54 台服务器通过光纤上的 InfiniBand 网络连接在一起。

作者图片

这些服务器运行 Linux 作为它们的操作系统，并且每一个都由两个 Power 9 处理器和四个 512 GB 主内存的 NVIDIA GPU组成，这意味着我们用两百多个 GPU 来计数。

InfiniBand 是互连服务器的行业标准，允许从远程服务器快速访问一台服务器的本地内存。

在这个新的场景中，我们需要软件堆栈的扩展来处理神经网络训练过程中的多个分布式 GPU。还有其他选择，但是在我们 BSC 的研究小组中，我们决定使用来自优步的 [Horovod](/distributed-deep-learning-with-horovod-2d1eea004c b2) 。Horovod 插入 TensorFlow 、 PyTorch 和 MXNet 。

[Horovod](/distributed-deep-learning-with-horovod-2d1eea004c b2) 使用消息传递接口(MPI) 与以分布式方式执行的进程进行通信。MPI 是一种普遍存在于任何超级计算机中的编程模型，用于通信在不同服务器中执行的进程。它还使用 NVIDIA NCCL2 库来管理服务器中 GPU 之间的数据通信。

为了加速训练，Horovod 使用了之前介绍的数据并行训练模型。也就是说，所有工人都在不同的数据上训练，所有工人都有相同的模型副本，神经网络梯度也是交换的。

这些年来，并行性和分布策略的总和使得人工智能社区对计算的需求不断增长。

新的大型计算机:超级计算的怪物

这种硬件和软件技术的结合创造了真正的超级计算怪兽。例如，谷歌拥有数百个 TPU 的计算基础设施，这些 TPU 可以放在一起合作解决深度学习和强化学习社区中出现的挑战。

图片来源:https://cloud . Google . com/blog/products/ai-machine-learning/Google-breaks-ai-performance-records-in-worlds-fast-training-super computer

谷歌最近的一篇论文提出了一个多语言翻译质量模型，有 6000 亿个参数。为了了解这个问题的严重性，我们可以将其与著名的 GTP-3 进行比较，这是 OpenAI 创建的第三代语言预测模型。它“只有”1750 亿个参数。

在这种情况下，我们谈论的计算需求相当于 22 年 1 TPU。在这篇论文中，作者用 TPU 年来衡量业绩。一个有趣的度量！。这意味着，如果我们只有一个可用的 TPU，我们将需要 22 年来做培训。

在这种情况下，Google 将培训分布在 2048 个 TPU 上，仅用了 4 天就取得了成效。

关于谷歌 TPU 基础设施系统架构的详细信息可以在这里找到。

更新 15/04/2021-来自微软、英伟达和斯坦福大学的研究:他们研究如何缩放一万亿参数模型的模型。参见论文GPU 集群上的高效大规模语言模型训练。

新的大算法:深度强化学习

在上一节中，我们考虑了一个深度学习问题，作为当今人工智能应用程序急切而快速地吞噬计算的一个例子。但实际上，人工智能领域的前沿应用是基于需要大量计算的深度强化学习模型。

如果你想通过介绍性的系列文章了解强化学习，这些文章涵盖了强化学习和深度学习的基本概念，从深度强化学习领域开始，你可以在这里找到它。

几年前，像 DQN 这样的基础算法是为了消耗一些硬件资源而构思的；例如，1CPU+1GPU 就足够了。如果我们按照时间线，分布式强化学习(RL)算法的初始版本只需要多几个 CPUs 例如异步演员-评论家方法 (A3C)，它在几个 CPU 和单个 GPU 上工作得非常好。

然而，如果我们仔细看看强化学习算法的最新发展，我们会发现它们越来越需要更多的计算资源。例如，两年前，一个名为黑斑羚的大规模分布式 RL 被设计成利用数百个 CPU。

当前分布式强化学习代理的架构通常分为参与者和学习者。这是黑斑羚的例子:

https://ai . Google blog . com/2020/03/massively-scaling-reinforcement . html

通常在 CPU 上执行的参与者在环境中采取步骤和在模型上运行推理之间迭代，以预测下一个动作。在收集了足够数量的观察数据后，参与者将向学习者发送观察数据和行动的轨迹。然后学习者优化模型，将模型的参数发送给行动者，每个行动者更新其推理模型的参数。在这种算法中，学习者使用来自数百台 CPU 机器上的分布式推理的输入在 GPU 上训练模型。

分布式强化学习方法的最新版本，来自 DeepMind 的种子方法，允许使用超过 200 个 TPU，太神奇了，对吧！！允许我们认为真正的大规模强化学习。

照片由 Jordi Torres 拍摄

好吧，不进入细节，假设种子强化学习架构被设计来解决IMPALA 方法中存在的一些缺点。在这种情况下，神经网络推理由学习者在 TPUs 上集中进行(而不是像 IMPALA 那样在 actor 中)，从而通过确保模型参数和状态保持在本地来实现加速推理和避免数据传输瓶颈。

虽然 actor 在每个环境步骤都向学习者发送观察结果，但由于非常高效的网络库 gRPC (在功能上等同于我之前提到的 MPI)，延迟保持得很低。这使得在一台机器上每秒可以完成多达一百万次查询。

图片来源:https://ai . Google blog . com/2020/03/massively-scaling-reinforcement . html

总之，学习器可以扩展到数千个核(例如，高达 2048 个 TPU)，并且演员的数量可以扩展到数千个机器以充分利用学习器，使得以每秒数百万帧的速度训练成为可能。印象深刻吧。

人工智能:超级计算能力是真正的推动者！

我们可以得出结论，计算正在响应人工智能社区的需求，允许我们解决所提出的模型。我在这份出版物中的论点是，计算能力是真正的推动者，或者，如果你喜欢，是人工智能进步的关键组成部分，当我们混合这三个组成部分时:大数据、大算法和大计算机。

在此期间，是什么推动了有效计算的变化？OpenAI 将人工智能和计算趋势分为摩尔定律和增加的支出/并行化，以及算法效率的进步:

图片来源:测量神经网络的算法效率 Danny Hernandez，Tom B. Brown OpenAI。

作者估计，2012 年至 2018 年间，最大规模的人工智能实验可用的有效训练计算将增加 750 万倍。

看起来计算将继续响应深度学习和强化学习社区的需求，允许他们解决所需的模型。

想象一下，谷歌需要更多的计算能力来实现一个新的强化学习算法，那么，谷歌唯一会做的就是聚合更多的并行和分布式服务器！仅此而已！

例如，几个月前，谷歌在行业标准基准 MLPerf 中打破 AI 性能记录。 MLPerf 基准测试模型被选为尖端机器学习工作负载的代表。

在这种情况下，Google 唯一需要做的就是聚合更多的服务器。最终的系统包括 4096 个 TPU 和数百台 CPU 主机，它们通过超高速互连连接在一起。总的来说，该系统提供了超过 430 PFLOPs 的峰值性能。

图片来源:https://cloud . Google . com/blog/products/ai-machine-learning/Google-breaks-ai-performance-records-in-worlds-fast-training-super computer

现在看来，增加服务器可以让我们对人工智能模型的需求做出反应。很简单，对吧？嗯，不是这样的！

需要思考的事情

在完成我的文章之前，让我给你布置一些“家庭作业”让你自己做。你承诺去做吗？希望如此！

谁能拥有并支付这些超级计算机？

在阅读了上一节之后，一个重要的问题出现了:解决这些挑战需要多少计算成本？你想过吗？

例如，根据下面的推文中的，我之前提到的训练使用深度学习产生类似人类文本的 transformer GPT-3 语言模型的估计成本在公共云上接近 1200 万美元。

图片来源:https://twitter.com/eturner303/status/1266264358771757057

2020 年 11 月 29 日更新:腾讯的一篇新论文再次展示了规模的力量，他们使用了一个包含 250，000 个 CPU 内核和 2，000 个 NVIDIA V100 GPU的集群进行培训。

也许你已经听说过 top500 榜单，这个榜单记录了世界上最快的计算机，每年发布两次，分别在 6 月和 11 月世界两大超级计算大会期间( SC 、 ISC )。

一般情况下，公共机构中托管有超级计算机，峰值性能以万亿次浮点运算(每秒 10 到 12 次运算)为单位，如下表所示。例如，Top1 的峰值性能为 500，000 万亿次。

TFlop/s =每秒 1 000 000 000 000 次数值运算。

2020 年 6 月 500 强榜单前十名(图片由 Jordi Torres 提供)

现在，Marenostrum 4，这台位于巴塞罗那的超级计算机，位于 UPC 大学校园的 Torre Girona 的教堂，在这个列表中占据了第 38 位，对我们来说不错！(虚访)。

之前提到的谷歌系统，包括 4096 个 TPU 和数百个通过超高速互连连接的 CPU 主机，提供超过 430，000 TFLOPs 的峰值性能。接近世界第一(根据 2020 年 6 月榜单)，和第二以及其他人相差甚远！

为了创造人工智能，我们需要超级计算机。谁能拥有并支付这些超级计算机？仅民族国家和跨国公司？

人工智能碳足迹

上周，西班牙报纸《先锋报》刊登了这篇文章:数字世界是这个星球上的第三个污染者。

照片由 Jordi Torres 和 Júlia Torres 拍摄

此外，麻省大学的研究对人工智能不可持续的成本提出了建议。他们声称，训练一个通用 NLP 模型的估计碳成本相当于从纽约到北京的 125 次往返航班产生的碳量。

这些数字可能是相对的，因为组织可以使用可再生能源为他们的计算设施供电。然后他们可以减少碳足迹。例如，冰岛的能源 100%来自可再生的地热和水力发电，其国家电网现代化且可靠；这意味着那里的人工智能系统运行更有效，提供更清洁的能源。

但是，即使这些数字是夸大的，人工智能计算需求的指数增长也很难想象我们可以在短期内只用绿色能源来驱动超级计算。

目前，绝大多数人工智能算法研究都集中于实现最高水平的准确性，而不太关注计算或能源效率。但随着世界的注意力转移到气候变化上，人工智能领域是否应该开始注意它的碳足迹？

我们不能逃避我们的责任

人工智能肯定正在渗透社会，就像电一样，我们会期待什么？我们将“发明”的未来是我们共同做出的选择，而不是偶然发生的事情。

这很好！例如，遗传学和基因组学从 DNA 和的信息中寻找突变和疾病的联系。在人工智能的帮助下，人体扫描可以早期发现疾病，并根据他们的遗传基因预测人们可能面临的健康问题。

但是就像生活中的大多数事情一样，哪里有光，哪里就有阴影。人工智能算法传播性别偏见，人工智能系统在未经公民知情同意的情况下对其进行监控。在许多其他的坏事中！

我们必须仔细考虑即将采用的人工智能及其影响。如果我们继续建设人工智能，而不考虑我们防止其滥用的责任，我们永远也不能指望看到人工智能帮助人类繁荣。

我们所有人，无论是正在研究还是想要研究这些课题的人，都不能回避我们的责任，否则，我们将来会后悔的。

感谢您阅读本出版物！

****鸣谢:非常感谢胡安·路易斯·多明格斯、阿尔瓦罗·约弗·阿尔瓦雷斯、米克尔·埃斯科瓦尔·卡斯特尔斯和劳尔·加西亚·富恩特斯对本文件校对工作的贡献。

BSC-CNS 人工智能研究组的新兴技术

我们在巴塞罗那超级计算中心** 和 UPC 巴塞罗那理工 的研究小组正在做这个课题的研究。**

动机

现实世界的挑战，例如卫生或银行等部门的图像处理，正在推动基础研究，以创建新的大型深度和强化学习模型。然而，创建这些新模式只是解决这些挑战的一部分。这些模型的训练过程需要大量的计算和执行时间。但是，在今天的并行和分布式基础设施中扩大大型深度和强化学习模型已经成为一个重大挑战，因为它需要机器学习和超级计算方面的大量多学科专业知识。总的来说，这两个领域的研究到目前为止还没有走到一起；现在需要努力在这些算法的并行化中提供联合解决方案，不仅需要对它们重新编程，还需要知道如何有效地使用并行和分布式资源。因为正如强化学习的主要研究者之一 Rich Sutton 最近所说的那样，“通过大规模计算增强的一般方法是最有效的”。我们的研究小组旨在引入将这两个研究领域相结合的解决方案。人工智能革命不仅仅是关于新的数学模型；这是关于如何利用 HPC 为下一代深度和强化学习方法提供的前所未有的机会。****

我们在这方面的最新论文

探索、发现和学习:状态覆盖技能的无监督发现，发表于第 37 届国际机器学习会议(ICML2020) 。提出了一种新的强化学习无监督技能发现范式。是我们和 @DocXavi 共同指导的博士生之一 @vcampos7 最后的贡献。本文由来自 Salesforce Research 的 @alexrtrott 、 @CaimingXiong 、 @RichardSocher 共同撰写。

关于 BSC 和 UPC

巴塞罗那超级计算中心 (BSC)是位于巴塞罗那的公共研究中心。它拥有一台 13.7 千万亿次的超级计算机，其中也包括新兴技术集群。2017 年 6 月世界排名第 13 位。

加泰罗尼亚理工大学(Universitat politècnica de Catalunya)，目前简称 BarcelonaTech ，俗称 UPC ，是西班牙加泰罗尼亚地区最大的工科大学。它还提供其他学科的课程，如数学和建筑。

本系列内容:

人工智能的超级计算

  1. 人工智能是超级计算问题
  2. 利用超级计算机进行深度学习训练
  3. 并行和分布式基础设施上的可扩展深度学习
  4. 用 TensorFlow 在多 GPU 上训练一个神经网络
  5. 分布式深度学习与 Horovod

## 深度强化学习解释-乔迪托雷斯。人工智能

人工智能正在重演视频游戏行业

原文：https://towardsdatascience.com/artificial-intelligence-is-replaying-the-video-game-industry-842c440fca08?source=collection_archive---------30-----------------------

图片:博尔哈·洛佩兹

AI 会跟上电子游戏吗？

在过去的几年里，人工智能已经给许多行业带来了巨大的变化。其中包括卫生、法律、零售和音乐行业。今天我将带你了解人工智能是如何改变视频游戏行业的，以及我认为人工智能在未来会把视频游戏带到哪里。

你可能已经意识到了游戏行业目前正在应对的热门平台变化。以前，视频游戏是通过光盘和盒式磁带购买的，然后用来安装游戏或在设备上玩游戏。如今，数字下载是发行的主要形式，在新的转变中，我们看到了通过平台向流媒体游戏转移的显著趋势，如 Steam 或谷歌最近推出的自己的视频游戏流媒体平台 Stadia 。除了这一发展，我们还看到了从常规流媒体到云流媒体的转变。这就带来了一个问题:“云流媒体会取代游戏机吗？”

图片:Stas Knop

为什么要在电子游戏中使用 AI？🎮

人工智能在视频游戏中的应用比大多数人意识到的要多得多。最早记录的人工智能在视频游戏中的使用可以追溯到 1978 年，当时流行的街机游戏如 Pong、太空入侵者、吃豆人、大金刚和大金刚都集成了某种形式的人工智能。人工智能主要对游戏中编码的某些动作以及一些随机移动做出反应。尽管游戏中的角色并没有边玩边学习，但这是在电子游戏中首次引入人工智能。

《吃豆人》于 1980 年首次发布，里面有一些类似 AI 的元素。有四个幽灵出现在这个名为。Inky，Blinky，Pinky 和 Clyde，每个人都有自己的个性，目的是游戏永远不会无聊。反过来，它会有玩家可以学习的行为。比如 Blinky 喜欢追吃豆人，Pinky 喜欢伏击吃豆人。

在视频游戏中用于模拟人工智能的一种广泛使用的算法是有限状态算法或 有限状态机 。有限状态算法表示并控制视频游戏的执行流程。它由一个或多个状态组成，但一次只能有一个状态处于活动状态。作为实现人工智能的一种方式，它工作得很好，因为它对视频游戏中的不同场景做出了很好的响应。

图片:费尔南多·贝维拉克瓦

目前大多数游戏中人工智能最常见的用途是在非玩家角色(通常指 NPC)中。NPC 只是一个不受用户控制的角色，然而，它是用来增强游戏体验的。NPC 使用人工智能来控制他们对游戏中用户行为的反应。

图片:凯文·彼德维尔

目前使用人工智能的视频游戏🎮

“视频游戏”中的人工智能实际上可以追溯到 1948 年，当时艾伦·图灵(通常被称为计算机科学之父)和大卫·尚珀诺恩为流行的棋盘游戏国际象棋开发了一种算法。这种算法是在计算机甚至可以执行简单查询之前开发出来的。这个项目被称为“涡轮增压”。

如今，《侠盗猎车手 5》(gt a5)已经将人工智能编入其中。虽然自动驾驶汽车还不允许在现实世界中的全球道路上漫游，但《侠盗猎车手 5》却不是这样。游戏中实施了一定数量的人工智能，以允许汽车学习如何自动驾驶。这个概念是由一个狂热的程序员和成功的商人 Harrison“sendex”Kinsley 提出的。多年来，GTA 5 一直被用于大学的人工智能研究。虽然 Rockstar Games 不赞成他们的代码未经他们允许就发表，但这并不能改变这些年来对人工智能研究有益的事实。

《红色死亡救赎 2》背后的团队希望为玩家创造一种身临其境的体验。这包括一个动态的环境，它会随着你的行动而真实地变化。还有一个人工智能奖杯，一旦完成三部分任务就可以领取。任务包括通过在特定时间(白天或晚上)完成一系列任务来定位 Marco Dragic。

最令人印象深刻的是《使命召唤 2》中使用的开创性 AI。玩家周围有许多盟军士兵，他们完全意识到周围环境的变化。他们还可以使用一个新的上下文敏感的战斗聊天系统来警告玩家。他们可以吸引敌人的火力，并移动坦克到盾牌作为掩护。他们也可以警告你即将到来的军队和激进分子的火力。

图片:苏米尔·库马尔

人工智能在电子游戏中的未来🎮

人工智能在不断进步。我们训练人工智能越多，给它的数据越多，它就变得越好。这是真的，尤其是在电子游戏中。人工智能从玩家的输赢中学习。在识别这些成功和失败时，人工智能可以用来识别这些在哪里发生以及它们是如何发生的。

2021 年，中国游戏市场将达到 350 亿美元。中国游戏市场巨大，据说还会变得更大，仅中国就有超过 6 亿“游戏玩家”。这是一个巨大的数字，这些统计数据对中国市场来说非常有希望。

图片:杰西卡·刘易斯

正如你所看到的，视频游戏行业目前正在经历一些大的变化，这对于游戏爱好者来说是非常令人兴奋的。然而，他们可能还需要一段时间才能赶上现有的高水平人工智能，并将其应用到游戏中。

所有观点和意见仅代表我个人，不代表甲骨文

人工智能正在重塑时尚产业

原文：https://towardsdatascience.com/artificial-intelligence-is-restyling-the-fashion-industry-c2ce29acae0d?source=collection_archive---------10-----------------------

图像:使用 Canva 创建

人工智能如何被用来修补市场上最大和最具竞争力的行业之一。

人工智能目前是一个时髦的术语，但它是如何被用来改善全球最大的行业之一的呢？人工智能正被用于提高服装制造和企业运营的生产率。新的和新兴的技术可以用来提高可持续性，并产生一个定制的，个人的客户体验。

人工智能是如何在时尚界得到应用的？💻

人工智能正在时装业中以许多不同的方式使用。人工智能在时尚界的第一个用例是作为顾问角色。人工智能数字助理正被用来根据顾客的身高、体重、体型和当前尺寸向他们推荐衣服。然后，客户可以根据他们输入系统的详细信息获得准确的尺寸。尺寸精度基于其他客户的反馈。平均来说，40%的网上购物最终会被退回。在客户咨询中使用人工智能很重要，因为它可以提高客户满意度，减少退货次数。

人工智能还可以用于商店和在线零售的实用性和生产力。通过记录销售、退货和网上购物，零售商可以跟踪库存，判断哪些商店需要哪些产品。根据凯捷的一项调查，人工智能可以通过提高多个流程和运营的效率，帮助零售商在 2022 年前每年节省 3400 亿美元。这个预测数字是巨大的，可以理解为什么许多零售商希望在他们的业务中采用人工智能等新技术。

图片:乌苏娜·马达里亚加

时尚与可持续发展中的人工智能🍃

时装业仍然是全球最大的污染源之一。它负责全球二氧化碳排放量的 10% 、全球工业废水排放量的 20% 、工业使用的所有杀虫剂排放量的 25% 。认为这个行业可以继续大规模生产服装以跟上这种快速时尚流行是不现实的。然而，人工智能可以用于生产的许多阶段，以应对这种困境，进而降低库存水平。AI 为时尚提供了一个可持续的解决方案，将整体库存水平降低了 20–50%，并改善了时尚行业的工作条件。人工智能与机器学习、深度学习、自然语言处理、视觉识别和数据分析的结合使用可用于减少趋势预测中的错误，并更准确地预测趋势，这将减少生产和未使用的服装数量。

在 2017 年，旧金山的一个亚马逊团队创造了一个未命名的 AI“时装设计师”。他们开发了一种算法，分析图像并复制风格，以类似的风格制作新的项目。我们还没有达到高级时装的水平，但这些新技术预示着未来的可能性。

图像:Unsplash

一家将可持续发展放在商业模式首位并坚持多年的公司是汤姆斯。由 Blake Mycoskie 于 2006 年 5 月成立，他们的使命声明如下:

“TOMS 的使命是通过商业帮助改善生活，这是我们的核心价值观，融入了我们所做的一切。我们相信与分享这些价值观并以道德方式开展业务的其他人合作。”

每买一双汤姆鞋，他们就向贫困地区捐赠一双。截至目前，汤姆斯已经捐赠了超过9650 万双鞋子。这些鞋子由许多材料制成，如天然大麻、有机棉、再生聚酯纤维。这些材料用于鞋的鞋帮、衬里和/或鞋内底。他们不仅捐赠鞋子，还捐赠了他们净利润的 33.3%。因此，他们每赚到 3 美元的 T4，就会捐出 1 美元的 T7。这显示了汤姆为回馈世界各地的贫困社区所做的贡献。汤姆斯已经不仅仅是提供鞋子，2011 年他们开始向有需要的人捐赠处方眼镜，2014 年他们开始为每人提供 140 升(一周的供应量)的水。2015 年，他们培训了熟练的助产士，并发放了安全分娩包。他们帮助超过 25000 名母亲安全分娩。毫无疑问，当涉及到他们的业务时，汤姆有他们的优先次序。****

图片:https://www.instagram.com/toms/

设计师在时尚中使用人工智能👗

我要讨论的第一个品牌是 H&M。它是一家全球流行的服装店，由 Erling Persson 于 1947 年在瑞典创立，在全球生产大量服装。他们选择使用高级分析和人工智能来改善他们的整体业务。H&M 正在改进他们发现趋势和规划物流的方式，并通过使用人工智能技术减少打折销售的数量和大量未售出的库存。他们还利用它来检查供求关系，并向每个商店分配足够数量的商品，再次减少了浪费的衣服数量。在 H&M 集团，他们将分析和人工智能与人类智能结合起来，使用所谓的“放大智能”

Stitch Fix 由 Katrina Lake 于 2011 年 2 月成立。这是一家为男性和女性提供个人风格服务的公司。他们使用来自顾客和客户的数据为用户创造准确的结果。客户输入他们的数据以创建简档。你回答这样的问题:“你喜欢购物吗？”以及“你早上花了多少时间准备”来产生个性化的体验。有许多不同的技术可以使这个工具/应用程序成功。其中一些包括:推荐系统、人工计算(利用人工智能解决计算问题)、物流优化、状态机(一台机器可以有不同的状态，但一次只能实现一个状态)、需求建模、库存管理和数据平台(其他系统可以访问的客户数据库)。

图片:Pexels

最后

人工智能在时尚行业有很多好处，包括使用在线时尚助手来改善客户体验、趋势预测和产生更可持续的解决方案。在一个消费者驱动的时代，我们必须向他们传达正确的信息，并鼓励他们参与讨论，因为我们正在走向一个更加数字化的时代。正如霍华德·米特曼(Bleacher Report 的首席执行官)所说:“内容是王道，但参与是女王，她说了算。”**

*所有观点和意见都是我自己的，不代表甲骨文。”

人工智能是破解宇宙奥秘的关键，下面是原因！

原文：https://towardsdatascience.com/artificial-intelligence-is-the-key-to-crack-the-mysteries-of-the-universe-heres-why-56c208d35b62?source=collection_archive---------38-----------------------

人工智能、数据科学和深度学习的工具是否先进到足以破解不可测量的宇宙的秘密？让我们来了解一下！

由 Unsplash 上 Greg Rakozy 拍摄的照片

几千个世纪以来，宇宙一直吸引着人类。看着天空让人想知道宇宙有多大。有太多的东西等待我们去探索和发现。宇宙既巨大又美丽。宇宙学家和天体物理学家正在尽力揭开宇宙的奥秘。既然宇宙如此浩瀚，我们很自然会想知道关于这个天体的各种概念和哲学。

人类的好奇心是由未知所驱动的。卫星每年发射数百万亿字节的信息，智利正在建设的一台望远镜每晚将产生 15 万亿字节的太空照片。现代望远镜可以扫描并覆盖很长的距离，但还不够长。宇宙太大了，无法达到预期的范围。

照片由 Amy-Leigh Barnard 在 Unsplash 上拍摄

在有限的技术和预算问题下，大型宇宙飞船和更好的设备，我们如何实现探索宇宙的目标？人工智能是解决这个问题的方法吗？

嗯！在提到所有限制的情况下，人工智能是黑暗宇宙中的亮星。这很可能是解决宇宙复杂性和征服宇宙奥秘的完美方案。

人工智能如何帮助克服这一点？

随着人工智能技术在数据科学、探索性数据分析和计算机视觉领域的进步，我们可以取得超乎想象的结果。

自从我们用望远镜开始对话以来，人工智能是打击更远距离的不清晰图像的最佳解决方案。如果你想知道这到底是如何工作的，那么你会惊讶地知道，人工智能特别是计算机视觉和深度神经网络领域处理图像绝对是非常棒的。

由于在这些方面的发展，我们有一种方法来创造许多清晰的视觉效果，可以识别这些模糊的再图像如何被重建来创造更多的副本。最后，我们可以确定这些神经网络产生的这些异常有效的图像的真阳性率和假阳性率。

正如这篇研究论文所描述的，将这项技术应用于寻找引力透镜出人意料地简单。首先，科学家们制作了一个数据集来训练神经网络，这意味着生成 600 万张假图像，显示引力透镜看起来像什么，不像什么。然后，他们将神经网络从数据中解放出来，让它慢慢识别模式。稍作微调后，他们有了一个程序，可以在眨眼之间识别引力透镜。

计算机模拟来解释和数字设计一个清晰的图片来代表我们宇宙中的数十亿个实体一直是科学家们实验的概念和理论哲学，但无济于事。人工智能已经明显改变了这个范围。这一成就归功于开发了称为深度密度位移模型(D . M)的深度神经网络架构的研究人员。

Cerqueira 在 Unsplash 上拍摄的照片

根据这篇研究论文，深度密度位移模型(D M)从一组预运行数值模拟中学习，以 Zel'dovich 近似(ZA)作为输入来预测宇宙的非线性大规模结构，这是一种基于微扰理论的解析近似。他们的大量分析表明，在预测非线性区域的宇宙结构方面，D M 优于二阶微扰理论(2LPT)，后者是一种常用的快速近似模拟方法。深度密度位移模型(D M)也能够精确地外推远远超出其训练数据，并预测明显不同的宇宙学参数的结构形成。

这个模型的构建对于天体物理学家甚至是这个特殊设计的创造者来说都是一个令人震惊的惊喜。它产生了超出开发者想象的精确和准确的响应方式。D M 制作的模拟异常精确，甚至对整个宇宙进行了三维模拟，让整个开发团队都感到惊讶。

人工智能的进步不仅限于使用望远镜进行图像分割或模拟整个宇宙。宇航员在太空中生存、去月球旅行和其他太空探险都很艰难。然而，即使是由于这些太空冒险的复杂性而产生的问题，也有一个解决方案。人工智能漫游车和机器人设备的使用。

亚当·米勒在 Unsplash 上的照片

先进的现代人工智能机器人漫游车可以用来取代天文学家在外层空间的作用。火星漫游车就是现代漫游车的一个例子。将高度先进的人工智能系统与卫星、机器人漫游车和宇宙飞船连接起来的好处占据了我们的发现机会，远远超出了人类的理解。

火星探测器上的智能数据传输软件消除了人类的调度错误，否则会导致宝贵的数据丢失。这增加了来自我们的行星邻居的有用数据。同样的技术也可以用于探索太阳系的长期任务，这意味着它们需要地球上人类控制者的最小监督。

拥有人工智能技术的机器人作为一个整体包含了更多。如今，人工智能在太空应用中的使用也很广泛，从机器人到无人能去的地方，再到自主航天器和群体智能。而且，通过使用人工智能，分析卫星图像的方式、巨型星座的管理，甚至寻找太阳系外的行星都变得更加容易。

GIF 来自欧空局

我们将在本文中揭示的最后一个讨论主题是人工智能领域的重大新发展，这可能是最重要和最特殊的发现。这个概念可以启发我们关于宇宙的最高结构、设计和能力。欢迎新的人工智能称为“黑暗模拟器。”

安娜斯塔西娅·杰尼娜在 Unsplash 上的照片

困扰了科学家几代人的一个概念是暗物质背后的理论。随着对暗物质或暗能量的详细研究和突破，不仅整个宇宙结构的秘密可以被揭开，而且现代物理概念的假设和复杂区别也可能得到解决。黑暗模拟器 AI 可能是解决天体物理学家问题的最佳工具。根据主要作者 Nishimichi 的说法—

“我们使用超级计算机建立了一个非常大的数据库，这花了我们三年的时间，但现在我们可以在几秒钟内在笔记本电脑上重建它。我觉得数据科学很有潜力。利用这个结果，我希望我们能够努力揭开现代物理学最大的秘密，也就是揭开暗能量是什么。我还认为我们开发的这种方法将在自然科学或社会科学等其他领域发挥作用。”
—西道。

黑暗模拟器从现有数据中学习，创建多个虚拟世界，并不断重复学习。在用真实巡天进一步测试所得工具后，它能够在几秒钟内成功预测 Hyper Suprime-Cam 巡天中的弱引力透镜效应，以及斯隆数字巡天中记录的三维星系分布模式，精确度在 2%至 3%以内。相比之下，在没有人工智能的情况下，通过超级计算机单独运行模拟需要几天时间。

杰瑞米·托马斯在 Unsplash 上拍照

结论:

使用人工智能的各种工具和技术来解释巨大宇宙的潜力是巨大的。在遥远的未来，关于宇宙的谜、悖论和秘密将会展开，我们将会对各种各样的奥秘有一个清晰的感知，或者至少有一个探索、检查和设想宇宙永恒的简要想法。

随着图形处理单元和自动化机械化的快速持续发展，以及 GANs 等深度学习算法的发展，我们清楚地推测我们的世界是如何形成的那一天可能不会太远。当你读到埃隆·马斯克的引语时，所有这些有趣的好奇的想法都被进一步提出来了。

“人工智能(我指的不是狭义的 AI)的进步速度快得令人难以置信。除非你直接接触过像 Deepmind 这样的团体，否则你根本不知道它的发展速度有多快——它正以接近指数级的速度增长。发生非常危险的事情的风险是在五年的时间框架内。最多 10 年。”

——埃隆·马斯克

我想以有趣、有趣、奇特和奇怪的方式结束这段对话。感谢大家抽出时间，让我知道你们有多好奇去发现宇宙中的未知事物，以及我们的未来！在我看来，发现任何形式的外星生命都将是一个伟大的开始，也是一项绝对了不起的成就。

一定要让我知道你们对迷人的宇宙最感兴趣的秘密。祝你有一个美好的一天！

有兴趣了解更多关于计算机视觉和神经网络的知识吗？查看这些文章，获得深入的解释、指南和更多内容！

[## OpenCV:用代码掌握计算机视觉基础的完全初学者指南！

包含代码的教程，用于掌握计算机视觉的所有重要概念，以及如何使用 OpenCV 实现它们

towardsdatascience.com](/opencv-complete-beginners-guide-to-master-the-basics-of-computer-vision-with-code-4a1cd0c687f9) [## 神经网络的完整有趣和复杂的历史！

重温人工神经网络发展背后的迷人历史

towardsdatascience.com](/the-complete-interesting-and-convoluted-history-of-neural-networks-2764a54e9e76) [## 神经网络拿 TensorFlow 游乐场开玩笑！

使用 TensorFlow Playground 探索神经网络并从中获得乐趣

towardsdatascience.com](/neural-networks-made-fun-with-tensorflow-playground-4e681a0c4529)

其他受欢迎的文章，你应该完全考虑检查！

[## 迷失在密林中:用简单的代码对机器学习中稀疏性的直觉！

为什么 ML 需要稀疏性？理解稀疏性的核心概念。

towardsdatascience.com](/lost-in-a-dense-forest-intuition-on-sparsity-in-machine-learning-with-simple-code-2b44ea7b07b0) [## Python 从头编码:没有任何机器学习库的矩阵乘法！

从零开始了解如何在没有任何机器学习库的情况下实现矩阵乘法！

towardsdatascience.com](/python-coding-from-scratch-matrix-multiplication-without-any-machine-learning-libraries-463624fe8726)

马塞洛·奎南在 Unsplash 上的照片

参考资料:

  1. 发现千度强引力透镜的研究论文
  2. 学习预测宇宙结构的形成
  3. 人工智能可能是探索宇宙的完美工具
  4. 第一个能够模拟宇宙的人工智能工作得如此之好，以至于令人害怕
  5. 第一个人工智能宇宙 sim 快速而准确——它的创造者不知道它是如何工作的
  6. 人工智能模拟宇宙，甚至连它的创造者都不知道它是如何精确的
  7. 人工智能创造了我们宇宙的 3D 复制品。我们不知道它是如何工作的。
  8. 开发出预测宇宙结构的人工智能工具
  9. 欧洲航天局
  10. 科学家称，名为“黑暗模拟器”的新人工智能可以告诉我们宇宙的结构

人工智能领域——100 篇优秀文章和研究论文

原文：https://towardsdatascience.com/artificial-intelligence-landscape-100-great-articles-and-research-papers-6ccd07237587?source=collection_archive---------51-----------------------

AI/ML 景观

早在 2015 年，我就写过一篇关于 100 篇大数据论文的文章，以帮助揭开景观的神秘面纱。同样的，我认为为 AI 做一个也不错。最初的部分是关于基础的，并提供了一些很好的链接来巩固你的基础。后半部分有一些很棒的研究论文的链接，是为想了解理论和细节的高级从业者准备的。

人工智能是一场革命，正在改变人类的生活和工作方式。机器能够以人类认为“智能”的方式执行任务是一个广泛的概念——这个术语可以追溯到 70 年前(见历史此处)艾伦·图灵，他定义了一个测试图灵测试，来测量机器表现出与人类同等或不可区分的智能行为的能力。这场革命有许多复杂的运动部件。我的目标是简化这些复杂的部分，并提供一个三层蛋糕的视角。顶层是人工智能服务，即解决实际问题的实际应用，中间层由基本的 ML 算法组成，而底层是实现前两者的 ML 平台。

首先是基本定义，人工智能 ( AI )是由机器展示的智能，与人类展示的自然智能形成对比。机器学习(ML)是人工智能的一个子集，它基于这样一个想法，即我们应该真正能够让机器访问数据，并让它们自己学习。神经网络(NN)进一步是 ML 的子集，其中计算机系统被设计成通过以与人脑相同的方式对信息进行分类来工作。深度学习(DL)进一步是 ML 的子集，它使用多层人工神经网络来解决复杂的问题，如对象检测、语音识别和语言翻译。

关于人工智能、人工智能和人工智能之间的区别，可以在这里和这里找到一些很棒的读物。神经网络的基础知识很好的解释了这里和通过代码这里和这里。人工智能可以根据类型进行分类，如这里所解释的狭窄、一般或强大或者反应机器、有限记忆、心理理论和自我意识的级别，如这里所解释的和

ML 算法

ML 算法可以分解为有监督的、无监督的和强化学习(这里解释这里解释，这里解释这里解释，这里解释这里解释)。ML 和 DL 在如何提取特征方面有所不同。传统的 ML 方法要求数据工作者通过应用学习算法来明确地提取特征。另一方面，在 DL 的情况下，特征由算法自动学习，并且不需要特征工程-例如，来自谷歌的 Meena 新聊天机器人具有 2.6B 特征。这是 DL 相对于传统 ML 方法的优势。

神经网络受我们大脑中神经元的启发，旨在识别复杂数据中的模式。我们大脑中的神经元被组织成一个数十亿的巨大网络，每个神经元通常与成千上万的其他神经元相连，这些神经元通常位于连续的层中，尤其是在大脑皮层(即大脑的外层)。神经网络有输入层、输出层和隐藏层。具有两个或更多隐藏层的神经网络被称为深度神经网络。

人工神经网络(ANN)模拟生物神经系统。一层的输出通过使用激活函数进行转换，成为下一层的输入。激活函数是附属于网络中每个神经元的数学方程，并基于每个神经元的输入是否与模型的预测相关来确定是否应该激活(“激发”)它。激活函数可以是线性的或非线性的。TanH、Sigmoid、ReLU、Leaky ReLU 的按键激活功能在这里和这里都有解释。

有不同种类的人工神经网络，如这里的和这里的和所述。一个完整的神经网络图是这里是。

  • 感知器是单层神经网络。感知器是最古老和最简单的神经网络，创建于 1958 年。它有一个输入层和一个输出层(没有隐藏层)。感知器无法学习复杂的模式，特别是，它们无法解决一些琐碎的问题，例如异或 (XOR)分类问题。
  • 多层感知器(MLP)又名“香草”网络——感知器的局限性可以通过堆叠多个感知器来消除。MLP 是深度学习的基础。全连接层或密集层是一个层，其中一层中的所有神经元都连接到前一层中的所有其他神经元。
  • 卷积神经网络引入了卷积层和子采样层。与 MLPs 中的全连接层不同，卷积层仅连接到其各自前一层的子区域，追求受生物学启发的局部感受域的概念。CNN 基本上是一个深度神经网络，由隐藏层组成——卷积层、池层、全连接层和归一化层。CNN 适用于图像和视频识别。一些补充阅读这里，这里这里，这里这里。
  • 递归神经网络(RNN)是一种特殊的网络，它沿着时间序列而不是空间序列工作，这使得它们对于手写和语音识别等关键问题非常有用。递归神经网络(RNN)在这里和这里和有很好的解释。他们患有短期记忆。长短期记忆网络——通常简称为“lstm”——是一种特殊的 RNN，能够学习长期依赖性(长时间记忆信息)，通过维持时间状态来解决 RNN 限制，如本文所述。门控循环单元是一种更新更简单的 LSTM。LSTM 氏症和 GRU 氏症都有称为“门”的内部机制来调节信息的流动。这里很好的解释了 LSTM 和 GRU 的区别。
  • 生成对抗网络(GAN)(原论文)——是一个特殊的网络，它实际上有两个子网络生成器和鉴别器不断相互竞争。生成器尝试生成一些数据，鉴别器尝试将生成的数据与真实的样本数据区分开来。基础知识在这里，高级话题在这里。
  • 自动编码器(纸)和变分自动编码器是实现压缩和解压缩功能的特殊种类的人工神经网络。它们将输入复制到输出，首先将输入压缩成一个潜在空间表示，然后从这个表示中解压缩输出。自动编码器的两个应用是数据去噪和降维。更多这里和这里。
  • 图形神经网络(GNN) ( 论文 & 论文)是基于深度学习的方法，对图形进行操作。现有机器学习算法的一个关键假设是，每个数据实例都是相互独立的。这种假设不再适用于社交网络、地理地图、分子结构等图形数据，因为每个实例(节点)都通过链接和交互与其他实例相关。gnn 自然有助于对图形数据结构建模。像 CNN 和 RNNs 这样的标准神经网络不能处理图形输入，因为它们在从一层到下一层的处理中是顺序的。这里的基础这里的和这里的。GNN(这里的基础知识)和 CNN 的混合被称为图形卷积网络(GCN)，RNN 被称为图形时空网络，自动编码器被称为图形自动编码器。卷积网络(GCN)是更有趣的网络(基础知识这里)。这些还有两种口味。光谱 gcn 或空间 gcn。谱 gcn 使用类似于常规卷积神经网络处理方式的滤波器。另一方面，空间 GCN 通过聚集邻居节点进行卷积。
  • 脉冲神经网络(SNN) ) ( 论文)是下一代人工神经网络，它希望通过使用类似于我们大脑中神经元功能的模型来弥合神经科学和机器学习之间的差距。顾名思义，SNNs 使用离散的激活阈值或峰值，而不是常用网络中的连续值。更多此处。

鉴于神经网络模型的复杂性和爆炸式增长，有相当多的努力来自动化架构工程，以找到针对给定业务问题的最佳机器学习模型的设计神经架构搜索。这是 AutoML 和超参数优化的一个子领域。更多这里和这里。

ML 平台

重要的努力不是花费在创新新的学习算法或模型上，而是花费在使 ML 工具和基础设施更好上。ML 平台为机器学习开发人员、数据科学家和数据工程师提供了基础，使他们的 ML 项目从构思到生产和部署，快速且经济高效。

ML 生命周期

典型的 ML 生命周期始于数据准备，随后是(特征)发现、开发和训练模型、测试、部署，最后使用模型进行推理或预测。数据准备通常与获取、导出和清理足够的训练数据以馈入 ML 算法相关联。特征发现和提取识别对业务领域最重要的关键数据属性。部署包括可观察性、可调试性、监控和生产化。Auto ML 框架的云特定基准可以在这里找到。

在现代 ML 生命周期中有几个挑战(见技术债务)。

  • 多个算法和库——ML 开发人员通常希望尝试每一个可用的算法来构建最精确的模型，一个正在进行项目的团队可能会尝试多个处理库——例如 MxNet 、 TensorFlow 、 Clipper 、 Caffe 、 PyTorch 、 Theano 、 Chainer 。
  • 实验-从输入数据到超参数，模型预测可能会受到数百个配置参数的影响。
  • 精度——从训练到部署的模型可能会从数据科学家易手到数据工程师，后者可能最终会使用不同版本的库，导致模型性能不佳。
  • 部署-由于多种推理环境，如 REST 服务、批处理和在线评分，因此存在挑战。像 Kubeflow 这样的框架使得部署更加简单

斯坦福大学的 MLFlow 开源项目(Databricks)和 DAWN (面向下一步的数据分析)Stack 是试图解决这些挑战的两项努力。MLflow 的关键原则是一个开放接口设计，与现有的 ML 平台如脸书 FbLearner 、优步 米开朗基罗、网飞、谷歌 TFX 、Airbnb 大头和腾讯(见此处的对比)相比，这种开放接口设计在保留生命周期管理优势的同时给予用户灵活性和控制权。除了解决 ML 生命周期的挑战之外，DAWN Stack 还解决了从新接口到新硬件的抽象问题。

ML 堆栈

1)计算硬件——对计算硬件——CPU、GPU 和 TPU——的一个很好的观察可以在来自脸书和谷歌的这些论文中找到。量子物理学和 ML 的交叉产生了量子机器学习。谷歌最近开源了 Tensorflow Quantum ，使用谷歌 Cirq 等框架进行混合经典量子模型的快速原型制作。

2)分布式深度学习——运行高度并行的模型需要并发(见分析)和调度器( DL2 、 Optimus 和忒瑞西阿斯)。在构建分布式深度学习框架方面有很多进展，在这里可以找到很好的介绍其中比较流行的有 Google GPIPE 、优步 Horovard 、DeepMind 的 TF-Replicator 和微软的pipe dreamZero&deep speed。

3)特征存储允许不同的团队管理、存储和发现用于机器学习项目的特征。它充当数据工程和数据科学之间的 API，实现改进的协作。一个很棒的介绍可以在这里找到，这里列出了的特色店列表。几个受欢迎的是来自谷歌的盛宴和一些背景这里，来自 Logicalclocks 的 HopsWorks ，来自 LinkedIn 的 Frame 和来自 Airbnb 的 ZipLine 。 ML Ops 可以与一个特性库相结合，实现模型的训练、测试和部署的自动化。

4)可解释性和可解释性——AI 系统中信任的 4 个特征是 i) 公平性其中模型和数据没有偏见 ii) 健壮性其中不容易篡改或损害他们被训练的数据 iii) 可解释性其中决策可以被他们的消费者理解 iv) 沿袭允许审计模型生命周期的开发、部署和维护的能力。这些技术中最突出的是莱姆和 SHAP ，它们基于模型不可知的方法，专注于解释给定黑盒分类器的单个预测。局部可解释模型不可知解释(LIME)提供了一种快速的方法，通过随机地反复扰动模型特征来获得预测，然后使用预测来计算近似的线性“解释模型”。SHAP (SHapley 附加解释)通过计算每个特征对预测的贡献来工作。它源于联盟博弈论，其中数据实例的每个特征值充当联盟中的参与者，并计算每个特征的边际贡献或支出(参见 Chris Molnar 的可解释机器学习书)。这两种技术之间的进一步区别在这里有详细描述。Google 的可扩展性白皮书论文也是很好的参考。

为了消除偏见，谷歌最近引入了几个新方法，用概念激活向量( TCAV )和联合学习进行测试。TCAV 从实例数据中学习概念。例如，TCAV 需要实例数据中的几个女性实例，以学习“性别”概念。人类使用概念来思考和交流，而不是使用每个特征的权重。TCAV 解释了人类相互交流的方式。联合学习将模型训练推到边缘(以防移动计算到设备)。

5)可视化——与模型可解释性和可解释性相关的是模型可视化。白盒 AI 查看模型复杂性和模型意识，以得出不同的可视化技术。谷歌开源了 Facets 来帮助可视化训练数据，优步内部使用 Manifold ，而脸书有 HiPlot 。

6)指标-指标用于衡量模型的质量和性能。有许多不同类型的评估指标可用于测试模型。这些包括混淆矩阵、分类准确度、精确度、召回率、ROC、AUC、F1 分数、灵敏度、特异性、对数损失、均方误差和平均绝对误差。三部曲系列是很好的参考。另一个介绍性的参考是这里的。就模型预测而言，偏差和方差之间有一个权衡，这可能由于欠拟合或过拟合而发生。为了建立一个好的模型，你需要通过在偏差和方差之间找到一个好的平衡来最小化总误差。另一个需要测量的重要事情是概念漂移和模型衰减。概念漂移发生在输入和输出数据之间的关系会随着时间而改变时，这意味着根据旧数据训练的模型不再像根据最近数据训练的模型那样准确。防止模型衰变的一个好方法就是持续监控和维护它。

最后，接下来的部分是给对构建和扩展 ML 算法和平台感兴趣的 AI 技术专家的。

人工智能、机器学习和深度学习——有什么区别？

原文：https://towardsdatascience.com/artificial-intelligence-machine-learning-and-deep-learning-what-the-difference-8b6367dad790?source=collection_archive---------18-----------------------

人工智能、机器学习和深度学习的简单解释以及它们之间的区别

在 Unsplash 上 NeONBRAND 拍摄的照片

人工智能是新的电力— 吴恩达

电力改变了世界的运作方式。它改变了运输、制造、农业，甚至医疗保健。比如电灯发明之前，人类仅限于白天活动，因为晚上很黑，只有买得起煤气灯的人才能做活动。相比现在，我们仍然可以在晚上进行活动，因为它是由电灯照明的。

人工智能(AI)也是如此。 AI 预计也有类似效果。我们今天可以举的一个具体例子是广告问题。此前，出现的广告是由人类手动确定的。现在，出现的广告是由人工智能根据用户档案数据确定的。例如，如果用户喜欢时尚，那么可能出现的是服装广告。

随着技术的进步，人工智能领域的研究也在增长，因此以前定义人工智能(AI)的基准现在变得过时了。

从这一发展中产生了机器学习和深度学习等新术语。但有时，AI、机器学习和深度学习之间存在切片，因此它们之间的区别可能非常不清楚。所以在这篇文章中，我将快速解释一下人工智能，机器学习和深度学习的含义以及它们之间的区别。

让我们从这张图片开始。

人工智能、机器学习和深度学习

从图片中我们可以看出，机器学习是人工智能的一部分，深度学习是机器学习的一部分。然而，有些人认为人工智能和机器学习是分开的。然而，在这篇文章中，我将讨论机器学习是人工智能的一部分。更多细节，让我们更明确什么是 AI。

人工智能

在 Unsplash 上由 Franck V. 拍摄的照片

人工智能已经研究了几十年，仍然是计算机科学中最难理解的学科之一。这部分是因为这个主题是多么的庞大和模糊。这在我们在社会中使用计算机的几乎每一个方面都有应用。人工智能是指在机器中对人类智能的模拟，这些机器被编程为像人类一样思考并模仿他们的行为。

人工智能这个术语是由约翰·麦卡锡在 1956 年首次提出的，当时他就这个主题召开了第一次学术会议。尽管，理解机器是否真的能思考的旅程在那之前很久就开始了。

人工智能通常会分析其环境，并采取行动来最大化其成功的机会。在早期，人工智能的方法是形式逻辑和专家系统。这些方法在当时统治了 AI。

然而，随着计算能力的发展，更加强调解决具体问题，人工智能与其他领域之间也有了新的联系。由此产生的一种方法就是学习，或者我们称之为机器学习。

机器学习

马里奥·高在 Unsplash 上拍摄的照片

按照字面意思，机器学习就是从数据中学习的机器。机器学习模仿了人类从童年到成年的学习概念。例如，如果教婴儿区分狗和猫，他们会得到狗和猫的图片，以及机器，如果你想让机器学习，我们必须向机器提供关于狗和猫的知识。给出的图片越多，机器区分猫和狗的能力就越强。

图像检测—来源:pix abay(https://www . pexels . com/photo/kitten-cat-rush-lucky-cat-45170/)

机器学习与计算统计学密切相关，计算统计学侧重于做出预测。数据挖掘也与这项研究有关，这项研究侧重于通过无监督学习进行探索性数据分析。

在机器学习中，使用了几种类型的算法，并根据算法的预期输入和输出进行分组。

监督学习

监督学习创建将输入映射到期望输出的函数，例如在分类中。它观察数据的模式，并将它们转换成模型来预测未来的数据。更多细节，我们看这个例子。

分类示例

从上图可以看出，起初我们只有 cross 和 round 类的数据。然后我们有了新的数据，三角形。然后，根据之前训练的模型预测新数据。因为新数据与交叉类具有相似性，所以这些数据被分类到交叉类中。

包括在监督学习中的方法的一个例子是神经网络、kNN、决策树、朴素贝叶斯、SVM 等。

无监督学习

无监督学习对输入集进行建模，例如聚类。不同于每个数据都有一个类的分类。聚类的工作原理是将相似的数据分组。

聚类示例

从上图可以看出，首先，我们有一组数据，然后根据数据与其他数据的相似性将数据分组到特定的组中。

包括在监督学习中的方法的一个例子是 k-means、DBSCAN 等。

强化学习

强化学习是一种应用于智能代理的学习算法，使它们能够适应其环境中的条件，这是通过最大化可实现的“奖励”奖赏的值来实现的。这种类型教导如何采取行动来处理问题，一个有影响的行动。

最常见的例子是自动驾驶汽车，机器被要求避免碰撞或违规。如果发生事故或违规，那么机器将获得负奖励，如果机器做得对，将获得正价值。从那里，机器将学习驾驶汽车。

从上面的一些解释，也许我们已经明白了什么是机器学习。其中机器学习侧重于根据过去的现有数据预测未来事件。

如今，几乎所有 AI 领域的行业都专注于开发机器学习，如情感分析、图像识别等。这是基于今天机器学习的快速发展。

然而，上面提到的方法仍然有弱点，其中之一对于复杂数据不是最佳的。因此，在下一节中，我将讨论机器学习的下一个级别，即深度学习。

深度学习

乔希·里默尔在 Unsplash 上的照片

深度学习是基于学习多层(即深度)表示/抽象的机器学习算法，受大脑结构和功能的启发，称为人工神经网络。基本上深度学习就是一个大型的神经网络。

你可能会问，需要多少层才算深度？这个问题没有明确的答案，但通常有两个或两个以上的隐藏层算作深度。“深度”这个术语本身是由 Geoffrey Hinton 在他题为“ 深度信念网的快速学习算法 ”的论文中引入的，用来解释大型人工神经网络的发展。

现在新的深度学习正在出现的一个原因是，已经有更快的机器和多核 CPU/GPU，以及更快和开放的分布式系统(Hadoop、Spark 等)。

与传统的机器学习方法相比，深度学习的优势在于能够处理大量的数据集，并减少建模中的人工干预。

脸书人工智能研究总监 Yann LeCun 发表了题为“卷积网络:释放机器学习对于强感知系统的潜力的演讲，深度学习之所以被称为 deep，是因为它有几个阶段来识别一个对象，所有这些都是训练的一部分。深度学习和传统机器学习的区别可以从下图看出来。

学习分层表示法——受https://www . slide share . net/embedded vision/01-am-keynotelecun启发——pix abay(https://www.pexels.com/photo/animal-pet-cute-kitten-45201/创作的猫图像

当使用传统的机器学习时，特征提取往往是不够的，我们经常添加中级特征。但这不足以表示数据，通常这部分是通过无监督学习来训练的。基本上，它只是捕捉统计数据，没有做太多。随着深度学习，它被模块流水线所取代，并且是可训练的。但是这是要付出代价的，就是大量的计算，需要大量的数据。

深度学习的方法有很多，比如卷积神经网络(CNN)，长短期记忆(LSTM)等。如果你有兴趣了解神经网络架构，可以访问下面的链接。

[## 人工智能、神经网络、机器学习、深度学习和大数据的备忘单

最佳人工智能备忘单的最完整列表

becominghuman.ai](https://becominghuman.ai/cheat-sheets-for-ai-neural-networks-machine-learning-deep-learning-big-data-678c51b4b463)

以下是深度学习的应用实例。

  • 自动驾驶汽车
  • 机器翻译
  • 图像彩色化

如果你有兴趣更好地理解神经网络，你可以尝试使用 Tensorflow 游乐场。

[## 张量流-神经网络游乐场

这是一种构建从数据中学习的计算机程序的技术。它非常松散地基于我们如何思考…

playground.tensorflow.org](https://playground.tensorflow.org/)

如果你喜欢这个帖子，你可以看看我的其他故事。

[## 如何开始一个机器学习项目

做机器学习项目的分步指南

towardsdatascience.com](/how-to-start-a-machine-learning-project-5654832cb1ed)

人工智能可能会让你获得重身幽灵奖

原文：https://towardsdatascience.com/artificial-intelligence-might-just-get-you-your-doppelganger-6511be7a405b?source=collection_archive---------66-----------------------

如果你曾经想过在世界的某个地方拥有你的分身，人工智能可能很快就会实现。

在 Unsplash 上由 Franck V. 拍摄的照片

人类的大脑远远超出了目前任何机器的能力。虽然计算机执行数百万次计算的速度确实比人脑快得多，但人类可以执行更复杂的活动，如表达情感、在高难度地形中保持身体平衡以及适应不断变化的环境和时间。人工智能(AI)试图弥合人脑和计算机之间的差距。

其中最成功的成果之一，是由汉森机器人公司创造的人形机器人——索菲亚【1】。该公司接着说，

Hanson Robotics 最先进的类人机器人 Sophia 体现了我们对人工智能未来的梦想。作为科学、工程和艺术的独特结合，Sophia 同时也是一个描绘人工智能和机器人未来的人类科幻小说角色，以及一个高级机器人和人工智能研究的平台。

虽然这可能看起来是一个虚构的角色和一个很酷的概念，但如果有机会与你长期互动，Sophia 甚至可能会像你一样，这可能不是不合理的。有没有想过，如果你有一个跟你一模一样的二重身 AI 怎么办？这听起来可能既有趣又怪异，但人工智能研究肯定会在不久的将来实现它。

人工智能的艰难旅程

人工智能是一个非常困难的话题，但它看起来很有前途。到 20 世纪上半叶，科幻电影引入了智能类人机器人和计算机的概念。然而，爱好者们并不仅仅把这当成一部小说。到 20 世纪 50 年代初，科学家和研究人员开始对人工智能产生兴趣。艾伦·图灵就是这样一个人，他在理论计算机科学和著名的“图灵机”的发展中具有很高的影响力。在他 1950 年在发表的论文“计算机械和智能”中，艾伦·图灵提出了一个问题——

机器会思考吗？

图灵很好奇的发现,如果人类可以吸收周围的信息来学习和做决定，为什么计算机不能做同样的事情？从那时起，人工智能研究吸引了大量研究人员，并在世界各地获得了大量资金。根据国际数据公司(IDC)的数据，2019 年全球人工智能支出为 375 亿美元，预计到 2023 年将达到 979 亿美元【3】。

晨酿在 Unsplash 上拍摄的照片

如今，人工智能与人类互动的主要实现之一是通过智能手机、笔记本电脑和数字助理，如 Siri 和 Cortana。它们不仅可以帮助你完成日常任务和设置提醒，还可以了解你的习惯、喜好和厌恶，甚至可以从你的声音和电话使用中检测你的情绪。在 2018 年的谷歌 IO 活动中，谷歌展示了他们的助理如何聪明到可以给一家沙龙打电话，与电话另一端的人互动，并毫无差错地安排约会。

[## 谷歌刚刚展示了一个令人惊叹的助手打电话的演示

在 I/O 2018 的舞台上，谷歌展示了谷歌助手令人瞠目结舌的新功能:在不太遥远的…

www.theverge.com](https://www.theverge.com/2018/5/8/17332070/google-assistant-makes-phone-call-demo-duplex-io-2018)

计算技术的进步

虽然人工智能不仅仅包括神经网络方法，但是神经网络和深度学习对于人工智能的有效性变得越来越重要【4】。随着硅技术的进步，处理器变得极其节能、快速和可靠。此外，存储技术在过去十年中有了很大的发展，在速度惊人的口袋大小的固态硬盘中存储万亿字节的数据已经成为可能，而这在几年前还是不可能的。

这使得研究人员能够建立和训练人工智能所需的大型复杂神经网络【5】，以模拟类似人类的特征，如感情，以及【合理决策】【6】的重要行为。此外，大量的计算可以在这些不那么耗电的处理器上进行，这使得这种远程应用程序的电池寿命更长。在更快更准确的传感器及其与机载嵌入式系统的可靠集成方面也正在进行大量的研究【7】，这将使这样的人工智能比以往任何时候都更加了解周围的环境——甚至可能不仅仅是一个活生生的人！

在更小的外形中更快更大的存储意味着大量的信息可以存储在 AI 硬件中。这可以是由人工智能的设计者存储的信息，但更重要的是，它将使人工智能能够实时存储信息——它在与环境交互时经历的信息。这些信息可以被 AI 实时用来学习新的东西——这就是所谓的【自我意识 AI】【8】，也就是说，它知道该学什么，不该学什么。这将使这样的人工智能能够适应变化，并更真实地与环境互动。

值得一提的是新兴的 5G 技术

5G 正开始成为一种超高速网络，不仅用于数据消费，还用于近乎实时的远程控制——这要归功于其低延迟。这意味着许多人工智能决策可以在云端做出，而不需要本地存储。由于“几乎无限”的可用知识【9】，在云中存储和计算决策不仅有助于人工智能做出更加恰当的决策，还将有助于跟踪和控制人工智能不执行非法或令人反感的任务。值得看看爱立信发布的使用 5G 的远程控制设备的潜在用例。

[## 5g 远程控制设备- 5g 用例

5G 引入了远程控制设备和重型机械的能力，从而释放了改进的潜力…

www.ericsson.com](https://www.ericsson.com/en/5g/use-cases/critical-control-of-remote-devices)

他们知道我们的一切

马库斯·斯皮斯克在 Unsplash 上拍摄的照片

但是二重身是怎么回事？

人工智能怎么能像我一样思考和决策？

你有没有和朋友聊过买 iPhone 的事情，下一刻就看到一个关于最新款 iPhone 的谷歌广告？或者你是否曾经想要点菜，而你最喜欢的菜却自动上来了？或者甚至 LinkedIn 建议你一个完整的信息，你可以用它来回复一个连接？你肯定经历过这个！

像谷歌和脸书这样的大型科技公司不断收集你的数据——你搜索了什么，你和谁聊天，你喜欢谁的帖子，甚至你喜欢什么音乐。这些数据用于个性化您对他们产品的体验，让他们的产品像您一样思考！但是这些信息的范围远远超出了内容个性化。

这些数据可以专门用来训练 AI 像你一样行为和决策。随着联网设备(智能手机和可穿戴设备)的出现，关于你睡眠模式的数据，直到对你重要的人，一切都存储在云中。IEEE【10】上的一篇论文也研究了微软 Kinect 在机器人应用中的应用，这是一种检测你姿势的传感器。该论文研究了如何通过逆向工程，使用从人类受试者收集的数据，教会机器人室内导航。

这样的 AI，如果在机器人身上实现，绝对可以在办公会议上替你骗过同事。它不仅看起来像你，行为也像你，而且在某些方面还可能在决策方面比你更聪明——这要归功于 5G 和联网设备范式的出现，这将使人工智能能够跟上最新发生的事情。不，我并不是说我们的技术已经为这样的转变做好了准备，但是我们可能已经很接近了。人工智能发展的速度和吸引研究人员的速度，不难想象人工智能在我们周围的未来。但是，这将导致下一个大问题，这是本世纪最大的辩论之一！

会危及我们吗？

照片由 Mikael Seegen 在 Unsplash 上拍摄

所有这些可能看起来很酷，对人类执行任务和做决策很有帮助。但是，研究人员和非科学界也担心它可能对我们有潜在的危险。

  1. 决策 —许多人担心这种智能决策会让人类过于依赖人工智能工具来为他们做决定。随着这种影响的加深，人们将被迫相信人工智能，而不知道它是如何工作的，这也将妨碍他们独立决策的能力。【11】
  2. 网络威胁 —网络安全已经成为现代社会的一个主要问题。随着人和设备的联系越来越紧密，网络攻击者的脆弱性及其可能带来的潜在影响已经是一个令人震惊的问题。随着人工智能的突然涌入及其指数级增长，网络攻击对这种技术的影响尚未完全知晓，它可能对社会产生的后果不应被低估。随着越来越多的个人信息被人工智能使用，数据隐私等问题也是一个主要问题。
  3. 自主人工智能的危险 —随着人工智能变得越来越复杂和智能，人们相信很快它将不再需要人类输入(或所谓的监督学习)来执行任务。它将被编程为自动从环境中学习并决定其行动来执行特定的任务。然而，许多人担心这种自主行为需要在人工智能设计中考虑严格的道德规范，因为它不应该在完成其目标时造成任何伤害或破坏。斯坦福大学的一篇文章很好地说明了人工智能的这个潜在问题。

[## 人工智能和机器人伦理

人工智能(AI)和机器人是将对发展产生重大影响的数字技术…

plato.stanford.edu](https://plato.stanford.edu/entries/ethics-ai/)

人工智能要么是发生在人类身上最好的事情，要么是最坏的事情。~斯蒂芬·霍金

我想以问一个问题来结束这篇文章— 你会给你的二重身取什么名字？请在评论区告诉我。我希望你喜欢这篇文章，它让你了解人工智能如何变得越来越聪明，越来越了解周围的环境，以及数据爆炸如何导致个性化达到这样的水平，以至于你的办公室同事可能会把你的分身误认为你！关于这个问题的更多讨论，请发邮件给我，地址是【jishnudeep.kar@gmail.com】或者在 Instagram 上给我发 DM。

参考

[1]https://www.hansonrobotics.com/sophia/

[2]http://sitn . HMS . Harvard . edu/flash/2017/history-artificial-intelligence/

https://www.idc.com/getdoc.jsp?containerId=prUS45481219

[4]https://www.pnas.org/content/early/2020/01/23/1907373117

[5]https://static . Google user content . com/media/research . Google . com

[6]https://link.springer.com/chapter/10.1007/11893004_69

[7]https://www . mdpi . com/journal/sensors/special _ issues/vision _ sens

https://doi.org/10.3389/frobt.2018.00088

[9]https://www . Forbes . com/sites/tomtaulli/2020/05/08/how-5g-will-unleash-ai/

https://ieeexplore.ieee.org/document/6236985

[11]https://ea-foundation . org/files/ai-opportunities-and-risks . pdf

https://plato.stanford.edu/entries/ethics-ai/

如果你喜欢这篇文章，你可能也会喜欢这些。

[## 机器学习对于保持家庭照明变得越来越重要

机器学习超越了图像分类和语音识别。了解为我们的产品提供动力变得多么重要…

towardsdatascience.com](/machine-learning-is-becoming-increasingly-important-to-keep-your-homes-lit-7bd2e62ca2b) [## 从印度到美国的文化冲击——一个学生的视角

如果你计划去美国，并且对那里的文化太过好奇，这可能是你最好的剧透！

medium.com](https://medium.com/illumination/cultural-shock-visiting-the-usa-from-india-a-students-perspective-1f901df99984) [## 使用这些技巧让你的 Matlab 代码更快更真实

我在 Matlab 上工作和编码的 4 年多的旅程中学到的技巧。

towardsdatascience.com](/make-your-matlab-codes-faster-and-more-realistic-with-these-tips-281389b9d376)

人工智能为谷歌产品提供动力

原文：https://towardsdatascience.com/artificial-intelligence-powering-google-products-18e191da88d0?source=collection_archive---------25-----------------------

人工智能如何深度融入谷歌产品

丹尼尔·罗梅罗在 Unsplash 上的照片

“我们希望使用人工智能来增强人们的能力，使我们能够完成更多的工作，并让我们花更多的时间进行创造性的努力。”

—杰夫·迪恩，谷歌高级研究员

我们都很熟悉谷歌以及它的搜索引擎如何为每个人带来互联网革命。谷歌声称，如果公司没有投入大量时间、金钱和努力来发展技术，如人工智能、深度学习和 机器学习 ，他们的搜索引擎和其他产品系列就不可能取得进步。

作为一家涉及多个领域的软件和硬件的多元化公司，谷歌现在明白创造人工智能产品以帮助其用户进入智能技术的新时代是多么重要。

[## 日常生活中人工智能的 10 个最佳例子

在过去的几十年里，人工智能一直在发展，它积极地使人们和…

blog.digitalogy.co](https://blog.digitalogy.co/best-examples-of-artificial-intelligence-in-everyday-life/)

谷歌当初为什么对深度学习感兴趣？

谷歌人工智能专注于将人工智能的好处带给每个人。

过去几年清楚地表明了谷歌对为其用户构建更智能的技术有多么感兴趣。证据包括其大量使用的搜索引擎以及许多其他产品，这些产品严重依赖于诸如人工智能、机器学习和深度学习等技术。谷歌的主要目标一直是了解其用户实际上是如何使用其服务的，这里的想法可能包括何时、何地以及如何使用其服务。

谷歌进军开发、采用和/或收购更好的技术将被证明对理解其产品背后的使用模式至关重要。谷歌还依赖于其基础设施和一系列算法，这些算法不断分析和寻找改进其产品的方法，以便最新的改进使其用户能够用更少的点击和点击完成更多的事情。

在这里了解更多—

[## 面向所有人的顶级谷歌人工智能工具

使用谷歌人工智能中心将想法变为现实

towardsdatascience.com](/top-google-ai-tools-for-everyone-60346ab7e08)

人工智能为谷歌产品提供动力

现在我们知道了为什么谷歌一直致力于将人工智能融入其各种服务中，让我们看看我们常用的谷歌的一些流行应用程序、服务和硬件。

1.谷歌搜索引擎

  • 类型:网络搜索引擎
  • 投放: 1997 年
  • 提供: 149 种语言
  • 写于: Python，C，C++

谷歌的搜索引擎自发布以来发生了巨大的变化，人工智能在其中发挥了重要作用。算法是任何搜索引擎的关键部分。随着时间的推移，谷歌调整了其搜索引擎算法，以支持该行业的各种趋势，但真正使谷歌能够建立如此高效的算法，以至于它们可以自主学习的是深度学习的突破。

如果没有人工智能，谷歌就不可能改进其搜索模式识别算法，以过滤和避免垃圾邮件，以及对搜索图像进行分类和编目。

谷歌搜索的工作原理—

2.谷歌翻译

  • 类型:神经机器翻译
  • 上线:2006 年 4 月 28 日(作为统计机器翻译)
    2016 年 11 月 15 日(作为神经机器翻译)
  • 创建者:弗朗茨·约瑟夫·奥奇
  • 提供: 109 种语言，见下文
  • 网址:translate.google.com

谷歌翻译是一个简单的在线工具，允许用户将任何文本从一种语言翻译成另一种语言。与 2006 年推出统计机器翻译时相比，谷歌翻译在提供即时翻译方面取得了长足的进步。

但最近人工智能的进步，特别是神经机器翻译，真正提高了翻译的质量和可靠性，包括超过 109 种语言来提供相关翻译。此外，自然语言处理的改进也优化了几个谷歌服务的语音输入功能。

作者图片

3.谷歌助手

图片来源— 谷歌助手

  • 类型:虚拟助手
  • 发布日期:2016 年 5 月 18 日
  • 操作系统:安卓、Chrome OS、iOS、iPadOS、KaiOS、Linux
  • 写于: C++
  • 提供:多语种
  • 配音者:琪琪·贝塞尔
  • 网址:assistant.google.com

你不能只谈论谷歌的人工智能创新，而把谷歌助手排除在讨论之外。你可以把谷歌助手看作是你手机的智能扩展，它可以帮助你在不接触它的情况下最大限度地完成你的数字任务，比如打电话、发短信、记笔记、设置提醒等等。

但这还不是清单的结尾，谷歌助手还支持语音搜索的自然对话，它可以从你的使用模式中学习并建议行动，甚至可以通过一个简单的命令一次自动完成几项任务。

4.谷歌广告

图片来源— 谷歌广告

AdWords ，现在叫做 Google Ads 是T5Google 营销套件工具的一部分。谷歌广告是一个让企业和用户在网上为他们的产品做广告的工具，让用户完全控制他们广告的制作、管理和投放。随着谷歌继续分析和描述其用户的搜索行为，它可以利用这些数据有效地将正确的广告瞄准正确的个人，这是谷歌广告背后的核心理念。

谷歌使用几个 ML 算法 ，这些算法根据几个指标对数千个关键词进行排序，然后用来挑选合适的广告展示给用户。此外，人工智能还可以为用户提供有价值的纠正性见解。

在这里了解更多—

5.谷歌地图

照片由亨利·珀克斯在 Unsplash 上拍摄

  • ****类型:网络制图
  • 2005 年 2 月 8 日
  • ****创建者:拉斯·拉斯穆森延斯·艾尔斯特鲁普·拉斯姆森
  • ****提供:多语言版本
  • 用: C++(后端)，JavaScript，XML，Ajax 编写
  • ****网址:https://www.google.com/maps

****谷歌地图是来自谷歌的便捷导航系统，可以在安卓、iOS 和网络上使用。它被评为顶级导航和地图应用程序，在用户中非常受欢迎。卫星图像、360 度地图、室内地图和实时交通状况只是谷歌地图提供的部分功能。

谷歌已经在谷歌地图中实现了几个人工智能和人工智能驱动的功能，例如与谷歌助手的集成，该助手分析用户的通勤路线，并根据实时数据建议交通流量和延迟较少的路线。另一个这样的功能是推荐附近的兴趣点，如加油站、吃饭的地方、自动取款机等等。****

在这里了解更多—

6.谷歌邮箱

图片来源— Gmail

  • ****类型:网络邮件
  • 2004 年 4 月 1 日
  • ****创建者:保罗·布赫海特
  • 提供: 105 种语言
  • 编写于: Java，JavaScript，C++(后端)，JavaScript (UI)，Ajax
  • 网址:【mail.google.com】T22

我们确信大多数用户主要使用 Gmail 作为他们首选的电子邮件服务，但是你知道谷歌已经为 Gmail 实现了许多智能功能吗？其中一个功能被称为智能回复，它分析整个电子邮件并建议一个合适的简短回复，甚至无需键入确认。

Gmail 还有垃圾邮件保护功能，可以过滤任何潜在的垃圾邮件，防止它们进入你的收件箱。此外，Gmail 中的人工智能可以智能地将你的电子邮件分类，如促销、社交、更新、主要和优先。当你试图撰写电子邮件时，Gmail 还可以预测文本，从而加快工作速度。

智能回复—

作者图片

智能邮件分类—

作者图片

Gmail 中的 Google Meet 选项卡—

7. YouTube

照片由freestocks.org从派克斯拍摄

  • ****类型:视频分享平台
  • 2005 年 2 月 14 日
  • 创始人:贾韦德·卡里姆，查德·赫利陈士骏
  • 写成: Python，C，C++，Java，Go，JavaScript
  • 【https://www.youtube.com/】网址:

自 2005 年以来，著名的在线视频分享平台 YouTube 的功能和规模都呈指数级增长。大量品牌使用 YouTube 进行营销，而数百万其他人使用它来消费他们感兴趣的最新视频内容。

为了给品牌和消费者提供安全无缝的体验，YouTube 部署了几个依赖于人工智能和人工智能的机制。这些人工智能驱动的机制包括自动识别和删除不良内容，自动推荐内容，以及根据用户的兴趣和观看历史播放下一个相关视频。

了解更多这里的事情—

8.谷歌浏览器

图片来源— Chrome

  • ****类型:网络浏览器、手机浏览器
  • 2008 年 9 月 2 日
  • ****引擎:Blink(iOS 上的 WebKit)，V8 JavaScript 引擎
  • ****操作系统:微软 Windows，安卓，Windows 7，等等
  • 用: C、C++、Java(仅限安卓 app)、JavaScript、Python 编写
  • 提供: 47 种语言
  • ****网址:www.google.com/chrome/

谷歌 Chrome 可能是最常用的浏览器之一，自 2008 年冬天首次推出以来，它已经经历了许多变化。在众多变化中，最近有几个变化是利用人工智能的力量让每个人都可以访问互联网。****

其中包括最近为视觉障碍者引入的辅助功能，该功能分析网站上的图像并播放音频描述或替代文本(如果可用)。谷歌 Chrome 获得的另一个便利技巧是，在谷歌搜索中搜索某些内容时，可以呈现视频中简短且高度相关的部分。

了解更多这里的事情—

9.Google Drive

图片来源— Google Drive

Google Drive 是个人和职业任务的顶级在线文件存储和协作选项之一。多年来，谷歌对 Google Drive 进行了多项改进，不仅节省了时间，还提高了生产率。其中一个功能称为快速访问，它使用 ML 来分析几个最常用的文件，并预测您最常访问的文件，从而让您可以在 Drive 中即时访问它，无需手动导航到该文件。

在此了解更多信息—

10.谷歌照片****

图片来源— 谷歌照片

  • ****类型:照片存储和分享
  • ****投放:2015 年 5 月 28 日
  • ****操作系统:安卓、iOS、web
  • ****网址:photos.google.com

把 Google Photos 想象成一个在线相册，可以让用户无缝管理自己拍摄的照片。他们所有的照片都被备份到云端进行保管，但这并不是谷歌照片的唯一目的。

Google Photos 利用一些漂亮的人工智能和人工智能技术为您提供智能功能，例如基于里面的主题对照片进行自动分组的、自动分析和增强照片以获得最佳效果的智能过滤器、与谷歌镜头的集成以识别对象和文本，等等。****

在这里了解更多东西—

11.谷歌日历****

图片来源— 谷歌日历

  • ****类型:电子日历
  • ****发布日期:测试版—2006 年 4 月 13 日，常规版—2009 年 7 月
  • ****平台:网络应用，安卓，iOS
  • 编程语言: Java，JavaScript
  • 网址:www.google.com/calendar/about

日历在我们的日常生活中起着决定性的作用，是管理它的一个重要工具。谷歌的日历应用提供了广泛的日常管理选项，但为了使其更加强大，谷歌增加了一个目标功能，旨在帮助用户实现他们的个人目标，无论是学习新的爱好，完成任何未完成的项目，还是去散步。

根据谷歌的说法，这种人工智能功能可以智能地分析你在繁忙时段的日常安排，如果需要，可以在你方便的时候自动重新安排你的目标。

在此了解更多信息—

12.巢凸轮室外****

Nest Cam Outdoor 是一款户外安全摄像头，可以将实时视频传输到您的手机上，以提醒您房子周围的任何可疑活动。Nest Cam 可以像许多其他安全摄像头一样完美地检测运动，但它与其他摄像头的区别在于底层的人工智能算法，该算法使用计算机视觉来检测外部情况。

除了智能地提醒你有人来了，也不是因为你的宠物在镜头前缩放，室外的摄像头总是在记录。捕捉的视频可以使用 Nest 应用来观看，它通过应用智能人工智能算法，可以让你快速筛选活动时段，而不是快速回放一整天。

更多人工智能驱动谷歌产品—

下一步是什么

我们浏览了谷歌的大量服务，讨论了人工智能和相关技术不仅在改善服务和体验方面发挥了关键作用，还让谷歌带来了新功能。如果谷歌继续以同样的热情朝着人工智能、深度学习和机器学习的方向前进，我们很有可能在接下来的几年里见证几个领域的巨大飞跃。

如果你有更多的建议或想法，我们很乐意倾听。

更多有趣的阅读—

我希望这篇文章对你有用！以下是一些有趣的读物，希望你也喜欢

** [## 给 Python 开发者的 10 个很酷的 Python 项目想法

您可以使用 Python 构建的有趣想法和项目列表

towardsdatascience.com](/10-cool-python-project-ideas-for-python-developers-7953047e203) [## 2020 年你必须使用的最好的 Python IDEs 和代码编辑器

具有显著特性的顶级 Python IDEs 和代码编辑器

towardsdatascience.com](/best-python-ides-and-code-editors-you-must-use-in-2020-2303a53db24) [## 2020 年人工智能工程师的顶级编程语言

从几种编程语言中，人工智能工程师和科学家可以挑选出适合他们需要的语言

towardsdatascience.com](/top-programming-languages-for-ai-engineers-in-2020-33a9f16a80b0) [## 机器学习和深度学习的最佳 Python 库

现代机器学习模型和项目的 Python 库

towardsdatascience.com](/best-python-libraries-for-machine-learning-and-deep-learning-b0bd40c7e8c) [## 选择 PyTorch 进行深度学习的理由

PyTorch 可以为深度学习程序员提供很多东西

towardsdatascience.com](/reasons-to-choose-pytorch-for-deep-learning-c087e031eaca)

关于作者

克莱尔 D 。在Digitalogy—是一个内容制作者和营销人员，这是一个技术采购和定制匹配市场，根据全球各地的特定需求，将人们与预先筛选的&顶尖开发人员和设计师联系起来。在Linkedin，Twitter，insta gram**。****

人工智能 vs 机器学习 vs 数据科学

原文：https://towardsdatascience.com/artificial-intelligence-vs-machine-learning-vs-data-science-2d5b57cb025b?source=collection_archive---------16-----------------------

图像信用

人工智能、机器学习和数据科学是在几乎所有领域的专业人士中变得非常流行的几个术语之一。如果任何专业人士从未听说过这些术语中的任何一个，那将是一件令人惊讶的事情。

随着第四次工业革命的开始，一场正在模糊物理、数字和生物领域之间界限的技术革命，现在有必要更好地理解快速变化的技术术语。

完全理解这些术语容易吗？

我们假设您事先不了解这些术语。我们的目标是深入研究每一个概念，并强调使每一个概念与众不同的特征。

什么是人工智能(AI)？

“人造的”可以是任何由人类制造的非天然的东西。你对“智力”这个词的理解是什么？它是理解、思考和学习的能力。因此，人工智能是计算机科学的一个广阔领域，它使机器看起来像具有人类智能。

人工智能的目标是模仿人脑，创造能够智能和独立运行的系统。人工智能可以以许多不同的方式表现出来。

如果你曾经要求 Alexa 为你点餐或浏览网飞电影的建议，你正在与 AI 互动，而没有意识到这一点。

人工智能的设计让你意识不到有一台机器在发号施令。在不久的将来，人工智能有望变得不那么人工，而更加智能。

“智力”这个词的定义在这里很重要。让我们用另外两种方式来定义智力。“智能”是在给定一组输入和各种可能的行动的情况下做出正确决定的能力，或者它是一组思维属性——计划、解决问题和推理的能力。

智能行为表现出什么？

  • 解决问题——为复杂问题寻找解决方案的过程。
  • 推理——以逻辑方式思考问题的行为。
  • 规划——为某事制定计划的过程。
  • 决策——做出重要决策的过程。
  • 做出推论——根据证据做出结论或判断。
  • 学习——通过学习、体验或接受教育获得知识。

什么是机器学习(ML)？

我们将从最不正式和最简单的定义开始。机器学习是一种事物标签，你可以用例子而不是指令来解释你的任务。

机器学习背后的概念是，你把数据喂给机器，让它们在没有任何人工干预的情况下(在学习的过程中)自主学习。考虑一个小场景。比方说，你报名参加了一些游泳课程，但你以前没有游泳经验。

不用说，最初，你的表现不会很好，因为你不知道如何游泳，但随着你观察和收集更多的信息，你的表现会越来越好。

纪念活动只是另一种收集数据的方式。就像我们人类如何从我们的观察和经验中学习一样，当机器获得大量数据时，它们也能够自主学习。

这正是我们如何运用机器学习的概念。它是让机器从经验中学习和改进的过程，而不是显式地自动编程。

那么，如何让机器从经验中学习呢？

要理解这部分，我们需要理解什么是算法。一个简单的谷歌定义指出，算法是“在计算或其他解决问题的操作中，特别是由计算机遵循的一个过程或一组规则。”

换句话说，算法可以是定义明确的计算机可执行指令的有限序列，通常用于解决一类问题或执行计算。现在我们知道了什么是算法，让我们来探索是什么让机器学习。

机器学习算法本质上是一个过程或一组程序，帮助模型适应给定目标的数据。ML 算法通常指定数据从输入到输出的转换方式，以及模型如何学习从输入到输出的适当映射。

更简单地说，机器学习算法是程序(数学和逻辑)，当它们接触到更多数据时，会自我调整以表现更好。

机器学习的“学习”部分意味着这些程序随着时间的推移改变他们处理数据的方式，就像人类通过学习改变他们处理数据的方式一样。

它们以这样一种方式改变，即任何特定输入值被映射到其正确输出值的概率在每次通过改变算法内的一组变量(或结构)而暴露给新数据时增加，该算法用于对输入值执行计算并得出最终输出值。

从术语“机器学习”中使用的“学习”一词可以明显看出，它与人工智能有关，人工智能包括人脑的学习能力。

机器学习是关于机器一起体验相关数据并获取模式，就像人类可以在任何数据集中找出模式一样。

机器学习是人工智能的一个子集

机器学习算法有不同的类型。一些算法被输入标记的数据，如果后来暴露于任何未标记的数据，这些算法会自我调整以吐出正确的标签(监督学习)。

一些算法给出了未标记的数据，以找出数据集中隐藏的模式(无监督学习)。

如果机器学习是人工智能的子集，那么什么人工智能不是机器学习？

机器还可以通过许多其他方式来展示它们的智能。机器学习算法依靠数据来智能地执行。

有没有不依赖数据但仍能显示智能的人工智能算法？

好吧，我们来探索一种人工智能的搜索算法。

人工智能中的“搜索”是什么意思？

人工智能中的搜索是通过中间状态的转换从起始状态导航到目标状态的过程。搜索算法对数据科学家来说非常有用。

形象功劳

红色的值是每个节点的试探法，黑色的值是在两个节点之间移动的成本。任何节点的启发式值表示从该特定节点到达目标节点所需的成本。从 a 到 e 的成本是 3 + 10 = 13。

A*算法利用成本和启发式值，通过计算最便宜的解决方案的估计成本，即 f(n) = g(n) + h(n)，找到从初始状态到目标状态的最短路径。g(n)是从初始节点移动到节点 n 的代价，h(n)是从节点 n 到达目标状态的估计代价(启发式值)。

这个算法是否智能执行？

该算法在每一步进行计算，保留以前计算的知识，并在每一步做出决定。这确实是一种人工智能。

但这是否需要数据集像任何机器学习算法一样智能地学习和执行呢？不。这是人工智能吗？是啊！这是机器学习的例子吗？不要！

人工智能是一个比机器学习更广泛的概念

人工智能是一种技术，其目标是创造能够模拟人类智能的智能系统。相比之下，机器学习是让系统获得特定形式的人类智能的方法之一。为了更好地区分这两者，我们将使用一个表格。

人工智能机器学习领域。人工智能的子集。目标是模拟人类智能来解决复杂问题。

目标是从数据中学习，并能够在出现新数据时预测结果，或者只是找出未标记数据中隐藏的模式。导致智力或智慧。通向知识。

寻找最佳解决方案的尝试。试图找到唯一的解决方案，无论它是否是最优的。

现在已经很清楚如何区分机器学习和人工智能的其他应用了。

尽管存在差异，但这些术语经常互换使用。因此，了解关键差异非常重要。人工智能经常使用 ML 及其其他子集，例如，自然语言处理(NLP)来解决文本分类等问题。

数据科学

“在未来 10 年，数据科学和软件对医学的贡献将超过所有生物科学的总和。”—维诺德·科斯拉

你知道什么是推荐引擎吗？你可能用过亚马逊网上购物。你有没有注意到，当你在亚马逊上搜索一个特定的商品时，你会得到类似的商品推荐？

亚马逊在这一切背后是如何运作的？它是如何向你展示你感兴趣的项目的？亚马逊、沃尔玛和网飞等公司表现出色的原因是他们如何利用用户生成的数据。

这些是数据驱动的公司。这些公司的关键一直是数据。

推荐系统根据用户的浏览历史、评级、个人资料详细信息、交易详细信息、购物车详细信息等过滤出每个用户的选择列表。这种系统用于获得对顾客购物模式的有用洞察。

它为每个用户提供了基于他们个人资料的电子商务网站的特定(独特)视图。

例如，如果你在亚马逊上搜索一台笔记本电脑，你可能也需要买一个电脑包。亚马逊将类似的交易映射在一起，然后向用户推荐相关的商品。

在我们深入探讨这个主题之前，有必要了解一些通常与数据科学相关的术语的含义。

什么是数据科学？

数据科学是一个多学科领域，专注于从大量原始(非结构化)和结构化数据中发现可行的见解。

数据科学家使用不同的技术来获得答案，结合计算机科学、预测分析、统计学和机器学习来解析海量数据集，以建立尚未想到的问题的解决方案。

数据科学专家的主要目标是提出问题并找到潜在的研究途径，而不太关心具体的答案，更重视搜索要问的正确问题。

你听说过大数据吗？

大数据是指难以实时存储和处理的海量数据。这些数据可用于分析洞察力，从而做出更好的决策。

什么是数据分析？

数据分析是对数据进行检查、清理、转换和建模的过程，其目标是发现有用的信息、提供结论和支持决策。它和数据科学不一样。

数据科学项目的工作步骤是什么？

  • 理解业务问题——询问相关问题，理解并定义问题的目标。
  • 数据采集—从多个来源收集数据。
  • 数据准备—数据清理和转换。
  • 探索性数据分析——定义和细化将在模型开发中使用的特征变量的选择。
  • 数据建模——这是数据科学项目的核心活动。这包括对数据重复应用不同的机器学习技术，如 KNN、决策树、朴素贝叶斯，以确定最适合业务需求的模型。
  • 可视化和交流——会见客户和交流商业发现。这一步创建了强大的报告和仪表板。
  • 部署和维护—在生产环境中部署之前，在生产前环境中测试模型。

在探索数据科学时，我们已经弄清楚了机器学习在其多样化环境中的确切应用位置(在数据建模步骤中)。让我们问自己一些重要的问题。

数据科学与机器学习有什么样的关系？机器学习是数据科学和人工智能的交叉吗？下图可视化了数据科学、人工智能和机器学习之间的关系。

形象功劳

显然，你可以看到 ML 和 AI 都不是数据科学的子集，而数据科学也不是这两者的子集。数据科学不仅仅是人工智能和人工智能。

人工智能和人工智能不仅仅是数据科学。数据科学中使用了 ML 技术来执行特定的任务和解决特定的问题。

数据科学领域采用了人工智能概念，而不是人工智能技术。

文本挖掘(人工智能和数据科学的交叉，但不是 ML)是一种人工智能技术，它使用自然语言处理将文档和数据库中的原始(非结构化)文本转换为适合分析或驱动机器学习算法的标准化结构化数据。

了解差异的重要性

数据科学领域提供了大量有前途的职业。为了给自己选择正确的专业，了解这些经常被错误地互换使用的不同术语之间的区别是至关重要的。

我们希望现在你对什么是数据科学，什么是机器学习，什么是人工智能的概念有了更好的了解。然而，关于人工智能和数据科学，你还有很多可以探索的。

人工神经网络

原文：https://towardsdatascience.com/artificial-neural-networks-ann-21637869b306?source=collection_archive---------64-----------------------

神经网络是执行由人脑中的神经元执行的任务的系统。神经网络包括作为人工智能(AI)一部分的机器学习，是我们开发神经元和大脑功能以复制人类学习方式的系统。

这是系统发展的第一步，该系统复制我们大脑中神经元的功能，帮助我们像人类一样学习。

神经网络(NN)形成一个隐藏层，其中包含将输入从输出更改为输出的单元，以便输出层可以使用该值。这种转化称为神经层，称为神经单元。下一级的输入由一系列称为功能的功能使用，这些功能又在一系列变换中用作下一级的输入，每一级的每一个都有不同的值。

通过重复这些转换，神经网络学习边缘形状等非线性特征，然后与最终层结合，对更复杂的对象进行预测。本文的主题将是神经网络的扩展版本，即深度学习。网络权重参数会发生变化，以最小化输入值与特定属性或边形状的期望值之间的差异。

人类大脑是已知的最强大的计算机器之一，其内部工作通常以已知的生物神经网络为模型。根据美国国立卫生研究院(NIH)的数据，它包含大约 1000 亿个通过路径和网络连接的神经元。

人工神经网络是受生物启发的计算机模型，以人脑中的神经元网络为模型。它们也可以被视为模拟输入输出关系的学习算法。人工神经网络的应用包括模式识别和预测。

人工神经网络(ann)被描述为机器学习算法，旨在通过从数据中提取有用的模式来获取自己的知识。他们将非线性函数应用于输入的加权和，并对它们之间的关系进行建模。

人工神经网络由许多互连的计算单元组成，称为神经元，是将输入映射到输出的函数逼近。人工神经网络是将输入映射到输出的函数或近似器，反之亦然。

单个神经元几乎没有内在收敛，但当许多神经元一起工作时，它们的组合效应可以表现出显著的学习性能。由神经元及其突触形成的神经网络是人类认知的关键组成部分，负责许多认知功能，如记忆、思维和决策。然而，今天，生物神经元被认为是人脑中最强大的计算单元之一，能够学习和记忆。

鉴于此，一个自然的假设是，为了复制大脑的功能和能力，包括智能的能力，并因此能够进行认知功能，如学习和决策，必须实现神经网络的计算机化版本。关系网络和图灵神经机器提供了证据，证明连接主义和计算主义的认知模型不需要相互矛盾，可以共存。

人工神经网络(ann)是直接受生物神经网络启发或部分模仿生物神经网络的统计模型。存在被称为人工神经网络的高级统计技术和概念，并且它们最重要的特征之一是并行模拟输入和输出之间的非线性关系的能力。

已经出现了几种类型的神经网络，但最基本的类型，神经网络，是所谓的“迁移信息网络”最常见的网络类型是神经网络，其中数据从网络的一部分线性地流向另一部分。

人工神经网络(ANN)与之类似，但它是科学中的一种计算网络，类似于人脑的属性。ANN 可以模拟人脑的原始神经元，所以它的处理部分被称为“人工神经元”。

术语“神经元”和“人工神经元”是等价的单位，并且暗示与生物神经元的密切联系。人工神经网络由相互连接的神经元组成，这些神经元受大脑工作方式的启发，但具有不同的特征和特性。

在微观层面，术语“神经元”用于解释深度学习是对人脑的模仿。然而，“深度学习”与人脑的神经生物学关系不大，而是与神经网络有关。

神经网络是一种机器学习方法，其中计算机通过分析训练样本来学习执行任务。在宏观层面上，神经网络可以被认为是人类智能使用的机器。

神经网络是对人脑的松散模拟，由紧密连接的简单处理节点组成。今天，大多数神经网络都是由节点层组成的，每个节点都在网络内外有意义地移动。例如，可以向物体识别系统提供一系列与特定标签一致相关的图像中的视觉图案。她会发现图像中的视觉图案与标签相匹配。

引用来源

CNN 新手手势识别

原文：https://towardsdatascience.com/artificial-neural-networks-for-gesture-recognition-for-beginners-7066b7d771b5?source=collection_archive---------16-----------------------

使用 Python 和 SqueezeNet 的有趣实验

奥斯曼·拉纳在 Unsplash 上拍摄的照片

CNN 或卷积神经网络是图像分类问题中最常用的算法。图像分类器将照片或视频作为输入，并将其分类到它被训练识别的可能类别之一。它们在各个领域都有应用，如无人驾驶汽车、国防、医疗保健等。图像分类有许多算法，在这个实验中，我们将研究这种类型中最受欢迎的算法之一，DeepScale 称之为 SqueezeNet 。

目标是:

我们的目标是设计一个应用程序，它将使用网络摄像头(或外部摄像头)作为输入设备，然后它将识别手势并将其分类到我们将要定义的类别中。在本文中，我们将看到如何使用 SqueezeNet 算法来设计一个应用程序，它采用不同的手势，然后触发某些动作。简而言之，我们可以向我们的计算机发送一些命令(无需触摸键盘或鼠标)。让我们戴上魔术师的帽子吧！🧙‍♂️

照片由阿列克谢·耶什金在 Unsplash 上拍摄

实验包括下列四个阶段:

概述:

  1. 定义我们的分类类别
  2. 收集训练图像
  3. 训练模型
  4. 测试我们的模型

1.定义我们的分类类别(手势)

巴迪 qb 在 Unsplash 上拍照

在我们最后的节目中，我们将表演一些动作。这是我决定要做的一些事情的清单。根据您的具体要求，此列表中的项目数量会有所不同。接下来，为了方便起见，我们将使用类别名称来映射这些操作，以便稍后在我们的程序中使用。

  1. 增加扬声器音量(类别= 向上 )
  2. 降低扬声器音量(类别= 调低 )
  3. 静音/取消静音(类别= 静音 )
  4. 播放/暂停(类别= 播放 )
  5. 打开谷歌浏览器(category =Chrome)

除了这五个类别，我们还应该有另一个类别(category =nothing)，当用户做出我们的模型无法识别的手势时，或者当用户没有输入手势时，我们将在最终的程序中使用这个类别。

现在我们已经决定了我们的六个类别，让我们看看我的手势看起来怎么样。

我在下面创建了一个所有手势和它们各自类别名称(红色)的拼贴画。

所有手势及其类别名称的拼贴画(使用网络摄像头拍摄)

2.收集用于训练的图像

下一组是为每个类别准备我们的训练图像。为了收集我们的训练数据集(图像)，我们将使用网络摄像头。为了让事情变得简单，我确保使用背景简单整洁的图片。下面的 python 程序将使用 OpenCV 库来执行这个动作，并将这些图像存储到一个名为“ training_images”的文件夹中。 程序需要两个输入参数:

python get_training_images.py 50 up

a) 要拍摄的图像数量(例如:- 50)

b) 标签(或类别)名称(例如:-向上、向下、播放、铬等)

程序 在捕捉到那么多图像后停止。第二个参数指示这些图像所属类别的名称。该程序在我们的' training_images '文件夹中根据类别名称创建一个子文件夹，并将所有图像存储在那里。

“training_images”文件夹中所有子文件夹的屏幕截图

一旦你运行该程序，网络摄像头的饲料将打开。将手放在白色框的边界内，按下“ s ”键到 开始 给手拍照。在此过程中，尝试移动您的手，在训练数据集中添加一些变化。我从这里开始，对每个类别运行程序两次，右手 50 张图片，左手 50 张图片。一旦程序结束，你应该能够看到你的手势名称的子文件夹中的图像。一旦这个过程完成，你将在每个文件夹中得到 100 张图片。你可能想选择一个适合你的号码，越多越好。

3。训练模型

在这个演示中，我们将使用 SqueezeNet。SqueezeNet是一个流行的用于图像分类问题的预训练模型，它非常轻量级，具有令人印象深刻的精确度。我们将在训练过程中使用 Keras 库。 Keras 是一个简单而强大的 python 库，广泛应用于深度学习。这使得训练神经网络模型变得非常容易。

让我们看一下用于我们培训的一些参数。

顺序:我们将使用顺序模型，这意味着各层以线性堆栈(顺序)排列。模型中的层作为参数添加到此构造函数中。

霍尔格连杆在 Unsplash 上拍照

退出率:在较小数据集上训练的神经网络往往会过度拟合，因此在新数据上不太可能准确。从理论上讲，训练模型的最佳方法可能是尝试不同参数值的不同组合，然后取这些单独结果的平均值，以得出一个概括的结果。但是这将需要大量的时间和计算资源来用这些参数的多种组合多次训练模型。为了解决这个问题，引入了辍学率。这里，层中的一些单元/节点(来自输入层或隐藏层，但不来自输出层)被'丢弃'，这使得该节点的输入和输出连接消失。简而言之，当在训练期间多次这样做时，不同数量的节点从层中被丢弃，使得该层在节点数量及其与前一层的连接方面看起来不同(粗略地模拟具有不同层配置的多个模型)。一个图层的辍学率的较好值在 0.5–0.8 之间。就我而言，在尝试了几个不同的值之后，我发现 0.5 给了我最好的结果。请注意，脱扣是用来避免过度拟合。如果模型的精确度低，则可以避免该参数。

节点:我们输出层中神经元/节点的数量等于我们试图预测的类的数量。

输入形状:SqueezeNet 要求的输入形状至少是 224 X 224(RGB 有 3 个通道)。在这个程序中，我们使用了 225 X 225。

选择优化器&损失:这里我选择了 亚当 优化器。并且基于问题的类型选择损失函数。例如:-对于二元分类问题，[loss = ' binary _ cross entropy ']更适合，对于多类分类问题，选择[loss = ' categorial _ cross entropy ']。而对于回归问题，可以选择 [loss='mse'] 。由于我们的问题是一个多类分类问题，我们将使用 分类 _ 交叉熵。

历元数:历元数是整个数据集在训练过程中通过神经网络的次数。对此没有一个理想的数字，它取决于数据。在这种情况下，我从 10 开始，我用了 15。数字越大表示训练时间越长。

激活函数:我们使用的是 ReLU 激活函数，这是神经网络中最常用的激活函数，因为它计算简单(还有其他优点)。该函数为负输入返回零，为正输入返回值本身。对于大多数现代神经网络，ReLU 是默认的激活函数。还使用的其他激活函数是 Sigmoid、Tanh 等。

池化:在 CNN 中，通常的做法是在卷积&激活层之后添加一个池化层。输入图像被下采样或转换成低分辨率版本，以便仅保留重要的细节并去除较精细的不太重要的细节。

soft max:soft max 层用在输出层之前的多类分类中。它给出了输入图像属于特定类别的可能性。

import numpy as np
from keras_squeezenet import SqueezeNet
from keras.optimizers import Adam
from keras.utils import np_utils
from keras.layers import Activation, Dropout, Convolution2D, GlobalAveragePooling2D
from keras.models import Sequential
import tensorflow as tfGESTURE_CATEGORIES=6
base_model = Sequential()
base_model.add(SqueezeNet(input_shape=(225, 225, 3), include_top=False))
base_model.add(Dropout(0.5))
base_model.add(Convolution2D(GESTURE_CATEGORIES, (1, 1), padding='valid'))
base_model.add(Activation('relu'))
base_model.add(GlobalAveragePooling2D())
base_model.add(Activation('softmax'))base_model.compile(
    optimizer=Adam(lr=0.0001),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

训练后，我们将把训练好的模型参数存储到一个文件(手势-模型 05_20.h5)中，我们将在稍后的模型测试中使用该文件。全部代码都在 github 库中。

model.save("gesture-model05_20.h5")

4。测试型号

为了测试这个模型，我使用了我的网络摄像头再次捕捉到的一些手势图像。该程序加载模型文件“手势-模型 05_20.h5 ”,并将输入图像作为参数，并预测其所属的类别。在传递图像之前，我们需要确保我们使用的尺寸与我们在训练阶段使用的尺寸相同。

from keras.models import load_model
import cv2
import numpy as npimg = cv2.imread(<input image file path>)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, (225, 225))model = load_model("gesture-base-rmsprop-model05_20.h5")
prediction = model.predict(np.array([img]))

对于以下测试图像，模型预测正确。然而，如果图像在背景中包含太多其他项目，它并不总是准确的。

测试图像(使用网络摄像头拍摄)

最后，尽管这种模式可能无法每次都完美运行，并且我们可以做很多事情来改善其性能，但它为我们提供了一个起点，并从这里开始建立这些基础。感谢您抽出时间阅读这篇文章，我希望它能帮助您创建您的第一个 CNN 项目。我期待着看到这个项目你的版本。请与我分享您的想法:)

在我的下一篇 文章 中，我们将看看如何使用 Python 基于已识别的类采取行动。

本文使用 Python OpenCV。如果您不熟悉 Python 中的 OpenCV 库，这里有一个链接，链接到我关于这个主题的介绍性文章。

[## 面向初学者的 10 行人脸检测

使用 Python OpenCV 在图像和视频中检测人脸的介绍。

towardsdatascience.com](/face-detection-in-10-lines-for-beginners-1787aa1d9127) [## 在 5 分钟内制作一个声控鼠标

Python 中语音识别和 GUI 自动化的初学者指南

medium.com](https://medium.com/@b.arindom/build-a-voice-controlled-mouse-keyboard-in-5-minutes-952bc8f101fc)

参考文献&延伸阅读:

[1] SqueezeNet，https://codelabs . developers . Google . com/codelabs/keras-flowers-SqueezeNet/

[2] Pooling，2019，https://machine learning mastery . com/Pooling-layers-for-convolutionary-neural-networks/

[3] SqueezeNet Paper，2016，https://arxiv.org/abs/1602.07360

[4]备选 OpenCV 方法，https://www.youtube.com/watch?v=-_9WFzgI7ak

[5]辍学:防止神经网络过度拟合的简单方法，2014，http://jmlr.org/papers/v15/srivastava14a.html

人为的特殊白痴

原文：https://towardsdatascience.com/artificial-special-idiocy-cae849c014e1?source=collection_archive---------25-----------------------

人工通用智能不太为人所知的堂兄

机器学习研究领域的大部分动力来自对一个终极目标的追求:对人工通用智能的探索(AGI)。这一长期目标激发了人们的热情，因为它总是让人们觉得遥不可及，但矛盾的是，出于深层的根本原因，人们无法理解。有人可能会创造一种全新的感知形式，这种可能性让一些人将对 AGI 的探索提升到了一种准宗教的目的——最近有人毫不讽刺地告诉我，“我愿意放弃我的生命来解决 AGI。”将这种狂热与对 AGI 根深蒂固的恐惧形成对比是很有趣的，如果流行文化是世界内在神经症的准确反映，那么普通大众似乎也同样广泛地分享这种恐惧。

可能会让一些人感到惊讶，我发现自己对参与寻找 AGI 相对不感兴趣。明确地说，我不能“不关心”AGI，部分原因是因为似乎有很多人真的认为制造终结者是我字面上的工作描述(剧透:它不是)。作为一名从事人工智能和机器人研究的人，我非常认真地承担责任，确保我的工作和行动解决该研究领域产生的问题，而不管它们在其他人身上引发的恐惧或热情。

假装和制造它

但我对寻求 AGI 有矛盾心理的主要原因是，我认为我们正处在一个实现“功能性 AGI”的轨道上，比实现“真正的 AGI”要快得多，而且前者很可能在未来几十年填补后者的生态位。就像飞机的发明严重阻碍了对建造人工鸟翼的追求，或者鉴于轮子的存在，对人工腿运动的追求从来不是人类最迫切的关注，今天的机器学习进步正在带来各种能力，这些能力可能在所有意图和目的方面看起来、感觉起来和行为起来都像真正的人工智能，但与真正的 AGI 的道路有很大差异，同时在功能上填充其技术角色。

举例来说，我最近与“人工智能”进行了对话，这些对话比我与许多人(当然不是你……我发誓，与你交谈要有趣得多……)的对话更有吸引力、更高级、更有用，然而这些神经网络(因为它们就是这样)只是稍微复杂，但却是固定的数学函数 y=f(x)，没有状态，没有永久记忆，也没有适应性。这些人工智能在时间中被冻结了。它们是输入-输出映射，没有进化或形成长期信念的机制。但它们展示了许多功能属性，这些属性将使系统能够偷偷通过图灵测试:它们表现得好像它们理解文化参考，它们开玩笑，它们可以在对话中携带上下文，并对基础事实做出推断。如果你的目标是拥有帮助人们完成任务的自动化交互代理，它们也是非常有用的。

具有讽刺意味的是，如果一场智能对话即将成为一个警告信号，表明你可能正在与一个机器人交谈，那么我们有一系列全新的问题需要关注。

简而言之，通往 AGI 的“假装成功直到成功”的道路实际上让我们走得比我想象的更远，这让我想知道，如果没有任何支撑 AGI 背后许多恐惧的不断发展、自我优化的机制，AGI 的大部分价值能否实现。要清楚的是，没有什么根本的东西阻止我们创造有状态并与长期记忆互动的人工智能，但仍然有一点值得赞赏的事实是，今天，人工智能管理的所有最大成就都不需要那种机器，但仍然在推动“感觉”智能和普遍有用的边界。时间会告诉我们这种模式能走多远，这种模式的好处是在实际环境中推理、训练和部署更简单。

在 AGI

假设我大错特错:这些“假”功能人工智能无法填补智能代理的生态位，而强大的人工智能确实就在我们的门口。一个主要的存在主义担忧是害怕释放非人类的、非常聪明的、非常强大的实体到世界上。这些可能是具有无限生命周期的代理人，他们的目标并不总是与我们的一致，他们有能力调动大量资源，并有能力迫使人类为他们的目的服务。

够吓人吗？如果这就是 AGI 的真正定义，那么这些实体今天已经在地球上漫游了:它们被称为公司和政府。公司和政府是由人组成的这一事实，并没有让它们变得不那么做作、不那么强大，或者更符合人类的偏好。(声明一下，这种将公司比作 AGI 的类比并不是我发明的，尽管我还没能找到我第一次遇到它的地方。欢迎指点。)

公司和政府都是这样的构造，它们一次又一次地证明了它们的目标是如何与任何个人的合理愿望大相径庭的:这些系统的动力本质上是非人类的，并且服从于诸如利润最大化或社会控制之类的目标，而这些目标往往与个人的利益关系不大。他们用近似人类语言的方式“说话”,但不完全是人类语言:他们用广告、新闻稿或宣传来和我们说话。和他们顶嘴可能是一种奇怪的体验，任何一个和客服打过交道或者在车管所排队的人都可以证明这一点。它们的流程是由人设计和进化的，没错，但 AI 也是。

公司和政府在任何情况下都是 agi。它们可能又大又可怕，以一种非常直接的方式统治着你的日常生活。但是我们已经接受了人类可以与之共存，事实上我们已经和它们发展了或多或少的共生关系。那么，为什么当一个假想的 AGI 是由硅制成的，而不是由人和过程制成的时候，感觉(包括我自己)要可怕得多呢？我们有理由相信，如果强大的 AGI 成为现实，它与人类的关系将会与它与企业实体的关系发生显著的不同吗？丹尼尔·吉尔伯特(Daniel Gilbert)在他的书《跌跌撞撞的幸福》中(用数据)指出，预测一个人未来的最佳方式不是想象未来的自己，而是环顾当下相关的代理人。我想知道，当谈到对强大的 AGI 可能到来的推理时，看一看工业革命期间现代公司的崛起是否是比常见的科幻小说比喻和叙述更好的代理:无论从哪方面来看，这都不是人类状况的直接和无痛的发展，但人类通过新的社会结构、新的法律和新的监督机制来适应它，迄今为止，这些已经以总体有益的方式带我们度过了这场混乱。

平心而论，我确实可以想象出类比可能会失效的几种方式。首先，如果这样的突破是在几年内而不是几十年内发生的话，所涉及的时间尺度。一代人内发生的颠覆与跨代变化看起来非常不同。其次，将任何新的参与者引入现有的生态系统，无论是生物的、社会的还是技术的，都存在真正的风险。第三，现代国家和企业未能解决的一个问题是如何将外部性管理(特别是地球资源和环境)纳入其“智能”中。有人可能会理直气壮地说，AGI 最大的外部因素……是我们。一个发人深省的想法是，如果我们今天不解决管理生态系统外部性的问题，我们可能永远没有机会真正面对这个问题。

在 ASI 上

致谢:苏珊·尼尔森 ( 来源)

我个人认为，围绕机器学习作为人类增强工具的问题比寻求更高形式的智能更具吸引力、可操作性和说服力。事实上，我的最终目标与其说是追逐 AGI，不如说是解决它的老白痴表亲的崛起:人工特殊白痴(ASI)，即无意或有意滥用当今不那么普遍的人工智能。与我们今天所接触到的 AGI 的替代品有关的问题，以及这些问题如何对我们生活的世界产生积极或消极的实质性影响，是深刻而迷人的。

因为 ASI 比较专业，所以他们对世界的理解往往会有盲点。事实上，他们对世界的理解可以更好地描述为他们无知的汪洋大海中的一个小岛。你不能仅仅通过向它展示狗和猫的图片来建立一个狗和猫的图像识别系统，否则它会根据狗或猫来推理它看到的一切，并且不会知道它不知道的东西，即世界上的大多数东西也不是。是的，我知道。贝叶斯主义者会告诉你，你可以使用适当的概率推理。试试看。当它不起作用时，他们可能会告诉你，你使用了错误的先验。恭喜你，你赢得了贝叶斯宾果游戏，只是用一个棘手的问题换了另一个。如果你一直在关注最近围绕基于能源的模型的一系列兴趣，你就会知道这个领域可能正在发生变化，回避概率可能就是入场券。

我记得我从事语音识别的日子，到目前为止，要提高语音到文本模型的准确性，最重要的事情是改善所有不是语音的东西的建模，从关门声到背景音乐到婴儿啼哭，这包含了比语音本身更大的听觉景观。理解你不知道的东西是当今人工智能领域最有趣的追求之一:我们与建模“已知的未知”斗争，更不用说“未知的未知”在这个领域有很多有趣的工作要做——是的，答案可能仍然是贝叶斯，但话说回来，什么不是呢？

然而，对我来说更有趣的是解决与 ASIs 相差一步的问题:帮助从业者理解首先存在问题，并且已经建立了解决方案和最佳实践的人的问题。无论是关于公平性、信任和可解释性、测试和验证，一旦人们消除了可能导致 ASI 的人类盲点，就有许多实用的方法来处理这些问题。

我今天工作的 AI 和机器人世界对 ASIs 绝对是无情的。与物理系统合作提高了风险:物理安全始终是机器人学的前沿和中心，在其关键路径中引入学习意味着从内部建立安全。它还提出了解决问题的新方法，通过帮助人工智能在物理世界中扎根，并使其体现为人类社会的参与者。我们正在进行的与日常机器人项目的合作体现了许多这些特征:人类世界中的机器人需要深刻的情境意识，无论是在物理还是社会互动方面。脆弱的人工智能的答案很可能是让它面对复杂混乱的物理世界。

问正确的问题:在新任务中训练 T5 变压器模型

原文：https://towardsdatascience.com/asking-the-right-questions-training-a-t5-transformer-model-on-a-new-task-691ebba2d72c?source=collection_archive---------8-----------------------

T5 转换器将任何 NLP 任务构建为文本到文本的任务，使预先训练的模型能够轻松学习新任务。让我们教老狗一个新把戏！

图片由 Pixabay 的 Katrin B. 提供

自从 2019 年 10 月 way 推出 T5(文本到文本转换变压器)以来，我就一直渴望尝试它(这是一个漫长的几个月)。我尝试了几次谷歌的开源代码和，但是我从来没有让它正常工作过。其中的一些超出了我的理解范围(张量流)😫)所以我想我要等拥抱脸来救援了！和往常一样，变压器的实现更容易使用，我对它进行了修改，以便与简单变压器一起使用。

在我们开始精彩内容之前，先简单介绍一下 T5 车型是什么，以及它为何如此令人兴奋。根据谷歌人工智能博客 T5 上的文章所述，该模型是一项关于迁移学习技术的大规模研究(论文链接)的结果，旨在了解哪种方法最有效。T5 模型在 C4 ( 巨大干净的爬行语料库)上进行预训练，这是一个新的绝对大规模的数据集，与模型一起发布。

预训练是迁移学习的第一步，在这一步中，模型在大量未标记的文本数据上进行自我监督的任务训练。在此之后，该模型在为特定任务定制的较小的标记数据集上进行微调(训练)，与在没有预训练的情况下简单地在较小的标记数据集上进行训练相比，产生了优越得多的性能。关于预训练语言模型的更多信息可以在我下面的帖子中找到。

[## 理解 ELECTRA 并训练一个 ELECTRA 语言模型

变形金刚模型如何学习语言？伊莱克特拉有什么新消息？你如何在一个平台上训练你自己的语言模型

towardsdatascience.com](/understanding-electra-and-training-an-electra-language-model-3d33e3a9660d)

T5 模型的一个关键区别是所有的 NLP 任务都是以文本到文本的格式呈现的。另一方面，BERT-like 模型将文本序列作为输入，并从输入中输出单个类标签或一段文本。通过在 transformer 模型之上添加相关的输出层，针对特定任务对 BERT 模型进行了改进。例如，为分类任务添加一个简单的线性分类图层。然而，T5 避开了这种方法，而是重新构建任何 NLP 任务，使得输入和输出都是文本序列。这意味着相同的 T5 模型可用于任何 NLP 任务，无需对架构进行任何售后更改。要执行的任务可以通过一个简单的前缀(也是一个文本序列)来指定，该前缀被添加到输入中，如下所示。

来自https://ai . Google blog . com/2020/02/exploring-transfer-learning-with-t5 . html

T5 的论文探讨了 NLP 迁移学习的许多最新进展。很值得一读！

然而，本文的重点是调整 T5 模型来执行新的 NLP 任务。由于统一的文本到文本的方法，这变得(令人惊讶地)容易。所以，让我们来看看前面提到的好东西！

任务

T5 模型在各种各样的 NLP 任务上被训练，包括文本分类、问题回答、机器翻译和抽象概括。我们将教授 T5 模型的任务是问题生成。

具体来说，当给定一个上下文时，模型的任务是询问相关问题。

您可以在简单变形金刚回购的 示例 目录中找到本指南使用的所有脚本。

数据集

我们将使用亚马逊评论数据(2018) 数据集，其中包含亚马逊上各种产品的描述以及与这些产品相关的问答对。

描述和问答配对必须单独下载。您可以按照下面的描述和问答对中的说明手动下载数据，也可以使用提供的 shell 脚本。本研究中使用的类别列表如下。

描述

  1. 转到评论网址。
  2. 从页面上的链接下载元数据文件(json.gz)。请注意，从每个类别的数据链接 (例如http://deepyeti . ucsd . edu/简墨/亚马逊/metaFiles/meta _ AMAZON _ fashion . JSON . gz)下载可能比下载所有产品的完整元数据更好。完整的元数据是一个 24 GB 的档案，您将需要一个lotRAM 来处理它。
  3. 将*meta_ALL_Beauty.json.gz* 重命名为 *meta_Beauty.json.gz* 以匹配问答文件中的名称。

问答配对

  1. 转到问答网址。
  2. 下载每个类别的文件。请注意，我使用的是没有多个答案的问答配对。

命令过程

或者，下面的 shell 脚本应该通过读取下面给出的两个文本文件的链接来下载所有必要的文件(将文本文件放在与 shell 脚本相同的目录data/)。它还会将*meta_ALL_Beauty.json.gz* 重命名为 *meta_Beauty.json.gz* 以匹配问答文件中的名称。

链接到元 JSON 文件

qa JSON 文件的链接

下载 JSON 文件的 Shell 脚本

有了数据文件，我们就可以开始训练我们的模型了！

设置

我们将使用简单变形金刚库(基于拥抱脸变形金刚)来训练 T5 模型。

下面给出的说明将安装所有的要求。

  1. 从这里安装 Anaconda 或者 Miniconda 包管理器。

  2. 创建新的虚拟环境并安装软件包。
    conda create -n simpletransformers python pandas tqdm
    conda activate simpletransformers

  3. 如果您使用 fp16 培训，请安装 Apex。请遵循此处的说明。(从 pip 安装 Apex 给一些人带来了问题。)

  4. 安装简单变压器。
    pip install simpletransformers

参见安装 文档

数据准备

我们可以使用下面给出的脚本处理数据文件，并以方便的格式保存它们。这也将把数据分成训练集和评估集。

改编自亚马逊评论数据 页面 给出的有帮助的脚本。

检查您的 *data/* 目录中是否有*train_df.tsv**eval_df.tsv*文件。**

训练模型

数据格式

T5 模型的输入数据应该是包含 3 列的 Pandas 数据帧，如下所示。

  • prefix:表示要执行的任务的字符串。
  • input_text:输入的文本序列。
  • target_text:目标序列。

在内部，简单的转换器将从熊猫数据帧中构建适当格式化的输入和目标序列(如下所示)。

T5 模型的输入具有以下模式:

*"<prefix>: <input_text> </s>"*

**目标序列有如下模式:

*"<target_sequence> </s>"*

前缀值指定了我们希望 T5 模型执行的任务。为了训练 T5 模型执行新任务，我们简单地训练模型，同时指定适当的前缀。在这种情况下，我们将使用前缀ask_question。即，我们的数据帧中的所有行在前缀列中将具有值ask_question。

培养

使用简单的变压器训练模型非常简单。

正如您可能从培训脚本中观察到的，我们正在使用t5-large预培训模型。在t5-large模型上使用这些参数需要用一个泰坦 RTX GPU 进行大约 12 个小时的训练。根据你的 GPU 资源，你可以增加train_batch_size来加快训练速度，或者你可以减少它来适应带有更少 VRAM 的 GPU(泰坦 RTX 有 24 GB)。

注意，您可以通过增加 *gradient_accumulation_steps* 来抵消小批量的影响。有效批量大致等于 *train_batch_size * gradient_accumulation_steps* 。

您还可以通过选择t5-base模型来显著提高训练速度和 GPU 内存消耗。这可能会导致相对更差(但绝不是差)的模型。

该训练脚本还将使用权重&偏差框架自动记录训练进度。你可以在这里看到我的日志。

评估模型

评估一个语言生成模型比评估一个分类模型稍微复杂一些。这是因为没有正确的答案可以和分类模型进行比较。评估数据集包含人们对这些产品的描述和问题，但这并不意味着这些是你可以问的唯一正确的问题。

因此，评估语言生成模型的最佳方式之一是生成文本，并让一个实际的人(或几个人)对其进行评估。

说到生成文本，过去几年解码算法令人印象深刻的发展导致了能够生成非常真实的文本序列的模型。(解码算法用于生成文本)**

以下部分简要概述了当前使用的流行解码算法。

解码算法

这一部分主要基于关于文本生成的拥抱脸笔记本。我强烈推荐阅读这本笔记本，以便更深入地理解解码算法，因为它很好地解释了算法并展示了如何使用它们。

  1. 贪婪搜索—在每个时间步长选择概率最高的单词作为下一个单词。T5 论文将该算法用于短序列生成(例如分类)。
  2. 波束搜索——在每个时间步跟踪n最可能的假设(基于单词概率),并最终选择总体概率最高的假设。(n是光束的数量)
  3. Top-K sampling —在每个时间步从 K 个最可能的下一个单词中随机抽取一个单词。每一步可供选择的单词数量是固定的。
  4. Top-p 采样—从最小可能单词集中采样一个单词，该单词的累积概率(每个单词的概率之和)超过每个时间步长的概率 p 。每一步可供选择的单词数量是动态的。

我们将结合使用 Top-K 和 Top-p 抽样技术，通过 T5 模型生成问题。这种策略通常会产生看起来更自然的文本。

问题生成

简单变压器 T5 模型的predict()方法用于生成预测，或者在我们的情况下，生成问题。

这里，我们为eval_df数据集中的每个描述生成 3 个问题。

让我们来看看一些样品。

**只是为了好玩，我将生成的问题与数据集中的实际问题混在了一起。每个描述有 4 个问题，其中 3 个是生成的，一个是原始的。看你能不能分辨出哪个是哪个！我很想在评论中看到你的猜测。😉

样本 1

描述:

Smart Solar San Rafael II Solar Mission Lantern 将为任何户外环境提供优雅的氛围，是您的露台、甲板或花园的理想选择:由全天候聚塑料制成，具有种子玻璃效果，15 英寸的灯笼可以放在任何表面上，也可以使用集成的挂环悬挂。Rafael II 由顶部的两个暖白色 LED 照明，灯内有一根蜡烛，灯内有一个琥珀色 LED，产生温暖的发光效果。Rafael II 由一体式单晶太阳能电池板和可充电镍氢电池供电，无需布线或运营成本。灯笼在黄昏时自动打开，在黎明时自动关闭。Smart Living Home & Garden 为从授权分销商和零售商处购买的全部产品提供自最初购买日期起 1 年的有限制造商保修。Smart Solar 成立于 2002 年，提供各种太阳能产品。我们为您的庭院和花园设计、制造和定制所有我们自己的产品。享受我们的太阳能、节能、环保照明解决方案、水景和户外装饰。我们相信你会喜欢太阳能生活——这就是为什么我们近 15 年来一直在创造太阳能产品，发展太阳能生活方式。

问题:

  • 从地面到 LED 灯泡的高度是多少？谢谢
  • 柱子蜡烛用的是什么电池？
  • 需要多大尺寸的灯泡？
  • 它们重吗？我们有很多风，他们会在桌子上

样本 2

描述:

带治疗孔耐用狗球

问题:

  • 哈巴狗玩它会安全吗？
  • 有没有吱吱声？
  • 狗嚼的时候会爆吗
  • 这件物品的重量是多少？

样本 3

描述:

Petco 河岩石浅溪水族馆砾石 Petco 水族馆砾石是理想的淡水和安全的海洋水族馆。这种高质量的砾石具有彩色、耐用的涂层，专门为其永久性和无毒而开发。砾石被加工以去除潜在的有害碎片和物质。它不会影响水的化学性质，也不会伤害任何鱼类、无脊椎动物或植物。可用于水族馆、池塘、水上花园和水族箱。

问题:

  • 我有一条鱼鳍很精致的斗鱼。我想确保我得到的砾石不会刮伤或撕裂它们。这东西有用吗？
  • 有人在盐水中尝试过吗，如果有，效果如何？
  • 袋子和塑料/材料的尺寸是多少？
  • 这种砾石有利于水族馆中藻类的生长吗？

样本 4

描述:

进入一个世界的建设乐趣与乐高城市启动设置具有 3 个标志性的车辆。和骑摩托车的警察一起抓强盗！用消防员的快速消防车灭火。然后比赛在救护车上帮助摔倒的阿飞。年轻的建造者需要所有的灵感来探索拯救世界的有趣方式，创造无限的玩耍可能性！包括 5 个带附件的迷你人:强盗、警察、消防员、救助者和一个阿飞。272 件。5 岁以下。+.，“进入一个充满乐趣的积木世界，乐高城市首发套装包括 3 辆标志性的汽车。和骑摩托车的警察一起抓强盗。用消防队员的快速消防车灭火。然后比赛在救护车上帮助摔倒的阿飞。年轻的建造者需要所有的灵感来探索拯救世界的有趣方式，创造无限的玩耍可能性。包括 5 个带附件的迷你人:强盗、警察、消防员、救助者和一个阿飞。

问题:

  • 当所有的零件都在盒子里时，启动装置会在盒子里占据多少空间？
  • 积木本身有多大？
  • 乐高迷你人可以被制作成适合乐高家吗？
  • 这套是什么颜色的？画面不清晰，看起来很暗。

样品 5

描述:

这款电视柜优雅时尚，为您的家庭带来全新的面貌。呈深浓咖啡色。两扇滑动门。四个存储区。

问题:

  • 如果我的电视不是 32 英寸的，有什么方法可以调整这个单元的高度或宽度吗？
  • 这些架子有多高？我有一个高接收器，想确定它是否合适。
  • 两个储物格的尺寸是多少？谢谢！
  • 抽屉是可以拆下来的还是固定的？

样本 6

描述:

我们说棉花了吗？你打赌我们做到了。男士充电棉长袖 t 恤可能感觉像一件普通的棉 t 恤，但它绝不是普通的。其独特的制作结合了棉的经典舒适性和全天候装备的内置防水性，创造出世界上第一件真正的高性能棉 t 恤。它摸起来很柔软，但比普通棉干得更快，所以你永远不会被压垮。轻盈舒适。可拉伸的机动性。这是你穿过的最有力量的棉质 T 恤衫。毕竟，这是安德玛。

问题:

  • 你能帮我拿个大号的吗？
  • 这对跑步/短跑有用吗？我的手臂很小，没有太多的灵活性，但做了很多短跑。我穿 vrs2 可以吗
  • 12 岁男孩的衬衫尺寸是多少？
  • 尺寸大是什么胸部尺寸英寸？

额外样品

描述:

连接圆点！，“连接打点器！Dotters 是我们的 10 只喜气洋洋的达尔马提亚狗，由我们的超软毛绒材料制成，不仅可爱，而且可机洗！

问题:

  • 你能吃这个吗？

👀

您还可以在其他产品描述上测试您的模型。下面的脚本使用了我在易贝上找到的一个随机描述。

以及由此产生的问题:

  • 地球仪有多大？
  • 这盏灯是什么颜色的？
  • 我能为这盏灯购买更多的球吗？

包裹

对我来说，T5 模型最吸引人的方面是通过仅仅改变前缀来训练它完成全新任务的能力。在本文中，我们已经训练模型通过查看产品描述来生成问题。然而，通过简单地改变前缀，完全有可能在其他任务上训练相同的模型，并在不同的任务之间切换。**

这种灵活性为 T5 型号打开了一个全新的可能性和应用世界。我等不及要看接下来会发生什么了！

您还可以通过选择t5-base模型来显著提高训练速度和 GPU 内存消耗。这可能会导致相对较差(但绝不是较差)的性能。

有抱负的数据科学家和程序员:你现在正在把钱留在桌子上

原文：https://towardsdatascience.com/aspiring-data-scientists-and-programmers-youre-leaving-money-on-the-table-right-now-daea3ffc6c7e?source=collection_archive---------49-----------------------

交互式工具，用于评估当今环境中所需的技能，并确定获得经验的垫脚石

佩皮·斯托扬诺夫斯基在 Unsplash 拍摄的照片

有许多关于成为数据科学家或开发人员所需的十大技能的精彩文章。这些技能需要数年时间来培养(尽管新兵训练营承诺)。与此同时，你可以在 gig 工作场所施展你的才华。在有(或没有)现实世界需求的情况下解决现实世界问题的经验，会让你对那些坚持只解决玩具问题的人有所帮助。

零工经济平台上的工作可能成功也可能失败。竞争非常激烈，尤其是那些全球性的职位。你可以做一些事情来增加找到好工作的几率。

技能自我评估

意识到什么是可用的是第一步。首先，列出你有信心按时完成专业产出的技能。一些想法:Excel 公式，SQL 查询，查询调优，web 抓取，SQL server 存储过程，可视化(Tableau，Power BI)，python，R，回归模型，流失模型。对于程序员来说，这个列表可能包括各种编程语言、数据库设计、云和 AWS 组件，如 S3、红移、弹性计算、ETL。

所需技能的分析

我对 2020 年 9 月 1 日 guru.com 上发布的所有工作做了一个快照分析。具体来看软件和编程工作，我用我的发现创建了一个 Tableau 仪表板。您可以通过此链接访问 Tableau Public 上的仪表板(点击此处)。

你会发现在 viz 的顶部有很多标签。这些是一些更常见的数据科学类型的任务。我会根据我的好奇心或评论中的要求添加更多内容。

Tableau 作者截图(点此)

需求是什么？

Tableau 作者截图(点此)

对编程语言的需求一直很高。那么，典型的数据科学技能属于这个列表的哪一部分呢？Python、SQL、Web 抓取都在图表的前三分之一。这些是你获得成功应该具备的一些基本技能。接零工是一个利用这些技能赚钱的绝佳机会。

里面有钱吗？

是的，自由职业是有钱的。下图显示了一个不错的预算甜蜜点。诚然，“低于 250”是从完全不值得大惊小怪到一个令人满意的发薪日的重大跨越。有时候，与客户的一次成功合作会引发另一次成功合作。或许这能让你找到一份收入更高的工作。这种情况经常发生，尽管你应该被警告把工作从平台上拿下来是有后果的。这些平台通过削减预算来赚钱，他们想把你留在那里。

Tableau 作者截图(点击此处)

确保好的演出

有一个学习曲线。我可以给你一些建议，但是你仍然需要从经验中学习。以下是我学到的一些经验。

  1. 这个要求合乎道德吗？我被要求创建虚假的产品评论或完成某人的家庭作业。我拒绝了这些提议。我在金融行业工作时，也会拒绝金融领域的任何事情。
  2. 需求写得好吗？我只挑选那些看起来是由希望完成专业工作的专业人士编写的需求。他们提供所需的信息，并对他们想要的回报(报告、代码、数据)有一个固定的期望。
  3. 要求合理吗？你认为你能用 200 美元编写和部署一个全新的应用程序吗？有人要求创建一个“像脸书一样”的应用程序吗？没有。让其他一些傻瓜去做那些工作，然后为了一点点的钱去做一大堆疯狂的工作。

4.工作是否值得付出，反之亦然？我做过从 5 美元到几千美元的工作。有时快速 10 美元击球手有助于保持你的情绪，只要你知道你能在 15 分钟内快速完成要求的工作。有些要求看似合理，但一旦你进入细节，它就会爆发。做个专业人士。你签约做这项工作，报酬是这么多。如果你快完成了，那就完成它。有时事情完全失控，或者问题无法用他们所要求的架构或技术来解决。在这种情况下，写一份完整的陈述，说明你完成了什么，你发现了什么，以及你建议接下来要做什么。

我对半年内每周 30 小时的工作持谨慎态度。你全职工作，没有福利或保护。那不是演出，那是工作。

5.客户声誉好吗？他们会付你钱吗？大多数网站会提供客户的反馈，以及他们过去花了多少钱。我有时会过滤那些只想要美国工人的客户。额外的好处是对这些工作的出价少得多，所以你的机会更大。

6.最后，你有能力完成这个请求吗？你有合适水平的技能吗？从你的联盟中挑选一些东西；你可能会有麻烦。此外，该请求是否需要任何特殊许可？画面发展想到了。虽然 Tableau Public 是免费的，但企业许可证却很贵。他们需要给你一把钥匙。

利用你所知道的来优先考虑你的训练。

既然你已经看了那里有什么，是时候将你的技能列表与要求的技能进行比较了。有没有一个领域有你还没有培训好的工作机会？这可能会成为你训练清单上的下一个目标。该自我评估将帮助您根据总体价值确定培训的优先顺序。最新的深度学习模型很有趣，但巩固需求收集、项目管理、专业演示、数据管理以及基本统计和分析的基础将带你走得很远。非常远。

结论

希望你能更好地了解你的技能与自由职业者市场的匹配程度。利用这些信息来指导你的训练，并利用你已经掌握的知识积累经验。

对于那些感兴趣的人，如果你想了解以下技能的更多信息，请在回复中大声喊出来:游戏设计、通用编程、网站开发、数据库设计、故障排除、Angular、Node.js、应用程序开发、所有 Cs、云、图形、硬件、内容管理、CRM、CSS、电子商务、开发等等。

数据科学/大数据实验室——第 3 部分(共 4 部分): 3 节点集群中 Ubuntu 上的 Hive 和 Postgres

原文：https://towardsdatascience.com/assembling-a-personal-data-science-big-data-laboratory-in-a-raspberry-pi-4-or-vms-cluster-8a1da8d49b48?source=collection_archive---------37-----------------------

实验室数据

使用 Hadoop、Spark、Hive、Kafka、Zookeeper 和 PostgreSQL 在 Raspberry Pi 4 或 VMs 集群中组建数据科学/大数据实验室

这段文字可以用来支持在任何 Ubuntu 20.04 服务器集群中的安装，这就是设计良好的分层软件的妙处。此外，如果您有更多的节点，您可以随意分发软件。本文假设您知道 Linux 命令行，包括 ssh、vim 和 nano。

我不建议从少于三个树莓开始，因为你需要设置通信，并且 Zookeeper 和 Kafka 都需要奇数个节点。如果您尝试使用单个节点，可以使用本指南。尽管如此，性能可能会令人失望——对于单节点，我建议虚拟机具有合理数量的 RAM 和处理器。

由于篇幅原因，我不得不将教程分成四部分:

所有配置文件均可在【1】:获得

[## ptaranti/RaspberryPiCluster

Hadoop+Spark+Hive+Kafka+Postgresql raspberry 集群(ubuntu 20.04)的配置文件

github.com](https://github.com/ptaranti/RaspberryPiCluster)

免责声明 : 此文免费提供给大家使用，风险自担。我小心地引用了我所有的资料来源，但是如果你觉得遗漏了什么，请给我发个短信。由于不同的软件版本可能会因其依赖性而表现出不同的行为，我建议使用我在第一次尝试中使用的相同版本。

4.一种数据库系统

我决定在集群中安装一个成熟的关系数据库，如果你要处理数据，这是一个明智的决定。我选择 PostgreSQL 主要是因为它对 GIS 的成熟支持(我使用 GIS 数据)。我将它放在节点 3 中，因为节点 1 有 Spark —来分配工作负载。

我将安装 Hive，它可以很好地与 PostgreSQL 以及 MySQL 和其他语言耦合。

您将找到几个关于如何安装 PostgreSQL 的教程和大量文档。

我有使用 PostgreSQL 的经验，但是按照

[## 如何在 Ubuntu 18.04 上安装 PostgreSQL

PostgreSQL 或 Postgres 是一个开源的通用对象关系数据库管理系统。PostgreSQL 有…

linuxize.com](https://linuxize.com/post/how-to-install-postgresql-on-ubuntu-18-04/)

您需要编辑以下文件

/etc/PostgreSQL/12/main/pg _ HBA . conf

我知道我很懒，以一种准许可的方式配置了 PostgreSQL。请随意更新，但是我建议您只有在所有集群都正常运行后才实施安全性。

你可能想改变设置

/etc/PostgreSQL/12/main/PostgreSQL . conf

我编辑了以下属性:

listen_addresses = '*'

这通知 PostgreSQL 监听主机中的所有网络接口。

为了方便，我把 postgres 的密码改成了 postgres(我知道这很蠢..这是实验室，不是生产环境):

pi@pi2:~$ sudo su - postgres
postgres@pi2:~$ psql
psql (12.2 (Ubuntu 12.2-4))
Type "help" for help.postgres=# ALTER USER postgres  WITH PASSWORD 'postgres';
ALTER ROLE
postgres=# \q
postgres@pi2:~$ exit
logout
pi@pi2:~$

为了方便起见，我也把我的配置文件放在了 GitHub 中(参见 pi3)

我将数据库设置为由应用程序用户/密码访问。

我喜欢在 windows 机器上使用 visual pgadmin4 来管理数据库。该工具可安装在您的笔记本电脑上，并可远程使用:

[## [计] 下载

用于 Windows，Mac，Linux 和网络的 PostgreSQL 工具

www.pgadmin.org](https://www.pgadmin.org/download/)

注意—按照 PostgreSQL 的默认 Ubuntu 安装程序，数据库管理器服务将在每次重新启动时自动启动。

5.储备

我找到的树莓集群教程没有讨论配置单元安装。

为了更好地理解 Hive，我建议使用项目 wiki 页面:

https://cwiki.apache.org/

注意:Hive 需要执行 Hadoop。在启动 Hive 之前，您需要运行:

start-dfs.sh
start-yarn.sh

我应该说安装 Hive 是痛苦的！我已经用 Derby 在本地安装了它，这或多或少很简单。但是我决定将环境作为一个产品来分发:

我在 PostgreSQL 服务器中实例化了一个 metastore 数据库。hive metastore 服务器连接到数据库并接收来自 hiveservers2 的连接。hiveserver2 通过 CLI、beeline 进行评估，并具有 webUI。

hive 架构升级得非常好，允许许多 hiveserver 和 metastore。用户可以通过网络连接并提交他们的查询。

在分布式环境中安装 Hive 最糟糕的地方是，我没有在文档或我查阅的书籍中找到任何更新的教程。但最后，一切都成功了。我将描述如何安装 Hive 分发安装。

从以下位置首次下载配置单元

[## /hive 的索引

编辑描述

downloads.apache.org](https://downloads.apache.org/hive/)

Hive 在一个完整的包中提供了所有的功能。请注意为您的 Hadoop 安装选择正确的 hive 版本。

在

/home/pi/tmp

wget  [https://downloads.apache.org/hive/hive-3.1.2/apache-hive-3.1.2-bin.tar.gz](https://downloads.apache.org/hive/hive-3.1.2/apache-hive-3.1.2-bin.tar.gz)tar -xvf apache-hive-3.1.2-bin.tar.gzmv apache-hive-3.1.2-bin hivesudo mv hive /opt/sudo chown -R pi:pi /opt/hive

5.1 设置环境

编辑

/home/pi/。巴沙尔

在文件末尾添加:

# HIVE**export HIVE_HOME=/**opt**/**hive
**export PATH=$PATH:/**opt**/**hive**/**bin

比:

source /home/pi/.bashrc

5.2 Metastore

在 Hadoop 文件系统上创建数据仓库:

hdfs dfs -mkdir -p /user/hive/warehouse
hdfs dfs -chmod g+w /user/hive/warehouse
hdfs dfs -mkdir -p /tmp
hdfs dfs -chmod g+w /tmp

5.3 Lib guava -冲突问题

存在由库版本引起的冲突。从 hive 中删除番石榴，并复制 Hadoop 中可用的更新版本:

$ rm /opt/hive/lib/guava-19.0.jar
$ cp /opt/hadoop/share/hadoop/common/lib/guava-27.0-jre.jar /opt/hive/lib/cp /opt/hive/conf/hive-env.sh.template  /opt/hive/conf/hive-env.sh

5.4 配置文件

我只从 hive 中准备了一个安装，并通过节点 1 和 2 (pi1 和 pi2)分发它。hiveserver2 将在 pi1 中启动，hive-metastore 将在 pi2 中启动(但配置文件完全相同)。

配置文件必须在以下位置创建:

/opt/hive/conf/hive metastore-site . XML

注意——javax . jdo . option . connection URL必须指向您的 PostgreSQL 数据库。我把它安装在 pi3 (192.168.1.13)

现在，编辑以下文件:

/opt/hive/conf/hive server 2-site . XML

注意—hive . metastore . uri必须指向您的 hive metastore 服务器。我在 pi2 (192.168.1.12)安装了一个

现在，编辑该文件:

【T18/opt/hive/conf/hive-env . sh

从 PostgreSQL 站点下载 JDBC 驱动程序

https://jdbc.postgresql.org/download.html

并将其复制到:

/opt/hive/lib/PostgreSQL-9 . 4 . 1208 . JRE 7 . jar

注意—这是当前版本，您应该安装更多更新。

5.5 准备 Postgres

我已经在我的 windows 笔记本上安装了 pgAdmin4 并连接到 PostgreSQL。

我使用 pgAdmin4 GUI 来执行这些步骤:

首先，使用密码 hive 创建一个新的角色 hive (该信息在 hivemetastore-site.xml 配置中使用)。

之后，您需要创建一个名为“metastore”的新数据库，用户“hive”作为所有者。

5.5.1 启动 metastore 数据库模式

此过程将读取 hivemetastore-site.xml 以了解连接信息— IP、端口、用户、密码、数据库名称。

pi@pi1:/opt/hive/bin$ ./schematool -dbType postgres -initSchema

输出:

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/opt/hive/lib/log4j-slf4j-impl-2.10.0.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/opt/hadoop/share/hadoop/common/lib/slf4j-log4j12-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See [http://www.slf4j.org/codes.html#multiple_bindings](http://www.slf4j.org/codes.html#multiple_bindings) for an explanation.
SLF4J: Actual binding is of type [org.apache.logging.slf4j.Log4jLoggerFactory]
Metastore connection URL:        jdbc:postgresql://pi3:5432/metastore
Metastore Connection Driver :    org.postgresql.Driver
Metastore connection User:       hive
Starting metastore schema initialization to 3.1.0
Initialization script hive-schema-3.1.0.postgres.sqlInitialization script completed
schemaTool completed

您可以在命令行中使用 pgsql 在 pgAdmin4 接口 ou 上检查新数据库。

编辑:

/home/pi/。巴沙尔

添加:

**export HIVE_HOME=/**opt**/**hive
**export HIVE_CONF_DIR=/**opt**/**hive**/**conf**export PATH=$**PATH**:$**HIVE_HOME**/**bin**:$**HADOOP_HOME**/**bin**:$**HADOOP_HOME**/**sbin

请参考的最终版本。GitHub 中的 bashrc。

5.6 通过网络连接 hiveserver2 和 hive-metastore 时出现的问题

当我将 hiveserver2 连接到 hive-metastore 时，我面临了一场噩梦。最后，我成功地实现了在:

[## HiveServer2 无法连接到配置单元 Metastore 解决方案/变通办法

从 Hive 3.x 开始，增加了针对 HiveServer2 客户端的新身份验证功能。启动 HiveServer2 服务时(配置单元…

kontext .技术](https://kontext.tech/column/hadoop/303/hiveserver2-cannot-connect-to-hive-metastore-resolutionsworkarounds)

此网页描述了由于在 Hive 3 中插入了新的身份验证功能而出现的错误。用于 HiveServer2 客户端的 x。启动 HiveServer2 服务时(Hive 版本 3.0.0)。

建议的解决方法需要在 Hadoop(所有节点中)修改文件 core-site.xml 中的 proxyuser 属性。

/opt/Hadoop/etc/Hadoop/core-site . XML

这在 GitHub 中有所体现。

注意:如果事情出错，您可能需要研究错误和服务。您应该考虑安装 netstat ，以便能够检查每个服务器中监听的端口。

Hiveserver 2 —端口 1000 和 10002 (10002 用于 webUI)

Metastore 端口 9083

sudo netstat -plnt | grep ‘1000’

5.7 分配蜂箱

现在，您必须将安装复制到要运行 hiveserver2、hivemetastore 的节点，以及要执行 CLI(直线)的位置。我复制到所有 3 个节点。

在我的安装中，如前所述，我在 pi1 中使用 hiveserver2，在 pi2 中使用 hivemetastore。请注意，hiveserver2 和 metastore 的配置文件是独立的。当启动这些服务时，您提供指示您打算启动哪个服务的参数。例如，在声明 hiveserver2 时，Hive 不会读取 hivemetastore-site.xml 文件。因此，对于我们来说，将两个配置保存在同一个文件夹中并分发安装是安全的。

要将配置单元安装复制到其他节点:

在 pi2 中:

sudo mkdir /opt/hive
sudo chown -R pi:pi /opt/hive

在 pi3 中:

sudo mkdir /opt/hive
sudo chown -R pi:pi /opt/hive

在 pi1 中:

rsync  -vaz /opt/hive/   pi2:/opt/hive
rsync  -vaz /opt/hive/   pi3:/opt/hive

5.8 启动配置单元

你需要先启动 Hadoop 和 yarn(start-DFS . sh和 start-yarn.sh )和 postgres ！！！

最初，我更喜欢用详细日志启动服务；这有助于了解一切是否顺利，以及了解 Hive 如何在后台工作。请注意， hive-metastore 和 hiveserver2 都需要单独的终端，而第三个终端对于直线来说是必要的。

您应该首先启动 hive-metastore。

在 pi2 中:

hive --service metastore --hiveconf hive.root.logger=INFO,console

初始化 hive-metastore 后，应该启动 hiveserver2。

在 pi1 中:

hive --service hiveserver2 --hiveconf hive.root.logger=INFO,console

您可以使用命令 hiveserver2 在没有详细日志的情况下启动

在初始化这个服务之后，你可以用 jps 和 netstat 命令来检查它。

5.9 直线

现在您可以运行 beeline 来检查是否一切顺利。我从 pi3 开始测试:

首先，启动 beeline 并连接到 hiveserver

pi@pi3:~$ beeline
WARNING: log4j.properties is not found. HADOOP_CONF_DIR may be incomplete.
WARNING: log4j.properties is not found. HADOOP_CONF_DIR may be incomplete.
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/opt/hive/lib/log4j-slf4j-impl-2.10.0.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/opt/hadoop/share/hadoop/common/lib/slf4j-log4j12-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See [http://www.slf4j.org/codes.html#multiple_bindings](http://www.slf4j.org/codes.html#multiple_bindings) for an explanation.
SLF4J: Actual binding is of type [org.apache.logging.slf4j.Log4jLoggerFactory]
Beeline version 3.1.2 by Apache Hive
beeline> !connect jdbc:hive2://192.168.1.11:10000/default
Connecting to jdbc:hive2://192.168.1.11:10000/default
Enter username for jdbc:hive2://192.168.1.11:10000/default:
Enter password for jdbc:hive2://192.168.1.11:10000/default:
Connected to: Apache Hive (version 3.1.2)
Driver: Hive JDBC (version 3.1.2)
Transaction isolation: TRANSACTION_REPEATABLE_READ

现在，您可以访问 hive 中的数据库

0: jdbc:hive2://192.168.1.11:10000/default> show databases;
INFO  : Compiling command(queryId=pi_20200604081053_b4992aba-814a-40cd-a32e-12d5b33f0926): show databases
INFO  : Concurrency mode is disabled, not creating a lock manager
INFO  : Semantic Analysis Completed (retrial = false)
INFO  : Returning Hive schema: Schema(fieldSchemas:[FieldSchema(name:database_name, type:string, comment:from deserializer)], properties:null)
INFO  : Completed compiling command(queryId=pi_20200604081053_b4992aba-814a-40cd-a32e-12d5b33f0926); Time taken: 6.27 seconds
INFO  : Concurrency mode is disabled, not creating a lock manager
INFO  : Executing command(queryId=pi_20200604081053_b4992aba-814a-40cd-a32e-12d5b33f0926): show databases
INFO  : Starting task [Stage-0:DDL] in serial mode
INFO  : Completed executing command(queryId=pi_20200604081053_b4992aba-814a-40cd-a32e-12d5b33f0926); Time taken: 0.215 seconds
INFO  : OK
INFO  : Concurrency mode is disabled, not creating a lock manager
+----------------+
| database_name  |
+----------------+
| default        |
+----------------+
1 row selected (8.228 seconds)
0: jdbc:hive2://192.168.1.11:10000/default>

看看这些表格。Hive CLI 类似于 SQL。

0: jdbc:hive2://192.168.1.11:10000/default> show tables;
INFO  : Compiling command(queryId=pi_20200604081200_943e5495-23c4-4e35-8975-cedef4563d62): show tables
INFO  : Concurrency mode is disabled, not creating a lock manager
INFO  : Semantic Analysis Completed (retrial = false)
INFO  : Returning Hive schema: Schema(fieldSchemas:[FieldSchema(name:tab_name, type:string, comment:from deserializer)], properties:null)
INFO  : Completed compiling command(queryId=pi_20200604081200_943e5495-23c4-4e35-8975-cedef4563d62); Time taken: 0.157 seconds
INFO  : Concurrency mode is disabled, not creating a lock manager
INFO  : Executing command(queryId=pi_20200604081200_943e5495-23c4-4e35-8975-cedef4563d62): show tables
INFO  : Starting task [Stage-0:DDL] in serial mode
INFO  : Completed executing command(queryId=pi_20200604081200_943e5495-23c4-4e35-8975-cedef4563d62); Time taken: 0.193 seconds
INFO  : OK
INFO  : Concurrency mode is disabled, not creating a lock manager
+-----------+
| tab_name  |
+-----------+
+-----------+
No rows selected (0.463 seconds)
0: jdbc:hive2://192.168.1.11:10000/default>

5.10 配置单元服务器 2 WebUI

Hiveserver2 在端口 10002 上有一个默认的 webUI:

http://pi1:10002/

然后

[## 数据科学/大数据实验室——第 4 部分，共 4 部分:卡夫卡和 Zookeeper over Ubuntu in a 3-node…

使用 Hadoop、Spark、Hive、Kafka 在 Raspberry Pi 4 或 VMs 集群中组建数据科学/大数据实验室…

towardsdatascience.com](/kafka-and-zookeeper-over-ubuntu-in-a-3-node-cluster-a-data-science-big-data-laboratory-part-4-of-4-47631730d240)

[1] P. G .塔兰蒂。https://github.com/ptaranti/RaspberryPiCluster

[2] R .唐。 HiveServer2 无法连接到 Hive Metastore 解决方案/变通办法 (2018)

数据科学/大数据实验室—第 2 部分，共 4 部分:3 节点集群中基于 Ubuntu 20.04 的 Hadoop 3.2.1 和 Spark 3.0.0

原文：https://towardsdatascience.com/assembling-a-personal-data-science-big-data-laboratory-in-a-raspberry-pi-4-or-vms-cluster-e4c5a0473025?source=collection_archive---------25-----------------------

实验室数据

使用 Hadoop、Spark、Hive、Kafka、Zookeeper 和 PostgreSQL 在 Raspberry Pi 4 或 VMs 集群中组建数据科学/大数据实验室

这段文字可以用来支持在任何 Ubuntu 20.04 服务器集群中的安装，这就是设计良好的分层软件的妙处。此外，如果您有更多的节点，您可以随意分发软件。本文假设您知道 Linux 命令行，包括 ssh、vim 和 nano。

我不建议从少于三个树莓开始，因为你需要设置通信，并且 Zookeeper 和 Kafka 都需要奇数个节点。如果您尝试使用单个节点，可以使用本指南。尽管如此，性能可能会令人失望——对于单节点，我建议虚拟机具有合理数量的 RAM 和处理器。

由于篇幅原因，我不得不将教程分成四部分

所有配置文件均可在【1】:获得

[## ptaranti/RaspberryPiCluster

Hadoop+Spark+Hive+Kafka+Postgresql 集群(ubuntu 20.04)的配置文件

github.com](https://github.com/ptaranti/RaspberryPiCluster)

免责声明 : 此文免费提供给大家使用，风险自担。我小心地引用了我所有的资料来源，但是如果你觉得遗漏了什么，请给我发个短信。由于不同的软件版本可能会因其依赖性而表现出不同的行为，我建议使用我在第一次尝试中使用的相同版本。

3.安装 Hadoop 和 Spark

Hadoop 和 Spark 安装考虑了来自[3，4]和其他来源的指令。

我使用了 Apache 网站上的更新版本:

  • hadoop-3.2.1.tar.gz
  • spark-2 . 4 . 5-bin-Hadoop 2.7 . tgz

3.1 设置您的环境

首先:下载，并将文件解压到/opt。授予 pi 用户访问权限。

sudo tar -xvf hadoop-3.2.1.tar.gz -C /opt/
sudo tar -xvf spark-2.4.5-bin-hadoop2.7.tgz  -C /opt/cd /opt/pi@pi1:/opt$ sudo mv hadoop-3.2.1 hadoop
pi@pi1:/opt$ sudo mv spark-2.4.5-bin-hadoop2.7 spark
pi@pi1:/opt$ sudo chown -R pi:pi /opt/spark
pi@pi1:/opt$ sudo chown -R pi:pi /opt/hadoop

添加到 /home/pi/。巴沙尔:

编辑后:

source /home/pi/.bashrc

3.2 将 Hadoop 和 Spark 配置为单个节点

现在您需要配置 Hadoop 和 Spark

为了清楚起见，我们首先将其配置为单个节点，然后针对群集进行修改。我在 GitHub 中的存储库只包含最终的集群配置文件。

Hadoop

转到文件夹

/opt/Hadoop/etc/Hadoop/

在这一点上，我遇到了很多麻烦:我不小心在文件头上插入了一行 blanc。这一空白行导致解析错误，Hadoop 一直失败，直到我意识到这个问题。

编辑文件

/opt/Hadoop/etc/Hadoop/Hadoop-env . sh，

在末尾增加以下一行:

**export JAVA_HOME=/**usr**/**lib**/**jvm**/**java-8-openjdk-arm64

编辑配置于

/opt/Hadoop/etc/Hadoop/core-site . XML

编辑配置于

【T18/opt/Hadoop/etc/Hadoop/HDFS-site . XML

现在准备数据区:

$ sudo mkdir -p /opt/hadoop_tmp/hdfs/datanode
$ sudo mkdir -p /opt/hadoop_tmp/hdfs/namenodesudo chown -R pi:pi /opt/hadoop_tmp

编辑配置于

/opt/Hadoop/etc/Hadoop/map red-site . XML

编辑配置于

/opt/Hadoop/etc/Hadoop/yarn-site . XML

准备数据空间:

$ hdfs namenode -format -force$ start-dfs.sh
$ start-yarn.sh$ hadoop fs -mkdir /tmp$ hadoop fs -ls /
Found 1 items
drwzr-xr-x   - pi supergroup          0 2019-04-09 16:51 /tmp

使用 jps 检查所有服务是否开启(数字变化..) :

$ jps
2736 NameNode
2850 DataNode
3430 NodeManager
3318 ResourceManager
3020 SecondaryNameNode

你需要这五项服务！

测试

为了测试单个节点，我参考了教程[2]:

执行以下命令:

**pi@pi1:/opt$ hadoop fs -put $SPARK_HOME/README.md /**
2020-06-24 19:16:02,822 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
2020-06-24 19:16:06,389 INFO sasl.SaslDataTransferClient: SASL encryption trust check: localHostTrusted = false, remoteHostTrusted = false
**pi@pi1:/opt$ spark-shell**
2020-06-24 19:16:23,814 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
Spark context Web UI available at [http://pi1:4040](http://pi1:4040)
Spark context available as 'sc' (master = local[*], app id = local-1593026210941).
Spark session available as 'spark'.
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 3.0.0
      /_/Using Scala version 2.12.10 (OpenJDK 64-Bit Server VM, Java 1.8.0_252)
Type in expressions to have them evaluated.
Type :help for more information.**scala> val textFile = sc.textFile("hdfs://pi1:9000/README.md")**
textFile: org.apache.spark.rdd.RDD[String] = hdfs://pi1:9000/README.md MapPartitionsRDD[1] at textFile at <console>:24**scala> textFile.first()**
res0: String = # Apache Sparkscala>

此时，我陷入了困境，出现了类似于以下内容的重复消息:

INFO 纱。委托人:申请报告 _1434263747091_0023(状态:已受理)

我遵循了[4]和其他来源的建议，更改了以下文件/opt/Hadoop/etc/Hadoop/capacity-scheduler . XML。

如果在资源较少的单台机器上运行集群，应该设置参数yarn . scheduler . capacity . maximum-am-resource-percent。此设置指示可分配给应用程序主机的资源比例，从而增加了可能的并发应用程序的数量。请注意，这取决于您的资源。它在我的 Pi 4 4GB 内存中工作。

编辑文件，添加属性:

/opt/Hadoop/etc/Hadoop/capacity-scheduler . XML

注意——教程通常提供命令抑制警告。我更喜欢在实验时看到这些警告。如果您想删除它，请参考第一个教程。

3.3 集群中的 Hadoop 与 Yarn

现在，您应该在单个节点中拥有一个完全可操作的安装。是 Hadoop 走向集群的时候了！

我完成了教程，但是遇到了一些问题。这是意料之中的—不同的环境，不同的软件版本。

经过一些尝试，我成功地拥有了一个稳定的环境。配置 Hadoop 以在集群中使用 Yarn 的下一步是将两者结合起来[2，4]。

注意—由于火花，除了节点 pi1 (pi1 ->主节点)之外，所有节点都具有相同的配置(p2、p3、… ->工作节点)。同样，我的 GitHub 存储库中有可用的配置。我已经提供了所有节点的配置。

为所有节点创建文件夹:

$ clustercmd-sudo mkdir -p /opt/hadoop_tmp/hdfs
$ clustercmd-sudo chown –R pi:pi /opt/hadoop_tmp
$ clustercmd-sudo mkdir -p /opt/hadoop
$ clustercmd-sudo chown -R pi:pi /opt/Hadoop

下一步将从 Hadoop 中删除所有数据。如果有重要的事情，先做好备份。

$ clustercmd rm –rf /opt/hadoop_tmp/hdfs/datanode/*
$ clustercmd rm –rf /opt/hadoop_tmp/hdfs/namenode/*

注意，火花只会存在于主人身上。

复制 Hadoop:

来自 pi1:

pi@pi1:~$  rsync -vaz  /opt/hadoop   pi2:/opt/ hadoop   
pi@pi1:~$  rsync -vaz  /opt/hadoop   pi3:/opt/ hadoop   
pi@pi1:~$  rsync -vaz  /opt/hadoop   pi4:/opt/ hadoop

对所有节点都这样做。

我更喜欢一个一个做，确认没有异常行为。

现在，需要编辑以下文件，更改配置:

/opt/Hadoop/etc/Hadoop/core-site . XML

/opt/Hadoop/etc/Hadoop/HDFS-site . XML

注意—属性 dfs.replication 表示数据在集群中复制的次数。您可以设置在两个或更多节点上复制所有数据。不要输入高于实际工作节点数的值。我用 1 是因为我的一个笔记本用的是 16GB 的 micro SD。由于新冠肺炎病毒爆发，我的一些部分在邮件中延迟了。如果配置错误，由于缺乏资源，您的 spark 应用程序将陷入“已接受”状态。

注意—最后一个属性DFS . permissions . enabled被设置为 false 以禁用权限检查。我使用集群外部机器上的 spark，这方便了我的访问。显然，我建议不要在生产环境中使用这个设置。我还关闭了安全模式。为此，在完成安装运行后:

 hdfs dfsadmin -safemode leave

数据在集群中复制的次数。您可以设置在两个或更多节点上复制所有数据。不要输入高于实际工作节点数的值。我用 1 是因为我的一个笔记本用的是 16GB 的 micro SD。由于新冠肺炎病毒爆发，我的一些部分在邮件中延迟了。如果配置错误，由于缺乏资源，您的 spark 应用程序将陷入“已接受”状态。

/opt/Hadoop/etc/Hadoop/mapred-site . XML

/opt/Hadoop/etc/Hadoop/yarn-site . XML

创建两个文件:

/opt/Hadoop/etc/Hadoop/master

/opt/Hadoop/etc/Hadoop/workers

更新所有节点上的配置文件后，需要格式化数据空间并启动集群(可以从任何节点启动):

$ hdfs namenode -format -force$ start-dfs.sh
$ start-yarn.sh

3.4 配置火花

基本上，您需要创建/编辑以下配置文件:

/opt/spark/conf/spark-defaults . conf

这些值可以根据您的硬件进行调整，但它们将适用于 Raspberry Pi 4 4GB。

将环境变量设置为:

/opt/spark/conf/spark-env . sh

在所有节点中安装以下软件包，以便允许节点处理用 python/pyspark 准备的作业:

sudo apt intall python3 python-is-python3

3.5 测试集群

重新启动所有节点，并重新启动服务:

$ start-dfs.sh
$ start-yarn.sh

您可以发送一个应用示例来测试 spark:

$ spark-submit --deploy-mode client --class org.apache.spark.examples.SparkPi /opt/spark/examples/jars/spark-examples_2.12-3.0.0.jar

在处理结束时，您应该会收到 PI 值的近似计算结果:

**Pi is roughly 3.140555702778514**

(这个圆周率计算需要改进！！！！)

3.6 面向 Hadoop 和 Yarn 的 Web 应用

Hadoop webUi

h ttp://pi1:9870/

最初，我无法在线处理(上传/删除)文件。以下网址提供了一种解决方法:

[## 无法将文件上传到 hdfs

当我试图上传文件到 HDFS，它显示“错误:未定义”。然而，从终端我可以成功上传文件…

community.cloudera.com](https://community.cloudera.com/t5/Support-Questions/unable-to-upload-files-to-hdfs/td-p/33650)

该解决方法是通过向 Hadoopcore-site . XML添加以下属性来实现的:

Yarn WebUi

http://pi1:8088/

然后

[## 数据科学/大数据实验室——第 3 部分(共 4 部分): 3 节点集群中 Ubuntu 上的 Hive 和 Postgres

使用 Hadoop、Spark、Hive、Kafka 在 Raspberry Pi 4 或 VMs 集群中组建数据科学/大数据实验室…

towardsdatascience.com](/assembling-a-personal-data-science-big-data-laboratory-in-a-raspberry-pi-4-or-vms-cluster-8a1da8d49b48)

[1] P. G .塔兰蒂。https://github.com/ptaranti/RaspberryPiCluster

[2]华生。构建 Raspberry Pi Hadoop / Spark 集群 (2019)

[3]梁伟雄。从零开始构建 Raspberry Pi Hadoop/Spark 集群 (2019)

[4]霍巴特。如何安装和设置 3 节点 Hadoop 集群 (2019)

数据科学/大数据实验室—第 1 部分，共 4 部分:Raspberry Pi 或 VMs 集群—操作系统和通信

原文：https://towardsdatascience.com/assembling-a-personal-data-science-big-data-laboratory-in-a-raspberry-pi-4-or-vms-cluster-ff37759cb2ec?source=collection_archive---------19-----------------------

实验室数据

使用 Hadoop、Spark、Hive、Kafka、Zookeeper 和 PostgreSQL 在 Raspberry Pi 4 或 VMs 集群中组建数据科学/大数据实验室

这段文字可以用来支持在任何 Ubuntu 20.04 服务器集群中的安装，这就是设计良好的分层软件的妙处。此外，如果您有更多的节点，您可以随意分发软件。本文假设您知道 Linux 命令行，包括 ssh、vim 和 nano。

我不建议从少于三个树莓开始，因为你需要设置通信，并且 Zookeeper 和 Kafka 都需要奇数个节点。如果您尝试使用单个节点，可以使用本指南。尽管如此，性能可能会令人失望——对于单节点，我建议虚拟机具有合理数量的 RAM 和处理器。

由于篇幅原因，我不得不将教程分成四部分

所有配置文件均可在【1】:获得

[## ptaranti/RaspberryPiCluster

Hadoop+Spark+Hive+Kafka+Postgresql 集群(ubuntu 20.04)的配置文件

github.com](https://github.com/ptaranti/RaspberryPiCluster)

免责声明 : 此文免费提供给大家使用，风险自担。我小心地引用了我所有的资料来源，但是如果你觉得遗漏了什么，请给我发个短信。由于不同的软件版本可能会因其依赖性而表现出不同的行为，我建议使用我在第一次尝试中使用的相同版本。

1.介绍

培训或学习数据科学或商业智能通常是一项孤独的任务。你可以去读 MBA 或者在网上诅咒，但是巩固知识需要实践和尝试。

对于某些技术来说，这很简单。Python 和 R 可以很容易的安装在一般的电脑上。然而，一个完整的实验需要集成几个工具，从数据采集到报告/可视化。

这些工具…我能说什么呢…我不喜欢不理解我正在使用的工具。我是一个 1987 年和 12yo 一起学习 Basic 语言的老家伙。我用 Z80 从磁带播放器加载程序，在 90 年代，我管理 Novell networks，在 Minix 之后几年才使用 Linux 不，我不是博物馆馆长。我学了 Fortran，Pascal，C，Java…现在又学了 R 和 Python。我想在接近真实的环境中训练管道和分析——这让我回到了工具上。我觉得不仅需要有训练的环境，还需要真正了解这个环境。

关于环境，我说的是 Apache 支持的解决方案(和一些朋友):Hadoop，Spark，Hive，Postgres，Kafka 等等，安装在一个集群上。在你的桌面上，你很可能使用 Anaconda 和 Rstudio(抱歉 Anaconda，但我更喜欢单机 Rstudio)。

这是我梦寐以求的实验室，我去了。

大数据环境需要现实世界中的分布式解决方案，可扩展性是首要要求。因此，学习如何配置环境对我来说很重要。我没有选择基于云的解决方案——我想要完全的控制，对“个人实验室”没有任何限制。

首先，我已经在我的笔记本上安装了完整的解决方案，使用了三台虚拟机(在 VirtualBox 上安装了 Ubuntu 20.04)。它工作了，但是有一些缺点——性能和网络。最糟糕的是——我把我的笔记本电脑从家搬到工作的地方，在那里使用这种“虚拟网络”是不可接受的。

当我决定尝试 Raspberry 时，我打算为我的实验室购买一个强大的工作站来虚拟化集群。新的 Raspberry Pi 4 最高可配 4GB 内存。这不是一辆法拉利，但我只需要一辆小型车就能拥有范并完成工作。我读了一些关于如何用 Raspberry 组装集群的文本，用于 Hadoop + Spark 解决方案——他们用 PI 3 取得了成功。

然后我决定用三个树莓派组装自己的集群。

我对结果很满意；它起作用了，它的性能允许我进行实验。我会向学生推荐这个。

2.组装集群

第一部分将引导您组装物理集群，安装 Ubuntu server 20.04，并为集群设置环境

2.1 你需要什么？

3 个或更多覆盆子 Pi 4 4GB

1 个千兆交换机(10/100/1000)

用于给 Pi 供电的 USB-C 电缆

你的覆盆子的微型 SD 卡

网络用以太网电缆

电源(我使用带 3 个 USB 3A 端口的充电器)

集群的丙烯酸底座

集群装载 1

集群装载 2

2.1.1 关于材料的一些说明:

树莓 Pi 4 有 wifi 和千兆以太网。我选择了使用千兆交换机的有线网络进行集群通信。我还使用无线网络进行远程访问。因此，您应该使用 cat 6 电缆。

因为想玩数据，所以买了 128GB 的 SD 卡。然而，其中一张卡没有交付，我开始为第二个覆盆子(节点 pi2)使用 16GB 的卡，它工作了。购买高读写速度的优质 SD 卡对集群性能至关重要。树莓有一些扩展板，可以让你使用 2.5 HD，SSD SATA 或 NVME。我没有安装它，但你可以很容易地安装一个 NAS 或数据存储区。

我花了很多时间配置集群，发现问题和归零几乎花了三周时间。我不是一个寻求让别人遭受同样痛苦的虐待狂，所以我决定出版这个指南，希望你喜欢。

我用了这些优秀的指南作为参考，重点在第[2，3，4]:

[## 构建 Raspberry Pi Hadoop / Spark 集群

专业提示:如果您只是在寻找如何配置 Hadoop 和 Spark 在集群上运行，请从这里开始。动机和…

开发到](https://dev.to/awwsmm/building-a-raspberry-pi-hadoop-spark-cluster-8b2) [## 从头开始构建 Raspberry Pi Hadoop/Spark 集群

本文将带领您从头开始使用 Raspberry Pi 构建 Hadoop 集群的漫长过程。

medium.com](https://medium.com/analytics-vidhya/build-raspberry-pi-hadoop-spark-cluster-from-scratch-c2fa056138e0) [## 使用 Raspberry Pi 构建 Hadoop 集群——IBM 开发人员食谱

简介 Hadoop 潜力巨大，是最知名的大数据项目之一。在本教程中，我们将…

developer.ibm.com](https://developer.ibm.com/recipes/tutorials/building-a-hadoop-cluster-with-raspberry-pi/)

然而，即使按照教程，我发现了许多问题和陷阱。有些问题可能与不同的软件版本有关。

为了在阅读本文时帮助您，也为了在我需要重新安装时帮助我自己，我将所有的配置文件保存在一个与 raspberries 中存在的文件夹结构相似的文件夹结构中——小心使用(IP、服务器名称等可能会因您而异)。所有文件都是最终版本，有 Hadoop、Hive、Zookeeper、Kafka 的分布式版本(Spark 和 Postgres 安装在单节点)。

2.2 安装操作系统

首先，您应该在集群支持中组装物理设备，而不是 SD 卡。不要急于从桌子上摆满零件开始；这样容易短路，你会丢失你的素材。

我的笔记本运行 Windows 10——我没有忘记黑暗面(Linux)——我有一些 Linux 虚拟机可供选择和使用。但是我在描述教程的时候会参考 Windows 支持软件。如果你是一个只懂 Linux 的极客，我相信你知道如何用你的工具完成工作(在 Linux 中通常更容易)。

2.2.1 下载并安装 Raspberry Pi 成像仪

使用 Ubuntu 服务器创建微型 SD 卡的最佳工具是 Raspberry Pi Imager [5]。该工具适用于 Windows、Ubuntu 和 Mac，可从以下网站下载:

[## 树莓 Pi 下载-树莓 Pi 的软件

Raspberry Pi OS(以前称为 Raspbian)是我们所有型号的 Raspberry Pi 的官方操作系统。使用…

www.raspberrypi.org](https://www.raspberrypi.org/downloads/)

此实用程序将刻录原始版本的初始操作系统。

建议:我尝试使用廉价的 microSD 转 SD 适配器，通常与笔记本 SD 插槽中的 micro SD 卡一起提供。速度非常慢，我换了一个 micro-SD 转 USB 适配器，用在 USB 3.0 端口。好多了。

Raspberry Pi 4 有 AMR64 架构——之前的版本是 AMR32。因此，任何 Linux 32/64 都可以很好地安装。在我的第一次尝试中，我使用了 Raspbian(只有 32 位版本)，但我在 Hadoop 安装上遇到了问题。之后我决定用 Ubuntu 64bit 版本(Ubuntu 推荐 Pi 4)。

插入您的 SD，启动 Raspberry Pi Imager 并格式化它(我总是在安装任何操作系统之前格式化)。安装 Ubuntu server 20.04 64 位。对你所有的 PI Micro SD 卡做同样的事情。

Ubuntu 20.04 服务器是最小版本，设置为通过 DHCP 连接以太网。

注意—如果您在将 micro SD 卡安装到 Raspberry 之前将其重新插入笔记本电脑读卡器，您将可以访问安装配置文件。理论上，你可以设置你的初始用户和网络配置。网络配置文件遵循 yaml 文件的网络计划标准。然而，我试了几次，都不能正常工作，于是我决定像往常一样，通过 ssh 连接或者使用键盘和显示器。

注意——Ubuntu 安装了 vim 和 nano 编辑器。我已经习惯了 vim，但是颜色的高亮模式使得阅读变得困难——即使戴着眼镜！我用了纳米。快捷方式显示在 nano 界面的底部。

连接到网络

这是一个集群——网络至关重要。本教程假设您有一个带路由器/网关的家庭网络。

您需要访问操作系统来配置您的网络。你可以通过两种不同的方式来实现:更简单的一种是购买一个从 micro-HDMI 到 HDMI 的适配器，有线键盘，然后逐一插入你的覆盆子。您可以使用初始用户名/密码直接访问。

默认用户/密码是 ubuntu/ubuntu，首次登录时会要求您更改密码。我把密码改成了“覆盆子”。这是一个实验，避免在集群中使用真实密码。

最初连接树莓的第二种方法是依靠您的 DHCP 并连接有线网络(以太网)上的 Pi，同样是一个接一个。

当访问您的路由器管理页面时，您将可以访问连接的设备，树莓将显示为“ubuntu”。记下远程连接的 IP 地址。

因为我的有线键盘没有准时到达，所以我用宋承宪做到了。一次只启动一个 Raspberry，配置它的网络、主机名、主机和用户，然后关闭它。这将有助于识别 ssh 初始连接的动态 IP。

当您给 Pi 4 加电时，您会看到 micro SD 附近的红色和绿色 led 闪烁。红色 led 表示电源，绿色表示它正在访问您的辅助内存(micro SD)。

我的所有 Pi 都有相同的用户/密码和文件位置配置。这使得管理集群变得更加容易。

2.2.3 第一项任务是建立您的网络。

就像我之前写的，我决定设置以太网和 wifi。我这样做是因为我的集群没有直接链接到我的路由器。我有一个 wifi 网络扩展器，TP-Link RE200，它提供一个以太网端口 10/100，但提供 2.4GHz + 5.0GHz 的无线传输。因此，我的解决方案是让千兆交换机仅用于集群内通信和我使用 wifi 的远程访问。无论如何，我将扩展器(RE200)的以太网连接到交换机，以确保到集群的第二条路由—以防万一。

Ubuntu server 20.04 使用 netplan 进行网络配置。作为一份简历，你制作一个格式良好的文本文件，并要求系统解析和处理/etc/netplan 文件夹中带有 yaml 后缀的文件。然后，Netplan 会相应地更改您的网络设置。

重要—缩进必须有 4 个空格。在意识到这一点之前，我在编辑时很挣扎。

您将找到以下要编辑的文件:

/etc/net plan/50-cloud-init . YAML

我很懒，只编辑了它，但是你可以通过改变它的后缀来避免 netplan 读取它并创建一个新的。

注意——在一些安装中与我的 Pi 失去连接后，这迫使我重新安装系统(我没有 USB 键盘)，我选择首先配置 wifi 并重新启动。在确保 wifi 正常后，我将以太网从 DHCP 改为静态 IP。

您可以复制我的文件并进行相应的编辑:

/etc/net plan 50-cloud-init . YAML

编辑文件后，您需要确认更改:

ubuntu@ubuntu:/etc/netplan$ sudo netplan apply

您需要使该文件适应您的环境。通常，您只需决定集群的 IP，更改路由器 IP(网关)并配置 wifi(名称和密码)。我有 2 个 wifi 网络(2.4G + 5G)。

为了让我的生活更轻松，我保持简单:

Hostname   IP (Ethernet)     IP(wifi)  
pi1        192.168.1.11      192.162.1.21
pi2        192.168.1.12      192.162.1.22
pi3        192.168.1.13      192.162.1.23

注意—确保从路由器可用于 DHCP 连接的范围中删除您选择的范围。

一旦有了稳定的网络连接，就可以开始真正的配置了。请记住，集群使用网络连接，树莓之间的访问权限必须正常，否则您的分布式服务将会失败。

我的集群架构如图所示:

2.3 创建您的用户

您将在所有节点中创建相同的用户，使用 sudo 访问:

注意—不要使用低级的 useradd 命令！

sudo adduser pi  
sudo passwd pi
New password:
Retype new password:
passwd: password updated successfullysudo usermod -aG sudo pi 
sudo usermod -aG admin pi

usermod 命令确保sudo 访问。

作为 pi 登录，并更新您的系统！

sudo apt update
sudo apt upgrade

你会发现安装 net-tools 包很有用！它附带了 netstat ，我们将使用它来检查节点中的活动服务(端口):

sudo apt-get install net-tools

2.4 远程桌面访问

我安装了一个带有网络浏览器(chromium)和远程桌面访问(xrdp)的轻量级图形界面(xfce4)。然而，这不是真的需要，我正在考虑删除它。但是如果你是一个 GUI 爱好者，你可能会喜欢它:

为了启用远程桌面访问，您需要:

安装 xfce4 和 xrdp:

Sudo apt-get install xfce4
sudo apt-get install xrdp

并创建文件

创建文件 /home/pi/。x 会话

echo xfce4-session > /home/pi/.xsession

并编辑该文件

/etc/xrdp/startwm.sh

sudo nano /etc/xrdp/startwm.sh

在最后一行之后增加以下内容:

startxfce4

重新启动服务:

sudo service xrdp restart

xcfe4 网页浏览器坏了。我安装了铬合金:

sudo apt-get install chromium-browser

以防万一，安装 extFat 支持(这可能有助于笔驱动程序):

sudo apt install exfat-fuse

重新启动后，您应该能够使用远程桌面从任何 windows 机器远程连接。

2.5 配置主机名和主机

您需要更新主机名以及/etc 中的主机文件。参见 GitHub 中的例子。

注意—从主机文件中删除对本地主机 127.0.01 的引用。

/etc/hosts

关于主机名，我建议您使用 pi1、pi2、pi3、… piX。这是因为我所有的配置文件都考虑这些主机名。否则，您将需要非常小心地编辑它。

/etc/hostname

2.6 安装 Java

这是一个致命的弱点:

Hadoop 经过编译，在 Java8 上运行良好。我已经寻找过了，但是我没有找到来自 Java Hotspot 8 或 Oracle Java 8 的 AMR64 架构版本。经过一些实验后，我决定支持 OpenJDK8，它已经在 Ubuntu 仓库中可用，并且维护得很好(我希望如此)。

您可以在[6]中找到关于 Hadoop 和 Java 支持的信息:

[## 阿帕奇软件基金会

Apache Hadoop 3.x 现在只支持 Java 8 Apache Hadoop 从 2.7.x 到 2.x 支持 Java 7 和 8 Java 11 支持现在…

cwiki.apache.org](https://cwiki.apache.org/confluence/display/HADOOP/Hadoop+Java+Versions)

要安装 java:

sudo apt-get install openjdk-8-jdk

这是我的版本:

pi@p2:~$ java -version
openjdk version "1.8.0_252"
OpenJDK Runtime Environment (build 1.8.0_252-8u252-b09-1ubuntu1-b09)
OpenJDK 64-Bit Server VM (build 25.252-b09, mixed mode)

2.7 配置 SSH

编辑文件(参见 GitHub):

/home/pi/。ssh/config

为 ssh 创建快捷方式

为所有群集节点中的用户 pi 生成公钥/私钥对:

命令和输出，您应该期望:

pi@pi1:~$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/pi/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/pi/.ssh/id_rsa
Your public key has been saved in /home/pi/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:mKDvp5u/AsK5CxUUYdkFNSM+rSI4S4aQJR7Wd1AcPZU pi@pi1
The key's randomart image is:
+---[RSA 3072]----+
|.oB=o=Ooo ...    |
|o*oo.+ = o E     |
|o.. = o   .      |
|+  o + o         |
|*o= . o S        |
|+B.o             |
|o....            |
|.. ....          |
| .. =*o.         |

将公钥复制到授权密钥列表:

cat .ssh/id_rsa.pub  >> .ssh/authorized_keys

并复制到所有节点:

cat ~/.ssh/id_rsa.pub | ssh pi2 'cat >> .ssh/authorized_keys'
cat ~/.ssh/id_rsa.pub | ssh pi3 'cat >> .ssh/authorized_keys'

注意—您应该在每个群集节点中执行此过程。最后，所有节点的列表中都会有所有的公钥。这一点很重要——没有密钥会阻止以后的机器间通信。

注意——作为一个例子，我在 GitHub 中包含了我的 ssh/authorized_keys 。显然，你不能使用它，因为它不会工作。你需要做你的钥匙圈。

基于密码的身份验证

参考教程建议禁用基于密码的身份验证，主要是因为安全问题。我决定不采纳他们的建议，因为我想使用传统的基于密码的访问来轻松访问节点。

如果您想探索这个选项，请查看本文开头引用的前两个教程。如果你想探索这个选项，请查看本文开头提到的两个教程。

2.8 管理集群的脚本

通过在以下文件中添加以下内容，创建函数来帮助您进行集群管理:

/home/pi/。巴沙尔

运行命令:

source /home/pi/.bashrc

您必须在所有节点中执行此操作。如果您愿意，可以使用 scp 在节点之间复制。如果使用 WinSCP 远程访问，您将能够复制和粘贴——但是在命令行中使用 scp 更快，您应该学会这样做。

注意—原始教程没有 clustercmd-sudo 。我把它包括进来，因为我试验了需要超级用户访问的命令问题。

注意—这些函数假设节点的主机名是 pi1、pi2、pi3、pi4…，并且所有节点都有一个用户/密码 pi/pi。这些假设也是在 Hadoop/Spark/Zookeeper/Kafka/Postgres 配置下做出的。如果您选择了不同的名称，那么您需要仔细检查每一行。

2.9 时间同步

通常，我用 UTC 时间服务器同步我所有的机器。在集群中，这一点更加重要。

pi@p2:~$ clustercmd date
Fri May 29 21:09:59 UTC 2020
Fri May 29 21:09:57 UTC 2020
Fri May 29 21:10:02 UTC 2020

好吧，我作弊了。我的集群已经同步了，我插入了时差编辑。但是你的集群可能有差异。

运行以下命令:

clustercmd-sudo apt install htpdate -yclustercmd-sudo htpdate -a -l [www.pool.ntp.org](http://www.pool.ntp.org)

后一个命令使用 htpdate 将节点时钟与www.pool.ntp.org 同步。

然后

[## 数据科学/大数据实验室—第 2 部分，共 4 部分:3 节点集群中的 Hadoop 和 Spark over Ubuntu

使用 Hadoop、Spark、Hive、Kafka 在 Raspberry Pi 4 或 VMs 集群中组建数据科学/大数据实验室…

towardsdatascience.com](/assembling-a-personal-data-science-big-data-laboratory-in-a-raspberry-pi-4-or-vms-cluster-e4c5a0473025)

[1] P. G .塔兰蒂。https://github.com/ptaranti/RaspberryPiCluster

[2]华生。构建一个 Raspberry Pi Hadoop / Spark 集群 (2019)

[3]梁伟雄。从零开始构建 Raspberry Pi Hadoop/Spark 集群 (2019)

[4]弗杜戈。使用 Raspberry Pi 构建 Hadoop 集群:使用单板计算机安装、配置和测试分布式存储和处理集群 (2017)

[5] G .霍林沃思。介绍 Raspberry Pi 成像仪，我们的新型成像工具 (2020)

[6] A. Ajisaka。 Hadoop Java 版本 (2020)

R 语言中的断言编程

原文：https://towardsdatascience.com/assertive-programming-in-r-36c3cc290930?source=collection_archive---------51-----------------------

您的代码应该按预期工作，否则会立即失败

您可能熟悉使用 testthat 包的单元测试。单元测试的目标是检查你的功能是否被正确开发。断言检查你的函数是否被正确使用。

单元测试是为开发人员准备的，并根据命令执行。
断言是针对用户的，并且在每次函数调用时执行。

照片由 chuttersnap 在 Unsplash 上拍摄

快速失败

运行时测试，通常称为断言，是一小段代码，用于检查条件，如果条件不满足，测试就会失败。断言使你的代码能够快速失败——这是一件好事。当某个东西出错时，我们不希望我们的程序继续运行，直到错误复合并暴露出来。相反，我们希望程序在错误的源头立即失败，并给出清晰准确的错误消息。

本文的目标是让你的 R 函数快速失效。假设你的函数没有错误或者副作用，错误进入你的函数的唯一途径就是通过它的输入。在本文中，您将学习如何使用断言来识别不良输入并警告用户(包括未来的您)。

输入有两种不好的方式:

  1. 功能输入包含错误。R 发现了一些错误:从不可能或丢失的值到十进制数中逗号和点的不一致使用。其他错误更加隐蔽。想想无效的信用卡号或不存在的邮政编码和糟糕的电子邮件格式。
  2. 你在开发你的功能时考虑了一个特殊的用例。你无法想象用户试图使用你的代码的所有方式。他或她可能以技术上正确的输入使用你的功能，但不是以预期的方式。你试过用sort.list(list(2, 1, 3))排序列表吗？

为什么 R 包“自信”

r 有几个用于编写断言的包。这篇文章提倡 R 包自信有三个原因:

  1. 该软件包为许多不同的情况提供了大量的功能
  2. 它的功能非常容易阅读

assert_all_are_positive(c(1, -2, 3))

3.并提供信息丰富的错误消息

Error: is_positive : c(1, -2, 3) contains non-positive values.
There was 1 failure:
 Position Value Cause
1 2 -2 too low

直接从起重机安装软件包，并将其加载到您的 R 会话中:

install.packages("assertive")

library(assertive)

写你的第一个断言

假设您编写了一个对数值向量的元素求和的函数:

add_numbers <- function(numbers) {
  result <- sum(numbers)
  return(result)
}

向量的值可以是任何数字。让我们在函数的开头写一个断言来检查我们的输入向量:

add_numbers <- function(numbers) {
 **assert_is_numeric(numbers)**
  result <- sum(numbers)
  return(result)
}add_numbers(c(1, 2, 2, 3)) # pass

注意断言是写在函数内部的。这意味着它总是在那里，等待每次调用函数时被执行。检查一个断言只需要几毫秒的时间，这对于除了对性能要求最高的应用程序之外的所有应用程序来说都没问题。

检查多个条件

假设您修改了函数，期望得到一个唯一的值的向量。现在你需要两个断言:

  1. 一个用于检查向量是否为数字
  2. 另一个检查向量没有重复值

您可以通过用来自magritter包的转发管道 %>%链接两个或更多断言来保持代码的可读性:

library(magrittr)add_unique_numbers <- function(input_vector) {
 **input_vector %>% 
    assert_is_numeric %>%
    assert_has_no_duplicates** result <- sum(input_vector)
  return(result)
}add_unique_numbers(c(1.5, 2, 2, 3)) # fail

有很多断言函数，适用于各种情况。全部背下来不太实际。只需在 CRAN 上搜索包文档就能找到适合你特定需求的功能。

让我们用一个练习来试试这个。下面的函数需要百分比值的向量，例如percentages <- c(64, 55, 97, 85)，并计算平均百分比。你能在 assertive 包中找到合适的断言吗？

calculate_mean_percentage <- function(percentages) {
 **# ... your assertion goes here**    result <- mean(percentages)
    return(result)
}

提示:在你的 R 控制台中编写 ls("package:assertive", pattern = "percent") 来搜索 assertive 中名称与“百分比”匹配的函数。

断言和谓词

您可能会在这里看到一种模式。所有断言都由三部分组成:

  1. 他们总是以assert_开头
  2. 后跟谓语is_或has_
  3. 并以期望结束，例如numeric

当检查对象的单个元素而不是对象本身时，谓词is_在中变为all_are_或any_are_。例如，下面的断言检查传递给函数的所有数字是否都是整数:

add_whole_numbers <- function(whole_numbers) {
 **assert_all_are_whole_numbers(whole_numbers)**
  result <- sum(whole_numbers)
  return(result)
}add_unique_numbers(c(1.5, 2, 2, 3)) # fail

除了核对数字

到目前为止，我们只处理了数字。但是断言包包含了各种情况下的断言。为了说明这一点，我们将用一些检查文本、日期甚至主机操作系统的例子来结束我们的讨论。

  • 你的函数需要一个人名向量吗？
    检查缺失或空字符串:

assert_all_are_non_missing_nor_empty_character()

  • 有一个只在 Windows 上工作的功能？然后确保用户正在运行 Windows:

assert_is_windows()

  • 你的函数期望一个人的出生日期吗？
    确定事情已经过去:

assert_is_in_past()

结论

在本文中，您学习了如何使用 assertive 包编写断言。多亏了断言，你的函数将做它们应该做的事情，或者快速失败，并给出一个清晰的错误消息。

参考文献

棉花理查德。(2017).测试 R 代码(第一版)。查普曼&霍尔。

亨特安德鲁。托马斯戴夫。(1999).《实用程序员》(第 25 版，2010 年 2 月)。爱迪生韦斯利朗曼公司。

用程序生成的游戏评估奖励学习中的概括(2/2)

原文：https://towardsdatascience.com/assessing-generalization-in-reward-learning-implementations-and-experiments-de02e1d08c0e?source=collection_archive---------56-----------------------

奖励学习中的泛化

在 OpenAI Procgen 基准游戏上实现 T-REX 奖励学习算法

作者:安东·马基耶夫斯基，周亮，马克斯·奇西克

注:这是 第二个两个 博文(部分 一个 )。在这些帖子中，我们描述了一个项目，该项目旨在评估奖励学习代理的概括能力。这个项目的实现是 GitHub 上可用的。

在第一篇文章中，我们回顾了一些基本的背景材料，并描述了我们项目的灵感和目标。在此过程中，我们讨论了一些作为我们实验出发点的论文。

****我们的实现基于 T-REX【Brown and Goo et al . 2019】。我们选择它是因为它的简单设置，以及作者提供的开源实现，这将节省我们大量的时间。根据这篇论文，该算法在 Atari 游戏上显示了强大的结果，因此我们想评估这些结果在 Procgen 环境中的表现如何，在 proc gen 环境中，级别将随机生成，因此无法记忆。

我们在四个 Procgen 游戏环境中运行了 T-REX 算法:CoinRun、FruitBot、StarPilot 和 BigFish。简单回顾一下:该算法应该学会在不访问游戏分数的情况下玩好游戏。游戏目标必须从所提供的一组分级演示和奖励模型的结果预测中仅推断出。****

这些是我们实现的算法步骤:

奖励学习算法步骤(图片由作者提供)

创建我们的演示数据集

为了训练任何东西，我们需要一个数据集。对于 T-REX，数据集由来自环境的分级演示组成。他们有多少人？在 T-REX 的论文中，作者仅用 12 个排名演示就能够在 Atari 上获得良好的结果。然而，我们怀疑我们将需要更多，因为我们相信 Procgen 环境可能会因为固有的随机等级而更难学习。

无论哪种方式，我们都需要从我们想要测试的四个 Procgen 环境中产生不同质量的演示。为此，我们可以自己玩游戏，也可以在这些环境中训练强化学习代理，利用实际环境本身提供的真正回报。

我们选择了后者；与手动方法相比，拥有训练有素的代理可以让我们以快几百倍的速度生成演示。当奖励学习的目的是在没有得到信息的情况下学习时，为什么使用真正的奖励是“合法”的？在训练期间，算法只能访问演示，而不能访问演示获得的奖励。

幸运的是，Procgen 的论文附带了代码，我们可以使用这些代码来训练许多代理人达到不同程度的性能。即使有这样的速度，每次生成“新鲜的”演示仍然需要在每次实验开始时等待几分钟。这将大大降低我们迭代和改进代码的效率，因此我们决定在运行任何实验之前生成所有的演示——每个环境数千个演示，并根据获得的总回报对它们进行排序

通过这种方式，我们为任何环境、任何质量、任何长度的演示创建了一个健壮的源，无论何时我们想要它们。

我们的第一个奖励模型

现在我们有了演示数据集，是时候用霸王龙的程序来训练我们的第一个奖励模型了。

为了评估奖励模型的质量，我们可以使用强化学习算法来训练代理，并评估代理的表现，但这在计算上是昂贵的。因此，我们寻找一个临时指标，通过它我们可以检验我们的训练的奖励模型与真实的奖励模型有多接近。我们决定使用一个简单的衡量标准，即相关系数。对于奖励模型来说，这个临时指标可能是一个不太可靠的衡量标准。然而，引入这一指标将每次实验花费的时间减少了大约 5 倍，使我们能够获得更多的数据点来评估算法。然后，我们将选择最佳回报模型，并对其运行 RL 算法，而不是必须对所有模型运行 RL 算法。****

我们的目标是在训练奖励模型和真实环境奖励模型之间的环境事件上具有高相关性，这意味着训练奖励模型类似于真实(目标)模型。对于我们选择的四个环境中的每一个，我们都进行了测试，改变了提供给 T-REX 的演示次数。我们测量了奖励模型预测的游戏总奖励与游戏中收集的实际奖励之间的相关性。

看看我们的第一个结果:

**在 Procgen 游戏中，不同演示次数的真实奖励和预测奖励之间的相关性(图片由作者提供)

x 轴是实验中使用的演示次数，y 轴是相关系数。我们用橙色和蓝色线条向展示了两种不同类型的相关性。图中的每个大点代表每批演示中 5 次不同运行的平均结果，由较小的点代表。

我们从该图中得出三个主要观察结果:

  1. 除了 CoinRun 之外，所有游戏的相关性看起来都很强。
  2. 这种相关性随着演示次数的增加而增加。正如我们所猜测的，在更复杂的 Procgen 环境中，12 个演示是不够的。从 100 到 200 个演示，相关性相当稳定和高。
  3. 当我们进行到 100 到 200 个演示时，运行的方差显著降低。我们看到，随着演示数量的增加，代表运行的小点越来越靠近。

我们的下一步是使用我们的奖励模型在 Procgen 上训练强化学习代理，该模型显示了最高的相关性，而不是来自环境的真实奖励。这是我们得到的信息:

**根据我们的一个奖励模型(图片由作者提供)在星际飞行员中训练 RL 特工

**根据我们的一个奖励模型(图片由作者提供)训练 FruitBot 中的 RL 代理

有点不对劲

剪辑通常看起来很好，但有些东西是关闭的。如果你看看 FruitBot，你会发现尽管我们训练有素的代理已经学会了不要撞墙，但它还没有学会如何避免非水果物品，这些物品共同构成了游戏对象的一半。回想一下，游戏中的任务是生存，同时尽可能多吃水果，避免所有其他食物。理想的代理应该是这样的:

最佳水果机器人代理使用 RL 训练游戏环境的真实奖励(图片由作者提供)

我们推测，我们训练有素的特工主要是在学习如何在中生存，也就是说，尽可能长时间地保持这一集(优化所谓的“长寿”目标)。生存直接导致奖励的环境的一个例子是掷竿子(在之前的博客文章中显示)，代理人每阻止一根竿子倒下一秒钟就获得+1 的奖励。在 FruitBot 中，到达最后一关会得到一大笔奖励，所以也许代理人已经知道了这一点的重要性，但不知道避开非水果的重要性。**

不过，在下结论之前，我们想做一些进一步的测试。我们意识到，这个“长期存在”的目标非常有意义，可以用作比较我们一般奖励模型的基线——换句话说，在 Procgen 环境中训练的好的奖励模型应该比简单的奖励模型做得更好，简单的奖励模型为代理活着的每个时间步长返回+1 奖励，就像在 CartPole 中一样。通过使用这样的基线，我们将对此进行测试。所以我们做了一些对比。

下面我们展示了与上面相同的相关图，但是现在有了实时基线(用红色虚线表示)，显示我们的回报模型通常表现稍差或接近基线，即使有 100 和 200 次演示！CoinRun 是一个例外，因为基线本身的相关性很差。

**在 Procgen 游戏中，不同数量的演示的真实和预测奖励之间的奖励相关性具有长期基线。所有游戏中使用两种相关类型的基线大致相同，所以我们用一条平均线来代表它们。(图片作者提供)

虽然学习奖励模型和真实奖励模型之间超过 75%的相关性看起来相当强，但高寿命基线相关性是令人担忧的，因为它们表明可能有一个实际上与环境无关的高度相关的奖励模型！

怎么办？

深度强化学习很棘手。正如我们在上一节中看到的，看起来令人鼓舞的结果在仔细观察后可能并不那么好。我们把精力集中在 FruitBot 上，这是问题最突出的地方，我们观察了真实的和预测的奖励在各个情节中是如何变化的:

**使用单一奖励模型在 6 个不同的 FruitBot 等级中的真实与预测累积奖励(图片由作者提供)

每张图显示了一个代理在不同级别中的真实(绿色)和预测(橙色)回报。x 轴是该集的时间步长，y 轴是到该时间步长为止获得的累积奖励。在 FruitBot 中，如果一集达到 420 个时间步，该集将自动结束，代理人将获得一大笔奖励(由结尾附近的绿色尖峰指示)。理想情况下，绿色和橙色的线看起来非常相似，因为习得的奖励应该与环境的真实奖励相似。

不幸的是，他们不是。事实上，除了接近尾声时的峰值之外，预测的和真实的回报似乎彼此毫无关联。这是怎么回事？

我们在代码中寻找错误，并尝试了几种方法来改进我们的奖励模型。在不涉及太多细节的情况下，我们尝试了标准的可靠方法来“按摩”我们的训练程序，包括诸如提前停止和正规化等元素，以及改变奖励模型的神经网络架构。

然而，这些变化似乎没有产生任何显著的差异，如这些更新的图表所示:

**在尝试改进我们的训练程序以创建更好的奖励模型后，使用单一奖励模型在 6 个不同的水果机器人级别中比较真实和预测的累积奖励(图片由作者提供)

接下来，我们决定简化实际任务。如果代理可以在简化版本中学习，那么我们将逐渐增加任务的难度，以找出是哪些特定元素导致了问题。我们知道 Brown 等人的论文中的算法在 Atari 游戏上只有 12 个演示，并试图在 Procgen 中使任务至少一样简单。

首先，我们将修改 Procgen，使游戏关卡按照固定顺序进行，而不是随机顺序。这就是雅达利游戏的工作方式，这使得代理人更容易学习。

此外，我们将远远不止使用 12 次演示，而是在 T-REX 算法中使用 150 次演示来提供更多的学习数据。这应该会导致更精确的奖励模型。然而，即使在这些修改之后，水果机器人的奖励模式还是不令人满意。

**在通过更多演示和连续关卡简化我们的训练程序后，使用单一奖励模型，在 6 个不同的 FruitBot 关卡中的真实与预测累积奖励(图片由作者提供)

在这一点上，我们确信我们做错了一些的事情，因为看起来我们修改后的任务至少和褐皮书中的任务一样简单，在褐皮书中 T-REX 算法训练了成功的代理。**

回到源头

在即使在简化的环境下也无法产生好的奖励模型之后，我们决定更仔细地研究最初的实现和作者报告的结果，以准确地指出我们的分歧所在。因为作者最初编写算法是为了在 Atari 上工作，所以我们无法进行直接比较。然而，我们可以看看他们提供的奖励模型与我们之前建立的长期基线相比如何。因此，我们从雅达利游戏《太空入侵者》中选取了一个经过霸王龙训练的奖励模型，并检查了它的预测奖励与环境给出的真实奖励之间的比较:**

**雅达利游戏《太空入侵者》中真实与预测的累积奖励为了了解这个情节在最初的 T-REX 文件实现中是如何表现的(图片由作者提供)

红线应该看起来像绿线，但它们非常不同，就像我们在早期的水果机器人游戏中看到的那样。看起来代理人正在学习一个恒定的正奖励，类似于长期基线。

经过进一步的研究，我们注意到，在论文作者提供的实现中，原始 T-REX 算法的输出是通过 sigmoid 函数传递的，该函数将预测的奖励值限制在 0 到 1 之间。

s 形函数图( 来源 )

我们怀疑这将使奖励模型偏向终生方法，因为给予小的、持续的积极奖励是容易的。

我们联系了丹尼尔·布朗，T-REX 论文的主要作者，讨论这些问题，他非常积极地回答我们的问题，并帮助我们排除可能的问题。事实证明，他自己也考虑过这个问题，甚至在他后来的一篇论文中进行了相关实验——他用霸王龙奖励模型和长期目标训练了代理人，并报告了他们的表现对比。根据报告的结果，T-REX 算法实际上产生了一个有意义的模型，其表现优于基线。

我们决定自己进行相应的实验。正如我们之前提到的，由于计算限制，我们无法运行我们想要的那么多“完整”测试，所以我们只在最简单的(顺序)模式下为 FruitBot 环境运行了实验。

**训练有素的代理人在 FruitBot 中获得的平均总奖励，带有红色长期基线的连续等级(图片由作者提供)

如你所见，在我们的实验中，我们找不到比那些在长期客观基线上训练过的人表现更好的代理人。公平地说，对于 T-REX 算法来说，水果机器人是一个艰难的游戏，在其他游戏中，我们有时会得到超越基线的代理，但很少如此。

我们不是经验丰富的深度强化学习研究人员，我们的结论可能是错误的，但对我们来说，T-REX 算法似乎以相当小的幅度击败了基线。我们计划看看如果我们引入 Procgen 水平的随机性，这种差异会如何变化，并且考虑到我们开始时与基线的接近程度，这种差异将很难发现。

包扎

经过相当长时间的讨论，我们决定最好从 T-REX 开始，尝试另一种奖励学习算法。毕竟，我们项目的最初灵感并不是霸王龙独有的——我们想从总体上研究奖励学习算法。我们最初选择霸王龙是因为它似乎最容易实现，也最容易操作；然而，回想起来，尝试使用更成熟的奖励学习方法可能会更好，特别是因为我们将该算法应用于更困难的设置。最值得注意的是，这表明实施了 Christiano 等人 2017 年的代码(在 post one 中讨论过)，该代码通常被认为是一项重要的结果，有助于启动奖励学习在深度强化学习中的使用。

尽管 GitHub 上有这篇文章中的算法实现，但是没有一个能够很容易地集成到我们的项目中。因此，最简单的前进方式是从头开始重新实现。

反射

最初，我们感兴趣的是解决测量奖励学习代理概括能力的问题。我们认为这是一个重要的问题，因为为了让一个智能体实际部署在现实世界中，它需要能够在看不见的情况下稳健地机动。以前的泛化测试仅限于标准的强化学习算法，我们希望通过应用相同的工具(如 Procgen)来奖励学习，从而帮助弥合这一差距。

简而言之，我们发现我们所学的回报函数相当脆弱。在许多不同的 Procgen 环境和许多不同的参数设置下训练了许多奖励学习代理之后，我们无法获得可用于进一步稳健地训练新代理的奖励函数。我们对神经网络架构进行了实验，但这很困难，因为除了直觉之外，几乎没有指导我们探索的原则。我们尝试了一些经典的改变——增加卷积层，改变滤波器大小，改变损失函数来预测多个步骤等。—并获得了中等的结果，有时比我们已经有的要好，但没有我们希望的那么好。

与任何深度学习项目一样，网络性能可能会受到架构或训练程序的精确变化的影响。尽管我们试图尽可能好地复制 T-REX 论文中发现的方法，但总有一些参数设置会产生良好的奖励函数，这是可行的。

外卖食品

虽然我们的项目不幸没有带来有趣的结果，但我们获得了宝贵的经验和重要的教训，其中一些我们想分享:

  1. 写下你在整个项目中的进展和计划——写下你的想法可以理清你的思路。如果我们仔细考虑接下来的实验，我们会节省很多时间。尽快落地很有诱惑力，但实际上，它并不像看起来那样富有成效。
  2. 从既定的算法开始。重要的是获得有效的结果，然后优化实施！
  3. 尽早建立基线——我们已经听了无数次了，但是仍然没有像我们应该做的那样早。我们本可以更早发现主要问题。
  4. 不要羞于向别人寻求帮助(如果你已经完成了你的工作)。我们并不建议给人们发电子邮件来询问你可以在几分钟内搜索到的问题。但是如果你的研究是基于某篇论文，并且取得了有趣的进展，或者对之前报道的结果有一致的担忧，你当然应该尝试联系作者。在项目过程中，我们与许多导师和其他与我们项目相关的研究人员进行了交流，包括丹尼尔·布朗、简·雷科和亚当·格里夫等人。我们通过人工智能安全营被介绍给他们中的一些人，但我们也只是简单地给其他人发邮件。他们都非常友好，对我们的问题给予了周到而详细的回答。我们非常感谢他们的帮助。

这总结了我们的旅程，它的结果和经验教训。我们希望每一个有抱负的研究人员都有机会体验我们在这个项目中所做的一切，我们非常感谢让这一切成为可能的人们。

用程序生成的游戏评估奖励学习中的概括(1/2)

原文：https://towardsdatascience.com/assessing-generalization-in-reward-learning-intro-and-background-da6c99d9e48?source=collection_archive---------48-----------------------

奖励学习中的泛化

强化学习、概括和奖励学习概述

作者:安东·马基耶夫斯基、周亮、马克斯·奇西克

注:这是 第一篇两篇 的博文(部分 两篇 )。在这些帖子中，我们描述了一个项目，该项目旨在评估奖励学习代理的概括能力。这个项目的实现是 GitHub 上可用的。

这第一篇文章将提供强化学习、奖励学习和概括的背景，并总结我们项目的主要目标和灵感。如果你有必要的技术背景，可以跳过前几节。

关于我们

我们是参加 2020 人工智能安全营 (AISC)的团队，这是一个早期职业研究人员就人工智能安全相关的研究提案进行合作的计划。简而言之，AI 安全是一个旨在确保随着 AI 的不断发展，它不会伤害人类的领域。

鉴于我们团队在人工智能技术安全和强化学习方面的共同兴趣，我们很高兴能在这个项目上合作。这个想法最初是由另一位 AISC 参与者 Sam Clarke 提出的，我们在夏令营期间与他进行了富有成效的交谈。

强化学习

在强化学习(RL)中，一个主体以获得奖励为目标与一个环境进行交互。最终，代理想要学习一种策略，以便随着时间的推移获得最大的回报。不过，首先要做的是:代理人到底是什么，报酬是什么？一个智能体是一个通过采取行动与某个世界互动的角色，也称为环境 、。例如，代理可以是玩视频游戏的角色、自动驾驶汽车模拟中的汽车或扑克游戏中的玩家。奖励只是代表代理人目标的数字，不管代理人的遭遇是否更好。例如，捡起一枚硬币可能给予积极的奖励，而被敌人击中则给予消极的奖励。

在 RL 中，状态代表环境中当前情况的一切。然而，代理实际上能看到的是一个观察。例如，在扑克游戏中，观察可能是代理自己的牌和对手以前的动作，而状态还包括对手的牌和一副牌中的牌的顺序(即代理看不到的东西)。在一些像象棋这样没有隐藏信息的环境中，状态和观察是一样的。

给定观察结果，代理采取动作。每次行动后，代理将从环境中获得以下形式的反馈:

  1. ****奖励:标量值，可以是正、零、负
  2. ****新观察:从先前的状态采取动作的结果，这将代理移动到新的状态并产生这个新观察。(此外，新状态是否为“终止”，意味着当前交互是已结束还是仍在进行中。比如完成一个关卡或者被对手吃掉会终止很多游戏。)

在 RL 中，我们的目标是通过使用奖励作为反馈来训练代理真正擅长一项任务。通过许多可能的训练算法之一，代理逐渐学习一种策略(也称为策略)，该策略定义了代理在任何状态下应该采取什么行动来最大化回报。目标是在整个情节中最大化奖励，这是一个代理从交互开始到结束状态所经历的一系列状态。

巨大成功的代理人被训练成在诸如 Atari 和 Go 游戏中有超人的表现。

强化学习过程(图片由作者提供)

以视频游戏 Mario 为例，让我们看看一个示例算法是如何工作的。假设马里奥右边有一个敌人，左边有一个蘑菇，上面什么都没有(见下图)。在这三个行动选项中，如果向左，他可能得到+2 的奖励，如果向右，他可能得到-10 的奖励，如果向上，他可能得到 0 的奖励。马里奥采取行动后，他将处于一个新的状态，有新的观察，并根据他的行动获得奖励。然后就是下一个动作的时候了，过程继续。回想一下，目的是最大化整个情节的回报，在这种情况下，这是从游戏开始到马里奥一生中的一系列状态。

马里奥学习吃蘑菇(图片由作者提供)

算法第一次看到这种情况时，它可能会随机选择一个选项，因为它还不了解可用操作的后果。随着它越来越多地看到这种情况，它会从经验中了解到，在像这些情况下，向右走不好，向上走可以，向左走最好。我们不会直接教狗如何捡球，但通过给予奖励，狗会通过强化来学习。同样，马里奥的行动也因经验反馈而得到加强，即蘑菇是好的，而敌人不是。

算法是如何实现回报最大化的？不同的 RL 算法以不同的方式工作，但人们可能会跟踪从这个位置采取每个动作的结果，并且下次 Mario 在这个相同的位置时，他会根据先前的结果选择预期最有回报的动作。许多算法大多数时候选择最佳行动，但有时也会随机选择，以确保它们探索所有选项。(注意，在开始时，代理通常随机行动，因为它还没有了解任何关于环境的信息。)

重要的是要不断探索所有的选择，以确保代理不会找到合适的东西，然后永远坚持下去，可能会忽略更好的选择。在马里奥游戏中，如果马里奥第一次试着向右走，看到它是-10，然后试着向上走，看到它是 0，从那一点开始总是向上走就不好了。这将错过尚未探索的左转+2 奖励。

想象一下，你试着在家做饭，但不喜欢食物，然后去麦当劳吃了一顿美妙的饭。你发现去麦当劳是一个很好的“行动”，但如果你一直在麦当劳吃饭，而不去尝试其他可能最终会提供更好“回报”的餐厅，那将是一种耻辱(而且对健康没有好处)。

一般化

RL 经常用在像雅达利这样的游戏设定中。在 Atari 游戏(类似于马里奥风格的游戏)中使用 RL 的一个问题是这些游戏的序列性质。赢得一关后，你进入下一关，并继续以同样的顺序通过关卡。算法可能只是简单地记住每一关发生的事情，然后在面对游戏中最微小的变化时悲惨地失败。这意味着算法可能实际上并不理解游戏，而是学习记忆一系列按钮，从而为特定级别带来高额奖励。一个更好的算法，而不是学习记忆一系列按钮按压，能够“理解”游戏的结构，从而能够适应看不见的情况，或者说概括。

成功的概括意味着在以前没有见过的情况下表现出色。如果你知道 22 = 4，23 = 6，24 = 8，然后可以算出 26 = 12，这意味着你能够“理解”乘法，而不仅仅是记住等式。

雅达利突破(来源)

让我们看一个在垃圾邮件过滤器环境中的一般化例子。这些方法通常通过收集那些将收件箱中的邮件标记为垃圾邮件的用户的数据来工作。如果一群人将“用这一招每天赚 800 美元”的邮件标记为垃圾邮件，那么该算法将在未来学习阻止所有电子邮件用户的所有这些邮件。但是，如果垃圾邮件发送者注意到他的电子邮件被阻止，并决定智取过滤器呢？第二天，他可能会发送一条新消息，“用这另一个技巧每天赚 900 美元”。仅记忆的算法将无法捕捉到这一点，因为它只是记忆要阻止的确切消息，而不是学习一般的垃圾邮件。概括算法将学习模式，并有效地理解垃圾邮件的构成。

奖励学习

游戏通常有非常明确的内置奖励。在像二十一点这样的纸牌游戏中，奖励对应于代理每手牌赢或输的多少。在 雅达利中，奖励依赖于游戏，但有明确的规定，比如击败敌人或完成关卡可以获得积分，被击中或死亡可以失去积分。

下图来自一个名为 CartPole 的经典强化学习环境，目标是让杆子在轨道上保持直立，杆子保持直立的每一秒提供+1 的奖励。代理人将车向左或向右移动，试图保持杆子平衡，保持平衡的时间越长，获得的+1 奖励就越多。

扁担(来源)

****然而，现实世界中的许多任务并没有如此明确定义的奖励，这导致了强化学习的可能应用受到限制。这个问题因这样一个事实而变得更加复杂:即使不是不可能，也很难详细说明明确定义的奖励。人类可以在训练期间向 RL 代理提供直接反馈，但是这将需要太多的人类时间。

一种被称为逆向强化学习的方法包括从演示中“逆向工程”出一个奖励函数。对于复杂的任务，从演示中找出奖励函数是很难做好的。

*奖励学习*涉及学习奖励函数，该函数描述了在环境中的每种情况下获得多少奖励，即当前状态和动作到所接收奖励的映射。目标是学习鼓励期望行为的奖励功能。为了训练算法来学习奖励函数，我们需要另一个数据源，例如成功执行任务的演示。奖励函数输出每个状态的奖励预测，之后标准 RL 算法可用于通过简单地用这些近似奖励代替通常已知的奖励来学习策略。

用奖励函数代替已知奖励的强化学习过程(图片由作者提供)

先前的工作(下文描述为 Christiano 等人 2017 年)提供了一个例子，说明学习奖励函数有多困难。想象一下教一个机器人做后空翻。如果你不是一个认真的体操运动员，自己演示如何成功完成这项任务将是一个挑战。人们可以尝试设计一个代理可以学习的奖励函数，但是这种方法经常成为非理想奖励设计和奖励黑客攻击的牺牲品。打赏黑客是指代理商可以在打赏规范中找到“漏洞”。例如，如果我们给后空翻正确的初始姿势分配了太多的奖励，那么代理人可能会学会永远重复地进入那个弯腰姿势。它会根据我们给它的奖励函数最大化奖励，但实际上不会做我们想要做的！

人类可以通过在每一步人工输入奖励函数来监督代理学习的每一步，但这将非常耗时和乏味。

指定奖励的困难指向了更大的人-人工智能协调问题，即人类希望人工智能系统符合他们的意图和价值观，但指定我们实际上想要的东西可能会令人惊讶地困难(回想一下每个精灵故事的结局！).

相关文件

我们想看看最近的几种奖励学习算法，以评估它们学习奖励的能力。我们特别感兴趣的是，当面对以前看不见的环境或游戏关卡时，算法有多成功，这测试了它们的概括能力。

为此，我们利用了大量先前的工作:

  1. 基于人类偏好的深度强化学习—Christiano 等人 2017。
  2. 奖励从人类偏好中学习，在雅达利 — 2018 由 Ibarz 等人提出。
  3. 利用过程化生成对强化学习进行基准测试—Cobbe 等人 2019。
  4. 从 Brown，Goo 等人的观察值 — 2019，通过逆向强化学习外推超过次优演示。

前两篇论文在利用奖励学习和深度强化学习方面很有影响力，第三篇介绍了 OpenAI Procgen 基准测试，这是一组用于测试算法泛化的有用游戏。第四篇论文提出了前两篇论文方法的有效替代方案。

从人类偏好进行深度强化学习(Christiano 等人，2017 年)

这篇文章的中心思想是识别一个好的后空翻比做一个好的后空翻要容易得多。该论文表明，对于我们只能识别出想要的行为的任务，即使我们无法演示，也可以学习预测的奖励函数。

提议的算法如下所示。它在通过人类偏好学习奖励函数和学习策略之间交替，这两者最初都是随机的。

重复直到代理牛逼:

1。展示两个简短的视频剪辑，展示代理在其当前策略的环境中行动

2。问一个人在哪个视频片段中代理更好

3。根据人类的反馈更新奖励函数

4。基于新的奖励函数更新策略

模拟机器人(如下图所示)被训练在一小时内完成 900 个查询的后空翻，这是一项很难演示或手动创建奖励的任务。

根据人类喜好训练后空翻动作(来源

实验在名为 MuJoCo 的物理模拟器和 Atari 游戏中进行。既然我们已经知道雅达利游戏的真正回报，为什么还要在雅达利进行这些实验呢？这提供了自动分配偏好的机会，而不是让人手动给出关于两个视频剪辑演示的反馈。我们可以通过简单地将具有更高真实奖励的剪辑排列为更好的剪辑来获得自动(合成)反馈。这使我们能够非常快速地进行实验，因为不需要人工。此外，在这种情况下，我们可以通过比较学习到的奖励函数和游戏中给出的真实奖励来评估算法的性能。

运动中的后空翻(来源

奖励从人类偏好和 Atari 演示中学习(Ibarz 等人，2018 年)

本文建立在前一篇论文的基础上，在 Atari 域中使用不同的设置和不同的 RL 算法进行了额外的实验。他们的主要创新是在开始时利用人类演示，以便开始一个体面的策略，而原始算法将不得不从一个完全随机行动的代理开始，因为在开始时不知道奖励。相对于 Christiano 使用的无演示方法，这些人类演示的加入在九个测试的雅达利游戏中的三个中显著提高了学习。

利用程序生成对强化学习进行基准测试(Cobbe 等人，2019 年)

人工智能研究实验室 OpenAI 开发了名为 Procgen Benchmark 的强化学习测试床游戏环境，其中包括 16 款独特的游戏。在每个游戏中，所有关卡都是相似的，有着相同的目标，但是实际的组成部分，如敌人和危险的位置是随机生成的，因此在每个关卡中会有所不同。

这意味着我们可以在许多随机水平上训练我们的代理，然后在全新的水平上测试它，允许我们了解代理是否能够概括它的学习。请注意与雅达利游戏的对比，在雅达利游戏中，训练是在连续的游戏级别上进行的，敌人、奖励和游戏对象总是在同一个地方。此外，当在连续的和非随机生成的游戏中测试代理的能力时，它们以相同的顺序在相同的水平上被测试。一个重要的机器学习原理是，用一组数据训练，用另一组数据测试，真正评估智能体的学习/概括能力。

我们在工作中主要考察了 Procgen 的四种环境:

  1. 躲避敌人的同时，在关卡结束时收集硬币
  2. 水果机器人:吃水果，避免非水果食物，如鸡蛋和冰淇淋
  3. ****星际飞行员:侧面滚动射击游戏
  4. ****大鱼:从小鱼开始，吃其他更小的鱼，变得更大

下面是每个游戏的截图。代理视图使用较低的分辨率来优化算法，以减少计算量。人类视角是指如果人类在玩游戏，游戏会是什么样子。

带有代理视图的 CoinRun、FruitBot、StarPilot 和 BigFish(图片由作者提供)

人类视角的 CoinRun、FruitBot、StarPilot 和 BigFish(图片由作者提供)

论文中的主要实验涉及在所有 16 个独特的游戏中训练代理，每个游戏的训练水平在 100 到 100，000 的范围内，同时保持训练时间固定。然后，这些代理在他们从未玩过的关卡上接受测试(这是可能的，因为每个关卡都是自动生成的)。他们发现，代理人需要在多达 10，000 个游戏级别(培训级别)上接受培训，才能在测试级别上表现良好。

下面的 StarPilot 游戏图用蓝色显示训练性能，用红色显示测试性能。y 轴是奖励，x 轴是用于训练的等级数。请注意，x 轴是对数刻度。

星际飞行员训练(蓝色)和测试(红色)(来源

我们看到代理在培训期间表现非常好，然后培训绩效下降，然后又略有回升。为什么代理训练得越多越差？由于训练时间是固定的，通过只训练 100 个级别，代理将一遍又一遍地重复相同的级别，并且可以很容易地记住所有内容(但是在测试时在看不见的级别上表现很差)。有了 1，000 个级别，代理将不得不将其时间分散到更多的级别，因此也无法学习这些级别。当我们达到 10，000 或更多的级别时，代理能够看到如此多样的级别，它能够很好地执行，因为它已经开始概括它的理解。我们还看到，测试性能很快提高到接近训练性能的水平，这表明代理能够很好地概括到看不见的水平。

通过从观察中进行逆向强化学习来推断次优演示之外的情况(Brown，Goo 等人，2019 年)

本文提出的算法名为 T-REX ，与之前提到的奖励学习方法不同，它在学习过程中不需要持续的人类反馈。虽然与监督每个代理动作相比，其他算法需要相对较少的人工时间，但它们仍然需要一个人来回答数千个偏好查询。T-REX 的一个关键思想是，通过在开始时完成所有偏好反馈，而不是在整个学习过程中持续完成，可以显著减少人类的时间投入。

第一步是生成正在学习的游戏或任务的演示。演示可以来自标准的强化学习代理，也可以来自人。

主要的想法是，我们可以通过从这些演示中提取短视频剪辑来获得大量偏好数据，并仅根据它们来自的演示的排名来给它们分配偏好。例如，有 20 个演示，每个演示将得到从 1 到 20 的等级。大量的短视频剪辑将从这些演示中选取，每个剪辑将被分配给它所来自的演示的等级，因此当它们面对彼此时，偏好将会转到来自更好的演示的剪辑。奖励函数将基于这些偏好。

这与以前的方法形成对比，以前的方法需要对每一对 1-2 秒的剪辑输入人类偏好。这里，我们只需要人类偏好输入来对初始演示进行排序。然而，霸王龙的缺点是它使用了一个近似值。并非来自较高等级的演示的所有剪辑都应该比来自较低等级的演示的剪辑更优选，但是该想法是平均而言，偏好将会很好地工作，并且该过程将足以学习奖励模型。

提供对演示的排序相当于在每一对演示之间给出偏好。例如，如果我们有三个演示，并将它们排序为 3>1>2，这意味着我们将生成 3>1、3>2 和 1>2 的排序。则根据剪辑来自哪个演示，从演示中随机生成的剪辑将被给予相同的偏好等级。

霸王龙的论文表明，只要有 12 次示范就足以学习一个有用的奖励模型。任何 12 个对象都有 12 * 11 / 2 = 66 个不同的对，因此从 1 到 12 对 12 个演示进行排名相当于回答多达 66 个关于哪个演示更好的查询，这比 Christiano 等人的算法所需的查询少约 100 倍。同样，尽管 T-REX 排名演示方法更有效，但由于简化了较好演示的所有剪辑都比较差演示的所有剪辑好的假设，它牺牲了精确度。

Brown 和 Goo 等人基于 Atari 的实验表明，霸王龙与之前描述的 Ibarz 等人的方法相比具有竞争力。它能够仅使用 12 个示范及其相应的偏好(等级)标签来学习优于示范的质量代理。

下图显示了五款 Atari 游戏中人类演示的得分与 T-REX 算法的得分之间的比较。虽然在蒙特祖马的复仇游戏中没有获得任何分数，但霸王龙的表现远远超过了人类 5 分中的 3 分。

霸王龙算法对人类(来源

T-REX 还在 8 场比赛中的 7 场比赛中超过了最先进的行为克隆算法(BCO)和模仿学习算法(盖尔)，如下图所示，同时在 8 场比赛中的 7 场比赛中击败了最佳演示。(行为克隆算法试图尽可能接近演示，而反向强化学习算法试图从专家演示中恢复奖励函数。)

T-REX 算法与其他先进方法的对比(来源)

接下来:实现和实验

基于 T-REX 的强大结果和简单的想法，我们决定将我们的初始实验基于将该算法与 Procgen 游戏环境相结合，这将为我们提供一个高效的奖励学习算法和各种基准游戏来测试泛化能力。我们将在本系列的第二篇博文中解释我们实现的细节以及实验结果和我们面临的问题。

评估员工调查的统计严谨性

原文：https://towardsdatascience.com/assessing-statistical-rigor-of-employee-surveys-1d27e3df998a?source=collection_archive---------29-----------------------

让我们谈谈相关性，克朗巴赫的阿尔法和因素分析

格伦·卡斯滕斯-彼得斯在 Unsplash 上拍摄的照片

人力资源行业严重依赖广泛的评估来支持其职能。事实上，为了确保不偏不倚和公平的招聘实践，美国劳工部保持了一套指导方针(统一指导方针)，以帮助人力资源专业人员进行评估开发。

性格评估经常被用于选拔，以确定文化是否适合一家公司。认知能力(即。在所有类型和级别的工作中，智商测试一直被认为是工作表现的最佳总体预测指标(Schmidt & Hunter，1998)。结构化面试在招聘决策中被广泛使用，因为它们通过标准化问题和评分来帮助消除偏见。绩效评估使用严格的李克特评估，要求经理和同事对员工的绩效进行评级(即行为锚定等级量表)。员工参与度调查评估员工对其雇主和工作的满意度、激情、努力和承诺程度。最后但同样重要的是，员工离职调查通常在员工离职时进行，以确定员工对与组织相关的一系列话题的感受。

这种对员工评估的广泛使用催生了一个数十亿美元的行业，专门开发各种各样的测试。让我们把注意力集中在员工态度调查上，因为他们构成了这个行业的一个非常大的部分。如果你要购买一份调查，你如何确定你得到的是高质量的产品？任何一个有声望的开发者不仅应该提供给你一份手册，还应该提供一份验证报告，该报告概述了为确保调查确实测量了它想要测量的内容而采取的步骤。

在本文中，我将检查一个员工离职调查，并根据一些选定的指标来确定调查的质量。因此，当您收到调查供应商的验证报告时，您将知道并理解做出明智购买所需的指标。

调查开发流程

在我们进入度量标准和代码之前，让我们花几分钟回顾一下一个统计上严格的调查是如何开发和验证的。

  • 这个过程从一个问题开始。例如:“我的员工对他们的工作和公司满意吗？”
  • 我们如何定义“幸福”？在我们开始写调查问题之前，我们需要从操作上定义“幸福”。我们搜寻员工快乐研究的文献。毫无疑问，你将到达诸如员工满意度、承诺和参与度等主题。你会读到几十份提出员工满意度独特模型的研究报告。Hackman & Oldham 的工作特征模型因其全面性和统计有效性而经常被用于员工满意度调查。有效性是指许多研究人员在他们的研究和/或评估中采用了这个模型，并发现它是正确的。

hackman & old ham(1980)的工作特征模型

  • 所选模型将作为构成调查的问题或项目的基础。根据调查的长度，我们将为每个部分写 3-10 个项目(即技能多样性、任务同一性、自主性等。)的模型。我们编写了多个问题来确认员工对每个模型组件的看法。我们将把重点放在定量项目上，这些项目要求员工选择一个与他们的内在态度(即李克特量表)。
  • 每个问题都可以通过允许研究领域的杰出研究人员(即员工满意度)来仔细检查每个问题。当员工因不当的雇佣决定而受到诉讼时，内容有效性经常在法律诉讼中被引用。其他形式的验证包括结构和标准有效性。
  • 完成第一份草案后，将使用与全部员工非常相似的员工样本进行试点测试。为了对结果有信心，获得大量有代表性的样本是很重要的。
  • 一旦实施了调查并收集了数据，就需要检查某些心理测量属性，即可靠性和有效性。基于心理测量结果，调查被修改，直到可以实现最佳心理测量。

员工离职调查示例

首先，这个虚构的数据集及其结果应该被视为虚构的。其次，终止原因(即。自愿、非自愿、退休等。)已从加载的数据集中省略，因为本文将专门关注李克特量表问题的心理测量属性。

import pandas as pd
import numpy as np
import scipy.stats as stats
import matplotlib.pyplot as plt
import seaborn as sns
import pingouin as pg
from factor_analyzer import FactorAnalyzer
from factor_analyzer.factor_analyzer import calculate_bartlett_sphericity
from factor_analyzer import ConfirmatoryFactorAnalyzer, ModelSpecificationParserimport warnings
warnings.filterwarnings('ignore')
pd.set_option('display.max_columns', None)
%matplotlib inlinewith open('likert.csv') as f:
    likert_items = pd.read_csv(f)
f.close()likert_items.head()


len(likert_items), likert_items.describe().T

len(李克特 _ 项目)

在加载我们的库时，我们有一个约 702 名员工的数据集，他们回答了 27 个 Likert 类型的问题，其中 1 个是强烈不同意，5 个是强烈同意。所提问题会影响员工对晋升机会、经理满意度、工作满意度、培训和工作/生活平衡的看法。

我们必须承认，被解雇的员工不需要填写离职调查。这完全由他们决定，因此调查结果可能会有偏差

潜在因素

如上所述，精心设计的调查植根于经过验证的学术模型，本次调查也不例外。已经开发了 27 个单项来评估 8 个潜在因素。

相关

likert_corr = likert_items.corr()plt.figure(figsize=(25,15))
mask = np.zeros_like(likert_corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True
plt.figure(figsize=(70,40))
plt.xticks(fontsize=50)
plt.yticks(fontsize=50)
sns.heatmap(likert_corr, cmap='coolwarm', annot=True,
            fmt=".2f", annot_kws={'size': 40, 'color': 'black'}, linewidths=2,
            vmin=-0.5, mask=mask)

当处理定量问题时，我们使用的第一个工具是可靠的相关性。相关矩阵将为我们提供调查的心理测量质量的第一手线索。以绿色突出显示的相关性是那些旨在衡量相同潜在结构的项目。这些相关性应保持相对较高的相关性(0.5 至 0.7)，因为这将表明这些项目正在测量一个较大结构的几个独特的子组件。然而，如果相关性太大(0.7 以上)，这将意味着项目可能测量非常相似或甚至相同的结构。我们最终希望我们的问题是评估一个更大因素的不同子成分，如“工作满意度”。

另一方面，突出显示区域之外的相关性应该保持尽可能低。这将表明这些项目正在测量非常不同的结构。例如，direct_mgmt_satisfaction 和 feed _ offed(0.75)之间的高度相关性相当令人沮丧，因为它们测量的是不同的潜在结构(员工价值和管理满意度)。另一方面，这种相关性也让我们看到了“反馈提供”项目的错误分类，因为经理最经常提供建设性的反馈，因此，人们可能会认为该项目实际上是评估管理满意度。

总的来说，查看相关矩阵，似乎管理满意度、工作满意度、团队满意度、培训满意度和工作/生活平衡是相对较强的潜在因素。另一方面，员工价值和组织环境相当薄弱。最后，薪酬满意度由一个问题组成。

可靠性

可靠性是一致性的衡量标准。换句话说，如果有人多次参加同样的性格评估，他们的分数应该不会相差很大。开发调查时最突出的可靠性指标是 Cronbach 的 Alpha ，这是一种内部一致性的衡量标准。Alpha 假定是一维的，或者传递到它的函数中的项目测量一个因素，因此，我们需要分别计算每个潜在因素的 Alpha。

valued = likert_items[['promotional_opportunities', 'performance_recognized', 'feedback_offered','coaching_offered']]mgmt_sati = likert_items[['mgmt_clear_mission','mgmt_support_me',
'mgmt_support_team', 'mgmt_clear_comm', 'direct_mgmt_satisfaction']]job_satisfaction = likert_items[['job_stimulating', 'initiative_encouraged', 'skill_variety','knowledge_variety', 'task_variety']]team_satisfaction = likert_items[['teamwork','team_support', 'team_comm', 'team_culture']]training_satisfaction = likert_items[['job_train_satisfaction',
'personal_train_satisfaction']]org_environment = likert_items[['org_culture', 'grievances_resolution', 'co-worker_interaction', 'workplace_conditions']]work_life_balance = likert_items[['job_stress','work/life_balance']]salary_satisfaction = likert_items[['fair_salary']]dict = {'valued': valued, 'mgmt_sati': mgmt_sati,
        'job_satisfaction': job_satisfaction,
        'team_satisfaction': team_satisfaction,
        'training_satisfaction': training_satisfaction,
        'org_condition': org_condition,
        'work_life_balance': work_life_balance}for i in dict:
    print('{} Alpha: {}'.format(i, pg.cronbach_alpha(data=dict[i], nan_policy='listwise'))

管理满意度、工作满意度、团队满意度和培训满意度都表现出高到非常高的阿尔法系数(0.8+)。高 alpha 结果表示项目正在测量相同的基础结构。员工价值、组织环境和工作生活平衡导致较低的阿尔法系数，这意味着项目可以改进，以更好地衡量他们的结构。我们至少需要 2 个项目来衡量 alpha，因此，salary_satisfaction 不包括在此分析中。

另一种常用的可靠性测量是“重测信度”。对同一样本进行多次调查，并比较分数以确定一致性。

要素分析

探索性因素分析

因素分析或更具体地说探索性因素分析经常用于调查开发过程中。它用于在开发阶段对评估进行初步探索。因子分析是一种数据简化技术，它试图将特征之间通常存在的差异提取到一个因子中。换句话说，旨在评估共同潜在因素的调查项目将一起协变。Covary 的意思是，如果有人在第一个问题上回答“非常同意”,他们很可能会在另一个旨在评估潜在因素的问题上以类似的方式回答。

全民教育与主成分分析

EFA 在降维方面类似于 PCA(主成分分析),但它有一些不同之处:

  • 一个 EFA 识别潜在因素，这些潜在因素可以被解释，因为这些潜在因素是有意开发的。
  • PCA 试图解释最大方差(PC1 将保存最大方差)，而 EFA 试图解释特征之间的协方差。
  • PCA 执行其分析，而不考虑潜在的结构，它只是想说明特征中的所有差异。
  • 通过设计，PCA 成分是正交的(不相关)，但是 EFA 因子不需要正交(取决于旋转)。

巴特利特球形度试验

在尝试使用因子分析之前，应该进行“Bartlett 球形检验”,检验是否有多个特征可以简化为潜在因子。Bartlett 检验的结果是显著的(p=0.00)，这意味着数据可以减少，我们可以继续进行因子分析。

chi_square_value,p_value=calculate_bartlett_sphericity(likert_items)
chi_square_value, p_value


factor = FactorAnalyzer()
factor.fit(likert_items)ev, v = factor.get_eigenvalues()
plt.figure(figsize=(15,10))
plt.plot(range(1, likert_items.shape[1]+1), ev, marker='X', markersize=12)
plt.xlabel('# of Factors')
plt.ylabel('Eigenvalues')
plt.grid()
plt.show()

我们可以使用 scree 图来确定最佳的因素数量。Kaiser 标准提到，一个因子应该解释一定量的差异，才能被视为有效因子。我们通常将截止值设置为 1 个特征值。

factor = FactorAnalyzer(8, rotation='promax', method='ml', impute='mean')factor.fit(likert_items)
factors = factor.loadings_
factors_df = pd.DataFrame(factors, columns=['factor1', 'factor2', 'factor3','factors4','factor5', 'factor6', 'factor7', 'factor8'] index=likert_items.columns)factors_df.style.bar(subset=['factor1', 'factor2', 'factor3',
'factors4','factor5', 'factor6','factor7','factor8'], color='green')

尽管 scree 图中有 5 个最佳因素，但我们知道该调查包含 8 个潜在因素。最后，加载分数的临界值相当主观，但我们将使用 0.5。

因素 1: 除了一个“管理满意度”项目外，其他项目在该因素中的权重都很高。我们还有来自“员工价值”和“组织环境”的项目，它们在因子 1 中的权重很高。此外，在回答问题时，评估“管理满意度”结构的项目似乎将调查参与者置于一个整体的组织视角或心态中。换句话说，要求个人从整体上考虑管理。然而，当调查对象回答“直接管理满意度”问题时，他们的视角变窄了，尽管享受着更广泛的组织领导，但他们对直接经理的看法可能会有所不同。这可能解释了为什么“直接管理满意度”项目在因子 1 上的加载如此之低。

我建议调查将管理潜在结构分为广义领导和直接经理满意度。此外，我强烈建议需要重新考虑“employee_value”结构，因为这些项目不会一起加载到任何因子上。

因素 2: 这个因素几乎完美地加载到“工作满意度”结构中。这将表明这些项目已经被很好地开发，并且正在测量它们缩进去测量的内容。

因素 3: “培训满意度”完美加载到因素 3 上。然而，重要的是要提到“评估促销机会”这一项有一定的积极意义。这是有意义的，因为一个为员工提供培训机会的组织肯定会有一个好的继任计划。

因素 4: 因素 4 似乎与“团队满意度”结构相对应。虽然，“team_culture”项由于加载量较低，需要改进。试图评估诸如“文化”之类的模糊主题的项目通常以较低的负荷出现在它们指定的结构中。也许将项目集中在组织文化模型的一个或两个特定组成部分肯定会有助于缩小问题的范围。

因素 5: 这个因素承载了巨大的“工作/生活平衡”潜在结构。

因素 6: 有趣的是,“团队交流”和“团队文化”在因素 6 上的负荷都非常高，尽管事实上“团队交流”也在因素 4 上负荷。因为“team_comm”在两个因素上负荷很高，这将表明调查者可能对该问题有不同的解释。也许在这个问题中加入一些上下文可能有助于提高它对因子 4 的加载。最后，简单地改变评估“团队满意度”的问题的顺序可能有助于这两个项目更好地载入因素 4。

因子 7: 我们没有看到任何可识别的结构加载到因子 7 上。

因子 8: 这是唯一加载“fair_salary”项的因子。在提出任何建议之前，这个结构当然需要更多的问题。

验证性因素分析

验证性因素分析最常用于确认已经验证的评估。例如，您希望使用从供应商处购买的现成调查来进行员工参与度评估。利用对您的特定组织员工样本的调查进行试点测试可能是个好主意。CFA 将是一个很好的工具，可以确认调查旨在衡量的基本结构，但要使用你的员工样本。

事实上，研究人员经常使用两种因素分析来验证他们的评估。使用 EFA 来观察有目的开发的结构并没有错。我发现全民教育的结果对于提炼单个项目的问题非常有帮助。一旦你根据 EFA 结果改进了项目，CFA 结果通常也会增加。

model_dict = {'valued_employee': ['promotional_opportunities', 'performance_recognized','feedback_offered', 'coaching_offered'],'mgmt_sati':['mgmt_clear_mission', 'mgmt_support_me', 'mgmt_support_team','mgmt_clear_comm', 'direct_mgmt_satisfaction'],'job_satisfaction': ['job_stimulating', 'initiative_encouraged',
'skill_variety','knowledge_variety','task_variety'],'salary_satisfaction': ['salary_satisfaction'],'team_satisfaction': ['teamwork','team_support', 'team_comm', 'team_culture'],'training_satisfaction': ['job_train_satisfaction', 'personal_train_satisfaction'],'org_condition': ['org_culture', 'grievances_resolution', 'co-worker_interaction','workplace_conditions'],'work_life_balance': ['job_stress','work/life_balance']}model_spec = ModelSpecificationParser.parse_model_specification_from_dict(
    likert_items, model_dict)cfa = ConfirmatoryFactorAnalyzer(model_spec, disp=False)
cfa.fit(likert_items)cfa_factors_df = pd.DataFrame(cfa.loadings_, columns=['factor1', 'factor2','factor3','factors4','factor5','factor6','factor7', 'factor8'],index=likert_items.columns)cfa_factors_df.style.bar(subset=['factor1','factor2','factor3',
'factors4','factor5','factor6','factor7','factor8'], color='orange')

摘要

员工价值

CFA 结果似乎大部分证实了从相关矩阵、alpha 信度和 EFA 得到的结果。评估“employee_value”结构的项目当然需要改进，因为在衡量什么方面似乎有些混乱。“绩效 _ 认可”和“反馈 _ 提供”似乎是衡量一个潜在的结构，因为它们的相关性是 0.63，并且它们对 EFA 和 CFA 的负荷都很高。该结构的 alpha 可靠性处于可接受的边缘(0.79)，当我们查看其他指标时，肯定需要对该结构进行工作。

管理满意度

除了“direct _mgmt_satisfaction”之外，衡量管理满意度的项目都很完善，经得起相关性、alpha 可靠性和因子分析的严格测试。如前所述，与其他问题相比,“direct _mgmt_satisfaction”问题可能存在规模问题。调查参与者大多回答关于更广泛的领导力结构的问题，这个问题问的是他们的直接经理。

工作满意度

所有 4 项分析都支持评估该结构的项目质量。我什么都不会改变:)

团队满意度

当比较 EFA 和 CFA 时，该结构具有一些矛盾的加载结果。然而，这些矛盾，边缘阿尔法可靠性，以及项目之间不那么惊人的相关性，指向急需修订的问题。我认为团队的结构是可操作的，但是“团队文化”的概念在参加调查的人中可能有不同的解释。

培训满意度

为了建立可信的信度和结构效度，每个结构至少提供 3 个问题是很重要的。衡量这一结构的两个项目写得非常好，似乎在评估一个因素。我想看看其他问题。柯克帕特里克的培训评估模型可以作为附加问题的基础。

组织环境

不幸的是，就像“员工价值”一样，这一概念需要进行重大修改。所有的指标都导致了低于标准的结果，从表面效度的角度来看，很难在心理上将这些项目包含在一个内聚的结构中。

工作/生活平衡

很像“训练满意度”,这个结构表现很好，但我们希望每个结构至少有 3 个项目。

薪资满意度

这个结构由一个项目组成，从实用的角度来看，它根本就不存在。即使是克朗巴赫的阿尔法也需要至少两个问题。

结论

开展员工调查无疑需要做大量的工作。更有甚者，当调查变成评估(即。认知能力或技能测试)在招聘过程中的严格性和文档呈指数级增长。我希望你喜欢看一些 I/O 心理学家的工作。一如既往，我欢迎您的反馈。

冠状病毒封锁对我们环境的影响分析。

原文：https://towardsdatascience.com/assessing-the-impact-of-the-coronavirus-lockdown-on-our-environment-through-data-2905535da51e?source=collection_archive---------2-----------------------

汤姆·霍尔姆斯在 Unsplash 上拍摄的照片

更新至 4 月 4 日的最新数据

你可能已经看到了推文，或者更糟的是，你可能已经分享了新闻；威尼斯有海豚和天鹅，中国有大象，在这个清新纯净、没有人类的世界里自由自在地游荡。在这个艰难的时刻，我们都想相信一些好的事情，但事实证明那些新闻和图片是假的，不完全是假的，只是与当前全球范围内的冠状病毒封锁无关。海豚和天鹅总是在威尼斯，大象的照片是一张旧照片。

所以问题来了，这是同一个古老的地球，还是仅仅好了一点点？为了消除噪音，揭示真正的真相，我决定查阅数据。空气质量指数(AQI)是一个非常可靠的指标，它反映了空气污染水平，因此是了解封锁影响的一个非常好的方法，至少对我们的低层大气是如此。你可以在 CovidExplore.com这里看到全球污染物水平每周的变化。

自 2020 年第一周以来的 NO2 浓度。新冠肺炎的气候面

我知道，对吧？你可以看到一月底(第五周)和现在的巨大差异。具体来说，二氧化氮水平受到了巨大的冲击，因为街上几乎没有汽车，也很少有工业在运营。最大的不同将出现在意大利、西班牙和伊朗，这些国家采取了最严格的封锁措施来应对病毒的传播。

CovidExplore.com是用这个 github 库创建的:https://github.com/mayukh18/covidexplore。

** [## mayukh18/covidexplore

flask app 通过数据探索新冠肺炎对世界的影响。该项目的主要目标是评估…

github.com](https://github.com/mayukh18/covidexplore)

现在让我们看看各地的数据和推论。**

欧洲

空太阳门广场，马德里。图片:路透社

一旦我们更深入地了解欧洲三个国家的污染水平，就会更加清楚:意大利、西班牙和法国，这三个国家是最早进入封锁状态的。

意大利于 3 月 10 日进入完全封锁状态(由垂直黑线表示)，是此次危机中受冲击最大的国家。二氧化氮水平不言自明。然而，PM2.5 并没有反映出太多的变化。

西班牙于 3 月 14 日进入封锁状态。

法国于 3 月 16 日进入封锁状态。

因此，汽车和工业排放减少的影响是显而易见的，在上述三个国家中，二氧化氮水平都达到了历史最低水平。然而，PM2.5 水平在很大程度上与锁定无关。还需要 2-3 周的时间来全面评估人类缺席对它的影响。

CNN 比较了 3 月 19 日和 2020 年 3 月之间的 NO2 水平这里。毫无疑问，1-2 周的无所事事可以治愈我们的情绪。

这是一段由欧洲航天局的 Sentinel-5P 卫星处理的欧洲上空的排放视频。

美国

川普对新冠肺炎局势的政策一直不一致。没有任何全国性的封锁，各州已经采取了自己的预防措施。加利福尼亚州和纽约州是受影响最严重的州之一。加州在全州范围内采取了最早的 T2 居家订单措施之一。

洛杉矶记录了美国最早的案例之一，因此像在家工作限制旅行这样的措施早在当局介入之前就在基层开始了。结果相当明显。你可以在这里查看加州和美国其他城市上空 NO2 水平的巨大差异。

亚洲

照片由瑞安·楚在 Unsplash 上拍摄

但最重要的可能是武汉，这一切的开始。就空气污染而言，中国也是世界上污染最严重的国家之一。1 月 23 日，武汉和湖北省的其他城市被中国政府完全封锁。在我们所有的样本中，这座城市给了我们最长的锁定视角。

这是欧空局为中国准备的相应的排放视频。

很明显，不是吗？如果你想看到封锁的即时效果，最好的例子是印度。印度在 3 月 22 日进行了试验性封锁后，从 3 月 25 日开始进入完全封锁状态。

事实上，新德里的人们在很长一段时间里一直看到如此低的空气质量指数水平。

我们气候的任何改善都不能证明或弥补我们世界人民正在经历的生命损失、苦难和痛苦。想一想都是愚蠢的。但是，我们能做的也许是从中吸取教训。COVID 危机导致了这一阶段，因为我们的世界领导人忙于否认它的影响，就像他们否认气候变化的各个方面一样。下一次，危机可能是气候危机。因此，我们应该做好准备。它的装甲可能没有任何缝隙。

数据是从aqicn.org获得的。每个国家的数据是其最大城市的平均值的近似值。为了使图表可读(因为读数波动很大)，显示的数据是过去 7 天的滚动平均值。这是截至 2020 年 3 月 27 日的最新数据。

搜集来的 AQI 数据就在 https://github.com/mayukh18/covidexplore的仓库里。其他与 COVID 病例相关的数据从 https://github.com/CSSEGISandData/COVID-19约翰霍普金斯大学系统科学与工程中心获得

参考资料:

  1. 贝尔瑞秋。"为什么人们如此渴望相信这个假故事是真的？"国家地理，2020 年 3 月 27 日。https://www . national geographic . com/animals/article/why-do-people 如此渴望相信这个假故事是真的
  2. 董，恩生等，“一个基于网络的实时跟踪的交互式仪表板”，2020 年 2 月 19 日。考研。https://pubmed.ncbi.nlm.nih.gov/32087114
  3. 帕特尔，卡莎。“意大利上空空气中二氧化氮减少”2020 年 3 月 13 日。美国宇航局地球天文台。https://earth observatory . NASA . gov/blogs/earth matters/2020/03/13/airborne-nitrogen-dioxide-reduces-over-Italy
  4. 加州下令封锁该州 4000 万居民，2020 年 3 月 19 日。华尔街日报。https://www . wsj . com/articles/China-reports-no-new-domestic-coronavirus-infections-for-first-time-since-outbreak-started-11584611233

将面板数据分配给机器学习模型的训练、测试和验证组

原文：https://towardsdatascience.com/assigning-panel-data-to-training-testing-and-validation-groups-for-machine-learning-models-7017350ab86e?source=collection_archive---------17-----------------------

确保您的团队是独立的，避免部署灾难

作者图片

[## shad Griffin/面板采样

在 GitHub 上创建一个帐户，为 shadgriffin/panelsampling 的开发做出贡献。

github.com](https://github.com/shadgriffin/panelsampling)

横截面数据包括在一个时间段内测量的单个实体。比如一万个人测一次就是横截面数据。

时间序列包括在多个时间段测量的一个实体。例如，十年来每天测量的单台机器就是一个时间序列。

面板数据包括在多个时间段测量的多个实体。例如，十个月内每月测量的 1000 名消费者是面板数据。或者说，100 天内每天测量 100 台机器，就是面板数据。

面板数据在数据科学中相当常见。有时，它被称为横截面时间序列数据。我还听说它被称为汇集的时间序列数据。不管你怎么称呼它，作为一名实践数据科学家，你很可能不得不处理它。

构建机器学习模型时，将数据中的记录分配给建模组是标准程序。通常，我们将数据随机分为训练组、测试组和验证组。在这种情况下，随机意味着数据集中的每条记录都有均等的机会被分配到三个组之一。

然而，当您处理面板数据时，稍微改变一下正常过程是有意义的。

在这本笔记本中，我通过一个简单的例子来说明如何做到这一点。

开始调教

导入所有相关的 Python 库

import numpy as np
import numpy.dual as dualimport pandas as pd

从 GitHub 导入数据

#Remove the data if you run this notebook more than once
!rm equipment_failure_data_1.csv#import first half from github
!wget [https://raw.githubusercontent.com/shadgriffin/machine_failure/master/equipment_failure_data_1.csv](https://raw.githubusercontent.com/shadgriffin/machine_failure/master/equipment_failure_data_1.csv)# Convert csv to pandas dataframe
pd_data_1 = pd.read_csv("equipment_failure_data_1.csv", sep=",", header=0)#Remove the data if you run this notebook more than once
!rm equipment_failure_data_2.csv#Import the second half from github
!wget [https://raw.githubusercontent.com/shadgriffin/machine_failure/master/equipment_failure_data_2.csv](https://raw.githubusercontent.com/shadgriffin/machine_failure/master/equipment_failure_data_2.csv)# convert to pandas dataframe
pd_data_2 = pd.read_csv("equipment_failure_data_2.csv", sep=",", header=0)#concatenate the two data files into one dataframe
pd_data=pd.concat([pd_data_1, pd_data_2])

数据探索

pd_data.head()

以下是对数据集中字段的描述。

ID —代表特定机器的 ID 字段。

日期—观察的日期。

REGION_CLUSTER —表示机器所在区域的字段。

MAINTENANCE_VENDOR —代表为机器提供维护和服务的公司的字段。

制造商——制造相关设备的公司。

WELL _ GROUP 表示机器类型的字段。

设备年龄-机器的年龄，以天为单位。

S15 —传感器值。

S17 —传感器值。

S13 —传感器值。

S16 —传感器值。

S19 —传感器值。

S18 —传感器值。

S8 —传感器值。

设备故障——“1”表示设备出现故障。“0”表示设备没有出现故障。

该数据代表一个面板数据集。我们在多个时间段测量了多台机器。ID 代表机器，DATE 代表日期。现在，让我们检查一下我们有多少台机器和多少个日期。

检查行数和列数。该数据有 307，751 行和 16 列

pd_data.shape

数据集中有 421 台机器。

xxxx = pd.DataFrame(pd_data.groupby(['ID']).agg(['count']))
xxxx.shape

数据集中有 731 个不同的日期。

xxxx = pd.DataFrame(pd_data.groupby(['DATE']).agg(['count']))
xxxx.shape

按实体(机器 id)创建测试、培训和验证组

我们可以将每个记录随机分配给培训、测试或验证组。虽然这可能行得通，但我不会推荐它。我建议在实体级别(在本例中是机器)将记录分配给组。

为什么？

嗯，我可以用一些多音节词(如自相关、回旋镖或蛋黄酱)来描述为什么，但让我们想想。

为什么我们将数据分成培训、测试和验证组？

我们希望确保我们的模型不会过度拟合。换句话说，我们希望确保我们的模型适用于新数据。

例如，让我们假设我们建立了一个模型，它以 100%的准确率预测了去年发生的事情。干得好，对吧？嗯，模型去年预测的多好真的不重要。我们需要它来预测今天、明天和后天。因此，如果一个模型以 100%的准确率预测了去年，却没有预测到明天，那就有点糟糕了。

在训练数据上构建模型，并在测试和验证数据集上验证准确性，可以减少过度拟合的机会(注意，这仍然是可能的，但我将把这个讨论留到以后进行)。

为了防止过度拟合，我们的培训、测试和验证组必须是独立的。也就是说，训练组中的数据必须不同于测试和验证组。或者，至少尽可能的不同。

那么，如果我们只是将面板数据集中的每条记录随机分配给每个组，会发生什么呢？

我们最终得到每个组中每个实体的记录。

例如，使用简单的随机选择方法，如果我们在 100 天内每天测量 100 台机器，那么物理上位于休息室旁边的机器很可能会出现在培训、测试和验证组中。同样，如果您与个人打交道(其中一个人的名字是 Steve Wakahookie)，Steve Wakahookie 很可能会出现在所有三个组中。

换句话说，你的培训、测试和验证小组并不是独立的，因为史蒂夫和休息室旁边的机器都在这三个小组中。

史蒂夫正在接受测试。史蒂夫正在接受训练。史蒂夫在验证中。如果他潜伏在所有三个群体中，那么这三个群体就不是独立的。

现在，如果我们基于实体分配组成员，所有 Steve 的记录将在培训、测试或验证组中。同样，休息室与机器相关联的所有记录将只属于三个组中的一个。

如果 Steve 参加了培训，但没有参加测试或验证，那么这个组就是独立的。

如果休息室旁边的机器在测试中，但不在培训或验证中，则这些组是独立的。

下面是几行 python 代码，以确保您的培训、测试和验证组是独立的。

获取所有 id(机器)的唯一列表。

aa=pd_datapd_id=aa.drop_duplicates(subset='ID')
pd_id=pd_id[['ID']]
pd_id.shape

用 0 到之间的随机数创建一个新变量。

np.random.seed(42)
pd_id['wookie'] = (np.random.randint(0, 10000, pd_id.shape[0]))/10000pd_id=pd_id[['ID', 'wookie']]

给每台机器 30%的机会通过验证，35%的机会通过测试，35%的机会通过训练数据集。

pd_id['MODELING_GROUP'] = np.where(((pd_id.wookie <= 0.35)), 'TRAINING', np.where(((pd_id.wookie <= 0.65)), 'VALIDATION', 'TESTING'))

这是每组有多少台机器坠落。

tips_summed = pd_id.groupby([‘MODELING_GROUP’])[‘wookie’].count()
tips_summed

将每个 id 的组追加到每个单独的记录中。

pd_data=pd_data.sort_values(by=['ID'], ascending=[True])
pd_id=pd_id.sort_values(by=['ID'], ascending=[True])pd_data =pd_data.merge(pd_id, on=['ID'], how='inner')pd_data.head()

这是每组中记录的数量。

tips_summed = pd_data.groupby(['MODELING_GROUP'])['wookie'].count()
tips_summed

结论

所以，这就对了。现在，我们准备建立一个机器学习模型。通过将实体而不是记录放入您的培训、测试和验证组，您可以确保这些组之间的独立性，并构建适用于昨天、今天和明天的模型。

作者

Shad Griffin 是 IBM 的一名数据科学家

关联规则挖掘:频繁项集是什么

原文：https://towardsdatascience.com/association-rule-mining-what-frequent-itemsets-is-all-about-1b3066535d81?source=collection_archive---------50-----------------------

凯利·西克玛在 Unsplash 上的照片

查找项目唯一组合的出现频率

要理解频繁项集，首先需要理解频繁项集和频繁项集。让我们先看看项目集是什么意思。简单地说，项目集是在一个事务或记录中一起出现的一组项目。组的大小可以小到 1，大到该事务或记录中所有项目的数量。甚至可以考虑大小为 0，但这不会产生任何有意义的结果。

项目集或幂集

让我们用一些关于项目集的代码更深入地研究一下。让我们从记录的一个例子开始。

这个记录只有三个项目:苹果、香蕉和牛奶。记录列表中总共有 2 个不同大小的集合，其中也包含一个空集。所以这个记录有 2 -1，7 个相关的集合。3 个项目可以创建总共 2 -1，7 个独特的集合。如果总共有 n 个可能的项目，它将产生 2^n-1 唯一集。

上面的代码显示了记录中的所有项目集。基本上显示了所有可能的 8 个唯一组，包括一个空集(通常不相关)。

如何计算项目集？

随着 n 变大，这些唯一项集会增长到一个非常大的数字。虽然有些可能永远不会一起出现。因为不是所有的项目组合都会出现在记录中。例如，如果记录相当于商店中的一笔交易，则不是每个项目都会以某种组合与所有其他项目一起出现。

记录中的项目集:

{('苹果'，'牛奶'，('香蕉'，'牛奶'，('苹果'，'香蕉'，'牛奶'，('鸡蛋'，'香蕉'，)，('牛奶'，)，('苹果'，'鸡蛋'，)，('鸡蛋'，)，('苹果'，'鸡蛋'，)，('面包'，)，('苹果'，'面包'，)，('苹果'，'面包'，)，('苹果'，)，('苹果'，'香蕉'，('鸡蛋'，'牛奶'))

来自项目
[()，('苹果'，)，('香蕉'，)，('牛奶'，)，('鸡蛋'，)，('面包'，)，('苹果'，'牛奶'，('苹果'，'鸡蛋')，('苹果'，'面包'，('香蕉'，'牛奶')，('香蕉'，'鸡蛋'，('香蕉'，'面包'，('牛奶'，'鸡蛋'，'面包')，('苹果'，'香蕉'，'牛奶'，'牛奶'，'牛奶')的项目集

上面的代码显示了一些记录和所有独特的项目。通过唯一项和少数记录计算的项集不匹配。使用记录的项集少于通过唯一项计算的项集。因此，不是从所有可能的唯一项中创建唯一项集，而是使用记录数据库来高效地计算可能的项集。

频率

频率是多少？它只是某一事件的发生次数与某一观察周期内所有事件的发生次数之比。那么它在项目集的情况下是如何工作的呢？让我们来分解一下。

某一事件的发生次数与某一观察周期内所有事件的发生次数之比

项目集出现的频率:
('苹果'，)，0.67
('香蕉'，)，0.33
('牛奶'，)，0.67
('苹果'，'香蕉')，0.33
('苹果'，'牛奶')，0.33
('香蕉'，'牛奶')，0.33
('苹果'，'香蕉'，'牛奶')，0.33
('鸡蛋'，)，0.67

例如，苹果出现在三分之二的记录中，所以它的频率是 2/3=0.67(四舍五入到两位小数)

支持度是关联规则挖掘中频率的另一个术语。在这种情况下，会使用某个阈值，并且只有高于该阈值的项目集才会被考虑用于规则挖掘。

结论

希望这篇文章能澄清什么是频繁项集。我想指出两点:

  1. 为了提高效率，如何从记录数据库中计算唯一项集而不是唯一项是很重要的。
  2. 一旦我们有了唯一的项目集，频率的计算方法是找出这个组合出现的所有记录，除以记录总数。

我想接下来写一下信心、提升、信念，然后在规则挖掘上来个满圈。

线性回归中的假设你可能不知道。

原文：https://towardsdatascience.com/assumptions-in-linear-regression-528bb7b0495d?source=collection_archive---------17-----------------------

进入现实世界

模型应该符合这些假设，以产生与数据的最佳线性回归拟合。

约瑟夫·巴里恩托斯在 Unsplash 上拍摄的照片

—所有图像(情节)均由作者生成和修改。

介绍

首先在处，线性回归是一种建模最佳的方法自变量与因变量之间的线性关系**。最简单的线性回归形式可由以下方程定义，该方程包含一个自变量和一个因变量:

简单线性回归

x 为自变量，
y 为因变量，
β 1 为 x 的系数，即斜率，
β 0 为截距(常数)，表示 y 轴上直线与原点的距离。

****线性回归是一种线性方法，用于模拟标量响应(或因变量)和一个或多个解释变量(或自变量)之间的关系。
——维基百科

线性回归类型

****1。简单线性回归——回归的最简单形式，涉及一个自变量和一个因变量，如上所述，我们在模型中拟合一条线。

2。多元线性回归 —回归的复杂形式，涉及多个自变量和一个因变量，可通过以下等式解释:

多元线性回归

x1 到 xn 为自变量，
y 为因变量，
β 1 到 β n 为各自 x 特征的系数，
β 0 为截距(常数)，表示 y 轴上直线距离原点的距离。

线性回归的假设

汤姆·罗伯茨在 Unsplash 上的照片

1。线性关系 —假设并理解自变量和因变量之间的关系是线性的，即系数必须是线性的，这是我们通过建模和预测发现的。

作者图片

预测变量被视为固定值，可以是任何复杂函数，如多项式、三角函数等。但是系数将与预测变量严格线性相关。

多项式回归

该假设用于实施多项式回归，其使用线性回归将响应变量拟合为预测变量的任意多项式函数，预测变量也与系数成线性关系。

****2。同方差(恒定方差)-假设残差项(即特征和目标之间关系中的“噪声”或随机扰动)必须具有恒定方差，即误差项在独立特征的不同值之间是相同的，与预测变量的值无关。

作者图片—已修改

分布中不应该有明确的模式，如果有特定的模式，数据就是异方差的。最左边的图显示了误差项之间没有明确的模式，即分布不断变化，而中间的图显示了误差随着估计值减小然后增大的模式，违反了恒定方差规则，并且最右边的图还显示了误差项随着预测值减小的特定模式，表示异方差。如果两个或多个正态分布共享一个公共协方差(或相关)矩阵，则它们是同方差的。

3。多元正态性 —假设误差项呈正态分布，即误差项的平均值为零，误差项之和也等于零。一个鲜为人知的事实是，随着样本量的增加，不再需要残差的正态性假设。

上面的 q-q 图表明误差或残差是正态分布的。误差项可以看作是一些微小残差或误差的合成。随着这些小残差数量的增加，误差项的分布趋于接近正态分布。这种趋势被称为中心极限定理，其中 t 检验和 f 检验仅在误差项呈正态分布时适用。

****4。无多重共线性-多重共线性定义为模型中使用的独立变量之间的相互关联程度。假设独立特征变量彼此之间根本不相关或者非常不相关，这使得它们是独立的。因此，在实际实施中，两个独立特征之间的相关性不得大于 30%，因为这会削弱所建模型的统计能力。为了识别高度相关的特征，可以使用成对图(散点图)和热图(相关矩阵)。

相关热图—作者提供的图片

高度相关的特征不应用于模型中，以保持模型与其所有特征之间的紧密关系，因为这些特征往往会一致变化。因此，随着一个特征的改变，相关特征的改变不会使后者如模型所要求的那样恒定，同时使用加权系数预测结果，并且回归系数的预期解释不符合。

5。无自相关 —假设数据中的特征之间不存在自相关。它主要发生在残差之间存在相关性的时候，即残差不应该正相关或负相关，并且应该具有良好的整体分布。这通常发生在下一个时刻依赖于前一个时刻的时间序列模型中。残差项中相关性的存在也降低了模型的可预测性。

自相关可以在杜宾-沃森测试的帮助下进行测试。德宾-沃森检验统计量定义为:

德宾-沃森方程

Durbin-Watson 检验统计量的值总是在 0 到 4 之间。精确值 2.0 表示在样本中没有检测到自相关。介于 0 和 2 之间的值表示正自相关，介于 2 和 4 之间的值表示负自相关。

6。无外推 —外推是一种可以存在于原始观测范围之外的估计。假设已训练的模型将能够仅针对位于训练数据范围内的数据，根据独立特征值来预测因变量的值。因此，模型不能保证预测值超出训练好的独立特征值的范围。

作者图片—已修改

结论:

我们已经解释了在对给定数据集实施线性回归模型之前必须关注的最重要的假设。这些假设只是一种正式的措施，以确保所建立的线性回归模型的可预测性足够好，从而为我们提供给定数据集的最佳可能结果。如果不满足这些假设，将不会停止建立线性回归模型，但会为模型的可预测性提供良好的信心。

感谢阅读。你可以在这里找到我的其他机器学习相关的帖子。

希望这篇帖子有用。我感谢反馈和建设性的批评。如果你想谈论这篇文章或其他相关话题，你可以在这里或在 LinkedIn 给我发短信。

** [## 是什么让逻辑回归成为一种分类算法？

对数优势，基线的逻辑回归解释。

towardsdatascience.com](/what-makes-logistic-regression-a-classification-algorithm-35018497b63f) [## 机器学习中最常见的损失函数

每个机器学习工程师都应该了解机器学习中这些常见的损失函数，以及何时使用…

towardsdatascience.com](/most-common-loss-functions-in-machine-learning-c7212a99dae0)**

线性回归的假设

原文：https://towardsdatascience.com/assumptions-of-linear-regression-5d87c347140?source=collection_archive---------0-----------------------

以及如何使用 Python 测试它们。

线性回归是回归模型的自行车。这很简单，但非常有用。它可以用于各种领域。它有一个很好的封闭解，这使得模型训练成为一个超快速的非迭代过程。

线性回归模型的性能特征已被充分理解，并得到数十年严格研究的支持。该模型的预测很容易理解，很容易解释，也很容易辩护。

如果只有一个回归模型，你有时间彻底了解，它应该是线性回归模型。

如果您的数据满足线性回归模型(特别是普通最小二乘回归(OLSR)模型)的假设，在大多数情况下，您不需要做进一步的调查。

这就引出了 OLSR 模型的以下四个假设:

  1. 线性函数形式:响应变量 y 应该是与解释变量 X. 线性相关
  2. 残差应为 i.i.d.: 在训练数据集上拟合模型后，模型的残差应为独立同分布的随机变量。
  3. 残差应呈正态分布:残差应呈正态分布。
  4. 残差应该是同方差的:残差应该是恒方差的。

让我们详细看看这四个假设，以及如何检验它们。

假设 1:线性函数形式

线性几乎不需要解释。毕竟，如果您选择进行线性回归，您就假设基础数据呈现线性关系，特别是以下线性关系:

y=βx+ϵ*

其中 y 为因变量向量， X 为包含截距的解释变量矩阵， β 为回归系数向量，为误差项向量，即 y 中的 X

如何使用 Python 测试线性假设

这可以通过两种方式实现:

  1. 一种简单的方法是相对于每个解释变量【x _ j】绘制 y ，并目视检查散点图的非线性迹象。
  2. 人们还可以使用 Pandas 中的DataFrame.corr()方法来获得响应变量和每个解释变量 x_j 之间的皮尔逊相关系数‘r’，以获得线性相关程度的定量感受。**

请注意，只有当 y 和 X 之间的关系已知为线性时，才应使用皮尔逊的‘r’。

让我们对联合循环发电厂的 4 个运行参数的 9568 个观测值的以下数据集进行线性假设测试，这些观测值持续了 6 年时间:

数据来源: UCI 机器学习知识库

解释变量 x_j 为以下 4 个电厂参数:

****环境温度摄氏度
排气容积水银柱高度
厘米环境压力毫巴水银柱
相对湿度百分比

响应变量 y 是电厂的 Power_Output ，单位 MW。

让我们将数据集加载到熊猫数据框架中。

****import** pandas **as** pd
**from** patsy **import** dmatrices
**from** matplotlib **import** pyplot **as** plt
**import** numpy **as** npdf = pd.**read_csv**('power_plant_output.csv', **header**=0)**

绘制每个解释变量相对于响应变量 Power_Output 的散点图。

**df.**plot**.**scatter**(**x**='Ambient_Temp', **y**='Power_Output')
plt.**xlabel**('Ambient_Temp', **fontsize**=18)
plt.**ylabel**('Power_Output', **fontsize**=18)
plt.**show**()df.**plot**.**scatter**(**x**='Exhaust_Volume', **y**='Power_Output')
plt.**xlabel**('Exhaust_Volume', **fontsize**=18)
plt.**ylabel**('Power_Output', **fontsize**=18)
plt.**show**()df.**plot**.**scatter**(**x**='Ambient_Pressure', **y**='Power_Output')
plt.**xlabel**('Ambient_Pressure', **fontsize**=18)
plt.**ylabel**('Power_Output', **fontsize**=18)
plt.**show**()df.**plot**.**scatter**(**x**='Relative_Humidity', **y**='Power_Output')
plt.**xlabel**('Relative_Humidity', **fontsize**=18)
plt.**ylabel**('Power_Output', **fontsize**=18)
plt.**show**()**

这是四个情节的拼贴画:

每个解释变量的功率输出散点图(图片由作者提供)

可以看到，环境温度和排气体积似乎与发电厂的功率输出线性关系最大，其次是环境压力和相对湿度。

让我们也打印出皮尔逊的“r”:

**df.corr()['Power_Output']**

我们得到以下输出，这支持了我们的视觉直觉:

**Ambient_Temp        -0.948128
Exhaust_Volume      -0.869780
Ambient_Pressure     0.518429
Relative_Humidity    0.389794
Power_Output         1.000000
Name: Power_Output, dtype: float64**

相关阅读: 相关性背后的直觉 ，对皮尔逊相关系数的深入讲解。

假设 2: i.i.d .残差

人们在拟合 OLSR 模型时作出的第二个假设是，模型拟合数据留下的残差是独立、同分布** 随机变量。**

我们将这一假设分为三部分:

  1. 残差是随机变量，
  2. 它们是独立的随机变量，并且
  3. 它们的概率分布是相同的。

为什么残差是随机变量？

在我们对数据集训练线性回归模型之后，如果我们通过相同的模型运行训练数据，该模型将生成预测。姑且称之为 y_pred。 对于向量 y_pred 中的每个预测值 y_pred ，从响应变量向量 y 中都有对应的实际值 y 。差值 (y — y_pred) 为残差' ε' 。这些 ε 的数量与训练集中的行数一样多，它们一起形成残差向量 ε 。

每个残差 ε 都是一个随机变量。要理解为什么，回想一下我们的训练集 (y_train，X_train) 只是从一些非常大的值总体中抽取的 n 值的样本。

如果我们从相同的总体中抽取不同的样本(y _ train’，X _ train’)，那么模型对第二个样本的拟合会有所不同，从而产生一组不同的预测【y _ pred’，并因此产生一组不同的残差=【y’—y _ pred’)**

在对模型进行训练之后，从总体中抽取的第三训练样本将会产生第三组残差ε=(y″—y _ pred″)、** 等等。**

现在可以看到，向量 ε 中的每个残差可以从与人们愿意用来训练模型的样本训练数据集的数量一样多的值集中取随机值，从而使每个残差 ε 成为随机变量。

为什么残差需要独立？

两个随机变量是独立的，如果其中一个取某个值的概率不依赖于另一个变量取的值。当你掷一个骰子两次时，它在第二次掷出 1，2，…，6 的概率并不取决于它在第一次掷出的数值。所以这两次投掷是独立的随机变量，可以各自取 1 到 6 的值，与另一次投掷无关。

在回归的背景下，我们已经看到了为什么回归模型的残差是随机变量。如果残差不是独立的，它们可能会表现出某种模式(肉眼并不总是很明显)。这种模式中有回归模型在对训练集进行训练时无法捕获的信息，从而使模型达不到最优。

如果残差不是独立的，这可能意味着很多事情:

  • 您的模型中缺少一个或多个重要的解释变量。缺失变量的影响表现为残差中的一种模式。
  • 你建立的线性模型只是数据集的错误模型。例如，如果数据集显示出明显的非线性，并且您试图在这样的数据集上拟合线性回归模型，那么 y 和 X 之间的非线性关系将以不同模式的形式在回归的残差中表现出来。
  • 残差不独立的第三个有趣原因是所谓的多重共线性，这意味着解释变量本身彼此线性相关。多重共线性会导致模型的系数变得不稳定，也就是说，当在不同的训练集上进行训练时，它们会从一次训练运行到下一次训练运行之间剧烈波动。这可能会使模型的总体拟合优度统计数据受到质疑。多重共线性(尤其是极端多重共线性)的另一个严重影响是，模型的最小二乘求解器可能会在模型拟合过程中抛出无穷大，从而使模型无法拟合定型数据。

如何检验残差的独立性？

核实独立性并不容易。但是有时可以在残差与预测值的图或残差与实际值的图中检测到模式。

另一种常用技术是使用杜宾-沃森测试，该测试测量每个残差与“先前”残差的相关程度。这就是所谓的滞后-1 自相关，这是一种用于确定时间序列回归模型的残差是否独立的有用技术。

让我们用一个线性回归模型来拟合电厂数据，并检验回归的残差。

我们将开始使用 Patsy 库创建模型表达式，如下所示:

**model_expr = 'Power_Output ~ Ambient_Temp + Exhaust_Volume + Ambient_Pressure + Relative_Humidity'**

在上面的模型表达式中，我们告诉 Patsy，Power_Output 是响应变量，而 Ambient_Temp、Exhaust_Volume、Ambient_Pressure 和相对湿度是解释变量。Patsy 将默认添加回归截距。

我们将使用 patsy 雕刻出如下的 y 和 X 矩阵:

**y, X = **dmatrices**(model_expr, df, **return_type**='dataframe')**

让我们也划分出训练和测试数据集。训练数据集将是整体大小的 80%(y，X** )，其余将是测试数据集:**

**mask = np.**random**.rand(**len**(X)) < 0.8
X_train = X[mask]
y_train = y[mask]
X_test = X[~mask]
y_test = y[~mask]**

最后，在训练数据上建立和训练普通最小二乘回归模型，并打印模型摘要:

**olsr_results = linear_model.**OLS**(y_train, X_train).fit()
print(**'Training completed'**)

print(olsr_results.summary())**

我们得到以下输出:

statsmodels 打印出的 OLS 回归输出(图片由作者提供)

接下来，让我们获得模型在测试数据集上的预测，并获得其预测:

**olsr_predictions = olsr_results.**get_prediction**(X_test)**

olsr_predictions 是类型stats models . regression . _ prediction。预测结果和预测可以通过prediction result . summary _ frame()方法获得:

**prediction_summary_frame = olsr_predictions.**summary_frame**()
print(prediction_summary_frame)**

模型的预测和 95%的上下置信水平(图片由作者提供)

我们来计算回归的残差ε=*(y _ test—y _ pred)😗****

**resid = y_test['Power_Output'] - prediction_summary_frame['mean']**

最后，让我们对照预测值y_pred=prediction_summary_frame[‘mean’]绘制resid :

**plt.xlabel('Predicted Power Output', fontsize=18)
plt.ylabel('Residual Error of Regression', fontsize=18)
plt.scatter(y_test['Power_Output'], resid)
plt.show()**

我们得到如下的情节:

根据模型预测绘制的残差(图片由作者提供)

可以看出，对于较小的功率输出值，残差或多或少是无模式的，但在功率输出范围的高端，它们似乎显示出线性模式。它表明，在功率输出范围的高端，模型的预测不如在范围的低端可靠。

****为什么残差应该有相同的分布？

同分布意味着对应于每个数据行的预测的残差 ε_i 具有相同的概率分布。如果误差分布不一致，就不能可靠地使用显著性检验，如用于回归分析的 F 检验 或对预测进行置信区间检验。这些测试中有许多依赖于残差相等，并且正态分布。这让我们想到了下一个假设。

假设 3:残差应该是正态分布的

在上一节中，我们看到了如何以及为什么回归的残差被假设为独立的同分布(i.i.d .)随机变量。假设 3 强加了一个额外的约束。这些误差应该都具有均值为零的正态分布。用统计语言来说:

∀ i ∈ n，ε_i ~ N(0， σ)

这一符号读作如下:

对于长度为 n 行的数据集中的所有 i ，回归的第 I 个残差是一个正态分布的随机变量(这就是为什么用 N ()表示)。这个分布的均值为零，方差为σ。此外，所有的 ε_i 具有相同的方差σ ，即它们是同分布的。

一个常见的误解是，线性回归模型要求解释变量和响应变量呈正态分布。

x_j 和 y 往往甚至不会同分布，更不用说正态分布了。

在线性回归中，只有回归的残差才需要正态性。

事实上，残差的正态性甚至不是严格要求的。如果残差不是正态分布的，那么你的回归模型不会出现可怕的错误。常态只是一种可取的性质。

通常告诉你的是，你的模型的大多数预测误差是零或接近零，大误差比小误差少得多。

如果残差不是 N(0，σ ) 分布会怎么样？

如果回归的残差不是 N(0，σ ) ，那么依赖于具有 N(0，σ ) 分布的误差的显著性的统计测试就简单地停止工作。

举个例子，

  • 只有当回归误差分布为 *N(0，σ)时， F 检验用于回归分析 的 F 统计量才具有所需的卡方分布。如果回归误差不是正态分布的，f 检验不能用于确定模型的回归系数是否共同显著。然后你将不得不使用一些其他的测试来找出你的回归模型是否比通过数据集均值的直线做得更好。***
  • 同样， t 值和置信区间 的计算假设回归误差为 N(0，σ ) 分布。如果回归误差不是正态分布的，模型系数和模型预测的 t 值将变得不准确，您不应过于相信系数或预测的置信区间。

非正态的一个特例:双峰分布残差

有时，人们发现模型的残差具有双峰分布，即它们有两个峰值。这可能指向一个错误指定的模型，或者模型中缺少一个重要的解释变量。****

例如，考虑以下情况:

您的因变量是一个二进制变量，如 Won(编码为 1.0)或 Lost(编码为 0.0)。但是你的线性回归模型将会产生连续实数范围的预测。如果模型沿着大约 0.5 的该标度的狭窄范围产生其大部分预测，例如 0.55、0.58、0.6、0.61 等。回归误差的峰值要么在零的一侧(当真值为 0 时)，要么在零的另一侧(当真值为 1 时)。这表明您的模型无法决定输出应该是 1 还是 0，因此它预测的值大约是 1 和 0 的平均值。

如果缺少一个关键的二进制变量(称为指示变量),就会发生这种情况，它会以下列方式影响输出值:

当变量值为 0 时，输出范围在一定范围内，比如接近 0。

当变量的值为 1 时，输出会呈现一个全新的值范围，这是以前的范围所没有的，比如 1.0 左右。

如果模型中缺少此变量，预测值将在两个范围之间取平均值，从而导致回归误差出现两个峰值。一旦添加了这个变量，模型就被很好地指定了，它将正确地区分解释变量的两个可能范围。

****Related read: [**When Your Regression Model’s Errors Contain Two Peaks**](/when-your-regression-models-errors-contain-two-peaks-13d835686ca)****

如何检验残差的正态性？

有许多可用的正态性检验。检查正态性最简单的方法是测量残差分布的偏度和峰度。

完美正态分布的偏度为 0，峰度为 3.0。

任何偏离，无论是正的还是负的，都表明偏离了常态。当然不可能得到完美的正态分布。预计会出现一些偏离常态的情况。但是“一点点”的离开是多少呢？如何判断离职是否重大？

偏离是否显著由正态性的统计检验来回答，如 Jarque Bera 检验和综合检验。这些测试中的 p 值≤ 0.05 表示分布在≥ 95%的置信水平下为正态分布。

让我们在电厂数据集上训练的线性回归模型上运行 Jarque-Bera 正态性测试。回想一下，残留误差存储在变量resid中，它们是通过对测试数据运行模型并从观测值 y_test 中减去预测值 y_pred 而获得的。

******from** statsmodels.compat **import** lzip
**import** statsmodels.stats.api **as** smsname = ['Jarque-Bera test', 'Chi-squared(2) p-value', 'Skewness', 'Kurtosis']**#run the Jarque-Bera test for Normality on the residuals vector** test = sms.**jarque_bera**(resid)**#print out the test results. This will also print the Skewness and Kurtosis of the resid vector** lzip(name, test)****

这会打印出以下内容:

****[('**Jarque-Bera test**', 1863.1641805048084), ('**Chi-squared(2) p-value**', 0.0), ('**Skewness**', -0.22883430693578996), ('**Kurtosis**', 5.37590904238288)]****

残差的偏斜度为-0.23，峰度为 5.38。Jarque-Bera 测试得出的 p 值是< 0.01 and thus it has judged them to be respectively different than 0.0 and 3.0 at a greater than 99% confidence level thereby implying that the residuals of the linear regression model are for all practical purposes not normally distributed.

Let’s plot the frequency distribution of the residual errors:

****resid.**hist**(**bins**=50)
plt.show()****

We get the following histogram showing us that the residual errors do seem to be normally distributed (but the JB has shown that they are in fact not so):

Frequency distribution of residual errors (Image by 作者

相关阅读: 用偏度和峰度检验正态性 ，关于正态性的深入解释和正态性的统计检验。

相关阅读: 当你的回归模型的误差包含两个峰值 : 一个关于处理双峰残差的 Python 教程。

假设 4:残差应该是同方差的

在上一节中，我们看到了为什么残差应当为 N(0，σ ) 分布，即均值为零且方差为 σ的正态分布。在本节中，我们对它们施加了一个额外的约束:方差σ应该是常数。特别是，σ不应该是响应变量 y 的函数，从而间接地是解释变量 X 的函数。****

一个数据集具有恒定方差的性质叫做。而与之相反，其中方差是解释变量 X 的函数称为 异方差 。****

下面是一组显示同方差的数据:

同方差的例子(图片由作者提供)

这是一个显示异方差的例子:

异方差的例子(图片由作者提供)

在谈论同方差或异方差时，我们总是考虑条件方差:Var(y|X=X _ I，或者 Var(ε|)这读作 y 的方差或 ε 对于X=X _ I的某个值。******

相关阅读: 每个数据科学家都应该知道的三个条件: 条件期望、条件概率&条件方差:回归建模者的实用见解

为什么我们希望残差是同方差的？

残差具有作为 y (因此 X )的函数的方差的直接后果是残差不再是同分布的。每个 X=x_i 的 ε 的方差会不同，从而导致 ε中每个 ε_i 的概率分布不相同。

我们已经看到，如果残差不是同分布的，我们就不能使用显著性检验，例如用于回归分析的 F 检验 ，或者对回归模型的系数或模型预测执行置信区间检查。许多这些测试依赖于独立的残差，同分布的随机变量。

什么会导致残差是异方差的？

当线性模型拟合到响应变量 y 的波动是当前值 y 的某个函数的数据时，异方差误差经常出现，例如，它是当前值 y 的百分比。这种数据集通常出现在货币领域。一个例子是公司股票价格的绝对变动量与当前股票价格成比例。另一个例子是某些产品销售的季节性变化与销售水平成正比。

数据收集过程中的错误也会引入异方差。例如，如果测量仪器在测量值中引入与测量值成比例的噪声，则测量值将包含异方差。

模型误差中引入异方差的另一个原因是简单地对数据集使用了错误的模型，或者遗漏了重要的解释变量。

如何修复模型残差中的异方差？

处理异方差误差有三种主要方法:

  1. 转换因变量，使其线性化，并抑制异方差。常用的变换有对数(y)和平方根(y)。****
  2. 确定模型中可能缺失的重要变量，以及导致误差变化以形成模式的变量，并将这些变量添加到模型中。或者，停止使用线性模型，切换到完全不同的模型，如广义线性模型或神经网络模型。
  3. 简单地接受残差中存在的异方差。

如何检测残差中的异方差？

有几种检验同质性的方法。以下是一些例子:

使用 Python 测试异方差

让我们通过使用怀特测试来测试模型的异方差残差。我们将使用之前建立的线性模型中的误差来预测发电厂的输出。

异方差的白色测试使用以下推理来检测异方差:

  1. 如果残差 ε 是异方差的，则它们的方差可以由【y】(因此由模型的解释变量 X 及其平方( X ) 和叉积(X*)的组合来“解释”*****
  2. 因此，当在误差 ε 和 (X ， X ，XXX)上拟合辅助线性模型时，期望辅助线性模型将能够解释至少一些关系，即**
  3. 如果我们对辅助模型运行回归的 F 检验 ，并且 f 检验返回≤ 0.05 的 p 值，这将使我们接受 f 检验的替代假设，即辅助模型的系数共同显著。因此，拟合的辅助模型是确实能够捕捉主模型的残差 ε 和模型的解释变量之间的有意义的关系。这使我们得出结论，主模型 ε 的残差是异方差的。****
  4. 另一方面，如果 f 检验返回 p 值≥ 0.05，那么我们接受 f 检验的零假设，即主模型的残差 ε 与模型的解释变量 X 之间没有有意义的关系。因此，主模型 ε 的残差是同方差的。

让我们对之前在测试数据集上运行拟合电厂输出模型时获得的残差进行白色测试。这些残留误差存储在变量resid.中

*******from** statsmodels.stats.diagnostic **import** het_whitekeys = ['Lagrange Multiplier statistic:', 'LM test\'s p-value:', 'F-statistic:', 'F-test\'s p-value:']**#run the White test**
results = **het_white**(resid, X_test)**#print the results. We will get to see the values of two test-statistics and the corresponding p-values**
**lzip**(keys, results)*****

我们看到以下几点:

*****[('**Lagrange Multiplier statistic:**', 33.898672268600926), ("**LM test's p-value:**", 2.4941917488321856e-06), ('**F-statistic:**', 6.879489454587562), ("**F-test's p-value:**", 2.2534296887344e-06)]*****

您可以看到，回归的 f 检验返回的 p 值为 2.25e-06，比 0.01 还要小得多。

因此，在 99%的置信度下，我们可以说白色测试使用的辅助模型能够解释主要模型的残差resid和主要模型的解释变量(在这种情况下为X_test)之间的有意义的关系。****

因此，我们拒绝 f 检验的零假设，即电厂输出模型的残差是异方差的，而接受另一个假设，即模型的残差是异方差的。****

回想一下，我们在残差与预测值 y_pred 的关系图中看到了以下各种线性模式:

残差与预测值(图片由作者提供)

从这个图中，我们应该预期我们的线性模型的残差是异方差的。白测正好印证了这个预期！

相关阅读: 异方差没什么可怕的 深入了解异方差及其后果。

延伸阅读: 非线性、异方差数据的稳健线性回归模型:Python 中的分步教程

摘要

普通最小二乘回归模型(也称为线性回归模型)是一种简单而强大的模型，可用于许多真实世界的数据集。

OLSR 模式有着坚实的理论基础。它的预测是可以解释和辩护的。

为了充分利用 OLSR 模型，我们需要做出并验证以下四个假设:

  1. 响应变量 y 应该与解释变量 X 线性相关。****
  2. 回归的残差应该是独立、同分布的随机变量。****
  3. 残差应该是正态分布的。
  4. 残差应该具有恒定的方差，即它们应该是同方差的。****

相关阅读

***** [## 非线性异方差数据的稳健线性回归模型

Python 的分步教程

towardsdatascience.com](/robust-linear-regression-models-for-nonlinear-heteroscedastic-data-14b1a87c1952) [## 相关性背后的直觉

两个变量相关到底意味着什么？我们将在本文中回答这个问题。我们还将…

towardsdatascience.com](/the-intuition-behind-correlation-62ca11a3c4a) [## 异方差没有什么可怕的

使用 Python 的原因、影响、测试和解决方案

towardsdatascience.com](/heteroscedasticity-is-nothing-to-be-afraid-of-730dd3f7ca1f)

引用和版权

联合循环电厂数据集:从 UCI 机器学习库下载，用于以下引用请求:

  • p NAR tüfek ci，使用机器学习方法预测基本负荷运行的联合循环发电厂的满负荷电力输出，国际电力和能源系统杂志，第 60 卷，2014 年 9 月，第 126–140 页，ISSN 0142–0615，，，
    ( ，)
  • Heysem Kaya，pnar tüfek ci，sadk fik ret gürgen:预测燃气和蒸汽联合涡轮机功率的本地和全球学习方法，计算机和电子工程新兴趋势国际会议论文集，2012 年，第 13–18 页(2012 年 3 月，迪拜

感谢阅读！如果您喜欢这篇文章，请 关注我 获取关于回归和时间序列分析的技巧、操作方法和编程建议。*****

小行星计划(第二部分)——测试驱动开发

原文：https://towardsdatascience.com/asteroid-project-part-2-test-driven-development-ed7af6c1820e?source=collection_archive---------38-----------------------

用 Python 进行空间科学

系列教程的第 22 部分继续我们科学项目的第二部分。在我们深入研究 Python 和近地对象之前，让我们看一下测试驱动开发

照片由马库斯·斯皮斯克在 Unsplash 拍摄

前言

这是我的 Python 教程系列“用 Python 进行空间科学”的第 22 部分。教程会话中显示的所有代码都上传到GitHub上。尽情享受吧！

介绍

不，我们还没有开始任何近地天体(NEO)相关的 Python 开发或实现。在砍树之前，我们需要先把斧子磨快。在我们的例子中:让我们深入一些开发概念，这些概念将导致一个可持续的长期项目和 Python 库。

你是怎么编码的？大多数开发人员(无论是业余程序员还是专业人士)都喜欢看到快速的结果；他们开发一个原型，一些可点击的界面，或者演示页面来实现第一个产品里程碑。在专业工作环境中，这也可能是由外部因素造成的，如截止日期、产品所有者、业务合作伙伴或期望在特定时间框架内获得结果的客户。由于专业背景和知识的不同，有些人可能会互相扯皮。

结果呢？例如:意大利面条代码测试不够好，难以维护、升级和理解！

在我们的科学项目中，我们希望开发一个可靠且可持续的 Python 解决方案。从事近地天体研究的业余或专业天文学家可以使用的工具。开发人员和编码人员也可以使用它来创建可以与库合并的新功能。

但是我们如何确保(从一开始)我们即将到来的库的可持续性和可维护性呢？嗯，除了适当的项目计划和项目结构( PEP8 格式化、 PEP257 和 Numpy Docstrings )之外，敏捷工作的世界中还有一个概念，它看起来很乏味，有些无聊……:测试驱动开发(TDD)。

测试驱动开发

TDD 逆转了“经典编程方法”。先编码后测试的范例变为先测试后编码。这些规则看似简单，却令人困惑:

  1. 为一个类/函数编写一个单独的(单元)测试/ …
  2. 编写产品代码以成功通过失败的单元测试
  3. 在所有单元测试成功之前，不要继续其他功能

这些都是苛刻的规定。首先，我需要为一个不存在的函数定义一个单元测试。这个测试显然失败了。现在我开发一些代码来成功完成单元测试。当测试通过后，另一个单元测试被添加，最终对同一功能再次证明其健壮性或泛型实现。它一次又一次地成功了吗？很好！您的功能似乎适合以后使用。如果没有，重新编码，直到所有测试都通过。

如果单个类或函数的所有单元测试都通过了，那么为编码项目的下一个元素定义并编写新的单元测试。

这种方法听起来可能很无聊。一个人想要在短时间内成就大事！为什么要用这种乏味的方法呢？开拓精神在哪里？即使你在做一个真正创新的产品或想法，你也需要基本的功能；完全独立于你想要达到的目标。测试第一确保你的工作有一个坚实的基础可以依靠。从长远来看，一个有几个初始错误的代码维护起来会更费时，例如，如果你的科学工作依赖于它…嗯…在最坏的情况下，你不得不撤回你的分析或数值模拟。

TDD 模式

凯文·Ku 在 Unsplash 上拍摄的照片

理论上，TDD 有三种工作/编码模式(这些模式很容易合并成另一种)。让我们假设您基于产品的需求创建了一个单元测试，并且您需要开发相应的产品代码:

  • 明显实现

显而易见的实现是最琐碎的模式。基于一个单元测试的例子，你可以清楚地得到一个通用的函数来解决问题。示例:存储为字符串的数值需要转换为实际的浮点数。您马上就会发现，通过应用 float('23.15 ')，可以将' 23.15 '转换为 23.15。

  • 假的吧

一个单元测试需要通过！你不知道如何做，所以你只是伪造结果！您设置一些常量，并返回断言测试所期望的硬编码答案。当然你造假(结果)。然而，基于这个虚假的常数，你试图回溯到实际的输入。最终，经过一些思考和研究，你会发现明显的实现在开始时并不明显。

  • 三角测量

Fake it 方法假设基于伪造常数和单个测试，开发人员将最终确定单元测试问题的通用解决方案。然而，如果一个问题太复杂，就需要更多的测试来覆盖更多的情况。越来越多的硬编码解决方案有助于三角测量特定问题的实际通用解决方案。假设您有从网站下载文件的任务。单元测试调用了一个函数，该函数需要返回一个类似“下载成功”的消息，但是您不知道从哪里开始。此时你可以伪造结果。创建一个包含下载功能的函数，创建一个带有条目“Download succeeded”的字符串并返回它。之后，添加另一个单元测试，例如下载的静态文件的散列值。同样，您通过伪造模拟文件的结果哈希值来再次伪造结果。越来越多的测试被添加进来，要求你检查服务器的响应等等。随着更多的测试和更多需要的功能，你开发的代码需要满足所有的长期需求。虚假的解决方案将转变为通用的解决方案。

重构和文档

最后，如果测试通过，考虑重构你的代码。在 Python 中，你应该遵循 PEP8 标准，确保高水平的代码样式…

[## PEP 8 风格的 Python 代码指南

Python 编程语言的官方主页

www.python.org](https://www.python.org/dev/peps/pep-0008/)

…提供注释以解释您的代码正在做什么，并提供 PEP257 风格(和/或 Numpy Doc 风格或您认为合适的其他风格)的文档:

[## PEP 257 -文档字符串约定

这个 PEP 的目的是标准化文档字符串的高层结构:它们应该包含什么，以及如何表达…

www.python.org](https://www.python.org/dev/peps/pep-0257/) [## numpydoc 文档字符串指南- numpydoc v1.2.dev0 手册

本文描述了用于 Sphinx 的 numpydoc 扩展的文档字符串的语法和最佳实践。注意…

numpydoc.readthedocs.io](https://numpydoc.readthedocs.io/en/latest/format.html)

重构和记录你的代码也会帮助你理解你自己的代码。也许有些部分包含单元测试没有涵盖的逻辑错误？也许你错过了一个重要的特征？编码、重构和文档化齐头并进。编程不应该是一个问题的纯粹抽象，还应该是人类可读的，以确保长期的可维护性和可持续性。

此外，剖析您的函数可以帮助您提高产品的性能。

结论与展望

今天我们讨论了测试驱动开发的一些基本原则，简称 TDD。TDD 将帮助我们为我们的空间科学近地天体项目开发一个可持续的 Python 库，提供经过测试的准确结果。在我们深入这个项目的科学部分之前，下次我们将看一个 TDD 的例子。在那里，我们将一步一步地完成提到的 TDD 过程，因为在项目过程中，你只会看到一些编码会话的结果和成功的单元测试(也许一个额外的视频博客会对一些感兴趣的读者有用？).

如果你纠结于编码，如果你迷失在自己的开发过程、对象和函数中，记得阅读 Python 的 Zen:

The Zen of Python, by Tim PetersBeautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one — and preferably only one — obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea — let’s do more of those!

托马斯

文献和参考资料

[## 测试驱动的开发——敏捷实践的实证评估

敏捷方法在工业界和研究界正获得越来越多的关注。许多行业正在转型…

www.springer.com](https://www.springer.com/de/book/9783642042874)

内存中敏感数据的非对称加密(Python)

原文：https://towardsdatascience.com/asymmetric-encrypting-of-sensitive-data-in-memory-python-e20fdebc521c?source=collection_archive---------22-----------------------

有时需要在读取和写入周期之间加密数据，例如，我们有一个设备可以获取敏感数据并记录下来进行处理。但是，由于数据存储在写入数据的同一设备上，我们不希望使用用于加密数据的同一密钥来解密数据。这就是我们使用非对称加密的原因。

照片由弗洛里安·奥利佛在 Unsplash 上拍摄

不对称加密

不对称加密对数据使用两个密钥(一个私钥和一个公钥)。这里，公钥用于每个单独的(易受攻击的)设备，仅用于加密数据。一旦加密，这些就不能被用来解密。然而，私钥是一个只提供给所有者的密钥，用于读取加密数据。也可以用私钥加密数据，这样就只能用公钥来读取数据，但这是一种不好的做法，会导致比它所解决的问题更多的问题。

密码学 python 包

我们将要使用的 python 包叫做cryptography，可以使用pip install cryptography来安装。

密钥生成

我们从导入所需的包开始:

**import** cryptography
**from** cryptography.hazmat.backends **import** default_backend
**from** cryptography.hazmat.primitives.asymmetric **import** rsa
**from** cryptography.hazmat.primitives **import** serialization

接下来，我们生成公钥和私钥。这些有两个参数—公共指数和密钥大小。公共指数是一个正质数(通常是65537)，密钥大小是模数的长度，以比特为单位(对于 2015 年的密钥，建议这些是>2048比特)

private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend()
)
public_key = private_key.public_key()

保存生成的密钥

要保存生成的密钥，我们必须首先对它们进行序列化，然后将它们写入文件:

# private key
serial_private = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.NoEncryption()
)
with open('private_noshare.pem', 'wb') as f: f.write(serial_private) # public key
serial_pub = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)
with open('public_shared.pem', 'wb') as f: f.write(serial_pub)

读取加密密钥

# make sure the following are imported
# from cryptography.hazmat.backends import default_backend
# from cryptography.hazmat.primitives import serialization#########      Private device only    ##########
def read_private (filename = "private_noshare.pem):
    with open(filename, "rb") as key_file:
        private_key = serialization.load_pem_private_key(
            key_file.read(),
            password=None,
            backend=default_backend()
        )
    return private_key

######### Public (shared) device only ##########
def read_public (filename = "public_shared.pem"):
    with open("public_shared.pem", "rb") as key_file:
        public_key = serialization.load_pem_public_key(
            key_file.read(),
            backend=default_backend()
        )
    return public_key

加密

为了存储一些敏感信息(例如一个人的体重),我们可以使用以下方法对其进行加密:

# make sure the following are imported
# from cryptography.hazmat.primitives import hashes
# from cryptography.hazmat.primitives.asymmetric import padding######### Public (shared) device only #########data = [b'My secret weight', b'My secret id']
public_key = read_public()open('test.txt', "wb").close() # clear file
for encode in data:
    encrypted = public_key.encrypt(
        encode,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )

    with open('test.txt', "ab") as f: f.write(encrypted)

[通信]解密

由于每个数据段都编码在相同数量的字节中，因此可以分块读取文件。这允许我们读取和解码每个数据块，重新创建原始数据集。

# make sure the following are imported
# from cryptography.hazmat.primitives import hashes
# from cryptography.hazmat.primitives.asymmetric import padding#########      Private device only    ##########read_data = []
private_key = read_private()with open('test.txt', "rb") as f:
    for encrypted in f:
        read_data.append(
            private_key.decrypt(
                encrypted,
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )))# >>> read_data = [b'My secret weight', b'My secret id']

结论

所以你有它，一个简单的方法来加密数据(在内存中)，面向公众的设备，这样你就需要一个单独的密钥来解码它了。

多处理 Python 中的异步并行编程

原文：https://towardsdatascience.com/asynchronous-parallel-programming-in-python-with-multiprocessing-a3fc882b4023?source=collection_archive---------12-----------------------

一种在个人计算机上加速代码的灵活方法

托马斯·索贝克在 Unsplash 上拍摄的照片

你希望你的 Python 脚本能运行得更快吗？也许他们可以。而且你不会(可能)不得不买一台新电脑，或者使用一台超级电脑。大多数现代计算机都包含多个处理核心，但默认情况下，python 脚本只使用一个核心。编写可以在多个处理器上运行的代码确实可以减少您的处理时间。本文将演示如何使用multiprocessing模块来编写并行代码，这些代码使用所有机器的处理器并提升脚本的性能。

同步与异步模型

异步模型在新资源可用时立即启动任务，而不等待之前运行的任务完成。相比之下，同步模型在开始任务 2 之前等待任务 1 完成。有关示例的更详细解释，请查看启动中的这篇文章。如果您能够以适当的方式构建代码，异步模型通常会为性能改进提供最大的机会。也就是说，任务可以彼此独立运行。

为了简洁起见，本文将只关注异步并行化，因为这是最有可能提升性能的方法。此外，如果您在笔记本电脑上为异步并行化构建代码，那么升级到超级计算机会容易得多。

装置

由于 Python 2.6 multiprocessing已经作为基础模块包含，所以不需要安装。简单来说就是import multiprocessing。因为“多重处理”需要一点时间来打字，所以我更喜欢import multiprocessing as mp。

问题是

我们有一组参数值，希望在灵敏度分析中使用。我们运行分析的函数计算量很大。我们可以通过同时并行运行多个参数来减少处理时间。

设置

导入multiprocessing、numpy和time。然后定义一个函数，将行号、i和三个参数作为输入。行号是必需的，以便以后可以将结果链接到输入参数。记住，异步模型不保持顺序。

import multiprocessing as mp
import numpy as np
import timedef my_function(i, param1, param2, param3):
    result = param1 ** 2 * param2 + param3
    time.sleep(2)
    return (i, result)

出于演示的目的，这是一个计算开销不大的简单函数。我添加了一行代码来暂停函数 2 秒钟，模拟长时间运行。函数输出对param1最敏感，对param3最不敏感。实际上，您可以用任何函数来替换它。

我们需要一个函数，可以将my_function的结果添加到一个结果列表中，这个函数被创造性地命名为results。

def get_result(result):
    global results
    results.append(result)

让我们以串行(非并行)方式运行这段代码，看看需要多长时间。用 0 到 100 之间的 3 列随机数建立一个数组。这些是将被传递给my_function的参数。然后创建空的results列表。最后，遍历params中的所有行，并将my_function到results的结果相加。计时，看看需要多长时间(大约 20 秒)，并打印出results列表。

if __name__ == '__main__':
    params = np.random.random((10, 3)) * 100.0
    results = []
    ts = time.time()
    for i in range(0, params.shape[0]):
        get_result(my_function(i, params[i, 0], params[i, 1],\
         params[i, 2]))
    print('Time in serial:', time.time() - ts)
    print(results)

正如所料，这段代码运行了大约 20 秒。另外，请注意结果是如何按顺序返回的。

Time in serial: 20.006245374679565
[(0, 452994.2250955602), (1, 12318.873058254741), (2, 310577.72144939064), (3, 210071.48540466625), (4, 100467.02727256044), (5, 46553.87276610058), (6, 11396.808561138329), (7, 543909.2528728382), (8, 79957.52205218966), (9, 47914.9078853125)]

并行运行

现在使用multiprocessing并行运行相同的代码。只需将下面的代码直接添加到串行代码的下面进行比较。为清晰起见，本文末尾包含了完整 Python 脚本的要点。

重置results列表，使其为空，并重置开始时间。我们需要指定我们想要使用多少个 CPU 进程。multiprocessing.cpu_count()返回机器可用的全部进程。然后循环遍历params的每一行，使用multiprocessing.Pool.apply_async 调用my_function并保存结果。使用apply_async的args参数传递my_function的参数，回调函数是发送my_function结果的地方。这将在一个新进程可用时立即开始一个新进程，并继续这样做，直到循环完成。然后关闭进程池。等待执行任何后续代码，直到所有进程都运行完毕。现在打印这段代码运行的时间和结果。

results = []
ts = time.time()
pool = mp.Pool(mp.cpu_count())
for i in range(0, params.shape[0]):
    pool.apply_async(my_function, args=(i, params[i, 0], params[i,\
     1], params[i, 2]), callback=get_result)
pool.close()
pool.join()
print('Time in parallel:', time.time() - ts)
print(results)

注意，使用apply_async将运行时间从 20 秒减少到 5 秒以下。另外，请注意，结果没有按顺序返回。这就是传递并返回行索引的原因。

Time in parallel: 4.749683141708374
[(0, 452994.2250955602), (2, 310577.72144939064), (1, 12318.873058254741), (3, 210071.48540466625), (4, 100467.02727256044), (5, 46553.87276610058), (6, 11396.808561138329), (7, 543909.2528728382), (9, 47914.9078853125), (8, 79957.52205218966)]

结论

对代码实现异步并行化可以大大减少运行时间。multiprocessing模块是在个人计算机上进行并行化的一个很好的选择。正如您在本文中看到的，根据您的机器规格，您可以获得显著的速度提升。如果你最终想升级到超级计算机，请注意multiprocessing有局限性。如果您的目标是超级计算，那么您会希望使用与消息传递接口(MPI)兼容的并行化模型。

不对称不是平行

原文：https://towardsdatascience.com/asyncio-is-not-parallelism-70bfed470489?source=collection_archive---------14-----------------------

你可能听说过 Python asyncio 是并发的，但不是并行编程。但是怎么做呢？我用简单的例子解释一下。

让我们从一个完美的并发例子#1 开始。

异步函数 say_after 是 Python 官方文档中的一个例子。它在休眠“延迟”秒后打印出“什么”。

在 main 函数中，我们创建了 say_after 的两个任务，一个在 1 秒后说‘hello’，另一个在 2 秒后说‘world’。运行它，我们看到它总共用了 2 秒钟，因为两个任务同时运行。完美！

主功能没有延迟

但是它们平行吗？让我们用更多的例子来理解并发性和并行性之间的区别。

示例 2:

我们将主函数替换如下。

如您所见，我们在创建任务后添加了一个 print 来检查任务是否在创建后立即启动，并在 main 函数中添加了一个 0.5 秒后的异步 sleep。注意 main 本身就是一个任务(协程确切地说)。

以下是输出:

主模式下异步睡眠 0.5s

第一，总共还是 2 秒，没有变化。它同时运行主任务和另外两个 say_after 任务。主服务器中的异步睡眠没有阻塞。

第二，“延迟前—创建任务后”在开始 say_after 任务前打印。是啊！创建的任务在创建后并不立即开始，而是由安排在所谓的事件循环中运行。它们仅在主任务等待时启动，即本例中的await asyncio.sleep(0.5)。根据我的理解，你不能控制任务的执行顺序，即优先级。

例 3:

主模式下阻止睡眠 0.5

在这个例子中，我们用 time.sleep 替换了 asyncio.sleep，time . sleep 等待 main 中的阻塞，并查看 say_after 任务何时开始。

看到总数现在是 2.5 秒。task1 在创建后 0.5 秒开始。很明显，任务不是并行的，即同时执行。

实施例 4:

你可能会争论应该用 asyncio.sleep 代替 time.sleep 用 asyncio 编程。主要任务正在做某事并导致延迟，这是怎么回事？

干线环路延迟 1 秒

在这个例子中，我们用一个循环替换 time.sleep，在主任务中增加大约 1 秒的延迟。

你可以看到我们得到了相似的结果。say_after 任务延迟开始，总时间变为 3 秒。

例 5:

如果一项任务开始了，它能保证在预期的时间内结束吗？不要！
下面我们来看看这个例子。

time.sleep 主模式 3s

我们在第 7 行中使用 asyncio.sleep(0.1)来允许 task1 和 task2 启动，但是在第 8 行中添加 time.sleep(3)来阻止 3 秒钟。
以下是输出:

您可以在第 3 行和第 4 行看到两个任务都立即开始，但不是在预期的 1 秒或 2 秒后“说”，而是在 3 秒后“说”(结束)。

原因是当 say_after 等待 1 / 2 秒时，事件循环返回到主任务并在那里阻塞 3 秒钟，然后才能返回到 say_after 任务继续。

你可以在这里找到完整的演示文件。

结论

Asynicio 尽最大努力做到并发，但它不是并行的。

您无法控制任务的开始和结束。

如果您在任务创建后立即等待任务，您可以控制启动，如下所示，但是它变成了同步编程，这对于异步目的没有意义。请注意，即使这不是 100%的保证，并认为自己。

task1 = asyncio.create_task(say_after(1, ‘hello’))
await task1

因此，如果你正在开发一个对时间敏感的应用程序，避免使用 asyncio(广义上的协程事件循环)。这种限制的原因是事件循环只使用一个线程来调度多个任务。

供选择的

那么并行的解决方案是什么呢？穿线。

这是示例 5 的等效代码，它在主函数中有 3 秒钟的睡眠阻塞。

输出如下所示。

3 秒延迟的线程输出

看到 task1 和 task2 都立即开始，并在预期的 1 秒和 2 秒内结束。

您也可以使用多处理来利用多个 CPU 内核。

最后，我并不是说您不应该使用事件循环，它在处理网络流量时非常有用。但这取决于你的需要。

Linkedin

在地理和数据科学的交叉点上

原文：https://towardsdatascience.com/at-the-intersection-of-geography-data-science-5cd065e7bf22?source=collection_archive---------35-----------------------

地理正在卷土重来，这要归功于数据科学

安妮·斯普拉特在 Unsplash 上的照片

地理，就像地图之类的东西，对吧？

如果你在成长过程中学习地理的经历和我一样，那么你也可以说出(几乎)所有 50 个州及其相应的首府。也许如果你不是美国人，你可以说出你国家的不同省份及其首府，甚至更多。让我们为此给自己一点鼓励吧！当我告诉你我决定主修“命名美国首都”这个领域，也就是更广为人知的“地理学”时，你可能不会感到震惊，我得到的是许多茫然的目光。据我所知，大多数美国人对你仍然可以在大学主修地理感到惊讶。相信我，我也是！我不认为我们需要更多的地图，或者美国的首都。

在大学的最后一个季度，我接触到了地理信息系统(GIS)，有些人可能会称之为现代制图。由于没有留下来学习 GIS 和支付更多学费的愿望，我毕业时错过了可能是我在地理学位中唯一可以获得的硬技能的机会。五年后，我进入了更广阔的数据科学领域，并结合 Python 的新知识，重新学习了 GIS 的奇迹和威力。事情是这样的，在我看来，地图永远不会无趣(好的地图，那是)。

GIS 的现代进步

现在是 2005 年，而“世界上只有 15%的地区被绘制到了地理编码的详细程度”( Lalitesh Katragadda，TEDIndia 2009 )。这还不包括海洋或海底测绘，如果我需要提醒你的话，它们占地球表面的 71%。因此，只有 29%的地球表面中的 15%被精确地绘制到那个点上。跳到 2020 年的今天，谷歌声称已经绘制了地球上 98%的地图。谷歌的街景在 2007 年才开始，所以在很短的时间内涵盖了大量的文字内容。这些进步是天文数字，也许超过了摩尔定律的速度。

“绘制世界地图是不可能的——我们选择并制作图形，以便我们能够理解它”——罗杰·汤姆林森，1981 年的一份议程笔记

但是，对于所有这些不断积累的结构化和非结构化地理空间数据，您能做些什么呢？我们用这些数据在做什么？可能性令人眼花缭乱，当然，正如任何强大的工具一样，伦理在谁有权使用它以及如何使用它方面发挥着重要作用(本文触及了 GIS 的一些黑暗起源和军国主义目的)。自 20 世纪 60 年代 GIS 首次出现以来，世界各地的机器学习和人工智能工程师已经将地图绘制技术提升到了新的高度。

照片由尼克·舒利亚欣在 Unsplash 上拍摄

地图不仅帮助我们导航，以最有效的方式把我们从 A 点带到 B 点。但是，随着我们今天拥有的数据量的增加，地图正在我们这个时代一些最前沿和最具创新性的项目中得到应用。这让我既兴奋又紧张。如果您有兴趣了解更多的历史和现代进步，请查看这个很酷的交互式 GIS 时间轴。

我兴奋什么？

应对气候变化

我们中的许多人都熟悉我们看到的世界各地海平面上升的地图，以及由于极地冰盖的快速融化而将遭受苦难的沿海城市和岛国。当然，理解和应对气候变化的最佳方式是能够看到我们的世界是如何变化的。我们必须能够看到我们面对的是什么。

在加利福尼亚，数据科学家和工程师已经使用卫星图像探测地球表面的热量，为公众提供几乎实时更新的西海岸野火地图。

公共卫生

即使作为一名大学地理专业的学生，我个人也从未像在过去 9 个月的全球疫情生活中那样对地图如此着迷。每周我都会看一张世界地图，看看这个世界在做什么。几乎每天我都在看纽约市的地图，看看这个城市的哪些区域是新指定的热点。人们依赖这种地图，不仅是为了去上班，也是为了安全地生活。

初创公司 Zzapp Malaria 正试图利用 GIS 技术，通过众包和测绘需要处理蚊子的水源，来帮助根除非洲的疟疾。对于非洲大陆的一个重大健康问题，这是一个令人难以置信的技术解决方案。

丽娜·洛斯在 Unsplash 上的照片

更加

与任何数据可视化一样，它需要讲述一个故事，否则人们不会连接。幸运的是，地图是很好的讲述故事的工具，因为它们可以帮助我们了解背景。地图很特别，因为它们有助于我们了解彼此以及我们周围世界的关系。随着现代数据采集和地理信息系统技术的发展，地图的局限性和它们能教给我们的东西正在不断减少。地理空间数据技术已经帮助创新了一切餐厅定位(Yelp)和汽车服务(优步)，从而改善了像伊斯坦堡这样的城市的地震后管理。

我紧张什么？

监视…差不多就是这样

监视是最重要的。我们许多人每天都在口袋里装着 GPS 追踪器，这绝对是一个黑色幽默的反乌托邦笑话。我将第一个承认，尽管我“只允许在使用应用程序时进行位置跟踪”，但我也不是最警惕关闭这些应用程序的人……尽管任何心怀不轨的人都可能将最良性的工具变成大规模杀伤性武器，但我们不要忘记意想不到的后果(比如一个肤浅的外观评级应用程序，有一天会摧毁民主的结构)。人们希望，像特里斯坦·哈里斯(Tristan Harris)和硅谷良心中的其他人这样的告密者将继续为人道主义价值观大声疾呼，因为这片土地的法律不可避免地跟不上技术进步的步伐。

兴奋起来，保持警惕

地理和数据科学的进步以及两者的融合令人兴奋不已。我希望你已经知道地理不仅仅是知道东西在哪里，以及说出各州首府的名字。当然你已经知道了，我只是需要提醒自己地理仍然很酷。

原子级深度学习

原文：https://towardsdatascience.com/atomic-scale-deep-learning-34238feda632?source=collection_archive---------63-----------------------

ML 能预测我们看不到的东西吗？

我通过总结激动人心的新研究论文来探索人工智能对传统科学的影响。在这篇文章里我在看一篇很棒的新论文:【部分扫描透射电镜与深度学习】( 科学报道， 10 ，8332，2020 )。

1|用电子我们能看到什么？

如果我想要一个物体的图像，我可以用我的相机拍照。相机快速记录可见光与物体相互作用的快照。这对于大多数日常情况来说非常有效，但当试图创建非常小的对象(如微生物、细胞、纳米材料和晶体)的图像时，就会出现问题。这些物体非常小，小于可见光的波长，所以我们看不见它们。在这些情况下，可以使用一种更有效的成像技术:电子显微镜(EM)。EM 不是记录低能量可见光如何与物体相互作用，而是发射一束高能电子束到样本上并记录这种相互作用。电子束的波长很短，甚至可以分辨非常小的特征，最好的显微镜可以达到原子级的分辨率——它们可以让我们看到原子！有许多不同类型的 EM，它们被用于无数的科学领域，从新材料开发到生物科学。

看看这张细胞(蓝色)表面的病毒颗粒(黄色)的惊人照片，它是通过扫描电镜收集的。

这张彩色扫描电镜照片显示了蓝色细胞表面的黄色病毒颗粒(MERS-CoV)。unsplash.com

尽管这些技术已经彻底改变了科学的许多方面(2017 年诺贝尔化学奖被授予冷冻电子显微镜),但它也有很多问题。电磁机器由电子枪和加速器、强大的真空系统和电磁透镜组成。它们并不便宜，而且获得它们的机会非常有限。此外，成像过程不是瞬间的；对于扫描 EM 技术，聚焦的电子束必须在样品表面的每一个微小部分上移动，并将结果整理以生成完整的图像。这降低了图像收集和研究的速度。最重要的是，这些超高能电子束会破坏敏感材料，妨碍高质量成像。

2|这跟机器学习有什么关系？

最近，在使用 ML 人工生成真实感图像方面有了真正令人兴奋的进展；神经网络现在可以填补照片中缺失的部分，甚至可以重新制作旧的低分辨率电脑游戏。下面的图片不是真人的照片，它是由人类肖像数据库中训练的神经网络创建的。

人脸的人工图像是由一个经过人体画像训练的模特生成的。公共领域图像。

如果我们不必扫描整个样品表面来生成 EM 图像会怎么样？如果我们可以快速扫描样本的一部分(产生部分扫描)，并使用这些深度学习技术准确填充空白，会怎么样？

这些是 Jeffrey Ede 和 Richard Beanland 在他们的论文部分扫描透射电子显微镜与深度学习中提出的问题。减少电子束扫描可以彻底改变 EM 成像，加快数据收集，甚至可以研究非常精细的材料。他们训练深度学习模型来完成部分 STEM(扫描透射 EM)图像，并获得了一些非常酷的结果。

4|数据，数据，数据…

每个 ML 工程师都知道数据收集和处理将决定一个项目的成败。你需要大量数据来训练一个神经网络。在这种情况下，作者整理了来自许多科学家工作的 16，000 幅高质量 STEM 图像的数据集。这个数据集非常多样化，包括不同材料的图像，放大到原子尺度。通过将每个 EM 图像裁剪成更小的子图像，并通过翻转和旋转来随机增加它们，训练数据的量进一步增加。

那么，如何将大量完整的 EM 图像(地面真实数据)转换成部分扫描呢？训练数据是通过将每个图像乘以一个二进制掩码得到的:乘以 1 保留像素值(一个“扫描”区域)，而乘以 0 删除该像素值(一个未扫描图像的“空白”区域)。

因为 EMs 不以这种方式扫描，所以研究了不同的屏蔽程序。网格和螺旋扫描提供了图像表面的均匀覆盖，扫描路径之间的间隔甚至可以调整，以改变原始图像被掩盖的程度。

演示通过应用二元蒙版生成的原始 STEM 图像和人工螺旋/网格图案。在知识共享许可下，经原文许可修改。

接下来，生成式对抗网络(GAN)被训练来填充这些部分扫描的掩蔽区域。

5|什么是甘？

2014 年，Ian Goodfellow 和他的同事报道了这类 ML 模型。让 GANs 真正酷的是，他们有两个截然不同的神经网络，相互竞争。“生成式”网络产生尽可能接近真实情况的虚拟数据点；在这种情况下，从部分扫描创建完整的图像。第二个“辨别”网络被训练来区分地面真实和生成的图像。随着两个网络的竞争和学习，发生器产生的图像与地面真相难以区分，而鉴别器在识别它们方面有所提高。这些令人惊叹的甘在图像生成方面取得了非常酷的突破，比如完成了照片的缺失部分，甚至改进了天文图像。

本文中使用的 GAN 比传统系统稍微复杂一些。首先，有一个多级生成器:由内部生成器生成的大规模图像特征被外部生成器增强，以生成完整的图像。这些生成的图像然后以两种方式用于学习。如果传递到训练者网络，通过与地面真实图像的比较计算均方误差，并用作即时反馈度量。这是非对抗性训练。或者，鉴别者观察不同大小的随机作物来预测图像是真实的还是生成的。这就是对抗性训练。

用于完成 STEM 图像的 GAN 的简化方案。在知识共享许可下，经原文许可复制。

结果如何？

通过训练这个 GAN 系统，取得了一些非常惊人的结果。看看下面的图像:使用只有 1/20 像素覆盖率的螺旋扫描，图像几乎与原始数据完全相同。与非对抗性系统优化的图像相比，使用对抗性学习方法制作的图像看起来更真实且不那么模糊。

比较掩蔽训练数据、地面真实茎图像和由 GAN 的非对抗性和对抗性训练的输入制成的人工图像。根据知识共享许可经原文许可修改。

扫描模式的类型对测试误差有影响:螺旋扫描产生的非对抗性图像比网格扫描产生的误差低。这是因为误差随着离扫描路径距离的增加而系统地增加。这有道理；在信息输入最少的地方，需要更多的推断。所以螺旋更好，因为它们间隔更小。

7|一些需要考虑的事情

没有完美的结果，我想指出几个问题:

  1. 目前的电子显微镜无法实现用于制作部分图像的螺旋和网格状扫描系统，因此必须开发其他扫描路径。
  2. 最小化误差的最佳扫描路径不是固定的模式，而是对每个样本都是唯一的。作者说，他们正在研究一个动态扫描系统，它会根据输入自动改变，这真是一个令人兴奋的想法！
  3. 该模型在预测可预测的结果方面做得很好，但它不能创建意外的数据。看看下面的图片，它显示了真实图像中缺失的原子缺陷。因为它位于扫描路径之间，所以 GAN 没有预测到缺陷。不幸的是，观察缺陷和意想不到的结果是电子显微镜最有趣的应用之一，这突出了这种部分扫描技术的一个关键缺陷；我们可能会错过有趣的结果。
  4. 这项新技术的表现一直优于之前报道的系统:深度学习超采样扫描透射电子显微镜。作者说，这是因为他们直到验证和训练损失分散后才进行训练，他们预计他们的系统会随着更多的计算而变得更好。也许…但是我们不能确定，所以一定要记住这一点。

地面真实图像(包含缺陷)与未预测缺陷的发生器输出的比较。在知识共享许可下，经原创论文许可修改。

7|最终想法

总的来说，这篇论文非常值得一读，它展示了部分 STEM 技术是如何将电子轰击减少 10-100 倍的。从部分扫描生成的完整图像显示只有 3-6%的误差，考虑到 STEM 本身是一种噪声技术，这已经是相当不错的了。这对于那些在有限时间内接触电磁设备的科学家以及那些研究电子敏感材料的人来说，可能真的很有帮助。

如果你喜欢这篇总结，我鼓励你阅读原文以获得更深入的结果！

用 Python 编写数据科学项目的 Atom 之氢

原文：https://towardsdatascience.com/atoms-hydrogen-for-writing-data-science-projects-using-python-46b6507fcdf7?source=collection_archive---------13-----------------------

萨法尔·萨法罗夫在 Unsplash 上拍摄的照片

每当我想写 Python 代码时，不管是为了测试还是部署，我都会打开 Jupyter Notebook 开始写。为什么不呢，对吗？它是免费的、开源的，每个人似乎都喜欢它(例如)。

如果您的公司想在他们的生产环境中部署您的代码，您可以使用 Anaconda Enterprise 来完成。

在 Anaconda 企业中部署 Jupyter 笔记本电脑

但是，如果您需要在您的项目中编写 Python 模块，那么在 Jupyter 中编写和测试模块，将其保存为 Python 文件，然后将其包含在您的主 Jupyter 笔记本中等等，这可能并不理想。

另外，部署 Anaconda Enterprise 的缺点是什么？嗯……

Anaconda 企业成本的谷歌结果

这就是我寻找替代工具的原因。它可以省去编写产品模块化代码的麻烦，但我仍然可以一行一行地运行代码，还可以内联显示数据和变量。

原子氢包来了！！！

氢是什么？

就像官方文件中的标语所说的

Jupyter 内核的所有功能，在您最喜爱的文本编辑器中。

到目前为止，这是真的，我喜欢我的 MacOS 10.15。它可以将您的 Atom 文本编辑器变成一个类似 Jupyter 的笔记本！另外，Atom 是一个轻量级的文本编辑器，提供了大量的包，使它成为一个非常棒的代码编辑器。

来源:氢官方页面

这篇文章将向你介绍我在安装 MacOS 10.15 过程中遇到的问题的步骤和解决方法。

1.安装 Atom

当然，这是一个非常容易做到的步骤。直接去 https://atom.io 下载最新版本的 atom。下载完成后，只需将应用程序文件复制并粘贴到您的应用程序文件夹中。

“那就双击打开吧？”—嗯，也不尽然。

许多 Mac 用户，包括我自己，发现我们无法打开编辑器，并收到了这样的消息。

“Atom 2”打不开，因为苹果无法对其进行恶意软件检查。这个软件需要更新。有关详细信息，请联系开发人员。

但是不用担心。

只需右键点击应用文件，然后点击“打开”。

2.安装氢气包

点击 原子>偏好>安装>氢型T5点击安装。

安装氢气包

一旦完成，您将需要安装 Python 的内核，否则，Hydrogen 将无法工作。打开你的终端，输入下面的代码。

python -m pip install ipykernel
python -m ipykernel install --user

这将安装 IPykernel，这是 Python 的一个内核，这样 Hydrogen 就可以像 Jupyter 那样让 Atom 执行 Python 代码。

一旦完成，重启 Atom，您将能够逐行运行您的代码，甚至显示您的pandas数据框和您通常在 Jupyter 中制作的其他视觉效果。要查看命令快捷键，你可以在 包>氢 上查看，在那里你会找到你可以使用的快捷键列表。你会发现它们和朱庇特的很相似。

氢捷径

要仅运行选定的代码行，只需选择要执行的代码行，然后按下运行快捷键。

太棒了，对吧？

要了解氢的全部功能，你可以在官方页面上查看。

加号—自动完成

最后，如果没有自动完成功能，它就不是一个编辑器。

Hydrogen 已经提供了自动完成功能，但是当我尝试的时候，几个变量或者内置的 Python 函数都没有显示出来。因此，我建议您添加autocomplete-python包。

点击 原子>首选项>安装>类型【自动完成-python】。然后单击安装。

如果你在自动完成基本的 Python 关键字和变量时发现了一些麻烦，可能是语法文件复制不正确。要修复它，您可以在您的终端中尝试下面的代码。

cd ~/.atom/packages/autocomplete-python/lib/jedi/parser
cp grammar3.6.txt grammar3.7.txt

最后的话

希望这篇帖子是有用的，并且每个人都有更好的时间来编写复杂的模块化机器学习、数据预处理或数据分析代码。尤其是在新冠肺炎·疫情造成的困难时期。

攻击模式检测和预测

原文：https://towardsdatascience.com/attack-pattern-detection-and-prediction-108fc3d47f03?source=collection_archive---------50-----------------------

网络对手在努力避免检测方面变得越来越复杂，许多现代恶意软件工具已经采用了绕过防病毒和其他威胁检测措施的新方法。

由于网络和组织使用复杂的方法来检测和响应攻击，这种响应可能会非常强烈，以至于犯罪分子会尝试使用更强的方法来响应。网络犯罪分子的复杂性不断增加，加上人工智能(AI)攻击的潜力不断扩大。

然而，网络安全正处于关键时刻，该领域必须将未来的研究重点放在能够预测关键情景和结果的网络攻击预测系统上，而不是依赖防御解决方案和专注于缓解。世界各地的计算机系统需要基于对网络威胁的全面预测分析的系统。

人工智能(AI)在很大程度上依赖于机器学习(ML)，它有能力识别从过去的经验中产生的模式，并基于这些模式做出预测。近年来，可以使用机器学习和人工智能等东西来攻击网络和设备的群技术显示出了新的潜力。

通过理解行为模式，分析恶意活动之间的模式和联系，预测未来的行动，并最终防止或检测潜在的恶意行为，可以定义有用的攻击模式。

上述网络威胁预测系统提供了有希望和有限的可能性，但大规模协调攻击需要在几个方面取得进展，包括检测和预测计算机系统中产生的事件。混淆技术用于通过故意使恶意代码难以理解来绕过检测，以便绕过网络的检测。

在评估网络安全风险时，必须考虑黑客的行为，考虑到已知漏洞的数量和攻击者渗透网络的选择，这可能是一项艰巨的任务。

在最近进行的一项特定研究中，数据被输入到两种深度学习技术中，这两种技术使用序列数据来描述网络攻击。他们还整合了基于信息论的分歧措施，以生成和完善对计算机和网络的假想攻击。

另一项由 NSF(国家科学基金会)资助的研究旨在基于网络罪犯的最新犯罪学理论模拟网络攻击场景。ASSERT/CASCADES 项目随着我们对不断发展的网络恐怖主义技术的了解而不断发展。该项目能够使用网络上发生的可观察到的恶意活动来预测即将到来的攻击。预计将有可能制定策略来区分正在进行的恶意活动，并在这些事件发生之前应对即将到来的关键威胁。

NEPAR 是另一个关于攻击模式识别的项目，用于提取美国和世界各地超过 150 万次网络攻击的模式数据。他们从公共和私人来源获取数据，发现并使用每次攻击中使用的特征和模式。这预测了对特定系统(例如计算机系统或网络)的攻击的可能性，并预测了对这些特定系统的成功攻击的可能性。

一些组织已经开始使用 MITRE 框架对攻击进行统计分析，以进行战术排序。蓝队防守游戏手册用于根据红队的对手游戏手册预测战术和绘制具体威胁，红队的对手游戏手册是根据收集的数据创建和更新的，并由该组织的数据收集和分析工具进行分析，如开源威胁评估工具包(OSTAT)。然后可以开发防御行动手册来创建反应日志，以使用网络指纹识别攻击。

将这两者结合起来，可以让 SOC(安全运营中心)安全团队准确了解网络钓鱼攻击的情况，以及如何在员工上当之前向他们发出警报。当对手突破网络时，可以借助红队防守游戏本识别攻击策略。

在一个懒惰的安全环境中，预测下一次攻击是领先一步应对与成功的电子邮件安全事件相关的中断的唯一方法。识别组织漏洞所在的异常和模式以及攻击者下一步可能攻击的位置是一种积极主动的方法。那些因为昨天的袭击而试图识别身份的人仍然处于更大的风险中。

据信，安全研究人员可以使用攻击模式识别或检测方法作为一种可以提供预防措施来防止未来攻击的方法。

引用来源

理解深度学习中的注意力

原文：https://towardsdatascience.com/attaining-attention-in-deep-learning-a712f93bdb1e?source=collection_archive---------1-----------------------

一点点关注怎么改变了 AI 游戏！

在 Unsplash 上由哈尼恩·克里姆利拍摄的照片

在我之前的一篇文章中，我谈到了注意力是我们人类拥有的最重要的资产之一。我们选择如何度过时间，以及在这段时间里我们选择关注什么，几乎决定了我们所有努力的结果。

在这篇文章中，我们将讨论我们如何给一个 ML 模型聚焦的能力，以及它对其性能的影响。

为什么模特需要被关注

让我们回顾一下一项任务——在许多 NLP 模型中普遍解决的任务——翻译。在大多数情况下，逐字翻译是行不通的，因为大多数语言没有共同的句子结构。一个简单的例子:

English => French
red => rouge
dress => robe
“*red dress*” => “*robe rouge*”
Notice how red is before dress in English but rouge is after robe.

NLP 模型通常处理此类任务的方式是，在中间状态下捕获输入句子中的所有信息——对象的细节，对象如何相互关联——然后使用此中间信息，并在输出语言中表达出来。在我们开始解码输出序列之前，用于该中间状态(即捕获来自输入序列的所有信息的状态)的向量的大小是固定的。

NLP 模型如何从输入序列转换到输出序列。输入序列和编码器型号以黄色显示，而输出序列和解码器型号以蓝色显示。注意，编码器模型中的 t 与解码器模型中的 t 无关，仅用于表示每个模型中的下一个时间步长。

中间状态在整个过程中起着至关重要的作用。它记住输入句子中传递的所有信息的能力对解码输出的质量至关重要。无论是翻译还是 QnA 任务，其中输入是一个问题和一个段落，模型需要基于该段落或任何其他序列到序列建模操作来预测该问题的答案，中间状态仍然是难题中最关键的部分。

这是最好的时代，这是最坏的时代，这是智慧的时代，这是愚蠢的时代，这是信仰的时代，这是怀疑的时代，这是光明的季节，这是黑暗的季节，这是希望的春天，这是绝望的冬天，我们面前什么都有，我们面前什么都没有，我们都将直奔天堂， 我们都在朝着另一个方向前进——简而言之，那个时代与现在的时代如此相似，以至于它的一些最喧闹的权威人士坚持认为，无论是好是坏，它只是在最高级的比较中被接受。

——双城记，查尔斯·狄更斯。

现在我要求你们在从左到右看一遍后，记住这个句子，甚至不要翻译，我限制了你们可以在笔记上写的单词数。不太容易，是吗？

记住这句话怎么样？这句话是关于汽车充满了我完全虚构的事实。免责声明:以下声明中出现的数字和用例是虚构的，它们的任何意义纯属巧合。

这辆车高 2 米——靠在我的朋友身上，宽 12 米——不幸的是，不太容易拥抱，8 米轴距——不管这些信息有什么用途，只有 0.1 米的转弯半径——让你更容易避开所有的问题，200 升的行李箱空间——可以装下你旅行时携带但从未使用过的所有行李， 0.25 米的离地间隙——如果你曾经在车下寻求庇护，6 缸发动机带 5 个气门——这是一个你只会在炫耀时使用的规格，最后还有一个双顶置凸轮轴，因为大型汽车有很大的词汇。 你真诚的:)****

玩笑归玩笑，在这种情况下，你不仅要记住我随机放进去的所有数字，还要记住它对应的特征——用粗体显示。在一个地方搞砸了，你就全弄错了。

到目前为止，很明显，在输入很长句子的情况下，中间状态失败，不足以捕获所有信息。当它处理完整个输入时，通常会忘记第一部分。为了提高模型的性能，并减轻中间状态单独负责将解码器可用的所有信息编码成固定长度向量以及成为潜在瓶颈的负担，我们使用了 注意力 的概念。使用这种新方法，信息可以在整个注释序列(编码器隐藏状态)中传播，解码器可以相应地有选择地检索这些信息。

模型中的注意机制

注意机制试图通过允许解码器模型访问所有隐藏状态来克服中间状态的信息瓶颈，而不是在预测每个输出时，从编码器的最后一个隐藏状态构建单个向量——也称为中间状态。

计算解码器模型的下一个隐藏状态。

解码器中单元的输入现在得到以下值:

  1. 解码器型号 Hₖ - ₁.的前隐藏状态
  2. 先前输出的解码器型号 Yₖ - ₁.
  3. 一个上下文向量 Cₖ—是所有编码器隐藏的的注释的加权和。(新增)

我在原稿上的图像。为了简单起见，我没有在这个图中显示中间状态。h t(最后一个编码器隐藏状态)将是中间状态，它将作为第一步中的输入被提供给解码器模型。

上下文向量和全局对齐权重的一些特征

全局对齐权重很重要，因为它们告诉我们下一次输出应该关注哪些注释。权重将会并且应该在解码器模型的每个时间步长中变化。它们是通过使用前馈神经网络来计算的。

每个情节的 x 轴和 y 轴分别对应于源句子(英语)和生成的翻译(法语)中的单词。每个像素示出了第 j 个源单词的注释对于第 I 个目标单词的权重αij(参见等式 1)。(6))、灰度(0:黑色、1:白色)——原纸。

一些值得注意的观察结果:

  • 在预测下一步时，权重很高——以白色显示——每次只显示几个词。对于给定的输出单词，不超过 3-4 个单词具有高关注度。
  • 注意力不会在特定的输入单词上停留很长时间。也就是说，仅仅因为前一步中的权重高，并不意味着后续步骤中的权重也会高。
  • 有时注意力会回到输入的单词上——看看输出中的单词“ que ”以及它的注意力是如何集中在第一个单词“ It ”上的。

预测时的流动——在模型的测试/验证期间

步骤的顺序如下:

编码器型号:

  • 第一步 : 运行输入序列得到所有隐藏状态，计算中间状态。

解码器型号:

  • 第二步: 为 k ᵗʰ步骤从注意层神经网络中获取全局对齐权值⍺ₖ ⱼ。
  • 第三步: 计算上下文向量通过将⍺ₖ ⱼ 与 hⱼ 相乘，用于范围 0 到 t 的 j，其中 t= 编码器模型中的步骤。

计算上下文向量的公式。对于我们的第三步，i = k。

  • 第四步: 取解码器的前一个隐藏状态，Hₖ - ₁ 、上下文向量 Cₖ 、和前一个输出 Yₖ - ₁ 得到解码器的下一个隐藏状态 Hₖ 。预测 Yₖ来自 Hₖ.
  • 第五步: 重复 2、3、4 直到模型预测结束 token。

如何获得全局对齐权重

我们知道我们使用前馈神经网络来输出这些全局对准权重 ⍺ₖ ⱼ 。这些权重的目的是反映每个注释 hⱼ w.r.t .的重要性，前一个隐藏状态在决定下一个状态 Hₖ.在某种程度上，这允许模型决定关注输入的哪些部分。权重越大，越受关注。所以下一个问题是，它的输入是什么，我们如何训练它？

输入

我们将解码器隐藏状态和注释都输入到我们的神经网络中，以预测单个值——eₖⱼ，正如论文作者喜欢称之为“关联能量”——表示注释在下一个解码器步骤 Hₖ.中的重要性我们对所有注释重复这个过程。一旦我们有了对应于所有注释的关联能量，我们就进行 softmax 以获得全局对齐权重** ⍺ₖ ⱼ.**

神经网络接收解码器的第 I 个隐藏状态和编码器的第 j 个隐藏状态，以预测每个 eij、相关能量。对于我们来说，i=k，因为我们在解码器模型中对第 k 个时间步长进行了处理。

****全局对齐权重:每个权重是神经网络输出的软最大值(eij)。

前面提到的步骤 2 现在可以分解如下:

  • 步长 2.a: 计算 eₖ ⱼ其中 j = 0 到 t，t =编码器模型中的时间步长。解码器隐藏状态对于所有 j 将是相同的，并且将是 Hₖ - ₁.

对于 j = 0 到 t，即编码器中的所有隐藏状态。

  • 步骤 2.b: 一旦我们得到了所有的 eₖⱼ，做一个 Softmax 得到⍺ₖ ⱼ.

培训/损失计算

比对模型直接计算软比对—考虑所有输入，这允许损失函数的梯度—为整个序列到序列模型的最终输出计算—反向传播。该梯度用于联合训练对齐模型以及整个平移模型。

设⍺ᵢ ⱼ是目标单词 Yᵢ从源单词 X ⱼ 翻译过来的概率。然后，第 i 个上下文向量 Cᵢ是概率为⍺ᵢ ⱼ的所有注释中的期望注释。当每个时间步长的损失被反向传播时，我们计算所有三个输入的梯度——先前的隐藏状态、先前的输出和上下文向量。(如果这对你来说有点困惑，请在这里阅读更多关于反向传播)在我们计算其输入的梯度之前，所有在一个时间步长中回流的梯度将被加在一起。**

Cₖ在每个时间步的梯度被用作我们用来预测全局比对权重的前馈神经网络的损失。

对性能的影响

  • 具有注意机制的模型能够显著地优于传统的编码器-解码器模型，而不管句子的长度，并且它对源句子的长度更加鲁棒。
  • 它还能够正确地将每个目标单词与源句子中的相关单词或它们的注释对齐，因为它会生成正确的翻译。
  • 它为变形金刚和谷歌的 BERT 等 SOTA 模型铺平了道路，从而推动了该领域的进一步发展——这些模型启发了脸书的 RoBERTa ，微软的 AzureML-BERT 以及更多。

结论

  1. 在我们当前的 RNNs 方法中，中间状态是性能的瓶颈。
  2. 注意力可以通过在预测下一个输出隐藏状态时查看每个单独的输入状态来解决这个问题。
  3. 计算注意力的数学方法。
  4. 与基于 RNNs 的模型集成。
  5. RNN +注意力模型的表现。

后续阅读:

*** [## 变形金刚(电影名)

或者我喜欢称之为类固醇引起的注意。💉💊

towardsdatascience.com](/transformers-89034557de14) [## 跟上贝茨

NLP 镇最受欢迎的家庭。

towardsdatascience.com](/keeping-up-with-the-berts-5b7beb92766)

如果你喜欢这篇文章，并想探索更多关于 Transformer 和 BERT (现已发布)，请务必查看我在同一网站上的文章。😄✌️

参考文献+推荐阅读

我认为你会喜欢的其他文章😄

我很高兴你坚持到了这篇文章的结尾。🎉我希望你的阅读体验和我写这篇文章时一样丰富。💖**

请点击这里查看我的其他文章。🔍

如果你想联系我，我会选择推特。📬***

基于 C-3 框架和 Azure ML 的出勤估计

原文：https://towardsdatascience.com/attendance-estimation-with-azure-ml-e6678f8a44ed?source=collection_archive---------54-----------------------

图片来自 Pexels https://www . Pexels . com/photo/people-on-stadium-event-1916 816/

TLDR；这篇文章提供了一个 E2E Jupyter 笔记本，用于训练带有 C-3 框架和用于 Python 的 AzureML SDK的人群计数模型

什么是受众评估

作为人工智能云开发者的倡导者，我经常发现自己在各种各样的观众面前说话。现在我有时间在家工作时制作一些新的演示，我一直在想当生活恢复正常时，如何更好地了解我所谈论的观众。

我经常根据注册或目测来估计我的演讲范围，但是如果有更好的方法呢？作为一名人工智能工程师，我受到了微软猫团队在人群计数方面所做工作的启发。我找不到任何关于如何在云上大规模训练这类模型的教程，于是决定自己写一篇，为我的读者记录这个过程。

帖子的代码可以在下面找到

[## aribornstein/AudienceEstimationAuzreML

观众估计的 E2E 人群计数示例—aribornstein/AudienceEstimationAuzreML

github.com](https://github.com/aribornstein/AudienceEstimationAuzreML)

如果你是 Azure 的新手，你可以使用下面的链接开始免费订阅。

[## 立即创建您的 Azure 免费帐户| Microsoft Azure

开始享受 12 个月的免费服务和 200 美元的信用点数。立即使用 Microsoft Azure 创建您的免费帐户。

azure.microsoft.com](https://azure.microsoft.com/en-us/free/?WT.mc.id=aiapril-medium-abornst)

检测与密集方法

在我们开始之前，我们应该试着理解两种顶级观众评估方法之间的区别。

左图为密集模型，右图为姿态检测模型。图片来自https://github . com/Microsoft/computer vision-recipes/tree/master/contrib/crowd _ counting

基于检测的方法，如人物检测、语义分割和姿态估计，在小人群中效果最佳，但难以扩展到估计几十人或更多人的较大观众规模。

来自 pynino 库https://github.com/hampen2929/pyvino的检测后和分段的结果

密集方法尝试学习原始图像和密度图之间的特征映射，该密度图是通过在图像中的所有人上放置关键点而生成的。这些模型最适用于估计大量受众的规模。

稠密地图的一个例子和从密度近似模式返回的估计输出

最受欢迎的密集模式之一是多列 CNN ( MCNN) 模式，因为它的评估时间相对较快。

运行预训练的密集近似器模型

有大量文档说明如何在云中训练和使用基于预训练检测的模型，以及一些现成的云服务。

在这篇文章中，我们将展示如何使用 AzureML SDK 和 C-3-Framework 运行和训练你自己的 MCNN 密集近似模型。

高君宇开发的 C-3 框架为 PyTorch 中实现的六种常见主流人群计数数据集和 MCNN 的多种模型配置提供了预处理代码。

[## gjy 3035/C-3-框架

一个开源的 PyTorch 代码正在开发中。我们将抽出业余时间来开发…

github.com](https://github.com/gjy3035/C-3-Framework)

在他的 G itHub Repo 中，高提供了经过处理的数据集和预训练的模型的链接。他没有在一个文档中提供端到端的示例，但是，因此我冒昧地在 Jupyter notebooks 中自己编写了一个示例，演示如何安装框架和运行预训练的模型。

[## aribornstein/AudienceEstimationAzureML

github.com](https://github.com/aribornstein/AudienceEstimationAzureML/blob/master/LocalCrowdCounting.ipynb)

使用 Azure ML 训练您自己的大规模密集近似模型

Azure 机器学习服务提供了几种训练机器学习模型的方法，从使用 SDK 的代码优先解决方案到低代码解决方案，如 AutoML 和可视化设计器。

使用 AzureML SDK 训练模型有 8 个简单的步骤

前 3 个步骤与设置培训基础架构有关，从选择计算设备到加载数据。

剩下的五个步骤与设置环境有关，以运行和试验不同的培训脚本，并管理生成的模型。

在下面的笔记本中，您将看到这 8 个步骤中的每一个步骤的示例，以此来训练您自己的大规模受众评估模型。

[## aribornstein/AudienceEstimationAzureML

github.com](https://github.com/aribornstein/AudienceEstimationAuzreML/blob/master/AML Crowd Counting Notebook.ipynb)

一旦你运行了这个笔记本，一定要看看我的关于生产机器学习的 9 个技巧，并试着摆弄代码。我在笔记本底部留了几个挑战让你尝试。

[## 生产机器学习的 9 个高级技巧

TLDR；将最新的机器学习模型整合到生产应用程序中是一件值得做的事情…

medium.com](https://medium.com/microsoftazure/9-advanced-tips-for-production-machine-learning-6bbdebf49a6f)

此外，我还在下面列出了一些关于人群计数的很好的资源。

额外资源

[## gjy 3035/Awesome-人群统计

如果您有任何问题、建议或改进，请提交问题或 PR。[C^3 框架]一个开源的…

github.com](https://github.com/gjy3035/Awesome-Crowd-Counting) [## 这是破纪录的人群！一个必读的教程来建立你的第一个人群计数模型，使用…

人工智能和机器学习将在未来十年成为我们最大的帮手！今天早上，我在…

www.analyticsvidhya.com](https://www.analyticsvidhya.com/blog/2019/02/building-crowd-counting-model-python/) [## 微软/计算机视觉-食谱

这个库提供了人群计数算法的生产就绪版本。不同的算法是统一的…

github.com](https://github.com/microsoft/computervision-recipes/tree/master/contrib/crowd_counting) [## C³ Framework 系列之一：一个基于 PyTorch 的开源人群计数框架

首发于微信公众号： 我爱计算机视觉 C3F：首个开源人群计数算法框架 【后期代码以及实验的重大更新，将会在该知乎专栏连载】…

zhuanlan.zhihu.com](https://zhuanlan.zhihu.com/p/65650998) [## 人群计数变得简单

作为 Udacity 学者的经历:

medium.com](https://medium.com/secure-and-private-ai-writing-challenge/crowd-counting-made-easy-1bf84f18ff61)

后续步骤

这里有一些额外的资源来帮助你在 Azure 上的计算机视觉之旅。

[## 自定义视觉| Microsoft Azure

通过简单地上传和标记一些图像，开始训练你的计算机视觉模型。模型在…上进行自我测试

azure.microsoft.com](https://azure.microsoft.com/en-us/services/cognitive-services/custom-vision-service/?WT.mc_id=aiapril-medium-abornst) [## 计算机视觉|微软 Azure

利用 Azure 认知服务 Computer Vision 从图像中提取丰富的信息并分析内容。

azure.microsoft.com](https://azure.microsoft.com/en-us/services/cognitive-services/computer-vision/?WT.mc_id=aiapril-medium-abornst) [## 视频索引器-人工智能视频洞察|微软 Azure

使用视频索引器从视频和音频文件中自动提取元数据。提高媒体的性能…

azure.microsoft.com](https://azure.microsoft.com/en-us/services/media-services/video-indexer/?WT.mc_id=aiapril-medium-abornst) [## 计算机视觉浏览器

AI2 计算机视觉浏览器提供了各种流行的模型演示-尝试，比较，并评估与您自己的…

vision-explorer.allenai.org](https://vision-explorer.allenai.org/) [## Facebook 研究/检测器 2

Detectron2 是脸书人工智能研究所的下一代软件系统，实现了最先进的物体检测…

github.com](https://github.com/facebookresearch/detectron2)

关于作者

亚伦(阿里)博恩施泰因 是一名人工智能研究员，对历史充满热情，致力于新技术和计算医学。作为微软云开发倡导团队的开源工程师，他与以色列高科技社区合作，用改变游戏规则的技术解决现实世界的问题，然后将这些技术记录在案、开源并与世界其他地方共享。

注意力和变压器模型

原文：https://towardsdatascience.com/attention-and-transformer-models-fe667f958378?source=collection_archive---------10-----------------------

实践教程

一个复杂的算法，简单解释一下

(图片由作者提供)

2017瓦斯瓦尼等人的《注意力就是你所需要的全部》是一篇里程碑式的论文，提出了一种全新的模型——变压器。如今，Transformer 模型在机器学习领域中无处不在，但它的算法非常复杂，难以琢磨。所以这篇博客希望能让你对此有更多的了解。

基本架构

那么下图中所有这些彩色矩形意味着什么呢？一般而言，转换器模型基于编码器-解码器架构。编码器是左手边的灰色矩形，解码器是右手边的那个。编码器和解码器都由两个和三个子层组成，分别是:多头自关注、一个全连接前馈网络和——在解码器的情况下——编码器-解码器自关注(在下面的可视化中称为多头关注)。

变压器架构(来源:Vaswani 等人，2017 年)

图中看不清楚的是，变压器实际上堆叠了多个编码器和解码器(图中用 Nx 表示，即编码器和解码器堆叠了 n 次)。这意味着一个编码器的输出用作下一个编码器的输入，一个解码器的输出用作下一个解码器的输入。

多头自我关注

Transformer 的新之处并不在于它的编码器-解码器架构，而在于它摒弃了传统上使用的循环层。相反，它完全依赖于自我关注。

那么什么是自我关注呢？简而言之，这是模型理解其接收到的输入的方式。

递归模型的一个问题是长期相关性(在一个序列内或跨几个序列)经常丢失。也就是说，如果序列开头的一个单词对于序列结尾的一个单词很重要，那么一旦到达最后一个单词，模型可能会忘记第一个单词。那些 RNNs 没那么聪明吧？；-)变形金刚模型使用不同的策略来记忆整个序列:自我关注！

序列中的长期依赖:如果模型没有从一开始就记住“男孩”，它可能不知道在结尾使用哪个代词。他，她，它？(图片由作者提供)

在自我注意层，输入 x(表示为向量)通过输入的三个表示向量:q(ueries)，k(eys)和 v(values)被转换成向量 z。这些用于计算一个分数，该分数显示该特定输入应该对给定序列中的其他元素给予多少关注。

我刚才用语言模糊表达的东西可以用下面的公式更精确地定义:

(图片由作者提供)

由于公式并不总是非常直观，一步一步的可视化计算应该会使事情变得更清楚一些。

(图片由作者提供)

比方说我们要为“蓬松煎饼”序列中的“蓬松”这个词计算自我关注度。首先，我们将输入向量 x1 (代表单词“fluffy”)与三个不同的权重矩阵 Wq、Wk 和 Wv(在训练期间不断更新)相乘，以获得三个不同的向量:q1、k1 和 v1。对输入向量 x2 (代表单词“煎饼”)进行完全相同的操作。我们现在有了两个单词的查询、键和值向量。

查询是我们想要计算自我关注度的单词的表示。因此，由于我们想获得对“fluffy”的自我关注，我们只考虑它的查询，而不考虑“pancakes”的查询。一旦我们计算完“fluffy”的自我关注度，我们也可以丢弃它的查询向量。

键是序列中每个单词的表示，用于匹配我们当前想要计算自我注意的单词的查询。

值是序列中每个单词的实际表示，我们真正关心的表示。将查询和关键字相乘得到一个分数，这个分数告诉我们每个值(以及相应的单词)在自我关注向量中所占的权重。请注意，该值不是直接与分数相乘，而是首先将分数除以 dk 的平方根，即关键向量的维数，然后应用 softmax。

这些计算的结果是每个单词一个向量。最后一步，将这两个向量相加，瞧，我们有了对单词“fluffy”的自我关注。

自我关注“他的”这个词。这些线条表示单词“his”对序列中其他单词的关注程度。(图片由作者提供)

你可能注意到了，它叫多头自关注。这是因为上面的过程使用不同的权重矩阵进行了多次，这意味着我们最终得到了多个向量(在下面的公式中称为头部)。这些报头然后被连接并乘以权重矩阵 Wo。这意味着每个大脑学习不同的关于给定序列的信息，并且这些知识在最后被结合。

(图片由作者提供)

到目前为止，我还没有提到最重要的一点:所有这些计算都可以并行化。为什么这是一件大事？我们先来看看 RNNs。它们需要按顺序处理顺序数据，也就是说，一个序列中的每个单词都要一个接一个地传递给模型。然而，变压器模型可以一次处理所有输入。这使得这些模型非常快，允许它们用大量的数据进行训练。您现在想知道，如果转换器一次收到一个句子，它是如何知道句子的正确顺序的？我将在下面关于位置编码的部分解释这一点。

正如我们在展示 Transformer 架构的第一张图片中看到的，自关注层集成在编码器和解码器中。刚刚看了一下自我关注在编码器中的样子。然而，解码器使用所谓的 屏蔽多头自关注。这意味着解码器输入中的一些位置被屏蔽，从而被自我关注层忽略。他们为什么要戴面具？当预测句子的下一个单词时，解码器不应该知道哪个单词在预测的单词之后。相反，解码器应该只知道直到当前位置的字。毕竟，当实际使用模型来获得真正的下一个单词预测时，解码器也无法看到未来的位置。因此，通过在训练期间屏蔽它们，我们不允许解码器作弊。

在第一句话中(带面具)，下一个词远比第二句话(不带面具)更难预测。“它的尾巴”这个词清楚地表明，预测这个词可能是“摆动”。(图片由作者提供)

该模型的一个关键方面仍然缺失。信息是如何从编码器流向解码器的？这就是编码器-解码器自关注层在这里的目的。这一层的工作方式与编码器中的自我关注层非常相似。然而，查询向量来自前一个被屏蔽的自我关注层，键和值向量来自最顶层编码器的输出。这允许解码器考虑编码器输入序列中的所有位置。

前馈网络

所以我们现在知道了自我关注层在每个编码器和解码器中做了什么。这就给我们留下了另一个我们没有谈到的子层:全连接的前馈网络。它们进一步处理自关注层的输出，然后将它们传递给下一个编码器或解码器。

(图片由作者提供)

每个前馈网络由两个线性层组成，中间有一个 ReLU 函数。权重和偏差 W1、W2、b1 和 b2 在序列中的不同位置是相同的，但是在每个编码器和解码器中是不同的。

位置编码

正如我们已经说过的，Transformer 模型可以并行处理序列中的所有单词。然而，这意味着丢失了一些重要的信息:序列中的字位置。为了保留这些信息，单词的位置和顺序必须对模型明确。这是通过位置编码完成的。这些位置编码是与输入向量维数相同的向量，使用正弦和余弦函数计算。为了组合输入向量和位置编码的信息，它们被简单地相加。

要更详细地解释位置编码到底是如何工作的，我在这里推荐这篇文章。

图层规范化

变压器模型的一个小但重要的方面是层标准化，它在每个编码器和解码器的每个子层之后执行。

(图片由作者提供)

首先，将各个编码器或解码器层的输入和输出相加。这意味着在最底层，输入向量 X 和输出向量 Z1 相加；在第二层中，输入向量 Z1 和输出向量 Z2 等等。然后用零和单位方差的平均值对求和向量进行归一化。这可以防止给定层中的值范围波动过大，从而使模型更快地收敛。

为了更深入地解释图层规范化，我在这里推荐这篇文章。

最终线性层和 Softmax

最后，为了得到输出预测，我们需要将最后一个解码器的输出向量转换成单词。因此，我们首先将输出向量输入到一个全连接的线性层中，并获得一个词汇表大小的 logits 向量。然后，我们将 softmax 函数应用于这个向量，以便获得词汇表中每个单词的概率分数。然后，我们选择概率最大的单词作为我们的预测。

《小背狗 __》下一个词预测的概率得分。(图片由作者提供)

摘要

Transformer 模型是一种新的编码器-解码器模型，它使用自我注意来理解语言序列。这允许并行处理，从而使它比任何其他具有相同性能的模型快得多。他们因此为现代语言模型(如伯特和 GPT 以及最近的图像生成模型铺平了道路。

参考文献

[1] A. Vaswani，N. Shazeer，N. Parmar，J. Uszkoreit，L. Jones，A. N. Gomez，L. Kaiser 和 I. Polosukhin，注意力是你所需要的一切 (2017)，NIPS'17:第 31 届神经信息处理系统国际会议论文集
[2] A. Kazemnejad， Transformer Architecture:位置编码 (2019)，Amirhossein Kazemnejad

信用

特别感谢 Philip Popien 对本文的建议和更正。

注意机器翻译

原文：https://towardsdatascience.com/attention-for-machine-translation-4a95db38ee34?source=collection_archive---------48-----------------------

神经机器翻译模型的注意机制的简要综述。

我们的大脑并不具备一次处理大量信息的能力。然而，我们所擅长的是专注于我们被给予的信息的一部分来理解它。当你被要求把一个句子从一种语言翻译成另一种语言时，你处理句子的方式是一边走一边挑选单个的单词，把它们串成短语，然后在心里为每一部分指定目标语言中相应的单词/短语。

当一个书面单词呈现给你进行翻译时，它会在你的大脑中启动一系列的神经认知过程。你大脑中正常的语言系统会读出你母语中的单词，但对于翻译来说，这种通常的倾向必须被抑制，这样翻译出来的意思才能显现出来。大脑的一个特定区域(称为“尾状核”)协调这一活动，就像管弦乐队的指挥一样，产生令人震惊的复杂行为。本质上，单词或单词序列的句法、语音、词汇和语义方面被包含、吸收，然后被语境化，以将所述单词序列翻译成其在目标语言中的对等物。

翻译——无论是人工翻译还是机器翻译——在本质上都不是客观的，也就是说，对于任何给定的句子，都没有唯一的翻译。人工翻译固有地带来将源语言单词、语法或句法引入目标语言表达的风险。两个人翻译一个相对较长的句子很少会完全相同。尽管最终的结果有所不同，但不变的是翻译的大致过程。对于翻译中出现的任何目标语言单词或短语，译者会更多地关注源句子的某些部分。

直到 2015 年，Bahdanau、Cho 和 Bengio 引入了“注意力”机制，人类的这种与生俱来的品质才被赋予机器算法。提出这种机制是为了通过允许模型自动(软)搜索源句子中与预测目标单词相关的部分来最大化翻译性能，而不必将这些部分显式地形成为硬段。我承认这句话可能很难理解，但是我们将通过分解它并一次注意一部分来理解它。(很 meta，我知道。)这篇 2015 年的论文影响深远，它将继续成为几个最先进模型的构建模块。

为什么我们需要关注？

在传统的神经机器翻译模型中，编码器-解码器组合与用于每种语言的编码器和解码器一起使用，或者将特定于语言的编码器应用于每个句子，然后比较其输出。编码器 RNN 读取源句子并将其编码成固定长度的向量。然后，解码器会根据编码器提供的矢量进行翻译。由语言对的编码器和解码器组成的整个编码器-解码器系统被联合训练以最大化给定源句子的正确翻译的概率。

瓶颈

这种体系结构的一个问题是，它过度依赖于一个固定长度的向量来包含所有必要的信息，并且是源句子的高质量表示。这种在固定向量向量上压缩和捕获所有信息的压力是一个瓶颈，它使得编码器神经网络难以在长句上表现良好。前面已经表明，随着输入句子长度的增加，基本编码器-解码器的性能会迅速下降。

核心理念

为了解决这个问题，Bahdanau 等人引入了一个对编码器-解码器模型的扩展，该模型学习联合对齐和翻译。新的架构部署了一个双向 RNN 作为编码器和解码器，它将能够关注所有的隐藏状态，而不仅仅是最终的隐藏状态。这种修改所做的是为解码器提供决策的灵活性，并因此识别源句子中可能与目标句子中下一个单词的预测更相关的部分。这是注意力机制的直觉，它现在把我们引向实现这一点的数学。

因此，这种新方法便于信息在注释序列中传播，解码器可以相应地选择性地检索该信息。

通过语言这一媒介，我们能够在很长的空间和时间范围内交流思想，但是句子中词与词之间的句法联系的建立，无论它们是否彼此靠近，都是任何语言表达思想的基础。这就是注意力介入并帮助从源语言到目标语言的语法映射的地方。识别单词与同一个句子中可能很远的其他单词的关系——同时忽略对我们试图预测的单词没有太大影响的其他单词——这就是注意力的目的。

我很想解释一下注意力机制 的 代数，但是我发现 Medium 的编辑对数学写作毫无帮助。你可以在本页 底部的 找到解释。

您可以访问我的页面 这里 。你可以关注我的推特供稿 这里 。

参考

[1] Bahdanau，d .，Cho，K. & Bengio，Y. 通过联合学习对齐和翻译的神经机器翻译。在程序中。学习代表国际会议 (2015)

[2]赵京贤、亚伦·库维尔和约舒阿·本吉奥。使用基于注意力的编码器-解码器网络描述多媒体内容。 (2015)

[3]苏茨基弗，I .维尼亚尔斯，o .和勒。用神经网络进行序列对序列学习。在程序中。神经信息处理系统进展。 (2014)

[4]克里斯·奥拉赫的博文。“注意力和增强循环神经网络”

注意力是你所需要的:发现变压器纸

原文：https://towardsdatascience.com/attention-is-all-you-need-discovering-the-transformer-paper-73e5ff5e0634?source=collection_archive---------0-----------------------

入门

Tensorflow 中变压器模型的详细实现

图片来自 Pixabay 的罗宇胜·谭

本帖我们将对论文中的相关神器**【瓦斯瓦尼、阿希什&沙泽尔、诺姆&帕尔马、尼基&乌斯科雷特、雅各布&琼斯、利翁&戈麦斯、艾丹&凯泽、卢卡兹&波洛舒欣、伊利亚进行描述和揭秘。(2017))【1】。这篇论文在注意力机制的使用上是一个巨大的进步，是对一个叫做 Transformer 的模型的主要改进。在 NLP 任务中出现的最著名的当前模型由几十个变压器或它们的一些变体组成，例如，GPT-2 或 BERT。

我们将描述这个模型的组成部分，分析它们的运作，并建立一个简单的模型，我们将应用于一个小规模的 NMT 问题(神经机器翻译)。为了阅读更多关于我们将要解决的问题，并了解基本的注意力机制是如何工作的，我推荐你阅读我以前的帖子“编码器-解码器模型和注意力机制指南”。

为什么我们需要变压器

在诸如神经机器翻译的序列到序列问题中，最初的提议是基于在编码器-解码器架构中使用 RNNs。这些体系结构在处理长序列时有很大的局限性，当新元素加入序列时，它们保留第一个元素信息的能力就丧失了。在编码器中，每一步中的隐藏状态都与输入句子中的某个词相关联，通常是最近的一个词。因此，如果解码器只访问解码器的最后一个隐藏状态，它将丢失序列的第一个元素的相关信息。然后为了处理这个限制，引入了一个新概念注意力机制。

与 RNNs 通常关注编码器的最后状态不同，在解码器的每个步骤中，我们会查看编码器的所有状态，从而能够访问关于输入序列所有元素的信息。这就是 attention 所做的，它从整个序列中提取信息，一个所有过去编码器状态的加权和。这允许解码器为输出的每个元素分配更大的权重或重要性给输入的某个元素。在每一步中学习聚焦于输入的正确元素，以预测下一个输出元素。

但是这种方法仍然有一个重要的限制，每个序列必须一次处理一个元素。编码器和解码器都必须等到完成t-1步骤才能处理t-th步骤。因此，在处理庞大的语料库时，这是非常耗时和计算效率低下的。

变压器是什么？

在这项工作中，我们提出了 Transformer，这是一种避免递归的模型架构，它完全依赖于一种注意机制来绘制输入和输出之间的全局依赖关系。Transformer 允许显著提高并行性……Transformer 是第一个完全依赖自我关注来计算其输入和输出表示而不使用序列比对 RNNs 或卷积的转导模型。

“注意力是你所需要的全部”论文[1]

Transformer 模型使用自我关注机制提取每个单词的特征，以计算出句子中所有其他单词对前面提到的单词的重要性。并且没有使用递归单元来获得该特征，它们只是加权和与激活，因此它们可以是非常并行和高效的。

但是我们将更深入地研究它的架构(下图)，以理解所有这些部分的作用[1]。

摘自瓦斯瓦尼等人 2017 年发表的论文《注意力是你所需要的一切》

我们可以看到，左边是编码器模型，右边是解码器模型。两者都包含一个重复 N 次的“注意力和前馈网络”的核心模块。但首先我们需要深入探讨一个核心概念:自我关注机制。

自我关注:基本操作

自我关注是一个序列对序列的操作:一个向量序列进去，一个向量序列出来。我们称输入向量为x1、x2、…、xt以及相应的输出向量为y1、y2、…、yt。向量都具有维度 k。为了产生输出向量yi，自关注操作简单地对所有输入向量进行加权平均，最简单的选择是点积。

彼得·布鲁姆的《从零开始的变形金刚》

在我们模型的自我关注机制中，我们需要引入三个元素:查询、值和键

查询、值和键

在自我关注机制中，每个输入向量都以三种不同的方式使用:查询、键和值。在每个角色中，它都与其他向量进行比较，以获得自己的输出yi(查询)，获得第 j 个输出yj(键)，并在建立权重(值)后计算每个输出向量。

为了获得这个角色，我们需要三个维度为k×k的权重矩阵，并为每个xi计算三个线性变换:

彼得·布鲁姆的《从零开始的变形金刚》

这三个矩阵通常被称为 K 、 Q 和 V、、三个可学习的权重层，它们被应用于相同的编码输入。因此，由于这三个矩阵中的每一个都来自相同的输入，我们可以将输入向量的注意机制应用于其自身，即“自我注意”。

成比例的点积注意力

输入包括维度dk的查询和关键字，以及维度dv的值。我们计算查询与所有键的点积，将每个键除以dk的平方根，并应用softmax函数来获得值的权重。

“注意力是你所需要的全部”论文[1]

然后我们使用 Q 、 K 和 V 矩阵来计算注意力得分。分数衡量的是在某个位置的一个单词上对输入序列的其他位置或单词的关注程度。也就是说，查询向量与我们正在评分的相应单词的关键向量的点积。因此，对于位置 1，我们计算点积。)的q1和k1，然后是q1。k2，q1。k3以此类推，…

接下来，我们应用“缩放”因子来获得更稳定的梯度。softmax 函数无法在大值下正常工作，导致梯度消失并减慢学习速度[2]。在“软最大化”之后，我们乘以值矩阵以保留我们想要关注的单词的值，并最小化或移除不相关单词的值(它在 V 矩阵中的值应该非常小)。

这些操作的公式是:

摘自瓦斯瓦尼等人 2017 年发表的论文《注意力是你所需要的一切》[1]。标度点积注意力公式。

多头注意力

在前面的描述中，注意力分数一次集中在整个句子上，这将产生相同的结果，即使两个句子以不同的顺序包含相同的单词。相反，我们希望关注单词的不同部分。“我们可以给自我注意更大的区分能力，* 通过组合几个自我注意头， 把词向量分成固定数量(h，头数)的组块，然后在相应的组块上应用自我注意，使用 Q，K，V 子矩阵。、【2】彼得·布鲁姆、《从零开始的变形金刚》。这产生了不同的分数输出矩阵。*

摘自瓦斯瓦尼等人 2017 年发表的论文《注意力是你所需要的一切》

但是下一层(前馈层)只需要一个矩阵，每个单词一个向量，所以“在计算每个头部的点积之后，我们将输出矩阵连接起来，并乘以一个额外的权重矩阵* *Wo* ，【3】。这个最终的矩阵从所有的注意力头获取信息。*

位置编码

我们简单地提到，句子中单词的顺序是这个模型中要解决的问题，因为网络和自我注意机制是排列不变的。如果我们打乱输入句子中的单词，我们会得到相同的解。我们需要创建单词在句子中的位置的表示，并将其添加到单词嵌入中。

为此，我们将“位置编码”添加到编码器和解码器堆栈底部的输入嵌入中。位置编码与嵌入具有相同的维数，因此两者可以相加。有许多位置编码的选择。

“关注是你所需要的”论文

因此，我们应用一个函数将句子中的位置映射到一个实值向量。网络将学习如何使用这些信息。另一种方法是使用位置嵌入，类似于单词嵌入，用向量对每个已知位置进行编码。“在训练循环期间，需要所有接受的位置的句子，但是位置编码允许模型推断出比训练期间遇到的序列长度更长的序列长度”，【2】。

在该论文中，应用了正弦函数:

摘自瓦斯瓦尼等人 2017 年发表的论文《注意力是你所需要的一切》[1]。位置编码

编码器

现在已经描述了模型的所有主要部分，我们可以介绍编码器组件了，[4]:

  • 位置编码:将位置编码添加到输入嵌入中(我们的输入单词被转换成嵌入向量)。“在两个嵌入层(编码器和解码器)和预 softmax 线性变换之间共享相同的权重矩阵。在嵌入层中，我们将这些权重乘以模型维度的平方根“”[1]。
  • N=6相同层，包含两个子层:一个多头自关注机构，和一个全连接前馈网络(两个线性变换和一个 ReLU 激活)。但是它是按位置应用于输入的，这意味着同一个神经网络被应用于属于句子序列的每一个“标记”向量。

  • 每个子层(attention 和 FC 网络)周围都有一个残差连接，将该层的输出与其输入相加，之后是一个层归一化。
  • 在每个残差连接之前，应用一个正则化:“在将每个子层的输出添加到子层输入并归一化之前，我们对每个子层的输出应用丢失。此外，我们对编码器和解码器堆栈“”[1]中的嵌入和位置编码的总和应用丢失，丢失率为 0.1。

归一化和残差连接是用来帮助深度神经网络更快更准确地训练的标准技巧。层标准化仅应用于嵌入维度。

彼得·布鲁姆，《从零开始的变形金刚》[2]

首先，我们实现编码器层，六个模块中的每一个都包含在编码器中:

下图将显示详细的组件:

杰伊·阿拉玛的《变形金刚》

编码器代码:

记住只有来自最后一层(第 6 层)的向量被发送到解码器。

解码器

解码器与编码器共享一些组件，但考虑到编码器输出，它们的使用方式有所不同[4]:

  • 位置编码:类似编码器中的位置编码
  • N=6相同的层，包含 3 个三子层。第一，掩蔽多头注意或掩蔽因果注意，以防止位置注意后续位置。“这种屏蔽，结合输出嵌入偏移一个位置的事实，确保了位置 I 的预测可以仅依赖于小于 I 的位置处的已知输出”[1]* 。它是通过设置为与点积注意模块的 softmax 层中的禁止状态相对应的值来实现的。第二组件或“编码器-解码器关注”对解码器的输出执行多头关注，键和值向量来自编码器的输出，但是查询来自先前的解码器层。“这使得解码器中的每个位置都能处理输入序列中的所有位置”【1】。最后是全连接网络。*
  • 残差连接和层归一化*围绕每个子层，类似于编码器。*
  • 并重复在编码器中执行的相同的残差下降。

解码器层:

杰伊·阿拉玛的《变形金刚》

在 N 个堆叠解码器的末端，线性层，一个全连接的网络，将堆叠输出转换为一个更大的向量，即逻辑值。“soft max 层 然后把那些分数(logits)变成概率(都是正的，加起来都是 1.0)。选择具有最高概率的单元，并产生与之相关的单词作为该时间步长的输出“， [3] Jay Alammar，“图示变压器”。

解码器组件:

连接所有部件:变压器

一旦我们定义了我们的组件并创建了编码器、解码器和 linear-softmax 最终层，我们就可以将这些部分连接起来，形成我们的模型，即 Transformer。

值得一提的是我们创建了 3 个遮罩，每个遮罩都允许我们:

  • **编码器掩码:填充掩码，用于从注意力计算中丢弃填充标记。
  • 解码器掩码 1 :该掩码是填充掩码和前瞻掩码的联合，有助于因果注意力“在未来”丢弃令牌。我们取填充掩码和前瞻掩码之间的最大值。
  • 解码器掩码 2:它是填充掩码，应用于编码器-解码器关注层。

正如你所看到的，然后我们调用编码器、解码器和最终的 linear-softmax 层来获得我们的 Transformer 模型的预测输出。

图片来自pix abayGerd Altmann

训练变压器模型

现在，我们已经详细描述了本文中的组件，我们准备实现它们，并在 NMT 问题上训练一个转换器模型。这是一个出于教育目的的玩具问题。

我们不会在这篇博文中处理数据争论。请点击我在简介中提到的链接，获取更多信息，并查看所提供的代码，以了解数据是如何加载和准备的。总之，创建词汇，标记化(包括一个eos和sos标记)并填充句子。然后我们创建一个数据集，一个批量数据生成器，用于批量训练。

我们需要创建一个定制的损失函数来屏蔽填充标记。

我们使用论文中描述的 Adam 优化器，包括beta1=0.9、beta2=0.98和epsilon=10e-9。然后，我们创建一个调度程序，根据以下内容改变训练过程中的学习率:

“你所需要的只是关注”论文。学习率衰减。

主训练功能

训练功能类似于许多其他 Tensorflow 训练，是序列到序列任务的常见训练循环:

  • 对于生成批量输入和输出的批量生成器上的每次迭代
  • 得到从 0 到 length-1 的输入序列，以及从 1 到 length 的实际输出，每个序列步骤中预期的下一个字。
  • 调用变压器来获得预测
  • 计算实际输出和预测之间的损失函数
  • 应用梯度来更新模型中的权重并更新优化器
  • 计算批次数据的平均损失和准确度
  • 显示一些结果并保存每个时期的模型

就这样，我们有了训练模型的所有必要元素，我们只需要创建它们并调用训练函数:

Jr Korpa 在 Unsplash 上拍摄的照片

做预测

当训练 ML 模型时，我们不仅对优化损失或准确性感兴趣，我们还希望我们的模型做出足够好的预测，在这种情况下，看看模型如何处理新句子。预测函数将向模型输入标记化的句子，并返回预测的新句子，在我们的示例中，是从英语到西班牙语的翻译。

这是该过程中的步骤:

  • 将输入句子标记为一系列标记
  • 将初始输出序列设置为sos标记
  • 直到我们达到最大长度或者模型返回了eos令牌
  • 预测下一个单词。该模型返回 logits，请记住，在损失计算中应用了 softmax 函数。
  • 获取概率最高的单词在词汇表中的索引
  • 将预测的下一个单词连接到输出序列

最后，我们的最后一个函数接收一个英语句子，调用转换器将其翻译成西班牙语并显示结果。

对于这个例子，我们只是用模型维度的一些值和前馈网络的单元进行实验，来训练模型一个小时。如果您想要优化模型，您可能应该对其进行更长时间的训练，并为超参数设置许多不同的值。

代码在我的 github 库 Transformer-NMT 中可用。代码部分摘自 Udemy 上 SuperDataScience 团队的一门名为《Python 中的现代自然语言处理》的优秀课程。我强烈推荐。

翻译的一些例子是:

**#Show some translations*
sentence = "you should pay for it."
print("Input sentence: {}".format(sentence))
predicted_sentence = translate(sentence)
print("Output sentence: {}".format(predicted_sentence))**Input sentence: you should pay for it. 
Output sentence: Deberías pagar por ello.***#Show some translations*
sentence = "we have no extra money."
print("Input sentence: {}".format(sentence))
predicted_sentence = translate(sentence)
print("Output sentence: {}".format(predicted_sentence))**Input sentence: we have no extra money. 
Output sentence: No tenemos dinero extra.***#Show some translations* sentence = "This is a problem to deal with."
print("Input sentence: {}".format(sentence))
predicted_sentence = translate(sentence)
print("Output sentence: {}".format(predicted_sentence))**Input sentence: This is a problem to deal with. 
Output sentence: Este problema es un problema con eso.***

我希望您喜欢尝试 Transformer 模型。在以后的帖子中，我们将处理另一个 NLP 任务。

参考

[1]瓦斯瓦尼、阿希什&沙泽尔、诺姆&帕马尔、尼基&乌兹科雷特、雅各布&琼斯、利翁&戈麦斯、艾丹&凯泽、卢卡什&波洛舒欣、伊利亚、《注意力就是你需要的一切》，2017。

[2]彼得·布洛姆，《从零开始的变形金刚》博文，2019。

[3]杰·阿拉玛，《变形金刚》博文，2018。

[4]莉莲翁，“注意？立正！!"博文，2018。

[5]里卡多·法因德斯-卡拉斯科，《关注是你所需要的全部》的评论博文，2017

[6]亚历山大·拉什，《带注释的变形金刚》，2018，哈佛 NLP 小组。

AUC 及其在 CatBoost 中的实现

原文：https://towardsdatascience.com/auc-and-its-implementation-in-catboost-6bc740c01f98?source=collection_archive---------33-----------------------

本教程是关于受试者工作特征(ROC)曲线下的区域(AUC)及其在 CatBoost 中的实现，用于二元分类、多类分类和排序问题。

关于 AUC

ROC 曲线显示了模型区分等级的能力。

将类别随机分配给对象的模型是“坏的”分类器，并且具有对角 ROC 曲线。分类器越好，ROC 曲线越高。绘制 ROC 曲线，y 轴为 TPR、真阳性率，x 轴为 FPR、假阳性率。该曲线也可以根据模型的敏感性和特异性进行解释，y 轴为敏感性，x 轴为(1-特异性)。

构建和可视化 ROC 曲线可用于测量具有不同概率边界的分类算法性能和选择实现指定假阳性或假阴性率所需的概率边界。

AUC 是 ROC 曲线下的面积。对所有对象进行正确排序的模型的最佳 AUC = 1(所有具有类别 1 的对象被分配比类别 0 的对象更高的概率)。作为随机猜测的“坏”分类器的 AUC 等于 0.5。

AUC 用于二元分类、多类分类和排序问题。 AUC 测量正确排序对象的比例和模型区分类别的能力。

AUC 具有一个重要的统计特性:分类器的 AUC 相当于分类器将随机选择的阳性实例排列得高于随机选择的阴性实例的概率。

CatBoost 实现

对于二分类、多分类、排序问题，在 CatBoost 中有 AUC 的实现。您可以在过度拟合检测和自动最佳模型选择的训练期间计算 AUC，使用 model.eval_metric 评估新数据上的模型，并将 AUC 用作预测评估和与 utils.eval_metric 比较的指标。请参阅如何在真实数据集上使用 Catboost 中的 AUC 一节中使用 CatBoost 进行模型拟合和 AUC 计算的示例。

有用的链接

  • 在维基百科上阅读更多关于 ROC 的内容。
  • 要从头开始了解 ROC 曲线的构建，请参见文章。
  • 要了解多类分类的 AUCμ，请参见文章。

二元分类

二元分类的计算规则

二元分类的 AUC 根据以下公式计算:

其中 aᵢ,aⱼ —算法给出的物体属于类别 1 的预测(概率)。

对所有对象对 i，j 计算总和，使得: tᵢ=0，tⱼ=1 其中 t 是真正的类标签。

如果对象 i，j 排序正确，则 I 是等于 1 的指示函数:

用户可以为每个对象分配权重，以指定每个对象在度量计算中的重要性。

二元分类 AUC 计算的一个简单例子

让我们看一个简单的 ROC 曲线构建和 AUC 计算的例子:

我们有 10 个对象的样本，4 个来自类 1，6 个来自类 0(“类”列)。所有对象同等重要(权重= 1)。假设我们预测了对象来自类别 1 的概率(“预测”列)。

分母等于对象对的数量 i，j 使得真实类 tᵢ=0,tⱼ=1 。因为有 4 个来自类 1 的对象和 6 个来自类 0 的对象，所以分母等于 24。

对于来自类 1 的每个对象，计算来自类 0 的对象的数量，这些对象在排序的数据集中位于下面(概率较小)。

我们添加+1 个正确排序的对象(例如，id 为 0 和 4 的对象)，如果概率相等，则添加+0.5 个对象(例如，id 为 1 和 7 的对象)。

例如，ID = 1 的对象将+4.5 加到 AUC 分子上，与 ID:8，3，6，9 的对象正确排序，并且与对象 7 具有相同的预测:

denominator = sum(toy_example['class'] == 1) * sum(toy_example['class'] == 0)numerator = (6 + 5 + 4.5 + 2)manually_calculated_auc = numerator / denominatormanually_calculated_auc = 0.7292

让我们用 Catboost 计算同样的指标，并确保一切都是正确的:

catboost_auc = eval_metric(toy_example['class'], toy_example['prediction'], 'AUC')[0]

受试者工作特征曲线

要构建 ROC 曲线，请将类别 1 (n1)的对象数量放在正方形中，第 1 条边沿 y 轴，类别 0 (n0)的对象数量沿 x 轴。

按照由模型预测以降序排列的目标标签列表，将沿着 y 轴增加 1/n1，遇到类别 1 的对象，并且沿着 x 轴增加 1/n0，遇到类别 0 的对象。

通过“类”列从上到下，如果类是 1，我们就在图上向上，如果类是 0，我们就在图上向右。当遇到预测相同的对象时，将 y 轴上的数字 1 和 x 轴上的数字 0 相加，然后沿着矩形的对角线前进。

AUC:加权计算

CatBoost 允许我们为数据集中的每个对象分配一个权重，以便根据上面的公式计算 AUC。如果没有分配权重，所有权重都等于 1，因此 AUC 与正确排序对的数量成比例。如果分配给此属性的权重被更改。

权重对于不平衡的数据集非常有用。如果在训练数据集中存在具有少量样本的一类或一组对象，则增加相应对象的权重可能是合理的。

例如，如果我们将权重 10 分配给一个对象，这可以理解为将 9 个相同的对象添加到数据集。

让我们以权重= 10 的一个重要对象的错误和正确分类为例来计算 AUC。

roc_auc = catboost.utils.eval_metric(toy_example[‘class’], toy_example[‘prediction’], ‘AUC’, weight=toy_example[‘weight’])[0]

AUC = 0.9167。一个重要的对象被正确排序，AUC 增加

roc_auc = catboost.utils.eval_metric(toy_example['class'], toy_example['prediction'], 'AUC', weight=toy_example['weight'])[0]

AUC = 0.4417。一个重要对象订购错误，AUC 下降

多类分类的 AUC

Catboost 中的多类分类实现了两个 AUC 指标。

首先是 OneVsAll 。根据二元分类计算原则，对每个类别分别计算 AUC 值。

第二个是 AUC μ，其被设计为满足以下特性:

  • 物业 1。如果模型在每个例子中给出正确标签的概率最高，那么 AUC = 1
  • 房产 2。对实施例的随机猜测产生 AUC = 0.5
  • 房产 3。AUC 对类别偏差不敏感

AUCμ可以解释为类别之间成对 AUC 的平均值。详情可在文章中找到。

OneVsAll AUC

Catboost 中的 OneVsAll AUC 返回 n-class 分类的 n 个 AUC 值。根据二进制分类计算规则，为从 0 到 K–1 编号的每个类 K 单独计算该值。类别 k 的对象被认为是正的，而所有其他的被认为是负的。

它的工作方式与二进制分类几乎相同，所以我在这里跳过计算细节(它们在 iPython 笔记本中)。

OneVsAll AUC 衡量分类器区分一类对象与另一类对象的能力。

OneVsAll 的一个优势是能够分别监控不同类的性能。

AUCμ

AUCμ可用作评估度量以防止过度拟合，而 OneVsAll AUC 仅可用于包含 k 值的信息(k 是类的数量)。

让我们来看看 AUCμ公式:

K 是班数， i < j ≤ K 是班数。

S(i，j) 是类 i 和 j 之间的可分性度量，定义为:

在哪里

  • I 是应用于 O 结果的指示函数，如果 O返回正值则返回 1，如果O返回负值则返回 0，如果O返回 0 则返回 0.5。
  • O 是一个方向函数，指示两个实例的顺序是正确、错误还是相同。如果预测排序正确，则返回正值；如果排序错误，则返回负值；如果排序相同，则返回 0。
  • a，b 分别是来自类 i，j 的对象，
  • p(a)，p(b) 是对象属于类别的预测概率的向量，
  • y(a)，y(b) 是对象的真标签 a，b (一热向量)，
  • vᵢ ⱼ 是一个两类决策超平面法向量。

O 计算如下:

向量 v_i，j 来自误分类代价矩阵 A ，该矩阵是在学习任务之后手动定义的。

vᵢ ⱼ=A ᵢ.—ⱼ.

一个 ᵢ ⱼ 是当实例的真实类是 j 时，将实例分类为类 i 的成本。然后，A 在(k1)—单纯形上定义一个划分，并归纳出 K 类之间的决策边界。

默认的误分类成本矩阵值在任何地方都是 1，除了对角线上的值是 0。它被称为 argmax 划分矩阵，因为它以最大概率分配一个类。

这是一个具有 argmax 划分矩阵 a 的 3 类分类问题的划分。对于使用定义的划分矩阵，边界(由箭头标记)被移动。

请关注文章了解更多详情。

CatBoost 允许我们设置误分类成本矩阵 A 和对象的权重来计算 AUCμ。

让我们计算一个非常小的例子的 AUCμ，这个例子有 3 个类和 4 个对象:

让我们计算每个有序类对的 S(i，j ):

让我们用 Catboost AUCμ计算相同的指标，并确保一切都是正确的:

我们可以看到 AUCμ相当高，但实际上，算法性能很差，精度为 0.25。因此，在培训期间评估其他重要指标是合理的。

AUCμ是评估算法在多分类问题中分类能力的一个很好的概括度量。在文章的第 4.3 节中可以看到更多关于多类 AUC 计算的不同方法及其特性。

AUCμ可以解释为类别之间成对 AUC 的平均值。与 OneVsAll AUC 不同，AUCμ是单个值，因此它可以在用于过拟合检测和树修剪的训练期间用作评估度量。

排名的 AUC

对于 CatBoost 中的排名，有两种不同的 AUC。

经典 AUC

用于具有对数损失和交叉熵损失函数的模型。它具有与二元分类的 AUC 相同的公式:

aᵢ ， aⱼ —预测对象的等级 i，j 。

对所有对象对 i，j 计算总和，使得: tᵢ=0，tⱼ=1 其中 t 是相关的。

上面的公式适用于目标值等于 1 和 0 的简单任务。如果我们有更多的目标值呢？

如果目标类型不是二进制，那么具有目标值 t 和权重 w 的每个对象 i 被替换为两个对象用于度量计算:

  • 重量 wt 目标值为 1 的σ₁
  • 重量为w(1t)的σ₂ ，目标值为 0。

目标值必须在范围[0；1] 。

让我们为一个小例子计算排名的经典 AUC。假设我们有 2 个文档，2 个请求，相应的相关性在范围[1，5]内，预测相关性在范围[0，1]内:

数据预处理后(详见笔记本),我们得到:

让我们计算 AUC:

排名 AUC

AUC 排名用于损失函数排名。

aᵢ，是预测对象的等级 i，j 。

对所有对象对 i，j 计算总和，使得: tᵢ < tⱼ 其中 t 是相关的。

排名 AUC 直接衡量正确排名对的数量。问题是指标的计算不考虑组。在我们的例子中，我们有组(请求),并且我们可能想要测量组内的质量，但是目前，AUC 是在数据集上计算的，并且如果例如一个请求的前一个文档的排名低于另一个文档的前一个文档，而真实排名相反(但是仍然是每个文档的前一个),则 AUC 惩罚我们。

AUC 用于排序的另一个问题是，它没有将顶部对象与其他对象区分开来。如果我们有许多不相关的文档，这些文档被模型排序为不相关，但排名在前 10 位，AUC 可能仍然很高，因为不相关对象的“尾巴”比相关对象的排名低。

概观

AUC 是一种广泛使用的度量标准，用于衡量模型区分类别和正确排序来自不同类别/具有不同相关性的对象的能力。AUC 是不可微的，因此不能用作损失函数，但作为一种度量，它提供了很多信息，非常有用。

我们研究了以下 AUC 类型:

  • 二元分类的 AUC。这是一个经典的度量标准，用来衡量模型的质量。ROC 曲线允许选择概率阈值以满足所需的假阳性或假阴性率。
  • 多类分类的 AUC:OneVsAll 和 AUCμ。OneVsAll AUC 有助于控制每个类的算法性能，但不能用作防止过度拟合的度量。相反，AUCμ是一个很好的概括指标，但是不能检测一个类的问题。
  • 排名的 AUC:经典 AUC 和排名 AUC。AUC 适合于排序任务，因为它被设计成测量算法如何区分类别，并且它简单地转移到区分相关和不相关的对象。但是 AUC 没有考虑到在排序问题中，前 n 个位置非常重要，并且平等地对待每个正确排序的文档对。

要更深入地了解数据处理、计算细节以及在 CatBoost 中使用 AUC 的示例，请参见 iPython 笔记本，代码见 CatBoost 教程。

AUC-ROC:简化

原文：https://towardsdatascience.com/auc-roc-simplified-5914185d24e?source=collection_archive---------35-----------------------

直觉的理解

来源:https://pxhere.com

介绍

机器学习的一个重要方面是模型评估。你需要一些机制来评估你的模型。这就是这些性能指标发挥作用的地方，它们让我们感觉到你的模型有多好。如果你熟悉机器学习的一些基础知识，那么你必须了解这些指标，如准确度、精确度、召回率、auc-roc 等。

假设您正在处理一个二元分类问题，并提出了一个准确率为 95%的模型，现在我问您这实际上意味着什么，您可以很快说出您的模型做出的 100 个预测中，有 95 个是正确的。让我们更进一步，现在基本的指标是回忆，我问同样的问题，你可能会花一点时间，但最终你会得出一个解释，比如在 100 个相关数据点(一般为正类)中，你的模型能够识别其中的 80 个。到目前为止，我们假设您使用 AUC-ROC 作为指标评估您的模型，得到 0.75 的值，我再次问您同样的问题，0.75 或 75%意味着什么，现在您可能需要思考一下，有些人可能会说模型有 75%的机会正确识别数据点，但现在您应该已经意识到不是这样。让我们试着对分类问题中最流行的一个性能指标有一个直观的理解。

历史

如果你参加过任何在线机器学习竞赛/黑客马拉松，那么你一定遇到过曲线下面积-接收器操作员特征，也称为 AUC-ROC，其中许多人将它作为他们分类问题的评估标准。让我们承认，当你第一次听说它的时候，你一定有过这样的想法，这个又长又花哨的名字是怎么回事？ROC 曲线的起源可以追溯到第二次世界大战，它最初用于分析雷达信号。美国陆军试图测量他们的雷达接收机在信号噪声中正确识别日本飞机的能力。现在我们有了一个小小的起源故事，让我们进入正题

几何解释

这是你在谷歌上搜索 AUC-ROC 时会遇到的最常见的定义。基本上，ROC 曲线是显示分类模型在所有可能阈值下的性能的图表(阈值是一个特定值，超过该值，您就说某个点属于特定类别)。曲线绘制在两个参数之间

  • 真阳性率
  • 假阳性率(FPR)

在理解 TPR 和 FPR 之前，让我们先快速看一下混淆矩阵。

来源:知识共享

  • 真阳性:实际阳性和预测阳性
  • 真阴性:实际阴性，预测为阴性
  • 假阳性(I 型错误):实际阴性但预测为阳性
  • 假阴性(II 型错误):实际阳性但预测为阴性

简单来说，你可以把假阳性称为假报警，把假阴性称为漏警。 现在让我们看看 TPR 和 FPR 是什么情况。

作者图片

作者图片

基本上，TPR/回忆/灵敏度是正确识别的阳性样本的比率，FPR 是错误分类的阴性样本的比率，如前所述，ROC 只不过是 TPR 和 FPR 之间跨越所有可能阈值的图，AUC 是该 ROC 曲线下的整个面积。****

来源:知识共享

概率解释

我们看了几何解释，但我想这仍然不足以开发 0.75 AUC 实际含义背后的直觉，现在让我们用概率的观点看一下 AUC-ROC。

让我先谈谈 AUC 的工作，稍后我们将在此基础上建立我们的理解

AUC 衡量模型区分类别的能力

0.75 的 AUC 实际上意味着假设我们取属于不同类别的两个数据点，那么有 75%的机会模型能够分离它们或者正确地对它们进行排序，即正点比负类具有更高的预测概率。(假设较高的预测概率意味着该点理想情况下属于正类)

下面举个小例子，让事情更清楚。

**╔═══════╦═══════╦═════════════╗
║ Index ║ Class ║ Probability ║
╠═══════╬═══════╬═════════════╣
║ P1    ║     1 ║ 0.95        ║
║ P2    ║     1 ║ 0.90        ║
║ P3    ║     0 ║ 0.85        ║
║ P4    ║     0 ║ 0.81        ║
║ P5    ║     1 ║ 0.78        ║
║ P6    ║     0 ║ 0.70        ║
╚═══════╩═══════╩═════════════╝**

这里我们有 6 个点，其中 P1、P2、P5 属于第 1 类，P3、P4、P6 属于第 0 类，并且在概率列中有相应的预测概率，正如我们说过的，如果我们取两个属于不同类的点，那么模型秩正确排序它们的概率是多少

我们将采取所有可能的配对，这样一个点属于类 1，另一个点属于类 0，我们将有总共 9 个这样的配对，下面是所有这 9 个可能的配对

**╔═══════╦═════════╦═══════════╗
║ Index ║  Pair   ║ IsCorrect ║
╠═══════╬═════════╬═══════════╣
║     1 ║ (P1,P3) ║ Yes       ║
║     2 ║ (P1,P4) ║ Yes       ║
║     3 ║ (P1,P6) ║ Yes       ║
║     4 ║ (P2,P3) ║ Yes       ║
║     5 ║ (P2,P4) ║ Yes       ║
║     6 ║ (P2,P6) ║ Yes       ║
║     7 ║ (P3,P5) ║ No        ║
║     8 ║ (P4,P5) ║ No        ║
║     9 ║ (P5,P6) ║ Yes       ║
╚═══════╩═════════╩═══════════╝**

此处，列 isCorrect 表示所提及的点对是否是基于预测概率的正确排序，即 1 类点比 0 类点具有更高的概率，在这 9 个可能的点对中的 7 个中，1 类点的排序高于 0 类点，或者我们可以说，如果选择一对属于不同类的点，模型将有 77%的机会能够正确区分它们。沃拉。现在，我认为您可能对这个 AUC 数字有一点直觉，只是为了澄清任何进一步的疑问，让我们使用 scikit learn 的 AUC-ROC 实现来验证它

AUC 验证的样本代码(图片由作者提供)

何时使用

尽管如此，AUC-ROC 在某些地方可能并不理想。

  • AUC-ROC 在数据集严重失衡的情况下效果不佳，为了给出一些直觉，让我们回顾一下这里的几何解释。基本上 ROC 是 TPR 和 FPR 之间的情节(假设少数阶级是积极阶级)，现在让我们再次仔细看看 FPR 公式

作者图片

FPR 的分母有一个真阴性作为一个因素，因为阴性类占多数。FPR 的分母由真阴性主导，这使得 FPR 对少数类预测的任何变化不太敏感(由于分母较高，假阳性数字的任何变化在 FPR 没有得到适当反映)。为了克服这个问题，使用精确召回曲线代替接收方操作者特征曲线，然后计算 AUC，尝试自己回答这个问题精确召回曲线如何处理这个问题(提示:比较 PR 曲线和 ROC 输入，召回和 TPR 是相同的，技术上只有 FPR 被精确代替，只需比较两者的分母，并尝试评估 PR 曲线中不平衡问题是如何解决的)**

  • AUC-ROC 试图衡量分类的等级排序是否正确，它没有考虑实际预测的概率，让我用一小段代码来说明这一点
**import pandas as pdy_pred_1 = [0.99,0.98,0.97,0.96,0.91,0.90,0.89,0.88]
y_pred_2 = [0.99,0.95,0.90,0.85,0.20,0.15,0.10,0.05]
y_act = [1,1,1,1,0,0,0,0]
test_df = pd.DataFrame (zip(y_act,y_pred_1,y_pred_2),columns=['Class','Model_1','Model_2'])
test_df**

两个样本模型(图片由作者提供)

如上所述，我们有两个模型 Model_1 和 Model_2，这两个模型都很好地隔离了这两个类别，但是如果我让你从它们中选择一个，你会选择哪一个，请稍等片刻，让我先画出这些模型的概率。

**import matplotlib.pyplot as pltcols = ['Model_1','Model_2']
fig,axs = plt.subplots(1,2,figsize=(15,5))
for index,col in enumerate(cols): 
    sns.kdeplot(d2[d2['Status']==1][col],label="Class 1",shade=True,ax=axs[index])
    sns.kdeplot(d2[d2['Status']==0][col],label="Class 0",shade=True,ax = axs[index])
    axs[index].set_xlabel(col)
plt.show()**

预测概率分布(图片由作者提供)

如果之前有任何轻微的疑问，我想现在你的选择将是非常清楚的，Model_2 是一个明显的赢家。但两者的 AUC-ROC 值是相同的，这是它的缺点，它只是测量模型是否能够正确地对类进行排序，它不查看模型区分两个类的程度，因此，如果您需要使用实际预测的概率，那么 AUC-ROC 可能不是正确的选择，对于那些好奇的人来说，log loss 是解决此问题的一种度量

因此，理想情况下，当数据集没有严重的不平衡，并且您的用例不要求您处理实际预测的概率时，应该使用 AUC-ROC。

多类别的 AUC

对于多类设置，我们可以简单地使用一个对所有的方法，每个类都有一条 ROC 曲线。假设您有四个类别 A、B、C、D，那么所有四个类别都有 ROC 曲线和相应的 AUC 值，即，一旦 A 是一个类别，B、C 和 D 组合起来就是其他类别，类似地 B 是一个类别，A、C 和 D 组合起来就是其他类别，等等。

结束注释

AUC-ROC 是您在处理分类问题时会经常遇到的东西，无论是在线黑客马拉松还是您的组织中分配给您的项目。我希望我能够对 AUC-ROC 到底是什么以及何时使用它给出一些基本的理解。如果您想讨论什么或有任何建议，可以通过以下方式联系我:

****领英:【https://www.linkedin.com/in/ravindra-sharma-832a04156 ****

参考

[1]: 《利用受试者工作特征(ROC)曲线分析分类模型:历史兴趣的最后注解》 (PDF)。犹他大学数学系。犹他大学数学系。检索于 2017 年 5 月 25 日**

使用 PyTorch 的生态系统工具进行音频分类

原文：https://towardsdatascience.com/audio-classification-with-pytorchs-ecosystem-tools-5de2b66e640c?source=collection_archive---------20-----------------------

PYTORCH 生态系统

torchaudio 和 Allegro 列车介绍

torchaudio 和 Allegro 列车的音频分类

音频信号无处不在。因此，对各种场景的音频分类越来越感兴趣，从听力受损者的火警检测，通过用于维护目的的引擎声音分析，到婴儿监控。虽然音频信号本质上是时间性的，但在许多情况下，可以利用图像分类领域的最新进展，并使用流行的高性能卷积神经网络进行音频分类。在这篇博文中，我们将通过使用将音频信号转换到频域的流行方法来演示这样一个例子。

这篇博文是关于如何利用 PyTorch 的生态系统工具轻松启动 ML/DL 项目的系列文章的第三篇。之前的博文主要关注图像分类和超参数优化。在这篇博文中，我们将展示如何使用 Torchaudio 和 Allegro Trains 实现简单高效的音频分类。

基于卷积神经网络的音频分类

近年来，卷积神经网络(CNN)已被证明在图像分类任务中非常有效，这导致了各种架构的设计，如 Inception、ResNet、ResNext、Mobilenet 等。这些 CNN 在图像分类任务上实现了最先进的结果，并提供了各种现成的经过预先训练的骨干。因此，如果我们能够将音频分类任务转移到图像领域，我们将能够利用这些丰富的主干来满足我们的需求。

如前所述，我们希望将音频信号转换成图像，而不是直接使用声音文件作为振幅与时间信号。以下预处理是使用这个脚本在 YesNo 数据集上完成的，该数据集包含在 torchaudio 内置数据集中。

作为预处理的第一阶段，我们将:

  • 使用 torchaudio 读取音频文件
  • 以固定的采样率对音频信号进行重新采样 —这将确保我们将使用的所有信号都具有相同的采样率。理论上，采样信号可以代表的最大频率略低于采样率的一半(称为奈奎斯特频率)。由于 20 kHz 是人类通常能听到的最高频率，44100 Hz 的采样率被认为是最受欢迎的选择。然而，在许多情况下，为了减少每个音频文件的数据量，移除较高的频率被认为是合理的。因此，对于低比特率的 MP3 文件，20050 Hz 的采样率已经相当普遍。在我们的例子中，我们将使用这个采样率。
  • 创建单声道音频信号 —为简单起见，我们将确保我们使用的所有信号都有相同数量的声道。

这种预处理的代码如下:

生成的 matplotlib 图如下所示:

来自 YESNO 数据集的音频信号时间序列

现在是时候将这个时序信号转换到图像域了。我们将通过将其转换为频谱图来实现，频谱图是信号频谱随时间变化的直观表示。为此，我们将使用对数标度的 mel 谱图。mel 频谱图是一种频谱图，其中频率被转换为 mel 标度，Mel 标度考虑了这样一个事实，即人类在较低频率下比在较高频率下更善于检测差异。mel 音阶会转换频率，使音高距离相等的人听起来距离相等。

因此，让我们使用 torchaudio 转换，并将以下代码行添加到我们的代码片段中:

现在，音频文件被表示为二维频谱图图像:

Mel 光谱图(上图)及其对数标度版本(下图)

这正是我们想要实现的。音频分类问题现在转化为图像分类问题。

使用 Allegro-Trains、torchaudio 和 torchvision 进行音频分类

Pytorch 的生态系统包括各种开源工具，可以启动我们的音频分类项目，并帮助我们管理和支持它。在这篇博客中，我们将使用其中的三种工具:

  • Allegro Trains 是一款开源的机器学习和深度学习实验管理器和 MLOps 解决方案。它提高了人工智能团队的效率和生产力，以及本地和云 GPU 的利用率。Allegro Trains 帮助研究人员和开发人员零集成地管理复杂的机器学习项目。
  • Torchaudio 是一个由 I/O 函数、流行数据集和常见音频转换组成的包。
  • Torchvision 是一个由流行的数据集、模型架构和计算机视觉的通用图像转换组成的包。

为了简单起见，我们不会在这个博客中解释如何安装一个 Trains-server 。因此，实验将被记录在 Allegro Trains 演示服务器上。有关如何部署自托管 Trains 服务器的更多信息，请参见 Allegro Trains 文档。

出于本博客的目的，我们将使用 UrbanSound8K 数据集，该数据集包含来自 10 个类别的 8732 个带标签的声音摘录(< =4s)，包括狗叫、警笛和街头音乐。我们将使用预训练的 ResNet 模型来分类这些音频文件。

我们将从初始化 Allegro Trains 来跟踪我们所做的一切开始:

接下来，我们将确保代码中没有隐藏“神奇数字”,并且所有脚本参数都反映在实验管理器 web 应用程序中。当编写 python 脚本时，可以使用流行的 argparse 包，Allegro Trains 会自动拾取它。在我们编写 Jupyter 笔记本示例时，我们将定义一个配置字典，并将其连接到 Allegro Trains 任务对象:

现在是时候定义我们的 PyTorch 数据集对象了。这个对象应该包括数据加载和数据预处理。数据集元数据的加载在类的构造函数中完成，并基于 UrbanSound8K 数据集结构进行配置。因此，它将如下所示:

接下来我们要做的是定义 Dataset 类的 __ getitem__ 方法。如前所述，我们希望这部分执行几个预处理步骤:

  1. 加载音频文件
  2. 将其重新采样到预配置的采样速率，注意这里这样做是为了简单起见。对音频文件进行重新采样是一项耗时的功能，会显著降低训练速度，并导致 GPU 利用率下降。建议在训练周期之前对所有文件执行该预处理功能。
  3. 将其转换成单声道音频信号
  4. 将其转换成 Mel 频谱图信号

除此之外，我们希望所有转换后的信号具有相同的形状。因此，我们将把所有 Mel 光谱图裁剪到一个预先配置的长度，并把比这个长度短的光谱图补零。结果应该是这样的:

现在最精彩的部分来了。由于我们已经将问题从音频域转换到图像域，所以我们不需要担心定义模型。我们可以使用 Torchvision 自带的内置模型之一。我们决定选择有效且健壮的 ResNet 模型。由于数据集很小，我们希望降低过度拟合的风险，因此我们将使用小而有效的 ResNet18 模型。除了我们刚刚采取的这个伟大的捷径，Torchvision 使我们能够加载在 Imagenet 上预先训练的模型，因此训练将更短，更有效。

我们需要做的就是使模型的输入层和输出层适应我们的数据。这很容易做到，如下所示:

就是这样！我们可以开始训练我们的模型了。在这篇博客中，我们不会讨论培训和评估循环的结构。它们非常简单明了——你可以在完整笔记本中查找它们。我们只需注意，在训练和评估过程中，我们确保将音频信号、标量(损耗、精度)和频谱图报告给 PyTorch 的内置 TensorBoard 类，以便进行调试。Allegro Trains 会自动拾取发送到 TensorBoard 的所有报告，并将它们记录在 web 应用程序中您的实验下。

我们剩下要做的就是使用火车代理在本地或远程机器上执行我们的 Jupyter 笔记本，并在 Allegro Trains 的 web 应用上观看我们的培训进度。

Allegro Trains webapp 中标量报告的快照

因为我们确保每隔几个迭代就报告调试数据，所以我们可以检查 Allegro Trains webapp 中的调试样本部分，并确保输入模型的数据是有意义的。我们可以听原始音频信号或检查频谱图:

Mel 光谱图调试报告的快照

音频调试样本的快照

摘要

自动音频分类是一个不断发展的研究领域，包括语音、音乐和环境声音等领域。这一新兴领域可以极大地受益于丰富的经验和为计算机视觉任务开发的各种工具。因此，利用 PyTorch 生态系统开源工具可以推动您的音频分类机器学习项目。您不仅可以享受一套免费的开源生产力工具，还可以通过将信号从时域转换到频域，使用一套强大且经过验证的预训练计算机视觉模型。

在本教程中，我们演示了如何使用 Tochaudio、Torchvision 和 Allegro Trains 来完成简单有效的音频分类任务。通过零集成工作和零成本，您可以获得一个通用的培训和评估脚本。要了解更多信息，请参考快板列车文件、火炬广播文件和火炬广播文件。

在本系列的下一篇博文中，我们将展示如何使用 PyTorch 生态系统轻松创建机器学习管道。这对于我们有重复任务序列的情况非常有效。比如预处理和训练，就像我们在这篇博文开头提到的。

原载于 2020 年 10 月 18 日https://allegro . ai。

音频开始检测:使用 Librosa 为棒球应用程序准备数据

原文：https://towardsdatascience.com/audio-onset-detection-data-preparation-for-a-baseball-application-using-librosa-7f9735430c17?source=collection_archive---------30-----------------------

使用声音来识别视频中的击球时间

周隼在 Unsplash 上拍照

介绍

我希望为棒球应用程序建立一个深度学习项目，其中一个挑战是数据收集。我需要很多击球手击球的短片。但是我在网上找不到这种数据集，因此，我决定自己收集和制作数据集。

我发现的大多数棒球击球视频在一个长视频剪辑中包含多次击球，例如:

我需要找到击球的瞬间，把它们剪下来，分成短片。一种简单的方法是手工操作，但是这非常费时费力。

我需要一个工具来自动完成这项工作。

受郑健国作品《用深度学习视频分析构建机器人裁判》的启发，我决定尝试一下 【发病检测】 。

经过一些研究和阅读教程，如这个，我使用 librosa 的发作检测功能。

加载视频

第一步是从 YouTube 下载并加载视频。我用 pafy 做的。

filename='batting_pratice' 
url='https://www.youtube.com/watch?v=dbZy8Q6J7pw' 
video = pafy.new(url)
clip = video.getbest(preftype="mp4")
clip.download()
os.rename(clip.filename,filename+'.mp4')

该视频现已下载并保存为“batting _ pratice.mp4”

加载音频

然后我可以用 librosa 加载音频。

x, sr = librosa.load(filename+'.mp4')

如果你感兴趣就去玩吧。

ipd.Audio(data=x, rate=sr)

并绘制波形图

plt.figure(figsize=(14, 5))
librosa.display.waveplot(x, sr=sr)
plt.show()

音频波形图(图片由作者提供)

你可以看到有一些尖刺，是击球的声音。工作是确定它们的时间。

应用过滤器

一个额外的步骤是使用高通滤波器过滤一些低频噪声。可以使用 scipy 来完成。

from scipy.signal import butter,filtfilt**def** butter_highpass(data,cutoff, fs, order=5):
   """
   Design a highpass filter.
   Args:
   - cutoff (float) : the cutoff frequency of the filter.
   - fs     (float) : the sampling rate.
   - order    (int) : order of the filter, by default defined to 5.
   """
   # calculate the Nyquist frequency
   nyq = 0.5 * fs
   # design filter
   high = cutoff / nyq
   b, a = butter(order, high, btype='high', analog=False)
   # returns the filter coefficients: numerator and denominator
   y = filtfilt(b, a, data)
   return yx_f=butter_highpass(x,1000, sr, order=5)

发病检测

然后我们可以开始发作检测，我们使用 librosa.onset 。详细介绍可以在他们的 doc 中找到。

o_env = librosa.onset.onset_strength(x_f, sr=sr)
times = librosa.frames_to_time(np.arange(len(o_env)), sr=sr)
onset_frames = librosa.util.peak_pick(o_env, 3, 3, 3, 5, 0.3, 100)

在这之后，我们应该看到存储在 onset_frames 中的峰值。

然后我们可以绘制它并检查。

D = np.abs(librosa.stft(x_f))plt.figure(figsize=(15,10))ax1 = plt.subplot(2, 1, 1)
librosa.display.specshow(librosa.amplitude_to_db(D, ref=np.max),
x_axis='time', y_axis='log')
plt.title('Power spectrogram')plt.subplot(2, 1, 2, sharex=ax1)
plt.plot(times, o_env, label='Onset strength')
plt.vlines(times[onset_frames], 0, o_env.max(), color='r', alpha=0.9,
linestyle='--', label='Onsets')plt.axis('tight')
plt.legend(frameon=True, framealpha=0.75)
plt.show()

发病检测(图片由作者提供)

看起来我们确定了所有的发病点。

现在，我们可以将 onset_frames 转换为时间:

onset_times = librosa.frames_to_time(onset_frames)

这会返回一个时间数组。

然后，我们可以将数据放入数据帧中，并在特定时间创建 youtube URLs。

检查其中一个示例。成功了！

切断视频

然后，我们可以使用计时将视频剪切成短片。我想要 3 秒的剪辑，所以我从(开始时间-1.5)到(开始时间+1.5)开始。这可以使用 ffmpeg 来完成。

for hit_time in onset_times:ffmpeg_extract_subclip(filename+'.mp4',round(hit_time)-1.5,    
     round(hit_time)+1.5,  
     targetname=filename+'/'+filename+'_'+str(int(hit_time))+".mp4")

现在，我有了一个工具，可以根据声音来检测击球，并自动进行切割。下一步将使用该工具收集更多数据，用于进一步培训。

感谢阅读。欢迎提出建议和意见。

在这里支持我:【https://medium.com/@c.kuan/membership】T2

具有深度学习的音频源分离

原文：https://towardsdatascience.com/audio-source-separation-with-deep-learning-e7250e8926f7?source=collection_archive---------11-----------------------

基本上是一种听觉超能力

作者:阿卡什·库马尔、桑尼·卡雷尔、普拉吉瓦尔·波卡雷尔、卡尼什克·辛格、凯莉·特雷维尼奥和米盖尔·加尔萨

想象一下，走进一个拥挤嘈杂的自助餐厅，能够将你听到的所有噪音“解混”到各自的扬声器中。这就是音频源分离的问题:将输入的混合音频信号分解成它最初来自的源。

音频源分离，也称为鸡尾酒会问题，是音频领域最大的问题之一，因为它在许多情况下都有实际用途:识别歌曲的人声，帮助聋人在嘈杂的区域听到扬声器，在逆风骑自行车时隔离电话中的声音，你会明白这一点。

我们提出了一种利用深度学习的优势来解决这个问题的方法。

我们的数据

在处理这个问题时，我们使用了 UrbanNoise8K 和 LibriSpeech 数据集。UrbanNoise 数据集为我们提供了各种背景噪音，而 LibriSpeech 数据集为我们提供了各种人在没有任何背景噪音的情况下阅读一本书。我们自己为音调分离生成音调。

我们的方法

在对该主题进行初步研究后，我们决定使用频谱图来处理音频，而不是原始波形。虽然 Lyrebird 的 MelGAN 和 OpenAI 的全新 Jukebox 在生成原始音频波形方面取得了成功，但我们项目的时间框架和神经网络的深度不允许我们与原始音频进行交互，因为它非常复杂。使用频谱图(原始 STFT 输出)，我们不会丢失有关音频波形的信息，并且可以以最小的损失重建它。

为了新奇，我们决定尝试不同的独特损失函数和训练架构，概述如下。

模型

我们尝试了许多不同的模型进行实验，从普通卷积神经网络到密集层，但我们决定采用两种模型 A 和 b。这两种模型都具有下述 U-Net 风格的架构。

U-Net 架构最初在图像分割中获得成功，但后来也被用于光谱图分析。下图总结了架构。它包括缩减像素采样层，将图像的高度和宽度减少到一个点。然后使用某种策略对图像进行上采样。残差(跳过)连接被添加到在相应的上采样层和下采样层之间具有相同形状的层之间。

适用于音频的 U-Net 模型。从这张纸上检索。

我们在 PyTorch 中实现了模型 A，它基于上面参考资料中引用的 Choi 等人的论文中的图表。这个想法非常类似于 U-Net 的下采样和带有跳跃连接的上采样。神经变换层仅改变图像中通道的数量，而下采样/上采样层将图像的高度和宽度改变 2 倍(简单卷积)。神经变换层和下采样层的数量从 7 到 17 不等。

每个神经变换层是一个由 4 个批处理范数、ReLU 和卷积运算组成的密集块，如下图所示。密集块意味着每个较小的块接收所有先前块的输出作为输入，本质上是将通道添加到“全局状态”变量上。下图说明了这个想法。

神经变换层图。从这张纸上检索。

模型 B 是模型 A 的缩小版，没有批次标准层。这在下面引用的 Belz 的博客文章中取得了成功。

模型 A 和模型 B 的输入是混合信号的频谱图。对于模型 A，输出值是预测语音的声谱图，目标值是目标孤立语音的声谱图。模型 B 的一个变化是，输出值不是预测语音，而是预测噪声的声谱图，目标是目标噪声的声谱图。通过从输入混合信号中减去预测的噪声信号来预测模型 B 中的语音。

星等谱图描述。来源:文森特贝尔兹，通过媒介。

我们使用两种不同类型的光谱图。一种类型是简单的 STFT 输出，其产生复数值频谱图，并被表示为代表实部和虚部的双通道图像。另一种类型仅涉及将 STFT 的幅度作为单通道图像馈送，并在最后接收幅度谱图。用于重建的短语只是初始 STFT 相位(相位不变)，如上图所示。

损失函数

损失函数是优化最重要的部分之一，因为它决定了最小化哪个表面。我们测试了以下损失函数，并使用它们与加权的线性组合。

为了理解损失函数，让我们定义一些变量。v 是语音谱图信号。n 是噪声频谱图信号。m 是输入到神经网络的混合音频信号。

M = V + N

V* 是生成器看到 m 后给出的预估语音。

M →发电机→ V*

目标是得到尽可能接近真实声音的估计声音。

目标: V* = V

V 上的 MSELoss，V*

输出和目标之间的常规元素级 ms 损耗是我们损耗函数中的主要项之一。这是一种广泛使用的稳健损失，但它没有考虑特征的局部性。

V，V*上的噪声加权 MSE loss

输出和目标之间的常规元素 MSELoss，但基于该点的真实噪声强度进行了额外的元素加权。我们希望这将有助于消除噪音，而不是重建声音(这相对容易做到)。

休伯在 N，N*上的损失

Huber 损耗本质上是 MSE 损耗和 MAE 损耗的分段函数，在低误差值时，它表现得像 MSE，但是在某个阈值之后，它变成 MAE。这惩罚了小于 MSE 的异常值，但是在低损失值下具有相似的 MSE 属性。我们认为这可以帮助微调输出和目标之间的误差。

V，V*上的可微结构相似性(SSIM)损失

与 MSELoss 不同，SSIM 损失最初用于通过考虑位置来比较两幅图像的结构相似性。这个想法是，MSELoss 对于两幅非常相似的图像中的轻微偏移是不鲁棒的。这个术语可以捕捉两个光谱图的整体结构，并查看它们是否大致相同。

源投影损失

我们自己想出了这个损失，与噪声加权 MSELoss 的想法相同:专门去除噪声。与其在谱图空间中工作，我们尝试对谱图的像素值运行 MSELoss，不如在更简单的空间中工作？基本思想是，您可以将所有频谱图视为大向量，并通过投影回真实语音和真实噪声向量加上一些正交噪声伪像来分解估计的语音向量。

分解:V = aV+bN+R*

目标现在变为简单地将 a，b，R 分别减少为 1，0， 0 。

目标:V =V→V = 1V+0N+0

为此，我们可以将 a，b， R 上的 MSELoss 设为 1，0， 0，。

该损失函数直接测量与真实语音和真实噪声部分的关系。

然而，当在实践中应用时，出现了一个问题。大部分损失来自最小化 R 噪声误差的幅度，而不是减少投射到噪声上的量。如果这一项的权重较低，那么就会出现 R 增长过快的问题，并在结果中引入不必要的噪声伪像，使这种损失弊大于利。

【计算机】优化程序

除非另有说明，学习率为 0.001 的 Adam 优化器在任何地方都被使用。在源投影实验中，使用了 SGD，因为它在输出中创建了更少的 R 矢量伪像(从 V + N 到 V 采取了更直接的直线路径)。

色调分离

为了从头开始，我们决定简单地分离一个被恒定音调覆盖的声音。我们对模型的输入是一个人说话，背景中播放一种音调，模型试图将声音从音调中分离出来，只返回声音。运行模型 A，我们得到了非常好的结果，如下所示。

输入:

[## mix0.wav

编辑描述

drive.google.com](https://drive.google.com/open?id=1s0U2uXMw-xT1MU9ZzlFON2gFAQnmDwwM)

输出:

[## vp0_naive.wav

编辑描述

drive.google.com](https://drive.google.com/open?id=1-vVWxPjqA-P_Ov-a15H63sE7dh1rCc9a)

培训损失图表:

空调噪声分离

作为一个更高级的挑战，我们决定分离被空调噪音覆盖的声音。我们对模型的输入是一个人说话，背景中有交流噪声，模型试图分离交流噪声，只返回说话的人。运行模型 A，我们得到的结果如下所示。

培训损失图表:

输入音频:

[## 输入. wav

编辑描述

drive.google.com](https://drive.google.com/open?id=1_7q0LLQ52WFUCDTiWze0f2olRCu-2rLC)

输出音频:

[## 输出. wav

编辑描述

drive.google.com](https://drive.google.com/open?id=13XY25Y3GK__ZX7TeRy7Wq0l2Pso7obNW)

用 GAN 方法分离空调噪声

为了改进之前的结果，我们决定采用 GAN 方法。众所周知，甘很难训练，而且很不稳定。考虑到这一点，我们决定预先训练生成器和鉴别器，本质上是在训练过程中给它们一个“开端”。我们希望这将增加 GAN 的训练稳定性和收敛性。

由于我们已经有了一个训练过的生成器，我们预先训练了一个鉴别器网络来区分真实语音和来自生成器的估计语音。这是鉴频器的先验训练损失图:

在预训练之后，我们在一个经典的对抗设置中设置发生器和鉴别器并进一步训练。发生者损失是先前损失项与欺骗鉴别者的新的对抗性损失的组合。

以下是发电机的训练损耗:

这是鉴别器的训练损失:

以下是我们在所有培训后取得的成果:

输入音频:

[## 输入. wav

编辑描述

drive.google.com](https://drive.google.com/open?id=1Yy06WGs84DNcVbeKdpnOEOn6auXpkvFX)

输出音频:

[## 输出. wav

编辑描述

drive.google.com](https://drive.google.com/open?id=1rmFPAqOTv3IeQe5_1yhClcIWgPyFv_0g)

虽然这听起来不太好，但我们断定这是因为我们的发电机不够深。我们为此总共使用了 7 个神经变换层，当用 GPU 训练时，可以很容易地增加到 17 或更高。

狗叫声分离

在我们的一个实验中，我们只在嘈杂的演讲中训练模型 B，对于噪音，我们从噪音数据集中提取不同的狗叫声音。该模型使用 10 个时期的 5000 个嘈杂的语音进行训练。为了便于训练模型，每个有噪声的语音音频保持 1 秒的长度。

在训练该模型之后，我们使用该模型来预测干净的语音。下面我们展示了输入噪声语音、目标干净语音和预测语音的频谱图和音频剪辑。

输入:

[## 输入. wav

编辑描述

drive.google.com](https://drive.google.com/open?id=1-b27xEeqiWwDXFlwCM-igicFma_Gfy9U)

输出:

[## 输出. wav

编辑描述

drive.google.com](https://drive.google.com/open?id=1hxZGgl5BA9WDZz8VaEi56EqjqsnO7Olh)

总体而言，该模型在训练数据和验证数据上都表现良好。预测的 80 毫秒的干净语音音频剪辑听起来非常像真实的声音。

网站(全球资讯网的主机站)

这是我们网站的链接:https://audio-separation.herokuapp.com/

简而言之，我们的网站接受任意长度的嘈杂音频输入，通过我们的模型输入片段，然后将它们组合在一起，返回声音的干净版本。用户可以选择将声源添加到他们的输入中，以测试模型是否有效。我们使用 React.js 开发前端，使用 Python Flask 开发后端。我们面临的主要挑战是后端处理前端发送的任意长度的音频文件。此外，我们不得不面对 Heroku cloud 实例内存不足的问题，因为 Tensorflow 和 PyTorch 占用了大量空间。为了解决这个问题，我们转向了 AWS，它提供了更大的存储选项。一旦我们解决了安装正确的包和拥有足够内存的后勤问题，我们就能够使用 Material-UI 和 React.js 开发前端。

来自我们网站的截图

结论

我们在这个项目中完成了大量的工作。我们的模型 A 在色调分离方面表现得非常好，但在去除复杂的空调噪音时有其缺点，因为它太浅了。我们的 B 型车比 A 型车小，在狗叫声中表现良好。模型 B 中的变化是我们预测了噪音而不是更复杂的声音，并从我们的输入声音中去除了预测的噪音。另一方面，在模型 A 中，我们使用了更直接的方法，我们试图直接预测无声的声音。在这两个模型中，我们自己版本的 U-net 架构都发挥了关键作用。

我们的主要方法是创建一个鉴别器网络和生成器，独立地对它们进行预训练，然后过渡到对抗式训练，如 GAN。对于该方法，我们使用投影损失通过将估计的噪声投影到真实语音和真实噪声以及剩余项来直接去除噪声。然后使用 MSE，我们能够尝试训练我们的模型忽略真实噪声和剩余项分量。虽然这种方法无法产生我们希望的空调噪音结果，但我们相信，如果我们能够用更强的计算能力和更深的网络来训练它，它将会成功。

未来的工作

这个项目还有相当多的工作要做。从尝试鸡尾酒会问题的完整解决方案到通用噪声分离器，我们希望看到更多的成果。在这个项目中，我们将采取的下一步措施包括首先尝试创建能够学习分离各种噪音的模型。虽然我们已经能够创建模型来处理狗叫等个体噪音，但更复杂的噪音，如警笛声，却超出了我们的能力范围。在此之后，我们期望继续将这些单独的模型结合起来，以创建一个单一的更通用的模型，可以从语音中消除任何类型的噪声。在这里，我们甚至可以更进一步，尝试识别我们正在消除的噪声。最后，我们的最终目标是解决多个扬声器，特别是 GAN。这将是一个更具挑战性的问题，因为我们必须从噪音中识别出语音，并试图将每个声音从其他声音中分离出来。

更多信息

Github 链接:https://github.com/akarshkumar0101/DSProject

来源:

使用的 Python 库:

  • 利布罗萨
  • PyTorch
  • 火炬报
  • 皮托尔赫-SSIM
  • 米尔评估
  • NumPy
  • Matplotlib
  • tqdm
  • 火炬摘要

使用机器学习算法的审计:金融数据科学用例

原文：https://towardsdatascience.com/audit-using-machine-learning-algorithm-a-financial-data-science-use-case-2316571c024c?source=collection_archive---------21-----------------------

ML 算法在现实审计中的应用

弗兰克·维西亚在 Unsplash 上拍摄的照片

数据科学的世界充满了奇迹(除了独角兽！).它无处不在，在健康科学、太空探索、图像识别、机器人、欺诈检测等领域都有应用。如果你曾经在网飞或 Prime 上看过一些东西，那么你很有可能已经接触到了令人惊叹的电影推荐算法！

我们如何在一个典型的内部审计职能中运用 ML 技术来减少假阴性和提高效率。副作用:降低成本。

金融业也不例外，我们已经看到了组织向应用先进的数据科学技术进行见解生成、预测、预算和欺诈风险的巨大转变。

当我在日常审计中研究 ML 的用例时，作为一名财务专业人员，我们都面临的一个非常现实的问题是“与标准有何不同”？

假设您有 1，600 笔交易(或购买发票)，其中每笔交易代表“购买数量”(体积)和为该数量支付的“金额”。为了识别任何异常值(即不遵循正常模式的交易)，在典型的审计环境中，我们会尝试从总体中抽取随机样本，然后希望我们的“随机”抽样能够检测到任何此类异常。这有时既费时又事与愿违，因为我们有遗漏实际异常值的风险，这些异常值不会被我们的样本发现，因此会报告假阴性。这对审计职能的成本和效率都有不利影响。

因此，我尝试采用一种 ML 算法(KNN，下面会进一步解释)来解决上述问题，并自动进行异常检测。该算法使用发票的数量和金额特征，并计算 1，600 个这种发票集中的异常值。

现在好的算法或代码和我们讲的故事一样好。因此，在我讲述准则的本质之前，下面是一份一页的执行摘要或电梯演讲，可以与我们的业务利益相关方分享:

如果你想知道模型是如何建立的，请继续阅读下面的内容。

数据科学拯救

Python 中一个专门用于离群点检测建模的包叫做 PyOD 。这个包(我用 pip install pyod 安装的)提供了多种算法来检测异常值，并且非常容易实现。然而，在本文中，我将把自己限制在一个基于邻近度的模型的用例上，这个模型被称为 KNN 或 K-最近邻。 KNN 是一种数学模型，它测量到最近的第 K 个邻居的距离，并根据该距离识别数据中的异常值。这是一种分类算法，将异常值分类为“1”和“0”的二进制结果，或者说“是”或“否”。

以下是分步实施的方法:

第一步:数据集

对于任何数据科学项目，生成有意义的随机数据集与算法或代码本身一样重要。所以我强烈推荐阅读关于‘随机数据’和‘种子’的好资源。生成的数据集是一组 1600 张购买发票，代表两个特征，即当月购买的“数量”和为该发票支付的“金额”。下面是它看起来的样子(想象的但看起来仍然足够真实！)

为 KNN 建模生成的随机数据

第二步:想象

让我们使用 Plotly 散点图快速可视化数据。关于 的快速纲要，请参考我的文章 。

步骤 3:训练和测试模型

现在有趣的部分来了，我们实际上建立了我们的模型并训练了算法。这些是我通常会遵循的步骤:

  1. 预处理和缩放数据:这有效地将数据标准化并缩放到 0 和 1 之间的值，这有助于处理现实生活中变化很大的大量数据集。然后，我们重塑数据集的特征(体积和数量),以便进一步处理。
from **sklearn.preprocessing** import **MinMaxScaler**
scaler = MinMaxScaler(feature_range=(0, 1))
df[[‘Volume’,’Amount’]] = scaler.fit_transform(df[[‘Volume’,’Amount’]])**# reshape the individual features to numpy arrays**
x = df['Volume'].values.reshape(-1,1)
y = df['Amount'].values.reshape(-1,1)X = np.concatenate((x,y),axis=1)

2。分割训练和测试数据:我使用了 80:20 的训练/测试分割。然后首先使用训练数据训练该模型，并使用测试数据测试该模型。由模型生成的异常分数的可视化为我们提供了正常和异常数据是如何分割的指示。

from sklearn.model_selection import train_test_split
**#split dataset into train and test data**
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
print (‘Train set:’, X_train.shape, y_train.shape)
print (‘Test set:’, X_test.shape, y_test.shape)**# train KNN detector**
from pyod.models.knn import KNN
clf_name = 'KNN'
clf = KNN(contamination=0.03, n_neighbors = 5) #assuming a 3% outliers based on some historical data
clf.fit(X_train)
**#raw anomaly score**
y_train_scores = clf.decision_scores_
**#Train predictions**y_train_pred = clf.predict(X_train) *#creates outlier labels (0 or 1)*
**#print size for sanity check**
print('Train score size: ',y_train_scores.shape)
print('Train prediction size: ',y_train_pred.shape)**# Now we have the trained KNN model, let's apply to the test data to get the predictions**
y_test_pred = clf.predict(X_test) # outlier labels (0 or 1)
**# Generate the anomaly score using clf.decision_function:**
y_test_scores = clf.decision_function(X_test)
**#print size for sanity check**
print('Test score size: ',y_test_scores.shape)
print('Test prediction size: ',y_test_pred.shape)**Output:**Train set: (1280, 2) (1280, 1)
Test set: (320, 2) (320, 1)Train score size:  (1280,)
Train prediction size:  (1280,)Test score size:  (320,)
Test prediction size:  (320,)

3。可视化训练和测试分数:让我们使用‘y _ train _ scores’和‘y _ test _ scores’将异常分数可视化为一个简单的直方图。注意异常的数量。

**#visualise training scores**
fig = px.histogram(y_train_scores)
fig.show()**#visualise test scores**
fig = px.histogram(y_test_scores)
fig.show() **# lets see the number of anomalies**
print('Anomalies in test data: ',np.count_nonzero(y_test_pred))
print('Anomalies in training data: ',np.count_nonzero(y_train_pred))**output:**
Anomalies in test data:  10
Anomalies in training data:  33

4。将模型应用到给定的数据集:现在，我已经使用了上面为这个示例生成的相同数据集来演示我们如何获得最终结果。

**#Apply model to the given data set**
y_pred=clf.predict(X)
y_pred_scores = clf.decision_function(X)

5。将所有这些放在一起:在这一步中，我们将预测标签 s ('0 '和' 1 ')附加到数据集，可视化和对异常值 ('1 ')的过滤，以获得需要进一步调查的发票列表:

df1[‘Outliers’] = y_pred.tolist() #append list to copy of dataframe**#visualise data using plotly fro df1 dataframe**
fig = go.Figure(go.Scatter(x=df1['Volume'], y=df1['Amount'],mode='markers',marker=dict(size=df1['Amount']**0.26+3,color=df1['Outliers'],colorscale='rdylgn_r')))fig.update_layout(xaxis_showgrid=True, yaxis_showgrid=True, plot_bgcolor='whitesmoke', 
        title={
        'text': 'Volume vs transaction size with anomalies',
        'y':.88,
        'x':0.5,
        'xanchor': 'center',
        'yanchor': 'top'},width=800,
    height=600)
fig.update_xaxes(title= '------>Volume' ,showline=True, linecolor='black')
fig.update_yaxes(title= '------>Amount', showline=True,linecolor='black')#overlay the bars
fig.show()


**# Filter data on Outliers = 1**
Review_sample=df1.loc[df1[‘Outliers’] == 1].reset_index()
Review_sample.drop(‘index’, inplace=True, axis=1)
print(‘Number of invoices to deep-dive:’, len(Review_sample), ‘which is’, round(len(Review_sample)/len(df1)*100,1),’% of total transactions’)
Review_sample.head()

显示 43 个“异常”交易中前五张发票的输出

上面展示了金融和审计环境中机器学习用例的一个非常简单的例子。在现实世界的问题中，我们肯定需要考虑许多因素和多种模型的使用，但是为了文章的长度，我只把它限制在 KNN。

在以后的文章中，我将深入研究数据科学在金融和会计领域的应用和用例。在自学之旅中，请随时评论或联系，分享关于这方面的想法或想法。

有关 PyOD 的更多资源，请参考此处 的 文档链接。链接里有一些非常好的文章，给了我很多启发和帮助。

数据开发中的审计与测试

原文：https://towardsdatascience.com/auditing-vs-testing-in-data-development-2c3feda3a1e4?source=collection_archive---------24-----------------------

“你如何测试数据？”

在 Unsplash 上科学高清拍摄的照片

“你如何测试数据？”

每当有人想讨论数据堆栈的现代化时，这个问题总是排在列表的首位。最常见的情况是，软件工程师负责解开 SQL 脚本和存储过程的网络，当他们发现“dev”和“prod”只是数据开发人员的 SQL 编辑器中不同的连接设置时，他们感到很苦恼。数据开发的发展非常缓慢，可以说缺乏自动化测试/测试驱动的开发是这种懒惰的一个重要原因。TDD 和 CI/CD 已经成为快速可靠的软件开发领域的爆炸性催化剂，一旦被采用，它们将对数据开发产生同样的影响。问题是 如何 进行数据转换/模型测试并不十分直观。数据给软件设计增加了一层活动部件，可以感觉几乎不可能测试；但是和任何类型的开发一样，如果事情感觉太复杂，你可能需要考虑的更小。那么如何测试数据呢？容易；你不知道。你 测试 软件，你 审核 数据。

非结构化开发和 TDD 在技术上都是编程的方式，就像它们在技术上都是电话一样。图片来自美国国会图书馆印刷品和照片部吉尔伯特·h·格罗夫纳收藏。

数据不是软件，但数据软件是软件

《剑桥词典》将软件定义为控制计算机工作的指令。在 ELT 入库流程的情况下，软件是 SQL(或 python，或 R 等。)来决定如何更改或处理数据。数据是这个软件处理的东西。这种区别看起来很明显，但明确地说出来仍然很重要，因为它是如此多混乱的根源。当我们编写软件测试时，关键是我们只测试软件。

事情在哪里变糟？

想象你拥有一家冰淇淋工厂(我们都可以做梦)。你的价值链大概是这样的:

假设你决定测试你的产品，所以你去商店买了一加仑的石头路。令你惊恐的是，你发现冰淇淋酸得要命！从这个测试中，我们知道有几个不同的地方可能会出错:

  • 这个牛奶场可能一开始就生产了劣质牛奶
  • 罐车可能污染了牛奶(不良 EL 工艺)
  • 工厂可能会让牛奶变质(转化软件错误)

如果一个测试告诉你出了问题，但是不能帮助你确定它发生在价值链的什么地方，那么这个测试就是没有价值的。单一责任原则告诉我们任何一点软件都应该只做一件事，并且把那件事做好。我们的测试也不例外！

如果不只是去商店测试，而是设立测试点，会怎么样？

  • 在对牛奶做任何处理之前，在牛奶场检查牛奶
  • 从罐车上接受牛奶之前，先检查一下
  • 就在装运前，检查工厂生产线末端的冰淇淋
  • 检查店面的冰淇淋

现在如果你在奶牛场发现一批酸奶，就没必要再往前走了。如果你在工厂生产线的末端收到一盒变质的冰淇淋，你知道它在加工过程中变酸了。

审计 你的数据是在对牛奶做任何事情之前检查它。审计所做的唯一一件事( SRP )就是确保我们的源数据按照我们的预期到达。

测试 您的转换/模型逻辑是在冰淇淋被处理后检查它。测试所做的唯一一件事( SRP )就是确保给定一个预期的数据输入，你的代码会像预期的那样运行。

事情变得混乱

审核和测试之间的界限最初可能很难看出，原因如下:

  • 代码看起来一样，一定是重复工作。开发人员对我们代码库中相同的文本段落有一种精心策划的恐惧。干编程告诉我们，任何两个看起来几乎相同的东西都应该被参数化/注入/粉碎成某种形式的单一的、可调用的执行。当我们的测试和审计提出类似的问题时，很容易尝试多任务处理。不要这样做！审计和测试可能会问同样的问题，但它们是在非常不同的环境中进行的。例如，在user_id中发现一个NULL值的审计告诉您有一个源数据问题或变更。转换测试中相同的NULL值告诉您您的 SQL 是不正确的。审计NULL只能意味着源数据有问题，因为您的转换还没有触及它。一个测试NULL只能意味着你的 SQL 代码有 bug，因为源数据通过了审计。**
  • 测试是工具，不是数据。测试的唯一目的是促进发展。给定一个不可变的输入，我们应该期待一个不可变的输出(否则我们会有更大的问题)。因此，测试是确定我们在输入和输出之间精心制作的逻辑何时“完成”的一种方式为了让测试有用，它们需要足够快，能够在我们开发的过程中一遍又一遍地运行，并且足够全面，以至于我们“目测”来验证我们工作的任何东西都有一个等价的自动化测试。有效测试的一个核心要求是，我们可以相信所提供的源数据与我们得到的承诺完全一致。
  • 审计是实质性的(和大量的元数据)。为了让我们的测试信任源数据，我们的审计不能信任源数据。审计对源数据有期望(即user_id永远不会是NULL)，并检查以确保这些期望得到满足(SELECT * FROM products WHERE user_id IS NULL)。当源数据没有通过这项检查时，审计人员并没有生气，他们只是感到失望——他们通过停止 ELT 过程来表达这种失望。

实践中的理论

理解审计-测试模型最简单的方法是浏览一个例子。

这里我们有来自一个电子商务网站的源数据，如下所示:

我们相信:
-所有记录必须*有一个user_id值

  • ip_region 只能是east、west、north或south*

因此，我们编写了在每次从源系统批量加载后运行的审计:

*## audit_users_user_id_is_not_null
SELECT * FROM "DATA_LAKE"."USERS" WHERE user_id IS NULL;## audit_users_region_in_set
SELECT * FROM "DATA_LAKE"."USERS" WHERE ip_region NOT IN ('west','east','south')*

如何运行审计可以有多种方式(从实现的角度来看)。重要的是:
-审计在任何转换之前首先运行。
-当所有审核通过时，ELT 正常进行。
-当审核失败时，会详细记录失败情况，ELT 会暂停并发出警报。

注意:Kimball围绕审计级别和记录模式做了大量的工作，这些不在本文的范围之内。**

从事聚合转换的开发人员也可以编写一个测试，在user_id中寻找NULL值:

**## test_user_id_never_null
SELECT * FROM "DATA_WAREHOUSE"."DIM_USER" WHERE user_id IS NULL;**

但是关键的区别在于:开发人员的测试只是为了告诉他们代码是否正确。审计层承诺所有记录都有user_id值，所以开发过程中的任何NULL值都意味着代码有 bug。开发人员可以根据承诺的输入安全地编写测试来检查预期的输出，当所有测试都通过时，代码就可以发布了。

如果没有user_id的记录进来，ELT 停止。所有记录都有一个user_id的信念不再被认为是正确的。通过审计记录调查缺失行的user_id,发现所有有问题的行都正好来自 2020–03–02t 11:10:53，是由一个应用程序错误引起的，该错误已被修补。还要注意的是，在那个时间戳没有创建有效的行。新的承诺是所有行都将有一个user_id，除了在 2020–03–02t 11:10:53 创建的记录。审计代码被调整以反映我们现在认为是真实的，应用程序代码被调整以处理数据的新现实。

审计记录可以(并且经常)被注释，以便为所有这些复杂性创建上下文。其结果是丰富的数据演变历史记录和高性能的开发工作流程，优化您最有价值的资产—数据开发人员带宽。

使用 Amazon Rekognition 定制标签增强肺炎胸部 x 光诊断

原文：https://towardsdatascience.com/augment-pneumonia-diagnosis-with-amazon-rekognition-custom-labels-6f2fb79a986d?source=collection_archive---------44-----------------------

亚马逊 Rekognition 自定义标签胸部 x 光预测模型测试结果

在尼日利亚读高中的时候，我想成为一名医生——我们都知道结果如何。公平地说，我进入了医学院预科，但在第二年意识到我不是被设计来切割人体的。在那之后，我换了学校学习计算机科学，我们都知道结果如何。然而，我并没有失去对改善医学科学的执着。2013 年，我的学士论文重点是使用基于案例的推理来诊断伤寒。如果我从头再来，我将利用自然语言理解方面的进步来利用临床记录，实时预测伤寒病例。保持警惕。

在过去的几周里，我一直在为亚马逊识别定制标签 ⁵、来自 AWS 的令人惊叹的人工智能服务寻找新的用例——这是继切片面包之后最伟大的事情。在仔细研究了 Kaggle 之后，我偶然发现了胸部 x 光图像(肺炎)数据集，这是我的灵光一现。如果医疗从业者可以在没有 Google⁴的计算能力和技术专长的情况下利用人工智能诊断肺炎，会怎么样？

假设:如果医疗从业者可以在没有谷歌的计算能力和技术专长的情况下利用人工智能诊断肺炎，会怎么样？

这项工作

准备数据集

为了使用 Amazon Rekognition 自定义 Labels⁵训练模型，我需要将数据集保存在本地并通过 Amazon Rekognition 自定义标签控制台手动上传，或者已经存储在 Amazon S3 存储桶中。考虑到数据集的大小和要完成的任务，我决定利用云的力量——AWS。我启动了我的亚马逊 SageMaker 笔记本，安装了 Kaggle python 库。

下一步是将图像上传到 S3 的一个地点。然而，我意识到一个小故障。尽管 Kaggle 数据集页面的信息显示了 3 类——正常、细菌性肺炎和病毒性肺炎，但文件夹仅分为 2 类——正常和肺炎。通过对图像的简单浏览，我意识到它们可以根据文件名进一步分成 3 类，这要感谢数据集管理员。

随着 3 类到位，数据被上传到我的 S3 桶，并准备进行训练。这是我做过的任何计算机视觉任务中最简单的数据争论，少了 11 行代码。

完成上述步骤后，我必须使数据集对 Amazon Rekognition 自定义标签可用。我简单地从在亚马逊自定义 Labels⁵中创建一个新的数据集开始，在 web 控制台上点击几下，指向我在 S3 中的数据集位置。Amazon Rekognition 自定义标签为您提供了直接从控制台标注数据集的机会。如果你有一些图片，我会推荐这个。在我的场景中，我有超过 3k 张图片，并通过文件夹结构将它们分成不同的类别，我必须选中“,根据图片存储的文件夹自动为图片添加标签。”选项，这样 Amazon Rekognition 可以自动推断标签。

我得到了什么:

随着数据集导入 Amazon Rekognition，是时候训练我的医疗诊断助手了。

训练模型

要在 Amazon Rekognition 自定义标签中训练模型，首先要创建一个项目。

一旦创建了项目，Amazon Rekognition 自定义标签就可以训练我的模型了。不到 5 次点击，我就开始了我的模特训练。为此，我:

  1. 选择了项目，
  2. 选择我的训练数据集，
  3. 指示 Amazon Rekognition 应该拆分训练数据集，
  4. 点击了“火车”橙色按钮，然后
  5. 等待(用机器学习模型训练时最需要的属性)。

结果呢

正如我提到的，我开始证明我的假设是错误的，医疗从业者不可能在没有谷歌的情况下使用人工智能对胸部 X-rays⁸进行分类。结果证明我错了:确实有可能，感谢亚马逊 Rekognition 定制 Labels⁵.让我们从评估我花了多少钱开始。

费用

  1. 数据集在网上很容易找到，这让我几乎不用花钱就能下载。
  2. 我的亚马逊 SageMaker 笔记本花费了我大约 2 美元，我也用它来完成其他任务
  3. 亚马逊 S3 成本低于 0.90 美元
  4. 亚马逊 Rekognition 定制标签的模型培训持续 1.308 小时，每小时 1 美元；大约 2 美元。

总培训费用约为 5 美元(4.90 美元)。这不需要谷歌的财力。

为了用训练好的模型进行预测，亚马逊 Rekognition 定制标签的费用是 4 美元/小时。因此，如果我将我的生产用例设计为在一个 28 天的月中每天 4 小时进行批量预测，我将花费大约 450.00 美元/月(包括可扩展性和基础设施管理)。从而帮助全球成千上万的医疗从业者提高肺炎诊断水平，挽救数百万人的生命。看到更好的主意了吗？

模型度量

我不会去详细定义每个指标，我已经在以前的 post⁷和亚马逊 Rekognition 自定义 Labels⁵文件中广泛地这样做了。技术上，模型性能精度为 0.946 ~=94.6%。

总之，在胸部 x 射线数据集上的 Amazon Rekognition 自定义标签上训练的肺炎诊断模型能够正确预测患者是否患有细菌性肺炎、病毒性肺炎或零肺炎病例。

此外

想想这对全世界卫生保健的重要性和规模，即使是在最偏远的地方。想想可以重用这种方法的医疗用例。想想我们可以通过用人工智能增强医疗从业者的 X 射线诊断来拯救生命。

迫不及待地想知道您将使用亚马逊 Rekognition 自定义 Labels⁵.构建什么你可以通过电子邮件联系我，在推特关注我，或者在 LinkedIn 联系我。

参考

[1]克曼尼，丹尼尔；张、康；Goldbaum，Michael(2018)，“用于分类的标记光学相干断层扫描(OCT)和胸部 X 射线图像”，Mendeley Data，v2http://dx.doi.org/10.17632/rscbjbr9sj.2

[2]更大的善的意义，维基百科，https://en.wiktionary.org/wiki/greater_good

[3]基于案例的推理，维基百科，https://en.wikipedia.org/wiki/Case-based_reasoning

[4]利用已裁定的图像标签开发胸部 x 光的深度学习模型，https://ai . Google blog . com/2019/12/Developing-Deep-Learning-Models-for . html

[5]亚马逊 Rekognition 定制标签，https://aws.amazon.com/rekognition/custom-labels-features/

[6]胸部 x 光影像(肺炎)，https://www . ka ggle . com/paultimothymooney/胸部 x 光-肺炎

[7]带亚马逊 Rekognition 定制标签的 AI Powered Video Assistant 裁判，https://medium . com/@ elesin . olalekan/AI-Powered-Video-Assistant-referend-with-Amazon-Rekognition-Custom-Labels-5e 4902 b 47 ce 5

[8] Google details AI 以人类级别的准确度对胸部 X 射线进行分类，https://venturebeat . com/2019/12/03/Google-details-AI-that-classified-胸部 X 射线以人类级别的准确度进行分类/

设计师需要增强智能，而不是黑盒人工智能

原文：https://towardsdatascience.com/augmented-intelligence-for-sustainable-design-and-architecture-2f96a2fac95e?source=collection_archive---------26-----------------------

我们正处于深度学习的复兴时期，但通用人工智能仍然很遥远。设计师需要工具来利用人工智能最擅长的东西:放大人类创造力的极限

急需颠覆的行业

建筑行业面临着生存危机。这是数字化程度最低的行业之一和全球领先的二氧化碳排放源。随着全球气温上升和大规模人口向城市中心迁移，我们迫切需要一种能够实现更可持续的工作方式的数字化变革。

作为建筑师，我们可以从其他领域学习，这些领域在开发协同人机系统方面取得了快速进展，这些系统利用了人类和人工智能生成的推理的积极方面。

在过去的一年里，开发了许多人工智能工具，为设计的环境影响和性能提供了新的见解。尽管潜力巨大，但广泛采用仍存在几个障碍:

  1. 需要大量专业知识来利用他们的能力
  2. 人工智能和其他计算方法需要严格定义的设计目标
  3. 对于客户——为项目融资的客户——来说，这些工具的输出仍然不透明，不可理解。

在Digital Blue Foam(DBF)，我们开发新的解决方案，加速世界向更好、更可持续的城市转型。我们是设计师和技术专家，具有强烈的责任感，推动建筑、工程和施工(AEC)行业迫切需要的革命向碳负项目发展。

在新的设计时代来临之际，几个基本问题依然存在:

  • 我们如何开发工具，给予设计师更大的权力来促进可持续设计？
  • 下一代用户交互是什么样子的？
  • 我们如何在一个设计工具中连接人类和机器智能的长处？

人工智能毫无意义

2019 年是新机器学习(ML)应用多产的一年。ML，机器从结构化数据或深度学习的非结构化数据中推断输出的能力，已经获得了大量的炒作和歇斯底里。这导致了一个普遍的误解，即如果我们使用最新的算法和计算能力收集和处理足够的数据，智能就会出现。事实根本不是这样。

使用相关性而不是因果关系的策略，ML 识别模式的速度非常快，尤其是当输入数据结构良好时。这就是它在玩像 Flappy Bird 这样的视频游戏时如此有效的原因。在大多数电子游戏中，规则和目标是一致的；不像真实世界，模式总是保持不变。但是当情况发生变化时会发生什么呢？

因果智能是人类智慧的基础。虽然人类识别模式的能力相对较差，但我们擅长将过去的知识重新应用到新的情况中。所以当 Flappy Bird 2 发布的时候，我们知道它将会有和第一代几乎一样的规则和目标，我们很快适应了。另一方面，我们的人工智能什么都不懂；它只是遵循一种模式。当模式改变时，人工智能变得无用。

增强智能的接口

Digital Blue Foam 开发了一种工具，可以引导 AEC 行业绕过一个主要瓶颈。建筑师花费大量时间学习和使用低效的绘图工具，这实际上分散了他们的基本角色，即创造和试验设计选项，以满足场地和项目的过多需求，无论是社会、环境还是经济需求。我们的工具使用增强智能将建筑师从这种麻烦中解放出来，并通过增强久经考验的草图绘制方法来帮助他们生成设计。

我们 DBF 是增强智能的主要支持者，而不是黑盒人工智能。在这种范式中，人工智能成为增强人类智能的工具，而不是取代它。虽然复杂的人工智能系统能够在分析“大数据”中的模式后做出决策，但它们的好坏取决于人类给它们的数据。

增强智能是人类和机器智能的杂交

增强智能已经嵌入到许多知名产品中。这在文字处理应用程序中尤为明显:MS Word 的拼写检查器、海明威编辑器和 Grammarly(一个在线语法检查器)是增强智能的几个日常例子。Powerpoint 中的“设计想法”功能是另一个例子，它使用增强智能来帮助非设计师改善他们的布局。

在我们的软件中，用户使用笔接口，用计算机设计。随之而来的是其他人所描述的具有人机协作的【人在回路】增强智能(郑，2017)。

I 人性化设计方法

手动设计方法源于直觉、经验和逻辑。它能够为复杂的问题提出解决方案，比如在形状奇特的地块的不同部分建造不同类型的建筑。

二计算方法:

计算策略能够快速生成符合预定义逻辑的解决方案。这种方法的本质非常适合迭代任务，例如生成基于规则的解决方案以及执行计算和分析。

III 增强智能(1+1 > 2):

增强智能(AI)方法结合了前两种策略的优点。它理解设计者的意图，在这种情况下是通过线条或节点，并应用规则集来生成高度细微差别的解决方案

用不太专业的术语来说，这意味着当设计者绘制草图时，计算机将该图解释为一个输入，以限制新设计的产生。反过来，设计师观察计算机生成的东西。然后，他们可以在顶部绘制草图来编辑结果，提供新的输入。通过重复这个过程，新的解决方案出现了，无论是机器还是人类都无法想象。

通过在我们的技术中应用增强智能的原理，我们希望将人类一生的经验中获得的常识与机器智能最擅长的事情联系起来:在大型数据集中识别有用的模式。

结论

史蒂夫·乔布斯是增强智能的大力倡导者，这种方法是苹果产品成功的主要原因。在《滚石》杂志 1994 年的一篇文章中，富有远见的乔布斯评论道:“技术什么都不是。重要的是你对人们有信心，相信他们本质上是善良和聪明的，如果你给他们工具，他们会用这些工具做很棒的事情。

增强智能并不是一个新概念，但值得更多的关注，因为我们正在研究如何应用人工智能提供给我们的所有惊人能力。为了解决 AEC 行业的生存危机，我们必须扩展我们对增强智能的定义，并利用人工智能的真正潜力:结合设计师直觉的敏感性和机器智能的蛮力。

注意事项

  • 郑等(2017)“混合增强智能:协作与认知”。信息技术前沿&电子工程
  • 合著者 Tejas Chavan
  • 作者提供的图片和视频
  • 特别感谢格雷厄姆·福斯特的剪辑！
  • 试试这里的数字蓝色泡沫

试试数字蓝色泡沫这里

使用基准标记的增强现实

原文：https://towardsdatascience.com/augmented-reality-using-fiducial-markers-b8124b8f528?source=collection_archive---------38-----------------------

ArUco 基准标记

根据维基百科，基准标记“是放置在成像系统的视野中的物体，其出现在产生的图像中，用作参考点或测量点。它可以是放置在成像对象中或上的东西，或者是光学仪器的十字线中的一个标记或一组标记。”[1]基准标记已经在许多不同的场合作为测量手段使用。例如，如果你拍一张某人站在尺子旁边的照片，看看他们有多高，尺子将作为一个基准标记。

2014 年发表了一篇研究论文，提出了一种专门为相机姿态估计设计的基准标记系统[2]。相机姿态估计是寻找真实环境中的点和它们的 2D 图像投影之间的对应关系的过程。使用基准标记使这一过程变得容易得多。他们提出的标记被称为阿鲁科标记。该论文的两位作者拉斐尔·穆尼奥斯和塞尔吉奥·加里多制作了一个模块来与他们合作，这个模块又作为 aruco 模块并入 OpenCV[3]。

用 OpenCV 和 Python 检测 ArUco 标记

在之前的一篇文章中，我提到了 Pyto [4],所以我想我应该写一个脚本，从我的 iPhone 上的一个实时摄像头中找到一个 ArUco 标记，然后在它周围画一个方框。我使用了以下 ArUco 标记图像:

阿鲁科标记(id=1)

我把这张图片打印在一张纸上，放在我的桌子上:

你会发现我把透明度降低到 50%来保存我的黑色墨盒！它仍然工作正常。

下面是我的脚本，它检测标记，然后在它周围画一个框，并附上 ID:

下面是在我的桌子上用 ArUco 标记运行的脚本:

增强现实

一旦我能够检测到标记，我想在它上面放置一个图像会很好，这样可以在你移动相机时保持正确的视角。为了实现这一点，我们需要知道标记的单应性。然后，我们可以将图像转换成相同的单应性，并将其正确地放置在标记的顶部。

你不需要理解单应、齐次坐标或矩阵的实际细节就能实现这一点。但是如果你感兴趣的话，可以看看最后的维基文章参考文献[5][6]。

为了获得单应性，我们调用 OpenCV 方法find 单应性。一旦我们有了单应性，我们就可以调用方法 warpPerspective ，它将对图像进行仿射变换，以将其置于正确的角度，并将其正确地放置在标记的顶部。

这是我的脚本:

这是它在 Pyto 运行时的样子:

参考和链接

[1]维基百科对“基准标记”的定义:https://en.wikipedia.org/wiki/Fiducial_marker

[2]塞尔吉奥·加里多-朱拉多，拉斐尔·穆尼奥斯-萨利纳斯，弗朗西斯科·j·马德里-奎瓦斯和曼努埃尔·j·马林-希门尼斯，遮挡情况下高度可靠的基准标记的自动生成和检测

[3]https://docs . opencv . org/4 . 1 . 0/D5/DAE/tutorial _ aruco _ detection . html

[4]皮托:【https://github.com/ColdGrub1384/Pyto】T4

[5] 单应维基百科定义

[6] 同质坐标维基百科定义

八月版:数据世界中的新闻业

原文：https://towardsdatascience.com/august-edition-journalism-in-a-world-of-data-9b6909be075?source=collection_archive---------29-----------------------

月刊

一点一点地解开现代生活的复杂性。

照片由马修·盖伊在 Unsplash 上拍摄

认识到数据是一把双刃剑可能是一颗难以下咽的药丸。从揭示我们社区的行为到创造完全假设的现实，我们致力于数据科学的社区有幸将数据视为一种资源，其潜力仅受我们想象力的限制。

然而，这种乐观的观点忽略了一个事实，即数据也是一个日益极化和复杂的世界的同义词。对于门外汉来说，现代数据过剩成为注意力分散和困惑的无尽来源。在错误的人手中，数据可以被用作面纱，让我们看不到这个世界。因此，了解数据传达我们对世界的看法的各种方式以及随之而来的责任，正成为现代讲故事者工具箱的重要组成部分。

在这期月刊中，我们将重点介绍我们关于数据新闻的一些最新讨论，以及过去一年中发表的一些关于“走向数据科学”的最佳文章，这些文章结合了严谨和创新的数据驱动的故事讲述方式。

从简单的数据分析应用到最新的机器学习模型，从政治到文化，这些故事向我们展示了数据——在正确使用的情况下——总是可以为我们带来更细致入微、更深刻的世界观，一次一点。

《走向数据科学》的编辑刘燕森。

面向数据记者的 Python:从网络上获取数据

由阿兰·琼斯—11 分钟读完

使用 Python 和 Pandas 在网络上发现、读取和分析 CSV、Excel 电子表格中的数据

失传的理解数据科学的艺术

作者哈姆丹·阿兹哈尔 — 6 分钟阅读

用于理解的数据科学和用于预测的数据科学之间存在巨大差异。

解读市场——机器学习与金融新闻

詹姆斯·贝克 — 22 分钟阅读

大量的金融新闻文章被发表。但只有一小部分能真正推动市场。知道哪些可能会有帮助。机器学习能指明方向吗？

如何在调查报告中使用开源卫星数据

本·马克斯科技记者 — 13 分钟阅读

今天，我们将尝试解决您可能与同事分享的一些保留意见，并教授一些访问、理解和处理开源卫星数据的基础知识。

来自金融科技初创公司数据新闻实习生的 3 堂课

由詹姆斯·勒 — 7 分钟读完

找出我在一家金融科技初创公司实习时学到的经验，这家公司正在利用机器学习来彻底改变信贷承销行业。

僧康的年轻选民并没有过剩

哈尼夫·萨马德 — 8 分钟阅读

获胜的工人党团队拥有特殊人口优势的证据很少——这对他们来说是个好兆头。

利用数据科学研究美国的经济不平等

由安德鲁·洪 — 12 分钟读完

我们如何利用公共数据来分析和理解美国黑人社区面临的挑战？

新视频

新播客

我们也感谢最近加入我们的所有伟大的新作家梅根·马洛伊、迈克尔·高尔金、尼乌莎·RF、乔斯琳·卢特斯、斯泰西·斯维特利克纳娅、亚历克斯·德里杰、史蒂文·麦克唐纳、许明初、纪尧姆·休特、 黄、罗曼·斯图德、普拉诺蒂·帕瓦尔、罗布·齐泽克、乔纳森·费尔南德斯、莱恩·布朗、米米·布朗等等。 我们邀请你看看他们的简介，看看他们的工作。

澳大利亚野火增加了环境空气污染

原文：https://towardsdatascience.com/australian-wildfires-increased-ambient-air-pollution-ddec47b0b5f8?source=collection_archive---------32-----------------------

我使用来自新南威尔士的监测数据来显示该州的环境空气污染是如何增加的。下载数据，自己看！

现在，你一定已经听说了澳大利亚东南部两个州新南威尔士和维多利亚发生的灾难性野火。到目前为止，森林大火已经烧毁了 800 多万公顷的土地，使 10 多万人流离失所，并导致至少 29 人和 10 亿只动物死亡。

令人心碎的照片在互联网上随处可见，其中大多数都有一个共同的特征:一片红色的天空。这种启示性的黄色过滤器是有机物燃烧产生的浓烟的产物。

野火是颗粒物(PM)的强大来源，PM 是由悬浮在空气中的有机(和无机)物质的混合物组成的颗粒。PM 10 和 PM 2.5 是两种常见的报告污染物；它们的数字表示颗粒的最大直径(微米)。这些微小颗粒只有人类头发的一小部分，非常危险。

事实上，空气污染(以 PM 的形式)可能是野火最大的无形后果，因为与空气污染相关的短期和长期成本不像火焰那样明显。

数据显示，在遭受火灾的地区，环境空气污染已经恶化；这些地区的个人定期暴露在被认为是'危险'或'T10 非常不健康'T13 的浓度中；一些监测站记录的浓度水平甚至超过了任何健康标准的极限。

虽然火灾结束后，严重的环境空气污染会很快恢复到正常水平，但它的一些无形成本可能会持续几十年。

滚动至底部，查看如何下载数据并自行进行分析的说明。

野火增加了环境空气污染

新南威尔士州(NSW)规划、发展和环境部报告他们每个监测站的多种污染物的日平均空气质量指数(AQI)。

资料来源:新南威尔士州规划、发展和环境部

AQI 将空气污染的剂量(即给定时间段内污染物的浓度)转换为基于国家空气质量标准的指数值。新南威尔士州政府使用的空气质量指数见下表。

澳大利亚和(通常使用的)美国环境保护局(EPA)标准的比较可以在这里找到。

我通过对分布在该州的 40 多个监测站的数据进行平均，得出了新南威尔士州 PM 2.5 的每日 AQI 估计值。结果(如下图所示)显示，自 9 月份以来，环境空气污染增加了一倍多——主要是由于 11 月份火灾加剧。事实上，环境空气污染的这种程度的峰值在以前的野火季节中并不存在(附录T6【A】，并且可以直接归因于丛林大火(附录 B** )。**

新南威尔士州 40+监测站 PM 2.5 日平均 AQI 读数，采用澳大利亚标准。资料来源:新南威尔士州规划、发展和环境部；作者的计算。

该地区的平均空气污染已经从平均非常好/良好上升到平均差/非常差。美国的等效 AQI 是中度——即空气质量可以接受，但可能对一些人构成风险，特别是那些对空气污染异常敏感的人。

这种增加也可以从野火通常排放的其他污染物(如 PM 10、CO 和臭氧)中观察到。我在附录 c中绘制了多种污染物的行为

然而，分析州一级的数据，掩盖了成千上万接近森林大火的人对非常危险的空气污染浓度的严重暴露；相反，独立地分析台站提供了对事件的更有启发性的见解。在下图中，我绘制了八个站点的数据，这些站点的每日 PM 2.5 浓度有显著差异。

8 个监测站(3 个应急站)PM 2.5 的日平均 AQI 读数，采用澳大利亚标准。资料来源:新南威尔士州规划、发展和环境部；作者的计算。

靠近火灾的两个城镇 Katoomba 和 Goulburn 的空气污染浓度经常远远超过可接受的水平(AQI 在 0-66 之间)。

到目前为止，北瓦加瓦加经历了环境空气污染最严重的一天。世界上污染最严重的城市是印度的古鲁格拉姆，其日均(PM 2.5) EPA AQI 为 145。1 月 5 日，北瓦加瓦加经历了日均 500+的 EPA AQI！

新南威尔士州监测站 PM 2.5 的十大日平均 AQI 读数。访问日期:2020 年 1 月 14 日。资料来源:新南威尔士州规划、发展和环境部；作者的计算。

临近的表格详细列出了空气污染最严重的 10 天(根据澳大利亚和美国环保局的空气质量指数)。Goulburn 不成比例地出现在十个最差的地方，接下来是 Katoomba 和 Orange。

12 月 31 日，古尔本的平均空气质量指数为 1335(环保局的空气质量指数为 385)，当时古尔本邮报上传了这张照片并报告停电。要比较你所在城市的环境污染与如此高的浓度，请查看 NYT 互动看看世界上污染最严重的空气与你所在城市的相比如何。

如果 2240 的空气质量指数看起来很高——与监测器报告的最高空气质量指数相比，这是微不足道的。记录的前十个浓度对应的 AQI 值在 4500 到 7200 之间(其中八个大于 5000)。

下面的直方图详细描述了一月份前两周的小时数(y 轴),监测器记录的空气质量指数(x 轴)被 EPA 标准标记为非常 不健康(即 EPA 空气质量指数为 200+)。它报告澳大利亚的等效空气质量指数。虽然空气质量指数超过 4000 不会持续超过几个小时(如下所示)，但它们会对人产生可怕的(如果不是致命的)后果。

直方图:1 月 1 日至 1 月 14 日，40 多个监测站记录了总计 331 个小时的空气质量指数超过 200。资料来源:新南威尔士州规划、发展和环境部；作者的计算。

跟踪 NSW.govaqicn.org或IQAir的实时空气污染读数；关注my fire watch*现场直播更新。*****

点击 阅读更多关于森林大火的信息。阅读更多关于 大火造成的空气污染的对话 。

如何提供帮助

NYT 发表了一篇关于 如何帮助澳洲火灾受害者 的文章。考虑为新南威尔士州农村消防服务局或维多利亚中央消防局*做贡献。* 救助儿童会 致力于管理儿童友好空间，让儿童能够在一个安全、受支持的环境中处理他们的经历。最后，考虑支持野生动物救援工作，例如来自世界野生动物基金会的。******

附录 A

附录 A 显示了 2017 年 6 月至 2020 年 1 月新州 PM 2.5 的日平均 AQI 读数。下图显示，这一野火季节的环境空气污染明显高于以往季节。

新南威尔士州 40+监测站 PM 2.5 日平均 AQI 读数，采用澳大利亚标准。资料来源:新南威尔士州规划、发展和环境部；作者的计算。

下图显示了相同的点，但使用的是 PM 10。

新南威尔士州 30+监测站 PM 10 日平均 AQI 读数，采用澳大利亚标准。资料来源:新南威尔士州规划、发展和环境部；作者的计算。

附录 B

附录 B 提供了进一步的证据，证明环境空气污染的增加与野火有关。2019 年的森林火灾季节开始于 9 月(比往常早)，由于更高的温度和热空气库，11 月期间加剧。到月底，消防队员已经扑灭了 120 多处森林大火。

我在 11 月初选择了一个任意的日期，然后进行了一个基本的回归不连续时间。结果可以在下图中找到。

新南威尔士州 40+监测站 PM 2.5 日平均 AQI 读数，采用澳大利亚标准。资料来源:新南威尔士州规划、发展和环境部；作者的计算。

虽然我没有考虑自回归或风等天气模式，但在数据中可以观察到约 40 个单位的具有统计显著性处理估计的明显不连续性。处理的右侧受到多种因素的影响，包括长期的自回归(因为更稠密的空气污染需要更长的时间来稀释)、风的模式、相互作用的影响以及野火的扩展和收缩。

下图描绘了处理前后样本的平均值(11 月火灾前后)。虽然它不能准确估计处理效果，但它表明野火是环境空气污染增加的根源。t 检验确定两个样本的平均值之间的统计显著差异。

附录 C

附录 C 介绍了对其他污染物的见解。野火排放一次污染物(PM、CO、NOx)和二次污染物。臭氧等二次污染物是 NOx 和 PM 与其他污染物(如碳氢化合物)相互作用的产物。下图显示一氧化碳和臭氧的浓度增加了(左)，而一氧化氮和二氧化硫的浓度没有变化(右)。

新南威尔士州记录的 CO、NO、SO2 和臭氧的日平均 AQI 读数。资料来源:新南威尔士州规划、发展和环境部；作者的计算。

虽然预计二氧化硫浓度不会发生变化，但野火是氮氧化物的主要排放源。me bust(2013)【1】将澳洲野火氮氧化物排放的可变性归因于在火灾季节植物在地下重新分配氮的事实。我们的数据确实显示了 NO 的季节性变化，在火灾季节浓度较低。

[1] A.K. Mebust，从太空观察到的野火氮氧化物排放的可变性 (2013)，加州大学伯克利分校。

自己分析数据

您可以下载数据并自己进行分析！前往新南威尔士州规划、发展和环境部并遵循以下步骤:

****第一步:选择数据类别和参数(污染物)。

选择“每日”或“每小时”现场平均值以及您感兴趣的污染物。这将提供浓度的平均值(g/m3 或 ppm)。****

有了浓度方面的数据，您就可以轻松地将空气质量转换为任何 AQI(无论是 EPA、澳大利亚还是您所在国家的环境机构使用的 AQI)。

要将浓度转换为澳大利亚 AQI，请遵循此处的说明。污染物目标浓度是给定污染物的 NEPM 空气标准。这个标准是由国家政府制定的。

****第二步:选择地区或站点。

由于数据下载时间不长，我建议您选择所有站点(站)。这可以通过选择粗体显示的区域来轻松完成。

不要忘记紧急站点！它们位于底部。

****第三步:下载数据。

点击 ' 下载成文件 ' 下载一个 xls (excel)文件。

选择所需的开始和结束日期。每小时数据的每次下载限制为 3652415 条记录。

下载数据后，您可以创建整个新南威尔士州地区的日平均值，如下所示:

***Daily_Average$mean = rowMeans(Daily_Average[2:nrow(Daily_Average], na.rm = T)***

您可以使用新南威尔士州使用的 AQI (仅用于 PM 2.5)生成一个变量，如下所示:

***Daily_Average$AQI_mean = (100*Daily_Average$mean)/25***

您可以使用 ggplot 绘制数据:

***main = ggplot(data=Daily_Average, aes(x=Date, y=AQI_mean)) + geom_line() + geom_smooth(span=0.6, col="steelblue4")***

制作一个最小的背景，如下所示:

***main + 
theme_minimal() + theme(panel.grid.minor = element_blank(), panel.grid.major = element_blank())***

插入澳大利亚 AQI 行作为参考，如下所示:

***main + 
geom_hline(yintercept = (0), col="steelblue2", alpha=0.6, linetype =   "dashed", size=.65) + # Very good
geom_hline(yintercept = (33), col="green4", alpha=0.6, linetype = "dashed", size=.65) + # Good
geom_hline(yintercept = (67), col="gold", alpha=0.6, linetype = "dashed", size=.65) + # Fair
geom_hline(yintercept = (100), col="orange", alpha=0.6, linetype = "dashed", size=.65) + # Poor
geom_hline(yintercept = (150), col="brown4", alpha=0.6, linetype = "dashed", size=.65) + # Very Poor
geom_hline(yintercept = (200), col="orangered2", alpha=0.6, linetype = "dashed", size=.65) # Hazardous***

按如下方式添加标签:

***main +
labs(title = "Ambient Air Pollution in New South Wales",
subtitle = "Daily average AQI readings of PM 2.5 (Australian standards)", 
caption = "Source: NSW Department of Planning, Industry and Environment; author's calculations.
Note: The mean is based on 40+ stations. The colored dashed lines are hazard labels based on NSW recommendations.") +
xlab("Date") + 
ylab("AQI") + 
theme(text = element_text(size=12.5)) + # Adjust font size
theme(plot.subtitle = element_text(hjust = 0.5)) + # Adjust text
theme(plot.title = element_text(hjust = 0.5)) # Adjust text***

可以通过 rdd 包进行时间上的回归中断:

***library(rdd)
library(dplyr)Daily_Average = Daily_Average %>% mutate(n = row_number())plot(RDestimate(data = Daily_Average, cutpoint = 876, AQI_mean~n))title(main="Bushfires Cause a Sharp Discontinuity in Ambient PM 2.5", ylab="AQI", xlab="Days since the start of time series")***

Python 的自动文档

原文：https://towardsdatascience.com/auto-docs-for-python-b545ce372e2d?source=collection_archive---------13-----------------------

编写代码很无聊，为什么要浪费时间呢？

照片由阿德里安在 Unsplash 上拍摄

不管我们喜不喜欢，好的文档绝对是项目成功的关键。那么，为什么好的文档如此难找呢？

在现实中，它常常被忽视，被当作代码本身的劣质产品。制作好的、用户友好的文档实在是太耗时了。

这种忽视是错误的。我们构建的工具的采用在很大程度上取决于易用性。如果文档难以浏览、理解，或者仅仅是使用起来没有吸引力，用户不会喜欢它。

因此，考虑到这一点，我相信我们都应该为简单而全面的文档而努力。

我们将介绍如何为任何 Python 项目快速构建自动文档工具。有了它，只需几秒钟就可以为包含大量代码的复杂项目生成文档。

正则表达式是我们的朋友，我们将在整篇文章中大量使用它们。我写这篇文章的目的是真正关注代码的这一方面，我希望你能从中学到很多东西(我当然有)。

如果你使用NumPy/SciPy docstring 标准 ，你甚至可以使用我使用的确切代码，这些代码在 GitHub 这里有 ！

在开始之前，现成的文档工具是现成的。用起来都没毛病，其实斯芬克斯，唯一一个我综合使用过的其实很不错。

然而，到目前为止，我还没有其他工具能特别快速地生成我喜欢的文档样式。

尽管如此，他们是好的，我建议你考虑你所有的选择。如果您对 Sphinx(或另一个)工具满意，请使用它。如果你想以你自己的风格构建一些东西(并学习正则表达式)，使用这个指南。

Jorn Eriksen 在 Unsplash 上拍摄的照片

结构

autodocs 文档结构可以表示为一棵树，如下所示:

由此我们可以看出，我们必须能够从代码中提取几个关键结构，它们是:

  • 文档字符串 : (包含描述、参数、参数数据类型等)这些是我们用来描述每个脚本、类和函数的块引用部分。
  • 类:类定义本身、它们的描述(包含在 docstring 中)和方法。
  • 函数:函数本身及其文档字符串，包含函数描述和参数。
  • 参数:包含在函数 docstring 中。每个参数包含一个描述、数据类型和一个“可选”标志。

我们将采用这些组件中的每一个及其各自的子组件，并使用这些信息来开发另一个简化的、可理解的文档的树状结构。

文档字符串

Numpy/Scipy 标准文档字符串(包含在三重引号中的部分)。

如您所见，我们可以通过每个文档周围的三重引号来识别文档字符串。在 regex 中，我们写(?s)\"{3}.*?\"{3}。

这里发生了一些事情。

  • \用作转义字符。我们将它放在 Python "或 regex {[()]}中有其他含义的字符前面，以“逃离”它们的原生含义。表明我们实际上只是想寻找那个字符。
  • 我们有两组\"{3}，这正好匹配我们的两组三重引号。
  • .*匹配除换行符之外的任何字符，?使其成为一个“懒惰”量词——停止正则表达式匹配"""的第一个实例到"""的最后一个实例，取而代之，我们匹配第一个和第二个、第三个和第四个实例，等等。
  • (?s)是一个全局模式修饰符，s告诉正则表达式我们希望.*也匹配换行符。

班级

一个类的示例格式，后跟一个类外函数。

一个类的开头可以很容易地通过单词class后跟一个空格、几个字母和一个冒号来识别。

为了防止我们匹配类开头之后的所有内容，我们将类的结尾标识为换行符直接跟在文本字符之后的第一个位置。

在 regex 中，我们写(?sm)class [\w\d_]+:.*(^\w)。

  • [\w\d_]匹配文本、数字和下划线字符，添加+意味着它将匹配无限数量的这些字符。
  • (?sm)还是我们的全局模式修饰符，m标志告诉正则表达式我们希望^和$分别表示一行的开始和结束。
  • (^.)是一行的开始^，后面紧跟着一个字符.。

功能

我们需要提取的例子。

功能有点不同。不像类，我们捕获类中包含的所有内容(这样我们也可以提取类方法)，我们只需要函数名和 docstring。

幸运的是，这使得我们的第一个函数匹配正则表达式更加容易，我们写(?s)def [\w\d_]+\(.*?\):\s+\"{3}.*?\"{3}。

描述

每个函数还包含我们必须提取的名称、描述和参数列表。我们分几部分来做，参数提取稍微复杂一点，我们将在下一部分讨论。

函数 名称我们用def [\w\d_]+\(提取，用它我们去掉def和(，只留下函数名称。

name = re.search(r"def [\w\d_+\(", func).group()
name = name.replace("def ", "").replace("(", "").strip()

描述 desc和参数表params是用(?s)\"{3}.*?\"{3}拉出 docstring 并在Parameters\n上拆分提取的。然后，我们删除三重引号和过多的空白。

docstring = re.search(r"(?s)\"{3}.*\"{3}").group()
desc, params = docstring.split("Parameters\n")
desc = re.sub(r"\s+", " ", desc.replace('"""', "")).strip()

因素

我们的参数列表包含在params中，看起来像这样:

为了匹配每个参数，我们编写(?s)\w+ : .*?(?=\w+ :)。

在很大程度上，我们已经涵盖了这方面的所有内容，除了一个部分— (?=\w+ :)。

在这种情况下，我们知道\w+ :将匹配后跟空格和冒号的多个字母。然而，它被包裹在(?=)中。这被称为正向前瞻断言。

通过添加这个，我们告诉 regex 对 assert (?=)声明，我们匹配的内容后面紧跟着\w :。

截图来自regex101.com

如果我们把它放到一个在线正则表达式测试器中，我们可以看到它几乎完美地工作，但是不幸的是，它遗漏了最后一个参数(因为它后面没有跟随\w :)。

我们通过一次提取一个参数来解决这个问题。在这个循环中，如果我们发现没有找到参数，我们用修改后的参数 finding regex (?s)\w+ : .*再次尝试，提取最后一个参数。

参数细节呢？

我们最后的、最深的提取层要求我们提取参数名、数据类型、“可选”标志和描述。

为此，我们简单地用换行符\n分割我们的参数文本new_param。现在，在索引0处，我们有了包含参数名、数据类型和可能的可选标志的第一行。让我们修改上面的代码来包含这个提取。

这里唯一增加的逻辑就是:对new_param的第一行进行拆分，给我们name和dtype。接着检查dtype中的单词'optional'，给出optional。

然后我们简单地将这些参数细节添加到新的params字典中。给了我们这样的东西:

我们的准则

至此，我们已经完成了从代码中提取我们需要的所有内容的代码。我们已经创建了前面提到的树形结构:

脚本或类行中包含的任何内容都将有一个专门的文档页面。脚本页面将包含名称、描述以及指向其下任何类的链接。

从单个脚本 docs.py 生成的页面，其中包含一个名为 DocsBuilder 的类。

在构建文档时，我们将遍历项目中包含的每个脚本和类。迭代地为每一个构建文档。

有了这个，我们可以继续为我们的文档构建 HTML 代码。

照片由你好我是尼克🎞 on Unsplash

构建文档

这些文档分为四个主要部分:

  • 脚本/类信息。这出现在每一页的顶部。这是来自第一个脚本或类级 docstring 的信息。
  • 面包屑导航栏。允许我们上下浏览文档级别。
  • 类节。在这里，我们将有一个脚本类列表，单击一个类按钮将显示类描述和文档链接。
  • 功能部分。这包含一个函数列表，详细说明了它们各自的参数。

在动态构建这些部分之前，我们确实需要将<head>信息添加到我们的初始 HTML 页面，现在我们将保持它非常简单。

我们将为页面中的 CSS 和 JS 使用 Bootstrap 。在<head>中，我们使用<link>元素附加引导 CSS 样式表。JS 脚本是稍后添加的。

在 Python 中，我们可以将这段代码添加到三重引号块中，或者从文件中读取它。变量html最初将只包含这个<head>元素。

顶级信息

这是我们的脚本/类信息，出现在我们页面的顶部。

当我们独立地遍历每个脚本和类时，我们可以同样对待它们。两者之间的唯一区别是脚本页面将包含类部分，而类则不包含(除非您在类中有一个类)。

对于docs.py，fullpath将只包含一个条目['docs']。但是对于较低的级别，例如DocsBuilder，这将包含通向类['docs', 'DocsBuilder']的层列表。因此，我们的主标题是列表fullpath[-1]中的最后一个索引。

顶层描述包含在desc中。

面包屑导航

接下来是我们的导航部分，我们用最高级别的页面readme初始化它。

接下来，我们遍历fullpath中的条目，创建一个到当前页面的完整“面包屑路径”。

因为生成的文件名都是骆驼大小写，并且包括任何前面的类/脚本。我们将相同的格式应用于变量path。这使得**DocsBuilder** -> **docs.docsbuilder**。

班级

类别都存储在一个名为classes的字典中。该字典包含类名和描述键值对。

首先，我们检查当前级别是否包含类，如果没有，我们不添加类部分。

如果我们有类，我们添加类和类按钮部分的开头。然后我们遍历classes，为每个项目添加一个按钮，只包含类name。

接下来，我们添加类按钮的结尾和类描述(和链接)的开头。我们遍历每个项目，添加按钮内容。这允许我们在点击按钮时显示课程描述和链接。

最后，我们结束这节课。

功能

函数存储在名为funcs的字典中，格式如上。

由于每个函数内部都有额外的参数层，所以这里还会发生更多的事情。

所有函数都包含在一个无序列表<ul>中，其中每个列表项<li>由一个函数组成。

包含在标签中的函数示例。

我们首先添加函数name，然后添加包含在<kbd>元素中的函数示例，通过用","连接所有参数来构建。

下面是参数表。这里我们用标签<table>和<tbody>初始化表格的开头。一个循环逐行构建表，由参数名和描述组成。

在这之后是几个标签结束部分。由于 functions 部分是页面的最终动态构建部分，我们可以添加 Bootstrap JS 脚本和结束标记。

生成文档

一旦我们将所有这些代码提取和页面构建脚本放在一起，我们就可以只用几行代码来构建文档。

当然，在这里，你在整篇文章中看到的所有东西都被构建到了DocsBuilder类中。

我们使用的所有提取正则表达式都包含在extract方法中。在build方法中的 HTML 构建代码。

我在包含许多脚本和类的更大的项目中运行过相同的脚本。尽管如此，所有文档都是在瞬间构建的。

你可以在 autodocs GitHub repo 中找到所有的代码。它绝不是一个完成的项目，所以请随时提出改进建议或指出不必要的代码！

如果你有任何其他问题或建议，请随时通过 Twitter 或在下面的评论中联系我们。

感谢阅读！

如果您喜欢这篇文章，您可能会对我最近写的另一篇关于处理来自 web 的文本数据的文章感兴趣。重点关注机器学习的数据准备:

[## 面向自然语言处理的网页抓取和预处理

使用 Python 抓取和处理 web 上的文本数据

towardsdatascience.com](/web-scraping-and-pre-processing-for-nlp-2e78810b40f1)

自动生成的知识图

原文：https://towardsdatascience.com/auto-generated-knowledge-graphs-92ca99a81121?source=collection_archive---------3-----------------------

利用网络抓取机器人、计算语言学、自然语言处理算法和图论的集合。

知识图是一种数据科学工具，处理相互关联的实体(人、组织、地点、事件等)。).实体是通过边连接的节点。知识图由这些实体对组成，可以遍历这些实体对来发现非结构化数据中有意义的联系。

图形数据库有一些固有的问题，其中之一是构建它们需要手工操作。在本文中，我将讨论我使用 web 抓取机器人、计算语言学、自然语言处理(NLP)算法和图论(提供 python 代码)进行自动生成的研究和实现。

网页抓取

构建知识图表的第一步是收集你的资源。对于某些目的来说，一个文档可能就足够了，但是如果你想更深入地在网上搜索更多的信息，有多种方法可以使用网络抓取来实现。维基百科是一个不错的起点，因为该网站的功能是作为一个用户生成的内容数据库，引用了大多数可靠的二手来源，这些二手来源审查来自一手来源的数据。

边注 :随时检查你的来源。信不信由你，网上的信息并不都是真的！对于基于启发式的解决方案，交叉引用其他网站或选择 SEO 指标作为信任信号的代理。

我将尽可能避免屏幕抓取，对维基百科 API 使用直接的 python 包装器。

下面的函数在维基百科中搜索给定的主题，并从目标页面及其内部链接中提取信息。

让我们测试一下这个函数的题目:“2007-08 年金融危机”

wiki_data = wiki_scrape('Financial crisis of 2007–08')

输出:

维基百科页面抓取:798

如果您想提取单页，请使用下面的函数:

计算语言学和自然语言处理算法

使用词性和依存解析可以从文本中自动构建知识图和。使用 NLP 库 SpaCy 从语法模式中提取实体对是快速的，并且可扩展到大量文本。

下面的函数将实体对定义为由根动词连接的具有主语-宾语依赖关系的实体/名词块。其他的经验法则可以用来产生不同类型的连接。这种联系可以称为主谓宾三元组。

调用主主题页面上的函数:

pairs = get_entity_pairs(wiki_data.loc[0,'text'])

输出:

提取的实体对:71

共指消解通过规范化文本、移除冗余以及将实体分配给代词，显著改进了实体对提取(参见下面我关于共指消解的文章)。

[## Python 中的共指消解

使用 NeuralCoref 将基于神经网络的共指消解集成到您的 NLP 管道中

towardsdatascience.com](/coreference-resolution-in-python-aca946541dec)

如果您的用例是特定领域的(医疗、法律、科学)，那么训练一个定制实体识别器模型也是值得的。

图论

接下来，让我们使用 NetworkX 库来绘制网络。我将创建一个有向多图网络，其节点大小与度中心性成比例。

draw_kg(pairs)

如果绘制的图形变得难以理解，我们可以增加图形尺寸或过滤/查询。

filter_graph(pairs, **'**Congress**'**)

大规模知识图表

为了有效地为我们的主题使用整个语料库 ~800 维基百科页面，使用在 wiki_scrape 函数中创建的列为每个节点添加属性，然后您可以跟踪每个节点位于哪个页面和类别。

我推荐使用多处理或者并行处理来减少执行时间。

大规模的知识图表是人工智能研究的前沿。唉，现实世界的知识并没有整齐地组织成一个模式，而是无组织的、杂乱的和有机的。

SQLAlchemy 中的自动反映表和列

原文：https://towardsdatascience.com/auto-reflecting-tables-in-sqlalchemy-f859ff3b6aab?source=collection_archive---------39-----------------------

或者几行代码让我想在街上翻跟斗

大卫·克洛德的《向上冲刺》

呻吟，不是另一篇 SQLAlchemy 文章！

相信我，这个不一样…

在对 SQAlchemy docs 进行了大量的自我反省和挖掘之后，我有了一个重要的发现:您不需要使用基于类的属性来利用基于会话的查询的强大功能。

本文中的代码是根据 Apache 2.0 软件许可证授权的。下面是将要讨论的 Python 代码的一部分:

https://gist . github . com/steadynotion/129 c 7 b 58 ff 0 a 146d 45083527888 c 5749

SQLAlchemy 中自动反映表的扰流板代码

简单吧？

嗯，算是吧:请允许我解释一下。

我已经创作了几个使用 Pandas 和 SQLite 的 Python 脚本。对于那些还没有享受过与熊猫一起工作的乐趣的人来说，这是一个惊人的包，在数据科学和许多其他领域有大量的应用。我惊叹于为各种 Pandas 函数指定各种关键字参数以获得惊人结果的简单性。我的脚本使用 SQLite 数据库来存储传入的、“中游”和结果数据集。虽然 SQLite 非常适合原型开发，但我现在需要更多。

比如认证。

我可以移植我现有的代码来指向一个不同的数据库，但是我真正想要的是与方言无关的东西。进入 SQLAlchemy 及其强大的对象关系映射器(ORM)。它允许开发人员作为 Python 友好的类与他们的数据库进行交互。非常酷！

SQLAlchemy 的巨大优势之一是基于会话的查询，它采用 Python 面向对象的语法，而不是 SQL 语句。对于那些使用过两种或两种以上数据库技术的人来说，我有点不好意思解释为什么这是有益的。对于那些没有享受过这种乐趣的人来说，这就像是在一次环球电话会议上，与每个外向、健谈的人交谈时雇佣一名翻译。

SQLAlchemy 的 ORM 是你的翻译器。标题中有“物体”意味着它热衷于…物体。有几个扩展 SQLAlchemy 的包，如 Elixir 和SQLSoup；他们也使用面向对象的方法。如果您的代码使用( drum roll please…) 对象，这是没有问题的。

一个小问题是，我的代码中的一些咳咳 大部分使用 JavaScript 对象符号(JSON)在运行时配置参数。我有一个装满 JSON 趣闻的曲棍球球袜:这些是另一篇文章的主题。可以说，我的许多 Python 脚本使用从 JSON 获得的基于string的参数进行配置。

在查看了 SQLAlchemy 文档并通过 Eclipse 调试器进行了一些检查之后，我拼凑了一个小而庞大的代码片段，它使我能够通过名称引用给定数据库中的每一个表和列，而不必将它们指定为对象和属性。

当我第一次看到一个没有错误的控制台时，我想在街上翻跟斗。

有些人可能会问‘那又怎样，我为什么要在乎？’也许一个更充分的例子是合适的。在深入下面的代码之前，如果您想知道如何使用 SQLAlchemy 配置数据库，我建议您查看以下有用的文章: SQLAlchemy — Python 教程作者 Vinay Kudari 和如何使用 Python SQLite3 使用 SQLAlchemy 作者 Mahmud Ahsan 。

一旦配置好 Python 环境和测试数据库，就可以将下面的代码片段加载到您选择的 IDE 中:

https://gist . github . com/steadynotion/8d 81 b5 bcdd 74 Fe 75 C3 a3 b 694516d 6528

一个更充分的例子

SQLAlchemy 中自动反映表的更完整的例子

配置了 SQLAlchemy engine之后，您可以将它与测试数据库中的表和列的名称一起提供给get_data函数。假设我们的测试数据库包含一个名为“ThisIsATable”的表和一个名为“ThisIsAColumn”的列。在“ThisIsAColumn”中，我们有几个基于文本的行，其中至少有一行包含“请尝试找到我”。

如果一切顺利，您应该有一个 Pandas DataFrame包含来自测试数据库的表的子集。多亏了几行代码，我们现在可以自由地编写与数据库无关的查询了。通过这些查询，我们可以获得供熊猫咀嚼的数据，这要归功于简单的基于string的参数。

从“易于维护”的角度来看，代码利用了公共函数和属性。调用私有属性通常是不明智的，因为这些属性在未来的版本中可能会改变；我倾向于尽可能回避私人属性。值得一提的是，上面代码中的Session是在函数get_data中调用的。这不是推荐的做法。有关创建和使用会话的更多信息，请参见这篇由 A Gordon 撰写的文章。SQLAlchemy 文档还包含关于创建和使用会话的信息，特别是标题为“我何时构造一个[Session](https://docs.sqlalchemy.org/en/13/orm/session_api.html#sqlalchemy.orm.session.Session)、何时提交它以及何时关闭它”的部分。

有了上面的代码，您和您的概念验证 Python 脚本现在能够通过方便的字符串指定最少的信息来自动加载和反映数据库元数据。

弦乐！如此美妙的事情。

跟我一起说:琴弦是很奇妙的东西！

在我看来，这代表了通过 SQLAlchemy 的数据库无关性，以及强大的 Pandas 库和基于string的关键字参数进行高级查询的开端！我认为另一个蛇的形象是合适的:它总结了 SQLAlchemy，熊猫和基于文本的互动之间的关系。它们共同组成了三驾马车，为自然语言处理和许多其他用例的无限扩展做好了准备。

蛇的图像由 Laura Barry 在 Upslash 上提供

祝你玩得开心，在外面注意安全！

E

使用 Python 自动更新您的 Github 概要文件

原文：https://towardsdatascience.com/auto-updating-your-github-profile-with-python-cde87b638168?source=collection_archive---------36-----------------------

实践教程

通过自动化您的个人资料自述来展示您的技能

照片由来自 Pexels 的克里斯蒂娜·莫里洛拍摄

背景

最近，我在 Github 上看到越来越多的开发者拥有个人资料级别README.md，我想创建同样的东西。我认为这是另一个展示我的机会。我还觉得这是一个将技术观众引向对我来说重要的东西的好地方，这些东西就是我过去几周一直在写的文章。此外，如果你作为一名读者，目前正在寻求提高你在同事、客户或潜在雇主中的权威，这可能是另一个给人留下深刻印象的机会。作为一名科技领域的招聘经理，我也会对那些通过 Github 个人资料展示自己技能的人留下深刻印象。

我想展示的东西之一就是我正在写的这样的文章。我每周都会写一些文章，这要求我每次发表文章时都要记得去更新这些文章。作为一个开发者，这将是不可接受的，因为我希望你们中的一些人会有这样的反应😉。

这让我开始寻找在我之前已经为这种自动化做了些什么的伟人。在搜索过程中，我找到了一些 Go 教程，以及一个非常好的 JavaScript 教程，我在页脚中做了链接。

以此为灵感，我想我会自己构建它，因为我还没有找到一个人以我喜欢的方式用 Python 做这件事。接受了这个挑战后，我现在需要搜索所需的组件来保持我的 Github 概要自述文件是最新的。

对于那些不愿意等着看结果的人。你可以自己看看下图中的结果。

作者图片

入门指南

正如你在上面看到的，我的 README 页面中我想要自动化的部分将会是 Medium 上最近文章的提要。为了轻松做到这一点，我需要一个 python 库来解析 RSS 提要。除此之外，我想在页脚添加我所在时区的当前时间戳，以表明上次更新的时间，因为这在 Github profile 登录页面中没有显示。所有这些都将在我选择的语言 Python 3.8 中发生，所以如果你继续学习，请确保使用 Python 3，因为有一些文件 I/O 是 Python 3 特有的。

图书馆

这里是我决定使用的库，基于前面提到的实现这个目标所需要的库。

feed parser—一个为 Atom 和 RSS 提要提供解析器的库。我本可以构建自己的解析器并使用 urlib 或 requests，但是我可以添加这种依赖。

pytz —允许我们为我们想要的时区提供一个人类可读的名称，这样我们就有了一个时区感知时间戳。这可能是通过标准库的 tzinfo 来实现的，但是这个库是我愿意用于这个目的的拐杖。

概念

虽然你应该可以克隆我的回购协议，并从中工作，或者只是从这篇文章中复制和粘贴。了解以下概念会很有用。如果这篇文章中的其他内容值得在这里发表，请在评论中告诉我，我可以为任何未来对 Github 自述文件的自动化部分感兴趣的读者添加它。

Github 操作 — Github 的 CI/CD 解决方案允许我们创建和更新我们的 Github 自述文件的工作流程。

真正简单的聚合(RSS) —一种标准化的提要格式，在这种情况下，允许用户或应用程序自动检查新内容。

开始建造

如果你还没有这样做，我的第一步也是一样的。我需要利用 Github Profile 特性创建一个自己命名的 Github 库。所以有了下面的回购，我准备开始建立我的README.md文件。

[## 迪兰罗伊/迪兰罗伊

我目前在道琼斯公司工作，利用尖端技术提供创新产品，我的…

github.com](https://github.com/dylanroy/dylanroy)

我们的自述文件

为了确定我想更新我的README.md的哪些部分，我在 markdown 文件中搜索了短语“## Stories by Dylan Roy on Medium”，并添加了新的内容，在本文后面，当我浏览用于更新自述文件的代码时，您将会看到这些内容。

在未来的迭代中，我可能只需要更新一个主模板，而不是这个粗糙的方法，虽然这可以等到我决定向我的个人资料添加更多动态更新信息的时候。

Python 代码

因此，我们想要创建的自动化代码非常简单。首先，我们将使用 feedparser 读取一个 RSS 提要。

下一步是找到提要中列出的所有项目，并检查它们是否有与文章相关联的标签。这是我能够识别哪些是我发布的真实故事，哪些是评论的唯一方法。介质应该真正改变这一点，因为这是一个相当黑客。

过滤掉评论后，我们将故事列表加入到一个减价列表中，并将其附加到当前 readme 的末尾，使用 Python string 的 find 函数来识别标题所在的位置，从而删除旧的故事列表。

一旦看到这个样子，我就发现在 Github 中查看配置文件时缺少了一些东西。如果由于某种原因同步失败，我不知道信息是否过时，只需查看自述文件。

为了让我的个人资料的读者明白这一点，也为了让我在调试问题时明白这一点。我需要在最终产品中添加一个带有最新更新日期的页脚，如下所示。

作者图片

我做的第一件事是创建一个页脚模板，如下所示。在这个模板中，我只是使用了 python 字符串插值的模板语法。

<hr>
<div align="center">
README.md last auto generated {timestamp}
<br>
<a href="https://medium.com/@dylanroy" target="_blank">Learn to automate you own README here!</a>
</div>

更新和添加页脚的代码非常简单。第一步是以适合我的格式更新我想要的时间值。这就是pytz库发挥作用的地方。我想用我的时区来反映它，所以我只是用那个时区配置了检索到的时间戳。

之后，就像使用标准 Python 格式函数替换那个时间一样简单。

注意:不是用标准的open函数打开文件，然后读取内容。我使用Path对象一次性读取文件的内容。否则，我需要在之后关闭文件流，或者为文件操作设置一个范围。

之后，我们只需要将 Github 动作运行所需的功能组合在一起。步骤很简单。

  1. 阅读旧的 readme 与我们的手路径对象。
  2. 将更新后的自述文件输出到变量中
  3. 将此内容写入文件，并追加更新后的页脚。

下面是完整的代码，这样可以更容易地为您自己的目的进行复制导入等等。

通过操作实现自动化

现在我只需要为需要调度的 Github 动作构建工作流。

在之前的一篇文章中，我实际上描述了如何构建一个操作工作流来保持数据集最新，因此如果您已经阅读过，那么您将只是在这一点上逐步完成动作，因为这些工作流非常相似。因为我已经写完了，所以我不会对每一步做太深入的描述。

[## 具有 Github 操作的简单版本化数据集

不到 10 行 Python 代码，保存了著名 CEO 的历史

towardsdatascience.com](/simple-versioned-datasets-with-github-actions-bd7adb37f04b)

首先，我们想安排我们的行动运行。在本例中，我只选择了上午 5:05。这些操作使用 cron 语法进行调度，因此这一步非常简单。

Github 动作工作流中需要定义的下一件事是我们想要在其上执行动作的操作系统。虽然将来我可能会使用更亮的图像，但我选择了最新的 ubuntu 来运行。

最初的步骤是我基本上复制并粘贴到我创建的每个动作中的步骤。它们按此顺序用于以下目的。获取 Github 存储库的工作副本，设置 Python 3.8，并安装将要执行的 Python 脚本的需求。

在工作流中的这一点上，运行我们的代码以更新数据集所需的一切都已经提供给了环境，因此在这一步中，我们现在将这样做。

现在，我们有了 readme 的更新版本，剩下的就是提交这些更改了。下面的命令就是这样做的，并推动这些更改。此时，我们已经执行了指示我们自动更新自述文件所需的所有操作。

和前面的步骤一样，这里是完整的 Github 操作流程。确保将这个文件放在.github/workflows目录中，这样就一切就绪了。

将来我将对我的自述文件做一个额外的改进。将有条件地部署我的自述文件更新。现在我每天都有一个提交，但是只有当新的帖子出现时才更新是有意义的。我在下面的另一篇文章中采用了这种方法，我在下面链接了一个版本化数据集的条件部署。

关键要点

实际上，自动化操作非常容易。在这种情况下，你的 Github Profile 自述文件不仅可以传达你是一名开发人员，还可以作为作品集的一部分。

如果你在找工作或想给人留下深刻印象，这份文件可以帮助你开始成为一个更有吸引力的候选人。你能做什么的限制实际上只是你的想象，因为围绕公共 Github Repos 没有任何明确的限制。一旦你开始使用它，就值得在 Github 中搜索一些其他的配置文件自动化的例子，因为有一些非常有创意的例子。我印象最深的是 Tim Burgan 的，他的个人资料中有一场公共象棋比赛。

[## 廷伯根-概述

游戏正在进行中。任何人都可以下一步棋。这才是重点。👋轮到你了！移动一个白色…

github.com](https://github.com/timburgan)

感谢阅读。我在下面链接了我的其他教程，如果你感兴趣的话，请看看，并给我一个关注，以保持对未来文章的了解。

阅读迪伦的其他教程

[## 用 Python 创建漂亮的架构图

停止花费时间手动调整未对准的箭头

towardsdatascience.com](/create-beautiful-architecture-diagrams-with-python-7792a1485f97) [## 具有 Github 操作的简单版本化数据集

不到 10 行 Python 代码，保存了著名 CEO 的历史

towardsdatascience.com](/simple-versioned-datasets-with-github-actions-bd7adb37f04b)

资源

将数据转换为模型的魔力

原文：https://towardsdatascience.com/autoai-the-magic-of-converting-data-to-models-185f26d22234?source=collection_archive---------43-----------------------

不用一行代码就能构建复杂的人工智能模型！

IBM Watson AutoAI

AutoAI 是一个图形工具，是 Watson Studio 的一部分，它允许在没有编码的情况下生成预测模型。AutoAI 由 IBM 生产，用于自动化企业 AI 模型开发，并减少建模生命周期的时间。奥拓获得爱康智能自动化奖。

AutoAI 具有强大的功能，包括:

  • 快速选择和创建模型
  • 人工智能生命周期管理，即理解你的数据，清理数据，预处理，培训，特征工程，微调，并为部署提供 API
  • 易用性(只需几次点击即可培训和部署不同的模型)

自动开票流程—来自自动开票文档的图像

Watson Studio 中的视觉识别

Watson Studio 识别服务使用尖端的深度学习算法对图像进行分析和分类，并检测物体和其他内容。它允许用户建立一个协作环境，机器学习工程师可以远程合作。它将项目与 Github 连接起来，使推和拉变更变得更加容易。它支持不同的图像格式，如 JPEG 和 PNG。它还支持笔记本。

使用 Watson Studio 构建的视觉识别模型— 来自 Watson Studio 文档的图像

自然语言分类器

Watson Studio 自然语言分类器允许用户基于用户定义的类来构建文本分类器。它支持 CSV(。csv)数据文件，其中包含每个类的样本。它支持不同的语言，包括英语、阿拉伯语、法语、德语、意大利语、日语、韩语、葡萄牙语(巴西)和西班牙语。Watson Studio 提供多类别分类和多阶段分类(单个 API 请求中最多 30 个单独的输入)。它还支持笔记本中的 API。

这是一个使用 Watson Studio 构建的示例模型，包含三个类(嗨，问题，问题。

Watson Studio 中的自然语言分类器模型生成器— 图片来自 Watson Studio 文档

自动示例

在下文中，我列出了我创建的几个博客，以指导您使用 AutoAI 训练和部署不同模型的步骤:

图像分类

我们将使用包含来自世界各地的 120 种狗的图片的斯坦福狗数据集。我们的分类器的目标是根据狗的品种对狗的图像进行分类。

[## 如何使用 Watson AutoAI 构建图像分类器

建立一个没有编码的图像分类模型

towardsdatascience.com](/how-to-build-an-image-classifier-using-watson-autoai-ab1ffda25bab)

使用预先训练的图像分类器

在这篇博客中，我们学习了如何通过将预先训练好的模型公开为推理任务的 API 来重用它们。

[## 如何使用 Watson AutoAI 推断预训练的图像分类器

推理 AutoAI 预训练模型

towardsdatascience.com](/how-to-inference-a-pre-trained-image-classifier-using-watson-autoai-a63894a06458)

目标检测

在这篇博客中，我们学习如何建立一个模型来检测大脑扫描中的癌症和液体。

[## 如何使用 Watson AutoAI 建立对象检测模型

无需编码，构建脑瘤目标检测模型

towardsdatascience.co](/how-to-build-an-object-detection-model-using-watson-autoai-64677e045fd0)

文本分类

我们建立了一个模型，用于将不同的 StackOverflow 帖子分类到不同的标签中。

[## 使用 Watson AutoAI 建立文本分类模型

如何在不编码的情况下使用 Watson Studio AutoAI 训练文本分类器

towardsdatascience.com](/build-a-text-classification-model-using-watson-autoai-3650c461642)

如果你是图像分类/深度学习的新手，请查看我的帖子，了解深度学习的基础知识，并在下面的博客中端到端地了解整个训练过程:

[## 在深度学习的掩护下

理解神经网络的循序渐进教程

towardsdatascience.com](/under-the-hood-of-deep-learning-e8bb39aec5d2)

了解关于嵌入和文本模型的更多信息

[## 嵌入模型背后的魔力

探索 Word2vec 和 GloVe 的实现

towardsdatascience.com](/the-magic-behind-embedding-models-c3af62f71fb)

如果你是文本数据的初学者，想从头开始，看看下面的帖子

[## 文本矢量化:将文本转换为数字的魔力

将文本转换成数字的魔力

towardsdatascience.com](/the-magic-behind-embedding-models-part-1-974d539f21fd)

结论

机器学习工程师经常花费相当多的时间来搜索合适的模型(参考模型)。使用 AutoAI 可以极大地改进和简化这一步骤。它有助于轻松建立深度学习模型，只需提供您的数据，无需一行代码。

如果您有任何问题，请告诉我！

承认

非常感谢Jorge Castaón的宝贵意见，使这个博客的质量得以提高！

资源

AutoAI:您的伙伴(值得信赖的合作伙伴),加快您的 AI 和 ML 模型的上市时间。

原文：https://towardsdatascience.com/autoai-your-buddy-trusted-partner-to-speed-up-time-to-market-for-your-ai-and-ml-models-64690fb22e16?source=collection_archive---------49-----------------------

自动化 ML 生命周期的不同步骤

在 Unsplash 上由 Franck V. 拍摄的照片

Auto AI 或 AUTO ML(甚至自动化数据科学)是学术界和行业中一个活跃的研究领域。云供应商推广某种形式的 AutoML 服务。同样，科技独角兽也为其平台用户提供各种 AutoML 服务。此外，还有许多不同的开源项目，提供了有趣的新方法。但是什么是 Auto AI，AutoML 是什么意思？

AutoAI 以一种复杂的方式利用特征训练来自动完成整个机器学习管道中的大多数复杂和耗时的任务，更具体地说，是特征工程和 ML 模型选择和构建部分。它不需要您成为数据科学专家。当然，如果你有这方面的专业知识会有所帮助，因为到那时，你将能够在下一个最佳水平上利用自动人工智能能力，这就是所谓的反馈回路中的人类。

预计自动化人工智能将有助于将 ML 功能提升到一个新的水平，帮助商业用户改善 ML 工作流程。虽然，自动人工智能的长期目标是自动化大部分(如果不是全部的话)将 ML 应用于商业用例的端到端过程。我们有必要了解它的能力、局限性以及自动化人工智能的未来目标。

这篇博客的重点是澄清概念，它包括什么，我们还缺少什么，或者换句话说，需要哪些潜在的改进来完成自动化数据科学之旅。本博客讨论了与 AutoML 相关的项目和研究工作的前景和历史，不仅着眼于超参数优化，还考虑了对端到端工作流和数据科学实践的影响。

🎓你会学到什么？

在这篇博客中，你将了解到以下几个方面:

  • 自动人工智能、自动人工智能，以及我们所说的自动人工智能/数据科学是什么意思
  • 目前使用的各种自动化技术
  • AutoML 的近期功能和局限性，以及长期目标
  • 如何利用这项技术来改善机器学习工作流的端到端生命周期

什么是汽车 AI？

AutoAI 代表人工智能的自动化。更具体地说，它意味着 ML / DL 管道的哪些部分(或步骤)可以而且应该自动化。它以机器学习步骤的选择和调整的自动化为中心，包括但不限于数据准备、特征工程和提取、模型选择、超参数调整和优化、结果解释和可视化。

ML 工作流程的哪些部分可以自动化？

虽然不是数据科学工作流中的一切，但我相信很多事情是可以自动化的。你可以看看下面一个典型的机器学习工作流程，我在 2020 年 4 月关于功能商店的文章中介绍过。我把它转贴下来供你参考。Feature Store 是让你的 AI 和数据科学工作流自动化的一个很好的方式(至少在很多部分)。关于功能商店的更多细节，你可以阅读 T2 的博客。

预先实现的模型类型和结构可以从输入数据集中呈现或学习以供选择。AutoAI 简化了 AI 项目的开发、价值证明计划，并帮助(企业)用户加快 ML 解决方案的开发，而无需丰富的编程知识。然而，就目前而言，它可以作为数据科学家的补充工具。这有助于他们快速找到他们可以尝试的算法，或者看看他们是否错过了一些算法，这可能是一个有价值的选择，以获得更好的结果。

通常，商业领袖认为，如果他们手中有自动人工智能工具，他们为什么要雇用数据科学家。我强烈建议不要陷入这种想法，因为它会给你错误的印象。

原因是，

  • 数据科学就像任何其他业务职能一样，必须尽职尽责地执行，并需要创造性思维和人类技能来充分利用它。
  • 汽车人工智能仍然没有出现，我们正在研究的仍然是狭义的人工智能，我们还没有接近实现(通用人工智能)AGI，一旦我们有了它，我们就可以考虑没有数据科学家的生活，至少在大部分情况下。
  • 数据科学就像保姆，你必须定期照看你的管道、模型、数据和其他资产
  • 理解业务和数据(CRISP-DM 模型的前两步)不能由算法来完成，你需要一个数据科学家来做这项工作，为 ML 管道准备好数据。
  • 同样，在管道的其他步骤中，您仍然需要数据科学家和人工智能专家来确保模型正常工作，如果有什么需要调整的话。
  • 最后但并非最不重要的一点是，一旦您获得了结果和业务见解，您仍然需要数据工作者来解释它们并将其传达给业务部门。

我在这里很早就提出了这些观点，这样您就不会因为没有数据科学家就可以使用 AutoAI 而感到困惑。如果您在迈向基于人工智能的转型之旅中同时拥有这两者，那将是最好的选择。

与此同时，我想强调并提醒你，有一个极好的价值，汽车人工智能可以提供给你，并缩短上市时间的毫升模型，这就是为什么我想出了这个博客。

企业寻求自动化 ML 管道和 ML 工作流中的不同步骤，以解决他们加快采用人工智能的趋势和需求的增长。在深入研究什么是自动化之前，我们先来看看标准的 ML 管道是什么样子的。如上图所示，它包括数据检索、数据准备、建模、超参数调整、模型部署和监控。

在初始数据摄取之后，我们需要删除重复项，修复缺失值，并解决数据中是否存在任何潜在错误。下一步是应用特征工程来提取和工程化特征，然后从清理后的数据集中获得训练数据。它包括数据编码、特征(重新)缩放、相关性分析等。

然后，我们将这些准备用于训练的特征馈送到所选模型，随后进行超参数调整。这种模型选择和参数调整需要数据科学家多次经历这个过程，并比较模型的性能。

由此产生的模型及其结果需要检验和解释。在这一步中，数据科学家必须验证特征的重要性，检测潜在的偏差，并解释预测，以便业务用户能够理解见解并理解它们对他们的相关性。

数据科学家对每个用例和每个用例中的每个用例都要经历这个过程。这些重复需要花费时间、精力、金钱和延迟才能投入生产。出于这个原因，我们建议 AutoAI 可以作为救星出现，并且可以自动化 ML 生命周期的许多步骤。

不同的供应商提供了 ML 管道自动化的解决方案。由 IBM 提供的解决方案被称为 AutoAI。AutoAI 专注于自动准备数据、选择和应用机器学习算法，以及构建最适合您的数据和业务场景的模型管道。

数据清理和特征工程

在 ML 管道中，数据摄取之后的第一步是关于数据清理和特征工程:特征+(选择、提取、构造)。“自动分析”可以帮助您检测数据中可能存在的重复项、缺失值以及其他不一致或错误。在解决了这些问题(数据清理)之后，我们将数据中的属性转换为特征，以便 ML 模型可以使用它们。特征的质量和数量极大地影响了模型及其结果。

特征选择:系统使用搜索策略选择特征子集，并对其进行评估。它一直这样做，直到找到适合该模型的这样一个特征集。

特征构建:从原始数据或结合现有特征创建新特征。

特征提取:侧重于使用 PCA、独立成分分析、isomap 等标准方法进行降维。

通常，这一步需要数据科学家花费大量时间，因为这是一个繁琐的过程。Auto AI 解决了这个问题，提高了效率并保证了质量特性。

提出正确的功能是机器学习流程中最耗时的步骤之一。

模型选择、超参数调整和模型测试

有两种选择模型的方法。传统上，数据科学家专注于手动模型选择:从传统的 ML 模型(决策树、SVM、逻辑回归等)中选择模型。)基于可用的数据和模型的适用性。AutoAI 使用的第二种方法是神经架构搜索(NAS) :它试图在 b 背景中使用强化学习来设计网络架构。

由于数据科学家是稀缺资源，这一部分通常对数据科学家来说非常具有挑战性，因为他们的时间和其他实际考虑有限，不允许他们同时尝试多个模型。AutoAI 在许多方面帮助他们。一旦模型得到训练，就可以在 AutoAI 的测试和进一步调整中重用它们。

为了有效地选择最佳模型，AutoAI 对小的数据子集运行估值器，逐渐增加。它有助于系统迭代地消除估值器并选择最佳估值器，同时节省时间和存储等稀缺资源。

一个至关重要的方面是超参数训练。它包含管理培训过程的数据。超参数调整运行整个训练作业，评估结果，并进行调整，以找到最佳的参数组合，从而找到解决方案。

Auto AI 提供了一个智能的超参数调整，可以调整每个算法的基本超参数。用于 HPO 的方法包括进化算法、强化学习、贝叶斯优化等。它搜索每个参数的不同范围的值，一旦算法完成执行，您可以选择相应的模型并可视化结果。

解释和可视化

您希望能够可视化数据集和模型，即能够看到关于数据的统计信息，如数据类型、分布、异常值等。如果没有自动化的人工智能，数据科学家可能需要几个小时甚至几天的工作。

可视化有助于用户更直观地了解和理解数据。它还可以帮助你解释模型，把它们变成白盒。例如，如果您可以直观地绘制决策树的结构，这将非常有帮助。它使用户能够评估模型并修改树结构，如剪枝和增强。同样，它有助于了解关于特征、特征的重要性以及特征如何影响模型预测的信息。

模型部署和监控

当模型准备好进行部署时，可以使用模型功能的一键部署，这让数据科学家感到非常轻松和舒适。此外，如果您可以选择并保存您希望与模型一起使用的服务，并创建模型的版本控制，这将会很有帮助。我的意思是，谁不想有“饭桶”在那里！

模型管线的自动评分使模型准备好在生产中运行它们。除此之外，它还为用户提供了运行多项实验的灵活性，例如 A/B 测试、健康检查、维护和应用安全补丁。

汽车人工智能的未来

在未来，汽车人工智能将获得更多的采用和动力。它要求进一步改进和增加 AutoAI 系统的功能。例如，添加数据收集功能将非常有帮助，因为这通常是需要解决的挑战性问题之一，尤其是高质量的数据。这个问题有两个解决方案；1)数据合成和 2)数据搜索。

数据合成:数据扩充将对图像数据有用；文本数据的翻译也有帮助，数据模拟可以服务于更特殊的任务。

数据搜索:由于互联网包含无限的数据，数据搜索可能会成为一个很好的解决方案。此外，特定于领域的功能将有助于针对特定场景自动化数据科学。

2020，Chan Naseeb。保留所有权利。

自动更正

原文：https://towardsdatascience.com/autocorrect-8c33f3b472a0?source=collection_archive---------15-----------------------

自然语言处理笔记

自然语言处理专业课程 2 第 1 周笔记

真诚媒体在 Unsplash 上拍摄的照片

自动更正是我们所有人的救星。有多少次，我去输入一条信息，它会出来，好像我喝醉了，然后自动更正替我调解-哦，我多么爱你自动更正(有时)。

更正式地说，自动更正是一种软件功能，它在我们打字时自动建议或纠正拼写或语法错误。

我们都使用自动更正，但这篇文章将教你它是如何工作的。然而，在这些笔记中，我们将只涉及拼写错误，而不是上下文错误。例如，“祝我的朋友生日快乐！”包含拼写错误的单词“deah”，“自动更正”有望识别该单词并将其更改为“dear”(假设我们的模型是准确的)。另一方面，“生日快乐我的鹿朋友！”不会被认为是一个错误，因为“鹿”是一个真实的单词(它是一种动物)，在上下文中是不正确的，除非你的朋友实际上是一只鹿。

注:捕捉上下文错误是一个更复杂的问题，我们将在以后讨论。

自动更正是如何工作的？

建立更正拼写错误的自动更正模型有 4 个关键步骤:

#1:识别拼错的单词——根据我们之前的例子，我们如何知道单词“ deah ”拼错了呢？如果一个单词拼写正确，那么这个单词可以在字典中找到，如果不正确，那么它可能是一个拼写错误的单词。因此，当一个单词在字典中没有给出时，我们会将其标记出来进行更正。

#2:查找字符串 n 编辑距离 —编辑是对一个字符串执行的将它转换成另一个字符串的操作， n 就是编辑距离(即 1、2、3 等的编辑距离)，它统计了编辑操作的次数。因此， n 编辑距离告诉我们一个字符串与另一个字符串相距多少个操作。以下是不同类型的编辑:

  • 插入(添加一个字母)
  • 删除(去掉一个字母)
  • 切换(交换两个相邻的字母)
  • 替换(将一个字母改为另一个字母)

通过这 4 次编辑，我们能够修改任何字符串。并且这些编辑的组合允许我们找到所有可能的字符串的列表，这些字符串是 n 编辑的。

注意:对于自动更正，n 通常是 1-3 次编辑。

#3:过滤候选词 —我们只想考虑候选词列表中拼写正确的真实单词，因此我们将这些单词与已知词典进行比较(如# 1】，并过滤掉候选词列表中未出现在已知词典中的单词。

#4:计算单词概率——利用我们的实际单词列表，我们可以计算单词概率，从候选单词中找出最有可能的单词。这就要求我们知道语料库中的词频和总字数。

图 1 :计算单词概率的公式(图片由作者提供)

给定图 1 中的公式，我们可以想象一个由句子“我很高兴，因为我在学习”组成的语料库，我们首先计算字数…

图 2 :字数统计(图片由作者提供 NLP 专业化课程 2 第 1 周表格的翻拍)

然后我们应用我们的公式来计算单词概率(我们将使用“I”作为例子)…

图 3 :计算单词“I”的单词概率

当执行自动更正时，我们必须找到概率最高的候选词，并选择该词作为替换。

最小编辑距离

上面我们看到了如何使用编辑距离应用自动更正，然而，当我们给定多个单词或整个文档时，我们也可以使用最小编辑距离来评估它们的相似程度。事实上，在许多情况下可以应用最小编辑距离，例如:

  • 拼写纠正
  • 文档相似度
  • 机器翻译
  • DNA 测序

还有更多。

最小编辑距离 →将一个字符串转换成另一个字符串所需的最少操作次数。

为了计算最小编辑距离，我们使用了我们已经讨论过的 3 种类型的编辑计算。这 3 个编辑是插入、删除和替换——最小编辑距离示例见图 4 。

图 4 :使用编辑将源单词替换为目标单词的示例(作者图片)

鉴于我们认为所有编辑操作的成本相同，图 4 中的编辑总数为 2。但是，通过调整每次编辑的成本，我们可以计算出编辑成本，这是我们试图通过合计每次编辑的成本来最小化的成本——更新后的编辑成本见图 5 。

图 5 :一次编辑的成本。

对于我们的例子，在图 4 中，我们修改后的编辑成本是 4。这很简单，我们可以直观地解决这个问题。然而，如果我们有更长的字符串或大量的文本，操作就会更多，也不会那么简单。我们可以尝试用蛮力来克服这一点，每次增加一个额外的距离，并枚举所有的可能性，直到一个字符串转换成另一个字符串。但是，这可能会花费不必要的长时间。

注意:这样求解会成倍增加计算复杂度，
随着每个字符串长度的增长。

动态规划

更快的方法是使用动态编程。动态编程是计算机科学中一项众所周知的专长，指的是通过将复杂的问题分解成更简单的子问题来简化它。其思想是简单地存储子问题的结果，这样我们就不必在以后需要时重新计算它们。这个简单的优化将时间复杂度从指数级降低到多项式级(来源: GeeksToGeeks )。

注意:深入研究动态编程超出了这篇文章的范围，但是你可以在维基百科上读到更多。

图 6 :我们要用编辑成本填充的矩阵 D——注意:D[2，3]用橙色突出显示，作为我们如何引用每个网格的示例。(图片由作者提供)

从图 6 的中给定我们的编辑成本，我们的矩阵 D 的第一个任务是填充 D[0，0]，我们从源中的空字符串到目标中的空字符串。这是非常明显的，因为它们是相同的，所以达到这一点的编辑次数应该是 0。

事实上，填充第一行和第一列是非常直观的，因为我们只是将删除的成本添加到前一个单元格中——参见图 7。

图 7 :填充 D 矩阵第一行第一列

这可以用数学方法表示，如图 8 中的所示。

图 8: 数学表达式(图片由作者提供)

现在，让我们将此公式应用于图 7 中的示例，以更新编辑成本。还记得我们之前说过答案是 4，我们直观地算出了答案，因为我们有相当简单的字符串。为了确定最小编辑距离，我们将看到在矩阵的 Dm，n中出现的操作数——如果我们做得正确，应该是 4。

图 9: 完成的三维矩阵

如你所见，矩阵同意 4 是将状态转换为污点的最小编辑距离。我还在矩阵中添加了一些颜色来突出有趣的图案。

注:这个我个人在重复了无数遍视频后还是没看懂。Youtube 上一个叫做最小编辑距离动态编程的视频帮我澄清了这个问题。

为了测量编辑距离，我们指定 3 个编辑:插入、删除和替换，编辑成本为 1、1、2，分别称为 Levenshtein 距离，这不是唯一的方法，但也是我们在示例中使用的方法。同样重要的是，我们在每个单元格中保留一个回溯，或者简单地说，一个指针，以允许我们跟踪我们是如何达到最小编辑距离的。

谢谢你看完。在 LinkedIn 上和我保持联系，让我们一起学习！

[## Kurtis Pykes -数据科学家-自由职业者，自由职业者| LinkedIn

在世界上最大的职业社区 LinkedIn 上查看 Kurtis Pykes 的个人资料。Kurtis 有 3 个工作列在他们的…

www.linkedin.com](https://www.linkedin.com/in/kurtispykes/)

谷歌、亚马逊和 Pinterest 中的自动更正以及如何编写自己的自动更正

原文：https://towardsdatascience.com/autocorrect-in-google-amazon-and-pinterest-and-how-to-write-your-own-one-6d23bc927c81?source=collection_archive---------8-----------------------

在本文中，我将解释什么是搜索功能领域的拼写纠正，它如何在谷歌、亚马逊和 Pinterest 中工作，并将演示如何使用自定义搜索引擎蝎狮搜索从头开始实现自己的应用。

“禽龙”，海因里希·哈德(维基媒体)

拼写纠正也称为:

  • 自动校正
  • 文本校正
  • 修复拼写错误
  • 错别字容差
  • “你是说？”

“等等”是一种软件功能，它可以给你提供替代文本的建议，或者对你输入的文本进行自动更正。

卡耐基梅隆大学的界面设计教授 Brad Myers 说，纠正键入文本的概念可以追溯到 20 世纪 60 年代。这是一位名叫沃伦·泰特尔曼的计算机科学家，他也发明了“撤销”命令，提出了一种叫做 D.W.I.M .的计算哲学，或者说“按我的意思做”泰特尔曼说，我们应该给计算机编程，让它们识别明显的错误，而不是让它们只接受完全格式化的指令。

第一个提供拼写纠正功能的知名产品是 1993 年发布的 Microsoft Word 6.0。

如今，人们无法想象他们的真实生活中没有消息传递、搜索、浏览和使用不同的商业应用程序:文本编辑器、内容管理系统(CMS)、客户关系管理系统(CRM)等。在所有这些网站中，人们会犯打字错误，忘记单词的正确拼写，有时还会犯语法错误等等。这绝对没问题，每个人都会犯错。一个好的软件所做的就是帮助你以最简单和最有效的方式修复这些错误。有很多方法可以做到这一点:从它如何寻找用户，它带来什么价值，以及它是如何在引擎盖下制造的。

在这篇文章中，我们将特别关注搜索系统，因为对于它们来说，在处理之前(或处理过程中)纠正您的搜索查询尤为重要，因为否则您的搜索结果可能是绝对错误的。

自动更正的不同方法

就用户体验而言，我们可以将这些方法分为两组:

  • 在第一种情况下，系统会在你输入的时候试图纠正你的文字
  • 在另一种情况下，它认为这是已知的，然后给你建议

在大多数情况下，这些方法是结合在一起的，所以系统会在你输入时试图纠正你，如果它认为还有问题，会在你得到搜索结果后建议你改正。

  • 自动更正 —立即更正键入的错误查询
  • 自动完成功能——许多现代网站的另一大功能，通常与自动更正功能结合在一起
  • 建议 —这是一种自动完成和自动更正的混合，看起来像是建议你键入的内容有一点不同，但仍然有意义(见下图)
  • 突出错误的——另一个不错的功能是突出错误。它也可以在你打字时和打字后完成
  • “你是说”——很多系统不仅在你打字的时候，而且在显示搜索结果的时候，都会向你推荐精炼的搜索查询。我们称之为“你是说…？”。依次有两种模式:
  1. 通过你的原始搜索查询进行搜索，然后只显示推荐的查询(就像谷歌一样)
  2. 或者按精搜索，建议“改为搜索

键入组件时:

查询后:

让我用图片向你展示不同的流行网站如何使用上述技术。

谷歌谷歌作为互联网上排名第一的网站无所不能:自动更正、自动完成、建议、错误突出显示和“你是指”。谷歌使用预测服务来帮助完成搜索，甚至是地址栏中键入的 URL:这些建议或预测(谷歌称之为预测)是基于相关的网络搜索、你的浏览历史和谷歌网站排名。

亚马逊使用名为 A9 的面向电子商务的搜索算法。它与谷歌算法的不同之处在于，它非常强调销售转化率。

就亚马逊的自动更正实现而言，它包含了前面提到的所有组件，但由于它是一个市场，其建议排名公式似乎包括了一个建议在销售方面对你有多大吸引力的因素。

Pinterest 也有自己的基于内部域/pin/pin ners 相关性的算法。

它是如何工作的

现在让我们考虑一下如何进行拼写纠正。有几种方法，但重要的是，没有一种纯粹的编程方法可以将你输入错误的“ipone”转换成“iphone”(至少质量不错)。大多数情况下，必须有一个系统所基于的数据集。数据集可以是:

  • 拼写正确的单词词典。反过来，它可以是:
  1. 基于你的真实数据。这里的想法是，在根据你的数据组成的字典中，拼写大多是正确的，然后对于每个键入的单词，系统只是试图找到一个最相似的单词(我们将很快谈论如何准确地完成)
  2. 或者可以基于与你的数据无关的外部字典。这里可能出现的问题是，您的数据和外部字典可能差别太大:字典中可能缺少一些单词，您的数据中可能缺少一些单词。例如，在这些情况下:

但是，对于较小的数据集合来说，这仍然是有意义的，因为这样一来，搜索查询被纠正的可能性就更大了

  • 不仅仅是基于字典，而且上下文感知，比如如果我搜索“白色 ber ，谷歌理解我指的是一只熊:

但是如果我把它改成“黑暗 ber ”，它就会明白我指的是啤酒:

上下文可能不仅仅是你查询中的一个相邻词，还包括你的位置、时间、当前句子的语法(比如把“there”改成“their”或者不改)、你的搜索历史以及几乎任何其他可能影响你意图的东西。

  • 另一个经典的方法是使用先前的搜索查询作为拼写校正的数据集。它甚至更多地用于自动完成功能，但对自动更正也有意义。这里的想法是，大多数用户的拼写是正确的，因此我们可以使用他们搜索历史中的单词作为事实的来源，即使我们的文档中没有这些单词，也不使用外部词典。上下文感知在这里也是可能的。
  • 另一种方法是使用你的用户以前的搜索查询和/或你的字典和/或文档来找出一些校正规则，并使用它们来校正新的搜索查询。甚至还有一项关于这个https://patents.google.com/patent/US6618697B1/en的专利

对于所有的方法，可以使用不同的算法来搜索和评估候选拼写纠正:

  • 从最简单的比较一个给定的单词和字典中的所有单词
  • 早期拒绝算法可以大大缩小候选列表的范围(我们将在下面详细讨论)
  • 不同种类的有限自动机来提高寻找候选者的性能(Lucene 的方式)
  • 概率模型，例如 Etsy 在先前搜索查询的基础上利用的隐马尔可夫模型
  • 到通常需要大量训练数据的不同机器学习技术

看看人工智能、机器学习和语义搜索最近发展得多快，我相信在这十年里，拼写纠正技术的前景可能会发生巨大变化，但就目前而言，上述方法似乎是最常用的。而且大多数解决方案都是基于你现有的数据收集和由此组成的字典。

如何编写您的自定义自动更正

在这里，我将描述我自己在蝎狮搜索的帮助下进行网站搜索的一部分经历。大约一年前，我在为一些客户项目工作时发现了这个产品，由于它的轻量级和快速搜索以及许多开箱即用的功能，我仍然在我的一些项目中使用它。

现在，让我们来讨论一下您可以使用哪些工具将自动更正功能添加到您的系统中，同时更深入地了解一些更简单的技术是如何工作的。

到这样做的话，我们将选择一个流行的定制搜索引擎，因为它们通常提供我们正在寻找的功能。我喜欢蝎狮搜索，因为与更知名的 Elasticsearch 相比，它更轻量级，更容易处理，因为它是 SQL 原生的，在大多数情况下工作更快。它是如此的 SQL 原生，你甚至可以用一个标准的 MySQL 客户端连接到它。它们提供了一个官方的 docker 图片，所以我将用它来演示自动更正在蝎狮搜索中是如何工作的:

➜ ~ **docker run --name manticore -d manticoresearch/manticore** 1ac28e94b3ca728fb431ba79255f81eb31ec264b5d9d49f1d2db973e08a32b9f

在容器内部，我将运行 mysql 来连接运行在那里的蝎狮搜索服务器:

➜ ~ **docker exec -it manticore mysql**
Welcome to the MariaDB monitor. Commands end with ; or \g.
Your MySQL connection id is 1
Server version: 5.5.21
Copyright © 2000, 2018, Oracle, MariaDB Corporation Ab and others.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

它配有两个测试表，我们可以用它们来快速纠正拼写:

MySQL [(none)]> **show tables;** +--------+-----------+
| Index  | Type      |
+--------+-----------+
| pq     | percolate |
| testrt | rt        |
+--------+-----------+
2 rows in set (0.00 sec)

让我们检查一下 testrt 的模式:

MySQL [(none)]> **describe testrt;** +---------+--------+------------+
| Field   | Type   | Properties |
+---------+--------+------------+
| id      | bigint |            |
| title   | field  | stored     |
| content | field  | stored     |
| gid     | uint   |            |
+---------+--------+------------+
4 rows in set (0.00 sec)

并在其中插入少量文档。让它成为电影标题:

MySQL [(none)]> **insert into testrt(title)** values('The Godfather'),('The Wizard of Oz'),('Combat!'),('The Shawshank Redemption'),('Pulp Fiction'),('Casablanca'),('The Godfather: Part II'),('Mortal Kombat'),('2001: A Space Odyssey'),('Schindler\'s List');Query OK, 10 rows affected (0.00 sec)

我们现在可以在索引中看到我们所有的文档:

MySQL [(none)]> select * from testrt;
+---------------------+------+--------------------------+---------+
| id                  | gid  | title                    | content |
+---------------------+------+--------------------------+---------+
| 1657719407478046741 |    0 | The Godfather            |         |
| 1657719407478046742 |    0 | The Wizard of Oz         |         |
| 1657719407478046743 |    0 | Combat!                  |         |
| 1657719407478046744 |    0 | The Shawshank Redemption |         |
| 1657719407478046745 |    0 | Pulp Fiction             |         |
| 1657719407478046746 |    0 | Casablanca               |         |
| 1657719407478046747 |    0 | The Godfather: Part II   |         |
| 1657719407478046748 |    0 | Mortal Kombat            |         |
| 1657719407478046749 |    0 | 2001: A Space Odyssey    |         |
| 1657719407478046750 |    0 | Schindler's List         |         |
+---------------------+------+--------------------------+---------+
10 rows in set (0.00 sec)

W 刚刚发生了什么:当我们插入标题时，不仅蝎狮搜索按原样保存了它们，而且它为自然语言处理(NLP)做了许多必要的事情:标记化(将标题拆分成单词)、规范化(将所有内容都小写)和许多其他事情，但对我们来说有一点很重要，那就是它将单词拆分成组成它们的三元模型。比如“战斗！”(或者实际上是常态化后的“战斗”)被拆分为【com】【OMB】【MBA】【bat】。为什么这很重要呢？

为了回答这个问题，让我们假设我们在“战斗”中打错了，而是输入了“comabt”。如果我们现在想要“战斗”被发现，我们该如何做呢？这些选项包括:

  • 我们可以查阅整个字典，将每个单词与我们的关键字(“comabt”)进行比较，然后我们会评估这两个单词之间的差异。它叫做莱文斯坦距离。对于给定的一对单词，有几种方法可以计算出来，但问题是，即使你能这么快地计算出两个单词，你也可能需要一段时间来比较字典中的每个单词和给定的单词
  • 因此，最好不要比较字典中的所有单词，而只比较那些更有可能对给定单词进行更正的单词。接下来是三元模型的概念——如果我们将所有的字典单词和搜索关键词都分成三元模型，我们现在可以操作这些更小的符号来找到候选词。

因此，在这种情况下，内部所做的是，蝎狮搜索首先将“comabt”拆分为中缀:“com”、“oma”、“mab”和“abt”，然后在字典中找到相应的单词，因为当文档被插入时，它也这样做。由于这种算法的复杂性不是很高(比互相比较每个单词低得多)，蝎狮很快发现有一个单词“combat”也有“com ”,而且它是唯一的候选单词。因此，在此之后，它所要做的就是确保候选单词与给定单词不会有太大差异。它计算 Levensthein 距离，认为它不大于限制值(默认为 4 ),并返回候选值:

MySQL [(none)]> call qsuggest('comabt', 'testrt');
+---------+----------+------+
| suggest | distance | docs |
+---------+----------+------+
| combat  | 2        | 1    |
+---------+----------+------+
1 row in set (0.00 sec)

在其他情况下，可能有更多的候选人。例如，如果您搜索“combat ”,字典中会有一个词与您的查询完全匹配(Levenshtein 距离为 0 ),但您可能会搜索另一个词，并调用 SUGGEST 也会返回该词:

MySQL [(none)]> call qsuggest('combat', 'testrt');
+---------+----------+------+
| suggest | distance | docs |
+---------+----------+------+
| combat  | 0        | 1    |
| kombat  | 1        | 1    |
+---------+----------+------+
2 rows in set (0.00 sec)

如果您输入两个单词，请调用 QSUGGEST，仅处理最后一个单词:

MySQL [(none)]> call qsuggest('mortal combat', 'testrt');
+---------+----------+------+
| suggest | distance | docs |
+---------+----------+------+
| combat  | 0        | 1    |
| kombat  | 1        | 1    |
+---------+----------+------+
2 rows in set (0.00 sec)

那么，如何在我的应用程序中使用这一功能呢？“你可能会问。很简单。只是:

  • 在每个新字符后继续发送搜索查询来调用 QSUGGEST
  • 并将它的输出显示给用户

下面是它在我们的数据集的情况下给出的日志，注意输入(在“call qsuggest”之后)和输出(在“suggest”列中):

MySQL [(none)]> call qsuggest('m', 'testrt');
Empty set (0.00 sec)
MySQL [(none)]> call qsuggest('mo', 'testrt');
Empty set (0.00 sec)
MySQL [(none)]> call qsuggest('mor', 'testrt');
Empty set (0.00 sec)
MySQL [(none)]> call qsuggest('**mort**', 'testrt');
+---------+----------+------+
| suggest | distance | docs |
+---------+----------+------+
| **mortal**  | 2        | 1    |
+---------+----------+------+
1 row in set (0.01 sec)
MySQL [(none)]> call qsuggest('**morta**', 'testrt');
+---------+----------+------+
| suggest | distance | docs |
+---------+----------+------+
| **mortal**  | 1        | 1    |
+---------+----------+------+
1 row in set (0.00 sec)
MySQL [(none)]> call qsuggest('**mortal**', 'testrt');
+---------+----------+------+
| suggest | distance | docs |
+---------+----------+------+
| **mortal**  | 0        | 1    |
+---------+----------+------+
1 row in set (0.00 sec)
MySQL [(none)]> call qsuggest('**mortal c**', 'testrt');
Empty set (0.01 sec)
MySQL [(none)]> call qsuggest('**mortal co**', 'testrt');
Empty set (0.00 sec)
MySQL [(none)]> call qsuggest('**mortal com**', 'testrt');
Empty set (0.00 sec)
MySQL [(none)]> call qsuggest('**mortal comb**', 'testrt');
+---------+----------+------+
| suggest | distance | docs |
+---------+----------+------+
| **combat**  | 2        | 1    |
| **kombat**  | 3        | 1    |
+---------+----------+------+
2 rows in set (0.00 sec)
MySQL [(none)]> call qsuggest('**mortal comba**', 'testrt');
+---------+----------+------+
| suggest | distance | docs |
+---------+----------+------+
| **combat**  | 1        | 1    |
| **kombat**  | 2        | 1    |
+---------+----------+------+
2 rows in set (0.00 sec)
MySQL [(none)]> call qsuggest('**mortal combat**', 'testrt');
+---------+----------+------+
| suggest | distance | docs |
+---------+----------+------+
| **combat**  | 0        | 1    |
| **kombat**  | 1        | 1    |
+---------+----------+------+
2 rows in set (0.00 sec)

结论

  • 自动更正是许多系统中常用的一个非常好的功能，它可以帮助用户找到更好的结果，网站所有者也不会因为输入错误或查询不正确而失去用户
  • 有许多方法可以实现它
  • 谷歌、亚马逊、Pinterest、Etsy 和其他大网站的实现似乎相当复杂，并且基于一种非平凡的算法
  • 但是在很多情况下，一些简单得多的东西也是有意义的
  • 蝎狮搜索可用于提供所需的功能。顺便说一下，在他们的网站上有一个关于它的互动课程:

[## 你是说？

你是说？除了自动完成功能之外，我们在本课程中讨论了一个简单的例子…

play.manticoresearch.com](https://play.manticoresearch.com/didyoumean/)

通过 Git 将 FastAPI 应用程序自动部署到 Heroku，只需 5 个简单的步骤

原文：https://towardsdatascience.com/autodeploy-fastapi-app-to-heroku-via-git-in-these-5-easy-steps-8c7958ef5d41?source=collection_archive---------25-----------------------

在 5 分钟内将您的应用分享到互联网

苏珊·路易斯·佩尼克斯在 Unsplash 上的照片

如果不是用现有的 app，可以参考我的虹膜分类器 FastAPI App 进行参考。我写过一篇关于如何设置的文章(Docker 组件是可选的)。

注意:我很快地组装了 Iris 应用程序来演示如何设置 FastAPI——在提供模型预测时，它肯定不符合最佳实践

[## 使用 FastAPI 和 Docker 部署 Iris 分类

让我们用 Docker 部署一个 FastAPI 应用程序来对一些虹膜进行分类。

towardsdatascience.com](/deploying-iris-classifications-with-fastapi-and-docker-7c9b83fdec3a)

这是我的虹膜分类器应用程序的 GitHub repo。我们将在本教程中以此为例。确保您正在使用的 FastAPI 项目也被托管为 GitHub 存储库。

什么是 FastAPI？

FastAPI 是一个现代、快速(高性能)的 web 框架，用于基于标准 Python 类型提示用 Python 3.6+构建 API。

FastAPI 网站提供了有关 FastAPI 如何工作以及使用 FastAPI 的优势的更多详细信息。

什么是 Heroku？

Heroku 是一个平台即服务(PaaS ),支持开发者完全在云中构建、运行和操作应用。

我真的很喜欢使用 Heroku 来展示我的副业项目，因为它很容易设置，而且免费层通常足以满足大多数目的。

在本文中，我将使用 Heroku 将我的 FastAPI 应用程序部署到公共互联网，并将主分支与生产应用程序同步。每当我将更改推送到主分支时，它们都会在 web 应用程序上同步。

步骤 1:添加 Procfile

Procfile 指定了应用程序在启动时执行的命令。创建一个名为Procfile的新文件(没有扩展名，确保使用相同的大小写)。

这是虹膜分类器的过程文件:

web: uvicorn iris.app:app --host=0.0.0.0 --port=${PORT:-5000}

如果您使用自己的 FastAPI 项目，相应地更改路径iris.app:app。这是实例化的FastAPI()对象的路径。

下面是矿供参考。

[可选]步骤 2:下载 Heroku CLI

按照 Heroku 网站上的说明下载 CLI:

[## Heroku CLI

Heroku 命令行界面(CLI)使得直接从终端创建和管理您的 Heroku 应用程序变得非常容易…

devcenter.heroku.com](https://devcenter.heroku.com/articles/heroku-cli#download-and-install)

虽然我们在这里实际上根本没有使用 CLI，但是 CLI 使得通过终端管理应用程序变得很容易。

步骤 3:在 Heroku 上创建应用程序

前往https://www.heroku.com/创建一个账户。导航到仪表盘创建一个新应用。

我把我的应用程序命名为 irisclassifierfastapi 。这个名字决定了默认的 URL——这个项目将在www.irisclassifierfastapi.herokuapp.com 托管。可以在应用程序的Settings页面将自定义域名添加到应用程序中。

步骤 4:设置自动部署

导航到 deploy 选项卡，点击 GitHub logo，认证并授权 Heroku 从你的 GitHub 账户部署代码。

连接后，选择存储库以连接到应用程序。从那里，选择一个分支并点击启用自动部署。如果您正在使用 CI 工具，您可以选中复选框以确保 CI 在部署变更之前通过。

第 5 步:首次手动部署您的应用程序

下次将更改推送到主分支时，将会部署该应用程序。由于我们还没有部署我们的应用程序(到目前为止还没有进行任何更改)，我们可以通过滚动到部署选项卡的底部来触发手动部署。

如果您安装了 CLI，也可以通过命令行执行手动部署。

[## 命令行

heroku 命令行界面(CLI)是使用 Heroku 的重要部分。使用它来执行几乎任何…

devcenter.heroku.com](https://devcenter.heroku.com/categories/command-line)

部署更改大约需要一分钟。你可以在https://irisclassifierfastapi.herokuapp.com/docs上找到虹膜分类器的 Swagger UI

只要我的应用程序在运行，这个 CURL 请求就允许我从分类器中获取预测。

curl 'http://irisclassifierfastapi.herokuapp.com/iris/classify_iris' -X POST -H 'Content-Type: application/json' -d '{"sepal_l": 5, "sepal_w": 2, "petal_l": 3, "petal_w": 4}'

分类器预测这种鸢尾有 91%的概率是海滨鸢尾。

有用的后期制作工具

这里有一些工具，你可以利用它们来调试糟糕的部署，并从总体上监控你的应用。

日志

在应用页面中，点击更多，从下拉菜单中选择查看日志查看应用日志。每个日志都是应用程序中发生的事件。日志可用于提供信息(例如，您可以记录用户属性)、警告和错误。

您可以使用 Python logging 库来添加更多的日志，这将使调试您的应用程序变得更加容易。

反转

如果部署不当，您可能希望回滚您的更改。虽然您可以在 Git 中通过恢复到以前的提交来实现这一点，但 Heroku 也提供了通过 UI 实现这一点的选项。

导航到活动选项卡查看以前的版本，并单击回滚到此处恢复到以前的版本。

指标(不可用于免费计划)

指标不可用于空闲层。度量图表捕获与系统健康和性能相关的信息，例如内存使用和事件发生。

爱好层下我的一个应用的指标选项卡如下所示:

如果您有兴趣了解更多关于应用程序开发的知识，请查看本课程。

[## 应用部署、调试和性能

在本课程中，应用程序开发人员将学习如何设计和开发云原生应用程序，以便无缝地…

click.linksynergy.com](https://click.linksynergy.com/link?id=J2RDo*Rlzkk&offerid=759505.11680934640&type=2&murl=https%3A%2F%2Fwww.coursera.org%2Flearn%2Fapp-deployment-debugging-performance)

感谢您的阅读！

如果你喜欢这篇文章，可以考虑给我买杯咖啡——每一点小小的贡献都帮助我找到更多的时间在这个博客上工作。请通过 Medium 关注我的最新消息。😃

作为一个业余爱好项目，我还在www.dscrashcourse.com建立了一套全面的免费数据科学课程和练习题。

再次感谢您的阅读！📕

PyTorch 与 TensorFlow 的自动挖掘和动态子类模型

原文：https://towardsdatascience.com/autodiff-and-dynamic-subclassed-models-with-pytorch-vs-tensorflow-c5224a0a375c?source=collection_archive---------59-----------------------

比较 PyTorch 1.x 和 TensorFlow 2.x 之间的自动 Diff 和动态模型子分类方法，使用自定义动态模型类和手动训练循环/损失函数从零开始训练线性回归

来源:作者

这篇短文重点介绍如何在 PyTorch 1.x 和 TensorFlow 2.x 中分别使用带有模块/模型 API 的动态子类模型，以及这些框架如何在训练循环中使用 AutoDiff 来获得损失的梯度，并从头开始实现一个非常简单的梯度后代实现。

生成一些带有一点噪声的线性数据

为了专注于自动差异/自动梯度功能的核心，我们将使用最简单的模型，即线性回归模型，我们将首先使用 numpy 生成一些线性数据，添加随机水平的噪声。

来源:作者

模型

然后，我们将在 TF 和 PyTorch 中从头开始实现一个线性回归模型，不使用任何层或激活器，而是简单地定义两个张量 w 和 b ，分别表示我们的线性模型的权重和偏差，并简单地实现线性函数: y = wx + b

正如你在下面看到的，我们的模型的 TF 和 PyTorch 类定义基本上是完全相同的，只有在一些 api 名称上有很小的不同。

这里唯一值得注意的区别是 PyTorch 显式地使用了一个参数对象来定义图表要“捕获”的权重和偏差张量，而 TF 在这里似乎更“神奇”，自动捕获图表要使用的参数。

事实上，在 PyTorch 中，参数是张量子类，当与模块 api 一起使用时，具有非常特殊的属性，可以自动将自身添加到模块参数列表中，并且会出现在例如 Parameters()迭代器中。

无论如何，这两个框架都能够从这个类定义和执行方法( call 或 forward )、参数和图形定义中提取，以便向前运行图形执行，并且正如我们稍后将看到的，通过自动微分功能获得梯度，以便还能够执行反向传播。

张量流动态模型

PyTorch 动态模型

训练循环、反向传播和优化器

现在，我们已经实现了简单的 TensorFlow 和 PyTorch 模型，我们可以使用 TF 和 PyTorch api 定义实现均方误差的损失函数，最后实例化我们的模型类，并运行一系列时期的训练循环。

同样，为了专注于自动区分/自动分级功能的核心，我们将使用 TF 和 PyTorch 特定的自动区分实现来实现一个定制的训练循环，以便为我们的简单线性函数提供梯度，并使用一个特别的简单梯度下降优化器来手动优化权重和偏差参数。

在 TensorFlow 训练循环中，我们将特别明确地使用 GradientTape API 来记录我们模型的正向执行和损失计算，然后我们将从该 GradientTape 获得梯度，以用于优化我们的权重和偏差参数。

PyTorch 在这种情况下提供了一种更“神奇”的自动梯度方法，隐式捕获参数张量上的任何操作，并为我们提供相同的梯度来优化我们的权重和偏差参数，而不使用任何特定的 api。

一旦我们有了权重和偏差梯度，那么在 PyTorch 和 TensorFlow 上实现我们的自定义梯度下降方法就像减去权重和偏差参数一样简单，这些梯度乘以一个恒定的学习速率。

这里唯一的微小差别是，当我们在反向传播中更新权重和偏差参数时，PyTorch 以一种更隐式和“神奇”的方式实现自动区分/自动嫁接，我们需要确保不要继续让 PyTorch 从这最后一次更新操作中提取 grad，这次显式调用 no_grad api，并最终将我们的权重和偏差参数的梯度归零。

张量流训练回路

PyTorch 训练循环

结论

正如我们所看到的，TensorFlow 和 PyTorch 自动微分和动态子类 API 非常相似，当然这两个模型的训练给了我们非常相似的结果。

在下面的代码片段中，我们将分别使用 Tensorflow 和 py torchtrainible _ variables和 parameters 方法来访问模型参数，并绘制我们学习的线性函数的图形。

标绘结果

来源:作者

源代码

[## 雅格布曼吉亚瓦奇/TF VS . py torch

比较 PyTorch 和 TensorFlow 2.x 之间的自动 Diff 动态模型方法从零开始训练线性…

github.com](https://github.com/JacopoMangiavacchi/TF-VS-PyTorch)

在 Fastai 库中实现自动编码器

原文：https://towardsdatascience.com/autoencoders-in-the-fastai-library-fa288e1f899a?source=collection_archive---------68-----------------------

在 fastai 中实现自动编码器的分步指南。

自动编码器架构。使用 NN-SVG 制作的图像。

介绍

fastai 是一个深度学习库，它使用现代最佳实践来简化训练神经网络[1]。虽然 fastai 为用户提供了一个高级别的神经网络 API，但它旨在允许研究人员和用户轻松混合低级别的方法，同时仍然使整个训练过程变得简单易行。

这篇文章将讲述如何在 fastai 中设置一个自动编码器。这将通过创建一个基本的 autoencoder 模型，在 fastai 中设置数据，最后将所有这些放到一个学习者模型中。

注意:假设对 fastai 和 PyTorch 有基本的了解。

履行

设置数据

自动编码器是一种神经网络，它通过架构中的某种瓶颈来学习重新创建输入。为此，我们需要一个输入和输出相等的 fastai 数据束。

在这里，我将给出一个使用图像数据实现这一点的示例，但是，还有一个更通用的示例，可以使用相应笔记本电脑上的任何可用阵列在这里。

导入数据集的代码如下:

from fastai import *
from fastai.vision import *size = 32
batchsize = 32
tfms = get_transforms(do_flip = True)
src = (ImageImageList.from_folder(image_path).label_from_func(lambda x: x))
data = (src.transform(tfms, size=size, tfm_y=True)
 .databunch(bs=batchsize)
 .normalize(imagenet_stats, do_y = False))

这与为分类器设置数据分组的两个区别是:

ImageImageList()

ImageImageList是一个内置的 fastai 列表，它将输入和输出数据都设置为图像。使用这种方法，我们仍然可以像使用show_batch一样使用内置的 fastai 函数。

第二个区别是标签的设置方式:

label_from_func(lambda x: x)

这允许用户从定义的功能中设置标签。这里我们使用一个输出输入的函数。

现在有了这些，我们可以运行:

data

哪些输出:

ImageDataBunch;Train: LabelList (4800 items)
x: ImageImageList
Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32)
y: ImageList
Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32)
Path: autoencoders-in-fastai/data;Valid: LabelList (1200 items)
x: ImageImageList
Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32)
y: ImageList
Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32),Image (3, 32, 32)
Path: autoencoders-in-fastai/data;Test: None

运行 show_batch 给出:

data.show_batch(rows = 1)

data.show_batch(rows = 1) 输出。从 CIFAR10 数据集中获取的图像。

创建模型

我们现在需要创建一个自动编码器模型。这是通过创建 PyTorch 模块来实现的。下面是从这里截取的一个基本例子。

from torch import nnclass Autoencoder(nn.Module):
    def __init__(self):
        super(Autoencoder, self).__init__()
        # Input size: [batch, 3, 32, 32]
        # Output size: [batch, 3, 32, 32]
        self.encoder = nn.Sequential(
            nn.Conv2d(3,12,4,stride=2,padding=1),
            nn.ReLU(),
            nn.Conv2d(12,24,4,stride=2,padding=1),
            nn.ReLU(),
            nn.Conv2d(24,48,4,stride=2,padding=1),
            nn.ReLU(),
            )
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(48,24,4,stride=2,padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(24,12,4,stride=2,padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(12,3,4,stride=2,padding=1),
            nn.Sigmoid(),
            ) def encode(self, x): return self.encoder(x) def decode(self, x): return self.decoder(x) def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded

创造快速学习者

现在我们把所有这些放入一个快速学习器中。为此，你需要定义一个损失函数，在这个例子中，我将使用 MSE 损失。

为了实现这一点，我们首先创建一个 autoencoder 实例，如下所示:

autoencoder = Autoencoder()

然后我们把这个放入一个快速学习者中:

import torch.nn.functional as Flearn = Learner(data, autoencoder, loss_func = F.mse_loss)

现在我们已经做到了这一点，我们可以轻松地利用 fastai 中包含的所有最佳培训实践，如lr_find和fit_one_cycle。

培养

fastai 中实现的所有技术现在都可以在您的自定义 autoencoder 上使用。

learn.lr_find()
learn.fit_one_cycle()

示例结果

使用 fastai 库，我在 CIFAR10 的一个子集上训练了 10 个历元，使用lr_find找到了一个最佳学习率和fit_one_cycle，并取得了以下结果:

使用 fastai 文库的 10 个时期的结果。

结论

在这里，我简单介绍了如何在 fastai 中实现自动编码器，您可以在这里找到笔记本和，其中包括所有代码以及如何为通用数组数据集实现它。一旦自动编码器经过训练，还有关于如何使用编码器和解码器部件的信息。

我在这里展示的 autoencoder 模型是一个非常简单的模型，有许多改进可以提及的是特征丢失、上采样而不是转置卷积以及最后的像素混洗。我发现这些在我自己的工作中非常有效。

参考

[1]杰瑞米·霍华德和西尔万·古格。_fastai:深度学习的分层 API。arXiv。https://arxiv.org/abs/2002.04688。2020.

自动编码器:研究和应用综述

原文：https://towardsdatascience.com/autoencoders-overview-of-research-and-applications-86135f7c0d35?source=collection_archive---------16-----------------------

自从机器学习的早期以来，人们一直试图以无监督的方式学习数据的良好表示。这项工作的基本假设是，解开表征很好地转化为下游监督任务。例如，如果一个人被告知特斯拉是一辆汽车，并且他对汽车的外观有很好的描述，他可能会在房屋照片中认出特斯拉的照片，而从未见过特斯拉。

大多数早期的表示学习思想都围绕着线性模型，如因子分析、主成分分析(PCA)或稀疏编码。由于这些方法是线性的，它们可能无法找到复杂数据的清晰表示，如图像或文本。特别是在图像的情况下，简单的变换，例如照明的改变，可能与像素强度有非常复杂的关系。因此，需要深度非线性编码器和解码器，将数据转换成其隐藏的(希望是解开的)表示，然后再转换回来。

自动编码器是神经网络模型，旨在学习数据点之间复杂的非线性关系。通常，自动编码器由多个神经网络层组成，并被训练在输出端重建输入(因此得名自动编码器)。在这篇文章中，我将尝试给出一个多年来开发的各种类型的自动编码器及其应用的概述。

自动编码器做什么

一般来说，使用自动编码器的假设是，如果我们正确地考虑数据点的几何形状，高度复杂的输入数据可以更简洁地描述。例如，考虑图 1 所示的所谓“瑞士滚”流形。虽然数据最初位于 3-D 空间中，但是可以通过“展开”该卷并将其展开在地板上(2-D)来更简单地描述它。注意，瑞士卷的线性变换不能展开流形。然而，自动编码器能够学习(可能非常复杂的)非线性变换函数。

图 1:展开瑞士卷流形。来源:Olivier Grisel——使用模块化数据处理工具包和 matplotlib 生成。，CC 乘 3.0，https://commons.wikimedia.org/w/index.php?curid=10661091

欠完整自动编码器

让自动编码器学习输入的低维表示的一个简单方法是约束隐藏层中的节点数量。由于自动编码器现在必须使用有限数量的节点来重建输入，它将尝试学习输入的最重要方面，并忽略数据中的细微变化(即噪声)。

为了实现欠完整自动编码器，至少需要一个隐藏的全连接层。如今，大多数自动编码器架构实际上采用多个隐藏层，以便使架构更深入。从经验上来说，更深层次的架构能够学习更好的表示并实现更好的概括。编码器和解码器中的层数和大小也是惯例，使架构对称。

欠完整自动编码器不一定需要使用任何显式正则化项，因为网络架构已经提供了这种正则化。然而，我们仍然应该小心模型的实际容量，以防止它只是简单地记忆输入数据。一个正则化选项是通过简单地使用解码器中相应层的编码器权重矩阵的转置，将编码器和解码器的参数绑定在一起。

图 2:欠完整自动编码器的概念视图

欠完整自动编码器的应用包括压缩、推荐系统以及异常值检测。异常值检测通过检查自动编码器的重构误差来工作:如果自动编码器能够很好地重构测试输入，则它很可能来自与训练数据相同的分布。然而，如果重建不好，数据点很可能是异常值，因为自动编码器没有学会正确地重建它。

卷积自动编码器

由于卷积神经网络(CNN)在许多计算机视觉任务中表现良好，因此自然会考虑将卷积层用于图像自动编码器。通常，在卷积自动编码器中，池层与卷积层一起使用，以减小隐藏表示层的大小。在编码器中，隐藏层之前通常是全连接层，并且在解码步骤之前，它被重新整形为适当的大小。由于卷积自动编码器的输出必须与输入大小相同，我们必须调整隐藏层的大小。原则上，我们可以通过两种方式做到这一点:

  • 在每个卷积层之前对隐藏层进行上采样，例如使用双线性插值，或者
  • 使用专门的转置卷积层来执行可训练形式的上采样。

第二种选择更有原则，通常提供更好的结果，但是它也增加了网络的参数数量，并且可能不适用于所有类型的问题，尤其是在没有足够的可用训练数据的情况下。

卷积自动编码器常用于图像压缩和降噪。在去噪的情况下，网络被称为去噪自动编码器，它被训练成不同于标准自动编码器:不是试图在输出中重建输入，而是输入被适当的噪声信号(例如高斯噪声)破坏，并且自动编码器试图预测去噪的输出。

卷积自动编码器也可以用于图像搜索应用，因为隐藏的表示通常带有语义。因此，对隐藏表示的相似性搜索比对原始图像像素的相似性搜索产生更好的结果。它的速度也明显更快，因为隐藏表示通常要小得多。

稀疏自动编码器

正如我已经提到的，欠完整自动编码器通过与输入和输出相比压缩隐藏层的大小来使用隐式正则化。稀疏自动编码器现在为隐藏层引入了一个显式正则化项。因此，取消了隐藏层必须小于输入的限制，我们甚至可以考虑隐藏层大小大于输入的过完备自动编码器，但在某些其他意义上是最佳的。

例如，我们可以在隐藏层上引入 L1 惩罚，以获得数据分布的稀疏分布表示。这将迫使自动编码器仅选择隐藏层中的几个节点来表示输入数据。注意，这种惩罚与通常在训练期间对神经网络的权重引入的 L2 或 L1 惩罚有质的不同。在这种情况下，我们限制隐藏层的值，而不是权重。与重量衰减相反，这一过程并不完全是理论上的，没有明确的潜在概率描述。然而，这是一个直观的想法，在实践中效果很好。

我们可以使用的另一个惩罚是 KL 散度。在这种情况下，我们引入了稀疏度参数ρ(通常为 0.005 或另一个非常小的值)，该参数将表示样本集合上神经元的平均激活。在我们的例子中，ρ将被假定为描述平均激活的伯努利分布的参数。我们还会计算ρ_hat，训练时所有例子的真实平均激活量。两个伯努利分布之间的 KL 散度由下式给出:

，其中 s₂是隐藏层中神经元的数量。这是一个可微的函数，可以作为惩罚加到损失函数中。

收缩自动编码器

正则化自动编码器的一个有趣的方法是假设对于非常相似的输入，输出也将是相似的。我们可以通过要求隐藏层激活的导数相对于输入较小来加强这一假设。这将确保输入的小变化将被映射到隐藏层中的小变化。收缩自动编码器这个名字来源于这样一个事实，即我们正试图将一小簇输入压缩成一小簇隐藏表示。

具体来说，我们在损失函数中包括一项，该项惩罚隐藏激活的雅可比矩阵的弗罗贝纽斯范数(矩阵 L2 范数)。

因此， h_j 表示隐藏激活， x_i 表示输入，| | | * | _ F表示弗罗贝纽斯范数。

变分自动编码器

变分自动编码器和其他类型的自动编码器之间的关键区别在于 VAEs 将隐藏表示视为具有其自身先验分布的潜在变量。这给了他们一个恰当的贝叶斯解释。变分自动编码器是具有适当定义的先验和后验数据分布的生成模型。

更具体地，变分自动编码器将输入数据和潜在表示的联合概率建模为 p(x，z) = p(x|z) p(z)。生成过程通过从 p(z) 中提取一个潜在变量并将其传递给由 p(x|z) 给出的解码器来定义。与其他自动编码器类型一样，解码器是一个学习参数函数。

为了找到输入(编码器)的最佳隐藏表示，我们必须根据贝叶斯定理计算 p(z|x) = p(x|z) p(z) / p(x) 。直接应用这个公式的问题是分母要求我们忽略潜在变量。换句话说，我们必须计算所有可能的潜在变量构型的积分。这通常很棘手。相反，我们转向变分推理。

在变分推断中，我们使用真后验 p(z|x) 的一个近似 q(z|x) 。q(z|x) 被明确地设计成易处理的。在我们的例子中， q 将由自动编码器的编码器功能建模。为了训练变分自动编码器，我们希望最大化以下损失函数:

我们可以将第一项识别为具有从先前(编码器)抽取的 n 个样本的解码器的最大似然。第二项对于变分自动编码器来说是新的:它试图使用 KL 散度作为度量，将变分后验 q 逼近真实先验 p 。此外， q 被选择为使得它在 m 训练样本上分解，这使得使用随机梯度下降进行训练成为可能。虽然这可以直观地理解，但你也可以严格地推导出这个损失函数。如果你熟悉贝叶斯推断，你也可能认识到损失函数是最大化证据下界(ELBO)。

我们通常选择简单分布作为先验 p(z) 。在许多情况下，对于所有隐藏单元，它只是均值为 0、方差为 1 的单变量高斯分布，从而导致 KL 散度的一种特别简单的形式(请查看此处的以获得准确的公式)。 q 通常也选择为单变量或多变量的高斯分布。

现在剩下唯一要讨论的是如何训练变分自动编码器，因为损失函数涉及从 q 采样。采样操作是不可微的。幸运的是，我们试图从中取样的分布是连续的。这允许我们使用一个技巧:我们让编码器生成分布的参数，而不是通过采样过程反向传播(在高斯分布的情况下，只是平均值μ和方差σ)。然后，我们从单位高斯ε中生成一个样本，并使用生成的参数对其进行重新缩放:

因为我们不需要计算梯度 w.r.t ε，并且所有其他导数都是明确定义的，所以我们完成了。这就是所谓的重新参数化技巧。请注意，重新参数化技巧适用于许多连续分布，而不仅仅是高斯分布。然而不幸的是，它对离散分布不起作用，比如伯努利分布。

在训练之后，我们有两个选择:(I)忘记编码器，只有使用潜在表示，通过采样并通过训练的解码器运行样本，从数据分布产生新的样本，或者(ii) 通过编码器、采样级以及解码器运行输入样本。如果我们选择第一个选项，我们将从潜在空间先验得到无条件样本。对于第二个选项，我们将得到以输入为条件的后验样本。

这已经激发了 VAEs 的主要应用:生成与训练数据相似的新图像或声音。当生成图像时，通常使用卷积编码器和解码器以及密集潜在向量表示。多年来出现了多种不同版本的变分自动编码器，包括旨在生成特别清晰的表示的 Beta-VAEs，克服不能使用离散分布的限制的 VQ-VAEs，以及根据某个标签(如有胡子或眼镜的脸)生成输出的条件 VAEs。请参见图 3，这是最近一个变化的自动编码器实例的输出示例。

图 3:在 CSVAE 中操作面部毛发和眼镜隐藏属性，这是一个最新的自动编码器版本。资料来源:克里斯、杰克、杰克·斯内尔和理查德·泽梅尔。"在变分自动编码器中学习潜在子空间."神经信息处理系统的进展。2018.

虽然变分自动编码器最近由于其他生成模型(如 GANs)的兴起而失宠，但它们仍然保留了一些优点，如先验分布的显式形式。

结论

自动编码器形成了一组非常有趣的神经网络结构，在计算机视觉、自然语言处理和其他领域有许多应用。虽然现在当然有其他类别的模型用于表示学习，如暹罗网络等，但对于各种问题，自动编码器仍然是一个很好的选择，我仍然希望在不久的将来这个领域会有很多改进。

自动编码生成对抗网络

原文：https://towardsdatascience.com/autoencoding-generative-adversarial-networks-16082512b583?source=collection_archive---------12-----------------------

AEGAN 架构如何稳定 GAN 训练并防止模式崩溃

双向街道 AEGAN(图片来源: Pixabay

甘很难训练。当他们工作时，他们创造奇迹，但是任何试图训练他们自己的人都知道他们是该死的挑剔的混蛋。GAN 训练中最常见的两个问题是模式崩溃和缺乏收敛。在模式崩溃中，生成器学习只生成少量样本；在生成“手写”数字的过程中，经历模式崩溃的 GAN 可能只能学会画 7，尽管这是高度真实的 7。由于缺乏收敛性，发生器和鉴别器之间的良性竞争恶化，通常鉴别器变得比发生器好得多；当鉴别器能够容易且完全地区分真实样本和生成样本时，生成器不会得到有用的反馈，也无法改进。

在最近的一篇论文中，我提出了一种技术，似乎可以稳定 GAN 的训练并解决上述两个问题。这种技术的副作用是它允许在真实样本之间进行有效和直接的插值。在这篇文章中，我的目标是逐步介绍本文的主要观点，并说明为什么我认为 AEGAN 技术有可能成为 GAN 培训师工具箱中非常有用的工具。

有人告诉我不要再埋 led 了，所以这是这篇论文最有趣的结果。这是怎么回事？请继续阅读，寻找答案。

进入艾根

双射映射

GANs 学习从某个潜在空间 Z (随机噪声)到某个样本空间 X (数据集，通常是图像)的映射。这些映射自然是内射的——ZZ中的每个点 z 对应于 X 中的某个样本 x 。然而，它们很少满射——X 中的许多样本在 z 中没有对应的点。实际上，当许多点 zi 、 zj 和 zk 映射到单个样本 xi 时，模式崩溃就发生了，GAN 无法生成点 xj 或 xk 。考虑到这一点，更理想的 GAN 应该具有以下品质:

  1. Z 中的每个潜在点 z 应该对应于 X. 中的一个唯一样本 x
  2. X 中的每个样本 x 应该对应于 Z 中的一个唯一潜在点 z 。
  3. 从 Z、 p(Z=z) 中抽取 z 的概率，应该等于从 X 、 p(X=x) 中抽取 x 的概率。

这三个性质表明，我们应该以潜在空间和样本空间之间的一对一关系(即双射映射)为目标。为此，我们训练一个函数 G : Z ⟶ X ，这是我们的生成器，另一个函数 E : X ⟶ Z ，我们称之为编码器。这些功能的目的是:

  • G(z) 应产生与分布在 X 中的比例相同的真实样本。(这是普通 GANs 的目标)
  • E(x) 应该产生与它们在 z 上分布的比例相同的可能潜在点。
  • 构图 E(G(z)) 应忠实再现原潜点 z 。
  • 构图 G(E(x)) 要忠实再现原图像 x 。

体系结构

图 1:高级 AEGAN 架构。网络用方框表示，价值用圆圈表示，损失用菱形表示。颜色代表组合网络，其中红色是常规图像生成 GAN，黄色是用于产生潜在向量的 GAN，蓝色是图像自动编码器，绿色是潜在向量自动编码器。

AEGAN 是一个四网络模型，由两个 GAN 和两个自动编码器组成，如图 1 所示，它是用于不成对图像到图像转换的 CycleGAN 技术的推广，其中一个图像域用随机噪声代替。简而言之，我们训练两个网络在样本空间 X 和潜在空间 Z 之间进行翻译，我们训练另外两个网络来区分真假样本和潜在向量。图 1 是一个复杂的图表，所以让我来分解它:

网络(方块):

  • G 是发电机网络。它将一个潜在向量 z 作为输入，并返回一个图像 x 作为输出。
  • E 是编码器网络。它将图像 x 作为输入，并返回潜在向量 z 作为输出。
  • Dx 是图像鉴别器网络。它将图像 x 作为输入，并将从原始数据集中提取的 x 的概率作为输出返回。
  • Dz 是潜在鉴别器网络。它取一个潜在向量 z 作为输入，并返回从潜在分布中抽取 z 的概率作为输出。

数值(圆圈):

  • x :来自原始数据集的真实样本。这有点不明确，因为在某些地方我用 x 来表示域 x 中的任何值。抱歉。
  • z :来自潜在生成分布(随机噪声)的真实样本。
  • x _ hat:G 给定一个实随机向量产生的样本，即 x_hat=G(z)。
  • z_hat :给定一个真实样本，E 产生的向量，即 z_hat=E(x)。
  • x_tilde :由 G 从 E 产生的编码中重现的样本，即 x_tilde=G(z_hat)=G(E(x))。
  • z_tilde :由 E 从 G 生成的图像中重现的向量，即 z_tilde=E(z_hat)=E(G(z))。

损失(钻石):

  • L1(蓝色):图像重建损失 ||G(E(x))-x||_1 ，即原始图像像素与自动编码重建像素之间的曼哈顿距离。
  • L2(绿色):潜在向量重建损失 ||E(G(z))-z||_2 ，即原始潜在向量和自动编码重建之间的欧几里德距离。
  • 甘(红):图像的对抗性丧失。 Dx 被训练来区分真实图像( x )和虚假图像( x_hat 和 x_tilde (未显示))
  • 甘(黄色):潜在载体的对抗性损失。 Dz 被训练来区分真实随机噪声( z )和编码( z_hat 和 z_tilde (未显示))

培养

AEGAN 的训练方式与 GAN 相同，交替更新发电机( G 和 E )和鉴别器( Dx 和 Dz )。然而，AEGAN 损耗函数比典型的 GAN 损耗稍微复杂一些。它由四个对立的部分组成:

艾根损失的对抗成分。

和两个重建分量(这里显示为加在一起):

艾根损失的重建部分。λs 是控制重建分量的相对权重的超参数。

这些加在一起就形成了艾根损失。 E 和 G 尽量减少这种损失，而 Dx 和 Dz 尽量增加这种损失。如果你不关心数学，直觉很简单:

  1. G 试图欺骗 Dx 相信生成的样本 x_hat 和自动编码的样本 x_tilde 是真实的，而 Dx 试图将它们与真实样本 x 区分开来。
  2. E 试图欺骗 Dz 相信生成的样本 z_hat 和自动编码的样本 z_tilde 是真实的，而 Dz 试图将它们与真实样本 z 区分开来。
  3. G 和 E 必须一起工作，以便自动编码的样本 G(E(x))=x_tilde 与原始的 x 相似，并且自动编码的样本 E(G(z))=z_tilde 与原始的 z 相似。

结果

首先，免责声明。由于个人原因，我只有时间和精力在单个数据集上进行测试。我按原样发布我的工作，以便其他人可以自己测试这项技术，验证我的结果，或者表明这是一个死胡同。也就是说，以下是 30 万步训练后的结果样本:

图 AEGAN 在 21552 张独特动漫人脸的数据集上经过 30 万步训练后生成的随机图像。

图 2 本身并不那么令人兴奋。如果你正在读一篇关于 GANs 的中型文章，那么你可能已经看到了在动画人脸上训练的风格 GANs 产生了更好的结果。令人兴奋的是将上述结果与图 3 进行比较:

图 3:GAN 在 21552 张独特动漫人脸的数据集上经过 30 万步训练后生成的随机图像。

用于生成图 3 中图像的 GAN 和用于生成图 2 中图像的 AEGAN 对于 G 和 Dx 具有完全相同的架构；唯一的区别是，AEGAN 也学习相反的功能。这稳定了训练过程。在你问之前，不，这不是一次性的侥幸；我对 GAN 和 AEGAN 重复了五次训练，在每种情况下，AEGAN 产生了良好的结果，GAN 产生了垃圾。

AEGAN 技术的一个令人兴奋的副作用是它允许在真实样本之间进行直接插值。众所周知，GANs 能够在样本之间进行插值；画两个随机向量 z1 和 z2 ，在向量之间进行插值，然后将插值结果反馈给发电机和吊臂！借助 AEGAN，我们可以在真实样本之间进行插值:

图 4:真实样本之间的插值。最左边和最右边的列是真实样本，而中间的图像是这些样本之间的插值。最下面一行显示了一个样本和水平镜像的同一样本之间的插值，给人一种角色正在转头的错觉。

因为编码器 E 能够将样本 x 映射到其在潜在空间中的对应点 z ，所以 AEGAN 允许我们为任何样本 x1 和 x2 找到点 z1 和 z2 并在它们之间进行插值，就像对典型 GAN 一样。图 5 显示了来自数据集的 50 个随机样本的重建:

图 5:排列在五列中的真实样本对(每对中的左边)及其重建(每对中的右边)。在这个意义上，AEGAN 的功能类似于自动编码器，但没有标志性的模糊。请注意，重建的眼睛颜色都是各种深浅不同的绿色，这是一种轻微的模式崩溃。

讨论

首先，我想指出这个实验的缺点。正如我所说的，这只是在一个数据集上测试的。各个网络 G 、 E 、 Dx 和 Dz 的结构也没有被广泛探索，也没有进行有意义的超调(关于层数或形状、λs 等。).网络本身相当简单；一个更彻底和公平的实验是将 AEGAN 技术作为包装器应用于更复杂数据集上的更强大的 GAN，如 CelebA 。

也就是说，AEGAN 具有许多令人满意的理论特性，这使得它适合于进一步的探索。

  • 强制 AEGAN 保留生成图像中潜在向量的信息，可以防止模式崩溃。这也允许我们避免像批量标准化和批量区分这样的批量独立性破坏技术。顺便说一下，由于 TF.keras 2.0 中的实现问题，我不得不在这个实验中避免批处理规范化，但那是另外一个故事了…
  • 学习双射函数允许在真实样本之间直接插值，而不依赖于辅助网络或可逆层。它还可以允许更好地探索和操纵潜在空间，可能通过试验不同的分布，就像在敌对自动编码器中所做的那样。
  • 将发生器直接暴露在真实样本下，可以减少它在像素空间的深渊中跋涉的时间。

对于最后一点，常规 GANs 的生成器从不直接接触训练数据，只通过鉴别器的反馈间接了解数据的样子(因此有了“blind forgers”)的绰号。通过包括重建损失，生成器可以在高维像素空间中直线朝向低维流形。考虑图 6，它显示了 AEGAN 仅经过 200 步训练后的输出:

图 6:200 个训练步骤(不是 200 个时期)后的 AEGAN 输出。人脸清晰可见，头发和眼睛的颜色、表情和姿势也各不相同。

将其与图 7 进行比较，图 7 显示了一个与 AEGAN 具有相同架构的常规 GAN 在其训练中的相同点:

图 7:200 个训练步骤(不是 200 个历元)后的 GAN 输出。因为你已经知道这些是脸，你可以看到头发，皮肤和眼睛，但有大量的模式崩溃和图像质量非常低。

正如你所看到的，AEGAN 在寻找低维流形方面特别有效，尽管测量它适应该流形的能力需要进一步的实验。

进一步的工作

  • 将 AEGAN 应用于 StyleGAN 等最先进的技术，看看它是否能提高质量和/或收敛速度。
  • 探索λ超参数以找到最佳值；探索课程方法，如随时间逐渐降低λs。
  • 将条件应用到培训中；探索伯努利和多伯努利潜在组件，就像在敌对自动编码器中所做的那样。
  • 将 AEGAN 应用于具有已知基础流形的设计图像数据集，以测量该技术能够多有效地再现它。
  • 找到一种方法来匹配潜在空间的维度和数据生成函数的流形的维度(说起来容易做起来难！)

正误表

如果我没有在某个地方提到变量自动编码器/ GANs ，这是一个有趣的相关技术，所以在这里。用于训练这些模型的数据可在 Kaggle 上获得。你可以在这里查看原论文。我的这个网络的 tf.keras 实现可以从下面的 github repo 获得:

[## ConorLazarou/AEGAN-keras

自动编码生成对抗网络(AEGAN)技术的 Keras 实现。

github.com](https://github.com/ConorLazarou/AEGAN-keras)

AutoGluon vs . XG boost—AutoML 会取代数据科学家吗？

原文：https://towardsdatascience.com/autogluon-vs-xgboost-will-automl-replace-data-scientists-dc1220010102?source=collection_archive---------8-----------------------

使用亚马逊的自动增长来预测贷款违约

照片由法比奥在 Unsplash 上拍摄

背景

2020 年 1 月 9 日，亚马逊推出了 AutoGluon，这是一个开源库，使开发者能够轻松构建自动机器学习(AutoML)模型。近年来，AutoML 已经成为机器学习领域的一个热门话题。许多高科技公司都推出了他们的 AutoML 工具包，包括微软、谷歌和脸书。它允许数据科学家通过将 ML 部署到 ML 本身来自动化 ML 任务，并且具有高准确性、部署简单性和时间效率的优点。AutoML 也非常通用，因为它可以处理许多数据任务，如图像分类、语言处理和表格预测。据 Gartner 称，预计到 2020 年，超过 40%的数据科学任务将实现自动化。

亚马逊对 AutoGluon 有着独特的眼光和很高的期望。正如亚马逊所说，它的目的是“让机器学习民主化，让深度学习的力量为所有开发者所用。”AutoGluon 的多个功能已经证明，亚马逊确实在“民主化”机器学习的艰巨任务，并使任何人都有可能学习:

  • AutoGluon 可以轻松训练和部署高精度模型。
  • 它只需要几行代码。
  • 可以针对特定的使用情形对自动增长进行定制。
  • 该库利用自动超参数调整、模型选择、架构搜索和数据处理。

这个列表中的最后一个特性值得特别关注，因为它预示着数据科学的未来将在很大程度上实现自动化，并且不需要手动构建和调整模型。一些数据科学专家开始担心他们是否会在不久的将来被 AutoML 取代，这是合理的。

在本文中，我的同事张一阳和我将测试自旋转的潜力，并将其性能与其他流行的 ML 方法进行比较。我们的基准将是经典的随机森林，以及 XGBoost(极端梯度提升)，这也是监督学习的一种流行技术。它具有优化的计算资源分配，这有助于其快速的执行速度和极高的准确性。XGBoost 被认为是 Kaggle 数据竞赛中获胜者的首选算法。

比较模型性能的主要任务是贷款违约预测，它涉及预测具有给定特征的人是否会拖欠银行贷款。长期以来，这项任务一直是最受欢迎的数据科学主题之一。

照片由佩皮·斯托扬诺夫斯基在 Unsplash 拍摄

数据准备

我们的表格数据集是从 Kaggle 网站上获得的。它由 30，000 个目前负债的个人及其基本信息组成，包括身份证、性别、教育、婚姻、年龄和给予的信贷。该数据集还包含连续 6 个月的还款状态、账单金额和以前的付款金额，以及下个月的默认指标。原始数据集已经非常干净了。我们对分类变量进行了虚拟编码(这是运行 XGBoost 所必需的)，即，将分类变量转换为一系列只有 0 和 1 级别的二分变量。

随机森林

我们的团队决定使用随机森林作为第一个基准。这是一种用于分类的集成学习方法。该模型随机采样训练数据，并创建特征子集，以构建数百或数千棵决策树，然后将所有树聚合在一起。随机森林因其高精度而成为最流行的 ML 方法之一。

在我们的测试中，我们将树的数量设置为 100，并将标准设置为“gini ”,它代表 gini 杂质:

# Random Forest
rm = RandomForestClassifier(
                             random_state=123,
                             criterion='gini',
                             n_estimators=100,
                             verbose=False)rm.fit(X_train,y_train)

混淆矩阵和特征重要性总结如下。我们使用随机森林取得了 81.77%的准确率。

XGBoost

XGBoost 是随机森林的继承者，被认为是基于决策树的集成 ML 算法皇冠上的明珠。它最初是由陈天琦和卡洛斯·格斯特林于 2016 年在华盛顿大学开发的，并在数据科学行业迅速获得了巨大的人气。XGBoost 通过系统优化和算法增强改进了梯度推进机器。

在数据科学家 Vishal Morde 完成的一项测试中，XGBoost 的性能在准确性和计算效率方面明显优于传统算法。结果如下图所示:

由于 XGBoost 在处理表格数据的预测问题时具有出色的性能，我们相信在这种情况下它可以成为自动增长的有力竞争者。我们运行 XGBoost 来构建贷款违约预测模型:

# XGBoost ClassifierX_train, X_test, y_train, y_test= train_test_split(X,y, test_size=0.2, random_state=123)model = xgb.XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,colsample_bynode=1, colsample_bytree=1, gamma=0,learning_rate=0.3, max_delta_step=0, max_depth=3,min_child_weight=1, missing=None, n_estimators=10, n_jobs=1,nthread=None, objective='binary:logistic', random_state=0,reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=123,verbosity=1)model.fit(X_train,y_train)
preds = model.predict(X_test)

XGBoost 帮助我们达到了 82.00%的准确率。下图显示了混淆矩阵和特征重要性。

自动增长

如前所述，Amazon 声称 AutoGluon 在涉及图像、文本和表格数据的各种数据任务中表现出色。在我们的研究中，我们专注于用表格数据进行预测。与 random forest 和 XGBoost 不同，AutoGluon 负责模型选择和超参数调整。第一步是使用 ML 来确定适合给定任务的几个模型。模型确定后，AutoGluon 再次利用 ML 优化每个模型的超参数。例如，如果 AutoGluon“认为”随机森林是该任务的良好模型，那么它将决定森林中决策树的数量，以及在拆分节点时考虑的功能数量。以下是我们的自动增长代码:

# AutoGluon Classifierpredictor = task.fit(train_data=train_data, label=label_column, output_directory=dir)y_pred = predictor.predict(test_data_nolab)

在我们的测试中，自动旋翼利用了以下模型。每个模型的性能和相应的计算时间总结在以下两个图表中:

自动旋转的最终准确率为 82.96%，这是一个振奋人心的数字。我们还为模型创建了混淆矩阵。请注意，可以通过配置模型进一步提高精度，这需要更先进的硬件。

但是，与前两种模型相比，计算时间要长得多。同样值得一提的是，当我们执行该命令时，我们不断收到以下警告:

Warning: Model is expected to require 25.288658239618677 percent of available memory...

我们运行代码的计算机在内存和 CPU 方面的计算能力都高于平均水平。似乎自动旋转是极其计算密集型的。

结论

为了评估这三个模型，我们不仅考虑了基于准确性分数和 AUC 分数的模型性能，还考虑了计算时间和模型建立的难度。我们相信所有这些在标准数据科学项目中都是必不可少的。结果总结如下:

就 AUC 分数和准确度分数而言，AutoGluon 具有最佳的模型准确度。此外，我们发现 AutoGluon 非常容易构建，因为它只需要几行代码就可以完成，并且不需要任何超参数调整。但是，它的一个主要缺点是计算时间比 XGBoost 长得多。根据具体需求，在选择模型时，必须在时间和精度之间进行权衡。尽管如此，当谈到自动化 ML 任务时，我们对 AutoGluon 的潜力非常有信心。它代表了数据科学行业的转折点:不仅仅是数据专家，不具备编码技能的人现在也可以构建有效的模型来满足他们的各种需求。

那么 AutoGluon 和其他 AutoML 最终会取代数据科学家吗？答案是复杂的:一些任务肯定会完全自动化，导致未来对数据科学家的需求减少。具体来说，专注于模型调整和优化的工作职能将更有可能被 AutoML 取代。根据中国著名数据科学家 Justin Ho 的说法，随着 AutoML 在未来达到更成熟的阶段，那些只拥有模型调整技能的人将失去竞争优势。然而，我们仍然怀疑它能否完全取代数据科学家，原因有五:

  1. 在无监督学习中，没有明确的措施来评估结果的质量。无监督学习被认为是成功的，只要它提供了可用于进一步分析的信息。此外，该过程需要大量的领域知识。AutoML 在此步骤中无法提供足够的帮助。
  2. Skim Technologies 的高级数据科学家 Marcia Oliveira 表示，迄今为止，还没有为强化学习开发出有效的 AutoML。
  3. AutoML 不能很好地处理网络数据、web 数据等复杂数据。
  4. 很少有 AutoML 能处理特征工程。
  5. AutoML 不能完全自动化构思商业见解和实施决策的过程。

下图展示了我们对 AutoML 未来在标准项目工作流程中所能完成的工作的预测。我们相信只有有限的一部分任务能够并且将会实现自动化。请注意，蓝色越深，任务自动完成的可能性越大。

毕竟，数据科学是一门艺术，需要结合业务洞察力和数据技术来解决现实世界中的问题。虽然 AutoML 可以在特定流程中取代人类，但还有许多其他领域需要数据科学家的创造力和领域知识。无论 AutoML 有多“聪明”，它只是一个帮助实现更大模型性能的工具。此外，它旨在将数据科学家从繁琐的“杂务”中解放出来，如超参数调整和数据清理，使他们能够专注于其他更重要的任务。因此，AutoML 应该被视为数据科学家的朋友，而不是敌人。作为数据科学家，我们应该了解 AutoML 的发展趋势，并加强我们无法完全被 AutoML 取代的能力。最重要的是，我们应该拥抱 AutoML 的力量，继续发掘它的真正潜力，让它更好地为人类服务。

警告

尽管亚马逊的 AutoGluon 似乎是我们测试中的最佳选择，但仍有几个警告需要注意:

  • 我们的测试仅证明了在使用给定数据的特定任务中，AutoGluon 优于 XGBoost。也就是说，如果我们使用另一个数据集或改变任务的性质，自动增长可能不是最佳选择。
  • 虽然 AutoGluon 在准确性方面略好于 XGBoost，但在大多数情况下，它比 XGBoost 计算量更大。
  • 自动旋转令人印象深刻的表现可能是纯粹运气的结果。

作者

[## 哈里(严俊)何-杜克大学-北卡罗莱纳州达勒姆| LinkedIn

我现在是杜克大学商业分析硕士课程福库商学院的学生。这里…

www.linkedin.com](https://www.linkedin.com/in/harry-junyan-he-4a1591130/) [## 张艺洋-杜克大学-富卡商学院-北卡罗莱纳州达勒姆| LinkedIn

我目前在杜克大学学习的定量管理硕士:商业分析和我的…

www.linkedin.com](https://www.linkedin.com/in/yiyang-zhang-386b68146/)

参考

[1]:希瓦尼。(2019 年 8 月 2 日)。自动机器学习的发展。https://www . cisin . com/coffee-break/technology/the-growth-of-automated-machine-learning-automl . html

[2]:安比卡·乔杜里。(2019 年 1 月 14 日)。亚马逊 AutoGluon 如何只用几行代码就能自动化深度学习模型。https://analyticsindiamag . com/how-amazons-autoglon-can-automated-deep-learning-models-with-just-the-less-lines-of-codes/

[3]:杰森·布朗利。(2019 年 8 月 21 日)。应用机器学习 XGBoost 简介。https://machine learning mastery . com/gentle-introduction-xgboost-applied-machine-learning/

[4]:威尔·科尔森。(2018 年 8 月 30 日)。Python 中随机森林的实现和解释。https://towards data science . com/an-implementation-and-explain-the-random-forest-in-python-77bf 308 a9b 76

[4]:毗瑟摩德。(2019 年 4 月 7 日)。XGBoost 算法:愿她统治长久！https://towards data science . com/https-medium-com-vishalmorde-xgboost-algorithm-long-she-may-rein-edd 9 f 99 be 63d

[5]:玛西娅·奥利维拉。(2019 年 3 月)。AutoML 不会取代数据科学家的 3 个原因。https://www . kdnugges . com/2019/03/why-automl-wont-replace-data-scientists . html

[6]: UCI 机器学习。信用卡客户数据集的默认值。https://www . ka ggle . com/UC IML/default-of-credit-card-clients-dataset

7 个简单的 Python 函数来清理您的数据

原文：https://towardsdatascience.com/automate-boring-tasks-with-your-own-functions-a32785437179?source=collection_archive---------10-----------------------

用 Python 自动化任务很容易。一旦你有了一个可以工作的脚本，把它变成一个可以帮助你更有效编码的函数！

因为重复通常很无聊！(照片摄于新加坡)

无论您是 Python 初学者还是专业人士，无论您是在工作中还是在家里使用 Python，您都有可能每天/每周/每月都要执行一些特定的任务。你有没有发现自己回到旧项目中，试图找到你为另一个项目开发的那段令人敬畏的代码？“在哪里？我可以发誓，我在另一个项目中也做过同样的事情！”—这是一个熟悉的想法吗？

如果您像我一样，在工作中进行大量的数据提取、转换和加载(ETL ),那么这个“问题”可能会特别重要。

我能想到几个例子，我相信你能找到数百篇其他的有很酷的技巧和功能的文章，有些更好，有些更差。我也见过他们。但是他们中的大多数会把同样的片段再给你看一遍。

这就是为什么我试图从典型的例子中走出来，分享一些我实际创作并经常使用的东西！这并不是说它们是有史以来最令人惊叹、编写得最好、令人兴奋的函数，但至少我很确定你在其他地方没有见过它们，也许你甚至可以调整一两个来帮助你解决未来的问题。在我的下一篇文章中，我将展示如何用 Python 创建自己的类。

你说的是什么样的任务？

您是否有一个文件夹，每天上传 csv 文件，然后需要不时地将它们合并成一个大数据集？或者，您可能希望为特定文件夹中的每个文件添加一列，并用不同的名称保存它们？也许您从数据库中提取的数据带有奇怪的列名，或者其中一列需要分成两部分。

你明白了，对吗？！

我将分享一些代码片段来解决这些问题，还有更多！但是玩笑开够了。下面是我们将在本文中编码的任务类型列表。我希望其中一些对你有用，就像它们几乎每天对我一样！

  • 合并特定文件夹中的所有文件
  • 编辑同一文件夹中的每个文件，然后重新保存
  • 清理数据集的标题
  • 将 dataframe 列拆分为两列或更多列
  • 根据列名筛选特定的数据框架列
  • 计算两个日期之间的天数
  • 计算两个日期之间的周/月/年数

处理 csv 文件

我记得当我让这两个功能工作时，我非常自豪。几分钟(甚至几小时)神奇地变成了几秒钟。“是生活中的小事”，我猜！

每天都要处理大量的 csv 文件，我每天都要提取每天的数据，这些数据大约每周都要进行编译。如果你有类似的任务，你可能会喜欢这些！

合并同一文件夹中的所有文件

这一个开始是一个简单的功能，但是后来它发展了一点。起点只是指向一个包含我想要合并的 csv 文件的文件夹，并将合并的数据集保存到一个新文件中。请注意，我使用的文件与的结构完全相同，但是您可以轻松地修改这段代码来满足您的需求。

但是 csv 文件只能放这么多行 …所以过了一会儿，我加了一个选项只合并内存中的文件。我添加了一个输入变量，这样我就可以调用这个函数，它会向我询问路径，而不是我在编写命令本身时复制路径。

你只需要为这个导入 glob 和 pandas 。strftime 是一种很好的跟踪文件创建时间的方法，它将日期添加到文件名中。

默认情况下，可以这样运行:folder _ CSV _ merge(' my _ pref fix ')。然后，它会提示您粘贴文件路径。新文件应该出现在与原始文件相同的文件夹中。这可能不是最佳做法，因此请确保编辑最后一行，以匹配您希望保存最终文件的位置。

如果您只想将 csv 文件中的所有数据放入内存中的一个数据帧中，而不是一个新文件中，只需添加参数 memory='yes' ，但是您需要将该函数调用到一个变量中。像这样:merged _ file = folder _ CSV _ merge(' my _ pref fix '，memory = 'yes ')。现在你将拥有一个包含所有文件的变量。

一次编辑几个文件

在最近的一个场合，我意识到我花了几个小时等待提取数百个文件，但是在提取的时候忘记给每个文件添加一个重要的列。再等一天重新拥有一切不是一个选择…

没问题！那就是对于循环的意义……对于？！

第一部分非常相似，因为我希望控制台提示我输入文件路径。在指定了文件路径之后，它将遍历每个文件，并对每个文件做一些事情。

在上面的例子中，我在每个文件中都有一列显示客户在我们公司工作了多少天。问题是我忘了在提取和转换时给这个值加 1(因为“资历= 0”对我来说很奇怪！).这是我需要做的唯一改变，但是如果你愿意，你可以添加更多的东西。重命名列、删除列、创建新列等。

这一次节省了我很多时间，如果你一定要知道的话，我确实在工作完成后表扬了自己。它实际上是在我试图计算客户保持率时使用的，如果你对此感兴趣，请查看我关于它的文章！

转换数据帧以满足您的需求

接下来的函数都是关于清理那些你从销售部门的人那里得到的数据集，或者任何其他懒得关心数据一致性和可读性的同事！甚至一些很久以前构建的数据库也会有怪异的列名，看起来像是句子，充满了奇怪的字符。

清洗数据帧标题

这个很简单，也很有用。几乎不言自明！这也很重要，因为您希望在项目中保持列名的一致性。

根据内容拆分列

接下来，一个简单的函数帮助您根据特定的字符或字符串拆分列。

假设您在数据帧中有一个列“tag ”,它实际上由一个类别和一个子类别组成，用下划线分隔。您希望将这两个列分开，这意味着我们需要一个名为“category”的列和另一个名为“subcategory”的列。简单:

split_columns(dataframe，'标签'，'类别'，'子类别'，' _')

再次检查您的数据框架，现在您有了两个新列！

根据名称筛选特定的列

这不是我每天使用的东西，但有一个特定的文件使我创建了它。该文件有几列不同年份的名称相同。但是我通常只需要处理一年的数据，所以我必须过滤相关的列。

为了让它更清楚，我在这个代码片段的末尾添加了一个小例子。运行它，自己看看它是如何工作的。

操作日期列

当我开始学习 Python 时，我记得我当时发现的最酷的特性之一是内置的日期/时间功能。我们在某个时候都是菜鸟！接下来的这些函数假设您已经将日期列转换成了 datetime 对象(例如这里的和)。

计算日期之间的天数

我将是第一个承认下一个函数不是有史以来最大的突破… 除非你想使用的列总是相同的，只有数据帧名称改变了。如果是这种情况，您可以在函数中对列名进行硬编码，并通过一个参数(即数据帧的名称)轻松使用它。

此函数使用两个日期之间的差异创建一个新列。更多关于“协同索引”是什么，在下一个。

计算日期之间的周数/月数/年数

总结一下，我将以 1 英镑的价格分享这 2 英镑！我需要这些来写我之前提到的客户维系文章。有必要计算分组。

可以用上面的函数获得每日分组，但是它不适用于每月分组或每年分组。如果你想知道为什么，你可以查看文章来了解我为什么需要它。

第一个函数 get_date_int 是必需的，这样我们就可以从每个日期中分离出年、月和周。该函数将为每个变量返回一个整数，我们将把它合并到calc _ coorts函数中。

转到第二个函数，我们需要一个带有两个日期列的 dataframe(在本例中，它是注册日期和最后登录日期，但是您可以更改名称以适合您的项目)。

一旦你运行它，你会在你的数据帧中得到两个新的列，叫做 cohort_w 和 cohort_y 。您的群组已准备好用于计算保留率！

敬请关注更多内容！

目前就是这样，但是正如我在开始提到的，我正在写下一篇关于如何用 Python 创建你自己的类的文章。一个类将让你直接使用这些函数，就像你使用一个“普通”的包，比如 Pandas 或 Numpy。不需要每次都定义函数。只需导入您自己的包并直接使用它们。

与此同时，我要感谢你阅读/评论和关注我，如果是这样的话。能够分享这段旅程并与这么多人联系真的很有收获！

别忘了看看我的其他文章:

[## 用一个简单的 Python 机器人增加你的 Instagram 粉丝

我在 4 天内有了 500 个真正的追随者！

towardsdatascience.com](/increase-your-instagram-followers-with-a-simple-python-bot-fde048dce20d) [## 我在找房子，所以我用 Python 做了一个 web scraper！

几个月后，我将不得不离开我租的公寓，去找一个新的。尽管这种经历很痛苦…

towardsdatascience.com](/looking-for-a-house-build-a-web-scraper-to-help-you-5ab25badc83e) [## 使用 Tkinter，将您以前的 Python 项目变成令人敬畏的工具

用 Tkinter、Python 和 Selenium 创建一个简单的应用程序和一个 web 抓取脚本！

towardsdatascience.com](/turn-your-previous-python-projects-into-awesome-tools-with-tkinter-2e61f2241e29)

感谢您的阅读！一如既往，我欢迎反馈和建设性的批评。如果你想取得联系，可以联系我 这里或者直接回复下面的文章。

自动将数据导入 Google Analytics

原文：https://towardsdatascience.com/automate-data-import-to-google-analytics-471de2c3fc76?source=collection_archive---------31-----------------------

建立一个数据管道，使用谷歌触角和 GCP 将数据导入谷歌分析。

来源 pixabay ，作者 geralt-9301

假设你已经将先进的机器学习技术应用于你的谷歌分析点击量数据来丰富它。现在，您希望将增强的数据发送到您的 google analytics，这样您就可以细分和锁定那些丰富的用户，以实现重新激活和其他营销目标。

在本演练指南中，我将演示如何建立一个数据管道，允许您使用 google 云平台将数据自动导入 google analytics。我们将使用谷歌触手来建立数据管道。

谷歌触手是一个免费使用的解决方案，有助于以自动化的方式将数据发送回谷歌分析。你所要做的就是将你的数据上传到云存储，该解决方案将按照谷歌分析要求的格式将数据发送到谷歌分析。

注意:这个解决方案广泛使用了谷歌云组件，因此，如果你想了解更多关于 GCP 方面的事情，我推荐 谷歌的 GCP 课程 作为一个很好的起点。

数据管道

数据导入管道，由 Muffaddal

触手使用了 GCP 的四个组件，即云存储、Firestore/Datastore、发布/订阅和云功能。

云存储用于存储需要导入的数据。您可以在这里上传要发送给 GA 的离线数据。数据需要采用特定的格式，以便 GA 读取。在后面的章节中会有更多关于数据格式的内容。

Firestore 或 Datastore 用于配置。它告诉 tentacles 向哪个 GA 帐户发送数据以及如何发送。根据您的 GCP 项目配置，您将使用 Firestore 或 Datastore。默认情况下，tentacles 使用 Firestore，但如果您的项目设置为使用 Datastore，那么 tentacles 将使用它。

发布/订阅用于保存、通知和移动数据。使用了三个 pub/sub。首先是ps-data。它保存从云功能临时发送的数据。其次是ps-tran。通知云函数从ps-data发布/订阅中读取数据。第三个是ps-api。这个发布/订阅负责在发布/订阅之间传递数据。

云函数是动作发生的地方。使用了三种云函数。首先是initiator。每当有文件上传到云桶时就会触发。它将上传的数据发送到ps-data发布/订阅。其次是 transporter。它由ps-tran触发，并将数据从ps-data传输到ps-api发布/订阅。最后一个云函数是apirequester。它从ps-api获取数据，并将其发送至测量协议。

下面是数据如何在组件之间移动。

数据解决方案架构，作者 Muffaddal

装置

我们将使用 GCP 的云壳安装数据管道。

1-打开外壳后，键入以下命令，复制运行安装所需的代码。

git clone https://github.com/GoogleCloudPlatform/cloud-for-marketing.git

2-下一步移动到我们复制的目录:

cd cloud-for-marketing/marketing-analytics/activation/gmp-googleads-connector

3-在正确的文件夹中输入一次bash deploy.sh。这将启动安装脚本。

在安装过程中，脚本会询问一些需要回答的配置问题。

  1. 项目 Id :首先提示您输入项目 Id。如果要使用默认项目，请提供项目 id 或按 enter 键。
  2. 输入地区:接下来需要告知地区。输入“y”表示默认值，或输入“n”表示新区域。
  3. 集成 API :谷歌触须可以导入多个目的地，但因为我们是为谷歌分析安装它，输入“0”。我将在本文后面讨论其他 API。
  4. 云存储空间:您将被要求提供一个存储空间名称，以便将数据上传到 google analytics。提供存储桶名称或按 enter 键选择默认存储桶名称。
  5. 文件夹名称:与存储桶类似，提供文件夹名称或保持默认。默认文件夹名称将为“出站”。
  6. 发布/订阅:接下来它会询问发布/订阅主题的名称。我建议保持默认，所以只需按回车键。
  7. 配置文件:当要求设置配置文件时，输入‘y’。
  8. 设置 Firestore/Datastore :如果您的项目还没有设置 Firestore 或 Datastore，您将被要求进行设置。单击它提供的链接进行设置。

按照上述步骤将完成安装，现在我们的数据管道组件可以使用了。

配置

接下来，我们必须添加配置，以便 tentacles 可以知道将数据发送到哪个 Google Analytics 属性。

  1. 在云外壳中键入以下命令
cp config_api.json.template config_api.json

2.接下来，通过单击云外壳右上角的 web 预览图标打开云控制台编辑器。

云网络预览，作者 Muffaddal

3.一旦进入编辑器，转到配置文件，该文件位于:
cloud-for-marketing/activation/gmp-googleads-connector

云代码编辑器导航面板，Muffaddal

4.删除config_api.json的内容并将下面的代码复制粘贴到文件中

config_api.json settings

5.在tid中添加 UA id，在dh中添加您的网站域名。

MP 的子对象告诉触须将数据发送到哪里。您可以添加多个用逗号分隔的子对象来配置多个 GA 属性。

我已经设置了配置文件，这样每当使用 tentacles 将数据导入 GA 时，还会触发一个名为Google Tentacles的事件。这有助于监控实时报告和顶级事件报告中的内容。

保存文件并返回到您的云外壳窗口。

firestore/数据存储

触手读取 Firestore 或 Datastore(取决于您的项目设置)来知道将数据发送到哪里。因此，我们必须将上一步中设置的配置迁移到 Firestore。

为此，请在云外壳中键入以下命令:

bash deploy.sh update_api_config

如果要求输入文件名，请点击回车，因为我们已经使用了默认文件名。如果一切顺利，你应该可以在 Firestore/Datastore 中看到你在config.json文件中的设置。

注意:每次更改配置时，您都必须运行上述命令。

我们的数据管道已经准备好了。接下来，让我们向 Google Analytics 发送一些数据。

数据文件格式

数据管道的工作原理是，你必须将文件移动到你在安装过程中提供的云存储桶文件夹中。您可以将文件上传到 bucket，或者从 bigquery 或任何其他方式将它移动到 bucket。

一旦文件被转移到存储，它就被处理并导入到 Google Analytics。

但是在上传的数据可以移动到 GA 之前，数据必须是特定的格式，并且文件需要有特定的命名约定，以便触须读取它。

数据格式

数据文件应该是具有 ndjson 格式的 CSV 文件。这意味着每一行都应该是用花括号括起来的要上传的数据行。

为了帮助理解这一点，假设我们想要发送一个自定义维度来描述用户对电影类型的喜爱程度。数据看起来是这样的:

{"cid":"1471305204.1541378885","cd1":"horror"}

“cid”是我们为其发送自定义维度 1 的用户的客户端 id。

只要文件内容是所描述的格式，我们就可以将任何内容发送到 GA，例如，如果我们想要发送一个事件标签‘upload’和自定义维度 2 作为‘stripe’，那么内容将如下所示:

*{"cid":"2070754008.1580876566","el":"*upload*","cd2":"*stripe*"}*

命名约定

为了让 tentacles 读取上传的文件，必须使用以下命名约定:

Muffaddal 对上传文件的命名约定

文件名的绿色部分是静态的，不应该改变，因为 Tentacles 被设计成只能读取这种格式。

红色部分表示发送数据的目的地。这告诉触须使用配置中的哪些设置。这可以定制为告诉 tentacles 应该使用哪个 GA 帐户来发送数据。

由 Muffaddal 创建的 config.json 文件

开头的“*”表示可以在此处添加附加文本，以赋予文件更有意义的名称，例如:

*analysis_results_****API[MP]_config[*GA_Setting_1*].csv***

搞定了。

在云存储中创建您在安装期间输入的 bucket 和文件夹，上传您的 CSV，您应该会在您的 Google analytics 的实时报告中看到一个事件。

结束注释

我们努力建立谷歌触角，使用谷歌云平台向谷歌分析发送数据。安装完成后，你只需将数据文件以正确的格式上传到谷歌云存储中，数据管道就会触发将数据导入谷歌分析。

请注意，谷歌触手也能够向其他谷歌营销平台发送数据。在步骤 3 安装的 API 集成中，我们输入“0”以使用测量协议。为了使用其他 API，请在该步骤中输入相关数字。此外，请记住，每个 API 都需要单独的配置，并期望云存储中有不同的数据格式，所以请记住这一点。阅读GitHub repo了解更多详情。

相似读取

  1. 向 BigQuery 发送 Google Analytics 点击量数据
  2. 使用 BigQuery ML 执行 RFM 分析

使用 Google Colab 自动准备数据:读取和处理 Zip 文件中的 Citi Bike 数据

原文：https://towardsdatascience.com/automate-data-preparation-using-google-colab-read-and-process-citi-bike-data-in-zip-file-2ab34dd33205?source=collection_archive---------49-----------------------

安东尼·福明在 Unsplash 上的照片

我不时会收到同事的请求，要求我处理一些大型数据文件，并从数据中报告一些统计数据。由于他们依靠 Excel 作为主要的数据处理/分析工具，而不使用 Python 、 R 或 SQL ，读取和处理超过 1048576 行的数据文件(Excel的行容量)成为一个问题。

为了处理 zip 文件中的数据，通常我会下载 zip 文件，解压缩得到 CSV 文件，然后将 CSV 文件导入 SQL、R 或 Python 进行处理。得到结果后，我需要将结果输出到 CSV 文件中，并将文件发送给请求这项工作的同事。当我每个月都有新数据进来时，我必须重复这个过程，这整个过程可能会变得很麻烦。

谷歌 Colab 让自动化成为可能

Google Colab (即 Google Colaboratory)提供了一个共享 Python 代码并在 web 浏览器中运行的平台。与非 Python 用户分享您的 Python 解决方案尤其有用。

这里有一个 Python 程序的例子，它使用 Google Colab 来自动准备每月花旗自行车的数据。该程序可以直接从 Citi Bike online 门户网站读取 zip 文件，并处理数据以报告每个日历日的 Citi Bike 行程总数。用户只需要提供他们想要处理的数据文件的 URL，并最终将结果下载/保存到他们的本地计算机。

花旗自行车数据

Citi Bike 网站每月都会发布用户使用数据，并维护回溯至 2013 年 6 月的历史数据。这是分析纽约大都市区微观流动趋势的良好数据源。

花旗自行车数据文件中的记录数量可能非常大。例如，2020 年 8 月的数据包含超过 200 万条记录，超过了 Excel 的行容量。

用于处理花旗自行车数据的 Python 程序

首先进入花旗自行车旅行数据门户并复制您想要处理的文件的链接地址:

https://s3.amazonaws.com/tripdata/index.html

要运行代码，你需要登录你的谷歌账户。一旦登录，你可以通过点击代码窗口左上角的箭头来运行 Python 代码。

将数据文件链接地址粘贴到输入框“数据 URL:”，点击“回车”。代码将从文件地址下载 zip 文件，并逐行读入数据，并将数据保存到一个 DataFrame 中。

data_address = input('Data url: ')
url = urllib.request.urlopen(data_address)
data = []
df = pd.DataFrame()
**with** ZipFile(BytesIO(url.read())) **as** my_zip_file:
    **for** contained_file **in** my_zip_file.namelist():
        **for** line **in** my_zip_file.open(contained_file).readlines():
            s=str(line,'utf-8')
            s = re.sub(r"\n", "", s)
            s = re.sub(r"**\"**", "", s)
            line_s = s.split(",")
            data.append(line_s)

df = pd.DataFrame(data)

一旦我们将数据存储到一个数据框架中，事情就变得简单有趣了。原始数据中的第一行包含变量名(或列名)。使用第一行中的数据作为数据帧的列名，然后从数据帧中删除第一行。然后根据每次旅行的“开始时间”合计数据帧，以计算每个日历日的旅行次数，并将结果打印到输出控制台。

col_name = df.iloc[0].astype(str)
df.columns = col_name
df = df.drop([0])
df['startdate']=df['starttime'].astype('datetime64[ns]').dt.date
date_count = df.groupby('startdate').count()[['bikeid']]
date_count.columns = ['count']
print(date_count)

一旦结果输出到控制台，通过在控制台底部的输入框“输出文件名:”中指定输出文件名，将结果下载到您的本地计算机。

output_file_name = input('Output File Name: ')
date_count.to_csv(output_file_name+'.csv') 
files.download(output_file_name+'.csv')

完整的代码如下:

**from** **io** **import** BytesIO
**from** **zipfile** **import** ZipFile
**import** **pandas** **as** **pd**
**import** **urllib.request**
**import** **re**
**from** **google.colab** **import** files

data_address = input('Data url: ')
url = urllib.request.urlopen(data_address)
data = []
df = pd.DataFrame()
**with** ZipFile(BytesIO(url.read())) **as** my_zip_file:
    **for** contained_file **in** my_zip_file.namelist():
        **for** line **in** my_zip_file.open(contained_file).readlines():
            s=str(line,'utf-8')
            s = re.sub(r"\n", "", s)
            s = re.sub(r"**\"**", "", s)
            line_s = s.split(",")
            data.append(line_s)

df = pd.DataFrame(data)
col_name = df.iloc[0].astype(str)
df.columns = col_name
df = df.drop([0])
df['startdate']=df['starttime'].astype('datetime64[ns]').dt.date
date_count = df.groupby('startdate').count()[['bikeid']]
date_count.columns = ['count']
print(date_count)

output_file_name = input('Output File Name: ')
date_count.to_csv(output_file_name+'.csv') 
files.download(output_file_name+'.csv')

[## 用我的推荐链接-华景石加入媒体

作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…

huajing-shi.medium.com](https://huajing-shi.medium.com/membership)

链接到 Google Colab 笔记本:

https://colab . research . Google . com/drive/1 sptto E6 sl 9 on b5-lhappowgcipe 1 mihw # scroll to = krmffxaw 30 RC

GitHub 链接:

https://github . com/Shi 093/Citi bike-Monthly-Report/blob/master/Citi bike _ daily count . ipynb

使用 Terraform 在 GCP 自动部署弹性搜索

原文：https://towardsdatascience.com/automate-elasticsearch-deployment-in-gcp-part-1-terraform-3f51b4fcf5e6?source=collection_archive---------12-----------------------

GCP 的弹性研究

在一个命令中设置您的 Elasticsearch、Kibana 和 Logstash (ELK)环境

(改编)伊莱恩·卡萨普在 Unsplash 拍摄的照片

我们都想利用 Elasticsearch 的强大功能，但是插件、配置和错综复杂的文档数量给入门设置了巨大的障碍。

NB！本指南希望您对 Terraform、Bash 脚本和 Elasticsearch 有一些基本的了解。

在 GCP(谷歌云平台)，目前开始使用 Elasticsearch 只有几个选择:使用 Elastic 中的托管 SaaS 或市场中的某个产品。这两种选择都有缺点，我打算展示我的方法，告诉您如何快速开始并看到一些结果，同时保持对您的部署的完全控制。

稍后，您可以吸收文档中的详细信息，并按照自己的进度深入理解。本文绝不是对 Elasticsearch 集群的完美设置的描述，它更像是一种让您需要的所有工具以一种平稳的方式快速启动和运行的方式，然后由您根据自己的用例修改脚本。我一直在 GCP 工作，但是这些例子应该适用于任何云环境。

Elasticsearch、Kibana、Logstash 和所有相关插件都是开源的，因此唯一的成本是在 GCP 或任何其他云环境中运行的虚拟机和基础设施。

Terraform 非常适合自动化部署，因为您只需一个命令，就可以在几分钟内拆除和启动虚拟机和基础架构。

1.将（行星）地球化（以适合人类居住）

1.1.虚拟机

首先，我们需要运行 Elasticsearch 的虚拟机:

这里发生了很多事情。通过迭代上面的代码片段，您可以选择想要部署多少台机器。最有趣的是我称之为./startup-elastic.sh的启动脚本。我们将在第 2 节回到这个话题。

我们还需要一个新实例来运行 Kibana:

所以，这是我们所需要的核心，实际的 GCE VM (Google 计算引擎)运行 Elasticsearch 和 Kibana 作为 Hashicorp 配置语言。

您可以在 var 文件中选择任何适合您的设置。此配置将在其自己的子网中部署一个带有 200 GB SSD 驱动器的虚拟机，该虚拟机的服务帐户具有最低要求的权限。没有外部 IP，所以我们必须想出另一种方法来访问虚拟机。

我的 tfvar 文件看起来像这样:

到目前为止一切顺利，但我们需要的不仅仅是虚拟机，对吗？
让我们设置 IAM，并给予虚拟机使用的服务帐户正确的权限。

1.2.许可

为了能够在 GCS (Google Cloud Storage)中创建我们的数据备份，服务帐户将需要一些细粒度的权限。

首先，我们使用虚拟机备份到 GCS 所需的权限创建一个自定义角色，并获取服务帐户的密钥，然后我们创建一个服务帐户，并将该角色应用于该帐户。最后，我们为服务帐户生成一个密钥。这个密钥我们将保存在 Elasticsearch 的 Keystore 中，并用它在 GCS 中创建一个备份存储库。

1.3.网络

为了安全，我们还需要一些网络基础设施。

我们首先为虚拟机和基础架构创建单独的 VPC(虚拟私有云)和子网。在这里，我们指定您可以给机器的 IP 范围。

由于虚拟机没有外部 IP，您无法访问互联网和下载任何软件。为了解决这个问题，我们需要用路由器打开一个 NAT 网关，以便能够从互联网上下载任何东西。一旦软件安装完毕，我们就可以移除 NAT 网关了。

在 GCP，如果你想通过 Appengine 或云功能访问你的 VPC 网络，你需要一个 VPC 连接器。在我的设置中，我在 GAE 上托管了一个 API，它通过 VPC 连接器调用 Elasticsearch 内部负载平衡器。

超过 1 个节点的 Elasticsearch 集群需要一个负载均衡器来分发请求。要将虚拟机置于负载平衡器之下，我们需要创建实例组。为了实现冗余，我们将虚拟机放在同一区域的不同分区中。如果一个区域出现问题，其他区域不会受到影响。在本例中，我们部署了三台虚拟机，my-elastic-instance-1 和 2 位于区域 d，而 my-elastic-instance-3 位于区域 c。

因为我们还想通过负载均衡器访问 Kibana，所以我们也将为此创建一个实例组。

现在，我们需要的是带有健康检查和转发规则的负载平衡器。

1.4.防火墙规则

当然，还有我经常忘记的部分，防火墙规则。允许子网中的节点之间进行内部通信，允许负载平衡器和运行状况检查与虚拟机进行通信。

2.Elasticsearch Bash 脚本

在这一节中，我们将看看有趣的东西:当部署机器时，在机器上运行的启动脚本。

该脚本接受几个输入参数:

  • 弹性搜索集群主节点的名称
  • 集群中所有节点的 IP
  • GCS 备份-存储桶名称(存储备份的位置)
  • 存储证书的 GCS 存储桶名称
  • 服务帐户密钥
  • Elasticsearch 的密码。

这些桶是手动创建的，但是如果您更喜欢在 Terraform 中创建，那也很好。

在我们查看脚本之前，还有另一个手动步骤——创建证书。这可能是自动化的，但我发现手动生成它们并在启动时将它们放入 GCS bucket 并复制到 Elasticsearch 更容易。

证书对于保护集群内的通信和启用 Kibana 中的某些功能非常重要。

我将把脚本分解成更小的块，并逐一解释它们。

2.1.启动检查

我们首先检查credentials.json文件是否存在，所以我们只运行一次启动脚本，而不是每次重启机器。如果文件存在，我们退出脚本。

2.2.安装必备组件

然后，我们下载并安装先决条件。你可以指定你喜欢哪个版本，或者只取最新的 7.x 版本如下。

2.3.配置 elasticsearch.yml

现在，我们需要在elasticsearch.yml文件中配置 Elasticsearch。在这里，我们设置节点的 IP，并决定哪个是主节点。

如果您还记得第 1 节，启动脚本接受了一些输入变量。
这些是:

2.4.配置堆大小

如果你以前有过使用 Elasticsearch 的经验，你就知道 RAM 有多重要。我不会深入讨论这个问题，我只是将堆大小设置为总 RAM 的 50%并且低于 32 GB。

2.5.安装 GCS 备份插件

在这一步，我们安装必要的插件，我们需要使用 GCS 作为我们所有弹性搜索索引的备份。这也将服务帐户密钥添加到密钥库中，并重新启动 Elasticsearch。

2.6.启用监控

下一个命令在群集设置中启用 X-Pack 监控。

2.7.扩展 Elasticsearch.yml 并复制证书

在这里，我们将放在 GCS 桶中的证书复制到 Elasticsearch 中，并且我们还使用一些安全设置扩展了elasticsearch.yml文件。最后，我们将密码添加到 Elasticsearch 密钥库中。在这些例子中，我们没有为密钥库设置任何密码。

现在，我们不想像发送到这个脚本中的所有其他参数一样，将我们的密码保存在 tfvar 文件中。如果你一开始就注意到了，我们的 tfvar 文件没有任何 elastic_pw。我们在部署 terraform 代码时添加了它，以使密码远离代码和存储库。

像这样:

2.8.注册备份存储库、创建自定义角色等。

最后一步是注册备份存储库并创建一个策略，以便每天将快照放入我们的备份存储桶。我们还创建了一些自定义角色。在这一步之后，您可以从 Elasticsearch 文档中添加您想要的任何内容。

当你安装 Elasticsearch 时，如果你也安装 Kibana(elastic search 的前端)和一些插件来监控你的集群，你的生活会轻松很多。

3.基巴纳巴什脚本

在这最后一部分中，我们将浏览 Kibana 启动脚本，并通过解释我们如何通过浏览器安全地访问 Kibana 来将它们联系在一起。

为了简单起见，我选择在与 Kibana 相同的实例中运行所有 beats 插件。

3.1.启动检查

正如我们在第 2 节中提到的，我们只想运行这个脚本一次。

3.2.安装必备组件

3.3.密钥库和密码

就像 Elasticsearch 一样，Kibana 有一个密钥库来安全地存储敏感信息。Keystores 的诀窍是 Kibana 将从kibana.yml和kibana.keystore读取设置。现在，Kibana 可以连接到 Elasticsearch，而不会以纯文本形式暴露我们的密码。Beats 和 APM 有以类似方式操作的密钥库。

3.4.将证书复制到 Kibana

3.5.追加 Kibana 配置文件

3.6.开始基巴纳

要向 Elasticsearch 发送数据，我们需要 Beats。它们充当 Elasticsearch 和 Logstash 的数据传送器。我将避免描述细节，因为它最好在文档中找到。

3.7.Filebeat

3.8.开始 Filebeat

3.9.公制节拍

3.10.心跳

3.11.高级电源管理

3.12.Logstash

皮尤，配置真多！

表演时间到了，让我们开始吧！

现在，我们的存储库中已经有了所有的配置，并且已经使用 Terraform 部署了 Elasticsearch，而没有暴露密码或证书。此外，您可以根据需要轻松添加更多插件和配置。

请注意，一切都部署在自己的 VPC 网络中，没有外部 IP 地址。那太好了，但是我们如何通过浏览器安全地访问 Kibana web 服务器呢？

3.13.访问基巴纳

这部分我们将在谷歌控制台手动完成，但也可以用 Terraform 自动完成。

我们保留一个静态 IP 地址，创建一个 HTTPS 负载平衡器。我们将后端配置设置为指向我们的 Kibana 实例组，而前端配置设置为我们的外部静态 IP 地址和端口 443。然后，我们创建一个证书，并将其分配给负载平衡器。设置负载平衡器时，可以在控制台中直接创建证书。

所以现在可以通过你预定的 IP 访问 Kibana 了。但是其他人也可以…这就引出了下一点:

输入 IAP ( 身份感知代理 )

IAP 允许我们通过设置 Oauth 客户端并授予用户 IAP 安全的 Web 应用用户权限来管理谁可以访问我们的负载平衡器。

现在，在 GCP 项目中，只有拥有此权限的用户才能访问您的 IP 地址。最重要的是，他们必须输入我们发送到 Kibana 的密码。

太棒了，现在我们可以在几分钟内用一个命令搭建一个全新的环境来运行 Elasticsearch、Kibana 和 Logstash！

在一个指挥部里部署一头麋鹿是什么感觉

感谢安德斯·阿克伯格的知识和支持。

使用 Python 自动处理电子邮件

原文：https://towardsdatascience.com/automate-email-with-python-1e755d9c6276?source=collection_archive---------7-----------------------

使用 Python 自动化枯燥的工作，优化我们的工作流程

照片由 Daria Nepriakhina 在 Unsplash 拍摄

M:我们都是上班族。如果你在工作日阅读这篇文章，你可能已经发送了几封电子邮件，或者很快就会这样做。

典型的工作者总共花 28%的时间阅读和回复电子邮件[1]。对于普通美国人来说，这相当于每天 2 小时 36 分钟。

电子邮件是保持工作世界运转的润滑油。没有它，世界看起来会非常不同。

但是，花在电子邮件上的时间真的有必要吗？《哈佛商业评论》的一项研究认为，事实并非如此。他们发现，由于电子邮件，我们平均每天浪费 1 小时 21 分钟。

我们所拥有的是难以想象数量的人可能被扔进无用的电子邮件任务的空白中。

尽管 Python 可能无法解决所有这些问题，但它肯定会有所帮助。

我们中的许多人都有数不清的电子邮件，这些邮件要求我们经历一个重复的过程，一周又一周地向相同的人发送所述过程的重复摘要。这种类型的重复对于自动化来说是成熟的。

我们将学习如何使用 Python 动态编写电子邮件，包括相关图片，以及附加重要文件。正确实施后，我们将节省大量时间，并消除潜在的人为错误。

它是如何工作的

对于这个任务，我们将使用两个库，email和smtplib。我们使用email来构建电子邮件消息本身，使用smtplib来发送消息。

这封邮件将被包含在一个叫做MIMEMultipart的物体中。这个对象可以包含几个子类，每个子类对应一个不同的媒体类型。我们的电子邮件将使用这些子类/部件构建，它们是:

  • MIMEText —纯文本，这将构成我们电子邮件的主体。
  • MIMEImage —允许我们在电子邮件中添加图像。
  • MIMEAudio —音频文件随该部分一起添加。
  • MIMEApplication —可以添加任何其他附件。

在我们使用这些不同的部分建立了我们的电子邮件消息之后，我们切换到smptlib。

SMTP 指的是简单邮件传输协议。这是通过互联网发送电子邮件最常用的协议。

在使用该协议时，我们将使用传输层安全(TLS)加密协议加密我们的电子邮件。

一旦我们与预定的电子邮件服务器建立了连接，我们就发送使用MIMEMultipart对象构建的电子邮件消息。那我们就完了。

哑剧

现在，让我们来充实上述过程。首先，我们的电子邮件消息，用MIMEMultipart构建。

MIMEMultipart允许我们附加几个子类。我们不需要使用它们，我们可以简单地通过MIMEText添加文本，然后就这样。但是，在大多数情况下，我们可能希望添加一个或多个其他类型。

MIMEMultipart的结构如上图所示。右边是我们的零件，MIMEText、MIMEImage和MIMEApplication。在左侧，是其他消息属性，如电子邮件主题。我们将不使用MIMEAudio，因此它被排除在上面的图像之外。

让我们来看一个示例导入和消息创建脚本:

这里发生了一些事情。在前五行中导入所需的库之后，我们初始化MIMEMultipart对象，将其赋给msg变量。

然后，我们将文本、图像image.jpg和附件report.docx附加到我们的消息msg中。

如上面的代码所示，使用attach方法可以很容易地将每个部分添加到MIMEMultipart中。

可以像访问 Python 字典一样访问和修改其他电子邮件和部件属性。例如，电子邮件主题的修改非常简单，如下所示:

msg['Subject'] = "Weekly Sales Report"

此外，我们还可以通过'Content-Disposition'键将文件元数据添加到我们的MIMEApplication对象中。我们这样做:

with open('report.docx', 'rb') as f:
    file = MIMEApplication(f.read())file['Content-Disposition'] = **"attachment; filename=report"**msg.attach(file)

附加几个文件

尽管我们在上面的例子中只附加了每个 MIME 子类中的一个，但是我们可以添加任意多个。这样做很简单，只需再次使用相关子类对象的attach方法:

for img_path in ['image1.png', 'image2.png']:
    img_data = open(img_path, 'rb').read()
    msg.attach(MIMEImage(img_data, name=os.path.basename(img_path)))

这里我们循环遍历一个包含两个图像文件的文件路径的列表— image1和image2。

我们将每个图像加载到img_data。注意当我们open图像时，我们通过指定'rb'标志将它们读取为二进制——我们必须对加载到MIMEMultipart子类中的所有内容都这样做。

最后，我们创建一个MIMEImage对象并将它们attach到我们的msg对象。创建MIMEImage时使用的name参数只是在电子邮件中指定附件名称。我们使用os.path.basename只返回文件名，没有任何路径或文件扩展名。

下面的代码是这个脚本的另一个更加结构化和完整的用例。其中我们包含了添加多个图像和附件的循环，还访问了'Subject'和'Content-Disposition'值。

简单邮件传输协议

如前所述。使用 SMTP 通过互联网在服务器之间传输电子邮件。幸运的是，smtplib让这个设置变得非常简单——我们只需要知道我们的电子邮件地址就可以了。

每个电子邮件提供商都有一个server地址和port号码。这些充当街道地址的数字等价物。

使用这些地址，我们初始化我们的 SMTP 连接。对于 Outlook，我们写smtp = smtplib.SMTP('smtp-mail.outlook.com', '587')。

一旦我们初始化了连接，我们必须让服务器知道我们想要如何与邮件服务器通信。

首先，我们使用smtp.ehlo发送一个 EHLO(扩展 Hello)命令。这告诉服务器我们可以使用扩展的 SMTP 协议(ESMTP)。有些服务器使用这个，有些不使用。但是，通过指定 EHLO，我们可以同时与 SMTP 和 ESMTP 服务器进行通信。

接下来，我们设置传输层安全性(TLS)加密。同样，这很简单，只需smtp.starttls即可实现。

我们用smtp.login登录 SMTP 服务器，用smtp.sendmail发送邮件。最后，我们用smtp.quit关闭与服务器的连接。

注意登录时，我们必须提供我们的电子邮件地址和密码。一般来说，尽量避免对此进行硬编码。相反，将它们保存在一个安全的本地文本文件中，并允许 Python 从那里读取它们。

至此，我们已经建立了自动化的工作流程。Python 现在可以为我们动态编写电子邮件，包括图像、音频和其他附件。

然后，我们使用 SMTP 协议发送这些消息，并使用 TLS 加密保护我们的通信。

我希望这篇文章是有用的，并帮助你腾出更多的时间来专注于工作中更有创造性、更深入的任务。

感谢阅读！

参考

[1] 《社会经济:通过社会技术释放价值和生产力》 (2012)，麦肯锡全球研究所

[2] M. Plummer，如何每天花更少的时间在电子邮件上 (2019)，《哈佛商业评论》

[3] SMTP 命令参考

除了自动报告之外，您还可以做更多的事情，例如机器学习培训更新或数据传输完成通知。当与移动电子邮件结合使用时，这是非常有用的。

如果您有兴趣进一步了解这方面的内容，我已经在另一篇文章《用 Python 通知:

[## 用 Python 通知

使用 Python 构建的电子邮件通知让生活更轻松

towardsdatascience.com](/notify-with-python-41b77d51657e)

使用 BERT 模型自动提取 Reddit 子组实体

原文：https://towardsdatascience.com/automate-entity-extraction-of-reddit-subgroup-using-bert-model-336f9edb176e?source=collection_archive---------33-----------------------

使用预先训练的 BERT 模型从 Subreddit r/Wordnews 中提取人名、位置和组织信息

被困在付费墙后面？点击这里阅读这篇文章和我的朋友链接。

资料来源:Unsplash 的 Luis Villasmil

命名实体识别(NER)是一个从非结构化文本中提取信息的过程。它也被称为实体提取。该方法提取时间、地点、货币、组织、医疗代码、人名等信息。我们可以将这些提取的实体标记为文章/文档的标签。

但是，我们通过从文本中提取实体来实现什么呢？这些标签能帮助我们减少文章搜索过程中的时间吗？

通过改进搜索过程，文章或文档上的标签可以节省大量时间。标签帮助我们对文本文档进行分类。这是 NER 的一个用例。

下面列出了 NER 的一些其他使用案例。

1.将通讯社的文章分为世界、体育、时尚、娱乐等类别。类别。

2。它有助于在不同的在线购物网站上搜索产品。

3。在线课程可以根据不同的相关标签进行分类。

我们将使用 BERT 预训练模型。点击了解有关 BERT 模型的更多信息。BERT 模型将从 Reddit 子组中提取人名、组织名和地名。

本文分为三个部分。

第一部分。数据收集和数据准备

Python 程序连接 Reddit API，从 subreddit 获取信息。然后我们根据 BERT 模型输入格式化数据。

第二部分。信息提取

我们将从第一部分准备的数据中提取实体信息。

第三部分。数据分析和数据可视化

在这一部分，我们将通过图表分析从第二部分提取的信息。

现在，让我们开始吧。

第一部分。数据收集和数据准备

我们将使用 Reddit 分组 r/Worldnews 数据。Reddit 提供 API 访问来获取标题、评论和其他与帖子相关的数据。PRAW 是一个 python 库，它帮助我们与 API 连接。在这里了解更多关于 PRAW 图书馆的信息。(https://praw.readthedocs.io/en/latest/)。您需要创建一个 Reddit 帐户来访问 API 所需的信息。

这些是必需的 API 信息。

reddit = praw.Reddit(client_id=’my_client_id’,
                     client_secret=’my_client_secret’,
                     user_agent=’my user agent name’)

按照文章中提到的步骤获取所需的 API 访问信息。

一旦你获得访问权，我们将从 r/Worldnews post 获取标题和评论。我们将使用 r/Worldnews 的顶级周刊。您可以根据不同的时间线和受欢迎程度接收来自子组的数据。

def replies_of(top_level_comment, comment_list):
  if len(top_level_comment.replies) == 0:
    return
  else:
    for num, comment in enumerate(top_level_comment.replies):
      try:
        comment_list.append(str(comment.body))
      except:
        continue
      replies_of(comment, comment_list)list_of_subreddit = [‘worldnews’]
for j in list_of_subreddit:
  # get 10 hot posts from the MachineLearning subreddit
  top_posts = reddit.subreddit(j).top(‘week’, limit=1)
  comment_list = []
    # save subreddit comments in dataframe
    for submission in top_posts:
      print(‘\n\n’)
      print(“Title :” , submission.title)
      submission_comm = reddit.submission(id=submission.id)
      comment_list.append(str(submission.title))
        for count, top_level_comment in enumerate(submission_comm.comments):
          try:
            replies_of(top_level_comment, comment_list)
          except:
            continue
print(comment_list)

这段代码将使用递归函数获取 subreddit 帖子的整个评论部分。数据将被存储到 comment_list 变量中。

第二部分。信息提取

第一部分准备的数据是 BERT 模型的输入格式。模型生成的输出保存在不同的变量中。

拥抱脸的 transformer python 库将帮助我们访问 DBMDZ 训练的 BERT 模型。BERT 令牌库中包含大约 30k 个单词。如果输入文本由库中不存在的单词组成，则 BERT 标记将该单词分解为相近的单词。

比如拥抱这个词会分裂成 hu 和##gging。如果一个未被识别的单词被认为是一个实体，那么每个被拆分的单词将被赋予相同的标签。

比如(' Hu '，' I-ORG ')，(' ##gging '，' I-ORG ')。

for sequence in comment_list:
  if len(sequence) > 512:
    continue
  tokens = tokenizer.tokenize(tokenizer.decode
                           (tokenizer.encode(sequence)))
  inputs = tokenizer.encode(sequence, return_tensors=”tf”)
  outputs = model(inputs)[0]
  predictions = tf.argmax(outputs, axis=2)
  list_bert = [(token, label_list[prediction]) for token, prediction in zip(tokens, predictions[0].numpy())]

由于 BERT 令牌限制，我将输入句子长度限制为 512。

我将这些词组合起来，并赋予它们各自的实体。这个模型不是 100%准确。因此，一些单词可能会被指定错误的标签。我们在分析中会尽量避免这些不相关的词。

第三部分。数据分析和数据可视化。

我们有三个类别进行分析。这些类别是位置、人名和组织。

从数据中提取的主题和实体的标题。

Title: Research finds that New Zealand beat Covid-19 by trusting leaders and following advice. Citizens had a high level of knowledge about coronavirus and how it spread, and compliance with basic hygiene practices and trust in authorities was at nearly 100%.{‘Location’: [‘UNITED STATES’, ‘ILLINOIS’, ‘GREECE’, ‘TAIWAN’, ‘NEW Z’, ‘ISLAND’, ‘PORTLAND’, ‘NSW’, ‘CANADA’, ‘QUEENSLAND’, ‘VIETNAM’, ‘CHRISTCHURCH’, ‘HAWAII’,’VICTORIA’, ‘UK’, ‘RUSSIA’, ‘WELLINGTON’, ‘INDIANA’, ‘CHUR’, ‘NZ CHINA’, ‘STATES’, ‘ARGENTINA’, ‘CALIFORNIA’, ‘IETNAM’, ‘TRUMPTOWN’, ‘TEXAS’, ‘FRANCE’, ‘AUS’, ‘NZ’, ‘NEW YORK’, ‘JAPAN’, ‘FLORIDA’, ‘QLD’, ‘AUCKLAND’, ‘KE’, ‘USA’, ‘THE’, ‘CHINA’, ‘ITALY’, ‘SWEDEN’, ‘JONESTOWN’, ‘MELBOURNE’, ‘AMERICA’, ‘NEW ZEALAND’, ‘IRAQ’,’US’, ‘AFGHANISTAN’, ‘AUSTRALIA’], ‘Organisation’: [‘YOUTUBE’, ‘FED’, ‘FACEBOOK’, ‘ALLPRESS’, ‘GNELL’, ‘VODAFONE’, ‘IRON’, ‘LIB’, ‘RESERVE BANK’, ‘LANEWAY’, ‘DEMS’, ‘ALJAZEERA’, ‘RVA’, ‘JACINDAS’, ‘CIA’, ‘LABOR’, ‘TREASURY’, ‘SMD’, ‘WHO’, ‘SENATE’, ‘LIBERALS’, ‘LIBERAL’, ‘IIRC’, ‘COVID’, ‘HS’, ‘PRC’, ‘NATIONAL’, ‘TIL’, ‘SHITREDDITSAYS’, ‘COM’, ‘FOX’, ‘EZZANZ’, ‘QLD’, ‘FAMILY FIRST’, ‘NATIONALS’, ‘NIN’, ‘DEFENCE FORCE’, ‘ZZAN’, ‘ACINDA’, ‘FOX NEWS’, ‘LABOUR’, ‘FEDERAL’, ‘HOUSE OF REPS’, ‘WORLDNEWS’, ‘MURDOCH’, ‘GREENS’], ‘Person Name’: [‘KEVIN’, ‘FATHE’, ‘KAREN’, ‘MACRON’, ‘WINSTON’, ‘LES’, ‘BUCKLEY’, ‘CHLÖE SWARBRICK’, ‘COLLINS’, ‘CLINTON’,’JUDITH COLLINS’, ‘TO’, ‘KYLER’, ‘ASHLEY’, ‘BILL GATES’, ‘THE P’, ‘SCOTTY’, ‘HITLER’, ‘TRUMP’, ‘RUPERT MURDOCH’, ‘GATES’, ‘HGO’, ‘WILLIAM CASEY’, ‘OAK’, ‘TOVA’,’JIM JONES’, ‘KEZZA’, ‘ENN’, ‘MERICA’, ‘ROF’, ‘BLOOMFIELD’, ‘GOD’, ‘KIF’, ‘CLIVE PALMER’, ‘DAVE GROHL’, ‘SHER’, ‘BLAIR’, ‘JACINDA ARDERN’, ‘DAD’, ‘JACINDA’, ‘WINS TON PETERS’, ‘LERON’, ‘BLOOMFIELDS’, ‘MURDOCH’]}

以下是我的观察。

1.新西兰的位置在评论中被多次提及。标题中也提到了这个地名。Reddit 用户可能更喜欢国家名称的简称，而不是全称。

例如，美国、新西兰和英国等国家的简称是美国、新西兰和英国。

2.当用户知道某个国家时，他们会提到这个国家的名字。或者他们属于那个国家。因此，我们可以说，对这个帖子发表评论的大多数用户来自新西兰、美国、澳大利亚或英国。

3.杰辛达·阿德恩是新西兰总理，这解释了为什么在大多数评论中提到这个名字。由于话题情绪积极，我可以说评论提到杰辛达·阿德恩的名字也是积极的。

4.我们还可以看到特朗普(美国总统)和比尔·盖茨(微软创始人)的名字。但是提到这些名字的评论的观点并不是决定性的。你可以分别分析那些评论。

5.杰辛达·阿德恩属于执政的工党。反对党是国家党。评论中既有劳工组织的名字，也有国家组织的名字。

6.你也可以看到提及科维德和世卫组织。在组织标签中提到脸书是不确定的，除非你有提到它的评论。

有了这些实体，您就可以预期它是什么类型的数据。你可以把这些数据归入《世界新闻》一类。这些标签将帮助你过滤阅读材料。

如果运行相同的 python 程序，则不会出现相同的主题。因此观察和标记可能会有所不同。

这是从帖子中摘录的位置条形图。

以下是从帖子中摘录的一个组织单词云。

结论

Reddit 是一个很好的社交媒体平台，可以测试 BERT 实体提取模型的准确性。本文将帮助您处理 BERT 模型的输出数据并提取实体。您将了解它的用例，以及如何使用这些标签对文本数据进行分类。

希望这篇文章能帮助你有效地搜索不同的文档。

请在这里找到完整的代码。

自动化你的(无聊！)用 Python 做 Excel 报表！

原文：https://towardsdatascience.com/automate-excel-reporting-with-python-233dd61fb0f2?source=collection_archive---------4-----------------------

创建 Excel 报表(包括图表！)却从未接触过 Excel！

Excel 和 Python 可以成为朋友！资料来源:Nik Piepenbreier

没有什么能逃过 Excel，这没关系！

Excel 无处不在。这是不可避免的，即使有 Python 这样强大的工具供您使用。

没关系！你的老板和同事仍然需要简单的方法来访问重要的数据。

但这并不意味着您不能通过使用 Python 使您的 Excel 工作变得更容易，所有这些都不需要接触 Excel！

使用 Python 自动生成 Excel 报表

你知道你每月、每周(每天)做的那些 Excel 报表吗？)依据？你为不同的客户做同样的事情四五次？

让 Python 来帮你做吧！

我们将要自动化的东西

让我们快速看一下我们将自动化什么！我们将使用我的熊猫数据透视表教程中的数据(我真的建议去看看！).

数据格式与您可能期望从包含客户销售数据的公司数据库中获得的数据格式相匹配。

我们将按区域划分这些数据，并创建两个汇总表，包括格式和图表。所有这些都不需要接触 Excel！

我们的最终数据流—一个工作簿到四个格式化报告。资料来源:Nik Piepenbreier

让我们加载我们的库

我们将依靠熊猫和 Openpyxl。我在我的故事中提到了 Openpyxl 很多，自动化这 3 个(无聊！！)用 Python 做 Excel 任务！它很好地介绍了它是如何运作的。

我们将使用两个库:

  1. 熊猫负责转换我们的数据并创建初始的 Excel 文件
  2. Openpyxl 格式化我们的工作簿并插入图表

加载我们的数据

让我们加载数据，快速浏览一下我们正在处理的内容！

正如我提到的，这些数据意味着类似于您可能从企业数据库系统中获得的数据。

这里，我们使用 pandas 读取 Excel 文件，将日期列解析为日期。

创建我们的数据透视表

让我们创建最终报告中需要的汇总表。

举例来说，让我们为东部地区创建一个数据透视表来测试我们的代码。

创建我们的第一个 Excel 文件

现在我们有了数据透视表，让我们将它加载到一个 Excel 文件中。

为此，我们将使用熊猫来加载它:

让我们快速看一下我们正在做什么:

  • 我们创建一个文件路径变量来标识我们希望文件存储在哪里，
  • 我们使用 ExcelWriter 来保存文件
  • 我们将两个数据透视表保存到单独的工作表中，从第 3 行开始(为以后的标题留下)

让我们的报告更漂亮

Pandas 有利于将数据导入 Excel。现在它已经在那里了，让我们稍微美化一下，并添加一些可视化效果。

这里发生了很多事情。让我们更详细地探索一下吧！

在第 5 节中，我们将工作簿和工作表加载到 Openpyxl 可以处理的独立对象中。

第六节还有一点儿事儿:

  • 我们在单元格 A1 和 A2 中向 sheet1 添加标题和副标题。
  • 我们更改季度列的标题以更好地反映数据。
  • 我们对标题和副标题应用样式。
  • 我们把金融领域的细胞换成货币。这需要一次应用于单个单元格。这就是我们使用 for 循环的原因。

在第 7 节中，我们添加了我们的条形图:

  • 我们创建一个条形图对象，并标识存储数据和类别的字段。
  • 然后将数据和类别应用于对象。
  • 最后，我们添加一个描述性的标题和样式。Openpyxl 使用了许多不同的样式——尝试一下吧！

这是我们的床单现在的样子:

我们得到的工作簿之一。资料来源:Nik Piepenbreier

为多个工作簿自动执行此工作流

虽然这已经很方便了，但是为一个地区这样做只会节省我们一点点时间。让我们用 for 循环对所有区域都这样做。

让我们仔细看看这里:

在第 8 节中，我们创建了一个列表，其中包含了我们想要覆盖的不同地区的所有唯一值。

在第 9 节中，我们在 for 循环中重复前面的代码:

  • 我们创建一个新的变量来保存我们想要保存文件的文件夹的路径。
  • 稍后，我们使用 f 字符串将区域名称插入到我们的脚本中，使其对每个区域都是动态的。

接下来呢？

Python 的好处在于它可以让重复的任务变得可伸缩。

想象一下，每天都收到这个文件，并且每天都必须创建这些工作簿。你每天都为自己节省了大量的时间！

结论

在这个简短的教程中，我们学到了不少东西！我们将一个工作簿转换成一组数据透视表，将它们导出到单独的工作簿中，并对每个工作簿应用格式和图形！

给自己一个鼓励！

如果你对更多类似的内容感兴趣，可以看看我关于 Excel 的其他故事，比如下面这个:

[## 自动化这 3 个(无聊！！)用 Python 做 Excel 任务！

不用再打开数百个 Excel 文件

towardsdatascience.com](/automate-these-3-boring-excel-tasks-with-python-666b4ded101b)

使用 Pandas Profiling 自动进行探索性数据分析

原文：https://towardsdatascience.com/automate-exploratory-data-analysis-with-pandas-profiling-90c1842d838f?source=collection_archive---------40-----------------------

通过使用自动生成的报告，节省可视化和理解数据的时间

来源https://pypi.org/project/pandas-profiling/

根据维基百科，探索性数据分析(EDA)是一种分析数据集以总结其主要特征的方法，通常采用可视化方法。

因此，EDA 是理解底层数据、变量分布及其相关性的过程。这使得 EDA 成为构建任何统计模型之前任何数据科学过程的第一步。

如果你也不知道 EDA 是如何执行的，这里有几个例子可以参考。

https://towards data science . com/explorative-data-analysis-EDA-a-practical-guide-and-template-for-structured-data-abfb F3 ee 3 BD 9

https://www . ka ggle . com/ekami66/detailed-explorative-data-analysis-with-python

但是 EDA 通常是一项非常耗时的任务，它需要你构建多个视图来检查变量之间的分布和交互。

有一些像 info()和 describe()这样的函数确实在一定程度上有所帮助，但是即使使用了这些函数，您仍然需要执行许多手动步骤。

这就是一个名为熊猫档案的非常酷的库派上用场的地方。这个库只需一行代码就能自动生成解释数据的详细报告！

下面快速浏览一下报告的样子。

变量概述:

变量统计:

变量之间的相互作用:

变量之间的相关性:

缺失值的数量:

样本数据:

惊人的正确！

对于每个列，报告中会显示以下统计信息(如果与列类型相关):

  • 类型推断:检测数据框中列的类型。
  • 要素:类型、唯一值、缺失值
  • 分位数统计，如最小值、Q1、中值、Q3、最大值、范围、四分位间距
  • 描述性统计，如平均值、众数、标准差、总和、中位数绝对偏差、变异系数、峰度、偏斜度
  • 最常见的值
  • 柱状图
  • 相关性突出显示高度相关的变量、Spearman、Pearson 和 Kendall 矩阵
  • 缺失值矩阵、计数、缺失值的热图和树状图
  • 文本分析了解文本数据的类别(大写、空格)、脚本(拉丁文、西里尔文)和块(ASCII)。
  • 文件和图像分析提取文件大小、创建日期和尺寸，并扫描截断的图像或包含 EXIF 信息的图像。

除此之外，报告中还介绍了变量之间的相关性和相互作用。

所有这一切只需要一行代码！

安装库

pip install pandas-profiling

导入库

from pandas_profiling import ProfileReport
profile = ProfileReport(df, title=”Pandas Profiling Report”)

您可以直接在 jupyter 笔记本上查看报告，但我更喜欢将报告转换为 HTML 文件，然后在浏览器上查看。

profile.to_file(“your_report.html”)

这将生成一个交互式仪表板，您可以在其中探索您需要的一切。

更多信息和例子，可以参考 https://pypi.org/project/pandas-profiling/的官方文档

尽管这是一个神奇的工具，但它也有一些缺点。在处理大型数据集时，生成报表需要花费大量时间。

解决这个问题的一种方法是使用下面的语法禁用昂贵的计算(如相关性和动态宁滨)。

profile = ProfileReport(large_dataset, minimal=True)

如果你正在寻找更多的例子，看看https://pypi.org/project/pandas-profiling/#examples

希望这有所帮助:)

使用 REST API 和 Python 自动获取 Tableau 服务器用户

原文：https://towardsdatascience.com/automate-getting-tableau-server-users-with-rest-api-and-python-228fe6e7677f?source=collection_archive---------10-----------------------

有多少次有人问你，你能检查一下这些人是否有 Tableau 权限吗？而且，当你打开列表时，它已经超过了 50 封邮件。

作为 Tableau 的网站管理员，最繁琐的任务之一就是向 Tableau 服务器上不存在的无照人员的企业主返回一个列表，以便他们可以请求预算和许可证。

验证和创建最终列表是一个手动过程。很容易出错，如果你有一个很长的输入列表，这将花费许多小时。

我将解释如何使用 Tableau REST API、Tableau 服务器客户端(TSC)和 Python Pandas 与本地 Tableau 服务器管理员用户连接并使用个人访问令牌(PAT)来自动完成这项任务

主要功能如下所示，在本例中，它使用 PAT 登录 Tableau 服务器。

手动步骤

你需要登录服务器，进入用户，点击过滤按钮，逐个搜索邮件或姓名，在另一个工具中做笔记。您不能使用网络浏览器搜索，因为页面是成批加载的，如果您不移动滚动条，它将不会显示您要查找的名称。

设置

如果你没有管理员用户来做测试，你可以以开发者的身份加入并在 https://www.tableau.com/developer/get-site申请一个免费的网站来获得你自己的 Tableau 在线网站

使用 Tab 命令测试连接

在使用 REST API 之前，可以使用 remote Tab 命令测试连接。如果没有，可以只下载安装 Tab 命令转到当前的 Tableau Server 发布页面，你会在页面末尾找到文件。

我打算在 Ubuntu 上使用 Windows 子系统 Linux (WSL2)。您需要安装 java，获取文件，安装 deb 包，刷新您的配置文件，打开一个新的终端(或使用 source 命令)并接受 EULA。

sudo apt update
sudo apt install default-jre
wget [https://downloads.tableau.com/esdalt/2020.3.0/tableau-tabcmd-2020-3-0_all.deb](https://downloads.tableau.com/esdalt/2020.3.0/tableau-tabcmd-2020-3-0_all.deb)
chmod +x tableau-tabcmd-2020-3-0_all.deb
sudo apt install ./tableau-tabcmd-2020-3-0_all.deb
tabcmd --accepteula

使用 Tab 命令测试登录而不检查 SSL 认证:

tabcmd login --no-certcheck -s [https://](https://10ax.online.tableau.com)yourserver[.online.tableau.com](https://10ax.online.tableau.com) -u your_user -p your_password -t your_site

为 Python 安装 REST API 库

我们将按照建议使用 pip 安装 Tableau 服务器客户端(TSC ),文档位于https://Tableau . github . io/Server-Client-python/docs/# install-TSC

pip install tableauserverclient
pip install tableauserverclient --upgrade

代码

我将在 WSL2 和 Ubuntu 中使用 Tableau 服务器客户端和使用 Miniconda 的 Python Pandas。如果你需要更多关于安装的信息，我在这个以前的帖子中留了一个指南

这种联系

有两种方法可以连接到 Tableau 服务器:

  • 使用直接在 Tableau 服务器中创建的本地管理员用户
  • 或者使用个人访问令牌(PAT)

正如文档所说，REST API 和 TabCmd 无法使用 SAML 进行单点登录(SSO)，比如使用 Office 365 Azure Active Directory。如果是你的情况，必须使用 PAT，可从 Tableau Server 2019.4 获得

在这两种情况下，您都必须提供完整的 URL 地址和站点以及登录标识。

如果您有许多站点要连接到默认站点，请将站点清空，如下所示:

site = ''

使用本地用户连接到 Tableau 服务器

使用下一个 Python 代码，您将可以连接到 Tableau 服务器。

使用个人接入令牌(PAT)

首先，您需要在用户设置中创建一个 PAT，您将需要令牌密码和令牌名称。

通过下面的代码，您将使用 PAT 连接到 Tableau 服务器。

使用 REST API 获取用户列表

使用 PAT，我创建了两个函数，一个用正则表达式验证电子邮件，另一个获取 Tableau 服务器用户列表，为文本添加一些清理:

与您的本地列表进行比较

使用 Python Pandas 和 Jupyter Lab，下一节将向您展示如何比较和导出到 Excel 文件。结果应该是 Anir 不存在，Elliot 无证。

我的 Tableau 服务器用户列表如下所示。

我将使用逗号分隔值(CSV)文件和要查找的电子邮件列表。

下一步是创建一个 Pandas DataFrame ，其中包含来自 Tableau 服务器的用户列表，具有前面的功能。

我检查是否有用户在用户名中有无效的电子邮件。

接下来，我将 CSV 文件加载到第二个数据帧

我验证 CSV 中是否有任何用户需要修复无效的电子邮件。

然后，我对两个数据帧进行左连接，以保留 CSV 文件中的所有电子邮件。

我创建了输出来分割有许可证、无许可证或不存在的用户。

并使用 openpyxl 将结果保存到 Excel 文件中

要安装 openpyxl，使用以下命令:

conda install openpyxl
conda update openpyxl

有用的资源

[## REST API

通过 Tableau Server REST API，您可以使用 HTTP 以编程方式管理和更改 Tableau 服务器资源。的…

help.tableau.com](https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api.htm) [## API 参考

重要提示:更多即将推出！本节正在积极建设中，可能不会反映所有可用的…

tableau.github.io](https://tableau.github.io/server-client-python/docs/api-ref#users) [## tableau/服务器-客户端-python

Tableau 服务器 REST API 的 Python 库。为 tableau/server-client-python 开发做出贡献，创建一个…

github.com](https://github.com/tableau/server-client-python/tree/master/samples)

谢谢

最后，我要感谢 Evan Slotnick、Anir Agarwal 和 Elliott Stam，因为他们向我展示了从 Tableau REST API 开始的道路。

快乐万岁！

借助 Google Colab 自动化 Kaggle 竞赛

原文：https://towardsdatascience.com/automate-kaggle-competition-with-the-help-of-google-colab-4c43a6960115?source=collection_archive---------26-----------------------

如何有效使用 colab 笔记本，创建 Kaggle 管道

当我开始研究 Kaggle 问题时，我在 Kaggle 笔记本上工作压力很大。在 Spyder 和 Jupyter 笔记本上工作过之后，我对在 Kaggle 上工作感到不舒服。在找出一些实用程序的过程中，比如增加 RAM、通过 API 加载数据、使用 GPU 等，我发现 Colab 解决方案更容易获得(也许这是 Google 的事情！).我在 Colab 中找到了一些简单的技巧，使使用 Colab 更容易，并创建了一个 Kaggle ML 管道来自动化这个过程。

Google Colab 是一个免费的 Jupyter/IPython 笔记本环境，不需要设置，完全在云中运行。

如何充分利用 Colab？

在创建一个新的 Python 笔记本后，确保将运行时类型更改为 GPU，您将分配到约 12.72 GB RAM 和英伟达特斯拉 P4 或英伟达特斯拉 K80 或英伟达特斯拉 P100 GPU 约 7.1 GB 作为 GPU。通过运行以下命令，可以将内存分配增加到大约 25.51 GB RAM，将 GPU 增加到大约 16 GB。

d=[]
while(1):
  d.append('1')

上面的命令试图扩展(由于‘append’命令)RAM，并在此过程中崩溃。在上次内存分配崩溃后，点击“获取更多内存”。然后，您可以通过运行以下命令来检查分配的 GPU。

!nvidia-smi

Kaggle 管道:

我正在考虑 Kaggle IEEE-CIS 欺诈检测竞赛，我现在将一步一步地分解 colab 中一个典型的 Kaggle 机器学习管道。

1.从 API 调用下载数据集:

首先下载您的 API 令牌，方法是转到您的 Kaggle 我的帐户(https://www.kaggle.com/Your-Username/account))，转到“API”部分，然后单击“创建新的 API 令牌”。您现在将下载一个名为“kaggle.json”的文件。你必须把这个文件上传到你的笔记本上。

from google.colab import files
uploaded = files.upload()

您可以使用下面给出的代码来下载和解压缩数据集。

!mkdir -p ~/.kaggle
!cp kaggle.json ~/.kaggle/
!chmod 600 ~/.kaggle/kaggle.json
!kaggle competitions download --force ieee-fraud-detection
#Unzip the downloaded files
!unzip sample_submission.csv.zip
!unzip test_identity.csv.zip
!unzip test_transaction.csv.zip
!unzip train_identity.csv.zip
!unzip train_transaction.csv.zip

现在，您可以以最有效的方式访问大小约为 1.2 GB 的数据集。

2.预处理和数据争论:

使用熊猫，读取这种规模的数据集有时需要几分钟。为了有效地使用提供的 RAM 和 GPU，我们可以使用 dask 包在不到一秒的时间内读取这些大数据集！！

import dask.dataframe as dd
train_identity = dd.read_csv('train_identity.csv')
train_transaction = dd.read_csv('train_transaction.csv')
test_identity = dd.read_csv('test_identity.csv')
test_transaction = dd.read_csv('test_transaction.csv')
sub = dd.read_csv('sample_submission.csv')
# let's combine the data and work with the whole dataset
train = dd.merge(train_transaction, train_identity, on='TransactionID', how='left')
test = dd.merge(test_transaction, test_identity, on='TransactionID', how='left')

说到数据争论，我接着改变了必要的数据类型，并训练和测试数据分割。这可以根据他们的风格和舒适度来做。你可以通过 colab 为我进行数据角力的步骤。

3.特征工程和特征选择:

这可以根据数据集的类型来完成，自由地创建新的特征并使用特征选择技术，如递归特征消除、BORUTA、基于树的特征选择等。我在“SelectFromModel”的帮助下使用了“sklearn feature_selection ”,并使用“XGBClassifier”来进行特征选择。

4.模型构建:

我使用 XGboost 来拟合数据，使用 gridsearchCV 或 randomsearchCV 或贝叶斯优化等超参数技术来选择参数，这些超参数优化技术的详细版本将包含在以后的博客中。

5。提交文件:

在对测试数据进行验证之后，可以将 Kaggle 的进一步“提交数据”预测添加到管道中，以确保在预测之后下载文件。

请从这个 colab 检查详细的 Kaggle 管道，我在提交文件上收到了大约 0.93 的分数，运行管道的最短时间为大约 5 分钟。然后，我们可以通过更改参数网格和使用不同的模型(如 LightGBM、Catboost、Adaboost 等)来改进模型，从而实现自动化。

专业提示:

除此之外，如果您担心 colab 可能会断开连接，您可以通过在浏览器中单击 Ctrl+ Shift + i，运行下面的一小段 Javascript 代码。

**function** **ClickConnect**(){
console.log("Working"); 
document.querySelector("colab-toolbar-button#connect").click() 
}**setInterval**(ClickConnect,60000)

结论:

处理 Kaggle 竞赛中提供的大型数据集可能是一个耗时的过程。如果我们可以有效地利用 google colab 笔记本来创建管道，那么我们就可以利用 dask 等并行计算库，并有效地使用 GPU 来加速和自动化数据建模过程。

参考资料:

使用 AWS Lightsail 自动化 python 脚本

原文：https://towardsdatascience.com/automate-python-scripts-with-aws-lightsail-b8dfdd5b0a2f?source=collection_archive---------11-----------------------

请跟随我在 AWS Lightsail Ubuntu 实例上自动化 python 脚本的过程。

在我作为一名数据科学家的工作中，我逐渐意识到自动化工作流的每个方面是多么必要。当大多数人听到数据科学这些词时，他们往往会想到机器学习和 AI，但实际上数据科学家的大部分时间都花在了各种工作上。在这篇博客中，我将关注使用 AWS Lightsail 的数据收集自动化。

下面概述的项目都托管在我的 github 上

1.创建一个 AWS Lightsail Ubuntu 实例

2.将专用 IP 地址应用于实例

3.在 Ubuntu 实例上安装 Python3.7 和 PIP

4.将 python 存储库克隆到实例

  • python 脚本将调用 reddit 的 api，并将来自 reddit.com/r/learnpython 的所有提交内容存储到一个 csv 文件中

5.创建每小时运行一次的 cron 作业

在亚马逊网络服务上创建一个 Ubuntu LightSail 实例

如果你是个人开发者或个人项目爱好者，Lightsail 可以帮助你部署和管理基本的云资源。如果你只是需要虚拟专用服务器，亚马逊 Lightsail 是最容易上手 AWS 的方法。Lightsail 包括快速启动项目所需的一切——虚拟机、基于固态硬盘的存储、数据传输、DNS 管理和静态 IP。创建实例后，您可以轻松地连接到它。您可以使用 Lightsail 控制台、Lightsail API 或 Lightsail 命令行界面(CLI)来管理实例。(【https://lightsail.aws.amazon.com/】T4)

首先，你需要在亚马逊 LightSail 注册。第一个月是免费的，这将给你足够的时间来决定这项服务是否是你所需要的。

登录后，您应该会看到 Lightsail 仪表盘。

Lightsail 仪表板

创建一个 Ubuntu 实例

1.单击“创建实例”按钮(上面圈出的)。

2.在 pick your instance image 下，选择 Linux/Unix

3.仅选择操作系统

4.选择 Ubuntu 18.04

创建 ubuntu 实例

5.选择您的实例计划:对于这个项目，我将使用最便宜的选项($3.50)，因为它足以运行大多数 python 脚本。还有，别忘了第一个月是免费的！

6.命名实例:对于这个项目，我将实例命名为“Ubuntu-Automation”

7.选择创建实例

选择创建实例后，您将返回到 AWS LightSail 仪表板。创建 Ubuntu 实例需要几分钟时间。创建实例时，状态将为“待定”,如下图所示:

待定创建

创建实例后，状态将变为“正在运行”。您还将看到分配给该实例的 IP 地址，对于我的实例，IP 地址是 3.227.241.208。此 IP 地址是动态的，每次重新启动实例时都会改变。根据您计划托管的项目，可能有必要设置一个静态 IP 地址。

Ubuntu 实例已创建并正在运行

创建一个静态 IP 地址

创建静态 IP 是可选的，只有在项目需要时才是必需的。我将创建一个静态 IP 地址，因为出于安全原因，我只向这个 IP 地址打开我的 SQL server。在初始设置之后，我更喜欢从我的本地机器 SSH 到 Ubuntu 实例，拥有一个静态 IP 使这个过程更容易。

1.在 Lightsail 仪表板中选择“网络”选项卡

2.点击“创建静态 IP”

网络仪表板

3.在“附加到实例”下选择您的 Ubuntu 实例服务器

4.给静态 IP 一个名称

5.点击“创建”

然后，您应该会看到新的静态 IP 地址。此 IP 地址不会改变。

向前迈进，我的静态 IP 地址将是 18.213.119.58，这是我将在这个项目的其余部分使用。

Python 自动化

对于这个项目，我将创建一个调用 Reddit API 的 python 脚本，并收集来自 reddit.com/r/learnpython.的所有新提交内容。对于本文的范围，我不会回顾这个特定的脚本是如何工作的，但是，你可以在 GitHubLink 查看所有代码。

使用 SSH 连接到 Ubuntu 实例

从 Lightsail dashboard 中，您可以使用基于 web 的 SSH 工具连接到您的 Ubuntu 实例。在初始设置之后，我更喜欢使用 SSH，因为它更简单，但是我确实发现使用基于 web 的工具更容易与我在这篇博客中回顾的设置进行交互。

终端 SSH 连接

在右上角选择帐户>帐户。这将带您到帐户仪表板，您可以在那里下载您的 SSH 密钥。

在 Lightsail 帐户面板中，选择“SSH 密钥”,然后下载。

  • 在本地计算机上，导航到~/。通过运行命令 cd ~/来运行 ssh。嘘
cd ~/.ssh
  • 将下载的密钥复制到此位置
  • 要检查密钥是否已复制到该位置，请运行命令 ls 列出所有文件。(请注意，此方法仅适用于基于 Unix 的操作系统。)
 ls

要通过 SSH 连接，请运行以下命令

ssh -i ~/.ssh/lightsail.pem -T ubuntu@{your_lightsail_IP_address}

我的 Ubuntu 服务器的 IP 地址是 18.213.119.58。为了连接，我将使用以下命令

第一次连接时，您会看到以下消息:

选择“是”连接到您的 Ubuntu 实例。

连接后，您将看到以下内容:

基于 web 的 SSH 连接和本地终端 SSH 连接都是有效的并且可以工作。我只是更喜欢通过终端连接。

在 Ubuntu 实例上获取 python 脚本

我将 python 脚本下载到 Ubuntu 实例的首选方法是通过 Git。

git clone [https://github.com/Landstein/AWS-Lightsail.git](https://github.com/Landstein/AWS-Lightsail.git)

(如果你的 ubuntu 实例上有你需要的配置文件，而你又不想让它托管在 github 上，你可以使用亚马逊的 S3 来传输)

安装 Python3.7 和 PIP

对于安装 Python 和 PIP，我建议通过 Lightsail 仪表板使用基于 web 的 SSH。

在存储库文件夹中运行以下命令，该命令将运行以下代码并安装 Python3.7 和 PIP。

bash install_python.sh

安装 Python 库

接下来安装 python 库 praw 和 pandas。运行批处理文件 python_libraries.sh。

Praw: Python reddit aPI 包装器

熊猫:数据处理和分析

bash python_libraries.sh

设置 Cron 作业

cron 软件实用程序是一个基于时间的作业调度程序，在类似 unix 的计算机操作系统中。设置和维护软件环境的用户使用 cron 来安排作业(命令或 shell 脚本)在固定的时间、日期或间隔定期运行。它通常会自动进行系统维护或管理——尽管它的通用性质使它在从互联网下载文件和定期下载电子邮件等方面非常有用(wikipeida.com)。

为了完全自动化这个过程，最后一步是让 cron 作业定期运行。

对于这个项目，我打算让我的脚本每小时运行 15 分钟。cron 命令将如下所示:

15 * * * * /usr/bin/python3 /home/ubuntu/AWS-Lightsail/learnpython_to_csv.py >> ~/cron.log 2>&1

如果你想尝试为你的 cron 任务设置不同的时间间隔，我建议你先看看https://crontab.guru/。

创建 Cron 作业

使用以下命令将编辑器设置为 vim

export EDIOTR=vim

进入 vim 并编辑 cron 作业

crontab -e

此时，VIM 将启动，您将能够编辑您的 cron 作业。

  1. 按 I 键进入插入模式
  2. 进入插入模式后，将 cron 作业复制并粘贴到编辑器中
  3. 按退出键
  4. 按:(冒号)、w(写)、q(退出)保存并退出 vim
:wq

现在您已经完成了，您的脚本将按照 cron 作业中给定的时间间隔运行。

要检查您的 cron 作业，您可以运行命令 crontab -l 来查看所有当前的 cron 作业。

crontab -l

出于日志记录的目的，打印语句和错误将存储在 cron.log 文件中。

cat cron.log

如果您看到类似的输出，这意味着一切都在工作！

cron.log

设置视频:

基于来自 Google BigQuery 的数据，在 Google Data Studio 中自动生成报告

原文：https://towardsdatascience.com/automate-reports-in-google-data-studio-based-on-data-from-google-bigquery-b7964b2cf893?source=collection_archive---------21-----------------------

来源:沉积照片

将报告配置为使用 Google App 脚本自动更新，并在 Data Studio 中可视化数据

关于使用 Google Data Studio

为那些还不知道数据工作室的人说几句:

  • 首先，Data Studio 很方便，因为它有很多第三方服务的连接器。他们可以很容易地连接到几乎任何数据源。谷歌的原生连接器和其他公司开发的连接器都可用，例如 Yandex。度量，Yandex。目录、脸书、推特等。如有必要，您可以创建自己的连接器。
  • 该服务易于使用，并且易于可视化数据。多个源可以连接到一个仪表板。
  • 在 Data Studio 中与同事共享报告很容易，让他们能够查看或编辑报告。同事不需要获得授权，他们只需点击链接打开仪表板。
  • 该工具的几乎所有功能都可以在免费版本中获得。

下面是 Data Studio 中的一个示例报告，其中包含一个在线商店的主要 KPI 和流量来源:

这是一个交互式控制面板，您可以在其中看到指标如何随时间、渠道、设备类别等发生变化。一份报告中可以有多页。这就是它如此方便的原因:一旦您设置了一个仪表板并与同事共享了一个链接，那么就不需要再做任何更改了(除非您添加了新的参数)。只要选择正确的日期，获取最新的信息。

现在让我们来解释一下如何才能创造出这样的美。我们基于来自 Google BigQuery 的数据构建报告，该报告将根据指定的时间表自动更新。

第一步。从 Google BigQuery 收集数据

BigQuery 有现成的库和连接器，可以让你从 CRM 系统上传交易、客户和项目信息到云存储。OWOX BI 将帮助您自动收集 GBQ: 中的所有其他数据

  • 用户在网站上的行为(未采样的实时数据)。
  • 广告服务的成本数据。
  • 来自通话跟踪系统的通话和聊天数据。
  • 来自电子邮件服务的电子邮件信息。

将不同来源的数据合并到 BigQuery 后，您需要:

  • 使用 SQL-query 选择您希望在报告的单独表格中看到的指标。
  • 使用 Google App 脚本设置一个规则来更新此表中的数据。
  • 在 Data Studio 中，将表与 GBQ 中的数据连接起来，并将其可视化。

用 OWOX BI 组合数据和自动生成报告的示意图如下:

第二步。在 Google BigQuery 中准备一个包含报告数据的表格

我们没有详细描述这些指令，因为我们假设您熟悉 Google BigQuery 接口。如果您需要复习如何处理表创建，请查看这篇文章:Google 中的 BigQuery 数据结构:如何开始使用云存储。

为了节省 Google BigQuery 资源，我们建议您首先创建一个 SQL-query 来生成一个表，其中包含您在特定时间段内需要的一组参数和指标:

进行查询并将结果保存为单独的 BigQuery 表:

然后创建一个视图，只在更短的时间内计算相同的指标。例如，您创建了一个十二月的源表。然后，每天视图将请求昨天的数据并将其添加到表中。

为此，运行另一个查询并单击保存视图:

第三步。创建自动更新表格的应用程序脚本

现在您需要创建一个脚本，该脚本将自动启动视图并将更新后的数据从视图发送到源 BigQuery 表。

为此，打开 Apps 脚本，单击创建脚本，命名它，并编写以下代码，用您自己的表替换项目名称、数据集和 BigQuery 表。

填写表格，在您的电子邮件中获得代码的全文

接收代码

然后单击时钟图标设置脚本运行的时间表。单击右下角的添加触发器按钮。选择时间触发事件源，指定所需的运行频率，然后单击保存。

准备好了！现在，GBQ 表中的数据将根据指定的时间表进行更新。

第四步。在 Google Data Studio 中创建报告

进入 Data Studio 主页，点击左上角的 New，选择 Report。然后点击右下角的 Create Data Source 并选择 BigQuery:

然后指定包含报告数据的项目、数据集和 GBQ 表，并单击右上角的链接:

在打开的窗口中，您将看到存储在连接表中的所有参数和指标，您可以使用这些参数和指标。在这里，如果需要，您可以通过单击右侧指标来重命名它们。

您还有机会创建自己的定制指标。使用“添加字段”按钮和公式(如果您单击问号，会出现帮助):

定义字段后，单击右上角的“添加到报告”按钮:

然后选择可视化工具(图形类型)，并在操控板上突出显示要放置它的区域。

控制面板在右侧打开，您可以根据需要定制报告:添加用于比较的参数、定制过滤器、日期范围、仪表板样式等。

然后剩下的就是使用 Grant Access 按钮与同事共享报告。

使用来自 Google BigQuery 的数据自动生成 Google Sheets 中的报告

原文：https://towardsdatascience.com/automate-reports-in-google-sheets-using-data-from-google-bigquery-e6bb38d745dd?source=collection_archive---------49-----------------------

来源:沉积照片

如何基于来自 Google BigQuery 的数据设置自动更新和发送 Google Sheets 中内置的电子邮件报告

为什么要 Google BigQuery？

在我们谈论设置之前，对于那些不熟悉云存储服务的人来说，先说几句 Google BigQuery 的特性和好处。

Google BigQuery 的优势:

  • 快速云解决方案，让您能够在几秒钟内处理数 TB 的数据
  • 适合小型和大型公司
  • 经济高效且易于扩展
  • 不需要服务器、容量预留和维护
  • 透明的定价策略—只为处理的数据付费，没有隐藏的费用
  • 数据处理的灵活性——用 SQL 访问包含数据的表，还可以使用 JavaScript 函数
  • 可靠性和安全性得到了众多证书的证实——PCI DSS、ISO 27001、SOC 2 和 SOC 3 Type II——因此您可以安全地存储客户的信用卡号、电子邮件地址和其他个人信息

易于自动化数据交换

Google BigQuery 的另一个值得强调的特性是它与外部服务的方便集成。该存储库有大量现成的库和连接器，使得自动化数据交换变得容易。例如，使用 OWOX BI ，你可以从谷歌分析、广告源、电话跟踪服务、电子邮件简讯等导入数据。into BigQuery:

以下是使用 BigQuery 的一些更有用的工具:

BigQuery 数据传输服务

BigQuery 最近推出了一款数据传输服务工具，可以自动传递来自谷歌广告服务的数据。它目前使用以下服务:

  • 谷歌广告
  • 活动经理
  • 谷歌广告经理
  • 油管（国外视频网站）

您可以通过几次点击来设置集成，之后来自这些服务的所有信息都会自动在 BigQuery 中提供给您。

在 Google BigQuery 中组合数据

要基于完整的数据构建报告并实现自动化，您需要在 BigQuery 中组合来自不同来源的数据。这里有一个如何做到这一点的例子:

  1. 首先，在谷歌分析中从你的网站收集数据。
  2. 使用 Google Sheets 从其他来源补充信息。
  3. 添加来自广告服务的成本数据——例如，通过 OWOX BI。
  4. 将所有这些数据导入 BigQuery。如果您是 Google Analytics 360 的客户，您可以使用 BigQuery 导出功能来完成这项工作。如果你没有 Google Analytics 360，你可以连接 OWOX BI，用它将数据从 Google Analytics 导入 Google BigQuery。
  5. 将信息从你的 CRM 和 ERP 系统转移到 BigQuery 并与你网站的数据相结合。
  6. 同样在 BigQuery 中，从任何种类的 Google Sheets 下载更多信息
  7. 如果您使用通话跟踪，请将通话和聊天数据上传到 BigQuery。OWOX BI 集成了五种通话/聊天服务。
  8. 对电子邮件时事通讯做同样的事情。
  9. 最后，使用数据传输服务，它从 Google 和 YouTube 广告服务导入数据

使用 OWOX BI BigQuery 报表附加组件

在您组合了 Google BigQuery 中的所有数据，通过一个关键参数将其链接起来，并构建了必要的报告之后，您可以自动将这些报告上传到 Google Sheets。为此，请使用 OWOX BI BigQuery Reports 插件。它类似于 Google Analytics Sheets 插件，但是需要 SQL 语法知识。要在 BigQuery 中访问数据，您需要构建一个 SQL 查询，之后您将在 Google Sheets 中看到所需结构的数据。

如何基于 Google BigQuery 数据在 Google Sheets 中创建报告

首先，在你的 Chrome 浏览器中安装 BigQuery Reports 插件。为此，打开一个 Google Sheets 文档，转到 OWOX BI BigQuery Reports 选项卡，并选择 Add a new report。

如果这是你第一次使用这个插件，你需要提供你的 Google BigQuery 帐户的访问权限。

图片由作者提供

之后，指定您想要在报告中查看其数据的项目。然后从下拉列表中选择一个 SQL 查询(如果您之前创建了查询)，或者通过单击“添加新查询”添加一个新查询。

图片由作者提供

您可以立即在 SQL 查询中将先前指定的动态参数添加到报表中。选择报告的日期，并通过单击“添加并运行”按钮运行查询。

此时，附加组件将在 BigQuery 中访问您的数据并执行计算。然后，在您的表中，将出现一个单独的工作表，其中包含查询结果。

现在您可以可视化这些数据，创建数据透视表，等等。

图片由作者提供

基于 BigQuery 数据自动更新报告

为了避免每次需要数据时都必须手动运行查询，您可以设置一个计划报告。为此，请转到附加组件–> OWOX BI big query 报告–>计划报告。

选择报告更新的频率(每小时、每天、每周或每月一次)。然后指定开始 SQL 查询的时间。如有必要，激活电子邮件提醒以更新报告。保存设置。

图片由作者提供

完成了。现在，您的报告将根据设定的计划自动更新。

使用 Google App 脚本通过电子邮件发送报告

最后，为了不错过 KPI 中的重要变化，您可以使用 Google App Script 配置通过电子邮件发送报告。

首先，让您的开发人员准备一个脚本，其中包含电子邮件地址和发送消息的条件，可以是定期发送，也可以是响应特定指标的重要更改。

您可以将此代码用作模板:

// Send an email with two attachments: a file from Google Drive (as a PDF) and an HTML file.
 **var** file = DriveApp.getFileById('abcdefghijklmnopqrstuvwxyz');
 **var** blob = Utilities.newBlob('Insert any HTML content here', 'text/html', 'my_document.html');
 MailApp.sendEmail('mike@example.com', 'Attachment example', 'Two files are attached.', {
     name: 'Automatic Emailer Script',
     attachments: [file.getAs(MimeType.PDF), blob]
 });

你可以阅读谷歌帮助中的开发者指南，了解更多关于如何构建这些代码的信息。

然后在表格中打开您需要的报告，进入工具–>脚本编辑器。将会打开一个新窗口，您需要在其中粘贴脚本。

单击时钟图标，设置脚本启动的时间表。现在点击右下角的+添加触发器按钮。然后选择事件源—时间触发器，并从列表中选择通过电子邮件发送报告的频率。最后，单击保存。

搞定了。现在，报告将会发送到您的电子邮件中，您不会错过任何内容，并且能够及时对您的营销活动进行更改。

用 Python 和 Gmail 发送电子邮件

原文：https://towardsdatascience.com/automate-sending-emails-with-gmail-in-python-449cc0c3c317?source=collection_archive---------3-----------------------

用几行代码发送电子邮件

这篇文章将解释如何在 Google 帐户中设置应用程序密码，并使用 Python 在几行代码中发送电子邮件，用于自动报告、测试自动化或 CI/CD 故障通知等。

Google 帐户设置

要使用 Gmail 帐户通过第三方应用程序(如 Python 脚本)发送电子邮件，我们需要设置应用程序密码。出于安全原因，普通 Gmail 密码仅限于网络登录。从 2020 年开始，即使你打开了谷歌账户中的“不太安全的应用访问”选项，也无法使用 Python 脚本中的普通密码登录你的 Gmail 账户。

首先，您需要启用两步验证。只需进入您的 Google 帐户>安全>登录 Google，选择两步验证并按照说明进行操作。

启用两步验证

接下来，创建一个应用程序密码。只需选择“两步验证”下的“应用程序密码”，您将看到如下窗口。在“选择应用程序”下拉列表中选择“其他”。

应用程序密码/步骤 1

输入一个名称，例如 Python，然后单击“生成”。请注意，该名称与 Python 脚本没有任何联系，可以是任何名称。

应用程序密码/步骤 2

然后你会得到一个新的应用程序密码。复制并保存不带空格的 16 字符密码，例如 xnwbjmgvjeeevlgc，以便在 Python 脚本中使用。

应用程序密码/步骤 3

用 yagmail 发送电子邮件

yagmail 是 Python 标准库 smtplib 的包装器，使得发送邮件变得非常容易。

要在 Python 中安装 yagmail，只需运行pip install yagmail。

下面是发送带有两个附件的电子邮件的示例脚本。

这段代码非常简单，不言自明，所以几乎不需要任何解释。除了您的 Gmail 用户名和应用程序密码，您只需定义收件人、主题和内容，就像从 web Gmail 写电子邮件一样。内容是一个列表，第一个元素是正文部分，其余是附件。在本例中，我们从脚本所在的同一文件夹中附加了“pytest.ini”和“test.png”。

要运行这个脚本，只需在任何平台上运行python send_gmail_by_yagmail.py，Windows、Linux 或 MacOS。您将在收件人帐户中收到一封电子邮件，如下所示。

示例电子邮件

要发送一组收件人，只需将“收件人”更改为一个列表。

to = [‘user1@gmail.com’, ‘user2@yahoo.com’]

注意，yagmail 默认使用 gmail SMTP 服务器，你可以显式定义 SMTP 服务器和端口。

host = 'smtp.gmail.com'
port = 465
with yagmail.SMTP(user, password, host, port) as yag:

使用 Python 标准库

我们也可以使用 Python 标准库，不需要安装任何额外的包来发送邮件。

首先，我们导入标准的 email 和 smtplib 包，并定义相关的变量。

  • Gmail 用户名和应用程序密码
  • Gmail 主机和端口
  • 到
  • 科目
  • 正文内容
  • 附件

标准库/第 1 部分

其次，我们用上面的信息定义一个电子邮件对象。消息被定义为 MIMEMultipart，这样我们可以添加附件，每个部分都是一个 MIMEText 对象，它也支持二进制文件。

标准库/第 2 部分

最后，我们调用 smtplib 登录并发送消息。

标准库/第 3 部分

你可以在这里找到完整的脚本 send_gmail_standard_lib.py 。当然要运行，只需输入python send_gmail_standard_lib.py。

Python 3.6+中的变化

上面两个例子支持 Python 3.5 甚至更低版本。Python 3.6 中引入了新的 EmailMessage API 来定义电子邮件。更多细节可以参考最新的文档和一个例子这里。

常见问题解答

在非英语 Windows 操作系统上，您可能会遇到如下 UnicodeDecodeError 错误。

server = smtplib.SMTP_SSL(smtp_host, smtp_port)
  File "C:\Program Files (x86)\Python37-32\lib\smtplib.py", line 1031, in __init__
    source_address)
  File "C:\Program Files (x86)\Python37-32\lib\smtplib.py", line 261, in __init__
    fqdn = socket.getfqdn()
  File "C:\Program Files (x86)\Python37-32\lib\socket.py", line 676, in getfqdn
    hostname, aliases, ipaddrs = gethostbyaddr(name)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc3 in position 2: invalid continuation byte

这似乎是 Python smtplib 模块的一个 bug。原因是您的计算机名包含非英语字符。因此，解决方法是简单地用英文字符重命名您的计算机名。

参考

https://github.com/kootenpv/yagmail
https://mp.weixin.qq.com/s/AMYeOiMX7URc_PFczqQ-5Q
https://docs.python.org/3/library/smtplib.html
https://docs.python.org/3/library/email.html

Reddit Post: TextBlob 和 VADER 的自动化情感分析流程

原文：https://towardsdatascience.com/automate-sentiment-analysis-process-for-reddit-post-textblob-and-vader-8a79c269522f?source=collection_archive---------24-----------------------

使用 VADAR 和 TextBlob python 库找到 Reddit 子群的情绪

被困在付费墙后面？阅读这篇文章，我的朋友链接在这里。

来源:图片由凯文·菲利普斯来自 Pixabay

你有没有想过如何从一个用户的评论中找到一个 subreddit 的情绪？或者想在加入之前检查不同主题的 subreddit 极性？如果你正在寻找这些问题的答案，那么这篇文章将会给你很大的帮助。在这篇文章中，我们将发现 subreddit 的整体情绪。

这里给不知道什么是 subreddit 和 reddit 的人解释一下。

Reddit

Reddit 是一个社交分享网站，它分为更小的社区，称为子社区。subreddit 只是一个专门讨论特定主题的板块。

用户，Reddit 的组成部分，加入这些社区并提交他们的想法和经验。然后，其他用户通过对这些想法的评论来表达他们的观点。

开始了解情绪分析所需的库:

1.PRAW

Reddit 提供了一个 API 来从他们的站点获取信息。我们将使用 Python 库 PRAW 与 Reddit API 进行交互。

2.VADER

VADER (Valence Aware 字典和情感推理器)是一个基于词典和规则的情感分析工具，专门针对社交媒体中表达的情感。我们将使用 VADER 对 Reddit 评论和话题进行情感分析。

3.文本 Blob

TextBlob 是一个用于处理文本数据的 Python 库。它为自然语言处理(NLP)任务提供了一个 API，如词性标注、名词短语提取、情感分析、分类、翻译等。

注意:代码的最终版本可以在本文末尾找到。

让我们导入这些库

import praw
from textblob import TextBlob
# VADER can be accessed by the NLTK library.
import nltk
# Download the VADAR tool and access it through the NLTK library.
nltk.download(‘vader_lexicon’)
from nltk.sentiment.vader import SentimentIntensityAnalyzer

在我们开始收集情绪分析数据之前，我们需要创建一个 Reddit 应用程序。访问此页面创建一个应用程序，并获取所需的身份验证和详细信息。

reddit_api = praw.Reddit(client_id=’my_client_id’,
                         client_secret=’my_client_secret’,
                         user_agent=’my_user_agent’)

Reddit_api 对象与 Reddit API 建立连接。我们将使用它的函数获取帖子和评论等子编辑信息。

我们使用 showerthoughts subreddit 来获得前 5 名每周帖子的数据。如果您想检查其他子编辑的极性，只需用您的子编辑名称替换 showerthoughts 即可。

top_posts = Reddit.subreddit(‘showerthoughts’).top(‘week’, limit=5)

此外，我们可以用小时、月和年来代替周。该限制将帖子限制为 5 个。有关 Reddit API 配置的更多信息，请访问本页。

下一步是获取每个子编辑中的数据:文章标题、评论和回复。subreddit 上的帖子分为两部分，标题和评论部分。有些标题有一小段描述，代表文章作者的观点。大多数投票的评论及其回复显示在评论区的顶部。

标题部分的实现

for submission in top_posts:
     print("Title of the post :", submission.title)

注释部分的实现

我已经使用递归复制了 subreddit 帖子的整个评论部分。

def replies_of(top_level_comment,
               count_comment,
               sub_entries_textblob,
               sub_entries_nltk):
    if len(top_level_comment.replies) == 0:
        count_comment = 0
        return
    else:
        for num, comment in enumerate(top_level_comment.replies):
            try:
                count_comment += 1
                   print(‘-’ * count_comment, comment.body)
                   text_blob_sentiment(comment.body,
                                       sub_entries_textblob)
                   nltk_sentiment(comment.body, sub_entries_nltk)
            except:
               continue
            replies_of(comment, 
                       count_comment,
                       sub_entries_textblob,
                       sub_entries_nltk)

Reddit 帖子的标题和评论部分

情感分析所需的子编辑数据现已可用。我们将在 TextBlob 工具中传递数据，并获取情绪。

def text_blob_sentiment(review, sub_entries_textblob):
    analysis = TextBlob(review)
    if analysis.sentiment.polarity >= 0.0001:
        if analysis.sentiment.polarity > 0:
            sub_entries_textblob[‘positive’]=
                              sub_entries_textblob[‘positive’]+1
            return ‘Positive’
    elif analysis.sentiment.polarity <= -0.0001:
        if analysis.sentiment.polarity <= 0:
            sub_entries_textblob[‘negative’]=
                             sub_entries_textblob[‘negative’] + 1
            return ‘Negative’
    else:
        sub_entries_textblob[‘neutral’]=
                             sub_entries_textblob[‘neutral’] + 1
        return ‘Neutral’

TextBlob 的所有函数都可以从分析变量中访问。我们将使用 analysis .情操来了解句子的极性得分。根据极性得分，我们将句子分为阳性、阴性和中性。所有句子的情感已经被统计并存储在变量 sub_entries_textblob 中。

对 VADER 工具遵循相同的过程，传递数据，并将情感存储在 sub_entries_nltk 中。

sia = SentimentIntensityAnalyzer()
def nltk_sentiment(review, sub_entries_nltk):
    vs = sia.polarity_scores(review)
    if not vs[‘neg’] > 0.05:
        if vs[‘pos’] — vs[‘neg’] > 0:
            sub_entries_nltk[‘positive’]=
                                 sub_entries_nltk[‘positive’] + 1
            return ‘Positive’
        else:
            sub_entries_nltk[‘neutral’]=
                                 sub_entries_nltk[‘neutral’] + 1
            return ‘Neutral’
    elif not vs[‘pos’] > 0.05:
        if vs[‘pos’] — vs[‘neg’] <= 0:
            sub_entries_nltk[‘negative’]=
                                sub_entries_nltk[‘negative’] + 1
            return ‘Negative’
        else:
            sub_entries_nltk[‘neutral’]=
                                 sub_entries_nltk[‘neutral’] + 1
            return ‘Neutral’
    else:
        sub_entries_nltk[‘neutral’]=sub_entries_nltk[‘neutral’] + 1
        return ‘Neutral’

我们可以使用 sia 对象访问 VADER 函数。sia.polarity 将一个句子作为输入，并将情感得分作为输出。从 nltk _ 情操()句子分类成积极，消极和中性的情绪。

如果您打印 sub_entries_nltk 和 sub_entries_textblob 变量，我们将获得正面、负面和中性情绪的总数。从计数中，我们将得出子涡旋的总体极性。

结论

在本文中，人们可以学习如何使用 PRAW python 库从 Reddit 获取信息，并发现 subreddit 的观点。此外，了解文本块和 VADER 工具是如何轻松实现情感分析的。这篇文章帮助你复制 subreddit 帖子的整个评论部分，并附上每个评论及其回复。

作者其他文章

  1. EDA 的第一步:描述性统计分析
  2. 路透社文章的文本数据分析和可视化
  3. 使用罗伯塔模型发现 Reddit 子群的情绪

这是完整的代码

自动化枯燥的工作:如何从命令行创建并打开一个名为 Jupyter 的笔记本

原文：https://towardsdatascience.com/automate-the-boring-stuff-how-to-create-and-open-a-named-jupyter-notebook-from-the-command-line-5efe9a6fbcad?source=collection_archive---------46-----------------------

今天我醒来，我意识到即使我喜欢自动化事情，我还是不断重复下面的行为:

  1. 我决定开始一项新实验。
  2. 我在终端上运行 jupyter-notebook 。
  3. 我在仪表板中创建了一个新笔记本。
  4. 我给笔记本重新命名。
  5. 我开始黑。

我一直想输入jupyter-notebook experiment . ipynb，然后出现一个命名的笔记本。这将为我节省大约 10 秒钟的宝贵时间，我可能会用这些时间来研究更多关于冠状病毒的数字！

因此，这里有一个在你的生活中永远不要给笔记本重新命名的快速方法。它在 MacOs 和 Linux 上运行得非常好，你也可以在 Windows 上做类似的事情。

  1. 打开您的 bash 个人资料。我的位于/。*bash*RC(“”自动展开到你的主目录)。
  2. 将以下代码添加到文件的底部:
new-notebook() {
    echo "{
 \"cells\": [],
 \"metadata\": {},
 \"nbformat\": 4,
 \"nbformat_minor\": 2
}" > $(pwd)/$1

    jupyter-notebook $(pwd)/$1
}

3.关闭并重新打开终端，或者运行 source ~/.bashrc. 这将让您开始使用刚刚创建的函数。

全部完成！资料来源:亚历山大·奈特(CC0)

如果您键入new-notebook example . ipynb，它将在当前工作目录中创建一个同名的新笔记本，并立即打开它。

请注意，该命令假设您将包含。文件名中的 ipynb 扩展名。如果您想避免这样做，只需修改函数代码，如下所示:

new-notebook() {
    echo "{
 \"cells\": [],
 \"metadata\": {},
 \"nbformat\": 4,
 \"nbformat_minor\": 2
}" > $(pwd)/$1.ipynb
 #or maybe 'jupyter-notebook', if that's what you use
    jupyter-notebook $(pwd)/$1.ipynb
}

重新激活 bash 概要文件后，您现在可以使用该命令，例如，使用 new-notebook example2 。

一个建议:我建议不要尝试使用 jupyter-notebook 作为命令名。一方面，我发现的唯一重载 bash 函数的技巧相当令人讨厌，可以说**最少。另一方面，如果我们不乐观，重载 jupyter-notebook 命令的意外行为可能会导致数据丢失。为了安全起见，最好用一个新名字！

学到了什么？单击👏说“谢谢！”并帮助他人找到这篇文章。

利用 Sklearn 管道实现机器学习模型的自动化

原文：https://towardsdatascience.com/automate-the-machine-learning-model-implementation-with-sklearn-pipeline-2ef1389062c9?source=collection_archive---------69-----------------------

在本教程中，我们将了解如何加快机器学习算法开发中的模型实现步骤。

在 Unsplash 上由 Hitesh Choudhary 拍摄的照片

很多时候，在处理机器学习问题时，我们会遇到这样的机器学习任务，我们希望预处理我们的数据，并用不同的分类器测试我们的模型，以选择最佳的一个。在这种情况下，在训练数据上单独拟合每个分类器，然后测试模型是非常繁琐的，更不用说还涉及到大量的冗余编码。此外，如果您的算法涉及交叉验证，并且您的预处理步骤涉及规范化或标准化等操作，则在学习之前对完整的训练集执行规范化或标准化将会影响测试集的规模。如果所有这些问题都有一个单一的解决方案，那不是很好吗？

嗯，有！Scikit-Learn 有一个管道模块，它提供了解决上述问题的简单方法。

Pipeline 是一个按顺序应用一系列变换和一个最终估计器的函数。管道的目的是组装几个步骤，这些步骤可以在设置不同参数的同时进行交叉验证。

现在让我们来看一个实现，它将展示我们如何使用管道来简化手头的任务。

在这里，我将使用 Iris 数据集，将其标准化，并测试分类器的数量，以查看哪一个给出了最佳结果。在这里，我将使用 KNN、SVM、随机森林和逻辑回归来测试算法。

首先，我们需要导入所有需要的模块。

现在，我们将从 Scikit-Learn 导入 Iris 数据集，并将其分成训练集和测试集。

接下来，我们将从 Scikit-Learn 中列出分类器名称及其各自的功能。最后，把它们连在一起。这一步将确保我们将所有分类器连同它们的名称一起一次性传递给我们的管道函数。

这里需要注意的一点是，我们将为所有分类器的所有超参数选择默认值。

现在，我们将定义将分类器的 zip 以及训练和测试数据作为输入的函数，准备带有分类器的 Standardscalar 管道，并将管道的结果馈送到我们稍后将定义的 fit_classifier() 函数。

最后，我们定义前面提到的 fit_classifier() 函数。该功能接收管道和列车测试数据。它用 pipeline.fit() 拟合管道来训练数据，计算预测和准确度分数。

现在是时候测试我们的算法了。

运行上面的行之后，我们得到以下结果。

分类器和准确度分数

最后，我们将看到分类器及其各自的准确度分数。

上面的运行给出了以下结果。

决赛成绩

你有它！我们刚刚看到 Scikit-Learn 的管道功能如何让生活变得更简单。

如果你觉得有用，不妨在这里 多看看我的文章 。

如果你有什么建议，请在评论里告诉我。

自动化这 3 个(无聊！！)用 Python 做 Excel 任务！

原文：https://towardsdatascience.com/automate-these-3-boring-excel-tasks-with-python-666b4ded101b?source=collection_archive---------3-----------------------

不用再打开数百个 Excel 文件

让我们来学习如何自动化一些枯燥的 Excel 任务！资料来源:Nik Piepenbreier

Excel 无处不在。无论好坏，它基本上是工作场所中数据分析的默认应用程序。在你的日常生活中，你可能需要完成许多无聊的任务，这让你思考，“一定有更好的方法”。Python 在那边！

所有这些例子在 VBA 都是可能的，但是 VBA 可能很乏味，嘿，我们喜欢 Python！

合并多个 Excel 文件

让我们将多个 Excel 文件合并成一个文件！资料来源:Nik Piepenbreier

您可能会发现自己有许多 Excel 工作簿(例如每月销售报告)。有一天，你被要求计算所有这些报表的总销售额。我们可以使用 Pandas 库轻松地将 Excel 工作簿与 Python 结合起来。

您可以使用 pip 或 conda 安装 Pandas:

pip install pandas
conda install pandas

对于本教程，让我们加载三个独立的 Excel 工作簿，它们链接到下面:

我们可以看到数据直到第 4 行才真正开始，所以我们需要 Pandas 从那一行开始导入工作表。在下面的代码中，我们将使用 read_excel 和 append 函数。

将 Excel 文件与 Python 相结合。资料来源:Nik Piepenbreier

让我们看看我们在这里做了什么:

  1. 在第 1 部分中，我们导入了 pandas，创建了一个包含所有 URL 的列表，并生成了一个名为 combined 的空白数据帧。
  2. 在第 2 节中，我们遍历了文件中的每个 URL，将每个文件读入一个数据帧(“df”)，跳过前三行，并将其附加到组合的数据帧中。
  3. 在第 3 节中，我们编写生成一个名为 combined.xlsx 的新 Excel 文件，其中包含我们合并的 Excel 工作簿！

从各种工作簿中获取值

使用 Python，很容易从多个文件中获得任何值！资料来源:Nik Piepenbreier

我们再来看另一个例子！假设我们只需要从每个销售报告中获得多伦多的总数，并将它们收集到一个列表中。我们知道总数存储在每个工作簿的单元格 F5 中。如果您正在跟进，如果您将文件存储在本地，这个包就可以工作。用上面的链接下载文件并保存到你的机器上。

对于这个例子，我们将使用另一个名为 openpyxl 的库。您可以使用以下代码安装 pip 或 conda:

pip install openpyxl
conda install openpyxl

让我们开始编码吧！

用 Python 从多个工作簿中获取单元格。资料来源:Nik Piepenbreier

让我们一步一步地分解它:

在 Windows 中复制文件路径。资料来源:Nik Piepenbreier

在第 1 节中，我们:

  • 生成了一个包含所有文件链接的列表(“文件”)。在 Windows 中，我们可以按住 Shift 键并单击鼠标右键，然后使用“复制为路径”来获取它的路径。
  • 您可能希望将字符串转换为原始字符串，方法是在它前面加上前缀“r”。
  • 我们还生成了一个空列表来存储我们的值。

在步骤 2 中，我们

  • 使用 openpyxl 遍历文件。
  • 的。load_workbook()方法加载一个文件。
  • 我们使用['Sheet1']和['F5']来引用工作簿和工作表对象中的工作表名称和单元格引用。
  • 最后，我们使用。value 属性提取单元格的值，并将其追加到值列表中。

在工作簿中应用公式

让我们在多个工作簿中应用相同的公式！资料来源:Nik Piepenbreier

让我们看看最后一个例子！在每个 Excel 工作簿中，我们都有跨行的汇总，但没有销售额的总计。同样，我们可以打开每个工作簿并添加一个公式，或者我们可以使用 Python 来完成这项工作！

我们将再次使用 openpyxl。如果您需要安装它，请查看上面的说明。上面也有下载文件的链接。

在工作簿中插入公式！资料来源:Nik Piepenbreier

在这段代码中，我们再次填充了一个文件列表。for 循环打开每个文件，并将“Sheet1”分配给一个变量 Sheet。

然后，我们将字符串' =SUM(F5:F8)'赋给单元格 F9，并使用。属性将货币样式直接分配给单元格。更多单元格样式可在官方文档中找到。

结论:用 Python 自动化 Excel

Python 使得使用 Excel 文件变得非常容易！在本文中，我们学习了如何组合各种 Excel 文件、获取特定值以及在工作簿中添加公式。

让我们使用 Python 创建可追踪的、可复制的代码，让我们复制我们的分析设计。虽然您可能一整天都在使用 Excel 工作簿，但是 Python 可以自动完成一些随之而来的繁琐任务。

使用 Airflow 自动将云 SQL 数据同步到 BigQuery

原文：https://towardsdatascience.com/automate-your-cloud-sql-data-synchronization-to-bigquery-with-airflow-7f9d992da18f?source=collection_archive---------14-----------------------

使用私有 IP 连接和云 SQL 代理保护您的数据和工作负载

斯科特·韦伯在 Unsplash 上拍摄的照片

如果你正在使用 GCP (Google Cloud Platform)来存储你的数据，很可能你正在使用 BigQuery 作为你的数据仓库或者数据湖解决方案(或者作为它的一部分)。存储交易数据的一些解决方案包括数据存储、云扳手和云 SQL。在许多情况下，尤其是从本地迁移到 GCP 时，云 SQL 是事务性数据的自然选择，因为它提供了托管 MySQL 和 PosgreSQL。

有许多方法可以将云 SQL 数据同步到 BigQuery。一个解决方案是使用带有云 SQL BigQuery 特性的联邦查询。尽管这种解决方案具有速度快、成本低的优势，但它至少有一个限制:还不可能将云 SQL 联邦查询与私有云 SQL 实例一起使用，这意味着留给您的是不太安全的公共实例。本文介绍了一种高度安全、自动化和生产就绪的方式，将您的云 SQL 数据导入 BigQuery。

你会得到什么

在本文结束时，您将获得

  1. 在 GCP 上构建云 SQL 数据同步到 BigQuery 工作流的详细分步指南。
  2. 访问包含用于构建工作流程的所有材料的 gitlab 存储库。您将能够使用存储库代码作为实现您自己的数据同步工作流的起点。

你需要跟进什么

这篇文章对于至少对 GCP 有基本了解的读者来说是最有价值的。如果你想知道这三个字母代表什么，我建议你花点时间在这里好好了解一下 GCP。我还假设你接触过阿帕奇气流和库伯内特斯。如果不是这样，你可以在 Udemy 上查看这篇优秀的气流介绍。你也可以在这里找到 Kubernetes 的快速入门。

要跟进，你需要的是一个 GCP 项目。如果你没有可用的项目，或者如果你只是想在现有项目中不产生任何费用的情况下尝试一下，你可以创建一个新的谷歌账户，并使用该账户创建一个免费的 GCP 账户和项目。

你会做什么

在接下来的几分钟内，您将:

  1. 设置 Apache 气流
  2. 创建云 SQL 实例
  3. 设置 Airflow 和云 SQL 之间的私有连接
  4. 创建大查询数据集
  5. 编写和部署数据同步任务
  6. 将新的模拟数据插入云 SQL
  7. 监控同步任务

设置 Apache 气流

请记住，Airflow 是一种工具，其目的是协调、自动化和监控批处理作业。在我们的上下文中，实际的同步工作是通过调用 GCP API 来完成的，我们将在 编写和部署数据同步任务 时看到。

在 GCP 上安装 Airflow 有很多选择，包括在谷歌计算引擎或谷歌 Kubernetes 引擎上定制安装。在这里，我们部署了一个 Google Cloud Composer 环境资源，它提供了一个 GKE 集群(以及其他 GCP 资源),并在该集群上安装了 Airflow。

要创建部署，请执行以下操作:

  • 打开您的云 shell，并将其配置为使用正确的 GCP 项目。将<project_id>替换为您打算使用的 GCP 项目的 ID:</project_id>

  • 如果适用，启用编写器 API(这可能需要 2 分钟)

  • 创建一个名为“cloud-composer”的服务帐户，并为其指定角色“roles/composer.worker”、“roles/cloudsql.client”、“roles/bigquery.user”和 roles/bigquery.dataEditor。

  • 使用 VPC 本地和专用 GKE 集群创建名为“data-synchronization-env”的 composer 环境。请耐心等待，直到 设置好气流和云之间的私有连接 SQL 我会在这里详细介绍一下 VPC 本地和私有 GKE 集群。为环境分配“cloud-composer”服务帐户。分配给服务帐户的云 SQL 和 BigQuery 角色由 Airflow 用来读取云 SQL 数据库和创建 BigQuery 同步表。

大约 30 分钟后，您的 cloud composer 环境应该在 GCP 项目的默认 VPC 网络中启动并运行。

创建云 SQL 实例

我们的云 SQL 到 BigQuery 同步架构的主要优势之一是，它实施了安全最佳实践。实际上，我们将使用私有实例，而不是为云 SQL 数据库使用公共实例。

在创建私有云 SQL 实例之前，我们需要在 GCP 项目中的 VPC 网络(这里我们选择“默认”VPC 网络)和云 SQL 实例所在的 VPC 网络之间创建一个 VPC(虚拟私有云)对等连接。“默认”网络上的实例将能够使用该 VPC 对等连接连接到私有云 SQL 实例。要了解更多关于创建云 SQL 私有实例的信息，请查看这个。

以下四个命令创建一个云 SQL MySQL 私有实例:

  • 如果适用，启用服务网络 API

  • 创建一个地址范围，并使用它来创建 VPC 对等连接。用您的项目 id 替换<project_id>(这可能需要 1 分钟)。</project_id>

  • 创建云 SQL 私有实例

为了能够连接到 SQL 实例，让我们创建一个云 SQL 用户。我还将创建一个数据库，我们将在本文后面将其同步到 BigQuery。

  • 创建云 SQL 实例用户，用适当的值替换<user_name>。主机“cloudsqlproxy~%”的值使得无法从云 sql 代理服务器进程之外的其他地方连接到用户<user_name>的实例。</user_name></user_name>

  • 在云 SQL 实例中创建一个数据库。称这个数据库为“经典模型”

  • 从其 sql 转储文件中导入流行的‘classic models’数据库。为此，我们首先创建一个 GCS bucket。为了方便起见，用您的 GCP 项目的名称来命名这个存储桶。

  • 复制 GCS (Google 云存储)中的 sql 转储文件。

  • 检索云 SQL 实例正在使用的服务帐户:注意“serviceAccountEmailAddress”字段的值

  • 将存储桶“cloudsql-to-bigquery”上的 storage.objectAdmin 角色授予该服务帐户。用上一步中检索到的电子邮件地址替换<service_account_email_address></service_account_email_address>

  • 执行转储文件导入

设置 Airflow 和云 SQL 之间的私有连接

回想一下，我们的 Airflow 安装运行在一个私有的 VPC 本地 GKE 集群上。一方面，顾名思义，私有集群是一种没有为工作节点分配公共 IP 的集群。事实上，我们不需要通过互联网公开我们的 GKE 工人。首先，将公共 IP 分配给工作节点可能会导致安全漏洞。其次，公共 IP 在这里没有用，因为云 SQL 实例不能通过公共 IP 连接访问。

另一方面，VPC 本地意味着 GKE 集群使用别名 IP 地址范围将流量从一个 pod 路由到另一个 pod。事实上，就 IP 路由而言，VPC 本地 GKE 集群有许多有用的好处。例如，当启用 VPC 本地模式时，集群 VPC 网络和通过 VPC 网络对等连接到它的任何网络之间存在本地路由。更多关于 VPC 本地集群的信息可以在这里找到。

如果到目前为止，为气流创建的 GKE 集群正在名为“default”的默认 VPC 内运行。至于云 SQL 实例，它运行在一个 VPC 网络中，该网络位于一个由 GCP 代表我们管理的项目中。既然 GKE 的工作人员属于两个不同的网络，并且没有公共 IP，他们怎么可能与 SQL 实例通信呢？

还记得我们之前在我们的项目“默认”VPC 网络和云 SQL 实例所在的 VPC 网络之间建立了一个 VPC 对等连接。这意味着我们的 GKE 工作人员和我们的云 SQL 实例可以通过私有 IP 连接进行本地通信，这要归功于启用了 VPC 本地模式。您可以在云控制台上找到有关这种对等的详细信息。

打开云控制台，点击菜单(左上角的汉堡图标)，向下滚动直到找到‘VPC 网络’。悬停在“VPC 网络”上。在下拉列表中，单击“VPC 网络对等”。

GKE 集群 VPC 网络和云 SQL 托管网络之间的 VPC 对等连接，图片由作者提供

此时，我们已经为云 SQL 到 BigQuery 的同步作业做好了准备，因为执行这些作业的 GKE 工作人员无法从互联网上访问。然而，我们可以更进一步，加密 GKE(或气流)和云 SQL 之间的连接。

传统上，这是使用 SSL 证书完成的，这意味着配置和管理 SSL 证书的开销。

加密到云 SQL 实例的连接的一种更简单的方法是使用云 SQL 代理。云 SQL 代理的工作方式是，让一个本地进程(称为代理客户端)运行在连接发起的环境中，让一个“远程”进程(称为代理服务器)运行在与云 SQL 实例相同的环境中。请访问这个文档，获得关于云 SQL 代理的全面解释。

我们在 GKE 上安装 SQL 代理，方法是创建一个运行 SQL 代理进程的 pod，然后创建一个服务在内部向集群公开该 pod。

但是在到达那里之前，我们需要设置 kubectl 二进制文件来与集群通信。为了实现这一目标:

  • 通过运行以下命令获取 GKE 群集名称。复制“名称”字段下的值

  • 连接到集群并配置 kubectl 二进制文件。用先前命令的值替换<cluster_name></cluster_name>

  • 获取云外壳服务器 IP 地址

  • 将云 shell 服务器列入白名单，以便 GKE 集群主服务器接受来自它的传入连接。确保在上一步中将<cluster_name>替换为集群名称，将<shell_server_ip_address>替换为 IP 地址</shell_server_ip_address></cluster_name>

我们现在准备在 GKE 集群上安装 SQL 代理。首先，在集群中为代理相关资源创建一个名称空间。为此，创建一个空文件，并将其命名为“namespace.yaml”。然后将以下内容复制到文件中:

创建 cloud-sql-to-bq 命名空间的 GKE 清单

现在创建名称空间:

然后创建一个名为“pod.yaml”的文件。然后将以下内容复制到文件中。请确保用您的 GCP 项目 ID 的值替换<project_id>。</project_id>

创建云 sql 代理 pod 的 GKE 清单

继续创建运行云 SQL 代理流程的 pod

现在，代理运行在 GKE 集群内的 pod“cloud-SQL-proxy”的容器“airflow-sqlproxy”中。最后，创建一个名为“service.yaml”的文件，并向其中添加以下内容。

创建云 sql 代理服务服务的 GKE 清单

将该清单应用到 GKE 集群，以实际创建服务，该服务将代理流程公开给集群中运行的其余 pod。

就是这样！我们已经在 GKE 工作者(以及气流工作者)和云 SQL 实例之间配置了一个私有的加密连接。架构现在看起来像这样:

架构图:为 Airflow 和云 SQL 之间的通信而设置的云 SQL，图片由作者提供

创建大查询数据集

在您的 GCP 项目中创建一个 bigquery 数据集，以保存将要从云 SQL 同步的所有表。

编写和部署数据同步任务

从云 SQL 到 BigQuery 的实际数据同步是由 Airflow DAG(有向无环图)处理的。DAG 由三个任务组成:

  • 第一个任务将数据从云 SQL 实例数据库“classicmodels”导出到之前创建的 GCS 存储桶。这是使用气流MySqlToGoogleCloudStorageOperator完成的

到云 SQL 实例的连接是私有的和加密的(因为使用了私有实例和云 SQL 代理)，并使用 Airflow 连接字符串“cloud_sql_proxy_conn”。

要配置此连接字符串:

  1. 打开气流用户界面。打开云控制台。接下来，单击控制台右上角的菜单栏。向下滚动直到找到“Composer”并点击它。然后点击“数据-同步-环境”菜单。在出现的水平栏上，单击“环境配置”。下一步向下滚动，直到你找到“气流网络用户界面”。单击“Airflow web UI”旁边的链接。使用正确的 google 帐户进行身份验证。气流用户界面如下所示:

气流用户界面，图片由作者提供

2.点击“管理”并在打开的下拉列表中选择“连接”。使用以下信息创建连接。将<user_name>替换为您之前创建的云 SQL 实例用户名，并点击“保存”。</user_name>

MysqlToGoogleCloudStorageOperator 的气流连接

  • 第二个任务使用GoogleCloudStorageToBigQueryOperator将数据从 GCS 存储桶导入 BigQuery 表

  • 第三个任务通过 BigQueryOperator 从第二步创建的表中创建一个聚合表。为了使事情看起来更具体一些，我在这个任务中根据销售数字计算了 classicmodels 示例数据库中的前 5 名雇员。

  • 创建一个名为“cloud_sql_to_bq.py”的文件，并将 DAG 代码片段复制到其中。

  • 通过查找字段“dagGcsPrefix”的值来检索云合成器 dags 目录的名称

  • 将文件“cloud_sql_to_bq.py”复制到 Cloud Composer dags 目录中

过一会儿，您的 DAG 应该开始运行，当它结束时，您应该在 BigQuery 数据集中找到您的新表。

恭喜你！您已经成功部署了数据同步 DAG 并实施了目标体系结构的所有部分:

架构图:云 SQL 数据同步到 BigQuery，图片由作者提供

将新的模拟数据插入云 SQL

为了让同步作业在每次运行时获取新数据，我在 GKE 上创建了一个 CRON 作业，它每 2 分钟运行一次，向“classicmodels”数据库的“employees”表添加新数据。

我不会在这里花太多时间讨论新的数据插入过程，因为它偏离了我们的主题。如果你有兴趣了解更多关于我是如何实现这个过程的，请耐心听我讲完，你将会看到一个 Gitlab 库，里面有迄今为止讨论过的所有材料。

监控同步任务

Airflow modern 用户界面(UI)为任务监控提供了许多有用的功能，包括工作流和任务状态、自定义图表、使用标准 SQL 的即席查询。此外，Cloud Composer 还提供本机指标和仪表盘来监控气流作业和 GKE 集群。

同步作业计划每 2 分钟运行一次(在现实生活中，您不会有这么高的运行速度)。下图显示了上次作业运行的结果。

同步作业的成功 dag 运行执行图，按作者显示的图像

总结

在本文中，我展示了一种将数据从云 SQL 同步到 BigQuery 的安全方法，使用完全同步而不是增量同步。完整的代码可以在这个 gitlab 私人仓库中获得。如果你有兴趣，请发一个访问请求给我，地址是 marcgeremie@gmail.com的，我很乐意将你添加到资源库中。

结束注释

可以肯定地说，本文中实现的架构已经可以投入生产了。尽管如此，还是有一些方法可以改进它。其中包括:

  • 为高可用性的云 SQL 实例添加故障转移副本。
  • 为云 SQL 实例添加一个读取副本，并从副本中读取同步作业，而不是直接从主实例中读取。
  • 不要使用在 cloud Composer GKE 集群中运行作业的操作符MySqlToGoogleCloudStorageOperator，考虑使用数据流或 Spark 操作符将表从云 SQL 导出到 GCS。
  • 考虑使用增量同步代替完全同步，以降低作业成本并提高性能。
  • 本文使用了一个 MySQL cloud SQL 实例。然而，它可以很容易地用 PosgreSQL cloud SQL 实例进行复制，只需对命令进行最少的更改。

参考

使用 Python 自动化您的数据管理规程

原文：https://towardsdatascience.com/automate-your-data-management-discipline-with-python-d7f3e1d78a89?source=collection_archive---------21-----------------------

如何提高企业数据质量和简化您的工作流程

照片由亚历山大·奈特从派克斯拍摄

任何与数据打交道的人都知道数据质量的重要性。无论你是在 excel 中进行基本分析，还是用决策树预测销售趋势，糟糕的数据总会让你举步维艰。将责任推给过度工作的数据管理员和贪婪的数据消费者很容易，但最终还是要由数据专业人员来承担这两者之间的联系。那么，您如何提升您企业的数据管理能力并倡导更有效的分析呢？自动化您的数据质量指标。

许多人以多种方式定义了数据质量指标。我喜欢使用 4 V 的和 4 C 的来构建关于质量的对话，因为它们易于记忆、营销和可视化:

4 C 标准

完整性 —预期的数据有多少？“重要”栏是否已填写？

一致性 —数据集之间的数据值是否相同？

符合性 —数据是否符合规定的格式？

好奇心 —利益相关者了解和/或参与了数据管理生命周期吗？

4 V 的

卷 —呈现多少信息？

速度 —输入数据的频率是多少？数据处理和传播的频率如何？

多样性 —存在哪些类型的数据？数据是结构化的、非结构化的还是半结构化的？

真实性 —数据可信吗？有哪些内在的差异？

我用几个 Python 包来快速测量和社会化这些概念。熊猫有很多内置的方法来调查数据:我用的是。描述用条件格式查找模式。为了得到更可靠的报告，我使用了熊猫概况，它可以很容易地嵌入到 Jupyter 笔记本中或者保存到 HTML 文件中。

**import pandas as pd
import** pandas_profilingdf = read_csv("raw_data.csv")
df.describe()profile = pandas_profiling.ProfileReport(df)
profile.to_file("profile.html")

Matplotlib 和 seaborn 是绘制数据的很好的库。我最近一直在探索如何创建快速、通用和引人入胜的可视化效果，可以很容易地嵌入到网站中。这里有一个很棒的指南告诉你如何做到这一点。

企业中的数据规程

到目前为止，我们已经检查了一些陈腐的理论，以构建一个数据质量社会化的概念框架，并拥有可视化和呈现度量的基本工具。是时候自动化了！作为数据专业人员，我们通过揭露脏数据和阐明数据债务来教育和激励企业管理数据以进行有效分析，这一点至关重要。自动化可以通过保持透明度和问责制将最佳实践固化为规程。

我最近在做一个项目，主要关注数据摄取，计算按特许经营分组的 全球产品的利润率。这项努力最初是为了更好地理解盈利能力，但很快就失去了控制。像大多数拥有全球足迹的企业一样，我的客户通过收购将运营成本最小化的公司(如分销商)来简化供应链，从而实现战略增长。

IT 整合跟不上运营计划；以前计算利润的努力被证明是不成功的，因为不同的 ERP 系统(总共超过 15 个)，混乱的术语，高乘务员流动率等。

来自世界各地的数据管理员会派个人。csv 文件通过电子邮件发送给商业智能团队，在企业数据仓库中与发票销售数据手动合并。预先打包的报告被传递给领导层，附带无数的警告，被确信其他利益相关者在稀释数据的数据管理员破坏。数据质量如此混乱以至于基本利润分析的可见性都无法达到，更不用说持续了。精疲力竭的 B.I 小组需要一些帮助！

问题定式化

数据 完整性 和 符合性 给利润计算带来了重大问题:不完整的数据会以多种不同的格式从没有结构的管理者那里涌入。 流速 不一致，不经常从各个群体中流出，在那里名声不佳 准确性低 。

最终，我将通过对利润计算进行高级分析来解释盈利能力和市场份额，从而为项目做出贡献。但是，如果没有有效的数据管理来计算数据科学管道中的利润率，我有很多机会来自动化一个有效的管道，并告知利益相关者数据质量。

战略

我们与数据管理员、所有者和治理委员会合作，仅确定利润计算所需的相关值，并按功能进行组织:产品到产品映射、成本、计量单位转换和附加属性。模板被复制以适应每个全球特许经销商，因此数据管理员只负责维护他们的资产。我们总共会有 50 多个文件！

我构建了一个 SharePoint 站点来托管文档存储库中的模板，它相当于 SharePoint 中的目录文件夹。然后，我创建了一个简单的 python 脚本来遍历“文件夹”以按功能连接文件，添加了额外的列，如“修改日期”、“初始文件名”和一个“完整性”度量，该度量计算相对于总数(按行)填充了多少列。超过 50 个文件减少到 4 个，代表每个功能数据资产。为了传播数据质量概念，我使用 pandas-profiling 按功能构建数据质量报告，并嵌入到 SharePoint 站点上。

B.I 团队厌倦了手动将平面文件上传到数据仓库。我使用了 pyODBC 来建立到企业 SQL 服务器的连接，并且只加载了满足适当“完整性”分数的记录。

**import** pyodbc
conn = pyodbc.connect(**'Driver={SQL Server};'
                          'Server=<server>;'
                          'Database=<database>;'
                          'Trusted_Connection=yes;'**)

cursor = conn.cursor()sql_query = **"SELECT * FROM table_name"** cursor.execute(sql_query)
cursor.fetchall()sql_df = pd.read_sql(sql_query, conn)

一旦将记录加载到数据仓库中，我就可以查询记录，并通过交叉引用具有信息模式和列约束的数据来检查 一致性；如果列的 VARCHAR 限制为 5，并且值的长度等于 10，则不会加载记录。我将这个“错误日志”存储在 SharePoint 站点上，供数据管理员在需要时参考。

最后，我们计算加载到 SQL Server 中的记录的利润，并将结果存储在 plotly 图形中，以提供关于特许经营业绩的即时反馈。一个漂亮的动画形象化描述了预期记录、已提供记录、已加载记录、有利润的记录以及一段时间内总收入的百分比。领导可以快速查看哪些数据管理员正在积极地贡献高质量的数据，哪些没有，以及哪里出现了主要的差异。最终结果是一个整合的平台，通过自动化管道实时更新数据质量指标，从而消耗特许经营的利润率。数据专业人员可以专注于将见解转化为行动，而不是“赶猫”。

来源:牧羊猫途经obrag.org

结论

数据管理远不如分析和高级技术那么吸引人，但同样重要。如果管理不当，糟糕的数据将会分散您进行深刻分析的注意力，并困扰您企业中有才华的数据专业人员。虽然过于简单，但本文概述的方法阐明了人员、流程、数据和技术如何相互作用，以产生企业的整体指标。在跳到“有趣的东西”之前，通过关注数据管理生命周期的基础，项目团队可以快速地从吸收数据转向理解数据。

总的来说，我的贡献每年将为企业节省 400 多个小时的人工工作。此外，我们还促成了一种缺乏数据管理的文化，并在此过程中帮助整合了数据质量战略。开始自动化您的数据管理纪律！

使用 TanD 自动化您的机器学习工作流程

原文：https://towardsdatascience.com/automate-your-machine-learning-workflow-with-tand-7bb79ccad384?source=collection_archive---------61-----------------------

用几个终端命令训练和部署您的 ML 模型，根本不需要代码

来源:https://cdn . pix abay . com/photo/2019/04/14/10/28/gears-4126485 _ 1280 . jpg。访问时间:2020 年 8 月 24 日

这是一个关于 TanD 的帖子，一个自动化机器学习工作流程的无代码框架。它的目的是展示如何使用它来自动化您的机器学习工作流任务，以将您的时间花在对您来说重要的事情上。

你可以在这里查看 GitHub 回购。

数据科学家、机器学习工程师或任何从事数据建模工作的人的工作流程都是重复的:在一些预处理的数据集上迭代地训练和部署模型，编写相同的函数来导入数据，一次又一次地拟合和部署一些机器学习模型，这很无聊，而且根本没有效率。

在这种背景下，开发了 TanD(训练和部署)框架来自动化这一机器学习工作流的一部分，以缓解数据科学家的生活，让他们把时间花在对他们来说重要的事情上。

它是如何工作的

类似于“Django for Machine Learning”，TanD 的主要思想很简单:通过一些终端命令和对一个.json文件的一些设置，用户能够训练一个 ML 模型(在 PyTorch 或 sklearn 上)，将它记录到mlflow中，自动创建一个 API 来参考它。只需几个命令，您甚至可以将它部署到 AWS 上，无需编写任何代码。

让你在工作中想怎么懒就怎么懒，而不会影响工作质量。在使用它的 CLI 生成项目模板之后，您可以插入您的数据集，让它为您完成工作，或者指定复杂的 train 函数和 API 端点。

我们现在将展示如何使用 TanD 来自动化 UCI 心脏病数据集上从训练到部署的 ML 工作流。

设置项目

我们首先必须安装 TanD，这很容易做到:

pip install train-and-deploy

如果您想遵循本教程的部署部分，您还应该安装 AWS CLI 、 ElasticBeanstalk CLI ，并设置您的 AWS CLI 凭证。不要担心，我们在这里展示的一切都可以用自由层来完成，尽管 API 将是可伸缩和有弹性的。为此，您也可以遵循 AWS 文档中的说明。

要创建一个 TanD 项目，必须在终端上运行命令。我们将使用 PyTorch 模板，尽管您可以使用 sklearn one 来跟踪所有内容:

tand-create-project --template pytorch-structured-classification## or if you prefer: tand-create-project --template sklearn-structured-classification

这将在文件夹上创建项目文件，并加载一个默认数据集(我们将使用它)，这就是上面提到的 UCI 心脏病。我们现在将逐一查看这些文件:

├── app.py
├── config.json
├── data
│   └── data.csv
├── Dockerfile
├── env_files
│   ├── app.env
│   ├── docker_app.env
│   └── train.env
├── lib
│   ├── __init__.py
│   ├── model.py
│   └── preprocess.py
├── mlflow-server.sh
├── requirements.txt
├── test_app.py
└── train.py

数据

数据文件夹包含将要使用的数据集。阳光下无新事。

配置

config.json文件遵循以下结构:

其中训练子字典包含与数据集和网络架构相关的训练参数。注意，我们必须指定包含标签的列，并在labels列表中按顺序命名它们。to_drop包含在定型之前应该从数据集中删除的所有列。

mlflow子目录包含与实验的mlflow记录相关的参数。

环境文件

env_files文件夹包含用于模型训练和部署的环境变量源文件。train.env为训练期间实验的mlflow记录设置变量；

MLFLOW_TRACKING_URI=sqlite:///database.db
MLFLOW_DEFAULT_ARTIFACT_ROOT=./mlruns/

两者都可以设置为本地路径或云托管路径。为了简单起见，我们将保留它们的默认值，但是注意，为了可伸缩性，您应该设置自己的mlflow db 和存储路径。

app.env包含与服务于模型的 API 相关的环境变量:

MLFLOW_TRACKING_URI="sqlite:///database.db"
MLFLOW_DEFAULT_ARTIFACT_ROOT="./mlruns/"
API_TOKEN="TOKEN123"
MODEL_STAGE="Production"

除了出现在train.env上的那些，我们在这里有模型的阶段，它将由mlflow加载器在生产中获取，还有一个令牌，它必须作为请求参考 API 的TOKEN头传递。

如果用户想在本地运行一个Docker，那么docker_app.env在一个单独的文件中包含变量。

Dockerfile 文件

当然，它包含了基于 FastAPI 构建服务于模型的图像的指令。

解放运动

Lib 包含模型架构(或者，在sklearn项目中，一个将config.json中选择的模型映射到sklearn模型的解析器)。

还包含preprocess.py，具有preprocess功能。在训练之前，我们在数据集中放置任何应该完成的预处理操作，这比仅仅删除列更复杂(或者我们可以在配置上保持在to_drop)。我们今天不会使用定制的预处理程序。

最后是主要文件:

火车

在执行任何所需的预处理操作后，train.py文件使用配置根据数据路径给出的数据训练模型。它将模型存储在mlflow上，这样就可以在生产中读取它，以及许多指标，如准确性、AUC-ROC、AUPR、精确度、召回、NPV 等...

如果您运行多次，它将保存不同的运行及其指标，您将能够在mlflow UI 中设置生产模型，只需运行:

bash mlflow-server.sh

这个脚本还从预处理的数据中创建了一个请求模型，存储在request_model.json中。该文件既用于测试模型，也用于新请求的验证和重新排序。

应用

TanD 模型模板包括一个简单的 FastAPI 应用程序，用于服务模型，受$API_TOKEN保护。它包括端点:

  • /进行健康检查；
  • /update-model用于通过请求使 API 在mlflow指定的后端获取最新的生产阶段模型—需要$API_TOKEN；和
  • /predict接收特征并返回模型预测—需要$API_TOKEN。

试验

为了确保一切正常，包括对 API 所有端点的测试。设置好适当的环境变量后，只需运行:

pytest

如果通过了，你就可以走了。

我们现在准备继续训练模型，测试 API，最后部署它。

训练模型

要训练模型，只需运行:

source env_files/train.env && python train.py

它将执行操作并将其记录到mlflow。您可能希望看到以下结果:

bash mlflow-server.sh

您将看到带有以下内容的用户界面:

注意，除了度量标准，它还存储了大量的度量标准和图表来帮助您评估模型。来源:我卑微的机器打印。

训练脚本还保存对预测的每个要素的分析，以便可视化给定每个分类要素的预测比例和每个类的连续要素的分布。(这有助于检查模型是否有任何“欺骗”的特征，并对学习有一些解释)。

对于心脏病预测为阳性的情况，该图像将是:

大量的图表有助于评估模型和理解它学到了什么。

你也可以在那里看到混淆矩阵，PR 和 ROC 曲线。

之后你可能会想

source env_files/app.env && pytest

断言一切正常。

一旦我们训练了这个模型，我们就能够开始探索 API，用Docker运行它，甚至用几个终端命令将它部署到 AWS。

运行 API

我们现在将展示运行一个 TanD 项目 API 的三种方法:本地，通过Docker和部署到 AWS ElasticBeanstalk。

本地运行

要在本地运行 API，您可以在具有适当要求的环境中运行:

uvicorn app:app --reload --host 0.0.0.0 --port 8000

这样，API 就可以在您的本地网络上打开了。你可以用一个curl帖子请求来测试一下:

curl --header "Content-Type: application/json" \
  --header "TOKEN: $API_TOKEN" \
  --request POST \
  --data '{"age":1,"sex":1,"cp":1,"trestbps":1,"chol":1,"fbs":1,"restecg":1,"thalach":1,"exang":1,"oldpeak":1,"slope":1,"ca":1,"thal":1}' \
  http://localhost:8000/predict

码头运行

您可能希望通过Docker运行它，这是一种可用于在云服务的通用虚拟机上部署它的方法。在 TanD 项目的根上构建它非常简单:

docker build . -t tand-app:v1

当您运行它时，一定要传递适当的环境文件和 API 使用的变量。您可以将它们设置在env_files/docker_app.env:

docker run -p 8000:8000 --env-file env_files/docker_app.env tand-app:v1

同样，您可以使用相同的命令来测试它，只需记住为请求使用正确的令牌:

curl --header "Content-Type: application/json" \
  --header "TOKEN: $API_TOKEN" \
  --request POST \
  --data '{"age":1,"sex":1,"cp":1,"trestbps":1,"chol":1,"fbs":1,"restecg":1,"thalach":1,"exang":1,"oldpeak":1,"slope":1,"ca":1,"thal":1}' \
  http://localhost:8000/predict

使用 AWS ElasticBeanstalk 部署它

TanD 还帮助您在 AWS EB 上部署它，这是一个很好的方法，因为它具有弹性和可伸缩性，同时仍然易于使用(通过我们的助手)。如果您按照上面的建议设置了 AWS CLI 凭据，安装了它，并安装了 ElasticBeanstalk CLI，那么现在就可以开始了。

要准备在 AWS 上部署您的 TanD 项目，请在项目根目录下运行:

tand-prepare-aws-eb-deployment --init-git

我们传递这个--init-git标志，因为 ElasticBeanstalk 使用了来自.git目录的一些信息，以便在部署期间将项目上传到 AWS S3。这样，在部署之前，TanD 创建了一个 g it 存储库，并提交了使其工作的所有内容。

如果您已经初始化了一个 git 存储库，您不必传递那个标志，只需记住添加并提交所有内容。

该脚本将创建一个脚本来部署 TanD 项目根目录上的应用程序、deploy-aws-eb.sh和.ebextensions目录，其中填充了一些用于部署的默认.config文件，遵循以下结构:

├── .ebextensions
    ├── options.config
    ├── cron.config
    └── scaling.config
  • options.config为项目设置环境变量，同app.env — mlflow后端、模型阶段、API token。这就是环境变量传递给 EB 的方式。
  • cron.config在部署的应用程序的每个实例上创建一个 cron 作业来每日查询 API update-model端点，因此它从mlflow后端获取最新的生产阶段模型。这样，如果您运行不同的实验并想要部署不同的模型，您可以通过mlflow UI 进行，它将在生产中更新。
  • scaling.config为您的 API 设置缩放配置。我们将这些参数设置为我们的应用程序可以拥有的最小和最大实例数、实例类型和缩放标准。我们将最后一个默认为延迟，但是您可以自由地这样做。

然后，我们可以通过一个简单的:

bash deploy-aws-eb.sh

部署大约需要 5 分钟。之后，您可以使用以下命令检查链接:

eb open

然后用相同的 curl 命令测试它(记住正确设置链接和 API 令牌):

curl --header "Content-Type: application/json" \
  --header "TOKEN: $API_TOKEN" \
  --request POST \
  --data '{"age":1,"sex":1,"cp":1,"trestbps":1,"chol":1,"fbs":1,"restecg":1,"thalach":1,"exang":1,"oldpeak":1,"slope":1,"ca":1,"thal":1}' \
  http://YOUR_LINK_GOES_HERE/predict

至此，我们结束了项目教程。

结论

作为一个结论，我们可以看到，TanD 允许您非常快速地训练和部署您的 ML 模型，只需要一些设置和终端命令，根本不需要任何代码，但是让您可以自由地适应和更改项目模板。

为了训练和部署您的项目，您只做了 6 个终端命令并检查了config.json上的一些设置:

tand-create-project --template pytorch-structured-classification## check config.json for your datasetsource train.env && python train.py
source app.env && pytest## run API as you will:tand-prepare-aws-deployment --init-git
bash deploy-aws-eb.sh

有了 TanD，你就可以自动化你的 ML 工作流程的很大一部分，节省你的时间去做对你来说重要的事情，或者只是偷懒和开心。

如果你喜欢这个帖子，考虑给它一些掌声或者主演 GitHub repo ，它有助于项目获得更多的可见性。

如果你想和我谈谈这个项目，有一些见解，只是想聊天的批评，你可以在 LinkedIn 上 ping 我或者在回购中创建一些问题。

参考资料:

[## piEsposito/TanD

TanD 是一个简单、无代码、灵活和可定制的框架，用于自动化机器学习工作流。用和…

github.com](https://github.com/piEsposito/TanD) [## MLflow -机器学习生命周期的平台

机器学习生命周期的开源平台 MLflow 是一个开源平台，用于管理机器学习生命周期

mlflow.org](https://mlflow.org/) [## 心脏病 UCI

https://archive.ics.uci.edu/ml/datasets/Heart+Disease

www.kaggle.com](https://www.kaggle.com/ronitf/heart-disease-uci)

使用 Process Manager 2 (PM2)自动化您的 Python 脚本

原文：https://towardsdatascience.com/automate-your-python-script-with-pm2-463238ea0b65?source=collection_archive---------3-----------------------

一个重要的 PYTHON 技巧

以新冠肺炎数据收集为例的分步指南

插图作者:金彩云

在数据科学中，您可能需要定期运行或处理您的 Python 脚本，尤其是数据收集，以使您的工作流程保持最新，因为它直接关系到您的结果准确性。您可能有一个 Python 脚本，每隔 1、2、…、 xx 分钟/小时运行一次，或者每天早上 6 点、晚上 9 点、 yy 点/晚上运行一次。而且每次都自己做又累又无聊。

这就是为什么自动化或计划你的脚本是重要的！！

当你在网上搜索它的时候，可能已经有几篇文章在讨论它了。如果您使用的是 Windows，您可以考虑使用一个 Windows 任务调度器，您可以使用它来调度您的 Windows 系统运行任何 execute(。exe)或批处理(。bat)文件。虽然它有一个好看的用户界面，但有些人仍然不太喜欢它。(来源 此处 )

或者如果你使用的是 macOS 或者 Linux，你可以考虑使用一个 Crontab 。但是当您有太多的脚本或作业需要管理/记录时，您可能会发现很难管理。

那么，让我们检查一下这个替代方案>>>

PM2 是另一个选择！

PM2 是为 Node.js 应用构建的流程管理器。

根据我使用 Node.js 进行 web 开发的经验，我不得不使用 CRON 来调度和管理几个 Node.js 应用程序，这给了我一段非常艰难的时间，直到我认识了 PM2 ！！从那以后我的生活好多了。PM2 让我的应用程序永远运行，并在我更新应用程序时自动重新加载。此外，我可以在任何应用程序上使用 CRON 或重启延迟手动安排重新加载时间，它可以在所有操作系统上完美运行！！

嘿等等…，PM2 不是仅限于 Node.js 应用吗？

不！没错， PM2 意在服务 Node.js 应用，但不限于 Node.js 运行时。在我使用 PM2 一段时间后，我意识到它可以用来管理任何编程脚本/运行时！从那时起，我用 Python 试了一下，效果很好！

在本文中，我将展示一个例子，展示如何使用 PM2 来调度和自动化您的 Python 脚本！！

我们开始吧！

PM2 装置

安装也可以在一条线上完成，您可以使用npm或yarn。

$ **npm install pm2@latest -g**
# OR 
$ **yarn global add pm2**
# Done!
# Check if program runs.
$ **pm2 -v**
vx.x.x

如果你在 Windows 10 上安装了 PM2，第一次运行时，你可能会遇到一个错误，因为当前用户有一个未定义的执行策略。您可以通过以下代码修复它:

$ **Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Unrestricted**

使用 PM2 运行 Python 脚本

安装完成后，您可以使用$ **pm2 start** <script name>命令通过 PM2 启动任何 python 脚本。

如果您有多个作业要运行，我还建议您给每个作业起一个有意义的名字，这样您以后就不会混淆了。可以用**--name** <name>给每个作业命名。默认情况下，当你启动任何.py文件时，PM2 会用 Python 运行你的脚本。但是，如果您的机器上安装了多个版本的 Python，您可以使用**--interpreter** <interpreter name: node, python, python3, python3.x, ...>选择特定的 Python 版本。

总的来说，启动 python 脚本的命令如下所示:

$ **pm2 start** job1.py --**name** job1 --**interpreter** python3

根据 PM2 的默认设置，它会试图让你的应用程序永远运行，这意味着你的脚本将在完成后立即自动重启。

嗯，对一台机器来说可能太多了！因此，有两种方法可以将 Python 脚本设置为定期运行 PM2: 1 .使用重启延迟 2。使用 cron

通过“重启延迟”自动重启

您可以使用**--restart-delay** <xxxx ms>选项将 Python 脚本设置为定期运行。这样，在 Python 脚本完成工作后，它将等待xxxx毫秒，直到下一次重启。

例如，如果您希望您的脚本在每次作业后每 10 秒重启一次，您通常可以在 Python 中使用while & time.sleep，如下所示:

**while True:**
...
   **time.sleep(10)**

有了 PM2，你不再需要while循环，你可以保持你的代码干净，把重启工作留给 PM2 。在每个作业后以 10 秒钟的睡眠时间运行脚本的命令如下所示:

$ **pm2 start job1.py --name job1-10s-delay --interpreter python3 --****restart-delay 10000**

使用“cron”自动重启

您还可以使用 cron 选项通过**--cron** <'cron pattern'>来调度您的 Python 脚本。使用--no-autorestart禁用 PM2 自动重启选项也很重要，这样它就不会在完成一个任务后自动重启，只会遵循 cron 表达式。

例如，每 1 小时(在第 0 分钟)重新启动脚本的命令如下所示:

$ **pm2 start .\testPm2.py --cron '0 * * * *' --no-autorestart**

关于 cron 的一个提示:如果你是第一次接触 cron 。它是 Unix 操作系统中基于时间的作业调度程序。 cron schedule 表达式允许您让您的程序在特定的时间定期重启。cron 的格式是'<minutes 0:60> <hour 0:24> <day of month 1:31> <month 1:12> <day of week 0:6>'.我推荐你可以尝试通过这个网站创建自己的 cron 表达式:这里。

让我们结束这无聊的部分，让我们一起经历一个真实世界的例子！

真实世界的例子

抓取全球新冠肺炎数据

假设您想每隔 5 分钟从 Worldometer 监控并存储新冠肺炎病例的数据。使用beautiful soap 4就可以轻松做到。例如，我的 Python 脚本(getcovid 19 data . py)将允许您从 Worldometer 获取新冠肺炎案例数据，并将数据存储到 CSV 文件( world_corona_case.csv )。

getCovid19Data.py(使用 bs4 抓取新冠肺炎的 Python 脚本)

而不是在脚本中使用while循环和time.sleep()或者使用常规的 cron 每 5 分钟重启一次脚本。

您可以使用 PM2 和重启延迟 (5 分钟=300000 毫秒)来完成:

$ **pm2 start getCovid19Data.py --name covid19-5minInt** **restart-delay** **300000**

或者，您可以使用 PM2 和cron*(5min = ' */5 * * * )来完成

$ **pm2 start getCovid19Data.py --name covid19-5minInt --cron '*/5 * * * *' --no-autorestart**

就是这样！现在，Python 脚本将每 5 分钟运行一次。现在您可以用这个命令检查您的日志

**$ pm2 l**

将显示列表。您可以在这里看到所有使用 PM2 运行的作业，这些作业将包含所有在后台运行的 Node.js 应用程序或 Python 脚本。

PM2 表显示了所有应用程序的列表

您可以使用命令pm2 log <id or name>查看特定作业的日志。在本例中，您可以使用以下命令:

$ pm2 log 0

作业 id 为“0”的 PM2 日志

从日志状态可以看到，Python 脚本每 5 分钟存储一次新冠肺炎数据，剩余的[~1.6 到 2.5 秒]是 Python 脚本每次请求数据并保存添加更新数据到CSV文件的时间。现在，让我们检查下面结果CSV文件中的结果。PM2 很好用！

将 PM2 与 cron 一起使用时，getcovid 19 data . py sscript 产生的 CSV 结果

一些其他有用的 PM2 命令

当你用 PM2 运行多个进程时。您可能希望对每个项目进行不同的操作。以下是我最常用的一些有用命令的列表。

$ **pm2 stop <name or id>** #stop specific process$ **pm2 restart <name or id>** #restart specific process$ **pm2 flush <name or id>** #Clear logs of specific process$ **pm2 save** #save list of all application$ **pm2 resurrect** #brings back previously saved processes
$ **pm2** **startup** #Command for running PM2 on startup

作者单词

我希望您喜欢这篇文章，它可以帮助您更容易地安排 Python 脚本，并将其应用到您的 Python 工作流中。如果您有任何问题、意见或建议，请随时与我分享。

关于我&查看我所有的博客内容:链接

平安健康！
感谢阅读。👋😄

自动化您的重复性报告！

原文：https://towardsdatascience.com/automate-your-repetitive-reports-5ee60a53bda2?source=collection_archive---------14-----------------------

自动化 R 脚本

来源:https://thumbs . gfy cat . com/impressive instructiveiberian emerald lizard-small . gif

什么是 R 脚本自动化，为什么？

在大多数用例中，R 用于分析数据、运行统计测试和构建模型。在这样做的过程中，数据科学家通过编写代码不断地与 R 进行交互，并从这些交互中产生结果。最终，这些结果被存储、共享或以报告的形式呈现。但是，如果您必须每天或以其他类型的定期间隔复制报告，该怎么办呢？嗯，你总是可以调出 R 脚本，重新运行脚本。但是，如果它是自动完成的，而不需要您在中间启动 R 和运行脚本，不是更好吗？

在本文中，我们将知道如何做到这一点！

我们在这里要做的事情的大纲

概括地说，本文有两个部分:

首先，在本文中，我们将创建一个使用实时数据的报告，即定期更新的数据源。

其次，一旦创建了报告，我们将自动执行每天重新创建报告的过程，以捕获更新的数据。

第 1 部分:创建报告:

因为这篇文章的目标是自动复制一个已经构建好的报告，所以我已经创建了一个报告并发布在这里:【http://rpubs.com/arafath/CRAN_Report。

请随意访问该报告，并在您的工作站中重新创建它。你可以给 RMarkdown 脚本起个和我一样的名字( 'CRAN_Download_Report。Rmd' )并将其保存在您想要保存的相同位置。存储 bat 文件和其他输出。

该报告中所做的如下所示:

  • 从综合存档网络(CRAN)调用 API 下载包的每日和每周下载计数，
  • 加载 R 中的数据，
  • 计算一些基本的统计数据，
  • 可视化数据
  • 生成包含基本统计数据和视觉效果的报告(html 格式)。

使用的数据:

CRAN 有一个 API 调用，我们可以使用它来获得特定时间内任何包被下载的总次数。我们将使用名为 cranlogs 的包来调用 api。

第 02 部分:自动化报告复制

一旦我们有了一个可以产生我们想要的结果的 R 脚本，复制工作流程看起来如下:

  • 打开 R 控制台或一些 IDE
  • 加载所需的 R 脚本
  • 运行脚本以产生结果

在这一步中，我们将知道如何告诉 R 自动完成上述所有步骤。这样，R 也将完成第 01 部分中提到的所有步骤。

自动化是如何工作的:

为了自动重新运行 R 脚本，我们将使用 Windows 任务调度程序(WTS)。使用任务计划程序，用户可以要求 windows 执行批处理文件(。蝙蝠)。批处理文件包含一系列可以由命令行解释程序执行的命令。

我们将创建一个批处理文件，每天自动运行一个 R 脚本。在 R 脚本中，它被指示调用。创建报告的 Rmd 文件。

创建 R 脚本来运行。Rmd 文件

您可以在 R 脚本中复制并粘贴以下代码，并将其另存为 run。R (我的 r 脚本文件名):

# Loading libraries [install the libraries before if not already installed]
library(knitr)
library(rmarkdown)
library(mailR)# Knits rmd file (.Rmd is saved in the working directory)
knit('CRAN_Download_Report.Rmd')# Creates the html output
render("CRAN_Download_Report.md")# sending email notification
send.mail(from = "youremail@gmail.com",
      to = c("testemail@gmail.com"),
      cc = 'youremail@gmail.com',
      replyTo = c("Reply to someone else <youremail@gmail.com>"),
      subject = "Report update status",
      body = "Daily report on CRAN package download is updated!",
      smtp = list(host.name = "smtp.gmail.com", port = 587, user.name = "youremail", passwd =    "password", tls = TRUE),
      authenticate = TRUE,
      send = TRUE)

这个 R 脚本所做的基本上是编织 rmd 文件并生成一个 html 报告，将它保存在工作目录中并发送一个电子邮件通知。

从窗口的命令外壳运行 R

在创建批处理文件之前，我们可以从命令终端手动运行我们的 R 脚本，并检查它是否按预期运行。

设置目录

打开 windows 命令外壳。在窗口中搜索“cmd”或“命令提示符”并打开它。它将打开黑色的命令外壳。

现在，使用“cd”命令将命令目录更改到您想要的位置，后跟您想要的文件位置(ref: image01)。

图片 01

从命令行运行 R

我们将使用的命令结构如下: <r.exe location="">CMD BATCH <.r file="" location=""/></r.exe>

这里，

  • R.exe 位置是你的 R 可执行文件所在的文件位置。执行这个文件应该会打开 R 控制台。
  • 。r 文件位置是保存 r 脚本的文件位置，该脚本将调用。Rmd 文件。
  • 文件保存位置是您想要保存执行输出的位置。

为了简单起见，我使用与 R 工作目录和位置相同的文件位置来保存任何输出。

在我的案例中，这些是确切的位置:

R.exe location = "C:\Program Files\R\R-3.6.1\bin\x64\R.exe" 
.R file location = "C:\Users\ahossa1\Personal\Learning\Automating R Script\run.R" 
file saving location = "C:\Users\ahossa1\Personal\Learning\Automating R Script\test.Rout"

这是我电脑中的最后一行代码(ref: image02):

"C:\Program Files\R\R-3.6.1\bin\x64\R.exe" CMD BATCH "C:\Users\ahossa1\Personal\Learning\Projects\Automating R Script\run.R" "C:\Users\ahossa1\Personal\Learning\Projects\Automating R Script\CRAN.Rout"

图片 02

一旦您输入命令(image02)并执行它，它应该运行 R 脚本，该脚本将编织 rmarkdown 文档并保存报告。您应该还会收到一封带有通知的电子邮件！

使用命令行指令创建批处理文件

我们可以将命令行指令(image02)保存为. bat 文件并保存。然后，在我们需要重新创建报告的任何时候，我们都可以执行。bat 文件，它会自动调用命令行界面并执行 R 脚本。

为此，请打开一个文本文件(。txt)。将 Windows shell 命令粘贴到。txt 文件，用扩展名保存。球棒。

在我的电脑里，我把它命名为“run.bat”。

在不需要定期重新创建报表的情况下，可以使用这个。bat 档。你所要做的就是双击(或单击)。bat 文件和报告将使用更新的数据生成。

使用 Windows 任务计划程序自动执行命令行活动

现在我们将要求我们的计算机自动调用。bat 文件定期。

  1. 在 Windows 搜索栏中搜索“任务计划程序”并打开应用程序。下面是它在我的电脑上的样子

图片 03

2.选择创建基本任务(图 03 红色标记)

3.为任务命名

图片 04

4.下一步，选择一个触发器。我选择了日报。

图片 05

5.转到下一步并选择开始时间。

图片 06

6.转到下一步，选择启动程序作为操作。

图片 07

7.下一步，加载程序/脚本(。bat 文件)。

图片 08

瞧！！我们完成了！

现在每天下午 3:30。下面的 CRAN 包下载报告将被创建，并将发送电子邮件通知！

使用 BioBert 从 Spark NLP 中的文本自动检测药物不良事件(ADE)

原文：https://towardsdatascience.com/automated-adverse-drug-event-ade-detection-from-text-in-spark-nlp-with-biobert-837c700f5d8c?source=collection_archive---------20-----------------------

在 Spark NLP 和 BioBert 的帮助下，第一个端到端预训练模型和管道可大规模检测药物不良反应。

国家癌症研究所在 Unsplash 上拍摄的照片

药物不良反应(ADRs)或药物不良事件(ADEs)对患者具有潜在的巨大危险，是发病率和死亡率的主要原因 [[1]](http://Pirmohamed et al.2004] Munir Pirmohamed, Sally James, Shaun Meakin, Chris Green, Andrew K Scott, Thomas J Walley, Keith Farrar, B Kevin Park, and Alasdair M Breckenridge. 2004. Adverse drug reactions as cause of admission to hospital: prospective analysis of 18,820 patients. BMJ, 329(7456):15–19.) 。许多药品不良反应很难被发现，因为它们发生在特定条件下的特定人群中，并且可能需要很长时间才能暴露。医疗保健提供者在销售产品前进行临床试验以发现药物不良反应，但通常数量有限。因此，需要上市后药物安全性监测来帮助发现药物上市后的不良反应【2】。

最近，医疗报告[【3】](http://H Gurulingappa and J Fluck. 2011. Identification of adverse drug event assertive sentences in medical case reports. In 1st international workshop on knowledge discovery and health care management (KD-HCM) co-located at the European conference on machine learning and principles and practice of knowledge discovery in databases (ECML PKDD), pages 16-27.)或社交网络数据[【4】](http://Rachel Ginn, Pranoti Pimpalkhute, Azadeh Nikfarjam, Apur Patki, Karen Oconnor, Abeed Sarker, Karen Smith, and Graciela Gonzalez. 2014. Mining Twitter for Adverse Drug Reaction Mentions: A Corpus and Classification Benchmark. In proceedings of the 4th Workshop on Building and Evaluating Resources for Health and Biomedical Text Processing (BioTxtM).)等非结构化数据已被用于检测包含 ADR 的内容。发表在科学生物医学文献中的病例报告非常丰富，并且生成迅速。社交网络是非结构化格式的冗余数据的另一个来源。虽然包含 ADR 的单个 tweet 或脸书状态可能没有临床意义，但大量的这些数据可能会暴露严重或未知的后果。

假设需要从各种非结构化的资源(如推特、新闻、网络论坛等)中收集 ADR。)以及科学论文(即 PubMed、arxiv、白皮书、临床试验等。)，我们希望建立一个端到端的 NLP 管道来检测文本是否包含可能的 ADR，并提取 ADR 和提到的药物实体。

规模上的 NLP:Spark NLP

Spark NLP 是一个构建在 Apache Spark ML 之上的自然语言处理库，每天被下载到 10K，总共有 150 万次。它是发展最快的 NLP 库之一，支持 Python、R、Scala 和 Java 等流行的编程语言。它为机器学习管道提供了简单的、高性能的&精确的 NLP 注释，可以在分布式环境中轻松扩展。

Spark NLP 提供了 330 多种经过预训练的管道和模型，支持超过 46 种语言。它支持最先进的转换器，如 BERT、XLNet、ELMO、ALBERT 和通用句子编码器，可以在集群中无缝使用。它还提供了标记化、词性标注、命名实体识别、依存解析、拼写检查、多类文本分类、多类情感分析以及更多 NLP 任务。如需更多信息和 Colab 笔记本样品，我们强烈建议您查看我们的车间报告。

Spark NLP 医疗图书馆中的 ADRs 模型

我们首先进行了深入的研究，以收集 NLP 研究人员和医疗保健专业人员使用的所有可用的 ADR 数据集(PsyTAR、CADEC、Drug-AE、TwiMed ),我们汇编了一个包含 40K 个样本和 10K ADR 阳性句子的数据集。然后我们在 Spark NLP 中训练了几个文本分类和命名实体识别(NER) 模型，使用 BioBert 语言模型，并作为预训练模型和流水线随 Spark NLP Enterprise 2.6.2 发布。

Spark NLP 医疗保健版(许可)

药品不良事件 NER 模型

我们发布了 4 种不同的阿德 NER 模型，每一种都根据系统的局限性和所需的精确度，在不同的嵌入上进行训练。

ner_ade_biobert:用 768d BioBert 嵌入(biobert_pubmed_cased)训练

ner_ade_clinicalbert:用 768d BioBert 嵌入式(biobert_clinical_cased)训练

ner_ade_clinical:200d 临床手套嵌入训练

ner_ade_healthcare:100d 保健手套嵌入训练

阿德·NER 可以提取两个实体:ADE和DRUG

您还可以在同一管道中使用 ADE NER 和断言状态模型，并检测 ADE 检测到的否定范围(gastric problems将被检测为absent)。

就像所有其他 Spark NLP 模型一样，您也可以在任何 Spark 数据帧上运行它，并获得每一行的预测。

阿德 NER 管道公司

艾德·NER 的预测样本

我们想看看我们的 NER 算法在基准 ADE 数据集上与最先进的(SOTA) [结果相比有多好，我们最终获得了新的 SOTA 精度，其 宏平均值为 90.51 ！](http://Giorgi, John, et al. "End-to-end Named Entity Recognition and Relation Extraction using Pre-trained Language Models." arXiv preprint arXiv:1912.13415 (2019))

我们的阿德 NER 模型击败了 Giorgi，John 等人(2019)在相同的训练和测试分裂中使用相同的 BioBert 版本报告的 SOTA 结果。

药物不良事件(ADE)分类模型

我们发布了 3 个不同的 ADE 分类模型，每个模型都根据不同的嵌入进行了训练，这取决于系统的局限性和所需的精确度。

classifierdl_ade_biobert:用 768d BioBert 嵌入进行训练(biobert_pubmed_cased)

classifierdl_ade_conversational_biobert:在 会话短句 上用 768d BioBert 嵌入进行训练。

classifierdl_ade_clinicalbert:经过 768d BioBert 临床嵌入训练(biobert_clinical_cased)

ADE 分类器将返回True或False以表明文本是否与可能的药物不良事件或反应有关。以下是一些预测:

正如所有其他 Spark NLP 模型的情况一样，您也可以将其包装在 LightPipeline 中，并获得给定文本的预测。

最后，让我们将我们的分类算法与基准 ADE 数据集上的【SOTA】[结果进行比较。正如你所看到的，我们最终获得了新的 SOTA 精确度，F1 的分数为 92.15 ！](http://Huynh, Trung, et al. "Adverse drug reaction classification with deep neural networks." Coling, 2016.)

我们还发布了 ADE 预训练管道以避免您从头开始构建管道。下面是如何在 Spark NLP 中使用它，只需一行代码，就可以一次提取给定文本的命名实体和 ADE 状态。

从 Spark NLP for Healthcare 3.1.2 开始，现在我们也有了 ADE 关系提取模型(re)来查找药物和 ADE 实体之间的关系。请参见这款笔记本上的详细笔记。

结论

在这篇文章中，我们宣布了一种新的分类和 NER 模型，用于从临床和对话文本中检测和提取药物不良事件。你可以在这个 Colab 笔记本上找到所有代码和更多示例，如果你想在自己的数据上尝试它们，你可以申请 Spark NLP Healthcare 免费试用许可。

Spark NLP 库在企业项目中使用，在 Apache Spark 和 TensorFlow 上本地构建，并提供一体化的最新 NLP 解决方案，为机器学习管道提供简单、高性能和准确的 NLP 符号，可在分布式环境中轻松扩展。

如果您想了解更多信息并开始练习 Spark NLP，请查看以下资源。您还可以参加我们的 2020 年 NLP 峰会，并结识 50 多位来自业界的杰出演讲者！

[## Spark NLP 简介:基础和基本组件

为什么我们需要另一个 NLP 库？

towardsdatascience.com](/introduction-to-spark-nlp-foundations-and-basic-components-part-i-c83b7629ed59) [## 基于 Bert 和通用语句编码器的 Spark NLP 文本分类

用 Bert 和 Spark NLP 中的通用语句编码器训练 SOTA 多类文本分类器，只需几个…

towardsdatascience.com](/text-classification-in-spark-nlp-with-bert-and-universal-sentence-encoders-e644d618ca32) [## Spark 自然语言处理中基于 BERT 的命名实体识别(NER)

用 BERT 在 Spark NLP 中的几行代码训练一个 NER，获得 SOTA 精度。

towardsdatascience.com](/named-entity-recognition-ner-with-bert-in-spark-nlp-874df20d1d77) [## 约翰·斯诺实验室/spark-NLP-车间

此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…

github.com](https://github.com/JohnSnowLabs/spark-nlp-workshop/tree/master/tutorials/Certification_Trainings)

使用 PyCaret 的自动化异常检测

原文：https://towardsdatascience.com/automated-anomaly-detection-using-pycaret-5e40df75fe36?source=collection_archive---------33-----------------------

一个开源的机器学习库——py caret！！

图片来源——un splash

PyCaret 是一个开源库，它通过各种模块提供了各种机器学习功能，其中之一就是异常检测。

PyCaret 的异常检测模块是一个无人监管的机器学习模块，用于识别数据中存在的极值，这些极值有时可能表明可疑活动或异常情况。

PyCaret 的异常检测模块提供了十二种不同的异常检测技术，根据您正在处理的问题进行选择。它还允许我们通过一个名为“setup”的函数，使用传递给该函数的各种参数值来执行特征工程任务。

在本文中，我们将对 PyCaret 本身提供的一个数据集应用 PyCaret 提供的三种异常检测技术。本文涵盖的三种技术是— 隔离林、K 最近邻和聚类。

在我们实现这些技术之前，让我们先来看看我们需要按照特定的顺序执行的步骤，以便通过使用下面的函数来识别数据中的异常。这些步骤对于 PyCaret 为异常检测提供的所有技术都是通用的。

  • get_data() —此函数用于访问 PyCaret 数据集。这是一个可选步骤。
  • setup() —该函数初始化环境，并在异常检测之前执行所需的预处理任务。它唯一需要的参数是“数据”参数中的数据帧，但下面是可以通过设置功能实现的各种预处理任务的示例。
**setup**(*data, categorical_features = None, categorical_imputation = ‘constant’, ordinal_features = None, high_cardinality_features = None, numeric_features = None, numeric_imputation = ‘mean’, date_features = None, ignore_features = None, normalize = False, normalize_method = ‘zscore’, transformation = False, transformation_method = ‘yeo-johnson’, handle_unknown_categorical = True, unknown_categorical_method = ‘least_frequent’, pca = False, pca_method = ‘linear’, pca_components = None, ignore_low_variance = False, combine_rare_levels = False, rare_level_threshold = 0.10, bin_numeric_features = None, remove_multicollinearity = False, multicollinearity_threshold = 0.9, group_features = None, group_names = None, supervised = False, supervised_target = None, session_id = None, profile = False, verbose=True*)
  • create_model() —此函数创建模型，并在设置阶段作为参数传递的数据集上对其进行训练。因此，该函数要求在使用之前调用 setup()函数。
df = pd.read_csv(path_to_csv) # to access your own dataset
or
df = get_data(“anomaly”) # to access PyCaret’s anomaly datasetsetup_data = setup(data=df)
sample_model = create_model(“iforest”)
  • plot_model() —该函数获取 create_model()函数期间创建的训练模型，并绘制 setup()函数期间传递的数据。因此，该方法要求在调用之前调用 setup()和 create_model()函数。返回的图用不同的颜色清楚地显示异常数据。
plot_model(sample_model)
  • predict_model() —此函数获取经过训练的模型，并使用它对新数据进行预测。新数据必须是熊猫数据帧的形式。该函数的输出是一个数据帧，其中包含名为“标签的预测以及相关的决策得分。

Label = 0 表示正常数据或内嵌数据

标签= 1 表示异常或异常值

现在，当我们对 PyCaret 异常检测函数的工作原理有了一个基本的了解后，让我们开始实际的实现吧。

**# Importing PyCaret dependencies.**
from pycaret.datasets import get_data
anomaly = get_data(“anomaly”)**# Importing anomaly detection module.**
from pycaret.anomaly import ***# Initializing the setup function used for pre-processing.**
setup_anomaly_data = setup(anomaly)

隔离林实现

# Instantiating Isolation Forest model.
iforest = create_model(“iforest”)# Plotting the data using Isolation Forest model.
plot_model(iforest)# Generating the predictions using Isolation Forest trained model.
iforest_predictions = predict_model(iforest, data = anomaly)
print(iforest_predictions)# Checking anomaly rows. Label = 1 is the anomaly data.
iforest_anomaly_rows = iforest_predictions[iforest_predictions[“Label”] == 1]
print(iforest_anomaly_rows.head())# Checking the number of anomaly rows returned by Isolaton Forest.
print(iforest_anomaly_rows.shape) **# returned 50 rows**

前 5 个异常行(标签 1)

使用隔离林创建的异常图(异常以黄色突出显示)

基于隔离林的异常图

K 最近邻(KNN)实现

# Instantiating KNN model.
knn = create_model(“knn”)# Plotting the data using KNN model.
plot_model(knn)# Generating the predictions using KNN trained model.
knn_predictions = predict_model(knn, data = anomaly)
print(knn_predictions)# Checking KNN anomaly rows. Predictions with Label = 1 are anomalies.
knn_anomaly_rows = knn_predictions[knn_predictions[“Label”] == 1]
knn_anomaly_rows.head()# Checking the number of anomaly rows returned by KNN model.
knn_anomaly_rows.shape **# returned 46 rows**

前 5 个异常行(标签 1)

使用 K 个最近邻创建的异常图(异常以黄色突出显示)

基于 KNN 的异常图

聚类实现

# Instantiating Cluster model.
cluster = create_model(“cluster”)# Plotting the data using Cluster model.
plot_model(cluster)# Generating the predictions using Cluster trained model.
cluster_predictions = predict_model(cluster, data = anomaly)
print(cluster_predictions)# Checking cluster anomaly rows. Predictions with Label = 1 are anomalies.
cluster_anomaly_rows = cluster_predictions[cluster_predictions[“Label”] == 1]
print(cluster_anomaly_rows.head())# Checking the number of anomaly rows returned by Cluster model.
cluster_anomaly_rows.shape # returned 50 rows

前 5 个异常行(标签 1)

使用聚类创建的异常图(异常以黄色突出显示)

基于聚类的异常图

参考

基于深度学习的石棉纤维检测

原文：https://towardsdatascience.com/automated-asbestos-analysis-using-semantic-segmentation-53e6741ba5c2?source=collection_archive---------46-----------------------

理解大数据

基于深度学习语义分割的建筑工地有害石棉纤维自动检测

作者:Soma Biswas，Debmalya Biswas

摘要。 空气中的可吸入纤维，如石棉等都有害健康，职业健康与安全指南和法律要求对所有含石棉的材料进行检测和鉴定。然而，石棉纤维的检测和鉴定是一个复杂、耗时和昂贵的过程。 在这项工作中，我们提出了一种基于深度学习的语义分割模型，能够自动化石棉分析过程，将周转时间从几小时减少到几分钟。所提出的深度神经网络提供了分析过程的端到端自动化，从转换输入扫描电子显微镜(SEM)图像开始，到识别和计数图像中的纤维数量，到掩蔽所识别的纤维区域并重新排列以通过能量色散光谱(EDS)进行有效处理。最后，我们提供了基于 U-Net 的语义分割模型的实现细节，该模型能够以高达 95%的准确度检测和计数 SEM 图像中的石棉纤维(空气样本)。

这篇论文已经被接受在 2021 年第 50 届 IEEE 应用图像模式识别(AIPR)(论文)上发表

1 导言

石棉是一种天然存在的硅酸盐，具有纤维状结构，由于其柔韧性、丰富性、耐火性和耐腐蚀性，通常被称为“奇迹矿物”。这些技术特点和低成本导致石棉被用于许多领域，尤其是建筑业，例如，作为混凝土或树脂化合物的一种成分。像其有用的属性一样，石棉是一种严重的污染物，可导致肺部疾病，如石棉沉滞症、间皮瘤和其他类型的癌症。这些疾病可能有很长的潜伏期。

1990 年，瑞士是首批禁止石棉的国家之一；大多数其他国家在 90 年代紧随其后。然而，在五十年代、六十年代和七十年代，石棉仍然存在于许多建筑物的建筑材料中。为了保护工人和居民的健康，现行的瑞士法律要求任何超过 1990 年的建筑需要在拆除或改造以及回收/处理建筑材料之前进行石棉检查[1，2]。

在过去，重点放在石棉的主要矿点，如喷雾石棉或纤维水泥。然而，如今含有极低浓度(低于 0.1%)石棉的材料仍被视为对工人健康的威胁，因此需要取样分析。举个例子，从 2010 年开始对瓷砖水泥进行分析，从 2017 年开始对石膏进行分析，这些样品中大约有 20%含有石棉。

不幸的是，石棉纤维的检测和鉴定是一个复杂而耗时的过程。如果不确定是否存在石棉，则从现场收集样本(空气或固体，视情况而定),并使用扫描电子显微镜(SEM)和能谱仪(EDS)进行分析。通常通过使用特殊设计的泵收集样品，该泵迫使空气通过镀金过滤器，利用静电相互作用收集颗粒和纤维。在分析之前，使用氧等离子体蚀刻去除样品的有机成分。然后在扫描电镜下分析过滤器的随机选择部分，以寻找薄至 3 米和短至 5 米的石棉纤维。还根据规定的纤维计数规则对单根纤维进行计数，并根据纤维类型进行分类。通过使用 EDS 分析纤维的化学成分来进行分类。最后，对石棉纤维的浓度进行评估，并与规范(因国家而异)定义的标准值进行比较。如果评估的石棉浓度超过一定值，则需要根据指南进行进一步处理。

SEM 图像和 EDS 结果用于各种领域中不同类型材料的形态和化学分析，如医疗技术[3，4]，法医学[5]，建筑行业[6，7]等。然而，分析过程通常是耗时的，因为操作者在获得样品的电子图像后，需要用肉眼手动识别感兴趣的物体，然后选择获得 eds 光谱的位置。因此，这种方法不仅费时，而且费力，并有可能产生偏见。

在这项工作中，我们提出了一个基于深度学习(DL)的语义分割模型来自动化分析过程。所提出的模型能够识别和计数纤维的数量，其中神经网络掩蔽所识别的纤维区域并重新排列它们，使得它们可以作为输入提供给能量色散光谱(EDS)。

自动化过程如图 1 所示。

图一。基于 DL 的自动化石棉分析(图片由作者提供)

  1. 自动成像软件设置为无人值守运行，用于扫描电镜图像采集，为操作员腾出时间进行数据解释。
  2. 在 SEM 图像中有效地识别和定位纤维，例如，识别单根纤维、团块、部分覆盖有非石棉颗粒/灰尘的纤维等。；使用基于 DL 的图像识别技术。这些技术适应石棉纤维的形态特征，并提供石棉计数。
  3. 通过使用自动 EDS 程序对所识别的纤维位置进行化学分析，从而生成报告，该报告显示了在样品中发现的纤维数量，并且石棉的化学成分和长宽比符合规范分析过程的标准指南。

自动化过程有可能将石棉分析的周转时间减少到几分钟，而不是目前的手工处理时间 1-2 小时；预计成本降低高达 25%。

本文的其余部分组织如下:在第 2 部分，我们扩展图 1 以提供每个步骤的细节，子部分对应于图像捕获和图像分析(语义分割和纤维计数)阶段。第 3 节提供了实现细节，包括语义分割模型的训练规范和准确性结果。第 4 节对论文进行了总结，并为未来的工作提供了方向。

2 自动化分析

在本节中，我们展开图 1 来提供每个步骤的细节。图 2 示出了扩展的过程。

图二。自动化石棉分析步骤(图片由作者提供)

2.1 SEM 图像捕捉

使用标准成像软件收集 SEM 图像。收集几组图像，每组包含 100 个 SEM 图像。对于每组图像，工作距离(WD)、高电压(HV)、放大率、亮度和对比度被设置为特定值。所有 SEM 图像可以存储在计算机的本地硬盘上，也可以直接上传到云中，以便执行下一步。这些 SEM 图像然后被提供作为基于深度学习的语义分割模型的输入。

2.2 图像分析

如图 2 所示，整个过程包括预处理、语义分割、纤维计数，随后是负责优化 EDS 处理的神经网络输出的后压制步骤。我们从语义分割模型开始，它构成了图像分析模块的核心。

2.2.1 语义切分

语义分割指的是一种能够给图像中的每个像素分配类别(标签)的图像识别模型。这允许语义分割模型输出对象在图像中的位置、该对象的形状、哪个像素属于哪个对象等。因此，基于深度学习的语义分割模型包括训练神经网络以输出输入图像的逐像素掩码。

在文献中已经提出了不同的神经网络用于语义分割，例如 FCN [8]、SegNet [9]和 U-Net [10]。在这项工作中，我们将重点放在 UNet 架构上，它似乎对我们的问题域有效。

U-Net 是一种端到端的语义分割模型，它建立在基于卷积神经网络(CNN)的图像分类模型上；通过以编码器-解码器的方式堆叠一堆卷积层。编码器对图像进行下采样，给出图像的压缩特征表示，解码器使用例如转置卷积的方法对图像进行上采样，给出分段输出(不同于使用数学插值的其他方法)。直观地说，编码器由一堆传统的卷积和最大池层组成(在图像分类模型的线上)。因此，它能够捕捉图像的“是什么”信息。由于“在哪里”信息在语义分割中同样重要，解码器能够通过逐渐应用上采样来恢复“在哪里”信息(精确定位)。

我们遵循[10]中概述的原始 U-Net 架构，稍加修改即可接受 1024 x 768 x 3 的输入图像(在[10]中输入图像的大小为 572x572x3)。U-Net 的好处是它不包含任何密集层，因此它可以接受任何大小的图像。

2.2.2 预处理

本模块的目的是在提供所有 SEM 图像作为语义分割的输入之前，验证它们的质量。如果任何 SEM 图像被确定为在锐度、亮度、对比度或放大率方面不适于处理；该层试图通过执行必要的图像变换来纠正这一点。如果不成功，它会将图像返回到“图像捕获”层，突出显示问题，并在 SEM 图像捕获过程中提供解决问题的建议。

2.2.3 纤维数

回想一下，在 SEM 图像分析的某些特定情况下，如石棉(空气样品)分析，需要计算图像中纤维的长度、宽度和长宽比。此外，我们还需要确定图像视野中可见纤维的数量。这确定了图像中石棉纤维的浓度，如果发现石棉浓度超过了某一阈值，根据指导方针，这将要求进一步的处理。

给定一个语义分割输出，其中图像中的(分类的)纤维的像素已经被屏蔽，我们使用 OpenCV HoughLines()函数[11]来计算图像的长度和数量。下面提供了相应的 python 代码片段:

def **get_fiber_details**(img): model = get_model()
  model.load_weights('Segmentation.h5)
  img= get_image(file) y_pred = model.predict(img[None,...].astype(np.float32))[0]
  y_pred = np.round(y_pred.reshape((IMAGE_H,IMAGE_W, NUMBER_OF_CLASSES)),0) for i in range(IMAGE_W):
    for j in range(IMAGE_H):
      if y_pred[j,i]>0:
        img[j,i,1]=255
        img[j,i,2]=0
        img[j,i,0]=0
      else:
        img[j,i,1]=0
        img[j,i,2]=0
        img[j,i,0]=0 edges = cv2.Canny(img, 25,255)
  lines = cv2.HoughLinesP(edges, 1, np.pi/180, 30, maxLineGap=250)
  cnt=0
  for line in lines:
    x1, y1, x2, y2 = line[0]
    print(x1, y1, x2, y2, math.sqrt((x1-x2)**2)+((y1-y2)**2))
    cnt=cnt+1**print**('No of fibers: '+str(cnt)).........................................(Sample)**Output**72 764 166 167 356503.0
131 64 630 618 307415.0
66 764 188 136 394506.0
75 440 303 722 79752.0
91 468 291 715 61209.0
497 738 950 384 125769.0
141 94 637 590 246512.0
.........................No of fibers: 147

2.2.4 后处理

此步骤的目标是为 EDS 处理准备输出。能量色散 X 射线光谱(EDS)是一种分析技术，通常与 SEM 集成，用于分析样品的元素组成或化学特性。为了进行 EDS，通常，首先在样品表面收集 SEM 图像，然后在图像上手动标记具体位置，用于感兴趣物体的化学分析。一旦在图像上识别出所有感兴趣的位置，这些 XY 坐标被手动传送到 EDS 程序的用户界面，以对这些位置进行化学分析。这个手动过程非常耗时。

在自动化过程中，由 get_fiber_details 函数提供被识别纤维的(x，y)坐标作为输出。后处理包括以这样的方式对纤维进行分类，即在 EDS 过程中，SEM 内的样品台需要在两个指定位置之间移动最短的距离(相对于电子束)。因此，该步骤的输出是在图像中检测到的纤维的(x，y)坐标的优化图，这有助于减少 EDS 处理，进一步导致更有效的分析。该位置图被直接上传到 EDS 用户界面，用于对物体执行 EDS。

3 实施

语义分割模型使用 100 个铁石棉(空气样本)进行训练，训练/验证集的比例为 80-20。所有 100 个 SEM 图像将采用相同的成像参数拍摄，即尺寸、分辨率、亮度、对比度、HV、WD，所有图像的每个参数都是相同的。原则上，这些图像可以在不同位置的相同样本上收集，或者在具有相同对象的不同样本上收集。图 3 示出了从训练语义分割模型中使用的样本注释图像。

图三。用于训练的示例注释图像(作者提供的图像)

图 4 示出了屏蔽了检测到的纤维的 U-Net 语义分割模型的相应输出。正如可以观察到的，我们用我们的模型实现了> 95%的准确度(精确度)，仅用 100 幅图像进行了训练。

图 4。 U-Net 语义分割输出(图片由作者提供)

4 结论

鉴于石棉对健康的危害，我们提出了一种基于深度学习的语义分割神经网络来自动化石棉分析过程。据我们所知，这是第一篇报道使用语义分割进行石棉分析的实用性的文章。正如在实施部分中所概述的，至少对于空气样本图像，结果是相当有希望的，在空气样本图像中，我们能够基于在 100 个带注释的图像上训练的模型获得> 95%的准确度。

将来，我们计划扩展模型以适应大量的石棉样品，其中石棉纤维可能形成巨大的团块，只有很少的单纤维是可见的。在团块的图像中识别这些单纤维是困难和费时的。我们希望多类语义分割模型在这里将是成功的，因为它将能够检测和分类作为图像中的对象的纤维和纤维团。

参考

[1]https://asca-vabs . ch/asca/498/VDI _ richt linie _ 3492 _ jun 2013 . pdf

[2]“石棉:取样、分析和清理程序分析师指南”，ISBN: 9780717628759，系列代码:HSG248，2005。

[3] M. Scimeca，A. Orlandi，I. Terrenato，S. Bischetti，E. Bonanno，“通过 EDX 微量分析评估非小细胞肺癌中的金属污染物”，《欧洲组织化学杂志》，第 58 卷(3):2403，2014 年。

[4] M. Scimeca，A. Pietroiusti，F. Milano，L. Anemona，A. Orlandi，L. T. Marsella 等.“组织学标本的元素分析:揭开纳米石棉纤维面纱的方法”, Eur J histo chem，第 60 卷:2573 页，2016 年。

[5] M. E. Taylor，“法医科学中的扫描电子显微镜技术”，《法医科学学会杂志》，第 13 卷，第 269-280 页，1973 年。

[6] B. R. Bandli，M. E. Gunter，“石棉标准参考材料的扫描电子显微镜和透射电子背散射衍射检查、不同形态的闪石颗粒以及滑石矿石的颗粒相鉴别”，显微镜和微量分析，第 20 卷，第 1805-1816 页，2014 年。

[7] B.R. Bandli，M. E. Gunter，(2001 年)。使用纺锤台和扫描电子显微镜鉴定和表征矿物和石棉颗粒:以美国利比蒙大拿州闪石-石棉为例，《显微镜》，第 49 卷，第 191-199 页，2001 年。

[8] J. Long，E. Shelhamer，T. Darrell，“用于语义分割的全卷积网络”，IEEE 计算机视觉和模式识别会议论文集，第 3431–3440 页，2015 年。

[9] V. Badrinarayanan，A. Kendall 和 R. Cipolla，“ SegNet:用于图像分割的深度卷积编码器-解码器架构”，载于《IEEE 模式分析和机器智能汇刊》，第 39 卷，第 2481-2495 页，2017 年。

[10] O. Ronneberger，P. Fischer，T. Brox，“ U-Net:卷积网络用于生物医学图像分割”，载于:医学图像计算和计算机辅助干预，LNCS，第 9351 卷:234–241 页，2015 年。

[11]开源计算机视觉(OpenCV)，https://opencv.org/

自动接触追踪还不能应对未来的大流行

原文：https://towardsdatascience.com/automated-contact-tracing-is-not-ready-for-future-pandemics-609e8d6d9391?source=collection_archive---------81-----------------------

大型科技公司正在打开数据监控的潘多拉魔盒吗？

存放照片

相信总是比否认容易。我们的思维自然是肯定的。”—约翰·巴勒斯

当政府争先恐后地应对冠状病毒时，他们对自动化费力的手动接触者追踪实践的解决方案的请求引发了一系列技术。当谷歌和苹果宣布他们将联手启用曝光通知 API，以便应用程序设计人员可以建立跨两个移动网络的联系人跟踪解决方案时，技术社区的反应很快。

最初，正如《连线》本月早些时候报道的那样，卫生官员并没有这么草率:

“相反，在技术的有限帮助下，受灾严重的各州的公共卫生官员正在部署大批人员。马萨诸塞州预算 4400 万美元雇佣 1000 名接触者追踪员。在彭博慈善基金会的资助下，纽约州上周表示，计划招聘多达 17，000 名员工。加州预计将很快宣布计划雇佣多达 20，000 名联系人追踪员。

显然，地面接触追踪有更高的有效率。这需要感染者和医疗界的参与——这是一个繁重的过程，但它允许卫生当局识别受影响的个人，对他们进行诊断，并迅速确定社区影响。这个过程需要外柔内刚的治疗和病人的信任。

然而，对自动化合同跟踪解决方案的需求并没有减少。当英国政府最初在四月中旬宣布推出 NHS 冠状病毒智能手机应用程序，试图跟上不断上升的病例时，这一举动引起了一些恐慌。如果用户出现症状，他们必须在应用程序中注册自己的状态。这又被发送给在一段时间内与他们有联系的其他用户。

来自“大量蓝牙数据”的重新识别和侮辱用户的风险显而易见。同样，新加坡备受称赞的 TraceTogether 应用程序以隐私第一为宗旨，被用于医疗访谈。然而，它未能领先于病毒，只有 13%的国家采用。此外，卫生当局能够访问每个用户历史记录的详细位置信息，并在应用程序中粗略地通知患者进行自我隔离。

在印度，据 Reina Legal 的合伙人 Tripti Dahr 称，新冠肺炎对印度政府视而不见，该应用程序在一个以前没有数据保护立法的系统中启动。政府规定申请是强制性的；它每 15 分钟追踪一次用户位置；政府声明他们不对用户数据的影响负责；当涉及到目的排除、数据最小化和数据共享时，就有了模糊性。

虽然其中一些在最近几周有所逆转，但其后果对该地区的数据保护立法来说是一个关键案例。

在美国，北达科他州一个名为 Care19 的联系人追踪应用在用户不知情的情况下向 Foursquare 分享数据。据 Jumbo Privacy 的首席执行官 Pierre Valade 称，该团队发现该应用程序正在共享位置、匿名 ID 以及手机的广告标识符，其中包括手机名称、设备名称和设备唯一标识符(UDID)。

在 TraceTogether 和 Care19 解决方案中，使用了加密方法(在一定程度上)来匿名化用户身份和个人身份信息。然而，在这两种情况下，数据操作员都能够重新识别个人。印度的情况表明，政府获取这种离散级别的信息并不断跟踪其公民是不对的。

在我写这篇文章的时候，美国最近几天的抗议和骚乱已经浮出水面，有消息称官员们正在使用联系追踪来监视抗议者。

通过推特

“明尼苏达州公共安全专员约翰·哈灵顿说他们已经开始联系追踪被捕者…他们和谁有联系？他们在倡导什么平台？…这是有组织犯罪吗？…我们现在正在构建这个信息网络。”

虽然当局无意中“创造”了相同的术语来跟踪病毒，但已经明确的是，疫情病毒之外的接触者跟踪的真正意图，以及这将对个人和团体造成的最终伤害，因为这为政府机构和执法部门有效颁布新的跟踪方法提供了机会。

蒙特利尔人工智能伦理研究所**也强调了这些早期解决方案的缺点:

  • 任何集中式解决方案都使数据极易受到危害。该系统的创建者必须是数据托管机构，除非他们已经将此外包给第三方，并保护公民的数据。将解决方案快速推向市场还没有解决这些潜在的问题。如果这些系统将使用 ML 来补充应用程序的功能，也许应该从对抗 ML 和 ML 安全的角度进行更深入的调查，以确保这些系统的安全。
  • 所有解决方案都需要强有力的采用(超过 60%的人口)才能有效。这成为了一个障碍，尤其是如果这个系统不是强制性的，人们不信任这个系统和它的创造者。如果解决方案没有考虑到老年人、不太懂技术的人或社会经济弱势群体，尤其是在人们可能没有智能手机的情况下，采用该解决方案也可能会有障碍。
  • 用户是否对系统有足够的信任，能够放心地输入症状数据，尤其是在应用程序中可能需要使用 ML 模型功能的情况下？
  • 最终，不正确的预测、不正确的风险评分以及任何其他可能误导个人和决策者的问题都有可能弊大于利。

一个更加全球化的解决方案即将出现。苹果和谷歌宣布了一项隐私安全的合作伙伴关系，并依赖于最少的数据收集，使传统的联系追踪方法成本更低。

5 月 20 日，苹果发布了包含曝光通知的 iOS 13.5 更新。一旦下载，这将使卫生当局的合同跟踪应用程序。苹果非常明智地将其 API 限制为只有“授权配置文件”，每个国家一个，由政府实体认可。它还限制了开发人员的要求，以确保应用程序仅用于新冠肺炎响应工作，只允许收集响应工作所需的最少数据，并禁止向其他用户披露受感染用户的数据。

禁止使用基于位置的 API、收集设备信息的其他框架、用户位置或任何其他访问个人身份信息的数据。从表面上看，它为最终用户提供了必要的隐私保护和控制。然而，允许这些应用程序运行的沙盒并非没有隐私问题。它打开了以个人为代价尊重疾病的更本地化的解决方案的大门。

对蓝牙低能耗(BLE)技术的研究已经成为解决方案。许多研究论文和文章都对其性能和长期可行性提出了质疑。

我们采访了 Paul-Oliver Dehaye，他是 PersonalData 的创始人。IO ，以及 MyData 的成员，这是一个非营利组织，旨在“通过提高个人对其个人数据的自决权来赋予个人权力”。Dehaye 研究了近感探测，评估了 BLE 技术的可行性。

对 BLE 的兴趣源于对可扩展的、更高效的接触追踪的需求，以便快速部署封锁措施。接收信号强度指示(RSSI)是从两个移动设备的发射机和接收机之间的信号强度推断距离的度量。RSSI 应该随着距离的增加而减小。然而，根据 Dehaye 的说法，情况可能并不总是如此。

影响一个信号强度的因素有很多:“发射功率，发射设备天线路径；飞行路径；接收设备天线路径；和接收器灵敏度。”RSSI 解读的准确性现在质疑 BLE 的有效性。这些发现表明，以下情况可能会产生不一致的结果:

  • 当人们并排行走时，信号强度比他们前后行走时高得多。
  • iPhones 比 Android 发出更强的信号强度；Dehaye 指出:他的观点可能会引起关注，因为 iPhone 的拥有量与许多社会经济指标相关。”
  • 位于智能手机路径之间的障碍物(如家具或墙壁)可能会反射无线电信号，使其强度增强或减弱，因此，尽管距离相似，室内和室外位置可能会显示不同的结果。
  • 在相同距离内，放在桌子上的电话比放在钱包或口袋中的电话具有更高的信号强度。手机方向也可以表现出明显的差异。

不变的是，在一个场景中，5 个人可能坐在相距两米的房间中，打开窗户，信号也会检测到相邻房间中的另外两个人，石膏板将他们分开，错误地检测到比同一空间中所需的更多的人。在另一种情况下，邻居停下来与同一条街上大约相隔三米的另一个人聊天，感染的风险较低。

然而，蓝牙检测可以加强两个设备之间的信号，并且当它们不是相互接触时，将邻居标记为相互接触。假阳性和假阴性结果的真实可能性将使有效地检测接触事件和管理社交距离策略变得更具挑战性。点击阅读 Dehaye 的观点，了解来自 RSSI 的更详细观点。

正如 Dehaye 指出的，“谷歌和苹果的 API 相当于为了流行病学的目的而重新定义了接触的概念。更准确地说，谷歌和苹果让应用开发者能够构建自己不断发展的定义，但它们限制了应用开发者可能使用的输入。我们在上面已经看到，仅蓝牙数据的当前输入很可能太差。因此，应用程序可访问的数据量很有可能会逐步扩大，但苹果和谷歌会控制这种情况。”

对于那些可能不太关心并愿意放弃他们的数据以让卫生官员提前发现病毒的普通公众，Dehaye 说:

“你被洗脑了。没有数字屏障可以阻止病毒传染给下一个人。它只是记录更集中的数据，可以帮助我们更接近“背后”的感染者。确切地说，我们如何利用这些数据是非常重要的，也是非常政治化的，事实上，如果你认为已经有了广泛的共识，那你就错了。我们可以用一些方法来处理这些可能对最终结果有害的数据(净负面影响)。”

“通过利用谷歌和苹果 API 的基于蓝牙的邻近追踪，我们失去了将传播风险等同于物理邻近的共同认知基础。苹果和谷歌开始定义规则，并将逐步引入新的数据作为输入……这也将导致构成误报和漏报的实质性转变。”

多伦多的急诊医生 Kashif Pirzada 博士对一些接触者追踪应用程序开发者的工作提出了以下观点:

“电子接触者追踪的一些要素可能非常有用，但应该补充而不是取代公共卫生当局的传统接触者追踪。蓝牙低能量信号技术是一种很有前景但未经测试的方法，但不幸的是受到苹果和谷歌应用该技术的方式的严重限制。没有 GPS 数据，公共卫生当局将无法发现传播的“热点”，而这是苹果/谷歌框架所禁止的。一些隐私保护应用程序正在生产中，包括麻省理工学院的 SafePaths 和欧洲的 PEPP-PT，由于他们的强力干预，这些应用程序都不可行。存在明显的隐私风险，但可以针对此次危机制定强有力的数据安全和隐私立法。无论如何，有迹象表明我们可能遗漏了 90-95%的感染，因此如果总体病例数很高，当前的接触者追踪可能没有用，将不得不使用传统的人群水平控制(封锁、封闭、戴口罩)。”

自动联系追踪将重塑社会的未来，科技巨头将极大地影响其发展道路

尽管这项技术在应对当前危机时面临诸多挑战，但错误结果导致的决策会产生深远的社会影响。根据 Pirzada，我们作为一个社会愿意部署解决方案来获得一些感染的早期迹象，而没有适当的保护措施吗？

流行病学家仍在了解这种病毒的季节性以及它如何随着时间的推移而变异。从各方面来看，接触追踪技术在人群中移动时会产生动态分数，并了解它在感染和再感染人群中的表现。随着时间的推移，这将是一个免疫分数，政府将利用它来塑造个人行为，直到了解更多或发现疫苗。

除非我们能够减轻这些早期阶段固有的偏见，否则最弱势群体被社会污名化和持续边缘化的风险将扩大社会经济差距。

我们还了解到，新兴的独角兽——自动接触追踪将有助于预测病毒的路径，并使我们的经济恢复正常——将活跃机会主义。健康数据本质上是流动的，然而，这种珍贵的商品将成为政府服务器上的永久记录。加上技术，这将最终意味着蓝牙嗅探器的进步。

我们开始看到这些迫在眉睫的措施，以提高苹果谷歌 API 所呈现的匿名水平，但它们将扩大蓝牙信号之间数据的上下文需求。这是一种必然性。

向更分散的解决方案的转变现在受到了大科技的影响。然而，曾经被等同于边缘网络的匿名性会不会开始成为隐私的代名词？如果是这样，接触追踪会不会在我们宝贵的敏感信息中隐藏犯罪活动？

欧盟卫生网络为成员国开发了一个工具箱以响应针对新冠肺炎的接触者追踪应用解决方案，这是我们见过的最全面的要求之一。他们的工具箱提供了彻底的、不断发展的要求，随着经济开放和国家间旅行正常化，这些要求寻求协调方法。它呼吁:

  • 主动的公众教育:定期、清晰和全面的沟通
  • 促进利益攸关方之间的公开辩论和互动
  • 在数据控制器、技术提供商
  • 支持对解决方案的持续评估和审查，以确保数据最小化、存储限制、影响评估以及源代码可访问性和可问责性

隐私社区最近流传最广的一个问题是，隐私是会在疫情中幸存下来，还是会逐渐消亡？

没有人知道五年后世界会是什么样子。然而，政府的草率行动，隐私技术缺乏适当的资金和支持，以及完全无视隐私和加密的数字数据驱动的商业模式的兴起——所有这些都描绘了更加严峻的场景。

在隐私法中，当政府本身不遵守规则时会发生什么？最近的发现表明 NSH 将持有冠状病毒数据 20 年与这些现行立法不符。苹果和谷歌都证明了它们不可信。令人担忧的是，他们集体垄断了移动市场，现在他们是这些平台的法官和陪审团。

当我们把精灵从瓶子里放出来的时候，尽管是出于好意，我们会对发生的事情感到后悔吗？技术是加速我们的意图的一种手段，然而，没有控制，没有教育，没有广泛的讨论，没有审查，技术将定义我们作为一个社会。

合著者，Roxana Nasoi—Roxana Nasoi是一位隐私倡导者和技术战略家，拥有 7 年的行为研究经验。Roxana 目前是 Tagion/i25s ApS 的 CSO，Aimedis 的董事会成员，Impulse4women 的董事会成员，香港以色列贸易协会的董事会成员，以及 Ideagist 孵化器的顾问。**

最初发布于 Gritdaily

使用 Selenium、Pygsheets 从 Yahoo Finance 自动收集数据

原文：https://towardsdatascience.com/automated-data-collection-from-yahoo-finance-with-selenium-pygsheets-126539999d72?source=collection_archive---------24-----------------------

Alexandre Debiève 在 Unsplash 上拍摄的照片。

将数据收集掌握在自己手中的简单方法

最近，我一直在学习技术交易，以及算法如何帮助投资者做出高效和有效的决策。鉴于人工智能和机器学习在金融领域日益突出，我认为值得研究学生和年轻专业人士如何参与进来。在接下来的文章中，我将概述我在获取数据、清理数据和在 Google Sheets 中托管数据时采取的最初步骤。

概观

在这个项目的最初步骤中，我想找到一种方法来自动收集历史数据，确保它清晰易懂，并将其附加到 google 工作表中。由于我正在收集 50 只股票的数据，我知道我不想手动点击雅虎财经，改变日期范围过滤器，并下载数据 50 次。为了实现自动化，我决定使用 Selenium (webdriver、Keys 和 By)、Pandas 和 time 库。 Yfinance 是一个允许与雅虎财经轻松互动的 API，但我认为自己尝试自动化数据收集将是一个有趣而富有挑战性的项目。

第一步

首先，我必须决定要收集哪些股票的数据。为了做到这一点，我利用了我的 Robinhood 账户中的“观察列表”。在过去的两年里，我花了一些空闲时间交易、研究和测试某些策略。在整个过程中，我收集了有价值的反馈，帮助我了解了股票市场中什么可行(什么不可行)的开端。下面是我的股票代码清单的代码片段:

有了这个列表，我将能够使用股票代码在雅虎财经上搜索正确的股票，获取其历史数据，然后将其下载到我的电脑上。

第二步

我决定使用一个“while”循环来遍历列表中的每个值。在这个循环中，我将执行三个步骤:

  1. 首先，我将设置我的 web 驱动程序，并利用 selenium 抓取雅虎财经搜索栏，搜索正确的股票代码。在整个过程中，我将利用 time.sleep() 来说明缓慢的 WiFi 和/或需要一段时间才能在浏览器中编译的进程。下面的代码片段突出了我用来完成第 1 部分的代码:

构建自动化数据收集算法的第一部分

2.第二个，我会切换到“历史数据”标签页。然后，我将单击日期范围过滤器，将其切换到 5 年，并单击“完成”和“应用”span 元素以应用更改。

构建自动化数据收集算法的第二部分

3.最后，我将单击“下载数据”span 元素，等待 15 秒钟，让文件完全下载到我的计算机上，然后关闭我的 web 驱动程序。在这之后，我将“I”加 1，继续到列表中的下一个索引。这个循环将一直持续到我列表中的最后一只股票。

构建自动化数据收集算法的第三部分

第三步

在使用 pygsheets 将这些 CSV 文件读入 google sheets 后，我们有了一个如下所示的数据集:

[## 股票

TSLA 日期，开盘，盘高，盘低，收盘，调整收盘，成交量 2020-01-03，440.5，454，436.920013，443.01001，443.01777774856

docs.google.com](https://docs.google.com/spreadsheets/d/1VJbaZoem-XFa_uboQfJHVvx64ryOseM0sJvWN7PJXB0/edit?usp=sharing)

这个数据集的维度可以用我们 Jupyter 笔记本中的几行代码来验证:

虽然为我们的股票列表收集了 5 年的历史数据，但我将在下一篇文章中更进一步(我将编写一个 python 脚本，每天运行它来自动收集数据)。

补充说明:使用 selenium 有一种更简单的方法，通过用股票符号格式化 url 来直接进入历史数据页面。我还将在下一篇文章中介绍这一点(我决定不在本文中使用它，因为纯粹是为了挑战用 selenium 一页一页地浏览网站。

使用 Python 自动导入数据

原文：https://towardsdatascience.com/automated-data-import-with-python-832e8f912845?source=collection_archive---------40-----------------------

python 中数据文件导入的自动化方法。

SpaceX 在 Unsplash 上拍摄的

数据导入在数据科学中起着举足轻重的作用。知道如何做可以防止模型失败的可能性。为了实现这一点，不同的方法取决于数据类型(例如 csv，。txt，。json)，都有可能。

将数据放入 python 环境是构建模型的基本步骤之一。在某些情况下，我们必须在不使用 API 或 SQL 数据库的情况下加载数据。在本教程中，我将介绍如何在 Python 中自动加载数据。编译这个可能有点棘手。此外，有可能找到一种简单的方法来做这件事。但是我想让你看看我复杂的方法。所以让我们开始吧。

入门指南

在开始之前，让我们使用以下命令导入必需的库。在适当的时候，我会解释为什么我们需要这些模块。

import pandas as pd
import os
from os import listdir
from os.path import isfile,join
import csv

下图显示了包含几种数据文件类型的数据文件夹。请记住文件名。我们将使用它们来创建变量名。

通常，我宁愿将我的工作目录指定为文件路径。这让我可以快速地组合文件路径和文件夹名称。

**#assign working directory to variable**
file_path=os.getcwd()**#setting path for data folder**
data_path=file_path+'\\'+'data'

提取文件名

这一步至关重要，因为我们将从文件名中生成变量名。有两种不同的代码来提取文件名。第一个有扩展，另一个没有扩展。我们使用 【列表目录】 和【is file】方法获取文件名。【listdir】方法是获取指定目录下所有文件的列表。在我们的代码中，目录是【data _ path】，这是我们不久前分配给我们的工作目录。所以，【is file】方法检查该文件是否存在于该文件夹中。

**# extracting file names without extensions**
file_names=[".".join(f.split(".")[:-1]) for f in listdir(data_path) if isfile (join(data_path,f))] **# extracting file names with extensions**
full_file_names=[f for f in listdir(data_path) if isfile (join(data_path,f))]**#checking file names and extensions** print(file_names)
print(full_file_names)

获取分隔符

到目前为止，一切都很好。现在是时候检测文件中使用哪个分隔符作为分隔符了。要做到这一点，我们需要由"类提供的方法。这个类用于推导 csv 文件的格式。**

****#creating a dictionary with file names and their extensions**
dict_del={}
delimit=[]
for i in range(len(file_names)):
    delimit.append(i)
t=0
for s in full_file_names:
    with open(data_path+'\\'+s, newline='', encoding="utf8") as csvfile:
        dialect = csv.Sniffer().sniff(csvfile.read(1024))
        csvfile.seek(0)
        reader = csv.reader(csvfile, dialect)
        delimit[t]=dialect.delimiter
        dict_del[s]=delimit[t]
        t+=1**

正如你注意到的，我们建立了一个字典和一个列表。名为 【分隔符】 的列表用于存储分隔符。我们使用 for 循环语法，通过索引用提取的分隔符轻松替换随机值。字典包含文件名(作为键)和分隔符(作为值)。让我们检查一下我们有什么；

****#checking dictionary and delimiters**
print(dict_del)
print(delimit)**

一个有风险的方法:globals()

是时候使用“【globals()”方法来创建变量了。有消息来源 ( 链接 ) 说它危险是因为它是全球性的。 这种方法会造成混乱，所以请仔细阅读！

****#creating global variables depend on file names**
z=0
files_ready=[]
for f,r in zip(file_names,full_file_names):
    globals()[f]=pd.read_csv(data_path+'\\'+r,sep=dict_del[r])        
    files_ready.append(f)
    z+=1**

如果您注意到，变量是为每个文件名单独创建的。我们完了！让我们确保它有效。

****#checking data files**
print(files_ready)
bank.head()
deacit.head()
netflix_titles.head()**

瞧啊。我们加载了所有文件，并给它们分配了一个变量。

最后，让我们对一个新的数据文件进行双重检查。我刚刚保存了一个.txt文件。(PSA)

我想知道它是否有效。

****#checking the new file**
print(files_ready)
PSA.head()**

一切似乎都运转正常。

最后的想法

正如我之前所说，我并不声称这些是实现这一目标的唯一和容易的选择。本教程是我创建的自动化过程的方式。随意开发代码。😃

****优点:

  • 只需运行代码，在短时间内加载几个文件。
  • 你不需要考虑变量名。
  • 你不会错过任何新文件。

****缺点:

  • 我测试的代码只有 csv 和 txt 文件。
  • 可能有更简单的方法。请去看看:)

有用链接

  • 学习如何使用 split()函数(链接)
  • os.path.join 和 os.path.isfile ( 链接)

概述

数据导入本质上是一项繁重的工作，但它仍然是构建数据模型的重要组成部分。你可以找到并使用更多的方法。

构建您的方法将提高您的编码技能。我希望这个指南对你有用。感谢阅读到最后。

****代码:

** [## eser saygı客户细分主管—图尔基耶 i̇ş银行| LinkedIn

经验丰富的项目主管，有银行业工作经验。英语熟练…

www.linkedin.com](https://www.linkedin.com/in/esersaygin/)**

实时 Tableau 公共可视化的自动化 ETL

原文：https://towardsdatascience.com/automated-etl-for-live-tableau-public-visualizations-54f2b8652224?source=collection_archive---------34-----------------------

Python，Google Sheets，Tableau Public，Windows 任务调度器

https://public.tableau.com/profile/eklavya.saxena#!/viz home/CoronavirusCOVID-19 cases world wide/新冠肺炎 _Country

在积极寻找全职工作机会的同时，在新的冠状病毒新冠肺炎爆发的不确定时期，我感到有必要创建一个一站式 Tableau 可视化仪表板来提高认识。渐渐地，我发现了零美元资源来保持更新或者在 Tableau Public 上生存。我希望这有助于我们保持更新，而不必经常粘在新闻频道上，我相信这有时确实会令人沮丧。

当我的一位采访者对我的见解和陈述表示赞赏，但同时引用“你对新冠肺炎数字的可视化很低，哦！不更新”。

那一刻，我感到受到了的挑战。在那之前，和我们许多人一样，我一直相信 Tableau Public 不可能有实时数据。如果你想打破这个神话，你来对了博客。简而言之，Google Sheets 就是你的答案。

这篇博客分为两个部分，有效地涵盖了实时 Tableau 公共可视化的自动化 ETL 的所有方面。

1。从 GitHub 提取数据并自动运行或调度 Python 脚本

这一部分(点击上面的链接标题)将讨论如何从 raw 中提取数据。GitHub 用户内容的 csv 文件，以及如何在 Windows 上使用任务调度程序自动运行 Python 脚本，包括以下子部分:

  1. 从原始数据中提取数据。GitHub 用户内容的 csv 文件
  2. 使用 Windows 上的任务调度程序自动化 Python 脚本

[## 从 GitHub 提取数据，并自动运行或调度 Python 脚本

博客的第一部分——实时 Tableau 公共可视化的自动化 ETL

towardsdatascience.com](/data-extraction-from-github-and-auto-run-or-schedule-python-script-9d1910239085)

②。Python 熊猫 data frame to Google Sheets for Tableau Public LIVE

本部分(点击上面的链接标题)将重点介绍如何使用 pygheets 库将 Pandas Dataframe 转换为 Google Sheets，以及如何使用 Google Sheets 启用 Tableau Public LIVE，包括以下子部分:

  1. 启用 Google Sheets API 并创建凭证
  2. 将 Python 连接到 Google Sheets 并导出数据帧
  3. 使用 Google Sheets 启用 Tableau 公共直播

[## Python 熊猫数据帧到谷歌表格桌面直播

博客的第二部分——实时 Tableau 公共可视化的自动化 ETL

towardsdatascience.com](/python-pandas-dataframe-to-google-sheets-for-tableau-desktop-live-cc1f86982bca)

感谢您的阅读！我希望这篇博客揭示了一个有趣的方面，即如何为 LIVE Tableau 公共可视化创建自动化 ETL。如果你觉得这有帮助或者没有帮助，请在评论中告诉我。如果这篇文章是有帮助的，分享它。

[## Eklavya Saxena -印度|职业简介| LinkedIn

精通数据的分析师和有抱负的数据科学家，拥有 2 年以上的销售或客户行业经验…

www.linkedin.com](https://www.linkedin.com/in/eklavyasaxena/)

自动化:算法如何塑造你我的生活

原文：https://towardsdatascience.com/automated-how-algorithms-shape-my-life-and-yours-9e885d258954?source=collection_archive---------34-----------------------

算法的目标不是给用户他们喜欢的内容，而是让用户更可预测。

泰勒·拉斯托维奇摄于佩克斯

这原本是我关于机器人、自动化和人工智能的免费博客 上的专题。

我认为，上周我对推荐系统的分析的逻辑后续(值得一读)将是我可以了解到的关于影响你我的算法的演练， 在低层次上 。这是一项调查，包含一些公司使用的具体指标和我发现的主题的高级分析。大多数情况下，它会变成一篇完整的研究论文，这篇文章是我发现的文章的精华，如果你对某个特定的球员感兴趣，可以通过链接阅读更多内容。

在做这项研究时，算法互动的点比我预期的要多得多——我的意思是，算法可以以比我们预期的更多的方式接触我们和互动。有人应该研究人类大脑中算法竞争的游戏理论。抖音的算法如何帮助它留住 Youtube 可能吸引的用户？如果人们想弄清楚一个应用程序是如何工作的，希望这是一个起点。

如果你想从这篇文章中获得最大的价值，点击几个链接。

来源——纽约伊萨卡的作者。

推荐系统和这些平台的一个总主题是:如果我们可以预测用户想要做什么，那么我们就可以把这个特性加入到我们的系统中。

一般问题的表述是:复合互动如何改变我们的行为方式，以及如何损害我们的福祉。

核心玩家

脸书、苹果、亚马逊、网飞和谷歌通常是最令人垂涎的公司，它们对世界人口有着巨大的影响。这篇文章并没有深入到这些公司的所有地缘政治和伦理问题，它只是试图展示它们是如何运作的。

脸谱网

该算法旨在向个人展示他们圈子中的事物，并让他们参与其中。这考虑了内容的来源、用户的地理位置、用户的社会地位、用户参与的历史、付费广告等等。该算法已经被研究得足够好，以至于意识到它具有戏剧性的效果，但对任何一个输入进行调节都是不可能的，因此通常被称为危险的黑盒。这种情况的二阶效应是，算法最终会预测你所在的圈子，并引导你进入其中部(如果你的圈子一开始是温和的，有时会被称为极化)。

我断断续续地使用 Instagram，最大的影响可能是促使我尝试美化我的生活，但谢天谢地，我认为这种影响很小。

【来源:华尔街日报， WSJ2 ， Verge ，脸书艾

推特

该算法类似于脸书的算法，但更有活力——尤其是对于拥有大量受众的用户。从 Twitter 本身来说，它考虑了以下特性:

推文本身:推文的新近性、媒体卡(图片或视频)的存在、总互动(如转发或点赞的数量)

推文作者:你过去与该作者的互动，你与他们的联系强度，你们关系的起源

你:你发现过去参与过的推特，你使用推特的频率和频繁程度

说实话，这个不多说。鉴于 Twitter 的怪癖，我可以看到他们有一个模糊的端到端优化器，没有太多的控制。

我绝对沉迷于 Twitter 上的知识活力和对其他知识分子的访问。这些蓝色的通知泡泡让我。

【来源:萌芽社交，推特博客，Hootsuite——一家社交媒体营销公司】

油管（国外视频网站）

细看一个神秘的娱乐平台。虽然由一家美国上市公司管理，但有多项研究显示了跟踪激进化途径的建议(见下文 NYT)，甚至显示了儿童令人不安的材料(纽约时报 2)。丰富的内容使得一系列的推荐具有难以置信的深度和影响力。既然公司正在与抖音竞争，我希望看到更多的公众见解。

我在 Youtube 上消费了很多休闲内容。我认为观看乔·罗根的视频片段让我获得了一些特朗普的广告(是的，拜登的广告更多)，但它让我思考我正在观看的视频是如何漂移的。

【来源: NYT ，纽约时报，购物化——是的他们分析 Youtube 算法？]

谷歌

作为第一个广泛有用的搜索引擎，每个人都使用谷歌。谷歌使用各种工具来索引网页(参见 PageRank 作为起点),包括文本、到其他页面的链接、网站上读者的历史等等。它在信息传播方面的作用至关重要，我担心它会有无法追踪的偏见。

在反垄断听证会和竞争对手的背景下，他们的地位更加岌岌可危。近年来，谷歌改变了搜索结果，加入了更多的广告和自我参考结果(尤其是在旅游和购物等有利可图的搜索中)。这种自我参照在我看来是与谷歌竞争的角度。

谷歌控制着我查找其他学术论文、博客、新闻等的方式。我不知道如何衡量超越大的影响。

【来源:《华尔街日报》， The Mark Up ，搜索引擎杂志

来源-作者。

未来的玩家

在这些领域，我看到算法以新的方式发挥作用，特别是以可能对一些人不利或有有害影响的方式。

新闻

传统媒体在线转移(《纽约时报》、《华尔街日报》等。)和新的在线出版物(媒体等)。)将圈住我们的政治和全球世界观。Clickbait 已经转变为阅读时间，但这从一个 clickbait 标题变成了一个 clickbait 标题+一个 readbait 介绍性段落。我在自己的中型文章中看到了这一点的影响——我的写作被调整到算法上(这很有效——教程、代码示例和列表比深入分析获得了更多的浏览量)。全世界的阅读人群正在 Substack 上重新崛起(还有其他平台——比如上下文是最近的事件)。

除了 clickbait,《纽约时报》开始在新闻平台上使用研究参与算法(具体来说，就是所谓的语境强盗— 研究中的语境)。坦率地说，当我阅读新闻时，我想阅读带有次要补充意见的事件。我不想控制我接收国内和国际新闻的方式，但这是一个预期的发展。

Medium 把我从 clickbait 逼到 Substack(这里)。我订阅了更多的时事通讯，如果趋势继续发展，我可能会退订《NYT》和《华尔街日报》。美国完全被特朗普毁掉的画面对我来说太狭隘了，没有给我足够广泛的教育——作为一个狂热的特朗普批评者。

[来源: NYT

购物

亚马逊希望成为购物的首选搜索引擎。他们正在扩展到许多不同的购物领域(如食品杂货、零售等)，以更好地了解个人需求。当你让 Alexa 提醒你一些事情时，那也可以被记录下来。这些构成了广告和销售的多模态推荐系统。

脸书创建了一个新的市场，试图对抗亚马逊的统治。脸书希望成为 Shopify(没有其他公司，Shopify 不是亚马逊的竞争对手)和供应商的中间人，创造一个人们可以购买任何东西的平台。在不同的激励(金融)下，看看这种情况如何发展会很有趣。

我已经采取措施减少使用亚马逊。它的推荐很奇怪，充满了重复的内容，但仍然非常方便。脸书市场的前景让我想到了更加自动化的客户-供应商连接。

【来源:】菜谱 快递，轴，销售

服务

新的应用程序将在许多领域提供价值:包括金融市场准入、客户分析、拼车等。首先，这些服务将较少受到公众监督，但时间会证明，它们中的许多将会产生极其有害的算法效果。我在未来的玩家中加入了服务，因为从采用到出现问题的时间尺度将会非常短(应用可以在用户中爆炸，参见 Zoom 的例子)。负面指标通常落后于采用，除了在最不经思考的服务可能永远的例子中。

【来源:加州大学伯克利分校金融科技，性别化人工智能失败，零工经济

二阶效应

这些是未讨论的当前应用程序，值得就可能的副作用(最初积极的应用程序)提出质疑。

消费设备

苹果手表试图为用户检测房颤，这带来了一个巨大的假阳性问题(见下面的 StatNews)。毫无疑问，技术公司将试图为他们的设备添加更多功能，随着数百万用户的市场渗透，不可避免的假阳性率将具有潜在的医疗和财务影响。这些设备和误导性数据点的复合效应将在 21 世纪 20 年代被观察到——不知情者面临的风险最大。

【来源:苹果、 StatNews 、 Oura

公共医疗/卫生工具

在健康领域有许多新公司，比如将分析锻炼的 stirry . ai 和将分析血液测试以给你健康评分的 Bloodsmart.ai(基于标准化的、经年龄调整的死亡风险)。这是初步的，但是游戏化一个人的健康来了。在苹果的“填充戒指”手表活动之后，仅仅几步之遥就是健康仪表板，告诉用户他们的习惯如何在数字上缩短他们的寿命。

我现在不怎么使用追踪器了，但是仅仅是在我的手表上有一个估计卡路里的读数就让我意识到当一天不锻炼的时候吃得太多了。这个问题会因血液指标或情绪健康的嘈杂读数而加剧。

【来源:奋斗，血拼

这不是机器人博客吗？

我们在关于推荐器和算法的民主化自动化的最后两次迭代中所说的一切都将在未来十年适用于机器人系统。我预测，在大型科技公司(根据一些研究提供的信息)管理的机器人的激励下，机器人与人类互动的渗透率将大幅增加。

少数制造个人机器人的小公司可能看起来更令人兴奋(例如 Hello Robotics )，但市场份额一开始会相对较小(高成本)，而许多公司可以用具体化的自主代理取代人类收银员和销售人员。

我做了一个资源追踪这些算法什么时候出错，还有一些哲学背景。

[## NATO Lambert/机器人-伦理-书籍

为对机器人伦理学感兴趣的人收集的读物。我从一系列机器故障开始…

github.com](https://github.com/natolambert/robot-ethics-books) [## 自动化大众化

一个关于机器人和人工智能的博客，让它们对每个人都有益，以及即将到来的自动化浪潮…

robotic.substack.com](https://robotic.substack.com/)

像这样？请在 https://robotic.substack.com/订阅我关于机器人、自动化和人工智能的直接时事通讯。

自动机器学习(AutoML)简介— TPOT 模块案例

原文：https://towardsdatascience.com/automated-machine-learning-automl-gentle-introduction-tpot-module-case-f5d5a73b2b29?source=collection_archive---------35-----------------------

自动机器学习模块简介

斯坦纳·恩格兰在 Unsplash 上拍摄的照片

根据维基百科的说法，自动机器学习或 AutoML 是将机器学习应用于现实世界问题的过程自动化的过程。AutoML 旨在从原始数据到可部署的机器学习模型建立一个完整的管道。用一个更简单的术语来说， AutoML 能够自动创建一个机器学习模型，而不需要先前的模型的先验知识。AutoML 本身仍然是人工智能领域最受欢迎的产品之一。

直到 2019 年或者最近，AutoML 正处于人们对人工智能期望的巅峰。不管是什么原因让人们大肆宣传 AutoML，不可否认的是，这个 AutoML 将极大地改变人们在数据科学领域的工作方式。作为一名数据科学家，我也在日常工作中应用 AutoML。

AutoML 是未来，但它并不像没有任何不利的一面。关于 AutoML，我注意到的几件事是:

  • 它不会取代数据科学家的工作。我们毕竟是人，是决定哪种结果可以产生和部署的人。
  • 数据还是最重要的。您可以将任何原始数据放入模型，但是不需要任何预处理或关于数据的进一步知识；不会有好的结果。
  • 预测指标是唯一的目标。在数据科学工作中，预测模型不一定是我们唯一想要的东西。大多数时候，我们想要的是模型对数据的解释。如果你的目标是知道什么特性是最重要的，那么 AutoML 是不合适的。

虽然有一些缺点，但 AutoML 仍然是数据科学领域的一个突破，作为一名数据科学家，了解它是理所当然的。在这篇文章中，我想介绍如何实现 AutoML 和一个 AutoML 模块；TPOT。

TPOT

TPOT 的好意

是一个优化机器学习流水线的 Python AutoML 模块。它将智能地探索成千上万个可能的管道，以找到最适合您的数据的管道，一旦它完成搜索(或者您厌倦了等待)，它会为您提供找到的最佳管道的 Python 代码，以便您可以从那里修补管道。在 TPOT 探索的大部分 python 代码都是基于 Python 模块 Scikit-learn (不限于，但大部分都是)的，这是大多数使用 Python 从事 ML 工作的人所熟悉的。

机器学习管道的例子。由 TPOT 提供

探索过程基于遗传编程。根据维基百科的说法，这是一种进化程序的技术，我们从不适合的(通常是随机的)程序群体开始，通过对程序群体应用类似于自然遗传过程的操作来适应特定的任务。更简单地说，它从随机 ML 模型开始，通过选择模型(和参数)的随机过程，它将走向最佳模型的方向。TPOT 使用的参数中有许多生物技术术语，但我会在后面解释一些重要的参数。

TPOT 既用于分类问题，也用于回归问题，基本上是一个监督学习问题，我们需要预测目标数据。让我们试着用 TPOT 做一个例子。

TPOT 的例子

出于学习目的，我将使用从 Kaggle 获得的心脏病数据集。数据的快照如下所示。

**import pandas as pd
heart = pd.read_csv('heart.csv')
heart.head()**

您可以阅读源中每一列的解释，但是这个数据集正在处理一个分类问题；不管某人是否有心脏病。我不会做任何数据预处理，因为我的意图只是给出一个 TPOT 如何工作的例子。

首先，我们需要安装模块。使用 TPOT 的建议是使用 Python 的【Anaconda】发行版，因为许多必要的模块已经存在。然后，我们通过 pip 或 conda 安装模块。

****#Using pip
pip install tpot#or if you prefer conda
conda install -c conda-forge tpot****

现在我们准备使用 TPOT 模块来尝试我们的 AutoML。让我们导入所有模块，并准备我们将使用的数据。

****#Import the TPOT specific for classification problem
from tpot import TPOTClassifier#We use the train_test_split to divide the data into the training data and the testing data
from sklearn.model_selection import train_test_split#Dividing the data. I take 20% of the data as test data and set the random_state for repeatabilityX_train, X_test, y_train, y_test = train_test_split(heart.drop('target', axis = 1), heart['target'], test_size = 0.2, random_state = 101)****

所有的准备工作都已就绪，现在让我们尝试使用 TPOT 的 AutoML 来解决分类问题。

****tpot = TPOTClassifier(generations=100, population_size=100,
                          offspring_size=None,
                          scoring='accuracy',
                          max_time_mins=None, 
                          max_eval_time_mins=5,
                          random_state=101,
                          warm_start=True,
                          early_stop=20,
                          verbosity=2)****

这个分类器似乎有很多参数，是的。您可以在这里检查 TPOTClassifier 中存在的所有参数，但是我将在下面解释一些重要的参数:

  • 世代控制运行流水线优化过程的迭代次数。
  • population_size 控制每一代遗传编程群体中保留的个体数量。
  • 后代尺寸控制每一代遗传程序中产生的后代数量。默认情况下，它等于第代的大小。****

总的来说，TPOT 将评估 人口 _ 规模 + 世代 × 后代 _ 规模 管道。因此，上面我们将有 100 + 100 × 100 个管道需要评估。

其他重要参数包括:

  • 评分控制功能用于评估给定管道对于分类问题的质量。参见评分功能这里的了解可以使用的评分功能。
  • max_time_mins 控制 TPOT 优化管道的时间。如果是没有，那么 TPOT 将不会有任何时间限制做优化。
  • max_eval_time_mins 控制 TPOT 评估单个管道的时间。更长的时间意味着 TPOT 可以评估更复杂的管道，但需要更长的时间。
  • warm_start 是指示 TPOT 实例是否将重用来自先前调用的群体的标志。设置 warm_start =True 可用于在数据集上短时间运行 TPOT，检查结果，然后从停止的地方继续 TPOT 运行。
  • early_stop 控制多少代 TPOT 检查优化过程中是否没有改进。如果在给定的数量之后没有更多的改进，那么 TPOT 将停止优化过程。

根据上面的参数，让我们尝试用我们的训练数据来拟合 TPOTClassifier。

**tpot.fit(X_train, y_train)**

优化过程如下所示:

如果每个管道都已经被评估，达到时间限制，达到提前停止限制，或者简单地终止，优化过程将停止。下面是我们之前尝试的 AutoML 过程的结果。

管道似乎已达到最大提前停止次数，并到达最佳管道。当然，由于这是一个随机过程，如果我再运行一次，我可能会得到一个完全不同的模型。

如果我们对照测试数据进行测试，让我们检查模型性能。我们可以使用优化的 TPOT 模型作为预测模型。

**from sklearn.metrics import classification_report
print(classification_report(y_test, tpot.predict(X_test)))**

尽管没有做任何预处理，这个模型看起来很好，虽然我敢打赌，如果我们分析数据，我们可以得到一个更好的模型，但让我们把它留在那里。

现在，如果您想拥有一套完整的管道自动导出，您可以使用下面的代码。

**#Give any name you want but still contain the .py extension
tpot.export('tpot_heart_classifier.py')**

完整的管道将显示在您的文件夹中，就在您的笔记本所在的文件夹中。如果您打开该文件，它将如下所示:

正如我们所看到的，我们不仅得到了最好的管道，还得到了完整的流程纲要。

结论

我只是向你展示如何使用 TPOT 汽车。这个过程很简单，从评估的角度来看，结果还不错。虽然， AutoML 不是实现最终结果模型的工具；事实上，AutoML 只是作为模型优化的开始，因为它可以为我们指明前进的方向。

如果您喜欢我的内容，并希望获得更多关于数据或数据科学家日常生活的深入知识，请考虑在此订阅我的简讯。

如果您没有订阅为中等会员，请考虑通过我的推荐订阅。

梯度推进机器的自动机器学习

原文：https://towardsdatascience.com/automated-machine-learning-for-gradient-boosting-machines-48cd38ad9649?source=collection_archive---------80-----------------------

如何利用 NNI 提升梯度增强机器的超参数调节水平

像 XGBoost 和 LightGBM 这样的梯度推进机器是当今最受欢迎的机器学习算法之一，经常出现在 Kaggle 竞赛的获胜者中。尽管它们开箱即用，但通过调整算法的参数可以获得一些性能提升。此外，参数数量太多，无法直观设置或依靠快速试错法。AutoML 前来救援。

AutoML——自动化机器学习——旨在使机器学习自动化。在这里，我们主要关注超参数优化的 AutoML。我们将研究三种不同的算法，每种算法都有不同的优势:Metis、贝叶斯优化超带(BOHB)和基于群体的训练(PBT)。据我所知，最后一个还没有适应梯度增压机。正如我们将看到的，PBT 和 GBM 的结合有一些有趣的含义。

可以在 GitHub 上找到完整代码:https://GitHub . com/NKDataConv/AutoML _ Gradient _ Boosting _ Machines。我们将使用工具 NNI 中的 AutoML 算法。你可以在这里找到安装 NNI 的说明。此外，我们将需要 LightGBMs，你可以在这里找到安装指南。

让我们从 Metis 开始，了解如何为 NNI 调整算法培训。

墨提斯

梅蒂斯的想法很简单。Metis 建立了一个参数与性能的模型。在一些初始随机试验后，该模型可以推断出有希望的参数配置。尝试这些，并根据存档的性能更新模型。Metis 背景中的模型是高斯过程，并且利用贝叶斯优化进行更新。

为了使您的算法适应 Metis，您需要做的就是添加两个描述实验的文件，并将两种方法集成到您现有的代码中。让我们先看看方法: nni.get_next_parameter() 给出下一个要尝试的参数配置。其次，nni . report _ final _ result()将存档的绩效进行反馈。

在下面的代码片段中，您可以看到这两种方法是如何与训练过程的其余部分一起发挥作用的。完整代码可在 GitHub 上获得。

在第二行中，生成了一些默认参数。还包括一些 AutoML 没有调优的参数。

您还会注意到，数据被分成四部分:训练集、测试集和两个验证集。现在，你可能想知道，为什么要有两个验证集。也许这不是绝对必要的。尽管如此，我认为这是一个好主意。关于这一点，让我直言不讳。训练集是针对机器学习算法本身的。在训练过程之后，在验证集上测量性能。通常，您执行一些迭代训练和验证。在此过程中，您需要手动检查验证集的性能。在训练和验证之间经过足够的周期后，验证数据集上的过度拟合可能会发生。这就是为什么我们应该拿出一套测试设备的原因。有了 AutoML，训练和验证之间循环变得更加复杂，而且要进行多次。因此，拥有一个测试集比以往任何时候都更重要。该测试集仅在 AutoML 的整个过程完成后使用。

现在来看两个验证集。第一个用于确定提前停止。提前停止是一个非常强大的想法。与梯度提升机器相结合，它确保当验证数据集的性能不再提高时，不再添加更多的树。但这本身就是对验证数据的优化。请记住，我们从验证数据集转移到测试数据集，因为验证数据已经发生了优化，我们不想过度适应。这同样适用于这里。我们通过提前停止优化第一个验证集。然后，我们转向超参数优化。这就是我们使用第二个验证数据集的地方。总结:将验证一分为二的优势在于，超参数优化不会发生在早期停止后产生良好结果的参数上。相反，它针对参数进行了优化，在训练过程(包括提前停止另一部分数据)之后，这些参数会产生良好的结果。

需要注意的一件非常重要的事情是报告回来的最终分数的性质。它不一定是可微的。在这里，是准确性。但是分数可以是任何东西，甚至是你自己定义的损失。基于这种损失，超参数被优化。通常，对于机器学习中的优化，损失必须是可微的，以找到最小值。这里的情况不是这样。这在陈述问题和性能测量方面提供了很大的自由度。我们可以在这里陈述我们真正关心的东西(而不是关注数学性质)。

现在，让我们回到代码。需要一个额外的文件 search_space.json 来描述参数搜索空间，从该空间对超参数进行采样。

这是一个 JSON 文件。参数的名称是关键，括号中是获取新值的策略(此处仅使用随机整数和均匀分布)。更多策略可用，见此处。)

第二个文件 config.yml 描述了 AutoML 配置。

这是 YAML 的档案。要注意的最重要的事情是获得正确的优化模式。当我们在这里优化精度时，我们希望将其最大化。如果你要使用像均方差这样的损失，你可以将它设置为最小化。

现在，可以从相应文件夹中的命令行启动实验:

nni CTL create—config config . yml

最后，您可以在 NNI UI 上观察结果。

用于超参数调整的 NNI 用户界面

BOHB

这种算法也做贝叶斯优化，但有另一个很酷的功能。这种特性称为连续减半。总的想法是，对整个数据集的训练在计算上是昂贵的。所以你开始只训练几轮助推。在这些提升回合之后，你比较表现，并且只继续最成功的回合。他们再次接受几轮训练，并再次比较他们的表现。这一直持续到只剩下一个配置。这是最成功的配置。该过程可以分别节省资源和时间，因此，对于需要花费太多时间进行多次训练的大型复杂数据集来说，这是一种很好的方法。

我们需要做一些小的改变来适应 BOHB。

首先要注意的是参数 TRIAL_BUDGET 。这个是 BOHB 自己设置的，不需要包含在 search_space.json 中。 TRIAL_BUDGET 负责保持第一次试验规模较小，并在以后的试验中延长试验时间。这个想法是有 10 个助推轮的倍数。在 TRIAL_BUDGET = 1 的情况下，将有 10 轮助推。用 TRIAL_BUDGET = 2 ，会有 20 轮助推，以此类推。这有一个缺点，参数 boosting_rounds 将不再包含在超参数优化中。

第二个要注意的是方法nni . report _ intermediate _ result。这不是绝对必要的，但是在 UI 中提供了一些很好的可视化效果。
最后，for 循环在第一次迭代和所有其他迭代之间存在差异。这是为了在第一次迭代中启动助推器(分别是模型)。在进一步的迭代中，模型将加载参数 init_model 和已经训练好的模型作为参数。

其他两个文件基本保持不变。

聚对苯二甲酸丁二醇酯（polybutylene terephthalate 的缩写）

现在让我们看看 PBT。这个想法类似于进化算法。PBT 总是训练一群算法。最有希望的那些将其超参数配置复制到群体中最没有希望的那些。通过应对，超参数出现微小变化。在一定的机会下，最没有希望的配置被新采样的配置替换。从一个算法到另一个算法的超参数的处理有很大的意义。在整个 AutoML 训练结束时，我们不会以某个超参数配置结束。相反，它是算法被训练的不同超参数的历史。我们还有一个训练有素的模特。利用 PBT，可以在开始时以较大的学习速率训练算法，在结束时以较低的学习速率训练算法。或者也许它有一些优势，开始时树的深度较低，结束时树的深度较高。有了 PBT，这一切都成为可能。而且是自动进行的。

与其他算法相比的一个缺点如下:通常你会在训练和验证集上找到一个好的超参数配置。然后你在你的测试集上测试它，如果你满意，在整个数据集上再次训练它。尚不清楚这对于 PBT 是否有意义。由于 PBT 返回训练好的算法，因此在整个数据集上复制超参数配置的历史可能没有意义。

最后，让我们再次看看执行情况。

作为 PBT 的一个附加参数，我们有检查点目录。它们是在一次迭代结束时从群体中保存模型并在下一次迭代开始时再次加载它们所必需的。PBT 和 NNI 会自动将来自不同群体的模型保存在专门的文件夹中。

现在你可以开始你自己的 AutoML 实验了。我建议从梅蒂斯开始。如果您的数据量很大，而时间又很紧，那么就转到 BOHB 吧。如果你可以在训练过程中忽略一些数据，尝试 PBT。如果你让我知道你的自动化实验进展如何，我会很高兴。

自动化机器学习不应该让数据科学家担心

原文：https://towardsdatascience.com/automated-machine-learning-shouldnt-worry-data-scientists-9a54dfef0491?source=collection_archive---------41-----------------------

意见

这些工具只做数据科学中简单的部分

照片由丹尼尔·塔特尔在 Unsplash 上拍摄

最近，我一直在看到很多服务和产品宣传机器学习的自动化。数据机器人和 H2O.ai 提供了允许在点击界面中创建机器学习算法的平台。他们甚至会为你做特征工程！这种功能，或者类似的东西，正在慢慢地被构建到各种工具和程序中。他们承诺自动化整个机器学习管道的创建——从特征转换、超参数调整到模型选择。有一些开源工具也可以做同样的事情(比如 TPOT ，一个我喜欢的很酷的模块，但是我永远无法在一个非常小的数据集上实际工作)。

现在，这些工具大多不是很好和/或非常昂贵(订阅数据机器人的费用，你可以雇用一名全职数据科学家)。但我毫不怀疑，很快就会有工具完全处理模型/超参数/特征转换过程。

有人问我是否担心自己作为数据科学家的工作安全。不，我没有。我迫不及待地想等到这些工具出现并开源，这样我就可以输入“import machinelearn ”,让它做愚蠢的超参数优化，然后我就可以继续做这项工作中最难的部分了。

当我获得的数据达到可以被这些工具之一接受的程度时，问题基本上就解决了。在这一点上，我需要运行一些代码来进行网格搜索，找到一个相当不错的模型，并调整超参数。见鬼，如果我现在用默认参数运行 XGBoost，它通常会和我曾经得到的一样好。做额外的调整工作是值得的，因为它相对容易，而且你很快就会达到收益递减点(除非你在一场 Kaggle 比赛中，即使收益递减也可能让你从第 10 名升至第 1 名，所以你可以充分利用精确度的每一个微小增量)。

一旦你有了你的数据格式，你就可以用它来进行一场 Kaggle 比赛，你已经完成了最困难的部分。如果在这一点上，我只是运行一个函数，进行比我的典型网格搜索更彻底的优化搜索，并且探索一些不同的特性转换，我会很高兴。也许我的模型会做得稍微好一点，我会节省自己写代码的几分钟。那会很好。但如果这会让你失业，也许你应该认真考虑一下你能拿出什么样的技能。

在我听说过的大多数数据科学职位中，一旦问题被框定，数据被收集，样本被选择，并且数据是整齐的一行一个样本的格式，困难的部分不是建立模型。最难的部分是到达那个点。虽然我不怀疑随着工具的发展，这些步骤中的一些在将来会变得更简单，但我看不出在不久的将来整个过程会容易地自动化。将业务问题转化为预测问题是困难的，需要大量的业务知识以及抽象的定量思维。弄清楚使用什么数据以及如何获取数据是很困难的——业务在发展，数据基础设施并不总是那么干净，所以这里没有现成的解决方案。选择一个无偏的样本集进行训练可能非常困难，对此没有一个千篇一律的解决方案。最常见的情况是，需要对来自问题细节知识的数据施加某种结构。

我毫不怀疑在接下来的几年里，我们会有一些很好的工具来自动构建机器学习管道。希望一旦这个问题变得微不足道，就不会有多少有抱负的数据科学家试图通过炫耀他们的模型在 Iris 数据集上有多精确来证明他们的技能。除此之外，我看不出对这个领域有什么影响。

使用 Python3.7 的自动机器学习:提高模型开发的效率

原文：https://towardsdatascience.com/automated-machine-learning-using-python3-7-improving-efficiency-in-model-development-8c3574febc0b?source=collection_archive---------10-----------------------

作者:萨利赫·阿勒哈利法和康纳·克兰西

介绍

随着过去几年数据科学的兴起，已经开发了各种 Python 工具和库来提高效率和扩展该领域科学家、分析师和程序员的能力。在 2018 中，一些最受欢迎的技能组合包括熊猫和 Scikit-learn 的高级使用。在 2019 中，一些最可雇佣的技能组合包括使用 PyTorch 和 Keras 。也就是说，2020 年的新年对我们有什么需求？在 2020 年，最受欢迎的技能之一将是自动化概念(T21)。

从数据科学的角度来看，大部分自动化通常是在机器学习模型的部署阶段观察到的。数据科学家准备数据、训练模型和部署解决方案，以循环的方式完成特定的任务。自动化的思想很少用在模型开发过程中。然而，考虑到我们已经看到的有利于自动化的转变，本文将展示如何在模型开发阶段使用自动化，使用 GridSearchCV 和 TPOT Python 库来识别准确的模型，以实现更快的模型部署。

图 1-机器学习模型开发过程。自动化通常出现在项目的部署阶段。然而，本文将展示自动化在过程的开发和验证阶段的使用。

标准算法选择

机器学习算法，如决策树、支持向量机或K-最近邻，都需要输入数据和各种参数或超参数的调整。超参数通常是由数据科学家选择的参数，如邻居的数量或树的最大深度。参数是由模型选择的内部值，例如权重。按照图 2 的原理图，采集数据，通过迭代每个算法并微调参数和超参数，开发多个模型。基于所需的标准对每个迭代进行评分，例如准确性和F1-分数，并选择得分最高的模型进行部署。

图 2——以传送带方式筛选算法的标准流程。

在开发和验证阶段，可能会使用 8-10 种不同的算法对每个数据集进行训练和评分，图 2 中列出了其中几种算法。在每种算法中，通常有 6-10 个超参数需要优化，其中许多参数的范围是无限的。假设每个模型都系统地尝试了超参数的每种可能的逻辑组合，则需要创建和测试大约 800 个模型。如果每个程序平均运行 2-3 分钟(取决于数据集的大小)，那么算法选择的参数优化将需要 2600 分钟，即每周 40 小时的标准工作时间。想象一下，如果在某种程度上，这个过程可以通过开源 Python 库实现自动化，将会取得多大的成就。

自动化机器学习

在 Pypi 中有许多允许自动算法选择和调整的库。一些著名的库包括 AutoML ， MLBox ，Auto-sk learn， GridSearchCV ，以及【TPOT——其中最后两个将是本文的重点。

我们将从 scikit-learn 自己的四个超参数优化器开始:

*[1] [model_selection.**GridSearchCV** 
[2] model_selection.**ParameterGrid**
[3] model_selection.**ParameterSampler**
[4] model_selection.**RandomizedSearchCV**](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.model_selection)*

选择超参数范围的方法是这些优化器之间的主要区别。第一个选项 GridSearchCV 利用了一种穷举方法，其中尝试了参数的每一种可能的组合。另一方面， RandomizedSearchCV 尝试相同的方法，然而，尝试的是全部可能组合的随机子集。让我们在下面的例子中仔细看看 GridSearchCV 。

数据创建和基线识别

我们将继续导入 make_blobs 库来生成一些数据供我们使用。我们将创建一个具有 4 个中心的 3D 数据集，并使用标准差 2 将它们更紧密地聚集在一起。这将确保数据没有很好地分离，并且需要开发更复杂的模型。

*import pandas as pd
from sklearn.datasets import make_blobsX, y = make_blobs(n_samples=600, # Total number of samples.
                      centers=4, # Number of centers.
                   n_features=3, # Number of columns of features.
                random_state=42, # The random seed state.
                cluster_std = 2, # The standard deviation.
                  )

df = pd.DataFrame(X)
df.columns = ["col_1", "col_2", "col_3"]
df["Label"] = y*

为了确认我们的数据的形状和整体外观，我们可以将它绘制成 3D 散点图，如下所示。

*from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(df["col_1"],   # X 
           df["col_2"],   # Y
           df["col_3"],   # Z
       c = df["Label"],   # Color By
         cmap='Accent',   # Colors
                   s=5,   # Size
          )

ax.set_xlabel('X Axis')
ax.set_ylabel('Y Axis')
ax.set_zlabel('Z Axis')

plt.show()*

图 3 —手边数据集的 3D 表示。

随着数据集的构建和准备就绪，我们可以继续选择一个模型。给定数据的形状、质心的位置和可分性，我们将尝试使用支持向量机( SVM )算法来训练分类器。

*## SVM Classifier:from sklearn.svm import SVC
svc_clf = SVC(gamma='auto',
              kernel = "poly",
              C = 0.1,
              degree = 4,
              tol = 0.01,
              random_state=42
              )svc_clf.fit(X_train, y_train)# SVM  Results: precision    recall  f1-score   support0       0.58      0.91      0.71        35
1       0.92      0.59      0.72        41
2       1.00      0.86      0.93        44
3       0.97      1.00      0.98        30 accuracy                           0.83       150
   macro avg       0.87      0.84      0.83       150
weighted avg       0.87      0.83      0.83       150print("SVM Accuracy: ", accuracy_score(y_test, svc_predictions, normalize=True, sample_weight=None)*100)SVM Accuracy: 82.6%*

我们的第一次尝试显示，使用上面显示的参数，一个 SVM 算法的准确率大约为 82%。现在可以迭代上面显示的各种参数来提高精度；然而， GridSearchCV 可以更有效、更系统地处理这些问题。

GridSearchCV

将尝试使用以下方法准备 GridSearchCV 。将设置可能的参数范围，并且模型将尝试选择产生最佳结果的参数集。

 *from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
svc_clf = SVC(gamma = 'auto')
parameters = {'kernel':('linear', 'rbf'), 'C':[1, 2, 5, 10], "degree" : [1,2,3,4,5], "tol" : [0.001, 0.01, 0.1, 1]}
clf = GridSearchCV(svc_clf, parameters, cv = 5)
clf.fit(X_train, y_train)
print ("Best Params: ", clf.best_params_)Best Params: {'C': 1, 'degree': 1, 'kernel': 'linear', 'tol': 0.001}*

随后使用推荐的参数重新运行 SVM 算法，我们可以达到 96%的准确率，比我们上面设定的基准高出 14%!

总结该过程，允许该库迭代所有可能的参数条件，并选择显示最有希望得分的条件集。这个过程太棒了。但是，这仍然需要为 7–9 个其他算法进行设置。这就是像 TPOT 这样的库可以用于进一步开发自动化的地方！

TPOT 图书馆

TPOT 库执行类似上面所示的搜索；在感兴趣的各种算法中的每一个上，迭代和调整后续参数。下面的图 4 描述了 TPOT 库运行的过程。该库导入数据集，并处理与特征预处理、特征选择和特征构造相关的所有项目。然后，TPOT 专注于算法选择、参数调整和模型验证，以优化模型。 TPOT 实现了 XGBoost 的使用，这是一个优化的分布式梯度增强库，旨在提高您的流程的效率和灵活性。

图 4——TPOT 图书馆运作流程示意图。

出于本教程的目的， TPOT 将通过下面这段代码确定算法和参数。

*from tpot import TPOTClassifier

pipeline_optimizer = TPOTClassifier(
    generations=5,         # Number of iterations
    population_size=30,    # number of individuals 
    cv=5,                  # Cross validationpipelines
    random_state=42,       # The seed of the pseudo random generator
    verbosity=3,           # Level of communication 
    scoring="f1_weighted"  # Scoring evaluation
)

pipeline_optimizer.fit(X_train, y_train)
pipeline_optimizer.score(X_test, y_test)

pipeline_optimizer.export('tpot_exported_pipeline.py')
print(pipeline_optimizer.fitted_pipeline_)*

完成此过程后，管道将导出一个名为tpot _ exported _ pipeline . py的文件，其中包含模型和结果。我们可以从打印在最后一行的拟合管道中看到，正确分类数据集数据点的最佳参数应该使用以下内容:

*Pipeline(memory=None,
         steps=[('gaussiannb', 
                   GaussianNB(priors = None,
                       var_smoothing = 1e-09))],verbose=False)*

使用高斯算法重新运行数据集后，我们达到了 98% 的准确率！大约比我们上一个型号高 2%。

结论

在机器学习模型开发过程的模型开发和验证阶段，可以使用 GridSearchCV 和 TPOT 库。 GridSearchCV 专门用于识别给定算法的最佳超参数；我们成功地将准确率提高了 14%,而没有明显的召回损失，总准确率达到 96%。 TPOT 用于自动算法和超参数选择，从而成功地将我们的准确率提高到 98%。在模型开发阶段实施这两种方法 将有助于提高模型的准确性，减少总的开发时间。

我们希望这篇文章既有益又有趣。一如既往，我们试图迎合我们的文章，以满足经验和非经验用户的需求。对于未来文章的建议，请随时通过文章顶部的 LinkedIn 个人资料联系我们。

使用 NLP 在 ITSM 进行服务请求分类

原文：https://towardsdatascience.com/automated-request-classification-in-it-services-management-2d1034fa83c1?source=collection_archive---------28-----------------------

初学者指南

使用机器学习对 ITSM 环境中的服务请求和事件进行分类

客户体验是下一个竞争战场。杰里·格雷瓜尔

你最不满意的顾客是你最大的学习来源。~ 比尔·盖茨

对于任何企业来说，客户的好感都是成功的关键驱动力。运行高效和有效的 IT 服务管理系统对赢得客户好感和获得竞争优势大有帮助。

让我们探索一下如何应用自然语言处理(NLP)来减少生产环境中服务请求或事件的平均修复时间(MTTR)。

让我们看一个假设的案例研究。

起飞成功 :

“ABC 时尚”推出了会员奖励计划，为客户提供了更新版的在线门户网站。在幕后，IT 基础设施有 3 个新的应用程序，为上游和下游系统之间的 15 个集成做出了贡献。一个 10 人的 IT 服务团队，内部分成 3 个子团队，每个子团队处理一个特定的集成领域，在新程序上线并中断一些事情之前，一直在提供最高质量的服务:

“休斯顿——我们有麻烦了”！！

>服务请求量增加了 5 倍，部分原因是客户对新系统缺乏了解，部分原因是系统集成中的已知问题。团队无法遵守如此高容量的服务水平协议(SLA)。

>来自客户的请求涵盖了以自由文本格式描述的广泛问题，这些问题在分析阶段很难手动分类。通常，客户没有在“联系我们”web 表单中选择正确的类别和子类别，这导致了不正确的分类和 IT 服务团队分配。这种请求的重新安排有助于 MTTR。

>由于系统中集成点增多，生产事故数量增加。然而，一些事故可以通过简单的步骤解决。

直到团队成员分析了问题，请求才获得适当的优先级。例如，无论在请求创建期间设置了什么样的默认优先级，门户登录失败或应用程序停机都应该以最高优先级来处理。

我们有解决办法吗？

谢天谢地，是的。进一步的头脑风暴表明，如果服务请求和事件在到达 IT 支持团队 之前得到适当的分类和标记，这些问题可以得到缓解 。

一个请求分类系统将解决这个问题，如果它是:

  1. 自动化:零人工干预完成。
  2. 基于内容:基于对请求中包含的实际内容的审查，而不是基于创建时错误选择的类别的人工猜测。
  3. 实时:在创建请求或事件时实时完成，而不是等到团队成员手动分类。

机器学习拯救世界

自然语言处理(NLP)是人工智能的一个子领域，涉及计算机和人类(自然)语言之间的交互。它用于将机器学习算法应用于文本和语音。

例如，我们可以使用 NLP 来创建语音识别、文档摘要、机器翻译、垃圾邮件检测、命名实体识别、问题回答、自动完成、预测打字等系统。

对于讨论中的问题，NLP 可以用于使分类“基于内容”,其中通过分析请求的内容，使用训练的模型来预测类别。

基于 NLP 的系统具有以下先决条件:

  1. 文本数据在输入系统之前应进行预处理。它应该丢弃“不需要的”和“噪声”数据。
  2. 文本数据应该标准化并“编码”成模型算法可以理解的格式；原始文本数据不能输入模型。通常，文本中的单词或字母被编码成数字，这些数字以某种方式向模型表示其含义。对于感兴趣的读者，这里有一个很好的文本编码解释:https://towardsdatascience . com/Text-Encoding-a-review-7c 929514 cccf
  3. 精确标注数据集的可用性是构建有效预测的良好模型的关键。这对于“监督学习”来说是正确的，在这种情况下，模型将从标记的数据集学习特征和模式，以便它可以预测未知或新输入数据的结果。例如，模型可以"学习"像点数、兑换、奖励、挣得等这样词语。出现在请求描述中可能意味着该请求应该属于“奖励积分”类别。如果可以提取历史服务请求或事件并正确标记以训练模型，则获得更准确的分类器的机会就越大。
  4. 应该清楚地定义目标类别，以便分类能够很好地工作。类别的数量不应该太低(重置本练习的整个原因)或太高(分类器将不能有效地理解正确的类别)。类别应该清晰且不重叠，以避免模型混淆。

考虑到这些，下面是构建服务请求分类器的基本 NLP 方法:

基于 NLP 的应用程序开发的典型流程

基本解决方案的 100 英尺视角

NLP 是一个海洋，有成千上万的文本处理方法和算法可供我们使用，随着我们试图更接近人类理解文本的专业知识，它每天都在不断改进。

然而，当手头的问题值得这样做时，简单往往会有回报。

让我们按照上面提到的开发模型，探索一个非常简单的方法来解决 ABC 时装店的分类问题。

目标类别:

以下是一些假设但真实的类别，可由 ABC 时尚店使用。它们互不重叠，涵盖了一般报告的大多数问题类型。

CRM 服务管理系统的目标类别示例

分类器模型性能度量最终确定:

模型的性能意味着该模型根据其学习的特征预测结果的好坏。对于目前的问题，将根据模型预测服务请求类别(从下面提到的 6 个类别中)的正确程度来衡量性能。

有许多方法可以衡量模型性能，其中 F1 分数简单易用。F1 分数基于两个指标—精确度和召回率，这两个指标决定了预测值的正确比例和预测的已知值的正确比例。

例如:如果模型将 10 个服务请求分类为“应用程序问题”，其中 8 个是实际的应用程序问题，而标记数据集中已知应用程序问题的总数为 12，则精度= 8/10 (0.8)，召回= 10/12 (0.83)。F1 得分= 2 P*R / (P+R) = 0.814

更多信息，请查看:【https://en.wikipedia.org/wiki/F1_score】T4

所以对于这个问题， F1 分数作为一个性能指标。

探索性数据分析:

假设服务请求的已标记数据集可用(可能是对过去 2 年的历史数据进行的人工标记),该数据集具有所有相关文本属性以及目标标签，探索性数据分析可以提供对数据的重要洞察，如:

按标记目标分组的记录计数—该数据集中排名前 5 的类别是什么？它是否严重偏向任何一种类型？

文本属性对于分析有多好？有太长/太短的单词吗？有没有需要删除的 PII 数据？他们的同一文本的多个版本—“登录”、“登录”、“登录”、“登录”具有相同的含义，并且可以转换为“登录”。

Pandas 是一个用于探索性数据分析的优秀软件包。将 json 或 csv 格式的源数据导入 Pandas 数据框后，可以应用各种函数来了解数据的特征，并基于正则表达式提取相关数据。

对于当前的问题，来自服务请求的字段子集，如“请求简短描述”、“详细描述”、“附加说明”、“工作日志”等，并将它们连接起来以获得源数据。源中的整个文本可能没有用，我们将不需要的普通行删除，以使文本更清晰。

文本数据编码和特征选择:

文本分类器模型应该基于从来自相同数据域的相似标记数据集中学习到的“特征”来预测任何输入文本数据的类别。如果我们有一些历史服务请求数据，这些数据在问题分析过程中被归类到上述类别之一，那么这些“知识”需要是原始文本，因此需要被转换成模型能够理解的特征值。从更高的层面来说，一个文本句子根据一些规则和预先确定的“词汇”被转换成一个数字向量——实数或整数。

这里不需要复杂的预训练编码器，因为重点是关键字的存在，而不是文本中单词的特定上下文和顺序。

Scikitlearn 是最易于使用的软件包之一，可用于文本编码和模型开发。它有各种各样的文本分析库以及实用程序和优化算法，可以帮助我们开始学习 NLP。

典型的文本标准化和编码过程

培训、测试和评估模型:

模型开发和测试遵循以下方法。模型开发是一个迭代的过程，在此过程中，根据模型指标(F1 分数)对模型进行评估，如果结果不令人满意，可以调整模型参数并重新开始训练过程。对于分类问题，“混淆矩阵”特别有助于检查模型表现不佳的特定情况，这意味着它预测输入数据的不同标签。这种情况需要重新考虑，特别是在数据 a 的可用性方面

如果随后的训练和测试没有提高 F1 分数很多，那么数据集大小或文本编码中的特征数量可能会被重新考虑。如果仍然没有什么需要改进的地方，可以认为模型已经优化了。

典型的模型开发和测试周期

部署模型:

一旦模型被构建和测试，最重要的部分就是部署。虽然现在大多数现代 ITSM 工具都具有可以定制的开箱即用的人工智能功能，但拥有一个内部构建的分类器模型总是有助于获得更多的控制和多功能性。

以下是部署分类器模型的几种方法:

部署分类器模型的各种选项

但是，将该模型部署到生产环境的最佳方式是将其预测功能作为 API 公开，该 API 支持与 ITSM 工具的实时集成，从而在创建服务请求时对其进行即时分类。

ITSM 工具和部署模型之间的典型 API 集成

基于容器的解决方案将所有的模型数据、元数据、库和实用函数封装在一个容器“映像”中，并将模型打包成一个可移植的应用程序。这些映像可以部署到 AWS 或 Azure cloud container 注册表中，从而在基础架构、可伸缩性、安全性和可用性方面更加易于管理。

最后，这是一个基于可用技术堆栈、预算和能力的最符合组织利益的架构决策。

分类器的示例配置

对于那些了解 NLP 概念、工具包和行话的人来说，下面是一个非常基本的和部分调优的样本模型开发方法:

输入数据集:来自 ITSM 工具的服务请求数据转储 csv 文件，已完成标记。

变量:

自变量 X =来自感兴趣领域的扩充、处理和标准化文本，如简短描述、说明、结束语、附加注释。

因变量 Y =个目标标签之一

>特征生成—编码:

scikitlearn 的 Encoder = CountVectorizer。

词汇表最多选择 3000 个单词(max_features ),并且只选择出现在 5 个以上示例中的单词。选择单个单词进行模式匹配(ngram_range=(1，1))

from sklearn.feature_extraction.text import CountVectorizer**# initialize a count vectorizer** 
cv = CountVectorizer(min_df = 5,max_df=1.0, max_features=3000, ngram_range=(1, 1))**# provide the entire input text to fit the Vectorizer**
cv.fit(x)

但是为了简单起见，对于这个特定的分类问题，不考虑这种复杂的编码。此外，像这样的分类问题，可能只需要检查单词的出现，而不是它们的相对顺序和位置/上下文；拥有一个计数矢量器是一个好的简单的开始，而不是使用 GRU/LSTM/伯特等复杂的单词嵌入。

独立(输入 X)数据由计数矢量器编码成特征矢量。

对于类别数= 6，相关(目标 Y)数据被编码成一个独热向量。

假设我们的数据集中有 6000 个示例，并且我们将它分成 80–20 个开发交叉验证集，编码看起来会像这样:

**# split train test sets of raw text data**
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.20, random_state=0)print('x_train = {} y_train = {} x_test = {} y_test = {}'.format(x_train.shape,y_train.shape,x_test.shape,y_test.shape))x_train = (4800,) y_train = (4800,) 
x_test = (1200,) y_test = (1200,)**# Encode the train and test data into feature vectors** 
X_train_vec = cv.transform(x_train)
X_test_vec = cv.transform(x_test)**# Convert the target categories into one-hot vectors of dimension 6 (number of target labels)** y_train_oh = convert_to_one_hot(y_train,C=6)
y_test_oh = convert_to_one_hot(y_test,C=6)**# print shapes of train and test sets**
print('X_train_vec = {} X_test_vec = {}'.format(X_train_vec.shape,X_test_vec.shape))
print('y_train_oh = {} y_test_oh = {}'.format(y_train_oh.shape,y_test_oh.shape))X_train_vec = (4800, 3000) X_test_vec = (1200, 3000)
y_train_oh = (4800, 6) y_test_oh = (1200, 6)

可以观察到输入变量 x_train，x_test 如何从字符串的一维向量转换成编码的稀疏矩阵 X_train_vec，X_test_vec，以及输出目标类别如何被编码成向量 from，y_train，y_test 到独热表示 y_train_oh，y_test_oh。

分类数据的一键编码请参见https://machine learning mastery . com/why-one-hot-encode-data-in-machine-learning/

>模型类型:浅层人工神经网络

>模型架构和超参数(部分调优):

输入编码层→

隐藏层 1 (128 个单位)→放弃正则化 1 (p=0.6) →

隐藏层 2 (128 个单位)→放弃正则化 2 (p=0.6) →

SoftMax 分类器(6 个单元—每个类别一个)。

正规化=辍学(0.6)

权重初始化= glorot_uniform (Xavier)

优化器=随机梯度下降(SGD)

损失函数=分类 _ 交叉熵

迭代次数(历元)= 40

***# Build Sequential Model by adding layers (Keras on Tensorflow)**model = Sequential()
model.add(Dense(128, activation='relu', input_dim=X_train_vec.shape[1],kernel_initializer=glorot_uniform(seed=None)))
model.add(Dropout(0.6))
model.add(Dense(128, activation='relu', input_dim=X_train_vec.shape[1],kernel_initializer=glorot_uniform(seed=None)))
model.add(Dropout(0.6))
model.add(Dense(6, activation='softmax'))**# initialize the optimizer algorithm**
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)**# Complile the model with a loss function and the above optimizer**
model.compile(loss='categorical_crossentropy', optimizer= sgd, metrics=['accuracy'])*

>模型实现:

使用带有 Tensorflow 后端的 Keras 在 Python 中建立模型。

>模型训练曲线:

我们看到了如何根据模型的迭代次数来绘制损失和准确性值。训练集的准确率达到 96%以上，但这并不意味着模型是准确的。必须用看不见的数据进行交叉验证和测试，看是否有过度拟合。

显示损失和准确度随迭代次数变化的训练曲线

>测试分类:

对测试数据集运行预测可能会导致假阳性和假阴性。分类报告和混淆矩阵示例如下:

分类报告和混淆矩阵有助于找出具体的问题领域

类别 4 的 F1 分数非常低。类别 0 和 1(混淆矩阵的第 2 行和第 1 列)之间有很多重叠，这意味着如果服务请求的实际类别(基本事实)是 1，那么它会被模型错误地标记为 0。

>保存编码器、模型和元数据用于未来预测:

对于将来的预测，可以保存模型和编码器，以便将来访问预测器过程。

***# Save the encoder into a pickle file**
# cv is the scikitlearn CountVectorizer instance that has been fit to the entire vocabulary 
with open("C:\\Users\\jch\\Downloads\\POC\\cv.pickle", "wb") as f:
    pickle.dump(cv,f)

**# serialize model to JSON**
model_json = model.to_json()
with open("C:\\Users\\jch\\Downloads\\POC\\model.json", "w") as json_file:
    json_file.write(model_json)
**# serialize weights to HDF5**
model.save_weights("C:\\Users\\jch\\Downloads\\POC\\model_wgts.h5")
print("Saved model to disk")*

当模型预测 API 被初始化时，这些可以被加载回存储器:

***# Load the encoder from the pickle file**
with open("C:\\Users\\jch\\Downloads\\POC\\cv.pickle", "rb") as f:
    cv = pickle.load(f)**# Load the model**
with open("C:\\Users\\jch\\Downloads\\POC\\model.json", "r") as json_file:
    loaded_model_json = json_file.read()
    model = model_from_json(loaded_model_json)**# load weights into new model**
model.load_weights("C:\\Users\\jch\\Downloads\\POC\\model_wgts.h5")*

他们从此幸福地生活在一起…

ABC Fashion 通过为其 ITSM 工具实施分类器，最终获得了高客户满意度的奖励。新的分类器在以下方面有所帮助:

收益:

> MTTR 减少了大量。

>以前需要相同解决步骤的服务请求，现在有 50%在创建后就自动解决了。这是可能的，因为问题被相应地标记，并被转发给自动化机器人用于解决步骤。

> ITSM 报告和仪表板可以按类别实时报告问题，从而深入了解服务请求类型的频率和趋势。

>关键系统警报被标记为严重级别为 1 的问题，并标记为立即响应。

>团队的工作量已经正常化，这给了他们进一步改进的机会。

结束这一切…

我们在这里看到的分类器模型，像任何开发和部署的软件一样，需要监控和维护。新的输入模式、预测的偏斜度、F1 分数的下降、新类别的引入、针对性能和可伸缩性对已部署应用的增强、针对更好的预测对模型进行调优——所有这些都属于一个生命周期。

现代 ITSM 工具有现成的基于人工智能的文本处理插件，这些插件完全由工具提供商管理。这种工具使开发变得简单、省事，有时被称为“零代码”。然而，与管理解决方案相比，构建内部模型提供了更好的控制和更大的即兴创作空间。

使用 AWS Lambda(带层)、AWS S3 和当前超级碗赔率的自动刮擦

原文：https://towardsdatascience.com/automated-scraping-using-aws-lambda-with-layers-aws-s3-and-current-superbowl-odds-dc7f9c6d27b1?source=collection_archive---------26-----------------------

关于如何在 AWS 上设置一个自动刮刀的指南，没有漂亮的 Soup 或 Selenium…一路上还带着相当多的戏谑！

*注意:这篇文章假设读者已经了解基本的 AWS Lambda 和 S3 功能。简单介绍一下 AWS 快速入门指南: Lambda 和 S3

开炮！(由 NFL 通过 Giphy 拍摄)

好吧…首先，让我们来解决房间里的大象。

是的，我是坦帕湾海盗队的球迷。不，我不是因为他们签了汤姆·布拉迪才开始喜欢他们的。我从 10 岁起就是一个粉丝，在坦帕以南大约一小时车程的地方长大，他们认为他们的新制服/标志比 creamsicle 的制服和 Bucco Bruce 的标志酷得多。为了完全透明，在今年 3 月 20 日之前，我不是 TB12 的粉丝。也就是说，我不记得有哪一次我对 NFL 橄榄球赛在秋季回归如此兴奋。去年，海盗队在传球码数方面领先联盟。布雷迪和埃文斯、戈德温、格隆考斯基和霍华德是一伙的吗？？？开炮！希望到九月来临的时候，世界会变得更好(通俗地说)，雷蒙德·詹姆斯体育场会被点亮！！！

NFC South 就要被干掉了！(照片由 NBC 体育通过 Giphy 拍摄)

海盗队签下布雷迪后不久，我看了看超级碗赔率，发现海盗队的赔率是+2600。如果你不熟悉美国博彩赔率，这意味着 100 美元的赌注，赌徒赢得了 2700 美元的总支出。就背景而言，堪萨斯城酋长队是目前赢得 2021 年超级碗的最大热门，目前的赔率在+550 到+650 之间，这取决于你检查的体育博彩赔率。在+2600 的情况下，我下了一个小赌注，如果成功的话，会有一笔可观的支出。

" Andrew，这篇文章不应该是关于实现自动化的 AWS Lambda 吗？"

最近，我一直在试图为一篇新的博客文章想一个新的主意，将我学到的一种流行的 AWS 服务结合起来。在听说海盗队也签下了罗布·格隆考斯基后不久，我开始思考我的赌注，赔率将如何变化，以及我如何分析未来 9-10 个月的走势。排队文章灵感！

在本帖中，我们将:

  • 创建一个 Lambda 函数，该函数将剔除当前超级碗赔率
  • 创建 Lambda 层以便于访问
  • 使用 CloudWatch 自动执行每天的抓取功能

赢得比赛的超级猫头鹰(照片由 PBS 通过 Giphy 拍摄)

自动气象站λ

我第一次接触 AWS Lambda 是在去年，当时一位同事听到我谈论我如何学习使用 AWS EC2 部署应用程序。他们解释了我为什么不需要一台 24/7 全天候运行的服务器来运行我选择的脚本或 scraper。相反，他们让我去调查 AWS Lambda。

“AWS Lambda 允许您在不提供或管理服务器的情况下运行代码。您只需为消耗的计算时间付费。有了 Lambda，你可以为几乎任何类型的应用程序或后端服务运行代码——所有这些都无需管理。只需上传你的代码，Lambda 就会为你的代码提供高可用性的运行和扩展。您可以将代码设置为从其他 AWS 服务自动触发，或者直接从任何 web 或移动应用程序调用它。”— AWS 链接

厉害！但是，作为一名数据科学家，我经常使用像 pandas 或 scikit-learn 这样的库。这两个库都没有预装在 Lambda 环境中。这意味着如果您想要包含除 AWS SDK 之外的库和依赖项，您需要创建一个部署包。此外，作为一名程序员，我学到的第一个概念是避免重复相同的代码。我希望尽可能地高效，不希望每次只需要几行代码就能实现目标时，就创建一个大的部署包。这就是λ层非常有益的地方。

  • 在继续阅读之前，请转到 AWS 控制台，创建一个基本的 Lambda 函数和一个具有基本 Lambda 权限的新执行角色。我们将使用这个λ向前移动；稍后我会详细讨论执行角色权限。

λ层

兰姆达斯像洋葱，这意味着他们也像食人魔(和冻糕！).

"不是每个人都喜欢洋葱。"(左图来自男高音 |右图来自纱线)

“您可以配置 Lambda 函数，以层的形式引入额外的代码和内容。层是包含库、自定义运行时或其他依赖项的 ZIP 存档。通过层，您可以在函数中使用库，而无需将它们包含在部署包中。”
--AWS 链接-

我真的希望在我花几天时间开发几个 Lambdas 之前就知道层的功能，因为调试过程会容易一百万倍。在构建 Chrome 扩展(仍在构建中)的过程中，我为应用程序中运行的三个主要 Lambdas 创建了一个大型部署包。浪费了相当多的时间，因为我不得不等待开发包的构建和上传，只是为了测试代码中的简单编辑。本质上，使用层类似于在虚拟环境中安装库。在某些时候，你必须在你的虚拟环境中安装这个库来使用它的代码，这基本上就是你在 AWS 上要做的事情。

本教程的主要目的是向你展示如何自动化你的 Lambda 函数。大声喊出来 Quy Tang 他的教程是关于如何为 Python 的熊猫库创建一个新的 AWS Lambda 层。它非常简单，可以快速启动并运行，并且我能够修改 Python 3.7 的代码。在浏览该指南时，我注意到的唯一区别是运行这段代码时得到的文件夹结构:

./get_layer_packages.sh
zip -r my-Python36-Pandas23.zip .

【左】前面提到的教程的结果(图片由曲唐拍摄)。[右]运行代码时的结果(作者截图)。

这两种文件夹结构都适用于上传到 AWS Lambda 层。如果您运行的是 Python 3.7，那么您将需要适当的 Docker 映像。在您的.sh脚本中，将.6改为.7:

lambci/lambda:build-python3.7

对于这个应用程序，我想避免使用 BeautifulSoup 和 Selenium，因为我想让它尽可能地轻便，并且我想使用 pandas 为我们提供的有用功能，pd.read_html(<URL_HERE>)。要记住的重要一点是，为了让.read_html()正常工作，你试图从中检索信息的网站必须有一个 HTML 格式的表格。当我想获取的唯一数据是 HTML 表中的数据时，我喜欢使用这个函数。对于我的个人项目，我还需要为requests库做一个单独的 Lambda 层。我需要这样做，因为我想访问的一个站点返回 403 响应，并需要特定的头来发出 GET 请求。(同样，因为库不包含在 AWS SDK 中)。

作者截图

*注:在我的调试过程中，我了解到 lxml 库需要调用上面的 pd.read_html() 函数才能得到响应。我在请求层中安装了 lmxl 只是为了方便自己。我本来可以专门为 lxml 再做一层的。

在谷歌上快速搜索“当前超级碗赔率”会有很多潜在的选项。在这篇文章中，我将只演示抓取一个网站，我之所以选择它是因为它过于简单，格式陈旧。理论上，你可以随意抓取任意多的网站。在我的私人版本中，我从 3 个其他来源获取数据，这些数据似乎是实时更新的。这三个来源不是体彩本身，但为市场上一些最可信的体彩提供了现场赔率。实时更新对我来说很重要，因为我的下一篇博文将是关于获取由特定事件触发的文本通知。我能想到的描述这一点的最好例子来自硅谷的T4，在那里吉尔福伊尔正在接收他的比特币价格变动通知。

编码的时间到了:

此时，你应该已经创建了一个 Lambda 和一两个不同的层。让我们深入一小段代码和自动化过程。下面是我们将在 Lambda 中实现的第一部分代码:

import json
import requests
import pandas as pd
from fractions import Fraction
from functools import reduce
from datetime import datetime, timedelta# set the URL
url = '[https://www.vegasinsider.com/nfl/odds/futures/'](https://www.vegasinsider.com/nfl/odds/futures/')# define the dataframe; located in the 6th index position
df = pd.read_html(url)[6]# limit the dataframe to the 32 teams/rows we want
df = df.iloc[:32, :-1]# label the columns
df.columns = ['team', 'odds']# convert the fraction to American odds
df.odds = df.odds.apply(lambda x: 100*float(Fraction(x)))# format the row into string w/ "+"
df.odds = df.odds.apply(lambda x: '+' + str('%g'%(x)))

好了，我们的数据已经格式化了，现在我们需要保存它:

这就是 AWS S3(简单存储服务)发挥作用的地方。前往 AWS 控制台的 S3 部分，创建一个基本的 S3 桶。一旦您完成了创建 bucket，请返回 Lambda 控制台。为了让你的 Lambda 能够访问 S3 桶，我们必须给 Lambda 这样做的权限。您可以在第一次实例化 Lambda 时授予它权限，也可以在创建后编辑权限。我们将选择后者。以下是步骤:

首先，点击 Lambda 中的“Permissions”选项卡。接下来，单击您的“执行角色:角色名称”下面的 URL 链接，这将打开一个带有身份和访问管理(IAM)控制台的新选项卡。接下来，单击标有“附加策略”的蓝色大按钮。最后，在过滤搜索中搜索“S3 ”,并选择“AmazonS3FullAccess”并附加策略。

既然我们的 Lambda 拥有 S3 权限，那么是时候进行更多编码了:

# instantiate S3 object
s3 = boto3.client('s3')# set datetime str w/ EST timezone adjustment and Daylight Savings
if datetime.now().month in range(4,11):
    day_and_time = (timedelta(hours=-4) + datetime.now())
else:
    day_and_time = (timedelta(hours=-5) + datetime.now())
day_and_time = day_and_time.strftime("%b-%d-%Y-%H%M%S")# the two different file paths used for uploading
scraped_file_path = '/tmp/SB_odds_' + str(day_and_time) + '.csv'
path_name_for_bucket = scraped_file_path[5:]# create csv file
output = final.to_csv(scraped_file_path, index=True)# upload the new csv file to S3
s3.upload_file(f'{scraped_file_path}', '<YOUR_S3_BUCKET_NAME_STR>', f'{path_name_for_bucket}')# define a simple lambda handler
def lambda_handler(event, context):
    return {
    'body': json.dumps('SUCCESS: The SB odds have been scraped!'),
    'date and time':day_and_time
}

在定义lambda_handler()函数时，不需要返回字典内容(或者根本不需要任何东西)。我写这段代码是因为当你运行一个测试时，看到输出是一种视觉享受。我稍后会解释更多关于时区和夏令时的调整，但是需要注意的是文件路径格式不包含任何空格。在继续之前，请确保测试您的函数并检查您的相关 S3 桶以获得结果文件。

大获成功！

祝贺安迪·雷德、马霍斯、蜜獾和所有 2020 KC 酋长队获得冠军！( NFL 通过 Giphy 拍摄的左和右照片)

如果你还在继续，你应该有一个 Lambda (w/ Layers)可以将一个.csv文件推送到你的 S3 桶中。然而，现在唯一能触发 Lambda 执行的事情是在控制台中按下“test”按钮。

自动化来了！

这个过程的下一步是设置一个自动触发器，在你想要的时间执行你的 lambda 函数。为了实现这一点，我们将使用 CloudWatch AWS 服务，更具体地说是一个 cron 作业。

“cloud watch 为您提供数据和可操作的见解，以监控您的应用、响应系统范围的性能变化、优化资源利用率，并获得运营状况的统一视图。”

CloudWatch 有很多功能，但是我们将只使用它来执行我们的 cron 任务。一般来说，Cron 用于运行预定的进程(例如:定期删除不再需要的日志文件)。你可以在这本初学者指南中读到更多关于 cron jobs 的内容。重要的一点是，我们将为一个函数设定一个时间，让它按照指定的时间表执行。AWS 控制台的 cron 表达式时间格式为:

<Minute> <Hour> <Day_of_month> <Month> <Day_of_week> <Year>

这些字段中的每一个都应该填入一个数值，数字之间只有一个空格。此外，我们将利用两个方便的 cron 通配符，*和?。*通配符代表字段中的所有值(例如:在小时字段中，*****将包括每个小时)，而?通配符代表我们的星期值，因为我们不关心它是星期几。这里有一个链接，包含了 AWS 上 cron 表达式可用的所有不同通配符。对于这个博客，我们将设置 cron 作业每天在美国东部时间 08:00 执行。请完成所有这些步骤，我将在以下段落中解释这是怎么回事:

  • 前往云手表控制台。
  • 在左侧，单击“规则”选项卡，然后单击蓝色的“创建规则”按钮。
  • 在“步骤 1”页面的左侧，选择“计划”选项，然后选择“cron 表达式”选项。
  • 输入00 12 * 04–10 ? 2020作为您的 cron 表达式。
  • 在“步骤 1”页面的右侧，单击“添加目标”按钮。
  • 在下拉菜单中，分别选择“Lambda function”和您的特定功能。
  • 最后，单击“配置详细信息”按钮，并填写下一页上的名称和描述框。

您可能已经注意到时间表中有一个“固定费率”选项。我不确定每天执行的确切时间，我想精确一些，所以我选择了“cron expression”。因为这篇文章是关于获得超级碗赔率的，所以我想设置刮刀每天运行直到下一次超级碗。我还没有想出用一个表达式来做这件事的方法，所以我们将重复这个过程四次来创建单独的规则。夏令时于 11 月 1 日结束，因此我们需要用两个表达来表示 2020 年。我们还需要一份 2021 年 1 月的，一份 2021 年 2 月 1 日至 2 月 7 日的。三个 cron 表达式将使用—(破折号)操作符来指定月或日值的范围:

00 12 * 04-10 ? 202000 13 * 11-12 ? 202000 13 * 1 ? 202100 13 1-7 2 ? 2021

到目前为止，您可能已经注意到 AWS CloudWatch 的执行时间是 GMT。除非你住在那个时区的某个地方，否则你会想根据你的时区来调整你的计划时间。这就是为什么我们在为.csv文件路径设置日期时间字符串时进行了时间增量调整。在创建了四个规则中的每一个之后，您应该已经准备好了。

结束语

你有它；一个自动铲运机，将填充你的 S3 桶每天与当前超级碗赔率！如果您想测试您的 cron 表达式并立即看到结果，只需将表达式的时间值编辑为从现在起 5 分钟(GMT)并稍事休息。5 分钟后，你的 S3 里会有一个新的.csv。

感谢阅读！如果你喜欢这篇文章，请发送一些中等掌声，并关注我的页面，以便将来发布。希望，你现在可以创建自己的自动铲球，不会像中场休息时的左鲨鱼一样。

lolz(左图来自男高音 |右图来自 Giphy )

本文的项目托管在 Github 上。

自动股票交易与 R

原文：https://towardsdatascience.com/automated-stock-trading-with-r-part-1-5a1020831096?source=collection_archive---------25-----------------------

杰森·布里斯科在 Unsplash 上的照片

本文解释了如何使用 r 创建一个交易管道

  • 连接 Google API 并加载当前持有数据
  • 连接 Robinhood API 并获取当前股票价格
  • 使用 Yahoo API 获取历史市场数据
  • 决策算法和执行订单

图 1:交易渠道

我使用以下 API

  • 谷歌云平台
  • 罗宾汉
  • 雅虎财经

1.设置

为了创建管道，我使用了 R Markdown 文档。我使用这些库来处理金融数据。

library(dplyr)
library(purrr)
library(dbplyr)

罗宾汉图书馆与罗宾汉账号互动。Quantmod 库允许与雅虎金融数据交互，并包括用于技术分析的有用库。

library(RobinHood)
library(quantmod)

我使用 googlesheets4、big query 和 DBI 与基于谷歌云服务的数据库进行交互。

library(googlesheets4)
library(bigrquery)
library(DBI)

这里的库是用来访问带有定义函数的本地 R 脚本的。

library(here)
source(here("src", "R", "data_functions.R"))
source(here("src", "R", "trading_models.R"))

2.连接 API

我为我的项目设置了账单，并使用。json 文件。

gs4_auth(
path = "google_auth.json",
cache = FALSE
)

在里面。Rprofile 我为 sys 环境设置了以下变量。

# Put that inside .Rprofile system file
Sys.setenv("username" = "adam")
Sys.setenv("password" = "test")

然后与 RobinHood API 建立连接。。Rprofile 文件传递上面定义的相关凭据。

robinhood_connection = RobinHood(
username = Sys.getenv("username"),
password = Sys.getenv("password")
)

3.收集数据并做出决策

然后，我使用雅虎财经 API 收集所有相关数据。

# This function is located in data_functions.R script
get_market_data <- function() {
 # Load data into the workspace
 getSymbols("AAPL", src="yahoo")
 return(AAPL)
}data <- get_market_data()

对于本文来说，这个函数收集 APPL 股票的历史数据。这将有助于交易算法做出决定。

然后，我将数据和输入参数传递给一个算法，该算法决定是买入还是卖出给定的股票。我将在另一篇文章中解释算法，它检查当前持有量并决定卖出、买入或持有给定的股票。这就是算法的输出。

stock_decision <- moving_average_model(
 data = data,
 trend_deviation = -4
)

4.执行订单

然后，我从 RobinHood API 请求最新的 APPL 股票价格。

market_price <- get_quote(
robinhood_connection,
ticker = c("AAPL"),
limit_output = TRUE
)$last_trade_price

然后，程序根据函数的输出执行购买。下订单应该会生成一封电子邮件。

if(purchase_stock$decision_buy) {
x = place_order(
RH = robinhood_connection,
symbol = "AAPL",
type = "market",
time_in_force = "gfd",
trigger = "immediate",
price = market_price,
quantity = n,
side = "buy"
 )
} else if (purchase_stock$decision_sell) {
x = place_order(
RH = robinhood_connection,
symbol = "AAPL",
type = "market",
time_in_force = "gfd",
trigger = "immediate",
price = market_price,
quantity = n,
side = "sell"
 )
}

最后，管道将输出写入 Google sheets，并在股票被买卖时更新持股表。

write_output_sheets(
data = stock_decision,
sheet = "records")if (purchase_stock$decision_buy | purchase_stock$decision_sell) {
update_current_holdings(purchase_stock)
}

总结

用 r 执行库存订单是可能的，而且相对容易。下一步是编排工作流。我尝试过用气流和云合成器来做这件事。Cloud Composer 比 airflow 更容易设置。也挺贵的。局部设置气流可能是一个更好的选择，但是，它需要更多的工程知识。

在下一篇文章中，我将讨论一个简单的移动平均线交易算法。

注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

参考

[1] RobinHood cran 包文档，https://cran . r-project . org/web/packages/robin hood/robin hood . pdf

[2] Quantmode cran 包文档https://cran . r-project . org/web/packages/quant mod/quant mod . pdf

[3]为 Google sheets 设置 Google APIhttps://googlesheets4.tidyverse.org

[4]云作曲https://cloud.google.com/composer

使用 Python 和 Cron 实现自动 Web 抓取

原文：https://towardsdatascience.com/automated-web-scraping-python-cron-e6bedf4c39eb?source=collection_archive---------21-----------------------

在 Unsplash 上 Sai Kiran Anagani 拍摄的照片

在廖内省建立一个每天更新的新冠肺炎数据集。

有时，我们想每天做一些事情。如果你一个人做似乎很无聊，你只是为了做而浪费时间。自动化是我们所需要的。通过在给定的时间安排它，我们可以节省时间，让计算机自己完成任务。

在本文中，我想向您展示如何使用 Python 为印度尼西亚廖内省构建新冠肺炎数据集来检索数据集，并使用 Cron 来调度任务。如果你想了解更多，你可以在我的 GitHub 库这里查看一下。

问题陈述

廖内是印度尼西亚的一个省。就像其他地方一样，这个地方也与新冠肺炎作战。他们的信息来源是 corona.riau.go.id。首页是这样的，

在网站上，它显示了省和地区一级存在的病例数量。虽然它是最新的，他们没有显示它的历史数据。就像下面这些图片一样，

左:省级案件量，右:地区级案件量

因为这个问题，我提出了一个 web 抓取技术来记录数据并保存为。csv 格式。在这之后，我将一步一步地向你展示我如何抓取网站，以及如何在给定的时间表自动完成这些任务。

该过程

用美汤刮网

我做的第一件事就是浏览网站。为了抓取它，我使用 bs4 库从其中提取文本。对于这种情况，存在一些问题。首先，我之前展示的表格来自另一个网站，它只是网站上的一个框架。因此，我们必须找到它的来源。

在 Microsoft Edge browser 上，我们可以通过右键单击每个表格来获取其框架的来源，然后选择“查看框架来源”。省级数据来源于https://covid19.riau.go.id/webster。对于城市或摄政级别，来源来自https://covid19.riau.go.id/pantauan_data_kasus。下一步是浏览每个网站，获取我们需要的数据。

首先，我们将从https://covid19.riau.go.id/webster提取数据。检索数据并不困难，因为我们只需检查哪个标签属于这个数字。我们想要提取的数据只是每一列的数字，所以我们可以使用一个列表作为列名。

基于上图，标签包含了数字。标签被标签封装。因此，我们必须提取所有的

标签，然后，我们提取每个标签的

| 标签内容。我们使用循环来提取数据，并将其放入一个具有字典结构的变量中，然后将其写入 CSV 文件。代码看起来像这样， |

如果我们显示。csv 文件，看起来像这样，

之后，我们将提取城市摄政级别的数据集。

对于数据集，我们将从https://covid19.riau.go.id/pantauan_data_kasus中获取。根据上面的图片，我们只需要首先检索所有的< tr >标签。之后，我们可以为每个< tr >标签检索< td >标签。变成. csv 文件的过程与前面的过程相同，代码如下所示:

在我们运行代码之后，它将创建一个. csv 文件，并附加在现有行的下面。这是的预览。csv 文件，

使用 Cron 调度任务

创建数据集后，我们可以专注于如何每天更新数据集。为此，我们可以在 Linux 上使用 Cron 来调度任务。在这种情况下，我将使用 Raspberry Pi Zero W 作为我的服务器来每天抓取数据集，我使用的操作系统是 Raspbian。

你已经注意到我在 Windows 上写了这个脚本。因此，我在 GitHub 上建立了一个知识库，这样任何设备都可以访问它。如果你想知道代码，你可以在我的库这里看到。我已经在我的 Pi 上克隆了存储库，所以我们可以直接调度任务。

在创建 schedule 命令之前，我们必须用。sh 格式来放置我们想要运行的脚本。我做的脚本看起来像这样，

第一行是 shebang 声明，告诉系统使用 bash 解释器。下面一行是我们想要运行的 python 脚本。完成这些之后，我们可以使用 Cron 创建我们的 schedule 命令。

要做到这一点，我们可以先打开终端。然后，键入 crontab -e，终端将打开一个 Nano 文本编辑器(如果您想使用 vim，可以更改它)。首先，我们会看到一些类似 crontab 文件的注释，

我们可以把我们的计划任务写在它的下面。它的结构看起来像这样，

**59 23 * * * /bin/bash ~/projects/covid-riau-tracker/script.sh**

嗯，一开始看起来很奇怪，但让我解释一下。前五个字段描述了我们任务的时间表。按照顺序，它们分别描述了分钟(0–60)、小时(0–24)、一个月中的某一天(1–31)、一个月(1–12)和一周中的某一天(1–7)。在这些字段之后，我们可以定义想要运行的命令。

因为我已经编写了脚本，所以我们可以使用 bash 来运行它。如果你仔细看，我写下了它的绝对路径。这是因为 Cron 没有与我们的文件相同的路径。这就是为什么我写绝对路径来访问文件。

在我们写完任务后，我们可以使用 CTRL + O 保存它，我们可以使用 CTRL + X 退出到终端。就这样，我们创建了一个 web 抓取任务的自动化。

结论

总之，如果我们想要的数据不是以友好的格式存在，web 抓取是一种有用的检索方法。csv 格式。同样，我们可以不自己运行它而让 Cron 来做。

虽然已经自动化了，但是有一个问题。就是如何更新数据集，然后推送到 GitHub。直到现在，我仍然无法将结果推送到 GitHub，我正在为此而挣扎。因此，如果你知道如何在 Cron 中做到这一点，请在下面留下评论。

我想这就是我现在能和你分享的。我希望这对你有所帮助，关于网络搜集如何真正有助于检索我们想要的数据，以及如何使其自动化。谢谢你。

为数据科学家和分析师自动创建气流 DAG

原文：https://towardsdatascience.com/automatic-airflow-dag-creation-for-data-scientists-and-analysts-17d24a9884ba?source=collection_archive---------24-----------------------

日常工作的自动化减少了数据错误，并为创新提供了更多时间。只需点击一下鼠标，使用这里提供的脚本，数据科学家和分析师就可以快速进行批量分析。

TL；DR : DAG creator 是一个 python 脚本，当运行时，它会选择最新的 json 定义文件，并将其中的值替换到 DAG 模板中，为每个定义文件创建新的 DAG。当执行新创建的 DAG 时，它会将查询的输出存储在 s3 中，然后将所需的数据推入 Redshift 中的最终表中。

最近，我听到(之前也遇到过)许多这样的场景:数据科学家或分析师希望通过批处理来自动完成分析，但他们必须等待数据工程师或软件工程师来完成。一方面，数据工程师知道如何生产代码，但另一方面，他们没有足够的时间来处理来自分析师和科学家的每一个需求。

这篇文章将展示一个工具，在没有数据工程师帮助的情况下快速生产你的代码。最棒的是，生产就绪代码附在这个帖子里，供那些想直接使用它的人使用。

根据我的经验，大多数数据科学家和分析师仍然通过会产生错误和数据问题的即席脚本进行日常分析。此外，对于一些人来说，制作脚本不值得他们花费时间，但是他们必须投资，因为这是团队的需求。对于像我一样的其他人，我们喜欢生产和优化 ETL 和数据流。

为什么生产数据分析:

好吧，信不信由你，有许多人仍然想知道为什么要生产代码，当他们可以每天早上或定期地通过改变 SQL 查询来执行它的时候。对他们和其他人来说，这些是你从生产数据的特别分析和处理中得到的好处。

  1. 一次性工作，您不必每天花 30 分钟来手动执行查询，这些查询可能会也可能不会给出无错误的数据。如果它偶然给出任何数据问题，那么将会有更多的时间浪费。
  2. 数据同时被复制到 S3，以备将来参考或未雨绸缪。
  3. 可读性和标准化的代码实践，对于任何新资源来说，理解和更新脚本将花费更少的时间。
  4. 在空间和时间之间，基于不同的用例，生产化的代码可以利用其中任何一个。
  5. 更好的异常处理将给出有意义的错误，最终将节省调试任何数据问题的时间。
  6. 其他人可以导入或继承您的工作，以便在他们的流程中使用。
  7. 自动回溯数据和重试逻辑。

自动气流 DAG 创建

此过程将自动创建 DAG，其中需要将所有分析任务放在 DAG 中，DAG 将充当模板。这些任务每次都是一样的。当您分析/查询数据时，这种情况肯定会出现，您必须将输出存储到一个表中，以便查看您的仪表板，或者您只想将数据附加到已经存在的表中，作为定期批处理的一部分。顺便说一下，DAG 是一个有向无环图。它是工作流中需要顺序或同时执行的任务的集合。

首先，在此过程中有 3 种类型的文件相关联:

  1. DAG 定义(。json)
  2. DAG 模板(。py)
  3. DAG 创建者(。py)

DAG 定义

简而言之，这些是每个 Dag 中不同的值。因为它定义了 DAG 的用途，所以我们称它为 DAG 定义文件。

下面是一个这样的例子:

你可以在这里找到示例文件

  • 查询:这是一个红移查询，它的 schema、table_name、from_date 和 to_date 参数化。当 dag_creator 被执行时，这些值将被填充。它应该在第一个“truncate {schema}”处包含 truncate 语句。“{table_name}”，它应该是{schema}中的 insert 语句。{table_name}它还应该具有用表的 datetime 列参数化的 from_date 和 to_date。将执行该查询，并将所需的数据放入一个临时表中。
  • 模式:红移模式
  • table _ name:schema 下的红移表。该名称用于红移表和 s3 文件夹。后者更难重命名，因此对于工作流，最好将其设置为您想要的最终表名。
  • table_columns :表格的列。它应该包含 batch_date。而且应该符合上面的查询。
  • start_date :上述查询应该开始执行的日期。(> =)
  • back_date_from :理想的情况是，如果用户今天更新了“查询”中的某些内容，那么从第二天开始，这些更改将会反映在表中，但是如果用户希望将日期倒推，以便这些更改也反映在过去的日期中，那么这需要是在表中进行更改之后的日期。这将自动清除 s3 键，并随后从表中删除> =该日期的行。现在，要么手动运行 DAG，要么等待下一次每日运行，以便将更新的数据推送到 s3 和表中。DAG 完成后，将此字段更新为其默认值，即“”。警告:请务必将此字段改回''，否则在每次 DAG 运行时，它将清除所需的 s3 密钥并删除表中的行。
  • batch_size :这用于将上面的红移查询分成多个批次，其中 batch_size 是在一个红移查询中运行的天数。当在初次运行时运行大量数据时，这提高了运行红移查询的速度。
  • template _ location _ in _ ec2:DAG 模板的位置。此位置是固定的，不应更改。该位置应该存在于您的虚拟机中。
  • dag _ folder:EC2 中放置最终 DAG 的文件夹，它将符号链接到 Airflow DAG 文件夹
  • DAG _ id:DAG 的 Id。这应该是唯一的，否则以前的同名 DAG 将被覆盖
  • Schedule _ interval:DAG 的时间表(Cron 格式)

DAG 模板

这是具有参数化值的最终 DAG 的框架，以便可以在 DAG Creator 的帮助下替换这些值。该 DAG 将具有下图所示的任务:

  • load_definition :这将从 s3 加载 DAG 定义
  • list_s3 :列出最近 14 天的 s3 密钥，这是 SLA。用气流变量覆盖它:“模块 _ 转换 _ 回顾 _ 天数”
  • compute_next_gather :基于列表键，这将计算出接下来几天要执行的任务，并因此将‘from _ date’和‘to _ date’推送到进一步的任务
  • 创建暂存表:创建暂存表
  • run_queries :根据上面计算的日期执行查询
  • 卸载 _ 暂存:将暂存台卸载到 s3 中
  • extract _ last _ batch _ date:从红移，这将计算 max(batch_date)
  • list_s3_for_table :列出 s3 键
  • s3_to_final :基于列表 s3 键和 last batch_date，这将计算出将哪些 s3 值推入最终表中
  • 红移 _ 分析:执行红移分析

下面是遵循的 s3 结构。并且符合红移数据库结构，即 schema.table.batch_date

= > S3://bucket/redshift _ schema/redshift _ table/batch _ date =YYYY-MM-DD/

你可以在这里找到 python 代码

DAG 创建者

这是主 DAG，它将从 DAG 定义中读取值，并将其替换到 DAG 模板中，并创建与存在的 DAG 定义一样多的 DAG。

  • get _ last _ modified _ definitions:从 s3 开始，将只选取那些在 DAG 创建者的最后执行日期之后(大于或等于)修改的定义。
  • remove _ old _ and _ create _ new _ dag:根据上面的定义列表，这将取消 DAG 与 EC2 的链接并将其删除，然后创建 DAG 并将其与新定义链接。

你可以在这里找到 python 代码

思考要点:

  1. 添加新的 JSON DAG 定义后，需要在 airflow GUI 中手动运行 dag_creator DAG current。DAG 运行完成后需要几分钟时间，新的 DAG 才会显示在 GUI 中。您可以在 CICD 管道中自动执行它，或者在 s3 中出现新定义文件时使用 Lambda 来执行它。所以，每当你按下
  2. 将表的所有权更改为数据库管理员或 ETL 管理员，以便 Airflow 可以将数据写入其中。

包裹

因此，当 DAG 创建器运行时，它将挑选最新的定义文件，并替换 DAG 模板中的值，以便为每个定义文件创建新的 DAG。当执行新的 DAG 时，它会将查询的输出存储在 s3 中，然后将所需的数据推入 Redshift 中的最终表中。

但是，如果你有大量的数据或点击流数据，不能把红移。下一篇文章将介绍另一种类似的教学方法，它将从 s3 中选择所需的拼花数据，而不是这里的红移，进行分析并将最终数据推入 s3 和红移。

机器学习模型的自动金丝雀释放

原文：https://towardsdatascience.com/automatic-canary-releases-for-machine-learning-models-38874a756f87?source=collection_archive---------38-----------------------

理解大数据

作为应用于机器学习的代码的连续部署和基础设施。

鸣谢:福扎伊·阿哈默德在 Pexels

“MLOps”是关于自动管理机器学习生命周期的。为此，机器学习工程师可以应用“DevOps”原则，主要区别在于它们的范围。

例如，ML 中的一个大挑战是测试，因为您不仅要测试数据是否满足某些要求，如训练模型所需的最少观察次数，还要检查您添加到模型中的新功能是否提高了它们的性能。

然而，一些“devo PS”工具可以直接应用于 ML 周期，如持续部署或基础设施作为代码。

在本文中，我们重点关注通过 Canary 部署持续交付 ML 模型，以及如何通过 AWS CloudFormation 为这些任务自动提供 AWS 堆栈。

H 高亮:所有附带的代码都可以在这个 repo 上找到，金丝雀策略是基于这个 AWS 的例子。

为什么要持续部署？

当用户可以直接与 ML 模型的结果或预测交互时，我们说它处于生产中，作为 API 部署以接收来自最终用户的请求。

如果我们继续改进这个模型，我们将需要一个框架来自动部署代码变更和重新训练模型。

例如，如果我们向模型中添加一些新变量，使其精度提高 x%，那么我们希望用户从这个新模型中获得结果。

这将意味着自动将最终用户的请求切换到较新的模型版本。

金丝雀释放怎么样？

“金丝雀”一词来源于煤矿中用金丝雀来警告矿工有毒气体的危险程度。

这种策略对部署很有用，因为一小部分用户或请求就像金丝雀一样，可以检测到已部署变更的早期问题。因此，在向所有用户发布该版本之前，可以检测到潜在的问题。

要实施 canary deploy，我们将遵循以下步骤:

  1. 将一小部分请求分配给较新的版本。
  2. 检查新版本中的错误。如果发现错误，回滚或将所有权重分配给当前版本。
  3. 重复第一步和第二步，直到新版本收到所有请求。

下面是伪代码版本。

金丝雀部署伪代码。来源:作者

步骤 1:将流量路由到新版本

AWS Lambda 允许实现金丝雀部署的一个特性是 加权别名 、别名是一个函数标识符。通过指定路由配置，它们允许一个将流量路由到同一功能的两个不同版本(不同的代码快照)。

例如，如果我想用一个开发阶段来标识一个 lambda 函数，我可以使用一个“dev”别名，我们稍后将看到如何使用 CloudFormation 自动实现这一点。

现在，假设“我的当前版本”拥有 100%的流量，我们希望开始将 10%的流量路由到“我的新版本”。

我们可以通过更改“dev”别名的路由配置来指定这一点。

在第 13 行(代码片段)，注意我们正在调用“update_alias”函数来将 10%的流量路由到“my_new_version”，有关此函数的更多详细信息，请参见文档。

一个自然产生的问题是，如何验证“我的新版本”没有错误？以便我们可以继续向它发送更多的流量。

步骤 2:检查调用错误

我们想知道函数是否返回一个错误，所以我们将使用调用度量，特别是 【错误】 度量，因为它们包括“由您的代码和 Lambda 运行时抛出的异常”(有关更多选项，请参见 Lambda 函数度量)。

由于“我的新版本”现在拥有 10%的流量，我们需要定义一个时间窗口来检索其可能的错误。例如，如果在之前的 5 分钟内有错误。

为此，我们考虑将每分钟内的所有误差相加。因此，如果在过去 5 分钟的给定分钟内，有一个错误，这将是一个警告，停止分配更多的权重给新版本。

现在，假设“我的新版本”出现了错误，我们该怎么办？

请注意，上面的 update_alias 有一个参数，用于配置路由到“dev”的流量。

因此，通过将一个空字典分配给“AdditionalVersionWeights”，我们将所有流量都转到“my_current_version”。

第三步:线性增加权重

到目前为止，我们已经知道了如何为新版本分配一个权重，以及在出现错误提示时应该做什么。但是，正如你在伪代码的第 9 行看到的(wₙ → wₙ + i )，我们还没有定义如何给“我的新版本”分配更多的权重。

鸣谢:西蒙·哈奇在 Unsplash

注意到“AdditionalVersionWeights”需要的流量百分比是一个浮点值，我们可以使用无限的数学函数来增加权重。

例如，我们可以考虑指数或二次函数，然而，通常的部署偏好类型是线性的。也就是说，流量在每一分钟以相等的增量分配，在我们的例子中，每分钟 10%，您可以在 repo 中查看这个实现。

通过 CloudFormation 实现 AWS 堆栈自动化

因为我们想在 AWS 上自动创建资源，所以我们通过 CloudFormation 创建服务。

到目前为止，我们已经调用了一个 lambda 函数，并从 CloudWatch 检索它的统计数据。这些是授予执行 Lambda 函数的 IAM 角色的操作或权限，简单来说，IAM 角色就像一张身份证，可以使用不同的 AWS 服务。

请注意模板上的 MLmodelAPI 资源，它表示作为无服务器 API 部署的 ML 模型。由于这超出了本文的范围，您可以在这里找到一个很好的实现。

正如您在上一节中所记得的那样，给 lambda 函数赋予一个别名可以让我们识别它，我们可以使用 AWS::Lambda::Alias 资源自动完成这项工作。

在这种情况下，我们根据工作阶段“dev”、“stage”或“prod”为 MLModelApi Lambda 函数分配标识符。

因此，如果我们在 ML 模型中添加一个新特性或者修复一个错误，我们可以安全地在“开发”阶段工作。当这些变化准备就绪时，我们发布一个新版本(新代码的快照)并开始向它发送新流量，就像我们之前看到的那样。

使用 Gitlab-ci 进行持续部署

每次我们推送一个 git 存储库时，在测试代码没有被破坏之后，我们都会运行一个脚本管道来部署新的变更。

然而，并不是每次推送都会改变 ML 模型 API 的代码，例如，只添加文档的代码。

出于这个原因，遵循常规提交的标准，我们允许部署(canary release)阶段只有在提交消息以 API 为目标时才是活动的。

一个例子是“Feat (Api):我的特征消息”或“Fix (Api):我的 Fix 消息”。在 repo 管道中，您可以发现部署阶段(齿轮标志)显示了提交“Feat (Api): Sample Lambda 函数”。

为了实现这一点，我们遵循一个正则表达式模式，首先匹配动作的类型(专长、修正、测试等等)。)通过捕获第一个大写字母，随后是两个或多个小写字母。然后，它通过匹配任何后跟“(Api)”的字符来匹配范围，在本例中是 Api。您可以在下面的代码中查看完整的正则表达式模式。

回滚到分支也可以应用，你可以在这篇文章上找到 ML 模型的 CI 应用。

最后的想法

现在，每次你对你的 ML 模型进行修改，就像提交“Feat (Api):添加一个新特性”一样简单。

这有两个很大的好处，一个是遵循一种编码风格，你和其他人将能够理解你的变化。第二，你可以自动看到你在生产中的变化。

添加到管道中的一个缺少的步骤是持续集成，这样您就可以获得回滚 git 分支的好处。

例如，您在“开发”中处理变更，在 CI 中转移到“阶段”,在 Canary 部署中继续“生产”。

你可以在下面的回购中找到所有代码和简要说明。

[## Miguel Trejo marr UFO/ml-canary-deploy 项目

金丝雀部署示例

gitlab.com](https://gitlab.com/Miguel_TM/ml-canary-deploy)

参考

  1. AWS Lambda 功能指标。

  2. AWS Lambda 部署示例。

  3. AWS Lambda 函数别名。

  4. Gitlab CI/CD 配置。

Azure 机器学习工作区的自动数据注册

原文：https://towardsdatascience.com/automatic-data-registration-for-azure-machine-learning-workspaces-65beb7d81521?source=collection_archive---------61-----------------------

大规模数据科学环境的再现性

A.介绍

Azure 机器学习(AML)工作区是一个很好的平台，数据科学家和数据工程师可以在这个平台上协作并从事不同的项目。它将笔记本编码环境、为代码提供动力的计算目标、保存数据源引用的数据集和数据存储库以及跟踪实验的方法结合在一起。

虽然围绕此工作区的大多数任务都可以通过用户界面或云外壳/命令行来完成，但是一旦您向外扩展到大量工作区或数据源，手动管理所有资源就会变得难以承受。

博客是 github repo 的伙伴。

这个项目的目的

  • 创建一种自动注册和管理 AML 工作区数据的方法(步骤 1-4)
  • 将这些任务的有用脚本打包到可以从一个控制点触发的容器中(步骤 5-6)
  • 启用授权和身份验证措施，以确保解决方案“企业就绪”(步骤 7)

一些好处:

  • 可再现性:不同项目/团队的相同数据(和版本)
  • 可伸缩性:易于管理不同的团队/项目:例如，运行 Azure 数据工厂管道来(同时)在整个域的所有工作区和订阅中填充新数据。
  • 数据跟踪:定义 RBAC，将触发这些任务的权限授予少数团队成员，以提高安全性和可跟踪性

使用的技术

该解决方案的功能架构:展示了由 ADF 触发的 python Web 应用程序，该应用程序将数据从数据湖存储区移动到各种 AML 工作区，然后再返回。作者图片

在 github 仓库项目中

  • Python 和 azureml-SDK
  • Flask，用于修改 python 脚本以作为 web 服务运行

在这个 Azure 教程博客中

  • Azure 数据湖作为您的数据源
  • Azure 机器学习工作区是注册数据的地方
  • Azure Web 服务
  • Azure 数据工厂触发对 web 应用的 HTTP 请求
  • 为了使这个解决方案安全，我们将使用 Azure 授权和认证概念:服务主体、密钥库、托管身份、AAD。

B.辅导的

资源部署

在本节中，我们将介绍必要资源的部署。查看 Azure 文档演练和更多信息的链接。

你在 Azure 上的新项目资源组。我在西欧部署了一切图片作者

1. Azure 机器学习工作区

  • 可以跨不同的资源组或区域
  • 在本教程中，我创建了一个“基本”AML 实例。

2.具有至少一个容器和至少一个文件的数据湖或 blob 存储

我在 medium-webapp-aml 资源组中名为 mediumstoragetutorial 的存储帐户。作者图片

  • 创建一个存储帐户，并确保在高级设置中启用“分层命名空间”，使其成为一个数据湖。
  • 我创建了一个名为 silver 的“主”容器(假设数据将来自您的业务中先前生成数据的任何流程)
  • 我添加了包含模拟数据的文件夹:一个会计和销售容器，每个容器包含一个 csv 文件，我们稍后需要在工作区中注册该文件。

3.服务主体

  • 在这个自动化场景中，服务主体(sp)用于向 AML 进行身份验证，而不是用户每次运行都必须使用 Azure 凭据登录。

3.1.我们将在您的 AAD (链接) (链接)上注册一个服务主体作为应用程序

  • 点击 Azure 门户右上角的> _ 图标，打开 Azure 云外壳。
  • 通过使用您想要的任何名称而不是 sp-medium-demo 运行此命令来创建服务主体:
az ad sp create-for-rbac --sdk-auth --name sp-medium-demo
  • 保存您在 json 响应中获得的clientId、clientSecret和tenantId字段，以备后用(它们将进入您的密钥库

3.2 授予其对您的 AML 和存储帐户的必要权限

  • 转到您的门户，打开机器学习和存储帐户资源，准备好您为服务负责人指定的名称，以添加到“角色分配”页面。

角色分配菜单。作者图片

  • 将服务负责人应用程序 C 贡献者添加到您的 AML 工作区
  • 使 sp 成为您的存储帐户的存储 Blob 数据读取器

4.钥匙库

github 中的代码片段，在 register_data.py. 文件中。图片作者

向密钥库添加秘密。作者图片

  • 在您的资源组中创建一个密钥库，并创建三个秘密来存储您刚刚创建的服务主体的凭证。(不带引号)
  • 您稍后将克隆的代码从密钥库中获取这些凭证，以确保自动化的&安全认证/授权。
  • 所以为了简单起见，你可以为你的秘密使用相同的名字，**tenant-id****sp-id****sp-password**为tenantId, clientId，以及在第 3.1 步得到的clientSecret值****

4.部署在 Web 应用程序中的代码(进行数据注册)，可在我的 github 上获得。

  • 在您选择 IDE 中克隆存储库。我将使用 Visual Studio 代码 (VSC)，以便更容易与 Azure Web App 集成。
  • C 孤独的 VSC github 库教程
  • 您可以通过将 Visual Studio 代码作为 flask 应用程序运行来测试该代码是否已正确导入 Visual Studio 代码，如 repo readme 中的所述。

运行代码时 Visual Studio 代码环境的屏幕截图。作者图片**

  • 在这段代码中，您唯一需要自己填写的是到您新创建的密钥库(DNS 名称:yourname.vault.azure.net)的链接，以及秘密的名称(如果您更改了它们，请参见步骤 4)，请参见 github 自述文件中的说明。
  • 要访问密钥库，您需要在密钥库访问策略中添加机密阅读器权限。你可以从现在开始运行代码的地方(例如一个 VM)这样做，但是在本教程中，我们在下一步中只将这些权限直接授予 web-app。
  • 因此，/send_data POST 请求应该还不能工作，这对安全性来说是件好事

5.一个 web 应用来托管您的 python 应用

我通过门户创建了“数据注册”应用程序，然后从您的资源中通过名称选择它来更改配置。作者图片**

  • 在 Azure 上创建一个“Web 服务”,运行时栈用 Python，操作系统用 Linux。部署后转到资源。
  • 更改您的应用程序服务的启动命令，以匹配您的 flask 应用程序的名称，并执行以下操作:
**gunicorn --bind=0.0.0.0 --timeout 600 app_body:app**
  • (见左图)然后保存配置。

我创建的数据注册应用程序现在可以在 VSC 看到。作者图片**

  • 现在，您需要将 Visual Studio 中的代码连接到您在 Azure 门户上创建的应用程序。
  • 为 VSC 安装 azure web 服务插件，然后根据需要使用您的 azure 凭据登录。
  • 现在你将在 VSC 拥有蓝色之刃(1。图片中)，您可以在您的订阅下的列表中看到您创建的 web 应用程序。单击标有 deploy (2。)
  • 当命令托盘要求时，填写克隆的 repo 中的“app”文件夹和新部署的 web 的名称。然后单击 accept，现在您就可以将 python flask 应用程序和依赖项部署到您的新网站了。
  • 部署完成后，请访问网站。它应该说“你好，尤利亚！”—将app_body.py中的此消息更改为您想要的任何内容。

5.05 允许 Web 应用程序访问密钥库

  • 对于 web 应用程序的另一个页面，即/send_data，我们需要 Web 应用程序从您在步骤 4 中设置的密钥库中读取秘密。
  • 首先，Web 应用程序需要一个身份来授权。在门户中启用此功能，方法是转到您的 web 应用程序，然后转到身份设置:

为您的 web 应用程序启用系统分配的身份，然后保存。作者图片**

作者图片

  • 现在转到门户中的密钥库，检查访问策略设置。单击以添加新的访问策略，并搜索您刚刚为其创建身份的 Web 应用的名称；在保存上一步之前，它不会显示在列表中)
  • 使用秘密管理权限模板，在选择负责人下选择您的 Web App 名称并保存。然后再次保存对所有访问策略的修改。****
  • 现在，您的 web 应用程序可以向/send_data选项卡发送 post 请求，并使用密钥库中的凭证注册您的数据。

6。一个 Azure 数据工厂实例向你的 web 应用发送请求

  • 部署 Azure 数据工厂，通过 Author & Monitor 打开实例，然后单击 create pipeline。
  • 现在搜索“Web”活动，并将其拖动到您的管道区域。这将是你管道中的唯一一步。
  • 填写您部署的 web 应用程序的名称，选择 POST request，并填写您的请求主体，作为您克隆的代码的 JSON 输入。点击查看如何创建这个 JSON。

作者图片

  • 您现在可以调试或立即触发来运行您的函数。
  • 管道成功后，您现在可以检查您的 AML 工作区。您通过 JSON 发送的数据存储/数据集现在应该已经注册并可用了！

成功！！作者图片

C.增强安全性

7.安全和授权限制

为什么

此时，任何人都可以调用您的 web 应用程序，这不是一个健壮和安全的解决方案。

虽然没有数据通过 HTTP 请求发送，但应用程序也没有提供任何关于应用程序的信息；这仍然不是尽可能健壮和安全的解决方案(也不是企业解决方案所必需的)

解决办法

期望的状态:只有你的 Azure 数据工厂实例被授权调用你的 Web 应用，从而将数据注册到你的工作区。

  • 我们通过激活数据工厂的托管标识来实现这一点；这样就可以像授权给用户一样授权给它
  • 通过设置对 Web 应用程序的 AAD 认证，用户(或应用程序)必须登录，并且他们的帐户必须具有正确的授权才能进行呼叫。

履行

我的同事 René Bremer 已经设计了这个解决方案，他在 github 上有一个资源库。按照步骤去做。你只需要从 Azure 功能适应 Web 应用程序(无论如何都是同样的步骤)。

这是他设计的安全流程:

由勒内·布雷默创作

结束了

希望这对您有用，无论是完整的解决方案，还是您可以在不同项目中使用的独立部分！

15 分钟内解释自动微分

原文：https://towardsdatascience.com/automatic-differentiation-15min-video-tutorial-with-application-in-machine-learning-and-finance-333e18c0ecbb?source=collection_archive---------36-----------------------

视频教程及其在机器学习和金融中的应用

我在过去的五年里做了很多关于自动微分 (AAD)的讲座和专业介绍。我甚至写了一本关于它的书。许多学生、学者和专业人士认为最有用的是 2019 年 11 月在彭博伦敦办公室录制的 15 分钟教程。

挑战是在不到 1/4 小时的时间内解释 AAD 的主要思想及其在机器学习和金融中的应用。我想给出的不仅仅是一个概述，而是对关键的数学和技术概念的一个实际的窥视。

我设法在这么短的时间内涵盖了主要概念:

  • 通过与有限差分等经典自动微分算法的比较，介绍 AAD 的优势，并在波动性风险报告的背景下进行演示。
  • 介绍计算图的关键概念，以及前馈神经网络和 Black & Scholes 公式实现的明显不同的示例。
  • 用可区分节点(或“ops”)的一般术语解释计算图，以及它们如何表达评估和区分。我还在威尔莫特杂志的三篇文章中详细讨论了这些话题。
  • 发现逆序微分的力量，将经典反向传播推广到任意计算，回顾反向传播作为前馈网络环境中的一个特例。
  • 解释 AAD 如何在执行过程中记录操作，并自动将它们按正确的顺序排列，以实现最佳反向传播，并在 Black & Scholes 计算图上进行说明。
  • 介绍路径微分，衍生产品风险管理中的另一个关键概念，以及如何使用 AAD 以神奇的速度和分析准确性计算它们。
  • 综上所述，解释先进投资银行中实施的现代衍生产品系统如何应用 AAD 实时计算复杂的风险报告，并使用支持计算机视觉或自然语言处理的相同底层技术。

我必须快速交付大量信息，因此本教程最好与幻灯片一起提供，如下所示:

点击图片查看幻灯片

安托万·萨维恩

在金融领域，衍生敏感性被称为“希腊人”——罗尔夫·鲍尔森在威尔莫特发表了一篇关于 AAD 的专栏文章(98 期，11 月 18 日，第 36-39 页)，名为这不是斯巴达 (300 个希腊人不会阻止我们)

基于机器学习的胸部 CT 扫描自动判读

原文：https://towardsdatascience.com/automatic-interpretation-of-chest-ct-scans-with-machine-learning-8902b1357de9?source=collection_archive---------33-----------------------

这张图片包括来自维基百科这里的可滚动 CT 的剧照，以及来自维基百科这里的胸廓图。

这篇文章提供了使用机器学习自动解释胸部 CT 扫描的深入概述，包括对来自 19，993 名不同患者的 36，316 卷新 RAD-ChestCT 数据集的介绍。这篇文章的主要参考是我最近的论文“基于机器学习的大规模胸部计算机断层扫描体积的多种异常预测”，其中描述了 RAD-ChestCT 的开发和分析，这是世界上最大的胸部体积成像数据集。

CT 扫描是大体积图像，大约为 512 x 512 x 1000 灰度像素，描绘了心脏、肺和胸部的其他解剖结构。它们用于包括癌症、感染和骨折在内的各种医疗状况的诊断和管理。这篇文章讨论了如何获得 CT 扫描，如何解释 CT 扫描，为什么 CT 的自动解释具有挑战性，最后，如何使用机器学习来自动解释 CT 扫描。

什么是胸部 CT 扫描？

胸部 CT 描绘了胸部，包括左肺、右肺、气道、心脏和大血管:

图片来源:维基百科

关于胸部解剖的更详细的概述，见这篇文章。

因为胸部 CT 扫描是体积图像，所以可以通过滚动三个不同的平面来查看:冠状面、轴面和矢状面。

修改自维基百科解剖平面

以下是轴面上的 CT 扫描示例:

这是轴面上的另一个 CT 扫描示例:

关于从所有三个不同视图显示的 CT 扫描示例，请参见这篇文章，其中包括正常胸部的可滚动高分辨率 CT 图像。

CT 扫描是如何获得的？

下图显示了 CT 扫描仪，它是一种环形仪器:

图片来源:维基百科

患者躺在手术台上，通过 CT 扫描仪的“环形孔”移动。这是 CT 扫描仪内部的样子:

图片来源:修改自维基百科

CT 扫描是基于 x 光的。然而，CT 与“投影 x 射线”不同，因为 CT 是 3D 的，而投影 x 射线是 2D 的(自动投影 x 射线解释在此概述)。

CT 扫描仪的 x 射线源将 x 射线束(上面红色部分所示)穿过患者的身体，射到探测器上。当患者穿过中心孔时，整个源/探测器设备围绕患者旋转，从而可以在 3D 空间中的许多点上测量患者身体的放射密度。

最终的 CT 扫描使用 Hounsfield 单位对患者体内数百万个点的辐射密度进行编码，其中空气显示为黑色，骨骼显示为白色。中等密度的组织显示为灰色。

放射科医师如何解读 CT 扫描？

CT 扫描是一种流行的成像形式，对于许多疾病的诊断和管理非常有用。放射科医生是解释医学图像并撰写描述性报告的医生，其他医生在护理病人时会用到该报告。

放射科医师执行两个主要任务来解释 CT 扫描。首先，放射科医师必须确定存在何种异常情况，例如肺炎(肺部感染)、肺不张(肺组织塌陷)、心脏肥大(心脏增大)、结节、肿块、胸腔积液(肺部积液)等。接下来，放射科医师必须在描述中指明异常位于何处。位置通常在医学上很重要——例如，不同种类的肺癌往往位于不同的地方。下表总结了放射科医师的任务:

CT 报告示例

这是一份来自国家诊断成像公司的胸部 CT 报告示例，其中的文本复制自一份公开的示例报告，您可以在此处查看:

检查:CTA 胸部 W W O 对比

临床病史:SOB、呼吸困难、呼吸困难、ILD、可能的职业性肺病

适应症:49 岁气短患者。可能是 PE。可能是职业性肺病。

程序:在无静脉造影和有静脉造影的情况下获得连续的轴向切片。通过肺动脉进行团注薄层切片。

肺动脉干显示无血栓或栓子迹象。没有鞍状栓子的证据。左右主肺动脉看起来不明显。双侧一级和二级肺动脉分支没有显示栓子。腋窝区域没有腺病。纵隔和肺门区域没有肿块或腺病。包括上腹部显示脾脏钙化，这可能表明远程肉芽肿性疾病。右边是一些局灶性肾皮质增厚，可能是先前的疤痕。没有证据表明肺实质间质性肺病。在图像 2 系列 4 的左下肺有一个 3 毫米的结节。如果有进一步的担忧，可以在 12 个月后进行 CT 监测。在左侧的同一系列图像 49 上也有一个类似的小结节。没有浸润或渗出。未见急性骨异常。

印象:没有肺栓塞疾病的证据。如果有足够的关注，可以在 12 个月时通过 CT 对左侧的一些小结节进行随访。没有间质性肺病的证据。

为什么说自动 CT 判读是一项有趣且具有挑战性的任务？

放射科医生为每次 CT 扫描制作这些详细的报告非常耗时。当患者已经接受了多次 CT 扫描时，这甚至更加耗时，例如，初始扫描和 3 个月后的随访扫描，因为在这种情况下，放射科医师必须并排比较两次扫描，以了解患者的健康状况如何变化。人们对开发机器学习方法以自动解释 CT 扫描、加速放射学工作流程并降低放射科医生 3–5%的实时诊断错误率非常感兴趣。

CT 扫描的自动解释具有挑战性，原因有几个:

挑战 1: 患者的解剖结构根据性别、年龄、体重和正常解剖变异而自然变化。因此“变异”不一定意味着“异常”

挑战二:有上百种可能的异常。下图仅显示了几个例子，包括嗜酸性肺炎、空洞性病变(“空洞”)、囊肿、肺气肿(肺变得更加疏松，例如由于吸烟)、气胸(肺和肺囊之间的气囊)和纤维化(类似于瘢痕形成):

从这些原始图像修改:嗜伊红细胞肺炎维基多克。空洞/囊肿/肺气肿放射科医生。气胸百科。纤维化维基百科

挑战 3: 在一次扫描中通常会出现多种不同的异常。平均 CT 扫描包含 10 +/- 6 种不同的异常。下面显示了几个具有一个以上异常的 CT 扫描切片示例:

由这些原始图像修改而来:心包积液放射科。肺炎、脓肿。心力衰竭放射医学

挑战 4: 此外，在一次扫描中经常会出现多个相同的异常情况。下面，我们可以看到一个扫描显示肺气肿肺中的多个肺大泡(大气囊)，另一个扫描显示充满结节，还有一个扫描显示多个肿块:

从这些原始图像修改:肺气肿TES.com。结节肺历书。大众研究门户

挑战 5: 不同的异常可以看起来彼此相似。在这些情况下，放射科医师依靠他们的广泛培训和患者的医疗背景来确定异常的性质。下面的扫描显示了肿瘤(“TUM”)和肺不张(“ATL”，塌陷的肺组织)，它们在该扫描中看起来相似:

图片来源:肺不张/肿瘤研究之门

挑战 6: 同样的异常可以有不同的表现。例如，同样的异常情况根据严重程度会有不同的表现，例如下面的肺炎扫描，左边的扫描显示整个肺部因肺炎而“变白”,而右边的扫描只显示肺部因肺炎而“变白”的一小部分:

由这些原图修改:肺炎例 1 Kalpana Bansal 。肺炎例 2 放射医学

同样的畸形也可能因其形状和质地而看起来不同。下图显示了根据形状(例如分叶状、针状、圆形)和质地(例如毛玻璃、实心)而看起来不同的肺结节:

修改自这些原始图像:肺结节维基百科

下图总结了自动化 CT 解释面临的挑战:

如何使用机器学习进行自动 CT 解读

为了理解如何使用机器学习进行自动 CT 解释，首先考虑哪种数据可用于训练模型是很重要的。

医疗保健系统保存与相应 CT 报告配对的 CT 体积:

有些患者只有一个 CT 体积和报告，例如上图中的患者 000000。其他患者将有多个 CT 体积和报告。这些多个 CT 体积可能是在不同的时间拍摄的和/或可能是身体的不同部分(虽然本文主要关注胸部 CT，但也可能获得头部、腹部、骨盆和其他区域的 CT)。

我们还需要考虑哪种数据在医疗保健系统中不可用:

根据 SeattleCCA.org的海量图像修改

具体来说，如上图所示，在基线时，我们无法访问:

  • 分割遮罩:这些是像素标签(“感兴趣的异常周围的跟踪轮廓”)，需要它们来训练分割模型。此处回顾了医学图像的分割模型。
  • 边界框:这些是围绕感兴趣的异常绘制的框，需要它们来训练对象检测模型。从技术上来说，放射科医生有时会直接在图像上绘制线条或其他注释，通过大量的工作，这些线条或注释可以变成适合训练机器学习模型的边界框注释(例如， DeepLesion )。然而，放射科医师从不在单次扫描中注释每个异常，并且更可能的是，放射科医师将在一次扫描中仅注释一种类型异常的一个代表性实例(例如，几个结节中的一个结节)。因此，所有异常的综合边界框注释永远不可用。
  • 全体积标签:这些是分配给训练全体积分类器所需的整个体积的标签。人们可能会认为医院会在 CT 扫描上存储“标签”,例如指示是否存在肿块(肿块=0 对肿块=1)。但是，医院不会存储这些信息。唯一可用的信息是自由文本报告。在以后的文章中，我将描述如何从自由文本报告中获得结构化的整卷标签。

可能性:从 CTs 生成文本

假设我们所有的是与报告配对的卷，一种直观的方法是尝试直接从卷中生成文本。在该设置中，我们将首先将 CT 体积处理成低维表示(例如，使用 CNN )，然后我们将从该低维表示生成文本(例如，使用 LSTM):

目前我还没有看到任何关于从体积中自动生成 CT 报告的研究。有几项关于自动生成胸部 x 射线报告的研究，这是一项更可行的任务，因为胸部 x 射线的尺寸小得多(小约 1，000 倍)，并且胸部 x 射线报告的长度短得多(短约 6 倍)。然而，即使在这个更简单的任务中，模型也很难产生准确的报告。我怀疑这部分是因为放射学报告包括许多“正常”的句子，所以对于一个模型来说，一个包含大多数正常句子的生成报告有可能获得“高分”，即使该报告在异常情况上搞砸了——这恰好是医生最关心的部分！

尽管从 CTs 生成文本可能是一项有趣的学术实践，但从 CTs 生成文本的主要实际缺点是:

  • 文本生成模型必须是完美的，才能在商业上使用。如果每 10 个笔记中有一个错误，没有人会使用该系统，因为医疗错误的潜在成本太高，而且“检查每份报告的正确性”所需的时间比从头开始口述报告所需的时间还要长。
  • 文本生成模型本身并不提供每个异常的性能指标，而这正是放射科医师为了信任该系统而需要看到的。有些异常比其他异常更难检测，放射科医生想知道该模型在检测每种异常方面有多好。

更实际的途径是建立一个机器学习系统，它可以以结构化的方式预测异常情况和位置。然后，我们可以获得每个异常的性能指标，还可以突出显示扫描中可以观察到每个异常的位置。这种系统可用于自动检伤分类(例如，“将所有带有气胸的扫描移动到放射科医师队列的顶部”)，并可与放射科医师的读数结合使用，以尝试并提高诊断准确性。此外，擅长预测异常和位置的系统也可以用于生成文本(如果这是期望的目标)。由于放射学语言是高度结构化的，仅给出异常及其位置的列表，使用规则生成基本的自由文本报告是微不足道的。

单一异常 CT 分类

由于前面部分列出的原因，人们对 CT 图像中的异常分类很感兴趣。

在单一异常 CT 分类中，模型(通常为 CNN)处理 CT 体积，并根据感兴趣的特定异常是否存在产生 0 或 1(即，二元分类):

所有先前的胸部 CT 分类工作都集中在一次预测一种异常或一类异常的模型上。这一先前的工作依赖于小的、手工制作的数据集，这些数据集已经由专家用小块水平或切片水平的疾病注释费力地标记。

这是我整理的一个表格，总结了一些先前通过胸部 CT 扫描预测间质性肺病的工作。此处显示的模型通常为每个切片或补片分配一个类别标签，用于间质性肺病的子类别:

这是我整理的另一个表格，总结了之前对 CT 扫描中其他异常的预测，包括肺癌、颅内出血和气胸:

对补丁级或切片级注释进行训练的一个优点是，得到的模型将固有地提供补丁级或切片级的本地化。

关于补丁或切片级注释的训练的一个缺点是这些注释在健康系统中不可用，并且必须手动获取，这:

  • 限制了可以包含在数据集中的 CT 数量(除了 Ardila 等人和 Kuo 等人的研究，所有这些论文都使用少于 1，200 次 CT 扫描)；
  • 限制可以考虑的异常数量(显示的所有研究都考虑了<8 abnormalities).

多重异常 CT 分类

尽管单一异常分类模型可以实现高性能，但是它们具有固有的有限功能。全面的 CT 解释将需要数百个独立的二元分类器。CT 解释的另一个框架是多标记分类，其中许多异常是从一次 CT 扫描中同时预测的。关于多类分类和多标签分类的回顾，请见本帖。

多标记异常分类如下进行:

每个 CT 体积被分配给一个、多个或不分配给任何类别。

直到我的最近的工作多标记胸部 CT 分类的问题还没有被探索。然而，已经对多标记 2D 胸部 x 射线分类进行了深入研究，这得益于具有多个全图像标记的胸部 x 射线的大型公共数据集的可用性:

受先前胸部 x 线多标记分类工作的启发，我最近致力于胸部 CT 的多标记分类。我在多标记胸部 CT 分类方面的工作有三个部分:

  • 准备来自 19，993 名不同患者的 36，316 个胸部 CT 体积的数据集。据我所知，这是世界上最大的多注释体积医学成像数据集。
  • 开发一种基于规则的方法，用于从平均 F 值为 0.976 的自由文本放射学报告中自动提取结构化异常标签。需要这些结构化异常标签来训练分类器。
  • 多器官、多疾病卷积神经网络分类器的训练和评估，该分类器分析整个 CT 体积以同时预测 83 种异常。该模型在 18 种异常情况下达到大于 0.90 的 AUROC ，所有 83 种异常情况的平均 AUROC 为 0.773。

在以后的文章中，我将更详细地探讨这些方向:如何准备大量的 ct 数据集和报告，如何从报告中提取结构化标签，以及如何构建完整的 CT 分类器。

关于 CT 数据的其他有趣任务

CT 数据的一些更有趣的任务是:

  • 对象检测，其中模型预测感兴趣的异常周围的边界框的坐标。这里，围绕感兴趣的异常的边界框需要用于训练和评估。在的深度病变论文中可以找到 CT 扫描中这一任务的例子。
  • 分割，其中模型预测像素标签(有效地，“异常的跟踪轮廓”)。
  • 配准，其中模型“对齐”两个不同的扫描，以便解剖结构处于大致相同的位置。

总结

  • 胸部 CT 是由大约 512 x 512 x 1000 灰度像素组成的立体医学图像，使用围绕患者身体旋转的 x 射线源和探测器采集。
  • 放射科医师通过识别扫描中出现的所有异常的性质和位置来解释胸部 CT。放射科医师写一份总结他们发现的报告。
  • 医院存储 CT 体积和自由文本报告，但不存储分割遮罩、边界框或结构化整体体积标签。
  • CT 扫描的自动解释的先前工作集中在一次识别一类异常，例如间质性肺病或颅内出血。
  • 最近，我整理了一个 36，316 个胸部 CT 体积的数据集，并建立了一个多标记分类模型来预测每个完整体积的 83 个异常。
  • CT 体积上的附加任务包括对象检测、分割和配准。

原载于 2020 年 3 月 5 日 http://glassboxmedicine.com**。

使用 Python 自动通知电子邮件

原文：https://towardsdatascience.com/automatic-notification-to-email-with-python-810fd357d89c?source=collection_archive---------16-----------------------

使用 Python 自动化您的通知系统

约纳斯·勒普在 Unsplash 上拍摄的照片

你有没有处于一个等待你的机器学习模型，需要去某个地方的位置？或者您正在执行另一项任务，并且一直在思考您的脚本是否已经成功运行？我以前也有过这样的经历，这就是为什么我用 Python 为我的电子邮件创建了一个自动通知系统。

在本文中，我将解释如何通过几个简单的步骤用 Python 创建自动化系统。让我们开始吧。

电子邮件准备

为了简单起见，我会使用 Gmail 的电子邮件系统。我们首先需要做的是从谷歌 API 控制台设置 Gmail API。在开发人员仪表板中，选择启用 API 和服务。

在那里，尝试输入并搜索 Gmail API。

在 Gmail API 选项中，单击启用以激活我们的 Gmail API。

完成后，我们需要在中创建凭据来访问电子邮件，并使用 Gmail 发送通知。

选择 OAuth 客户端 ID，当询问应用程序类型时，因为我使用 Jupyter Notebook 来运行我的脚本，所以我会选择桌面应用程序。

随便你给它起什么名字，这里我就叫它 gmail_python。当您完成创建凭证时，您需要以 JSON 形式下载它。对于我的推荐，最好改名为‘credentials . JSON’。

将文件与 Jupyter 笔记本(或脚本)放在同一个文件夹中。

创建通知系统

电子邮件系统将基于谷歌 Gmail API 的推荐发送电子邮件。我还会使用电子邮件模块来帮助我构建发送电子邮件的系统。

首先，让我们创建生成消息的函数。

from email import encoders
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import base64
import osdef create_message(sender, to, subject, message_text):
  """Create a message for an email.Args:
    sender: Email address of the sender.
    to: Email address of the receiver.
    subject: The subject of the email message.
    message_text: The text of the email message.Returns:
    An object containing a base64url encoded email object.
  """
  message = MIMEText(message_text)
  message['to'] = to
  message['from'] = sender
  message['subject'] = subject
  return {'raw': base64.urlsafe_b64encode(message.as_string().encode()).decode()}

然后我们创建发送消息的函数。

def send_message(service, user_id, message):
  """Send an email message.Args:
    service: Authorized Gmail API service instance.
    user_id: User's email address. The special value "me"
    can be used to indicate the authenticated user.
    message: Message to be sent.Returns:
    Sent Message.
  """
  try:
    message = (service.users().messages().send(userId=user_id, body=message)
               .execute())
    print('Message Id: {}'.format(message['id']))
    return message
  except:
    print ('An error occurred')

现在我们有两个功能来创建消息和发送电子邮件。下一步，让我们创建一个自动化通知系统的函数。这里我们需要之前从 google Gmail API 创建的凭证。在这里，我将我的系统设置为使用凭证 JSON 文件作为‘credentials . JSON’。

def notification(sender, to, subject, notification):#Sender is the sender email, to is the receiver email, subject is the email subject, and notification is the email body message. All the text is str object.SCOPES = '[https://mail.google.com/'](https://mail.google.com/')
    message = create_message(sender, to, subject, notification)
    creds = Noneif os.path.exists('token.pickle'):
        with open('token.pickle', 'rb') as token:
            creds = pickle.load(token)
        #We use login if no valid credentials
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow =   InstalledAppFlow.from_client_secrets_file('credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
            # Save the credentials for the next run
        with open('token.pickle', 'wb') as token:
            pickle.dump(creds, token)service = build('gmail', 'v1', credentials=creds)
    send_message(service, sender, message)

随着我们的通知功能准备就绪，我们可以尝试发送通知。例如，我会尝试学习下面的机器学习模型。

import seaborn as sns
import pandas as pd
from sklearn.linear_model import LinearRegression#Loading the dataset and only using the numerical variables
mpg = sns.load_dataset('mpg').drop(['origin', 'name'], axis = 1)
linear_model = LinearRegression()try:
    #Training the model
    linear_model.fit(mpg.drop('mpg', axis =1), mpg['mpg'])notification('test1[@gmail.com](mailto:cornelliusyudhaw@gmail.com)', 'test2[@gmail.com](mailto:cornelliusyudhaw@gmail.com)', 'Notification - Success Training', 'The model has finish')
except:
    notification('test1[@gmail.com](mailto:cornelliusyudhaw@gmail.com)', 'test2[@gmail.com](mailto:cornelliusyudhaw@gmail.com)', 'Notification - Failed Training', 'The model encountered error')

现在，当培训结束或他们遇到错误时，我会收到通知。我们用于训练的上述数据含有 NaN 值，所以这显然会导致误差。虽然，我的观点是，我们现在能够为我们的电子邮件创建通知系统。

结论

在本文中，我向您展示了如何使用 python 为您的电子邮件创建一个简单的通知系统。你可以随意修改这个系统。

如果您喜欢我的内容，并希望获得更多关于数据或数据科学家日常生活的深入知识，请考虑在此订阅我的简讯。

如果您没有订阅为中型会员，请考虑通过我的介绍订阅。

针对印度口音微调 Mozilla DeepSpeech

原文：https://towardsdatascience.com/automatic-speech-recognition-for-the-indian-accent-91bb011ad169?source=collection_archive---------9-----------------------

谷歌语音识别 API 的最佳开源替代品——现在是第二大英语国家！

张肯尼在 Unsplash 上拍照

让计算机识别语音的最初尝试之一是专注于识别数字！贝尔实验室在 1952 年设计了 奥黛丽系统 ，它可以识别单个语音说出的数字。从那以后，维基百科的这篇文章中详细记录了许多其他的实验。快进到今天，我们有最先进的自动语音识别引擎(ASR ),如苹果的 Siri、谷歌助手和亚马逊的 Alexa。

很长一段时间，谷歌的语音转文本 API (STT)是任何 ASR 任务事实上的选择。当像Mozilla deep speech这样的开源替代品在 2017 年末问世时，这种情况慢慢改变了。它基于百度的原始深度语音研究论文，并使用(大部分)美国英语数据集进行训练，导致对其他英语口音的泛化能力较差。

在最近的一次实习中，我不得不为一个视频会议平台集成一个 ASR 引擎，这个平台主要由印度人使用。我们更倾向于寻找开源替代方案，但是大多数通用方案在实时会议中表现不佳。就在那时，我看到了 DeepSpeech 和 IITM 的Indic TTS项目。

Indic 数据集包含超过 50 GB 的来自印度 13 个邦的说话者的语音样本。它由 10000 多个英语口语句子组成，既有男性也有女性母语者。这些文件可以在中找到。wav 格式连同相应的文本。

在本文中，我将向您展示使用 Indic 数据集对 DeepSpeech 进行微调的过程，但是您也可以轻松地对其他英语数据集进行微调。你可以在 IITM 网站上注册，向他们索取数据集。

先决条件:熟悉 ASR 引擎、语音处理，并对递归神经网络和张量流有基本的了解。

注意:我所有的训练和预处理都是在 Google Colab 上用 DeepSpeech 版本 0.7.4 完成的

预处理数据集

在你申请数据集后，IITM 会给你七天的时间访问他们的 Google Drive 链接。因为我长期需要这些数据，所以我把所有的 ZIP 文件都转移到了 Google Cloud Bucket 中。每个 ZIP 文件都会有一个包含的文件夹。wav 文件和对应的名为 txt.done.data 的元数据文件。

我们需要处理元数据文件，并为数据集生成培训/开发/测试分割。我们可以一次为一个州训练模型，或者将几个州分组，然后训练模型。下图显示了如何处理元数据。

作者图片

下面给出的 GitHub 要点包含了生成单个 CSV 文件的完整代码，我们稍后需要对其进行拆分。大部分代码都是不言自明的，有足够的注释。确保先安装好 Librosa 和 num2words 。

执行脚本时， wav 参数指向包含所有音频文件的文件夹，而 meta 参数指向包含 txt.done.data 文件的文件夹。这里，第一部分将数据从 Google Bucket 复制到 Colab。第二部分创建一个 CSV 文件，最后一个命令追加到这个 CSV 文件中，依此类推。如果您想单独训练每个 ZIP 文件，只运行一个命令并继续分割 CSV(尽管我不建议这样做)。如果附加到同一个文件，小心注释掉第 45 行。

$ gsutil cp gs://bucket-name/hindi_female_english.zip /content/hindi_female_english.zip
$ gsutil cp gs://bucket-name/hindi_male_english.zip /content/hindi_male_english.zip$ unzip hindi_female_english.zip -d /content/hindi_female_english
$ unzip hindi_male_english.zip -d /content/hindi_male_english--------------------------------------------------------------------$ python preProcess.py --wav /content/hindi_female_english/english/wav --meta /content/hindi_female_english/english$ python preProcess.py --wav /content/hindi_male_english/english/wav --meta /content/hindi_male_english/english

现在，我们有一个 CSV 文件，需要将它分成三个单独的文件。在左边的要点中，我们首先将主 CSV 文件分割成序列和中间，然后将中间分割成开发和测试。然后我们最终有了三个文件，对应于 DeepSpeech 训练所需的三个拆分。

微调深度演讲

这里给出了官方培训文档。它非常详细，但跳过了一些可能会让你沮丧很长时间的细节😩。我假设您已经将数据集传输到 Google Cloud bucket，并且有适当的互联网连接，因为如果您不快速重新连接，Colab 会终止您的实例。以下所有步骤均摘自 Colab 上的 培训笔记本 此处 。

  1. 授权 Colab 访问您的 Google Cloud Bucket: 下载您项目的 IAM 访问凭证文件并上传到 Colab。
import os
from google.colab import authauth.authenticate_user()os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "creds.json"#ensure the path is set correctly
!echo $GOOGLE_APPLICATION_CREDENTIALSproject_id = '<gcloud-project-id>'
bucket_name = 'gs://<bucket-name>'
!gcloud config set project {project_id}

2。从 GitHub: 克隆 DeepSpeech v0.7.4，下载相应的检查点。

!git clone --branch v0.7.4 [https://github.com/mozilla/DeepSpeech](https://github.com/mozilla/DeepSpeech)!wget [https://github.com/mozilla/DeepSpeech/releases/download/v0.7.4/deepspeech-0.7.4-checkpoint.tar.gz](https://github.com/mozilla/DeepSpeech/releases/download/v0.7.4/deepspeech-0.7.4-checkpoint.tar.gz)!tar -xvf deepspeech-0.7.4-checkpoint.tar.gz -C \
/content/model_checkpoints/

****3。安装 DeepSpeech 依赖项:每次训练模型时，我们都需要安装很多东西。详细步骤在笔记本这里给出。

****4。设置默认的 CUDA 版本:如果你第一次没有做好，这部分将会非常令人沮丧😤。出于某种原因，每当你试图在 Colab 中设置默认的 CUDA 版本为 10.0 (DeepSpeech 需要 CUDA 10.0 和 CuDNN v7.6)，它总是试图恢复到 10.1🤷。我发现了一系列看似有效的步骤，但我不能保证每次都有效——你可能需要挖掘一点点，才能找到正确的方法。详细步骤在笔记本这里给出。如果你仍然不能让它工作，我会非常乐意帮助:)

5。安装 TensorFlow-GPU:

!pip3 uninstall tensorflow
!pip3 install 'tensorflow-gpu==1.15.2'

6。将数据从 Google Bucket 复制到 Colab:这里需要小心，将文件复制到您生成 CSV 文件时的位置，因为模型使用 CSV 文件中声明的音频文件的绝对路径。

%cd /content/!gsutil cp gs://bucket-name/hindi_female_english.zip /content/hindi_female_english.zip
!gsutil cp gs://bucket-name/hindi_male_english.zip /content/hindi_male_english.zip!unzip hindi_female_english.zip -d /content/hindi_female_english
!unzip hindi_male_english.zip -d /content/hindi_male_english

7。检查不在 alphabet.txt : 中的额外字符这个文件(存在于 /DeepSpeech/data 中)定义了 DeepSpeech 正在被训练的语言的字母表。因为我们的任务语言是一样的，我们不需要改变它。如果我们想用一种完全不同的语言训练一个新的模型，我们需要重新定义字母表并遵循这些步骤。将三个 CSV 文件上传到 /content/ 并对其运行 check_parameters.py 。

!python3 /content/DeepSpeech/training/deepspeech_training/util/check_characters.py -csv /content/train.csv -alpha!python3 /content/DeepSpeech/training/deepspeech_training/util/check_characters.py -csv /content/dev.csv -alpha!python3 /content/DeepSpeech/training/deepspeech_training/util/check_characters.py -csv /content/test.csv -alpha

****注意:您可能需要注释掉check_characters.py中的一些行才能让它工作。在注释掉一些行之后，这个文件中的第 44 行应该是这样的

if not args.disable_unicode_variants:
  unicode_transcript = unicodedata.normalize("NFKC", row[2])
  #if row[2] != unicode_transcript:
    #print("Your input file", in_file, "contains at least one transript with unicode chars on more than one code-point: '{}'. Consider using NFKC normalization: unicodedata.normalize('NFKC', str).".format(row[2]))
    #sys.exit(-1)
all_text |= set(row[2])

8.训练模型(最后😌):这一步非常简单。尝试不同的超参数，并仔细检查路径。增强参数可以帮助您的模型更好地进行概化。

9.导出模型进行推理:训练过程完成后，a 。pb 模型文件被导出到 export_dir 。但是这个模型非常大(~700MB)，并且对于批量预测不是非常有效。幸运的是，有一个选项可以将导出的模型转换成内存映射模型，之后我们会得到一个。pbmm 模型文件。

%cd /content/DeepSpeech/!python3 util/taskcluster.py --source tensorflow --artifact convert_graphdef_memmapped_format --branch r1.15 --target .!./convert_graphdef_memmapped_format --in_graph=/content/models/ft_model.pb --out_graph=/content/models/ft_model.pbmm

这个。pbmm 文件相对较小(~180MB)且高效，可与相应的划线器文件一起使用，以改善推断结果。

结论

唷！那篇文章很长😵。如果您已经到达这里，感谢您的坚持:)

在我使用 DeepSpeech 的过程中，我发现它是 ASR 最容易使用的库之一。我希望这篇文章能帮助任何自己尝试的人。

你可以通过 LinkedIn 、 GitHub 联系我

** [## 使用 Mozilla DeepSpeech 自动生成字幕

对于那些嘴里薯条的噪音让你无法看电影的时候:)

towardsdatascience.com](/generating-subtitles-automatically-using-mozilla-deepspeech-562c633936a7)**

用 Python 进行语音识别

原文：https://towardsdatascience.com/automatic-speech-recognition-in-python-programs-a64851ad29b3?source=collection_archive---------18-----------------------

图片来自俚语实验室

语音识别

比较 9 个最突出的选择。

语音识别技术在过去的几年里发展迅速，并且正在从科学领域过渡到工程领域。随着 Alexa、Siri 和 Google Assistant 等语音助手的日益流行，一些应用程序(例如， YouTube 、加纳王国、 Paytm Travel 、 My Jio )开始拥有语音控制的功能。在 Slang Labs，我们正在为程序员构建一个平台，让他们能够轻松地用语音体验来增强现有的应用程序。

自动语音识别(ASR)是处理语音的必要的第一步。在 ASR 中，对麦克风说出的音频文件或语音经过处理并转换为文本，因此也称为语音到文本(STT)。然后，该文本被馈送到自然语言处理/理解(NLP/NLU)以理解和提取关键信息(例如意图、情感)，然后采取适当的行动。ASR 也有独立的应用，例如记录口述，或为视频制作实时字幕。

我们对 ASR 和 NLU 感兴趣，尤其是它们在应用程序中语音到动作循环的功效。我们的 Android 和 Web SDK提供了从应用程序员的角度来看合适的简单 API，而俚语平台则处理将 ASR、NLU 和文本到语音(TTS)缝合在一起的复杂性负担。但是，很自然地，我们对 ASR、NLU 和 TTS 的技术状态感到好奇，尽管我们没有将我们技术堆栈的这些部分作为单独的 SaaS 产品来展示。对现有 ASR 解决方案的探索就是这种好奇心的结果。

服务与软件

有两种可能性:在云上调用语音转文本 SaaS，或者在应用程序中托管一个 ASR 软件包。

服务是最容易开始的方式。你必须报名参加 SaaS 并获得钥匙/证书。然后，您就可以在代码中使用它了，或者通过 HTTP 端点，或者通过您选择的编程语言中的库。然而，对于合理的大量使用，它通常花费更多的钱。

软件软件包在您托管它时为您提供完全的控制，还可以为您的应用创建更小的模型，并将其部署在设备/边缘上，而无需网络连接。但训练和部署模型需要专业知识和前期努力。

使用语音云服务与自托管 ASR 软件包的权衡

这是一个可逆的选择。例如，您可以从云服务开始，如果需要，迁移到您自己的软件包部署；反之亦然。您可以设计您的代码来限制这种反转的爆炸半径，以及在您迁移到另一个 SaaS 或软件包的情况下。

批处理与流式

您需要确定您的应用程序需要批处理 ASR 还是流式 ASR。

批处理:如果你有需要离线转录的录音，那么批处理就足够了，而且更经济。在 batch API 中，音频文件作为参数传递，语音到文本的转换一次性完成。

流媒体:如果你需要实时处理语音(比如声控应用，视频字幕)，你就需要一个流媒体 API。在流式 API 的情况下，使用音频缓冲区的可用块重复调用它。它可能会发送临时结果，但最终结果在最后才可用。

所有的服务和软件包都有批处理 API，但是目前有些缺少流式 API。因此，如果你有一个流媒体应用程序，这消除了一些选择。

Python 的选择

大多数语音服务提供流行编程语言的库。在最坏的情况下，您总是可以使用 HTTP 端点。对于语音包来说也是如此，这些包带有各种编程语言的绑定。在最坏的情况下，您可以自己创建绑定。所以使用 Python 没有任何约束。

我为本文选择 Python，因为大多数语音云服务和 ASR 软件包都有 Python 库。此外，你可以在浏览器中使用它的同伴 Colab notebook 运行文章的代码片段，而不需要在你的计算机上安装任何东西。

一个常见的用例是从麦克风收集音频，并将缓冲区(批处理或流)传递给语音识别 API。不变的是，在这样的转录器中，麦克风是通过 PyAudio 访问的，这是通过 PortAudio 实现的。但是由于麦克风在 Colab 上不可用，我们将其简化。我们将使用一个完整的音频文件来检查批处理 API。对于流式 API，我们将把一个音频文件分成块并模拟流。

如何最好地利用文章的其余部分

涵盖以下服务和软件包。

服务:

  1. 谷歌语音转文本
  2. 微软 Azure 语音
  3. IBM Watson 语音测试
  4. 亚马逊转录
  5. 细微差别

软件:

  1. CMU 狮身人面像
  2. Mozilla DeepSpeech
  3. 卡尔迪
  4. 脸书 wav2 字母

由于某些特性或限制(在各自的章节中列出)，没有为 Amazon Transcribe、Nuance、Kaldi 和脸书 wav2letter 提供代码示例。相反，给出了代码示例和资源的链接。

下一节有常见的实用函数和测试用例。最后一节介绍了 Python SpeechRecognition包，它提供了对几个服务和软件包的批处理 API 的抽象。

如果你想对所有的服务和软件包有一个总体的了解，那么请打开 Colab ，在你阅读这篇文章的时候执行代码。如果您只对特定的服务或套餐感兴趣，请直接跳到该部分。但是不管是哪种情况，都要使用 Colab 中的代码来更好地探索它。

让我们深入研究代码。

通用设置

下载我们将用于测试语音识别服务和软件包的音频文件:

$ curl -LO https://github.com/mozilla/DeepSpeech/releases/download/v0.6.0/audio-0.6.0.tar.gz

$ tar -xvzf audio-0.6.0.tar.gz

$ ls -l ./audio/

它有三个音频文件。用需要的元数据定义测试用例:

TESTCASES **=** [
  {
    'filename': 'audio/2830-3980-0043.wav',
    'text': 'experience proves this',
    'encoding': 'LINEAR16',
    'lang': 'en-US'
  },
  {
    'filename': 'audio/4507-16021-0012.wav',
    'text': 'why should one halt on the way',
    'encoding': 'LINEAR16',
    'lang': 'en-US'
  },
  {
    'filename': 'audio/8455-210777-0068.wav',
    'text': 'your power is sufficient i said',
    'encoding': 'LINEAR16',
    'lang': 'en-US'
  }
]

另外，写一些实用函数。read_wav_file()获取音频文件的路径，并返回缓冲字节和采样率:

**def** **read_wav_file**(filename) **->** Tuple[bytes, int]:
    **with** wave**.**open(filename, 'rb') **as** w:
        rate **=** w**.**getframerate()
        frames **=** w**.**getnframes()
        buffer **=** w**.**readframes(frames)

    **return** buffer, rate

simulate_stream()对于模拟 steam 来尝试流式 API 很有用。通常，会有一个类似麦克风的音频源。每隔一段时间，麦克风将生成一个语音块，该语音块必须传递给流 API。simulate_stream()函数有助于避免所有的复杂性，并专注于 API。它需要一个音频缓冲区和批处理大小，生成该大小的块。请注意下面的yield buf语句:

def simulate_stream(buffer: bytes, batch_size: int = 4096):
    buffer_len = len(buffer)
    offset = 0
    while offset < buffer_len:
        end_offset = offset + batch_size
        buf = buffer[offset:end_offset]
        yield buf
        offset = end_offset

谷歌语音转文本

谷歌将语音转文本作为谷歌云服务之一。它有 C#、Go、Java、JavaScript、PHP、Python 和 Ruby 的库。它支持批处理和流模式。

设置

你将需要你的谷歌云证书。您需要设置指向 cred 文件的环境变量GOOGLE_APPLICATION_CREDENTIALS:

$ export GOOGLE_APPLICATION_CREDENTIALS**=**'/path/to/google/cloud/cred/file/gc-creds.json'
$ ls -l $GOOGLE_APPLICATION_CREDENTIALS

批处理 API

使用批量语音转文本 API 很简单。您需要创建一个SpeechClient，创建一个带有音频元数据的config，并调用语音客户端的recognize()方法。

**from** google.cloud **import** speech_v1
**from** google.cloud.speech_v1 **import** enums

**def** **google_batch_stt**(filename: str, lang: str, encoding: str) **->** str:
    buffer, rate **=** read_wav_file(filename)
    client **=** speech_v1**.**SpeechClient()

    config **=** {
        'language_code': lang,
        'sample_rate_hertz': rate,
        'encoding': enums**.**RecognitionConfig**.**AudioEncoding[encoding]
    }

    audio **=** {
        'content': buffer
    }

    response **=** client**.**recognize(config, audio)
    *# For bigger audio file, replace previous line with following:
*    *# operation = client.long_running_recognize(config, audio)
*    *# response = operation.result()* 
    **for** result **in** response**.**results:
        *# First alternative is the most probable result
*        alternative **=** result**.**alternatives[0]
        **return** alternative**.**transcript

*# Run tests* **for** t **in** TESTCASES:
    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        t['filename'], t['text']
    ))
    **print**('google-cloud-batch-stt: "{}"'**.**format(
        google_batch_stt(t['filename'], t['lang'], t['encoding'])
    ))

当您运行它时，您将在输出中看到每个音频测试文件的文本:

audio file="audio/2830-3980-0043.wav"    expected text="experience proves this"
google-cloud-batch-stt: "experience proves this"

audio file="audio/4507-16021-0012.wav"    expected text="why should one halt on the way"
google-cloud-batch-stt: "why should one halt on the way"

audio file="audio/8455-210777-0068.wav"    expected text="your power is sufficient i said"
google-cloud-batch-stt: "your power is sufficient I said"

流式 API

谷歌的流媒体 API 也相当简单。为了处理音频流，您可以使用可用的音频块重复调用流 API，它将返回临时结果:

**from** google.cloud **import** speech
**from** google.cloud.speech **import** enums
**from** google.cloud.speech **import** types

**def** **response_stream_processor**(responses):
    **print**('interim results: ')

    transcript **=** ''
    num_chars_printed **=** 0
    **for** response **in** responses:
        **if** **not** response**.**results:
            **continue**

        result **=** response**.**results[0]
        **if** **not** result**.**alternatives:
            **continue**

        transcript **=** result**.**alternatives[0]**.**transcript
        **print**('{0}final: {1}'**.**format(
            '' **if** result**.**is_final **else** 'not ',
            transcript
        ))

    **return** transcript

**def** **google_streaming_stt**(filename: str, lang: str, encoding: str) **->** str:
    buffer, rate **=** read_wav_file(filename)

    client **=** speech**.**SpeechClient()

    config **=** types**.**RecognitionConfig(
        encoding**=**enums**.**RecognitionConfig**.**AudioEncoding[encoding],
        sample_rate_hertz**=**rate,
        language_code**=**lang
    )

    streaming_config **=** types**.**StreamingRecognitionConfig(
        config**=**config,
        interim_results**=**True
    )

    audio_generator **=** simulate_stream(buffer)  *# chunk generator
*    requests **=** (
        types**.**StreamingRecognizeRequest(audio_content**=**chunk)
        **for** chunk **in** audio_generator
    )
    responses **=** client**.**streaming_recognize(
        streaming_config, requests
    )
    *# Now, put the transcription responses to use.
*    **return** response_stream_processor(responses)

*# Run tests* **for** t **in** TESTCASES:
    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        t['filename'], t['text']
    ))
    **print**('google-cloud-streaming-stt: "{}"'**.**format(
        google_streaming_stt(
            t['filename'], t['lang'], t['encoding']
        )
    ))

在输出中，您可以看到随着输入更多音频，效果会有所改善:

audio file="audio/2830-3980-0043.wav"    expected text="experience proves this"
interim results: 
not final: next
not final: iSpy
not final: Aspira
not final: Xperia
not final: Experian
not final: experience
not final: experience proved
not final: experience proves
not final: experience proves the
not final: experience proves that
not final: experience
final: experience proves this
google-cloud-streaming-stt: "experience proves this"

微软 Azure 语音

微软 Azure 认知服务是一个 AI 服务和认知 API 的家族。语音服务包括语音转文本，文本转语音，语音翻译服务。

设置

安装 Azure 语音包:

$ pip3 install azure-cognitiveservices-speech

您可以在 Microsoft Azure portal 上启用语音服务并查找您帐户的凭据。你可以在这里开一个免费账户。服务凭据:

AZURE_SPEECH_KEY **=** 'YOUR AZURE SPEECH KEY'
AZURE_SERVICE_REGION **=** 'YOUR AZURE SERVICE REGION'

批处理 API

Azure 的批处理 API 也很简单。它接受一个配置和音频输入，并返回文本:

**import** azure.cognitiveservices.speech **as** speechsdk

**def** **azure_batch_stt**(filename: str, lang: str, encoding: str) **->** str:
    speech_config **=** speechsdk**.**SpeechConfig(
        subscription**=**AZURE_SPEECH_KEY,
        region**=**AZURE_SERVICE_REGION
    )
    audio_input **=** speechsdk**.**AudioConfig(filename**=**filename)
    speech_recognizer **=** speechsdk**.**SpeechRecognizer(
        speech_config**=**speech_config,
        audio_config**=**audio_input
    )
    result **=** speech_recognizer**.**recognize_once()

    **return** result**.**text **if** result**.**reason **==** speechsdk**.**ResultReason**.**RecognizedSpeech **else** None

*# Run tests* **for** t **in** TESTCASES:
    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        t['filename'], t['text']
    ))
    **print**('azure-batch-stt: "{}"'**.**format(
        azure_batch_stt(t['filename'], t['lang'], t['encoding'])
    ))

输出将如下所示:

audio file="audio/2830-3980-0043.wav"    expected text="experience proves this"
azure-batch-stt: "Experience proves this."

audio file="audio/4507-16021-0012.wav"    expected text="why should one halt on the way"
azure-batch-stt: "Whi should one halt on the way."

audio file="audio/8455-210777-0068.wav"    expected text="your power is sufficient i said"
azure-batch-stt: "Your power is sufficient I said."

流式 API

Azure 有几种流 API。通过创建不同类型的音频源，人们可以推送音频块，或者向 Azure 传递回调来拉取音频块。它触发几种类型的语音识别事件来连接回调。以下是如何将推送音频流与音频流发生器连接起来:

**import** time
**import** azure.cognitiveservices.speech **as** speechsdk

**def** **azure_streaming_stt**(filename: str, lang: str, encoding: str) **->** str:
    speech_config **=** speechsdk**.**SpeechConfig(
        subscription**=**AZURE_SPEECH_KEY,
        region**=**AZURE_SERVICE_REGION
    )
    stream **=** speechsdk**.**audio**.**PushAudioInputStream()
    audio_config **=** speechsdk**.**audio**.**AudioConfig(stream**=**stream)
    speech_recognizer **=** speechsdk**.**SpeechRecognizer(
        speech_config**=**speech_config,
        audio_config**=**audio_config
    )

    *# Connect callbacks to the events fired by the speech recognizer
*    speech_recognizer**.**recognizing**.**connect(
        **lambda** evt: **print**('interim text: "{}"'**.**format(
            evt**.**result**.**text
        ))
    )
    speech_recognizer**.**recognized**.**connect(
        **lambda** evt:  **print**('azure-streaming-stt: "{}"'**.**format(
            evt**.**result**.**text
        ))
    )

    *# start continuous speech recognition
*    speech_recognizer**.**start_continuous_recognition()

    *# push buffer chunks to stream
*    buffer, rate **=** read_wav_file(filename)
    audio_generator **=** simulate_stream(buffer)
    **for** chunk **in** audio_generator:
      stream**.**write(chunk)
      time**.**sleep(0.1)  *# to give callback a chance against fast loop* 
    *# stop continuous speech recognition
*    stream**.**close()
    time**.**sleep(0.5)  *# give chance to VAD to kick in
*    speech_recognizer**.**stop_continuous_recognition()
    time**.**sleep(0.5)  *# Let all callback run* 
*# Run tests* **for** t **in** TESTCASES:
    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        t['filename'], t['text']
    ))
    azure_streaming_stt(t['filename'], t['lang'], t['encoding'])

第一个测试用例的输出如下所示:

audio file="audio/2830-3980-0043.wav"    expected text="experience proves this"
interim text: "experience"
interim text: "experienced"
interim text: "experience"
interim text: "experience proves"
interim text: "experience proves this"
azure-streaming-stt: "Experience proves this."

IBM Watson 语音转文本

IBM Watson 语音转文本是一项 ASR 服务。NET，Go，JavaScript， Python ，Ruby，Swift，Unity API 库，还有 HTTP 端点。它有丰富的文档。

设置

您需要注册/登录，获取 API 密钥凭证和服务 URL，并填写在下面。

批处理 API

可以预见，批处理 API 非常简单:

**import** os

**from** ibm_watson **import** SpeechToTextV1
**from** ibm_cloud_sdk_core.authenticators **import** IAMAuthenticator

**def** **watson_batch_stt**(filename: str, lang: str, encoding: str) **->** str:
    authenticator **=** IAMAuthenticator(WATSON_API_KEY)
    speech_to_text **=** SpeechToTextV1(authenticator**=**authenticator)
    speech_to_text**.**set_service_url(WATSON_STT_URL)

    **with** open(filename, 'rb') **as** audio_file:
        response **=** speech_to_text**.**recognize(
            audio**=**audio_file,
            content_type**=**'audio/{}'**.**format(
                os**.**path**.**splitext(filename)[1][1:]
            ),
            model**=**lang **+** '_BroadbandModel',
            max_alternatives**=**3,
        )**.**get_result()

    **return** response['results'][0]['alternatives'][0]['transcript']

*# Run tests* **for** t **in** TESTCASES:
    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        t['filename'], t['text']
    ))
    **print**('watson-batch-stt: "{}"'**.**format(
        watson_batch_stt(t['filename'], t['lang'], t['encoding'])
    ))

以下是输出:

audio file="audio/2830-3980-0043.wav"    expected text="experience proves this"
watson-batch-stt: "experience proves this "

audio file="audio/4507-16021-0012.wav"    expected text="why should one halt on the way"
watson-batch-stt: "why should one hold on the way "

audio file="audio/8455-210777-0068.wav"    expected text="your power is sufficient i said"
watson-batch-stt: "your power is sufficient I set "

流式 API

Watson 的流媒体 API 在 WebSocket 上工作，只需要一点点工作就可以设置好。它具有以下步骤:

  • 创建一个用于接收语音识别通知和结果的RecognizeCallback对象。
  • 创建缓冲队列。麦克风(或流模拟器)产生的音频块应该写入该队列，Watson 读取并使用这些块。
  • 启动一个执行语音识别(以及 WebSocket 通信)的线程。
  • 启动麦克风或语音模拟器，开始产生音频块
  • 完成后，加入语音识别线程(即，等待它完成)。
**import** json
**import** logging
**import** os
**from** queue **import** Queue
**from** threading **import** Thread
**import** time

**from** ibm_watson **import** SpeechToTextV1
**from** ibm_watson.websocket **import** RecognizeCallback, AudioSource
**from** ibm_cloud_sdk_core.authenticators **import** IAMAuthenticator

*# Watson websocket prints justs too many debug logs, so disable it* logging**.**disable(logging**.**CRITICAL)

*# Chunk and buffer size* CHUNK_SIZE **=** 4096
BUFFER_MAX_ELEMENT **=** 10

*# A callback class to process various streaming STT events* **class** **MyRecognizeCallback**(RecognizeCallback):
    **def** **__init__**(self):
        RecognizeCallback**.**__init__(self)
        self**.**transcript **=** None

    **def** **on_transcription**(self, transcript):
        *# print('transcript: {}'.format(transcript))
*        **pass**

    **def** **on_connected**(self):
        *# print('Connection was successful')
*        **pass**

    **def** **on_error**(self, error):
        *# print('Error received: {}'.format(error))
*        **pass**

    **def** **on_inactivity_timeout**(self, error):
        *# print('Inactivity timeout: {}'.format(error))
*        **pass**

    **def** **on_listening**(self):
        *# print('Service is listening')
*        **pass**

    **def** **on_hypothesis**(self, hypothesis):
        *# print('hypothesis: {}'.format(hypothesis))
*        **pass**

    **def** **on_data**(self, data):
        self**.**transcript **=** data['results'][0]['alternatives'][0]['transcript']
        **print**('{0}final: {1}'**.**format(
            '' **if** data['results'][0]['final'] **else** 'not ',
            self**.**transcript
        ))

    **def** **on_close**(self):
        *# print("Connection closed")
*        **pass**

**def** **watson_streaming_stt**(filename: str, lang: str, encoding: str) **->** str:
    authenticator **=** IAMAuthenticator(WATSON_API_KEY)
    speech_to_text **=** SpeechToTextV1(authenticator**=**authenticator)
    speech_to_text**.**set_service_url(WATSON_STT_URL)

    *# Make watson audio source fed by a buffer queue
*    buffer_queue **=** Queue(maxsize**=**BUFFER_MAX_ELEMENT)
    audio_source **=** AudioSource(buffer_queue, True, True)

    *# Callback object
*    mycallback **=** MyRecognizeCallback()

    *# Read the file
*    buffer, rate **=** read_wav_file(filename)

    *# Start Speech-to-Text recognition thread
*    stt_stream_thread **=** Thread(
        target**=**speech_to_text**.**recognize_using_websocket,
        kwargs**=**{
            'audio': audio_source,
            'content_type': 'audio/l16; rate={}'**.**format(rate),
            'recognize_callback': mycallback,
            'interim_results': True
        }
    )
    stt_stream_thread**.**start()

    *# Simulation audio stream by breaking file into chunks and filling buffer queue
*    audio_generator **=** simulate_stream(buffer, CHUNK_SIZE)
    **for** chunk **in** audio_generator:
        buffer_queue**.**put(chunk)
        time**.**sleep(0.5)  *# give a chance to callback* 
    *# Close the audio feed and wait for STTT thread to complete
*    audio_source**.**completed_recording()
    stt_stream_thread**.**join()

    *# send final result
*    **return** mycallback**.**transcript

*# Run tests* **for** t **in** TESTCASES:
    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        t['filename'], t['text']
    ))
    **print**('watson-cloud-streaming-stt: "{}"'**.**format(
        watson_streaming_stt(t['filename'], t['lang'], t['encoding'])
    ))

产出:

audio file="audio/2830-3980-0043.wav"    expected text="experience proves this"
not final: X. 
not final: experts 
not final: experience 
not final: experienced 
not final: experience prove 
not final: experience proves 
not final: experience proves that 
not final: experience proves this 
final: experience proves this 
watson-cloud-streaming-stt: "experience proves this "

亚马逊转录

Amazon transcript是一个语音转文本 AWS 云服务，拥有 C#、Go、Java、JavaScript、PHP、Python 和 Ruby 的库。它有一个批处理语音转文本 API(也可以作为命令行使用)，但是它要求音频文件要么在 S3 桶中，要么可以通过 HTTP 获得。它在 WebSocket 和 HTTP/2 上也有一个流媒体 API。这里有一个使用 AWS Java SDK 的示例，但是没有 Python 绑定(当然可以使用 Python 套接字库，但是需要进入低级事件流编码)。

Amazon Transcribe Python APIs 目前不支持本文中涉及的用例，因此这里不包括代码示例。

细微差别

Nuance 很可能是最古老的商业语音识别产品，甚至是为各种领域和行业定制的。他们确实有语音识别服务的 Python 绑定。这里是他们 GitHub repo 中的一个代码样本。

我想不出创建开发者账户的方法。我希望有一种方法可以获得类似于其他产品的有限期限的免费试用信用，并获得访问服务所需的凭据。

CMU 狮身人面像

CMUSphinx 已经存在了相当一段时间，并且一直在适应 ASR 技术的进步。 PocketSphinx 是一个语音转文本解码器 Python 包。

设置

首先安装 swig 。在 macOS 上，您可以使用brew进行安装:

$ brew install swig
$ swig -version

在 Linux 上，可以使用apt-get:

$ apt-get install -y swig libpulse-dev
$ swig -version

然后使用 pip 安装pocketsphinx:

$ pip3 install pocketsphinx
$ pip3 list | grep pocketsphinx

创建解码器对象

无论您使用批处理还是流式 API，您都需要一个解码器对象:

**import** pocketsphinx
**import** os

MODELDIR **=** os**.**path**.**join(os**.**path**.**dirname(pocketsphinx**.**__file__), 'model')

config **=** pocketsphinx**.**Decoder**.**default_config()
config**.**set_string('-hmm', os**.**path**.**join(MODELDIR, 'en-us'))
config**.**set_string('-lm', os**.**path**.**join(MODELDIR, 'en-us.lm.bin'))
config**.**set_string('-dict', os**.**path**.**join(MODELDIR, 'cmudict-en-us.dict'))

decoder **=** pocketsphinx**.**Decoder(config)

批处理 API

批处理 API 非常简单，只有几行代码:

**def** **sphinx_batch_stt**(filename: str, lang: str, encoding: str) **->** str:
    buffer, rate **=** read_wav_file(filename)
    decoder**.**start_utt()
    decoder**.**process_raw(buffer, False, False)
    decoder**.**end_utt()
    hypothesis **=** decoder**.**hyp()
    **return** hypothesis**.**hypstr

*# Run tests* **for** t **in** TESTCASES:
    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        t['filename'], t['text'])
    )
    **print**('sphinx-batch-stt: "{}"'**.**format(
        sphinx_batch_stt(t['filename'], t['lang'], t['encoding'])
    ))

您将看到现在熟悉的输出:

audio file="audio/2830-3980-0043.wav"    expected text="experience proves this"
sphinx-batch-stt: "experience proves this"

audio file="audio/4507-16021-0012.wav"    expected text="why should one halt on the way"
sphinx-batch-stt: "why should one hold on the way"

audio file="audio/8455-210777-0068.wav"    expected text="your power is sufficient i said"
sphinx-batch-stt: "your paris sufficient i said"

注意抄写中的错误。随着更多的训练数据，它通常会改善。

流式 API

流式 API 也非常简单，但是没有挂钩来获得中间结果:

**def** **sphinx_streaming_stt**(filename: str, lang: str, encoding: str) **->** str:
    buffer, rate **=** read_wav_file(filename)
    audio_generator **=** simulate_stream(buffer)

    decoder**.**start_utt()
    **for** chunk **in** audio_generator:
        decoder**.**process_raw(chunk, False, False)
    decoder**.**end_utt()

    hypothesis **=** decoder**.**hyp()
    **return** hypothesis**.**hypstr

*# Run tests* **for** t **in** TESTCASES:
    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        t['filename'], t['text']
    ))
    **print**('sphinx-streaming-stt: "{}"'**.**format(
        sphinx_streaming_stt(t['filename'], t['lang'], t['encoding'])
    ))

Mozilla DeepSpeech

Mozilla 在 2019 年 12 月发布了 DeepSpeech 0.6 软件包，用 C、Java、.NET、 Python 和 JavaScript，包括支持在 edge 设备上使用 TensorFlow Lite 模型。

设置

您可以使用 pip 安装 DeepSpeech(如果您想在 Colab 运行时或您的机器上使用 GPU，请使用它deepspeech-gpu==0.6.0):

$ pip install deepspeech**==**0.6.0

下载并解压缩模型(这需要一段时间):

$ curl -LO https://github.com/mozilla/DeepSpeech/releases/download/v0.6.0/deepspeech-0.6.0-models.tar.gz
$ tar -xvzf deepspeech-0.6.0-models.tar.gz
$ ls -l ./deepspeech-0.6.0-models/

测试它是否一切正常。检查最后三个命令的输出，您将分别看到结果【经验证明少】【为什么要中途停顿】【我说你的动力够用了】。你都准备好了。

$ deepspeech --model deepspeech-0.6.0-models/output_graph.pb --lm deepspeech-0.6.0-models/lm.binary --trie ./deepspeech-0.6.0-models/trie --audio ./audio/2830-3980-0043.wav

$ deepspeech --model deepspeech-0.6.0-models/output_graph.pb --lm deepspeech-0.6.0-models/lm.binary --trie ./deepspeech-0.6.0-models/trie --audio ./audio/4507-16021-0012.wav

$ deepspeech --model deepspeech-0.6.0-models/output_graph.pb --lm deepspeech-0.6.0-models/lm.binary --trie ./deepspeech-0.6.0-models/trie --audio ./audio/8455-210777-0068.wav

创建模型对象

第一步是读取模型文件并创建一个 DeepSpeech 模型对象。

**import** deepspeech

model_file_path **=** 'deepspeech-0.6.0-models/output_graph.pbmm'
beam_width **=** 500
model **=** deepspeech**.**Model(model_file_path, beam_width)

*# Add language model for better accuracy* lm_file_path **=** 'deepspeech-0.6.0-models/lm.binary'
trie_file_path **=** 'deepspeech-0.6.0-models/trie'
lm_alpha **=** 0.75
lm_beta **=** 1.85
model**.**enableDecoderWithLM(lm_file_path, trie_file_path, lm_alpha, lm_beta)

批处理 API

批量语音转文本只需要几行代码:

**import** numpy **as** np

**def** **deepspeech_batch_stt**(filename: str, lang: str, encoding: str) **->** str:
    buffer, rate **=** read_wav_file(filename)
    data16 **=** np**.**frombuffer(buffer, dtype**=**np**.**int16)
    **return** model**.**stt(data16)

*# Run tests* **for** t **in** TESTCASES:
    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        t['filename'], t['text']
    ))
    **print**('deepspeech-batch-stt: "{}"'**.**format(
        deepspeech_batch_stt(t['filename'], t['lang'], t['encoding'])
    ))

输出:

audio file="audio/2830-3980-0043.wav"    expected text="experience proves this"
deepspeech-batch-stt: "experience proof less"

audio file="audio/4507-16021-0012.wav"    expected text="why should one halt on the way"
deepspeech-batch-stt: "why should one halt on the way"

audio file="audio/8455-210777-0068.wav"    expected text="your power is sufficient i said"
deepspeech-batch-stt: "your power is sufficient i said"

流式 API

DeepSpeech streaming API 需要创建一个流上下文，并重复使用它来提供音频块:

**def** **deepspeech_streaming_stt**(filename: str, lang: str, encoding: str) **->** str:
    buffer, rate **=** read_wav_file(filename)
    audio_generator **=** simulate_stream(buffer)

    *# Create stream
*    context **=** model**.**createStream()

    text **=** ''
    **for** chunk **in** audio_generator:
        data16 **=** np**.**frombuffer(chunk, dtype**=**np**.**int16)
        *# feed stream of chunks
*        model**.**feedAudioContent(context, data16)
        interim_text **=** model**.**intermediateDecode(context)
        **if** interim_text **!=** text:
            text **=** interim_text
            **print**('inetrim text: {}'**.**format(text))

    *# get final resut and close stream
*    text **=** model**.**finishStream(context)
    **return** text

*# Run tests* **for** t **in** TESTCASES:
    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        t['filename'], t['text']
    ))
    **print**('deepspeech-streaming-stt: "{}"'**.**format(
        deepspeech_streaming_stt(t['filename'], t['lang'], t['encoding'])
    ))

DeepSpeech 返回中期结果:

audio file="audio/2830-3980-0043.wav"    expected text="experience proves this"
inetrim text: i
inetrim text: e
inetrim text: experi en
inetrim text: experience pro
inetrim text: experience proof les
deepspeech-streaming-stt: "experience proof less"

卡尔迪

卡尔迪是一个在研究社区中非常流行的语音识别工具包。它旨在试验不同的研究理念和可能性。它有各种可能的技术和备选方案的丰富集合。与代码实验室中讨论的其他替代方案相比，学习曲线更加陡峭。

PyKaldi 提供 Python 绑定。请务必看一下他们的 GitHub repo 的自述文件。

没有预构建的 PyPI 即用包，您必须从源代码或 Conda 构建它。这两种选择都不适合 Colab 环境。

脸书 wav2 字母

脸书于 2020 年 1 月发布了 wav2letter@anywhere 。它拥有一个完全卷积的(CNN)声学模型，而不是其他解决方案使用的递归神经网络(RNN)。它非常有前途，包括用于边缘设备。它为其推理框架提供了 Python 绑定。

和 Kaldi 一样，这也不提供 PyPI 包，需要从源进行构建和安装。

语音识别 Python 包

SpeechRecognition 包提供了几种解决方案的良好抽象。我们已经探索使用谷歌服务和 CMU Sphinxpackage。现在我们将通过 SpeechRecognition 包 API 来使用这些 API。可以使用 pip 进行安装:

批处理 API

SpeechRecognition 只有批处理 API。第一步是从文件或麦克风创建音频记录，第二步是调用recognize_<speech engine name>函数。它目前有 CMU 狮身人面像、谷歌、微软、IBM、Houndify 和 Wit 的 API。让我们通过 SpeechRecognition 抽象使用一个云服务(Google)和一个软件包(Sphinx)来结帐。

**import** speech_recognition **as** sr
**from** enum **import** Enum, unique

**@**unique
**class** **ASREngine**(Enum):
    sphinx **=** 0
    google **=** 1

**def** **speech_to_text**(filename: str, engine: ASREngine, language: str, show_all: bool **=** False) **->** str:
    r **=** sr**.**Recognizer()

    **with** sr**.**AudioFile(filename) **as** source:
        audio **=** r**.**record(source)

    asr_functions **=** {
        ASREngine**.**sphinx: r**.**recognize_sphinx,
        ASREngine**.**google: r**.**recognize_google,
    }

    response **=** asr_functions[engine](audio, language**=**language, show_all**=**show_all)
    **return** response

*# Run tests* **for** t **in** TESTCASES:
    filename **=** t['filename']
    text **=** t['text']
    lang **=** t['lang']

    **print**('\naudio file="{0}"    expected text="{1}"'**.**format(
        filename, text
    ))
    **for** asr_engine **in** ASREngine:
        **try**:
            response **=** speech_to_text(filename, asr_engine, language**=**lang)
            **print**('{0}: "{1}"'**.**format(asr_engine**.**name, response))
        **except** sr**.**UnknownValueError:
            **print**('{0} could not understand audio'**.**format(
                asr_engine**.**name
            ))
        **except** sr**.**RequestError **as** e:
            **print**('{0} error: {0}'**.**format(asr_engine**.**name, e))

输出:

audio file="audio/2830-3980-0043.wav"    expected text="experience proves this"
sphinx: "experience proves that"
google: "experience proves this"

audio file="audio/4507-16021-0012.wav"    expected text="why should one halt on the way"
sphinx: "why should one hold on the way"
google: "why should one halt on the way"

audio file="audio/8455-210777-0068.wav"    expected text="your power is sufficient i said"
sphinx: "your paris official said"
google: "your power is sufficient I said"

其他提供商的 API

对于其他语音识别提供商，您将需要创建 API 凭证，您必须将这些凭证传递给recognize_<speech engine name>函数，您可以查看这个示例。

它还有一个很好的麦克风抽象，通过 PyAudio/PortAudio 实现。在批次中检查示例以捕捉来自麦克风的输入，并在背景中持续进行。

想写一个把麦克风输入转换成文本的 Python 转录器？看看这个: 如何使用 Mozilla deep speech构建 Python 转录器。

如果您喜欢，请:

通过 Google 云和 Sheets 自动刷新 Tableau 数据

原文：https://towardsdatascience.com/automatic-tableau-data-refreshing-through-google-cloud-and-sheets-13aeb3962fd8?source=collection_archive---------26-----------------------

通过 Python、Google Sheets 和 Google Cloud 的 Tableau 公共数据管道自动化教程

这篇文章介绍了通过 python、Google Sheets 和 Google Cloud 为 Tableau Public 构建自动数据刷新管道所需的步骤。在之前的帖子自动刷新 Tableau Public 中，我解释了如何将 Tableau Public 工作簿连接到 Google Sheets，以利用 Tableau Public-Google Sheet 的每日刷新。我描述了如何在本地安排一个启动守护进程来更新 Google Sheet 中包含的数据，从而刷新 connected Tableau 公共工作簿中的数据。虽然这种设置适用于相对不频繁的刷新周期，但不适用于需要每天(或更频繁)更新的数据。下面详细介绍的设置解决了这个问题，以创建一个真正自动化的数据刷新程序。

为什么您应该自动化您的更新渠道？

虽然我对每周更新英超联赛表的原始数据更新方法非常满意，但我后来构建了需要更频繁更新的 Tableau 仪表盘。对于我的 MLB 击球率预测工具，我需要每天刷新数据以使其具有相关性。在 MLB 赛季的每一天都打开我的个人电脑不是一个好的选择，所以我开始寻找一种可靠的任务调度方法。我最终选定了下面的工作流程:

  1. 使用 Google Cloud Scheduler 安排一个实例运行
  2. 在实例中启动一个 cron 作业，运行我的代码来获取更新的数据并将其加载到 Google Sheets
  3. 使用 Google Cloud Scheduler 安排实例停止运行(为了省钱，因为它每天只需要运行 5 分钟)

我考虑过使用 Google Cloud Scheduler 直接执行脚本，而不是在实例中使用 cron，但是我喜欢通过 ssh 连接到实例，并且我已经熟悉了使用虚拟实例，所以这是阻力最小的途径。我也考虑过使用我在工作中使用的 Airflow，但是它需要一个类似的调度设置和一个额外的 web 服务器部署层。然而，我正在将这一过程转换为 Airflow，因此我可以更容易地安排未来的新工作，并在完成后更新后续帖子。

谷歌云入门

如果你是第一次安装谷歌云，我建议你遵循这个指南。首次使用 Google Cloud 的用户第一年可以获得 300 美元的积分，不过你必须启用计费并填写信用卡信息才能使用。你也可以使用谷歌云的免费层，它有使用限制。空闲层限制了您的可用内存和处理能力，但是您应该有足够的空间来执行基本操作。我对这个脚本使用了第二小的层实例大小，但是它非常便宜，因为我每天只运行 5 分钟。

创建实例

我每次都使用同一个实例，这样我就可以存储代码供重复使用。可能有更好的方法，但对我来说这是最直接的方法。为了在本地机器和实例之间移动代码，我使用 GitHub。显然，GitHub 使版本控制变得更容易，但这也是一种比每次我需要更新脚本时从我的本地机器向实例移动代码更简单的方法。

创建项目

首先，您需要创建一个新项目，因为 Google Cloud 将所有东西都组织在项目中。要创建新项目，请进入项目页面，点击“创建项目”。您可以随意命名它，但是要确保它易于输入，以防您最终从命令行引用它。设置好项目后，您可能需要启用计算引擎 API。进入你项目的控制台(你项目的主页——点击左上角的 Google Cloud Platform)并点击 API。在下一个屏幕的顶部，单击“启用 API 和服务”，然后搜索并添加计算引擎 API。

启动实例

启用 API 后，您可以导航回控制台并单击“转到计算引擎”链接(如果没有出现，请单击左上角的侧栏图标，向下滚动并单击计算引擎)。当您进入计算引擎时，您可以选择创建一个实例。单击“创建”创建您的实例。您可以为您的实例取一个名称(同样，最好是一个容易键入的名称)，然后选择一个区域和可用性区域。这些是谷歌云服务器的位置，你可以在那里托管你的虚拟机。典型的指导是选择一个离你近的地区，但我认为这没那么重要。你的区域选择也不是特别重要。然而，当你去启动你的实例时，它将在那个区域启动，区域组合默认为。如果您的默认区域关闭(偶尔会发生)，您可以跨区域移动它，但是我从来不需要这个选项。

选择您的地区和区域后，您将选择您的实例类型。我用的是 N1 系列，机型 g1-small。根据您的计算需求，有一大堆选项。g1-small 在这方面和其他方面都为我提供了很好的服务，所以我一直保留着它！

在那里，您需要点击“访问范围”下的“允许完全访问云 API”。这将确保您的实例可以计划启动和停止。最后，您将希望允许 HTTP 和 HTTPS 流量。你需要他们运行一个脚本，从某个地方获取数据，然后存储在 Google Sheets 中。您可以在以后更改这些选项，但是从一开始就设置它们会更容易。一旦您的实例设置好了，您就可以通过点击实例，然后点击 start 来启动它！

设置您的实例

要连接到您的实例，您可以在新窗口中打开连接，按照其他选项之一在浏览器中打开它，使用另一个 ssh 客户端，或者通过 g Cloud(Google Cloud 命令行界面)连接。

我混合使用控制台和 gcloud 来使用 Google Cloud，但是你可以轻松地使用其中任何一种。然而，当连接到实例时，我更喜欢 gcloud，这样我可以更自然地与它们交互。要安装 gcloud，请按照这里的说明进行操作。要通过 gcloud 连接到您新创建的实例，您可以在本地终端中键入命令，或者从下拉列表中复制命令并粘贴到本地终端中。如果你不确定它是否有效，如果你看到你的终端把你的位置列为<你的 google 用户名> @ <你的实例名> (对我来说就是 irarickman@instance-1)，你就会知道你在你的实例中。恭喜你，你现在在你的虚拟机里了！

安装软件包和工具

对于我的特定用例，我需要设置一些东西来准备运行我的 MLB 数据刷新脚本。根据您的需求，您自己的设置可能会有所不同，但是我需要以下内容

Python 包 —你的虚拟机应该附带 Python。如果没有，请执行第二步

  1. 运行须藤 apt 更新
  2. (如果你没有 python) 运行 sudo 来安装 python3
  3. 运行 sudo 来安装 python3-pip 来安装最新的 pip
  4. 通过 pip3 安装您需要的任何软件包。对我来说，这主要是 pybaseball，pygsheets，和一些较小的。

安装 Git 并克隆您的代码仓库——如果您还没有安装 Git，请遵循以下步骤。这里假设你想从 Github 或 Gitlab 中提取代码。如果没有，跳过这一步！

  1. 运行 sudo 来安装 git
  2. 像往常一样克隆您的回购协议！我用的是 https auth，可能会提示你输入用户名和密码。如果您使用 SSH，您需要完成正常的 ssh keygen 设置。

创建一个 Google Sheets API 应用程序并连接到它——为了避免重复创建另一个教程，我推荐遵循 Erik Rood 的优秀 Google Sheets API 设置。设置好凭据后，您需要将它们安全地复制到实例中以供使用。要保护拷贝，请打开一个新的终端标签，这样您就可以回到本地目录并运行

gcloud compute scp <file_path>/client_secret.json <googleusername>@<instance-name>:<~/file path>.

第一次使用 scp 时，系统会要求您创建一个密码短语。如果你只是按两次回车键，它不会创建一个。如果您输入了密码，您需要在每次 scp 时输入。如果您从现在起几个月后再次尝试 scp，并且不记得您的密码，跳过密码非常有用。如果您在连接实例时遇到任何错误，您可能需要指定项目和区域(记住它也需要运行)！要获得更多指导，我建议查看 GCP 文档。

加载您的凭据后，您可以对您的应用进行身份验证。这是一次性认证。您的浏览器可能会试图警告您该应用程序不安全。您可以点击高级并继续操作。要设置身份验证，您可以尝试运行您的脚本(并确保您适当地设置了您的授权文件位置),或者在您移动凭证的位置从命令行运行 python 并键入:

import pygsheets
gc = pygsheets.authorize()

您将被引导通过将 url 复制到浏览器中来完成认证流程。按照随后的指示，将密钥粘贴到命令行中，您应该已经准备好了！你可以在这里看到我的代码是如何使用 Google Sheets 的。

计划您的实例

这是允许您定期启动和停止实例的部分。要设置完整的工作流，您需要创建以下各项

设置发布/订阅主题

首先，导航至发布/订阅并点击“创建主题”。您将希望给它一个易于跟踪的名称，例如“start-instance”。

设置云功能

接下来，跳到你的云函数上，点击“创建函数”，然后按照以下步骤操作:

  1. 给你的函数起一个名字，可能是“startInstance”。
  2. 选择您的地区(同样，可能希望保持在同一个地区)。
  3. 选择发布/订阅作为触发器。这将启动你的功能。发布/订阅主题实际上只是向您的函数传递一条消息，让它知道它需要启动。在这种情况下，它还将区域和实例交付给 start。
  4. 在下拉列表中选择“启动实例”发布/订阅。您可以选择是否“失败时重试”。根据您的任务和结构的频率，您可能需要也可能不需要重试。我不为我的。
  5. 点击“下一步”进入代码编辑器。
  6. 在“入口点”输入字段中，输入函数的名称(例如，startInstance)。
  7. 在 index.js 编辑器中，擦除编辑器中已有的代码，输入下面的代码。确保将你的函数名替换为“导出”。<在第 33 行和第 77 行输入函数名，例如 start instance>。这段代码也可以在谷歌的教程 repo 中找到，不过 我在第 38–39 行、82–83 行和 120–122行做了一些小改动。Google 提供的脚本要求在调度任务中传递一个标签。我不标记我的谷歌云资源，所以我从搜索中删除了标签组件。下面的版本可以粘贴到 index.js 编辑器中，启动和停止函数都可以，只需要记住更改停止函数名。明确地说，您不需要在相应的开始和停止函数中包含开始和停止代码，但是为了方便起见，您可以在下面找到所有代码。
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the “License”);
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an “AS IS” BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.// [START functions_start_instance_pubsub]
// [START functions_stop_instance_pubsub]
const Compute = require(‘[@google](http://twitter.com/google)-cloud/compute’);
const compute = new Compute();
// [END functions_stop_instance_pubsub]/**
 * Starts Compute Engine instances.
 *
 * Expects a PubSub message with JSON-formatted event data containing the
 * following attributes:
 * zone — the GCP zone the instances are located in.
 * label — the label of instances to start.
 *
 * [@param](http://twitter.com/param) {!object} event Cloud Function PubSub message event.
 * [@param](http://twitter.com/param) {!object} callback Cloud Function PubSub callback indicating
 * completion.
 */
exports.**<enter start function name>** = async (event, context, callback) => {
 try {
 const payload = _validatePayload(
 JSON.parse(Buffer.from(event.data, ‘base64’).toString())
 );
 //const options = {filter: `labels.${payload.label}`};
 const [vms] = await compute.getVMs();
 await Promise.all(
 vms.map(async (instance) => {
 if (payload.zone === instance.zone.id) {
 const [operation] = await compute
 .zone(payload.zone)
 .vm(instance.name)
 .start();// Operation pending
 return operation.promise();
 }
 })
 );// Operation complete. Instance successfully started.
 const message = `Successfully started instance(s)`;
 console.log(message);
 callback(null, message);
 } catch (err) {
 console.log(err);
 callback(err);
 }
};
// [END functions_start_instance_pubsub]
// [START functions_stop_instance_pubsub]/**
 * Stops Compute Engine instances.
 *
 * Expects a PubSub message with JSON-formatted event data containing the
 * following attributes:
 * zone — the GCP zone the instances are located in.
 * label — the label of instances to stop.
 *
 * [@param](http://twitter.com/param) {!object} event Cloud Function PubSub message event.
 * [@param](http://twitter.com/param) {!object} callback Cloud Function PubSub callback indicating completion.
 */
exports.**<enter stop function name>** = async (event, context, callback) => {
 try {
 const payload = _validatePayload(
 JSON.parse(Buffer.from(event.data, ‘base64’).toString())
 );
 //const options = {filter: `labels.${payload.label}`};
 const [vms] = await compute.getVMs();
 await Promise.all(
 vms.map(async (instance) => {
 if (payload.zone === instance.zone.id) {
 const [operation] = await compute
 .zone(payload.zone)
 .vm(instance.name)
 .stop();// Operation pending
 return operation.promise();
 } else {
 return Promise.resolve();
 }
 })
 );// Operation complete. Instance successfully stopped.
 const message = `Successfully stopped instance(s)`;
 console.log(message);
 callback(null, message);
 } catch (err) {
 console.log(err);
 callback(err);
 }
};
// [START functions_start_instance_pubsub]/**
 * Validates that a request payload contains the expected fields.
 *
 * [@param](http://twitter.com/param) {!object} payload the request payload to validate.
 * [@return](http://twitter.com/return) {!object} the payload object.
 */
const _validatePayload = (payload) => {
 if (!payload.zone) {
 throw new Error(`Attribute ‘zone’ missing from payload`);
 } //else if (!payload.label) {
 //throw new Error(`Attribute ‘label’ missing from payload`);
 //}
 return payload;
};
// [END functions_start_instance_pubsub]
// [END functions_stop_instance_pubsub]

在 package.json 编辑器中，删除编辑器中的现有代码并输入以下内容:

{
 “name”: “cloud-functions-schedule-instance”,
 “version”: “0.1.0”,
 “private”: true,
 “license”: “Apache-2.0”,
 “author”: “Google Inc.”,
 “repository”: {
 “type”: “git”,
 “url”: “[https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git](https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git)"
 },
 “engines”: {
 “node”: “>=10.0.0”
 },
 “scripts”: {
 “test”: “mocha test/\*.test.js — timeout=20000”
 },
 “devDependencies”: {
 “mocha”: “⁸.0.0”,
 “proxyquire”: “².0.0”,
 “sinon”: “⁹.0.0”
 },
 “dependencies”: {
 “[@google](http://twitter.com/google)-cloud/compute”: “².0.0”
 }
}

单击 Deploy，您的功能就应该设置好了！请注意，在下面的步骤中，我们将从调度程序传递区域和实例名称，这些名称将通过发布/订阅传递给函数，这样它就知道要开始什么了！

设置您的云计划任务

最后，转到云调度器，点击“创建”，然后按照以下步骤操作:

  1. 为您的作业选择一个区域(可能与您的实例相同)。
  2. 在下一页，给你的工作起一个名字和描述。我使用“启动实例”来启动它，使用“停止实例”来停止它！
  3. 指定时间表。下面的标题提供了更多信息，但是您需要使用 unix-cron 格式来安排。cron 调度的好处在于它足够灵活，可以每 5 分钟或每月第三天的午夜调度一次。欲了解更多信息，请查看此帮助页面。
  4. 选择您的时区。这样做时要小心。稍后我们将讨论在您的实例中设置 cron 作业。这些默认为 UTC，所以如果您决定不更改您的 cron 时区，您需要确保这些时间表是一致的。我喜欢使用 UTC，因为它不受夏令时的影响。
  5. 选择您的目标作为发布/订阅。
  6. 输入您的主题名称—它应该是您在上面的发布/订阅步骤中使用的名称。
  7. 在 payload 部分，您将告诉您的任务从哪个区域和实例开始。粘贴并编辑下面的代码:
{“zone”:”<zone>”,”instance”:”<instance-name>”}

设置停止实例工作流

上面的工作流程对于启动您的实例来说很棒，但是这个过程的全部要点是启动，然后停止实例。要设置停止工作流，遵循相同的步骤，只需将名称更改为 stop，并仔细检查是否在云函数脚本中填写了停止函数名称。请记住适当地设置启动和停止之间的时间间隔，以便在脚本启动后停止它(反之亦然)。

计划您的 python 脚本

一旦您将实例设置为启动和停止，您将希望在实例中设置脚本通过 crontab 运行。幸运的是，这个过程要简单得多。启动您的实例并在。在实例中，输入 crontab -e 。您将被要求选择您的编辑器，(我更喜欢 nano)，然后您将被带到 crontab 文件。要阅读关于这个文件的更多信息，请查看 crontab.guru 。在那里你还可以找到一个有用的编辑器来测试 crontab 计时。

在您的 crontab 文件中，您可以安排您的脚本。再次提醒，要注意时间和时区！目标是在实例运行的同时调度 crontab 运行。默认情况下，您的 crontab 将在 UTC 上运行。因此，您需要考虑适当的 UTC 时间，以便与实例的开始/停止时间保持一致。找到合适的时间后，输入类似下面的命令来安排您的脚本:

 0 10 * * * python3 /home/<google username>/projections_code/update_batting_avg-gcp.py

如果您有多个 python 安装(例如 python 2.7、anaconda 等)。)您将需要准确地指定要使用哪个 python 可执行文件。同样，您可能希望根据文件所在的位置来调整路径。

最后，我建议测试您的调度器和 cron 时间，以确保它们是一致的。我测试了我的脚本，将时间表设置为几分钟后运行，然后在我知道可以运行时调整实际脚本。虽然这是一个很好的前期工作，但它确实节省了我一些时间，并使一个有趣的画面仪表板。我希望本指南对您有所帮助——请随时提供反馈！

自动文本摘要

原文：https://towardsdatascience.com/automatic-text-summarisation-ccc98d2b323f?source=collection_archive---------46-----------------------

用 TextRank 凝聚客户投诉

动机

这项工作来自我使用美国消费者投诉数据集完成的 NLP 分类任务。任务是仅使用文本叙述来预测客户抱怨的金融产品。这是一个相当简单的监督问题，因为训练数据有标签，简单的逻辑回归分类器可以给出 0.80 的精度。当我浏览被错误分类的投诉时，我被它们的冗长所震惊。以下是对一种抵押贷款产品投诉的开始:

Hello, we have big problem again, there is a foreclosure sale scheduled for our home on XX/XX/XXXX and we are out of options and we have exhausted ourselves with this horrible company. We have had many attempts to receive an affordable monthly payment but no resolution and no affordable monthly payment offer has been given. We have sent in a request for mortgage assistance form along with bank statements taxes paystubs and other documents necessary for a loan modification review. We recently sent Mr. Cooper all documents but Mr. Cooper ahs the sale still scheduled. As part of this bailout, on XX/XX/XXXX, the United States Government took over XXXX XXXX and pumped billions, which in XX/XX/XXXX, then Treasury Secretary XXXX XXXX said as much as {$XXXX} XXXX would be pumped into XXXX XXXX and XXXX XXXX, each, which was separate from the {$700.00} in TARP funds given out to other lenders. 1\. The guidelines issued by the United States Treasury set forth a detailed process whereby a participating servicer, either action or not acting through its subsidiary, must : a. identify loans that are subject to modification under the HAMP program, both through its own review and in response to requests for modification from individual homeowners ; b. collect financial and other personal information from the homeowners to evaluate whether the homeowner is eligible for a loan modification under HAMP...

整份诉状约 2000 字长，引用了美国财政部、联邦和州政府的政策，还掺杂了该公司和特定涉案人员的行为。看到这一点，我对机器学习算法有了真正的了解，这种算法无需人工干预就能对投诉进行分类。对于这个任务，单词“mortgage”的频繁出现会向人暗示我们正在处理一个抵押贷款产品。但是，如果我们想深入到问题的层面，了解投诉的内容，那么我们需要阅读这篇文章——这不是大多数人会喜欢的任务。

幸运的是，我们可以使用机器学习来减少理解文本的努力，通过自动文本摘要。

自动文本摘要

自动文本摘要的一个很好的定义是“产生一个简洁流畅的摘要，同时保留关键信息内容和整体含义的任务”。有两种不同的方法，提取总结和抽象总结。

摘录摘要

  • 从原文中找出最重要的句子或短语
  • 仅从原文中提取句子
  • 摘录的句子将是我们的总结
  • 大多是无监督学习

抽象概括

  • 从原文中产生新的句子
  • 生成的句子可能不会出现在原文中
  • 更困难的任务，包括语言理解
  • 使用深度学习方法

提取与抽象摘要

在这里，我们将只关注提取总结算法。我们要看的这个叫做 TextRank。

TextRank 算法

TextRank 算法是一种提取的无监督文本摘要算法。这是一个相当古老的方法，于 2004 年首次提出。顾名思义，它与著名的 PageRank 算法有相似之处，page rank 算法用于按重要性对网站进行排序。

应用程序中的文本等级

TextRank 与 PageRank 的比较

  • 代替网页的句子
  • 任意两个句子之间的相似度相当于网页转移概率
  • 相似性得分存储在一个正方形矩阵中，类似于 PageRank 中使用的矩阵 M

首先，将文本拆分成句子。我们计算每对句子之间的相似度。这建立了一个完整的加权图，即每个顶点(句子)连接到所有其他顶点，每个边是它连接的两个顶点之间的相似性得分。边的值基本上类似于为另一个顶点“投票”——投票越多，顶点(句子)的重要性就越高。然而，正如在 PageRank 中，谁投票也很重要:重要的句子在投票时的贡献更高。在过去，他们使用重叠来计算句子之间的相似度，但现在我们可以只使用句子嵌入来计算余弦相似度。

下面是分成句子的示例段落和句子嵌入之间的相似性矩阵。

0: ‘I have reached out to the credit bureaus about these debts they have put on my credit file.'
1: ‘This has been a long road.’
2: ‘When ever I apply for anything I am never approved because for some reason I believe me and someone has the same social.’
3: ‘Its extremely frustrating.’
4: ‘I just would like all this inaccurate information removed’

我们使用这个矩阵运行 PageRank 算法(PageRank 在 networkx 中作为方法可用)，取前五个句子作为文本摘要。

结果

在用于进行实验的语料库中，单词的中位数是 51，最大值是 2643 个单词。总结之后，字数的中位数略微下降到 40 个，但是我们基本上消除了长尾效应，现在投诉的最大字数为 482 个。

你可以去我的 Github repo 查看一些文本摘要的例子，这里有一个简单的例子。这是一份在“讨债”下提交的投诉，具体问题是“关于债务的书面通知”。

原文:

'It was recently reported on my account that I had a derogatory account with Eastern Connecticut Account. I have never received anything regarding a missing payment to my New York address. This is regarding an XXXX XXXX payment for XXXX dollars. This was a charge from XX/XX/XXXX, I had XXXX XXXX XXXX XXXX XXXX at the time as I was under my father’s insurance. \tI received a few phone calls in XX/XX/XXXX from *XXXX Fraud Alert #*, I obviously did not answer. I had a voicemail saying to please call and confirm a social security number. I XXXX Eastern Connecticut and saw extremely negative reviews. My concern regarding giving them my personal information only began to grow. When I called back I instructed the representative that they showed up on my phone as fraud. Then the representative began to instruct me on an XXXX XXXX debt. I asked from when was this from, they said XX/XX/XXXX. I asked her if XXXX XXXX put my insurance in. XXXX XXXX XXXX XXXX XXXX in and out of state number. I know that my insurance would have went through, as I had XXXX XXXX XXXX and had numerous bills that were all covered. I instructed her to reach out to the XXXX XXXX and try to submit the claim or call me back if there were any issues. I didn’t feel comfortable just making a payment to this organization, especially after the reviews and the type of infection I had during that time. When the organization never called me back, I assumed that the XXXX XXXX had taken care of it.\tAfter I got an update from my XXXX  app on a negative report to my score, I saw it was Eastern Connecticut. I immediately called Eastern Connecticut, and left numerous Voice Mail Messages. I had one representative hang up on me multiple times, when I was trying to explain I don’t live in Connecticut. After finally getting through to one representative, I finally paid the XXXX dollars. I asked if they could send a report to your company saying they didn’t have my address and the person laughed at me over the phone. He said, “Why would I help your credit score”. He said, having a phone number is sufficient enough to report someone as a derogatory account. \tThis organization is taking advantage of people and I don’t want my credit report to be negatively reflected by this. XXXX even reported their entity as fraud. I did pay this organization, however extremely reluctantly. I have attached a copy of the receipt. Please, if your organization can update my credit score and remove this derogatory account information. I have never missed a payment on any of my accounts. I have a number of student loans that I’m trying to pay off, and this negative credit score will hurt my future in receiving a lower interest rate.'

总结文本:

'He said, having a phone number is sufficient enough to report someone as a derogatory account. This organization is taking advantage of people and I don’t want my credit report to be negatively reflected by this. I asked if they could send a report to your company saying they didn’t have my address and the person laughed at me over the phone. I have never received anything regarding a missing payment to my New York address. I have a number of student loans that I’m trying to pay off, and this negative credit score will hurt my future in receiving a lower interest rate.'

这个总结看起来很有意义，但它并不完美，因为句子来自原文，而且没有试图确保连贯性或语法。

回到分类

从投诉中删除了这么多单词后，我想检查分类任务现在将如何执行。使用与全文相同的方法——标记化、tf-idf 矢量化，然后应用线性 SVC 分类器，我们获得了 0.80 的精度，这与我使用全文获得的结果相同！召回矩阵如下:

结论

在为消费者投诉构建产品分类器时，我注意到长时间的投诉使得人工验证结果成为一项特别艰巨的任务，于是我研究了在不丢失关键信息的情况下总结文本的方法。我们使用了一种叫做 TextRank 的无监督方法，可以快速运行。它产生合理的摘要，并且当使用摘要文本而不是原始全文作为分类的输入时，我们发现该算法在性能上没有损失。当然，该方法的缺点是摘要中的所有文本都来自原始文本。

参考

自动检测新冠肺炎错误信息

原文：https://towardsdatascience.com/automatically-detect-covid-19-misinformation-f7ceca1dc1c7?source=collection_archive---------24-----------------------

图片来源:Unsplash

NLP，机器学习，新冠肺炎

普通市民识别假新闻不容易。而假冠状病毒新闻也不例外。

作为打击关于冠状病毒的错误信息的努力的一部分，我尝试并收集了训练数据，并训练了一个 ML 模型来检测冠状病毒的假新闻。

我的训练数据并不完美，但我希望它可以帮助我们了解假新闻在风格和语言使用上是否与真实新闻有系统的区别。所以，让我们来看看。

数据

正如在上一篇文章中提到的，我从各种新的来源收集了超过 1100 篇关于新冠肺炎的新闻文章和社交网络帖子，然后给它们贴上标签。数据集可以在这里找到。

fake_covid.py

我决定基于新闻标题和新闻文章主体创建几十个新功能。我来一一解释一下。

标题中大写字母

  • 计算每个标题中大写字母的数量。
  • 计算每篇文章正文中大写字母的百分比，而不是简单地计算数字，因为文章的长度差异很大。

title _ 大写. py

图 1

boxplot_cap.py

图 2

平均来说，假新闻标题中出现大写字母的单词要多得多。这让我想到假新闻针对的是容易被标题影响的受众。

停止标题中的单词

  • 统计每个标题中停用词的数量。
  • 计算每篇文章正文中停用词的百分比，而不是简单地计算数量，因为文章的长度差异很大。

stop _ words.py

图 3

boxplot_stop_words.py

图 4

假新闻标题比真实新闻标题的停用词少。

标题中的专有名词

  • 计算每个标题中专有名词(NNP)的数量。

图 5

boxplot_proper_noun.py

图 6

假新闻标题专有名词比较多。显然，标题中专有名词的使用对于区分真假非常重要。

从文章标题分析中抽离

总的来说，这些结果表明，假新闻的作者试图通过在标题中使用所有大写单词来吸引注意力，并通过跳过停用词和增加专有名词来尽可能多地向标题中挤压内容。我们将很快发现这些是否也适用于文章正文。

这里有一个假新闻标题与真实新闻标题的例子。

假新闻标题:“《烟枪》重磅采访全文:FRANCES BOYLE 教授揭露新冠肺炎冠状病毒的生物武器来源”

真实新闻标题:“冠状病毒这样的疫情为何呈指数级传播，如何‘拉平曲线’”

特征

为了研究虚假和真实的新闻文章，我们在文章主体上计算许多基于内容的特征。它们是:

  • 使用词性标注器，记录每个标注在文章中出现的次数。

pos_tag.py

  • 文章正文中否定和疑问句的数量。

否定. py

  • 使用 Python 库— textstat 计算文本的统计数据，以确定任何文章的可读性、复杂性和等级水平。每个统计特征值的解释可以在这里找到。

textstat.py

ttr.py

  • 文章正文中动力词、休闲词、试探词、情感词的数量。

power_words.py

探索

文章正文中的大写字母

大写 _text.py

图 7

平均而言，假新闻在文章正文中出现大写字母的单词比真实新闻多。

文章正文中的停用词

text_stop_words.py

图 8

假新闻和真实新闻中停用词的比例似乎没有显著差异。

文章正文中的 NNP(专有名词，单数)

专有名词文本

图 9

与标题类似，假新闻在文章正文中也包含更多专有名词。

文章正文中的否定词

否定. py

图 10

平均来说，假新闻的否定词比真新闻多一点。

支架

括号. py

出于某种原因，在我的数据中，假新闻在文章正文中使用了更多的括号。

类型-令牌比(TTR)

ttr.py

图 11

就 TTR 而言，假新闻和真实新闻之间似乎没有显著的区别。

我没有探究所有的数字特性，你可以自己做。然而，从我的探索中，我发现假新闻文章在标题上比在正文上有更多的不同。

哈佛健康出版社诉自然新闻

记住，自然新闻是极右的阴谋论和假新闻网站。我从那里收集的新闻文章都被贴上假新闻的标签。

哈佛 _natural.py

图 12

在预期范围内，自然新闻文章使用的停用词比哈佛健康出版社少得多。

哈佛 _ 自然 _ttr.py

图 13

[TTR](https://carla.umn.edu/learnerlanguage/spn/comp/activity4.html#:~:text=A type-token ratio (TTR,a given segment of language.) 意在捕捉文档中词汇的词汇多样性。低的 [TTR](http://carla.umn.edu/learnerlanguage/spn/comp/activity4.html#:~:text=A type-token ratio (TTR,a given segment of language.) 意味着文档有更多的单词冗余，高的 [TTR](http://carla.umn.edu/learnerlanguage/spn/comp/activity4.html#:~:text=A type-token ratio (TTR,a given segment of language.) 意味着文档有更多的单词多样性。很明显，在 TTR 方面,《哈佛健康杂志》和《自然新闻》有很大的不同。

分类模型

由于我的数据收集有偏差，我们不会使用“来源”作为特征，例如，我只从脸书和推特上收集假帖子。而事实上，脸书或推特上的大多数帖子都是真实的。

我相信你已经注意到我们已经创建了大量的数字特征。对于第一次尝试，我决定使用它们来拟合一个支持向量机(SVM)模型，该模型具有线性核和 10 重交叉验证，以防止过度拟合。

linearSVC_fake.py

print(scores.mean())

当 10 重交叉验证完成时，我们可以在每次迭代中看到 10 个不同的分数，然后我们计算平均分数。

取 C 参数 的所有值，检查精度得分。

c_accuracy1.py

图 14

从上面的图中我们可以看到，对于 C=1，精度接近 84.2%，然后下降到 83.8%左右，并保持不变。

我们将更详细地了解为我们提供良好准确度分数的参数的确切值。

c_accuracy2.py

图 15

上图显示，对于 C=0.7，准确度得分最高。

未来的工作

记得为了学习和探索，我创建了几十个新的数字特征，并使用它们来拟合分类模型。我建议您使用假设检验方法来选择前 8 或前 10 个特征，然后运行线性 SVM 模型和 10 重交叉验证。

假设检验不能对数据中的预测类说什么，但是，这些检验可以说明哪些特征比其他特征更重要。

Jupyter 笔记本可以在 Github 上找到。周末愉快！

*参考:【https://arxiv.org/pdf/1703.09398.pdf *

从文件中自动推断关系结构

原文：https://towardsdatascience.com/automatically-inferring-relational-structure-from-files-ee0790c8002c?source=collection_archive---------23-----------------------

一种使用 pandas 和 NetworkX 自动推断和显示类似 CSV 数据的底层关系结构的方法

从数据文件的集合到对业务有意义的信息空间地图。(原始图像，在 DataSmith 中生成的图形)

背景

他们叫你来是因为他们需要洞察力。也许是对未来的计划，或者是对现在的批判性评估——无论哪种方式，你的愿景都需要有严肃具体的证据支持。为了实现这一点，你需要获取一些原始数据，并将这些数据快速转化为知识。

实际上，放在你办公桌上的很可能是一捆 CSV 文件，由业务分析师匆忙汇编而成，或者是在地下室布满灰尘的服务器上发现的。

我们需要知道这些文件意味着什么，但我们不能为此目的轻易采用标准的 ML 算法，因为我们可能要查看的业务数据是高度分类的——名词将是法律实体、员工、销售、产品和客户，而不是数字观察。

在本文中，我们将看看如何使用 Python、 pandas 和 N etworkX 快速洞察这些 CSV 文件的底层结构。本文中讨论的功能的后端代码(不是特别简洁)可以根据需要获得。

(本文所有图片均为原创。我自己的图形可视化工具 DataSmith 生成的图形图像。)

用例示例

为了便于讨论，让我们以这个描述销售的真实(并且真实地枯燥……)的 CSV 文件为例。

图 1:自然环境中的示例 CSV 文件。

显然，这些列中的一些彼此之间具有特定的关系。给定的“国家”可能总是在同一个“地区”。“Region”和“RegID”似乎大致是一回事。目前还不清楚“货币”是否总是与“国家”或“城市”匹配，或者“ProdGrp”是否与其他任何东西有任何关系。“SaleID”看起来很适合作为主键。

我们想要的是一种工具，它能产生类似于我的纸笔分析的东西:

图 2:两分钟的 CSV 文件铅笔和纸分析

只是我们希望它是即时的、正确的、像样的。本文的其余部分描述了解决这个问题的方法。

我们可以使用许多技术来推断数据结构的近似值，但是大体上我们需要一些基本的构建块:

  • 衡量一列对另一列的依赖程度的方法
  • 一种基于该度量值构建列关系图的方法
  • 一种简化和表示图形方法

事实上，以上三个步骤是许多(如果不是全部)关系信息可视化挑战的特征。现在，我们将依次查看如何定义一个度量、构建一个图表，以及从图表中呈现有用的结论。

措施

本节考虑了测量列之间相关性的方法，并提出了一种自定义的测量方法，即“码头系数”。为了推断关系结构，我们主要想回答以下问题:

  • “A 列可能是 B、C 和 D 列的关键字吗？”
  • ' A 列是 B 列可能是其属性或子维度的维度吗？'

相关性，卡方和他们的朋友

我们需要一个度量来告诉我们列之间是否相关，以及相关程度如何。我们的 ML 本能可能会告诉我们寻找列之间的相关性。不过，这并不是很有效，因为纯粹的相关性并不真正适用于分类变量之间。

所以，我们寻找一个相关的分类版本。常见的卡方测度就是这样；它为我们提供了两个分类变量独立性的数值度量。

图 3:卡方公式

在实践中，卡方是一个可怕的相关性度量，因为它没有缩放，并且很难知道我们应该如何对更大或更小的卡方值做出不同的反应。为了找到列之间相关度的度量，我们可以使用一个叫做 Cramer V 的度量；这种测量是一种缩放的卡方:

图 4:克莱姆的 V——一个缩放的卡方检验

维基百科建议对克莱姆的 V 这里的进行额外的缩放步骤，这可能是分类字段的“最正确”的类似相关性的度量。然而，在实践中，它对当前的任务并不那么有用。

这些方法的问题在于它们是相互关联的度量。为了回答我们的问题，我们想要一个方向性的度量；我们正在寻找不对称的关系，其中 A 列暗示 B 列，但不是(通常)反之亦然。

贝叶斯定理的

为了测量 A 列隐含 B 列的程度，我们可以使用贝叶斯逻辑。这有两大好处:

  • 它产生了一个“信心水平”，这是我们正在寻找的；我们想知道给定 A 列的值，我们对 B 列的值有多大的把握。
  • 这是一种单向关系，很容易表达 A 暗示 B 的情况，但反之则不然。

在实践中，贝叶斯逻辑对我们的问题是有用的，但它有一些缺点。特别是，贝叶斯模型的大多数可用实现对于分类输入都不太适用。例如，为了在 sklearn 中使用非常有用的 Bernoullian Bayes 实现，我们必须使用所谓的‘one hot’编码来将输入列表示为一组布尔值:

图 5:一键编码；决定“语言”是否依赖于“城市”

这是将分类数据转换成适合普通 ML 算法的状态的一般问题的一个特例，这本身就是一个有趣的问题(参见这篇关于数据科学的文章中的介绍)。

虽然贝叶斯方法当然不应该被拒绝用于结构推断——事实上，它们可能非常有用——但这里的目标是构建一个快速、简单的工具。特别是，要推断整个文件的结构，这可能很大，我们需要将每一列与几乎每一列进行比较，而这需要使用贝叶斯方法。此外，当一列几乎暗示另一列的值时，贝叶斯置信水平产生一个难以解释的数字。

码头系数

出于这些原因，对于手头的任务，值得建议一个新的衡量标准，即“码头系数”(之所以这么叫，是因为它在金丝雀码头很有用，金丝雀码头是伦敦的一部分，那里有大量的 CSV 文件)。这是一个回答问题的简单方法:

如果我用 A 列的值来猜测 B 列的值，那么我的正确率是多少？

码头系数计算如下:

图 6:码头系数

…其中 a 是我们的目标列的可能值， b 是我们的从属列的可能值，N ba 是在两列中具有特定值对的记录数。换句话说，它是每个可能的 a 值的最频繁 b 值的总和。

当然，当 A 列暗示 B 列时，码头系数为 1。如果码头系数略低于 1，则表明除了特定数量的数据错误外，A 列暗示 B 列。如果该值较低，则建议在列之间进行一些关联，并且需要进行一些调整，以便很好地猜测是否存在实际的关系。

码头系数的一个优点是，它可以表示为熊猫(奇怪的心理图像，那里)的单个快速运行线，这对于我们的用例来说是理想的。

*w = (df.groupby([cb,ca])[ca].count().max(level=0)).sum()/df.shape[0]*

另一个优点是，它表达了一个对商业有意义的事实:“如果你假设 A 列暗示了 B 列，那么你会得到完全错误的答案(1-w) 100%”。*

构建图表

选择了一个列对另一个列的依赖性的度量之后，我们继续构建一个推断的底层数据结构的图。我们需要图表，因为为了从蕴涵矩阵中提取知识，我们将使用图表技术来简化图表以便显示。

构建蕴涵矩阵

我们通过测量每对列之间的蕴涵度来构建一个蕴涵矩阵。在我们枯燥的销售数据示例中，隐含矩阵恰好是:

图 7:示例数据的隐含矩阵。我们看到“City”几乎意味着“Store ”,但不完全是。

阈值

我们可以在这里决定一段关系有多脆弱才值得考虑。我们可以通过定义一个阈值来做到这一点，低于该阈值的两列之间的关系将被忽略。假设我们使用码头系数，以下阈值是一个很好的起点:

  • 1 —如果我们正在寻找完全的关系完整性，并且我们假设数据没有损坏，则使用此选项。
  • 0.98 —如果我们正在寻找完全的关系完整性，但我们预计底层关系结构可能会因数据质量问题而略微模糊，请使用此值。
  • 0.85 —使用此值，我们将寻找不一定等于实际外键约束的强关系

列移除

在构建矩阵之前，应该从数据集中删除某些类型的输入列。例如:

  • 基数非常低的列可能没有用。基数为 1 的列是没有意义的，因为每隔一列就意味着它们。
  • 看起来像数字度量的列，例如浮点数，可能不构成关系结构的一部分。
  • 基数很高但很大的列可能是不构成关系结构一部分的文本值。

在现实生活中，这一步几乎总是需要的。在我们的示例数据中，为了简洁起见，已经删除了这样的列。

清洗

可能需要填充 nan，纠正 Excel 中引入的空白问题，并进行其他清理。幸运的是，Python/pandas 是完成这类任务的强大工具。

从矩阵中构建图形

我们的“蕴涵矩阵”有表示列之间单向关系强度的单元。这恰好意味着它也是一个图邻接矩阵(其中关系强度是列权重)。

因此，构建关系的图形表示很容易；我们挥动 python 魔棒，非常有用的 NetworkX 库一步就为我们构建了一个图形:

*g = nx.from_numpy_matrix(mat,create_using=nx.DiGraph)*

在现实生活中，我们必须在这里完成一些簿记任务——特别是，原始的 DataFrame 列名需要变成 NetworkX 图中的节点名。

现在，我们可以使用一系列技术(有些在 Python 中已经可用，有些没有)从图中提取决策输入，即知识。

图表的分析和展示

在这一节中，我们考虑从我们的列关系图中呈现快速、可读的输出的步骤。

主键

我们可以很容易地识别主键候选；它们是暗示其他列的列。

出于几个目的，我们想要删除主键，这样它们就不会因为它们的许多关系而使图形变得混乱。

同义词

我们也可以很容易地识别同义词列组；如果两列互相暗示，则它们是同义词。这在现实生活中经常发生，因为如此多的文件包含像‘汽车序列号’、‘汽车牌照号’、‘汽车 ID’等我们期望一起变化的字段。虽然查找成对的同义词列很容易，但是识别大组同义词需要一点图论知识，而 NetworkX 可以很容易地为我们完成:

*filter(lambda x:len(x)>1, nx.strongly_connected_components(g))*

我们在这里做的是识别“强连接组件”，这是图中所有节点都具有双向关系的子图。如果它们有双向关系，它们就是同义词，所以每个结果子图都是一组同义词。然后我们过滤掉只有一个节点的子图。

我们简化图形的下一步是将所有同义词压缩在一起。为此，我们可以使用各种方法，但“最正确的”可能是使用极其强大的 PowerGraph 方法。这种方法将具有相似关系的节点压缩成单个节点。下图给出了一个想法:

图 8:用于简化包含同义词的图的 PowerGraph 方法

对 PowerGraph 的全面讨论，以及超图的迷人世界，超出了本文的范围。 cola 项目包含一个相当容易实现的 PowerGraph。在本文附带的我自己的代码中，我使用了一种更线性的方法；可惜 NetworkX 这次没有给我们一个预打包的算法。

属性

找到键和压缩同义词后，我们现在可以寻找维度。事实上，剩下的每一个不是键的列都是一个维度(因为我们之前已经清除了所有的度量)，但是仅仅知道这一点并没有太大的用处。现实生活中，有趣的维度是有结构的；例如，在我们的例子中，我们期望“城市”有一个属性“国家”,可能还有一个属性“语言”和/或“货币”,即使我们不太确定它们是如何连接在一起的。

我们使用更方便的 NetworkX 算法来发现这些属性。

*dimensions = list(nx.weakly_connected_components(r))*

弱连通分量是由单向关系连接的子图；这正是我们所期望的每个维度，因为维度中的属性通过单向“是属性”关系连接。

当我们执行这一步时，我们发现了另一个简化的机会。我们的维度会以过多的关系结束。例如，如果真正的基础结构是“城市意味着国家，意味着地区”，那么隐含矩阵也将显示城市意味着地区，即使这对人类读者来说不是有用的信息。我们需要去除这些多余的关系，如下所示。

图 9:通过寻找生成树从维度中移除多余的关系

为此，我们可以使用另一种 NetworkX 算法来找到表示维度的子图的“最小生成树”。这是用尽可能少的边来表示图形，并删除不必要的关系。

布局

最常见的可视化表示图形的方式是古老而重要的 d3 项目称之为“力定向布局”。如果您使用 NetworkX 和 matplotlib，这就是您将得到的结果(尽管 NetworkX 称之为“spring layout”)。这通常不是一种非常有用的方式来呈现对业务有意义的项目的小图表(我认为，这甚至也不是一种有用的方式来呈现一般的大多数图表)。默认情况下，NetworkX 和 matplotlib 为我们的示例图形生成了以下可视化效果:

图 10:未简化图形的简单力导向布局的严酷结果

这对于检查代码是否工作以及我们是否有一个图表来说是不够的，但是对于演示或决策来说是没有用的。

在这种情况下，适当的布局选择应该是利用这样一个事实，即我们知道在中间有零个或多个主键，并且有零个或多个分支维度连接到它们。像 GraphViz twopi 这样的放射状布局会更好，但仍然会引入视觉噪音——定位的变化看起来有意义，但却是布局逻辑而不是图形的产物。我实现了一个特定于任务的布局，将维度约束为从主键辐射出来的一条直线(带有分支)。

结果

我们的最终输出如下所示:

图 11:在 DataSmith 中生成的最终结果，显示了输入文件的维度结构

这与我们的预期相差不远，但对于所花的几秒钟来说，结果还不错(在 7000 行的输入文件上)。三个维度是可见的，我们可以看到，虽然货币是每个国家，语言是每个城市，这是我们可能不会采取其他方式。几个同义词已经确定并压缩在一起。该工具使用了适合显示维度信息的布局，并添加了一些微妙的颜色来帮助我们直观地对列进行分组。

进一步的步骤

我在这里只讨论了基础知识。进一步的工作可能沿着以下路线进行:

  • 跨多个输入文件关联数据。这涉及到在文件间寻找关联 id，这是一项重要的任务，但适用于许多用例。
  • 更好地使用贝叶斯逻辑。我认为码头系数对于基本上相关的数据是理想的，但是对于仅统计相关的数据，以及对于使测量而不是维度有意义的数据，将贝叶斯逻辑融入其中将是有趣的。
  • 数据质量用例。这里描述的技术可以构成数据质量链中非常有用的一部分，特别是对于取代基于数据透视表的操作。

如果你有兴趣讨论这样的问题，请联系我们。如上所述，本文中显示的函数的后端代码可以根据请求获得(不保证)！这是一个为应用分析和可视化的最新进展提供巨大机会的领域，可以降低成本，让生活更轻松。

使用人脸通过计算机视觉自动锁定和解锁 Ubuntu！！！

原文：https://towardsdatascience.com/automatically-locking-unlocking-ubuntu-with-computer-vision-using-a-human-face-db35cbe312f7?source=collection_archive---------38-----------------------

我用 OpenCV 和人脸识别库实现了一个自动人脸解锁技术。

Ubuntu Face

在玩代码之前，让我们看看你的 Ubuntu 机器上需要安装的库。

要求

  1. python 3.7
  2. OpenCV 4.1.0
  3. NumPy
  4. 人脸识别
  5. sudo apt-get 安装 gnome 屏保
  6. sudo apt-get 安装 xdotool

下面是三个 python 文件，刚好可以实现这一点！！！

1.face_generate.py

2.face_train.py

3.face_unlock.py

演示视频

1.face_generate.py

生成面

作为第一步，我们必须生成训练图像来训练模型。我已经创建了一个 python 文件来生成我们的面部图像。当你执行这个文件时，它会在命令行中询问你的名字，然后系统会用给定的名字创建一个文件夹。

number=0;
frame_count=0
detector = dlib.get_frontal_face_detector()
print("enter the person name")
name = input()
folder_name="dataset/"+nameif os.path.exists(folder_name):
    print ("Folder exist")
else:
 os.mkdir(folder_name)

之后，我们需要使用 OpenCV 库通过网络摄像头读取我们的脸，并将其存储在相应的文件夹中，在保存到该文件夹之前，我们应该调整我们的图像大小。

image = imutils.resize(image, width=500)
  gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
   # detect faces in the grayscale image
  rects = detector(gray, 1)
  # loop over the face detections
  for (i, rect) in enumerate(rects):
   # determine the facial landmarks for the face region, then   
   (x, y, w, h) = face_utils.rect_to_bb(rect)
   #print rect.dtype
   cro=image[y: y + h, x: x + w]out_image = cv2.resize(cro,(108,108))

   fram= os.path.join(folder_name+"/",str(number)+ "." + "jpg")
   number+=1  
   cv2.imwrite(fram,out_image)  
   cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)   
  frame_count+=1

这将需要 50 张人脸图像来训练模型，你可以根据自己的需要改变图像的数量。

2.face_train.py

该文件将读取由 face_genrate.py 文件生成的每个人脸图像。完成后，我们需要将它们传递给 load_image_file 方法，以获取图像的面部位置。

face = face_recognition.load_image_file("dataset/" + person + "/" + person_img)
# location is in css order - top, right, bottom, left
height, width, _ = face.shape
face_location = (0, width, height, 0)

在训练我们的人脸模型之前，我们应该对我们的图像进行编码，所以我使用了 face_encoding 方法。此外，我们应该将我们的名字存储在一个数组中，以便用 k-最近邻算法进行训练。

face_enc = face_recognition.face_encodings(face, known_face_locations=[face_location])face_enc = np.array(face_enc)
face_enc = face_enc.flatten()

# Add face encoding for current image with corresponding label (name) to the training data
encodings.append(face_enc)
names.append(person)

Sci-kit 学习库是机器学习算法的流行库。我们使用了 sci-kit 学习库提供的 KNeighborsClassifier 算法。

knn_clf = neighbors.KNeighborsClassifier(n_neighbors=n_neighbors,         algorithm=knn_algo, weights='distance')
knn_clf.fit(encodings,names)

最后，我们应该使用 pickle 库保存我们的模型文件。

# Save the trained KNN classifier
if model_save_path is not None:
    with open(model_save_path, 'wb') as f:
        pickle.dump(knn_clf, f)return knn_clf

3.face_unlock.py

这个 python 文件将根据训练好的图像锁定和解锁 ubuntu 系统。让我们首先使用 OpenCV 库通过网络摄像头捕捉我们的脸。使用 read 方法后，我们可以将人脸图像作为帧来读取。

camera = cv2.VideoCapture(0)
(grabbed, image1) = camera.read()

我们必须从图像中检测人脸的位置，因此我使用了 face_location 方法。得到人脸位置后，我们应该传递给 face_encodings 方法对人脸图像进行编码，以便进行下一步处理。

image = image1[:, :, ::-1]X_face_locations = face_recognition.face_locations(image)# If no faces are found in the image, return an empty result.
if len(X_face_locations) != 0:

# Find encodings for faces in the test iamge
faces_encodings = face_recognition.face_encodings(image,   known_face_locations=X_face_locations)

在预测之前，应该使用 knn 模型来找到给定人脸的最佳匹配。下面是验证脸的预测方法。它将返回名称和顶部、左侧、右侧和底部变量。

closest_distances = knn_clf.kneighbors(faces_encodings,   n_neighbors=1)are_matches = [closest_distances[0][i][0] <= 0.4 for i in range(len(X_face_locations))]predictions = [(pred, loc) if rec else ("unknown", loc) for pred, loc, rec in zip(knn_clf.predict(faces_encodings), X_face_locations, are_matches)]

使用 gnome shell 命令锁定和解锁 ubuntu 系统。

if name not in "unknown":
    os.popen('gnome-screensaver-command -d && xdotool key Return')
else
    os.popen('gnome-screensaver-command -a')

如果用户的面部未知或未被检测到，系统将保持锁定状态。

结论

就这样，在上面列出的三个 python 文件的帮助下，我们已经使用人脸成功测试了 ubuntu 的自动锁定和解锁技术。你可以在这里得到完整的源代码

如果您需要任何帮助或协助，请联系我 LinkedIn 和 Twitter 。

自动将您的项目从 DVC≤ 0.94 迁移到 DVC 1.x

原文：https://towardsdatascience.com/automatically-migrate-your-project-from-dvc-0-94-to-dvc-1-x-416a5b9e837b?source=collection_archive---------77-----------------------

将您的项目从 DVC ≤ 0.94 迁移到 DVC 1.x 可能是一个非常复杂的过程。这里有一个简单的方法。

DVC 1.0 已经发布了！

DVC 1.0 已经发布，并带来了一整套期待已久的功能。如果你对新功能的完整列表感兴趣，你应该看看 DVC 官方发布的。其中一个主要的变化是一个单独的dvc.yaml文件，它存储了描述管道的所有必要信息。这在充当 git 存储库中缓存文件占位符的.dvc文件和调用dvc repro时要运行的管道的描述之间创建了一个清晰的分离。

这次升级的一个注意事项是，将包含大量.dvc文件的存储库迁移到新的格式是一个相当复杂的过程。在这篇文章中，我将带你完成从 DVC ≤ 0.94 到 DVC 1 的迁移过程。x 使用一个单一自动化脚本，然后演示一种方法来检查您的迁移是否成功。

迁移一个装满。dvc 文件到新 DVC 1。X YAML 格式

设置

  1. 首先，在终端中打开您的存储库目录。
cd path/to/your/repository

2.我强烈建议创建一个新的分支，专门用于这个迁移，这对于以后比较新旧配置也很有用

git checkout -b dvc-1-migration

3.升级至最新的 DVC 1。x 版本(现在是时候了)。

**# Homebrew (Mac)** brew upgrade dvc**# Chocolatery (Windows)** choco upgrade dvc**# Conda** conda update -c conda-forge dvc**# pip** pip install dvc -U

运行迁移脚本

捷径——不要告诉我细节！

我建议您继续阅读，看看脚本在做什么，但是如果您只是想运行脚本，您可以在您的目录中执行以下操作:

curl 'https://raw.githubusercontent.com/DAGsHub/Dvc1Migration/master/migrator.py' | python -

漫漫长路——我想明白！

在 DVC ≤ 0.94 阶段以包含其细节的文件命名— Dvcfile或<name>.dvc。从 DVC 1 开始，您定义了阶段的名称，而不是包含它的文件的名称。

由 DVC 的合作者之一提供的这个 python 脚本正在将一个单阶段文件转换成dvc.yaml和dvc.lock中的一个阶段。它将原始的.dvc文件(或Dvcfile)和应该出现在新管道中的 stage 的名称作为参数。这意味着你必须手动运行python migrator.py <file.dvc> <stage_name>无数次。当涉及到具有许多阶段的管道时，这可能会变得很麻烦。此外，一些.dvc文件并不代表管道中的阶段，而只是跟踪文件缓存信息。这意味着它们是由 DVC 在运行命令dvc add或dvc import时创建的。这些不应该作为阶段出现在您的dvc.yaml文件中。

我冒昧地修改了脚本，这样它就可以移植一个包含我想要的任意多的.dvc文件的整个项目。简而言之，它将搜索带有“cmd”键的.dvc文件，并将它们的内容添加为新格式的 stage。例如，如果您当前有一个名为train.dvc的阶段文件，脚本将假设您想要调用阶段train。您可以根据自己的喜好随意改变这种行为！

你可以这样下载:

curl 'https://raw.githubusercontent.com/DAGsHub/Dvc1Migration/master/migrator.py' -O

所有原始的.dvc文件将被备份为<old_file>.dvc.bak，并且在您的工作目录的根目录下将创建两个新文件

  1. dvc.yaml
  2. dvc.lock

要运行命令，请执行以下操作:

python migrator.py

输出应该如下所示:

Creating 'dvc.yaml'
Adding stage 'featurization' in 'dvc.yaml'
Generating lock file 'dvc.lock'
Adding stage 'training' in 'dvc.yaml'
Updating lock file 'dvc.lock'
Adding stage 'Dvcfile' in 'dvc.yaml'
Updating lock file 'dvc.lock'
...

如果你不认识这种模式，请在下面的评论中描述你的问题，我会尽我所能来看看。

否则，通过运行以下命令开始跟踪新生成的文件:

git stage -u .
git add dvc.yaml dvc.lock
git commit -m "migration to dvc 1"
git push -u origin dvc-1-migration

这将:

  1. 在 git 中将旧的.dvc文件标记为已删除，同时保持工作目录中的备份文件不被跟踪
  2. 将新的dvc.yaml和dvc.lock添加到 git 树中
  3. 将分支dvc-1-migration提交并推送到您的origin遥控器

差不多完成了

就这样，您现在已经将您的项目迁移到 DVC 1 号了！

由本杰明·戴维斯在 Unsplash 拍摄的照片

没那么快！您希望确保您的管道也这样做，并且您的所有数据文件都被正确地跟踪。

比较您的管道

检查 YAML 文件 一个选项是手动检查创建的文件，并验证所有阶段、部门、输出和指标都存在，并且运行正确的命令。或者，您可以…

直观地比较管道图 理想情况下，您会希望轻松地查看新旧管道，直观地描述两个版本的差异。 DAGsHub 是一个致力于数据科学社区的平台，可以为您做到这一点，它支持 DVC 1 和更老的版本(也有其他很酷的功能)。欢迎你使用任何你喜欢的其他工具来可视化这些差异，但实际上我是有偏见的；-)

通过将您现有的存储库连接到 DAGsHub，您可以通过切换分支将您以前的管道与您在分支dvc-1-migration中创建的管道进行比较。

注意

计算 DVC 1 管道图时，DAGsHub 执行的计算与原始计算略有不同。dvc 文件。这可能会导致节点以不同的顺序出现。除此之外，节点和边应该还是一样的。

谢谢大家！

感谢你阅读了这一点，我希望你觉得有用。如果您有任何建议或反馈，请在下面留下评论，或加入 DAGsHub discord channel 。

posted @ 2024-10-15 13:43  绝不原创的飞龙  阅读(92)  评论(0)  编辑  收藏  举报