量化聊天室毒性

原文： https://towardsdatascience.com/quantifying-chatroom-toxicity-e755dd2f9ccf?source=collection_archive---------22-----------------------

Courtesy of Caspar Camille Rubin on Unsplash

使用机器学习来识别在线聊天室中的仇恨

**注意:**下面是粗俗语言的例子

在这个项目中使用的代码可以在这里找到 。

前几天晚上，我参加了由 Twitch (漂亮的办公室和美味的食物！)我和那里的一些软件工程师聊了起来。原来他们是一个“安全”团队，完全致力于保持聊天清洁，保护聊天室中的流媒体和观众，这是有道理的，因为聊天互动可以说是 Twitch 的核心驾驶体验。考虑到这一点，我开始尝试构建自己版本的聊天毒性分类器(在我的好朋友 Randy Macaraeg 的帮助下)。今天，我将带您经历这一过程！

Twitch chat is a core driver of its user experience

第一步是找到一个数据集。幸运的是，我们在 Kaggle 的朋友举办了一场在维基百科上识别有毒评论的 比赛，该比赛提供了一个超过 30 万条评论的数据集，人工标记了六个类别的二进制标签，包括有毒、严重有毒、淫秽、威胁、侮辱和身份仇恨。

简而言之，自然语言预处理

一旦我们有了数据，我们需要通过清洗过程。对于一般的文本数据集，这通常包括:

• 删除标点符号
• 删除停用词(如“the”、“this”、“what”)
• 词干化/词尾化(通过删除后缀如“-ed”、“-ing”，将单词简化为基本形式)。

此外，处理在线文本和评论需要进一步删除超链接、用户名和自动消息(该数据集中最常见的评论是维基百科对新用户的欢迎消息)。

您所做的预处理因项目而异，对于这一点，除了词干化和词元化，我们有最好的准确性指标来做上述所有工作，这将 ROC AUC 指标降低了 10%。我们还考虑了 n 元语法，其中除了单个单词之外，您还可以查看成对或三个(或更多)单词，但这也使我们的 ROC AUC 指标下降了 5%，因此我们最终没有使用它。

…向量化…

为了将单词转化为机器学习算法可以理解和处理的东西，我们需要做一些称为矢量化的事情。简而言之，这是将单词转化为多维向量的过程，其方式是将单词的含义或上下文与向量指向的位置相关联。 从某种意义上来说，矢量化就是让计算机通过将相似的词义映射到相似的向量空间来量化词义。

词频—逆文档频率矢量化

对于这个应用程序，我们希望 快速、基于上下文的 矢量化。一些方法，如 Word2Vec 和 spaCy 涉及预先训练的数千兆字节的模型，这些模型在数十万甚至数百万个文档上训练，然后将单词的含义简化为一组数百个数字。一般来说，这些模型在保持单词的上下文和含义方面非常出色，但是它们速度慢且庞大。这就是术语频率逆文档频率矢量化的用武之地(TF-IDF)。这种矢量化方法查看一个单词在注释中出现的次数相对于它在其他注释中出现的次数。 两件事导致更高的 TF-IDF 分数:

1. 该词在被评分的特定评论中出现的频率更高。
2. 该词在所有其他评论中出现频率较低。

A glance at the highest TF-IDF scores in comments with the toxic label. We can see cursing is highly correlated with the toxicity labels!

一旦我们将所有的评论转换成 TF-IDF 单词向量集，下一步就是建模。最终目标是在聊天室中实现一种自动调节算法，需要一种快速算法来处理成千上万的同时浏览者相互聊天。为此，我们使用基本的逻辑回归进行分类。实质上，逻辑回归使用你的中学斜率公式:

其中 y 是某事发生的几率(使用 sigmoid 函数在 0 和 1 之间压缩)， m 是由于独立变量 x 的变化引起的 y 的单位变化， b 是偏差，或 y 截距。 这篇文章 对逻辑回归进行了更深入的解释。

所以现在我们有了构建模型的所有要素。此时，我们通过将每个评论输入到 TF-IDF 矢量器来训练我们的模型，该矢量器将该评论转换为 20，000 个特征的矢量(我们希望作为词汇表跟踪的最大字数)。然后，我们将这 20，000 个 TF-IDF 得分特征传递到我们的模型中。为简单起见，我们独立训练六个单独的模型，每个标签一个。这给了我们以下 ROC 评分！

曲线下的受试者工作特征(ROC)面积

Receiver Operating Characteristic (ROC) curves for logistic regression models.

ROC 曲线下的面积告诉我们，如果我们改变概率阈值以获得更多的真阳性，我们会获得多少更多的假阳性。在这个项目的上下文中，假阳性是说一个评论是有毒的，而它实际上不是，真阳性是正确地识别一个有毒的评论。基本上， ROC 曲线下的面积越大，意味着对于额外的真阳性 ，我们得到的额外假阳性越少，这是我们想要最大化的。

如你所见，我们得到的 AUC 值约为 0.97 到 0.98，非常接近最大值 1。这意味着我们可以庆祝，因为我们的模型在识别真正的阳性方面非常棒！

结论和实施

因此，我们创建了一个模型，该模型接收一条互联网评论，然后给出该评论是否属于六种有毒类别的六种可能性。在一台 2019 款 Macbook Pro 上，分类速度大概是每秒 1150 条消息！还不错。虽然还有一些需要改进的地方，但这是一个很好的审核工具，如果有不怀好意的人在他们的频道上发帖，可以用来提醒版主。

请关注我的下一篇文章，了解我们如何在网上和 twitch 聊天机器人中部署这个模型！

用数据量化政治势头

原文： https://towardsdatascience.com/quantifying-political-momentum-with-data-ef181df072a6?source=collection_archive---------25-----------------------

政治评论员每天都在谈论当前的政治形势，当我在电视上看着这些会说话的人做他们的事情时，我总是一遍又一遍地听到“政治势头”这个词。2016 年大选后尤其如此，2018 年大选后也是如此。但是什么是政治动力呢？共和党人和民主党人都声称在 2016 年大选后拥有它。怎么会有人赢有人输呢？我开始思考量化政治势头的方法；过去的法案、民意调查的支持率以及其他民意调查信息都浮现在脑海中，但所有这些信息的问题是，它们都可能被人们扭曲，而且大多数时候它们只考虑了过去投票的人。在浏览科罗拉多州州务卿的网站时，我偶然发现了选民登记，并认为这是衡量政治势头的一个很好的方式。如果人们喜欢一个政党的信息，他们会改变他们的党派，当新的人登记投票时，他们也可以选择一个党派。这将允许我看到是否有人正在改变他们的党派或注册一个党派。顺便说一句，我收集了我的数据，我不知道是哪一个，但它会让我知道一个政党是否正在通过计算他们的政党规模来获得动力。这将是我量化“政治动力”的方式此外，为了能够尝试更多的数据科学技术，我还试图预测 2018 年的选民登记人数。

旁注——我在几个月前完成了这个项目，但从未写过。原因是，我认为我过去/现在害怕过去三四年中产生的有害政治环境，以及如果我的数据不支持你当时的政治观点，我可能/将要受到的强烈反对。但是你知道吗，我在这里谈论的是数据，而且仅仅是数据。是的，这可能是政治数据，我会提到政党是如何受到影响的，但如果你想写一个回应，因为我的结果不会助长你的政党信仰，或者他们不同意你最喜欢的政治谈话主持人在电视上说的话，去写一篇关于它的长脸书帖子或什么的。我不想听。数据是我的安全空间。但是，如果你真的想谈论或评论数据分析以及如何将数据用于政治目的，第一杯酒我请。抱歉，咆哮了，但是，现在回到定期安排的博客。

我所有的数据都是从科罗拉多州政府的网站上下载的。使用政治数据的一个好处是，大部分政治数据被视为公共信息，可以免费下载。一个你必须支付“行政费用”来获取公共数据的例子是选民登记文件。这显示了该州每个注册选民的信息，由于其规模，对于普通公民来说有点昂贵。非常有趣的文件，如果你曾经得到它。但是，我很幸运，我能够免费下载我的信息。我下载的是选民登记统计 excel 文件。这份档案包含了公布当月登记选民人数的信息。该文件中的一些示例工作表如下:党派和地位、性别、党派和年龄，以及按国会选区、州参议院选区、州众议院选区和选区的细分。我想要的信息是从党和状态表。下面是聚会和状态表的大致样子。

From the All Reports excel file from http://www.sos.state.co.us/pubs/elections/VoterRegNumbers/2016VoterRegNumbers.html#April

我最终下载了 60 个这样的文件。从 2012 年 11 月到 2017 年 10 月，每月一次。听起来很简单，只需编写一个脚本将所有这些文件加载到 python 中可用的格式，但是文件本身存在一些问题。首先，并不是所有的年份都有相同的格式。在 2015 年(2012-2014 年)之前的几年中，没有“Prereg”选民，如上图所示，“UNI”(团结)党被 AEL(美国人选举)党取代，并且在如上图所示的不同位置，它也是 excel 的旧版本。我不知道的是熊猫会读书。xls 和。xlsx 文件不同，而升级文件格式并不难，这是一项繁琐的任务。上面所有的问题都通过使用 excel 解决了，但是我真的希望科罗拉多州的州务卿的网站能对数据更加友好。

为了简化我的分析，我对数据做了一些更改，将所有“Prereg”投票者添加到活跃投票者中。“预登记”选民是那些登记投票但实际年龄还不够大的人。一个例子是，一个 17 岁的人在 18 岁生日之前登记投票，但在下一次选举中可以投票，因为那时他们已经 18 岁了。我无法找到 2015 年之前这些“预登记”选民的统计数据，所以我将他们加入了活跃选民，因为我觉得这有助于了解新的和年轻的选民。我还把除了民主党和共和党之外的所有政党都加入了无党派的行列。这是为了简化我的分析，只需要关注三个变量而不是七个。

首先，我想让自己熟悉这些数据，而最简单的方法就是绘制数据图表。我首先开始查看所有县的注册选民总数，以及所有县的政党的活跃选民。这两个图表都给了我一个我正在处理的所有数据的概览。

https://public.tableau.com/profile/cbjohnson30#!/vizhome/Colorado_Voter_Registration/Total

左边是所有县和政党的登记选民总数。该图中的一些关键兴趣点表明，科罗拉多州在偶数年选举后清理了选民名单。这意味着去除那些已经去世或搬走并且多年没有投票的人。另一个有趣的现象是，偶数年选举前选民登记数量增加，但奇数年选举前不会出现同样的增长。关于这个图表，我想指出的最后一点是，因为它有规律的增加和减少，所以可以肯定地说，这个图表有 2 年或 24 个月的季节性。这对于预测未来的注册人数非常重要。

https://public.tableau.com/profile/cbjohnson30#!/vizhome/Colorado_Voter_Registration/Active

左边是所有县的政党的所有活跃选民的图表。这张图表信息量很大，确实为了解整个科罗拉多州的选民登记率提供了一些很好的见解。我注意到的第一件事是 2013 年所有活跃选民中出现的巨大峰值，但在总选民图表中没有看到。这是因为科罗拉多州众议院法案-1303，创造了选民准入和现代化选举法案，于 7 月生效。这改变了不活跃选民的定义。在这项法案之前，如果你在前两次选举中没有投票，你就成了不活跃的选民。法案通过后，只有 USPS 退回你的选票，你才成为一个不活跃的投票者。如果你收到了你的选票，但由于某种原因没有投票，你仍然被贴上积极选民的标签。活跃选民定义的变化并不影响我的分析，但在预测未来的选民登记人数时却发挥了作用。另一个有趣的地方是初选前后登记人数的变化。在初选之前，大约 6000 名选民将他们的登记状态从无党派改为民主党或共和党，以便他们可以在党内初选中投票。初选结束后，他们又变回原来的样子。幸运的是，这不需要再发生了，因为 2016 年通过了 108 号提案，允许无党派人士在初选中投票。

现在我对我的数据有了更多的了解，是时候做一些深入的分析了。时间序列分析的两种常见形式是移动平均数和与上月的百分比变化。移动平均线在金融预测中很常见，因为它通过平滑图表来帮助减少数据的波动。虽然这在其他时间序列问题中很有用，但我不认为它会帮助我分析这些数据，因为我正在寻找数据中不同的波动点。

与前一个月相比的百分比变化是一个我知道会很有趣的图表，因为这些计算做了两件有趣的事情。第一，它会告诉我某个政党的人数是增加了还是减少了。第二，它会自动将数据标准化，这样我就可以轻松地将不同的政党进行比较。以上是按党派划分的活跃选民的整个数据集与上月相比的百分比变化图。在这个图表中，我最感兴趣的是这些线相互分开的时间。这意味着一个政党以不同于其他两个政党的速度增加或减少其活跃选民数量。我注意到的前两个部分是 2013 年的大幅飙升和初选前后的几个月。这两者在本博客前面都有解释。这个图表加上一个小的补充，可以让我回答我上面提到的关于政治动力的问题。

为了回答我最初的问题，即政治势头是否可以用一个政党的注册选民数量来量化，我使用了上图中与上月相比的百分比变化，以及一些其他特征。这些功能包括将图表限制在奇数年，并给图表添加一个标签，允许我只查看民主党或共和党获胜的县。例如，在 2017 年，我可以查看投票支持唐纳德·特朗普或希拉里·克林顿的县。下面是这两张并排的图表。

首先，看左边的图表，投票给唐纳德·特朗普的县，你可以看到共和党(红色)和民主党(蓝色)的界限明显分开。红线在正数范围内徘徊，从 0.0 到 0.002，这意味着共和党注册选民的数量在这段时间内一直在增长。而注册民主党人的数量几乎总是为负数，这意味着注册民主党人的数量在这段时间内几乎总是在减少。现在，把这个和左边的图表比较一下，那些投票给希拉里·克林顿的县，红色和蓝色的线在 9 月份之前几乎是一起移动的。接下来，看看无关联(紫色)线。对于投票给特朗普的县来说，这条线的斜率比投票给克林顿的县更陡。它也有一个更高的顶点。这意味着，在投票给特朗普的县，登记为无党派的选民比投票给克林顿的县增长得更快。

在 2016 年的选举中，总统竞选被公然认为是选票上最热门的竞选，而在 2014 年，州长竞选被认为是选票上最热门的竞选。在 2014 年鲍勃·博普雷兹(共和党)和约翰·希肯卢珀(民主党)之间的州长竞选中，你也可以看到上面提到的相同趋势。这个图表可以在这里看到。这种模式没有那么极端，但仍然存在。由于科罗拉多州众议院法案-1303，我无法完成 2012 年总统选举的分析。

但话虽如此，我想从全州选举的角度来看这个问题，克林顿赢得了科罗拉多州，希肯卢珀也赢得了他的竞选。因此，如果科罗拉多州的一个县支持在全州竞选中失利的候选人，你会看到失败政党的注册选民增加。但是，投票给获胜候选人的县没有看到获胜政党注册选民的同样激增。例如，正如我们在上文中看到的，在投票给输掉科罗拉多州的特朗普的县中，共和党注册选民有所增加，但在投票给克林顿的县中，我们没有看到注册民主党选民的激增。

如果我是一个政党的成员，利用这些信息，在新的一年的头几个月里，在人们对以前的选举记忆犹新的时候，有针对性地进行选民登记，可能是值得的。比如，在科罗拉多州，共和党可以在投票给沃克·斯特普尔顿(州长竞选中的败选候选人)的县开展选民登记运动。或者，民主党可以在德克萨斯州投票给贝托·奥罗克(在德克萨斯州参议院竞选中失败的候选人)的县开展选民登记运动。我知道这与我之前所说的州长竞选比参议员竞选有更大的影响是相反的，但是考虑到谁参加了竞选以及选举期间全国瞩目的焦点，我认为可以肯定地说这是上届德克萨斯州选举期间最大的一次竞选。我也在关注另一个州的比赛，所以不要全信。

该项目的最后一部分是预测 2018 年的选民登记情况。由于上面提到的季节性，我认为季节性 ARIMA 模型会很适合我的数据集。ARIMA 代表“自回归综合移动平均线”这个模型的公式如下。

该模型不仅会查看预测时间之前的时段，还会查看一个或多个季节之前的时段，以帮助进行预测。在这种情况下，每个周期是一个月，每个季节是两年或 24 个周期。

从表面上看，这些预测可能看起来合理，但我并不像我希望的那样信任这些预测。出现这种情况有几个原因，但归根结底是因为我没有足够的数据来证明我的预测是正确的。有了数据，我就有了，这也是我解决不了的问题。如上所述，2013 年不活跃选民和活跃选民的定义发生了变化，这使得我无法再往前追溯。

如果我包括任何自回归和移动平均成分，我的模型只能回顾一个季节。这是一个问题，因为 2016 年由于有争议的总统选举，选民大量涌入。看看偶数年的 11 月，登记选民总数将达到:2012 年 365 万，2014 年 366 万，2016 年 387 万。我的预测预测 2018 年 11 月将有 402 万选民。我的预测是，非总统年将是一个非常大的年份。这是我在模型中看到的一个缺陷。如果我能够回顾三个甚至四个赛季，这将有助于缓解 2016 年的大幅增长，并且能够更好地区分总统年和非总统年之间的差异，以产生更好的结果。

从 2018 年 11 月的实际注册选民总数来看，我的预测没有我想象的那么远。这个数字是 399 万。虽然我能够说服自己，由于逻辑原因，我的模型不会那么准确，但有时在得出结论之前，最好等待现实生活中的数据。公平地说，我仍然认为如果我有几年的可靠数据，这个数字会更准确。

要查看其余的图表，请访问我的 Tableau 公开简介: https://public.tableau.com/profile/cbjohnson30#!/
要查看用于此的代码，请访问我的 GitHub: https://github.com/CBJohnson30

量化天气对零售销售的影响

原文： https://towardsdatascience.com/quantifying-the-effect-of-weather-on-sales-a3975aaaed43?source=collection_archive---------23-----------------------

Converting weather data into sales indicators | Photo by the author

读者注意 :本文假设读者对数据科学和分析概念有所了解。

澳大利亚一家大型零售商的财务团队想知道“天气对每周销售额有多大影响？”这个问题的答案—这是一个普遍存在的问题，许多财务分析师和经理都在努力解决这个问题。然而，这个行业中没有人有科学的方法来解决这个问题。

准确量化天气对销售的影响的应用有很多，例如:

1.)通过优化定价和在特定天气条件下对合适的产品打折来改善客户服务。
2。)估算对特定天气敏感产品的需求，如雨伞或冰淇淋。
3。)通过降低营运资本来改善供应链&通过确定恶劣天气来降低物流成本。

如上所述，解决这个问题的商业价值是巨大的，因为这可以帮助更好地理解某些天气事件对收入和利润的影响。不仅如此，企业还可以更好地监控和报告受天气影响的客户每周交易习惯。这个项目的最终目标是预测未来一周依赖天气的销售情况。

在本文中，我不想深入数学模型选择和实现的本质。然而，下面概述了用于执行项目的项目管理框架的高级理解。我将描述用于解决问题的跨行业数据挖掘标准流程(CRISP)数据科学框架，并阐述我是如何着手解决这个问题的。

CRISP 数据科学框架包括:

1.)商务理解
2。)数据理解
3。)数据准备
4。)造型
5。)测评
6。)部署&演示

从业务理解开始，我描述了问题的当前状态和未来期望的状态。定义问题的下一步是把它分解成更小的子问题，这些子问题是互斥的，并且是完全的。一旦问题被分解成更小的组成部分，例如，在我们的天气分析中，不同州的温度、风速和降水对每周销售有什么影响？此外，洪水或飓风等重大天气事件的影响是什么？我们如何使用现有的测量指标来定义洪水和飓风？我开始意识到不同的解决方案必须结合起来才能回答这个主要问题。

由于该项目的业务理解阶段的一个重要部分是研究，我利用现有的基于天气的销售预测研究来快速缩小方法范围。所确定的方法得到横向阅读和研究的支持，以确保该方法符合手头具体问题的需要。对方法进行一些必要的修改，以针对给定的问题定制解决方案。因此，使用现有的研究确保了利益相关者更快的周转。

根据 CRISP 框架，第二步是数据理解。在我的分析中有两个主要的数据来源。一个是从 IBM Cognos TM1 接收的州级销售数据，另一个是从气象局(BOM)网站收集的天气数据。与所需的利益相关方召开研讨会，以了解分析所需的所有数据字段。对于 BOM 数据，使用元表和数据表中提供的信息收集数据理解。

第三步是数据准备，这一步非常关键，因为最终模型的准确性在很大程度上取决于数据准备阶段。这一步可以进一步分解为特征选择和特征工程。在这一步中，我探索了可用特性的不同组合和排列，以便特性集可以与输出变量(即每周销售额)具有更高的相关性或适合性。我还去除了季节性的影响，如圣诞节和复活节期间，因为销售趋势在这些时期变化很大。

在建模步骤中，我试验了多元自适应回归样条(MARS)算法、自回归综合移动平均(ARIMA)和各种非线性机器学习算法，如随机森林(RF)和 XGBoost，以选择最适合我们给定数据分布的算法。使用高级机器学习算法的缺点之一是结果的可解释性。因此，为了更好地解释结果；我将温度、风速和降雨量的连续值转换成不同范围的桶，这样我就可以回答这样的问题，如维多利亚州气温上升 10 度会导致多少 X%的收入增加或减少？解释这些问题对于利益相关者展示分析项目的价值非常重要。

