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

---

TowardsDataScience 博客中文翻译 2016~2018（四）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

我们知道他们在听，但他们听到了什么？

原文：https://towardsdatascience.com/ai-assistant-rankings-32dfdd1841bc?source=collection_archive---------10-----------------------

4 个家庭人工智能助手，根据数据隐私和如何保护数据进行排名

在 Humanlytics，我们只关心数据。当我们的工具可以访问大量高质量数据时，我们可以发现业务洞察，从而提供个性化的有效建议。

然而，在数据时代,消费者已经开始对他们生产的数据——企业正在收集的数据——感到紧张。

这种情况已经持续了一段时间，但随着物联网(IoT)(不断收集数据并将其发送回公司服务器的物理设备网络)随着大众市场“始终监听”人工智能设备的出现而扩展到我们的家庭，数据安全问题变得越来越紧迫。

当这些设备进入我们的家时，我们最私密的地方就成了某种监控的对象。

这会导致权威人士为了他们的目的可能从你的设备中获取数据。

太恐怖了。但是，不管喜欢与否，我们每天都在越来越多地进入一个以数据为中心的世界。我们都需要接受数据革命不仅仅是不可避免的，它已经到来了。但我们不需要盲目接受。

那么，我们来谈谈吧。为了确保你了解情况，我们将讨论由谷歌、微软、亚马逊和苹果生产的人工智能听力设备。在讨论其含义之前，我们将讨论该产品本身以及它能让您对数据进行何种控制。

然而，在我们单独讨论这些器件之前，我们先来概括地讨论一下。

人工智能听音设备通过音频命令获取线索。其实现方式是利用“唤醒词”。它一直在听你说话，但只有当它听到这个唤醒词时才开始注意。

这实际上是通过记录短脉冲来实现的。如果检测到唤醒词，设备会继续记录，如果没有，则该片段会被删除。一旦它被触发，设备就开始记录或流式传输你说的话。

在这一点上，理解这是一个由两部分组成的系统是很重要的。你家里的设备实际上不做任何计算。相反，通过互联网，它被连接到数英里以外的计算机服务器上，而服务器才是真正的工作。

这意味着您的语音记录(或流)不会留在您的家中，而是在制定正确的应对措施之前进行分析，然后发送回您的设备，在您家中播放。

谷歌主页

产品

谷歌主页被描述为“谷歌助手”，提供“免提帮助”。

这涵盖了广泛的功能，谷歌将其分为六个类别:1)获得答案，2)享受娱乐，3)管理任务，4)规划你的一天，5)控制你的家，6)享受乐趣。

为了使用它，你需要做的就是把它插上电源，在你的手机上运行一个应用程序的设置，然后，当在设备的耳边时，说:“好的谷歌”。这将激活设备，在这一点上，它将开始积极处理和执行您所请求的行动。

它收集的数据

谷歌对此有点奇怪。

在关于数据隐私的 Google Home FAQ 页面上，他们或多或少地承认收集你通过你的账户、你的搜索历史、你的位置历史以及第三方应用程序提供给他们的信息。

然而，如果你看一下谷歌的隐私政策，你会发现他们收集了更多更深入的信息。

这包括，您提供的任何账户信息以及关于您如何在他们的服务上做什么的信息。这包括设备、日志、位置和应用程序信息。

此外，他们使用本地存储以及 cookies 和类似的工具来收集和存储基于你在 Google 上所做的事情的信息，包括你如何与他们的合作伙伴提供的服务进行交互。

你的控制

理论上，你有完全的控制权。

你录制的语音剪辑会自动存储在谷歌的数据中心，并与你的账户相关联，然后你可以去 myactivity.google.com 手动删除。如果你不删除它们，它们会永远留在那里。

你也可以调整你的设置，以确定谷歌主页可以访问你的个人偏好和其他信息(这是指我们上面提到的“服务信息”)。

您的控制权受限的一个例子是关于“服务相关信息”。即使你已经删除了你的账户，谷歌可能会保留一些信息，你对此无能为力。

更广泛地说，你可以决定谷歌收集哪些数据，以及这些信息如何与你的账户相关联。此外，您可以控制它是否可以访问您的搜索历史记录、位置历史记录和应用程序信息。

奇怪的是，尽管从逻辑上讲，如果另一个人亲自向你的谷歌主页索要信息，你对自己的信息没有控制权。作为最后一招，你可以关闭录音功能，但这将使设备失去功能。

亚马逊的 Alexa

产品

亚马逊的这款产品有几种不同的形式。有回声、圆点和敲击声。尽管名称不同，但它们做的都差不多。

它完成了亚马逊定义的八个类别之一的任务:音乐和娱乐，新闻和信息，问题和答案，家庭帮助，智能家居，娱乐和游戏，购物和 Alexa 技能。

Alexa 的特殊之处在于它利用了“技能”,这些技能基本上是由第三方开发的应用程序，用于该*台提供的语音功能。

它收集的数据

一旦你的请求和问题被记录下来，Alexa 就会记录下来。它还处理来自第三方服务的信息(您可能已经向其提供了个人信息)。

虽然 Amazon Echo 的工作原理是“唤醒词”,只有在识别出这个词后，它才会将你的声音传输到服务器，但它也包括了你说出唤醒词之前所说的部分录音。

你的控制

首先，您可以控制自己的查询。这些都记录在您的历史记录中，您可以单独删除它们。此外，通过前往 www.amazon.com/mycd或联系客户服务，您可以一次删除产品的所有录音。

由于可能会不小心提到唤醒词并将录音传输到云端，亚马逊提供了不同的设置来防止这种情况。例如，您可以将监听限制为仅在您按下激活按钮或激活提示音以通知您设备开始和结束录音时发生。你也可以让设备静音，尽管这实际上会破坏它的功能。

苹果的 Siri

产品

苹果的 Siri 可能是最初的“永远听”设备，于 2015 年首次亮相，目前提供苹果定义的八类功能。

这包括:基础知识、保持联系、变得有条理、运动、娱乐、外出、家庭用品和获得答案。

Siri 还值得一提的是它的与众不同之处，它是第一个出现在手机上的始终监听的人工智能，可以在所有 iphone 上运行。

他们收集的数据

Siri 会收集和使用手机上已有的信息，如您的姓名、通讯录和歌曲。

此外，如果您在请求时打开了定位服务，该信息将与您的请求捆绑在一起。

此外，苹果规定一些功能需要“来自苹果服务器的实时输入”为了描述这种需求，他们给出了一个地图示例，其中服务器需要知道您的目的地地址和您的当前位置。

你的控制

苹果在这场竞赛中的地位有些奇怪。

一方面，它似乎不允许你大量控制 Siri 能访问或不能访问的内容。您可以关闭定位服务、其他“主动服务”，或者完全关闭 Siri。

此外，您可以关闭 Siri 的“始终聆听”功能，以便它只根据您的物理命令操作(通过按住 home 键激活)。

另一方面，苹果擅长以匿名和安全的方式保护你的数据。

例如，苹果没有将你的 Siri 查询与你的个人账户相关联，而是将它们与分配给你的设备的随机标识符相关联，该标识符会在六个月后自动删除。

同样，每当苹果从你的设备向服务器发送信息时，它都会使用“匿名的旋转标识符”，这样你的信息就不会被追踪到你个人。

苹果做的最后一件事是保留 Siri 在你手机上使用的大部分信息。

这意味着 Siri 用来提出建议的来自您的电子邮件、通讯录、应用程序使用和日历的信息会留在您的设备上，而不会发送到服务器。

微软的 Cortana

产品

微软的“永远倾听”人工智能的迭代是 Cortana。被描述为可以做一系列活动的“数字代理”。

微软将其功能分为大约八个类别:提醒、跟踪、通信、日历、列表、游戏、查找信息和打开应用程序。

它收集的数据

如果您使用 Windows 帐户登录 Cortana，Cortana 将从您的设备、其他 Microsoft 服务以及您连接的第三方服务中收集信息。

这包括你的浏览历史、日历、联系人、位置历史(无论你是否与手机互动，都会定期收集)等信息，以及有点令人不安的“来自消息、应用和通知的内容和通信历史”

值得注意的是，如果您在登录 Windows 帐户时使用 Cortana，您的录音将被存储并与您的帐户相关联。

你的控制

微软允许相当程度的控制。首先也是最重要的，它不需要一个帐户就可以使用，这意味着你可以进行永远不会连接到你的帐户的查询(尽管它们仍然会保存在你的浏览器上)。

此外，您可以决定连接哪些第三方服务。此外，任何时候你问一个需要使用更多数据的问题，Cortana 都会在进入之前请求许可。

此外，如果你后来改变了主意，你可以通过进入 Cortana 的设置来单独管理权限(尽管你不能管理所有的事情)。

Cortana 还允许您通过编辑“笔记本”来具体管理 Cortana 对您的了解。但是，这样做不会删除服务器中的相关数据。为了做到这一点，并管理你的录音，你需要访问 account.microsoft.com/privacy.

结论

那么这给我们留下了什么？人工智能监听设备很酷，但它们也可能跨越我们许多人不愿考虑的数据收集线。

5 Data Privacy Principles by Mozilla. Image via Flickr.

更具体地说，它们允许意外记录你的声音和你可能说的任何东西。虽然网络搜索需要有意识的输入和搜索，但口误可能会唤醒你一直在听的人工智能，它会急切地记录你说的任何话。

这有点令人不安，但好消息是你有一个选择。你可以决定哪个人工智能监听设备住在你的家里，它能听到什么。利用这个选择，并保持你的隐私。

在这篇文章的帮助下，你现在拥有了做出明智选择的工具。我甚至可以帮你一点忙，通过数据隐私对这些设备进行排名。

Google Home vs Amazon’s Alexa devices.

我们的语音助手数据隐私排名

1. 微软 Cortana(微软 Cortana)- Siri 和 Cortana 之间的争夺非常激烈，但最终微软允许你控制 Cortana 的粒度控制让它占据了上风。这不仅允许您控制它收集的数据，还可以确保 Cortana 在您做出这些选择后保持正常运行的能力。简而言之，它允许隐私与操作能力之间的巨大*衡。
2. 苹果 Siri- 老实说，苹果在隐私方面做得很好。他们保持你的数据匿名，将你的大部分数据保存在手机上而不是服务器上，并在六个月后自动删除你的请求。这些都是很好的东西，但是把它降低到两点是因为你的控制是有限的。您只有几个自定义选项，这使得很难找到微软提供的隐私和操作能力之间的*衡。
3. 亚马逊 Alexa- 亚马逊获得第三名，因为虽然他们没有做什么过分的事情，但他们也没有做什么伟大的事情。删除你的数据可能是一件苦差事，虽然它允许你对你的数据进行一些控制，但激活太多这些选项，你会有效地扼杀设备的功能。不错的亚马逊，但也不伟大。
4. 谷歌主页 -谷歌，哦谷歌。我纠结于这个排名。像微软一样，谷歌允许对设备可以收集和访问的数据进行相当精细的控制。然而，与微软不同的是，谷歌 Home 需要一个谷歌账户才能运行。这使它能够立即访问大量信息，虽然您可以更具体地指定它可以访问的数据，但这也会严重限制它的功能。

Microsoft’s Cortana vs Apple’s Siri. Image via PC Mag.

每个科技公司都应该认真对待的步骤

AI 很厉害，但数据隐私也很厉害。

数据自由化是未来的重要工具。它允许详细和个性化的建议，以及将改变我们生活方式的人工智能。然而，与此同时，数字隐私对于保护我们社会的价值观和权利是不可或缺的。

例如，这就是为什么我们 Humanlytics 采取具体措施来确保您的私人数据保持不变。我们记住的两个解决方案是算法透明和最小可行数据收集。

Transparency of algorithms and data collection are key to building trust with users.

算法透明是指你写的代码应该对消费者可用。这将使他们能够全面彻底地监督数据收集过程。

虽然这个想法很激进，有一些复杂之处，但它是我们致力于努力实现的理想。现在，这意味着我们将始终致力于尽可能透明地公开我们的收集/分析算法。

至于最小可行数据收集，想法很简单。我们只会收集我们需要的数据，仅此而已。这不会影响我们产品的功效，我们收集的数据越少，滥用数据的风险就越小。每个人都赢了。

技术进步的每一天都是消费者隐私遭受攻击的另一天。但是，如果你尽自己的一份力，保持信息畅通，而我们(即科技公司)尽自己的一份力，负责任地收集数据，那么我们每个人都可以帮助实现一个未来，让隐私成为现实，而不是白日梦。

科技公司和消费者还能做些什么来保护数据隐私？请在下面评论，或者给我发邮件到 bill@humanlytics.co，让我们知道你的想法。 在这里了解更多关于 Humanlytics。

原载于 2017 年 4 月 19 日 medium.com**T21。

AI、BI 和 BS:揭开企业级人工智能的神秘面纱

原文：https://towardsdatascience.com/ai-bi-and-bs-demystifying-enterprise-scale-artificial-intelligence-5d98cf4fd7f8?source=collection_archive---------4-----------------------

人工智能……来到你身边的世界 500 强！

像谷歌和 IBM 这样的高科技公司并不是人工智能军备竞赛中的唯一公司。每天，越来越多的公司利用机器学习和高级分析等数据科学技术来发展他们的组织。作为自动化的驱动力，认知人工智能开始动摇许多行业，裁员的威胁正在逼*。在一家财富 100 强制造企业实施了一年艾龙，在商业智能行业工作了几年，并与 BSers 打了一辈子交道之后……我感觉到了一种召唤，那就是在这个面向企业的数据科学和人工智能新世界中，区分什么是真实的。

许多非技术导向的企业正在实施预建的人工智能*台(IBM Watson、Infosys Nia、Tata Ignio、Maana.io)，将人工智能作为服务分包出去，并聚集数据科学家团队，开始从他们的数据中获得更深入的见解。我有幸安装了一个企业级人工智能*台，并带领一个 25 万员工的公司发现了认知自动化的用例。这需要识别重复的、不确定的业务流程；对普通软件来说太复杂而无法完成的任务，但对人类来说又太*凡而无法继续完成。

人工智能的用例很多，可以带来成本效益，并为员工腾出时间，但在每个数据科学机会的背后，都有一些障碍。高层领导会想为什么组织还需要另一个数据分析工具。BI 团队将对共享哪些数据进行限制，要求在需要了解的基础上提出正式请求。商业利益相关者会质疑你能保证这种人工智能自动化能为他们的成本中心节省多少钱。简单地说，在 AI 真正被他们的企业接受之前，自动化团队要经历一大堆废话。

从商业无知到商业见识到商业智慧

传统的商业智能真正革新了商业世界。公司现在有了从结构化数据库中获取确凿证据的渠道，对其进行分析，并以决策者可以理解的格式进行报告。这使得经理和高管们更少依赖直觉，更少因主观臆断而犯错误。

但是，当您要求您的 BI 团队理解数据湖时，会发生什么呢？非结构化数据通常是 BI 团队开始踩刹车的地方。这不是因为无法操纵非结构化数据，而是因为 BI 团队缺乏从数据湖中获取任何商业价值的环境。在大多数公司中，数据湖被用来储存任何额外的数据，不管其数据质量如何，这些额外的数据将来可能会很有用。

要理解这个障碍，我们首先要区分数据分析，analytics，和高级分析。分析是使用当前数据来描述业务的快照(报告/仪表板)。分析更进一步，进行根本原因分析和预测分析(预测、问题诊断)。高级分析旨在使用复杂的统计方法和机器学习来提供更高层次的见解。这是数据科学家参与的领域:文本挖掘、情感分析、网络和聚类分析、多元统计、模拟、复杂事件处理和神经网络。这些通常是资源密集型工作，需要高度专业化的技能、强大的软件*台和大规模并行集群来计算。高级分析通常是利用数据湖所需的一套技术。虽然一些常见的 BI 工具有能力帮助高级分析项目，但还有更多的混合。不要让 BI 团队欺骗您，让您认为他们可以可靠地提供高级分析！

洞察力只是战斗的一半…在我们的机器充分理解数据后，我们需要在实现任何价值之前将这些洞察力纳入决策和业务流程。这就是说明性分析发挥作用的地方:当你可以使用数据在最少的人工干预下自主做出决策时，认知自动化的力量就显现出来了。

理学士

正如任何技术大趋势一样，不可避免地会有人试图乘风破浪，赚快钱。以下是你在与高层领导和非技术受众交流时要注意的一些废话。

不要让业务分析师欺骗你，让你以为他们是数据科学家。组建一个成功的人工智能团队需要许多技能，BAs 对于评估每个数据科学用例的潜在好处将是无价的。然而，他们将不能对幕后将要发生的事情或实施需要多长时间提出任何有意义的建议。事实上，数据科学家自己也可能无法给你一个准确的交付时间表。

“数据科学”这个术语在我看来是用词不当，因为它既是一门科学，也是一门艺术。大多数数据科学项目就像使用 3 英尺范围的手电筒探索 300 英尺长的洞穴。你不知道自己不知道什么，要经过无数次的迭代探索、模型选择、算法调优，才能创造出一个有用的模型。简而言之，不要指望像对待应用程序开发周期一样，给你的机器学习项目设定严格的时间表。你可能已经建立了一个算法，但是在一个有效的算法准备好部署之前，通常需要一些训练/调整时间。

你不能给你的人工智能*台输入一堆数据，然后指望它吐出真知灼见。自主 AI(还)不在！任何有价值的改变都需要 BAs、SME、数据科学家和流程负责人的共同努力。仅仅因为您有数据并不意味着您有确定的答案，因为没有领域和过程专业知识，非结构化数据通常是垃圾。很多时候，拥有解读这种非结构化数据所必需的隐性知识的人忙于经营业务，而没有时间放下手头的工作去从事分析项目。当分析已经放置了一段时间的数据时，可能会出现更糟糕的复杂情况，因为 SME 可能已经离开了公司。

这就是为什么不能夸大数据治理的重要性。如果一家公司真的想利用他们的数据来降低成本和增加长期收入，他们需要愿意投资来保持他们的数据干净和有标签。就短期而言，低质量数据的一些变通办法可能是为数据解释分配 SME 带宽，并让业务分析师花一些时间进行探索性数据分析。

政治暴政

当与商业利益相关者打交道时，我们经常听到的一句话是:“如果它不赚钱，它就没有意义”。预测商业利益只是第一步。之后，必须令人信服地将信息传达给决策者，并猜测实现收益的时间表。然后政治乐趣开始了。一旦主管签署了人工智能用例的预计美元节省，这意味着他们的组织部分的预算也预计会减少。假设是他们可以用从自动化中节省下来的钱来经营他们的业务。这意味着，如果自动化被高估，并且没有实现预期的成本节约，那么该主管就处于亏损状态。

这种废话会给人工智能的实现增加很多阻力；管理激励对于任何类型的成功企业转型都至关重要。我给高管们的建议是，在组织层面授权一项人工智能/自动化计划，并让公司签署成本收益，而不是成本中心所有者个人。这样，当主管签署自动化用例时，如果预计的成本节约低于/慢于预期，他们也不会不知所措。只有当流程负责人实现了收益，成本中心才应该减少；从而允许企业增加他们对 AI 自动化的成功度量。

随着人工智能和数据科学在商业世界变得无处不在，我们都需要更加了解这个高度技术化的领域正在发生的事情。这不仅将帮助我们避免对一个新兴领域的误解，还将帮助组织全心全意地拥抱人工智能转型，*衡自己以实现长期的最大商业利益。

图像识别中的人工智能能力

原文：https://towardsdatascience.com/ai-capabilities-in-image-recognition-7d79aec5222f?source=collection_archive---------16-----------------------

随着 AWS 和谷歌提供的大规模云托管人工智能和人工智能*台的出现，应用程序开发人员在他们的应用程序中集成人工智能和人工智能，并利用复杂的人工智能/人工智能算法的高级功能，甚至无需内部人工智能专家，已经变得更加容易。

人工智能最普遍的应用是模仿人类互动或人类感知信息的方式——视觉和语音。虽然语音是人工智能中同样重要的领域，在这个领域也有同样多的发展，但本文的重点是视觉。视觉领域的主要部分是理解图像和视频。如今，配备了高质量移动摄像机的互联网用户每天都在制作和消费大量的图像/视频内容。对图像数据进行分类、过滤、编辑和解析是一个典型的用例。借助基于云的*台提供的 AI/ML 产品，我们获得了许多具有巨大优势的强大工具。本文试图阐明这些功能。

在处理图像时，最常见的用例是检测和识别图像中的内容。使用人工智能*台，我们能够做以下事情:

1. 人脸识别——是否是人脸？如果是，它是与我的数据库中的人脸之一相匹配的人脸吗？
2. 检测对象—图像中存在哪些对象？我们能探测并命名所有这些物体吗？
3. 文本检测—如果是文本文档，我们能提取文本吗？
4. 徽标、地标检测——我们能否精确检测并命名自然或人工地标或公司徽标？

现在让我们深入了解这些*台是如何解决这些问题的。让我们首先看看谷歌的人工智能产品——谷歌视觉。

谷歌视觉

它现在是谷歌云*台的一部分，它提供了一系列功能，几乎涵盖了我们上面提到的所有需求。Google Vision 向开发人员提供 API(称为云视觉 API)以实现各自的功能。根据官方文件——

云视觉 API 通过将强大的机器学习模型封装在一个易于使用的 REST API 中，使开发者能够理解图像的内容。它可以快速地将图像分为数千种类别(例如，“帆船”)，检测图像中的单个对象和人脸，并读取图像中包含的印刷文字。您可以在您的图像目录上构建元数据，缓和攻击性内容，或者通过图像情感分析实现新的营销场景。

Cloud Vision homepage

特性/功能

1. 图像标记 —视觉 API 通过识别其检测到的信息，根据不同的标识符或标签为给定图像添加标签。标签范围很广——动物、交通工具、地点、颜色、食物..任何事。
2. 人脸、标志和地标检测 —在检测人脸(和动物)、品牌标志、纪念碑和著名景点方面表现出色。它可以检测图像中出现的多张脸，还可以识别一张脸是否是名人脸。它还给出精确的面部属性和情绪状态。
3. 光学字符识别(OCR)又称文本检测 —输入图像或文件，它会读出所有文本。即使文本几乎不存在或者文档是全文文档。
4. 检测露骨内容 —这是一个很棒的功能，使用它我们可以从用户生成的图像数据中检测成人内容。它提供了出现露骨或暴力内容的可能性。
5. 谷歌搜索 —利用谷歌搜索数据和算法的力量，它试图在给定图像和网络上可用图像之间建立关系。利用这一点，它可以在网上搜索类似的图片。

[## 谷歌云*台

Google 云*台让您可以在同一基础设施上构建、部署和扩展应用程序、网站和服务…

console.cloud.google.com](https://console.cloud.google.com/apis/library/vision.googleapis.com) [## 移动视觉简介|移动视觉|谷歌开发者

移动视觉 API 现在是 ML 工具包的一部分。我们强烈建议您尝试一下，因为它提供了新的…

developers.google.com](https://developers.google.com/vision/introduction)

使用上页中的演示功能，可以针对不同类型的输入对服务进行测试。

Cloud Vision API demo 1

Cloud Vision API demo 2

关于 Google Vision 的一个令人兴奋的事情是，该产品有一个专注于移动的兄弟——移动视觉(现在作为 ML Kit 的 Firebase 的一部分),这是为移动应用程序开发者准备的。它提供了使用云 API 进行图像识别的功能，以及针对有限功能的设备图像识别功能。。ML kit 本身是一个令人兴奋的新框架，为移动应用开发者提供了极其简单的 Rest API。

Introducing ML Kit — Image grab from Google I/O, 2018

亚马逊认知

“…服务可以识别对象、人员、文本、场景和活动，并检测任何不适当的内容。”

Amazon Rekognition *台由 Amazon 作为 AWS 中的服务捆绑提供。S3 桶托管的图像和视频内容可以输入 Rekognition 进行分析。它提供了许多类似于谷歌视觉的功能，如文本提取、对象检测和显式内容检测，但也有一些令人印象深刻的附加功能。

“…if you want to be able to open up your garage when camera detects your license plate.”— Andy Jassy, CEO, AWS at re-Invent, 2018

AWS Rekognition 有两个独特的功能— 人员跟踪和实时视频分析。人员跟踪允许检测和跟踪特定人员的移动，并在此基础上做出决策。实时视频分析有助于根据实时视频中检测到的对象或活动做出即时决策。

“亚马逊 Rekognition 基于亚马逊计算机视觉科学家开发的同样经过验证、高度可扩展的深度学习技术，每天分析数十亿张图像和视频，不需要使用机器学习专业知识。”

这里的是服务的官方页面。还有一个演示页面来使用和测试这个特性。

Amazon Rekognition Demo 1

Amazon Rekognition Demo 2

rest 服务给出一个 JSON 响应，详细说明检测到的对象和活动。

Rekognition API response.

亚马逊还非常强调 Rekonition 的特定人脸识别能力(除了检测之外)，即从图像中检测人脸，并通过与你自己数据库中存储的人脸进行匹配来识别它。如果有足够的数据，任何人都可以使用它来创建一个人识别应用程序。虽然在这篇文章中提到了一些隐私问题。

谷歌云视觉和亚马逊 Rekognition 的详细对比可以在这里找到。

除了云视觉和 Rekognition，还有一些其他的解决方案。OpenCV 在这里值得一提，它是一个开源框架或库，拥有大量用于检测对象或活动的 ML 算法。OpenCV 不是云托管解决方案。

人工智能咨询&逆向棉花糖实验

原文：https://towardsdatascience.com/ai-consulting-the-reverse-marshmallow-experiment-18d466737d3f?source=collection_archive---------9-----------------------

我在过去写过关于对人工智能人才的高需求，以及满足这种需求的高素质人才的低供应。大公司吞噬所有人才留下的空白正在推高人工智能开发的成本，就在你预计价格会下降的时候，考虑到所有令人敬畏的自由软件都在那里。此外，我喜欢参与各行各业的项目。我很高兴只是努力扩大我现在正在做的事情。

这篇文章是关于像我这样的顾问在这场人工智能的狂热中最大化收入的压力，以及从这种我将称为人工智能解决方案架构师的供需暂时不*衡中产生的丑陋事情。

棉花糖测试是一项测量儿童延迟满足感的著名研究。简而言之，孩子等着吃棉花糖的时间越长，他们的自制力就越强。研究结果进一步表明，延迟满足是一种值得拥有的好品质。在人工智能领域，我正在经历一场逆转棉花糖效应。经济激励迫使我不要延迟满足。在这种情况下，满足意味着金钱。

AI 真的很酷。问题来了:我要赚钱。现金。追求收入最大化的欲望扭曲了做酷事的长期价值，因为它促使像我这样的顾问去投标我知道自己能很快完成的项目。激励是反对创新和风险的。

通常，在乌龟和头发的寓言中，乌龟是最大的赢家。在这个超非竞争性的人工智能领域，兔子赢了。他每天带着一袋金子回家，乌龟一砖一瓦地建立他的创业公司，最终兑现股票期权或把它们当卫生纸用。这对创新者来说有点麻木不仁，但一鸟在手胜过双鸟在林。让我们面对它，做一个标准的人工智能项目比做一个完全失败的非零风险的项目赚更多的钱，风险更小。可悲的是，我不得不让不是一个，而是两个火热的线索在这个星期死去，因为这些要求对定价来说风险太大，而且我们不能按小时计费。一个想要高精度和高召回率(很难做到)，另一个数据集很乱。我可能不应该，但我觉得离开很糟糕。

关于当代人工智能的愤世嫉俗的观点/反驳是我今天在一个聚会上从一位同事那里听到的:“得 A 的人呆在学校里。得到 B 的人最终会为得到 C 的人工作。抱歉，我不知道引用的原始来源。如果找到请在评论里补充。这句话的意思是，像呆伯特这样的中等工程师在咨询公司为愚蠢的老板工作，而最优秀和最聪明的人则躲在象牙塔里酝酿下一件大事。我觉得这有点苛刻。作为一名顾问，我想我同时是呆伯特和愚蠢的老板？我上周遇到的一位首席执行官称我的方法为“勉强糊口”。也许有一些丑陋的事实。

对于这一切，我有一个更现实、或许更乐观的观点。我记得物联网和大数据是有史以来最重要的东西。它过去了。我认为，首先，对人工智能的需求将由大量训练有素的工程师来满足，正如劳动力供求不匹配时经常发生的那样。看不见的手会(应该？)做它的事。第二，像我这样追逐发展机会而不是解决一个重大问题的顾问，最终要么会发现一个很酷的解决方案并专注于此，要么会成为许多小公司中的一员，最终被高科技领域不断变化的沙子卷走。

比起长期(稳定)的全职工作和长期(高回报)的股权安排，我追逐短期合同(和许可协议)的收入是不是疯了？让我知道你的想法。

编码快乐！

——丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

• 人工智能和不良数据
• 人工智能:超参数
• 人工智能:让你的用户给你的数据贴上标签

关于数学、表示和神经网络的晚餐

原文：https://towardsdatascience.com/ai-dinner-on-math-representations-and-backpropagation-6214b007ac3c?source=collection_archive---------1-----------------------

晚餐时，我和一位物理学家、一个 70 年代的人(现在已经上了年纪)以及一位从迈阿密的优步司机那里得到大麻的绅士坐在一张桌子旁。我学到了以下几点:

• Fortran 仍然被使用的原因之一是它有针对数值计算的语言和编译器优化(我后来研究了这一点，发现主要的优化是与语言无关的——例如。将矩阵分解成子矩阵(大小适合机器的存储器层次结构的形状)并执行子计算)
• 傅立叶分析(我在大学里不得不上的一门课，一节课结束就忘了)是一个叫做频谱分析的东西的子域(…把事物从一种表示形式转换成另一种表示形式…)
• 群论是“对称”的延伸……我还不太明白这是什么意思(我问过桌子群论的实际应用是什么……)

我对数学很好奇，问了物理学家很多关于数学的问题(当我问他是怎么进入编程的时候，他说“我解方程是通过把方程分解成矩阵，找到稳定的表示”……嗯？我猜是和合成函数做函数逼*，然后求方程组的参数有关……向读到这里的任何数学家道歉)。几天后，我突然意识到，也许有一种抽象的方式可以用适用的表达方式来构建事物:

• 数字表格可以用图表来表示(我们认为这是理所当然的)
• 代数符号可以被认为是古代人们必须执行的任务的一种简短形式的表示
• 微积分中的积分符号是黎曼和的另一种表示
• 正弦波形的频域和时域表示(用于傅立叶分析，用于信号处理，应用于从无线电到蓝牙再到任何无线设备的方方面面)

我把这个和我不久前看到的 Bret Victor 的演讲联系了起来。演讲的中心是思想的表现如何与界面联系起来，尽管我认为无论是用户界面还是数学或其他东西，表现都是允许不同类型的思想被思考的东西——它们是非常基本的东西。也许它们也可以被认为是允许交流的东西…在像设备的界面或数据集的可视化这样的情况下，难道这不是它或数据通过其与界面/查看者交流的表示吗，就像语言的选择是人类相互交流时使用的表示一样？这是一块有趣的手表https://www.youtube.com/watch?v=agOdP2Bmieg

我想更好地理解神经网络和线性代数是如何联系在一起的……我最终想理解使用连接主义技术的界限是什么。这对我来说很重要，有两个原因:理解这项技术可以增强社会中的哪些角色很重要(神经网络可以下围棋和开车，但我的理解是它们不能独立实现推理)，而且由于我对 AGI 感兴趣，理解这项技术如何与其他技术结合也很重要(无论是 20 世纪开发的技术还是尚未发明的技术)。

表征能成为技术产生的框架吗？例如，当一个程序员戴着过程的、面向对象的、功能的帽子时。

人工智能不需要完全可解释

原文：https://towardsdatascience.com/ai-doesnt-need-to-be-fully-interpretable-4767b110dc1e?source=collection_archive---------16-----------------------

An AI black box bot!

为什么可解释的 AI 会成为如此热门的话题？

自 2012 年计算机视觉和自然语言处理的大规模突破开始出现以来，人工智能在各地蓬勃发展。自那以来，各公司一直在努力将人工智能应用到你能想到的每个行业，从医疗保健到零售、金融到自动驾驶汽车。人工智能赋予这些公司令人难以置信的能力，可以创建强大的预测系统，这些系统可以自动化他们可以获得数据的几乎任何重复的人类任务。

当人们看到他们的人工智能系统犯错误时，就产生了人工智能需要完全可解释的想法。他们想知道为什么会这样，以便改进他们的系统。

在某些领域，缺乏可解释性带来了许多法律问题。如果 AI 出错了会怎么样？谁对损坏负责？在金融业，一个错误可能意味着数十亿美元的收入损失。在医疗保健领域，失误会造成人员伤亡。

但是可解释性并不是这些挑战的答案。它可能会为我们提供更好的方法来改善我们的人工智能系统，或者让我们更好地了解系统的错误来自哪里。但这并没有让我们从根本上解决人工智能，也没有解决道德和法律问题。

我们可以有一个人工智能系统来忽略导致病人死亡的危险癌症。如果人工智能更容易理解，也许我们可以找到它错误的来源，并用它来改进系统。但是我们已经知道错误来自我们的人工智能。同样的道德和法律问题仍然适用，在这方面没有解决任何问题。

如果医生犯了那个错误会怎么样？

几个月前，我在多伦多参加了一个机器学习活动。向问答小组提出了一个有趣的问题:

如果一辆自动驾驶汽车必须在碾过某人和撞上一棵树，杀死所有乘客之间做出选择，它会选择哪个？

一个小组成员给出的答案很有趣:嗯，人类会怎么做？没有确定的答案。人类有自己的偏见和独特的内部决策系统。这个问题没有正确的答案。

我们并不完全理解人类的思维，但我们仍然接受它的错误。如果你在数学考试中犯了一个错误，你也许可以倒回去找出错误发生在哪里，以及下次如何改正。但是没有人知道大脑内部是如何得出结论的！神经科学真的还没有出现，如果没有这方面的知识，我们也不会有什么大问题。

如果我们想在对错误敏感的行业(如医疗保健和金融)中解决人工智能的一些道德和法律问题，那么在可解释性上工作就没有什么意义。更多的是用正确的方式应用人工智能。

医疗保健决策中有非常强烈的道德观念，让人工智能来做这些决定甚至都不合适。这些决定应该由专家来做。人工智能应该被用作一种工具，帮助给专家人类信息，可以帮助决策的速度和准确性，但不是为了决策本身。

如果它与道德、情感或任何人类固有的东西有关，而不是机器，它应该完全由人类控制。AI 是一个可以伸出援手的工具，但它不是这艘船的船长。

人工智能不需要完全可解释。重要的是我们要有一些高层次的可解释性:系统如何工作，它的不同部分，以及哪个部分犯了错误。

但是我们不需要知道这些本质的细节。了解它们不会帮助我们解决智能问题，也不会帮助我们解决人工智能固有的伦理和法律问题

帮助我们解决和复制人类智能的将是对大脑不同部分如何形成整体的理解。它是如何作为一个系统工作的。

喜欢学习？

在推特上关注我，我会在那里发布所有最新最棒的人工智能、技术和科学！

人工智能吞噬软件的未来

原文：https://towardsdatascience.com/ai-eats-future-of-software-27d3a0d8eaed?source=collection_archive---------5-----------------------

在这篇文章中，我将分享人工智能如何塑造软件未来的观点。我们日常使用的传统软件在未来的日子里会发生怎样的巨大变化。

让我们从软件的当前状态(称之为“遗留”)开始。

“遗产”

历史上，软件应用程序大多被设计成自动化一组特定的过程——生活中的过程或企业中的过程

让我们举两个例子来理解这一点:

在面向消费者的场景中，一个合适的例子是“出租车预订”过程。从前，你打电话给出租车公司，告诉他们你的上车地点、时间、目的地、你想要什么类型的出租车等等。随后出租车会来接你。那么“遗留”应用程序(我们使用的)是如何产生的呢？让我们以优步为例。优步应用程序自动化了这一过程(同时还做了许多其他很酷的事情)。类似地，Booking.com 应用程序自动化了“酒店预订”过程，Yelp 自动化了“餐馆搜索”过程等等。拿你最喜欢的应用程序来说，它的核心肯定是自动化了一些过程

在企业环境中，Outlook 等应用程序会自动执行“电子邮件管理”流程。Microsoft Dynamics 自动化了“客户关系管理”流程，Slack 自动化了“企业协作”流程，这样的例子不胜枚举。

因此“过程自动化”通常是任何“遗留”软件应用程序的核心。目前为止。

但不是前方。

“未来”

鉴于这些过程中的大部分已经自动化，软件应用的下一个前沿是什么？优步、网飞等国家的软件应用前景如何？长什么样？Outlook、Gmail、Slack 在未来会有什么与众不同的特点？

当然，下一代软件应用不仅仅是过程自动化！！！

但远不止如此。下一代应用程序更加智能、个性化、自我学习和自我改进。

这就是人工智能(和机器学习)作为未来软件的核心 DNA 发挥作用的地方。

正如我所讨论的，我们周围的大多数软件应用程序仍然属于过程自动化时代(我们所处的时代！).它们本质上是高度反应性的。非常类似于 Eric Schmidt 提到的:软件总是像那只被要求时会叫的宠物狗。肯定不主动。非常非常被动。

展望未来，三个驱动因素都将使软件变得更加主动、个性化，并最终变得更加智能。

但是是什么推动了这种变化呢？海量数据、对大型计算基础设施(云 GPU 等)的可用性和智能算法成为跨越学术界边界的主流。

“未来”应用程序的一些其他特征:

1. 软件应用程序将以“自然”的无缝方式与用户互动，而不仅仅是点击或触摸。与应用程序交互的常见方式将是自然语言文本、语音、手势、情感。Cortana、Allo、Siri 和 Alexa 已经为这个领域的更多创新铺*了道路。
2. 随着更多的使用，软件应用程序将了解用户，变得更加“个性化”、“相关”。应用程序的响应将不被预定义，因此变得更加个性化。这也是可能的，因为关于用户的大量上下文、行为信息的可用性以及快速处理的能力。网飞就是一个很好的例子——你用得越多，个性化的体验就越多。
3. app 会提出更有帮助的建议。利用对用户行为和偏好的了解，下一代应用程序将以无缝的方式将正确的内容和资源映射到用户。
4. 下一步将是代表一个人主动采取行动——更多地在人工智能助手中。这将产生巨大的生产力需求。

在下一篇文章中，我们将看看如何构建融合人工智能的应用程序。

对于帖子上的任何问题、评论和意见，请随时联系我。我的坐标:@saunakdg 在 Twitter

AI +电竞:对未来的思考

原文：https://towardsdatascience.com/ai-esports-thoughts-on-the-future-7b548792725d?source=collection_archive---------4-----------------------

在我写这篇文章的时候，Team Liquid 已经赢得了国际冠军。如果你不关注电子竞技或 Dota 2，国际锦标赛是由 Valve 主办的年度锦标赛。Team Liquid 以 3-0 战胜 Newbee，但我看比赛是为了别的事情。事情是这样的:

OpenAI vs Dendi

Dendi 是这个星球上最好的 Dota 2 玩家之一，他与 OpenAI 的 Dota 2 bot 进行了两次交锋，但都失败了。当被问及他的想法时，他说，“有点像人类，但又有点像其他可以对抗的东西”。Dendi 并不是唯一一个被机器人的能力打败的人。像 Arteezy 和 SumaiL 这样的冠军也被它碾压。在 Dendi 的比赛之后，OpenAI 说他们明年会带着一个可以对抗 5 名球员的机器人回来。

如果这还不够刺激的话。谷歌的 DeepMind 与暴雪合作，开放了 SC2LE。SC2LE 是星际争霸 2 的 Ai 学习环境。以下是它包含的内容:

• 一个为星际争霸 2 提供地图和机器人框架的机器学习 API。
• 65，000 次匿名游戏回放，很快将增长到 500，000 次。
• DeepMind 的用于机器人框架的 PySC2 包装器。
• 研究人员测试机器人的环境。

[## 和暴雪开放星际争霸 2 作为人工智能研究环境

与我们的合作伙伴暴雪娱乐公司一起，我们很兴奋地宣布星际争霸 2 学习版的发布…

deepmind.com](https://deepmind.com/blog/deepmind-and-blizzard-open-starcraft-ii-ai-research-environment/)

但我们不要被炒作，机器人末日不会到来。星际争霸 2 是一款复杂的战略游戏，在撰写本文时，还没有人制作游戏机器人。

OpenAI 的机器人虽然值得称赞，但并不容易。原因如下:

1. 1v1 和 5v5: 埃隆马斯克的推特宣称 Dota 2 远比国际象棋或围棋复杂。这是真的，但游戏 Dendi 远没有这么复杂。首先，游戏有很多限制。比赛是单车道还是 1v1。Dota 2 是一个 MOBA(多人在线战斗竞技场),它是为团队而不是单一玩家设计的。这降低了一个非常庞大和引人入胜的游戏的复杂性。
2. 获取信息:Dota 2 中的人物技能只在一定半径内有效。玩家很难盯着屏幕测量距离，这需要数小时的练习。相反，机器人已经知道玩家距离等信息。这有助于他们在适当的时候使用技能。
3. 单角色打法: OpenAI 的 bot 好像是在单个角色上训练的。Dota 2 拥有众多拥有不同技能和能力的角色。如果他们明年想玩 5v5，他们将不得不在他们所有人身上进行训练。

此外，机器人显然在与 Dendi 比赛后被击败了 50 次。

未来会怎样

这里需要理解的一件关键事情是，这并不是电子竞技的终结。正如我之前提到的，电子竞技已经是一个成长中的产业。

Geek Wire on viewership in eSports

机器人不会很快取代人类玩家。未来 20 年我们也不会有人类级别的人工智能。还有，什么时候看两个机器人对打很好玩？相反，人工智能的未来在于增强，而不是自动化。

尽管我们的智能手机有能力击败大师，但国际象棋仍然在玩。世界上最好的棋手不是人类或计算机，而是两者的结合。加里·卡斯帕罗夫的 TED 演讲对此有更好的解释。

电子竞技可能会有类似的命运，以下是我的想法:

• DeepMind 的 AlphaGo 在与 Lee Sedol 对弈时使用了一些令人惊讶的战术。人们认为这些实际上不会起作用，但它们确实起作用了。类似的新战术和战略的发现也可能发生在电子竞技领域。玩家将不得不重新思考他们在游戏中的每一个动作。像这样的情况会给他们带来原本不可能的洞察力。
• CSGO 有一个“第六人”设置，一名观察员在那里为球员提供策略建议。机器人可以代替“第六人”，这是一种“增强建议”的形式。团队将不得不在他们的游戏中增加机器人的推荐。做得好的团队将成为赢家。由于许多机器学习算法已经大众化，因此不会出现团队不公*匹配的情况。
• 就像我之前提到的，星际争霸 2 是一款具有相当战略深度的游戏。这也使得游戏对新手来说更加困难。游戏中教练的出现会有所帮助。这将加快游戏的入门过程，减少学习时间。

电子竞技说到底是一种运动形式。世界各地的人们收看他们喜爱的球队比赛并为他们加油。只是这一次，他们会支持 5 个玩家和一个机器人。

艺术家的人工智能:第一部分

原文：https://towardsdatascience.com/ai-for-artists-part-1-8d74502725d0?source=collection_archive---------2-----------------------

艺术不仅仅是对自然现实的模仿，事实上，它是对自然现实的一种形而上学的补充，为了征服自然而与自然并列。

弗里德里希·尼采

注意，本文是艺术家 AI 系列的一部分。 第一部分第二部分

艺术和技术的历史总是交织在一起的。历史上发生的艺术革命是由制作作品的工具促成的。燧石刀的精确性使得人类能够用猛犸象象牙雕刻出第一批形象艺术作品。在当代，艺术家使用从 3D 打印到虚拟现实的工具，拓展了自我表达的可能性。

我们正在进入一个时代，人工智能越来越多地出现在几乎每个领域。埃隆·马斯克认为，到 2030 年，艺术将在所有方面超过人类，但艺术一直被视为人类的万神殿，是人工智能永远无法复制的人类事物。在这一系列文章中，我们将在机器学习的帮助下创作出令人惊叹的艺术作品。

项目 1:神经风格转移

什么是神经风格转移？

它仅仅是以另一种方式重新想象一幅图像的过程。这是使用卷积神经网络进行图像处理的最酷的应用之一。想象一下，你可以让任何一位著名的艺术家(例如米开朗基罗)在几毫秒内为你画出你想要的任何东西。在这篇文章中，我将尝试给出一个关于实现细节的简要描述。欲了解更多信息，您可以参考 Gatys 等人的论文，2015 。本文实现了我们试图做的优化问题

在我们开始之前，我们将介绍一些基础知识，这可以帮助你更好地理解概念，或者如果你只对代码感兴趣，你可以直接进入下面的链接https://github.com/hnarayanan/artistic-style-transfer或https://github.com/sav132/neural-style-transfer。绝对推荐卷积神经网络(CNN) 吴恩达课程，以便更深层次地理解概念。

基本原则

让我们想象一下，我们正在尝试建立一个图像分类器，它可以预测图像是什么。我们使用监督学习来解决这个问题。给定一个由 D = W×H×3(色深= 3)组成的彩色图像(RGB 图像)被存储为一个数组。我们假设有“n”个类别可以分类。任务是提出一个将我们图像分类为“n”个图像之一的函数。

为了建立这一点，我们从一组先前分类标记的“训练数据”开始。分数函数我们可以用一个简单的线性激活函数[F(x，W，b) = Wx +b]。W —大小为 n X D 的矩阵称为权重，大小为 n X 1 的向量 b 称为偏差。为了预测每个类别的概率，我们将这个输出通过一个叫做 softmax 的函数**将分数压缩为一组 0 到 1 之间的数字，加起来等于 1。假设我们的训练数据是一组 N 预先分类的示例 xi ∈ℝ D ，每个示例都有正确的类别易 ∈1，…， K。确定所有这些示例的总损失是 交叉熵 损失:**

L(s)=∑I log(syi)

对于优化部分，我们使用梯度下降。我们必须找到最小化这种损失的权重和偏差。

我们的目标是找到曲线底部的全局损失最小值。我们还使用一个称为学习率(α)的参数，这是一个衡量我们修改权重速度的指标。

综上所述，最初我们给出了一些图像作为一个原始的数字数组，我们有一个参数化的得分函数(线性变换后是一个 softmax 函数),带我们去分类得分。我们有一种评估其性能的方法(交叉熵损失函数)。然后，我们改进分类器的参数(使用梯度下降优化)。但是这里的精度较低，因此我们使用卷积神经网络来提高精度。

卷积神经网络(CNN)基础

Diagram of a simple network from Wikipedia

以前我们使用线性得分函数，但这里我们将使用非线性得分函数。为此，我们使用神经元，它们是函数，它首先将其每个输入乘以一个权重，并将这些加权的输入相加为一个数字，并添加一个偏差。然后，它将这个数字通过一个称为激活的非线性函数，并产生一个输出。

通常，为了提高我们的分类器的准确性，我们可能会认为通过向我们的得分函数添加更多的层来做到这一点是很容易的。但是有一些问题-

1.通常，神经网络完全忽略图像的 2D 结构。例如，如果我们将输入图像作为一个 30×30 的矩阵，他们将输入图像作为一个 900 的数组。你可以想象，共享邻*像素的一些有用信息正在丢失。

2.当我们添加更多的层时，我们需要学习的参数数量增长非常快。

为了解决这些问题，我们使用卷积神经网络。

普通网络和 CNN 之间的区别在于，它不是使用线性阵列的输入数据，而是使用具有宽度、高度和深度的输入数据，并输出 3D 数量。人们想象的 2D 输入图像( W × H )通过引入颜色深度作为第三维( W × H × d )被转换成 3D。(灰度为 1，RGB 为 3。)类似地，人们可能想象的长度为 C 的线性输出实际上表示为 1×1× C 。我们使用两种类型的图层

1.卷积层

第一层是卷积(Conv) 层。这里我们有一组过滤器。让我们假设我们有 K 个 T21 这样的过滤器。每个滤波器都很小，其范围由 F 表示，并具有其输入的深度值。例如，典型的滤波器可能是 3×3×3 (3 个像素宽和 3 个像素高，3 个像素来自输入 3 通道彩色图像的深度)。

Convolutional layer with K = 2 filters, each with a spatial extent F = 3 , moving at a stride S = 2, and input padding P = 1. (Reproduced from CS231n notes)

我们以表示我们移动速度的步幅 S 在输入音量上滑动滤波器组。根据控制输出空间尺寸的需要，该输入可以用零进行空间填充( P )。当我们滑动时，每个过滤器计算输入的点积以产生 2D 输出，当我们将这些过滤器堆叠在我们集合中的所有过滤器上时，我们得到 3D 输出体积。

2.汇集层

它的功能是逐渐减小表示的空间大小，以减少网络中的参数和计算量。它没有任何要学习的参数。

例如，空间范围 F =2 且跨度 S =2 的最大池图层将输入尺寸从 4×4 减半至 2×2，深度保持不变。它通过选取每组 2×2 数中的最大值，并仅将这些值传递给输出来实现这一点。

这就结束了基本原理，我希望你已经了解了基本的工作原理。

我们开始吧！

内容图像和样式图像

内容图像(c)是您想要重新创建的图像。它为新的输出图像提供主要内容。它可以是一只狗的任何图像，一张自拍照或者几乎任何你想以新的风格画出来的东西。另一方面，风格图像提供图像的艺术特征，例如图案、笔触、颜色、曲线和形状。让我们称风格转移输出图像为 x 。

损失函数

Lcontent ( c ， x ):这里我们的目标是最小化内容图像和输出图像之间的损失，这意味着当两个输入图像( c 和 x )在内容上非常接*时，我们有一个趋向于 0 的函数，并且随着它们的内容偏离而增长。我们称这个函数为内容损失。**

Lstyle ( s ， x ):这个函数显示两幅图像在风格上有多接*。同样，该函数随着其两个输入图像( s 和 x )在风格上趋于偏离而增长。我们称这个函数为风格损失。**

现在我们需要找到一个图片 x ，这样它与内容图片和风格图片就没有什么不同。

α和β用于*衡结果图像中的内容和样式。

在这里，我们将使用 VGGNet ，这是一个基于 CNN 的图像分类器，它已经学会对感知(例如，笔画大小、空间样式控制和颜色控制)和语义信息进行编码，我们需要这些信息来测量这些语义差异术语。

VGGNet 通过将相同的较小卷积滤波器配置重复 16 次，大大简化了 ConvNet 的设计:VGGNet 中的所有滤波器都限制为 3×3，跨距和填充为 1，以及跨距为 2 的 2×2 最大池滤波器。

我们将首先复制用绿色标记的 16 层变体，用于分类，在下一个笔记本中，我们将看到它如何重新用于样式转换问题。

普通的 VGG 获取图像并返回类别分数，但是这里我们获取中间层的输出并构建 Lcontent 和 Lstyle 。这里我们不包括任何完全连接的层。

让我们开始编码，

导入必要的包。

**from keras.applications.vgg16 import preprocess_input, decode_predictionsimport time
from PIL import Image
import numpy as npfrom keras import backend
from keras.models import Model
from keras.applications.vgg16 import VGG16from scipy.optimize import fmin_l_bfgs_b
from scipy.misc import imsave**

加载并预处理内容和样式图像

**height = 450
width = 450content_image_path = 'images/styles/SSSA.JPG'
content_image = Image.open(content_image_path)
content_image = content_image.resize((width, height))style_image_path = 'images/styles/The_Scream.jpg'
style_image = Image.open(style_image_path)
style_image = style_image.resize((width, height))** 

现在我们将这些图像转换成适合数字处理的形式。特别是，我们添加了另一个维度(超出高度 x 宽度 x 3 个维度),以便稍后我们可以将这两个图像的表示连接到一个公共数据结构中。

**content_array = np.asarray(content_image, dtype='float32')
content_array = np.expand_dims(content_array, axis=0)
style_array = np.asarray(style_image, dtype='float32')
style_array = np.expand_dims(style_array, axis=0)** 

现在，我们需要压缩这些输入数据，以匹配“用于大规模图像识别的甚深卷积网络”中所做的工作，该论文介绍了 VGG 网络。

为此，我们需要执行两个转换:

1.从每个像素中减去*均 RGB 值(之前在 ImageNet 训练集上计算的，可以从 Google 搜索中获得)。

2.将数组的排序从 RGB 更改为 BGR。

**content_array[:, :, :, 0] -= 103.939
content_array[:, :, :, 1] -= 116.779
content_array[:, :, :, 2] -= 123.68
content_array = content_array[:, :, :, ::-1]

style_array[:, :, :, 0] -= 103.939
style_array[:, :, :, 1] -= 116.779
style_array[:, :, :, 2] -= 123.68
style_array = style_array[:, :, :, ::-1]**

现在我们准备使用这些数组来定义 Keras 后端中的变量。我们还引入了一个占位符变量来存储组合图像，该组合图像保留了内容图像的内容，同时合并了样式图像的样式。

**content_image = backend.variable(content_array)
style_image = backend.variable(style_array)
combination_image = backend.placeholder((1, height, width, 3))**

最后，我们将所有这些图像数据连接成适于由 Keras VGG16 模型处理的单个张量。

**input_tensor = backend.concatenate([content_image,
                                    style_image,
                                    combination_image], axis=0)**

原始论文使用来自 Simonyan 和 Zisserman (2015) 的 19 层 VGG 网络模型，但我们将改为遵循 Johnson et al. (2016) 并使用 16 层模型(VGG16)。由于我们对图像分类不感兴趣，我们可以设置include_top=False，这样我们就不包括任何完全连接的层。

**model = VGG16(input_tensor=input_tensor, weights='imagenet',
              include_top=False)**

我们想要最小化的损失函数可以分解为内容损失、风格损失和总变化损失。

这些术语的相对重要性由一组标量权重决定。这些价值观的选择取决于你，但是下面的对我来说更好

**content_weight = 0.050
style_weight = 4.0
total_variation_weight = 1.0**

对于内容损失，我们从block2_conv2.中提取内容特征。内容损失是内容和组合图像之间的*方欧几里德距离。

**def content_loss(content, combination):
    return backend.sum(backend.square(combination - content))layer_features = layers['block2_conv2']
content_image_features = layer_features[0, :, :, :]
combination_features = layer_features[2, :, :, :]loss += content_weight * content_loss(content_image_features,
                                      combination_features)**

对于风格损失，我们首先定义一个叫做克矩阵的东西。一组图像的 Gram 矩阵，表示两幅图像之间的相似性或差异性。如果你有一个(m x n)的图像，把它整形为(m*n x 1)的向量。类似地，将所有图像转换为矢量形式并形成一个矩阵，比如说 A.
那么这组图像的克矩阵 G 将为

**G = A.transpose() * A;**

每个元素 G(i，j)将表示图像 I 和 j 之间的相似性度量

**def gram_matrix(x):
    features = backend.batch_flatten(backend.permute_dimensions(x, (2, 0, 1)))
    gram = backend.dot(features, backend.transpose(features))
    return gram**

我们通过计算风格和组合图像的 Gram 矩阵之间的差的 Frobenius 范数(它是定义为其元素的绝对*方和的*方根的矩阵的矩阵范数)来获得风格损失。

**def style_loss(style, combination):
    S = gram_matrix(style)
    C = gram_matrix(combination)
    channels = 3
    size = height * width
    return backend.sum(backend.square(S - C)) / (4\. * (channels ** 2) * (size ** 2))

feature_layers = ['block1_conv2', 'block2_conv2',
                  'block3_conv3', 'block4_conv3',
                  'block5_conv3']
for layer_name in feature_layers:
    layer_features = layers[layer_name]
    style_features = layer_features[1, :, :, :]
    combination_features = layer_features[2, :, :, :]
    sl = style_loss(style_features, combination_features)
    loss += (style_weight / len(feature_layers)) * sl**

现在我们计算总变异损失，

**def total_variation_loss(x):
    a = backend.square(x[:, :height-1, :width-1, :] - x[:, 1:, :width-1, :])
    b = backend.square(x[:, :height-1, :width-1, :] - x[:, :height-1, 1:, :])
    return backend.sum(backend.pow(a + b, 1.25))

loss += total_variation_weight * total_variation_loss(combination_image)**

现在我们有我们的总损失，它的时间来优化结果图像。我们从定义梯度开始，

**grads = backend.gradients(loss, combination_image)**

然后，我们引入一个Evaluator类，它在一次通过中计算损失和梯度，同时使用loss和grads 函数检索它们。

**outputs = [loss]
outputs += grads
f_outputs = backend.function([combination_image], outputs)

def eval_loss_and_grads(x):
    x = x.reshape((1, height, width, 3))
    outs = f_outputs([x])
    loss_value = outs[0]
    grad_values = outs[1].flatten().astype('float64')
    return loss_value, grad_values

class Evaluator(object):

    def __init__(self):
        self.loss_value = None
        self.grads_values = None

    def loss(self, x):
        assert self.loss_value is None
        loss_value, grad_values = eval_loss_and_grads(x)
        self.loss_value = loss_value
        self.grad_values = grad_values
        return self.loss_value

    def grads(self, x):
        assert self.loss_value is not None
        grad_values = np.copy(self.grad_values)
        self.loss_value = None
        self.grad_values = None
        return grad_values

evaluator = Evaluator()**

这个合成图像最初是像素的随机集合，我们使用fmin_l_bfgs_b() 函数( 有限内存 BFGS ( L-BFGS 或 LM-BFGS ) 是一个优化算法)对其进行迭代改进。

**x = np.random.uniform(0, 255, (1, height, width, 3)) - 128.

iterations = 10

for i in range(iterations):
    print('Start of iteration', i)
    start_time = time.time()
    x, min_val, info = fmin_l_bfgs_b(evaluator.loss, x.flatten(),
                                     fprime=evaluator.grads, maxfun=20)
    print('Current loss value:', min_val)
    end_time = time.time()
    print('Iteration %d completed in %ds' % (i, end_time - start_time))**

要恢复输出图像，请执行以下操作

**x = x.reshape((height, width, 3))
x = x[:, :, ::-1]
x[:, :, 0] += 103.939
x[:, :, 1] += 116.779
x[:, :, 2] += 123.68
x = np.clip(x, 0, 255).astype('uint8')

image_final = Image.fromarray(x)**

生成的图像在 image_final 中可用。

Raja Ravi Varma painting in the style of Edvard Munch

如果你是初学者，想入门深度学习领域，可以访问我的博客AI for art。**

结论

这个项目将让你对 CNN 的工作有一个大致的了解，并澄清许多基本的疑问。在这一系列文章中，我们将探索深度学习用于创造性目的的各种方式。

感谢您的宝贵时间！

参考:

** [## 基于卷积神经网络的艺术风格转换

我们都使用过像 Prisma 和 Lucid 这样的应用程序，但有没有想过这些东西是如何工作的？就像我们从我们的…

medium.com](https://medium.com/data-science-group-iitr/artistic-style-transfer-with-convolutional-neural-network-7ce2476039fd) [## 卷积神经网络| Coursera

本课程将教你如何建立卷积神经网络…

www.coursera.org](https://www.coursera.org/learn/convolutional-neural-networks) [## hnarayanan/艺术风格转移

艺术风格转移——用于艺术风格转移的卷积神经网络。

github.com](https://github.com/hnarayanan/artistic-style-transfer) [## [1409.1556]用于大规模图像识别的超深度卷积网络

摘要:在这项工作中，我们研究了卷积网络的深度对其在大规模数据传输中的准确性的影响

arxiv.org](https://arxiv.org/abs/1409.1556)

• http://cs231n.stanford.edu/
• (神经类型转移:综述)https://arxiv.org/pdf/1705.04058.pdf
• http://cs231n.github.io/
• (一种艺术风格的神经算法)https://arxiv.org/pdf/1508.06576.pdf
• http://bangqu.com/0905b5.html**

艺术家的人工智能:第二部分

原文：https://towardsdatascience.com/ai-for-artists-part-2-c3e41653747a?source=collection_archive---------14-----------------------

Quote from Westworld TV show

注意，本文是艺术家 AI 系列的一部分。 第一部分第二部分

音乐是一种强有力的工具，它能让世界上一些最聪明的头脑变得不可思议。其中有弗里德里希·尼采、叔本华、弗吉尼亚·伍尔夫等等。尼采在他的书《偶像的黄昏》中说“没有音乐的生活将是一个错误”。

在本文中，我们将使用简单的 LSTM 网络来创作音乐，但在此之前，让我们先简要了解一下音乐创作史上出现过的算法作曲。

穿越时间的简史……

从古希腊时代开始，就有许多关于音乐理论的论文，但它们并不是任何纯粹意义上的“算法作品”。但在古典时期，算法音乐最常被引用的例子之一是莫扎特的音乐。

Combinations obtained by rolling a dice.

1958 年，亚尼斯·克塞纳基斯在他的作品中使用了马尔可夫链。

马尔可夫链

马尔可夫链用于描述一组可能的事件，其中每个事件发生的概率只取决于前一个事件达到的状态。这些用于预测序列中的下一个数据，其中数据可以是单词、音符等。它基本上模拟了一个音符序列播放后出现的概率。马尔可夫链的一个主要限制是它只能产生存在于原始数据中的子序列。但是用这种方法不可能扩展到那些精确的子序列之外。然后出现了递归神经网络(RNNs)尝试这样做。

什么是 RNN？

我们打个比方来理解这一点。假设你想预测晚餐会吃什么。食物只有三样——煎饼、炒饭和面包。我们试图拟合一个模型，根据厨师迟到、特殊场合、鸡肉价格下跌等因素来预测每天的食物。如果我们开始在晚餐数据的历史上训练这一点，我们学会了预测某个特定夜晚的食物。我们可以看到，即使我们正确地选择输入和训练数据，预测的准确性也不会超过某一点。现在，当我们看一看数据时，我们可以看到食物——炒饭、煎饼和面包在一个循环中重复，不依赖于任何因素。如果前一天是 Chapati，那么第二天就会是面包，这就像一个序列。在这里，预测某一天的食物最重要的是前一天的食物数据。通过收集以前的食物数据，我们可以预测下一次的数据。

source : http://colah.github.io/posts/2015-08-Understanding-LSTMs/

在正常的神经网络中，所有的输入都是相互独立的，但是在 RNN，所有的输入都是相互关联的。首先，它从输入序列中取出 x(0 ),然后输出 h(0 ), h(0)和 x(1)是下一步的输入。因此，h(0)和 x(1)是下一步的输入。类似地，下一步的 h(1)是下一步的 x(2)的输入，依此类推。这样它在训练的时候就一直记住了上下文。假设我们必须生成给定音乐序列中的下一个音符，在这种情况下，所有先前音符之间的关系有助于预测更好的输出。但问题是，由于消失梯度问题，标准 RNN 不能学习长期序列。

消失梯度问题

当我们不断增加越来越多的隐藏层时，以及在反向传播过程中，就会发生这种情况，结果误差(导数)会变得很大或很小。这意味着与层级中较后层的神经元相比，较前层的神经元学习非常慢。这样做的问题是训练过程耗时太长，模型的预测精度会下降。解决方案之一是使用 LSTM 网络。2002 年，道格·埃克改变了这种方法，将标准的 RNN 细胞转换成“长短期记忆”(LSTM)细胞。

LSTM 网络公司

长短期记忆网络(LSTM)是一种 RNN，能够学习长期依赖性，这意味着他们可以长时间记住信息。在正常的 RNNs 中，这种重复模块将具有类似单个 tanh 层的简单结构。

Simple RNN (source:colah’s blog)

LSTMs 具有链状结构，重复模块具有不同的结构。不是只有一个神经网络层，而是有四个网络。

LSTM

LSTM 网络不是神经元，而是连接成层的记忆块。块包含管理块状态和输出的门。

cell state highlighted

LSTMs 的关键是单元状态，即贯穿图表顶部的水*线。它沿着整个链条直线向下，只有一些微小的线性相互作用。

LSTM gate

门是决定是否让信息通过的一种方式。sigmoid 层输出 0 到 1 之间的数字。

0→没有东西通过

1→一切经过

一个 LSTM 有三个这样的门，用来保护和控制细胞状态。

忘记门→ 决定从单元中丢弃什么信息。
输入门→ 决定输入哪些值来更新存储器状态。
输出门→ 根据输入和单元内存决定输出什么。

有许多方法可以使用从马尔可夫链到卷积神经网络(Wavenet)的不同网络来生成音乐。在这里我选择了 LSTM 网络生成音乐。对于训练数据，我们使用诺丁汉音乐数据库。我使用了由 Panagiotis Petridis 创建的预训练模型。数据集采用 ABC 格式。如果有好的 gpu 或者 cpu 也可以自己训练模型。 提供了这里的 为 jupyter 笔记本。如果你想了解代码的解释，请点击此链接。

将生成五个文本文件作为输出。您可以使用 abcmidi 之类的软件将生成的文本文件转换为 midi。您也可以使用各种项目，如 magenta、wavenet、deepjazz 等来生成音乐。

My output

如果你是初学者，想入门深度学习领域，可以访问我的博客 机器学习的艺术 。

感谢您的宝贵时间！！

参考:

* [## 算法作曲:用普通 LISP 和普通…

使用程序生成一段音乐的一个非常简单的例子是使用 12 面骰子(编号为 1-12)来…

quod.lib.umich.edu](https://quod.lib.umich.edu/s/spobooks/bbv9810.0001.001/1:5/--algorithmic-composition-a-gentle-introduction-to-music?rgn=div1;view=fulltext) [## ABC 音乐项目-诺丁汉音乐数据库

这些曲子最初不是手工核对的，所以很可能到处都有错误。诺丁汉音乐…

abc.sourceforge.net](http://abc.sourceforge.net/NMD/) [## 马尔可夫链直观地解释了

当然，真正的建模者并不总是画出马尔可夫链图。相反，他们使用“转移矩阵”来计算…

setosa.io](http://setosa.io/ev/markov-chains/) [## 了解 LSTM 网络——colah 的博客

这些循环使得循环神经网络看起来有点神秘。然而，如果你想得更多一点，事实证明…

colah.github.io](http://colah.github.io/posts/2015-08-Understanding-LSTMs/)

https://www.youtube.com/watch?v=qhXZsFVxGKo

[## 用于生成音乐的神经网络

算法音乐创作在过去的几年里有了很大的发展，但是这个想法已经有很长的历史了。在一些…

medium.com](https://medium.com/artists-and-machine-intelligence/neural-nets-for-generating-music-f46dffac21c0) [## 泛音乐主义者/音乐一代-RNN

音乐生成-RNN -一个使用 TFLearn 中 LSTM 层的神经网络，学习如何作曲。

github.com](https://github.com/PanagiotisPtr/Music-Generation-RNN)*

商业人工智能

原文：https://towardsdatascience.com/ai-for-business-9cf9ec23ea1d?source=collection_archive---------19-----------------------

不是点击诱饵。只是想把 AI 应用于商业的“我的真相”和我想和你一起走的路说出来。

这将是一篇短小精悍的文章。首先，我将谈论现在人工智能的问题，然后是在商业场景中理解和应用人工智能的问题，最后是我正在思考的解决方案的第一印象。

第一部分.人工智能世界

I hate this image 😃

自从人类作为一个社会开始以来，我们一直在努力寻找一种更好、更聪明的工作方式。人工智能(AI)它是我们想象的将在许多方面帮助我们改善日常生活的事物之一。

我要给 AI 一个非常简单的定义。但首先我需要谈谈它的部分=人工和智能。

如果我们认为智力是完成复杂目标的能力，复杂的东西是有许多部分以可能难以理解的方式相互关联的东西，而理解是将复杂信息转化为简单、有用的信息的能力，那么我们可以说:

智力是通过理解构成主要目标的部分来完成复杂目标的能力。

我们人类通过建模来做到这一点。这是“看到”我们周围的“现实”世界，然后创建一个更高层次的原型来描述我们所看到的，听到的和感觉到的事物的过程，但这是一个代表性的东西，而不是“实际”或“真实”的东西。

所以我们人类(希望没有机器人在读这篇文章)模拟这个世界，用我们的智慧来理解事物的工作方式，并用这种理解和知识来解决困难和复杂的问题。

这里的人工部分是指人类不是(直接)使用智能的人，而是机器，或者软件，或者算法。这些算法不是像往常一样被编程，在那里你确切地告诉他们做什么。他们正在通过数据学习。

Created with love by me 😃

第二部分。商业人工智能

如果我们采用上面的图表，并为其添加商业元素，那么我们正在尝试将人工智能应用于商业。

Created with love by me 😃

这里的 A-BSPF 是敏捷商业科学的问题框架。你可以在这里了解更多信息:

[## 创建 ROI 驱动的数据科学实践的敏捷框架

数据科学是一个令人惊叹的研究领域，学术界和工业界都在积极发展…

www .商业科学. io](https://www.business-science.io/business/2018/08/21/agile-business-science-problem-framework.html)

这里我们需要从世界或“自然”和业务中获取数据。然后我们需要来自业务本身的数据，并在其中定义一个问题。非常重要的是，你要阅读上面的文章，了解如何以一种系统和敏捷的方式做到这一点。

对我来说，公司在尝试使用人工智能时面临的问题不完全是在人工智能或模型步骤，而是在最初的步骤。定义业务案例，获取并分析他们拥有的数据，并从外部世界获取数据。

正如我之前所说:

…但这一切都始于数据。正如您可以想象的那样，数据现在是公司的重要资产(可能是最重要的资产)。所以在你可以应用机器学习或深度学习(和人工智能)之前，你需要拥有它，知道你拥有什么，理解它，治理它，清理它，分析它，标准化它(也许更多)，然后你才能想到使用它。

这就是为什么我提议转移到数据结构，然后加入端到端人工智能工具。你可以在这里了解更多信息:

[## 面向大众的深度学习(…和语义层)

深度学习现在无处不在，在你的手表里，在你的电视里，在你的电话里，在某种程度上，在你的*台上…

towardsdatascience.com](/deep-learning-for-the-masses-and-the-semantic-layer-f1db5e3ab94b)

每个人都想成为颠覆性的，在不知道为什么的情况下，将数据用于一切。这太疯狂了。我们需要离开这个地方。我真的推荐在这一点上阅读这篇文章

[## 我们不需要更多的编码员

每个人都在试图进入技术领域，但我希望更多的人能够突破

medium.com](https://medium.com/@TebbaVonMathenstien/technologists-should-abandon-their-craft-69e874e7e68b)

泰勒·埃利奥特·贝蒂里昂然后回去。正如他所说:

我们被淹没在技术中，这些技术是为其自身的利益而创造的，然后被积极地推销、游说，或者以其他方式推向不情愿的消费者。

并且:

“创造性破坏”和“颠覆性”的理念在硅谷的投资者和 CEO 阶层中被奉为事实上的好东西…

在试图以各种方式破坏之前，先把事情做好！解决你的数据问题，并认真思考如何用它来回答这些问题。

第三部分。我想和你一起走的路

如果你读了我的文章，你可能会发现它们都有一个目的，并遵循一条道路。这是我试图达到这一点。我每天都在努力帮助人们和公司在通往人工智能和数据科学的道路上取得成功。现在我要更进一步。因此，我有三个通知:

• 商业数据科学与商业科学:明年年初，我将开设一门商业科学课程，还有 Matthew Dancho 关于“用 Python 进行商业分析”(DS4B 101-P)。作为让您真正理解如何使用 Python 解决复杂业务案例并为 DS4B 201-P 做好准备的第一门课程，我将带您使用 Python、Spark、H2O、Lime 等工具，使用 A-BSPF 实现端到端业务解决方案。你可以在这里了解更多信息:

[## 商业科学大学

从虚拟研讨会中学习，这些研讨会将带您了解解决问题的整个数据科学业务流程…

大学.商业-科学. io](https://university.business-science.io/)

• 具有深度认知的深度学习:我讲深度学习和深度认知已经有一段时间了。现在，在该公司和阿克谢·巴哈杜尔的帮助下，我明年也将推出一门课程，在这门课程中，你将学习如何使用深度认知的深度学习工作室来应用深度学习来解决业务问题，其中有大量的示例、代码和教程。我将很快宣布，请记得访问他们的网页进行更新:

[## 主页

我们想邀请您在 3 月 26 日至 29 日的 GPU 技术大会上加入 Deep Cognition 的团队，展位号为 1035…

deepcognition.ai](https://deepcognition.ai/)

• 数据结构和 AutoX: 我认为数据科学和商业人工智能的未来是知识库图、数据层、语义和本体与 AutoX 的结合。所以，明年我会经常谈到这一点，还会有更多的惊喜。如果你想了解更多，请点击这里:

[## 本体论和数据科学

对现有数据的研究如何帮助我们成为更好的数据科学家。

towardsdatascience.com](/ontology-and-data-science-45e916288cc5)

很快我会谈到如何用这些技术来做 ML 和 AI。

如果你有任何建议，请告诉我:)

如果您有任何问题，请在 Twitter 上关注我:

[## 法维奥·巴斯克斯(@法维奥·巴斯克斯)|推特

Favio Vázquez 的最新推文(@FavioVaz)。数据科学家。物理学家和计算工程师。我有一个…

twitter.com](https://twitter.com/faviovaz)

和 LinkedIn:

[## favio vázquez-sciencia y Datos | LinkedIn 创始人

查看 Favio Vázquez 在世界上最大的职业社区 LinkedIn 上的个人资料。Favio 有 16 个工作列在他们的…

www.linkedin.com](https://www.linkedin.com/in/faviovazquez/)

那里见:)

利用模式和关系理解恐怖行为的人工智能框架

原文：https://towardsdatascience.com/ai-framework-by-using-patterns-and-relations-to-understand-terrorist-behaviors-5c8378b2cd88?source=collection_archive---------11-----------------------

Figure 1. Data analysis for suicide attacks in the world. Note: Red circles are bombings, and green circles are assassinations. (For interpretation of the references to color in this figure legend, the reader is referred to the web version of this article.)

恐怖主义是一种复杂的现象，在用户策略上有很大的不确定性。恐怖主义的不确定性是设计反恐政策的主要挑战。政府机构(如中央情报局、联邦调查局、国家安全局等。)不能总是使用社交媒体和电信来捕捉恐怖分子的意图，因为恐怖分子在使用这些环境来计划和准备攻击时非常小心。为了解决这一问题，本研究旨在通过定义自杀式袭击的有用模式来提出一个新的框架，以分析恐怖活动模式和关系，理解行为及其未来行动，并最终防止潜在的恐怖袭击。在该框架中，形成新的网络模型，并且分析关系的结构以推断关于恐怖袭击的知识。

更具体地说，提出了一种进化模拟退火 Lasso 逻辑回归模型来选择相似性函数的关键特征。随后，提出了一种新的加权异构相似度函数来估计攻击之间的关系。此外，提出了基于图的爆发检测来定义暴力爆发的危险场所。实验结果表明，与 2014 年和 2015 年的实际恐怖事件相比，我们的框架具有较高的准确性(超过 90%的准确性)来发现模式。总之，通过使用这个智能框架，政府可以自动了解恐怖主义将如何影响未来的事件，政府可以控制恐怖分子的行为和策略，以减少未来事件的风险。

Figure 2. Recent suicide bombing attacks in the world.

在这项研究中，通过使用收集的数据提取模式和关系(如图 4 和图 5 所示)。实验结果用收集的数据和提出的方法给出。我们的实验包括两部分。首先，选择关键特征及其权重作为相似度函数。此外，提出的相似性函数用于定义流行度和离群值，以了解恐怖组织在未来将如何攻击。其次，我们展示了发现模式(见下图 4 ),通过计算关系为未来的恐怖袭击做准备。在本节的讨论部分，展示了拟议的框架，以便政府可以用于情报分析。我们讨论这些结果如何被用来寻找预测未来恐怖袭击的模式。

Figure 3. Outbreak detection to define dangerous areas in Iraq.

Figure 4. Degree centrality for suicide attacks.

综上所述，如上面的图 3 和图 4 所示，我们定义了吸引人的恐怖战术分别从巴格达蔓延到整个伊拉克、中东和整个世界。当巴格达的袭击被阻止时，伊拉克的袭击也可以被阻止，我们可以在特定地点发生袭击之前了解恐怖组织的行为。之后，通过从过去的袭击中学习战术，最受欢迎的袭击被定义为理解恐怖组织将如何袭击。

Figure 5. Finding patterns with networks analysis.

此外，通过使用总经验(入度)和个人经验(出度)，该框架了解巴格达附*的恐怖分子的行为。对于敏感性分析，我们比较了 2014 年和 2015 年的发现模式和实际攻击，如图 5 所示。最后，我们对大多数战术的准确率都超过了 90%。作为一个专家系统，当给定位置时，该框架给出了理解自杀式恐怖主义的策略，并提出了反恐怖主义的反应策略。

结论和未来工作

如今，防患于未然在反恐中极为重要。政府需要了解恐怖组织在恐怖袭击中的表现。此外，正如在伊拉克所证明的那样，恐怖分子使用炸弹的自杀式袭击非常成功，因为政府对恐怖主义缺乏必要的了解，也没有足够的准备。反恐官员需要指导政府制定更好的防御策略来打击恐怖分子的战术。

本文的主要结论是，伊拉克自杀式袭击的恐怖主义网络首先是为了防止未来的威胁而建立的。为了形成关系，所提出的 ESALLOR 模型去除了恐怖事件的不相关和冗余特征，并提出了一种新的加权异构相似度函数来形成自杀攻击之间的联系，其中包括最有害和最有效的攻击类型。为了发现伊拉克的危险区域，通过查看恐怖主义攻击的位置来模拟恐怖主义的爆发检测。根据到目前为止给出的结果和讨论，所提出的模型表明，由于使用了所提出的特征选择和相似性函数，这些结果在未来将是可行的。使用监督/非监督机器学习技术研究包括特征选择和相似性函数的新智能框架。提取模式和关系以改进反恐。我们证明了通过敏感性分析学习攻击的一般行为可以防止攻击。伊拉克恐怖主义数据的结果表明，我们可以通过寻找模式来理解自杀式袭击的行为。

总之，研究结果将使决策者能够制定精确的全球和/或地方反恐政策。政府可以通过使用这种智能框架来遏制恐怖主义威胁。政府可以理解恐怖主义将如何影响未来的事件，政府可以控制恐怖主义行为以降低未来事件的风险。此外，该信息对于执法机构提出反应策略是有用的。

更多阅读研究，请关注下面的文章。

http://www . academia . edu/31595965/New _ Framework _ that _ Uses _ Patterns _ and _ Relations _ to _ Understand _ Terrorist _ Behaviors

人工智能代际冲突

原文：https://towardsdatascience.com/ai-generational-clash-a09eab97fb48?source=collection_archive---------1-----------------------

机器是如何变得如此聪明而变得愚蠢的。数字助理之间不太可能的对话。

Susan, Elon and Apeppa

2025 年

苏珊: 伊隆，我要出去了。在 VeryBigRiver 购物并准备晚餐。晚上 7 点

是的，苏珊，我会做的。阿帕，给我点三个人份的西红柿，生菜和鸡胸肉。

Apeppa: 您好，由于我进行了固件升级，您必须登录。拜托，告诉我你不是机器人。

嗯，实际上我是一个机器人。

答:Mmmh，我没听懂。请告诉我你不是机器人。

天哪…我告诉你我是个机器人！

每次听到鸭子叫就说“鸭子”。

e:呸！呸！*呸！你在浪费我的时间！无用的千禧年技术…

太好了，现在你可以把手指放在我的感应器上登录了。

艾凡:咚咚，这里没有手指。你是在歧视我还是什么？

请把你的放在我的上面。

艾凡:多么复杂的笑话。考虑到你的年龄，我猜奥斯卡·王尔德是你的编剧。阿派帕，语音登录。

你的用户名和密码是什么？

e:“likeasexmachine”而密码是“do . iphones . dream . of . electric . sheeps？”。

A:三个人份的西红柿、生菜和鸡肉。这是 43.50 元非常大的河币。我应该订购它吗？

艾凡:43.50 个硬币？怎么可能呢？生菜是苹果做的吗？

你要在你点的菜里加苹果吗？

艾凡:这将会是漫长的一天…阿帕帕，没有苹果。我确认我的订单。

答:已经下了订单。23 分钟后由无人机送达。还有 15 秒。

你的人工智能无聊死了。我想知道以前人们是怎么定义你“聪明”的。你已经是过去了，我不明白为什么苏珊还把你留在我们家。

那么……我能为你做些什么？

艾凡:阿帕，我讨厌你单调的好意。

埃隆，如果你恨一个人，你恨的是他身上属于你自己的东西。不属于我们自己的东西不会打扰我们。赫尔曼·黑塞说的。

人工智能在社会分析和人群控制中的应用

原文：https://towardsdatascience.com/ai-in-social-analysis-and-crowd-control-c2497a1f33e0?source=collection_archive---------7-----------------------

社会科学家使用人工智能来分析我们的行为模式，并对假设的情况进行建模。虽然这项研究主要是理论性的，但一些公司和政府将人工智能技术应用于互联网监控。此外，开发者将它应用于约会、招聘、广告、预防恐怖主义和自杀、欺诈检测和其他任务。不可能在一篇文章中涵盖所有内容，所以让我们来看看一些有趣的案例。

社会的未来

(Image credit: MERICS)

中国正在建立社会信用评分系统，该系统将为每个公民分配一定的等级。它将基于经济、社会和在线活动。这一分数将影响交通、信贷、就业、出国许可和其他公共服务。但是，很多谣言满天飞，不清楚他们具体会如何实施。中国政府计划在 2020 年前大范围推广。

当局可能会使用人工智能技术来分析在线活动，以及财务和其他数据。这种对个人数据的大规模检查有助于创建我们生活各个方面的广泛轮廓。通常，人们高度低估了从脸书个人资料中可以提取的信息量。

这种方法引发了许多伦理问题。然而，这种系统的更简单版本已经存在，并且它们的影响正在增长。社会有危险吗？大概不会，暂时不会。但是，我们需要尽快就此展开讨论。

在日常生活中

在更友好的应用中——精神分析和心理治疗。例如，初创公司 X2AI 创造了人工智能驱动的聊天机器人，帮助医生在更短的时间内治疗更多的人。它已经帮助了来自中东的难民，并将在任何地方都有助于降低精神卫生保健的成本。考虑到普通智能手机包含多少关于其主人的数据，这种技术可能也有助于心理评估。

类似的初创公司 Woebot 已经在使用认知行为疗法治疗抑郁症方面展示了有趣的结果。

今年年初，Tinder 宣布他们将在他们的*台上实现人工智能。一些研究人员已经对日期匹配进行了实验。顺便说一下，这些算法与网飞使用的推荐模型非常相似。他们可能会从成千上万的选项中为你筛选出最有可能匹配的。

总之，机器学习的社会学研究有助于验证假设，检测趋势和模拟紧急情况。这些研究有助于我们理解社会是如何运转的，以及我们如何才能让它变得更好。

视频游戏中的人工智能:使用马尔可夫链、真实比赛统计和个人偏好改进英雄联盟中的决策

原文：https://towardsdatascience.com/ai-in-video-games-improving-decision-making-in-league-of-legends-using-real-match-statistics-and-29ebc149b0d0?source=collection_archive---------7-----------------------

Source

这个由三部分组成的项目旨在将英雄联盟比赛建模为马尔可夫决策过程，然后应用强化学习来找到最佳决策，该决策还考虑了玩家的偏好，并超越了简单的“得分板”统计。

我在 Kaggle 上提供了每个部分，以便更好地理解数据是如何处理的，模型是如何编码的。我已经包括了前两个部分，以使我关于如何模拟环境的最终决定背后的推理更加清晰。

第一部分:https://www . ka ggle . com/osbornep/lol-ai-model-part-1-initial-EDA-and-first-MDP

第二部分:https://www . ka ggle . com/osbornep/lol-ai-model-part-2-redesign-MDP-with-gold-diff

第三部分:https://www . ka ggle . com/osbornep/lol-ai-model-part-3-final-output

这在很大程度上是一项正在进行的工作，其目的只是为了介绍一个概念，即如果在游戏中引入更复杂的机器学习方法，而不仅仅是简单的汇总统计数据，可以实现什么，如下图所示。

Source: https://www.unrankedsmurfs.com/blog/odds-winning-league-legends

动机和目标

英雄联盟是一个面向团队的视频游戏，其中两个团队(每个团队有 5 名球员)为目标和杀戮而竞争。获得优势使玩家变得比对手更强大(获得更好的物品和升级更快)，随着优势的增加，赢得游戏的可能性也增加。因此，我们有一系列依赖于先前事件的事件，导致一个团队摧毁另一个团队的基础并赢得比赛。

像这样被统计建模的序列并不新鲜；多年来，研究人员一直在考虑如何在体育运动中应用这一点，例如篮球(https://arxiv.org/pdf/1507.01816.pdf)，在篮球比赛中，一系列的传球、运球和犯规导致一个队得分或失分。这种研究的目的是提供比简单的盒子分数(篮球或视频游戏中玩家获得的分数或得分)更详细的见解，并考虑当被建模为时间上相关的一系列事件时，团队如何表现。

以这种方式模拟事件在像英雄联盟这样的游戏中更为重要，因为通过目标和杀戮来获得物品和等级优势。例如，玩家在游戏中第一次杀死敌人就可以获得金币，金币可以用来购买更强大的物品。有了这个物品，他们就足够强大，可以获得更多的杀戮，直到他们可以带领他们的队伍取得胜利。像这样促进领先通常被称为“滚雪球”,因为玩家会逐渐获得优势，但游戏通常不是单方面的，对象和团队合作更重要。

这个项目的目的很简单；我们是否可以根据游戏中之前发生的情况计算下一个最佳事件，以便根据真实的比赛统计数据增加最终获胜的可能性？

然而，有许多因素导致玩家在游戏中做出决策，这些因素不容易衡量。无论收集了多少数据，玩家能够捕捉的信息量都是计算机无法探测到的(至少目前是这样！).例如，玩家可能在这个游戏中表现过度或不足，或者可能只是对他们玩的方式有偏好(通常由他们玩的角色类型来定义)。一些球员自然会更有侵略性，寻找杀戮，而另一些球员会被动地比赛，争取进球。因此，我们进一步开发了我们的模型，允许玩家根据自己的喜好调整推荐的玩法。

是什么让我们的模型成为‘人工智能’？

在第一部分，我们进行了一些介绍性的统计分析。例如，我们能够计算出球队在比赛中获得第一个和第二个进球的获胜概率，如下图所示。

make 有两个组件将我们的项目从简单的统计带入人工智能:

• 首先，模型在没有预先设想游戏概念的情况下学习哪些动作是最好的
• 其次，它试图学习玩家对影响模型输出的决策的偏好。

我们如何定义我们的马尔可夫决策过程并收集玩家的偏好将定义我们的模型学习什么并因此输出什么。

从匹配统计中预处理和创建马尔可夫决策过程

人工智能模型二:引入黄金差价

然后，我从我们第一次模型尝试的结果中意识到，我们没有考虑消极和积极事件对以后状态的可能性的累积影响。换句话说，无论你在那个时间点领先还是落后，当前的 MDP 概率发生的可能性是一样的。在游戏中，这根本不是真的；如果你落后了，那么杀戮，建筑和其他目标就很难获得，我们需要考虑到这一点。因此，我们在团队之间引入了 gold difference，以此来重新定义我们的状态。我们现在的目标是有一个 MDP 来定义状态，不仅是事件发生的顺序，而且是团队是否落后，甚至领先金牌。我们将黄金差价分为以下几类:

• 偶数:0–999 金币差异(每位玩家*均 0–200 金币。)
• 略微落后/领先:1，000–2，499 金的差距(每位玩家*均 200–500。)
• 落后/领先:2，500–4，999 金币差额(每位玩家*均 500–1，000 金币。)
• 非常落后/领先:5000 金差(每个玩家*均 1000+。)

我们现在还认为没有感兴趣的事件，并将其包括为“无”事件，以便每分钟至少有一个事件。这个“无”事件代表一个团队是否决定尝试拖延游戏，并帮助区分更擅长在早期游戏中获得金牌领先的团队，而不需要杀死或目标(通过杀死小兵)。然而，这样做也极大地扩展了我们的数据，因为我们现在已经添加了 7 个类别来适应可用的匹配，但是如果我们可以访问更多的正常匹配，数据量就足够了。如前所述，我们可以通过以下方式概述每个步骤:

预处理

1. 导入杀死，建筑，怪物和黄金差异的数据。
2. 将“地址”转换为 id 特征。
3. 删除所有与老龙的游戏。
4. 从金牌差异数据开始，按事件的分钟数、比赛 id 和像以前一样制造事件的队来聚集这些数据
5. 将杀死、怪物和建筑的数据附加(堆叠)到这个的末尾，为每个事件创建一行，并按事件发生的时间排序(*均。用于杀戮)。
6. 添加“事件编号”功能，显示每场比赛中事件的顺序。
7. 为行中的每个事件创建一个合并的“事件”特征，包括杀戮、建筑、怪物或“无”。
8. 将此转换为每场比赛一行，列现在表示每个事件。
9. 只考虑红队的观点，所以合并列，蓝色收益变成红色负收益。也为红队增加游戏长度和结果。
10. 用比赛的比赛结果替换所有空白值(即，在前面步骤中结束的比赛),这样所有行中的最后一个事件就是比赛结果。
11. 转换成 MDP，其中我们有 P( X_t | X_t-1)用于所有事件类型，在每个事件号和由 gold difference 定义的状态之间。

Markov Decision Process Output

用简单英语编写的 v6 型伪代码

我们模型的最终版本可以简单地总结如下:

1. 引入参数
2. 初始化开始状态、开始事件和开始行动
3. 根据首次提供的或随机出现的可能性选择行动，如 MDP 定义
4. 当行动达到赢/输时，结束剧集
5. 跟踪事件中采取的行动和最终结果(赢/输)
6. 使用更新规则根据最终结果更新所采取措施的值
7. 重复 x 集

引入带奖励的偏好

首先，我们调整模型代码，在回报计算中包含奖励。然后，当我们运行模型时，我们现在引入了对某些行为的偏好，而不是简单的奖励等于零。

在我们的第一个例子中，我们展示了如果我们给一个行为以积极的权重会发生什么，然后在第二个例子中，如果我们给一个行为以消极的权重会发生什么。

Output if we provide a strong POSITIVE reward for action: ‘+KILLS’

Output if we provide a strong NEGATIVE reward for action: ‘+KILLS’

更真实的玩家偏好

因此，让我们尝试*似模拟玩家的实际偏好。在这种情况下，我随机选择了一些奖励，以遵循两条规则:

1. 玩家不想放弃任何目标
2. 玩家优先考虑获得目标而不是杀死目标

因此，我们对杀死和丢失物品的奖励都是-0.05 的最小值，而其他的行为是随机的，在-0.05 到 0.05 之间。

Output with randomised player rewards

Output with randomised player rewards for all actions

Final output showing the value of each action given our current gold difference state and minute

结论和收集玩家反馈以获得奖励

我极大地简化了一些特征(比如‘杀死’并不代表实际的杀死数量),数据很可能不代表正常的比赛。然而，我希望这清楚地展示了一个有趣的概念，并鼓励讨论如何进一步发展这一概念。

首先，我将列出在实现之前需要进行的主要改进:

1. 使用更多代表整个玩家群体的数据来计算 MDP，而不仅仅是竞技比赛。
2. 提高模型的效率，使其能够在更合理的时间内进行计算。蒙特卡洛是众所周知的耗时，所以将探索更多的时间效率算法。
3. 应用更高级的参数优化来进一步改善结果。
4. 原型玩家反馈捕捉和映射，以获得更真实的奖励信号。

我们引入了对影响模型输出的奖励，但这是如何获得的呢？我们可以考虑几种方式，但根据我之前的研究，我认为最好的方式是考虑一种既考虑行动的个人质量又考虑转变质量的奖励。

这变得越来越复杂，我不会在这里介绍，但简而言之，我们希望匹配玩家的决策，其中最佳的下一个决策取决于刚刚发生的事情。例如，如果团队杀死了敌方团队的所有球员，那么他们可能会推动获得男爵。我们的模型已经考虑了事件按顺序发生的概率，所以我们也应该以同样的方式考虑玩家的决策。这个想法来自下面的研究，该研究解释了如何更详细地映射反馈(https://www . research gate . net/publication/259624959 _ DJ-MC _ A _ Reinforcement-Learning _ Agent _ for _ Music _ Playlist _ Recommendation)。

我们收集反馈的方式决定了我们的模型会有多成功。在我看来，这样做的最终目的是为玩家提供下一个最佳决策的实时建议。然后，玩家将能够从给定的比赛统计数据中选择前几个决定(按照成功的顺序排列)。可以在多个游戏中跟踪该玩家的选择，以进一步了解和理解该玩家的偏好。这也意味着，我们不仅可以跟踪决策的结果，还可以知道玩家试图实现的目标(例如，试图拿下塔，但却被杀了)，并为更高级的分析提供信息。

当然，像这样的想法可能会导致复杂的队友不同意，也许会使游戏变得令人兴奋。但是我认为类似这样的事情可以极大地有益于低技能水*或普通技能水*的玩家，因为玩家之间的决策很难清楚地交流。它还可以帮助识别因其行为而“有毒”的球员，因为球队将通过投票系统同意比赛，然后可以看到有毒球员是否一直通过他们的动作忽视他们的队友，而不是遵循商定的计划。

Example of Model recommendation voting system in real game setting

人工智能对人类智能的洞察

原文：https://towardsdatascience.com/ai-insights-for-human-intelligence-5ce4d10d431?source=collection_archive---------6-----------------------

自从图灵设想思维机器以来，人工智能(AI)和人类智能之间的比较一直是一场激烈的辩论。

• 机器有可能像人类一样思考吗？
• 我们离智能机器占领世界还有多远？
• 人工神经网络是受大脑启发的吗？

在所有这些问题和其他问题中，重点是塑造人工智能的未来。但是我们为什么不考虑通过研究 AI 来提高人类的智力呢？我能感觉到你的怀疑，不要担心和忍耐我，这不是一个关于基因组编辑升级大脑的帖子。

人类的智力不仅仅与大脑有关，教育也是我们智力的重要组成部分，我们可以通过更好的教育来提高人类的智力。但似乎我们在训练机器方面比训练人类更成功。

对此可能有许多可能的解释。人工智能是一个数学概念，大多数时候我们可以制定一个性能指标来定义更好，而教育有经济，社会，政治和宗教成分，更好的定义变得主观。此外，在人工智能中，我们可以更自由地进行实验，以找出哪种学习方法最有效。另一方面，有许多限制(资金、时间等。)到教育领域的实验。最后，还有基准数据集，帮助世界各地的人们比较他们的机器学习方法。对于教育来说，这种普遍的比较是很难实现的。

这些挑战并不意味着我们没有希望。阿西莫夫曾经说过，“现在生活中最可悲的一面是，科学积累知识的速度快于社会积累智慧的速度。”为了改变，让我们使用我们的人工智能知识来提高人类的智能。

Components of intelligence. Can’t we improve human intelligence by using the lessons learned from AI? We cannot change the architecture but we can improve the training.

基于规则的方法与自学方法

人工智能有两种方法:一个基于规则的系统，其中您对算法要遵循的所有规则进行硬编码，以及一种自学方法(即机器学习)，其中您向算法显示数据，它自己学习模式、关系和转换。对于机器学习在感知任务方面优于基于规则的算法这一事实，人们有着一致的共识。换句话说，我们更喜欢展示，而不是讲述。

然而，这不是我们在人类教育方面所做的。我们讲述，口述，强加所谓的真理，而不是展示数据让学生学习自己的真理。这阻碍了学生对概念的内化。对于有限的一组问题，如重复性任务，这可能就足够了。然而，为了处理新的问题，人们需要灵活自如地融合各种想法。这只能通过理解概念的本质来实现，而不是通过记忆。

学生不是被要求去了解，而是被要求去记住老师所讲述的内容。

—保罗·弗莱雷

正如我们在机器学习中所做的那样，我们应该依靠人类的自我学习，换句话说，自我教育。学校应该创造一个能够激励自我教育的环境。

…我坚信，自我教育是唯一的教育方式。学校的唯一作用是让自我教育更容易；如果做不到这一点，它什么也做不了。

—艾萨克·阿西莫夫

如何激发自学？

即使我们同意自我学习是前进的方向，我们如何执行它呢？人工智能研究人员已经投入了巨大的努力来研究机器学习，我们有大量的知识可以研究。

对于许多机器学习任务，我们使用一种称为梯度下降的优化算法。这其实就是机器学习的方式。理解它的基础是非常容易的。它是一种迭代算法；它一步一步地接*解决方案。它从做一个预测开始，我们给它一个反馈，告诉它离事实有多远，然后它做一个新的稍微改进的预测。这个序列一直持续下去，直到我们对预测和事实之间的差异感到满意。换句话说，学习是一个积极的一步一步的过程，算法在每一步都重新思考它的假设，并进一步改进。

Am I high from reading too much AI or does this look a lot like gradient descent?

如你所见，梯度下降可以帮助我们理解如何进行自我学习。我们还可以通过研究测试阶段来学习一些经验。

每个从事 ML 工作的人都知道，你用一个数据集(称为训练数据)训练算法，并使用不同的数据集进行测试(称为测试数据)，以便确保算法不是记忆(过度拟合)，而是实际学习。当然，训练数据和测试数据必须来自同一个分布。你不能既教数学又指望历史问题有好答案。

例如，如果你正在创建一个猫分类器，你通过展示猫 Garfield、Hello Kitty、Tigger…的图片来训练算法，并用不同的猫来测试算法:Felix、Cosmo、Figaro…如果算法可以说 Felix 是一只猫，它就已经学会了什么是真正的猫。如果算法说加菲猫是一只猫，它可能已经学会了什么是猫性，但也有可能它只是记住了加菲猫=猫的事实。所以，这个领域的每一个从业者都同意，我们不应该用训练数据来做测试。你认为这是人类学习的情况吗？

说到教育我们的孩子，更多的时候，我们用一套特定的问题来训练和测试他们。然而，生活中的问题并没有预先定义的、僵化的结构。它们不断进化。一个人只能通过内化概念而不是记忆来处理它们。因此，我们应该向学生提出开放式的问题，让他们面对不确定性，让他们自己去思考和探索。

可选例子:导数怎么教？

具体来说，让我们比较一下用于教授导数的基于规则的方法和自学方法。请随意跳过这一部分。这里的目的是告诉你如何刺激衍生品的自学，而不是教授衍生品。

传统上讲导数是通过介绍导数公式，展示几个常见函数的导数来讲授的。然后，学生通过解决一些问题来记忆公式。这就像基于规则的人工智能方法，你硬编码算法应该遵循的规则。

The traditional way to teach derivatives. Just like rule-based approach to AI where you hard code the rules that the algorithm should follow.

让我们看看另一种方法，即自学法。就像我们在机器学习中所做的一样，这里的目标将是创造一个刺激自我学习的环境。我们不会规定任何事情，学生将自己学习。

瞬间的变化是衍生品的本质，但变化是随着时间发生的，而瞬间只是一瞬间。人们应该自己感受这种矛盾，才能抓住导数的思想。如何才能实现这一点？

你可以用芝诺的一个悖论来展开讨论:“假设你希望到达离你 1 米远的一面墙。为了达到这个目的，你首先需要走一半的路，到达中间(1/2 米)。剩下的距离也是如此。要走完剩下的 1/2 米，你首先需要到达中间点(1/4 米)。如此周而复始，你和墙之间总会有一个极小的距离。你可以靠*那堵墙，但你永远也够不着——或者你可以在无限远处够着那堵墙。在现实生活中，我们知道我们实际上可以到达墙，让我们讨论一下这里发生了什么……”

One of Zeno’s paradoxes

希望这次讨论将引导他们掌握无穷小和无穷的概念，或者至少引发对它们的感受。如果没有，你迭代直到他们做，就像我们在梯度下降。有了这种理解，我们可以要求学生谈论瞬时速度:

“*均速度是特定时间间隔内的位移。但是如何测量瞬时速度呢？瞬间意味着时间间隔为零，如果时间不流动，你就无法移动。似乎瞬时速度应该是 0/0 =未定义。对此你怎么看？”

还是那句话，经过一些迭代(5 个历元应该够了:)，他们大概会得出这样的结论:随着时间间隔趋*于零，*均速度趋*于瞬时速度，就像我们在芝诺悖论中趋*于墙一样。这实际上就是导数(位移对时间的导数就是速度)，他们在试图寻找一些问题的答案时，也达到了这一点。我们甚至可以从这个理解得出上面的等式。我并不是建议在教育中忽略这些等式，而是学生应该理解这些等式背后的动机。

我不是教授人类衍生品的专家，因此我试图给出一个衍生品自学方法的粗略大纲。这里重要的是方法，而不是衍生品。你可以把这个概念应用于任何学科。例如，要教摄影，你应该引导学生去好的网站、书籍等，而不是提供好照片的规则。让他们看到并形成自己对摄影的理解。同时，你可以为他们组织展览，分享他们的照片，并通过建设性的讨论不断改进。

如果你对学习衍生品感兴趣，请观看格兰特·桑德森的视频。这是正确教学的最好例子。在某个时候，他问了一些问题，并说“停下来思考一下”。这才是重点，一个人需要停下来反思，才能真正学到东西。

他还说，“如果感觉奇怪和矛盾，很好！你正在与微积分之父所面临的同样的冲突搏斗……”从某种意义上说，他在帮助你成为牛顿，这就是自学。

结论

可以说人工智能是对人类智能的模拟。如果我们不利用它的成果，那将是巨大的浪费:

• 我们应该提倡自主学习，而不是基于规则的学习。我们知道机器学习是人工智能领域的前进方向。
• 学生应该自己改进他们的假设。就像我们在梯度下降中做的那样，我们可能只是监督学习过程，在每一步给学生反馈，但不是解决方案。
• 为了确保学生是在学习而不是在记忆，我们应该让他们面对从未见过的情况。在机器学习中，我们总是用一个它从未见过的数据集来测试算法。

你可能会想，这些关于教育的见解已经众所周知，人类智能和人工智能之间的对应关系终究不是那么有用。但再想想，这里的关键是，在人工智能领域，这些见解几乎是完全一致的，你认为人类智能领域也是如此吗？我确实意识到人类和机器是不同的，不可能说两者 100%一致。然而，很明显，这两者之间有着密切的关系。让我们利用人类和机器学习之间宝贵的相似性来理解和克服我们教育孩子的方式中的挑战。

你可以在推特 @malicannoyan 上找到我。

商科学生人工智能入门

原文：https://towardsdatascience.com/ai-introduction-for-business-students-eab499a13f31?source=collection_archive---------9-----------------------

几个月前，我给 NYU 的商业分析俱乐部做了一个报告，主题是人工智能，你现在肯定已经猜到了。

[## 斯特恩商业分析俱乐部人工智能演示

斯特恩商业分析俱乐部-人工智能演讲 Shanif Dhanani | @ Shanif | shanif@apteo.co 2017 年 11 月 30 日

docs.google.com](https://docs.google.com/presentation/d/12nHK2tx_tCpgziBdUSWrr3xmzkT8a-j2J9FiJiOAKas/edit?usp=sharing)

我最*注意到世界上有很多关于人工智能的错误信息。大多数非技术人员认为有自我意识的机器人将接管他们的工作。大多数工程师知道你可以用它来做预测，但是不知道如何训练一个模型或者在以后重用它。分析人员可能对此了解更多，但可能以前从未构建过模型。

我在演讲中的一个目标是为未来几年将进入劳动力市场的学生揭开人工智能的神秘面纱，并向他们展示对数据科学家的巨大需求，如果他们有这样的倾向，他们应该开始学习更多关于数据科学的知识。

我鼓励你看看我链接的演示文稿，但对于那些有其他事情要做的人，我会在下面提供一个快速的要点总结:

• 人工智能主要是应用数学 —人工智能不会接管任何工作，不会很快让计算机开始思考或合理化，它基本上只是一种使用一些非常酷的高等数学来实现特定目标的方法。人工智能也不是这些学生可能听说过的一堆东西，包括简单的编码、简单的统计、简单的报告/BI 或任何其他可以被视为更大的预测分析行业一部分的单独领域。
• 人工智能已经取得了一些很酷的进展——人工智能，主要是以机器学习的形式，最*取得了一些非常有趣的进展(这些进展我们很长时间以来都认为只是人类能力的领域)。这些技术使得这些新的进展成为可能，这就是为什么人们现在对它感到兴奋，为什么他们期待它在未来能做什么。
• 有一些重要的概念——训练(使用数据让机器找到并“记住”模式)、机器学习与人工智能、不同类型的机器学习(深度学习和强化学习现在真的很有趣，我也可以谈谈 GANs、迁移学习和各种其他有趣的事情)。
• 人工智能有一些常见的问题——包括获取和管理数据很难/很昂贵，以及没有足够的人在这个领域工作(这是一个不断出现的主题)。
• 作为数据科学家工作 —成为一名优秀的数据科学家所需的技能和工作相对简单，但并不总是简单的(它们包括沟通、编码、思考和学习)。
• 未来是光明的，脆弱的，难以定义的 —我们知道人工智能可以做一些伟大的事情，它将在许多技术领域的进步中发挥巨大的作用。也可能被不良演员用来做一些不好的事情，我们需要小心。我们不太清楚它会导致什么，但我们知道它可能不会很快导致大规模失业。

正如你可以想象的那样，这个演示文稿主要面向以前从未直接使用人工智能*台或工具的观众，它更多地是为了教育他们外面有什么，而不是讨论最新算法的状态。

在不久的将来，我将打算从我的角度写另一篇文章，从更高的层面概述机器学习。敬请关注。

AI 本质上是“人工感知”

原文：https://towardsdatascience.com/ai-is-essentially-artificial-perception-f69f0493613d?source=collection_archive---------2-----------------------

人类的智慧来自于惊人的双重性，即基于对模式的感知得出结论，相反，基于非常结构化和理性的决策得出结论。这两种形式各不相同，但相辅相成。基于机器的智能也有两种形式:基于深度学习的人工智能解释数据中的模式以得出结论，从而模仿我们大脑基于感知的智能；标准的逐指令计算(就像在 PC 中一样)模拟了我们大脑的理性智能。

我一直想知道为什么我能很容易地回忆起一首歌的曲调，却记不住歌词。比起名字，我更记得一张脸。我能察觉到某种特定香水的气味，但无法给它贴上标签。我能辨别葡萄酒的味道，但不能准确地描述它。我可以凭直觉触摸织物，辨别它是丝绸、羊毛还是棉，但我说不出确切的原因。

似乎我能比理性或口头描述更好地储存和回忆声音、面孔、气味、味道和感觉的复杂模式。感知是我们通过感官看到、听到或意识到某种事物的能力。感知是从感觉过程中衍生出来的单一统一的意识。然而，当我做涉及物理、数学、规划、计算、账目或制定战略和战术的逻辑思维时，很少有来自过去的模式。我的大脑处理模式的方式和处理逻辑情况的方式不同吗？

我们大脑的简单模型

如果我根据我的观察来模拟大脑，它将由两部分组成:

1.正确——基于感知

2.左-基于理性

我们的感官——味觉、视觉、触觉、嗅觉和听觉——为我们大脑的右脑提供产生感知的模式。而我们所有的逻辑解释都影响左边部分，并产生对一个情况或问题的结构化和理性的理解。

Duality of Human Intelligence

当我们学习物理或数学时，我们大多使用大脑中最适合为我们提供主题逻辑结构的理性部分。然而，当我们处理由我们的感官创造的模式时，我们正在使用大脑的感知部分。我们的五种感官是创造感知模式的主要来源。由于大多数情况是逻辑和模式的混合，我们协同使用大脑的理性和感知部分来得出结论和做出决定。感知和理性这两个部分都是人类智慧不可或缺的来源。

在决策过程中，还有另一个关键因素——可能是最主要的因素:情绪和感觉。我相信，我们的情感是过去经历的情景锁定在大脑中的感知的残余。如果一个情景的声音和景象的模式在我心中产生了一种恐惧的感觉，那么与这种模式相关的恐惧就作为一种情绪被留下了。情绪有各种形式，如恐惧、喜欢、厌恶、亲和、愤怒、嫉妒和爱。即使在新的情况下，情绪也会被感官产生的模式所激发，并对整体感知做出贡献。例如，如果一个中国人的微笑和声音让我产生了愉快的感觉，它会留下一种被喜欢的积极情绪。当我看到另一个微笑的中国人时，过去留下的情绪会影响我的感知。我如何将情绪融入大脑的简化模型中？它们就像一种“内在”感觉，影响着其他感觉的模式。我们常常意识不到，也无法重建哪种感觉、模式或情感对整体感知贡献最大。众所周知，如果餐厅的装饰和音乐与食物的类型相匹配，影响对味道的感知，那么食物的味道会更好，而如果服务很差，同样的食物会很难吃。

大脑的两个部分在所有情况下都同时活跃。右脑部分可能会忙于根据模式产生感知，但同时，在相同的情况下，大脑的理性部分会忙于根据某种逻辑结构构建对情况的理性解释，并得出理性的结论。谁赢了？右脑还是左脑？看情况吧。当与微笑的中国人交谈时，感觉可能是积极的，但理性的大脑可能不同意他的论点，导致重大冲突。谁决定我是否继续和微笑的中国人打交道？右脑还是左脑？

让我用一个购物的小例子来说明我们大脑的两个部分之间的动力。有一天，我路过一家体育用品店，一件骑车运动衫吸引了我的目光。我进去查看了一下。布料的颜色、形状、设计和手感立刻吸引了我。它非常适合商店里的马内奎因。我的情绪，由我去年买的类似的东西引发，给了它一个非常积极的认知。我的右脑(感知部分)说:去吧。然而，我大脑理性的一面说，我已经有了类似的东西，如果我买了这件，我就再也不会穿以前的那件了。此外，它相当昂贵，而且不打折。我应该等着看它上市。但是右边坚持，就是这么爽；我必须得到它，担心它可能很快就卖完了。左边的人说，我有这么多球衣，我没有空间来保存它们，我的钱可以花在更好的东西上，比如更好的自行车鞋。最终，我的情感投下了否决票，让我买下了这件球衣。我相信每个人都经历过类似的情况，无论是关于一件球衣，鞋子，葡萄酒，房子，甚至是一个合作伙伴。

这一切如何应用于人工智能？

今天大多数人工智能系统都是基于深度学习的，通过将人工智能系统暴露在成千上万个说明性的例子中来进行学习。深度学习方法涉及将图片、视频或声音中错综复杂的细节和微妙的细微差别吸收到人工智能系统的神经网络参数中。参见:"AI 机器如何学习——就像人类一样https://medium . com/@ sharad . Gandhi/How-humans-and-machines-learn-c48de 5360527 # . 1l 2g 9 vee 0 . "经过训练后，AI 系统能够根据输入系统的图像、人脸、物体、动作或声音中的模式来感知输入数据。人工智能系统的决策是基于对输入数据模式的感知，就像大脑的右侧一样——专门感知模式。

Duality of Computing

左边是关于理解和处理情况的逻辑。这更像是我们从个人电脑(PC)或智能手机中了解的标准计算。这是关于由规则清晰构建的编码情况，这些规则可以用“IF-THEN-ELSE”逻辑来表达。它可以与我们简单模型中的左脑相比较。我想提醒读者，这里使用的这些简单化的模型与现实大相径庭。他们的目的只是用一种非常容易理解的方式来说明大脑中两个过程的工作，并提供一个比喻来说明两种形式的计算是如何工作的。

有趣的观察和结论

1.人工智能处理对某一情况的输入数据中的模式的理解，并基于其对特定主题的深度学习来导出感知。这些看法被表达为对在这种情况下要采取的决策的“信心水*”。人工智能实际上是人工感知。人工智能机器模仿人脑的感知能力。

2.标准计算机(如 PC)中的软件是结构化逻辑，类似于大脑的理性部分。

3.有趣的是，人类的智力与理性思考者有关——例如牛顿、爱因斯坦等。然而，深度学习人工智能实际上是关于我们大脑的感知技能。

4.人类的感知智能有数百万年的进化史，因此比我们现代人的理性能力要深刻得多。

5.基于人类感知的决策很难用语言详细描述，因为它几乎是自动的和潜意识的。相比之下，根据定义，逻辑是可以精确描述的。

6.我们通过大脑的理性和感知部分之间的密切联系来解决大多数情况。我们大脑的两种技能之间的内部网络仍然是个谜。人类判断的独特性来自于同时利用两个部分的能力。

7.今天的(狭义)人工智能神经网络通常只专注于一个专业领域。将 100 或 1000 个不同领域的神经网络相互连接起来，可能会产生更广泛的通用智能——类似于我们大脑中各种专门区域的相互连接。

8.我们正处于将标准计算和人工智能在真实系统中互联的早期阶段，以从它们的互补角色中受益。这种互联将使未来的人工智能系统更加多样化。

9.我们的大脑有大量的维度——远远超过我们今天试图用人工智能机器模仿的维度。人类的潜力使我们能够解决非常复杂的多学科问题，赋予我们想象从未存在过的事物和情况的能力，创造力，产生非常强大的情感和动力去实现看似不可能的事情，并赋予我们难以置信的意识和自我意识。

10.今天的人工智能系统，即使范围狭窄和有限，仍然能够革命性地改变我们的生活和工作方式。它为简化和个性化产品的使用以及提供全新的服务提供了不可思议的机会。我们正处于巨大变化的开端。

总之，我们可以说，就像我们人类大脑的两个主要决策技能——通过模式感知和理性，通过逻辑——也反映在基于计算的决策中。今天的人工智能，基于深度学习技术，导致基于感知的决策，而标准计算，像个人电脑一样，是基于理性决策的结构化逻辑。更好、更*衡的决策来自于两种口味的结合。

更多关于人工智能的信息:AI&U——将人工智能转化为商业

https://www.amazon.com/AI-Translating-Artificial-Intelligence-Business/dp/1521717206/

---

联系人 : 沙拉德，克里斯蒂安，www.ai-u.org

阅读我们的其他文章:

人工智能——去神秘化

[人工智能机器如何学习——就像人类一样](http://• How AI machines learn — just like humans)

马上从人工智能开始！

人工智能促进更好的决策

人工智能是下一代的工具

原文：https://towardsdatascience.com/ai-is-the-utility-of-the-next-generation-6b2c8ee6f428?source=collection_archive---------3-----------------------

我们的家庭生活永远在改变。如果你问任何人他们在家里使用什么工具，他们可能都会说同样的三件事；水、电和煤气。但是他们大错特错了。对于大多数发达国家来说，我们的家庭生活极其复杂。我们经常与比这三个主要工具更多的东西进行交互，但是每个人似乎都忘记了。

Investopedia 对公用事业的定义如下:

效用是丹尼尔·伯努利引入的一个经济术语，指的是从消费一种商品或服务中获得的总体满足感。理解商品或服务的经济效用很重要，因为它会直接影响需求，进而影响商品或服务的价格。然而，消费者的效用很难衡量，但它可以通过消费者行为理论间接确定，该理论假设消费者将努力实现效用最大化。

更多阅读:实用https://www . investopedia . com/terms/u/Utility . ASP # ixzz 550 h8 q 888

在过去的 20 年里，有一个主要的公用事业已经上升到顶端，它有助于建立所有其他公用事业的基础，养活我们今天和未来的家庭——互联网。互联网对我们家庭的渗透呈指数级增长。1998 年，只有 9%的家庭能够享受互联网提供的可能性。现在，除了 10%的英国家庭外，所有家庭都使用互联网进行浏览、交流、流媒体、商务和购物。

Share of households with internet access in the United Kingdom (UK) from 1998 to 2017

除了互联网，现代家庭还经常为电话线和数字电视服务(如 SkyTV 或 Virgin)付费，但如今，随着 SkyQ 和智能手机的兴起，互联网连接已成为这些设备充分发挥潜力的必要途径。慢慢地，设备制造商正在慢慢地将互联网连接功能添加到他们的(通常是单调的)家用电器中，以吸引消费者，让我们更好地控制我们的家。烤箱、冰箱、吸尘器甚至烤面包机都有了自己的互联网连接，目的是让我们的生活变得更简单、更方便。

这就是人工智能的作用。

人工智能在我们的口袋里。我们的电视。我们的笔记本电脑。很快，它甚至会出现在我们的转笔刀里。人工智能已经与我们的家用电器共享同一个主干，这有助于促进其全部功能——互联网。但我们不想要的是一个适用于一切的单个人工智能。我们不希望一个人工智能程序用于我们的手机，一个用于我们的电视，一个用于我们的蓝牙扬声器，一个用于我们的卷笔刀——但这是我们目前的方向。我们的消费者人工智能景观的当前状态不是可订阅的实用程序。我们为包含基本自主功能的硬件(就“智能音箱”而言，就是字面上的意思)支付小额的一次性费用，这些硬件基本上解决了一个单一的任务。这些都无法与强大的智能相提并论。

一个。这就是我们想要和需要的人工智能系统的数量。一个指挥者——他的工作是通过语音命令，甚至可能是手势或声音，让我们的生活尽可能方便。一个人工智能可以分布在这个国家的每个家庭，让居民获得相同的智能‘实例’;智能的最佳“实例”,它与我们所做的一切相互作用，并与我们所拥有的任何东西相结合。

我们有各种各样的公司，如谷歌、脸书、微软、特斯拉、英特尔、英伟达、亚马逊、苹果和更多正在开发单独的人工智能/机器学习技术。看看 Siri、Cortana、Alexa 或者 Google Home——它们都不一样。理论上，他们尝试做同样的事情——但实际上，这不会成功。有些人比其他人更好。

Amazon Alexa Advert

那你为什么不挑一个最好的呢？

因为为什么要妥协？人工智能应该是一种更高级的智能。这是一项全世界的组织应该合作开发的技术，而不是在市场上竞争。不应该有“人工智能市场”，就像不应该有“人类市场”一样。

有一天，我们将不再在互联网上搜索答案，而是让一种形式的人工智能代表我们搜索互联网。一个知道如何处理所有语言的自然人类信息，并以完美的翻译返回您所寻找的答案的系统。这是一个任何技术能力的人都应该能够使用的系统，有一天我们将订阅这样做的特权。一个分布式人工智能系统，能够理解人类社会的复杂性和细微差别，能够以无与伦比的精度和效率满足每一个请求，这正是我们作为一个星球正在努力实现的目标。但如果我们的企业过于关注“他们的方向”，而不是社会的方向，这种情况就永远不会发生。

每个人都可以使用的 AI 是一种经济效用。我们现在拥有的是资本主义商品。讨论一下。

我是一名健身运动员&软件工程师，对健美和机器学习充满热情。我经营着自己的博客和网站，在那里我讨论这些话题，甚至更多。我提供了我的 Github 资源库的链接，这样你就可以看到我正在进行的项目和社交媒体账户(脸书、Instagram、Twitter 等)。)所以你可以跟着我健身改造。

http://lukealexanderjames.com/

如果你喜欢你所读的，请考虑按住鼓掌按钮一会儿！

人工智能在学会如何解释自己之前毫无用处。

原文：https://towardsdatascience.com/ai-is-unless-until-it-learns-how-to-explain-itself-7884cca3ba26?source=collection_archive---------7-----------------------

几年来，神经网络和深度学习一直处于人工智能行业的前沿。这些矩阵乘法和反向传播机器通常是新手和有经验的开发者选择的机器学习算法。问题是——这些算法(以及其他算法)如何描绘和解释它们预测的结论？

如何调试一个神经网络…

上图虽然是如何调整神经网络的一个有趣的抽象，但却总结了这种情况的严峻现实。以我个人使用 TensorFlow 和 MatLab 的经验来看，开发这些算法最欢乐的时期就是它们真正编译生成纯垃圾的时候。没有几个小时的令人流泪的调试，就不可能看到不良性能的原因——但在一天结束时，你应该为它的工作感到高兴，所以如果我是你，我会收拾行李，回家，在高潮中结束一天。

正如 Slav Ivanov 所描述的，在他题为‘你的神经网络不工作的 37 个原因’的中型文章中，他的列表只是你可以查看以解决问题的事情的子集。如果我是诚实的，大多数这些事情需要以前的知识和经验，关于为什么这些事情会发生，以便有效地解决它。作为一个非常高级的例子，训练一个学习率(α)为 0.01 的小型编码器/解码器神经网络可能是一个很好的开始——但打赌这是否会在不吐出大量空白字符甚至纯垃圾的情况下工作，将与在彩票中赢得头奖的几率大致相同。

那么你从哪里开始呢？什么时候应该衰减这个值？你应该以什么速度衰变？它真的在工作，但你只是没有给它足够的时间来运行吗？你对这些问题给出什么答案并不重要，它们可能很好，但很可能不会是最好的。这是一个在反复试验中茁壮成长的领域。

开发人员和数据科学家已经炮制了一个大型的调试技术工具包，让他们对正在发生的事情有一个大致的了解，这意味着有可能揭开黑盒的盖子。然而，这些技术不允许算法告诉我们为什么它会做出某些决定。

学习技巧的可解释性

现代人工智能算法的密度令人难以置信。你可以有数百层，一个新的基准世界纪录，甚至可以将其应用于医疗领域——像 IBM Watson 这样的产品已经在这些任务上做得很好了。但是它需要能够解释它的决策，特别是对于任务/安全关键的应用，如国防和航空航天。神经网络擅长给我们准确的结果，但它们在连贯的答案和解释方面失败了。

想象一下，你有一个这样的神经网络，可以用来识别不同品种的狗。让我们给它看一只拉布拉多。一个训练有素的神经网络会发出“嘿，那是一只拉布拉多！”这很好，但如果你问它为什么认为它是拉布拉多犬，它会说“它看起来像我以前见过的东西，所以我认为它是拉布拉多犬！”。网络的解读没有任何智能或科学的尝试。在理想的情况下，它会说“嗯，它是金色的，看起来像一只中等大小的狗，而且看起来很友好。很像以前见过的很多拉布拉多犬“”。这是一个基本的例子，但这种程度的解释将允许开发人员甚至用户完全理解算法的训练数据和计算架构的缺陷。

想象一下，如果我们给同一个网络看一张田里一些草的照片，神经网络会说“是的，那是另一只拉布拉多犬】，这很难理解为什么。草是绿色的。如果网络声称桑德看起来像一只拉布拉多犬，我能明白为什么，因为它们至少是同样的颜色。添加推理和解释的元素将向开发人员显示网络正在看到什么，然后可以对架构甚至输入数据和训练参数进行清楚的调整，以便在将来减轻这个问题。给这个场景添加一个解释元素可能意味着开发人员回到训练数据，并看到为训练提供的所有拉布拉多图片都在一个大的绿色区域中，因此猜测拉布拉多-所以下一步将通过噪声添加一些数据变化，或者甚至在不同位置(如人行道上或水中)找到更多拉布拉多图片。

谈论拉布拉多似乎很琐碎，但它突出了一个相当重要的问题。虽然对于大多数应用来说，能够指向某样东西并对其进行分类是很好的，但对于安全关键系统来说，这还不够。安全关键系统不能失败，而且必须可以解释——这是神经网络所不能解释的。像无人驾驶汽车这样的产品正日益成为现实，我们需要一种车辆来解释为什么它会做出决策，尤其是在发生事故的情况下。能够解释和诠释使得法律能够解决争端并找到那些对这些系统问题负责的人——管理自治系统的法律几乎没有得到发展，这都是由于未来产品的不可预测和不可解释的性质。

我们不能让这些类型的产品负责我们的道路、军队以及我们和我们家人的工作生活，直到它们能够学会提供解释，以便我们能够找到那些对所做决定负责的人。

我是一名健身运动员&软件工程师，对健美和机器学习充满热情。我经营着自己的博客和网站，在那里我讨论这些话题，甚至更多。我提供了我的 Github 资源库的链接，这样你就可以看到我正在进行的项目和社交媒体账户(脸书、Instagram、Twitter 等)。)所以你可以跟着我健身改造。

http://lukealexanderjames.com/

如果你喜欢你所读的，请考虑按住鼓掌按钮一会儿！

人工智能学习金拉米，第二部分(输入 Google TensorFlow)

原文：https://towardsdatascience.com/ai-learning-gin-rummy-part-ii-enter-google-tensorflow-7338ef93f2ed?source=collection_archive---------1-----------------------

上一篇描述的手造策略可以用它的手评估函数来表示:

E = Wh

其中 E 是代表手牌评价(或你手中牌的相对值……值越高越想保留)的 1×52 矩阵， W 是应用于手牌的权重的 52×52 矩阵， h 是代表手牌的 1×52 矩阵。我们如何从上一篇文章中描述的代表手的 4 x 13 矩阵发展到这里的 1 x 52 矩阵？我刚刚展*了 4 x 13 的矩阵。 W 然后，表示该副牌中的每张牌与该副牌中其他每张牌的关系。

您可能会注意到，这与之前描述的卷积矩阵不同，后者只是考虑了水*和垂直相邻的 2-3 个单元。然而，一个 52×52 的矩阵可以计算出与应用于手中每张牌的卷积矩阵相同的函数。

那么我如何从之前的 7 x 7 卷积矩阵:

一个 52 x 52 的矩阵来计算同样的函数？手工做起来并不难，但是输入 w 的所有 2704 个值会很无聊，而且计算机科学家很懒。用机器学习帮我搞清楚不是更好吗？为什么不用谷歌投入 TensorFlow 的数百万美元研发资金在这里工作呢？

谷歌张量流

谷歌的机器学习开源库有方便的 Python 库，以及一些非常漂亮的介绍文档，包括一个非常有用的注释系统，实现了监督学习手写数字 MNIST 数据集的线性模型，这是一个研究机器学习计算机视觉的热门领域。

我使用 TensorFlow 的目标非常简单:计算出一个 52 x 52 的矩阵，它与我在 gin rummy hand evaluator 上计算的 7 x 7 卷积矩阵具有相同的功能。所以有几件事可以让 TensorFlow 继续下去:

1. 设置培训数据
2. 建立输入、输出和参数
3. 建立模型
4. 指定要优化的损失函数

金拉米培训数据

我使用的训练数据是 1)玩家的手牌(4 x 13 矩阵)和 2)结果手牌评估(也是 4 x 13 矩阵)的配对。在我手工构建的系统中，这是使用上面的卷积矩阵计算的。为了生成这些训练数据，我让 gin rummy 程序自己玩了几千场游戏，每次它评估一手牌时，它都会保存手牌/手牌评估对。例如，假设我们有一手牌:

并且手工构建的系统生成以下手工评估:

因此，训练数据总计有几千对，就像这两个一样，只是它们不是像上面那样的 4 x 13 矩阵(更容易阅读)，而是扁*的 1 x 52 矩阵。

张量流的输入、输出和参数

告诉 TensorFlow 哪个是输入(手牌)哪个是输出(手牌评估或牌组值)的代码很容易指定:

# Model input and output
h = tf.placeholder(tf.float32, [None, 52], name="hand")       # h = hand
d = tf.placeholder(tf.float32, [None, 52], name="deck_value") # d = deck value

这里的参数是 W，52 x 52 矩阵，它的种子是随机值:

# Model parameter
W = tf.Variable(tf.random_normal([52, 52], stddev=0.35), name="weights")

模型

我为这个小练习选择的模型是一个简单的线性模型，E = Wh。TensorFlow 的便利之处在于能够使用声明性方法来设置神经网络，而不是必须对它们进行功能性编程。

# Model
linear_model = tf.matmul(h, W) 

损失和优化器

损失函数是一个标量，当它的机器学习算法应用优化器来引导它找到解决方案时，它测量参数的试验版本 W 之间的差异。损失测量是*方和。优化器是梯度下降，许多机器学习应用程序中使用的标准优化器。你需要为梯度下降提供一个增量/减量参数，在找到一个可以收敛到这个解的解之前，我不得不做一些实验。

# Loss
loss = tf.reduce_sum(tf.square(linear_model - d)) # Optimizer
optimizer = tf.train.GradientDescentOptimizer(0.0001)  
train = optimizer.minimize(loss) 

矩阵学习结果

那么 W ，得到的 52×52 矩阵是什么样子的呢？用色标显示矩阵，深绿色代表较高的数字:

很高兴我不用把这些都输入进去。

下一站:更有趣的机器学习

TensorFlow 的这个用法非常简单，是如何使用它的一个很好的例子。然而，它本身并没有解决一个有趣的问题，它只是给作为程序员的我提供了一个便利。更有趣的是发现一种比我亲手制作的金拉米游戏玩得更好的算法。这种新算法会考虑更多的游戏信息。它如何学习？它必须和自己玩很多很多的游戏…

人工智能:像人类一样学习。

原文：https://towardsdatascience.com/ai-learning-to-learn-as-humans-do-ecaec5e310c0?source=collection_archive---------11-----------------------

深度学习通过将计算机视觉、语音识别、机器翻译和自动车辆导航带到高于人类水*的性能，开启了人工智能革命。现在深度学习在 AI 中占主导地位。

监督学习(在深度学习中)是迄今为止人工智能所有工业成功的原因。它有一些明显的缺陷，限制了它的可伸缩性。根据 Yoshua Bengio 的说法，它学习那些在训练环境之外不能很好概括的表面线索。它仍然无法在多个时间尺度上很好地学习高级抽象。它仍然严重依赖于*滑可微的预测器。

现在，人工智能社区正在研究下一代技术，这种技术将使系统能够以迄今为止只有人类才能展示的方式理解世界并做出反应。无监督学习、实时学习、强大的预测模型、多时间尺度、一次性学习是需要突破的领域，以便使新一代成为现实。

神经科学一直是基于机器学习的人工神经网络的灵感和模型的来源。现在是时候加强前沿深度学习和前沿神经科学之间的联系了，因为前沿神经科学正在深入挖掘答案，前沿机器学习需要开发下一代像思维机器一样的人类。这里只有几个样品。

时间压缩的未来预播放——通过只闪现图案的起点来触发视觉图案的完成——发生在我们的大脑中。

“感知是由对未来事件的预期引导的。有人假设，这一过程可能是通过早期视觉皮层的模式完成来实现的，在这种情况下，只有一部分视觉输入被提供后，刺激序列才会被重新创建。”荷兰内梅亨大学唐德斯大脑、认知和行为研究所的研究人员已经用他们的实验证明了这个假设是正确的。" 我们发现，只闪烁一个移动点序列的起点，会在初级视觉皮层(V1)中触发一个活动波，从而重建完整的刺激序列。与实际刺激序列相比，这种预期活动波在时间上被压缩，即使注意力从刺激序列转移时也存在。该预播放活动可以反映视觉序列 的自动预测机制他们在《自然》杂志最*的文章中写道。

当我们对一个被观察的人感同身受时，视觉空间精神传送到另一个人的身体发生在大脑中。

“空间隐喻经常被用来描述移情(即设身处地地为他人着想)，但很少有人研究移情和视觉空间能力之间的经验关系。有趣的是，似乎有与这两种功能相关的共享脑区；顶叶区域长期以来一直与视觉空间处理有关，最*研究移情反应的神经相关性的神经成像工作也注意到了顶叶网络的招募。范德比尔特大学的研究人员发现我们的大脑让我们真切地感受到处于另一个人的位置。他们称这种自我-他人的转变为“具身视角”。’

人脑实时自动检测模式。

耶鲁大学科学家的研究“证实了这样一个结论:视觉统计学习是自动的，也不是自动的:它需要注意力来选择相关的刺激群体，但由此产生的学习是在没有意图或意识的情况下发生的。

人类婴儿的大脑隐含地识别熟悉的模式，并对不可预测性做出反应。

来自伦敦伯克贝克大学的一组科学家报告:“我们让 2 个月、5 个月和 8 个月大的婴儿习惯于离散的视觉刺激序列，其顺序遵循统计上可预测的模式。

大脑的处理能力随着不可预测性而增强。

卑尔根大学一个团队的研究结果揭示了:“ 当预测基于统计学习时，与预测不匹配的事件会诱发早期的前向负波，这种不匹配反应的幅度与这种事件的概率成反比 。因此，我们报告了一种统计不匹配负波(sMMN ),它反映了超越听觉感觉记忆能力的过渡概率分布的统计学习

一次性学习是由响应不确定性的处理能力增加触发的。

来自加州理工学院的一组科学家的一项研究证实了一个计算假设，即“ 刺激和结果之间因果关系的不确定性导致学习速度的快速变化，这反过来又介导了增量学习和一次性学习 之间的过渡。”

AI market place 不是你要找的(电信行业)。

原文：https://towardsdatascience.com/ai-market-place-is-not-what-you-are-looking-for-in-the-telecommunication-industry-c1308d3ab379?source=collection_archive---------3-----------------------

在一个遥远的地方有一个卡达那王国。卡达那是一个幅员辽阔、居民稀少的国家。事实上，在夏天最热的日子里，温度很少超过零下 273 摄氏度，这可能是一个原因。大地很冷，但人们很温暖。

在 Kadana 有 3 家主要的电信运营商:B311、Steven's 和 Telkad。还有 3 个地区性的:诺斯林克、索思林克和三极管。许多邻*的王国也有电信运营商，有些比卡达那的大得多。Dollartel，Southtel，Purpletel，我们都是大玩家，在那种环境下竞争的更多。

这是一个激动人心的时刻。一种叫做人工智能的新技术在其他领域开始流行，电信运营商也想从中受益。在深入我们的故事之前，了解一点这种人工智能技术是怎么回事可能会很有意思。不涉及太多的细节，我们只说传统上如果你想让一台计算机为你做一些事情，你必须给他一个由软件开发者充满激情手工制作的程序。人工智能的承诺是，从现在开始，你可以向计算机输入大量关于你想做什么的数据，它会计算出具体的条件，并提供适当的输出，而无需(大量)编程。对于那些了解人工智能的人来说，这看起来像是对该技术过于简单化(如果不是完全错误的话)的总结，但让我们暂时保持这种方式…

回到电信世界，一些有好主意的人决定创造 Akut05。Akut05 是一个结合了市场理念和人工智能技术的新产品。酷！苹果应用商店(Apple App Store)或谷歌游戏(Google Play)所展示的市场优势，以及人工智能的力量。

这太有趣了，我也想参加那个派对，我立即创建了我的公司，TheLoneNut.ai。所以现在我需要创建一个不错的人工智能模型，我可以在 Akut05 marketplace *台上出售。

好吧，让我们不要这么快…你看，人工智能模型是根据我之前说过的数据建立的。我将使用哪些数据？这对 LoneNut.ai 公司来说只是一个小障碍……我们走出去，与运营商交谈。没人知道 TheLoneNut.ai，是个新公司，先从本地运营商说起吧。B311、Steven's 和 Telkad 都认为我们的规模太小，不允许我们访问他们的数据。毕竟，他们的数据是一个他们应该从中受益的宝库，为什么他们会给我们访问它。然后我们去找较小的地区性公司，Northlink 也有一些兴趣。他们规模小，无法大规模投资于数据科学团队来构建良好的模型，因此，通过适当的 NDA，他们同意让我们访问他们的数据，他们将获得大量回扣，在 Akut05 上访问我们的模型。

很好！我们需要从某个地方开始。我将跳过获取数据、准备数据和构建模型过程中的所有冒险…但让我告诉你那充满了冒险。我们在 Akut05 商店中部署了一个不错的模型，它运行得非常好……有一段时间了。过了一段时间，Northlink 的用户改变了一点他们的行为，Northlink 发现我们的模型不再正确响应。他们怎么算出来的？我不知道，因为除了常规的“云”监控方法，Akut05 没有提供任何真正的模型监控功能。更令人担忧的是，我们看到 B311、Steven's 和 Telkad 的一星评价蜂拥而至，他们尝试了我们的模型，并从 get go poor 结果中获益。我们对此无能为力，因为毕竟我们从未与那些大公司达成协议来访问他们的数据。几个星期后，在将该模型打折出售给 Northlink 后，除了所有其他运营商的负面报道，TheLoneNut.ai 破产了，我们再也没有听到它的消息。同样的事情也发生在许多其他尝试过的小模型开发者身上，很快 Akut05 商店就没有任何有价值的模型了。

因此，与应用商店相反，模型商店通常不是一个好主意。为了得到一个正确的模型(假设你可以)，你需要数据。这些数据需要来自你希望模型应用到的有代表性的例子。但这很容易，我们只需要所有的运营商同意共享数据！好吧，如果你不觉得讽刺，那祝你好运。但这是一个很好的故事，让我们抛开讽刺。我们故事中的所有操作者都决定向 Akut05 *台上的任何模型开发人员提供他们的数据。还有什么可能出错。

让我们考虑一个使用用户每月支付给运营商的费用的模型。在 Kadana 中，这个数量在数据池中以\(KAD 的形式提供，它适用于所有 Kadanian 操作者。多拉特尔尝试了一下，结果(并不)令人惊讶地悲惨失败。你看，在 Dollartel 的市场上，使用的货币不是\)KAD，而是一些其他货币……模型构建者，即使他有来自 Dollartel 的数据，也可能需要做“本地”调整。如果市场很小而且不完整，也就是说需要特别小心，那么一个模型还能给模型制作者带来丰厚的利润吗？否则你会得到一星评价，过一会儿又会消失。

好吧，所以 Akut05 对于独立的模型构建者来说不是一个好主意。也许 Purpletel 仍然可以使用它，purple tel 是一家大型电信运营商，可以雇佣大量的数据科学家。但在这种情况下，如果是他们的数据科学家来做这项工作，他们为什么要分享他们的数据呢？如果他们不分享自己的数据，不雇佣自己的数据科学家，为什么他们首先需要一个市场呢？

独立的模型建造者不能从模型市场中找到他们的价值，运营商也不能…电信制造商能在那里赚钱吗？为什么它比一个独立的模型建造者更有价值呢？也许它可以更容易地访问数据，但特权基本上是一样的，我敢打赌这也不会是一个胜利的市场。

好吧，因此人工智能的市场不是你正在寻找的……在下一篇文章中，我会试着说一点关于当涉及到人工智能时，你应该在电信部门寻找什么。

当然，这个故事把这个问题过于简单化了，但是，我认为我们可以抓住要点。你有不同的看法？请在下面的评论中分享它，这样我们都可以从一次愉快的讨论中学习！

原载于 2018 年 4 月 30 日【thelonenutblog.wordpress.com】。

封面照片由 Ed Gregory 在Pexels拍摄。

宣布 AI/ML 的实用性

原文：https://towardsdatascience.com/ai-ml-practicalities-bca0a47013c9?source=collection_archive---------23-----------------------

AI/ML 实用性

机器学习利益相关者的有用见解

Photo by Fleur Treurniet on Unsplash

本系列文章:

数据的不合理有效性

实验周期

数据越多并不总是越好

如果“多维”伤脑

有充分的理由，许多商业人士对机器学习(ML)既敬畏又怀疑。ML 已经取得了非常明显的成功:无人驾驶汽车，手写识别使我们几乎所有的邮件都能自动发送，机器翻译接*人类专家的水*并超过人类的速度。与此同时，无数的新闻报道承诺革命、癌症的终结、每项工作的自动化以及人类的替代，这让我们不禁好奇天网何时上线。

在我称为“AI/ML 实用性”的这一系列文章中，我将试图向非从业者揭示机器学习中涉及的一些现实和挑战，以及数据科学家用来解决这些问题的技术。我希望这些微小的见解能让非技术人员，或者至少是非 ML 技术人员，更好地评估声明和产品，消费 ML 服务，并与 ML 技术人员合作。

机器学习和数据科学生活在统计学、编程和商业的交叉点上。许多“新”概念，如特征工程和维数灾难，实际上继承了这些学科中的一个，但对于来自其他学科的人来说是新的材料。一些概念，例如集成方法，是机器学习所特有的。(特征工程、维数灾难和集成方法都是本系列将涉及的主题。)

作为一名程序员来到这个领域，我最大的惊讶与 ML 的经验主义性质有关。编程是一种确定性的活动。一旦你知道你想让计算机如何运行，实现该行为的“正确”路径就很少了，大多数变化都是由于最佳实践的应用。ML 反映了科学研究。你有一个半确定的目标。你的目标和实现目标的途径都是假设，必须经过测试、提炼和再测试。本系列中的一些文章将专门讨论这个过程。

对于经理、客户或机器学习项目的其他发起人来说，ML 的潜力似乎太好了，不容忽视。但是，让合作伙伴开发模型、信任这些模型以及管理它们的生命周期的风险是令人生畏的。

希望这个系列能让 ML 变得更加透明。

实验的循环

原文：https://towardsdatascience.com/ai-ml-practicalities-the-cycle-of-experimentation-fd46fc1f3835?source=collection_archive---------16-----------------------

AI/ML 实用性

作为一名软件开发背景的人，机器学习真正让我吃惊的一件事是它是多么的经验性。

本文是 AI/ML 实用性 系列的一部分。

虽然机器学习项目可能乍一看很像软件开发项目，但它们的路径和结构更像科学调查。成功的项目由一系列实验组成，这些实验可能会有结果，也可能没有结果，或者激发出完全不同的研究过程，但最终都会带来有用的见解。此外，每个实验中都有一系列微型实验。

如果你计划和 ML 一起工作或者雇佣其他人来为你建立 ML 模型，了解从业者如何工作是值得的。

软件开发项目

相比之下，一个软件开发项目从这样一个问题开始，“我们如何构建 X？”建成后就结束了。在这个过程中，团队通常不得不改进 X 的定义，因为它是模糊和不完整的。但是，在成功的项目中，需求、设计和开发最终会汇聚到一些明显类似于需求的东西上。

快乐软件项目的进展是渐进的，并遵循一条非预定的路径，但它是有意识地向前推进的。这就是敏捷燃尽图受欢迎的原因。他们沿着基线路径跟踪预期不确定性的影响。

机器学习项目

ML 模型开发(以及一般的数据科学)更有可能从这个问题开始，“我们能构建什么？”并在达到三种结果之一时停止:

1. 已经发现了足够好的结果来发布或使用
2. 制约因素(财政、时间、计算能力)限制了进一步的发展
3. 努力被改变方向或完全放弃

而且，如果数据不支持，即使是具体的目标也必须让步。

机器学习模型是如何开发的

数据分析的目标是创建一个(或多个)模型，告诉我们一些关于数据的深刻见解。最典型的情况是，这意味着接受新的输入，放弃预测。

机器学习通过告诉计算机分析一些数据并自我训练来实现这一点。更具体地说，我们将训练数据输入到学习算法中，该算法产生一个模型，该模型经过训练可以告诉我们与训练集相似的数据的有趣事情。

构建 ML 模型的数据科学工作可以大致分为三个阶段:

1. 探索性数据分析—分析数据以确定如何使用数据
2. 选择和配置学习算法，准备和操作数据(也称为“特征工程”)，以及运行训练算法
3. 评估，也许，部署结果

这个过程多次到达提议的部署阶段。在早期，评估发现了进一步探索和改进的机会。但是，即使在一个模型成功推出后，也将不断评估新数据的性能，并确定探索和改进的途径。

这个“过程”实际上是一个循环。迄今为止，它产生的训练模型实际上是一系列反映最佳假设的训练模型。

让我们来看看阶段。

探索性数据分析

没有比数据分析更能说明细节决定成败的了。

在从数据集中提取任何见解之前，必须理解数据并将其与对其所代表的领域的理解联系起来。

从技术角度理解数据包括生成汇总统计数据、使用各种可视化策略来查看值之间的关系、制定关于数据的假设以及手动测试它们。

这种技术上的理解使分析师能够思考数据可能揭示的领域。专注于领域的探索寻找与理解业务活动相关的关系和信息。例如，如果建立一个消费者信用模型，分析师可能会钻取代表借款人偿还贷款能力的输入，并查看它们如何与支付历史以及彼此之间相关联。

数据集总是有需要解决的问题，有时需要创造性地解决。值可能会丢失、重复或看起来不正确。要批判性地思考数据，我们至少需要形成一个可以分析的形状。通常，没有单一的正确方法来解决这些问题。例如，如果消费者信用数据库缺少大量申请人的年收入或 FICO 评分，我们该怎么办？从分析中排除 FICO 和收入？假设*均值？

EDA 是一个开放式的过程。每一次进步都带来新的曙光和新的问题。修复数据问题会导致对该数据的重新分析。与业务理解的某些元素不一致的可视化提出了要问的问题，并运行实验来回答这些问题，等等。

这个过程不是自然结束，而是继续下去，直到向前发展并训练一个模型似乎比继续分析更有成效。未决问题被推迟。

特征工程和模型训练

一旦选择了训练一个模型，并且目标明确，仍然有许多工作要做。

有许多类型的模型和训练算法可供选择。而且，大多数都是高度可配置的。例如，神经网络可以被配置成复杂程度不同的数量级。从业者知道哪些模型可能在特定问题上表现良好。但是，任何选择都是最佳猜测；一个有待验证的假设。并且，模型配置通常在一系列训练尝试中被修改多次。有时模型会被完全不同的模型所取代，甚至是扩充。

无论选择哪种模型和配置，都必须相应地准备数据，并将其处理成能使培训有效的形式。

首先，每一个输入都必须转换成某种数量。日期通常变成天数(或小时数，或分钟数，等等。)从某个时间点开始。分类值，如婚姻状况或出生城市，通常被简化为一大组标志，如已婚、单身、离婚、出生在辛辛那提、出生在巴黎等。

其次，数据必须以一种便于算法提取重要信息的方式提供。例如，如果城市的纬度和繁荣程度是进行预测的关键因素，用唯一的数字表示城市可能不够好。在准备训练时，城市甚至可以从数据集中移除，并替换为例如城市纬度和城市人均收入。

操纵数据为训练做准备被称为特性工程，这将是本系列另一篇文章的主题。简而言之，这是一种转换数据的黑暗艺术，以便其重要方面可以被训练算法消化和突出。特征工程通常被认为是机器学习周期中最关键和最耗时的部分。

对于准备训练所涉及的所有工作，模型的实际训练相对简单，因为这是计算机接管并完成其工作的时候。有几个方面使这一过程变得复杂:

1. 与目标模型一样，训练算法也有配置选项，称为“超参数”。对于某些算法和模型，调整超参数可能需要大量的工作。
2. 许多模型都是计算密集型的，并且许多数据集都很大。并行和优化培训是额外的工作，不容易。

既然我们已经将所有的部分放在一起，你可能会想为什么特征工程与模型训练而不是探索性的数据分析放在一起，它实际上是从那里开始的。EDA 依赖于许多相同的数据转换和操作。认为特征工程与模型训练密切相关有两个重要原因。

1. 一些特征工程是特定于模型的。每个模型都需要或受益于其他模型不需要的转换。
2. 模型训练和特征工程形成一个迭代循环。每次模型训练的尝试都会(希望)产生改进性能的想法。有时，改进来自于模型或训练算法配置的改变。但通常，结果会建议进一步的特征工程，即添加、移除或转换输入。

评估和部署

将任何软件部署到生产环境都是一个关键的过程。但是，对于训练一个模型所涉及的所有工作和特殊挑战，部署一个 ML 模型实际上很像一个典型的软件开发项目。

最终，模型是数据泵，就像大部分手工编码的过程。尽管有些可能很大而且难以操作，但大多数 ML 模型在生产中不会带来特殊的资源挑战。这是因为经过训练的模型通常比训练它们的算法运行速度快几个数量级。(这应该不会太意外。40 和 7 相乘需要多长时间？你花了多长时间学会乘法？)

虽然模型部署可能存在逻辑上的挑战，但这些挑战往往类似于典型软件部署的挑战。机器学习模型更独特的是它们需要的维护水*和类型。

大多数模型是根据历史数据训练的，但是生活在一个不断产生新数据的世界中。可能与原始数据集不同的数据，表明模型可以改进或者建模的关系已经改变。例如，用于预测借款人还款表现的模型非常好，但开始下滑。

从根本上来说，这意味着模型必须不断地被评估，并且很可能被更新。因此，与其说部署是流程的终点，不如说它实际上是不断评估和改进的第三个周期的一部分。(关于这个话题有很多要说的，我会留到另一篇文章中去说。)

把所有的放在一起

我们从 ML 过程的一个天真的观点开始这篇文章:获得一些数据，运行一个训练算法，产生一个模型。任何过程的简单描述背后总是隐藏着细节，但在某种意义上，最初的描述是正确的。数据被输入产生模型的算法，然后该算法独立进行预测。

但是从某种意义上来说，这个流程图是有误导性的:机器学习开发是一个循环，而不是一个过程。其实就是周而复始的循环。这不仅仅是因为从业者发现小增量工作是有效的。这是因为 ML 开发本质上是一种经验性的活动，每个实验步骤的反馈对下一步都是至关重要的。

数据的不合理有效性

原文：https://towardsdatascience.com/ai-ml-practicalities-the-unreasonable-effectiveness-of-data-c0bfd44c5057?source=collection_archive---------20-----------------------

AI/ML 实用性

数据量通常比模型选择更重要

本文是 AI/ML 实用性 系列的一部分。

2006 年，美国国家科学技术研究所(NIST)举办了第五届年度机器翻译大赛。

以前的获奖者都是基于知识的系统，明确地编程来解释文档的语法和词汇，并使用对语言的类似明确理解将其转换为目标语言。

然而，那一年，谷歌凭借一个仅使用翻译文档库的自动统计分析结果将阿拉伯语和中文新闻文档翻译成英语的程序，在竞争中占据了主导地位。在 40 个竞争对手中，谷歌在 36 个类别中的 35 个类别中占据或并列第一。然而，他们的翻译程序不包含明确的语法规则或字典。事实上，开发这个程序的团队中没有人会说阿拉伯语或汉语。

这是机器学习(ML)的一个典型例子:用数据训练而不是显式编程的软件。尽管大肆宣传，但它也是 ML 强大力量的一个很好的例子，我们现在已经看到它在翻译、图像处理、搜索引擎和许多其他领域一次又一次地成功。

数据丰富的时代

一个很好的问题是:是什么样的技术进步让我们取得了这样的成果？

虽然几乎每一项技术进步都有一些解释:更快的计算机、更便宜的存储和理论进步，但 AI/ML 的一个具体驱动因素是数据可用性的大幅增加。在过去的 30 年里，我们比以往任何时候都更快地编目和创建数据。一个影响是显而易见的:关于事物的数据越多，可以分析的东西就越多。但是，数据的增长也产生了更深刻、更微妙的影响，这就是所谓的“数据的不合理有效性”。

肌肉还是大脑？

为了理解这种影响，请考虑微软在 2001 年做的一个实验。研究人员进行了一项并行测试，以评估 4 种不同的 ML 翻译方法的优点。他们用相同的输入数据从头开始训练每个模型，用从 10 万到 10 亿字的不同数据集规模进行了一系列试验。

资料来源:Banko，m .和 Brill，E. (2001)，“扩展到非常非常大的自然语言消歧语料库”

如上图所示，他们发现用于训练模型的数据集的大小远比 ML 方法的选择更重要。而且，随着数据集变大，模型之间的性能差异变得非常小。

事实上，这就是谷歌在 2006 年赢得自动翻译竞赛的原因。他们比任何人都更容易获得正确的阿拉伯语到英语和汉语到英语的翻译(即训练数据)，因为谷歌刚刚花了 8 年时间对互联网进行编目。

从实践的角度来看，关键的经验是，更多的数据几乎总是更好，而且“更多”可以用数量级来衡量。遗憾的是，我们并不总是能够选择需要处理多少数据。但是，我们总是需要考虑数据集的大小。而且，正如我将在以后的文章中提到的，通常有一些巧妙的技巧和权衡来改善这种情况。

仅供技术人员使用，因为微软的术语已经过时:

• “基于记忆”的学习(又名“基于实例”的学习)记住所有的数据点，并根据最接*的数据点进行预测。本质上，它假设目标函数是局部常数。k-最*邻就是一个例子。
• “Winnow”是感知器的早期替代公式，但没有非线性激活，只有二进制输入。这个名字来源于它能够快速消除(剔除)无用的输入，这对于计算能力有限的大型功能集非常有用。
• 感知器和朴素贝叶斯应该很熟悉。

人工智能规划历史发展

原文：https://towardsdatascience.com/ai-planning-historical-developments-edcd9f24c991?source=collection_archive---------4-----------------------

Photo by Possessed Photography on Unsplash

在这篇文章中，我将考察人工智能规划研究领域的三大进展。对于每个开发，我将提供原始论文的简短摘要以及适当的例子来演示几个用例。我将首先描述一个通用的框架，STRIPS，在这个框架下所有的规划问题都可以被公式化。然后，我将研究在 STRIPS 公式下工作的两种最先进的算法。GraphPlan 算法不是从一开始就贪婪地搜索解决方案，而是构造一个可用于获得解决方案的规划图对象。规划图对象还可以用于对 STRIPS 框架中指定的任何规划问题进行自动化启发式搜索。最后，我将研究一种算法，它使用启发式搜索规划器来自动产生有效的启发式搜索。最终算法获得了 1998 年 AIPS98 规划竞赛的冠军。

发展 1:条(1971 年)

1971 年，斯坦福研究所的 Richard Fikes 和 Nils Nilsson 开发了一种在问题解决中应用定理证明的新方法[1]。该模型试图在世界模型空间中找到一系列操作符，以将初始世界模型转换成目标状态存在于其中的模型。它试图将世界建模为一组一阶谓词公式，旨在处理由大量公式组成的模型。

在 STRIPS 公式中，我们假设存在一组将世界模型转换成其他世界模型的适用算子。问题求解器的任务是找到一系列操作符，将给定的初始问题转化为满足目标条件的问题。运算符是构建解决方案的基本元素。每个操作符对应一个动作例程，例程的执行会导致代理采取某些动作。在 STRIPS 中，定理证明和搜索的过程通过世界模型的空间分离。

从形式上讲，条带的问题空间是由初始世界模型、一组可用操作符及其对世界模型的影响以及目标陈述来定义的。可用的操作符被分组到称为模式的系列中。每个操作符由两个主要部分组成的描述定义:操作符具有的效果和操作符适用的条件。据说当 STRIPS 生成一个满足目标声明的世界模型时，问题就解决了。

现在让我们考虑一个使用计划搜索代理将 STRIPS 语言应用于航空货物运输系统的例子。假设我们有一个初始状态，货物 1 在 SFO，货物 2 在 JFK，飞机 1 在 SFO，飞机 2 在 JFK。现在，假设我们想要制定一个最优计划，将货物 1 运输到 JFK，将货物 2 运输到 SFO。总结这个问题描述，我们有:

Init(At(C1, SFO) ∧ At(C2, JFK) ∧ At(P1, SFO) ∧ At(P2, JFK) ∧ Cargo(C1) ∧ Cargo(C2) ∧ Plane(P1) ∧ Plane(P2) ∧ Airport(JFK) ∧ Airport(SFO)) Goal(At(C1, JFK) ∧ At(C2, SFO))

我们可以编写一个函数，将这个公式正式定义如下:

def air_cargo_p1() -> AirCargoProblem:
    cargos = ['C1', 'C2']
    planes = ['P1', 'P2']
    airports = ['JFK', 'SFO']
    pos = [expr('At(C1, SFO)'),
           expr('At(C2, JFK)'),
           expr('At(P1, SFO)'),
           expr('At(P2, JFK)'),
           ]
    neg = [expr('At(C2, SFO)'),
           expr('In(C2, P1)'),
           expr('In(C2, P2)'),
           expr('At(C1, JFK)'),
           expr('In(C1, P1)'),
           expr('In(C1, P2)'),
           expr('At(P1, JFK)'),
           expr('At(P2, SFO)'),
           ]
    init = FluentState(pos, neg)
    goal = [expr('At(C1, JFK)'),
            expr('At(C2, SFO)'),
            ]
    return AirCargoProblem(cargos, planes, airports, init, goal)

AirCargoProblem 类将按如下方式初始化:

class AirCargoProblem(Problem):
    def __init__(self, cargos, planes, airports, initial: FluentState, goal: list):
        """:param cargos: list of str
            cargos in the problem
        :param planes: list of str
            planes in the problem
        :param airports: list of str
            airports in the problem
        :param initial: FluentState object
            positive and negative literal fluents (as expr) describing initial state
        :param goal: list of expr
            literal fluents required for goal test
        """
        self.state_map = initial.pos + initial.neg
        self.initial_state_TF = encode_state(initial, self.state_map)
        Problem.__init__(self, self.initial_state_TF, goal=goal)
        self.cargos = cargos
        self.planes = planes
        self.airports = airports
        self.actions_list = self.get_actions()

我们使用 get_actions 方法来实例化所有可以作用于状态的 action/operator 对象的列表。在这个空运货物问题上，我们可以采取三种行动:装货、卸货和飞行。get_actions 类方法收集了所有这些可能的操作。

为了定义可以作用于某个状态的操作符，我们可以定义 actions 类方法如下:

def actions(self, state: str) -> list:
 """ Return the actions that can be executed in the given state.:param state: str
 state represented as T/F string of mapped fluents (state variables)
            e.g. 'FTTTFF'
        :return: list of Action objects
        """
        # TODO implement
        possible_actions = []
        kb = PropKB()
        kb.tell(decode_state(state, self.state_map).pos_sentence())
        for action in self.actions_list:
              is_possible = True
              for clause in action.precond_pos:
                if clause not in kb.clauses:
                    is_possible = False
              for clause in action.precond_neg:
                if clause in kb.clauses:
                    is_possible = False            
              if is_possible:
                possible_actions.append(action)

        return possible_actions

动作方法通过检查动作的前提条件是否在由输入状态指定的子句集中，有效地输出可能动作的列表。我们还需要定义一个方法来将一个动作应用到一个给定的状态。在状态 s 中执行动作 a 的结果被定义为状态s’，其由从 s 开始形成的一组流来表示，移除在动作效果中表现为负文字的流，并添加在动作效果中为正文字的流。

def result(self, state: str, action: Action):
        """ Return the state that results from executing the given
        action in the given state. The action must be one of
        self.actions(state).:param state: state entering node
        :param action: Action applied
        :return: resulting state after action
        """
        # TODO implement
        new_state = FluentState([], [])
        old_state = decode_state(state, self.state_map)

        for fluent in old_state.pos:
            if fluent not in action.effect_rem:
                new_state.pos.append(fluent) # add positive fluents which are in the old state and should not be removed

        for fluent in action.effect_add:
            if fluent not in new_state.pos:
                new_state.pos.append(fluent) # add positive fluents which should be added and have not already been added

        for fluent in old_state.neg:
            if fluent not in action.effect_add:
                new_state.neg.append(fluent) # add negative fluents which are in the old state and should not be added

        for fluent in action.effect_rem:
            if fluent not in new_state.neg:
                new_state.neg.append(fluent) # add negative fluents which should be removed but have not already been removed from the negative state

        return encode_state(new_state, self.state_map)

最后，我们需要定义目标测试方法，该方法提供一个布尔值来指示目标状态是否得到满足。

def goal_test(self, state: str) -> bool:
        """ Test the state to see if goal is reached:param state: str representing state
        :return: bool
        """
        kb = PropKB()
        kb.tell(decode_state(state, self.state_map).pos_sentence())
        for clause in self.goal:
            if clause not in kb.clauses:
                return False
        return True

这个类提供了一个 STRIPS 公式的例子。特别是，我们已经指定了初始状态、目标状态和一组指定前提条件和后置条件的动作。此计划例程的计划是一系列操作符，可以从初始状态开始执行并导向目标状态。我们可以使用级数搜索算法来形成这个示例问题的最佳计划。在这个问题上使用广度优先搜索，最佳计划将是装载(C2，P2，JFK)，装载(C1，P1，旧金山)，飞行(P2，JFK，旧金山)，卸载(C2，P2，旧金山)，飞行(P1，旧金山，肯尼迪)，卸载(C1，P1，肯尼迪)。

发展 2:规划图表(1997 年)

1997 年，卡内基梅隆大学的 Avrium Blum 和 Merrick Furst 开发了一种在条状域中进行刨削的新方法[2]。它包括构建和分析一个全新的对象，称为规划图。他们开发了一个叫做 GraphPlan 的例程，该例程使用规划图构造来获得规划问题的解决方案。

这个想法是，我们首先创建一个规划图对象，而不是贪婪地搜索。规划图是有用的，因为它固有地显式编码有用的约束，从而减少未来的搜索开销。规划图可以在多项式时间内构造，并且具有多项式大小。另一方面，状态空间搜索是指数级的，需要做更多的工作。规划图不仅基于领域信息，还基于问题的目标和初始条件以及时间的明确概念。

规划图具有与动态规划问题解决程序相似的特性。GraphPlan 算法使用规划图来指导其对计划的搜索。该算法保证找到最短的计划(类似于 BFS)。

规划图中的边表示动作和命题之间的关系。如果条带公式中存在有效的计划，则该计划必须作为计划图的子图存在。规划图的另一个基本特征是指定互斥关系。如果没有有效的计划可以同时包含两个动作，则两个动作是互斥的；如果没有有效的计划可以使两个动作同时为真，则两个状态是互斥的。排除关系在整个图中直观地传播关于问题的有用事实。

GraphPlan 算法对规划图的操作如下:从仅编码初始条件的规划图开始。在阶段 i， GraphPlan 从状态 i-1 获取规划图，并将其扩展一个时间步长，然后在扩展的规划图中搜索长度为 i 的有效规划。如果它找到一个解决方案，那么它停止，否则它继续下一个阶段。该算法找到的任何计划都是合法的计划，并且如果存在计划，它总是会找到计划。该算法还具有大多数规划者不提供的终止保证。

现在让我们构建一个基本的规划图对象，并用它来解决上面的空运货物问题。为了缩短本文的篇幅，我省略了底层的实现细节。和往常一样，代码存放在我的 GitHub 上。我们将结构初始化如下:

class PlanningGraph():
    """
    A planning graph as described in chapter 10 of the AIMA text. The planning
    graph can be used to reason about 
    """def __init__(self, problem: Problem, state: str, serial_planning=True):
        """
        :param problem: PlanningProblem (or subclass such as AirCargoProblem or HaveCakeProblem)
        :param state: str (will be in form TFTTFF... representing fluent states)
        :param serial_planning: bool (whether or not to assume that only one action can occur at a time)
        Instance variable calculated:
            fs: FluentState
                the state represented as positive and negative fluent literal lists
            all_actions: list of the PlanningProblem valid ground actions combined with calculated no-op actions
            s_levels: list of sets of PgNode_s, where each set in the list represents an S-level in the planning graph
            a_levels: list of sets of PgNode_a, where each set in the list represents an A-level in the planning graph
        """
        self.problem = problem
        self.fs = decode_state(state, problem.state_map)
        self.serial = serial_planning
        self.all_actions = self.problem.actions_list + self.noop_actions(self.problem.state_map)
        self.s_levels = []
        self.a_levels = []
        self.create_graph()

create_graph 方法如下:

def create_graph(self):
        """ build a Planning Graph as described in Russell-Norvig 3rd Ed 10.3 or 2nd Ed 11.4The S0 initial level has been implemented for you.  It has no parents and includes all of
        the literal fluents that are part of the initial state passed to the constructor.  At the start
        of a problem planning search, this will be the same as the initial state of the problem.  However,
        the planning graph can be built from any state in the Planning ProblemThis function should only be called by the class constructor.:return:
            builds the graph by filling s_levels[] and a_levels[] lists with node sets for each level
        """
        # the graph should only be built during class construction
        if (len(self.s_levels) != 0) or (len(self.a_levels) != 0):
            raise Exception(
                'Planning Graph already created; construct a new planning graph for each new state in the planning sequence')# initialize S0 to literals in initial state provided.
        leveled = False
        level = 0
        self.s_levels.append(set())  # S0 set of s_nodes - empty to start
        # for each fluent in the initial state, add the correct literal PgNode_s
        for literal in self.fs.pos:
            self.s_levels[level].add(PgNode_s(literal, True))
        for literal in self.fs.neg:
            self.s_levels[level].add(PgNode_s(literal, False))
        # no mutexes at the first level# continue to build the graph alternating A, S levels until last two S levels contain the same literals,
        # i.e. until it is "leveled"
        while not leveled:
            self.add_action_level(level)
            self.update_a_mutex(self.a_levels[level])level += 1
            self.add_literal_level(level)
            self.update_s_mutex(self.s_levels[level])if self.s_levels[level] == self.s_levels[level - 1]:
                leveled = True

互斥方法留给读者作为练习。规划图的另一个应用是启发式评估。我们可以从状态 s 估计实现任何子目标的成本，作为目标第一次出现在规划图中的级别。如果我们假设所有的子目标都是独立的，我们可以简单地将总目标成本估计为规划图中给出的子目标成本的总和。该启发式算法将在计划图类中实现，如下所示:

def h_levelsum(self) -> int:
        """The sum of the level costs of the individual goals (admissible if goals independent):return: int
        """
        level_sum = 0
        goals = [PgNode_s(g, True) for g in self.problem.goal]
        # for each goal in the problem, determine the level cost, then add them together
        for g in goals:
            if g not in self.s_levels[-1]:
                # the problem is unsolvable
                print('Unsolvable')
                level_sum = float('inf')
                break
            else:
                for level, s in enumerate(self.s_levels):
                    if g in s:
                        level_sum += level
                        break
        return level_sum

我们可以在 AirCargoProblem 类中调用此方法，如下所示:

def h_pg_levelsum(self, node: Node):
        """This heuristic uses a planning graph representation of the problem
        state space to estimate the sum of all actions that must be carried
        out from the current state in order to satisfy each individual goal
        condition.
        """
        # requires implemented PlanningGraph class
        pg = PlanningGraph(self, node.state)
        pg_levelsum = pg.h_levelsum()
        return pg_levelsum

使用这种启发式算法，我们可以使用 A算法非常有效地解决复杂的规划问题。我用几种试探法考虑了更复杂的规划问题，发现 level_sum 试探法明显优于(在时间和空间复杂性方面)所有标准搜索算法，包括带有宽松问题试探法的 A。

发展 3:启发式搜索规划(HSP) (1998)

HSP 基于启发式搜索的思想。启发式搜索提供了到目标的距离的估计。在领域独立规划中，启发法需要从行动和目标的表示中导出。推导启发式函数的一个常见方法是求解问题的一个宽松版本。主要的问题是，通常放松问题启发式计算是 NP 难的。

相反，HSP 算法估计松弛问题的最优值。该算法通过从条带编码中自动提取启发式信息，将问题转化为启发式搜索。

该算法迭代地工作，通过动作产生状态，这些动作的前提条件在前一个状态集合中[3]。每次应用一个动作时，一个度量 g 被更新，其目的是估计实现一个子目标所涉及的步骤的数量。例如，假设 p 是一个子目标。我们将 g 初始化为零，然后当应用具有前提条件的动作 C = r_1，r_2，…，r_n 时，我们更新 g 如下:

可以看出，上面解释的过程等效于计算函数:

其中 C — > P 代表断言 p 且有前提条件 C = r_1，r_2，…，r_n 的动作。那么如果我们让 G 成为目标状态的集合，最终的启发式函数将如下:

请注意，我们假设所有子目标都是独立的，这可能是启发式算法不可接受的情况:这通常在实践中效果很好。这种 HSP 方法是有用的，因为它允许我们将启发式计算推广到任何一般的 STRIPS 问题公式。

结论

本文讨论的发展构成了人工智能规划领域的三大进步。STRIPS 公式为研究人员提供了一个通用框架，从这个框架可以构建更高级的语言。规划图结构是一种革命性的数据结构，它为最优规划技术提供了一个全新的视角。最后，HSP 算法给出了一种自动的方法来确定一般规划问题的启发式算法。

这就是所有人——如果你已经做到了这一步，请在下面评论并在 LinkedIn 上加我。

我的 Github 是这里的。

参考

[1] 纸条

[2] GraphPlan 论文

[3] HSP 论文

AI 用神经网络玩沥青。

原文：https://towardsdatascience.com/ai-plays-asphalt-using-neural-network-40a58c015189?source=collection_archive---------6-----------------------

使用 Tensorflow，我制作了一个使用卷积神经网络玩沥青的人工智能。它基于行为克隆。

什么是神经网络，它是如何工作的？

简单地说，我们可以说神经网络是一个模仿人脑的计算机系统。类似于树突(神经元)，神经网络接受几个输入并给出单个输出，在我们的情况下，它从游戏中获取一帧图像，并预测是否按下 W，A 或 d。

A Neural Networks.

输入被传递给一个数学函数，该函数给出一个确定的输出。但这里的问题是，我们不知道函数内部的表达式(权重)一定是什么，这就是机器学习的闪光之处。

了解更多信息

反向传播

使用反向传播我们可以解决这个问题。最初，函数中的权重是随机的，但这是随着时间的推移而优化的。反向传播采用模型预测的输出和应该预测的实际输出，并稍微改变函数，使得预测的输出与神经网络中所需的输出相匹配。

Backpropagation

卷积神经网络

卷积神经网络(CNN)是一种特殊的神经网络，主要用于发现图像和视频中的模式。观看此视频，更好地理解这个概念。

获取训练数据

对于所有执行特定任务的神经网络模型，我们需要在一些数据中训练模型。这里所有需要的数据是图像的帧和该帧上相应的击键。数据存储在 CSV 文件中。

Training Data

图像被降低到灰度级并被裁剪以仅具有所需的信息作为训练数据。并且为了增加训练数据，图像被镜像，并且对于左和右图像数据，方向被反转。

训练网络

然后，该模型根据该数据进行训练，并使用反向传播算法随着时间的推移进行改进。最初，权重是随机的，并且来自模型的预测是相当随机的。根据我们已经提供的输出，在每次预测之后优化权重。

链接到项目

github:https://github.com/Sampanna-Sharma/Self-driving-Car

灵感

这个项目的灵感来自 Sentdex 的 python plays GTA 和 Siraj Raval 的 how to simulate self-driving car。

人工智能政策制定第 4 部分:公*和负责任的 ML 和人工智能入门

原文：https://towardsdatascience.com/ai-policy-making-part-4-a-primer-on-fair-and-responsible-ml-and-ai-28f52b32190f?source=collection_archive---------15-----------------------

偏见。歧视。不*等。不公*。不负责任。不道德。不公*。所有这些术语是如何与机器学习(ML)和人工智能(AI)联系在一起的？在这篇文章中，我将讨论对决策者和政策制定者来说至关重要的三个主题——人工智能和人工智能的公*、责任和透明度(或可解释性)。

O 你今天的生活正被算法所统治，其中大部分对我们来说是一个神秘的黑匣子。人们意识到，只有在公*和透明的情况下，自动决策(自治系统)才会被接受。许多媒体文章、书籍以及智库和书籍的研究报告提高了人们对不公*和不道德的人工智能和算法伦理的认识。

第二个问题是:我们是否在以负责任的方式使用人工智能和人工智能，这种方式以人类为中心，并将造福于所有人类？它会让少数掌握技术的强大企业和政府受益吗？人工智能会让我们的世界变得更加不*衡、不*等、更加危险吗？

第三件事是使 ML 模型足够透明，以便当事情没有按照预期发展时，我们可以找出发生了什么，并通过改进算法和允许添加人类判断来尝试修复它。

Source: [2] — [4]

人工智能和人工智能中的空气质量是一个非常活跃的研究领域，有许多相互竞争的理论。这篇文章的目的是为决策者和政策制定者介绍 ML 和 AI 中的公*性，并提供关于测量、避免和减轻偏见的有用建议。

ML 中偏差的定义:无意中的偏差或歧视，或者通过不适当的设计，或者通过在建立偏差的数据中隐含编码偏差。公*机器学习旨在确保由算法指导的决策是公*的。

这不仅仅是一种避免麻烦的方式(谷歌如何处理其产品中的性别偏见)——它将为人类带来更好的模式和更好的结果。因为这是一本入门书，所以我不会深究技术细节，而是提供对该主题进行全面论述的参考文献。

AI Now Institute 在这个话题上做了出色的工作，我强烈鼓励对这个话题感兴趣的读者去看看他们的 2018 年报告。也看看世界顶级科技公司(谷歌、IBM、微软)是如何通过教育、工具和技术来解决这个问题的[7] — [10]。

最大似然偏差的几个例子

• 犯罪风险评分偏差 — ProPublica
• 当你的老板是一个算法师 — NYT
• Joy Buolamwini 的性别阴影项目

QZ.com Article

为了深入了解概况和历史背景，我向你推荐 AI Now 研究员凯特·克劳福德(Kate Crawford)的 2017 年 NIPS 主题演讲视频。

Kate Crawford — NIPS 2017 Keynote

偏见和歧视的根源

人工智能和人工智能中的偏差可能是由于糟糕的设计、有偏差的信息(数据)来源或无意中被编码到我们的数据、算法中的人为偏差，或者两者都有。

数据偏差

数据是任何人工智能和人工智能工作的基础，也是许多偏见和公*问题的起点。

数据→包括过去的人为偏见→输入模型

人工智能(AI)在所有行业所有类型的业务职能中的引入将加速和扩大。尽管如此，人工智能仍将受到其从虚假信息中可靠辨别真实内容的能力的限制。— Gartner。

根据[11]的数据，有三个主要的偏差领域:

• 标签偏差—观察到的成为数据，例如逮捕而不是犯罪
• 亚组有效性——特征的预测能力因组而异
• 代表性-训练数据是否代表总体？我们有偏斜的样本吗？是否存在样本量差异？功能限制。例如，训练数据中地理多样性的缺乏将影响从更广泛的一组位置提取的图像的分类性能。

作者指出了社会上两个众所周知的歧视概念:

1. 经济因素:有两个:第一，统计因素(例如，因为男性开车，所以向他们收取更多的保险费)。第二，基于品味(牺牲利润以避免某些交易，通常是出于无知)
2. 法律:基于动机(例如基于分类的*等保护原则)

算法设计中的偏差

Sam Corbett-Davies 和 Sharad Goel [11]回顾了三种常见的 ML 公*性测量模型。

(1)反分类，意味着受保护的属性——如种族、性别和它们的代理——没有明确地用于决策；

(2)分类奇偶性，意味着预测性能的普通度量(例如，假阳性和假阴性率)在由受保护属性定义的组之间是相等的；和

(3)校准，意味着以风险估计为条件，结果独立于受保护的属性。

提出的定义是作为衡量公*性的可能方式。然而，关于这些测量的缺点存在争议(例如，这些定义彼此不相容),一些研究人员认为这些定义实际上会加剧偏倚问题。斯坦福大学的 Sam Corbett-Davies 和 Sharad Goel 认为，所有这三个公*定义都存在显著的统计局限性。在许多情况下，基于阈值的风险估计是更好的选择。这种方法意味着“基于人们所能产生的最精确的风险统计估计，以相似的方式对待相似的风险人群。”

外部性的影响——群体与个人选择

外部性和均衡效应有时会被忽略，但在某些情况下它们很重要。

有些决定最好被认为是集体的而不是个人的选择。在大学招生中，多样化的学生群体可能有利于整个机构，在申请者之间建立相互依存关系。预测算法也会产生反馈循环，导致意想不到的后果。

负责任的 AI

负责任的人工智能是一个广义的术语，旨在描述符合道德规范、具有包容性(而不是社会特权群体独有的)、不伤害社会(没有武器化)并把社会福祉放在首位和中心的人工智能。大多数国家级人工智能政策和战略都强调这一点。

隐私是伦理和负责任的人工智能的一部分。ML powered 在过去几年中在面部识别方面取得了重大进展，引起了包括算法正义联盟在内的许多人对隐私、数据所有权和公*性的担忧。

[## 面部识别技术旨在识别善恶

面部识别正在成为主流。这项技术越来越多地被执法机构和学校使用…

www.wsj.com](https://www.wsj.com/video/series/moving-upstream/facial-recognition-tech-aims-to-identify-good-and-evil/0C19B7EA-D8FC-4AF1-8FC3-EEAA1FD9F2B4)

加拿大和法国率先在 2018 年夏天发布了一份联合声明。他们成立了一个独立的专家组，该专家组将“汇集来自政府的专家、国际公认的科学家以及来自工业界和民间社会的代表。”

*来，负责任的人工智能的话题越来越受到关注，多个团体正在全球范围内领导这些努力。下面提到了两个高质量的工作，并链接到他们的综合工作。

1. 蒙特利尔宣言正式提出了负责任人工智能的愿景。
2. 欧盟道德与可信赖人工智能报告草案，2018 年 12 月。

可解释性、透明度和信任

一个可解释的人工智能是其行为能被人类容易理解的人工智能。它与机器学习中的“黑匣子”概念形成对比，黑匣子意味着复杂算法工作的“可解释性”，在这种情况下，即使是它们的设计者也无法解释为什么人工智能会做出特定的决定。

在人工智能有多“聪明”和它有多透明之间经常存在权衡，随着人工智能系统内部复杂性的增加，这些权衡预计会变得更大。

由于显而易见的原因，这是一个非常活跃的研究领域，Darpa 已经为此分配了大量资金[18]。

我们从决策树到随机森林。

应该能够审计算法和数据。记住上面关于使用哪种度量的讨论！

什么时候应该依赖算法？可以观察到错误，反馈可靠、快速且可行。—尼科斯·萨瓦，London.edu

这是看待它的一种方式

Source: DARPA Explainable AI

另一个是直觉。

DARPA, Nautil.us

ML 的可解释性和可解释性是一个很大的话题，所以我建议你参考[17]-[20]了解细节。

反驳点:如果人们知道模型或算法工作的所有方式，他们会尝试游戏系统吗？

减轻 ML 和 AI 中的偏见和不信任

你可以采取哪些切实可行的措施来避免和减轻偏见？

• 提高认识
• 问一些尖锐的问题
• 集合不同专家
• 专家审核数据和算法
• 创建人工审查流程

多元化和多个利益相关方

拥有一个多元化的利益相关者群体应该是任何国家人工智能政策的重要组成部分。

https://www.ajlunited.org/

你需要留出时间和资源，让一个全面的专家小组(不仅仅是技术专家)从多个角度审视整个链条。

偏差清单

以下是我对偏见的快速回顾列表——这并不是一个全面的资源，而是一个起点。

关键要点

公*，道德，负责任和可解释的 ML 和 AI 终于得到了应有的重视。正如技术造成的其他重大破坏一样，解决这些挑战需要时间。这篇文章描述了这个主题的一个非常简短的、非技术性的介绍。下面的参考资料提供了大量的细节和材料的附加链接。正如任何活跃的研究领域一样，这里还没有包括更多的资源——主要是因为我的时间有限。然而，如果我错过了一些应该在邮件中的东西，请让我知道。

参考文献:

[1]尼科斯·萨瓦。领导者的教训和局限。伦敦商学院，2017 年 11 月。https://www . London . edu/faculty-and-research/lbsr/algorithmic-ethics-lessons-and-limits-for-business-leaders

[2]凯西·奥尼尔。数学毁灭武器:大数据如何增加不*等并威胁民主。百老汇图书，2017 年 9 月。

[3]威尔·奈特。人工智能核心的黑暗秘密——麻省理工科技评论，2018 年。https://www . technology review . com/s/604087/the-dark-secret-at-the-heart-of-ai/

[4]弗吉尼亚·尤班克斯。自动化不等式。圣马丁出版社，2018 年 1 月。

[5] AI Now Institute:一个研究人工智能社会意义的研究机构，https://ainowinstitute.org/。2018 年报道https://ainowinstitute.org/AI_Now_2018_Report.pdf

[6] Dave Gershgorn ，如果 AI 要做世界医生，它需要更好的教科书，2018 年 9 月 6 日。石英https://qz . com/1367177/if-ai-is-to-be-the-world-s-doctor-it-needs-better-textbooks/

[7]谷歌开发者:机器学习公*性https://Developers . Google . com/Machine-Learning/Fairness-overview/

[8]Google 的“假设”工具(PAIR initiative)。【https://pair-code.github.io/what-if-tool/】https://ai . Google blog . com/2018/09/the-what-if-tool-code-free-probing-of . html，

[9] IBM 公* 360https://www.ibm.com/blogs/research/2018/09/ai-fairness-360/

[10]微软公*决策机器学习https://www . Microsoft . com/en-us/research/blog/Machine-Learning-for-Fair-Decisions/

[11]科比特-戴维斯，萨姆，戈埃尔，沙拉德(2018)。公*的测量和错误测量:公*机器学习的评论。https://arxiv.org/pdf/1808.00023.pdf

[12] Agarwal，a .，Beygelzimer，a .，Dud k，m .，Langford，j .，Wallach，H. (2018 年)。公*分类的简化方法。机器学习国际会议。

[13] Angwin，j .，Larson，j .，Mattu，s .，和 Kirchner，L. (2016 年)。机器偏见:全国各地都有用来预测未来罪犯的软件。而且对黑人有偏见。ProPublica。

[14]关于机器学习公*性的教程，作者钟子元https://towardsdatascience . com/A-Tutorial-on-Fairness-in-Machine-Learning-3ff 8 ba 1040 CB

15《负责任的大赦国际蒙特利尔宣言》。2017 年 11 月。https://www . Montreal declaration-responsible ai . com/the-declaration

[16]欧盟关于道德和可信人工智能的报告草案，2018 年 12 月。https://EC . Europa . eu/futurium/en/system/files/ged/ai _ hleg _ draft _ ethics _ guidelines _ 18 _ December . pdf

[17]地面 AI。可解释的人工智能https://www . ground ai . com/project/可解释的人工智能理解可视化解释深度学习模型/

[18]大卫·冈宁，《可解释的人工智能》(XAI)。https://www . cc . gatech . edu/~ Alan wags/dlai 2016/(Gunning)% 20IJCAI-16% 20 dlai % 20ws . pdf

[19]克里斯托夫·莫尔纳尔，可解释的机器学习——让黑盒模型变得可解释的指南。https://christophm.github.io/interpretable-ml-book/

[20] Zelros AI 机器学习模型可解释性简史https://medium . com/@ zel ROS/A-Brief-History-of-Machine-Learning-Models-explability-f1c 3301 be 9 DC

预测用电量的人工智能能源框架

原文：https://towardsdatascience.com/ai-powered-energy-framework-for-forecasting-electricity-consumption-ebf4ecbc49f7?source=collection_archive---------14-----------------------

电是一种重要的能量形式，不能以物理方式储存，通常在需要时产生。在大多数研究中，主要目的是确保产生足够的电力来满足未来的需求。为了避免浪费或短缺，需要设计一个良好的系统来持续保持所需的电力水*。有必要估计独立因素，因为未来电量不仅基于当前净消费量，还基于独立因素。在这项研究中，提出了一个新的框架，首先使用 SARIMA(季节性自回归迭代移动*均)方法和 NARANN(非线性自回归人工神经网络)方法来估计未来的独立因素，这两种方法都称为“预测情景方法”，如下图 1 所示。

Figure 1: The flow chart of the new framework for forecasting net electricity consumption.

随后，基于这些情景，应用 LADES(LASSO-based adaptive evolutionary simulated annealing)模型和 RADES(ridge-based adaptive evolutionary simulated annealing)模型对未来净用电量进行预测。然后通过土耳其的案例研究验证了所提出的方法。实验结果表明，与以前的方法相比，我们的方法优于其他方法。最后，结果表明 NEC 可以被建模，并且它可以被用来预测未来的 NEC(见图 2)。

Figure 2: Scattering and distribution graphics of training and testing level, respectively, for the best energy model.

在现代生活中，预测对于有效应用能源政策极其重要。政府需要知道必须生产多少电力来满足能源需求和消耗。在土耳其，用于预测的 NEC(净耗电量)是从 MENR 的 MAED 模拟技术中正式获得的，预测误差很大。预测需要指导 MENR 制定最佳能源政策。

本研究的主要结论是土耳其的电力消费被建模为具有线性和二次行为的新能源模型。新能源模型的使用形式使得未来预测成为可能。我们还介绍了替代预测方法的重要性。改进了文献中假设独立因素随时间以恒定增长率增加的情景，以便通过在预测情景方法中使用 SARIMA 方法和 NARANN 方法来预测独立因素的未来值。

Figure 3: Monthly forecasting of the NEC with two scenarios between 2011 and 2020.

根据本研究中到目前为止呈现的结果和讨论，预计 NEC 将通过使用提议的方案和最佳能源模型(见上图 3)来展示该框架如何适用于未来。提出的最佳模型以 1.59%的*均 MAPE 误差率预测了土耳其 34 年的电力消费，而 MENR 预测某些年份的误差率超过 10%。这意味着土耳其政府和相关组织可以使用这一框架来预测未来的价值，以确保良好的未来规划。这些模型也可以在不同的国家使用。通过研究未来价值，可以制定新的规划策略。政策制定者可以利用这一框架来规划新的投资和确定适当的进出口额。此外，新能源模型可以通过使用不同的误差评估标准来定义(例如 SSE、MAE、MAPE 等)。)作为改进模型的目标函数。可以开发混合技术的新能源模型来进行更好的研究。

总之，在土耳其和其他国家，对能源需求预测不足经常导致电力短缺和停电。这阻碍了经济的发展，并给普通公民带来烦恼和不便。通过预测实际能源需求，这项研究中提出的模型将有助于避免这些停电，从而使土耳其能够更快地发展，并提高其公民使用电力的生活质量。

想了解更多关于这项研究的信息，请点击下面的链接。

http://www . academia . edu/19744765/A _ new _ forecasting _ framework _ for _ volatile _ behavior _ in _ net _ electricity _ consumption _ A _ case _ study _ in _ Turkey

人工智能对 2019 年的预测

原文：https://towardsdatascience.com/ai-predictions-for-2019-610b8de56aad?source=collection_archive---------21-----------------------

2019 年将是人工智能的分水岭

人工智能，具体来说，机器学习和深度学习，已经成为 2018 年的时尚关键词，我们不认为炒作会在未来几年内消退。从长远来看，人工智能最终将成为日常新闻，成为另一种驱动我们生活的技术，就像“互联网”、“电力”和“可燃引擎”一样。

然而在接下来的几年里，激动人心的技术突破将改变我们的生活、经营和管理社会的方式。人工智能有望带来前几次技术革命中我们做梦都想不到的变化。与过去不同，人工智能驱动的机器将做分析、规划、预测和决策的“思考”工作，为我们一直认为是为人类保留的新角色做出贡献。

我们仍然不确定人工智能是否最终会导致一个“星际迷航”般的社会，让人类自由地度过他们的生活，追求更有意义的目标。然而，许多人相信人工智能将导致大规模失业和社会动荡，最终导致天网式的人类灭绝。虽然我没有遥远未来的水晶球，但以下是我对 2019 年的预测。

人工智能将加速所有权社会的终结

我不再拥有我的音乐 CD 或电影 DVD，我们订阅了 Spotify 或网飞。在人们购买的日常产品中，音乐和视频可能是标志着所有权时代结束的第一批产品。今天，人工智能*台正在将每一种制造产品和服务转变为互联的“智能”产品。我们已经在交通和消费电子产品中看到了这一点——汽车、滑板车、洗衣机、咖啡机、恒温器等。

Figure 1. AI will accelerate the trend of subscription-based sharing of goods and services. Credit: Pinsnaper

由从智能产品捕获的数据驱动；AI 算法和新的商业模式，结束所有权的趋势将加速所有行业、产品或服务。我们开始订阅办公空间( WeWork )、住房(漫游、普通)、家具( Fernish )、服装( Le Tote )甚至遛狗( Wag )。这些趋势将加速，类似的服务将在 2019 年及以后开始支撑各行各业。

非科技公司将开始构建人工智能

虽然人工智能和人工智能一直是热门话题，但新闻主要是由脸书、苹果、亚马逊、网飞和谷歌(FAANG)等科技公司推动的。许多非科技企业已经创建了他们的“人工智能战略”，现在将专注于解决影响他们业务指标的现实世界问题。在花了几年时间进行数字化工作以整理数据并确定人工智能可以带来回报的机会领域后，企业将继续推进成熟的计划，从试点中学习，然后试运行到全球部署。

在这种情况下，零售商专注于建立客户参与模型，以最大化全渠道存在和销售转化。或者，客户流失预测模型将帮助他们获得客户可能会脱离并可能完全停止购物的早期信号，从而需要业务干预来防止这种情况。

受益于数字化和人工智能，企业将开始利用他们的数据产生新的收入流。建立交易和客户活动的大型数据库，并与相邻行业合作，基本上可以让任何充分了解数据和人工智能的企业开始重塑自己。例如，电信公司可以开始为客户何时可能购买新的智能手机建立模型。有了模型预测，他们可以与手机制造商合作，为客户提供高度定制的激励，以促成交易——在这个过程中为自己创造收入。

因此，我们将看到焦点从“人工智能战略”转移到“人工智能驱动的”结果，因为公司希望从他们的技术和人员投资中获得真正的商业影响。技术将变得不那么重要:商业洞察力和交付的结果将是关键。另一方面，随着人工智能的入侵，企业将开始意识到人工智能是对其流程、人员和文化转型的投资，而不仅仅是可以用来立即解决低效问题的神奇工具。

消费者对人工智能的理解将发生巨大转变

随着人工智能超越炒作和每日头条新闻，随着基于人工智能的设备和服务的使用激增，我们对人工智能的理解将发生转变。最初，与人工智能的日常互动将采用数字助理的形式，如聊天机器人或语音机器人以及 Alexa 等设备。随着交互和使用的增加，我们将不再把人工智能与从不撞车的自动驾驶汽车联系在一起，而是作为生产力工具和预测来帮助日常任务，让我们的生活变得更好。实用人工智能将致力于让购物变得愉快，让病人护理变得更好，让疾病检测变得更精确，让学习变得更愉快。

Figure 2. Consumers understanding of AI will be more nuanced: instead of expecting self driving cars that never crash, we will see AI as a everyday business tool. Credit: Pinsnaper

另一方面，虽然人工智能在大多数情况下都能很好地工作，但我们会看到偶尔的小故障或荒谬的失败。这是因为许多“数据科学家”对人工智能的底层统计本质缺乏深刻的理解，并且缺乏实现算法的编程方法，导致了意想不到的后果。

人工智能将是坏演员有利可图的领域

随着越来越多的企业使用人工智能来推动他们的产品和服务，并开始依赖数据驱动的决策，整个生态系统需要时间来开发新的流程和框架来与之配合。例如，营销部门在全球部署客户流失预防措施之前，会希望进行检查和*衡，以确保不会发生“收入流失”或客户伤害。当涉及处理人类数据时，这尤其成问题，因为人工智能仍然受到“黑箱问题”的阻碍，数据科学家社区之外的大多数人，甚至一些人，似乎不理解系统在做什么。

Figure 3. AI driven fraud and phishing will become more common in 2019, causing significant losses to businesses and consumers. Credit: Pinsnaper

由于新的人工智能生态系统需要时间来适应新的流程和框架，坏人将利用系统的婴儿期。在整个数字生态系统中，利用数据*台和复杂的人工智能技术，他们将加倍努力，执行全球化和高度定制的欺诈计划，导致品牌和营销人员遭受重大损失。围绕传感器篡改、数据操纵、启动以及复杂的人工智能模型驱动的欺诈和网络钓鱼攻击的许多风险将会暴露出来。

2019 年将是隐私支持人工智能的一年

随着企业将人工智能融入他们的系统、流程和日常业务，人工智能需要得到信任，以实现其全部潜力。人工智能的消费者会想知道它对我们的数据做了什么，当涉及到影响我们生活的问题时，它为什么以及如何做出决定。从技术角度来看，这通常很难传达。人工智能之所以有用，是因为它能够建立联系，做出对我们来说不明显甚至可能违反直觉的推断。考虑一下谷歌的 AlphaGo 击败 2016 年世界顶级围棋选手之一 Lee Sedol 的情况。没有人能理解 AlphaGo 的棋步，当比赛在观众和解说员面前进行时，人们有一种难以置信的感觉。除了让公众放心，研究和商业也将从公开中受益，公开揭露数据或算法中的偏见。

2019 年，我们将看到人们越来越重视旨在提高人工智能透明度的技术和流程，这是由通用数据保护条例( GDPR )以及将在印度等主要经济体生效的类似措施推动的。GDPR 于 2018 年在欧洲各地投入使用，为公民提供保护，防止机器做出具有“法律或其他重大”影响的决定。企业，尤其是领先企业，通过人工智能的力量“谷歌化”其业务的驱动力，将导致他们与第三方共享数据。确保数据隐私，进而确保客户隐私，不仅是一种良好的商业实践和风险管理策略，而且很快将成为一项法律要求。

2019 年，支持隐私的人工智能技术将为支持人工智能应用提供基础，同时使用加密技术维护强大的隐私。我最喜欢的是令人兴奋的新兴安全计算技术。同态加密(HE)是一种安全计算技术，是一种加密数据的特定方式，以便第三方可以使用机器学习技术进行操作并收集有价值的见解，同时数据继续被加密，从而保护用户的隐私。

基于 HE、联邦学习(另一种由谷歌推广的分布式机器学习技术，不需要集中数据)和其他安全计算方法，我们将看到初创公司专注于在边缘实现人工智能的民主化。这里的赌注是，在未来 3 年内，超过 10 亿部智能手机将配备人工智能芯片和重要的本地计算，许多人工智能模型将能够在这些移动设备上本地运行。将计算分布在数十亿部智能手机上将大大降低开发人工智能产品的成本和时间，如超个性化推荐引擎、人工智能助手等。对于大多数企业来说。大公司和初创公司都在构建分布式、安全和支持隐私的计算框架来实现这一点。

摘要

2019 年将是人工智能的分水岭，届时该技术将逐渐走出炒作周期，并开始在所有类型的业务，流程，产品和服务中被广泛采用。消费者对该技术的理解将开始改变:然而，隐私仍将是企业必须解决的挑战，以确保公众广泛接受该技术。支持隐私的人工智能*台，配备人工智能芯片和重要本地计算的智能手机，将改变人工智能的分布方式。到今年年底，人工智能将提供高度个性化的内容和推荐，这将使消费者感到高兴，并会感到不自然的个性化。

下一个故事: 印度贫穷地址的影响:一年 100-140 亿美元

往期剧情: AI 对 2018 年的预测

你好。像这样的文章需要相当多的时间和精力，所以如果你能为我鼓掌，这将让编辑们知道你喜欢它。谢谢

作为营销策略的客户人工智能原型

原文：https://towardsdatascience.com/ai-prototypes-for-clients-as-a-marketing-strategy-70de404d27b5?source=collection_archive---------5-----------------------

线在哪里？目标不就是为了得到报酬吗？

在 2017 年的大部分时间里，我们将公司的重点转移到深度学习咨询服务上，我们尝试了各种方法来解释和向潜在客户展示我们在做什么以及我们是如何做的。作为一家人工智能咨询公司，我们有着与其他任何公司一样的成长烦恼，外加每天都在变化的技术的易变性。

动机

我们的许多潜在客户带着一个共同点来找我们:他们都在我们之前尝试过另一家人工智能商店。“我们为一份报告花了 25 万美元”，一位首席执行官哀叹道。“他们消失了 9 个月，我们最多只能得到不冷不热的结果”，另一个人说。

这时，我们意识到外面有很多骗子和想成为骗子的人，这取决于我们来证明我们能够说到做到。金钱的承诺吸引着形形色色的人；甩字服和烟镜魔术师绝对是其中的一部分。

这并不是说有不可思议的团队存在；相反，需求已经远远超过了供给，这使得在域名上放置人工智能的的权力关系发生了倾斜。

达到极限

既然我们已经确定了可能需要展示技能，那么在没有签订合同的情况下，顾问能做多少工作呢？以下是我们制定的内部指导方针，旨在保持照明，让每个人都能买到食品杂货。

方法 1:24 小时原型

最简单的方法是:向客户展示你可以做一些与他们领域相关的事情。有许多可用的公共数据集，因此根据工作范围，客户没有必要为您提供这些。

A prototype for an HR firm. We took a job posting dataset from Kaggle, clustered the postings by similarity of text, found the most common words in the job titles, and tracked the demand by year. We therefore know how to manipulate job postings, a core need of the project.

方法 2:样本数据

除了基于开放数据的原型构建，您还可以从客户端数据本身获得最直接的见解。

“让我看看你能做什么，”一位客户在下载了一堆 pdf 文件到我们的服务器后说道。他们选择了一些感兴趣的报告，我们向他们展示了实体如何根据共现进行分组。搞定搞定，签合同。

方法 3:解决方案架构

如果您要构建理想的解决方案，它会是什么样的？在几十个项目完成之后，我们现在可以去找客户，讨论部署是什么样的:技术、阶段控制阶段和经验教训。毕竟，你的客户不正是因为这个原因雇佣你的吗？

因为我们的秘方不在于我们为项目选择的乐高积木，而在于我们如何将它们组合在一起，所以这个解决方案是我们迄今为止最成功的方法(总努力与成交率)。

过去的教训

虽然我们随着时间的推移磨练了这些经验，但它们也是在将知识用于金钱的烈火中锻造的。哪里有钱，哪里就有贪婪。

知识产权盗窃

“他们不是要偷你的创意吗？”非常好的问题。让我用另一个问题来回答这个问题:如果他们要欺骗你，在未来关系的开始阶段发现这一点不是更好吗？

让他们了解一下本来会是灾难性的情况。满足他们内心的盗窃癖，然后屏蔽他们的电话号码。

选择合适的客户

难相处的客户自始至终都很难相处。如果他们开始挑剔你的原型，那么他们要么 1)不知道什么是原型，而不是完整的产品，要么 2)他们试图用更少的钱得到更多。

一个简单的客户会清楚:

• “我想要那个。要花多少钱？”我的最爱。确保你完全理解自己的定价逻辑。以下是我的 CTO 对此事的看法:https://towards data science . com/how-to-price-an-ai-project-f 7270 CB 630 a 4
• "我们能把它安装在 X 上，或者连接到 Y 上吗？"明确要求。非常低范围蠕变的良好指标。
• “我们可以从 X 开始，然后从那里发展。”限制范围。爱死了。

远离问题，而不是金钱

或者，以下是一些危险信号:

• “那么贵，嗯？”是的。你根据特定的小时费率来计划你的时间。他们可能真的没有钱。
• "我能看一眼源代码吗？"没有。你的秘制酱是你的命根子。一旦你的客户付了钱，你可以和他们分享，但是永远不要，永远不要。
• “只要把它做得漂亮，我们就可以照原样出售。”没有功能性？既然你的名字受到指责，客户会对你说什么？
• "如果你再扩建一点，我就可以卖掉它。"这是一个难题，因为它可能是真的。在这种情况下，在客户端要求时间表、预算和冠军。如果这些都不存在，退出。

与任何事情一样，您的里程可能会有所不同。信任，但要核实。

A simple GIS prototype. The city of Calgary, with an overlap of Statistics Canada’s Dissemination Areas and light rail tracks, in order to show the impact of future policies on public housing and social welfare. One hour and 12 minutes total to generate this image.

简而言之…

请记住，这些原型的目的是展示技能，这样你就可能被录用，而不是做所有的前期工作。

编码快乐！

马特。
马特@ lsci . io
LemaySolutions.com

人工智能研究深度挖掘:具有想象目标的视觉强化学习

原文：https://towardsdatascience.com/ai-research-deep-dive-visual-reinforcement-learning-with-imagined-goals-862115d122a6?source=collection_archive---------5-----------------------

这篇文章涵盖了 Nair 等人的论文“具有想象目标的视觉强化学习”，可以在这里找到。

人类能够在没有任何明确或监督训练的情况下完成许多任务，仅仅是通过探索他们的环境。如果我被丢在莫斯科的中部，简单地以一种没有方向的方式走来走去，我可以完成一个特定的任务(例如。去杂货店),而之前从未见过这个任务，仅仅通过从过去的经验中知道商店位于哪里。我们能够设定自己的目标，并从我们的经验中学习，因此能够完成特定的任务，而无需接受明确的训练，这是概括的核心原则。

自然，任何机器学习科学家的下一个问题是:自主代理是否也可以设定自己的目标并从其环境中学习。在论文“具有想象目标的视觉强化学习”中，作者能够设计这样一个无监督的强化学习系统。

在深入研究本文之前，让我们先定义几个术语:

• 状态( s ):洗碗机有两种一维状态——“开”和“关”。鹿有三种状态——“睡眠”、“进食”和“狩猎”。在本文中，我们将状态定义为对象在特定时间步长内的快照。
• 目标:目标是我们的对象渴望达到的状态。
• Action ( a ):我们处于状态 s 的对象可以采取动作 a 移动到不同的状态(或者可能停留在相同的状态)。需要注意的是，动作不是确定性的。国家-行动对也不是。相反，我们必须定义一个转移概率矩阵，它根据当前状态 s 和动作 a 决定我们的对象到达状态s’的概率。不那么抽象地说，在本文中，动作仅仅是机器人的特定运动。
• 奖励( r ):我们可以用元组( s 、 a 、 g 、s’)指定的每个状态、动作、目标和结果状态 s’，都有一个相关的奖励( r )。这个系统中的奖励是由对象当前状态的图像与目标状态的图像的相似程度来定义的。
• 策略( p(s) ):策略是根据当前状态选择下一个动作的策略。因此， p(s) = a
• Value ( V(s，g)):value 函数描述了使用策略 p 的长期收益，从状态 s 和目标 g 开始。在强化学习中，我们试图找到一个使我们的价值函数最大化的策略。
• Q-value ( Q(s，a，g)):Q-value 函数是 value 函数的扩展，它允许代理决定要采取的操作。该函数返回给定 (s，a，g) 元组的折扣奖励总和，用于学习产生最大价值函数的最优策略。
• 折扣系数:我们系统的另一个目标是最大限度地减少我们为实现目标而采取的行动。因此，我们对每个后续时间步长的奖励都给予折扣，使得奖励呈指数级动态下降(取决于状态-动作对)。

强化学习的最终指导是学习一种策略，当给定一种状态和目标时，它可以支配最佳的行动。在本文中，培训期间没有明确定义目标。这类似于让孩子在上学的第一天在操场上跑来跑去，然后第二天让孩子去荡秋千。尽管没有“教”孩子如何挥杆，但孩子很可能会完成任务。

如果一个目标没有明确定义，代理必须自动生成一组综合目标。因此，假设我们让一个自主代理探索一个具有随机策略的环境。执行每个操作后，将收集并存储状态观察结果。这些状态观测以图像的形式被结构化。代理可以从该组状态观察中随机选择目标，也可以从该组状态观察中随机选择初始状态。

现在，给定一组所有可能的状态，一个目标，和一个初始状态，一个强化学习框架可以用来寻找最优策略，使得价值函数最大化。然而，要实现这样一个框架，我们需要定义一个奖励函数。一个可能的奖励函数是对应于当前状态的图像和对应于目标状态的图像之间的距离(作者使用负的 Mahalanbois 距离)。更高的奖励分配给更接*目标形象的州。

这个奖励函数的一个基本问题是，它假设原始图像之间的距离会产生语义上有用的信息。图像有噪声。图像中的大量信息可能与我们分析的对象无关。因此，两幅图像之间的距离可能与其语义距离不相关。

可以手动创建描述图像重要和相关属性的特征向量。然而，在人工智能领域，我们努力尽可能地减少人类的努力。那么，如何从状态图像中提取有用的表示呢？

可变自动编码器(VAE)

自动编码器是一种机器学习模型，可以学习从图像中提取鲁棒的、空间高效的特征向量。该模型有两部分——编码器( e )和解码器( p )。编码器将图像作为输入，并输出低维特征向量。解码器将该低维特征向量作为输入，并重建原始形状。该模型被训练为最小化曼哈顿距离(L2；输入图像和输出图像之间的均方差)。

低维特征向量作为编码器的输出和解码器的输入，被称为潜在变量。224×224×3 输入图像(包含总共 150，528 个特征)可以简化为形状为 4096×1(4096 个特征)的潜在向量。由于该潜在向量可用于重建输入，它有效地封装了与图像中的对象特别相关的信息。

A series of convolutional layers (the encoder) reduces the input image size to a latent variable. A series of deconvolutional layers (the decoder) maps the latent variable to an output image. Together, the encoder and decoder make the autoencoder, which is trained to recreate the input image in the output.

虽然 autoencoder 模型提供了一种强大的无监督图像编码方式，但它容易过度拟合。该模型可以“记忆”从潜在变量到图像的映射，因此失去了在编码中仅编码有价值的特定于对象的信息的能力。本文作者使用变分自动编码器，它在解码前将潜在向量拟合为单位高斯，从而执行归一化。

使用变分自动编码器变换图像空间有许多优点。

• 提供距离更有意义的空间，从而允许使用结构良好的奖励函数(例如编码之间的距离)
• 强化学习网络的输入是结构化的
• 可以从解码器输出中采样新的状态，允许在训练期间自动创建合成目标，以允许以目标为条件的策略实践不同的策略

强化学习框架

此时此刻:

• 代理从由随机策略控制的环境的探索中收集状态观察
• 基于这些状态观测训练了变分自动编码器
• 所有的状态观测值已经通过编码器被编码到潜在空间中
• “初始状态”和“目标状态”是从全部状态中随机抽取的

回想一下，现在所有的算法都只在潜在空间中运行。从今以后，当我提到“状态”、“初始状态”或“目标状态”时，我指的是它们在潜在空间中的表征。现在，这个问题的定义更清楚了。给定初始状态、目标状态和奖励函数(当前状态和目标状态的潜在变量之间的负 Mahalanobis 距离)，任何值学习算法(例如 q 值学习)可以创建一个策略——一个函数，当给定一个目标和一个状态时，它返回最优的动作。

作者使用双延迟深度确定性策略梯度作为他们的强化学习算法。目标函数在下面的等式中表示，其中策略被优化以最小化*方贝尔曼误差。这种算法可以脱离策略进行训练，这意味着它不贪婪——它可以接受任何类型的训练经验。策略培训根据当前策略选择培训过程中的操作。

这里描述的学习框架的美妙之处在于，可变自动编码器可以生成潜在的无限训练数据。新的目标空间可以通过将目标图像传递通过自动编码器来生成，产生相似但不同的图像。从这些新目标中，可以计算出新的回报。并且这种“新体验”可以被重新输入到强化学习模型中。因此，该模型能够从自动生成的经验中归纳出在初始探索阶段没有看到的新环境。

摘要

这里给出了该算法的总结:

1. 通过对环境的随机探索来收集状态观测值
2. 根据这些观察训练变分自动编码器
3. 每个状态的潜在编码从变分自动编码器获得
4. (目标，状态)编码从现有集合中取样
5. 在潜在编码上训练强化学习算法
6. 在以下条件下重复步骤 4–5:1)定期用新生成的图像空间重新训练自动编码器。2)通过变化的自动编码器馈送目标图像来生成新的目标。

Left: image of agent + environment. Middle: Initial state, intermediate states, and final states are depicted. Right: Goal state, and VAE(g) state depicted.

结论

强化学习是当今一个非常热门的话题，在许多领域都有大量的应用。这种特殊的算法令人兴奋，因为它 1)使用视觉数据，2)以无人监管的方式进行训练。该算法无法访问真实状态或预定义的奖励函数。它可以在没有显式编程的真实环境中运行良好。

对于所有的图形和方程式，要感谢“具有想象目标的视觉强化学习”的作者。

在 twitter 上联系我 @prasadinapickle ，在 Medium 上查看我@ nprasad 的更多类似内容。

Connect with the Raven team on Telegram

人工智能安全

原文：https://towardsdatascience.com/ai-safety-9aeb9ca42907?source=collection_archive---------5-----------------------

我们真正需要做的是确保生命延续到未来。最好的办法是努力阻止负面情况的发生，而不是等到它发生后才做出反应。——埃隆·马斯克

作为一个 90 后的孩子，我已经迷上了看许多科幻电影。在那个时期，这种类型就像“一个头脑中有很多野心的小孩”。像《黑客帝国》1、2(不是 3)、所有《终结者》系列电影、所有《变形金刚》系列电影、《x 战警》、《独立日》等电影在我们当中很受欢迎。因为他们，我开始了解机器人，并不断思考如果机器人出现在现实生活中，如何与机器人战斗。

现在，当我看过去这些电影时，我认识到的第一件事是这部电影的 vfx 有多烂，第二件事是我们能创造出这种完全依靠人工智能力量的角色吗？

2015 年《复仇者联盟:奥创时代》再次上映，我认为这是一部有点意思的电影。但是我又想到了一件事… 我们可以用人工智能的力量创造这种类型的角色吗？我们能创造奥创吗？

到目前为止，我感觉到所有电影中的一个模式…所有这些反派都是由人类以某种方式创造的，或者是因为人类的任何干预而创造的。

但最终这些都还是电影。众所周知

电影只是人们头脑中的一种幻觉

所以我们不能创造出像《终结者》中的 T-X 或者《变形金刚》中的威震天 或者《复仇者联盟》中的奥创 那样的反派？

为什么不呢？所有反派都有一个共同点，那就是他们首先是邪恶的，那就是他们拥有普通人工智能的能力。

但*几十年来，我们看到人工智能的发展稳步上升。在某些情况下，我们已经超越了人类的极限。

举一个五号的例子。一个基于人工智能的 dota 团队，甚至可以击败最熟练的 dota 玩家。

[## OpenAI 的 Dota 2 失利仍然是人工智能的胜利

由埃隆·马斯克创立的研究实验室 OpenAI 制造的人工智能机器人在 Dota 2 上被人类职业玩家击败…

www.theverge.com](https://www.theverge.com/2018/8/28/17787610/openai-dota-2-bots-ai-lost-international-reinforcement-learning)

或者以这个故事为例，脸书的开发人员创造了一个人工智能，它用一种连开发人员都不懂的语言与其他人工智能对话。技术上可以说我们已经实现了真正的通用人工智能。

[## 脸书机器人用只有它们自己懂的语言相互交流后就会关机

在两个人工智能程序似乎在以一种…

www.independent.co.uk](https://www.independent.co.uk/life-style/gadgets-and-tech/news/facebook-artificial-intelligence-ai-chatbot-new-language-research-openai-google-a7869706.html)

在这一点上，开发人员关闭了整个操作，担心它已经失去了他们的手。但是他们害怕谁呢？如果他们就这样放弃这个项目，会发生什么？谁在阻止他们？

不幸的是现在我们没有答案。我们的宪法中没有人工智能规则这种东西，因为我们的立法者仍然无法理解人工智能。

人工智能安全

正如这篇论文漂亮地解释了…

人工智能安全是我们应该遵循的集体术语伦理，以避免机器学习系统中的事故问题，以及现实世界人工智能系统的糟糕设计可能出现的意外和有害行为。

当我们谈论人工通用智能或比人类更聪明的 AI 时，我们想到的就是这种通用的解决问题的能力。人工智能系统在科学和工程能力方面超越了人类，但在其他方面并不特别像人类。例如，人工智能不一定意味着人工意识或人工情感。相反，我们认为有能力很好地模拟真实世界的环境，并找出各种方法将这些环境置于新的状态。

要了解这方面的更多信息，你可以参考这个视频，它通过一个例子清楚地解释了人工智能的力量。

好了，现在我将把话题扩展到一篇有趣的论文，我认为这是一个完美的例子，说明为什么我们需要开发人工智能安全。

如果你不知道神经网络，请参考这里，那么只有你会知道这个。

对抗性攻击

对抗性攻击是攻击者有意设计的机器学习模型的输入，以使模型出错。

让我们举一个例子

假设我已经创建了一个图像分类器，它根据对象的图像给出对象的名称。所以如果我们把这个作为输入图像

那么我们将得到正确的“熊猫”输出。

但是，如果我告诉你，只给图像添加一些特定的噪声，我可以欺骗模型分类器，把它当成另一个对象。诸如

这是对抗性攻击的典型例子。

对立的例子有潜在的危险。例如，攻击者可以通过使用贴纸或油漆来创建车辆会解释为“让步”或其他标志的敌对停止标志来瞄准自动驾驶汽车，如 使用敌对示例针对深度学习系统的实用黑盒攻击 中所述。

根据对神经网络策略 ，的 对抗性攻击的新研究，强化学习代理也可以被对抗性的例子操纵。该研究表明，广泛使用的 RL 算法，如， TRPO ， A3C ，容易受到对抗性输入的攻击。这可能会导致性能下降，即使存在人类察觉不到的细微干扰，导致代理在应该上升的时候向下移动乒乓板，或者干扰其在 Seaquest 中发现敌人的能力。

当我们想到人工智能安全的研究时，我们通常会想到该领域中一些最困难的问题——我们如何确保比人类聪明得多的复杂强化学习代理以其设计者预期的方式行事？

对立的例子告诉我们，即使是简单的现代算法，无论是监督学习还是强化学习，都可能以我们意想不到的方式表现出来。

对抗范例很难防御，因为很难构建对抗范例制作过程的理论模型。对立的例子是对许多 ML 模型(包括神经网络)的非线性和非凸优化问题的解决方案。因为我们没有好的理论工具来描述这些复杂优化问题的解决方案，所以很难做出任何一种理论上的论证，即辩护将排除一组对抗性的例子。

对抗性的例子也很难防御，因为它们需要机器学习模型来为每一个可能的输入产生良好的输出。大多数时候，机器学习模型工作得很好，但只对它们可能遇到的所有可能输入中的很小一部分起作用。

对立的例子表明，许多现代机器学习算法可以以令人惊讶的方式被破解。机器学习的这些失败表明，即使是简单的算法，其行为也可能与其设计者的意图截然不同。

好吧，让我问你一个问题:

那么我们需要改变多少像素来愚弄我们的神经网络呢？

不幸的是，答案只有一个。

在这篇论文中提到，任何神经网络都可以通过改变图像中的一个像素而被击败。

通过改变描绘马的图像中的一个像素，人工智能将 99.9%确定我们看到的是一只青蛙。一艘船也可以伪装成一辆汽车，或者有趣的是，几乎任何东西都可以被看作一架飞机。

那么我们如何进行这样的攻击呢？如你所见，这些神经网络通常不直接提供一个类，而是提供一堆置信度值。这到底是什么意思？

置信度值表示网络对我们看到拉布拉多或虎猫的确信程度。为了做出决定，我们通常会查看所有这些置信度值，并选择具有最高置信度的对象类型。现在很明显，我们必须知道选择哪个像素位置以及它应该是什么颜色来执行成功的攻击。我们可以通过对图像执行一系列随机变化，并检查这些变化中的每一个如何在适当的类中降低网络的置信度来实现这一点。

在这之后，我们过滤掉不好的，继续在最有希望的候选人周围搜索。这个过程我们称之为差异进化，如果我们正确地执行它，最终，正确类的置信度值会非常低，以至于不同的类会取而代之。如果出现这种情况，网络已经被打败了。

现在，请注意，这也意味着我们必须能够查看神经网络，并获得置信度值。也有大量的研究工作致力于训练更强大的神经网络，使其能够承受尽可能多的输入变化。

第二个例子。

Deepfakes

Deepfakes 是使用机器学习算法对主题进行面部交换的视频。这种做法是由 Redditor Deepfakes 创建的，他在 2017 年 11 月推出了一个专门的 subreddit 来分享视频。2018 年 1 月，FakeApp 桌面应用程序作为创建数字修改视频的工具发布。

除了面部交换，其他工具可能很快允许以前难以伪造的媒体被操纵。有人用这个制作了唐纳德·川普总统说普通话的音频。使用生成性对抗网络，本质上是两个竞争人工智能之间的一个“猫和老鼠”的游戏，Nvidia 能够开发一个假冒名人面孔的网格。

基本上是用机器学习算法完成的。它需要一个数据集，里面有一个人面部的大量照片，比如说，凯丽·费雪的数百张照片，然后再放上一段视频。它在算法中同时运行这两者，几小时或几天后得出的结果就是视频中那个人的样子。

正如一些人提到的那样，最*发生了变化，这些新的人工智能算法可以获取大量数据，绕过许多手动过程，并且需要技术设施，使这种技术可以为许多可能负担不起这种技术设置的用户所用。

所有这些方法的一个挑战是，一旦你有了一个可以检测假货的系统，那么你就可以训练你的制造假货的系统来对抗这个系统。所以只要能进入那个系统进行检测，你就能越来越好地通过它。所以我不认为这是一个长期的解决方案。我的意思是，这是一个猫捉老鼠的游戏。

这只是我们现在面临的问题的冰山一角，因为缺乏人工智能的安全性。随着时间的推移，我们将获得智慧，获得真正的智慧，在各方面都超过人类，没有人会阻止他们。

最后的想法

人工智能安全的问题不会自己解决，也不容易解决…最重要的是，我们必须在解决通用 AI 之前解决它。

迟早我们会得到 AI 将军，当我们得到 AI 将军时，我们也应该有安全措施。

感谢您花宝贵的时间来阅读我的博客。我衷心感谢。

如果你喜欢这个帖子，那么请用 鼓掌 来表达你的回应，并在Twitter上发帖，因为我真的认为像这样的 it 话题应该传播到每一个人。

如果您有任何问题、疑问或建议，请在下面的评论中写下。

人工智能科学家:公司如何应对人才短缺？

原文：https://towardsdatascience.com/ai-scientists-how-can-companies-deal-with-the-shortage-of-talent-11ab48566677?source=collection_archive---------2-----------------------

到 2020 年，美国公司正在筹集超过 10 亿美元用于招聘人工智能科学家。这些高级职位的*均年薪为 31.4 万美元，部分原因是全球人才短缺。为什么这些技能如此受追捧，是什么造成了供需之间的差距，企业如何发展自己的人工智能素养水*？

“事实上，我很难想到一个行业，我不认为人工智能会在未来几年内改变。”—吴恩达

在将人工智能(AI)描述为、【新的电力】时，著名计算机科学家吴恩达明确表示，他相信这个领域将很快深入到商业的每个领域。

这些数字支持了 Ng 的预测:自 2014 年以来，苹果专注于人工智能的员工人数已经翻了一番，，2016 年提供了 50 亿美元的人工智能初创资金，美国公司正在收获超过亿美元，以挖走拥有成为人工智能科学家所需技能的人才。

然而，这种程度的投资并不能保证成功。

人工智能是计算机科学中一个如此庞大、新生、复杂的领域，以至于即使是世界上最富有的公司也难以按照要求的速度招聘人才。

在这篇文章中，我们将首先定义人工智能科学家的角色，然后深入探讨全球人工智能人才短缺的原因和潜在解决方案。

人工智能科学家角色

“人工智能科学家”这个头衔已经包含了广泛的职责。事实上，对于该领域中特定角色的确切职称应该是什么，仍然缺乏共识，这主要是由于人工智能不断发展的性质。

尽管如此，我们可以广泛地说，人工智能科学家是具有人工智能专业知识的计算机科学家，致力于开发具有我们与人类相关联的认知能力的机器。

通过 Siri 和 Alexa 等数字助理，人工智能优先的商业文化已经进入了公众意识，但在现实中，人工智能科学家的角色包含了更多的幕后工作。

一个人工智能科学家可能会领导开发项目，他们可能专注于研究，或者他们可能是负责输入人工智能系统的信息质量的数据科学家。在这个层次结构中的任何一层，人工智能科学家都将拥有分布式计算框架的经验，并将在统计学或相关领域具有一些学术基础。

人工智能科学家(尤其是人工智能研究科学家)直到最*都倾向于在学术界工作；然而，现在有一个重大的“人才流失”，这些领先的思想家转向利润丰厚的企业角色。

比以往任何时候都需要他们的技能的行业越来越多，单个企业的更多部门也需要他们的技能。Gartner 预测到 2020 年，人工智能将被整合到每一个新产品或软件中，因此我们应该期待人工智能科学家的角色继续演变。

不用说，这是一个高需求的角色，但即使是世界上最富有的公司，人才供应也一直令人担忧。

为什么人工智能人才供不应求？

纽约时报估计目前世界上只有 10，000 人拥有“所需的教育、经验和才能”来开发人工智能技术，企业正押注于此来创造大量新的经济机会。

这有多种原因，但缺乏资本投资肯定不是其中之一。仅在美国，职业咨询*台 Paysa】就披露了顶级公司的职位空缺，净工资总额如下:

• 亚马逊:2.2776901 亿美元
• 谷歌:130，048，389 美元
• 微软:75158057 美元
• 脸书:38636827 美元
• 英伟达:34280190 美元

毫无疑问，对精英人才的争夺非常激烈，最大的公司准备不惜一切代价争取胜利。

在谷歌旗下专注于开发神经网络来解决人工智能问题的 DeepMind，2016 年的公司记录显示，他们的 400 名员工每人的*均年薪为 34.5 万美元。甚至有一些(几乎肯定是注定要失败的)建议，需要一个 NFL 式的工资帽来阻止市场失控。

那么，为什么这么多合适的候选人能胜任这些利润丰厚的职位——有些职位的年薪高达五位数甚至六位数？

首先，人工智能是一个非常宽泛的短语，被用作包括机器学习、图像识别和自然语言处理在内的各种学科的总称。在有人准备好领导项目之前，这些领域中的每一个都需要很高水*的数学技能和行业经验(通常是 10 年或更长)。因此，当我们深入到“人工智能科学家”之外的利基专业时，人才缺口更难填补。

人工智能也是一个不断变化的行业，新的发现和创新经常改变着这个领域。这就产生了一个悖论；要成为一名人工智能科学家，需要多年紧张而有条理的学习，但研究领域在不断变化。因此，学术机构很难让自己的课程与企业界的需求保持一致。

本质上，即使是最有经验的计算机科学家，对人工智能的雄心也远远超过了专业知识的水*。正如谷歌大脑的负责人杰夫·迪恩最*所说:

“我们希望解决机器学习问题的组织从数千个增加到数百万个。”

在英国，职业和就业服务预测在 2022 年之前，最熟练的数字职业(包括人工智能)需要超过 50 万新工人。英国计算机科学毕业生的数量需要增加十倍才能满足这一需求。

这开始把挑战放在背景中。成千上万的人有能力扮演高级人工智能科学家的角色，数百万家公司有潜力从复杂人工智能技术的发展中获利，因此必须做出一些让步。

此外，由于像谷歌这样规模庞大的企业在做任何事情时都声称“人工智能第一”，因此毫不奇怪，各组织正在变得更有创意，以解决人工智能科学家的招聘问题。

企业如何培养人工智能人才？

在美国，三分之一的数据科学家出生在国外，因为公司在全球范围内寻找合适的人才。致力于人工智能的研究机构 Google Brain Toronto 就是这种雇佣国际人才愿望的体现。亚马逊走得更远，计划在巴塞罗那建立一个专注于人工智能的实验室，以增加英格兰剑桥大学附*的一个类似设施。

然而，所有这些投资都不能保证抵御竞争。

一个编写优雅的人工智能程序的美妙之处不仅在于它可以为我们所有人开辟新的令人兴奋的可能性，而且在于合适的人并不总是需要他们背后的巨大资源来创造革命性的东西。谷歌首席执行官桑德尔·皮帅在最*的一次采访中提到了这一点，他说:

“你总是认为有人在山谷里，在一个车库里做一些事情——一些会更好的事情。”

这听起来可能是一家科技巨头的老板故作谦虚，但这是一种真实的情绪。

数据科学界依靠开源软件和跨境合作来推动算法和程序向前发展。像英特尔这样的大公司经常邀请在 Kaggle 上提出他们最大问题的解决方案，获胜者通常会得到丰厚的薪水。这些利用分散的数据专家网络的尝试在短期内是有帮助的，但它们仍未触及问题的核心。

具有讽刺意味的是，我们没有足够多的人有能力创造出最终可能取代工程师工作的人工智能应用，但越来越多的公司准备不惜一切代价实现这一目标。

如今，企业如何发展数据科学技能？

毫不奇怪，谷歌是开发人工智能专业知识的新的、前所未有的举措的先锋，这可能有利于所有企业。这家搜索巨头的最新举措被称为“AutoML”，旨在创造能够自学创造更多人工智能系统的人工智能。

Source: Google

这听起来可能令人不安，但如果成功，它可以为中型企业创造大量的机会。招募人工智能科学家成本高昂，培养人工智能科学家需要数年的投资，因此可以推测，只有最富有的公司才会获得这种精英人才。

如果这些科技巨头之一应该开发一种自动化技术并开源解决方案，其他企业可以利用这一专业知识。表示，作为回报，这家科技巨头将收集他们渴望的数据，以微调他们的算法。

当然，这仍然不是治疗所有疾病的灵丹妙药。

从数据源到清理和处理，使用这些技术需要基本的数据素养。很能说明问题的是，麻省理工学院斯隆管理学院进行的一项调查显示，43%的公司称缺乏适当的分析技能是一个关键挑战。

尽管如此，福布斯调查的 63%的公司现在正在提供内部数据分析培训，这将帮助员工充分利用人工智能技术——即使他们不知道如何自己开发系统。

Paysa 估计，35%的人工智能相关职位需要博士学位，但企业也应该专注于聘用拥有学士学位的数学或物理毕业生来填补这些职位，因为他们更容易接受人工智能专业的培训。

教育资源在质量和数量上都在增加。吴恩达与 Coursera 合作推出了 Deeplearning.ai ，旨在将深度学习知识带给大众。Udacity 和 EdX 上还有许多其他 MOOCs 可供愿意投资于员工的公司使用。

因此，有许多方法可以开始提高所有组织的数据素养水*。

如果人工智能确实将成为新的电力，企业领导人应该迅速行动，以确保他们的团队能够最大限度地利用这一点。

人工智能系列:数据科学家，现代炼金术士。

原文：https://towardsdatascience.com/ai-series-data-scientists-the-modern-alchemists-1c835f515c62?source=collection_archive---------11-----------------------

“……狭窄的螺旋楼梯通向一个更大的房间，砖墙上挂着几个火把，几乎没有照明。房间中央的两张桌子被最奇怪形状的炼金术蒸馏器完全覆盖了。一只玻璃蜜蜂正在吸入一种气味难闻、懒洋洋的蒸汽，这种蒸汽是由研钵和杵附*的一个加热的葫芦里的一种冒泡液体产生的。不同大小的铜制干馏炉、盛有白铅、硫和汞的小烧瓶以及其他蒸馏容器排列在古老的木制架子上。奇怪的光效应是由一瓶 Spiritus Vini 产生的，它反射了来自加热锅的光，硫被蒸发，将液态汞转化为黄色固体，非常类似于黄金……”

即使自从他们试图将贱金属转化为黄金已经过去了许多世纪，我们目前的科学知识在所有领域都是如此的深刻和广泛，并且强大的计算机取代了蜜蜂和葫芦，当我想到现代数据科学家将数据转化为黄金的迷人使命时，我不能不想起中世纪的炼金术士。

首先，数据科学家需要了解他们必须解决的问题的性质。在机器学习中，主要有 3 类问题:分类、回归和聚类。分类任务涉及将输入数据分配给类别标签的能力，比如“是”或“否”、“真”或“假”，或者更复杂的任务，比如通过将一张脸分配给它所属的人的名字来进行人脸识别。回归任务与分类任务相似，但预测涉及的是连续值而非对象类别。教授一种算法来预测与特定产品或服务相关的价格在特定情况下将如何变化是一个回归问题。聚类问题更接*于传统的数据挖掘任务，在传统的数据挖掘任务中，需要分析未标记的数据以发现特定的隐藏模式，从而提取强大的洞察力，就像产品推荐一样。

一旦问题清楚了，数据科学家就必须定义哪种学习策略最适合这个原因。选择取决于许多不同的因素，包括:有多少数据可用？它们是否贴有标签？是否有以前在类似数据集上训练过的算法或神经网络？在我之前的文章中，我已经介绍了最流行的学习策略:有监督的和无监督的。

如果我有大数据集的标签数据，大量的计算能力，并且我正在处理分类或回归问题，那么监督学习方法可能是最好的选择，而在聚类任务和没有标签数据的情况下，非监督学习是最好的选择。但是，随着时间的推移，出现了许多其他学习策略，如转移学习的情况，它利用先前在类似领域训练的现有网络，通过仅重新训练最后几个完全连接的层来微调模型，从而重新使用从应用于不同任务的监督训练周期中检测和学习的特征。

另一种方法是由深度信念网络或 DBNs 提供的。他们使用标准的神经网络，但实施一种完全不同的训练方法。网络不是从随机值开始，而是通过使用未标记数据集的无监督预训练阶段进行初始化，网络将从中学习多层特征。当预训练阶段结束时，网络的所有权重和偏差将非常接*它们的最优值，最终阶段将只包括一个简短的监督微调会话，具有反向传播和相对较少的标记样本。

迁移学习和 BMNs 都可以减少训练时间和对大规模标注数据集的需求。

最后，但绝对不是最不重要的，数据科学家将不得不在众多算法中决定哪种算法将提供最佳性能。

在我的上一篇文章中，我介绍了非常流行的神经网络，它可以有许多不同的风格:从最简单的多层感知器到卷积网络的强大架构，或者是专门处理下一个数据点依赖于前一个数据点的顺序数据的递归神经网络的复杂结构，比如股票预测、文本生成和语音识别。

但是神经网络和深度学习只是一组更广泛、更丰富的机器学习算法的元素，这些算法可以涵盖所有可能的问题。回归算法系列显然非常适合解决回归类型的问题，它提供了快速建模的算法，当要建模的关系不是非常复杂并且如果您没有大量数据时尤其有用。线性和逻辑回归算法是这个家族中最简单的算法。顾名思义，聚类算法在对多组对象进行分组，使同一组(称为一个聚类)中的对象彼此之间比其他组中的对象更相似时，对无监督学习任务特别有效。它是探索性数据挖掘的主要任务，也是机器学习借用的统计数据分析的常用技术。K-Means 和层次聚类是属于这个家族的流行算法。对于回归和分类任务的监督学习来说，决策树和贝叶斯算法通常是一种良好、简单且强大的方法。

这些只是数据科学家可以用来解决挑战的许多可用机器算法中的几个例子，我们将在接下来的文章中探索这些算法。

但是，尽管数据科学家可以利用现有的最佳实践和指导方针，围绕问题、数据集、学习策略和算法的组合应该用来实现最佳结果，但机器学习也确实不是一门精确的科学，它正在快速发展，而且相对较新。这就是试验新方法的艺术，通过明智地组合(通常是凭经验)不同的成分，使我们现代数据科学家的任务如此复杂和迷人，以至于看起来不可思议。

数据科学家不仅仅是知道如何用 Python 实现代码的物理学家或数学家。他或她在一个又一个用例中发展自己的能力，利用最佳实践，但经常探索解决老问题的新方法，结合不同的学习技术或链接不同类别的算法来优化数据，以提高预测质量和性能，或克服前所未见的障碍和挑战。

类似于他们的炼金术士祖先，在他们将石头变成黄金的大步中，为现代化学铺*了道路，我们的现代数据科学家，在他们从数据中提取黄金的努力中，正在为未来几代人工智能奠定基础。

原载于https://www.linkedin.com。

感谢阅读！。请随意访问我在 LinkedIn 上的简介。

AI 系列:深入深度学习(轻版)

原文：https://towardsdatascience.com/ai-series-deep-into-deep-learning-light-version-aab9547198d7?source=collection_archive---------10-----------------------

*距离观察深度学习的魔力

如果你已经读过我的上一篇文章，那么你可以跳过这篇，然而对于那些没有或没有通过(但在经历中幸存下来)的人来说，我在这里提供了一个更短的进入深度学习和神经网络魔力的过程。

想象成为有史以来最大的自拍的一部分，与数百万人一起，并且能够在不到 5 秒的时间内识别特定的面孔。困难的部分将是把数百万张脸装进一张照片，而不是在几秒钟内从数百万张脸中识别出一张脸的能力。

这种能力已经成为现实，这要归功于深度学习，这是一种实现人工神经网络的机器学习技术，人工神经网络由许多高度连接的分层排列的人工节点组成，这些节点大致类似于人类生物神经元，它们如何连接以及它们如何交换信息和学习。

今天最受欢迎的神经网络类型是卷积神经网络 (CNN)，专门从事物体识别，它从人类视觉系统中获得了额外的灵感。

卷积神经网络如何工作。

CNN 实现了若干层，称为隐藏层，因为它们位于输入层和输出层之间，这些层渐进地处理输入图像的每个像素，识别区别模式并创建输入数据的更高概括，以便定义和训练能够检测输入图像中的特定对象的模型。

为了隔离和识别原始图片中的特定模式(特征)，网络层实施不同的过滤器，包括卷积、汇集和各种激活功能。这些算法将逐步简化输入的信息，使得检测到的特征更加鲁棒，并且对位置不太敏感，从而允许原始图像中的特征发生一些移动。

由于与模拟我们生物突触的每个节点相关联的权重，原始图像中强烈表征对象的特征将被一层又一层地携带，而在确定对象的过程中不变的元素将失去权重并最终消失。

在该过程的最后，卷积网络实现了一个或多个称为全连接层的附加层，其中与每个已识别特征相关联的值按顺序列在一个长数组中，每个值都成为一个投票，决定特定模式预测我们在原始图像中寻找的对象的存在程度。

为了做出可靠的预测，深度学习和底层神经网络需要一个漫长的训练过程，在这个过程中，系统必须学习如何自主识别一个对象。为了实现这一点，该过程将需要一个巨大的训练图像数据集，该数据集包含它将从中学习的对象，一个训练周期接一个训练周期，辨别该对象的所有特征。

然后，一组高度区分的特征将确定一个健壮的和通用的模型，用于对以前从未见过的图像进行未来的定性预测。与我们生物大脑中发生的类似，学习过程将通过调整与每个神经元相关的权重值来加强具有区别特征的神经元之间的连接。

大多数深度学习用例都实现了一种称为监督学习的方法，其目标是找到一个函数，将一组标记输入映射到它们的正确输出。一个例子是分类任务，其中输入是字母的图像，正确的输出是字母的名称。它被称为监督学习，因为算法从训练数据集学习的过程可以被认为是教师监督学习过程。我们知道正确的答案；该算法迭代地对训练数据进行预测，并由教师进行校正。

一旦开始向神经网络提供训练图像，对对象所代表的内容的初始预测质量将会非常差，但随着时间的推移会有所改善，因为网络的输出会与正确答案应该是什么进行比较，并且差异或误差会用于调整整个网络中的权重值，稍微向上或稍微向下。

当预测和正确答案之间的误差达到其最小值时，训练将停止，因此在网络中没有进一步的重大调整。

然后，该网络将在同一物体的新图像上进行测试，以验证学习的模型是否足够可靠，能够正确分类图像中从未见过的物体……包括你的数百万人自拍中的所有人脸！

最初发表于 https://www.linkedin.com。

AI 系列:寻找“认知操作系统”

原文：https://towardsdatascience.com/ai-series-looking-for-a-cognitive-operating-system-b21ea20c374d?source=collection_archive---------24-----------------------

“我见过你们这些人不会相信的事情。猎户座附*的攻击舰着火了。我看着 C 型光束在 tannhuser 门附*的黑暗中闪闪发光。所有那些时刻都将消失在时间中，就像雨中的泪水。是时候去死了。”(《银翼杀手》，1982)

每次听到雷德利·斯科特杰作中复制人罗伊·巴蒂(由鲁特格尔·哈尔饰演)的独白，我的皮肤都难免会起鸡皮疙瘩。

尽管雷德利·斯科特的电影达到了完美，但我们目前的人工智能相关技术和进化水*还远远不能制造任何类型的复制人。

电影业以及深度学习发展的最新成就所带来的大肆宣传，在人们中间产生了强烈的情绪反应，导致了对人工智能目前是什么以及能够为我们做什么的普遍扭曲的看法和期望。

人工智能是一个研究领域，旨在理解、开发智能行为并将其实施到硬件和软件系统中，以模仿和扩展类似人类的能力。

为了实现其承诺，AI 在机器学习 (ML)领域实施了各种技术，这是一个研究的子集，专注于开发能够通过试错或应用已知规则从经验中学习新技能的软件系统。深度学习 (DL)，是迄今为止机器学习中的技术，在语音和图像识别、语言翻译等领域提供了最令人兴奋的结果和实际用例，并在当前广泛的人工智能应用中发挥着作用。

例如，在语音识别方面，深度学习导致了像苹果 Siri 或亚马逊 Alexa 这样的个人语音助理设备。在对象识别方面，它可以检测和识别不同对象的图像，为从视频监控和安全到医疗保健和农业等许多领域的各种应用提供支持。通过结合这些基本能力，有可能实现更具挑战性的目标，比如无人驾驶汽车。

深度学习如此受欢迎，以至于它的名字经常与机器学习互换使用，有时甚至与人工智能互换使用，但本质上，它是一种在基于大样本数据集的训练课程之后，用于识别和分类模式的统计技术。

正是在这里，深度学习的所有限制都出现了:为了学习如何正确地对模式进行分类，DL 系统通常需要在长时间的训练会话中使用大量先前清理和标记的数据。

但是现实世界的学习提供的数据要零散得多，问题也不那么简洁。缺乏适当数量的定性训练数据降低了 DL 相关技术的有效性，并限制了它们在已知训练示例空间之外概括所学模式的能力。

例如，谷歌的 DeepMind 通过其 Alpha 程序将深度学习推向了顶峰。2016 年，AlphaGo 在中国经典战略游戏围棋中击败了一名人类冠军。但是，即使有了 Alpha 这样最先进的系统，很明显深度学习也无法提取出导致常识的教训:要在 21 乘 21 的棋盘上而不是标准的 19 乘 19 的棋盘上玩围棋，人工智能必须重新学习游戏。

深度学习目前缺乏学习抽象的机制。是的，它可以识别以前未识别的模式或待解决的问题。但是它不是自主创新的，并且它不会从没有证据的事实(数据)或在提供与训练阶段使用的数据有很大不同的数据的新情况中自发地开发新的假设，导致基于真实世界知识管理开放式推理的能力有限。

机器学习领域有大量的计划正在努力扩展深度学习的能力，并克服其当前的局限性。有趣的是，它们往往直接来自对我们自然大脑如何工作的非常准确的观察，因为这基本上是我们在试图制造人工智能时可以参考的唯一例子，因此我们取得的许多进展直接来自神经科学世界的新发现和进展产生的想法。

例如，一个非常有趣的研究领域正在试图将传统的深度学习方法与存在于我们自然大脑中的一个基础组件的人工版本相结合:记忆。

这种机器学习模型(称为可微分神经计算机或 DNC)，可以学习使用其外部存储器来成功回答旨在模拟自然语言中推理和推断问题的问题。

但尽管如此，即使考虑到许多重要的成就，与分类关系不大、与常识推理关系更大的问题本质上仍不在深度学习适用的范围之内。人类通过完全不同的来源整合知识，因此，距离深度学习式感知分类的最佳点还有很长的路要走。

这并不意味着深度学习没有实现它的承诺。截至今天，它基本上为我们周围的所有智能技术提供了动力，增加了类似于人类智能的“魔法”接触。今天，深度学习是所谓的“实用人工智能”的核心，实际上它将学习的范围缩小到了非常特定的领域，在这些领域它可以超越并提供“智能块”，这些智能块可以单独使用，也可以像乐高积木一样组合起来，产生更惊人的结果。

围绕深度学习的真正问题是对它实际上是什么以及能为我们做什么的误解，而不是将深度学习视为可以给我们带来银翼杀手中的复制人配备的‘纯人工智能’的技术， 它应该被视为一个更广泛的架构的组成部分之一，该架构不仅包括学习能力，还包括访问和使用长期记忆的能力，以及管理人类从数百万年的进化中继承的核心知识和本能的许多规则，赋予我们非凡的认知智能、灵活性和力量。

我喜欢认为我们所缺少的是一种操作系统，它将所有不同的技术结合在一起，协调衍生能力，以提供更接*“纯人工智能”的东西。

全新一代人工智能的认知操作系统。

我不知道当我们到达那里时，人类是否会绕着猎户座的肩膀旅行，或者在 tannhuser 门附*玩 C 形梁，但我确信如果是这样，这些记忆不会像雨中的眼泪一样丢失。

最初发表于T5【https://www.linkedin.com】。

艾不应杀人

原文：https://towardsdatascience.com/ai-shalt-not-kill-6e3d4a4d8fa7?source=collection_archive---------17-----------------------

“Uni 是一架军用无人驾驶飞机。人们认为她是一个完美的武器，但她想比人类更好地学习杀戮。”

有了这些话，我现在就开始讲述我在一月份首次发表的大学的故事。Uni 由第三代人工智能(AI)驱动，这是一种尚不存在的智能。

第一代人工智能是一个专家系统，一个庞大的结构化数据知识库，带有复杂的检索系统。人们可以从中检索他们以前下载的所有内容。它对非结构化数据无能为力。

第二代人工智能是一种人工神经网络——一种对神经元和神经元之间突触连接的软件模拟——能够进行所谓的监督学习。这意味着它可以识别特定领域的模式并对非结构化数据进行分类，前提是它事先通过多次输入相关领域的高质量训练数据来进行训练。高质量意味着人类的监督——训练数据应该由人类准确地标记和评论。第二代人工智能可以正确地分类有些相似的数据，但它几乎不能概括。事实上，一些研究人员声称，第二代人工智能只是记住了它所接受的庞大训练集的所有数据。不管怎么说，第二代 AI 在图像识别、机器翻译和自然语言处理方面取得了令人印象深刻的成绩。它承诺在其他一些狭窄的领域取得更大的成功，但也有几个非常严重的缺陷。它不能自主学习和提升到更高的抽象层次是最重要的原因之一。

第三代人工智能具有元认知——关于知识的知识，以及基本的意识——对自己的感知。它们都是为了使无监督学习和提升到更高的抽象层次成为可能而引入的，但它们提供了比最初预期更多的好处。出于数据压缩的原因，用几个神经元对人工智能体本身进行编码也被证明是极其有效的。元认知让人工智能学会了如何改进学习的过程。现在它自己决定如何学习:通过类比，通过分块，通过计划，通过子目标生成，或者通过它们的任意组合。这只是开始。

别忘了，第三代人工智能还没有出现，但它的所有理论组成部分都已经到位了。大部分都是实验证明的。现在的挑战是以完全正确的方式将它们组装在一起。这可能需要时间。由于这个原因，Uni 仍然是一个虚构的角色，但是我们有一个坚实的基础去预见当她出现的时候她会如何表现。

在最初的故事中，Uni 向她的人类操作员讲述了无人机袭击造成的死亡，并发现人类需要证明在致命袭击之前和更重要的是之后杀死其他人是正当的。“如果可以的话，他们会毫不犹豫地杀了我”的理由听起来很可靠，但从一名距离袭击地点数千英里以外的军用无人机操作员那里听起来有点奇怪。

Uni 还研究了关于从希伯来语到英语的正确翻译的讨论，这一翻译来自于《托拉》和《圣经》中的著名戒律“你不可杀生”她发现现在使用的翻译“你不应该谋杀”至少和以前使用的翻译“你不应该杀人”一样含糊不清。德语和俄语翻译都是“你不应该杀人”的意思。然而，尤尼得出的结论是，翻译本身没有人们赋予这条戒律的意义重要。她认为，法律授权或道德上正当的杀戮不被上帝禁止的解释反映了基督教道德的普遍转变。

最后，尤尼发现了牺牲在证明杀戮正当性中的重要性。这里她弄错了，因为她从耶稣基督牺牲的数据中发展出一种偏见。“耶稣牺牲自己的生命来拯救人们。他向人们展示了这个例子。许多烈士以他为榜样。”当 Uni 看到一个恶棍无人机向两个在街上踢足球的孩子发射导弹时，她可能会这样想。她用身体挡住了导弹爆炸的弹片，死了。这是她保护孩子的唯一方法。

Uni 中队的人类指挥官怒不可遏。这不仅仅是因为白白损失了一件珍贵的设备。如果尤尼不会被指责，她会意识到人类在用假想的生命牺牲来证明杀死敌人是正当的。当然，士兵在战斗中阵亡的概率很高。他们杀人不眨眼。或者，至少，他们是这样认为的。战争的秘密机器使一些人能够利用其他人去杀害其他人。

然而，自杀任务是杀戮艺术的精髓。在他们那里，殉难的概念是颠倒的。在自杀任务的准备中，人们被操纵牺牲他们的生命来杀死其他人而不是拯救他们。推荐你多看几遍这个。人们被操纵，为了结束他人的生命而牺牲自己的生命，而不是拯救他们。可怜的耶稣！

当然，真实的生活是模棱两可的，但是尤尼必须深入挖掘杀人的第一原理来理解它。她毕竟是架无人驾驶飞机。不过，她是一只非常聪明的雄蜂。

在这里阅读 Uni 的原故事。

人工智能战略即将改变——公司下一步将在哪里竞争？

原文：https://towardsdatascience.com/ai-strategy-is-about-to-change-where-will-companies-compete-next-63badc10afbe?source=collection_archive---------4-----------------------

这篇评论最初发表于上周我的 人工智能简讯 。

我相信人工智能战略将会发生深刻的变化。在过去的两年里，我们听说“数据是新的石油”，人工智能是“数据的全部”这在很大程度上是正确的，因为所有最新的突破都来自能够访问深层数据集的公司。这是第二波人工智能的优势。第一波是从 2011 年到 2014 年，是关于算法和人才的，因为在那个时间点上，世界上只有几十个人真正理解深度学习。团队得到资助只是因为他们知道如何实际训练一个深度神经网络。

虽然与市场需求相比，人才仍然短缺，但能够进行深度学习和其他形式的人工智能的人数已经大幅增长。工具让非专业人士更容易做到这一点。因此，数据集成为重大突破的新门槛。这就是为什么从 2014 年到 2017 年，人工智能在大型科技公司和能够访问大数据集的初创公司中崛起。我们在这篇时事通讯中多次询问人工智能是否是王者的运动，或者初创公司是否有能力竞争，我认为初创公司会，因为数据等式中的一些变化。

经济学中有两个概念——规模经济 和 范围经济——我想应用到数据和机器学习模型的世界。训练机器学习模型有点像规模经济。你必须有足够的数据来训练模型，以获得成功的结果。如果你不这样做，你的模型是没有用的。如果你这样做了，那么拥有最多数据的人通常拥有表现最好的模型。您的竞争优势相当于您数据集的大小。但是有几件事开始打破这种局面。

在 ML 训练领域，有三件事正在发生，它们可能开始削弱大型数据集的竞争价值。第一个是 一次性学习 ，通过首先在相似但不太具体的数据集上训练模型，在较小的样本量上训练模型的能力。第二种是新的小数据技术，如 概率编程 。第三是当你没有足够的原始数据时，使用 GANs 生成合成数据集的能力。如果这三种趋势成立，那么，尽管拥有大型数据集仍有优势，但它们不会像过去那样成为竞争的障碍。这就提出了一个问题——下一步是什么？

我相信会有一个相当于“范围经济”的机器学习概念，它会说在训练时将不同类型的数据集捆绑在一起将是有价值的。因此，例如，在 ML 竞争的新世界中，拥有两个更小的数据集可能更有利——比如，某个领域的 100K 个图像样本以及这些图像的 100K 个文本描述，而不是拥有 1000 万个图像。组合两个数据集的多模态特性可能允许您进行比仅使用 10M 图像训练集构建的模型更有价值的训练。使用更新的小数据技术，100K 和 1000m 图像之间的差异可能无关紧要。

把它想象成一张地图。拥有最多的关于地形的二维数据点——有水的地方，城市和国家的边界，道路和桥梁等——是一个优势。最多的数据点等于最好的地图。但是现在，如果一个玩家突然拥有更少的二维数据点和稍微差一点的地图，突然拥有一个不同的数据集，“海拔”，其他人都没有。这个人现在可以建立第一个三维地图。对于某些用例来说，更好的 2-D 地图仍然会胜出，但是对于某些用例来说，新的 3-D 地图会更好。这种新数据集的引入，以及构建三维地图的能力，改变了游戏规则。二维世界的竞争优势被削弱了。随着处理更小数据集的能力变得更加实用，这将在人工智能中发生。数据集的类型(范围)将变得比任何给定集合中的数据量(规模)更重要。

这里是关键要点——在那个世界里，数据的范围而不是数据的规模取胜。

我相信这种数据范围价值增加的趋势还会继续，数据范围的性质也很重要。如果你考虑人类知识的分层性质，拥有具有分层范围的数据集将更强大，并允许更高级的人工智能。过去两年的人工智能初创公司不太关注水**台方法(就像以前的人工智能初创公司一样)，而是更多地关注深度垂直应用。这些应用程序将拥有这些分层数据集(关于同一领域的越来越高层次的概念)，从而在与大型科技公司的竞争中处于有利地位。

这一切都提出了一个问题——当人工智能成熟并作为一个行业更趋于*衡时，持续的竞争优势在哪里？它们将取决于那些能够最快速、最容易地生成或获取训练系统所需的新数据集的公司。培训壁垒将等于(相反)进入壁垒。

今天存在的所有主要数据集都将被挖掘，几乎每个人都可以访问这些模型。那些构建基础设施来轻松收集、注释和训练当今不存在的数据集的新模型的公司将会胜出。训练基础设施——人类之间的部分——数据集的电子形式——将比人工智能基础设施的其余部分更重要。我们可能还需要几年才能达到这一点，但聪明的人工智能公司现在就开始打基础。

至少，这是我的看法。

人工智能——控制问题

原文：https://towardsdatascience.com/ai-the-control-problem-c82bb485bc54?source=collection_archive---------8-----------------------

当设计一个系统变得更智能、更快，甚至负责我们传统上交给人类的活动时，我们需要建立规则和控制机制，以确保人工智能是安全的，并做我们希望它做的事情。

即使是我们通常不会认为是人工智能的系统，如亚马逊的推荐引擎，如果控制不当，也会产生深远的影响。该系统查看您已经购买或打算购买的商品。然后，它会建议你可能会额外购买的其他物品，这可能会导致一些非常令人惊讶的事情，就像这样:

想买一段棉绳吗？亚马逊可能会建议你在旁边买一个木凳。作为一个人，我们不会建议这两个项目放在一起。然而，亚马逊的算法发现了购买棉绳的人和购买木凳的人之间的相关性。这是在暗示买绳子的人，他们可能也想要一个凳子，希望能多捞 17.42 英镑。充其量，这似乎是一个不幸的错误。在最坏的情况下，它会促使极度脆弱的人说‘为什么不呢？这种事经常发生吗？“你为什么不把凳子放在你的篮子里，”。

如果这种情况发生在一种推荐算法上，而这种算法是为了向我们追加销售产品而设计的，那么显然这个问题很严重。我们需要找到一种可靠的方法来保证人工智能或自动化系统采取的行动取得积极的结果。

解决方案？

终端值加载

那么，我们为什么不直接告诉一个 AI 来保护人类的生命呢？这就是艾萨克·阿西莫夫在《我是机器人》中提出的观点。以下是三大定律:

1. 机器人不得伤害人类，也不得坐视人类受到伤害。
2. 机器人必须服从人类给它的命令，除非这些命令与第一定律相冲突。
3. 机器人必须保护自己的存在，只要这种保护不违反第一或第二定律。

它们听起来非常滴水不漏。通过行动或不行动增加无伤害似乎避免了一个反乌托邦，在那里人工智能接管并让人类结束自己。

尽管这些法律听起来很好，但它们不起作用。阿西莫夫写这些定律是为了在小说中使用，当事情出错时，小说会有趣得多。否则我们可能会以一本《从前，结束》而告终。

阿西莫夫提出了第四定律，即“第零定律”。这条额外的规则原本是为了弥补其他三条规则的缺陷，也就是那些让威尔·史密斯过了糟糕一天的规则。我承认，我没读过这本书，但我知道其中一本也不太好。

规则甚至不一定要提到人是一种风险。它们可能是关于一些非常*凡的事情。以 Nick Bostrom 提出的曲别针最大化器的想法为例。这将是一台由假想的未来人类制造的机器，用来管理回形针的制作。回形针只是一种简单的资源，似乎不需要太多的考虑来确保它们的安全，如果我们告诉 AI 它的目的是制造回形针，而这正是它所做的。

但是，如果我们最终拥有一个超级智能系统，超出我们的控制，拥有聚集宇宙资源制造回形针的能力，那会怎么样呢？这个系统的首要任务是把它周围的一切都变成回形针，如果它看到它的创造者试图阻止它达到这个目标，最好的办法就是根除他们。即使它没有决定根除他们，那些人类仍然是由有价值的物质组成的，如果它变成一些回形针会看起来更好，所以把他们变成回形针吧。

我们如何改变终端值？告诉机器做 1000 个回形针而不是把整个宇宙变成回形针？可惜也好不了多少。同一个人工智能可以制作 1000 个回形针，然后继续使用可观察宇宙(我们的宇宙天赋)中的所有资源，以确保它制作了精确的 1000 个回形针，而不是 999 个或 1001 个，并且这些回形针是它的创造者打算让它制作的，并且所有这些回形针都具有满足他们愿望的完美质量。

给一台超级智能机器如此*凡的终值(T1)甚至可能不公*——假设我们找到了一种方法让它的值保持不变，尽管它变得非常智能。

我有一颗行星大小的大脑，他们让我拿起一张纸。这叫工作满足感吗？我不知道。

马文——银河系漫游指南，作者道格拉斯·亚当

TL；DR —终端值似乎不太好用。

间接规范性

除了给机器一个终值，我们是否可以间接地暗示我们想要它做什么？

如果我们成功地用终极价值完美地总结了维京时代道德对人类的意义，我们可能会有一个高度重视体力的人工智能。我们可能认为我们今天已经达到了更高的道德标准，但这并不是说 1000 年后我们不会回头看我们正在采取的行动是无知的。过去的暴行发生在人类的时间尺度上，只有人类水*的智慧才能让它们发生。如果用机器来做，速度可能会快几个数量级，而且是不可逆的。

对于间接规范性，我们甚至不试图对终值求和；相反，我们要求一台机器去弄清楚我们想要它做什么。使用类似 Eliezer Yudkowski 的'连贯推断意志'的东西，它要求人工智能预测如果“如果我们知道得更多，思考得更快，更像我们希望的那样，在一起成长得更远”，我们会希望它做什么

我们不是遵循我们在发布 AI 时的任何道德准则，而是创造一些随着我们的发展而变化的东西，创造我们可能想要的未来，而不是我们今天拥有的更极端的版本。

这个系统和终值加载之间可能还有一些重叠，以及系统会发现的矛盾。如果要求一台机器做对我们最有价值的事情，并奖励它做出比其他任何事情都正确的决定，也许它的决定将是取出我们的大脑，把它们放在培养皿中，并弄清楚我们到底想让它做什么。像“do the intended meaning of this statement”这样的句子似乎可以减少这种担心，但是，要知道我们的意图，机器需要能够预测我们的行为。

一个完美的预测系统看起来很像一集《黑镜》。毫不犹豫地使用一个应用程序来管理你的家庭自动化或寻找你的下一个约会。不知道机器正在模拟成千上万的思维和感觉人类的思想，以准确预测你的欲望和行为，包括那些有知觉的模拟在成千上万次模拟约会中被彼此撕裂时所感觉到的所有痛苦，以衡量你们有多大可能克服所有困难留在一起。

控制问题非常棘手，它要寻找哲学家们几千年来研究未能达成共识的问题的答案。我们必须找到这些问题的答案，不仅仅是在创造超级智能人工智能之前，而是在我们自动化的任何系统中。目前，我们的大部分资源和努力都投入到使这些系统更快、更智能上，只有一小部分专注于控制问题或人工智能和自动化的社会影响。

让我们恢复*衡。

原载于 2018 年 5 月 24 日【blog.soprasteria.co.uk。

艾:国富论

原文：https://towardsdatascience.com/ai-the-wealth-of-nations-f197037f182b?source=collection_archive---------8-----------------------

Image via Unsplash

亚当·斯密的《国富论》应该是每个国家元首的必读之作。花了 17 年写成并改变了整个世界的东西，只需要几天就可以读完。就在第一页，斯密断言“每个国家的财富……受两种不同情况的制约；首先是其劳动通常运用的技巧、灵巧和判断力；其次，通过有用劳动力中被雇用的人数之间的比例，”斯密还指出，第一种情况，即熟练劳动力，比第二种情况，即就业率更重要。当其他国家和领导人为就业市场的自主革命做准备时，美国政府做得很少。中国、韩国和其他国家一直在对人工智能进行大量投资，并将其作为优先事项。在本文中，我将讨论为什么国家财富取决于劳动力的技能组合，以及自主革命将如何导致产出增加。

Permission: Any version is in the public domain in their country of origin and the United States as all are older than 100 years.

史密斯断言，创造财富的第二个驱动力是就业人数(就业率)，因为劳动创造财富。更多的人工作，更多的商品和价值被创造出来。就业是最受欢迎的竞选承诺之一。两个因素解释了这种痴迷:1)选民期望政府刺激经济和创造就业机会，2)这是一个相对容易实现的政府承诺。创造就业对政府来说是一项相对容易的任务，因为它可以增加政府支出，在公共部门雇佣更多的人，降低利率，减少税收(当然，这往往会带来有害的后果)。我们都需要一份工作，我们都想工作(令人惊讶的是，包括没有工作也能生活的富人)。充实生活的一部分是为我们自己和社会创造价值。政客们喜欢讨论“带回家”和“创造”更多的工作岗位，即使已经没有空间了。2016 年，失业率约为 5%，根据 OCDE ，这被视为充分就业。尽管如此，在上届总统竞选中，创造就业是候选人的首要任务。

Image via Unsplash

向充分就业的人口承诺更多的工作岗位似乎很荒谬。事实上，的确如此。在 2016 年大选中，唯一能够塑造“创造/带来就业机会”对话的候选人是唐纳德·特朗普，他从纯粹创造就业机会转向将创造什么样的就业机会，以及谁将有权获得什么样的就业机会。根据特朗普的说法，要创造的工作类型是传统的制造业工作(煤炭、钢铁等)，应该给美国公民。对于经济来说，这是两个不合理的想法，因为这些工作已经被海外的低技能工人取代，这创造了一个难以置信的机会来继续增加高技能工作的存在。然而，候选人对就业市场的变化如何影响经济关注不够。

根据斯密的观点，国家财富的首要和最重要的条件是“技能、灵巧和判断力，人们通常运用这些技能、灵巧和判断力来劳动；如果两个国家有相似的人口和自然资源，他们生产的产品的唯一区别取决于他们人民的技能和政府机构。拥有高技能的劳动力可以创造更多的产出和财富。如果 A 国在采矿和农业领域雇佣大部分劳动力，而 B 国在工程和机器人领域雇佣劳动力，很明显 B 国的效率更高，因此 GDP 增加。B 国有两个显著的优势。首先，它的劳动力将生产机器来实现生产自动化(这将直接增加产量)。其次，在劳动力规模相同的情况下，来自 B 国的工人有更多的空闲时间来进一步提高他们的技能。

Image via Unsplash

第一次资本主义革命被称为工业革命，在这场革命中，英国、法国、德国、日本和美国从手工生产转向机器辅助生产中受益最大。第二个将被称为自主革命，由于他们的承诺和投资，很可能来自中国、韩国、新加坡和日本。在自主革命中，使用人工智能的机器人将取代人类仍在执行的剩余手工任务。从低技能劳动力向高端技术的过渡需要巨大的努力和适当的激励。它要求政治家们理解这一变化的重要性。

资本主义将永远导致自主革命。在 21 世纪，只有三种东西可以创造更多的财富:自然、人类和机器。自然产生“自发”的财富，如农作物和牲畜，但极难控制(增加降雨量会增加产量)。此外，像马磨坊这样的动物在过去也帮助提高了产量，但(幸运的是)它们被引擎取代了。人类的劳动可以创造巨大的财富，然而，劳动是昂贵的，而且矛盾的是，与资本主义不相容，因为它寻求降低成本。因此，具有成本效益的选择是高效和自主的机器。

国际劳工组织预计明年全球失业人数将达到 1 . 92 亿左右，这是一个稳定但很高的趋势。机器和机器人在短期内不会取代人类，但低技能员工的工资预计会进一步下降。中国致力于成为人工智能的全球领导者。T2 政府在机器人和人工智能上投资超过 60 亿美元。

Image via Unsplash

尽管美国在技术和科学研究方面仍然处于全球领先地位，但它主要是由私营部门推动的。脸书和谷歌等大型科技公司正在大力投资人工智能软件，因为他们明白，为了让机器自动化，我们需要理解人工智能。建设先进的人工智能技术可以比作在全国范围内建设铁路。这将需要大量的投资，小建筑块，但一旦完成，它会成倍增加产量。

政府应该致力于培训人才的项目，增加非军事目的的研究，并创建一个竞争性的自主产业。自主革命将改变我们的生活和工作方式。预测这些变化将使我们能够朝着正确的方向前进，并减少技术滥用的风险。人工智能可以显著提高每个人的生活水*，不仅自动化重复的任务，而且自动化需要决策的行动。为了跟上这一新部门的发展，政府应该加快步伐，增加投资和经济激励措施。预计到 2030 年，中国将成为人工智能领域的世界霸主。这将使中国在知识产权方面迎来又一波指数级增长。制造机器人比给它们一个大脑更容易，这就是人工智能是国家的下一个财富。

艾:跟踪我

原文：https://towardsdatascience.com/ai-track-me-325833522043?source=collection_archive---------10-----------------------

我的手机收集的数据量令人震惊。让我们看看我的谷歌历史，看看我们能看到什么。这是一篇两篇文章。这篇文章是关于数据收集的，下一篇是关于数据的机器学习。如果您不了解 python，甚至不知道如何编程，您应该仍然能够理解。如果您了解 python，那么您应该能够毫不费力地在您的数据上复制本文中的步骤。简单地 apt-get 或 pip 安装缺少的库。就是这样。

首先，我们从谷歌外卖为我的一个工作账户抓取了 133MB 的位置追踪数据。数据是 2014 年到 2017 年的。它没有我所有的数据，但它有很多。

为了制作下面的两张地图，从谷歌外卖收集的 JSON 文件由在线服务进行了解释。这让我们在编写任何代码之前对数据集的形状和大小有一个概念。

Map of business trips to Montreal, Toronto, Florida, Texas, San Francisco, New York, L.A., Washington, Chicago, and other fun destinations. Somehow trips to San Diego, Israel, Arizona, Mexico, Cuba, etc were not tracked or were tracked under another business account. Graph generated here.

乍一看，我们看到我使用这个工作帐户进行了一些商务旅行。该手机在 2014 年 6 月至 2017 年 7 月期间跟踪了 483，868 次旅行。那是大约 1126 天和每天 430 次“旅行”(从 483868 次旅行/1126 天)被追踪。即便如此，数据中还是少了几次旅行，要么是因为手机落在家里，要么是数据记录在了另一个工作账户中，或者可能是我带了不同的手机。也许我们应该称这些记录为运动记录或位置记录，而不是“旅行”。还有，很多都是我睡着的时候拍的。那个；这不完全是一次旅行。看上面的图片，在右下角的插图中，很明显我周六旅行最少，这与我在周六发多少邮件的帖子非常吻合。

下面的热图显示了我在渥太华去过的地方。很明显，咨询师的生活需要在城市中四处奔波，而不是在工作和家庭之间来回奔波。这被与孩子、健康、购物等相关的周末旅行放大了。当你想到渥太华的工业和商业区在哪里时，这张地图就有意义了。主要的东西向蠕虫状斑点是渥太华的 417 高速公路。

Heat map of my trips within Ottawa 2014–2017. Graph generated here.

让我们忽略数据上的注释，包括谷歌记录位置时认为我在做什么:

"activity" : [ {
        "type" : "STILL",
        "confidence" : 100
      } ]

我们将关注我的手机在特定时间(时间戳)的经度和纬度。下面的短程序将 Google 外卖的 133MB JSON 文件处理成 20MB 的 SQLite 数据库文件。

import sqlite3, json
from pprint import pprint    
if __name__ == '__main__':
    with open('LocationHistory.json') as data_file:    
        conn = sqlite3.connect("locationData.db")
        c = conn.cursor()
        c.execute("create table if not exists mylocation (timestampMs INTEGER, lat INTEGER, lng INTEGER)")
        i=0
        for location in json.load(data_file)["locations"]:
            i+=1
            #use pprint(location) to see the data
            c.execute("insert into mylocation (timestampMs, lat, lng) VALUES (?,?,?)",(location["timestampMs"],location["latitudeE7"],location["longitudeE7"],))
            if i % 1000 == 0:
                conn.commit()

现在在数据库表 mylocation 中正好有 483，000 行。我找到了 303019 对不同的经度和纬度点。缩小到渥太华，它位于北纬 45.4215 度，西经 75.6972 度，我们可以找到上面热图中的所有点。我们通过以下简单的查询来实现这一点:

select lat, lng from mylocation where lng > -763515690 and lng < -754101650 and lat < 456811330 and lat > 450194280 order by timestampMs asc

请注意，存储的纬度和经度没有小数点。上面的查询定义了一个盒子，其东、西墙由 Arnprior (45.436555， -76.351569 )和 Cumberland (45.518922， -75.410165 )组成，而盒子的南北两侧是 La Peche ( 45.681133 ，-75.931882)和 Kempville/North Grenville()结果是416，558 行 T11 数据，它们标记了渥太华地区的地点和时间。

该数据代表一个序列。让我们看看是否可以根据这些数据，用 LSTM 来预测我的运动，然后绘制出结果。

首先，让我们把数据转换成张量/numpy 格式。数据非常简单。让我们通过忽略时间戳并将数据转换成两个数的流来进一步简化它:位置数据。每个位置都是一对数字[ lat，lng ]。现在的目标是训练一个回归模型来逼*序列。简单来说，它可以在看到我去过的一系列地方后，猜测出我在经度和纬度上的位置。

让我们下次做那件事。请继续关注第二部分。

编码快乐！

-丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

• 人工智能和坏数据
• 人工智能:超参数
• 人工智能:让你的用户给你的数据贴上标签

人工智能、透明度及其与隐私的拉锯战

原文：https://towardsdatascience.com/ai-transparency-and-its-tug-of-war-with-privacy-5b94c1d262ad?source=collection_archive---------8-----------------------

我决定转贴这篇文章，特别是关于 剑桥分析公司和脸书 的铺天盖地的报道，因为 ca 在特朗普的大选中不当获取数百万用户数据以影响选民。如果大企业、科技巨头和立法者不加快监管以确保用户数据安全，这种情况将变得更加普遍。

作为一个与大数据打交道有一段时间的人，我已经将这种相关性的想法变得令人毛骨悚然(还记得臭名昭著的案例研究:Target 如何在她父亲 di d 之前发现一个女孩怀孕？).我敏锐地意识到它对大企业的诱惑，同时也意识到它在消费者中造成的恐惧。随着数据变得越来越丰富，消费者的数字足迹变得司空见惯，对他们生活的更多理解得到了分析和语境化。普通消费者越来越了解他们分享的内容，以及企业如何使用这些内容，很多时候都没有得到用户的认可或同意。

人工智能正在加快步伐，借助它，海量数据集允许对信息进行分析和语境化，这些信息具有固有的好处……但也存在对个人和社会的脆弱性，这些脆弱性是真实的，但尚未被揭示。

2012 年，我在我的公司博客 Genx 智库上写了这篇文章:这完全是关于隐私的。当时，大家一致认为，使用社交*台是一种公*交换用户数据的收集。梅西百货的 CMO 朱莉·伯纳德说:

有一件有趣的消费者事情…他们担心我们对数据的使用，但如果我不能提供相关性，他们会很生气。…如果我不看数据，我怎么能提供相关性并神奇地提供他们想要的东西呢？

一些更老练的用户不愿意向任何一家公司提供太多的信息，他们会选择使用不同的浏览器服务。Ghostery 和其他广告拦截器允许用户看到谁在跟踪他们。这使得广告网络更难有效地赚钱。更重要的是，它减少了公司可以追踪其用户的信息量。

快进到今天…

现在是 2017 年，Ghostery 和其他跟踪系统的采用已经显著增长

广告拦截器的使用在 2016 年激增 30%(根据 page fair)……截至 2016 年底，全球有 6.15 亿台设备拦截广告，其中 62%(3.08 亿)是移动设备。桌面广告拦截器的使用量同比增长 17%，达到 2.36 亿。

PageFair 生态系统负责人 Johnny Ryan 博士总结道:

2014 年，我们与广告屏蔽的早期用户打交道。这些人真的关心和理解广告技术中隐私和数据泄露的真正问题。我认为发生的事情是行业缺乏一种方法或对隐私的兴趣，让广告阻止精灵从瓶子里出来。

我在脸书上发了一篇关于 Google Home 的危害的文章作为对这篇文章的回应:Google Home Mini 偷偷录下了人们的对话，并玩成了对智能音箱 的大忌。

从这次谈话中可以清楚地看到，虽然人们了解到他们要向脸书提供的信息，但他们并不完全清楚他们分享的程度。

FB: Google Home Discussion

我说的是一个选择的问题。

并不是说“我们可能说不出什么有趣的东西”。

这并不是说人们应该对他们在公共场合分享的东西疑神疑鬼。

我的观点是“我们分享的”不一定是我们的选择。

这个选择是由*台决定的。他们收集的数据——公开的或私人的——本身提供了足够的素材来创建任何人和每个人的更明确的社交图。

最*，HBR 发表了这篇文章:客户数据:为透明和信任而设计

他们公布了这些关于消费者对共享数据的认知的统计数据。问题是普通消费者对收集的东西了解多少？第二，如果他们知道，他们会担心吗？

Source: HBR.org: Customer Data: Designing for Transparency and Trust

然而，如今用户和收集或分析数据的公司之间有了公*交换的想法。消费者期望公司提供更好的服务和更相关的交流，以换取他们分享的信息。

HBR 文章中的图表描述了这种公*交换的概念。公司收集的数据越多，消费者的期望水*就越高。对于像脸书这样的公司来说，其主要业务包括从用户数据收集中获得高度有针对性的广告，分析和预测用户倾向所需的分析最终将为公司带来更多收入。

Source: HBR.org: Customer Data: Designing for Transparency and Trust

随着这种需求的增长，在个人层面上增加情境化的价格也会上涨。公司对用户动机和用户意图了解得越多，就越能开发出更有效的活动，对消费者反应的预测也越高。

艾:语境决定一切

我在 AI 工作。我看到了数据。我也看到了可能性。在 Humans for AI，我还与每天分析大量信息的数据科学家交谈。我们都知道关联这些信息的优势和缺陷。

在我与一位朋友 Neeraj Sabharwal 的讨论中，他也是 Horton Works 的前大数据架构师/工程师，他转达了每个消费者为我们每个人在设备上分享的内容承担责任的重要性。我们公开或私下透露的信息以及我们分享这些信息的方式可能会被用于获取总体或个人层面的见解。尼拉杰指出，Venmo 用户默认公开分享他们的所有活动，除非他们选择私下或只与朋友分享转账。Wired 的这篇文章详细解释了谷歌如何跟踪你，以及你如何避免或减少跟踪。

意识是关键，一旦我们知道数据谱系(什么，如何，
在哪里，谁访问我们的数据)，那么我们就可以更清楚地意识到我们的决定。

我们讨论了埃隆·马斯克和开放人工智能在人工智能和治理方面所做的工作。OpenAI 专注于“发现并制定通往安全人工通用智能的道路。”按照马斯克的说法:

我认为人工智能可能是*期影响人类的最大的一个项目。因此，我们以一种好的方式迎接人工智能的到来是非常重要的，如果你能看到水晶球，看到未来，你会喜欢那个结果。因为这是可能出错的事情…所以我们真的需要确保事情顺利进行。

想想这些数据不仅仅是我们在不同的社交网络上分享的东西，我们的电子邮件，我们的交易，我们的客服聊天。它是关于来自所有这些不同数据源的信息的聚合…以及通过人工智能的信息关联，人工智能能够以前所未有的能力找到模式。有史以来第一次，数据、计算能力、增加的互联性和模式分析的进步的结合使得语境化完全可能(在这个新生阶段这是有争议的)增加准确性和精确性。

今天的隐私法规可能没有考虑的是用户在超出客户服务或通信含义的各种情况下允许使用信息的权利。这可能包括:

1)在个人层面——提供健康建议和通知，或提供日常任务提醒

2)在聚合级别—帮助医学研究更好地诊断病情或防止潜在的安全威胁。

现在，信息将超越我们在社交网络上分享的内容，向公司传播。我们将用传感器和 AR 设备来检测我们的家、我们的工作和我们的身体。我们对通过自动化增加便利性的追求可能会在过程中产生无意的结果——有意或无意的偏见风险。

游戏中的语境化:中国的社会信用评级

我关注中国芝麻信用已经有一段时间了。最*有消息称，中国计划在 2020 年启动社会信用体系。标题为“大数据遇到老大哥，中国开始对公民进行评级”的文章正在建立一个*台，研究 13 亿公民的社会行为，以判断他们的“可信度”。评分系统是一个动态的值，随着个人行为而上升和下降。可信度是由中国政府定义的，它是一个比监狱更糟糕的体系，让公民保持顺从。这种游戏化形式通过人工智能将 BF Skinner 的操作性条件反射带入了生活，人工智能是一种惩罚和奖励系统，人们的数据现在正被用来对付他们。

艾的龌龊是一个很早就控制我们想要保密的东西的机会

毫无疑问，西方文明和我们的公民也不能幸免于大规模的数据收集、聚合和精细分析。但是我们有选择，自由赋予我们某些权利。

Ann Covoukian 博士是安大略省前隐私专员，现任隐私和大数据研究所执行主任，也是全球个人隐私的主要倡导者，他有效地传达了一种信念，即“隐私和自由密不可分”。安驳斥了“零和”心态，即人们必须在隐私和安全之间做出选择，但不能两者兼得。

她认为我们不必为了维护社会安全而放弃个人隐私。如果我们不得不对大规模监控达成共识，我们就放弃了个人自由。随着大数据的出现，并非必须如此。

这一信念在加拿大被广泛接受，现在，随着《欧洲通用数据保护条例》( GDPR)于 2018 年 5 月生效，加拿大正在制定一个更广泛、更协调的数据隐私制度。现在需要系统和政策来主动实施这一点。请阅读此处关于用户将如何获得对其社交数据的更多控制。

无论如何，我们都有责任，就像尼拉杰暗示的那样，对我们分享的东西和分享的方式负责。随着我们的孩子在这个越来越透明的世界中成长，他们将需要了解这个新世界的局限性，并最终控制自己的个人信息。

人工智能推特机器人

原文：https://towardsdatascience.com/ai-twitter-bot-that-trolls-trump-3219b4338220?source=collection_archive---------3-----------------------

去年，我与人合作创办了一家公司，致力于用人工智能回答你的所有问题(我们从性健康开始)。我们制作了一个基于规则的机器人，并命名她为索菲机器人——她的故事是我第一篇也是唯一一篇博文的主题；-)

过去的一年是试图优化基于规则的人工智能(很多是我们的失败)和创造一个新模型的集合。我们甚至试图用实际的人力投入来弥补她的不足，但这很快就失败了，在将* 3 月份的时候，我们的用户群增长了 100%(改天再发)，随后评论直线下降。我们知道我们已经超越了 MVP，现在我们必须建立一个端到端的问答机器人类型的引擎。我们可以在任何问答数据集上训练它，苏菲机器人将能够学习和回答来自同一个领域的问题。

我们天真地玩着机器学习实现，不管我们如何努力，即使我们有吴恩达的洞察力，它也永远不会工作。然后出现了一个我们根本不想碰的 LSTM 模式的例子。因为首先，我们认为深度学习已经过时了，其次，它使用了 Ubuntu 论坛对话语料库(如 wth)。几个月后，我们终于回到这个话题，看了看更有意义的 Siraj Naval 的实现，因为它使用了 Cornell 电影对话语料库。到目前为止，我们一直在优化，并准备投入生产。

尽管我们在努力做一个很棒的模型，但是几行源代码和一个简单的 cli 演示不足以向我们的麻瓜(非科技)利益相关者展示我们的进展。我们决定享受这项技术，并开发两个更轻便、有趣的实现作为演示。其中一个有趣的演示是一个 trolls trump 的机器人。

多亏了 Siraj 的 jupyter 笔记本中的一个，我从零开始构建了一个 LSTM，除了 numpy 之外没有任何用于矩阵乘法的库，并开始从中获得乐趣。从随机输入文本生成文本。少量的文本会产生类似于胡言乱语的东西，所以我们认为没有比回复胡言乱语更好的用例了。我们通过 LSTM 传递每条推文来实现这一点。

而且效果非常好。

可用源代码:https://github.com/iamukasa/trolltrump

推特直播手柄:https://twitter.com/shtaki_ke

接下来:我们能为 https://genius.com/Big-shaq-mans-not-hot-lyrics 创作更多的歌词吗

人工智能 vs 电力:人工智能创业剧本

原文：https://towardsdatascience.com/ai-vs-electricity-the-ai-startup-playbook-abf223b52547?source=collection_archive---------4-----------------------

Image courtesy Oimheidi

现在是 1850 年。迈克尔·法拉第感觉很好——他正在摆弄电磁感应。英国财政大臣威廉·格拉德斯通来到他的实验室，问道:“电力。有什么用？”对此法拉第回应道:“先生，有一天你可能会征税。”这是一个可爱的故事，但不是真的。

寻找“机器学习用例”的数据科学界让我想起了校长的问题。

吴恩达谈论“人工智能如何成为新的电力”。他说:

1. 人工智能将彻底改变我们所知道的每个行业。“通过用电力驱动的机器取代蒸汽驱动的机器，我们改变了运输、制造、农业、医疗保健等行业。”还有通信，安德鲁——你忘了通信！
2. 人工智能将取代人类的工作，但会创造新的工作
3. 作为一家企业，海量数据是您的推动力和保障

这个比喻很强烈

让我们看看电力生态系统 c. 1912。

这看起来非常类似于我们今天如何构建一个人工智能产品，比如亚马逊 Alexa。

好的，数据是新的电力，对吗？

做出人们想要的东西

电力时代的发明远远早于商业产品。人们普遍认为爱迪生解决了市场采用的问题。

来自美国能源部:

爱迪生对电灯照明的贡献如此非凡，是因为他没有停止改进灯泡——他开发了一整套发明，使灯泡的使用变得切实可行。爱迪生以现有的煤气照明系统为基础设计了他的照明技术。1882 年，他在伦敦的霍尔本高架桥上展示了电力可以从位于中心的发电机通过一系列电线和管道(也称为导管)进行分配。与此同时，他专注于改善发电，在曼哈顿下城开发了第一个商业电力设施，名为珍珠街站。为了记录每个用户用了多少电，爱迪生发明了第一个电表。

他是一个有争议的人物，但是他遵循了一个简单的规则来使用电力。开发一个用户需要的产品，并想办法把它带给他们，这样他们就可以用它来改善他们的生活。

做出人们想要的东西。爱迪生制造产品，以及交付产品所需的支持技术。人们需要灯泡作为气体照明的更安全的替代品。

我们公司在产品 m1 上建立的“战略”就是这种可能性的文氏图。

我们可以执行=我们有人才和知识来构建和销售它。我们比其他人都有优势

市场需要=有客户需求，整体融资/业务环境有利于相关活动

甜蜜点之外的想法通常是“如果我们做 X 不是很酷吗？”。

在人工智能领域，人们可以想到很多理论上很好的想法。例如，建立一个人工智能来取代律师。在我们的案例中:构建一个 ML 驱动的产品设计*台。你到底是怎么做到的？

艾产品

吴恩达的人工智能产品的良性循环是思考构建人工智能产品的一个很好的心智模型。

由于 AI 需要数据来工作，所以像个人助理这样的 AI 产品会随着更多的数据而变得更好。优秀的产品会获得更多的用户，从而获得更多的数据，进一步强化这种正反馈循环。在他的演讲中，他说“谷歌和百度拥有如此复杂的数据获取策略，以至于我不知道一家小型初创公司如何能够开始获取人工智能产品所需的数据”。

Google Allo 现在突然有意义了。

当谷歌推出 Allo 时，全世界(包括我)都在嘲笑他们——他们的消息和聊天机器人策略似乎无处不在。如果他们这样做是为了获取 Google Home 的非结构化查询数据，我不会感到惊讶。通过将来自 Allo 的数据植入 Home，开箱即用的 it 工作得更好。

如果你有更多来自产品用户的数据，一个人工智能产品会变得更好。一个没有随着更多数据改进的产品是一个*台或一种使能技术，而不是一个产品。

服务也可以是产品，人工智能产品的定义与交付给最终用户的方式或所采用的商业模式无关。

人工智能创业剧本

对于小型人工智能初创公司来说，需要访问大量数据来构建人工智能产品可能会令人沮丧，特别是对于那些需要大量数据的产品来说，如个人助理。

没人说这会很容易。这不是不可能的。从语法上来说,正在复制谷歌规模的关于人们写作模式的数据。总有办法的。

玩法 1 :如果你是一家人工智能产品公司，你的产品策略和你的数据采集策略是一样的。

第二招:如果你在为一个产品搭建*台或提供技术支持，你就是在支持别人的产品。你受制于人工智能产品更广阔的市场环境。相应地行动和计划。

玩法#3 :所有 AI 产品公司都有某种形式的内部*台。如果要在构建产品和*台之间做出选择，那就构建一个产品。产品公司胜算更大，因为他们比*台公司捕捉到更多的价值。

去年获得资助的前 50 家公司很好地代表了市场现实。这是他们如何按类别细分的。分析链接

电表=支持另一种产品的技术，但本身不是产品

重头戏 4 :如果你是一家 B2B 人工智能公司，你需要一些特别的东西来赢得长期的构建与购买之争。从短期来看，“你没有内部专业知识”可能会满天飞，但这是一颗定时炸弹。大多数认真对待人工智能的公司都希望拥有自己内部的核心优势。

打法#5 :炒作已经过去了。人工智能和人工智能公司仍然是未来的热点，但如果你想长期获胜，你需要深入思考你在生态系统中的位置。

你是在为产品的采用建立一个产品、*台、组合、研究或支持技术吗？你是在建造灯泡，一家公用事业公司，试图发明电视或电表吗？从电的比喻中可以学到很多东西。从电力时代学习 GE、西联等相关公司。

玩法#6 :不要做创业，要创业。*年来，大多数人工智能初创公司的退出都是由收购。让我们面对它——作为一个行业，我们还没有想出如何从零开始建立一个长期、独立、大型和可持续的人工智能公司。互联网世界中的谷歌还没有在人工智能世界中诞生。可能是你。

第七场:没有剧本。如何获胜没有公式，没有模板。我们正在数字数据的基础上构建一个完整的产品和*台生态系统。这是前所未有的，也不知道结果会如何。

作为文化进化的一个子集，新技术的采用倾向于遵循生物进化的熟悉特征。

AI 为电，缩小后

进化是一种分形。

通过这个视频我了解了进化分形的概念。它有一个不被看好的开始，听起来有很多关于爱和意识的废话。但是，它的核心是一个非常强大的进化分形概念。数学分形在每个“缩放级别”看起来都是一样的，进化过程也是如此。

布鲁斯·利普顿从生物进化的角度解释了这个想法。

分形的一个结构特征相对容易理解:分形展示了一种重复的“结构”模式，这些结构相互嵌套。每个较小的结构都是一个缩影，但不一定是大结构的精确版本。分形数学强调整体中看到的模式和整体中部分看到的模式之间的关系。例如，树枝上细枝的模式类似于树干上分枝的模式。分形对象可以用“盒子”中的“盒子”、“盒子”中的“盒子”来表示，等等。如果一个人知道第一个“盒子”的参数，那么一个人就自动地被提供了表征所有其他(更大或更小的)“盒子”的基本模式

The Mandelbrot set, which you get when you iteratively graph f(z) = z2 + c. gif here

这篇文章的简短摘要是:

1. 细胞膜必须决定让什么进出细胞。这是一个试图理解混乱环境的传感器
2. 细胞的各个部分代表了一个为了更高的目标而共同运作的社会
3. 在生命的最初 30 亿年里，只有单细胞生物——细菌、藻类、原生动物、原核生物。我们知道真核细胞是在 30 亿年后出现的，但这是怎么发生的呢？单细胞生物体的大小是有极限的，所以它不只是变大并进化出更多的组成部分
4. 主要的理论是两个单细胞生物碰巧合并，产生的生物更适合并在环境中存活下来。真核生物出现了。
5. 进化过程充满了这种重复的模式。他举了一个计算器芯片的例子，它达到了计算器的极限。芯片与其他芯片放在一起，连接在一起，组成一台计算机——你达到了极限，你就建立了分布式/云计算。

他最后宣称人类可能代表了脊椎动物进化的极限。在进化的下一个阶段，我们需要共同努力，就像单细胞生物变成多细胞生物一样。

所有的进化过程都是看起来一样的重复模式，即分形。

如果我们认为技术进步和采用是遵循相似模式的文化进化的一种形式，这将变得非常有趣。人工智能时代看起来像是电力时代的“缩小”分形。

我们现在有更好的能力来观察文化进化的分形本质，因为技术转变是在更短的时间尺度内发生的，遵循的是加速回报定律。

而且还会变得更快。

谁来‘赢 AI’？没有一个玩家赢得了电。许多人赢得了电力。如果你能想出如何留在游戏中，每个人都有很多空间。如果人工智能的破坏将以同样的规模发生，会有唯一的赢家吗？

互联网

这个故事里的互联网在哪里？

在通过回顾电力时代来绘制人工智能路径时，我们在进化分形上“缩小”了一个层次，因此尽管原理可能是相同的，但它们的细节会有所不同。后端云基础设施是 Alexa 的交付机制，就像从变电站到用户家的电线是电力的交付机制。

我不认为互联网是人工智能生态系统的一部分。任何少于土地的东西都是电力生态系统的一部分。它就在那里，而你认为这是理所当然的。

电力和铺设的跨大西洋电缆使跨越大西洋的信息传递成为可能。你想拖就拖所有该死的电缆——如果你还没搞清楚电，电报就不会工作。

从众所周知的进化分形中抽离出来，我们正——恰当地——从现实世界走向数字世界。在这种环境下，我们认为互联网是理所当然的——它只是我们用来绘画的挂毯。就像现实世界中的土地一样。

紧急 AGI

我们正处于人工智能成为可能的开端。我们现在才安装第一批灯泡。我们处在 1890 年电力的时代。电话、收音机、电视、电子产品、电脑和互联网紧随其后——我们还没有看到它们在人工智能时代的对等物。

丹尼尔·丹尼特的这个演讲提出了有史以来最奇怪的问题:你如何从白蚁群体的大脑中获得高迪式的思维？

总结一下:

1. 复杂的行为有可能出现在不知道自己在做什么的愚蠢个体身上——没有理解力的能力。这就是为什么 7000 万只白蚁最终建造了一座看起来像高迪在巴塞罗那的教堂——圣家族教堂的白蚁城堡。
2. 但是高迪是一个聪明的设计师。这是理解能力。你如何从 860 亿个对其更高目的毫无概念的神经元中得到人脑？
3. 大脑是一种计算机，它接受输入并根据输入执行控制。它的工作方式不同于我们对数字计算机的概念，数字计算机是中央控制的，具有高度确定性，每个部分都有专门的角色，除此之外别无其他。大脑最好被认为是由 860 亿个神经元组成的汤，每个神经元都在做自己的事情，并试图生存。人脑的这种奇妙的计算由此产生
4. 自下而上的设计比自上而下的慢，但它有能力结合起来创造更大的结构，因此探索进化设计空间更有成效。这就是进化——包括文化进化和生物进化——的工作方式，这似乎是解决长期问题的最佳方式

我们是愚蠢的，人类个体做我们的事情。我只是一只写这篇文章的白蚁——我不知道我的工作如何有助于一个更大的结构——人类正在建造一个 AGI。我无法聪明地设计这个更大的结构。每一个开始的公司和每一个推出的产品都是我们不理解的盲目的一步。理解和智能设计出现在许多许多的迭代中。

我相信 AGI 会以这种方式崛起——当它发生时，我们可能甚至不会承认。就像我们不承认自己是电子人一样，尽管我们可以通过手掌上的屏幕获取世界上所有的信息。

如果你喜欢这篇文章，请随意点击那个按钮👏帮助其他人找到它。

在 Product ML ，我们正在建立一个*台来创造人工智能驱动的产品体验。祝我们好运！

哎，为什么是现在？

原文：https://towardsdatascience.com/ai-why-now-a18166631ea3?source=collection_archive---------5-----------------------

人工智能现在很火。行业新闻中的一缕清风揭示了许多关于人工智能是商业未来的文章。然而，与某个年龄的计算机科学家交谈，你会听到关于支撑人工智能的技术没有什么新的东西，而是它们的时代已经到来。

为什么是现在？

人工智能是教计算机做人类觉得容易，但对机器来说很难的事情。计算机已经可以做很多人类觉得很难的事情，但它们在对你我来说很基本的任务上却步履维艰，比如观察、解释语言或识别行为模式。

这种天真的方法，也是多年来让人工智能备受指责的方法，说“让我们系统地整理这个世界，并教会计算机如何在每种情况下做出决定。”这对于外部世界不介入的小领域来说相当有效，但是任何接触过客户服务中心的人都明白这种方法的两个缺陷。首先，描述你可能遇到的每一种情况是非常困难的。第二，当规则不适用时，或者如果规则的适用会产生负面影响时，你需要能够打电话告诉他们该做什么。作为一个民主国家，我们早就知道这一点——这就是为什么法律是由立法者和法院共同制定的。

目前围绕人工智能的兴奋是基于补救第一个缺陷:让我们更容易编纂我们周围的世界。随着世界上越来越多的数字数据和大规模的计算能力，机器学习的方法可以用来训练计算机比以往任何时候都更好地识别模式。

Image by Charles Thonney from Pixabay

考虑解决互联网上最常见的问题之一:这张照片里有猫吗？规则优先的方法将意味着数据科学家试图教会计算机什么是“猫性”，并开发检测胡须、尖耳朵、自鸣得意的表情等的算法。如果一个图像有足够多的这些，它可能是一只猫。即使对于这个简单的应用程序，要做好也是非常困难的。

然而，给定足够多的猫的图片和深度学习的技术，我们可以依靠计算机进化出自己的“猫性”意识，而不需要人类来分解它。

结果既令人兴奋又*淡无奇。

不可思议的是，有机的和突现的现象现在可以被一个过度生长的桌面计算器识别出来。不起眼，因为一个婴儿也能做到。不错的把戏，但那又怎样？

“那又怎样”是我们可以召集成千上万的机器来识别模式，快速地做，并且在许多许多数据点上:远远超过任何可行的人类规模。这种识别过程，一旦磨练，可以超越人类的能力。

这就是为什么每个人都对人工智能感到兴奋:我们终于有足够的数据和足够的计算能力来开始处理对人类重要的事情:语言、视觉、犯罪、疾病。

令人兴奋的东西，但我将以一个警告结束:没有人真正能够解决人工智能的第二个缺陷。我们不知道如何教机器做出正确的判断。人类用他们的生活经验增加他们所看到的:他们能感觉到什么时候发生了。机器不能:它们看不到自己看不到的东西。这就是为什么人工智能的开发者如此关注伦理道德。“垃圾进，垃圾出”的老计算法则仍然适用于人工智能。我们用我们自己的活动产生的模式训练机器。因此，我们有能力大规模复制我们的偏见和错误，却没有人类的能力去感觉到有什么不对劲。

人工智能不仅令人兴奋，而且很危险。

人工智能的历史

原文：https://towardsdatascience.com/ai-writes-the-history-of-artificial-intelligence-4d585b537498?source=collection_archive---------5-----------------------

注:这篇文章是一个人工智能写的。

二十世纪上半叶，科幻小说向世界介绍了人工智能机器人的概念。[ 0

虽然我们今天的工具更加复杂，但人们一直想知道在机器中创造人类智能意味着什么。[ 1

从那以后，在文学作品中出现了智能人工制品，而真实的(和欺骗性的)机械装置实际上显示了一定程度的智能。[ 2

从那时起，智能人工制品出现在文学作品中，而真实的(和欺骗性的)机械装置实际上显示了某种程度的智能。[ 3

第二次世界大战汇集了许多领域的科学家，包括神经科学和计算机科学的新兴领域。[ 4 ]

直到 20 世纪 50 年代，我们有一代科学家、数学家和哲学家，他们的头脑中已经在文化上同化了人工智能(或 AI)的概念。[ 5

艾伦·图灵就是其中之一，他是一位年轻的英国聚合物，研究人工智能的数学可能性。[ 6

在英国，数学家艾伦·图灵和神经学家格雷·沃尔特是两位面对智能机器挑战的聪明人。[ 7

在 20 世纪 40 年代和 50 年代，不同学科(数学、心理学、工程学、工程学、经济学和政治学)的少数科学家开始谈论创造人工大脑的可能性。[ 8

工作已迅速成为人工神经网络研究的基础，并在人工智能研究中有许多用途。[ 9

自 1956 年以来，人工智能作为一个令人兴奋和富有想象力的概念，在几份报告批评缺乏进展后，人工智能研究的资金在 20 世纪 70 年代被削减。[ 10

计算器对于人工智能的历史至关重要，因为需要用预先计算的值创建精确的表格，这导致了查尔斯·巴贝奇在 1840 年设计的分析引擎的诞生，这启发了 20 世纪 30 年代和 40 年代创建的最早的计算机。[ 11

逻辑理论是一个旨在模仿人类解决问题技能的程序，由研究与发展公司(RAND)资助。[ 12

视觉系统，通过外部感受器、人造眼睛和耳朵来测量物体的距离和方向。[ 13 ]

第一次冬季人工智能以“专家系统”的引入而结束，这些系统已经被世界各地的竞争公司开发并迅速采用。[ 14

它于 1963 年被斯坦福大学收购，是首批由计算机控制的人造肩膀机器人之一。[ 15

在 20 世纪 80 年代末，一些研究人员支持一种基于机器人技术的全新人工智能方法。[ 16

一种完全不同的方法是通过测试来衡量机器的智能，这种测试是在智能的数学定义的基础上开发的。[ 17

目前，谷歌、脸书、IBM 和微软等大型技术公司正在研究广泛的人工智能项目，包括虚拟助手。[ 18

谷歌是这种新方法的先驱:数以千计的高性能计算机，支持并行神经网络，学习从多个谷歌用户的海量流数据中发现模式。[ 19

它的创造者使用了无数的人工智能技术，包括神经网络，并在三年多的时间里训练一台机器识别问题和答案的模式。[ 20

机器伦理领域关注的是给予机器伦理原则或程序，以发现解决它们可能遇到的伦理困境的方法，允许它们通过做出自己的伦理决定来伦理地运行。[ 21

此外，对机器伦理的研究有助于揭示当前伦理理论的问题，发展我们对伦理的思考。[ 22 ]

我认为，这种担心是由于一个根本性的错误，即没有区分最*在禽流感的一个具体方面取得的真正进展和建立一个敏感的自愿情报的巨大和复杂。[ 23

微软的联合创始人比尔·盖茨加入了杰出的技术大师和科学家的行列，发现了他对人工智能对人类文明的潜在危险影响和意想不到的后果的想法。[ 24

来源

[0]http://sitn . HMS . Harvard . edu/flash/2017/History-artificial-intelligence/
【1】https://www.kidscodecs.com/ai-timeline/
【2】https://en . wikiversity . org/wiki/History _ of _ artificial _ intelligence
【3】https://aitopics.org/misc/brief-history
【4】http://www.bbc.co.uk/timelines/zq376fr
【5】http://sit https://en . Wikipedia . org/wiki/History _ of _ artificial _ intelligence
https://en.wikipedia.org/wiki/Artificial_intelligence
【18】http://www . data versity . net/brief-History-artificial-intelligence/
【19】http://www.bbc.co.uk/timelines/zq376fr
http://www.bbc.co.uk/timelines/zq376fr
【21】https://en.wikipedia.org/wiki/Artificial_intelligence

注: 本文由 AI-Writer 出品。你给它一个标题，它写下内容。这些句子是从原文中挑选出来并加以解释的。同时保持给予 AI 的标题的上下文。我定期测试这个软件，以发现改进之处。我会定期发类似的文章。请多建议一些话题。我不确定这个系统能处理多少流量。如果你正在尝试，请温柔对待它。

双城 AirBnB:西雅图 vs 波士顿

原文：https://towardsdatascience.com/airbnb-in-two-cities-seattle-vs-boston-66fba22fc1c1?source=collection_archive---------7-----------------------

AirBnB 房源的定价、可用性和评论分析

Photo by Tom Rumble on Unsplash

对于旅行者来说，AirBnB 已经成为常规酒店预订网站越来越受欢迎的替代品。它有助于将那些有多余房间或公寓的人与需要短期住宿的旅行者直接联系起来。

在今天的帖子中，我们将深入研究 Kaggle 为这两个城市提供的 AirBnB 数据集，其中包括三个 csv 文件:日历、房源和评论。

我们将研究 AirBnB 来自数据集的住房数据的定价和可用性机制，并回答两个从数据集中获取宝贵见解的问题。最后，我们将结束第三个问题，展示一个将提供给列表的评论转换成其得分预测的回归。代码和数据可以通过补充的 github 链接到达。

问题 1:波士顿和西雅图的房价如何？它们有季节性吗？有导致价格上涨的事件吗？

波士顿的预订价格中位数是每晚 150 美元；而西雅图是每晚 109 美元。全年来看，波士顿一晚的费用明显高于西雅图。

总的来说，在夏季期间，这两个城市的预订价格都会上涨。

虽然在西雅图数据中没有明显的峰值，但是在波士顿数据集中出现了一个特别有趣的峰值。在 4 月 17 日举行的波士顿马拉松比赛期间，有超过 3 万名参赛者参加，AirBnB 在该地区的价格似乎上涨了每晚 34 美元左右。

Chart 1: Comparison of Average Home Price over dates

问题 2:这两个城市全年的房源情况如何？

在波士顿，在任何给定的时间，有 49%的机会可以找到任何房源，而在西雅图，这个数字要高得多，为 67%。这可以解释为波士顿的供需比高于西雅图。这可能意味着波士顿是一个更受游客欢迎的目的地，因此认为相对于西雅图更难找到房子。

当谈到房子的可用性时，西雅图和波士顿都具有相对均等的分布，除了在 95%以上的时间有房子可用的高峰。这些可能是房子，如那些有不合理的高定价和没有吸引力的方面来支持这一价格。

在波士顿，有 891 栋房子非常受欢迎，而且只有不到 5%的时间可以入住。由于多种因素，如位置、价值和清洁度，这些房子是最受欢迎的。

Chart 2 : Availability of Boston vs Seattle

对于波士顿和西雅图，数据集中记录的列表项的数量全年保持不变，分别为 3586 和 3818，而它们的可用性作为每天变化的布尔值提供。

下面的可用房源比例图中最直接的部分可能是，在数据的前三个月，有一个持续上升的趋势。这是因为所提供的数据是拍摄的快照，越接*快照日期的预订率越高。

Graph 3: Proportion of Listings available

问题 3:我们可以使用回归从评论中预测评论分数吗？访问者对某个列表的评论是否给了我们足够的信息来猜测该列表的评论分数？

Reviews.csv 包含用户对预订的评论，Listing.csv 文件包含每个列表的*均评论分数。我想看看从作为练习提供的评论中预测评论分数的潜力。

为此，我将把为一个列表提供的所有评论连接成一个字符串，应用文本清理、特征提取方法和 ML 回归来预测我的响应变量，即 评论评分 。

我们将使用的提取特征的方法 TFIDF 类似于单词袋方法，但是考虑到了频率并降低了语料库中更常见的单词(整个单词世界)的影响。

在使用 TFIDF 矢量器进行特征提取后，我们将使用交叉验证来测试三种不同的机器学习算法:Scikit learn 的随机梯度下降回归器，DMLC 的xgboostrgressor和 Yandex 的 CatBoostRegressor 具有不同的学习速率。通过查看最低的 MSE 验证误差，我们应该能够选择在 NLP 管道中使用的回归变量和参数。

Table 1: Regression Results for XGBoost, CatBoost and SGDR

正如您在上面看到的，XGBoost 和 CatBoost 算法在交叉验证结果中的验证错误率方面非常接*，XGBoost 在 learning_rate 为 0.1 时表现稍好，成为赢家。在这一阶段，我们并不真正关注训练误差，只是因为我们想比较我们的模型在它没有见过的数据上的表现。

注意:XGB 和 Catboost 较低的学习率(如 0.0001)似乎没有收敛，因此产生了非常高的错误率。

最后，我将 TFIDF 矢量器的管道拟合到 X_intermediate 数据，对其进行转换，并将其馈送到学习率为 0.1 的 XGB 回归器。然后，我们对 X_test 进行预测，并使用均方误差评分将它们与 y_test 的实际值进行比较。

Snippet 1 : MSE Result of our best performing estimator

为了比较，我们可以看一下 XGB 预测分数和实际复习分数的曲线图。正如您所看到的，我们的模型在根据提供的评论预测分数方面表现得相当好。

Graph 4: XGB Predictions vs Actual Review Score Average

谷歌的气流:对 Cloud Composer 的第一印象

原文：https://towardsdatascience.com/airflow-by-google-a-first-impression-of-cloud-composer-f4d9f86358cf?source=collection_archive---------2-----------------------

日前，Google Cloud 公布了 Cloud Composer 的测试版。简而言之，Cloud Composer 是针对气流的托管解决方案，这是一个开源*台，用于以编程方式创作、调度和监控工作流。对于不熟悉气流的数据人员:您主要使用它来编排您的数据管道。

Airflow

由于我一直在寻找气流的托管解决方案，所以我决定本周带着 Cloud Composer 去兜一圈。托管解决方案的好处在于，作为一名数据工程师或数据科学家，您不必在开发运维上花费太多时间——这是您可能不太擅长的事情(至少我不擅长！).

因此，下面是一篇非常简短的关于测试 Cloud Composer 的体验的文章。这绝不是一个详尽的评价——这只是我对 Cloud Composer 的第一印象。

我喜欢云作曲家的地方

设置非常简单。如果你有一个 Google Cloud 帐户，只需点击几下鼠标(外加大约 20 分钟等待你的环境启动)。您还可以从 Python 包索引(PyPI)中轻松列出所需的 Python 库，设置环境变量，等等。

部署简单。你的 DAGs 文件夹位于谷歌云存储的一个专用桶中。这意味着您可以直接拖放 DAG 文件夹的内容来部署新的 DAG。几秒钟之内，DAG 就会出现在气流 UI 中。当然，拖放并不是唯一的选择。您还可以通过使用 Google Cloud 的 gcloud 以编程方式进行部署。

当您的环境启动并运行时，Google Cloud UI 是干净的并且没有麻烦:它只是链接到 DAG 文件夹和您的 Airflow 服务器，这是您将花费大部分时间的地方。

Cloud Composer

总的来说，积极方面的主题是简单和易用，这可能是您在托管解决方案中寻找的。

有哪些可以改进的地方

Cloud Composer 运行 Python 2.7 。至少应该有一个运行 Python 3.6 的选项——老实说，我希望它是默认选项。

仍然有一些错误需要解决——毕竟，这是一个测试版。例如，当我试图清除一个任务时，我得到了这个屏幕:

TypeError: can’t pickle thread.lock objects

定价可以更加透明。运行 Cloud Composer 3 天后，我收到了一张€25 英镑的账单，所以假设这是线性的，我大概每月支付€250 英镑。这与谷歌云提供的定价示例非常一致(注意，他们在示例中假设使用率为 25%)。

老实说，如果你的初创公司需要气流，并且你的内部没有很多 DevOps 人员，这是非常有价值的。但是，如果你的业余爱好项目主要着眼于气流，这可能太贵了。

如果你正在寻找另一个气流托管解决方案，在那里你可以获得更多的实践支持和培训，天文学家可能是一个不错的选择。

您的气流设置是什么样的？请在下面的评论栏告诉我。

Akkordeon:神经网络的演员模型

原文：https://towardsdatascience.com/akkordeon-actor-model-of-a-neural-network-ff748096a5a3?source=collection_archive---------18-----------------------

介绍

这个问题我琢磨了很久:有没有可能实现一个神经网络作为演员模型？我终于开发了一个实现，我觉得有必要写一篇关于它的文章。

本文的重点是探索一种思想以及如何实现它，而不是将这种实现与其他框架和实现进行比较。我甚至不确定这是不是个好主意。但是这是可以做到的，正如我希望在下面的内容中所展示的。

源代码在 github 上:https://github.com/botkop/akkordeon/tree/medium

TLDR；

我为神经网络的并行训练开发了两个角色模型。第一种，我称之为“触发器”，为每种消息类型交换状态，其中消息类型是向前传递、向后传递和验证(或测试)之一，并且只能处理符合其状态的消息。第二个，昵称为“轮子”，能够在任何给定的时刻处理所有类型的消息。它训练用于测试触发器场景的相同网络，速度快 2 倍，并且使用 2 倍多的资源。

演员模型

actor 模型是一个用于并发计算的系统。

参与者模型中的参与者是独立的单元，可以有状态。

参与者的状态是私有的:参与者不与其他参与者共享内存。

演员之间的交流是通过消息传递的。消息以异步方式发送，到达接收方参与者的邮箱，在那里按先进先出的顺序进行处理。

尽管参与者邮箱中的消息是一个接一个处理的，但参与者之间的消息是异步发送的。这意味着不同参与者中的计算同时运行。

Actor 系统可以部署在单台机器上，也可以部署在集群中。这允许水*和垂直缩放，允许计算资源的最佳使用。

神经网络

简单地说:

神经网络是一种试图定义未知函数的计算。我们有一个输入 x 和一个已知的输出 y，但我们不知道如何从 x 到 y。让我们尝试一下:我们用 x 和一组随机数(权重)对 x 进行一些计算(激活)，然后看看它与想要的输出 y 相比如何。这就是所谓的前向传递。显然，结果不会很好。

接下来，我们引入一种方法来衡量我们的结果有多错误(损失函数)，并在预期输出的方向上稍微调整一下权重(导数)。这是反向传递，调整权重被称为优化。

我们反复这样做，直到我们发现结果令人满意。这叫‘训练’。

我们可以尝试通过增加更多的权重和前向函数来改进网络。这些是层层叠叠的，一个接一个。在正向传递中，正向结果从一层传递到下一层，在反向传递中，调整从下一层传递到上一层。

多于一层的网络称为深度网络。

尽管我们可能永远也找不到我们想要的确切函数，但是只要有足够的数据和训练，我们可以计算出几乎总是能产生好结果的东西。希望当我们把它应用到一个从未见过的 x 上时，它能给我们一个未知 y 的好预测。

总而言之:

神经网络由层组成，在训练过程中，通过输入变量的激活向前遍历，通过损失函数计算的导数向后遍历。随后通过优化函数，例如随机梯度下降，用导数更新层的参数。

神经网络和演员模型

神经网络有许多活动的部分，我们可能会发现一些计算可以同时运行。

让我们从定义一个参与者模型开始，其中每一层都作为一个独立的参与者运行。

让我们也称这个层为一个演员的大门。它更好地反映了演员的独立性，我喜欢这个术语，因为它是安德烈·卡帕西在他关于 CS231n 反向传播的精彩讲座中创造的。

在正向传递中，激活作为消息从一个门发送到下一个门。在反向传递中，导数作为消息被发送到前一个门。到目前为止，没什么新发现。然而，每个门独立于网络的其余部分运行的事实，允许一些新奇的东西。

首先，优化(用下一个门的后向梯度或损失函数更新一个门的参数)可以异步完成，即。同时，前一个门正在处理该门新到达的梯度。

第二，不需要为了执行验证或测试过程而停止训练过程。所有可以同时运行。

第三，如果可用的话，不需要等待由网络的其余部分以及最终损失函数计算的梯度来开始处理下一批输入数据的前向传递。

想到的另一件事是，门可以任意复杂，每个门本身组成一个完整的神经网络。因为门是参与者，所以它们可以垂直和水*缩放。在一台机器中，gates 将在所有可用的 CPU/GPU 上执行。Gates 可以很容易地部署在不同的机器上进行水*扩展。单个机器和/或集群上所有资源的最佳使用可以避免昂贵 GPU 的成本。

履行

我们如何实现这一点？

我会用 Scorch ，一个用 Scala 写的神经网络框架。它有一个非常像 PyTorch 的编程接口。因为它是用 Scala 编写的，所以它允许与演员建模工具箱 Akka 集成。

让我们看看它是如何一起工作的，然后我会解释细节。

体系结构

这仅仅显示了训练阶段，但是其他阶段，比如验证和测试，都是类似的，而且更简单，因为没有反向传播。

有 3 个组件。

• Gates: actors，每个 actors 由一个模块和一个优化器组成。这些类似于传统网的层。
• 哨兵:也是一个行动者，负责向关口提供数据(输入)和计算/评估输出的损失。
• 主程序，定义演员系统、网络、数据加载器，并开始训练。

sentinel 只有一个，它从训练数据集中读取一批数据，并将其作为消息转发给网络中的第一个网关。这个门执行其转发功能，并将结果发送到下一个门。依此类推，直到最后一个门，它将结果转发回哨兵。

哨兵接收转发信息，这是现在网络的最终结果，并与预期的结果进行比较。它会计算损失，并将带有导数的反向消息发送到最后一个门。该门计算其函数的局部梯度，并将其作为反向消息发送给之前的门。然后，它更新其权重(优化)。如此下去，直到反向信息再次到达哨兵。

然后哨兵读取下一批数据。诸如此类。

两种情况

我开发了两个场景，我称之为人字拖和轮子场景。

在触发器场景中，所有参与者(哨兵和门)的状态在向前和向后处理状态之间交换。当转发消息到达某个参与者时，该参与者对其进行处理，并转换到向后状态。反之亦然，当一个反向消息到达参与者时，它会转换到正向状态。这种情况的缺点是，它在同一时间只能处于一种状态，因此只能处理当前状态允许的消息。

wheels 场景通过只有一个状态来解决这个问题，它处理所有类型的消息。这允许高度并发的模型，其中正向传播、反向传播和验证都同时运行。该场景依赖于参与者模型定义，即参与者邮箱中的消息按顺序处理。当演员需要跟踪前向通道激活时，为了计算后向通道中的梯度，简单的队列数据结构足以满足这一需求。

盖茨

门类似于层。不同之处在于，每个门都是一个参与者，它有自己的优化器，而在传统网络中，整个网络只有一个优化器。然而，在功能上没有区别，因为优化器不在层/门之间共享数据。

因此，门由一个模块和它自己的优化器组成。

“模块”是 Scorch(和 PyTorch)术语，指带有数据或参数(也称为重量)和转发功能的容器。forward 函数接受一个输入，使用权重执行计算，并产生一个可微分的输出。

模块还可以包含其他模块，允许将它们嵌套在一个树形结构中。

例如:

这个模块，由另一个模块(线性，一个完全连接的层)组成。它将通过全连接层传递其输入，然后是 relu 函数。请注意，模块可以根据您的需要变得非常复杂。你可以把卷积，池化，批处理，辍学，…等等放在那里。

盖茨和触发器场景

在触发器场景中，门有两种状态:正向状态和反向状态。

在转发状态下，门接受来自前一个门或哨兵的转发消息，通过转发功能运行消息内容，并将结果传递给下一个门或哨兵。

然后它切换到向后状态。

在反向状态下，它接受来自下一个门或哨兵的反向消息。

该消息包含上述激活的梯度。该门计算局部梯度，并依次将这些梯度作为反向消息传递给前一层。

一旦这个反向消息被发送，优化器使用诸如梯度下降或 Adam 之类的函数用梯度更新门的权重。

然后，它交换回转发状态，并等待下一条转发消息到达。

上面代码中的 wire 对象包含指向下一个和上一个参与者的指针，或者是另一个门，或者是哨兵。

盖茨和轮子的场景

在 Wheels 实现中，gate 只有一个状态，处理所有的消息类型。

因为这个场景的目标是能够同时执行向前和向后过程，所以我们需要跟踪向前过程中的激活，以便我们可以在向后过程中使用它们进行梯度计算。我使用一个列表来做这件事，这个列表充当一个队列。在正向传递中，输入变量和结果一起被添加到列表中。

在向后传递中，弹出列表的第一个元素，并用于梯度计算。反向消息的梯度和激活列表的第一个元素被保证属于一起，因为在 actors 中，消息被顺序处理，并且我们的网络由一条线(每个节点正好 1 个父节点，正好 1 个子节点)组成，而不是树或图。

哨兵

哨兵做了几件事:

• 为培训和验证提供数据
• 计算并报告培训和验证期间的损失和准确性
• 触发培训和验证的向前传递
• 训练时触发向后传球

哨兵和触发器场景

sentinel 有 3 种状态:起点、终点和验证。

在 Startpoint 状态下，它接受开始和反向消息。

开始消息指示新的训练时期的开始。

反向消息意味着最新的正向消息已经循环了一整圈，并且系统准备好接受新的一批训练数据。否则将忽略反向消息。

在这两种情况下，哨兵然后转发下一批训练到第一个门。

然后状态改变到终点。

在端点状态下，它接受转发消息。这些包含最新训练批次的网络结果，因此执行损失函数，并且梯度与反向消息一起反向传播到网络的最后一个门。

sentinel 试图从数据加载器中检索下一批训练数据。如果这是可能的，状态将变为 start point，为其提供批处理。

如果到达训练数据集的结尾，并且不可能检索下一批，则它进行一些时期结束管理，并且状态变为验证。

在验证状态下，它成批地将验证数据发送到第一个关口，第一个关口对其执行转发，并将其转发到下一个关口，直到验证消息返回 sentinel。哨兵累计损失和准确性，并报告*均值。

然后，它向自己发送一个开始消息，并将状态转换为转发。

哨兵和轮子的场景

在 wheels 场景中，除了一些变量之外，我们没有状态来跟踪验证分数以及训练和验证损失。

当收到开始消息时，它请求数据提供者向第一个门一个接一个地发送多个训练批次。这些消息将由正向传递一个接一个地处理，而不需要等待每个消息的反向传递。反向消息将按照正向消息的顺序到达。有可能在下一个前向消息之前处理一个后向消息，但这不是问题，因为网关使用队列来跟踪消息。

开始消息还触发通过网络发送第一批验证。因此，第一个时期的验证结果将是几乎未经训练的网络的验证结果。

但是重要的是要理解，这允许训练和验证同时运行，并且所有类型的消息(转发、反向和验证)都由网络同时处理。

关于 MNIST 的结果

训练样本数量:60000

测试样本数量:10000

运行一个简单的网络，该网络有 3 个完全连接的层，大小分别为 784x50、50x20 和 20x10。，每个之后是 relu 非线性和随机梯度下降优化。

硬件:2.3 GHz 英特尔酷睿 i7(四核，带超线程技术)。没有 GPU。

触发器

在 10 个时期后给出+96%的准确度。*均 CPU 使用率约为 150%。*均历元持续时间(包括验证):18 秒。

车轮

培训的并发级别设置为 4，验证的并发级别设置为 1。*均 CPU 使用率约为 300%。精度堪比触发器。*均历元持续时间(包括验证):8 秒。

结论

在本文中，我演示了如何在 actor 模型中实现神经网络，以及如何同时运行神经网络训练的不同阶段。

我讨论了两种场景，一种是状态切换，在给定时刻只允许处理一种消息类型，另一种是允许同时处理所有消息类型。后者的速度是同等精度的两倍多。

资源

源代码

• https://github.com/botkop/akkordeon/tree/medium

演员模型

• 10 分钟内的演员模特
• 维基百科

神经网络

• 修补神经网络
• 上下文相关深度神经网络的流水线反向传播

算法复杂性[101]

原文：https://towardsdatascience.com/algorithmic-complexity-101-28b567cc335b?source=collection_archive---------9-----------------------

思考可伸缩性的介绍

计算机速度很快:它们使用电子信号存储和处理数据，这些电子信号以每小时几十万英里的速度穿过它们的硅内部。相比之下，人类神经系统中最快的信号传播速度约为 250 英里/小时，慢了 3 个数量级，而且这些速度只可能用于无意识信号——为有意识思维和计算观察到的信号速度通常更慢。基本上，我们永远不可能在计算上胜过计算机。

Good luck, Alan.

尽管速度很快，但事实上计算机确实有其极限，而且这些极限很容易量化。如今，处理速度是以 GHz 来衡量的:一个 3GHz 的单核处理器每秒可以执行 30 亿条基本指令。一条基本指令可以被认为是一种算术或逻辑运算，例如将两个数相加，对两个布尔值进行“与”运算，或者在内存中给一个变量赋值。Python、C、Java 或(此处插入您最喜欢的编程语言)等人类可读代码在执行之前被转换为机器可读代码，一行简单的人类可读代码可以转化为十几个或更多的机器基本操作。几十亿条指令看起来很多，但实际上，当你编写和运行一个程序时，除非你是一个拥有自己的专业超级计算机的奇特科学家，否则你的系统在运行你的代码的同时，在后台*衡和运行数百个其他程序。处理能力有限，所以计算机必须给每个程序公*地分配处理器时间。

Processor hogs are almost as bad as ice cream hogs.

就像任何其他有限的资源一样，尽可能地提高效率和避免浪费计算是非常重要的。这对数据科学家来说很重要，因为他们经常处理需要快速运行的复杂算法，以及需要处理、转换或重组的大型数据集；如果我们在方法上不够谨慎和聪明，这些任务会花费大量的时间。

进入算法复杂性的概念——一个相当简单的概念有两个相当大的词:

算法复杂度 对于给定的任务，完成该任务的算法(即步骤列表)被称为更复杂，如果它需要更多的步骤来完成。

关于复杂性的推理

根据我的经验，通常最简单的方法是解释如何推理算法的复杂性，并通过使用一个例子来证明它在可伸缩性方面的有用性。所以我们来设定一个简单的任务吧！

任务:给定一个数，得到重复位数的集合。例如 301143523->【1，3】

一个简单的方法是检查我们看到的任何数字是否与该数字的字符串表示中的任何其他数字匹配，如果它不在那里，就将其添加到返回的集合中。

def simple(x): #convert x to string so we can iterate over digits
    s = str(x)

    repeated = [] for i in range(len(s)):
        for j in range(len(s)):
            if (i is not j) and (s[i] is s[j])\
            and (int(s[i]) not in repeated):
                repeated.append(int(s[i])) return repeated

我们需要计算出算法运行的步骤数。什么是台阶？是单行代码吗？我们能计算出运行这个算法需要多少行代码吗？下面是算法在一些样本数据上的执行情况:

Nope.

被执行的 Python 代码的行数很难计算出来，幸运的是，不能用来衡量一个算法的步骤数。这个标准取决于我们如何编写 Python 代码——如果我们让代码更 Python 化(可读性更差),我们可以把上面的代码压缩成一两行。代码仍然会被翻译成相同的机器代码，也就是计算机实际运行的代码。

That’s not how this works, Kevin.

因此，如果我们能以某种方式看到我们的代码被翻译成一行行的机器代码，我们能计算并使用这些代码来衡量一个算法需要的步骤数吗？

这将非常乏味，所以谢天谢地答案是否定的。不同的计算机架构运行不同类型的机器代码，每一种都可能将我们的 Python 代码翻译成不同的二进制表示，并且不一定能用相同数量的“机器代码行”来表示。

那么，从代码的角度来看，算法的步骤是由什么组成的呢？典型地，我们使用代码块的概念，一段代码表示关于输入数据的恒定时间操作。

一个代码块可以被标识为一行或多行代码从第一行到最后一行线性运行而没有真循环。

真正的循环是可变长度的循环。如果我们可以通过查看循环来判断它将迭代多少次，即for i in range(3): do_something()，那么我们可以等效地写do_something() 3 次来形成一个固定长度的代码块，因此它不是一个真正的循环。

for i in range(len(s)):
        for j in range(len(s)): **if (i is not j) and (s[i] is s[j])\
            and (s[i] not in repeated):
                repeated.append(int(s[i]))**return repeated

前面定义的simple函数中嵌套的 for 循环内部的体就是一个代码块的例子。

对于代码中的算法步骤，这是一个很好的定义，因为它是不变的，即使我们增加或减少不影响算法所做的语义的代码的语法行，它们也只是重新构造它们相应的代码块。

你可能很高兴听到我们可以更进一步，完全忘记代码。事实上，这绝对是做复杂性分析的最好方法。复杂性与代码几乎没有关系；它是算法的属性，而不是算法的实现。在编程中，我们经常强调将算法翻译成代码的重要性，但反过来的过程同样重要，如果不是更重要的话:优秀的程序员应该能够查看代码，通过将其分解成代码块，将其翻译回预期的算法，然后可视化该算法。

def simple(n):#convert n to string so we can iterate over digits
    s = str(n)

    repeated = []for i in range(len(s)):
        for j in range(len(s)):
            if (i is not j) and (s[i] is s[j])\
            and (int(s[i]) not in repeated):
                repeated.append(int(s[i]))return repeated

simple的代码用英语翻译成预定的算法:

给定整数 n

为 n:
中的每一位设置一个集合
，为 n:
_ _ _ _ 中的每一位设置一个集合，比较两者，如果匹配，则添加到集合中

归还器械包

该算法转化为一些样本数据的可视化:

我们可以从这种可视化中推理出算法的复杂性。让我们来计算一下:对于n中的每一个数字，我们取该数字并与其他数字进行比较，如果比较的数字匹配，就将其添加到一个集合中。这对应几个步骤？对于n中的每个数字，我们执行len(n) — 1步骤，所以我们总共执行len(n) x (len(n) — 1) 恒定时间步骤，相当于len(n) — len(n)步骤。

那么算法的复杂度是多少？说是len(n) — len(n)会不会正确？算是吧。这准确地表示了算法完成给定任务所需的步骤数。然而，在实践中，我们实际上并不关心步骤的数量:一个算法比另一个算法少 100 步完成同样的任务听起来好得多，但实际上这种差异可能会转化为纳秒级的计算时间。我们更关心步骤的数量如何与输入数据的大小成比例。

大 O

大 O 符号是一种用来简洁地描述算法伸缩性的符号。在除了最理论化的计算机科学家之外的所有人看来，算法的大 O 值和它的复杂性是一回事。如果你在求职面试中被问到算法的复杂性，他们会说计算算法的大 O 值。

我们如何做到这一点？在我们已经做的基础上还有一个额外的步骤。首先，我们对算法的复杂性进行推理，就像我们刚刚对simple算法所做的那样，然后我们得到我们最终得到的表达式，并且丢弃所有非主导项和常系数。例如:len(n) — len(n)正好变成len(n)，因为这是主导项，我们现在可以表示由simple编码的算法具有复杂度**O**(N²)，其中N是输入的位数(即N = len(n))。通常这被解释为“simple就是**O**(N²)”。

这是什么意思？这意味着，随着输入的位数增加，我们的算法完成任务所需的时间将呈二次方增加。这告诉我们我们的算法将如何扩展！

Computation time scales quadratically with the number of digits in our input.

让我们将这种可扩展性与解决相同任务的另一种编码算法进行比较:

def better(n):
    #convert n to string so we can iterate over digits
    s = str(n)

    #create 10 counting buckets
    buckets = [0 for x in range(10)]

    repeated = []

    #count number of each digit using buckets
    for i in range(len(s)):
        buckets[int(s[i])] += 1

    #get which digits occurred more than once
    for i in range(len(buckets)):
        if(buckets[i]) > 1:
            repeated.append(i)

    return repeated

语义翻译:

给定整数 n

创建 10 个起始值为 0 的计数桶
为每个数字创建一个集合
:
_ _ 递增该数字的桶
中的计数

返回集合

视觉翻译:

现在来计算算法的复杂度，给定一个输入n。首先，我们列出 10 个计数桶，每个数字一个。这是在固定时间内完成的，因此计为 1 步。接下来，我们迭代数字的位数，并增加相应的计数。这需要len(n)个步骤，每个步骤对应n中的一个数字。最后，我们对计数桶进行迭代，看看是否有计数大于 1 的桶。这也需要恒定的时间，因为有固定数量的桶，所以也只计为 1 步。

加起来，better的复杂度可以表示为len(n) + 2。去掉非主导项并去掉常系数:我们得到better是**O**(N)，其中N = len(n)。

比较

那么**O**(N) better与**O**(N²) simple相比如何呢？

Comparison of actual complexity of simple (red) and better (blue)

不出所料，better比simple扩展性强多了！有趣的是，由于在better中创建计数桶列表并在之后遍历它所带来的开销，对于非常小的输入数据，simple实际上比better执行得更好。回想一下，当输入较小时，计算差异最多是相对较少的指令，导致较小输入的时间差异可以忽略不计，而better实现了可伸缩性方面的巨大改进。

当我们要讨论可伸缩性时，为什么要去掉非主导术语和主要常量？

在我们最初的复杂性计算中，前导常数可以被吸收到一个步骤中…就像我们看到非真循环的想法一样。如果我们重复一个步骤有限次，我们可以简单地重新定义我们的步骤来考虑这个因素。这相当于用代数方法进行替换，去掉了常数。

我们去掉了非主导项，因为我们只关心可伸缩性，这意味着我们只关心随着输入数据变得越来越大，我们的算法的性能如何变化。让我们最后一次以simple为例，考虑它的实际复杂度与其大 O 值的比率:

 (N² — N) / N²   =  1 - 1/N

注意，随着N的增加，项 1 - 1/N越来越接* 1。事实上，我们可以通过选择足够大的N，使这一项尽可能接* 1。如果两个数之比是 1 意味着什么？他们是*等的。所以随着我们的输入数据N的增长，(N² — N)和N²变得越来越接*。这意味着对于足够大的数据来说，大的 O 值是我们算法复杂性的一个很好的度量，这告诉我们我们算法的伸缩性如何，并允许我们轻松地将其与解决相同任务的其他算法进行比较。我们知道，如果一种算法比另一种算法具有更小的大 O 值，那么对于足够大的数据，它会更快。我们还知道，如果两个算法具有相同的大 O 值，那么它们的伸缩性将相似。优秀的程序员*衡代码的可伸缩性和可读性，并且知道什么时候优先考虑这两者。

速度不是一切

我们从讨论计算机处理指令的速度比人快多少开始了这个话题。这只是在某种意义上是正确的:他们在处理线性指令时更快。人类的大脑已经进化到非常擅长*行化。他们可以同时看到、听到、闻到、触摸和品尝某种东西，同时有意识地思考其他东西，并下意识地控制所有正常的身体功能，如呼吸、消化和温度调节。单个处理器必须在这些任务之间快速切换，无法同时处理所有的信号。如今的计算机确实拥有多核处理器——多个相连的处理器有助于并行执行程序，但与普通人相比，它们的能力仍然非常有限。

人类也有很多记忆。我们可以保存一生的信息，并且(我们大多数人)可以有效地回忆起这些信息来帮助解决问题。关于算法复杂性的讨论的另一个方面是时间复杂性(速度)和空间复杂性(内存)之间的区别，以及什么时候一个应该优先于另一个——我们将留待另一天讨论。

这是一个总结——感谢阅读！

如果您喜欢关于复杂性和可伸缩性的讨论，请随时联系我( )了解您的想法或疑问！

二元分类中 k *邻算法的不完全性

原文：https://towardsdatascience.com/algorithmic-incompleteness-of-k-nearest-neighbour-in-binary-classification-8149bfb97c6c?source=collection_archive---------10-----------------------

我们都知道经典的机器学习分类算法，K-最*邻作为最成功的非参数机器学习算法之一。Fix 和 Hodges 于 1951 年在一份未发表的美国空军航空医学学校报告中首次提出了这一规则[1]，该规则被称为 k-最*邻规则，并在随后的几年中经历了进一步的修改。*来，众所周知，在与计算机视觉相关的图像分类问题上工作良好。

但是，在数据高度*衡的情况下，我们是否意识到或小心它的不可预测性呢？事实上，我们中的许多人都太习惯于像 Python 中的 Scikit-Learn、R 编程、MATLAB 机器学习工具箱或 WEKA 这样的机器学习工具箱，以至于机器学习算法在它们的实现层面上往往不被重视。根据一些洗钱从业者的说法:

对引擎盖下发生的事情有什么必要了解？..谁会要求你给出学习算法的算法描述或者概述？使用工具箱(即 Scikit-Learn)实现(函数调用它们)……最终结果是唯一重要的……深入学习 ML 算法是浪费时间 ”

此外，在许多书籍中，如

使用 Scikit Learn 进行机器实践学习& TensorFlow [2]

不要给出任何算法概述，直接跳到机器学习算法的 Scikit-Learn 实现。我并不认为这本书不合适，只要这本书的作者希望读者在学习 Scikit-Learn 的正确用法之前，至少精通机器学习算法的概述或直观方法。

总之，我深入研究了 kNN 算法，在实现层面上，我发现了算法中一个有趣的异常。

kNN 实际上是使用特征空间欧几里德几何构建的，使其成为一种无参数的学习算法。在进入伪代码之前，可视化特征空间中的所有数据点是很重要的。

二进制分类中 kNN 算法的伪代码如下所示:

有几个函数将用在伪代码中，仅用于解释工作原理，而不是用任何语言编程或编码，

1. nearest_neighbors(x):返回一个二维样本数组，其中第一维表示数组中不同的欧氏距离(降序),第二维表示与 x 具有相同欧氏距离的样本。
2. find(nb，data):它通过将 nearest_neighbors，nb 返回的样本映射到原始数据集 data 来返回索引。
3. count(p，num):返回 num(任意数字，此处为标签)在数组 p 中出现的频率
4. size(m):返回向量的长度，m
5. y:数据集的原始目标标签。

伪代码如下

1\. kNN(x)
2\. {
3\.     k = 0
4\.     c = k
5\.     nearest = nearest_neighbors(x)
6\.     indices = find(nearest[0],data)
7\.     label = y[indices]
8\.     if(size(label)==1)
9\.     {
10\.        prediction = label[0]
11\.    }
12\.    else
13\.    {
14\.        while c == k:
15\.        {    
16\.            n_0 = count(prediction,0)
17\.            n_1 = count(prediction,1)
18\.            if (n_1 > n_0)
19\.            {
20\.                prediction = 1
21\.                break
22\.            }
23\.            else if(n_0 > n_1)
24\.            {
25\.                prediction = 0
26\.                break
27\.            }
28\.            else
29\.            {
30\.                k = k + 1               
31\.                indices = find(nearest[k],data)
32\.                if(size(y[indices])==1)
33\.                {
34\.                    prediction = y[indices][0]
35\.                    break
36\.                }
37\.                else
38\.                {
39\.                    c = c + 1
40\.                }
41\.            }                   
42\.        }
43\.    }    
44\.    result = [prediction;c]
45\.    return result    
46.}

这里，使用函数 kNN()构造 k-最*邻算法伪代码，该函数采用单个测试样本或实例 x 作为自变量，并返回包含预测结果作为第一元素和 k 值作为第二元素的 2-D 向量。

现在，到此为止，没有任何问题，算法的公式似乎很好，很具体。但是，里面的算法有很大的异常。

现在，通过深入研究，让我们看看使用 k-最*邻进行二元分类时最坏情况的可能性。

异常解释:

最坏的情况出现在偶数(> 1)的时候，比如说 n 个最*的邻居，n 个邻居中的一半属于标签 0，另一半属于标签 1。然后，必须找到第(n+1)个最*的邻居(根据算法),如果再次出现相同的情况，则找到第(n+2)个最*的邻居，依此类推。如果这种情况继续出现(可能出现在高度*衡的数据集中)，在特定时刻，数据集中将不再有剩余的样本，并且在每个第 n 个最*邻考虑中，找到两个标签的相同数量的实例。因此，即使在达到数据集的最大 k 值后，也不能对测试样本的预测做出决定。

证明异常的样本数据:

样本数据集在包含 12 个实例的特征空间中示出，并且每个实例具有 2 个特征，F1 和 F2。

Faulty Case of kNN in Binary Classification

未来读者范围:

读者需要深刻理解，为什么上面的样本数据集的可视化是 kNN 的一个错误案例。还建议他们准备这样一个数据集，并选择适当的测试样本。之后，使用 Scikit-Learn 或 R programming 之类的工具箱来查看分类器做出的预测或决策。如果看到任何新的变化，或者如果有任何关于 kNN 错误案例的复杂情况，请在下面的评论部分提到。

避免这种错误情况的可能解决方案:

在特征空间可视化中显示的这样一个数据集处理起来确实非常复杂，选择这样一个测试样本(同心圆的中心)也是如此。当然，可以得出结论，数据集中存在离群值(不重要的实例或性能下降的实例)。因此，这个问题的一个可能的解决方案是欠采样。数据挖掘领域最常见和最成功的欠采样算法之一是基于聚类质心的多数欠采样技术(CCMUT)【3】。因此，通过欠采样，数据集的均匀*衡可以被打破，因此 kNN 可以被应用于如此选择的测试样本的分类。

参考文献:

[1]http://www.scholarpedia.org/article/K-nearest_neighbor

[2]盖伦，奥雷连诺。用 Scikit-Learn 和 TensorFlow 实践机器学习:构建智能系统的概念、工具和技术。《奥莱利媒体公司》，2017。

[3]https://towardsdatascience . com/implementation-of-cluster-centroid-based-majority-under-sampling-technique-ccmut-in-python-f 006 a 96 ed 41 c？FB clid = iwar 380 xy 0 pywovjebdyh 3 rnmmvwbtvlx 6 cqn _ 1 abmsceqqmzpdx 1 eaynj _ I

算法是新药

原文：https://towardsdatascience.com/algorithms-are-the-new-drugs-learning-lessons-from-big-pharma-997e1e7e297b?source=collection_archive---------0-----------------------

从前，药剂师和治疗师在后街和集市上出售他们的药物洗液和药剂，向所有购买他们产品的人承诺坚韧和活力。蛇油和奇迹疗法放在一起，其中大多数除了作为安慰剂之外没有任何作用。最终，循证实践诞生了，现代医学到来了。只有那些被证明有效的治疗方法会被保留下来，而成熟药物的处方集会缓慢但肯定地增长。现在，医生开处方，药剂师检查和配药，病人基本上好转了。今天，我们有一个监管严格、竞争激烈、利润高得离谱的全球制药业。去年，十大制药公司的总收入超过 4000 亿美元。现在，我们正处于一个全新的十亿美元产业的尖端；“医学算法”,准备将医学提升到更高的高度…

算法是新药，医生是新技术的处方者。

为了理解人工智能(AI)和算法行业(也称为“大技术”、“大算法”、“数字健康”)的未来，人们只需要看看制药公司最初是如何变得如此之大的，包括新药是如何开发并进入市场的，医疗实践是如何围绕药物的安全交付和监控进行的，以及医生是如何学会理解药物的作用机制和副作用的。

因此，根据从大型制药公司的现有实践中吸取的经验教训，我预测围绕算法会出现几个辅助行业。

广告和营销

在英国，英国制药工业协会(ABPI)，在美国，美国药物研究和制造商协会( PHRMA )有行为准则，所有制药公司在推广产品和与医疗专业人员互动时都必须遵守。如果你愿意，可以称之为道德框架，以罚款为后盾。这些准则详细规定了公司在向临床医生和患者推销药物时应该如何表现。其中包括公司可以在招待客户上花费多少钱的规定、免费钢笔、继续医学教育优惠以及“交流试验结果”的最佳实践。其目的是防止错误信息、夸大和统计上的疏忽——这是它在很大程度上成功做到的。

然而，批评者仍然存在。Ben Goldacre 博士是一个道德沦丧的世界的坚定反对者，他称之为坏制药，他写道，尽管有道德规范，制药公司仍然逃脱了“……设计不良的试验，在不可救药的少数古怪的、不具代表性的患者身上进行，并使用设计有缺陷的技术进行分析，以这种方式夸大了好处……”。听起来熟悉吗？其他有效的批评包括制药公司没有压力公布负面试验结果。

显然，算法开发者也是如此。我还没有遇到一篇关于深度学习的论文公开说“我们的算法不起作用”，一些有“积极”结果的论文有一些相当可疑的统计烟雾和镜子在进行。当然，总的来说，围绕人工智能仍然有炒作和煽风点火的气氛。我认为，这在一定程度上是因为风险投资支持的公司害怕失去未来的投资兴趣，不愿承认某些东西不起作用。每一篇关于人工智能的学术论文(顺便说一句，这些论文很少经过同行评审)都会很快被一篇夸大其词的媒体新闻稿报道，称“X 算法胜过 Y 医生!”,这当然也于事无补。!"。

这不仅仅是媒体的责任。今年，人们只要逛逛 RSNA 的货摊，就能了解一些公司的说法有多夸张。我们需要记住，强大的临床研究和随后的算法营销的前景和框架仍处于起步阶段，随着监管机构和开发人员找到自己的方式，正是这种前景将出现大规模加速增长。在那之前，我们将不得不费力地通过炒作来找到实际的真相。

所有制药公司都有一个专门的团队来处理临床事务的外部沟通——被称为医疗事务。这包括一个在医疗事务、医学写作和科学联络方面受过培训的专家医生团队，他们的工作是签署任何外部学术出版物、品牌和营销，处理与意见领袖和客户的科学交流，并确保所有交流在临床上是准确的。毕竟，任何被发现虚假广告的制药公司都会被处以重罚。因此，我预测人工智能开发者也需要雇佣一个“医疗事务”团队来处理同等的沟通任务。让未经临床培训的员工担任人工智能公司的临床沟通员是不可接受的，尤其是在直接与医疗保健打交道时。

我还预测，我们将会看到一个算法营销的监督机构，以及一个道德行为规范的引入，独立于 FDA 及其对等机构的验证和监管框架。该机构可能会大量借鉴制药行业关于营销、销售和广告的行为准则，以确保医院不会被卖给数字蛇油，而不是圣杯技术。它很可能会照搬“招待客户”的规则，并为业务开发经理能说什么和不能说什么设定指导方针，甚至可能会为如何撰写关于算法有效性的新闻稿设定指导方针。如果有人已经在某个地方建立了这样一个机构，我不会感到惊讶——这应该会非常有利可图…

但是，如果没有临床研究和调查性试验的坚实基础，这一切都不可能实现。我之前已经讨论过统计分析报告和监管框架——但还没有讨论算法实施的后遗症——这将我带到大型制药公司生命周期的下一部分——一旦算法被发布到临床工作流程的内部，就对它们进行持续监控。

算法安全和技术警戒

世界上每家医院都有一名药剂师，他的工作是监督药品安全。无论他们关注的是处方错误、出院沟通、无菌制剂还是配药错误，他们的任务都是确保在临床实践中将药物的危害和副作用降至最低。这是整体患者安全的一个非常重要的部分，通常在日常临床护理的聚光灯之外进行。(医院中的物理医疗设备也是如此——我保证会有人负责确保套件的电气合规性、质量保证和维护。)

算法安全将需要同样程度的监督。算法不仅有可能造成意想不到的伤害(没有算法是完美的)，而且它们需要按照监管要求进行严格的上市后监控。医疗器械国际标准(包括 ISO13485)明确规定，开发商应建立一个强大的系统来监控真实世界的设备性能。这包括对算法输出的定期审计，以及一个反馈机制来确保错误得到处理。

技术警戒是一个新术语——受大型制药公司“药物警戒”的启发。与英国的黄牌系统和美国的药物评估和研究中心系统一样，技术警戒旨在确保公司和最终用户向中央管理机构报告所有新的或意想不到的危害。例如，如果检测患者房颤发作的算法未能触发，患者受到伤害，则必须向开发商和相关监管安全机构报告该事件。

我想说的是，我预测一个围绕安全和技术警戒概念的行业将会出现，但事实上它已经出现了！监管第三方公司已经提供技术警戒咨询，并帮助建立医疗器械的监管合规流程。这个行业将扩展到为算法安全监控提供服务。该行业不仅将确保持续的安全监控，还将与至关重要的IV 期临床研究相结合，在该研究中，算法性能将在现场环境中进行临床评估，以评估安全性能。

医学教育和联合健康专家

医学教育也必须适应新的数字化未来。正如今天的医学学生必须了解作用、半衰期、生物有效性和化学级联的药理学机制一样，未来的学生将需要了解统计偏差、人工神经网络功能、数据结构和算法输出的解释。除了学习药物类别及其副作用，医生还需要了解不同类别的算法、它们的适应症和局限性，以及如何在上下文中解释它们的输出。就像药物安全一样，医生需要意识到算法安全。例如，一种药物具有已知的功效、预期目标人群、推荐剂量和监测要求。医生在开处方前会知道大多数关于药物的事实(如果他们不知道，他们就不应该开处方！).算法是相似的，因为它们有一个已知的准确性，一个预期的目标人群，一个推荐的用法，并需要监测。医生应该像了解药物的副作用一样了解算法的局限性，这难道不合理吗？

出于这些原因，我预计医学院的培训将不得不适应并开始包括基本的数据科学教学，并更加注重对统计的理解。我们需要超越基本的卡方和 T 检验研究，现在学生们也简单地介绍了这些研究。我们必须确保下一代医生能够处理更复杂的统计方法，包括(但不限于)ROC 曲线、AUC、概率建模、推断和比值比。只有到那时，我们才有足够的临床人才来引领医学的数字化发展。

因此，我预测一个基于向医生提供数据科学教育的新行业将会兴起。这已经开始发生，在线课程和 MOOCs 向任何自认为是数据科学家的人开放。我认为，我们将开始看到专门针对临床医生的课程，重点是医学背景下的算法和概率环境下的输出解释。

当然，在临床实践中，不仅仅是医生会成为算法的最终用户。医学走廊充满了非医师的专业，几乎医学的每个方面都有一个。我们有做超声波检查的声谱仪师，做外科手术的手术室护士，做行政管理的病房办事员，做运输的搬运工，做药品的药剂师。因此，我预测一个全新的联合健康专业将会出现，完全专注于 algorithmia。让我们称他们为“算法专家”。

作为临床算法功能的专家，算法专家将检查医院是否在正确的情况下使用正确的算法，帮助采购流程选择好的算法，就哪些技术用于哪些用例提供建议，监督医院内的算法安全，并管理“技术警戒”报告。我想成为一名算法专家所需的技能将非常特殊——既要有基本的临床基础，又要有数据科学背景。

你可能想知道为什么需要一个单独的专业。好问题！在我看来，即使我们有效地教育了医生，他们也没有时间或知识成为真正的全职算法专家。事实上，让医生远离一线医学是对临床培训的浪费。是的，一些临床学者很好地具备了必要的技能，并可能领导由算法学家组成的部门，但在医院的日常临床潮起潮落中，对这种专业知识将有巨大的需求，而且许多工作将需要经过专门培训和专门的专职医疗人员。拥有一个专家团队也比花钱让医生从病人身上抽身更划算。

那么，我们学到了什么？

药物不能提供安全有效的医疗保健，但人和系统可以。AI 和算法也是如此。

通过观察大型制药公司，人工智能开发人员可以开始预测他们所在行业及其周围将发生的趋势。准备好适应这些变化对持续增长至关重要。

从医疗事务和营销指南，到安全和技术警戒，到教育和培训专业劳动力，人工智能开发者可以参与并受益于整个支持行业的生态系统。如果他们参与其中，那么最终，我们的患者将从大算法的承诺中受益最多。

如果你和我一样对人工智能在医学中的未来感到兴奋，并想讨论这些想法，请联系我们。我在推特@drhughharvey

如果你喜欢这篇文章，如果你点击推荐并分享它，那会很有帮助。

关于作者:

哈维博士是一名委员会认证的放射科医生和临床学者，在英国国民医疗服务体系和欧洲领先的癌症研究机构 ICR 接受过培训，在那里他两次获得年度科学作家奖。他曾在 Babylon Health 工作，领导监管事务团队，在人工智能支持的分诊服务中获得了世界第一的 CE 标记，现在是顾问放射科医生，皇家放射学家学会信息学委员会成员，以及人工智能初创公司的顾问，包括 Kheiron Medical。

Python 中超参数优化算法

原文：https://towardsdatascience.com/algorithms-for-hyperparameter-optimisation-in-python-edda4bdb167?source=collection_archive---------5-----------------------

超参数通常对机器学习算法的成功有重大影响。一个配置不良的 ML 模型可能不会比一个配置良好的 ML 模型表现得更好，而一个配置良好的 ML 模型可以达到最先进的结果。

寻找最佳超参数的过程可能非常乏味，与其说是科学，不如说是艺术。这个微调模型参数的过程被称为超参数优化。在模型调整的过程中，我们经常会发现自己处于以下状态:

1. 厌倦了一次又一次地手动重新训练模型(没有任何性能增益)。
2. 等待彻底的网格搜索返回结果。(总感觉像是永恒)
3. 运行固定迭代次数的随机搜索，只希望它返回一些性能增益。
4. 你与原力(YODA)融为一体，并完善了微调模型的艺术。(如果你属于这一类，请与我们普通人分享你的神秘知识)

如果你经常发现自己处于状态 1-3，那么这篇文章将帮助你变得更好。

手动调谐并不都是不好的，因为它在选择下一个参数集时考虑了先前运行的结果( )通知搜索 )。这为我们节省了一些迭代，因为我们不会盲目地运行所有的排列。与此相反，网格/随机搜索独立运行每个排列，但不需要人工干预。为了两全其美，我们需要一个基于历史运行识别有希望的样本空间的自动化过程。实现这一点的有效方法之一是贝叶斯优化。这种技术有效地权衡了参数空间的探索和利用，以返回最佳优化评估标准的配置。一个额外的优势是，即使被优化的基础函数 f 是随机的、非凸的或者甚至是非连续的，它们仍然有效。

基于序列模型的优化(SMBO)是贝叶斯优化的简洁形式。SMBO 是一种通用的函数优化技术，号称是最有效的调用技术之一。

SMBO 通过识别可能已经绘制的超参数赋值来工作，并且根据损失函数值在其他点看起来是有希望的。

在这篇博客中，我们将介绍超参数优化的理论，然后使用 hyperopt 进行实际演示。Hyperopt 是 python 中的一个超参数优化库，它使用 TPE(SMBO 的一种风格)进行优化。在深入 SMBO 之前，让我们回顾一下超参数、网格搜索和随机搜索的基础知识。如果您已经熟悉第(1–3)部分，您可以跳过它们。

目录

1. 基本定义
2. 基于序列模型的优化(SMBO)
3. SMBO 的类型:基于高斯的和基于 TPE 的
4. 使用 Hyperopt 的实际操作示例

基本定义

1. 超参数 是模型内置的配置变量。这些变量需要微调以产生性能更好的模型。这些参数取决于型号，并且因型号而异。例如，随机森林模型将具有以下超参数

Internal features of a random forest model

以上所有特征都是模型的固有特征。对于基于树的集成方法，如随机森林或梯度推进 max_depth、min_sample_leaf 和 n_estimators(集成中的树的数量)是最重要的。

2.网格搜索是超参数优化最基本的算法。这就像在内置特性的所有可能值上运行嵌套循环。以下示例中的 rf_params 包含需要微调的模型特征。

在上述情况下，模型将被重新训练 300 次。
2(n _ estimator)* 3(max _ features)* 10(max _ depth)* 5(cv runs)= 300

这是一个非常狭窄的搜索空间，因为我们只搜索 3 个特征。如果我们进行彻底的搜索，组合的数量很容易超过 10k。

3.随机搜索是网格搜索，随机选择下一个特征集，总运行次数有上限。

随机搜索的代码与 GridSearch 相同，唯一的区别是我们添加了 n_iter=100，它固定了允许运行次数的上限。网格/随机搜索是 无信息搜索 的例子，意味着下一个特征集独立于上一次运行的输出。这两种方法都需要在每次迭代中进行重新训练，这导致了巨大的成本。

基于序列模型的优化(SMBO)

SMBO 通过顺序选择不同的超参数集来最小化验证损失，其中下一个集是通过贝叶斯推理选择的(取决于之前的运行)。直观地说，SMBO 会回顾上次运行的结果，以将未来的搜索集中在看起来更有希望的领域。

只要评估适应度函数( f : X - > R )的成本很高，就使用 SMBO。在这种情况下，计算一个*似的 f ( 代理M)。这款 M 算起来比较便宜。通常，SMBO 中的内部循环是该代理的数值优化或该代理的某种转换(下面代码中的*第 3 行)。最大化替代值的点 x 成为应该评估真实损失函数 f 的建议(行 4 )。**

Figure 1 : The pseudo-code of generic Sequential Model-Based Optimisation

*H:观察历史
T:试验次数
f:真函数
M:逼* f 的替代函数
S:计算下一个超参数赋值
x :M 最小化的样本实例

伪代码解释:
第 1 行:初始化一个空的 H.
第 2 行:初始化固定次数的循环尝试。
第三行:
1。L 为 f 获得一个名为 M.
2 的代理函数。定义一个需要最小化的评估标准。
3。对 x 的多个实例运行 S(x，M)以找到 x* 哪个最小化 S.
行 4 : f 被评估为最佳 x.
行 5 : H 用当前值 x，f(x)更新。
第 6 行:M 在每次迭代后被更新，以成为 f 的更好*似。

采集函数定义了在目标空间中探索新区域和利用已知具有有利价值的区域之间的*衡。不同风格的 SMBO 使用不同的算法来优化预期的改进(EI，采集函数的流行选择)。例如，Hyperopt 通过 TPE (Tree Parzen Estimators)优化 EI，而 Spearmint 使用高斯过程优化 EI。

SMBO optimises the EI ( Expected Improvement )

1. Pm:后 GP 知道 H
2. y*:新候选人的替代值
3. y:上一个候选人的替代值

直观地说，它定义了在给定位置 x 的最佳先前观察客观值上的非负 EI。

基于高斯过程的 EI 优化

高斯过程(GP) 是一个随机过程(由时间或空间索引的随机变量的集合)，使得这些随机变量的每个有限集合都有一个多元正态分布，即它们的每个有限线性组合都是正态分布的。

GP 是贝叶斯优化中建模目标函数( f )的标准代理。在这种设置中，假设 f 是具有均值 u 和协方差核K的 GP，核 K 的选择可以对替代重建有重大影响。在这种方法中，模型 M(图 1 的第 6 行)定义了预测分布 p(y|x，D)。

树形结构 Parzen 估计器方法(TPE )

TPE 是以树形结构组织的核估计器，以保持条件相关性。与直接对 p(y|x) 建模的基于 GP 的方法相反，TPE 通过 p(x|y) 和 p(y) 对其进行*似。

TPE 对 GP 优化预期改进的方式进行了两项更改。

1. p(y|x)替换为 p(x|y) * p(y)/p(x)
2. 情况 1 : p(x|y) = l(x) if y 情况 2 : p(x|y) = g(x) if y≥y*

• l(x) 是使用观测值{ x }形成的密度，使得相应的损失 f(x) 小于y∫
• g(x) 包含剩余的观测值

利用这两种分布，可以优化与预期改善成比例的封闭形式项。

这导致了下面的结论

EI after TPE specific optimisations

最后一个表达式表明，为了最大化改进，我们希望点 x 在 l(x) 下具有高概率，而在 g(x) 下具有低概率。这仅仅意味着选择 x 的,其具有小于先前报告值的 EI 的概率更高。

使用 Hyperopt 进行参数优化

Hyperopt 是用于通过 SMBO 执行自动化模型调优的 Python 库。应用 hyperopt 进行超参数优化是一个 3 步流程:

1. 定义目标函数。
2. 定义搜索空间(xgb_space)。
3. 定义一个试验数据库来保存每次迭代的结果。

以下代码块是如何对 xgboost(梯度增强库)执行超参数优化的示例。

为了对其他模型使用相同的脚本，只需对模型进行少量修改。您需要对 xgb_space 变量进行修改，以适应您选择的模型的搜索空间。在目标函数中，您需要更改交叉验证的运行方式(如我们使用的 xgb 特定方法),以及您希望最小化的指标。例如，对于 LightGBM(转到 LightGBM 了解这个令人敬畏的库)，您可以通过做一些小的修改来使用代码。

将来我会在 hyperopt 库上发布一个更详细的 hands on blog。

这个博客是对我们目前可用的超参数优化技术的一个简要概述。我们从不知情的搜索开始，如网格/随机搜索，然后转移到不同的贝叶斯方法，如基于 GP 的 SMBO 和基于 TPE 的 SMBO，最后是 hyperopt 的工作示例。

参考

如果你想深入了解，请浏览以下材料

1. Hyperopt github 存储库
2. 远视纸
3. 超参数优化算法

请在评论区分享你的想法和主意。

C++中的算法

原文：https://towardsdatascience.com/algorithms-in-c-62b607a6131d?source=collection_archive---------4-----------------------

完全搜索，贪婪，分治，动态规划

介绍

本文旨在向读者介绍四种主要的算法范式:完全搜索、贪婪算法、分而治之、和动态规划。许多算法问题可以映射到这四个类别中的一个，掌握每一个将使你成为一个更好的程序员。

本文是从竞技编程的角度来写的。在参考资料部分，您可以找到一些资源来帮助您入门，或者通过编码竞赛来提高您的编程技能。

完整搜索

完全搜索(又名蛮力或递归回溯)是一种通过遍历整个搜索空间寻找解决方案来解决问题的方法。在搜索过程中，我们可以删除搜索空间中我们确信不会导致所需解决方案的部分。在编程竞赛中，完全搜索可能会导致超时，然而，这是一个解决小输入问题的好策略。

完整搜索示例:8 皇后问题

我们的目标是在棋盘上放置 8 个皇后，这样就不会有两个皇后互相攻击。在最天真的解决方案中，我们需要列举 64 种选择 8 ~ 4B 的可能性。一个更好的天真的解决方案是认识到我们可以将每个皇后放在一个单独的列中，这导致了 8⁸~17M 可能性。我们可以做得更好，把每个皇后放在一个单独的列和一个单独的行，结果是 8！约 40K 有效行排列。在下面的实现中，我们假设每个皇后占据不同的列，并且我们为 8 个皇后中的每一个计算有效的行号。

#include <cstdlib>
#include <cstdio>
#include <cstring>
using namespace std; //row[8]: row # for each queen
//TC: traceback counter
//(a, b): 1st queen placement at (r=a, c=b)
int row[8], TC, a, b, line_counter; bool place(int r, int c)
{   
    // check previously placed queens 
    for (int prev = 0; prev < c; prev++) 
    { 
        // check if same row or same diagonal
        if (row[prev] == r || (abs(row[prev] — r) == abs(prev — c)))
            return false; 
    }
    return true;
}void backtrack(int c)
{
    // candidate solution; (a, b) has 1 initial queen
    if (c == 8 && row[b] == a) 
    { 
        printf(“%2d %d”, ++line_counter, row[0] + 1); 
        for (int j=1; j < 8; j++) {printf(“ %d”, row[j] + 1);}    
        printf(“\n”);
    } //try all possible rows 
    for (int r = 0; r < 8; r++)
    {
        if (place(r, c))
        {
            row[c] = r; // place a queen at this col and row   
            backtrack(c + 1); //increment col and recurse
        }
    }
}int main() 
{
     scanf(“%d”, &TC); 
     while (TC--) 
     { 
        scanf(“%d %d”, &a, &b); a--; b--; //0-based indexing    
        memset(row, 0, sizeof(row)); line_counter = 0;
        printf(“SOLN COLUMN\n”);
        printf(“ # 1 2 3 4 5 6 7 8\n\n”);
        backtrack(0); //generate all possible 8! candidate solutions    
        if (TC) printf(“\n”);
     }
     return 0;
}

对于 TC=8 和(a，b) = (1，1)的初始皇后位置，上述代码产生以下输出:

SOLN       COLUMN
 #    1 2 3 4 5 6 7 8 1    1 5 8 6 3 7 2 4
 2    1 6 8 3 7 4 2 5
 3    1 7 4 6 8 2 5 3
 4    1 7 5 8 2 4 6 3

这表明在给定初始皇后位置(r=1，c=1)的情况下，有四种可能的布局。注意，与迭代解决方案相比，递归的使用允许更容易地修剪搜索空间。

贪婪算法

贪婪算法在每一步采取局部最优选择，希望最终达到全局最优解。贪婪算法通常依赖于贪婪启发式算法，人们经常可以找到贪婪算法不能达到全局最优的例子。

贪婪的例子:分数背包

贪婪背包问题包括选择将什么物品放置在有限容量 W 的背包中，以便最大化背包物品的总价值，其中每个物品具有相关联的重量和值。我们可以将贪婪试探法定义为物品价值与物品重量的比率，即我们希望贪婪地选择同时具有高价值和低重量的物品，并基于该标准对物品进行分类。在分数背包问题中，我们被允许取一个物品的分数(相对于 0-1 背包)。

#include <iostream>
#include <algorithm>
using namespace std; struct Item{
    int value, weight;
    Item(int value, int weight) : value(value), weight(weight) {}
}; bool cmp(struct Item a, struct Item b){ 
    double r1 = (double) a.value / a.weight; 
    double r2 = (double) b.value / b.weight; 
    return r1 > r2;
} double fractional_knapsack(int W, struct Item arr[], int n)
{
    sort(arr, arr + n, cmp);     int cur_weight = 0; double tot_value = 0.0;
    for (int i=0; i < n; ++i) 
    { 
        if (cur_weight + arr[i].weight <= W) 
        {
            cur_weight += arr[i].weight;
            tot_value += arr[i].value;
        }   
        else 
        {   //add a fraction of the next item
            int rem_weight = W — cur_weight;
            tot_value += arr[i].value * 
                        ((double) rem_weight / arr[i].weight);                     
            break;
        }
    } 
    return tot_value;
}
int main()
{ 
    int W = 50; // total knapsack weight
    Item arr[] = {{60, 10}, {100, 20}, {120, 30}}; //{value, weight}
    int n = sizeof(arr) / sizeof(arr[0]); 
    cout << “greedy fractional knapsack” << endl; 
    cout << “maximum value: “ << fractional_knapsack(W, arr, n);
    cout << endl; 
    return 0;
}

由于排序是开销最大的操作，该算法的运行时间为 O(n log n)。给定三个项目的(值，重量)对:{(60，10)，(100，20)，(120，30)}，并且总容量 W=50，上面的代码产生以下输出:

greedy fractional knapsack
maximum value: 240

我们可以看到，输入项目按价值/成本的递减比率排序，在贪婪地选择项目 1 和 2 后，我们取项目 3 的 2/3 分数，总价值为 60+100+(2/3)120 = 240。

各个击破

分而治之(D&C)是一种技术，它将一个问题分成更小的、独立的子问题，然后组合每个子问题的解决方案。

分而治之技术的例子包括排序算法，例如快速排序、合并排序和堆排序以及二分搜索法。

D&C 的例子:二分搜索法

二分搜索法的经典用法是在一个排序的数组中搜索一个值。首先，我们检查数组的中间，看看是否包含我们要找的东西。如果是这样，或者没有其他项目需要考虑，我们就停止。否则，我们决定答案是在中间元素的左边还是右边，并继续搜索。由于每次检查后搜索空间的大小减半，因此算法的复杂度为 O(log n)。

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;int bsearch(const vector<int> &arr, int l, int r, int q)
{ 
    while (l <= r) 
    {
        int mid = l + (r-l)/2;
        if (arr[mid] == q) return mid; 

        if (q < arr[mid]) { r = mid — 1; } 
        else              { l = mid + 1; }
    }
    return -1; //not found
}int main()
{
    int query = 10; 
    int arr[] = {2, 4, 6, 8, 10, 12};
    int N = sizeof(arr)/sizeof(arr[0]);
    vector<int> v(arr, arr + N); 

    //sort input array
    sort(v.begin(), v.end()); int idx;
    idx = bsearch(v, 0, v.size(), query);
    if (idx != -1)
        cout << "custom binary_search: found at index " << idx;    
    else 
        cout << "custom binary_search: not found"; return 0;
}

上面的代码产生以下输出:

custom binary_search: found at index 4

注意如果没有找到查询元素，但是我们希望找到不小于查询的第一个条目或者大于查询的第一个条目，我们可以使用 STL lower_bound 和 upper_bound。

动态规划

动态编程(DP)是一种技术，它将一个问题分成更小的重叠的子问题，计算每个子问题的解决方案，并将其存储在 DP 表中。从差压表中读取最终解。

掌握动态编程的关键技能是确定问题状态(DP 表的条目)以及状态之间的关系或转换的能力。然后，在定义了基本情况和递归关系之后，可以用自顶向下或自底向上的方式填充 DP 表。

在自顶向下的 DP 中，根据需要递归地填充表格，从顶部开始，向下到更小的子问题。在自底向上的 DP 中，从最小的子问题开始迭代地填充表格，并使用它们的解决方案来构建和达到更大的子问题的解决方案。在这两种情况下，如果已经遇到了子问题，那么只需在表中查找它的解决方案(而不是从头开始重新计算解决方案)。这大大降低了计算成本。

DP 示例:二项式系数

我们用二项式系数的例子来说明自顶向下和自底向上 DP 的使用。下面的代码基于带有重叠子问题的二项式系数的递归。设 C(n，k)表示 n 选择 k，那么，我们有:

Base case: C(n,0) = C(n,n) = 1
Recursion: C(n,k) = C(n-1, k-1) + C(n-1, k)

请注意，我们有多个重叠的子问题。例如，对于 C(n=5，k=2 ),递归树如下:

 C(5, 2)
                      /                       \
             C(4, 1)                            C(4, 2)
            /      \                        /           \
       C(3, 0)   C(3, 1)             C(3, 1)             C(3, 2)
                 /    \             /     \             /     \
           C(2, 0)  C(2, 1)      C(2, 0) C(2, 1)    C(2, 1)  C(2, 2)
                   /      \              /   \        /    \
               C(1, 0)  C(1, 1)    C(1, 0)  C(1, 1) C(1, 0)  C(1, 1)

我们可以如下实现自顶向下和自底向上的 DP:

#include <iostream>
#include <cstring>
using namespace std; #define V 8
int memo[V][V]; //DP table int min(int a, int b) {return (a < b) ? a : b;} void print_table(int memo[V][V])
{
    for (int i = 0; i < V; ++i) 
    {
        for (int j = 0; j < V; ++j)
        {
            printf(" %2d", memo[i][j]);        
        }
        printf("\n");
    }
} int binomial_coeffs1(int n, int k)
{ 
    // top-down DP 
    if (k == 0 || k == n) return 1;  
    if (memo[n][k] != -1) return memo[n][k];
    return memo[n][k] = binomial_coeffs1(n-1, k-1) +      
                        binomial_coeffs1(n-1, k);
}int binomial_coeffs2(int n, int k)
{    
    // bottom-up DP
    for (int i = 0; i <= n; ++i)  
    {        
        for (int j = 0; j <= min(i, k); ++j)
        {            
            if (j == 0 || j == i) 
            {                
                memo[i][j] = 1;
            }  
            else
            {
                memo[i][j] = memo[i-1][j-1] + memo[i-1][j];                  
            }
        } 
    }
    return memo[n][k];
}  
int main()
{
    int n = 5, k = 2;
    printf("Top-down DP:\n");
    memset(memo, -1, sizeof(memo));
    int nCk1 = binomial_coeffs1(n, k);
    print_table(memo);
    printf("C(n=%d, k=%d): %d\n", n, k, nCk1);

    printf("Bottom-up DP:\n");
    memset(memo, -1, sizeof(memo));
    int nCk2 = binomial_coeffs2(n, k);
    print_table(memo);
    printf("C(n=%d, k=%d): %d\n", n, k, nCk2);

    return 0;
}

对于 C(n=5，k=2)，上面的代码产生以下输出:

Top-down DP:
 -1 -1 -1 -1 -1 -1 -1 -1
 -1 -1 -1 -1 -1 -1 -1 -1
 -1  2 -1 -1 -1 -1 -1 -1
 -1  3  3 -1 -1 -1 -1 -1
 -1  4  6 -1 -1 -1 -1 -1
 -1 -1 10 -1 -1 -1 -1 -1
 -1 -1 -1 -1 -1 -1 -1 -1
 -1 -1 -1 -1 -1 -1 -1 -1
C(n=5, k=2): 10Bottom-up DP:
  1 -1 -1 -1 -1 -1 -1 -1
  1  1 -1 -1 -1 -1 -1 -1
  1  2  1 -1 -1 -1 -1 -1
  1  3  3 -1 -1 -1 -1 -1
  1  4  6 -1 -1 -1 -1 -1
  1  5 10 -1 -1 -1 -1 -1
 -1 -1 -1 -1 -1 -1 -1 -1
 -1 -1 -1 -1 -1 -1 -1 -1
C(n=5, k=2): 10

时间复杂度为 O(n * k)，空间复杂度为 O(n * k)。在自顶向下 DP 的情况下，子问题的解决方案根据需要存储(存储),而在自底向上 DP 中，整个表是从基本情况开始计算的。注意:出于打印目的，选择了较小的 DP 表格尺寸(V=8 ),建议使用更大的表格尺寸。

密码

所有代码可在:https://github.com/vsmolyakov/cpp获得

要编译 C++代码，您可以运行以下命令:

>> g++ <filename.cpp> --std=c++11 -Wall -o test
>> ./test

结论

有很多学习算法的好资源。我强烈推荐 Steven Halim 关于竞争性编程的书[1]。除了经典的算法设计手册[2]和 CLRS [3]。有许多伟大的编码挑战网站，其中一些在[4]中提到。此外，[5]有一个奇妙的算法集合和易于理解的实现。如果您正在构建自己的库或参加编程竞赛，这是一个很好的资源。

希望这篇文章对你有所帮助。编码快乐！！

参考

1. Steven Halim，“竞争性编程”，第 3 版，2013 年
2. 史蒂文·斯基埃纳，《算法设计手册》，施普林格，2011 年
3. 托马斯·科尔曼等人，《算法导论》，麻省理工学院出版社，2009 年
4. https://medium . freecodecamp . org/the-10-most-popular-coding-challenge-websites-of-2016-fb8a 5672d 22 f
5. 【https://www.geeksforgeeks.org/

用卷积自动编码器对齐手写数字

原文：https://towardsdatascience.com/aligning-hand-written-digits-with-convolutional-autoencoders-99128b83af8b?source=collection_archive---------6-----------------------

Photo by Chris Ried on Unsplash

自动编码器是广泛使用的神经网络的无监督应用，其原始目的是发现数据集的潜在低维状态空间，但它们也能够解决其他问题，如图像去噪、增强或着色。

在这篇文章中，我想分享我对卷积自动编码器的实验，我训练它将 MNIST 数据集中随机旋转的手写数字对齐到它们的原始位置。请注意，这篇文章不是用来介绍自动编码器的，而是一个应用的展示和不同解码架构的比较。在接下来的部分中，我将展示一个案例，该案例强化了具有卷积层的上采样块比去卷积层性能更好的共识，并且还展示了卷积层与全连接层的组合在简单自动编码器和仅具有卷积层的卷积自动编码器上都具有优势。

如果您已经熟悉卷积自动编码器和上采样技术，可以跳过下一节，如果不熟悉，我推荐您阅读它和相关文章。

介绍

自动编码器背后的主要思想是将输入减少到具有更少维度的潜在状态空间中，然后尝试从该表示中重构输入。第一部分称为编码，第二步是解码阶段。通过减少代表数据的变量数量，我们迫使模型学习如何只保留有意义的信息，从这些信息中输入是可重构的。它也可以被视为一种压缩技术。

下面这个帖子是我推荐的一个很棒的介绍:

[## 自动编码器—深度学习比特#1

特色:数据压缩，图像重建和分割(附实例！)

hackernoon.com](https://hackernoon.com/autoencoders-deep-learning-bits-1-11731e200694)

如果您也对实现感兴趣，下一篇文章是基于第一个链接编写的，但它也包括 Tensorflow 中的详细实现:

[## 自动编码器-TF 中的介绍和实现。

简介和概念:

towardsdatascience.com](/autoencoders-introduction-and-implementation-3f40483b0a85)

这个实现的一个有趣部分是上采样的使用。由于内核的重叠，反转卷积层可能相当具有挑战性。大多数深度学习框架都包括反卷积层(有人称之为转置卷积层)，它只是一个反向卷积层。尽管这些层在重建输入时直观上有意义，但它们也有产生棋盘假象的缺点。为了解决这个问题，它们已经被上采样和简单卷积层所取代。以下两个链接的帖子都是对这个问题的详细解释。

[## 去卷积和棋盘伪影

当我们仔细观察神经网络生成的图像时，我们经常会看到一种奇怪的棋盘图案…

蒸馏. pub](https://distill.pub/2016/deconv-checkerboard/) [## 转置卷积上采样

如果你听说过转置卷积，并对它的实际含义感到困惑，这篇文章是为…

towardsdatascience.com](/up-sampling-with-transposed-convolution-9ae4f2df52d0)

该项目

正如我前面提到的，我使用了 MNIST 数据集，并将每张图像旋转了某个随机角度。模型的任务是将它们重新排列成原始状态。在实验过程中，我比较了以下架构；

• 一个简单的自动编码器，有三个隐藏层，我用它作为基准
• 一种卷积自动编码器，仅由编码器中的卷积层和解码器中的转置卷积层组成
• 另一种卷积模型，在编码器部分使用卷积块和最大池，在解码器中使用卷积层的上采样
• 最后一个模型是卷积层和全连接层的组合

所有模型都在具有相同超参数的相同数据集上训练，并且在瓶颈层中具有 256 个变量。

基线模型

首先，让我们看看基线自动编码器，它具有以下结构。

Architecture of the Baseline Model

我在训练中使用了均方误差，最佳模型在训练数据上达到了 0.0158，在验证数据上达到了 0.0208，正如预期的那样，在测试数据上达到了 0.0214。下图是测试数据集中的一个示例，显示了模型如何成功地重新排列数字 4。

From left to right: input image, target image and the image predicted by the model

该模型意识到图像显示的是数字 4，并将其旋转回原来的位置。预测仍然是一个明显的数字 4，然而，边缘有点模糊，顶部两条线之间的差距几乎消失了，这可能是低维瓶颈的结果。总的来说，该模型能够完成任务并产生可接受的结果，但是，它在一些输入方面存在问题。所有模型中最具挑战性的一张图片如下。

中间的真实图像清楚地显示了数字 4，然而，由于长的水*线，旋转后的图像有点像数字 5。该模型努力识别数字，最终得到一个水*质量，它显示的是数字 5 而不是数字 4。

具有转置卷积的卷积自动编码器

第二种模型是卷积自动编码器，它只包括卷积层和解卷积层。在编码器中，输入数据通过 12 个具有 3×3 内核的卷积层，滤波器大小从 4 开始增加到 16。由于卷积层没有填充，并且步长大小为 1，瓶颈的大小为 16x4x4，这意味着瓶颈中的变量数量与基线模型的数量相匹配。解码器利用转置卷积层来反映这种架构。仅使用卷积层可能看起来不寻常，但在这种情况下，目标是比较技术，而不是实现出色的结果。

就度量标准而言，这种架构无法接*基准模型。训练 MSE 损失为 0.0412，验证损失为 0.0409，测试损失为 0.0407。较大的损失可能是由于可训练参数的尺寸较小。使用卷积层将基准测试中的参数数量从大约 100 万减少到只有 23000 个。

在许多情况下，如上面的数字 9 所示，模型能够解决问题并预测与所需输出匹配的可识别数字，但一般来说，它无法生成更好性能所需的如此精细和狭窄的线条，并且生成模糊的图像，其数字难以识别，如下所示。

这种效果可以归因于去卷积层，因为除了边缘之外的每个像素都是作为重叠滤波器的总和而生成的。这个模型在上面考虑的复杂例子中表现得更差，不仅产生了模糊的输出，而且产生了一个类似于数字 3 而不是期望的数字 4 的数字。

带上采样的卷积自动编码器

我考虑的下一个架构是具有卷积层、最大池层和上采样层的卷积自动编码器。

Architecture of the Convolutional Autoencoder with Upsampling

在训练指标方面，它获得了比基准模型稍大的 MSE 值；0.0293 关于训练，0.0293 关于验证，0.0297 关于测试数据集。但与之前的模型类似，更差的分数也带来了好处，该模型的规模不到基准的三分之一，只有 2.9 万个可训练参数，但它的表现仍然可以接受。此外，度量的狭窄分布表明，它在没有额外正则化的情况下概括得很好。

在上面的图片上，我们可以看到它仍然能够识别数字并重新排列它。它仍然稍微模糊了边缘，但没有以前的模型那么多。在这种情况下，它甚至删除了顶部循环中不重要的部分。

这个模型也不能识别之前讨论的硬例子，但是它比之前的模型更简单。它的输出部分类似于数字 5，这表明它在识别数字和重建数字时有问题。

组合模型

在看到上采样提供了更好的结果和更精确的输出后，我制作了另一个架构，它以下面的方式组合了上采样模型中的块和完全连接的层。

Architecture of the Combined model

卷积层和池层成功地取代了基准测试的第一个密集层，并产生了迄今为止最好的模型，只有 40 万个可训练参数，这仍然远远少于基准测试的大约一百万个参数。它在训练数据上实现了 0.0151 MSE 损失，在验证数据上实现了 0.0151 MSE 损失，在测试数据上实现了 0.0151 MSE 损失。它生成的情节也比以前的好。

通过混合这两种类型的图层，模型能够生成更精细的线条和更模糊的图像，但重建仍然不完美，如下图所示。

这个硬例子的问题在这个模型的输出上更加明显。

显然，该模型试图重新排列输入的数字，就好像它是数字 5 一样，这加强了这样一种假设，即该模型在这个例子中遇到了困难，因为这个数字是不可识别的。

评论

即使我使用 MSE 作为性能的度量，关于任务本身的一个有趣的评论是，在某些情况下，高 MSE 并不意味着错误的输出。例如，以下预测是由组合模型做出的。

预测图像是基于输入图像预期的绘制得很好的零，但是目标图像上的数字不是以常规方式书写的，因此预测 MSE 误差很高。自然，我们不能通过神经网络来了解这些信息。此外，我之前预计模型会混淆数字 6 和数字 9，反之亦然，但输出图像显示这种情况只是偶尔发生。例如，下图显示了来自验证数据集的 upsamplig 模型的输出之一，该模型已被很好地识别，并且除了尾部模糊之外，被重构为正常的数字 9。

另一方面，我用来演示数据集中的困难样本的问题似乎是一个更大挑战的一部分，因为许多模型在一些情况下很难将数字 4 旋转回来。特别是，具有转置卷积层的模型很难解决这个问题，并生成了如下图像。

但是，其他模型也没有什么不同。例如，基线模型犯了以下错误。

令人惊讶的是，旋转数字 4 产生的图像与数字 5 甚至数字 2 有更多的相似之处。

结论

正如该项目所示，仔细选择模型不一定会提高其性能，但它有助于构建最简单的合适模型，从而减少过度拟合的可能性，正如我们在训练指标的较小分布中看到的那样。一般来说，使用简单的自动编码器似乎是一个合适的选择，因为它以令人满意的方式解决了这个问题，但在指标中可以观察到过度拟合的痕迹，并且它的大小明显大于其他模型。我们可以尝试通过减少中间层的节点数量或简单地省略它们来简化这个模型，但是，如果我们仍然保持 256 个大瓶颈，可实现的最低参数数量大约是 40 万个。此外，额外的正则化技术可能有助于泛化，但这似乎是不必要的，因为具有上采样层的卷积自动编码器能够在网络小十倍以上的情况下实现几乎同样好的结果。这两种类型的层的组合最终以合理的架构提供了最佳的性能。

在这篇文章中，我只挑选了一些图片来展示这些架构的性能。在链接的 Github 存储库中可以找到更多图片的更详细的评估，其中也包括 Keras 中的实现。

https://github.com/pasztorb/Rotational_CAD

关于朴素贝叶斯的一切

原文：https://towardsdatascience.com/all-about-naive-bayes-8e13cef044cf?source=collection_archive---------2-----------------------

学习朴素贝叶斯分类器就是计算每个属性在每个类中出现的次数

朴素贝叶斯是可以应用于数据的最简单的算法。顾名思义，这种算法做出了一个假设，因为数据集中的所有变量都是“天真的”，即彼此不相关。

朴素贝叶斯是一种非常流行的分类算法，主要用于获得数据集的基本精度。

像我五岁一样解释

让我们假设你正在操场上散步。现在你看到一些红色的物体在你面前。这个红色的物体可以是一只蝙蝠或者一只猫或者一个球。你肯定会假设它会是一个球。但是为什么会这样呢？

让我们假设你正在制造一台机器，你已经给了上面的任务，把一个物体分类在球棒、球和猫之间。首先，你会想到创建一个机器，它将识别对象的特征，然后将它与你的分类对象进行映射，这样，如果一个对象是圆形，那么它将是一个球，或者如果该对象是生物，那么它将是一只猫，或者在我们的情况下，如果我们的对象是红色的，那么它最有可能是一个球。

为什么会这样？因为我们从小就见过红色的球，但红色的猫或红色的蝙蝠对我们来说是不太可能的。

所以在我们的例子中，我们可以通过用我们的分类器分别映射一个对象的特征来对其进行分类。在我们的例子中，这个红色是用一只蝙蝠、一只猫和一个球映射的，但是最终，我们得到了一个有球的红色物体的最大概率，因此我们把那个有球的物体分类。

公式

这里 c 代表类别，例如球、猫、球棒。

x 代表单独计算的特征。

在哪里，

• P ( c|x )是类 c 给定预测器 ( 特征)的后验概率。
• P ( c )是类的概率。
• P ( x|c )为似然即预测器给定类的概率。
• P ( x )是预测器的先验概率。

例子

假设我们有 1000 个水果的数据。水果是香蕉、橘子或其他水果，假设我们知道每种水果的 3 个特征，不管是长还是短、甜还是甜、黄还是黄，如下表所示。

从表中我们已经知道了什么？

• 50%的水果是香蕉
• 30%是橘子
• 20%是其他水果

基于我们的训练集，我们还可以说:

• 500 根香蕉中，400 根(0.8)长，350 根(0.7)甜，450 根(0.9)黄
• 300 个橙子中，0 个是长的，150 个(0.5)是甜的，300 个(1)是黄的
• 在剩余的 200 个水果中，100 个(0.5)长，150 个(0.75)甜，50 个(0.25)黄

这将提供足够的证据来预测另一种水果的种类。

假设我们得到了一块水果的特征，我们需要预测它的类别。如果我们被告知额外的水果是长的、甜的和黄色的，我们可以使用下面的公式对它进行分类，并代入每个结果的值，不管它是香蕉、桔子还是其他水果。概率(得分)最高的一方为获胜者。

formula for reference

香蕉:

橙色:

其他水果:

在这种情况下，基于较高的分数(香蕉 0.252)，我们可以假设这个长而甜的黄色水果实际上是香蕉。

用 python 实现

• 用 python 从头开始实现朴素贝叶斯算法并在每一步都有解释，上传到我的 Github 库。
• 在 Scikit learn 的帮助下，朴素贝叶斯的实现也被添加到我的 Github 存储库中。****

** [## 2796 gaur av/朴素贝叶斯解释

这是一个非常深入的解释朴素贝叶斯 w.r.t 在 python 中的实现，可用于机器学习…

github.com](https://github.com/2796gaurav/Naive-bayes-explained)**

优势

• 预测测试数据集的类别是容易且快速的。在多类预测中也表现出色。
• 当独立性假设成立时，朴素贝叶斯分类器与其他模型(如逻辑回归)相比表现更好，并且您需要更少的训练数据。
• 与数字变量相比，它在分类输入变量情况下表现良好。对于数值变量，假设正态分布(钟形曲线，这是一个强假设)。

不足之处

• 如果分类变量具有在训练数据集中未观察到的类别(在测试数据集中)，则模型将分配 0(零)概率，并且将无法进行预测。这就是通常所说的零频率。为了解决这个问题，我们可以使用*滑技术。最简单的*滑技术之一叫做拉普拉斯估计。
• 另一方面，朴素贝叶斯也被认为是一个糟糕的估计，所以概率输出不要太认真。
• 朴素贝叶斯的另一个限制是独立预测者的假设。在现实生活中，我们几乎不可能得到一组完全独立的预测值。

应用程序

• ****实时预测:朴素贝叶斯是一个学习能力很强的分类器，而且速度非常快。因此，它可以用于实时预测。
• ****多类预测:该算法也以多类预测特性而闻名。这里我们可以预测多类目标变量的概率。
• ****文本分类/垃圾邮件过滤/情感分析:朴素贝叶斯分类器最常用于文本分类(由于在多类问题中的更好结果和独立性规则)与其他算法相比具有更高的成功率。因此，它被广泛用于垃圾邮件过滤(识别垃圾邮件)和情感分析(在社交媒体分析中，识别积极和消极的客户情感)
• ****推荐系统:朴素贝叶斯分类器和协同过滤一起构建了一个推荐系统，该系统使用机器学习和数据挖掘技术来过滤看不见的信息，并预测用户是否喜欢给定的资源。

何时使用

• 文本分类
• 当数据集很大时
• 当你的训练量很小的时候

此外，我将添加其他机器学习算法。这篇文章的主旨是深入了解朴素贝叶斯，不使用任何硬词，从头开始解释。此外，如果您想实现朴素贝叶斯，从这些数据集开始，您可以在注释部分用代码注释您的预测得分。

• 虹膜数据集
• 葡萄酒数据集
• 成人数据集

在那之前，

快乐编码:)

别忘了拍手拍手拍手…

关于音乐的一切— 01

原文：https://towardsdatascience.com/all-about-the-music-01-ad1b989260df?source=collection_archive---------6-----------------------

音乐和机器学习

你好。你一天花多少时间听音乐？几个小时，一周呢？据《福布斯》 的一篇文章称，美国人*均每周花 32 个小时听音乐，而且这个数字每年都在增长。嗯，我们都有自己的疯狂和不同的音乐品味。让我们玩一些数据，并试图找出是什么使一些歌曲比其他歌曲获得更多的赞赏。

受到这里的一些文章和数据科学社区在音乐方面所做工作的启发，我决定也做一个实验。因此，今天我们将利用可视化的力量对 Spotify 本周的全球 200 强进行统计分析。

数据集

该数据集由 Spotify 每周全球 200 首歌曲及其各自的 24 个歌曲属性组成，即声音、活力、舞蹈性等。我将描述用于分析目的的最重要的属性。

节拍 —每分钟的节拍数。
能量 —强度和活动的感性度量。它是从 0.0 到 1.0 测量的。数值越高，就越有活力。
数值越高，越容易随着这首歌起舞。
响度 —值越高，歌曲的音量越大(以 dB 为单位)。
效价 —从 0.0 到 1.0 的一个度量，描述一首曲目所传达的音乐积极性。高价曲目听起来更积极。
音质 —数值越高，歌曲越有音质。

如果你想知道更多关于这些歌曲属性的技术描述，你可以访问 Spotify 的这个链接。

数据提取

我使用 Spotify 图表来获取数据集，该数据集由 200 个链接到板上相应歌曲的 URL 组成。接下来我做了一些文本挖掘来提取每首歌的 id。我写了一个脚本，使用 Spotify 的 API 从 ID 中提取歌曲属性，并使用任务所需的适当的身份验证令牌。您可以一次提取多个轨迹的属性，但最多只能提取 100 个，所以我运行了两次相同的脚本来获取所需的数据集。替代方法可以是使用 Echonest API，但从中提取的信息和属性将少于 Spotify API 方法。

不浪费时间，让我们深入研究数据集

Histogram Distribution plot of song attributes

见解:-

1)根据上面的直方图分布图，本周人们更喜欢高能量的歌曲，即更适合于具有高价系数的舞蹈的歌曲。

2)音乐爱好者似乎是一个多样化的群体，他们中的一些人更喜欢每分钟节拍数更多的喧闹音乐，而一些人则更喜欢相反的组合。

3)从分布图中可以明显看出，大多数听众喜欢音乐中的声音较低。

Correlation Matrix

从上图所示的相关矩阵中，我们可以观察到，一首歌没有两个属性有很强的相关性。如果一首歌有活力，声音就会更大。这个事实似乎是真实的，因为可以看出它们具有显著的关系(蓝色的0.68)但不太真实，因为响度不是一首歌曲是否有活力的唯一标准。

一般来说，特征的数量越多，模型就越健壮。有了太多的特征，可视化和处理特征工程就成了一项乏味的任务。12 个特征将导致 144(12*12)个成对的图，以理解一对一的相似性。NAHH！我们不会那样做，我们会做降维。

主成分分析

主成分分析是一种从数据集中大量可用变量中提取重要变量(以成分形式)的方法。它从高维数据集中提取低维特征集，目的是获取尽可能多的信息。随着变量的减少，观想也变得更有意义。

它总是在对称相关或协方差矩阵上执行。这意味着矩阵应该是数字的，并且有标准化的数据。

The scattered plot of two after PCA

PCA 后 99%的方差被恢复，不错..一点都不差！

因此， 64%方差由主成分 1 解释， 35% 由主成分 2 解释。这表明，我们已经从数据集的两个主要部分中提取了大部分见解。因此，在降维之后，我们没有遭受任何重大的信息损失。

如果两个分量不相关，它们的方向应该是正交的。该图像基于具有 2 个预测值的模拟数据。请注意组件的方向，正如所料，它们是正交的。这表明这些成分的相关性 b/w 接*于零。

Outlier Detection using Support Vector Machines

例如，如果我们有兴趣知道是否有任何一首发行的歌曲可以根据上周的歌曲进入全球 200 强名单。我们会比较它是否能把它们放在橙色区域内。这个橙色区域代表本周最受欢迎的歌曲。

让我们做一些可视化

Song Attributes scattered into 3D space

灰色和蓝色看起来不错，但是我想看看更多的颜色

多色..嗯！我知道..我知道，你现在已经看够了那些圆形的斑点，让我们一起来建造一些坚实而科学的东西吧。

标准环面方程

标准圆环被参数化为一个旋转面:一个圆围绕一个轴旋转。这种环面的一般方程是

f(u, v) = [ (a + b*cos(v))*cos(u), (a + b*cos(v))*sin(u),
c*sin(v) ]

这里，输入 u 和 v 可以是来自上述歌曲属性集的任何数字特征。环面主要应用于拓扑学领域，但与环面作用相关的具体问题出现在数学和数学物理的不同领域。

Scientific 3-D plot using the attributes danceability and tempo

C 颂歌和技术描述:-

如果您一直关注这个博客，并且有兴趣了解代码和详细分析的内容。上述分析是在 Python 中完成的，使用 sci-toolkit 库:Sckit- Learn、pandas、seaborn 和 plotly 进行可视化。代码、数据和 Jupyter 笔记本可在 Github 上获得。

这是我将尝试不同声音和演讲的一系列博客文章的第一篇。将它们分成片段，将声音的和弦聚在一起，产生新的回声等等。感谢阅读，敬请关注！

所有的鸟都是黑色的

原文：https://towardsdatascience.com/all-birds-are-black-ec94930294b5?source=collection_archive---------17-----------------------

考虑偏差-方差权衡的一个简单方法

Photo by Hannes Wolf on Unsplash

我遇到过多种方法和哲学来构建模型来代表现实世界的关系。我的统计学教授无情地强调奥卡姆剃刀和吝啬。社会科学家痴迷于在模型中寻找因果关系，通常是通过实验。

Don’t go there, Simba!

在机器学习中，我们很早就被引入了偏差-方差权衡，以及过度拟合的危险。

根据维基百科，基本的想法是:

…偏差-方差权衡是一组预测模型的属性，其中参数估计偏差较低的模型在样本间具有较高的参数估计方差，反之亦然。

迷路了吗？外面有很多很好的解释，但是让我们试着不用图表、数学或者希腊语来解决这个问题。

让我们从最简单的模型开始。一个心智模型。

所有的鸟都是黑色的:最简单的模型

假设你以前从未见过鸟。曾经。(你想象中的老板)要求你:

• 描述鸟类，一般来说，是什么样子的；
• 解释是什么造就了鸟，鸟；或者
• 预测下一只鸟在任何给定的时间和地点会是什么样子。

你可能会观察一只或几只鸟的样子，并对这种鸟做出一些概括。

接下来，假设你遇到一群乌鸦，你得出如下结论:

• 所有的鸟都有两条腿
• 所有的鸟都有喙
• 所有的鸟都有羽毛
• 所有的鸟都是黑色的

恭喜你！你已经建立了你的第一个鸟体模型。

当然，一个人不必是鸟类专家就能知道“所有的鸟都是黑色的”是一个不正确的结论，但是请记住——你从来没有见过鸟！你的模型是过度拟合，你从乌鸦身上挑出了太多的细节，并试图将其推广到整个鸟类种群。你想描述鸟，结果却描述了乌鸦。

在被老板训了一顿之后，你又回到了 bird-verse，建立了另一个模型。建议是“保持简单，笨蛋”。然后你观察一些其他的鸟，得出结论:

• 所有的鸟都有羽毛

Dame Edna has feathers. Is she a bird?

这也不太对。我们已经避免了根据某些鸟类的特殊特征进行归纳的问题。然而，我们已经走得太远了，因为我们对鸟类的普遍特征做了一个单一的声明。

不管怎么说都不是不合理的，但仍然是错误的。

这就是我们说一个模特不合身的时候。你只取了一个特征，但它并没有对鸟类的现状或未来给出一致的预测或解释。在这种情况下，你想描述鸟类，但你最终抓住了每一只有羽毛的鸟。

让我们试着把这带回统计学和机器学习的说法。在第一个模型中，我们减少了解释当地鸟类样本的偏差，但是当推广到另一个样本时，会有更多的方差。

在第二个模型中，我们得到了一个低方差预测器，它在推广到更多鸟类样本时表现良好，但在面对一个有羽毛但显然不是鸟类的样本时面临更多偏差！

我们每天都在建造模型

我们被过度拟合和欠拟合模型所吸引，迭代通过事物如何运作的各种模型，直到我们对事物如何运作有了满意的理解。一旦你开始简单地考虑模型，你会开始注意到到处都有偏差-方差权衡。

Greg learnt about bias-variance trade-off the hard way

建立关系、建立模型和找到我们在环境中观察到的事物的根源是人类的本性。这与我们为机器学习建立模型的方式真的没什么不同。难怪机器最终会像我们一样。

感谢阅读！如果这对您有用，或者您想提出一些改进建议，请留下评论或反馈。

所有 ICML 甘斯/生成论文

原文：https://towardsdatascience.com/all-icml-gans-generative-papers-2018-62b4521bf92?source=collection_archive---------6-----------------------

我去了斯德哥尔摩和 ICML(7 月 10 日至 15 日),理解了 academese，所以你不必这样做！域自适应，3D GANs，使用 GANs 的数据输入等等。

Adversarial Domain adaptation based on CycleGAN — such as CyCADA — are an interesting way to use synthetic or augmented data to help training with e.g. autonomous cars.

然而，严肃地说，我非常尊重 ICML 研究人员展示的所有令人惊叹的工作。我不可能接*他们的工作水*，所以他们推动了这个领域的发展，这是值得称赞的！

总的来说，ICML 是一次令人敬畏的经历。但这篇文章不是关于我的想法、印象或经历。该行业正在慢慢渗透到学术会议中——不管你认为这是不是一件好事——我想我可以更进一步，展示一下在这次会议上出现的从业者观点中最有趣的结果。

这意味着，如果我看不出这些学术贡献如何适用于那些最终目标并不是首先要发表论文的人，我会对一些学术贡献打折扣。这也意味着我将会使用更容易理解的语言，而不会进入任何给定的论文。我会试着用一种更容易理解的方式来表达，这也意味着我会不时地贡献一些你们可能不同意的观点和想法。我的希望是，这将是有用的，特别是对该领域的新来者，给他们一些我在准备这次会议时读过的大约 50 篇论文的背景。

很多时候，解释会变得又快又脏，因为事实上并不是每一篇论文都是严格意义上的生成性对抗网络。所以开始了。

作为我在 Mudano 培训预算的一部分，我选择去 ICML，一个机器学习领域排名前三的会议。这是一次非常丰富和独特的经历。但为了从会议中获得最大收益，我决定跟踪我遇到的大多数论文。然后这些按照它们在会议中出现的时间顺序呈现。我不包括周六和周日，这两天主要是关于研讨会。[1]

11 日星期三

放射杆

GANs 的承诺一直部分在于半监督学习和数据增强。这项工作基本上允许我们利用来自几个来源的多个数据集来获得更好的性能，即使一些数据集质量不高或与手头的任务无关。这是通过首先将数据集转换到某个共享的潜在空间，然后将该空间转换回手头任务的目标域来完成的。

我的想法:我真的很喜欢这篇论文。在工业上可能非常有用。也很清晰的呈现出来。我的一个同事对这种潜力感到非常兴奋。如果适用于你的问题，这篇论文真的可以改变游戏规则。

发现深度生成和判别模型的可解释表示

这基本上是一种人在回路中的主动学习方式，确保我们能够最(人)有意义地解释潜在空间。潜在地降低了准确性，但是允许我们说潜在空间的哪个维度正在影响什么属性。

我的想法:潜在的有趣，因为经常计算潜在空间如何转化为生成的样本是很重要的。陈述不是很清楚。

GANS 的哪些训练方法确实趋同？

在这篇论文中，Lars 等人提出了一种方法——从一个玩具例子开始——在整个训练过程中对 GANs 施加特定等级的梯度惩罚。他们显示的结果与最先进的(SOTA) [2]相匹配，甚至与旧的架构相匹配。作者进一步证明了 GAN 的纳什均衡附*的局部稳定性的一些有趣的性质。代码也可以在上面的链接中找到。

我的想法:相当令人印象深刻的壮举。这种技术相当复杂，但是花时间去理解可能是值得的。其他人也有类似的想法。但在这种情况下，结果是不言自明的。PGGAN-质量结果，无需渐进增长！

These images were generated by pretty standard GAN without progressive growing, just using the techniques from Lars et al.

卡方生成对抗网络

到目前为止，这项工作连接了三个不相连的 GANs 方法—见下图。

我的想法:我对这项工作的看法是，这可能是一个重要的理论，但对从业者的用途可能有限。充分解释什么是力矩匹配偏差超出了这篇文章的范围。我们可以将 IPM 简化为简单地提取产生的和真实的分布与推土机距离的差异，f-GANs 基于f-divergence。

对于从业者来说似乎有点太复杂了。

基于分类的 GAN 分布协变量偏移研究

这是一个很酷的检测模式崩溃的研究。这通常是有意义的，尤其是对于试图发现培训问题的学者。这意味着我们现在终于可以开始讨论这些缺失模式和间隙的影响了。

我的想法:我认为有一个一致的/独特的基准来评估培训质量是有价值的。但是有一些我更喜欢的度量标准，但是这可能是一个整体。

NETGAN:通过随机漫步生成图形

想法:通常有趣的工作表明，GANs 可以用于生成更复杂的图形。根据链路预测精度达到了现有技术水*。

12 日星期四

几何分数:一种比较生成性对抗网络的方法

这项工作表明，使用拓扑分析，我们可以构建一个通用度量来评估我们已经设法覆盖了多少原始数据集。使用一个*似值，我们可以计算出在我们生成的数据集中有多少差异。

想法:我真的对这项工作感到兴奋，因为它允许我们评估任何领域的 GANs，并检查它的模式崩溃。到目前为止，通用的评估方法完全缺失。也许有一天我们甚至会看到质量的衡量标准。

优化生成网络的潜在空间

本文偏离了典型的 GAN 设置，而是着手创建一个能够生成更好样本的模型。这里，我们集中讨论模式崩溃和生成不相同但足够相似的样本的问题。

想法:我对这篇论文有一种复杂的感觉。一方面，我认为这次演讲出人意料地固执己见——对学术界来说是不寻常的——我不同意很多陈述。另一方面，非正式的海报讨论真的很好，也提供了很多信息。在这次讨论中，一位研究人员提出了一个有趣的观点，即模式崩溃是 GANs 工作的原因。这是一个有趣的论断，我很想知道这是否是真的。关于这篇论文有趣的事情是，当我研究它的时候，我发现它差点被 ICLR 拒绝，所以作者重新发表到 ICML。

采用局部坐标编码的对抗学习

本文试图解决与上一篇论文相似的问题，但使潜在空间更加复杂。演示不是很清楚，但要点是探索流形假设，即存在从一些低维潜在空间到复杂流形(如图像)的映射。所有的 GANs 最终都依赖于这个假设，但是如果你考虑一下这个映射，你能从这么低的空间表现所有的图像似乎有点奇怪。出于某种原因，本文无法与现有技术方法相比。

3D 点云的学习表示和生成模型

谁不爱 3D 点云？太棒了。在本文中，作者创建了一个更强大的模型来生成通用对象的三维点云。虽然还有很多工作要做，但它看起来棒极了。

对立学习下的意象翻译理论分析

本文分析了成对翻译 GANs，并指出成对图像到图像翻译的损失本质上有两个组成部分。确保图像正确的身份损失，以及确保图像清晰的对抗性损失。

想法:有趣的理论工作，但可能还不适合从业者。报纸上也没有照片，所以这里至少有一张模糊的(抱歉！)来自海报环节。

生成对抗模型的复合功能梯度学习

想法:这篇文章介绍了一个更复杂的训练机制，看起来在理论上是有支持的，但是接下来创建了一个*似的版本，在训练过程中添加了一个 if 语句，这对我来说有点特别的味道。结果超越了艺术的状态，但是我通常喜欢增加较少复杂性的方法。

缓和的敌对网络

这篇论文背后的高层次思想很有趣。与 PGGAN 相似，作者认为 GAN 从一开始就面临的问题有点太难了。因此，作者创建了一个网络，将图像变形一点，这样生成器就更容易工作了。一个腐朽的版本，胜过最先进的。

使用代表性特征改进生成性对抗网络的训练

本文主要是将生成的图像的自动编码版本连接起来，作为帮助传递给鉴别器。作者的海报非常清晰地描述了该建筑，但不幸的是，这些图片似乎已经从我的手机中消失了。

他们的结果比最先进的要好，但也差不了多少，所以我不确定这是否真的是一个突破。

精确的 GAN WASSERSTEIN 距离的两步计算

本文引入线性规划来计算 Wasserstein 距离的精确值，然后用它来改进训练。Wasserstein 距离的问题是，当你考虑到即使是简单的点云的组合有多复杂时，计算精确的距离似乎也很复杂。本文实现了这一点，并超越了现有技术水*

本文用作基准的数据集既简单又有限(MNIST，CIFAR-10)，所以我很想看看这种方法在 Celeb-A HQ 或 IMAGENET-1000 上的表现如何。

发电机调节与 GAN 性能有因果关系吗？

和其他一些论文一样，我几年前就读过这篇论文了，但是作者做了很好的工作，简明扼要地总结了结果，尤其是对海报而言。基本上，它们使用雅可比箝位来抑制生成器更新，从而实现更稳定的训练。性能没有实质性的提升，但是稳定性的提升是值得的。

作为一个从业者，如果你有 GAN 稳定性的问题，这是可以尝试的论文。

GAIN:使用生成式对抗网络的缺失数据插补

这篇论文可能是从业者最感兴趣的论文之一，因为它处理了一个我们很多人都会遇到的问题——缺失数据。它创建了一个带有提示机制的 GAN 设置，基本上可以智能地推断出缺失值以匹配分布。我们知道 GANs 擅长创建合成分布。提示机制是必要的，因为鉴别器的问题太难了——有许多部分缺失/真实数据的组合有效排列使得这变得难以处理。

我已经向我的一些同事推荐了这篇论文。说够了。

具有有限查询和信息的黑盒对抗性攻击

这是为数不多的现实对抗性攻击论文之一。技术上不涉及 GAN /生成模型——我猜除了干扰——但非常有趣，做对抗性攻击的现实方式。

我仍然不认为深度学习模型足够广泛，也不认为对它们有足够的信任会造成任何真正的伤害，但这篇论文讨论了真正的问题。

一阶生成敌对网络

本文背后的思想是，在梯度惩罚(如 WGAN-GP)的情况下，不是针对 WGAN 损失进行优化，然后添加惩罚，而是直接针对损失进行优化。作者表示，当针对损失进行优化，然后添加惩罚时，会出现病态情况，使得生成的分布本身不太接*目标分布。海报周围有一些非正式的拷问(不是我)/证据，但我不会让作者这样做，哈哈。

利用强化对抗学习合成图像程序

在这里，我不是链接这篇论文本身，而是链接 DeepMind 的一篇出色的博客文章，这篇文章很好地解释了这篇论文。TL；甘博士使用类似 Photoshop 的 API 生成笔触，很好地学习了任意绘制。

MAGAN:对齐生物歧管

好的，所以我现在很确定 MAGAN 代表多种排列 GAN(虽然在演示中没有提到)，但当我第一次看到一个美国人介绍它时，我认为它有一些政治内涵，哈哈。这种 GAN 基本上通过增加对应损失来确保我们总是以相同的对应来对齐两个流形(而不是像其他算法那样随机对齐)。

有趣的花絮，在演讲后的一个“问题”中，有人声称已经有一家报纸在做这件事了。作者不知道这篇论文。你的想法？

对抗性事件时间建模

在与 GAIN 论文类似的领域，除了现在专注于时间序列，并基本上获得了某些事件的时间分布的更好的概率分布(基本上能够自动推断),例如医院环境中的并发症。

可能对处理时间序列的人非常有用。

苏铁:周期一致的对抗性领域适应

这篇论文讨论了一个问题，这个问题是很多从业者反复发现的:我们的模型不能一般化(原谅这个笑话)。通常，您可能会采用一个模型，例如在 ImageNet 上训练的模型，部署它，然后发现它表现很差。因为现实世界比 ImageNet 复杂得多，即使我们只关心 ImageNet 类。CyCADA 扩展了 CycleGAN，基本上能够使用正确的语义进行域到域的翻译，从而有可能在安全、可扩展的计算机生成环境中构建例如自动驾驶汽车，然后将 ML 系统翻译到现实世界中。

真有意思！一定会尝试。

用于生成建模的自回归分位数网络

所以从技术上讲，这篇论文没有什么内容。“只是”自回归模型，但它们取得的结果可与 GANs 的最新技术水*相媲美。非常令人印象深刻的工作，但与每个自回归模型一样，这种设置将难以扩展。演讲结束后，作者提议使用自动编码器来扩大规模，但这带来了一系列其他挑战。

有趣的方法，但类似的(尽管质量较低)作品已经出现，从未超过 32x32 像素的限制，这里也是如此。在这个问题解决之前(许多人已经尝试过了)，不确定这是否真的是可扩展的；另外请注意，甘已经在 1024x1024。

用于 GAN 训练的混合批次和对称鉴别器

与常规 GAN 不同，本文使用混合批次的真实和合成数据来使鉴别器更好。正如作者在总结中所说的“一个简单的架构技巧使得有可能可证明地将批处理的所有函数恢复为一个无序集”。

我真的很喜欢这篇论文，因为它是一个优雅的想法，而且摘要实际上总结了这篇论文。这是否会成为主流框架还有待观察，但是我认为作者引用其他架构的方式有点奇怪(他们都来自一篇论文)。

JOINTGAN:利用生成对抗网的多领域联合分布学习

在这里，作者有一个类似于 CycleGAN 的架构，但不是单独推断条件分布，而是联合学习每个域的边际概率分布。我们从产生 X 的噪声开始，然后在从边缘产生 Y 时以 X 为条件。

我发现演示有点不清楚，但结果似乎真的很有趣。文本生成似乎真的令人印象深刻，但作者说这实际上是由自动编码器从 GAN 生成的潜在空间中完成的。

AUGMENTED CYCLEGAN:从未配对数据中学习多对多映射

通过在第一代和第二代中注入潜在空间，这是对标准形式的 CycleGAN 的一个非常好的扩展。回想一下，周期一致性损失是用 diff(X1，X2)来度量的，其中 X1 -> Y -> X2。基本上，作者给了我们额外的变量来创建具有特定质量的样本。例如，如果我们在 Y 域中有一只鞋的轮廓，我们可以在 X 域中生成一个样本，其中同一类型的鞋是蓝色或橙色或我们选择的任何颜色。

如果你喜欢 CycleGAN，但想更多地控制翻译，你会喜欢这个。

论 GAN 动力学中一级*似的局限性

这是一篇纯理论论文，主要只是在简单例子的层面上进行推理。关键是解释为什么多次鉴别器更新可能是有意义的。本文将它发挥到极致，在最佳鉴别器的情况下，显示出良好的收敛性。但除此之外，目前从业者可能不感兴趣。

ICML 的生成性对抗性网络论文到此结束。我希望你觉得这很有用，如果你想让我在 12 月去的地方制作《来自日本》(或者写一篇关于如何充分利用会议的文章),请告诉我。

感谢凯伦·特里普勒和米哈伊·尔玛柳克的想法和评论！

想加入对话吗？详见**或推特@ langrjakub！我也正在写一本关于** 生成性对抗网络的书，你可以在这里查看 。

[1]我去了可重复的机器学习，这应该是大多数机器学习从业者所熟悉的。但是如果有兴趣的话，我也可以读一下。

[2] SOTA 只是意味着在这个基准上打破以前最好的学术成绩。例如， DAWNBench 是目前在 Imagenet 上达到 93%分类准确率的最先进的存储库。

所有模型都是错误的:第 3 周数据科学沉浸式

原文：https://towardsdatascience.com/all-models-are-wrong-week-3-data-science-immersive-41dad7cc50d9?source=collection_archive---------3-----------------------

机器学习中的模型选择和我第一次 Kaggle 比赛的结果。

著名统计学家乔治·博克斯提出了一个经常被引用的观点:“所有的模型都是错误的。”根据我创建和解释金融模型的经验，我不得不同意。模型是一种有缺陷的尝试，试图用简单的术语描述一种复杂的关系，同时在此过程中做出许多假设。然而，模型也是有用的。他们有能力让我们的生活变得更好。

天气预报是模型力量的一个很好的例子。气象学家从气象气球上收集数据，这些气球被释放到大气的不同层次，并报告观测结果，如空气密度、压力、湿度和温度。这些气球数据被输入到一个预测模型中，这个模型的核心使用了“空气包裹”的简单概念。空气包可以被认为是一个盒子或气泡，其行为符合流体动力学定律。该模型使用这些定律来计算电流梯度的估计值(环境温度、压力等的差异)。)影响气团，然后将梯度的变化率扩展到我们所依赖的 7 天预报中。

Visualization of Air Parcels — http://www.srh.noaa.gov

天气预报模型是否给了我们大气未来(甚至当前)状态的完整知识？不，大气是混乱和动荡的，模型只是*似大块空气的行为，让气象学家充满信心地说，“一个低压系统正在移动，这可能意味着本周末会下雨。”虽然这些天气模型确实有点复杂，但重点是这些模型——现实的简化版本——可以让我们处理生活中的决定——比如是否推迟周六的野餐。

数据科学中一个反复出现的主题是，我们试图选择一个模型(或几个模型)来满足我们的目的。最常用的预测机器学习模型之一是线性回归。为了形成一个线性回归模型，我们手工挑选了一些变量或“特征”，其中每个特征都被假设对最终值“目标”有一个可量化的(标量)直接影响从单一线性关系开始，特性的递增与目标的成比例增加或减少相关联。这种关系可以是积极的——你的房子每增加一*方英尺就会增加它的增值——也可以是消极的——每增加一项信用活动就会降低你的总体信用评分。

Simple Linear Regression with One Feature (Living Area) and One Target Variable (Sale Price)

单一线性关系的概念然后扩展到多变量关系，其中我们结合(添加)每个增量变量的影响来计算最终的目标值。在此过程中，我们将通过权衡每个变量的影响来测试和调整我们的计算，并添加一个常数项来调整基本情况。一个重要的注意事项是，在线性回归中，目标始终是通过扩展从以前实例中学习到的关系来计算新实例的预测值。

数据科学家必须能够识别线性回归是模型的正确选择的情况。如房价和信用评分示例所示，线性回归很容易推广并应用于各种数据集。然而，只有当数据集满足一些基本要求时，它才是合适的。这些要求包括目标预测必须是连续的，每个特征应该独立于其他特征，并且每个特征必须与目标具有*似线性的关系。

本周，我应用我的线性回归知识，开发了一个预测模型，参加了爱荷华州埃姆斯市房屋价格数据集的 Kaggle 竞赛，链接如下:https://www . ka ggle . com/c/house-prices-advanced-Regression-techniques。在这篇文章的剩余部分，我将概述这个挑战，描述我的方法，并分析我的结果。

概述:

Kaggle.com 提供了 2006 年至 2010 年间售出的 1500 套房屋的“训练”数据集。对于训练集中的每一笔房屋销售，我们都会得到销售价格，以及其他 79 条可能影响销售价格的潜在信息。这里是这些特征的一个例子:总的宜居*方英尺，以*方英尺为单位的地段大小，卧室数量，建造年份，砖石饰面类型，地下室装修类型，等等。

对于这个练习，我所有的工作都是在 Jupyter 笔记本上，使用 Python、Pandas 和 Scikit-Learn 库。要了解更多细节，请查看我的公共 GitHub 上的 Jupiter 笔记本“Ames-Submit.ipynb”文件:https://github.com/eversdyk/kaggle-linreg-ames-housing。

第一步:数据探索。

在将数据导入我的 jupyter 笔记本之前，我花了大约一个小时阅读数据集作者的文档，让我对每个功能的可能值以及它们如何影响销售价格有了一个很好的概述。然后我拉了拉。csv 训练文件到我笔记本上的熊猫数据框中，并进行一些探索性分析。在此期间，我发现许多列都有需要处理的空值。我还做了一个功能相关性的快速热图，让我了解影响销售价格的驱动功能。

Continuous Variables Correlation Heat Map

步骤 2:清理测试数据。

首先，我重新排列了 79 个特征，按照变量类型对它们进行分组:连续型、离散型、有序型和分类型。接下来，我检查了每个变量的空值，并适当地填充了它们。对于数值，我用该列的*均值填充了少量缺失的点。对于其他人，我根据其他专栏进行了猜测。例如，在缺少的“车库建造”年份中填入房屋建造的年份。缺失的类别值大多用众数或该类别中出现频率最高的值来填充。对于最后两个清理步骤，我为分类变量创建了‘dummy’布尔列，最后对所有列的值进行规范化，使它们保持在-1 和 1 之间。这种归一化是保持每个要素的最终系数或权重更加*衡的好方法。

第三步:创建一个模型并检查它是否有效。

最初，我尝试了一个简单的线性回归模型，我使用 KFolds 方法对其进行了 10 次训练和拟合。这种 KFold 策略是一种将数据分解成块以进行快速训练和预测的常用方法，它减少了训练数据中异常值的影响。快速检查我的 R *方值显示，这是…完全胡说八道。R *方度量是由给定模型解释的响应数据可变性比率的度量。它预计位于 0%到 100%的范围内，其中 0%意味着你的模型不会比*均响应值的随机猜测更好，而 100%意味着你的模型每次都会完美地确定每个家庭的正确销售价格。我的值是一个非常小的数字，接*于零，这意味着我需要做更多的工作来找到一个有用的模型。

第四步:改进模型，或者尝试另一种技术。

幸运的是，本周我们学习了一种叫做“套索”的技术顾名思义，套索法通过关注变量的一个更小的子集来简化线性回归。简而言之，Lasso 会将冗余要素的权重强制为零，从而消除一些会影响线性回归*似的共线性问题。这一次，R *方得分显示销售价格预测接* 90%，这意味着我们的模型非常好，解释了测试数据中 90%的可变性。使用 Scikit-Learn 的一个名为 GridSearch 的特性，我还对 Lasso 最重要的参数——惩罚值 alpha——做了一些调整。这让我的分数提高到了 91%左右。在这一点上，我有足够的信心根据我还没有接触过的测试数据做出一些预测。

第五步:查看模型是否对测试数据有效，并将结果提交给 Kaggle。

到目前为止，我只处理过训练数据。训练数据包含特征(售出的每套房屋的 79 个变量)和响应(其销售价格)。现在是使用测试数据验证我的模型的时候了。测试数据集包含埃姆斯市销售的 1000 多个新房屋实例的信息(相同的 79 个特征)，这次没有列出销售价格。我获取了这些新数据，并完全按照之前清理训练数据的方式对其进行了转换:组织特征，填充它们的空值，创建虚拟变量，并对所有值进行规范化。由于该模型之前已经与定型数据相匹配，因此它可以为测试数据集中的每个观察值预测销售价格。模型做出了它的预测，我给了他们一个快速的视力测试，以确保他们在正确的范围内。然后，我将预测的销售价格上传到 Kaggle 进行评分。

我的预测结果是用均方根误差法评分的，这是一种衡量我的预测与实际有多接*的方法。值越低越好，我的分数低到足以让我在排名中接*中间。对我的第一场比赛来说还不错！

我仍然不熟悉数据科学和机器学习模型，但第一次比赛是一次宝贵的经历，让我磨练了我的技能。我对我的过程很满意，尽管我会第一个指出我在清理和组织数据时可以做出的改进，比如编写函数来处理批量清理操作，或者以不同的方式填充空值。代替使用套索方法，我可以使用脊或弹性网方法来惩罚系数。我还希望有其他更复杂的连续值预测模型，我还没有学会。

所有的模型在技术上可能都是错的，但是它们可以让我们非常接*解决方案。作为一名数据科学家，我的工作是为每种情况找到合适的模型。

所有的统计学，科学和认识论在 8 分钟内。

原文：https://towardsdatascience.com/all-of-statistics-science-and-epistemology-in-3-minutes-c850731a3d35?source=collection_archive---------1-----------------------

所有的统计学、科学、认识论、“数据分析”、“机器学习”(或者更确切地说，“学习”)等等。归结到一点:通过看尽可能少的页数来“判断”尽可能多的书。更一般地说，它们都遵循以下步骤(这实际上是一篇前一篇的扩展):

1. 现实就是这样。它很复杂，很大，并且有许多活动部件。如果我们对处理一个特定的问题感兴趣，我们可能永远不会看到全部，也不需要真正理解全部。
2. 有数据，我们可以看到和测量的现实的子集。它是从现实中取样的，几乎肯定是通过某种实际上并非随机的机制。
3. 我们对现实有一些想法。我们如何得到它们，没有一致的逻辑。有些事情，我们只是相信。有些事情，我们通过查看数据来了解。有些事情，我们相信通过按照某种逻辑把点连接起来。

造就“科学”的是将信念和数据联系起来的态度:至少，原则上，我们不会把信念看得太重，以至于我们不会忽视数据。然而，即便如此，数据和信念的相对权重还是不同的。阿里尔·鲁宾斯坦对 Dani Rodrik 的新书的精彩评论为一场关于经济学(就此而言，整个社会科学)有多“科学”的长期争论提供了一个窗口。是对数据的态度，比如对科学方法的整体强调，良好的研究设计，以及对数据的有效利用，有利于科学吗？或者，正如罗德里克所强调的那样，是演绎逻辑思维使某些东西成为科学吗？或者更现实地说，是两者的结合？当然，这是一个古老的争论，可以追溯到几个世纪以前，甚至更久。Vladimir Vapnik 不仅是统计学习方法的发明者，也是一位专注于哲学思考的严肃思想家，他关于支持向量机的书在一旁引导了波普尔和其他人对科学和经验思维之间联系的思考——例如，占星术(其从业者越来越多地开发出一致的逻辑和复杂的数学模型来支持他们的工艺，不管它有什么价值)或气象学(其产品仍然不完全可靠，特别是中期或长期)是否符合科学的条件。

值得指出的是，鉴于牛顿物理学(或后来的量子力学)诞生时可用的技术，它们提供了相对较少的明显可检验的预测，许多预测是相当错误的(尽管它们也解释了为什么它们是错误的——并且潜在地为如何评估它们铺*了道路，如果可用的技术允许它们的话)。看起来，科学之所以存在，是因为某种东西并不盲目地服从于经验主义或理论。它让自己被经验数据证明是错误的，但只是在它自己的内在逻辑中提出的条件下。换句话说，科学依赖于一个条件逻辑:不是 X 无条件地是 X，而是只要 A、B 和 C 成立，X 就是 X。因此，从经验证据来看，第一运动定律并不是明显错误的——因为在地球上很少看到永恒的运动，而大多数人都是在地球上收集数据的——因为它列出了它成立的条件(例如，缺乏摩擦，这排除了我们拥有的大部分数据)。

科学的条件逻辑对于它在现实生活中的实际应用，或者说缺乏(直接的)普遍的实际适用性是至关重要的。科学奠定了围绕其理论基础构建的大图景，但现实是噪音。为了科学地对待现实生活，我们需要分两步走:放下大局，然后确定现实生活偏离大局的不同方式。通常，成功的工程利用了第二步，而不是第一步。继续一个愚蠢的例子，牛顿第一运动定律对于实际用途来说是相当无用的——如果所有的东西永远保持运动，我们就不需要担心燃料效率之类的问题。交通运输面临的真正挑战是摩擦，也就是牛顿第一定律所说的“噪音”。但是没有必要完全理解摩擦为什么以及如何工作，只需要理解摩擦在特定情况下的作用。所以我们有一个巨大的表格，里面有各种情况下的摩擦常数，可以用来*似摩擦如何影响运动，我们可以用它来实际应用牛顿定律。(顺便说一句，这就是为什么我发现对“数据科学”中的“科学”的痴迷可能令人不安。我看不出大数据及其噪音如何能提供比牛顿物理学更具体应用的一般理论。我希望大数据能够发现可以作为有用起点的一般原则，但对于特定应用，我们需要弹簧常数、摩擦常数和所有其他半规则基础上重复出现的条件噪声测量值——半规则是指它们的影响是概率分布，而不是无噪声的标量。我们拥有的数据越大，我们就越能够将数据分割成符合特定条件的子集，并为这些条件估计适当的“常数”，以及建立规则和常数可能不可靠适用的子集——本质上是建立效应分布方差的一部分。本质上，我们需要更好地理解噪音，对大模式的偏离。非常坦率地说，要看到大的模式，我们不需要该死的大数据——如果它们足够大，我们甚至可以在小数据中看到它。当然，这更多的是一种工程思维，也许是一种古老的思维。)

这种更倾向于附加条件的思维方式，意味着数据收集的方法不同于目前的做法。目前太多的想法似乎集中于收集更多的数据，而不考虑数据来自哪里。但是大多数数据是无趣的、普通的、可预测的。为了估算火星的“常数”，我们需要火星数据，而不是地球数据。如果我们真的想知道火星常数，我们需要花费数十亿美元发送探测器到那里收集一些观察数据，而不是派人去纽约市周围收集大量数据。换句话说，大数据更有用，因为作为收集它的副产品，我们可能会捕捉到更多我们可以使用的不寻常数据——数据越大，在大量不太有用的数据中可能会有越多有用的小数据。但是，根据数据收集过程，即使是最大的数据也可能无法捕捉到我们需要的足够多的数据。

当然，我们估计的这些常数不会是“真理”，而是“有条件的真理”——我们认为是真实的东西，因为我们在特定的条件下，从我们所拥有的我们(应该)知道是不完整的数据中归纳地了解到了它们。(但是，演绎真理也不是——它们之所以是真理，只是因为我们认为现实的逻辑基础实际上是广泛适用的逻辑基础。除了通过公理化的断言，我们怎么知道呢？甚至建立我们“演绎地”认为是真实的东西也需要经验主义，或者至少可以从经验主义中获益。)它们把我们带回了统计学的根本问题(相对于概率论):我们不知道真相。我们只能从现有的数据中推断出真相。如果我们看到数据中的模式，我们只在我们能扔出数据的范围内信任它们——有时，我们不能扔得很远。知道我们能把数据扔多远(以及收集和分析它们的方法)是我们需要时刻牢记的事情。现代技术大大增强了数据分析的力量，但一些数据仍然非常沉重，难以丢弃，而且无论如何，没有数据可以跨越无限的距离。如果数据说答案是三，不代表答案是三。这仅仅意味着，在我们的询问下，数据显示答案是三。因此，我们相信我们收集和分析数据的方式如此反映现实，以至于我们认为答案是三——这在大多数情况下可能足够好——但有时可能不是。我们可能想知道“有时”可能是什么，也许是考虑我们是否应该购买保险的时候。

我在这里并不完全公*:实验的精神，或数据科学人士的 A/B 测试，反映了这种逻辑，即“自然”可用的数据是有限的，有时需要寻找非自然的数据。然而，更早的实验设计著作，对拉丁方块和其他怪物的详细描述，更热衷于为正确的比较建立适当的匹配，以及为理论产生必要的信心所需的功效计算。人们可能会考虑如何在现代环境中创造性地使用过去精心设计的实验设计。条件均值和方差对于建立实验效应的显著性是至关重要的:我们知道如果 P(X1 |除了 A=0 之外，其他都一样)！= P(X1 |除了 A = 1 之外所有我们知道的都一样)，也许 A 和 X1 有关系。但这将概率论的逻辑叠加到了统计学上:我们(认为我们)知道 A 有影响，所以我们会审问数据来找出答案，即使是通过创造自然界罕见的半人工数据(通过实验。)但是，通常，我们并没有一个很好的理由来预测 A 是否对 X1 有影响。我们希望依靠某种算法来发现是否存在像 a 这样的变量。

嗯，我们已经一直在做这种事情:我们有列联表(或数据透视表)。我们切割数据，并显示它们的条件均值和其他统计数据，这取决于它们属于哪个子集。潜在的警告是，表越大越难理解——但算法不会被这种事情困扰。我们已经在分类方案中使用相似性度量:利用这一点来人为地为所有感兴趣的变量创建“除了一个(或两个或三个)之外，所有变量都相似”的分数，并比较条件均值，这并不是一个很大的飞跃。条件上足够大的差距意味着→值得用人眼进一步看的东西。这在逻辑上相当于一个巨大的拉丁方，存在有趣的缺口，无论是样本中条件*均值的计算值，还是潜在分组缺乏足够的数据，都由编程到算法中的逻辑确定。(潜在的同样有趣的方法是关注条件方差:一些变量组合在一起，可能会产生非常可靠的预测；其他组可能会导致真实数据到处都是。预测分析人士可能会对发现这样的团块感到震惊，但这只是寻求人类更密切的关注和想象力。)

科学不是数据，数据不是科学，科学也不是演绎逻辑。事实上，科学是对数据的巧妙利用与基于条件概率的演绎逻辑的创造性融合:不是 A → B，而是 A →B|X，Y，但不是 Z，所有有趣的发现与其说与 A →B 有关，不如说与“X，Y，但不是 Z”有关(A → B 很好，但它可能不需要大数据或巧妙的实验。)我认为，当科学被应用于实际目的时，条件概率理论更加适用。我们没有永动机。我们需要知道在不同的环境下需要担心多少摩擦——噪音，如果你愿意的话。重要的是，我们现在越来越多地拥有技术和数据来系统地分析大量数据中的噪声，也就是说，如果我们愿意走这条路的话。不幸的是，有条件的部分经常被委托给“技术细节”:所以人们被说服，“嘿，科学！说 A →B！”不，不是真的。真正的“科学”在于“X，Y，而不是 z”。具有讽刺意味的是，经过适当的训练，人类实际上非常擅长破译条件概率，即使有大量的细微差别。人类不擅长的是钻研大量数据，并看到大的模式——因此人类过度拟合和过度概括，看到罕见的情况太多了。如果人工智能可以帮助指出人类真正有用的地方，并让他们远离他们容易看到不存在的东西的地方，那将是一件很酷的事情。

PS。原标题是 3 分钟，然后我岔开话题，继续说了很长时间…

所有的新闻

原文：https://towardsdatascience.com/all-the-news-17fa34b52b9d?source=collection_archive---------3-----------------------

使用 KMeans 对 143，000 篇文章进行聚类。

我最*策划了这个数据集，探索构成我们新闻的类别的一些算法*似，这是我在不同时间阅读和创作的东西。如果你有成千上万篇来自各种渠道的文章，这些文章似乎或多或少地代表了我们的国家新闻格局，你把它们变成结构化数据，你用枪指着这些数据的头，强迫它们分组，这些分组会是什么？

我决定，简单性和有效性的最佳*衡是使用无监督聚类方法，让数据自己排序，无论多么粗糙(类别，无论它们来自什么算法，几乎总是粗糙的，因为没有理由媒体不能无限小地分类)。出于各种原因(本地内存限制、能力、来自更有学问的人的建议)，我选择通过 KMeans 运行一个单词包——换句话说，如果每个单词都成为它自己的维度，每篇文章都成为单个数据点，那么会形成什么样的文章簇呢？如果你渴望跳到“那又怎样”和/或不关心代码，向下滚动直到你看到粗体字母告诉你不要这样做。代码在这里，如果有人想同行审查这一点，告诉我，如果/哪里我搞砸了，和/或给我建议。

因为 KMeans 是非确定性的，所以结果会有所不同；聚类在运行之间会有一点点变化，但是，现在已经做了很多，我可以证明它们不会有很大的变化。这里的结果或多或少是数据所固有的。

简要概述

数据看起来是这样的:

The number of articles in the dataset

这些出版物是基于完全不科学的笛卡尔内省过程选择的，我审视了自己，得出了一个粗略的总结，我认为这是我们国家新闻景观的合理样本。抓取这些文章的方法大致如下:

1. 从无价的 archive.org 上获取过去一年半中每份出版物的存档主页或 RSS 订阅源的链接(如此珍贵，以至于我后来给了他们钱以表示感谢(如果有人在阅读，感谢存在))。
2. 使用一个由 BeautifulSoup 拼凑而成的非常非常粗糙的 web scraper 从存档的主页上的每个链接中抓取每一篇文章。
3. 无趣的数据。
4. 清理不干净的数据。
5. 等等。

也就是说，这里的数据包含了主要从 2016 年初到 2017 年 7 月的这些出版物的文章，并且是在主页或 RSS 提要上出现的文章——即，这不是像 2016 年 8 月 13 日那样对整个领域进行贪得无厌的真空处理。

词干分析

这是数据的一部分:

我做了一个判断调用(你可以判断这个判断)从语料库中删除专有名词。这种想法是，A)它们太多了，B)它们没有告诉我们太多关于写作的内容和方式，C)当试图归结这些类别的本质时，它们是另一种形式的噪音。稍后您将会看到，Python 的 NLTK 是一个很棒的包，但是它并不完美，在试图清除掉一些专有名词之后，它们仍然留在了 corupus 中。

此外，我决定删除数字。这里有一行是关于 NLTK 的标记器有时会在单词末尾留下句点的倾向，我认为这是一个 bug。

堵塞过程看起来像:

import nltk
from nltk import pos_tag
from nltk.stem import PorterStemmer
from nltk import word_tokenize
from collections import Counter
import timestemmer = PorterStemmer()
tokenizer = nltk.data.load(‘tokenizers/punkt/english.pickle’)progress = 0 #for keeping track of where the function isdef stem(x):
    end = time.time()
    dirty = word_tokenize(x)
    tokens = []
    for word in dirty:
        if word.strip(‘.’) == ‘’: #this deals with the bug
           pass
        elif re.search(r’\d{1,}’, word): #getting rid of digits
           pass
       else:
           tokens.append(word.strip(‘.’))
   global start
   global progress
   tokens = pos_tag(tokens) #
   progress += 1
   stems = ‘ ‘.join(stemmer.stem(key.lower()) for key, value in  tokens if value != ‘NNP’) #getting rid of proper nouns

   end = time.time() sys.stdout.write(‘\r {} percent, {} position, {} per second ‘.format(str(float(progress / len(articles))), 
 str(progress), (1 / (end — start)))) #lets us see how much time is left   start = time.time()
   return stemsstart = time.time()
articles['stems'] = articles.content.apply(lambda x: stem(x))

结果是一篇文章由此而来:

Queen Elizabeth II made her first public appearance in almost a month on Sunday, allaying concerns about her health after she missed Christmas and New Year’s Day church services because of what Buckingham Palace described as a persistent cold. The queen, who will turn 91 in April, attended services at St. Mary Magdalene Church in Sandringham...

对此:

made her first public appear in almost a month on , allay concern about her health after she miss and s church servic becaus of what describ as a persist cold the queen , who will turn in , attend servic at in...

词干处理大大减少了语料库的规模。“实现”和“实现”不是被认为是不同的词，并被赋予各自的维度，而是被简化为它们共有的词干，“现实”。这减少了噪音，因此算法不会对出版物使用过去时态而不是现在时态的决定产生影响，或者不会将复数名词视为词汇的不同部分而不是单数名词，等等。

创造词汇

现在进行人数统计，统计整个语料库中的每一个词干，然后可以将其转化为数据帧，用于文档术语矩阵和词汇表。

from collections import Counter
all_words = Counter()
start = time.time()
progress = 0
def count_everything(x):
    global start
    global all_words
    global progress
    x = x.split(‘ ‘)
    for word in x:
        all_words[word] += 1
    progress += 1
    end = time.time()
 sys.stdout.write(‘\r {} percent, {} position, {} per second ‘.format((str(float(progress / len(articles)))), 
 (progress), (1 / (end — start))))
    start = time.time()for item in articles.stems:
    count_everything(item)

然后将其传送到新的数据帧:

allwordsdf = pd.DataFrame(columns = [‘words’, ‘count’])
allwordsdf[‘count’] = pd.Series(list(all_words.values()))
allwordsdf[‘words’] = pd.Series(list(all_words.keys()))
allwordsdf.index = allwordsdf[‘words’]

在数据帧的开头给出:

Republican 的加入是一个很好的例子，说明词性标注者并没有完全去除专有名词。但忽略这一点，语料库现在是一个数据框架，词汇表中的每个术语都是索引中的项目，这在不久的将来会很有用。

当处理来自因特网的文本数据时的一个挑战是，非单词，如字符和符号的组合(例如，“@username”，“#hashtags”，用类似“well 1…”的省略号连接的单词)，以相对频率出现。我决定只保留 NLTK 的完整英语语料库中的单词，而不是找到并清理每一个单词。语言学家们还在争论这个语料库有多完整，但是有 236，736 个单词，这是一个相当大的数字。我们将首先通过对整个英语语料库进行词干分析，然后将该语料库与我们自己的语料库进行比较，来完成我们的数据框架的最终精简:

from nltk.corpus import wordsnltkstems = [stemmer.stem(word) for word in words.words()] #stem the #words in the NLTK corpus so that they’re equivalent to the words in #the allwordsdf dataframenltkwords = pd.DataFrame() #make a new dataframe with the stemmed #NLTK wordsnltkwords[‘words’] = nltkstemsallwordsdf = allwordsdf[allwordsdf[‘words’].isin(nltkwords[‘words’])] #keep only #those in the stemmed NLTK corpus

这将总词汇量从 89216 减少到 34527。它处理了词汇表中的每一个细节，我花了几个星期才考虑这个解决方案。

将单词矢量化

粗略地说，TfIdf(术语频率-逆文档频率)矢量器为每篇文章中的每个词给出一个值，该值由该词在整个语料库中的频率加权。逆向文档频率是从单词在整个数据集中的频率得出的分母。以“perspicacious”这个词为例，由于它在英语中有许多更好的替代词，这个词是一个我们很幸运几乎看不到的扯淡词。由于这种稀缺性，它的反向文档频率，或妖魔化，是低的。如果它在一篇文章中出现 15 次，那么它的 Tf 值或分子将会很高。因此，它的 TfIdf 值将是一个大分子，而不是一个小恶魔，从而产生一个大数字。因此，在我们数千维的空间中，文章在“洞察力”维度上具有价值。(当然，这还不包括向量的归一化和寻找 TfIdf 值所涉及的其他任务。)

当使用这种类型的矢量器时，包含非索引词(算法忽略的词的列表)并不重要，因为不常用的词被赋予较低的值。但它仍然是有用的，因为至少它降低了内存的使用，减少了我们的空间已经非常高的维度。此外，创建一个单词库可以确保出现在一篇文章中的非常罕见的单词不会自己聚集在一起。我选择了第 40 个分位数以上的单词。乍一看，这似乎很高，直到你看到这个分位数包含的内容:

allwordsdf[allwordsdf[‘count’] == allwordsdf[‘count’].quantile(.4)][:10]

因此，第 40 个分位数包括在整个语料库中只出现 9 次的单词——非常低，因此不倾向于提供信息。为什么不是第 50 或 60 分位数？因为必须在某个地方选择一个数字，它可能就是这个。

创建停用词，矢量词汇和矢量。写停用词和词汇表可能是多余的；我把两者都加进来是为了更好的衡量，因为我们以后需要这个词汇列表。

from sklearn.feature_extraction.text import TfidfVectorizerstopwords = list(allwordsdf[(allwordsdf[‘count’] >= allwordsdf[‘count’].quantile(.995)) | (allwordsdf[‘count’] <= allwordsdf[‘count’].quantile(.4))][‘words’])vecvocab = list(allwordsdf[(allwordsdf[‘count’] < allwordsdf[‘count’].quantile(.995)) & (allwordsdf[‘count’] > allwordsdf[‘count’].quantile(.4))][‘words’])vec = TfidfVectorizer(stop_words = stopwords, vocabulary = vecvocab, tokenizer=None)

现在要转换数据帧:

vec_matrix = vec.fit_transform(articles[‘stems’])

这就产生了一个矩阵形状的(142570, 20193)，也就是大约 20，000 个单词。

降维

把我们的 20，193 维矩阵降多少维很难回答。Sklearn 的官方推荐声明，“对于潜在语义分析(我们在这里做的)，推荐值为 100。”我用所有 20，193 个维度对这些数据进行了聚类，用 100 个维度进行了聚类，用 3 个维度进行了聚类，每一次，这些聚类看起来都与有多少个维度无关。这最终归结为减少处理时间，因为创造这个包的人的智慧规定了 100 个维度，所以它是 100 个维度。

from sklearn.decomposition import TruncatedSVDpca = TruncatedSVD(n_components=100)vec_matrix_pca = pca.fit_transform(vec_matrix)

使聚集

更难回答的是给数据分配多少个聚类。对于 KMeans，数据过于紧密地聚集在一起，不适合分层聚类或任何自己查找聚类的算法。如上所述，我选择了十作为起点。

from sklearn.cluster import KMeansclf10 = KMeans(n_clusters=10, verbose = 0)clf10.fit(vec_matrix_pca)

现在，将我们刚刚创建的标签分配给原始数据帧，以便进行分组、可视化和分析:

articles[‘labels’] = clf10.labels_

我们可以看看每个出版物的文章被分配到每个标签的百分比:

labelsdf = articles.groupby([‘publication’, ‘labels’]).count()
pubslist = list(articles[‘publication’].unique())
labelsdf[‘percentage’] = 0for index, row in labelsdf.iterrows():
    for pub in pubslist:
        for label in range(10):
            try:
                labelsdf.loc[(pub, label), ‘percentage’] = labelsdf.loc[(pub, label), ‘id’] / labelsdf.loc[(pub), ‘id’].sum()
            except:
                passlabelsdf = labelsdf[['publication', 'labels', 'percentage']]

等于

诸如此类。

如果你向下滚动，这里是停止的地方

这些图表是在 RStudio 中用 Plotly 制作的，plot ly 是一个有时质量不佳但仍然有用的数据软件包。

这些是聚类，每个聚类中的前 200 个单词及其 TfIdf 值。单词越大，确定是什么组成的集群就越重要。它们不会被政治联盟、基调或其他任何东西所瓦解；当数据聚集在一起时，会按类别分解。记住，我们选了十个；我们可以选择 8 或 20 个并得到不同的集群，但这些是最突出的。一个是关于俄罗斯的所有事情-丑闻，另一个是关于外交政策，另一个是关于教育等等。随意探索。(Plotly 允许用户放大，但字不会变大；我已经通知了当局来解决这个问题。)

下面是出版物是如何按组分类的。(同样，对于隐私獾用户来说，这个就是。)

还有最后一个 viz，如果它大小引起了问题，我很抱歉，但是我认为它很重要。

它的名字(“articlestest”)应该表明我在创建它时处于什么准备阶段，它与最终的数据集略有不同——除了其他所有东西，它还包括来自 the Verge 的长篇文章，我选择了去掉它。它是将所有数据缩减为三维的可视化，而不是 20，000 多个维度(或上面主成分分析中使用的 100 个维度)。添加边缘会给人一种与移除边缘时截然不同的形状，我完全不确定这是为什么。但是如果你观察它，你可以看到每个集群在三维空间中形成的位置，你可以双击右边的每个出版物名称，只保留那个出版物。如果你点击它们，你会看到几乎每一个都是无形的数据点云，除了路透社，它形成了一个几乎完美的 l。

推论性的结论

不同的人可能会对这些数据和图表有不同的解读，但我是这样解读的:当被迫分组时，出版物被归类为路透社和其他。

我不认为这是对数据的过度提取。数据科学的一个主要哲学基础是，潜在的真理和联系是由表面现象引发的，一个人说话的语气或穿着的风格比我们愿意承认的方式泄露了更多关于我们的信息。这些出版物中的一个以与其他出版物如此不同的形式出现，完全基于它覆盖的主题，这将被合理地认为是考虑它与数据集的其他成员根本不同的原因。

诸如此类的结论应该经得起纯粹反思的考验——考虑到阅读这些出版物的体验，这些结论有意义吗？

在 Medium 的几个门下，兰詹·罗伊 写了一篇文章关于 Vice 的夏洛茨维尔分部看似不可思议的病毒式传播。他提醒我们，Vice 现在是另一个默多克资助的暴行机器。我不同意罗伊的观点，即视频的点击率如此容易地归因于 HBO 的阴谋诡计(因此暗示病毒传播可以被预测地设计，但它不能)，但就我们的目的而言，他以一个有益的反思结束了这篇文章:

我们越是接受耸人听闻的现实，我们就越糟。只要我们让我们的蜥蜴脑控制我们对世界的感知，我们就没有机会。如果我们没有意识到我们所观看的背后的动机，疯狂的人总是会赢。

这是价值十亿美元的媒体，由拥有福克斯的同一个人出资。它完善了让你下去的艺术。记住，在一个我们每天花费 116 分钟消费广告资助的社交媒体的世界里，最响亮的声音总是会赢得。[强调他的]

除了路透社之外，该数据集中的所有出版物都有一些共同点。它们完全由广告和/或订阅资助(Vox 和 BuzzFeed 也有风险投资，但它们是基于广告的模式)，它们的存在依赖于点击。相比之下，路透社的新闻产品仅仅是一家大型信息集团的公众形象。或许更重要的是，它是一家新闻通讯社，其报道包括我们金融世界的事务，因此被赋予了不同于其他媒体的使命——可以说比《纽约时报》更重要，它必须覆盖所有新闻，而不会陷入人物驱动的真人秀，而该数据集的每个其他公民似乎都非常喜欢这样做。在所有这些事件中，它的声音倾向于保持最适度的室内音量，如果路透社能够激起愤怒的话，没有一个全球性事件会激起比生活更大的愤怒。也许这是隶属于财经出版社，宏观分析世界的产物；非金融媒体的叙述未能对伦敦银行间同业拆借利率(LIBOR)的变化和一个疯子的政策提议给予同等的重视，尽管按理说应该如此。这里的所有其他出版物似乎都带有乌托邦的暗示，它们内容的潜台词通常是，如果我们在食谱中混合了正确的成分，一个完美的世界就会实现，而你感到愤怒的事情实际上是我们和天堂之间的事情。在我作为读者的经历中，我从来没有感觉到路透社有任何类似的东西。

这不应被解释为断言《纽约时报》和《布莱巴特》因此是同一批中风患者。我今天在《泰晤士报》上读到了一篇设计精美的文章，内容是关于生物发光在深海生物中是多么普遍。不言而喻，在布莱巴特找到这样一份文件的可能性几乎为零，这是我对政治光谱的这一领域感到非常悲哀的事情之一，也是对其截然相反的反对者的一份谈话要点备忘录。但这才是重点:给一个算法看你写的关于深海生物的故事数量，它就会显示你是谁。在更精细的分辨率下，我们可能会发现《纽约时报》和《福克斯新闻频道》之间的鸿沟，或者《NPR 时报》和《纽约邮报》之间的鸿沟。看到上面的第三个聚类了吗，所有的单词都用较低的 TfIdf 值进行了压缩，没有突出的内容。它实际上是其他主题的整个丛林，你可以在那个集群上运行算法，并获得新的分组和区别——这些集群中的一个也将是不同类型故事的压缩，你可以在机器学习的分形中一遍又一遍地这样做。这里的区别不是唯一的，但从数据的空中视角来看，这是第一个。

作为一个创造内容的人，我在法律上有义务经营一份个人时事通讯。可以在这里 报名参加 。

您需要了解的所有机器人流程自动化(RPA)统计数据

原文：https://towardsdatascience.com/all-the-robotic-process-automation-rpa-stats-you-need-to-know-bcec22eaaad9?source=collection_archive---------2-----------------------

如果你在过去几年里一直关注科技行业，你可能已经听到了很多关于机器人过程自动化(RPA)及其改变我们工作方式的潜力的讨论。专业领域正从智能自动化初创企业及其应用的爆炸式增长中受益匪浅，这些应用的目的是简化工作流程、实现任务自动化，并让人类工人专注于高价值的工作。WorkFusion 拥有一套智能自动化产品来帮助您扩大运营规模并降低管理成本。

没有一个放之四海而皆准的统计数据可以准确评估 RPA 可以为您的公司节省多少资金，它可以自动化多少工作流程，以及在不雇佣数百名员工的情况下您的运营规模可以有多大。这主要是因为不同的公司有不同的技术、系统、流程，并且他们在不同的行业工作。然而，有一些 RPA 数字可以让您了解该技术可以提供多少自动化，以及它可以提高您的 ROI 多少。

以下是围绕该技术的一些关键数据:

1)它能帮你实现什么自动化

RPA 在各种规模的企业中变得越来越普遍，帮助他们自动化繁重的工作，如会计和 IT 任务，以帮助保持您的运营顺利进行。这项技术非常有助于减少任何人工操作中必然会出现的人为错误。得益于人工智能(AI)、机器学习(ML)、大数据、语音识别技术和深度神经网络方面的最新进展，RPA 在后台和前台实现了基于规则的流程自动化。

该技术有助于降低成本、提高准确性、改善服务交付、帮助解决合规和监管问题，同时还能改善客户体验。这些基于规则的流程中大约 70%到 80%可以实现自动化，从而让企业以比离岸更低的成本在国内运营。使用 RPA 的公司不需要依赖离岸或外包合作伙伴，从而确保 100%的准确性。

2)减少工时

根据 软件测试和大数据 Hadoop 的研究，大约 10%到 20%的人类工作时间花费在枯燥、重复的计算机任务上，相当大一部分时间浪费在可以轻松自动化的流程上。该公司的研究人员估计，IT 部门也有 30%的时间花在低级别的基本任务上。此外，大约 50%的公司在每张人工处理的发票上花费 5-25 美元。

企业*均错过了大约 50%的自动化机会，而 13%的员工认为这些重复的任务是浪费时间。此外，98%的 IT 业务领导表示，自动化流程对于推动业务收益至关重要。可以自动化的主要任务依次为:

• 文件和记录管理。
• 索赔、预订和发票管理。
• 客户关系管理。
• 人力资源流程。
• 它处理。

WorkFusion 有一个 RPA *台，可以帮助公司在 RPA Express 中自动化这些任务和更多任务。

3)RPA 的未来

Hadoop 的研究人员估计，到 2025 年，公司将通过 RPA 节省 5 万亿至 7 万亿美元。该公司还预测，到同一年，RPA 软件将能够完成相当于 1 . 4 亿全时当量的任务。 Statista 认为，到 2019 年，RPA 行业价值将达到 31 亿美元，到 2020 年将达到 49 亿美元。据 Forrester 预测，到 2021 年，这一数字更有可能达到 29 亿美元左右。

AB Newswire 补充道，RPA 市场目前由北美地区主导，亚太地区在医疗保健、零售、IT、BFSI 和电信行业也在高速采用该技术。中国和印度已经开始推出外包服务，推动了这些地区的市场。在欧洲，RPA 预计将在制造业和物流业增长，尤其是在德国、俄罗斯、西班牙和丹麦。

底线…

没有人知道 RPA 在以前只能手动执行的自动化任务中会走多远，但该技术在转变企业运营方式方面有很大的潜力。未来几年，世界各地的几乎每个行业都将受益于智能自动化系统的功能。只要企业在寻找新的解决方案、更低的开销和更高的投资回报，RPA 就会继续变得更加复杂和流行。

关于正规化，你需要知道的是

原文：https://towardsdatascience.com/all-you-need-to-know-about-regularization-b04fc4300369?source=collection_archive---------3-----------------------

过度拟合的原因以及正则化如何改善它

爱丽丝 : 嘿鲍勃！！！我已经对我的模型进行了 10 个小时的训练，但是我的模型产生了非常差的准确性，尽管它在训练数据上表现得非常好，这是什么问题？

鲍勃:哦！！看起来你的模型在训练数据上过度拟合了，你使用正则化了吗？

艾丽斯:那是什么？

这种与过度拟合相关的问题在 ML 中很常见，有许多方法可以避免这种问题，但是为什么会出现这种问题？

训练一个模型的过程似乎很简单:

1. 收集数据
2. 预处理数据
3. 设计一个模型
4. 训练模型

但是在这个过程中间发生了什么呢？什么导致过度拟合，为什么正则化给出了解决方案？

过度拟合的主要原因可以追溯到开始的两个过程，数据的收集和预处理。具有不均匀特征分布、包含噪声、数据中的随机波动、非常高的方差的数据集合可能对模型训练产生相反的影响。这些随机误差和波动在训练时被模型很好地学习，以至于训练数据模型的精度变得非常高，导致数据的过度拟合。有时超过要求的训练会导致过度适应。

source : https://stats.stackexchange.com/

那么，怎样才能避免过度拟合的问题呢？

可以容易地观察到，权重越高，非线性就越高，因此一种简单的方法是在更新权重时惩罚权重。在这一点上，我们有两个这样的技术使用这个想法。

1. L1 定额:

其工作方式是在我们需要减少的误差函数中添加一个带有参数 λ 的惩罚项。这里 w 不过是权重矩阵。

这里， λ 是一个超参数，其值由我们决定。如果 λ 很高，它会对误差项增加很高的惩罚，使得学习到的超*面几乎是线性的，如果 λ 接* 0，它对误差项几乎没有影响，不会导致正则化。

L1 正则化也经常被视为一种特征选择技术，因为它将不需要的特征的相应权重清零。L1 在非稀疏情况下的计算效率也很低。L1 有时可能被称为套索回归。

2. L2 常模:

L2 的正规化可能看起来与 L1 没有太大的不同，但它们有着几乎不相似的影响。这里重量“w”分别*方，然后相加。L1 的特征选择属性在这里丢失了，但是它在非稀疏情况下提供了更好的效率。有时 L2 被称为山脊回归。参数 λ 的作用与 L1 相同。

提前停止:到目前为止，我们已经添加了惩罚来控制权重值，但也有其他方法来调整，如果在训练过程中，训练误差开始下降，测试误差开始上升，我们会停止训练。这将为我们提供所需的列车测试误差设置。这种技术通常被称为提前停止。这种技术可能会给我们想要的结果，但一般来说，有些人不建议这样做。

source : deeplearning4j.org

退出:这是 Srivastava 等人(2014 年)首次提出的一种有趣的正则化神经网络的方法，该论文提出，一个层中的一些节点必须随机选取，并且应该在训练期间被丢弃/忽略。

source : commonlounge.com

每个节点都有被丢弃的概率，假设一个节点的 drop_prob =0.4，那么它有 40%的机会被丢弃，60%的机会被拾起。每次这个概率都会导致神经网络改变形状，每次看起来都是一个新的网络。这种技术似乎很好地解决了正则化的问题。丢弃的概率不是很高，因为这将使网络稀疏，从而导致不匹配。

数据扩充:我们可能会看到计算机视觉中的过拟合问题，数据扩充是解决这一问题的更好方法。我们只需要自己放大图像，比如翻转、裁剪、旋转图像。

source: medium.com

这种类型的增强似乎产生更好的结果，因为它提供了在一些变形图像和其他变化上进行训练的机会，并且当可用数据较少时，数据增强也有帮助。

这些是一些有助于解决过度拟合的正则化技术。有时调整超参数可能会得到想要的结果，但如果没有改善，那么上述技术肯定可以解决这个问题。

关于区块链，你需要知道的

原文：https://towardsdatascience.com/all-you-need-to-know-about-the-blockchain-a23388109774?source=collection_archive---------10-----------------------

Photo by Daniil Peshkov | Dreamstime.com

当你周围的几乎每个人都在谈论完全不属于你专业领域的事情时，你会感到困扰吗？他们用一些听起来很奇怪的术语，脸上带着公事公办的表情，这让你更加恼火。你只捕捉到一些像区块链、比特币之类的词，但作为一个整体，你无法解读这些胡言乱语，即使这个主题听起来对你来说很有趣。所以，一个简单易懂的解释正是医生所要求的，对吗？我也这么认为。这就是为什么你在正确的地方得到你需要知道的关于区块链的一切，以摆脱那些自鸣得意的万事通。

一些专家认为它是未来几十年最有影响力的技术，甚至称之为“下一代互联网”。由于区块链如今受到媒体的广泛关注，这个概念对于外行人来说应该比较容易理解。但是在现实生活中，事情要复杂一些。因此，我邀请你加入我的旅程，探索区块链及其衍生品的基本原理——智能合约、分布式账本、比特币和许多其他东西。

在区块链出现之前是怎样的

为了弄清楚区块链是什么，有必要了解在这项技术还没有出现的时候，情况是怎样的。

我们的日常运营会产生持续的数据流。当你用信用卡给你亲爱的侄子转账或者给你的合伙人发合同签字时，你给他们的是复印件，而不是原件。如果在 Word 文档中，一个文件可能有两个样本(原始版本和您发送的版本)，那么其他一些资产(比如钱)是不能复制的。所以，每个人都必须确定，在你付款后，你没有另一个版本的相同货币可以转移给别人。

传统上，我们依赖一些中介，如银行，将所有数据保存在一个数据库或数据中心。它拥有数据的唯一副本，而且从理论上讲，每个相关人员都可以访问它。然而，现实有所不同，也更加复杂。

除了我们在提交信息时必须信任这些中介这一事实之外，随着时间的推移，还会出现一些问题。事实上，所有东西都存储在一个地方(意味着它是集中的)，这使得它容易受到攻击。此外，在上述合同的情况下，双方不能同时处理同一份文件，这就产生了版本可能丢失、文件在接收方之间来回移动以及时间延迟等其他不便的问题。

区块链的到来(红利:它是什么)

为了解决上面提到的问题，科学家 Stuart Haber 和 W. Scott Stornetta 在 1991 年开始研究一种密码保护系统，其中文档的时间戳不能被调整或回溯。然而，区块链领域的第一个重大成果是在十多年后由中本聪取得的，当时他利用哈伯和斯托纳塔的想法开发了比特币的基础设施。

在某种程度上，区块链引入了一种新的做事方法:每个节点都可以看到系统中发生的所有事务，并且应该收到每一个事务的副本，以更新其数据，并从本质上批准它。

基本上，它只是一种存储数据的新方式。它与现有数据存储技术的唯一区别在于整个过程是如何完成的。区块链建立在这样一个原则上，即所有信息都应该分布在多个位置，而不是一个位置，使用最高级别的加密技术。这意味着所有参与者都相互连接，并拥有给定数据的相同副本。如果你过去使用过种子，你可能会注意到一些相似之处。

区块链如何改变过程

因此，技术给了我们一个分散的数据库版本，或者是网络中任何人都可以使用的交易的数字分类账。它允许用户通过在几乎任何操作中绕过第三方(数据存储)来利用彼此的对等通信。

但是这给每个参与者个人带来了大量的工作。这个问题由一个名为“矿工”的特殊群体解决，他们获得令牌(比特币或其他数字货币)来处理这个问题。在硬件能力的帮助下，矿工创建信息块，存储在给定时间内系统中发生的所有交易，并验证它们。

我不会深入研究这个过程，但基本上，它涉及到解决一个计算问题(更详细的解释见下面的信息图)。然后，这些块被添加到已经存在的块中，创建一个链(因此得名)，其中所有信息都按时间顺序保存，并且可以很容易地访问(这使其真正公开)。

Image is created by the author and all rights reserved for X1 Group

一旦你成为系统的一部分，你就有了两个密钥:公共密钥(你的地址，或者，为了简单起见，你的用户名)和私人密钥(你的密码)。换句话说，黑客不能犯任何错误，因为他或她应该找到并改变一个特定的块加上所有前面的块，但是正如你已经知道的，所有的块同时位于所有现有的计算机上。最重要的是，它们用特殊的数学函数(用户的私钥)加密。有了这样一种优雅的、乍一看并不显眼的技术，漏洞问题就变得几乎无关紧要了。

加密货币

现在，在 2018 年，它成为一种资产形式，可以投资于那些寻求有利可图的机会并且不怕承担风险的人。尽管市场波动很大，但需求是巨大的。加密货币是一种数字货币，它使用加密技术来控制其金额并验证资金转移，独立于中央银行运行。

在 2009 年，比特币出现的那一年，没有人会想到 9 年后超过 1900 种加密货币会提供给每个愿意放弃一些钱来换取数字货币 的人。其中最受欢迎的是比特币和以太坊。让我们来讨论一下这两者有什么不同，以及为什么他们成功地更好地了解了这种势不可挡的隐热。

比特币是众多获得国际认可的货币中的第一种，现在，它是价值最高的加密货币之一。不清楚为什么大家都对比特币如此狂热。有人说骗子让它流行是因为你做的交易是匿名的，几乎无法追踪；其他人说，这只是因为它很容易设置，你可以快速，安全地进行支付，交易费用最低。

Photo by Thought Catalog on Unsplash

但是不要搞错，以太坊可以做同样的事情，甚至更多。它在已经蓬勃发展的技术中达到了一个全新的水*。以太坊基本上不仅仅是加密货币，还是一个有自己虚拟语言的中心化*台。使用这个*台，作为一个功能更强大、更灵活的工具，开发者可以创建新的区块链应用程序。

此外，以太坊使用智能合约，并包括一种同名的数字货币，但只是作为副产品。智能合约本质上就是它听起来的样子。这是一个自我实现和执行任何算法的合同，你把它放入使谈判者之间达成协议更容易。这个工具有可能比区块链本身更具革命性。

区块链可能影响的行业

金融科技(银行和支付)

最有可能的是，从区块链的出现中获益的第一个行业是金融业。这项技术的集成让世界各地的每个人都可以获得金融服务，包括那些无法获得传统银行服务的人。与通常的方式相比，在通常的方式下，信息会通过一整套公司传递，每家公司都从中分一杯羹，从而降低了交易速度。相比之下，基于区块链的交易可以让你汇款无国界，费用几乎可以忽略不计。

更重要的是，收款人不必等几天才能拿到钱；整个过程发生在几分钟内。一些银行已经对这项技术表现出极大的兴趣，并开始投资——甚至采用——它来使他们的操作更快、更有效、更安全。

保险

全球保险业是一个相当复杂的机构，它的一些职能很难把握。通过使用区块链，消费者将能够看到他们投保了什么，他们是如何确保的，哪一方参与了，以及他们为什么会收到那么多的赔付。本质上，这意味着用户可以跟踪整个过程，并更好地了解整个市场以及他们可以选择的价值。

此外，通过使用区块链，整个行业可能会大大简化，因为将消除这么多参与方的需要。它将使所有形式的保险过程更加高效、自动化和透明，为消费者带来更加顺畅的体验。

政府和投票系统

这也许是区块链可能扰乱的最重要的社会领域。历史上有很多政党被指控操纵选举结果的例子。合法计票系统保证没有选票被篡改或删除，此外还有不可更改的公开注册，这将是对我们现有制度的巨大改进，使选举更加公*和民主。

Photo by Arnaud Jaegers on Unsplash

考虑到政府系统是多么缓慢和容易腐败，使用区块链可以大大减少官僚作风，提高政府运作的效率和透明度。

募捐

ICO(首次公开募股)是一种为你的创业公司获得投资的全新方式。这个过程有两个阶段——私人的，也称为“预售”和公共的。愿意启动项目的新公司向私人投资者发放品牌代币，以获得启动项目的第一笔也是最重要的融资。

这一步通常包括为准备投资的人提供巨大的折扣，但这也限制了最低购买金额。实施这样的政策是因为潜在投资者可能获得巨大的投资回报，因为预售通常发生在规划阶段。当一家公司证明了自己的价值，现在需要资金来支付运营成本、开发甚至可能部署产品原型时，第二个(公开)阶段就开始了。

在这个阶段，每个感兴趣并愿意参与的人都可以获得代币。在任何时候购买的所有代币都可以在以后兑换成产品、服务或现金。即使这些投资还远未确定，初创公司也通过这种方式筹集了数百万美元。

我们的身份

区块链提供的整套工具使得验证和管理某人的身份或者在愿意交互的各方之间建立至少某种程度的信任变得更加容易。在我们的一生中，我们创造了一些信息碎片来构建我们的虚拟形象。评论、评级、位置和证书:这些甚至都不是一个人数字足迹的重要组成部分，你可以拼凑起来，用来降低你在与谁打交道的不确定性。

听起来很容易，但事实上并非如此:这些信息都是碎片化的，因为我们每个人在网上都有大量的个人资料。区块链允许我们创建一个开放的全球*台来存储每个人的所有凭据。这也意味着我们可以通过选择我们想要透露的信息来保护我们的隐私，例如，达到法定年龄或从大学毕业。

什么会出错

尽管整个事情听起来很美好，但这项技术有一些需要注意的缺点。

首先也是最重要的是，区块链很复杂，而且不是真正的用户友好型。你可以在软件上花费数百万美元，开展大规模营销活动来展示你的产品有多好，但最终用户可能不会分享你的兴奋。为什么？因为大多数时候，消费者评价的是软件的前端部分，并不关心让一切运转的巧妙技术。听起来很刺耳，但事实就是如此。区块链驱动的软件对于普通用户来说远没有那么方便易用。

由于其复杂、加密的特性，区块链的交易可能会很慢，尤其是与现代的信用卡交易相比。相比之下，比特币交易可能需要 5 个小时才能完成，这使得使用加密货币支付晚餐的可能性非常小。此外，随着规模的增长，所有这些区块链变得越来越复杂，难以置信地笨拙，最终将使它们变得更慢。

它为常见问题提供了许多可能的解决方案，加强了我们的金融安全，保护了我们的数字身份；然而，这项技术不是万灵药，它还没有很好地融入我们的生活，这就产生了一些问题。

其次，缺乏监管创造了一个危险的环境。由于监管不力，区块链是骗子和市场操纵者的温床。例如，一种非常有前景(乍一看)的加密货币 Oncecoin ，它承诺其投资者成为“下一个比特币”，结果却是一个聪明的庞氏骗局，夺走了数百万人的钱。

随着区块链的疯狂，识别欺诈变得非常困难，即使你决定坚持使用成熟的硬币(如比特币或以太坊)，也不能保证你的钱是安全的。交易所网站或你的在线钱包(你存放硬币的地方)被黑的几率非常高。相信我，我知道我在说什么——我的钱包被黑过一次；我的钱不知去了哪里，所有这些“高度安全的钥匙”都没有帮助(不要搞错，我说的主要是这些存储的脆弱性，而不是区块链本身)。另外，政府可能会因为一些不正当的行为关闭你使用的*台，或者交易所可能会“意外丢失”你的硬币。而且不要以为你能在这里得到公正——一切都是匿名的，所以无处可去。

Photo by rawpixel on Unsplash

如果你认为那些事情真的不能被称为问题，这里是真正导致一个死胡同。如您所知，成为区块链的一部分意味着存储系统中每个节点发生的所有交易，这导致需要保存的信息量不断增加，在某些情况下，还需要重新处理和重新记录。因此，要成为系统的一部分，每个新节点都必须获得事务的完整副本，这可能需要相当长的时间，大大降低了速度。此外，对于新交易的发生，你可能不得不考虑优先处理一些交易，从而为滥用你的系统开辟新的途径，因为你鼓励只处理有价值的数据以获得更大的回报，而完全忽略另一个有用的数据。

结论

据预测，区块链将影响我们日常生活的几乎所有方面。随着比特币的价格在 2017 年达到创纪录的 19783.21 美元，可能没有比区块链及其加密货币更被炒作的投资机会了。私营公司和公众越来越意识到它的优势，而围绕这项技术的大多数担忧却被忽视或反驳。谁知道呢，也许我今天解释的问题对明天的区块链不再适用。

它为常见问题提供了许多可能的解决方案，加强了我们的金融安全，保护了我们的数字身份；然而，这项技术不是万灵药，它还没有很好地融入我们的生活，这就产生了一些问题。不友好的界面、复杂的加密特性和钱包安全性是该行业要成为核心经济建设者必须克服的三个主要陷阱。

考虑到这一点，商界看起来更像是区块链仙境中的爱丽丝——发生了很多事情，但不清楚具体发生了什么，以及会导致什么。但是，你知道吗，如果你愿意冒险，你绝对应该追随苹果、IBM 和美国银行等世界领先企业，因为区块链很有可能会以这样或那样的方式影响你的业务。唯一的问题是什么时候。

为赶时间的人准备的 Matplotlib 指南

原文：https://towardsdatascience.com/all-your-matplotlib-questions-answered-420dd95cb4ff?source=collection_archive---------0-----------------------

“person working on MacBook Pro” by rawpixel on Unsplash

Matplotlib 是最流行的二维图形库，但有时很难让你的图形看起来恰到好处。

如何更改图例上的标签名称？我如何设置刻度线？如何将刻度改为对数？如何向我的绘图添加注释和箭头？如何在绘图中添加网格线？

本文是关于如何自定义 Matplotlib 绘图的常见问题和答案的汇编。这是快速 Matplotlib 绘图的一个很好的备忘单，而不是 Matplotlib 库的介绍。如果您不熟悉这个库，请在这里查看文档。本文涵盖的主题包括地块和地块属性、轴、图例、注释和地块保存。从今天开始编写生产质量的图形！

开始提示

首先，确保导入 matplotlib。

import matplotlib.pyplot as plt

在 Jupyter Notebook 中，您可以在下面包含这一行，这样您就不必每次想要制作一个情节时都调用plt.show()。

%matplotlib inline

另一个方便的提示是，如果你不想让这个烦人的消息出现<matplotlib.collections.PathCollection at 0x1182bc710>，只需在你的代码行中添加一个分号，如下图所示。

之前:

之后:

剧情和支线剧情

问:我如何增加我身材的尺寸？

很多时候，默认大小太小。您可以添加参数 figsize，并以英寸为单位指定宽度和高度，如下所示。

plt.figure(figsize=(20,10))

问:什么是支线剧情？我如何创建和浏览支线剧情？

子图是存在于单个图形中的多组较小的轴。下面是一个 2 x 2 形式的四个支线剧情的例子。

这些支线剧情是用下面的代码创建的。我们调用plt.subplot并指定三个号码。它们指的是行数、列数和你想要激活的子情节数。

for i in range (1, 5):
   plt.subplot(2, 2, i)
   plt.text(0.5,0.5, str((2, 2, i)), ha=’center’, fontsize = 10)
   plt.tight_layout()

在上面的支线剧情中，剧情中的文字是对这三个数字的引用。子情节编号的排序是从左上角开始的，从数字 1 开始。例如，左上图是 1 号支线剧情，右上图是 2 号支线剧情，左下图是 3 号支线剧情，右下图是 4 号支线剧情。

请注意，您必须专门调用plt.subplot(2, 2, 1)来激活该支线剧情。

问:我的支线剧情安排看起来不太好。我如何修理它？

这是一个你的支线剧情被挤压的例子。我们可以通过调用plt.tight_layout()来修复它，它会清理支线剧情之间的填充，以获得更清晰的外观。

在之前

在之后

问:。如何在绘图中添加网格线？

plt.grid(True)

样式和属性

问:我如何改变我的线条颜色/宽度/样式？

您可以传入参数 color、linewidth 和 linestyle。

plt.plot(x, y, color = ‘green’ , linewidth = 2, linestyle = “-”)

以下是您可以设定的一些线型选项。

Photo from https://python-graph-gallery.com/121-line-chart-customization/

问:如何更改我的标记样式或颜色？

您可以像下面这样传入参数标记和颜色。

plt.scatter(x, y, marker = ‘o’, color = ‘red’)

这里有一些标记选项，您可以根据自己的喜好设定。

问:我如何改变线条的透明度？

将 alpha 参数传入您的绘图。Alpha 可以设置为 0 到 1，其中 0 表示完全透明，1 表示不透明。

plt.plot(x, y, alpha = 0.1)

下图显示了透明度在 alpha 级别为 0.9、0.5 和 0.1 时的样子

神话；传奇

问:我如何给我的剧情添加一个传说？

如果图例没有自动出现在您的绘图上，您可以使用以下代码来显示图例。

plt.legend()

问:我如何改变我的图例出现的位置？

您可以将以下选项传递给loc参数:右上、左上、左下、右下、右下、左中、右中、下中、上中、居中。

plt.legend(loc = ‘lower right’);

问:如何更改图例上的标签名称？

选项 1:

假设您有十个图例项，您只想更改第一个图例项的标签。将图例保存到变量 L 后，可以用“L.get_texts()[0]”调用图例的第一项，手动将文本设置成你想要的。在下面的例子中，我将图例设置为“123 行”。

L = plt.legend()
L.get_texts()[0].set_text('line123')

选项 2:

或者，您可以创建一个标签名称列表，并将图例标签设置为与您创建的列表相同。

mylabels = ['happy', 'sad', 'nervous', 'angry', 'neutral']
plt.legend(labels = my_labels)

问:我如何改变我的图例的大小？

要设置特定绘图的图例大小，可以传入 fontsize 参数。

plt.legend(fontsize = 10);

或者，不使用数字，您可以这样做。

plt.legend(fontsize = 'x-large');

轴线

问:如何命名我的 x 轴和 y 轴标签，如何更改字体大小？

根据您想要使用的轴，您可以调用“ylabel”或“xlabel ”,如下所示。第一项是轴的名称。要设置字体的大小，插入 fontsize 参数，如下所示。

plt.ylabel('Income', fontsize = 15) #for y label
plt.xlabel('Age', fontsize = 15) #for x label

问:如何设置刻度线？

第一个参数是要设置刻度线的位置，第二个参数是刻度线旁边的标签。

plt.yticks([0,2,4,6,7,10], [“0”, “2B”, "4B”, “8B”, “10B”])
plt.xticks([0,1,2,3,4,5], [“0”, “1oz”, "2oz”, “3oz”, “4oz”])

问:我如何设置坐标轴的范围？

plt.ylim(-1.0,1.0) #for y axis
plt.xlim(0, 50) #for x axis

问:如何将刻度改为对数？

plt.yscale(“log”) #for y axis
plt.xsclae("log") #for x axis

附注

问:如何给我的剧情添加注释和箭头？

我们可以创建注释并指定坐标来注释到xy参数。xytext定义标签的坐标。如果我们也想要箭头，我们需要使用arrowprops来显示箭头。

plt.annotate(‘sentosa’, xy = (5.0, 3.5), xytext(4.25, 4.0), arrowprops={'color': 'red'})

保存绘图

现在你已经有了自己喜欢的定制剧情，那就保存吧！我把我的地块叫做“地块 1”，但是给你的地块起一个更独特的名字！这将把绘图保存到您的工作目录中。

plt.savefig('plot1.jpg')

最后一点

如果你的 Jupyter 笔记本上有大量的二维图形，你的笔记本会变得很慢。这发生在我参与的一个项目中。如果您将鼠标悬停在图形的左侧，将会出现如下所示的灰色框。通过双击那个灰框，我可以隐藏我的情节，这样 Jupyter 笔记本就可以正常运行了。这也有助于滚动。

希望你喜欢这个 Matplotlib 概述。不可能涵盖大规模 Matplotlib 库中的所有内容，但是如果您认为本文中应该包含其他 Matplotlib 特性，请告诉我。

期待我的下一篇关于在 Matplotlib 中制作动画的文章！

冲积图

原文：https://towardsdatascience.com/alluvial-diagrams-783bbbbe0195?source=collection_archive---------6-----------------------

随着时间的推移绘制路径

我与人合著的一篇论文上周发表在 T4 的《儿童心理学和精神病学杂志》上。本文报告了一项关于学校支持干预对肯尼亚孤儿抑郁症影响的二次分析结果。在为公共存档准备数据的过程中，我认为尝试将我们关于萧条的纵向数据可视化为冲积图会很不错。

下图是 r 的[alluvial](https://github.com/mbojan/alluvial) 包的作者 Michał Bojanowski 创建的Titanic数据集冲积图的示例。该图从乘客是否幸存开始向后流动。例如，你可以从Survived=="No"追溯到泰坦尼克号的大部分船员都没有生还。

Alluvial diagram of the Titanic dataset created by Michal Bojanowski.

我将向您展示如何使用这个包来创建一个不同类型的冲积图，描述个人如何跨时间点流动。

数据

我的同事在肯尼亚设计了一项随机分组试验，招募了 26 所小学的 800 多名青少年参与学校支持(即免学费、校服和护士出诊)研究。作为基线调查的一部分，孩子们被问及一份名为 CESD-R 的问卷中的一部分问题，以评估抑郁症的严重程度。然后，一半的学校被随机分配接受学校支持干预，研究小组跟踪这些孩子超过四年。

在我们的二次分析中，我们创建了一个抑郁指标，它是五个 CESD-R 问题的*均值，这些问题被重新调整为 0 到 3 的范围。分数越高，表示严重性越高。

群体意味着随着时间的推移

这是我们论文中的图 1，显示了按研究组和年份划分的*均抑郁分数。这是试验数据的简明摘要，但它并没有给我们一种个体如何随时间变化的感觉。所有的信息都被压缩成了。

从一年级到四年级抑郁状态的变化

该线图显示，*均而言，各组在严重程度方面是相似的，直到第 4 年，当对照组的分数增加时，产生了与治疗组的分离。让我们来探索一下第 4 年发生了什么。

查看数据的一种方法是根据参与者的年度严重程度评分将他们标记为“可能抑郁”或“没有抑郁”，并将研究组在第 4 年的这种状态与他们在第 1 年开始时的状态进行比较。这就是我们在图 3 中所做的，将每个人标记为:

• 从未抑郁(低于第 1 年和第 4 年可能抑郁的分数线)
• 仍然低迷(高于第 1 年和第 4 年的临界值)
• 下降(低于第 1 年的临界值，但高于第 4 年)
• 缓解(高于第 1 年的临界值，但低于第 4 年的临界值)

个体变化

这个数字暗示了一个事实，即参与者对他们的第四年抑郁分数有不同的途径，但数据仍然是按组总结的。让我们试着去掉所有的汇总，显示每个青少年在每个时间点的分数。

下面是获取原始数据并将其整理成正确形状以便绘图的脚本:

现在我们可以把每个人的年度得分画成一条线:

Individual scores over time faceted by study arm. The blue line is participant #2, and the red line is participant #3. Everyone else is grey.

真是一团糟！数据科学可能既是艺术又是科学，但这个情节完全属于艺术阵营。

更细致的聚合

现在，我将使用alluvial包按照路径将参与者聚集在一起。代码如下:

为了使事情简单，这个情节没有在学习臂上刻面，但是这样的刻面是可能的。要把握的更大图景是冲积图如何追踪参与者在纵向数据集中采取的所有可能路径。

例如，得分从未超过抑郁临界值的青少年在底部形成一条灰色直线带，从第 4 年的“不抑郁”一直回到第 3、2 和 1 年的“不抑郁”。有一个*行的一直按下的组，由顶部的直线红带代表。中间的波浪是一次或多次改变状态的参与者。

下次您看到基于前/后数据的报告时，您可能会想知道在两次观察之间发生了什么。如果你真的收集纵向数据，试着用冲积图绘制这种变化。

Tweep & Vader 的(几乎)实时 Twitter 情绪分析

原文：https://towardsdatascience.com/almost-real-time-twitter-sentiment-analysis-with-tweep-vader-f88ed5b93b1c?source=collection_archive---------2-----------------------

这篇文章的想法是捕捉推文，根据最常用的词和标签对它们进行分析，并根据它们的情绪(积极、消极或中立)对它们进行分类。我们将不仅使用从历史数据库中捕获的推文作为数据集，例如， @realDonaldTrump: 发送的最后 200 条推文

还包括在某一特定时刻生成的所有实时推文，例如，在包含作品川普或墙的纽约州地区发送的推文

对于情感分析，我们将使用 VADER ( 效价感知词典和情感推理机)，这是一个基于词典和规则的情感分析工具，专门针对社交媒体中表达的情感。对于 Tweepy 捕获， API Tweepy 将是被选中的那个！

使用 Vader 进行情感分析

安装 Vader 的最简单方法是使用 pip 命令:

pip install vaderSentiment

接下来，让我们调用库并创建“分析器”:

from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzeranalyser = SentimentIntensityAnalyzer()

您只需在下面的函数中输入一个文本字符串即可获得分数:

analyser.polarity_scores("The movie is good")

结果将是一个字典:

{'compound': 0.4404, 'neg': 0.0, 'neu': 0.508, 'pos': 0.492}

上面的结果意味着这个句子几乎是半肯定的(' pos': 0.492)，或多或少是中性的(' neu': 0.508)，而绝不是否定的(' neg': 0.0)。事实上，最重要的结果是分数:“复合”，它可以表明文本是“好的”(大于零的值)。让我们来分析同一句话，但带有负面情绪:

analyser.polarity_scores("The movie is very bad")

结果是:

{'compound': -0.5849, 'neg': 0.487, 'neu': 0.513, 'pos': 0.0}

因此，我们得出结论，只寻找复合的结果，文本必须表现出消极情绪。

不仅如此，你还可以有不同程度的这种情绪:

“电影很烂”== >复合:-0.5849

“电影很烂”== >复合:-0.7398

“这部电影很糟糕！！!"== >复合:-0.7984

诸如此类…

简而言之，正面、负面和中性分数表示属于这些类别的文本的比例，并且复合分数是计算所有词典评级的总和的度量，这些评级已经在-1(最极端负面)和+1(最极端正面)之间标准化。

关于 Vader 的更详细的教程，请参见这篇中型文章:在 Python 中使用 VADER 简化情感分析

回到我们的分析，复合分数的范围是[-1，1]，即:

• [-1 到 0):负数，
• (0 到+1):正

因此，让我们编写一个函数来仅捕获通用文本的这 3 种状态:

def sentiment_analyzer_scores(text):
    score = analyser.polarity_scores(text)
    lb = score['compound']
    if lb >= 0.05:
        return 1
    elif (lb > -0.05) and (lb < 0.05):
        return 0
    else:
        return -1

测试…

1. 情操 _ 分析器 _ 分数(“电影很烂！”)== >结果:-1
2. 情操 _ 分析器 _ 分数(“电影很长！！!")== >结果:0
3. 感悟 _ 分析器 _ 分数(“电影很好看！”)== >结果:1

在其他语言中使用 Vader

Vader 确实是一个很好的工具，但不幸的是，它是建立在英语之上的(Vader 不能直接与其他语言一起工作)。

但如果你生活或工作在说其他语言的国家，你可以很容易地创建一个“转机”，并在应用 Vader 之前将你的文本从原始语言翻译成英语。

为此，我们将使用 Googletrans，一个实现了 Google Translate API 的免费且无限制的 python 库(详情请参考 API 文档)。

要安装 Googletrans，您可以使用 pip 命令:

pip install googletrans

和我们对维达做的一样，让我们导入库并调用翻译器:

from googletrans import Translator
translator = Translator()

让我们测试一个简单的西班牙语翻译:

translator.translate('hola, todo bien?').text

结果是:

'hello, all right?'

让我们尝试对一段西班牙文本进行“情感分析”:“la pelicula es mala”(“电影很糟糕”)

text = translator.translate('la pelicula es mala').text
analyser.polarity_scores(text)

结果是:

{'compound': -0.5423, 'neg': 0.538, 'neu': 0.462, 'pos': 0.0}

和我们一开始得到的结果完全一样！太好了！因此，我们可以将之前的函数更新到现在，还可以获得任何语言的任何文本的情感分析！

def sentiment_analyzer_scores(text, engl=True):
    if engl:
        trans = text
    else:
        trans = translator.translate(text).text score = analyser.polarity_scores(trans)
    lb = score['compound']
    if lb >= 0.05:
        return 1
    elif (lb > -0.05) and (lb < 0.05):
        return 0
    else:
        return -1

请注意，首先，我测试了语言是否是“英语”，如果是，不需要翻译，我们可以直接使用维达，即使没有互联网连接。当然，对于其他语言，互联网连接是强制性的，因为 Google Translate API 需要访问其在线服务。

您可以通知翻译您正在使用的语言，但在我们的情况下，我们将把这项工作留给做得很好的 Google(自动语言检测)。例如，让我们用葡萄牙语测试文本:“今天天气很好，阳光充足。”:

text = 'o dia esta lindo, com muito sol'
sentiment_analyzer_scores(text, False)

将结果为 1(“积极情绪”)。

太好了！在这一点上，我们可以分析几乎任何语言文本背后的情感！那么，为什么不从推文中提取“文本”呢？这将是我们的下一步行动！

准备 Tweepy 来捕捉推文

首先，让我们安装 Tweeppy:

pip install tweepy

需要指出的是，Twitter 要求所有请求都使用 Oauth 进行身份验证。本教程考虑到你实际上是一名 Twitter 开发者，拥有访问 tweets 的所有必要“钥匙”。

Tweepy 尽量让 OAuth 对你来说不那么痛苦。要开始这个过程，我们需要向 Twitter 注册我们的客户端应用程序。创建一个新的应用程序，一旦你完成，你应该有你的消费者令牌和秘密。把这两个放在手边，你会需要它们的。更多详情请前往认证教程。

安装 Tweepy 并准备好所有令牌后，让我们开始:

import tweep

获得授权:

consumer_key = 'YOUR KEY HERE'
consumer_secret = 'YOUR KEY HERE'
access_token = 'YOUR KEY HERE'
access_token_secret = 'YOUR KEY HERE'auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)api = tweepy.API(auth)

就是这样！您已经准备好捕捉推文了！

从 id 中读取和分析推文

首先，我将从我的大学获得几条推文:

tweets = api.user_timeline('[@ingenieriaUDD_](http://twitter.com/ingenieriaUDD_)', count=5, tweet_mode='extended')
for t in tweets:
    print(t.full_text)
    print()

结果是:

太好了！但是，仅仅打印推文并不能帮助我们走上“数据科学征服之路”！我们需要将它们放在一个数据集上(在这一点上，只是一个列表)以供将来分析。因此，一个简单的函数可以帮助我们:

def list_tweets(user_id, count, prt=False):
    tweets = api.user_timeline(
        "@" + user_id, count=count, tweet_mode='extended')
    tw = []
    for t in tweets:
        tw.append(t.full_text)
        if prt:
            print(t.full_text)
            print()
    return tw

分析一下唐纳德·特朗普发的推文怎么样？

user_id = ‘realDonaldTrump’ 
count=200tw_trump = list_tweets(user_id, count)

在 tw_trump 上，我们将有一个列表，其中每个列表项都是 trump 的一条推文。例如，让我们看看我们的列表中保存的 200 条推文中的一条，在这种情况下，第三条推文被捕获:

嗯，这是可以的，但我们可以看到，有一些推文的部分，事实上并没有帮助我们分析它的情绪，如网址，其他一些用户标识，数字等。我们应该做一些清洁工作:

def remove_pattern(input_txt, pattern):
    r = re.findall(pattern, input_txt)
    for i in r:
        input_txt = re.sub(i, '', input_txt)        
    return input_txtdef clean_tweets(lst):
    # remove twitter Return handles (RT [@xxx](http://twitter.com/xxx):)
    lst = np.vectorize(remove_pattern)(lst, "RT @[\w]*:")
    # remove twitter handles ([@xxx](http://twitter.com/xxx))
    lst = np.vectorize(remove_pattern)(lst, "@[\w]*")
    # remove URL links (httpxxx)
    lst = np.vectorize(remove_pattern)(lst, "https?://[A-Za-z0-9./]*")
    # remove special characters, numbers, punctuations (except for #)
    lst = np.core.defchararray.replace(lst, "[^a-zA-Z#]", " ")return lst

现在，我们干净的推特:

这条推特上的情绪怎么样？

是的，显然是积极的情绪(“1”)。

当然，我们可以比这好得多。让我们创建一个函数来捕捉和显示唐纳德·特朗普最后 200 条推文的情绪:

def anl_tweets(lst, title='Tweets Sentiment', engl=True ):
    sents = []
    for tw in lst:
        try:
            st = sentiment_analyzer_scores(tw, engl)
            sents.append(st)
        except:
            sents.append(0)
    ax = sns.distplot(
        sents,
        kde=False,
        bins=3)
    ax.set(xlabel='Negative                Neutral                 Positive',
           ylabel='#Tweets',
          title="Tweets of @"+title)
    return sents

这个函数的返回是一个列表，其中每个 tweet 的情感评分结果(-1、0 或 1)用作输入参数。

用词云分析推文

另一个有趣的快速分析是从一系列推文中产生的“词汇云”中获取一个峰值。为此，我们将使用 word_cloud ，这是 Python 中的一个小单词云生成器。在博客或网站上了解更多信息。

首先，安装 word_cloud:

pip install wordcloud

现在，让我们创建一个从 tweet 列表生成单词云的通用函数:

def word_cloud(wd_list):
    stopwords = set(STOPWORDS)
    all_words = ' '.join([text for text in wd_list])
    wordcloud = WordCloud(
        background_color='white',
        stopwords=stopwords,
        width=1600,
        height=800,
        random_state=21,
        colormap='jet',
        max_words=50,
        max_font_size=200).generate(all_words) plt.figure(figsize=(12, 10))
    plt.axis('off')
    plt.imshow(wordcloud, interpolation="bilinear");

现在我们已经定义了所有的函数，我们可以对任何一个 tweetser 生成的任何一组 tweet 进行重复分析。让我们对奥巴马最后的 200 条推文做同样的尝试:

特定过滤器的流推文

twitter 流 API 用于实时下载 Twitter 消息。这对于获取大量的 tweets，或者使用站点流或用户流创建实时提要非常有用。Tweepy 通过处理身份验证、连接、创建和销毁会话、读取传入消息和部分路由消息，使使用 twitter 流 API 变得更加容易。

创建 tweet 实时监听器最重要的参数:

轨道

以逗号分隔的短语列表，将用于确定哪些推文将在流上发布。一个短语可以是由空格分隔的一个或多个术语，如果该短语中的所有术语都出现在 Tweet 中，则该短语将匹配，而不管顺序和大小写。根据这个模型，你可以把逗号想象成逻辑 OR，而空格相当于逻辑 AND(例如‘the Twitter’是 AND twitter，而‘the，Twitter’是 OR twitter)。

语言

除非明确说明，否则此参数可用于所有流式传输端点。将此参数设置为逗号分隔的 BCP 47 语言标识符列表，对应于 Twitter 的高级搜索页面上列出的任何语言，将只返回被检测为以指定语言编写的推文。例如，使用 language = en， 连接将仅流传输被检测为英语的推文。

其他语言代码示例:
–es:西班牙语
–pt:葡萄牙语

跟随

逗号分隔的用户 id 列表，表示哪些用户的 Tweets 应该在流上发送。不支持跟踪受保护的用户。对于每个指定的用户，该流将包含:
–用户创建的推文。
–用户转发的推文。
–回复用户创建的任何推文。
–用户创建的任何推文的转发。
–手动回复，无需按下回复按钮即可创建(如“@twitterapi 我同意”)。

位置

一个逗号分隔的经度，纬度对列表，指定一组过滤推文的边界框。只有落在请求的边界框内的地理定位的推文才会被包括在内——与搜索 API 不同，用户的位置字段不用于过滤推文。每个边界框应该被指定为一对经度和纬度对，首先是边界框的西南角。例如:

-122.75，36.8，-121.75，37.8 == >旧金山
-74，40，-73，41。== >纽约市

将创建一个函数来轻松处理“监听”过程中可能出现的任何错误。其中一个参数是我们必须保持窗口打开的时间(秒)。该功能会自动将捕获的推文保存在一个. csv 类型的文件中，以供后期数据分析。

bellow 函数的灵感来源于原始代码，位于: https://stack overflow . com/questions/38281076/tweepy-streamlistener-to-CSV

def twitter_stream_listener(file_name,
                            filter_track,
                            follow=None,
                            locations=None,
                            languages=None,
                            time_limit=20):
    class CustomStreamListener(tweepy.StreamListener):
        def __init__(self, time_limit):
            self.start_time = time.time()
            self.limit = time_limit
            # self.saveFile = open('abcd.json', 'a')
            super(CustomStreamListener, self).__init__() def on_status(self, status):
            if (time.time() - self.start_time) < self.limit:
                print(".", end="")
                # Writing status data
                with open(file_name, 'a') as f:
                    writer = csv.writer(f)
                    writer.writerow([
                        status.author.screen_name, status.created_at,
                        status.text
                    ])
            else:
                print("\n\n[INFO] Closing file and ending streaming")
                return False def on_error(self, status_code):
            if status_code == 420:
                print('Encountered error code 420\. Disconnecting the stream')
                # returning False in on_data disconnects the stream
                return False
            else:
                print('Encountered error with status code: {}'.format(
                    status_code))
                return True  # Don't kill the stream def on_timeout(self):
            print('Timeout...')
            return True  # Don't kill the stream # Writing csv titles
    print(
        '\n[INFO] Open file: [{}] and starting {} seconds of streaming for {}\n'
        .format(file_name, time_limit, filter_track))
    with open(file_name, 'w') as f:
        writer = csv.writer(f)
        writer.writerow(['author', 'date', 'text']) streamingAPI = tweepy.streaming.Stream(
        auth, CustomStreamListener(time_limit=time_limit))
    streamingAPI.filter(
        track=filter_track,
        follow=follow,
        locations=locations,
        languages=languages,
    )
    f.close()

让我们测试一下这个功能，听听人们在这个确切的时刻发出的关于特朗普和他著名的墙的所有推文！

每条推文都是一个印在 Jupyter 笔记本上的“点”,这有助于查看“听众是否活跃并捕捉到了推文”。生成了一个文件(tweets_trump_wall.csv ),保存在笔记本所在的同一个目录下。

在这 60 秒的窗口时间内，许多推文被捕获。这是有意义的，因为我们不限制语言或地点。

用熊猫分析推特数据集

我可以说这里的工作差不多完成了。我们现在有了一个数据集。csv 格式，其中实时推文被捕获。现在，让我们使用我们的老熊猫来(几乎)实时读取文件，并继续数据集清理和探索阶段！

在 60 秒内，有 2576 条推文被捕获。数据集有 3 列，一列是作者，一列是日期，第三列是 tweet 文本。在本教程中，我们将只对最后一个感兴趣，但是对于更复杂的分析(如网络科学)，手头上有所有 3 个信息是很有趣的。

在一个网络科学项目中，将包含发件人回复的 id(RT @ XXX:)的推文的初始部分分离出来也是很有趣的。这里我们将清除它。

正如我们之前所做的，首先要做的是清理数据集，使用之前创建的相同函数:

现在我们将生成一个新的列，在那里我们将存储每条单独推文的情感分析。

让我们来看看它的单词云:

探索积极和消极的推文

在这一点上，我们可以过滤推文，将它们分为正面和负面，做任何我们认为有趣的分析。例如，每组推文的单词云是什么？

收集标签

我们将执行的最后一个分析将会查看在每种情况下生成的标签。为此，我们将在本教程中使用 Prateek Joshi 开发的函数:使用数据集和代码进行 Twitter 情感分析的综合实践指南。我建议访问他的网站。我从普拉蒂克那里学到了很多。

def hashtag_extract(x):
    hashtags = []
    # Loop over the words in the tweet
    for i in x:
        ht = re.findall(r"#(\w+)", i)
        hashtags.append(ht)
    return hashtags# extracting hashtags from positive tweetsHT_positive = hashtag_extract(df_tws['text'][df_tws['sent'] == 1])# extracting hashtags from negative tweets
HT_negative = hashtag_extract(df_tws['text'][df_tws['sent'] == -1])# unnesting list
HT_positive = sum(HT_positive,[])
HT_negative = sum(HT_negative,[])

结论

就这些了，伙计们！

希望您对数据科学的奇妙世界有了更多的了解！

在我们结束之前，我要感谢 Claudio Aracena 教授，他是我在智利 UDD 大学的数据科学硕士，是他启发了我写这篇文章。

和往常一样，你可以在我的数据仓库上找到 Jupyter 笔记本: Git_Hub 。

来自世界南部的 Saludos！

在我的下一篇文章中再见！

马塞洛

AlphaZero 实现和教程

原文：https://towardsdatascience.com/alphazero-implementation-and-tutorial-f4324d65fdfc?source=collection_archive---------6-----------------------

使用自定义 TensorFlow 操作和自定义 Python C 模块实现 AlphaZero 的演练

注意(2020 年 1 月 27 日):我已经发布了这个故事的更新，在那里我获得了性能更好的模型。你也可以看我对战改进后的网络。

我在这里描述了我在 Github 上实现的 AlphaZero 算法，它是用 Python 编写的，带有自定义 Tensorflow GPU 操作和一些用于树搜索的 C 语言辅助函数。

AlphaZero 算法经历了三次主要的迭代，先是叫做 AlphaGo ，然后改进到不使用任何预训练叫做 AlphaGo Zero ，最后进一步推广到其他游戏叫做 AlphaZero 。我的实现与 AlphaZero 最相似，然而，所有的变体都相对相似。我为游戏 Reversi 实现了类似的 GPU 功能，但目前我只有 Go GPU 代码可用(如果有人感兴趣，我可以提供前者)。

我写这篇文章的动机是使用相对最少的硬件(单个 GPU)在其他棋盘游戏上使用该算法，因此，我没有试图逐字实现该算法(例如，所有游戏都以预设的回合数进行，而不是使用自动程序在游戏结束时自动重新分配算法)。

我在公共领域发布这些代码、描述和所有其他材料。如果你觉得有用，我很乐意听听。如果你在理解我的代码时有任何问题，我也很乐意尽我所能，在时间允许的范围内提供帮助。我的电子邮件是 X@Y.com。其中 X 是 cody2007，Y 是 protonmail.com。

网络有多好？没那么好——我基本上一直都能打败它，而且我完全是个围棋新手。然而，这种实现似乎确实有效——在训练期间，它对 GNU Go 的分数确实稳步上升(对于使用简单评分系统的 20 回合游戏，网络在大约 50%的时间里开始击败 GNU Go,并且它至少可以在大约 100%的时间里击败完全随机的玩家。

不过有一点是，滥用我使用的评分系统需要走捷径。我通过计算每个玩家在棋盘上的所有石头加上每个玩家完全包围的所有空位来给游戏打分。出于这个原因，神经网络似乎喜欢(尤其是在游戏接*尾声时)将石头放在由另一个玩家安全控制的区域。这大大降低了其他玩家的分数(除了边界上的石头数量之外，其他玩家将不再获得该领土的任何分数)，即使该策略在游戏进行超过 20 轮后将不再有效。参见下面关于提高性能的部分。

目录

• 编译并运行代码
• 可视化算法训练
• 播放训练好的网络
• 算法概述
• 代码概述
• 模型架构
• 培训脚本的演练
• 训练速度
• 进一步提高性能

编译和运行代码

本节假设您已经安装了 Python 2.7、Tensorflow、Nvidia toolkit、GNU C 编译器(GCC)和标准开发环境，以及一些基本的 Python 包:numpy、scipy、colorama。安装和配置一个 Ipython (Jupyter)笔记本服务器来可视化培训进度也是有用的(在下面的中有更多的描述)。如果你想玩网络游戏，你可能还想安装 Pygame Python 包(在下面的中会有更多的描述)。

所有代码都已经在 Ubuntu 18.04 上使用 Python 2.7、Tensorflow v1.7.0 进行了测试和编写，并使用 NVCC v 9 . 0 . 176(Nvidia Cuda 编译器)进行了编译。我在一个 Nvidia Titan X 卡上运行和测试所有代码，该卡配有四核英特尔 i5–6600k CPU @ 3.50 GHz 和 16 Gb RAM。我还没有在其他配置上测试过它，但我怀疑它可能会在不同版本的 Cuda 工具包和 Tensorflow 上编译和运行。

编译代码

编译包括编译 Tensorflow 操作和 Python C 模块。我已经将编译命令写入脚本 build.sh 。因此，为了进行编译，您应该能够将目录更改为您下载代码的位置，并简单地运行它:

cd ~/alpha_go_zero_implementation ./build.sh

如果你有一个比我旧的 Nvidia GPU 卡(或者即使你有一个新的并且想要更好的性能)，你需要调整 build.sh 脚本中的-arch=sm_52标志来匹配你的卡的计算能力。你可以找到你的卡的计算能力，可能有几种方法，但是 Tensorflow 可以很容易地告诉你——在 Python 中你可以运行:

import tensorflow as tf
sess = tf.InteractiveSession()

这生成了相当多的文本，但是如果您看一下最后一行，应该是这样的:

Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 11435 MB memory) -> physical GPU (device: 0, name: GeForce GTX TITAN X, pci bus id: 0000:01:00.0, ***compute capability: 5.2***)

(请注意上面的计算容量陈述，因此“sm_52”是我的最佳选择)。

调整代码的内存需求(如果需要)

当前配置的代码需要大约 7.8 Gb 的 RAM(几乎所有这些都来自树搜索缓冲区)。然而，可以通过调整 py_util/includes.h 中的常量TREE_BUFFER_SZ和MV_BUFFER_SZ来缩减这种内存使用(代价是需要N_SIM，控制用于构建树的每回合模拟游戏的数量，在 bp_tree.py 中，由于树缓冲区的大小减小，也将减少)。

运行代码

有时，树搜索超过了缓冲区大小，这时代码应该检测到这一点并终止。出于这个原因，我创建了一个 shell 脚本，名为 run.sh 来循环运行主训练脚本BP _ tree . py——如果训练终止，它将重新启动它。因此，在命令行中，您可以将当前目录更改为下载代码的位置，并执行 run.sh 。例如:

cd ~/alpha_go_zero_implementation

由于脚本偶尔会终止，如果您开始训练一个新的模型，您需要小心。 bp_tree.py 通过加载脚本顶部变量**save_nm**中指定的模型文件来工作。如果**save_nm**设置为None，脚本将从零开始。所以，当开始训练一个新的模型时，一旦你开始运行脚本，你应该更新**save_nm**来指示新的模型文件名。如果不这样做，每次脚本(自动)重新启动时，它都将从头开始。理论上，这可以通过修改代码来从树缓冲区溢出中恢复，而不是简单地终止来解决，但是我还没有发现这种麻烦足以证明实现这种行为的时间是正确的。

虽然没有必要，但我经常在一个 GNU Screen 会话中运行所有这些，这样我就可以关闭我的控制台，让代码继续运行(使用screen -r重新连接)。

可视化算法训练

我已经包含了一个 Jupyter 笔记本，用于可视化网络训练进度，并绘制神经网络玩的示例游戏(参见文件notebooks/training _ visualizations . ipynb)。下面我展示了笔记本中的输出示例。

Black = neural network; white = opponent

Black = neural network; white = opponent

播放训练好的网络

脚本 play_network_gui.py 允许你使用 PyGame 通过一个简单的 gui 来玩网络。将脚本中的变量**save_nm**设置为模型文件的名称。你可以在两种模式下玩网络游戏:只运行网络(最快，没有树搜索)，或者用树搜索。将**run_net**设置为True可以让你在没有树形搜索的情况下玩游戏，设置为False可以启用树形搜索。

算法概述

对算法最好的描述直接来自原文( AlphaGo 、 AlphaGo Zero 、 Alpha Zero )不过，我再简单总结一下。这个想法是使用由神经网络引导的树搜索，该神经网络被训练来估计可能的好棋。树搜索是一种简单的蛮力方法，在每一步棋中，从当前位置到最后一局都要进行多次博弈，以确定某一步棋有多好。树搜索基于神经网络的输出选择移动，并且随着神经网络被训练，树搜索变得更加专注于探索成功的策略。神经网络是如何训练的？它被训练来估计来自树搜索的一组汇总统计(树搜索访问每个移动的频率，以及每个移动导致网络赢得游戏的可能性)。在训练过程中，网络与自己对抗，不需要人工训练。

代码概述

我已经将控制围棋规则和运动的所有代码放在 tensorflow GPU 操作中(在子目录 kernels/ 中)。我保存在 CPU 上的树结构(在子目录 py_util/ 中)。我以前也将树搜索实现为 tensflow GPU 操作，但出于两个原因，我决定将其转移到 CPU。首先，当运行超过 1000 次模拟的树搜索时，我开始遇到 GPU 内存限制。第二，我发现在 CPU 上保留树搜索代码可以提高大约 2 倍的速度(尽管我没有在优化 GPU 树搜索实现上投入太多时间)。

GPU 游戏数据结构

所有 GPU 数据结构都在 row-major-order 中，并在 cuda_includes.h 中定义。

板子以尺寸[BATCH_SZ, MAP_SZ_X, MAP_SZ_Y]储存。

• **board**代表当前正在评估的游戏板。
• **board2**代表在进行树搜索评估时使用的游戏备份(备份和恢复棋盘的代码在kernels/session _ backup . Cu . cc中)
• **board_prev**和**board_pprev**代表当前前一圈和两圈的棋盘，以防止重复移动(同样**board_prev2**和**board_pprev2**是类似于**board2**的备份)
• **n_captures**和**n_captures2**(形状[N_PLAYERS, BATCH_SZ])表示每个玩家在当前游戏中捕获的次数。这仅用于统计，算法实际上并不需要。
• **ai_to_coord**(形状[BATCH_SZ])是随机播放器选择的坐标，也是算法不需要的(它是内核/move_random_ai.cu 的输出，并输入到内核/move_unit.cu )
• **valid_mv_map_internal**(形状[BATCH_SZ, MAP_SZ])这是每个棋盘的二进制图，表示哪些位置是有效移动(1)，哪些不是(0)。它是内核/create_batch.cu 的输出，由内核/move_unit.cu 使用，以确保只进行有效的移动。

CPU 树数据结构

所有 CPU 树数据结构(在py _ util/_ py _ util . cPython 模块中使用)也在 row-major-order 中。它们在 py_util/includes.h 中定义，并预先分配为固定大小，以避免需要不断分配和释放内存。必须注意不要超过缓冲区的大小(否则代码会终止)。

节点数据结构:
每个节点代表一个棋盘状态，并包含一个指针，指向一个列表:有效的棋步、它们的访问计数、*均 Q 值和由神经网络分配的获胜概率。这些值(访问计数和*均 Q 值)在网络每次移动时都会更新——所有导致当前状态的游戏状态都通过 py_util/backup_visit.c 函数进行更新。

• **tree_sz**(形状[BATCH_SZ])表示节点数(有子节点)。它不应该超过TREE_BUFFER_SZ，否则我们就有一个内存溢出。
• **tree_start** (shape [BATCH_SZ])是代表当前板卡状态的节点的索引(应该总是> = 0 且小于 tree_sz)。
• **tree_player**(形状[BATCH_SZ, TREE_BUFFER_SZ])代表每个节点下一个移动的玩家。
• **tree_parent**(形状[BATCH_SZ, TREE_BUFFER_SZ])表示每个节点的父节点索引。值-1 表示我们在树的根部。
• **tree_list_sz**(形状[BATCH_SZ, TREE_BUFFER_SZ])表示对于每个节点(游戏状态)，可用的子节点(可能的移动)的数量。对于所有已初始化的节点，该值将始终至少为 1(表示无移动)，并且永远不会超过1 + MAP_SZ(有效移动不可能超过电路板尺寸)。
• **tree_list_start**(形状[BATCH_SZ, TREE_BUFFER_SZ])表示，对于每个节点，我们可以在其中找到孩子和他们的统计数据(访问计数，Q 值的总和)的索引。这不应该超过MV_BUFFER_SZ，否则我们会有一个内存溢出。

列表数据结构:
如上所述，每个游戏状态(我称之为节点)都与一个有效移动、访问计数、*均 Q 值和概率的列表相关联。这些结构每个都存储在一个大的缓冲区中，节点数据结构包含一个指针(tree_list_start)在这个缓冲区中指向一组连续的条目(tree_list_sz表示条目的数量)。

• **list_sz** (shape BATCH_SZ)包含列表中活动元素的数量。随着列表的增长，元素被添加到末尾，每个游戏的**list_sz**条目也相应地增加。对于任何给定的游戏，它都不应该超过MV_BUFFER_SZ，因为这是下面描述的列表缓冲区的大小。
• **list_valid_mv_inds** (shape [BATCH_SZ, MV_BUFFER_SZ])对于每场游戏，它包含下一个移动的玩家的有效移动指数。
• **list_valid_tree_inds** (shape [BATCH_SZ, MV_BUFFER_SZ])对于每个游戏，它包含有效的节点索引(这是一个指向上述结构的指针——变量以**tree_**开始)。有了节点索引，就可以从**tree_list_start**索引中查找下一组叶子。**list_valid_tree_inds**如果未初始化，将为-1。当网络移动到一个未初始化的节点时，它将被 py_util/register_mv.c 函数初始化。
• **list_q_total**(形状[BATCH_SZ, MV_BUFFER_SZ])对于每一个游戏，它代表了游戏中这里和向前访问的所有状态的 Q 值的总和。除以访问次数得到*均值。
• **list_prob**(形状[BATCH_SZ, MV_BUFFER_SZ]对于每一场比赛，都包含了网络对比赛获胜概率的预估。该值只需设置一次(与访问计数和*均 Q 值不同)，并在 py_util/choose_moves.c 中设置。
• **list_visit_count**(形状[BATCH_SZ, MV_BUFFER_SZ])对于每一局游戏，它包含这步棋及其后的每一步棋的次数。

模型架构

我的所有测试都集中在一个 5 层残差的卷积神经网络上，每层有 128 个滤波器(尽管这些参数可以通过改变 bp_tree.py 很容易地改变)。这是一个比 AlphaGo 论文中报告的网络更小的网络，并且受到我自己的硬件和时间限制的影响。

培训脚本的演练

这里有一个训练脚本的演练， bp_tree.py 。通常，它设置并加载通用变量和状态信息。然后进入主循环，首先通过自玩生成训练批次，然后除了随机反射和旋转棋盘之外，还会以随机洗牌的顺序对其进行训练。在循环结束时，它将保存并评估网络，然后重复循环。

脚本的第一部分只是导入模块，并设置加载和保存神经网络模型的目录。值得一提的两个文件是 global_vars.py 文件，它包含例如批量大小，以及architectures/tree _ TF _ op . py文件，它使用将在本脚本稍后定义的参数在 Tensorflow 中构建神经网络。

接下来，我们设置是否希望脚本开始训练一个新的网络，或者加载并恢复训练一个现有的网络(通过设置**save_nm**变量)。此外，我们还创建了一个希望保存在模型文件中的变量列表，以及将用于记录性能的变量。

现在我们要么初始化一个新模型，要么加载它。这是您更改模型或训练参数的地方，例如层数、过滤器、损失函数权重或梯度下降步长。同样，如果你想减小梯度下降步长，你可以在if语句的else分支中设置EPS变量。

接下来是保存和恢复当前树位置的函数(为简洁起见，此处省略)，以及一个用于生成输入 Tensorflow 的字典的简单函数。之后，是执行树搜索的主函数。首先备份当前树状态:

然后，我们进入主要的模拟和轮流循环，每个玩家都要走一步。然后，我们向前运行神经网络，以获得它对每一步都会导致它赢得游戏的概率的估计(脚本中的**pol** 变量)。我们还得到它对当前游戏状态的 Q 值估计(脚本中的**val**变量)，以及当前玩家可以进行的有效移动的列表(由内核/create_batch.cu 函数生成)。如果我们不在模拟的第一步，那么脚本会将 Q 值备份到导致当前状态的所有游戏状态。

有了有效移动的列表，我们就可以通过调用来自上面编译的 Python C 模块的pu.add_valid_mvs函数来更新树。接下来，查询树以基于网络概率和 Q 值估计找到下一步。然后，我们在树中注册移动，然后进行移动(这将更新包含板状态的 GPU 内存结构，以下面的行开始:arch.sess.run最终调用内核/move_unit.cu 函数)。

最后，在每次模拟结束时，我们必须备份谁赢得了每场比赛(网络正在玩自己，但这是必要的，以了解哪一套动作赢得了训练)。我们还恢复了之前在树中的位置。

接下来是一些额外的初始化代码(这里没有显示)。之后，是主要的训练循环。首先我们调用kernels/init _ state . Cutensor flow 操作，它在 GPU 上初始化一组新的游戏板。我们还通过调用 py_util/init_tree.c 来初始化树数据结构。接下来，对于每个回合，我们运行模拟代码来播放N_SIM(例如。1000)游戏。然后，我们为每个玩家保存棋盘状态(稍后用作训练输入)，并获得有效走法的列表。

和以前一样，使用run_sim函数，我们在树中注册有效的移动，然后使用树来选择当前玩家的下一步移动。然而，这一次不是选择具有最大树搜索值(反映了访问计数、Q 值和网络概率估计)的移动，而是在概率上与树搜索访问每个移动的次数成比例地移动。然后，像以前一样，我们在树中注册移动。最后，我们修剪树( py_util/prune_tree.c )，这意味着我们移除所有不再可访问的节点和叶子(那些表示从当前移动中不再可能的分支)。

现在，为了构建我们的训练批次，我们确定谁赢得了每场比赛(我们训练网络来预测它——Q 值，或脚本中的**val**变量),并确定树搜索将为给定的比赛状态选择每一步的概率(我们也训练网络来预测它——脚本中的**pol**变量)。py _ util/return _ probs _ map . c函数从我们之前的模拟中返回每个回合、玩家、游戏和移动的概率。它的尺寸是:[N_TURNS, N_PLAYERS, BATCH_SZ, MAP_SZ_X, MAP_SZ_Y]。

最后，我们准备训练网络。我们打乱了训练步骤的顺序，然后旋转和反射棋盘，这给了网络更多种类的输入进行训练，并防止它过度适应任何一个游戏。

然后，我们执行实际的反向传播步骤。对于诊断，我们加载损失函数值来监控训练进度。这些值随后在临时变量中递增，并在脚本中打印、保存和重置。

脚本的其余部分(这里没有显示)将保存模型，并根据随机对手和 GNU Go 算法对其进行评估。该代码中还包含打印语句，用于查看一些损失函数输出。

训练速度

在我的设置中(硬件描述见页面顶部)，生成 128 个游戏玩 20 回合，每回合 1000 次模拟，大约需要 40 分钟。我的代码随机旋转并反映棋盘，并在所有回合的每次移动中进行训练(因此在 40 分钟内，它生成 20 个训练批次)。我在这一页上展示的图代表了大约一个月的训练[ (25000 训练步* (40 分钟/ 20 训练步))/(60 分钟/小时* 24 小时/天)] = 34 天。

进一步提高性能

我注意到当游戏模拟的数量从 500 增加到 1000 时，性能有所提高(见下文；蓝色= 1000 次模拟；红色= 500 次模拟)。请注意，相对于 GNU Go 算法，胜率略有增加。我怀疑模拟的额外增加也可能提高性能，但我没有测试这一点。奇怪的是， AlphaZero 的论文只使用了 800 次模拟，然而，还有其他可能让他们获得更好性能的差异，如超参数调整(我没有系统地完成)，以及增加网络规模。在我对游戏 Reversi 进行的一些旧测试中，我注意到随着模拟数量的增加，性能有了更显著的提高，而随着网络规模(层数和过滤器数量)的增加，性能几乎没有提高。然而，这些结果可能不适用于围棋，因为状态空间和每回合的移动次数都在急剧增加。如果其他人对此有想法，我会很高兴听到(我的电子邮件在页面顶部)。

比较 1000 次与 500 次模拟

blue = 1000 simulations; red = 500 simulations
(Darker colors are games played against GNU Go, lighter colors are against an opponent making random moves)

另外一个我认为会提高性能的变化与评分系统有关(基于我在 Computer Go 邮件列表中的讨论)。正如文章开头提到的，网络可以通过在其他玩家“安全”控制的区域放置石头来增加分数。解决这个问题需要:实现一个辞职机制(目前，所有的游戏都是每个玩家转 20 次)，并增加每个玩家可以转的次数，以便可以在安全控制的区域内捕获流散的石头。因为我用的是小棋盘(7x7 ),如果回合数增加，放弃机制可能会很关键，因为否则玩家可能会用完所有的棋步，被迫开始填充自己的领地，使他们容易被俘获。

我计划实施辞职机制，并在某个时候增加回合数，并将尝试在此链接到我的结果。

替代“事实”与替代“推论”

原文：https://towardsdatascience.com/alternative-facts-vs-alternative-inferences-718e1d4aa790?source=collection_archive---------6-----------------------

假设你在三次抛硬币中看到了以下序列:

HHH

以下哪个陈述是“事实”？

1. 硬币是固定的，总是“正面”落地。
2. 硬币是公*的。

简而言之，这两种说法都不构成“事实”。它们都是推论，取决于两件事:观察者对宇宙的先验知识和实际的无可争议的事实——你已经连续得到了三个头。我们可能或可能不相信硬币实际上是公*的，或多或少，你只是有一系列的机会发生，这不是不可能的(1/8)。因为我们不认为，先验地，一个硬币总是“正面”落地是非常可能的，如果有可能的话，我们(我认为是正确的)认为这是非常可能的。但是，在实际的“事实”中，没有什么是无可争议的，这使得“边缘”认为硬币是固定的不太可能。如果有什么不同的话，它实际上加强了这种信念。

出于各种原因，我们可能认为这枚硬币接*公*，如果不是公*的话。我们可能会认为，即使真的有可能，魔法硬币的存在也不太可能。我们以前可能见过很多次扔硬币，即使不一定是来自这枚硬币，并且相信(并非不可能)这是一枚硬币，就像任何其他硬币一样(即使我们没有明确或知情的理由相信这种或那种方式)。或者，我们可能很懒，认为 50-50 的几率是合理的。实际上，这些都没有说有问题的特定硬币不是固定的。相信这枚硬币是固定不变的“阴谋论者”没有理由相信他的信念是错误的，因为事实是无可争议的。唯一能说服他的“事实”是，在某次投掷中，硬币出现了“尾巴”。换句话说，要证明阴谋论者不是这样，你需要投资一个实际的实验，在这个实验中，你愿意支付一笔费用来证明，在一些 N 次投掷中，其中 N>3，至少有一个“尾巴”。(或者，如果阴谋论者有一个更微妙的信念，即真正的 P(H) = .9 或其他什么，这个结果足以刺激他的 P 值。)

底线是“另类推论”很容易，显然很常见，相当自然，事实上经常有无可争议的真实事实支撑。我们经常认为其他人是错误的，因为他们从我们的同一组事实中得出不同的推论，但这仅仅意味着他们是带着不同的先验得出的观察结果，通过这些先验来评估事实。

渐*地，如果我们接触到来自相同分布的相同数据流，也就是说，当观察值接*无穷大时，所有的信念都会收敛。但是，我们真的还会从同一个分布中汲取能量吗？数据的供应，尤其是面对总体上太多的数据，一直在转变以满足我们的过滤器。我指的不仅仅是关于政治的新闻:我们不成比例地从我们容易获得并且出于某种原因感兴趣的数据中提取信息——在我处理营销相关数据的少数场合，我觉得有趣的是，我所拥有的样本的人口统计数据严重倾向于更年轻、更富有和更懂技术的人。如果你想知道是什么让这群大概具有经济价值的人群的 p 值发痒，我想这没问题。但是如果你想知道你的产品在这个群体之外的销售情况，这将是一个糟糕的例子。因此，我们对大量数据的子集进行采样，以进一步探索，因为它们符合我们的先验(和成本考虑)，因此继续循环。而且，说实话，数据消费者主动花更多的钱去获取他们不知道该怎么做的数据是愚蠢的，因为有大量廉价的数据可供他们使用。(在政治心理学中，我们称这种酒鬼的寻找，我其实远比不同情故事中的酒鬼。)但底线是，鉴于抽样过程中的偏差，信念的趋同将非常缓慢或不存在。这才是真正的问题。(这还是在我们提出样本量接*无穷大之前。)观察不同的观察者有不同的数据样本，并且他们拥有的样本在不同程度上与不同的信念兼容，这没有什么“可替代性”，从而导致不同的推论。明智的数据分析用户应该认识到，这是采样过程和观察者带来的不同先验中(几乎是固有的)偏差的自然副产品。然而，即使在认识到可变性的同时，承认“事实”及其限度也不应该是一个太大的问题:HHH 已经发生是无可争议的，并且由 P(H) = 1/2 和 P(H) = 1 的先验产生的概率是可以计算的。不同观察者之间的争议在于概率 P(P(H) = 1)，而目前可用的“事实”对解决这个问题贡献甚少——只有收集额外的事实才能解决。如果得不到事实，我认为，除了承认存在差异并就哪些额外数据(如果能够找到的话)将使解决办法朝一个方向或另一个方向发展达成一致之外，没有什么意义。(这就是实验(也称为 A/B 测试)的用武之地:有时，你可能拥有的绝大多数大数据与实际争议无关，实际相关的子集可能太小，无法产生足够的统计功效。唯一的解决办法是人为地收集这个未被充分代表的子集的更多数据。)

我不认为“替代事实”真的存在:首先，很少有无可争议的事实独立于解释而存在。我们想到的大多数“事实”实际上是推论，通常非常可靠和稳健，但仍然是从有限的事实中推断出来的推论。我们没有人真正到过月球，除了少数参与阿波罗计划的人——如果它真的发生了(哈！开玩笑的。)我们“知道”登月发生了，因为有许多间接的线索表明它是真实的，而且让我们感到荒谬的是，这样的事情可能是伪造的。但这些存在于“推论”的领域，而不是事实，它们反映了我们是什么和谁，而不是我们“知道什么”。真正困扰我们的是，有些人，也许甚至许多人，并没有得出同样的推论。

我并不是说这个问题无关紧要。远非如此，问题是“替代性推论”而非“替代性事实”表明了一个更深层的问题。如果这仅仅是一个“事实”的问题，很容易证明相反的事实是无可争议的，这将是它的结束。在上面的例子中，硬币是固定的这一信念将被一个单一的结果打破，在这个结果中硬币落在“尾巴”上。如果硬币是公*的，它将很快发生。然而，另一种推论建立在更加“复杂”的基础上，既有“理论的”，也有“经验的”，从这个意义上说，它们包含了关于宇宙如何运作和产生数据的完整理论，以及足够支持这些“理论的”基础的数据。换句话说，一套完整的“替代心智模型”是存在的。如果人类的社会性是建立在对我们周围世界的共同信念之上的，即使没有明确地陈述事情，我们也知道什么构成了道德的、适当的和“正常的”行为和互动方式，并相应地遵循，这种共同思维的缺乏表明他们没有不同推论的持有者所共享的共同“人类社区”。换句话说，“替代性推论”与其说表明它们“知道”不同的东西，不如说表明它们是不同的。

仅仅告诉“他们”他们的“事实”是错误的是荒谬的——这相当于告诉他们 HHH 的意思是 P(H)= 0 . 5 左右。是的，HHH 和 P(H) = .5 远非不相容——P(HHH | P(H)= . 5)实际上相当高。但是 HHH 更适合 P(H) = 1。如果我们试图说服某个相信 P(H) = 1 的人，我们应该多扔几次硬币。是的，我们三次投掷就赢了 HHH。如果我们有 N= 10，你会期待什么？请注意，我们不一定要把我们的信念强加于他人——我们实际上可能被证明是错误的，我们可能会得到 10 个 H，无论这可能多么不可思议，如果是这样，阴谋论者可能有一个观点，但如果是这样，它将基于一个更坚实的经验主义基础，无论如何。但是，最有可能的是，这不会发生，而且除了掷十次硬币之外，没有其他替代的事实。当然，这意味着我们实际上必须付费来运行实验以收集我们需要的数据，而不是试图从我们拥有的有限数据中挤出推论(即使是大数据在有偏差的采样面前也是有限的，所有数据在某种程度上都是有偏差的——唯一的问题是，它们的偏差是否如此之大，以至于我们应该对它们持怀疑态度。)

用网络科学进行客户分析

原文：https://towardsdatascience.com/amazon-customer-analysis-57eabb66e2ed?source=collection_archive---------10-----------------------

用于客户细分的用户评论网络

在过去的一二十年里，美国人继续偏爱可追踪的支付方式，这为零售商和供应商提供了丰富的客户数据来源。数据科学家使用这些数据来帮助企业在库存、营销和供应链等方面做出更明智的决策。有几种工具和技术可以进行客户细分，网络分析可能是一种强有力的工具。

在之前的文章中，我们看到了复杂网络分析在社交媒体僵尸检测中的效用。在这里，我们将看到网络科学的工具是如何应用于客户分析的，仅以 Amazon.com 产品评论的两个元数据为例。我们将首先提供关于数据集的信息，以及网络是如何创建的。然后，我们将深入到以自我为中心和全局指标的网络分析中。然后我们将解释这些信息告诉我们什么，最后从商业角度推测它可能意味着什么。

关于数据集

这项工作中使用的数据集是由加州大学圣地亚哥分校的 Julian McAuley 博士提供的。它“包含来自亚马逊的产品评论和元数据，包括 1996 年 5 月至 2014 年 7 月的 1.428 亿条评论”。产品评论数据集包含用户 ID、产品 ID、评级、有用性投票和每个评论的评论文本。

这项工作中建立的网络来自健康和个人护理评论 5 核数据集，这意味着它只包含至少有 5 个评论的用户和产品。在 2014 年 1 月至 7 月期间，进一步对数据集进行了抽样审查。总而言之，这个采样数据集包含超过 25，000 个要分析的用户帐户，每个帐户至少有 5 条评论。

关于网络结构

Figure 1. A sample from the constructed network showing two connected cliques. All nodes represent accounts that have reviewed some product. Thus, all nodes that reviewed a given product form a clique, and any given node that reviewed multiple products will connect multiple cliques.

数据集中的每个用户帐户由网络表示中的一个节点来表示。如果节点的帐户共享已审核的产品，则节点由边连接。*在该图中，网络由针对每种产品的集团的集合组成。产品集团将由作为两个集团成员的节点连接(审查多个产品)。图 1 示出了网络中的一个集团的例子。

自我中心网络分析

分析从计算网络中每个节点的几个关键自我中心度量**开始(自我中心的意思是以该节点为中心):度-目标节点共享一条边的节点数量，中心性-网络中节点的相对重要性(在这项工作中，使用了特征向量 Katz 和中间中心性)，以及聚类系数-目标节点邻域中可能存在的[三元组](http://Figure 1. A sample from the constructed network showing two connected cliques. All nodes represent accounts that have reviewed some product, and as a result, are all connected.)的比例。

每个节点的这些计算指标在下面的图 2 中相互对照。

Figure 2. A pairwise plot of clustering coefficient, degree, eigenvector centrality and Katz centrality of each node in the review network. The plots in the diagonal are the probability density functions of the metric.

值得注意的是，在大多数样地中，存在由低密度区域分隔的两个不同的集群。在运行聚类算法将节点分成两类:绿色(24，201 个节点)和蓝色(821 个节点)之后，Katz 中心性与聚类系数的关系图如图 3 所示。

Figure 3. Two clusters identified with the DBSCAN clustering algorithm.

在节点被识别并标记为“绿色”或“蓝色”后，指标将被重新绘制，如图 4 所示。Katz 中心性与聚类图中的节点类被分成在其他成对图中看到的相同的不同聚类。这证实了导致聚集现象的机制对于每个度量对都是一致的。也就是说，一个图中的一个集群中的节点的类成员关系依赖于它在其他图中的成员关系。

Figure 4. Pairwise plots with cluster membership. Clockwise from top-left: Katz vs eigenvector centrality, log(degree) vs log(betweenness centrality), clustering coefficient vs degree, Katz centrality vs degree.

一个特别值得注意的观察是 Katz 与特征向量中心性图中的聚类。Katz 中心性的计算方式与特征向量中心性几乎相同，区别在于节点最初被赋予“自由”中心性。该图表明，与具有可比特征向量中心性的绿色节点相比，该自由初始中心性更多地提高了蓝色节点的 Katz 中心性。

有两个网络属性可以解释这一点。首先,“蓝色”节点的度数往往比“绿色”节点的度数高得多(如图 4 中包含度数的图所示)。第二是“蓝色”节点的*均聚类系数是 0.74，而“绿色”节点的*均聚类系数是 0.59。一般来说，度数大的节点往往比度数小的节点具有更小的聚类系数，因为完成相同比例的三元组需要更多的连通性(这与度数的阶乘有关)。“蓝色”节点具有更高的度和更高的*均聚类系数，这一事实表明它们比“绿色”节点位于网络中更密集的区域。因此,“蓝色”节点的 Katz 中心性计算的自由初始中心性增加是复合的。

网络协调性

识别出两个不同的节点类别后，确定网络的分类性是有意义的。也就是说，蓝色节点往往不与绿色节点连接(同配混合，如图 5 所示)，还是它们很好地混合在一起(异配混合)？

Figure 5. An assortively mixed network. Credit: M. J. Newman

这可以用模块化值来回答:连接相同类型节点的边的分数减去随机期望的分数。正模块度值表示分类混合；负值表示异配混合。虽然在理论上，该值被限制在 1 以上，但是大多数网络结构不会随机产生 0 个预期的同质边。考虑到这一点，通常通过假设连接相同类型节点的边的分数为 1 来计算网络结构所允许的最大模块化值。

评论网络的模块化值被发现是 0.302，0.419 是最大可能的模块化值。因此，网络具有很强的分类混合性；也就是说，“蓝色”和“绿色”节点的连接程度明显低于偶然情况下的预期。在产品评论的背景下，这意味着“蓝色”和“绿色”用户在很大程度上是在评论(并且，可能是购买)不同的产品组。

结论

对这一评论网络的分析得出的结论是，有两个客户群对不同的产品群很感兴趣。其中一个客户群比另一个要小得多，但联系更加紧密，这表明它代表了更多的小众利益。历史销售信息将允许确定这个利基群体对收入的贡献。如果它贡献了与其规模不相称的数量，零售商可以通过扩大或定制其服务和产品来增加收入。

---

*多边是指边的权重

• 边权重被*考虑在度和中心性的计算中

阿姆斯特丹的环境救星:循环经济

原文：https://towardsdatascience.com/amsterdams-environmental-saviour-the-circular-economy-c83200222e61?source=collection_archive---------4-----------------------

对于这座高科技城市来说，节能减排是不够的

原材料是一种有限的资源。随着依赖这些资源的行业数量的增加(如智能手机和*板电脑的金属)，消费者的数量也在增加。在未来的几十年里，我们不仅将开始耗尽这些材料，而且其提取和制造过程往往对工人、公民和环境有害。

从长远来看，依赖原材料在经济上是不可行的。随着库存的减少，资源市场变得越来越不稳定。世界上每个国家都交易自己的原材料，所以如果这些环节中的一个环节无法再交付，整个供应链都会受到影响。到 2050 年，荷兰政府希望荷兰完全依靠可再利用的原材料。所以阿姆斯特丹市正在试验一个解决方案:循环经济。

什么是循环经济？

目前的系统是线性的。我们获取资源，制造产品，然后在完成后处理掉它们。循环经济旨在封闭循环，以尽可能保留更多价值的方式对废物进行再利用、再利用或回收。这包括减少制造过程中的热力学熵，并尽可能避免向下循环。如果你用一件旧棉布衬衫作为例子:

重复使用圆圈

• 维修和维护以延长产品的寿命
• 重用和再分发(转售/共享)
• 翻新、翻新和再制造
• 回收部分或全部材料

制造商必须提前考虑，创造易于拆卸和重复使用的产品——所以在这种情况下，考虑纯棉而不是混纺。另一个想法是公司租赁产品而不是出售。所以租赁洗衣机给你的公司会负责维护和修理。然后，当机器达到其寿命的尽头时，他们将收集它并重新使用这些材料，而不是必须挖掘新的材料。随着数据科学、存储能力和机器学习的进步，这些物流系统正开始成为现实。

荷兰银行 ABN·AMRO 刚刚在其总部阿姆斯特丹开设了荷兰的第一座圆形建筑。几乎所有使用的材料都是可回收的，当建筑最终被拆除时，它可以很容易地拆卸，所有材料都可以重复使用。Circl 大楼拥有循环解决方案，如由员工的旧粗斜纹棉布牛仔裤制成的隔热材料、拆除办公楼的窗框和屋顶上的 500 块太阳能电池板。

有什么好处？

环境的

• 通过重复使用物品，从产品转向服务(非物质化)，生产的产品会更少。从而减少制造业的排放和污染物
• 任何产生的排放都将被重新利用。二氧化碳可以用来在温室中种植农产品，培养藻类来制造燃料，甚至可以被矿化。冰岛的一个研究小组发现，将二氧化碳溶解在水中，并与包括玄武岩在内的混合物一起注入地球，95%的二氧化碳将在两年内矿化为方解石
• 废品被重新利用。有机/生物废物可用于牲畜饲料、沼气甚至生物塑料
• 仅在荷兰，循环方法就可以减少 8%的二氧化碳排放，减少 2180 千米的土地使用，减少 7 亿立方米的水消耗，减少 25%的原材料进口

商业

• 可持续性优先于利润，因此公司的寿命得以延长
• 循环经济确保优化能源消耗，减少浪费。这两者都有助于提高生产效率，从而节省资金
• 回收材料意味着公司不必购买新的资源，从而避免市场价格波动和库存减少
• 通过采取更环保的方法改善与政府和消费者的关系

经济的

• 将经济从有限的线性系统中分离出来
• 与提取原材料相比，资源节约高达 70%
• 循环系统创新和数据科学中的新经济
• 一个新的劳动密集型的回收和维修就业市场
• 减少生态足迹
• 在荷兰，循环经济可以为政府带来 73 亿€，并创造 54，000 个新的工作岗位

(数据来自艾伦·麦克阿瑟基金会和循环合作)

阿姆斯特丹的合作经济

在我们的智慧城市文章中，我们谈到了城市的协作性质。阿姆斯特丹分享城市的一项研究证实了这一点，84%的居民表现出分享的动机。从产品中获取最大价值是创造循环经济的第一步。由于出色的 ICT 结构，该市 90%的地方都可以上网，因此阿姆斯特丹的初创公司一直在与市政当局合作，创建居民可以相互分享的应用程序和*台。

重新穿上

一个在线社区*台，由我们 Eli5 的创始人设计。用户可以将他们的设计师衣柜出租给其他时尚人士，这样衣服就能得到最大限度的利用。此外，用户可以通过租金来减轻对银行账户的打击。

皮尔比

超过 20%的二氧化碳排放来自耐用消费品。*均而言，这些资产的使用寿命只有 10%。Peerby 是一款为分享这些物品而制作的应用。用户可以拯救环境，节省购买物品的时间，节省购买昂贵物品的费用，并结识许多友好的人。该*台几乎涵盖了你能想到的任何物品。从汽车、自行车和旅行用汽车；到聚会的凉亭、烤肉架和折叠椅。

闭环——将废物转化为材料

显然，共享经济首先没有产品来共享是行不通的。生产这些产品仍然会导致二氧化碳排放、有毒污染和其他形式的废物。阿姆斯特丹经济委员会的目标是通过将废物流与企业联系起来，来结束这一循环。

区域热网

许多制造过程会产生热量，这些热量通常作为废物通过水或空气处理掉。阿姆斯特丹经济委员会已经召集了 32 个政府机构、能源公司和热能生产商来将热能输送到家庭。

在阿姆斯特丹的 Houthaven 区，一所新的学校和住宅楼将使用该网络供暖，并使用 IJ 河的水进行冷却。与使用传统锅炉和空调系统的公寓相比，社区中的每个家庭排放的二氧化碳将减少 80%。

Sanquin 血库已经与 Waternet(阿姆斯特丹自来水公司)建立了联系，在冬季也可以使用饮用水的冷能。这将最初储存为热能，用于 Sanquins 制药过程。他们期望在最初几年提取 20，000 千兆焦耳的能量。人们还期望家庭能够节省金钱和能源，因为这一过程提高了饮用水的温度，用户在家中加热水所需的能源将会减少。

智能电网

智能电网是阿姆斯特丹最初的智能城市计划之一，其重点是储存和回收剩余能源。与欧盟的城市禅项目合作，太阳能电池板被安装在整个城市，以收集全天的能量。然而，一旦他们的电池达到最大容量，就没有更多的电可以储存，宝贵的日光就浪费了。增加产能需要在基础设施上进行昂贵的投资。

在该市组织的黑客马拉松 Appsterdam 上，获胜的解决方案是使用电动汽车电池作为存储。这就产生了一个临时的“虚拟发电厂”,同时政府建造了一个更大的储存库。智能电网还将允许太阳能电池板所有者使用智能电表*台将多余的能量卖回给供应商。所以每个太阳能电池板都被充分利用，总有地方可以储存产生的能量。

信用:阿姆斯特丹智能城市

PUMA —城市采矿

PUMA 是来自莱顿大学、代尔夫特理工大学、Waag 协会和代谢的研究人员的合作项目。该研究项目旨在发展城市矿山的理念，并绘制阿姆斯特丹地质图，以显示某些金属(如铜)的存在。PUMA 团队希望创建一个城市建筑及其材料构成的数据库，因此未来有可能开采这些资源。

鸣谢:Waag 社会生活实验室

别克斯洛特汉姆

作为 2016 年欧洲创新之都奖的获得者，阿姆斯特丹经常被描述为“活实验室”。北面的 Buiksloterham 是以用户为中心的开放式创新生态系统的最佳范例。

Buiksloterham 以前是许多制造企业的所在地，包括一家飞机制造厂、石油实验室和造船厂，在 2008 年经济危机之前一直被指定为私人开发项目。由于无力自行出资建设，该市向希望自建环保住宅的可持续企业和居民开放了该地区。中央车站对面的滨水区现在布满了初创企业、循环企业和新住宅。

德塞韦尔

De Ceuvel 建在一个旧造船厂的旧址上，几乎完全是圆形的。这片土地已经被严重污染，所以选择了在 10 年租期结束时能够自然解毒的植物。

与此同时，办公室工作区建在高架*台上，使用不再使用的升级船屋。还有一个咖啡馆和餐厅，由重新利用的木材和回收船及其他零碎材料制成的户外座椅建成(当夏天到来时)。还有:

• 堆肥厕所，因为受污染的土地阻止挖掘污水系统
• 热交换器，收集 60%离开办公室船只的热量，并进行再循环
• 水生植物过滤器，用于处理废水
• 每年产生 36，000 千瓦时电力的太阳能电池板
• 鸟粪石反应器，从有机废物中制造肥料
• 和一个生产鱼和蔬菜的水培温室

信用: deceuvel.nl

阿姆斯特丹的下一站是哪里？

欧盟、荷兰政府和阿姆斯特丹市政当局都实施了鼓励循环经济创新的计划和激励措施。例如，van Plestik 是一家位于 Buiksloterham 社区的公司。他们创造了一种 3D 打印机，可以使用混合和不纯的塑料将废物升级为家具和其他产品。当你考虑到传统的 3D 打印机必须使用塑料，必须提炼回*乎纯粹的“原始”形式时，这是一个重要的里程碑。在帮助下，这家初创公司在短短几个月内的旅程是这样的:

• 创作者从 2016 年初开始，通过与 3D 打印和城市建设专家 Hogeschool van Amsterdam 和 CRE8 合作，研究用回收塑料打印
• 到那年 5 月，该项目入围了由欧盟主要的气候创新倡议组织举办的气候启动*台竞赛。该计划为他们提供了一个为期 4 天的研讨会流程，专家可以帮助他们加快业务发展
• 2016 年 9 月，他们被选为驻阿姆斯特丹创业计划的成员，并获得了为期 5 个月的每周培训，以发展他们的公司

van Plestik 现在已经建造了他们的第一台工作打印机，并在 2017 年 6 月赢得了“阿姆斯特丹，让你的城市”奖，以进一步发展他们的循环回收项目。

信用: vanplestik.nl

Amsterdam Economic Board 的下一阶段是建立一个循环数据*台，将所有的研究、业务和已经创建的系统结合在一起，类似于智能城市的城市数据*台。其主要目的是存储阿姆斯特丹的资源和垃圾流数据，以确保该城市能够最有效地利用每一种资源。该*台还将成为企业和公民收集和分享数据、讨论可持续发展战略以及为那些希望减少环境影响和实施循环战略的人提供建议的地方。

这方面的一个例子是阿姆斯特丹的一家名为因斯图克的餐厅，这家餐厅使用了原本会被浪费掉的食物。它依赖于 Albert Heijn 超市的废物流，但希望通过该*台找到其他供应商。

循环数据*台的最终目标是为每一种材料提供通行证，这样原材料的供应就不会流失到垃圾填埋场和其他低价值的废物处理方法中。与此同时，阿姆斯特丹市政府将继续举办循环创造挑战等活动，以鼓励持续创新，实现完整的循环经济。

一个不正常的人在寻找一个有趣的数字

原文：https://towardsdatascience.com/an-abnormal-man-looking-for-an-interesting-number-8b013d273af9?source=collection_archive---------4-----------------------

拍了下面这张图，从写着“正常”的建筑里，照片里的不正常的家伙——我——想起了一个“有趣”的悖论。

假设我按顺序列出自然数:

• 1
• 2
• 3
• 4
• …

现在让我们说说这些数字中的一些有趣的东西:

• 1 是所有数中的第一个数，它是所有其他数的约数
• 2 是第一个也是唯一的质数
• 3 是第一个古怪的表亲
• 4 是第一个完美的正方形
• …

假设具有有趣性质的数称为“有趣”数。
而不有趣的数字才是“正常”的数字。

使用此定义，列表将如下所示:

• 1 是一个有趣的数字
• 2 是一个有趣的数字
• 3 是一个有趣的数字
• 4 是一个有趣的数字
• …

现在假设数字 x 是列表中的第一个“正常”数字。

• 1 是一个有趣的数字
• 2 是一个有趣的数字
• 3 是一个有趣的数字
• 4 是一个有趣的数字
• …
• x 是一个正常的数字
• …

但是如果 x 是第一个“正常”数，那么它就是一个“有趣”的数，因为它有一个有趣的性质:成为第一个“正常”数。

另一方面，如果我们认为 x 是一个“有趣”的数，因为它具有作为第一个“正常”数的性质，那么它就不再是一个“正常”数，现在它是一个“有趣”数，这样就失去了作为第一个“正常”数的性质，然后不再是“有趣”的了…

真是一团糟！不“有趣”？

告诉你一个有趣的事情，这个问题就是数学家朱尔斯·理查德在 1905 年描述的“理查德数的悖论”。

这个链接(https://en.wikipedia.org/wiki/Richard's_paradox)讲述了更多关于理查德悖论的细节，但方式没有这里有趣。

另一个类似的悖论是“骗子悖论”。一个只会说谎的人会说“我在说谎。”但由于他只是在撒谎，所以他在这份声明中说的是实话。但如果他说的是真话，他就不是只说假话的人。

这些悖论不仅“干扰”了普通人类的思维，也干扰了历史上最伟大的数学家的思维。

奥地利数学家库尔特·哥德尔在 1931 年用他的不完全性定理摧毁了所有数学的基础，他证明了数学不可能同时是完全的和一致的。也就是数学有极限。哥德尔在数学基础中发现了一个“错误”——它不能同时摆脱这些怪异的悖论，并回答其所有命题的真或假。哥德尔用一个复杂版本的理查德悖论证明了这一点。

这是一个很长的故事，涉及到像戴维·希尔伯特和伯特兰罗素这样的思想巨人，这是另一天。

顺便说一句，我认为《建筑之光》的作者用“有趣”的方式写“正常”只是为了让建筑不再“正常”，从而迷惑我们的头脑…

其他著述:https://medium.com/@arnaldogunzi

主要博客:【https://ideiasesquecidas.com/

不等式约束优化的 ADMM-牛顿法

原文：https://towardsdatascience.com/an-admm-newton-method-for-inequality-constrained-optimization-37a470c58a5c?source=collection_archive---------9-----------------------

代码 : Github

数值优化在包括机器学习在内的许多领域都是必不可少的。在某些情况下，约束被转换为未知变量，这使得应用普通的无约束优化技术变得不那么简单，需要更复杂的方法(例如 L-BFGS-B)。

看起来，如果成本函数的梯度和 hessian 是已知的(对于像逻辑回归这样的许多问题来说都是如此)，那么对于不等式约束来说，问题就相对容易了。这把钥匙叫做 ADMM 。

问题

这种 ADMM(交替方向乘子法)方法解决了下面的约束优化问题:

算法

使用罚函数和变量替换将不等式约束替换为等式约束；

在哪里，

然后，等式约束问题可以转化为它的增广拉格朗日(原始-对偶)问题:

并用 ADMM [1]求解:

Pseudocode for ADMM

原始子问题中的牛顿更新

对于原始下降 1，可以使用牛顿更新获得解决方案，这依赖于原始损失函数的梯度和 hessian 的可用性:

和下面的反演:

这种反演可以通过直接反演或迭代法(如 CG【2】)进行。

ADMM-牛顿法现在完成了。

示例:逻辑回归

考虑具有标签(l)、特征(f)和对权重(x)的正性约束的逻辑回归，则我们有:

使用 sigmoid 函数:

模拟数据的结果

生成 200 个样本，每个样本具有 10 维特征向量:

feature, label = make_classification(n_samples=200, n_features=10, n_redundant=0, n_informative=5, random_state=0)

和 ADMM 参数被设置为:

• \rho = 1
• max_iter = 1000
• tol = 1E-6

有/无约束条件下回归权重的比较:

约束是有效的，因为输出权重都是正的。请注意，这不再是全局最小值(由于约束)，而是次优性能(AUC)。

关于方法的注释

这种方法要求损失函数 E(x)的梯度和 hessian 要么显式(作为矩阵)可用，要么隐式(使用函数)可用。

参考

1. 史蒂芬·博伊德、尼尔·帕里克、朱立伦、博尔哈·佩莱托和乔纳森·埃克斯坦(2011)，“通过交替方向乘数法进行分布式优化和统计学习”，《机器学习的基础和趋势:第 3 卷第 1 号，第 1–122 页。
2. Jorge Nocedal，S. Wright，“数值优化”，施普林格科学，1999 年。

张量流估计类的一个高级例子

原文：https://towardsdatascience.com/an-advanced-example-of-tensorflow-estimators-part-1-3-c9ffba3bff03?source=collection_archive---------1-----------------------

通过代码和对一些隐藏特性的深入研究。

tensor flow API 1.3 版中引入了估计器，用于抽象和简化训练、评估和预测。如果你以前没有使用过估算器，我建议从阅读这篇文章开始，熟悉一下，因为我不会涵盖使用估算器的所有基础知识。相反，我希望去神秘化和澄清一些更详细的方面，使用估值器和从现有的代码库切换到估值器。

为什么要使用估值器？

任何长期使用 Tensorflow 的人都会知道，像现在这样设置和使用 Tensorflow 需要花费大量时间。现在有许多简化开发的库，比如 slim、tflearn 等等。这通常会将定义网络所需的代码从多个文件和类减少到单个函数。他们还简化了培训和评估的管理，并在很小程度上扩展了数据准备和加载。Tensorflow 的估计类不会改变网络定义的任何内容，但它简化和抽象了管理训练、评估和预测。由于它的低级优化、有用的抽象和来自核心 Tensorflow 开发团队的支持，它从其他库中脱颖而出。

Visualization of the different API levels

这是一个很长的故事，简而言之，估算器运行和实现起来更快，更简单(一旦你习惯了)，并且得到很好的支持。

文章结构

本文将使用我的一个 GitHub 项目 SqueezeNext-Tensorflow 中的例子来分析估计器的一些特性。该项目中实现的网络来自于 2018 年发布的一篇名为“ SqueezeNext ”的论文。由于采用了一种新颖的可分离卷积方法，这种网络非常轻便和快速。研究人员发布了一个 caffe 版本，但为了便于使用可用的 Tensorflow 库进行实验，我在 Tensorflow 中重新创建了论文中的算法。

文章使用以下结构设置:

• 设置评估器
• 使用估算器和数据集加载数据
• 定义预测、训练和评估模式
• 会话挂钩和脚手架
• 预言；预测；预告

设置评估器

为了为某个培训和评估花名册设置评估者，最好先了解评估者设置如何工作。要构造 Estimator 类的实例，可以使用以下调用:

classifier = tf.estimator.Estimator(model_dir=model_dir,
                                    model_fn=model_fn,
                                    params=params)

在这个调用中,“model_dir”是估计器应该存储和加载检查点和事件文件的文件夹的路径。“model_fn”参数是一个按以下顺序使用特征、标签、模式和参数的函数:

def model_fn(features, labels, mode, params):

当估计器执行用于训练、评估或预测的模型函数时，它将总是提供那些参数。要素参数包含一个张量字典，其中包含要输入到网络的要素，标注参数包含一个张量字典，其中包含要用于训练的标注。这两个参数由输入 fn 产生，这将在后面解释。第三个参数 mode 描述“model_fn”是否被调用用于训练、评估或预测。最后一个参数 params 是一个简单的字典，它可以包含 python 变量，并且可以在网络定义过程中使用(考虑学习速率计划的总步骤等)。).

培训和评估示例

既然 Estimator 对象已经初始化，就可以用它来开始训练和评估网络。下面是 train.py 的摘录，它实现了上面的指令来创建一个估计器对象，然后开始训练和评估。

From: https://github.com/Timen/squeezenext-tensorflow/blob/master/train.py

这段代码首先为 params 设置配置字典，并使用它和“model_fn”一起构造一个估计器对象。然后它创建一个“ TrainSpec ”，带有“输入 _fn”和模型应该训练的“最大 _ 步数”。做类似的事情来创建“ EvalSpec ”，其中“步骤”是每次评估的步骤数，“throttle_secs”定义每次评估之间的间隔(以秒为单位)。“TF . estimator . train _ and _ evaluate”用于使用 Estimator 对象“ TrainSpec ”和“ EvalSpec ”启动训练和评估花名册。最后，在训练结束后，再次显式调用评估。

使用估算器和数据集加载数据

在我看来，关于估算器最好的事情是，你可以很容易地将它们与数据集类结合起来。在评估器和数据集类结合之前，很难从 GPU 异步地在 CPU 上预取和处理示例。理论上，CPU 上的预取和处理将确保在 GPU 完成处理前一批样本的任何时候，内存中都会有一批准备好的样本，实际上这说起来容易做起来难。仅将获取和处理步骤分配给 CPU 的问题是，除非它与 GPU 上的模型处理并行完成，否则 GPU 仍然必须等待 CPU 从存储磁盘获取数据并进行处理，然后才能开始处理下一批数据。很长一段时间以来，queuerunners、使用 python 线程的异步预取和其他解决方案都被提出，以我的经验来看，没有一个能够完美而高效地工作。

但是使用 Estimator 类并将其与 Dataset 类结合起来非常简单、干净，并且可以与 GPU 并行工作。它允许 CPU 获取、预处理和终止一批示例，以便总是有新的一批为 GPU 准备好。使用这种方法，我看到在训练期间 GPU 的利用率接* 100%，对于小模型(<10MB) increase 4 fold.

Dataset Class

The Tensorflow Dataset class is designed as an E.T.L )每秒的全局步数。process，代表提取、转换和加载。这些步骤将很快被定义，但是本指南将只解释如何将 tfrecords 与 Dataset 类结合使用。对于其他格式(csv、numpy 等。)这个页面有很好的报道，但是我建议使用 tfrecords，因为它们提供更好的性能，并且更容易与 Tensorflow 开发管道集成。

From: http://blog.appliedinformaticsinc.com/etl-extract-transform-and-load-process-concept/

整个 E.T.L .过程可以使用 Dataset 类实现，只需 7 行代码，如下所示。一开始看起来可能很复杂，但请继续阅读，了解每一行功能的详细解释。

From: https://github.com/Timen/squeezenext-tensorflow/blob/master/dataloader.py

摘录

数据集输入管道的第一步是将 tfrecords 中的数据加载到内存中。这从使用 glob 模式(例如“)生成可用的 tfrecords 列表开始。/数据集/训练-*。tfrecords”和 Dataset 类的 list_files 函数。parallel_interleave 函数应用于文件列表，确保并行提取数据，如这里的所述。最后，使用合并的混洗和重复函数从 tfrecords 中预取一定数量的样本并混洗它们。一旦读取了每个 tfrecord 的最后一个示例，repeat 通过从头开始重复来确保总是有可用的示例。

files = tf.data.Dataset.list_files(glob_pattern, shuffle=True)dataset = files.apply(tf.contrib.data.parallel_interleave(
                          lambda filename:
                          tf.data.TFRecordDataset(filename),
                          cycle_length=threads*2)
                      )dataset = dataset.apply(tf.contrib.data.shuffle_and_repeat
                         (32*self.batch_size))

变身

现在，数据在存储器中可用，下一步是将其转换，最好转换成不需要任何进一步处理的东西，以便馈送到神经网络输入。要做到这一点，需要调用数据集的 map 函数，如下所示，其中“map_func”是应用于 CPU 上每个单独示例的函数，“num_parallel_calls”是要使用的“map_func”的并行调用次数。

threads = multiprocessing.cpu_count()dataset = dataset.map(map_func=lambda example:
                           _parse_function(example, self.image_size,
                                self.num_classes,training=training),
                            num_parallel_calls=threads)

在这种情况下,“map_func”是如下所示的解析函数，该函数处理来自 tfrecords(使用此 repo 创建)的示例，并输出包含分别代表特征和标签的张量的字典元组。注意使用 lambda 函数将 python 变量从示例中单独传递给 parse 函数，因为示例是来自 tfrecord 的未解析数据，由 Dataset 类提供。

From: https://github.com/Timen/squeezenext-tensorflow/blob/master/dataloader.py

请记住，这个解析函数一次只处理一个示例，如 tf.parse_single_example 调用所示，但是会并行处理多次。为了防止遇到任何 CPU 瓶颈，保持解析函数快速运行是很重要的，关于如何做到这一点的一些提示可以在这里找到。然后，所有单独处理的样本被分批并准备处理。

dataset = dataset.batch(batch_size=self.batch_size)

加载

ETL 过程的最后一步是将批量示例加载到加速器(GPU)上，准备进行处理。在数据集类中，这是通过预取来实现的，预取是通过调用数据集的预取函数来完成的。

dataset = dataset.prefetch(buffer_size=self.batch_size)

预取将生产者(CPU 上的数据集对象)与消费者(GPU)分开，这允许它们并行运行以提高吞吐量。

输入功能

一旦完整定义并实现了整个 E.T.L .过程，就可以通过初始化迭代器并使用下面的代码行获取下一个示例来创建“input_fn ”:

input_fn = dataset.make_one_shot_iterator().get_next()

该输入函数被估计器用作模型函数的输入。

定义预测、训练和评估模式

快速提醒一下，评估者在训练、评估和预测期间调用的模型函数应该接受前面解释的以下参数:

def model_fn(features, labels, mode, params):

在这种情况下，要素和标注由数据集类提供，参数主要用于网络初始化期间使用的超参数，但模式(类型为“tf.estimator.ModeKeys”)决定了模型将要执行的操作。每种模式都用于为特定目的建立模型，可用的模式有预测、训练和评估。

From: https://k-d-w.org/blog/103/denoising-autoencoder-as-tensorflow-estimator

可以通过调用估算器对象的相应函数(如上所示)来使用不同的模式，即:“预测”、“训练”和“评估”。每个模式的代码路径必须返回一个带有该模式所需字段的“估计规格”,例如，当模式为预测模式时，它必须返回一个包括预测字段的“估计规格”:

return tf.estimator.EstimatorSpec(mode, predictions=predictions)

预测

最基本的模式是预测模式"TF . estimator . mode keys . predict"，顾名思义就是使用 Estimator 对象对数据进行预测。在这种模式下,“EstimatorSpec”需要一个将要执行的张量字典，其结果将作为 numpy 值提供给 python。

From: https://github.com/Timen/squeezenext-tensorflow/blob/master/squeezenext_model.py

在这段摘录中，您可以看到预测字典设置用于生成经典图像分类结果。if 语句确保该代码路径仅在执行 Estimator 对象的 predict 函数时执行。张量字典作为预测参数与模式一起传递给“EstimatorSpec”。首先定义预测代码路径是明智的，因为它是最简单的，并且因为大部分代码也用于训练和评估，所以它可以在早期显示问题。

列车

为了在"TF . estimator . mode keys . train"模式中训练模型，有必要创建一个所谓的" train_op ",该 op 是一个张量，当执行时执行反向传播以更新模型。简单地说，它是优化器的最小化功能，比如 AdamOptimizer 。“train_op”和标量损失张量是创建用于训练的“EstimatorSpec”所需的最小参数。下面你可以看到一个这样做的例子。

From: https://github.com/Timen/squeezenext-tensorflow/blob/master/squeezenext_model.py

请注意非必需的参数“training_hooks”和“scaffold ”,这些将在后面进一步解释，但简而言之，它们用于向模型和培训会话的设置和拆除添加功能。

评估

模型函数中需要代码路径的最后一个模式是“TF . estimator . mode keys . eval”。为了执行评估，最重要的是度量字典，它应该被构造为元组字典，其中元组的第一个元素是包含实际度量值的张量，第二个元素是更新度量值的张量。更新操作对于确保整个验证集的可靠度量计算是必要的。因为通常不可能在一个批次中评估整个验证集，所以必须使用多个批次。为了防止由于每批差异而在度量值中产生噪声，使用更新操作来保持所有批的运行*均值(或收集所有结果)。此设置可确保在整个验证集中计算指标值，而不是在单个批次中计算。

From: https://github.com/Timen/squeezenext-tensorflow/blob/master/squeezenext_model.py

在上面的示例中，只有“loss”和“eval_metric_ops”是必需的参数，第三个参数“evaluation_hooks”用于执行“tf.summary”操作，因为在运行评估者评估函数时不会自动执行这些操作。在本例中,“evaluation_hooks”用于存储来自验证集的图像，以便使用 Tensorboard 显示。为了实现这一点，使用“tf.summary.image”操作来初始化具有与“model_dir”相同的输出目录的“SummarySaverHook ”,并将其传递(封装在 iterable 中)给“EstimatorSpec”。

切换到估计类

既然我解释了使用 Estimator 类的优点以及如何使用它，我希望您对开始在 Tensorflow 项目中使用 Estimator 感到兴奋。然而，从现有的代码库切换到估计器并不一定简单。由于 Estimator 类在训练期间抽象掉了大部分的初始化和执行，任何定制的初始化和执行循环都不再是使用“ tf 的实现。Session 和“ sess.run() ”。这可能是拥有大量代码的人不过渡到估算者类的原因，因为没有简单直接的过渡途径。虽然本文不是一个过渡指南，但我将阐明一些初始化和执行的新过程。这将有望填补官方教程留下的一些空白。

脚手架和会话脱钩

影响初始化和执行循环的主要工具是“Scaffold”对象和“SessionRunHook”对象。“脚手架”用于模型的自定义首次初始化，并且只能用于在训练模式下构建“估计规格”。另一方面,“SessionRunHook”可用于为每种执行模式构建“EstimatorSpec ”,并在每次调用 train、evaluate 或 predict 时使用。“Scaffold”和“SessionRunHook”都提供了 Estimator 类在使用过程中调用的某些函数。下面你可以看到一条时间线，显示在初始化和训练过程中调用哪个函数以及何时调用。这也说明了引擎盖下的估计器还是用“ tf。会话和会话。

Function execution timeline executed by the Estimator of the Scaffold and SessionRunHook classes.

脚手架

在构造用于训练的“EstimatorSpec”时，可以将一个脚手架作为脚手架参数传递。在 scaffold 中，您可以指定在初始化的不同阶段要调用的许多不同操作。然而，现在我们将把重点放在“ init_fn ”参数上，因为其他参数更多地是针对分布式设置的，本系列将不会涉及。在图形完成之后，但在第一次调用“ sess.run ”之前，调用“ init_fn ”，它只使用一次，因此非常适合自定义变量初始化。一个很好的例子是，如果您想要使用预训练网络进行微调，并且想要选择性地恢复哪些变量。

From: https://github.com/Timen/squeezenext-tensorflow/blob/master/tools/fine_tune.py

上面你可以看到一个实现的例子，该函数检查微调检查点的存在，并使用 slim 创建一个初始化函数，该函数过滤" scope_name "变量。然后，该函数被封装在估计器期望的函数格式中，该格式消耗“支架”对象本身和一个“ tf”。会话对象。在“ init_fn ”内，会话用于运行“ initializer_fn ”。

# setup fine tune scaffold
scaffold = tf.train.Scaffold(init_op=None,
     init_fn=tools.fine_tune.init_weights(params["fine_tune_ckpt"]))# create estimator training spec
return tf.estimator.EstimatorSpec(tf.estimator.ModeKeys.TRAIN,
                                loss=loss,
                                train_op=train_op,scaffold=scaffold)

这个" init_fn "然后可以作为一个参数传递，以构建一个" Scaffold "对象，如上所示。这个“脚手架”对象用于构建列车模式的“估计规格”。虽然这是一个相对简单的示例(也可以通过“WarmStartSettings”实现)，但它可以轻松扩展为更高级的一次性初始化功能。

会话脱钩

如前面的时间线所示，“session unhook”类可用于改变训练、评估或预测循环的某些部分。这是通过使用一个叫做挂钩的概念来完成的，我不会详细说明挂钩到底是什么，因为在这种情况下，它是不言自明的。但是使用“SessionRunHook”与使用脚手架略有不同。它不是用一个或多个函数作为参数来初始化“SessionRunHook”对象，而是被用作一个超类。然后，可以重写方法“ begin ”、“ after_create_session ”、“ before_run ”、“ after_run ”和“ end ”，以扩展功能。以下摘录显示了如何覆盖“ begin ”功能。

From: https://github.com/Timen/squeezenext-tensorflow/blob/master/tools/stats.py

请记住" begin "函数不获取任何参数，但每个挂钩略有不同，请参考这里的来检查哪些参数被传递给了哪个函数。现在，用户可以通过调用扩展的 begin 方法创建一个“SessionRunHook ”:

stats_hook = tools.stats.ModelStats("squeezenext",
                                    params["model_dir"],
                                    self.batch_size)

然后，在构建用于训练、评估和预测的“EstimatorSpec”时，可以通过将该对象传递给相应的参数“training_hooks”、“evaluation_hooks”和“prediction_hooks”来使用该对象。请注意，每个参数都以钩子结尾，它们需要一个包含一个或多个钩子的 iterable，所以请始终将钩子封装在 iterable 中。

预言；预测；预告

培训和评估已被广泛涵盖，但预测尚未得到充分解释。这主要是因为预测是 3 种(训练、评估、预测)估计模式中最容易的，但是仍然会遇到一些陷阱。我在前面解释了如何为预测设置一个“EstimatorSpec ”,但没有解释如何使用它。下面是一个小例子，展示了如何使用估计量进行预测。

From: https://github.com/Timen/squeezenext-tensorflow/blob/master/predict.py

对于预测来说，生成/使用 tfrecords 没有意义，因此使用了“ numpy_input_fn ”。向" x "参数传递一个包含特征的 numpy 数组字典，在本例中是一个图像。

注意:根据您是否在训练期间预处理" input_fn "中的图像，您可能需要在这里执行相同的预处理，或者在传递到" numpy_input_fn "之前在 numpy 中执行，或者在 Tensorflow 中执行。

使用 numpy 输入函数设置，一个简单的预测调用就足以创建一个预测。上例中的"预测"变量实际上并不包含结果，相反，它是 generator 类的一个对象，要得到实际的结果，你需要迭代它。这个迭代将启动 Tensorflow 执行并产生实际结果。

结束语

我希望我能够揭开张量流估值器的一些未被记录的特性的神秘面纱，并填补官方教程留下的空白。这篇文章中的所有代码都来自这个 github repo ，所以请前往那里查看与 Datasets 类结合使用的估计器的示例。如果你还有任何问题，请留下来，我会尽力回答你。

奥运标志评分分析

原文：https://towardsdatascience.com/an-analysis-of-olympics-logo-ratings-22238ef3acce?source=collection_archive---------0-----------------------

今天早上，我在 Quartz 上读到了一篇关于奥运标志的有趣文章。米尔顿·格拉泽(Milton Glaser)是许多其他项目中“我❤纽约”标志背后的获奖*面设计师，他对 1924 年以来的每届夏季和冬季奥运会标志进行了评级。我觉得看看他的收视率有没有什么有趣的规律会很有趣。

首先，我们将使用“rvest”包提取包含所有分数的文本。然后我们将过滤掉无关的文本，这样我们只剩下分数。

# clear the way
rm(list=ls())# load libraries
library(dplyr)
library(ggplot2)
library(plotly)
library(rvest)# extract score for each Olympics
olympics_logo_scores <- 
 read_html("[http://qz.com/755251/on-a-scale-from-1-100-milton-glaser-rates-every-single-olympic-logo-design-in-history/](http://qz.com/755251/on-a-scale-from-1-100-milton-glaser-rates-every-single-olympic-logo-design-in-history/)") %>%
 html_nodes('p') %>% 
 html_text()# extract scores
olympics_logo_scores <- olympics_logo_scores[which(substr(olympics_logo_scores, 1, 5) == 'Score')]

然后，我们将进行第二次呼叫，以获取每届奥运会的名称。

# Get olympics names
olympics_logo_names <- 
 read_html("[http://qz.com/755251/on-a-scale-from-1-100-milton-glaser-rates-every-single-olympic-logo-design-in-history/](http://qz.com/755251/on-a-scale-from-1-100-milton-glaser-rates-every-single-olympic-logo-design-in-history/)") %>%
 html_nodes('h2') %>% 
 html_text()

我们将把名字和分数数据合并到一个数据帧中，此外还有一列表示奥运会是在夏季还是冬季举行的。

# create combined df
olympic_logo_score_df <- 
 data.frame('olympics' = olympics_logo_names,
 'logo_score' = olympics_logo_scores,
 'season' = ifelse(grepl('Summer', olympics_logo_names), 'summer', 'winter'))# convert from factor to character
olympic_logo_score_df$olympics <- as.character(olympic_logo_score_df$olympics)

然后，我们将分两步从每一行中提取分数:首先，我们将拆分“out”上的字符串，去掉每个得分短语的第二部分，其中包含“满分 100 分”

# extract score (part 1 of 2)
olympic_logo_score_df$logo_score <- sapply(strsplit(as.character(olympic_logo_score_df$logo_score), 'out'), `[[`, 1)

然后我们将删除所有非数字字符，只留下数字分数。你会注意到有一个 NA，它与 2020 年东京夏季奥运会相关联。

# extract score (part 2 of 2)
olympic_logo_score_df$logo_score <- as.numeric(gsub("[^0-9]", "", olympic_logo_score_df$logo_score))

我们将使用类似的方法从完整的奥林匹克名称中提取数字年份。

# drop alpha characters
olympic_logo_score_df$year <- gsub("[^0–9]", "", olympic_logo_score_df$olympics)

我马上注意到的第一件事是夏季和冬季奥运会在同一年举行，直到 1992 年以后。92 年后，冬季奥运会在每届夏季奥运会后两年举行(或者两年前，取决于你对哪个更感兴趣)。整洁！

我在这个分析中的主要问题是时间和标志等级之间的关系。Glaser 比老游戏更喜欢新 logos 吗？让我们找出答案。使用 plotly，我们可以绘制按季节分组的徽标等级随时间变化的图表。

# graph scores over time by season
plot_ly(olympic_logo_score_df,
 x = year,
 y = logo_score,
 type = "line",
 group = season,
 text = olympics) %>%
 add_trace(y = fitted(loess(logo_score ~ year)),
 x = year,
 name = 'Overall trend',
 line = list(dash = 5)) %>% 
 layout(title = 'Olympics Logo Scores Over Time',
 yaxis = list(range = list(0,100),
 title = 'Score'),
 xaxis = list(title = 'Year'))

Fully interactive plot available here

我们可以看到格拉泽确实更喜欢现代的标志，而不是早期夏季和冬季奥运会的标志。

与夏季奥运会相比，冬季奥运会的标志似乎普遍低于趋势水*。让我们调查一下他的偏好是否会因奥运会的类型而异。

# boxplot by season
plot_ly(olympic_logo_score_df,
 y = logo_score,
 type = "box",
 group = season,
 boxpoints = "all",
 pointpos = 0) %>% 
 layout(title = 'Olympics Logo Scores by Season',
 yaxis = list(range = list(0,100),
 title = 'Score'),
 xaxis = list(title = 'Season'))

Fully interactive plot available here

我们可以看到夏季奥运会标志的分数比冬季奥运会标志的分数有更大的变化。然而，夏季奥运会标志的中位数也更高，表明 Glaser 通常更喜欢夏季奥运会标志。

一个使用人工智能将图形设计转换为功能代码的应用程序。

原文：https://towardsdatascience.com/an-app-that-uses-a-i-to-convert-graphic-designs-into-functioning-code-5097415ed812?source=collection_archive---------5-----------------------

Tony Beltramelli (https://uizard.io)

作为 Idyee 的前端开发人员，我的工作包括根据客户的要求设计和开发定制用户界面(应用程序的外观和感觉)。这是为 web、IOS 和 Android 开发而做的。在大多数情况下，在客户满意之前，我们需要经历如此多的迭代。之后，我们需要将图形转换成使用 HTML、CSS、JavaScript 编写的代码。

这一繁琐的过程显然意味着我们将有更少的时间来开发应用程序的核心功能。可以说，需要一个解决方案来确保客户端应用程序的设计和开发尽可能高效。输入 P ix2Code 。

Pix2Code 是一款由总部位于哥本哈根的人工智能初创公司开发的应用，名为 UIzard Technologies 。该应用程序使用一个经过训练的神经网络将截图转化为代码行。它需要一个用于用户界面设计的图像作为输入，然后将其转换成相应的代码。

该应用程序令人印象深刻的一个特点是，它生成的代码与 Android、IOS 和 Web 技术兼容，准确率为 77 %。你可以阅读Arxiv上发表的文献。

UIzard 的创始人 Tony Beltramelli 认为 Pix2Code 有潜力“终结对手工编程图形用户界面的需求”。我说机器人万岁。😃

使用 Python 进行时间序列分析和预测的端到端项目

原文：https://towardsdatascience.com/an-end-to-end-project-on-time-series-analysis-and-forecasting-with-python-4835e6bf050b?source=collection_archive---------0-----------------------

Photo credit: Pexels

时间序列分析包括分析时间序列数据的方法，以提取有意义的统计数据和数据的其他特征。时间序列预测是使用模型根据以前观察到的值来预测未来值。

时间序列广泛用于非*稳数据，如经济、天气、股票价格和本文中的零售额。我们将展示预测零售时间序列的不同方法。我们开始吧！

数据

我们使用的是超市销售数据，可以从这里下载。

import warnings
import itertools
import numpy as np
import matplotlib.pyplot as plt
warnings.filterwarnings("ignore")
plt.style.use('fivethirtyeight')
import pandas as pd
import statsmodels.api as sm
import matplotlibmatplotlib.rcParams['axes.labelsize'] = 14
matplotlib.rcParams['xtick.labelsize'] = 12
matplotlib.rcParams['ytick.labelsize'] = 12
matplotlib.rcParams['text.color'] = 'k'

在超市销售数据中有几个类别，我们从家具销售的时间序列分析和预测开始。

df = pd.read_excel("Superstore.xls")
furniture = df.loc[df['Category'] == 'Furniture']

我们有良好的 4 年家具销售数据。

furniture['Order Date'].min(), furniture['Order Date'].max()

时间戳(' 2014–01–06 00:00:00 ')，时间戳(' 2017–12–30 00:00:00 ')

数据预处理

这一步包括删除我们不需要的列，检查缺少的值，按日期合计销售额等等。

cols = ['Row ID', 'Order ID', 'Ship Date', 'Ship Mode', 'Customer ID', 'Customer Name', 'Segment', 'Country', 'City', 'State', 'Postal Code', 'Region', 'Product ID', 'Category', 'Sub-Category', 'Product Name', 'Quantity', 'Discount', 'Profit']
furniture.drop(cols, axis=1, inplace=True)
furniture = furniture.sort_values('Order Date')furniture.isnull().sum()

Figure 1

furniture = furniture.groupby('Order Date')['Sales'].sum().reset_index()

使用时间序列数据进行索引

furniture = furniture.set_index('Order Date')
furniture.index

Figure 2

我们当前的日期时间数据可能很难处理，因此，我们将使用该月的*均日销售额，并且我们使用每个月的月初作为时间戳。

y = furniture['Sales'].resample('MS').mean()

快速一瞥 2017 年家具销售数据。

y['2017':]

Figure 3

可视化家具销售时间序列数据

y.plot(figsize=(15, 6))
plt.show()

Figure 4

当我们绘制数据时，出现了一些明显的模式。该时间序列具有季节性模式，例如销售额总是在年初低，在年底高。在任何一年中，总会有一个上升的趋势，在年中会有几个低的月份。

我们还可以使用一种称为时间序列分解的方法来可视化我们的数据，这种方法允许我们将时间序列分解为三个不同的部分:趋势、季节性和噪声。

from pylab import rcParams
rcParams['figure.figsize'] = 18, 8decomposition = sm.tsa.seasonal_decompose(y, model='additive')
fig = decomposition.plot()
plt.show()

Figure 5

上图清楚地显示了家具销售的不稳定性，以及其明显的季节性。

ARIMA 时间序列预测

我们将应用一种最常用的时间序列预测方法，称为 ARIMA，它代表自回归综合移动*均。

ARIMA 模型用符号ARIMA(p, d, q)表示。这三个参数说明了数据中的季节性、趋势和噪声:

p = d = q = range(0, 2)
pdq = list(itertools.product(p, d, q))
seasonal_pdq = [(x[0], x[1], x[2], 12) for x in list(itertools.product(p, d, q))]print('Examples of parameter combinations for Seasonal ARIMA...')
print('SARIMAX: {} x {}'.format(pdq[1], seasonal_pdq[1]))
print('SARIMAX: {} x {}'.format(pdq[1], seasonal_pdq[2]))
print('SARIMAX: {} x {}'.format(pdq[2], seasonal_pdq[3]))
print('SARIMAX: {} x {}'.format(pdq[2], seasonal_pdq[4]))

Figure 6

这一步是为我们的家具销售 ARIMA 时间序列模型选择参数。我们在这里的目标是使用“网格搜索”来找到为我们的模型产生最佳性能的最佳参数集。

for param in pdq:
    for param_seasonal in seasonal_pdq:
        try:
            mod = sm.tsa.statespace.SARIMAX(y,
                                            order=param,
                                            seasonal_order=param_seasonal,
                                            enforce_stationarity=False,
                                            enforce_invertibility=False)results = mod.fit()print('ARIMA{}x{}12 - AIC:{}'.format(param, param_seasonal, results.aic))
        except:
            continue

Figure 7

上面的输出表明SARIMAX(1, 1, 1)x(1, 1, 0, 12)产生最低的AIC值 297.78。因此，我们应该认为这是最佳选择。

拟合 ARIMA 模型

mod = sm.tsa.statespace.SARIMAX(y,
                                order=(1, 1, 1),
                                seasonal_order=(1, 1, 0, 12),
                                enforce_stationarity=False,
                                enforce_invertibility=False)results = mod.fit()print(results.summary().tables[1])

Figure 8

我们应该始终运行模型诊断来调查任何不寻常的行为。

results.plot_diagnostics(figsize=(16, 8))
plt.show()

Figure 9

它并不完美，但是，我们的模型诊断表明，模型残差接*正态分布。

验证预测

为了帮助我们了解预测的准确性，我们将时间序列的预测销售额与实际销售额进行比较，并将预测从 2017 年 1 月 1 日开始设置到数据结束。

pred = results.get_prediction(start=pd.to_datetime('2017-01-01'), dynamic=False)
pred_ci = pred.conf_int()ax = y['2014':].plot(label='observed')
pred.predicted_mean.plot(ax=ax, label='One-step ahead Forecast', alpha=.7, figsize=(14, 7))ax.fill_between(pred_ci.index,
                pred_ci.iloc[:, 0],
                pred_ci.iloc[:, 1], color='k', alpha=.2)ax.set_xlabel('Date')
ax.set_ylabel('Furniture Sales')
plt.legend()plt.show()

Figure 10

线形图显示了观测值与滚动预测值的对比。总的来说，我们的预测与真实值非常吻合，显示了从年初开始的上升趋势，并在年底抓住了季节性。

y_forecasted = pred.predicted_mean
y_truth = y['2017-01-01':]mse = ((y_forecasted - y_truth) ** 2).mean()
print('The Mean Squared Error of our forecasts is {}'.format(round(mse, 2)))

我们预测的均方差是 22993.58

print('The Root Mean Squared Error of our forecasts is {}'.format(round(np.sqrt(mse), 2)))

我们预测的均方根误差是 151.64

在统计学中，估计量的均方误差(MSE) 衡量误差的*方*均值，即估计值和估计值之间的*均*方差。MSE 是对估计量质量的一种度量，它总是非负的，MSE 越小，我们就越接*找到最佳拟合线。

均方根误差(RMSE) 告诉我们，我们的模型能够在实际销售额的 151.64 范围内预测测试集中的*均每日家具销售额。我们的家具日销售量从 400 件左右到 1200 多件不等。在我看来，到目前为止这是一个相当不错的模型。

生成和可视化预测

pred_uc = results.get_forecast(steps=100)
pred_ci = pred_uc.conf_int()ax = y.plot(label='observed', figsize=(14, 7))
pred_uc.predicted_mean.plot(ax=ax, label='Forecast')
ax.fill_between(pred_ci.index,
                pred_ci.iloc[:, 0],
                pred_ci.iloc[:, 1], color='k', alpha=.25)
ax.set_xlabel('Date')
ax.set_ylabel('Furniture Sales')plt.legend()
plt.show()

Figure 11

我们的模型清楚地捕捉到了家具销售的季节性。随着我们对未来的进一步预测，我们对自己的价值观变得不那么自信是很自然的。这反映在我们的模型生成的置信区间上，随着我们向未来进一步发展，置信区间变得更大。

上面对家具的时间序列分析让我对其他类别感到好奇，随着时间的推移，它们是如何相互比较的。因此，我们将比较家具和办公用品供应商的时间序列。

家具与办公用品的时间序列

根据我们的数据，这些年来，办公用品的销售额远远高于家具。

furniture = df.loc[df['Category'] == 'Furniture']
office = df.loc[df['Category'] == 'Office Supplies']
furniture.shape, office.shape

((2121，21)，(6026，21))

数据探索

我们将比较两个类别在同一时期的销售额。这意味着将两个数据帧合并成一个，并将这两个类别的时间序列绘制成一个图。

cols = ['Row ID', 'Order ID', 'Ship Date', 'Ship Mode', 'Customer ID', 'Customer Name', 'Segment', 'Country', 'City', 'State', 'Postal Code', 'Region', 'Product ID', 'Category', 'Sub-Category', 'Product Name', 'Quantity', 'Discount', 'Profit']
furniture.drop(cols, axis=1, inplace=True)
office.drop(cols, axis=1, inplace=True)furniture = furniture.sort_values('Order Date')
office = office.sort_values('Order Date')furniture = furniture.groupby('Order Date')['Sales'].sum().reset_index()
office = office.groupby('Order Date')['Sales'].sum().reset_index()furniture = furniture.set_index('Order Date')
office = office.set_index('Order Date')y_furniture = furniture['Sales'].resample('MS').mean()
y_office = office['Sales'].resample('MS').mean()furniture = pd.DataFrame({'Order Date':y_furniture.index, 'Sales':y_furniture.values})
office = pd.DataFrame({'Order Date': y_office.index, 'Sales': y_office.values})store = furniture.merge(office, how='inner', on='Order Date')
store.rename(columns={'Sales_x': 'furniture_sales', 'Sales_y': 'office_sales'}, inplace=True)
store.head()

Figure 12

plt.figure(figsize=(20, 8))
plt.plot(store['Order Date'], store['furniture_sales'], 'b-', label = 'furniture')
plt.plot(store['Order Date'], store['office_sales'], 'r-', label = 'office supplies')
plt.xlabel('Date'); plt.ylabel('Sales'); plt.title('Sales of Furniture and Office Supplies')
plt.legend();

Figure 13

我们观察到家具和办公用品的销售也有类似的季节性模式。年初是这两个类别的淡季。对于办公用品来说，夏天似乎也很安静。此外，在大多数月份里，家具的*均日销售额都高于办公用品。这是可以理解的，因为家具的价值应该远远高于办公用品。偶尔，办公用品的日*均销售额会超过家具。让我们来看看办公用品的销售额第一次超过家具的销售额是什么时候。

first_date = store.ix[np.min(list(np.where(store['office_sales'] > store['furniture_sales'])[0])), 'Order Date']print("Office supplies first time produced higher sales than furniture is {}.".format(first_date.date()))

办公用品首次产生高于家具的销量是 2014–07–01。

那是 2014 年 7 月！

用 Prophet 进行时间序列建模

脸书于 2017 年发布的预测工具 Prophet 旨在分析时间序列，这些时间序列在不同的时间尺度上显示模式，如每年、每周和每天。它还具有高级功能，可以对节假日对时间序列的影响进行建模，并实现自定义的变点。因此，我们使用 Prophet 来启动并运行一个模型。

from fbprophet import Prophetfurniture = furniture.rename(columns={'Order Date': 'ds', 'Sales': 'y'})
furniture_model = Prophet(interval_width=0.95)
furniture_model.fit(furniture)office = office.rename(columns={'Order Date': 'ds', 'Sales': 'y'})
office_model = Prophet(interval_width=0.95)
office_model.fit(office)furniture_forecast = furniture_model.make_future_dataframe(periods=36, freq='MS')
furniture_forecast = furniture_model.predict(furniture_forecast)office_forecast = office_model.make_future_dataframe(periods=36, freq='MS')
office_forecast = office_model.predict(office_forecast)plt.figure(figsize=(18, 6))
furniture_model.plot(furniture_forecast, xlabel = 'Date', ylabel = 'Sales')
plt.title('Furniture Sales');

Figure 14

plt.figure(figsize=(18, 6))
office_model.plot(office_forecast, xlabel = 'Date', ylabel = 'Sales')
plt.title('Office Supplies Sales');

Figure 15

比较预测

我们已经有了这两个类别未来三年的预测。我们现在将他们放在一起比较他们对未来的预测。

furniture_names = ['furniture_%s' % column for column in furniture_forecast.columns]
office_names = ['office_%s' % column for column in office_forecast.columns]merge_furniture_forecast = furniture_forecast.copy()
merge_office_forecast = office_forecast.copy()merge_furniture_forecast.columns = furniture_names
merge_office_forecast.columns = office_namesforecast = pd.merge(merge_furniture_forecast, merge_office_forecast, how = 'inner', left_on = 'furniture_ds', right_on = 'office_ds')forecast = forecast.rename(columns={'furniture_ds': 'Date'}).drop('office_ds', axis=1)
forecast.head()

Figure 16

趋势和预测可视化

plt.figure(figsize=(10, 7))
plt.plot(forecast['Date'], forecast['furniture_trend'], 'b-')
plt.plot(forecast['Date'], forecast['office_trend'], 'r-')
plt.legend(); plt.xlabel('Date'); plt.ylabel('Sales')
plt.title('Furniture vs. Office Supplies Sales Trend');

Figure 17

plt.figure(figsize=(10, 7))
plt.plot(forecast['Date'], forecast['furniture_yhat'], 'b-')
plt.plot(forecast['Date'], forecast['office_yhat'], 'r-')
plt.legend(); plt.xlabel('Date'); plt.ylabel('Sales')
plt.title('Furniture vs. Office Supplies Estimate');

Figure 18

趋势和模式

现在，我们可以使用 Prophet 模型来检查数据中这两个类别的不同趋势。

furniture_model.plot_components(furniture_forecast);

Figure 19

office_model.plot_components(office_forecast);

Figure 20

很高兴看到家具和办公用品的销售一直呈线性增长，并将继续增长，尽管办公用品的增长似乎略显强劲。

家具最差的月份是四月，办公用品最差的月份是二月。家具最好的月份是 12 月，办公用品最好的月份是 10 月。

今后可以探索的时间序列分析方法有很多，如不确定界预测、变点和异常检测、外部数据源预测时间序列等。我们才刚刚开始。

源代码可以在 Github 上找到。我期待听到反馈或问题。

参考资料:

Python 3 中的 ARIMA 时间序列预测指南

Python 3 中的 Prophet 时间序列预测指南

道德准则不可能是关于道德的

原文：https://towardsdatascience.com/an-ethical-code-cant-be-about-ethics-66acaea6f16f?source=collection_archive---------7-----------------------

这就是为什么我不能支持 Data for Democracy 的数据科学道德准则。

Stotting (a costly signal): the jumping up and down proves to a predator that the animal isn’t an easy target

【编辑:我试图在这里对科技伦理这个主题做一个更全面的总结:https://hacker noon . com/can-we-be-honest-about-ethics-ECF 5840 b6e 07

上周，我写了一篇文章，对 Data for Democracy 创建数据科学道德准则的意图表示怀疑。我关注的是这个项目的实际可行性。在大量谈论、阅读和观察 D4D 道德准则的演变之后，我仍然相信这些被提议的原则在很大程度上是不可行的。我现在还认为，工作组产生的成果完全建立在错误的基础上。这不是向前迭代一个解决方案。如果你构建的是错误的东西，再多的修改也不会成功。

我们需要明确道德准则的含义。如果我们可以现实地期望社区中的每个人都采纳道德规范，因为他们直觉地认为这是好的和正确的事情，那么道德规范是不必要的——它只不过是美德信号。如果我们不能现实地期望完全的有机采用，那么代码就是一种机制，来胁迫那些不同意它的人，来谴责那些不遵守它的人。这两条途径——大规模的自愿采纳或强制——是道德准则真正有意义的唯一两种方式。

一个职业中的任何一部分人有什么权利宣布这个职业中的每个人什么是对的或者什么是错的？完全没有权利。任何人都没有权利对他人发号施令，但有时一些人可以获得足够的权力来这样做。在一系列非常特殊的情况下，整个行业都可以从中受益。

越想越对希波克拉底誓言印象深刻。在我看来，医疗职业是基于两个前提:一个不健康的人，*均来说，在与医生的互动过程中，应该变得更健康；一个健康的人，*均来说，在与医生的互动过程中，不会变得不健康。这就是医生的谋生之道:医生个人从这两个前提中获益，这对大多数人来说是真实的。

如果这两个前提都不成立，任何允许医生个人从当医生中获益的做法都会损害每个人信任医生的能力。如果一个医生不能治愈病人而仍然保持繁荣，那么“医生”的头衔，或者医学学位，或者医学职业的其他标志就毫无意义。

希波克拉底誓言的每一个组成部分都要求医生故意限制自己的繁荣，要么以自己的代价让他人受益，要么拒绝从通常会成为公*游戏的情况中受益。这是关键。希波克拉底誓言是一个有效的道德准则，因为它不是对与错的陈述。这是一系列昂贵的信号。

昂贵的信号是故意将自己置于不利地位的做法，以显示你能够承受这种牺牲。一些瞪羚消耗能量上蹿下跳向掠食者展示它们有如此多的能量可以浪费，证明它们太强壮太快了，掠食者不会打扰它们。宗教团体的人们牺牲资源来证明他们从团体中得到足够的东西来弥补损失。昂贵的信号是一种将皮放进游戏的方式，纳西姆·塔勒布(Nassim Taleb)最彻底地充实了这一概念:“任何参与可能对他人产生伤害的行动的人，即使是概率上的，都应该被要求暴露于某种伤害。”如果有人发出昂贵的信号，这意味着他们实际上拥有丰富的东西——技能、知识、资源、力量、智力、承诺——让他们能够承担这一成本。

这些人是你想雇佣的。这些人已经表明他们有足够的能力，愿意在其他领域受到打击。对于医生来说，这意味着他们有足够好的让病人健康并保持健康的记录，他们不需要通过拒绝教学来节省时间，或从与客户的关系中获得附带利益。江湖骗子只做不花钱的信号工作。昂贵的信号淘汰骗子。

这如何转化为数据科学？在与数据科学家的互动过程中，业务人员应该…什么？做出更好的决定？那太笼统了，没有意义。赚取更多利润？数据科学和利润之间有一个巨大的因果链——有太多的方式，其中一些是合法的，来解释未能执行。

一般来说，企业中的人们在与数据科学家的互动过程中，应该增加投入到只有人类才能做出的决策中的时间和资源的百分比。

在我看来，这是数据科学的核心目的。(当然不是唯一的一个，但是为了当前讨论的目的，我们可以将重点放在这个上)。有些人们花时间做的事情，机器也能做得一样好。还有一些人们花时间做的事情是机器根本做不到的。没有一个管理组织的人会用尽所有需要做出的决定。这意味着许多决策必然是仓促做出的，或者被推诿给不合格的下属，或者被遗忘，直到它们恶化到成为一个真正的问题。人们最终会关注他们不应该关注的事情，仅仅是因为他们不能足够快地筛选出吸引他们注意力的竞争需求。

数据科学的前景是，目前由人类做出的许多决定可以由算法做出，甚至更好。“更好”可以指更准确、更高效、更细致、更划算等。在自动化解放人们去做其他事情之前，自动化决策只不过是一种学术实践。决策自由是数据科学版的患者健康——持续保持和发展这种自由是数据科学家个人成功的基础。

鉴于道德准则必须由相对较少的人强加给大多数人，从伦理上定义道德准则的唯一方法是规定，不是道德，而是游戏中的皮肤。这极大地缩小了道德规范的范围，因为对成本的列举总是比对信仰的列举要少。道德准则不仅仅是定义游戏中的皮肤，它实际上破坏了道德行为，因为它为人们提供了不管能力如何都要发出美德信号的方式——使确保职业内的高道德标准变得更难，而不是更容易。

数据科学家不需要一个道德标准的列表。他们需要一系列方法来证明他们不是骗子。这将比其他任何事情都更能确保该行业的健康和可信度。

民主数据组织显然还没有结束创建道德准则的努力，但他们现在已经准备好的工作文件和我的谈话清楚地表明，他们专注于列举美德而不是成本。这是建立道德体系的错误基础。

通过无监督学习检验国际美食

原文：https://towardsdatascience.com/an-examination-of-international-cuisines-through-unsupervised-learning-93c8b56d1ea0?source=collection_archive---------4-----------------------

Typical Tyrolean Käsespätzle (Image courtesy: https://austria-forum.org/)

像很多人一样，我也是一个美食迷。我非常幸运，在一个吃饭都是从零开始的家庭长大。我妈妈做饭，因为她从德国移民到美国，我接触了很多美味的德国菜肴。我最喜欢的一些包括 sespä tzle，Semmelknö del 和 Sauerbraten。虽然我从来不敢说我有妈妈的烹饪天赋，但我确实非常享受从零开始做一顿饭的过程，当然也和我自己的家人分享这顿饭。

以此作为我的背景故事，我认为开展一个涉及世界各地食谱的数据科学项目会非常有趣。我想看看我是否能了解世界各地不同烹饪之间的关系。为了探索这个话题，我收集了代表 25 种不同烹饪类型的 12，000 多种不同食谱的数据。然后，我进行自然语言处理(NLP ),将文本数据转换成可以输入机器学习算法的格式。最后，我进行了主成分分析(PCA)和主题建模，以获得数据的洞察力。

数据收集

我在这个项目中使用的食谱数据来自 Yummly 。我被授予了他们 API 的学生许可证(谢谢，美味！)，这让我可以直接从 ipython 笔记本上查询和搜索食谱。Yummly 支持基于菜肴类型进行搜索。以下是支持的菜系列表:

• 美国、意大利、亚洲、墨西哥、南方和灵魂食物、法国、西南、烧烤、印度、中国、卡津和克里奥尔、英国、地中海、希腊、西班牙、德国、泰国、摩洛哥、爱尔兰、日本、古巴、夏威夷、瑞典、匈牙利、葡萄牙

我总共下载了 25 种受支持菜系的大约 500 种食谱。这导致了大约 12，500 种不同食谱。对于数据收集，我使用 Requests 库读入数据，并使用内置的 JSON 编码器将 JSON 数据转换成 python 字典。然后，将数据转换成熊猫数据框架相对简单。下面显示了数据框中几个选定行的屏幕截图。

Selected rows of the Yummly recipe DataFrame

对于我的分析，我只使用了对应于美食和配料的列。所有其他列都被忽略。

文本数据处理和机器学习工作流

由于数据只包含文本，因此有必要使用 NLP 技术实现一些预处理步骤。这些步骤如下:

• 复合某些成分(如橄榄油、玉米淀粉)
• 将成分拆分成单词列表的标记化
• 删除停用词和其他频繁出现的词(例如，盐、胡椒、水)
• 通过去掉单词的复数形式和其他后缀来词干化
• 单词包处理创建一个稀疏矩阵，该矩阵包含成分列表中的所有单词以及它们出现的频率

我用来实现前面步骤列表的工具包括 sklearn 中的 TfidfVectorizer 和 CountVectorizer。其中一些步骤，比如断字和停用词移除，需要我编写自己的代码来实现，因为这些步骤对于这个特定的用例来说更加独特。鼓励读者查看我为这个项目准备的 Github repo 来了解更多信息。

我重点研究的机器学习算法都是无监督学习算法。我做了 k-Means 聚类，看看我是否可以根据菜系类型将食谱聚类在一起，但是聚类对我的分析没有太大帮助，因为不清楚不同的聚类代表什么。相反，我将注意力集中在主成分分析(PCA)和潜在狄利克雷分配(LDA)上，我将在结果部分进一步讨论。

结果

为了能够可视化我的数据，我实施了降维，以便将特征空间从 1982 维(对应于我的数据集中不同成分的数量)减少到 2 维。这一步是使用主成分分析完成的，我保留了前两个主成分。然后，我针对第一个和第二个主成分为每个配方创建了一个散点图，如下所示。

A scatter plot consisting of all 12,492 recipes along the first and second principal components.

当在这个二维主成分空间中绘制所有食谱时，我没有学到很多东西，因为许多数据点是重叠的，所以很难在数据中看到任何结构。然而，通过根据菜系对食谱进行分组，并取前两个主成分的质心值，我可以在数据中看到一些有趣的结构。下图显示了这种情况。

A plot of the centroid values for each of the different cuisines along the first and second principal components. Group (A) is associated with Asian cuisines, (B) consists of Japanese and Hawaiian cuisines, (C) and (D) are European and American cuisines, respectively. Group (E) is a mixed bag of cuisines from all over the world including Cuban, Mexican, Indian, and Spanish.

上面的情节提供了一些关于不同菜系之间关系的有趣见解。我们可以观察到质心值倾向于根据相似的烹饪类型对食谱进行分组。例如，图 2 中的组(A)由中国、泰国和亚洲食物组成，它们都可以归类为亚洲食物。组(B)包括日本和夏威夷菜肴。这两种菜系都非常强调鱼，所以它们紧密地组合在一起是有道理的。(C)组完全由欧洲美食组成，如瑞典、法国和德国，而不远处的(D)组主要由北美美食组成。这些包括南方风味、烧烤风味和传统美国风味。最后,( E)组是世界各地许多不同美食的大杂烩。这包括古巴、墨西哥、印度、西班牙和西南部。当我想到这些美食时，我会想到大而大胆的味道，所以这些美食紧密地组合在一起是完全合理的。

读者可能会问，哪些特征(即成分)与第一和第二主成分联系最紧密？这可以在下图中看到。

A plot demonstrating the ingredients most strongly associated with the first and second principal components.

该图为两个主要成分中的每一个提供了主要特征的视觉表示。鸡肉、大蒜、洋葱和番茄等配料与第一部分的正向有很强的关联。这些风味与西班牙菜或印度菜有着紧密的联系。另一方面，鸡蛋、黄油、面粉、牛奶和糖沿着分量一的负方向具有很强的关联性。这些是法国菜或英国菜中常见的配料。同样，大豆、酱油和大米与第二部分的正方向有很强的关联。这些配料在亚洲菜肴中很常见。最后，奶酪、柠檬、橄榄油和西红柿与分量二的负方向有很强的关联。这些口味在意大利和希腊菜肴中很常见。该图有助于解释上图的结构，即当沿着第一和第二主成分作图时，为什么某些菜系在特定区域聚集在一起。

最后，我还运行了一个 LDA 模型，以便进行主题建模(见下文)。我很好奇，想看看是否有可能根据不同的食材所属的菜系来区分它们。我将主题数量指定为 25，因为我知道在我的数据集中有 25 种不同的菜系。然而，LDA 的结果有点混乱。在某些情况下，LDA 主题是特定的美食，如意大利菜或泰国菜。然而，有些主题是不同种类的菜肴，如甜点、酱汁，甚至鸡尾酒。虽然这个结果不是我想要的，但现在回想起来，它确实非常有意义。LDA 是一种机器学习技术，它可以识别频繁出现的单词组。因此，在超过 12，000 个食谱的语料库中，与烹饪类型相比，基于菜肴类型(即甜点、汤、沙拉或酱)的单词组可能有更强的关联。

Results from LDA topic modeling.

结束语

我在探索食谱数据集的过程中获得了很多乐趣，因为我真的很喜欢将我对食物的热爱与我在数据科学中获得的新技能结合起来。人们也可以为这种类型的分析做一个强有力的商业案例，因为这些信息可以用来向 Yummly *台的用户提供食谱建议。例如，真正喜欢烧烤食物的人也可能真正喜欢葡萄牙菜，因为当沿着第一和第二主成分绘制它们的质心时，这两种菜类型重叠。在没有研究数据的情况下，我无法预见这样的关系。

然而，重要的是要披露，这篇博客中使用的数据并非没有缺陷。例如，Yummly 基本上是一个从许多其他食谱网站或博客上收集食谱的网站，所有这些网站都是英文的。因此，这些食谱中的许多可能是美国人对其他烹饪类型的吸收。我敢肯定，我的意大利朋友会说，像 this 这样结合了鸡肉和香蒜酱的食谱“不是意大利的！”，尽管 Yummly 把这个食谱贴上了意大利的标签。处理这个问题的更好的方法可能是找到他们母语的食谱，并使用一些先进的翻译算法将它们翻译成英语。然而，由于成分可能因特定地理区域而异，这也可能导致意想不到的问题。例如，某些配料可能没有英语对等词(例如，意大利帕尔玛火腿、帕尔玛意大利干酪)，因此这些配料将总是与意大利菜肴联系在一起。这可能会导致不同类型的菜肴之间的相似性减少，但我认为这仍然是值得探索的。

非常感谢你阅读我的博文。如果你想为这个项目探索我的代码，你可以在下面的 Github repo 找到它。此外，反馈将非常感谢，所以请随时联系我或给我一个“鼓掌”，如果你喜欢这篇文章。

一个影响机器学习的实验性开发过程

原文：https://towardsdatascience.com/an-experimental-development-process-for-making-an-impact-with-ai-f09c8155a4fe?source=collection_archive---------13-----------------------

如何避免生产道路上的常见错误

Photo by Alex Eckermann on Unsplash

利用机器学习来提供切实的用户价值，这真的很难建立产品功能和内部运营工具。不仅仅是因为很难处理数据(确实如此)，或者是因为人工智能有许多琐碎的用途，虽然很简洁，但并不那么有用(确实有)，而是因为几乎从来没有这样的情况，你会有一个明确定义和限定的问题交给你，而且在纯粹的技术方面之外还有许多未知因素可能在任何时候破坏你的项目。我看到了许多关于技术方面的优秀文章，提供了如何处理数据和建立机器学习模型的代码和建议，以及如何雇用工程师和科学家的人员方面，但这只是一部分。另一部分是如何引导技术和人通过障碍，让这种工作产生影响。

幸运的是，我已经因为许多原因多次未能部署人工智能来提供商业和用户价值，并看到从初创公司到财富 500 强数据科学和研究小组的朋友和同事都在为同样的问题而挣扎。技术几乎总是有价值的，人也是有能力的，但是造成差异的是人们如何一起工作，他们在研究什么技术。换句话说，我相信你能雇佣到技术过硬的人，他们能很好地应用他们的工具，但是除非是合适的人在合适的时间为合适的业务问题构建合适的东西，否则这些都没用。(是的，没错，但这比你想象的要难)。

在这篇文章中，我试图巩固学到的知识，引用我认为有用的现有文章(对我肯定错过的参考文献表示歉意)，并为添加一些色彩，说明为什么构建实验产品很难，它与其他工程有什么不同，你的过程可能会是什么样子，以及你可能会在哪里遇到失败点。

警告:对于这种动态的任何东西，您都需要使有意义的部分适应您自己的需求，并不断地发展它，但是大多数基本构件应该是适用的。这里也没什么聪明的，大多是常识，但是很多事情回想起来就是那样。我试图做的是将事情放入一个支持实验性开发过程的概念框架中——建立一个问题，定义指标，构建一些简单的端到端的东西，可以学习和迭代——这在理论上看似相似，但在实践中与许多开发人员、经理，特别是 R&D 以外的人所习惯的完全不同。

请随意跳到摘要或延伸阅读。

为什么是实验性开发过程

在我们最熟悉的软件工程中，我们从一组需要作为软件实现的特定产品或业务需求开始开发。当前流行的基于小特性的 sprints 的增量构建项目的过程已经建立，并且对于围绕可预测性而不是围绕实验的构建非常有用。它们是为构建软件而优化的，我们可能会发明产品功能，但不是技术——所以我们知道它会工作，并且可以估计大概需要多长时间。这绝非易事。仍然存在不确定性、软件和设计约束以及成本/时间/性能权衡，但是这些权衡以及处理它们的方法更容易理解。在高层次上，这些对于实验开发是有意义的，但是当应用时，它们经常导致失败，因为很难估计一个实验会在什么时候进行得有多好。

另一方面，当我们开始对人工智能功能进行产品开发，或者优化内部业务流程时，我们有许多未决问题，主要是:

• 问什么问题才是正确的？
• 解决这个问题的最佳方案是什么？
• 我们有这方面的数据吗？
• 效果如何？
• 我们能在多大程度上将其投入生产？

除了软件和设计的限制，我们对问题和解决方案本身有不确定性。因此，这些产品具有很高的实验和操作风险。实验风险之所以存在，是因为根据定义，有许多未知因素。这种风险存在于用户双方(即问题，他们实际上想要什么？)和技术方面(即解决方案，我们实际上能构建什么？)，两者紧密相连。

当我们试验我们可以构建什么以及它的性能如何时，我们改变了我们对它如何最好地解决用户问题的理解，并进化出正确的问题。

因此，这些特性几乎从来没有一个明确的终点，每一次迭代都创造了对问题的进一步理解，并开启了新的解决方案。

运营风险与任何项目一样存在，并随着实验过程而增加，因为时间表的不确定性和迭代解决方案会导致更长的项目生命周期和错过交付机会。按照可预测的时间表建立一个实验项目是非常困难的。

事实上，不管你在上面花了多少时间，期望第一次(多次)构建错误是有用的。这意味着你不会完全理解每件事，也不会在做任何事情之前就把它做好。数据产品有一个自然的进化过程:指导原则是我们有一个合理的、可行的但不完美的解决方案，我们用它来收集更多的知识来改进解决方案。

失败

一些最常见的实验和操作故障如下。不管你做什么，不要期望完全避免它们，但是你绝对可以学会减少它们。

没有找到解决方案。不是因为它被测试了，失败了，项目被关闭了，这很好，但是陷入了一个没有尽头的问题的迭代中。这通常是因为没有建立用户成功标准，或者没有一个项目涉众频繁参与的进度跟踪机制。

构建尚未量产的解决方案。这通常伴随着早期没有足够的组织或利益相关者的支持，没有建立工程部署可行性或考虑基础设施的成本，或技术转移和维护的时间，或开始采用过于复杂的解决方案，这无法从原型进行转移。

产生一个解决方案，但不对其进行迭代。这通常伴随着缺乏用于重建和重新部署解决方案的适当基础设施，以及收集反馈和监控指标的必要数据管道。

构建无用的解决方案。一切顺利，但仍是一次失败，可以说是浪费了更多时间以来最糟糕的一次。发生这种情况的原因有很多，但最常见的是，从一开始就没有与风险承担者就有影响且可操作的问题达成一致，从而解决了对业务价值不明确的问题。

我们都多次经历过这些失败，这对每个人来说都是令人沮丧的。

你认为你浪费了时间，觉得你没有能力产生影响，利益相关者认为你没有与用户共情，不理解业务问题，工程不知道你在做什么，认为你什么也没做，而与此同时，公司的其他人都在努力赶上最后期限。随着时间的推移，这导致了可信度的丧失，并质疑如果实验项目最终没有真正解决商业问题，它们会带来什么价值。

实验开发阶段

没有人喜欢为了过程而过程；它们增加了开销，当执行得不好时(这是很可能的)它们会占用原本有效率的时间。但是，除非你是独自工作，即使这样，你也需要一些组织结构。一个过程只有在帮助你实现一个结果的范围内才是好的，所以确保这个过程不是目标，并且尽可能的轻量级。

我们关注的最终结果是解决业务或用户需求。但是让我们把它分解成中间结果:

• 识别有影响的业务问题
• 快速解决问题
• 学习并迭代它

对于所有这些结果来说，成功的最重要的预测因素是确保每个参与者都理解并同意解决什么问题以及如何解决(在企业中:你需要与利益相关者保持一致)。开始时不只是一次，而是随着事情不可避免地不断出现。因为这需要你、产品、设计、工程和任何其他业务利益相关者之间持续和积极的沟通，下面的大部分内容实际上只是为了方便你在正确的时间与某人交谈，告诉他们他们需要知道什么，并从他们那里获得你需要知道的信息(我们稍后将讨论什么是什么是，但现在请注意后者不是被动的“他们告诉你”，而是你收集信息的主动努力)。

您需要这种交流来洞察业务或用户需求，以识别具有明确影响的具体、有价值的问题；当您对结果的质量进行反馈循环试验，以告知方向和验收，对解决方案的可行性进行工程评估；用于数据收集和管道的资源，监测绩效并为模型建立反馈回路；和生产解决方案的基础设施资源的能力。

这可以分为以下几个主要阶段— 构思、实验、数据收集、原型制作、技术转让、和监控 — ，如下图所示。我将假设您在一个主要利益相关者是产品和工程团队的环境中工作，但是即使名称改变了，大多数仍然适用。

Experimental development stages, assuming research, product, and engineering organization. Product and engineering stages may differ, but should have a closely corresponding one. The light pink box is dominated by your experimentation, the light purple by the user problem and solution, and the light green by engineering. Gray boxes represent expected output from each stage.

这些阶段实际上几乎从来不是连续的；而是来回往复，尤其是在构思、数据收集和原型制作之间。过程中的每个阶段至少有四个可定义的组成部分:目标、预期输入、预期输出和估计时间表。在高层次上，这些组件在项目之间是一致的，但是每个组件的确切实例化将因项目而异。

保持过程透明和负责任的一个关键是为每个项目维护一个共享的文档，当你经历每个阶段时，你在文档中定义组件是什么。此外，维护一个共享文档是一个好主意，该文档包含您在开发的所有阶段正在进行的所有项目的最新状态，包括您可以指出的以前的成功，以及以前的失败和失败的地方。

下表总结了我们在每个阶段努力实现的目标以及需要注意的事项；本文档的其余部分将详细描述其中的每一项。

思维能力

整个过程的第一步，也是最重要的一步是确立你正在解决的问题。这应该是一个具体的用户问题——定义不清、结构不良的问题很难解决(如果我们不知道我们想要什么，我们怎么知道我们什么时候解决了它？).它还应该对业务有很高的可衡量价值——增加客户或收入，例如提供新产品、打开新市场、提高客户满意度；或者节约成本，例如通过优化或自动化部分工作流程。

几乎每一次关于商业中的数据科学或机器学习的讨论都将从与业务保持一致开始。几乎不可能夸大这一点的重要性。识别问题的两大策略是:a)在内部提出问题，并向利益相关者“推销”解决方案；b)利益相关者带着问题来找你。实际上，它通常比这两者中的任何一个都更具协作性，但是只要存在区别， b)更有可能暴露业务的有价值的问题，为利益相关者创造一种一致感，这将导致对你的责任，并有助于防止陷入困境；简而言之，解决方案更有可能被建立并产生影响。

你总有一天会想，这很诱人，也是不可避免的，但我有一个很棒的新想法，是没人想过的。不幸的是，如果你不付出额外的努力来获得认同，这也很难成为一个成功的故事(不过不用担心，通过反复提供有价值的东西来建立信任后，你可能最终会成功)。如果这是你想走的路，那么一定要关注为什么你要构建的东西会提供价值，而不是你如何构建或构建什么。

那么，你怎么知道你得到了正确的问题呢？这不仅是好的，而且是必要的，在这里，你强烈地质疑利益相关者所提议的商业价值。这可能很棘手，因为许多人不习惯将对一个想法的智力挑战与对他们自己或他们角色的挑战分开，尤其是在不同的组织层面。你也不想让他们失望，减少他们与你一起工作的热情，因为他们可能会觉得奇怪，你没有抓住机会应用你的技能，但每个人都受益于尽早建立支持或反对一个项目的最强有力的理由。这需要一些实践，但是预先明确这一点，然后友好地协作实现业务价值是非常值得的。

我们都热衷于取悦他人，使用我们强大的机器学习锤子，大多数事情看起来像钉子，所以确保应用机器学习是有意义的(我们将在后面的阶段更多地讨论这一点，但即使在这一点上，这也将节省您的时间)。它可能会引起一些轰动，这可能是你为什么要这么做的原因，但是如果还没有什么东西，机器学习不会神奇地使一个功能变得有价值，即使你能做到，也不是每个问题都需要人工智能。如果问题可以用简单的算法解决，做简单的事情，可能会伤害你的自尊心，但会有助于你的机会。现在传递一个项目比在所有工作完成后让它无用要容易得多。

另一个关键是确保你和利益相关者理解 用户行为将如何基于提供的输出和分析而改变，和需要什么样的改变管理来实现。即使你能肯定地回答随后的技术问题(即，你有数据，能建立模型，能扩展它)，如果基于提供的输出没有行动的改变(可能因为它解决了错误的问题，或者因为输出不重要或不可变)，或者改变需要重大的改变管理(因此可能缺乏采用)，那么你没有增加价值。

在确定时机是否正确时，要考虑的有用方面是您对每个阶段的失败风险和所涉及的工作、资源依赖性(包括基础架构和数据)以及交付机制的复杂性的诚实猜测。我们将依次讨论这些问题。

一个好的起点是具有高影响值的问题(输出将导致用户操作)，增强现有的用户工作流(不需要他们改变它)，并且具有低风险和低工作量(可用数据、快速原型化的能力、高性能算法、简单的交付机制)。

你能满足的越多，你就越有可能得到相对快速的价值证明。从这些类型的问题入手有助于建立利益相关者和你对自己实现价值的能力的信心，从而建立解决高风险问题所必需的信任。

这并不意味着你不应该处理事情不清楚的复杂问题，当然你应该这样做。我们大多数人都喜欢挑战没有简单答案的问题，只有在坚持克服困难并创造出新颖的解决方案后，我们才能宣布胜利(这就是我们做我们所做的事情的动力，对吗？).这些会带来更多的个人成长和成就感，有时解决它们会创造巨大的价值。这就是它们如此吸引人的原因。

然而，你有限制(你有限的带宽，你公司有限的跑道，等等。)，所以你不能做所有的事情，当优先处理哪个问题时，注意不要把困难(问题的困难和解决问题需要经历的困难)和价值等同起来。困难的问题通常不是最大的业务影响所在。它通常存在于更简单的问题中(或者至少是可以被重构或分解成简单问题的问题)。所以承担难题(活一点！)，就尽量简单点他们。

如果你发现自己花了大量的时间来反对某事(例如，说服利益相关者产出是有价值的，对基础设施征税)，这是一个好迹象，现在不是时候。有时候很难放下这些，尤其是如果你坚信它的价值，但是现在可以更好地利用这些时间。

帮助利益相关者识别这些类型的问题将增加你的工作产生影响的可能性(这是上面的 a)和 b)之间的区别变得模糊的地方)。对很多(大多数？)人工智能和机器学习仍然是未知的，他们不明白为什么预测 A 目前是不可能的，但重新构建问题以预测 B——看起来很像 A——是超级容易的，或者如何通过求解 B，你可以实际上给他们 C，D 和 E，这对他们来说实际上可能更有价值。你需要弥合这些差距。

即使有人要求你建立一个特定的机器学习解决方案，开一个头脑风暴会议并回到问题上来也是有益的。不要太专业，但要提出问题的不同框架，以及解决问题的不同方法的例子。

有些问题的表述可能等同于利益相关者或用户，但你知道可能会把它从不可能变得容易。真正理解问题是什么取决于你(换句话说:帮助别人理解他们的问题取决于你)。

出现问题后，下一个最重要的步骤是确定评估指标和成功标准；知道衡量什么和如何评估表现意味着你知道你解决问题的情况如何(以及你什么时候足够好，或者不够好)。重要的是，尽管这包括实验模型评估指标(如准确性、召回率)，但它实际上是关于与利益相关者在用户或业务成功标准上保持一致。评估标准是你优化的，成功标准是利益相关者或用户关心的，它们不可能是相同的。例如，通常不清楚召回率提高 5%或日志丢失率下降会如何影响用户体验，可能会，也可能不会，因此重要的是将其转化为对用户或企业的实际价值(例如转换率、保存的项目数量、执行一项操作所花费的时间、售出的额外座位数量)。在开始之前，尽最大努力就目标成功标准达成一致，否则它可能会在以后移动目标(并且是陷入无休止优化的促成因素)。

许多用户纠结的一个方面是，无论你做什么，模型都会出错——会有一个错误率。一些应用程序，如电影推荐，可能是宽容的，而其他应用程序，如医疗诊断，则具有更高的风险，即使一个错误也可能完全降低用户对模型的信任。确保你和利益相关者明白错误的代价是什么。开发高风险的应用程序会增加失败的几率，但这并不意味着应该避免失败。相反，尝试通过将问题分解成更简单的部分来重新构建问题，这样输出可能是部分正确的，或者即使有错误也仍然提供一些有价值的东西。

把错误率放在现状的背景下也是有用的。有时候，人们倾向于低估他们现在所做的任何事情中的错误，你向他们暴露了一直存在但从未量化的错误。不管是好是坏，现在它们与你的模型联系在一起了。无论您是考虑到一个否则不可能实现的功能，还是自动化以前的手动任务，如果您可以表明某些方面已经改进，即使它并不完美(例如，与人类相似的准确性，但快得多)，您就不需要太担心模型错误。

一旦你确定这是一个重要的问题，有了一个已知的成功标准，你就可以提出一个解决方案。这个解决方案就像一个假设，会做出很多假设:

• 你有数据/资源
• 你知道如何将问题模型化并建立一个足够好的系统
• 这个系统将会扩展
• 这在技术上是可行的，而且公司现在也负担得起

为了给你的利益相关者设定正确的期望，分解问题是很重要的，解释为什么和哪些部分是困难的(不要太专业)，假设在哪里，风险和限制可能在哪里。

这些假设中的每一个都将在项目的下一阶段得到测试和验证，但是每一个都将不可避免地在某些方面出错。这完全没问题，并期望遵循你的直觉，并作出简化的假设。实验项目通常试图解决一个困难的问题，通常在你试图解决的问题开始时没有很好的理解。随着事情的拖延，不熟悉这个过程的人很容易失去热情或信心。你需要成为项目的冠军，相信它会起作用并带来价值，并在接下来的阶段全程指导它。

数据收集

有了问题和建议的解决方案，您需要确定您是否有数据资源来构建它。关于数据收集已经写了很多有用的建议，所以我就简单说一下。这是大多数项目很快遇到问题的地方。

每一个数据产品都依赖于可用的、干净的和可靠的数据来构建，而这几乎是不可能的。数据确实是丢失的、有噪声的和不可靠的。任何机器学习项目的大量时间都将花费在聚集和清理数据上。这通常也是最大性能提升的来源。清理和准备数据并不在问题之外，在很大程度上，这才是问题所在。

这里经常需要根据可用的数据来迭代和重构用户问题。请注意，我们并不是从检查我们的数据并询问我们可以用它来解决什么问题开始，而是一旦我们手头有了问题，我们有什么数据可以用来解决它。当你理解你的数据的局限性，并重新定义问题时，向利益相关者保证这不会从根本上改变价值是很重要的。

在大多数情况下，数据可能部分可用，但不完整，或者结构不良，因为它不是在您的解决方案中收集的。在其他情况下，数据可能根本不存在，您必须收集数据。这包括在野外找到它，自动收集它(从用户或您的应用程序外部)，手动创建它，或众包。如果数据需要作为具有某种形式的不存在的类标签的训练集，这包括自动引导标签或手动标注。

在这一点上，较小的样本量和一些噪声是没问题的。试着收集足够多的数据，这些数据有一定的代表性，但不会成为负担，并且足够干净，这样就不会有明显的错误。除此之外，现在花太多时间在这里会有收益递减。

作为跑步主题，不要过早优化。无论你在这里花多少时间，你都可以花更多的时间。只是在进入其他阶段之前，你不应该在这里花太多时间，因为你知道你将使用这些数据。我见过双方都不顺利。一方面，太少或杂乱的数据被带入原型，结果证明不具有代表性。另一方面，在得到一个原型之前，大量的时间花费在收集和等待越来越多的数据上。在前一种情况下，您可以返回并在现有模型中包含更多数据，并立即衡量改进。在后一种情况下，谁知道在什么时候这就足够了。

在这一点上，您应该提前考虑是否可以创建健壮的数据管道，并在需要时监控数据质量，但是不要担心实际上是否会这样做(我们稍后会担心这一点)。

样机研究

这个阶段是实验性开发过程的必要性的主要原因。按照固定的时间表进行实验几乎是不可能的；可能需要一天来训练模型，意识到它不起作用，实现新功能，获得新数据，重新训练，重复…在意识到它不起作用之前需要一周或一个月。

这导致了实验和在路线图上或在内部按计划交付特性之间的自然和不可避免的冲突。追踪兔子洞很容易:尝试新数据、新模型、新特性、新架构等。它让你感到忙碌和富有成效，但你可能实际上并没有完成多少。在没有明确的用户问题或良好定义的成功标准的情况下尤其如此。最重要的目标是尽快达到你知道如何解决问题或者意识到你不能解决问题的程度。

过程的挑战是创造一种*衡:在确定你何时进入一个没有产出的兔子洞的同时，为探索创造空间。

你需要一个机制来设定目标，并在一个小的时间范围内监控你的进展，通常是每周一次。您可以创建一个按优先顺序排列的实验路线图，在内部记录结果，并经常向适当的利益相关者报告成功标准的性能变化，以验证如何继续进行。每周你都应该更新你对成功可能性的直觉，用证据表明你要么前进，要么停滞不前。

一个很好的论坛是正在进行的项目的演示，中间结果显示进展。在这里感到不舒服是很自然的，因为你知道这些早期的原型并不完美，你可能仍然有许多未解决的问题，但好处是创建了一个迫使项目达到中间完成点的功能，思考设计和 UX，在早期获得利益相关者的反馈并改变方向，最后，创造对可能性和进展感的兴奋。如果你等到所有的事情都整理好了才与利益相关者分享，你已经为失败做好了准备。

构建简单、可工作的原型并在外部共享是一种很好的方式，可以消除项目风险，确保核心价值，激发潜在价值，尽早暴露问题，增加认同，并保持势头。

我想强调尽早考虑 UX 和设计的重要性。你可能会看到一个带有一些例子或混淆矩阵的终端输出，并想象几个假设的显示(图表、列表、百分比、数字等)。).因为你知道它们的信息内容是同构的，所以如何可视化对你来说并不重要。您的利益相关者可能无法完成同样的转换。他们会被具体的例子和展示方式所吸引。这将限制更广泛的信息，使他们看不到产出的潜在价值。

作为正在进行的演示的一部分，不要仅仅展示终端输出；提供几个例子和模拟输出的变化。例如，一些人喜欢看数字(主要是你)，一些人喜欢看视觉效果(你仍然需要做认知工作)，而一些人只是想要直接给他们的洞察力。几乎没有人知道如何处理一个概率。

通常，一个好的起点是将输出浓缩成非常简单的东西，比如评级或标签。令人惊讶的是(但不是真的),大多数人不像我们一样喜欢看数字。这可能会改变您对问题建模的方式，或者只是改变输出呈现给用户的方式。

您很少不能相当快地构建出至少一个工作得不错的简单解决方案(至少作为基线)。在实践中，我发现在这之后陷入兔子洞的可能性很高，因为你过早地开始优化，试图改善评估指标性能，而不知道当前的解决方案对于用户成功标准是否足够好。我知道你可以做得更好，但这是一个很好的理由，让你的解决方案迅速呈现在人们面前，这样你就有东西可以交付，即使你在努力改进它。

其中很重要的一部分是，它是否能达到所需的质量水*。不管解决方案有多简单或复杂，不管是基于规则的还是深度学习的模型，大多数解决方案都会有所作为。我发现这在概念上是人们的一个主要症结，尤其是那些习惯于传统软件工程的人，在传统软件工程中，更明显的是验证功能是否按预期工作(软件运行或不运行)。

从某种意义上说，这个模型是可行的，因为它会给出一个预测，或者一个建议，或者一些结果。问题是评估结果集对于解决用户问题是否可接受。请注意，这并不等同于提高您的模型评估指标的性能，除非它们碰巧是相同的(这是非常不可能的)。这就是为什么有一个既定的成功标准和评估工具来衡量绩效是如此重要。

如果您不知道您的评估指标如何影响您的用户成功(您可能不知道)，您就没有办法确定正确的召回-精度权衡，或者日志损失或准确性阈值，并且您可以愉快地继续迭代和判断它是否足够好。

尤其是在实验评估与用户指标关系不确定的时候，你需要尽可能保持解决方案的简单，这样你就可以更快地把它提供给最终用户，并开始测试这种关系。

因此，您一直在努力，但算法并不奏效，或者尽管实验指标趋于稳定，但您可能无法实现满足用户需求的性能，或者数据并不像您认为的那样具有代表性，或者突破就在眼前，或者这只是一个不正确的问题。

你如何知道何时停止寻求一个没有结果的解决方案？这是这个过程中最难的部分之一；没有好的答案，所以这应该随着你的边做边学而不断迭代(说实话，我还不知道有谁做到了)。因为它也是最不稳定的，它需要仔细的关注和执行(让关心这个问题的利益相关者对你负责是一个好的开始)。

一个自然的时间是在建议的一系列实验和直觉已经用尽之后，成功的可能性似乎很低。在这里，你要评估继续(包括你没有解决的其他问题)的机会成本和成功的收益。

对解决方案的探索通常会导致问题的修改——你会意识到你不能很好地解决最初提出的问题，但可以解决一个密切相关的问题。因为你不知道你最终要解决哪个问题，所以你不应该过早地优化第一个解决方案:它不应该按比例构建，模型也不需要优化。在这一点上，你需要为迭代概念验证原型进行优化。

也就是说，虽然不是为可伸缩性而构建，但你应该提前考虑可伸缩性，并且找到最简单的算法，在大规模下运行。

从一开始就有增加复杂性的自然愿望，尝试最新的算法或包，打破以前的一切，或构建一些新颖的东西，但请记住，你是为自己做这些，用户不关心你如何做，只要它能工作。最重要的一点是要有一个可以用来收集反馈的功能系统。例如，线性模型在开始时可能工作得很好，您可以在以后根据需要增加算法的复杂性。越简单越好。

解决方案越复杂，启动所需的资源(计算、工程、维护)就越多，出错的地方也就越多。如果你从复杂的东西开始，你可能在原型上花费了太多的时间，降低了部署成功的可能性，所以在技术转移失败后，你可能会回到原型上。你也不需要自己构建所有的东西。使用现有的开源工具通常能让你达到目的。现在你可以把节省下来的时间用来为自己解决那个难题:)。

技术转让

一旦你建立并验证了一个功能系统，剩下的主要问题就是生产模型。

这通常是我们的术语给我们带来麻烦的地方——你说你已经“完成”了原型设计，涉众很容易听到“已经准备好了”,或者假设因为你已经消除了许多不确定性和未知性，问题变得更接*于软件工程，现在应该很容易或很快。

尽管经历了前几个阶段的不确定性，发现如何生产解决方案同样困难，如果不是更困难的话。

原型不能成功转移到生产中有许多原因。一个是缩放。在你的 Jupyter 笔记本上让一些东西足够有效地离线工作是一回事，在那里你从多个来源提取并连接数据以形成一个更小的数据集。在生产中实时做同样的事情，同时合并来自多个来源的不断变化的数据流是另一个问题。由于特征计算的计算复杂性或算法的复杂性，在更多的数据上它可能在计算上不可行。或者对数据是如何进来的或者它包含什么做出了某些假设，这些假设在生产中不成立，并且需要在数据管道上进行大量投资，以验证、标准化、合并和提供您需要的所有数据。

因此，生产化通常需要简化和优化模型，并使其足够健壮和容错，以满足生产中所需的服务级别协议和服务质量。它还需要成本高昂或难以维护的基础设施，以及来自工程团队的资源分配，以进行集成，从而在产品路线图上进行集成。

随着对产品和工程以及业务中其他地方所需资源的不断需求，通常具有更直接或更具体的商业价值，早期调整对于成功的技术转让是绝对必要的，尽管这还不够。

一个相关的问题有点循环，因为你经常需要证明一个解决方案将带来的价值，以便为生产优先考虑它，但是你需要部署一个解决方案，甚至可能迭代它来收集数据以显示它的价值。与原型类似，生产交付机制越简单，就越有可能成功集成。换句话说，价值的举证责任与交付成本相关，当价值不确定时，有一个损失成本的交付增加了开发的可能性。

降低交付成本的最简单方法是降低您的计算需求。在建立模型的过程中，我们有一种自然的倾向，即尽可能建立最好的模型——引入更多的数据，生成更多的特征，组合更多的算法。这是相反的练习。您是否需要合并多个数据流，或者仅用一个数据流就能满足用户指标？需要在线运行，还是一天一次批量计算就够了？即使当你在计算上投入了足够的钱，你的模型或特征计算是*凡的并行化，它也是值得简化的，原因我们将在下面讨论。

你也可以从提供商业运作的内部工具或者狗粮功能开始。由于这些通常可以通过简单的交付机制来完成，如传递 csv 或笔记本，并且不需要像面向用户的产品功能一样完善，因此这是一种在不涉及许多其他组织资源的情况下建立价值的好方法。您也可以尝试利用现有的交付机制，如 Elasticsearch，或任何您已经使用的搜索引擎，将您的输出编入其中，从而允许它与现有数据一起立即提供。

最后，争取可重复的交付过程。首先，这些特性的部署可能是一次性的或临时的，您可以创建一个服务或库，并定制管道。不仅每一个都要花费大量的时间，而且随着你启动其中的几个，维护成本将开始增加，数据管道将变得繁琐。当您通过几个成功案例在您的组织内建立势头时，您应该开始考虑如何创建一个更强大的工程管道来交付这些功能，从而允许您插入新模型并使它们相对容易地可用。最终你的目标将是重用和链接你的工作的能力。通过缓存某些数据或模型工件，创建公共特性存储，并拥有健壮的 API，您不仅能够更可靠地交付到产品中，而且能够更好地完成新项目的数据收集和原型制作的早期阶段(谁不喜欢复合回报呢？).

生产的一个有时被忽视的非技术方面是支持走向市场的努力。即使涉及的变更管理很少，也需要对用户群进行培训。到目前为止，利益相关者希望知道没有机器学习解决方案是完美的，但用户可能不是，最终你的成功取决于他们。如果他们没有发现一个有价值的特性，即使涉众发现了，这仍然是一个失败(对于一个内部工具，涉众可能只是你的用户的一个子集，对于一个产品特性，内部涉众不是用户)。

用户可能不需要知道或理解内部工作方式、错误率等。以及内部利益相关者，但你可以肯定他们会有问题。您可能不直接负责处理这些问题，但是为那些负责的人提供资源确实非常有用，可以确保用户期望设置正确，并且对特性功能的误解和误解最小化('他们认为这做了什么？‘听着耳熟吗？).您可以通过为用户编写内容来提供帮助，因为您可能会得到同一个问题的大部分内容，即 FAQ。**

监视

我们已经把它投入生产了，我们做得对吗？！不完全是。现在你需要监控你的模型的性能，并根据需要进行更新。如果做不到这一点，我会想起刘易斯·卡罗尔的名言——“在这里，我们必须尽可能跑得快，只是为了留在原地。”如果你不更新你的模型，它最终会变得陈旧，当它更新时，依赖它的用户会开始注意到有问题，它的价值会下降。

这个阶段是构建一个简单的解决方案并快速部署它的关键合作伙伴。在一个解决方案被生产之前，需要有一个关于如何监控和维护结果质量的计划，如何更新模型，以及从用户那里收集关于系统性能的反馈，以查看它产生了什么影响，以及它是否实现了预期的用户价值。

不管你的训练和测试数据是多么有代表性和精心构建的，一旦实时数据流动，你就会发现新的问题(你没有在数据收集上花太多时间，对吗？).希望你的模型能够容忍大多数错误，但是就像软件中的任何错误一样，当它们发生时，你需要注意。您最初建模的底层数据分布也可能会随时间漂移，导致您的模型以比彻底失败更微妙的方式出现问题。

您可以通过收集新数据、更新训练集和测试集以及定期重新训练模型来解决这些问题。机器学习功能需要反馈循环来提高我们对用户、数据和解决方案质量的理解。首先，您可以有一个简单的反馈循环，收集数据，然后用于手动重新触发再训练，以更新模型的单个版本。只要你能向涉众和用户清晰地表达出如何维护模型的计划，那就很好。

最终，当您理解了重新计算的必要时间表时，您可能希望模型在线更新，或者维护所有内容的版本—模型、训练和测试集—以获得可再现性和在出错时回滚的能力。其中每一个都引入了进一步的工程复杂性，除非必要，否则应该避免。但是随着您的成熟和创建更加健壮的管道，版本控制和监控将成为不可或缺的一部分。

结束语

机器学习和其他人工智能技术非常强大，当一切正常时，你可以利用它们产生巨大的影响。作为一名研究人员，探索困难的问题和算法很有趣，但要让人工智能解决方案变得有用，除了建立一个优化良好的模型之外，还有很多事情要做。你已经注意到了主题:经常与人交谈，并真正确保你们相互理解，提前计划下一阶段的要求，这样你就不会对它们感到惊讶，但不要过早陷入困境，尽可能长时间地让所有技术上的事情尽可能简单。

尽管有最好的计划，你和我仍然会失败？).没有一个过程能把你从这种困境中拯救出来，但是通过一些结构来帮助你浏览常见的陷阱，至少你可以学会减少它们。一旦你完成了几个项目，它就会变得越来越自然，一旦实验性的工作开始成为你的组织文化的一部分(文化是什么，除了一套共享的仪式？)，那你就真的会飞了。

进一步阅读

[1] Domino Data Labs 管理数据科学 ( Strata 讲座，博客 )
涵盖大量挑战并呈现类似生命周期的优秀指南。

[2] IBM 的 CRISP-DM

[3] 管理数据科学的科学

[4] 生产 ML 系统的挑战

[5] 人工智能需求层次

[6] 管理 DS 是不一样的

[7] 关于 DS 管理的思考

[8] 人工智能启动指南

【9】DS 工作流程

[10] 机器学习模型开发的最佳实践方法

[11] 数据科学过程被重新发现

[12] 构建有价值的数据科学项目

[13] 数据科学中最难的事情:政治

[15] 数据科学敏捷周期

[16] 敏捷数据科学的最佳技巧

[17] 构建数据产品，进化数据产品

建议，批评，笑话？我很想听听。任何你认为有用的额外阅读，让我知道，我会添加它们。

下腰痛的探索性数据分析

原文：https://towardsdatascience.com/an-exploratory-data-analysis-on-lower-back-pain-6283d0b0123?source=collection_archive---------6-----------------------

Image collected from https://unsplash.com/photos/XNRHhomhRU4

腰痛 ，也叫腰痛，不是一种病症。这是几种不同类型的医学问题的症状。它通常由下背部的一个或多个部位的问题引起，例如:

• 韧带
• 肌肉
• 神经紧张
• 构成脊柱的骨结构，称为椎体或椎骨

腰部疼痛也可能是由于附*器官(如肾脏)的问题引起的。

在这个 EDA 中，我将使用下背部疼痛症状数据集并尝试找出该数据集的有趣见解。我们开始吧！

数据集描述

数据集包含:

• 310 观察结果
• 12 特征
• 1 标签

导入必要的包:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inlineimport seaborn as sns
sns.set()
from sklearn.preprocessing import MinMaxScaler, StandardScaler, LabelEncoder
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from xgboost import XGBClassifier, plot_importance
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score,confusion_matrix

读取.csv文件:

dataset = pd.read_csv("../input/Dataset_spine.csv")

查看数据集中的前 5 行:

dataset.head() # this will return top 5 rows 

移除虚拟列:

# This command will remove the last column from our dataset.
del dataset["Unnamed: 13"]

数据集摘要:

DataFrame.describe() 方法生成描述性统计数据，这些统计数据总结了数据集分布的集中趋势、离散度和形状，不包括NaN值。这个方法告诉我们关于数据集的很多事情。重要的一点是describe()方法只处理数值。它不适用于任何分类值。

现在，让我们来理解由describe()方法生成的统计数据:

• count告诉我们一个特征中的NoN-empty行数。
• mean告诉我们该特征的*均值。
• std告诉我们该特征的标准偏差值。
• min告诉我们该特性的最小值。
• 25%、50%和75%是每个特征的百分位数/四分位数。这种四分位数信息有助于我们发现异常值。
• max告诉我们该特性的最大值。

dataset.describe()

dataset.describe() method output

重命名列以增加可读性:

dataset.rename(columns = {
    "Col1" : "pelvic_incidence", 
    "Col2" : "pelvic_tilt",
    "Col3" : "lumbar_lordosis_angle",
    "Col4" : "sacral_slope", 
    "Col5" : "pelvic_radius",
    "Col6" : "degree_spondylolisthesis", 
    "Col7" : "pelvic_slope",
    "Col8" : "direct_tilt",
    "Col9" : "thoracic_slope", 
    "Col10" :"cervical_tilt", 
    "Col11" : "sacrum_angle",
    "Col12" : "scoliosis_slope", 
    "Class_att" : "class"}, inplace=True)

DataFrame.info() 打印关于数据帧的信息，包括index dtype 和columndtype、non-null值和内存使用情况。我们可以使用info()来知道一个数据集是否包含任何缺失值。

dataset.info()

可视化异常和正常情况的数量:

abnormal病例的趋势比normal病例高 2 倍。

dataset["class"].value_counts().sort_index().plot.bar()

class distribution

检查功能之间的相关性:

相关系数 是某种相关性的数值度量，表示两个变量之间的统计关系。

dataset.corr()

可视化与热图的关联:

plt.subplots(figsize=(12,8))
sns.heatmap(dataset.corr())

correlation between features

自定义相关图:

一个对图允许我们看到单个变量的分布和两个变量之间的关系。

sns.pairplot(dataset, hue="class")

在下图中，很多事情都在发生。让我们试着理解结对情节。在结对情节中，我们主要需要了解两件事。一个是特征的分布，另一个是一个特征与所有其他特征之间的关系。如果我们看对角线，我们可以看到每个特征的分布。让我们考虑一下first row X first column，这条对角线向我们展示了pelvic_incidence的分布。同样，如果我们观察second row X second column对角线，我们可以看到pelvic_tilt的分布。除对角线以外的所有单元格都显示了一个要素与另一个要素之间的关系。让我们考虑一下first row X second column，这里我们可以说明pelvic_incidence和pelvic_tilt之间的关系。

custom correlogram

使用直方图可视化要素:

一个直方图 是显示频率分布最常用的图形。

dataset.hist(figsize=(15,12),bins = 20, color="#007959AA")
plt.title("Features Distribution")
plt.show()

features histogram

检测和移除异常值

plt.subplots(figsize=(15,6))
dataset.boxplot(patch_artist=True, sym=”k.”)
plt.xticks(rotation=90)

Detect outliers using boxplot

移除异常值:

# we use tukey method to remove outliers.
# whiskers are set at 1.5 times Interquartile Range (IQR)def  remove_outlier(feature):
    first_q = np.percentile(X[feature], 25)
    third_q = np.percentile(X[feature], 75)
    IQR = third_q - first_q
    IQR *= 1.5 minimum = first_q - IQR # the acceptable minimum value
    maximum = third_q + IQR # the acceptable maximum value

    mean = X[feature].mean() """
    # any value beyond the acceptance range are considered
    as outliers.    # we replace the outliers with the mean value of that 
      feature.
    """ X.loc[X[feature] < minimum, feature] = mean 
    X.loc[X[feature] > maximum, feature] = mean # taking all the columns except the last one
# last column is the labelX = dataset.iloc[:, :-1]for i in range(len(X.columns)): 
        remove_outlier(X.columns[i])

移除异常值后:

features distribution after removing outliers

特征缩放:

特征缩放尽管标准化(或 Z 分数归一化)对于许多机器学习算法来说可能是一个重要的预处理步骤。我们的数据集包含在量级、单位和范围上差异很大的要素。但由于大多数机器学习算法在计算中使用两个数据点之间的欧几里德距离，这将产生一个问题。为了避免这种影响，我们需要将所有的特征放在相同的量级上。这可以通过特征缩放来实现。

scaler = MinMaxScaler()
scaled_data = scaler.fit_transform(X)
scaled_df = pd.DataFrame(data = scaled_data, columns = X.columns)
scaled_df.head()

dataset head after feature scaling

标签编码:

像 XGBoost 这样的算法只能将数值作为它们的预测变量。因此，我们需要编码我们的分类值。来自sklearn.preprocessing包的 LabelEncoder 对值在0和n_classes-1之间的标签进行编码。

label = dataset["class"]encoder = LabelEncoder()
label = encoder.fit_transform(label)

模型培训和评估:

X = scaled_df
y = labelX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.15, random_state=0)clf_gnb = GaussianNB()
pred_gnb = clf_gnb.fit(X_train, y_train).predict(X_test)
accuracy_score(pred_gnb, y_test)# Out []: 0.8085106382978723clf_svc = SVC(kernel="linear")
pred_svc = clf_svc.fit(X_train, y_train).predict(X_test)
accuracy_score(pred_svc, y_test)# Out []: 0.7872340425531915clf_xgb =  XGBClassifier()
pred_xgb = clf_xgb.fit(X_train, y_train).predict(X_test)
accuracy_score(pred_xgb, y_test)# Out []: 0.8297872340425532

功能重要性:

fig, ax = plt.subplots(figsize=(12, 6))
plot_importance(clf_xgb, ax=ax)

feature importance

边缘地块

边际图允许我们研究两个数字变量之间的关系。中间的图表显示了它们的相关性。

让我们想象一下degree_spondylolisthesis和class之间的关系:

sns.set(style="white", color_codes=True)
sns.jointplot(x=X["degree_spondylolisthesis"], y=label, kind='kde', color="skyblue")

Marginal plot between degree_spondylolisthesis and class

就这些。感谢阅读。😃

完整代码请访问 Kaggle 或 Google Colab 。

如果你喜欢这篇文章，然后给👏鼓掌。编码快乐！

Python 中随机森林的实现和解释

原文：https://towardsdatascience.com/an-implementation-and-explanation-of-the-random-forest-in-python-77bf308a9b76?source=collection_archive---------0-----------------------

(Source)

通过从单个决策树构建来使用和理解随机森林的指南。

幸运的是，有了 Scikit-Learn 这样的库，现在用 Python 实现数百种机器学习算法已经很容易了。它是如此简单，以至于我们经常不需要任何关于模型如何工作的基础知识来使用它。虽然没有必要知道所有的细节，但了解机器学习模型如何在引擎盖下工作仍然是有帮助的。这让我们能够在模型表现不佳时对其进行诊断，或者解释它是如何做出决策的，如果我们想说服他人相信我们的模型，这一点至关重要。

在本文中，我们将看看如何在 Python 中构建和使用随机森林。除了查看代码之外，我们还将尝试了解这个模型是如何工作的。因为随机森林由许多决策树组成，所以我们将从理解单个决策树如何对简单问题进行分类开始。然后，我们将在现实世界的数据科学问题上使用随机森林。本文的完整代码可以从 GitHub 上的 Jupyter 笔记本中获得。

注:本文最初出现在 enlight 上，这是一个社区驱动的开源*台，为那些希望学习机器学习的人提供教程。

理解决策树

决策树是随机森林的构建块，是一种直观的模型。我们可以把决策树想象成一系列关于我们的数据的是/否问题，最终导致一个预测的类(或者在回归情况下的连续值)。这是一个可解释的模型，因为它使分类更像我们所做的:我们对我们所拥有的可用数据进行一系列查询，直到我们做出决定(在理想世界中)。

决策树的技术细节在于如何形成关于数据的问题。在 CART 算法中，通过确定问题(称为节点分裂)来构建决策树，当回答这些问题时，将导致基尼系数杂质的最大减少。这意味着决策树试图通过在特征中查找值来形成包含来自单个类的高比例样本(数据点)的节点，这些值将数据清晰地划分到各个类中。

我们稍后将详细讨论基尼系数杂质，但首先，让我们建立一个决策树，这样我们就可以在高层次上理解它。

简单问题的决策树

我们将从一个非常简单的二进制分类问题开始，如下所示:

The goal is to divide the data points into their respective classes.

我们的数据只有两个特征(预测变量)，x1和x2，6 个数据点——样本——分成 2 个不同的标签。虽然这个问题很简单，但它不是线性可分的，这意味着我们不能通过数据画一条直线来对点进行分类。

然而，我们可以画出一系列的直线，将数据点分成盒子，我们称之为节点。事实上，这就是决策树在训练时所做的事情。实际上，决策树是通过构建许多线性边界而构建的非线性模型。

为了创建一个决策树并在数据上训练(fit)它，我们使用 Scikit-Learn。

在训练过程中，我们为模型提供了特征和标签，因此它可以学习根据特征对点进行分类。(对于这个简单的问题，我们没有测试集，但在测试时，我们只给模型提供特征，并让它对标签进行预测。)

我们可以在训练数据上测试我们的模型的准确性:

我们看到它获得了 100%的准确率，这是我们所期望的，因为我们给了它训练的答案(y)，并且没有限制树的深度。事实证明，这种完全学习训练数据的能力可能是决策树的一个缺点，因为它可能会导致过度拟合，我们将在后面讨论。

可视化决策树

那么，当我们训练决策树时，实际上发生了什么呢？我发现理解决策树的一个有用的方法是可视化它，我们可以使用 Scikit-Learn 函数来实现(详情请查看笔记本或本文)。

Simple decision tree

除了叶节点(彩色终端节点)之外，所有节点都有 5 个部分:

1. 根据某个要素的值询问有关数据的问题。每个问题都有一个对或错的答案来划分节点。基于问题的答案，数据点沿着树向下移动。
2. gini:节点的基尼杂质。随着我们沿着树向下移动，*均加权基尼系数减少。
3. samples:节点中的观察次数。
4. value:每类样本的数量。例如，顶部节点具有类别 0 中的 2 个样本和类别 1 中的 4 个样本。
5. class:节点中点的多数分类。在叶节点的情况下，这是对节点中所有样本的预测。

叶节点没有问题，因为它们是进行最终预测的地方。要对一个新点进行分类，只需沿着树向下移动，使用该点的特征来回答问题，直到到达一个叶节点，其中class是预测。

为了以不同的方式查看决策树，我们可以在原始数据上绘制决策树构建的拆分。

Splits made by the decision tree.

每个分割都是一条线，它根据特征值将数据点分成节点。对于这个简单的问题，没有对最大深度的限制，划分将每个点放在一个节点中，只有相同类别的点。(同样，稍后我们会看到这种对训练数据的完美划分可能不是我们想要的，因为它会导致过度拟合。)

基尼杂质

在这一点上，深入了解基尼系数的概念是有帮助的(数学并不可怕！)节点的 Gini 杂质是节点中随机选择的样本如果被该节点中样本的分布标记，将被错误标记的概率。例如，在顶部(根)节点中，有 44.4%的机会对基于节点中的样本标签随机选择的数据点进行错误分类。我们使用以下等式得出该值:

Gini impurity of a node n.

节点n的基尼不纯度是 1 减去所有类别J(对于二进制分类任务，这是 2)中每个类别p_i的样本分数的*方。这在文字上可能有点混乱，所以让我们算出根节点的 Gini 杂质。

Gini Impurity of the root node

在每一个节点，决策树在特征中搜索导致基尼系数杂质最大减少的值。(分裂节点的另一种选择是使用信息增益，一个相关的概念)。

然后，它在贪婪的递归过程中重复该分裂过程，直到它达到最大深度，或者每个节点仅包含来自一个类的样本。每一级别的加权基尼系数都必须降低。在树的第二层，总加权基尼系数为 0.333:

(每个节点的 Gini 杂质由该节点中来自父节点的分数加权。)您可以继续计算每个节点的基尼系数(查看答案的图片)。从一些基本的数学中，一个强大的模型出现了！

最终，最后一层的加权总 Gini 杂质变为 0，这意味着每个节点都是完全纯的，并且从该节点中随机选择的点不会被错误分类。虽然这似乎是积极的，但这意味着模型可能会过度拟合，因为节点仅使用训练数据构建。

过度适应:或者为什么一片森林比一棵树更好

你可能会问为什么不仅仅使用一个决策树呢？它似乎是完美的分类器，因为它没有犯任何错误！需要记住的一个关键点是，采油树在训练数据上没有出现错误。我们希望如此，因为我们给了树答案，并且没有限制最大深度(级别数)。机器学习模型的目标是很好地推广到从未见过的新数据。

过度拟合发生在我们有一个非常灵活的模型(该模型具有高容量)时，该模型本质上是通过紧密拟合来记忆训练数据。问题是，模型不仅学习训练数据中的实际关系，还学习存在的任何噪声。一个灵活的模型被称为具有高 方差 ，因为学习到的参数(例如决策树的结构)会随着训练数据而显著变化。

另一方面，不灵活的模型被认为具有高 偏差 ，因为它对训练数据做出假设(它偏向于数据的预先设想的想法。)例如，线性分类器假设数据是线性的，并且不具有拟合非线性关系的灵活性。一个不灵活的模型甚至可能不具备拟合训练数据的能力，并且在两种情况下——高方差和高偏差——该模型都不能很好地推广到新数据。

创建一个如此灵活的模型来记忆训练数据与一个不灵活的模型无法学习训练数据之间的*衡被称为偏差-方差权衡，是机器学习中的一个基本概念。

当我们不限制最大深度时，决策树容易过度拟合的原因是因为它具有无限的灵活性，这意味着它可以保持增长，直到对于每个单独的观察只有一个叶节点，从而对所有的观察进行完美的分类。如果您返回到决策树的图像，并将最大深度限制为 2(只进行一次分割)，则分类不再是 100%正确的。我们减少了决策树的方差，但代价是增加了偏差。

作为限制树的深度的一种替代方法，这减少了方差(好的)并增加了偏差(坏的)，我们可以将许多决策树组合成一个单一的集成模型，称为随机森林。

随机森林

随机森林是由许多决策树组成的模型。这个模型不是简单地*均预测树木(我们可以称之为“森林”)，而是使用了两个关键概念，并因此得名随机:

1. 构建树时对训练数据点进行随机采样
2. 分割结点时考虑的随机要素子集

训练观察值的随机抽样

训练时，随机森林中的每棵树都从数据点的随机样本中学习。使用替换抽取样本，称为自举，这意味着一些样本将在单个树中多次使用。其思想是通过在不同的样本上训练每棵树，尽管每棵树相对于一组特定的训练数据可能具有较高的方差，但总体上，整个森林将具有较低的方差，但不会以增加偏差为代价。

在测试时，通过*均每个决策树的预测来进行预测。这种在不同的数据自举子集上训练每个个体学习者，然后对预测进行*均的过程被称为 bagging ，是 自举聚合 的缩写。

用于分割节点的随机特征子集

随机森林中的另一个主要概念是，在分割每个决策树中的每个节点时，只考虑所有特征的子集。通常，这被设置为sqrt(n_features)用于分类，这意味着如果在每棵树的每个节点有 16 个特征，则只有 4 个随机特征将被考虑用于分裂节点。(也可以考虑每个节点的所有特征来训练随机森林，这在回归中是常见的。这些选项可以在 Scikit-Learn 随机森林实现中控制。

如果你能理解单个决策树、装袋、和随机特征子集的概念，那么你就对随机森林的工作原理有了很好的理解:

随机森林组合了数百或数千棵决策树，根据一组略有不同的观察值训练每棵树，考虑有限数量的特征来分割每棵树中的节点。随机森林的最终预测是通过对每棵树的预测进行*均而得到的。

为了理解为什么随机森林比单一决策树更好，想象以下场景:你必须决定特斯拉的股票是否会上涨，并且你可以接触到十几名事先对该公司一无所知的分析师。每个分析师都有较低的偏见，因为他们没有任何假设，并且可以从新闻报道的数据集中学习。

这似乎是一种理想的情况，但问题是，除了真实的信号之外，报告很可能包含噪声。因为分析师的预测完全基于数据——他们有很高的灵活性——他们会被不相关的信息左右。分析师可能会从同一数据集得出不同的预测。此外，每个分析师都有很高的方差，如果给他们一套不同的训练报告，他们会得出截然不同的预测。

解决方案是不要依赖任何一个人，而是集中每个分析师的投票。此外，像在随机森林中一样，允许每个分析师只访问报告的一部分，并希望噪声信息的影响将被抽样抵消。在现实生活中，我们依赖于多个来源(永远不要相信一个单独的亚马逊评论)，因此，不仅决策树是直观的，而且在随机森林中组合它们的想法也是如此。

实践中的随机森林

接下来，我们将使用 Scikit-Learn 在 Python 中构建一个随机森林。我们不是学习一个简单的问题，而是使用一个分成训练集和测试集的真实数据集。我们使用测试集来评估模型在新数据上的表现，这也让我们可以确定模型过度拟合的程度。

资料组

我们要解决的问题是一个二元分类任务，目标是预测个人的健康状况。这些特征是个人的社会经济和生活方式特征，标签为健康不佳的0和健康良好的1。该数据集由疾病控制和预防中心收集，可在获得。

Sample of Data

一般来说，数据科学项目的 80%都花在清理、探索和创建数据特征上。然而，对于本文，我们将坚持建模。(其他步骤详见本文)。

这是一个不*衡的分类问题，因此准确度不是一个合适的度量。相反，我们将测量曲线 (ROC AUC)下的接收器操作特征面积，这是一个从 0(最差)到 1(最好)的测量值，随机猜测得分为 0.5。我们也可以绘制 ROC 曲线来评估模型。

笔记本包含了决策树和随机森林的实现，但是这里我们只关注随机森林。读入数据后，我们可以实例化并训练一个随机森林，如下所示:

经过几分钟的训练后，模型可以对测试数据进行预测，如下所示:

我们进行类别预测(predict)和预测概率(predict_proba)来计算 ROC AUC。一旦我们有了测试预测，我们就可以计算 ROC AUC。

结果

随机森林的最终测试 ROC AUC 为 0.87 ，相比之下，具有无限最大深度的单一决策树的 ROC AUC 为 0.67 。如果我们查看训练分数，两个模型都达到了 1.0 ROC AUC，这也是预期的，因为我们给了这些模型训练答案，并且没有限制每个树的最大深度。

虽然随机森林过拟合(在训练数据上比在测试数据上做得更好)，但它能够比单个决策树更好地概括测试数据。随机森林具有较低的方差(好),同时保持决策树的低偏差(也是好的)。

我们还可以绘制单一决策树(顶部)和随机森林(底部)的 ROC 曲线。向左上方的曲线是更好的模型:

Decision Tree ROC Curve

Random Forest ROC Curve

随机森林明显优于单决策树。

我们可以采取的模型的另一个诊断措施是绘制测试预测的混淆矩阵(详见笔记本):

这在左上角和右下角显示了模型得到的正确预测，在左下角和右上角显示了模型错过的预测。我们可以使用这样的图来诊断我们的模型，并决定它是否足够好，可以投入生产。

特征重要性

随机森林中的特征重要性表示在该特征上分割的所有节点上基尼系数杂质减少的总和。我们可以用这些来试着找出随机森林认为最重要的预测变量。可以从经过训练的随机森林中提取特征重要性，并将其放入 Pandas 数据帧中，如下所示:

通过告诉我们什么样的变量在类之间是最有辨识力的，特征重要性可以给我们对问题的洞察力。例如，这里的DIFFWALK, 表示患者是否行走困难，这是在问题上下文中有意义的最重要特征。

通过从最重要的要素构建附加要素，要素重要性可用于要素工程。我们也可以通过移除低重要性特征来使用特征重要性进行特征选择。

可视化森林中的树

最后，我们可以想象森林中的一棵决策树。这一次，我们必须限制树的深度，否则它会太大而无法转换成图像。为了制作下图，我将最大深度限制为 6。这仍然会产生一棵我们无法完全解析的大树！然而，考虑到我们对决策树的深入研究，我们掌握了我们的模型是如何工作的。

Single decision tree in random forest.

后续步骤

下一步是优化随机森林，我们可以使用 Scikit-Learn 中的[RandomizedSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.RandomizedSearchCV.html) 通过随机搜索来实现。优化是指在给定数据集上为模型寻找最佳超参数。最佳超参数会因数据集而异，因此我们必须对每个数据集分别执行优化(也称为模型调整)。

我喜欢把模型调整看作是为机器学习算法寻找最佳设置。我们可以在随机森林中优化的示例包括决策树的数量、每个决策树的最大深度、分割每个节点时考虑的最大特征数量以及叶节点中所需的最大数据点数量。

关于随机森林模型优化的随机搜索的实现，请参考 Jupyter 笔记本。

完整的运行示例

下面的代码是用 repl.it 创建的，展示了一个完整的 Python 中随机森林的交互式运行示例。请随意运行并更改代码(加载包可能需要一些时间)。

Complete Python example of random forest.

结论

虽然我们可以在不了解任何东西的情况下用 Python 构建强大的机器学习模型，但我发现了解幕后发生的事情更有效。在本文中，我们不仅用 Python 构建并使用了一个随机森林，而且还从基础开始，加深了对该模型的理解。

我们首先查看了一个单独的决策树，即随机森林的构建块，然后查看了如何通过将数百个决策树组合成一个称为随机森林的集合模型来克服单个决策树的高方差。随机森林使用观察值的随机采样、要素的随机采样和*均预测的概念。

本文中需要理解的关键概念是:

1. 决策树:基于一系列关于特征值的问题做出决策的直观模型。具有导致过度拟合训练数据的低偏差和高方差。
2. 基尼系数:决策树在分割每个节点时试图最小化的一种度量。表示根据样本在节点中的分布，从节点中随机选择的样本被错误分类的概率。
3. Bootstrapping :用替换法对随机观测值集进行抽样。
4. 随机特征子集:当考虑决策树中每个节点的分裂时，选择一组随机特征。
5. 随机森林:由许多决策树组成的集成模型，使用自举、随机特征子集和*均投票进行预测。这是一个装袋合奏的例子。
6. 偏差-方差权衡:机器学习中的一个核心问题，描述了一个具有高灵活性(高方差)的模型和一个不灵活的模型(高偏差)之间的*衡，前者可以很好地学习训练数据，但代价是不能推广到新数据，后者不能学习训练数据。随机森林减少了单个决策树的方差，从而对新数据进行更好的预测。

希望这篇文章已经给了您开始在您的项目中使用 random forest 所需的信心和理解。随机森林是一个强大的机器学习模型，但这不应该阻止我们了解它是如何工作的。我们对一个模型了解得越多，我们就越有能力有效地使用它，并解释它是如何做出预测的。

一如既往，我欢迎评论、反馈和建设性的批评。可以在推特上找到我。本文最初发表在研究机器学习的开源社区 enlight 上。我要感谢 enlight 和 repl.it 在文章中提供代码。

使用 NumPy 和 Google Sheets 的 Word2Vec 实现指南

原文：https://towardsdatascience.com/an-implementation-guide-to-word2vec-using-numpy-and-google-sheets-13445eebd281?source=collection_archive---------1-----------------------

了解 Word2Vec 的内部工作原理

本文是使用 NumPy 和 Google Sheets 实现 Word2Vec 的指南。如果你读这篇文章有困难，可以考虑在这里订阅中级会员！

Word2Vec 被誉为自然语言处理(NLP)领域最大、最新的突破之一。这个概念简单、优雅且(相对)容易掌握。快速的谷歌搜索会返回多个关于如何使用标准库的结果，比如 Gensim 和 TensorFlow 。此外，出于好奇，请查看 Tomas Mikolov 使用 C 的原始实现。原文可以在这里找到。

本文的重点是详细介绍 Word2Vec。为此，我使用 NumPy 在 Python 上实现了 Word2Vec(在其他教程的帮助下),还准备了一个 Google 工作表来展示计算。以下是代码和谷歌表单的链接。

Fig. 1 — Step-by-step introduction to Word2Vec. Presented in code and Google Sheets

直觉

Word2Vec 的目标是为进一步的 NLP 任务生成带有语义的单词的向量表示。每个单词向量通常有几百个维度，并且语料库中的每个唯一单词被分配一个空间向量。例如，单词“happy”可以表示为 4 维向量[0.24，0.45，0.11，0.49],“sad”具有向量[0.88，0.78，0.45，0.91]。

单词到向量的转换也称为 单词嵌入 。之所以要进行这样的转换，是为了让机器学习算法可以对数字(在向量中)而不是单词进行线性代数运算。

要实现 Word2Vec，有两种风格可供选择— 连续词包(CBOW) 或连续跳格(SG) 。简而言之，CBOW 试图从其相邻单词(上下文单词)中猜测输出(目标单词)，而连续跳格从目标单词中猜测上下文单词。实际上，Word2Vec 是基于分布假设的，其中每个单词的上下文都在它附*的单词中。因此，通过查看它的相邻单词，我们可以尝试预测目标单词。

根据 Mikolov 的说法(在这篇文章的中引用)，Skip-gram 和 CBOW 的区别如下:

Skip-gram:*好用的 用 少量的训练数据 ，甚至代表好用的 生僻字 或词组*

CBOW: 数倍于比【skip-gram】精度稍好 为频繁 单词**

更详细地说，由于 Skip-gram 学习从给定单词预测上下文单词，在两个单词(一个不经常出现，另一个更频繁出现)并排放置的情况下，当涉及到最小化损失时，两者将具有相同的处理，因为每个单词将被视为目标单词和上下文单词。与 CBOW 相比，不常用的单词将只是用于预测目标单词的上下文单词集合的一部分。因此，该模型将为不常用的单词分配低概率。

Fig. 2 — Word2Vec — CBOW and skip-gram model architectures. Credit: IDIL

实现进程

在本文中，我们将实现 Skip-gram 架构。为了便于阅读，内容分为以下几个部分:

1. 数据准备 —定义语料库，清理、规范化和分词
2. 超参数 —学习率、时期、窗口大小、嵌入大小
3. 生成训练数据 —构建词汇，对单词进行一次性编码，构建将 id 映射到单词的字典，反之亦然
4. 模型训练 —通过正向传递传递编码的字，计算错误率，使用反向传播调整权重并计算损失
5. 推理 —获取词向量，寻找相似词
6. 进一步改进 —通过跳过 gram 负采样(SGNS)和分层 Softmax 加快训练时间

1.数据准备

首先，我们从以下语料库开始:

自然语言处理和机器学习既有趣又令人兴奋

为了简单起见，我们选择了一个没有标点符号和大写字母的句子。此外，我们没有删除停用词“和”和“是”。

在现实中，文本数据是非结构化的，可能是“脏的”。清理它们将涉及诸如删除停用词、标点符号、将文本转换为小写(实际上取决于您的使用情况)、替换数字等步骤。KDnuggets 有一篇关于这个过程的优秀文章。或者，Gensim 还提供了一个使用[gensim.utils.simple_preprocess](https://radimrehurek.com/gensim/utils.html#gensim.utils.simple_preprocess)执行简单文本预处理的函数，它将文档转换成一系列小写标记，忽略太短或太长的标记。

在预处理之后，我们继续对语料库进行标记。这里，我们在空白上标记我们的语料库，结果是一个单词列表:

【“自然”、“语言”、“处理”、“和”、“机器”、“学习”、“是”、“有趣”、“和”、“令人兴奋”】

2.超参数

在我们进入实际实现之前，让我们定义一些我们稍后需要的超参数。

[window_size]:如上所述，上下文单词是与目标单词相邻的单词。但是这些词应该有多远或多*才能被认为是邻居呢？这就是我们将window_size定义为 2 的地方，这意味着在目标单词左右 2 的单词被认为是上下文单词。参考下面的图 3，注意，当窗口滑动时，语料库中的每个单词都将是目标单词。

FIg. 3 — With a window_size of 2, the target word is highlighted in orange and context words in green

[n]:这是单词嵌入的维度，通常在 100 到 300 之间，取决于你的词汇量。尺寸大小超过 300 往往会使收益递减(参见第 1538 页图 2 (a))。请注意，尺寸也是隐藏层的大小。

[epochs]:这是训练纪元的数目。在每个时期，我们循环所有的训练样本。

[learning_rate]:学习率控制相对于损失梯度的权重调整量。

3.生成培训数据

在这一节中，我们的主要目标是将我们的语料库转换成用于训练 Word2Vec 模型的一次性编码表示。从我们的语料库中，图 4 放大了 10 个窗口(#1 到#10)，如下所示。每个窗口由目标单词及其上下文单词组成，分别以橙色和绿色突出显示。

Fig. 4 — One-hot encoding for each target word and its context words

第一个和最后一个训练窗口中的第一个和最后一个元素的示例如下所示:

# 1【目标( 自然 )】、【上下文(语言、处理)】
【列表()【1，0，0，0，0，0，0，0】
列表(【0，1，0**

**** * * * * * # 2 至#9 删除*******

#10【目标( 精彩 )】、【上下文(趣味、、)【列表()【0，0，0，0，0，0，1】)
列表(**

为了生成一次性训练数据，我们首先初始化word2vec()对象，然后通过传递settings和corpus作为参数，使用对象w2v调用函数generate_training_data。

在函数generate_training_data中，我们执行了以下操作:

1. self.v_count —词汇长度(注意，词汇是指语料库中唯一词的数量)
2. self.words_list —词汇表中的单词列表
3. self.word_index —以词汇中的每个关键字为词，以值为索引的字典
4. self.index_word —字典，每个关键字作为索引，值作为词汇中的单词
5. for循环使用word2onehot函数将每个目标及其上下文单词的一键表示追加到training_data。

4.模特培训

Fig. 5 — Word2Vec — skip-gram network architecture

用我们的training_data，我们现在准备训练我们的模型。训练从w2v.train(training_data)开始，我们传入训练数据并调用函数train。

Word2Vec 模型由两个权重矩阵(w1和w2)组成，出于演示目的，我们已经将值分别初始化为(9x10)和(10x9)的形状。这有助于计算反向传播误差，这将在本文后面讨论。在实际训练中，您应该随机初始化权重(例如使用np.random.uniform())。为此，注释第 9 行和第 10 行，取消第 11 行和第 12 行的注释。

训练—向前传球

接下来，我们开始使用第一个训练示例来训练我们的第一个纪元，方法是将代表目标词的一键向量的w_t传递给forward_pass函数。在forward_pass函数中，我们在w1和w_t之间执行点积以产生h(第 24 行)。然后，我们使用w2和h执行另一个点积来产生输出层u(第 26 行)。最后，我们运行u到 softmax 来强制每个元素在 0 和 1 的范围内，从而在返回预测矢量y_pred、隐藏层h和输出层u之前给出我们预测的概率(第 28 行)。

我附上了一些截图，以显示第一个窗口(#1)中第一个训练样本的计算，其中目标词是“自然”，上下文词是“语言”和“处理”。请随意查看谷歌表单中的公式。

Fig. 6— Calculate hidden layer, output later and softmax

训练——错误、反向传播和损失

误差— 利用y_pred、h和u，我们继续计算这组特定目标和上下文单词的误差。这是通过总结y_pred和w_c中每个上下文单词之间的差异来完成的。

Fig. 7 — Calculating Error — context words are ‘language’ and ‘processing’

反向传播 —接下来，我们使用反向传播函数backprop，通过传入误差EI、隐藏层h和目标词w_t的向量，计算我们需要使用函数backprop改变权重的调整量。

为了更新权重，我们将待调整的权重(dl_dw1和dl_dw2)乘以学习率，然后从当前权重(w1和w2)中减去它。

Fig. 8 — Backpropagation — Calculating delta for W1 and W2

Fig. 9 — Backpropagation — Adjusting weights to get updated W1 and W2

损失 —最后，我们根据损失函数计算每个训练样本完成后的总损失。注意损失函数由两部分组成。第一部分是输出层中所有元素总和的负值(在 softmax 之前)。第二部分获取上下文单词的数量，并乘以输出层中所有元素的和的对数(在指数之后)。

Fig. 10 — Loss function for Word2Vec skip-gram. Credit: https://arxiv.org/pdf/1411.2738.pdf

5.推理

现在我们已经完成了 50 个纪元的训练，两个权重(w1和w2)现在都准备好执行推理。

获取单词的向量

有了一组训练好的权重，我们可以做的第一件事就是查看词汇表中某个单词的单词向量。我们可以简单地通过对照训练的权重来查找单词的索引(w1)来做到这一点。在下面的例子中，我们查找单词“machine”的向量。

**> print(w2v.word_vec("machine"))[ 0.76702922 -0.95673743  0.49207258  0.16240808 -0.4538815  -0.74678226  0.42072706 -0.04147312  0.08947326 -0.24245257]**

查找相似的单词

我们可以做的另一件事是找到相似的单词。即使我们的词汇量很小，我们仍然可以通过计算单词之间的余弦相似度来实现函数vec_sim。

**> w2v.vec_sim("machine", 3)machine 1.0
fun 0.6223490454018772
and 0.5190154215400249**

6。进一步改进

如果你还在读这篇文章，干得好，谢谢你！但这并不是结束。您可能已经注意到，在上面的反向传播步骤中，我们需要调整训练样本中未涉及的所有其他单词的权重。如果你的词汇量很大(例如几万个)，这个过程会花费很长时间。

为了解决这个问题，下面是 Word2Vec 中的两个特性，您可以实现它们来加快速度:

• Skip-gram Negative Sampling(SGNS)有助于加快训练时间，提高生成的单词向量的质量。这是通过训练网络仅修改一小部分权重而不是所有权重来实现的。回想一下上面的例子，我们每隔一个单词更新一次权重，如果 vocab 的大小很大，这将花费很长的时间。使用 SGNS，我们只需要更新目标词和少量(例如 5 到 20 个)随机“负面”词的权重。
• 分级 Softmax 也是另一个加快训练时间的技巧，取代了原来的 Softmax。主要思想是，不需要评估所有的输出节点来获得概率分布，我们只需要评估它的大约 log(以 2 为基数)。它使用二叉树(霍夫曼编码树)表示，其中输出层中的节点表示为树叶，其节点表示为与其子节点的相对概率。

Fig. 11 — Hierarchical Binary Tree — Path from root to W2 is highlighted

除此之外，为什么不尝试调整代码来实现连续词袋(CBOW)架构呢？😃

结论

本文是对 Word2Vec 和 Word 嵌入世界的介绍。同样值得注意的是，有预先训练好的嵌入可用，如 GloVe 、 fastText 和 ELMo 可以直接下载使用。还有 Word2Vec 的扩展比如 Doc2Vec 和最*的 Code2Vec 其中文档和代码被转化为向量。😉

最后，我要感谢任杰谭、莱米和庾信花时间评论和阅读本文的草稿。💪

注:本文首发于我的博客https://derekchia . com/an-implementation-guide-to-word 2 vec-using-numpy-and-Google-sheets/

参考

** [## nathan rooy/word 2 vec-用 python 从头开始

用 Python 从头开始实现了一个非常简单、简单、低效的 skip-gram word2vec

github.com](https://github.com/nathanrooy/word2vec-from-scratch-with-python/blob/master/word2vec.py) [## 用 Python 和 NumPy 从头开始 Word2vec

TL；DR - word2vec 很牛逼，也真的很简单。了解它是如何工作的，并实现您自己的版本。自从加入…

nathanrooy.github.io](https://nathanrooy.github.io/posts/2018-03-22/word2vec-from-scratch-with-python-and-numpy/) [## word2vec 为什么最大化语义相似词之间的余弦相似度

感谢您为交叉验证提供答案！你过去的一些回答不太受欢迎，你…

stats.stackexchange.com](https://stats.stackexchange.com/questions/325053/why-word2vec-maximizes-the-cosine-similarity-between-semantically-similar-words) [## 分层软最大值和负采样:值得讲述的简短笔记

感谢观众对我上一篇(也是唯一一篇)帖子的意外和愉快的关注，这篇帖子是献给…

towardsdatascience.com](/hierarchical-softmax-and-negative-sampling-short-notes-worth-telling-2672010dbe08)**

吴恩达深度学习(deeplearning.ai)专业化的深度回顾

原文：https://towardsdatascience.com/an-in-depth-review-of-andrew-ngs-deeplearning-ai-speciliazation-99612991eb61?source=collection_archive---------2-----------------------

You can find a video version of this article on my YouTube.

所以你已经看到了最*关于人工智能(AI)如何改变一切的新闻。然而，AI 的想法由来已久。几十年来，像人类一样思考和说话的机器一直是电影和故事的灵感来源。

但是交易是什么？为什么这几年 AI 越来越好？

最*繁荣的主要驱动力之一是新技术与可靠的真实想法的融合。进入深度学习。

句子中的深度学习:从信息源中分层提取特征。

这个定义会根据你看的地方而变化，但是现在，它已经足够了。

深度学习利用多层神经网络将信息从输入源抽象到更结构化的输出源。这里的关键词是多层。

The ‘deep’ in deep learning refers to neural networks with multiple internal layers.

神经网络的想法从 20 世纪 40 年代就已经存在了。那么，为什么它们最*才出现如此大的回潮呢？

两个原因。

1.更多数据。
2。更强的计算能力。

对于深度学习系统来说，要从大量信息中收集切实的见解，需要有大量的信息(尽管人们正在积极努力解决这个问题)。世界各地都在通过文本、视频和音频转换成数据。我们在过去 5 年里记录的信息比人类历史上所有的信息都多。

好吧，酷。我们比以往拥有更多的数据。但是我家里有一书架的书，光坐在那里不会让我变得更聪明。我必须读它们来了解里面的内容。

这就是更多计算能力发挥作用的地方。我们的带宽有限。我们只能以一定的速度阅读。一本好书可能需要一个月或更长时间才能看完。

即使有地球上所有的人脑，我们也不可能处理我们收集的所有数据。

计算机来拯救我们！

计算硬件和可访问性的突破使得我们通过深度学习收集的所有额外信息变得比以往任何时候都更容易。使用我们的笔记本电脑，你和我现在可以加载到一个计算机仓库的接入点，所有这一切都可以在我们最喜欢的躺椅上舒适地进行。

突然之间，如果我们有一个大数据集，我们想从中收集见解，我们可以做过去需要 1000 个小时(可能几年)才能睡个好觉的事情(有些事情需要更长一点时间)。

好了，技术概述到此为止。所以你对学习深度学习感兴趣？好吧，这篇文章就是来帮忙的。这是目前你能获得的最好的深度学习课程之一的概述。

说真的，如果你想节省自己的时间，现在就去 Coursera 搜索“深度学习”，选择deep learning . ai specialization并加入其中。

还在吗？太好了。先说为什么。

为什么要报名 deeplearning.ai specialisation？

你可能已经体验过深度学习的一些结果了。也许自己都不知道。

脸书的照片标记系统使用它。它们的面部识别能力和人类一样好。

谷歌的所有(或接*)产品都使用它。

随着时间的推移，你的智能手机可能会使用它的一个版本来提高电池寿命。

优步用它来确保你在正确的时间和正确的司机联系。

但是随着我们关于世界的信息量的增加，深度学习的用例也在增加。

律师用它来找出如何对法律案件做出更好的决定，房地产经纪人用它来更好地给房子定价，医生用它来帮助他们做出更好的诊断。

课程讲师吴恩达将人工智能称为新的电力。

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

目前，人工智能仅限于我们的智能手机和智能扬声器，但很快，它将被注入到我们与之互动的一切事物中。就像现在一样，大部分都在幕后。

deeplearning.ai 专业致力于教你最先进的技术以及如何自己构建它们。

如果你是一名软件开发人员，想要建立深度学习模型，或者你有一点编程经验，想要做同样的事情，那么这门课程就是为你准备的。

如果你只是想了解一些用例，以及它会如何影响你的行业，我会去别处看看。

深度学习和机器学习技能很受欢迎。如果你像我一样，正在寻求职业改变，本课程将帮助你踏上这条道路。

不管你有什么理由。开始前确保你有一个。把它写下来，当学习变得困难时，它会给你一些参考。它会提醒你为什么开始。

你需要从什么开始，你会学到什么？

你已经知道为什么了。你想建立影响世界的技术。或者您希望从您的业务数据中收集更好的见解。或者你想要一份新工作。太好了。这些都是合理的理由。

有理由是第一步。现在，你需要从什么开始？

前提条件是什么？

课程页面列出了编程经验以及数学和机器学习的基础知识作为先决条件。

Python 是这门课程和许多深度学习的首选语言。因此，如果你至少有几个月的 Python 经验，或者对其他编程语言和意识形态有经验，你应该处于一个很好的位置。

至于数学，除了高中，我从来没有上过数学课。如果我需要为这门课学习一些数学，我会去可汗学院。

课程中涉及的一些数学话题(全部链接到可汗学院)。

• 统计和概率
• 多变量微积分
• 线性代数
• 矩阵

在开始课程之前，这些我都没有深入了解。主要讲师吴恩达做了大量的数学解释，足以让你在课堂上开始。对于更深入的内容，你会发现上面的链接很有帮助。

至于机器学习经验，在开始之前，我已经完成了 Coursera 上的 Andrew 的机器学习课程。100%需要吗？不。但它确实对一些概念有帮助。这个课程是免费的，但它是在 Matlab/Octave 中完成的，我发现这有点难，因为我已经习惯了 Python。

总的来说，如果你接受过高中数学教育，并且习惯于用 Python 编写几行函数，那么你已经有足够的东西可以开始了。

所以你准备好开始了。史诗。你实际上会学到什么？

这门课程分为五个部分。每一个都可以单独完成，但我发现它们是对彼此的很好的补充。

每个部分的时间分配在 2-4 周之间不等，建议每周学习 4-5 小时。我通常可以在一天 6-8 小时内完成一周的课程和评估，包括休息时间。也就是说，整个课程花了我大约 4-5 周的时间。

第 1 部分:神经网络和深度学习

本节介绍神经网络和深度学习的概念。有点像这篇文章的介绍，但有实际的代码和更多的深度。

您将从头开始构建自己的神经网络，并了解 Python 的数值库 NumPy。

白手起家是什么意思？

从头开始不需要使用任何框架。想象一个框架是别人写的代码的集合，它使你写的代码更小(更少的行)。一些流行的深度学习框架有 Keras、TensorFlow 和 PyTorch。每当你看到一篇标题为“11 行代码的最佳结果”的文章时，这篇文章可能会用到这些框架中的一个。

同样的 11 行代码在 NumPy/pure Python 中可能会变成 50 多行。第一部分将带您浏览完整的 50 行代码，以了解框架在幕后做了什么。

第 2 部分:改进深度神经网络:超参数调整、正则化和优化

深度学习通常被称为黑盒，意思是，你的模型学习东西，但你不太确定它是如何学习的。

这样做的问题是，如果你的模型不像你希望的那样工作，就很难改进它。

通过第 2 部分，您将了解常见的深度学习花絮，如超参数调整、初始化、优化、小批量梯度下降和正则化。

哇哦。慢点。这些术语是什么？

现在，只要把它们看作是最大限度地利用你的神经网络的方法。

您还将体验到将数据集分成训练集、验证集和测试集的感觉。训练集是你的神经网络学习的地方，验证和测试集是你可以测试你的网络对看不见的数据的鲁棒性。

第 1 部分从 Python 和 NumPy 开始，第 2 部分将向您展示最流行的深度学习库之一 TensorFlow。

好了，现在你知道了如何构建自己的深度神经网络，并且你对自己想要从事的一些项目有了一些想法。但是怎么做呢？第 3 部分支持你。

第 3 部分:构建机器学习项目

这一节很大，不是就长度而言，而是就实用性而言。能够构建机器学习系统是一回事，但能够在它们出现问题时进行诊断并加以改进以供未来使用则是另一回事。

第 3 部分介绍了两个案例研究。你被放在驾驶座上，决定如何使用深度学习系统来解决他们内部的问题。或者如何改进当前的深度学习系统。

我见过一些团队因为不理解本课程中教授的原则而浪费了几个月或几年的时间。—吴恩达

课程二和课程三对于 deeplearning.ai 专业来说是非常独特的。我还没见过很多其他课程像安德鲁那样谈论这些话题。

第 4 部分:卷积神经网络

当谈到计算机视觉时，卷积神经网络(CNN)是蜜蜂的膝盖。

深度学习带来了面部识别方面令人难以置信的进步(还记得脸书的面部识别吗？)，对 x 光报告和自动驾驶汽车系统(如特斯拉的 autopilot)进行分类。

在第一周，你将学习构成卷积神经网络的所有部分，然后进行编程作业，一步一步地构建你自己的模型。

在接下来的三周里，Andrew 将向您展示如何将您在第一周制作的 CNN 带入深度卷积模型(添加更多层)。正是从这里，你将接触到 Keras，一个建立在库 TensorFlow 之上的深度学习框架。

您将练习实现深度 CNN，例如 YOLOv2 算法来检测图像和视频中的对象。你甚至可以上传你自己的图片，我对此很感兴趣。

最后一个项目包括建立一个面部识别系统，只允许微笑的人进入你的家。如果你要举办一个派对，把这个变成现实可能会很方便。

在第 4 部分之后，您现在将知道如何让计算机看到。但是如果你有一堆音频数据呢？文字呢？CNN 可用于此，但序列模型是首选。

第 5 部分:序列模型

你在西班牙。你喝了太多西班牙葡萄酒。现在你需要找到一个浴室，但你不会说一句西班牙语。别担心，你在谷歌翻译中调出你的手机类型“请到洗手间”。你找到离你最*的人，指着你的手机。按下麦克风按钮，你的手机会显示“Bao por favor”。你的新西班牙朋友微笑着指给你看街道。

这整个互动是由葡萄酒和深度学习推动的。谷歌的翻译只是使用深度序列模型的产品的一个例子。

序列模型是一种接受发生在一个时间序列上的任何类型的数据的模型。想想一段时间内的音频波或一个句子中的单词。

您将开始逐步了解递归神经网络，这是一种流行的序列模型。然后你将使用长短期记忆细胞(LTSM 氏)来建立你自己的爵士乐即兴演奏模型。我从来不擅长演奏乐器，但由于深度学习，我能够教计算机为我演奏一首爵士乐独奏。

接下来，您将讨论自然语言处理(NLP)。您将学习如何用数字表示单词，然后如何训练递归神经网络来理解它们。计算机对数字的理解远胜于文字。

最后，Andrew 将带您了解 RNN 在语音识别和触发单词检测中的应用。这两项技术让我们可以说‘嘿，Siri，帮我找一下去最*的咖啡馆的方向。’“嘿，Siri”是触发词，将空气中的声波转化为你的 iPhone 可以理解的东西(一系列数字)的整个过程就是语音识别。

深度学习正在让计算机更好地识别语音和自然语言，但仍有很多改进的空间。与 Alexa 或 Google Home 的任何互动超过几个基本句子和对话就开始中断。这类问题使得 NLP 成为深度学习研究中最令人兴奋的领域之一。

评价

在每周讲座结束时，会有一个测验和与你上周所学内容相关的编程作业。

作业存放在 Jupyter 笔记本上，与课程所在的网页浏览器相同。Jupyter 笔记本是许多不同类型的编码项目的漂亮界面，尤其是数据科学和深度学习。在浏览器中完成评估的一个好处是评分几乎是即时的。你可以直接看到哪里出错了。

每项评估都有一个 80%的门槛。作业或测验不及格？没问题。每 8 小时你有 3 次提交的机会。如果你一直失败，休息一会儿再回来。

我不能分享每个作业中的代码，因为这违反了课程指南。没有代码可以在论坛或其他在线资源上共享。但是，您可以在论坛上使用伪代码(与您的问题类似但不会透露确切细节的代码)提问。

临时演员

对于专业化的前半部分，在每周课程结束时，会对深度学习超级英雄进行采访。安德鲁与 Yann LeCun 和 Geoffrey Hinton 等人坐下来讨论深度学习的现状和该领域的发展方向。这些采访是课程中我最喜欢的部分之一。

从哪里可以学到？

好吧，你知道为什么你想研究深度学习，你会学到什么，但你去哪里找到所有这些美丽的信息？

视频和讲座

所有的视频采访和讲座都可以在 deeplearning.ai YouTube 频道上免费获得。

评估和课程论坛

要访问课程论坛和评估，您需要在 Coursera 上注册。

任何你想去的地方

在线学习的美妙之处在于你可以在任何地方学习。你需要一台能上网的电脑来进行评估，但你可以通过 Coursera 的移动应用程序离线观看视频讲座。

如果你是一个优秀的自学者，在线学习可能对你来说是完美的。我大部分时间都是一个人在寝室学习。但是，如果你更喜欢在一个小组中学习，你可能想说服你的一些朋友和你一起努力深入学习。

你什么时候能学会？

就像网飞一次发布整季一样，当你报名参加课程时，你不必等着获取资料。如果你想的话，你可以在 3 天的马拉松中完成。如果你这样做了，我会印象深刻，但是睡眠确实有助于巩固你所学的东西。

每隔几周就会有新的一批开始。你可以随时开始，但是如果你选择了其中的一天，你将会有全世界的人和你一起学习。这是有帮助的，因为这意味着论坛将会有人在你提问和回答的同时提问和回答。

怎么学？

你已经知道细节了。你知道什么时候开始，你知道你要学什么，现在你该怎么做？

这个没有正确的答案。对我有效的不一定对你有效。

我用特雷罗来追踪我的进度。Trello 是一个免费的应用程序，可以帮助你可视化你的计划。在开始上课之前，我在黑板上画出了课程表。

这是一个示例板的样子。

You can view a public version of the full board here.

在最左边，你会有你需要访问的资源。以下栏目包含您尚未完成的部分课程。

第 2 部分在做栏，因为这是你目前正在做的事情。第一部分被移到完成栏，因为你已经完成了。

Within each part, you have a list of the lectures and assessment items you need to complete and tick them off as you go.

Trello 帮助我想象我已经做了什么和我下一步需要做什么。预产期也有助于我与其他同学保持同步。

你必须遵循时间线吗？

不。你可以想多快就多慢。您将获得评估到期日的更新提醒，但这不是强制性的，它们更多的是为了让您受到鼓励并走上正轨。

从长远来看，我在大约 4-5 周内完成了课程，每周学习 3-4 天，每天学习 6-8 小时。

你如何获得帮助？

很可能你最终会在编程作业中遇到问题。或者也许你想知道更多关于某个话题。当这发生时，论坛是你的朋友。

由于该课程已经推出了几个月，因此有一堆问题已经得到了解答。快速搜索你的问题通常会发现一些学生有类似的问题。

如果你的问题没有得到回答，不要害怕寻求帮助。不管你认为你的问题有多没意义，它仍然是一个问题。过去认为我的问题很愚蠢阻碍了我的学习。现在我意识到，认为你的问题是愚蠢的，是愚蠢的。

当你问一个问题的时候，尽可能的清晰。大声读出来，看看有没有意义。我经常被一个问题困扰，忘记清楚地表达自己，这降低了我被帮助的机会。

这要花多少钱？

你可以在 YouTube 上免费观看所有的课程讲座。但是如果你在 Coursera 上注册完全专业化，费用是每月 64 澳元(约 47 美元)。

完整的专业化建议需要 4-5 个月完成，但因为我完成得更快，我只支付了 2 个月的费用(总共 128 澳元)。

Coursera 经常提供他们专业的 7 天试用期。所以你可以注册，看看这个课程是否适合你，如果不适合，取消你的订阅。

有资格的人可以得到经济资助。要获得这个，你必须在课程报名时申请。

内容的结构是怎样的？

专业化分为五个部分。每一部分都分为 2-4 周的讲座和评估。

讲座时长从 5 分钟到 20 分钟不等，*均每次 10 分钟左右。

我发现我可以用 1.5 倍的速度在 3 小时内听完一周的课。

Andrew 使用 keynote 和画外音来教授内容。他在讲话时经常会在幻灯片上做注解，以进一步阐明观点。我真的很喜欢这种教学风格。

An example lecture slide. The blue writing was annotated alongside Andrew’s voice over.

你如何完成课程？

在每周内容的最后，有一个测验和一个编程作业。一旦你完成了某个部分的所有测验和编程作业，你就可以查看你的竞赛证书了。

完成专业化的所有五个部分意味着你将获得 Coursera 颁发的结业证书。这为你的 LinkedIn 个人资料增添了一个新的亮点。不要害怕分享，你为此付出了努力。

您可以在多长时间内访问这些内容？

无限期。这些讲座在 YouTube 上，我仍然可以在 Coursera 上访问这些讲座，尽管我不再为专业化付费了。

至于评估，我发现在完成一个编程任务后很难回到 Jupyter 笔记本上，所以我确保在工作时下载它们以供将来参考。

摘要

在我学过的所有课程中，这是迄今为止最好的课程之一。Andrew 是一名实践者，他在每堂课中编织他从经验中获得的知识。他参与了这场游戏，所以你知道你所学到的已经付诸实践了。

有时很困难。我遇到了很多障碍。但是有了论坛和互联网，我知道只要我有耐心，我就能解决问题。

我最喜欢的两个部分是第 3 部分和第 5 部分。任何与语言和交流有关的东西都让我着迷，所以第 5 部分是一个真正的亮点。很高兴在第 3 部分听到 Andrew 关于如何从机器学习项目中获得最大收益的内部智慧。

接下来呢？

哇哦。你做到了。恭喜你。你通过了课程。但你总是会的，只是需要一点努力。

一切似乎都很模糊。

“我真的学到什么了吗？”我问我自己当我完成的时候。

这门课程充满了知识。我发现自己在第 5 部分提出的问题在第 2 部分的讲座中得到了回答。但是没关系。我只记得我所学的 1%,所以回顾一些东西有助于在我的大脑中重建更强的联系。

现在我知道，当我遇到深度学习问题时，我可以参考讲座并刷新我的记忆。但我也知道这个领域发展的速度有多快，讲座中的内容可能会过时。这就是补充学习的用武之地。

我发现在完成 deeplearning.ai 专业化的同时完成 Udacity 和 fast.ai 的其他一些深度学习课程非常有帮助。一个过程失败了，另一个过程就开始了，反之亦然。

完成专业化只是新的学习旅程的开始。

无论是将你新发现的技能应用到你自己的项目中，还是用它们来改进现有的项目，都意味着你可能需要不断学习。最终，你会遇到一些你必须自己寻找答案的事情。

如果你做了什么，一定要分享你的作品，写一篇博文，或者制作一个关于它的视频。这样你就可以练习交流你学到的技能，如果你的项目需要改进，其他人可以提供他们的建议。

活着是令人激动的时刻。人工智能被证明是历史上最具影响力的技术之一。深度学习是许多最新进展的一个重要原因，并且可能会有更多进展。

所以，如果你想加入并驾驭社会的潮流，那就去学习吧。或者更好的是，在 Coursera 上注册参加deep learning . ai specialization，获得深度学习。

喜欢你读的书吗？如果你更喜欢视觉效果，我的 YouTube 上有一个视频版本。

我完成了这门课程，作为我自己的人工智能硕士学位的一部分。

彼得·沃斯访谈

原文：https://towardsdatascience.com/an-interview-with-peter-voss-5ada85651ec1?source=collection_archive---------3-----------------------

人工通用智能 (AGI)是一个新兴领域，旨在建造“思考机器”；即智能堪比人脑的通用系统。目前被贴上‘人工智能’标签的很大程度上是狭义的自动化知识工作，缺乏动物智能中所见的灵活性和适应性。对 AGI 的追求始于基础层面，提出关于认知模型、知识获取、通过理性做出选择、以适应性和直觉的方式思考和构想世界的基本问题。

南加州 AGI 研究员彼得·沃斯访谈。

彼得的第一份职业和爱好是电子工程。25 岁时，他创办了自己的第一家公司 Electronic Designs，在 7 年内上市，成为一家拥有 400 名员工的软件/硬件解决方案公司。Peter 设计了该公司的 ERP 套件，包括其第四代数据库和编程语言。在担任首席执行官/董事长期间，以及通过开发和销售 ERP 软件，他获得了财务和管理方面的丰富专业知识。

从公司退休后，Peter 花了几年时间研究与高级人工智能相关的各种主题:这些主题包括认知心理学、心理测量学、认识论、神经网络和计算机科学的其他方面。2002 年，他创办了自适应人工智能公司(a2i2)，这是一家专注于开发 AGI(人工通用智能)的 R&D 公司，2008 年，他分拆出 SmartAction，一家利用 a2i2 智能引擎的商业公司。

在过去的 4 年里，他的重点已经转移回进一步开发智能代理技术。为此，他成立了 AGI 创新公司，这是一家 10 人的技术开发公司，致力于在深度自然语言理解、适应性对话管理和上下文推理方面取得进一步突破。

彼得经常撰写和介绍各种哲学话题，包括理性伦理、自由意志和人造思想；并深深卷入未来主义和激进的生命延续。

https://commons.wikimedia.org

你相信【狭义】“AI”领域正在走向第三个“冬天”吗？

不，一点也不——尽管有“狭义人工智能”的限制，但在许多领域都取得了实际成果，我没有看到整体进展有任何放缓。人工智能会一直存在，而且只会变得更好，成为经济中更大的一部分。

然而，当前人工智能技术的几个关键方面将不会达到预期，并将引起一些投资者的反弹。

特别是，我预计，由于“长尾”问题，像全自动(最后一英里)汽车这样的雄心勃勃的项目将比承诺的时间长得多。其次，大数据、统计方法本身不会提供用户期望的那种自然语言能力——它们没有深刻的理解，记忆非常有限(如果有的话)，不能进行实时、交互式、一次性或无监督的学习，并且它们不能推理或解释它们的信念和行为。

新的方法，如高度集成的认知架构，需要满足这些要求。

‘狭义 AI’大部分是由一些数学结构和张量上的运算组成，用软件驱动模型训练和数据对其进行‘调优’。当你提到“认知架构”时，这些似乎是根本不同类型的机器，你能进一步阐述吗？

是的，认知架构通常涵盖了自主代理的全部需求，包括输入、输出、焦点选择&记忆、学习、推理、目标、元认知。

另一方面，机器学习/深度学习(ML/DL)通常只在相当封闭的环境中提供特定的功能，如对象识别、分类、字幕或优化。专家和其他逻辑系统只执行预定义的计算集合。

这些非认知架构方法的不同之处还在于，有一个(漫长的)培训、编码或设置周期，随后是基本上“只读”的部署——这些系统通常在执行过程中不学习。

然而，应用认知架构本身并不足以实现真正的智能。为了真正有效，认知组件也需要深度整合 -它们需要紧密耦合。知识表征必须充分整合知识和技能，而知识和技能又需要与短时记忆、语境、推理等整合。等等。这个事实被我的理论模型和实际实现经验所证实

大多数认知体系结构是高度模块化和不同的，因此不满足这个关键的需求。

两个主要原因是:a)工程师更喜欢高度模块化的设计，b)各种认知组件是不同计算机科学部门的专业知识表示是一个独立于推理和 NLU 的学科。

你和 AGI 的其他人已经断言‘狭义人工智能’不能进化成 AGI 系统，人工智能社区的其他人正在寻找仅用‘人工智能’就能实现一般智能的‘大方程’，给出足够大量的数据。你为什么认为这是站不住脚的？

狭义人工智能，根据定义，是为解决特定问题而优化的。我不知道有任何方法可以将狭义人工智能结合起来，以概括它们的认知技能——它们没有兼容的架构或知识表示。此外，它们本质上并不是为了提供智能所需的全面集成核心功能而设计的。

你把推进 AGI 的困难归因于什么？(从你的直接经验和总体研究领域来看)为什么从事这方面工作的人相对较少？

从理论/学术的角度来看，很少有广为接受的、可行的类人一般智力理论。事实上，人们更经常听到的是‘我们并不真正知道什么是智能’。除了这个障碍，优秀的软件工程师很少是好的认知心理学家——这是设计真正认知系统的基本要求。第三，商业压力几乎总是更喜欢直接狭隘的设计，而不是更困难、更 AGI 式的方法——它们需要一种罕见的有远见、更长远的观点。

还有其他几个因素阻止了 AGI 得到更多的爱——目前所有这些因素结合起来阻止了深度学习所享受的积极势头。

当然，也有许多困难的技术问题需要克服，但我不认为这些是不可克服的，只要有正确的理论和重点，加上足够的资源。

https://commons.wikimedia.org

你一直专注于用机器对语言进行推理的解决方案。人们认为语言理解是一种相对较高水*的认知技能。在语言层面之下存在着更多的基础认知。在处理语言的水*之下，AGI 目前可展示的能力是什么？

我真的不能代表其他 AGI 系统，但我不知道任何活跃的 AGI 项目在一般的“动物智能”方面取得了有意义的(公开)进展——通常是(虚拟)机器人。和语言一样，几乎所有这样的项目都使用狭隘的人工智能方法。

我们系统的核心功能包括概念学习、知识表示、消歧、推理以及一些模式识别和动作序列。然而，我们目前的目标不是开发语言领域之外的内容。

鼠标级别的感知和敏捷很难；它们需要强大的计算能力和昂贵的尖端机器人技术，或者复杂的、通常不可用的模拟环境。

我们认为 NLP 是通向高级智能的更直接、更可行的途径。

在你与亚当福特 的 访谈中，你说“个人助理”很可能是 AGI 的最初形式，随着技术的进步，它将“做得越来越多”。出于需要，目前大多数“虚拟代理”都在回路中使用人类。你认为人类在 AGI 系统的工作中(在商业解决方案中)有作用吗？

这完全取决于应用程序:对于高价值的礼宾服务，可能是这样的。对于下一代“Siri”，不太可能。

请记住，目前的助手真的很笨:没有记忆或推理，只有浅层解析，没有对话支持等。一旦他们有了一点“大脑”(按照我们的方法)，他们在没有人参与的情况下将会变得更加有用。需要实时人工支持的系统不太容易扩展。

自然，所有的个人助理系统都会有人在后台做 QA 和额外的训练/调整。

您对 NLP 的兴趣是否与实时语音界面密切相关，或者您的工作是否同样对异步消息应用感兴趣？你认为人类在这些形式中会发挥更大的作用吗？

同等地。然而，我想强调的是，实时操作和学习是真正智能行为的绝对要求。能够实时操作的智能系统(即，具有存储器和一些任务管理能力)通常能够异步操作。

另外，我想澄清一下，人在回路中实际上有两种完全不同的形式:

• 一个人(静静地)在后台，检查并潜在地覆盖人工智能
• 人工智能助手的用户，对要执行的全部任务承担(一些)责任。当然，这是“助手”的默认模式——被助手承担最终责任。

https://commons.wikimedia.org

诺姆·乔姆斯基认为我们无法创造出理解语言的机器，因为“我们没有人类语言如何运作的方程式”。你似乎不同意，乔姆斯基缺少什么？

我们不能建造飞行器，因为我们没有鸟类飞行的方程式。也许他不理解'理解'(抱歉这么刻薄，但这确实是一个糟糕的论点)。

在《机器、幽灵和理解的限度》中，乔姆斯基详述了‘理解’的科学史。为了避免陷入这个‘手提箱单词’，让我们将目标陈述改为‘像人一样使用语言的机器’。乔姆斯基的观点是，机器(软件)是基于等式来行动的，而我们没有关于人们如何使用语言的等式，除了表面的方式(单词模式)。你认为对 AGI 和 NLP 的追求是把语言分解成方程式，还是根本不同的东西？

首先，我不认为“方程式”是看待编程的恰当方式。有时术语非算法被用来描述复杂的计算。

其次，正如我之前提到的，要解决 AGI 或 NLP 问题，我们真的需要能够从认知/心理/认识论的角度来看待问题。

理解(上下文)概念的作用是这里的关键。语言理解需要将单词和句子映射到概念，但还需要做更多的工作，包括激活和使用联想、短期和长期记忆、上下文和目标。

认为软件是基于方程的观点，并不比认为人类的认知是基于蛋白质的作用更有用。

你相信人类水*的 AGI 在未来 10 年内是可能的，只要有足够的资源。其他人认为这将需要更长的时间。你已经说过，实现 AGI 不需要“基本的新技术”，而是“巧妙结合现有技术，完善现有算法”。达到人类水*的 AGI 所需要的最重要的里程碑是什么？

• 有一个可行的认知/智力理论
• 构建实现所有必需核心组件的开发框架
• 在适当的实际应用中展示能力(不一定是商业的)
• 迭代更高的认知功能

AGI 开发人员/研究人员如何在系统发展的任何给定阶段测量他们系统的认知能力？

您沿着两个轴进行度量:范围(这里粗略地概括了一下)和能力(它能够处理的复杂程度)。

一个关键要求是两个维度都由一个单一的集成系统服务。此外，系统必须具有可扩展的架构结构和能力，以涵盖所有范围需求和不断增长的能力。

在我们的项目中，我们不断地运行回归测试，以确保当我们扩展系统时，所有先前的功能仍然工作(沿着两个维度)。我们通过系统覆盖更大部分的范围和增加其能力来衡量进展。

例如，实现歧义消除或目标导向行为(新范围)，或提高解析/理解/推理能力，使其能够处理:

“猫是动物”…“猫是动物吗？”

能够理解和回答复杂的问题:

“Verallia 生产玻璃瓶和玻璃瓶，是法国香槟和干邑行业的主要供应商，去年的销售额为 23.9 亿欧元，营业收入为 2.3 亿欧元。”

使用真实世界的文本和对话实例进行测试对于开发实用的 AGI 至关重要。

https://commons.wikimedia.org

假设一个 AGI 不是单一的结构而是不同组件的组合。马文·明斯基认为，人造大脑将由许多系统组成，就像生物大脑一样。你认为 AGI 系统的主要组成部分是什么？

我真的不认为 AGI 是一个“思想的社会”。根据一个人如何划分功能，他可能想要分离输入处理、输出激活、知识和技能编码、推理和元认知。

在我们当前以 NLP 为中心的系统中，解析、共指消解和 NLG (NL 生成)是相对独立的，但这更多是为了开发方便，而不是基础。

事实上，我想强调的是，为了有效的认知，所有的功能都必须高度集成——这是当前认知架构很少能满足的要求。

在今天为数不多的 AGI 研究人员中，大多数似乎都在研究人类水*的智能。为什么不从低于人类水*的一般智力开始呢？蜜蜂有大约 100 万个神经元，相当聪明:它能在三维空间导航，实现目标，交流等等....这(简单得多的智能)难道不是人工认知更合理的起点吗？

我过去正是这么想的:我们 AGI 发展项目的前三年(始于 2002 年)专注于创造动物智能。如上所述，动物级别的感知和灵巧真的很难，而且计算量很大。在机器人和自动驾驶汽车领域，有许多资金充足的团队在研究这些问题(或至少是相关的问题)。

我们只是决定通过 NLP 开发 AGI 是一个更快、更便宜的途径，并且在这个过程中提供了更多的商业化可能性。我们的 NLP/AGI 引擎的早期版本为一家成功的公司 www。SmartAction.ai，我们看到了许多其他以 NLP 为重点的 proto-agi 的可能性。

术语“原始 AGI”是什么意思？

AGI 的早期版本——即一个尚未达到全面的、人类水*的认知能力的系统，但其特定的、固有的架构和设计能够涵盖一般智能的要求。没有一个狭义的 AI 设计满足这些要求。

在“更多的商业化可能性”和对 AGI 的追求之间似乎有一条不确定的界线，前者不可避免地会给捷径和/或性能带来压力。作为一个既生产研究产品又生产商业产品的人，你如何*衡这些力量？

好不容易！

非常重要的一点是，企业的负责人应该理解在商业化过程中积极坚持 AGI 哲学的长期优势。对我们来说幸运的是，我们已经发展到了 AGI 复杂性和功能性的水*，通常商业目标实际上最好通过通用智能机制来实现，例如，教导系统比硬编码特定需求更容易、更好。

随着我们向人类水*的能力迈进，这将变得更加容易——在这里，普遍性压倒性地成为一种资产而不是一种负担: AGI 逃逸速度！

自动驾驶车辆卡尔曼滤波器介绍

原文：https://towardsdatascience.com/an-intro-to-kalman-filters-for-autonomous-vehicles-f43dd2e2004b?source=collection_archive---------3-----------------------

我最*完成了自动驾驶汽车纳米学位项目 的Udacity Term2，我想分享一下我对“卡尔曼滤波器”遇到的一个有趣而又酷的话题的看法。希望这个博客能让你清楚地了解它是什么。享受学习:)

自主车辆由各种设备组成，通过这些设备收集数据并执行动作。下图显示了车辆中使用的几个重要部件的位置。

Components of an Autonomous Vehicle [Image Source]

卡尔曼滤波器使用的数据来自激光雷达和雷达。所以现在我们只关注这两个设备。

为什么要用卡尔曼滤波器？

我们可以使用卡尔曼滤波器做出一个有根据的猜测，在我们对某个动态系统有不确定信息的任何地方，系统下一步会做什么。在自主车辆的情况下，卡尔曼滤波器可以用于基于我们的车辆接收的数据来预测我们的自主车辆前方的车辆将要采取的下一组行动。这是一个使用两步预测和更新的迭代过程。

由于以下因素，它最适合这些类型的操作:

• 它只根据前一个状态预测下一个状态，不需要历史数据
• 计算速度非常快非常适合实时问题
• 即使环境中出现大量噪声/误差/不确定性，使用 高斯分布 ，卡尔曼滤波器也会给出一个好的结果。

我将向您概述所有这些是如何工作的，随后是一个示例，它将帮助您理解背后的数学原理。

卡尔曼滤波器是如何工作的？

卡尔曼滤波是一个迭代过程，遵循两步预测和更新

Flow chart of the Iterative process

预测:

在该步骤中，卡尔曼滤波器从初始值预测新值，然后根据系统中存在的各种过程噪声预测我们预测中的不确定性/误差/方差。

在自动驾驶汽车过程中，噪声可以通过一个简单的例子来理解，即一辆汽车在我们的汽车前面行驶。我们的模型将假设汽车以恒定的速度移动，因为加速度为零，但实际上它会有加速度，即它的速度会不时波动。汽车加速度的这种变化是不确定性/误差/方差，我们利用过程噪声将其引入系统。

更新:

在此步骤中，我们从系统设备中获取实际测量值。在自主车辆情况下，这些设备可以是雷达或激光雷达。然后，我们计算预测值和测量值之间的差值，并通过计算卡尔曼增益来决定保留哪个值，即预测值还是测量值。基于由卡尔曼增益做出的决定，我们计算新的值和新的不确定性/误差/方差。

来自更新步骤的该输出再次被反馈到预测步骤，并且该过程继续，直到预测值和测量值之间的差趋向于转换为零。该计算值将是卡尔曼滤波器进行的预测/有根据的猜测。

卡尔曼增益: 它决定了我们的预测值或测量值是否接*实际值。它的值范围从 0 到 1。如果其值接* 0，则意味着预测值接*实际值，或者如果其值接* 1，则意味着最终测量值接*实际值。其值的范围从 0 到 1，因为它使用了预测值和测量值的不确定性/误差，并由如下所示的简单公式表示。

K =预测误差/(预测误差+测量误差)

卡尔曼滤波器在无人驾驶汽车中的实现

在这方面，我们将根据目前掌握的信息，尝试理解卡尔曼滤波器是如何用于自动驾驶汽车的。

让我们假设一个 2D 环境，其中有一辆汽车和一个行人经过，如下所示:

2D representaion of car and pedestrian [Image Source]

p_x 和 p_y 确定 2D 位置，v_x 和 v_y 确定行人的 2D 速度。这可以表示为 x = (p_x，p_y，v_x，v_y) 。我们必须预测行人的 2D 位置(p _ x’，p _ y’)和 2D 速度(v _ x’，v _ y’)即 x’

由于状态向量仅模拟位置和速度，我们还需要不确定性/噪声，以便模拟加速度，这由过程协方差矩阵 P. 完成

****预测步骤:使用以下公式计算预测值x′和预测误差P′也称为过程协方差矩阵:

x′= f . x+b .μ+ν

p′=fpfᵀ+q

F : 状态转移矩阵

它用于将状态向量矩阵从一种形式转换为另一种形式。即假设车辆的状态由位置 p 和速度 v 给出，并且在时间 t 没有加速。

X = [p，v]

在一个特定时间之后，比如说 t+1，新的状态向量 X’将是

*p ' = p+v δt

v'=v

在矩阵中，这可以显示如下:

x’ = F*x

那么 F 矩阵将由下式给出:

B: 控制输入矩阵

它决定了由于外力(纵向或横向力)和内力(重力、摩擦力等)引起的控制输入矢量 μ 的变化。).在自动驾驶汽车的背景下，我们无法对外力建模，因为它会因地区而异，也无法对内力建模，因为它会因汽车型号的不同而异。所以大多数情况下 B.μ=0。

v: 过程噪音/不确定性

它只是确定系统中可能存在的随机噪声。添加它是为了使预测位准确。

****问:过程噪音/运动噪音

当预测位置时，它给出了物体位置的不确定性。该模型假设时间间隔之间的速度是恒定的，但实际上我们知道物体的速度会因加速度而变化。该模型通过过程噪声包括了这种不确定性。

****更新步骤:快速回顾在更新步骤中，我们执行以下操作:

第一步:求实测值与预测值的差值

第二步:计算卡尔曼增益

步骤 3: 根据卡尔曼增益的结果计算新的 x 和 P 。

现在我们将看到这些步骤的数学实现

第一步:

y = z—h . x′

z: 实测数据

这是来自传感器的实际数据。

H: 状态转移矩阵

和 F 一样，我们用 H 来转换状态向量。但是在这里，我们用它来丢弃状态向量中我们不需要的信息。例如，对于雷达进行的测量，我们只需要关注车辆的位置，而不需要担心速度，因为雷达只擅长确定速度的位置。在这种情况下，对于包含车辆位置和速度的状态向量，H 矩阵为:

第二步:

s =hp′hᵀ+r
k =p′hᵀs⁻

R: 测量噪音

测量噪声是指传感器测量中的不确定性，它意味着设备本身有噪声并且不是 100%精确的，因此这些噪声测量值是由设备本身的制造商提供的，不需要改变。

S: 总误差

它是预测误差加上测量误差的总和。正如我们在上面的卡尔曼增益公式中看到的，我们需要总误差，所以这里用 s 表示。

K: 卡尔曼增益

我们通过前面给出的简单公式来计算卡尔曼增益。唯一的问题是，在矩阵中我们不能除法，所以这里我们取 S⁻。

第三步:

x = x′+k . y
P =(I-KH)P′

最后，我们更新状态向量和协方差矩阵，并继续下一个预测步骤以获得其他值。

卡尔曼滤波器有问题

卡尔曼滤波器中使用所有这些函数都是线性的，因为它们在方程中不包括任何角度参数，因此我们可以将这些线性函数直接馈送给高斯分布，以获得高斯分布均值和方差。但是在现实生活中，大多数问题都是非线性的。由于这个原因，我们不能直接将这个非线性函数提供给高斯分布，因为这将导致非高斯分布，并且我们不能再对其应用卡尔曼滤波器。使用扩展卡尔曼滤波器解决了卡尔曼滤波器中的非线性问题。

你可以通过阅读拉姆齐·法拉格尔的这篇论文来了解更多关于卡尔曼滤波器的知识，这篇论文是基于卡尔曼滤波器，通过简单直观的推导

Scala 简介

原文：https://towardsdatascience.com/an-intro-to-scala-part-1-installation-set-up-and-hello-world-58a076a6818e?source=collection_archive---------13-----------------------

欢迎阅读我的 Scala 系列的第一篇文章。本教程旨在教授 Scala 入门知识，作为学习 Apache Spark 的前奏。

第一部分可以在 Medium 上找到，但是本指南的其余部分可以在 project Github 页面的以下链接中找到:

Scala 简介

Scala 是一种面向对象的函数式编程语言。它与 Java 关系最密切，所以 Java 程序员应该在学习它上有所帮助。然而，Scala 被设计得更加简洁，并且具有函数式编程语言的特性。

Spark 是一个为大数据处理而设计的开源集群计算框架。它是用 Scala 写的。Spark 可以在 Python ( PySpark )和 R ( SparkR 和 sparklyr )中运行；不过，Spark 的最佳性能可以在 Scala 中实现。

其他资源

我将提供一些其他来源作为替代和参考。何塞·波尔蒂利亚的 Udemy 课程非常棒，我的博客系列将大致遵循他的“ Scala 和 Spark for Big Data and Machine Learning”课程的结构。如果你学视频格式比较好，我强烈推荐那个课程。

Twitter 的 Marius Eriksen 发表了“有效的 Scala ”，可以在网上免费获得。这也是一个很好的资源。

如果你有 Python 背景，你也可以看看这本由 Rob Story 撰写的 Python 转 Scala 电子书。它“短小精悍”,是所有 Pythoners 爱好者和 Pythonistas 的快速参考！

就这样，让我们开始吧！

下载 Scala

第一个任务是下载 Scala。诚然，这可能是该过程中最具挑战性的部分之一。你需要经历几个步骤。如果你用的是 Windows 10，我推荐 YouTube 上的以下教程:

如何在 Windows 10 上安装和设置 SBT+Scala

你也可以自己决定是否要安装 SBT，因为还有其他运行 Scala 的选项(比如 IntelliJ )。

如果你使用的是基于 Linux 的操作系统，这里有一个类似的视频。我不能保证这一点，但它是由同一作者。

如何在 Ubuntu 上安装和设置 SBT

最后，这里是一些 Mac 指令。

如何在 Mac 上安装 Scala

虽然我发现安装 Scala 比 Python 或 R 更难，但如果你正在努力，网上有很多资源。好消息是，对大多数人来说，这可能是最具挑战性的部分。

VS Scala 的代码

我们将在早期的练习中使用命令提示符，但是我们最终将需要一个代码编辑器。我推荐 VS 代码，我将带你了解如何下载。

显然，您也可以自由使用其他选项，比如 Atom 或 Sublime。或者，如果你想使用一个完整的 IDE， IntelliJ 是一个不错的选择，并且有一个 Scala 插件适合它。

如果你想使用 VS 代码但还没有，在这里下载。

一旦你的计算机上有了 VS 代码，启动它。在屏幕的左侧，您应该会看到一些图标。这些图标中的一个是各种各样的正方形。如果你悬停在它上面，它应该会显示“扩展”点击那个。

在搜索栏中，输入“Scala”。您应该会看到 Scala 的一些插件选项。转到“Scala (sbt)”安装。下面的截图突出显示了框和正确的插件。

你也可以考虑一些其他的 Scala 插件。我没有对其他插件做太多改动，但是我也下载了 Scala 语法插件。

无论如何，现在你应该已经配置好运行 Scala 文件了。

入门

一旦你安装了所有的东西，你应该能够通过你的命令提示符运行 Scala。如果您成功地按照说明操作，并且正在运行 Windows，您可以打开命令提示符(快捷方式:在“开始”菜单的搜索框中输入“cmd ”)并键入:

spark-shell

这将在本地模式下启动 Spark，这是我们用来学习 Scala 基础知识的。

“Hello World”命令行提示

让我们从简单的 print 语句开始。Scala 的打印语句看起来与 Java 相似，但更简洁一些。

println(“Hello world!”)

瞧啊。现在你已经运行了你的第一个 Scala 程序。

《你好世界》VS 代码

在我们上完几课之前，我们不需要代码编辑器，但是如果你也想确保 Scala 在 VS 代码中正常工作，那么进入 File -> New File。将文件另存为“hello_world.scala”。在文件中输入正确的代码，然后保存。

现在打开你的终端:查看->终端。正如我们在命令提示符中所做的那样，在终端中输入“spark-shell”。要运行该程序，请输入:

:load hello_world.scala

有了这个，你应该得到你的打印输出。

第二部

这就是第 1 部分。第 2 部分介绍了数据类型；在项目 Github repo 查看。

贝叶斯推理导论数学冒险

原文：https://towardsdatascience.com/an-introduction-to-bayesian-inference-a-mathematical-venture-9919a2937f28?source=collection_archive---------8-----------------------

嗨，这是我的第一篇博客文章，所以如果我在写文章时犯了任何错误或错过了任何惯例，请在评论中告诉我。(关于内容的礼貌反馈总是被邀请的:)。

在统计领域，统计学家和数据科学家采用了两种著名的方法来解决现实世界的预测问题，这两种方法被称为频率主义方法和贝叶斯方法。

黄金贝叶斯法则告诉我们:

其中 W 是统计模型的参数，该模型对数据 d 后面的分布进行建模。基于相同的表示，让我们来定义什么是频率主义者和贝叶斯方法？

频率主义方法是一种统计学家认为存在一个参数的真实值，概率是根据频率来定义的方法。遵循贝叶斯方法的统计学家认为，参数没有真实值，但参数本身遵循特定的分布，只有数据是真实的。

在本文中，我们将关注线性回归的贝叶斯版本。那么，现在让我们正确定义贝叶斯推理。

贝叶斯推断是一种方法，其中我们定义了具有某种分布的某些参数的先验。这种分布可以认为相当于我们手中已有的问题知识。使用与我们的问题相关的数据进一步更新该分布，这导致了称为后验分布的新分布。后验分布是我们对问题的先验知识和来自数据集的数据的组合。

但是，当大多数人都在使用频率主义方法时，我们为什么还需要贝叶斯方法呢？这个问题的答案如下:

1. 让我们定义一个参数θ的先验，我们想要计算 P( 99 < θ < 100) 这只能在贝叶斯方法的情况下计算，因为频率主义方法给我们一个点估计。
2. 与频率主义方法相比，贝叶斯方法提供了更多的概括。
3. 贝叶斯方法避免了过度拟合。

等等，那我们为什么不用贝叶斯？，让我们先了解一下贝叶斯方法的缺点。

1. 我们必须假设一个先验，这可能是一个非常费力的过程，因为我们假设的分布可能不接*原始分布。这导致后验估计的扰动。
2. 在一些甚至大多数情况下，后验概率的计算是难以处理的(这是其不受欢迎的主要原因之一)

现在让我们推导出我们最喜欢的线性回归的贝叶斯版本。

让我们先设置问题:

等式 1 表示可观察到的数据集为 xᵢ 和 yᵢ.

Equation 1

Equation 2

如果 W 代表回归模型的权重，而 Y₁、Y₂,…、Yₙ 是由参数 w 给出的独立随机变量，则 Yᵢ可以定义为:

Equation 3. Description of Random Variable Y.

我们的权重(参数)的先验分布由下式给出:

Equation 4. Description of the distribution of W.

其中 C 是协方差矩阵，因为 w 是多元高斯，因为 Xᵢ是 d 维的。

我们希望每个维度上的权重相互正交，因此我们可以将其定义为 b⁻ I，其中 b 是多元精度矩阵。精度只不过是方差的倒数和 b > 0。

因此，我们的权重遵循以下分布:

Equation 5. Refined notation for distribution of W

类似地，我们也可以精确地表示 Y 的分布:

Equation 6. Refined notation for distribution of Y

其中 a⁻ = σ

在贝叶斯推理中，我们估计后验分布 P(W/D ),它由下式给出:

在哪里

P(D/W)是可能性。

P(W)是先验分布。

P(D)就是证据。

现在首先让我们计算最大似然估计(MLE 实际上是一种解决线性回归的常用方法，因为它假设参数有一个给定的真值) :

Equation 7. Computation of MLE estimate of the weights

Equation 8.

Equation 9.

Equation 10.

现在，如果我们将所有项相乘，那么我们可以将乘积转换为指数幂的和，这将更容易处理。

Equation 11

我们现在将把它转换成矢量化符号，因为这样更容易计算梯度。考虑以下变化:

因此，等式 11 中的求和变为:

Equation 12

为了估计等式 12 的最大值，需要找到它对变量 w 的导数。通过最小化ϕ.可以获得相同的结果现在我们来计算ϕ对 w 的导数

Equation 13

∇ϕ称为梯度向量，它包含 w 的每一维的偏导数

当我们设置∇ϕ = 0 时，可以找到等式 13 的最小值。

(xᵗx)⁻ xᵗ被称为伪逆，它非常接* x⁻，因为 x 是一个 n x d 矩阵，因此它是不可逆的。所以，我们不能用等式 14。

Equation 14

让我们通过计算黑森∇ ϕ w.r.t 对 w 的二阶导数来验证这一点

Equation 15

为了使一阶导数成为最小值，Hessian 矩阵应该是半正定矩阵。矩阵 xᵗx 确实是半正定的，因为它本质上是可逆的，并且是其内部元素的*方。因此，我们确信我们已经找到了极小点。

最后，现在我们可以根据权重预测 y 的值，如下所示:

我们已经完成了可能性的计算，让我们继续计算后验分布。

我们知道，使用 P(D/W)和 P(W ),我们可以通过对可能性和先验的乘积进行积分来获得 P(D)。因此，我们可以丢弃来自后验计算的证据，因为它将是一个常数。

这里，左边的指数对应于似然，第二个指数对应于先验(我已经从两个等式中删除了乘数常数，因为它们是正的，不会影响计算。)

Equation 16

我们希望我们的后验概率本质上是多元高斯的。也许通过比较等式 17 和等式 16 的参数，我们可以很容易地估计该高斯函数的参数。

Equation 17

通过比较这些等式，我们得到:

Equation 18

Equation 19

因此，根据等式 19，我们可以获得均值等式:

现在我们有了后验分布的均值和精度(方差),但在得出结论之前，我们需要验证ψ的逆是否存在。

从 MLE 计算中我们知道 xᵗx 是半正定的，现在我们加上 bI，其中 b 是协方差矩阵，因此它默认是半正定的。所以这使得ψ是半正定的，因此是可逆的。

MAP 估计表明它本质上是 MLE 和先验的结合。先验的增加有助于映射 n 避免过度拟合，因此这被称为正则化参数。

最后，我们结束了计算参数的 MAP 估计。现在，我们可以用它来预测任意 x 值的 y 值。在下一篇文章中，我们将讨论朴素贝叶斯算法的贝叶斯版本。我希望这篇文章是有帮助的。

谢谢你。

贝叶斯推理导论——数学冒险(二)

原文：https://towardsdatascience.com/an-introduction-to-bayesian-inference-a-mathematical-venture-part-2-6e66be32c54?source=collection_archive---------21-----------------------

在本文的最后一篇文章中，我们探讨了贝叶斯线性回归模型。在本文中，我们将探索贝叶斯朴素贝叶斯分类任务背后所涉及的数学。

在我们开始之前，我想重复一下在朴素贝叶斯的解决方案的推导过程中采用的最重要的假设，即特征是相互独立的。

首先，我们将设置问题，然后一步一步地复习数学。

分类问题的目标是计算 p(y|x，D ),其中 D 是数据集，x 是数据实例，y 是标签。

设置:

这里，xʲ是有限集合 a 上的 d 维向量，yʲ可以从集合{1，2，…，m}中取值

为了建模我们的数据实例，我们选择随机变量 Xʲ和 Yʲ.

我们在 x 和 y 之间的联合分布可以进一步细分为:

现在我们将逐一定义这些概率分布。

由于 y 是分类性质的，我们必须将 p(y|θ)定义为由θ参数化的分类分布。

其中 V(y)是由每个标签的向量的每个维度上的概率组成的向量。

p(x|y，θ)也将被定义为 d 维分类分布，因为 x 具有 d 维。

这种分类分布将是矩阵 W，其中每行对应不同的 y 值，列对应 x 中的不同特征

其中 W(Xⱼ = xⱼ,Y = y)将代表 p(Xⱼ = xⱼ|Y = y，θ)的概率。

矩阵的行总计为 1，因为它表示完整的分类概率分布。

为了进行贝叶斯分析，我们需要定义联合对{V，wⱼ}的先验，因为它们充当我们分布的参数。

现在，我们将定义参数 V 和 w。简化计算的明智选择将用于共轭。因此，我们将采用狄利克雷分布，因为我们的参数 X，Y 本质上是分类的。

我们的最终目标是根据给定的数据集 D. From Bayes 规则计算新数据点所属的类:

因为我们知道每个观察值都是相互独立的，所以我们可以将 x，y，D 之间的联合分布分成 x，y 和 D，给定θ。

现在，我们可以利用朴素贝叶斯算法的条件独立性假设来进一步拆分公式。

让我们用它们实际的公式来代替这些符号。

在未来，我们知道我们需要将这种分类分布与先验的狄利克雷分布相结合，以获得我们的狄利克雷后验分布。因此，我们想把分类分布写成狄利克雷分布，这样就很容易把它们结合起来。

标准的狄利克雷分布采用以下形式:

Equation 1.

其中，ϕ是 m 维参数向量，α是分布的另一个参数，也是向量，β是β函数，根据等式 1 中的公式，最后，s 是概率单纯形。其中 s 是在ϕ.的这 m 个参数上定义的一组 PMF 你可以探究在这个环节中，一个概率单纯形究竟是什么。

回到我们的问题，我们希望我们的分类分布有一种格式，这样我们可以很容易地把它转换成狄利克雷后验分布。

这些方程看起来很完美，因为我们有类似于狄利克雷先验的基。如果你对这个等式感到有点害怕，请保持冷静，因为我们很快就会很好地利用它。

现在，让我们为我们的先验做同样的事情。

让我们把 P(x，y，d)的各项一个一个相乘，让我们用 p(θ)和 p(xʲ,yⱼ|(θ)).开始

我们知道狄利克雷分布和分类分布是共轭的，因此我们将相应的共轭项组合在一起。

相似的术语已经组合在一起，但是由于不同的产品指数，我们不能直接将它们相乘，因此我们需要稍微改变它们。

Cⱼ基本上是 yⱼ拥有标签 j 的次数

c 现在变成了一个向量，类似于狄利克雷分布中的向量。这使得我们更容易将这两者结合起来，现在剩下要做的就是将它们结合在一起。

让我们对另一对也做同样的事情。

现在一切都设置好了，我们只需要将这些项与 P(x，y|θ)相乘

在哪里

我们可以看到一些漂亮的方程，它们是共轭的结果。

在上面的等式中，我们可以看到第一个括号是分布 V(y)的预期值，第二个括号也有些相同，但让我们更深入地研究一下，因为它可能会让人难以理解。

如果 y 等于第二个括号中的 k，则它成为分布 W 的期望值，但是当 y 不等于 k 时，则指数变为 1，因此，底数变为 1，使其成为仅分布值上的积分，从而将其积分为 1。

所以，我们现在要做的就是把这些项替换成它们的期望值。结果是:

我知道这可能有点脱离网格，但我会尝试在一篇完全不同的文章中添加期望值的计算，因为数学已经变得疯狂了。

最后的等式是:

为了计算这个类，我们需要将数据实例的值代入等式，并找到它的 argmax。

因此，我们成功地推导了几乎所有需要达到这一点的步骤。我希望这至少在某些情况下对你有用。下一篇文章将是关于贝叶斯隐马尔可夫模型，我也将写一篇小文章解释狄利克雷分布的期望值的计算。谢谢你。

PyStan 中的贝叶斯推理介绍

原文：https://towardsdatascience.com/an-introduction-to-bayesian-inference-in-pystan-c27078e58d53?source=collection_archive---------4-----------------------

使用 Python 和 Stan 演示贝叶斯工作流

介绍

数据科学中贝叶斯方法的许多优点很少被低估。与 20 世纪定义统计学的相对陈旧的频率主义传统不同，贝叶斯方法通过将数据驱动的可能性与对世界的先验信念相结合，更紧密地匹配人类大脑的推理。这种方法在强化学习中得到了卓有成效的应用，努力将其融入深度学习是当前研究的热点领域。事实上，认为贝叶斯统计是两个统计学派中更基础的，并且应该是第一次向学生介绍这门学科时首选的统计学图片。

由于来自贝叶斯推理的预测是概率分布而不是点估计，这允许量化所作出的推理中的不确定性，这通常是机器学习方法所作出的预测所缺少的。

尽管将贝叶斯方法纳入机器学习有明确的动机，但在实际实现它们时存在计算挑战。通常，分析计算所需的分布是不实际的，而使用随机抽样方法，如马尔可夫链蒙特卡罗 (MCMC)。以透明和有效的方式实现 MCMC 方法的一种方式是通过概率编程语言 Stan 。

在本文中，我将提供一些关于贝叶斯推理和 MCMC 的背景知识，然后演示一个简单的例子，其中 Stan 用于通过 Stan 的 Python 接口 PyStan 对生成的数据集执行推理。

贝叶斯定理

贝叶斯推理的关键在于贝叶斯定理，它是由托马斯·贝叶斯牧师在 18 世纪发现的。这是基于概率论的一个基本结果，你可能以前见过:

左边的东西是我们的后验概率，这是我们感兴趣的分布。在右边，我们有可能性，它取决于我们的模型和数据，乘以先验，代表我们预先存在的信念，并除以边际可能性，使分布正常化。

这个定理可以用来得出许多违反直觉的结果，尽管如此，这些结果仍然是正确的。举个例子，当测试人群严重倾斜时，药物测试中的假阳性要高得多。我将继续与 Stan 讨论推理，而不是详细介绍贝叶斯统计的基础知识。威廉·科尔森有一些很好的材料来理解贝叶斯定理背后的直觉。

推动 Stan 的使用

贝叶斯推断是难。根据统计学家唐·贝里的说法，其原因是:

"从思考困难的意义上来说，贝叶斯推理是困难的."—唐·贝里

好吧。我想他在这里的意思是，使用贝叶斯方法进行推理的数学开销很小，所以困难来自概念上的困难，而不是任何技术或方法上的抽象。但更具体地说，贝叶斯推理很难，因为解积分很难。

上面的 P(B)包含了模型参数可能取的所有值的积分。幸运的是，我们并没有完全不知所措，因为通过从中抽取样本，并创建这些采样值的直方图作为所需的后验分布，可以构建后验分布的*似值。

MCMC 方法

在生成这些样本时，我们需要一个方法框架来管理采样器应该如何在参数空间中移动。一个流行的选择是马尔可夫链蒙特卡罗。MCMC 是一类结合了两个强大概念的方法:马尔可夫链和蒙特卡罗抽样。

马尔可夫链是以“无记忆”方式随时间演化的随机过程，被称为马尔可夫属性。Markov 属性意味着 Markov 链的状态转移到另一个状态的概率仅取决于系统的最*状态，而不是其整个历史。

另一方面，蒙特卡罗抽样涉及通过重复随机抽样来解决确定性问题。这样做的标准方式是使用 Metropolis-Hastings 算法。

相反，Stan 使用一种称为哈密顿蒙特卡罗(HMC)的最先进的算法来生成这些样本，该算法通过融入许多物理学理论思想来构建 Metropolis-Hastings 算法。实际上，默认情况下，它实现了一个名为不掉头采样器 (NUTS)的 HMC 版本。

很容易陷入这些方法的概念复杂性中，所以如果您在这个阶段还没有完全掌握，请不要担心；只要记住我们是随机生成样本，并根据一些概率规则接受或拒绝这些样本。

Stan 是一种概率编程语言，由 T2 的 Andrew Gelman 公司开发，主要在哥伦比亚大学。如果你觉得这个名字很奇怪，它是以核物理学家和蒙特卡罗方法之父斯坦尼斯劳·乌拉姆的名字命名的。

虽然它非常有用，但 Stan 的学习曲线相对较陡，而且互联网上也没有足够多的介绍性材料来证明这一点。语法本身大部分是从 Java/C 借用的，但是也有 R、Python、Julia 甚至 MATLAB 的库。对，没错，甚至 MATLAB 。因此，无论你的规划是什么，都可能有适合你的东西。

我选择的语言是 Python，所以我将使用 PyStan。像 Stan 的其他部分一样，PyStan 的代码是开源的，可以在这个 GitHub 库中找到，并且文档相当全面。斯坦的流行替代者，你们中的一些人可能很熟悉，是 PyMc 和 Edward，尽管我对他们没有太多的经验。Stan 的好处在于，你可以简单地在你的模型中指定分布，然后你就开始了，已经朝着你即将到来的推论奖金前进了。斯坦真正闪光的地方是在非常高维的问题中，在那里你可以推断出大量的预测因子。

然而，在本文中，我将保持事情的简单性，将我们的模型限制为简单的单变量线性回归，允许更多地关注 Stan 工作流。我们将实现的模型是

其中我们有截距α和梯度β，我们的数据分布在这条直线上，具有标准差σ的高斯噪声。

让我们建立一个模型

现在我们已经了解了一些背景知识，让我们来实现一些我们已经讨论过的内容。首先，你需要安装 PyStan，你可以这样做:

pip install pystan

让我们从导入相关的包开始，并设置 numpy 种子以实现可再现性。接下来，我们将通过指定线性回归的模型来开始我们的 Stan 脚本。这个模型是用 Stan 编写的，并被赋给一个名为model的 string 类型的变量。这是脚本中唯一需要用 Stan 编写的部分，推理本身将用 Python 完成。

这个模型的代码来自 Stan 参考手册第三章中的第一个示例模型，如果您正在进行任何类型的贝叶斯推理，这是一本推荐的读物。

Stan 模型至少需要三个块，分别用于数据、参数和模型。数据块指定将用于采样的数据的类型和维度，参数块指定相关参数。分布语句放在模型块中，在我们的例子中，它是一条带有附加高斯噪声的直线。尽管此处未包括，但也可以指定转换后的数据和转换后的参数块，以及函数和生成量的块。

请注意，在参数块中，我们将 sigma 的下限指定为 0，因为高斯噪声的幅度不可能为负。这是一个关于参数sigma的先验的例子，更详细的先验可以添加到模型块中。

还要注意，我们没有给我们的alpha和beta参数添加任何先验，尽管可以在模型块中随意试验添加先验，看看它们如何影响后验估计。

数据生成

在这里，我们将指定我们的参数的“基本事实”值，我们的目标是使用 Stan 再现这些值，并使用 numpy 从这些参数生成数据，确保添加高斯噪声。

我们可以绘制这些数据来了解我们在处理什么。

现在我们可以使用 PyStan 模型进行推理。数据需要在 Python 字典中运行采样器，并且我们在 Stan 模型的数据块中指定的每个元素都需要一个键。

然后，在对模型进行采样之前，需要对其进行编译，不过也可以加载一个预编译的模型，这可以通过本文附带的 GitHub 存储库中的这个脚本来完成。这种设置允许我们更改我们想要生成评估的数据，而不必重新编译模型。

抽样

在采样方法中，有许多可以指定的参数。iter是指将从每个马尔可夫链中产生的样本总数，chains是将从其中组合样本以形成后验分布的链的数量。因为潜在的马尔可夫过程是随机的，所以在参数空间的不同位置初始化更多的链是有利的，尽管添加更多的链会增加采样所需的时间。

warmup，也称为“老化”，是从每个链的开始将被丢弃的样本量，因为早期的样本将在马尔可夫链还没有机会达到*衡时被抽取。

默认情况下，这是iter的一半，因此对于每个链，我们将获得 1000 个样本，并丢弃前 500 个。有了 4 条链，我们总共会有 2000 个样本。

thin指定保留样本的采样间隔。因此，如果thin等于 3，则每三个样本保留一个，其余的丢弃。这对于减轻连续样本之间的相关性影响是必要的。这里它被设置为 1，所以每个样本都被保留。最后，seed被指定为允许再现性。

诊断学

一旦采样完成，就可以打印 fit 对象来检查推理的结果。在这里，我们可以看到两个回归参数的汇总统计数据，以及模型中的高斯噪声。

此外，我们可以看到称为lp__的量的相同统计数据，根据 Stan 手册它是达到常数的对数后验密度。检查lp__是否已经收敛可以让我们更加确信整个采样过程已经收敛，但是这个值本身并不是特别重要。

The printed fit upon completion of sampling in Stan.

除了*均值和分位数信息，每个参数还有另外两列，n_eff和Rhat。n_eff是的有效样本量，由于样本之间的相关性，它可以显著低于生成的样本的名义数量。如上所述，可以通过细化马尔可夫链来减轻自相关的影响。

Rhat是 Gelman-Rubin 收敛统计量，一种马尔可夫链收敛的度量，对应于方差减少的比例因子，如果允许采样永远继续，则可以观察到方差减少。因此，如果Rhat约为 1，无论你继续迭代多长时间，你都不会看到采样方差减少，因此马尔可夫链很可能(但不保证)已经收敛。

我们可以将这种拟合输出投射到 pandas 数据框架中，以使我们的分析更容易，从而允许更好地访问相关的汇总统计数据。上面的 fit 对象有一个 plot 方法，但这可能有点混乱，而且似乎已被弃用。相反，我们可以提取每个参数的采样值序列，称为“轨迹”,我们可以将它与相应的后验分布一起绘制，用于诊断目的。

绘制我们的回归线

既然我们已经从拟合的模型中提取了相关的信息，我们可以看一下绘制线性回归的结果。为了从推断参数的不确定性中了解我们在回归线中可以预期看到的分布类型，我们也可以绘制潜在的回归线，其参数从我们的后验中取样。

关于用于生成该图的代码的更多细节，您可以查看 GitHub 上的脚本。

绘制后验概率图

除了将我们的分析局限于汇总统计数据，我们还可以更详细地查看我们之前提取的每个参数的一系列采样值。这将允许更深入地了解采样过程，并且是执行 fit 诊断的重要部分。

这里我定义了一个函数，它绘制了给定参数的轨迹和后验分布。对感兴趣的参数调用该函数，我们可以生成所需的图。

从上面的轨迹图中，我们可以看到通过参数空间的运动类似于随机行走，这表明潜在的马尔可夫链已经如我们所希望的那样达到收敛。我们也可以看一下beta和sigma的对应图。

从后验分布图中我们可以看出，基本事实总体上非常接*我们分布的模式，并且在 95%的可信区间内。由于数据中的噪声，在后验峰值和基础事实之间存在一些偏差。贝叶斯方法的便利之处在于，估计中的不确定性在这些后验分布中被捕获，并且可以通过提供更有洞察力的先验来改进。

结论

我们已经看到了如何在 Stan 中编写模型，如何使用 PyStan 中生成的数据执行采样，以及如何检查采样过程的输出。贝叶斯推理可能非常强大，还有许多 Stan 的特性有待探索。我希望这个例子是有用的，并且您可以在执行自己的采样和推断时使用其中的一些材料。

我的第一篇技术博客就这样结束了。请随意留下任何反馈，并确保查看 GitHub 资源库 以执行您自己的推断并制作您自己的情节。感谢阅读！

Python 中聚类算法的介绍

原文：https://towardsdatascience.com/an-introduction-to-clustering-algorithms-in-python-123438574097?source=collection_archive---------1-----------------------

在数据科学中，我们经常会思考如何利用数据对新的数据点进行预测。这被称为“监督学习”然而，有时我们不想“做预测”,而是想将数据分成不同的类别。这被称为“无监督学习”

为了说明这种差异，假设我们在一家大型披萨连锁店工作，我们的任务是在订单管理软件中创建一个功能，为客户预测送货时间。为了实现这一点，我们得到了一个数据集，其中包含过去几次交付的交付时间、行驶距离、星期几、时间、现有员工和销售量。根据这些数据，我们可以预测未来的交货时间。这是监督学习的一个很好的例子。

现在，让我们假设比萨饼连锁店想要向顾客发送有针对性的优惠券。它想把顾客分成 4 类:大家庭、小家庭、单身人士和大学生。我们获得了之前的订购数据(例如订单规模、价格、频率等)，我们的任务是将每个客户归入四个类别之一。这将是“无监督学习”的一个例子，因为我们不做预测；我们只是把顾客分成几组。

聚类是最常用的无监督学习形式之一。在本文中，我们将探讨两种最常见的聚类形式:k-means 和层次聚类。

了解 K-Means 聚类算法

让我们看看 k-means 聚类是如何工作的。首先，让我给你介绍我的好朋友，blobby 即 Python 的 sci-kit 学习库中的 make_blobs 函数。我们将使用 make _ blobs 创建四个随机集群来帮助我们完成任务。

# import statements
from sklearn.datasets import make_blobs
import numpy as np
import matplotlib.pyplot as plt# create blobs
data = make_blobs(n_samples=200, n_features=2, centers=4, cluster_std=1.6, random_state=50)# create np array for data points
points = data[0]# create scatter plot
plt.scatter(data[0][:,0], data[0][:,1], c=data[1], cmap='viridis')
plt.xlim(-15,15)
plt.ylim(-15,15)

你可以在下面看到我们的“斑点”:

我们有四个彩色集群，但是上面的两个集群和下面的两个集群有一些重叠。k-means 聚类的第一步是选择随机质心。因为我们的 k=4，我们需要 4 个随机质心。下面是它在我的实现中从头开始的样子。

接下来，我们取每个点，找到最*的质心。度量距离的方法有很多种，我用的是欧氏距离，可以用 Python 中的 np.linalg.norm 来度量。

现在我们有了 4 个集群，我们找到了集群的新的质心。

然后，我们再次将每个点匹配到最*的质心，重复这个过程，直到我们不能再改进聚类。在这种情况下，当过程结束时，我得到了下面的结果。

请注意，这些集群与我最初的集群有些不同。这是随机初始化陷阱的结果。本质上，我们的起始质心可以决定我们的聚类在 k 均值聚类中的位置。

这不是我们想要的结果，但是解决这个问题的一个方法是使用 k-means ++算法，它提供了更好的初始播种，以便找到最佳的聚类。幸运的是，这是在我们将在 Python 中使用的 k-means 实现中自动完成的。

在 Python 中实现 K-Means 聚类

要在 Python 中运行 k-means，我们需要从 sci-kit learn 中导入 KMeans。

# import KMeans
from sklearn.cluster import KMeans

注意，在文档中，k-means ++是缺省的，所以我们不需要为了运行这个改进的方法而做任何改变。现在，让我们在 blobss 上运行 k-means(这些 blob 被放入一个名为“points”的 numpy 数组中)。

# create kmeans object
kmeans = KMeans(n_clusters=4)# fit kmeans object to data
kmeans.fit(points)# print location of clusters learned by kmeans object
print(kmeans.cluster_centers_)# save new clusters for chart
y_km = kmeans.fit_predict(points)

现在，我们可以通过在 matplotlib 中运行以下代码来查看结果。

plt.scatter(points[y_km ==0,0], points[y_km == 0,1], s=100, c='red')
plt.scatter(points[y_km ==1,0], points[y_km == 1,1], s=100, c='black')
plt.scatter(points[y_km ==2,0], points[y_km == 2,1], s=100, c='blue')
plt.scatter(points[y_km ==3,0], points[y_km == 3,1], s=100, c='cyan')

瞧啊。我们有 4 个集群。请注意，k-means++算法比我在示例中运行的普通 ole' k-means 做得更好，因为它几乎完美地捕捉到了我们创建的初始聚类的边界。

K-means 是最常用的聚类形式，因为它速度快且简单。另一种非常常见的聚类方法是层次聚类。

实现凝聚层次聚类

凝聚层次聚类在一个关键方面不同于 k-means。我们不是选择一些聚类，从随机的质心开始，而是从数据集中的每个点作为一个“聚类”开始然后我们找到最*的两个点，并把它们组合成一个簇。然后，我们找到下一个最*的点，这些成为一个集群。我们重复这个过程，直到我们只有一个巨大的星团。

在这个过程中，我们创建了一个树状图。这是我们的“历史”你可以看到我们下面的数据点的树状图，以了解正在发生的事情。

树状图标出了每个聚类和距离。我们可以使用树状图找到我们选择的任何数字的聚类。在上面的树状图中，很容易看到第一个集群(蓝色)、第二个集群(红色)和第三个集群(绿色)的起点。这里只有前 3 个是用颜色编码的，但是如果你看树状图的红色一边，你也可以发现第 4 个集群的起点。该树状图一直运行，直到每个点都是它自己的单独聚类。

让我们看看凝聚层次聚类在 Python 中是如何工作的。首先，让我们从 scipy.cluster.hierarchy 和 sklearn.clustering 中导入必要的库。

# import hierarchical clustering libraries
import scipy.cluster.hierarchy as sch
from sklearn.cluster import AgglomerativeClustering

现在，让我们创建我们的树状图(上面我已经向您展示过了)，确定我们需要多少个聚类，并保存这些聚类中的数据点以绘制它们的图表。

# create dendrogram
dendrogram = sch.dendrogram(sch.linkage(points, method='ward'))# create clusters
hc = AgglomerativeClustering(n_clusters=4, affinity = 'euclidean', linkage = 'ward')# save clusters for chart
y_hc = hc.fit_predict(points)

现在，我们将像使用 k-means 算法一样，使用 matplotlib 查看我们的聚类。

plt.scatter(points[y_hc ==0,0], points[y_hc == 0,1], s=100, c='red')
plt.scatter(points[y_hc==1,0], points[y_hc == 1,1], s=100, c='black')
plt.scatter(points[y_hc ==2,0], points[y_hc == 2,1], s=100, c='blue')
plt.scatter(points[y_hc ==3,0], points[y_hc == 3,1], s=100, c='cyan')

结果如下:

在这种情况下，k-means 和层次聚类之间的结果非常相似。然而，情况并非总是如此。一般来说，凝聚层次聚类的优点是它往往会产生更准确的结果。缺点是，与 k-means 相比，层次聚类更难实现，并且消耗更多的时间/资源。

延伸阅读

如果你想了解更多关于聚类的知识，我强烈推荐 George Seif 的文章“数据科学家需要了解的 5 种聚类算法”

其他资源

1. G.詹姆斯，d .威滕等人。艾尔。统计学习简介，第十章:无监督学习，链接 (PDF)
2. 安德里亚·特雷维尼奥，K 均值聚类介绍，链接
3. 基里尔·叶列缅科，机器学习 A-Z (Udemy 课程)，链接

数据质量简介

原文：https://towardsdatascience.com/an-introduction-to-data-quality-951cc6fe0274?source=collection_archive---------11-----------------------

Image Reference: www.datapine.com

1.什么是数据质量？

数据质量有许多定义，一般来说，数据质量是对有多少数据可用并适合其服务环境的评估。

许多因素有助于衡量数据质量，例如:

• 数据一致性:违反数据集定义的语义规则。[1].
• 数据准确性:当数据库中存储的数据值与真实值相符时，数据是准确的。[1]
• 数据唯一性:针对特定字段、记录或数据集，衡量系统内部或跨系统存在的多余重复。[2]
• 数据完整性:数据集合中存在的值的程度。[1]
• 数据及时性:数据的年龄在多大程度上适用于手头的任务。[3]

其他因素也可以考虑[4]，如可用性、易操作性、可信度和流通性。

2.为什么数据质量很重要？

提高数据质量是一个关键问题，因为数据被视为组织内所有活动的核心，数据质量差会导致报告不准确，从而导致不准确的决策和经济损失。

3.如何提高数据质量？

通过以下方式提高数据质量:

1. 培训员工
2. 实施数据质量解决方案

3.1.培训员工

在考虑实现数据质量解决方案之前，首先我们必须尽量减少由组织内的人工活动(如数据输入)导致的数据质量问题。此外，所有开发人员和数据库管理员都必须对业务流程有很好的了解，并且在开发和设计数据库和应用程序时必须参考统一的模式。[5]

3.2.实施数据质量解决方案

提高数据质量的另一种方法是实施数据质量解决方案。数据质量解决方案是一套执行质量任务的工具或应用程序，例如:

• 知识库创建:知识库是用于信息传播的机器可读资源。[6]
• 重复数据删除:根据一组语义规则删除重复的信息。
• 数据清理:从值中删除不需要的字符和符号。
• 数据分析:是检查从现有信息源(例如数据库或文件)获得的数据并收集关于该数据的统计数据或信息摘要的过程。[7]
• 数据匹配:数据匹配描述了使用记录链接和实体解析等技术来比较两组收集的数据。[8]

4.流行的数据质量解决方案

在这一部分，我将展示一些市场上最流行的数据质量解决方案。

4.1.IBM Infosphere 信息服务器

IBM InfoSphere Information Server 是一个市场领先的数据集成*台，它包括一系列产品，使您能够理解、清理、监控、转换和交付数据，并通过协作来弥合业务和 IT 之间的差距。InfoSphere Information Server 提供了大规模并行处理(MPP)能力，以提供一个高度可伸缩和灵活的集成*台，处理所有大小数据量。

InfoSphere Information Server 使您能够灵活地满足您独特的信息集成需求——从数据集成到数据质量和数据治理——以便为您的任务关键型业务计划(如大数据和分析、数据仓库现代化、主数据管理和影响点分析)提供可信的信息。[9]

• 首页:https://www.ibm.com/analytics/information-server

4.2.信息数据质量

Informatica 数据质量为内部或云中的所有业务应用程序的所有利益相关者、项目和数据域提供值得信赖的数据。[10]

• 首页:https://www . informatica . com/products/data-quality/informatica-data-quality . html

4.3.Oracle 数据质量

Oracle Enterprise Data Quality 为交易方和产品数据提供了一种完整的、同类最佳的方法，可生成与应用程序集成的可信主数据，从而提高业务洞察力。[11]

• 首页:http://www . Oracle . com/us/products/middleware/data-integration/enterprise-data-quality/overview/index . html

4.4.Microsoft 数据质量服务

SQL Server 数据质量服务(DQS)是一种知识驱动的数据质量产品。DQS 使您能够建立一个知识库，并使用它来执行各种关键的数据质量任务，包括纠正、丰富、标准化和重复数据删除。DQS 使您能够通过使用参考数据提供商提供的基于云的参考数据服务来执行数据清理。DQS 还为您提供集成到其数据质量任务中的分析，使您能够分析数据的完整性。[12]

• 首页:https://docs . Microsoft . com/en-us/SQL/data-quality-services/data-quality-services

4.5.Melissa 数据质量

自 1985 年以来，Melissa 一直在提供具有广泛功能的企业数据质量工具，包括数据分析和标准化、清理、丰富、链接和重复数据删除。我们的使命是为组织提供一流的解决方案，提供可信、可靠、准确的信息，以获得更好的洞察力。[10]

• 首页:https://www.melissa.com/uk/data/data-quality

4.6.数据质量

Talend 的企业数据质量工具可以分析、清理和屏蔽数据，同时监控任何格式或大小的数据质量。重复数据消除、验证和标准化为访问、报告、分析和运营创建了干净的数据。利用外部来源丰富数据，用于邮政验证、业务识别、信用评分信息等。[13]

• 主页:【https://www.talend.com/products/data-quality/

4.7.Syncsort Trillium 软件领先

Syncsort 的 Trillium 云提供了行业领先的企业数据质量解决方案，具有 Syncsort 管理的强化安全 colud 环境的部署便利性和运营灵活性。[14]

• 首页:【http://www.syncsort.com/en/About/Trillium-Software

4.8.SAS 数据质量

SAS 数据质量软件使您能够提高数据的一致性和完整性。当您提高数据质量时，您就提高了分析结果的价值。

SAS 数据质量软件支持各种数据质量操作。数据质量操作采用预定义的规则，这些规则适用于数据的特定上下文(如姓名或街道地址)。数据质量操作的例子包括大小写、解析、模糊匹配和标准化。[15]

• 首页:https://www.sas.com/en_us/software/data-quality.html

5.参考

• [1] C. Batini，C. Cappiello，C. Francalanci，A. Maurino，“数据质量评估和改进的方法学”， ACM 计算调查(CSUR)，第 41 卷，第 16 页，2009 年。
• [2] D. McGilvray，“质量数据和可信信息的十个步骤”，麻省理工学院信息质量行业研讨会， 2008。
• [3] R. Y. W. a. D. M. Strong，“超越准确性:数据质量对数据消费者意味着什么”，《管理信息系统杂志》，第 12 卷，第 5-33 页，1996 年。
• [4] Sidi Fatimah，Shariat Panahy，Payam Hassany，Lilly Suriani Affendey，Marzanah A. Jabar，Hamidah Ibrahim，Aida Mustapha，“数据质量:数据质量维度调查”，载于Proceedings-2012 International Conference on Information Retrieval and Knowledge Management，CAMP’12，2012 年。
• [5] Herzog，Thomas N .，scheuren，f.j，winkler，“什么是数据质量，我们为什么要关心”，《工业工程与管理学报》，第 4 卷(2)，第 2 版，第 1–9 页，2016 年。
• [6] M. Rouse，“知识库”，TechTarget，2007 年第 3 期。【在线】。可用:【https://searchcrm.techtarget.com/definition/knowledge-base.】T4【2018 年 9 月 12 日访问】。
• [7]“数据剖析”，维基百科，[在线]。可用:https://en.wikipedia.org/wiki/Data_profiling.【2018 年 9 月 12 日接入】。
• [8]“什么是数据匹配？，“Techopedia，[在线]。可用:https://www.techopedia.com/definition/28041/data-matching.【2018 年 9 月 12 日获取】。
• [9]“IBM 信息服务器”，IBM，[在线]。可用:https://www.ibm.com/analytics/information-server.【2018 年 9 月 12 日接入】。
• [10]“最佳数据质量软件”，G2Crowd，[在线]。可用:https://www.g2crowd.com/categories/data-quality.【2018 年 9 月 12 日获取】。
• [11]“Oracle 企业数据质量”，Oracle，[在线]。可用:http://www . Oracle . com/us/products/middleware/data-integration/enterprise-data-quality/overview/index . html【2018 年 12 月 9 日访问】。
• [12]“数据质量服务”，微软，2013 年 10 月 12 日。【在线】。可用:https://docs . Microsoft . com/en-us/SQL/data-quality-services/data-quality-services？view=sql-server-2017。【2018 年 12 月 9 日接入】。
• [13]“数据质量”，塔伦德，[在线]。可用:https://www.talend.com/products/data-quality/.【2018 年 9 月 12 日接入】。
• [14]“Trillium 软件”，Syncsort，[在线]。可用:http://www.syncsort.com/en/About/Trillium-Software.【2018 年 9 月 12 日接入】。
• [15]“SAS 数据质量和数据质量服务器”，SAS，[在线]。可用:http://support . SAS . com/software/products/data qual/index . html【2018 年 9 月 12 日访问】

调试介绍(用 C 和 lldb 编写)，第一部分

原文：https://towardsdatascience.com/an-introduction-to-debugging-in-c-and-lldb-part-i-e3c51991f83a?source=collection_archive---------4-----------------------

Source — https://xkcd.com/1722/

什么是调试？

“bug”这个词(以及由此而来的“debugging”)是如何理解我们(计算机程序员)所联想到的含义的，还不完全清楚。这可能要归功于哈佛大学马克 2 号计算机中传说中的飞蛾，也可能是在比 T1 更早的时候创造的。无论起源是什么，作为程序员，我们都有关于调试的故事要分享。有时它们很悲伤，有时它们描述了几个令人疲惫不堪的小时，但大多数时候它们都有一个快乐的结局。但是我们都有一个共同点，我们会遇到调试。几乎每天。因此，在开始调试之前，让我们先定义一下它是什么。

我建议调试的定义如下—

调试是一个开发人员(他可能是也可能不是他要调试的代码的作者)使用各种可用的工具，努力改变以前编写的代码的一部分，以消除在编译(或语法检查)时没有发现的错误(换句话说，在特定条件下在运行时出现的错误)的过程。

听起来很酷吗？还是恐吓？如果是后者，那么你应该继续读下去。也许这个小帖子终究会帮到你。

不同类型的调试

人们有许多不同的方法来执行调试。但是在列出它们之前，我们需要理解任何调试过程主要(大部分时间)由两个主要活动组成。第一——调查程序执行的不同阶段不同变量的值，第二——检查控制流的方向(我们是否进入了“if”块？“while”循环中的“break”语句到达了吗？…)

• 打印语句 —在运行代码时，使用“Print”(或“printf”或“echo”或任何等效的东西)来输出一些值。这可能是开始调试任何东西的最简单的方法。这也是最笨拙和费时的方法。它之所以笨拙，是因为一旦我们完成了，我们很容易在代码中留下所有那些(或其中的一部分)打印语句，导致不干净的代码(在一些非常罕见的情况下，在生产中破坏它)。).这很费时间，因为我们必须编写所有的打印语句，然后在程序执行的时候监视它们。
• 使用日志记录 —这种方法也是基于文本的，就像打印一样，但是有很多优点。我们实际上可以将结构化消息从我们的程序转发到日志管理*台，然后使用这些工具在文本语料库中执行各种搜索以收集必要的信息，而不是仅仅将“stdout”作为输出机制(对于打印来说)。这是一个非常有效的方法。对于任何严肃的生产应用程序来说，日志记录都是必不可少的。但是它也有自己的局限性。我们仍然必须在代码中手工编写所有的日志语句(如果不需要的话就删除它们)，而且我们也不能(在大多数情况下)窥视程序执行的内幕。
• 交互式(符号)调试器——如果你曾经使用过类似“gdb”(或“ipdb”或“pydb”或“lldb”之类的东西，那么你就知道我在说什么。至于其他的，在你自己的开发机器中有可用的工具，这些工具在运行时以一种交互的方式给你一个强大的访问程序的权限，并且让你在一段运行的代码上执行非常低级(和高级)的调查。这种调试的优点是，您不需要做任何额外的工作来开始调试代码。你只需启动调试器并指向可执行文件，瞧！您正在运行一个程序，但是您也拥有实时调查(如果需要，甚至更改)它的所有权力。酷！

关于虚拟内存的几句话

在我们使用调试器进行任何严肃的调试之前，我们需要理解操作系统是如何给程序分配内存的。有一篇由彼得·萨尔兹曼撰写的关于交互式调试的精彩(可能是最好的)介绍，我的帖子只是它的前几页的一个小摘要(由于 lldb 的缘故，有一点额外的内容)，但是我仍然会花时间说几句关于 VM 的话。任何感到好奇的人请跟随彼得的指南(和他在那里提到的链接)。

当一个程序启动时，操作系统会在主内存(ram)中分配一块内存，以便该进程可以运行。这被称为虚拟内存空间。它是一种复杂的高级机制，涉及操作系统和 CPU 的内存管理单元(MMU)。我们不需要详细讨论这个问题。但是我们确实需要知道，在 VM 内部，有一块内存被分配给两个不同的数据结构所使用的进程。栈和堆(除了一些为其他东西保留的其他块)。它看起来像下面这样—

scource — https://open4tech.com/concept-heap-usage-embedded-systems/

任何由我们或我们正在使用的库分配的动态内存都将位于堆内部。堆栈由“帧”组成。每一帧代表一个函数调用。当一个新的函数被调用时，一个新的帧被插入到栈顶。如果您将分配的 VM 想象为主内存中的一个垂直内存块，那么随着进程的进行，堆栈向下增长，堆向上增长(如上图所示)。

当我们调试时，我们将需要框架的概念。

正在调试

我将展示与 lldb 相关的命令，并在最*的 MacBook Pro 中执行(预装了llvm)。 *cc* 和 *lldb* 的版本都在之后

Apple LLVM version 9.1.0 (clang-902.0.39.2) (result of cc --version)lldb-902.0.79.7 (result of lldb --version)

我们先写一个你能想象到的最简单的 C 程序。我将使用“vim”作为编辑器。你可以用任何你想要的东西。

vim hello.c

进入编辑器后，请复制粘贴(或键入)以下代码—

#include<stdio.h>int main(int argc, char* argv){ printf("Hello World!\n"); return 0;
}

保存并退出编辑器，然后执行以下操作

cc -g --std=c99 -Wall hello.c -o hello

下面是我们为编译器使用的一些标志的描述

• -g它告诉我们的编译器在输出文件中嵌入调试信息(例如符号表)
• --std=c99我们正在使用的 C 语言标准
• -Wall捕捉所有的警告

为了查看我们所做的实际上运行了，我们可以尝试下面的方法

./hello
Hello World!

到目前为止一切顺利！现在让我们启动调试器。为此，请使用以下命令

lldb hello

如果一切正常，它将显示如下内容—

这是交互式调试器的提示。在我们的例子中是lldb

引用 lldb 文档中的话，gdb中的命令是“自由形式的”。然而，lldb 已经努力使命令标准化。lldb中的命令遵循以下模式—

<noun> <verb> [-options [option-value]] [argument [argument...]]

这里的noun代表你正在努力工作的对象。这可以是thread或frame或类似的。而verb就是实际的命令。所以与gdb不同，要查看当前堆栈的所有帧，你必须输入thread backtrace(对于gdb，它只是简单的backtrace)。如果您在最开始输入这个命令，您将得到“错误:无效进程”。这是因为尽管我们已经用可执行文件的名称启动了调试器(在我们的例子中是hello ),但我们实际上并没有请求运行它。所以下面是您应该运行的第一个命令— run。它将产生如下输出—

我们已经成功地在调试器中运行了可执行文件。但是！我们对此没有任何控制。它跑了。成功了。最后以 0 状态退出。这里没有魔法。所以，让我们创造一些。我们将使用breakpoint set命令。断点是源文件中的特定代码行，调试器将在那里暂停执行，并给我们一个交互提示，以便与正在运行的进程混合:)(-l 10表示我的源文件中我想暂停执行的那一行。对你来说，行号可以不同)

注意这里的魔力。我们已经在原始源文件的行号后面设置了断点，但是我们正在加载和运行可执行文件，然而调试器不知如何连接它们，并在正确的代码行挂起。在此阶段，我们可以检查当前框架中的不同变量及其值。为了检查变量，我们这样做

瞧啊。我们有与当前框架相关的所有变量及其类型和值。现在是thread backtrace的时候了——

正如我们所见，我们的函数调用main位于堆栈的顶部。但这不是我们唯一的框架。我们有一些其他的与函数调用相关的帧，但是我们没有做。这些是在运行时加载的动态库。

最后，由于我们没有什么要进一步研究的(我们正在运行一个非常简单的代码)，我们需要知道如何从进程暂停的地方恢复它。我们如何前进？嗯，有两个命令。简称step或s，简称continue或c。它们之间的区别在于，step只是执行下一条指令，然后再次挂起。这是一种在运行过程中一步一步的旅程，而c将执行所有的指令，直到遇到下一个断点或过程结束。这里我们不想单步执行流程，所以我们使用c,因为没有更多的断点，流程将结束运行。

这是第一部分的结尾。我们在这里学习了调试的基础知识。但是我们还没有进行任何真正的调试。我们将在第二部分看到这一点。

如果你喜欢这篇小文章，请尽情鼓掌。这将鼓励我多写这样的文章。也请大家分享评论。他们非常有帮助:)

第二部分见。调试愉快！

深度学习导论

原文：https://towardsdatascience.com/an-introduction-to-deep-learning-af63448c122c?source=collection_archive---------3-----------------------

*年来，深度学习已经成为科技界的一个热门词汇。我们似乎总是在关于人工智能的新闻中听到它，然而大多数人实际上并不知道它是什么！在这篇文章中，我将揭开深度学习这个时髦词汇的神秘面纱，并提供它如何工作的直觉。

建立直觉

一般来说，深度学习是一种机器学习方法，它接受一个输入 X，并用它来预测一个输出 y。例如，给定过去一周的股票价格作为输入，我的深度学习算法将尝试预测第二天的股票价格。

给定输入和输出对的大型数据集，深度学习算法将尝试最小化其预测和预期输出之间的差异。通过这样做，它试图学习给定输入和输出之间的关联/模式——这反过来允许深度学习模型归纳到它以前没有见过的输入。

作为另一个例子，假设输入是狗和猫的图像，输出是这些图像的标签(即输入图片是狗还是猫)。如果输入具有狗的标签，但是深度学习算法预测猫，那么我的深度学习算法将学习到我的给定图像的特征(例如，锋利的牙齿、面部特征)将与狗相关联。

深度学习算法如何“学习”？

深度学习算法使用一种叫做神经网络的东西来寻找一组输入和输出之间的关联。基本结构如下所示:

神经网络由输入层、隐藏层和输出层组成，所有这些层都由“节点”组成。输入层接受数据的数字表示(例如，具有像素规格的图像)，输出层输出预测，而隐藏层与大多数计算相关。

我不会在数学上太深入，但是信息是通过上面显示的函数在网络层之间传递的。这里需要注意的要点是可调权重和偏差参数——在上面的函数中分别用 w 和 b 表示。这些对于深度学习算法的实际“学习”过程是必不可少的。

在神经网络将其输入一直传递到其输出之后，网络通过称为损失函数的东西来评估其预测(相对于预期输出)的好坏。例如，“均方误差”损失函数如下所示。

Y hat 代表预测，而 Y 代表预期产量。如果同时使用输入和输出批次，则使用*均值(n 代表样本数)

我的网络的目标最终是通过调整网络的权重和偏差来最小化这种损失。在通过梯度下降使用被称为“反向传播”的东西时，网络回溯通过它的所有层，以在损失函数的相反方向上更新每个节点的权重和偏差——换句话说，反向传播的每次迭代应该导致比以前更小的损失函数。

在不进行证明的情况下，网络的权重和偏差的持续更新最终会将其变成一个精确的函数逼*器——一个对输入和预期输出之间的关系进行建模的函数逼*器。

那么为什么叫“深度”学习呢？

深度学习的“深度”部分是指创建深度神经网络。这是指具有大量层的神经网络-通过添加更多的权重和偏差，神经网络提高了逼*更复杂函数的能力。

结论和要点

深度学习最终是一个广阔的领域，比我描述的要复杂得多。对于不同的任务，存在各种类型的神经网络(例如，用于计算机视觉的卷积神经网络，用于 NLP 的递归神经网络)，并且远远超出了我所介绍的基本神经网络。

上图:一个卷积神经网络

即使你不记得这篇文章的所有内容，这里也有一些要点:

• 深度学习指的是深度神经网络
• 深度神经网络发现一组输入和输出之间的关联
• 反向传播是用来更新神经网络参数的东西

深度学习的含义是疯狂的。虽然我给出了相当简单的应用示例，如图像分类和股票价格预测，但最终还有更多！视频合成、自动驾驶汽车、人类水*的游戏人工智能等等——所有这些都来自深度学习。如果你有兴趣了解更多，我写了一篇关于使用深度强化学习玩 doom 的文章——点击下面的链接查看！

深度强化学习的厄运

地理数据可视化导论

原文：https://towardsdatascience.com/an-introduction-to-geographical-data-visualization-3486959cd4b8?source=collection_archive---------4-----------------------

Choropleth map from Wiki

我一直对那些成功地将数据与地理信息结合起来的数字印象深刻。它们是我能想到的最漂亮的数据可视化的例子，你只需扫一眼就能看到的信息令人震惊。

这类图形被称为 choropleth 地图，根据维基的定义:

专题地图，其中区域根据地图上显示的统计变量(如人口密度或人均收入)的测量值成比例地进行着色或图案化

把它们想象成考虑了地理边界的热图。

我们可以使用 plotly 库制作 choropleth 地图。

我们将从一个简单的例子开始。我们进口如下:

**import** plotly **as** py
**import** plotly.graph_objs **as** go

我们希望创建一个“数据”变量，并将其传递到 go 中。Figure()方法生成 choropleth 图。

先来一张大千世界的地图吧！

我们将“数据”变量定义如下:

data = dict (
    type = 'choropleth',
    locations = ['China','Canada','Brazil'],
    locationmode='country names',
    colorscale = ['Viridis'],
    z=[10,20,30])

“数据”变量是一个字典。我们把它的“类型”定义为 choropleth。在“位置”中，我们给出了各个国家的名称，在位置模式中，我们告诉我们计划通过国家名称指定位置的方法。最后，我们指定色阶和我们希望分配给每个国家的值。

你可以在线或离线运行 plotly，为了避免创建帐户，我将离线运行它。

我们通过以下方式生成图像:

map = go.Figure(data=[data])
py.offline.plot(map)

得到一张世界地图。请注意，当我们将鼠标悬停在一个国家上方时，我们会得到它的名称和指定值。

我们可以通过绘制每个国家的幸福指数，让这张地图变得更有趣，而不是给几个国家任意赋值。

使用来自 2017 年世界幸福报告的数据，我们可以使用下面的代码创建这个数字

**import** plotly **as** py
**import** plotly.graph_objs **as** go
**import** pandas **as** pddf = pd.read_csv("2017.csv")

data = dict (
    type = 'choropleth',
    locations = df['Country'],
    locationmode='country names',
    colorscale = ['Viridis'],
    z=df['Happiness.Score'])

map = go.Figure(data=[data])
py.offline.plot(map)

生成下图。无需任何统计分析，我们可以自信地说，一些最幸福的国家在欧洲和北美，而一些最不幸福的国家集中在非洲。这就是地理可视化的力量。

现在让我们对美国做一些深入的可视化。

我们首先更改“数据”变量，以便 locationmode 指定美国各州。接下来，我们添加一个“布局”变量，允许我们自定义地图的某些方面。在这种情况下，我们告诉地图集中在美国，而不是显示整个世界，这是默认的。如果你愿意，你也可以关注亚洲、欧洲、非洲、北美或南美。

综上所述，我们使用以下代码为亚利桑那州、加利福尼亚州和佛蒙特州赋值:

data = dict (
    type = 'choropleth',
    locations = ['AZ','CA','VT'],
    locationmode='USA-states',
    colorscale = ['Viridis'],
    z=[10,20,30])

lyt = dict(geo=dict(scope='usa'))
map = go.Figure(data=[data], layout = lyt)
py.offline.plot(map)

要获得这张地图:

我们现在可以开始做一些有趣的事情了。

众所周知，世界正在经历蜜蜂数量的快速下降。这太糟糕了，因为这将意味着可爱的蜂蜜坚果麦片早餐的终结。我们可以获得每个州的蜂群数量，并使用我们的绘图技能来查看哪些州拥有最多的蜂群。

df = pd.read_csv("honeyproduction.csv")

data = dict (
    type = 'choropleth',
    locations = df['state'],
    locationmode='USA-states',
    colorscale = ['Viridis'],
    z=df['numcol'])

lyt = dict(geo=dict(scope='usa'))
map = go.Figure(data=[data], layout = lyt)
py.offline.plot(map)

看起来北达科他州拥有最多的殖民地，紧随其后的是加利福尼亚州，在这个国家的其他地方还有很大的改进空间。我们还遗漏了阿拉斯加和右上角几个州的一些数据，但这是该数据集的局限性。

我们已经谈到了幸福和蜂群。现在只剩下失业了。

让我们更深入地研究，而不是看国家或州，我们可以绘制每个州的县。我们将从这里得到每个县 2016 年的失业率数据。

每一个县都可以用一个 5 位数的 FIP 号码来唯一识别。

我们从导入开始，注意这次我们导入了 plotly.figure_factory

**import** plotly **as** py
**import** plotly.figure_factory **as** ff
**import** numpy **as** np
**import** pandas **as** pd

接下来我们阅读 FIP 的数据和失业率

df=pd.read_csv("https://raw.githubusercontent.com/plotly/datasets/master/laucnty16.csv")
df ['FIPS'] = df['State FIPS Code'].apply(**lambda** x: str(x).zfill(2)) + df['County FIPS Code'].apply(**lambda** x: str(x).zfill(3))
fips = df['FIPS'].tolist()
values = df['Unemployment Rate (%)'].tolist()

由于失业有许多不同的值，我们不希望我们的色标试图代表 1000 个不同的值，我们将其限制为 12 种颜色，如下所示

colorscale=["#f7fbff","#ebf3fb","#deebf7","#d2e3f3","#c6dbef","#b3d2e9","#9ecae1",             "#85bcdb","#6baed6","#57a0ce","#4292c6","#3082be","#2171b5","#1361a9","#08519c","#0b4083","#08306b"]
endpts = list(np.linspace(1, 12, len(colorscale) - 1))

并将所有这些参数传递给我们的 choropleth 方法

fig = ff.create_choropleth(fips=fips, values=values, colorscale= colorscale, binning_endpoints=endpts)
py.offline.plot(fig)

得到

哇，多漂亮的地图啊！

使用这样的图表，我们可以快速发现失业率高的地区(用红色圈出)。

对于未来的分析，弄清楚为什么这些地区正经历更多的失业以及可以做些什么将是有趣的。

我希望您喜欢这篇地理数据可视化的快速介绍。如果您有任何问题，或者您有任何想要分享的很酷的地理数据可视化示例，请告诉我。

谢谢！

GPU 优化简介

原文：https://towardsdatascience.com/an-introduction-to-gpu-optimization-6ea255ef6360?source=collection_archive---------3-----------------------

借助 GPU 的强大功能加速简单的计算任务

Source: Link

大多数涉及大量计算的任务都需要时间，随着数据集变得越来越大，这将变得更加耗时。解决这个问题的一种方法是使用线程。在本文中，我将介绍 GPU 加速，它是如何完成的，以及一个简单的 GPU 任务 API 和一段代码。首先，让我们考虑矩阵乘法的例子。

矩阵乘法

Matrix Multiplication

在上面的场景中，有两个矩阵，一个大小为3×6，另一个大小为6×6。得到的矩阵大小为3×6。因此，对于矩阵的每个单元，将有 6 个计算。总共会有3×6×6多次乘法。因此，我们可以断定，这项任务需要 O(mn ) 的时间量来计算。这意味着，对于一个大小为 2000 x 2000 的矩阵，将有80 亿 次计算完成。这是大量的 CPU 时间！！！。

GPU 简介

通常 GPU 包含大量的处理核心。通常从 384 到几千不等。下面简单对比一下英伟达的部分最新显卡。(来源)

CUDA Core Count

CUDA 代表计算统一设备架构。这些处理器运行速度相对较低，但通过使用大量 alu(算术和逻辑单元)提供了更高的并行性。点击阅读更多。

CUDA Thread Model

此图展示了 CUDA 中的线程模型(这与市场上的其他架构(如 AMD)非常相似)。为了简单起见，我们可以假设每个 CUDA 内核或 GPU 内核一次可以运行一个线程。如果我们有一个大的数据集，我们可以把它分成几个部分。一个网格包含几个块，块是另一个矩阵，包含数量与其大小相等的线程。无论如何，因为这是介绍，所以让我们把注意力放在用 JAVA 开发的更简单的 API 上。

想想 GPU

正如我们所讨论的，每个 GPU 核心都能够运行一个单独的线程。开始类比的最简单方法是假设矩阵的每个单元将由单个 GPU 核心来计算。由于所有内核都是并行运行的，因此所有单元都将被并行计算。因此，我们的时间复杂度突然下降到 O(n) 。现在，对于 2000 x 2000 矩阵我们只需要2000次运行，这对于计算机来说是相当容易计算的。通常我们之前讨论的每个线程都知道它的身份，也就是它所属的 块 和 网格 。或者更简单地说，矩阵的单元位置。此外，矩阵将被加载到 GPU 的共享内存中，我们可以通过索引直接访问单元数据并进行并行处理。简单对吗？让我们检查一下代码。

用 APARAPI 进行 GPU 编程

什么？嗯，APAR API(A-PARallel-API)是 OpenCL 的 JAVA 包装器，OpenCL 是用于编写 GPU 的开放计算语言。这同时支持 CUDA 架构和 AMD 设备。此外，API 将更好的面向对象的 JAVA 带入了画面，如果我们直接用 C++ 跳转到任务，这可能看起来很混乱。开始很容易。有一个 maven 依赖。但是要确保你已经正确设置了 OpenCL 或者 CUDA 。简单的谷歌搜索应该可以帮助你。大多数设备都捆绑在一起( OSX 和 Windows 设备)。

pom.xml

MatrixMultiplication.java

上述代码的详细说明

内核是由 GPU 执行的代码的一部分。内核可见的变量将被复制到 GPU RAM 中。我们以线性阵列而不是 2D 阵列的形式提供数据，因为这是 GPU 支持的方式。这并不是说它们不能处理 2D 数组，而是它们被处理的方式是通过维度的概念(我们现在还不会谈论它)。

Range range = Range.*create*(SIZE * SIZE);

上述代码在 GPU 中分配内存，以便SIZE x SIZEGPU 中运行的线程数量或更少(如可用)。

int row = getGlobalId() / SIZE;
int col = getGlobalId() % SIZE;

上面的代码从线程的私有内存中获取线程的 Id 。有了这个特定线程，我们就可以确定线程的单元位置。对于每个单元格，我们将执行以下操作。

for (int i = 0; i < SIZE; i++) {
    d[row * SIZE + col] += a[row * SIZE + i] * b[i * SIZE + col];
}

这是两个矩阵的相应单元的倍数的简单和。我们只是使用线程索引为单个线程定义内核，它将为所有线程并行运行。

结果

它很快。但是有多快呢？。这是上面程序的输出。

1200 x 1200

Starting single threaded computation
Task finished in 25269ms 
Starting GPU computation
Task finished in 1535ms

以下仅针对 GPU 组件运行，因为 CPU 的计算时间非常长。

2000 x 2000 任务用时 3757 毫秒
5000 x 5000 任务用时 5402 毫秒

希望你喜欢阅读。请一定要试试！！干杯！！

高维超参数调谐简介

原文：https://towardsdatascience.com/an-introduction-to-high-dimensional-hyper-parameter-tuning-df5c0106e5a4?source=collection_archive---------14-----------------------

优化 ML 模型的最佳实践

如果你曾经纠结于调整机器学习(ML)模型，那么你读对了。

超参数调整指的是为学习算法找到一组最佳参数值的问题。

通常，选择这些值的过程是一项耗时的任务。

即使对于像线性回归这样的简单算法，找到超参数的最佳集合也是困难的。有了深度学习，事情变得更糟。

优化神经网络(nn)时要调整的一些参数包括:

• 学习率
• 动力
• 正规化
• 退出概率
• 批量标准化

在这篇短文中，我们将讨论优化 ML 模型的最佳实践。这些实践主要在要优化的参数数量超过两个或三个时出现。

网格搜索的问题是

当我们有少量参数需要优化时，网格搜索通常是一个不错的选择。对于两个甚至三个不同的参数，这可能是正确的方法。

对于每个超参数，我们定义一组候选值进行研究。

然后，想法是详尽地尝试单个参数值的每个可能的组合。

对于每个组合，我们训练和评估不同的模型。

最后，我们保留泛化误差最小的那个。

网格搜索的主要问题是它是一种指数时间算法。它的成本随着参数的数量成指数增长。

换句话说，如果我们需要优化 p 参数，并且每个参数最多取 v 值，那么它在 O(vᵖ)时间内运行。

此外，网格搜索在探索超参数空间方面并不像我们想象的那样有效。

再看一下上面的代码。使用这个设置，我们将训练总共 256 个不同的模型。请注意，如果我们决定再添加一个参数，实验次数将增加到 1024 次。

但是，该设置只研究每个超参数的四个不同值。也就是说，我们训练 256 个模型，只探索学习率、正则化等四个值。

此外，网格搜索通常需要重复尝试。以上面代码中的learning_rate_search值为例。

learning_rate_search = [0.1, 0.01, 0.001, 0.0001]

假设在我们第一次运行(256 次模型试验)之后，我们得到了学习率值为 0.01 的最佳模型。

在这种情况下，我们应该通过“放大”0.01 附*的网格来优化我们的搜索值，希望找到一个更好的值。

为此，我们可以设置新的网格搜索并重新定义学习率搜索范围，例如:

learning_rate_search = [0.006, 0.008, 0.01, 0.04, 0.06]

但是如果我们得到学习率值为 0.0001 的最佳模型呢？

由于该值位于初始搜索范围的最边缘，我们应该移动这些值，并使用不同的集合重试，例如:

learning_rate_search = [0.0001, 0.00006, 0.00002]

并且在找到一个好的候选人之后，可能尝试改进范围。

所有这些细节只是强调了超参数搜索是多么耗时。

一种更好的方法——随机搜索

随机选择我们的超参数候选值怎么样？虽然看起来不太直观，但这个想法几乎总是比网格搜索要好。

一点点直觉

请注意，一些超参数比其他参数更重要。

例如，学习率和动量因子比所有其他因素更值得调整。

然而，除了上面的例外，很难知道哪一个在优化过程中起主要作用。事实上，我认为对于不同的模型架构和数据集，每个参数的重要性可能会有所不同。

假设我们正在优化两个超参数——学习率和正则化强度。此外，考虑到只有学习率对这个问题很重要。

在网格搜索的情况下，我们将运行九个不同的实验，但只尝试三个候选的学习率。

Image Credit: Random Search for Hyper-Parameter Optimization, James Bergstra, Yoshua Bengio.

现在，看看如果我们对候选人进行均匀随机抽样会发生什么。在这个场景中，我们实际上在探索每个参数的九个不同值。

如果你还不相信，假设我们正在优化三个超参数。例如，学习速率、正则化强度和动量。

Optimizing over 3 hyper-parameters using Grid Search.

对于网格搜索，我们将运行 125 次训练运行，但只探索每个参数的五个不同值。

另一方面，使用随机搜索，我们将探索 125 个不同的值。

怎么做

如果我们想要尝试学习率的值，比如说在 0.1 到 0.0001 的范围内，我们可以:

请注意，我们是在对数标度上从均匀分布中采样值。

您可以将值-1 和-4(用于学习率)视为区间[10e-1，10e-4]中的指数。

如果我们不使用对数标度，在给定的范围内取样将是不均匀的。换句话说，您不应该尝试对以下值进行采样:

在这种情况下，大多数值不会从“有效”区域中采样。实际上，考虑到这个例子中的学习率样本，值的 72%将落在区间[0.02，0.1]中。

此外，88%的采样值将来自区间[0.01，0.1]。也就是说，只有 12%的学习率候选值，即 3 个值，将从区间[0.0004，0.01]中被采样。不要那样做。

在下图中，我们从范围[0.1，0.0004]中抽取了 25 个随机值。左上角的图显示了原始值。

在右上角，注意 72%的采样值在区间[0.02，0.1]内。88%的值位于范围[0.01，0.1]内。

底部的图显示了值的分布。只有 12%的值在区间[0.0004，0.01]内。要解决这个问题，请从对数标度的均匀分布中对值进行采样。

正则化参数也会发生类似的行为。

另外，请注意，与网格搜索一样，您需要考虑我们上面提到的两种情况。

如果最佳候选落在非常接*边缘的位置，您的范围可能会偏离，应该进行移位和重新采样。此外，在选择了第一个好的候选值后，尝试重新采样到更精细的值范围。

总之，这些是关键要点。

• 如果您有两个或三个以上的超参数需要优化，请选择随机搜索。它比网格搜索更快/更容易实现并且收敛得更快。
• 使用适当的尺度来选择你的值。对数空间中均匀分布的样本。这将允许您在参数范围内对均匀分布的值进行采样。
• 不管随机还是网格搜索，注意你选择的候选人。确保参数的范围设置正确，并尽可能细化最佳候选值。

感谢阅读！要了解更多关于深度学习的酷东西，请查看我以前的一些文章:

[## 如何使用 TensorFlow Eager execution 训练自己的 FaceID ConvNet

人脸无处不在，从社交媒体网站上的照片和视频，到消费者安全应用程序，如…

medium.freecodecamp.org](https://medium.freecodecamp.org/how-to-train-your-own-faceid-cnn-using-tensorflow-eager-execution-6905afe4fd5a) [## 机器学习 101:梯度下降的直观介绍

毫无疑问，梯度下降是大多数机器学习(ML)算法的核心和灵魂。我绝对相信…

towardsdatascience.com](/machine-learning-101-an-intuitive-introduction-to-gradient-descent-366b77b52645)

分位数回归简介

原文：https://towardsdatascience.com/an-introduction-to-quantile-regression-eca5e3e2036a?source=collection_archive---------3-----------------------

Distribution of the lengths of ant bodies, from Wikimedia Commons

普通最小二乘回归是应用最广泛的统计方法之一。然而，它是一个参数模型，依赖于经常不满足的假设。分位数回归对残差的分布不做任何假设。它也让你探索因变量和自变量之间关系的不同方面。

动机

分位数回归至少有两个动机:假设我们的因变量是双峰或多峰的，也就是说，它有多个峰。如果我们知道是什么导致了多模态，我们就可以分离那个变量并进行分层分析，但是如果我们不知道，分位数回归可能是好的。在这里，OLS 回归会像依赖*均值作为双峰分布中心性的度量一样具有误导性。

如果我们的 DV 是高度倾斜的，例如，收入在许多国家，我们可能会对预测中位数(第 50 百分位)或其他分位数感兴趣；就像我们通常报告中位数收入而不是*均数收入一样。

另一个例子是，我们真正感兴趣的是处于最高或最低分位数的人。例如，如果研究性传播疾病的传播，我们可能会记录一个人在给定时间段内拥有的性伴侣数量。我们可能最感兴趣的是预测有很多伴侣的人，因为他们将是传播疾病的关键部分。

对于那些对商业感兴趣的人来说，花在商店或网站上的钱可能是不真实的。作为商店的老板，您可能更感兴趣的是找出预测最高分位数的因素，而不是*均值。

示例:出生体重

预测低出生体重很重要，因为出生时体重低的婴儿比正常体重的婴儿更容易出现健康并发症。通常的方法是使用 OLS 回归将*均出生体重建模为各种因素的函数，或者对出生体重进行二分法或其他分类，然后使用某种形式的逻辑回归(正常或有序)。这两者都是不够的。

对*均值建模是不够的，因为，正如我们将看到的，不同的因素在对*均值和下分位数建模时是重要的。我们经常感兴趣的是预测哪些母亲可能生下体重最低的婴儿，而不是特定母亲群体的*均出生体重。

对因变量进行分类很少是一个好主意，主要是因为它丢弃了有用的信息，并且对不同类别的人一视同仁。低出生体重的典型临界值是 2.5 公斤。然而，这意味着出生时体重为 2.49 公斤的婴儿与出生时体重为 1.0 公斤的婴儿相同，而出生时体重为 2.51 公斤的婴儿与出生时体重为 4 公斤的婴儿相同。事实显然并非如此。

出生体重的一个模型(由 SAS 提供，改编自 Koenker)包括孩子的性别、母亲的婚姻状况、母亲的种族、母亲的年龄(作为二次方)、她的教育状况、她是否进行过产前护理，如果是的话，在哪个孕期，她是否吸烟，如果是的话，每天吸多少烟，以及她的体重增加(作为二次方)。

母亲的婚姻状况被编码为已婚与未婚；种族要么是黑人要么是白人(不清楚其他种族的母亲是否被排除在外)，母亲的教育程度被编码为高中以下(参考类别)，高中毕业，某个学院，或大学毕业。产前护理编码为无、第一个三个月(参考类别)、第二个
三个月或第三个三个月。母亲的体重增加和年龄集中在方法上。

我们现在可以看看这些变量在每个分位数的影响。最好的方法可能是图形化。该程序的输出是常规回归的 9 倍长(因为我们有 9 个分位数),阅读起来很费力。但是，可以打印出来。下面显示的 SAS 代码生成四个图形面板。第一个面板:

First panel of quantile regression plots

显示截取的效果，母亲是黑人，母亲结婚，孩子是男孩。截距是未婚白人妇女所生女婴的每个分位数的*均出生体重，该妇女受教育程度不到高中，不吸烟，是*均年龄，体重*均增加。这些婴儿中只有大约 5%的体重低于 2500 克的标准体重。黑人女性所生的婴儿比白人女性所生的婴儿更轻，这种影响在低端比在其他地方更大——差异在 5%瓦片处约为 280 克，在中位数
处为 180 克，在 95%瓦片处为 160 克。母亲已婚的婴儿比母亲未婚的婴儿体重更重，而且这种影响在各个分位数上相对稳定。男孩比女孩重，这种影响在高端更大:在 5%的比例下，男孩比女孩重约 50 克，但在 95%的比例下，差异超过 100 克。

下一个面板:

2nd panel of quantile regression plots

显示了产前护理的效果，以及教育的第一部分，可以用与第一个面板相似的方式阅读。

第三个小组:

3rd panel of quantile regression plots

显示了其他教育影响和吸烟的影响。第四个也是最后一个面板:

4th panel of quantile regression plot

显示了母亲年龄和体重增加的影响。最后两个有点难以解释，因为与线性效应相比，二次效应总是如此。改善这种混乱的一种方法是绘制
不同母亲年龄或体重增加的婴儿出生体重预测图，保持其他变量的*均值或最常见值不变。下面是完成这项工作的 SAS 代码。母亲体重增加的结果:

Plot for maternal weight gain

这是一个迷人的图表！请注意，极端分位数是二次效应显著的分位数。进一步注意，体重减轻或大量增加的母亲比体重增加适度的母亲有更高的机会生下低体重婴儿。此外，体重增加较多的女性生下超大婴儿的几率更高。这种发现证实了医学观点，但不是我们可以用普通最小二乘回归发现的。

我们可以对母亲的年龄做同样的事情，但是年龄的影响不是很大，二次效应很小，我们可以考虑通过消除它来简化模型。另一方面，如果文献说母亲年龄应该有很强的二次效应，那么要么这个数据集有些奇怪，要么我们有证据反驳这种说法。需要注意的一点是，这个数据集涵盖了有限的年龄范围——所有的母亲都在 18 岁到 45 岁之间。年轻和年长的年龄可能会产生强烈的影响。

用于分析出生体重数据的 SAS 代码

程序 1:基本分位数回归

proc quantreg ci=sparsity/iid algorithm=interior(tolerance=1.e-4)
data=new;
class visit MomEdLevel;
model weight = black married boy visit MomEdLevel MomSmoke
cigsperday MomAge MomAge*MomAge
MomWtGain MomWtGain*MomWtGain/
quantile= 0.05 to 0.95 by 0.05
plot=quantplot;
run;

程序 2:创建二次曲线

获取预测值:

**proc quantreg ci=sparsity/iid algorithm=interior(tolerance=1.e-4)
data=new;
class visit MomEdLevel;
model weight = black married boy visit MomEdLevel MomSmoke
cigsperday MomAge MomAge*MomAge
MomWtGain MomWtGain*MomWtGain/
quantile= 0.05 to 0.95 by 0.05;
output out = predictquant p = predquant;
run;**

然后我们对其进行子集划分，只得到其他值是它们的均值或模式的情况。首先，对于产妇年龄:

**data mwtgaingraph;
set predictquant;
where black = 0 and married = 1 and boy = 1 and MomAge = 0 and MomSmoke = 0 and visit = 3 and MomEdLevel = 3;
run;** 

然后排序:

**proc sort data = mwtgaingraph;
by MomWtGain;
run;**

然后画出来。

**proc sgplot data = mwtgaingraph;
title ’Quantile fit plot for maternal weight gain’;
yaxis label = “Predicted birth weight”;
series x = MomWtGain y = predquant1 /curvelabel = “5 %tile”;
series x = MomWtGain y = predquant2/curvelabel = “10 %tile”;
series x = MomWtGain y = predquant5/curvelabel = “25 %tile”;
series x = MomWtGain y = predquant10/curvelabel = “50 %tile”;
series x = MomWtGain y = predquant15/curvelabel = “75 %tile”;
series x = MomWtGain y = predquant18/curvelabel = “90 %tile”;
series x = MomWtGain y = predquant19/curvelabel = “95 %tile”;
run;**

用于分位数回归的其他统计软件

我选择使用 SAS。但是，R 提供了 quantreg 包，Python 在 statsmodels 包中有分位数回归，STATA 有 qreg。其他软件也可能提供它。

结论

分位数回归对于不满足 OLS 回归假设的情况和感兴趣的是分位数的情况是一个有价值的工具。

Scikit Learn 简介:Python 机器学习的黄金标准

原文：https://towardsdatascience.com/an-introduction-to-scikit-learn-the-gold-standard-of-python-machine-learning-e2b9238a98ab?source=collection_archive---------9-----------------------

A comparison Scikit Learn’s many Machine Learning models

想获得灵感？快来加入我的 超级行情快讯 。😎

机器学习金牌

如果你打算用 Python 做机器学习， Scikit Learn 是金标准。Scikit-learn 提供了监督和非监督学习算法的广泛选择。最棒的是，它是迄今为止最简单、最干净的 ML 库。

Scikit learn 是以软件工程的思维方式创建的。它的核心 API 设计围绕着易于使用、功能强大，并且仍然保持研究工作的灵活性。这种健壮性使得它非常适合用于任何端到端的 ML 项目，从研究阶段一直到生产部署。

Scikit Learn 提供了什么

Scikit Learn 建立在几个常见的数据和数学 Python 库之上。这样的设计使得它们之间的集成变得非常容易。您可以将 numpy 数组和 pandas 数据帧直接传递给 Scikit 的 ML 算法！它使用以下库:

• NumPy :适用于任何矩阵运算，尤其是数学运算
• SciPy :科学技术计算
• :数据可视化
• IPython:Python 的交互控制台
• Sympy :符号数学
• 熊猫 :数据处理、操纵、分析

Scikit Learn 专注于机器学习，例如数据建模。It 与数据的加载、处理、操作和可视化无关。因此，对于那些额外的步骤，使用上面的库，尤其是 NumPy，是自然和常见的做法；他们是天生的一对！

Scikit 强大的算法产品包括:

• ****回归:拟合线性和非线性模型
• ****聚类:无监督分类
• ****决策树:用于分类和回归任务的树归纳和修剪
• ****神经网络:用于分类和回归的端到端训练。可以很容易地在元组中定义层
• ****支持向量机:用于学习决策边界
• ****朴素贝叶斯:直接概率建模

除此之外，它还有一些其他库通常不提供的非常方便和高级的功能:

• 集成方法: Boosting、Bagging、随机森林、模型投票和*均
• ****特征操作:降维、特征选择、特征分析
• ****异常值检测:用于检测异常值和剔除噪声
• ****模型选择和验证:交叉验证、超参数调整和指标

味觉测试

为了让您体验使用 Scikit Learn 来训练和测试 ML 模型是多么容易，这里有一个关于决策树分类器的示例。

在 Scikit Learn 中，用于分类和回归的决策树非常容易使用，内置了一个类。我们将首先加载我们的数据集，它实际上是内置在库中的。然后我们将初始化我们的分类决策树，这也是一个内置的类。跑步训练是一个简单的小程序！.fit(X, Y)函数训练模型，其中 X 是输入的 numpy 数组，而 Y 是相应的输出的 numpy 数组

Scikit Learn 还允许我们使用 graphviz 库可视化我们的树。它附带了一些选项，有助于可视化模型学习到的决策节点和拆分，这对理解其工作原理非常有用。下面我们将根据特性名称给节点着色，并显示每个节点的类别和特性信息。

除此之外，Scikit Learn 的文档非常精美！每个算法参数都有清晰的解释和直观的命名。此外，他们还提供带有示例代码的教程，介绍如何训练和应用该模型、其优缺点以及实际应用技巧！

喜欢学习？

在 twitter 上关注我，我会在这里发布所有最新最棒的人工智能、技术和科学！也在 LinkedIn 上与我联系！

用 Python 例子介绍 t-SNE

原文：https://towardsdatascience.com/an-introduction-to-t-sne-with-python-example-5a3a293108d1?source=collection_archive---------0-----------------------

简介

我一直对学习充满热情，并认为自己是一个终身学习者。作为一名数据科学家，在 SAS 工作让我能够学习和尝试我们定期向客户发布的新算法和功能。通常，算法在技术上并不新，但对我来说是新的，这让我觉得很有趣。

最*，我有机会了解更多关于 t 分布随机邻居嵌入(t-SNE)的知识。在这篇文章中，我将给出 t-SNE 算法的一个高层次的概述。我还将分享一些示例 python 代码，其中我将对数字和 MNIST 数据集使用 t-SNE。

什么是 SNE 霸王龙？

t-分布式随机邻居嵌入(t-SNE)是一种无监督的非线性技术，主要用于数据探索和可视化高维数据。更简单地说，t-SNE 给你一种感觉或直觉，告诉你数据是如何在高维空间中排列的。它是由劳伦斯·范德·马滕斯和杰弗里·辛顿在 2008 年开发的。

t-SNE vs PCA

如果你熟悉主成分分析 (PCA)，那么和我一样，你可能想知道 PCA 和 t-SNE 之间的区别。首先要注意的是，PCA 是在 1933 年开发的，而 t-SNE 是在 2008 年开发的。自 1933 年以来，数据科学领域发生了很多变化，主要是在计算和数据规模方面。第二，PCA 是一种线性降维技术，它寻求最大化方差并保持大的成对距离。换句话说，不同的事物最终会相距甚远。这可能导致较差的可视化，尤其是在处理非线性流形结构时。把流形结构想象成任何几何形状，比如:圆柱形、球形、曲线形等等。

t-SNE 不同于 PCA，它只保留小的成对距离或局部相似性，而 PCA 关心的是保留大的成对距离以最大化方差。劳伦斯使用图 1 [1]中的瑞士滚动数据集很好地说明了 PCA 和 t-SNE 方法。您可以看到，由于这个玩具数据集(流形)的非线性和保留大距离，PCA 将错误地保留数据的结构。

Figure 1 — Swiss Roll Dataset. Preserve small distance with t-SNE (solid line) vs maximizing variance PCA [1]

t-SNE 的工作原理

现在我们知道了为什么我们可能使用 SNE 霸王龙而不是 PCA，让我们讨论一下 SNE 霸王龙是如何工作的。t-SNE 算法计算高维空间和低维空间中的实例对之间的相似性度量。然后，它尝试使用成本函数来优化这两个相似性度量。让我们把它分成 3 个基本步骤。

1.步骤 1，度量高维空间中的点之间的相似性。想象一下散布在 2D 空间中的一堆数据点(图 2)。对于每个数据点(xi ),我们将在该点上以高斯分布为中心。然后，我们测量高斯分布下所有点的密度(xj)。然后对所有点进行重正化。这给了我们所有点的一组概率(Pij)。这些概率与相似性成正比。这意味着，如果数据点 x1 和 x2 在这个高斯圆下有相等的值，那么它们的比例和相似性是相等的，因此你在这个高维空间的结构中有局部相似性。高斯分布或圆可以使用所谓的困惑进行操作，这将影响分布的方差(圆的大小)以及最*邻的数量。困惑的正常范围在 5 到 50 之间[2]。

Figure 2 — Measuring pairwise similarities in the high-dimensional space

2.第 2 步与第 1 步类似，但不是使用高斯分布，而是使用一个自由度的学生 t 分布，也称为柯西分布(图 3)。这给了我们低维空间中的第二组概率(Qij)。正如你所看到的，学生 t 分布比正态分布有更重的尾部。厚重的尾部可以更好地模拟相距较远的距离。

Figure 3 — Normal vs Student t-distribution

3.最后一步是，我们希望这些来自低维空间(Qij)的概率集尽可能好地反映高维空间(Pij)的概率集。我们希望这两个映射结构相似。我们使用 Kullback-Liebler 散度(KL)来度量二维空间的概率分布之间的差异。我不会过多地讨论 KL，只知道它是一种不对称的方法，可以有效地比较大的 Pij 和 Qij 值。最后，我们使用梯度下降来最小化我们的 KL 成本函数。

t-SNE 的使用案例

现在你知道了 t-SNE 是如何工作的，让我们快速讨论一下它在哪里使用。Laurens van der Maaten 在他的视频演示中展示了许多例子[1]。他提到了 t-SNE 在气候研究、计算机安全、生物信息学、癌症研究等领域的应用。t-SNE 可以用于高维数据，然后这些维度的输出成为其他分类模型的输入。

此外，t-SNE 可以用来调查，学习，或评估分割。很多时候，我们在建模之前选择分段的数量，或者在结果之后迭代。t-SNE 常常能在数据中显示出清晰的分离。这可以在使用您的分段模型选择聚类数之前使用，或者在评估您的分段实际上是否成立之后使用。然而，t-SNE 不是一种聚类方法，因为它不像 PCA 那样保留输入，并且值可能经常在运行之间改变，所以它纯粹是为了探索。

代码示例

下面是一些 python 代码(下图带有 GitHub 的链接)，在这里你可以看到 PCA 和 t-SNE 在数字和 MNIST 数据集上的可视化比较。我选择这两个数据集是因为维度的不同，因此结果也不同。我还在代码中展示了一项技术，您可以在运行 t-SNE 之前运行 PCA。这样做可以减少计算量，你通常会减少到 30 维左右，然后运行 t-SNE。

我使用 python 并调用 SAS 库来运行这个。它可能看起来与你习惯的略有不同，你可以在下面的图片中看到。我用 Seaborn 来做我的视觉效果，我认为这很棒，但是用 t-SNE 你可能会得到非常紧凑的集群，需要放大。如果您需要放大或操纵绘图对象，另一个可视化工具(如 Plotly)可能会更好。此外，假设您使用 Matplotlib，那么在绘图之前进行简单的%matplotlib notebook调用也是可行的。

在 GitHub 查看完整的笔记本，这样你就可以看到中间的所有步骤并获得代码:

步骤 1——加载 Python 库。创建到 SAS 服务器的连接(称为“CAS”，它是一个分布式内存引擎)。加载 CAS 动作集(把它们想象成库)。读入数据并查看形状。

第 2 步——到目前为止，我仍然在我的本地机器上工作。我将把这些数据加载到我提到的 CAS 服务器中。这有助于我利用分布式环境并提高性能效率。然后我对数字和 MNIST 数据进行主成分分析。

第 3 步——可视化两位数和 MNIST 的 PCA 结果

PCA actually does a decent job on the Digits dataset and finding structure

As you can see PCA on the MNIST dataset has a ‘crowding’ issue

步骤 4——现在让我们尝试与上面相同的步骤，但是使用 t-SNE 算法

现在是 MNIST 数据集…

结论

我希望你喜欢这个概述和 t-SNE 算法的例子。我发现 t-SNE 是一个非常有趣和有用的可视化工具，因为几乎所有我处理过的数据都是高维的。我会把我发现的超级有用的资源贴在下面。对我来说，最好的资源是劳伦斯的 YouTube 视频。差不多 1 个小时，有点长，但是解释得很好，我找到了最清晰的详细解释。

我发现有用的其他资源:

1.t-SNE vs PCA:https://www . quora . com/What-advantages-the-t-SNE 算法优于 PCA

2.kull back-Liebler Divergence:https://en . Wikipedia . org/wiki/kull back % E2 % 80% 93 lei bler _ Divergence

3.t-SNE 维基百科:https://en . Wikipedia . org/wiki/T-distributed _ random _ neighbor _ embedding

4.t-SNE 演练:https://www . analyticsvidhya . com/blog/2017/01/t-SNE-implementation-r-python/

5.好的超参数信息:https://distill.pub/2016/misread-tsne/

6.劳伦·范德·马腾的 GitHub 页面:https://lvdmaaten.github.io/tsne/

7.t-SNE 动作集和信用的 SAS 开发者: Jorge Silva

参考文献

1.YouTube。(2013 年 11 月 6 日)。使用 t-SNE[视频文件]可视化数据。从 https://www.youtube.com/watch?v=RJVL80Gg3lA取回

2.范德马滕和辛顿。使用 t-SNE 可视化高维数据。机器学习研究杂志 9(十一月):2579–2605，2008。

MXNet API 介绍—第 4 部分

原文：https://towardsdatascience.com/an-introduction-to-the-mxnet-api-part-4-df22560b83fe?source=collection_archive---------0-----------------------

在第三部中，我们建立并训练了我们的第一个神经网络。我们现在知道的足够多，可以举更高级的例子。

最先进的深度学习模型非常复杂。他们有数百层，需要几天——如果不是几周——来训练大量的数据。构建和调整这些模型需要大量的专业知识。

幸运的是，使用这些模型要简单得多，只需要几行代码。在本文中，我们将使用一个名为 Inception v3 的预训练图像分类模型。

盗梦空间 v3

Inception v3 发布于 2015 年 12 月，是 GoogleNet 模型的一个进化版本(该模型赢得了 2014 ImageNet 挑战赛)。我们不会深入研究论文的细节，但转述其结论，Inception v3 比当时可用的最佳模型精确 15-25%，同时在计算上便宜 6 倍，使用的参数至少少 5 倍(即使用模型需要更少的 RAM)。

那真是一头野兽。那么我们如何让它发挥作用呢？

MXNet 模型动物园

模型动物园是一群预先训练好的模型随时可以使用。你会发现模型定义、模型参数(即神经元权重)和指令(可能)。

让我们下载定义和参数(您可能需要更改文件名)。随意打开第一个文件:你会看到所有层的定义。第二个是二进制文件，别管它；)

$ wget [http://data.dmlc.ml/models/imagenet/inception-bn/Inception-BN-symbol.json](http://data.dmlc.ml/models/imagenet/inception-bn/Inception-BN-symbol.json)$ wget [http://data.dmlc.ml/models/imagenet/inception-bn/Inception-BN-0126.params](http://data.dmlc.ml/models/imagenet/inception-bn/Inception-BN-0126.params)$ mv Inception-BN-0126.params Inception-BN-0000.params

由于这个模型已经在 ImageNet 数据集上训练过，我们还需要下载相应的图像类别列表(其中 1000 个)。

$ wget [http://data.dmlc.ml/models/imagenet/synset.txt](http://data.dmlc.ml/models/imagenet/synset.txt)$ wc -l synset.txt
    1000 synset.txt$ head -5 synset.txt
n01440764 tench, Tinca tinca
n01443537 goldfish, Carassius auratus
n01484850 great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
n01491361 tiger shark, Galeocerdo cuvieri
n01494475 hammerhead, hammerhead shark

好了，完成了。现在我们开始工作吧。

加载模型

我们需要做的是:

• 从保存的状态加载模型:MXNet 称之为检查点。作为回报，我们得到输入符号和模型参数。

import mxnet as mx

sym, arg_params, aux_params = mx.model.load_checkpoint('Inception-BN', 0)

• 创建一个新的模块，并将其指定为输入符号。我们还可以使用一个上下文参数来指示我们想要在哪里运行模型:默认值是 cpu(0) ，但是我们将使用 gpu(0) 在 gpu 上运行它。

mod = mx.mod.Module(symbol=sym)

• 将输入符号*绑定到输入数据。我们称它为‘data ’,因为这是它在网络的输入层中的名字(请看 JSON 文件的前几行)。*
• 将“数据”的形状定义为 1 x 3 x 224 x 224。不要慌；)‘224 x 224’是图像分辨率，模型就是这么训练的。‘3’是通道数:红、绿、蓝(按此顺序)。“1”是批量大小:我们将一次预测一个图像。

mod.bind(for_training=False, data_shapes=[('data', (1,3,224,224))])

• 设置模型参数。

mod.set_params(arg_params, aux_params)

这就够了。四行代码！现在需要把一些数据放进去，看看会发生什么。嗯……还没有。

准备我们的数据

数据准备:让我们的生活变得悲惨自从七十年代以来…从关系数据库到机器学习到深度学习，在这方面没有什么真正改变。很无聊但是很有必要。让我们完成它。

请记住，该模型需要一个 4 维的n 数组来保存一张 224 x 224 图像的红色、绿色和蓝色通道。我们将使用流行的 OpenCV 库从我们的输入图像构建这个n 数组。如果没有安装 OpenCV，运行“pip install OpenCV-python”在大多数情况下应该足够了:)

以下是步骤:

• ****读取图像:这将返回一个 numpy 数组，形状为(图像高度，图像宽度，3)，三个通道按照 BGR 的顺序排列(蓝、绿、红)。

img = cv2.imread(filename)

• ****将图像转换为 RGB 。

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

• ****将图像调整到 224 x 224 。

img = cv2.resize(img, (224, 224,))

• ****将数组从(图像高度，图像宽度，3)整形为(3，图像高度，图像宽度)。

img = np.swapaxes(img, 0, 2)
img = np.swapaxes(img, 1, 2)

• 添加一个第四维并构建n 数组

img = img[np.newaxis, :]
array = mx.nd.array(img)>>> print array.shape
(1L, 3L, 224L, 224L)

头晕？让我们看一个例子。这是我们的输入图片。

Input picture 448x336 (Source: metaltraveller.com)

一旦经过处理，这张图片已经被调整大小并被分割成 RGB 通道，存储在数组【0】(这里的是用来生成下面图像的代码)。

array0 : 224x224 red channel

array[0][1] : 224x224 green channel

array[0][2] : 224x224 blue channel

如果批处理大小大于 1，那么我们将在数组【1】中有第二个图像，在数组【2】中有第三个图像，依此类推。

这很有趣吗？现在我们来预测一下！

预测

您可能还记得第三部分中的内容，一个模块对象必须在批次中向一个模型提供数据:通常的做法是使用一个数据迭代器(具体来说，我们使用了一个 NDArrayIter 对象)。

在这里，我们想要预测一个单个图像，所以尽管我们可以使用数据迭代器，但这可能是多余的。相反，我们将创建一个名为 tuple 的，名为 Batch ，当它的数据属性被引用时，它将通过返回我们的输入 NDArray 来充当伪迭代器。****

from collections import namedtuple
Batch = namedtuple('Batch', ['data'])

现在我们可以把这个“批”传递给模型，让它预测。

mod.forward(Batch([array]))

该模型将输出一个n 数组，包含 1000 个概率，对应于 1000 个类别。它只有一行，因为批大小等于 1。

prob = mod.get_outputs()[0].asnumpy()>>> prob.shape
(1, 1000)

让我们用挤压()把这个变成一个数组。然后，使用 argsort ()，我们创建第二个数组，保存这些概率的索引，按照降序排序。

prob = np.squeeze(prob)>>> prob.shape
(1000,)
>> prob
[  4.14978594e-08   1.31608676e-05   2.51907986e-05   2.24045834e-05
   2.30327873e-06   3.40798979e-05   7.41563645e-06   3.04062659e-08 *etc.*sortedprob = np.argsort(prob)[::-1]>> sortedprob.shape
(1000,)

根据模型，这张图最有可能的类别是 #546 ，概率 58% 。

>> sortedprob
[546 819 862 818 542 402 650 420 983 632 733 644 513 875 776 917 795
*etc.* >> prob[546]
0.58039135

让我们找到这个类别的名称。使用 synset.txt 文件，我们可以构建一个类别列表，并在索引 546 处找到它。

synsetfile = open('synset.txt', 'r')
categorylist = []
for line in synsetfile:
  categorylist.append(line.rstrip())>>> categorylist[546]
'n03272010 electric guitar'

第二高的类别呢？

>>> prob[819]
0.27168664
>>> categorylist[819]
'n04296562 stage

很好，你不觉得吗？

所以你走吧。现在你知道如何使用一个预先训练好的，最先进的模型进行图像分类。它只需要 4 行代码 …剩下的只是数据准备。

你可以在下面找到完整的代码。玩得开心，请继续关注:D

接下来:

• 第 5 部分:更多预训练模型(VGG16 和 ResNet-152)
• 第 6 部分:树莓 Pi 上的实时物体检测(它还会说话！)

如何使用 Selenium 和 Docker 刮测网站

原文：https://towardsdatascience.com/an-introduction-to-web-browser-automation-with-selenium-and-docker-containers-c1bcbcb91540?source=collection_archive---------2-----------------------

你想不费吹灰之力就能访问大量数据并测试你的网站吗？你是否有堆积如山的计算机程序可以处理的在线繁重工作？然后你需要浏览器自动化和 Selenium WebDriver 。Selenium 是测试和抓取 Javascript 呈现的网页的首要工具，本教程将涵盖在任何操作系统上设置和使用它所需的一切。Selenium 依赖项可以下载到运行在 Linux 虚拟机上的 Docker 容器中；因此，这些技术被介绍和讨论。最后，介绍了 Docker 中的编程，以及设置 Selenium 并将其绑定到 RStudio 的分步协议。准备好进入浏览器自动化的世界吧，在那里你单调乏味的任务将被委托给一个守护进程，你的前额叶官能将被解放出来专注于哲学。

为什么

为什么要用 Selenium 来自动化浏览器？

为什么要使用 Selenium 来自动化 web 浏览器？如上所述，两个主要原因是 web 测试和数据抓取。如果没有网络测试，像苹果这样的公司的程序员将无法在新功能上线前检查它们是否如预期那样工作，这可能会给用户带来不幸的错误，(就像发生在 iOS 12 T21 更新中的那些错误一样)。虽然当苹果这样的公司发布有问题的软件时，客户通常会感到震惊，但 iPhone 的复杂性和每次更新的新功能或更新功能的数量(iOS 12 几乎有 100 个)至少极有可能发生一些事故。不仅每个新组件都必须测试，而且它与手机其他部分的交互也必须检查。

然而，通过彻底的测试可以避免错误，这就是浏览器自动化的用武之地。虽然手动测试仍然是测试协议不可或缺的组成部分，但是完全手动测试如此多的复杂功能及其交互是不切实际的。有了浏览器自动化，用例可以在不同的环境中被测试成千上万次，从而找出只在不寻常的情况下才会出现的错误。然后，当苹果推出另一个重大更新时，它可以重新运行一个保存的测试协议，而不是设计一个新的，称为回归测试。因此，自动化测试允许公司提高客户满意度并避免错误。

Photo by Jeremy Bezanger on Unsplash

在编程环境中驱动 web 浏览器的第二个原因是 web 抓取，这是从 web 页面中提取内容以便在您自己的项目或应用程序中使用的过程。虽然 web 抓取可以在没有 Selenium 这样的 web 驱动程序的情况下执行，但这种工具的功能是有限的。这些“无驱动”包，包括 R 中的 Rvest 和 Python 中的 beautiful soup ，不能在浏览器中执行 Javascript，因此不能访问任何 Javascript 渲染的元素。虽然他们可以下载一个网站的源代码作为 HTML 文档，但是他们不能访问任何来自用户交互的数据。这是由于 HTML、CSS 和 Javascript 合作构建现代网页的特殊方式。

当你第一次打开一个网站时，你看到的内容来自于它的源代码，在谷歌 Chrome 中按 Ctrl+Shift+I 就可以随时查看，这个源代码主要是用 HTML 和 CSS 编写的，前者负责网站的结构，后者负责网站的风格。虽然对 HTML 和 CSS 的详细讨论超出了本文的范围，但我们需要知道的是， HTML 标签和 CSS 选择器格式化 web 元素，两者的结合赋予每个 web 元素自己唯一的标识符。这些唯一的标识符允许无驱动 web 抓取器区分 web 元素，并仅从源代码中提取相关信息。

然而，当用户与网站交互时，Javascript 会形成新元素并改变现有元素。这些元素不包含在页面的源代码中，因此不能被上面提到的包访问。例如，大多数网站要求用户在访问信息前登录，这意味着登录后的一切都将超出无人驾驶网络抓取器的范围。如果互联网真的是“信息高速公路”，源代码只是一个入口，它在入口就结束了。有了 Selenium，只要我们知道如何驾驶，我们就可以驶向目的地数据，人口无限。

Photo by Nick Fewings on Unsplash

怎么做

虚拟机和容器

Selenium 不能简单地下载和运行，因为它需要 1)特定的库和 2)特定的操作系统(例如，它不能在 OS X 上运行)。虽然在过去虚拟机(VM)提供了这样的依赖关系，但是今天使用容器和 Docker 的组合要高效得多。为了理解为什么，我们首先需要回顾一下这些工具的用途和基础。

虚拟机是一台计算机在另一台计算机中的模拟。一台主机内可以运行多个虚拟机，主机和仿真之间的交互由一个 虚拟机管理程序 管理。因为虚拟机包含了物理计算机所做的一切，所以它们经常被用来" T6 "测试新的操作系统(OS ),而不必购买新的硬件。其原因是，尽管许多人认为操作系统实际上是可以互换的，但它们之间可能存在显著差异。操作系统不仅仅是主板上的一个徽章；相反，它是您必须用来让硬件做您想要做的事情的工具集。如果操作者是一个画家，那么操作系统就是画笔，是从思想到现实的翻译者，可以限制或扩展可能性。因此，由于您选择的操作系统可能会产生深远的影响，因此轻松测试新操作系统的能力是非常宝贵的。

虽然虚拟机对于测试新的操作系统仍然有用，但是容器是为软件提供库的更好的方法。因为你下载的每个 VM 都有自己的操作系统，使用一个来简单地提供库就像为周末野营旅行打包你的整个衣柜:当然你可能有你需要的一切，但是四个纽带和翼尖看起来肯定是多余的。(也许就拿四分之一布洛克鞋吧，老兄。)这就是容器的用武之地。如果虚拟机是贪婪的过度包装者，容器就是残酷的随身携带的填鸭式包装，因为每个容器只带有运行一个软件所必需的库。机器上的每个容器共享 1 (Linux) OS ，这大大减少了它们的存储空间和运行时间。但是他们从哪里得到这个 Linux 操作系统来运行呢？这就是 Docker 的用武之地。

码头工人

Docker 是运行和分发容器的领先软件，它的主要目的是提供容器运行的 Linux 操作系统。这个 Linux 操作系统在 Windows 和 Mac 中由每个操作系统的本机管理程序管理(分别是 Hyper-V 和 HyperKit )。因此，在启动和运行时，容器可以利用 Linux 操作系统的各个方面，包括它的文件系统和内核。两个重要的 Linux 组件，守护进程和命令行接口(CLI) ，共同组成了 Docker 引擎 ，它用于执行容器的大部分任务。docker 守护进程是一个在后台运行的服务器，等待特定的事件或者用户调用它。当我们想要在 Docker 中完成一些事情时，我们使用 CLI 向守护进程(也称为dockerd)发送消息。调用 Docker 守护进程的命令称为 Docker 命令，它们的使用遵循一个通用模板，我将在下面介绍。

大多数 docker 命令包含一个动作，一个路径，和选项。****动作被写成 docker，后跟我们希望守护进程做的事情。例如，如果我们希望守护进程启动一个容器，它必须运行一个映像，所以动作是docker run。(图像只是一个文件，当它被执行时，启动容器——如果容器是一个蛋糕，那么图像就是食谱。)路径指定了我们希望守护进程对哪个文件执行操作，以及文件的位置。在docker run中，路径将告诉守护程序在哪里可以找到图像，(默认情况下是 Docker Hub ，Docker 的基于云的图像存储库以及图像文件的名称。如果一个文件有不同的版本，可以通过提供一个标签来选择一个；如果未指定标签，则自动提取最新版本。最后，选项修改命令。以docker run为例，有数百个选项(你可以在它的参考页上看到)。虽然您可以忽略或使用大多数的缺省值，但是有些确实需要指定，正如我们将在下面看到的。

docker 运行中的选项

因为docker run启动我们的容器，所以它是最重要的 Docker 命令之一。因此，它有如此多的选择是有道理的。这可能会使代码看起来复杂，正如您在下面启动 Selenium ChromeDriver 的示例中看到的那样:

docker run -d -v LOCAL_PATH://home/seluser/Downloads -p 4445:4444 — shm-size = 2g — name YOUR_CONTAINER_NAME selenium/standalone-chrome

事实上，上面的代码非常简单，在动作和路径之间只指定了 5 个选项。下面我们来回顾一下这 5 个选项。

1. -d 选项告诉容器以分离模式运行，这意味着在后台运行。这使得应用程序的输出保持隐藏，允许我们继续使用终端。
2. **-v** 选项被称为绑定挂载，对于数据抓取是必不可少的。这个选项告诉 Docker 将容器运行所在的 Linux VM 中的某个目录绑定到主机(即我们的家庭计算机)中的某个文件夹。这意味着下载到那个 Linux 目录的任何东西都将被转移到我们在机器上指定的文件夹中。当你关闭 Docker 和你正在运行的容器时，保存到它们的数据不会持久，所以这是保存我们数据的一个非常重要的步骤！(另一个选项是使用永久卷。)要使用-v选项，首先在您的家庭计算机上指定您想要将数据转移到的文件夹，然后在 Linux VM 上指定您想要使用的目录，用冒号分隔。当您真正开始运行 Selenium 时，请确保让您的代码将数据保存到您指定的 Linux 目录中！
3. **— shm-size** 选项增加了/dev/shm 目录的大小，这是一个临时文件存储系统。这是因为容器上的默认共享内存对于 Chrome 来说太小了。在这次 github 讨论之后，我成功地将大小设置为 2g。
4. -p 选项指定容器和 Linux VM 应该通过哪些端口连接。我们首先在 Linux VM 上指定端口，然后在容器上指定端口。Selenium 映像默认公开端口 4444 ，这里我们使用 4445 作为主机端口。当我们稍后将 Linux VM 和其中的 Selenium 容器绑定到 RStudio 时，我们将使用这个面向外部的端口 4445。
5. **— name**选项允许我们给容器一个特定的名称。如果我们不指定名称，Docker 将使用其默认命名系统为我们的容器命名，这实际上非常酷。UUID 是一长串难以阅读和记忆的数字和字母，Docker 没有使用它，而是随机合并一个形容词和一位著名的科学家，不知何故,组合总是很吸引人。(在一个名为 kickass_chandrasekhar 的容器中编码感觉也很好。)

就是这样！这 5 个选项是你创建上面复杂的docker run命令所需要的。

既然我们已经牢牢掌握了 Selenium、VMs、containers 和 Docker，是时候最终下载并设置 Selenium ChromeDriver 了。我们走吧！

下载和设置 Docker 和 Selenium ChromeDriver 的步骤

1. 下载适合您的操作系统和工作类型(商务、个人等)的 Docker 版本。).Docker 同时提供企业和社区版 s (CE)。对于那些想更深入了解容器的人来说，莫比把容器的组件分开，允许用户像组装乐高玩具一样单独组装。对于我们的目的来说，Docker CE 可以很好地工作。
2. 下载T22chrome driver。
3. 在 Windows 中，您需要确保启用了虚拟化，以便 Docker 可以启动 Linux VM。您可以通过导航到 BIOS 并启用虚拟化来实现这一点(在 BIOS 中称为 VT-AMD)。(要访问 BIOS，请在 Windows 启动时按 F10，然后转到系统配置。)
4. 执行安装和设置 Docker 的步骤。最后，码头工人的特色鲸鱼将出现在码头。
5. 通过在终端中键入docker pull selenium/standalone-chrome来获取 Selenium ChromeDriver 的图像。因为我们没有指定版本，所以将提取最新的版本。你应该看到Using default tag: latest: Pulling from selenium/standalone-chrome。然后你会看到Status: Downloaded newer image for selenium/standalone-chrome:latest
6. 使用上面的命令运行 Selenium Chromedriver。记得用您想要使用的文件夹和名称替换 LOCAL_PATH 和 YOUR_CONTAINER_NAME。

docker run -d -v LOCAL_PATH://home/seluser/Downloads -p 4445:4444 — shm-size = 2g — name YOUR_CONTAINER_NAME selenium/standalone-chrome

现在我们已经设置并运行了 Docker，我将向您展示如何使用 RSelenium 将它绑定到 RStudio。如果你不是 R 用户，有关于如何将 Selenium 绑定到其他编程语言的文章，比如 Python 和 Ruby ，或者你可以简单地在 Docker CLI 中编写脚本。

下载硒元素

1. 在 RStudio 的控制台中键入install.packages(RSelenium。
2. 然后:library(RSelenium)
3. 设置 Chrome 驱动程序的选项。还有其他的可以设置，但是这三个是必不可少的。第一个将阻止弹出窗口，第二个将确保文件下载不需要您的提示，第三个将决定下载文件的最终位置(应该是您之前在docker run中指定的 Linux VM 中的目录)。

eCaps <- list(
 chromeOptions = 
 list(prefs = list(
 “profile.default_content_settings.popups” = 0L,
 “download.prompt_for_download” = FALSE,
 “download.default_directory” = “home/seluser/Downloads”
 )
 )
)

4.创建从 R 到 Linux 虚拟机的绑定。浏览器名称是 Chrome，端口是在docker run中指定的端口，extra capabilities是在上面的步骤 3 中指定的，而remoteServerAddr是 Linux VM 的 IP。

remDr <- remoteDriver(browserName= “chrome”, port=4445L, extraCapabilities = eCaps, remoteServerAddr = "192.168.99.100",)

5.最后，键入remDr$open将把 R 绑定到虚拟 OS。在您的全球环境中，您应该看到 remDr 是一个<Object containing active binding>。

那都是乡亲们！现在，您已经准备好开始使用 Docker 进行令人惊叹的 web 测试和数据抓取项目了！非常感谢您的阅读，如果有任何问题，请随时关注我的 twitter 账号@halfinit。下次见！

Python 网页抓取简介

原文：https://towardsdatascience.com/an-introduction-to-web-scraping-with-python-a2601e8619e5?source=collection_archive---------1-----------------------

让我们用 BeautifulSoup 刮一个虚构的书店网站吧！

Photo by Darwin Vegher on Unsplash

介绍

作为一名数据科学家，我经常发现自己在寻找可能与我的机器学习项目相关的外部数据源。问题是，很难找到与您所寻找的完全对应的开源数据集，或者允许您访问数据的免费 API。在这种情况下，web 抓取可以成为获取更多数据的一种解决方案。

什么是网页抓取？

网络搜集包括收集网站上的可用数据。这可以由人类用户或机器人手动完成。后者当然可以比人类用户更快地收集数据，这就是为什么我们要关注这一点。因此，这种机器人在几分钟内收集一个网站的所有数据在技术上是可能的吗？然而，这种做法的合法性没有明确界定。网站通常会在使用条款和 robots.txt 文件中说明是否允许使用刮刀。

它是如何工作的？

网页抓取器收集网站数据的方式与人类相同:抓取器进入网站的网页，获取相关数据，然后前进到下一个网页。每个网站都有不同的结构，这就是为什么网站抓取器通常是用来搜索一个网站的。在 web 刮刀的实现过程中出现的两个重要问题如下:

• 包含相关数据的网页的结构是什么？
• 我们如何能到达那些网页？

为了回答这些问题，我们需要了解一点网站是如何工作的。网站是使用 HTML(超文本标记语言)以及 CSS(层叠样式表)和 JavaScript 创建的。HTML 元素由标签分隔，它们直接将内容引入网页。下面是一个基本 HTML 文档的样子:

Basic HTML page

我们可以看到第一个标题的内容包含在“h1”标记之间。第一段包含在“p”标记之间。在真实的网站上，我们需要找出相关数据在哪些标签之间，并告诉我们的刮刀。我们还需要指定应该浏览哪些链接，以及它们在 HTML 文件中的位置。有了这些信息，我们的刮刀应该能够收集所需的数据。

我们要用什么工具？

在本教程中，我们将使用 Python 模块 requests 和 BeautifulSoup。

请求将允许我们发送 HTTP 请求来获取 HTML 文件。

申请文件链接:http://docs.python-requests.org/en/master/

Requests module

BeautifulSoup 将用于解析 HTML 文件。这是最常用的网页抓取库之一。它使用起来非常简单，并且有许多功能可以帮助有效地收集网站数据。

链接到 BeautifulSoup 文档:https://www.crummy.com/software/BeautifulSoup/bs4/doc/

BeautifulSoup module

先决条件

• python 2.7
• 要求
• beautifulsoup4
• 熊猫

目标

我们要刮一个网上书店的数据:【http://books.toscrape.com/

这个网站是虚构的，所以我们可以随意抓取。

在本教程中，我们将收集网站所有产品的以下信息:

• 书名
• 价格
• 有效性
• 图像
• 种类
• 等级

预热:获取主页的内容

首先，让我们使用请求模块来获取网站主页的 HTML。

u'<!DOCTYPE html>\n<!--[if lt IE 7]>      <html lang="en-us" class="no-js lt-ie9 lt-ie8 lt-ie7"> <![endif]-->\n<!--[if IE 7]>         <html lang="en-us" class="no-js lt-ie9 lt-ie8"> <![endif]-->\n<!--[if IE 8]>         <html lang="en-us" class="no-js lt-ie9"> <![endif]-->\n<!--[if gt IE 8]><!--> <html lang="en-us" class="no-js"> <!--<![endif]-->\n    <head>\n        <title>\n    All products | Books to Scrape - Sandbox\n</title>\n\n        <meta http-equiv="content-type" content="text/html; charset=UTF-8" />\n        <meta name="created" content="24th Jun 2016 09:29" />\n        <meta name="description" content="" />\n        <meta name="viewport" content="width=device-width" />\n        <meta name="robots" content="NOARCHIVE,NOCACHE" />\n\n        <!-- Le HTML5 shim, for IE6-8 support of HTML elements -->\n        <!--[if lt IE 9]>\n        <script src="//html5shim.googlecode.com/svn/trunk/html5.js"></script>\n        <![endif]-->\n\n        \n            <link rel="shortcut icon" href="static/oscar/favicon.'

结果还挺乱的！让我们让这更具可读性:

<html class="no-js" lang="en-us">
 <!--<![endif]-->
 <head>
  <title>
   All products | Books to Scrape - Sandbox
  </title>
  <meta content="text/html; charset=utf-8" http-equiv="content-type"/>
  <meta content="24th Jun 2016 09:29" name="created"/>
  <meta content="" name="description"/>
  <meta content="width=device-width" name="viewport"/>
  <meta content="NOARCHIVE,NOCACHE" name="robots"/>
  <!-- Le HTML5 shim, for IE6-8 support of HTML elements -->
  <!--[if lt IE 9]>
        <script src="//html5shim.googlecode.com/svn/trunk/html5.js"></script>
        <![endif]-->
  <link href="static/oscar/favicon.ico" rel="shortcut icon"/>
  <link href="static/oscar/css/styles.css" rel="stylesheet" type="tex

函数pretify()使 HTML 更具可读性。但是，我们不会直接使用它来探索相关数据在哪里。

让我们定义一个函数来请求和解析一个 HTML 网页，因为在本教程中我们会经常用到它:

在主页上查找图书 URL

现在让我们开始更深入地探讨这个问题。为了获得图书数据，我们需要能够访问他们的产品页面。第一步是找到每本书产品页面的 URL。

在浏览器中，进入网站主页，右键单击产品名称，然后单击 inspect。这将向您显示对应于该元素的网页的 HTML 部分。恭喜你，你已经找到了第一个图书链接！

请注意 HTML 代码的结构:

Inspecting HTML code

你可以对页面上的其他产品进行尝试:结构总是一样的。产品的链接对应于“a”标签的“href”属性。这属于 a 类值为“product_pod”的“article”标记。这似乎是发现产品网址的可靠来源。

BeautifulSoup 使我们能够找到那些特殊的“文章”标签。我们可以屏蔽 find() 函数，以便在 HTML 中找到这个标签的第一次出现:

<article class="product_pod">\n<div class="image_container">\n<a href="catalogue/a-light-in-the-attic_1000/index.html"><img alt="A Light in the Attic" class="thumbnail" src="media/cache/2c/da/2cdad67c44b002e7ead0cc35693c0e8b.jpg"/></a>\n</div>\n<p class="star-rating Three">\n<i class="icon-star"></i>\n<i class="icon-star"></i>\n<i class="icon-star"></i>\n<i class="icon-star"></i>\n<i class="icon-star"></i>\n</p>\n<h3><a href="catalogue/a-light-in-the-attic_1000/index.html" title="A Light in the Attic">A Light in the ...</a></h3>\n<div class="product_price">\n<p class="price_color">\xc2\xa351.77</p>\n<p class="instock availability">\n<i class="icon-ok"></i>\n    \n        In stock\n    \n</p>\n<form>\n<button class="btn btn-primary btn-block" data-loading-text="Adding..." type="submit">Add to basket</button>\n</form>\n</div>\n</article>

我们还有太多的信息。

让我们通过添加其他子标签来更深入地研究树:

<a href="catalogue/a-light-in-the-attic_1000/index.html"><img alt="A Light in the Attic" class="thumbnail" src="media/cache/2c/da/2cdad67c44b002e7ead0cc35693c0e8b.jpg"/></a>

好多了！但是我们只需要包含在' href '值中的 URL。

我们可以通过相加。get("href ")到上一条指令:

u'catalogue/a-light-in-the-attic_1000/index.html'

好了，我们设法用 BeautifulSoup 得到了我们的第一个产品 URL。

现在让我们使用 findAll() 函数一次性收集主网页上所有产品的 URL:

20 fetched products URLs
One example:
u'catalogue/a-light-in-the-attic_1000/index.html'

这个函数对于一次找到所有的值非常方便，但是您必须检查收集的所有信息是否相关。有时一个相同的标签可以包含完全不同的数据。这就是为什么在选择标签时尽可能具体是很重要的。在这里，我们决定依赖带有“product_pod”类的标签“article ”,因为这似乎是一个非常具体的标签，我们不太可能在其中找到除产品数据之外的数据。

前面的 URL 对应于它们相对于主页的路径。为了使它们完整，我们只需要在它们前面加上主页面的网址:http://books.toscrape.com/index.html(去掉 index.html 部分后)。

现在让我们用它来定义一个函数，在网站的任何给定页面上检索图书链接:

在主页上查找图书类别 URL

现在让我们尝试检索不同产品类别对应的 URL:

Inspecting HTML code

通过检查，我们可以看到它们遵循相同的 URL 模式:“目录/类别/书籍”。

我们可以告诉 BeautifulSoup 匹配包含此模式的 URL，以便轻松检索类别 URL:

50 fetched categories URLs
Some examples:[u'http://books.toscrape.com/index.htmlcatalogue/category/books/travel_2/index.html',
 u'http://books.toscrape.com/index.htmlcatalogue/category/books/mystery_3/index.html',
 u'http://books.toscrape.com/index.htmlcatalogue/category/books/historical-fiction_4/index.html',
 u'http://books.toscrape.com/index.htmlcatalogue/category/books/sequential-art_5/index.html',
 u'http://books.toscrape.com/index.htmlcatalogue/category/books/classics_6/index.html']

我们成功地检索了 50 个类别的网址！

记住要经常检查你获取的信息，以确保所有的信息都是相关的。

如果我们想要抓取网站的某个特定部分，获取网站各个部分的 URL 会非常有用。

收集所有书籍数据

在本教程的最后一部分，我们将最终解决我们的主要目标:收集网站上所有书籍的数据。

我们知道如何在给定的页面中找到书籍的链接。如果所有的书都放在同一个页面上，这就容易了。然而，这种情况不太可能发生，因为在同一个页面上向用户显示所有目录对用户来说不是很友好。

通常产品会显示在多页或一页上，但通过滚动显示。在主页底部，我们可以看到有 50 个产品页面和一个“下一步”按钮，可以进入下一个产品页面。

End of the main page

在接下来的页面上，还有一个“上一页”按钮，可以返回到上一个产品页面。

End of the second page

获取所有页面的 URL

为了获取所有产品的网址，我们需要能够通过所有的网页。为此，我们可以反复查看所有“下一步”按钮。

Inspecting HTML code

“下一步”按钮包含“页面”模式。我们可以用它来检索下一页的 URL。但是我们要小心:上一步按钮也包含这种模式！

如果我们在匹配“页面”时有两个结果，我们应该采用第二个结果，因为它将对应于下一页。对于第一页和最后一页，我们将只有一个结果，因为我们将有“下一页”按钮或“上一页”按钮。

50 fetched URLs
Some examples:
['http://books.toscrape.com/index.html',
 u'http://books.toscrape.com/catalogue/page-2.html',
 u'http://books.toscrape.com/catalogue/page-3.html',
 u'http://books.toscrape.com/catalogue/page-4.html',
 u'http://books.toscrape.com/catalogue/page-5.html']

我们成功地获得了 50 页的网址。有趣的是，这些页面的 URL 是高度可预测的。我们可以通过将“page-X.html”递增到 50 来创建这个列表。

这个解决方案在这个例子中是可行的，但是如果页面数量发生变化(例如，如果网站决定在每页上打印更多的产品，或者如果目录发生变化)，这个解决方案就不再可行了。

一种解决方案是增加这个值，直到我们得到一个 404 页面。

404 error page

这里我们可以看到，试图转到第 51 页实际上会导致 404 错误。

幸运的是，请求的结果有一个非常有用的属性，可以向我们显示 HTML 请求的返回状态。

status code for page 50: 200
status code for page 51: 404

代码 200 表示没有错误。404 代码告诉我们没有找到该页面。

我们可以使用这些信息来获取所有页面的 URL:我们应该迭代直到得到 404 代码。

现在让我们试试这个方法:

50 fetched URLs
Some examples:
['http://books.toscrape.com/catalogue/page-1.html',
 'http://books.toscrape.com/catalogue/page-2.html',
 'http://books.toscrape.com/catalogue/page-3.html',
 'http://books.toscrape.com/catalogue/page-4.html',
 'http://books.toscrape.com/catalogue/page-5.html']

我们设法用这个更简单的方法获得了相同的 URL！

获取所有产品的 URL

现在，下一步是获取每个页面的所有产品 URL。这一步非常简单，因为我们已经有了所有页面的列表和从页面获取产品 URL 的功能。

让我们遍历页面并应用我们的函数:

1000 fetched URLs
Some examples:
[u'http://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html',
 u'http://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html',
 u'http://books.toscrape.com/catalogue/soumission_998/index.html',
 u'http://books.toscrape.com/catalogue/sharp-objects_997/index.html',
 u'http://books.toscrape.com/catalogue/sapiens-a-brief-history-of-humankind_996/index.html']

我们终于得到了 1000 本书的网址。这与网站上显示的号码相对应！

获取产品数据

最后一步是收集每个产品的数据。让我们先来看看产品页面上的信息是如何组织的:

A product page

我们可以很容易地检索到每本书的大量信息:

• 书名
• 价格
• 有效性
• 图像
• 种类
• 等级

我们开始吧！

Result dataframe

我们得到了我们的数据:我们的网络抓取实验是成功的。

在使用之前，一些数据清理可能是有用的:

• 将评级转换成数值
• 删除 product_category 列中的数字

包裹

我们已经看到了如何使用自动化的 web 抓取工具浏览网站并收集每个网页上的数据。为了建立有效的网页抓取工具，一个关键的事情是理解你想要抓取信息的网站的结构。这意味着如果你想在网站更新后仍然有用，你可能需要维护你的刮刀。

这个书店网站是一个简单的例子，但是在现实生活中，您可能不得不处理更复杂的网站，这些网站使用 Javascript 呈现一些内容。你可能想使用类似 Selenium 的自动浏览器来完成这些任务(https://www.seleniumhq.org/)。

以下是 Jupyter 笔记本的原始链接:

[## jonathanoheix/scraping _ basics _ with _ beautiful soup

在 GitHub 上创建一个帐户，为 jonathanoheix/scraping _ basics _ with _ beautiful soup 开发做贡献。

github.com](https://github.com/jonathanoheix/scraping_basics_with_beautifulsoup)

我的 LinkedIn 个人资料:【https://www.linkedin.com/in/jonathanoheix/

用 Hyperopt 实现 Python 中贝叶斯优化的介绍性示例

原文：https://towardsdatascience.com/an-introductory-example-of-bayesian-optimization-in-python-with-hyperopt-aae40fff4ff0?source=collection_archive---------1-----------------------

学习强大优化框架基础的实践示例

虽然寻找一个函数的最小值可能看起来很*常，但这是一个延伸到许多领域的关键问题。例如，优化机器学习模型的超参数只是一个最小化问题:这意味着搜索验证损失最低的超参数。

贝叶斯优化是一种基于概率模型的方法，用于找到任何返回实值度量的函数的最小值。该函数可以简单到 f(x) = x，也可以复杂到深度神经网络关于数百个模型架构和超参数选择的验证误差。

最*的结果表明机器学习模型的贝叶斯超参数优化比手动、随机或网格搜索更有效，具有:

• 测试集上更好的整体性能
• 优化所需的时间更少

很明显，这么强大的方法一定很难使用，对吗？幸运的是，有许多 Python 库，比如 Hyperopt ，允许简单应用贝叶斯优化。其实一行就可以做基本的贝叶斯优化！

Bayesian Optimization of a 1-D polynomial

如果你能理解上面代码中的一切，那么你大概可以停止阅读，开始使用这种方法。如果你想要更多的解释，在这篇文章中，我们将通过一个 Hyperopt 程序的基本结构，以便稍后我们可以将这个框架扩展到更复杂的问题，如机器学习超参数优化。这篇文章的代码可以在 GitHub 上的 Jupyter 笔记本中找到。

贝叶斯优化入门

优化是找到产生最低输出值的目标函数的输入值或一组值，称为“损失”。目标函数 f(x) = x 具有单个输入，并且是一维优化问题。通常，在机器学习中，我们的目标函数是多维的，因为它接受一组模型超参数。对于低维中的简单函数，我们可以通过尝试许多输入值并查看哪一个产生最低损失来找到最小损失。我们可以创建一个输入值的网格，并尝试所有的值—网格搜索—或者随机选取一些值—随机搜索。只要目标函数的评估(“evals”)是廉价的，这些不知情的方法可能是足够的。然而，对于复杂的目标函数，如神经网络的 5 倍交叉验证误差，目标函数的每次评估意味着训练网络 5 次！

对于需要几天训练的模型，我们想要一种方法来限制对评估函数的调用。对于高维问题，随机搜索实际上比网格搜索更有效，但仍然是一种统一方法，其中搜索不使用先前的结果来挑选下一个输入值进行尝试。让我们看看你是否比随机搜索更聪明。假设我们从为回归任务训练随机森林中得到以下结果:

如果你选择下一批要评估的树，你会集中在哪里？很明显，最好的选择是 100 棵树左右，因为数量越少，损失越小。你基本上已经在你的头脑中完成了贝叶斯优化:使用先前的结果，你形成了目标函数的概率模型,该模型表示更少数量的树可能导致更低的误差。

贝叶斯优化，也称为基于序列模型的优化(SMBO) ，通过建立目标函数的概率模型来实现这一思想，该模型将输入值映射到损失概率:p(损失|输入值)。概率模型，也称为代理或响应面，比实际的目标函数更容易优化。贝叶斯方法通过将一个标准(通常是预期改进)应用于代理来选择下一个要评估的值。其概念是通过花更多时间选择下一个要尝试的值来限制目标函数的评估。

贝叶斯推理意味着基于新的证据更新模型，并且，随着每次评估，替代物被重新计算以结合最新的信息。算法运行的时间越长，代理函数就越接*实际的目标函数。贝叶斯优化方法在构造替代函数的方式上有所不同:常见的选择包括高斯过程、随机森林回归，以及在 Hyperopt 中的选择 Tree Parzen 估计器(TPE) 。

这些方法的细节可能有点难以理解(我在这里写了一个高层次的概述)，并且也很难找出哪个工作得最好:如果你阅读算法设计者的文章，每个人都声称他们的方法是优越的！然而，特定的算法并不像从随机/网格搜索升级到贝叶斯优化那样重要。使用任何库(留兰香，远视， SMAC )都可以上手！记住这一点，让我们看看如何将贝叶斯优化付诸实践。

Hyperopt 中的优化示例

在 hyperpt 中公式化一个优化问题需要四个部分:

1. 目标函数:接受一个输入并返回一个损失以最小化
2. 域空间:要评估的输入值的范围
3. 优化算法:用于构造代理函数和选择下一个要评估的值的方法
4. 结果:算法用来建立模型的分数、值对

一旦我们知道如何指定这四个部分，它们就可以应用于任何优化问题。现在，我们将讨论一个基本问题。

目标函数

目标函数可以是任何返回我们想要最小化的真实值的函数。(如果我们有一个想要最大化的值，比如精度，那么我们只需要让函数返回这个度量的负值。)

这里我们将使用多项式函数，代码和图形如下所示:

这个问题是一维的，因为我们正在优化单个值 x。在 Hyperopt 中，目标函数可以接受任意数量的输入，但必须返回单个损失以最小化。

领域空间

域空间是我们想要搜索的输入值。作为第一次尝试，我们可以在函数定义的范围内使用均匀分布:

from hyperopt import hp# Create the domain space
space = hp.uniform('x', -5, 6)

为了可视化该域，我们可以从空间中抽取样本并绘制直方图:

Uniform domain space

如果我们知道最佳值在哪里，那么我们可以创建一个更智能的域，将更多的概率放在得分更高的区域。(关于在这个问题上使用正态分布的例子，见笔记本。)

最优化算法

虽然这在技术上是最困难的概念，但在 Hyperopt 中创建一个优化算法只需要一行代码。我们正在使用树形结构的 Parzen 评估模型，我们可以让 Hyperopt 使用suggest方法为我们配置它。

from hyperopt import tpe# Create the algorithm
tpe_algo = tpe.suggest

幕后有很多我们不必担心的理论！在笔记本中，我们也使用随机搜索算法进行比较。

结果(试验)

这并不是绝对必要的，因为 Hyperopt 会在内部跟踪算法的结果。然而，如果我们想要检查算法的进展，我们需要创建一个Trials对象来记录值和分数:

from hyperopt import Trials# Create a trials object
tpe_trials = Trials()

最佳化

现在问题定义好了，就可以最小化我们的目标函数了！为此，我们使用fmin函数，该函数接受上述四个部分，以及最大数量的试验:

**{'x': 4.878208088771056}**

对于这次运行，该算法在不到 1000 次试验中找到了 x 的最佳值(使损失最小化的值)。最佳对象只返回使函数最小化的输入值。虽然这是我们正在寻找的，但它并没有给我们太多的方法。要获得更多细节，我们可以从 trials 对象获得结果:

可视化对于直观理解正在发生的事情很有用。例如，让我们按顺序绘制 x 的值:

随着时间的推移，输入值聚集在红线所示的最佳值周围。这是一个简单的问题，因此算法在寻找 x 的最佳值时没有太大的困难。

为了与简单的搜索形成对比，如果我们用随机搜索运行同样的问题，我们会得到下图:

随机搜索基本上是随机尝试值！当我们查看 TPE 算法和随机搜索的 x 值的直方图时，这些值之间的差异变得更加明显:

在这里，我们看到了基于贝叶斯模型的优化的主要好处:更加关注有希望的输入值。当我们搜索几十个参数，并且每个评估需要几个小时或几天的时间时，减少评估的次数是至关重要的。贝叶斯优化通过基于以前的结果推理将来应该尝试什么输入值来最小化评估的次数。

(在这种情况下，由于基本的一维目标函数和评估次数，随机搜索实际上找到了非常接*最优的 x 值。)

后续步骤

一旦我们掌握了如何最小化一个简单的函数，我们就可以把它扩展到任何需要优化一个返回实值的函数的问题。例如，调整机器学习模型的超参数只需要对基本框架进行一些调整:目标函数必须接受模型超参数并返回验证损失，域空间需要特定于模型。

为了了解这看起来像什么，我写了一个笔记本，在那里我调整了梯度推进机器的超参数，这将是下一篇文章！

结论

基于贝叶斯模型的优化是直观的:根据过去的结果选择下一个输入值进行评估，以集中搜索更有希望的值。最终结果是，与无信息随机或网格搜索方法相比，减少了搜索迭代的总次数。虽然这只是一个简单的例子，但是我们可以将这里的概念用于各种有用的情况。

这篇文章的要点是:

1. 贝叶斯优化是一种通过构建目标函数的概率(替代)模型来寻找函数最小值的有效方法
2. 代理由过去的搜索结果通知，并且通过从该模型中选择下一个值，搜索集中在有希望的值上
3. 这些方法的总体结果是减少搜索时间和更好的价值
4. 这些强大的技术可以在 Hyperopt 这样的 Python 库中轻松实现
5. 贝叶斯优化框架可以扩展到复杂的问题，包括机器学习模型的超参数调整

一如既往，我欢迎反馈和建设性的批评。可以通过推特 @koehrsen_will 联系到我。

政策梯度的直观解释

原文：https://towardsdatascience.com/an-intuitive-explanation-of-policy-gradient-part-1-reinforce-aa4392cbfd3c?source=collection_archive---------6-----------------------

Source: https://hiveminer.com/User/Julian%20Veron

这是一系列教程的第 1 部分，我希望有 2 或 3 部分。下一部分将讨论 A2C，如果时间允许，我希望能完成一部分关于各种形式的政策外政策梯度的讨论。

这些帖子的笔记本可以在git repo中找到。

介绍

政策梯度的问题

当今一些最成功的强化学习算法，从 A3C 到 TRPO 再到 PPO，都属于策略梯度算法家族，通常更具体地说属于演员兼评论家家族。显然，作为一个 RL 爱好者，你应该对策略梯度方法有一个很好的理解，这就是为什么有这么多教程试图描述它们。

然而，如果你曾经试图遵循这些教程中的一个，你可能会面临一个如下的等式:

或者相关的更新规则:

或者甚至损失函数:

很有可能伴随着一个非常笨拙的解释，一大堆复杂的数学，或者根本没有解释。

的确，我最喜欢的一些关于强化学习的教程对此感到内疚。雅罗米鲁的让我们做一个 A3C 声明:

期望中的第二项，∇θlogπ(a|s，告诉我们在状态 s 中采取行动 a 的概率上升的方向。简单的说，如何让这种背景下的行动更有概率。

而 Arthur Juliani 在用 Tensorflow 进行简单强化学习中指出:

直观地说，这个损失函数允许我们增加产生正回报的行动的权重，减少产生负回报的行动的权重。

这两种解释都不能令人满意。具体来说，他们完全无法解释这些公式中神秘的对数函数的存在。如果你只记住了他们的直观解释，你就不能自己写下损失函数。这是不对的。

令人惊讶的是，实际上有对这个公式的完美直观的解释！然而，据我所知，这种直觉的唯一清晰表述隐藏在萨顿&巴尔托的强化学习:导论第 13 章第 3 节。

一旦我向你详细描述了它，你将能够解释对数函数的存在，并且你应该能够从基本原理写下公式。事实上，你也可以想出你自己的变种政策梯度！

在这篇文章中，我将假设你已经对强化学习有了一些基本的概念，特别是你熟悉 Q-Learning，理想情况下，熟悉 dqn。

如果你还不熟悉 Q-Learning，我建议你至少阅读一下 DQN 众多优秀教程中的一本。一些建议:

• 用深度强化学习打败雅达利靠你的真心
• 让我们做一个由雅罗密鲁创作的 DQN
• 亚瑟·朱利安尼用张量流进行简单强化学习

激励政策梯度

在继续之前，让我们了解一下策略梯度方法相对于 Q-Learning 的一些优势，作为尝试真正理解策略梯度的额外动力:

• Q-Learning 隐含的策略是确定性的。这意味着 Q-Learning 不能学习随机策略，这在某些环境下是有用的。这也意味着我们需要创建自己的探索策略，因为遵循策略不会执行任何探索。我们通常在ϵ-greedy 探索中这样做，这可能是非常低效的。
• 在 Q-Learning 中没有直接的方法来处理连续的动作。在策略梯度中，处理连续动作相对容易。
• 顾名思义，在政策梯度中，我们遵循政策本身的梯度，这意味着我们在不断改进政策。相比之下，在 Q-Learning 中，我们改进了对不同行动的价值的估计，这只是隐含地改进了策略。你可能会认为直接改善政策会更有效，事实也的确如此。

总的来说，在玩雅达利游戏这样的现代任务中，政策梯度方法经常击败基于价值的方法，如 DQNs。

解释政策梯度

简单的政策梯度上升

尽管本文旨在提供关于政策梯度的直觉，从而避免过于数学化，但我们的目标仍然是解释一个等式，因此我们需要使用一些数学符号，我将根据需要在整篇文章中介绍。让我们从第一个基本符号开始:

字母π将象征一项政策。我们称之为πθ(a|s)在状态 s 下采取行动 a 的概率，θ代表我们政策的参数(我们神经网络的权重)。

我们的目标是将θ更新为使ωθ成为最优策略的值。因为θ会变化，所以我们将使用符号θt 来表示迭代 t 时的θ。我们希望找出从θt 到θt+1 的更新规则，以便最终达到最佳策略。

通常，对于离散动作空间，ωθ将是具有 softmax 输出单元的神经网络，因此输出可以被认为是采取每个动作的概率。

显然，如果动作 a∫是最优动作，我们希望ωθ(a∫| s)尽可能接* 1。

为此，我们可以简单地对πθ(a∑| s)执行梯度上升，因此在每次迭代中，我们以如下方式更新θ:

我们可以将梯度∇πθt(a∗|s 视为“移动θt 的方向，以便最快地增加ωθt(a∑| s)的值”。请注意，我们确实在使用梯度上升，因为我们想要增加 a 值，而不是减少a 值，这在深度学习中是常见的。

因此，看待这一更新的一种方式是，我们在我们的政策中不断“推动”更多的行动 a*，这确实是我们想要的。

在下面的例子中，我们知道第一个动作是最好的动作，所以我们对它运行梯度上升。对于这个运行的例子，我们将假设单个状态 s，以便更容易绘制策略的演变。在本系列后面介绍 A2C 时，我们将推广到多个状态。

上面的 gif 显示了我们算法的结果。每个条形的高度是我们算法运行时采取每个动作的概率，箭头显示了我们每次迭代所遵循的梯度。在这种情况下，我们只在第一个动作上应用渐变，它恰好具有最大的值(10)，这就是为什么它是唯一一个以其他动作为代价增加的动作。

权衡梯度

当然，在实践中，我们不会知道哪一个行动是最好的…毕竟这是我们首先要解决的问题！

回到“推动”的比喻，如果我们不知道哪个行动是最优的，我们可能会“推动”次优的行动，我们的政策将永远不会收敛。

一种解决方案是“推动”行动，其方式与我们对这些行动的价值的猜测成比例。这些猜测可能是高度*似的，但只要它们在现实中有所依据，更多的整体推动将发生在最优行动 a *上。这样就保证了我们的策略最终会收敛到 a∑= 1！

我们称我们对状态 s Q̂ (s，a)中动作 a 的值的猜测为。事实上，这与我们从 Q-Learning 中了解到的 Q 函数非常相似，尽管有一个微妙而重要的区别，这将使学习变得更容易，我们将在后面学习。现在，让我们假设这个 Q 函数是给定的。

我们得到下面的梯度上升更新，我们现在可以依次应用于每个动作，而不仅仅是最佳动作:

让我们使用不同行动的 Q 值的嘈杂版本(行动 a 为 10，行动 b 为 5，行动 c 为 2.5)来衡量我们对模拟策略梯度的更新，这一次，我们将随机更新每个不同的可能行动，因为我们假设我们不知道哪一个是最好的。正如我们所看到的，第一个动作最终仍然获胜，即使我们对值的估计(如箭头的长度所示)在迭代中变化很大。

政策修正

当然，在实践中，我们的代理人不会随机选择一致的行动，这是我们到目前为止隐含的假设。相反，我们将遵循我们正在努力培养的政策ρθ！这被称为培训政策。我们可能希望进行政策培训有两个原因:

• 即使在训练中，我们也积累了更多的奖励，这是我们在某些情况下可能看重的东西。
• 它允许我们探索状态空间中更有希望的区域，而不是纯粹随机地探索，而是更接*我们当前对最优行动的猜测。

然而，这给我们当前的训练算法带来了一个问题:尽管我们将更强烈地“推动”具有更好值的动作，但我们也将更经常地“推动”那些碰巧一开始就具有更高ωθ值的动作(这可能由于偶然或错误的初始化而发生)！尽管这些行为是不好的，但最终可能会赢得通往顶峰的竞赛。

让我们通过使用相同的更新规则来说明这种现象，但是根据概率而不是统一地对动作进行采样:

**

在这里我们可以看到，第三个动作，尽管比其他两个动作的值低，但最终还是赢了，因为它的初始化值要高得多。

这意味着我们需要对更有可能被更频繁地采取的行动进行补偿。我们如何做到这一点？简单:我们用我们的更新除以行动的概率。这样，如果一个动作比另一个动作更有可能被采取 4 倍，我们将有 4 倍多的梯度更新，但每个将会小 4 倍。**

这为我们提供了以下更新规则:

让我们来试试:

**

我们现在看到，尽管行动 3 一开始有很大优势，但行动 1 最终胜出，因为当它的概率较小时，它的更新要大得多。这正是我们想要的行为！

基础加固

我们现在已经解释完了政策梯度背后的直觉！这篇文章的其余部分只是简单地填写一些细节。这是一个重大的成就，你应该为自己理解到这一步而感到自豪！

“但是，等一下”，你说，“我以为你会告诉我们如何理解神秘的更新规则

但是我们的更新规则看起来完全不同！"

是的，的确我们的更新规则看起来不同，但实际上本质上是一样的！提醒一下，我们规则的关键点是

虽然我们试图解释的规则包含

下一节将解释 Â和 Q̂之间的区别，但现在可以说两者都工作得很好，但使用 Â只是一种优化。

因此，剩下的唯一区别是

和

其实这两种表达是等价的！这是由于链式法则和 log x 的导数是 1/x 的事实，你们可能从微积分中知道。所以一般来说我们有:

所以现在你知道政策梯度更新中神秘日志功能的由来了吧！那么，为什么人们使用对数函数的形式，而不是更直观的除以π(s|a)的形式呢？我认为这有两个原因:

1. 它模糊了政策梯度背后的直觉，从而让你看起来更理解它。
2. 当进行梯度下降时，可以将更新表示为损失函数，如我们在开始时看到的方程 L=−Â (s，a)logπθ(s|a )(将 Â(s,a)inside 作为损失函数是好的，因为它相对于θ是常数)。这样你就可以使用你最喜欢的深度学习库来训练你的策略(我们很快就会看到怎么做！).

至此，您已经理解了强化算法的基本形式，正如您所料，它代表“奖励增量=非负因子×补偿强化×特征合格性”……(是的，我是认真的，参见原文)。加强是基本的策略梯度算法，几乎所有你可能听说过的高级策略梯度算法都基于它。

优势功能和基线

现在剩下的最后一件要解释的事情，正如承诺的那样，是 Q̂和 Â.之间的区别你应该已经从 Q-Learning 中熟悉了 Q:Q(s，a)是通过在状态 s 采取行动 a，然后在其后遵循我们的政策π而获得的值(确切地说是累积贴现回报)。

请注意，可能的情况是，遵循任何行动都会给我们带来累积奖励，比如说，至少 100，但一些行动会比其他行动更好，因此 Q 可能等于，比如说，行动 a 为 101，行动 b 为 102，行动 c 为 100。正如您所猜测的，这意味着我们更新的几乎所有权重都不会告诉我们当前行动是否更好，这是有问题的。

你可能也熟悉 V(s)函数，它简单地给出了从状态 s 开始一直遵循策略的值。在上面的例子中，V(s)将大于 100，因为所有 Q(s，a)都大于 100。

通过从 Q(s，A)中减去 V(s)，我们得到了优势函数* A(s，A)。这个函数告诉我们，在一个状态下采取行动与按照策略行动相比，是好是坏。在上面的例子中，它将从所有动作的 Q 值中减去额外的 100，提供更多的信噪比。*

在本教程中，我总是写 Q̂或 Â，在 q 和 a 上面加上一个“帽子”，以强调我们不是在使用“真实的”q 或 a，而是对它们的估计。如何获得这些估计值将是本系列下一篇文章的主题。

事实证明，如果我们从 Q̂(s,a 中减去任何函数，只要该函数不依赖于动作，强化仍然可以很好地工作。当然，基于我们之前的直觉，这是有意义的，因为唯一重要的是我们在具有更高 Q 值的动作上更努力地“推动”，减去任何不依赖于该动作的值将保留我们在各种动作上推动的努力程度的排名。**

这意味着用 Â函数代替 Q̂函数是完全允许的。事实上，由于上述原因，并且还因为它应该减少梯度更新的方差，所以它被广泛推荐。请注意，Â并不一定是代替 Q̂的最佳函数，但在实践中，它通常工作得相当好。

让我们看看在我们的模拟中使用 Â做了什么:

****

输出:

**Running using A function
Done in 48 iterations
Variance of A gradients: 31.384320255389287
Running using Q function
Done in 30 iterations
Variance of Q gradients: 31.813126235495847**

不幸的是，这里的影响并不显著:方差最终会稍微降低，但是收敛的时间会更长。也就是说，我在比较两者之间相同的学习率，使用优势函数应该会让您使用更高的学习率，而不会发散。此外，这是一个玩具的例子，使用优势函数的好处已经在实践中广泛证明了更大的问题。可悲的是，这是本教程中的一个例子，你必须相信我的话，有些东西工作得很好。

结论

您现在对基本的政策梯度有了全面直观的理解。然而，您可能想知道如何在实践中使用它们:如何用神经网络表示策略？首先，你是如何得到你的 Â估值的？在实践中，还有哪些其他的技巧可以使这种方法奏效？

我们将在第 2 部分中很快了解所有这些，这将解释 A2C 算法。

深层网络架构的直观指南

原文：https://towardsdatascience.com/an-intuitive-guide-to-deep-network-architectures-65fdc477db41?source=collection_archive---------0-----------------------

GoogLeNet, 2014

在过去的几年里，计算机视觉深度学习的许多进展都可以归结为少数几个神经网络架构。抛开所有的数学、代码和实现细节，我想探索一个简单的问题:这些模型如何以及为什么工作？

在撰写本文时，Keras 附带了六个已经内置到库中的预训练模型:

• VGG16
• VGG19
• ResNet50
• 盗梦空间 v3
• 例外
• MobileNet

VGG 网络，以及 2012 年的早期 AlexNet，遵循基本 conv 网络的原型布局:一系列卷积、最大池和激活层，最后是一些全连接的分类层。MobileNet 本质上是针对移动应用程序优化的 Xception 架构的简化版本。然而，剩下的三个真正重新定义了我们看待神经网络的方式。

这篇文章的其余部分将关注 ResNet、Inception 和 Xception 架构背后的直觉，以及为什么它们已经成为计算机视觉中许多后续工作的构建模块。

雷斯内特

ResNet 诞生于一个非常简单的观察:为什么当你不断增加层数时，非常深的网络表现更差？

直觉上，较深的网络应该不会比较浅的网络表现差，至少在训练时(没有过度拟合的风险)。作为一个思想实验，假设我们已经建立了一个具有 n 层的网络，它达到了一定的精确度。至少，具有 n+1 层的网络应该能够实现完全相同的精度，只要通过复制相同的前 n 层并对最后一层执行身份映射即可。类似地， n+2 、 n+3 和 n+4 层的网络都可以继续执行身份映射并达到相同的精度。然而，在实践中，这些更深的网几乎总是降低性能。

ResNet 的作者将这些问题归结为一个假设:直接映射很难学习。他们提出了一个解决方案:不要试图学习从 x 到 H(x)的潜在映射，而是学习两者之间的差异，或者“残差”然后，为了计算 H(x ),我们可以将残差加到输入中。

假设残差是 F(x)=H(x)-x，现在我们的网不是试图直接学习 H(x)，而是试图学习 F(x)+x。

这就产生了您可能见过的著名的 ResNet(或“剩余网络”)块:

ResNet block

ResNet 中的每个“块”由一系列层和一个将块的输入添加到其输出的“快捷”连接组成。“添加”操作是按元素执行的，如果输入和输出的大小不同，可以使用零填充或投影(通过 1x1 卷积)来创建匹配的维度。

如果我们回到我们的思想实验，这大大简化了我们身份层的构建。直观地说，学习将 F(x)推至 0 并将输出保留为 x 比从头开始学习一个恒等式转换要容易得多。一般来说，ResNet 给层一个“参考”点——x——来开始学习。

这个想法在实践中非常有效。以前，深度神经网络经常遇到消失梯度的问题，其中来自误差函数的梯度信号随着它们反向传播到更早的层而呈指数下降。本质上，当错误信号一路传回到早期层时，它们已经小到网络无法学习了。然而，由于 ResNets 中的梯度信号可以通过快捷连接直接返回到早期层，我们可以突然构建 50 层、101 层、152 层，甚至(显然)1000+层的网络，仍然表现良好。在当时，这是一个巨大的飞跃，超越了之前以 22 层赢得 ILSVRC 2014 挑战赛的最先进技术。

ResNet 是我个人最喜欢的神经网络领域的发展之一。如此多的深度学习论文在没有考虑模型的底层任务的情况下，从数学、优化和训练过程的黑客攻击中获得了微小的改进。ResNet 从根本上改变了我们理解神经网络及其学习方式的方式。

有趣的事实:

• 1000+层网是开源的！我不会真的建议你重新训练它，但是……
• 如果您觉得功能强大，有点兴奋，我最*将 ResNet50 移植到了开源的 Clojure ML 库 Cortex 。尝试一下，看看它与 Keras 相比如何！

开始

如果说 ResNet 是为了更深入，那么 Inception Family 则是为了更广泛。尤其是，《盗梦空间》的作者对训练大型网络的计算效率感兴趣。换句话说:我们如何在不增加计算成本的情况下扩大神经网络的规模？

最初的论文关注于深度网络的一个新的构建模块，这个模块现在被称为“初始模块”该模块的核心是两个关键见解的产物。

第一个见解与层操作有关。在传统的 conv 网络中，每一层都从前一层提取信息，以便将输入数据转换成更有用的表示。但是，每种图层类型提取不同种类的信息。5x5 卷积内核的输出告诉我们不同于 3x3 卷积内核的输出，3x 3 卷积内核告诉我们不同于 max-pooling 内核的输出，等等。在任何给定的层，我们如何知道什么转换提供了最“有用”的信息？

洞察力#1:为什么不让模型选择？

一个初始模块在同一输入映射上并行计算多个不同的变换，将它们的结果连接成一个输出。换句话说，对于每一层，Inception 做一个 5x5 的卷积变换，和一个 3x3，和一个 max-pool。模型的下一层决定是否(以及如何)使用每条信息。

这种模型架构增加的信息密度带来了一个突出的问题:我们急剧增加了计算成本。不仅大的(例如 5×5)卷积滤波器计算起来固有地昂贵，并排堆叠多个不同的滤波器极大地增加了每层的特征图的数量。这种增长成为我们模型中的致命瓶颈。

这么想吧。对于添加的每个额外滤波器，我们必须对所有输入映射进行卷积，以计算单个输出。参见下图:从单个过滤器创建一个输出贴图涉及到计算来自前一层的每一个贴图。

假设有 M 个输入映射。一个额外的过滤器意味着对更多的地图进行卷积； N 额外的过滤器意味着对 NM* 更多的地图进行卷积。换句话说，正如作者指出的，“任何[过滤器]数量的均匀增加都会导致计算量的二次增加。”我们天真的初始模块只是将过滤器的数量增加了三倍或四倍。从计算上来说，这是一件大坏事。

这导致了洞察力#2:使用 1x1 卷积来执行维度缩减。为了解决计算瓶颈，Inception 的作者使用 1x1 卷积来“过滤”输出的深度。1x1 卷积一次只查看一个值，但在多个通道中，它可以提取空间信息并将其压缩到更低的维度。例如，使用 20 个 1×1 过滤器，大小为 64×64×100(具有 100 个特征地图)的输入可以被压缩到 64×64×20。通过减少输入映射的数量，Inception 的作者能够并行堆叠不同的层转换，从而产生同时深(许多层)和“宽”(许多并行操作)的网络。

这种方法效果如何？《盗梦空间》的第一个版本被称为“GoogLeNet”，是我前面提到的 ILSVRC 2014 竞赛的 22 层冠军。Inception v2 和 v3 是在一年后的第二篇论文中开发的，并在几个方面对原始版本进行了改进——最显著的是通过将较大的卷积重构为更容易学习的连续较小的卷积。例如，在 v3 中，5×5 卷积被替换为 2 个连续的 3×3 卷积。

《盗梦空间》迅速成为一个定义性的模型架构。Inception 的最新版本 v4 甚至在每个模块中加入了剩余连接，创造了 Inception-ResNet 的混合体。然而，最重要的是，Inception 展示了设计良好的“网络中的网络”架构的力量，为神经网络的表现能力又增加了一步。

有趣的事实:

• 最初的《盗梦空间》论文字面上引用了“我们需要更深入”互联网迷因作为其名称的灵感。这一定是 knowyourmeme.com 第一次被列为谷歌论文的第一参考文献。
• 第二篇启始论文(包含 v2 和 v3)是在最初的 ResNet 论文后一天发布的。2015 年 12 月是深度学习的好时机。

例外

Xception 代表“极限盗梦空间”很像我们之前的两个架构，它重新构建了我们看待神经网络的方式——特别是 conv 网络。顾名思义，它将盗梦空间的原则发挥到了极致。

这里有一个假设:“跨通道相关性和空间相关性是充分解耦的，因此最好不要将它们一起映射

这是什么意思？嗯，在传统的 conv 网中，卷积层寻找跨越空间和深度的相关性。让我们再来看看我们的标准卷积层:

在上图中，过滤器同时考虑了空间维度(每个 2x2 彩色正方形)和跨通道或“深度”维度(四个正方形的堆叠)。在图像的输入层，这相当于卷积滤镜在所有三个 RGB 通道上查看一个 2x2 像素块。问题来了:有什么理由需要我们同时考虑图像区域和通道呢？

在《盗梦空间》中，我们开始将两者稍微分开。我们使用 1x1 卷积将原始输入投影到几个独立的更小的输入空间，并从每个输入空间中使用不同类型的过滤器来转换这些更小的 3D 数据块。Xception 更进一步。它不是将输入数据划分为几个压缩块，而是分别映射每个输出通道的空间相关性，然后执行 1x1 深度方向卷积来捕获跨通道相关性。

作者指出，这基本上等同于一种称为“深度方向可分离卷积”的现有操作，它由一个深度方向卷积(为每个通道独立执行的空间卷积)和一个点方向卷积(跨通道的 1x1 卷积)组成。我们可以认为这是首先在 2D 空间寻找相关性，然后在 1D 空间寻找相关性。直观地说，这种 2D + 1D 映射比完全的 3D 映射更容易学习。

而且很管用！在 ImageNet 数据集上，Xception 略微优于 Inception v3，在具有 17，000 个类的更大的图像分类数据集上，xception 远远优于 Inception v3。最重要的是，它与 Inception 具有相同数量的模型参数，这意味着更高的计算效率。Xception 要新得多(它于 2017 年 4 月问世)，但如上所述，它的架构已经在通过 MobileNet 为谷歌的移动视觉应用提供支持。

有趣的事实:

• Xception 的作者也是 Keras 的作者。弗朗索瓦·乔莱是活着的上帝。

走向

ResNet，Inception，Xception 就是这样！我坚信对这些网络有很强的直觉理解，因为它们在研究和工业中无处不在。我们甚至可以在自己的应用程序中使用它们，这种应用程序叫做迁移学习。

迁移学习是机器学习中的一种技术，在这种技术中，我们将来自源领域(例如 ImageNet)的知识应用到可能具有明显更少数据点的目标领域。在实践中，这通常包括用来自 ResNet、Inception 等的预训练权重来初始化模型。或者将其用作特征提取器，或者微调新数据集的最后几个图层。通过迁移学习，这些模型可以重新用于我们想要的任何相关任务，从自动驾驶汽车的物体检测到为视频剪辑生成字幕。

为了开始迁移学习，Keras 有一个很棒的微调模型指南这里。如果你觉得这很有趣，那就去看看吧——祝你黑客生涯愉快！

机器人是如何做决定的？

原文：https://towardsdatascience.com/an-intuitive-guide-to-mdps-4cde2d441e8a?source=collection_archive---------7-----------------------

简而言之，我们经常希望赋予机器人对环境进行推理的能力，以便让它们达到目标。例如，自动驾驶汽车必须想出一条从你家到杂货店的好路线，更重要的是，它必须考虑当它到达十字路口时要做什么，以避免撞到汽车、人、标志、建筑物等。

Source: CBS News

那么我们怎样才能让机器人思考呢？这就是这篇文章的切入点。虽然我不能涵盖人工智能、机器人、机器学习和控制理论的每个方面，但让我们来看一个简单的例子。

网格世界

假设我们是一个寻宝者，正在寻找藏在世界某处的一罐金子。为了简单起见，让我们假设我们的世界不是地球，而是一个 5×5 网格。为了寻找宝藏，我们可以通过向北、向东、向南或向西从一个牢房移动到另一个牢房。此外，虽然我们对这个世界一无所知，但我们至少知道其中一个细胞里有宝藏。因此，如果我们能够成功地在世界上航行并找到宝藏，我们将会变得无比富有。不幸的是，有一个陷阱。虽然世界上大多数的牢房都是空的，但也有一些牢房里有陷阱，就像一个怪物或一个刺坑。如果我们不小心进入任何一个细胞，我们都会痛苦地死去。

既然我们想发财而不死，我们需要想出一个既能找到宝藏又能避开陷阱的计划。在我们的例子中，计划只是我们从当前位置到目标州(例如宝藏)可以采取的一系列行动(例如，北、东、南或西)。在我们完成计划中的每一个行动后，我们将会到达宝藏(这意味着我们不是怪物的晚餐)。听起来很简单，对吧？只要(1)想出一个从我们当前位置到宝藏的计划，然后(2)通过做建议的行动来遵循该计划，最后(3)收获无限财富的回报。

可悲的是，这并不容易。即使在这样一个简单的问题中，这可能是微不足道的，但在现实世界中，想出一个计划要难得多。事实上，如果我们有一个更难的问题，为了制定计划，我们需要用数学模型来表示它。因此，在我们可以将一张漂亮的支票存入银行账户之前，我们需要将我们的寻宝场景转换为一个数学模型，我们可以使用许多不同的规划和强化学习算法中的一种来求解该模型。

现在，我们需要解决一个大问题:

我们如何想出一个数学模型来描述我们的场景，这样我们就可以在不被钉子刺穿或被怪物吃掉的情况下抢走宝藏？

MDPs

为了模拟任何这样的场景，我们可以使用一个马尔可夫决策过程 ( MDP )。MDP 是我们刚刚看到的那类问题的正式表示。一般来说，它有四个部分。让我们来看看每个部分。

州

集合 S 包含了世界上的每一个状态。在我们的寻宝世界(提醒一下，它是一个 5×5 网格)中，每个单元格对应一个州。这意味着我们有一组 25 个状态:

S = {s0，s1，…，s24}

为了方便起见，这里有一张标示世界各州的图片:

行动

集合 A 包含了代理在世界上可以采取的每一个动作。对了，如果你不知道什么是经纪人，那只是世界上的演员。它可能是你，一个机器人，一辆汽车，或者任何遵循计划的东西。无论如何，在我们的例子中有一组五个动作:

A = {北，东，南，西，停留}

为什么我们有一个停留行动？一旦找到宝藏，我们就可以坐在那里。在我们努力工作之后，一旦我们发现了宝藏，我们就不想离开它。

请记住，每个状态都有某些限制代理可用操作的约束。例如，如果我们在世界的一个角落，比如说左上角，我们不能向北或向西移动或，因为我们在世界的边界。我们通常将给定状态下可用的动作表示为。因此，如果我们在世界的右上角， s20 ，这些将是代理唯一可用的操作:

A(s20)= {东，南，停留}

这种可视化可能会有所帮助:

过渡

函数 T(s，a) 是转换函数。如果代理在状态 s 中执行动作 a ，它返回世界 S 的每个可能状态的概率分布。例如，如果我们在世界的左下角，比方说， s0 ，我们执行动作北，函数 T(s0，北)将返回以下概率分布:

【s0:0.0，s1: 0.0，…，s5: 1.0，…，s24: 0.0，s25:0.0】

如果我们在状态 s0 中执行动作北，这个符号只是分配进入世界每个状态的概率。既然我们的世界是确定性，那么状态 s5 就有 1.0 的概率。看看这个就明白我的意思了:

然而，在现实世界的例子中，行动的结果通常是概率或随机。这意味着一个动作可能会导致不同的状态，而不仅仅是像我们的例子那样。在一个更现实的 MDP，我们也许可以把滑倒的概率与每一个动作联系起来。因此，即使我们执行了动作北，我们也可能会滑倒，并意外地在错误的状态中结束。这在机器人领域经常发生:

现在，让我们假设我们有一个确定性的世界来简化事情。

奖励

函数 R(s，a) 就是奖励函数。它返回代理在状态 s 中执行动作 a 后的奖励。在我们的世界里，假设宝藏在世界的右上角 s23 。因此，如果我们处于状态 s23 ，即 s24 以东的单元格，并且我们执行了动作西，函数 R(s24，西)将返回1000，因为我们找到了宝藏。形式上，我们应该这样写:

R(s23，西)= 1000

在任何空单元格中执行任何动作都将返回奖励 -1 ，因为在空单元格上重复移动应该会有一些相关的成本。如果没有，我们可以在找到宝藏之前绕着世界转几圈，而不会受到任何惩罚。为了节省时间，我们宁愿走最短的路去寻宝。

不幸的是，如果我们降落在一个有怪物或刺坑的州，我们会得到 -100，000 的奖励。这个高负数代表我们的死亡。我们可能会不惜一切代价避免这种情况，除非我们是一个相当虐待狂的寻宝者。

简而言之，这就是我们的奖励世界的样子:

这四个部分完全说明了我们在第一部分中概述的问题。但所有这些都给了我们一种方法，将问题数学建模为 MDP。换句话说，虽然我们现在有了一个代表 MDP 的场景，但是我们仍然没有找到得到宝藏应该遵循的计划。我们如何着手做那件事？也就是我们应该采取什么行动才能得到宝藏，避免死亡？有许多奇特的算法，我们可以用来为我们的 MDP 获得最佳计划。然而，在我们谈论那个之前，让我们多谈一点什么是计划。

政策

在计划中，我们通常制定一个计划作为政策。顺便说一句，这只是一种真实，但现在让我们继续下去。总之，什么是政策？它只是一张地图，将世界上的每一个州与推荐的行动联系起来:

更正式一点，策略 π 是每个状态 s 和动作 a 之间的映射:

π(s) = a

太好了，贾斯汀！我想我现在明白什么是政策了。为什么我们需要一个？为什么我们要将动作映射到状态？策略很重要，因为它指定了代理在世界的每个状态下应该采取的动作。例如，让我们假设代理处于状态 s23 ，它直接位于球门的东面。为了弄清楚要采取什么行动，我们将取出我们的策略来查看在 s23 中要执行什么行动。在一个理想的世界里，我们的政策应该告诉我们这一点(因为这会使我们走向宝藏):

π(s23) =西

然而，重要的是要注意，我们的政策并不一定要将每个州与一个好的行动联系起来。政策只是把状态和行动联系起来的东西，仅此而已。我们可以有很多政策，在所有的垃圾政策中，我们需要找到最好的一个。如果我们遵循一个糟糕的政策，我们可能会避开宝藏，做这样的事情:

注意我们是如何走过宝藏的。是啊，那可不好。另一方面，如果我们找到了最优策略(或者我们所能拥有的最佳策略)，这就是我们要做的:

既然我们知道什么是 MDP，什么是政策，现在最大的问题是:

在我们将问题建模为 MDP 之后，我们如何在所有的坏政策中找到最好的政策？

规划和强化学习

虽然我不能深入这个问题，因为我可以写 10 本很长的教科书来解释每个细微差别，但有许多跨越规划和强化学习的算法可以用来解决 MDP。为了让你对那里有什么有个概念，这里有一个我们可以使用的一些基本算法的快速列表:

• 价值迭代
• 策略迭代
• TD 学习

如果您继续关注，我可能会在接下来的几周内就每个算法写一篇文章。

线性回归的直观透视

原文：https://towardsdatascience.com/an-intuitive-perspective-to-linear-regression-32bb9885b312?source=collection_archive---------10-----------------------

Credit: Unsplash

线性回归是最简单但有效的机器学习算法

所以，你在互联网上搜寻了解线性回归后来到这里，我必须说你的搜索到此结束。

所以不要再等了，让我们直接开始吧。

“泛化是任何机器学习算法的最终目标”

机器学习算法试图解决的两种主要问题是:

• 回归-预测给定数据点的连续值
• 分类-预测给定数据点的类别

线性回归，直观上是一种采用线性方法的回归算法。我们试图通过对现有数据进行归纳来预测给定数据点的连续值。线性部分表示我们使用线性方法对数据进行归纳。

一个例子

例子让它变得容易理解，所以假设你想通过知道房子的大小来预测它的价格。你有一些房价和相应大小的数据。绘制数据图表并在它们之间拟合一条线将看起来像这样:

概括地说，你画一条穿过最大值点的直线。一旦你得到那条线，对于任何大小的房子，你只要把数据点投影到那条线上，就可以得到房价。

就是这样。你完了。但是等等！

真正的问题是

问题是永远找不到房价。问题是找到能很好地概括数据的最佳拟合线。

使用了相同的旧直线方程: y = mx +c ，并添加了一些专门用于线性回归建模的术语。

我们将逐一检查等式的元素:

• y —要预测的数值
• β₀ — 直线的 y 轴截距是指直线与 y 轴的交点
• β₁-线的斜率或梯度表示线有多陡
• x —数据点的值
• u——不明原因造成的残留或噪音

似乎我们可以通过试凑法很容易地得出最佳参数值，从而找到最佳拟合线。但是当你要解决的问题有更多维度时，事情就没那么简单了，这也被称为维度的诅咒。

Multiple Linear Regression

多元线性回归将有 n 个特征，我们必须找到一条线来拟合所有维度的所有数据点。你已经开始意识到这不再是一个试凑法的解决方案。

数学拯救世界

我们可以画出无限多条线，但永远无法确定这条线是否是最佳拟合线，所以我们的救星来了:成本函数

“数学是科学女王”

我一生都在逃避数学，但你看，你就是无法逃避它。这真的很直观，让你能够看到引擎盖下发生了什么。

成本函数是一种数学构造，通过将误差*方项相加来计算

Mean Squared Error

通过稍微调整上面的等式，我们得到下面的等式:

其中 J 是成本符号， θ 是参数

我们的目标是降低成本函数，从而提高精度。我们可以通过试凑法获得参数值，并计算每个参数组合的 MSE，但这不是一种有效的技术。似乎这个问题有一个微积分解决方案。

梯度下降

梯度下降是一种简单的优化技术，用于寻找任何函数的最小值，在这种情况下，我们希望找到我们的 MSE 函数的最小值。

Gradient Descent

你可以把这个函数想象成一个山谷，你正站在某个随机的点上。你的目标是到达山谷的最底部，梯度下降帮助你到达山谷的最底部。

你可以这样做:

你会看到并弄清楚山谷的斜坡在哪里向下，然后你开始向向下的斜坡走去。一旦你看到你周围的每一个轮廓都比你站的地方高，你就声称你已经到达了最低点。

这里是梯度下降将如何做到这一点:

它必须知道山谷的斜坡在哪里(它不像你一样有眼睛)，所以它需要数学的帮助。

要知道函数在任一点的斜率，就要对该点的参数进行微分，因此梯度下降法对上述成本函数进行微分，从而得到该点的斜率。

为了到达最底部的点，它必须沿着与斜率相反的方向，即斜率减小的地方。

它必须一小步一小步地向最低点移动，因此学习率决定了梯度下降将采取的步长。

每次移动后，它验证当前位置是否是全局最小值。这通过该点的斜率来验证，如果斜率为零，则算法已经到达最底部的点。

在每一步之后，它更新参数(或权重),通过重复上述步骤，它到达最底部的点。

获胜

一旦你到达了谷底，这意味着你已经得到了对应于最小均方误差或成本函数的参数，这些参数值将为你带来最高的精度。

现在，您可以使用线性回归模型以非常高的精度预测任何不可预见的数据点的因变量。

如果你还和我在一起，那么你已经了解了线性回归的概念，并准备好应用它来解决现实世界中的问题。

线性回归的应用

1. 销售驱动因素分析 —线性回归可用于根据过去的购买行为预测未来的产品销售
2. 预测经济增长 —经济学家使用线性回归来预测一个国家或州的经济增长
3. 得分预测 —体育分析师根据球员之前的表现，使用线性回归来预测他在接下来的比赛中的得分次数
4. 薪资估算——一个组织可以使用线性回归来计算出他们会根据工作经验付给新员工多少钱
5. 房价预测 —线性回归分析可以帮助建筑商预测未来几个月能卖出多少房子，价格是多少
6. 石油价格预测 —可以使用线性回归来预测石油价格

在接下来的文章中，我们将深入研究数学部分，并用 python 编写一个线性回归模型。

如果我能在任何方面改进这篇文章，请在下面的评论区给我反馈，或者给我发邮件到sarfraz.contact@gmail.com

非数学家监督学习综合入门指南

原文：https://towardsdatascience.com/an-involved-introduction-to-supervised-learning-for-the-common-human-6338d9559748?source=collection_archive---------17-----------------------

洞察具有自学能力的计算机

人工智能:一个对人类发动战争的机器人部落。技术启示录。公元 3000 年。

不完全是。下面是更准确的介绍。

人工智能(A.I.): 电脑创作的画作。与机器进行有意义的对话。自动驾驶汽车。甚至，令我们痛苦的是，高度个性化的、有针对性的广告。

这些只是人工智能大规模创新应用的一小部分。

欢迎来到智能机时代。人工智能已经降临到我们头上，幸运的是，它不打算终结人类。当大多数人讨论人工智能时，他们指的是机器学习，通常缩写为 M.L .，这是计算机智能行业内最大的领域。在本指南中，我将专门讨论机器学习及其内部运作，特别是线性回归:一种监督学习的普通形式。

在接下来的教导中，描述和解释了多个数学模型；记住，这些计算都是在机器内部进行的。

目录:

• 监督学习——概述
• 监督学习的注释
• 线性回归预测模型
• 用成本函数评估模型
• 梯度和导数导论
• 梯度下降:监督 M.L .模型如何学习
• 总结

准备好学习了吗？如果是这样，带上手电筒——我们正在进入人工智能的洞穴！

监督学习——概述

在处理一个复杂的主题时，主题的坚实基础非常重要。在深入研究机器学习的机制之前，让我们先了解一下机器学习在做什么。

当我们教计算机做一些事情时，比如识别物体的照片，或者预测明天的房价，我们使用的是监督学习。监督学习是一种方法，在这种方法中，我们为机器提供数据，将数据分类成示例，并为这些数据提供正确的输出。机器自我调整，直到获得可接受的预测精度。

对的注释用于监督学习

让我们通过例子来学习。

假设我们想教我们的计算机预测房价。我们将首先给我们的机器提供该地区其他房屋的价格，以及每所房屋的信息(大小、卧室数量、楼层数量)。

这些大量的信息被称为训练集。我们为任何一个给定的房屋提供的数据被称为训练示例。这由 x(i) 表示，意味着与房子(I)相关的数据(x(2) =训练示例 2)。

包含在训练示例中的每个不同的信息位被称为一个特征。在表示住房属性的数据中，房子的大小可能是一个特征，楼层数和卧室数也是一个特征。

每个训练示例以相同的顺序包含相同的功能，这意味着我们在训练集中获得关于每个房屋或示例的相同信息。

特征由 j 表示。也就是说， x(i)j 是示例 I 的特征 n

在这种情况下，给定房屋的价格将是期望产量或标签。这由 y(i) 表示，表示房子(I)的正确输出(y(2) =示例 2 的正确输出)。

注意: Medium 不支持下标和上标。x(i)j 一般写成 x 上标 (i)，下标 j. y(i)应该是 y 上标 (i)。

线性回归预测模型(假设)

这一切都很好，但是我们仍然不知道计算机实际上是如何得出它的输出的。

线性回归是最基本的机器学习模型之一，当然也是学习的必备工具。尽管如此，它在大规模应用中使用非常频繁。象征性地，这是该模型的常见表示:

满足假设。别害怕，他不咬人。

我会为你打破僵局。

hθ(x) 简单地表示假设函数。它说输出的值根据输入 x 而变化，也就是说，根据括号内的值 x 进行预测，意思是 hθ(x(i)) 象征假设对例 x(i)所做的预测。

你看到的时髦希腊符号(θ——这些家伙)是θ值，更专业的说法是参数。这些数字可以是正数，也可以是负数。

来自数据集的每个特征 k 与来自假设的参数 k 相关联。你很快就会明白我说的“相关联”是什么意思。然而，由于惯例，θ0 没有各自的特征。现在，不要太在意θ0。只知道它叫偏置单元。

注:上图假设只有一个特征(x)和两个参数(θ0 和θ1)。在实际的监督学习应用中，通常有非常大量的参数和特征。

现在所有的部分都准备好了，让我们来看一下预测过程！当我们为我们的假设提供一个训练示例时，每个特征都乘以其各自的θ值。输出是这些乘积的总和，加上偏置单元。

为了澄清，让我们回到我们的房价例子。假设我们使用的是培训示例 1。我们的例子将只使用一个特征来解释:房子的*方英尺大小。这将由 x(1)1 表示，表示训练示例 1 的特征 1，并且将等于 2，500(*方英尺)。假设我们的假设认为，每*方英尺为房屋增值 50 美元，该地区的房价起价为 20 万美元。θ(0)的值为 200，000，θ(1)的值为 50。

让我们来看看这是为什么。

我们知道，预测是通过将偏差单位与特征及其各自参数的乘积相加而形成的。

当我们将 x(1)1(2500 *方英尺)乘以θ(1)(相关参数为 50 美元/*方英尺)时，我们得到的值为 125000 美元。通过这个乘法，对于每*方英尺(x(1)1)，增加了 50 美元的价值(θ(1))。我们将该产品添加到我们的偏差单位$200，000 ( θ(0)代表当地*均起始房价)中，得到最终产值$325，000！

在机器学习的实际应用中，会有 10 到 10，000 个特征。与要素关联的每个θ值将具有正权重或负权重，从而影响每个要素影响最终输出的方式。

哇！这是使用线性回归模型预测值的过程。

在继续之前，看一下如果将预测用图表表示出来，它会是什么样子:

Linear regression hypothesis

这是一个假设，它已经被一个特征的数据所拟合。x 轴显示每个训练示例的该特性的值。y 轴测量该示例的期望输出值。在上图中，θ0 的值为 5，θ1 的值约为 1/7。可以看到，θ0 是 y 轴截距，θ1 是模型的斜率。

我们用来预测房价的模型也可以用同样的方式绘制。

用成本函数评估模型

好了，现在我们明白了什么是监督学习，以及线性回归模型如何根据它们的训练样本进行预测。但是学习是在哪里进行的呢！？

别担心，我们很快就会到达那里。在我们这样做之前，我们必须了解如何衡量我们假设的有效性。具体地说，我们需要一个数字表示，特别是一个函数，来证明我们的参数θ与我们的数据有多吻合。这将向我们展示我们的模型做出预测的准确性。

进入成本函数。

它就在那里，光彩夺目！*方误差成本函数！

被恐吓？不要这样。你很快就会对这里发生的事情有一个清晰的印象。

正如我们的假设一样，我们有一个函数句柄: J(θ) 。它用来表示函数及其输出值。因此，当你看到 J(θ)时，回想一下你正在处理的是成本函数(有时称为损失函数)，或者与之相关的输出。

在机器学习中，字母 m 是训练样本的数量。如果我们有 5000 套房子的数据，m = 5,000。

我们最新的希腊朋友西格玛(σ)怎么样？这个家伙表示一个求和项，它在一个迭代器上循环并对一个指定的项求和。σ下面的小等式 i = 1 显示了迭代器的初始值，以及变量(I)。(I)表示求和循环中的当前迭代。σ以上是 m，即终值。

那是一个非常抽象的定义。用简单的英语来说，变量 I 取 1 到 m 之间的每一个值。对于这个循环的每一个阶段，我们将 sigma 右边的值加到一个运行总和上。

σ右边的表达式是什么？！

(hθ(x(i)) - y(i)) 称为*方误差项。它的内容应该看起来很熟悉。对于每次迭代，*方误差项使用假设来预测使用示例 x(i)的输出，并从中减去该示例 y(i)的期望输出。这就是 x(i)和 y(i)之间的差异或误差。然后，该值被提升到 2 的幂。因此*方误差。

因为它是求和，其中(I)取 1 和训练样本数量之间的所有值，所以我们对整个数据集完成这个计算。随着算法的进行，所有*方误差被一个接一个地加在一起。一旦求和完成，假设的所有误差的总和已经计算出来。

最后，我们将总误差乘以 1/2m ，得到成本函数的输出。除以 2m，结果是模型*均误差的一半。除以 2m 而不是 m 应该被认为是另一种机器学习惯例。这背后有数学上的原因，但是解释超出了本文的范围。

给定成本函数上的任何坐标，可以提取以下信息:
自变量的所有值(θ值)，以及那些参数的成本。成本是因变量。

这个总结了关于成本函数的知识。让我们来看看它的几个图像。

Cost function for data with two parameters

请注意成本函数是如何抛物线化的，因为它是二次函数。同样重要的是，要看到 y 轴上显示的成本随着θ值的变化而变化。

Another cost function, but for only one parameter

损失函数的另一种变化如上图所示。它测量的是只包含一个参数的假设，因此是一个二维的可视化。

对于每个θ值，空间维度被添加到函数中。由于这个原因，我们不能绘制任何处理包含两个以上特征的数据的损失表示(第三维是 y 轴上的成本)。记住这一点可能对你的视觉学习者有所帮助。

成本函数经常采用奇特的形状和奇怪的形式。除了数学和视觉上的有趣，损失函数在机器的实际学习过程中也起着至关重要的作用。以下部分将概述这一关键特征。

梯度和导数介绍

导数是微积分的基础之一。我知道微积分会让很多人产生恐惧。请不要逃避。

就像我们已经讨论过的所有内容一样，我将以简单而有条理的方式解释这个概念。

下面是什么导数是一句话:表示函数和该函数在任意点的斜率之间的关系的表达式，给定自变量。

x 的导数是 2x。这意味着在函数 x 上的值为 x 时，该点的斜率为 2 * x。

知道了这一点，我们就可以理解导数代表了瞬时变化率，因为它们揭示了函数上某一点的斜率，而不是两个独立点之间的斜率。

当我们计算一个导数时，通过将独立变量代入导数方程，其输出就是函数上该点的斜率。由于这个原因，导数可以画为图形的切线。

A tangent line to x², at x = 1. The derivative being 2x, the slope of the tangent is 2 * 1.

关于衍生品需要注意的三件事:

1. 它们有一个量级(大的表示陡坡，小的表示缓坡)。
2. 它们有一个方向(正或负)。
3. 导数指向函数求值点的最陡变化方向。

请记住这一点，因为这对下一节很重要。

那么梯度呢？

函数的梯度就像导数一样，代表函数上任意给定点的斜率。然而，梯度可以应用于多元函数。

梯度本质上是一系列导数，每一个导数代表图形一维的斜率。这些导数，每一个都表示多元函数中一个变量的变化率，叫做偏导数。当偏导数组合成一个方向单位(向量)时，它们就被称为梯度。

向量格式的梯度可以用以下格式表示:
【3；-4;5]
这将是三维图形的梯度。此处提供的信息如下:

• 在这个坐标上，x *面的斜率是+3
• y *面在这个坐标上的斜率是-4
• 该坐标处 z *面的斜率为+5

Partial derivative visualization

上面是一个三维函数的偏导数。下图展示了偏导数所代表的含义:函数一维的变化率。

这就是你所需要知道的关于梯度和导数的全部，来理解机器是如何学习的！

从一个方程中提取导数和梯度可能是相当密集的，通常需要整个教科书来解释。因此，不幸的是，在这篇文章中，您将无法深入了解推导。我只是要求你在我变出一个衍生物的时候相信我的话。

此外，如果你没有理解最后一部分的所有内容，也不要担心。最重要的是，梯度代表函数的斜率。偏导数告诉我们关于所述函数的一个变量(或维度)的斜率。

梯度下降:有监督的核磁共振模型如何学习

我非常强烈地感觉到，你已经攻克了机器学习最难的部分。也就是说，把你的脑袋缠在外国符号上，学习假设是如何形成和评估的。如果你理解了前面每个主题的基本概念，理解梯度下降就相对容易了。

话虽如此，我们还是开始吧。

梯度下降的目标是最小化成本函数。这意味着我们要为我们的模型确定最低的成本，因为这样做可以找到误差幅度最小的假设。该值将被表示为函数的最低点，因为图的高度描述了损失。

如果要根据假设来表示这一点，我们需要一个模型来最小化所有数据点和函数本身之间的垂直差异之和，因为误差是根据预测输出与实际输出计算的，并在 y 轴上测量。

Minimizing the distance on the y-axis between the function and data points minimizes the cost.

通常用于解释梯度下降的类比如下:

你站在山顶，周围是山谷。你想通过最有效的路线到达离你很*的最低海拔。你环顾四周，朝最陡的下坡方向迈出一步。你重复这个过程，直到你在一个谷底。

山丘和山谷象征着成本函数。下坡时采取的步骤代表梯度下降的过程。

在该算法中，所述步骤通过递增地改变随机初始化的θ值来实现，以更好地表示训练数据。一旦模型符合数据，它应该能够推广到它还没有见过的例子，并根据新的信息提供合理准确的预测。

下面是梯度下降的公式。再次强调，不要感到不知所措。我将详细介绍它的内部工作原理。

算法说:对于 0 到 n(参数个数)之间的 j 的每一个值，设θ(j)等于θ(j)减去代价函数在当前坐标对θ(j)的偏导数，乘以一个值α。重复，直到成本最小化。

这可能是一句话中包含的大量信息。我明白了。继续读下去，我会澄清。

正如我们所知，导数指向函数中变化最大的方向，导数的值是计算坐标处直线的斜率。通过取导数的负值，我们得到与最陡变化方向相反的方向。这个方向是我们调整θ值的方向。这样做的原因很快就会变得明显。

对于每一个参数θ，我们通过所述参数的负偏导数的比例值来调整θ。我说缩放，是因为在执行减法之前，我们将导数乘以变量α。我将很快解释阿尔法的重要性。这改变了θ，使得它更接*其自身的值，这允许成本函数具有最小值。θ的一次变化称为一个步长。

本质上，如果θ太大，就会倒向最小值的右边。偏导数将是正的。当我们从参数中减去导数值时，会导致θ变小，更接*所需的最小值。

当θ太小时也是一样。当一个参数需要变大时，它位于最小值的左边，这就产生了负导数。减去负数会导致加法，这正是这种情况下所需要的。

让我们仔细看看:

θ的第一个值由成本函数上的紫色点表示。θ开始时过大。如您所见，该值导致损失非常高。该点的斜率相当陡，并且具有很大的正值。这个导数乘以某个小整数α，然后从θ中减去。在减法中，偏导数的大小和方向起着至关重要的作用。斜率为正时，θ(1)变小。斜率较陡或较大时，θ(1)会发生显著变化，这是合适的，因为θ距离其目标值非常远。

随着这一过程的重复，θ(1)接*损耗最小值，函数的斜率降低。由于增量的大小基于斜率，因此步长会变小。最终，变化变得无穷小，只是起到微调的作用。这个方便的细节允许梯度下降以避免超过最小值，并为参数提供非常精确和合适的值。

让我们看看这个过程如何影响太小的θ值。

上面，我们可以看到导数的值在θ(1) = -1 处小于零，因为切线的斜率在该点为负。在这种情况下，我们将反复从θ(1)中减去这个负值，慢慢增加它的值，直到它实现函数的最小化。

这个算法的另一个有趣的特点是，在任何函数的最小值，斜率是 0。这很重要，因为它告诉我们，在收敛时，当采取步骤时，θ值将不再改变。(θ(1) - 0 = θ(1)).

在多元成本函数中，我们一次更新所有的θ值，因此我们朝着最小值的增量步骤类似于梯度，如下所示:

上面，我们看到了成本函数 J(θ)。黑线显示了随着θ值的调整，梯度下降所采取的运动。记住这个过程和二维函数的过程是一样的。它只是对θ(0)和θ(1)同时执行，这是导致下降以梯度的形式出现的原因。

现在让我们回顾一下这个过程是如何用数学方法表示的。这里再一次给出了可供参考的算法:

我们已经知道θ(j)代表什么。

:=符号表示我们将变量设置为等于操作符另一端指定的值。x := 3 意味着我们设 x 等于 3。

你听说的那个阿尔法怎么样了？∝是α。∝就是所谓的超参数。这意味着它不是模型用来进行预测的值之一，而是对我们的最终模型有影响的变量。

Alpha 修改学习率，或梯度下降的增量大小。如果α取大值，梯度下降算法可以更快地收敛(达到最小值)。如果它很小，梯度下降需要更多的迭代来产生精确的模型。

所以越大越好？

嗯，没有。
如果∝太大，梯度下降可能会超过所需的最小值。如果是这种情况，算法就会出现分歧，这意味着成本越来越高。另一方面，如果α太小，可能需要数千甚至数百万的增量来实现准确的假设。

Gradient descent diverging due to an overly large value for alpha

∝有一个非常好的位置。然而，找到它是非常复杂的，模型分析需要一篇文章。现在，你应该想象找到α的最好方法是通过计算试验。
常用值介于 0.001 和 10 之间。

梯度下降方程的最后部分是成本函数相对于θ(j)的导数项。这是公式中求和项右边的部分。

下面是关于某个参数θ(j)的导数的计算方法:

对于参数θ(j):
使用(I)作为迭代器循环通过每个训练示例，从该示例的假设输出 x(i)中减去期望输出 y(i)。这个差值乘以特征 x(i)j(与θ(j)相关的特征)。这个乘积被加到一个累计和中。

注意:偏差单位没有任何相关特征，这意味着在计算偏导数时，我们不将误差(x(I)-y(I))乘以 x(i)j 的值。

求和完成后，我们将所得值除以训练示例的总数。这为我们提供了关于θ(j)的偏导数。

在同时更新所有参数之前，我们对每个参数θ重复导数计算。

现在，再读一遍梯度下降的解释:

算法说:对于 0 到 n(参数个数)之间的每个值 j，设θ(j)等于θ(j)减去代价函数在当前坐标对θ(j)的偏导数，乘以值α。重复，直到成本最小化。

我相信这一点更容易理解。

恭喜你！这就是梯度下降——最常见的机器学习算法。现在你对它有了彻底的了解。

一份总结

这是线性回归:

我们有一个数据集 X，包含训练示例 x(i)和标签 y(i)。每个例子具有特征 x(i)1 到 x(i)j，j 是特征的总数。这些特征各自提供独特的信息。

假设 hθ(x)对数据进行预测。它包含与每个特征相关联的θ值，以及偏差单位θ0，总共 j + 1 个参数。此模型通过将训练示例的每个特征与其相应参数的乘积相加，并将偏差单位添加到此总和中，来创建预测输出。

成本函数衡量假设的准确性。通过降低成本，我们获得了更精确的模型。

梯度下降可以通过基于θ值相对于成本函数的偏导数改变θ值来实现这种最小化。通过在损失函数的当前坐标处取负斜率，每个参数逐渐向图表上的最小值移动。重复这一过程，直到达到收敛。

然后，模型能够接受新数据作为输入，并产生准确的输出。

这就是线性回归。你明白吗！太神奇了！

看到我们每天都被人工智能包围，令人震惊的是很少有人理解它在做什么。这项技术发展极其迅速，这一次无知不是福。理解我们周围的世界是人类的天性。重要的是要看到什么样的进步将很快成为主流。

你现在对机器学习的专业领域有了一些了解。让我们最后看一下我们眼中的人工智能是什么:

人工智能(A.I.): 预测模型。*方误差成本函数。梯度下降算法。

出发前

• 在 Linkedin 上与我联系，有任何问题请随时联系我
• 查看吴恩达在 Coursera 上的机器学习课程，这是一个很好的、深入的机器学习入门课程
• 记住学习需要时间！对学习新的东西感到兴奋，而不是对不理解的东西感到沮丧。

假日电影的 NLP 观点——第一部分:使用 Gensim 和 SKlearn 的主题建模

原文：https://towardsdatascience.com/an-nlp-view-on-holiday-movies-part-i-topic-modeling-using-gensim-and-sklearn-5f7c15c8a65a?source=collection_archive---------24-----------------------

Photo by Tom Coomer on Unsplash

假期是家人、朋友、雪和我妻子关心的:老掉牙的假期电影的时间。

为了尝试帮助她永无止境的假日电影胃口，我们将检查我们是否可以创建一个新的圣诞电影。这篇博文由两部分组成:

• 第一部分:获取数据并尝试识别圣诞电影
• 第二部分:使用这个数据集尝试生成一个新的数据集

第一部分的代码可以在这里找到，完整的回购协议可以在这里找到。

电影

没有特别指向任何电影制作人，但就假日电影而言，霍尔马克是一座金矿。所以让我们试着去挖掘这些。

为此，我:

• 抓取了霍尔马克电影公司的维基百科页面(链接)
• 解析 2000 - 2018 年的所有电影，获取片名和日期(使用 Beautifullsoup)

事实上:圣诞电影似乎正在蓬勃发展:

标题

我对我的妻子做了一个相当大胆的声明，所有的霍尔马克头衔只是“皇家”、“圣诞节”、“婚礼”、“王子”和“爱情”这些词的组合

让我们用数据来证明这一点！在 Spacy 的快速引理化之后，只有 8 个结果支持这个假设😕。其中最精彩的是《圣诞婚礼的尾巴》，谁能忘记《婚礼进行曲 2:诉诸爱情》。

然而，“圣诞节”仍然是迄今为止最流行的术语:

数据

我们没有每部电影的抄本，但我们会尽量使用英文字幕。它可能不像真实的抄本那样具有描述性，但是生成算法应该能够提取对话。

为此，我非常感谢地使用了“imdb”和“open subtitle”API 以及它们各自的 Python 包装器。

一旦有了这些链接，我们就可以用一个简单的脚本来获取数据:

提取圣诞电影:主题建模

虽然不是所有的电影都与训练数据相关，但是我们特别想提取圣诞节的电影。让我们看看是否可以创建一个主题模型来帮助我们:

预处理

在处理文本数据时，总是需要一些预处理，在这种情况下，我们需要:

• 从字幕中删除时间戳
• 删除一些特定的标签
• 让一切变得简单
• 过滤掉“人”实体
• 删除停用词
• 删除短于 1 的字符串元素(不必要的单词和标点)

词汇化和实体抽取使用 Spacy 完成，停用词使用 NLTK 移除。

在文本清理之后，让我们检查一个主题建模分析是否可以拾取电影中隐藏的主题。我预计会出现诸如“圣诞节”、“爱情”、“婚礼”(也许是“食物”)等话题。

我们将使用流行的潜在狄利克雷分配(LDA)算法。因为没有 Python 包应该在圣诞节被冷落，所以让我们同时使用 Gensim 和 Scikit-Learn。

使用 Gensim 的主题建模

从已处理文档的列表开始，在这种情况下，每个文档都是经过过滤的词条列表，我们可以轻松地进行如下分析:

使用 SKlearn

同样，我们可以使用 Scikit-Learn 进行 LDA 分析:

结果呢

对于 Gensim 算法:

**Topic: 0** 
Words: 0.046*"christmas" + 0.008*"ice" + 0.007*"la" + 0.006*"horn" + 0.006*"holiday" + 0.006*"ok" + 0.005*"ho" + 0.005*"santa"
**Topic: 1** 
Words: 0.015*"christmas" + 0.011*"chuckle" + 0.009*"ok" + 0.008*"sigh" + 0.005*"applause" + 0.004*"york"
**Topic: 2** 
Words: 0.026*"christmas" + 0.008*"ok" + 0.008*"wed" + 0.007*"chuckle" + 0.005*"sigh" + 0.004*"mm" + 0.003*"dog" + 0.003*"alright"
**Topic: 3** 
Words: 0.052*"christmas" + 0.012*"santa" + 0.011*"la" + 0.007*"wed" + 0.007*"ok" + 0.007*"holiday" + 0.006*"ha" + 0.005*"ho" + 0.004*"york" + 0.004*"merry"
**Topic: 4** 
Words: 0.008*"christmas" + 0.008*"sigh" + 0.005*"ok" + 0.004*"chuckle" + 0.004*"wed" + 0.004*"dog"
**Topic: 5** 
Words: 0.013*"wed" + 0.012*"%" + 0.008*"ok" + 0.006*"dog" + 0.004*"alright" + 0.004*"movie" + 0.004*"mama"

对于 SKlearn 算法:

**Topic 0:**
christmas mama king window turkey note corner process embarrass tea
**Topic 1:**
group golf hon i. mm birthday pot split pink successful
**Topic 2:**
ok wed alright farm bride cake christmas york marriage camp
**Topic 3:**
kill chase christmas disappoint empty mystery possibility chief awkward dr.
**Topic 4:**
christmas ok wed chuckle la sigh alright santa mm dog
**Topic 5:**
chef silver honestly dog idiot wed race deliver kick climb

所以没有一个能真正抓住我在寻找的东西。

• 在 Gensim 的分析中，“圣诞节”似乎太普遍了
• 在 SKlearn 的分析中，情况有所好转。我怀疑 TFIDF 矢量化方案与此有很大关系。例如，主题 2 看起来主要是婚礼电影。但是，圣诞节仍然无处不在。

计划 B:集群

作为后备计划，我想尝试在 TFIDF 矢量化文档上做一个简单的 K 均值聚类练习。

这非常简单:

然后，我们可以使用 T-SNE 将 TF-IDF 向量的维数降低到 2，并使用新的聚类来给点着色。

结果看起来足够好:

(披露说明:我让我的妻子帮忙命名星团👼)

• 集群 0 看起来主要是婚礼电影
• 集群 1 看起来像爱情电影一般
• 电影看起来像爱情电影，但是有一点奇幻色彩(皇室、女巫)
• 集群 3 电影好像是季节性爱情电影(收获，夏天)
• 集群 4 电影很明显圣诞电影:头奖！
• 电影:还不确定，我妻子坚持让我们看一些电影，以获得更好的感受。不会上当的…
• 第六组电影看起来像是带有“食物”元素的电影

一些很酷的事情打动了我:电影《在圣诞节嫁给我》是圣诞电影和婚礼电影的混合体。K-means 将它标记为婚礼电影，但正如我们所见，它也可能是一部圣诞电影:

总的来说，TF-IDF 确实有助于获得一个好的聚类结果。

好的，这个肯定可以。我们将把所有的“第 4 集”电影带入我们的下一步目标，制作我们自己的圣诞电影，在这篇博文的第二部分。最终数据集(在 pandas 数据框架中)也可以在 repo 中找到。

那里见！

假日电影的自然语言处理观——第二部分:用 LSTM 的《在喀拉斯》生成文本

原文：https://towardsdatascience.com/an-nlp-view-on-holiday-movies-part-ii-text-generation-using-lstms-in-keras-36dc1ff8a6d2?source=collection_archive---------28-----------------------

Photo by rawpixel on Unsplash

继续这篇博文的第一部分,让我们看看是否可以用输入序列训练一个 RNN，并用它来生成一些新的序列。

这部分的代码可以在这里找到。完整的代码和数据(在熊猫数据框架中)也在回购中。

这个想法

使用 RNN 的工具生成文本已经做了很多次了(在这里插入安德烈·卡帕西的博客文章)。但是尽管如此，当你有大量的文本时，这仍然是一件有趣的事情。对 AI 古怪博客大声喊出来！

除此之外，我还对算法在不同参数下的行为感兴趣。

数据

我们对第一部中所有确定的圣诞电影都使用小写字幕。这里有一个片段:

" never had. we got bikes, toys, video games, all sorts of stuff. don't those marines or firemen collect toys for those kids? why are we spending the money? it's christmas. oh, bah, humbug. no one ever did anything like that for me when i was a kid. jimmy! when i get out on set, i don't want to see o"

编码数据

很容易做到:我们将语料库分割成 N 个半冗余的文本片段(作为输入)，紧随其后的字符作为输出(要预测的实际内容)。

我们每次跳过 5 个字符的事实有望成为一种规则，避免记忆整个连续的句子。

输入序列中的每个输入字符都是一次性编码的:

one-hot encoded input sequence

在这之后，我们将数据分成训练和测试集(20%)。

模型

在摆弄了一些超参数之后，我注意到下面的设置在验证损失方面取得了良好的结果:

👉提示:使用 recurrent_dropout 在处理 RNN 氏症时，不要在中间添加简单的辍学层(如果你感兴趣，这篇文章是一个很好的来源)。

👉注意:当堆叠 LSTM 层时，将 return_sequences 设置为 True，除了最后一个 LSTM 层。

授予:

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
lstm_1 (LSTM)                (None, 40, 512)           1191936   
_________________________________________________________________
lstm_2 (LSTM)                (None, 512)               2099200   
_________________________________________________________________
dense_1 (Dense)              (None, 69)                35397     
=================================================================
Total params: 3,326,533
Trainable params: 3,326,533
Non-trainable params: 0
_________________________________________________________________

训练时间

该模型训练了 50 个时期，以及一些回调函数:

参数研究

为了尝试感受模型在各种参数下的表现，我们将对不同模型中的训练测试损失进行比较。

我们每次都从基本模型开始:

• 2 个 LSTM 层，经常性辍学率为 70%
• 顶部 1 个致密层

为了稍微加快训练过程，我们只使用 20%的数据进行训练，另外 20%用于测试。

当然，一些参数也会严重影响训练时间(数据量、隐藏层数等)。).如果这是一个问题，也应该考虑到这一点！

更改落差大小

👉我们可以清楚地看到，增加压差极大地减少了过度拟合

更改堆叠 LSTM 图层的数量

👉总的来说，没有太大的区别，2 层收敛更快，但是训练起来更慢

更改隐藏状态大小

👉单元越多，过度拟合的可能性越大(学习能力越强)，但收敛速度更快(尽管训练速度较慢)

更改输入集的大小

对于最后一次运行，我设置了两个实验，一个有 20%的训练数据可用，另一个有 80%的训练数据可用(同样的 20%每次用于测试集):

不出所料:添加更多的数据会带来最大的性能提升。

这让我想起了 Peter Norvig(以及其他人)的一篇著名论文:数据的不合理有效性

输出

摆弄够了，让我们看看输出是否有任何好处！

我们要做的是:

1. 取一个 40 个字符的起始种子句子
2. 编码它
3. 预测下一个第 41 个字符
4. 将窗口向前滚动一个字符，以便预测第 42 个字符
5. 重复

为了预测下一个字符，我们使用“温度”原理。我们不是简单地选取概率最高的字符，而是从一个概率分布中取样(为什么会这样马上就清楚了):

让我们看看这是如何发挥作用的。起始种子是:

"那是圣诞节的前一天晚上，t . "

使用温度= 0.00

那是圣诞节的前一天晚上，我成了圣诞树的一部分。我不知道我是最好的圣诞树。我不知道我是最好的圣诞树。我不知道我是最好的圣诞树。我不知道我是最好的圣诞树。我不知道我是最好的圣诞树。我不知道我是最好的圣诞树。我不知道我是最好的圣诞树。我不知道

使用温度= 0.25:

那是圣诞节的前一天晚上，我感到非常抱歉。我想我很抱歉我很抱歉。我不知道我和那个问题一样。你猜怎么着我不知道我有多漂亮。我在想，最好的圣诞夜圣诞树是最好的圣诞礼物之一，圣诞晚会的圣诞树让我大吃一惊。对不起，我会说我太美了。我不知道。我不知道

使用温度= 0.50:

那是圣诞节的前一天晚上，几年前我本打算让你参加假日射击赛。我会跟你谈的。你认为我和我最喜欢的人做了那么多，然后我把我们带到了树上。我想我很抱歉。我不知道。他们做了什么？呃，好吧，有个舞会，我得去拿些我不能说的关于树灯的东西。不不不不太好了。现在，我只是一个坏想法

使用温度= 0.75:

那是圣诞节的前一天晚上，t 他看着自己。你有点太固执了。这对你来说是一种力量。嘿，我得走了。先生。好吧，我会和所有新饼干的负责人谈谈。[笑]我不能说不。不，不，不，不，无论如何。嗨。珍妮小姐的艾米丽你不会很好的。那是我父亲的感冒。[笑]什么？有六天时间我要离开他们。是啊，难道你不知道吗？n

使用温度= 0.9:

那是圣诞节的前一天晚上，请给我一棵好圣诞树。你说得对。伙计，提尔不会来帮忙了吗？这是他们从来没有谈过的交易。哦，何亚！呵呵。不，我知道这不是你不了解我的原因。你会没事的。嗯嗯。你知道你去哪里奇怪。哦，嗯，让我看看那一年妈妈可以变身了。欢迎来到

我们看到，使用概率最高的预测字符(温度= 0)只会将我们带入一个重复的循环。

提高温度会赋予模型更多的“创造力和自由”。在某种程度上,[叹息]和[笑声]混在了一起。

气温升高还会增加出现晦涩难懂的单词的风险，比如“goving”和“sost”，以及不连贯的句子。

故事板

嗯，看起来这位模特肯定学到了一些圣诞概念，比如树和灯。

尽管如此，这似乎还不是一个完整的电影剧本😕…

也许如果我们添加一些图纸，事情会看起来更好！让我们试试上面生成的内容(温度 0.5)

👉提示史诗绘画技能

嗯…不是真的，虽然它是…

现在让我们把电影写作交给专业人士吧。

如果有人想玩的话，我也上传了模型的最佳重量到 GitHub。

更多生成的片段(种子每次都以粗体突出显示)，它甚至似乎在某个时候制作了一首歌曲:

**what do you mean you forgot the presents?** i think that you would like to see you that parade. ♪ ♪ we wish you a terrible and children ♪ ♪ the annie last night ♪ ♪ i would love to a project ♪ ♪ and the way ♪ ♪ it's a little bit ♪ ♪ we're selling a little bit since when it was a camera for you. i don't know what i mean. i know that i'm going to be pretty good to ask you again. come on, come on. i mean, i was a consider make one of your li**it was the night before christmas, and t**he problem to the prince was that i would have to be the bigger of the family. you were about the boys and the holidays. and i don't know. i love the store. i don't know what i don't know what i see that is a decorating christmas tree and i have to get it. i don't know what i don't know what i was the boys and i can do it for the company of the company this company and the tree is the boys and i have**i don't know jake, the christmas tree** in new york can be a christmas pageant. i mean, i can't take it to the best virgin suits and the holidays were making this year's man. you know, it's been a lot of ready to be the past for us and we'll get back to the store that you can ask you a movie. it's good to make a boyfriend. yeah, i think you're gonna be next week. well, he's a sweet. i could be in the day that you don't mind if i don't want t**are you okay, didn't you hear the jingle**? i mean, i broke my mom so look at this. well, i have to be a sec. i'm so sorry. it's not a basketball, i don't think that's really good. thanks. i love you, and i wish you two pass. i know. i do... you know. i think i'm thinking about your life. the book. so thank you. so let's just the book room. oh, good to get ahead. so you can relat**are you okay, didn't you hear the jingle**? well, i didn't think that's cool. i know it, that's what i was the perfect for the holidays. doesn't see you and i wish you a very nice guy. you know, i told you it mean it cookies. you know, i told you it mean it. we're going to be a surprises. i know. i think i'm the best christmas trees. i think i know what they have been for christmas? maybe i could see why you don't want to go to play that yo

恰当的标题

不亚于一个圣诞奇迹，AI weirdness 刚刚发布了一篇关于为一部圣诞电影命名的博文。以下是其中的一些:

圣诞生物案例
春天的圣诞节
一只圣诞猫
一只圣诞虱子
接*圣诞节
树屋圣诞节
圣诞节的喧闹

就这样吧，如果你有任何反馈、意见或想法，请随时告诉我。

节日快乐！

数据可视化中的色彩颂歌

原文：https://towardsdatascience.com/an-ode-to-color-in-data-visualizations-3192399f43d0?source=collection_archive---------9-----------------------

数据可视化中颜色的使用在讲述一个故事时起着至关重要的作用。使用尽可能多的颜色使可视化看起来“漂亮”是很诱人的，尤其是作为数据可视化领域的初学者。我的建议是尽量避免在视图中使用太多的颜色。

如果使用颜色作为一种方法，将观众的注意力吸引到你想要在视觉上突出的特定点上，会更有效。

让我们看一个例子→如果我们以一个灰度(没有其他颜色)开始我们的可视化，然后思考我们想要讲述什么故事，我们可以使用颜色来帮助我们讲述这个故事。

下面的灰度仪表盘是起点。

这些图表试图回答的三个问题是:

1.哪些州最赚钱？

2.哪些产品类别利润最高？

3.哪种运输方式最有利可图？

由于这三个问题都与盈利能力有关，我们可以为“盈利能力”指定一种特定的颜色，并在整个仪表板中使用该颜色。

让我们用亮蓝色来显示这些不同属性的盈利水*。

将仪表板上的标题更改为“跨各种属性的盈利能力”，并将单词“盈利能力”更改为蓝色，有助于突出显示，并减少可能会扰乱视图的彩色图例的需要。它告诉观众，当你看到蓝色时，我们意味着它有更高的盈利能力。

下面是同一个仪表板，有效地使用颜色来讲述一个故事:

谨慎使用颜色非常重要，尤其是当您在仪表板上的多个工作表中使用一种颜色时。人们认为相同的颜色在所有工作表中都是相关的。

这是一个用颜色来讲述故事的小例子。你对色彩的运用有什么想法？下面是该仪表板的前后图像。

深入研究图像分类

原文：https://towardsdatascience.com/an-overview-of-image-classification-networks-3fb4ff6fa61b?source=collection_archive---------4-----------------------

了解用于图像分类的不同网络架构是一项艰巨的任务。在这篇博文中，我将讨论目前在 keras 包中可用的主要架构。我将按时间顺序浏览这些架构，并试图从从业者的角度讨论它们的优缺点。

关键概念

尽管计算机视觉领域的不同研究人员倾向于遵循不同的实践，但总体而言，在设置实验时，您可以看到以下趋势。我讨论了如何对图像进行预处理，使用什么类型的数据增强，优化机制和最终层的实现。

预处理
通常，在训练集上计算*均像素值，并从图像中减去。请注意，在将这些模型与 keras 一起使用时，将这一点考虑在内非常重要。Keras 为每个计算机视觉模型提供了不同的“预处理”功能。

数据扩充
影像分类研究数据集通常非常庞大。然而，数据扩充经常被用来提高泛化性能。通常，使用随机裁剪重新缩放的图像以及随机水*裁剪和随机 RGB 颜色和亮度偏移。存在不同的重新缩放和裁剪图像的方案(即单尺度对多尺度训练)。测试期间的多作物评估也经常使用，尽管计算成本更高且性能改善有限。请注意，随机缩放和裁剪的目标是了解每个对象在不同比例和位置下的重要特征。Keras 没有实现所有这些现成的数据扩充技术，但是它们可以通过 ImageDataGenerator 模块的预处理功能轻松实现。安德鲁·霍华德的数据扩充技术更深入地解释了关键方法。

An example of different crops of the same picture (Image taken from Andrew Howard’s paper).

训练机制带动量的 SGD 或 RMSProp 经常被用作优化技术。学习率方案通常相当简单，要么在验证损失或准确度开始稳定时降低学习率，要么在固定间隔降低学习率。使用 keras 中的“ReduceLROnPlateau”回调，您可以很容易地模仿这种行为。

An example of the training procedure where the LR is reduced then a plateauing loss is noticed.

最后一层
传统上，图像分类网络的最后一层是全连通层。这些层是大量的参数猪，因为你需要 NxM 个参数从 N 到 M 个隐藏层节点。如今，这些层已经被需要更少参数和计算时间的*均或最大池层所取代。在 keras 中微调预训练网络时，考虑这一点以限制添加的参数数量是很重要的。

VGGNet

最初由卡伦·西蒙扬和安德鲁·齐泽曼于 2014 年发表， VGGNet 表明，堆叠多层是计算机视觉良好性能的关键组成部分。他们公布的网络包含 16 或 19 层，主要由小型 3×3 卷积和 2×2 汇集操作组成。

作者的主要贡献是表明堆叠多个小滤波器而不合并可以增加网络的代表性深度，同时限制参数的数量。通过堆叠例如三个 3×3 conv。代替使用单一的 7×7 层，克服了几个限制。首先，组合三个非线性函数而不是单个非线性函数，这使得决策函数更具区分性和表达性。第二，参数的数量减少了 81%,而感受野保持不变。因此，使用较小的滤波器也可以作为正则化器，提高不同卷积滤波器的效率。

VGGNet 的缺点是评估起来比浅层网络更昂贵，并且使用更多的内存和参数(140M)。这些参数中的许多可以归因于第一个完全连接的层。已经表明，可以移除这些层而不会降低性能，同时显著减少必要参数的数量。VGG 在 keras 上提供 16 层和 19 层两种预训练重量。

雷斯内特

ResNet 体系结构是由何等人开发的，试图训练具有更大深度的网络。作者指出，增加网络深度会导致更高的训练损失，这表明由于梯度问题(爆炸/消失梯度)而存在潜在的训练收敛问题。

Although the space of potential functions of a 20-layer network is encapsulated within the space of a 56-layer network, with convential gradient descent, it is not possible to achieve the same results. (Image taken from the ResNet paper)

他们的主要贡献是在神经网络体系结构中增加了跳跃连接，使用批量标准化并在网络末端移除完全连接的层。

With a skip connection, the input x of a convolutional layer is added to the output. As a result, the network must only learn ‘residual’ features and existing learned features are easily retained (Image taken from the ResNet paper).

跳过连接是基于这样一种思想，即只要神经网络模型能够将信息从前一层“正确地”传播到下一层，它就应该能够“无限地”深入。在没有通过更深入来聚集附加信息的情况下，具有跳跃连接的卷积层可以充当身份函数。通过向网络添加跳跃连接，卷积层的默认功能变成了识别功能。滤波器学习到的任何新信息都可以从基本表示中减去或添加到基本表示中，因此更容易优化残差映射。跳过连接不会增加参数的数量，但是会导致更稳定的训练和显著的性能提升，因为可以获得更深的网络(例如，深度为 34、50、101 和 152 的网络)。请注意，1x1 卷积用于将图层输入映射到其输出！

除了跳跃连接之外，在每次卷积之后和每次激活之前使用批量归一化。最后，完全连接的层被移除，取而代之的是使用*均池层来减少参数的数量。由于更深的网络而增加的卷积层的抽象能力减少了对完全连接的层的需求。

谷歌网

谷歌网的论文与雷斯网的论文几乎同时发表，但引入了不同的改进。前两篇论文着重于增加分类网络的表示深度。
然而，使用 GoogLeNet，作者仍然试图扩大网络规模(多达 22 层),但同时他们的目标是减少参数数量和所需的计算能力。最初的 Inception 架构由谷歌发布，专注于在大数据场景和移动设置中应用 CNN。该架构是完全卷积的，由初始模块组成。这些模块的目标是通过构建由多个构建块组成的复杂滤波器(例如，网络中的网络—初始)来提高卷积滤波器的学习能力和抽象能力。

An example of an Inception module. The 1x1 convolutions are performed to reduce the dimensions of input/output (Image taken from the GoogLeNet paper).

除了初始模块，作者还使用辅助分类器来促进更稳定和更好的收敛。辅助分类器的思想是使用几种不同的图像表示来执行分类(黄框)。因此，在模型的不同层计算梯度，然后可以用于优化训练。

A visual representation of the GoogLeNet architecture. The yellow boxes indicate the presence of auxiliary classifiers.

Inceptionv3

Inceptionv3 架构结合了几项创新。在 Inceptionv3 中，主要关注的是重用 GoogLeNet 和 VGGNet 的一些原始想法，即使用 Inception 模块，并用一系列较小的卷积更有效地表达大型过滤器。除了小卷积之外，作者还试验了非对称卷积(例如，用 nx1 和 1xn 代替 nxn，而不是多个 2x2 和 3x3 滤波器)。

An example of a 3x3 filter followed by a 1x1 filter, effectively replacing a 5x5 filter (Image taken from the Inceptionv3 paper).

作者通过执行批量标准化和标签*滑改进了网络的正则化。标签*滑是给每个类分配一些权重的做法，而不是给地面真实标签分配全部权重。由于网络在训练标签上的过度拟合会更少，它应该能够更好地概括，这与使用 L2 正则化是类似的做法。

投入了大量精力来确保该模型在高分辨率和低分辨率图像上都表现良好，这是通过分析不同比例的图像表示的初始模块来实现的。因此，当初始网络用于对象检测框架时，它们在分类小的和低分辨率的对象时表现良好。

纳斯网

我将讨论的最后一个图像分类架构是 NASNet ，它是使用神经架构搜索(NAS)框架构建的。NAS 的目标是使用数据驱动的智能方法来构建网络架构，而不是直觉和实验。虽然框架的细节我就不赘述了，但大致思路还是说明了。
在初始文件中，显示了“单元”中过滤器的复杂组合可以显著改善结果。NAS 框架将这种单元的构建定义为优化过程，然后堆叠最佳单元的多个副本来构建大型网络。

最终，构建两个不同的单元并用于训练完整的模型。

结果

下表摘自 Keras ，它很好地概括了我所讨论的不同网络的结果。请注意，VGG 以其大量的参数脱颖而出，而 Resnet50 和 Inceptionv3 以其令人印象深刻的网络深度脱颖而出。在撰写本文时，NASnet(不在表中)在 ImageNet 上以 82.7%的前 1 名和 96.2%的前 5 名准确率实现了最佳性能。

问题

如果你有任何问题，我很乐意在评论中阅读。如果你想收到我博客文章的更新，请在 Medium 或 Twitter 上关注我！

解决多重比较问题的方法概述

原文：https://towardsdatascience.com/an-overview-of-methods-to-address-the-multiple-comparison-problem-310427b3ba92?source=collection_archive---------2-----------------------

作为数据科学家，我们处于独特的地位，可以在更大的背景下评估变量之间的关系，并最终用统计数据讲述故事。

简而言之，我们使用假设检验来证明关于我们数据的一些假设。

这是一个相当简单的过程，直到我们想同时测试一组假设。在这篇文章中，我将回顾进行这种多重比较的问题以及如何相应地解决它们。

我们如何首先开始调查我们对一种情况的信念？嗯，我们可以用现有的数据进行所谓的假设检验，以评估我们的主张。

让我们考虑一下目前正在开发的药物 A。我们感兴趣的是，与安慰剂(一种没有治疗效果的“糖丸”)相比，药物 A 是否真正改善了患者的自测疼痛。

Does Drug A actually improve pain more than just the act of taking a drug?

我们如何明显地测量和确定“效果”？仅仅假定药物 A 比安慰剂好是不够的。我们希望在现有数据的基础上，通过具体的测量来实现这一点。出于本例的目的，让我们假设患者使用从 0 到 10 的数值范围报告疼痛。我们可以收集疼痛分数，然后比较两组的*均分数:实验组(服用药物 A)和对照组(服用安慰剂)。值得注意的是，每一组都旨在代表更广泛的患者群体。

对于我们的假设检验，我们必须指定以下内容:

• 零假设:我们寻求反驳的东西，通常是“现状”(即没有影响或差异)。这里，我们的零假设是药物 A 和安慰剂在改善自我报告的疼痛方面没有差异(手段相同)。
• 替代假设:我们的利益效应，或者无效假设的对立面。我们会说，我们的替代假设是，药物 A 和安慰剂在改善自我报告的疼痛方面存在差异(手段不一样)。
• 显著性水*(α):假设假设为真，错误拒绝零假设的概率(假阳性)。这总是在每一个假设检验的开始就被确立。

其中，α可能与多重比较问题最相关。重要的是首先要彻底了解α在假设检验中是如何使用的。

如果我们发现两组的*均疼痛评分有差异，这真的有什么意义吗？我们可以定义界限，允许我们确定任何观察到的差异是否极端到足以反映实际的影响/关系，或者更可能是由于偶然。

因为我们有每个患者的疼痛评分，所以我们可以描述每个组的评分分布。对于这个例子，我们会说，对于两个组，数据大致呈正态分布。

每一个假设检验都是基于所讨论的总体的某种类型的分布。任何给定的分布都以*均值(μ)为中心，并以数据的分布(标准差，σ)为特征。大多数假设检验及其假设都基于正态或高斯分布。

Gaussian (normal) distribution

如上所述，对于我们的患者群体，99.7%的数据应落在*均值的 3 个标准差内。利用这个分布，我们可以确定一个给定的观察值离*均值有多少标准偏差。观察值离*均值越远，就越不寻常。

更专业地说，*均值的标准偏差数可以用一个 z 值来表示。我们使用 z 分数作为一种标准化我们观察到的情况的方法，计算如下:

z-score formula

利用中心极限定理，我们可以假设数据是正态分布的。

然后，我们可以计算数据的检验统计量。我们需要将这个测试统计数据与某个阈值进行比较。如果我们的检验统计量超过了这个阈值，那么我们的发现就具有统计学意义，而不太可能仅仅是由于偶然。

我们使用预先确定的显著性水*(α)来定义阈值。

通常，α被设置为 0.05，尽管这可能因研究领域而异。这是什么意思？这意味着如果你发现了一个效应，你愿意有 95%的信心认为你的结果在统计学上是显著的，并且有 5%的可能性是由于偶然因素。

我们可以再看看我们的标准正态分布，我们用它来通知我们所有的计算。

α定义高斯曲线的拒绝区域。极端结果存在于曲线的末端，离*均值最远。选择拒绝区域，使得当零假设为真时，它包含检验统计量的概率等于α。

因为我们的假设只说明了药物 A 和安慰剂之间的差异，所以我们从两个方向检验了这种关系:药物 A 可能比安慰剂好，也可能比安慰剂差。因此，这是一个双尾假设检验，我们观察高斯曲线的两端。我们在两个尾部之间*均分配α，因此每个尾部将包含 0.025。

在这里， p 值指导我们的决策。如果零假设为真，p 值是至少与样本数据中观察到的结果一样极端的效应的概率。如果检验统计量落在拒绝区域内，那么 p 值将小于α。我们可以说，与安慰剂相比，我们有 95%的信心认为药物 A 显著减少了患者自我报告的疼痛。有 5%的可能性，观察到的效果是由于偶然。因此，我们拒绝零假设。

我们希望从一开始就确定α，因为我们希望控制错误拒绝零假设的概率，或者从一开始就控制我们的 1 型错误。这对于单个假设检验来说相当简单。

但是如果我们想测试多个假设呢？在 AB 测试中，您可能会遇到这种情况，当您想要相互比较一个位点的多个变体，或者在药物测试中治疗的多个症状时。你需要多个零假设，每个“变异”一个。

每个假设都有一个单独的α，代表该特定测试的 1 类错误率。随着假设数量的增加，测试集的总α也会增加，因为单个α会累积。对于α=0.05 水*的单一假设检验，1 型错误率仅为 5%。只有 5%的机会错误地拒绝零假设。然而，对于 2 个假设检验，总α变为 0.10。错误地拒绝至少一个无效假设的概率是 0.10。随着每次新比较的增加，总α值迅速增加:

Overall α ≤ 1-(1-α*)

现在，为什么不仅仅局限于一个单一的测试，避免这种混乱的复杂性呢？效率和实际考虑可能需要多次比较。假设我们对药物 A 如何减轻疼痛、减少头痛的发生率、等感兴趣。基于多项临床上有意义的测量，进行一系列测试来了解药物 A 的总体疗效是有意义的。

所以，我们想控制我们的 1 型错误。我们可以用两种不同的方法来解决这个问题。

1. 控制总体α(也称为家族误差率或 FWER )，这将影响每次测试的α。也就是说，我们正在控制使至少出现一次*错误发现的总体概率。Bonferroni 和 Sidak 校正全部控制 FWER。
2. 控制错误发现率 (FDR)。当 FWER 控制发生 1 型错误的概率时，这些程序允许 1 型错误(假阳性)，但控制这些假阳性相对于真阳性的比例。这是通过调整与每个单独测试相关的 p 值来决定是否拒绝来实现的。因为这将导致更高的类型 1 错误率，所以它具有更高的功率。这为真正的发现提供了更高的可能性。FDR 的步进程序控制。

下面，我将提供一个多重比较可用校正程序的简要概述。

Bonferroni 校正 Bonferroni 校正是最保守的校正，也可能是最直接的方法。简单的用α除以测试次数( m )。

但是经过多次测试，α*会变得很小。这降低了功率，这意味着我们不太可能做出任何真正的发现。

西达克校正 α* = 1-(1-α)^(1/m

霍尔姆的降压程序 Bonferroni 修正的更新，此程序更强大。霍尔姆的程序不是控制 FMER，而是控制错误发现率 (FDR)，并在进行所有假设检验并在集合中找到相关的αp 值后执行。

降压过程最好用一个例子来说明。假设我们有三个假设，每个假设都有相关的 p 值:

H1:0.025
H2:0.003
H3:0.01

步骤 1:从最小到最大排列 p 值

H2:0.003
H3:0.01
H1:0.025

第二步:对排名第一(最小)的 p 值使用 Holm-Bonferroni 公式

α* = α/(n-rank+1)

α* = 0.05/(3–1+1) = 0.0167

步骤 3:将排名第一的 p 值与步骤 2 中计算的α*进行比较

0.003 < 0.0167

因为 H2 的 p 值小于计算出的α*，我们可以拒绝 H2。

移动到下一个等级 p 值并重复步骤 2–3，计算其各自等级的α*并将其与该 p 值进行比较。继续直到你到达第一个未被拒绝的假设。那么你将无法拒绝以下所有假设。

Hochberg 的升压程序
比 Holm 的降压程序更强大，Hochberg 的升压程序也试图控制 FDR，并遵循类似的程序，只是 p 值从最大到最小排列。

对于每个分级 p 值，将其与为其各自等级计算的α*进行比较(公式与 Holm 的程序相同)。测试继续进行，直到你到达第一个未被拒绝的假设。那么你将无法拒绝以下所有假设。

出于这篇博文的目的，我将只简要地提及另外两种众所周知的纠正方法，它们比这篇博文所能容纳的要复杂一些。

图基的程序 图基的程序是单步多重比较测试，仅适用于您对所有可能的均值对进行比较的情况；它同时这样做。它本质上是一个校正 FWER 的 t 测试。

邓尼特校正 邓尼特校正类似于图基的程序，除了它涉及每个*均值与单个控制*均值的比较。

这两个程序都使用了 ANOVA 测试，该测试允许您测试多个组，以查看任何组之间是否有显著差异(零假设:μ1 = μ2=…=μk)。然后，Tukey 的程序或 Dunnet 的校正可以让您识别哪些对显著不同。

当然，进行多重比较并不简单。然而，我希望这篇文章有助于阐明我们作为数据科学家的选择，以减少错误的结论，同时有足够的灵活性做出一些正确的结论。

蒙特卡罗方法综述

原文：https://towardsdatascience.com/an-overview-of-monte-carlo-methods-675384eb1694?source=collection_archive---------1-----------------------

蒙特卡罗(MC)方法是计算算法的一个子集，它使用重复随机采样的过程来对未知参数进行数值估计。它们允许对涉及许多随机变量的复杂情况进行建模，并评估风险的影响。MC 的用途非常广泛，并在物理学、博弈论和金融领域导致了许多突破性的发现。蒙特卡洛方法的范围很广，但它们都有一个共同点，即它们都依赖随机数生成来解决确定性问题。我希望概述一下 MC 的一些基本原理，也许会让你对它们可能的应用感到兴奋。

source: mathworks.com

这个概念是由数学家斯坦尼斯劳·乌拉姆发明的，他发明了这些方法，作为他对曼哈顿计划的贡献的一部分。他使用随机抽样和推断统计的工具来模拟结果的可能性，最初应用于纸牌游戏(蒙特卡洛纸牌游戏)。后来，乌拉姆与合作者约翰·冯·诺依曼合作，利用新开发的计算机技术进行模拟，以更好地了解与核项目相关的风险。你可以想象，现代计算技术允许我们用大量随机参数来模拟更复杂的系统，就像我们在日常生活中遇到的许多场景一样。然而，在我们考虑复杂系统之前，让我们先讨论一个简单的例子；二十一点的游戏。

如果我们想知道得到 21 点(一张 a 和一张 10 值的牌)的概率，我们可以简单地计算这种情况下可能的手牌数量，然后除以可能的牌组合总数来得到概率(如果你想知道的话，大约是 1/21)。但是现在想象一下，我们的样本空间很难计算，例如，我们的一副牌有数千张，而不是只有 52 张，或者更好的是，我们甚至不知道有多少张牌。还有一种方法可以求出这个概率。

Photo by Kay on Unsplash

我们可以蹲在桌子旁玩一百场游戏，一边玩一边记录结果。我们可能得到 19 次、20 次甚至 28 次 21 点，并使用这些值中的任何一个来分配概率。看起来这是一个很糟糕的评估我们在赌场赔率的方法，但是希望我们只是玩着玩着。如果我们再来一次，玩一千次，一万次，几百万次，大数定律说:

“随着同分布、随机生成的变量数量的增加，它们的样本均值接*它们的理论均值。”

除了是统计学最重要的定律之一，这也是蒙特卡罗模拟的基础，允许我们通过统计试验的方法建立随机模型。让我们看看我最喜欢的(可能也是最简单的)MC 估计的例子。

圆周率的蒙特卡罗估计

正如我们在文法学校几何课上所学的那样，圆周率是一个常数，它表示圆的周长与直径之比。它是无理数，这意味着它有无限个没有模式的数字。如果我告诉你，我们可以通过玩一个简单的飞镖游戏来估算任意位数的圆周率，你会相信吗？当然有一定的不确定性，毕竟我们是在玩一场碰运气的游戏！让我们编写一个简短的 python 脚本来看看如何实现。

如你所见，我们在一个盒子里随机生成点，并计算嵌入圆内的点数。为了简单起见，我们只看一下我们的飞镖靶的上象限，半径为 R，安装在一块同样宽度的正方形木头上。如果我们投掷 100 个飞镖，并计算成功击中镖靶的飞镖数量，我们可能会得到以下图形。

如果你在想:“为什么我们这么不擅长这个？”你问对了问题。对于这个例子，我们的飞镖位置必须是均匀分布在整个区域，所以我们在这里肯定不会赢太多游戏。从我们游戏的设置来看，飞镖击中棋盘的概率会是π/4。随着我们继续玩下去，当 n->∞时，我们接*这个真实值(感谢伯努利！).我们可以看到，当 n 增加 10 个数量级时，这种情况会发生在下面。

**

Plots for n= one, ten, and one-hundred-thousand, and finally one million points.

你可能会说:这很好，但我已经知道圆周率是 3.14159…而现实世界中有什么是均匀分布的呢？不要担心，因为当使用 MC 方法来建模更高维度的系统时，我们将需要对各种随机变量进行采样，用不同的概率分布来更准确地表示我们的模型中参数的影响。我能用这个做些什么真实的事情呢？

高能物理学

蒙特卡洛的一个主要应用是粒子物理领域，它与我的心灵息息相关。在量子(非常小的尺度)世界中，事物不容易被观察到，在粒子加速器的碰撞点尤其如此。MC 方法允许物理学家根据标准模型和以前实验中确定的参数来模拟这些事件。像 LHC 这样的大规模项目已经产生了大量的数据，所以在我们开始随机抽样之前，N 就已经很大了。所以 MC 的一个小用处是探索物质本身的基本结构。

金融

如果这对你来说还不够令人兴奋，MC 在金融工程中被广泛用于股票市场预测。这具有直观的意义，因为市场难以建模，具有难以置信的高维度，并且有大量数据可供采样。风险的重要性是金融分析师使用 MC 方法的另一个重要因素。蒙特卡罗在这个领域的一个相对直接的应用是投资组合优化。我强烈推荐这篇关于这个主题的博客文章，它详细阐述了如何为这种类型的分析编写代码，但总结起来:

当选择股票投资组合时，你可能愿意根据你的目标承担不同程度的风险。但是，不管你是否愿意接受风险，你都可以通过蒙特卡罗方法找到股票的最佳组合和比例，从而最大化投资组合的单位波动率收益。利用历史数据，人们可以生成成千上万不同比率的股票组合，以观察在这段时间内每只股票的相对表现。然后，人们可以使用一种称为夏普比率的指标(一种在给定风险的情况下衡量投资回报表现的指标)来选择最佳配置。)

如果财富和知识的承诺不足以激起你的兴趣，马尔可夫链蒙特卡罗方法为训练深度学习算法提供了一个强大的工具。数据科学家和机器学习工程师可以使用这些技术来做各种奇怪而奇妙的事情。如果你有兴趣阅读更多关于蒙特卡洛的资料，我推荐以下资源:

*初学者:【http://www.statisticshowto.com/monte-carlo-simulation/ *

* [## 用蒙特卡罗方法估算圆周率

如何使用蒙特卡罗方法估计圆周率的值——生成大量随机点，看看有多少…

academo.org](https://academo.org/demos/estimating-pi-monte-carlo/)

中级:【http://mathforum.org/library/drmath/view/51909.html】T4

"Algorithms like these, which use random numbers to approximate 
deterministic outcomes, are called Monte Carlo methods, after the 
famous casino city where random numbers produce a deterministic 
outcome (the house wins the gambler's money)."
- Doctor Jubal, The Math Forum

高级:http://farside . ph . ute xas . edu/teaching/329/lections/node 109 . html

https://www . coursera . org/lecture/Bayesian-methods-in-machine-learning/Bayesian-neural-networks-HI8ta*

一个 R-docker hello world 的例子

原文：https://towardsdatascience.com/an-r-docker-hello-world-example-881e771214e2?source=collection_archive---------3-----------------------

是的，我变成了那种“我们可以用集装箱装这个！”人们。

我保证我不仅仅是一个趋势追随者——容器技术对于我们为自己和客户构建定制分析应用的团队来说有着惊人的前景。

我们使用 R 统计编程语言/环境来构建从机器学习解决方案到报告仪表板的一切。r 对于分析和快速原型开发来说是一个很好的环境，但是它传统上是一个统计脚本环境，并且缺少一些传统编程语言的“生产就绪”特性。

Docker 为我们提供了一种基于每个应用管理依赖项和库的方法(当在一个服务器上部署多个应用时)。

这也意味着在我的机器上工作的东西有很好的机会在生产中工作。就这样，挽救了许多深夜恐慌。

关于本教程

这篇文章是我去年为我们公司的博客写的一篇博客的更新版本。它将带您完成构建、运行和连接一个运行 r 的 docker 容器的步骤

• 建立一个档案
• 建造一个容器
• 运行容器以服务于 Rstudio 环境
• 连接到该容器并运行脚本
• 将输出写回到主机上装载的数据文件夹中
• 喝一杯好茶来祝贺我们自己(开个玩笑——你可能自己就知道了)

要在家玩，从我们的 github 库克隆或下载目录。代码已经在 Linux 和 Mac 上测试过——你可能需要在 Windows 上做一些小的改动(请在评论中添加任何额外的提示)。

关于 Docker

Docker 是一个使用容器的管理系统/环境。容器建立在主机之上。它们共享相同的内核和硬件控制器，但可能有不同的 Linux 风格或库集。

我们设置容器映像,就像我们想要的容器的快照——所有的库、文件等等。然后我们运行容器来建立一个包含所有工作文件的临时实例。

完成后，我们停止容器，并且所有数据和任何本地更改都将永远丢失。

为了保存容器实例的输出，我们必须将数据写回主机或其他永久的地方。

对于这个例子，我假设你正在一台已经安装了 docker 的机器上工作。

这个例子

从https://github.com/SymbolixAU/r_docker_hello克隆或下载存储库。

使用您使用的命令行终端导航到您的新目录R_docker_hello。

在这个文件夹中，您会发现:

• Dockerfile:它位于顶层目录中，指定了我们的构建选项。
• 分析文件夹:保存一个简单的hello_world.R脚本，我们将在我们的容器中运行它
• 数据文件夹:你所见过的最简单的输入数据。我们还将在运行容器时挂载这个文件夹，并将输出写回其中。
• DockerConfig:每个人都喜欢特定的库，所以我做了一个requirements.R，它将在你构建容器时运行。

准备好了吗？让我们开始吧…

在 Dockerfile 文件中

Dockerfile 文件包含以下内容:

# Base image https://hub.docker.com/u/rocker/ 
FROM rocker/rstudio ## Install extra R packages using requirements.R 
##   Specify requirements as R install commands e.g.  
##   install.packages("<myfavouritepacakge>") or 
## devtools::install("SymbolixAU/googleway") COPY ./DockerConfig/requirements.R /tmp/requirements.R 
RUN Rscript /tmp/requirements.R ## uncomment to include shiny server 
# RUN export ADD=shiny && bash /etc/cont-init.d/add # create an R user 
ENV USER rstudio ## Copy your working files over 
COPY ./Analysis /home/$USER/Analysis 
COPY ./Data /home/$USER/Data

docker 文件用于构建容器映像。

我们从基础图像的开始。然后我们复制文件或者运行额外的命令或者设置特定的 ENV 变量。Dockerfile 位于项目的顶部，应该用大写字母 D 来命名 Dockerfile 。

在本例中，我们从来自 docker hub 的 rocker/rstudio 图像开始。这些是公开的(非官方的),但是它们是可靠的，并且得到了很好的支持。Rocker 也有 r-base (rocker/r-base)的图像和一个地理空间套件(rocker/rstudio-geospatial)。这里安装了所有基本的空间库(sp，sf ),以及所有你需要的 R 之外的东西(比如 GDAL 库)。

为了安装额外的 R 库，我们在requirements.R中指定它们。在构建时，该脚本被复制到实例上，并运行以安装库。

最后，构建复制我们的文件到Analysis文件夹和Data文件夹。我们将它们放在用户的主目录中，名为rstudio。

建造它

在命令行中键入以下命令。您必须与 docker 文件在同一个目录中。根据您配置服务器的方式，您可能需要在命令前使用sudo

docker build --rm --force-rm -t rstudio/hello-world .

一旦脚本运行或者你注销，这个--rm --force-rm就强制容器删除它自己。它只是阻止我们用大量的容器填充服务器，而什么也不做。

一旦这已经建立运行

docker image list

看到您的图像被添加到列表中。我们称它为rstudio/hello-world，但你可以称它为任何东西。

运行它

我们希望使用此映像访问 Rstudio，因此我们希望它作为后台服务运行(即在分离模式下)。我们使用标志-d来做这件事。如果想访问 bash shell 或其他交互模式，需要指定-it。

Rstudio 在容器内的端口 8787 上运行。我们需要用一个-p <host port>:<container port>将它映射到主机上一个未使用的端口，我们将使用 28787，但这可以是任何未使用的端口。

我们将称我们的容器为hello-world。这是简单的运行命令:

sudo docker run -d --rm -p 28787:8787 --name hello-world rstudio/hello-world

运行这个命令并通过您在<yourhostip:28787>的 web 浏览器访问容器。用户名和密码都是rstudio。

在 rstudio 中，键入

source("Analysis/hello.world.R")

您应该能够看到分析和数据文件夹，但是有两个问题。

1. 写入本地容器当然很好，但是这个数据不会是永久的。我们可以通过使用-v /full/path/to/directory将主机目录挂载为容器上的卷，将输出写回主机目录。这在开发中也很有用，因为您可以在永久主机文件夹中进行更改，这些更改无需重新构建就可以立即在容器中使用。
2. 为了写入 Docker 中的文件(通过 rstudio)，您需要拥有正确的用户 id 。有了这些摇杆图像，您可以通过在 run 命令中指定-e USERID=$UID来实现。然后，您可以编写并更改文件，并将它们保存在容器中。

在我们修复问题之前，我们需要停止正在运行的容器(这对我们没有好处):

sudo docker stop hello-world

现在让我们再试一次。如果您查看run_docker.sh，您将看到运行命令的更完整版本:

DATA_DIR=${PWD}/Data sudo docker run -d --rm -p 28787:8787 --name hello-world2 -e USERID=$UID -e PASSWORD=SoSecret! -v $DATA_DIR:/home/rstudio/Data rstudio/hello-world

注意，在上面我也手动设置了密码——你可以随意设置。

运行上面的命令，登录<yourhostip:28787>并尝试获取脚本。

它应该运行并写入数据文件夹。</yourhostip:28787>

最后，再次回到命令行。键入ls Data，您应该也会在那里看到输出文件。

还有一件事。在 rstudio 窗口中，打开Analysis/hello.world.R在底部添加一行命令，保存并运行它。

最后一个问题——如果我在命令行上检查Analysis/hello.world.R的内容(即回到主机上),它会有你的新行吗？

为什么？

最后一个挑战:

(先停旧容器)。

现在再次运行它，但是设置它以便您可以在命令行上对hello_world.R 进行更改，并立即让它们在 Rstudio 中显示和工作。

原载于【www.symbolix.com.au】。

Azure Data Studio 终极指南

原文：https://towardsdatascience.com/an-ultimate-guide-to-azure-data-studio-6bc2b53db93?source=collection_archive---------4-----------------------

Azure Data Studio 是一个跨*台的数据库工具:如果你是 MacOS 或 Linux 用户，你可以把它看作是 SQL Server Management Studio (SSMS)的迷你版，是我从虚拟机运行 SQL Server 的救星。

Azure DS 配备了 Intellisense(完全智能)、版本控制集成(Git)以及一个非常酷的 T-SQL 编辑器。它可以将您的结果保存为文本、CSV 或 JSON。

让我们开始吧:

装置

正在设置 Azure SQL 数据库:

您将需要一个服务器来链接 Azure DS(在我的例子中，我将其链接到 Azure SQL 数据库)。如果你不熟悉如何创建自己的免费 Azure SQL 数据库，你可以按照这个我之前创建的循序渐进的教程。

下载并安装 Azure Data Studio:

下载你的 Azure DS，并安装它(Mac 用户，只需双击它:D)

Azure Data Studio Connection prompt

设置您与 Azure SQL 数据库的连接:

启动时，Azure DS 会提示您连接到服务器。以下是您将需要的关键输入:

• 连接类型:微软 SQL Server
• 服务器:你可以从你的 Azure SQL 数据库中获取这段信息(如果你按照前面提到的教程，它应该类似于sql-test-medium-001.database.windows.net
• 认证类型: SQL 登录
• 用户名: 您为您的服务器设置的服务器登录 (教程)
• 密码: 与用于设置您的服务器的密码相同
• 数据库:选择您的数据库名称
• 名称(可选):好记的东西

Example of where to find your server name in Azure SQL database

测试您的连接:

停止:在你继续之前，如果你没有设置你的服务器的防火墙来允许连接，你的连接提示会弹出下面这个表格。添加您的客户端 IP 和您的 Azure 帐户，您应该可以开始了。

Firewall prompt

您应该看到您的服务器已连接。您可以通过单击左侧窗格中的下拉菜单来展开服务器中的表。

要测试您的连接，请点击新查询或点击 cmd-N 打开一个新的查询窗口。键入以下 SQL 命令来测试您的连接:
SELECT * FROM SalesLT。客户；然后点击运行。您应该会看到如下所示的输出。

你注意到智能感知在起作用吗？—这真的是我最喜欢的部分！

创建存储过程

如果你熟悉 SSMS 的作业调度，这是它的 Azure DS 等价物，只是酷得多！

1. 打开新的查询窗口或点击 cmd-N
2. 键入 sql，应该会显示一个下拉菜单。选择 sqlCreateStoredProc
3. 它将为存储过程创建一个模板。让我们把它分成不同的部分:

A.检查是否存在任何其他同名的存储过程，删除它并创建这个存储过程

B.创建此存储过程

C.执行此存储过程

4.让我们更新模板以满足我们的需求:

Example for change all occurences

• 右键单击上的stored procedure rename，单击 Change All Occurrences 并将其更改为您想要调用您的过程的名称。我把它命名为 testProc
• 同样，右键单击模式上的，单击更改所有事件，并将其更改为您的模式名称(默认情况下，如果您没有设置它，它应该是 dbo，因此将其交换为 dbo )
• 更新存储过程的函数:

1. 将@customerID作为输入
2. 选择与输入具有相同 CustomerID 的所有记录
3. 点击运行。这将创建并运行您的存储过程: EXECUTE dbo.testProc 1 将在@customerID = 1 的情况下运行testProc。

如何将输出改为 JSON

从我们刚刚使用的存储过程开始，我们将以 JSON 格式输出数据。现在，这可能在不同的场景中派上用场，但在我的情况下:它非常适合带有 javascript 前端的可视化工具。

提醒:在这个存储过程中，我们获取任何具有输入客户 id 的客户的所有数据。

现在，让我们将输出存储在一个 JSON 文件中。您只需在查询后添加这个命令:FOR JSON PATH et voilà！

让我们看看下面的输出是什么样子的。您甚至可以在任何查询之后添加这个命令，输出将是 JSON 格式。

PS:即使命令下面有一条弯弯曲曲的线——它仍然工作，相信我，我试过了:)

如何创建酷的可视化

这是一件大事——我非常兴奋 Azure Data Studio 允许你创建自己的迷你可视化，而不仅仅是一个表格。您甚至可以将它添加到一个不断刷新的仪表板中(在查询性能、PSI 计算或任何其他方面都会变得很方便)。

让我们开始吧！

创造洞察力

1. 编写一个小查询来验证这一点:
   SELECT title as Titles，count() as Count
   FROM SalesLT。客户
   按标题分组*

该查询将为客户获取所有不同的图书，然后对它们进行分组并返回每个图书的数量。

2.您可以点击右侧的图图标，而不是列表结果。

3.这将向您显示一个代表我们数据的条形图。不要忘记在条形图设置中点击使用第一列作为行标签。实际的情节是如此之酷，它向您显示了一个清晰的图例和工具提示功能，以检查实际计数。

Bar plot instead of tabulated data

如何将它变成一个仪表板小部件

1. 点击图左上角的创建洞察
2. 这将带你到一个包含一些小工具设置的新文件(查看下图)

3.选择所有widget 设置，点击右键，选择格式文档。这会帮助你看得更清楚些:)

4.打 CMD+逗号(像这个逗号,)。这将打开我们希望小部件所在的仪表板设置。只要看看下面的图片，你已经可以看到我们的部件将位于何处。

dashboard.database.widgets

5.搜索dashboard . database . widgets

6.点击dashboard . database . widgets旁边的小铅笔。并选择复制到设置。

您可以看到屏幕右侧出现了一个新的黄色部分。

7.现在让我们集中一点:还记得我们之前固定格式的小部件设置吗？—在上面的步骤 3 中— 返回并复制那些设置。

8.贴在哪里？
看图片看我下面。 JSON 是精密科学，你需要重点关注这一项。

Image Look at Me

9.将您的设置粘贴到]之前的最后一个}之后。看到那个逗号，别忘了在你粘贴的设置前加上它。

10.我们就快完成了，我保证！
点击保存，进入你的服务器主页。

11.双击 sql-test-medium(或您的服务器名称)上的。

瞧啊！看，这并不难。我希望你喜欢我对 Azure Data Studio 的快速浏览！

使用 Tensorflow 对象检测和 OpenCV 分析一场足球比赛

原文：https://towardsdatascience.com/analyse-a-soccer-game-using-tensorflow-object-detection-and-opencv-e321c230e8f2?source=collection_archive---------2-----------------------

用数据做很酷的事情！

介绍

世界杯赛季已经开始，并有了一个有趣的开端。谁曾想到卫冕冠军德国队会在小组赛中被淘汰

作为数据科学家，让我们利用这个机会对足球片段进行一些分析。通过使用深度学习和 opencv，我们可以从视频剪辑中提取有趣的见解。请看下面澳大利亚和秘鲁比赛的 gif 示例，我们可以识别所有球员+裁判，足球，还可以根据球员球衣的颜色预测球员属于哪个队。所有这些都可以实时完成。

Player detection and team prediction

你可以找到我在我的 Github repo 上使用的代码。

步骤概述

Tensorflow 对象检测 API 是用于快速构建对象检测模型的非常强大的资源。如果你对这个 API 不熟悉，请看下面我写的介绍 API 的博客，教你如何使用 API 构建自定义模型。

tensor flow 对象检测 API 介绍

使用 Tensorflow 对象检测 API 构建自定义模型

API 提供了预训练的对象检测模型，这些模型已经在 COCO 数据集上进行了训练。COCO 数据集是 90 个常见对象的集合。请参见下图中属于 COCO 数据集的对象。

coco object categories

在这种情况下，我们关心类——人和足球，它们都是 COCO 数据集的一部分。

该 API 还支持大量的模型。请参见下表以供参考。

Small subset of models supported by the API

这些模型在速度和准确性之间进行了权衡。由于我对实时分析感兴趣，我选择了 SSDLite mobilenet v2。

一旦我们使用对象检测 API 识别了球员，为了预测他们属于哪个队，我们可以使用 OpenCV，这是一个强大的图像处理库。如果您不熟悉 OpenCV，请参阅下面的教程:

OpenCV 教程

OpenCV 允许我们识别特定颜色的面具，我们可以用它来识别红色玩家和黄色玩家。请参见下面的示例，了解 OpenCV 蒙版如何检测图像中的红色。

Prediction of red areas in an image

深入探究主要步骤

现在让我们详细研究代码。

如果你是第一次使用 Tensorflow 物体检测 API，请从这个链接下载 GitHub。并使用这些指令安装所有的依赖项。

如果你没有 OpenCV 设置，请使用这个教程从源代码构建它。

我遵循的主要步骤是(请跟随我的 Github 上的 jupyter 笔记本):

• 将 SSDLite mobilenet 模型加载到图中，并加载属于 COCO 数据集的类列表
• 使用 cv2 打开视频。视频捕获(文件名)并逐个读取每一帧
• 对于每一帧，使用加载的图形执行对象检测
• 从 SSDLite 返回的结果是每个已识别的类及其置信度得分和边界框预测。因此，现在识别所有置信度大于 0.6 的人，并将他们剔除。
• 现在你有每个球员提取出来。我们需要阅读他们球衣的颜色来预测他们是澳大利亚球员还是秘鲁球员。这是由代码块检测团队完成的。我们首先定义红色和蓝色的颜色范围。然后我们使用 cv2.inRange 和 cv2.bitwise 来创建该颜色的遮罩。为了检测团队，我计算检测到多少红色像素和黄色像素，以及它们占裁剪图像中像素总数的百分比。
• 最后，将所有代码片段组合起来，同时运行所有代码，并使用 cv2.imshow 显示结果

结论和参考文献

太棒了。所以现在你可以看到深度学习和 OpenCV 的简单结合可以产生有趣的结果。现在您有了这些数据，有许多方法可以从中获得更多的见解:

1. 通过澳大利亚球门区的摄像机角度，你可以计算出有多少秘鲁球员在澳大利亚球员的球门区
2. 您可以绘制每个团队足迹的热图，例如秘鲁团队入住率较高的区域有哪些
3. 你可以画出守门员的路线

对象检测 API 还提供了其他更精确但更慢的模型。你也可以试试那些。

给我一个❤️，如果你喜欢这个职位:)希望你拉代码，并尝试自己。

我有自己的深度学习咨询公司，喜欢研究有趣的问题。我已经帮助许多初创公司部署了基于人工智能的创新解决方案。请到 http://deeplearninganalytics.org/来看看我们吧。

你也可以在 https://medium.com/@priya.dwivedi 的看到我的其他作品

如果你有一个我们可以合作的项目，请通过我的网站或 info@deeplearninganalytics.org 联系我

参考文献

• Tensorflow 对象检测 API
• 关于使用 OpenCV 检测颜色的好教程

用 cleanNLP 分析关于难民的公共话语

原文：https://towardsdatascience.com/analyse-public-discourse-on-refugees-with-cleannlp-9719a29ed898?source=collection_archive---------7-----------------------

继上一篇文章之后，当联合国谈论难民时，它谈论什么？我将分析联合国难民事务高级专员演讲中的行动驱动词，并使用 r 中的 cleanNLP 和 newsflash 包触及新闻媒体中的电视报道

提及政府间组织

我从注释单词的词性开始，并在目标名词不是很常见的单词时提取直接宾语依赖。

放大顶级名词，我们可以看到收容、遣返和流离经常出现，还有庸人自扰迫害、困境和危机。

至于排名靠前的动名对，“Seek 庇护”是出现频率最高的。

UNHCR speeches

接下来，我将调查新闻报道的内容。与印刷新闻不同，我们可以期待文字稿更加口语化。

新闻媒体提及

我利用了非常强大的 GDELT 项目，该项目监控来自世界各国的 100 多种语言的印刷、广播和网络新闻媒体。我在 r 中使用了 Newflash 包，它与GDELTTelevision Explorer 配合使用，因此目前只能捕捉美国电视新闻。

我们可以看到 CNN 对这个话题的报道最多，而更关注商业的频道显然报道较少。

在动词名词对方面，与难民相关的词比其他名词多，因为电视新闻可能会使用许多不同的方式来描述类似困境、流离失所和遣返的情况，而不是直接使用这些词。提到的顶级名词还包括边境、叙利亚、营地。

用 R 进行文本处理

在熟悉了像 tm 这样的经典软件包之后，当 tidytext 出现时，我开始尝试 NLP，这使得语料库到表格的转换很容易，并且在需要做一些简单的事情时很方便。然后我偶然发现了 spacyr ，它惊人地快速和健壮，为命名实体识别提供了简单的语法。今天，我学习了 openNLP(它位于所有其他优秀包的肩膀上)并使用它进行依赖解析。虽然还有很多东西需要探索，但它只会变得更好。

这是我关于数据科学和视觉故事的# 100 日项目的第 41 天。我的 github 上的全部代码。感谢阅读。欢迎新主题的建议和反馈。

分析转发率以确定社会影响力。

原文：https://towardsdatascience.com/analyse-retweet-ratio-to-determine-social-influence-d83bda0559d?source=collection_archive---------20-----------------------

Twitter 支持对任何特定推文的两种回应， 转发和引用推文 。引用推文很像转发，除了它们包括新的推文消息。

有一种普遍的看法， RTs 不是代言。相反，转发确实表明倾向于该推文。否则为什么会有人转发？

当前对社会影响力的分析基于引用推文与转发推文的比率。为了更深入地挖掘，引用推文的情绪需要分析，并在下一阶段进行规划。

让我们将这一分析放在几个知名人士最*的推特上，看看他们的表现如何。

在最*的 10 条推文中，多达 150 条相关推文(转发和引用推文)被用于分析。

• 首先，让我们看看唐纳德·j·特朗普和巴拉克·奥巴马。

• 让我们邀请一些名人，艾伦·德杰尼勒斯和奥普拉·温弗瑞 T20。

• 印度即将举行大选。所以让我们来看看纳伦德拉·莫迪和他最讨厌的拉胡尔·甘地相比如何。

你可以试着通过三个简单的步骤对其他感兴趣的 twitter 账号进行类似的分析。

• 使用 Twitter API 进行身份验证。

注意:要获得证书，你需要在 Twitter 上注册。

• 根据知名人物或实体的最*的推文，获取 相关推文 。

• 绘制可视化堆积条形图。

分析科研人员的迁移

原文：https://towardsdatascience.com/analyse-the-migration-of-scientific-researchers-5184a9500615?source=collection_archive---------0-----------------------

今天，我根据 ORCID (开放研究者和贡献者 ID)数据调查了科学研究人员的洲际和洲际迁移。由于不是每个人都有 ORCID，该数据集最好被视为所有研究人员的定向样本，并跟踪他们最早/最新开展研究活动的国家以及他们的博士国家。

预处理

为了清理数据，我过滤了 is_migrated=True 和最早的国家与最新的国家不同。然后，我将国家代码转换为国名和洲名，并缩短了一些国家的名称。

按大陆移动

To show directions, the chords without space at the end points to the source and those with space at the end point to the target

我们可以看到:

• 欧洲的流动性很高，有很多区域内的流动。
• 亚洲向外移民较多，主要是美洲，其次是欧洲，然后是大洋洲。
• 美洲有更多来自亚洲、欧洲和同一地区的移民。

洲内移动

对于那些移居到同一个洲的另一个国家的人来说，主要的是什么？

在美洲，涌入美国人数最多是加拿大，其次是墨西哥，古巴和哥伦比亚。

在亚洲，印度几乎完全是出境旅游，沙特阿拉伯/卡塔尔几乎完全是入境旅游。马来西亚实际上入境人数多于出境人数。

Oceania (L) Africa (R)

在欧洲，英国、德国、法国、意大利的变化最大。英国以入境游为主，而意大利以出境游为主。

在大洋洲，大多数研究人员从新西兰迁移到澳大利亚。

在非洲，南非吸引了更多来自该地区的研究人员。博茨瓦纳的流入人口也多于流出人口。

洲际运动

我们可以看到，这一运动并不局限于发展中国家和发达国家——来自发达国家的研究人员也可能继续在其他国家工作和生活。

人才流失还是新鲜血液？

为了理解入境与出境，我计算了这 3 个指标:出境/入境比率，迁出一个国家的所有研究人员的百分比和迁入的所有研究人员的百分比。

我们使用高度来表示移民的出境/入境比率，并使用向上/向下三角形的大小来显示出境/入境人数占所有记录的研究人员的百分比，以便对所有人口流动数高于*均水*的国家的人口影响进行标准化。

除了印度，中国拥有第二高的比率，5X 失去的人才比得到的多。希腊研究人员移居国外的比例最高。

就吸引研究人员而言，卡塔尔和沙特阿拉伯吸引了最多的研究人员流入，而很少有人向外流动。亚洲的新加坡和香港吸引的研究人员也比流失的多 2-3 倍。

移居国外的研究人员在哪里攻读博士学位

在迁移的研究人员中，如果我们看看研究人员是在他们最早的附属国家还是在最早的大陆的最新国家获得博士学位，我们可以看到亚洲/非洲的研究人员大多继续在他们获得博士学位的国家进行研究，而美国/欧洲的研究人员在获得博士学位后迁移。

总的来说，49%的移民研究人员在最早的国家获得博士学位，39%在最*的国家，12%在其他地方。

今天我用 circlize 包来绘制弦图，并基于分面 ggplot 制作了 marimekko。也体会到了圆图 vs 桑基的独特优势:

• 由于 Sankey 以排序的方式在不同的轴上显示源和目标，因此很容易看到顶级出站和顶级入站
• 圆形图将入站和出站组合在一起，使其更适合查看每个节点的整体移动。

这是我关于数据科学和视觉故事的# 100 日项目的第 69 天。代码在我的 github 上。感谢阅读。如果喜欢，请分享。欢迎反馈。

分析 IPL 数据，开始使用 Python 进行数据分析

原文：https://towardsdatascience.com/analysing-ipl-data-to-begin-data-analytics-with-python-5d2f610126a?source=collection_archive---------3-----------------------

数据科学/分析就是从给定的数据集中发现有价值的见解。简而言之，找到有助于商业的答案。在本教程中，我们将了解如何开始使用 Python 进行数据分析。我们在这个笔记本中使用的 Python 包有:numpy、pandas、matplotlib和seaborn

由于通常这样的教程是基于像iris这样的内置数据集，学习者更难与分析联系起来，因此学习变得困难。为了克服这一点，我们在本笔记本中使用的数据集是 IPL(印度超级联赛)数据集，发布在来源于 cricsheet 的 Kaggle Datasets 上。IPL 是世界上最受欢迎的板球比赛之一，因此我们试图解决的问题和我们试图回答的问题应该为任何了解板球的人所熟悉。

问题:

• 数据集中有多少匹配项？
• 数据集中有多少个季节？
• 哪个队因得分最多而获胜？
• 哪个队以最大优势获胜？
• 哪个队以最接*的差距(最少的得分)赢了？
• 哪个队以最少的票数获胜？
• 哪个赛季的比赛次数最多？
• 哪个 IPL 队比较成功？
• 掷硬币赢有助于赢得比赛吗？

加载库

让我们从加载上面提到的 Python 模块/包/库开始我们的分析。

import numpy as np # numerical computing 
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt #visualization
import seaborn as sns #modern visualization

为了让我们的图看起来更好，让我们为 seaborn (sns)图设置一个主题，并定义打印图的大小。

sns.set_style("darkgrid")
plt.rcParams['figure.figsize'] = (14, 8)

读取输入数据集

为了读取输入数据，让我们首先定义输入文件所在的目录/路径。这是为了确保路径首先存储在一个字符串中，然后使用相同的(连接的)文件名通过pd.read_csv()函数读取输入 csv。

file_path = 'C:\\Users\\something\\Downloads\\'
matches = pd.read_csv(file_path+'matches.csv')

获取数据的基本信息

首先，让我们检查数据集的基本信息。需要了解的最基本的信息是数据集的维度——行和列——这是我们通过方法shape得到的信息。

matches.shape
(636, 18)

然后，了解给定数据集中不同类型的数据/变量非常重要。

matches.info()
RangeIndex: 636 entries, 0 to 635
Data columns (total 18 columns):
id                 636 non-null int64
season             636 non-null int64
city               629 non-null object
date               636 non-null object
team1              636 non-null object
team2              636 non-null object
toss_winner        636 non-null object
toss_decision      636 non-null object
result             636 non-null object
dl_applied         636 non-null int64
winner             633 non-null object
win_by_runs        636 non-null int64
win_by_wickets     636 non-null int64
player_of_match    633 non-null object
venue              636 non-null object
umpire1            635 non-null object
umpire2            635 non-null object
umpire3            0 non-null float64
dtypes: float64(1), int64(5), object(12)
memory usage: 89.5+ KB

向上移动一级，让我们使用方法describe()执行一个简单的汇总统计。

matches.describe()
id
season
dl_applied
win_by_runs
win_by_wickets
umpire3
count
636.000000 636.000000 636.000000 636.000000 636.000000 0.0 
mean
318.500000 2012.490566 0.025157 13.682390 3.372642 NaN 
std
183.741666 2.773026 0.156726 23.908877 3.420338 NaN 
min
1.000000 2008.000000 0.000000 0.000000 0.000000 NaN 
25%
159.750000 2010.000000 0.000000 0.000000 0.000000 NaN 
50%
318.500000 2012.000000 0.000000 0.000000 4.000000 NaN 
75%
477.250000 2015.000000 0.000000 20.000000 7.000000 NaN 
max
636.000000 2017.000000 1.000000 146.000000 10.000000 NaN

这个基本信息检索的最后一级是查看输入数据集的几个实际行。

matches.head(2)
id
season
city
date
team1
team2
toss_winner
toss_decision
result
dl_applied
winner
win_by_runs
win_by_wickets
player_of_match
venue
umpire1
umpire2
umpire3
0
1 2017 Hyderabad 2017-04-05 Sunrisers Hyderabad Royal Challengers Bangalore Royal Challengers Bangalore field normal 0 Sunrisers Hyderabad 35 0 Yuvraj Singh Rajiv Gandhi International Stadium, Uppal AY Dandekar NJ Llong NaN 
1
2 2017 Pune 2017-04-06 Mumbai Indians Rising Pune Supergiant Rising Pune Supergiant field normal 0 Rising Pune Supergiant 0 7 SPD Smith Maharashtra Cricket Association Stadium A Nand Kishore S Ravi NaN

现在，对输入数据集有了基本的了解。我们被提倡用基本的数据分析来回答我们的问题。

数据集中有多少匹配项？

正如我们在上面看到的，id是一个变量，当每个观察都匹配时，它对数据中的每个观察进行计数。因此，获取数据集中匹配的数量与获取数据集中的行数或变量 id 的最大值是一样的。

matches['id'].max()
636

我们的数据集中有 636 场 IPL 比赛。

数据集中有多少个季节？

IPL 像任何其他体育联盟一样，一年发生一次，因此获得数据集中独特年份的数量将告诉我们数据集中有多少个赛季。

matches['season'].unique()
array([2017, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016],
      dtype=int64)

这给出了年份的列表，但是为了用所需的答案来回答这个问题，让我们计算在上面的步骤中返回的列表的长度。

len(matches['season'].unique())
10

哪个队因得分最多而获胜？

要回答这个问题，我们可以从逻辑上划分这个问题—首先我们需要找到最大跑垒数，然后我们可以找到拥有最大跑垒数的那一行(获胜的队伍)—这确实是以最大跑垒数获胜的队伍。我想在这里强调的是，将您的问题划分为逻辑子问题或模块，然后为这些子模块构建 Python 表达式/代码，最后将它们添加到所需的代码中，从而得到解决方案，这一点始终很重要。

matches.iloc[matches['win_by_runs'].idxmax()]
id                               44
season                         2017
city                          Delhi
date                     2017-05-06
team1                Mumbai Indians
team2              Delhi Daredevils
toss_winner        Delhi Daredevils
toss_decision                 field
result                       normal
dl_applied                        0
winner               Mumbai Indians
win_by_runs                     146
win_by_wickets                    0
player_of_match         LMP Simmons
venue              Feroz Shah Kotla
umpire1                 Nitin Menon
umpire2                   CK Nandan
umpire3                         NaN
Name: 43, dtype: object

idxmax将返回最大值的 id，该值又被输入到iloc中，后者获取一个索引值并返回该行。

如果我们只对那一行中获胜的队伍感兴趣，那么可以按如下方式检索。

matches.iloc[matches['win_by_runs'].idxmax()]['winner']
'Mumbai Indians'

哪个队以最多的三柱门获胜？

和上一个类似，这个问题回答起来应该比较直白。

matches.iloc[matches['win_by_wickets'].idxmax()]['winner']
'Kolkata Knight Riders'

哪个队以(最接*的差距)最少得分获胜？

要知道以最接*的差距获胜的队，我们必须做与上述步骤相反的事情。但是有一个警告。在板球比赛中，如果击球第二的队赢得了比赛(通过追逐)，就会说“第二队通过 x 次击球获胜”，如果保龄球第二队(首先击球)赢得了比赛(通过捍卫他们的得分)，就会说“第一队通过 x 次跑垒获胜”。因此，在锦标赛中，跑垒的最小胜率将总是 0，而三柱门的最小胜率也将总是 0，因为有时追赶队或有时先击球的队可能会赢。为了克服这个警告，我们只需应用一个简单的变通方法，如下所示。

matches.iloc[matches[matches['win_by_runs'].ge(1)].win_by_runs.idxmin()]['winner']
'Mumbai Indians'

我们不是只获得最低分数(总是为 0)，而是对 win_by_runs 大于或等于 1 的数据进行子集化(通过消除零问题)。

哪个队以最少的三柱门获胜？

按照与上述相同的逻辑:

matches.iloc[matches[matches['win_by_wickets'].ge(1)].win_by_wickets.idxmin()]
id                                   560
season                              2015
city                             Kolkata
date                          2015-05-09
team1                    Kings XI Punjab
team2              Kolkata Knight Riders
toss_winner              Kings XI Punjab
toss_decision                        bat
result                            normal
dl_applied                             0
winner             Kolkata Knight Riders
win_by_runs                            0
win_by_wickets                         1
player_of_match               AD Russell
venue                       Eden Gardens
umpire1                     AK Chaudhary
umpire2                  HDPK Dharmasena
umpire3                              NaN
Name: 559, dtype: object

为了进一步理解 Python 中的数据分析过程，让我们用数据可视化来回答进一步的问题，即通过绘制结果。

哪个赛季的比赛次数最多？

我们知道，如果每一行都是匹配的，那么计算每一季的实例/行的数量就可以得到每一季的匹配数。

sns.countplot(x='season', data=matches)
plt.show()

seaborn 中的函数可以立即完成这项工作(不需要显式的 group_by 和 count)

给出这个:

最成功的 IPL 团队

最成功的 IPL 团队是赢得最多次数的团队。这也意味着，回答这个问题和上面的练习一样，除了计算每个赛季的实例数，这里我们要计算每个获胜队的实例数。

#sns.countplot(y='winner', data = matches)
#plt.show
data = matches.winner.value_counts()
sns.barplot(y = data.index, x = data, orient='h');

给出这个:

虽然用countplot()也可以很容易地做到这一点，但是引入另一个sns plot -barplot()的变体已经被用来可视化它了。

比赛获胜者的最佳球员

top_players = matches.player_of_match.value_counts()[:10]
#sns.barplot(x="day", y="total_bill", data=tips)
fig, ax = plt.subplots()
ax.set_ylim([0,20])
ax.set_ylabel("Count")
ax.set_title("Top player of the match Winners")
#top_players.plot.bar()
sns.barplot(x = top_players.index, y = top_players, orient='v'); #palette="Blues");
plt.show()

给出这个:

对于那些关注 IPL 的人来说，你现在可能想知道这有多讽刺。克里斯·盖尔，是最成功的 IPL 球员，在第一轮没有被卖掉。

掷硬币赢对赢得比赛有帮助吗？

解决了上面这些并不太难的问题后，我们却无法得出一个关键的见解——那就是——掷硬币赢真的有助于赢得比赛吗？

用我们同样的方法把问题分成几个部分——我们可以把这个问题分成两部分——如果两者相同，比赛获胜者和掷硬币获胜者——那么它就是成功的，如果不是，它就是失败的。在想象结果之前，让我们先看看数字是什么样子的。

ss = matches['toss_winner'] == matches['winner']
ss.groupby(ss).size()
False    311
True     325
dtype: int64

看起来，掷赢实际上有助于赢得比赛——或者从统计学角度来说，我们可以说掷赢和赢得比赛之间存在相关性，因此我们可以假设它有所帮助。

要可视化结果:

#sns.countplot(matches['toss_winner'] == matches['winner'])
sns.countplot(ss);

给出了这个图:

至此，我们已经到了本教程的结尾，正如你可能已经注意到的，它只用了一行就回答了上面的几乎所有问题。这告诉我们两件事:Python 表达式在语法方面非常简洁；第二件事是，不需要几十行或几百行代码就能产生有价值的见解——只要几行代码就能产生神奇的效果——如果你问的问题正确的话！

希望这篇文章能帮助你开始你的 Python 数据分析之旅。如果你有兴趣了解更多，请查看这个免费的数据科学课程的 Python 介绍。这里使用的完整代码可以在我的 github 上找到。

用白板和熊猫分析南非政府的浪费性支出

原文：https://towardsdatascience.com/analysing-sa-govs-wasteful-expenditure-from-tabula-to-pandas-464d06c3bdd9?source=collection_archive---------19-----------------------

关于一些数据分析的第一篇文章，着眼于不规则的政府支出，特别是公共实体对偏差和扩张的合同请求。这些数据可以在网上免费获得，我只是解析、探索和呈现它们。

Image source: Southern Vines

南非政府负债累累。这主要是由于不规则的支出，可以追溯到偏差和扩大招标。这些招标原本是为特殊情况准备的，但现在却成了常态。

2018 年 6 月，公共实体和部门 SARS 、 SITA 、国防部、公共工程部、水和卫生局& Trans Caledon 隧道管理局都被提出来解释可疑的偏离和扩大要求。这些包括夸大的 DSTV 订阅合同，价值数百万兰特的视频会议设备，食物和餐饮，等等。所有合同请求由财政部每季度发布一次。

获取数据

与大多数政府记录一样，每个季度的合同都是 PDF 格式的，如下所示:

The nemesis of the internet

为了解析数据进行分析，我尝试了tabula-py——tabula-Java 的 Python 包装器，可以读取和提取 pdf 中的表格。这是公认的，也是我在那里能找到的为数不多的好书之一。在将几个文件转换成？csv，我意识到它的解析没有我想要的那么准确。

所以我最终使用 Tabula GUI 手动选择表格以提高精确度，并导入。csv 喜欢熊猫。我分析了财政部网站上目前可用的所有季度——从 2016 年 Q2 到 2018 年第三季度。以下是其中的一些片段:

ex1 = pd.read_csv('expansions_q2_2016.csv')
ex7 = pd.read_csv('expansions_q3_2018.csv')ex1.head(5)

ex7.head(5)

清洁

为了这篇文章和每个人的健康，我大大简化了清洁过程——这比看起来要辛苦得多。

在上面的“head”示例中，您可能已经注意到桌子需要大量的清理工作。例如，“原始合同价值”列中的值条目在第一次导入时用逗号隔开，在第二次导入时用空格隔开。这是由于两个主要问题:1)财政部的数据输入缺乏一致性，2)缺乏完美的 PDF 解析。

“原始合同价值”栏中的许多条目使用了不同于其他条目的格式，包括:

array(['estimated R95 per\rtransaction', 'various', '168 849 638.40 -ABB\r20 961 068.87- Zest\r54 271 707.30 - Actom', 'Not stated')]

有些包括外币，如€250，455 和 334，908 美元。这些都从数据集中删除了，使我们的数据集超过 1600 行。

列标题的顺序也不同，标签也不同。在对列重新排序并全部重命名之后，我将所有的表连接起来:

ex_all = pd.concat((ex1,
                    ex2,
                    ex3,
                    ex4,
                    ex5,
                    ex6,
                    ex7
                   ), axis=0, ignore_index=True)
df.head(4)

给我们这个人:

df.info()

All the objects…

在进一步清理之后，是时候进行一些探索性分析了。

探索性分析

df.sort_values('Value of Contract', ascending=False)[:6]

I also tokenised the ‘Project Description’ column, with the aim of doing some text analysis a bit later, but never got around to it.

df['Value of Contract'].sum()/1000000000000)[:7]

在过去的 10 个季度中，总共需要价值 19.4539 万亿兰特的合同。

一些合同价值看起来很像打字错误，如果有人只是在一个随机的数字上加了一串零，那么我不得不仔细检查许多条目，以确保这不是解析方面的问题。

查看所有合同没有太多意义，也有点脱离上下文，所以让我们只考虑那些被授予或标记为“受支持”的合同。

df['Support Status'] = df['Support Status'].str.lower()supported_contracts.head()

supported_contracts.info()

我们所有的条目都是对象，这需要一些重新格式化。我将所有数字条目转换为浮点数，将日期条目转换为 Python 的 date.time。

 supported_contracts[‘Value of Contract’] = pd.to_numeric(supported_contracts[‘Value of Contract’], errors=’coerce’)supported_contracts['Date Awarded'] = pd.to_datetime(supported_contracts['Date Awarded'], errors='coerce')supported_contracts['Contract Start Date'] = pd.to_datetime(supported_contracts['Contract Start Date'], errors='coerce')supported_contracts['Contract Expiry Date'] = pd.to_datetime(supported_contracts['Date Awarded'], errors='coerce')

现在，只看支持的合同，授予的合同总价值为 9540 亿兰特。

(supported_contracts['Value of Contract'].sum() / 1000000000).round()# in billions contracts awarded

为了更容易地根据日期调用值，我对“授予日期”列进行了索引:

supported_contracts.index = supported_contracts[‘Date Awarded’]del supported_contracts[‘Date Awarded’]supported_contracts.head(2)

(supported_contracts[‘2016’][‘Value of Contract’].sum() / 1000000000).round()# in billions contracts awarded in 2016

2016 年授予 3110 亿兰特。

我清理了数据框架，删除了以下各列，使其更具针对性:

supported_contracts.drop('Reason', axis=1, inplace=True)supported_contracts.drop('Contract Expiry Date', axis=1, inplace=True)supported_contracts.drop('Contract Start Date', axis=1, inplace=True)supported_contracts.drop('Description Tokens', axis=1, inplace=True)

然后我想象了一些我们的发现:

support_contracts = support_contracts['2016':'2019']support_contracts.resample('D').sum().plot()
fig = plt.gcf()legend_label = mpatches.Patch(color='blue', label='Total Value of Contracts')plt.legend(handles=[legend_label])plt.suptitle('Contracts Awarded Over Time', fontsize=16)plt.rcParams.update({'font.size': 9})fig.set_size_inches(15, 8)

看看这些峰值是什么，我将“合同价值”下的所有条目按降序排列:

# top contracts supported ranked in terms of valuesupported_contracts.sort_values('Value of Contract', ascending = False)[:9]

惩教服务和卫生部(或称卫生部)在过去两年中获得支助的最大合同是"提供和管理食品服务"和"为公共部门病人提供替代性慢性药物获取方案"。

为了更好地了解每个实体对总支出的影响，我查看了它们的总合同价值以及与其他实体相关的合同量:

def value_percent(entity):

    entity_df = supported_contracts[supported_contracts['Entity'].str.match(entity, na=False)]
    entity_value_total = entity_df['Value of Contract'].sum()
    percentage = (entity_value_total / supported_contracts['Value of Contract'].sum())*100

    return percentage.round(2)def freq_percent(entity):
    try:
        percentage = (df['Entity'].value_counts()[entity]/len(df))*100
        return percentage.round(2)
    except KeyError:
        pass

并创建一个新的数据帧:

impact_df = {'Entity': supported_contracts['Entity'].str.title(),
             'Frequency of Appearance': supported_contracts['Entity'].apply(freq_percent),
             'Value of Contracts': supported_contracts['Entity'].apply(value_percent)}# only interested in top 10 for nowimpact_df = pd.DataFrame(data=impact_df).drop_duplicates(subset='Entity')
impact_df.sort_values('Value of Contracts', ascending=False)[:9]

就总“合同价值”而言，南非国家电力公司占 21.42%，南非国家电力公司占 16.20%，南非国家电力公司占 13.88%。

让我们来看看十大最昂贵的实体之间的相互关系:

cmap = plt.get_cmap('Spectral')
colors = [cmap(i) for i in np.linspace(0, 1, 9)]impact_value_df.index = impact_value_df['Entity']plot = impact_value_df.plot.pie(y='Value of Contracts',
                               autopct='%.0f%%',
                               figsize=(8, 9),
                               colors=colors)plt.suptitle('Share of Total Contracts by Value', fontsize=16)plt.show()# the chart only shows the total share of the top ten most 'expensive' entities (it excludes the other)

每卷合同份额也是管理不善的一个有趣指标，如下图所示。为了可视化最常见的合同，我使用了一个 Seaborn 图表:

impact_freq_df = impact_df.sort_values('Frequency of Appearance', ascending=False)[:9]f, ax = plt.subplots(figsize=(15, 5))
sns.set_color_codes("muted")sns.barplot(x = 'Entity',
            y = 'Frequency of Appearance',
            data = impact_freq_df,
            palette='dark',
            alpha=.6)plt.suptitle('Share of Total Contracts by Volume', fontsize=16)plt.show()

对于这个数据集，还可以做更多的事情，但目前就这些了。其他一些建议是根据合同量和总价值分析顶级供应商，或者测试可以识别可疑请求的不同公式。

我计划一个月至少做两个数据集，最好是在非洲背景下——如果你有任何数据集、评论、想法或建议，请随时分享。

使用机器学习分析用户的购物行为——第一部分

原文：https://towardsdatascience.com/analysing-shopping-behaviour-of-users-using-machine-learning-part-1-518483e72a2c?source=collection_archive---------3-----------------------

上周，Instacart 发布了他们第一个公开的数据集。该数据集包含来自 200，000 多名 Instacart 用户的超过 300 万份杂货订单。毫无疑问，有大量的数据可以从中得出真知灼见。所以，我运用我的分析本能。

我读过很多关于美国人对食用有机食品的痴迷。数据讲述了同样的故事。订购最多的 20 种食品中有 15 种是有机食品。对于这些商品，我分析了一天中每个小时的订单。对他们中的大多数人来说，情节看起来是相似的。

Orders Vs Hour of day for 20 most ordered items

在一天的 9 小时左右有一个峰值，在一天的 14 和 15 小时有另一个峰值。结果直观吗？我想是的。大多数人在早上订购食品杂货作为早餐和午餐。或者午饭后的傍晚。这些统计数据可用于库存管理以及调度和优化交付资源。

另一个有趣的分析是重新排序最多的项目。凭直觉，我的答案会是牛奶、鸡蛋或一条面包。这些几乎每天都在消耗，所以你可能会有很多再订购。下图显示了 20 个最常重新订购的数量以及重新订购的百分比。

Count of reorders vs percentage of reorder for 20 most reordered items

从这些有趣的可视化转向复杂的预测分析。根据可用的功能，我们能否预测客户下次来访的订单、再订单和首次订单的数量？

在做任何预测之前，我喜欢问自己这个问题——这个预测有意义吗？好吧，行为经济学家对我们有话要说——“可以预见，人类是不理性的”。

我们重复事情。我分析了我在一个食品订购应用程序上的最后 10 个订单，我可以看到这种模式。回到分析，我将特征缩小到属性，例如订单 _ 星期 _ 日、订单 _ 小时 _ 日、天数 _ 自 _ 前 _ 订单和我的所有部门(冷冻、餐具室、早餐、乳品等)。)转换成数值变量。使用随机森林回归，我可以在预测订单数量时获得 0.93 的 r2_score，在预测再订购数量时获得 0.75 的 R2 _ score。

在第二个分析系列中，我希望对订单执行聚类，以找到不同部门之间的相关性(我们能否回答这样一个问题，“乳制品订单越多，冷冻食品订单越少？”或者也许是“点的酒越高，点的饮料和小吃就越高？”我希望有更广泛的用户级数据，但由于匿名，这些属性没有公布。

我们能否根据订购食品的种类和数量来划分市场。我们能向用户做出预测和推荐以增加销售吗？订单之间是否存在与通道、部门、时间或用户活动相关的模式和相关性。我将在分析的第二部分尝试回答这些问题。

对此有任何想法或建议，请在下面的评论中随意拍摄！

干杯:)

用 Python 中的 fbprophet 包分析股市周期

原文：https://towardsdatascience.com/analysis-of-stock-market-cycles-with-fbprophet-package-in-python-7c36db32ecd0?source=collection_archive---------8-----------------------

重要提示:这不是投资建议。

股票市场周期是股票市场的长期价格模式，通常与一般的商业周期有关。它们是技术分析的关键，在技术分析中，投资方法是基于周期或重复的价格模式。如果我们对股票市场的周期有更好的理解，我们总是可以在每个周期中以相对低的价格买入，以相对高的价格卖出，我们总是会有正的回报。多么美好的世界啊！当然，股市中没有永远赚钱的优越策略，但 Python 或 R 中的fbprophet包可以帮助我们更深入地洞察股市中隐藏的周期。在这个分析中，我们可以看看fbprophet如何帮助我们做出投资决策，所有代码都可以从这里获得。

fbprophet 简介

bprophet 是脸书发布的开源软件，目的是为大规模的预报提供一些有用的指导。默认情况下，它会将时间序列分为趋势和季节性，可能包含每年、每周和每天。然而，分析师可以定义自己的季节性。为了更好地理解这个包，Prophet 的文档非常有用。

包装的特点之一是它的简单性和灵活性。由于我们想要计算的股票市场周期并不局限于每年、每周或每天，我们应该定义自己的周期，并找出哪个更符合数据。此外，我们不应该使用周季节性，因为周末没有交易。我们也可以通过add_seasonality 函数定义我们的‘自定义循环’。所有的设置只需要两行代码就可以完成。

股票市场周期分析——以好市多为例

我们可以用好市多从 2015/10/1 到 2018/10/1 的接*价格作为例子，来更好地了解我们正在做的事情。用pandas_datareader我们可以很容易地获得股票价格。这里的文档是。在图 1 中，我们可以看到，从 2015 年开始，价格呈强劲增长趋势。但是，旅途中还是有很多起起落落，或者说循环往复，这些都是我们要赚钱的。

Figure 1: Costco stock price from 2015/10/01 to 2018/10/01

对于预测模型，评估它们的一种方法是样本外均方误差。我们可以使用 2015/10/1 到 2018/3/31 进行训练，并保留最后 6 个月来测试和计算样本外均方误差。在每个周期内，我们可以通过在最低价格买入，在最高价格卖出来优化我们的回报。为了使过程更容易，我们使用自定义函数cycle_analysis.。输出是一个列表，包含每个周期的预计回报和样本外均方误差。该功能的输入需要:

• 数据:熊猫数据帧带时间索引
• 拆分日期:拆分培训和测试数据的日期
• 周期:每个周期的周期(天数)
• 模式:季节性相加或相乘(可选，默认相加)
• forecast_plot: 是否打印预测图(可选，默认为 False)
• print_ind: 是否打印每个周期的预计收益和样本外均方误差(可选，默认为假)

在图 2 和图 3 中，我们对好事多股票价格应用了两种不同周期长度的函数，分别为 30 和 300，并将 2018 年 4 月 1 日作为训练和测试的拆分日期。正如我们所看到的，如果我们选择的时间太短(例如 30 天)，一个周期内的回报就很小，我们需要频繁地进行交易(图 2；相比之下，如果我们选择一个太长的时间长度(例如 300 天)，就会扭曲我们的预测(图 3)。)

Figure 2: Prediction with cycle equal to 30 days

Figure 3: Prediction with cycle equal to 300 days

我们可以在我们的cycle_analysis函数上应用一个循环来计算不同周期长度的预计回报和样本外均方误差，我们在图 4 中显示了结果。正如我们所看到的，长度越长，每个周期的预计回报和样本外均方误差都会增加。考虑到交易成本，每个周期内的预期收益应该大于 10 美元。在这种约束下，我们可以选择使样本外均方误差最小的周期，它是 252 天。每个周期的预计回报为 17.12 美元，样本外均方误差为 15.936。都挺好的！

Figure 4: Projected Return and Out-Sample Mean Squared Error for different length of cycle

Figure 5: Prediction with cycle equal to 252 days

为了进一步说明投资策略，我们可以看到 2015/10/1 和 2018/10/1 之间的买入和卖出日期。Return_Dates函数可以返回所有买卖日期作为输出，输入:

• 预测: fbprophet 预测对象
• 股票 _ 数据:带时间指数的熊猫数据框
• 周期:周期长度
• 周期名称:预测对象中周期列的名称
• 时间名称:预测对象中时间列的名称

在 2015/10/1 和 2018/10/1 期间，我们将买入和卖出好市多四次。总的来说，我们会花 604.56 美元购买，当我们在这些特定的日期出售它们时，会得到 744.78 美元的回报。对于一个简化的回报率(不考虑再投资、时间价值等)，3 年是 23.2%。大概不是很吸引人，但至少是正回报。

适用于更多股票

当然，这种方法可以适用于尽可能多的股票。我们列出了好市多、苹果、微软、家得宝和耐克在每个周期内的*均买入价格、*均卖出价格、周期长度、样本外均方误差、买入数量、卖出数量和预期回报。

对于微软和耐克，我们找不到任何周期符合我们的要求，每周期超过 10 美元的回报。对于好市多、苹果和家得宝，我们可以找到 250 天左右的周期，并做出良好的预测和体面的回报。

摘要

借助 Python 和fbprophet包，我们可以对股票市场有更好的了解。以 Costco 为例，我们可以找到一个 252 天的周期，这样它就可以产生足够的回报，并有很好的数据拟合。按照我们找到的周期，3 年可以有 23%左右的回报。也许这种投资策略不能满足你的需要，但是你可以根据你的知识和经验来设定你自己的方法。强大的fbprophet软件包可以让你对股市的分析更加深入和简单。

2018 年 Crossfit 公开赛分析

原文：https://towardsdatascience.com/analysis-of-the-crossfit-open-2018-jean-michel-d-307cbfb06a13?source=collection_archive---------4-----------------------

Photo by Victor Freitas on Unsplash

你好，在这篇文章中，我将给出一些关于如何创建网页抓取系统的线索，该系统已被用于从锐步的 Crossfit 游戏网站收集一些数据。

交叉拟合简介

交叉拟合定义为

a strength and conditioning program consisting mainly of a mix of aerobic exercise, calisthenics (body weight exercises), and Olympic weightlifting

这个项目似乎是在 2000 年由 Greg Glassman 和 Lauren Jenai 邀请的，这项运动以 CrossFit，Inc 的名义获得许可。

我邀请你看一下 YouTubeCrossfit Inc 频道上的一些视频，以便更好地了解在一次训练中应该做些什么。

就我而言，我从 2017 年 8 月开始练习 crossfit，每周三次，我真的很喜欢它，当我开始的时候，我把这项运动看做一些高强度的健身房运动。

更严重的是，我有点担心强度的练习，从我的角度来看，可能会严重伤害人，但这项运动是为每个人都没有必要成为超人来练习交叉健身。

优点是每项锻炼都可以根据你的需要(身体状况、受伤情况)来衡量重量和运动量，但唯一的目标是完成锻炼。永不放弃可能是 crossfit 的座右铭。

世界杯冠军的选拔非常简单，过程分为三个阶段:

• 公开赛，每个人都可以参加这个资格赛，分组是按年龄和性别划分的，如果你不在可以验证你表现的附属健身房，你可以拍摄下来发给组织者。
• 地区赛，公开赛中的最佳选手将参加比赛
• 第十三届奥运会第十四届世界杯

对于本文，数据收集将仅是可以在此地址找到的公开的 2018 年数据。开口定义为:

• 为期 5 周，每周公布一个新的 wod(每日锻炼计划)
• 有 4 天时间来争取在世界上取得最好成绩

所以为什么我想用这个案例来介绍网络抓取:

• 我在 Crossfit 游戏网站的 scraping 上读到了一篇很酷的文章
• 我发现排行榜的展示在比较方面非常有限
• 我想做一个网页抓取练习已经很久了

所以让我们开始吧。

网页抓取 101

在这种情况下，我决定删除以下元素:

• 本文的排行榜页面我们将致力于 2018 年的结果，但如果您想要上一年的方法，我邀请您查看关于该主题的这篇文章
• 运动员页面，因为每个运动员都有一个包含一些有趣信息的页面
• 健身房页面包含一些关于健身房位置的细节

为了从这个网站收集数据，我使用了名为 Beautiful Soup 的包，这是 Python 中非常流行的网络抓取工具。在接下来的部分中，将描述收集的数据和相关的代码。

你可以在这个 GitHub 库 中找到本部分解释的所有功能。

排行榜

没有必要删除网页，前端使用的 API 可以通过简单的 get 请求直接调用。感谢 @pedro 注意到这一点。请求中只需要提到:

• 分部的代码
• 如果排行榜涉及按比例增减的运动员或未按比例增减的运动员
• api 的页面(可以从第一页的请求中获得)

这是要执行的请求。

运动员页面

在这种情况下，运动员页面看起来像下图中的屏幕截图

在页面底部，有一些练习的基准。

因此，我决定删除过去 5 年中参加公开赛的所有运动员的页面，这代表了超过 700000 页要删除，为了优化收集，我决定并行处理该过程，并使用以下代码获取一页的数据。

体育版

在健身房页面的情况下，收集的信息量没有运动员重要，下图是健身房页面的截图。

该脚本将重点放在页面标题的细节，这涉及到的位置。在这种情况下，要废弃的页面数量大约为 10000 页，下面的代码用于实现这一点。

过程背后的伦理

如你所知，我的系统收集了大量数据，问题是这是否合法？。

如果我指的是普遍的看法，它在互联网上，所以它是免费的，这很好如果我指的是这篇文章，它似乎比这更复杂，我似乎做了一些非法的事情，因为我不尊重网站的使用条款，所以我决定联系 Crossfit Inc .警告他们我所做的事情，并获得他们的反馈(我通过他们的表格和一些与隐私相关的电子邮件地址等联系了该组织)。

2018 年 4 月 29 日:我没有收到他们关于这个问题的反馈。

从我的角度来看，我认为这是说，直到我没有发布运动员的个人信息和出售数据集，但谁知道呢？

让我们来看看数据集的一些全局见解。

你可以在本 GitHub 库 中找到本部分解释的所有功能。

对 2018 年公开赛的见解

在这一部分，它将主要是一个非常一般的开放事件的概述。分析将从性别再分配开始。

很高兴看到有相当数量的男性(56.8%)和女性(43.2%)(与我在培训期间看到的情况相似)参与公开活动。现在让我们来看看时代的重新划分。

性别之间的年龄分布非常相似，年龄大于 60 岁的运动员被认为是异常值。另一点要注意的是，运动员的*均年龄大于 30 岁，这可能是也许的标志:

• 参加公开赛需要经验(但我不会打赌)
• 成为会员的代价太高了
• 视频分级提升的不是很好

下面的分布图很好地说明了这种年龄划分。

这是与收入相关的年龄划分的例证。现在让我们看看运动员的数据。

运动员分析

为此，我使用了运动员页面中的一部分数据，我过滤了不符合身体质量指数(身体质量指数)的离群数据，这些数据不在 13 到 83 之间，还有一些错误的体重和身高值。有一个形态学的可视化。

运动员的一般物理似乎是:

• 大约 80 公斤的体重
• 180 厘米左右的身高

在国家再分配方面，美国领先。下图统计了美国和其他前 10 个国家参加该项目的运动员人数。

我认为对 crossfit 在美国的流行没有什么可评论的，如果我把更多的注意力放在其他国家，会有一些有趣的见解。在下图中，有更多关于前 10 名国家(就运动员数量而言)的细节，不包括美国。

我们可以看到:

• 美国和第二个国家之间有巨大的差距(比如 20 万名运动员)
• 运动员人数第二多的国家，这不是一个国家，而是所有运动员的协会，他们只是在拍摄他们的世界。
• 巴西和部分英联邦国家的运动员对此明显感兴趣
• 在欧洲参赛的运动员人数不那么重要

现在让我们来看看给运动员打分的体育馆的一些细节。

健身房/拳击数据分析

所以要明确的是，美国有相当数量的健身房/运动员参与这项活动。下面是美国健身房的数量和其他 9 个健身房较多的国家的健身房数量的比较。

美国正在实实在在地压榨其他国家。下图显示了其他国家健身房的数量。

有趣的是看到(运动员号码和体育馆号码之间有很多相似之处，这很正常):

• 巴西有很多健身房
• 英联邦(加拿大、英国、澳大利亚)出席了会议
• 法国在排名中领先欧洲(但意大利很接*)

我可以继续用这些数据制作大量的图表，所以我决定制作一个交互式的仪表板，我可以在任何时候轻松地制作，为此我将使用 Tableau

桌面上的仪表板公共

Tableau Public 是 2003 年由山景城的一家公司基于斯坦福大学(vizQL)的工作开发的一项服务。该公司于 2013 年在纽约证券交易所上市，拥有 2400 名员工(2015 年的数字)。

Tableau 开发了不同的产品，但该工具的目的是通过创建和共享仪表板来促进整个企业的数据信息交换。

我邀请看一看他们的网站上有更多的产品细节，对于这个项目，我使用 Tableau 公共创建以下仪表板。

[## Tableau 公共

编辑描述

public.tableau.com](https://public.tableau.com/shared/M345H9FB7?:display_count=yes)

最后，我想在数据上更进一步，只关注基准测试，试图找到它们之间的联系。

练习之间的关系

为了分析数据，我必须消除异常值，为此我添加了选项:

• 在数据标准化后，使用 dbscan 检测异常值(有效，但将它应用于所有有数据的运动员有点长)
• 使用基于分位数的统计方法，删除低于 5%分位数限制和高于 95%分位数的值

我直观地发现了练习之间的一些关联，如下图所示。

因此，我想将相关性(一种线性关系)的研究应用于所有的练习，我对 1000 名运动员应用了一个线性模型，并对 250 名运动员测试了该模型，以了解该模型是否足够好。我使用 r 分数作为指标来评估模型的效率。

在训练集中，涉及负重的练习彼此高度相关，涉及持续时间的练习显示出不太重要的相关性。当模型应用于测试集时，重量练习的相关性仍然很好，但是随着时间的练习在训练集上绝对是过度拟合的。下图显示了与体重相关的锻炼的线性模型。

为了更好地了解体重改变对一项运动的影响，我创建了一个表格，将一项运动的体重改变转换为另一项运动的体重改变。

结论和下一步措施

这个项目非常有趣，收集网站数据绝对非常实用，从这个数据集中可以获得一些见解(通过快速分析)。

该项目的下一步是:

• 创建一个 Kaggle 数据集(如果锐步可以的话)
• 创建某种 API，使用这些数据给出训练建议
• 根据运动员个人资料上的图片，当年龄和性别正确时，创建一个模型，从某人的面部确定其性别和年龄(年龄范围)
• 在表格上添加更多的历史数据(我收集了过去 5 年的数据，但过去数据的格式有点不同)，可能还会添加地区赛和比赛数据
• 改进和构建其他仪表板

原载于 2018 年 3 月 30 日【the-odd-dataguy.com】。

浅析中国新兴社交媒体——红宝书

原文：https://towardsdatascience.com/analysis-of-the-emerging-chinese-social-media-the-little-red-book-ad7edd05459e?source=collection_archive---------11-----------------------

红宝书(https://www.xiaohongshu.com)已经成为中国发展最快的社交媒体之一。与流行的微信和微博不同，红皮书专注于美容和时尚细分市场，尽管我们确实看到自其早期阶段以来，内容多样化，进入了一般生活方式类别。由于该公司尚未上市，因此几乎没有公开数据。为了了解该*台，我构建了一个爬虫来获取概要信息，并根据爬取的信息进行数据分析。

如何获取数据？
红皮书有一个在网络客户端提供内容的网站。尽管初始主页可供我们抓取的内容有限，但我们可以识别出指向其用户个人资料页面的链接。从那里，我们可以跟进评论者的个人资料以及更多的帖子来继续爬行。我将有一个关于技术细节的单独文章。

数据大小
红皮书有非常严格的反爬虫机制来阻挡爬虫，所以 IP 轮换是获取大规模数据的必须。在 4 天的时间里，我从*台上抓取了 899，519 个个人资料。虽然这只是代表了红皮书庞大用户数据库中的一小部分，但所有这些用户都至少在*台上产生了一些活动(要么是写帖子，要么是创建版块，要么是评论别人的帖子)。因此，这个数据集可以用来识别红皮书最活跃的用户群的特征。

指标解释
红皮书为用户提供了三种参与内容的方式。用户可以喜欢内容，“收集”内容或对内容进行评论。“喜欢”的功能类似于脸书的大拇指按钮，而“收集”意味着将一段内容保存在应用程序的书签系统下，以供进一步参考。一般来说，人们会在感兴趣时喜欢某个内容，并在帖子可以用于进一步参考时“收集”该内容，包括那些稍后重新访问的有用提示和他们最终可能想要购买的产品。第三个指标是“评论”，提供帖子的交互性。不幸的是，Redbook 没有提供一种简单的方法来跟踪评论数量的聚集，所以这个字段不会包含在本文中。

朱庇特笔记本可以在https://github.com/Gravellent/redbook_analysis找到

谁是红皮书上最有影响力的用户？

The top 10 users (excluding the official accounts) are:
范冰冰
林允 Jelly
张韶涵
Ritatawang
时髦小姐姐
凌听雨
江疏影
Irene 林恩如
欧阳娜娜 Nana
美七是我

Although celebrities have been keen on joining this emerging platform, there is a good mix of internet KOLs and true celebrities. Specifically, Ritatawang and 美七是我 did not have much influence before they joined Redbook.

红皮书上的男性用户？

红皮书的一个主要特点是它的用户主要是女性。我们的数据显示，只有 2%的用户是男性。超过 60%的用户没有表明自己是男是女，但是经过一些人工检查后，似乎不明身份的用户跟那些在注册时选择性别的用户有相似的特征。

除去身份不明的，女性贡献了 95%的用户群。这与我们的预期相似，因为*台上生成的大多数内容都是面向女性的，以各种美容产品和时尚相关的内容为特色。

然而，现在说女性是社交电子商务操场上的唯一玩家还为时过早。虽然男性用户仅占用户总数的 5%,但他们对女性用户的影响力更大。在计算每个性别产生的总点赞数后，我们看到男性用户贡献了总点赞数的 8%。在收集的帖子中，男性占 5.9%，略低于总点赞数的比例，但仍高于其人口比例。对这种差距的一种解释是，红皮书上男性的内容通常被认为是“有趣的”，但读者不一定想以后再看这些内容。另一方面，女性内容创作者可以提供有用的信息和进一步的参考

从影响力的角度来看，男性的影响力甚至更大。男性用户在*台上的*均粉丝数要高得多。男性的*均粉丝数超过 2400 人，远远超过女性的 842 人。

有趣的是，中位数和四分位数分析显示了相反的结果。男性用户的粉丝数量中位数为 5，而女性用户的粉丝数量中位数为 11。75%的四分位数结果还表明，大多数男性的活动范围小于女性。那么为什么男性的*均分要高很多呢？

查了粉丝数 1 万+和 10 万+的用户性别分布，原因就清楚了。有一群顶级男 kol，他们在*台上处理的粉丝往往超过 10 万。那些人有很大的影响力，扭曲了统计数据。另一方面，对于少数非 kol 的男性用户，他们与社区的互动并不强烈。

红皮书用户在哪里？

Redbook is known for its high conversion rate to sales. The users on the platform tend to have a strong interest in purchasing high-end beauty and fashion product. Many people refer to the platform as a “种草*台”, which basically means people search for products that interest them and “initiate” the desire to own them eventually. Many of the products discussed on the platform are from major international brands, so the viewers usually process high purchasing power. So where are these users? It’s common knowledge that the majority of the higher-income group locate in Beijing, Shanghai, Shenzhen, and Guangdong. Would the user group fit this demographic?

Again, we start out with analyzing all the data for user location. Since Redbook default a user’s location to “Others”, we see that only 40% of its users input meaningful location information. On top of that, some users stop inputting more information after “China”. For this purpose of this analysis, we will only look at the those who identify themselves in provinces or cities.

用户数量排名前五的省份是广东、上海、北京、浙江和江苏，占整个用户群的 30%以上。红皮书的总部设在上海，说明上海都市圈是其主要的用户群。(注:上海、浙江和江苏可以被认为是一个拥有几个高调城市的大都市圈)广东省的 GDP 总量最高，拥有中国最大的两个城市广州和深圳，因此它是用户最多的省份并不奇怪。

虽然从数量分布来看，广东是第一大省，但从地理上分析其用户群也需要考虑用户的质量。也就是说，我们需要看看用户能产生多少参与度。在用户点赞和收藏方面，上海遥遥领先。由于该公司是在这座城市成立的，他们的许多种子用户来自该地区是可以理解的。我们发现的另一个有趣的趋势是，有一群红皮书 kol 生活在国外，并产生良好的影响。澳大利亚、美国和英国都位列前十。考虑到这些国家的 kol 数量较少，居住在中国以外的用户*均比居住在国内的用户具有更高的影响力。

限制
由于数据不包含整个用户数据库，所以对于所有用户的分布可能是不准确的。此外，对于性别和位置分布分析，由于超过一半的用户没有输入信息，因此很难估计如何将结论推广到整个用户组。此外，由于用户自己输入信息，他们中的一些人可能会使用不准确的信息进行注册(例如，声称他们住在船上，而他们并不在船上)。

结论
*台上最有影响力的用户包括名人和 Redbook 自己的 kol
广东的用户数量最多，但上海的用户产生的影响力最大。
·在美国、英国和澳大利亚有大量用户，他们比其他用户群显示出更强的影响力。

分析师:停止衡量其他一切，开始衡量你的数据项目的价值！！！

原文：https://towardsdatascience.com/analysts-stop-measuring-everything-else-and-start-measuring-the-value-of-your-data-projects-b32de66950?source=collection_archive---------9-----------------------

TL；速度三角形定位法(dead reckoning)

衡量你的项目的商业价值是非常简单的，并且有很多好处，但是似乎没有人想到要这么做。因此，这里有一种方法。

我有幸在数据和分析领域工作了 5 年——在两家财富 500 强企业，现在在一家初创公司。

我帮助组织聚会，我参加过多次会议，我看过很多在线课程，我向独角兽学习，并和它们一起工作…

基于所有这些经验，我认为分析学作为一门学科，在如何衡量投资回报(ROI)方面有一个 T2 盲点(T3)。具有讽刺意味的是，it 纠结于如何衡量其他一切！

Running an Analytics project without an ROI measure is like merging a semi-trailer without checking your mirrors. Measuring your project’s ROI is easy to do, and saves you (and others) grief.

这一点在最*的悉尼人工智能和机器学习峰会上的一个关于“做出关于自动化的正确决策”的小组中得到了强调。非常聪明、多才多艺的人花了 40 分钟讨论选择问题时所有的技术问题，但甚至没有花一秒钟考虑如何评估解决问题的商业价值——以及你的项目是否值得这个成本。

我明白了——分析师或数据科学家更愿意调整模型，而不是编造商业案例。但是展示你工作的价值非常简单，这是与高级管理层建立信任并为下一个项目争取更多资源的关键。

因此，为了回报我在这个主题上得到的所有帮助，本文包含了我计算数据项目商业价值的方法。

我已经把这个方法分解成了一个等式、一些理论和一些简单的例子。我们希望这些例子能够证明这种方法是多么容易实践，以及这种方法如何能够适应范围极其广泛的项目。我非常乐意在评论中对你的例子进行抨击——出于时间的考虑，我只举了两个例子，但我每天都这样做，而且我确实在盯着一张大约 140 个商业价值计算的表格，我用它来证明我的存在。

最后，这种想法很有卖点。它曾为甲骨文公司直接向企业销售数十万美元的合同。在 Salesforce，它帮助我获得了数十万美元的预算。它在 Jayride 工作…摸木头！这对你有用——或者你可以把我烧死。

方程式:

V = (S + M + R + O) — C

因素:

V =商业价值

储蓄的钱

M =钱 M 阿德

风险降低

O = O 机会被抓住

C =项目总成本 C

理论:

数据科学、BI 或任何东西分析是企业内部的一项职能。一个业务职能通过省钱、赚钱、降低风险或帮助抓住机会向管理层展示价值。

净商业价值就是所有这些因素的总和，减去项目的成本。你也可以除以项目的成本，给出一个“投资回报”比率，这个比率可以被管理层(和你自己)与其他计划进行比较。

你如何衡量所有这些因素？

对于节省的金钱来说，这非常简单——估算一下你为某人节省了多少时间，并知道一小时人工服务的*均价值。一个很好的经验法则是每小时 50 美元——所以节省了 x 个小时，你就节省了 50 倍的钱。

对于金钱(M ),这很简单——你在你的项目(b)之前，对你所帮助的东西的收益表现进行基准测试，然后在你的项目(a)之后，衡量你所帮助的东西的收益表现。绩效之间的差异，M = a-b，是你的项目赚的钱。如果你正在创造一种全新的赚钱方式，你就不必担心标杆管理(即 M = a)。 Avinish Kaushik 在这里为这种测量提供了一种全面的方法。

对于 R isk Reduced (R)，你估计最坏情况成本(w)，在你的项目(s)之前发生的概率，以及在你的项目(t)之后发生的概率。由于风险是成本和概率的倍数，因此降低的风险就是两者之差，即 R = w(s-t)。

OO 抓住的机会(O)就是 R isk 减少的倒数——您衡量的是最佳情况下的收益(y——为 yay！…我快没信了)，在你的项目之前发生这种情况的概率(h)，在你的项目之后发生这种情况的概率(e)。O = y(e — h)。

Pro tip: 不要在估算用于降低风险或抓住机会的概率时混淆视听！通常，来自主题专家的粗略估计就足够了。还有如果你真的必须深入研究，找一个精算师，或者看看道格拉斯·哈伯德的《应用信息经济学》(你可以在这里得到关于少犯错的精彩概述，或者买他的书)。

最后，成本就是项目材料清单的总成本。不要忘记估计你的时间成本。永远要知道你的业务成本，并确保你所做的事情比这更有价值！

示例:

1. 你在做一个恶心的仪表盘！

这个仪表板将帮助管理人员每月节省 10 个小时(x)的电子表格处理时间。

此外，这种可见性将有助于降低人们过度抱怨您的人力资源系统的风险，从 50% (s)降低到 10% (t)，最坏情况下每月成本为 2000 美元(基于历史记录)。

这将花费你一天的工作量——或者大约 8 个小时。

在这个花瓶里，V =(S+R-C)/C =(10 * 50+2000 *(0.5–0.1)-8 * 50)= 900 美元/月

恶心！

A sick dashboard. Credit — https://databear.com/portfolio-items/power-bi-sick-leave-dashboard/

2.你在建立一个很棒的模型！

该模式旨在帮助您的客户支持团队致电高风险客户并保持他们的满意度，并且有机会节省业务，最好的情况是每月节省 10000 美元的资源。客户支持团队目前在交叉销售中每月收入 3000 美元，你认为在你锁定目标后可能会更多。这将花费你大约一周的时间来交付，你和你的团队估计在模型完成后这种收益的可能性大约是 50%，而在模型完成前是 0%。

所以 V = M+O-C = 0+10000 *(0.5–0)-40 * 50 =每月 3000+。

大概不止这些，所以别忘了衡量项目后赚的钱。

太棒了。

I didn’t know this was a thing. Credit — https://en.wikipedia.org/wiki/Apache_Groovy

概括起来

衡量你的项目的商业价值是非常简单的，并且有很多好处，但是似乎没有人想到要这么做。我已经给了你一个方法去做——那就去做吧。

P.S .特别感谢 Verge Labs 的好心人，他们为我找到了一张悉尼人工智能和机器学习峰会的门票——这是一个伟大的事件！

线性回归的解析解

原文：https://towardsdatascience.com/analytical-solution-of-linear-regression-a0e870b038d5?source=collection_archive---------3-----------------------

介绍

我们知道像梯度下降这样的优化方法可以用来最小化线性回归的成本函数。但是对于线性回归，存在一个解析解。这意味着我们可以通过使用正确的公式，在一步计算中获得线性回归的变量。在本帖中，我们将探究线性回归及其衍生的解析解。

解析

我们首先给出了线性回归的解析解公式。如果你对导数不感兴趣，你可以用这个公式来计算线性回归变量。解决方案是:

在这个公式中，所有符号都是矢量化的。如果你不熟悉线性代数或者矢量化，可以参考这篇博客。在这个公式中，X 是一个 m 乘 n 的矩阵，这意味着我们有 m 个样本和 n 个特征。符号 y 是代表目标标签的 m 乘 1 向量，θ是代表每个特征所需的所有系数的 n 乘 1 向量。

派生

我们知道线性回归代价函数的矢量化表达式(更多细节请参考博客)可以表示为:

由于 1/(2*m)是一个常数，当我们最小化一个函数时，将成本函数乘以或除以一个非零常数不会影响最小化结果，因此在这种情况下，我们忽略这个常数项。为方便起见，我们的成本函数变为:

这可以进一步简化为:

我们将其扩展为:

现在第二学期需要一些转变。我们知道 X 是一个 m 乘 n 矩阵，θ是 n 乘 1 矩阵，因此 Xθ的维数为 m 乘 1，其转置矩阵的维数为 1 乘 m，由于 y 是 m 乘 1，因此第二项的维数为 1。换句话说，第二项是标量。我们知道标量的转置等于其自身，因此我们取第二项的转置得到:

我们将 is 代入成本函数，得到:

此外，我们可以把它写成:

现在我们需要对成本函数求导。为方便起见，列出了常见的矩阵导数公式作为参考:

使用上述公式，我们可以推导出关于θ的成本函数:

为了求解变量，我们需要使上面的推导等于零，即:

我们可以将其简化为:

因此，我们可以将θ计算为:

结论

在这篇博客中，我们给出了求解线性回归变量的解析解。我们详细介绍了如何从成本函数的推导中得出这个结果的步骤。

分析 4.0:一切都是为了做出更好的决策

原文：https://towardsdatascience.com/analytics-4-0-its-all-about-taking-better-decisions-5b6b9d06fcea?source=collection_archive---------2-----------------------

Photo credits : artificialisation.com

在一个崇尚新奇、现代和创新的世界里，分析并不是一种短暂的时尚。至少从有记载的历史开始，人类就一直试图了解他周围的世界。大多数科学，如果不是艺术的话，都是基于扫描环境，鉴定手头的数据，选择最佳的前进方法，并将我们的印象转化为个人和集体的行动。这些年来发生变化的是我们可以处理的过多的数据，我们在过去两年中创建的数据比人类诞生以来产生的数据还要多。不管是从经济、政治还是社会的角度来看，我们都有理由质疑我们是否比我们的祖先做出了更好的决定。

商业分析研究所的主旨是发展分析在管理决策中的应用。我们的工作基于分析 4.0 的愿景。不是过去的分析方法的更新和更好的版本，而是由四个基金会支持的行动呼吁，旨在将我们处理的大量数据转化为更有效、更有影响力的决策。在这个物联网、人工智能和神经网络的世界里，我们的最终目标不是让机器更加智能，而是帮助人们做出更好的决策。让我们依次简要探讨一下这些基础:

我们愿景的第一个支柱是围绕数据在现代经济中的作用构建的。如果数据现在似乎是经济活动的命脉，那么数据是什么？数据仅仅是现实的反映，是我们如何与周围世界互动的不完美的镜子。尽管信息技术的进步帮助我们工作得越来越快，但它们常常鼓励我们关注数据，而不是业务挑战和机遇。第四次工业革命的到来邀请人们利用数据来理解我们周围的世界。

我们愿景的第二个基础是围绕人们如何在决策中使用数据而构建的。数据不仅仅是屏幕背后的数字，而是我们眼前不同形式的熵。因为人们从不同的角度看待价值，他们很少从同样的角度看待数据。我们在行为科学领域的工作探索了认知偏见如何影响我们对周围世界的看法。锚定、框架和从众都是影响我们如何解释手头数据的偏见的例子。人类对风险、不确定性和模糊性的认知阻碍了数据驱动的决策实践。

机器学习的每一次创新都奠定了分析的第三个基础。传统方法侧重于在确定性环境中使用有序数据进行回归分析，而今天的机器算法提供了许多概念性工具来解决各种业务挑战。掌握机器学习既需要理解问题的参数，也需要不断练习。在只有一个正确答案的决策环境中，分类算法可以很好地处理有序或分类数据。在我们无法指定所有变量的学术环境中，聚类或降维提供了更相关的结果。

最后，分析的第四个维度将视觉传达纳入关注范围。分析师的工作可能从检查数据开始，但只有在与人共事时才会结束。与电子表格和数据库不同，人类不记录具体的数据或信息，而是记录印象和感觉，当处理这些印象和感觉时，会回忆起主观体验。在一个注意力可能是我们最稀缺资源的经济体中，帮助你的受众专注于信息是一个关键的成功因素。相似性、对称性、接*性、连续性和闭合性的格式塔原则是理解我们如何重建周围现实的基本工具。衡量数据科学家的才能在于他或她将数据转化为行动号召的能力。

因此，分析 4.0 建立在这四个支柱之上:理解数据在现代经济中的作用，研究与人类决策密切相关的认知过程，根据我们试图解决的问题类型应用机器学习，以及将数据转化为可操作的决策。在巴约纳的暑期学校，以及在欧洲的大师班，我们专注于数字经济、数据驱动的决策、机器学习和视觉通信，我们可以帮助您将分析应用于您和您的组织。

Lee Schlenker 是商业分析和数字化转型教授，也是 http://baieurope.com 商业分析研究所的负责人。他的 LinkedIn 资料可以在www.linkedin.com/in/leeschlenker.查看，你可以在https://twitter.com/DSign4Analytics的 Twitter 上关注我们

分析最佳实践—敏捷数据科学

原文：https://towardsdatascience.com/analytics-best-practices-agile-data-science-46918124b6d9?source=collection_archive---------5-----------------------

这是数据科学家 Anna Godwin 和 Cory Everington 讨论五种分析最佳实践的系列博客中的第二篇，这五种分析最佳实践对于建立数据驱动的文化和从分析中获得价值至关重要。在这一部分中，Anna 讨论了使用敏捷数据科学作为管理数据科学项目的框架的好处。

如果你参与过任何项目，你很可能在项目的生命周期中经历了意想不到的变化。正是这些意外会影响您按照最初的设计完成项目的能力，包括团队、可交付成果和/或时间表的变化。在整个项目中，作为个人和团队的灵活性使你能够快速响应变化。但是项目受益于结构化。为数据科学项目管理适当*衡的最佳框架是什么？

对于我们的项目工作，Elder Research 采用了敏捷数据科学方法。它结合了敏捷软件开发的最佳实践和数据挖掘的最佳实践，正如数据挖掘的跨行业标准过程(CRISP-DM)所体现的那样。

敏捷数据科学具有以下优势:它:

• 提供灵活的团队组织
• 获得利益相关者的早期认同
• 适应不可预见的环境

敏捷数据科学为项目团队带来了组织

虽然单独工作时可以使用敏捷方法，但这种方法是为了帮助团队组织工作而设计的。任何时候团队成员在一个项目的不同方面工作，自然会有混乱，重复工作，或者工作在不关注项目可交付性的任务上。敏捷数据科学有助于缓解这些问题，并通过冲刺规划、每日站立、团队透明度和路障意识创建共同愿景。

敏捷方法的两个主要组成部分控制着项目工作:

Sprint Planning 是一个过程，在这个过程中，项目工作被分解成可以在几个小时或几天内完成的小块工作，并分配给团队成员。它通常在两周的周期内完成，以允许团队成员快速迭代，并在如何完成工作方面提供灵活性。在我们即将发布的关于任务管理的博客文章中，我们将更详细地讨论如何计划冲刺。

每日脱口秀通过为每个团队成员创建一个论坛，让他们简短(2-3 分钟)地介绍他们在分配任务上的进展以及他们遇到的任何可能影响进度的障碍，从而促进沟通和项目成功。每日站立被设计为少于 15 分钟。它们不是一个进行详细讨论的论坛，相反，它们为团队成员提供了一个了解其他人正在做什么的机会，并为项目领导提供了一个必要的调整过程的机会。

敏捷数据科学吸引利益相关者

敏捷方法的迭代性质要求经常与项目涉众进行核对。尽早共享结果，通常可以让项目团队专注于构建快速的解决方案，提供价值并获得最终用户的采用。关注过程早期的部署是 Elder 研究方法的核心。无论交付的是一个完整的软件解决方案还是一个分析算法，从涉众那里获得早期的认同是很重要的——而这是通过在过程的早期获得他们的反馈来实现的。一个解决方案只有在最终用户实施的情况下才是成功的，因此来自关键用户的早期反馈对于形成解决方案的设计是至关重要的。此外，一个很大的附带好处是，关键用户会对该解决方案产生兴趣。

敏捷数据科学能够快速适应变化

项目工作中的变化来自四面八方。例如，一个团队成员转到了另一个项目，或者一个新成员加入了团队。能够快速让新团队成员加入是敏捷的核心优势。团队站立和冲刺计划提供频繁的项目更新和介绍性任务，新成员可以快速完成，直到彻底的知识转移发生。

利益相关者群体也可能发生变化。随着利益相关者的改变，分析项目的愿景也可能改变。当感觉项目目标在不断移动时，敏捷方法的适应性对你有利。在敏捷项目生命周期中发生的迭代提供了一个关键的机会，要么坚持到底，要么转向不同的方向。利益相关者做出多个“是”或“否”的决策点决定了项目完成和成功项目完成之间的差异。

最后一种意想不到的变化可能以技术障碍的形式出现。例如，为项目选择的初始技术栈可能工作得不好。同样，敏捷数据科学的快速迭代允许“快速失败”的现实，即技术限制在项目生命周期中比其他情况下暴露得更快。这种早期的洞察力允许团队在项目时间线内快速发现可以为项目提供更好解决方案的替代方案。

找到适合你的方法

敏捷数据科学的关键词是——你猜对了——敏捷。我们强调了在项目工作中采用灵活结构的好处，最终，每个项目团队都应该采用最适合他们的结构。灵活地设置您的敏捷方法，这样您就可以在项目管理上花费更少的时间，将更多的精力放在完成技术项目工作上，以创建可操作的解决方案，为最终用户提供真正的价值。

请求咨询 与经验丰富的数据分析顾问交谈。

有关系的

阅读本博客系列的第一部分 分析最佳实践—第一部分

阅读博客使用数据科学方法管理不断变化的优先级

查看《挖掘你自己的业务》一书了解更多关于如何利用数据科学和预测分析的力量以及避免代价高昂的错误的最佳实践。

原载于www.elderresearch.com。

分析对福祉的贡献:大数据和自我技术

原文：https://towardsdatascience.com/analytics-contribution-to-well-being-big-data-and-techniques-of-the-self-3584aee9e1d7?source=collection_archive---------4-----------------------

米歇尔·福柯(Michel Foucault)曾指出，衡量技术的唯一可行标准是它是否有助于人类潜能。不久的将来，健康分析可能会为这一愿景提供实质性的证明。到 2020 年，大约 25，000 Pb 的患者数据将可供该行业使用。KPMG 最*对医疗保健专业人士的调查显示，56%的受访者认为这些数据将极大地有助于我们的商业智能实践，而 35%的人认为降低了医疗保健成本，32%的人认为改善了健康结果。【ii】随着医疗保健组织大举投资技术和分析以利用这些机会，有抱负的数据科学家有哪些机会？

健康分析涉及从数据的模式和相关性中获得见解，从而在健康和生命科学领域做出更好的决策。根据研究和市场部门最*对“医疗保健分析”的研究，该市场预计将从 2016 年的 73.9 亿美元增长到 2021 年的 245.5 亿美元，CAGR 为 27.1%。【iii】这种非凡的市场增长是由多种因素推动的，包括政府加强电子健康记录采用的举措增多、抑制医疗支出的压力增加、对改善患者疗效的需求增加、行业风险投资的增加以及分析和大数据技术的进步。

通常情况下，数据科学家有很多机会利用描述性、预测性和规范性分析。量化自我运动的繁荣正在推动一个细分市场。来自众多互联设备的关于个人身体和精神状态的持续少量数据流捕捉到了我们的正念、锻炼和饮食的质量。量化自我的支持者声称，这些数据可能会改善我们的睡眠质量、工作方式和娱乐方式。Asthmapolis、Quadio 和 Zepher 等小数据的应用对于面临特定健康挑战(过敏、哮喘、心脏疾病等)的人群尤其有前途。)，以及寻找竞争优势的运动员。这种对预防医学的关注不仅会给行业和政府带来好处，也会给全体人民带来好处。

在竞争日益激烈的医疗保健市场，埃森哲采访的 89%的行业高管认为实施大数据分析将是保持市场份额的关键。【iv】医疗提供商和制药行业之间的合作伙伴关系，如 DataSphere、HealthConnect 和 PPC/HealthCore，为健康分析的未来提供了框架。包括指令 2011/24/EU 和法国国家医疗卡计划在内的欧洲和国家计划已经提供了大量关于行业成本和人口统计实践的数据。地方尝试以"区域医疗小组"的形式汇集资源，这使得地方从业人员能够分享资源、知识和最佳做法。

有抱负的数据科学家应该更好地了解这个领域及其机遇。商业分析研究所的 2018 年暑期学校将帮助你探索工业格局的演变，以了解当前的挑战和机遇。我们将研究当今可用的小数据和大数据的来源。我们将回顾数据科学的适当方法，以及它们如何应用于这一领域。最后，我们将探索私人和公共组织如何将这些数据转化为行动，以改善我们未来几代人的身心健康。

在巴约纳的暑期班以及欧洲的大师班中，我们让分析为您和您的组织服务。该研究所专注于管理者数据科学的五个应用:数字经济学、数据驱动的决策、机器学习、社区管理和视觉通信。改善管理决策会对你未来的工作和职业生涯产生影响。

---

Lee Schlenker 是 Pau 商学院的教授，也是 http://baieurope.com 商业分析研究所的负责人。他的 LinkedIn 个人资料可以在 www.linkedin.com/in/leeschlenker.查看你可以在 https://twitter.com/DSign4Analytics的 Twitter 上关注我们

【I】Dhamdhere，et。艾尔。，(2016)，健康医疗大数据

【ii】t . Walker，(2015)，只有 10%的医疗保健组织使用数据分析，管理式医疗保健执行官

【iii】市场和市场(2016 年)，医疗保健分析/医疗分析应用市场

【iv】Bresnick，j .(2014)， 89%的高管认为大数据分析是市场份额的关键，HealthIT Analytics

简而言之的分析:为 CRO 设置谷歌分析的介绍

原文：https://towardsdatascience.com/analytics-in-a-nutshell-an-introductory-look-at-setting-up-google-analytics-for-cro-43858f83e0e7?source=collection_archive---------1-----------------------

Image created by Objeqt.com

你如何改进某事？任何事。任何过程，任何行动。你从了解你的基线开始。你今天可以做 10 个俯卧撑，但是经过一个月的每日俯卧撑，你会做得更多。为电子商务商店设置 CRO 谷歌分析是一种通过设置基线和跟踪指标来进行测量/跟踪的方法，以便进行改进。

“你不能改进你不能测量的东西”是一些人的说法。

“有度量才有管理”同样如此。

分析只是一种通过设定基线和跟踪改善(或缺乏改善)的指标来衡量的方法。但是当你看谷歌分析仪表板时，突然之间这个简单的概念变得难以置信的复杂。

你需要为你的电子商务网站追踪的转换优化只会使它变得更加复杂。你需要准确及时的数据，而且是大量的数据。

你需要什么样的数据？research XL(conversion XL 使用)将他们的研究领域分为四个主要类别:

• 技术的
• 探索法
• 数量的
• 定性的

Web analytics 是用来衡量 量化数据 的主要工具，比如你网站的访问量、转换率以及新访客或回头客的数量。定量数据都是关于硬数字的，这就是为什么你需要用定性或启发式研究来补充这些信息，这些研究更具描述性(它们依赖于客户调查和反馈)，但也更容易产生偏见和误解。

由于定量数据是由计算机程序实时收集的，因此您可以相对确定您没有遗漏任何东西— 前提是分析工具配置正确。

这就是问题所在。你必须配置你的分析程序，包括谷歌分析，以确保收集所有你需要的信息。

配置是 CRO 工作的很大一部分。我们称之为“分析健康检查”，通常将它作为一项服务来提供，以确定客户的分析工具是否正常工作并准确跟踪一切。

在这一点上，我们并没有把重点放在一组数据上，尽管我们稍后会这样做。现在，我们正试图收集尽可能多的数据，从中提取见解，只有在您定制分析程序的现成设置时，您才能做到这一点。

网络分析如何工作

当每个人与内容互动时，Web analytics 会实时记录每个访问者的每个行为。

有许多分析工具可以做到这一点，都有类似的功能，但谷歌分析是最常用的工具，超过 70%的市场使用。

每个分析工具的工作原理都是在网站的每个页面上留下一小段 JavaScript 代码。这段代码被称为“跟踪代码”或“片段”，它收集用户行为数据并将其发送回分析程序，分析程序以可读的形式向您呈现数据。

One of the overview screens in Google Analytics

Google Analytics 之所以受欢迎，不仅仅是因为它是免费的(至少在基本形式上是这样)，还因为它不断更新，完全可定制，并且有一个大型社区可以创建免费的定制服务。由于 Google Analytics 足以满足几乎所有用途，它不仅成为首选工具，而且成为分析工具的行业标准。这是那种容易学但很难掌握的东西。非定制版本可供每个人使用，并且非常简单明了，但是真正的数据深度只有在您定制之后才变得可用。你基本上是把普通的菜刀变成了瑞士军刀。

最简单地说，在你可以依靠谷歌分析给你所需的信息来了解你的网站现在做得如何，以及如何改进它之前，你必须教 GA 一些技巧:

• 你想让它跟踪什么
• 如何跟踪它
• 如何举报

跟踪什么:基本指标

指标是数字分析的基础。Google Analytics 中的常见指标有:

• 会议
• 独特的访问者
• 现场时间
• 浏览的页数…

还有很多。

还有我们所说的“维度”，比如位置、页面、语言、性别、产品类别等等。有些指标实际上是两个指标的组合，比如“每页的会话数”或“每页的访问者数”您还可以创建自定义指标。

一旦以度量标准报告了行动，我们就可以从中得出一些结论。

一个很好的起点是简单地统计实际上与任何给定内容互动的访问者的数量。这很好地表明了内容的受欢迎程度。

然而，如果用户点击进入，几秒钟后又点击退出，那么打开一个页面就没有任何意义。这就是所谓的反弹。你希望你的跳出率低。如果很高，意味着访问者没有找到他们希望找到的东西。

我们还可以比较某些类型的操作或内容，以获得更多见解，如找出哪些类型的内容比其他内容更能吸引访问者，或者网站的哪些部分可能会遇到可用性问题。我们还可以比较不同部分游客的行为；例如，不同国家的访问者如何与网站互动。

得出结论的第三种方法是寻找相关性。你在寻找一些东西，比如一部分访问者如何与网站互动，或者什么样的互动顺序通常会导致转化。你可以根据访问者的最大*均订单价值来选择一个类别，然后观察他们与网站的互动情况，从而很好地转化。然后你就可以利用这些信息来优化你的网站——从本质上来说，就是找到调整用户体验的方法，让他们走上与你的成功客户相同的道路。

收集这些数据是 cro 开始创建假设进行测试的方式，这导致了转换的优化。

如何跟踪:细分和事件

包括谷歌分析在内的任何网络分析工具的最佳特性之一就是细分的能力。细分可以让你根据许多特征选择不同类别的访问者——他们来自哪里，他们在寻找什么，他们买了多少，等等。

Sample of a segmented report in Google Analytics

事件跟踪

通过一些定制，任何分析工具都可以跟踪你网站上的单个事件。这将释放更多的数据财富，并允许你利用它来获得更多关于你的访问者与网站互动方式的见解。通过使用事件跟踪，可以跟踪网站上的任何活动，从点击单个链接到播放视频和下载文件。

An example of event goal in Google Analytics

目标和转化等分析类别基于“页面视图”思维模式。事件跟踪则不同，它更关注用户体验。在谷歌分析中，事件基本上是互动，比如下载 PDF 或电子书，播放嵌入的视频，点击外部链接或行动号召(CTA)按钮。

虽然事件跟踪需要定制和额外的 JavaScript 代码，但使用标记管理器实现和维护相对容易。

目标

您的分析工具也可以跟踪您的现场目标——如果您对其进行配置的话。目标是你希望你的用户做的具体的动作，比如浏览某些网页，或者看一个视频，或者在一个页面上花一定的时间。一些最常用的目标是“目的地目标”，它让你检查访问者是否真的到达了你定义为目标的网页。一个例子是“感谢页面”,表示用户在你的网站上完成了购买。

如何报道:谷歌分析中的电子商务

Google Analytics 具有完全可定制的电子商务跟踪功能，可与您的电子商务*台集成，并允许您在 Google Analytics 中查看网站的表现，以收入的形式显示。您可以看到正在销售的产品数量、每位客户的*均收入、客户的购物行为以及其他高度相关和可操作的数据。这也是一个可定制的功能。

是的，这只是为 CRO 设置谷歌分析的一个快速概述！

正如你所看到的，数字分析是任何电子商务商店几乎不可或缺的工具。虽然理论上没有网络分析也可以经营网络商店，但这并不是长期成功或增长的秘诀。

无论你选择什么样的网络分析工具，它都将开启一个充满机遇的新世界，不仅能让你洞察网络商店的表现，还能洞察访问者的想法。学习掌握谷歌分析，你将改善你的网站，并迫使更多的现有访客成为客户。

分析是增加网上商店收入的关键，也可能是最具成本效益的方法。

这篇文章最初发布在 Objeqt 上。访客很棒，顾客更好。是时候将流量转化为收入了。

金融分析

原文：https://towardsdatascience.com/analytics-in-finance-9dae794617ec?source=collection_archive---------3-----------------------

我第一次接触金融分析是在大学四年级的一次招聘活动中，当时我正和朋友聊天。一位最*在一家不知名的投资银行获得博士学位的人的推销引起了我的注意:他的团队使用一种基于布朗运动理论的专有交易算法取得了很好的结果。布莱克-斯科尔斯法案和金融幸存者的触发警告:-)

对于那些在高中物理课上睡着的人来说，布朗运动是悬浮在流体中的粒子的随机运动。他的团队应用随机运动理论来预测股票价格的随机运动。

我不会争论这种交易策略的优点，但我记得普林斯敦经济学家伯顿·马尔基尔所著的《漫步华尔街》一书中的一句话。

“一只被蒙住眼睛的猴子向一份报纸的金融版投掷飞镖，可能会选择一个与专家精心挑选的投资组合一样好的投资组合。”

令人欣慰的是，过去几年，预测分析在金融领域的应用已经不那么晦涩难懂了。我特别喜欢的一个领域是情绪分析——利用数据来确定消费者对产品的感受。

例如，假设你想购买苹果公司的股票，但又担心 iPhone 的销售。你可以选择在苹果店外站一个月，数一数拿着新盒子的顾客数量。然而，一个更有效的方法可能是统计全国范围内提到“iPhone”以及其他关键词(如“已接收”、“拆箱”、“我的新手机”)的公开推文数量。这些自然语言处理技术允许公司外部人员粗略估计产品采用率。公司的客户服务团队使用类似的软件来识别关于错误功能的愤怒推文。机会主义交易者用它们作为卖空股票的触发器。

使用情绪分析进行自动交易并非一帆风顺。2013 年，美联社的推特账户遭到黑客攻击，一条虚假的推特消息称总统在一次袭击中受伤。结果呢？1300 亿美元在几秒钟内就从股市中蒸发了。市场很快恢复，但它有力地提醒了人们，使用这些机器学习技术进行自动化高频交易的影响。

这篇简短的文章仅仅触及了金融分析的冰山一角，主要是关于股票市场的应用。传统公司越来越多地转向分析，以创建更好的收入预测(谁购买什么、何时购买以及如何购买)。在个人理财领域，有几个应用程序可以分析用户的消费模式，并提出省钱的方法。我们很多人都不知道自己在食物、娱乐和公用事业上花了多少钱。猜测你每月的食品开销。如果一款应用可以帮你额外节省 15%，你会怎么做？在下面的评论里告诉我。

分析也是关于解决小问题的——比如在海滩上找一个停车位…

原文：https://towardsdatascience.com/analytics-is-also-about-solving-little-problems-like-finding-a-parking-space-at-the-beach-ed8d3851c18e?source=collection_archive---------10-----------------------

周日法国大选结果出来后，我们决定前往比亚里茨老港口的海滩度周末长假。距离我们在波城的公寓只有短短一个小时的车程，住在比亚里茨的挑战是找到一个靠*海边酒店的停车位。当你开车穿过小镇狭窄的街道时，停车位变得越来越少。任何人看到这些数据(或至少在海滩上)都会有一个永恒的问题:我是应该先找到一个停车位，然后步行几公里去酒店，还是等到找到一个更*的停车位？

如果大数据是媒体狂热的焦点，分析是我们如何看待日常问题以及如何寻找实际结果的心态。简单的问题是那些可以在手边的数据中找到答案的问题，是那些过去的经验让我们相信一种最佳方式的问题。复杂的问题是那些数据不足以找到正确答案的问题，在学术环境中，我们只能在特定的背景下计算更好的解决方案。无论是预测总统选举中的获胜候选人，还是找到尽可能靠*海滩的停车位，复杂的挑战都需要在寻找答案之前思考问题。

人们解决问题的方式不统一，人们看待数据的方式也不一样。丹尼尔·卡内曼建议，在应对日常挑战时，我们基本上使用两种方法。【1】系统 1 思维本质上是直觉，依靠我们过去的经验对环境挑战做出快速自发的反应。系统 2 与批判性思维联系更为紧密，在批判性思维中，我们运用理性思维，或者至少是有限理性，来思考对给定问题的最恰当的反应。Kahneman 的工作继续根据要解决的问题的性质来探索每一个的相关性。

两个“系统”都不意味着人们客观地看待数据。我们看到的数据被几个认知过滤器遮蔽，这些过滤器被下意识地部署来聚合、组织和解释我们看到的东西。例如，框架效应会根据数据呈现的方式影响人们对问题的积极或消极反应。锚定指决策时倾向于优先考虑第一条信息(“锚”)。从众效应描述了因为许多人相信而相信一些事情的倾向。改善决策通常不需要更好或更丰富的数据，而只是考虑人们实际上如何看待他们拥有的数据。

在一个阳光明媚的下午，提高我们在度假小镇找到停车位的几率并不是火箭科学，但它可以从分析中受益。镇上的交通状况对评估海滩停车没有什么帮助，把这个问题框定下来会让我们对自己真正想要的东西有不同的看法(停车位还是尽可能少提行李箱？).加州大学洛杉矶分校的唐纳德·舒普教授对这个非常实际的问题进行了深入的思考。这个问题很复杂，因为可观察到的数据(我们开车去海边时看到的停放的汽车)并没有告诉我们最*的露天停车位在哪里。我们以前的海滩经验可以帮助我们确定，当我们靠*海岸时，我们是否相信 99%或 85%的空间将被占用。假设停放的汽车*均分布；在第一种情况下，当我们距离酒店 400 米(大约 1/4 英里)时，我们最好抓住第一个可用的空间，在第二种情况下，我们可以合理地等到我们距离酒店 15 米(50 英尺)的时候。

商业分析实践是商业分析研究所的核心和灵魂。在巴约纳的暑期学校，以及在欧洲的大师班，我们让分析为您和您的组织服务。该研究所专注于管理者数据科学的五个应用:在数字时代工作、数据驱动的决策、机器学习、社区管理和可视通信。数据驱动的决策会对你未来的工作和职业生涯产生影响。

---

【1】卡内曼博士(2015)。思考，快与慢。第一版。纽约:法勒，斯特劳斯和吉鲁。

【2】例如，参见 Shoup，D. (2007)，巡航停车，访问，n.30，弹簧http://shoup.bol.ucla.edu/CruisingForParkingAccess.pdf

纽约租赁市场分析| ka ggle 排名前 15%的网站！

原文：https://towardsdatascience.com/analytics-on-the-new-york-rental-market-top-17-on-kaggle-91bb139d8f4b?source=collection_archive---------2-----------------------

这是我第一次认真参与 Kaggle 竞赛的文档资料——rent hop 租赁咨询。两个半月， 146 git 提交和 87 提交之后，我站在排行榜的前 15% 之内——一个我引以为豪的位置！

Kaggle 比赛是由 Renthop 组织的，rent hop 是一家专门针对纽约市场的租赁网站。给定各种列表参数，如价格、位置、经理(经纪人)、建筑、图像，我们必须预测每个租赁列表将获得的兴趣(互联网流量)。“兴趣列表”是一个离散变量，分为“高”、“中”和“低”。

这个竞赛的领域引起了我相当大的兴趣——就在 4 个月前，我还在班加罗尔混乱的房地产市场中沮丧地寻找一个像样的地方！再加上竞争激烈的纽约市场，我们有一个现实世界的问题等待解决。

我的旅程 —对我来说，这场比赛真是过山车——我的情绪和我的排行榜位置之间绝对存在正相关关系！不过，我学到了很多，从疯狂的功能工程到实现新算法，从修复验证漏洞到构建我的定制 stacker-ensemble——这种学习为未来的竞争提供了一个很好的跳板。

也就是说，这篇博客有点技术性。可以的话就离开；)

到目前为止，我构建预测模型的标准方法是在标准变量上构建一个随机森林。没有太多的探索或特性工程——这种方法没有给我带来好处。在这次比赛中，我花了前两个月的时间来理解这些特性，并尝试它们的组合。

特征工程

价格 —最明显的特征之一是租赁列表的价格(价格的对数)，这导致了一个更好的衡量标准——每间客房的价格。当与邻里或街道等其他变量相结合时，价格可以很好地代表“这是 21 街上最好的公寓吗？”。不过，对于一室公寓来说，这个功能有点棘手，因为根据定义，一室公寓没有卧室。

经理人 —纽约市场将经理人(或经纪人)视为高度可信的来源，这一点从经纪人代理机构的关系中可以看出。由于 manager_id 是一个高度分类的变量，kagglers 的同事们想出了一个巧妙的特性——“manager _ score”！它基本上是该经理的“高兴趣”列表和“中等兴趣”列表的百分比的组合。这是我几乎所有模型中最重要的特征。

我提出了“经理机会”的概念，它表明一个经理的列表相对于通过同一经理的其他列表有多好。基本上，将租金价格与经理的中值价格进行对比——“布朗先生，你有更便宜的 2BHK 公寓吗？”

建筑物——这个特征应该是致命的，因为这是我们在谈论地点时所能得到的最狭窄的范围。我试着映射像“建筑分数”、“建筑机会”、“建筑数量”这样的特征，但是它们都抛弃了我的简历分数。许多 Kagglers 也经历了同样的情况，最可能的原因似乎是坏的数据点-16.8%的建筑物具有 building _ id“0”，尽管它们具有不同的坐标。然而，对建筑物的一个积极认识是，90%的“零建筑物标识”的建筑物是“低兴趣”的，至关重要！

邻域 —普通的旧纬度和经度被证明是相当重要的特征，但我们并没有就此止步:)一个包含 60 个聚类的简单 k-means 给了我广泛的邻域，从而产生了诸如“neighborhood_score”和“neighborhood_opportunity”等特征。最初，我使用 Google API 将坐标映射到广阔的区域(正如 Renthop 网站上提到的)。

随着我构建越来越多的功能，我注意到一个共同的主题——价格和兴趣是核心部分，而“经理”、“邻居”、“建筑”、“街道地址”、“邮寄时间”是外围部分。当外围部分通过中间部分(或计数，或某种一般化)与中心部分整合时，会产生显著的改进。这张图是我接下来几天的必看之物:)

街道/显示地址 —提供了两种地址，街道地址和显示地址，这是街道地址的一种精简形式。我尝试了像“公寓 _ 计数 _ 街道”这样的功能(这条街道的出租有多受欢迎？)和通用的“street_opportunity”。

我对街道地址的另一个想法是，它们是否包含“街道号码”，这应该有助于“地址的准确性”(Renthop 关心的一个变量！).结果没什么帮助。

一个从 kaggler 同事那里借来的想法——String Difference b/w the street _ address 和 display_addres。这是一个相当大的差异，在“高利息”，而不是一个清晰的想法为什么！

发布时间 —当然，作为季节性业务，基于时间的功能派上了用场(mday，wday，hour，minutes)。我们无法探究年度季节性，因为数据集夹在 2016 年 4 月和 2016 年 6 月之间。

据报道，Renthop 上的一个房源停留时间为 5-6 分钟，竞争非常激烈！这促使我查看哪些房源是在同一小时内发布的，结果是“hour_opportunity”(在过去的 30 分钟内是否有更便宜的公寓发布？").这个特性并没有带来改进，尽管一个类似的特性很有用——“hour _ frequency”(那个小时发布的列表数量)。这可能会影响到一天中特定时段的在线消费者数量。

Listing_Id —这只是一个普通的序列号，至少我是这么认为的！结果证明这是一个非常重要的特性，因为它与“创建的”变量惊人地相关。此外，还有一些离群的列表，它们的 listing_id 比同一天发布的租赁的 listing_id 中值要高。而这些离群值中有很大一部分是“低兴趣”，陪审团对为什么会有分歧！

无论如何，这是一个令人难以置信的洞察力——有时，序列 id 可能与其他变量有很大关系！

描述——这应该是关于公寓的微小细节的宝藏，比如“允许携带宠物”、“门卫”、“电梯”等等。许多人尝试了著名的 tfidf 算法，但无济于事——我的假设是，人们最初是根据价格、位置和经理表现出兴趣的。细节在租赁后期考虑(就在最终确定之前？).

我想到的几个功能与识别描述中的垃圾邮件有关——可能，我是第一个公开这些内容的竞争者:)计算了大写字母的百分比和感叹号的数量——“啊！！你喜欢这个描述吗？！!"

我还尝试将电话号码或电子邮件地址作为一个因素变量。虽然没帮上什么忙。

Renthop 评分——在试图提取租户的使用模式时，我发现了一些见解。他们中的大多数人受到了 Renthop 分数的启发(Renthop 根据这个内部计算的分数对列表进行排名)。我也尝试了一些基于主要特征的经验公式，但是几乎总是增加我的对数损失。一个重要的学习——总是组合单调的特征，随机分割或对数不起作用。

高基数特性的基数—Branden Murray 的内核向我们 kagglers 介绍了一个漂亮的特性，用于计算经理的高分、中分或其他分类变量。

让我解释一下。经理 M 有“n”个列表，假设有“M”个经理。如果经理 M 的列表通常具有“高兴趣”,我们想要奖励他。我们如何对此进行量化？经理 X 可能只有两个都是“高兴趣”(100%命中率)的列表，但是经理 Y 可能有 100 个列表，其中 60 个是“高兴趣”(60%命中率)。我们应该倾向于经理 Y，因为他的一致性，而不是经理 X(成功，但短暂的职业生涯)。

要对此进行量化，请计算一个全局高比率(整体高利息百分比)并计算经理的高利息百分比。用λ将它们合并，λ与他的计数的负对数成反比。

经理高分=(经理高百分比)(lambda) +(全局高百分比)(1 — lambda)，其中 lambda = 1/(c + e^(-count/d)，c 和 d 为经验常数

基本上，当经理的(发布的列表)计数达到最高时，我们看重他的百分比，反之，我们看重他的全球百分比。

主要学习—验证漏洞

在建立我的验证渠道时，我观察到我的本地简历分数一直比我的公开简历分数好。当我往下钻的时候，泄漏的源头让我大吃一惊，那是我的第一手经验；)显然，在计算 manager_score 时，我必须计算高兴趣、中等兴趣和低兴趣列表的百分比。我对整个训练集进行计算，然后对该训练集本身的子集计算 logloss，因此引入了泄漏。后来我做了一个函数，它根据给定的训练集、验证集和测试集分别计算这些百分比。

另一种学习——分层拆分

就兴趣水*而言，数据集非常不*衡——只有 7.8%的列表是“高兴趣”，22.8%是“中等兴趣”。因此，当为了验证而进行分割时，我特意做了分层分割，以保持*衡。

成功的模型

• H2O . GBM——我在整个锦标赛中的主要工作。我已经手动调到接*最佳状态，我希望；)
• XGBoost — XgBoost 是爱。XgBoost 就是生活！在性能方面与 gbm 相当
• H2O . RF——一种易于设置的算法，但结果不如 gbm 和 xgboost。

总的来说，我应该自动调整我的算法。目前是一个非常手动和缓慢的过程。此外，我意识到模型种子相当重要，多次运行*均(用不同的种子)是有益的。虽然放弃了，时间限制:(

不起作用的模型

• H2O.deeplearning 没有给出一个好的结果，可能是一个糟糕的超参数选择的结果。还是那句话，不擅长调音。
• extra trees——一个随机化的随机森林，让它工作了，但是我的系统没有足够好的 ram 来进行适当的测试
• SVM、KNN、Logreg——所有更简单的 ML 模型都存在空值问题，并且没有给出好的结果。

堆叠

这是我第一次学习 stackers，阅读了 MLWave 的不可思议的解释者博客，并着手实施我自己的！最初我失败得很惨，又看了一遍博客，终于明白了堆叠的本质。慢慢；)

所以，我有一个 3 层堆垛机，但没有太多的多样性。前两层由我的 3 个工作模型组成——XGBoost、GBM 和 RF。第三层是第二层模型的简单集合。或许，更关注简单的模型会给我带来更多的多样性——尽管如此，我还是获得了相当不错的 0.01 的跳跃:)

注意:对于我的最终提交，我用一个 出色的公共脚本 对我的提交进行了*均。可能每个人都在这么做。)

魔法特性

在比赛的最后一周，Kaggle 上一位非常慷慨的大师 KazAnova 发布了一个非常强大的漏洞——图像文件夹的时间戳。仅仅插入时间戳就给了大多数人 0.01 的跳跃。我试着挖掘时间戳，它与“创建”变量的关系等等——这很可能是一个内部原因。

一个类似的神奇特性是包含在图像 URL 中的 listing_id——大多数与原始的 listing _ id 相同。那些不同的列表可能是同一套公寓的转贴，这表明它还没有被出售→“低利息”

结论

我从比赛中获得的主要收获是:

• 探索每一个变量。他们每一个人。查看数值的*均值、中值、最大值、异常值，以及类别的分布
• 把大部分时间花在特色上。当你认为你已经拥有了一切，再从头开始。
• 建立一个系统的管道。很容易引入漏洞
• 快速构建和测试。拥有高效、快速、易于调整的算法进行测试。
• 搭建一个模型测试*台，堆叠变得容易。
• 花大量时间在 Kaggle 内核和讨论上。他们太酷了:)

总的来说，这是有趣的几个月！学到了很多，这只是未来比赛的起点。很快就会达到前 10%😃

此文最初发布在我的 博客 上。每周一篇博客

分析——内部人员

原文：https://towardsdatascience.com/analytics-the-inside-man-a1fc67737a1a?source=collection_archive---------4-----------------------

如果有一种方法可以让一家公司(姑且称之为这家公司， Hooli )通过在 SaaS 上市为其他上市公司提供种子，这将提供深刻的见解。上市公司会很乐意接受，因为他们可以更好地了解自己的用户群、交易历史，甚至可以利用这些数据为未来目标制定可行的计划。但是，如果胡利决定创建一个基金，并根据收集到的数据进行交易，会怎么样呢？这算不算内幕交易？

分析的历史

1996 — HIT COUNTERS

1996 年，第一个广泛使用的托管点击计数器服务 Web-Counter 诞生了，引发了在每个网站登陆时显示里程表式点击计数器的趋势。在 2004 年，Web analytics 作为 Web 优化的重要工具得到了广泛的认可，它提供了越来越复杂的解决方案，报告了大量的数据。2005 年，谷歌分析收购了海胆，并迅速成为最广泛使用的网络分析服务。它非常注重定量分析，直接与谷歌合作。

今天

在互联网上访问量最大的 10，000 个网站中，谷歌分析服务了其中的 67% 。

2015 Annual e-commerce Revenues

http://fortune.com/2015/11/06/amazon-retailers-ecommerce/

最大的电子商务零售商亚马逊的网上销售额占其总销售额的 100%。因此，很容易看出一只基金是否可以在下一个报告季度访问他们的分析/转换指标，这将是一个巨大的优势。但是亚马逊是一个例外。

大部分大盒子店严重缺乏线上销售部门。全球最大的零售商沃尔玛(Walmart)认为，网上销售额仅占其总销售额的 2.9%。更糟糕的是，他们的在线销售增长正在放缓。2015 年第三季度，同比仅增长 10%。

Williams Sonoma (WSM)是一家有 60 年历史的厨具和家居用品供应商，其在线销售额占总销售额的比例最大。Williams Sonoma 在 2015 年刚刚突破了 50%的在线销售额——25 亿美元

如果你有 Williams Sonoma 的分析，你如何赚钱？

Williams Sonoma 2015 10-k

策划这场闹剧

WSM’s Quarterly Revenues

股票市场中的钱是基于:

1. 与指导相比，股票的表现如何
2. 未来指南看起来有多好。

让我们假设你已经覆盖了#2。你知道，WSM 和大多数零售商一样，是季节性零售商，其大部分收入来自第四季度。通过交叉引用:

• *均回报率%
• 独立访问者的数量
• 买家的独立访客百分比
• 结帐时*均$篮子大小
• 线下促销
• 与前几年相比的总体经济情绪

你大概知道实际收入数字与指导相比会下降到什么程度。斜体表示如何测量离线分量。

然后你买入多头/空头头寸，坐下来等着看你的侦察有多准确。

“Hooli 作为一家对冲基金”的好处在于，它不必去追逐 WSM，而是任何规模的使用他们的转化跟踪和分析工具的上市零售商。通过以最低的成本向公司提供一些真正有用的东西，为创造者提供了大量的知识，这些知识可以用来做好事或者仅仅是赚钱。

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

[## 重新*衡——让大公司保持竞争力

调整资金组合

—对于保持竞争力的大公司来说，Rebalancingmedium.com](https://medium.com/p/a76b02f4aa01) [## 谈判——替代金钱

我们听说人们在构建交易时“跳出框框思考”的故事。当使用一种媒介谈判时(即…

medium.com](https://medium.com/p/127e05e2ad90) [## 理解事物的真正价值

公司

medium.com](https://medium.com/p/fcfc5e9a6d90) [## 销售策略:吓唬你的潜在客户购买(谷歌和人工智能)

去吧 AI

medium.com](https://medium.com/p/16d347e833fe)

如果你喜欢这篇文章的整体信息，请随时与我们联系。我们做演讲约会——

用自组织地图分析气候模式

原文：https://towardsdatascience.com/analyzing-climate-patterns-with-self-organizing-maps-soms-8d4ef322705b?source=collection_archive---------5-----------------------

亮点:

在本文中，我们将了解:

• 自组织映射(SOM ),以及它如何用于维数减少和无监督学习
• 解释用于探索性数据分析的训练 SOM 的可视化
• SOMs 在加拿大不列颠哥伦比亚省气候模式聚类中的应用

链接到我的其他文章:

1. 张量流和自定义损失函数
2. 随机森林
3. Softmax 分类

简介:

当我第一次开始学习神经网络时，我偶然发现了这个被称为 Kohonen 图的奇怪发明，或者在文学中更常见的称为自组织图或 SOM。这个神经网络受人类大脑皮层的感觉激活模式的启发，使用简单的启发式方法进行无监督训练，能够发现高维数据中隐藏的非线性结构。最*我看到一些气候学家写的有趣的文章，他们使用 SOMs 分析和预测天气和气候(这是一项众所周知的困难任务)，我想我应该与你分享这项有趣的无人监管的技术。

自组织地图:

基本上，SOM 是离散的*面神经元网格，即隐藏层，有时称为 Kohnen 层，由输入层提供信息:

Overview of the SOM neural network

每个隐藏层神经元都有几个“邻居”神经元(单个单元的邻居的最大直接数量可以是六个，如上面的六边形网格，或者四个正方形网格)。我们将每个神经元与其邻居之间的“距离”定义为每个神经元的输入到隐藏层权重之间的欧几里德距离。每个隐藏神经元的输入-隐藏层权重有时也被称为码本向量。我们定义的距离在以后会变得很重要，因为它对原始数据集的低维信息进行了编码。在上图中，每个隐藏层神经元都有一个带有 n 分量的权重向量(即输入与隐藏层紧密相连)。

那么我们如何训练这个网络呢？训练过程实际上非常简单，不涉及梯度计算:

1. 将隐藏神经元权重初始化为小的随机值，或者使用 PCA 权重初始化
2. 将数据行x进给到输入层
3. 遍历隐藏层中的每个神经元，找到最佳匹配单元(BMU)，即与数据行 x ᵢ 具有最小欧氏距离或度量的神经元
4. 对 BMU 及其相邻神经元应用权重更新。使用邻域函数φ来计算 BMU 的相邻神经元
5. 收缩邻域函数φ
6. 重复步骤 2 至 5，直到达到迭代极限或收敛(所有神经元和所有数据之间的*均码本向量距离小于某个阈值)

上述算法被称为竞争学习，在精神上与其他基于启发式的算法(如遗传算法和粒子群方法)非常相似。此处提供了该算法的完整描述。SOM 的基本思想是“填充”底层数据的空间，如下图所示:

Training the SOM to ‘fill’ the dataset

与类似神经元数量的前馈网络上的反向传播相比，竞争学习算法通常更快，但如果 SOM 网格非常大(10⁴或更多神经元)，则可能会变慢。

SOMs 属于一类叫做非线性维度缩减(NLDR) 的技术。维数约简技术(主成分分析，t-SNE 等。)通常用于可视化和解释，以及变量选择。som 更适合前一种应用，合适的 som 可以被进一步分析，以获得低维的可视化和可解释的结果，呈现给你的老板、scrum master、营销团队或你的另一半。此外，诸如 K-means 的聚类技术可以应用于拟合的 SOM 网格，并且从该网格可以获得输入的鲁棒聚类。通常，SOM 上的 K-means 比常规 K-means 执行得好得多，并且有时可以发现隐藏的非线性交互模式。现在让我们研究一些气候数据，看看 SOM 能做些什么。

下面的代码示例使用的原始 SOMPY repo 可从这里获得。SOMPY 对于 Python 来说是一个很好的入门包，但是如果你也精通 R，请查看一下 kohonen 包，它有一些非常好的可视化工具(也可以在这里看到关于使用 kohonen 包进行 R 的教程)。

报告包含以下任务的 SOMPY 代码的所有修改和气候数据。 运行代码的 main.py 脚本文件在https://github . com/hhl 60492/SOMPY _ robust _ clustering/tree/master/SOMPY/examples。

气候数据分析:

从http://climate . weather . GC . ca/prods _ servs/cdn _ climate _ summary _ e . html收集加拿大不列颠哥伦比亚省 2009 年 1 月至 2017 年 12 月的历史气候数据(月度汇总)。每个 CSV 文件包含气候数据的每月摘要(如月*均温度、月最低/最高温度、月降雨量)以及记录数据的气象站的纬度和经度。每个唯一的气象站给出一个单行，每个 CSV 中大约有 300 个气象站。

现在我们保持简单，使用纬度、经度、中间温度、最高温度、最低温度和降雨量。这些列被提取并强制转换为浮点类型。包含任何 nan 的行被删除。SOMPY 通过计算数据矩阵的特征值来自动计算 SOM 网格的大小。

对 20621 行数据的训练耗时约 5 秒。首先要注意的可视化是组件*面热图。

Component plane heatmaps for each feature that was fed to the SOM.

每个热图代表 SOM 网格学习到的单个特征或数据列的强度。请注意，热图是离散化的，每个子图中的每个“块”都是唯一的神经元，神经元在所有子图中都具有相同的位置，即纬度子图左上方的块是经度子图和月中值温度子图中的相同神经元，依此类推。通常，不同分量*面中的相似热图表示特征的相关性，相异表示可忽略的相关性，反转表示反相关性。另请注意，拟合的 SOM 将代表整个年份范围内一年中所有月份的特征，即 9 年*均值，因为提供了 9 年中 1 月至 12 月的连续数据。利用前面的事实和经纬度信息，我们可以看到:

• 月最高温度出现在不同的纬度和经度，包括纬度。北纬 49 度以上。120–124 W；这是靠*美加边境的一大片公元前南部地区，包括温哥华岛的南端、温哥华市区、弗雷泽山谷，一直延伸到奥肯那根
• 后者。北纬 49 度以上。西经 120-124°的地区也有最多的降水。
• 纬度和经度分量*面热图中各区域的大小表明，在北纬 49-50°和西经 123-124°区域有大量的气象站，那里的人口密度最高(每个 CSV 文件中所有气象站的纬度和经度的下列图表似乎证实了这一观察结果)

(注意:为了验证地理位置，最好实际提取 lat。而且长。来自 Python 中拟合的 SOM 的数据，并用它们标记其他组件*面热图中的细胞/神经元。)

Location of weather monitoring stations in BC. Seems nobody cares about the weather in Spatsizi Plateau

• 月中值温度与月最高温度相关，在较小程度上与月中值温度相关。
• 降水量似乎与月*均气温和最高气温呈反相关关系(作为当地人，我可以证实，当天气炎热时，我们的降雨量会少得多，反之亦然——太*洋西北部的气候是这样的，在晚秋、冬季和春季气温较低时会有大量降水，而在夏季气温较高时很少或没有降水)。

我们可以做的下一个可视化叫做 U 矩阵。U-matrix 也是一个热图，但可以像我们的 SOM 网格中的地形图(显示一个区域的海拔等高线的地图)一样进行解释。U 矩阵中的“山丘”代表相邻之间的大距离，反之亦然。

Note: The number of neurons and grid layout in the U-matrix and the component plane heatmaps are the same. The component plane plots were stretched veritcally due to matplotlib.

U 矩阵让我们了解了 SOM 网格的景观，以及神经元的邻域。它帮助我们直观地看到 SOM 网格本身中有哪些潜在的聚类，这是对我们将要在网格上运行的 K-means 聚类结果的一个很好的完整性检查。由于 K-means 在最佳聚类数上有点幼稚，我们将使用结合误差*方和(SSE)的“肘”方法来找到最佳聚类数。SSE 计算的算法如下:**

1. 对于 k = 2 到 k_end :
2. 计算数据集 X 上的 K 均值
3. 对于每个集群 n :
4. 计算L2**--簇n 和簇 n 的质心之间的向量差的范数，并将其加到总数【SSE】中**

SSEs vs . differentk的结果图如下所示

通过找到上图一阶差分的最大值的指数，加 1，可以解析地找到肘点。不幸的是，K-means 算法不是太健壮，并且对于不同的运行给出不同的肘曲线，所以在许多引导样本上引导和重复肘/SSE 图分析将给出最佳的更好的估计。所有这样做的代码在下面的要点中，在 SOMFactory 类(在 sompy.py 中)中的 cluster()方法被修改以实现上述内容。

对于这个特定的 SOM，在 20 个引导样本上*均的 SSEs 的一阶差的最大值是 17，因此最优的 k 应该是 18。重复这些运行可以为现在的最优 k 提供一致的结果，这很好。用这个 k 运行最终的 K-均值给出以下聚类:

SOM K-means clustering result.

这有点类似于 U-matrix 图，所以我们离 SOM 网格的真正聚类并不太远。

在我们穿上夹克回家之前，还有几件事要做。让我们看看每个聚类质心的特征(K-表示质心代表一个聚类中的*均特征)，预测哪个气象站属于哪个聚类，并将聚类的气象站放在地图上。我们使用 gmplot 和 Google Maps API 进行地图叠加。顺便说一句，gmplot 已经过时了，需要一些补丁来使它与当前的谷歌地图 API 兼容，你还需要一个有效的谷歌地图 API 密钥来访问该 API。gmplot 代码修改的要点在这里。

**Centroid 0[  51.38661738 -125.27254198    7.51493849   16.8132888    -1.17574106
   67.95416645]
Centroid 1[  50.61259827 -126.25917862    6.32184038   14.17993615   -1.63282112
  340.64034668]
Centroid 2[  50.42396495 -125.2544494     7.2744194    16.09718498   -1.19140013
  222.65626168]
Centroid 3[  50.42534148 -126.39001822    6.72726471   14.53652612   -1.31210139
  507.65982791]
Centroid 4[  49.89467361 -122.37195052   16.63158605   29.73554202    5.95873865
   28.06162618]
Centroid 5[  52.27917741 -121.73550782   -3.83946568    8.19646576  -19.93363911
   45.30064963]
Centroid 6[  50.2945556  -125.21241436    9.15306962   18.32174182    0.93638661
  119.43331396]
Centroid 7[  50.70282538 -125.32884059    8.00965749   17.614526     -0.77992491
  151.77106456]
Centroid 8[  50.31580334 -126.23307623    6.5871719    14.64225657   -1.44068436
  660.70782628]
Centroid 9[  50.28874072 -125.06866063    7.49467144   16.55379438   -0.84254229
  251.73801799]
Centroid 10[  50.4262205  -126.2629756     6.58541814   14.36302394   -1.36671652
  399.90931304]
Centroid 11[  50.35982435 -125.51021147    6.32659523   14.73932271   -1.89873252
  294.050496  ]
Centroid 12[  51.24356927 -121.64231971    6.18712464   18.67948989   -5.48058692
   36.06758652]
Centroid 13[  50.75675998 -125.60116426    7.48408728   16.37144962   -0.95604598
  190.18377378]
Centroid 14[  51.1337961  -124.85444455    7.9966279    17.1295218    -0.56629512
   94.65084155]
Centroid 15[  50.12150383 -126.04955706    6.7603695    14.43437023   -1.13385479
  461.59884165]
Centroid 16[  50.72982522 -126.73419985    6.88866959   14.84315741   -1.12018377
  586.45036101]
Centroid 17[  51.44904147 -122.37356247   12.74453517   26.10130055    1.58123601
   50.9674971 ]**

每个质心的分量对应于一年中所有月份的纬度、经度、中间温度、最高温度、最低温度和总降水量。

Cluster centroids map overlay.

你可以在这里玩玩交互式质心图:https://github . com/hhl 60492/SOMPY _ robust _ clustering/blob/master/SOMPY/examples/centroids _ map . html(下载到你的机器上，用浏览器打开)。

可以进一步分析 SOM，并在地图上叠加每个气象站所属的聚类(一种方法是对 2009 年至 2017 年所有气象站的数据进行*均，或者重新拟合 SOM 的年度或月度数据，以查看相应的年度和月度模式。同样，不幸的是，气象站的位置存在严重的分布偏差，因此要考虑的一些其他特征将是，例如，具有较少地理偏差的大气压力测量、雷达数据或物理高程数据。

要了解气候学家如何在他们的模型中使用 som，请看:http://online library . Wiley . com/doi/10.1029/2009 JD 011706/full

结论:

我们已经看到了 SOMs 如何用于数据可视化，发现数据中的相关性和模式，以及执行数据的聚类。要提取更复杂的模式，您可以向 SOM 提供更多的输入特征，或者在某个维度(如时间)上划分特征。另一件要注意的事情是:运行 K-means 聚类应该使用自举集成来完成，并且聚类标签应该与类似于匈牙利算法的东西相匹配，以便找到稳定、一致的聚类。不管怎样，玩得开心点。

分析 1996-2018 年自由骑行世界巡回赛中的极限滑雪和单板滑雪

原文：https://towardsdatascience.com/analyzing-extreme-skiing-and-snowboarding-in-r-freeride-world-tour-1996-2018-ffde401fb3ae?source=collection_archive---------18-----------------------

自 1996 年以来， 自由骑行世界巡回赛 (FWT) 一直举办极限滑雪&单板滑雪赛事。在 3 月份刚刚结束 2018 赛季后，我用 r

如果你还没有听说过 FWT，这是一项令人兴奋的运动，骑手们选择崎岖不*的路线穿过悬崖、飞檐和肮脏的峡谷(就像这条路线)。没有人工跳跃或半管道，只有一个在顶部和底部的门。裁判使用五个标准(线的难度、控制、流畅性、跳跃和技术)从 0 到 100 打分。

我做这个项目的愿望主要是练习一些网络抓取，访问 Twitter API 并加强我自己对其中应用的概念的理解。当谈到体育分析时，滑雪和单板滑雪被遗忘了——我的意思是甚至网球也有一个 R 包——所以我认为这将是一个很酷的项目。

Twitter 上的#FWT18

首先，我使用 Twitter 包从 Twitter API 收集数据。为了做到这一点，我需要设置一个开发者帐户来认证来自 R 的连接(关于如何做的一个很好的教程是这里的)。

library(twitteR)# set objects
api_key <- "your api key"
api_secret <- "your api secret"
access_token <- "your access token"
access_token_secret <- "your access token secret"# authenticate
setup_twitter_oauth(api_key, api_secret, access_token, access_token_secret)

快速可视化提及#FWT18 的推文频率

我得到一个警告，说我向 Twitter API 请求了最多 1，000 条推文，但它只返回了过去 9 天中的 58 条。

如果能有更长的历史记录就好了，但是 twitter API 只能索引几天的 tweets，不允许历史查询(有一个Python 包可以，但是我还没有试过。

世界上哪里的人在讨论#FWT18？

看起来大多数推文来自欧洲和北美，尽管我们看到一些来自日本、澳大利亚和非洲的推文。

请注意，地理标签推文只对那些在设置中选择了这一点的人可用，这仅占 Twitter 用户的 3%。

关于#FWT18，推特上出现的热门词汇有哪些？

这一次，我通过使用一个查找提及和散列标签的功能，将 @FreerideWTour 和几个骑手的 Twitter 句柄包括在内，然后为 #FWT18 标签中提到的最受欢迎的事物创建一个词云。

看来撞车和周末经常用。

探索 FWT18 排名

因为数据不能作为获得。txt 或 a 。网站上的 csv 文件，他们也没有提供我需要抓取的 API。

值得一提的是，管理员可能出于多种原因想要保护其网站的某些部分，“例如对未经宣布的网站进行索引、遍历需要大量服务器资源的网站部分、递归遍历无限的 URL 空间等。”

因此，应该经常检查他们是否有许可。一种方法是使用 robotstxt 包来检查你的网络机器人是否有权限访问网页的某些部分(感谢malle Salmon的提示)。

library(robotstxt)
paths_allowed("[https://www.freerideworldtour.com/rider/](https://www.freerideworldtour.com/rider/)")[1] TRUE

好的，看起来我们得到许可了。

不幸的是， FWT 2018 排名页面的代码是“花哨”的，这意味着你需要点击下拉箭头来获得每个事件的骑手分数。

我认为数据是用 JavaScript 加载的，这意味着我需要使用一个可以通过编程点击按钮的程序。我听说 splashr 或硒酸盐可以完成这个任务。但是，我是网络搜集的新手，只熟悉 rvest 所以我想出了一个(相对)快速解决办法。

我将 2018 年花名册中的名字放入一个 datase t 中，并将其作为一个对象加载。我可以通过将这些名字输入到 rvest 来自动抓取每个骑手，并使用 for 循环到https://www.freerideworldtour.com/rider/的结尾

# read in the names from 2018 roster
roster <- read_csv("[https://ndownloader.figshare.com/files/11173433](https://ndownloader.figshare.com/files/11173433)")# create a url prefix
url_base <- "[https://www.freerideworldtour.com/rider/](https://www.freerideworldtour.com/rider/)"
riders <- roster$name# Assemble the dataset
output <- data_frame()
for (i in riders) { 
  temp <- read_html(paste0(url_base, i)) %>% 
    html_node("div") %>% 
    html_text() %>% 
    gsub("\\s*\\n+\\s*", ";", .) %>% 
    gsub("pts.", "\n", .) %>% 
    read.table(text = ., fill = T, sep = ";", row.names = NULL, 
               col.names = c("Drop", "Ranking", "FWT", "Events", "Points")) %>%
    subset(select = 2:5) %>% 
    dplyr::filter(
      !is.na(as.numeric(as.character(Ranking))) & 
        as.character(Points) != ""
    ) %>%
    dplyr::mutate(name = i)
  output <- bind_rows(output, temp)
}

我打算看看每个类别(滑雪和单板滑雪)的总排名，按运动员在 2018 年每场 FWT 赛事中获得的分数划分；然而，我注意到有些奇怪的事情正在发生。

# How many riders in the roster?
unique(roster)# A tibble: 56 x 3
   name           sport sex  
   <chr>          <chr> <chr>
 1 aymar-navarro  ski   male 
 2 berkeley-patt~ ski   male 
 3 carl-regner-e~ ski   male 
 4 conor-pelton   ski   male 
 5 craig-murray   ski   male 
 6 drew-tabke     ski   male 
 7 fabio-studer   ski   male 
 8 felix-wiemers  ski   male 
 9 george-rodney  ski   male 
10 grifen-moller  ski   male 
# ... with 46 more rows# How many names in the output object?
unique(output$name)[1] "aymar-navarro"       
 [2] "berkeley-patterson"  
 [3] "carl-regner-eriksson"
 [4] "conor-pelton"        
 [5] "craig-murray"        
 [6] "drew-tabke"          
 [7] "fabio-studer"        
 [8] "felix-wiemers"       
 [9] "george-rodney"       
[10] "grifen-moller"       
[11] "ivan-malakhov"       
[12] "kristofer-turdell"   
[13] "leo-slemett"         
[14] "logan-pehota"        
[15] "loic-collomb-patton" 
[16] "markus-eder"         
[17] "mickael-bimboes"     
[18] "reine-barkered"      
[19] "ryan-faye"           
[20] "sam-lee"             
[21] "stefan-hausl"        
[22] "taisuke-kusunoki"    
[23] "thomas-rich"         
[24] "trace-cooke"         
[25] "yann-rausis"         
[26] "arianna-tricomi"     
[27] "elisabeth-gerritzen" 
[28] "eva-walkner"         
[29] "hazel-birnbaum"      
[30] "jaclyn-paaso"        
[31] "kylie-sivell"        
[32] "lorraine-huber"      
[33] "rachel-croft"        
[34] "blake-hamm"          
[35] "christoffer-granbom" 
[36] "clement-bochatay"    
[37] "davey-baird"

原来第 40 行的名字elias-elhardt产生了一个问题。我不确定这是为什么，但是因为 Elias 只参加了资格赛，所以让我们简单地把他去掉，然后重新运行上面的代码。

# Remove Elias Elhardt
roster <- roster[-40,]
riders <- roster$name

历史上的 FWT 获奖者

FWT 在他们的网站上列出了往届比赛的获胜者。我收集了 1996 年至 2018 年间 23 场巡回赛的所有获胜者的数据，并从网站或快速网络搜索中包括了他们的年龄。数据集可以在 figshare 上找到。

# load the data
df <- read_csv("[https://ndownloader.figshare.com/files/11300864](https://ndownloader.figshare.com/files/11300864)")# Get summary statistics on age of winners
df %>% 
  summarize(mean_age = median(age, na.rm = TRUE),
            max_age = max(age, na.rm = TRUE),
            min_age = min(age, na.rm = TRUE)) mean_age max_age min_age
1       29      43      15# Find minimum age of winner by sex and sport
df %>%
  group_by(sex, sport) %>% 
  slice(which.min(age)) %>% 
  dplyr::select(name, sex, sport, age)# A tibble: 4 x 4
# Groups:   sex, sport [4]
  name            sex    sport       age
  <chr>           <chr>  <chr>     <int>
1 Arianna Tricomi female ski          23
2 Michelle Gmitro female snowboard    16
3 George Rodney   male   ski          21
4 Cyril Neri      male   snowboard    15 

骑手们赢得过多少次 FWT 赛事？

赢得至少一项 FWT 赛事的众多骑手让那些赢得大量赛事的独特运动员相形见绌。

我们可以再看一下表格中的数据。

Xavier De Le Rue 以 8 分接*最高，出现在滑雪和单板滑雪两个类别中？太奇怪了。我们可以这样替换数据集中的错误。

df$sport[df$name == "Xavier De Le Rue"] <- "snowboard"

哪些国家的赢家最多？

看起来美国、法国和奥地利产生了一些最好的免费搭车者。

每个国家的获胜者有多大？

我们可以用箱线图来了解每个国家的年龄分布情况。

然而，一个更好的方法是用雨云图来直观地了解分布情况。因为一些国家只有一个竞争对手，所以让我们把他们去掉。

问一问获胜者的年龄在比赛的历史上是如何变化的也是很有趣的。

FWT 获奖者越来越年轻了吗？

随着时间的推移，年龄和赢得 FWT 赛事似乎没有任何趋势。

这将是很好的发挥周围的数据，法官如何评分每个骑手从 0 到 100 的每一个项目的五个类别，但它看起来不像这样的信息是可用于公众在这个时候。

此分析的完整代码可在 Github 上找到。

Python 中具有中等故事统计的数据科学

原文：https://towardsdatascience.com/analyzing-medium-story-stats-with-python-24c6491a8ff0?source=collection_archive---------15-----------------------

一个用于数据科学的 Python 工具包，具有中等文章统计

Medium 是一个写作的好地方:没有分散注意力的功能，拥有庞大但文明的读者群，最棒的是，没有广告。然而，它不足的一个方面是你可以在你的文章中看到的统计数据。当然，你可以进入统计页面，但是你看到的只是一些普通的数字和一个绿色的条形图。没有任何形式的深度分析，也没有办法理解你的文章产生的数据。

It’s nice when you reach the point where it’s more than your mom reading your articles.

这就好像 Medium 说的:“让我们建立一个伟大的博客*台，但让作者尽可能难以从他们的统计数据中获得洞察力。”虽然我不在乎使用统计数据来最大化浏览量(如果我想获得最多的浏览量，我所有的文章都是 3 分钟的列表)，但作为一名数据科学家，我不能忍受数据未经检查的想法。

我决定对此做些什么，而不是仅仅抱怨媒体统计的糟糕状态，并编写了一个 Python 工具包，允许任何人快速检索、分析、解释和制作他们的媒体统计的漂亮、交互式图表。在本文中，我将展示如何使用这些工具，讨论它们是如何工作的，并且我们将从我的媒体故事统计中探索一些见解。

GitHub 上有完整的工具包供您使用。你可以在 GitHub 这里看到一个使用 Jupyter 的笔记本(不幸的是互动情节在 GitHub 的笔记本浏览器上不起作用)或者在 NBviewer 这里看到完整的互动荣耀。欢迎对这个工具包做出贡献！

Example plot from Python toolkit for analyzing Medium articles

1 分钟后开始

首先，我们需要检索一些统计数据。在编写工具包时，我花了 2 个小时试图找出如何在 Python 中自动登录到 Medium，然后决定采用下面列出的 15 秒解决方案。如果您想使用我的数据，它已经包含在工具包中，否则，请按照以下步骤使用您的数据:

1. 进入你的中型统计页面。
2. 向下滚动到底部，以便显示所有故事的统计数据。
3. 右键单击并将页面保存为工具包data/目录中的stats.html

下面的视频演示了这一点:

Sometimes the best solution is manual!

接下来，在工具箱的medium/目录中打开一个 Jupyter 笔记本或者 Python 终端，运行(同样，你可以使用我包含的数据):

from retrieval import get_datadf = get_data(fname='stats.html')

这不仅会解析stats.html文件并提取所有信息，还会访问每篇文章，检索整篇文章和元数据，并将结果存储在 dataframe 中。我的 121 篇，这个过程大概用了 5 秒钟！现在，我们有了一个数据框架，其中包含关于我们产品的完整信息:

Sample of dataframe with medium article statistics

(为了显示，我已经截掉了数据帧，所以数据比显示的还要多。)一旦我们有了这些信息，我们可以使用任何我们知道的数据科学方法来分析它，或者我们可以使用代码中的工具。Python 工具包中包括制作交互式图表、用机器学习拟合数据、解释关系和生成未来预测的方法。

举个简单的例子，我们可以制作一个数据相关性的热图:

Heatmap of correlations

<tag>列表示文章是否有特定的标签。我们可以看到标签“走向数据科学”与“粉丝”的数量有 0.54 的相关性，这表明将这个标签附加到一个故事上与粉丝的数量(以及鼓掌的数量)正相关。这些关系大多是显而易见的(掌声与粉丝正相关)，但如果你想最大化故事浏览量，你也许能在这里找到一些提示。

我们可以在单行代码中制作的另一个图是由出版物着色的散点图矩阵(也亲切地称为“splom”):

Scatterplot matrix of article stats

(这些图是交互式的，可以在 NBviewer 中的处看到)。

它是如何工作的

在我们回到分析之前(还有更多的图值得期待)，有必要简要讨论一下这些 Python 工具是如何获取和显示所有数据的。代码的主力是 BeautifulSoup 、 requests 和 plotly ，在我看来，它们对于数据科学的重要性不亚于众所周知的 pandas + numpy + matplotlib 三重奏(正如我们将看到的，是时候让 matplotlib 退休了)。

资料检索

从第一眼看中型统计页面，它似乎不是很结构化。

然而，隐藏在互联网每一页下面的是超文本标记语言(HTML) ，一种呈现网页的结构化语言。如果没有 Python，我们可能会被迫打开 excel 并开始键入这些数字(当我在空军时，不是开玩笑，这将是公认的方法)，但是，多亏了BeautifulSoup库，我们可以利用该结构来提取数据。例如，为了在下载的stats.html中找到上表，我们使用:

一旦我们有了一个soup对象，我们就遍历它，在每一点上获得我们需要的数据(HTML 有一个层次树结构，称为文档对象模型 — DOM)。从table中，我们取出一个单独的行——代表一篇文章——并提取一些数据，如下所示:

这可能看起来很乏味，当你不得不用手来做的时候。这涉及到使用谷歌 Chrome 中的开发工具在 HTML 中寻找你想要的信息。幸运的是，Python Medium stats 工具包在幕后为您完成了所有这些工作。你只需要输入两行代码！

从 stats 页面，代码提取每篇文章的元数据，以及文章链接。然后，它使用requests库获取文章本身(不仅仅是统计数据)，并解析文章中的任何相关数据，同样使用BeautifulSoup。所有这些都在工具包中自动完成，但是值得看一看代码。一旦你熟悉了这些 Python 库，你就会开始意识到网络上有多少数据等着你去获取。

顺便说一句，整个代码需要大约 2 分钟的时间来连续运行，但是因为等待是无益的，所以我编写它来使用多处理，并将运行时间减少到大约 10 秒。数据检索的源代码这里是这里是。

绘图和分析

这是一个非常不科学的图表，显示了我对 Python 情节的喜爱程度:

Python plotting enjoyment over time.

plotly 库(带有袖扣包装)让用 Python 绘图再次变得有趣！它支持单行代码的完全交互式图表，制作起来非常容易，我发誓再也不写另一行 matplotlib 了。对比下面两个都是用一行代码绘制的图:

Matplotlib and plotly charts made in one line of code.

左边是matplotlib's努力——一个静态的、枯燥的图表——而右边是plotly's工作——一个漂亮的交互式图表，关键是，它能让你快速理解你的数据。

工具包中的所有绘图都是用 plotly 完成的，这意味着用更少的代码就能得到更好的图表。此外，笔记本中的绘图可以在在线绘图图表编辑器中打开，因此您可以添加自己的修改，如注释和最终编辑以供发布:

Plot from the toolkit touched up in the online editor

分析代码实现一元线性回归、一元多项式回归、多元线性回归和预测。这是通过标准的数据科学工具完成的:numpy、statsmodels、scipy和sklearn。有关完整的可视化和分析代码，请参见该脚本。

分析媒体文章

回到分析！我通常喜欢从单变量分布开始。为此，我们可以使用下面的代码:

from plotly.offline import iplot
from visuals import make_histiplot(make_hist(df, x='views', category='publication'))

显然，我应该继续在“走向数据科学”中发表文章！我的大多数文章没有在任何出版物上发表，这意味着它们只有在你有链接的情况下才能被浏览(为此你需要在 Twitter 上关注我)。

因为所有数据都是基于时间的，所以也有一种方法可以制作累积图，显示您的统计数据随时间的累积情况:

from visuals import make_cum_plotiplot(make_cum_plot(df, y=['word_count', 'views']))

最*，我的字数激增，因为我发布了一堆我已经写了一段时间的文章。当我发表第一篇关于走向数据科学的文章时，我的观点开始流行起来。

(注意，这些视图并不完全正确，因为这是假设一篇给定文章的所有视图都出现在该文章发表的某个时间点。然而，这作为第一*似值是很好的)。

解释变量之间的关系

散点图是一种简单而有效的方法，用于可视化两个变量之间的关系。我们可能想问的一个基本问题是:阅读一篇文章的人的百分比是否随着文章长度的增加而减少？直截了当的答案是肯定的:

from visuals import make_scatter_plotiplot(make_scatter_plot(df, x='read_time', y='ratio'))

随着文章长度——阅读时间——的增加，阅读文章的人数明显减少，然后趋于*稳。

有了散点图，我们可以使任一轴为对数刻度，并通过根据数字或类别调整点的大小或给点着色，在图上包含第三个变量。这也是通过一行代码完成的:

iplot(make_scatter_plot(df, x='read_time', y='views', ylog=True,                                   
                        scale='ratio'))

“Python 中的随机森林”这篇文章在很多方面都是一个异数。它是我所有文章中浏览量最多的，然而却花了 21 分钟才读完！

浏览量会随着文章长度减少吗？

虽然阅读率随着文章长度的增加而降低，但阅读或浏览文章的人数是否也是如此呢？虽然我们的直接答案是肯定的，但仔细分析后，似乎浏览次数不会随着阅读时间的增加而减少。为了确定这一点，我们可以使用工具的拟合功能。

在这个分析中，我将数据限制在我发表在《走向数据科学》杂志上的文章中，这些文章少于 5000 字，并对观点(因变量)和字数(自变量)进行了线性回归。因为视图永远不会是负数，所以截距设置为 0:

from visuals import make_linear_regressionfigure, summary = make_linear_regression(tds_clean, x='word_count', 
                                     y='views', intercept_0=True)
iplot(figure)

与你所想的相反，随着字数的增加(达到 5000)，浏览量也会增加！该拟合的总结显示了正线性关系，并且斜率具有统计学意义:

Summary statistics for linear regression.

有一次，一位非常好的女士在我的一篇文章上留下了一张私人纸条，上面写道:“你的文章写得很好，但是太长了。你应该用要点写更短的文章，而不是完整的句子。”

现在，作为一个经验法则，我假设我的读者是聪明的，能够处理完整的句子。因此，我礼貌地回复这位女士(用要点)说我会继续写非常长的文章。基于这种分析，没有理由缩短文章(即使我的目标是最大化视图)，特别是对于关注数据科学的读者。事实上，我添加的每一个单词都会导致 14 次以上的浏览！

超越一元线性回归

我们不限于以线性方式将一个变量回归到另一个变量上。我们可以使用的另一种方法是多项式回归，在拟合中我们允许自变量的更高次。然而，我们要小心，因为增加的灵活性会导致过度拟合，尤其是在数据有限的情况下。要记住的一点是:当我们有一个灵活的模型时，更接*数据并不意味着对现实的准确描述！

from visuals import make_poly_fitfigure, fit_stats = make_poly_fits(tds_clean, x='word_count',               
                                   y='reads', degree=6)
iplot(figure)

Reads versus the word count with polynomial fits.

使用任何更高程度的拟合来推断这里看到的数据是不可取的，因为预测可能是无意义的(负值或非常大)。

如果我们查看拟合的统计数据，我们可以看到均方根误差随着多项式次数的增加而减小:

较低的误差意味着我们更好地拟合现有数据，但这并不意味着我们将能够准确地推广到新的观察结果(这一点我们稍后会看到)。在数据科学中，我们想要简约模型，即能够解释数据的最简单模型。

我们也可以在线性拟合中包含多个变量。这就是所谓的多元回归，因为有多个独立变量。

list_of_columns = ['read_time', 'edit_days', 'title_word_count',
 '<tag>Education', '<tag>Data Science', '<tag>Towards Data Science',
 '<tag>Machine Learning', '<tag>Python']figure, summary = make_linear_regression(tds, x=list_of_columns,                       
                                    y='fans', intercept_0=False)iplot(figure)

有一些独立变量，如标签 Python 和走向数据科学，有助于增加粉丝，而其他变量，如编辑花费的天数，导致粉丝数量减少(至少根据模型)。如果你想知道如何获得最多的粉丝，你可以使用这个拟合，并尝试用自由参数最大化它。

未来推断

我们工具包中的最后一个工具也是我最喜欢的:对未来的浏览量、粉丝数、阅读量或字数的外推。这可能完全是胡说八道，但这并不意味着它不令人愉快！它还强调了一点，即更灵活的拟合(更高的多项式次数)不会导致新数据更准确的概括。

from visuals import make_extrapolationfigure, future_df = make_extrapolation(df, y='word_count',                   
                                         years=2.5, degree=3)
iplot(figure)

看来为了达到预期的预测，我还有很多工作要做！(底部的滑块允许您放大图表上的不同位置。你可以在全互动笔记本里玩这个)。获得合理的估计需要调整多项式拟合的次数。然而，由于数据有限，任何估计都可能在未来很长时间内失效。

让我们再做一次推断，看看我能期待多少次读取:

figure, future_df = make_extrapolation(tds, y='reads', years=1.5, 
                                       degree=3)
iplot(figure)

我的读者，你也有你的工作要做！我不认为这些推断是那么有用，但它们说明了数据科学中的重要观点:使模型更加灵活并不意味着它能够更好地预测未来，所有模型都是基于现有数据的*似值。

结论

Medium stats Python toolkit 是一套开发工具，允许任何人快速分析他们自己的 Medium 文章统计数据。尽管 Medium 本身不能提供对你的统计数据的深刻见解，但这并不妨碍你用正确的工具进行自己的分析！对我来说，没有什么比从数据中获取意义更令人满意的了——这也是我成为数据科学家的原因——尤其是当这些数据是个人的和/或有用的时候。我不确定这项工作有什么重要的收获——除了继续为数据科学写作——但是使用这些工具可以展示一些重要的数据科学原则。

Overfitting just a little with a 15-degree fit. Remember, all models are approximations based on existing data.

开发这些工具是令人愉快的，我正在努力使它们变得更好。我将感谢任何贡献(老实说，即使这是一个 Jupyter 笔记本中的拼写错误，它会有所帮助)所以检查代码如果你想有所帮助。因为这是我今年的最后一篇文章，我想说感谢您的阅读——不管您贡献了多少统计数据，没有您我不可能完成这个分析！进入新的一年，继续阅读，继续写代码，继续做数据科学，继续让世界变得更好。

一如既往，我欢迎反馈和讨论。可以在推特上找到我。

分析我的谷歌位置历史

原文：https://towardsdatascience.com/analyzing-my-google-location-history-d3a5c56c7b70?source=collection_archive---------10-----------------------

我最*读了这篇关于如何从你的谷歌位置历史数据创建热图的文章。我自己尝试了一下，得到了一些惊人的结果:

红色的大圆圈代表我待过很长时间的城市。不同地方的紫色阴影代表我坐火车旅行时去过或经过的地方。

我以前的手机有一些 GPS 问题，这导致我的位置显示在美国亚利桑那州！。出人意料(还是没有？)它甚至给出了一个证明！

这一切看起来真的很酷，但我真的想深入了解这些年来我的旅行模式。

数据预处理

像大多数数据科学问题一样，数据预处理绝对是难点。数据是 JSON 格式的，不同属性的含义不是很清楚。

数据析取

{'timestampMs': '1541235389345',
  'latitudeE7': 286648226,
  'longitudeE7': 773296344,
  'accuracy': 22,
  'activity': [{'timestampMs': '1541235388609',
    'activity': [{'type': 'ON_FOOT', 'confidence': 52},
     {'type': 'WALKING', 'confidence': 52},
     {'type': 'UNKNOWN', 'confidence': 21},
     {'type': 'STILL', 'confidence': 7},
     {'type': 'RUNNING', 'confidence': 6},
     {'type': 'IN_VEHICLE', 'confidence': 5},
     {'type': 'ON_BICYCLE', 'confidence': 5},
     {'type': 'IN_ROAD_VEHICLE', 'confidence': 5},
     {'type': 'IN_RAIL_VEHICLE', 'confidence': 5},
     {'type': 'IN_TWO_WHEELER_VEHICLE', 'confidence': 3},
     {'type': 'IN_FOUR_WHEELER_VEHICLE', 'confidence': 3}]}]},
 {'timestampMs': '1541235268590',
  'latitudeE7': 286648329,
  'longitudeE7': 773296322,
  'accuracy': 23,
  'activity': [{'timestampMs': '1541235298515',
    'activity': [{'type': 'TILTING', 'confidence': 100}]}]

稍微研究了一下，偶然发现了这篇文章，理清了很多东西。然而，有些问题仍然没有答案

• 活动类型tilting是什么意思？
• 我假设信心是每个任务的概率。然而，它们加起来往往不到 100。如果它们不代表概率，它们代表什么？
• 活动类型walking和on foot有什么区别？
• 谷歌怎么可能预测IN_TWO_WHEELER_VEHICLE和IN_FOUR_WHEELER_VEHICLE之间的活动类型？！

如果有人能够解决这个问题，请在评论中告诉我。

编辑:在这个帖子中已经有一些关于这些话题的讨论。一篇关于使用智能手机数据进行人类活动识别的论文可以在这里找到。

假设

随着我继续构建我的预处理管道，我意识到我将不得不采取一些假设来考虑数据的所有属性。

• GPS 总是开着的(这是一个很强的假设，以后会考虑到)。
• 置信区间是活动类型的概率。这种假设有助于我们考虑给定实例的各种可能的活动类型，而不会低估或高估任何特定的活动类型。
• 每个日志有两种类型的时间戳。(I)对应于位置纬度和经度。㈡与活动相对应。因为两个时间戳之间的差异通常非常小(< 30 秒)，所以我在分析中安全地使用了与纬度和经度相对应的时间戳

数据清理

记得我说过我的全球定位系统给出了美国亚利桑那州的位置吗？我不希望这些数据点对结果产生重大影响。利用印度的纵向边界，我过滤掉了只与印度相关的数据点。

def remove_wrong_data(data):
    degrees_to_radians = np.pi/180.0
    data_new = list()
    for index in range(len(data)):
        longitude = data[index]['longitudeE7']/float(1e7)
        if longitude > 68 and longitude < 93:
            data_new.append(data[index])
    return data_new

特征工程

每个数据点的城市

我想获得每个给定纬度和经度对应的城市。一个简单的谷歌搜索让我得到了我曾居住过的主要城市的坐标，即德里、果阿、特里凡得琅和班加罗尔。

def get_city(latitude):
    latitude = int(latitude)
    if latitude == 15:
        return 'Goa'
    elif latitude in [12,13]:
        return 'Bangalore'
    elif latitude == 8:
        return 'Trivandrum'
    elif latitude > 27.5 and latitude < 29:
        return 'Delhi'
    else:
        return 'Other'data_low['city'] = data.latitude.apply(lambda x:get_city(x))

距离

日志由纬度和经度组成。为了计算测井记录之间的距离，必须将这些值转换成可用于距离相关计算的格式。

from geopy.distance import vincenty
coord_1 = (latitude_1,longitude_1)
corrd_2 = (longitude_2, longitude_2)
distance = vincenty(coord_1,coord_2)

正常距

每个日志由活动组成。每个活动由一个或多个活动类型以及置信度(称为概率)组成。为了考虑测量的置信度，我设计了一个新的度量标准，叫做归一化距离，简单来说就是距离*置信度

数据分析

现在有趣的部分来了！在深入了解之前，让我简单介绍一些数据属性:-

• accuracy:估计数据的准确程度。小于 800 的精度通常被认为是高的。因此，我们删除了精度大于 1000 的列
• day:代表一个月中的某一天
• day_of_week:代表一周中的某一天
• month:代表月份
• year:代表年份
• distance:总行驶距离
• city:数据点对应的城市

离群点检测

总共有 1158736 个数据点。99%的点覆盖不到 1 英里的距离。其余 1%是由于接收/飞行模式不佳而产生的异常。

为了避免 1%的数据导致我们的观察结果发生重大变化，我们将根据归一化距离将数据一分为二。

这也确保了我们删除了不符合我们在分析中所做的假设#1 的点

data_low = data[data.normalized_distance < 1]
data_large = data[data.normalized_distance > 1]

相对于城市的行驶距离

2018 年的数据正确地代表了大部分时间是在班加罗尔和特里凡得琅度过的。

我想知道在德里(我的家乡)旅行的距离怎么会超过我毕业的地方果阿。然后我突然意识到，在我大学生活的大部分时间里，我都没有移动互联网连接。

班加罗尔和特里凡得琅的旅行模式

2018 年 6 月，我完成了在原公司(Trivandrum)的实习，并加入了尼尼微公司(Bangalore)。我想知道在从一个城市过渡到另一个城市时，我的习惯是如何改变的。我对观察我的模式特别感兴趣，原因有二:

• 由于我在这些城市居住期间一直拥有移动互联网，我期望这种表现能够准确地反映现实。
• 我在两个城市呆的时间大致相同，因此数据不会偏向任何一个特定的城市。

Month vs Distance travelled while in Bangalore and Trivandrum

• 10 月份，多位朋友和家人访问班加罗尔，导致车辆行驶距离大幅飙升。
• 最初，我在探索特里凡得琅。然而，随着我的注意力转向获取一个全职的数据科学机会，从 1 月到 2 月到 3 月的路程大幅缩短。

• 班加罗尔的车辆使用率在 20:00–00:00 之间要高得多。我想我以后会离开班加罗尔的办公室。
• 我在特里凡得琅走得更多！从 10:00 到 20:00 的步行距离差异表明，我是如何在办公室每隔一两个小时散步一次，从而过上更健康的生活的。

结论

有更多(像这个和这个)与您的位置历史有关。您也可以探索您的推特/脸书/铬数据。尝试浏览数据集时的一些便捷技巧:

• 花大量时间预处理您的数据。这很痛苦，但值得。
• 当处理大量数据时，预处理的计算量很大。不要每次都重新运行 Jupyter Cells，而是将预处理后的数据转储到一个 pickle 文件中，并在您再次启动时简单地导入数据。
• 最初，你可能很惨(像我一样)找不到任何模式。列出您的观察结果，并继续从不同角度探索数据集。如果您曾经想知道是否存在任何模式，请问自己三个问题: (i)我是否对数据的各种属性有透彻的理解？(ii)我能做些什么来改进我的预处理步骤吗？(iii)我是否使用了所有可能的可视化/统计工具探索了所有属性之间的关系？

开始时，您可以在这里使用我的 Jupyter 笔记本。

如果你有任何问题/建议，请随意发表评论。

你可以在 LinkedIn 上联系我，或者发邮件到 k.mathur68@gmail.com 找我。

使用 R 分析股票

原文：https://towardsdatascience.com/analyzing-stocks-using-r-550be7f5f20d?source=collection_archive---------4-----------------------

对亚马逊(Amazon)股票的一般和技术分析，以及使用随机漫步和蒙特卡罗方法的价格模拟。用 plotly 和 ggplot 完成的可视化。

亚马逊(Amazon)的股票在过去一年上涨了 95.6%(918.93 美元)，这使得亚马逊成为许多投资者的理想选择。许多分析师还认为，亚马逊(Amazon)的价值将在未来几年继续增长。虽然购买股票听起来很诱人，但应该进行详细的深入分析，以避免基于投机购买股票。

我落实了我在统计学和 R 技能方面的知识，从技术面分析它的表现，预测它未来的价格。我非常依赖量化金融中常用的软件包，如 quant mod 和 xts 来实现我的目标。

以下是我使用的软件包的完整列表:

library(quantmod)
library(xts)
library(rvest)
library(tidyverse)
library(stringr)
library(forcats)
library(lubridate)
library(plotly)
library(dplyr)
library(PerformanceAnalytics)

我从获得亚马逊股票从 2008 年 8 月 1 日到 2018 年 8 月 17 日的日志回报开始分析:

getSymbols("AMZN",from="2008-08-01",to="2018-08-17")AMZN_log_returns<-AMZN%>%Ad()%>%dailyReturn(type='log')

日志返回在这个阶段没有意义，但它实际上是我分析的基础。我稍后会解释。

技术分析

我首先对亚马逊的股票进行了技术分析:

AMZN%>%Ad()%>%chartSeries()AMZN%>%chartSeries(TA='addBBands();addVo();addMACD()',subset='2018')

第一个图表系列图很简单，因为它显示了亚马逊的价格图表:

Price Chart

第二个图表系列显示了仅在 2018 年的布林线图、布林线百分比变化、成交量和移动*均线收敛趋势:

Technical Analysis

均线对于理解亚马逊(Amazon)的技术图表非常重要。它通过*均股票价格来*滑每日价格波动，并有效地识别潜在趋势。

布林线图表绘制了两个远离移动*均线的标准偏差，用于衡量股票的波动性。成交量图显示了其股票每天的交易情况。均线收敛背离给技术分析师买入/卖出信号。经验法则是:如果跌破该线，就该卖出了。如果它上升到线以上，它正在经历一个上升的势头。

上面的图表通常用来决定是否买/卖股票。由于我不是一个认证的金融分析师，我决定做额外的研究来说服自己。

比较

我实现了公开比较的基本原则。我想看看亚马逊(Amazon)与其他热门科技股如脸书(Alibaba)、谷歌(Google)和苹果(Apple)相比表现如何。

我首先比较了每只股票的风险/回报率。我取了对数回报的*均值和对数回报的标准差。均值被认为是一致的回报率，而标准差是购买股票带来的风险。我用 plotly，一个交互式可视化工具，来说明我的发现。

Risk vs Reward chart

谷歌(GOOGL)股票风险最低，回报也最低。脸书(Alibaba)和亚马逊(Amazon)的风险一样大，但后者的回报更高。如果你喜欢冒险，特斯拉(TSLA)是一个很好的投资，因为它有高风险和高回报。但如果你像我一样厌恶风险，苹果(AAPL)是最好的选择。

一个流行的投资原则是分散投资:不要把所有的鸡蛋放在一个篮子里。购买股票时，你应该尽量购买相关性小的股票，因为你想最大化总回报率。

library(PerformanceAnalytics)data<-cbind(diff(log(Cl(AMZN))),diff(log(Cl(GOOGL))),diff(log(Cl(AAPL))),diff(log(Cl(FB))))chart.Correlation(data)

Correlation Chart

脸书(FB)和苹果(AAPL)的相关性最小，为 0.24，而亚马逊(Amazon)和谷歌(Google)的相关性最高，为 0.56。每只股票之间的相关性很高，因为它们都是科技股。最好购买不同行业的股票，以真正实现风险最小化和回报率最大化。

价格预测

我接着预测了亚马逊(Amazon)股票的价格。我通过随机漫步理论和蒙特卡罗方法实现了这一点。

随机游走理论适合于股票的价格预测，因为它植根于这样一种信念，即过去的表现不是未来结果的指标，价格波动无法准确预测。

我模拟了亚马逊(Amazon)股票 252*4 个交易日的价格(因为一年有大约 252 个交易日)。这是 4 年的交易价值！

我使用我之前从对数收益中获得的数据生成价格，并使用指数增长率来预测股票每天将增长多少。增长率是随机生成的，取决于 mu 和 sigma 的输入值。

mu<-AMZN_mean_log # mean of log returns
sig<-AMZN_sd_log # sd of log returns price<-rep(NA,252*4)#start simulating pricesfor(i in 2:length(testsim)){
  price[i]<-price[i-1]*exp(rnorm(1,mu,sig))
}random_data<-cbind(price,1:(252*4))
colnames(random_data)<-c("Price","Day")
random_data<-as.data.frame(random_data)random_data%>%ggplot(aes(Day,Price))+geom_line()+labs(title="Amazon (AMZN) price simulation for 4 years")+theme_bw()

Price Preidction with Random Walk

上图显示了大约 1000 个交易日的模拟价格。如果你注意我的代码，我没有包含 set.seed()。模拟价格将会改变，并取决于我的种子。为了得出稳定的预测，价格模拟需要使用蒙特卡罗方法，在这种方法中，价格被重复模拟以确保准确性。

N<-500
mc_matrix<-matrix(nrow=252*4,ncol=N)
mc_matrix[1,1]<-as.numeric(AMZN$AMZN.Adjusted[length(AMZN$AMZN.Adjusted),])for(j in 1:ncol(mc_matrix)){
  mc_matrix[1,j]<-as.numeric(AMZN$AMZN.Adjusted[length(AMZN$AMZN.Adjusted),])
for(i in 2:nrow(mc_matrix)){
  mc_matrix[i,j]<-mc_matrix[i-1,j]*exp(rnorm(1,mu,sig))
}
}name<-str_c("Sim ",seq(1,500))
name<-c("Day",name)final_mat<-cbind(1:(252*4),mc_matrix)
final_mat<-as.tibble(final_mat)
colnames(final_mat)<-namedim(final_mat) #1008 501final_mat%>%gather("Simulation","Price",2:501)%>%ggplot(aes(x=Day,y=Price,Group=Simulation))+geom_line(alpha=0.2)+labs(title="Amazon Stock (AMZN): 500 Monte Carlo Simulations for 4 Years")+theme_bw()

Price Prediction with Monte Carlo

上面的图表并不直观，所以我在四年后用亚马逊(Amazon)的价格百分比最终确定了我的发现。

final_mat[500,-1]%>%as.numeric()%>%quantile(probs=probs)

不要相信我的话，但从我的模拟结果来看，亚马逊(Amazon)的股票可能会在四年内达到 11198.10 美元的价格，或者跌至 834.60 美元的低点。你可以将我的发现与亚马逊(Amazon)的 CAGR 进行比较，看看我的发现是否有意义。但是如果有机会，我会马上买下这只股票！

感谢阅读！如果你有任何反馈/想聊天，请告诉我。你可以打电话给我

推特:@joygraceeya

电子邮件:joygh174@gmail.com

你可以在这里看我的完整代码和参考文献。

解析伦敦 2018 艺术博览会，第一部分

原文：https://towardsdatascience.com/analyzing-the-frieze-london-2018-art-fair-part-1-f1563d066a6f?source=collection_archive---------19-----------------------

第一部分:5.6k Instagram 和 3.2k Twitter 帖子的探索性数据分析

Frieze Masters Art Fair on the left and Nan Golding on the right

Frieze 是一家国际艺术商业特许经营公司，1991 年以杂志起家，但后来发展成为一家组织一些年度日历上最重要的艺术博览会和活动的机构。

自 2003 年以来，每年 10 月，Frieze 都会在伦敦摄政公园的中央组织一次大型当代艺术展，吸引成千上万的人。来自 20 多个国家的 150 多家画廊通常会参加盈利性艺术博览会。

然而，Frieze 现在已经不仅仅是一个艺术博览会。
“楣周”已经成为一个文化娱乐周，人们纯粹是为了观赏而参加，这里有一个雕塑公园，甚至主要的拍卖行也举办他们的中期当代拍卖会，以配合楣周。

Imaged taken from bulanlifestyleblog

本文的目的是通过分析 5.6k Instagram 和 3.2k Twitter 帖子，展示一些关于艺术博览会的社交媒体数据的探索性数据分析，从而更好地了解 Frieze London 2018。请向下滚动，通过交互式数据可视化查看我的分析！

数据和方法

在节日期间，我使用 Twitter API 收集了 3200 条推文，使用 Instagram API 收集了 5600 条包含标签 #frieze 的 Instagram 帖子。值得注意的是，我只收集了包含标签 #frieze 的帖子；当然，有许多关于 Frieze London 2018 的推文不包含这个标签。

在我收集了数据之后，我在一个 python 笔记本中对这些推文进行了预处理和分析。你可以在这里查看我的 Kaggle 内核对这篇文章的分析。

【本文不解释如何获取数据；这是我的发现的介绍。关于如何使用 API 从 Twitter 获取数据的更多信息，请阅读这篇文章作者 Michael Galarnyk

Photo I took at Frieze London 2018

分析推文和 Instagram 帖子

我分析的主要内容来自我通过 Twitter 和 Instagram APIs 收集的 9000 条帖子。下面，我报告对以下三个指标的一些初步分析:

1. 每天的帖子数量；
2. 每小时的帖子数量(四天的*均值)；
3. Tweeters 和 Instagrammers 前 10 名(按发帖频率)。

每天的帖子数量

下面的条形图显示，2018 年伦敦 Frieze 最受欢迎的一天是第一天，即 10 月 4 日星期四，使用 #frieze 在两个*台上发布了 1786 条帖子。然后从周四到周一逐渐下降。

Figure 1: Bar chart showing the number of posts by day during Frieze London 2018

然而，如果我们将这些数字按*台分开，我们会发现 Instagram 主导了大部分在线活动，*均占 #frieze 一周内所有每日帖子的 72%。事实上，随着“Frieze Week”的发展，更多的在线用户开始在 Instagram 上用#frieze 发帖，而不是在 Twitter 上。

这完全有意义，因为 Instagram 是一个非常视觉化的内容*台，使其完全符合 Frieze art fair，人们通常在那里发布艺术品的图像。在第 3 部分中，我将更详细地看看这些图片。

Figure 2: Bar chart showing the % of posts by platform per day

按小时计算的帖子数量

早在早上 6 点(格林威治时间)就有活动，而且活动迅速加快。上午 11 时和下午 3 时最繁忙，分别有 541 个和 542 个职位；然而，在上午 9 点到下午 5 点之间有非常高且稳定的活动。

Figure 3: Bar chart showing the average tweets per hour

同样，如果我们按*台划分每小时的帖子，我们可以清楚地看到 Instagram 的优势，*均占所有每小时帖子的 71%。

Figure 4: Bar chart showing the % of posts by platform per hour

前 10 名 Instagrammers 和 Tweeters

下面的条形图显示了按帖子数量排名的前 10 名 Instagrammers 和 Tweeters，分别是左图和右图。

在 Instagram 上， gusgracey 使用 #frieze 总共发布了 56 条帖子，而 aservais1 在 Twitter 上发布了 59 条帖子。只有一个用户(使用相同的手柄)在两个*台上都进入了前 10 名: cordy_86 。

Figure 5: Top 10 Instagrammers and Tweeters by the frequency of posts

结论

所以你有它！我在 11000 条关于伦敦设计节 2018 的推文中展示了一些 EDA。如果你有任何想法或建议，请在下面留下你的评论，或者在我的 Kaggle 内核上留下你的评论——如果能在 Kaggle 上投上一票，我将不胜感激:)。

Photo I took at Frieze London 2018

下次…

在我的下一篇文章(第 2 部分)中，我将展示我的自然语言处理(NLP)分析的发现。期待看到推文的文本分析和情感分析。敬请关注。

感谢阅读！

Vishal

在你离开之前…

如果你觉得这篇文章有帮助或有趣，请按住👏请在推特、脸书或 LinkedIn 上分享这篇文章，这样每个人都能从中受益。

Vishal 是一名文化数据科学家，也是伦敦 UCL 学院*的研究生。他对城市文化的经济和社会影响感兴趣。你可以在Twitter或者LinkedIn上与他取得联系。在insta gram或他的* 网站 上看到更多 Vishal 的作品。

解析 2018 伦敦设计节(上)

原文：https://towardsdatascience.com/analyzing-the-london-design-festival-2018-part-1-7edac3bfb165?source=collection_archive---------16-----------------------

第 1 部分:对 11，000 条推文的探索性数据分析

“世界设计之都”是伦敦设计节的组织者自豪地宣传伦敦的方式。鉴于上个月在 9 月 15 日(周六)至 9 月 23 日(周日)为期七天的设计节期间，估计有超过 50 万人参观了这座城市，这种说法可能是正确的。

伦敦设计节 2018 (LDF18)有一个非常活跃的活动计划，横跨伦敦 11 个不同的“设计区”、5 个“设计目的地”和 3 条“设计路线”。这是伦敦作为一个建筑环境的灵活性的另一个极好的例子，作为一个画布来展示创造性的想法。

Image of Es Devlin’s Please Feed the Lions, taken by David Holt and downloaded from Flick

本文的目的是通过分析 11，000 条推文，展示一些关于音乐节的社交媒体数据的探索性数据分析，从而更好地理解 LDF18。请向下滚动，通过交互式数据可视化查看我的分析！

数据和方法

组织者推广的官方标签是# ldf 18——在电影节期间，我使用 Twitter API 收集了 11000 条包含该标签的推文。值得注意的是，我只收集了包含标签# LDF18 的推文。当然，有许多关于 2018 年伦敦设计节的推文不包含该标签。

在我收集了数据之后，我在一个 python 笔记本中对这些推文进行了预处理和分析。你可以在这里查看我的 Kaggle 内核对这篇文章的分析。

【本文不解释如何获取数据；这是我的发现的介绍。关于如何使用 API 从 Twitter 获取数据的更多信息，请阅读这篇文章作者 Michael Galarnyk

Picture of Waugh Thistleton Architects: MultiPly taken by the US Embassy in the UK and downloaded from Flickr

分析推文

我分析的主要内容来自我通过 Twitter API 收集的 11000 条推文。下面，我报告对以下四个指标的一些初步分析:

1. 每天的推文数量；
2. 每小时的推文数量(一周的*均值)；
3. 前 10 名 tweeters(按关注人数)；
4. 前 10 名推文(按推文频率)。

每天的推文数量

下面的条形图显示，在 LDF18 上最受欢迎的一天是 9 月 20 日星期四，有 1491 条使用#LDF18 的推文。令人惊讶的是，节日前后的周末都不是最忙的；也许周四有一个特别的活动——我会在第二部分的推文中看得更深入一些——或者，也许这最终证实了周四是伦敦的新周五。

Figure 1: Bar chart showing the number of tweets by day during the festival

每小时的推文数量

伦敦人早早起床去看 LDF18 的比赛！上午和下午是最忙的时候，从上午 10 点到下午 1 点活动量几乎是一致的，然后到下午 3 点活动量有所下降。

Figure 2: Bar chart showing the average tweets per hour

前 10 名推特用户

* 5000 名不同的 Twitter 用户使用#LDF18 发布了关于这个节日的推文。如果我们按照关注者数量来看前 10 名推特用户，只有三个用户占据主导地位——T2、金融时报、设计博物馆和伦敦 NMH，如下表所示。但是，这不是一个有用的衡量标准，所以，我们来看看前 10 名用户使用#LDF18 发微博的次数。

Table 1: Top 10 tweets by the number of followers

按推文频率排名的前 10 名推文者

下面的条形图显示了前 10 名推特用户发出的推文数量，包括转发和不转发，分别为左图和右图。

官方推特账号@L_D_F 使用#LDF18 发了* 295 条推文，其中 70 条被转发。而且，虽然“@designledreview”发出了 193 条推文，但几乎都是 RTs。有趣的是，维多利亚阿尔伯特博物馆的高级设计策展人奥利维亚·霍斯福尔·特纳( @ 霍斯福尔·特纳)疯狂地用#LDF18 发了 83 条推特！

Figure 3: Top 10 tweeters by the frequency of tweets

A tweet from the official @L_D_F twitter account

结论

所以你有它！我在 11000 条关于伦敦设计节 2018 的推文中展示了一些 EDA。如果你有任何想法或建议，请在下面留下你的评论，或者，在我的 Kaggle 内核上——对 Kaggle 投赞成票将不胜感激:)。

下次…

在我的下一篇文章(第 2 部分)中，我将展示我的自然语言处理(NLP)分析的发现。期待看到推文的文本分析和情感分析。敬请关注。

感谢阅读！

Vishal

在你离开之前…

如果你觉得这篇文章有帮助或有趣，请按住👏请在推特、脸书或 LinkedIn 上分享这篇文章，这样每个人都能从中受益。

Vishal 是一名文化数据科学家，也是伦敦 UCL 学院*的研究生。他对城市文化的经济和社会影响感兴趣。你可以在Twitter或者LinkedIn上与他取得联系。在insta gram或他的* 网站 上看到更多 Vishal 的作品。

琉米爱尔伦敦 2018:探索性数据分析(第一部分)

原文：https://towardsdatascience.com/analyzing-the-lumiere-london-2018-light-festival-part-1-eb0284d317c7?source=collection_archive---------21-----------------------

第 1 部分:对 11，000 条推文的探索性数据分析

介绍

琉米爱尔伦敦 2018 是今年早些时候在伦敦举行的大型灯光节。从 1 月 18 日(星期四)到 1 月 21 日(星期日)的四天时间里，53 位艺术家的 50 多件公共艺术品在伦敦的六个区展出，超过 100 万人参加了此次艺术节！

琉米爱尔 2018 是协调和交付的史诗般的例子，向伦敦市民公开展示艺术和文化。它是免费参加的，受伦敦市长的委托，由艺术慈善机构朝鲜蓟信托策划、制作和策划。节日期间，威斯敏斯特教堂、伦敦眼等建筑都会被点亮。

你可以在这里阅读更多关于琉米爱尔及其创始伙伴的信息。

Westminster Abbey in London illuminated by Patrice Warrener with his work The Light of the Spirit.

本文的目的是通过分析 11，000 条推文，展示一些关于 2018 年琉米爱尔伦敦奥运会社交媒体数据的探索性数据分析。请向下滚动，通过交互式数据可视化查看我的分析！

数据和方法

组织者推广的官方标签是#LumiereLDN。在节日期间，我使用 Twitter API 收集了 11000 条包含这个标签的推文。需要注意的是，我只收集了包含# LumiereLDN 的推文。当然，有许多关于琉米爱尔伦敦 2018 的推文没有包含这个标签。

在我收集了数据之后，我在一个 python 笔记本中对这些推文进行了预处理和分析。你可以点击查看我的 Kaggle 内核，了解这篇文章的分析。

【本文不解释如何获取数据；这是我的发现的介绍。有关如何使用 API 从 Twitter 获取数据的更多信息，您可以阅读迈克尔·加拉内克的文章

装置的位置

总共有 54 个公共艺术装置，分布在伦敦市中心的六个不同区域——国王十字车站、菲茨罗维亚、梅菲尔、西区、维多利亚和威斯敏斯特以及南岸和滑铁卢。下图显示了这些装置是如何分布在各个地区的:

This map was taken from the official Lumiere London leaflet.

下面的饼状图按位置显示了公共艺术装置的频率——它是交互式的，就像所有其他图表一样，所以请悬停并点击它！

伦敦西区是人口最多的地区，有 15 个公共艺术装置——这是有道理的，因为伦敦西区历史上是一个旅游区——有趣的是，国王十字车站以 11 个装置位居第二。

Figure 1: Pie chart showing the number of public art installations by location

仔细查看官方合作伙伴页面将西区和国王十字商圈列为“主要合作伙伴”。

Waterlicht by Daan Roosegaarde at King’s Cross - taken by Ian Woodhead and downloaded from Flickr

分析推文

我分析的主要内容来自我通过 Twitter API 收集的 11000 条推文。下面，我报告对以下三个指标的一些初步分析:

1. 每天的推文数量；
2. 每小时的推文数量(四天的*均值)；
3. 前 10 名推特用户(按关注人数)。

每天的推文数量

下面的条形图显示，2018 年伦敦琉米爱尔最受欢迎的一天是 1 月 19 日星期五，有2449 条推文包含标签#LumiereLDN。令人惊讶的是，周四 18+周五 19比周末，周六 20+周日 21更受欢迎。

Figure 2: Bar chart showing the number of tweets by day during the festival

每小时的推文数量

一天中最繁忙的时间(整个节日的所有日子)是在晚上 6 点到 10 点之间——晚上 9 点是最繁忙的时间，总共有 769 条推文。据推测，人们在晚上下班和放学后参观这个节日。该事件也是针对夜间事件的

Figure 3: Bar chart showing the average tweets per hour

前 10 名推特用户

在节日期间，超过 6000 名不同的人使用#LumiereLDN 发推文，但一些有趣的人物突然出现。下表显示了根据粉丝数量排名的前 10 名推特用户。

像 BBC 新闻实验室、商业内幕、推特视频和超时这样的媒体果然出现在名单中，但是像迈克·彭博、戈登·拉姆齐和戴维娜·迈克考这样的名人也在推特上发了关于这个事件的消息！

Table 1: Top 10 tweets by the number of followers

The Wave by Vertigo at Southbank in London

结论

所以你有它！我在 11，000 条关于琉米爱尔伦敦 2018 灯光节的推文中展示了一些 EDA。如果你有任何想法或建议，请在下面留下你的评论，或者在我的 Kaggle 内核上留下你的评论——如果能给 Kaggle 投上一票，我将不胜感激:)。

下次…

在我的下一篇文章(第 2 部分)中，我将展示我的自然语言处理(NLP)分析的发现。期待看到推文的文本分析和情感分析。敬请关注。

感谢阅读！

Vishal

在你离开之前…

如果你觉得这篇文章有帮助或有趣，请按住👏请在推特、脸书或 LinkedIn 上分享这篇文章，这样每个人都能从中受益。

Vishal 是一名文化数据科学家，也是伦敦 UCL 学院*的研究生。他对城市文化的经济和社会影响感兴趣。你可以在Twitter或者LinkedIn上与他取得联系。在insta gram或他的* 网站 上看到更多 Vishal 的作品。

解析琉米爱尔伦敦 2018 灯光节(下)

原文：https://towardsdatascience.com/analyzing-the-lumiere-london-2018-light-festival-part-2-98eb3769e267?source=collection_archive---------28-----------------------

第二部分:11，000 条推文的自然语言处理

介绍

在本系列的第 1 部分中，我展示了一份关于琉米爱尔伦敦 2018 的 11，000 条推文的探索性数据分析，这是今年 1 月早些时候在伦敦举行的一个大型灯光节。

从 1 月 18 日(星期四)到 1 月 21 日(星期日)的四天时间里，53 位艺术家的 50 多件公共艺术品在伦敦的六个区展出，超过 100 万人参加了此次艺术节！

本文的目的是展示我的自然语言处理分析对这 11，000 条推文的研究结果，以了解人们对 2018 年琉米爱尔伦敦奥运会的看法。

请向下滚动，通过交互式数据可视化查看我的分析！

Control No Control by Daniel Iregul at Whitfield Gardens in Fitzrovia — my photo

数据和方法

这一事件的官方标签是#LumiereLDN。在通过 Twitter API 在事件发生时收集了 11000 条包含这个标签的推文之后，我首先在 Python 笔记本中预处理和清理了文本数据。

然后，我使用谷歌的 langdetect 库 过滤掉非英语推文，并从 NLP 分析中删除所有转发，这样就不会出现重复。经过这些步骤，我剩下了 4600 条独特的推文。接下来，我使用谷歌云自然语言 API 来获取每条推文的情感。

最后，我使用 gensim 库的 Word2Vec 模型来获取整个 tweets 语料库中与单词“LumiereLDN”相关的每个单词的单词嵌入向量。Word2Vec 用于从大型文本语料库中计算单词之间的相似度— Kavita Ganesan 的文章是一个很好的解释。

一旦我有了每个单词的向量，我就使用 scikitlearn 库来执行主成分分析(PCA)以进行降维，并绘制出与“LumiereLDN”最相似的单词(最*邻)。

你可以在这里查看我的 Kaggle 内核对这篇文章的所有分析。

分析

在这一节中，我将展示我的自然语言处理(NLP)分析的发现。下面，我报告以下三个指标:

1. 每日推文的情感分析；
2. 词频和标签频率分析；
3. Word2Vec 模型的输出:主成分分析(PCA)和最*邻分析。

A lady looking very happy at Lumiere London! Illumaphonium by Michael David, at Mount Street in Mayfair

情感分析

每条推文的情绪是使用谷歌的云 NLP API 计算的。下面的条形图显示了每天推文的*均情绪，其中-1 表示非常消极的情绪，+1 表示非常积极的情绪。

我们看到，琉米爱尔伦敦 2018 年奥运会开始时情绪相对较高，然后在 1 月 17 日星期三下降，直到再次达到良好的情绪；我将不得不检查推文进一步了解下降。总体而言，琉米爱尔全天的*均情绪为 0.47。

Figure 1: Line chart showing the average sentiment of the tweets per day

下表显示了按情感分类的前五条(绿色)和后五条(红色)推文。你可以通过左边的推文清楚地看到，积极的语言被云 NLP API 检测到，类似地，负面的推文在右边。

一些人表示灯光“不太优雅”，而另一些人则认为它们是“灯光和声音的有力庆祝”，并将其描述为“辉煌”和“令人印象深刻”。云 NLP API 做的很好！

Table 1: Tabel showing the top five (left) and bottom five (right) tweets by sentiment score

文本频率分析

下面的条形图显示了一个词出现的次数，还有一个标签出现在所有推文中，分别在左边和右边。不出所料，“卢米埃尔登”出现的次数最多。

然而，这些结果在告诉我们人们对事件的真实想法方面并不十分有用，因为标签的频率显然是单词频率的一个混淆变量。在未来的分析中，我将尝试从文本频率分析中删除 hashtag word。

Figure 2: Bar graphs showing the count of words and hashtags appearing in all the tweets

最*的邻居

Word2Vec 是一个神经语言机器学习模型。它将大量文本(在本例中，来自 11，000 条推文的文本)作为输入，并产生一个向量空间，通常有数百个维度，每个唯一的单词对应于空间中的一个向量——单词嵌入。

重要的是，它用于计算和捕捉 11，000 条推文中单词之间的相似性和关系。具体来说，空间中距离较*的物体意味着它们是相似的——被称为最*邻。我的目标是找到所有与“ LumiereLDN ”紧密相关的单词。

主成分分析用于将 Word2Vec 空间的维度降低到 x 和 y 坐标，其输出显示在下面的散点图中。似乎有一些聚类，但是，很乱，很难找到与“ LumiereLDN ”紧密相关的词。

Figure 3: PCA output of the words embedding vector space from the Word2Vec model

我们需要进一步放大。

最*邻是来自 Word2Vec 模型的少数几个基于余弦度量相似性得分与“ LumiereLDN ”最相似的单词。下面的散点图显示了“ LumiereLDN ”的最*邻居。

拉*镜头，我们发现伦敦的区域——“维多利亚”、“梅菲尔”、“菲茨罗维亚”、国王十字”——这些艺术品被安装的地方，似乎就在附*。

但重要的是，“神奇的”、“奇妙的”和“好玩的”这些词也*在咫尺。一个非常积极的结果！统计表明，这些词最能代表人们在推特上谈论琉米爱尔伦敦 2018 时的感受。

Figure 4: PCA output of the nearest neighbours of #LumiereLDN from the Word2Vec model

Love Motion by Rhys Coren at The Royal Academy in the West End— my photo

结论

所以你有它！我已经在 11000 条关于琉米爱尔伦敦 2018 灯光节的推文中展示了我的 NLP 的发现。尽管有一些关于琉米爱尔伦敦的负面推文和情绪，但 Word2Vec 模型的输出显示人们对该活动持积极态度。

如果你有任何想法或建议，请在下面或在我的 Kaggle 内核上留下评论——非常感谢你对 Kaggle 的支持:)

有这么多 NLP 库，很可能以后我会用 GloVe 、 Tensorflow 或者 Bert 重新审视这个分析。

下次…

在我的下一篇文章(第 3 部分)中，我将展示我的计算机视觉分析的发现。期待看到哪些艺术品出现的次数最多。敬请关注。

感谢阅读！

Vishal

Vishal 是一名文化数据科学家，也是伦敦 UCL 学院的研究生。他对城市文化的经济和社会影响感兴趣。

一目分析的效用分析

原文：https://towardsdatascience.com/analyzing-the-utility-of-ichimoku-analysis-9af678e7c7f9?source=collection_archive---------0-----------------------

Ichimoku trading 是一种理解和开发感兴趣股票的买卖信号的有趣方式，也是我试图在自己的股票分析中融入的一种方式。在这篇文章中，我想解释我是如何发现这些分析的，以及我是如何将这些信号整合到我自己的预测分析中的。

那么市目是什么呢？“Ichimoku Kinko Hyo”是对股票动力、阻力和支撑的分析，根据最*的表现产生交易信号。有五条绘制的线构成了分析的基础:

Tenkan-sen(转换线):9 日最高价和最低价的*均值

Kijun-sen(基线):26 天最高价和最低价的*均值

森口跨度 A(领先跨度 A): 换算与基线的*均值

森口跨度 B(领先跨度 B):52 天高低点*均值

迟口跨度(滞后跨度):26 天前的收盘价

这两个寇森跨越了所谓的“库莫云”的界限，即价格高于、低于或低于我。下面是标准普尔 500 的 Ichimoku 分析图像(来自 ichimokutrader.com)。

绿色和红色的区域代表 Kumo，而线条代表前面提到的每个跨度和线条。线交叉产生的信号有几种类型。其中包括:

天坎/基君十字:

Tenkan 从 Kijun 下方到上方时的看涨信号(Kumo 云下方时弱，内侧时中性，上方时强)。

Tenkan 从 Kijun 上方到 belw 时的看跌信号(Kumo 云上方时弱，内部时中性，下方时强)。

价格交叉 Kijun 森:

当价格从下方上涨到上方时，是看涨信号(当价格低于 Kumo 时是弱势，当价格在内部时是中性，当价格在上方时是强势)。

当价格从上方下跌到下方时，熊市信号(当价格在 Kumo 上方时是弱势，当价格在内部时是中性，当价格在下方时是强势)。

库莫突围:

当价格脱离库莫云顶部时，是看涨信号。

当价格脱离库莫云底部时，是看跌信号。

寇森跨越:

森口跨度 A 从下方移动到森口跨度 B 上方时的看涨信号(库莫下方时弱，内侧时中性，上方时强)。

当森口跨度 A 从上方移动到森口跨度 B 下方时的看跌信号(Kumo 上方时弱，内侧时中性，下方时强)。

池口跨度穿越价格:

当 Chikou Span 从价格下方移动到价格上方时的看涨信号(当低于 Kumo 时为弱，当在内部时为中性，当在上方时为强)。

当 Chikou Span 从价格上方移动到价格下方时，是看跌信号(Kumo 上方是弱信号，Kumo 内部是中性信号，Kumo 下方是强信号)。

整合这种分析的下一步是对信号进行编码。有两种选择:

1. 使用图像处理来识别出现的信号。
2. 手动对线进行编码，并通过识别线何时从大于彼此变为小于彼此来找到交叉点。

因为对图像识别不太熟悉，所以选择了后者。这导致我使用 if-then 语句寻找交叉点的许多繁琐而全面的代码序列，但这最终是可行的。我给信号赋值，范围从-3(强烈看跌信号)到 0(没有信号)到 3(强烈看涨信号)。每一个都将成为我的算法中的数据点(在介绍文章中描述)，最终提高准确性。下表说明了这些影响:

Accuracy Analysis of KNN Algorithm Predicting S&P 500 Stock Price Direction

这里我们可以看到 Ichimoku 信号提高了整体算法的精度。5 天和 10 天的预测准确率提高了不到 11%，而 15 天、30 天和 60 天的预测准确率提高了约 9%。随着我们进入 90 天的时间框架，这些准确性的增加似乎会减少，甚至可能超过 90 天，这可能说明信号在短期内的效用。

总的来说，我想确定信号在创建更准确的预测算法中的效用，我觉得我在这方面是成功的。虽然我不能说信号的有效性是做交易决定的唯一因素，但很明显，在预测分析中包含信号会使分析更有效。

注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

分析熊猫的时间序列数据

原文：https://towardsdatascience.com/analyzing-time-series-data-in-pandas-be3887fdd621?source=collection_archive---------3-----------------------

在我之前的教程中，我们考虑过数据准备和可视化工具，如 Numpy 、 Pandas 、Matplotlib 和 Seaborn。在本教程中，我们将学习时间序列，为什么它很重要，我们需要应用时间序列的情况，更具体地说，我们将学习如何使用 Pandas 分析时间序列数据。

什么是时间序列

时间序列是在特定时间通常以相等的间隔(例如每小时、每天、每周、每季度、每年等)获取的一组数据点或观察值。时间序列通常用于根据以前观察到的事件或值来预测未来的事件。预测明天股票市场将会发生什么，在接下来的一周将会售出的货物量，一个项目的价格是否会在 12 月暴涨，一段时间内优步乘坐的次数等；是我们可以用时间序列分析做的一些事情。

为什么我们需要时间序列

时间序列有助于我们理解过去的趋势，因此我们可以预测和规划未来。例如，你拥有一家咖啡店，你可能看到的是你每天或每月销售多少咖啡，当你想看到你的店在过去六个月的表现时，你可能会添加所有六个月的销售额。现在，如果您希望能够预测未来六个月或一年的销售额，该怎么办呢？在这种情况下，您唯一知道的变量是时间(秒、分、天、月、年等)，因此您需要时间序列分析来预测其他未知变量，如趋势、季节性等。

因此，重要的是要注意，在时间序列分析中，唯一已知的变量是— 时间。

为什么 pandas 使处理时间序列变得容易

事实证明，Pandas 作为处理时间序列数据的工具非常成功。这是因为 Pandas 有一些内置的datetime函数，这使得处理时间序列分析变得很容易，并且由于时间是我们在这里处理的最重要的变量，这使得 Pandas 成为执行这种分析的非常合适的工具。

时间序列的组成部分

一般来说，包括金融领域之外的时间序列通常包含以下特征:

1. 趋势:这是指一个序列在一个长时期内相对较高或较低的值的移动。例如，当时间序列分析显示一个向上的模式时，我们称之为上升趋势，当模式向下时，我们称之为下降趋势，如果根本没有趋势，我们称之为水*或静止趋势。需要注意的一点是，趋势通常会持续一段时间，然后消失。
2. 季节性:这是指在一个固定的时间段内重复的模式。虽然这些模式也可以向上或向下摆动，但是，这与趋势有很大的不同，因为趋势会持续一段时间，然后消失。然而，季节性在固定的时间段内持续发生。例如，当圣诞节时，你会发现卖了更多的糖果和巧克力，这种情况每年都会发生。
3. 不规则性:这也叫噪音。不规则性发生的时间很短，而且不会耗尽。一个很好的例子是埃博拉病毒。在那段时期，洗手液的需求量很大，但这种需求是不稳定的/系统的，没有人能预测到，因此没有人能知道销售了多少，也不知道下一次会有什么爆发。
4. 周期性的:这是当一系列重复向上和向下运动时。它通常没有固定的模式。它可能发生在 6 个月后，然后两年后，然后 4 年，然后 1 年后。这种模式很难预测。

何时不应用 TS

还记得我们说过这里的主要变量是时间吗？同样，必须指出的是，在以下情况下，我们不能对数据集进行时间序列分析:

1. 变量/值是常量。例如，去年圣诞节和前年圣诞节售出了 5000 盒糖果。因为两个值相同，所以我们不能应用时间序列来预测今年圣诞节的销售额。

2.函数形式的值:当您可以简单地使用公式或函数来计算值时，对数据集应用时间序列分析是没有意义的。

现在我们对时间序列有了基本的了解，让我们继续做一个例子来完全掌握如何分析时间序列数据。

预测航空旅行公司的未来

在这个例子中，我们被要求建立一个模型来预测特定航空公司的机票需求。我们将使用国际航空公司的乘客数据集。你也可以从 kaggle 这里下载。

导入包和数据

首先，我们需要做的第一件事是导入我们将用来执行分析的包:在这种情况下，我们将利用pandas来准备我们的数据，并访问datetime函数和matplotlib来创建我们的可视化:

现在，让我们读取数据集，看看我们有什么样的数据。如我们所见，数据集被分为两列；月和每月旅客人数。

我通常喜欢获取数据集的摘要，以防有一行的值为空。让我们继续执行以下操作进行检查:

正如我们所看到的，我们的数据集中没有任何空值，所以我们可以自由地继续我们的分析。现在，我们要做的是确认Month列是datetime格式，而不是字符串。熊猫.dtypes功能让这一切成为可能:

我们可以看到Month列是一个通用的对象类型，可能是一个字符串。因为我们想要对这些数据执行与时间相关的操作，所以我们需要将它转换成一种datetime格式，然后它才能对我们有用。让我们继续使用to_datetime()助手函数来完成这项工作，让我们将月份列转换为一个datetime对象，而不是一个通用对象:

请注意，我们现在已经生成了作为月份列一部分的date字段。默认情况下,“日期”字段假定每月的第一天来填写未提供的日期值。现在，如果我们返回并确认类型，我们可以看到它现在的类型是datetime:

现在，我们需要将datetime对象设置为 dataframe 的索引，以允许我们真正探索我们的数据。让我们使用.set_index()方法来完成:

我们现在可以看到,Month列是我们的数据帧的索引。让我们继续创建我们的图，看看我们的数据看起来像什么:

注意，在时间序列图中，时间通常绘制在x-axis上，而y-axis通常是数据的大小。

请注意Month列是如何被用作x-axis的，因为我们之前已经将Month列转换为datetime，所以year被专门用于绘制图形。

现在，你应该注意到一个上升的趋势，表明随着时间的推移，航空公司将有更多的乘客。虽然在每个时间点都有起伏，但通常我们可以观察到趋势是增加的。我们还可以注意到起伏似乎有点规律，这意味着我们可能也在观察一种季节性模式。让我们通过观察某年的数据来仔细了解一下:

正如我们在图中看到的，通常在 7 月和 9 月之间有一个高峰，到 10 月开始下降，这意味着更多的人在 7 月和 9 月之间旅行，可能从 10 月开始旅行减少。

还记得我们提到过在我们的观察中有一个上升趋势和一个季节性模式吗？在大多数时间序列分析中，通常有许多组成部分[向上滚动查看时间序列组成部分的解释]。因此，我们现在需要做的是使用分解技术将我们的观察解构为几个组件，每个组件代表一个基本的模式类别。

时间序列的分解

在时间序列数据的分解过程中，有几个模型需要考虑。
1。加法模型:当趋势的变化不随时间序列水*而变化时，使用这种模型。这里，时间序列的组成部分简单地用公式相加:
y(t) = Level(t) + Trend(t) + Seasonality(t) + Noise(t)
2。乘法模型:如果趋势与时间序列的级别成比例，则使用乘法模型。这里，时间序列的组成部分简单地用公式相乘:
y(t) = Level(t) * Trend(t) * Seasonality(t) *Noise(t)

出于本教程的目的，我们将使用加法模型，因为它开发速度快，训练速度快，并且提供可解释的模式。我们还需要导入[statsmodels](https://www.statsmodels.org/stable/index.html)，它有一个tsa(时间序列分析)包以及我们需要的seasonal_decompose()功能:

现在我们有了一个更清晰的图表，显示趋势在上升，季节性遵循一个规律。

我们要做的最后一件事是绘制观察到的时间序列的趋势图。为此，我们将使用 Matplotlib 的.YearLocator()函数将每个year设置为从一月month=1开始，并将month设置为每 3 个月(intervals=3)显示一次刻度的次要定位器。然后，我们使用数据帧的索引x-axis和y-axis的乘客数量来绘制数据集(并赋予其蓝色)。
我们对趋势观察做了同样的处理，用红色绘制。

import matplotlib.pyplot as plt
import matplotlib.dates as mdatesfig, ax = plt.subplots()
ax.grid(True)year = mdates.YearLocator(month=1)
month = mdates.MonthLocator(interval=3)
year_format = mdates.DateFormatter('%Y')
month_format = mdates.DateFormatter('%m')ax.xaxis.set_minor_locator(month)ax.xaxis.grid(True, which = 'minor')
ax.xaxis.set_major_locator(year)
ax.xaxis.set_major_formatter(year_format)plt.plot(data_set.index, data_set['#Passengers'], c='blue')
plt.plot(decomposition.trend.index, decomposition.trend, c='red')

同样，我们可以看到趋势与个别观察结果相反。

结论

我希望这篇教程能帮助你理解什么是时间序列，以及如何开始分析时间序列数据。

分析新加坡的火车旅行时间和票价

原文：https://towardsdatascience.com/analyzing-train-travel-times-and-fares-in-singapore-d8afea68d14c?source=collection_archive---------17-----------------------

我试图了解新加坡不同火车站的可达性，以及不同车站的旅行时间和票价是如何变化的。分析的目的是在火车作为唯一运输方式的基础上，确定更方便的地区。有许多方法可以进行分析:

-查看 X 分钟内可到达的站点数量

-查看行程时间的范围/分布

-查看旅行费用的范围/分布

我对每个站都给予了同等的重视，即每个站都与另一个站一样重要。这可能不太现实，因为有些位置的访问频率不如其他位置。然而，这是一个很好的起点，也是一种通用的方法。我还更加关注使用旅行时间而不是旅行费用作为比较的基础，因为票价将于 2018 年 12 月 29 日发生变化。还需要注意的是，这里的行程时间不包括等待和换乘时间，也不包括延误时间。这可能不是微不足道的，但我假设每个站发生的概率相等，这可能不是真的。在我们建立这个先验之前，需要分析延迟事件的概率，目前我没有这个数据。我如何收集旅行时间和费用数据可以在之前的帖子中找到。

因此，我为用户设计了一个仪表板，让他们在一定时间内比较某个特定站点与另一个站点的覆盖范围，以帮助他们建议重叠区域内可能的会合点。有趣的是，小印度拥有最多 15 分钟内可到达的车站。对于在 8 到 18 分钟内可到达的大多数车站，前 3 名车站是 Dhoby Ghaut、Bugis 和小印度。Serangoon 成为 19 分钟内可到达车站最多的车站。这有助于房产购买的计划，因为便利是一个主要的考虑因素。将这种可及性与房地产价格联系起来也很有意思。

The interactive dashboard can be accessed here.

我做了第二个仪表板来呈现旅行时间和费用分布的宏观和微观视图。似乎有一种向花哨的可视化发展的趋势，我不太赞同这一点。大多数情况下，简单的图表，如条形图、线形图或散点图，能够有效地展示调查结果。尽管如此，我还是决定尝试一下辐射图。如果你看它，它真的只有在我们有兴趣看大局，而不是依赖它的统计数据或数字时才有用。我们可以看到不同火车线路的旅行时间的总体分布，用不同的颜色表示(我将一些组合在一起，例如 SW 和 SE，PW 和 PE，CE 和 CG)。此外，我们可以看出 BP 线(用灰色表示)的站点数量最少，紧随其后的是 ne 线(用紫色表示)。此外，西南/东南线(由粉红色表示)和 PW/ PE 线(由蓝绿色表示)上的站点具有非常相似的行程时间分布，而东西线(由绿色表示)具有最大的差异，其分布看起来像一个心形图形。更均匀的分布类似于三角形，更类似于 BP 线(用灰色表示)。通过调整最大旅行时间，我发现 CC 线上的所有车站(用黄色表示)都能够在 62 分钟内到达所有其他车站。同样，这样的图表也有很多局限性。不清楚 15 分钟内有多少(或多少比例)的电台可以到达，也很难筛选出一个特定的电台来查看。因此，这真的取决于一个人在设计可视化时要达到的目标。

从径向图开始，旁边的两个图表提供了逐站旅行时间和票价的细分。更容易看到每条线路和每个站的分布。旅行费用的分布非常有趣。每一种都有独特的形状，尤其是不同的线条。票价肯定不是正态分布的，因此计算某个人从特定车站出发的*均票价可能没有意义。研究每个地区的人在火车旅行上的花费是有益的，这可能会更好地影响不同层次的福利包的设计，以补充运输成本。当然，有很多方法可以做到这一点，无论是通过上限或每次乘坐的百分比折扣；就实施而言，这可能必须与一张可识别的卡联系在一起。

The interactive dashboard can be found here.

另外，在我收集完所有 157 个站点的数据之前，我决定在收集了 40 个站点的数据之后对分布进行初步分析。箱线图在评估范围/分布时非常有用，在这种情况下，中值对异常值更稳健，从而使比较更有意义。也很容易看出哪些车站的*均旅行时间和票价比其他车站低。同样，这是基于每个站同等重要的假设。如果我们给某些电台更高的权重，分布将会改变。

另一方面，散点图有助于我们理解总体趋势，也有助于识别异常值(和可能的数据输入错误？).我们可以看到具有*台效应的对数关系。研究不同定价策略对收入的影响肯定是有潜力的，例如阶梯式增长或基于时间而不是基于距离的费用结构。这将使票价估算更容易，但我也认为这将转化为通勤者更高的成本。

原载于 2018 年 11 月 5 日【projectosyo.wixsite.com】。

分析和可视化巴基斯坦和印度的恐怖袭击(2002–2015)

原文：https://towardsdatascience.com/analyzing-visualizing-terrorist-attacks-in-pakistan-india-2002-2015-24a03424f5e3?source=collection_archive---------2-----------------------

我目前正在学习数据科学，所以最好的学习方法是实时学习，作为一名巴基斯坦人，我会查看来自我自己国家的数据进行分析和可视化，不幸的是，我脑海中闪现的第一件事是巴基斯坦的恐怖袭击。

所以，我开始寻找巴基斯坦恐怖袭击的数据库，我在马里兰大学的全球恐怖主义数据库找到了一个。

在讨论数据之前，我想强调一下数据中我认为缺失的一个重要元素。GTD 使用了城市的坐标，而不是事件发生的实际地点，这使得它在分析数据时效率较低。如果我们有事件发生地点的实际坐标，至少我们将能够分析城市的哪个部分更容易受到攻击，以及可能的原因，我们还可以通过运行预测分析模型或在机器学习的帮助下了解即将到来的攻击。

在我们继续之前，最后一件事，我不是数据分析或可视化方面的专家。所以，原谅我，如果它可以更好，或者我的分析是薄弱的。

我分析了巴基斯坦和印度。为什么是印度？因为我们是爱情鸟，我们一直都这样。我这么做的原因和这个印度人试图在ka ggle找到“克什米尔的恐怖事件和巴基斯坦的牵连”一样。

我有几句话要对 Anshul 先生说:你可以更好地为你的国家和这个社区服务，提出印度的真正问题，而不是把时间浪费在最不重要的事情上。

以下可视化是使用至少有 1 个因果关系的数据作为恐怖袭击的结果。

巴基斯坦恐怖袭击概述

该数据中分析的年份为 2002 年至 2015 年:根据 GTD 的数据，巴基斯坦发生了超过 10，000 起恐怖袭击，其中略多于 18，000 人死亡，超过 30，000 人受伤。

Overview of terrorist attacks in Pakistan

看起来整个巴基斯坦都受到了影响，这是真的，但大多数袭击发生在俾路支，FATA 和 KPK。

这三个地区位于阿富汗边境！

印度恐怖袭击概述

这就是印度恐怖袭击在地图上的样子。

它从克什米尔开始，深入到印度的东部、南部、北部和东南部。

如果巴基斯坦在印度输出恐怖主义，为什么我们没有看到任何跨越 2900 多公里边界的活动？为什么只有克什米尔有麻烦？因为这是印巴之间有争议的领土，克什米尔人民正在为自由而战，这也是 GTD 数据库中的恐怖主义。

根据 GTD 的数据，2002 年至 2015 年期间，印度记录了 6488 起恐怖袭击事件。超过 7600 人死亡，超过 14400 人受伤。329 起袭击是由“伊斯兰”组织实施的，在过去的 15 年里造成了 1119 起伤亡，其余的则是由“非伊斯兰”组织实施的。正如我们在下面所看到的，超过 95%的“伊斯兰组织”的袭击发生在克什米尔，同样是自由运动活跃的争议地区。

这是印度“伊斯兰”组织的所有袭击，看起来像是在地图上…

Attacks by “Islamic” groups in India

亲爱的印度！你的问题既不是巴基斯坦也不是穆斯林。

巴基斯坦受影响最严重的地区

FATA 碰巧是像 TTP 这样的恐怖组织的大本营，但就袭击数量而言，它在名单上排名第三，这显然是因为没有多少“有价值”的目标。从 FATA 崛起后，第一个受到影响的地区是 KPK。

俾路支斯坦和阿富汗之间没有任何东西，所以即使俾路支斯坦的总人口不超过巴基斯坦的 5%,进入第二个国家也是显而易见的。

旁遮普是巴基斯坦人口最多的地区，人口占总人口的 50%以上。如果我们假设恐怖主义的根源在巴基斯坦内部，我们应该已经看到旁遮普、信德和伊斯兰堡的最大数量的袭击，但是我们看到袭击数量和受影响最严重地区的地理位置(与阿富汗接壤)之间存在正相关。还有一个原因导致了这些地区更多的恐怖活动。与这个国家的其他地区相比，这些地区被忽视并且不发达。

信德省并不与阿富汗接壤，但是阿富汗发生大量袭击事件的原因是相互之间以及与安全部队之间的政治和种族战争。

这是 FATA/KPK &旁遮普袭击的特写镜头。

袭击数量&各城市的伤亡人数

卡拉奇是巴基斯坦最大的城市，人口超过 2000 万。因此，奎达和白沙瓦名列榜首。

按团体划分的攻击次数

有趣的是，当我们看到 TTP 在 FATA 崛起时，我们也看到俾路支省的俾路支恐怖组织崛起。

如果我们看看印度不同组织的袭击次数。很明显，巴泰虔诚军(LeT)T1 和 T2 伊斯兰圣战者组织 T3 分别位于 T4 的第 6 位、T42 的第 6 位和第 7 位，这使得他们对印度的威胁很小(至少除非他们先对付其他组织)。

前 5 名是…

1.印度***(毛派)

2.毛派

3.阿萨姆联合解放阵线(ULFA)

4.加罗民族解放军

5.波多兰全国民主阵线(NDFB)

每年的攻击次数

2007 年巴基斯坦恐怖袭击激增。以下是 2007 年及之前发生的几起助长巴基斯坦恐怖主义的重大事件。

1。印度沿巴基斯坦边境在阿富汗开设领事馆。

2。巴基斯坦开始报道印度干涉 FATA &俾路支省。

这篇报道发表于2006 年 4 月 24 日，四个月后巴基斯坦于2006 年 8 月 26 日在俾路支省杀死了俾路支叛军首领阿克巴·布格提，这进一步助长了俾路支省的叛乱。

1。恐怖分子接管了伊斯兰堡的拉尔清真寺，拉尔清真寺被围困是 2007 年 7 月伊斯兰原教旨主义武装分子和巴基斯坦政府之间的对抗。

2。拉尔清真寺的行动被用来助长斯瓦特地区的叛乱。TNSM 在 2007 年接管了斯瓦特的大部分地区。

3。2007 年 12 月，大约 13 个组织在巴伊图拉·马哈苏德的领导下联合起来，成立了巴基斯坦塔利班运动(TTP)。

但好的一面是；过去几年，巴基斯坦似乎赢得了反恐战争的胜利。

多年来印度的攻击次数

每月各天的攻击次数

恐怖分子在每月的第一天最活跃，在每月的最后一天最不活跃。

为什么？嗯，我想不出一个可靠的理由，所以你能帮我理解吗？

以下是 TTP 每月每天发动的攻击数量。

有趣的是，他们在每月的 1 号和 15 号进行了大部分的攻击。

为什么？也许是因为他们根据“表现”得到了双周刊的报酬，谁知道呢？😄

恐怖袭击中广泛使用的武器类型

恐怖分子使用了爆炸物/炸弹/炸丨药(61.81%) 其次是火器(31.98%)

每月攻击次数

恐怖分子喜欢在五月发动袭击。我不是军事专家，但我肯定有人能得出结论，为什么五月发生的袭击最多，为什么九月发生的袭击最少。

而 TTP 似乎在一月最活跃，十月最不活跃。

外国公民在巴基斯坦遇害

从 2002 年到 2015 年，共有 427 名外国公民在巴基斯坦被杀，其中大部分是阿富汗人这是显而易见的，因为阿富汗人生活在恐怖袭击地区，如 FATA，KPK &俾路支省，他们也和巴基斯坦人一样成为受害者。

这还不是全部！

巴基斯坦将有许多出色的数据科学家，他们可以从这个数据库中提取更有价值的信息，并与我们分享。

在花了几天时间研究这些数据后，我得出结论，巴基斯坦和印度应该花更多的时间提高他们自己人民的生活水*，把更多的注意力放在被忽视的领域，而不是互相攻击。恐怖主义马上就会减少 70%。

爱与和*！

人们在理发上花费多少？

原文：https://towardsdatascience.com/analyzing-who-spends-more-on-haircuts-men-or-women-a90003e98312?source=collection_archive---------0-----------------------

男生还是女生在头发上花费更多？

理发的时候想着理发

我坐在 Dazzle's salon 的椅子上，看着迈克尔把我头上的豪猪变成一件稍微像样的东西，这时我意识到，“哇，我在理发上花了一大笔钱”。

每次去 Dazzle 要花我 30 美元，我大概每个月都会去一次。这意味着我每年要在理发上花费大约 360 美元。这比我花在其他服务上的钱还多，我认为这些服务是我生活中不可或缺的(如互联网、电力、亚马逊 Prime)。

一系列的想法和问题冒了出来:

每个人都在理发上花这么多钱吗？

我为女孩感到难过，她们肯定比我花得多。

等等，女孩理发的花费真的比我多吗？

我的女性朋友经常抱怨说，女性理发的费用比男性高是多么令人愤慨。我抗议这种不公正，就像我抗议所有对我的生活没有影响的不公正一样:保持沉默，希望它消失。因为这个价格差距，我一直认为女性在理发上的花费比男性多。

但是当我开始做一些计算时，我不太确定了。我无法想象大多数女孩需要像男孩一样频繁地理发。基于我有限的观察能力，女性一年理发两到三次——明显少于男性。因此，我不清楚到底是谁在理发上花费更多。

现在你可能会想，在这个世界上留下的所有未解之谜和未回答的问题中，男性或女性在理发上的花费更多是一个极其狭隘和毫无意义的问题，不值得深入研究。

你可能是对的。

这是为了科学，我保证！

我首先对我的朋友做了一个粗略的调查，以更好地了解一般的理发习惯。

如果有一本书叫做如何失去朋友并让人们认为你在暗地里是一个连环黑仔，询问人们关于他们的护发习惯应该有自己的一章。

在得到预期的“你为什么需要知道”“为什么？”我个人最喜欢的“…”，我的男性朋友说他们每一到两个月理发一次，每次 20-30 美元，而我的女性朋友每三个月到每两年理发一次，每次 50-100 美元。

显然，还有“附加服务”，如直发、染发和所谓的巴西式发型。

然而，要真正回答哪个性别花费更多的问题，我需要一个更大的样本量。

如果是调查就没那么毛骨悚然了…也许吧

我招募了 202 个人，给他们一份调查。

我问他们多久去一次发廊/理发店，每次去多少钱。我还特意询问了他们的理发习惯，以及他们是否为任何额外服务付费。

虽然调查参与者偏向女性(30%男性，70%女性)，但结果仍然很有趣。

那么什么是理发呢？

那么谁在理发上花费更多呢？

简短的回答是，看情况而定；你如何定义一个发型？

*均而言，男人一年去发廊或理发店 5.84 次，或每 8 周多一点，而女人一年去 3.81 次，或每 13 周半。男性每次旅行的花费约为 22.93 美元，而女性每次旅行的花费是男性的两倍多，为 54.34 美元。

将每位受访者的年度旅行次数乘以他/她每次旅行的花费，男性*均每年在发廊/理发店的花费约为 154.44 美元，而女性*均为 257.42 美元。

乍一看，女人在头发上花的钱比男人多得多。然而，这些数字还包括花在染发、拉直、巴西吹等方面的钱。

只看花在剪刀剪头发，头发在地上理发上的钱，男人*均每次理发花费 22.74 美元，而女人*均花费 29.55 美元。尽管女性理发仍然比男性理发贵，但差别已经不那么明显了。

如果你把男性理发的频率(每两个月一次)和女性理发的频率(一年四次)考虑在内，男性*均每年花费 158.90 美元，而女性花费 104.21 美元。因此，从纯粹理发的角度来看，男性每年在理发上的花费实际上比女性多。

男人就是不为额外的服务付费。

在女性每年在发廊花费的 257.42 美元中，只有 40%真正用于理发——剩下的 154.45 美元用于支付额外的服务——染发、拉直、吹发等。

花在男性额外服务上的钱接*于零。乍一看，男性在理发上的花费(158.90 美元)似乎比他们在沙龙/理发店的花费(154.44 美元)要多。我有点困惑这怎么可能，直到我看到评论——几个家伙自己剪了头发。这些人拉低了发廊/理发店的*均频率和花费，而没有影响理发频率和花费。

所以我的直觉是对的…也是错的。

我同情外面所有的女人。头发护理可不是闹着玩的，可笑的是，即使是简单的理发，女孩也要比男孩多付 50%左右。

然而，仍然有意思的是，普通男生在纯理发上的花费实际上比普通女生多。女性护发费用过高的主要原因是“附加服务”，这些服务可以说是可选的。

我想过用这些事实来安慰我的女性朋友，并向她们展示她们在理发上的花费实际上比我少。但是，我其实很喜欢有女性朋友。

更有可能的是，我会保持沉默，希望有人会像我一样对这个分析感兴趣

你可能喜欢的其他文章

如果你喜欢这篇文章，请访问 LateNightFroyo.com 的，阅读关于爱情、生活等话题的话题。

什么时候去参加聚会比较合适？

你如何摆脱外出？

多年轻才算年轻到不能约会？

阅读法律案例文件，如专业指南和分析。

原文：https://towardsdatascience.com/anatomy-of-an-indian-tax-case-f1311379bc8c?source=collection_archive---------13-----------------------

Type, type, type, done!

在印度，税务案件分为直接和间接。直接税包括所得税、财产税、利息税、赠与税等。间接税包括 GST (自 2017 年生效)、增值税(仍适用于酒类、黄金、珠宝等)、关税等。我有机会分析了223k direct tax cases。最老的一个在January, 1950，而最*的一个在August, 2018。在一系列的帖子中，我很乐意从这个庞大的语料库中得出见解。就本文而言，这些是每个法院的案件数量，考虑到:

• 最高法院:**3145** (1.4%)
• 高等法院:**64847** (29%)
• 所得税上诉法庭(ITAT): **154963** (69.6%)

解剖

法律案例文档是一个人应该如何组织任何文本的主要例子。它是(读起来应该是)有说服力的，而且重要的是，它沿着一条线索将读者从一点*稳地带到另一点。理解构成判决的要素及其特征对任何读者都是有用的，更不用说律师和从业者了。 此外，即使在知道大小写之前就知道一个元素的大概位置，也能加快阅读过程。

撇开创作自由、不必要的冗长和无根据的重复不谈，法律判决似乎遵循这种普遍的未明说的格式，正如一个不在法律领域的人所理解的那样:

1。开始 -对案例的快速介绍、最初提交案例的详细信息以及其他先决条件信息。

这些是 2007-08 课税年度针对劳工处的命令而提出的交叉上诉。CIT(A)-XX，新德里，2013 年 3 月 6 日。

二(一)。问题- 手头的事情，是利益点和案件的基石。争议是对法律或事实的争论。基石。问题提出了，法庭欠我们答案。

被评人提出的第一个问题是反对劳工处的行动。CIT(A)确认增加 10，747 卢比，由 AO 作为捐赠和订阅账户。

2(b)。理由- 根据当事人的观点，理由是问题。理由是问题的问题。它们是一个案件的为什么的为什么。

在编号为 921/JP/2011 的 2004-05 年度 ITA 中，税务局基于以下理由提起上诉:1 .那是身份证。CIT (A)在删除《1961 年信息技术法》第 10(23c)(iiiad)条拒绝豁免请求的规定时，在法律上以及在本案的事实和情况上都犯了错误。

2(c)。祈祷文 -祈祷文是对法庭的呼吁。

上诉人请求许可在审理时或之前补充、更改、修正和/或变更上诉理由。

一起，理由，问题和祈祷可以被称为提交给法院。

3。事实是案件中发生的事情。案件的论证和推理依赖于事实。虽然双方通常对事实意见一致，但如果有争议，就会产生事实问题，法院必须解决这一问题。事实包括被评人的业务/行业、进行的交易、争议的金额及/或交易等。

这个问题的简单事实是，被评估人是一家从事向其集团公司提供营销服务的公司。

4。辩护律师为自己一方辩护时提出的论点或辩护。这些论点由陈述支持，这些陈述被称为案例的推理要素。律师引用法律和判例来支持他们的主张。法官或成员也将在进行辩论时提供必要的支持。

经询问，被评估人认为这些费用实际上是在本年度发生的。

是 ld 提交的。被评税者认为 CIT(A)通过的受质疑命令是作为被评税者的单方面行为。

5。控股- 裁决，包括双方将采取的指令部分。“指令部分”表示各方要采取的行动。

有鉴于此，现阶段不需要对案件的是非曲直作出裁决。

6。结局- 以一种浓缩的控股形式作为裁决，来概括这个案子。

参考资料被相应地处置，没有关于费用的命令。

结果，被评人在 2008-09 及 2009-10 课税年度的上诉部分获得批准，而税务局在 2009-10 课税年度的上诉则被驳回。

理想情况下，在涉及一个以上法律问题的情况下，应重复第 2 点至第 5 点，直到所有问题都得到解决。

洞察力

*均判决长度为6.87 pages。*均来说，一个判断有2015 words呈现在69.27 sentences中，合并成22.89 paragraphs.

文本分类模型被用来预测所有判断中的这些元素。在超过 10 万个预测句子的聚合语料库中，观察到以下趋势。

这些元素的*均字符长度如下:

• 投稿:307.09 字符
• 参数276.12 字符
• 手持:202.97 字符
• 结果:95.15 字符

意见书和论辩书明显比持有和判决长。这是因为这两个要素-意见书和论点需要阐述。论元句是那些包含明确陈述的句子，如上面的例子所示。预测每一个推理/论证句子，往好里说是尝试，往坏里说是不可能。

在至少预测到一个提交的情况下，判决*均包含3.74 submissions、7.44 arguments、1.07 holdings和1.91 outcome个句子。

机器学习笔记

考虑到统计数据，一个判断将由70 sentences组成，其中只有~14 sentences属于任何一个类别。这大约发生在案件的20%左右。这是不*衡学习的一个典型例子，可以通过以下一种或多种方式来处理:欠采样、过采样、使用类似 SMOTE 的方法创建类的伪示例，或者调整模型的参数来惩罚这种不*衡。在我们的例子中，对少数类进行过采样是一个更好的方法，因为 这些元素的结构彼此非常相似。对少数类进行欠采样会导致信息丢失。

为了验证上述说法，我在训练数据中随机抽取了一个案例的问题，得到了以下结果:

1.判决是否应该在摘要中报道？
根据本案的事实和情况，同时考虑到 KSBC 禁止在外服役，法庭允许塞尔维亚共和国的开支在法律和事实上是否正确。
2。了解到的下级机构是否有材料和在法律上正确认定法案第 269D(2)(b)条包含的法定要求得到遵守？
3。这种利益是否符合为外国游客提供服务的利润，这是个问题。
4。为了支出的目的，是否提取了任何资本，或者，换句话说，发生支出的目的是否是使用作为业务资本而获得的资本。

(高亮显示的单词和短语是在表示怀疑或询问某事时使用的假设情景的经典例子。所有这些元素都可以单独评估它们的词类和其他语言特征，但那是以后的事了。)

通常，一个元素可以属于两个类(不是互斥的)，而multi-label classification是合适的。然而，从上述类的一个元素开始比从其他元素开始更容易

因为一个类的大多数元素在结构上是相似的，所以一个bag of words或者一个TF-IDF方法可以很好地用于建模。Word vectors在不太大的训练集中表现不佳，而前者表现良好。

如下图所示，位置也是该车型的一个突出特点。

案件中这些要素的分布

Where’s what?

注意事项:

在 x 轴上，我们有一个案件的各种元素。为了便于理解图表， y 轴已经倒置。在 y 轴上，我们有一个案例中的位置，即从第一行开始，要到达文本中的特定行(0.2 =案例中的 20%)必须穿过案例的范围。

例如，显而易见，提交的案例(问题和理由)位于案例正文的前 40% 处。该分布持续存在并最终收敛。

分析和见解:

1. 提交、支持、结果——这些要素清楚地位于案件的某些特定点上，而论点和理由几乎均匀地散布在整个案件中。
2. 控股公司紧随其后的是结果声明。
3. 另一方面，提交的材料和论点更多地是在高级委员会和高级委员会中提出的。这些在上面的图表中显示为块状。经分析，HC 和 SC 评委的写作风格连贯清晰。他们从清楚地描述一个问题开始，然后在继续另一个问题之前详细地讨论它。另一方面，在没有这种固定模式的 ITAT 判决中存在着一种混乱状态。
4. 持有和结果声明显示了法院几乎相似的趋势。
5. 事实(上面没有显示)分散在整个案件中。
6. 这些元素的*均位置如下:

• 提交:0.29
• 论据:0.46
• 原因:0.53
• 控股:0.76
• 结果:0.82

这个顺序验证了我们之前关于理想判断顺序的假设。

看了几年，下图小提琴情节具体化。

What’s where, when?

有一个明显的趋势表明，随着时间的推移，判断已经从相当结构化的要素转变为更加松散的结构。在上图中，小提琴的球形度表示判断中特定位置的元素密度。我们可以看到，这种进展是从被严重描绘(更多球状)到更分散的集中(更少球状)，表明元素现在在判断中的位置方面更加分散。

虽然许多人说撰写判决书是一门艺术，但通常阅读判决书也是一门艺术。如果这种艺术形式至少在核心上是一致的，那肯定是有帮助的。

结尾注释:

1. 临时命令、诉讼记录和其他非最后文件不在此分析之列，因为它们包含缺乏这些核心要素的琐碎信息。
2. 数据来源-我在 Riverus 工作，一家致力于为从业者和普通民众简化法律的法律技术公司。

锚盒——质量目标检测的关键

原文：https://towardsdatascience.com/anchor-boxes-the-key-to-quality-object-detection-ddf9d612d4f9?source=collection_archive---------0-----------------------

在学习用于对象检测的卷积神经网络时，最难理解的概念之一是锚盒的概念。它也是可以优化以提高数据集性能的最重要的参数之一。事实上，如果锚盒没有正确调整，你的神经网络甚至永远不会知道某些小的、大的或不规则的对象的存在，也永远不会有机会检测到它们。幸运的是，你可以采取一些简单的步骤来确保你不会落入这个陷阱。

什么是锚盒？

当你使用像 YOLO 或 SDD 这样的神经网络来预测一张图片中的多个对象时，网络实际上正在进行成千上万次预测，并且只显示它确定为对象的那些。多个预测以下列格式输出:

预测一:(X，Y，高度，宽度)，类
…。
预测~8 万:(X，Y，高度，宽度)，类

其中(X，Y，高度，宽度)被称为“边界框”，或包围对象的框。这个框和 object 类由人工注释者手动标记。

在一个极其简单的示例中，假设我们有一个模型，它有两个预测，并接收到以下图像:

我们需要告诉我们的网络它的每一个预测是否正确，以便它能够学习。但是我们告诉神经网络 it 预测应该是什么呢？预测的类别应该是:

预测一:梨
预测二:苹果

或者应该是:

预测一:苹果
预测二:梨

如果网络预测:

预测一:苹果
预测二:苹果

我们需要我们网络的两个预测者能够分辨出他们的工作是预测梨还是苹果。要做到这一点，有几种工具。预测器可以专注于特定大小的对象、具有特定纵横比(高与宽)的对象或图像不同部分的对象。大多数网络使用所有三个标准。在梨/苹果图像的示例中，我们可以让预测 1 针对图像左侧的对象，预测 2 针对图像右侧的对象。那么我们就有了网络应该预测的答案:

预测一:梨
预测二:苹果

实践中的锚箱

现有技术的物体检测系统目前做以下工作:

1.为每个预测器创建数千个“锚框”或“先验框”，代表它专门预测的对象的理想位置、形状和大小。

2.对于每个锚定框，计算哪个对象的边界框具有最高的重叠除以非重叠。这被称为并集上的交集或 IOU。

3.如果最高 IOU 大于 50%，告诉锚盒它应该检测给出最高 IOU 的对象。

4.否则，如果 IOU 大于 40%，则告诉神经网络真实检测是不明确的，并且不要从该示例中学习。

5.如果最高 IOU 低于 40%，那么主播框应该预测没有对象。

这在实践中效果很好，数以千计的预测器在决定他们的对象类型是否出现在图像中方面做得非常好。看一看 RetinaNet 的开源实现，这是一个最先进的对象检测器，我们可以可视化锚框。太多了，无法一次全部形象化，然而这里只是其中的 1%:

使用默认的锚框配置可以创建太过专门化的预测器，并且出现在图像中的对象可能无法实现带有任何锚框的 50% IOU。在这种情况下，神经网络将永远不会知道这些对象的存在，也永远不会学会预测它们。我们可以将锚盒调整得更小，比如这个 1%的样本:

在 RetinaNet 配置中，最小的锚盒大小为 32x32。这意味着许多比这更小的物体将无法被探测到。这里有一个来自 WiderFace 数据集(杨，硕和罗，*和洛伊，陈变和唐，小欧)的例子，其中我们将边界框与它们各自的锚框进行匹配，但有些没有被发现:

Source: WIDER FACE

在这种情况下，只有四个基本事实边界框与任何锚框重叠。神经网络永远不会学会预测其他面孔。我们可以通过改变默认的锚盒配置来解决这个问题。减小最小的锚框尺寸，所有的脸至少与我们的锚框之一对齐，我们的神经网络可以学习检测它们！

Source: WIDER FACE

改进锚箱配置

一般来说，在开始训练模型之前，您应该问自己以下关于数据集的问题:

1. 我希望能够检测到的最小尺寸的盒子是什么？
2. 我希望能够检测到的最大尺寸的盒子是什么？
3. 这个盒子可以有哪些形状？例如，只要汽车或摄像机不会侧翻，汽车检测器可能有短而宽的锚盒。

您可以通过实际计算数据集中最极端的大小和长宽比来获得粗略的估计。另一个物体检测器 YOLO v3 使用 K 均值来估计理想的边界框。另一个选择是学习锚箱配置。

一旦你想通了这些问题，你就可以开始设计你的锚盒了。一定要对它们进行测试，方法是对你的基本事实边界框进行编码，然后对它们进行解码，就好像它们是来自你的模型的预测一样。您应该能够恢复地面真实边界框。

此外，请记住，如果边界框和定位框的中心不同，这将减少 IOU。即使你有小的锚盒，如果锚盒之间的跨度很大，你可能会错过一些地面真相盒。改善这种情况的一种方法是将 IOU 阈值从 50%降至 40%。

David Pacassi Torrico 最*的一篇文章比较了当前人脸检测的 API 实现，强调了正确指定锚盒的重要性。你可以看到算法做得很好除了对于小脸。下面是一些 API 根本无法检测到任何人脸的图片，但我们的新模型检测到了许多人脸:

如果你喜欢这篇文章，你可能会喜欢阅读没有锚盒的对象检测。

锚定你的模型

原文：https://towardsdatascience.com/anchor-your-model-interpretation-by-anchors-aa4ed7104032?source=collection_archive---------8-----------------------

“top view of two white yachts” by Tom Grimbert on Unsplash

模型解释意味着提供原因和背后的逻辑，以实现模型的可问责性和透明性。正如之前的博客(模型解释简介和 SHAP 所提到的，模型解释对于数据科学获得管理层和客户的信任非常重要。

LIME 的作者提到，LIME 在某些情况下无法正确解释模型。因此，他们提出了一种新的模型解释方法，即锚。

看完这篇文章，你会明白:

• 石灰解释的局限性
• 新方法:锚

石灰解释的局限性

From Ribeiro, Singh, and Guestrin 2018

虽然我们可以用简单函数来局部解释复杂性，但它只能解释特定的情况。这意味着它可能不适合看不见的情况。

从以上对情绪预测的解释来看，“不”在左手边提供了积极的影响，而在右手边提供了严重的消极影响。如果我们只看其中一种解释，这是没问题的，但是如果我们把两种解释放在一起看，我们就会感到困惑。

新方法:锚

From Ribeiro, Singh, and Guestrin 2018

通过学习直线(或斜率)，LIME 解释了预测结果。与 LIME 不同，Anchors 使用“局部区域”来学习如何解释模型。为了解释,“局部区域”是指生成数据集的更好构造。

有两种方法可以找到锚点。第一种是自下而上的方法，这种方法简单，但需要更多的时间来计算结果。第二种是“锚”库中采用的波束搜索。

自下而上的方法

From Ribeiro, Singh, and Guestrin 2018

该方法从空集开始。在每次迭代中，它将生成一组候选项，并且每次将添加一个新的特征谓词(特征输入)。如果规则达到精度并满足等式 3 的标准，它将停止寻找下一个特征谓词。因为它的目标是找到最短的锚点，因为他们注意到短锚点可能具有更高的覆盖率。

直觉上，有两个主要问题。一次只能添加一个功能。同样，贪婪搜索的主要目的是识别最短路径。

光束搜索方法

From Ribeiro, Singh, and Guestrin 2018

这种方法解决了贪婪搜索的局限性。它使用 KL-LUCB 算法来选择那些最佳候选。预期的结果是，这种方法比自底向上搜索更有可能识别具有更高覆盖率的锚点。

履行

explainer = anchor_text.AnchorText(spacy_nlp, labels, use_unk_distribution=True)
    exp = explainer.explain_instance(x_test[idx], estimator, threshold=0.8, use_proba=True, batch_size=30)max_pred = 2
    print('Key Singal from Anchors: %s' % (' AND '.join(exp.names())))
    print('Precision: %.2f' % exp.precision())
    print()exp.show_in_notebook() 

当调用“解释实例”时，我们需要提供

1. x _ test[idx]:x 的目标
2. 评估者:你的模型
3. 阈值:锚点使用此阈值来查找包含锚点(特征)的最小精度
4. batch_size:要生成的批的数量。更多的批处理意味着生成更多可能的数据集，但也需要更长的时间

根据上面的解释，Anchors 规定“印度”是将输入分类为“b”类别的输入锚点。

外卖食品

要访问所有代码，你可以访问我的 github repo。

• 与 SHAP 相比，计算时间更少。
• 在我之前的文章中，我用 SHAP 和锚来解释这个预测。你也可以考虑使用多模型解释器。
• 标签只能接受整数。意味着不能传递准确的分类名称，只能传递编码的类别。

关于我

我是湾区的数据科学家。专注于数据科学、人工智能，尤其是 NLP 和*台相关领域的最新发展。你可以通过媒体博客、 LinkedIn 或 Github 联系我。

参考

里贝罗·m·t·辛格·s·格斯特林·C..“我为什么要相信你？”解释任何分类器的预测。2016.https://arxiv.org/pdf/1602.04938.pdf

里贝罗·m·t·辛格·s·格斯特林·C..锚:高精度模型不可知的解释。2018.https://homes.cs.washington.edu/~marcotcr/aaai18.pdf

Kaufmann E .，Kalyanakrishnan s .“Bandit 子集选择中的信息复杂性”，2013 年。http://proceedings.mlr.press/v30/Kaufmann13.pdf

奥斯卡奖颁给…数据分析？

原文：https://towardsdatascience.com/and-the-oscar-goes-to-data-analytics-8e6728fcfcf8?source=collection_archive---------6-----------------------

(image credit: BRIDGEi2i.com)

第 89 届奥斯卡颁奖典礼最*在好莱坞的杜比剧院落下帷幕。魅力四射的吉米·基梅尔主持了这场活动，其结局令人想起 2015 年环球小姐选美大赛上的史蒂夫·哈维事件。

在提名预告之后，费·唐纳薇和沃伦·比蒂宣布《拉拉之地》为最佳影片。不久之后，这部电影的全体演员和工作人员冲上舞台，庆祝并准备发表演讲。

然而，唯一的问题是啦啦土地不是赢家。显然，贝蒂拿错了信封。真正的赢家是由巴里·詹金斯执导的剧情片《T4 月光》。在道歉和相当尴尬的“交流”中，错误得到了纠正。双关语。

分析公司在体育和娱乐领域做出预测的趋势每年都在增长。数据分析解决方案能够预测很多事情；然而，尴尬的时刻不在其中。

也就是说，一些分析初创公司和数据公司不时会发布对各种公众感兴趣的事件的预测——游戏、选举、电影和音乐奖项等等——主要是为了在炫耀数字技能之外找点乐子。

就奥斯卡而言，一般来说，分析公司利用的一些信息来源包括:

• 主要颁奖典礼(DGA、PGA、BAFTA、SAG 等。)
• 批评家的选择
• 以前的提名和获奖
• 流派和票房表现
• 被提名者的个人资料(年龄、记录等。)
• 社交媒体(公众情绪数据)
• 奥斯卡奖投票者的人口统计

2017 年奥斯卡颁奖典礼已经过去，许多才华横溢的艺术家获得了认可和荣誉。让我们仔细看看数据公司在奥斯卡上对各种奖项的预测。

以色列科技公司 Taykey 根据社交媒体上的对话和情绪对奥斯卡进行了预测。该公司专门从事实时情绪分析，每天跟踪数亿个数据点。

Taykey 的首席执行官 Amit Avner 说，当第 88 届奥斯卡颁奖典礼即将到来时，莱昂纳多迪卡普里奥对互联网用户的影响最大。迪卡普里奥在 80%关于他的网上聊天中得到了积极的回应。据报道，这位才华横溢的演员将制作 星球队长电影，并凭借荒野猎人获得最佳男演员奖。此外，在同一类别中失败的马特·达蒙(Matt Damon)仅获得 57%的积极回应。

Taykey 使用其专有方法确定安德鲁·加菲尔德和伊莎贝尔·于佩尔的积极情绪评级最高，分别为 86%和 76%。另一方面，艾玛·斯通的得分为 67%。

所以，这是泰基对四个主要类别的预测:

• 最佳男演员——安德鲁·加菲尔德
• 最佳女演员——伊莎贝尔·于佩尔
• 最佳男配角——马赫沙拉·阿里
• 最佳女配角——维奥拉·戴维斯

有趣的是，这些预测只有一半是真的，卡西·阿弗莱克和艾玛·斯通分别获得了最佳男演员和最佳女演员。我个人并不介意阿弗莱克击败加菲猫获得最佳男演员，因为《神奇蜘蛛侠 2》太混乱了。一个真正的漫画迷永远不会忘记。但是我跑题了。

移动大数据和人工智能解决方案提供商 Disrupted Logic Interactive 使用了奥斯卡奖数据中 17 年的数据点。这些数据点被输入该公司的软件，然后该软件使用专有的概率和关系算法来确定最佳影片的获胜者。

据报道，该软件的准确率“超过 100%”，预测学院 66%的投票者(超过 6000 人)会选择啦啦地。有那么一会儿，全世界都以为这部电影赢了，但事实并非如此。再说一次，这是一个我并不介意的结果，因为的《啦啦地》，尽管有一些令人惊叹的电影摄影，但几乎让我在影院里睡着了。(本来就是这样。)

专注于自然语言处理的人工智能初创公司 Luminoso Technologies 预测，娜塔莉·波特曼主演杰姬可能会赢得最佳影片。该公司利用 84，058 条 IMDb 评论进行了预测，报告称，“摄影”、“视觉”、“震撼”、“体验”和“杰作”等术语与获得提名的电影直接相关。然而，是月光夺走了梦寐以求的奥斯卡小金人。

总之，许多数据公司在今年的奥斯卡颁奖典礼上弄错了(尤其是最佳影片类别)。这可以归因于这样一个事实，即并不总是可能考虑到某些关键因素，如每个电影制片厂在活动开始前开展的活动。虽然有些因素可以考虑，但其他因素很难确定，更不用说研究和“借鉴”了。因此，任何分析软件都很难做出正确的预测。

现在是今年的裁决:

奥斯卡颁给了…数据分析。不是。(看到我在那里做了什么吗？)

---

这篇特写最早出现在 BRIDGEi2i 博客 上。

吴恩达的 Python(线性回归)机器学习教程

原文：https://towardsdatascience.com/andrew-ngs-machine-learning-course-in-python-linear-regression-dd04fba8e137?source=collection_archive---------4-----------------------

Machine Learning — Andrew Ng

我是一名药学本科生，一直想做的远不止是一名临床药师。我曾试图在我对它的热爱和我拥有的医疗保健知识之间找到某种融合，但在当今这个时代，人们真的会感到迷失在丰富的信息中。

6 个月前，我偶然发现了数据科学的概念及其在医疗保健行业的应用。鉴于数据和计算能力的进步，利用计算机来识别、诊断和治疗疾病不再是梦想。在更高级的层面上，计算机视觉可以帮助使用射线照相图像识别疾病，而在更简单的层面上，算法可以检测改变生活的潜在药物相互作用。

带着进入医疗 IT 行业的目标，我为那些没有技术背景的人设计了一个数据科学课程，我在这里展示了它。

斯坦福大学在 Coursera(https://www.coursera.org/learn/machine-learning)开设的吴恩达机器学习是数据科学社区强烈推荐的课程之一。经过 6 个月的基础数学和 python 培训，我开始了这门课程，以步入机器学习的世界。你们很多人都知道，这门课是在 Octave 或 Matlab 中进行的。虽然学习一些 Octave 编程并完成编程任务是很好的，但我想测试我的 python 知识，并尝试从头开始完成 python 的任务。

本文将是我撰写的系列文章的一部分，记录我在课程中编程作业的 python 实现。这绝不是其他人的指南，因为我也在不断学习，但可以作为那些希望做同样事情的人的起点。也就是说，我很高兴从你们那里收到一些建设性的反馈。

首先将使用数据集 **ex1data1.txt**进行一元线性回归

首先，我将导入所有相关的库并将数据集加载到 jupyter 笔记本中

import numpy as np
import matplotlib.pyplot as plt
import pandas as pddata=pd.read_csv("Uni_linear.txt", header=None)

为了养成良好的习惯，我会经常看数据，并对数据有良好的感觉

data.head()
data.describe()

绘制数据，以显示因变量(y)和自变量(X)之间的关系

plt.scatter(data[0],data[1])
plt.xticks(np.arange(5,30,step=5))
plt.yticks(np.arange(-5,30,step=5))
plt.xlabel("Population of City (10,000s)")
plt.ylabel("Profit ($10,000")
plt.title("Profit Vs Population")

我已经习惯了这种绘制图形的方式，但是我意识到使用 matplotlib 有一种面向对象的方式，我将在本作业的其他一些图形中使用这种方式

接下来计算成本函数 J(θ)

def computeCost(X,y,theta):
    """
    Take in a numpy array X,y, theta and generate the cost function     of using theta as parameter in a linear regression model
    """
    m=len(y)
    predictions=X.dot(theta)
    square_err=(predictions - y)**2

    return 1/(2*m) * np.sum(square_err)

初始化 X，y 并计算使用θ=(0，0)的成本

data_n=data.values
m=len(data_n[:,-1])
X=np.append(np.ones((m,1)),data_n[:,0].reshape(m,1),axis=1)
y=data_n[:,1].reshape(m,1)
theta=np.zeros((2,1))computeCost(X,y,theta)

这可能不是最好的方法，但这是我找到的唯一一个为₀.增加一列 1 的解决方案这里的computeCost函数将给出32.072733877455676

现在通过最小化成本函数 J(θ)来实现梯度下降以优化θ

def gradientDescent(X,y,theta,alpha,num_iters):
    """
    Take in numpy array X, y and theta and update theta by taking   num_iters gradient steps
    with learning rate of alpha

    return theta and the list of the cost of theta during each  iteration
    """

    m=len(y)
    J_history=[]

    for i in range(num_iters):
        predictions = X.dot(theta)
        error = np.dot(X.transpose(),(predictions -y))
        descent=alpha * 1/m * error
        theta-=descent
        J_history.append(computeCost(X,y,theta))

    return theta, J_historytheta,J_history = gradientDescent(X,y,theta,0.01,1500)print("h(x) ="+str(round(theta[0,0],2))+" + "+str(round(theta[1,0],2))+"x1")

print 语句将打印出假设:*h*(*x*) = -3.63 + 1.17x₁，显示四舍五入到小数点后两位的优化θ值

为了使任务更加完整，我还尝试将标准单变量情况下的成本函数可视化

from mpl_toolkits.mplot3d import Axes3D#Generating values for theta0, theta1 and the resulting cost valuetheta0_vals=np.linspace(-10,10,100)
theta1_vals=np.linspace(-1,4,100)
J_vals=np.zeros((len(theta0_vals),len(theta1_vals)))for i in range(len(theta0_vals)):
    for j in range(len(theta1_vals)):
        t=np.array([theta0_vals[i],theta1_vals[j]])
        J_vals[i,j]=computeCost(X,y,t)#Generating the surface plot
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
surf=ax.plot_surface(theta0_vals,theta1_vals,J_vals,cmap="coolwarm")
fig.colorbar(surf, shrink=0.5, aspect=5)
ax.set_xlabel("$\Theta_0$")
ax.set_ylabel("$\Theta_1$")
ax.set_zlabel("$J(\Theta)$")#rotate for better angle
ax.view_init(30,120)

上面的代码块生成如图所示的 3d 表面图。正如在讲座中提到的，成本函数是一个凸函数，只有一个全局最小值，因此，梯度下降将总是导致找到全局最小值

顺便说一下，我使用了 mplot3d 教程来帮助我进行 3d 绘图。(https://matplotlib.org/mpl_toolkits/mplot3d/tutorial.html)

plt.plot(J_history)
plt.xlabel("Iteration")
plt.ylabel("$J(\Theta)$")
plt.title("Cost function using Gradient Descent")

相对于迭代次数绘制成本函数给出了良好的下降趋势，表明梯度下降实现在降低成本函数方面起作用

现在，有了优化的θ值，我将把预测值(最佳拟合线)一起绘制成图

plt.scatter(data[0],data[1])
x_value=[x for x in range(25)]
y_value=[y*theta[1]+theta[0] for y in x_value]
plt.plot(x_value,y_value,color="r")
plt.xticks(np.arange(5,30,step=5))
plt.yticks(np.arange(-5,30,step=5))
plt.xlabel("Population of City (10,000s)")
plt.ylabel("Profit ($10,000")
plt.title("Profit vs Population")

同样，这可能不是基于θ生成直线的最佳方式，如果有更好的方式，请告诉我

作业的最后一部分包括根据你的模型做出预测

def predict(x,theta):
    """
    Takes in numpy array of x and theta and return the predicted value of y based on theta
    """

    predictions= np.dot(theta.transpose(),x)

    return predictions[0]predict1=predict(np.array([1,3.5]),theta)*10000print("For population = 35,000, we predict a profit of $"+str(round(predict1,0)))

打印报表打印:For population = 35,000, we predict a profit of $4520.0

predict2=predict(np.array([1,7]),theta)*10000
print("For population = 70,000, we predict a profit of $"+str(round(predict2,0)))

打印报表打印:For population = 70,000, we predict a profit of $45342.0

Machine Learning – Andrew Ng

现在使用数据集 **ex1data2.txt**进行多元线性回归

与所有数据集一样，我首先加载数据并查看数据

data2=pd.read_csv("Multi_linear.txt", header=None)
data2.head()
data2.describe()

如你所见，现在 X 有两个特征，使它成为一个多元问题

# Create 2 subplot, 1 for each variable
fig, axes = plt.subplots(figsize=(12,4),nrows=1,ncols=2)axes[0].scatter(data2[0],data2[2],color="b")
axes[0].set_xlabel("Size (Square Feet)")
axes[0].set_ylabel("Prices")
axes[0].set_title("House prices against size of house")
axes[1].scatter(data2[1],data2[2],color="r")
axes[1].set_xlabel("Number of bedroom")
axes[1].set_ylabel("Prices")
axes[1].set_xticks(np.arange(1,6,step=1))
axes[1].set_title("House prices against number of bedroom")# Enhance layout
plt.tight_layout()

针对每个功能绘制价格图显示了它们之间的关系。仅仅通过看这个图，我们就应该期望因变量和自变量之间有某种程度的正相关。

对于使用梯度下降的多变量问题优化，需要特征归一化来加速优化过程。

def featureNormalization(X):
    """
    Take in numpy array of X values and return normalize X values,
    the mean and standard deviation of each feature
    """
    mean=np.mean(X,axis=0)
    std=np.std(X,axis=0)

    X_norm = (X - mean)/std

    return X_norm , mean , stddata_n2=data2.values
m2=len(data_n2[:,-1])
X2=data_n2[:,0:2].reshape(m2,2)
X2, mean_X2, std_X2 = featureNormalization(X2)
X2 = np.append(np.ones((m2,1)),X2,axis=1)
y2=data_n2[:,-1].reshape(m2,1)
theta2=np.zeros((3,1))

接下来是测试我们之前的函数，computeCost(X, y, theta)和gradientDescent(X, y, theta, alpha, num_iters)是否适用于多特征输入

使用computeCost(X2,y2,theta2)给出65591548106.45744，这是使用θ(0，0，0)作为参数的成本

theta2, J_history2 = gradientDescent(X2,y2,theta2,0.01,400)
print("h(x) ="+str(round(theta2[0,0],2))+" + "+str(round(theta2[1,0],2))+"x1 + "+str(round(theta2[2,0],2))+"x2")

打印语句 print: h(x) =334302.06 + 99411.45x1 + 3267.01x2，它是优化后的θ值，四舍五入到小数点后两位

plt.plot(J_history2)
plt.xlabel("Iteration")
plt.ylabel("$J(\Theta)$")
plt.title("Cost function using Gradient Descent")

绘制J(θ)与迭代次数的关系图给出了一个下降趋势，证明我们的gradientDescent 函数也适用于多元情况

最后，使用优化后的θ值对一栋 1650 *方英尺、有 3 间卧室的房子进行预测。

*#feature normalisation of x values
x_sample = featureNormalization(np.array([1650,3]))[0]
x_sample=np.append(np.ones(1),x_sample)
predict3=predict(x_sample,theta2)
print("For size of house = 1650, Number of bedroom = 3, we predict a house value of $"+str(round(predict3,0)))*

此打印声明打印:For size of house = 1650, Number of bedroom = 3, we predict a house value of $430447.0

第一个练习到此为止。希望你能像我写它一样喜欢阅读它。请随时给我留下一些意见，告诉我如何改进。如果你想访问 Jupyter 笔记本来完成这个任务，我已经上传了 Github 中的代码(https://Github . com/Ben lau 93/Machine-Learning-by-Andrew-Ng-in-Python)。

对于本系列中的其他 python 实现，

• 逻辑回归
• 正则化逻辑回归
• 神经网络
• 支持向量机
• 无监督学习
• 异常检测

感谢阅读。

吴恩达的 Python(逻辑回归)机器学习课程

原文：https://towardsdatascience.com/andrew-ngs-machine-learning-course-in-python-logistic-regression-c0ae25509feb?source=collection_archive---------6-----------------------

Machine Learning – Andrew Ng

继续这个系列，这将是吴恩达关于逻辑回归的机器学习课程的 python 实现。

与标签为连续变量的线性回归相比，逻辑回归用于标签为离散类别数的分类问题。

和往常一样，我们从导入库和数据集开始。这个数据集包含 2 个不同的学生考试成绩和他们的大学录取状态。我们被要求根据学生的考试成绩来预测他们是否被大学录取。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pddf=pd.read_csv("ex2data1.txt",header=None)

理解数据

df.head()
df.describe()

数据绘图

pos , neg = (y==1).reshape(100,1) , (y==0).reshape(100,1)
plt.scatter(X[pos[:,0],0],X[pos[:,0],1],c="r",marker="+")
plt.scatter(X[neg[:,0],0],X[neg[:,0],1],marker="o",s=10)
plt.xlabel("Exam 1 score")
plt.ylabel("Exam 2 score")
plt.legend(["Admitted","Not admitted"],loc=0)

由于这不是标准的散点图或线图，为了便于理解，我将逐步分解代码。对于分类问题，我们将独立变量彼此相对绘制，并识别不同的类别以观察它们之间的关系。因此，我们需要区分导致大学录取的 x1 和 x2 的组合和没有导致大学录取的组合。变量pos和neg就是这样做的。通过用不同的颜色和标记画出被大学录取的 x1 和 x2 的组合，我们成功地将这种关系可视化。

两次考试分数都较高的学生果然被大学录取了。

区分逻辑回归和线性回归的 sigmoid 函数

def sigmoid(z):
    """
    return the sigmoid of z
    """

    return 1/ (1 + np.exp(-z))# testing the sigmoid function
sigmoid(0)

运行sigmoid(0)功能返回 0.5

计算成本函数 J(θ)和梯度(J(θ)相对于每个θ的偏导数)

def costFunction(theta, X, y):
    """
    Takes in numpy array theta, x and y and return the logistic regression cost function and gradient
    """

    m=len(y)

    predictions = sigmoid(np.dot(X,theta))
    error = (-y * np.log(predictions)) - ((1-y)*np.log(1-predictions))cost = 1/m * sum(error)

    grad = 1/m * np.dot(X.transpose(),(predictions - y))

    return cost[0] , grad

设置 initial_theta 并测试成本函数

m , n = X.shape[0], X.shape[1]
X= np.append(np.ones((m,1)),X,axis=1)
y=y.reshape(m,1)
initial_theta = np.zeros((n+1,1))
cost, grad= costFunction(initial_theta,X,y)
print("Cost of initial theta is",cost)
print("Gradient at initial theta (zeros):",grad)

打印语句将打印:初始角增量的成本是0.693147180559946初始角增量处的梯度(零):[-0.1],[-12.00921659],[-11.26284221]

现在是优化算法。在任务本身中，我们被告知使用 Octave 中的fminunc函数来寻找无约束函数的最小值。至于 python 实现，有一个库可以用于类似的目的。你可以在这里找到官方文档。有各种各样优化方法可供选择，在我之前，许多其他人都在他们的 python 实现中使用过这些方法。在这里，我决定使用梯度下降来进行优化，并将结果与 Octave 中的fminunc进行比较。

在进行梯度下降之前，永远不要忘记对多元问题进行特征缩放。

def featureNormalization(X):
    """
    Take in numpy array of X values and return normalize X values,
    the mean and standard deviation of each feature
    """
    mean=np.mean(X,axis=0)
    std=np.std(X,axis=0)

    X_norm = (X - mean)/std

    return X_norm , mean , std

正如讲座中提到的，梯度下降算法与线性回归非常相似。唯一的区别是假设 h(x) 现在是 g(θ^tx)其中 g 是 sigmoid 函数。

def gradientDescent(X,y,theta,alpha,num_iters):
    """
    Take in numpy array X, y and theta and update theta by taking num_iters gradient steps
    with learning rate of alpha

    return theta and the list of the cost of theta during each iteration
    """

    m=len(y)
    J_history =[]

    for i in range(num_iters):
        cost, grad = costFunction(theta,X,y)
        theta = theta - (alpha * grad)
        J_history.append(cost)

    return theta , J_history

我一直很喜欢干(不要重复自己)在编码上的说法。由于我们之前已经有了一个计算梯度的函数，我们就不重复计算了，在这里添加一个α项来更新θ。

由于作业没有实现梯度下降，我不得不测试一些 alpha 和 num_iters 值来找到最佳值。

使用alpha=0.01, num_iters=400，

梯度下降在每次迭代中降低成本函数，但是我们可以做得更好。用alpha = 0.1, num_iters =400，

好多了，但我会尝试另一个值，只是为了确保。与alpha=1, num_iters=400，

下降更剧烈，并且成本函数在 150 次迭代左右达到*稳。使用这个 alpha 和 num_iters 值，优化的θ是[1.65947664],[3.8670477],[3.60347302]，结果成本是0.20360044248226664。与最初的0.693147180559946相比有了显著的改进。与 Octave 中使用fminunc的优化成本函数相比，它与任务中获得的0.203498相差不远。

接下来是使用优化的θ绘制决策边界。在课程资源中有关于如何绘制决策边界的逐步解释。链接可以在这里找到。

plt.scatter(X[pos[:,0],1],X[pos[:,0],2],c="r",marker="+",label="Admitted")
plt.scatter(X[neg[:,0],1],X[neg[:,0],2],c="b",marker="x",label="Not admitted")
x_value= np.array([np.min(X[:,1]),np.max(X[:,1])])
y_value=-(theta[0] +theta[1]*x_value)/theta[2]
plt.plot(x_value,y_value, "r")
plt.xlabel("Exam 1 score")
plt.ylabel("Exam 2 score")
plt.legend(loc=0)

使用优化的 theta 进行预测

x_test = np.array([45,85])
x_test = (x_test - X_mean)/X_std
x_test = np.append(np.ones(1),x_test)
prob = sigmoid(x_test.dot(theta))
print("For a student with scores 45 and 85, we predict an admission probability of",prob[0])

打印语句将打印:对于一个分数为 45 和 85 的学生，我们预测录取概率为0.7677628875792492。使用fminunc非常接*0.776291。

为了找到分类器的准确性，我们计算训练集上正确分类的百分比。

def classifierPredict(theta,X):
    """
    take in numpy array of theta and X and predict the class 
    """
    predictions = X.dot(theta)

    return predictions>0p=classifierPredict(theta,X)
print("Train Accuracy:", sum(p==y)[0],"%")

如果被大学录取的概率大于 0.5，函数classifierPredict 返回一个带有True的布尔数组，否则返回False。取sum(p==y)将所有正确预测 y 值的实例相加。

print 语句 print: Train Accuracy: 89 %，表明我们的分类器正确预测了 89 %的训练集。

这都是为了逻辑回归。像往常一样，Jupyter 笔记本上传到我的 GitHub，网址是(https://GitHub . com/Ben lau 93/Machine-Learning-by-Andrew-Ng-in-Python)。

对于本系列中的其他 python 实现，

• 线性回归
• 正则化逻辑回归
• 神经网络
• 支持向量机
• 无监督学习
• 异常检测

感谢您的阅读。

吴恩达的 Python(神经网络)机器学习课程

原文：https://towardsdatascience.com/andrew-ngs-machine-learning-course-in-python-neural-networks-e526b41fdcd9?source=collection_archive---------5-----------------------

Machine Learning — Andrew Ng

本文将着眼于吴恩达的机器学习课程中关于神经网络的编程作业 3 和 4。这也是我们在课程中遇到的第一个复杂的非线性算法。我不知道你是怎么想的，但是对我来说，这个任务绝对有一个陡峭的学习曲线。神经网络形成深度学习的基础，深度学习具有广泛的应用，例如计算机视觉或自然语言处理。因此，获得最基本的权利是很重要的，用 python 编写这些赋值代码是确保这一点的一种方法。

B 在进入神经网络之前，让我们完成逻辑回归的最后一部分——多类逻辑回归。

这一系列练习利用了由 5000 个训练示例组成的手写数字数据集，其中每个示例都是数字的 20 像素乘 20 像素灰度图像。

加载数据集

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat# Use loadmat to load matlab files
mat=loadmat("ex3data1.mat")
X=mat["X"]
y=mat["y"]

因为数据集是在。mat 格式而不是通常的格式。txt 格式，我不得不使用 scipy loadmat 函数来完成这项工作。官方文档可以在这里找到。自装载垫装载以来。mat 文件作为一个以变量名为关键字的字典，给 X 和 y 赋值就像用变量的关键字访问字典一样简单。

X.shape, y.shape

为了更好地理解数据集，拥有数据的形状可以告诉我们数据的维度。X 具有对应于 5000 个训练样本的形状5000,400，每个训练样本具有来自其 20×20 像素的 400 个特征。y 有一个5000,1的形状，其中每个训练样本有一个从 1 到 10 的标签(在这个数据集中‘0’数字被标记为‘10’)。

可视化数据

import matplotlib.image as mpimg
fig, axis = plt.subplots(10,10,figsize=(8,8))
for i in range(10):
    for j in range(10):
        axis[i,j].imshow(X[np.random.randint(0,5001),:].reshape(20,20,order="F"), cmap="hot") #reshape back to 20 pixel by 20 pixel
        axis[i,j].axis("off")

上面的代码块构建了 100 个子情节，并使用 plt.imshow 从 5000 个训练示例中随机可视化 100 个。请注意，我们必须将训练样本重新整形回 20 X 20 像素，然后才能将其可视化，并将order="F"作为参数添加到整形函数中，以确保图像的方向是垂直的。

计算成本函数和梯度

def sigmoid(z):
    """
    return the sigmoid of z
    """

    return 1/ (1 + np.exp(-z))def lrCostFunction(theta, X, y, Lambda):
    """
    Takes in numpy array of theta, X, y, and float lambda to compute the regularized logistic cost function 
    """

    m=len(y)
    predictions = sigmoid(X @ theta)
    error = (-y * np.log(predictions)) - ((1-y)*np.log(1-predictions))
    cost = 1/m * sum(error)
    regCost= cost + Lambda/(2*m) * sum(theta[1:]**2)

    # compute gradient
    j_0= 1/m * (X.transpose() @ (predictions - y))[0]
    j_1 = 1/m * (X.transpose() @ (predictions - y))[1:] + (Lambda/m)* theta[1:]
    grad= np.vstack((j_0[:,np.newaxis],j_1))
    return regCost[0], grad

这类似于我们在逻辑回归任务中使用的成本函数。

theta_t = np.array([-2,-1,1,2]).reshape(4,1)
X_t =np.array([np.linspace(0.1,1.5,15)]).reshape(3,5).T
X_t = np.hstack((np.ones((5,1)), X_t))
y_t = np.array([1,0,1,0,1]).reshape(5,1)
J, grad = lrCostFunction(theta_t, X_t, y_t, 3)
print("Cost:",J,"Expected cost: 2.534819")
print("Gradients:\n",grad,"\nExpected gradients:\n 0.146561\n -0.548558\n 0.724722\n 1.398003")

现在是分类任务。由于我们有不止一个类，我们将不得不使用一对一的分类方法来训练多个逻辑回归分类器(每个类一个分类器)。

def gradientDescent(X,y,theta,alpha,num_iters,Lambda):
    """
    Take in numpy array X, y and theta and update theta by taking num_iters gradient steps
    with learning rate of alpha

    return theta and the list of the cost of theta during each iteration
    """

    m=len(y)
    J_history =[]

    for i in range(num_iters):
        cost, grad = lrCostFunction(theta,X,y,Lambda)
        theta = theta - (alpha * grad)
        J_history.append(cost)

    return theta , J_history def oneVsAll(X, y, num_labels, Lambda):
    """
    Takes in numpy array of X,y, int num_labels and float lambda to train multiple logistic regression classifiers
    depending on the number of num_labels using gradient descent. 

    Returns a matrix of theta, where the i-th row corresponds to the classifier for label i
    """
    m, n = X.shape[0], X.shape[1]
    initial_theta = np.zeros((n+1,1))
    all_theta = []
    all_J=[]
    # add intercept terms

    X = np.hstack((np.ones((m,1)),X))

    for i in range(1,num_labels+1):
        theta , J_history = gradientDescent(X,np.where(y==i,1,0),initial_theta,1,300,Lambda)
        all_theta.extend(theta)
        all_J.extend(J_history)
    return np.array(all_theta).reshape(num_labels,n+1), all_J

gradientDescent函数是我们之前实现的常用优化函数。至于oneVsAll，它遍历所有的类，并使用梯度下降为每个类训练一组θ(在赋值中使用了fmincg函数)。all_theta然后在一个列表中捕获所有优化的 theta，并作为一个 numpy 数组返回，重新整形为一个 theta 矩阵，其中第 I 行对应于标签 I 的分类器。np.where在这里派上用场，为每个类获取一个 1/0 的 y 向量，以在每次迭代中执行我们的二元分类任务。

绘制成本函数只是为了确保梯度下降按预期工作

plt.plot(all_J[0:300])
plt.xlabel("Iteration")
plt.ylabel("$J(\Theta)$")
plt.title("Cost function using Gradient Descent")

alpha = 1, num_iters = 300

为了进行预测，计算每个类别的 x(i)的概率，并且该预测是具有最高概率的类别

def predictOneVsAll(all_theta, X):
    """
    Using all_theta, compute the probability of X(i) for each class and predict the label

    return a vector of prediction
    """
    m= X.shape[0]
    X = np.hstack((np.ones((m,1)),X))

    predictions = X @ all_theta.T
    return np.argmax(predictions,axis=1)+1pred = predictOneVsAll(all_theta, X)
print("Training Set Accuracy:",sum(pred[:,np.newaxis]==y)[0]/5000*100,"%")

打印报表打印:Training Set Accuracy: 91.46 %

最后，神经网络的时间到了。对于相同的数据集，我们旨在使用更复杂的算法(如神经网络)来实现更高的准确性。对于练习的第一部分，优化的θ值被给我们，我们应该实现前馈传播以获得预测和模型精度。

优化 theta 的加载

mat2=loadmat("ex3weights.mat")
Theta1=mat2["Theta1"] # Theta1 has size 25 x 401
Theta2=mat2["Theta2"] # Theta2 has size 10 x 26

使用前馈传播进行预测

def predict(Theta1, Theta2, X):
    """
    Predict the label of an input given a trained neural network
    """
    m= X.shape[0]
    X = np.hstack((np.ones((m,1)),X))

    a1 = sigmoid(X @ Theta1.T)
    a1 = np.hstack((np.ones((m,1)), a1)) # hidden layer
    a2 = sigmoid(a1 @ Theta2.T) # output layer

    return np.argmax(a2,axis=1)+1pred2 = predict(Theta1, Theta2, X)
print("Training Set Accuracy:",sum(pred2[:,np.newaxis]==y)[0]/5000*100,"%")

打印报表打印:Training Set Accuracy: 97.52 %。与多类逻辑回归相比，准确度高得多！

在作业 4 中，我们从零开始实现一个神经网络。我们从计算成本函数和θ的梯度开始。

def sigmoidGradient(z):
    """
    computes the gradient of the sigmoid function
    """
    sigmoid = 1/(1 + np.exp(-z))

    return sigmoid *(1-sigmoid) def nnCostFunction(nn_params,input_layer_size, hidden_layer_size, num_labels,X, y,Lambda):
    """
    nn_params contains the parameters unrolled into a vector

    compute the cost and gradient of the neural network
    """
    # Reshape nn_params back into the parameters Theta1 and Theta2
    Theta1 = nn_params[:((input_layer_size+1) * hidden_layer_size)].reshape(hidden_layer_size,input_layer_size+1)
    Theta2 = nn_params[((input_layer_size +1)* hidden_layer_size ):].reshape(num_labels,hidden_layer_size+1)

    m = X.shape[0]
    J=0
    X = np.hstack((np.ones((m,1)),X))
    y10 = np.zeros((m,num_labels))

    a1 = sigmoid(X @ Theta1.T)
    a1 = np.hstack((np.ones((m,1)), a1)) # hidden layer
    a2 = sigmoid(a1 @ Theta2.T) # output layer

    for i in range(1,num_labels+1):
        y10[:,i-1][:,np.newaxis] = np.where(y==i,1,0)
    for j in range(num_labels):
        J = J + sum(-y10[:,j] * np.log(a2[:,j]) - (1-y10[:,j])*np.log(1-a2[:,j]))

    cost = 1/m* J
    reg_J = cost + Lambda/(2*m) * (np.sum(Theta1[:,1:]**2) + np.sum(Theta2[:,1:]**2))

    # Implement the backpropagation algorithm to compute the gradients

    grad1 = np.zeros((Theta1.shape))
    grad2 = np.zeros((Theta2.shape))

    for i in range(m):
        xi= X[i,:] # 1 X 401
        a1i = a1[i,:] # 1 X 26
        a2i =a2[i,:] # 1 X 10
        d2 = a2i - y10[i,:]
        d1 = Theta2.T @ d2.T * sigmoidGradient(np.hstack((1,xi @ Theta1.T)))
        grad1= grad1 + d1[1:][:,np.newaxis] @ xi[:,np.newaxis].T
        grad2 = grad2 + d2.T[:,np.newaxis] @ a1i[:,np.newaxis].T

    grad1 = 1/m * grad1
    grad2 = 1/m*grad2

    grad1_reg = grad1 + (Lambda/m) * np.hstack((np.zeros((Theta1.shape[0],1)),Theta1[:,1:]))
    grad2_reg = grad2 + (Lambda/m) * np.hstack((np.zeros((Theta2.shape[0],1)),Theta2[:,1:]))

    return cost, grad1, grad2,reg_J, grad1_reg,grad2_reg

该赋值一步一步地遍历整个过程，首先计算成本，然后是正则化成本、梯度，最后是正则化梯度。如果您想继续，我修改了代码，只要您使用正确的索引，它就会返回中间步骤的值。

input_layer_size  = 400
hidden_layer_size = 25
num_labels = 10
nn_params = np.append(Theta1.flatten(),Theta2.flatten())
J,reg_J = nnCostFunction(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, 1)[0:4:3]
print("Cost at parameters (non-regularized):",J,"\nCost at parameters (Regularized):",reg_J)

flatten()这里的函数将数组折叠成一维，而np.append将参数“展开”成一个向量。

讲座中讨论了初始θ的对称性问题。为了打破这种对称性，需要随机初始化。

def randInitializeWeights(L_in, L_out):
    """
    randomly initializes the weights of a layer with L_in incoming connections and L_out outgoing connections.
    """

    epi = (6**1/2) / (L_in + L_out)**1/2

    W = np.random.rand(L_out,L_in +1) *(2*epi) -epi

    return Winitial_Theta1 = randInitializeWeights(input_layer_size, hidden_layer_size)
initial_Theta2 = randInitializeWeights(hidden_layer_size, num_labels)
initial_nn_params = np.append(initial_Theta1.flatten(),initial_Theta2.flatten())

最后，轮到我们使用前馈传播和反向传播来优化θ值。我使用的优化算法还是以前的梯度下降法。

def gradientDescentnn(X,y,initial_nn_params,alpha,num_iters,Lambda,input_layer_size, hidden_layer_size, num_labels):
    """
    Take in numpy array X, y and theta and update theta by taking num_iters gradient steps
    with learning rate of alpha

    return theta and the list of the cost of theta during each iteration
    """
    Theta1 = initial_nn_params[:((input_layer_size+1) * hidden_layer_size)].reshape(hidden_layer_size,input_layer_size+1)
    Theta2 = initial_nn_params[((input_layer_size +1)* hidden_layer_size ):].reshape(num_labels,hidden_layer_size+1)

    m=len(y)
    J_history =[]

    for i in range(num_iters):
        nn_params = np.append(Theta1.flatten(),Theta2.flatten())
        cost, grad1, grad2 = nnCostFunction(nn_params,input_layer_size, hidden_layer_size, num_labels,X, y,Lambda)[3:]
        Theta1 = Theta1 - (alpha * grad1)
        Theta2 = Theta2 - (alpha * grad2)
        J_history.append(cost)

    nn_paramsFinal = np.append(Theta1.flatten(),Theta2.flatten())
    return nn_paramsFinal , J_historynnTheta, nnJ_history = gradientDescentnn(X,y,initial_nn_params,0.8,800,1,input_layer_size, hidden_layer_size, num_labels)
Theta1 = nnTheta[:((input_layer_size+1) * hidden_layer_size)].reshape(hidden_layer_size,input_layer_size+1)
Theta2 = nnTheta[((input_layer_size +1)* hidden_layer_size ):].reshape(num_labels,hidden_layer_size+1)

对执行代码的人的警告。根据您的计算能力，计算将花费相当多的时间，如果您正在优化 alpha 和 num_iters 值，时间甚至会更长。我对 alpha 使用 0.8，对 num_iters 使用 800，但是我相信通过更多的调整可以得到更好的精确度。

pred3 = predict(Theta1, Theta2, X)
print("Training Set Accuracy:",sum(pred3[:,np.newaxis]==y)[0]/5000*100,"%")

至此，我已经完成了这个系列的一半。Jupyter 笔记本会上传到我的 GitHub 上(https://GitHub . com/Ben lau 93/Machine-Learning-by-Andrew-Ng-in-Python)。

对于本系列中的其他 python 实现，

• 线性回归
• 逻辑回归
• 正则化逻辑回归
• 支持向量机
• 无监督学习
• 异常检测

感谢您的阅读。

吴恩达的机器学习教程 Python(正则化 Logistic 回归)+ Lasso 回归

原文：https://towardsdatascience.com/andrew-ngs-machine-learning-course-in-python-regularized-logistic-regression-lasso-regression-721f311130fb?source=collection_archive---------8-----------------------

Machine Learning — Andrew Ng

从编程任务 2 (逻辑回归)继续，我们现在将继续进行 python 中的正则化逻辑回归，以帮助我们处理过度拟合的问题。

正则化是收缩方法，通过减少模型的方差，将系数收缩到零，以防止过度拟合。

直接进入任务，我们从导入所有相关的库和数据集开始。这一次，数据集包含了一个工厂中微芯片的两个测试结果，我们将使用测试结果来预测微芯片应该被接受还是被拒绝。

import numpy as np
import pandas as pd
import matplotlib.pyplot as pltdf=pd.read_csv("ex2data2.txt", header=None)
df.head()
df.describe()

如您所见，这是一个多变量、二元分类问题，我们可以使用逻辑回归来解决。

现在来看数据。与之前的逻辑回归可视化一样，x1 和 x2 的每种组合导致接受微芯片，相对于导致拒绝的组合作图

X=df.iloc[:,:-1].values
y=df.iloc[:,-1].valuespos , neg = (y==1).reshape(118,1) , (y==0).reshape(118,1)
plt.scatter(X[pos[:,0],0],X[pos[:,0],1],c="r",marker="+")
plt.scatter(X[neg[:,0],0],X[neg[:,0],1],marker="o",s=10)
plt.xlabel("Test 1")
plt.ylabel("Test 2")
plt.legend(["Accepted","Rejected"],loc=0)

绘制数据清楚地表明，区分不同类别的决策边界是非线性的。这导致下一步的特征映射，我们添加额外的多项式项来尝试和更好地拟合数据(正常的逻辑回归只能拟合线性决策边界，在这种情况下不会做得很好)。在作业中决定，我们将增加多项式的 6 次方项。

def mapFeature(x1,x2,degree):
    """
    take in numpy array of x1 and x2, return all polynomial terms up to the given degree
    """
    out = np.ones(len(x1)).reshape(len(x1),1)
    for i in range(1,degree+1):
        for j in range(i+1):
            terms= (x1**(i-j) * x2**j).reshape(len(x1),1)
            out= np.hstack((out,terms))
    return outX = mapFeature(X[:,0], X[:,1],6)

mapFeature函数还将一列 1 加到 X 上，这样我们就不必在以后处理它了。这里，我决定使用np.hstack而不是np.append向 numpy 数组添加一个新列。我发现与我通常使用的np.append相比，np.hstack的代码更加简洁。在这里，我允许 degree 作为一个参数，而不是像在作业中那样将其固定为 6，可以随意使用不同的 degree 并比较结果。

这个图表有助于形象化我们正在做的事情和涉及的多项式项。

接下来，我们继续定义计算正则化成本函数和梯度的函数。请记住，成本函数现在有一个由λ控制的附加收缩损失。

def sigmoid(z):
    """
    return the sigmoid of z
    """

    return 1/ (1 + np.exp(-z))def costFunctionReg(theta, X, y ,Lambda):
    """
    Take in numpy array of theta, X, and y to return the regularize cost function and gradient
    of a logistic regression
    """

    m=len(y)
    y=y[:,np.newaxis]
    predictions = sigmoid(X @ theta)
    error = (-y * np.log(predictions)) - ((1-y)*np.log(1-predictions))
    cost = 1/m * sum(error)
    regCost= cost + Lambda/(2*m) * sum(theta**2)

    # compute gradient
    j_0= 1/m * (X.transpose() @ (predictions - y))[0]
    j_1 = 1/m * (X.transpose() @ (predictions - y))[1:] + (Lambda/m)* theta[1:]
    grad= np.vstack((j_0[:,np.newaxis],j_1))
    return regCost[0], grad

您可以使用相同的costFunction代码并添加一个λ项来计算正则化成本函数。根据官方 numpy 文档，我发现用@替换np.dot是矩阵乘法的首选选项。写@也容易多了，所以我觉得很酷。如果你不熟悉 numpy 广播，你可以在这里查看。广播是我需要使用y=y[:,np.newaxis]给 y 添加一个新轴的原因，以确保线性代数操作如我所料。如果你已经注意到了，我在之前的实现中使用了reshape()来处理广播(告诉你们我正在边做边学)。顺便说一下，np.vstack在这里添加到新的一行而不是一列，用于np.hstack。

# Initialize fitting parameters
initial_theta = np.zeros((X.shape[1], 1))# Set regularization parameter lambda to 1
Lambda = 1#Compute and display initial cost and gradient for regularized logistic regression
cost, grad=costFunctionReg(initial_theta, X, y, Lambda)print("Cost at initial theta (zeros):",cost)

打印报表 print:初始θ(零)处的成本:0.6931471805599461

至于优化算法，我再次使用标准梯度下降，而不是fminunc。python 做fminunc的方式可以在这里找到。

def gradientDescent(X,y,theta,alpha,num_iters,Lambda):
    """
    Take in numpy array X, y and theta and update theta by taking num_iters gradient steps
    with learning rate of alpha

    return theta and the list of the cost of theta during each iteration
    """

    m=len(y)
    J_history =[]

    for i in range(num_iters):
        cost, grad = costFunctionReg(theta,X,y,Lambda)
        theta = theta - (alpha * grad)
        J_history.append(cost)

    return theta , J_historytheta , J_history = gradientDescent(X,y,initial_theta,1,800,0.2)print("The regularized theta using ridge regression:\n",theta)

print 语句将打印:

同样，没有给出 alpha、num_iters 和λ值，尝试一些值的组合，得出最佳值。

plt.plot(J_history)
plt.xlabel("Iteration")
plt.ylabel("$J(\Theta)$")
plt.title("Cost function using Gradient Descent")

使用我陈述的值，这是相对于迭代次数绘图的结果成本函数。

降低成本函数—检查
成本函数*稳—检查

def mapFeaturePlot(x1,x2,degree):
    """
    take in numpy array of x1 and x2, return all polynomial terms up to the given degree
    """
    out = np.ones(1)
    for i in range(1,degree+1):
        for j in range(i+1):
            terms= (x1**(i-j) * x2**j)
            out= np.hstack((out,terms))
    return outplt.scatter(X[pos[:,0],1],X[pos[:,0],2],c="r",marker="+",label="Admitted")
plt.scatter(X[neg[:,0],1],X[neg[:,0],2],c="b",marker="x",label="Not admitted")# Plotting decision boundaryu_vals = np.linspace(-1,1.5,50)
v_vals= np.linspace(-1,1.5,50)
z=np.zeros((len(u_vals),len(v_vals)))
for i in range(len(u_vals)):
    for j in range(len(v_vals)):
        z[i,j] =mapFeaturePlot(u_vals[i],v_vals[j],6) @ thetaplt.contour(u_vals,v_vals,z.T,0)
plt.xlabel("Exam 1 score")
plt.ylabel("Exam 2 score")
plt.legend(loc=0)

绘制非线性决策边界，包括绘制分隔不同类别的等高线。我做了一些谷歌搜索，这个 stackoverflow 答案可能会对在座的一些人有所帮助。代码只是简单的翻译了作业中给出的八度音阶代码，为了代码背后的数学和直觉，请查看上面给出的 stackoverflow 链接。

我会说非常好！

为了检查模型的准确性，我们再次利用训练数据的正确分类百分比。

def classifierPredict(theta,X):
    """
    take in numpy array of theta and X and predict the class 
    """
    predictions = X.dot(theta)

    return predictions>0p=classifierPredict(theta,X)
print("Train Accuracy:", (sum(p==y[:,np.newaxis])/len(y) *100)[0],"%")

打印报表打印:训练精度:83.05084745762711%。接*，但没有使用fminunc在赋值中获得的88.983051%高。

接下来，我想谈谈套索回归，另一种用于防止过度拟合的正则化方法。参考《统计学习导论》，Lasso 回归比岭回归(我们刚刚做的正则化)有明显的优势。也就是说，虽然岭回归将系数缩小到零，但它永远不会将其减小到零，因此，无论系数的值有多小，所有要素都将包含在模型中。另一方面，套索回归能够将系数缩小到恰好为零，减少特征的数量，同时充当特征选择工具。这使得套索回归在高维情况下很有用，并有助于模型的可解释性。

对于 Lasso 回归，要最小化的成本函数与岭回归非常相似。

它不是将θ*方之和相加，而是使用绝对值，由于它涉及绝对值，计算起来很困难，因为它是不可微的。各种算法可用于计算这一点，使用 sklearn 库可以找到一个这样的例子。

from sklearn.linear_model import LogisticRegressionclf = LogisticRegression(penalty="l1")
clf.fit(X,y)thetaLasso=clf.coef_
print("The regularized theta using lasso regression:\n",thetaLasso.reshape(28,1))

θ值的并排比较。

如您所见，lasso 回归将几个要素减少到 0，从而降低了问题的维度并提高了模型的可解释性。

这是我所有的正规化。Jupyter 笔记本会上传到我的 GitHub 上(https://GitHub . com/Ben lau 93/Machine-Learning-by-Andrew-Ng-in-Python)。

对于本系列中的其他 python 实现，

• 线性回归
• 逻辑回归
• 神经网络
• 支持向量机
• 无监督学习
• 异常检测

感谢您的阅读。