TowardsDataScience 博客中文翻译 2019（四百五十一）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

解决人工智能问责制差距

原文：https://towardsdatascience.com/solving-the-ai-accountability-gap-dd35698249fe?source=collection_archive---------13-----------------------

让开发者对他们的作品负责

A self-driving car — steering wheel not included

昨天，一份泄露的英国政府白皮书指出社交媒体高管可能要对其平台算法上的有害内容扩散承担法律责任。这项提议旨在解决自主决策带来的一个最大问题:当人工智能造成伤害时，谁应该受到指责？

心灵的差距

这种“责任差距”是一个比看起来更糟糕的问题。我们的法律体系是建立在一个基本假设之上的人类代理人。用自主代理(自动驾驶汽车、社交媒体算法和其他类型的人工智能)取代人类行为者，会让这个系统陷入混乱。这一责任缺口导致了三个方面的问题:因果关系、正义和补偿。

因果关系

当有人开枪打死另一个人时，从法律角度来看，因果关系通常很简单:决定扣动扳机的人是另一个人死亡的最大“原因”，并由法律系统相应处理。但是，当一个人工智能自动做出一个对人造成伤害的决定时，法律责任的过程就会陷入混乱。

拿自动驾驶汽车来说。即使车辆完全自主地决定高速离开高速公路并发生碰撞(也许预见到迎面而来的碰撞，并倾向于采取规避行动)，你显然也不能将那辆自动驾驶汽车拖到法庭面前，迫使它面对正义。即使你可以(一些专家建议人工智能程序被赋予法律人格，这意味着理论上它们将能够被拖上法庭)，也没有建立因果关系的先例或过程。

与开发商、制造商或首席执行官相比，是否真的可以说自主系统的决策是导致乘客死亡的“最大原因”？我不太确定。

正义

同样，法律体系的惩罚和补救措施在很大程度上是针对人类的，而不是自主的计算机程序。对违法者实施有效惩罚的能力远非法律程序的附属品，而是对司法体系的基本公正至关重要。为了可信，法律系统能够适当有效地惩罚不法行为是至关重要的。

换句话说，如果杀人犯被判处荒谬的“惩罚”,而这些惩罚并没有以任何有意义的方式影响他们的生活，司法系统将失去其作为一种威慑的价值，以及建立在正义得到伸张这一原则上的道德信誉。这抓住了人工智能带来的问题:你不能把人工智能扔进监狱，或对它处以罚款，或让它支付赔偿——不管它是否具有法律人格。法律系统的惩罚或补救措施没有一个对自主计算机程序有效。如果没有有效的惩罚或补救措施，我们的法律体系就失去了正义的基础。

补偿

为受害者伸张正义不仅仅包括对造成伤害的人进行有效的惩罚，在许多情况下，受害者寻求某种形式的金钱赔偿，即使只是收回法律费用。一个普遍的法律原则是，遭受伤害的人应该被放在他们如果没有犯罪的话应该处于的位置。因此，如果像机器人手术工具这样的自主医疗设备出现故障并伤害了患者，患者应该能够在法律体系中寻求赔偿，以支付医疗费用。

同样，当伤害是由自主代理人造成时，我们的法律体系很难适用一般原则(在这种情况下，受害者赔偿)。法院显然不可能强迫人工智能——一个计算机程序——向受害者支付数千美元来支付他们的医疗费用。因此，为了让受害者在法律体系中有任何追索权，他们必须能够寻求有能力支付赔偿的人(或者至少是企业)。因此,“责任漏洞”给寻求通过法律系统获得赔偿的受害者增加了严重的困难。

…

因果关系、正义和赔偿这些问题是相互关联的，共同对我们的法律制度提出了巨大挑战。为了让系统保持可信和公正，从根本上需要以某种方式填补人工智能问责制的空白:首先将人工智能相关的伤害归咎于一个人或一群人。

威力巨大……

这种将人工智能的行为(以及任何间接伤害)与一个人或一群人联系起来的必要性，向我们提出了公平的问题。当代人工智能系统的决策极其难以理解或解释——即使对负责编程的开发人员和编码人员来说也是如此。人工智能算法和过程非常复杂，以至于自主决策有时被比作黑匣子。在这种复杂的情况下，让一个人承担法律责任真的公平吗？

简而言之:是的。我的观点是，人工智能开发者——定义为直接塑造人工智能编程的个人或群体——应该首先对人工智能决策所导致的行为(和任何伤害)承担法律责任。

从道德上讲，人工智能开发人员是对人工智能所做的决定负最大责任的群体。尽管上面捕捉到了黑盒动态，但如果任何一方应该能够预见人工智能造成的未来伤害，那就是从无到有创造人工智能决策能力的团队。

一个(并非不合理的)类比是，一个行为不端的孩子在商店里发脾气并毁坏了一些产品——我们有理由期待孩子的父母为被毁坏的产品买单，即使他们自己没有造成损害，也不能说完全理解孩子为什么会造成损害。像那些父母一样，开发者处于防止伤害的最佳位置，即使他们对他们的创作缺乏完全的控制，一种道德责任从这种动态中产生。

实际上，同样的开发人员也是到目前为止在创建人工智能的复杂过程中积极采取风险管理和安全措施的最强有力的角色。像这篇文章提出的那样，对人工智能开发人员施加法律责任，会对该群体产生强烈的激励，促使他们加强安全措施，并遵守更严格的风险缓解框架。

如果像监管机构或制造商这样的团体在第一时间对人工智能负责，这种健康的激励就不会出现在同样的程度上，因为他们对人工智能的发展方式没有那么直接的控制。人工智能开发者有能力让人工智能变得更安全，我的提议将他们的个人激励与这一责任结合起来。

在实践中，我想象这个提议看起来像一个“可反驳的假设”,即人工智能开发者应该面对特定人工智能的任何受害者的诉讼。一个可反驳的假设与承认有罪不是一回事:它只是意味着，如果一个人工智能开发者认为另一方(比如他们组织的首席执行官)对人工智能造成的伤害负有更大的责任，他们必须向法庭证明这种信念，以避免责任。

举一个假设的例子(咳)某社交媒体巨头的人工智能开发人员，他们创造了一个像老虎机一样令人上瘾的算法。我的可反驳的假设允许那些认为自己受到算法伤害的人起诉那些开发者。但是，如果这些开发人员能够指出强有力的证据，证明他们直接受到管理层的指示，让人工智能尽可能令人上瘾，那么诉讼就会落在那些沉迷于增长的经理们的脚下。

无论人工智能伤害案件的最终被告是开发人员还是开发人员可以指向的另一方，与人工智能责任差距相关的问题都得到了解决。确定因果关系的责任在于开发商(而不是受害者)，正义可以通过有效的惩罚和补救措施来实现，受害者可以向人类一方寻求赔偿。

发展网飞，冷却

AI 问责没有完美的解决方案。让开发者承担责任的提议的最大风险之一是对人工智能开发的寒蝉效应。毕竟 AI 开发者往往是小演员——个人或者小公司。当他们的创造造成伤害时，不管他们是否是最应该受到谴责的，每次他们的人工智能造成伤害时面临诉讼的现实噩梦可能会合理地使人工智能开发者非常谨慎地将他们的创造发布到世界上(他们的对冲基金投资者可能会在伸手拿支票簿之前停下来)。

然而，寒蝉效应的威胁不足以压倒上述伦理和实践方面的考虑。许多为大型科技巨头工作的开发人员将受益于替代责任，这意味着科技巨头将被迫将他们的法律资源用于保护他们的开发人员。

我们可能最终会看到政府采用“无过失”保险政策(类似于新西兰的 ACC 系统用于支付与事故相关的医疗费用)来支付与人工智能相关的诉讼。例如，考虑到自动驾驶汽车的部署可能会拯救许多生命，国家肯定有强烈的动机以这种方式支持人工智能的部署。受害者将失去起诉开发商个人的能力，但会得到伤害承认，其医疗费用由政府承担。

或者，政府可以为自己保留起诉其发明造成伤害的人工智能开发者的权力。这可能是一个将最恶劣的罪犯送上法庭的更有效的系统。自主决策的受害者可以通过一个专门的机构让开发商承担责任，类似于警方在刑事案件中与受害者合作。这有助于防止闸门被打开，并有助于防止基于车库的人工智能编码员被淹没在民事诉讼中。

这些思想实验捕捉到的是，人工智能问责制的差距可以得到解决——有一个新的假设，即人工智能的开发者首先要负责——而不需要通过让程序员破产来拖延行业。

…

从本月泄露的文件来看，英国将提出一种解决人工智能问责差距的方法:针对科技巨头的首席执行官。这篇文章规划了一条不同的道路，一开始就让开发者负责。无论如何，越来越有必要调整我们的法律体系，使其能够以道德和法律公平的方式处理自主代理人的案件。

这种结构性的航向修正容易吗？当然不是。但它用公共政策辩论取代了令人担忧的问责差距，这无疑是朝着正确方向迈出的一步。

解开反向传播之谜

原文：https://towardsdatascience.com/solving-the-mystery-of-backpropagation-73b18cae8e40?source=collection_archive---------26-----------------------

Photo by Cristina Gottardi on Unsplash

在大多数广泛使用的基于神经网络的人类级超越学习系统中，该算法是相当重要的。1986 年发表在《自然》杂志上的一篇论文使这一方法广为人知，这篇论文的作者是大卫·鲁梅尔哈特、杰弗里·辛顿和罗纳德·威廉姆斯。

原始论文的结论是，“将该程序应用于各种任务表明，有趣的内部表示可以通过权重空间中的梯度下降来构建，这表明值得在神经网络中寻找更具生物学意义的梯度下降方法”。好吧，反向传播可能不完全是在我们的自然神经元网络中发生的，但它肯定在数学学习系统中表现出了巨大的成果。这将催生一个激动人心的人工智能新时代。

反向传播算法处理连续调整神经网络内部参数(权重和偏差)的系统方法，以使网络做出的预测误差最小。如果你想从事机器学习和深度学习的复杂应用，了解它的内部工作方式似乎是至关重要的。

反向传播最聪明的地方似乎是用来计算成本函数相对于网络中每个权重和偏差的偏导数的方法。这为思考这个优雅的算法是如何第一次被发现的铺平了道路。

但是，如果你仔细观察神经网络的行为，可能会有一种系统的方法来推断衍生品的奥秘。

想象将单个权重 w 值改变一个小因子δw的情况，如下图所示；

现在，这一变化将影响涉及该重量的立即激活，使其改变δa。

δa的变化将依次影响下一层中的所有其他节点。

最终，以类似的方式穿过所有层，开始整个变化的δw 影响最终的成本函数。

现在，我们可以把它看作是变化的向前传播。换句话说，我们可以用我们操纵的权重的第一次变化来表示网络成本的最终变化。

The change in cost as a partial derivative of the weight change performed

现在，计算成本的变化看起来就像是一项计算𝜕C/𝜕w 的任务。看看它是如何在网络上传播的，我们可以用公式表示它与第一个δw 之后发生的所有变化的关系。

上述表达式显示了由于δw .导致的最直接激活的变化，这将依次影响δa之后的下一次激活。

现在这里的δa可以用之前的表达式代替，你会得到下面的表达式；

我们倾向于在这里看到一种模式。从δw的第一次变化开始，随后的激活受到前一层激活变化的影响。∂a/∂a 开始成为我们经过的每一个节点的通用术语。现在很清楚，对于每一层中的每个节点，模式将如下所示；

这里的 m，n，p …项表示不同的层，而 ∑ 表示我们对每层中的所有节点求和。

我们记得，反向传播算法的任务是找到所有参数的偏导数*，即*。关于网络末端成本变化的所有权重和偏差。因此，如果我们简化上面的等式，这表明我们可以根据激活和权重的值来制定所有权重和偏差的表达式。这个计算每个参数变化幅度的过程，给了我们一个方向，如果我们想降低网络中的总成本。计算出的导数给出了梯度下降的方向。非常直观和优雅。

这就是大卫·鲁梅尔哈特等人。艾尔。想出了反向传播的解决方案？嗯，也许吧。但该算法最吸引人的地方在于，这些持续适应成本变化的过程如何最终产生一个模拟输入数据表示的参数空间，从而可以预测/识别相同分布的新实例。

这一事实通常被视为反向传播的奥秘，这使得批评者将深度神经网络称为黑盒。但他们真的是吗？

我的论点是，如果我们系统地评估并花时间实际思考在神经网络的优化期间发生了什么，也许我们能够解决这个问题。但是，许多层次和抽象层次似乎太多了，有时我们的短期记忆无法保留和形成整个过程的整体画面。这就是机器正在帮助我们做的事情。

我最后的想法是，这是我们能想出的最好的办法吗？因为如果你仔细想想，通过反向传播进行泛化的整个过程是一个非常数据饥渴和耗时的过程。对于机器来说，是否会有更好的方法来获得现实世界中物体的表现呢？这些问题是研究的前沿。我们从未像现在这样兴奋地去研究它们。

帖子中提出的观点直接受到了迈克尔·a·尼尔森的著作 【神经网络与深度学习】 的影响。强烈推荐给任何想从零开始学习深度学习的人。

感谢阅读。

为机器学习解决标记数据集的先有鸡还是先有蛋的难题

原文：https://towardsdatascience.com/solving-the-paradox-solving-the-chicken-egg-problem-of-machine-learning-1d0a7ab75008?source=collection_archive---------29-----------------------

通过不完美的人类模式识别为分类模型创建有限数据集的第一次尝试。

我在夏初第一次写了创建命名实体识别系统的悖论，当时我正试图从有限的数据中创建一个模型。当你已经提取了 10，000 多个正面/负面/任何你想要分类的例子，并把它们整齐地放在一个. txt 文件中时，机器分类就很容易了。当你没有任何方法来组装接近这种规模的东西，而不支付领域专家几十万美元来完成一项极其无聊的任务时，机器分类是很难的。你通常会求助于标签系统来帮你做到这一点——但是请等待！你需要分类系统为你做自动标注。这就是悖论所在。

这是我在西北大学时投入了大量时间的事情，在我的职业生涯中，我一直在寻找解决这个问题的方法。你如何解决“先有鸡还是先有蛋”的问题，即需要一个好的分类模型才能有一个标签系统，但是为了得到一个好的标签系统，你需要一个分类模型？答案就在句子里，特别注意单词“ good ”。

看，人类受益于已经在他们的头脑中有一个通用的机器学习系统的等价物。这就是为什么深度学习算法的首要例子被称为神经网络。我们的大脑真的很擅长识别信息中的初始模式，只是它们不能很好地扩展，也不是完美的。在本文中，我将列出一个用于训练分类模型的模式——这可以说是你可以进入任何其他类型的机器学习任务(如生成或强化学习)之前的第一步。

这个模式对任何有经验的机器学习工程师来说都不是开创性的。当他们面对复杂的问题而没有清晰的数据集时，他们可能会有一种模糊的感觉。相反，这篇文章的目的是用稍微不同的措辞潜在地构建一个非常模糊的主题——希望它能让一个复杂的主题变得更容易理解。

我要提出的答案是，你不要马上试图创造一个完美的系统。一个完美的系统经常(但不总是)被一件事阻碍。不是超参数，也不是(总是)您选择的模型(尽管这对于正确处理很重要)，而是数据需要以某种形式进行分析。如果它已经被安排在一个整洁的 Excel 文档中，这是很有帮助的，但正如非结构化数据科学家所知，最有效的信息很少被排序。

对于如何处理非结构化环境，我还没有一个很好的框架。我所能提供的是我自己的策略，从非结构化的 word 文档中创建带标签的数据集，并收集关于如何在各种环境中向外扩展和推广的建议。

我的任务是创建一个“sectionizer ”,或者一种在特定标签下对文档区域进行分类的方法。这旨在为以后的构建提供一个基础——一种跨各种领域的非结构化文档的上下文化方法。出于本文的目的，我使用非结构化来指代没有在类似数据库的字段中拆分的文档。这并不是说它们没有结构——事实上，文档的底层结构和我发现它的能力是这种方法有效的部分原因。考虑到我所有的输入文档在这个意义上都是非结构化的，我试图引入结构和标记来创建一个带标签的数据集。

在某种程度上，我的“非结构化文本”的所有元素都在各部分之前标有标题。从某种意义上来说，这是一个“标签”,但不是一个我可以放心使用的标签。章节标题并不总是匹配的(不同的作者使用不同的方式引用同一事物)，但是我需要能够将某个文档的章节与一个通用分类法相匹配。这就是需要训练数据的原因。

我的计划是通过将文档标记成句子，然后标记每个单独的句子，并获得字符串的长度&将其与句子配对，来找出部分标题。然后，我将只提取少于 6 个单词的“句子”,并将其视为章节标题。我不会永远是对的，但我会有一些事情发生。然后，我将使用这种方法对每个文档进行“分段”,将每个部分的标题标识为“标签”,将它后面的所有内容标识为“内容”。分开。txt 文件，我将标题每个。txt 文件作为节标题，并写入与其相关的内容作为数据。我的假设是，当我在 20 多个文档中运行时，我将收集这个生态系统中每个部分的 20 多个示例的数据集。txt 文件。

最后，我创建这个训练集的理由是假设我正在处理的所有文档都不适合我正在开发的这个简洁的模式。章节标题并不总是匹配的，即使它们的内容应该匹配。这与评估每个部分的完美方法相去甚远，但我认为这将是一个有用的初步数据集组装过程。希望通过时间和初始分类算法，我可以实现一个主动学习的解决方案，用来改进我输入的数据。

我很想听听别人对我的策略的看法，不管它是基于太多不确定的假设，还是我的方法太复杂。然而，我认为这是接近高度非结构化环境的良好的第一步，这种环境需要一些初步的结构来开始工作。它利用了这样一个事实，即我自己的观察可以注意到一些小模式，我可以用它来规避这样一个悖论:需要标记数据集来产生好的分类，但需要分类器来产生自动化的标记数据集。我的下一步是创建几个基线来识别我创建的模型中的改进。

用 Python 解决旅行推销员问题

原文：https://towardsdatascience.com/solving-travelling-salesperson-problems-with-python-5de7e883d847?source=collection_archive---------2-----------------------

如何使用随机优化算法通过 Python 的 mlrose 包解决旅行推销员问题

mlrose 提供实现一些最流行的随机化和搜索算法的功能，并将它们应用于一系列不同的优化问题领域。

在本教程中，我们将讨论旅行推销员问题的含义，并通过一个例子来说明如何使用 mlrose 来解决这个问题。

这是关于使用 mlrose 解决随机优化问题的三个系列教程中的第二个。第 1 部分可在此处找到，第 3 部分可在此处找到。

什么是旅行推销员问题？