使用 K-fold 交叉验证技术对模型进行评估，其中在模型在训练期间未见过的各种测试数据集上验证训练的统计模型。K 倍交叉验证创建了稳健的模型，比其他方法具有更低的偏差。我得到的维多利亚州和新南威尔士州的模型的拟合优度(R 平方)约为 80%。在全国范围内，拟合优度大于 75%。所得模型的平均绝对百分比误差(MAPE)小于 12%，完全在应用所需的不确定性范围内。

最后，使用 R 代码与 Microsoft excel 的集成来部署模型。我在 excel 上创建了一个用户友好且高度直观的仪表板，用于分析结果的消费。我的商业智能仪表盘每周都会显示天气对销售的影响，以及其他销售驱动因素的定性和定量描述。这份报告完全是使用 VBA 自动生成的，每周只需点击一下就可以用新数据刷新。

总之，对准确预测和更好规划的需求在零售业中是至关重要的。尤其是因为重大天气事件，如洪水或干旱，如果处理不当，会给企业带来巨大的财务损失。我所做的是设计一种方法来验证和衡量一个不可控的销售驱动因素对业务的影响。有了这方面的知识，商场运营、交易和规划以及供应链团队将能够更好地预见重大天气事件对市场的潜在货币影响，并采取正确的策略将损失降至最低。

作为分析的下一步，我想看看天气事件对商店的影响，以及不同的天气条件如何影响不同类别的产品。拥有更精细的视图最终将有助于优化业务绩效。此外，我相信这才是分析的真正力量所在。

量子信息与人工智能

原文： https://towardsdatascience.com/quantum-computing-and-ai-789fc9c28c5b?source=collection_archive---------8-----------------------

Google’s qubit circuits are built out of superconducting materials, which are then kept at very low temperatures. Photo from Google through The Verge retrieved Sunday the 13th of October 2019

在人工智能新发展的背景下探索术语和历史

既然有这么多关于量子计算的讨论，我认为探索我遇到的一个术语是合适的，即量子神经网络。然而，要做到这一点，我必须与术语*‘量子信息’*作斗争。因为我两者都不精通，所以你必须把这篇文章看作是一个很难理解的问题，而不是最终的答案。你可以看到第一部分是 NIST 关于量子计算历史的文章摘要。

在物理学和计算机科学中， 量子信息 是 信息 状态的一个 量子 系统。它是研究 量子信息 理论的基本实体，可以使用 量子信息 处理技术进行操控

量子神经网络 ( QNNs )是基于量子力学原理的神经网络模型。QNN 研究有两种不同的方法，一种是利用量子信息处理来改善现有的神经网络模型(有时反之亦然)，另一种是寻找大脑中潜在的量子效应。”**

量子信息史

我当时在看美国国家标准与技术研究院的一个帖子，作者是 Ben P. Stein 关于量子信息的历史与未来。他将量子信息描述为量子物理学和计算理论的结合。

“谷歌、英特尔、微软、IBM 等等都有量子团队，他们实际上在努力打造硬件，”

JQI 研究员、马里兰大学物理学教授、量子信息公司 IONQ 的联合创始人克里斯·门罗说。

这个领域似乎正在从学术实验室向工业领域过渡。

“量子力学彻底改变了 20 世纪。它解释了原子等非常小的物体的工作原理，以及光子或单个光包等能量非常小的东西。它带来了激光、微型计算机芯片和节能发光二极管。根据半导体行业协会的数据，它催生了半导体行业等新的经济领域，2016 年全球销售额达到 3390 亿美元，与 2016 年同期相比，2017 年第二季度增长了 21%。”

“计算是一个物理过程，如果你从这个角度来考虑，它会在计算和物理科学中打开各种新的视野，”NIST 的数学家罗恩·布瓦韦特说

1994 年，时任美国电话电报公司·贝尔实验室数学家的彼得·肖尔创造了一种算法，用于在未来的量子计算机上运行，可以快速破解用于银行和其他敏感交易的加密方案。根据 NIST 的说法，这一发现引发了一场竞赛，并发展成一个新的领域。

研究人员不再仅仅专注于建造一台可以执行 Shor 算法和破解加密代码的量子计算机。对许多人来说，中间目标是实现“量子优势”，这是加州理工学院的约翰·普雷斯基尔创造的术语。因此，当量子计算机能够执行普通计算机不可能或不切实际的任务时，这一目标就能实现，这在优化问题中通常被认为是有趣的。

“有充分的理由相信量子计算机将擅长解决优化问题。首先，大自然似乎对它们没什么意见。当植物利用光合作用将阳光转化为能量时，它们一直在解决这些问题。”

JILA physicists used the quantum properties of a strontium lattice atomic clock to simulate magnetic properties long sought in solid materials. The atoms are confined in an optical lattice, shown as an array of disk-shaped traps set at shallow depths. A laser (yellow wave) probes the atoms to couple the atoms’ spins and motions. The two atomic spin states (red and blue), which are also the clock “ticks,” are locked to the atoms’ right and left motions. Credit: Steven Burrows and Ye Group/JILA

量子化、叠加、消隐和纠缠

“量子计算机将通过利用非常小的……的奇怪规则来获得它们的特殊能力” “**

这些规则之一是 量子化 。一名消防员在滑下一根柱子时，经历了一个平稳连续的重力势能范围。像电子这样的微小粒子可以在原子的能级之间进行突然的“量子”跳跃。

Credit: N. Hanacek/NIST

***叠加。* 在普通的经典世界中，滑板运动员一次只能在一个地点或位置，例如坡道的左侧(可以表示数据值 0)或右侧(表示 1)。但是，如果一个滑板运动员能够像一个量子物体(如原子)一样行事，他或她就可以处于 0 和 1 的“叠加”状态，有效地同时存在于两个地方。

有人认为这对信息技术非常有用。

普通的数据位只能是 0 或 1。

如果离子在碗的左右两边处于叠加状态，可以同时充当 0 和 1。

根据 NIST 的说法，量子比特，或称量子位，可以用来处理大量的信息，比传统的要快得多。

破坏叠加态被称为 退相干 ，这是一个主要问题。因此，研究人员必须保护量子位，并隔离它们。

当一个量子叠加态(比如一个原子同时处于 0 和 1 态)被某种外界扰动破坏时，比如一个实验者测量原子，就会发生退相干。

Credit: N. Hanacek/NIST

量子计算机的另一个要素是 纠缠 ，这可能是所有量子特性中最奇怪的。这是一种量子比特之间的量子联姻。

在被称为纠缠的量子现象中，即使两个粒子相距很远，它们的属性也是纠缠在一起的。

阿尔伯特·爱因斯坦指出了这种“幽灵般的超距作用”，这让他非常不安，但这种行为已经被一次又一次地证实，包括在最近具有里程碑意义的 NIST 实验中。测量一个量子位的值，它就决定了第二个纠缠量子位的值。”

The NIST process for”purifying” an unusual property of quantum physics calledentanglement involves illuminating two pairs of beryllium ions (charged atoms)with a series of ultraviolet laser pulses. Credit: Bill Pietsch, Astronaut 3Media Group Inc.

然而，量子位越多，它们的解密速度就越快。NIST 声称这就是为什么仍然没有量子计算机能够执行真正有用的任务。在做任何有价值的事情之前，系统可能会崩溃。

原子钟和纠缠理论

在 20 世纪 90 年代，NIST 的研究人员已经有了量子位，但称之为原子钟。

“原子钟报时的精确度惊人。NIST-F2 是美国用于计时的最精确的原子钟，保持时间的精确度不到十亿分之一秒的百万分之一。这看起来似乎有些过火，但 GPS 卫星包含原子钟，并依靠这种精度来发送时间戳信号，帮助我们在地球上的任何地方精确定位，误差在一米以内。”

1994 年春末，人们通过电子邮件讨论 Shor 的结果，NIST 物理学家 Charles Clark 组织了 NIST 量子计算和通信研讨会。

阿图尔·埃克特，当时是牛津大学的物理学家。埃克特正在社区里四处传播这些令人兴奋的新想法。1991 年，埃克特提出了基于纠缠的量子密钥分配理论，这是量子密码术的一个重要组成部分，并在十年后的实际设备中得以实现。

他们设想在实验系统中使用捕获的离子。

在提出的方案 中，研究人员将一组单个离子困在一条线上，就像电线上的鸟一样。激光将操纵离子的能量状态，使它们分别代表 0 和 1 或者两者的叠加。每一个离子都可以通过来回摇动来相互交流。摇动可以让每个离子与其邻居交换信息。这样，研究人员就能够用量子位进行计算。”

False-color images of 1, 2, 3, 6, and 12 magnesium ions loaded into a NIST planar ion trap. Red indicates areas of highest fluorescence, or the centers of the ions. As more ions are loaded in the trap, they squeeze closer together, until the 12-ion string falls into a zig-zag formation. Credit: Signe Seidelin and John Chiaverini/NIST

因此，他和小组成员克里斯·门罗用激光控制离子的能量状态，以影响它们的运动。1995 年 12 月，他们宣布了量子计算机的第一个组件。

量子逻辑门

“逻辑门是处理信息的构件.”

通过在电路中安排门，工程师可以创建类似于流程图的东西，使计算机能够执行多种逻辑运算，如数学计算，并执行计算机可以完成的各种任务。

使用激光，研究人员还可以使离子的内部能量状态进入 0 和 1 的叠加状态，使离子的运动进入 0 和 1 的叠加状态。这使得门可以同时处理多种可能性，不像普通的逻辑门，所以门可以同时考虑商业交易的“是”和“否”两种可能性。

David Wineland and other members of NIST’s Ion Storage Group in 1996, shortly after they began to do experiments in the field of quantum information. Credit: Courtesy Chris Monroe

Elaborate laser-table setups such as this one in a NIST-Boulder lab are where many important quantum-information experiments get done. Credit: J. Jost/NIST

****相互纠缠的多个量子位 可以用来同时进行大量的计算。

两个量子位的门可以同时处理四种可能的 0 和 1 的组合。

三量子位门可以处理八种可能的组合。

“每增加一个量子位，门可以同时处理的组合数量就会增加一倍，所以每增加一个新的量子位，组合数量就会呈指数增长。”

然而，测量只能提取关于计算结果的少量信息。部分理解为什么 NIST 提到另一个概念。

波粒二象性 : 一切物体既可以充当粒子，也可以充当波。作为波，离子在空间中有波峰和波谷；峰值代表测量时更可能发现离子的位置。波峰和波谷叠加在一起就形成了新的波形。这些波将组合或“干涉”形成新的波型。通过干扰波，科学家创造出可以转换回量子位值的模式，并产生有用的信息。

根据 Ronald F. Boisvert 的说法，量子计算需要创建所有可能答案的均匀叠加，然后操纵该叠加。因此，当一个人进行测量时，他很有可能得到正确的答案。

建造量子计算机的竞赛

如前所述，最微小的扰动都会破坏量子位中的叠加态，当你给纠缠量子系统添加越来越多的量子位时，它会变得越来越脆弱。

NIST-博尔德小组创造了一个“跑道”阱来捕获和存储多种离子，并用于处理量子信息。他们建造了一个 量子处理器 ，可以运行任何只需要两个量子位的计算机程序。

“一台实用的量子计算机将需要更多的量子位，所以一个想法是将许多这些双量子位处理器连接起来，让它们作为一台成熟的计算机一起工作。”

A gold-on-alumina trap inside a case that protects against electrical interference. Credit: Blakestad/NIST

还有人试图建造微小的微观“量子”鼓，通过释放被称为声子的微小能量包来振动。

NIST’s microscopic aluminum drum, embedded in a superconducting circuit, has both classical and quantum properties. Like a percussion instrument it oscillates at a steady rate with a well-defined amplitude (drum height). It could be used for storing quantum information.

公司 ——从谷歌、IBM、英特尔和微软这样的大公司到量子电路公司和 JQI 门罗创办的创业公司 IonQ 这样的小公司——也在致力于制造量子计算机

根据 NIST 的说法，实现量子优势的竞争是激烈的。

• 谷歌的 John Martinis(前 NIST 研究员) 宣布 该公司的目标是很快展示一台使用超导元件的 49 量子位量子计算机。
• IBM 报道了一个基于超导元件的 50 量子位系统 的建造和测试。
• 在 2018 年拉斯维加斯 CES 展上，英特尔公布了一款 49 量子位量子测试芯片 。
• 在日本，研究人员已经建立了一个系统，使用光纤中的光子来创建他们所谓的 量子神经网络 ，旨在作为一台擅长处理旅行推销员问题等任务的专用量子计算机。

人们认为第一台量子计算机会像 20 世纪的第一台传统计算机一样庞大。

就用途而言，通讯似乎有潜力，可以远距离传送信息。

“研究人员似乎同意一件事:光子或光的粒子将被用来从一台量子计算机向另一台传输信息。在最近一次引人注目的演示中， 中国将纠缠光子 从一颗卫星发送到 1200 公里(约 750 英里)外的地面。

加密随着量子计算死去了吗？

当我听到谈论量子计算时，最常见的是与安全联系在一起。然而，根据 NIST 的说法，由于两项发展，所有的希望都没有失去:量子密码术和后量子加密。

量子密码术 :测不准原理表示测量任何物体都会干扰它。量子加密依赖于这样一个事实，即窃听(试图获取信息)是一种测量形式，会以一种可以被检测到的方式干扰系统。量子密码术在安全通信中也有应用。中国 的研究人员最近使用技术 与远在 2500 公里(约 1600 英里)之外的澳大利亚同事进行了一次安全视频通话。

另一方面，它可能不可行，原因有三:

1. 它非常昂贵
2. 它旨在防止窃听者而不是攻击者

然而，量子密码系统非常昂贵，而且可能被黑客攻击:

“……已经证明，即使是基于量子特性的密码系统 在现实世界条件下也可能被黑客攻击 ；例如，当静电或噪声——受经典物理规则支配——不可避免地被引入系统时。”

量子密码术被设计来保护两个可信任方之间的通信不被窃听者截获。

但是如果另一边的人是网络攻击者呢？窃听者目前并不是网络安全中最大的担忧。

后量子加密 :加密数据的方式，使用不涉及因式分解的数学函数。后量子算法是基于量子信息之前的经典数学技术。研究人员已经在开发后量子算法，以防量子计算机成为现实。

没有计算机的量子信息应用

量子传感器 :原子钟有可能被用作量子传感器。这些量子逻辑时钟是新一代超精密计时设备的一部分。这些新装置非常精确，它们不仅仅可以报时；它们可以作为重力和其他属性的传感器。

另一种是 原子陀螺仪 ，“一种旋转传感器，利用波粒二象性。

“我们通常认为原子是微小的球——换句话说，是粒子。但是在适当的情况下，原子可以表现为波。一个原子的波长——连续波峰和波谷之间的距离——太小而无法察觉，但如果你让原子变得更冷，它们的波长就足够大，可以在当今的实验中被探测到。”

Artist’s depiction of quantum simulation. Lasers manipulate an array of over 50 atomic qubits in order to study the dynamics of quantum magnetism. Credit: E. Edwards/JQI

量子隐形传态 :NIST 国家标准与技术研究所的研究人员已经将光粒子中携带的量子信息“隐形传态”或转移超过 100 公里(km)的光纤，比之前的记录远了 4 倍。

第二次量子革命

根据 NIST 的说法，我们似乎正在取得很大进展，已经到了“第二次量子革命”的地步。

第一次革命 :当科学家们知道量子力学的规则并按照这些规则建造设备时，使得激光和晶体管等发明成为可能，这些发明是计算机的基本组成部分。

第二次量子革命 :在比以前更大的程度上控制单个量子系统，如带电分子，使量子信息的应用更加强大。这种方法借用了实验 NIST 原子钟的量子逻辑方法。

Credit: N. Hanacek/NIST

实验室天体物理联合研究所(JILA)的三维(3-D)量子气体原子钟是第二量子分辨率的早期例子，它将锶原子之间的相互作用控制到一个精致的程度，使原子钟比以往任何时候都更加精确。

Credit: G.E. Marti/JILA

“……赌注很高，从国家到企业，每个人都在参与这场游戏。”

与量子相关的人工智能的新发展

因此，我们也许可以看到一些与人工智能领域的联系。处理信息对许多公司来说都很重要，量子力学导致了半导体的出现，这就是我们今天所知道的计算的出现。提到了对量子发展感兴趣的大公司，但是我将提到一个:谷歌。

谷歌的企业使命是“组织世界上的信息，并使其普遍可用和有用。”

在物理学中，一个 量子 (复数:quanta)是参与一个相互作用的任何物理实体(物理性质)的最小量。

在物理学和计算机科学中， 量子信息 是量子系统状态的信息。它是量子信息理论研究的基本实体，并且可以使用量子信息处理技术来操纵。

因此，世界上最大的技术公司之一对最小的信息部分都感兴趣，而 Google.com 是世界上访问量最大的网站。

谷歌有一个名为 Quantum 的团队:谷歌人工智能 的一项研究成果: “…旨在构建量子处理器和开发新的量子算法，以大幅加速机器学习的计算任务。”

量子计算**正如谷歌人工智能所描述的: “是一种新的范式，将在加速人工智能的任务方面发挥重要作用。我们希望为研究人员和开发人员提供开源框架和超越传统能力的计算能力。”

As of Sunday the 13th of October 2019 these are the areas in Quantum at Google AI

他们有开源框架，专门用于开发新的量子算法，以帮助解决实际问题的近期应用。一个工具是 Cirq，另一个是 OpenFermion。

Two tools used by Google AI in Quantum retrieved Sunday the 13th of October 2019

他们将近期应用描述为:

• 量子模拟:通过化学和凝聚态模型的精确模拟来设计新材料和阐明复杂物理是量子计算最有前途的应用之一。
• 错误缓解技术:他们致力于开发全量子纠错的方法，这种方法能够显著降低当前设备中的噪声。
• 量子机器学习 :他们正在近期量子器件上开发混合量子-经典机器学习技术。
• 量子优化 :航空航天、汽车和其他行业的离散优化可能会受益于混合量子经典优化，例如模拟退火、量子辅助优化算法(QAOA)和量子增强群体转移可能会与当今的处理器一起使用。

谷歌的量子机器学习

他们正在研究通用量子电路学习，用于量子和经典数据的分类和聚类。他们还对生成性和鉴别性量子神经网络感兴趣，这些网络可以用作量子通信网络中的量子中继器和状态净化单元，或者用于验证其他量子电路。

谷歌人工智能的团队正在探索量子神经网络:

** [## 探索量子神经网络

自成立以来，谷歌人工智能量子团队一直致力于理解量子计算在机器中的作用…

ai.googleblog.com](https://ai.googleblog.com/2018/12/exploring-quantum-neural-networks.html)

“从一开始， 谷歌人工智能量子团队 就致力于理解量子计算在 机器学习 中的作用。”

它们通常仍在取得进展，研究正处于开始应用的实验阶段。

2019 年 9 月 20 日，据英国《金融时报》报道，谷歌声称已经建造了第一台量子计算机，可以进行超过当今最强大的超级计算机能力的计算，这是研究人员热切期待的里程碑时刻。代号为 Sycamore 的 53-qubit design it 似乎做到了这一点，但谷歌并未在文章中置评。

后来的 新科学家 在 9 月 26 日宣称谷歌已经达到*‘量子霸权’*。

“谷歌的量子计算机解决了一个叫做随机电路采样问题的任务。在这样的问题中，经过一系列的计算后，每个量子位输出 1 或 0。目的是计算每种可能结果发生的概率。谷歌表示，Sycamore 只需几分钟就能找到答案——它估计在最强大的超级计算机上完成这项任务需要 10，000 年。虽然这令人印象深刻，但它没有实际用途。”

Eric Lukero/Google through NewScientist retrieved the 13th of October 2019

Google’s qubit circuits are built out of superconducting materials, which are then kept at very low temperatures. Google developed a 53-qubit design called Sycamore, which was used to achieve the recent breakthrough.

据报道，他们最近利用可编程超导处理器取得的名为 量子优势的突破性进展的完整论文已经公布，并且可以在网上 阅读 。然而，等待谷歌确认本文中的任何信息可能是明智的。下面是总结:

量子计算机诱人的前景是，某些计算任务在量子处理器上的执行速度可能比在经典处理器上快得多。一个根本的挑战是建立一个高保真处理器，能够在指数级大计算空间中运行量子算法。在这里，我们报告了使用具有可编程超导量子位的处理器来在 53 个量子位上创建量子态，占据状态空间 253 \u 1016。来自重复实验的测量采样相应的概率分布，我们使用经典模拟来验证。虽然我们的处理器需要大约 200 秒来对量子电路的一个实例进行 100 万次采样，但最先进的超级计算机将需要大约 10，000 年来执行相同的任务。相对于所有已知的经典算法，这种显著的加速提供了计算任务上量子优势的实验实现，并预示着备受期待的计算范式的到来。”

考虑量子信息和人工智能的交叉领域接下来会发生什么是很有趣的。也很难说它将走向何方，也许是一种新的计算范式？**

这是第 500 天的第 132 天。500 天来，我每天都写一篇关于人工智能或与之相关的新文章。

商业量子计算

原文： https://towardsdatascience.com/quantum-computing-for-business-347b95d400f9?source=collection_archive---------13-----------------------

在过去的一年里，我们见证了量子计算领域的惊人进步，以及来自全球企业的全新兴趣。

本文呈现了 量子计算 现在的商业前景和现实应用。

a quantum computer

什么是量子计算？

经典计算机有一定的局限性。摩尔定律，大致说的是计算能力每两年翻一番，正慢慢走向终结，因为与进一步小型化相关的根本性技术壁垒。另一方面，计算机是线性运行的，处理一个又一个任务，计算的并行化受到阿姆达尔定律的限制。将这两个因素结合在一起意味着处理真正困难的现实生活问题或简单的真正大数据将需要计算范式的转变。

量子计算机是潜在的解决方案之一。他们正在对量子位进行操作，量子位本身会受到纠缠或叠加等量子效应的影响。这意味着它们可以同时一起工作，因此省略了阿姆达尔定律。此外，与经典电脑的线性性质相反，它们的能力会随量子位元的数目成指数增长。总之，这引起了工业界和学术界应有的关注。你可能已经看到一些文章描述了一个量子的未来，在破解任何安全代码或密码方面，因为量子计算机的计算能力将不可避免地远远超过经典计算机。

量子计算机有多强大？

我们还没有到那一步。尽管最近大肆宣传，我们仍然在 量子优势 之前，这是一个实际的证明，量子计算机可以比经典计算机更好地解决现实世界的问题。这意味着，你不应该指望量子计算机会让你的业务得到全面优化。至少现在没有。那么量子计算是假的吗？肯定不是！这只是过程的早期，像往常一样，有你必须付出的代价，投资失败的潜在风险，但一旦技术更加成熟，也会有回报。

在理论层面上，不同的研究小组证明了某些量子算法将提供超越经典算法的指数级加速。然而，他们都假设量子计算机具有足够良好的量子位，这不是当前的硬件水平。我们目前正处于嘈杂的中等规模量子器件时代，简称 NISQ。 谷歌 、 IBM 、 微软 、 D-Wave 、 Rigetti 、 IonQ 等公司都在尝试打造自己的 NISQ 设备。最近几年有很多进展，导致了具有几十个量子位的硬件的产生，并解决了现实世界的问题，如 优化城市中的出租车路线 或 模拟分子 。这些解决方案并不完美，也不如在超级计算机上获得的解决方案最优，但它们显示了一个良好的趋势——量子计算机真的正在达到商业水平，这是迟早的事情。

寻找次优解决方案是量子空间中所有服务提供商在现阶段提供混合解决方案的原因之一，这些混合解决方案将经典机器学习与量子计算相结合，例如 1QBit、Zapata 或 QxBranch。一些公司只提供在模拟器上工作的服务(在经典计算机上模拟的量子计算，目前比较 Atos 、 Xanadu 或 微软 )或在量子启发的硬件上工作的服务( 富士通数字退火机 )。混合方法会在快速扩展的问题中产生有趣的结果，例如在物流中，或者在只有稀疏数据的情况下，例如预测涡轮机何时会发生故障。这些类型的问题不可能在经典计算机上很好地解决，因此它们为量子计算机提供了一个很好的切入点，量子计算机提供了不同的计算方法和替代的、有趣的解决方案。

我们仍然需要几年的时间才能在不同的行业达到量子优势，但现在是开始实验量子的最佳时机。量子计算机与经典计算机完全不同，因此习惯它们需要一个过程。现在就启动它将让你的公司为量子计算比经典计算更强大的时刻做好准备。

量子计算机的商业应用

我写这篇文章的主要原因是总结量子计算在当今商业世界中的潜在应用。你会发现下面是一些行业的列表，在这些行业中，量子计算机已经和我们现在拥有的技术一起使用。我举了一些已经在尝试的公司的例子，只要有关于它的公开信息和可用的链接。我只展示了最大的企业，但是已经有一些中型公司为了他们的利益而试验量子。

• 金融 :银行业呈现出过多的问题，如投资组合优化、资产定价、风险分析、欺诈检测、市场预测，这些都在量子计算机的能力范围之内。首先，银行已经开始尝试，例如 巴克莱和摩根大通 与 IBM 合作，或者 NatWest 与富士通 合作。
• 保险 :量子计算的潜在应用始于金融工具(债券、衍生品)的估值；保险产品的期权和担保的估价；量化运营风险。 安联保险公司 通过与 1QBit 合作开始试验。
• 能源板块 :优化现有网络结构和预测使用量是两大关联问题，都很适合在量子计算机上测试。 埃克森美孚 已经开始尝试将 IBM 作为量子合作伙伴。
• 交通 :量子计算机使用的最好例子是交通优化，就像 大众 和 D-Wave 一起做的那样。旅行推销员问题及其各种变体构成了在 NISQ 设备上尝试的一类很好的问题。
• 物流 :与运营相关的供应链问题通常很复杂，无法通过经典计算机进行优化，这为 quantum 进入市场创造了良好的潜力。阿里巴巴开始在自己的硬件上进行实验。
• 汽车和航空 :自动驾驶或飞行，或者管理一个庞大的车队都会带来优化问题，这些问题会随着车辆数量的增加而迅速扩大。这就是为什么像 大众 、 戴姆勒 或 福特 这样的汽车行业玩家都在进入这个领域。航天工业也非常活跃，NASA、空客、洛克希德·马丁和合作伙伴都在进行试验，从科技巨头到初创企业。
• 化学品和制药 :药物发现是一个非常昂贵的过程，模拟分子需要大量的计算。量子计算机自然适合制药研发，因为它们更适合模拟量子物体，因为它们本身具有量子特性。 Biogen 在量子计算的药物发现应用方面与埃森哲合作。再比如 罗氏 和 陶氏化学 。
• 材料 :指望更好的电池、芯片或网络架构的行业可以探索量子计算，模拟新的可能性或优化现有结构。这个商业垂直领域的实验是由 博世 和 霍尼韦尔 开始的。
• 区块链和网络安全 :区块链是关于安全交易和合同的。它主要依赖于加密方法，因此容易受到涉及最新技术的网络攻击。这就是为什么探索后量子密码术或量子区块链是对未来的良好准备。到目前为止，只有 埃森哲 将区块链与量子一起提及。然而，网络安全公司有一个整体趋势，那就是关注后量子密码术，即在拥有强大量子计算机的世界中安全运行的算法，参见 微软 或 谷歌 。

这只是冰山一角。我只描述了最大的企业和他们的风险投资，还没有提到活跃的创业社区或已经在这个领域工作的中型公司。毫无疑问，量子计算是下一件大事！

量子计算如何入手？

如果你已经决定要在你的组织内试验量子计算，你能做的最好的事情就是找到一个可以向你介绍这个领域的合作伙伴。目前有几十家初创公司和公司提供量子计算服务，要么是在利基业务分支，要么是在一般情况下。如果你在寻求帮助，只需通过社交媒体给我写一条信息。

如果你想了解更多关于量子空间的内容，这里有一些很棒的概述文章:

• BCG 关于量子计算商业生态系统的广泛 报告，
• 量子计算有线指南 解释其工作原理，
• 麻省理工技术评论 更多技术视角的概述。

祝你的量子之旅好运！

如果你想了解更多，可以看看这个关于量子计算的书单。

量子计算速成班使用非常丰富多彩的图表

原文： https://towardsdatascience.com/quantum-computing-with-colorful-diagrams-8f7861cfb6da?source=collection_archive---------3-----------------------

几乎所有你需要知道的关于量子计算的东西都用非常直观的图画来解释…

Have a quantum cat

量子计算是一个相对较新的、崭露头角的领域，它打破了量子物理学、研究或非常小的事物以及计算机科学的概念。

在这篇文章中，我将用直观的类比和一如既往的丰富多彩的草图和绘图向您介绍驱动这个年轻的、不断增长的领域的概念。

注意: 为了简单起见，我不会在本文中涉及数学和向量符号。如果有兴趣阅读这样的文章，请在下面留言或通过 Twitter 联系我！

经典计算机科学中的信息表示

经典计算机科学涉及比特的流动和操作，比特是计算机中信息的基本单位。它可以保存 1 或 0 的值，但不能同时保存两者。

1 或 0 通常对应于硬件上一个原子的电荷，代表计算机中的真/假或开/关状态。

这些电荷的变化导致位从 1 到 0 的翻转，反之亦然，从而允许信息从存储器的一个位置流向另一个位置。

Traditional bits are just charges on computer hardware that store information depending on their charge.

在量子计算中表示信息

在传统的计算机中，信息是用传统的位来表示的，这些位只能拥有 1 或 0 的值，而不能同时拥有这两个值。在量子计算机中，我们用量子比特(量子比特)来表示信息。

我们可以用 bra-ket 符号来表示量子位:|0⟩或|1⟩，分别读作‘ket 0’和‘ket 1’。

嗯，在量子计算中，量子位可以同时具有 1 和 0 的值，因为有一个叫做 叠加 的过程。

叠加的奇怪例子

叠加是指一个粒子或实体可以同时以两种状态存在的现象。它可以作为两个东西存在，也可以存在于两个不同的位置。例如，让我们看看薛定谔的猫悖论。

如果你把一只猫锁在一个隔音的、不可避免的掩体内，掩体内有一些可能爆炸的爆炸材料，这只猫处于死亡的 和活着的 的叠加状态，因为你不知道材料是否真的爆炸了(可能是因为掩体是隔音的)。**

There is a 50–50 chance of the explosive material either blowing up and killing the cat or staying as is. This is taken from the Minute Physics video on Quantum Superposition

只要你不打开地堡检查，猫在技术上是死的和活的。

然而，当观察者实际检查叠加态物体的状态时，一个奇怪的情况出现了。在这种情况下，现实崩溃为一个单一的结果，它不能再同时存在于多个状态中。同样，如果你再也憋不住了，打开地堡，你可能会看到猫死了。

你猜怎么着？你的好奇害死了猫…

或者，你检查的时候猫可能还活着。当一个观察者(在这种情况下是你)观察一个最初处于叠加状态的物体时，他们只会看到 n 个结果中的一个展现在眼前。如前所述，现实崩溃的结果之一。

这和量子计算有什么关系？

一个量子位可以以叠加态存在，同时携带 1 和 0 的值。这为解决需要大量计算能力的复杂问题打开了一个全新的可能性世界。

Qubits can exist in 2 possible states until observed (which causes reality to collapse to one of the states)

传统逻辑门

为了操纵基本位，它们必须由逻辑门转换，逻辑门要么将位翻转到另一个值，要么让它们保持原样。逻辑门的一些著名例子包括与、或、非、异或和与非。

它们接受成对的位值，并根据门的功能将它们转换为 1 或 0。

An example of a NAND gate that takes in pairs of similar bits and returns the flipped bit

量子逻辑门

为了转换量子位，我们让它们通过量子逻辑门(或量子门)，量子逻辑门根据门的功能将量子位的现有状态映射到另一个状态。

这听起来可能很模糊，但量子门实际上是经典的逻辑门，作用于量子位而不是传统的位。量子门可以无一例外地执行标准经典逻辑门所能执行的所有动作。

让我们看几个量子门的例子:

哈达马德门

或许最常见的是，阿达玛门接受一个量子位作为输入，输出一个量子位，这个量子位有 50%的几率是 1 或 0。

用简单的数学术语来说，量子位坍缩为 1 或 0 的概率是相等的。这本身就是一种叠加，输出量子位有两种可能的状态，直到我们 观察到 它或者在进一步的计算中使用它。

Hadamard 门由方框中的“H”表示，可以多次添加到电路中，以输出一个具有相同机会为 1 或 0 的位。

The Hadamard Gate

There’s a 50–50 chance of the Qubit collapsing to either a 1 or 0

泡利-X 门

Pauli-X 门以 Wolfgang Pauli(顺便说一句，这个名字很棒)命名，它接受一个量子位。它本质上相当于 而非 门，它否定这些位并翻转它们。它在量子位上执行比特翻转。它将|0⟩映射/更改为|1⟩，将|1⟩映射/更改为|0⟩.

The Quantum equivalent of the NOT Gate — The Pauli Gate

The Pauli-X Gate performs a bit flip and negates the Qubits

受控非门也被称为 CNOT 门。这接收 2 个量子位，并且如果第一个量子位是|1⟩.，只将第二个量子位从|0⟩翻转到|1⟩和|1⟩到|0⟩否则，它保持不变。

The CNOT or Controlled-NOT Gate

The CNOT gate only flips the second Qubit if the first Qubit is |1⟩

测量是在电路末端对量子位进行的一种特殊类型的操作，以在操作完成后获得量子位的最终值。

与上面的门相比，测量是不可逆的，因此不是量子门。我之前提到过，当一个观察者看到最初处于叠加状态的东西时，现实会坍缩成其中一个结果。

类似地，测量函数是观测器，它获取折叠量子位的值，并将它们放在一起，作为严格为 1 或 0 的最终输出位。

The Measurement function is represented as this symbol in a Quantum Circuit

The Measurement function takes in a Qubit and observes it to collapse its state to either 1 or 0.

代表量子模型

模型是物理学家用来模拟和观察当你以某种方式戳宇宙时会发生什么的东西。当涉及到可视化时，它们帮助很大。

同样地，量子模型代表处理许多量子现象的情况(例如叠加)。

我们如何在计算机上表示一个数学量子模型？

我们通过使用量子电路来做到这一点。电路代表计算过程，其中量子位通过量子逻辑门，根据其类型/功能将量子位从一种状态转换为另一种状态。

为了建立一个量子电路，我们需要量子逻辑门和量子位的组合，通过时间来获得想要的结果。为了形象化量子电路的样子，请看下图。

该图显示了三个量子位，都具有状态|0⟩或 ket 0 。盒子里的 H 代表量子逻辑门(H 是哈达玛门)。

在这个图中，我们可以看到每个量子位通过一个哈达玛门。第二和第三个量子位各自通过另一个哈达玛门。

通过将这些量子门和量子位放在一个电路中，你可以想象信息在电路中的流动。

在这篇文章中，我试图总结量子计算背后看似困难的理论。量子计算是一个崭露头角的领域，有一个非常小的社区。在即将发表的关于量子计算的文章中，我将涉及数学和向量符号。

如果你想让我报道其他事情，请在下面发表评论，或者在 Twitter 或 LinkedIn 联系我。很快，我将带你用简单的 Python 制作你自己的量子电路(是的。我说 Python)。

如果我犯了什么错误，请让我知道(我也在学习！).

在那之前，下期再见！

一定要看看我关于技术和机器学习的其他文章，以及对未来软件创新的评论。

** [## 遗传算法综合指南(以及如何编码)

遗传算法的起源

medium.com](https://medium.com/sigmoid/https-medium-com-rishabh-anand-on-the-origin-of-genetic-algorithms-fc927d2e11e0) [## CatGAN:使用 GANs 生成猫脸

GANs 的详细回顾以及如何跟他们浪费时间…

hackernoon.com](https://hackernoon.com/catgan-cat-face-generation-using-gans-f44663586d6b) [## TensorFlow.js 简介🎉

在浏览器上运行 ML 模型变得更加容易！

hackernoon.com](https://hackernoon.com/introducing-tensorflow-js-3f31d70f5904) [## 马尔可夫链简介

马尔可夫决策过程的一般指南

medium.com](https://medium.com/sigmoid/rl-markov-chains-dbf2f37e8b69)

里沙卜·阿南德的原创文章**

量子机器学习:量子计算机上的一种快速聚类算法

原文： https://towardsdatascience.com/quantum-machine-learning-a-faster-clustering-algorithm-on-a-quantum-computer-9a5bf5a3061c?source=collection_archive---------11-----------------------

本作品发表在《论文集》 neur IPS 2019 ，可以查看相关 论文 了解更多详情，以及 会议海报 。

量子机器学习是一个非常热门的话题。正如约尔达尼什·克里尼迪斯*(我的博士生导师) 所说:这是量子计算中 *【最被夸大和低估】** 的话题。这个相当年轻的研究领域旨在开发执行机器学习任务的 量子算法 ，例如对猫和狗进行分类的十亿美元市场。你什么都不需要知道，我会解释的。

I guess this is a superconducting qubit quantum chip, but to be honest I don’t know. It’s just pretty.

量子计算 1 分钟

现在你可能会问: 什么是量子算法？与任何常规算法一样，它只是一系列命令，但这次它是由 量子门 组成的电路。 什么是量子门？ 这就像一个经典的门，作为 OR，AND，NOT，作用于 量子比特 而不是比特。 什么是量子位？ 嗯，这是一个量子位:它可以是和 两者的一个位，而不是 1 或 0 。比如通俗地说，可以是叠加态 25%|0 > + 75%|1 >。我们用符号 |0 > 和 |1 > 来记住这些就是现在的量子态。更一般地说，一个量子位的状态是 ⍺|0 > + β|1 > ，其中⍺和β是复数，称为 振幅 。 2 个量子位可以同时拥有|00 >、|01 >、|10 >和|11 >四种组合。8 个具有 3 个量子位的组合，等等，总是并行存在。那是量子物理！接受它，即使它在我们对现实的感知中并不常见。例如，一个量子位可以是一个原子、一个光子、一个离子或任何可以有两种状态的量子系统。就像一只小小的 薛定谔的猫 。 **

所以量子算法的输入是由量子位组成的。如果你有 n 个量子位，你同时有 个 2^n 个组态。你不喜欢吗？有了 300 个量子比特，你就有了 2^300 态，这是宇宙中原子的数量！

另一个重要的事实:如果你 测量 一组量子比特，你不会看到整个叠加(你不是量子)，而只是其中一个配置，随机的，概率与这个配置的振幅相关。

Most probably what a quantum computer will NOT look like.

量子机器学习

有几种基本的量子算法被用作 长期 量子机器学习(QML)的构建模块。这些算法用于寻找矩阵的特征向量，执行矩阵乘法或矩阵求逆，估计两个向量之间的内积或距离。请记住这些重要的量子概念:我们可以通过多次测量来恢复量子态的经典描述，最重要的是，我们需要能够在单个量子态中加载一个矢量或一组矢量。所有这些子例程都允许 执行线性代数任务，并证明了加速**，通常在矩阵或向量的大小上指数级地更快，并有量化的误差保证。**

注:有很多关于不同方法的研究，称为“量子机器学习”，这些方法基于参数化的量子电路。我们希望它们在短期内可能非常有用和强大，但是它们不能复制分析性的机器学习算法，也不能保证加速或准确性。我们的方法更多的是一种计算机科学和长期的方法。

矢量的量子编码

这是关键部分！给定一个 d 维的向量 v ，我们可以通过使用它的每个分量作为表示标准基的状态的量子振幅来对它进行编码。这可以仅使用 对数(d)** 来完成。**

我们现在可以为我们的数据集定义一组 N 向量 v_1 ，… v _ N 的量子编码。我们要开始叠加 N 个 向量，每个向量在维度*上。每个向量由其索引 i 给出，因此我们使用 log(N) 量子位创建所有索引的叠加。 ***

Left : Superpostion of N quantumly encoded vectors using log(N)log(d) qubits. Right : detailed expression of one vector quantumly encoded using log(d) qubits. Vector notation : v = ( v¹ , v² ,…)

经典的 k 均值算法

先简单说一下经典机器学习。有监督和无监督算法之间有一个根本的区别:第一种算法从输入和它们的标签中学习 (我告诉你这些是猫，这些是狗，现在学习) ，而第二种算法在没有指示的情况下学习 (我只是告诉你找到两组不同的动物) 。****

kmeans loop : The dots are vectors of the dataset. The black stars are centroids. Source : https://blog.floydhub.com/introduction-to-k-means-clustering-in-python-with-scikit-learn/

k-means 算法是最基本的无监督学习算法之一。它的目的是 在数据集中找到聚类 ，通过找到 k 理想质心。然后，每个点都有一个标签，对应它的集群！

在每次迭代中，对于 每个 向量 (点) ，我们计算它们到 每个 质心 (黑星) 的距离。所以有 k x N 的距离来计算。如果你有几百万个数据点，那就太多了。 **

该算法的一次迭代做了两件简单的事情:
1)我们通过查看每个向量的当前最近质心，将标签更新到每个 向量。2)我们通过平均每个集群中的向量来更新每个 质心的 。 ****

量子 k-均值

在 我们的论文 中，我们开发了一个 k -means 算法的量子模拟，称为 -q-means **。步骤真的一样，但是一切都是在量子叠加中完成的。****

1 -我们从数据集中所有矢量的 的量子叠加开始，我们同时计算到 k 个质心中每一个质心的所有距离 。
2 -然后我们可以 通过选择最近的质心来同时标记所有向量 。所有的标签都是以量子态书写的，也是叠加态。
3 -然后 测量标签量子位 。量子物理学告诉我们，我们会随机只看到一个标签:它意味着剩余的量子态是 所有带有那个标签 的矢量的叠加！那是纯粹的量子把戏。
4 -利用量子矩阵乘法，我们可以得到一个描述 新质心 的量子态。
5 -我们执行断层扫描来 检索 新质心的经典版本
6 -我们重复最后的步骤，直到我们有了 k 新质心。

分析:因为 N 向量总是被叠加使用，所以运行这个算法 的时间与 N 成对数关系！对 k 和 d 的依赖性几乎类似于经典的 k -均值，其在 n 中是线性的。 **

请记住，这纯粹是一个理论算法，尚未在实际的量子计算机或经典模拟器上进行测试！如果你感兴趣的话，请继续，并尝试实现它！

我们能运行这个算法吗？

一个重要的问题出现了:我们如何测试我们的量子算法的质量和收敛性？有 3 个选择:
-在 实际量子计算机 上运行电路，但这目前还不可行。
-在量子电路的 经典仿真器 上运行电路，可行但受限于量子位的数量。
-因为 q -means 与 k -means 遵循完全相同的步骤，我们可以 经典地实现它的一个版本 (在 python 中) ，通过将 k -means 与额外的“量子”误差(比如质心估计中的随机性和噪声)相结合来模仿 q -means。 ****

Training curve, on the MNIST dataset, of the k-means (plain red) compared to a classical simulation of q-means (dashed) for several error values. Despite quantum noise and randomness, q-means converges as well.

有了上面描述的线性代数的量子子程序，特别是内积估计，我们现在能够想象其他几种 ML 情况的量子算法: 量子神经网络 ， 量子卷积神经网络 ， 量子高斯混合模型 ，也许是量子谱聚类。这是令人兴奋的，一切都将被重写。

🎄我能在圣诞节得到一台量子计算机吗？

** 号 号
面对现实吧，这些算法远远领先于我们。它们需要大量具有纠错功能的良好量子位，但它们也需要量子 RAM (QRAM)，需要创建初始量子矢量编码，这可能也很难构建。

那又何必呢？首先，如果有一天这些算法可能会被使用，我们应该看看它们，看看它会把我们引向何方。我们不应该等待学习算法，我们必须从基础开始，赶上更复杂的技术。经典 ML 是一个发展非常迅速的领域，一些先进的理念可以帮助 QML。这就是为什么在 NeurIPS 2019 上发表 QML 论文是一个很好的机会！

此外，描绘出我们未来的可能性已经非常重要了。从长远来看，我们现在应该探索量子计算机能做什么或不能做什么。对于建造量子计算机的人来说，了解 QML 算法中需要什么样的基本要求，我们需要什么样的状态初始化来确保加速，我们将如何处理线性代数，需要什么样的精度等等也很重要。

时间会证明一切！

Or more? Source : myself ©

[1] S. Lloyd，M. Mohseni，p . Rebentrost[2013]
【2】n . wie be，A. Kapoor，K. Svore [2014]
【最近邻方法的量子算法用于监督和非监督学习】
【3】s . Chakraborty，A. Gilyén，S. Jeery [2018]

量子机器学习:k 均值聚类的距离估计

原文： https://towardsdatascience.com/quantum-machine-learning-distance-estimation-for-k-means-clustering-26bccfbfcc76?source=collection_archive---------13-----------------------

几周前，我被邀请在我们学校的年度科技节上演示量子计算的一些应用。

我选择专注于量子机器学习，在我的研究过程中，我发现了一些我认为超级酷的东西:一种完全不同的思考方式，即我们估计点之间距离的方式，这可以使量子 k-means 聚类算法比经典算法快得多。

然而，在我们深入研究之前，让我们先快速回顾一下经典的 k-means 聚类算法。

(经典)k 均值聚类到底是什么意思？

K-means 聚类是一种分类算法，这意味着当我们向它提供数据时，它会尝试将每个数据点与其他一些具有类似属性的点放入一个组或类中。它也是一种无监督的学习算法，所以我们不需要使用我们的一些数据集来训练模型，或者帮助它学习数据的特征。

如果我们有一个包含汽车型号、发动机尺寸和离地间隙列表的小型数据集，并将其输入到 k-means 算法中，输入将是这样的:

我们的输出可能如下所示:

但是算法是如何做到这一点的呢？

那么它是如何工作的呢？

虽然这听起来非常复杂，但是 k-means 聚类背后的思想实际上非常简单。它只是把你要求它分类的每一个新数据点放入它最接近的组中。

将这一点形象化会更容易理解——红点会进入哪个星团？

看起来红点最接近蓝点，所以 k-means 聚类算法会将其放入蓝色聚类中。

不过，这又引出了另一个问题:判断图上两点之间的距离对我们来说很容易，但我们如何让计算机做同样的事情呢？

由于每个点都被表示为一组数字——每个数字都指定了该点在一个平面中的位置——计算机可以使用点之间的坐标差来找到点之间的距离。

我们可以把每一个聚类表示为一个位于该组“平均”位置的点。

我们如何找到平均值？我们可以在一个维度上将属于一个簇的所有点的坐标相加，然后除以该组中的点数。如果我们对每个维度都这样做，那么这些坐标所代表的点就可以用作聚类的平均值或质心。如果我们用上面的例子来做这件事:

彩色的 x 标记了每个簇的质心。

现在，如果我们取代表红点的坐标和群质心之间的差，我们可以证实我们最初的猜测，红点属于蓝色星团:

右下角的文本给出了从红点到每个簇的质心的欧几里德距离。正如我们所看到的，到蓝色质心的距离是最小的，这意味着红点确实会被归类到蓝色星团中。

我们如何找到距离？我们用质心和红点的坐标作为向量。

例如，如果我们想计算到蓝色质心的距离，我们可以从蓝色质心的位置向量中减去红点的位置向量:

要计算距离，我们需要计算矢量的大小:

k-means 聚类算法会找到新点与每个质心之间的距离，然后将新点放入质心最近的聚类中。

超级简单吧？

要点是，找到从一个新数据点到每个质心的距离是关键——之后的所有事情，如比较距离，并将新点分配给一个组，都容易得多。

既然我们已经得到了经典的版本，让我们把事情推进到量子宇宙。

我们知道，我们的算法需要测量到不同质心的距离:但我们如何将使用向量减法测量距离的想法转化为我们可以在量子计算机上轻松有效地执行的事情？

有了经典的量子计算机，我们可以很容易地计算出欧几里得距离，但是试图在量子计算机上这样做要困难得多——而且需要的量子比特比我们能提供的还要多。其原因是，由于量子位的概率性质，相位差和概率振幅很容易测量，但像两个向量之间的距离这样的事情却不容易测量。

我们只需要距离，这样我们就可以将数据点分配到不同的组，我们需要知道哪个聚类离数据点最近。如果我们有另一个更容易测量的参数，可以让我们计算出哪个质心最接近呢？

这个参数不一定要和距离成正比，只要和它正相关就行。这是可行的，因为我们只需要最近的质心，而不需要到每个质心的精确距离，我们可以将新的数据点放在与我们的参数取的最小值相关联的群集中。

幸运的是，当我们处理量子位时，有许多类似距离的参数可用，如两个(归一化)向量之间的内积，以及测量处于 |0> 或 |1> 状态的量子位的概率。

但是我们如何使用两个向量之间的内积来帮助我们估计距离呢？

我们需要做一点数学计算。如果你不喜欢，可以直接跳到下一节的结尾——你真正需要知道的是我们最终得出的可测量变量之间的关系。

关联内积和距离

让我们从一个零初始化的辅助量子位和一个量子态ψ开始，它存储了我们想要估计的归一化向量:

现在我们可以假设 |x> 是我们想要分类的新数据点的位置向量，而 |y> 是我们数据中一个聚类的质心。

首先，我们对辅助量子位应用一个阿达玛门，把它推到叠加态:

为了使状态ψ与我们的辅助量子位纠缠在一起，我们对辅助量子位上控制的ψ应用一个交换门:

这里的 *F*(|Ψ>) 只是一种更简单的方式来展示 |Ψ> 的交换版本，这是交换门应用于 |Ψ> 的结果。

接下来，我们将另一个哈达玛门应用于辅助量子位:

这里 *I* 代表恒等运算符— *I*(|Ψ>) 简单来说就是给出 |Ψ> 。

接下来的几个步骤可能看起来有点随机，但我们真正要做的是将我们现在拥有的等式转化为一种形式，它包含两个向量 |x> 和 |y> 的内积。

如果我们替换 (*I — F*) 和 (*I*+*F*) ，我们得到这个:

我们可以用一个叫做期望值的超级有用的概念来进一步简化这个问题(你可以在这里阅读这个概念)。这个想法是，我们可以将辅助量子位在 |0> 状态下被测量的概率表示为内积:

如果我们把 *I* 和 *F* 重新代入:

如果我们展开内积，我们得到这个:

自 <xy , xy> = 1 和 <xy , yx> = (<x , y>)^2 开始:

太棒了——所以现在我们有了在 |1> 状态下测量辅助量子位的概率，这是我们很容易测量的，和我们想要找到两个向量之间距离的内积之间的关系。

我们现在需要做的就是证明等式的右边与两个向量 |x> 和 |y> 之间的欧几里德距离正相关。

如果我们扩展矢量减法:

因为两个向量都是归一化的，所以它们的幅度是 1:

如果我们看看我们之前推导出的等式，它们看起来非常相似:

酷！看起来我们有了一个容易测量的参数，可以用来代替测量距离。现在让我们使用 qiskit 实现我们的距离估计算法。

从盒子到球体

我们如何将我们想要估计的点之间距离的矢量坐标编码成量子位？

让我们首先绘制几个类，它们的质心，以及我们想要分类的一个新点:

红点是我们要分类的新数据点，彩色的 x 标记每个类的质心。

我们需要找到一种方法，将我们目前用来描述质心的直角坐标转换成球面坐标，这样我们就可以将图上的每个数据点表示为布洛赫球面上的另一个点(查看 这篇 文章，了解量子位表示的超级平滑介绍):

要转换数据点，我们需要执行以下步骤:

• 取一个零初始化的量子位，对其应用哈达玛门，移动代表量子位的向量，使其沿着 x 轴。
• 根据对应于特征 1 的数据点的值设置φ。
• 根据对应于特征 2 的数据点的值设置θ。

θ的范围可以从 0 到 π 弧度，φ的范围可以从 0 到 π 弧度。

为什么我们需要限制φ可以取值的范围？

假设我们有两个数据点，当用一个量子位表示时，它们取相同的θ值和φ值 0 和 2π 。量子位将占据布洛赫球上的同一个点，即使它们代表的点具有不同的特征值，这将搞乱我们的算法——它只在布洛赫球上量子位之间的相位差与两个数据点之间的实际欧几里得距离大致成比例时才起作用。

使用以下等式，我们可以轻松地将数据特征值映射到θ和φ值:

这里 d_0 和 d_1 代表数据特征 1 和 2 的值。如果这些没有意义，回到我们数据的散点图，看看每个特征的范围(-1 到 1)，以及θ和φ。

我们找到了一种方法，从将我们的数据绘制为图上的点，到使用量子位来表示它们——现在让我们把手弄脏，看看我们的算法是否真的有效。

构建距离估计器

你可以在这里得到我使用的数据。

我们已经看到了上面的数据图，以及我们需要分类的红点。为了方便起见，让我们再次绘制我们的数据，但是这里只显示了每个类的质心:

我们得到了一个简洁、超级简单的图表:

我们需要比较从红点到每个质心的距离，所以我们必须将质心和红点的坐标编码到我们的量子位中。为此，我们使用上一节中提出的规则:

现在我们从 qiskit 导入我们需要的所有模块，并创建寄存器来保存我们的量子位和结果:

我们可以使用 qiskit 提供的 U3 门来实现我们需要执行的旋转，以对我们的数据点进行编码。 U3 门可以这样应用:

这条指令将导致量子位从正 z 轴向外移动θ弧度，从正 x 轴向外移动φ弧度，就像我们之前看到的布洛赫球一样。

让我们实现我们在连接辅助量子位的概率和两个向量之间的距离的部分中走过的过程:

现在我们可以检查新数据点属于哪个类。让我们也打印欧几里得距离，以了解到每个质心的距离之间的差异:

我运行了这个程序很多次，得到了这些结果:

它看起来很有效——超级酷！

我们构建了一个量子距离估计器，与 k-means 聚类算法一起使用，我认为这很棒。你可以在这里获得整个程序— 随意在其他数据集上运行它，感受一下它是如何工作的。

这篇文章只是我将发布的一个新系列的开始，涵盖了量子机器学习的不同方面——敬请关注！

面向金融科技的量子神经网络

原文： https://towardsdatascience.com/quantum-neural-networks-for-fintech-dddc6ac68dbf?source=collection_archive---------16-----------------------

时间序列函数拟合

在本文中，我们将解释量子神经网络的一般概念，并且我们将解释可以在一维时间序列数据上训练以拟合数据的函数的模型。我们还将提供 Github 上培训药品销售数据模型的教程的链接。

量子位和量子电路

什么是 量子神经网络 ？要回答这个问题，我们需要理解量子位和量子电路的概念，量子电路是量子计算中用来描述量子位操作的基本图表。 量子电路 非常类似于描述逻辑门操作的电路图，这些逻辑门在经典计算中使用，例如在你的电话或笔记本电脑上。量子位是位的量子计算版本，其行为与位不同。许多人谈到量子位时，仿佛它们是神秘的，并且“同时是零和一”尽管这实际上是不正确的，而且是对他们行为的过度简化，掩盖了数学的精确性。这样做要么是出于作者的误解，要么是因为作者认为读者缺乏知识或注意力。思考量子位元状态的适当方式，是将其视为球体上的一个位置，例如地球表面，北极为“1”，南极为“0”。量子门在这个位置上运行，在全球范围内移动。

Qubits being operated on by the Hadamard gate

如果我们有几个量子位，我们可以用几个门分别操作它们，或者同时用一个多量子位门操作它们。我们画一个电路图来表示哪些量子位在特定的时间通过特定的门。对于量子比特的基本介绍和来自量子力学的基本概念，李奥纳特·苏士侃的书“ 量子力学:理论最小值 ”对于只有一点线性代数作为先决条件的新人来说相当不错。

变分量子电路

某些量子电路的行为非常像我们从机器学习中了解并喜爱的神经网络。我们可以开发“变分量子电路”，模仿在深度学习中变得如此流行和有效的深度神经网络的行为。这些电路中的门的行为就像一层神经网络，我们可以以各种方式训练它们，以执行所有与 TensorFlow 或 Pytorch 中使用的神经网络相同的任务。

事实上，在许多情况下，量子方法在计算能力和准确性方面提供了极大的改进。即使经典地模拟这种方法，也显示出高达 100 倍的性能提升，正如在 TensorNetwork 的应用中所看到的那样，这是一个由谷歌建立的库，它使用 TensorFlow 作为后端，允许用户用张量网络取代神经网络的层。如果你不熟悉张量网络是什么，看看 我的另一篇文章 ，关于它们如何被用来模拟量子电路，以及它们如何被谷歌和其他人用于 机器学习 。

好的，所以量子电路可以像神经网络一样被训练，可以执行神经网络可以执行的任务。然后呢？那么你可以在一台真正的量子计算机上运行它！我知道，你读过的大部分新闻都说量子计算还需要几年时间，实际应用还不清楚。这些信息已经过时，而且非常不准确。不相信我？试试 IBMQ 量子体验 自己看吧。IBM 目前允许用户注册一个免费账户，在 Qiskit 中开发代码，然后可以在 IBM 的量子计算机上运行。其实我有一个 Github 教程 repo 给大家展示如何使用开源软件 PennyLane 来执行各种量子机器学习任务！让我们来看一个例子。

金融科技和时间序列

正如我们在下面看到的，量子神经网络，基于 草莓地 的光子量子计算，学习平滑有噪声的数据(红色部分)。

Noisy Sine Function

Trained Model on Noisy Sine Function

如果你不太了解金融科技(FinTech)或金融科技，它只是一个应用于金融和投资的科技术语。它可以是任何东西，从一个跟踪你的支出的应用程序到最新最棒的用于股票交易的 机器学习模型 。 我们的例子 是用一维函数拟合时间序列数据的模型。特别是，这是一个来自 PennyLane 的经过修改的 示例，它是根据一些合成数据以及一家澳大利亚制药公司大约 17 年来的一些药品销售数据进行训练的。数据已被重新调整，但在其他方面未被处理和更改。该模型花费了 12-24 小时来训练。训练模拟版本所花费的时间不应该令人惊讶，因为模拟量子电路对于经典(基于比特的)计算机来说通常是相当困难的。模型学习的函数的结果可以用红色显示。

Pharmaceutical Sales Data 1991–2008

Trained Model Prediction (in red)

量子机器学习的应用不再是对未来的预测， 它们是现实 ，而且非常有趣！这里应该提到几件事。首先，执行这些计算所需的量子位数量完全在当前量子计算硬件的能力范围之内。其次，这不仅是我们可以在当前的量子计算机上执行的任务，而且我们在当前的硬件上实际上有足够的量子位来使用一种叫做“ 量子纠错 ”的东西这是一种将冗余信息编码成多个量子位的方式，从而减轻计算中的误差(感兴趣的读者也可以参考“ 拓扑码的量子计算 ”了解量子纠错的介绍)。使用量子纠错所需的量子位数量取决于问题。因此，在某些情况下，我们能够在当前的硬件上实现纠错。当我们考虑到许多量子机器学习算法，如我在 Github 上的 二进制分类器教程 ，只需要一个量子位，而即使是 IBM 最基本的公开可用硬件也有五倍于此的量子位时，不难看出我们很容易看到量子计算机在时间序列函数拟合和分类问题等方面的实际应用。看到企业开始投资将量子机器学习集成到他们的商业模式中，纯粹是为了帮助他们理解这项技术在这一点上如何以及为什么有用。

如果你有想法要分享，有问题，或者你需要量子机器学习的咨询服务，请通过 LinkedIn 联系作者，访问奇点 网站 ，或者查看 Github 教程 。

使用 Amazon Athena 从 S3 文件中查询数据

原文： https://towardsdatascience.com/query-data-from-s3-files-using-aws-athena-686a5b28e943?source=collection_archive---------3-----------------------

亚马逊雅典娜被定义为“一种交互式查询服务，它使得使用标准 SQL 直接在亚马逊简单存储服务(亚马逊 S3)中分析数据变得容易。”因此，这是另一个用于存储在 S3 的大型数据集的 SQL 查询引擎。这与其他 SQL 查询引擎非常相似，比如 Apache Drill。但与 Apache Drill 不同，Athena 只能从亚马逊自己的 S3 存储服务中获取数据。然而，Athena 能够查询各种文件格式，包括但不限于 CSV、Parquet、JSON 等。

在本帖中，我们将看到如何使用存储在 S3 的样本数据集作为 在 Athena 中设置一个表。csv 文件。但是为此，我们首先需要示例 CSV 文件。你可以在这里下载 。

下载完文件后，在 AWS S3 中创建一个新的 bucket。我建议创建一个新的桶，这样你就可以专门使用这个桶来尝试雅典娜。但是您也可以使用任何现有的存储桶。

下载完文件后，在 AWS S3 中创建一个新的 bucket。我建议创建一个新的桶，这样你就可以专门使用这个桶来尝试雅典娜。但是您也可以使用任何现有的存储桶。

所以，现在你已经有了 S3 的文件，打开 Amazon Athena。您可以选择在 Athena 主页上创建一个表。我的看起来有点像下面的截图，因为我已经有几个表了。从截图中可以看出，创建表格有多种选择。在这篇文章中，我们将坚持基本原则，选择“从 S3 桶数据创建表”选项。所以，现在你已经有了 S3 的文件，打开 Amazon Athena。您可以选择在 Athena 主页上创建一个表。我的看起来有点像下面的截图，因为我已经有几个表了。从截图中可以看出，创建表格有多种选择。在这篇文章中，我们将坚持基本原则，选择“从 S3 桶数据创建表”选项。

选择该选项后，您将被重定向到创建表的四步过程。让我们简单地看一下这些步骤。

第一步:姓名和地点

正如您在上面的屏幕中看到的，在这一步中，我们定义了数据库、表名和 S3 文件夹，该表的数据将来源于该文件夹。如果您已经有一个数据库，您可以从下拉列表中选择它，就像我所做的那样。如果没有，您可以选择从这个屏幕创建一个数据库。

接下来，为表提供一个名称。对于这个例子，我将表格命名为 sampleData ，只是为了保持它与我使用的 CSV 文件相同。

接下来，您必须提供存储文件的 S3 文件夹的路径。注意不能提供文件路径，只能提供文件夹路径。因此，该文件夹中具有匹配文件格式的所有文件都将被用作数据源。由于我们只有一个文件，我们的数据将仅限于此。在这篇文章中，我们将忽略加密选项。

我们还要注意，Athena 不会将这些源文件中的任何数据复制到另一个位置、内存或存储中。每个查询都是针对原始数据集运行的。

第二步:数据格式

这是非常直接的一步。您只需选择数据源的文件格式。因为我们使用的是 CSV 文件，所以我们将选择 CSV 作为数据格式。

第三步:列

在第三步中，我们定义数据集中每个文档/记录的“列”或字段。这是必需的，以便 Athena 知道我们正在处理的数据的模式。此处未定义的任何字段或列，或者名称中有拼写错误(即配置错误)的字段或列，将被忽略并替换为空值。因此，请确保正确配置列。

如果您的数据集有太多的列，并且单独配置它们变得很繁琐，您也可以批量添加列。你会在页面底部找到选项。例如，我们示例中的批量配置如下所示:

_id string, string1 string, string2 string, double1 double, double2 double
如您所见，格式非常简单。您可以指定列名，后跟一个空格，再后跟该列中的数据类型。列定义用逗号分隔。
 
第四步:分区
 
这一步有点高级，处理分区。因为我们的数据很小，也因为这超出了这篇文章的范围，我们现在跳过这一步。所以忽略这一步，确认剩下的配置。
 