旅行推销员问题(TSP)是一个经典的优化问题，其目标是确定一组 n “城市”(即节点)的最短旅行，在同一城市开始和结束，并且恰好访问所有其他城市一次。

在这种情况下，一个解决方案可以用一个由 n 个整数组成的向量来表示，每个整数都在 0 到 n-1 的范围内，指定了访问城市的顺序。

TSP 是一个 NP-hard 问题，这意味着，对于较大的 n 值，在合理的时间内评估每个可能的问题解决方案是不可行的。因此，tsp 非常适合使用随机优化算法来解决。

例子

考虑以下包含 8 个城市的地图，编号为 0 到 7。

一名销售人员想去这些城市中的每一个，在同一个城市开始和结束，并且访问其他城市一次。

一个可能的城市旅行如下图所示，可以用解向量 x = [0，4，2，6，5，3，7，1]来表示(假设旅行从城市 0 开始并结束)。

然而，这并不是这些城市中最短的游览。这个问题的目的是找出 8 个城市中最短的 T21 之旅。

用 mlrose 求解 tsp

假设 TSP 的解可以用一个范围为 0 到 n-1 的整数向量来表示，我们可以定义一个离散状态优化问题对象，并使用一个随机优化算法来解决它，就像我们在之前的教程中对 8 皇后问题所做的那样。

[回想一下，离散状态优化问题是状态向量的每个元素只能取一组离散的值。在 mlrose 中，这些值被假定为 0 到( max_val -1)范围内的整数，其中 max_val 在初始化时定义。]

然而，通过这种方式定义问题，我们最终可能会考虑无效的“解决方案”，这涉及到我们不止一次地访问一些城市，而一些则根本不访问。

另一种方法是定义一个优化问题对象，该对象只允许我们将第 n 个城市的有效旅游视为潜在的解决方案。这是一种更有效的解决 tsp 的方法，可以使用TSPOpt()优化问题类在 mlrose 中实现。

我们将使用这种替代方法来解决上面给出的 TSP 示例。

解决该问题所需的步骤与解决 mlrose 中任何优化问题的步骤相同。具体来说:

1. 定义一个适应度函数对象。
2. 定义一个优化问题对象。
3. 选择并运行随机优化算法。

在开始这个例子之前，你需要导入 mlrose 和 Numpy Python 包。

import mlrose
import numpy as np

定义一个适应度函数对象

对于示例中的 TSP，目标是找到八个城市中最短的行程。因此，适应度函数应该计算给定旅程的总长度。这是在 mlrose 的预定义TravellingSales()类中使用的适应性定义。

默认情况下，TSPOpt()优化问题类假设TravellingSales()类用于定义 TSP 的适应度函数。因此，如果要使用TravellingSales()类来定义适应度函数对象，那么可以跳过这一步。然而，如果需要，也可以手动定义适应度函数对象。

为了初始化TravellingSales()类的适应度函数对象，需要指定所有城市的( x ， y )坐标或者每对可能旅行的城市之间的距离。如果指定了前者，则假设每对城市之间的旅行是可能的，并且城市对之间的距离是欧几里德距离。

如果我们选择指定坐标，那么这些应该作为对的有序列表输入(其中对 i 指定城市 i 的坐标)，如下所示:

或者，如果我们选择指定距离，那么这些应该作为一个三元组列表输入，给出所有城市对之间的距离 d ， u 和 v ，对于这些城市，旅行是可能的，每个三元组的形式为( u ， v ， d )。

指定城市的顺序并不重要(即，假设城市 1 和 2 之间的距离与城市 2 和 1 之间的距离相同)，因此每对城市只需要被包括在列表中一次。

使用距离方法，可以如下初始化适应度函数对象:

如果在初始化适应度函数对象时指定了坐标列表和距离列表，则距离列表将被忽略。

定义一个优化问题对象

如前所述，在 mlrose 中解决 TSP 的最有效方法是使用TSPOpt()优化问题类定义优化问题对象。

如前一步所示，如果已经手动定义了一个适应度函数，那么初始化TSPOpt()对象所需的唯一附加信息就是问题的长度(即旅程中要访问的城市数量)以及我们的问题是最大化还是最小化问题。

在我们的例子中，我们想要解决长度为 8 的最小化问题。如果我们使用上面定义的fitness_coords适应度函数，我们可以如下定义一个优化问题对象:

problem_fit = mlrose.TSPOpt(length = 8, fitness_fn = fitness_coords,
                            maximize=False)

或者，如果我们先前没有定义适应度函数(并且我们希望使用TravellingSales()类来定义适应度函数)，那么这可以作为优化问题对象初始化步骤的一部分，通过指定坐标列表或距离列表而不是适应度函数对象来完成，类似于手动初始化适应度函数对象时所做的。

在我们的例子中，如果我们选择指定一个坐标列表，而不是一个适应度函数对象，我们可以将优化问题对象初始化为:

coords_list = [(1, 1), (4, 2), (5, 2), (6, 4), (4, 4), (3, 6), 
               (1, 5), (2, 3)]problem_no_fit = mlrose.TSPOpt(length = 8, coords = coords_list,
                               maximize=False)

与手动定义适应度函数对象一样，如果在初始化优化问题对象时指定了坐标列表和距离列表，则距离列表将被忽略。此外，如果除了坐标列表和/或距离列表之外还指定了适应度函数对象，则坐标/距离列表将被忽略。

选择并运行随机优化算法

一旦优化对象被定义，剩下要做的就是选择一个随机优化算法，并用它来解决我们的问题。

这一次，假设我们希望使用一种遗传算法，其默认参数设置为群体大小( pop_size )为 200，突变概率( mutation_prob )为 0.1，每步最多尝试 10 次( max_attempts )，并且对算法的最大总迭代次数没有限制( max_iters )。

这将返回以下解决方案:

The best state found is:  [1 3 4 5 6 7 0 2]The fitness at the best state is:  18.8958046604

该算法找到的解决方案路线如下图所示，总长度为 18.896 个单位。

与上一教程中给出的 8 皇后示例一样，通过调整优化算法的参数，该解决方案有可能得到改进。

例如，将每步的最大尝试次数增加到 100，并将变异概率增加到 0.2，会产生总长度为 17.343 个单位的旅程。

The best state found is:  [7 6 5 4 3 2 1 0]The fitness at the best state is:  17.3426175477

该解决方案如下图所示，可以证明是解决该问题的最佳解决方案。

摘要

在本教程中，我们介绍了旅行推销员问题，并讨论了如何使用 mlrose 有效地解决这个问题。这是一个关于 mlrose 如何解决一个非常特殊的优化问题的例子。

mlrose 致力于解决的另一种非常特殊的优化问题是机器学习权重优化问题。也就是为神经网络、回归模型等机器学习模型寻找最优权重的问题。

我们接下来将讨论如何使用 mlrose 来解决这个问题，在我们的第三篇也是最后一篇教程中，可以在这里找到。

要了解更多关于 mlrose 的信息，请访问这个包的 GitHub 资源库，这里有。

Genevieve Hayes 博士是数据科学家、教育家和人工智能及分析专家，拥有Genevieve Hayes Consulting。你可以在LinkedIn或者Twitter上关注她。她还是 价值驱动数据科学 的主持人，这是一个每月两次的播客，面向希望最大化其数据和数据团队价值的企业。

想要发掘企业数据的价值，但不知道从哪里开始？下载免费的数据科学项目发现指南。**

用动态规划法求解 TSP

原文：https://towardsdatascience.com/solving-tsp-using-dynamic-programming-2c77da86610d?source=collection_archive---------7-----------------------

是的，因为没有足够的解决方案

当我在为我的运输系列中的另一篇文章( I 、 II ，敬请关注 III)进行研究时，我正在为旅行销售员问题 (TSP)寻找一个动态规划解决方案。

我确实找到了许多资源，但是没有一个是我喜欢的。要么是它们太抽象，太理论化，出现在一个我不喜欢看的长视频里，或者，你知道，不是我的风格。好像我不明白其中的逻辑。

所以说实话，我甚至不想写这篇文章，因为我认为它已经被写了一千遍了。但是，生活难道不令人惊讶吗？

关于这篇文章后面的完整代码，你可以去 这里 。

背景

你可以在本帖中读到一个更好、更令人愉快的版本，但要点如下。我们在一个平面上有n个点，我们希望找到恰好访问每个点一次的最短路径。

Yup, this is already a spoiler with the solution! Did I mention I wasn’t planning on writing this post?

DP 速成班

实际上，我真正想说的是，这是而不是DP 速成班😇

如果您不习惯动态编程的概念，我推荐一个比我更好的介绍，介绍这个漂亮的方法。幸运的是，一个有趣且直观的工具已经存在了！请访问 Siraj Raval 的精彩视频，加入我们的讨论🤓

构建 DP 树

在动态编程(DP)中，我们边走边构建解决方案。在我们的例子中，这意味着我们的初始状态将是任何要访问的第一个节点，然后我们通过添加每个可能的节点来扩展每个状态，以形成大小为 2 的路径，等等。每次我们访问以前访问过的部分解决方案时，我们只保留最好的分数。

啊哈！
但是你问什么是“已访问部分解决方案”？
而且你问的没错！
弄清楚什么应该“保留在内存中”是成功的 DP 解决方案的关键要素之一。经过反复试验，我决定在内存中保留每个部分解决方案的最后一个的和倒数第二个的节点。

For the partial solution [1,2,3,4], where 4 in the last node visited, we ask ourselves — what is the best way to get there? We can either come from 3 and have a total cost of 1.8, or come from 2 and have a total cost of 1.5.

一旦你确定了你想在内存中保存什么，代码就非常简单了，而且对于不同的问题，在不同的 DP 实现之间几乎没有变化:

回溯最短路径

一旦我们到达了树的末端，意味着我们在备忘录中保存的路径是完整的，那么“剩下的一切”就是折回我们的步骤以找到最佳路径。

幸运的是，我们记住了每个部分路径中的最后一个和倒数第二个节点！

Our optimal path in pink: [4,1,2,3]

因此，第一步将是查看最后一层，包括所有完整路径，并选择总成本最低的最后一个节点。

从那里，我们可以使用倒数第二个节点来追溯我们的步骤。

与启发式解决方案相比

好了，现在我们有了 TSP 问题的最优解，我们可以用它做什么呢？

嗯，事情是…那不多…

TSP 是一个 NP 完全问题，求解到最优是高度不可伸缩的。幸运的是，在之前的帖子中，我们使用快速启发式方法解决了 TSP 问题。在那篇文章之后，你们中的许多人问我——这个解决方案与最优方案相比如何？而我终于可以回答了！

哇！！这就是指数增长的样子！！😨

撇开复杂性不谈，启发式的解决方案总是让它接近最优解😅

对于这个实验中的最大输入，即使我们看最终结果，它看起来也非常相似🎯

AAAA，那是所有的人！敬请期待我们的下一次冒险！

这篇文章后面的完整代码你可以去 这里 。

再来点饭桶

原文：https://towardsdatascience.com/some-more-git-f6d8a1179918?source=collection_archive---------35-----------------------

看看在这篇关于 Git 中分支和合并的文章之前的 Git 基础知识文章！

Photo by Markus Spiske on Unsplash

Git 的设计是为了促进同一个项目的并行/多个版本。这个工具叫做分支。分支有效地允许我们将项目带入多个不同的方向，而不是单一的线性进展。它让我们维护一个分支，即“主”分支，它拥有原始版本的代码，然后还有其他分支，允许我们处理原始代码的不同版本，然后，将这些分支合并到原始代码中——合并。

当有其他人在同一个项目上工作，但是在不同的特性上工作，同时发生但是分开开发时，这个工具特别有用。最后，我们可以将不同的分支(比如代表不同特性的不同分支)合并到主分支中。

与分支相关的命令:

• 列出当前在我们仓库中的所有分支。带有*和绿色的文本表示这是我们当前所在的分支。
• git branch -a:列出所有远程和本地分支
• git branch <branch name>:用该分支名称创建一个新分支
• git branch -d <branch name>:删除分支
• git checkout <branch name>:转移到不同的分支机构
• git commit -am "message":合并了添加和提交步骤——添加我们已经更改的所有行并提交它们。

要将两个分支合并在一起:转到(git checkout)分支master，然后:git merge <name of branch to be merged with the master branch>

注意:所有这些变化都发生在我们的本地计算机上。因此，主机站点只有主分支，而我们在我们的存储库中有一个新的分支——我们刚刚创建的分支。

如果我们将检出到新的分支，添加并提交对新分支所做的更改，然后将这些更改推送到主机站点，我们会得到一条消息，说明*“当前分支特性没有上游分支”*。这是因为我们在主机站点上没有可以推送的新分支—它只有一个主分支。

因此，为了推送至主机站点上的新分支，我们使用:

• git push --set-upstream origin <name of the new branch>，其中 origin 是远程的名称(存储在主机站点上的存储库的版本)。因此，主机站点主分支本质上是，origin/master，而我们的本地主分支就是master分支。
• git fetch:从源获取提交并下载到本地。因此，我们在本地得到的两个分支是，master和origin/master。

现在，如果我们希望我们的主分支反映整体的新变化，基本上，合并我们所在的位置，即master分支与origin/master所在的位置，我们:git merge origin/master。因此，我们的主分支现在反映了 origin 的最新版本。

叉

存储库的分支是该存储库的完全独立的版本，它只是原始版本的副本。分叉一个项目就是重命名它，启动一个新项目，围绕这个想法建立一个社区。

叉还是克隆？

当我们分叉一个项目时，我们实际上只是在克隆它。fork 就是选择获取原项目的副本，启动父项目的不同线程。另一方面，贡献者可以选择克隆一个存储库，从而获得一个原始项目的副本来进行工作、修改、添加/删除。在做出他们认为合适的更改后，他们希望这些更改与代码的原始版本合并。为此，他们提交一个拉取请求。这仅仅是一种方式，说明“嘿，我已经做了一些更改，希望有人在将它们合并到代码的原始版本之前对它们进行审核”。这是一个非常有用的功能，可以获得持续的反馈和渐进的修改。

捐款时，将项目转入您自己的主机站点帐户是有益的。从那里:将其克隆到您的本地计算机，为您的新代码创建一个本地分支，进行更改，提交，推送，与 master 合并，删除本地分支，最后发送您的 pull 请求以查看您所做的更改是否生效！

感谢您抽出时间阅读这篇文章！

关于“时间序列模型是否被认为是机器学习的一部分？”

原文：https://towardsdatascience.com/some-thoughts-on-the-question-of-are-times-series-models-considered-part-of-machine-learning-or-c71eba12bfb4?source=collection_archive---------13-----------------------

Forecasting the Air Passenger time series: ARIMA (top) vs. LSTM (bottom)

这是一篇非常简短的笔记，在我再次遇到某种形式的问题“时间序列分析是机器学习的一部分吗？/时间序列分析算不算监督学习？”在论坛上。

这个问题显然是一个非常宽泛的问题，并且在某种程度上是主观的。几个月前，我和一位同事在的工作中发生了一场争论，争论的焦点是拟合一个指数平滑模型是否构成“从数据中学习”，尽管我们对模型拟合的方式和我们使用的技术完全一致。我不想假装公正地对待这个宽泛的问题，或者对它提供一个全面的答案。相反，在这里我将介绍两种非常有用的方法来看待时间序列分析和 ML 方法的问题。我认为这两种看待问题的方式是有用的，因为记住这两种方式可以让你在试图解决时间序列分析问题时更好地决定使用什么方法。此外，我在这里描述的区别避免了沿着“线性回归被认为是机器学习吗？”等等…

统计方法是参数化的，而 ML 方法不是:

在时间序列社区，大多数人(f 跟随例如 Makridakis、Spiliotis 和 Assimakopoulos )将时间序列分析技术分为两类:统计方法，如 ARIMA、霍尔特-温特斯、Theta 等，以及 ML 方法，如神经网络、支持向量回归或随机森林。使用这种分类，两个类别之间的主要区别在于，在前一种情况下，模型是参数化的，即假设一个已知的函数来表示数据(例如指数平滑:Y(t)=αY(t-1)+(1-α)(Y *(t-1))*，(Y(t)为实际值，Y *(t)为预测值)，我们只需要将正确的参数(在这种情况下为α)拟合到该函数。

在后一种情况下，我们不对代表我们数据的函数的形状做出任何假设，我们依靠我们算法的通用近似属性来找到我们时间序列的最佳拟合(严格地说，大多数 ML 模型也是参数化的，但它们是一种更松散、更广泛的参数化形式。在这种情况下，我们可以认为它们是非参数的，因为它们可以以任意的精度和复杂度来近似任何函数。

这为什么有用？当选择是用统计方法还是用 ML 时，你应该问自己:

• 我的时间序列数据背后的随机过程是否足够复杂，以至于需要某种通用近似器来建模？
• 我的时间序列中是否有足够的数据点和足够高的信噪比，以便我可以拟合复杂的非参数模型？
• 由于拟合简单的参数模型需要较少的计算，可用的计算资源允许基于 ML 的方法吗？(如果您计划自动化您的流程并在生产环境中运行它，这一点尤其重要)

序贯方法与纯自回归方法:

第二个有趣的分类是由伯格梅尔、海德曼和古提出的。在他们的论文中，他们将时间序列方法分为序列方法和纯自回归方法:

• 序列模型，如指数平滑模型:这里预测值 Y(t)* 和过去值 Y(t-1)，Y(t-2) 等之间的关系是递归的，并且随着每个新的时间步长，模型“消耗”一个额外的滞后值。如果想要用数据完整地表达模型，最终需要使用整个时间序列。我们可以用简单的指数平滑法来看这个例子:Y *(t)=αY(t-1)+(1-α)Y *(t-1)。如果我们想根据可用的数据扩展这个表达式，我们必须解开表达式:**Y *(t)=αY(t-1)+(1-α)(αY(t-2)+(1-α)Y *(t-2))等等…直到我们最终得到一个形式为:Y *(t)=αY(t-1)+(1-α)(αY(t-2)+(1-α)(αY(t-3))的模型…(1-α)^(t-1)y(0)。(注意，Y(0)是一个不可观测的变量，这就是为什么这些方法通常使用最大似然估计量)。你在这里看到了为什么模型被认为是“连续的”:使参数适合数据的唯一方法是按顺序计算一切以适合我们的模型。指数平滑模型、具有 MA 成分的 ARIMA 模型、大多数状态空间模型都属于序列类别。典型地，你用最大似然法和/或卡尔曼滤波器来拟合这样的模型。
• “纯”自回归方法是任何时间序列模型，其中预测值 Y(t)* 是时间序列变量 Y(t): Y(t) = f(Y(t-1)，Y(t-2)，…Y(t-n))* 的固定数量的 n 过去滞后的函数。 f(…) 可以是线性的，也可以是非线性的，关键是用于预测的过去滞后数总是固定的。最大似然模型都属于这一类别，但一些 ARIMA 模型也是如此(即 ARIMA(p.d.q) 模型，其中 q=0 ，因此没有移动平均分量)。您不需要整个序列来估计 f(Y(t-1)，Y(t-2)，…Y(t-n)) ，并且您仅使用可观察的数据点来拟合/训练您的模型，因此可以使用 OLS 或梯度下降。

这为什么有用？Bergmeir、Hyndman 和 Koo 的论文的主要结果是，对于序列模型，正常的交叉验证不适用，因为模型查看数据的顺序对模型如何拟合至关重要。你将不得不求助于时间序列交叉验证，这是比较棘手的，或者放弃交叉验证，转而采用另一种模型选择方法。另一方面，对于纯自回归方法，如果模型中的误差是不相关的，正常的交叉验证是适用的。因此，是否可以使用交叉验证将取决于您使用的方法。

顺便说一句，使用“纯”自回归模型是因为 ARIMA 或 BSTS 可以有自回归成分，但总体上仍然是序列模型。

最后一点:脸书越来越受欢迎的 Prophet 模型不符合 Bergmeir 等人提出的任何一个类别，因为它是一个 GAM 风格的模型，直接适用于时间变量。它在精神上更接近于序列模型，在某种意义上，正常的交叉验证不会很好地与它一起工作，因为该模型具有明确的时间依赖性。

Prophet 也不太适合我在第一个分类中提到的任何一个类别:一方面，它是参数化的，本质上是统计性的，基于 GAMs ，另一方面，Prophet 模型中的第二项是傅立叶展开，这使得它在本质上有点类似于一些基于核的 ML 方法。也许这就是它变得如此受欢迎的原因，它有一种“两全其美”的氛围。

参考资料:

1. 南 Makridakis，E. Spiliotis，V. Assimakopoulos，“统计和机器学习预测方法:关注点和前进方向”， PloS one， 2018。
2. C.Bergmeir，R. J. Hyndman，B. Koo，“关于评估时间序列预测的交叉验证有效性的说明”，莫纳什大学计量经济学和商业统计系工作论文，2015 年。
3. S.J. Taylor，B. Latham，《大规模预测》，美国统计学家， 2018。

关于数据文件您不知道的一些事情如果您是数据科学的新手，请从 web 导入数据文件:第 1 部分

原文：https://towardsdatascience.com/something-you-dont-know-about-data-file-if-you-just-a-starter-in-data-science-import-data-file-e2e007a154c4?source=collection_archive---------9-----------------------

要成为数据科学领域的大师，你必须了解如何管理你的数据以及如何从网络上导入数据，因为大约。现实世界中 90%的数据直接来自互联网。

Data Engineer Life ( Source: Agula)

如果你是数据科学领域的新手，那么你必须努力快速学习概念。现在，你在正确的地方可以更快地学习一些东西。

M 此外，根据我的经验，我认识了许多数据科学领域的新手或处于学习过程中的人。所有这些人都急于在几秒钟内覆盖伦敦到纽约的距离，等待它**Elon Musk HYPERLOOP(仍然 Elon Hyperloop 需要 4.67 小时来完成 5585 公里的范围)，我认为这项技术仍在工作中。

Source: DailyExpress( Elon Musk Hyper-loop Concept)

还有，你很努力地想在一小时内走完这段距离。你不是能在几分钟内看完所有网站内容，并做出一个独特的新内容的 AI。数据科学是一个你必须创造策略的领域，就像罗伯特·布朗(Robert R. Brown)的《像兔子一样富裕》(顺便说一下，如果你想更多地了解金融世界，并喜欢为未来存钱，这是一本值得一读的好书)。让我们回到正题；数据科学是一个你需要花一些时间去获得一些有用的、深入的知识的领域。
在本主题中，我们将介绍一些我们每天在项目中使用的不同数据格式。作为一名数据科学家，我们都花了很多时间来准备数据(70%的时间花在数据准备、清理和处理缺失值上)。大多数数据人能理解我的观点，是的，没关系，这就是我们现在的生活。我们都能理解操作完全不同的数据种类所带来的挑战。有时候，处理不同的数据类型会让你很苦恼，但是等等，我还没有谈到非结构化信息或半结构化数据。

Data makes me mad( source: Critique Cricle)

对于任何一个数据科学家和数据工程师来说，处理不同的数据格式都是一项令人厌倦的任务。现实世界中的实际数据非常混乱，你很难得到清晰的表格数据。因此，对于数据科学家来说，了解不同的数据格式、处理所有这些格式的挑战，并找到在现实生活中处理这些数据的最佳方法，是非常重要的。
我们将讨论一些对数据科学家领域有用的文件格式。不过，大部分的数据技能()。csv()、文本、酸洗文件、Excel 文件、电子表格和 Matlab 文件，所有这些文件都在本地环境下工作。然而，作为一名数据科学家，你的大部分时间这些技能已经足够了。因为大部分时间你都要处理从万维网上导入的数据。

[## 忘记 API 用漂亮的汤做 Python 抓取，从 web 导入数据文件:第 2 部分

API 并不都是为你准备的，但是美丽的汤会永远伴随着你。

towardsdatascience.com](/forget-apis-do-python-scraping-using-beautiful-soup-import-data-file-from-the-web-part-2-27af5d666246)

比如说；您需要从 UCI 机器学习数据集库中导入葡萄酒数据集。你是如何从网上获得这些数据的？现在，您可以尝试使用您最喜欢的网络浏览器来下载该数据集。

Wine Data-Set(Source:uci.edu)

现在有一些导航到适当的网址点，并点击适当的超链接下载文件。然而，这种方法产生了一些严重的问题。首先，它不是用代码编写的。此外，假装可再生性问题。如果有人想复制您的工作流，他们不一定要在 Python 之外这样做。其次，不具备可扩展性；如果你想下载 50、100 或 1000 个这样的文件，分别需要 50、100 和 1000 倍的时间。如果您使用 python，您的工作流可以具有可再现性和可伸缩性。
我们将在这一部分使用 python 来学习如何从**WWW(world Wide Web)**导入和本地数据集。我们还将直接从 www(万维网)上加载熊猫数据框中的同类数据集。无论它们是平面文件还是不同的文件，您都可以将这些技能放在发出 HTTP 请求的更广泛的意义上。特别是，您会喜欢 HTTP GET 请求，用简单的英语来说就是从 web 上获取数据。您将使用这些新的请求技能来学习从互联网上抓取 HTML 的基础知识。此外，您将使用精彩的 Python 包 Beautiful Soup 来传递 HTML 并将其转换为数据。漂亮的汤来传递 HTML 并把它变成数据。
现在有一些很棒的套餐。帮助我们导入您将要使用的 web 数据，并熟悉 URLlib(urllib 包)。这个模块实现了一个高级接口，用于在万维网上检索数据。特别是， urlopen()函数与内置函数 open 相关，但是接受通用源定位器而不是文件名。现在让我们通过一个为红酒数据集导入一个质量数据集的例子，直接从 web 导入。

这里发生的是导入一个名为 URL 的函数，它是从 url live 包的 request 子包中检索的。

1. 来自 Web 的平面文件(打开并阅读):

我们刚刚学习了如何从互联网上导入文件，在本地保存并存储到数据帧中。如果我们想加载文件而不在本地保存它，我们也可以使用 pandas。因此，我们将使用函数 pd.read_csv() ，并将 URL 作为第一个参数。

2。来自 Web 的非平面文件:

熊猫的功能是如此有用的本地存储文件，它有一个近亲，帮助我们加载各种文件。在下一个练习中，我们使用 pd.read_excel()导入 excel 电子表格。

3。HTTP 请求(执行)使用 urllib:
HTTP 是超文本传输协议，是网络数据通信的基础。我们将执行 urlretrieve() 执行一个 GET 请求。在本练习中，您将 ping 服务器。

4。使用 urllib 的 HTTP 请求(打印):

我们已经知道如何 ping 服务器，现在我们将提取响应并打印 HTML。

5。HTTP 请求(正在执行)使用请求

现在，您对如何使用 urllib 包使用 HTTP 请求有了全面的了解，您将弄清楚如何在更高的层次上做同样的事情。同样，我们将 ping 服务器，您必须将这个程序与之前的程序进行比较。(使用 urllib 的 HTTP 请求(执行))。我们不会在这里关闭连接。

我想现在你已经对如何从网上提取数据有了一点概念。
在下一部分中，我们将了解美丽的汤，如何在数据科学中使用 API，然后我们将在整个系列中讨论 Twitter API。所以，请在 medium 和 Twitter 上关注我。因此，在您的数据科学之旅中，您不会错过任何一个重要主题。此外，欢迎来到数据科学世界。

我已经发表了第 2 部分，你可以看看，让你的数据工程师技能更上一层楼。欢迎在我的 linkedin 上提问。

[## 忘记 API 用漂亮的汤做 Python 抓取，从 web 导入数据文件:第 2 部分

API 并不都是为你准备的，但是美丽的汤会永远伴随着你。

towardsdatascience.com](/forget-apis-do-python-scraping-using-beautiful-soup-import-data-file-from-the-web-part-2-27af5d666246)

参考:

1. 葡萄酒数据集
2. https://datacamp.com/使用 python 从 web 导入数据
3. https://docs.python.org/3/howto/urllib2.html
4. https://archive.ics.uci.edu/ml/datasets/wine

有时候你需要销售

原文：https://towardsdatascience.com/sometimes-you-need-to-sell-57a90a372fe7?source=collection_archive---------20-----------------------

在过去的几年里，我从不同的数据主管那里收到了同一个问题的多个变体:

你有什么建议可以影响我公司不同部门的团队，并让他们负责执行我们的计划吗？我经常无法让其他团队听取我们的想法，或者执行这些想法，即使其他人也认为这些想法很好。”

几乎所有认识我的人都可以证明，这是我职业生涯中的一个重大挑战。事实上，如果说我最大的失败，以及我造成的最大的灾难，都属于这个范畴，这可能是一种保守的说法。我也看到许多人在职业生涯的早期就在这个问题上挣扎——“如果我的想法是好的，为什么其他人不听我的，不去做我建议的事情？”。斗争的根源通常是另一方的人有他们自己的动机、挑战和动机，他们看待世界的方式与你不同——不是说他们是混蛋或愚蠢。他们不想做你想让他们做的事情有很多原因:

• 他们可能有关于他们的领域或操作环境的信息或背景，而你没有，这将有意义地改变你对情况的看法。
• 如果一个本应显而易见的好主意是由部门外的人提出的，他们可能会对自己在公司的地位感到挑战和担忧。
• 他们看待问题的优先级别可能与你不同。
• 和许多其他人。

这些都是需要应对的挑战性场景，尤其是对数据人员而言。如果你们中的任何人像我一样，你们希望每一次对话都集中在数据的分析和解释上。不幸的是，人类就是人类，当我们的湿湿糊糊的衣服卷进来时，事情并不总是这样。这就是这类情况最难解决的原因，尤其是当一家公司不断扩大，每天都有新团队出现的时候。为突破建立一个好的工具包是很重要的。

传统智慧:建立所有的关系

当我遇到这种情况时，人们给我的明显答案是“与所有人建立关系”。从某种意义上说，这应该是显而易见的——如果人们不喜欢我，这将会影响他们的反应和做我所建议的事情的动机。即使他们对我保持中立，他们也不太可能拿自己的名誉和结果冒险，因为这会影响他们根据我的话所负责的事情的表现。虽然我承认这是真的，但也感到非常不满意。当然，与你的同事和队友建立关系很重要，但是为了完成任何事情，真的有必要与每个人都成为亲密的朋友吗？我们这些内向或目标导向的人(到了不想把个人生活带入工作的程度)怎么办？

我觉得我需要一个框架来更好地了解正在发生的事情，但这也指向了我为业务实现良好结果的目标。这并不是说我的同事不是好人，也不是说我不想和他们在一起。更多的是说，在工作中，我们共同努力为公司创造价值，这不应该取决于每个人都和其他人成为朋友(尊重其他人，但不一定觉得你应该请他们吃饭喝酒)。

在我继续之前，有一点很重要:我绝不提倡你操纵或强加你的意愿给你的同事。我将要列出的策略是用来确保你的想法被听到，并且相对于其他的想法得到公平的评价。)

顿悟:你在出售你的服务

经历了许多痛苦的失败，引发了与同伴和导师的长时间讨论，我开始明白我问题的根源。当我需要向一群人宣传我的观点时，我实际上是在向他们推销我的服务。我告诉他们，他们应该相信我有解决他们问题的办法。因此，如果他们不听我的，即使我的推理是可靠的，我的想法有价值，那么我做错了。我没能让他们相信我的服务是有价值的，可以帮助他们实现目标。原来这个问题有一个非常强的类比:企业销售。

不管你喜不喜欢，当你试图让另一个团队接受你提出的想法和行动方案时，你就像一个顾问或卖主在向那个团队推销。你试图让他们相信你服务的价值，即使他们和你在同一家公司工作。这是因为他们的责任在别处——对他们的老板、部门、组织、同事。你置身事外，只能影响，不能支配。这与任何试图向企业推销产品的人所处的情况非常相似:您对某个问题有一个解决方案，但您认为某个组织已经解决了该问题，但还没有充分解决。如果他们选择你，你的解决方案会给他们带来显著的价值，你需要让他们相信这一点。在最简单的情况下，他们已经发现了问题，并正在寻找一个专家伙伴来帮助解决问题。最糟糕的是，他们甚至没有意识到问题的存在。

我还想强调的是，有一个重要的区别，那就是你让企业成功的总体目标是完全一致的。在企业销售中，你被激励去销售你的解决方案，即使组织真的应该购买不同的解决方案。在这种情况下，如果有人提出一个更好的想法，你会被激励放弃你的想法(假设你在一家运营良好的公司工作，尽管如果不是这样，你会有更大的问题)。这意味着你的目标不是销售，而是在所有其他选择中被公平地倾听和评估。以这种方式思考问题，即使类比不准确，也给了我一些可以推动问题前进的方法。有文字教科书写着如何向企业销售，我不是专家，所以我完全没有资格列出所有的策略。也就是说，通过阅读和与我认识的最好的企业销售人员交谈，我得到了一些可行的建议。

1.获得环境的准确图片

第一条建议是了解你要“销售”给的群体的动机、结构、激励和约束——基本上了解他们运作的环境。了解他们如何看待进步、威胁，以及最重要的价值，将使您能够诊断您的一致之处和不同之处。它还会让您了解他们的运营环境，以及他们可能会对哪些超出您视野的事情做出反应。例如，也许他们的部门现在有多个项目落后于计划，他们的主管正在向他们施加压力，要求他们快速交付成果，以避免与高管团队进行不愉快的会面，因此他们不想接受更多的工作。或者，他们可能将 1000 万美元的影响作为他们的年度目标，他们估计你的项目只有 10 万美元的最大收益。

了解你的目标群体如何看待这个世界，可以让你洞察他们的反应，对你的假设进行压力测试，并让你决定你所倡导的道路是否正确。可以说，如果你不理解你所交谈的群体的世界观和背后的原因，你就不能有效地倡导你的行动方针。

2.找一个冠军

第二(假设你已经投入了工作，知道你的想法有真正的价值)是识别或培养一个拥护者——这个群体中的一个人，他与你的观点一致，并能从他们的角度领导这个问题。这一点很重要，因为这个人与团队中的其他人在同样的环境下工作，受到同样的限制，因此可以提出一个更有说服力的案例。这一点至关重要，因为它承认，即使你对公司价值的目标可能是一致的，但你并不处于与你试图说服的那些人相同的工作条件下。例如，你所提倡的行动过程，即使是正确的，也可能导致其他团队不得不承担大量的加班和客户支持，从而大大增加他们的工作量。或者，您希望他们使用的新功能可能会导致他们需要改变其多个团队成员的日常工作任务，这意味着他们需要投资培训，并在提升期间应对生产力损失。

如果你能让一个人相信你的想法是正确的，那么你的想法就更有可能是正确的(因为他们比你更全面地了解对他们团队的影响)。此外，那个人会更有效地“推销”你的想法，因为他们在游戏中有利益，需要和他们的队友一起承担部署成本，而你没有。如果你不能培养这个人，在大多数情况下，这意味着你缺少一些东西，你应该努力找到你错误的假设或盲点。

需要注意的是，在有些情况下，你面对的是一大群混蛋，在这种情况下，他们可能是错的。根据我的经验，这比大多数人认为的要少得多。当受害方通过一个便利的对话进行工作时，他们通常会发现每一方归咎于另一方的邪恶动机是错误的。)

3.使评估尽可能简单

这意味着提前做好准备工作来构建您的案例-收集支持证据和分析，花时间制作一份可读、清晰、简洁的推介材料或备忘录，构建原型，收集您自己的资源来帮助在工作流程中实施解决方案。本质上，你应该尽可能地消除认知和劳动方面的负担，让他们根据实际价值而不是环境来评估你的提议。你为他们做的努力越多，就越有可能有人愿意尝试你的解决方案。毕竟，上一次有人让你做一些收益不确定的事情，而你知道仅仅是尝试一下就需要你做很多工作，而你答应了是什么时候？你能消除的与负荷相关的摩擦越多，你得到的评价就越公平。

结论:情况很艰难，但可行

这样做并没有让情况变得更容易，也没有减少我必须做的工作量。在取得一些成功之前，我失败了多次，而且我仍然不是每次都成功。但它确实让问题变得容易处理，并给了我前进的方向。希望对你有帮助。

抱歉，但是你的猫或狗 AI 正在破坏这个世界。

原文：https://towardsdatascience.com/sorry-but-your-cat-or-dog-ai-is-damaging-the-world-5adc62328e5?source=collection_archive---------29-----------------------

“绿色人工智能”论文综述

Photo by Pineapple Supply Co. on Unsplash

何艾场正在改变世界。自从它在本世纪初复苏以来，我们已经感受到了这种技术对我们日常生活、商业世界和计算全景的冲击和影响。一开始，我们把人工智能和它的孩子机器学习，与网飞和亚马逊的推荐系统或者旨在预测这是否是垃圾邮件的模型联系在一起。然而，情况发生了变化。人工智能已经进化得如此之快，以至于它正滑向我们生活的其他方面。例如，无人驾驶汽车无疑是其主要成就之一。但是，随着该领域的不断发展和进步，训练和维护这些系统所需的要求和计算能力也在不断提高。虽然这些平台和服务正在塑造我们的未来，但不幸的是，它们的高功耗要求正在对环境造成损害。

2019 年 7 月，来自艾伦人工智能研究所、卡耐基梅隆大学和华盛顿大学的罗伊·施瓦茨、杰西·道奇、诺亚·史密斯和柳文欢·埃齐奥尼发布了一篇题为“ 绿色人工智能 ”的论文在该出版物中，作者倡导他们命名的人工智能研究，以及环境友好和包容的方法。特别是，作者建议使用效率，以及准确性和整体性能，作为未来人工智能实施的评估指标。此外，作者认为绿色人工智能可以将这个领域变成一个更具包容性的领域。通过这样做，不仅研究人员，而且学生和其他无法接触到最先进的机器的人都将有机会为该领域做出贡献。

Photo by Jono on Unsplash

红色 AI

根据论文，绿色 AI 的反义词是红色 AI 。也就是，“通过使用大规模计算能力，寻求在准确性(或相关衡量标准)方面获得最先进结果的人工智能研究——本质上是“购买”更强的结果。“关于这一点，他们说，尽管研究正在产生更好、更准确的机器学习模型，但实际的收益充其量只是对数。换句话说，当我们考虑科学投入的资源数量时，这种好处并不显著。这里，资源指的是三个不同的因素。第一个是进入模型的训练数据的数量，它影响训练阶段的长度。然后，在单个例子上有模型的执行成本**(要么训练系统，要么预测结果)。最后，他们提到的最后一个资源是一个模型在找到一组最优超参数之前经历的次实验或迭代，这是一个用于调整模型的旋钮。以这三个分量为基础，作者开发了一个随它们线性增长的方程。看起来是这样的:**

Equation 1. The Cost of an AI. Taken from the Green AI paper. https://arxiv.org/pdf/1907.10597

简而言之，这意味着开发一个机器学习模型的总成本与处理单个( E )样本的产品成比例，乘以训练( D )数据集的大小乘以( H )超参数试验的数量。但是为什么是这些特殊的价值观而不是其他的呢？作者对此进行了补充。第一个组成部分 E ，与训练或维护大型神经网络模型所需的大量资源相关的费用。例如，在某个时候，著名的围棋系统 AlphaGo 的成本大约是每小时 1000 美元(来源)，而其他的，如 Grover model，用于检测假新闻，需要超过 25000 美元来训练它(来源)。

同样，等式的第二部分， D ，指的是训练集的大小，解释了当前采用更大数据集的趋势增加了系统的计算成本。关于这一点，他们评论说，训练像 FAIR 的 RoBERTa 语言模型这样的人工智能实体需要大约 25000 个 GPU 小时，因为它有 400 亿个单词的大型训练语料库(来源)。然后，还有最后一个元素， H 。这个描述了一个项目在最终版本发布之前要经历的实验次数。例如，Google 的一个项目已经在超过 12000 种不同的架构上进行了训练。作者指出，这一数值通常不被报道。

Photo by Simone Dalmeri on Unsplash

绿色人工智能

前一节中给出的等式和概念指出了如果希望降低训练机器学习模型所需的成本和资源，可以考虑的不同措施。尽管如此，这些价值并不能说明全部，也不能准确描述人工智能的环保程度。因此，作者介绍了各种效率的绿色措施，这些措施可以用作评估标准来量化人工智能的环境友好性。

这些措施中的第一个是由模型产生的直接碳足迹。然而，现实地说，这一措施是相当不稳定的，因为它是如何依赖于电力基础设施。因此，不可能用它来比较不同型号的性能。和这个分数类似的还有该型号的用电量。与碳足迹不同，电力使用更容易获得，因为大多数 GPU 和 CPU 都报告电力消耗比率。然而，这个使用值非常依赖于硬件。因此，再一次，用它来比较不同的模型是不实际的。另一个效率指标是培训时间。虽然这是一个非常直接的方法，可以快速判断人工智能的效率和绿色程度，但与上一个一样，它也非常依赖于硬件。

Photo by Sarah Dorweiler on Unsplash

另外两个更技术性的指标是参数的数量和浮点运算 (FLOP)。前一个涉及到让一个算法学会的点点滴滴；换句话说，它们是学来的东西。使这种方法成为一种合适的方法是因为参数的数量与模型的内存消耗直接相关，因此，它与所需的能量有关。尽管如此，它并不完美，这是由于模型的架构设计。因此，即使两个模型有相似的一组参数，它们的形状也会决定它们的工作量。

最后，我们有作者所谓的具体措施，浮点运算。FLOP 定义了模型执行的基本算术操作的数量，给出了它所做的总工作量及其能耗的估计值。此外，FLOP 的另一个有用的特性是它完全独立于硬件，因此，它适用于跨模型进行公平的比较。尽管翻牌并不完美。例如，一个模型可以有不同的实现，因此即使两个架构是相同的，它们所做的工作量也直接与神经网络下面的框架相关联。目前是一些 库计算一个系统的 FLOP，甚至还有论文报告它们的值。然而，提交人指出，这并不是一种普遍采用的做法。

那么，我们能做些什么呢？

在整篇论文中，作者提到了谷歌等知名公司生产的大型、复杂和昂贵的模型。但是我们剩下的人怎么办呢？作为一名数据从业者和机器学习工程师，我会插话说，我们也可以有所作为。

首先，当开发一个新模型时，我们应该记住论文中的等式，并考虑它的每个组成部分。与此同时，我们应该问自己，并确定开发一个 ML 系统所需的某些部分(例如，一个大规模数据集)是否对我们想要实现的性能至关重要。更极端的是，我们需要考虑我们是否应该训练这个模型。比如，这个世界真的需要另一个猫或者狗的分类器吗？外面有很多这样的人。抓住一个，带着它走。同样，还有像 转移学习 这样的技术，其中可以重用为一个任务训练的模型作为另一个任务的起点；这种方法可以大大减少训练时间。然后，就是很多机型的精简版。虽然它们不如它们的重型对应物精确，但它们可以非常快速和高效，例如 MobileNet 。别误会我的意思。我并不是说我们应该忽略笨重的模型，停止做“红色人工智能”绝不！有些关键案例，如疾病诊断和自动驾驶汽车，需要最先进的模型。

Photo by Evan Dennis on Unsplash

作为总结，我想说的是，我们，数据社区，应该更加意识到我们正在对环境产生的影响。为了进一步传播声音，并鼓励其他人，我们可以开始采取一些小步骤，例如用上述指标来衡量模型，并记录结果。没有必要说人工智能已经存在了。它的模式和产品会越来越好，越来越强，越来越饥渴。所以，我真的相信我们只是在抓这个红绿人工智能现象的表面。

抱歉，项目不会给你带来工作

原文：https://towardsdatascience.com/sorry-projects-dont-get-you-jobs-3e5d8e74bfdc?source=collection_archive---------0-----------------------

我们如何高估了数据科学项目在工作过程中的作用——以及 4 个真正重要的面试技巧。

from Unsplash.com

TLDR:如果你想成为一名数据科学家，就不要再追求项目了，先专注于掌握这四项技能。

概述

1。问题 :我们如何高估了项目在数据科学招聘过程中的作用。

2。轶事: 我自己的数据科学项目如何在网上疯传，但在实际采访中收效甚微。

3。解决方法: 掌握招聘经理实际测试的 4 项技能，这些技能暗中测试你的“智力”。

4。结论 :数据科学项目在求职中的作用。

序言:项目思维

对于有抱负的数据科学家如何获得利润丰厚的数据科学职位，存在巨大的误解，这与项目有关。

我所说的项目是指在 Jupyter Notebook 上尝试一些最新的机器学习或深度学习算法，并将这些工作上传到 Github 上，就好像这最终会赢得招聘经理的心一样。

但是你猜怎么着？他们不会从你的个人项目中读取太多代码。如果你这样想，你就有了我所说的项目思维。

项目思维定势:(名词)做越来越多的 ML 项目并把它们放在简历上的思维定势最终会让你得到那份高薪的数据科学工作，这在现实中不会打动多少人。

我怎么知道这个？因为我自己就是那个笨蛋。在应用程序执行许多不同的项目来扩展我的“投资组合”之前，我花费了宝贵的时间。我在项目上取得了很大进展——完成了一些获得数据领域杰出人物认可的项目。

但是现在，作为旧金山的一名数据科学家，我意识到我错了，更糟糕的是，有那么多人在追随我的脚步。这是一个警告你关于项目的故事，以及关于项目将带你去哪里的现实(剧透，不太远)。

PS:记住我只申请了加州旧金山的数据科学家职位。所以我要说的可能不适用于你所在的地区或你申请的职位。这是一个人的观点(实际上是两个人，你会在下面看到)。但这个故事也有一个可概括的方面，因为我看到世界各地的人们都对“项目”的(虚假)诱惑力和潜力感到敬畏。

1.轶事:我如何成为项目的“上帝”

在我申请数据科学职位之前，我花了 4-5 周的时间在我的项目上，因为那是我认为正确的行动方针。作为一名职业钢琴家，我想在音乐方面有所作为。这让我想到了神经网络，特别是 LSTMs 被用来产生新的音乐。

我花了整整两周的时间阅读这方面的学术论文，回想起来，我大概理解了其中的 30%。但是在那 30%里，有些事情真的困扰着我。我觉得一些研究人工智能音乐的人并不具备音乐基础方面的深厚知识。这可以从他们通过超级复杂的神经网络架构创造新声音的方式中看出，这些架构似乎没有反映出真正的音乐家是如何创作音乐的。

Example of academic research where music is created using LSTMs.

这让我如此困扰，以至于我决定基于隐马尔可夫模型从头开始创建一个算法。大约 800 行纯 python 代码后，我开发了自己的音乐制作算法。我称之为流行音乐制作人。

流行音乐制作人将音乐数据作为输入，分解音符，找出这些音符之间的统计关系，并根据这些统计数据重新创作一首全新的流行歌曲。

Architectural Basis of Pop Music Maker.

一切都失控了

我在 TowardsDataScience.com 上写了一篇关于我的机器的文章，没几天，这篇文章就爆了。每天都有成千上万的人开始阅读它，尤其是当有人在 HackerNews 上发布了我的文章之后。当我意识到发生了什么的时候，这篇文章已经在 Twitter 和 LinkedIn 上成为热门话题。到了 Travis oli phant(Numpy 的创始人和 Anaconda 的创始人)和 O’Reilly Media 的 Ben Lorica 在他们自己的社交媒体上分享了我的内容。

随着越来越受欢迎，每天都有数百人通过我创建的 flask 网站使用我的算法。这导致我的网站不断崩溃，因为部署我的代码的 AWS EC2 实例太小，无法处理大流量。一些互联网上的人开始说我是骗子，因为当他们想尝试我的算法时，网站不可用。

[## 制作音乐:当简单概率胜过深度学习

概述:我如何发现一个使用深度学习制作音乐的问题，并通过创作自己的原创来解决它…

towardsdatascience.com](/making-music-when-simple-probabilities-outperform-deep-learning-75f4ee1b8e69)

很快，这些批评在许多社交媒体网站上迅速演变成一场全面的激烈争论。一些拥有博士学位的研究人员对我在基于贝叶斯理论的方法中犯的错误大发雷霆。其他人来拯救我，捍卫我的工作(包括本·洛里卡)。简而言之，我重新点燃了互联网部分地区贝叶斯与频率统计的圣战。

起初，我决定向那些出于某种原因感到受到侮辱的人道歉，并礼貌地询问我如何才能改进我的方法。但是经过几天的道歉，我再也受不了了。辩论让我精疲力尽，我只想远离互联网。我关掉了所有的电子设备。

那么这个故事的重点是什么呢？

我讲这个故事是因为你会认为，尽管存在争议，但在我的简历中加入这个项目将有助于我获得数据科学的工作。结论:没有。除了一个来自小型创业公司的人伸出援手，没有人真正关心。总的来说，我面对的炽热只是一个微小的火花，被湾区科技的强风吹灭了。

更重要的是，招聘委员会的人并没有真正在项目上测试我。因为招聘过程不是基于你做过多少项目。这是我在很多数据科学申请者身上看到的一个普遍假设。

不要只是从我这里拿走；在我对 DoorDash 的 Jeffrey Li 进行的 TDS 独家采访中，Jeff 谈到了有抱负的数据科学家身上的陷阱:

“我在市场上看到的大多数数据科学家的最大陷阱是能够将机器学习模型与商业影响联系起来。所以很多非常非常聪明的人建立了这个非常复杂的五层神经网络，它能做出很好的预测，得分很高。但是，当我们深入研究特定模式的业务影响时，他们通常很难回答这个问题。”

如果数据科学招聘不是基于项目，那是基于什么？这是基于招聘方所说的“智力测试”。

2.臭名昭著的“智力测试”

我真的不喜欢“智力”这个词，因为这是一个暗示生物禀赋的词(你要么拥有它，要么没有)。但不幸的是，我看到它在科技招聘领域被频繁使用——而且是秘密使用。

我总是从私下渠道听到各种形式的“那个人不够聪明/不适合技术角色”。我第一次听说这些表达是从我的好朋友那里，他们是加利福尼亚湾区的软件工程师。

对我来说，这个词感觉非常压抑和飘渺。但在对这个在科技界使用的词“智能”反思了很长时间后，我开始理解它的实际含义。通过理解它的含义，我发现它没有任何“生物学”的东西——这意味着任何人都可以通过足够的准备来提高。更重要的是，我发现了破解数据科学面试的秘方。

打破“智力测试”

智力测试是所有招聘过程的基础。这是技术挑战、带回家和白板问题的基础。测试有四个主要因素。这些是:

1. 分析思维
2. 变量提取
3. 边缘案例检测
4. 最佳处理

前三分之一是最重要的。第四个是值得拥有的，一旦招聘经理从你那里得到足够的关于前三个方面的信号，就会被问到。但是这四个都是为了提取你未来技术角色的潜力和能力的信号。

简而言之:以下四项技能非常重要，但对统计、编码和 SQL 的理解也很重要。我假设这是一个大家都知道的显而易见的真理，所以我不会在这里进入知识基础。

1.分析思维

分析思维指的是将一个巨大的问题分解成可消化的部分，然后依次解决的能力。简而言之，它构建了一个包含多个检查点的思维路线图，最终通向最终的解决方案。

这部分智力可以通过实际的编码挑战或者理论上的商业/产品问题来衡量。经理会给你一大堆问题陈述，从一开始你可能会觉得没有结尾。这是有意的，因为测试的目的不在于结束。所以你的解决方案实际上是否有效并不重要。主要的一点是评估你在协调一个多步骤计划来解决一个复杂问题的能力。

这种能力需要测试，因为在实际的数据科学角色中，会有太复杂的问题，无法强行解决。必须绘制战略路线图，并概述与对业务或技术堆栈的影响相关的每个步骤的优缺点。但是，即使要实现这一点，数据科学家也需要具备灵活的战略头脑，以生成各种带有可识别检查点的工作解决方案。

对于想在这方面做得更好的申请者来说，尽可能多地解决 Leetcode 问题。阅读数据科学产品问题。产品问题的一个例子是:

一家送餐公司正在发布一款带有新用户界面的新应用。目标是通过增加送货人的旅行次数来增加他们的收入。概述一个测试策略，看看新的应用程序是否比旧的更好。

2.变量提取

变量提取指的是你能想出多少相关变量来解决手头的问题。例如，我给了你这个场景:“一栋大楼里有两部电梯，有些人抱怨其中一部比另一部慢。你需要知道什么来确认投诉是否合法？”

这种思维实验通常由不熟悉数据科学但想衡量你的“智力”的产品/非数据人员提出。这里所说的智力，是指他们专门评估你能在多大程度上提出解决面试官自己也会思考的问题所需的变量。

但是你和你从未见过的人如何在认知过程中保持一致呢？好消息是，这些实验中 99%的变量(我认为)都属于这些类别:

1. 时间(高峰时间会影响一部电梯的速度吗？)
2. 位置(可能有些楼层比其他楼层住的人多？)
3. 技术细节(也许电梯有一个技术问题，这是人们内部感知之外的问题)
4. 用户统计(楼里的人都是谁？当工作人员去另一个电梯的时候，来访者会去一个电梯吗？)

变量提取之所以重要，是因为它触及了实验的核心。进行实验需要相关的测试变量，如果你能通过想出你的经理没有想到的更合适的变量来增加测试的准确性，这是一种非常有价值的技能。

你可以通过尽可能多的不同数据来提高这方面的智力。摆弄时序数据，摆弄地理数据。无论什么拓宽了数据熟悉的知识边界。

3.边缘案例检测

边缘案例检测通常在你与招聘经理合作完成前两个部分之后。在前两者发出足够的信号后，经理会给你一个曲线球。他/她会想出一些办法来彻底推翻你想出的路线图和为解决问题而提取的变量。

这是面试中很难的一部分，因为你会因为你的逻辑漏洞当场暴露而感到慌乱。让自己冷静下来，仔细倾听经理给你的暗示。通常他们心里已经有一些答案，你必须撬开，他们会扔面包屑，引导你在他们自己的脑袋里找到答案。

他们抛出这样的曲线球，让你的思维过程脱轨，看看你在没有遇到的情况下表现如何。在实践中，在您的数据科学工作流中会有数百个您没有想到的边缘案例，尤其是当您的工作在生产中运行时。

怎么练:这个真的练不出来。当它发生的时候，深呼吸，问问题来澄清如果你需要的话，跟着面包屑。

4.最佳处理

最后一项是可选的，通常在技术面试结束时进行，如果还有时间的话。这项技能建立在智力测试的第一个测量之上(分析思维)。一旦你想出了一个特别的方法，经理会问你是否有比你想出的更好的方法来解决问题。

他们这样做是因为行业中的所有数据科学工作一开始都是粗略的，需要多次迭代才能改进。但这只是在作品的初稿完成之后。这就是为什么这个方面的排名低于前三个，我认为。

3.最后一句话:项目实际上是从哪里来的？

我相信项目确实在应用阶段的开始就发挥了作用。对我来说，它们解决了以下问题:

1. 建立自信。很多人认为完成项目是申请公司前的必要步骤(一种内部仪式)。
2. 寻址变量提取和优化组件。项目允许您处理许多不同形式的数据。它为您提供了通过摆弄管道等来优化数据处理的空间。
3. 提供一个机会来获得最初的招聘电话。招聘人员的角色不是智力测试，而是将候选人交给招聘经理进行测试。他们还向招聘人员展示了你对数据科学的主动性和承诺，这些项目是展示的好方式。

但是在最初的筛选之后，项目就没什么分量了。这有三个原因:

1. 项目不会帮助你通过技术挑战。
2. 项目不会对你作为数据科学家的潜力进行任何外部验证——只是告诉经理你复制或记忆现有代码的能力有多强。
3. 招聘经理没有时间一页一页地阅读你的笔记本。他们每天收到数百份申请。而且他们还要管理自己的团队，这已经是全职工作了。

强调我的最后一点，你需要的是对你已经完成的工作的外部确认。换句话说，在你的机器学习项目中获得 83%的 AUC，对于经理来说，你作为未来数据科学家的潜力没有什么信号。但是说有数百人试用过你的机器可能会给你所展示的数字提供更有意义的背景。

还是不相信我要说的话吗？最后，听听哥伦比亚大学数据科学研究所的主任的看法，他也是我在 TDS 访谈中采访的对象:

总监 Jeannette Wing :“计算机科学家每天都在使用某些技术和方法来解决问题。有的是:

1。我如何设计一个算法来解决这个特殊的问题

2。我如何将这个特殊的问题分解成更小的部分

3。我如何定义抽象层

4。如何定义组件之间的接口

这个问题解决技术的集合和一个人处理一个大系统或大问题的方法的集合——这就是我所说的像计算机科学家一样思考。”

然后是 IBM 的首席数据科学家，我问他，“数据科学家最重要的特质是什么？”。

他的回答是:IBM 的每个人都有一个共同点，那就是他们都是顾问。他们需要能够与客户合作。他们需要与高管开会，并能够明智地讨论解决方案。

如果你喜欢这篇文章，请关注我的简介。一如既往，祝你好运！

[## Haebichan Jung - Medium

阅读容格在媒介上的作品。数据科学项目负责人|数据科学家。每天…

medium.com](https://medium.com/@haebichan)

对熊猫中的数据框进行排序

原文：https://towardsdatascience.com/sorting-data-frames-in-pandas-a5a3af6f346a?source=collection_archive---------7-----------------------

如何快速有效地排序数据帧

许多初学数据的科学家试图通过编写复杂的函数来对数据框进行排序。这不是最有效或最简单的方法。不要重新发明轮子，使用 pandas 包提供的 sort_values()函数。让我们看看现实生活中的例子，以及如何在您的代码中使用 sort_values()函数。

加载数据集

我们将使用 python 字典来创建一些假的客户端数据，并将这些数据加载到 pandas 数据框中。我们将保持简单，所以我们将只有四列:姓名，国家，年龄和最近的活动日期。数据集很简单，但我们将给出一个很好的概述，说明如何以几种不同的方式对数据帧进行排序。

import pandas as pd
import numpy as np
client_dictionary = {'name': ['Michael', 'Ana', 'Sean'], 
                     'country': ['UK', 'UK', 'USA'], 
                     'age': [10, 51, 13],
                     'latest date active': ['07-05-2019', '23-12-2019', '03-04-2016']}
df = pd.DataFrame(client_dictionary)
df.head()

就在上面，我们有我们的客户数据框。它只有三个客户端，但足以展示所有不同的排序可能性。

按字母顺序排序

让我们从按字母顺序排列名字的数据帧开始。我们将使用 panads sort_values()函数，并通过使用一个名为“by”的参数来指定要按哪个列名排序:

df.sort_values(by='name')

我们可以看到，数据框现在是根据名称列按字母顺序排序的。

我们可以通过使用 ascending=False 作为函数参数来颠倒排序:

df.sort_values(by='name', ascending=False)

按号码排序

让我们试着做同样的事情，但是现在按年龄排序。代码看起来完全一样，只是我们更改了将用于排序的列名:

df.sort_values(by='age')

按日期排序

同样，同一行代码也适用于日期！我们唯一需要确保的是我们的日期被识别为日期类型，而不是字符串。我们将使用 astype()方法做到这一点，然后应用排序函数:

df['latest date active'] = df['latest date active'].astype('datetime64[ns]')
df.sort_values(by='latest date active')

按多列排序

排序值函数可以处理多列。它将首先根据列列表中的第一个元素对数据帧进行排序。如果使用第一列有不可排序的值，它将前进到列表中的下一列。让我们看一下先按国家排序，再按姓名排序的例子:

df.sort_values(by=['country','name'])

这里我们可以看到我们的条目是按国家排序的。所有英国条目都在美国条目之上，然后它们甚至根据其名称列进一步排序。

使用原位参数

最后但同样重要的是，如果希望当前数据框保存排序结果，请记住使用 inplace 参数并将其设置为 True:

df.sort_values(by=['country','name'], inplace=True)

结论

您可以使用单行代码高效地对数据框进行排序。神奇的是使用熊猫包中的 sort_values 函数。如果您了解如何使用本概述中概述的参数，您将能够根据自己的需要对任何数据框进行排序。希望你会觉得有用，快乐排序！

原文发布于 aboutdatablog.com: 整理熊猫、中的数据帧 2019 . 10 . 16。

PS:我正在 Medium 和aboutdatablog.com上撰写以简单易懂的方式解释基本数据科学概念的文章。你可以订阅我的 邮件列表 在我每次写新文章的时候得到通知。如果你还不是中等会员，你可以在这里加入。

下面还有一些你可能喜欢的帖子

* [## python 中的 lambda 函数是什么，为什么你现在就应该开始使用它们

初学者在 python 和 pandas 中开始使用 lambda 函数的快速指南。

towardsdatascience.com](/what-are-lambda-functions-in-python-and-why-you-should-start-using-them-right-now-75ab85655dc6) [## Jupyter 笔记本自动完成

数据科学家的最佳生产力工具，如果您还没有使用它，您应该使用它…

towardsdatascience.com](/jupyter-notebook-autocompletion-f291008c66c) [## 当你开始与图书馆合作时，7 个实用的熊猫提示

解释一些乍一看不那么明显的东西…

towardsdatascience.com](/7-practical-pandas-tips-when-you-start-working-with-the-library-e4a9205eb443) [## Pandas 数据操作函数:apply()、map()和 applymap()

以及如何在熊猫身上正确使用它们…

towardsdatascience.com](/pandas-data-manipulation-functions-7b3519fc1370)*

使用图像的声音分类

原文：https://towardsdatascience.com/sound-classification-using-images-68d4770df426?source=collection_archive---------11-----------------------

介绍

本周我读到了深度学习的一个非常酷的应用。使用图像对音频文件进行分类。这些图像被称为 光谱图 。

频谱图 是信号频率随时间变化的直观表示。现在，声音分类或音频标记有各种应用。然而，一个真正有趣的应用程序是由一位名叫莎拉·胡克的女士开发的。

她创办了一个名为 Delta Analytics 的非营利组织，他们一起帮助建立了一个系统，将旧手机挂在坎扬雨林的树上，用它来听链锯的声音。然后，他们使用深度学习来识别链锯何时被使用。这一系统将向护林员发出警报，护林员将反过来阻止雨林中的非法砍伐。

数据集

对于本文，我使用了 UrbanSound8k 数据集。它包含来自 10 个类别的 8732 个带标签的城市声音摘录。所有音频文件都≤4s，这使得创建频谱图更容易，因为较长的音频文件需要裁剪和重叠。让我们看看有哪些类别:

我们可以通过以下方式收听 Jupyter 中的一个音频文件:

在我们将音频文件转换成频谱图之前，我们需要检查这些文件是如何存储的。在我们使用的数据集中，音频文件分布在名为fold1 to fold11.的文件夹中，我们使用数据的方式是，假设我们使用的是fold1。那么fold2 to fold11将由我们的训练集组成，而fold1将是我们的验证集。这样，我们需要一个接一个地使用所有的文件夹作为我们的验证集，而其余的文件夹构成我们的训练数据。我们的最终精度将是所有这些的平均值。(K 折叠交叉验证)

密码

我们有两个选项可以将音频文件转换成频谱图， matplotlib 或 librosa 。我们将选择后者，因为它更容易使用，并且在声音领域广为人知。在我们使用它之前，我们只需要安装一个小的依赖项来确保 librosa 工作良好。

我们现在可以将音频文件转换成频谱图。现在，我没有自己写这个代码，我只是用了别人的代码。这样做是没问题的，只要你理解代码是做什么的。

Python 的好处在于，仅仅是经常查看代码就能让你对正在发生的事情有一个公平的想法。我对这段代码的第一印象是，我们正在打开一个声音文件，初始化一个绘图，将声音文件转换成声谱图，最后保存绘图。如果我们想详细地理解代码，我们总是可以钻研文档。

由于我们正在创建和存储地块，这将需要大量的时间来运行。因此，我选择只做一次折叠，而不是所有的折叠。

一旦我们有了所有的光谱图，我们可以把它当作一个图像分类问题，并遵循标准程序。关于频谱图需要注意的一点是，在不丢失大量数据的情况下将它们转换回音频是非常困难的。

分类

我们首先使用数据块 api 创建一个数据束。

请注意，我们没有对数据进行任何转换。这是因为无论条件如何，光谱图总是以相同的方式生成，这与单击图像不同，单击图像可能会因照明或其他因素而变化。然而，有一些音频转换可以应用(更多的在另一篇文章中)。

让我们来看看一些光谱图:

我们现在可以使用转移学习来训练我们的神经网络对这些图像进行分类。

我们训练了几个纪元。

解冻模型，找到学习率，再训练一些。

一旦我们对我们的模型满意，我们就可以节省重量。

由于一个与生成的输出文件数量相关的 Kaggle 错误，我无法提交我的内核。一旦我解决了这个错误，我会发布一个链接。

参考笔记本。

这就是本文的全部内容。

如果你想了解更多关于深度学习的知识，可以看看我在这方面的系列文章:

[## 深度学习系列

我所有关于深度学习的文章的系统列表

medium.com](https://medium.com/@dipam44/deep-learning-series-30ad108fbe2b)

~快乐学习。

声音事件分类:从 A 到 Z

原文：https://towardsdatascience.com/sound-event-classification-using-machine-learning-8768092beafc?source=collection_archive---------11-----------------------

音频(声音)是我们接收到的感知环境的主要感官信息之一。我们周围的几乎每一个动作或事件都有其独特的声音。音频有 3 个主要属性，帮助我们区分两种声音。

• 振幅——声音的响度
• 频率——声音的音高
• 音色——声音的质量或声音的特性(例如，钢琴和小提琴之间的声音差异)

假设一个声音事件是一个动作产生的音频片段。动作可以是说话、哼唱、打响指、行走、倒水等。作为人类，我们从很小的时候就开始训练用声音来识别事件。有人可以说，人类学习新的声音事件和识别声音事件的效率非常高。听播客仅使用声音识别能力来理解播客。有时，我们使用声音识别和其他感官信息来感知周围环境。

然而，系统地(最好使用计算机程序或算法)识别音频事件是非常具有挑战性的。这主要是因为，

• 录音剪辑的噪声——传感器噪声和背景噪声。
• 一个事件可能以不同的响度级别和不同的持续时间发生。
• 将有限数量的示例输入算法。

我们来看声音分类部分。假设问题是仅使用声音将给定的音频剪辑分类为以下事件之一。

• 打电话——通过电话交谈
• 掌声
• 跌倒——一个人跌倒在地上
• 扫地——用扫帚扫地
• 洗手——用水槽和水龙头洗手
• 看电视—电视声音
• 进/出—门打开或关闭的声音
• 其他—以上事件都不是

本文中使用的音频数据来自斯里兰卡莫拉图瓦大学收集的辅助生活数据集。音频剪辑是用两个 MOVO USB 全向麦克风录制的。wav 文件。声音事件分类是通过执行音频预处理、特征提取和分类来完成的。

音频预处理

首先，我们需要想出一个方法来表示音频剪辑(。wav 文件)。然后，音频数据应该被预处理以用作机器学习算法的输入。Librosa 库为用 python 处理音频提供了一些有用的功能。使用 Librosa 将音频文件加载到 numpy 数组中。该阵列将由各个音频剪辑的幅度以称为“采样率”的速率组成。(采样率通常为 22050 或 44100)

将一个音频片段加载到数组中后，第一个挑战——噪声——应该得到解决。Audacity 使用“频谱门控”算法来抑制音频中的噪音。该算法的一个很好的实现可以在 noisereduce python 库中找到。该算法可以在 noisereduce 库的文档中找到。

import noisereduce as nr# Load audio file
audio_data, sampling_rate = librosa.load(<audio_file_path.wav>)# Noise reduction
noisy_part = audio_data[0:25000]  
reduced_noise = nr.reduce_noise(audio_clip=audio_data, noise_clip=noisy_part, verbose=False)# Visualize
print("Original audio file:")
plotAudio(audio_data)
print("Noise removed audio file:")
plotAudio(reduced_noise)

Visualization of the Noise reduction with waveform plots

生成的音频片段中包含一个空长度(不必要的静音)。让我们来修剪比响度阈值静音的前导和尾随部分。

trimmed, index = librosa.effects.trim(reduced_noise, top_db=20, frame_length=512, hop_length=64)print(“Trimmed audio file:”)
plotAudio(trimmed)

Noise Reduced and silence trimmed audio file waveform

特征抽出

预处理的音频文件本身不能用于分类为声音事件。我们必须从音频片段中提取特征，以使分类过程更加高效和准确。让我们从每个音频片段中提取短时傅立叶变换(STFT)的绝对值。为了计算 STFT，快速傅立叶变换窗口大小(n_fft)被用作 512。根据等式 n_stft = n_fft/2 + 1 ，在 512 的窗口大小上计算 257 个频率仓(n_stft)。将窗口移动 256 的跳跃长度，以便在计算 STFT 时具有更好的窗口重叠。

stft = np.abs(librosa.stft(trimmed, n_fft=512, hop_length=256, win_length=512))

对于数据集，频率仓的数量、窗口长度和跳跃长度是根据经验确定的。对于特征生成中的参数，没有一组通用的值。这将在调整和增强结果部分再次讨论。

让我们回顾一下音频片段的绝对 STFT 特征的含义。考虑一个包含t个样本的音频剪辑。假设我们正在 STFT 获得f个频率仓。考虑窗口长度为w，窗口跳数为h。计算 STFT 时，将固定长度的w窗口滑动h步，得到一系列窗口。这将产生 1+(t-w)/h 个窗口。对于每个这样的窗口，记录范围 0 到 sampling_rate/2 内的频率仓的振幅(单位为 Hz)。当确定频率仓的值时，频率范围被等分。例如，考虑 n_fft=16 且采样速率为 22050 的 STFT 频段。那么将有 9 个频率仓具有以下值(以 Hz 为单位)。

[     0   ,   1378.125,   2756.25 ,   4134.375, 5512.5  ,   6890.625,   8268.75 ,   9646.875,  11025   ]

音频剪辑的绝对 STFT 特征是一个 2 维数组，它包含每个窗口的所提到的频率振幅仓。

因为声音事件具有不同的持续时间(样本数)，所以使用频率轴上的平均值来展平二维特征阵列。因此，将使用固定大小的阵列 257(STFT 频率仓的数量)来表示音频剪辑。这看起来像是音频剪辑的不良表示，因为它不包含时间信息。但是每个给定的音频事件都有其独特的频率范围。例如，扫频事件的刮擦声使其特征向量比落频事件具有更多的高频振幅。最后，通过最小-最大归一化对特征向量进行归一化。应用归一化以使每个声音事件位于共同的响度级别。(如前所述，振幅是一种音频属性，我们不应在此用例中使用振幅来区分声音事件)。下图显示了由绝对 STFT 特征捕获的声音事件的归一化 STFT 频率特征。

Normalized STFT Frequency signatures of Sweeping (right) and Falling (left) sound events

事件分类

现在，声音事件被预处理并使用 STFT 特征有效地表示。STFT 特征用于训练完全连接的神经网络(NN ),该神经网络将用于分类新的声音事件。神经网络由 5 个完全连接的层组成。这些层中有 256、256、128、128 和 8 个神经元。所有层都有 ReLU 激活函数，4ᵗʰ层有一个丢弃层，以减少对训练数据的过拟合。使用 Keras 密集层可以轻松构建神经网络(模型)。该模型是使用“亚当优化器编译的。

# build model
model = Sequential()model.add(Dense(256, input_shape=(257,)))
model.add(Activation(‘relu’))

model.add(Dense(256))
model.add(Activation(‘relu’))

model.add(Dense(128))
model.add(Activation(‘relu’))

model.add(Dense(128))
model.add(Activation(‘relu’))
model.add(Dropout(0.5))model.add(Dense(num_labels))
model.add(Activation(‘relu’))model.compile(loss=’categorical_crossentropy’, metrics=[‘accuracy’], optimizer=’adam’)

上述神经网络模型在 880 个样本上训练，并在 146 个样本上验证。它对看不见的音频事件进行分类，平均准确率为 93%。下图显示了与预测相对应的标准化混淆矩阵。

Confusion Matrix of the NN model’s prediction

调谐和增强结果

到目前为止，我们已经获得了一个非常好的模型。我们能做得更好吗？总会有更好的模式。极限是我们希望我们的分类有多好。查看混淆矩阵，我们可以观察到，像看电视这样的一些活动已经被错误分类，误差为 50%。因此，我们应该考虑调整模型，预处理和特征提取步骤。

我们可以通过编程来检查特征提取中频率仓数量、窗口长度和跳跃长度的最佳值。可以使用可视化方法来确定参数的最佳值。特征类型(这里是 STFTs 的绝对值)也可以由经验决定。机器学习模型是需要调优的必要部分。可以以这种方式确定层数、漏失层属性、激活函数、优化器和学习速率。

注:为了提高上述神经网络的精度，进行了一定程度的调整。你仍然可以提高。

下一步，我们可以实现一个连续的声音事件分类器，它接受音频流并实时对声音事件进行分类。希望这篇文章对你有用。在不久的将来，一篇关于连续音频分类的补充文章将会发表。

在这个 Git 仓库中找到完整的 python 代码。

声音 UX

原文：https://towardsdatascience.com/sound-ux-sound-representation-of-machine-learning-estimation-on-image-and-temperature-data-by-5b71bb4bb745?source=collection_archive---------29-----------------------

通过粒度合成对图像和温度数据进行机器学习估计的声音表示

本研究的目的是通过发音显示捕获的图像和温度数据。发音是一种将各种数据转换为声音的技术，用于辅助功能、媒体艺术和交互设计。我们提出了一种系统，通过图像和温度数据中的机器学习，根据移动对象之间的最小距离和路径预测来生成声音。声音依赖于基于 k-means、拟合和光流的路径预测数据的最小距离，并通过粒度合成和拍现象声音来设计。我们还检查了光流上的流动矢量图像分类和结果的声音分配。

本研究中考虑了环境智能，并提出了智能空间的概念，其中设备通过各种协议连接。环境智能必须是嵌入式的、环境感知的、个性化的、自适应的和预期的。[1]机器学习和人工智能是实现自适应和预期功能的关键技术。我们已经通过对象跟踪和对象识别考虑了环境空间，并且已经假设该空间具有通过各种协议彼此连接的设备，具有智能并且通过声音激活来提供服务。我们也考虑基于几种方法的研究，如 r .默里·斯查费和巴里·特鲁阿克斯提倡的声景、交互设计和媒体艺术

发音和机器学习

Figure 1. Conceptual Diagram

为了实现所提出的系统，考虑了通过发音和机器学习的响应系统。发音是一种从各种类型的数据到声音的转换技术，这种技术有很多实现方式。在这里，我们关注从图像数据到声音的转换。图 1 显示了这个过程的概念图。与图像中的对比度轮廓相关的数据通过声音设计被映射到指定的声音。图 1(a)显示了来自图像数据的实时声音映射，声音指示图像的当前状态。声音不包含未来信息。图 1(b)显示了来自图像数据的实时声音映射，包括指示当前状态的声音，以及机器学习和 AI 的预测。此外，系统可以将当前状态和预测作为未来信息进行比较。该系统是根据图 1(b)所示的类型设计的，图像数据使用实时数据和预测进行超声处理。

声音导航

我们考虑了声音导航以及图像和温度的声音表示。对声音导航的研究，包括诸如可访问性、交互设计和媒体艺术等领域，已经进行了。[4]为了用声音表示图像或温度数据，考虑了以下目标。

1 方向和距离的声音表示

从图像中提取的数据被转换成数字声音，并表示为空间信息。声音是根据距离和方向的不同而设计的。音高或音调取决于距离和方向，声音也因不同而变化。换句话说，如果物体的估计轨迹和实际轨迹之间的距离很大，则分配给这些轨迹的声音显著不同。

2 使用光流的运动物体的声音表现

光流信息由运动物体的速度矢量组成，图像中的点显示为矢量。流向量用于定义当前状态。我们使用相关系数和指定的声音来计算状态。

温度的发音

我们考虑了温度的发音。所实现的系统可以从传感器连续获得温度数据，并且我们检查了测井数据的发音。

系统型号

Figure 2 System Model

图 2 显示了本研究中使用的系统模型。这个系统的一个目的是用声音来表示方向和距离。我们通过机器学习实现了系统的嵌入式算法，以估计路径预测，并通过声音揭示预测和对象之间的差异。

机器学习

・Figure 3. Object Tracking

图 3 示出了对象跟踪图像。基于通过强度变化进行阈值处理并从原始图像中减去该图像，由照相机捕获的图像被转换成二进制图像。(右)如果图像中的对象连续移动，则减影图像中会保留白色像素，并通过标记算法为检测到的对象分配编号。(左)作为学习数据的对象的轨迹用于图像中的路径预测和状态。

通过多项式近似的路径预测

通过目标跟踪记录轨迹点，通过多项式逼近估计路径预测。多项式近似由最小二乘法导出。

距估计轨迹点的最小距离

Figure 4. Minimum Distance from Estimated Trajectory Point

图 4 显示了从直线(a)和曲线(b)的估计轨迹点的最小距离。在系统中计算基于公式的最小距离。

移动物体轨迹的 K 均值聚类

Figure 5. K-means Clustering for Moving Objects

系统中的摄像机可以检测与移动物体上的许多点相关的数据。为了将点分成若干组，在系统中使用了 K-均值聚类。图 5 示出了在三个集群的情况下移动对象的 k 均值聚类，并且三个组在图中由不同的颜色表示。红点表示与行人相关的移动物体上的点。将这些点分类成组取决于群集的数量，这必须决定。基于轮廓系数确定最佳聚类数。[5]图 6 示出了聚类数和轮廓系数之间的关系。在图 6 中，簇的数量是 3，轮廓系数随着接近 1 而提高。

Figure 6. Silhouette Coefficient[5]

图 7 示出了通过 k 均值和拟合的路径预测。该系统在将移动物体分类成组(三个集群)后，通过拟合来估计行人的轨迹。图 8 显示了估计轨迹的最小距离。该系统计算移动物体(行人)的最小距离并估计轨迹。

Figure 7. Path Prediction

Figure 8. Minimum Distance from Estimated Trajectories

光流

Gunnar Farneback 算法的高斯滤波器用于计算光流，并计算图像中均匀间隔的网格的速度矢量，以便测量作为大气的矢量流。图 9 示出了通过光流计算的速度矢量的例子。还计算了相关系数和向量之和。我们研究了基于光流速度矢量的客观标准的计算。

Figure 9. Example of Velocity Vectors by Optical Flow

温度数据

该系统使用温度计获取温度数据，然后用于确定空间的状态。来自温度数据的参数通过 OSC [7]发送到声音引擎(Max/MSP ),并进行发音。

发音

声音是为系统设计的，考虑了以下因素:

每拍的声音被分配给与预测轨迹的距离。

通过粒度合成的声音和通过距离控制参数的节拍变化。

声音分配

在系统通知表示距离或速度信息的声音之前，声音是通过声音映射生成的，距离被映射到声音。我们在声音映射中考虑了节拍和颗粒合成。

击败

Figure 10. Beat

拍是两个频率略有不同的波之间的干涉图案。图 10 显示了 440 Hz 和 445 Hz 正弦波产生拍频的情况。该模式是周期性振动。图 11 显示了一个最大/MSP 节拍补丁示例。

Figure 11. An Example of Max/MSP Patch (Beat)

颗粒合成

我们研究了系统中颗粒合成的声音生成。颗粒合成得到的声音由颗粒组成，颗粒是被分裂成小波片段的样本。图 12 显示了颗粒合成的原理。通过以下程序制造颗粒。

1.样品中谷物的提取

2.乘以窗口函数

提取的样本 s ( n )乘以一个窗口函数，得到一个区间之外的值。我们根据移动物体和估计轨迹之间的距离，通过改变振幅和频率来设计颗粒。交叉合成是通过卷积进行的信号处理，它涉及两个谱函数的相乘。

Figure 12. Granular Synthesis

我们通过交叉合成设计声音，并假设抽象的声音，其中包括一些音高和环境声音，如汽车噪音。图 13 显示了利用正弦波和汽车噪声的两个 880Hz 样本进行交叉合成获得的频谱。

Figure 13. Spectrum by Cross Synthesis (Car Noise and Sine Wave)

在图 13 中，上方正弦波的最大幅度为 0.7，下方正弦波的最大幅度为 0.2。由于正弦波的影响，880 Hz 左右的频率存在于较低正弦波的底部。相比之下，由于汽车噪音的影响，较高正弦波的顶部存在一个频率范围。这意味着自波动以来，熵在上层的顶部增加了。图 14 显示了颗粒合成贴片(Max/MSP)。声音的产生取决于与运动物体和轨迹之间的距离有关的控制参数。

Figure 14. Granular Synthesis Patch (Max/MSP)

系统实现

Figure 15. System Implementation

该系统由数据分析器、摄像机、温度计和声音引擎组成(图 15)。数据分析器通过 OpenCV 和传感器数据库分析图像数据和温度数据。一些关于移动物体的数据和温度数据存储在一个文件中，并由与机器学习相关的 python 脚本进行分析。获得的数据通过 OSC 协议发送到声音引擎(Max/MSP ),声音通过粒度合成和实时节拍生成。

总结

Figure 16. Correlation Coefficients of Velocity Vectors

基于光流数据的结果，我们研究了速度矢量的相关系数。图 16 显示了速度矢量图像(a)、(b)和©。红线表示速度矢量。如果存在移动物体，图像中会出现许多红线。我们计算了每个组合的速度向量的相关系数。表 1 显示了这些组合的结果。图 16(a)和(b)没有显示速度矢量，而图 16©中出现了许多速度矢量。基于速度向量的相似性，图 16(a)和 16©之间的相关系数非常低(0.026171)，而图 16(b)和 16©之间的相关系数很高(0.2745)。

本研究的结论如下:

1 相关系数和平均值是判断图像情况的标准。

2 运动物体和轨迹之间的距离是影响路径预测的一个重要因素。

参考

1.阿尔茨，e。和 b。埃根(编辑。) [2002].家庭实验室的环境智能研究。恩德霍芬菲利普斯研究公司。

2.“建筑用户界面:建筑设计和人机交互发展的主题、趋势和方向”，Martyn Dade-Robertson，《国际建筑计算杂志》，2013 年 3 月 1 日

3.“为响应式环境设计声音表现”Takuya Yamauchi，第 22 届听觉显示国际年会(ICAD2016)，澳大利亚国立大学，堪培拉，2016 年 7 月 3 日至 7 日

4.“声音珠宝”山内拓哉和岩武彻莱昂纳多音乐杂志第 18 期麻省理工学院出版社

5.《Python 机器学习》，塞巴斯蒂安·拉什卡，Packt 出版社

6.建筑用户界面:建筑设计和人机交互发展的主题、趋势和方向。

7.Wright，m .，Freed，A .，“开放式声音控制:与声音合成器通信的新协议”，国际计算机音乐会议，塞萨洛尼基，希腊，1997 年

今日汤

原文：https://towardsdatascience.com/soup-of-the-day-97d71e6c07ec?source=collection_archive---------8-----------------------

数字音乐

美汤网刮——初学者指南

尽管有成千上万可爱干净的数据集可供数据科学家们使用(大部分在 Kaggle 上)，但你总是会有那些讨厌的假设不在他们的范围之内。从头开始创建你需要的数据集是一个潜在的令人生畏的前景——即使你能在网页上看到数据，实际上将它转换成可供分析的格式可能涉及大量的手工工作。

令人高兴的是，网络抓取自动化了从网页中检索信息的过程，通过使用正确的工具，我们可以创建可靠的数据存储，然后进行分析。

注意——这是一系列文章中的第一篇。在这里，我们将一步一步地用漂亮的 Soup 库介绍 webscraping Metacritic 的机制。随后的博客将深入探讨我们对其背后进行的分析。

第一步。对 HTML 的理解刚刚好

超文本标记语言(HTML)是告诉网络浏览器在页面上显示什么信息的代码。重要的是，它没有说太多关于如何显示信息(网站通常组合两组代码，HTML 和层叠样式表 (CSS)来呈现页面，CSS 负责页面的外观)。

这很重要，因为我们感兴趣的是网页的信息，我们知道这些信息将被存储在 HTML 代码中的某个地方。

有益的是，大多数浏览器提供了一种简单的方法来查看 HTML 代码的哪一部分引用了页面上的特定元素。

Right-click on any element on the page, then select ‘Inspect Element’

This brings up the browser’s ‘Inspector’, and shows which line of the HTML refers to which element on the web page

This process also works in reverse — we can hover over a line of code in the Inspector, and it’ll highlight the part of the web page that this code refers to

HTML 代码本身可能看起来吓人，但是结构比看起来要简单。内容通常包含在“标签”中，标签是在<>括号内的东西。例如，当声明一段文本时，HTML 代码可能如下所示:

<p>My text here, inside the paragraph tags</p>

HTML 有不同类型的标签，做不同的事情——最常见的(正如你在上面的截图中看到的)是:

• 表头: < h1 > < /h1 >(注意，我们可以有 h1，h2，…，h6，这取决于想要的表头层次结构)。
• 有序列表: <李></李>
• 无序列表: < ul > < /ul >(即项目符号样式列表)
• 超链接:
• Span:(用于识别段落中的子字符串——如果您希望您的同伴 CSS 代码只格式化句子中的某些单词，这很有用)
• 语义元素: < div > < /div >

注意——语义元素是一个包罗万象的范畴，而“div”是一个你会在 HTML 的许多块中经常看到的术语。这些“div”标签的典型用途是创建“子元素”，其中可以包含列表、其他标题和其他子元素。

这就像计算机文件资源管理器中的文件夹树结构——根“我的文档”文件夹可能包含文档和文件，但也可能包含其他文件夹。这些文件夹可以依次包含更多的文件夹。

因此，如果我们想在这个元符号页面上隔离特定专辑的“发布日期”,我们可以看到它包含在几个嵌套的子元素中。最终，我们可以在代码本身中找到发布日期。

正如我们所看到的，许多标签还具有其他属性来进一步区分它们自己。这些通常被标记为元素的“id”或“class”。当我们从 HTML 代码中提取数据时，这些将是至关重要的。

第二步。将 HTML 提取到 Jupyter 笔记本中

我们可以在浏览器中看到 HTML 现在我们需要将它放入 Jupyter 笔记本(或等效物)中，以便我们可以分析它。为此，我们使用 python 的’请求库。

请求的语法非常简单。假设我们想从上面提到的 Metacritic 中获取 HTML。我们可以使用。get()方法:

**import** requestsurl = [https://www.metacritic.com/browse/albums/artist/a?num_items=100](https://www.metacritic.com/browse/albums/artist/a?num_items=100)page = requests.get(url)

我们现在可以在“page”变量上调用一些其他有用的方法。例如，我们可以检查状态码。

page.status_code

如果这返回‘200’，那么我们都很好，尽管其他的状态代码可能表明我们需要修改最初的‘请求’。

第三步。阅读 HTML 汤

一旦我们有了“请求”对象(“页面”)，我们就可以使用 Beautiful Soup 库中的 html.parser 特性来理解它的内容。

**from** bs4 **import** BeautifulSoupsoup = BeautifulSoup(page.content, ‘html.parser’)

然而，如果我们实际调用“soup”变量，我们会看到事情仍然有点混乱(当然远远谈不上美好)。

This output goes on for quite some time…

这就是浏览器的检查器派上用场的地方。因为我们可能有一个好主意，知道我们想从页面中获得什么信息，所以我们能够在 inspector 中找到相应的 HTML。

因此，如果我想在这个页面上创建一个所有艺术家名字的列表，我可以在第一个这样的名字上‘检查元素’,并查看信息是如何存储在 HTML 中的。

我们可以看到，艺术家名“A Camp”存储在一个“有序列表”(由

• 标记表示)中，其类为“stat product_artist”。给定网站的结构，我们可以猜测所有艺术家的名字将以相同的方式存储(尽管我们当然可以通过检查元素来检查这一点，就像我们对“A Camp”所做的那样)。

我们用漂亮的汤。findAll()方法，使用类“stat product_artist”查找有序列表的所有实例，将这两个特征指定为单独的参数。

artistHTML = soup.findAll(‘li’,class_=”stat product_artist”)

这给了我们一个“bs4.element.ResultSet”类型的对象。仔细观察这个对象，我们可以看到它看起来有点像 python 列表。

特别是，我们可以索引这个 ResultSet 对象来隔离不同的艺术家名字(我们可以使用’ len '函数来检查我们有多少，在这个例子中是 99)。

请注意，“bs4.element.ResultSet”对象中的这些元素本身是类型为“bs4.element.tag”的对象。

这意味着他们带来了一些新的方法，可以帮助我们提取我们需要的信息。

在这一点上我们应该注意，这不是获取艺术家姓名信息的唯一方式。我们还可以在 HTML 中更深入一层，尝试 soup.findAll('span '，class_= "data))。然而，这种方法增加了一层复杂性——事实证明，使用这种标签存储的每个相册有三种不同类型的信息；艺术家姓名、发行日期和 metascore。这是可以管理的，但是所描述的方法可能会更加直接。

第四步。从 HTML 标签中提取数据

获取存储在标签中的信息(并确保它以正确的格式返回给我们)并不总是最直接的任务，可能需要一些尝试和错误。我倾向于先采用几种不同的方法。

。get_text()往往是最可靠的。有时，我们需要对它输出的字符串进行编辑，以使它们成为所需的形式。因此，我们应该在不同的元素上尝试该方法，以确保我们可以在所有元素上进行相同的编辑。

我们可以看到，我们需要去掉艺术家姓名两边的子字符串。我们可以为此使用一个正则表达式方法，但是，我们可以偷懒，将两个。请改为 replace()方法:

artistHTML[0].get_text().replace(‘\n’, ‘’).replace(‘Artist:’, ‘’)

我们现在可以遍历 artistHTML 中的不同元素，提取艺术家的名字，并将它们放入一个列表中。我们可以使用循环来实现这一点:

artists = []
**for** element **in** artistHTML:
    artist = element.get_text()
    artist_final = artist.replace(‘\n’,’’).replace(‘Artist:’,’’)
    artists.append(artist_final)

…或者是列表理解，我发现这样更有条理:

artists = [element.get_text().replace(‘\n’,’’).replace(‘Artist:’,’’)
           **for** element **in** artistHTML]

然后这些列表可以按原样存储，或者例如可以将它们放入熊猫数据帧中。

如前所述，从汤里提取数据有许多不同的方法。和大多数“编码”一样，很少有一种正确的方法来做某事——漂亮的汤文档是一个很好的地方来看看不同的元素方法在起作用。

第五步。正在获取所有数据…

一旦我们从网页中提取了我们想要的所有数据。根据站点的结构，下一个任务是从新页面中提取数据。

例如，如果我们想要 Metacritic 中的所有艺术家的名字，我们将需要转到第 2 页，然后是第 3 页，依此类推(这只是针对以“A”开头的艺术家！).显然，我们希望这样的过程可以通过代码自动完成。有几种方法可以解决这个问题。

1. 第二次猜测网址

我们刚刚抓取的网址是:

[https://www.metacritic.com/browse/albums/artist/a?num_items=100](https://www.metacritic.com/browse/albums/artist/a?num_items=100)[&page=0](https://www.metacritic.com/browse/albums/artist/a?num_items=100&page=1)

如果我们跟随链接到第 2 页，然后到第 3 页，我们看到的网址是:

[https://www.metacritic.com/browse/albums/artist/a?num_items=100&page=1](https://www.metacritic.com/browse/albums/artist/a?num_items=100&page=1)[https://www.metacritic.com/browse/albums/artist/a?num_items=100&page=2](https://www.metacritic.com/browse/albums/artist/a?num_items=100&page=2)

显然，我们有一个模式 URL 末尾的数字是页码减一。这意味着我们可以非常简单地遍历 URL，依次抓取每个 URL。

首先，我们需要确定给定字母有多少页(以“A”开头的艺术家有 11 页，但显然以其他字母开头的艺术家会有多或少)。

鉴于这个数字显示在页面上，我们可以在 HTML 中找到它。我们可以使用步骤 2、3 和 4 中描述的过程来分离这个数字，并将其分配给 python 中的一个变量(我们称之为“pages”)。

**for** page_number **in** range(pages): url = f'https://www.metacritic.com/browse/albums/artist/a?num_items=100&page={page_number}' page = requests.get(url)*# We then include the scraping code* ***inside*** *the loop, ensuring that data from each new URL is appended to data collected from the previous pages - either in lists, or Pandas dataframes*

2。在 HTML 本身中查找下一个 URL

对于组织良好的网站(如 Metacritic ),第二次猜测 URL 就足够了，但是对于其他不太整洁的网站，这种方法可能不起作用。然而，假设我们在页面上有一个“下一页”按钮，我们可以在 HTML 中找到它及其相应的超链接。

假设我们在寻找一个超链接，我们应该留意标签。我们可以像第 3 步一样使用 soup.findAll()方法。注意，即使只有一个这样的元素，findAll 方法仍然是一个类似列表的对象，我们需要对它进行索引。

考虑到 URL 就在标签本身中，我们信任的。get_text()方法将在这里工作。相反，我们可以查看元素的属性，使用。attrs 的财产。

注意 attrs 对象看起来很像一本字典。因此，我们可以使用“href”键来查找所需的值。然后我们可以使用 f 字符串输出完整的 URL。

这个 URL 可以被传递到请求中(参见步骤 1)，并且生成的页面可以被抓取。通过将这些代码行作为循环的一部分，我们可以让我们的抓取代码自动依次遍历每个页面。

网络搜集是一项非常强大的技术，也是任何数据科学家弓上的一根弦。上面的指南是作为一个起点写的，尽管还有许多其他的免费技术(事实上，除了漂亮的汤之外还有其他的刮库)。

刮的开心！

空间基础

原文：https://towardsdatascience.com/spacy-basics-4b606a70f97b?source=collection_archive---------18-----------------------

NLP 和 spaCy 入门指南

Photo by Patrick Tomasso on Unsplash

文本数据的一个主要挑战是提取有意义的模式，并使用这些模式找到可操作的见解。

NLP 可以被认为是一个由两部分组成的问题:

1. **加工。**将文本数据从原始形式转换成计算机可以理解的形式。这包括数据清理和特征提取。
2. **分析。**利用处理后的数据提取见解并做出预测。

这里我们将重点关注处理步骤。

我们将使用通过抓取唐纳德·特朗普的推文创建的数据集。创建你自己的 Twitter 数据集的教程可以在这里找到:

[## 我的第一个 Twitter 应用

如何使用 Python 和 Tweepy 创建自己的数据集

towardsdatascience.com](/my-first-twitter-app-1115a327349e)

我们将专门关注 spaCy “一个用于 Python 中高级自然语言处理 (NLP)的免费开源库”

spaCy 对于 NLP 任务来说是一个很好的选择，特别是对于处理文本来说，它有大量的特性和功能，其中很多我们将在下面讨论。

完整的笔记本可以在这里找到。

标记化

根据researchgate.net的说法，令牌的一个很好的定义是“两个空格之间，或者空格和标点符号之间的一串连续的字符。”在英语中，标记通常是单个单词，但也可以是标点符号和数字。

首先，我们使用spacy.load()方法加载模型包并返回 nlp 对象。接下来，我们调用字符串上的nlp(), spaCy 标记文本并创建一个文档对象:

# Load model to return language object
nlp = spacy.load('en')# Calling nlp on our tweet texts to return a processed Doc for each
df['doc'] = [nlp(text) for text in df.text]
df.sample(3)

Dataframe with Doc column added.

在标记化之后，我们可以做各种事情。

我们可以做一些基本的事情，比如计算每个文档的令牌数，并用直方图显示出来:

# Sum the number of tokens in each Doc
df['num_tokens'] = [len(token) for token in df.doc]# Visualize histogram of tokens per tweet
g = sns.distplot(df.num_tokens)

Histogram of tokens per tweet

或者我们可以利用 spaCy 提供的许多可用的令牌属性。

词性标注

Spacy 使使用标记属性获得词性标签变得容易:

# Print sample of part-of-speech tags
for token in sample_doc[0:10]:
    print (token.text, token.pos_)

Tokens and their part-of-speech tags.

命名实体

除了词性标签，我们还可以预测文档中出现的命名实体。

根据维基百科，一个命名实体“是一个现实世界的物体，比如人、地点、组织、产品等等。，可以用一个合适的名字来表示。”

for ent in sample_doc.ents:
    print(ent.text, ent.label_)

Named entities from sample tweet.

而且，如果我们不知道输出意味着什么，spaCy 必须了解 NORP 代表民族、宗教或政治团体。

在这种情况下，该模型正确地预测了“民主党人”是一个 NORP，但却错误地把“椭圆形办公室”归类为一个组织。

我们可以使用 spaCy 的 visualizer displaCy 来可视化命名实体:

# Visualize named entities with displacy
spacy.displacy.render(sample_doc, style='ent', jupyter=True)

displaCy entity visualization.

词汇化

词汇化是将每个单词还原到它的词根，或词汇。

比如谈、谈、谈都是同一个词的形式。它们都有一个共同的词根:说话。

在 spaCy 中，我们调用token.lemma_来获得每个单词的词条。

结论

这里我们探讨了 spaCy 的一些基本功能，包括标记化、词性标注和词条化。这些只是图书馆提供的众多工具中的一部分。

在以后的文章中，我们将探索使用上述方法从文本数据中获得洞察力。

Spacy + Redis =魔法

原文：https://towardsdatascience.com/spacy-redis-magic-60f25c21303d?source=collection_archive---------14-----------------------

Source : Pixabay

我是 Spacy 的常客，过去我曾用它解决过一些有趣的问题。自然语言处理中的一个基本问题是寻找单词或短语之间的相似性。许多自然语言处理库提供了通过余弦相似度分数来检查单词/短语是否相似的功能。

问题

找到两个词之间的相似之处很容易。如果你说了 20 万个单词会怎么样！！并且想要对照包含 10k 个单词的表格来检查每个单词的相似性。更不用说为每个单词存储 3 个最相似的单词，并写入 csv 文件或您的数据库。

您的普通笔记本电脑可能无法处理这样的内存密集型工作。

即使有，那也是极其缓慢的！！

输入 Redis

什么是 Redis

Redis 代表RemoteDidictionarySserver。它是一个快速、开源、内存中的键值数据存储，可用作数据库、缓存、消息代理和队列。Redis 由 Salvatore Sanfilippo 开发。

为什么要用 Redis？

因为它快得惊人！！

现在，下一个显而易见的问题是，是什么让它变得如此之快？

答案是，与将数据存储在磁盘或 SSD 上的数据库相比，所有 Redis 数据都驻留在内存中。通过消除访问磁盘的需要，Redis 等内存中的数据存储避免了寻道时间延迟，可以在几微秒内访问数据。

回到问题

好吧，那么，回到我们的问题。由于我的笔记本电脑没有足够的计算能力和存储空间，我决定在 AWS 上构建一个 EC2 实例。

你可以参考我的这篇文章，按照步骤 1 到 3 来创建 EC2 实例并选择合适的机器映像。对于这个任务，我推荐至少有 64 GB 内存的更高的实例类型。

一旦创建了 EC2 实例，就必须执行以下步骤

安装 Redis

安装 Python (推荐 3.5+版本，你可能还要安装其他包，比如 numpy，pandas)

安装空间

安装 Tmux(我会谈到为什么我们需要它)

假设您已经正确安装了以上所有组件，让我们来看看代码。

第一步:启动 redis 服务器并访问它

初始部分是不言自明的，我们导入所需的包。然后我们进入 redis 服务器。

第二步:从大名单中读出单词。

Redis 支持许多数据结构。我们将在本文中广泛讨论的数据结构之一是列表(在 redis 的上下文中)。列表是一系列有序的值。与列表交互的一些重要命令有 RPUSH 、 LPUSH 、 LLEN 、 LRANGE 、 LPOP 和 RPOP 。要了解更多，可以访问 redis 的这个精彩的互动教程。

在下面的代码片段中，我们定义了一个函数来读取 20 万个单词。单词存储在 csv 文件“big_Keywords”中名为“keyword”的列中。单词被一个一个地读取，并存储在“big_words”键下的列表中。

你可以在这里插入包含大量单词的文件，而不是“big_keywords”文件。

第三步:通过空间进行单词相似度。

所以让我们解开上面的代码。首先，我们下载预训练的空间模型“en_vectors_web_lg”。然后我们读取包含 10k 字的参考文件‘small _ topics . CSV’。(您可以在这里插入自己的文件)。

接下来，我们使用命令 LPOP (lpop)从更大的列表“big_keywords”中逐个删除元素。(记得我们之前创建了一个列表‘big _ keywords’并通过 LPUSH 将单词放入这个列表中)。

然后我们有了标准的循环，我们做的核心工作是从两个列表中寻找单词之间的相似性。然后，我们通过命令 Zadd 将结果以格式(big_word，topic，score)存储到一个集合中。

例如(苹果，菠萝，0.7)，苹果是大列表中的一个单词，它在小列表“主题”中有一个相近的匹配。0.7 的分数是余弦相似性分数。

现在这里有一个小问题。使用 Zadd 时，值按升序存储，但是我们希望值按降序存储。因为余弦值为 1.0 意味着完全匹配。所以我们要寻找精确的单词匹配或者至少是最接近的匹配。为此，我们使用命令 zrevrangebyscore 。

现在我们已经得到了我们想要的排序列表，我们通过 lpush 将它们放入名为“results”的列表中。

第四步:调用函数。

我们最终完成了所有的逻辑工作，现在剩下的就是将结果放入一个新的 csv 文件中。之后，我们编写一小段代码来调用每个函数。

给我看看魔法

Source : Pixabay

我把这篇文章命名为 Spacy + Redis= Magic。现在是时候揭示 Spacy 和 Redis 的组合到底有什么神奇之处了。

首先，我们确保我们的 redis 服务器启动并运行。您可以通过输入命令“redis-cli”后跟“ping”来检查这一点。如果 redis 安装正确，服务器启动并运行，那么您应该得到’ pong ’

现在神奇的部分来了，我们现在阅读 200K +以上的单词。

不可思议的是，这 200，000+单词在不到 3 秒的时间内就被读完了！！

单词读得太快了，以至于一开始我以为单词根本没读。我通过命令“llen”验证了这些单词是否被阅读。

输入 Tmux

我之前告诉过你我们需要 Tmux。那么 Tmux 是什么呢？

Tmux 代表终端多路复用器，它非常有用，因为它允许您在命令行环境中平铺窗口窗格。这反过来允许你在一个终端上运行或监视多个程序。

有各种快捷方式来分割窗格，如

ctrl + b %:垂直分割屏幕

ctrl+b”:将屏幕水平分成两半

ctrl+b c:创建一个新的窗格
ctrl+b 箭头键让你从一个屏幕导航到另一个屏幕。

你可以在这里这里和这里阅读更多优秀资源

我如何在我的案例中使用 Tmux

如果你还记得的话，我告诉过你，考虑到大量单词的性质，寻找相似单词的整个过程是一个非常耗费记忆的过程。我们有一台拥有多个内核的远程机器。使用尽可能多的内核是理想的，因为这将加快我们的进程。

通过 Tmux，我们可以同步屏幕并同时运行我们的流程，如下所示。

整个过程可能需要 18-20 小时。如果我们不使用 Redis，这个练习可能需要几天时间！！

一旦整个过程完成，我们可以输入命令“python 3.7 spac redis . py dump”。这将生成结果 csv 文件。

完整的代码可以在下面的要点链接中找到

希望你喜欢这篇文章。

你可以联系我

领英

推特

参考资源:

• Redis_AWS
• 数字 _ 海洋 _redis
• Redis_Interactive
• Tmux
• Redis 博客
• Redis Github
• Tmux_sync_panes

基于 TensorFlow Lite 的 Android 文本分类

原文：https://towardsdatascience.com/spam-classification-in-android-with-tensorflow-lite-cde417e81260?source=collection_archive---------9-----------------------

📱移动机器学习

使用 Android 中的 TF Lite 模型对文本进行分类

机器学习已经被证明在一些用例中表现出色，比如我们将在你的 Android 应用中执行的垃圾邮件分类。我们将在 Python 中开始使用它，这是我们使用 Keras ( TensorFlow)创建分类器的地方。

本文假设您已经初步了解 TensorFlow、文本分类和 Android 应用程序开发。🤔

路线图

1. 我们在 Python 中使用tensor flow和Keras创建一个分类器。
2. 将 Keras 模型转换为tensor flow Lite模型
3. 将 Keras 的 tokenizer 词汇表转换成 JSON 文件。
4. 在 Android 中加载 TF Lite 模型和 JSON 文件。
5. 在 Android app 中对模型进行推理。

我将参考这个项目的 GitHub 资源库的各种文件。您可以在旁边打开它，以获得更好的学习体验。😀

Python 项目回购->https://github.com/shubham0204/Spam_Classification_TF

Android 项目回购->https://github . com/Shu bham 0204/Spam _ class ification _ Android _ Demo

先从(Python 开始！😍)

Exciting hearing “Python”?

首先，我们需要使用 Pandas 解析 CSV 文件中的数据。然后，我们需要对消息进行标记，填充它们，并将它们存储在 NumPy 数组中，用于训练和测试。最后，我们有了生成 5 个文件的DataProcessor.py脚本。(参见data processor . py文件)

android / 
        - word_dict.json
processed_data / 
        - x.npy
        - y.npy
        - test_x.npy
        - test_y.npy

想知道word_dict.json文件是从哪里来的？你知道我们需要一个tf.keras.preprocessing.text.Tokenizer对象来标记消息。

Tokenizer 维护一个 Python dict对象，该对象包含成对的单词及其索引。我们使用以下方法将这个dict转换成一个 JSON 文件:

Snippet 1

我们可以使用记号赋予器将文本转换成整数序列。但是，对于 Android 中的推理，我们将需要这个词汇。此外，代码将输出所有序列的最大长度。我们在 Android 中将需要这个最大长度。

我们需要在 TensorFlow 中创建一个分类器。如果你是一个经验丰富的 ML 开发人员，这很容易，对不对？(参见model . py文件)

Snippet 2

注意: activations.leaky_relu 是自定义实现，在官方 TensorFlow 版本中不可用。可以尝试使用 ***tf.keras.layers.LeakyReLU*** 中的 LeakyReLU 图层。

我们可以轻松达到 86%的准确率😎对于垃圾短信收集数据集由Kaggle.com上的UCI 机器学习。接下来，我们将把训练好的 Keras 模型保存到一个 h5py ( .h5)文件中。我们可以通过调用方法来实现这一点:

model.save( 'models/model.h5' )

现在，为了在 Android 上使用这个模型，我们需要将这个文件(model.h5)转换为 TensorFlow Lite 模型。那很简单😅我们也可以使用后训练量化来减少模型的大小。(参见tflitebufferconverter . py文件)

Snippet 3

Python 中的工作已经完成。现在，我们将只使用 Android 中android/目录下列出的文件。(参见 安卓/ 目录)

android/
    - word_dict.json
    - model.tflite

创建 Android 应用程序(Kotlin Now！)

First impressions with Kotlin

Android 应用程序将使用我们在 Python 中训练的模型将消息分类为垃圾邮件或非垃圾邮件。这将是一个简单的应用程序，有一个 EditText 和一个用 Kotlin 编程的按钮😤。

还记得 GitHub Repo->https://GitHub . com/shubham 0204/Spam _ Classification _ Android _ Demo吗

从一个项目开始

1. 我们创建一个简单的空项目(很可能在 Android Studio 中)
2. 选择 Kotlin/Java 作为编码语言。
3. 将 Python 项目中 ***android/*** 目录下的所有文件复制到你 app 的 assets 文件夹中。(参见[***assets/***](https://github.com/shubham0204/Spam_Classification_Android_Demo/tree/master/app/src/main/assets)【文件夹】
4. 在您的 ***build.gradle*** ( app 级) 中添加 TensorFlow Lite(版本 1.13.1)依赖项

dependencies {
    // Other app dependenciesimplementation **'org.tensorflow:tensorflow-lite:1.13.1'** }

在你的build.gradle(应用级)中，添加这些不允许压缩.tflite文件的行。

android {
      ...
    }
    buildTypes {
        release {
            ...}
    }
    aaptOptions {
        noCompress **"tflite"** }
}

从 JSON 文件加载词汇表

我们从应用程序的 assets 文件夹中加载word_dict.json文件。我们将把它解析成一个包含单词索引对的HashMap。(参见classifer . kt文件)

Snippet 4

现在，我们可以使用data散列表从单词中获取我们在 Python 中用于训练的索引。

在主(UI)线程上解析如此巨大的 JSON 文件不是一个好的做法，因为它可能会干扰线程上的其他进程。因此，我们使用 Kotlin 协程来高效地执行这项任务。

标记和填充文本

这个任务是用 Python 执行的。但是，由于我们倾向于将标记化和填充的整数序列提供给我们的模型，我们将在 Kotlin 中编写两个方法来实现这一点。(参见classifer . kt文件)

Snippet 5

this.maxlen的值为 171。记得吗？我们的 Python 项目告诉我们，最大长度是 171，我们将所有序列填充到 171 的长度。vocabData是散列表，我们在前面的方法中加载了它。

注意，如果这个单词在词汇表中不存在(data HashMap)😔然后我们返回一个索引 0。

从资产文件夹加载模型

我们以 MappedByteBuffer 的形式从assets文件夹中加载模型。(参见main activity . kt文件)

Snippet 6

对邮件进行分类

现在，我们将所有方法组合在一起，对消息进行分类并打印结果。(参见main activity . kt文件)

Snippet 7

结果😎

还有呢！

仅此而已。累了吧？😴

That’s awesome!

希望你觉得这个博客有趣。对于任何建议和疑问，请在评论区自由表达。

TensorFlow 和 Android 可能会成为👫

谢谢你。😀

具有深度学习的垃圾邮件过滤系统

原文：https://towardsdatascience.com/spam-filtering-system-with-deep-learning-b8070b28f9e0?source=collection_archive---------6-----------------------

并探讨了单词嵌入的幂特征提取

Photo by Ant Rozetsky on Unsplash

深度学习在许多行业变得非常流行，许多有趣的问题都可以通过深度学习技术来解决。在本文中，我将向您展示如何利用深度学习模型来设计一个超级有效的垃圾邮件过滤系统。

不久前，我写了一篇关于用传统的机器学习算法过滤垃圾邮件的文章。

在那篇文章中，我介绍了从数据探索、数据预处理、特征提取到为算法选择正确的评分标准。有兴趣的可以看这里的文章！

今天，在构建垃圾邮件过滤系统时，我将更多地关注以下两个部分:

1. 单词嵌入
2. GRU +双向深度学习模型

什么是文字嵌入？

单词嵌入是以矢量化格式表示的文本数据。因此，对于像“dog”这样的单词，单词 embedding 会将其转换为一个形状为(1，x)的向量，x 是一个可以配置的值。

直觉上，你可以把这个向量看作是描述这个词的一种方式。如果这个词是一个形状向量(1300)，这意味着有 300 个不同的特征描述这个词。

那些特征是什么？老实说，我们不知道。深度学习将在训练过程中识别这些特征。

训练过程的最终结果是从单词到有意义的单词向量的映射。

听起来像个很酷的魔术，是吧？更酷的是，两个单词向量之间的余弦距离实际上意味着一些重要的东西。

具有更接近语义的单词在向量空间中将具有更短的余弦距离。

例如，向量“男人”和向量“女人”之间的余弦距离非常接近。

w2v.most_similar('man')# Output
# [('woman', 0.699),('person', 0.644),('him', 0.567)]# 'woman' has the highest similarity score with 'man'

预训练权重的单词嵌入

有一些开源的单词嵌入已经在大量的文本数据上进行训练，它们的权重开放给公众下载。

通过使用开源单词嵌入，您可以节省收集文本数据的时间。而且，还可以节省生成单词嵌入的时间和计算资源。

使用预先训练的单词嵌入的缺点是单词嵌入可能在来自不同域的数据源上被训练。这可能并不总是适合您正在应用的用例。

例如，在科学期刊的文本数据上训练的预训练单词嵌入可能不太适合检测恶意推文之类的问题。这个单词嵌入的好处不会那么显著。

预训练单词嵌入的不同变体

大多数开源单词嵌入都列出了它们被训练的来源，所以你需要根据你要解决的问题仔细选择。

以下是一些例子:

1. 手套

2.维基新闻

3.谷歌新闻矢量

试验单词嵌入

在本教程中，我们使用手套字嵌入。手套嵌入的格式与 python 库 **gensim，**所期望的有点不同。

所以你从手套官网下载嵌入这个词之后，需要做一些简单的转换。

通过运行下面的 python 脚本，可以很容易地将其转换成与 word2vec 嵌入兼容的格式。

确保您安装了 python gensim 模块。

python -m gensim.scripts.glove2word2vec -i glove.6B.300d.txt -o glove.6B.300d.word2vec.txt

之后，您可以使用 gensim 库轻松加载它，

w2v = KeyedVectors.load_word2vec_format(
      'glove.6B.300d.word2vec.txt’,binary=False)

我们还可以对这个向量执行一些操作，并得到一些有趣的结果。

例如:

例 1:国王-男人+女人=王后

示例 2:马德里-西班牙+法国=巴黎

让我们看看如何在代码中实现这一点，以及我们可能会得到什么有趣的结果。

w2v.most_similar(['king','woman'],negative=['man'],topn=1)
# Output: [('queen', 0.6713277101516724)]w2v.most_similar(['madrid','france'],negative=['spain'],topn=1)
# Output: [('paris', 0.758114755153656)]

我们还可以让单词嵌入模型计算出给定单词列表中哪个是离群值

w2v.doesnt_match("england china vietnam laos".split())
#Output: englandw2v.doesnt_match("pig dog cat tree".split())
#Output : treew2v.doesnt_match("fish shark cat whale".split())
#Output : cat

我已经在笔记本中包含了相关代码，您可以尝试不同的输入，看看它是否符合您的期望。

现在我想你已经见证了单词嵌入强大的特征提取能力。

在下一节中，我们将了解如何将这种预训练的单词嵌入与 Keras 中的嵌入层相结合，以便我们可以在训练中使用它。

嵌入层

Keras 是一个非常棒的高级深度学习库，可以帮助你轻松构建深度学习模型。它抽象了许多低级的数学细节，让你以一种非常直观的方式建立你的模型。

嵌入层是 Keras 提供的包装层之一，方便我们训练单词嵌入。

首先，我们需要利用 tokenizer 来帮助我们将所有的单词转换成某种标记/索引。

在标记化层，他们维护一个将单词映射到索引的字典。比如狗-> 0，猫->1 等等。

max_feature = 50000tokenizer = Tokenizer(num_words=max_feature)
tokenizer.fit_on_texts(x_train)# Converting x_train to integer token, token is just an index number that can uniquely identify a particular wordx_train_features = np.array(tokenizer.texts_to_sequences(x_train))
x_test_features = np.array(tokenizer.texts_to_sequences(x_test))

Tokenization Layer to transfer text to simple token

Internal working of the tokenization layer

嵌入层将在内部维护一个查找表，该查找表将索引/标记映射到一个向量，该向量在高维空间中表示单词。

Full overview of the whole transformation

Brief summary of the whole process

嵌入+双向+门控递归单元(GRU)

GRU

GRU 是 LSTM 建筑的变体，许多文章在解释背后的理论方面做了大量工作。

为了简洁起见，我不会对所有这些模型背后的理论做太多解释。

我推荐克里斯·奥拉写的关于这个话题的博客。他的博客展示了一些精美的图片来解释 GRU 的内部运作。

双向

双向的想法简单而强大。它的作用是拥有两个 LSTM 网络，而不是一个。

对于第一个 LSTM 网络，它将按照正常方式输入序列。对于第二个 LSTM 网络，它将反转输入序列并馈入 LSTM 网络。这两个网络的输出将被合并，然后传递到下一层。

双向背后的直觉是，对于某些句子，上下文信息在句子的末尾。没有上下文信息，可能会产生歧义。例如:

1\. Find me at the bank in that forest. (River bank) 2\. Find me at the bank in the city center. (Financial Bank)

因此，双向阅读句子有助于模型确定单词的确切含义。

如果你对理论知识感兴趣，我会推荐阅读原文论文。

构建网络

现在，让我们开始在 Keras 中构建我们的网络，我们将涉及嵌入层、双向层和门控循环单元(GRU)等组件。

对于嵌入，我们有两种选择:

1. 从头开始训练嵌入层
2. 使用一些预先训练好的开源权重嵌入。

在本文的最后，我们将比较使用普通单词嵌入和手套单词嵌入产生的结果。

香草字嵌入

下面的代码片段显示了如何在 Keras 中轻松构建嵌入层、双向和 GRU。

inp = Input(shape=(max_len,))x = EmbeddingLayer(max_features,embed_size)(inp)x = Bidirectional(CuDNNGRU(64, return_sequences=True))(x)x = GlobalMaxPool1D()(x)x = Dense(16, activation="relu")(x)ix = Dropout(0.1)(x)x = Dense(1, activation="sigmoid")(x)model = Model(inputs=inp, outputs=x)model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])print(model.summary())

Summary of the model

预训练手套字嵌入

手套单词嵌入是由斯坦福大学 NLP 小组开源的。我们需要先下载嵌入这个词，你可以在官方网站找到出处信息。

他们已经发布了不同版本的 word embedding，并在不同的数据源上接受了培训。请随意使用这里列出的单词嵌入的其他变体进行更多的实验。

将重量从手套转移到 Keras 嵌入层的代码相当长，这里我只展示一小段代码，让您了解转移是如何进行的。我会在本文末尾分享笔记本代码。

embeddings_index = convert_glove_to_index('glove.6B.300d.txt')# Randomly initialize the embedding matrix
embedding_matrix = np.random.normal(emb_mean, emb_std, (nb_words, embed_size))# Transferring weight
for word, i in word_index.items():
    embedding_vector = embeddings_index.get(word)
    if embedding_vector is not None: 
       embedding_matrix[i] = embedding_vector

现在，嵌入矩阵包含了来自手套嵌入的所有权重，将它们转移到 Keras 层只是多了一行代码。

构建模型时，需要指定嵌入层的权重。其余的代码与构建普通嵌入层的方式相同。

x = Embedding(max_features, embed_size, weights = [embedding_matrix])(inp)

模型的性能

在训练集上训练几次迭代后，让我们从准确度、精度和召回方面比较模型的性能。

如果你对为什么选择这些指标感兴趣，你可以阅读我之前写的文章。我已经包含了对这些不同的性能指标选择的详细解释。

从上表中，你可以清楚地看出 LSTM 模型比朴素贝叶斯算法做得更好。原因可能是:

1. Tfidf 矢量器没有考虑句子中单词的顺序，因此丢失了大量信息。
2. LSTM 是近年来序列数据(文本、语音、时间序列数据)中最伟大的算法之一

Photo by rawpixel on Unsplash

两种嵌入模型的性能比较

精度&召回

我只运行了 20 个时期的模型，没有做任何进一步的微调。

这两个模型的精确度和召回率相差不大。一些原因可能是由于:

1. 手套嵌入是在与我们在这个问题中拥有的数据非常不同的源上训练的，因此我们从预训练嵌入中获得的好处没有显著的帮助
2. 这个垃圾邮件过滤问题中的文本数据并不太复杂。普通的单词嵌入是捕捉模式的一个足够好的模型。

比较这两个模型的精度图，你会发现一些有趣的东西:

Accuracy of Glove Word Embedding

Accuracy of Vanilla Word Embedding

在开始有更好的性能之前，香草词嵌入的准确性在最初的几个时期保持平稳。

然而，手套词嵌入的准确度具有平滑的准确度曲线，并且逐渐提高。

这些观察可以粗略地给我们一些启示，即在训练的早期，普通单词嵌入模型仍然在学习和调整它的权重。

因此，预先训练的单词嵌入仍然有助于加快模型的学习，您可能不会注意到这个问题中的速度优势，但是当您在足够大的文本数据上训练时，这些速度差异将非常显著。

结论

在本文中，我展示了如何通过 Keras 使用单词嵌入和 LSTM 模型构建一个垃圾邮件过滤系统。

对于文本数据，单词嵌入无疑是一个很好的特征提取工具，利用 LSTM 模型，我们可以构建一个性能非常好的垃圾邮件过滤系统。

你可以在这个 Github 库中找到这个笔记本的代码，或者你可以直接从 Colab 中运行它。

使用卷积神经网络和 Flask 的垃圾邮件预测器

原文：https://towardsdatascience.com/spam-predictor-using-convolutional-neural-networks-and-flask-bb94f5c54a35?source=collection_archive---------19-----------------------

了解如何将机器学习集成到 web 界面中。

由大卫·洛伦兹、克里斯蒂扣篮和塞丽娜·帕特尔

希望为您的公司制作一个易于使用的内部预测工具，开发一个原型来向潜在的投资者推销机器学习产品，或者向朋友炫耀您的机器学习模型？

由于 Python 的 Flask，将机器学习模型与用户友好的 HTML 界面集成起来很简单。该框架可以应用于用户提供数据并从机器学习模型接收预测的任何示例。例如，X 射线技术人员可以上传患者的 X 射线，并通过图像识别立即接收自动诊断。Flask 是一个服务于应用程序后端模型的解决方案。

我们的用例示例

让我们想象一下，有成千上万的手机用户很难区分垃圾短信和朋友发来的短信。作为一名创新者，你想建立一个原型网站，用户可以输入文本，以接收自动垃圾邮件或火腿的区别。你来对地方了！您将学习(a)如何构建一个卷积神经网络来将文本分类为火腿或垃圾邮件，以及(b)如何将这种深度学习模型与使用 Flask 的前端应用程序集成。

是的，你很有可能相当擅长判断一条短信是否是垃圾短信，并且不需要机器学习。因为数据和问题的简单性，我们选择它作为我们的用例。您可以花更少的时间了解问题，花更多的时间了解工具！此外，您将能够自己轻松地运行整个示例，甚至不需要 GPU！

设计深度学习模型

卷积神经网络(CNN)在图像识别之外还有许多应用。例如，CNN 对于时间序列预测和自然语言处理(NLP)具有预测能力。CNN 的输入是一个矩阵。在图像识别中，每个图像的像素被编码为代表每个像素颜色强度的数值。

我们将重点讨论 CNN 的 NLP 应用，并训练一个单词 CNN。一个单词 CNN 的输入矩阵包括代表一个句子中单词的行和代表 n 个维度的单词嵌入的列。我们将回到单词嵌入，但是现在，考虑句子“哟，我们正在看一部关于网飞的电影”这句话 10 维的矩阵表示如下。

Matrix representation of sentence with 10 dimensions (note: padding not pictured)

你可能想知道上面这些数字代表什么。让我们打开包装。单词嵌入是单词的广义矢量表示。具有相似上下文的单词共享相似的向量。如下图所示，“我”和“我们”有相似的向量表示，但“网飞”是不同的。

Vector representations of “I”, “we”, and “netflix”

为什么以这种方式概括单词？用单词嵌入来概括单词有助于防止过度拟合。您可能想知道向量中的每个维度代表什么。技术上的解释是，它们是神经网络中隐藏层的权重，该神经网络在周围单词的上下文中预测给定单词。实际上，将这些维度视为单词的属性是很有帮助的。例如，一个维度可以代表一个单词有多快乐或悲伤。

有两种常见的方法来生成单词嵌入:(1)预训练的单词嵌入，如 Word2vec 或 GloVe，以及(2)从训练样本生成的单词嵌入。预先训练的单词嵌入是从大量文本语料库中产生的嵌入，并且概括得很好。在训练数据中生成的单词嵌入会导致特定于语料库的嵌入。

关于单词嵌入的更多信息，这篇文章很有帮助。

数据集

我们使用垃圾短信收集，可下载这里。

该数据集由被分类为垃圾邮件(好的)或垃圾邮件(坏的)的文本消息组成。数据的摘录如下所示。

SMS Spam data excerpt

That’s a lot of ham!

带 Keras 的 Word CNNs

Keras 只需几行代码就可以轻松创建一个单词 CNN。对于这个模型，我们使用 Keras“嵌入”层在我们的语料库中生成嵌入。注意，嵌入层的输出是一个矩阵，它是卷积层的必要输入。

在不到一个小时的时间里，通过处理这些数据，我们能够在测试集中达到 98%的准确率。CNN 的力量！

现在我们有了一个训练好的模型，我们保存预先训练好的权重、结构和记号赋予器。我们的 Flask 应用程序利用这些文件，这样我们就不需要在每次启动应用程序时都重新运行模型训练过程。这节省了时间和计算。我们的代码如下所示。

该模型的源代码和短信数据可以在 GitHub 这里找到。

用烧瓶给模型上菜

我们现在创建一个界面，使用户能够与我们的 CNN 互动。为此，我们使用 Python Flask 创建了一个 REST(表述性状态转移)API(应用程序编程接口)。

RESTful API 在用户和托管预训练模型的服务器之间创建了一个链接。你可以把它想象成一个总是在“倾听”等待用户输入数据、生成预测并向用户提供响应的模型。我们使用 Python Flask 与用户在网页上输入和接收的内容进行交互。您可以将 Python Flask 视为预训练模型和 HTML 页面之间的桥梁。

首先，我们加载预训练的模型和分词器进行预处理。

接下来，我们创建一个应用预处理的助手函数。为什么我们需要加载记号赋予器？否则，附加到由用户输入的单词的标识符与在训练过程中分配的标识符不对齐。因此，单词 CNN 会将输入解释为与用户输入完全不同的句子。加载经过酸洗的标记化器确保了与模型训练的一致性。

接下来，我们编译我们的模型，并通过示例确认它的工作情况:

既然我们已经加载了预处理和预训练的模型，我们就可以让 Flask 与我们的 HTML 页面交互了。我们构建了两个 HTML 页面:(1) search_page.html 和(2)prediction.html。当用户第一次访问网页时，下面的 if 条件不成立，将加载 search_page.html。该页面包含一个名为“text _ entered”的 HTML id，它是表单的一部分。

当用户输入文本并单击表单的提交按钮时，“request.method”变成了“POST”因此，用户在 HTML 表单中输入的 text _ entered 变成了 textData，它被转换成一个名为 Features 的数组，其中包含每个单词的数字标识符。这个数组通过预先训练的单词 CNN 生成一个代表垃圾邮件概率的预测。

然后，render_template 将 prediction.html 页面发送给用户。在此页面上，来自单词 CNN 的预测被插入到 HTML 代码的“{{ prediction }}”中。

我们的最后一步是定义我们将在本地运行它的位置:

为了进行测试，在执行上述代码行之后，您在 web 浏览器上访问“0.0.0.0:5000”以加载 search_page.html。在执行此操作之前，请确保(HTML 文件保存在名为“templates”的文件夹中，并且(2)model . H5、model.json 和 tokenizer.pickle 保存在运行 Python 或 Jupyter 笔记本的同一目录中。我们现在可以在本地测试应用程序了。

1. 执行 Flask 应用程序中的所有代码行(等待查看上面的“*运行于…”消息)
2. 打开谷歌 Chrome 之类的浏览器，访问“0.0.0.0:5000”
3. 输入下面的例子，然后点击“获得垃圾邮件预测！”

HTML interface to enter in email text

4.单击“获取垃圾邮件预测！”，这将返回下面的页面。

HTML output of prediction

5.观察 Jupyter 笔记本中的输出，它打印了预测函数中的每一步

Jupyter notebook with application running locally and user entering example

成功！我们输入了一个 ham 示例，应用程序返回了 2%的垃圾邮件。我们的应用程序在本地运行。

部署到云

当您的本地应用程序就位并正常工作后，您现在可能希望将它启动到云中，以便任何地方的用户都可以与它进行交互。然而，在云中调试要比在本地调试困难得多。因此，我们建议在迁移到云之前在本地进行测试。

启动到云很容易！

如果你使用的是 Jupyter 笔记本，你需要创建一个 main.py 文件。

您需要将以下内容上传到 Google Cloud:

1. main.py
2. 模板文件夹
3. 一个 yaml 文件
4. 带权重的 h5 文件
5. 带有模型框架的 json 文件
6. 腌制的记号赋予器
7. requirement.txt 文件

请注意，您需要在 requirements.txt 中指定 gunicorn 版本，以便 Google Cloud 可以连接到 Python web 服务器来下载 requirements.txt 文件中指定的适当库。requirements.txt 中不需要 pickle(Python 标配)，如果包含它，Google Cloud 会返回错误。

接下来，我们在云中键入以下命令来运行它:

1. CD[文件夹名]
2. gcloud 应用部署

有关启动 Google Cloud 的更多详细信息，请参见 GitHub 上的分步指南此处。此外，这个视频为谷歌云部署步骤提供了很好的参考。

垃圾邮件预测器诞生了

现在，您已经创建了一个可用的应用程序，它允许您确定一条消息是垃圾邮件还是 ham。

Flask 应用程序的源代码可以在 GitHub 这里找到。

有兴趣看另一个 Flask + Word CNN 用例吗？点击观看我们关于药物不良反应的视频。

请注意，Flask 非常适合用户数量有限的原型和应用程序(例如，一个公司的小用户群的内部工具)。Flask 不适用于为成千上万用户提供服务的生产级模型。

烧瓶和图像识别

你可能会想:这很棒，但我想让 Flask 与图像识别的深度学习进行交互。你很幸运！虽然我们在这个例子中关注于单词 CNN，但是对于图像，方法是类似的，并且我们有一个图像的例子。下面链接的 GitHub 库通过 CNN 交互用户上传的图像，以进行图像识别。

卷积神经网络使用 UCSD 的标记图像来诊断儿童肺炎可以在这里找到。

Python Flask 接受 X 射线技师上传的图像并提供诊断(健康或肺炎？)可以在这里找到。