您的 Athena 查询设置现在已经完成。您将被带到查询页面。这里，您将获得 CREATE TABLE 查询，该查询用于创建我们刚刚配置的表。您不必运行这个查询，因为表已经创建并在左窗格中列出。此处显示的查询仅供您参考。也许下次您可以手动创建这个查询，而不是在控制台中经历三到四个步骤。
 
现在剩下的就是查询表，看看我们的配置是否合适。为了测试这一点，我们将运行这个简单的 SQL 查询:
 
select * from sampledata limit 10;
运行该查询后，您的输出应该类似于下面的屏幕截图。
 
我们甚至可以在这个数据集上运行聚合查询。这里有几个例子:
 
select avg(double1) from sampledata;
select sum(double2) from sampledata limit 20;
差不多就是这样。现在，您可以在 Athena 的 S3 中对基于文件的数据源运行 SQL 查询。当你必须分析在 S3 以多个文件形式存储的大量数据集时，这非常方便。根据数据在文件中的分布方式和文件格式，您的查询将非常高效。你可以在 S3 查询数百 GB 的数据，并在几秒钟内返回结果。甚至包含多个连接的复杂查询也能很快返回。或许我们改天会更详细地讨论这个问题。
 
 
3 在 Twitter 上关注我，了解更多数据科学、机器学习，以及通用技术更新。此外，你可以关注我的个人博客，因为我在 Medium 之前发布了许多我的教程、操作方法帖子和机器学习的优点。
 
如果你喜欢我在 Medium 或我的个人博客上的帖子，并希望我继续做这项工作，请考虑在 Patreon 上支持我。
 
查询分段和拼写纠正
 
 
原文：https://towardsdatascience.com/query-segmentation-and-spelling-correction-483173008981?source=collection_archive---------17-----------------------
 
在英语中，人们通常输入由空格分隔的查询，但有时不知何故，这个空格被无意中遗漏了。找到单词边界的方法被称为查询分割。例如，我们可以很容易地破译
 
 
坚果巧克力
 
 
无坚果巧克力
 
但是，机器不能，除非我们教他们。这里有一个证据:
 
Showing results of an unsegmented search query
 
因为我们没有失去我们的能力，我们的大脑不知何故直觉地和无意识地这样做。但是，在搜索领域，它会影响没有正确分割的特定查询的结果的精确度和召回率。让我们看看如何:
 
电子商务中的搜索引擎特别是基于倒排索引的，应该有索引的查询或者分析器【比如子字符串等等。]必须在索引链接到特定产品列表的产品属性时使用。但是，问题依然存在，这主要与查准率和查全率有关。如果我们将上述查询分为三部分，那么我们可以对三个查询词进行布尔搜索[使用 AND],即“nut”、“free”和“chocolates ”,结果是三个结果交集的产品列表，即只返回三个列表中包含的产品。因此提高了精度。
该查询也可能拼写错误
 
 
例如“nutfreechacolatas”或“skommedmilk”
 
在这里，我们可以看到巧克力的拼写是错误的。但是，为了纠正这一点，前提条件是识别分段，即单词边界，以便首先为拼写纠正算法提供输入。
 
No Results for an unsegmented query having misspelled words
 
3.在基于机器学习 NLP 的 查询理解 **，**我们需要将正确分段和正确拼写的查询馈送到模型中，以便在找到搜索查询的意图时获得更好的准确性。我实现这些算法主要就是为了这个目的。
 
这里，我们看到拼写校正算法依赖于分词。所以，让我们先看看如何进行细分:
 
通过以几种方式分割字符串，可以实现查询分割。但是，等等，通过使用这种天真的方法，可以存在多少种可能的不同组合。实际上，它是指数的，对于长度为 n 的单词，它是{ 2^(n−1)} 可能的组合，因为对于给定的字符串将有(n-1)个边界。查询的有效和真实组合的最终列表将基于该组合是否由有效单词组成来决定，并且基于查询中最可能的单词组合(即具有最高概率的组合)来排序或分类。稍后将解释如何计算每个组合的概率。现在，使用这种简单的方法，查询“nutfreechocolates”(长度，n = 17)有 2 个⁶ = 65，536 个组合。随着查询长度的增加，它将无法扩展，并且需要大量的计算能力。为了更高效，我分析了两种算法:
 
动态编程方法:
 
在朴素方法中，我们做了一些类似的计算，一次又一次地寻找查询的前缀的最可能的段，该段可以被记忆以改进从指数(O(2^n)到多项式函数(O(n))的复杂性。我们通过一个例子来了解一下:
 
For query: **“isit” [Total Segment = 2^3 = 8]** It can be either segmented in 2 parts or 3 parts or 4 partsStart with 4: [Possible composition = 3C3 = 1]
"i" "s" "i" "t = P(i|'')*P(s|i)*P(i|t)*P(t|i)Start with 3: [Possible composition = 3C2 = 3]
"i" "s" "it" = P(i|'')*P(s|i)*P(it|s)
"is" "i" "t" = P(is|'')*P(i|is)*P(t|i)
"i" "si" "t" = P(i|'')*P(si|i)(P(t|si)"Start with 2: [Possible composition = 3C1 = 3] 
"i" "sit" = P(i|'')*P(sit|i)
"is" "it" = P(is|'')*P(it|is)
"isi" "t" = P(isi|'')*P(t|isi)where P(A|B) is conditional probability of happening of A given that B has already occured. The bigram probability is introduced for more context. Unigram probability can also be used to find the probability of composition.
这里，通过使用蛮力方法计算了 8 个组成。为了使用 DP 避免这种情况，每次在我们的程序进行递归调用来分割剩余的字符串之前，我们都要检查这个精确的子串以前是否被分割过。如果是这样，我们只需消除递归调用，并从缓存中检索该子串的最佳分割结果(在特定子串第一次被分割时存储在缓存中)。
 
在计算每个单词的概率得分时，我们假设这个单词是有效的，并且存在于字典中(如果这个单词无效，那么我们需要在这里应用拼写纠正)。一个单词的分数将是:
 
 
p(A)= freq(A)/freq 之和(所有字)
 
 
而 P(composition)= log(P(word 1))+log(P(word 2))+…其中组合由单词 1、单词 2 等组成。
 
 
因为，合成的朴素贝叶斯概率将是独立单词概率的乘积，即 P(AB) = P(A) * P(B)
 
如果这个词在字典中不存在，那么按照http://norvig.com/ngrams/ch14.pdf
 
 
P(A) = 10 /(频率(所有字的总和)* 10^len(A))
 
代码可以在这里找到:https://github.com/grantjenks/python-wordsegment
 
三角矩阵法；
 
代替记忆查询的前缀的所有组成，这里只有具有最高概率的前缀组成将被较低概率覆盖。这种方法在这里得到了更好的解释:https://towardsdatascience . com/fast-word-segmentation-for-noise-text-2c 2c 41 f 9 E8 da
 
S pelling 校正也可以使用许多方法来完成。但是，它们可能非常昂贵。在这里，我将讨论除简单方法之外的两种优化方法:
 
Peter Norvig 方法:它包括通过对每次迭代中提供的查询使用插入、删除、替换和转置操作来生成 n 个编辑距离之外的候选项。然后，语言模型，其中如果在字典中找到，则计算在第一步中生成的可能候选的得分/概率，以及错误模型，其中字典中没有找到的单词将经历插入、删除、替换和换位操作的又一次迭代，并且将再次应用语言模型。但是，这是非常昂贵的，因为每次编辑生成的候选列表对于每个单词都会增加(54 n +25)倍。对于我们示例中的查询“nutfreechacolatas ”,长度为 17。因此，在计算编辑的第一次迭代中，将有 5417+25 = 943 个候选项。同样，在每个候选的第二次迭代中，可能的候选将是 54943+25 = 50，947。因此，它不会随着编辑距离的增加和查询时间的延长而扩展。
使用对称删除的拼写校正【sym spell】:这里，通过在在线处理查询之前使用预处理，已经优化了复杂度。在生产场景中，预处理任务需要时间，并且依赖于字典的大小，因此我们可以创建拼写纠正类的单例类，该类在第一次尝试创建字典的对象时加载字典。主要思想是通过仅从字典中删除查询中的字符以及要被纠正的给定查询并在中间相遇来生成候选。这里的四个操作将按以下方式处理:
 
a)删除和插入:从字典中删除一个字符相当于在给定的查询中添加一个字符，反之亦然。
 
 
删除(字典条目，编辑距离)=输入条目
 
 
字典条目=删除(输入条目，编辑 _ 距离)
 
b)替换和换位:从字典和给定查询中删除一个字符相当于替换，从字典和给定查询中删除两个连续字符相当于换位操作。
 
 
删除(字典条目，编辑距离)=删除(输入条目，编辑距离)
 
在这种方法中，我们需要计算由给定查询的删除操作生成的候选词和也由删除操作形成的词典词之间的编辑距离，因为编辑距离可能在两侧同时删除期间改变。比如对于单词:bank，经过预处理后，在字典中，bank = ban[编辑距离= 1]并且如果给定查询=“xban”。关于给定查询的删除，xban = ban[编辑距离= 1]，但是 bank！=xban，因为两者之间的编辑距离为 2。
 
有几种计算编辑距离的方法:
 
汉明距离:它只允许替换，因此，它只适用于相同长度的字符串。
最长公共子序列(LCS) :只允许插入和删除。
Levenshtein 距离:允许插入、删除、替换，但不允许换位。即转换 AC- > CA 将被替换计为 2 编辑距离。
Damerau Levenshtein 距离:它允许我们正在进行的所有四种操作，以便生成候选。实际上，这种算法有两种变体:a)受限 Damerau-Levenshtein 距离(最优字符串对齐算法):相邻换位计为 1 次编辑，但子字符串不能编辑多次:ed(“CA “，” ABC”) =3，有 2 次替换(CA- > AC)和 1 次插入(AC- > ABC)。b)真实 Damerau-Levenshtein 距离:相邻的转座算作 1 次编辑，子串可以编辑多次:ed(“CA “，” ABC”) =2 带 1 次转座(CA- > AC)和 1 次插入 AC- > ABC。后者正在实施中。
 
使用真实 Damerau-Levenshtein 距离计算编辑距离的代码:可在此处找到:https://github . com/mammothb/symspellpy/blob/master/symspellpy/edit distance . py
 
这里，不是使用 2-d DP 来计算编辑距离，而是使用两个大小等于查询长度的 1-d 数组。在空间复杂度方面，这里进行了另一层优化。详细概述可以在这里找到:https://www . code project . com/Articles/13525/Fast-memory-efficient-Levenshtein-algorithm-2
 
该算法经过优化，具有恒定的时间复杂度。字典中所有可能删除的单词都被散列，并用它们的原始单词列表进行索引，以使搜索更快。该词典是通过使用三个来源创建的:1 .产品的品牌名称，2。产品的显示名称，3。先前搜索的前 n 千个关键字。
 
 
对于我们的用例，字典中包含大约 350，000 个单词，前缀长度 7 用于候选生成，对于平均长度为 8 个字符的查询，平均花费 5 ms。
 
感谢阅读。请务必阅读以前的故事，以了解更多信息，并继续关注空间的更多更新。
 
参考资料:
 
https://en . Wikipedia . org/wiki/damer au % E2 % 80% 93 levenshtein _ distance
【https://en.wikipedia.org/wiki/Levenshtein_distance
https://github.com/mammothb/symspellpy
https://towards data science . com/symspellcompound-10 EC 8 f 467 c 9 b
https://towards data science . com/fast-word-segmentation-for-noise-text-2c 2c 41 F9 E8 da
https://towards data science . com/sym spell-vs-bk-tree-100 x-faster-fuzzy-string-search-spell-checking-C4 F10 d 80 a 078
https://medium . com/@ wolfgarbe/1000 x-faster-spelling-correction-algorithm-2012-8701 fcd 87 a5f
http://norvig.com/ngrams/ch14.pdf
 
结合使用 Python 和 SQL 查询英超联赛
 
 
原文：https://towardsdatascience.com/querying-the-premier-league-using-python-and-sql-combined-501cb9d9319a?source=collection_archive---------14-----------------------
 
通过 Python 从 Excel 到 MySQL，然后再回到 Excel
 
Image Courtesy of Chaos Soccer Gear via Unsplash
 
有时将 Excel 表格转换成 MySQL 数据库可能很有用。这种转换将允许使用简单的 SQL 查询来执行查询操作。使用 Python，我们可以简单地将有限的 Excel 电子表格转换成 MySQL 数据库。
 
为了证明这是可能的，我将使用一个体育的例子。目睹了利物浦在欧洲冠军联赛(07/05/19)中击败巴塞罗那的胜利表现，我将选择一个离家近的例子，英超积分榜。
 
通过 Python 从 Excel 到 MySQL
 
我首先下载英超联赛表，并将其填充到一个 Excel 文件中，如下所示。重要的是，我将这个 Excel 文件保存为一个“逗号分隔值文件 (csv) ”。
 
首先，我使用 打开 函数和 read()方法 读取这个’ Premier_league.csv '文件作为字符串， fString 。然后，我创建一个空列表，并在每个新行字符处分割这个字符串。然后，我在字符串中每个指定的逗号处进一步拆分该行，并添加到我的 fList。为了验证，我打印了我的列表。在这里，我可以看到我有一个嵌套列表，fList 的第一个元素代表列，第二个元素代表占据第一名的团队，以此类推。
 
接下来，我需要连接到我的数据库管理系统(DBMS)。为了实现这一点，我使用 pip 命令安装 mysql-connector，并将这个模块导入到我正在处理的脚本中。为了确认到 MySQL 的连接，我打印出 MySQLConnection 对象，该对象返回一个我的连接内存中的对象，确认连接已经建立。
 
我现在创建一个游标，用游标的***execute method()***创建我的数据库，‘football _ db’。当我切换到我的 MySQL 工作台，并刷新模式图标时，我可以看到我的数据库现在出现了！
 
确认了数据库配置后，我现在可以开始创建我的表了。首先，我需要为表创建列。我可以使用子字符串符号来分配我的每个列名。这也有助于提高可读性。例如,“Played”列对应于前面提到的嵌套 fList 中的元素号 0，在这个子列表中，它又对应于第一个元素[0]。
 
然后，我使用“创建表格”命令创建一个表格，并将其命名为 Football，因为这似乎是合适的。因为这个表列条目语句分布在几行中，所以我用三个字符串将它们括起来。对于每一列，我使用了使用 的替换字段语法。format() 方法，并为我的每一列分配一个合适的数据类型。例如,“已踢比赛”列的数据类型为“int ”,字符数限制为 2，这是基于每支球队在整个赛季中最多踢 38 场比赛。最后，我执行表生成，并切换到 MySQL Workbench 进行确认。
 
足球表中的列建立后，下一个目标是将每个队的行插入到表中。然而，这里必须小心。有必要删除第一行 fList[0]，因为再次向表中插入列是没有意义的。
 
为了插入包含所有团队数据的行，我创建了一个名为“rows”的空字符串。然后，我使用 for 循环遍历 fList，并用括号替换方括号。这里使用另一个 if 语句在字符串中的所有行条目之间添加一个逗号。
 
接下来，我使用带有“VALUES”的“INSERT INTO”命令，将我的行连接到该语句，然后将该语句传递给游标的 execute 函数，然后将该函数提交给数据库。接下来，我需要通过再次切换到我的工作台并查看我的表来确认一切正常。
 
完美！现在我们可以开始在足球桌上执行查询了。首先，让我们看看谁在这个赛季赢了不到 15 场比赛，但累积了超过 45 分。我们只需在 WHERE 子句中定义条件语句，结果就会出现。
 
我们还可以使用一些 SQL 聚合函数来挖掘数据。例如，让我们通过检查联盟中的球队数量来确认事情正在进行。此外，让我们确定英超联赛中每支球队赢得的最少比赛，最高进球以及平均平局数。
 
将输出导出回 Excel
 
最后，如果我们能以上面显示的格式将这些数据导出到 Excel，那就太好了。虽然使用上面显示的导出选项卡很容易做到这一点，但作为奖励，我将演示如何用 Python 简单地编写这一点。
 
我首先决定我的文件名’ my_football_stats ，并将其保存为一个 CSV 文件。然后，我在“写”模式下打开这个 CSV 文件，并创建一些标题，写入我的文件。接下来，我执行我的 SQL 查询，并在 cursor.fetchall()中捕获输出，我将它分配给变量 result。结果的类型是一个列表。这意味着我可以通过索引结果列表从列表中提取元素。行[0]对应于队的数量，行[1]，赢得的最少游戏等等。
 
当我运行这个脚本时，我可以检查我的目录中的文件，'my _ football _ stats【T1]'并读取 Excel 文件，如下所示。
 
本教程已经展示了我们如何完成一个完整的循环。首先，从一个 Excel 文件开始，我们可以将它转换成一个数据库表，以便在数据库管理系统中进行查询。然后，我们可以输出我们希望运行回 Excel 的任何查询，以完成我们的转换。虽然使用 Python 的 Pandas 库可以做到这一点，但是通过创建关系表可以很容易地构建这个例子。例如，我们可以使用团队的名称作为惟一的 ID，并开始连接到特定于该团队的其他表。这样，我们就可以创建强大的关系数据库。
 
棋盘游戏问答
 
 
原文：https://towardsdatascience.com/question-answering-for-board-games-17065e17d935?source=collection_archive---------17-----------------------




    
 
建立一个问答系统来使用棋盘游戏规则手册
 
Photo by Christopher Paul High on Unsplash
 
什么是问答系统？
 
在自然语言处理中，我们不仅试图解释单词之间的关系，而且希望建立对文本的机器理解。问答是一门特殊的学科，旨在建立自动回答问题的系统，这些问题可以从文本中的信息得到回答。目标是回答一系列问题(事实、列表、定义等)。)通过返回相应的文本部分。可以想象，拥有一个分析问题和文本语义的模型是相当复杂的。最近的发展语言建模(如 BERT)有助于使这样的任务更加精确和健壮。
 
当考虑问答系统时，需要理解的一个更广泛的范例是开放域和封闭域。顾名思义，开放领域寻求解决任何问题，而封闭领域专注于某一特定领域。想想维基百科上的信息差异吧，它涵盖了所有的内容，而伍基培百科上的信息都是关于星球大战的。各有各的效用，只是看你的目标是什么。
 
因此，问题回答系统听起来相当惊人，但请注意，像许多其他自然语言处理领域一样，它仍在发展，也有不足之处。我不会在这里详细说明，但是如果你感兴趣，我鼓励你阅读文章 关于语义网中问答挑战的调查。 它很好地概述了这些系统仍然面临的一些挑战。
 
有哪些应用？
 
创建和支持一个问答系统可能是一项严肃的工作，所以首先花点时间思考为什么要创建它们是很重要的。最实际的用途之一是创建聊天机器人。我知道，我知道，他们不是每个人都喜欢的机械助手。不过，它们确实有潜力帮助客户或处理特定领域的问题，否则就像许多人担心的那样，需要人们实际阅读一些东西。
 
制作你自己的
 
您可以想到许多场景，其中您有一些文本形式的信息，并希望使其易于搜索，所以让我们尝试一个想法。自然地，我的大脑去了最实际的用途，棋盘游戏规则！
 
我经常玩游戏，偶尔会玩一些更复杂的策略游戏。有时候像这样的游戏的问题是所有的工作都投入到实际上知道如何玩它们。人们很容易忘记不同规则的复杂性，忘记发牌的数量，甚至忘记如何知道游戏何时结束。还有一个个人的烦恼是，当你想做一个战略性的举动，但想确保它是合法的，所以你必须查找它，并给别人一个机会来判断你在做什么。
 
如果你有一个工具，任何人都可以问一个问题，找到特定的规则，而不必手动挖掘文本，会怎么样？听起来像一个问题回答系统的情况！
 
为此，我们将使用一个名为 cdQa 的 Python 包。它有一套强大的功能来构建、注释和查询你自己的封闭领域问答系统。首先，您导入 cdQa 和一些不同的工具:
 
import pandas as pd
from cdqa.utils.converters import pdf_converter
from cdqa.utils.filters import filter_paragraphs
from cdqa.utils.download import download_model
from cdqa.pipeline.cdqa_sklearn import QAPipeline
pdf_converter:从 pdf 中提取文本(这个特定的转换器需要一个文件夹)。在本例中，我有一个名为“rules”的几个游戏的 rulebook pdfs 文件夹，将按如下方式实现:
 
boardgames_df = pdf_converter(directory_path=’rules/’)
filter_paragraphs:缩小范围，只在我们的文本中找到段落(本质上是在文本中寻找某个长度或其他参数)。要使用，您需要给它创建的整个数据帧:
 
boardgames_df = filter_paragraphs(boardgames_df)
download_model:找一个预先训练好的模特。我们将使用的模型是一个预训练的 BERT 模型，在 SQuAD 1.1、上进行微调，这是一个阅读理解数据集，通常用于测试和基准测试问答系统的表现。要下载名为“models”的文件夹中的商店:
 
download_model(model=’bert-squad_1.1', dir=’./models’)
QAPipeline:创建我们的 QA 系统。这将使用预先训练的模型使管道适合您的语料库。
 
cdqa_pipeline = QAPipeline(reader='models/bert_qa_vCPU-sklearn.joblib')
cdqa_pipeline.fit_retriever(boardgames_df)
厉害！我们现在准备测试我们的 QA 系统。为了询问和查看我们的结果，我们使用管道实例的predict方法，该方法返回一个包含答案、文档标题、段落和分数的元组。以下是一个搜索示例:
 
query = 'How do you win at Villianous?'
prediction = cdqa_pipeline.predict(query)
print('Query: {}\n'.format(query))
print('Answer: {}\n'.format(prediction[0]))
print('Paragraph: {}\n'.format(prediction[2]))*Query: How do you win at Villianous?
Answer: you must explore your character’s unique abilities and discover how to achieve your own story-based objective
Paragraph: To win, you must explore your character’s unique abilities and discover how to achieve your own story-based objective. Each Villain Guide will inspire you with strategies and tips. Once you’ve figured out the best way to play as one Villain, try to solve another. There are six different Villains, and each one achieves victory in a different way!™*
看起来不错！对于我的进一步实现，我实际上更喜欢只返回段落，因为对于某些规则来说，拥有额外的上下文是有帮助的。cdQa 还有一些其他非常好的特性，比如能够手动注释文本，以及轻松导出管道以在网站上使用，所以我鼓励进一步探索它。
 
我将继续自己的工作，但是要查看这里显示的代码，你可以访问我的 GitHub 页面。
 
企业用例的问题解答
 
 
原文：https://towardsdatascience.com/question-answering-for-enterprise-use-cases-70ed39b74296?source=collection_archive---------32-----------------------
 
在企业领域回答用户的问题仍然是一个具有挑战性的命题。企业越来越多地转向自动聊天助手来处理技术支持和客户支持交互。但是，这些工具只能成功地对它们接受过培训的问题进行故障诊断，这暴露了当今企业问答(QA)技术面临的日益严峻的挑战。
 
为了解决这个问题， IBM Research AI 推出了一个名为 TechQA 的新排行榜，它使用了来自用户在 IBM DeveloperWorks 上发布的真实问题。TechQA 的目标是促进对企业 QA 的研究，从相对较小的一组 QA 对中学习是更现实的情况。
 
TechQA 是首个解决企业 QA 用例的排行榜。IBM Research AI 预计将从企业领域创建额外的用例，以促进对这一关键能力的额外研究。
 
QA 背景
 
我们可以根据问题的特点和对应的答案来区分以下几类 QA 问题。相对较短的问题(少于 12 个单词)与较长的问题(从 10 到 50 个单词或更多)有很大的不同。)如今，在 IT 等企业支持环境中，更长的问题会越来越多，典型问题的中值长度为 35 个单词。
 
答案也可以被分割成 I)一个到大约五个单词的短(仿真陈述)连续文本跨度，ii)从大约六个单词到一个句子的更长的答案，或者 iii)甚至更长，例如一个到几个段落。在 IT 支持中，答案的中值长度约为 45 个词。
 
现有 QA 排行榜
 
简短问题/简短回答语料库的例子是成功的 SQuAD v1.1(大约 70 个提交)和 v2.0(大约 60 个提交)阅读理解排行榜[i，ii]，其中提供了维基百科的一段话以及一个问题，例如“哪个 NFL 队在超级碗 50 上代表了 AFC？”。在大约两年的时间里，该系统从 50 年代中期改进到 90 年代中期，代表了任务的相对快速进展。
 
然而，在 v1.1 版上表现最好的系统非常弱，当问题被稍微修改为在提供的文档中没有答案时就崩溃了。当用对抗性问题进行测试时(当大约 50%的问题在文章中没有答案时)，F测量性能下降超过 20 点。
 
SQuAD v2.0 是 2018 年年中推出的，带着这样的对抗性问题。F 测量值开始时大约为 70%,在大约一年的时间里迅速提高到大约 90%。然而，由于数据中的基本设计缺陷，即使是顶级的 SQuAD v2.0 系统对于现实世界的应用来说也仍然很弱。也就是说，这些问题是在“机械怪人”看了包含答案的文章后产生的。这种观察偏差造成了问题中的单词和答案的上下文之间的高度重叠。
 
为了解决这种观察偏差，通过收集用户对谷歌搜索引擎的问题，然后使用 turkers 找到答案，创建了一个名为 Natural Questions [iii]的新排行榜。当在自然问题排行榜上测试团队系统时， F 度量急剧下降到 6%(在简答题上——对于团队 1.1 版系统是 2%)，这说明了团队训练系统的脆弱性。
 
自然问题排行榜上的最高评分系统目前在 IBM Research AI GAAMA 系统[iv]在不到六个月的时间里(2019 年 7 月)达到了大约 60%的简短答案的 F 测量值，自 2019 年初开始在 F 测量 52%的简短答案以来。IBM Research AI 正在继续监控这些系统，看看它们需要多长时间才能在这项任务上接近人类的表现。
 
另一个需要考虑的方面是:证明(或找到)一个答案可能需要从不同的文档中找到几个片段来确定正确的答案。这就是所谓的多跳问答任务。HotpotQA [v]是一个排行榜，关注需要几个部分来确定答案的问题。在一年多一点的时间里，F 指标从 52%提高到 71%。然而，HotpotQA 受到观察偏差问题的困扰，该问题是在阅读包含答案的文档后产生的。
 
IBM Research AI TechQA 语料库
 
TechQA 语料库强调了自动化客户支持领域的两个现实问题。首先，它包含用户在技术论坛上提出的实际问题，而不是专门为竞赛或任务生成的问题。其次，它具有真实世界的规模— 600 个培训、310 个开发和 490 个评估问题/答案对—因此反映了在企业用例环境中创建标记数据集的成本。
 
因此，TechQA 旨在刺激领域适应方面的研究，而不是作为从头构建 QA 系统的资源。该数据集是通过在 IBM Developer 和 IBM DeveloperWorks 论坛上搜索已发表的 IBM Technote(解决特定技术问题的技术文档)中的问题及其公认答案而获得的。
 
除了问答对之外，TechQA 还提供了大约 80 万条公开可用的 Technotes 作为配套资源，以支持领域适应研究(例如，预训练/微调上下文相关的向量嵌入)。
 
对于 TechQA 来说，基于 IBM Research AI 针对自然问题的简短答案的顶级 performing⁴ GAAMA 系统，答案的 F 度量为 53%,略高于总是回答 No_answer 的系统的 50%。GAAMA 系统在 TechQA 训练集(600 个 QA 对)上进行了微调。)
 
关于 TechQA 任务和排行榜的更多细节可以在 ibm.biz/Tech_QA 的找到。
 
[i] Pranav Rajpurkar、、Konstantin Lopy-rev 和 Percy Liang。小队:机器理解文本的 10 万+题。2016 年自然语言处理经验方法会议论文集，2016。
 
[ii]知道你所不知道的:无法回答的问题。Pranav Rajpurkar，Robin Jia 和 Percy Liang。2018 年计算语言学协会第 56 届年会论文集。
 
【三】自然问题:问答研究的标杆。汤姆·科维亚特科夫斯基、詹尼玛利亚·帕洛玛基、奥利维亚·雷德菲尔德、迈克尔·科林斯、安库尔·帕里克、克里斯·阿尔贝提、丹妮尔·爱泼斯坦、伊利亚·波洛苏欣、马修·凯尔西、雅各布·德夫林、肯顿·李、克里斯蒂娜·n·图塔诺瓦、Llion Jones、张明伟、戴、雅各布·乌兹科雷特、阔克·勒、斯拉夫·彼得罗夫。计算语言学协会汇刊，2019。
 
[iv]首席财务官:构建生产 NLP 系统的框架，Rishav Chakravarti，Cezar Pendus，Andrzej Sakrajda，Anthony Ferritto，潘麟，Michael Glass，Vittorio Castelli，J . William Murdock，Radu Florian，Salim Roukos，Avirup Sil。2019 自然语言处理经验方法会议录(EMNLP)，Demo Track，2019。
 
[v] HotpotQA:一个用于多样化、可解释的多跳问题回答的数据集，杨，彭琦，张赛正，Yoshua Bengio，，Ruslan Salakhutdinov，Christopher D. Manning2018 自然语言处理经验方法会议论文集，2018 年 10-11 月。
 
[1]“丹佛野马”是摘录的答案。
 
[2]请注意，最先进的红色曲线上的蓝点代表最早达到相应最先进水平的时间。
 
[3]这些多跳问题在创建自然问题排行榜时已被删除。
 
[4]截至 2019 年 10 月 28 日排行榜在https://ai.google.com/research/NaturalQuestions
 
伯特、XLNET、XLM 和迪沃伯特使用简单变压器回答问题
 
 
原文：https://towardsdatascience.com/question-answering-with-bert-xlnet-xlm-and-distilbert-using-simple-transformers-4d8785ee762a?source=collection_archive---------7-----------------------
 
问题:如何使用变形金刚进行问答？回答:简单的变形金刚，咄！(看到我在那里做了什么吗？)
 
Photo by Camylla Battani on Unsplash
 
自然语言处理中的问题回答
 
 
背景:问答(QA)是信息检索和自然语言处理(NLP)领域中的一门计算机科学学科，它涉及到构建自动回答人类用自然语言提出的问题的系统。
 
 
人类:什么是问答系统？
 系统:自动回答人类用自然语言提出的问题的系统
 
QA 在大量的任务中有应用，包括信息检索、实体提取、聊天机器人和对话系统等等。虽然回答问题可以有多种方式，但最常见的问答方式可能是从给定的上下文中选择答案。换句话说，系统将从正确回答问题的上下文中挑选一个范围的文本。如果无法从上下文中找到正确答案，系统将只返回一个空字符串。
 
使用预先训练的 Transformer 模型进行迁移学习在 NLP 问题中已经变得无处不在，问答也不例外。考虑到这一点，我们将使用 BERT 来处理问答任务！
 
我们将使用简单变形金刚库来轻松处理变形金刚模型。
 
 [## ThilinaRajapakse/简单变压器
 
这个库是基于 HuggingFace 的变形金刚库。简单的变形金刚让你快速训练和…
 
github.com](https://github.com/ThilinaRajapakse/simpletransformers)
 
简单的变形金刚是建立在高超的拥抱脸变形金刚库之上的。
 
从这里安装 Anaconda 或 Miniconda 包管理器。
创建新的虚拟环境并安装软件包。
 conda create -n simpletransformers python pandas tqdm
 conda activate simpletransformers
 如果使用 cuda:
 conda install pytorch cudatoolkit=10.0 -c pytorch
 其他:
 conda install pytorch cpuonly -c pytorch
 conda install -c anaconda scipy
 conda install -c anaconda scikit-learn
 pip install transformers
 pip install seqeval
 pip install tensorboardx
如果您使用 fp16 培训，请安装 Apex。请遵循此处的说明。(从 pip 安装 Apex 给一些人带来了问题。)
安装简单变压器。
 pip install simpletransformers
 
我们将使用斯坦福问答数据集(SQuAD 2.0) 来训练和评估我们的模型。SQuAD 是一个阅读理解数据集，也是 QA 模型的标准基准。该数据集在网站上公开提供。
 
下载数据集并将文件(train-v2.0.json，dev-v2.0.json)放在data/目录中。
 
为了在简单的转换器中执行 QA，数据必须以正确的格式保存在 JSON 文件或 Python 字典列表中。
 
如果使用 JSON 文件，这些文件应该包含一个字典列表。字典代表一个上下文及其相关的问题。
 
每个这样的字典包含两个属性，"context"和"qas"。
 
context:提问的段落或文本。
qas:问答列表。
 
问题和答案被表示为字典。qas中的每个字典都有以下格式。
 
id : (string)问题的唯一 ID。在整个数据集中应该是唯一的。
question:(字符串)一个问题。
is_impossible : (bool)表示是否能从上下文中正确回答问题。
answers:(列表)问题正确答案列表。
 
单个答案由具有以下属性的字典表示。
 
answer:(字符串)问题的答案。必须是上下文的子字符串。
answer_start : (int)上下文中答案的起始索引。
 
我们可以很容易地将球队数据转换成这种格式。
 
Simple Transformers 有一个类，可以用于每个受支持的 NLP 任务。这个类的对象用于执行训练、评估(当基本事实已知时)和预测(当基本事实未知时)。
 
这里，我们创建一个QuestionAnsweringModel对象，并设置超参数来微调模型。第一个参数是型号类型，第二个是型号名称。
 
args参数接受一个可选的 Python 字典，其中包含超参数值和配置选项。我强烈推荐在这里查看所有选项。
 
默认值如下所示。
 
要加载一个先前保存的模型而不是默认模型，您可以将 model_name 更改为包含已保存模型的目录的路径。
 
model = QuestionAnsweringModel('bert', 'path_to_model/')
训练模型是一行程序！只需将train_data传递给train_model函数。
 
您还可以通过向train_model方法传递一个包含相关属性的dict来更改超参数。注意，这些修改将持续甚至在训练完成后。
 
train_model方法将在每 n 步创建一个模型的检查点(保存)，其中 n 为self.args['save_steps']。训练完成后，最终模型将保存到self.args['output_dir']。
 
dev 数据的正确答案没有在小队数据集中提供，但是我们可以将我们的预测上传到小队网站进行评估。或者，您可以将训练数据分成训练和验证数据集，并使用model.eval_model()方法在本地验证模型。
 
对于本指南，我将简单地把预测上传到小队。
 
分解这些代码，我们读入开发数据，将其转换成正确的格式，获得模型预测，最后以所需的提交格式写入 JSON 文件。
 
使用这些超参数获得的结果如下所示。
 
"exact": 67.24500968584182, 
"f1": 70.47401515405956, 
"total": 11873, 
"HasAns_exact": 64.1025641025641, 
"HasAns_f1": 70.56983500744732, 
"HasAns_total": 5928, 
"NoAns_exact": 70.3784693019344, 
"NoAns_f1": 70.3784693019344, 
"NoAns_total": 5945
小队 2.0 是一个具有挑战性的基准，这反映在这些结果中。一些超参数调整应该会提高这些分数。同样，使用一个large模型而不是base模型也会显著提高结果。
 
问题对识别
 
 
原文：https://towardsdatascience.com/questions-pairs-identification-f8abcafb5b17?source=collection_archive---------7-----------------------
 
没有愚蠢的问题…只有重复的问题！
 
你有一个迫切的问题——你登录 Quora，发布你的问题，然后等待回复。有可能你问的确实是独一无二的，但通常如果你有问题，别人也会有。你有没有注意到 Quora 告诉你一个类似的问题已经被问过了，并且给了你链接让你直接找到它？Quora 如何发现你刚才问的问题与之前已经问过的其他问题相匹配？
 
出于对这个问题的好奇，我和我的团队——Jui Gupta、 Sagar Chadha 、崔婷 Zhong 决定参加 Kaggle Quora 重复问题挑战赛。目标是使用复杂的技术来理解问题语义并突出重复(相似)的问题。
 
但是为什么一个公司想要强调重复的问题呢？
 
更便宜的数据存储 —存储更少的问题！很明显！
改善的客户体验 —更快地回答问题。
重复使用内容 —如果一个问题之前已经回答过，那么对一个类似的问题使用相同的答案是非常高效的。
 
数据集由大约 400，000 对问题组成，以 6 列的形式组织，如下所述-
 
id: 行 id
 
qid 1，qid 2: 问题对中每个问题的唯一 id
 
问题 1，问题 2: 问题的实际文本内容。
 
is_duplicate: 对于语义不同的问题，标签为 0，对于本质上只有一个答案的问题(重复问题)，标签为 1。63%的问题对是语义不相似的，37%是重复的问题对。
 
A look at the data
 
数据探索
 
一项数据分析显示，问题中最常见的单词如下-
 
Word cloud for most common words
 
标记为不重复的重复问题
 
我们还发现了一些问题对，虽然重复，但在标签中被标记为 0。其中一些如下所示-
 
Duplicates marked as different
 
这些问题的标签被改为 1，以提高模型的准确性！
 
检测一对问题之间的相似性的一个非常简单的方法是查看第一个问题中的独特单词，这些单词在第二个问题中也存在，作为两个问题中总单词的比率。然后，这个数字可以用在一个简单的模型中，例如逻辑回归，来预测重复问题和不同问题。
 
Word Similarity between questions
 
这种方法有局限性，因为两个几乎没有共同词汇的问题仍然有相同的意思。这可能是由于不同的句子结构、同义词的使用等。考虑句子“成为一名数据科学家需要做什么”和“成为一名优秀的数据科学家需要具备哪些素质”。虽然这些很少有共同的词(不包括停用词)，但提问者的意图是相同的。为了超越比较句子中的单词，我们需要一种方法来理解所考虑问题的语义。
 
生成句子嵌入是一个三步的过程
 
句子标记化 —使用我们数据中的所有问题，我们创建了一个大字典，将每个单词映射到一个唯一的整数索引。然后，这个字典用于将句子从字符串序列转换为整数序列。
零填充— 流程的下一步是确保模型(神经网络)的输入长度一致。为了做到这一点，我们为每个问题选择了一个最大长度——在我们的分析中是 25 个——然后将句子截断或填充到这个长度。在长度少于 25 个单词的句子的开头插入 0。
嵌入矩阵— 最后，我们使用预训练的单词嵌入将每个单词转换成向量表示。每个单词被转换成一个 300 长的向量。
 
Process to get sentence embedding
 
上面描述的过程从我们的文本数据中为问题 1 和问题 2 创建了维度为(200000，25，300)的数据张量。这有双重目的-
 
将文本字符串转换为可用于训练神经网络的数字
给出了我们的数据的表示，它对单词的含义和单词之间的关系进行了编码。利用简单的数学，我们就可以确定两个词的意思是相似还是完全相反。
 
如此创建的数据张量然后被发送通过神经网络模型进行训练，这将在下面描述。
 
包的埋设方法
 
然后，使用上述方法创建的嵌入将通过上面画出的网络传递。让我们看看上面的网络发生了什么-
 
时间分布密集层 —当我们想要对每个时间步长应用相同的变换时，这些用于时态数据。在我们的数据集中，每个问题有 25 个单词，对应 25 个时间步长。我们使用具有 300 个隐藏输入的密集层，因为我们的数据具有 300 维嵌入，所以我们得到该层的 90，000 + 300(偏差)= 90，300 个权重。问题 1 和问题 2 都通过相似的时间分布层。
 
下图清楚地表明了这种转变—
 
Time Distributed Dense Layers
 
时间分布密集层中的 300 个隐藏单元(显示为橙色)中的每一个都与每个时间步长的单词向量(显示为蓝色)相连接，并产生更高阶的表示(显示为绿色)。所有密集层单元都具有非线性的“Relu”激活。
 
Lambda 层——Keras 中的 Lambda 就像 python 中的*‘def*’关键字——它们允许我们在模型中使用自定义层。我们在时间分布密集层之后获得的较高阶表示上使用λ层，以获得问题中所有单词的平均意义。
 
Lambda layers
 
计算平均值实质上是计算问题在 300 维中的聚合表示。这在这些维度上概括了整个问题的意义。Average 只是可能的聚合之一，还有其他可能的聚合，如 max、sum 等。
 
注意力接近的双 LSTM
 
上面提到的嵌入模型架构的简单包确实达到了相当好的准确性。那为什么还要费心使用双向 LSTM 和注意力层呢？
 
当我们回去手动检查导致最高错误分类的问题对时，我们发现这主要是由于较长的句子。这是有意义的，因为我们没有考虑一种方法来捕获和实现单词，把它们从以前和将来的状态转换到我们现在的状态。这需要实现由类似 LSTMs 的网络提供的自适应选通机制。在研究中，我们幸运地发现了一篇关于使用双向 LSTMs 进行关系分类的论文，它被用于图像字幕、问题回答等任务中。
 
现在来看模型，我们所做的改变包括在单词嵌入阶段后添加一个双向 LSTM，以将更高级的特征合并到我们的嵌入向量中。在这之后，与之前我们串联问题不同，我们通过在问题对之间进行相似性来实现注意力。
 
注意力层 —与之前的单词袋不同，注意力层包括问题之间的点积计算，然后是没有任何非线性的密集层。
 
完成建模后，我们是如何评价我们的模型的？
 
由于这是一个二元分类任务，我们使用**二元交叉熵(对数损失)**来计算我们的准确度。
 
二元交叉熵:
 
基线准确率为 63%，因为我们的数据就是这样分割的。这是我们建立的模型的模型性能。
 
Model accuracy for our analysis
 
对模型使用不同的预训练嵌入。例如 Word2Vec、fasttext
在嵌入连接中尝试不同的相似性度量。例如曼哈顿距离
提取并组合其他附加的 NLP 特征。例如常用词的数量/比例
利用相同概念的另一个有趣的问题是使用上下文段落的问题回答。我们可以尝试一下。
 
这些工作没有一项是我们自己能够完成的。查看以下参考资料，获取我们使用的所有重要资源:
 
https://www.aclweb.org/anthology/P/P16/P16-2034.pdf
https://nlp.stanford.edu/pubs/snli_paper.pdf
https://www.kaggle.com/c/quora-question-pairs/data
https://github.com/bradleypallen/keras-quora-question-pairs
https://github.com/Smerity/keras_snli
https://towards data science . com/building-a-question-answering-system-part-1-9388 aad ff 507
 
请随时让我们知道您的想法和我们可以改进的方法！😃
 
使用 Python 快速收集脏数据
 
 
原文：https://towardsdatascience.com/quick-and-dirty-data-gathering-with-python-9d3d4b8cba13?source=collection_archive---------22-----------------------




    
 
前几天我去杂货店的时候，简直不敢相信自己的眼睛。另一家星巴克似乎一夜之间就在我家附近的街区开张了。还有…这家新的星巴克是 字面意思是 就在两个街区之间，每个街区都有他们自己的星巴克！
 
以新星巴克不断涌现的速度，我发现自己在想: “洛杉矶县会有多少家星巴克？”
 
快速的谷歌搜索并没有给我想要的东西。要么结果只是在洛杉矶市(而不是整个县)，要么估计值已经过时 5 年以上。我知道我必须做什么:自己收集数据！
 
我决定从访问星巴克商店定位器开始，希望它能给我需要的信息。
 
Starbucks Store Locator
 
我得到了… 有点儿 …我想要的。我发现，通过在搜索栏中键入邮政编码，我得到了以该邮政编码为中心的 100 家星巴克商店的列表。
 
通过查看页面顶部的 URL，我发现可以使用哪个 API 调用(发送到星巴克网站的命令的别称)来访问以邮政编码 90815 为中心的 100 家商店的列表:
 
 
https://www.starbucks.com/store-locator?place=90815
 
基于此，我想出了一个如何获取洛杉矶县所有星巴克门店信息的计划:
 
 
1。 获取洛杉矶所有邮政编码的列表
 
 
2。 对于每个邮政编码，调用上面的 API 并解析返回的 100 家星巴克门店
 
 
3。 从存储的大列表中删除重复项(因为一个 API 调用和下一个 API 调用之间可能有很多重叠)
 
 
4。 删除所有不在洛杉矶县的商店(因为有些邮政编码就在洛杉矶县的边界上，可能包括邻近县的商店)
 
听起来合理吗？我们开始吧！
 
首先，我想提供这个项目需要的 Python 库列表:
 
获取洛杉矶县所有邮编的列表
 
这个很简单，你可以从很多不同的来源得到这个列表。我选择了直接从县里拿。我将这些邮政编码(每行一个)加载到一个名为 laZips.txt 的文本文件中。
 
为每个邮政编码调用 API
 
接下来，我们要为我们收集的每个邮政编码调用 Starbucks Store Locator API:
 
Scraping all Starbucks stores in LA County
 
您可能已经注意到了神奇的’ processResponse '函数，它获取星巴克返回的内容，并将该文本转换成 100 家商店中每一家的信息。实际上，这只是一堆文本处理，我鼓励您查看完整的代码。
 
此时，变量 allStores 是一个商店信息列表，每个信息看起来像这样:
 
删除重复的商店
 
一个问题是，我们的星巴克门店主列表 allStores ，将包含(可能很多)重复的门店。
 
没什么大不了的！让我们遍历并删除已经遇到商店 id 的所有商店。
 
此时，变量 laStores 不包含重复的商店。
 
移除洛杉矶县以外的商店
 
我们的名单还有一个问题。邮政编码可能在洛杉矶县的郊区，因此以该邮政编码为中心的 100 家星巴克店将包括邻近县的店。我们如何解决这个问题？
 
一种选择是在我们的商店信息中使用’ City’ 字段，并将其与我们收集的洛杉矶县的一些城市列表进行匹配。这可能行得通，但我担心在我们的数据和我们从网上获取的城市名称列表之间会有轻微的差异。
 
让我们用一种更直接的方法。也就是说，我们将使用洛杉矶县的 geojson 文件(基本上是一个 json 文件，它精确地定义了一个复杂的形状，如洛杉矶县)。我会把这个文件贴在我的 GitHub 上。
 
在进行数据清理之前，让我们制作一张地图，以确保我们确实需要担心洛杉矶县以外的商店。
 
是的 …很明显，我们在洛杉矶县(以蓝色突出显示)之外有商店。让我们摆脱他们！
 
让我们使用 keepLAStores 重新生成地图:
 
耶！问题修复。
 
(我很快会写一篇关于如何创建这样的地图的教程！)
 
咻！现在我们已经完成了所有工作，让我们将数据存储在一个 csv 中，以备将来再次使用:
 
那么…洛杉矶有多少家星巴克？
 
本项目中使用的所有代码和必要文件都可以在这里找到。
 
快乐的数据采集！
 
快速代码来美化你的直方图和散点图
 
 
原文：https://towardsdatascience.com/quick-code-to-spruce-up-your-histograms-scatterplots-ca44b9e2777f?source=collection_archive---------19-----------------------
 
简单的图表是数据分析必不可少的可视化工具。如果你正开始学习如何用 Python 制作可视化效果，你可以对你的图形参数做一些小的调整，这将使它们更加突出。首先，导入 Pyplot 和 Seaborn 库。
 
选择 Matplotlib 颜色来照亮你的图表。
 
二。用选定的边缘颜色勾勒出直方图的轮廓。
 
import seaborn as sns
from matplotlib import pyplot as plt
%matplotlib inlineplt.rcParams["patch.force_edgecolor"] = True
plt.figure(figsize=(8,8)) #adjust the size of your graphsns.distplot(df["glucose"], bins= 20,color ='tomato',
hist_kws=dict(edgecolor="k", linewidth=2)) 
#modify colors, number of bins, and linewidth for custom looks
三。创建一个支线剧情网格，以便快速浏览。
 
sns.set_style('darkgrid',{'axes.edgecolor': '.9'},)
f, ax = plt.subplots(2,3,figsize = (16,7))
plt.rcParams["patch.force_edgecolor"] = True
vis1 = sns.distplot(df["pregnancies"],bins=10,color='mediumturquoise',
hist_kws=dict(edgecolor="magenta", linewidth=2.5),ax= ax[0][0])vis2 =
sns.distplot(df["glucose"],bins=10,color='mediumturquoise', hist_kws=dict(edgecolor="magenta",linewidth=2.5),ax=ax[0][1])vis3 = sns.distplot(df["bloodpressure"],bins=10,color='mediumturquoise', hist_kws=dict(edgecolor="magenta", linewidth=2.5),ax=ax[0][2])vis4 = sns.distplot(df["skinthickness"],bins=10,color='mediumturquoise', hist_kws=dict(edgecolor="magenta", linewidth=2.5), ax=ax[1][0])vis5 =
sns.distplot(df["insulin"],bins=10,color='mediumturquoise', hist_kws=dict(edgecolor="magenta", linewidth=2.5),ax=ax[1][1])vis6 =
sns.distplot(df["bmi"],bins=10,color='mediumturquoise', hist_kws=dict(edgecolor="magenta", linewidth=2.5),ax=ax[1][2])
四。选择标记形状、尺寸和色图以增加散点图和回归图的可读性。确定一个“色调”变量输入，以增加每个数据点的清晰度，或者以同样的方式使用“大小”。
 
plt.figure(figsize = (8,8))ax = sns.scatterplot(x = df.insulin, y = df.glucose, hue= df.bmi, size=df.bmi, sizes=(0,200), marker = ‘h’, palette=’plasma’, data=df)
plt.figure(figsize = (8,8))ax = sns.scatterplot(x = df.insulin, y = df.glucose, style=df.diabetes, hue=df.diabetes,palette= ‘husl’,
markers=[‘D’,’*’],size= df.diabetes,sizes=(200,100), data=df)
随机森林快速指南
 
 
原文：https://towardsdatascience.com/quick-guide-to-random-forests-5d2a6b233d1f?source=collection_archive---------40-----------------------
 
当我刚进入数据科学领域时，我听说过这些被称为随机森林的神话模型。我迫不及待地想了解更多。如果这听起来像你，请继续读下去。
 
Image source
 
很自然，在谈论森林之前，我们应该先谈谈树——也就是决策树。决策树(有时称为 CARTs，用于分类和回归树)是相对容易理解的监督机器学习模型。
 
这里有一个决策树的简单例子:根据下图，你适合还是不适合？
 
Simple Decision Tree (Image source)
 
你刚刚用决策树把自己分类为适合或不适合。我碰巧强烈反对吃披萨会让你不健康，但是嘿，这只是个例子。(在这篇文章中，我将只把这些模型作为分类器来讨论，因为这样更容易理解，但这些树模型也可以用作回归模型。)
 
决策树可以长出很多分支，直到每个分支都尽可能“纯粹”。(每个节点的纯度用基尼杂质量化。)如果让一棵树一直生长到每个叶节点都完全纯净，那么这些树就可以一直生长下去，直到它们看起来更像吊灯而不是树。
 
Overfit Decision Tree (Image Source)
 
如果决策树任其发展，你的模型将会不堪重负。有可能决策树非常适合您的训练数据，因此不会对新信息做出很好的响应。在这种情况下，这是非常典型的决策树，你的模型将有很高的误差方差。
 
随机森林是一种流行的模型，可以缓解决策树中的过度拟合问题。但是在深入研究随机森林之前，我需要说一些关于袋装决策树的事情，这是一个与随机森林密切相关的集合模型。
 
袋装决策树得名于“Boot strapAGaggregating”Bootstrapping 是替换随机抽样的实践。在数据科学中，bootstrapping 在许多不同的上下文中使用，但在这里，我们 bootstrapping 是为了生成更多的树。
 
Bootstrapping (Image source)
 
在上图中，您可以将左边的条形(有 4 个不同颜色的方块)视为原始样本。如果我们从原始样本中抽取一个相同大小的新样本，或者用替换随机抽样，我们可能会得到右边的顶条。请注意，第一个引导示例看起来与原始示例相似，但并不完全相同。然后，我们重复这个自举过程 n 次，每次从原始样本中随机取样替换，产生 n 个自举样本*。*
 
Bagging (Image source)
 
自举之后，我们有了 n 个样本，在上图中用包含圆点的圆圈表示。从每个样本中，构建一个决策树。每个决策树生成自己的预测，然后汇总这些预测以生成总体预测。回到适合与不适合模型，如果对于给定的观察，66 棵树预测为“适合”，44 棵树预测为“不适合”，则该观察的整体预测为“适合”
 
(Image sources)
 
随机森林是一种特殊类型的袋装决策树。如上图所示，简单的套袋生产的树有些不同。然而，随机森林产生的树木更加多样化。自举过程与装袋过程完全相同，因此树中的额外变化一定来自过程中的其他地方。
 
事实上，随机森林中树的额外变化来自于每棵树是如何从它的引导样本构造的。在袋装决策树中，在构建每棵树的分支时考虑所有特征，而在随机森林中，在构建每棵树的分支时仅考虑随机的特征子集。这个过程被称为随机子空间方法，它使每棵树都不会过度拟合，从而减少了由于模型中的差异而产生的误差。
 
我希望这篇关于随机森林的简要描述能让您对该模型有一些基本的了解，并对您的进一步研究有所启发！
 
快速安装指南:AWS SageMaker 上的 Nvidia RAPIDS + BlazingSQL
 
 
原文：https://towardsdatascience.com/quick-install-guide-nvidia-rapids-blazingsql-on-aws-sagemaker-cb4ddd809bf5?source=collection_archive---------19-----------------------
 
RAPIDS 于 2018 年 10 月 10 日发布，从那时起，NVIDIA 的人们夜以继日地工作，为每个版本添加了令人印象深刻的功能。当前版本( 0.9 )支持的首选安装方法是 Conda 和 Docker ( pip 支持在 0.7 中被取消)。此外，在 Google Colab 中可以免费获得 RAPIDS it，并且还支持微软的 Azure 机器学习服务。
 
然而，可能有像我一样的人想要/需要在 AWS SageMaker 中使用 RAPIDS(主要是因为我们的数据已经在 S3 上了)。 本指南旨在作为快速安装指南。它远非完美，但它可能会为您节省几个小时的试错时间。
 
我还将包括 BlazingSQL ，一个基于 cuDF 的 SQL 引擎。作为一名数据科学家，查询数据的能力非常有用！
 
在 SageMaker 上安装 RAPIDS 有两个主要要求:
 
显然你需要一个 GPU 实例。目前在 SageMaker 中只有两种类型的加速实例:ml.p2 (NVIDIA K80)和 ml.p3 (V100)实例。然而，由于 RAPIDS 需要 NVIDIA Pascal 架构或更新的架构，我们只能使用 ml.p3 实例。
RAPIDS 需要 NVIDIA 驱动 v410.48+(在 CUDA 10 中)。AWS 5 月更新了驱动。因此，RAPIDS v0.7 是可以安装在 SageMaker 中的第一个版本。
 
当前 RAPIDS 稳定版(0.9)的安装过程如下:
 
启动或创建您的 ml.p3 SageMaker 实例。一旦实例被服务打开它。在本指南的剩余部分，我将使用 JupyterLab。
在 JupyterLab 中: Git - >打开终端，打开 shell 并执行以下命令:
 
source /home/ec2-user/anaconda3/etc/profile.d/conda.sh
conda create --name rapids_blazing python=3.7
conda activate rapids_blazing 
我强烈建议创造一个新的环境。如果您尝试在 SageMaker conda python3 环境中安装 RAPIDS，将需要数小时来解决环境问题，并且还可能会产生奇怪的操作(例如，安装 RAPIDS 不支持的 python 2，等等。).
 
3.Conda 安装了 RAPIDS (0.9)和 BlazingSQL (0.4.3)以及一些其他的包(特别是需要 boto3 和 s3fs 来处理 S3 文件)以及 Sagemaker 包的一些依赖项，sage maker 包将在下一步进行 pip 安装。在 RAPIDS 版本中，dask-cudf 被合并到 cudf 分支中。解决这个环境大概需要 8 分钟:
 
conda install -c rapidsai -c nvidia -c numba -c conda-forge \
              -c anaconda -c rapidsai/label/xgboost \
              -c blazingsql/label/cuda10.0 -c blazingsql \
              "blazingsql-calcite" "blazingsql-orchestrator" \
              "blazingsql-ral" "blazingsql-python" \
              "rapidsai/label/xgboost::xgboost=>0.9" "cudf=0.9" \
              "cuml=0.9" "cugraph=0.9" "dask-cudf=0.9" \
              "python=3.7" "ipykernel" "boto3" \
              "PyYAML>=3.10,<4.3" "urllib3<1.25,>=1.21" \
              "idna<2.8,>=2.5" "boto" "s3fs" "dask" \
              "anaconda::cudatoolkit=10.0"
4.安装 Sagemaker 和 flatbuffers 包，并注册要在 JupyterLab 中使用的内核:
 
pip install flatbuffers sagemaker
ipython kernel install --user --name=rapids_blazing
5.等待大约一分钟，然后打开或创建一个新的笔记本，你应该能够选择新的内核:*内核- >改变内核- >康达 _ 急流 _ 炽热。*注意:请不要使用 rapids _ flashing 内核来代替 conda _ rapids _ blazing，因为如果使用该内核，BlazinSQL 将无法运行。
 
6.让我们首先导入 RAPIDS 和 BlazingSQL 包:
 
import cudf
import cuml
import dask
import pandas as pd
import dask_cudf
from blazingsql import BlazingContext
bc = BlazingContext()
我们应该得到一个“连接建立消息。
 
7.让我们做第一个测试来检查 cuDF 是否正常工作:
 
df = cudf.DataFrame()
df[‘key’] = [0, 1, 2, 3, 4]
df[‘val’] = [float(i + 10) for i in range(5)]
print(df)
8.测试累计:
 
df_float = cudf.DataFrame()
df_float[‘0’] = [1.0, 2.0, 5.0]
df_float[‘1’] = [4.0, 2.0, 1.0]
df_float[‘2’] = [4.0, 2.0, 1.0]
dbscan_float = cuml.DBSCAN(eps=1.0, min_samples=1)
dbscan_float.fit(df_float)
print(dbscan_float.labels_)
9.如果没有错误，我们已经成功导入并使用了基本的 cuDF 和 cuML 功能。下一步是读取和使用存储在 S3 的数据。例如，使用 gzip 压缩读取一些 csv 文件:
 
import boto3
import sagemaker
from sagemaker import get_execution_role
role = get_execution_role()
df= dask_cudf.read_csv(‘s3://your-bucket/your-path-to-files/files*.csv.gz’, compression=’gzip’)
df2=df.compute()
9.现在我们可以使用 BlazinSQL 来查询我们的数据:
 
bc.create_table(‘test’, df2)
result = bc.sql(‘SELECT count(*) FROM test’).get()
result_gdf = result.columns
print(result_gdf)
我将尝试在安装过程之外更新和扩展这个指南。同时，我得到了三个有趣的结果:
 
与 pandas read_csv 相比，cuDF (v0.10) read_csv 提高了 7 倍。
与 sklearn LogisticRegression 相比，cuML LogisticRegression 提高了 32 倍。
与非 GPU xgboost(’ tree _ method ‘:’ GPU _ hist ')相比，GPU xgboost (‘tree_method’:'hist ')性能提高了 7 倍。
 
展望未来，RAPIDS 版本将为 AWS 用户提供一些不错的特性。例如，cudf.read_csv 将能够直接读取 s3 文件，dask-cudf.read_parquet 在读取 s3 文件时的一个错误已被修复，并将包含在 0.10 中。我感谢 RAPIDS 团队对我报告的一些 github 问题的迅速关注和解决。
 
欢迎对本指南提出任何意见。愿 GPU 加速您的分析！！
 
推特:@艾文佐
 
领英:【https://www.linkedin.com/in/dr-iván-venzor-64322732/】T21
 
使用数据块激发火花的快速入门指南
 
 
原文：https://towardsdatascience.com/quick-start-guide-to-spark-with-databricks-d2d24a2f995d?source=collection_archive---------32-----------------------
 
从 Spark 获得结果只需几分钟，而不是几天
 
Apache Spark 是处理大量数据的强大框架，可能是最强大和最高效的。任何如此强大的工具都必然是复杂的，对于初学者来说可能很难使用。
 
当尝试用 Scala 开始使用 Spark 时，这种情况最为明显。很容易找到一些加载文件并运行一些查询的示例代码。但是请尝试在某个地方实际运行示例代码。
 
你可以用 sbt 构建工具在 Scala 中完成。这是一个不错的方法，但是如果你还没有准备好用 sbt 构建和运行 Scala 应用程序，安装了 Scala 和 sbt，你的计算机，可能还有一个 IDE，并且知道如何从头开始生成 sbt 项目，这可能就不那么容易了。如果你是一名 Scala 开发人员，这可能没那么难，尽管即便如此，这仍然比它需要的要难。
 
此外，在当今时代，当我们想要编写一些代码并快速获得一些结果时，我们通常不想创建一个完整的 sbt 或 Maven 或 Gradle 项目，我们只想打开一个 Jupyter 笔记本，复制并粘贴几行代码，然后按 shift 键返回。
 
但是尝试用 Scala 和 Spark 来做这件事。
 
您的第一选择可能是 Amazon Web Services 的 SageMaker，如果您正在使用 Python 和 scikit-learn，这是一个很好的选择。但是如果您正在用 Spark 做完全相同的事情——使用几乎完全相同的代码，那么祝您好运。SageMaker 中有一个 Spark 选项——但是开箱即用就不行！至少上次我尝试的时候，我得到了一个神秘的错误，然后在谷歌上搜索了一下，发现 Spark SageMaker 选项需要你创建一个 Spark 集群，并将其连接到笔记本电脑上。你知道怎么做吗？你想吗？从笔记本或错误中显然看不出来。
 
最后，你可以在你的笔记本上安装 Jupyter 笔记本，然后安装 sparkmagic 扩展(它有多个组件),然后希望所有的作品和所有的部分都以正确的方式指向彼此。我得到了这个工作，但它花了几天的时间在多方面挠头。幸运的是，他们也有一个 Docker 选项，所以如果你的笔记本电脑上安装了 Docker，你就可以(很可能)更快地完成这项工作。只要确保将一个本地目录挂载到正在运行的 Docker 实例上，这样就不会在每次重启机器时丢失您的工作！如果您还不熟悉 Docker CLI，您可能会很难学到这一课——如果您只是试图运行一些 Spark 示例代码，您可能不想考虑这一点。
 
必须有一种更好的方法来对一些本地数据运行一些 Spark 命令，幸运的是有这种方法。
 
输入数据块
 
Databricks 为 Spark 提供了 AWS 决定不提供的“像 SageMaker 一样简单”的选项。更好的是，社区版是免费的——具有讽刺意味的是，它运行在 AWS 上，AWS 本身会向您收取费用，让您做完全相同的事情，而您需要做更多的工作！
 
让我们开始吧。
 
首先，去community.cloud.databricks.com创建一个账户。单击“尝试数据块”并选择社区选项。
 
您将不得不创建一个(免费的)集群，但它只需要几次点击，如何做是非常明显的。点击左边的“集群”图标，创建一个集群，并给它一个名称，任何名称。因为这是您的第一个(目前也是唯一的)集群，所以名称是什么并不重要。您不必使用 Linux 命令行在某个文件系统中寻找它，这一切都是点击式的。
 
现在，点击左边的“数据砖块”图标，然后创建一个“新笔记本”选择 Scala 选项(除非您想要 Python ),然后选择您已经创建的集群。那是唯一的一个，所以选择它应该很容易。您可能需要单击左侧的“工作区”图标来打开笔记本，但仅此而已。现在，你有了一台运行 Scala 的笔记本，内置了 Spark。不，真的。唯一的痛苦是，只要你坚持使用免费选项，你将不得不每天重新创建一个集群(只需点击几下鼠标)。
 
为了用 Spark 做任何事情，你需要一个 SparkSession。如果您不知道这意味着什么，请不要担心——随着您对 Spark 越来越熟悉，您可以更深入地了解这一点，但目前它只是一个指向您的集群的对象，允许您运行 Spark 命令。在 Databricks 中，它只是被称为spark。你可以通过输入“spark”并按下 shift-enter 键来验证它在笔记本中是活动的。
 
如果你看到这样的东西，那么你有火花运行，你是好的。令人惊讶的是，如果你在 Databricks 之外尝试这种方法，仅仅到这里就需要做这么多的工作。
 
现在，让我们做一些有用的事情。让我们加载一些数据，提取一些见解，并保存到其他地方供以后使用。我将使用旧金山房价的一组数据，这些数据我已经用于其他项目。这只是一个简单的 CSV 文件，你真的可以使用任何 CSV 文件。
 
首先，通过点击左侧的“数据”图标，然后点击“添加数据”按钮，将文件上传到笔记本中，然后上传文件。选择并上传您的文件。请注意，您上传的文件将存储在 Databricks 系统的/FileStore/tables/[file]中。
 
我们现在可以读取文件了。
 
val df = spark
.read
.option("header", "true")
.option("inferSchema", "true")
.csv("/FileStore/tables/housing_data_raw.csv")
我在这里所做的只是告诉 SparkSession 读取一个文件，推断模式(数据的类型，例如字符串或整数)，注意 CSV 在第一行有一个头(而不是第一行的数据)，并给出文件的路径。运行该命令后，我们可以使用 Databricks 的显示功能快速查看我们的数据。
 
我们现在可以对 CSV 文件执行查询。不需要编写解析函数，不需要逐行循环。我们可以对 CSV 执行 SQL 查询。
 
首先，让我们将数据集注册为 Spark 中的临时表:
 
df.createOrReplaceTempView("mytable")
现在，我们可以直接对 CSV 文件运行 SQL 查询，就像它是一个数据库一样:
 
%sqlselect zipcode, count(zipcode) as count from mytable group by zipcode order by count;
这只是 Spark SQL 的一个示例，但这里的要点是，我们现在已经开始使用 SQL，在我们自己的沙箱中，只需几分钟就可以创建，而无需找到(或提供)关系数据库。
 
另一方面，如果您曾经花了几个月或几年的职业生涯来编写 SQL 查询，您(像我一样)可能会有许多糟糕的记忆，那就是根据用户输入将越来越复杂的变量串在一起。这些既难看又麻烦，而且极难支持和扩展。这就是火花的力量所在。我们可以在不编写任何实际的 SQL 查询的情况下执行与上面完全相同的查询。相反，我们可以通过在我们的数据帧上执行 Spark 查询函数，在 Scala 中编写 Spark 代码:
 
display(df.select($"zipcode").groupBy($"zipcode").count().orderBy($"count"))
这将显示与前面的原始 SQL 查询完全相同的结果。另外，注意display()函数是特定于数据帧的。当使用直接火花时，然后.show功能将显示结果(尽管没有所有的铃声和哨声)，例如:
 
df.select($"zipcode").groupBy($"zipcode").count().orderBy($"count").show
现在，让我们查询更具体的信息。假设我们想要两居室房屋的平均价格(可能是房子、公寓等。)的邮政编码是 94109。在 Spark 中，这很简单:
 
import org.apache.spark.sql.functions._display(df.select($"lastsoldprice")
.filter($"zipcode"===94109)
.filter($"bedrooms"===2)
.select(avg($"lastsoldprice")))
让我们稍微分解一下这个查询。
 
首先，我们选择数据框中的lastsoldprice字段。接下来，我们过滤我们的数据帧，首先，它只包含zipcode为 94109 的值，其次，它只包含卧室数量为 2 的值。在每种情况下，我们都使用===,因为我们将值与一列值进行比较，而不是与单个变量进行比较。然后查询平均值lastsoldprice。注意必须导入avg功能。这里有一些细微之处你可能需要记住(或者查找),但是代码本身是不言自明的。
 
结果是一个新的 DataFrame，然后我们使用display函数显示它。
 
现在，让我们看看一些更复杂的查询。首先，让我们创建一个只包含我们需要的字段的数据帧:
 
val fineTune = df.select($"address", $"bathrooms", $"bedrooms", $"finishedsqft", $"lastsolddate", $"lastsoldprice", $"neighborhood", $"totalrooms", $"usecode", $"yearbuilt", $"zipcode")
从现在开始，每个查询都将变得更加高效，因为我们只查询和返回我们实际需要的字段。
 
接下来，我们可以为数据子集创建数据框架。例如，假设我们想要一个只包含任务区内单户家庭信息的数据框架:
 
val mission = fineTune.filter($"neighborhood"==="Mission").filter($"usecode"==="SingleFamily")
我们可能希望找到 2015 年出售的这些房屋的平均价格。我们可以从我们的mission数据帧开始，并从那里进一步查询以创建新的数据帧:
 
import org.apache.spark.sql.functions._
import java.text.SimpleDateFormatval mission2015 = mission
.withColumn("lastsolddateint", unix_timestamp($"lastsolddate","MM/dd/yy"))
.filter($"lastsolddateint" > new SimpleDateFormat("MM/dd/yyyy").parse("01/01/2015").getTime() / 1000)
.filter($"lastsolddateint" < new SimpleDateFormat("MM/dd/yyyy").parse("01/01/2016").getTime() / 1000)
.orderBy($"lastsolddateint".asc)display(mission2015)
最后，这一切看起来都很好，但是我们实际上如何把这些数据带走呢？Spark 一般假设你要在 Spark 里做所有的事情，做完了就要在某个地方写出来。因此，我们将把最终的数据帧写入另一个 CSV 文件:
 
mission2015
   .repartition(1)
   .write
   .format("com.databricks.spark.csv")
   .option("header", "true")
   .mode("overwrite")
   .save("/FileStore/Mission2015.csv")
这应该都是不言自明的，除了repartition(1)。简单地说，我们希望将集群中的所有分区作为单个分区写出。否则，如果我们的集群是这样设置的，我们可能最终会创建多个文件(每个分区一个)。
 
话虽如此，Spark 仍然使用这个 write 命令创建多个文件，如果您运行以下命令，就可以看到这一点:
 
%fs ls /FileStore/Mission2015.csv
但是如果你仔细观察上面的结果，很明显只有一个 CSV 文件。其余的都是 Spark 用于内部管理的东西。
 
现在，我们怎么拿到这份文件？这就像它应该的那样简单。显示数据帧，并下载:
 
注意底部的下载按钮——这是使用display命令显示的每个数据框的底部。只需点击该按钮，您将获得您的 CSV。
 
如果你真的想的话，你可以在 Excel 中使用各种过滤器和查询来完成所有这些工作。但是使用 Spark，您可以创建这些转换的管道(每个邻居、卧室数量等的组合一个管道)。这将查询并生成结果(平均价格或新数据帧/CSV 文件之类的集合)，并针对万亿字节或更多数据的数据集执行此操作。只需扩展您的底层集群来支持这一数据量，无需更改代码。代码将已经设置为运行，并可以作为一个夜间我们的每小时工作自动化，如果这是你想要的。
 
这在 Excel 或 MySQL 中可不容易管理。
 
高斯过程回归快速入门
 
 
原文：https://towardsdatascience.com/quick-start-to-gaussian-process-regression-36d838810319?source=collection_archive---------0-----------------------
 
理解高斯过程回归(GPR)和使用 scikit-learn 的 GPR 包的快速指南
 
高斯过程回归(GPR)是一种非参数的贝叶斯回归方法，正在机器学习领域掀起波澜。GPR 有几个好处，可以很好地处理小数据集，并且能够提供预测的不确定性测量。
 
与许多流行的监督机器学习算法不同，这些算法学习函数中每个参数的精确值，贝叶斯方法推断所有可能值的概率分布。让我们假设一个线性函数: y=wx+ϵ 。贝叶斯方法的工作原理是通过指定参数的*、 p(w)、、 w ，并使用贝叶斯规则基于证据(即观察数据)重新定位概率:*
 
Calculating posterior distribution with Bayes’ Rule [1]
 
更新后的分布 p(w|y，X) ，称为 后验分布 ，因此结合了来自先验分布和数据集的信息。为了得到在看不见的感兴趣点的预测， x ， 预测分布 可以通过用它们的计算后验分布加权所有可能的预测来计算[1]😗
 
Calculating predictive distribution, f is prediction label, x* is test observation [1]*
 
为了便于积分，通常假设先验和似然是高斯型的。使用该假设并求解预测分布，我们得到高斯分布，从中我们可以使用其均值获得点预测，并使用其方差获得不确定性量化。
 
高斯过程回归 是非参数的(即不受函数形式的限制)，因此 GPR 不是计算特定函数参数的概率分布，而是计算所有符合数据的容许函数的概率分布。然而，与上面类似，我们指定一个先验(在函数空间上)，使用训练数据计算后验，并计算我们感兴趣点的预测后验分布。
 
有几个用于高效实现高斯过程回归的库(例如 scikit-learn、Gpytorch、GPy)，但为了简单起见，本指南将使用 scikit-learn 的高斯过程包[2]。
 
***import** sklearn.gaussian_process **as** gp*
*在 GPR 中，我们首先假设在 之前有一个 *高斯过程，这可以使用均值函数【m(x)】和协方差函数 k(x，x’)来指定:
 
Labels drawn from Gaussian process with mean function, m, and covariance function, k [1]
 
更具体地说，高斯过程类似于无限维多元高斯分布，其中数据集的任何标注集合都是联合高斯分布。在这个 GP 先验中，我们可以通过选择均值和协方差函数来结合关于函数空间的先验知识。通过将标签分布和噪声分布相加，我们还可以容易地将独立、同分布的(I . I . d)【ϵ∨n(0，σ)合并到标签中。
 
**数据集由观察值、 X、及其标签、 y、s 组成，分为“训练”和“测试”子集:
 
**# X_tr <-- training observations [# points, # features]
# y_tr <-- training labels [# points]
# X_te <-- test observations [# points, # features]
# y_te <-- test labels [# points]**
根据高斯过程先验，训练点和测试点的集合是联合多元高斯分布的，因此我们可以这样写它们的分布[1]:
 
GP prior rewritten: multivariate distribution of training and testing points
 
这里，K 是协方差核矩阵，其中它的项对应于在观测值处评估的协方差函数。以这种方式编写，我们可以利用训练子集来执行模型选择。
 
在 模型选择 期间，选择并调整 GP 先验中的均值函数和协方差核函数的形式。均值函数通常是常数，或者为零，或者是训练数据集的均值。协方差核函数有很多选择:它可以有很多形式，只要它遵循一个核的性质(即半正定和对称)。一些常见的核函数包括常数、线性、平方指数和 Matern 核，以及多个核的组合。
 
一种流行的核是常数核与径向基函数(RBF)核的组合，其针对函数的平滑性进行编码(即空间中输入的相似性对应于输出的相似性):
 
Constant times RBF kernel function
 
这个内核有两个超参数:信号方差σ和长度尺度 l 。在 scikit-learn 中，我们可以从各种内核中进行选择，并指定它们的超参数的初始值和界限。
 
**kernel = gp.kernels.ConstantKernel(1.0, (1e-1, 1e3)) * gp.kernels.RBF(10.0, (1e-3, 1e3))**
在指定了内核函数之后，我们现在可以在 scikit-learn 中为 GP 模型指定其他选择。例如，alpha 是标签上 i.i.d. 噪声的方差，normalize_y 是指常数均值函数-如果为假，则为零；如果为真，则训练数据均值。
 
**model = gp.GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10, alpha=0.1, normalize_y=True)**
调整协方差核函数的超参数的一种流行方法是最大化训练数据的对数边际似然。基于梯度的优化器通常用于提高效率；如果上面未指定，默认优化器是’ fmin_l_bfgs_b’ 。因为对数边际可能性不一定是凸的，所以使用具有不同初始化的优化器的多次重启(n _ restructs _ optimizer)。
 
**model.fit(X_tr, y_tr)
params = model.kernel_.get_params()**
如果需要，可以通过调用 model.kernel_ 来获得内核函数的调整后的超参数。get_params() 。
 
为了计算预测的后验分布，数据和试验观察被排除在后验分布之外。同样，因为我们选择了高斯过程先验，计算预测分布是易处理的，并导致可以完全由均值和协方差描述的正态分布[1]:
 
Predictive posterior distribution for GPR [1]
 
预测是均值 f_bar，方差可以从协方差矩阵σ*的对角线获得。请注意，计算平均值和方差需要对 K 矩阵求逆，这与训练点数的立方成比例。通过 sci-kit learn 的 GPR 预测功能，推理很容易实现。*
 
**y_pred, std = model.predict(X_te, return_std=True)**
**注意，返回的是标准差，但是如果 return_cov=True，则可以返回整个协方差矩阵。然后可以计算 95%的置信区间:高斯分布的标准偏差的 1.96 倍。
 
为了测量回归模型对测试观测值的性能，我们可以计算预测值的均方误差(MSE)。
 
**MSE = ((y_pred-y_te)**2).mean()**
参考文献:
 
[1] Rasmussen，C. E .，& Williams，C. K. I .，机器学习的高斯过程 (2016)，麻省理工学院出版社
 
[2]f . Pedregosa，g . Varoquaux，a . gram fort，Michel，v . Thirion，b . Grisel，o .等人。艾尔。，sci kit-learn:python 中的机器学习 (2011)，《机器学习研究杂志》
 
难度炸弹爆炸了吗
 
 
原文：https://towardsdatascience.com/quickblarks-62aa90169ff0?source=collection_archive---------22-----------------------
 
我想与你分享(通过一系列图表)当一个人在新鲜出炉的以太坊难度数据上发布像 Ed Mazurek 这样的世界级数据科学家时会发生什么。
 
你得到了 QuickBlarks(如果你想知道的话，这是“QuickBlocks”和“R”的组合)。如果你不知道“R”和 R 工作室，你应该知道。太神奇了。
 
在几乎没有任何解释的情况下，我将把“R”代码复制并粘贴到用于创建它的图表旁边。问艾德代码是什么意思。
 
逗号分隔的数据如下所示:
 
 
块号，时间戳，难度
 11438269988，17171480576
 21438270017，17163096064
 31438270048，17154715646
 41438270077，17146339321
 …
 
在编写本报告时，已生成的 7，105，056 个数据块中的每一个都有一条记录。下面是一些初步的设置代码，用于读取数据并对其进行一些清理。
 
require(tidyverse)
require(scales)
require(dplyr)
require(magrittr)homestead.block <- 1150000
byzantium.block <- 4370000
bin_size <- 200
period_size <- 100000
sample_size <- 50000difficulty <- read_csv(‘difficulty-generated-1a.csv’) %>%
 filter(block.number > homestead.block) %>%
 mutate(block.bin = floor(block.number / bin_size) * bin_size) %>%
 mutate(fake.block =
   ifelse(block.number >= byzantium.block,
      block.number — 3000000,
      block.number) + 1) %>%
 mutate(period = floor(fake.block / period_size)) %>%
 mutate(bomb = 2 ^ period) %>%
 mutate(parent.difficulty = lag(difficulty)) %>%
 mutate(parent.ts = lag(timestamp)) %>%
 mutate(diff.delta = difficulty — parent.difficulty) %>%
 mutate(ts.delta = timestamp — parent.ts) %>%
 mutate(diff.sensitivity = diff.delta / difficulty) %>%
 mutate(ts.sensitivity = ts.delta / timestamp)current.block <- difficulty$block.number %>% tail(1)
current.bomb <- max(difficulty$bomb)
这是我们第一个图表的代码:
 
difficulty %>%
    sample_n(sample_size) %>%
    group_by(block.bin) %>%
    ggplot(aes(x=block.number)) +
    geom_line(aes(y=diff.delta, color=’diff.delta’)) +
    geom_line(aes(y=bomb, color=’bomb’))
这是第一个图表，显示了前 710 万个块中每个块的difficulty中的delta。它还用红线显示了难度炸弹。你可以看到它又爬上来了。
 
下一个图表，是用这段代码制作的，
 
difficulty %>%
    sample_n(sample_size) %>%
    group_by(block.bin) %>%
    ggplot(aes(x=block.number)) +
    geom_line(aes(y=diff.sensitivity, color=’diff.sensitivity’))
显示难度计算对当前情况的“反应”。我们用diff.delta除以block.difficulty来计算sensitivity。我不确定，但我认为 jaggys 来自于难度值的计算方式。它捕捉到下一个最近的 10 秒来调整，所以 10，11，12，… 19 都给出相同的调整，但 20，21，22，…给出不同的调整。
 
Sensitivity vs. Block Number
 
下一个图表，由这个“R”代码生成，
 
difficulty %>%
 group_by(block.bin) %>%
 summarize(sum.diff.delta = sum(diff.delta), na.rm=T) %>%
 ggplot(aes(x=block.bin, y=sum.diff.delta)) +
 geom_line()
显示diff.delta值的累计和。可以清楚的看到前拜占庭难度炸弹发动的战斗。上，下，上，下。事实上，难度在目标附近徘徊正是难度计算器应该做的。它保持块的时序一致。
 
莱恩·雷蒂格想知道，由于当前链的散列率增加，难度炸弹的效果是否会被掩盖。我不确定(我什么都不确定)，但自拜占庭以来积木难度的更广泛传播可能表明他的直觉是正确的。难度炸弹是不是藏在大黑静电里？
 
在下面的图表中，我们展示了一些用更多的“R”代码制作的其他东西。在本节中，我们计算数据块时间戳平均值的差值，或者数据块时间戳差值的平均值，然后根据之前的图表(如果你想理解，你必须问 Ed)。
 
difficulty %>%
 group_by(block.bin) %>%
 summarize(sum.diff.delta = sum(diff.delta, na.rm=T), mean.ts.delta = mean(ts.delta, na.rm=T)) %>%
 gather(key = vars, value = val, -block.bin) %>%
 ggplot(aes(x=block.bin, y = val)) +
 geom_line() +
 facet_wrap(facets = ‘vars’, scales = ‘free’, ncol = 1)
现在我们只是展示了一大堆看起来很酷的黑色锯齿的疯狂图表(坚持住，下面有一些有趣的东西)。
 
上面的图表是用这种几乎难以理解的代码制作的:
 
difficulty %>%
 group_by(block.bin) %>%
 summarize(sum.difficulty = sum(difficulty), sum.diff.delta = sum(diff.delta, na.rm=T),mean.ts.delta=mean(ts.delta, na.rm=T)) %>%
 mutate(percent.delta = sum.diff.delta / sum.difficulty) %>%
 gather(key = vars, value = val, -block.bin) %>%
 ggplot(aes(x=block.bin, y = val)) +
 geom_line() +
 facet_wrap(facets = ‘vars’, scales = ‘free’, ncol = 2)
最后，一些真正有趣的事情
 
10 月份，在 T4 举办的状态黑客马拉松上，艾德和我受到启发，着手解决以太坊难度计算的问题。他担心，当前链条的散列率比拜占庭爆炸前高得多，会使炸弹更长时间地模糊不清，然后，一旦爆炸，会让人们措手不及。
 
我们想看看他的直觉是否正确。
 
简单说说炸弹。它以指数增长曲线爆炸，每 100，000 块翻一番。这产生了一个锯齿曲线的效果，因为链条很难抑制上升，正如我们在之前的中讨论的。
 
在下一组图表中，我们将数据分成 100，000 个数据块的存储桶，并将这些存储桶称为periods。(下面黑线显示的是电流period。)这种波动在下面的图表中很明显，我们也将数据分成分组:前拜占庭和后拜占庭。这使我们能够将两个爆炸的炸弹排在一起进行比较。
 
当我们这样看数据时，我们看到了什么？首先，我们看到后拜占庭时代的炸弹开始抬头。
 
difficulty %>%
 mutate(era = ifelse(block.number <= byzantium.block, ‘before byzantium’, ‘post byzantium’)) %>%
 sample_n(sample_size) %>%
 ggplot(aes(y = diff.sensitivity, x = period, color=block.number)) +
 scale_colour_gradient2(low = “red”, mid = “green”, high = “blue”, midpoint = byzantium.block, space = “Lab”, na.value = “grey50”, guide = “colourbar”) +
 geom_point(size = point_size) + 
 facet_wrap(facets = ‘era’, nrow = 2) +
 geom_vline(xintercept = 41)
上面的代码给了我们这个图表:
 
在这里，我想，我们终于找到了一些有趣的东西。虽然，我们还没完。
 
接下来，我们将后拜占庭时期的数据和前拜占庭时期的数据相互叠加。
 
我们现在看到的是，如果我们足够仔细地观察，紫色的小点(现在的子炸弹)比绿色的小点(以前的子炸弹)更低。
 
莱恩是对的。这一次，难度炸弹的效果会变得模糊不清，不像以前那么明显。这可能会让它的效果不太明显，直到爆炸。那要多久？炸弹什么时候来？我们已经在第 41 期了。最后一颗炸弹(见此图)现在开始显示减速。最后一枚炸弹现在已经开始加速了。我认为这一次也是如此，但它隐藏在更高的哈希速率后面。
 
Thomas Jay Rush 拥有软件公司 QuickBlocks，其主要项目也被称为 QuickBlocks，这是一个软件库和应用程序的集合，能够对以太坊区块链进行实时、逐块的智能合同监控和分析。通过网站联系他。