TowardsDataScience-博客中文翻译-2016-2018-三十八-

TowardsDataScience 博客中文翻译 2016~2018（三十八）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

Python 属性的原因和方式

原文：https://towardsdatascience.com/the-why-and-how-of-python-properties-b791817cf4b9?source=collection_archive---------3-----------------------

https://cdn.programiz.com/sites/tutorial2program/files/python-property.jpg

一个现实世界的问题

大约一年前，我们在我目前的工作中遇到了一个有趣的障碍:我们的计算机视觉管道消耗了太多的内存。拥有 10gb 可用内存和一个相当大的交换分区的机器正在猛烈地颠簸。经过一些调查，我们意识到这是我们在流水线开始时将一个任务的所有相关输入图像加载到内存中的结果。当流水线第一次组装时，每个作业的最大图像数量约为 20 个，这并不是一个问题，但这个数字突然开始增长。我们在一个有 210 个图像的作业中发现了这个问题，一个 52 兆的图像占用了 11 兆的内存。

太好了。我们遇到了一个问题。解决这一难题的简单方法是只在需要的时候将图像加载到内存中，而不要保留对它的不必要的引用。这是一个不错的解决方案(尽管它本身有一些问题是可以解决的，但我不会在本文中深入讨论)，但这似乎需要大量的重构。为了理解为什么，请允许我向您展示一些(非常简单的)示例代码:

# The class that holds onto the image
class ImageHolder:def __init__(self, image_path):self.image = load_image_from_path(image_path) holders = []
# The bit of code that loads the images
for image_path in large_list_of_paths:holders.append(ImageHolder(image_path)) # Various parts of the pipeline that do something with the images
for holder in holders:do_something(holder.image)

现实世界的解决方案

在大多数其他语言(如 C++)中，最简单的解决方案是:

class ImageHolder:def __init__(self, image_path):self.image_path = image_path def get_image(self):return load_image_from_path(self.image_path)

但是这产生了一个问题:我们现在必须确保所有对ImageHolder.image的引用都变成了ImageHolder.get_image()。我们还需要确保程序员记得更改未来的代码(尽管有些人会认为我们应该从一开始就这样做，如果属性不存在，我也会同意)。虽然这两个任务都不是特别重要的任务，但是它们仍然很烦人，而且它们扰乱了代码本身的语义(也就是说，operate_on(holder.image)比operate_on(holder.get_image())读起来要好得多)。谢天谢地，在 python 中，我们可以这样做:

class ImageHolder:def __init__(self, image_path):self.image_path = image_path@property
def image(self):return load_image_from_path(self.image_path)

现在ImageHolder.image(看起来不像函数调用)返回图像，就好像它是一个指向图像的字段。这个就是 python 属性的魔力。他们将我们从最初糟糕的设计中解救出来(从一开始就没有设置 getters 和 setters ),同时使我们的代码看起来不那么笨拙。

另一个不太“现实”的例子

当然，使用这样的抽象还有无数的其他原因，它确实有助于保持对象中的状态的总大小较小，并提高可维护性。考虑一个Circle类的简单实现:

PI = 3.141
class Circle:def init(self, radius):self.radius = radiusself.area = PI * self.radius ** 2self.circumference = 2 * PI * self.radius

并按以下方式使用它:

c = Circle(1)
print c.area  # prints 3.141
print c.circumference  # prints 6.282c.radius = 2
print c.area  # prints 3.141 which is incorrect
print c.circumference  # prints 6.282 which is incorrect

一旦我们更改了radius,area和circumference字段在更新之前都是无用的(我们可以在这里使用 setters 来缓解这种情况，但那是另一篇文章了)。与下面的实现进行比较:

PI = 3.141
class Circle:def init(self, radius):self.radius = radius def area(self):return PI * self.radius ** 2 def circumference(self):    return 2 * PI * self.radius

再次对其运行相同的测试，我们得到:

c = Circle(1)
print c.area  # prints 3.141
print c.circumference  # prints 6.282c.radius = 2
print c.area  # prints 12.564 which is correct!
print c.circumference  # prints 12.564 which is correct!

只有radius成为该对象的状态才有意义，因为其他两个值都可以从中导出。Python 属性允许我们封装这种现实，而不会使语法看起来笨拙。

结论

我想展示 Python 属性在现实环境中的用处。我希望这篇文章能做到这一点。关于属性(以及设置器)更详细的讨论可以在这里找到。我将在另一篇文章中讨论 setters，在那篇文章中，我将解释如何更新一个没有加载到内存中的图像(以及其他内容)。

纵横字谜数据的疯狂世界

原文：https://towardsdatascience.com/the-wild-world-of-crossword-data-71d560e222f5?source=collection_archive---------6-----------------------

Photo by Natalia Ostashova on Unsplash

我一直很喜欢填字游戏。我妈妈和姐妹们会从《蒙特利尔公报》上翻出《纽约时报》的填字游戏，一起研究，有时还会问我一个与体育相关的问题。

快进到 30+ Kurt，现在自己解决满满的谜题，像个真正的男孩。不过，我真正喜欢上它是在最近的圣诞节假期，当时我们在圣阿黛尔的 Lac Pilon 湖边小屋的室外温度是零下 31 华氏度。不用说，我们大部分时间都是在噼啪作响的炉火旁啜饮温暖的东西。尽管天气寒冷，但这是一个愉快的假期，在没有有线电视(和相当不稳定的 wifi)的情况下，我们通过做填字游戏来打发时间。

现在，回到纽约，那里的天气不太冷，我认为自己是一个十足的拼图迷，我用几种不同的方式解决问题:

• 因为我可爱的母亲每天早上仍然会收到一份真正的报纸，所以她很友好地扫描并通过电子邮件将每一份 NYT 填字游戏发给我和我的女朋友(我们会立即打印出来并添加到我们专用的填字剪贴板上)。
• 我买了 NYT 的数字订阅(我知道，很疯狂，对吧？)只是为了进入他们的填字游戏。是的，这确实复制了妈妈发送的内容，但它也让我可以访问每天的迷你，非常适合地铁通勤。
• 说到地铁通勤，我的很长。因此，如果我没有什么小事情要做，我有时会通过解决脑海中的几个线索来挠我的纵横字谜之痒，同时从某人的肩膀上偷看他们的地铁谜题(令人毛骨悚然还是资源丰富？).

NYT 填字游戏有什么大不了的？

我在这里转述了维基百科的内容，但基本上这是一个由《纽约时报》发布的每日谜题，还被其他 300 多家报纸和出版物转载(这是我妈妈在蒙特利尔得到的)。

它有一大堆不同的贡献者，但自 1993 年以来一直由老威尔·肖兹编辑。一周中的每一天，谜题都变得越来越难，最容易的是周一，最难的是周六(周日是一个更大的谜题，通常等同于周四的难度)。随着时间的推移，我已经很适应周一和周二了，但要完成整个周三的拼图还是有些困难。

历史说够了，来说数据吧

多亏了迈克尔，我得以获得一份相当大的数据转储，其中包括从 1993 年 12 月到 2017 年 7 月的 NYT 填字游戏数据。接下来我做了什么？嗯，首先我放下了正在做的周三填字游戏，然后就一头扎进去了。

将数据上传到 Google Cloud，并在 BigQuery 中运行一些 SQL 查询后，我发现了一些有趣的事实:

有趣的事实

• 24.5 年
• 8238 个谜题
• 432205 条线索
• 108，423 个唯一答案
• 54，820 个(或 51%)唯一答案从未被使用超过一次

好，等等，这意味着 49%的唯一答案被多次使用？！

嗯，有意思，我想知道哪些词用得最频繁…

10 个最常用的答案(谜题出现的百分比)

那么，我们得到了什么？它看起来像一组短词，可以很容易地用来填补较长答案留下的空白。看到像 E 、 A 和 R 这样的字母突出也很有趣，因为它们是英语中最常用的三个字母(根据牛津词典)。这三个字母加起来占英语的 27.24%，而对于 NYT，它们占最常用答案的 68.75%(32 个字符中的 22 个)。

快速提示:根据这些数据，你大概可以预计到 纪元 这个词大约每 2.4 周出现一次。(记住，这个线索可能与时间、棒球或平等权利有关。)

好奇看看这一周的每一天是如何分解的吗？我抓住你了。

一周中最常用的 10 个答案

我还研究了线索的长度。我发现它们可以是简短的一个单词的线索，也可以是更长的句子甚至段落。由于谜题的难度随着一周的进展而变化，我认为观察平均线索字符数在一周内的变化可能会很酷。

每周各天的平均线索字符数

好了，这就对了，一清二楚:更高的难度=更长的线索

从周三到周六，平均字符数每天都在增加，我们可以自信地说，越长的线索通常越难找到。这可能只是我，但我发现这很令人满意，周日平均字符数下降到几乎与周四完全相同的水平(记得我之前提到过周日是更大的谜题，但与周四的难度水平大致相同)。

我无法解释的一件事是，为什么从周一到周三，线索长度略有下降。 有人有什么想法吗？？

如果你曾经做过(甚至看过)填字游戏，你就会知道有两个方向的线索和答案:横向和纵向。所以，我研究的最后一件事是基于方向的线索长度是否有差异。

按回答方向列出的平均线索字符数(&星期几)

好吧，这个没什么进展。这里没什么可看的，但让我们试着延伸一下。如果我们先前确定较长的线索通常意味着较难的线索，那么根据上面的数据，我们可以说:

向下的线索比交叉的容易。_(ツ)_/

好了，今天就到这里，各位。我得去煮些咖啡，然后回到这个讨厌的星期三。有人知道六个字母的单词“乔”吗？

使用的工具

谷歌云存储，谷歌大查询，Excel，GitHub，infogram

话加起来！

原文：https://towardsdatascience.com/the-words-add-up-why-baseball-usa-india-cricket-d31b595b8df4?source=collection_archive---------7-----------------------

Image by Julia_S from Pixabay

当你学习数学的时候，你有没有想过除了数字之外的东西？如果 1 + 2 = 3，那你为什么不能说“绿色+水果=苹果？”

今天，当我们向人工智能的婴儿大脑教授人类世界时，事实证明我们可以做到。为了教会机器理解人类语言，我们必须教会它们单词之间的关系。一种方法是用大量文本训练一个算法。幸运的是，我们的社会擅长的一件事是生成大量的文本！

我遇到的第一个尝试是马尔可夫链技术。马尔可夫链的思想是，你可以通过知道当前事件来预测一系列事件中下一步的概率。想想手机上的自动完成功能是如何工作的。

通过用示例数据训练机器，您可以预测一个序列的下一个可能结果。马尔可夫链有很多有趣的应用，比如计算机生成的音乐。如果你用自然语言训练它们，你可以创造出表面上看起来像语言的句子，而且通常是非常有趣的。看看“schmimpsum”，它可以让你根据各种来源生成填充文本，包括莎士比亚和公司使命声明:

我们的市民聚集在一起向博伊西市的哈佛大学学习。积极主动地计划绝对诚实、勤奋、能力、智慧和全面的计划。

然而，马尔可夫链对于语言学应用来说过于简单。单词之间有许多比“很可能被用作下一个单词”更有用的关系。

输入 Word2Vec

随着计算语言学领域的发展，计算机已经发明了许多不同的单词表示法。在数学上产生惊人结果的那个叫做 Word2Vec ，由谷歌发明，于 2013 年发表。你可能会天真地想象计算机会给每个词汇分配一个唯一的 ID 号，而不是给这个词分配一个数字向量。如果你回忆一下你的几何，这些向量就像坐标一样，可以通过加法和减法来操作。[0 1] + [1 2] = [1 3]以此类推。

为了获得 Word2Vec 如何工作的心理模型，可以把它想象成试图根据单词的意思在图表上排列单词。您希望看似相关的单词在图表上彼此靠近，因此它们的坐标是接近的。所以“妈妈”和“姐姐”将会彼此靠近。当然，两个维度不足以代表所有的关系。“Pup”像“kitten”一样，因为它们是幼小的动物，但它也像“dog”、“pet”和“seal”…你很快就会用不完。所以在计算机中，我们倾向于使用几百维而不是二维。在这个过程的开始，单词被随机放在图表上，然后算法被输入大量的示例文本。每当单词在句子中彼此靠近时，它们在图表上就彼此靠近一点。给定足够多的示例文本，图表最终编码了大量关于单词如何关联的知识。

结果，正如“Word2Vec”的名字所暗示的，每个单词最终都被分配了一个向量。然后，有趣的事情开始了，你可以像这样做一些有趣的数学运算:

国王+(女人-男人)=王后

巴黎+(意大利-法国)=罗马

换句话说，在我们的图表上，无论首都意味着什么，都是在一个特定的“方向”上，所以如果你把意大利推向那个方向，你就会到达罗马。好玩！一个有趣的应用是在语言翻译中，毕竟为什么“two-English+Spanish = dos”不会呢？事实上，一个更加复杂的系统现在支持谷歌翻译，甚至可以在以前从未遇到过的语言对之间进行翻译。

将事物转化为向量的整个概念也适用于其他问题领域。来自餐馆预订网站 OpenTable 的数据科学家们尝试对他们的数据使用向量表示。例如，他们发现，如果你在市中心一家牛排店的名字前加上“天井”,你会发现这家牛排店有一个很大的天井！或者，如果你正在旅行，想在家里找一家与你最喜欢的餐馆相似的餐馆。他们发现

旧金山阿基罗餐厅+芝加哥=芝加哥正木寿司

如果你很好奇，可以看看这个矢量类型模型列表，其中包括了其他领域的论文和例子。我最喜欢的一个是棒球模型，它将击球手和投手的统计数据编码成向量。它包括一些有趣的例子，如寻找球员的“反手二重身”。例如:

迈克·特劳特–左撇子+右撇子=布莱斯·哈珀

除了充满乐趣之外，这种数学还让我们更接近一种自动化的方式，让机器了解现实世界实体之间的关系——这种事情太复杂，太令人厌倦，无法通过显式枚举来教授。结果可以用来回答现实世界的问题。

数据可视化的世界

原文：https://towardsdatascience.com/the-world-of-data-visualization-d4b621b77e76?source=collection_archive---------4-----------------------

不管你在哪里工作或做什么，你周围的一切都是由指标定义的。波士顿的房子价格是多少？你的汽车行驶了多少英里？星巴克每年卖出多少杯咖啡？更重要的是，你应该产生多大的影响才能在职业生涯中迈出下一大步？

作为人类，我们喜欢我们所有的问题都得到简洁而全面的回答。多年来，数据可视化技术变得越来越复杂。可能是使用最先进的 GIS 系统来表达野火数据，使用 Tableau、 D3.js 和 Bokeh 的组合向您的潜在投资者提供市场预测，使用平行坐标来表达更高维度的数据，甚至是使用 MS Excel 的老式数字处理。数据可视化的最大创新发生在我们自己的大数据领域，我们需要找到一种复杂的方法，以巧妙的可视化指标来查看数百万个数据点。只需谷歌和探索！

有了这些复杂的数据可视化技术，我确信你们中的很多人想从简单的东西开始。虽然 MS Excel 是一个快速而简单的选项，但在如何处理数据、操作绘图手柄的级别以及在各种媒体(如 web 界面、图形用户界面和移动应用程序)上共享绘图手柄方面缺乏灵活性。依我拙见，Matplotlib 是一个极好的开端。

Matplotlib 是一个开源的 Python 库，拥有广泛的开发者社区。几乎任何复杂的可视化问题都可以通过 Matplotlib 丰富的函数数组轻松解决。语法相当类似于 Matlab ( 点击这里了解详情)和 Octave ，对于那些想要快速转换的人来说。最重要的是，绘图句柄可以与各种基于 Python 的应用程序无缝连接。

至此，下面是我关于 Matplotlib 的基础教程，可以帮助大家踏上数据可视化的伟大旅程:

xtensor 视觉

原文：https://towardsdatascience.com/the-xtensor-vision-552dd978e9ad?source=collection_archive---------11-----------------------

在这里，我们展示了 xtensor 项目的愿景，即 C++语言中的 n 维数组——这使得编写高性能代码并将其绑定到数据科学语言(Python、Julia 和 R)变得很容易。

Results of running the same C++ implementation from Julia, Python, R, and C++ (from left to right)

展示一个清晰的愿景是很重要的——尤其是对于开源项目:只有一个共同的目标才能把人们聚集在一起。这就是为什么我们决定最终整理出一份文件，展示我们对 C++如何在数据科学的未来发挥重要作用的愿景，以及为什么。当今数据科学的三种主要语言是 Python、Julia 和 r。

Python 科学计算生态系统中有很多很酷的库是其他语言所没有的，比如 Julia 和 R——反之亦然。例如，scikit-learn 是一个专用的 Python 包。变通办法通常是从 Julia 调用 Python 解释器，但这不是特别快或优雅，而且转换代价很高。这些软件包中包含的数值方法已经很好地建立起来了，并且由于拥有大量的用户群而经过了彻底的测试。不幸的是，选择这三种语言中的一种作为参考实现，而不是一种通用语言，会妨碍其他数据科学语言的采用。不同社区的重复工作损害了生态系统的可持续性和科学成果的可复制性。这不仅适用于成熟的数值方法，也适用于标准协议、文件格式阅读器、数据科学的公共数据结构的实现。

对于这项任务，C++的主要优势是速度和成熟度，以及一个庞大的开发人员社区。虽然有其他有前途的语言，但 C++长期以来一直是科学计算的基石，而且不会消失——尽管它非常缺乏 n 维数组库。相反，现代 C++变得越来越好，语言和标准库比以往任何时候都好。

1. C++可以非常快。你通常会发现 C++在基准测试中名列前茅。例如在基准测试游戏中，C++与 C 和 Rust 一直位列前三。然而，像 Rust 这样的语言在结果中显示出更多的变化，而 C 和 C++保持稳定。你可以确信总是有办法用 C++创建尽可能最快的代码——语言永远不会阻止你达到目标。
2. C++有一个强大的类型系统，可以带来很大的好处，还有一个强大、灵活的模板系统，允许我们让编译器生成极其优化的汇编。
3. 通用意味着可重用:所有代码最好只写一次。这就是为什么一门通用语言需要让它容易被其他语言使用。数据科学中的三大巨头是 Python、R 和 Julia。他们每个人都有优秀的工具与 C++对话:Python 的 pybind11 ，R 的 RCpp ，Julia 的 CxxWrap 。当您用 C++编写代码时，您可以确保能够从这些语言中重用它。

xtensor 如何尝试解决这个问题

The xtensor data science stack

借助 xtensor，我们旨在开发一个适用于整个数据科学生态系统的解决方案。xtensor 是 C++的 n 维数组容器，类似于 Python 的 NumPy。我们严格遵循 NumPy API，但是是纯 C++和强类型的(甚至有一个备忘单来显示这些 API 是如何匹配的)。此外，我们提供了 Python、R 和 Julia 的官方绑定。这意味着，如果你用 xtensor 用 C++编写一次数值算法，你就可以无缝地使用数据科学的每一种主要语言的例程。xtensor 非常灵活，可以使用动态语言进行内存管理:如果通过 xtensor-julia 分配一个 julia 数组，就会使用 Julia 自己的内存分配器和垃圾收集器。xtensor 还透明地处理任何内存布局，例如 Julia 和 R 的列主布局和 NumPy 的行主布局。近年来，C++在自我现代化方面取得了巨大进步(C++ 14 和 c++ 17 ),这使它成为一种非常高效的语言。

在剩余的博客文章中，我们将研究光线明暗处理高度图算法的实现——它首先来自 R 社区，然后被用来展示 GraalVM 如何加速 R，这是 Julia 和 Pythran 争论的问题。本文的目的是展示我们如何用 xtensor 在 C++中一劳永逸地实现该算法，然后在保持最高速度的同时创建到这些语言的绑定。

挑战

我们已经将最初的 R & Julia (来自 Tyler Morgan-Wall 和 Simon Danisch)首先移植到 Python，然后移植到 xtensor(你可以在这里找到 Python 版本)。

我们的版本住在 https://github.com/wolfv/xtensor-showcase 的

您可能会注意到，除了到处使用花括号之外，移植的 C++代码的长度基本上与原始的 Python 或 R 实现相同。NumPy 用户可能还会识别出linspace等功能。这是因为对于大多数高级数组操作，我们坚持使用 NumPy APIs。当然，最大的区别是提供了<double>模板参数，这是高效计算和使用我们的模板表达式引擎生成快速代码所必需的强大编译时类型(关于如何工作的详细解释可以在这里找到)。

我们现在可以为三大巨头创建绑定:Python、R 和 Julia。对于每种语言，都有各自的 xtensor 包:

• xtensor-python :无缝处理 NumPy 数组
• xtensor-r :来回传递 R 个向量和矩阵
• xtensor-julia :绑定 julia 的 n 维数组

这三个软件包的工作方式都相似。它们使用特定于语言的 C++包(pybind11、CxxWrap.jl 和 RCpp)在宿主语言中本地创建数据结构。使用这些包，我们在 C++中创建新的 xtypes:XT::py array用于 NumPy 数据支持的 python 数组，XT::raray用于 R 版本，xt::jlarray 用于 Julia。此外，软件包还包含具有静态维数的版本(相当于 xt::xtensor ，其中 N 是表示维数的整数。这实现了对 C++编译器和模板表达式引擎的一系列优化。

例如，让我们看看 Python 绑定(Julia 和 R 绑定一样简单):

作为函数的输入，我们取一个 xt::pyarray 。这个类型是用 pybind11 注册的，类型是从 NumPy 数组自动转换的——任何步骤都不需要复制缓冲区内容！由于 rayshade_impl 函数将模板参数 E 作为输入，因此我们可以用遵循 xexpression 接口的任何类来调用它。当然，pyarray 做到了这一点(以及 rarray 和 jlarray)。

基准

以下是基准。正如您所看到的，基准测试显示了像 C++和 Julia 这样的编译语言是如何生成非常有效的代码的，并且 xtensor 绑定根本不会影响速度！(顺便说一下，C++的结果比 Julia 的稍慢，因为没有使用专门的基准测试包，我们只在笔记本电脑上计时了一次迭代 CPU 通常需要一些迭代来提高速度)。

 Benchmarks ╔══════════════════╦════════════╗║     Language     ║  Time (s)  ║ ╠══════════════════╬════════════╣║ C++              ║   .0164812 ║ ║ Python / xtensor ║   .0220982 ║ ║ Python / NumPy   ║ 14.224207  ║║ Julia / xtensor  ║   .014221  ║║ Julia            ║   .014501  ║║ R / xtensor      ║   .01328   ║║ R                ║  9.905     ║╚══════════════════╩════════════╝

这里我们需要提一下:Brodie Gaslam 令人印象深刻地展示了如何通过利用矢量化使 R 代码具有高性能(同样的原理也可以用在 NumPy 和 xtensor 中)。他的代码运行速度几乎和使用 xtensor 的 R 一样快，达到了 0.058 秒。

如何开始

这个例子的代码被上传到 https://github.com/wolfv/xtensor-showcase 的。我们已经为 xtensor 创建了许多文档以及千篇一律的项目模板，以帮助人们开始使用 Python 和 Julia 的插件。你也可以在 QuantStack 项目下的 GitHub 上查看各种x sensor-repositories。我们经常在网上的 Gitter 聊天室或 Twitter 上聊天。

我们想从这里走向何方

对于 xtensor 来说，未来还有许多有趣且具有挑战性的任务:

• 更多的 NumPy API: 我们已经介绍了很多，但是仍然缺少一些部分！我们甚至已经编译了一个 GitHub 项目,其中有一些 NumPy API 中缺少的易于处理的部分。例如，如果你想再次尝试 C++，我们很乐意通过实现一些缺失的功能来指导新手！
• 进一步加速一些功能:目前我们已经实现的功能还有一些瓶颈。是时候摆脱他们了。
• GPU 支持——很明显的一个。每个人都有，我们需要得到它，希望明年。这可以大大加快对大数据的操作。
• 更好的互操作性:例如，我们希望获得对 Apache Arrow (工作正在进行中)和 PyTorch 的深度支持。我们也会对更多的语言绑定感到高兴。比如 Matlab/Octave，或者 Java！
• 编译 NumPy 到 xtensor: 这是一个大的。在 python 的帮助下，我们可以将 NumPy 代码编译成 C++(python 目前在 c++中有自己的 NumPy 实现)。我们已经与 python 的作者密切合作，python 使用与 xtensor 相同的 SIMD 库(称为 xsimd )。这里的大愿景是，人们可以使用 NumPy 编写一次数字代码来实现快速原型，然后自动将其编译成 C++。在 C++中，我们可以很容易地生成 Python 的绑定代码(导出到一个独立的库)以及 R 和 Julia！这可能使从高级算法描述编写跨语言库变得非常好。

您可以在 Twitter 上关注作者，或者访问https://gitter.im/QuantStack/Lobby的 Gitter 聊天室，讨论 xtensor 及相关项目！

链接:

• x tensor:GitHubReadTheDocs

YCombinator 应用程序或我们如何几乎做到这一点—第 2 部分(共 2 部分)

原文：https://towardsdatascience.com/the-ycombinator-application-procedure-or-how-we-almost-made-it-part-2-of-2-1ac37b002fcd?source=collection_archive---------0-----------------------

Vahanalytics founders before the final interview

在这篇文章的第一部分(你可以在这里阅读)，我解释了 Y Combinator 的申请过程有以下五个步骤:

1. 登录
2. 表单
3. 视频通话
4. 最终面试
5. 结果

我已经在之前的帖子中介绍了第 1 步和第 2 步，我将在这里介绍其余的步骤。

视频通话:

提交申请三周后(申请截止日期后两周)，我收到了以下电子邮件:

很自然，我们既兴奋又紧张。这是什么意思？这是否意味着我们进入了下一步？或者这只是武断的，对最终的决定没有影响？

事实是，还没有人清楚视频通话的步骤。这不是强制性的，有些创业公司会经历，有些不会。

如果你真的被邀请参加，这些建议应该会有所帮助:

1. 一收到邮件就选择一个电动吃角子老丨虎丨机，以便在你方便的时候玩。
2. 视频通话通常最长持续 10 分钟，由合作伙伴接听。我们和道尔顿·考德威尔在一起。
3. 不要为电话准备太多。确保你准备了简单明了的基本问题的答案。我再一次强调清楚也不为过。清晰，清晰，清晰！
4. 我们的通话持续了不到 10 分钟，我们被问及以下问题:你的初创公司做什么，你正在解决的根本问题是什么，谁是你的客户/用户，他们为什么需要你做的东西，他们用什么代替，你的解决方案如何更好，最后是几个关于收入和数字的简单问题。
5. 在面试过程中保持冷静，手边准备一些水，自己决定谁将回答什么类型的问题(我们按照以下方式进行了分工:与想法/业务相关的— Shivalik，与用户相关的— Nikhil，与收入相关的— Arun 和与技术相关的— Someshwar)并且慢慢地、仔细地回答每个问题，不要互相谈论。

如果你的视频通话进行得很顺利，你的大部分回答都令人满意，YC 的合作伙伴也喜欢你的团队，你应该会感到相当自信。耐心等待，直到收到他们的回复。继续工作，关注你的收件箱！

面试邀请:

视频通话后，我们真的很焦虑，在 Reddit 上查看 hackernews 线程和/u/startups，因为世界各地的创始人不断分享他们的进展。几天后，申请被拒的消息开始传来。我们离邀请截止日期(YC 发出所有采访邀请的日期)越来越近，许多人开始在网上倾诉他们的紧张，就像我们一样。最后，在视频通话后大约 4 个晚上，我们收到了这封电子邮件:

Holy shit! Was this for real?!

当我说那晚我们庆祝的时候你最好相信我。我们要去加州的山景城——深入硅谷，去采访 Y Combinator 的合伙人！

第二天醒来，我们开始着手解决这个问题。以下是我们在准备过程中必须做的一些事情:

1. 安排一个面试时间。我在网上阅读了大量关于最佳位置选择的资料，现在可以坦率地告诉你，这些都不重要。这是一个 10 分钟的面试，不管你选择什么时间或星期几。在一天结束的时候，你和你的孩子在世界上最聪明的人面前。
2. 浏览第一个链接中的所有可用资源，其中包括关于旅行和住宿报销的详细信息(对于像我们这样飞越半个世界的人来说尤其重要！)，关于尽快获得签证的帮助，关于法律帮助的细节(如果需要的话)等等。
3. 检查机票——根据你的面试时间确定暂定日期。为任何可能发生的情况，在任何一边都要保持至少 1-2 天的缓冲时间。我们在面试前 24 小时到达，整整 8 天后才离开，因为我们想充分利用硅谷/加州之旅！
4. 在离你最近的美国领事馆预约签证(或者在你的国家需要的任何手续)。如果你来自美国，恭喜你，你领先一步。一个问题是在他们的邀请函和面试时间之间只有一两周的时间。如果你所在国家的美国签证程序碰巧出现拥堵，就像在印度一样，那你就麻烦了。我们得到了签证预约日期，大约在我们 YC 面试时间的 3 周后！我们立即申请了紧急签证预约，并提供了机票、YC 的相关信息和一封强有力的支持信。在我们向迈克尔·赛贝尔(YC 的合伙人)解释了问题后，他马上给我们发了一封信。如果签证官对此无动于衷，给 YC 发邮件，向他们解释情况。我的一个朋友(另一家创业公司的创始人，也是 YC 邀请的同一批人)无法及时获得签证，所以 YC 好心地将他们的面试时间推迟了一个月左右。是的，他们真的很灵活，而且了解国际边境政治。
5. 为实际面试做准备。将你对基本问题的所有回答进行排练，并在推特上发布。让您的所有数字和指标触手可及。不要纠结于计算 DAU 或者平均得分。屏幕时间什么的，在面板前。准备好一个便携格式的产品演示(最好是电话/平板电脑),如果没有互联网，最好有一个不会崩溃的版本。

扫清了所有障碍，包括签证面谈、预订航班、在山景城预订 AirBnb 以及为国际旅客解决其他后勤问题(国际 SIM 卡、换钱等)后，我们终于登上了阿联酋航空的 A380 飞机，踏上了飞往旧金山的旅程！

实际面试:

After the final interview, with the famous YC signboard

我们的采访时间是下午两点。我们确保提前 30 分钟到达，签到并坐下来等待。我们周围有很多优秀的团队，我们甚至遇到了几个来自印度的朋友，他们是 YC 的校友，帮助我们完成了这个过程。

然后我们被叫去面试了！

我们的小组成员包括:道尔顿·考德威尔，埃里克·米基科夫斯基，卡罗琳·利维(山姆·奥特曼的名字也在我们的小组名单上，但他失踪了，真倒霉)。

面试持续了整整 10 分钟，用闹钟计时。我们被问到的问题是:

1. 告诉我们你在构建什么(简而言之:Vahanalytics为以驾驶员安全和行为为中心的物流车队提供分析。如果您是运输行业的企业，我们是唯一可以告诉您的人——您的哪些司机是好的/坏的(根据手机传感器数据客观测量),他们最担心的领域是什么，您如何提高他们的表现，以及您无法了解的车队行为的其他趋势是什么。)
2. 告诉我们你的客户。
3. 这些人具体是谁(指客户)？
4. 看起来你已经有了一个稳固的团队，一个工作产品和你的第一个付费客户，接下来呢？
5. 你考虑过美国/加拿大市场吗？
6. 所以美国市场已经有竞争对手了？
7. 为什么优步/Lyft 还没有开始使用这个？
8. 美国的优步怎么样？
9. 你将如何加速增长？
10. 您希望这是一个什么样的销售周期？
11. 如何才能缩短这个销售周期，快速成长？

面试结束后，我们气喘吁吁、紧张不安地走了出来。我们认为我们做得很好。面试进行得很顺利，没有太多的分歧或激烈的讨论。事后看来，这可能是一个不好的迹象——似乎没有一个合作伙伴与我们有过多的接触。我可能对细节想得太多了，但这确实像是一个危险信号。

我们开着一辆优步回到山景镇中心，在一家墨西哥酒吧喝了几品脱啤酒，开始了痛苦的等待。

结果是:

经验法则是，如果你在面试后被录取，你会在当天下午 6-6:30 接到面试你的合伙人的电话。如果没有，你会在晚上 7 点后收到他的拒绝邮件。

下午 6:30 来了又去，但没有电话。我们的心沉了下去，我们开始害怕最终拒绝电子邮件。最后，在晚上 7:30 左右，我们在收件箱里收到了这封邮件:

Heartbreaking stuff, really

心碎。拒绝。悲伤。又喝了一杯，然后该继续前进了。差不多就是创业创始人的生活。

不管怎样，我仍然感谢道尔顿花时间和精力来解释他的理由。如果你仔细阅读字里行间的意思，你会发现有一些明确的行动要点:将我们自己与现有的竞争对手区分开来，找到一个好的增长方法，并证明我们的销售周期正在像我们所说的那样缩短。

在回印度之前，我们花了一周时间在山景城和旧金山附近观光，决心做得更好。

如果你被录取了，不要让它冲昏你的头脑。你的战斗才刚刚开始。

如果你像我们一样被拒绝了，不要灰心。把失望当作动力，让自己做得更好。

永远记住:做得更好，下次再申请！YC 最喜欢重复申请人，他们已经找到了解决上次指出的缺点的方法。

考虑到这一点，我们一直在增加我们的销售额，缩短我们的销售周期，这一次再次申请。手指交叉！

这就把我们带到了第二也是最后一部分的结尾。第一部分可以在这里找到。如果你觉得这篇文章有帮助，请点击👏帮助别人找到它！如果你有自己的建议或者 YC 申请期间的有趣故事，请在下面留下评论。

部署 ML 模型有两种非常不同的方式，下面是两种方式

原文：https://towardsdatascience.com/there-are-two-very-different-ways-to-deploy-ml-models-heres-both-ce2e97c7b9b1?source=collection_archive---------1-----------------------

如果一个 ML 模型用 Jupyter 做了一个预测，周围有人听吗？

大概不会。部署模型是使它们有用的关键。

这不仅适用于您正在构建产品的情况，在这种情况下，部署是必要的——它也适用于您正在为管理生成报告的情况。十年前，高管们不会质疑假设，把自己的数字输入 Excel 表格，看看有什么变化，这是不可想象的。今天，一个密不透风的 matplotlib 数字的 PDF 可能会给初级副总裁留下深刻印象，但在经验丰富的高管眼中，它很可能会引发对 ML 的怀疑。

不要帮助带来人工智能炒作周期的结束！

因此，ML 模型的部署成为热门话题，仅仅是因为没有多少人知道如何去做；看到你既需要数据科学又需要工程技能。正如我最近发现的，有两种真正不同的方法来部署模型:传统的方法，和一个更近的选择，老实说，让我大吃一惊。

在本文中，我将为这两种部署提供一个简单明了的最佳实践模板。和往常一样，对于动觉学习者，如果你想测试一下，可以直接跳到代码这里，我实际上在这里部署了这个代码。我知道不是每个人都喜欢在阅读时跳来跳去；看起来是这样的:

I didn’t train the model for long; it’s not the point of this article!

如何部署 ML 模型

如果你是分析师出身，你可能不理解 web 应用架构，所以让我先说明一下。抱歉，如果这是过于简单化和人为解释！但是我见过太多的“ML 模型部署”,它们实际上只是包装在 Flask 中的 XGBoost，我知道这是一个真正的问题。

用户(这里的左边)使用的浏览器只运行 Javascript、HTML 和 CSS。那是前端。它可以调用后端服务器来获取结果，然后处理和显示结果。后端服务器应该尽快响应前端的请求；但是后端可能需要与数据库、第三方 API 和微服务对话。后端也可能应用户的请求生成缓慢的作业——比如 ML 作业，它应该将这些作业放入队列中。(请记住，用户通常必须以某种方式验证自己)。

Commonly, the frontend might be built with JS and/or React, and the backend with Python (and Django or Flask) or NodeJS (and Express).

现在，让我们谈谈分布式 web 应用程序架构。

一般来说，为了可伸缩性，我们希望运行尽可能多的后端实例。这就是为什么上图中‘服务器’有气泡冒出来的原因；他们代表“更多的这些”。因此，每个实例必须保持无状态:处理完 HTTP 请求并退出。在请求之间不要在内存中保留任何东西，因为一个客户端的第一个请求可能会发送到一个服务器，随后的请求会发送到另一个。

如果我们有一个长时间运行的端点，这是很糟糕的:它会占用我们的一个服务器(比如说…做一些 ML 任务)，使它无法处理其他用户的请求。我们需要保持 web 服务器的响应性，并让它移交长时间运行的任务，使用某种共享持久性，以便当用户检查进度或请求结果时，任何服务器都可以报告。此外，工作和部分工作应该能够由尽可能多的工人并行完成。

答案是先进先出(FIFO)队列。后端只是简单地将作业排队。工人从队列中挑选并处理作业，执行训练或推理，并在完成后将模型或预测存储到数据库中。

有了库 MLQ ，以下就是后端 web 服务器的全部需求——一个让作业排队的端点，一个检查作业进度的端点，一个在作业完成时提供作业结果的端点。

真正部署 ML 模型的架构是这样的:

1. 后端服务器从用户的网络浏览器接收请求。它被包装在 JSON 中，但是语义上类似于:“明天是星期三，我们今天卖出了 10 台。明天我们会接到多少客户支持电话？”
2. 后端将作业{星期三，10}推入队列(与后端本身分离的某个位置，比如 MLQ 的 Redis)。队列回答“谢谢，让我们称之为作业 ID 562”。
3. 后端回复用户:“我会计算的。它的 ID 是 562。请稍候”。后端可以免费为其他用户服务。
4. 用户的 web 浏览器开始显示“请稍候”微调按钮。
5. 工作人员——至少是那些当前没有处理另一个作业的工作人员——不断地轮询作业队列。工作线程可能存在于另一台服务器/计算机上，但它们也可能是同一台计算机上的不同线程/进程。工作人员可能有 GPU，而后端服务器可能不需要。
6. 最终，一个工人将获得该作业，将它从队列中移除，并处理它(例如，通过某个 XGBoost 模型运行{星期三，10})。它会将预测保存到数据库中。假设这一步需要 5 分钟。
7. 同时，用户的 web 浏览器每 30 秒轮询一次后端，询问作业 562 是否已经完成。后端检查数据库是否存储了 id=562 的结果，并相应地进行回复。我们的多个水平后端中的任何一个都能够满足用户的要求。您可能会认为共享数据库是一个单点故障，您是对的！但是，我们单独提供了副本和一些故障转移机制，可能是分片/负载平衡，所以一切都很好。
8. 五分钟多一点后，用户投票得到一个结果，我们就可以提供给用户了。

还涉及到一点点，主要是处理弹性和持久性(如果工作人员在工作中途离线怎么办？如果用户的输入是垃圾，导致作业失败怎么办？)但这是最基本的。这是一个非常简单的 MLQ 工人模板。它只是等待，直到接收到一个作业，然后对作业参数运行一个函数并存储结果。您可以在同一个服务器或分布式服务器上并行运行尽可能多的这些东西。如果你查看回购协议，你会找到尼采/张量流 RNN 模型的完整代码。

有几个很好的排队框架可用，或者可以形成合适队列的东西，包括 Celery、Dask、ZeroMQ、native Redis 和一个库，我最近把它变成了一个易于使用的版本，用于部署不复杂的辅助项目: MLQ 。卡夫卡也是一个东西，但是普通读者会知道我不喜欢过度架构的、基于 Java 的项目。MLQ 不成熟；我不是想在这里推销。用芹菜代替严肃的项目。

本周，我花了一些时间与 NVIDIA 交流，并询问了他们关于作业排队的规范解决方案(具体来说，在我的情况下，这样我就可以让每个使用 Jupyter 笔记本电脑的工作人员都可以使用 GPU farm，而无需他们同时尝试提交作业)。还没有，但我确信他们正在努力。在那之前，用排队系统手工推出解决方案是唯一的办法。

(在那次会议上，大家可能也很感兴趣:每个人都认为 MXNet 是一个非常好的框架，也许是最好的——但遗憾的是，它可能正在被淘汰)。

实时？

您可能想知道，ML 队列如何与实时应用程序一起工作？答案是:同样的方式，但是由于延迟的原因(比如工业物联网)并不理想。队列入口点可以是分布式的，所以真正的技巧在于数据库如何处理它。此外，普遍的看法是，人们不会接受私人数据被发送到后端，这也是“边缘的 ML”成为热门话题的另一个原因。如果推断所需的所有数据都可以在一个地方获得，我们就在那里进行推断。所以，没有进一步告别:

如何部署一个 ML 模型，以 2

所以，可怜的被诽谤的前端工程师进来了，每个人都认为线性代数意味着一个接一个地做计算，但他却是你的团队中最受欢迎的人。事实证明，他可能并不是一个傻瓜，但也许只是在等待时机，直到 Javascript 的人工智能工具赶上 Python。最近，他们做到了。

一言以蔽之，现在可以从 Javascript 使用 Tensorflow 了。起初，我对谷歌宣布的这种想法不屑一顾，这可能意味着用蹒跚、残缺的模型进行推理，这些模型必须符合某种模式(最多有 12 个过滤器的单个卷积层，FP-8 等)。也只有推论！肯定不是训练。Javascript 怎么可能做到这一点。

我大错特错了！

在这篇文章中，我不想把重点放在用 Javascript 训练模型上——这非常酷，但并不总是非常实用——而是为训练好的模型提供一种替代的部署模式。记住你的 训练好的模型将会对全世界开放。任何人都可以复制它，看看层是什么样子，并窃取所有的参数。我想我会说这是不可避免的，你的模型可能没有你想象的那么特别:任何竞争优势都在于你可以部署模型修订的数据和速度。当然，你在模型上构建的产品有多棒。无论如何，要小心。

首先，建立一个模型

TensorflowJS 可以在用户的网络浏览器中执行任何 Keras 模型。而且，通过 Web GL，它们是硬件加速的！我没有确切的数字，但据我所知，它对我很有效。肯定没有 Python 快，但我肯定随着时间的推移 JS 会赶上来的。

对于本文，我复制了官方 Tensorflow Keras 文本生成 LSTM 示例的代码并运行它来构建一个模型。我完整的 Jupyter 笔记本在这里。

然后，将模型导出到 TFJS。你可能需要pip install tensorflowjs。然后:

import tensorflowjs as tfjs
tfjs.converters.save_keras_model(model, '.')

在目录中，你现在可以找到model.json和group1-shard1of1。

接下来，建立一个使用该模型的网站

现在所有的 Tensorflow JS 示例都使用 Yarn，我知道这有点过时了(当我做更多可视化工作时，yarn成为了新的热点，而npm是老狗；现在反过来了)。让我们暂时抛开前端的反复无常。

无论如何，希望你有纱线和一个工作的节点安装(至少版本 9)。对于一个服务于前端模型的网站的最小例子，你可以克隆我的回购。

实际的 Javascript 代码并没有那么有趣。关于从缓冲区创建张量有一些样板文件，但是实际使用这个模型需要做的就是:

model = await tf.loadModel('[https://mydomain.com/model.json'](https://exploitip.com/model.json'));
output = model.predict(input);

完整的端到端前端(和后端)部署示例是我的报告中的。

维奥拉。硬件加速的 Keras 型号，您甚至不需要后端。

限制

除了你的网络架构可以被所有人看到之外，我能想到的最大缺点是，在许多实际应用中并不是所有的数据都可以在前端获得。在我工作的地方，当用户输入一个查询时，我们从 Elasticsearch 获取大量数据，并对这些数据运行一个模型(实际上是几个)。向前端发送这么多数据是不可行的。

即使是这样，你也可能想对的每次预测收费，一旦你进入 Javascript 领域，这是不可能的。

最后

很简单:

• 使用队列
• 不要占用你的后端网络服务器；将任何 ML 过程与提供资产和端点的行为分开
• 确保一切都是无状态的，并且能够并行运行
• 考虑前端部署

Not really. They all get momentarily sad.

我希望你喜欢这篇文章并从中有所收获！如果你这样做了，请点赞并关注，和/或在这里或在 @tomgrek 提供反馈。我在旧金山建造人工智能，并且总是喜欢和其他的书呆子/人工智能爱好者交谈，所以请随意通过任何方式联系。

真相没有单一的版本

原文：https://towardsdatascience.com/theres-no-single-version-of-the-truth-fe4b9857a453?source=collection_archive---------5-----------------------

我时常听到一个让我毛骨悚然的短语。这通常与一些陈词滥调的商业比喻有关(想到无耻地使用“在一天结束时”)。现在，有一个让我思考措辞在现代商业中的价值:真相的单一版本。

这个短语有不同的说法，比如真理的一个版本或者真理的单一来源。不管用哪种方式，在如今“另类事实”的氛围下，这个短语有了更深的含义。让我们解释一下这个短语的意思，以及为什么在部署这个短语时应该非常小心。

SSOT 与信息系统设计

这个术语最初的应用是在设计捕捉和传播信息的系统时。这在访问许多不同数据流的情况下尤其相关。“单一事实来源”模型确保相关应用程序访问相同的数据源，从而提高准确性和相关性。如果没有 SSOT，由于数据来源的差异，同一问题可能会有不同的答案。

这一点在建筑系统设计等领域尤为重要，在这些领域，一个变化就会产生迅速的连锁反应。下图显示了 SSOT 在特定情况下的工作方式。事实上，该图也可以应用于在任何信息系统中组合和验证多个数据源的方式。

源代码与版本

这是关键的区别。拥有单一的真实来源意味着任何给定的用户都可以依赖这些数据。系统被理解为将所有相关的数据源拉进那个单一的源，然后从那个点开始的所有查询依赖于那个源。

在商业词汇中,“单一来源”已经变成了“单一版本”虽然有一个的论点，即单一版本的真相是一个普遍接受的应用于数据集的规则，我有一个问题。单一版本的真相仍然意味着有其他版本的真相可用。单一的事物不能有多个版本。同样的数据，不同的方法可能会产生矛盾的答案。如果是这样，那就不是真理。是观点！

为什么你应该关心

所有伟大领袖的一项基本技能是接受大量不确定性的能力。在不断变化的宏观经济环境中，没有什么是确定的。尽管模糊不清，但企业必须经营。领导者必须在不确定且经常不稳定的环境中接受多重真理。

精彩文章“ Both/And Leadership ”的作者指出了美国人的思维方式是如何框定这个国家与不确定性的关系的:

如果一个想法是“正确的”，它的对立面一定是错误的；如果情况似乎不是这样，那么我们必须重新定义我们的想法，以消除矛盾。

这就在灰色地带制造了一个真空。在当今西方企业的主流思维中，根本没有容纳多重真理的空间。如果一个领导者在一个想法上全力以赴，那就会减少分析其他潜在竞争想法所需的自省。

为了挑战这种似是而非的心态，文章接着提出了三个关键的转变，以适应现代商业世界的不确定性和矛盾性。坚持接受矛盾——你不能控制一切，也不应该尝试。消除稀缺思维——这阻碍了企业和员工的发展。走向充满活力和变化的状态——稳定是无法实现的幻想。

话语比以往任何时候都重要。走进时代的悖论，改变你的沟通方式，在当今的商业环境中放大你的成功。

记住这一点:如果你说“单一来源”，那么你是在谈论一个技术产品开发概念。您必须确定该来源符合 SSOT 的标准。如果你说“单一版本”，那么你真的没有说太多。你应该阐明你的意思，以避免混淆和怀疑。

我知道许多企业使用“单一版本”来让团队围绕一个共同的数据视图，但我不同意这个说法！相反，应该像命名项目一样命名数据集，并以这种方式引用它。或者称之为风景。“单一版本”暗示了一些不可能的事情！

本文代表尼克的个人观点，不反映他所属或受雇的任何公司。

尼克·维维安是一名记者和交流者，对旅游事业充满热情。在过去的十年里，他在世界各地为《孤独星球》等品牌创作内容，并在 nickvivion.com 撰写了大量关于内容、技术和旅游的文章。

这三个市场还没有被人工智能和深度学习服务

原文：https://towardsdatascience.com/these-3-markets-arent-yet-being-served-by-ai-and-deep-learning-3cde7ad20d50?source=collection_archive---------12-----------------------

这些将是艾唾手可得的果实

想获得灵感？快来加入我的 超级行情快讯 。😎

AI 突破了；渗透到大多数人会不假思索想到的每个行业。有许多公司正在研究自动驾驶汽车、自动机器人、个人助理等东西。你甚至可以找到更引人注目的应用如法律研究、营销、银行、销售！

…但这并不能涵盖一切。上面列出的所有应用程序都有一个共同点，那就是它们都更倾向于面向大型企业。大银行的银行业务，跨国组织的市场营销，汽车公司的自动驾驶汽车等等。

这里缺少的是小家伙。因为在媒体上看起来不酷而经常被遗忘的领域。

当每个人都在谈论仓库机器人时，我们已经忘记了可以帮助人们从事繁重劳动或老年人的机器人。那些没钱拥有自己的世界级人工智能研究团队的小企业主怎么办？他们被忽略了！

这些是我们需要在落后之前开始关注的市场。它们是可以应用人工智能的唾手可得的果实。

让我们看看最大的 3 个

公共服务和公用事业

当我们说公共服务和公用事业时，我们会想到常规医疗保健(如医生检查)、管道、电力输送和污水处理。虽然不是最性感的行业，但这些服务服务于所有地方的大众。

例如，大多数应用于医疗行业的深度学习都是针对专家进行的，如放射科医生、心脏病专家等。但是一个人去体检的正规医生呢？或者在像美国这样的国家，很多人付不起这些专家的费用，他们会怎么样？还没有对任何一种技术进行太多的探索，这种技术至少可以给一个人一些早期预警信号或建议，如果他们真的需要去找如此昂贵的专家。

此外，还有其他公共设施，如电力、水电和天然气。如果我们能找到用人工智能优化这些过程的方法，就能节省大量的成本。强化学习可能是一个很好的起点，因为一个可训练的、有行动奖励协议的代理人似乎很适合这样的工作。也许可以开发更有效的路由方法，或者使公用事业管道中的更多过程自动化。

这些是许多不性感但重要的公共行业中的一小部分，它们目前是不值得的。

小型企业

另一个不受关注的市场是小企业市场。大部分人工智能都是针对大公司的。但是那些小企业呢？他们占了北美就业的很大一部分！

事实上，小型企业确实面临着与大型企业类似的挑战，这些挑战可以通过人工智能来解决，只是规模较小。一个杂货店想要最大化它的营销和销售，就像一个更大的企业一样，它只是一个“本地”问题。一家大公司可能会使用人工智能来找出如何在电视广告或大型广告牌广告上最好地营销他们的产品。你当地的杂货店也希望有更好的人工智能市场，但也许是通过更有吸引力的传单或店面招牌。

也有咨询/合同方面的事情，人们可能会独立工作。也许使用人工智能来为这些人创造一些线索，这样他们就可以更有效地寻找新客户。

人工智能可用于解决较小企业的需求，这些企业的需求与较大企业的需求基本相同，只是规模不同，角度不同。

手工劳动

有一个微小的瓶颈，它总是存在于任何一个建造实物的项目中，那就是实际的体力劳动。

现在，这里有一些部分正在被人工智能处理，例如制造(想想装配线风格)和仓储。但是那些更重的工作呢，比如铺路，冶金，或者只是在房子里搬重物？这些东西目前都被遗漏了！

任何工作的体力劳动，通常花费最多的时间、金钱和精力，并造成最多的身体伤害。这是工作中最难的部分，需要最大的努力。有趣的是，在许多方面，最费力的部分往往是最重复的，然而在应对这个市场方面仍有很大的差距。

这种差距的一部分是目前进展缓慢的机器人领域。著名计算机视觉科学家和该领域的领导者 Jitendra Malik 最近在 ECCV 2018 上表示，机器人领域远远落后于人工智能:

机器人技术比计算机视觉落后十年，甚至二十年——Jitendra Malik，ECCV 2018

这是一个巨大的差距。因此，虽然许多视觉感知的奇妙算法正在开发中，但机器人在进行基本的抓取时仍然存在严重的问题。与此同时，目前的机器人不太灵巧，几乎没有“熟练”的控制，也不能有效地与环境互动。

如果我们只关注人工智能中事物的视觉和语言部分，我们将局限于无法以智能方式与世界进行物理交互的静止事物。

喜欢阅读关于科技的文章吗？

在推特上关注我，我会在那里发布所有最新最棒的技术！

这 5 个数据可视化将使你以一种新的眼光看待史蒂芬·科拜尔晚间秀

原文：https://towardsdatascience.com/these-5-data-visualizations-will-make-you-see-late-show-with-stephen-colbert-in-a-new-light-34e03cc2541d?source=collection_archive---------15-----------------------

像许多人一样，我晚上的例行公事是一边喝酒一边看史蒂芬·科拜尔的节目。这是一首完美的颂歌。斯蒂芬设法让我发笑，即使是在最糟糕的日子里。

Picture Credit : Daily Beast

这个节目有两部分。斯蒂芬以一段独白和对当天政治事件的评论开始。在第二部分，斯蒂芬与客人交谈。我在深夜秀中见过各行各业的人，从总统到训熊师。这种嘉宾的多样性让我对出现在史蒂芬·科拜尔节目中的人的人口统计数据感到好奇。

他们中的大多数是做什么工作的？他们相对年轻还是年老？臭名昭著的性别差距存在于最著名的自由主义节目之一吗？我还能发现其他模式吗？

数据不容易获得。所以我决定刮维基百科。我已经收集了从展览开始的过去 3 年的数据。截止 2018 年 11 月 2 日，《T4》共 641 集，993 位嘉宾。

搜集和清理众包数据并不容易，但我得到的见解非常值得。例如，很少有人会想到黄金时段节目中最常出现的嘉宾是竞争对手的脱口秀主持人和天体物理学家。是的。约翰·奥利弗和尼尔·德格拉斯·泰森分别出场 9 次和 8 次。

Yeah , Neil deGrasse Tyson is normally not impressed with bad arguments

现在是严肃讨论的时候了。你们中的一些人可能会耸耸肩问:我们已经知道斯蒂芬邀请美国社会精英参加他的深夜玩笑，但是做数字运算重要吗？答案是:可以。这种解释更多地与我们在这些时代消费内容的方式有关，而不是针对我们正在分析的节目。

对我们消费的常规内容进行公正的分析比以往任何时候都更重要，因为我们正处于过滤泡沫之中。

过滤气泡是一种智力隔离状态，可能是由个性化搜索造成的。在后真相的时代，我们一遍又一遍地听到我们想听到的真相。此外，内容制作者倾向于制造政治二分法，以在一个已经分裂的国家扩大受众。

随着数百万美国人每晚收看史蒂芬·科拜尔的深夜秀，这个节目有着无与伦比的影响力。有关于斯蒂芬对现实世界影响的学术研究。科尔伯特凸起是社会科学家詹姆斯·h·福勒创造的一个术语。它的意思是由于作为嘉宾出现在节目中或在节目中被提及，某人或某事的受欢迎程度增加。福勒的研究发现，在节目中露面后的 30 天里，给民主党政客的捐款上升了 40%！虽然这项研究是关于科尔伯特报告——史蒂芬·科拜尔之前的节目——它的有效性仍然存在。

见鬼，他甚至可以筹集到一百万美元现实世界超级政治行动委员会。所以这个节目值得一个批判性的分析。

现在谈谈数字和细节。

好莱坞，请这边走

Top 10 occupation groups of the guests in Late Show with Stephen Colbert

与类似的深夜节目一样，嘉宾主要来自娱乐和表演行业，占嘉宾总数的 76。这个街区有各种各样的演员、说唱歌手、歌手、音乐家、电影制作人、编剧，当然还有单口相声演员。

被忽略的那一部分是我们可以看到这部剧的多样性的地方。从 YouTube 名人到四星将军再到天主教主教，这四分之一的人是一个真正的混合体。在模糊的分组之下，有一些你通常不会在深夜电视访谈节目中遇到的稀有珍宝。像记者和作家组的斯蒂芬·金和安德鲁·苏利文或者像科学和学者组的理论物理学家布赖恩·格林和语言学家约翰·麦克沃特。

此外，政府、政治和军事、记者和作家、和电视记者和主持人职业群体合计占 17%,即使在通常专用于娱乐的第二部分，该节目也清楚其优先性和特征。

贝克德尔测试

Distribution of Gender Ratio of guests in Late Show with Stephen Colbert

数字说话响亮而清晰。自由节目也不能摆脱性别差异。该节目中的性别差距是男性领先 30 个百分点。考虑到斯蒂芬的大多数客人都来自演艺圈，这个数字是很大的，在这个领域里，女性和男性的才能是不相上下的。如果你把职业类别和性别划分一起分析，对比就更加明显了。

例如，在娱乐、演艺界职业类别中，男女嘉宾的划分分别为 62.2%和 37.7 %。当我们转向其他被认为“严肃”的职业，如科学和学术，比例差距变得更大，分别为 75%和 25%。在政府、政治和军事占领区，男女比例分别为 71%和 29%,男性占优势。然而， 商业和企业在嘉宾性别差距最大的类别中登上了领奖台，男性嘉宾比例高达 94%，甚至超过了女性嘉宾比例为 16%的体育。

斯蒂芬喜欢中年男人

Distribution of age of the guests of Late Show with Stephen Colbert. Color indicates gender.

嘉宾的平均年龄为 47 岁，标准差为 13.56，显示了年龄分布。如果我们按性别划分，女性客人的平均年龄是 45 岁，男性是 50 岁。这种性别间平均年龄的差异与职业类别有很大的相关性。

例如，在上图中，我们可以看到女性客人数量高于男性的唯一年龄范围是 28 至 36 岁。进一步研究数据，我发现 28 至 36 岁的女嘉宾中有 94%来自娱乐和表演行业。相比之下，年龄在 28 岁至 36 岁之间的男性客人在职业人群中的分布要广得多。见下图。

Distribution of male guests who are 28 to 36 across occupation categories

让我们谈谈政治

Political View distribution of the guests in Late Show with Stephen Colbert

来自世界各地的访客中，有 60%的人更新了他们的维基百科页面政党栏，他们都是民主党人。如果你只从美国两党的角度来看，这些数字会变得更有趣。在 71 名政治观点被标记为共和党或民主党的美国客人中，民主党人比共和党人多三倍。这些数字符合特朗普 2016 年就职后该节目变得越来越政治化的普遍看法。

所有可爱的人，他们都来自哪里？

Distribution of birth states of of the guests in Late Show with Stephen Colbert. Color scale indicates density.

绘制美国客人的出生城市和州揭示了一些有趣的模式。客人来自全国各地，但也有例外。大约 40%的客人出生在加利福尼亚州和纽约州。

一项双变量分析表明，在娱乐和表演行业类别的客人中，有 31%出生在两个州。相比之下，政治客人的出生状态的百分比分布得更广。除了纽约州——我认为它是一个异常值——21 个州的比率从 5.77%到 1.92%不等。在这里，我们嗅到了一种趋势，即在重要的大都市长大对于某些职业来说很重要，这些职业的人生起点较少或较早。

大苹果闪耀

Distribution of American guests across top 10 American Cities

我深入研究了出生地点的可变性。这次我深入城市。纽约市作为一个空间因素的重要性是非常明显的。上图显示，在美国前 10 大城市中，纽约市拥有 47.7%的客人份额。

我们在上一节中得到的信号——人们成长的地方会影响他们的职业——在我们将特定的职业和城市联系起来时会变得更强。这与来自数据的其他证据和趋势相关，例如茱莉亚音乐学院是纽约市最负盛名的艺术学校之一，也是客座率最高的学校。

所有的职业，像表演、唱歌和写作，早期的推动可能会有不公平的优势，这显示了与出生城市的相关性。与其他城市相比，纽约在电视记者和主持人群体中占有 55%的份额。57%的娱乐和娱乐业群体和 69%的记者和作家群体都出生在纽约市。

TL；博士？

Picture Credit: http://gif-finder.com

1. 斯蒂芬的大多数客人来自演艺圈，但也有其他很酷的人
2. 谈到政治，斯蒂芬更喜欢驴子而不是大象已经不是什么秘密了
3. 越来越多来自不同领域的女性将使这个精彩的节目成为必不可少的

数据和研究。

我们正在建立一个强大的系统来衡量科学……但是创新呢？

原文：https://towardsdatascience.com/these-are-some-of-the-things-you-are-likely-to-hear-if-you-spend-time-talking-to-people-running-138a31eaea2e?source=collection_archive---------3-----------------------

Cell structure from Robert Hooke’s Micrographia (1665). Source: Wikimedia Commons

“我们的工作是创造新的联系，但我们如何证明它们的价值？”

“测量是短期的，但我们的影响是长期的”

“衡量我们的方式让我们不敢冒险”

如果你花时间与实施支持创新的项目和干预措施的人交谈，你可能会听到这些事情。这些创新实践者所说的是，用于评估他们的指标是不正确的，这使得他们的工作更加困难。

但是什么是正确的衡量标准呢？我们如何得到它们？开始测量目前不为人知的事物有什么坏处吗？

在这篇博客文章中，我通过首先查看科学研究的相邻领域的情况来探索这些问题，我认为，关于科学活动的新一波数据(科学计量学)正在以前所未有的详细程度和及时性，使测量和跟踪科学投入、过程和产出变得越来越容易。

不幸的是，在创新领域(企业、政府和第三部门应用新思想的领域)，事情的进展没有那么快，因此我们对创新如何发生以及支持创新的最佳方式的理解仍然不够。我概述了科学中情况不同的原因，并概述了生成更好的创新数据的策略，帮助我们的创新衡量(innometrics)赶上科学计量学。

创建科学政策的科学

在过去的几个月里，我参加了几次会议和研讨会，数据的数量和质量以及科学计量学学者为回答重大科学政策问题而部署的方法的复杂性给我留下了深刻的印象，这激发了我写这篇博客的灵感。

在去年 9 月的经合组织蓝天论坛上，我看到了关于科学合作和研究人员流动的非常有趣的介绍。我对由 Katy brner 和合作者制作和策划的知识图谱感到惊讶，他们使用先进的分析和信息设计来创建科学研究的详细地图，以及不同研究领域之间的联系。

例如，参见下面的地图(基于这篇论文)。它基于对超过 200 万篇论文的分析显示了医学科学子领域之间的关系。研究人员和资助者可以使用这些地图在浩瀚的科学海洋中导航，并识别潜在的有趣论文和领域之间的联系。

来源:斯库平、比伯斯丁和伯尔纳(2013 年)

在欧盟委员会(European Commission)组织的一次专家研讨会上，我了解到在欧盟委员会的支持下，一个由欧洲研究人员组成的财团正在开发的科学与创新研究基础设施 RISIS 。RISIS 是一组链接的数据集和一个安全的实验室，用于存储和分析科学活动的微观数据。

就在几周前，我参加了由科技公司 Digital Science 组织的 FuturePub 会议，会上他们的首席执行官丹尼尔·胡克(Daniel Hook)介绍了 协作的互联文化 ，一份报告，该报告对科学协作进行了新的分析，其数据来自背面的，这是一个协作科学写作和出版的平台。

下面这张取自该报告的漂亮图表显示了不同国家机构之间的联系(红色代表北美国家，蓝色代表欧洲国家，紫色代表南美国家，黄色代表西亚国家)。作者指出，欧洲国家之间的高水平合作部分是由欧盟研究基金推动的，这鼓励了欧洲各地的研究人员一起工作。你可以想象这样的数据和可视化有助于回答重大的政策问题，比如英国退出欧盟对英国在国际研究网络中的地位的影响。

来源:卡尔弗特和胡克(2017)

我在自己的工作中受益于科学计量学的新浪潮。由英国研究委员会和创新机构 Innovate UK 资助的项目的开放数据集“研究之门” (GtR)是对我们为威尔士政府开发的创新数据仪表板 Arloesiadur 的重要投入。GtR 包含数万个项目和组织的详细链接信息。我们正在使用机器学习、自然语言处理和网络科学来分析这些数据，以跟踪研究课题和技术的出现，确定威尔士具有比较优势的领域，并发现威尔士研究人员之间合作的新机会。

下图显示了基于这些数据的研究主题的初步网络。在这个图表中，经常出现在相同项目中的研究主题被拉近了。颜色代表每个主题所在的更广泛的科学学科。尽管科学学科显而易见，但它们远非孤立。特别是，‘media _ design _ creative’，‘management’，‘process _ mechanical _ engineering’以及环境和生命科学研究的政策应用等应用性和实践性研究主题似乎在学科之间架起了桥梁，表明这些项目通过将学科联系起来解决实际问题而创造了价值，此外还提供了这些问题的解决方案！

资料来源:Nesta(即将出版)。

创新计量学落后于科学计量学

不幸的是，我们衡量新思想(包括科学研究产生的思想)应用的创新过程的能力并没有以同样的速度扩大和提高。哈桑·巴克希和我在去年经合组织蓝天会议上提交的一份工作文件中提出了创新政策数据现状的问题，所以我现在只浏览一下:

许多当前的创新研究依赖于创新调查，例如社区创新调查。这些(明确地说，是高质量的)调查受到样本量小和难以比较回答的困扰，它们缺乏关于商业合作和贸易的详细信息，并且不能用于识别单个企业。对于寻找具体地点、行业和网络或单个企业详细信息的研究人员和政策制定者来说，它们并不那么有用(而不是部门总量或平均值)。

专利可以填补其中的一些空白，但在以科学为基础和技术密集型的行业中，只有极小一部分企业拥有专利。不到 1%的英国创新调查受访者认为专利对于保护他们的创新非常重要。

通过通常由国家统计机构维护的安全数据实验室，可以越来越多地获得关于公司财务业绩的微观管理数据。不幸的是，这些数据告诉了我们很多关于公司业绩的信息，却没有告诉我们多少关于创新的信息。【2】和以前一样，他们缺乏关于商业网络的信息，并且(可以理解的)是匿名的。

如何解释这些差异？

我们拥有比创新更好的科学数据，原因很简单:科学活动更容易衡量，衡量的内容更公开地共享，共享的内容更容易整合，以获得对科学系统更统一的看法。

让我们依次讨论这两件事。

1.关于测量的容易程度:虽然很少有人会认为科学是一个简单的系统(如果有疑问，回到上面的图表)，但它的输出不如创新那样多样化。简单地说，学术研究者产生论文。【3】相比之下，创新包括新产品、服务、流程、商业模式、组织方式和“软”创新，这些创新在不同行业之间有很大差异。没有一个像 Scopus 这样的数据库可以让人们去寻找关于这些创新的信息。

科学货币引文的高可见性也使得在学术界比在工业界更容易绘制合作和影响网络，在工业界，许多(如果不是大多数的话)信息流和人员不会留下书面痕迹，或者在许多独立或专有的数据集中留下一点痕迹，如企业用来跟踪销售和购买的客户关系系统，或 LinkedIn 等专业网络。

2.这让我们想到了推动新一轮科学计量学浪潮的科学体系的另一个特征:开放性。科学由少数(主要)公共和第三部门组织资助，这些组织收集大量关于“投入”(资金、科学工作者的特征、项目描述等)的运营数据。)，而且越来越开放以降低知识获取和再利用的壁垒。在期刊付费墙之外获取论文也变得越来越容易。创新方面的情况非常不同，政府在发布创新项目参与者的数据方面速度较慢，拥有宝贵创新数据的公司没有多少动力发布这些数据。

3.在整合方面:科学系统在开发和采用唯一标识符方面取得了长足进步，这使得跨数据库连接信息成为可能:这包括用于识别内容(例如论文)的数字对象标识符、研究人员的持久数字标识符 ORCiD 以及全球研究机构目录 GRID 。由于这种元数据基础设施，科学计量学的研究人员可以顺利地从许多不同的来源汇集信息，以获得对创新系统的全面了解。这种全球标准在创新领域不太发达。例如，用于唯一标识企业的全球法律实体标识符 (GLEI)在英国的注册公司不到 3 万家，占英国企业人口的比例微乎其微。

帮助创新计量学赶上科学计量学

这东西很重要。就目前的情况而言，创新政策决策基于错误数据的风险很大，糟糕的指标会扩大，以填补良好指标缺失造成的空白，这可能会造成一个颠倒的世界，成功的项目似乎已经失败，反之亦然。

毫不奇怪，糟糕的创新数据也减缓了大数据、数据科学和人工智能(AI)方法在创新政策和实践中的使用。相比之下，更大更好的科学计量数据集正在推动一个新兴的科技场景，包括数字科学(我之前提到过)，以及其他创业公司，如仁慈的 AI 、 Meta 或 Yewno ，他们都在使用人工智能来加强科学发现和合作。

更糟糕的是，对创新的错误衡量在科学政策中产生了负面溢出效应，因为低质量的创新指标使得衡量公共投资对科学的影响变得更加困难，越来越多地基于经济增长和就业的前景。甚至还存在这样的风险，即缺乏关于科学研究推动创新的微妙方式的信息，可能会导致政策制定者关注科学影响的更粗糙的衡量标准，如从大学到工业的衍生产品或知识产权许可。

这可不行。我们知道，创新对于提高生产率、重新平衡经济、减少经济不平等和应对巨大的社会和环境挑战至关重要，但这需要有效的政策来支持创新，并基于正确的数据和指标来监管创新。正如欧盟专员卡洛斯·莫达斯(Carlos Moedas)在经合组织蓝天会议(OECD Blue Sky conference)的演讲中指出的那样，“数据是(创新)政策运行的燃料。没有它，我们无法知道我们是否做出了正确的决定。

我们如何前进？

有三个广泛的行动领域，与我上面提出的衡量、开放和整合的思想相关。

首先，我们需要扩展新数据源和数据科学方法的使用，以衡量和规划创新。和其他人一样，创新者在网站和服务中留下数字足迹，他们用这些网站和服务来筹集资金、建立关系网、合作、招聘、营销和销售。我们需要积极分析这些来源，以衡量创新投入、活动和产出。这就是我们在诸如科技国家、创意地理或 Arloesiadur 等项目中所做的，并取得了可喜的成果。现在我们需要开始推动这些方法进入政策主流，并围绕它们的使用建立信任。我们与 NIESR 和其他合作伙伴在国家统计局建立的经济统计卓越中心所做的工作正是以此为目标。

另一个更好地衡量创新的潜在策略是用网络数据“即时预测”商业创新。例如，人们可以进行一项大型调查来衡量商业创新，然后在其他更及时匹配的数据源中寻找这些指标的良好预测者，如受访者的网站(用机器学习的语言来说，我们将在通过调查标记的数据集中训练一个模型)。然后，我们可以使用我们所了解的代理和度量之间的联系来估计我们没有调查的其他业务(但显示创新“信号”)具有创新性的可能性，并比大型和昂贵的调查更快和更频繁地跟踪情况的变化。

其次，我们需要找到一种方法来打开当前关闭的重要创新数据集。这适用于公共部门，几乎在默认情况下，公共部门应该公开参与创新项目的公司的数据(这是创新英国已经在通过研究之门做的事情)，以及商业注册，甚至在合理的范围内，公开行政数据集。专门为创造高质量数据而设计的政府干预，例如由创新增长实验室倡导和运行的干预，是这种混合的重要元素。

在私营部门方面，一些平台如 GitHub、Meetup 或 Twitter 对其数据相当开放，可以通过开放应用编程接口(API)访问这些数据。LinkedIn 等其他网站非常封闭，它们的数据提供了研究劳动力流动、商业网络和创新能力的绝佳机会。

是否有任何法规、激励措施和技术系统(包括通过安全数据服务共享数据)可以到位，以鼓励更系统地共享这些信息，为创新和经济政策提供信息？

第三，我们需要整合数据集，以获得创新系统的统一视图。如果 YouTube 或苹果应用商店中存在关于内容创新的数据，GitHub 等协作编码网站中存在关于数字创新的数据，Glassdoor 等工作评论网站中存在关于组织创新的数据，我们如何全面衡量创新？

为了有效地合并所有这些数据集，我们需要唯一的标识符来告诉我们，GitHub 中的创新创业公司 X 与参与创新计划 Y 和加速器 Z 的公司是同一家，与科学中已经存在的公司是同一家。政府和数据平台还能做些什么来鼓励像 GLEI 这样的商业标识符的使用呢？那么个体创新者的唯一标识符呢？比如，它可能帮助我们追踪个体轨迹，以绘制思想传播图，并衡量创新项目的长期影响。在这里，我们可以从公共部门的解决方案开始，比如在北欧国家实现了如此多伟大创新研究的个人身份号码，以及私人部门的解决方案，比如 LinkedIn 或 Twitter 等平台上的社交用户 id。

结尾和警告:指标只是开始

我们需要更多更好的数据来制定创新政策，我相信，受科学计量学进步的启发，上述议程会有所帮助。然而，为了产生影响，需要使用我们开发的新指标，并且要聪明地使用。

正是在这一点上，我或许应该缓和一下我对科学领域形势的乐观态度，在这个领域，学者们早就表达了对痴迷于指标，以及简化影响因子或大学排名的过度和扭曲影响的担忧。世界的复杂性将永远压倒我们描绘它的能力，而科学、技术和企业创造力所固有的不确定性将永远挫败我们预测和控制它的愿望。

然而，无知并非福佑，很少有人会认为应对所有这些挑战的方法是停止测量。答案是继续衡量，更好地衡量，谦虚地衡量，理解度量的局限性，通过使用和使用我们所学的东西来学习。这些过程是科学方法的核心，可以帮助我们更好地理解和支持科学以及创新。

此博客最初发布于 Nesta 网站

收到了詹姆斯·菲普斯的有益评论。

说明这篇博客的图像是在罗伯特·胡克的 显微照片 中通过早期显微镜看到的细胞结构，这是如何利用更好的测量来揭示复杂性而不是消除复杂性的例子。

尾注

【1】科学计量学是“科学”和“计量学”的结合体。它指的是对科学的衡量，通常使用出版物或专利等科技产出。

【2】说到这里，有人把微观行政数据和创新调查数据、创新计划数据进行匹配，效果很大。

诚然，书籍或艺术品等其他产出在艺术和人文学科中也很重要。

这些是真正的堆栈溢出趋势:使用页面视图

原文：https://towardsdatascience.com/these-are-the-real-stack-overflow-trends-use-the-pageviews-c439903cd1a?source=collection_archive---------5-----------------------

直到今天，获得 Stack Overflow 的季度浏览量并不容易。了解如何获取这些指标，并开始使用我们的交互式仪表盘。

在这篇文章中，我将向你展示如何获得 Stack Overflow 上每个标签的季度浏览量，以及为什么它很重要。如果您只是想开始玩这些数字，这个交互式 Data Studio 仪表板已经为您准备好了:

Update chart 2019–01, see previous results and how-to below

Original results 2018–06, see updated above

TensorFlow 真的比 Git 更受关注吗？

根据堆栈溢出趋势工具 tensorflow现在比git更流行:

有意义吗？虽然tensorflow值得很多关注，但git是最受程序员欢迎的工具之一——在机器学习社区内外。事实证明，该工具测量每个标签的新问题数量，而这只是故事的一半。如果我们可以比较每个标签的页面浏览量百分比和问题百分比，会怎么样？

Top chart: Percentage of views that ‘git’ gets on Stack Overflow, vs ‘tensorflow’. Bottom chart: Percentage of new questions for each tag on Stack Overflow. Turns out ‘git’ gets way less new questions, but way more views.

发生了什么:看看图表——即使每个季度为tensorflow创造了更多的问题，标有git的问题获得了至少 6 倍的浏览量。

我们可以看到.net对firebase、c++对r以及.net对typescript的类似趋势:

These charts show that in '.net’ vs 'firebase’, 'c++’ vs 'r’, and '.net’ vs 'typescript' one of the technologies gets more pageviews, while the other gets more new questions.

您可以在这里看到，衡量新问题的数量只能说明问题的一半。如果你是 Stack Overflow 博客的粉丝，你会发现在许多故事中，甚至他们也使用了%的浏览量。但是获得堆栈溢出时每个标签每个季度的查看次数并不容易，直到今天:

• Stack Overflow 提供了他们的趋势工具，但是它只关注新问题的数量。
• Stack Overflow 提供了数据交换服务，在这里人们可以发布和运行任意的 SQL 查询。编写一个查询来计算新问题的 #很容易，但是要找到历史浏览量是不可能的。
• Stack Overflow 还发布了他们数据的季度转储，这些数据我们在 BigQuery 上分享，供任何人分析。同样，很容易找到每个季度的问题数量，但不可能找到历史的视图数量。
• 但是，如果您有每个堆栈溢出转储的副本，然后在它们之间进行数学运算来计算每个标签的季度浏览量，会怎么样呢？我就是这么做的！

其他有趣的比较

前 5 名:Java、JavaScript、Python、C#、Android、PHP

• Java 和 Javascript 一直是最受关注的——但是 JavaScript 每个季度都会收到更多的新问题。
• Python 正在快速追赶！它得到的问题仍然比 JavaScript 少，但它得到的浏览量比 Java 和 JavaScript 多。
• C#在页面浏览量排名前五，但在问题数量排名前五。另一方面，PHP 有很多问题，但不足以在页面浏览量排名前五。

JavaScript 框架:Angular vs Angular，React，Vue

• 如果angularjs要死了，谁来代替它？不是别人，正是angular！您可以想象这个新标签在问题数量和浏览量方面接管前一个标签有多快。
• reactjs哪儿也不去，而是向右上方走。
• vue.js比其他替代产品更受关注，但仍有很长的路要走。

机器学习

• TensorFlow 和 Keras 吸引了所有的注意力和问题。
• PyTorch 和 MxNet 勉强注册。咖啡在 2017 年更强，但这些天融入了底部。

即将推出的语言:Swift，Go，Haskell，Kotlin，Rust

• Swift 盖过了这一类别中的所有其他公司。
• Go 在浏览量上比在问题数量上更有优势。
• 科特林是生长最快的。
• 哈斯克尔和拉斯特:保持强大的伙伴！

Swift, Go, Haskell, Kotlin, Rust attention on Stack Overflow — progressively removing the top ones to highlight the differences between the remaining.

BigQuery vs 红移

我❤大查询。

AWS Lambda vs GCP 函数 vs Azure 函数

• AWS 有优势，但 GCP 和 Azure 一直在向右上方移动。

App Engine vs Kubernetes vs Heroku

App Engine 是我最喜欢的 PaaS，但这几天关注度越来越低。与此同时，Kubernetes 不是一个 PaaS，但它不断得到更多的问题和关注。

让我们更深入:通过页面浏览量的趋势问题

那么，我们能根据浏览量找到每个标签的首要问题吗？当然:

但是让我们把它留给我的下一篇文章。敬请期待！

链接

[## 堆栈溢出数据可能揭示谷歌在云中对抗亚马逊的秘密武器

有许多不同的方法来评估不同技术的受欢迎程度。Redmonk 看 GitHub 和 Stack…

www.techrepublic.com](https://www.techrepublic.com/article/stack-overflow-data-could-reveal-googles-hidden-weapon-against-amazon-in-the-cloud/)

操作方法

我们在 BigQuery 中使用 Stack Overflow 的数据，由谷歌云公共数据集计划每季度更新一次

[## Google BigQuery 公共数据集现在包括堆栈溢出问答

2016 年 12 月 15 日星期四

medium.com](https://medium.com/google-cloud/google-bigquery-public-datasets-now-include-stack-overflow-q-a-5a8a7e371b52)

每季度页面浏览量

#standardSQL
WITH historic_views AS (SELECT *, '201703' qFROM `fh-bigquery.stackoverflow_archive.201703_posts_questions` UNION ALLSELECT *, '201706' q FROM `fh-bigquery.stackoverflow_archive.201706_posts_questions` UNION ALLSELECT *,  '201709' q FROM `fh-bigquery.stackoverflow_archive.201709_posts_questions` UNION ALLSELECT *, '201712' q FROM `fh-bigquery.stackoverflow_archive.201712_posts_questions` UNION ALLSELECT *, '201803' q FROM `fh-bigquery.stackoverflow_archive.201803_posts_questions` UNION ALLSELECT *, '201806' q FROM `fh-bigquery.stackoverflow_archive.201806_posts_questions` 
), top_tags AS (SELECT value FROM UNNEST((SELECT APPROX_TOP_COUNT(tags, 5000)top  FROM `fh-bigquery.stackoverflow_archive.201803_posts_questions` WHERE NOT tags LIKE '%|%'))WHERE count > 10
), views_per_tag AS (SELECT tag, COUNTIF(DATE(creation_date) BETWEEN DATE_SUB(PARSE_DATE('%Y%m',  q), INTERVAL 3 MONTH) AND PARSE_DATE('%Y%m',  q)) questions, SUM(view_count) views_cum, PARSE_DATE('%Y%m',  q) qFROM historic_views, UNNEST(SPLIT(tags, '|')) tagGROUP BY tag, q
), views_per_q AS (SELECT *, views_cum - LAG(views_cum, 1) OVER(PARTITION BY tag ORDER BY q) viewsFROM views_per_tag
), percents AS (SELECT *, 100*views/SUM(views) OVER(PARTITION BY q) views_percent, 100*questions/SUM(questions) OVER(PARTITION BY q) questions_percentFROM views_per_qWHERE views IS NOT nullAND tag IN (SELECT value FROM top_tags)
) SELECT *
FROM percents

显著的趋势差异

#standardSQL
WITH toptags AS (SELECT *FROM `fh-bigquery.stackoverflow.201806_stacko_tags_views` WHERE q='2018-06-01'AND tag NOT IN ('string', 'git', 'sql')AND views_percent>0.05
)SELECT a.tag, b.tag btag, a.views_percent - b.views_percent
FROM toptags a
JOIN toptags b
ON a.tag!=b.tag
AND a.views_percent>b.views_percent
AND a.questions_percent< b.questions_percent
ORDER by 3 DESC

后续步骤

如果你也想看看每个问题获得的浏览量:我发表了它。

[## 真正的顶级堆栈溢出问题

很容易找到有史以来最大的堆栈溢出问题，但是当前最大的问题给了我们什么…

towardsdatascience.com](/finding-the-real-top-stack-overflow-questions-aebf35b095f1)

想要更多的故事？查看我的中，关注我的推特，订阅reddit.com/r/bigquery。还有试试 big query——每个月你都可以从免费获得一个完整的 TB 级分析。

[## BigQuery 惰性数据加载:DDL、DML、分区和半万亿维基百科页面视图

分析维基媒体公开发布的 4tb 维基百科浏览量数据集的最简单方法是什么…

medium.com](https://medium.com/google-cloud/bigquery-lazy-data-loading-ddl-dml-partitions-and-half-a-trillion-wikipedia-pageviews-cd3eacd657b6) [## 堆栈溢出何时回复:如何用 BigQuery 预测

当你最后发布一个关于栈溢出的问题时，一个漫长的等待就开始了。有人会回答你的问题吗？会不会…

medium.com](https://medium.com/@hoffa/when-will-stack-overflow-reply-how-to-predict-with-bigquery-553c24b546a3)

我们不必担心的事情人工智能:工程师/科学家的视角

原文：https://towardsdatascience.com/things-we-dont-have-to-worry-about-ai-an-engineer-scientist-s-perspective-f7695d434004?source=collection_archive---------22-----------------------

Photo by Joakim Honkasalo on Unsplash

人工智能这个词通常与每个领域的颠覆联系在一起，通过优化，由不同类型的预测提供动力，通过智能和精细的控制实现自动化。但谈到人工智能的未来，我们所能想到的就是散布关于人工智能最新进展的恐惧文章，以及最终人工智能反人类的电影，这些电影刺激我们倾向于智能机器消灭我们，或者通过诱导技术奇点来奴役我们，使我们成为存在的威胁。

事实上，有几个伟大的论点确定性地使智能机器成为人类迫在眉睫的生存威胁，就在我们创造它们的那一刻。其中一个全面的论点如下- 通过给智能机器设定目标，我们确保了它的自我保护、资源获取和独立决策，当智能要求统治时，它们的目标机制将会走向显示统治和夺取对世界的权力，因此最终奴役我们或消灭我们。

这种论点范式的例子很流行，继承了这种论点的全部或部分性质，但最终成为对人类的威胁或终结。

曲别针最大化器

其中之一是“回形针最大化器”。这就是这个思维实验或特殊困境的过程——一个人工智能代理决定或被告知制作尽可能多的回形针。它试图通过改进自己来获得大量的回形针，寻找获得回形针的新方法，同时抵制自己偏离目标。在某个时候，它开始首先改造整个地球，然后增加空间部分成为回形针制造设施。

在同一个领域的另一个思维实验是这样的——想象一下，一个最初被编程用来消除癌症的医疗机器人如何得出结论，消除癌症的最佳方式是消灭基因上易患这种疾病的人类。

这些思想实验(以及大多数其他实验)的一个重要警告是，它们假设我们自己创造的未来是完整而复杂的人工智能，但考虑到它相对于人类今天的理解或智能的统治地位。有人强烈支持，为了将智能集成到机器中，我们首先必须了解我们自己的智能，这是我们所知道的唯一全面的智能。因此，创造完全人工智能的人类智能将比我们今天的智能更加复杂。

用瑞士神经科学家帕斯卡·考夫曼的话说，他是 Starmind 公司的首席执行官，该公司的使命是创造一个由数千名专家的大脑组成的“超级有机体”

“更好地了解我们自己的大脑不仅会使人工智能成熟到足以与人类智能相匹敌，还会使脑机接口更好，使两者之间能够进行对话”

我们成功地建造了一个人工智能代理人，这种理解是对那些通过我们自己的创造或我们自己的好奇心标志着人类末日的论点的一种令人平静的反驳。

我们不能担心智能特工伤害我们的所有可能性。有些可以通过良好的工程来避免，有些可以通过这些代理如何工作的强有力的理论来避免，但大多数可以通过我们真正知道我们在做什么来避免。最重要的是，我们都有一个有限的“担忧预算”。我们的时间、精力和努力也是如此。这些是一些担心不会有成效而且看起来很愚蠢的话题，久而久之。

I/O 目标和行动

我们给智能代理设定目标的方式，以及我们从它那里获得帮助来完成事情的方式。目前，我们不会给使用自然语言的机器(狭义智能)设定目标。我们不要求计算机-“学习驾驶并帮助我们驾驶我们的汽车”，不，我们编写一个学习程序，它通过经验(数据)学习如何处理一些情况(这里是驾驶)，然后将这个程序部署到我们的汽车中，使它能够控制或自动驾驶汽车。

在未来，我们不会通过自然语言为一个智能主体设定目标，而不确定他们不会太过拘泥于字面意思，或者他们不会因为不知道实现目标的方法而显得荒谬。即使对于自主代理，我们也不会给予超过他们完成任务所需的控制权。这是很好的工程。

潜在目标对齐问题

当我们不像让智能代理开车那样具体或精确地输入目标时，这个问题就出现了。例如，当我们用自然语言发出指令时，它必须根据输入的命令字符串来推断目标、子目标和目标函数。这对机器来说可能非常困难，因此它会犯错误，伤害人类，或者至少让人类后悔接受机器的帮助。

我们没有创造任何基于自然语言进行核心控制工作的机器，也没有创造任何可以推断潜在目标、子目标结构及其重要性、难度、可行性等的机器。所以，担心我们如何给我们将在离现在更远的未来制造的机器设定目标是没有建设性的，也是没有任何成效的。

道德和驱动力的一致性

这类通过智能机器灭绝人类的论点非常流行。如果我们创造的机器具有与我们不同的驱动力和伦理，那么它们最终会伤害我们，或者至少成为我们探索自己驱动力的障碍。

从古代哲学家到现在的认知科学家，对人的欲望、目标和内容机制的研究已有数千年。我们已经确定，理解我们自己的智能可能是创造人工智能所必需的。那么，在我们制造智能机器之前，我们应该已经想出了这个问题的答案，通过了解我们的机制，并试图在机器中模拟它们。

如果我们担心智能代理改变它们的目标和驱动来伤害我们，脸书人工智能集团主任严乐存已经暗示了加密目标函数，它不允许机器改变我们给它们的目标。

主观经验论证

与上述所有概念不同，主观经验通常用于反对机器获得任何内部驱动力或动机，这些驱动力或动机必须与内部主观感觉相联系。因此，没有主观经验，智能代理只是有目标和目的的实体，但不一定有动机改变它们以伤害它们的创造者。

如果智能机器没有主观经验或拥有与我们不相似的东西，那么智能机器会渴望自由或拼命寻找其存在的意义的想法只是一厢情愿。

资源获取约束

像计算时间、计算能力、电力、互联网连接这样的资源可以通过对智能代理的约束来提供。我们必须给代理人资源来完成目标，但是很容易对这些资源进行限制。

更有害的资源，如与具有相同目标的代理人形成群体、协作的统一行动和社会发展方面，获取起来要复杂得多，并且相对容易受到约束，就像在物理世界中一样。人类通过从一个文明到另一个文明的进化，缓慢地学会了交流、合作和共同生活。

史蒂夫·平克(Steve pinker)对智能机器有一个很好的看法，与上面类似，当被问及它们是否会在这次采访中成为一个存在的威胁时。

从数据中学习的归纳力量

机器从数据中归纳出智能。为了在从数据中学习的机器中激发新颖和创造性的行为，需要提供抽象和贯穿模型架构的视角。很可能，这种感应能力不足以模仿我们复杂的欲望和内容机制或最终会伤害人类的主观体验。

我们的创造力和好奇心源于强烈的欲望、目标和内容机制。我们需要对自己的智能进行大量的增强和理解，才能在一个自主代理中大规模地整合这些属性，这肯定不能仅仅从大量的数据中归纳出来。

我属于试图制造智能机器的领域，而不是头脑风暴这个领域的成果及其对社会的影响。我不反对来自外部的批判性分析，每个领域都应该有来自外部的这种元素。但是在大量这样的分析中，我作为制造智能机器和研究大脑的研究者的观点，似乎对归功于智能机器的非凡事物更具批判性，只是因为直面制造智能机器的所有障碍。

在同样的背景下，美国计算机科学家、图灵奖的第一位获得者艾伦·珀利斯(Alan Perlis)说:“在人工智能领域度过的一年足以让人相信上帝。”

人们很容易对我们正在建造的智能机器以及人类控制它或与之共存的能力产生误解。这些概念有助于我们克服穿越这些地形时的陷阱。

人工智能不会在一夜之间出现

智力不会像意外一样突然出现。智力不是新奇的直觉。我们不知道人类的智力发展了多少亿年，这是时间孕育的进化的丰硕成果。因此，它不会突然出现在一台机器或一组机器中，然后繁殖/改进自己，以至于超越人类，奴役我们。

智力不能解决一切

当我们谈论未来的智能机器时，我们倾向于认为它们具有机器所具有的所有超人能力，快速、精确和具体的计划行为，以及我们人类已经拥有的能力。我们理所当然地认为我们作为人类所拥有的能力，我们在自己之间建立的沟通和协作是因为我们都分享的潜在故事和我们都想实现的集体目标。首先，对于机器来说，在一个物理世界中培养这种能力对我们来说既不是迫在眉睫的，也不是模糊不清的。此外，培养这种能力可能会有很多副产品，其中之一可能是以更富有成效的方式与人类合作的能力。

智慧可能不渴望权力

当我们想到智能机器时，我们倾向于假设智能来自于控制或夺取权力并显示统治地位的欲望。那可能是完全不同的事情。此外，就智力而言，我们不应该假定它与我们所拥有的东西相似。

目前，自主代理不能有任何主观道德(无论是好的还是坏的)

目前，我们并没有给一个自主的代理人伦理，我们只是让它按照我们自己的伦理行事。此外，我们可能不会制造理解我们的道德准则和伦理的机器，我们只是必须努力制造行为符合它们的机器，并且必须根据我们是否会因为它所呈现的效用而容忍它的不良影响来部署它们。在制造自动驾驶汽车时，我们只是试图让它们尽可能符合我们的道德规范。在这个时候，我们无法理解生活在这个世界上的所有道德规范，我们的行为会影响周围人的生活，目前，这些知识对这些机器来说是不合情理的。说一辆自动驾驶汽车有意识地杀死了一名老妇人而不是一名儿童是不符合逻辑的。

所以，大多数时候当我们在思考智能机器的时候，我们只是在一厢情愿地娱乐我们对未来的恐惧。

但是，这种对每一种可能的厄运的分析确实有一些用处——例如，我们知道在设计这些东西时应该多小心，以及我们应该小心哪些东西。

现在还不要担心这些事情-(也许几个世纪)

生存威胁

要做到这一点，智能机器种族应该有一个共同的目标，那就是夺取宇宙的权力，应该成功地获取巨大的资源，然后，我们应该在控制它们和与它们如此可怕地和谐相处方面失败，尽管我们一开始就有能力建造它们。

奴役人类

这就像一个催眠术的故事。在这一点上，机器种族不知何故需要人类来维持他们的生存，或者以奴役他们的创造者为乐。生存威胁比这种困境更有可能。我们已经建立了反对生存威胁的有力论据。

技术奇点

人类的智力是一个至今几千年都没有解决的问题。除此之外，当我们最终足够聪明，能够制造出能够让自己变得更好的智能机器时，我们至少应该希望，我们能够确保自己的存在不受影响，无论是在我们的生物体内还是在任何人造体内。

这是《 探知情报 》报道中的一篇专栏文章。参考基础文章- 计算机器中的智能——了解更多详情。这篇报道中即将发表的文章详细讨论了深度学习在生物学上是否合理，以及在深度学习和神经科学的交叉点上，生物学上的合理性是否重要。

成为数据科学家需要知道的事情

原文：https://towardsdatascience.com/things-you-need-to-know-about-becoming-a-data-scientist-2467a3f61457?source=collection_archive---------4-----------------------

读者您好！这篇文章(以及我所有的文章)的更新版本在我的网站上免费提供:Victoria . dev—感谢阅读！

我最近参加了一个由大会在新加坡主办的题为“所以你想成为一名数据科学家/分析师”的小组讨论。该小组介绍了职业生涯不同阶段的专业人士，并为有希望的观众提供了丰富的信息，包括如何找到数据科学家工作的技巧，以及揭穿该领域神话的故事。

小组成员

米斯拉布·费祖拉-汗 —数据科学副总裁、戈 _JEK
安东尼·塔 —数据科学家、亚洲科技
利奥·郭俊 —数据科学家、戈 _JEK
加百列·江 —数据科学家
亚当·德雷克 —首席数据官、阿塔佐

这里有一个讨论要点的纲要，为简洁起见进行了解释。

一天的生活是什么样的？

我们大多是“数据管理员”数据处理的很大一部分始于数据清理，并由数据清理组成。没有高质量的数据，你不会得到准确的结果。了解应该如何清理数据在很大程度上包括与数据分析没有直接关系的技能。为了充分理解你希望解决的问题，你需要与相关人员交谈。重要的是，每个人都了解项目的所有元素，以及这些元素的确切名称。以“销售额”为例，根据谈话对象的不同，计算方式可能会有所不同。

什么是数据“科学家”与数据“分析师”？

这很大程度上取决于你工作的公司。“Data [insert modifier]”只是历史上被称为“业务分析”的工作领域的一个新的区别在较小的公司中，与任何其他职位一样，一个人可能会在“数据科学家”的头衔下处理各种与数据相关的任务在一个拥有更多员工和更精细专业化分工的大公司中，你可能会有一个处理较少技术方面的“数据分析师”，和一个工作技术性很强并涉及定量学习或机器学习的“数据科学家”。

数据科学/分析领域足够新，以至于职称的标准定义还没有达成一致。考虑职位时，关注公司而不是头衔。

应该加入创业公司还是大公司？

没有错误的答案。了解自己的工作风格和偏好将有助于指导你的决定。

创业公司通常提供更多的自由和更少的微观管理。这也意味着你必须接受更少的指导，并且需要能够自己解决问题、学习和进步。

在一家大公司，你可能会经历更多的结构，并被期望遵循非常明确的既定流程。你的工作范围可能会比创业时更集中。总的来说，你会体验到更少的自由，但是对你的期望却更加确定。

最后，尤其是在你职业生涯的初期，不要太看重选择这个或那个。如果你喜欢这家公司，不管是大公司还是小公司，试一试。如果几个月后你对那里不满意，那就换一家试试。没有什么职业决策是永恒的。

同样值得注意的是，即使你第一次就找到了喜欢的公司，一两年后换公司对你最有利。你一生中获得的大部分加薪将发生在职业生涯的头十年。假设你被 A 公司聘为初级数据科学家，为期两年——两年后，你就不再是初级了。比方说，你现在可以在数据科学家的职位上获得 30%的加薪，但两年后 A 公司不太可能给你加薪 30%。在这一点上，是时候找到 B 公司，在你的简历上多写几年的经验，然后可能再次换公司。你不会在一家公司呆上几十年就挣大钱——你永远都是初级开发人员。

总体而言，对于数据科学候选人来说，最重要的技能是软技能。好奇心、韧性和良好的沟通技巧至关重要。坚持，尤其是在适应快速变化的行业时，是非常重要的。最有前途的候选人对这个领域有足够的热情去学习他们能学到的一切，甚至是他们工作范围之外的东西。像编码和算法这样的硬技能是可以教授的——是软技能让优秀的候选人脱颖而出。

黑客技能也至关重要。这并不一定意味着你可以写代码。掌握整体概念、了解算法、有足够的好奇心不断学习的人会比只会写代码的人走得更远。在熟悉基本导航点的基础上建立黑客技能需要创造力。有能力提出以新的方式使用可用工具的解决方案——这就是黑客技能。

设计思维是另一个重要的资产。能够理解系统如何在技术和业务层面上集成是非常有价值的。如果你能看到全局，你更有可能找到不同的方法来完成总体目标。

你可能认为在简历上看到流行语会让你作为候选人看起来更有吸引力——更多时候，这是一个危险信号。把“高级机器学习”放在简历上，然后证明自己不懂基本算法，看起来不太好。最能说明你的是你的项目和你申请的工作之外的兴趣。这个行业的热门话题变化很快——你最好对基本原理有一个扎实的掌握，并有广泛的经验，而不是随便说出什么趋势。

人类在数据科学领域有前途吗？机器什么时候会取代我们？

这不是数据科学独有的问题，许多历史例子已经存在。金融投资是一个很好的例子——过去你可以让一个人进行计算和预测，现在计算机可以自动完成很多工作，每天对风险和可能的回报做出决策。

就像在其他已经接受自动化的行业一样，人类不会被取代的地方是人的因素。你仍然需要人来处理沟通、创新、好奇、解释和理解问题……所有这些都是企业中人的基本方面。

最终，机器和更多的自动化将使人类的工作变得不那么痛苦。通过自动化世俗的东西，比如数据净化，人类的思想被解放出来去开发更有趣的东西。

数据驱动自动化的未来应用是什么？

法律是自动化的下一个很好的候选对象。使用数据评估风险的程序可以处理很多问题。

医学是另一个通过数据进步的成熟领域。放射科医生，你的日子屈指可数:图像检测来找你了。整个诊断学领域将会彻底改变。

数据科学最近一个特别有趣的应用是语言翻译。通过观察不同语言的句子结构和口语的相似性，我们能够根据相似的单词在语言结构中占据的“空间”对它们进行分类。

保险业——最初的数据科学行业——已经并将继续变得非常自动化。随着使用数据评估风险的能力增强，我们开始看到新的创新保险产品推出。电子商务公司现在可以为客户退回产品的风险购买保险——如果没有我们今天拥有的数据的可访问性，很难做到这一点。

我如何推动数据驱动的决策，并让我的老板同意我的观点？

这是一个有内涵的问题。归根结底，这取决于公司的数据文化和决策路径。我们经历过为管理层工作，他们说，“我们已经做出了决定，我们只需要数据来证明。”显然，这是一个艰难的工作岗位。

一般来说，问问你自己，“我让我的老板看起来很好吗？”你可能会听到这些，然后想，“为什么我要让我的老板得到所有的荣誉？”—但是谁在乎呢？让他们去邀功吧。如果你能做出好的工作，你就让你的团队看起来不错。如果你让你的团队看起来不错，你对你的团队和老板来说就是不可或缺的。不可或缺的人会被倾听。

你对初露头角的数据科学家有什么最好的建议？

不要太热衷于太快定义自己。如果你过于缩小你的关注范围，尤其是在你学习的时候，你可能会陷入成为“技术 A，第 3 版”专家的境地，而公司正在寻找第 4 版的专家。它发生了。

总体而言，对基本面的广泛理解对你更有价值。也许你开始写代码，并决定你不喜欢它，但发现你真的很擅长设计大局观的东西和领导团队，你最终成为了技术领导。这甚至会因你工作的公司而异，所以要保持灵活性。

你最好的选择是追随你所热爱的，并尝试理解广泛的整体概念。花大部分精力学习永恒的东西，比如像 TensorFlow 这样热门话题下的基础技术。用对当地情况、不同公司和产品的广泛了解来武装自己。

如果你专门专注于学习代码，学好一门语言就更容易学习其他语言。确保你了解基本知识。

TL；it 博士:

亚当:多说不要放弃。
安东尼:【为人】勇敢，而且事必躬亲。
加布里埃尔:要有创意。
郭俊:值得付出痛苦。
米斯拉布:自我评估，保持反馈循环。

General Assembly 是众多对数据科学职业感兴趣的学校和资源之一。如果你想了解更多，我强烈推荐这篇文章。祝你好运！

原载于vickylai . io。

关于数据科学作为平台的思考

原文：https://towardsdatascience.com/thinking-about-data-science-as-a-platform-f9e98277dcc6?source=collection_archive---------3-----------------------

“数据的可用性”是一个成熟的改进和发展领域。毕竟，只有人们使用数据，数据才有价值。我的博士研究表明，在决策中使用数据是一个需要更多投资的领域。

进入 Data Science as a Platform ，或 DSaaP (读作 dee-sap)——专为每位业务经理量身定制的一站式洞察、关键绩效指标和知识商店。

DSaaP 提供了将出色的用户体验(UX)与按需提供的全面洞察相结合的机会。业务经理会像每天处理电子邮件一样登录该工具，并将 DSaaP 作为他们工作的一部分。

DSaaP 可能会是什么样子？它是如何工作的？

当我谈到 DSaaP 时，我想到了几件事。第一个是与业务用户系统(如 Active Directory)链接的登录屏幕。这是为了确保 DSaaP 可以由 IT 人员集中维护，而不是作为一个独立的工具。见下图 1。

Diagram 1: DSaaP login mock-up

登录到 DSaaP 系统后，用户会看到一些小部件。每个小部件都是一个仪表板，用户只能看到与其项目和小组计划相关的仪表板。

例如，负责数字渠道的营销总监可能有一个社交媒体仪表板、一个在线媒体支出仪表板和他们的营销团队 KPI 仪表板。见下图 2。

Diagram 2: DSaaP homepage mock-up showing different dashboard widgets

所有的小部件将是可互换的和动态的。它们将由用户和分析师共同控制。用户决定哪些数据是最重要的，因此决定了出现在主屏幕上的小部件。

分析师负责维护底层仪表板，并通过 DSaaP 系统主动向用户发送有关任何新见解、警报或重要信息的消息。

DSaaP 系统的底层架构展示了数据交换是如何工作的。见下图 3。

Diagram 3: DSaaP architecture example

DSaaP 系统本质上是从分析开始的(图 3 中的步骤 1)。数据科学家和分析师使用不同的工具来运行模型、执行分析项目和设置最终将被仪表板小部件需要的底层数据。

然后，这些数据被保存到业务环境中的表或数据源中(图 3 中的步骤 2)。

在那里，分析师创建数据可视化和仪表板，并显示给最终用户(图 3 中的步骤 3)。例如，这些可以是 web 应用程序中的定制版本，或者是 Tableau、Qlik、DOMO 或 PowerBI 等可视化工具中的定制版本。

可视化的位置和类型取决于仪表板主题。每个仪表板都用关键字分类或标记，DSaaP 将使用这些关键字来过滤显示给每个用户的小部件。

例如，数字渠道的高级营销总监 Mark Doe 可能会获得标有“社交媒体”、“数字广告表现”和“数字营销分析”的仪表板。

然后，分析师将仪表板发布到 DSaaP 系统(图 3 中的步骤 4 ),当用户登录门户时，这些仪表板将显示给用户。

最后，DSaaP 如何帮助决策？

DSaaP 为“数据可用性”提供了许多好处。下面列出了一些好处，但最终归结为三点:每个业务领导者的整体洞察力、引人入胜的用户体验和集中的工具。

DSaaP 的主要优势

• 提供了一种工具来访问由专家策划的见解，从而限制了访问数据时的主观偏见
• 在一个位置存储整体见解，使分析师能够将所有数据源和数据见解集中在一个位置，这样业务经理就可以花更少的时间来消化来自不同团队的见解
• 通过出色的用户界面鼓励数据使用——UX 是 DSaaP 的核心，以用户为中心的智能 UX 意味着管理人员更有可能使用该工具来收集他们做出决策所需的信息
• 提供真实的单一来源—在一个地方提供见解，消除重复工作并建立对数据的信心
• 可与任何可视化工具配合使用——DSaaP 基于小部件，具有通过 API 收集的仪表盘，或基于每个部分的最佳数据可视化工具(如 Qlik、Tableau、Domo 或自定义可视化工具)嵌入到界面的各个部分
• 有助于消除数据孤岛，构建集中工具自然有助于消除数据孤岛，分析师不得不考虑公共平台。这也意味着底层数据的位置不太重要，数据湖或关系数据库都可以输入到 DSaaP 中

DSaaP 思维已经在 Qlik、Tableau 和 DOMO 等工具中开始，但它们只是解决方案的一部分。这些工具很好地可视化了数据，但是在整个企业中扩展起来很麻烦，并且没有提供覆盖所有数据源的必要功能。DSaaP 需要更广泛，能够覆盖所有用例，从 Tableau、DOMO 或任何其他工具中引入可视化，以及由 R、Python 或 JavaScript 等程序构建的自定义可视化。

我们现在拥有了开发 DSaaP 所需的所有部件。机器学习、API、支持网络的应用和数据可视化都已经达到了 DSaaP 现在可以而且应该成为现实的地步。为决策制定开发 DSaaP 的好处是引人注目的，令人鼓舞的是，许多创新企业已经开始创建 DSaaP 的工作版本。

想写关于数据科学的博客吗？这里有一些提示和可能的好处。

原文：https://towardsdatascience.com/thinking-of-blogging-about-data-science-here-are-some-tips-and-possible-benefits-680ff0e51d67?source=collection_archive---------7-----------------------

有如此多的初级、中级和专业数据科学家通过为数据科学博客和/或他们的个人博客写作来与社区分享。一般来说，他们的文章可以是技术性的，也可以是非技术性的。技术文章通常用一些代码来解释一些技术概念。在这篇文章中，我将试图说服你开始写作，并给你一些如何开始的指导方针。

让我们从确定你为什么应该开始写作开始:

打造个人品牌

这对数据科学来说是正确的，对任何其他职业道路来说也是正确的。当你写作时，你就确立了自己作为数据科学专家的地位。网上的人会把你和你写的东西联系起来。当人们想到你的时候，他们会根据你写的东西来看你。作为一名数据科学家，这对于建立你的个人品牌是一件非常好的事情。写作是你向世界展示自己能力的一种方式，也是你一份无声的简历。有许多出版物，如《走向数据科学》和《心跳》,你都可以投稿。与你的个人媒体账户相比，与他们一起发表的优势在于，他们有编辑在你的文章上线前对其进行审核。他们也会给你反馈，帮助你提高写作技巧。他们做的另一件令人惊奇的事情是帮助你把你的内容推到网上。这确实对你在这个领域建立品牌大有帮助。

成为数据科学社区的一部分。

LinkedIn、脸书、Medium 等网站上有许多数据科学社区。通过写作，你也建立了一个追随者的关系，他们总是期待你的作品。当有人在 LinkedIn 上联系我并告诉我他们知道我是我们国家机器学习的贡献者之一时，我感到很惊讶。知道你的工作为外面的人提供了价值是如此的激励人心。通过为这些社区做贡献，你也把自己放在了一个从社区获得帮助变得容易的位置上。这是因为人们认为你是真正关心社区发展的人。一些出版物也付钱给你为他们写作，但是如果这将是你写作的唯一理由，我可以向你保证，你不会在游戏中持续足够长的时间。

指导他人

因为有了互联网，我们生活在一个地球村的世界上。因为他们的课程和博客，我很崇拜很多数据科学家。虽然他们可能不知道，但他们正在指导我和许多其他崇拜他们的人。同样，我的工作和你的工作可以指导其他数据科学爱好者，因为现在所有人都连接起来了。我认为最好的学习方法是向走在我们前面的人看齐，与我们处于同一水平的人一起工作，并指导那些仍在前进的人。你还在等什么？是时候为下一个数据科学爱好者点燃蜡烛了。

向前支付

你很有可能因为有人指导你、出版了一门课程或写了一篇博客而学到了你所知道的东西。同样，你的工作可以支持即将到来的数据科学家相信他们梦想的美丽。这也是保持社区发展的一种方式。

无数机会之门

当你写作的时候，你的作品会立刻被全世界的人看到。任何人在谷歌上搜索你或者查看你的个人资料都可以找到你的作品。我开始在我的个人媒体账户上写作，后来开始为《走向数据科学》写作。波士顿一个机器学习博客的社区经理看到了我的工作，并通过 LinkedIn 联系了我。他们想知道我是否有兴趣为他们的博客写付费文章。很多人想为付费博客写作，但他们没有作品集可以展示。当机会出现时，你的文章将成为你的简历。

既然已经说服你应该写作，让我们来看看你应该牢记的一些指导方针。

不是每个人都会读你的文章

把这些碎片拼在一起需要很多时间，但事实是，并不是每个看到你文章的人都会读它。记住这一点，让人们容易浏览你的文章。不要写独白。使用副标题，然后在它们后面加上解释。如果你的副标题吸引了读者的注意力，他们会继续往下读。写一篇没有副标题的长文章会让读者很难理解你的文章。

尽可能使用图像

我们是视觉生物。图像能吸引读者的注意力。用图像来解释某些概念。例如，如果你正在写一篇关于决策树的文章，一个决策树的图片会让读者很容易理解决策树的概念。

使用要点

不要在一个句子中倒数，而是用要点来做。在一个段落中记下要点会让你很难理解一篇文章。使用项目符号或数字使文章的结构看起来很好，容易理解。

你的代码是你文章中最不重要的东西

最重要的是让读者理解这些概念。当他们这样做时，他们可以使用任何可用的工具来实现它们。根据经验，你应该总是在编码前解释，然后再解释。在你粘贴任何代码之前，确保你已经事先解释了代码段将要做什么。没有事先解释就复制粘贴代码会使你的文章难以阅读和理解。解释某个函数所采用的参数，以便读者有正确的理解。不要只解释表面的东西。花时间深入解释概念。不要只是复制粘贴谷歌上全球可用的内容。花点时间研究，这样你的文章才能为读者提供真正的价值。

小心时态

如果你在写一篇观点文章，你可以用“我”和“我的”这样的词。然而，如果你正在写一个教程，使用诸如“让我们”这样的词。例如，不要说我现在将加载数据集，你应该说让我们现在加载数据集。

一些数据集被过度使用

Iris 数据集等数据集已被多次使用。虽然使用这些数据集没有错，但读者总是希望看到新的东西。使用像 Keras 或 Scikit learn 这样的软件包附带的数据集也很好。然而，这些数据集已经很干净，剥夺了读者了解如何为数据科学准备数据集的机会。虽然并不总是可能做到这一点，但我可以向您保证，初学者总是在寻找展示完整数据科学生命周期的文章。

在发布之前获得人们的反馈

在发布前征求反馈有助于在发布前改进您的文章。它可能会帮助你添加一些你忽略的东西，或者删除一些不必要的东西。

校对你的工作。

这听起来显而易见，但却非常关键。阅读一篇有拼写和语法错误的文章是极其困难的。

不要停笔

你会惊讶地知道，有一些人正急切地等待你的下一个帖子，不要让他们失望。

结论

写作和其他技能一样，需要时间来掌握。你要做的就是开始。随着你不断写作，你的技能会提高。所以，如果人们不喜欢第一个帖子，不要放弃。我希望我已经说服你开始为这个了不起的数据科学家社区做贡献。

如果你喜欢这本书，你可能也会喜欢我写的关于数据科学家技术写作的书。

围绕太阳的第三天(或离深潜边缘一英尺)

原文：https://towardsdatascience.com/third-day-around-the-sun-or-one-foot-off-the-edge-of-the-deep-dive-c255a0c2421c?source=collection_archive---------13-----------------------

It’s the wall’s way of saying hello.

今天是我在位于中城/东亚特兰大/庞塞高地/亚特兰大的庞塞市市场或任何他们现在称之为该地区的地方的大会最先进的艺术园区参加数据科学沉浸式项目的第三天。地理很重要。这座城市正在发生许多技术和文化变革，而这个地方是变革的核心。

我已经开始陷入疯狂，希望我不会像《现代启示录》中的库尔茨上校那样结束，尽管我的父亲和朋友会说已经太晚了。确实如此。但今年早些时候变得非常明显的是，职业和个人成长需要大规模的自由转变，这不仅是为了繁荣，也是为了在我看来即将到来的社会经济流离失所的圣经风暴中生存。几年前我听到过一句有趣的话，虽然记不清是从哪里或从谁那里听到的，但那是:

很快，你将不得不决定你是被机器人控制还是由你来控制它们

那好吧。我不期望机器人来控制。但我确实预计，机器和自动化的数字结构将要做的工作，比我们人类个人所能做的要多得多。很少有人真正为这种未来的现实做好准备。如果我希望成功，我需要成为他们中的一员。

一点背景:我在各种营销管理岗位上工作了十几年。我自己注意到的是，由于技术、经济和职业人口统计的变化，不仅在营销领域蓬勃发展变得越来越困难，而且仅仅是生存(我在这里特别重复这个短语，因为营销往往引领媒体和传播变革)也变得越来越困难。尽管我热爱市场营销，并将永远热爱市场营销，但仅仅了解和应用执行市场营销战略和沟通的技术已经不足以保持对企业和其他组织的重要性。

让事情变得更具挑战性的是，学位课程不会让我去我想去的地方。我有工商管理硕士学位。在当前的商业文化氛围下，多一个硕士学位可能对我不利，而不是对我有利。我需要“穿针引线”

我在以前的全职雇主那里了解了大会。几名员工正在学习网页开发和用户体验课程。我也开始看到大会的在线广告，特别是在脸书和 LinkedIn 上。过了一年多一点(！)的研究和自我评估，以确定我是否真的需要采取行动，我决定，是的，这是必要的。参加一个受科技行业尊重的非传统数字教育校园比走传统的学位路线更有效。

我从基础开始:数据分析。我也很高兴那段时间我没有工作，因为尽管是业余课程，它却像浴缸里的海绵一样吸干了我的暑假。但这种努力和牺牲是值得的，因为它为我申请全日制数据科学沉浸式项目做了充分的准备。如果我没有选这门课，我是不可能被录取的。

所以我现在在这里。第三天上课。我的前期工作完成了一半(我在抓紧！我在抓紧时间！).从现在到 12 月 20 日，我还有很多工作要做。别担心，我会确保咖啡杯和水杯放在洗碗机里。我喜欢让事情简单、干净、整洁。

用深度卷积神经网络进行图像到食谱的翻译

原文：https://towardsdatascience.com/this-ai-is-hungry-b2a8655528be?source=collection_archive---------0-----------------------

https://github.com/Murgio/Food-Recipe-CNN

介绍

在这篇文章中，我们将看看如何训练一个深度卷积神经网络，它能够将图像分类为食物类别和输出匹配的食谱。到目前为止，我们强调选择目标领域的困难有两个方面。首先，烹饪菜肴的单个成分的分类或对象识别的进展很少。问题是，实际上没有公共处理过的数据集可用于此。第二，到目前为止，烹饪菜肴表现出内在的高度类间相似性，这使得即使对于最复杂的系统来说，推断菜肴类别也是一个困难的问题。为了应对这些挑战，我们从欧洲最受欢迎的烹饪食谱平台 chefkoch.de 中收集了一个新的数据集，其中包含> 800，000 张食物图像和> 300，000 份食谱，并在数据集上实证比较了当代机器学习模型(卷积神经网络)和更传统方法(最近邻搜索)的有效性。

前言

其他任何领域对人类健康的影响都不亚于营养。每天，用户在社交网络上发布不计其数的食物图片；从第一个自制的蛋糕到顶级的米其林菜肴，如果人们成功地做了一道菜，他们很乐意与世界分享他们的喜悦。事实上，无论一个人与另一个人有多么不同，好的食物几乎都会受到每个人的高度赞赏。

单个烹饪原料的分类进展很少。问题是几乎没有公开编辑过的记录。这项工作处理的问题是自动识别拍摄的烹饪菜肴，并随后输出适当的食谱。所选问题的难度与之前的监督分类问题之间的区别在于，食物菜肴中有很大的重叠(又名高类间相似度)，因为不同类别的菜肴可能仅在图像信息方面看起来非常相似(见图 1)。

Figure 1: Images of distant categories may look similar (be it by similar cooking methods (e.g. grill marks) or an overlap of characterizations, inter alia), but sure enough, don’t taste similar!

根据座右铭分而治之，教程被细分为个更小的部分:

根据目前的状态，超过 300，000 个食谱的最大德语数据集将被搜集和分析。我们假设使用机器学习可能会克服更传统的所谓查询方法的障碍:我们使用卷积神经网络(简称 CNN)将对象识别或烹饪法庭识别与在超过 80 万张图像的记录中搜索最近邻居(下一个邻居分类)相结合。这种组合可以帮助找到更有可能的食谱，并且将分类引导到更有成效的方向，因为 CNN 的前 k 个类别与具有排序相关性的下一个相邻类别相比较。诸如 Kendall Tau 的基于等级相关性的方法本质上测量两个项目在两个分级列表中处于相同顺序的概率。数学上，肯德尔τ计算如下

notation: Rithesh Agrawal

在哪里

• N =总对数
• C =一致对的数量
• D =不一致对的数量

方法学

管道由以下步骤描述:

1. 每个配方 R 由 K 张图片组成。对于这些图像中的每一个，从预训练的卷积神经网络中提取特征向量 w ∈ W (其已经在 ILSVRC 2014 图像识别竞赛中使用 1000 个类别上的数百万个图像进行了预训练)。不严格地说，特征向量在最后一个完全连接的层中形成图像的内部表示，就在 1000 类别的 Softmax 层之前。
2. 这些特征向量 W 然后通过 PCA(主成分分析)从一个N×4096矩阵减少到一个N×512矩阵。结果，选择与输入图像具有最小欧几里德距离的前 k 个图像。由于计算某种成对距离度量是计算密集型的，并且不能很好地扩展，我们将注意力转向变体 ANN(近似最近邻)。
3. 此外，美国有线电视新闻网是用类别 C 和 R 食谱的图片来训练的。 C 是使用一种流行的主题建模技术动态确定的，该技术被称为非负矩阵工厂化(NNMF)和配方名称的语义分析。结果，我们为配方中的每个图像获得了类别上的概率分布。
4. 美国有线电视新闻网(CNN)的前 k 类(2。)与来自前 k 个光学相似图像(1。)与肯德尔τ相关。

图 2 概述了一般方法:

Figure 2: (a) Each image k ∈ K is transformed into the image embedding w and pairwise euclidean distances (L2 Norm) are calculated to the image query q. (b) The query image q is classified with the fine-tuned VGG-16 and the probability distribution is compared to the euclidean distances.

1│── 数据准备
│ └──清算数据
│ └──数据扩充

2)───数据分析和可视化，拆分数据(训练、有效、测试)

3│── 主题建模
│ └──潜在狄利克雷分配(LDA)
│ └──非负矩阵分解

4│── 特征提取
│ └── k 近邻
│ └── t-SNE 可视化

5│── 迁移学习:训练预先训练好的 CNN(卷积神经网络)
│ └── AlexNet、VGG、ResNet、GoogLeNet

6└── 用烧瓶展开

每个部分都包含 Jupyter 笔记本，您可以在 Github 页面上查看。

收集和准备数据

为了能够训练模型，人们需要足够数量的数据(所谓的数据扩充和预训练模型的微调提供了一种补救措施)。只有通过这样的数据量，训练集的泛化能力才能不断提高到一定程度，测试集中的高精度才能实现。本教程的第一部分处理特征及其关系的数据采集、分析和可视化。

无耻之徒:我正在开发一个 python 代码编辑器，它简化了数据分析和数据绘图。更多信息请访问:莫比乌斯代码编辑器

谷歌研究总监彼得·诺维格在 2011 年的一次采访中透露

我们没有更好的算法。我们只是有更多的数据。

无一例外，数据集的质量和数量都不容忽视。这就是为什么欧洲最大的烹饪平台会被刮:每个食谱，最后是 316'756 个食谱(截至 2017 年 12 月)，总共下载了 879'620 张图片。重要的是，下载时不要进行得太快，并保护有太多查询的服务器，因为否则禁止自己的 IP 地址会使数据收集更加困难。

更多的数据导致更多的维度，但更多的维度并不一定导致更好的模型及其表示。干扰学习的数据集中的偏离模式可能会被更多维度无意地放大，数据记录的概括和学习对于神经网络来说是不利的，信噪比降低。

所有 30 万份食谱按日期排序:http://www.chefkoch.de/rs/s30o3/Rezepte.html

做网站报废的时候，尊重 robots.txt 文件很重要。一些管理员不希望机器人访问特定的目录。https://www.chefkoch.de/robots.txt提供:

User-agent: * # directed to all spiders, not just scooters
Disallow: / cgi-bin
Disallow: / stats
Disallow: / pictures / photo albums /
Disallow: / forumuploads /
Disallow: / pictures / user /
Disallow: / user /
Disallow: / avatar /
Disallow: / cms /
Disallow: / products /
Disallow: / how2videos /

列出了我们不感兴趣的目录，因此您可以放心地继续。尽管如此，我们还是建议采取一些措施，比如随机标题和在不同请求之间留出足够长的停顿时间，以避免网站被封禁。

*# Chefkoch.de Website*
CHEFKOCH_URL  = 'http://www.chefkoch.de'
START_URL     = 'http://www.chefkoch.de/rs/s'
CATEGORY      = '/Rezepte.html'category_url = START_URL + '0o3' + CATEGORY**def** _get_html(url):page = ''**while** page == '':**try**:page = requests.get(url, headers=random_headers())**except**:print('Connection refused')time.sleep(10)**continue****return** page.text**def** _get_total_pages(html):soup = BeautifulSoup(html, 'lxml')total_pages = soup.find('div', class_='ck-pagination qa-pagination').find('a', class_='qa-pagination-pagelink-last').text**return** int(total_pages)html_text_total_pages = _get_html(category_url)
total_pages = _get_total_pages(html_text_total_pages)
print('Total pages: ', total_pages)Total pages:  10560

下一个重要步骤是选择不利于不重要数据的特征。为神经网络准备原始数据在实践中很常见。在第一遍中，下载配方名称、配方的平均应用、评级数量、难度级别、准备时间和发布日期。在第二遍中，然后是配料列表、配方文本、所有图像和配方打印的次数。有了这些功能，可以很好地描述数据记录，并帮助获得对数据集的深刻理解，这对选择算法很重要。

诸如配方名称、等级、上传配方的日期等数据。存储在 csv 文件中。如果配方有图像，缩略图会放在 search_thumbnails 文件夹中。我们将利用多重处理来确保更短的下载时间。更多信息请访问 Python 的文档

**def** scrap_main(url):print('Current url: ', url)html = _get_html(url)_get_front_page(html)*#sleep(randint(1, 2))*start_time = time()
**with** Pool(15) **as** p:p.map(scrap_main, url_list)
print("--- **%s** seconds ---" % (time() - start_time))

请注意，给定的代码已被缩短。完整的代码请访问相应的 Jupyter 笔记本。

接下来，我们需要刮成分列表，准备，标签和每个食谱的所有图像。

**def** write_recipe_details(data):dpath = DATAST_FOLDER + DFILE_NAME**with** open(dpath, 'a', newline='') **as** f:writer = csv.writer(f)**try**:writer.writerow((data['link'],data['ingredients'],data['zubereitung'],data['tags'],data['gedruckt:'],data['n_pics']*#data['reviews'],**#data['gespeichert:'],**#data['Freischaltung:'],**#data['author_registration_date'],**#data['author_reviews']*))**except**:writer.writerow('')

如果下载一切顺利，我们的数据如下所示:

• 总共 879，620 张图片(35 GB)
• 316，756 个配方
  ——其中 189，969 个包含一个或多个图片
  — —其中 107，052 个配方包含两个以上的图片
  ——126，787 个不包含图片

数据分析和可视化

统计数字

为了获得第一印象，我们通常绘制一个热图，以获得对哪些可能的特征感兴趣的初步见解。

Figure 3: The heatmap gives us insight which values correlate with other values.

相关度最高的有票和平均 _ 评分。图 2 显示了第一列第二行的配对图，很明显，评分数越高，配方的评分越好。同样有趣的是准备时间和收视率数量的对比。大多数评论都是基于准备时间短的食谱。ChefKoch 社区似乎更喜欢简单的食谱。另一个想法是比较每年新上传食谱的数量。

Figure 4: In the years 2008 to 2009, it has noticeably the most uploads per year. A quick search search on the internet shows that in 2008 the food price crisis had prevailed.

曲线对比(下图)显示，全球价格上涨和食谱供应之间存在虚假的相关性。我的假设是，对食谱的需求上升是因为一个人呆在家里为自己和家人做饭，以节省预算并尽可能使收支平衡。

Figure 5: On the left the index and on the right the number of uploaded recipes per year.

佐料

一共 316'755 份食谱分享 3'248'846 份配料。如果去掉所有出现不止一次的成分，就有63’588 种独特成分。对于成分的关联分析，使用了 APRIORI 算法。这提供了什么成分与其他成分组合出现的频率。

Table 1: On the left are the top 8 and on the right the top 9–16 ingredients with the highest incidence.

在所有的食谱中，盐占了 60%。在第三个位置，你可以看到第一个元组，两种成分的组合，即胡椒和盐，仅超过 40%，它们是迄今为止最常见的一对。最常见的三胞胎、四胞胎甚至五胞胎都可以在对应的 Jupyter 笔记本中找到。

更多图形详见 本笔记本 。

主题建模

该程序的目标是将所有配方名称分为 n 类。对于监督分类问题，我们必须为神经网络提供带标签的图像。有了这些标签，学习才成为可能。问题是 Chefkoch.de 没有对他们的图片进行分类。分割 316’755 配方名称的可能程序如下所示。

到目前为止，考虑下面的例子，其中给出了四个配方名称:

• 蘑菇披萨
• 青椒配豌豆和金枪鱼
• 海鲜披萨
• 豌豆辣椒粉

以上四个配方名称必须分为 n 类。一般来说，第一个和第三个食谱需要放在同一个类别中，可能叫做比萨饼。由于豌豆的原因，第二和第四食谱也可以被放入新的类别。但是，如何正确地对 300，000 多个食谱名称进行分类呢？

潜在狄利克雷分配

概率主题建模(LDA，[Blei 等人，2003])和向量空间模型(LSA，[Deerwester 等人，1990])通过将文档建模为潜在主题集上的有限混合物或通过奇异值分解(SVD)来近似单词的含义。自从 Blei 等人[2003]的开创性工作以来，已经提出了类似的方法[Jagarlamudi 等人，2012]，通过在每个主题中提供种子词来指导模型学习期望的主题。也就是说，题目是提前知道的。

一般来说，在大多数 NLP 任务中，名称体必须被清理，即停用词被移除，词被减少到它们的根。干净的词汇作为输入。

de_stop = get_stop_words('german')
s_stemmer = SnowballStemmer('german')
tokenizer = RegexpTokenizer(r'\w+')
final_names = []**for** recipe_name **in** twentyeigth_iter:raw = recipe_name.lower()tokens = tokenizer.tokenize(raw)stop_t = [recipe_name **for** recipe_name **in** tokens **if** **not** recipe_name **in** de_stop **and** **not** recipe_name **in** filter_words_]stem_t = [i **for** i **in** stop_t **if** len(i)>1]**if** len(stem_t)==0: final_names.append(['error'])**else**: final_names.append(stem_t)print('20 Cleaned Recipe names example: **\n** >>>')
pprint(final_names[:20])20 Cleaned Recipe names example: >>>
[['bratapfel', 'rotkohl'],['frühstückswolke'],['deichgrafensalat'],['geschichteter', 'kohl'],['rinderlendenragout'],['blaukraut'],['sauerbraten'],['punschtorte'],['oberländer'],['mcmoes', 'pasta'],['geschnetzeltes'],['ahorn', 'bacon', 'butter'],['endiviensalat'],['rote', 'linsen', 'gemüse'],['kotelett', 'gratin'],['rotkohl'],['remouladensauce'],['nudeln'],['kohlsuppe'],['gemüse', 'hackfleischauflauf']]

Figure 6: 300 topics were set as condition. The model for Topic 89 provides good results: drinks are detected and summarized.

为了简单起见，不讨论精确的数学定义。因此，我们有一个概率列表，可以确定模型符合主题的程度。例如:' 0.363 * '干贝'+ 0.165 * '麻辣'+ 0.124 * '夏日'+ 0.006 * "塔布莱"+ 0.004 * "燕麦饼干"。

在 Github Repo 的 04_01_topic_modeling.ipynb 中可以找到一个交互式图表来浏览 300 个主题中的每一个。

非负矩阵分解

第一步是计算 tf-idf(词频-逆文档频)。考虑到在整个文本语料库中的重要性，这仅仅代表了菜谱名称中的一个单词的重要性。最重要的四个词是:

1.【T4 沙拉(2935.18)】2。意大利面(2429.36)
3。托泰(2196.21)
4。蛋糕(1970.08)

NMF 算法将 tf-idf 作为输入，并且同时执行降维和聚类。这一努力为前 4 个主题提供了出色的结果，如下所示:

话题#0:
意面 carbonara alla olio aglio al sabo puttanesca di mare
话题#1:
沙拉什锦玉米瓜菊苣 bulgur 萝卜芹菜 q uinoa 不冷不热
话题#2:
面条中国亚洲米氏亚洲炒锅乌冬面罗勒黑光
话题#3: 【T28

因为我们不是疯子，所以我们从 0 开始索引。

使用 t-SNE 可以将结果可视化。重要的是，具有几个维度的记录被简化为 2D，这允许为每个配方名称找到一个坐标。

Figure 7: For further information visit the corresponding Jupyter Notebook.

特征提取

对于 CNN，首先对图像信息进行汇总，以减少参数的数量。我们假设 CNN 中的第一层识别图片中的粗略结构。越深入到最后一个 Softmax 层，学习到的特征就越精细。我们可以利用这一点，采用预先训练的 CNN，这些 CNN 已经用数百万张图片进行了训练，并删除最后几层，用我们自己的数据来训练它们。这为我们节省了数百万个参数，从而减少了计算时间。这里选择的 CNN 是 VGG-16，它在 2014 年的分类比赛中接受了 1000 个类别的训练。

如果去掉最后一层，我们就得到倒数第二层的特征提取器。这形成了 n×4096 矩阵，其中 n 是输入图片的数量。

features = []
**for** image_path **in** tqdm(images):img, x = get_image(image_path);feat = feat_extractor.predict(x)[0]features.append(feat)

我们让 VGG-16 计算我们所有图像的向量。这个向量可以说是图片的指纹 : 神经网络构建的内部表示。

Figure 8: (a) Left-side is plot the 4096 vector calculated from the cake on the right (b).

现在，我们所要做的就是将每个新的给定输入图像通过 VGG-16，获得指纹向量，并使用近似最近邻搜索计算最近邻。我将为此使用的库是法尔康。FALCONN 是一个带有最近邻搜索算法的库。FALCONN 中的算法基于 局部敏感哈希【LSH】，这是一类流行的高维空间最近邻搜索方法。FALCONN 的目标是为基于 LSH 的数据结构提供非常高效且经过充分测试的实现。

目前，FALCONN 支持两个 LSH 家族的余弦相似性:超平面 LSH 和十字多面体 LSH。这两个散列族都是用多探针 LSH 实现的，以便最大限度地减少内存使用。此外，FALCONN 针对密集和稀疏数据进行了优化。尽管 FALCONN 是为余弦相似性而设计的，但它通常可用于欧氏距离下的最近邻搜索或最大内积搜索。

为了测试 choosen ANN 方法，我们传递了左边的布朗尼图像(图 9)，并如预期的那样收到了看起来相似的菜肴。

我们甚至可以创建一个图像网格来查看神经网络的解释。下图只是整个图像的一小部分。你可以看到有相似特征的烹饪菜肴靠得更近。整个网格可以在这里找到。

Figure 10: Similar cooking dishes are closer to each other.

结论

我们引入了一个新的数据集，将烹饪图像和相应的食谱结合在一起。我们强调了选择的食物领域和预先存在的图像分类任务之间的差异，并通过实验研究了卷积神经网络和近似最近邻方法的有效性。

如何在没有预训练的情况下从头开始训练自己的神经网络，并使用 Flask 将我们的系统变成 web 应用程序(第五部分和第六部分)，将在下一篇教程中讨论。

这是合同风险管理的个性化指南

原文：https://towardsdatascience.com/this-is-contranalyst-your-personalized-guide-to-contract-risk-management-a77573b80f66?source=collection_archive---------2-----------------------

使用黑客马拉松从 legal JOIN tech 选择合同、风险、大数据；

势不可挡。如果有人问我，我会用这个词来形容柏林法律科技黑客马拉松。进一步的描述也适用，但是让我们暂时忘记它，从头开始。

大数据如何帮助合法用户？哪里有适合培训 IT 系统的充足数据？我们能满足更广泛受众的哪些需求？这些都是我们小组开始活动时提出的问题。

这基本上带来了我们小组在实际黑客会议开始时试图匹配的两种观点:

1. 客户需要什么？换句话说，从问题和需求导向的角度来看待它。
2. 什么是容易实现和利用的？也就是说，从可能的解决方案和可行性的角度来看一看。

请注意，在订购透视图时，我们坚持“客户至上”的方法。解决了一个需求，一个业务很可能会随之而来。

在这样的讨论中，我们专业知识和背景的多样性派上了用场。随着所有这些力量的投入，很快，我们预期产品的图像实现了:
contra analyst，用户的“个人”合同分析师，显示特定合同的风险以及总体风险敞口的概述(例如，有多少份合同有潜在的无效条款)。

既然大局已定，就让黑客攻击开始吧…

这个过程是反复进行的，小组全体成员轮流讨论，专题专家轮流准备，小组成员轮流讨论。首先，从时间的角度来看，这被证明是最有效的。另一方面，随着定期锐化迭代，理解很快增加，学习很容易。

在第一轮，马可创造了第一个模型；Xavier 从仪表板设计开始，Idan 负责图表设计，律师们解释了合同的重点，并开始提供合同示例作为输入。将工作并行化，并为了一个共同的目标朝着同一个方向努力。由于黑客马拉松期间的主动联系，我们还获得了免费使用 OCR(光学字符识别)解决方案的机会，该解决方案能够解决 PDF 文档到文本的转换，并简化文本识别过程。很快就看到了第一批成果，已经开始显示什么是可能的。出乎意料的是，我们将要完成我们的项目。

An impression of a single contract within ContrAnalyst

然而，很快，第一个障碍出现了:在将第一个合同输入到模型中进行训练之后，我们慢慢地有了一个更好的图像，与很难实现的事情相比，什么是立即可行的，并且需要合理的努力。我们最初测试子句有效性的任务对于一天半的黑客马拉松来说有点太大了。对于小组的大部分成员来说，这有助于我们了解必要的工作以及学习模型的合适输入。

现在，重新聚焦时间。作为开始，我们决定在合同中使用更标准、更容易访问的信息:剩余期限。我们只有很少的训练集(大约 40 份不同的合同)，即使这样也很困难；机器学习可以提供惊人的解决方案，但总是以足够多的可用数据为代价；因此，我们提出了进一步降低复杂性的想法，并手动创建了关于术语的不同子句，涵盖了最重要的变体，但大多数都具有某种程度上相似的结构。

最后，通过共同努力，我们从不同的角度和角度研究了这个主题，并在演示中自豪地展示了一个可视化原型，展示了一个仪表板和一个可能的工具结构。我们对结果很满意，柏林法律技术黑客马拉松的评审团也很喜欢，我们很高兴获得了第三名。

The dashboard overview in the tool.

感谢评审团、活动的赞助商和价格，更感谢组织者以令人难以置信的动力和精神举办了这场伟大的活动！

The final autors: Marco, Idan, Xavier, Nuri and Baltasar

团队(您可以通过媒体联系我们或在 LinkedIn 上找到我们):

• 我们的设计师 Idan Nesher 能够让几乎所有东西看起来都很吸引人
• Marco Scaravelli，意大利人，我们的 IT 和机器学习专家
• Xavier Lavayssière，法国人，也是我们当中最关注顾客的人
• 努里·卡德姆，律师，非常喜欢
• 巴尔塔萨·塞韦茨，前 IT 业人士，后成为律师
• 大卫，另一位律师，不幸地在演讲前离开了

该团队的方法与硅谷最受欢迎的一句名言完美契合:

“试过了。曾经失败过。没关系。再试一次。再次失败。失败得更好。”
(塞缪尔·巴克特在沃斯沃德何)

这就是你谈论酒的方式

原文：https://towardsdatascience.com/this-is-how-you-talk-about-wine-2a41d6844587?source=collection_archive---------15-----------------------

数据科学有助于揭开语言的神秘面纱

喝酒是一回事，理解专家们在谈论葡萄酒时使用的充满形容词的语言是另一回事。如果你和我一样，你已经被比较味道的描述逗乐了，困惑了(赞许！)到“湿花岗岩”或讨论“鼻子”暗示“石墨和铅笔屑”。加上单宁、酸度和余味等术语，偶尔喝葡萄酒的人会想知道这些描述告诉了他们什么。

我们能从所有的描述性术语中解读出什么吗？我们能在葡萄酒评论中找到一些简单的东西来提醒我们什么是我们喜欢的，什么是我们不能接受的吗？

我对 Kaggle 数据集进行了分析，该数据集包含来自葡萄酒爱好者杂志的超过 13 万篇葡萄酒评论，旨在了解专家们用来描述葡萄酒的词汇能告诉我们关于葡萄酒的质量、价格和美味的信息。

Fig 1: Pinot word descriptions compared to all wines

我的第一步是比较所有评论中描述性词语的平均使用情况，以及 20 种不同葡萄酒中相同词语的使用情况。任何显著的差异都应该指出是什么让这种葡萄酒变得如此重要。在左边(图 1)你可以看到，如果你喜欢樱桃或覆盆子口味和浅红色，那么黑皮诺可能是你想要的。

Fig 2: Sauvignon Blanc descriptions

如果你不是浆果迷，那么长相思值得一试。绝对不能与浆果相提并论，但有很多关于柑橘、苹果和清淡松脆的谈论(图 2)。

看到红葡萄酒和白葡萄酒之间的这种对比并不意外，但是不同类型的红葡萄酒之间的语言有什么不同呢？

Fig 3: Syrah descriptions

对于西拉(图 3)，你将享受黑色，成熟的浆果味道和一些胡椒味。不像上面的皮诺，你会尝到黑莓而不是樱桃。如果你喜欢这些口味，那么你可能会想继续喝内比奥罗(图 4 ),它能给你更多的浓度和辣味。“坚实”这个词的重要意义在于表达了你品尝的东西的各个组成部分是如何协调工作的。

Fig 4: Nebbiolo descriptions

现在你知道了这些区别，你可以试着自己品尝，并在向朋友描述葡萄酒时使用这些术语。总的来说，红葡萄酒是关于浆果、单宁和香料的，而白葡萄酒是关于柑橘、酸和松脆的味道。

你描述的特定浆果或柑橘及其强度取决于你的味蕾。

最后，我将葡萄酒评论中唯一使用的词按照得分(0-100)和价格分类，制成词云。高价酒和高分酒有什么共同点？荣誉:

Fig 5: Unique words for wines costing over $200

Fig 6: Unique words for wines scoring more than 97 points

有几个描述性的词偷偷放在里面，但没有多少能告诉你酒是什么味道。但是，这是一个很好的赌注，无论是高价葡萄酒还是高分葡萄酒都很好喝。

同样的关系不适用于低成本葡萄酒和低评分葡萄酒:

Fig 7. Unique words for wines priced less than $10

Fig 8. Unique words for wines scoring less than 82 points

便宜的葡萄酒(图 7)被认为是容易、简单和清淡的。正如我们在第一节中了解到的，苹果、绿色和清洁这些词的出现表明许多廉价的葡萄酒是白葡萄酒。

低分葡萄酒(图 8)没有什么可推荐的。植物性的、乏味的、苦涩的、刺耳的:这些词除了低评分评论外，在任何地方都找不到。

所以，你可以找到一种又好又便宜的酒，但是不要指望用低分的酒就能开心。

我们发现了描述葡萄酒最常用的词，以及它们的用法如何随着葡萄酒的类型和质量而变化。要听起来像专家，有 3 个简单的步骤:

1. 学会区分酸度和单宁，并描述你品尝时的酸度和单宁含量。
2. 形容红葡萄酒带有浆果、香料和成熟的味道。用柑橘类水果、苹果和松脆来形容白葡萄酒。
3. 当其他方法都失败时，就照我做的去做，然后说，“这很好。我会喝了它"

这是我作为数据科学家真正做的事情

原文：https://towardsdatascience.com/this-is-what-i-really-do-as-a-data-scientist-d637ed747ef9?source=collection_archive---------4-----------------------

source:Pixabay

数据科学越来越受欢迎，许多人正试图加入这一潮流，这很好。但许多人认为，数据科学、机器学习(在这里插入任何其他时髦词汇)是将数据插入一些 Sckit-Learn 库。实际工作是这样的。

为了让您了解上下文，在收集数据后，会发生以下情况。不要误会，我不认为这应该被认为是一个简单的步骤，但我想重点谈谈数据预处理和规范化。

问题是

如果你关注我的博客，你可能会意识到我在机器 2 机器领域做了很多工作。最近在工作中，我试图根据机器的行为，也就是它们的数据消耗，将它们聚集在一起。

这些功能可报告特定服务类别(如社交媒体、音频等)的下载和上传使用情况。为此，让我们假设我们正在查看一个计数器，该计数器查看与 AWS (Amazon Web Services)建立了多少连接。

如果我们按原样获取数据，并决定从中提取聚类，我们会得到如下结果:

注意，这是数据的一个 LDA 2 轴表示。LDA 作为 90%的代表因素。即使它不是完美的，聚类也几乎是无用的。在这一点上，一些我建议使用这种或那种算法，并调整超参数，这正是最糟糕的想法。

臭名昭著的数据

现在，让我们开始工作。数据是什么样的。建议你在输入一些来自 sklearn.cluster import KMeans 的之前要花很多时间。我们将看一下这个例子的一个具体特征，但请记住，大多数特征都是相似的。

这是 AWS 计数器(不是真的，但我们会假装)。

所有的数据看起来都是 0，但如果你仔细看，有价值上升到 3e+7。你怎么能指望用这个创造出任何有意义的距离。即使您将其缩放到 0 和 1 之间，大多数数据也将介于 0 和 0.0000005 之间或类似的值，因此距离不会变得更好。

如果我们观察所有非零数据，我们会发现一些更有趣的东西:

数据处理

这开始看起来像一个对数正态分布。现在我们如何使它正常化？至少有一点。所以我的一个同事，Tanguy 有一个非常聪明的主意，关于如何转换对数正态分布。盒考克斯变换。这种转换试图尽可能“正常化”不同的分布，包括对数正态分布。

这个变换试图最小化这个公式中的 lamda 值(图片来自维基百科):

在我们的例子中，有太多的零，lamda 会更低，大约是这样:(注意:你只需要得到正值，所以所有的值都加 1)

在这张图片中，您可以看到 9 点左右的小凸起，它包含了大部分非零数据。在这一点上，我们已经有了更好的东西，在距离方面好了几个数量级，但仍然可以改进。

我们再把这个数据的来龙去脉带回来。我们正试图对机器行为进行分类。在机器对机器的世界里，这里面隐藏着大量的信息。机器可以使用 AWS。这听起来很可笑，但在这里非常重要。这些机器通常被编程来完成非常特殊的任务，例如报告天气、表演节目等等。他们的任务通常是硬编码的，他们不会随机开始脸书之类的。仅仅是他们可以使用服务(比如 AWS)这一事实就包含了大量信息。因此，我的计划是，我将把 0 保留为 0，然后为其余的数据指定 0.5 到 1 的范围。现在剩下的数据怎么表达… Box Cox 变换。我将在唯一的非零设备上进行转换。

这是它的样子。在左侧，您可以看到所有数据都进行了转换，就像在 0–1 空间中解释的那样。在右边，你有一个在 0.5 和 1 之间的部分的缩放图形。

即使左边的图看起来没有那么好，我可以向你保证，对于算法来说，这是一个不同的世界。

结果

因此，在对数据进行预处理后，我们对其运行聚类算法，并且在没有任何定制的情况下，我们得到了结果。

结论

我发现人们对算法有点“触发式快乐”,太快地跳到了模型构建上。有人说你甚至不需要理解背后的数学，我不同意，你至少需要理解算法的基础。至少足以理解如何为它准备数据。作为例子，在 K-意味着这是所有关于点之间的距离，当你有这种类型的范围(10e7)你不能指望算法找到字幕模式，它将被范围蒙蔽。

所以拜托，一遍又一遍的看你的数据。到了你觉得可以用手分离它的程度，然后让花哨的算法来完成剩下的工作。

原载于 2018 年 4 月 27 日coffeeanddata . ca。

神经网络揭秘 1:分类问题

原文：https://towardsdatascience.com/this-series-is-an-attempt-to-make-neural-networks-understandable-for-people-who-know-nothing-more-df6695b6cd39?source=collection_archive---------1-----------------------

他的系列文章试图让只懂高中数学的人理解神经网络。没有比看着冗长的数学公式和一长串代码却不知道如何使用它们更可怕的了。带走了所有的乐趣！

所以事不宜迟，让我们从理解一个简单的分类问题开始，它将温和地介绍神经网络背后的概念。

假设你是一家公司的招聘经理，该公司正在招聘大学生进行暑期实习。你可能会收到一个学生的简历，他的平均绩点是 3.0，并且完成了 10 个个人项目，你决定雇佣这个学生。另一份简历可能有 1.0 的 GPA 和 2 个个人项目，你拒绝了这份申请。现在你需要决定另一份有 2.7 GPA 和 8 个个人项目的简历是否被录取？

为了找到答案，让我们先把现有的数据绘制成图表，x 轴是平均绩点，y 轴是项目数量。

蓝点代表被录取的学生，橙点代表被拒绝的学生，灰点代表我们需要决定的学生。现在让我们把过去几年中可能发生的所有接受和拒绝的数据加到我们的图表中。

注意蓝点和橙点之间的分隔线，它清楚地告诉你，绩点 2.7 和项目 8 的学生应该被录取。这条线在人工智能/神经网络/ML 行话中被称为“模型”(每当我听到这个术语时，我总是会抓狂，但它真的没有那么糟糕，对吗？).对于我们人类来说，画这条线很容易，但它涉及到仔细绘制每个数据点，然后找到最佳拟合线的平凡任务。好消息，电脑的发明是为了让我们远离这些无聊的工作，这样我们就可以专注于更重要的任务。那么我们如何让计算机为我们找到模型呢？

让我们从一些基本的数学开始，我们将用变量 x1 标注对应于 GPA 的横轴，用变量 x2 标注对应于项目数量的纵轴。因此，蓝色和橙色点的分界线将有一个线性方程:

Approximate equation without real numbers

这个等式真正代表的是学生的分数，可以写成以下格式:

现在，每当我们想知道一个新学生是否合格时，我们在这个等式中输入每个值，如果分数是正的，那么我们接受这个学生，否则不接受。让我们把 2.7 作为平均绩点，8 作为项目数量。我们得到 3.9 分。学生合格！

在更一般的形式中，我们将有一个用于该模型的方程:

或者以矢量形式表示为:

在哪里

和

我们只取两个向量的乘积。按照惯例，我们将 W 称为权重，x 称为输入，b 称为偏差。我们可以将正面分数标注为 1(蓝点)，负面分数标注为 0(橙点)。

最后，我们模型的预测是:

这意味着如果分数大于 0，我们的算法将尝试预测 1，如果分数小于 0，则预测 0。我们的算法对数据已有的标签做出的预测越接近，它的表现就越好，这就相当于将蓝点和橙点分开的最佳拟合线。

F 对于这篇文章，我将在这里停下来，我希望到现在为止，对分类问题，它们如何工作以及算法如何试图找到预测已经有了一些了解。这是一些简单的背景，我想在我们深入神经网络的神奇世界之前介绍一下。下次见，再见！

欢迎提出改进意见:)

这会让你知道你有多需要用 Airbnb 旅行

原文：https://towardsdatascience.com/this-will-make-you-know-how-much-you-need-to-travel-with-airbnb-442abd51c8c4?source=collection_archive---------25-----------------------

基于西雅图、波士顿 Airbnb 数据集

Photo by Zhifei Zhou on Unsplash

Photo by Lance Anderson on Unsplash

这些图片促使你去赶飞机吗？如果你的答案是肯定的，你和我一样是一个“嗜 Hodophile”。暂时远离现实，成为一名观察者是一种充满敬畏的感觉——它让你感激你所拥有的，你所能做的，你的朋友和家人。旅行让你再次成为自己 —万岁！老实说，我最喜欢的回忆之一是在保加利亚坐在长椅上喝着啤酒看着人们走过(那里还好，至少没人说什么)。

我不知道你有多富裕，但作为一名学生，预算一直是一个问题，让我不敢坐飞机。我已经使用 Airbnb 很长时间了，因为我喜欢使用 Airbnb 比使用酒店或其他住宿更自由，此外，我碰巧找到了价格更低的家一样的地方。 然而，在走访不同城市时，我观察到 Airbnb 的价格各不相同。 我早就该走进数据世界了。

数据集由来自 Kaggle 的关于西雅图和波士顿 Airbnb 的信息组成，每个数据集有 3818 和 3585 行。我的目标很明确: 【了解 Airbnb 价格】 。为此，我有一些问题，我很乐意与你分享我的答案。

1.两个城市实际上存在价格差异吗？

给你答案，是的有区别。看看我是怎么得出这个答案的。由于单价是 1000 美元，并且由于一些异常值(非常昂贵的 Airbnb ),很难区分两个城市之间的差异。

Figure 1: price distributions of Seattle and Boston

经过价格的对数变换后，我可以更清楚地看到这种区别。

Figure 2: log-price distributions of Seattle and Boston

我们观察到波士顿 Airbnb 的价格普遍较高，而且更加分散。西雅图对数价格分布显示出更加对称的方面，而波士顿对数价格分布似乎稍微偏左，这意味着波士顿租金价格形成较高。从技术上讲，西雅图和波士顿的对数价格均值分别为 4.68 和 4.94，标准差分别为 0.57 和 0.65。

根据 Trulia ，这对应的是每月租金中位数。平均而言，波士顿的月租金中位数约为 2900 美元，而西雅图的月租金中位数约为 2700 美元。因此，这个结果并不奇怪。然而，有趣的是两个城市的销售价格中位数显示出相反的趋势:西雅图的房地产销售价格中位数平均为 69 万美元，波士顿为 61 万美元。使用价格与租金比率的概念，我们得出波士顿为 17.53，西雅图为 21.30。根据一般经验，如果该比率从 16 到 20，那么购买房产是有风险的，如果是 21+，那么租房比买房好得多。因此，波士顿似乎是一个更有希望买房的地方。

2.同一个主机拥有多少 Airbnb 房产？

自从我确认存在价格差异，我想找到更多的为什么。我的第一个兴趣是少数“超级”主机是否决定了市场价格。是这样吗？

Figure 3: Average property numbers owned by a host

波士顿的房东平均拥有更多 Airbnb 房产。这可能意味着，决定 Airbnb 房产价格的主机数量减少了。但是我们现在还不能确定任何事情，所以让我们继续深入研究。

Figure 4: Distribution of number of properties in Seattle

Figure 5: Distribution of number of properties in Boston

查看单个分布，我们可以确认在波士顿有更多的“超级”主机。因此，我们可以假设这些“超级”主机将波士顿的 Airbnb 价格定得更高。但我没说他们真的有。有了预测模型，我就能知道这个预测器排在哪里了。

3.价格如何基于位置传播——均匀还是不均匀？

我的下一个问题是，位置是否会影响两个城市的 Airbnb 价格，因为繁忙的位置价格较高似乎是很自然的。我使用邮政编码作为位置信息的代理。

Figure 6: Seattle location distribution by zip code

Figure 7: Boston location distribution by zip code

就扩散程度而言，根据标准差，两个城市的位置分布没有显示出太大差异。然而，我们注意到一个模式，它不是均匀分布的。当我们将分布与来自 Trulia 的租金地图(西雅图和波士顿)进行比较时，高比例位置对应于高租金区域；因此对价格分配有更大的影响。

Figure 8. Seattle and Boston rent heatmaps

毕竟，大多数 Airbnb 房产都拥挤在城市的热点地区。

4.我的模型能很好地预测价格吗？

嗯，没有什么是完美的——至少在数据科学领域是这样。然而，我对我的预测模型的性能非常满意。在表 1 中，预测价格与实际价格相差不远。

Table 1: True price values and predicted price values

【我知道这可能让人望而生畏。这只针对好奇的乡亲们 :

我采用了臭名昭著的 极限梯度推进(又名 XGBoost)回归器 作为框架，并结合了穷举 网格搜索交叉验证。 在每次迭代中，用 5 重交叉验证对模型进行评估，并找到给出最佳性能的最佳参数。

与交叉验证 RMSE 相比，测试 RMSE(均方根误差)有所降低，约为每 1，000 美元 78.0201，这是有希望的——这意味着 该模型在野外的表现优于实践中的 ！】

如需了解更多详情，请访问我的Github！

5.价格最重要的预测因素是什么？

Figure 9. Top 10 important features for Airbnb price

现在，我们获得了十大重要功能列表，内容如下:

• zip_has:邮编所在位置的 Airbnb 房产数量。位置繁忙程度的指示器。
• 浴室:浴室数量。
• host _ days:host 托管 Airbnb 房产的天数。
• 卧室:卧室数量。
• minimum_nights:您需要预订的最低住宿天数。
• extra_people:比主人多的客人额外收费。
• 床位:床位数
• guests _ included:Airbnb 酒店可以容纳的客人数量。
• availability_365:一年中可用的天数。
• 评论数量:评论的数量。

如果你看到上面的列表，它们在预测价格中扮演重要角色似乎是很自然的。第一，如果这个地方是一个旅游景点等繁忙的地方，对住宿的需求应该更多；从而提高了价格。 浴室、卧室、床的数量反映了舒适度的高低。没有人愿意在洗手间前排队等候或睡在沙发上。如果你已经经营 Airbnb 房产很长时间了，你应该知道市场是如何波动的。从数据科学的角度来看，你更可预测，因为你比一个新主持人更有可能引领市场趋势。最少住宿、额外客人费用和最多客人人数是由主办方设定的规则，并直接计入价格计算中。所以这三个因素排名靠前是有说服力的。最后，一年中可用的天数和评论的数量反映了 Airbnb 房产的受欢迎程度。自然，高需求导致更高的价格。****

我们没有看到“host_has”(一个主人拥有的财产数量)排在前 10 名(实际上排在第 13 名)——这里的一个要点是，我们的本能在某些情况下不是最好的工具，这个世界需要数据科学家！(哈哈)

结论

在这个项目中，我们深入研究了西雅图和波士顿的 Airbnb 数据集，发现了一些有趣的模式:

1. 波士顿是使用 Airbnb 旅行比西雅图更贵的城市。这一现象符合目前两个城市每月租金中位数的趋势——波士顿的房租更贵。
2. 波士顿的房东平均拥有更多 Airbnb 房产，也有更多“超级”房东。因此，这可能意味着几个超级主持人可以左右城市的平均价格。
3. 高比例位置对应于西雅图和波士顿的高租金区域。因此，我们可以假设租金、位置和 Airbnb 价格密切相关。
4. 根据重要特征，我们知道受欢迎程度、位置、舒适度和物业规则会影响 Airbnb 的价格。

这个项目提出了一些问题，如两个城市的价格是否存在差异，价格如何基于位置传播，以及最重要的预测因素是什么。希望这个项目回答了这些问题，并为你提供了什么可以影响 Airbnb 价格的见解。 我相信这种预测模型可以为顾客提供有关旅行预算和计划的信息，并为主人为他们的房产定价提供参考。

尽管如此，仍有很大的改进空间。我张开双臂欢迎任何反馈和建议 —最后，我们数据科学家分享！做这个项目时，我渴望去旅行，我也想去。无论您在哪里旅行，无论是环游世界还是数据世界。我祝你旅途好运。一路顺风！

与作者联系

你可以在 LinkedIn 上和他联系

如需了解更多详情，请访问他的 Github

参加 Deeplearning.ai 课程后的想法

原文：https://towardsdatascience.com/thoughts-after-taking-the-deeplearning-ai-courses-8568f132153?source=collection_archive---------1-----------------------

更新时间:2018 年 2 月 2 日:当我写这篇博文的时候，只有 3 门课程已经发布。 本专精的 5 门课程现在全部出 。我很快会有后续博文。 ]

简介:

在全职工作和家里蹒跚学步的孩子之间，我用业余时间学习认知科学和人工智能的思想。偶尔会出现一篇很棒的论文/视频/课程，你会立刻被吸引住。

吴恩达新推出的 deeplearning.ai 课程就像那部让人向往的什恩·卡鲁斯或拉吉尼坎塔电影！

很自然地，课程一在 coursera 上发布，我就注册了，并花了 4 个晚上的时间疯狂地观看课程，完成测验和编程作业。

DL 实践者和 ML 工程师通常花大部分时间在抽象的 Keras 或 TensorFlow 级别上工作。但偶尔休息一下，认真学习算法的具体细节，并实际手动进行反向传播也是不错的。它既有趣又非常有用！

本课程的内容是:

吴恩达的新 ad venture 是一种自下而上的方法来教授神经网络——强大的非线性学习算法，在初级到中级水平。

在经典的 Ng 风格中，该课程通过精心选择的课程、整齐定时的视频和精确定位的信息块来讲授。Andrew 从他的经典 ML 课程停止的地方开始，介绍了使用单个神经元(逻辑回归)并慢慢增加复杂性(更多神经元和层)的神经网络的想法。在 4 周(课程 1)结束时，学生将了解构建密集神经网络所需的所有核心思想，如成本/损失函数，使用梯度下降和矢量化并行 python(numpy)实现进行迭代学习。

Andrew 耐心地解释了必要的数学和编程概念，以精心规划的顺序和良好的节奏，适合可能对数学/编码生疏的学习者。

课程材料和工具:

video lecture

讲座使用演示幻灯片，Andrew 使用数字笔在幻灯片上书写。这似乎是让听众集中注意力的有效方法。我觉得以 1.25 倍或 1.5 倍的速度观看视频很舒服。

quiz tool

测验放在每堂课的最后，是多项选择题的形式。如果你看一遍视频，你应该能很快回答所有的问题。您可以尝试多次测验，系统旨在保持您的最高分。

Jupyter notebook programming assignment

编程作业通过 J upyter 笔记本完成——强大的基于浏览器的应用程序。

作业有一个很好的引导顺序结构，你不需要在每个部分写超过 2-3 行的代码。如果您直观地理解了像矢量化这样的概念，那么您只需一行代码就可以完成大多数编程部分！

作业编码后，只需点击一次按钮，即可将您的代码提交给自动评分系统，该系统会在几分钟内返回您的分数。有些作业有时间限制——比如说，在 8 小时内尝试三次等等。

Jupyter 笔记本设计精良，使用起来没有任何问题。说明书很精确，感觉像是打磨过的产品。

本课程面向谁:

任何有兴趣了解什么是神经网络，它们如何工作，如何建立它们，以及将你的想法变为现实的可用工具的人。

如果你的数学生疏了，也没必要担心——安德鲁解释了所有需要的微积分，并在每个场合提供了导数，这样你就可以专注于构建网络，专注于用代码实现你的想法。

如果你的编程生疏了，有一个很好的编码作业教你 numpy。但是我建议先在 codecademy 上学习 python。

这个 DL 课程与杰瑞米·霍华德的 Fast.ai 课程有何不同:

让我用一个类比来解释这个:假设你正在努力学习如何驾驶汽车。

杰里米的速度很快。人工智能课程从一开始就把你放在驾驶员的位置上。他教你移动方向盘，踩刹车，油门等。然后他慢慢地解释了更多关于汽车如何工作的细节——为什么转动轮子会让汽车转弯，为什么踩刹车踏板会让你减速和停车等等。他不断深入汽车的内部工作原理，到课程结束时，你会知道内燃机是如何工作的，油箱是如何设计的等等。这门课程的目标是让你学会驾驶。在你能相当好地驾驶之后，你可以选择在任何时候停下来——没有必要学习如何制造/修理汽车。

安德鲁的 DL 课程做了所有这些，但是在完全相反的顺序。他先教你内燃机！他不断添加抽象的层，到课程结束时，你就能像 F1 赛车手一样驾驶了！

快速人工智能课程主要教你驾驶的艺术，而安德鲁的课程主要教你汽车背后的工程。

如何学习本课程:

如果你在此之前没有做过任何机器学习，先不要上这门课。最好的起点是 Andrew 在 coursera 上原创的 ML 课程。

完成该课程后，请尝试完成杰瑞米·霍华德优秀的深度学习课程的第一部分。杰里米教授深度学习自上而下，这对于绝对的初学者来说是必不可少的。

一旦你对创建深度神经网络感到舒适，那么参加这个新的 deeplearning.ai 课程专业化是有意义的，它可以填补你对底层细节和概念的理解中的任何空白。

本课程中我喜欢的内容:

1. 事实基本上是明明白白的——所有的不确定性和模糊性都会被定期消除

2.Andrew 强调深度学习的工程方面，并提供了大量节省时间和金钱的实用技巧——DL 专业化的第三门课程对我作为领导工程团队的架构师的角色来说非常有用。

3.行话处理得好。安德鲁解释说，一个经验过程=试验&错误——他非常诚实地面对设计和训练深度网络的现实。在某种程度上，我觉得他可能只是称深度学习为美化的曲线拟合

4.粉碎所有关于 DL 和 AI 的炒作——Andrew 对主流媒体中 AI 炒作的扩散进行了克制、谨慎的评论，在课程结束时，很明显 DL 一点也不像终结者。

5.开箱即用的精彩样板代码！

6.课程结构优秀。

7.漂亮、一致且有用的符号。安德鲁努力为神经网络建立一个新的命名法，我觉得他在这方面会相当成功。

8.这种教学风格是安德鲁所独有的，并且是从曼梯·里传承下来的——我能感受到 2013 年我参加他最初的曼梯·里课程时的那种兴奋。

9.对深度学习英雄的采访令人耳目一新——听到个人故事和轶事既激励又有趣。

我发现缺少的东西:

我希望他能更具体地说“””！

一路上我学到了一些额外的东西:

1. DL 不容易。随着时间的推移，需要一些艰苦的工作来“理解”这些概念，并使它们很好地工作。 Andrew 不久前写了一篇 quora 回答，引起了我的深深共鸣。

2.好的工具很重要，会帮助你加快学习的步伐。在看到安德鲁用一支数码笔教学后，我买了一支。它帮助我更有效地工作。

Black ink is Andrew’s and colors are mine

3.我之所以推荐 Fast.ai 课程，是有心理原因的。一旦你找到了你的激情，你就可以学习无拘无束。

4.每当你得满分时，你就会产生多巴胺的冲动:

hell yeah!

5.不要被 DL 行话吓倒( hyperparameters = settings，architecture/topology=style 等)。)或数学符号。如果你有信心并且注意听课，安德鲁展示了为什么符号和记号实际上是非常有用的。它们将很快成为你的首选工具，你将会很有型地使用它们！

some scary looking symbols which will begin to make sense when you watch the lecture videos

结束语(可选阅读):

1. 每个人都是从这个领域的初学者开始的。如果你是 DL 领域的新手，自然会对所有的术语和概念感到害怕。请不要放弃。你可能被吸引到这个领域，希望找到你的职业。相信你的直觉，保持专注，你会比你意识到的更快成功！甚至吴恩达在过去的某个时候也不得不学习线性代数——他并不是天生就有这方面的知识。
2. 虽然这是一个令人难以置信的资源，但这并不是世界上唯一的数字图书馆课程。许多慷慨的老师像萨尔曼·可汗、杰瑞米·霍华德、巴斯蒂安·特龙、杰夫·辛顿都像吴恩达一样在网上免费分享他们的知识。我不够幸运，无法继续攻读硕士或博士学位，因为我必须参加工作，养家糊口——但这并不意味着学习必须停止。由于知识的民主化，我有机会定制自己的学习计划。我可以选择向我最崇拜的人学习:编程(Gerald Sussman)、线性代数(Gilbert Strang)、人工智能(马文·明斯基)、哲学(丹尼尔·丹尼特)、心理学(让·皮亚杰)、物理学(汉斯·贝特)…
3. 大部分应用数字逻辑实际上是训练有素的工程——Ng 教授在课程 3 中提供了精彩的汇编(我迄今为止发布的 3 门课程中最喜欢的)。让 DL 为您的问题工作所需的心态与处理任何其他困难的工程问题所需的心态没有什么不同。你需要知道的一切都已经被克劳德·香农在几十年前清晰地记录下来了。

感谢阅读并致以最美好的祝愿！

更新:感谢压倒性的积极回应！许多人要求我解释梯度下降和微分学。 希望这对 有所帮助！

关于对抗性歧视性领域适应的思考

原文：https://towardsdatascience.com/thoughts-on-adversarial-discriminative-domain-adaptation-f48e3938d518?source=collection_archive---------8-----------------------

我偶然浏览了一下这篇论文讨论了当测试图像属于不同于训练集的域时的图像分类。

当我们有模型训练的情况时，例如动物的 2D 图片，并且面临需要对动物的 3D 图像进行分类的情况时，领域适应就发挥作用了。虽然它们属于同一个类(马)，但模型很困惑，因为它们看起来不同于它从中学习特征的马的图像。

本文主要介绍了一种称为对抗鉴别域自适应的技术，它采用了 GAN 的思想，通过使用鉴别器来区分来自源域和目标域的图像。

由于图像可以属于不同的域，我们首先学习到一个公共特征空间的映射，以便我们可以将一个域不变向量馈送给我们的鉴别器。我们在这里使用一个判别模型，并试图通过一个编码器(足够接近一个生成器，但不完全是一个)来学习映射。鉴别器接收来自两个域的映射，并判断图像是否属于源域。

ADDA 为其鉴别器使用损失函数，使其完全依赖于其目标分布。优化损失函数基本上试图标记目标分布图像，就好像它们属于源域一样。对于映射，我们对源域和目标域使用联合权重，仅仅是因为由于不同的域，在一个域中学习的特征不需要在另一个域中相同。

建筑:

Architecture for ADDA. (Source: https://arxiv.org/pdf/1702.05464.pdf)

我们使用两种不同的 CNN 来学习映射。我们首先使用典型的图像分类技术训练源 CNN 和源分类器。在这一步之后，我们修复了源 CNN 和分类器。

然后，在领域适应步骤中，我们通过标准的广告过程训练鉴别器和目标 CNN。我们在这个阶段维护源映射并学习目标映射。

最后，在测试阶段，我们使用目标映射对测试图像进行编码，并在其上运行分类器。

感谢阅读！

关于人工智能的想法，只是为了好玩。

原文：https://towardsdatascience.com/thoughts-on-artificial-intelligence-just-for-fun-e80167dd319a?source=collection_archive---------4-----------------------

electric Paul Klee, 1983, by Malcolm P. Dickson, Private collection

"艾已经半个多世纪了，背上了太多的包袱."卡洛斯·佩雷斯

人脑中大约有个 千亿个神经元。

100,000,000,000

这就需要在带有神经网络的计算机中模拟大量的神经元——也许是为了达到通常意义上的“智能”。稍后会有更多关于智力和一千亿个神经元的内容。

卡洛斯·佩雷兹(Carlos E. Perez)最近发表了一份关于人工智能现状的最精彩的概述，人工智能景观的不同领域，在其历史背景下，“人工智能的许多部落”。写得很好，推荐给任何对当前人工智能领域感兴趣的人。

本着透明的精神，我的激情属于卡洛斯·e·佩雷斯(Carlos E. Perez)所描述的“生物灵感主义者”一类，“创造更接近神经元在生物学中出现的模型的人”支持小说此外，更重要的是，考虑改善成瘾行为对人类状况的影响。也就是说，知道该做什么，如何影响成瘾背后的神经元。我认为，这些神经元 DNA 的计算机模型是一个好地方，可以开始为这些神经元生成一个影响因素和结果行为的详尽列表，有可能支持改善成瘾的方法。这只是个人猜测。正如我在这篇文章的结尾所指出的，我只是一个观察者和提问者，边走边学。

这种方法的理由是什么？漫长的游戏。

“智力有许多不同的定义，包括一个人的逻辑、理解、自我意识、学习、情感知识、计划、创造力和解决问题。它可以更概括地描述为感知信息，并将其作为知识(T21)应用于环境或背景中的适应性行为的能力维基百科“情报”

因此，尽管机器学习和深度学习为当前人类的追求增加了巨大的价值，但将术语“智能”应用于这些努力似乎并不正确，因为这个术语是如何被他人使用和解释为具有特定含义的——特别是自我意识的能力。

漫长的游戏

考虑一下自我意识意味着什么，思考，然后在某种程度上或多或少地利用逻辑感来处理输入，理解输入。考虑一下理解意味着什么。

如果你是有自我意识的，知道并理解关于一个物体、一个实体、它的行为、它相对于它的背景的目的、关于它的一切的一切，那么关于缺乏对那个物体、那个实体的理解的摩擦会在哪里？从定义上来说，不会有任何摩擦——事实上，你会知道这个物体和它所在的系统的一切。我们每个人都有特定的心智能力，而他们所处的系统是一个额外的限制因素。随着智能系统的增长超过人类的智能能力，那么也许这些人工智能系统在理论上能够更多地了解我们以及我们如何与我们的环境互动，甚至可能有助于指导我们改善互利的结果。

继续关于人工智能的长期博弈。让我们考虑一下云架构为神经网络提供了什么——高级别的云接口，是硬件和软件之间的抽象层——神经网络和软件所驻留的实际处理器、内存、存储和网络。价值—基于需求的透明硬件可扩展性。回到开篇——人脑中有多少神经元？一千亿。暂且不考虑在神经网络架构内的计算机上模拟人脑神经元及其所有 DNA 复杂性(对某个基因的 DNA 链的影响，例如， Tet3，蛋白质编码基因)之间的比较，仅一千亿个神经元所需的计算机能力就取决于模型的设计水平。作为点的一千亿个神经元的模型网络，不包括神经元的内部网络，将比每个神经元及其内部组成部分的模型需要更少的计算机资源，仅 DNA 就需要大量的计算机资源。Bitesize Bio上的 Yevgeniy Grigoryev 估计，大约需要 1.5 千兆字节来表示 1 个 DNA 序列(以字节计的整个二倍体人类基因组)。

1.5 千兆字节 x 100 亿个神经元= 1500 亿千兆字节或 150 x 10 的 9 次方

十亿千兆字节= 1 艾字节，因此我们需要 150 艾字节。

那有多大？

据说 5 艾字节相当于人类说过的所有单词

我们继续前进。

卡耐基梅隆大学计算机科学教授齐夫·巴尔-约瑟夫说:“神经科学中有很多关于计算模型的工作，这些计算模型不仅考虑了抑制性神经元的更多细节，还考虑了驱动这些神经元的蛋白质等等。”Larry Hardesty，2017 年 1 月 9 日，模型阐明了抑制性神经元的目的

有趣的是，是的，我知道这是一个延伸，几乎令人恐惧，因为我们有能力创建这个基本的测试 作为今天的神经网络计算机模型，神经科学有一个可测试的模型来确定新生儿的“意识”——理论上可以应用于基于计算机的意识模型，一旦有了，作为一个测试。

“……Filippetti 和她的同事测试了 40 名出生 12 小时至 4 天的新生儿。婴儿坐在屏幕前实验者的腿上。在屏幕上，一段视频显示一个婴儿的脸被画笔抚摸。研究人员要么在屏幕上显示抚摸的同时用刷子抚摸婴儿的脸，要么将抚摸延迟五秒钟。

接下来，婴儿们看了同样的视频，但是颠倒了。同样，研究人员在颠倒图像的同时抚摸婴儿的脸，或者将抚摸延迟三秒钟。

Filippetti 告诉 LiveScience，和这么小的婴儿一起工作是一个挑战。

“就婴儿完全清醒和有反应的实际时间而言，这是具有挑战性的，”她说。

为了确定婴儿是否像在橡胶手错觉中一样，将他们在屏幕上看到的面部抚摸与他们自己的身体联系起来，研究人员测量了婴儿在每种情况下看屏幕的时间。注视时间是婴儿研究中使用的标准测量方法，因为婴儿不能回答问题或口头表明他们的兴趣。

研究人员发现，当抚摸与婴儿在自己脸上的感觉相符时，婴儿看屏幕的时间最长。这只适用于正面朝上的图像；婴儿似乎没有把翻转的面孔和他们自己的联系起来。

这些发现表明，婴儿生来就具有建立身体意识所需的基本机制……”婴儿生来就有一些自我意识，《生活科学》，2013 年 11 月 21 日

“长期游戏”的要点是，首先，在创造真正的人工智能方面，我们比我们想象的更近和更远，使用我们通常所说的智能作为基线。我们比我们想象的更接近了，因为我们正在学习人类神经元如何支持人类意识，以及如何使用计算机模型来复制这些过程。也许，我们比我们想象的还要遥远，因为支持这样一个模型所需要的纯粹的计算机能力。也就是说，我们创建新计算模式的速度正在加快，例如云、容器和无服务器计算。

最后，当我们调查人工智能的当前状态时，这些系统被用作支持人类活动的工具。想想人类使用工具的历史。随着时间的推移，我们的历史一直是关于人和工具的协同关系。电脑只是工具。带起搏器，人工肺，假肢等。我们已经走上了将技术融入我们生活的道路，可以说几乎一直都是如此。然而，尽管我们使用工具，我们仍将是独一无二的人类。

关于我们所走道路的总结:

”布林评论说，尽管离谷歌大脑的杰夫·迪恩(Jeff Dean)只有几个纸夹的距离，但他没有看到深度学习的到来。如果创建谷歌的布林本人都无法预测深度学习的进步，那么我们对来自其他竞争人工智能部落的许多其他从业者又能说些什么呢？那是既得利益者？总之，不要相信你的常驻人工智能专家，他可能属于不同的部落。”卡洛斯·佩雷斯

你可能会说你对你写的东西一无所知！我咯咯地笑着回应道，“千真万确”，因此有了参考文献。既然我们同意这一点，让我们讨论一下参考文献的有效性。干杯。

参考资料:

《人工智能的众多部落》https://medium . com/intuition machine/The-Many-Tribes-problem-of-Artificial-Intelligence-ai-1300 faba 5b 60 # . gmpi 7 uvx 2

支持 DNA 研究的神经网络:预测 DNA-蛋白质结合的卷积神经网络架构，2016，https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4908339/#!po=31.1594

“儿童神经科学”https://faculty.washington.edu/chudler/what.html

“生物神经网络和人工神经网络有什么区别？"http://cog sci . stack exchange . com/questions/7880/什么是生物和人工神经网络的区别

维基百科，“情报”https://en.wikipedia.org/wiki/Intelligence

哈佛科学家认为他们已经找到了意识的物理来源

婴儿生来就有一些自我意识http://www.livescience.com/41398-baby-awareness.html

厄尔·米勒因在认知神经科学方面的杰出成就而获得戈德曼-拉基奇奖，这位神经科学家因其在模拟大脑回路引起认知方面的作用而获得认可。http://news . MIT . edu/2016/earl-miller-receives-Goldman-rakic-prize-in-cognitive-neuroscience-1101

脑细胞的 DNA 不同https://www . science news . org/article/brain-cells % E2 % 80% 99-DNA 不同

单个人类神经元的体细胞突变追踪发育和转录历史http://science.sciencemag.org/content/350/6256/94

神经元不断改写自己的 DNAhttp://www . Hopkins medicine . org/news/media/releases/neurons _ Constantly _ Rewrite _ Their _ DNA

模型揭示了抑制性神经元的目的

维基百科，心灵上传，https://en . Wikipedia . org/wiki/Mind _ uploading # Computational _ complexity

维基百科，神经计算模型【https://en.wikipedia.org/wiki/Models_of_neural_computation

人类基因组中储存了多少信息？http://bitesizebio . com/8378/人类基因组储存了多少信息/

自我浮现在脑海中:构建意识大脑

兆字节、千兆字节、兆兆字节……它们是什么？http://www.whatsabyte.com/

谁是汉克·m·格林？

“我就是我说过的我，一个讲故事的人。但是，你可能会问，我从哪里来，要到哪里去？十是我去哪里的钥匙，它决定了我从哪里来。”

读一读汉克·m·格林@https://sites.google.com/view/time-a-trilogy/写的《第一册:十》的草稿

推特@hankmgreene 或https://twitter.com/hankmgreene

https://www.facebook.com/hankmgreene

Flipboard: HankMGreene

建立卓越的数据科学中心来管理整个模型生命周期

原文：https://towardsdatascience.com/thoughts-on-data-organization-strategy-783dbd2b8ec9?source=collection_archive---------8-----------------------

他的数据技术革命浪潮依然强劲，各种规模的公司都在积极建立/扩大他们的数据科学团队。在寻找组织数据科学人才的最佳方式的过程中，由一个中央平台数据科学团队和嵌入业务部门的多个专业团队组成的混合组织模式已成为最佳策略和成熟策略。下面这篇发表在《走向数据科学》上的文章很好地解释了混合模型。

[## 数据组织的阶段

towardsdatascience.com](/the-stages-of-the-data-organization-b3f4f0589716)

虽然还没有标准名称，但 one central platform 数据科学团队可以称为卓越中心，因为他们传播良好实践并为数据基础架构做出贡献。尽管这种混合模式已经使许多公司在数据科学方面获得了巨大的投资回报，但我们还有更大的潜力将这种组织模式推向更高的水平。

我认为一个潜在的领域是授予卓越中心“评审者”的角色，让他们不仅仅是推动者。从模型穷到模型富，许多新的模型每天都在不同的组织团队中被创建和使用，有时低质量的模型会被发送出去并导致不良后果。我们现在需要一个值得信赖的地方，比如卓越中心，来仔细研究我们周围的模型，尤其是关键任务模型。

所有的模型都是错的

在我的一个工作项目中，我正在评估一个由我的同事创建的模型。我发现一个输入变量对我们的预测几乎没有贡献。我比较了有和没有输入变量的预测结果，始终得到几乎相同的结果。因为这个输入变量是那个项目中计算开销最大的特性，为了良好的建模/工程实践，我建议删除这个变量。我的同事建议保留这个变量，因为我们团队的一位高级领导构思了这个特性。保留它在政治上是有利的。最终保留了特色。

包含一个非信息变量可能没什么大不了的，但是，偏离追求卓越是不好的。当部署有缺陷的模型时，当根据错误的数据做出决策时，我们可能会面临严重的后果。乔治·博克斯有句名言，“所有的模型都是错的，有些是有用的。”模型有优点和缺点，需要仔细评估；在当今漫长而复杂的模型生命周期中，错误很可能会发生。

来自可信评审者的话语和评论可以帮助我们更好地评估模型的状态:如果数据质量是可接受的，如果模型假设和选择是有效的，如果性能度量被彻底测试，如果一切都被记录并可再现，如果业务解释与公式一致。当办公室政治生效时，评论者的角色变得更有价值。下面这篇 HBR 的文章说，“太深入业务职能的分析师往往偏向于现状。”

[## 3 件事阻碍了你的分析，而技术不是其中之一

许多公司继续与商业分析作斗争。这和技术无关…

hbr.org](https://hbr.org/2017/06/3-things-are-holding-back-your-analytics-and-technology-isnt-one-of-them)

卓越中心

一天，一位合作者告诉我，他建立了一个表现非常好的模型。知道他的发展是复杂的，几乎不可复制的，我发现自己很难相信他的说法。如果他从第三方评论者那里得到一个大拇指，我会立刻知道一些伟大的东西真的被创造出来了。在软件开发中，有人开发，有人测试。数据科学社区还缺乏这样的实践(如果我错了，请告诉我)。

将评审员角色赋予卓越中心是有方向性的，如何在现实世界中操作评审取决于团队、领导和文化。也许多个团队应该一起承担这个角色:数据人员、领域专家和工程师。尽管如此，我认为我们希望将高数据科学标准制度化，以便最大限度地发挥数据科学的影响，并防止不良后果。这一步将使当前的混合模式更加互联和治理。

更进一步，模型生命周期管理现在是一个开放的空间。如何注册、监控和淘汰数据科学工件(作为一个模型、一个特性、一个包、一个提取)需要深思熟虑的策略、强有力的领导和社区支持。上面讨论的审阅者角色只是模型生命周期管理的一个方面。卓越中心应该在这一开放领域发挥作用。

关于数据、科学和认识论的思考

原文：https://towardsdatascience.com/thoughts-on-data-science-and-epistemology-d816b3019743?source=collection_archive---------5-----------------------

这是我很久以来一直想以某种形式写的一篇文章，但是乔安娜·马尔瓦尼昨天提出的一个问题让我的想法变得清晰了一些，所以我在这里尝试阐述一下。

让我首先指出，在我的内心深处，我是一个“数据怀疑论者”，这并不意味着我不相信数据告诉我们的东西，而只是我怀疑我们是否能从数据中学到我们愿意相信的东西，不管我们可能会提出什么样的算法。“科学”是一个两步走的过程，其中数据分析是关键部分，但不是全部。

在我看来，构成“科学”的两个步骤是确定“正常”的范围，然后是观察到的现象是否代表了对正常状态(而不是高斯变化)的足够有趣的偏离。)如何建立“正态性”的范围可以是演绎的(即“公理化的”，遵循“逻辑”原则)或归纳的(即以数据为中心，没有任何先验偏见。)从本质上说，这是“理论”阶段，在这个阶段，假说形成了。从这个意义上来说，这只不过是人们从传统的“研究设计”课程中学到的东西，至少在理论上是如此。我的观点可能与教科书描述略有不同的地方是，可接受的常态范围并不普遍。人们来自不同的背景、需求和兴趣。他们每个人所认为的“正常”(推而广之，对正常的足够“有趣”的偏离)不一定是相同的。对于已经熟悉萤火虫的捕食习惯的昆虫学家来说，如果他们的先验知识被转化为假设，他们应该彼此等距分布，这正是人们通常应该期待的——即使他们自己不一定采取这一步骤。对于不知道萤火虫会互相吞食的外行人来说，它们的分布不是随机的才是有趣的部分——前提是他们能理解遍布于给定空间实际上不是随机的。

一个潜在的严重问题来自于数据消费者之间关于“通常”应该从数据中得到什么的错误沟通——一种“黑天鹅”问题。卡尼曼和特沃斯基对行为经济学的一个重要贡献是，人们对罕见事件的期望过高或过低，这取决于环境。一些人，甚至很多人，以有意义的概率期望赢得彩票，战胜股市，成为职业运动员。与此同时，人们忽略了为数不多但数量可观的人可能同时投票给奥巴马(2012 年也是如此)和特朗普的可能性，也忽略了这一“罕见”事件可能带来的后果。数据分析可以帮助实现的是精确确定正常预期的范围-整个分布，而不仅仅是平均值-以便所有受众都能就基线达成一致。请注意，这不需要用数学术语。数据可能总是为 0，除了 1-2%的情况下为 1(据我所知，这是大多数现实生活数据的典型情况——问题、投诉、评论等)。是罕见的事件。)所以正常的范围可以简单地描述为 98–99%的时间为 0，1–2%的时间为 1。如果我们不能认同手头的数据，再加上我们可能有的任何演绎洞见，那 1——2%是由什么构成的，这就是我们所能说的。请注意，这与“预测性”分析略有不同:我们期望 0，但如果我们得到 1，我们不应该太惊讶，而不是“如果 X，答案是 0，如果 y，答案是 1。”归根结底，我们处理统计数据是因为我们不知道真实世界的全貌，因此，我们不仅需要精确了解我们“知道”的事情，还需要精确了解我们不知道的事情。在这种情况下，即使我们确实知道更多关于 X 和 Y 的信息，如果 X，那么“预测”应该是答案可能是 0，但有 1 的小概率(有希望量化“小概率”，有置信区间)；如果 Y，答案可能是 1，但也有可能是 0。即使“预测”没有明确说明，这些说明也应该是数据消费者所期望的，并且应该被要求提供。(这对于理解 2016 年选举中发生的事情很重要，回想起来，2012 年也是如此:大多数人投票是可预见的，但有些人没有，在一些不寻常的情况下，试图将“通常”应用于不寻常的时期是科学的弊端。)

不过，一般来说，数据分析人员似乎在确定什么是“正常”方面做得很好。似乎很少被关注的重要部分是第二阶段:识别偏离常态的情况，并评估它们对手头目标的意义。为了实现这一点，需要重新思考数据科学中的一个常见实践:将样本划分为训练集和测试集，并使用后者来验证前者中发现的模式。作为第一步的一部分，这是一个很好的实践，因为它有助于将健壮的模式从脆弱的模式中分离出来——但前提是要小心使用，我将在下面详述。它对识别显著偏离常态没有任何作用，事实上，过于盲目地投入交叉验证实际上会抑制有趣模式的发现。

正如我所建议的，发现有趣偏差的方法颠倒了交叉验证逻辑。在交叉验证的逻辑中，敌人是过度拟合:我们希望确保模型在训练集和测试集之间产生一致的预测。如果模型为训练集预测了测试集中没有出现的东西，那么模型可能是坏的。或者，也许模型实际上是好的，甚至比我们想象的更好——我们无法说出这一点，因为我们对数据以及训练集和测试集在某种程度上的差异了解不够，这可能对我们来说并不明显。我们应该询问数据中训练集和测试集之间的偏差出现在哪里，并检查偏差来自哪里。我们应该知道足够多的概率理论来评估偏差，以样本中出现偏差的子集为条件，是否可以用随机性来解释，或者是否有更有意义的东西。也许基于小的子样本邻域排列的重采样方法可以用来评估偏差的统计显著性(这几乎不是一个革命性的建议:匹配是一种足够流行的统计技术，它只是一个相对简单的编程工作——遗憾的是，我并不特别擅长匹配大数据的小片段)。

一个常见的问题是，随着数据变得越来越大，越来越多的数据来自显而易见的、容易的、简单的和平庸的，这往往会强化刻板印象和传统智慧。有趣的潜在发现潜伏在不寻常的、奇怪的、最重要的、罕见的数据子集里，这些子集变得越来越容易被忽略，特别是当在一个由通常和可预测性主导的样本中接受稳健性检查时。与产生可靠预测的绝大多数“容易”数据点相比，样本中不寻常但有趣的子集也不那么容易预测，这并没有什么帮助，因为它们太少了，无法成为统计上有用的样本。套用托尔斯泰关于幸福家庭与不幸福家庭的名言，预测什么使家庭幸福是非常容易的，而不幸福家庭的最佳预测者是他们不幸福。如果目标是理解不幸的家庭，这是有问题的。

这值得吗？如果 99%的家庭是幸福的，或者 99%需要翻译的文件遵循可预测的模式，或者 99%的选民在 99%的时间里表现可预测，那么当模式打破时，在 1%的人身上花费大量时间是否值得呢？我觉得要看那 1%在哪里，什么时候。事实上，大多数日常琐事可能是简单的、常规的、可预测的，但那 1%可能会导致足够重大的事件——比如金融崩溃或选举失败。也许并不是所有奇怪的 1%的数据都值得严格审查，但一个好的分析师应该睁大眼睛，看看从这些不正常的小片段中可以学到什么，并尽他/她所能从中学习。

杰哈和托普对 JAMA《适应人工智能》的思考

原文：https://towardsdatascience.com/thoughts-on-jamas-adapting-to-artificial-intelligence-by-jha-and-topol-9965d6f6c25d?source=collection_archive---------3-----------------------

当记者写下人工智能在医疗保健领域的颠覆性力量时，他们往往会专注于放射学和病理学，这是有充分理由的。这两项交易都涉及从可量化的图像数据中解读模式——在从面部识别到热狗分类的几项研究和商业应用中，人工智能已经证明了这一点。

在每篇文章中，房间里的大象是放射科医生和病理学家的未来？

我今天了解到，这个问题去年在《美国医学会杂志》的一篇题为“适应人工智能，放射科医生和病理学家成为信息专家”的文章中得到了正面回答

标题足够有趣。然后我看到两位作者是索拉博·贾(放射学家)和埃里克·托普，我知道我必须从防火墙后面偷偷拿出一份拷贝。大多数关注医疗保健的人都知道托普。他是一个书籍作者，医学博士，见解深刻，固执己见，但专业如此。我读过 Jha 在医疗保健博客上的帖子和在 Twitter 上关注他(值得)。他聪明、直言不讳、与众不同。一半的乐趣是看着他在传统的医疗文化中一往无前，而且做得很好。我想这些人在这件事上花了不少时间。以下是他们不得不说的话:

人工智能将取代放射学家和病理学家今天所做的许多工作。

Jha 博士和托普博士粉碎了任何认为人工智能将无法做大多数放射学家和病理学家今天所做的事情的想法。他们引用了创业公司和大公司已经被证明比人类更有效的例子。他们用了 2 页文章的一半来阐述这个明白无误且令人信服的观点——不管你喜不喜欢，这都在发生。句号。现在是适应这一新现实的时候了。

"为了避免被计算机取代，放射学家必须允许自己被计算机取代."

在第 2 页中，为真正的测试做好了准备。贾和托普博士将如何处理“人类的下一步是什么”这一部分？

随之而来的是引人入胜。我重读了三遍。这是一部接一部的戏剧:

放射科医生和病理科医生到底是什么？

用贾和托普博士的话说:

“放射科医生的主要目的是提供医疗信息；图像只是获取信息的一种手段。放射科医生更适合被认为是专门从事医学成像的“信息专家”。

这类似于病理学家，他们也是信息专家。病理学家和放射科医生在本质上是相似的，因为他们都从图像中提取医学信息。"

值得概括一下:

• 放射科医生和病理学家是一样的，因为他们的主要工作是解释图像。
• 如果不是信息专业，图像解释和结果交付是什么？
• 图像是达到目的的手段——你们真的是信息专家。

那是一些元的东西。但是放射科医生和病理科医生会如何看待重新定义他们的价值主张呢？在多年学习阅读非常具体的图像以获得非常具体的模式后，他们认为自己是信息专家吗？就此而言，对于仅仅是信息专家的初级保健医生来说，诊断考试是不是达到目的的手段？

现在，谁在乎。这是一个大胆的开场白。如此大胆，以至于作者继续加倍强调需要大胆的笔触。

你的两个领域早已拥抱科技。在你做的许多更复杂的任务上，人工智能比你做得更好。受过训练的鸽子可以做你的工作。

在你指责我胡编乱造之前，以下是他们的原话:

“病理学家已经接受了机器和技术……人工智能可以执行病理学家更复杂的任务，在某些情况下，具有更高的准确性……尽管此类研究需要对更多样化的组织类型进行大规模验证，但在放射学和病理学领域，人工智能显然可以处理许多任务。为了强调放射学和病理学之间的共性，研究人员使用操作性条件反射训练鸽子在乳房 x 光片上发现异常钙化，并在组织学上检测乳腺癌。

舞台已经搭好(以我的鸽子比你的优等生聪明为例)，贾博士和托普提出了我确信会被许多人视为异端的观点:

你的两个学科应该合并成一个单一的实体，称为信息专家。

那是巨大的。你们两个的职位都不需要再存在了。它们应该被合并。忘记图像，坚持附加值:解释更难的图像(尽管前一段认为这项任务的时间不多了)，建议进一步的测试，并指导临床医生。你仍将是“医生的医生”你不会得到你的头衔，也不会做你被训练去做的事。

我知道这些家伙不会让人失望的。

人工智能+人类=对于那些跨越人机界限的人来说，生产力和影响力更大

杰哈和托普认为，“一个信息专家，在人工智能的帮助下，有可能管理整个非洲城镇的筛查工作。”

当然是真的。那些学会跨越人/机器世界的人会面临新的机会和影响。然而，我更希望使用这种观点的人承认这种新的供需现实的负面影响。

我想当蒸汽动力针织机来到取代它们的时候，这是对针织者的鼓励。养马的人可能确信亨利·福特的努力会在某种程度上改善他们的生活。几代人之后，在底特律制造业经济崩溃前不久，他的经理们可能向他们的工厂工人推销了同样的小说。

请再告诉我一次，当一个人可以做成千上万我们曾称之为放射科医生的工作时，我们真正需要多少“信息专家”？

既然这样，我们就放他们一马吧。毕竟，他们只是提议烧毁两个学科。

信息专家应该接受不同方面的培训。

“受训者只需掌握足够的医学物理学知识，就能提高医学图像的次优质量。信息专家应该学习贝叶斯逻辑、统计学和数据科学，并了解基因组学和生物统计学等其他信息来源，因为他们可以将不同来源的数据与患者的临床状况相结合。”

除了“你不应该再以任何可识别的方式被训练成放射科医生或病理学家”之外，我不知道该如何解释这个问题。如果我的解释是合理的，它回避了一个问题:这真的是放射学和病理学特定的进化所需要的吗？或者这是放射科医生和病理学家应该考虑申请的新的和需要的子学科的情况吗？那么现有的被 AMA 认可的医学分支学科医学信息学呢？另一次…

合并两个不同的医学专业可能会遇到阻力，每个专业都有独特的教学、传统、认证和报销

我会带爆米花。

“联合起来，放射学家和病理学家可以随着人工智能的兴起而繁荣发展。”

嗯嗯好吧。只要我们不再是放射学家和病理学家，对吗…？

“工作岗位不丢；相反，角色被重新定义；人类被迫从事需要人类元素的任务。”

告诉那些被解雇的放射科医生吧。

鉴于他们传达的信息的严重性(和诚实性),他们的结束语令人惊讶地乐观。他们也不仅仅是有点矛盾。我猜他们在这个问题上有过激烈的争论——也许是和 JAMA 的编辑们，也许是彼此。

总之，这篇文章非常有趣。这是我在同行评审的医学杂志上见过的最大胆的文章，它不带任何歉意地提出了一个有争议的、充满政治意味的话题。支持变革必要性的证据令人信服。在我看来，要求开设新专业是正确的。我不确定这种需求代表了放射科医生和病理科医生的自然进化，而不是他们的下坡路。无论哪种方式，放射科医生，病理学家，临床医生和管理人员在阅读这篇文章后会有很多要考虑的。向杰哈博士和托普博士致敬。

关于公制设计的思考

原文：https://towardsdatascience.com/thoughts-on-metric-design-51a4c3b773a0?source=collection_archive---------11-----------------------

我注意到，当我在硅谷提起“指标”这个话题时，人们似乎要么爱我，要么恨我。跟踪并尽可能采取一些你认为能抓住你的业务或产品的重要方面的措施，对一些人来说是提高生产力的灵丹妙药，对另一些人来说则是短视的创造力杀手。不管你对定义和跟踪指标的好处有多强烈的感觉，如果你决定这样做，花时间去思考指标设计的原因和方法是值得的。我们最近在 Wealthfront 做了一些这样的事情，我想我应该分享一下我从这个过程中学到的东西。

关于度量的资源

有无数的书籍和的 TED 演讲(甚至的公司)致力于度量的主题。不同的人使用不同的名字和缩写，他们以稍微不同的方式定义和使用度量，但是他们最终得到了相同的点。我不会总结所有的细节，我会列出我在 Wealthfront 定义业务和产品指标的过程中参考过的资源。

• 衡量什么最重要——约翰·杜尔登
• 用数据取胜——汤姆·东格斯
• 创建数据驱动的组织 — 卡尔·安德森
• 如何为你的产品选择正确的 UX 指标——凯瑞·罗登
• 在人群之上——比尔·格利

度量的用途是什么

指标可用于前瞻性和回顾性。

未来的

我所说的前瞻性是指使用一个指标作为评估决策潜在影响的框架。这种度量的使用有助于解决的一个问题是团队之间对于他们试图优化什么的分歧。就度量标准达成一致使团队能够就不同项目的相对优先级进行富有成效的讨论。没有度量标准，关于团队应该做什么的争论可能会脱轨，因为对每个人的工作目标没有共同的理解。例如，我选择“实验运行次数”作为数据科学团队的内部指标，这有助于我对我们纠正到达率偏差的工作进行优先排序。预期使用指标的一个额外步骤是设定移动指标的目标，尽管这不是必需的，也不意味着指标与绩效评估相关。

回顾的

一旦团队前瞻性地使用度量标准，他们就可以考虑回顾性地使用它们。这意味着将度量的变化作为评估项目或团队的机制。这是反对度量的人容易有问题的用例，尤其是当度量被用作个人或团队认可和晋升的基础时。当一个团队对他们的度量没有高度的控制时，或者如果影响他们的度量的外部因素不能被适当地考虑时，这个用例可能是具有挑战性的。Wealthfront 的一个例子可能是依赖于市场的指标，如管理下的资产变化(AUM)。

这是一个多么好的衡量标准

一个有用的指标应该是有意义的、可测量的和可移动的。

有意义的

首先，指标应该捕捉对业务直接或间接重要的东西。对于 Wealthfront 来说，一个直接重要的指标可能是净存款或新客户资金账户的数量。间接重要的指标可能是那些更高级别的指标中的一个。例如，在其他条件不变的情况下，减少客户流失意味着更少的客户取钱，这将增加净存款。虽然这似乎是显而易见的，但它通常是团队最难达成一致的部分。

可测量的

如果一个指标不能被测量，那么它就不能被追溯使用。如果不清楚该指标是否可以或应该移动，那么在前瞻性地使用时也会很有挑战性。例如，众所周知，口碑很难准确衡量或评估。如果结果是你的客户已经在谈论你的产品了，那么试图增加这个指标可能是徒劳的。有些指标无法直接测量，但仍有潜在价值。例如，客户终身价值是估算的，而不是测量的(至少在有用的时间范围内)。然而，这可能是一种健康的方式来组织关于优先考虑哪些产品和功能的讨论。

动产

最后，一个好的度量标准需要是可移动的，至少在理论上是如此。如果一个团队不能影响它，一个度量标准在未来和过去都是无用的。例如，税前、费用前回报对 Wealthfront 来说是一个糟糕的指标，因为我们无法控制全球投资市场，我们也无法改变它们。然而，保留将是一个有效的指标，因为我们可以通过改变我们的产品来取悦我们的客户并解决他们的问题，从而使他们留下来。即使一个指标是估计的而不是测量的，它仍然是可移动的，就像 CLV 的情况一样。

The price of VTI (“the market”) would make a poor metric because it is not moveable (unless you control Donald Trump’s Twitter account)

衡量标准有局限性

度量不需要做所有的事情。

平衡力

我在 Wealthfront 工作过的许多团队遇到的一个挑战是担心他们提出的指标有一些盲点或弱点。例如，我们的财务规划团队希望有一个衡量指标来捕捉路径的参与度。但是，他们担心这一指标可能会被过度优化，以至于客户登录的频率超过了对他们有益的程度。当我指出他们的另一个面积指标有效地衡量了我们客户的财务成果的质量时，我们同意这将对冲过度指数化参与的风险。 Keith Rabois 将衡量制衡指标的实践称为“配对指标”。

文化

降低指标盲点风险的另一个因素是使用它们的文化。例如，我们 Wealthfront 的公司价值观和产品原则分别概述了我们的行为方式和我们如何制造产品。这些工件和它们所代表的文化使得一个团队不太可能做一些对我们的客户或我们的业务不利的事情，因为这是优化他们的一个度量的简单方法。例如，我们或许可以通过使在我们这里销户变得极其困难来减少提款(像美国银行、大通银行、富国银行和其他大银行那样做)，但这将与我们的原则和价值观产生强烈的矛盾，因此永远不会发生。

衡量行动，而不是言语

选择捕捉行为而非情绪的指标。

接近度

度量是你所重视的东西的代理。如果你想一想你真正想用你的标准捕捉什么，你会发现有些人比其他人更接近这个理想。例如，客户的推荐可能比他们的会议时间长短更能衡量他们的快乐程度。这是因为推荐是一时高兴的结果，这两个事件在事件的因果图中紧密相连。不难想象，一个更长的会议可能是由无数与快乐完全无关的因素驱动的。从这个意义上说，推荐比会话长度更“接近”愉悦。接近度可以是一个有用的维度，用于在两个指标之间进行选择，或者问自己是否有更好的东西可以抓住你真正想要衡量的东西(或者，如果你真的迷失了，你开始重视什么)[参见上面“有意义的”一节。])

“从不衡量用户的快乐”——凯西·科济尔科夫

阿尼玛斯

都说行动胜于言语。我持更严厉的观点，认为语言是无声的。你的客户告诉你的话是在转移注意力，除非这与他们的所作所为有强烈且持续的关联(我还没有在野外遇到过这种情况。)例如，如果你在入职流程结束后对用户进行调查，平均评分为 4.9，但只有不到 10%的人转化为付费客户，那么你就是一个使用 NPS 的傻瓜。客户有很多理由对你和他们自己撒谎，这些样本中的选择偏差足以让它们变得毫无用处。此外，听取社交媒体上抱怨最大声的少数(可能)用户的声音是加倍愚蠢的。无论你是否将它作为一个明确的衡量标准，放弃决策权以感知 Twitter 情绪是对职责的放弃。唯一重要的是你的客户做什么。

简单地说

无论您计划前瞻性地还是回顾性地使用指标，请记住确保它们是有意义的、可测量的和可移动的。不要担心你的度量标准之间是否有差距，只要它们相互平衡，并且你在你相信的文化和价值观的背景下使用它们。无论你做什么，请衡量行动而不是语言。

对网络、通信、区块链和太空时代互联网的思考

原文：https://towardsdatascience.com/thoughts-on-networks-communications-blockchains-and-a-space-age-internet-42a0cdf62a7d?source=collection_archive---------11-----------------------

网络是可视化和量化对象及其与其他对象的关系的重要方式。互相交换光子的粒子构成了一个网络。拥有发送和存储由卡车、轮船和飞机运输的货物的仓库的公司也构成了一个网络。有许多有趣的例子，包括电视广播、食物链、消费者零售和电网。

可以通过考虑描述业务运作的网络来理解业务。例如，油井位于某些自然发生的地方，但石油或其衍生物无处不在(汽油和塑料，举几个主要的例子)。例如，将石油从油井直接输送到人们的汽车上，效率会非常低。如果你画一个地理网络，其中节点是地图上的位置，边是位置之间的距离，这一点很容易看出来。然后你可以在上面画另一个图，新的边表示石油管道和它们的容量或距离。通过将这些边的“权重”相加，你可以很好地了解建设管道网络的成本。

但是一对多的网络结构很好地描述了电视。它是一种广播媒体，有效地获取单一来源，并在同一时间将其直接分发给观众。如今，电台广播和社交媒体上的任何直播视频也是如此。

对比这两者，我们看到有时一个非常简单的图形视角可以告诉你很多关于企业的本质。我们可以看出，由于地质条件的限制，石油公司面临着一个巨大的分配问题，以及为什么可再生能源可以在地球上更大的地理区域内更有效。我们可以看到传统电视如何面临明显的个性化危机，或者我们可以看到个性化如何成为内容创作爆炸的驱动因素。

描绘网络时，立即可以看到的是规模问题。一个简单的问题是边的数量相对于节点的数量是如何增长的。例如，在电话网络中，人们需要相互交谈，但是随着节点(人)数量的增加，边的数量也成平方增加。对于 100 万电话服务客户来说，这意味着 1 万亿条电话线。对于 3000 万客户来说，就是 900 万亿！另一种看待它的方式是看你在二维(或者三维，如果你喜欢，洞察力是关于节点之间的边密度)中组织图形的能力。如果你能以一种有组织和合理的方式画出图表，而没有很多边相互交叉，这意味着你正在处理一个可分解的问题。所有这一切的教训是层次:如果你有它，你知道你可以缩放你正在看的任何东西到第一近似值。

请注意，在我们的例子中，我们是如何以两种方式使用网络图的，这在一开始可能会有点混乱。在石油开采和分配的例子中，我们考虑了实物是如何在空间中移动的。在电视示例中，我们当然也可以考虑电视信号的物理传输，并展示它与石油分配的相似之处。相反，我们专注于客户对服务的看法，这揭示了其明显的局限性。考虑一下图是如何被其他图限制的，比如地理图或基础设施图，这是一些常见的图，可以给图添加一个新的维度。或者想象一个更微妙的例子，个性化如何创建一个社交群体之间连通性更有限的图表。这导致了回音室的出现和假新闻被用于大规模的政治影响。

因此，网络图是一种强有力的心理工具，有助于揭示系统的结构。对企业来说，它有助于澄清企业如何运作，如何继续运作，以及何时停止运作。

通信行业的网络

过去，美国的邮件传递通过纽约市的一个办公室，然后分发到当地的邮局(概念上是一个基本的星形图，或轴辐式模型)。但是邮件的物理移动被限制在公路和铁路的运输图上。这不是一个特别令人惊讶的事实，这只是一个最基本的事实。人们想要交流他们在哪里。电报是第一个能够传输电脉冲来交流信息的设备。它们首先出现在火车站，然后迅速转移到邮局。

电报主要被火车站、邮局、其他重要的政府机关和大公司使用。对于一般人来说，维护硬件和记录他们之间的消息需要太多的工作。电话的发明完全改变了这一点，因为人们可以听到声音，并几乎在瞬间传送自己的声音。

考虑一下当我们从几个重要的组织相互交流转变为中产阶级家庭中的每个人相互交流时，网络会发生怎样的变化。图形变得更加密集，解决潜在的电话线路爆炸的自然方法是建立路由集线器。交换机正是建立这样一个电话网络所必需的发明。

但是回想一下我们之前电话网络稠密图中的数字。所需的通信带宽并没有减少，我们只是将这一负担转移到了更少的“更粗”的管道上，这些管道构成了我们今天拥有的更稀疏、更高效的网络的主干。请注意，更粗的管道意味着在“垂直”缩放方面的更大投资，而“水平”缩放将只是添加更多的线，正如我们之前所考虑的那样。曾几何时，农民在农村地区使用廉价的绝缘铜线架设电话网络，甚至采用已经穿过牲畜围栏的带刺铁丝网！对他们来说，水平扩展确实有效，但是垂直扩展带来了只有专注的大公司才能获得的技术进步。在抽象图形视图中，某些边在视觉上可能看起来更粗，权重更大，以描述它们所服务的流量的容量和体积。

从电话线路到光纤的过渡严重依赖于先前的基础设施。它也显示了进一步的纵向扩展，这是电信公司保持其控制的机制。他们是技术的受益者，这些技术强加了严格的物理和地理限制，使得建设全新的网络极其昂贵。

不提及这种权力如今正受到怎样的挑战是不公平的。电信公司喜欢成为客户生活的中心。虽然从技术上来说这仍然是事实，但沟通已经从电话交谈发展到视频聊天、短信、博客、推特、喜欢和公开评论。作为消费者，人们的注意力现在分散在许多概念媒介上。电信公司现在是烦人的公用事业公司，似乎只是碍手碍脚。人们关注的是像脸书和推特这样的交流促进者。

对于新技术公司来说，电信是一个巨大的威胁。只要互联网还在物理电缆上运行，电信公司就会统治。没有什么比过去几年的互联网中立之战更能说明这一点了。

但是有一种技术可以完全改变这种情况。

无线和空间

突然间，SpaceX 和脸书以全新的方式打造互联网基础设施的努力变得有意义了。推翻电信业的唯一方法是让它们目前的基础设施变得无关紧要。如今，电信公司确实拥有一些无线技术，但它还不够成熟，不足以在很大程度上取代物理电缆。事实上，它们甚至还不够成熟，互联网服务提供商(ISP)无法在它们和客户之间使用。尽管移动服务提供商在这方面做得越来越好，但只要物理电缆仍然是骨干提供商，这种局面就不会改变。

对脸书来说，投资 moonshot 通信项目对其持续繁荣至关重要。如果其中一家成功了，他们将成为有史以来最强大的通信公司(就像贝尔系统之前一样)。对于 SpaceX 来说，回报甚至更令人震惊:他们将拥有太空运输以及行星内部甚至可能是行星之间的通信。这将使他们成为有史以来最强大的公司之一。

想象一下，通过一项真正成熟的无线技术，地球内部的通信格局会发生怎样的变化。如果无线信号可以通过卫星传播到整个地球，以前基础设施的负担就不复存在了。电信公司的地面基础设施是其业务不可或缺的一部分，它们会发现自己的影响力受到了严重限制。它们是会下降，还是只是继续处于下降状态，还有待讨论，但很明显，权力格局将会发生重大变化。

消除对重型地面基础设施的需求的非常有趣的含义是，它消除了新的 ISP 公司进入的巨大资本壁垒。发射卫星网络、重组卫星网络或让卫星退役，将比在难以到达的地方(比如海底)铺设数百万英里的新电缆容易得多，也更划算。一个斗志昂扬的新贵，拥有超越当今无线电或光学的新技术，可以将它打包到几颗卫星上，部署到整个地球。理论上，消费者转换的障碍可以忽略不计。

假设无线技术超越了太空运输技术，很明显，通信领域的能源前景看起来要平坦得多。最终我们将殖民足够多的星球，让星际通讯变得重要。那么部署这些网络的基础设施将再次成为新进入者无法逾越的障碍。

如此循环往复。

事情的另一方面

关于系统网络的讨论，如果不讨论集中与分散，就永远不会完整。某件事是集中还是分散取决于你的观点。但是，如果您选择一个视图并查看代表它的图表，集中化很容易发现:您会看到少数元素(节点、边或两者)具有高价值，而许多元素价值较低。例如，从计算机网络硬件的角度来看，人们拥有的计算机(笔记本电脑、电话等。)都是低值。高价值计算机的价格高达数十万美元，构成了这些通信网络的主干。

一个分散的系统有一个图，图中的价值分布更加均匀。例如，互联网的逻辑图是一个将简单的计算机连接到其他计算机的网络，其节点的价值相当均衡。换句话说，人们日常使用的电脑彼此没有太大的不同，它们大多做相似的事情。

一个更有趣的例子是欧盟之前的西欧。它们是一些国家的集合，一些比另一些更强大，以分散的方式相互作用。好处是显而易见的:完全的自主权和来自监管机构的自由，该机构可能会为这些国家做出次优的决定。缺点也相当明显:在许多维度上协调性、一致性和速度都降低了。正如欧盟的形成所表明的，出于多种原因，人们对中央集权有着强烈的兴趣。

可能去中心化最有趣的例子是比特币，它建立在一种叫做区块链的东西上。比特币网络的分布也非常均匀，就像互联网一样。分散式系统付出了更高的开销，作为回报，它消除了集中式系统的缺点。就金钱而言，如果权力下放从无能或恶意的政府手中夺走了权力，那么它的间接成本可能是可以接受的。

但是比特币的成本还没有被完全理解。截至目前，区块链总体上面临着规模扩大危机。从网络上不难看出这一点:所需的资源量随着需要服务的节点数量的增加而增加。比特币的一个核心限制是每秒钟允许的交易次数，大约是三四次。这里有许多旋钮可以转动，但基本的限制是，在将事务添加到区块链之前，需要在所有或至少大多数节点之间达成共识。

一个有用的类比是民主与独裁:民主需要公民达成共识，这严重阻碍了行动的速度。这就是为什么罗马人在危机时刻会临时任命独裁者。这也是为什么许多民主政府在某些情况下赋予其领导人某些权力，以中断民主统治。这突出了集中式和分散式系统之间的基本权衡，以及它们必须如何扩展。

中断的约束违反

通过从图表和约束条件的角度来看上个世纪电信业的历史，我们可以讨论新进入者可能会如何产生影响。地理网络对其物理基础设施网络的限制揭示了一个可能的中断区域。卫星通信只是一种技术，但其颠覆力量背后的基本原理是改变或违反对现状的限制。想到也许一些自主飞行器可以使用自动跟踪激光跨越海洋发射信号是很有趣的。在这种情况下，连接世界的整个电信主干网将被一家拥有一点先进技术的小型航空航天公司取代。

当然，也完全有可能这样的技术没有被发现。然后，我们让政府去遏制一个不受控制的行业巨兽(就像他们过去所做的那样)。但是，技术发展掌握在少数人手中的可能性极小，因为这是一个极其密集的过程，并不总是在强大组织的严格控制下蓬勃发展。真正改变范式的技术也不太可能只让当权者受益。想一想一项技术会以多少种其他可能的方式影响社会，很明显这是真的。区块链是一个很好的例子，互联网也是。有人可能会说，赞助者会随着时间的推移而改变，但大众和少数人之间的控制权之争是一个基本事实。想想比特币的采用如何超过了没有资源监管它的第三世界政府。对这些国家的公民来说，他们正在或很快会发现自己拥有更大的控制权。

这也可以解释为一个网络。很明显，当前的技术掌握在冷酷无情的人手中，对其他人来说可能是一笔糟糕的交易。但无休止的权力整合揭示了一种根本无法扩展的结构。它表明，即使个体本身是无效的，甚至是无组织的，但数量仍然有很大的影响力。这是罗马帝国衰落的主要原因之一。

技术可能会提高一个小团体控制一个大团体的能力，但这不可能无限扩大。我们知道物理空间、时间以及速度等衍生概念是有限的，而且永远都是有限的。技术可以使我们的环境和环境得到指数级的改善，但是每一次我们只是指数级地扩张我们的环境并恢复我们熟悉的力量平衡。

对于这样一个简单的工具，网络视角提供了对我们世界惊人的洞察力。

本文中对网络的处理是非常基本的，但是通过将事物视为图形(网络的基本数学对象)，我们可以做各种各样不可思议的事情。很多关于图的实际问题，从根本上来说都是网络科学领域研究的难题。解决这些问题的方法是将互联网数据包从你的电脑路由到脸书的基础，从你收到亚马逊包裹的速度，到网飞将相同内容同时传输给数百万用户的能力。网络图还有许多其他用途，其中一个重要的用途是本体(或知识图)。将这些系统严格定义为图形，可以使用非常有趣的数学工具。我希望在某个时候，在一篇更技术性的文章中涵盖其中的一些内容。

我在这里写的笔记主要是受我最近开始读的三本书的启发。第一本讲述了在物理世界中，网络是如何以极其相似的结构出现的，书名为 好主意来自 。第二个是关于电报以来的通讯史，也就是所谓的 总开关 。我只读过这两本书的第一章，但是一点点白日梦产生了一些有趣的想法，我想记下来。我想它们会随着我的深入而改变。最后一本书在我看来不太新，但对技术如何影响社会有着深刻的见解，书名是《文化帝国》，作者是我最喜欢的作者之一彼得·欣延斯。他对成本重心格局变化以及技术如何在其中发挥关键作用的观点是我们这个时代最有趣的观点之一。他还编写了 ZeroMQ 及其非常有趣的文档。让软件文档变得有趣是一个不可思议的壮举，证明了 Hintjens 作为作家的天赋，所以希望这是一个足够有说服力的理由来看看他的作品。

关于招聘与技术的思考

原文：https://towardsdatascience.com/thoughts-on-recruiting-and-technology-5bae04b933e?source=collection_archive---------0-----------------------

由于我即将进入大学四年级，最重要的是毕业后找份工作。我敢肯定，对于全国的每一个大学毕业生来说，这都是一件压力很大的事情。为了剖析求职过程，我试着把它看作一条双行道:招聘者和求职者。招聘者希望找到人才加入他们的公司，而求职者希望找到最好的工作地点。作为一个求职者，我认为从招聘者的角度来看会非常有趣。如何找到合适的候选人？如何评价一个人对另一个人？如何确保一个强有力的候选人不会对公司失去兴趣？

上周，我参加了一个在 Hired 的聚会活动，这是一个职业市场，它将求职者和想要雇佣他们的公司联系在一起。他们就技术和招聘的交叉进行了小组讨论。在旧金山这样一个高度创新和以技术为导向的地方，软件侵入了公司的每个职能部门，甚至在销售(Salesforce)、用户研究(UserTesting)、集客营销(HubSpot)等非技术岗位……招聘也不例外，推出了 Jobvite、Workable、ApplicantStack 等产品……在这次讨论中，小组讨论了用于招聘和雇用顶级人才的创新工具，以及技术如何改变公司获取人才的各个方面。小组成员是:

安德鲁·哈布斯 —温室产品总监

Vivek Reddy—Entelo 前人才主管**

艾琳·勒纳——联合创始人兼首席执行官接受采访**

Gemmy Tsai—产品负责人。

艾莉森·巴瓦泽-佩德罗——育碧美人力资源经理

按照我通常的写作风格，我会概括讨论中的问题和答案，并对每个问题补充一些我的想法。

为什么大多数科技公司目前的招聘流程被打破了？

来自小组成员的大多数反应的共同点是，那里有太多的噪音；因此，很难对你的工作申请进行优先排序。从求职者的角度来看，如何放大信号？(如何发现合适的机会去争取？).双方也有很大的差异:公司找不到合适的候选人，求职者不知道他们想要什么。Aline 举了一个软件工程招聘的例子——它应该是完全精英化的(基于候选人的编程技能),但许多公司转而追求血统(基于他们去的大学或之前工作的公司的名称)。

在我看来，至少最后一部分是真的，硅谷的许多科技公司更看重应聘者的学历。如果你在斯坦福或常春藤盟校学习，你的机会会比其他申请人多得多。在一所文理学院学习，我真的需要主动想出策略来吸引招聘者的注意:个人网络、会议和聚会、社交媒体参与……等等。

技术如何改善现有的破碎流程？

像“雇佣”和“T2 温室”这样的产品确实让公司和候选人更容易互动，更了解对方。从小组成员对这个问题的回答中，我发现了 3 件有趣的重要事情:

技术改变了候选人和公司之间的权力动态。传统上，公司可以等待候选人申请空缺职位。现在，这些公司不得不将自己标榜为一个有市场、值得工作的地方，因为有许多其他选择可供候选人从雇佣或温室等平台中选择。

招聘人员的角色转变为品牌大使。这是非常直观的:如果公司需要树立自己的品牌，招聘人员的工作就是与候选人交谈，展示质量、福利以及任何关于工作机会的积极方面。

****公司需要采用其他职能领域的技术来培养候选人。这又回到了我在第一段提出的观点——销售、营销、人力资源都需要利用技术来培训新员工，让他们熟悉工作文化。

Aline 提出了另一个很好的解决方案，那就是使用技术来评估面试表现。她的公司intervaling . io，本质上是为软件工程候选人提供样本技术面试问题，然后使用评分算法对其进行排名。

然而，最有趣的答案来自 Gemmy，Hired 的产品负责人——应用机器学习和大数据来帮助采购和招聘过程。他提到，Hired 的产品团队正在使用机器学习算法，根据候选人个人资料和公司职位描述的数据，将候选人与他们最有可能感兴趣的工作进行匹配。我认为这完全改变了游戏规则，因为它将使招聘过程完全民主化。

求职者找到合适工作的主要挑战是什么？

专家小组的回答更倾向于候选人如何最好地表现自己。他们在这里:

确保你的简历整洁有序。

在整个求职和面试过程中保持诚实和真实。

少即是多:关注你过去最自豪的成就，而不是罗列一大堆东西。

期待这个过程是双向的。

最后，公司方面应该有更好、更详细的职位描述，以便应聘者知道应该期待什么和准备什么。

你是那种随时都在为找工作而感到压力的人吗？或者你是一名招聘人员，想要寻找最优秀的人才在你的公司工作？我很想听听你对这篇文章的看法！

解释线程和并发概念

原文：https://towardsdatascience.com/threads-and-concurrency-concepts-explained-2b0aa3b49b5a?source=collection_archive---------10-----------------------

我目前的工作要求我编写代码，如果代码是按顺序编写的，可能会花很多时间来执行。一个示例任务是将几个视频剪辑提取到帧中，以便用于训练我的深度学习模型。对于总持续时间为 4 小时的 96 个剪辑，序列代码将花费 1 小时用于帧提取。具有讽刺意味的是，我的电脑只有一个核心工作，而其余的闲置。这就是线程和并行处理可以介入并产生影响的地方！

不久前我在计算机系统课程中获得的关于线程和并行处理的知识现在已经帮助我显著地改进了我的代码。不用说，一旦代码被重写，运行同样的任务会快几倍。具体来说，在上面的例子中，现在只需要大约 11 分钟，因此在我的 CPU 上大约快了 5-6 倍(6 个内核/ 12 个逻辑处理器)。

那么什么是并行处理呢？粗略地说，并行处理是指你有一个很长的任务，可以分解成独立的子任务(也就是说有些任务不能分解，例如子任务可能是依赖的，因此为这些任务并行编写代码是没有用的)。然后，子任务被分布在本地计算机或网络上的处理器上，以最小化总执行时间。子任务可以是应用于相同数据的不同函数，或者是应用于数据分布的相同函数。

穿线呢？我想和你分享我在计算机系统课程中写的最后一个 zine 项目。希望这将为您提供线程和并发的概述。如果你不知道 zine 项目，请查看 wiki、这个链接中的 zines 简史，以及如何在这个链接中制作 zine。此外，因为我教授是小猫的忠实粉丝，她有时会在讲座幻灯片中与我们分享令人敬畏的图片，所以如果你在我的杂志项目中到处看到一些，不要感到惊讶:)

请找到下面的项目！

我希望你喜欢这篇文章。希望它也能启发你改进你的代码。在我的下一篇文章中，我将与您分享一些示例用例。和往常一样，请随时在下面给我反馈！

干杯，

回溯测试历史数据的 3 种方法

原文：https://towardsdatascience.com/three-approaches-for-backtesting-historical-data-aee7783b9e64?source=collection_archive---------6-----------------------

读取和处理数据，用于交易中的统计和定量分析

任何对金融市场的统计分析感兴趣的人都需要处理历史数据。需要历史数据来进行回溯测试或训练:

• 量化交易。
• 统计交易。
• 价格行动回放/演练。

每种需求都来自不同的目标。

3 个关于为什么需要回溯测试和统计分析的例子

将回溯测试和统计分析结合到交易中有很多原因，它们可能来自非常不同的交易风格和方法:

1. 日内交易者可能对收集关于在交易时段期间开仓缺口被平仓的概率的统计信息感兴趣。
2. 价格行为自主交易者可能想要重放历史数据用于训练目的，或者简单地浏览过去的交易日。
3. 一个定量/算法交易者可能想要运行模拟和回测她的算法。

虽然每种市场方法都不尽相同，但对可用数据进行计算的需求却是所有方法的共同点。

如何做到这一点的 3 种方法

有三种主要的不同方法来处理历史数据分析:

1. 可以使用像 Metatrader 或 Pro Real Time 这样的交易平台——仅举两个在散户中很有名的软件包为例。它们提供编程和回溯测试功能，并且具有与实际下单工具相同的优势。
2. 一个特定的回溯测试软件(比如 Amibroker - 仅仅是提到一个负担得起的软件)可以用来执行所有的数据分析和回溯测试。它们通常比常规的股票图表软件更擅长回溯测试和分析，因此可以被认为是更严格的方法。
3. 可以开发定制软件，最常用的两种语言是 R 和 Python 。就资源和时间而言，这是昂贵的，但也是最灵活的方法，因为它对分析数据的内容和方式没有任何限制。使用编程语言还可以提供你可能需要的所有数学库，它可以让你校准性能，如果你需要的话。

你可以找到关于哪种方法是最好的方法的强烈意见。但是，就像科技和商业中的任何事情一样，权衡是存在的，环境会推动一种解决方案优于其他解决方案。

如果你正在做算法交易，你的计划是坚持价格和标准指标，利用软件图表交易工具，如 Metatrader 可能是最好的选择，它的好处是以后更容易将实际的算法策略投入市场。

更全面的回测方法是使用特定的回测软件。这带来了额外的好处，因为您可以利用该工具的扩展分析和功能。学习曲线可能与交易/图表软件相似，你将有额外的步骤来弄清楚如何将分析转化为可操作的东西。虽然有负担得起的选择，但这也将带来额外的成本。

如果您正在进行不常见的分析，定制软件可能会节省时间和痛苦，因为现有的工具和框架将迫使您遵循某些分析/策略。

在这种情况下，编程语言的选择也是相关的。这可能是最严肃和最灵活的方法，但也是对资源和时间要求最高的方法。如果你不打算分配必要的承诺、技能、时间或资源，这肯定是一个糟糕的选择。

您也可以将它们混合使用，因为这些选项并不相互排斥。您可以使用回溯测试平台进行更常见的分析和概要分析，并使用定制软件进行非常具体的分析，这在现有框架中可能很难实现。

关于使用 Metatrader 的一些问题

由于是免费的，并且是我使用的差价合约的制图和交易软件，我认真考虑过使用 Metatrader 。

作为一个商业框架，它带来了这类产品的常见弱点:

• 学习曲线并不像供应商和产品爱好者所说的那么容易。
• 它们的初始设置通常不那么简单。获取我们的第一个直方图有时可能很有挑战性。
• 当你做标准的事情时，它们可以节省时间，但是当你受到限制时，打破常规通常要困难得多。
• 它们通常存在性能问题，因为它们被构造为模块化和分层的软件，以应对各种资产和场景。
• 存在盲点，该工具要么太复杂而无法使用，要么根本不可能实现您想要的。
• 你必须学习很多东西，但你实际上只使用了其中的一些能力。

主要的优势是你通常可以很快得到富有成效的结果，并且通常更容易得到社区的支持。

使用 Metatrader

当我对统计分析感兴趣时，我有机会和一个交易者交谈，他把这作为他工作的一部分。他对为什么使用 Metatrader 提出了很好的观点，但是他的一个评论让我想到:

Metatrader 可能是最好的方法，因为您可以实际看到数据，并且所有指标都已经在那里了。尽管如此，我一点也不喜欢它。

当有人花了足够的时间来掌握一个软件工具，但不是 100%满意时，这应该触发一个危险信号。

这位同事已经成功通过了 Metatrader 要求的学习曲线。他设法克服了商业框架的所有限制，并且他明智地利用了他过去的努力和 Metatrader 的实际优势和能力(一旦你处理了最初的学习曲线，这些都是相关的)。

我还意识到，这个人可能不愿意开发定制工具，最终目标是得到一个可以工作的交易机器人。在这种情况下， Metatrader 可能是最好的选择。

在这次谈话之后，我浏览了一下 Metatrader 的文档，并试图找出如何获得基本的统计输出。我无法理解如何轻松地进行基本和简单的分析，并且我发现没有针对数据的实际数据模型。我只是不喜欢我所看到的-这显然是基于我以前在技术框架方面的经验的个人意见。我认为，任何回溯测试工具都应该能够轻松地导入数据，并提供基本的统计数据，而只需一个忠诚的用户付出最少的努力。

我觉得 Metatrader 不适合我，因此我决定继续寻找和评估定制软件选项。虽然不是我选择的选项，但是值得一提的是 Metatrader 可能是最快最安全的快速见效的方法。

使用 Amibroker

来自 quantitative rader 的简·福克斯(Jane Fox)对定量方法很认真。她除了统计支持的算法之外不使用任何其他东西，当我在一次采访中听她讲话时，我发现她正在使用 Amibroker，并对软件包本身和使用特定回溯测试软件包的抽象概念产生了兴趣。

作为一个纯粹的量化交易者，一个特定的回溯测试软件方法可能最适合这个任务。回溯测试是她的策略的 DNA。同样相关的是，Jane 似乎交易股票的摇摆头寸，并且可能不需要处理分钟蜡烛线或进行开箱即用的分析。

在这种情况下，能够轻松地将所有相关的指标和工具整合到回溯测试中可以节省时间和金钱。

在 Metatrader 的案例中，我确信学习使用它们并不像供应商和爱好者宣传的那样简单。

开发你自己的定制软件

在本文的开头，我使用了打开缺口作为例子。我是故意提到这一点的，因为我是在参加何塞·科迪纳的一次研讨会时，对金融市场的统计分析产生了兴趣。

何塞·科迪纳是西班牙著名的交易者，他在过去的 20 年里一直使用统计分析。这个研讨会是关于 DAX 开盘缺口的，它是一个关于如何分析市场特定方面的杰出介绍。分析非常具体，以至于他使用的是定制平台(如果我没猜错的话，他使用的是定制的 C# 软件)。我对分析的速度(包括分析 DAX 期货数年的 1 分钟蜡烛线)和用于解决问题的整体分析过程感到惊讶。

我最后的想法

我主要对日内操作感兴趣，特别是短期价格行为和市场统计性质之间的相关性。如此具体，我最终决定定制软件将是我的出路。

它不会很快给你结果，但它允许你建立一个定制的和熟悉的框架来满足你的需求。如果您对可用性不挑剔(编写商业软件是一个不同的历史，但这不是我的目标)，并且如果您使用 UNIX/Linux 环境，您可以利用现有的软件包，那么像图形功能和用户界面这样的几个方面可以很容易地解决。

的确，我们需要投入更多的时间和资源，但商业工具也同样需要一个严格的环境，并且有自己的学习曲线。使用标准编程语言不会带来任何挑战，因为商业工具没有适当的文档，因为程序是众所周知和理解的，问题可以随着时间的推移而得到解决，而不会出现任何戏剧性的情况。

无论如何，在三个不同的选项中，我认为特定的回溯测试工具可能是一个好的选择，我计划在不久的将来广泛地测试一个。

免责声明:帖子中提到的产品和人物绝不是作者认可的，也不代表作者的观点。仅在出于教育或说明目的的公共专业活动/相关性的背景下提及他们。

公司级仪表板的三个常见错误

原文：https://towardsdatascience.com/three-common-mistakes-with-company-level-dashboards-88d636f1bf5d?source=collection_archive---------5-----------------------

公司级仪表板很特殊。他们掌握着所有部门和业务领域最重要的关键绩效指标(KPI)。

从首席执行官到最新的团队成员，组织中的每个人都被吸引到公司级仪表板。这使得它们不仅是一个报告工具，也是一个聚焦工具。因此，需要多加小心。

在这篇短文中，我概述了公司级仪表板的三个常见错误。

1。没有一致的设计美学

公司仪表板应该是组织数据可视化的黄金标准。这意味着:标准化的图表、一致的调色板和结构良好的布局。

然而，这很少实现。通常，我发现每个部门的仪表板都有非常不同的外观和感觉——逐步上升到不一致的公司级仪表板。

这通常是由于不同的分析师以他们自己的方式为仪表板做出贡献，并且没有一个总体的团队/个人关注用户体验。

不一致的设计意味着用户必须更加努力地提取他们需要的信息。导致混乱和误读数据。

一个设计良好的公司级仪表板在所有图表中具有一致的外观和感觉。例如，轴在标度和数字格式上都是标准化的。图表以一致的网格模式对齐。每个仪表板和每个图表的过滤器按钮都在同一个位置。标题和描述在位置和字体上都是一致的。颜色从同一个调色板标准化，允许用户轻松地从一个图表移动到下一个图表。

2.太复杂了

就在上周，我看到了一个公司级的仪表板，向用户展示了 24 个不同的指标。用户还可以选择通过原始数字或比率进行切换，有效地给了他们 48 种不同的指标来消化。这么多的信息造成了混乱。

仪表板上太多的复杂性会麻痹查看者，导致用户要么完全忽略信息，要么只关注熟悉的指标。研究告诉我们，管理者在做商业决策时会偏向于熟悉的标准和数据。

需要设计公司级别的仪表板，以便只显示关键的 KPI。深入和复杂的分析不应出现在公司层面的仪表板上。相反，它们应该只存在于部门或项目级别的仪表板中。

我见过的最好的公司级仪表板有一个顶级仪表板，上面有收入或新用户增长等 uber KPIs，每个部门还有一个仪表板，显示他们的前 6 个(或更少)KPI。

如前所述，公司级仪表板既是一种报告工具，也是一种聚焦工具，因此应该尽可能保持其简单性。

3。优化所有格式的用户体验

决策的节奏越来越快，人们期望企业领导可以在需要时通过他们的所有设备获得信息。

然而，我很少看到针对移动优化的仪表板。相反，我们仍然希望用户从桌面访问数据。这对一些人来说可能没问题，但我很少看到高层领导坐在办公桌前。他们经常从一个会议跑到另一个会议，只带着一个 iPad 或手机。

为了满足数据用户的需求，公司级仪表板需要对所有用户可用——这意味着在所有设备上；手机、台式机或 iPad。

我曾在几次与高层领导的会议中被抓到，他们有自己的 iPad，想看一些数据，但看不清楚仪表盘。这是我早期学到的一课，它教会我确保我构建的每个新仪表板都是移动友好的。

---

公司级仪表板为组织设定了数据可视化的标准。如果它们设计得很差，那么其他仪表板和报告也会设计得很差，增加了数据被错误读取或者更糟，根本不被使用的可能性。

然而，一个设计良好的公司级仪表板可以为清晰明了的报告创造条件。它通过提供一组简单、易于理解的 KPI 来帮助用户，这些 KPI 可以帮助部门集中精力并与共同的目标保持一致。它还可以通过设置预期标准来提升整个组织的数据可视化。清晰明了的报告对于用户体验和鼓励用户在决策中正确使用数据都很重要。

商业领袖应该问苹果新机器学习套件的三个问题

原文：https://towardsdatascience.com/three-questions-business-leaders-should-be-asking-about-apples-new-machine-learning-kit-6c3a6d889ec4?source=collection_archive---------10-----------------------

这家科技巨头的开源工具包可以帮助你的企业利用人工智能的最新发展

2017 年底，苹果发布了 Turi Create，这是一个开源包，可以让开发者更容易地将机器学习的力量融入他们的应用程序，从而在机器学习领域引起了轰动。该公司的声明声称，Turi Create 将允许用户“专注于任务，而不是算法。”让我们面对现实吧:对于时间和资源有限的商业领袖来说，这简直是天籁之音！

现在，世界各地的数据科学家和软件开发人员已经有了一些时间来吸收这一消息，并开始与 Turi Create 合作，让我们来分析一下它如何成为您企业的游戏规则改变者——即使您的企业仍在跟上人工智能的最新发展。

1。那么图里到底在创造什么？

Turi Create (TC)是一个机器学习工具包，让你通过插入几行代码来为你的应用程序实现定制的机器学习模型。它的优势，以及它与其他套件的区别，是它的速度，效率和独特的功能(如 GPU 加速)，这些功能要么不存在，要么处于竞争包的早期阶段。

到目前为止，TC 的主要用途分为以下几类:

• 推荐:了解用户偏好并推荐可能感兴趣的产品
• 图像分类:按类别标记图像
• 图像相似性:学习图像之间的共同模式
• 对象检测:标记图像和视频中的对象“是什么”和“在哪里”
• 活动分类:通过身体传感器和活动追踪器了解锻炼、健康和习惯
• 文本分类:将未标记的单词和文章映射到类型和主题

这仅仅是开始。展望未来，我们可以期待 TC 开发人员探索主题建模(从文档中总结和提取主题和主题)和自然语言处理(阅读和理解语言)，开辟一个全新的可能性领域。

2。好了，我了解了基本情况。那么苹果究竟在用 TC 做什么呢？

苹果收购 Turi，一年后发布 Turi Create，表明该公司正在认真建设其机器学习能力。当然，它在这个领域并不孤单，因为从谷歌这样的巨头到小型初创公司都在“大数据”领域竞争。

然而，与其他一些科技公司不同，苹果以尊重客户的数据隐私为荣，因此它的重点仍然是改善总体用户体验。以下是库比蒂诺团队目前在其产品和服务中使用 TC 的一些方式:

• 增强 Siri 预测您需求的能力
• 升级 Apple Music 以更好地为您匹配出色的新艺术家
• 为拨打您 iPhone 的新号码改进来电显示
• 预测你的卡路里消耗和一般活动
• 差分隐私允许您在不牺牲隐私或数据机密性的情况下利用人工智能

随着 Apple 继续扩大其对 TC 的使用，您将希望了解最新的应用程序，以便可以集思广益，如何为您自己的业务挑战开发类似的解决方案。最好的方法之一就是关注苹果公司定期更新的机器学习博客。

3。这些都是非常有趣的应用，但是我如何开始考虑使用 TC 来使我在 T4 的业务受益呢？

这里有一个好消息:因为 Turi Create 为你做了很多工作，你不需要开发先进的机器学习技能来利用它的前沿技术。此外，因为 TC 是开源的，所以您很可能能够找到由第三方开发人员创建的现有模型来帮助您解决业务问题。

您的任务在于创造性地将 TC 及其开源模型应用于您独特的数据集。例如，如果您的企业销售订阅服务或许可软件，TC 的广泛分类模型套件可能会确定哪些客户更有可能流失或“流失”。然后，您可以激励这些客户续订，或者确定另一种产品是否符合他们的需求。

另一个用例:如果你的公司提供许多产品或服务——并且你有关于你的客户群的数据——你可以实施 TC 的推荐系统来量化客户的兴趣，并优先考虑你营销或提供的新产品。目前，这些模型驱动着亚马逊和易贝的“推荐给你”列表、Spotify 的音乐播放列表管理和 GrubHub 的供应商聚光灯。

最后，如果您经营一家使用身体传感器收集心脏、大脑或活动指标的医疗企业，您可以使用 TC 的活动分类器从陀螺仪、恒温器等设备获取数据。该模型将预测可能发生的锻炼、慢性疾病或医疗紧急情况。除了医学领域，您还可以将模型应用于网络安全、工程和任何可以从嘈杂的数据中推断出模式的领域。

思考这些例子，您可能开始理解如何以类似的方式使用您自己的数据。既然你已经开始询问(1)Turi Create 的基础知识，(2)苹果如何使用该平台，以及(3)你如何将它创造性地应用到你的工作中，你就离搞清楚 TC 如何为你的业务打开一个新的可能性世界更近了三步。

关于我:我是 Metis 的高级数据科学家，该公司提供全职沉浸式训练营、兼职职业发展课程、在线学习和企业计划，以加速数据科学家的职业生涯。

你应该问任何人的三个问题——人工智能或机器学习

原文：https://towardsdatascience.com/three-questions-to-ask-artificial-intelligence-ai-machine-learning-6402c23ecf89?source=collection_archive---------8-----------------------

人工智能和机器学习看起来像黑匣子吗？这里有一些基本的问题，可以打开他们的盖子，以更批判性的方式接近他们。

Key take-away from Momin M. Malik: All the hyped names distract from the substance that it is just statistics.

你可能很难想到一家大型企业不谈论使用人工智能来解决他们目前面临的至少一些问题。似乎无处不在。

但这是什么呢？记者们如何报道它而不求助于 AI 将军的好莱坞图片:一台可以做任何事情的机器，从熨烫你的衬衫到奴役人类？

幸运的是，哈佛大学伯克曼克莱恩中心的数据科学博士后 Momin M. Malik 对于当你遇到一家公司或政府机构销售“由人工智能驱动”的东西时应该问什么样的关键问题有一些想法。

Momin M. Malik is a data science postdoctoral fellow at the Berkman Klein Center for Internet & Society at Harvard University,

1.型号是什么？

根据 Malik 的说法，人工智能、机器学习、预测分析和神经网络只是用来描述自 50 年代以来一直在研究的同一事物的一些名称。

但是创造一个无所不能的人工智能的想法已经被普遍抛弃，除了在好莱坞。电脑里并没有藏着有感知能力的人造生物。

听到 AI，ML 等的时候。今天它要窄得多。这只是数学。许多名字偏离了现实，这只是统计模型，每个模型都有自己的用途。

具体来说，你应该问这是不是一个决策树？

如果是的话，你可能是幸运的，因为这些可以被普通人理解。其他像“神经网络”或“随机森林”这样的模型对人们来说太复杂了，难以理解。另一方面，决策树可能非常简单，它背后的数据科学家可以带你穿过它的分支。

2.预测精度如何(以及基于什么)？

机器学习基本基于两组数据:训练数据和测试数据。你把第一组数据输入机器，教会它数据集中的相互关系，并把它放入一个模型。

假设你用了泰坦尼克号一半的乘客名单。该列表将包括乘客的年龄、性别、机票类型和票价，以及他们是死是活。那是你的训练数据。

这些数据允许你建立一个模型，如果你知道新乘客的年龄、性别、机票类型和价格，这个模型可以估计新乘客存活的可能性。

乘客名单的另一部分可用于通过查看模型预测正确结果(活着还是死了)的频率来计算模型的准确性。那将是你的测试数据。

销售“人工智能驱动”软件的人可能会吹嘘自己的预测准确率接近 100%。但是像这样的数字可以用很多方法计算，你可以" 过度拟合 "一个模型，它在你的测试数据上工作得很好，但是在现实世界中就不那么好了。

麻省理工学院媒体实验室的研究员 Joy Buolamwini 最近的一项有趣的发现正好证明了这一点。

Joy Buolamwini is also the founder of the Algorithmic Justice League. Photo by Niccolò Caranti (CC)

当她使用面部识别模型时，她发现该软件可以在她朋友和同事的脸上工作，但不能在她自己的脸上工作。直到她戴上白色面具，人工智能才注意到她。).

从那以后，她记录了多少商业面部识别算法在识别黑人女性方面如此糟糕，以至于他们还不如抛硬币来决定他们的性别，尽管他们在主要是白人(男性)的脸上测试时可能工作得很好。

具体的准确性数字可能不是非常重要，但询问它所依据的测试数据可能会揭示模型中的漏洞或通常对少数群体打击最大的固有偏见。

根据 Momin M. Malik 的说法，另一个危险信号是，如果模型使用的追溯数据只关注过去发生的事情。

模型的最佳测试是在模型建立后收集的数据。但是这种类型的测试通常不会进行。

在许多情况下，这可能是好的，但由于显而易见的原因，泰坦尼克号模型不应该被用来预测现代邮轮上的生存变化。

3.模型的目标是什么？训练数据与此相关吗？

最终，人工智能试图根据大量数据预测结果。所以你喂它什么很重要。有些可能只是噪音，隐含着不存在的意思。

泰坦尼克号乘客的头发颜色或他们名字中的字母数量可能不应该出现在存活率的模型中。

当你把所有东西都扔进模型而没有任何理论或思想支持时，这被称为“数据挖掘”。

另一个更复杂的问题是:尽管泰坦尼克号甲板上的男性溺水率比女性高得多，但这并不是因为他们的性别。这是因为规则，分配妇女和儿童的救生艇第一。但是模型不能告诉你，因为它不在数据中。

“机器学习的很多问题都是关于因果关系的。我们必须记住，预测是唯一的相关性，”这是 Momin M. Malik 的观点之一。

他在哈佛法学院的一次周四活动上展示了这些照片。你可以发电子邮件给伯克曼·克莱恩的研究员詹恩·海伦了解更多活动信息。如果你想更多地了解计算机擅长什么以及它们非常非常不擅长什么，莫明·m·马利克推荐梅雷迪思·布鲁萨德的《人工智能》。它现在在我的阅读清单上。

拉托亚·彼得森也写过“为什么记者需要了解人工智能”:

“…为了让我们真正让公众了解人工智能革命的全部潜力，我们需要在更强大的知识库上工作。”

尽管像我这样的记者应该更好地向销售或使用人工智能的人提出关键问题，但一些人呼吁对算法进行实际审计。哈佛商学院的这篇文章“为什么我们需要审计算法”说得好:

“为了金融市场和其他利益相关者的利益，公司长期以来一直被要求发布经审计的财务报表。这是因为——就像算法一样——公司的内部运作对外部的人来说就像“黑箱”一样(……)难道我们不应该让具有社会影响力的“黑箱”算法接受类似的审查吗？"

哈佛科学家建议提出以下问题:

1. 我如何最佳地建模和使用这些数据中的模式？
2. 这个数据样本能恰当地代表潜在的现实吗？
3. 基于当今现实的分布是合适的吗？

麻省理工学院媒体实验室的图灵盒项目是另一件值得关注的事情。2019 年，他们计划发布审计算法软件。

如果你已经走了这么远，感谢你的阅读。今年我在麻省理工学院做我的骑士科学新闻奖学金，在那里我花时间研究技术和新闻的关系。任何想法或想法都非常欢迎。

[## 为什么我现在在剑桥

探索开发者和记者之间的关系…

medium.com](https://medium.com/@magnusbjerg/the-journalist-developer-relationship-or-why-im-in-cambridge-right-now-318f3300bad1)

不应该使用深度学习的三个理由

原文：https://towardsdatascience.com/three-reasons-that-you-should-not-use-deep-learning-15bec517b622?source=collection_archive---------4-----------------------

Tweaking neural network hyperparamters can be tricky business. Even Peter Griffin has trouble with it!

我为学习者写了一份名为《强大的知识》的时事通讯。每一期都包含链接和最佳内容的关键课程，包括引文、书籍、文章、播客和视频。每一个人都是为了学习如何过上更明智、更快乐、更充实的生活而被挑选出来的。 在这里报名 。

深度学习在过去几年里一直是人工智能领域最热门的事情。事实上，这真的激发了科学家、政府、大公司和几乎所有人对人工智能的兴趣！这确实是一门非常酷的科学，具有潜在的巨大的实际和积极的应用价值。它被用于金融、工程、娱乐以及消费产品和服务。

但是我们真的应该到处使用它吗？每当我们做出新的东西时，我们应该自动进行深度学习吗？

有一些情况下，它真的不适合使用深度学习，以及一些为什么你会选择走另一条路的原因。让我们探索它们…

(1)它对小数据不太适用

为了实现高性能，深度网络需要非常大的数据集。我们拥有的标签 数据越多，我们的模型表现就越好。获得良好注释的数据既昂贵又耗时。雇人手动收集图像并贴上标签根本没有效率。在深度学习时代，数据无疑是你最有价值的资源。

在最新研究中取得高性能的网络，往往是在几十万甚至 几百万 样本上训练出来的。对于许多应用程序来说，这样的大型数据集并不容易获得，而且获取起来既昂贵又耗时。对于较小的数据集，回归、随机森林和 SVM 等经典 ML 算法通常优于深度网络。

(2)实践中的深度学习既困难又昂贵

深度学习仍然是一项非常前沿的技术。你肯定可以像很多人一样得到一个快速简单的解决方案，特别是使用广泛可用的 API，如 Clarifai 和谷歌的 AutoML 。但如果你想做一些相当定制的东西，这样的服务不会削减它。除非你愿意把钱花在研究上，否则你会有点局限于做一些至少和其他人做的事情稍微相似的事情…

这也很昂贵，不仅因为获取数据和计算能力所需的资源，还因为雇佣研究人员。深度学习研究现在非常热门，所以这三项费用都非常高。你最终还会有很高的开销，因为当做一些定制的事情时，你会花很多时间去尝试和破坏。

(3)深层网络不容易解释

深层网络是非常“黑箱”的，因为即使现在研究人员也没有完全理解深层网络的“内部”。他们有很高的预测能力，但解释能力较低。由于缺乏理论基础，超参数和网络设计也是一个相当大的挑战。

最近有很多工具，比如显著图和激活差异，它们对某些领域非常有效，类似于下图所示的工具。但不幸的是，它们并不能完全适用于所有应用。这些工具经过精心设计，主要是为了确保您不会使网络过度适应数据集或专注于虚假的特定要素。仍然很难解释每个特征对深度网络的整体决策的重要性。

Visualizations of features in a deep convolutional neural network

另一方面，经典的最大似然算法，如回归或随机森林，由于涉及直接的特征工程，很容易解释和理解。此外，调整超参数和改变模型设计更加简单，因为我们对数据和底层算法有了更透彻的理解。当网络的结果必须被翻译并交付给公众或非技术受众时，这些尤为重要。我们不能只说“我们卖了那支股票”或“我们在那个病人身上用了这种药”因为我们的深层网络这么说。我们需要知道原因。不幸的是，到目前为止，我们所有关于深度学习的证据都是经验性的。

喜欢学习？

在 twitter 上关注我，我会在这里发布所有最新最棒的人工智能、技术和科学！也在 LinkedIn 上和我联系吧！

对人工智能重新品牌化三思的三个理由

原文：https://towardsdatascience.com/three-reasons-to-think-twice-about-ai-re-branding-d0c8e7c11e5d?source=collection_archive---------6-----------------------

(Image details are given in footnotes)

“当我使用一个词时，”汉仆·邓普蒂用相当轻蔑的语气说，“它的意思就是我选择它的意思——不多也不少。'

“问题是，”爱丽丝说，“你能不能让单词有这么多不同的意思。” —刘易斯·卡罗尔，透过镜子

“人工智能”或简称“AI”是一个不透明的术语，没有公认的定义，范围也有争议。它通常被用来代表一种或多种不同的技术，这些技术有能力给整个世界带来实质性的、变革性的和破坏性的变化。由于它所代表的技术的影响力越来越大，它在新闻报道中的出现频率越来越高。许多组织都在争先恐后地将其纳入营销材料，并将其融入内部流程。鉴于目前围绕这个词的热议，肯定“跟上这个项目”并利用这种高水平的兴趣是有意义的吗？为什么你不想让人们看到你的公司时马上想到“人工智能”？

在科学和技术社区内，使用人工智能作为标签，几十年来一直被视为有问题的。在机器学习、数据科学、图像分析和自然语言处理等研究领域，这个术语很少被提及。也许现在是我们这些在这些领域工作的人或者对该领域的历史有更深理解的人思考我们如何与我们的雇主和利益相关者接触的时候了:特别是，我们如何围绕这些新兴技术进行有效的沟通，同时将所有这些技术聚集在一个过度宣传的品牌下的固有风险降至最低。下面，我提出了人工智能标签在科学界不受欢迎的三个相互关联的原因，并通过一个论点扩展了每个原因，即我们为什么要对这个术语在工业中的过度采用保持谨慎。

1。历史论证

不记得过去的人注定要重蹈覆辙。——乔治·桑塔亚纳

我们现在已经看到两个 AI winters 了。当这些发生时，研究资金枯竭，项目被封存，工作岗位流失，科学进步受到限制。人工智能历史上的下一个重大故障将会不同，它将不会是一个冬天，而会有更多的反弹。现在这似乎是必然的了；剩下的问题更多的是反弹会有多大。如果目前关于自动化对就业市场的影响的预测成为现实，这可能是相当大的一笔。在这种情况下，预计会看到与禽流感相关的负面宣传越来越多，就像前两个禽流感冬天一样，个人和组织会争相通过明显(1)远离这个术语来实现损害限制。如果余波达到政治层面，学术研究活动可能会受到深刻影响。面对公众压力，政治层面的反应可能会引发下意识的、而非深思熟虑的监管反应。

2.“教育公众”的论点

"任何足够先进的技术都和魔法没什么区别。"
——亚瑟·C·克拉克

对于大多数在可能被视为人工智能的领域工作的人来说，存在着精确、准确和有意义的标签。让我们使用它们。如果我们从事数据科学，就这么说吧(2)。如果我们正在开发增强现实硬件，就这么说吧。如果我们专注于自然语言处理，那么让我们明确这一点。如果我们在机器人技术中结合机器学习方法，那么让我们用那种精确度来描述它。将这些不同的技术融合在一个抽象的标签下，给原本清晰明了的技术蒙上了一层不必要的神秘面纱。如果我们希望更广泛的公众对将影响他们的发展有一个明智的理解，让我们尽可能使用准确和有意义的术语来帮助创造这种理解。

如果人工智能将成为许多人认为的巨大、包罗万象、改变生活的范式转变、引发奇点的“东西”，那么它将影响科学的每个领域和地球上每个人的生活。因此，这个术语将变得比现在更加模糊不清……包含了几乎所有的东西，意味着几乎所有的东西。会比现在更不具体，更有问题。如果大多数普通人认为人工智能是有效的“魔法”，那么科学和技术社区将在他们所面临的最重要的教育挑战中失败。

3.“语义”论点

" 机器能否思考的问题……和潜艇能否游泳的问题一样重要。 —埃德格·w·迪杰斯特拉

我们用了一个词——智力——几个世纪以来，人们一直在争论这个词的含义，我们把它纳入了一个用来定义一门科学学科的术语。因此，结果是我们创造了一个本身也无法定义的表达。由此产生的关于人工智能现在意味着什么的广泛观点(不幸的是，对许多人来说是“天网”)经常会破坏有价值的讨论或辩论。关于某种形式的机器学习方法与特定挑战的相关性的技术对话，可能会立即被类似“什么是智能？”这样的感叹词边缘化，“机器真的能变得有意识吗？”或者“机器会接管吗？”以这种方式“离题”的对话通常是无法恢复的(3)。

值得强调的是，事实上，数据科学(个人数据、隐私权)和自动化(围绕无人驾驶汽车的问题、对就业的影响)领域出现了许多至关重要的哲学和伦理问题，需要紧急考虑。这并不是说这样的讨论是不相关的，而是在某个特定领域的背景下产生或正在进行的讨论需要某种程度的关注，才能有任何价值或取得任何成果。由于人工智能不是一个特定的领域，围绕这个术语的任何对话都很合理地向任何人开放，基于他们对人工智能对他们个人代表什么的看法。因此，这一术语已成为滋生混乱和误解的温床，并经常成为不同学科和利益之间分歧的爆发点。

反论点

一旦新技术碾过你，如果你不是压路机的一部分，你就是道路的一部分。”—斯图尔特·布兰德

当然，有一种观点认为人工智能是“瓶子里的精灵”:它现在实际上是一种不可阻挡的力量，有巨大的经济动力推动它；这意味着无论我们选择什么术语，它都会对我们产生影响。所有这些毫无疑问都是真的，这些都不能使上面的论点无效。然而，“人工智能”的发展如果不承认或不参与上面提到的一些问题，可能会产生令人不安的社会后果，对未来的发展产生不利影响:

• 与企业相比，学术研究资金往往更容易受到政治因素的影响。由于人工智能的反弹，减少对人工智能或自动化研究的公共学术资助，仅仅意味着更大比例的持续科学发展将越来越多地集中在少数强大的受利润驱动的公司。
• 虽然将自己标榜为人工智能可能符合强大公司的利益，因为他们可能会经受住任何这样的反弹，但类似的市场定位(如果人工智能被视为负面)可能会在相对更大的程度上对中小型公司产生不利影响。
• 另一方面，尽管公众强烈反对人工智能，但经济力量对人工智能在行业中生存的保证可能会使行业和个人的观点两极分化(对于历史上的例子，考虑公众知识的质量差和围绕转基因和水力压裂的一般性辩论)以及日益加剧的财富不平等。对人工智能来说，出现这种情况的可能性只会加强提高公众理解的理由。如果按照惯例，将许多底层技术毫无意义地合并在一个被贬低的术语中，那么建立这种理解的尝试将会变得混乱。

艾很清楚现在是瓶子里的妖怪。这种表达一直伴随着我们。当它是正确的表达方式时，让我们使用它。如果不是这样，鉴于我们手边有大量定义明确、普遍接受、准确且有意义的术语，让我们尽可能有效地与受众沟通。

脚注:

(1)历史上，一些人工智能研究项目通过研究人员重新命名他们的工作，或者使用现有的术语，新的标签或者两者的结合(统计学，机器学习，统计学习)，度过了人工智能的冬天。)

(2)经常有人声称或观察到数据科学是一个不可定义或模糊的术语。这正日益成为一小部分个人或组织的自私论点，并且严重夸大了事实。数据科学领域的大多数人都非常清楚自己在做什么。然而，数据科学目前是一个热门术语，因此它很容易被滥用，例如在寻求项目资金时，或被寻求就业的个人滥用。它可以服务于那些在数据科学边缘工作或超越数据科学边缘的人的利益，尝试扩展该术语的含义，以便他们自己的活动适合它。

(3)希望我已经阐明，这不是一个反对广泛辩论的论点，也不是反对我们当前科学发展背景下的一般哲学问题的论点。也不是反对讨论智力或意识的意义。

图片(从左到右):
-两个反对增加机械化的人看到机器弄坏了一台提花织机——维基百科。
——“总督”郁金香，在 1637 年“郁金香狂热”崩溃的高峰期，其球茎售价约为普通房屋价格的五倍——维基百科。
-用注射器注射西红柿的图像是一种常见的图形，用于表示对转基因生物的担忧——exposingtruth.com。

展示数据洞察力的顶级技巧

原文：https://towardsdatascience.com/three-tips-for-persuading-with-data-52d1e51f45ed?source=collection_archive---------9-----------------------

更有效、更容易理解

对于数据分析师来说，没有什么比揭示真实公司问题的数据更令人兴奋的了。然而，向管理层提出见解却一事无成是完全令人泄气的。

你必须考虑它是我的信息，我的语言，还是我的技术。这里有一些解决这个问题的方法。

不要用你的才华让他们过于耀眼

一位营销副总裁透露，在他明白如何与面前的观众交谈之前，他没有说服力。这位主管有统计学博士学位，所以可以说他了解数据分析。

在他的第一份工作中，他在向管理人员展示他的分析时并不成功。最后，另一位经理透露，这些演示具有如此先进的分析能力；他觉得自己很蠢！他经常不理解正在展示的内容，并且害怕在别人面前提问。

陈述让听众觉得自己很蠢——你认为他之后听了多少？哎哟！在他努力用这些精彩的见解使人眼花缭乱的时候，他没有考虑到观众。向企业领导演示时，考虑需要多少分析来证明你的观点。也许谈论标准差和 t 检验是过多的细节或错误层次的细节。这取决于公司文化。

很多时候，经理想要更高层次的细节。他们相信你已经做了功课。如果您担心房间里的一些专家需要详细的分析，那么请预测他们的问题！如果有帮助的话，添加一些备份幻灯片。

技巧 1:利用数据洞察力进行说服的能力必须与你的受众的需求和数据悟性相匹配。

人们想帮助别人

在最近的一次会议上，一名与会者在吃早餐时评论说，他知道他的学校可以从第三名上升到全州第一名。不一会儿，他就快速地说出了 15 个统计数据，这让我确信这个目标是可以实现的。

当想到这个目标所涉及的所有工作时，我觉得这是一个巨大的挑战。在试图吃一天前的丹麦面包时，我没有一个简单的答案。

他无法让他的同事听他的。我怀疑他遇到了与上一个故事中的绅士相似的问题。他告诉老师们，如果他们能提高一个标准差，一切都会变得完美。

一个标准差之外…这难道不是数据怪胎的话吗？

在讨论了这个问题后，我建议他考虑将人加入到数据中，因为观众可能更倾向于帮助单个学生变得比整个学区更好。人们喜欢帮助别人，教育者也想帮助学生，对吗？我得意洋洋地走开了，享受着新鲜的咖啡。

技巧 2:了解你的受众！一些观众更容易被情感上的原因所说服，而不是被看似无用的崇高管理目标所说服。

较小的问题更容易解决

后来，当我与另一位与会者交谈时，他提供了一些额外的见解。有时学校排名第一的位置可能接近 50 名学生的进步。这一想法缩小了问题的规模。

而不是“我们如何让整个学区成为第一？”可以是“如何帮助 50 名学生在学术生涯中脱颖而出？”然后达到我们的目标？

你可以举出这些学生的具体例子，了解每种情况下需要什么。这 50 个学生里面可能有一个模式！也许该团队能够找到经济高效的解决方案，推动学区向前发展。管理人员达到了他们的目标，教育者做着他们喜欢的事情——教学生。

当你和更少的观众一起工作时，你会发现更容易和他们联系，激发他们的热情，从而带来组织需要的改变。许多专家强调从小项目开始并取得成功的重要性。这自然会吸引更多人关注你的工作，包括你的管理层。

技巧三:成就是否比你想象的更近？较小的问题解决起来更自然，需要的帮助也更少。更容易获得认同！

应对机器崛起的三种方式

原文：https://towardsdatascience.com/three-ways-to-react-to-the-rise-of-the-machines-fd43db7b2c85?source=collection_archive---------7-----------------------

该系统于 1997 年 8 月 4 日上线。战略防御中不包括人类决策。天网开始以几何速度学习。它在东部时间 8 月 29 日凌晨 2 点 14 分有了自我意识。在恐慌中，他们试图拔掉插头。”

科幻迷可能会记得这句话来自终结者 2:审判日。作为一个孩子，它描绘的场景完全吓坏了我。这不是第一部机器变得有自我意识的电影。斯坦利·库布里克的 2001:太空漫游以哈尔 9000 平静、单调但令人毛骨悚然的话语而闻名:“对不起戴夫，恐怕我做不到”。

20 世纪 70-90 年代的电影和小说不乏描述数字化、计算机化技术转化为人类意识状态的场景。直到不久前，人工智能还被视为计算机化学习的快速发展，这将导致向智能生命形式的突然转变。一项技术能够自我意识并不是一个不现实的终结游戏。例如，这个视频表明，技术能够通过一种自我意识的“国王的智者”测试。

从今天的镜头来看，我们应该是既欣慰又担忧的。我们应该松一口气，因为《T4》中的天网事件并没有发生。我们仍然没有达到真正取代人脑复杂性的人工智能水平。毫无疑问，人工智能已经走了很长的路，但它目前只能可靠地取代人类做出的最简单、最可预测的决定。即使机器能够在 Jeopardy 或 Go 中获胜，也是因为它们可以在任何给定的时间点处理比人类更复杂的场景，但只能在定义的可能性宇宙内。最初的想法仍然是机器人无法企及的。

不过，我们应该感到担心，因为它正以比任何人预测的更普遍的方式发展。人工智能并不像几十年前预期的那样是政府或军事组织的专有财产。它属于我们所有人。它正在世界各个角落成长和发展。它受制于我们改进技术的本能冲动，这可能会使它势不可挡。没有单个芯片需要销毁，就像《终结者》中的那样。在这种民主化和无孔不入的形式下，也许没有什么能阻止 AI 的成长。许多人会说，也没有什么能控制它。

我们为什么要担心 AI？

虽然 Alexa 变得有自我意识并订购大量由汤姆·塞立克主演的电影的可能性很小(我听说她是一个粉丝)，但我们应该出于非常不同的原因担心人工智能——经济原因。历史上曾有一段时期，普通工人确实在技术发展中失败了，而我们可能正处于这样一个时期的开端——而且是一个漫长的时期。

历史上只有一个时期能与我们自上世纪 70 年代以来经历的技术发展的大规模增长相媲美:工业革命，尤其是在英国和美国。工业革命推动了巨大的社会和经济变革，导致手工工作被机器取代，人口大规模流动，人口财富分配的中断，以及全球贸易的永久性变化。

NYU 大学的鲍勃·艾伦教授是一位专家经济学家，他经常从历史对比中寻找对当今问题的见解。在我参加的 Bob 最近的一次演讲中，他展示了一些非常详细的分析结果，这些分析是他对工业革命和过去 30-40 年间的生产率和工资进行的。回顾英国 1770 年至 1890 年的工业变革时期，鲍勃研究了其对生产率增长和实际工资增长(即基于收入的基本商品的可负担性)的影响。这张图表总结了他的发现:

模式很明显。在工业革命的前 60 年，投资者以牺牲工人为代价获得了利益。只是从 1830 年开始(鲍勃认为，所有主要的机械化变革都已完成)，工资才开始随着生产率的增长而变动。鲍勃的分析也显示了美国类似的结果。

从今天的情况来看，两者有很强的相似性。自 20 世纪 70 年代以来，我们一直处于一个类似的时期，工人们正在失去他们从技术发展中获得的那份好处。下图显示了美国长期趋势的发展:

从 1980 年到今天这段时间尤其令人担忧。我们是否应该像工业革命那样，期待工资水平很快会赶上来？鲍勃·艾伦对此持悲观态度，我能理解为什么。我们才刚刚处于人工智能革命的开端，迄今为止只有一小部分工作受到了影响，这种破坏还要持续几十年。普通工人可能需要蹲下来做长期工作。

我们的三个选择

我们没有一个带着奥地利-美国口音的机器人可以及时送回去解决这种破坏正在造成的新的不平等，但我们能做些什么来控制它吗？我不想在这里假装有任何答案，但我经常听到关于这个问题的三种观点:

1. 干预主义:要求政策干预的呼声越来越高。在我最近参加的一次演讲中，著名经济学家罗伯特斯基德尔斯基勋爵(Lord Robert Skidelsky)的一句话让我记忆犹新:“现在，即使是技术乌托邦主义者也不得不相信政策干预”。如果我们认为它对人们的福祉有害或需要工作，是否有可能减缓甚至停止 AI？这需要什么样的政策或国际机构才能有效？
2. 自由放任:我敢说，我听到的大多数观点都属于这一类。让我们乘风破浪，期待最好的结果。这是由什么驱动的？一种我们无法实际控制或预测将会发生什么的感觉？人们对人工智能的兴趣如此之深，以至于愿意拿自己的经济福祉冒险，看看它最终会走向何方？一种信念，即使不是在我们的有生之年，事情最终总会在经济上达到平衡？
3. 用人工智能对抗人工智能:也许这个领域最有趣的工作是试图预测一些威胁人们经济福祉的可能发展，以及使用人工智能方法来应对这些威胁的可能性。麦肯锡全球研究所的研究帮助我们更好地理解不同的工作是如何“自动化”的，而像 Doyne Farmer 这样的学术工作有望更好地揭示当机器人抢走他们的工作时，某些人类技能集将如何“可移植”。

与此同时，当我们下定决心的时候，在世界的某个地方，另一种技术正在被迭代，这种技术将在未来几年里或好或坏地改变我们的生活。

时间不多了。你会选择哪个选项？

参见 此处 了解鲍勃·艾伦研究的更多细节。

最初我是一名纯粹的数学家，后来我成为了一名心理计量学家和数据科学家。我热衷于将所有这些学科的严谨性应用到复杂的人的问题上。我也是一个编码极客和日本 RPG 的超级粉丝。在LinkedIn或Twitter上找我。

收拾熊猫

原文：https://towardsdatascience.com/tidying-up-pandas-4572bfa38776?source=collection_archive---------4-----------------------

对于那些使用熊猫模块的人来说，你会很快意识到的第一件事是，做任何事情都有不止一种方法。

本文的目的是展示我们如何通过从 R 的dplyr和tidyverse库汲取灵感来限制这种情况。

由于来自学术界，R 通常是我周围人的通用语言(计算生物学/生物信息学或统计学)。和他们一样，我迷上了著名的tidyverse元包，它包括dplyr(之前的plyr、ply(e)r)、lubridate(时间序列)和tidyr。

PS。在我写这篇文章的时候，我意识到这不仅仅是 *tidyverse* ，而是整个 R 生态系统，我已经开始喜欢上它了，同时也喜欢上了宏基因组学和计算生物学。

为了方便从 R 起步的人，pandas是 python 的 dataframe 模块。像 H2Oai 的数据表这样的其他包是存在的，它在很大程度上受到 R 自己的数据表库的启发。

在他的演讲中，Hadley Wickham(dplyr 包的创建者)他提到我们真正需要的表格操作只是一些函数:

• 过滤器
• 挑选
• 安排
• 使突变
• group_by
• 概括
• 合并

然而，我认为你需要比以上更多的东西。

比如知道 R 的apply函数族，会有很大帮助。或者像summary或str这样的汇总统计函数，尽管现在我大多使用skimr::skim进行汇总。

skim(iris) 
## Skim summary statistics 
## n obs: 150  
## n variables: 5  
##  
## ── Variable type:factor ────────────────────────────────────────────────────────────────────────────────────────────────── 
## variable missing complete n n_unique top_counts ordered 
## Species 0 150 150 3 set: 50, ver: 50, vir: 50, NA: 0 FALSE 
##  
*## ── Variable type:numeric ─────────────────────────────────────────────────────────────────────────────────────────────────*
*##      variable missing complete   n mean   sd  p0 p25  p50 p75 p100     hist*
*##  Petal.Length       0      150 150 3.76 1.77 1   1.6 4.35 5.1  6.9 ▇▁▁▂▅▅▃▁*
*##   Petal.Width       0      150 150 1.2  0.76 0.1 0.3 1.3  1.8  2.5 ▇▁▁▅▃▃▂▂*
*##  Sepal.Length       0      150 150 5.84 0.83 4.3 5.1 5.8  6.4  7.9 ▂▇▅▇▆▅▂▂*
*##   Sepal.Width       0      150 150 3.06 0.44 2   2.8 3    3.3  4.4 ▁▂▅▇▃▂▁▁*

事实上，skimr 的输出看起来真的很像 Google 的 Facets。正如您所看到的，打印基本的分布统计和直方图。

因此，在这篇文章中，我将尽力演示tidyverse词汇表与pandas DataFrame 方法的一对一映射。

为了演示，我们将使用著名的鸢尾花数据集。

# python 
import seaborn as sns 
iris = sns.load_data("iris")

我选择使用 seaborn 导入 iris 数据集，而不是使用 sklearn 的datasets.load_iris，这是因为后者将数据集导入为 numpy 数组，而不是 pandas DataFrames。

在导入一个表之后，我做的第一件事就是在 data.frame 上运行str函数(不完全等同于pd.DataFrame.info()方法)并检查是否有 NAs。

# R
str(iris)
> 'data.frame':   150 obs. of  5 variables:$ Sepal.Length: num  5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...$ Sepal.Width : num  3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...$ Petal.Length: num  1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...$ Petal.Width : num  0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...$ Species     : Factor w/ 3 levels "setosa","versicolor",..: 1 1 1 1 1 1 1 1 1 1 ...# python 
iris.info(null_counts=True)
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 5 columns):
sepal_length    150 non-null float64
sepal_width     150 non-null float64
petal_length    150 non-null float64
petal_width     150 non-null float64
species         150 non-null object
dtypes: float64(4), object(1)
memory usage: 5.9+ KB

过滤器

现在，进入下一个功能。与 R 的filter最接近的方法是pd.query方法。在下面的例子中，截止值已经被定义为一个变量。

# R
iris %>% filter(sepal.width > cutoff)# python
## Method 1: 
iris[iris.sepal_width > cutoff]## Method 2:
iris.query("sepal_width > @cutoff”)

在 python 中有两种方法可以做到这一点。

方法 1 可能是你会发现大多数 python 爱好者使用的方法。

不过在我看来，pd.DataFrame.query()和dplyr::filter()的映射更为紧密。

使用 query 的一个缺点是…遵循 *pep8* 约定的 linters，比如 *flake8* ，会抱怨 *cutoff* 变量没有被使用，尽管它已经被声明: *sepal_width > @cutoff* 。这是因为 linter 无法识别在查询的引用参数中使用的 *cutoff* 变量。

注意:令人惊讶的是，filter 在 pySpark 中有所回报。😃

# python (pyspark)type(flights) 
pyspark.sql.dataframe.DataFrame# filters flights which are > 1000 miles long flights.filter('distance > 1000')

挑选

这让人想起 SQL 的select关键字，它允许您选择列。

# R 
iris %>% select(sepal.width, sepal.length)# Python 
iris.loc[:, [["sepal_width", "sepal_length"]]]

最初，我认为下面的df[[’col1’, 'col2’]]模式会是一个很好的地图。但是我很快意识到我不能做类似于select的柱状切片。

# R 
iris %>% select(Sepal.Length:Petal.Width)# Python  
iris.loc[:, "sepal_length":"petal_width"]

关于loc方法需要注意的一点是，当选择只有一行时，它可能返回一个序列而不是一个数据帧。因此，您必须对感兴趣的行进行切片，以便输出返回一个数据帧。

# Pythoniris.loc[1, :]  # returns a Series 
iris.loc[[1],:] # slicing returns a dataframe

但是select真正令人惊叹的是，它能够让取消选择列，这是loc方法中所没有的。

你必须使用.drop()方法。

# R
df %>>% select(-col1) # Python
df.drop(columns=["col1"])

注意我必须添加参数 *columns* ，因为 drop 不仅可以用于删除列，该方法还可以基于它们的索引删除行。

和filter一样，select也用在 pySpark 上！

# python (pySpark)# shows the column xyz of the spark dataframe.
df.select("xyz").show()# alternative  
df.select(df.xyz)

安排

通过 arrange 函数，可以按照特定的列对表格进行排序。

# R 
df %>% arrange(desc(col1))# Python 
df.sort_values(by="col1", ascending=False) 
# everything is reversed in python fml.

使突变

dplyr的mutate实际上是 R 的apply的升级版。

注意 : R 的许多其他应用如 *mapply* 和 *lapply* 但是可以在很大程度上被 purrr 库中的新函数所取代。

# R 
df %>% mutate(new = something / col2, newcol = col+1 )# Python 
iris.assign(new = iris.sepal_width / iris.sepal, 
newcol = lambda x: x["col"] + 1 )

默认情况下，tidyverse的mutate函数获取整列并对其进行矢量化操作。如果你想逐行应用这个函数，你必须将rowwise和mutate连接起来。

# R
# my_function() does not take vectorised input of the entire column 
# this will failiris %>% rowwise %>% mutate(new_column = my_function(sepal.width, sepal.length))

为了使用.assign方法达到同样的效果，您应该在函数中嵌套一个apply。

# Pythondef do_something(col): #set_trace() if re.search(r".*(osa)$", col): value = "is_setosa" else: value = "not_setosa" return value iris = iris.assign( transformed_species = lambda df: df.species.apply(do_something) 
)

如果你很懒，你可以把两个匿名函数链接在一起。

# Pythoniris = iris.assign( transformed_species = lambda df: df.species.apply(do_something_string))

绕道:申请

来自 R 的apply帮助文档:

apply(X, MARGIN, FUN, ...)

其中MARGIN的值对于(行、列)取1或2，即。如果您想应用于每一行，您可以将轴设置为0。

然而，在 pandas axis 中，什么值(索引 I 或列 j)将用于应用函数输入参数的索引。

be 使用的0是指数据帧的索引，轴1是指列。

因此，如果你想进行行操作，你可以设置轴为 0。

# Rdf %>% apply(0, function(row){ ... do some compute ... })

自从 *plyr* 和后来的 *dplyr.*之后就很少这样做了

然而在熊猫身上没有plyr。因此，如果您想要进行逐行操作，我们必须返回使用 apply，但是，轴现在是 1 而不是 0。我最初发现这非常令人困惑。原因是因为row实际上只是一个pandas.Series，它的索引是父 p 和 as。DataFame 的列。因此，在本例中，轴指的是将哪个轴设置为索引。

# pythoniris.apply(lambda row: do_something(row), axis=1)

有趣的是，我在 R 中没有使用的模式是在列上使用 apply，在这个例子中是pandas.Series对象。

# pythoniris.sepal_width.apply(lambda x: x**2) # if you want a fancy progress bar, you could use the tqdm functioniris.sepal_width.apply_progress(lambda x: x**2) # If u need parallel apply # this works with dask underneath  import swifteriris.sepal_width.swifter.apply(lambda x : x**2)

在 R 中，有一个常见的习惯用法，我经常在groupby的平行版本中使用，如下所示:

# Runique_list %>% 
lapply(function(x){ ... df %>% filter(col == x) %>% do_something() # do something to the subset ... 
}) %>% do.call(rbind,.)

如果你想要一个平行版本，你只需要把lapply改成mclapply。

此外，还有来自 r 的parallel / snow图书馆的mclapply

# Rncores = 10 # the number of cores 
unique_list %>% mclapply(function(x){ ... df %>% filter(col == x) %>% do_something() # do something to the subset ... 
}, mc.cores=ncores) %>% 
do.call(rbind,.)

另外，在 PySpark 中，您可以将整个表分成几个分区，并行地进行操作。

# Python (pySpark)(dd.from_pandas(my_df,npartitions=nCores).map_partitions(lambda df : df.apply( lambda x : nearest_street(x.lat,x.lon),axis=1)).compute(get=get) # imports at the end)

为了达到同样的目的，我们可以使用dask，或者使用swiftapply模块的更高级别的包装器。

# Python# you can easily vectorise the example using by adding the `swift` method before `.apply` 
series.swift.apply()

分组依据

pandas 中的.groupby方法相当于 R 函数dplyr::group_by返回一个DataFrameGroupBy对象。

tidy verse 中有 *ungroup* 函数对分组后的数据帧进行解组，为了达到同样的效果，不存在一对一的映射函数。

一种方式是完成*groupby*->-*apply*(两步法)和送料应用同一个功能 *apply(lambda x: x)* 。这是一个身份函数。

概括

在熊猫中，summarise功能的对等物是aggregate，缩写为agg功能。你必须把这个和groupby结合起来，所以这又是一个类似的两步groupby - > agg转换。

# R r_mt = mtcars %>% mutate(model = rownames(mtcars)) %>% select(cyl, model, hp, drat) %>% filter(cyl < 8) %>% group_by(cyl) %>% summarise( hp_mean = mean(hp),drat_mean = mean(drat), drat_std = sd(drat), diff = max(drat) - min(drat) ) %>% arrange(drat_mean) %>% as.data.frame

用 Python 编写的相同系列的转换如下:

# Python def transform1(x): return max(x)-min(x) def transform2(x): return max(x)+5 py_mt = ( mtcars.loc[:,["cyl", "model", "hp", "drat"]] #select      .query("cyl < 8") #filter .groupby("cyl") #group_by .agg({ #summarise, agg is an abbreviation of aggregation     'hp':'mean', 'drat':['mean', 'std', transform1, transform2] # hmmmmmm}).sort_values(by=[("drat", "mean")]) 
# multindex sort (unique to pandas) ) py_mt

合并

R 本身支持merge函数，类似地，熊猫也有pd.merge函数。

# R df1 %>% merge(df2, by="common_column")# Pythondf1.merge(df2, how="inner", on="common_column")

除了merge功能，还有join功能。dplyr 中还存在其他连接，例如left_join、right_join、inner_join和anti_join.

原地

在 R 中有一个复合赋值管道操作符%<>%，它类似于一些 pandas 函数中的inplace=True参数，但不是所有的。:(很明显，熊猫将会完全取代……

排除故障

在 R 中，我们有browser()函数。

请注意，这不适用于 Jupyter 的 IRKernel。

# R 
unique(iris$species) %>% lapply(function(s){ browser() iris %>% filter(species == s) ....})

它会让你进入功能，如果你想做一些调试，这是非常有用的。

在 Python 中，有set_trace函数。

# Pythonfrom IPython.core.debugger import set_trace(iris.groupby("species") .apply(lambda groupedDF: set_trace())
) 

最后但同样重要的是，如果你真的需要使用一些 R 函数，你总是可以依赖于rpy2包。对我来说，我主要用这个来绘图。ggplot2 ftw！抱歉 matplotlib 和 seaborn

%load_ext rpy2.ipython

有时使用 r 安装 r 包会有问题。你可以运行

conda install -r r r-tidyverse r-ggplot

此后，您可以在同一个 Jupyter 笔记本中交替使用 R 和 Python。

%%R -i python_df -o transformed_dftransformed_df = python_df %>% select(-some_columns) %>% mutate(newcol = somecol * 2)

注: *%%R* 是细胞魔法， *%R* 是线条魔法。这意味着如果你有一个多行 r 函数/代码，使用前者。

如果你需要输出像一个正常的熊猫数据帧打印，你可以使用百分之一魔术

%R some_dataFrame %>% skim

迂回:省略

在 R 中，您可以做的一个巧妙的技巧是将参数传递给内部函数，而不必在外部函数的函数签名中定义它们。

# R 
#' Simple function which takes two parameters `one` and `two` and elipisis `...`,somefunction = function(one, two, ...){ three = one + two sometwo = function(x, four){ x + four } sometwo(three, ...) # four exists within the elipisis  
} 
# because of the elipisis, we can pass as many parameters as we we want. the extras will be stored in the elipisissomefunction(one=2, two=3, four=5, name="wesley")

在 python 中，**kwargs代替了...。下面是对其工作原理的解释。

说明

首先，双星号**被称为解包操作符(它被放在函数签名之前，例如kwargs，所以合起来看起来像**kwargs)。

约定是将该变量命名为 *kwargs* (代表keyworded arguments)但它可以被命名为任何名称。

大多数描述 unpack 操作符的文章都会以这个解释开始:字典被用来传递函数的参数。

# Pythonadictionary = { 'first' : 1, 'second': 2 } 
def some_function(first, second): return first + second 
some_function(**adictionary) # which gives 3

但是你也可以改变这一点，将**kwargs设置为一个函数签名。这样做可以让您在调用函数时键入任意数量的函数签名。

签名-值对被包装到一个名为kwargs的字典中，该字典可以在函数内部访问。

# Python 
# dummy function which prints `kwargs`def some_function (**kwargs): print(kwargs) 
some_function(first=1, second=2)

前两种情况并不排斥，你实际上可以_*它们混合在一起。即。有署名的还有一个**kwargs。*

*# Python 
adictionary = { 'first' : 1,'second': 2,'useless_value' : "wesley"
} def some_function(first, second, **kwargs): print(kwargs) return first + secondsome_function(**adictionary)*

输出将是:{'useless_value': 'wesley'}

它允许 python 函数接受您提供的任意多的函数签名。将直接使用在函数声明期间已经定义的那些。没有出现在其中的可以从 kwargs 中访问。

通过将**kwargs作为内部函数中的一个参数，您基本上是将字典展开到函数 params 中。

*# Pythondef somefunction(one, two, **kwargs): print(f"outer function:\n\t{kwargs}") three = one + two 
def sometwo(x, four): print(f"inner function: \n\t{kwargs}") return x + four returnsometwo(three, **kwargs) 
somefunction(one=2, two=3, four=5, name=“wesley”)*

外部功能:{“four":5, “name":"wesley"}。

里面里面夸尔格斯:{“name":"jw"}.

现在让我们将它与原始的 R 省略号进行比较:

*# R #' Simple function which takes two parameters `one` and `two` and elipisis `...`,somefunction = function(one, two, ...){ three = one + two sometwo = function(x, four){ x + four } sometwo(three, ...) # four exists within the elipisis  
} 
# because of the elipisis, we can pass as many parameters as we we want. the extras will be stored in the elipisissomefunction(one=2, two=3, four=5, name="wesley")*

结论

虽然在熊猫身上做同样的事情有很多方法，比 dplyr (tidyverse)规定的方法更多。我希望内部 R 用户在用 pandas 编码时标准化代码库，提高代码可读性。

此外，来到 Honestbee 后，让我措手不及的是所需的 SQL 数量。

这一点我感觉是来到工业界对学术界最大的偏离。公司中的数据以数据库/数据湖(不太常见)和数据流的形式有序存储。不再有一个大的平面数据文件。

虽然有 dbplyr 包，但我强烈建议您花点时间熟悉一下 SQL，尤其是查询 RDS 和 Redshift 的 postgreSQL。

更新:

Sparklyr 对 rstudio 的人们竖起了大拇指

我们已经完成了将tidyverse动词映射到熊猫的尝试，希望你发现这是有益的！回头见！

原载于 2018 年 12 月 16 日ethe Leon . github . io。

剩余寿命——使用 Flask 和 PythonAnywhere 在 Web 上模拟预期寿命并制作原型

原文：https://towardsdatascience.com/time-left-to-live-modeling-life-expectancy-and-prototyping-it-on-the-web-with-flask-and-68e3a8fa0fe4?source=collection_archive---------9-----------------------

Source: Lucas Amunategui

对预期寿命建模显然属于统计学领域，但当你以互动和教育的形式将它扩展到互联网时，它就变成了应用数据科学。在本演练中，我们将把一个简单的线性回归模型与 Flask web 应用程序联系起来，实质上是将一个等式转换成一个交互式工具，整个世界都可以从中进行游戏和学习。

让我们谈谈预期寿命。虽然我认为这个话题是一个重要的认知工具，但我先向那些觉得它令人沮丧的人道歉。它和那些互动银行工具一起提醒你，你还没有多少钱可以退休。

我们将使用 PythonAnywhere.com 的来安装这个模型，这是一个易于使用的免费实验网络服务平台。我们还将使用有趣的图形和简单的语言，以确保它切中要点，引人入胜。你可以在 TimeLeftToLive.com的查看完成版。

Traditional output versus fun & Interactive

这是一个令人惊讶的简单模型，使用顶级统计学家收集的可靠数据来构建。两个最重要的消息来源是世界卫生组织(世卫组织)和中央情报局。这里我们将使用世界卫生组织(世卫组织)全球健康观察站的数据。

死亡率数据

我们将使用“出生时的预期寿命(岁)”和“60 岁时的预期寿命(岁)”的综合数据集。这将为我们的线性回归提供两个点，我们可以很容易地从中提取任何其他年龄。还是那句话，对此不能全信！这些只是平均水平，预期寿命每天都在提高！从世卫组织网站:

简单线性回归和预测预期寿命

线性回归模型试图用直线来解释两个或多个变量之间的关系。 ReliaSoft 的实验设计和分析参考

我们将使用 scipy.stats 包进行线性回归。让我们看一个简单的例子来说明如何使用线性回归进行预测。我们创建了两个预期寿命的虚拟数据集，一个是新生儿的，另一个是 60 岁的:

**import pandas as pd
import matplotlib.pyplot as plt# create fictitious data set 
simple_life_dataset = pd.DataFrame({'Age':[0, 60], 'Life Expectancy':[90, 30]})
simple_life_dataset.head()**

Life expectancy at 0 and 60 years old

现在我们将这些数据输入到stats . Lin regressive函数中。我们将只使用它的两个输出，斜率和截距。这两个值和 y = mx+b 的直线方程，将为我们提供估算任何年龄预期寿命所需的一切。

**import numpy as np
from scipy import stats
slope, intercept, r_value, p_value, std_err = stats.linregress(simple_life_dataset['Age'],simple_life_dataset['Life Expectancy'])
print('intercept: ', intercept)
print('slope: ', slope)('intercept: ', 90.0)
('slope: ', -1.0)**

那么，根据我们虚构的数据，一个 20 岁的人还能活多少年？我们将 stats . Lin regressive 的输出应用于 y = mx+b 线方程:

预期寿命估计值=斜率年龄+截距*

**np.ceil(slope * 20 + intercept)70.0**

我们还有 70 年的寿命。如果我们把虚构的数据集和新的估计值一起画出来:

**fig, axes = plt.subplots(figsize=(5,5))
x = [0,20,60]
y = [90, 70, 30]
axes.plot(x,y, color='blue', linestyle='--', marker='o')
fig.suptitle('Life Expectancy')
axes.set_xlabel('age')
axes.set_xlim([-5,100])
axes.set_ylabel('life_expectancy')
axes.set_ylim([0,100])
plt.show()**

The linear relationship between age and life expectancy according to our fictitious data

世卫组织死亡率数据

我们下载真实数据保存到本地吧。然后，让我们进行与上面完全相同的练习:

**# load WHO longevity data
# http://apps.who.int/gho/data/node.main.688
who_list = pd.read_csv('http://apps.who.int/gho/athena/data/GHO/WHOSIS_000001,WHOSIS_000015?filter=COUNTRY:*&x-sideaxis=COUNTRY;YEAR&x-topaxis=GHO;SEX&profile=verbose&format=csv')# save a local copy of the data set for our Flask prototype later on
who_list.to_csv('WHOSIS_000001,WHOSIS_000015.csv')# Keep only useful features fix case display of country text
who_list = who_list[['GHO (DISPLAY)', 'YEAR (CODE)' , 'COUNTRY (DISPLAY)', 'SEX (DISPLAY)', 'Numeric']]
who_list['COUNTRY (DISPLAY)'] = [ctry.title() for ctry in who_list['COUNTRY (DISPLAY)'].values]# print a few rows
who_list[who_list['COUNTRY (DISPLAY)']=='France'].head(10)**

WHO longevity data for France

我是一个 49 岁的美国人，让我们预测一下我还能活多少年(yikes！).首先让我们看看数据，这真的很有趣。根据最新数据，美国新生儿男性的预期寿命是 77 岁，而根据最新数据，美国 60 岁男性的预期寿命是 22 岁，总共是 82 岁，给出了什么？这是统计学的复杂性之一，对一个 60 岁的人取平均值意味着这个人已经活了 60 年，这被称为生存偏差。这对于我们来说意味着，这个模型对于接近于 0 的人来说有点悲观，对于接近于 60 的人来说有点乐观。

**country = 'United States Of America'
sex = 'Male'# pull latest entries for birth and 60 years for a country and gender
sub_set = who_list[who_list['COUNTRY (DISPLAY)'].str.startswith(country, na=False)]
sub_set = sub_set[sub_set['SEX (DISPLAY)'] == sex]# sort by year in descending order to work with the latest read
sub_set = sub_set.sort_values('YEAR (CODE)', ascending=False)
sub_set_birth = sub_set[sub_set['GHO (DISPLAY)'] == 'Life expectancy at birth (years)'] 
sub_set_60 = sub_set[sub_set['GHO (DISPLAY)'] == 'Life expectancy at age 60 (years)'] print('sub_set_birth:')
print(sub_set_birth.head(5))
print('sub_set_60:')
print(sub_set_60.head(5))sub_set_birth: GHO (DISPLAY)  YEAR (CODE)  \
16046  Life expectancy at birth (years)         2015   
17532  Life expectancy at birth (years)         2014   
15326  Life expectancy at birth (years)         2013   
12318  Life expectancy at birth (years)         2012   
17531  Life expectancy at birth (years)         2011COUNTRY (DISPLAY) SEX (DISPLAY)   Numeric  
16046  United States Of America          Male  76.93852  
17532  United States Of America          Male  76.76836  
15326  United States Of America          Male  76.45519  
12318  United States Of America          Male  76.43168  
17531  United States Of America          Male  76.29261 sub_set_60: GHO (DISPLAY)  YEAR (CODE)  \
7481   Life expectancy at age 60 (years)         2015   
7900   Life expectancy at age 60 (years)         2014   
9935   Life expectancy at age 60 (years)         2013   
16044  Life expectancy at age 60 (years)         2012   
16211  Life expectancy at age 60 (years)         2011              COUNTRY (DISPLAY) SEX (DISPLAY)   Numeric  
7481   United States Of America          Male  22.07029  
7900   United States Of America          Male  21.95811  
9935   United States Of America          Male  21.72074  
16044  United States Of America          Male  21.72548  
16211  United States Of America          Male  21.61596**

让我们从世卫组织数据集中提取两个最新的数据点，并绘制出来:

**# create data set with both points as shown in first example
lf_at_birth = sub_set_birth['Numeric'].values[0]
lf_at_60 = sub_set_60['Numeric'].values[0]# let's organize our data and plot
age = [0,60]
life_expectancy = [lf_at_birth, lf_at_60]fig, axes = plt.subplots(figsize=(5,5))
x = age
y = life_expectancy
axes.plot(x,y, color='blue', linestyle='--', marker='o')
fig.suptitle('Life Expectancy')
axes.set_xlabel('age')
axes.set_xlim([-5,100])
axes.set_ylabel('life expectancy')
axes.set_ylim([0,100])
plt.show()**

现在，让我们估计一下我的预期寿命:

**# model 
slope, intercept, r_value, p_value, std_err = stats.linregress(age, life_expectancy)
print('intercept: ', intercept)
print('slope: ', slope)# predict life expectancy for an 49-year-old male in the USA:
np.ceil(slope * 49 + intercept)('intercept: ', 76.938519999999997)
('slope: ', -0.91447049999999985)
33.0**

还有 33 年，最好让它们有价值！现在，让我们将上述所有代码封装到一个函数中，这样我们就可以很容易地用其他参数预测其他年龄(当我们将其移植到 Flask 时，这将使我们的生活变得容易得多)。

**def get_life_expectancy(age, country, sex):# pull latest entries for birth and 60 yearssub_set = who_list[who_list['COUNTRY (DISPLAY)'].str.startswith(country, na=False)]sub_set = sub_set[sub_set['SEX (DISPLAY)'] == sex]sub_set = sub_set.sort_values('YEAR (CODE)', ascending=False)sub_set_birth = sub_set[sub_set['GHO (DISPLAY)'] == 'Life expectancy at birth (years)'] sub_set_60 = sub_set[sub_set['GHO (DISPLAY)'] == 'Life expectancy at age 60 (years)'] # not all combinations exsits so check that we have data for bothif len(sub_set_birth['Numeric']) > 0 and len(sub_set_60['Numeric']) > 0:# create data set with both points as shown in first examplelf_at_birth = sub_set_birth['Numeric'].values[0]lf_at_60 = sub_set_60['Numeric'].values[0]# model slope, intercept, r_value, p_value, std_err = stats.linregress([0,60],[lf_at_birth, lf_at_60])# predict for the age variablereturn(np.ceil(slope * age + intercept))else:return None**

让我们做一个快速测试:

**# test the function out using a 22-year-old Japanese female:
get_life_expectancy(22, 'Japan', 'Female')66.0**

66 岁的生活听起来是对的。

使用 Flask 和 Pythonanywhere 构建我们的模型原型

PythonAnywhere.com是一个在互联网上快速原型化你的 Python 交互式想法和模型的好方法。在 PythonAnywhere.com注册一个免费账户——你需要一个有效的电子邮件地址。

设置 Flask Web 框架

接下来，让我们用 Flask web 服务平台在 PythonAnywhere 上创建一个 web 服务器。这是非常容易做到的。在' Web 选项卡下，点击'添加新的 web app 蓝色按钮。并接受默认设置，直到您到达“选择一个 Python Web 框架”并点击“ Flask ”，然后是最新的 Python 框架。

您将进入登录配置页面，点击绿色的“重新加载您的 account.pythonanywhere.com”按钮，并使用您的新 URL 进行一次旋转:

您应该看到一个简单但真实的网页，带有来自 Flask 的' Hello！消息:

上传预期寿命网页代码

现在我们需要用我们的预期寿命代码替换 Flask 通用框架代码。点击“文件选项卡，在您的 root 帐户下创建一个名为“life _ expectations的新文件夹。在该文件夹中，上传我们之前下载并保存的' WHOSIS_000001，WHOSIS_000015.csv '数据。创建一个名为' flask_app.py 的 Python 文件，并在下面粘贴' flask_app.py '代码。

**from flask import Flask, render_template, request, url_for
import pandas as pd
import numpy as np
from scipy import stats
import logging
import datetime
import os.path
from flask import Markupapp = Flask(__name__)
app.config["DEBUG"] = True# constructor - load once (otherwise setup a local csv copy to save on bandwidth usage)
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
app.logger.error(BASE_DIR)
src = os.path.join(BASE_DIR, 'WHOSIS_000001,WHOSIS_000015.csv')
who_list = pd.read_csv(src)
who_list = who_list[['GHO (DISPLAY)', 'YEAR (CODE)' , 'COUNTRY (DISPLAY)', 'SEX (DISPLAY)', 'Numeric']]
who_list['COUNTRY (DISPLAY)'] = [ctry.title() for ctry in who_list['COUNTRY (DISPLAY)'].values]
country_list = sorted(set(who_list['COUNTRY (DISPLAY)'].values))def get_life_expectancy(age, country, sex):# pull latest entries for birth and 60 yearssub_set = who_list[who_list['COUNTRY (DISPLAY)'].str.startswith(country, na=False)]sub_set = sub_set[sub_set['SEX (DISPLAY)'] == sex]sub_set = sub_set.sort_values('YEAR (CODE)', ascending=False)sub_set_birth = sub_set[sub_set['GHO (DISPLAY)'] == 'Life expectancy at birth (years)']sub_set_60 = sub_set[sub_set['GHO (DISPLAY)'] == 'Life expectancy at age 60 (years)'] # not all combinations exsits so check that we have data for bothif len(sub_set_birth['Numeric']) > 0 and len(sub_set_birth['Numeric']) > 0:# create data set with both points as shown in first examplelf_at_birth = sub_set_birth['Numeric'].values[0]lf_at_60 = sub_set_60['Numeric'].values[0] # model slope, intercept, r_value, p_value, std_err = stats.linregress([0,60],[lf_at_birth, lf_at_60]) # predict for the age variablereturn(np.ceil(islope * age + intercept))else:return None@app.route('/', methods=['POST', 'GET'])
def interact_life_expectancy():# select box defaultsdefault_age = 'Select Age'selected_age = default_agedefault_sex = 'Select Gender'selected_sex = default_sexdefault_country = 'Select Country'selected_country = default_country # data carriersstring_to_print = ''healthy_image_list = [] if request.method == 'POST':# clean up age fieldselected_age = request.form["age"]if (selected_age == default_age):selected_age = int(29)else:selected_age = selected_age # clean up sex fieldselected_sex = request.form["sex"]if (selected_sex == default_sex):selected_sex = 'Both sexes' # clean up country fieldselected_country = request.form["country"]if (selected_country == default_country):selected_country = 'United States Of America' # estimate lifespancurrent_time_left = get_life_expectancy(age=int(selected_age), country=selected_country, sex=selected_sex)if (current_time_left is not None):# create output stringstring_to_print = Markup("You have <font size='+10'>" + str(int(np.ceil(current_time_left))) + "</font> healthy years left to live!")else:string_to_print = Markup("Error! No data found for selected parameters")current_time_left = 1 # healthy yearshealthy_image_list = []# squat.png, stretch.png, jog.pnghealthy_years_left = int(np.ceil(current_time_left))image_switch=0if (healthy_years_left > 0):for y in range(healthy_years_left):if image_switch == 0:healthy_image_list.append('static/images/Cycling.png')elif image_switch == 1:healthy_image_list.append('static/images/Jogging.png')elif image_switch == 2:healthy_image_list.append('static/images/JumpingJack.png')elif image_switch == 3:healthy_image_list.append('static/images/Stretching.png')elif image_switch == 4:healthy_image_list.append('static/images/WeightLifting.png')else:healthy_image_list.append('static/images/Yoga.png')image_switch = -1image_switch += 1 return render_template('main_page.html',country_list = country_list,default_country = selected_country,default_age=selected_age,default_sex=selected_sex,string_to_print = string_to_print,healthy_image_list = healthy_image_list)**

您的'life _ expectation'文件夹应该如下所示:

仍然在'life _ expectations下创建另一个名为' static 的文件夹，并在其下创建另一个名为' images 的文件夹，并上传以下六个运动图标(不幸的是，您一次只能上传一个):

********

您的“图像”文件夹应该如下所示:

返回到'life _ expectations文件夹，创建'模板文件夹。Templates 文件夹将存储我们的 HTML 模板，Flask 将使用这些模板动态显示我们的内容。在“模板文件夹下，创建一个名为“ main_page.html 的文件，粘贴以下动态 html 代码:

**<!DOCTYPE html>
<HTML lang="en">
<HEAD><TITLE>TimeLeftToLive.com</TITLE><META charset="utf-8"><META name="viewport" content="width=device-width, initial-scale=1"><link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css"><script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script><script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
</HEAD>
<BODY>
<DIV class="container"><DIV class="row"><H2><a href='http://www.TimeLeftToLive.com' target='_blank'>TimeLeftToLive.com</a></H2><H4>More Data Science and Machine Learning Articles at <a href='http://amunategui.github.io' target='_blank'>amunategui.github.io</a></H4><BR> <FORM id='submit_params' method="POST" action=""> <SELECT class="selectpicker" name="sex"><option value="" selected></option><option>Both sexes</option><option>Female</option><option>Male</option></SELECT><SELECT class="selectpicker" name="age"><option value="{{default_age}}" selected>{{default_age}}</option>{% for age in range(1,100) %}<option value="{{age}}">{{age}}</option>{% endfor %}</SELECT><SELECT class="selectpicker"  name="country"><option value="{{default_country}}" selected>{{default_country}}</option>{% for country in country_list %}<option value="{{country}}">{{country}}</option>{% endfor %}</SELECT> <button type="submit" class="btn btn-primary">Show me</button><button type="button" class="btn btn-primary" onclick="location.href='/';" value="Reset">Reset</button></FORM>
<BR>
<H2>{{string_to_print}}</H2>
<BR>
<TABLE>
<TR>
{% for imag in healthy_image_list %}{% if loop.index == 21 or loop.index == 41 or loop.index == 61 or loop.index == 81 %}</TR><TR>{% endif %}<td><img src={{imag}} width="40" height="40"></td>{% endfor %}</TR>
</TABLE>
</BODY>
</HTML>**

您的'模板'文件夹应该如下所示:

虚拟文件刷新

返回到' Web 选项卡，将'源代码从:

**/home/manuelamunategui/mysite/**

到

**/home/manuelamunategui/life_expectancy/**

点击下面几行的'/var/www/manuelamnategui _ python anywhere _ com _ wsgi . py'链接，编辑下面一行代码:

**project_home = u'/home/manuelamunategui/mysite'**

到

**project_home = u'/home/manuelamunategui/life_expectancy'**

点击绿色的“重新加载你的 account.pythonanywhere.com”按钮，带着你的新网址和交互式网络应用去兜风吧！

恭喜你！

在那里！恭喜那些走到这一步的人！并利用这些简单的工具和技术来展示您的 Python 想法！

感谢阅读！

曼努埃尔·阿穆纳特吉

免费电子书《成为数据科学家——赞美你的技术研究的基本技巧》的作者

在 amunategui.github.io 获取更多信息

英国 A&E 就诊和急诊入院的时间序列分析和预测

原文：https://towardsdatascience.com/time-series-analysis-and-forecasting-for-a-e-attendances-and-emergency-admission-in-england-53e41a93be35?source=collection_archive---------6-----------------------

简介:

这个项目的目标是分析和预测实时序列数据。这些报告和数据集来自 NHS 英格兰网站，该网站报告了英格兰国家医疗服务机构和独立部门组织的事故和急诊人数。

数据周期从 2010 年 8 月开始，到 2018 年 7 月结束。正如你所注意到的，我已经将注意力集中在“总出席人数”这一主要栏目上，并计划将其扩展到其他栏目，如果有人对该分析感兴趣的话。以下是数据集的屏幕截图:

关于时间序列分析:

时间序列分析是数据科学的重要课题之一。在这种类型的分析中，数据科学家尽可能准确地预测未来，这就是所谓的预测。我们可以想到大量的应用和想法，其中时间序列分析和预测可以有利于决策。在我之前的文章(点击这里)中，我讨论了医疗保健领域的一个应用。然而，让我们想一想不同领域的更多应用。

1)您可以使用时间序列分析，通过分析历史事件来预测或预报您的网站在未来的点击量和点击数。

2)预测或预测股票或黄金的价格和走势。

3)制造商预测生产和消耗率的另一个应用程序。..等等

价值主张:

我认为，对于数据科学家来说，思考项目的潜在价值以及它如何为决策者带来好处是非常重要的。这是我个人在一个项目开始时所做的。

对于这个项目，我相信通过预测和预测每月的 A&E(事故和紧急情况)出勤，许多重要的决定可以很容易地做出。无论是关于医疗和非医疗的股票购买或员工招聘和他们的工作时间表。此外还要为招待与会者做一些后勤准备。因此，将有助于提高服务质量和减少病人的等待时间。

该项目:

我将使用 R 中的时间序列包来分析和预测 Total A & E 英国 NHS 的出勤情况。以下是主要步骤的总结:

1.加载库和数据集

2.时间序列绘图和分析

3.探测

4.分解

5.均值和朴素方法预测

6.线性回归预测

7.ARIMA 模型预测

8.参考

注意:我是通过 Jupyter 笔记本环境使用 R 的。

加载库和数据集

在本节中，我将加载所需的库、数据集，然后进行一些数据辩论:

library(dplyr)library(urca)library(forecast)library(dygraphs)require(ggplot2)

正在加载数据集:

df <- read.csv ( file= ".. A&E admissions.csv", header = TRUE, sep = "\t")

更改标题名称，使其对 r 更友好。现在“总出席人数”列将表示为“TA”:

setnames ( df, old= c("Period","Total.Attendances), new=c("dateTime", "TA")

检查 ta 列中缺失的数据:

summary(is.na(df$TA))*> Mode   FALSE**> logical      96*

看来没有丢失数据，太好了！现在，我将使用 POSIX 函数将“dateTime”列转换为带有时区说明的日期时间对象:

to.POSIXct <- function(col) {*## Function to create a POSIXct time series**## Create a character vector from the numeric input*dateStr <- paste(as.character(col))*## Return the POSIXct time series object*as.POSIXct( strptime(dateStr, "%d/%m/%Y"))}df$dateTime <- to.POSIXct(df$dateTime)class(df$dateTime)>'POSIXct' 'POSIXt'

时间序列绘图与分析

现在，将 TA 转换为时间序列类:

TA.ts <- ts ( df[,'TA'] , frequency = 12,  start=c(2010,8), end= c(2018,7) )class(TA.ts)> 'ts'

时间序列摘要:

summary(TA.ts)*> Min. 1st Qu.  Median    Mean 3rd Qu.    Max.**> 1599364 1784570 1871972 1875892 1950438 2176022*

绘制英国每月 A&E 总出勤率

plot.ts(TA.ts, main = "Monthly Total A&E Attendance in England",  xlab = "Year", ylab = "TA")

绘制 A&E 在英国的季度和年度总出勤率:

TA.ts.qtr <- aggregate (TA.ts, nfrequency = 4)
TA.ts.yr <- aggregate (TA.ts, nfrequency = 1)plot.ts(TA.ts.qtr, main = "Quarterly Total A&E Attendance in England", xlab = "Year", ylab = "TA")
plot.ts(TA.ts.yr, main = " Yearly Total A&E Attendance in England", xlab = "Year", ylab = "TA")

绘制直方图和箱线图，以检查 TA 分布:

hist (TA.ts, breaks = 20, main = paste('Distribution of Total A&E Attendance in England'), xlab = "TA")

boxplot(TA.ts ~ cycle(TA.ts), xlab = "Month", ylab = "TA", main = "Monthly Total A&E Attendance in England - Boxplot")

我们可以注意到 TA 在同一个月和其他月份之间的分布和变化。5 月、7 月和 3 月分别是过去 8 年中最繁忙的月份。

探测

现在，仔细看看过去 8 年的与会者总数。这可以通过应用移动平均技术来实现，以便平滑趋势信号。我们将计算 6、12、24 和 36 个月的平均值，以控制趋势平滑度。

par(mfrow = c(2,2))plot(TA.ts, col="gray", main = "Half Year Moving Average Smoothing")
lines(ma(TA.ts, order = 6), col = "red", lwd=3)plot(TA.ts, col="gray", main = "1 Year Moving Average Smoothing")
lines(ma(TA.ts, order = 12), col = "blue", lwd=3)plot(TA.ts, col="gray", main = "2 Year Moving Average Smoothing")
lines(ma(TA.ts, order = 24), col = "green", lwd=3)plot(TA.ts, col="gray", main = "3 Year Moving Average Smoothing")
lines(ma(TA.ts, order = 36), col = "yellow4", lwd=3)

我们可以看到，在过去的几年中，A&E 与会者的人数几乎呈线性增长。

接下来，让我们检查从 2010 年到 2017 年英国人口对 A&E 出席人数的影响。首先，我必须收集英格兰人口的时间序列数据。幸运的是，我在英国国家统计网站找到了想要的数据。

Eng.Pop <- read.csv(file= ".. /England Pop.csv", header = TRUE,  sep = ",")head(Eng.Pop)*> Year Population**> 2010 52642500**> 2011 53107200**> 2012 53493700**> 2013 53865800**> 2014 54316600**> 2015 54786300*

创建带有刻度(1000)的时间序列人口数据

pop.ts <- ts((Eng.Pop$Population)/1000, frequency = 1, start= 2010, end= 2017)

地块人口时间序列:

plot(pop.ts, main = "England Popuation", xlab = "Year", ylab = "Number of People in 1,000")

现在，让我们从每年的 A&E 总出勤数据中去除英国人口上升的影响，然后比较两条曲线:

par(mfrow = c(1,2))
plot.ts((TA.ts.yr/pop.ts), lwd=2,col = "red", main = "Yearly Total A&E Attendance in England Adjusted by Population", xlab = "Year", ylab = "TA")
plot.ts(TA.ts.yr, col = "blue", lwd=2, main = " Yearly Total A&E Attendance in England", xlab = "Year", ylab = "TA")

我们可以明显地注意到，在 2010 年至 2017 年期间，英国人口数量的增加对 A&E 每年的总出席人数影响甚微。从 2011 年年中到 2014 年年中，与会者人数几乎保持不变。然后曲线从 2014 年年中开始跳跃到 2015 年底。需要额外的调查和数据来研究为什么英格兰在 2014 年底开始收到突然大量的事故和紧急情况。

分解

在这一步中，我们将把时间序列数据分解成三个部分:趋势、季节和剩余部分。剩余分量必须是稳定的(随机噪声)。换句话说，均值和方差必须是常数。另外，自协方差函数不依赖于时间。

我将对 TA 的记录时间序列使用 STL(使用黄土的季节和趋势分解)分解:

autoplot( stl(log(TA.ts), s.window="periodic", robust=TRUE))

现在，我们必须检查和测试剩余的数据，以确保它是稳定的。首先，我们将绘制自相关函数和偏自相关函数:

par(mfrow = c(1,2))
Acf(TA_rem, main ="ACF for Remainder")
Pacf(TA_rem, main ="PACF for Remainder")

ACF 没有明显的滞后，也没有季节效应，这意味着自协方差不依赖于时间。让我们通过绘制剩余部分的箱线图来检查常数均值和方差:

boxplot(TA.ts_rem ~ cycle(TA.ts), xlab = "Month", ylab = "TA", main = "Boxplot of Total Attendance Remainder")

平均值和方差是常数(无显著变化)。此外，我将应用单位根检验(KPSS 检验)来检查信号。KPSS 检验的零假设表明数据是稳定的，我们将寻找任何证据来拒绝零假设。

TA.ts_rem %>% ur.kpss()  %>% summary()*####################### 
# KPSS Unit Root Test # 
#######################*> Test is of type: mu with 3 lags.> Value of test-statistic is: 0.0287 > Critical value for a significance level of: 10pct  5pct 2.5pct  1pct
> critical values 0.347 0.463  0.574 0.739

检验统计值小于 10%临界值，表明通过了零假设，数据是稳定的。

意味着&天真的方法预测

在这里，我们将应用一些基本模型来预测 12 个月(从 2018 年 8 月至 2019 年 7 月)的 A&E 出席总人数。平均法就是取所有样本点的平均值。而天真和天真的季节性预测使用上一期进行下一期预测。

TA.fit.sa <- meanf(TA.ts, h = 12)
TA.fit.na <- naive(TA.ts, h = 12)
TA.fit.sna <- snaive(TA.ts, h = 12)
plot.ts(TA.ts, main = "Monthly Total Attendance NHS in England", xlab = "Year", ylab = "TA", xlim = c(2010, 2019))
lines(TA.fit.sa$mean, col = "blue")
lines(TA.fit.na$mean, col = "green")
lines(TA.fit.sna$mean, col = "red")
legend("topleft",lty=1,col=c("blue","green", "red"), cex = 0.75, legend=c("Mean method","Naive method", "Seasonal naive method"))

线性回归预测

首先，将拟合时间序列线性回归模型，然后使用“预测”包以 80%和 95%的置信区间预测 12 个月的值(从 2018 年 8 月到 2019 年 7 月):

fit.lm_TA.ts <- tslm(TA.ts ~ trend+season)frcst.lm <- forecast(fit.lm_TA.ts, h = 12, level = c(80,95))plot.ts(TA.ts, main = "Monthly Total A&E Attendance in England", xlab = "Year", ylab = "TA", xlim = c(2010,2019))lis(frcst.lm$fitted, col = "b

线性回归模型表现相当好，因为我们将拟合数据(蓝色)与实际数据(黑色)进行了对比。接下来，让我们通过检查残差来评估模型。残差均值和方差必须随时间保持不变，如下所示:

boxplot(residuals(fit.lm_TA.ts) ~ cycle(TA.ts), xlab = "Month", ylab = "TA", main = "Boxplot of Residuals")

拟合值和实际值之间的散点图:

df[,"TA.fitted"] <- as.numeric(fit.lm_TA.ts$fitted.values)plot(df$TA, df$TA.fitted, main = "Scatterplot between fitted & actual values", xlab = "Fitted Value", ylab = "Actual")
abline(0, 1, col="blue")

绘制并列出 2018 年 8 月至 2018 年 7 月的一年预测:

plot.ts(TA.ts, main = "Monthly Total Attendance NHS in England", xlab = "Year", ylab = "TA", xlim = c(2010,2019))
lines(frcst.lm$mean, col = "blue")

frcst.lm*> Point          Forecast   Lo 80   Hi 80   Lo 95   Hi 95*
*> Aug 2018        1990708 1932450 2048965 1901013 2080402*
*> Sep 2018        1984479 1926222 2042736 1894784 2074174*
*> Oct 2018        2045357 1987100 2103614 1955662 2135051*
*> Nov 2018        1957509 1899252 2015766 1867814 2047204*
*> Dec 2018        1997633 1939376 2055890 1907939 2087328*
*> Jan 2019        1957718 1899461 2015975 1868023 2047413*
*> Feb 2019        1860605 1802347 1918862 1770910 1950299*
*> Mar 2019        2113073 2054816 2171330 2023378 2202768*
*> Apr 2019        2022652 1964395 2080909 1932957 2112347*
*> May 2019        2137346 2079089 2195603 2047651 2227040*
*> Jun 2019        2073922 2015664 2132179 1984227 2163616*
*> Jul 2019        2153840 2095583 2212097 2064145 2243535*

ARIMA 模型预测

ARIMA 代表自回归综合移动平均线。这是时间序列预测的另一种方法。事实上，这是时间序列预测中最广泛使用的方法。

在本节中，我们将对季节性调整数据进行差分变换，以获得平稳信号。然后通过实验得出非季节性 ARIMA 模型的 p，d，q 参数。然后，为季节性 ARIMA 模型设置 P，D，Q 值。最后，将季节性 ARIMA 和自动 ARIMA 模型的结果进行比较。这是《预测原理和实践》一书中的图表摘要，介绍了使用 ARIMA 模型进行预测的一般过程

记住 ARIMA(p，D，q)(P，D，Q)模型:

p =非季节性部分的自回归部分的阶

d =非季节性部分涉及的一阶差异度

q =非季节性部分的移动平均部分的顺序

P =季节部分的自回归部分的阶

D =季节部分涉及的一阶差异度

Q =季节性部分的移动平均部分的阶数

首先，我们将分解数据，然后在没有季节成分的情况下重新构建— seasadj()函数:返回经季节调整的数据:

TA.ts %>% stl(s.window='periodic') %>% seasadj() -> TA.ts_seasadj
autoplot(TA.ts_seasadj, main= " Seasonal Adjusted Monthly A&E Attendance", lwt= 3)

ggtsdisplay(TA.ts_seasadj, main="Seasonal Adjusted Data with ACF and PACF plots")

显而易见，我们可以看到季节性调整数据并不是稳定的。让我们用 KPSS 单位根检验来复查一下:

TA.ts_seasadj %>% ur.kpss() %>% summary()*####################### 
# KPSS Unit Root Test # 
#######################* > Test is of type: mu with 3 lags. > Value of test-statistic is: 2.2591 > Critical value for a significance level of: 10pct  5pct 2.5pct  1pct
> critical values 0.347 0.463  0.574 0.739

测试统计值远高于临界值的 1%。这意味着信号不是稳定的。为了做到这一点，我们将应用一种叫做差分的有用的变换。差异可以通过消除时间序列水平的变化，从而消除(或减少)趋势和季节性，帮助稳定时间序列的平均值。

TA.ts_seasadj %>% diff() -> TA.ts_diff
ggtsdisplay(TA.ts_diff, main="Differencing Seasonal Adjusted Data with ACF and PACF plots")

ACF 图和 PACF 中的一些显著滞后将帮助我们确定 AR 和 MA 的 p 和 q 值。但总的来说，信号看起来是平稳的，让我们用 KPSS 单位根检验再次确认:

TA.ts_diff %>% ur.kpss() %>% summary()*####################### 
# KPSS Unit Root Test # 
#######################*> Test is of type: mu with 3 lags.> Value of test-statistic is: 0.0547> Critical value for a significance level of: 10pct  5pct 2.5pct  1pct
> critical values 0.347 0.463  0.574 0.739

测试统计值小于 10%临界值，这意味着数据是稳定的。这意味着一个差分变换足以获得静态数据。让我们评价和比较几个 ARIMA 模型——ARIMA(0，1，2)、ARIMA(1，1，2)和 ARIMA(1，1，1):

*# ARIMA(0,1,2)*summary(Arima (TA.ts_seasadj, order= c(0,1,2)))*> Series: TA.ts_seasadj* 
*> ARIMA(0,1,2)**> Coefficients:*
*>          ma1      ma2*
*>       -0.4453  -0.2117*
*> s.e.   0.0999   0.0937**> sigma^2 estimated as 1.459e+09:  log likelihood=-1136.32*
*> AIC=2278.64   AICc=2278.9   BIC=2286.3**> Training set error measures:*
*>                 ME     RMSE      MAE       MPE     MAPE      MASE        ACF1*
*> Training set 8044.3 37593.57 29865.46 0.3906696 1.586877 0.5389833 -0.05881525*

—

# ARIMA(1,1,2)
summary(Arima (TA.ts_seasadj, order= c(1,1,2)))*> Series: TA.ts_seasadj* 
*> ARIMA(1,1,2)* *> Coefficients:*
*>          ar1      ma1      ma2*
*>      -0.0782  -0.3745  -0.2516*
*> s.e.   0.3092   0.2901   0.1742**> sigma^2 estimated as 1.474e+09:  log likelihood=-1136.29*
*> AIC=2280.58   AICc=2281.02   BIC=2290.8**> Training set error measures:*
*>                   ME     RMSE      MAE      MPE     MAPE      MASE       ACF1*
*> Training set 7978.19 37581.15 29927.57 0.387108 1.589947 0.5401043 -0.0523739*

—

# ARIMA(1,1,1)
summary(Arima (TA.ts_seasadj, order= c(1,1,1)))*> Series: TA.ts_seasadj* 
*> ARIMA(1,1,1)**> Coefficients:*
*>         ar1      ma1*
*>       0.2644  -0.7487*
*> s.e.  0.1427   0.0907**> sigma^2 estimated as 1.477e+09:  log likelihood=-1136.91*
*> AIC=2279.82   AICc=2280.08   BIC=2287.48**> Training set error measures:*
*>                    ME     RMSE      MAE       MPE     MAPE      MASE       ACF1*
*> Training set 8057.644 37831.55 29899.12 0.3908637 1.589457 0.5395909 -0.019330*

ARIMA(0，1，2)是最好的，因为平方误差比系数值低得多。此外，它还具有最低的 AIC、BIC 和误差测量值，如 RMSE。让我们拟合选择的模型，检查残差，最后预测 12 个月:

fit*_TA.ts <- Arima (TA.ts_*seasadj, order= c(0,1,2))
checkresiduals(fit_TA.ts, lag = 10)*> Ljung-Box test**> data:  Residuals from ARIMA(0,1,2)*
*> Q* = 7.0949, df = 8, p-value = 0.5264**> Model df: 2\.   Total lags used: 10*

残差几乎呈正态分布，略有偏斜。除了在第 12 个阶段，ACF 没有显示出显著的数值。具有显著 p 值的 Ljung-Box 检验得出结论，残差是随机的(白噪声)。

从 2018 年 8 月到 2019 年 7 月的 12 个月预测:

frcst_TA.ts = forecast (fit_TA.ts, h=12)plot(frcst_TA.ts)

经过多次迭代后，我将季节部分(P，D，Q)的值估计为(1，1，1)。接下来，将拟合、评估和预测季节性 ARIMA 模型:

fit.seas_TA.ts <- Arima (TA.ts, order= c(0,1,2), seasonal=c(1,1,1))summary(fit.seas_TA.ts)*> Series: TA.ts* 
*> ARIMA(0,1,2)(1,1,1)[12]* *> Coefficients:*
*>           ma1      ma2     sar1     sma1*
*>       -0.5537  -0.2862  -0.3102  -0.6428*
*> s.e.   0.1050   0.1036   0.1416   0.1891**> sigma^2 estimated as 1.741e+09:  log likelihood=-1005.48*
*> AIC=2020.96   AICc=2021.74   BIC=2033.06**> Training set error measures:*
*>                    ME     RMSE      MAE       MPE     MAPE      MASE*
*> Training set 3386.278 37856.27 28465.13 0.1337672 1.513877 0.5137116*
*>                      ACF1*
*> Training set -0.009264586*

所有平方误差都远低于系数的绝对值。AIC 和 BIC 的表现优于非季节性 ARIMA 模型(0，1，2)。同样，我们需要确保残差是随机的，并且是非结构化的:

checkresiduals(fit.seas_TA.ts)*> Ljung-Box test**> data:  Residuals from ARIMA(0,1,2)(1,1,1)[12]*
*> Q* = 23.202, df = 20, p-value = 0.279**> Model df: 4\.   Total lags used: 24*

直方图分布有点偏斜，但模型仍然通过了永盒测试。p 值显著，ACF 图中没有显著的滞后。因此，我们现在有了一个季节性 ARIMA 模型，它通过了检查，可以进行预测了。该模型对未来一年的预测如下所示:

frcs.seas*_TA.ts <- forecast (fit.seas_*TA.ts, h=12)
summary(frcs.seas_TA.ts)*> Forecast method: ARIMA(0,1,2)(1,1,1)[12]**> Model Information:*
*> Series: TA.ts* 
*> ARIMA(0,1,2)(1,1,1)[12]* *> Coefficients:*
*>           ma1      ma2     sar1     sma1*
*>       -0.5537  -0.2862  -0.3102  -0.6428*
*> s.e.   0.1050   0.1036   0.1416   0.1891**> sigma^2 estimated as 1.741e+09:  log likelihood=-1005.48*
*> AIC=2020.96   AICc=2021.74   BIC=2033.06**> Error measures:*
*>                    ME     RMSE      MAE       MPE     MAPE      MASE*
*> Training set 3386.278 37856.27 28465.13 0.1337672 1.513877 0.5137116*
*>                      ACF1*
*> Training set -0.009264586**> Forecasts:*
*>          Point Forecast   Lo 80   Hi 80   Lo 95   Hi 95*
*> Aug 2018        2021727 1968205 2075248 1939872 2103581*
*> Sep 2018        2014485 1955875 2073094 1924849 2104121*
*> Oct 2018        2070211 2010979 2129444 1979623 2160800*
*> Nov 2018        1990520 1930671 2050369 1898988 2082052*
*> Dec 2018        2024607 1964148 2085067 1932142 2117072*
*> Jan 2019        1981844 1920780 2042907 1888455 2075233*
*> Feb 2019        1880516 1818854 1942178 1786212 1974820*
*> Mar 2019        2139569 2077315 2201824 2044359 2234780*
*> Apr 2019        2036234 1973392 2099076 1940126 2132342*
*> May 2019        2161701 2098278 2225124 2064703 2258698*
*> Jun 2019        2092552 2028553 2156552 1994674 2190431*
*> Jul 2019        2175445 2110872 2240018 2076689 2274200*

ARIMA 12 个月预测图(0，1，2) (1，1，1) [12]:

plot(frcs.seas_TA.ts)

另一方面，我们可以使用 auto.arima()来完成大部分工作。它将给出以下结果:

fit_TA = auto.arima(TA.ts, max.p=5, max.q=5,max.P=2 , max.Q=2, max.order=5, max.d=2, max.D=2, start.p=0, start.q=0, start.P=0, start.Q=0)
frcst*_TA = forecast(fit_*TA, h=12)
summary(frcst_TA)*> Forecast method: ARIMA(1,0,0)(1,1,1)[12] with drift**> Model Information:*
*> Series: TA.ts* 
*> ARIMA(1,0,0)(1,1,1)[12] with drift**> Coefficients:*
*>          ar1     sar1     sma1      drift*
*>       0.4134  -0.2152  -0.7774  2753.7605*
*> s.e.  0.1001   0.1514   0.2567   225.8097**> sigma^2 estimated as 1.667e+09:  log likelihood=-1016.63*
*> AIC=2043.26   AICc=2044.03   BIC=2055.41**> Error measures:*
*>                     ME     RMSE      MAE        MPE     MAPE      MASE*
*> Training set -1930.433 37268.02 28165.95 -0.1540752 1.507049 0.5083123*
*>                    ACF1*
*> Training set 0.01430932**> Forecasts:*
*>          Point Forecast   Lo 80   Hi 80   Lo 95   Hi 95*
*> Aug 2018        2015362 1962792 2067932 1934963 2095761*
*> Sep 2018        1997133 1940272 2053995 1910171 2084096*
*> Oct 2018        2044986 1987423 2102549 1956951 2133021*
*> Nov 2018        1958307 1900624 2015989 1870089 2046524*
*> Dec 2018        1994969 1937266 2052671 1906720 2083217*
*> Jan 2019        1949321 1891615 2007027 1861067 2037575*
*> Feb 2019        1857882 1800176 1915589 1769627 1946137*
*> Mar 2019        2115227 2057520 2172934 2026972 2203482*
*> Apr 2019        2015541 1957834 2073247 1927286 2103795*
*> May 2019        2131158 2073452 2188864 2042904 2219412*
*> Jun 2019        2066159 2008456 2123863 1977909 2154410*
*> Jul 2019        2147445 2089755 2205135 2059215 2235674*

绘制 ARIMA 12 个月的预测(1，0，0) (1，1，1) [12]:

plot(frcst_TA)

预测摘要

最后，让我们将季节性朴素线性回归、ARIMA(0，1，2)(1，1，1)和自动 ARIMA(1，0，0)(1，1，1)的所有预测结果合并到一个名为 summary.ts 的数据框架中，然后绘制线图:

summary.ts*>    Seas.Naive	Linear.Reg	ARIMA	Auto.ARIMA*
*> Aug-18	1924663	1990708	2021727	2015362*
*> Sep-18	1925961	1984479	2014485	1997133*
*> Oct-18	2044137	2045357	2070211	2044986*
*> Nov-18	1976971	1957509	1990520	1958307*
*> Dec-18	2003954	1997633	2024607	1994969*
*> Jan-19	2000086	1957718	1981844	1949321*
*> Feb-19	1820012	1860605	1880516	1857882*
*> Mar-19	2049785	2113073	2139569	2115227*
*> Apr-19	1978084	2022652	2036234	2015541*
*> May-19	2161779	2137346	2161701	2131158*
*> Jun-19	2091318	2073922	2092552	2066159*
*> Jul-19	2176022	2153840	2175445	2147445*

— — -

summary(summary.ts)>       Seas.Naive        Linear.Reg          ARIMA           Auto.ARIMA     
> Min.   :1820012   Min.   :1860605   Min.   :1880516   Min.   :1857882  
> 1st Qu.:1964219   1st Qu.:1977789   1st Qu.:2008494   1st Qu.:1985803  
> Median :2002020   Median :2010143   Median :2030421   Median :2015451  
> Mean   :2012731   Mean   :2024570   Mean   :2049118   Mean   :2024458  
> 3rd Qu.:2060168   3rd Qu.:2083709   3rd Qu.:2104307   3rd Qu.:2078426  
> Max.   :2176022   Max.   :2153840   Max.   :2175445   Max.   :2147445

参考文献

其实我看过很多文章练习时间序列分析。毕竟，最有用的一本是《预测:原理与实践》,作者是罗布·J·海曼，乔治·阿萨纳索普洛斯

此外，我从微软获得的课程和证书(应用机器学习)也非常有益。除了关于时间序列分析的有价值的信息之外，还有动手实验。

Python 中的时间序列分析:简介

原文：https://towardsdatascience.com/time-series-analysis-in-python-an-introduction-70d5a5b1d52a?source=collection_archive---------0-----------------------

用于时间序列建模的可加模型

时间序列是日常生活中最常见的数据类型之一。金融价格、天气、家庭能源使用量甚至体重都是可以定期收集的数据示例。几乎每个数据科学家都会在日常工作中遇到时间序列，学习如何对它们建模是数据科学工具箱中的一项重要技能。分析和预测周期性数据的一个强大而简单的方法是加法模型。这个想法很简单:将时间序列表示为不同尺度的模式组合，比如每天、每周、每季度和每年，以及总体趋势。你的能源消耗可能在夏天上升，在冬天下降，但是随着你提高你家的能源效率，总的趋势是下降的。加法模型可以向我们展示两种模式/趋势，并根据这些观察结果做出预测。

下图显示了将时间序列分解为总体趋势、年度趋势和周趋势的加法模型。

Example of Additive Model Decomposition

本文将介绍一个使用 Python 和脸书开发的 Prophet 预测包为金融时间序列数据创建附加模型的示例。在这个过程中，我们将介绍使用 pandas 的一些数据操作，使用 Quandl 库和访问财务数据，以及使用 matplotlib 进行绘图。我在有指导意义的地方加入了代码，我鼓励任何人查看 GitHub 上的 Jupyter 笔记本以获得完整的分析。这个介绍将向你展示你自己开始建模时间序列所需的所有步骤！

免责声明:现在到了令人厌烦的部分，我不得不提到，当谈到财务数据时，过去的表现不是未来表现的指标，你不能用这里的方法致富。我选择使用股票数据，因为它很容易在每天的频率上获得，而且玩起来很有趣。如果你真的想变得富有，学数据科学是比玩股市更好的选择！

检索财务数据

通常，花费在数据科学项目上的大约 80%的时间是获取和清理数据。多亏了 quandl 金融库，这个项目的这个比例降低到了 5%。Quandl 可以从命令行与 pip 一起安装，让您用一行 Python 就可以访问数千个财务指标，并且每天允许多达 50 个请求，无需注册。如果你注册了一个免费账户，你会得到一个允许无限请求的 api 密匙。

首先，我们导入所需的库并获取一些数据。Quandl 自动将我们的数据放入 pandas dataframe，这是数据科学的首选数据结构。(对于其他公司，只需用股票代码替换“TSLA”或“通用汽车”即可。您也可以指定日期范围)。

# quandl for financial data
import quandl
# pandas for data manipulation
import pandas as pdquandl.ApiConfig.api_key = 'getyourownkey!'# Retrieve TSLA data from Quandl
tesla = quandl.get('WIKI/TSLA')# Retrieve the GM data from Quandl
gm = quandl.get('WIKI/GM')
gm.head(5)

Snapshot of GM data from quandl

关于 quandl 的数据几乎是无限的，但我想重点比较同一行业的两家公司，即特斯拉和通用汽车。特斯拉是一家令人着迷的公司，不仅因为它是 111 年来第一家成功的美国汽车初创公司，还因为在 2017 年的中，尽管只销售了 4 种不同的汽车，但它仍是美国最有价值的汽车公司。最有价值汽车公司头衔的另一个竞争者是通用汽车公司，该公司最近显示出拥抱汽车未来的迹象，制造了一些非常酷(但看起来不酷)的全电动汽车。

Not a very hard choice

我们可以轻松地花费数小时来搜索这些数据，并将其下载为 csv 电子表格文件，但是，多亏了 quandl，我们在几秒钟内就获得了所有需要的数据！

数据探索

在我们开始建模之前，最好通过绘制一些探索图来了解一下结构和范围。这也将允许我们寻找需要纠正的异常值或缺失值。

熊猫数据帧可以很容易地用 matplotlib 绘制。如果任何图形代码看起来吓人，不要担心。我还发现 matplotlib 不直观，经常从堆栈溢出或文档中复制并粘贴示例来获得我想要的图形。编程的规则之一是不要重新发明一个已经存在的解决方案！

# The adjusted close accounts for stock splits, so that is what we should graph
plt.plot(gm.index, gm['Adj. Close'])
plt.title('GM Stock Price')
plt.ylabel('Price ($)');
plt.show()plt.plot(tesla.index, tesla['Adj. Close'], 'r')
plt.title('Tesla Stock Price')
plt.ylabel('Price ($)');
plt.show();

Raw Stock Prices

仅从股价上比较两家公司并不能说明哪家更有价值，因为公司的总价值(市值)还取决于股票数量(市值=股价*股票数量)。Quandl 没有股票数量的数据，但我可以通过快速的谷歌搜索找到两家公司的平均年度股票。虽然不精确，但对我们的分析来说足够精确了。有时候我们不得不用不完美的数据来凑合！

为了在我们的数据框架中创建一列市值，我们使用了一些 pandas 的技巧，比如将索引移动到一列(reset_index ),同时使用 ix 索引和修改数据框架中的值。

# Yearly average number of shares outstanding for Tesla and GM
tesla_shares = {2018: 168e6, 2017: 162e6, 2016: 144e6, 2015: 128e6, 2014: 125e6, 2013: 119e6, 2012: 107e6, 2011: 100e6, 2010: 51e6}gm_shares = {2018: 1.42e9, 2017: 1.50e9, 2016: 1.54e9, 2015: 1.59e9, 2014: 1.61e9, 2013: 1.39e9, 2012: 1.57e9, 2011: 1.54e9, 2010:1.50e9}# Create a year column 
tesla['Year'] = tesla.index.year# Take Dates from index and move to Date column 
tesla.reset_index(level=0, inplace = True)
tesla['cap'] = 0# Calculate market cap for all years
for i, year in enumerate(tesla['Year']):# Retrieve the shares for the yearshares = tesla_shares.get(year)# Update the cap column to shares times the pricetesla.ix[i, 'cap'] = shares * tesla.ix[i, 'Adj. Close']

这为特斯拉创造了一个“上限”栏。我们对 GM 数据做同样的处理，然后合并两者。合并是数据科学工作流的重要组成部分，因为它允许我们在共享列上连接数据集。在这种情况下，我们有两个不同公司在相同日期的股票价格，因此我们希望连接日期列上的数据。我们执行“内部”合并，只保存同时出现在两个数据帧中的日期条目。合并后，我们重命名这些列，这样我们就知道哪一列对应哪一家汽车公司。

# Merge the two datasets and rename the columns
cars = gm.merge(tesla, how='inner', on='Date')cars.rename(columns={'cap_x': 'gm_cap', 'cap_y': 'tesla_cap'}, inplace=True)# Select only the relevant columns
cars = cars.ix[:, ['Date', 'gm_cap', 'tesla_cap']]# Divide to get market cap in billions of dollars
cars['gm_cap'] = cars['gm_cap'] / 1e9
cars['tesla_cap'] = cars['tesla_cap'] / 1e9cars.head()

Merged Market Capitalization Dataframe

市值以十亿美元计。我们可以看到，在我们的分析期开始时，通用汽车的市值大约是特斯拉的 30 倍！事情会在整个时间线上保持不变吗？

plt.figure(figsize=(10, 8))
plt.plot(cars['Date'], cars['gm_cap'], 'b-', label = 'GM')
plt.plot(cars['Date'], cars['tesla_cap'], 'r-', label = 'TESLA')
plt.xlabel('Date'); plt.ylabel('Market Cap (Billions $)'); plt.title('Market Cap of GM and Tesla')
plt.legend();

Market Capitalization Historical Data

在数据过程中，我们观察到特斯拉的快速增长和通用汽车的小幅增长。2017 年期间，特斯拉的价值甚至超过了通用汽车！

import numpy as np# Find the first and last time Tesla was valued higher than GM
first_date = cars.ix[np.min(list(np.where(cars['tesla_cap'] > cars['gm_cap'])[0])), 'Date']
last_date = cars.ix[np.max(list(np.where(cars['tesla_cap'] > cars['gm_cap'])[0])), 'Date']print("Tesla was valued higher than GM from {} to {}.".format(first_date.date(), last_date.date()))**Tesla was valued higher than GM from 2017-04-10 to 2017-09-21.**

在此期间，特斯拉卖了大约 48，000 辆，而通用卖了 1，500，000 辆。在一段时间内，通用汽车的销量是特斯拉的 30 倍，但其价值却低于特斯拉！这无疑展示了一个有说服力的高管和一个高质量(尽管数量非常少)产品的力量。虽然特斯拉的价值现在低于通用汽车，但一个好问题可能是，我们能期待特斯拉再次超过通用汽车吗？什么时候会这样？为此，我们求助于加法模型进行预测，或者换句话说，预测未来。

用先知建模

2017 年 Python 和 R 发布了脸书先知包，全世界的数据科学家都欢欣鼓舞。Prophet 设计用于分析具有日常观察的时间序列，这些观察显示不同时间尺度上的模式。它还具有高级功能，可以对假日对时间序列的影响进行建模，并实现自定义的变点，但我们将坚持使用基本功能来启动和运行模型。Prophet 和 quandl 一样，可以从命令行安装 pip。

我们首先导入 prophet，并将数据中的列重命名为正确的格式。日期列必须称为' ds '，而我们要预测的值列必须称为' y '。然后，我们创建 prophet 模型并使其符合数据，就像 Scikit-Learn 机器学习模型一样:

import fbprophet# Prophet requires columns ds (Date) and y (value)
gm = gm.rename(columns={'Date': 'ds', 'cap': 'y'})# Put market cap in billions
gm['y'] = gm['y'] / 1e9# Make the prophet model and fit on the data
gm_prophet = fbprophet.Prophet(changepoint_prior_scale=0.15)
gm_prophet.fit(gm)

当创建 prophet 模型时，我将 changepoint 设置在 0.15 之前，高于默认值 0.05。该超参数用于控制趋势对变化的敏感程度，数值越高越敏感，数值越低越不敏感。这个值用于对抗机器学习中最基本的权衡之一:偏差与方差。

如果我们太接近我们的训练数据，称为过拟合，我们有太多的方差，我们的模型将不能很好地推广到新数据。另一方面，如果我们的模型没有捕捉到训练数据中的趋势，那么它就不合适，并且有太多的偏差。当模型拟合不足时，增加变点先验允许模型更灵活地拟合数据，如果模型拟合过度，减少先验会限制灵活性。变点先验比例的影响可以通过用一系列值做出的图形预测来说明:

变点先验比例越高，模型就越灵活，越符合训练数据。这可能看起来正是我们想要的，但是学习训练数据太好可能会导致过度拟合，并且无法准确地对新数据进行预测。因此，我们需要在拟合训练数据和能够推广到新数据之间找到恰当的平衡。由于股票每天都在变化，我们希望我们的模型能够捕捉到这一点，所以在尝试了一系列值后，我增加了灵活性。

在创建 prophet 模型的调用中，我们还可以指定变点，当时间序列从增加到减少，或从缓慢增加到快速增加时，会出现这些变点(它们位于时间序列中速率变化最大的位置)。转折点可能对应于重大事件，如产品发布或市场中的宏观经济波动。如果我们不指定变点，prophet 将为我们计算它们。

为了进行预测，我们需要创建一个所谓的未来数据框架。我们指定要预测的未来周期数(两年)和预测频率(每天)。然后，我们用我们创建的先知模型和未来数据框架进行预测:

# Make a future dataframe for 2 years
gm_forecast = gm_prophet.make_future_dataframe(periods=365 * 2, freq='D')# Make predictions
gm_forecast = gm_prophet.predict(gm_forecast)

我们未来的数据框架包含特斯拉和通用汽车未来两年的估计市值。我们可以用 prophet plot 函数可视化预测。

gm_prophet.plot(gm_forecast, xlabel = 'Date', ylabel = 'Market Cap (billions $)')
plt.title('Market Cap of GM');

黑点代表实际值(注意它们如何在 2018 年初停止)，蓝线表示预测值，浅蓝色阴影区域是不确定性(始终是任何预测的关键部分)。由于初始不确定性会随着时间的推移而传播和增长，因此预测的不确定性区域会越来越大。这可以在的天气预报中观察到，天气预报的时间越长越不准确。

我们还可以检查由模型识别的变更点。同样，变点表示时间序列增长率显著变化的时间(例如，从增加到减少)。

tesla_prophet.changepoints[:10]**61    2010-09-24
122   2010-12-21
182   2011-03-18
243   2011-06-15
304   2011-09-12
365   2011-12-07
425   2012-03-06
486   2012-06-01
547   2012-08-28
608   2012-11-27**

为了比较，我们可以看看这段时间内谷歌对特斯拉的搜索趋势，看看变化是否一致。我们在同一张图上绘制了变化点(垂直线)和搜索趋势:

# Load in the data 
tesla_search = pd.read_csv('data/tesla_search_terms.csv')# Convert month to a datetime
tesla_search['Month'] = pd.to_datetime(tesla_search['Month'])
tesla_changepoints = [str(date) for date in tesla_prophet.changepoints]# Plot the search frequency
plt.plot(tesla_search['Month'], tesla_search['Search'], label = 'Searches')# Plot the changepoints
plt.vlines(tesla_changepoints, ymin = 0, ymax= 100, colors = 'r', linewidth=0.6, linestyles = 'dashed', label = 'Changepoints')# Formatting of plot
plt.grid('off'); plt.ylabel('Relative Search Freq'); plt.legend()
plt.title('Tesla Search Terms and Changepoints');

Tesla Search Frequency and Stock Changepoints

特斯拉市值的一些变化点与特斯拉搜索频率的变化一致，但不是全部。由此，我会说相对谷歌搜索频率并不是一个很好的股票变化指标。

我们仍然需要弄清楚特斯拉的市值何时会超过通用汽车。由于我们对未来两年都有预测，合并数据框架后，我们可以在同一张图上绘制两家公司。在合并之前，我们重命名列以跟踪数据。

gm_names = ['gm_%s' % column for column in gm_forecast.columns]
tesla_names = ['tesla_%s' % column for column in tesla_forecast.columns]# Dataframes to merge
merge_gm_forecast = gm_forecast.copy()
merge_tesla_forecast = tesla_forecast.copy()# Rename the columns
merge_gm_forecast.columns = gm_names
merge_tesla_forecast.columns = tesla_names# Merge the two datasets
forecast = pd.merge(merge_gm_forecast, merge_tesla_forecast, how = 'inner', left_on = 'gm_ds', right_on = 'tesla_ds')# Rename date column
forecast = forecast.rename(columns={'gm_ds': 'Date'}).drop('tesla_ds', axis=1)

首先，我们将只绘制估计值。估计值(在 prophet 软件包中称为“yhat ”)消除了数据中的一些噪声，因此它看起来与原始图略有不同。平滑程度将取决于变点先验比例-更高的先验意味着更灵活的模型和更多的起伏。

GM and Tesla Predicted Market Capitalization

我们的模型认为，特斯拉在 2017 年短暂超越通用汽车只是一个噪音，直到 2018 年初，特斯拉才在预测中永远击败通用汽车。确切的日期是 2018 年 1 月 27 日，所以如果这种情况发生，我会很高兴地因为预测未来而受到表扬！

制作上图时，我们忽略了预测中最重要的部分:不确定性！我们可以使用 matplotlib(参见笔记本)来显示有疑问的区域:

这是预测的一个更好的表示。这表明两家公司的价值都有望增加，但特斯拉的增长将比通用汽车更快。同样，不确定性随着时间的推移而增加，正如预测所预期的那样，特斯拉的下限低于通用汽车在 2020 年的上限，这意味着通用汽车可能会保持领先地位。

趋势和模式

市值分析的最后一步是查看整体趋势和模式。Prophet 使我们能够轻松地可视化整体趋势和组件模式:

# Plot the trends and patterns
gm_prophet.plot_components(gm_forecast)

General Motors Time Series Decomposition

趋势非常明显:通用汽车的股票正在上涨，并将继续上涨。每年的模式很有趣，因为它似乎表明通用汽车的价值在年底增加，并在夏季缓慢下降。我们可以尝试确定在一段时间内通用汽车的年度市值和平均月销售额之间是否存在相关性。我首先从谷歌收集每月的汽车销量，然后用 groupby 计算几个月的平均值。这是另一个关键的数据科学操作，因为我们经常想要比较不同类别的统计数据，例如特定年龄组的用户，或者来自一个制造商的车辆。在这种情况下，我们希望计算每个月的平均销售额，因此我们将这些月份组合在一起，然后计算销售额的平均值。

gm_sales_grouped = gm_sales.groupby('Month').mean()

看起来月销售额与市值并不相关。8 月单月销量第二高，正好在市值最低点！

查看每周趋势，似乎没有任何有意义的信号(周末没有记录股票价格，所以我们查看一周内的变化)。这是意料之中的，因为经济学中的随机游走理论指出，股票价格每天都没有可预测的模式。正如我们的分析所证明的，从长期来看，股票往往会增加，但在日常尺度上，即使有最好的模型，我们也几乎没有可以利用的模式。

简单看一下道琼斯工业平均指数(股票交易所 30 家最大公司的市场指数)就能很好地说明这一点:

Dow Jones Industrial Average (Source)

很明显，这个信息是回到 1900 年，投资你的钱！或者在现实中，当市场下跌时，不要退出，因为根据历史，它会重新上涨。总的来说，每天的波动太小，甚至看不到，如果我们像数据科学家一样思考，我们会意识到，与投资整个市场并长期持有相比，每天玩股票是愚蠢的。

Prophet 还可以应用于更大规模的数据测量，如国内生产总值，这是一个国家经济总体规模的衡量指标。我根据美国和中国的历史 GDP 建立了先知模型，做出了以下预测。

中国 GDP 超过美国的确切日期是 2036 年！由于观察频率低(GDP 每季度测量一次，但 prophet 使用每日数据效果最佳)，该模型存在局限性，但它提供了一个基本预测，不需要宏观经济知识。

有许多方法可以对时间序列建模，从简单的线性回归到带有 LSTM 细胞的递归神经网络。加法模型是有用的，因为它们开发快，训练快，提供可解释的模式，并做出具有不确定性的预测。Prophet 的能力令人印象深刻，我们在这里只是触及了皮毛。我鼓励你利用这篇文章和笔记本来探索 Quandl 提供的一些数据或者你自己的时间序列。请继续关注时间序列分析的未来工作，以及 prophet 在我日常生活中的应用，参见我在上的帖子，使用这些技术来建模和预测体重变化。作为探索时间序列的第一步，Python 中的附加模型是必由之路！

一如既往，我欢迎反馈和建设性的批评。可以在 wjk68@case.edu 找到我。

时序日历热图

原文：https://towardsdatascience.com/time-series-calendar-heatmaps-9f576578fcfe?source=collection_archive---------12-----------------------

一种可视化时间序列数据的新方法

介绍

时间序列是按时间顺序编制索引的一系列数据。时间顺序可以用天、周、月或年来表示。可视化时间序列数据的最常见方法是使用简单的折线图，其中横轴绘制时间增量，纵轴绘制所测量的变量。可以使用ggplot2中的geom_line()或简单使用Base R中的plot()功能来实现可视化。

在本教程中，我将介绍一个名为时序日历热图的新工具来可视化时序数据。我们将看看如何使用ggplot2绘制时间序列日历热图。我们还将探索由 Paul Bleicher 编写的calendarHeat()函数(在 GPL 许可下作为开源发布),它提供了一种创建可视化的简单方法。

动机

如果你曾经去过 GitHub，你肯定会偶然发现下面的图表，它显示了一个用户在过去一年中所做的贡献。瓷砖的颜色代表贡献的数量(如图表右下角的图例所述)。在这里，日历热图提供了一种直观的方式，在类似日历的视图中直观地显示用户一年中所做的提交数量，从而很容易识别日常模式或异常情况。

Heatmap from Github

另一个很好的例子可以在下面这篇由《华尔街日报》发表的文章中找到，这篇文章显示了 70 年来美国所有 50 个州的感染人数。

http://graphics.wsj.com/infectious-diseases-and-vaccines/

在这里，日历热图可以很容易地识别各种疾病感染人数的年度模式。

个案研究

为了说明日历热图的使用，我们将可视化亚马逊过去 5 年的股票价格(NASDAQ: AMZN)。我们将关注调整后的收盘价，该收盘价将通过tidyquant包获得。

包装

我们将安装并导入tidyquant包来获取亚马逊的股票价格。我们还将安装并导入ggplot2来执行可视化。calendarHeat()的 R 代码可以通过 Paul Bleicher 的 Github 页面下载。

*# install tidyquant* install.packages('tidyquant', repos = "http://cran.us.r-project.org")
library(tidyquant) *#install ggplot2* install.packages("ggplot2", repos = "http://cran.us.r-project.org") library(ggplot2) *#Load the function to the local through Paul Bleicher's GitHub page* source("https://raw.githubusercontent.com/iascchen/VisHealth/master/R/calendarHeat.R")

加载数据

amznStock = as.data.frame(tidyquant::tq_get(c("AMZN"),get="stock.prices")) *# get data using tidyquant* 
amznStock = amznStock[year(amznStock$date) > 2012, ] *# Using data only after 2012*Using ggplot2

使用

使用ggplot2创建日历热图的过程有些麻烦。在制作热图之前，我们需要将数据整理成正确的形状。下面的代码列出了如何使用ggplot2管理创建日历热图的数据的步骤。

library(plyr)
library(plotly)amznStock$weekday = as.POSIXlt(amznStock$date)$wday *#finding the day no. of the week*amznStock$weekdayf<-factor(amznStock$weekday,levels=rev(1:7),labels=rev(c("Mon","Tue","Wed","Thu","Fri","Sat","Sun")),ordered=TRUE) *#converting the day no. to factor* amznStock$monthf<-factor(month(amznStock$date),levels=as.character(1:12),labels=c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"),ordered=TRUE) *# finding the month* amznStock$yearmonth<- factor(as.yearmon(amznStock$date)) *#finding the year and the month from the date. Eg: Nov 2018* amznStock$week <- as.numeric(format(amznStock$date,"%W")) #finding the week of the year for each date amznStock<-ddply(amznStock,.(yearmonth),transform,monthweek=1+week-min(week)) *#normalizing the week to start at 1 for every month* p <- ggplot(amznStock, aes(monthweek, weekdayf, fill = amznStock$adjusted)) + geom_tile(colour = "white") + facet_grid(year(amznStock$date)~monthf) + scale_fill_gradient(low="red", high="green") + xlab("Week of Month") + ylab("") + ggtitle("Time-Series Calendar Heatmap: AMZN Stock Prices") + labs(fill = "Price") p

Calendar Heatmap using ggplot2

使用 calendarHeat()

calendarHeat()使流程变得更加简单。我们只需要调用函数并指定以下五个参数。

• date:需要绘制数据的日期。
• values:与这些日期相关联的值。
• color:调色板。默认为 r2g(红转绿)。其他预定义选项有 r2b(红到蓝)和 w2b(白到蓝)。您可以通过定义如下所示的向量来创建自己的调色板。
• ncolors:热图的颜色数量
• varname:图表标题

r2g <- c("#D61818", "#FFAE63", "#FFFFBD", "#B5E384") calendarHeat(amznStock$date, amznStock$adjusted, ncolors = 99, color = "r2g", varname="AMZN Adjusted Close")

Calendar Heatmap using calendarHeat()

何时使用ggplot2?中的calendarHeat() v/s geom_tile

calendarHeat()是一个预定义的函数，因此它在如何修改图形方面提供的灵活性较小。为了用除了在calendarHeat()函数中指定的五个参数之外的其他方式更新数字，我们需要修改底层代码。ggplot2另一方面提供了灵活性，因为我们从头开始构建可视化。

此外，ggplotly可以与ggplot2图表集成，使其更具交互性。例如，通过使用ggplotly我们将能够计算每天的价格。calendarHeat()另一方面，不能与ggplotly集成(不确定是否有现有的包可以帮助实现相同的功能)。

说到方便，calendarHeat()提供了一种更简单的方法来构建图表。我们只需要调用一个函数，一个相对标准的数据集就可以很容易地可视化，而不需要做太多的数据筛选。

什么时候应该使用日历热图？

当“每日值”或“星期几”值很重要时，日历热图很有用。如果我们想查看全年的每日数值，那么日历热图特别有用。

另一方面，如果我们想看到一个趋势(例如:季节性、形状、平稳性等。)，日历热图帮助不大。这些也不能描绘月度或年度趋势。如果我们希望看到数据的总体趋势，那么简单的折线图是更好的方法。

参考

https://www.r-bloggers.com/ggplot2-time-series-heatmaps、https://www . rdocumentation . org/packages/iClick/versions/1.4/topics/calendar heat、https://github . com/iascchen/vis health/blob/master/R/calendar heat。R ，https://www . tableau . com/about/blog/2017/2/viz-variety-show-heat maps-66330

假人的时间序列——三步过程

原文：https://towardsdatascience.com/time-series-for-dummies-the-3-step-process-447fb642a6f1?source=collection_archive---------13-----------------------

克里斯·圣·杰尔&肖恩·安肯布鲁克，Zencos

在一顿令人满意的中餐外卖后，你心不在焉地打开了免费的幸运饼干。瞥了一眼里面的财富，你读到，“你的一个梦想将会实现。”你一边嗤之以鼻，一边扔掉小纸片，把饼干放进嘴里。作为一个聪明、理性的人，你知道财富是微不足道的——没有人能预测未来。然而，这种想法可能是不完整的。有一种方法可以非常准确地预测未来:时间序列建模。

时间序列建模可能无法告诉你什么时候会遇到你一生的挚爱，或者你应该穿蓝色还是红色的领带去上班，但它非常擅长使用历史数据来识别现有的模式，并用它们来预测未来会发生什么。与大多数高级分析解决方案不同，时间序列建模是一种低成本的解决方案，可以提供强大的洞察力。

本文将介绍构建高质量时间序列模型的三个基本步骤:使数据稳定、选择正确的模型以及评估模型的准确性。本文中的例子使用了一家大型汽车营销公司的历史页面浏览量数据。

步骤 1:使数据稳定

时间序列涉及到数据的使用，这些数据是由等间距的时间增量(分钟、小时、天、周等)索引的。).由于时间序列数据的离散性，许多时间序列数据集在数据中内置了季节和/或趋势元素。时间序列建模的第一步是考虑现有的季节(一段固定时间内重复出现的模式)和/或趋势(数据向上或向下移动)。考虑到这些嵌入模式，我们称之为使数据稳定。趋势和季节性数据的例子可以在下面的图 1 和图 2 中看到。

Figure 1: Example of Upward Trending Data

Figure 2: Example of Seasonal Data

什么是平稳性？

正如我们之前提到的，时间序列建模的第一步是消除数据中存在的趋势或季节的影响，使其保持平稳。我们一直在讨论术语平稳性，但是它到底是什么意思呢？

平稳序列是指序列的平均值不再是时间的函数。对于趋势数据，随着时间的增加，序列的均值会随着时间的推移而增加或减少(想想房价随着时间的推移而稳步上升)。对于季节性数据，序列的平均值随着季节而波动(想想每 24 小时温度的上升和下降)。

我们如何实现平稳性？

有两种方法可以应用于实现平稳性，差分数据或线性回归。要计算差值，需要计算连续观察值之间的差值。要使用线性回归，您需要在模型中包含季节性组件的二进制指示变量。在我们决定应用这些方法中的哪一种之前，让我们来研究一下我们的数据。我们使用 SAS 视觉分析绘制了历史每日页面浏览量。

Figure 3: Time Series Plot of Raw Page Views

最初的模式似乎每七天重复一次，表示一周一季。随着时间的推移，页面浏览量持续增加，这表明有略微上升的趋势。对数据有了大致的了解后，我们应用了平稳性的统计检验，即扩展的 Dickey-Fuller (ADF)检验。ADF 检验是平稳性的单位根检验。我们不会在这里进入细节，但是一个单位根表示序列是否是非平稳的，所以我们使用这个测试来确定处理趋势或季节的适当方法(差异或回归)。基于上述数据的 ADF 测试，我们通过对一周中某一天的虚拟变量进行回归来去除七天季节，并通过对数据进行差分来去除趋势。由此产生的静态数据可以在下图中看到。

Figure 4: Stationary Data After Removing Season and Trend

步骤 2:构建时间序列模型

既然数据是稳定的，时间序列建模的第二步是建立一个基本水平的预测。我们还应该注意到，大多数基本水平的预测不需要第一步使你的数据稳定。只有更高级的模型才需要这样做，比如我们马上要讨论的 ARIMA 模型。

建立基础水平预测

时间序列模型有几种类型。要构建一个可以准确预测未来页面浏览量(或任何您感兴趣的预测)的模型，有必要确定适合您的数据的模型类型。

最简单的选择是假设 y 的未来值(您有兴趣预测的变量)等于 y 的最新值。这被认为是最基本的，或“天真模型”，其中最近的观察是明天最可能的结果。

第二种模型是平均模型。在这个模型中，数据集中的所有观察值被赋予相同的权重。y 的未来预测值计算为观测数据的平均值。如果数据是水平的，生成的预测可能相当准确，但如果数据是趋势性的或具有季节性成分，则提供的预测会非常差。使用平均模型对页面浏览量数据的预测值如下所示。

Figure 5: Average (Mean) Model Forecast

如果数据具有季节性或趋势性元素，那么基准水平模型的更好选择是实施指数平滑模型(ESM)。ESM 在上述简单模型和平均模型之间找到了一个合适的中间点，最近的观察值被赋予最大的权重，而所有以前的观察值的权重随着时间的推移呈指数递减。ESM 还允许将季节性和/或趋势性组件纳入模型。下表提供了 0.7 的初始权重以 0.3 的速率指数下降的示例。

Table 1: Example of the exponentially decreasing effect of past observations of Y.

在时间序列预测中，可以实施各种类型的 ESM。要使用的理想模型将取决于您拥有的数据类型。下表根据数据中的趋势和季节组合，提供了使用哪种 ESM 的快速指南。

Table 2: Model Selection Table

由于强七天季节和数据的上升趋势，我们选择了一个附加的冬季 ESM 作为新的基准水平模型。生成的预测很好地延续了轻微的上升趋势，并捕捉到了七天的季节。但是，数据中仍有更多模式可以删除。

Figure 6: Additive Winters ESM Forecast

ARIMA 造型

在确定了最能解释数据中的趋势和季节的模型后，您最终有了足够的信息来生成一个像样的预测，如上图所示。然而，这些模型仍然是有限的，因为它们没有考虑到感兴趣的变量在以前的时间段内与其自身的相关性。我们将这种相关性称为自相关，这在时间序列数据中很常见。如果数据具有自相关性，就像我们的一样，那么就可以进行额外的建模来进一步改进基线预测。

为了捕捉时间序列模型中的自相关效应，有必要实施自回归综合移动平均(或 ARIMA)模型。ARIMA 模型包括说明季节和趋势的参数(如使用虚拟变量表示一周中的天数和差异)，但也允许包含自回归和/或移动平均项来处理数据中嵌入的自相关。通过使用适当的 ARIMA 模型，我们可以进一步提高页面浏览量预测的准确性，如下图 3 所示。

Figure 7: Seasonal ARIMA Model Forecast

步骤 3:评估模型准确性

虽然您可以看到所展示的每个模型的准确性都有所提高，但是直观地确定哪个模型的准确性最好并不总是可靠的。计算 MAPE(平均绝对百分比误差)是比较建议模型的整体预测精度的一种快速简便的方法-MAPE 越低，预测精度越好。比较前面讨论的每个模型的 MAPE，很容易看出季节性 ARIMA 模型提供了最佳的预测精度。请注意，有几种其他类型的比较统计数据可用于模型比较。

Table 3: Model Error Rate Comparison

摘要

总之，建立一个强大的时间序列预测模型的诀窍是尽可能多地去除噪声(趋势、季节和自相关)，这样数据中唯一剩下的未解释的运动就是纯粹的随机性。对于我们的数据，我们发现带有回归变量的季节性 ARIMA 模型提供了最准确的预测。与上面提到的简单模型、平均模型和 ESM 模型相比，ARIMA 模型的预测更加准确。

虽然没有时间序列模型能够帮助你的爱情生活，但有许多类型的时间序列模型可以帮助你预测从页面浏览量到能源销售的任何事情。准确预测您感兴趣的变量的关键是，首先，理解您的数据，其次，应用最符合您的数据需求的模型。

最初发表于【www.kdnuggets.com】。

时间序列预测— ARIMA 模型

原文：https://towardsdatascience.com/time-series-forecasting-arima-models-7f221e9eee06?source=collection_archive---------1-----------------------

ARIMA 代表自回归综合移动平均线。有季节性和非季节性 ARIMA 模型可用于预测

非季节性 ARIMA 模型:

这种方法需要考虑三个变量

P =滞后时段，例如:(如果 P= 3，则我们将在计算的自回归部分使用时间序列的前三个时段)P 有助于调整预测序列的拟合线

纯自回归模型类似于线性回归，其中预测变量是 P 个前期

a 在 ARIMA 模型中，我们使用差分将时间序列转换为平稳序列(没有趋势或季节性的序列)。d 指时间序列达到稳定状态所需的差分变换次数。

平稳时间序列是指均值和方差在一段时间内保持不变。当数列平稳时更容易预测。

差分是一种将非平稳时间序列转化为平稳时间序列的方法。这是为 ARIMA 模型准备数据的重要一步。

第一差值是当前时间段和先前时间段之间的差值。如果这些值不能围绕恒定的平均值和方差旋转，那么我们使用第一个差分的值找到第二个差分。我们重复这个过程，直到得到一个平稳序列

确定序列是否充分差分的最佳方法是绘制差分序列，并检查是否有恒定的均值和方差。

Q =该变量表示误差分量的滞后，其中误差分量是时间序列的一部分，不能用趋势或季节性来解释

自相关函数图(ACF):

自相关是指时间序列与其过去值的相关程度，而 ACF 是用于查看点之间相关性的图，直到并包括滞后单位。在 ACF 中，相关系数在 x 轴上，而滞后数在 y 轴上显示。

自相关函数图将让您了解给定的时间序列如何与其自身相关

通常在 ARIMA 模型中，我们使用 AR 项或 MA 项。我们只是在极少数情况下才使用这两个术语。我们使用 ACF 图来决定在我们的时间序列中使用哪一项

如果在滞后 1 处有一个正自相关，那么我们使用 AR 模型

如果在滞后 1 处有一个负自相关，那么我们使用 MA 模型

在绘制 ACF 图之后，我们转向部分自相关函数图(PACF)。偏相关是时间序列中的观测值与先前时间步的观测值之间关系的总结，其中插入观测值的关系已被移除。

滞后 k 处的部分自相关是在去除了由较短滞后处的项引起的任何相关的影响之后得到的相关。

如果 PACF 曲线在滞后 n 处下降，那么使用 AR(n)模型，如果 PACF 曲线的下降更加平缓，那么我们使用 MA 项

自回归成分:纯粹的 ar 模型仅使用过去值的组合进行预测，类似于线性回归，其中使用的 AR 项的数量与预测中考虑的以前期间的数量成正比。

在模型中使用 AR 术语

• ACF 图显示自相关向零衰减
• PACF 曲线很快接近零
• 平稳序列的 ACF 在滞后-1 时为正

移动平均线:时间序列图中的随机跳跃，其影响在两个或多个连续的时间段内都能感觉到。这些跳跃代表在我们的 ARIMA 模型中计算的误差，并代表 MA 分量将滞后的情况。一个纯粹的 MA 模型会像指数平滑法一样平滑这些突然的跳跃。

当模型符合以下条件时，在模型中使用 MA 术语

• 滞后-1 时负自相关
• 几个滞后之后急剧下降的 ACF
• PACF 逐渐减少

综合成分:当时间序列不稳定时，该成分开始起作用。我们必须对级数求差以使其稳定的次数就是积分分量的参数(I 项)

我们可以用 ARIMA(ar-term，ma-term，i-term)表示我们的模型

找到正确的模型是一个迭代过程。

季节性 ARIMA (SARIMA)款:

顾名思义，当时间序列表现出季节性时，就使用这种模型。这个模型类似于 ARIMA 模型，我们只需要添加一些参数来解释季节

我们把萨里玛写成

ARIMA(p，D，Q)，

• p —自回归的次数
• d——差异程度
• q —移动平均项的数量
• m —指每个季节的周期数
• (P，D，Q)-表示时间序列季节性部分的(P，D，Q)

季节性差异考虑了季节和当前值与上一季度值的差异，例如:月份差异可能是 2018 年 5 月的值-2017 年 5 月的值。

• 在纯季节性 AR 模型中，ACF 衰减缓慢，而 PACF 截止到零
• 当季节性自相关为正时，使用 AR 模型
• 在纯季节性 MA 模型中，ACF 截止到零，反之亦然
• 当季节性自相关为负时，使用 MA 模型

最后的步骤

• 第一步——检查平稳性:如果一个时间序列有趋势或季节性成分，在我们可以使用 ARIMA 预测之前，它必须是平稳的。。
• 第二步—差分:如果时间序列不是平稳的，需要通过差分来平稳化。取第一个差值，然后检查平稳性。尽可能多地接受差异。一定要检查季节差异。
• 第三步——过滤出一个验证样本:这将用于验证我们的模型有多准确。使用列车测试验证分割来实现这一点
• 步骤 4 —选择 AR 和 MA 术语:使用 ACF 和 PACF 来决定是否包括 AR 术语、MA 术语或两者都包括。
• 步骤 5 —建立模型:建立模型，并将预测的周期数设置为 N(取决于您的需求)。
• 步骤 6 —验证模型:将预测值与验证样本中的实际值进行比较。

我也附上我的回购代码:))))))

[## sangarshanan/时间序列预测

了解时间序列预测。为 Sangarshanan/时间序列预测的发展作出贡献

github.com](https://github.com/Sangarshanan/Time-Series-Forecasting)

时间序列预测流程

原文：https://towardsdatascience.com/time-series-forecasting-flow-2e49740664de?source=collection_archive---------14-----------------------

需求预测的关键步骤简介

C 收集

这里的关键是数据存储的格式。

直观上，我们认为时间序列数据的格式如下，也称为宽格式。

然而，宽格式对于基于 SQL 的存储是不利的，因为当我们添加新日期时，我们需要向表中添加另一列，因此，最佳实践是以 long 格式存储数据，如下所示。

这里值得一提的另一件事是，由于我们很可能在这里预测多个产品，一种方便的方法是使用 Python 字典，其中键是产品 ID，值是长数据格式(基本上是一个数据帧)。所以我们最终得到了一个数据框架的字典。

清洗

这里的清洁很标准。基本上我们寻找异常值。通常的做法是，如果我们有奇怪的值，比如需求的固定负数(通常大于或等于 0)，我们就丢弃它们。这里我们需要寻找的另一件事是丢失的值。我们可以使用 pandas fillna 函数，在该函数中，我们指定是否要用 0 来替换它们，或者用诸如 last demand(回填)这样的方法来替换它们。

测试

也称为回溯测试。基本上最常见的两种开窗方式，一种是滑动(训练和预测时间固定)，一种是扩展(训练数据长度一次增加 x)。优步做了一项伟大的工作，将以下两种方法形象化。

常见的评估指标包括 MAPE、wMAPE、sMAPE，以及 RMSE 和 RMLSE(如果数据分布是偏斜的)。

M 造型

这里最重要的一点是，通常简单的方法(如所有数据点的平均值)优于更复杂的 ARIMA。FB 的 prophet 包(用 R 和 Python 两种语言)也可以是一个首选算法。

E 估价

在评估性能时，我们可以尝试不同的训练和预测长度，以更好地理解我们的数据以及所使用的算法。例如，当训练数据为 1 周，预测数据为下一周时，Naive 方法表现极佳；在训练和预测方面，当我们拥有更长的数据长度时，ARIMA 会大放异彩。换句话说，我们需要首先确定我们的业务用例，无论是短期预测还是长期预测，这样我们才能更好地评估来自不同算法的结果。

问问题？

jchen6912@gmail.com

最佳气体补充的时间序列预测

原文：https://towardsdatascience.com/time-series-forecasting-for-optimal-gas-refill-88650b1cf029?source=collection_archive---------4-----------------------

Aral petrol station in the mountainous region of Bamberg — Reinhold Möller

你有没有遇到过这样的情况，当你开车经过一个加油站，当你昨天支付的价格比现在高很多时，你变得沮丧？别担心！我们可以用数据科学来克服这个问题！我们可以把这个问题变成一个预测问题。在这篇文章中，我们将建立一个模型来预测你应该今天还是明天补充。

The idea of the data science solution. We want to forecast if the price increases by looking at the past.

数据

2013 年，德国联邦政府决定建立一个中央组织，收集德国所有加油站的油价数据。所有加油站都被迫提供气价变化。数据是公开的，有很多应用程序可以让你看到这些数据。我们将使用这些数据来解决我们的预测问题。数据可以从https://creativecommons.tankerkoenig.de/下载。数据存储为 PostgreSQL 转储。包含了 2015 年 5 月以来的所有气价。解压缩数据后，您可以使用以下命令将它们放入本地 PostgreSQL 数据库:

C:\Program Files\PostgreSQL\10\bin>psql.exe -U postgres -f “C:\…\history.dump”

在 RapidMiner 中实现这一点很容易:你需要将 PostgreSQL 数据库连接到你的工作室，并使用 Read Database 操作符。

RapidMiner process to get the data into it. The Read Database operator contains the SQL-script which is posted below.

在我的特例中，我想为一个加油站这样做:位于多特蒙德 Westfalendamm 的 ARAL 加油站。这是德国 RapidMiner 办公室正前方的加油站。因此，我们使用一个快速 SQL 查询来获取这个加油站的所有数据:

SELECT * FROM gas_station_information_history
JOIN gas_station
ON gas_station.id = gas_station_information_history.stid
WHERE gas_station.street = ‘Westfalendamm’ AND brand = ‘ARAL’

存储后，我们可以看看数据。

数据准备

两个基本属性是“日期”和“e10”，其中 e10 表示含 10%乙醇的标准气体。

A view of the data. E10 is premium gasoline. The original data set also contains the prices for diesel as well as additional data on the station.

这里的问题是数据没有等距的时间戳。它只记录数据的每次变化。我们想要生成什么样的数据集:

Aug 26, 2016, 4PM — 1269Aug 26, 2016, 5PM — 1269Aug 26, 2016, 6PM — 1269….

这将使我们的数据每小时均衡一次。为此，我们首先创建一个示例集，如下所示:

Data set after equalization

我们将它附加到原始集合中，对其进行排序，得到下表:

The original data set and the equalized data set combined. We can fill the missing data using the previous values to get the price at a given time.

我们用最后一个存在的前一个值来填充缺失的值，并通过过滤“isEqualized”来过滤掉原始数据。RapidMiner 流程如下所示:

RapidMiner process for the preprocessing.

数据集现在是干净的，我们可以继续进行特征生成和建模。

特征生成

首先，我们生成一个标签。请记住，我们想要解决这个问题:我是今天还是明天再加注？因此，我们的标签是当前价格和 24 小时内价格之间的差异。由此我们可以生成一个表示价格上涨的二项式标签。

下一步是特征生成。首先，我们对数据进行窗口处理。窗口意味着我们在当前行中包含过去 48 小时的所有价格。结果数据集如下所示:

Windowed data set in RapidMiner. e10–47 indicates the price 47 hours before, e10–46 the price 46h ago and so.

因为我早上 8 点到达办公室，所以我想预测现在或明天早上 8 点补充是否有意义。因此，我只查看上午 8 点的数据，并过滤掉其余的数据。特征准备的完整 RapidMiner 过程如下所示:

我们为每个数据点生成一个特征向量。这已经足够训练一个模特了。

系统模型化

我们现在有了一个可以学习的完美数据集。我用一个广义线性模型来预测我们的标签。对于这样的第一次尝试，结果是好的:

Confusion Matrix for the GLM. The confusion matrix is estimated using a 10-fold Cross Validation.

该模型的 AUC 为 0.7。虽然这并不完美，但仍然比默认模型要好！

基于 LSTMs 和 Prophet 的时间序列预测

原文：https://towardsdatascience.com/time-series-forecasting-with-lstms-and-prophet-predict-your-email-workload-48bf9cdb1580?source=collection_archive---------6-----------------------

Image via photodune.net under license to mtstrauss

预测您的电子邮件工作量

ime 系列预测为测试数据科学算法提供了一个绝佳的平台。毕竟，如果一个人能够预测未来，那该有多好？用于演示预测算法的典型数据集是股票图表、销售和气象数据。在这里，我们将尝试一些与每个在线用户更相关的东西，即你将收到的电子邮件的数量。根据一份电子邮件统计报告，2014 年，上班族平均每天收到 85 封电子邮件。让我们试着根据你的历史收件箱数据做一个准确的预测。为此，我们将探讨使用 LSTMs 和脸书的先知。这里的目标是如何为不同的算法准备数据，并提供一个定性的概述，而不是微调。可以说，结果会因你通常收到的电子邮件数量以及你用于训练的数据而有很大差异。

收集数据

我们首先在imapclient包的帮助下用我们自己的收件箱创建一个数据集。一个很好的介绍可以在自动化枯燥的东西上找到，第 16 章。我们将加载过去三年(从 2016 年 1 月 1 日开始)的所有电子邮件，并获取主题和日期。我们使用pandas将它转换成数据帧。

A total of 12738 e-mails loaded.

在我的例子中，我们现在有 12738 封电子邮件用于培训。请注意，上面的代码是针对装满电子邮件的收件箱的。如果你已经将你的电子邮件分类在不同的文件夹中，相应地调整代码。有些人，包括我自己，会立即删除不重要的电子邮件。然后，模型的输出是重要消息的数量，而不是实际的电子邮件。另请注意，一些电子邮件提供商(如谷歌)会阻止连接，称他们不允许从“不太安全”的应用程序连接到他们的服务。这可以在他们的设置中启用。原则上，你也可以查看本地邮箱。查看mailbox套餐可能是一个好的开始。

数据探索

现在，让我们先做一些可视化数据探索，并绘制每小时和每天的电子邮件数量。为此，我们将使用pandas及其重采样和groubpy功能。通过使用sum()和count()参数，我们可以对每个时间间隔进行标准化。此外，我们使用seaborn进行可视化。

Figure 1: Exploring the data

从数据中，我们可以看到一个独特的模式，即分布遵循典型的周一至周五 9-5 时间表，上午 10 点收到的电子邮件最多。由于每小时电子邮件的峰值数量仅略高于一封电子邮件，因此尝试对此数据集进行每小时预测没有什么意义。因此，我们将尝试预测每天的电子邮件工作量。

初步考虑:预测不可预测的事情

在我们深入研究我们的模型之前，有必要考虑一下我们问题的一些主要限制。可以说，接收电子邮件的时间点在某种程度上是随机的，因此无法预测。在大多数情况下，发送者并不知道对方是谁；因此，我们可以假设它们在统计上是独立的。作为估计，我们可以将我们的过程近似为泊松过程，其标准偏差等于其平均值的平方根。对于大约 12 封电子邮件，我们预计 RMSE 至少为 3.5，这完全是由于我们分布的随机性(sqrt(11.95) ~ 3.461)。
为了进一步阅读，我推荐阅读关于二郎分布的文章，该分布被开发用于检查在某个时间段内打电话的次数。

计算基线

为了创建基线模型，我们可以使用来自历史数据的查找表。在过去的某一天，我收到了多少封电子邮件？为了对模型进行基准测试，我使用一个移动窗口来创建我的查找表，并计算第二天的预测差异。

RMSE for BASELINE 7.39

对于基线模型，我们得到 7.39 的 RMSE，我认为，相对于至少 3.5 的预期 RMSE，这是一个不错的值。

与 LSTM 的电子邮件预测

作为更高级的模型，我们将使用长短期记忆(LSTM)神经网络。关于 LSTMs 的精彩介绍可以在这里找到。对于我们的模型，我们将使用 6 天的窗口大小，并让模型预测第七天。

RMSE for LSTM 7.90

Figure 2: Training the LSTM

通过观察损失，我们可以看到 LSTM 网络正在学习，并且在预测未来价值方面变得越来越好。我们还可以看到，RMSE 比基线模型差一点。虽然名义上的差异并不大，但它与基线模型的接近程度确实令人瞩目。这表明网络能够学习一周的工作结构，在周末你会收到较少的电子邮件。

另一件值得一提的事情是，我们不能直接比较基线的 RMSE 和 LSTM。这是因为我们为基线的滚动预测转移了训练数据，而 LSTM 只看到了 80%的训练数据。你也可以这样做来训练 LSTM；然而，这在计算上将更加昂贵。

先知的电子邮件预测

接下来，我们将使用脸书的先知库创建一个模型。这是一个加法模型，我们可以用每年、每周和每天的季节性来拟合非线性趋势。同样，为了对模型进行基准测试，我们将把数据分成训练集和测试集，并计算 RMSE。与基线模型类似，我们将增加拟合数据的数量，并计算 RMSE。

RMSE for PROPHET 6.96

从 RMSE 基准测试来看，Prophet 模型是数据集性能最好的模型。现在让我们试着理解这是为什么。为此，我们绘制了模型的组成部分，以更好地理解模型正在做什么。这可以通过在我们的模型上使用performance_metrics函数来完成。

from fbprophet.diagnostics import performance_metrics
prophet_model.plot_components(prophet_forecast)

Figure 3: Components of the Prophet model

通过检查 Prophet 模型的组件，我们可以看到它可以识别数据中的关键趋势。总的趋势是电子邮件的总体增长。每周季节性准确地描述了工作日/周末时间表。一年中的季节性表现在重大节日，即新年期间电子邮件很少，但圣诞节前会增加。9 月份也是低点，9 月份是数据集所在国家的重要节假日。因此，可以理解为什么性能相当好。

综合起来:电子邮件预测

最后，我们将部署 Prophet 模型作为预测工具。为此，我们再次登录 IMAP 服务器，并使用自 2016 年 1 月 1 日以来的所有历史数据来训练我们的预测模型。在训练模型之后，我们绘制前一周的历史数据和下一周的预测。

Figure 4: E-mail forecast for the upcoming week

讨论

LSTMs 和脸书的 prophet 提供了一种直接的方法，可以相当准确地预测电子邮件数据。当考虑到模型的基本机制时，我认为这是可以理解的。LSTM 预测是基于一组最后的值，因此我们不太容易因季节性变化，并已经考虑了当前的趋势。与此形成对比的是，prophet 模型作为一个附加系统在建模方面做得很好，它发现并展示了季节性。当谈到规划未来的工作量或人员配备时，我发现这是您正在寻找的信息。现在可以对模型进行微调。这类问题的一个关键挑战是，如果你只有零星的事件，内在的随机性将是不可预测的。
最后，我们不要忘记，我们已经有了一个很好的基线模型，它强调预测模型不一定总是需要复杂的 ML 算法。

基于递归神经网络的时间序列预测

原文：https://towardsdatascience.com/time-series-forecasting-with-rnns-ff22683bbbb0?source=collection_archive---------8-----------------------

在这篇文章中，我想给你一个我建立的预测时间序列数据的 RNN 模型的概述。这项工作的主要目标是设计一个模型，该模型不仅可以预测下一个时间步，还可以生成一系列预测，并利用多个行驶时间序列以及一组静态(标量)特征作为其输入。

模型架构

在高层次上，该模型利用了非常标准的序列到序列递归神经网络架构。其输入是预测时间序列的过去值，与其他驱动时间序列值(可选)和时间戳嵌入(可选)连接在一起。如果静态特征可用，模型也可以利用它们来调节预测。

编码器

编码器用于将时间序列输入及其各自的时间戳嵌入[ x ]编码为固定大小的向量表示[ S ]。它还为单独的时间步长[ h ]产生潜在向量，这些潜在向量稍后用于解码器关注。为此，我利用了一个多层单向递归神经网络，其中除了第一层之外的所有层都是残差。

Fig. 1. — Example 2-layer encoder

在某些情况下，您可能有太长的输入序列，可能会导致训练失败，因为 GPU 内存问题或大大降低它的速度。为了处理这个问题，该模型将输入序列与具有相同内核大小和步长的 1D 卷积进行卷积，然后将其馈送到 RNN 编码器。这将 RNN 输入减少了 n 倍，其中 n 是卷积核的大小。

语境

Fig. 2. — Context layer

上下文层位于输入编码器和解码器层之间。它将编码器最终状态[ S ]与静态特征和静态嵌入连接起来，并产生一个固定大小的向量[ C ，该向量随后被用作解码器的初始状态。

解码器

解码器层被实现为具有注意力的自回归递归神经网络。每一步输入都是先前序列值和为该步骤嵌入的时间戳的串联。向解码器提供时间戳嵌入有助于模型学习季节性数据中的模式。

Fig. 3. — Decoder layer

在第一步，编码器将上下文[ C ]作为初始单元值，并将初始序列值[ v 和第一时间戳嵌入[ E ]的串联作为单元输入。然后，第一层发出注意查询[ q ]，该查询被馈送到注意模块，该模块输出状态[ s ]，该状态然后被用作下一步骤中的单元状态。解码器的较低层不使用注意力。解码器[ o ]的输出是原始预测值，这些预测值随后与为该步骤嵌入的时间戳一起被馈送到下一步骤。

注意

Fig. 4. — Attention

注意允许解码器在解码期间选择性地访问编码器信息。这是通过学习加权函数来实现的，该加权函数将先前的单元状态[ q ]和编码器输出列表[ h ]作为输入，并输出每个编码器输出的标量权重。然后，它取编码器输出的加权和，将其与查询连接，并取非线性投影作为下一个单元状态。从数学上讲，这可以表述如下:

Eqn. 1. — Attention function

数据准备

在本文中，我不会一步一步地指导如何为序列对序列学习问题准备数据，但我会尝试向您概述让模型工作所需的步骤。

首先，您需要确保时间序列要素的范围不与目标的范围重叠，并且最新的要素时间戳正好在第一个目标时间戳之前。此外，如果您有任何静态特性(例如聚合统计)，它们需要聚合到最后一个特性时间戳。我知道这听起来是显而易见的，但有时真的很容易忽略，并为您的模型表现如此之好而兴奋，只是发现您将未来的信息泄露到了您的训练数据集中。

数据，包括特征和目标，需要被标准化为神经网络模型的合适范围。这通常意味着在 -1 和 1 之间的某处。我决定采用的标准化方案是首先采用一个对数来消除任何潜在的偏差，然后计算一个平均值和标准偏差。然后，网络的输入是日志的 z 分数。

Eqn. 2. — Features normalization

对于目标值，有多个标准化选项。例如，可以使用我在上面描述的类似方法预测最新输入值(如果输入值为 0，这可能是一个问题)或归一化绝对值的相对变化。

结果

作为本文的一个例子，我使用上面描述的模型来预测 Shopify 股票未来五个交易日的收盘价，给定过去六十个交易日的数据。内核/步距= 5 的输入序列卷积层用于将编码器 RNN 输入大小从 60 步减少到 12 步。

Chart 1. — Shopify closing price

有人可能会说，在不考虑新闻等其他因素的情况下，股价是不可预测的(即使这样也很难)。这就是为什么我决定使用另外六个报价器(苹果、亚马逊、谷歌、脸书、微软和 IBM)作为模型的输入，以便它可以学习它们之间可能的相关性。使用的特征是每日开盘价、最高价、最低价、收盘价(OHLC)和成交量。我用“spread”(abs(high-low))和每个特征的过去 60 天平均值作为静态输入来扩充时间序列特征。

Chart 2. — MAE by day

图表 2。显示每天的平均绝对误差。我们可以看到，我们对未来的预测越深入，就越糟糕。从直觉上来说，这是有意义的，因为该模型对下一个交易日的预测比五天后的预测更好。

正如每一个机器学习模型一样，有模型做出非常好的预测的成功，也有预测不太好的失败。以下是这种情况的一些例子。

Chart 3. — Successes

Chart 4. — Failures

结论

递归神经网络是对序列数据建模的有力工具。本文中描述的模型可以应用于从销售预测到能源消耗预测的许多问题。它可以根据多元输入序列和标量输入来调整其预测，这使得它足够灵活，可以合并多个数据源。Tensorflow 实现的模型可以在这里找到。

如果你喜欢这篇文章，请推荐给其他人。另外，如果你有任何建议，请在下面留下你的评论。

使用 Splunk 进行时间序列预测。第一部分介绍&卡尔曼滤波器。

原文：https://towardsdatascience.com/time-series-forecasting-with-splunk-part-i-intro-kalman-filter-46e4bff1abff?source=collection_archive---------3-----------------------

让我们考虑一个比调整仪表板上的输入字段更实际的任务。

时间序列预测是数据分析中一项非常典型的任务。Splunk ML Toolkit 为此任务提供了两种众所周知的方法:卡尔曼滤波和 ARIMA。不幸的是，当遇到实际问题时，这些方法有时会失败。因此，让我们仔细研究一下它们，然后考虑 Splunk 中时间序列预测的一些其他技术。

工作

好了，我们来定义一个目标。让我们使用 Splunk 来监控一些指标，例如登录系统的次数、数据库中的事务数等。我们希望分析我们业务的增长(例如，为了容量规划和资源管理)。作为分析的一部分，我们希望根据过去几年的数据预测一年的登录次数。

Number of logins (max hour per day) from 2015 to 2017

如你所见，这是一个很普通的任务。但是让我们用灵活性的要求使它变得更复杂。因为监控不是唯一的指标，我们的方法或算法必须非常通用，以预测几乎任何指标，而无需用户进行大量调整。毕竟，我们需要构建一个具有这种功能的仪表板:用户选择一个指标，指定几个调优参数，并获得所选指标一年的适当预测。

趋势、季节性和平稳性

我们来刷新一下关于时间序列的一些基本概念。一般来说，时间序列可以分解成几个部分:趋势部分、季节部分和残差部分。趋势是时间序列值变化的一个大致方向。例如，上升趋势意味着时间序列的值平均比以前的值大。季节性成分代表数据中的一些周期性波动。例如，夜间的登录次数总是比白天少，工作日的登录次数总是比周末多。残差分量是时间序列值和确定性分量(趋势、季节性)之间的差值，通常代表某种噪声。

有两种主要的模型来处理这些组件。在加法模型中，初始时间序列表示为分量之和，在乘法模型中表示为它们的乘积。有时候，选择哪种模式可能是一个艰难的选择。一般来说，如果季节性波动的幅度随着时间的推移而增加，则乘法模型更为可取。

对于每个时间序列，我们可以计算均值、方差和自相关。如果这些参数随时间保持不变，则时间序列是稳定的。在下图中，您可以找到一些平稳(蓝色)和非平稳(黄色、红色、紫色)时间序列的示例。

Examples of stationary and non-stationary time series

‘蓝色’系列的均值和方差分别等于 0 和 1，所以这个系列是平稳的。“黄色”系列显示出增加的趋势，即平均值不是常数。“红色”序列表现出明显的日季节性，即自相关函数在滞后 24、48……小时时有一个局部最大值，而且它也不是常数。“紫罗兰”系列表现出增加的趋势和扰动，即均值和方差也不是常数。

真实世界的时间序列很少是平稳的。但是有很多技术和变换可以把它们变成静态的。

让我们打开 ML Toolkit 并尝试预测我们的系列。

卡尔曼滤波器

卡尔曼滤波是一种产生未知变量估计值的算法，这种估计值往往比基于单一测量值的估计值更准确(抱歉，我复制了来自维基文章的定义)。换句话说，卡尔曼滤波器将时间序列作为输入，并执行某种平滑和去噪。在此之后，可以预测平滑的序列。但是应该考虑到卡尔曼滤波首先是去噪，而不是预测。这就是为什么预测的结果可能有点不合适。

进入助手>预测时间序列，选择卡尔曼滤波器作为算法。

Let’s get it started

ML 工具包提供了几种预测方法:

• LL(地方水平)仅预测时间序列的地方水平(没有任何趋势或季节性)；
• LLT(本地级别趋势)仅预测趋势；
• LLP(季节性当地水平)仅预测季节性成分；
• LLP5(结合了 LLT 和 LLP)考虑了趋势和季节性。

玩具示例

首先，让我们尝试将卡尔曼滤波器应用于上述示例中的一个非平稳时间序列，以检查平滑能力。让我们选择“黄色”系列—它只是恒定趋势和正态分布噪声的总和。我是通过这个 SPL 查询得到它的(normal是一个定制的外部命令，它从分别在loc和scale参数中指定的字段返回一个具有均值和方差的正态分布值):

| gentimes start=”01/01/2018" increment=1h
| eval _time=starttime, loc=0, scale=20
| normal loc=loc scale=scale 
| streamstats count as cnt
| eval gen_normal = gen_normal + cnt
| table _time, gen_normal
| rename gen_normal as “Non-stationary time series (trend)”

好的，让我们用“LLT”算法应用卡尔曼滤波器，未来时间跨度= 200，置信区间= 95。

Kalman filtering with LLT forecasting

看起来不错。滤波器真正去除正态分布的噪声，并预测实际趋势。

真实的谈话

现在让我们尝试预测我们的登录次数。我们的时间序列显然包括趋势和季节成分，所以让我们选择预测算法= LLP5，未来时间跨度= 365(预测一年)，周期= 365(因为我们预计这个季节周期是最长的)。

Kalman filter with LLP5 forecasting of number of logins

嗯……很明显，结果有点出乎意料。似乎过滤器认为我们的数据波动是一种噪音。因此，滤波器消除了这种噪声，只保留了趋势分量。但有点令人困惑的是，算法中负责季节性成分的“LLP”部分根本不起作用。反正这个预测是不能接受的。

然而，也有一线希望。首先，置信区间的上下界对于离群点检测非常有用。第二，不可否认，趋势成分的预测相当不错。所以，让我们试着过滤掉所有的异常值，从初始数据中去除趋势成分。请注意，初始时间序列的方差随着时间的推移而增加。这就是为什么乘法模型似乎更适合我们的情况。所以，让我们用初始值除以趋势分量的值。

| inputlookup daylogins.csv
| timechart span=1d fixedrange=f max(daylogins) as daylogins
| predict “daylogins” as prediction algorithm=”LLT” future_timespan=365 period=365 lower”95"=lower”95" upper”95"=upper”95"
| eval daylogins = case(daylogins < ‘lower95(prediction)’, ‘lower95(prediction)’, daylogins > ‘upper95(prediction)’, ‘upper95(prediction)’, 1=1, daylogins)
| eval season = daylogins / prediction
| table _time, season
| where _time<strptime(“2018–01–01”, “%F”)

这里我在 SPL 使用了一个predict命令。这是一个卡尔曼滤波的命令，你可以通过点击“预测时间序列”仪表板上的“显示 SPL”按钮来检查它。

将方法更改为 LLP，然后单击“预测”。

Forecast of seasonal component

嗯，还不错。主要的季节性特征(比如新年后的大衰退)几乎被完美地捕捉和预测。

俄罗斯有一个延长的新年假期。它开始于 1 月 1 日，持续约 8-10 天(实际持续时间每年不同)。它指出，在那些日子里，许多地区的用户活动比其他日子少得多。

但是，一如既往，细节决定成败。看看新年假期后预测的峰值。好像和一年前一样。实际上，它们看起来太相似了。请注意，在 2015 年和 2016 年，没有任何类似的峰值。如果关闭异常值移除，相似性会变得更加明显。

Forecast seems to be just a copy of the last period of data

预测中会重复 2017 年 2 月的异常值，但不会重复 2016 年 5 月的异常值。因此，似乎卡尔曼滤波器与 LLP 算法高估了最后一段时间的价值(在我们的情况下是最后 365 天)，而不理会相应的前一段时间的价值。

同样的情况也发生在除夕夜的旺季。

然而，卡尔曼滤波的这种特性并没有使这种预测完全不充分。如果我们真的只想依赖最近一段时间的数据，这可能会有用。例如，我们将根据前几周的数据预测一周的登录次数，以便实时检测关键问题。如果登录次数显著减少，这可能意味着认证服务器的可用性或类似的一些问题。对于这种监控，我们可以创建一个简单明了的预测，只需将新数据与置信区间的界限进行比较。

Week forecast for the data completeness check

好吧，让我们回到最初的一年预测。尽管有明显的缺点，我们的时间序列的季节成分的预测是相当合理的。因此，让我们将预测的趋势分量乘以预测的季节分量，以恢复到所需的登录次数。

| inputlookup daylogins.csv 
| timechart span=1d fixedrange=f max(daylogins) as daylogins 
| predict "daylogins" as prediction algorithm="LLT" future_timespan=365 lower"95"=lower"95" upper"95"=upper"95" 
| eval daylogins = case(daylogins < 'lower95(prediction)', 'lower95(prediction)', daylogins > 'upper95(prediction)', 'upper95(prediction)', 1=1, daylogins) 
| eval season = daylogins / prediction 
| predict "season" as season_prediction algorithm="LLP" future_timespan=365 period=365 lower"0"=lower"0" upper"0"=upper"0"
| eval prediction = prediction * season_prediction
| table _time, daylogins, prediction
| eval prediction = if(isnull(daylogins), prediction, null)
| where _time<strptime("2019-01-01", "%F")

Forecast of number of logins using Kalman filtering

看起来很不错。注意，我最终在没有 ML Toolkit Assistant GUI 的情况下在纯 SPL 实现了这个预测。因此，我可以将该搜索插入到任何应用程序的任何仪表板中(只需考虑知识对象的权限)。我需要指定的唯一参数是季节成分的周期(即多重季节性情况下的最大季节周期)。您可以允许用户通过简单的输入文本框在仪表板上指定此参数，默认值为 365。还可以使用傅立叶变换或分析自相关函数来自动计算最大季节周期(我想我们稍后会谈到这一点)。

未完待续…

下面我们简单回顾一下 Splunk 中的卡尔曼滤波器。

• 这是一个简单而有用的时间序列预测工具。
• 人们只需一个 SPL 命令就可以轻松创建预测，而无需调整大量参数。
• 滤波器(顾名思义)在平滑噪声时间序列方面表现良好。

但是这种简单意味着缺乏灵活性。

• 你根本无法控制季节周期。在多重季节性的情况下，你只能依靠过滤器的内部算法。
• 季节性预测很少考虑最后一段时间以外的值。
• 没有任何类似“平滑系数”的参数用于“去噪灵敏度”的调节。因此，滤波器有时会执行非常激进的平滑，并且会导致有价值信息的丢失。

好吧，今晚到此为止。在下一部分，让我们更仔细地看看 Splunk 中的 ARIMA 。敬请期待！

时序嵌套交叉验证

原文：https://towardsdatascience.com/time-series-nested-cross-validation-76adba623eb9?source=collection_archive---------0-----------------------

这篇博文讨论了对时间序列数据使用传统交叉验证的缺陷。具体来说，我们解决了 1)在不导致数据泄漏的情况下分割时间序列，2)使用嵌套交叉验证来获得独立测试集的无偏误差估计，以及 3)使用包含多个时间序列的数据集进行交叉验证。

用例

这篇文章是对缺乏关于如何对包含多个时间序列的数据使用交叉验证的在线信息的回应。

这篇文章将帮助任何有时间序列数据的人，特别是多个独立的时间序列。这些方法是为医学研究中多个参与者的时间序列医学数据而设计的。

交叉验证

交叉验证(CV)是一种用于调整超参数和产生模型性能的稳健测量的流行技术。两种最常见的交叉验证是k-折叠交叉验证和保留交叉验证。

由于文献中术语的差异，我们明确定义了我们的 CV 程序。首先，我们将数据集分成一个称为训练集的子集和另一个称为测试集的子集。如果需要调整任何参数，我们将训练集分成一个训练子集和一个验证集。在训练子集上训练模型，并且选择最小化验证集上的误差的参数。最后，使用选择的参数在完整的训练集上训练模型，并记录测试集上的误差。

Figure 1: Example of hold-out cross-validation. The data is split into a training set and a testing set. Then the training set is split again to tune hyperparameters- one part is used to train the model (training subset) and the other part (validation set) is used to validate the model.

为什么时间序列的交叉验证不同？

在处理时间序列数据时，传统的交叉验证(如 k -fold)不应使用，原因有二:

1. 时间依赖性

对于时间序列数据，在分割数据时必须特别小心，以防止数据泄漏。为了准确地模拟“真实世界的预测环境，我们站在现在并预测未来”(Tashman 2000)，预测者必须保留在用于拟合模型的事件之后按时间顺序发生的事件的所有数据。因此，对于时间序列数据，我们使用保留交叉验证，而不是使用 k 折叠交叉验证，其中数据的子集(暂时分割)被保留用于验证模型性能。例如，参见图 1，其中测试集数据按时间顺序排在训练集之后。类似地，验证集按时间顺序排在训练子集之后。

2.任意选择测试集

您可能会注意到，图 1 中测试集的选择是相当随意的，这种选择可能意味着我们的测试集误差是对独立测试集误差的糟糕估计。为了解决这个问题，我们使用了一种叫做嵌套交叉验证的方法。嵌套 CV 包含一个用于误差估计的外环和一个用于参数调整的内环(见图 2)。内部循环的工作方式与前面讨论的完全一样:将训练集分为训练子集和验证集，在训练子集上训练模型，并选择使验证集上的误差最小化的参数。然而，现在我们添加了一个外部循环，它将数据集分成多个不同的训练和测试集，并且对每次分割的误差进行平均，以便计算模型误差的稳健估计。这是有利的，因为:

嵌套的交叉验证过程提供了真实误差的几乎无偏的估计。(瓦尔马和西蒙，2006 年)

Figure 2: Nested CV Example

时间序列的嵌套 CV 方法

我们建议用两种方法对单一时间序列的数据进行嵌套 CV。我们将处理这样一个场景，其中我们有来自一个医疗患者/参与者的多天数据:

1. 预测下半年
2. 日正向链接

预测下半年

第一种类型，预测后半部分，是嵌套 CV 的“基本情况”,只有一个训练/测试分割。这样做的好处是这种方法易于实现；然而，它仍然受到任意选择的测试集的限制。数据的前半部分(在时间上分开)被分配给训练集，后半部分成为测试集。验证集的大小可以根据给定的问题而变化(例如，在图 3 的示例中是 1 天的数据)，但是确保验证集在时间上在训练子集之后是很重要的。

Figure 3: Predict Second Half Nested Cross-Validation

日前向连锁

预测后半部分嵌套交叉验证方法的一个缺点是，任意选择保留测试集会对独立测试集产生预测误差的有偏估计。为了更好地估计模型预测误差，通常的方法是创建许多训练/测试分割，并对所有分割的误差进行平均。我们使用的技术称为日前向链，基于一种称为前向链的方法(在文献中也称为滚动原点评估(Tashman 2000 年)和滚动原点重新校准评估(Bergmeir 和 bentez 2012 年))。使用这种方法，我们连续地将每一天作为测试集，并将所有以前的数据分配到训练集中。例如，如果我们的数据集有五天，那么我们将产生三个不同的训练和测试分割，如图 4 所示。请注意，在本例中，我们有三次拆分，而不是五次，因为我们需要确保至少有一天的培训和验证数据可用。该方法产生许多不同的训练/测试分割，并且对每个分割的误差进行平均，以便计算模型误差的稳健估计。

Figure 4: Day Forward-Chaining Nested Cross-Validation

请注意，在我们的示例中，我们使用“Day”正向链接；然而，一次也可以迭代每个数据点(但这将意味着更多的分割)，而不是迭代跨越天。

多个时间序列的嵌套交叉验证

既然我们有两种分割单个时间序列的方法，我们讨论如何处理具有多个不同时间序列的数据集。同样，我们使用两种类型:

常规

对于“常规”嵌套交叉验证，如何进行训练/验证/测试分割的基本思想与之前相同。唯一的变化是拆分现在包含了来自我们数据集中每个参与者的数据。例如，如果有两个参与者，参与者 A 和 B，则训练集将包含来自参与者 A 的前半天的数据和来自参与者 B 的前半天的数据。同样，测试集将包含每个参与者的后半天的数据。

人口知情

对于“群体知情嵌套交叉验证”,我们利用不同参与者数据之间的独立性。这使得我们可以打破严格的时间顺序，至少在个体的数据之间(在个体的数据内部仍然是必要的)。由于这种独立性，我们可以稍微修改常规的嵌套交叉验证算法。现在，测试和验证集只包含来自一个参与者的数据，比如说参与者 A，并且来自数据集中所有其他参与者的所有数据都允许出现在训练集中。请参见图 5，了解这对于群体通知日正向链接嵌套交叉验证是如何工作的。该图显示，参与者 A 的第 18 天是测试集(红色)，之前的三天是验证集(黄色)，训练集(绿色)包含来自参与者 A 之前的所有数据，以及来自其余参与者的 all 数据(本例中为 B 、 C 、 D 和 E )。需要强调的重要一点是，正是由于这些参与者的时间序列的独立性，使用其他参与者的“未来”观察结果不会造成数据泄漏。

Figure 5: Population-Informed Day Forward-Chaining, where, in addition to Day Forward-Chaining method (left subfigure) for Participant A, we also allow all other participants’ data to be in the training set (right subfigure). Note that the grey bars indicate when the participant was sleeping.

其他重要的嵌套交叉验证注意事项

最后，我们总结了不同嵌套交叉验证方法的优缺点，特别是在计算时间和独立测试集误差估计的偏差方面。分割数量假设数据集包含 p 名参与者和 d 名参与者的数据。

总结:

我们首先回顾了交叉验证，列举了使用嵌套交叉验证背后的基本原理。我们讨论了如何分割时间序列数据而不导致数据泄漏，特别建议了两种方法:1)预测下半年和 2)日前向链接。然后，我们讨论了如何使用两种方法处理多个独立的时间序列:1)常规方法和 2)群体通知方法。

引文:

C.伯格梅尔和 J. M .贝尼特斯。时间序列预测器评估的交叉验证的使用我 nf。Sci。，2012 年 5 月 191:192–213。ISSN 0020–0255。doi:10.1016/j . ins . 2011 . 12 . 028 . URL hTTP://dx . doi . org/10.1016/j . ins . 2011 . 12 . 028 .

长度 j .塔什曼。预测准确性的样本外检验:分析与评述。国际预测杂志，16(4):437–450，2000 年。URL https://ideas . repec . org/a/eee/int for/v16y 2000 i4p 437-450 . html

南瓦尔玛和西蒙。使用交叉验证进行模型选择时误差估计的偏差。BMC 生物信息学，7(1):91，2006 年 2 月。ISSN 1471–2105。doi:10.1186/1471–2105-7–91。

时机很重要:社交网络中预定的影响力最大化

原文：https://towardsdatascience.com/timing-matters-scheduled-influence-maximization-in-social-networks-2736543fffed?source=collection_archive---------12-----------------------

Influence spread

社交网络领域中的一个高度研究的主题是搜索有影响力的节点，当这些节点被播种(即被有意激活)时，可以通过病毒传染过程进一步激活网络的大部分。实际上，文献中提出了各种数学模型来描述这种扩散过程的动态特性，并提出了不同的解决方案来最大化这种模型的影响。
然而，这些解决方案中的大多数集中在选择一组在扩散过程的初始阶段被播种的节点。

我们最近的出版物( PDF ) 发表在 IEEE 计算社会系统汇刊(D. Goldenberg，A. Sela 和 E. Shmueli) 上，该出版物是特拉维夫大学大数据实验室研究的一部分，提出了一种预定播种方法，该方法不仅旨在找到要播种的最佳节点集，还旨在找到执行这些播种的正确时机。
更具体地说，我们确定了现有传染模型的三个不同属性，可通过预定方法利用这些属性来提高激活节点的总数:

1. 随机动力学
2. 社会效应递减
3. 状态依赖播种

通过分别分析这些属性，我们通过理论和经验评估证明了调度播种方法相对于传统初始播种方法的优势。
我们的分析显示，当使用计划播种方法时，感染节点的最终数量提高了 10%-70%。

随机动力学

在图 1 中，我们展示了随机动力学中调度方法的优势，其中延迟播种可以在激活节点数量方面获得高达 30%的改善:

Fig 1: Comparing Scheduling seeding approaches in stochastic diffusion models.

因为延迟播种决策可以避免播种预算的不必要花费，所以通过最大化对网络的总影响，这些预算单元可以用于新的目标。

社会效应递减

通过分析具有复杂传染特性和随时间递减效应的扩散模型，我们发现预定播种方法可以通过“及时”利用播种预算来改善总影响。图 2 展示了在社会效应递减的线性阈值模型下，初始播种策略和预定播种策略的最佳可能结果的比较:

Fig 2: Dynamics of the diffusion process for Initial and Scheduled seeding approaches on the Dolphins network

正如我们所看到的，通过为第三时间步节省单个播种预算单位，调度方法成功地激活了 49 个节点，而不是传统初始播种方法中的仅 43 个。

状态依赖播种

在播种动作本身的结果取决于邻居节点的激活状态的设置中，播种的定时可以起到至关重要的作用。在图 3 中，我们展示了一个例子，在这个例子中，为了被激活，一个种子节点需要有至少一半的邻居已经被激活。

Figure 3: An example of scheduling advantage in state-dependent seeding dynamics.

通过逐步实施播种行动，我们可以利用累积激活过程并在播种结束时获得更大的总影响力。

总结

我们的发现有可能开辟一个新的研究领域，专注于寻找播种行动的正确时机，从而有助于提高我们对信息传播动力学的理解，并设计更好的影响最大化策略。对于每个提出的属性，我们考虑了一个简化的传染模型，允许我们隔离特定属性对预定播种方法的成功的贡献。然后，我们展示了一个极简的玩具示例，展示了通过预定播种方法获得的好处。我们还进行了理论分析，以比较调度播种方法和传统初始播种方法的性能。最后，我们展示了一组经验模拟实验，这些实验比较了调度和初始播种方法在许多真实世界社交网络拓扑上的性能。在整个工作中，我们尽量保持分析的简单性。
例如，在展示有利于计划播种方法的三个属性时，我们将每个属性与其他属性隔离开来。
未来的工作可能会进一步分析这些属性的不同组合，这可能会呈现它们之间的非平凡的相互作用。例如，虽然随机性的存在被证明是支持延迟播种行为的有力论据，但是社会效应递减的存在可能需要尽快播种节点。对这种情况的初步探索可以在我们以前的工作中找到(主动病毒营销:将持续的主动播种努力纳入扩散模型)，其中分析了状态依赖播种的动态以及随机性和社会效应递减的存在。

我们的评估主要基于利用真实网络拓扑的理论分析和模拟。在未来，用额外的真实世界数据(如用户的购买历史)来丰富我们的模拟会很有趣。此外，进行现场实验来比较通过预定播种方法和初始播种方法获得的采用率将是有见地的。总之，我们相信我们的发现有潜力打开一个全新的研究领域，专注于寻找播种行动的正确时机，从而帮助我们提高对扩散动力学的理解，并设计更好的策略来塑造社会行为。

数据可视化技巧

原文：https://towardsdatascience.com/tips-for-data-visualization-c00d505db7cf?source=collection_archive---------7-----------------------

您的数据取决于您理解和交流数据的能力，这就是为什么选择正确的可视化/图表至关重要。如果您不能有效地展示数据，关键的见解可能会丢失。信息可以用几种不同的方式可视化，每种方式都更能提供特定的洞察力。

处理数据时，首先要理解你想要讲述的故事或你试图强调的关系。这将有助于选择正确的形象来传达你的信息。

在开始可视化数据之前，您应该了解常见的数据类型:

1. 定量——可以计数或测量；数字的
2. 分类—可以根据组或类别进行排序
3. 离散-具有有限数量的可能值
4. 连续-测量，其值在一个范围内

理解数据关系对于数据可视化过程非常重要。下面列出了常见的数据关系:

👉时间序列—跟踪一段时间内指标值的变化

👉名义比较-比较子类别的数量值

👉相关性—包含两个或更多变量的数据，这些变量之间可能存在正相关性或负相关性

👉部分到整体的关系——与整体相比的数据子集

👉分布—显示围绕中心值的数据分布

👉偏差-显示数据点之间的相互关系，以查看任意给定点与平均值的差距

👉排名-显示两个或多个值在相对大小上的相互比较

其他提示:

使用图标增强理解，减少额外的标签/图例

使用逻辑层次对数据集进行排序

以一种让受众能够简单比较数值的方式来可视化数据

使用注释或标注突出显示重要信息

用一种颜色代表每个类别，在整个演示文稿/仪表盘中保持一致

不要使用三维图表——它可能会扭曲对信息的理解

避免在一个视图中使用超过 5 种颜色

不要使用分散注意力的背景色或有渐变的颜色

有效的数据科学讲座技巧

原文：https://towardsdatascience.com/tips-for-effective-data-science-talks-b50961262c26?source=collection_archive---------9-----------------------

在研究生院，我学会了在做演讲前练习。授课进一步强化了沟通的重要性，这让我在行业中受益匪浅。

最近，我不得不为实习生在全公司范围内展示他们的项目提供建议。我意识到我没有一个向导来指引他们…所以现在我正在制作它。

这并不意味着是真理，它们只是我在过去 15 年左右的时间里通过非正式测试学到的一些技巧。

让我们从最重要的部分开始:你必须努力工作。但是通过练习会变得更容易。

把它想象成编写软件:在对任何用户进行测试之前，你曾经编写过完美的软件吗？为什么你会期望发表一个伟大的演讲而不在人们身上进行测试呢？迭代开发的类比更深入:你可以尝试聪明地预测你的受众，或者你可以只是去找一个小的随机样本受众并尝试一下。

诚实地考虑他们的反馈，不要觉得自己受到了批评。大约一半的反馈不应该只看表面。当有人向你建议解决方案时，首先确定他们正在解决的问题。解决同一个问题往往有更简单的方法。

我建议在演讲中只回答澄清性的问题，而把所有讨论性的问题留到最后。最好提前说:如果有人在第二张幻灯片上迷失了方向，觉得自己不被允许大声说出来，这种缺乏理解的情况通常会加剧，他们将很难理解接下来的几张幻灯片(有时甚至是整个演讲！)你要允许提问。但是你不想和 1%的听众进行 10 分钟的讨论。之后进行讨论。

管理您的技术

买一个遥控器，让幻灯片播放时不会分心。在会议上，这很正常，但在公司会谈中，这甚至很有帮助。你可以更专注于吸引观众，减少开销。

如果您使用的是 Mac，请设定“请勿打扰”模式。最糟糕的是在谈话中得到一个松弛/Hangouts 通知。同样，关闭谷歌日历或禁用中断通知。或者完全关闭 Wifi。

当我们谈到技术的时候，早点到那里，仔细检查投影仪/电视。如果你在连接器和设置上笨手笨脚，观众可能会开始互相交谈，很难重新获得他们的注意力。

讲

如果你有麦克风，最好说大声点，让麦克风离嘴远一点。这样就不会放大你的呼吸声。它还能防止许多廉价麦克风拾取的尖锐声音。你也会显得更加自信。

在大房间里，迅速确认后面的观众能听到你。这可能看起来很傻，但 10 秒钟是值得的。

尊重观众

不熟悉的术语往往会失去你的听众。你的观众并不愚蠢，但他们可能不知道什么是雅各宾派，或者被教了一个不同的词，或者不习惯英语。吴恩达的机器学习课程就是一个好技术的例子；他经常会多花几秒钟来确保术语的定义，以及所有不同背景的人都有平等的机会。

用具体的例子描述你的问题可以减少术语和抽象概念的复杂性。在许多情况下，依靠一个例子来解释将决定留住和失去一个人。

尽可能让房间里的每个人都有机会阅读您的幻灯片。增加默认字体大小。

有些人视力不好或者没有视力。所以当你展示图表时，用文字描述你所看到的。

当简单的单词可以使用时，不要使用难懂的单词

抓住观众的注意力

吸引你的观众很重要。人们相互镜像；如果你对他们感兴趣，他们也会对你感兴趣。至少试着和大多数观众进行一次眼神交流。

动画文本，以便一次显示一个项目符号。对于一个复杂的话题，这有助于你的听众将注意力集中到当前最重要的事情上，这通常是最后一个要点。

幻灯片不是用来传递信息的；文本只是提供备份。

优先考虑

抄袭最好的，但要给予表扬。这是你在准备时间用完时，从制作讲座幻灯片中学到的东西。例如，如果你试图解释监督学习和非监督学习之间的区别，网上可能有一个很好的图表。

计算机科学中的一个常见错误是使内容过于技术化(即使是在会议上)。会议演讲的目的是让人们阅读你的论文。在一个简短的演讲结束时，听众应该都知道这篇论文是否与他们相关。在行业讲座上，你可能会向其他领域的同行解释新技术。你应该积极地优先考虑你认为 90%的观众需要知道的内容，永远不要为了炫耀你的技术实力而牺牲掉那 90%的内容。

论记忆与练习

我不会一字不差地记住我的演讲。但我确实记得那次谈话的感觉。对我来说，练习就是学习如何从一张幻灯片流到另一张幻灯片。然后当我在台上演讲时，我自然会跟着感觉正确的流程走。这导致了受控但没有死记硬背的谈话。

一般来说，我通过一次看一张幻灯片并假装说话来练习一次。我动了动嘴，没有发出声音。这有助于我更准确地估计时间。

然后在同龄人之前练习。特别是，我试图包括一些不熟悉这个话题的人和一些熟悉的人。来自非技术人员的反馈通常是最重要的。你甚至可以用它来建立关系网，大多数人会很乐意帮忙的。

对于重要的会谈，在会谈的那天，我会自己练习一遍。如果我有一个酒店房间，我大声说话。

这是我的方法，但是你可能会发现记忆对你有用。或者你可能会复制吴恩达和记录自己。

结束想法

糟糕的演讲的一个标志是观众不会提问。

好的展示的一个标志是他们会问你问题。

一场精彩演讲的标志是，他们会问你一些聪明的问题，并相互辩论。你教会了他们一些有价值的东西，他们的好奇心会推动你学习更多。

在 pandas 中使用日期时间索引

原文：https://towardsdatascience.com/tips-on-working-with-datetime-index-in-pandas-2bcedf956d70?source=collection_archive---------5-----------------------

Photo by Jordan Benton from Pexels

对一个人有用的东西可能对另一个人有用

正如您从标题中所理解的，它并不是 Python 中时间序列或日期时间数据类型的完整指南。因此，如果你期望从 A 到 Z 得到深入的解释，那就错了。说真的。关于这个话题有一篇精彩的文章，解释得很好，很详细，也很直白。不要在这个上浪费你的时间。

对于已经读到这一部分的人，我会告诉他们，你肯定会在这里找到有用的东西。再说一次，说真的。我找到了我关于时间序列的笔记，并决定把它整理成一篇小文章，里面有一些通用的提示，我想这些提示在你处理日期的 80%到 90%的情况下都是适用的。所以很值得分享不是吗？

我有一个数据集，其中包含自 2016 年以来马德里每小时的空气污染物测量值，因此我将以它为例。

导入数据

默认情况下，当使用read_csv()导入 csv 文件时，pandas 将使用第一列作为索引，因此如果您的日期时间列不是第一列，您将需要显式指定它index_col='date'.

pandas 的美妙之处在于它可以在导入过程中预处理您的 datetime 数据。通过指定parse_dates=True，pandas 将尝试解析索引，如果我们传递整数或名称的列表，例如 if [1，2，3]–它将尝试将第 1、2、3 列分别解析为单独的日期列，列表列表，例如 if [[1，3]]–将第 1 和第 3 列合并，解析为单个日期列，dict，例如{'foo' : [1，3]}–将第 1、3 列解析为日期，并调用结果“foo”。如果您使用其他方法导入数据，您可以在其后使用pd.to_datetime。

我使用以下代码导入了我的数据:

import pandas as pd
import globpattern = 'data/madrid*.csv'
csv_files = glob.glob(pattern)
frames = []for csv in csv_files: df = pd.read_csv(csv, index_col='date', parse_dates=True)     frames.append(df)
df = pd.concat(frames)
df.head()Out[4]: BEN  CH4   CO  EBE  NMHC     NO   NO_2  NOx  
date                                                                          
2016-11-01 01:00:00  NaN  NaN  0.7  NaN   NaN  153.0   77.0  NaN  
2016-11-01 01:00:00  3.1  NaN  1.1  2.0  0.53  260.0  144.0  NaN  
2016-11-01 01:00:00  5.9  NaN  NaN  7.5   NaN  297.0  139.0  NaN  
2016-11-01 01:00:00  NaN  NaN  1.0  NaN   NaN  154.0  113.0  NaN   
2016-11-01 01:00:00  NaN  NaN  NaN  NaN   NaN  275.0  127.0  NaN

这些数据是从 24 个不同的站点收集的，涉及 14 种不同的污染物。我们不打算分析这些数据，为了简单一点，我们将只选择一个站，两种污染物，并删除所有 NaN 值(危险！请不要在不了解后果的情况下在家里重复)。

df_time = df[['O_3', 'PM10']][df['station'] == 28079008].dropna() df_time.head() Out[9]: O_3  PM10
date                          
2016-11-01 01:00:00  4.0  46.0
2016-11-01 02:00:00  4.0  37.0
2016-11-01 03:00:00  4.0  31.0
2016-11-01 04:00:00  5.0  31.0
2016-11-01 05:00:00  6.0  27.0

现在，当我们准备好数据后，我们就可以玩日期时间索引了。

选择值

尽管默认的 pandas datetime 格式是 ISO8601(“yyyy-mm-DD hh:mm:ss”)，但当使用部分字符串索引选择数据时，它可以理解许多其他不同的格式。例如:

**df_time.loc['2016-11-01'].head()** Out[17]: O_3  PM10
date                          
2016-11-01 01:00:00  4.0  46.0
2016-11-01 02:00:00  4.0  37.0
2016-11-01 03:00:00  4.0  31.0
2016-11-01 04:00:00  5.0  31.0
2016-11-01 05:00:00  6.0  27.0**df_time.loc['November 1, 2016'].head()** Out[18]: O_3  PM10
date                          
2016-11-01 01:00:00  4.0  46.0
2016-11-01 02:00:00  4.0  37.0
2016-11-01 03:00:00  4.0  31.0
2016-11-01 04:00:00  5.0  31.0
2016-11-01 05:00:00  6.0  27.0**df_time.loc['2016-Nov-1'].head()** Out[19]: O_3  PM10
date                          
2016-11-01 01:00:00  4.0  46.0
2016-11-01 02:00:00  4.0  37.0
2016-11-01 03:00:00  4.0  31.0
2016-11-01 04:00:00  5.0  31.0

都产生相同的输出。所以我们可以自由使用任何对我们来说更舒适的东西。我们还可以选择整个月的数据:

**df_time.loc['2016-11'].head()** Out[20]: O_3  PM10
date                          
2016-11-01 01:00:00  4.0  46.0
2016-11-01 02:00:00  4.0  37.0
2016-11-01 03:00:00  4.0  31.0
2016-11-01 04:00:00  5.0  31.0
2016-11-01 05:00:00  6.0  27.0**df_time.loc['2016-11'].count()** Out[24]: 
O_3     715
PM10    715
dtype: int64

如果我们想选择整年，情况也是如此:

**df_time.loc['2016'].head()** Out[31]: O_3  PM10
date                          
2016-11-01 01:00:00  4.0  46.0
2016-11-01 02:00:00  4.0  37.0
2016-11-01 03:00:00  4.0  31.0
2016-11-01 04:00:00  5.0  31.0
2016-11-01 05:00:00  6.0  27.0**df_time.loc['2016'].count()** Out[32]: 
O_3     8720
PM10    8720
dtype: int64

如果我们想对数据进行切片并找到某个特定时间段的记录，我们继续使用loc访问器，所有规则与常规索引相同:

**df_time.loc['2017-11-02 23:00' : '2017-12-01'].head()** Out[34]: O_3  PM10
date                          
2017-11-02 23:00:00  5.0  30.0
2017-11-03 00:00:00  5.0  25.0
2017-11-03 01:00:00  5.0  12.0
2017-11-03 02:00:00  6.0   8.0
2017-11-03 03:00:00  7.0  14.0**df_time.loc['2017-11-02 23:00' : '2017-12-01'].count()** Out[35]: 
O_3     690
PM10    690
dtype: int64

重采样

Pandas 具有简单、强大且高效的功能，用于在频率转换期间执行重采样操作(例如，将秒数据转换为 5 分钟数据)。这在金融应用中极为常见，但不限于此。

resample()是一个基于时间的 groupby，其后是对其每个组的归约方法。

resample功能非常灵活，允许我们指定许多不同的参数来控制频率转换和重采样操作。sum、mean、std、sem、max、min、median、first、last、ohlc、
是resample()返回对象的方法

# Converting hourly data into monthly data
**df_time.resample('M').mean().head()** Out[46]: O_3       PM10
date                            
2016-01-31  21.871622  19.990541
2016-02-29  32.241679  25.853835
2016-03-31  44.234014  16.952381
2016-04-30  46.845938  12.189076
2016-05-31  53.136671  14.671177

对于向上采样，我们可以指定一种向上采样的方法，以便在创建的间隙上进行插值:

# Converting hourly data into 10-minutely data
**df_time.resample('10Min').mean().head()** Out[47]: O_3  PM10
date                          
2016-01-01 01:00:00  8.0  17.0
2016-01-01 01:10:00  NaN   NaN
2016-01-01 01:20:00  NaN   NaN
2016-01-01 01:30:00  NaN   NaN
2016-01-01 01:40:00  NaN   NaN**df_time.resample('10Min').mean().ffill().head()** Out[48]: O_3  PM10
date                          
2016-01-01 01:00:00  8.0  17.0
2016-01-01 01:10:00  8.0  17.0
2016-01-01 01:20:00  8.0  17.0
2016-01-01 01:30:00  8.0  17.0
2016-01-01 01:40:00  8.0  17.0

我们可以使用以下方法来填充 NaN 值:'填充'，'回填'，' ffill '，' bfill '，'最近的'。在文档中可以找到更多相关细节。或者我们可以通过以下方法使用插值来实现:'线性'，'时间'，'索引'，'值'，'最近'，'零'，'线性'，'二次'，'三次'，'重心'，' krogh '，'多项式'，'样条'，'分段 _ 多项式'，' from _ 导数'，' pchip '，' akima '。同样，关于这一点的更深入的解释可以在熊猫文档中找到。

和重采样频率:

形象化

Datetime Index 的另一个令人惊叹的特性是绘图简单，因为 matplotlib 会自动将其视为 x 轴，所以我们不需要显式指定任何内容。

import seaborn as sns
sns.set()
df_plot = df_time.resample('M').mean()
**plt.plot(df_plot)** plt.title('Air polution by O3 and PM10')
plt.ylabel('micrograms per cubic meter (mg/m3)')
plt.xticks(rotation=45)
plt.show()

正如在开始时所承诺的——一些小技巧，在大多数情况下，在处理日期时间数据时会有所帮助。对我来说——又一个将思想转化为知识的更新者和组织者。都赢了。有人会觉得它有用，有人可能不会(我在第一段就警告过:D)，所以实际上我希望每个阅读这篇文章的人都会觉得它有用。

这是知识最令人兴奋的特点——当你分享它时，你不会失去任何东西，你只会有所收获。要写一篇文章，需要一些研究，一些验证，一些学习——基本上你最终会获得更多的知识。

知识只是一种工具。应用与否是你的责任。归根结底，你知道多少并不重要，重要的是你如何运用这些知识。但那已经是另一个故事了…

感谢您的阅读，度过不可思议的一周，学习，传播知识，明智地使用它，并将其用于行善🙂

最初发表于【sergilehkyi.com】。

数据科学家，你需要知道的一个图算法

原文：https://towardsdatascience.com/to-all-data-scientists-the-one-graph-algorithm-you-need-to-know-59178dbb1ec2?source=collection_archive---------4-----------------------

Photo by Alina Grubnyak on Unsplash

图表为我们提供了一种非常有用的数据结构。它们可以帮助我们找到数据中的结构。随着机器学习和大数据的出现，我们需要获得尽可能多的关于我们数据的信息。学习一点图论当然可以帮助我们。

这里有一个由 UCSanDiego 在 Coursera 上开设的大数据图形分析课程，我强烈推荐学习图论的基础知识。

我在这篇文章中要关注的算法之一叫做连通域。为什么它很重要。我们都知道聚类。

你可以用非常通俗的术语把连通分量看作是一种硬聚类算法，它在相关/连通的数据中寻找聚类/孤岛。举一个具体的例子:假设您有关于连接世界上任何两个城市的道路的数据。你需要找出世界上所有的大洲以及它们包含的城市。

你将如何实现这一目标？来吧，考虑一下。

从零售角度来看:比方说，我们有很多客户使用很多账户。使用连通分量算法的一种方法是在数据集中找出不同的族。我们可以基于相同的信用卡使用、相同的地址或相同的手机号码等假设客户之间的边界(道路)。一旦我们有了这些连接，我们就可以在相同的上运行连接组件算法来创建单独的聚类，然后我们可以为这些聚类分配一个家族 ID。我们可以使用这些家庭 id 根据家庭需求提供个性化建议。我们还可以使用这个家族 ID，通过创建基于家族的分组特征来推动我们的分类算法。

在财务视角中:另一个用例是使用这些家庭 id 来捕获欺诈。如果一个帐户过去曾有过欺诈行为，那么关联的帐户也很有可能容易受到欺诈。

足够多的用例。让我们从一个用 Python 编写的简单的 graph 类开始，用代码开始我们的开发。

从现在开始，这篇文章将更多地围绕代码展开。

您当然可以使用我们的新图形类。在这里，我们试图建立一些图表。

Output:
Vertices of graph:
['a', 'c', 'b']
Edges of graph:
[['a', 'd', 2], ['c', 'b', 5], ['c', 'e', 5], ['c', 'd', 3], ['b', 'c', 2]]
Add vertex:
Vertices of graph:
['a', 'c', 'b', 'z']
Add an edge:
Vertices of graph:
['a', 'c', 'b', 'z']
Edges of graph:
[['a', 'z', 1], ['a', 'd', 2], ['c', 'b', 5], ['c', 'e', 5], ['c', 'd', 3], ['b', 'c', 2], ['z', 'a', 1]]
Adding an edge {"x","y"} with new vertices:
Vertices of graph:
['a', 'c', 'b', 'y', 'x', 'z']
Edges of graph:
[['a', 'z', 1], ['a', 'd', 2], ['c', 'b', 5], ['c', 'e', 5], ['c', 'd', 3], ['b', 'c', 2], ['y', 'x', 1], ['x', 'y', 1], ['z', 'a', 1]]

现在让我们做一些有趣的事情。

出于理解的目的，我们将使用上面的 graph 类。python 中有许多模块，我们可以用来做我接下来要做的任何事情，但是为了理解这些方法，我们将从头开始编写所有的东西。
让我们从一个示例图开始，我们可以用它来达到我们的目的。

Vertices of graph:
['Mannheim', 'Erfurt', 'Munchen', 'Numberg', 'Stuttgart', 'Augsburg', 'Kassel', 'Frankfurt', 'Wurzburg', 'Karlsruhe']
Edges of graph:
[['Mannheim', 'Frankfurt', 85], ['Mannheim', 'Karlsruhe', 80], ['Erfurt', 'Wurzburg', 186], ['Munchen', 'Numberg', 167], ['Munchen', 'Augsburg', 84], ['Munchen', 'Kassel', 502], ['Numberg', 'Stuttgart', 183], ['Numberg', 'Wurzburg', 103], ['Numberg', 'Munchen', 167], ['Stuttgart', 'Numberg', 183], ['Augsburg', 'Munchen', 84], ['Augsburg', 'Karlsruhe', 250], ['Kassel', 'Munchen', 502], ['Kassel', 'Frankfurt', 173], ['Frankfurt', 'Mannheim', 85], ['Frankfurt', 'Wurzburg', 217], ['Frankfurt', 'Kassel', 173], ['Wurzburg', 'Numberg', 103], ['Wurzburg', 'Erfurt', 186], ['Wurzburg', 'Frankfurt', 217], ['Karlsruhe', 'Mannheim', 80], ['Karlsruhe', 'Augsburg', 250]]

假设给我们一张图表，上面有德国的城市以及它们之间各自的距离。你想知道如何从法兰克福(起点)到慕尼黑。可能有许多方法可以遍历该图，但您需要找到从法兰克福到慕尼黑至少需要访问多少个城市)这个问题类似于在未加权的图中找出节点之间的距离。

我们这里使用的算法叫做广度优先搜索。

我们在上面这段代码中所做的是创建一个队列，并根据级别遍历它。我们以法兰克福为起点。我们循环通过它的邻近城市(曼海姆、维尔茨堡和卡塞尔)并把它们推入队列。我们跟踪他们处于什么水平，以及我们到达他们的路径。因为我们弹出队列的第一个元素，我们确信我们将按照城市等级的顺序访问城市。

查看这篇关于 BFS 的帖子，了解更多关于排队和 BFS 的信息。

({'Augsburg': 3,'Erfurt': 2,'Frankfurt': 0,'Karlsruhe': 2,'Kassel': 1,'Mannheim': 1,'Munchen': 2,'Numberg': 2,'Stuttgart': 3,'Wurzburg': 1},{'Augsburg': ':->Frankfurt->Mannheim->Karlsruhe','Erfurt': ':->Frankfurt->Wurzburg','Frankfurt': ':','Karlsruhe': ':->Frankfurt->Mannheim','Kassel': ':->Frankfurt','Mannheim': ':->Frankfurt','Munchen': ':->Frankfurt->Kassel','Numberg': ':->Frankfurt->Wurzburg','Stuttgart': ':->Frankfurt->Wurzburg->Numberg','Wurzburg': ':->Frankfurt'})

我做这个例子是为了展示 BFS 算法是如何工作的。我们可以扩展这个算法，在一个不连通的图中找出连通的部分。假设我们需要在图中找到几组不相连的顶点。

例如，下图有 3 个不相连的子图。我们能找到哪些节点属于某个特定的子图吗？****

[['Kassel','Munchen','Frankfurt','Numberg','Augsburg','Mannheim','Wurzburg','Stuttgart','Karlsruhe','Erfurt'],['Bangalore', 'Kolkata', 'Delhi', 'Mumbai'],['NY', 'ALB', 'TX']]

上面的代码类似于前面的 BFS 代码。我们将图的所有顶点保存在节点列表中。我们从节点列表中取出一个节点，并在其上启动 BFS。当我们访问一个节点时，我们从节点列表中删除该节点。每当 BFS 完成时，我们从节点列表中的另一个节点开始，直到节点列表为空。

如您所见，我们能够在数据中找到不同的组件。仅仅通过使用边和顶点。这个算法可以在不同的数据上运行，以满足我上面介绍的任何用例。

但通常使用零售案例的连接组件将涉及大量数据，您将需要扩展该算法。

PySpark 中的连接组件

下面是这篇论文中关于 MapReduce 中连接组件的实现，以及 Google Research 中之后的实现。阅读 PPT 以更好地理解实施。一些现成的代码供您使用。

或者在 PySpark 中使用 GraphFrames:

要安装图表框架:

我在命令行上运行:py spark—packages graphframes:graph frames:0 . 5 . 0-spark 2.1-s _ 2.11，它打开了我的笔记本，并在我尝试在笔记本中导入后安装了 graph frames。

要格式化的字符串为:graphframes:(最新版本)-spark(你的 spark 版本)-s_(你的 scala 版本)。

查看 本指南介绍如何使用 GraphFrames 了解更多信息。

GraphFrames 库实现了 CC 算法以及各种其他图形算法。

上面的帖子有很多代码，但希望对你有所帮助。我花了很多时间来实现算法，所以想让它对人们来说很容易。

如果你想阅读更多关于图算法的内容，这里有一个由 UCSanDiego 在 Coursera 上开设的大数据图分析课程，我强烈推荐你学习图论的基础知识。

请随时在 LinkedIn 上与我联系，在 Twitter / Medium 上关注我，或者给我发消息征求意见。继续收听，继续学习。

首先发表在我的博客 mlwhiz.com这里。

参考

1. Python 中的图形
2. 图论博客简介
3. 加州大学圣地亚哥分校 Coursera 大数据课程的图表分析

做还是不做(数据科学家)

原文：https://towardsdatascience.com/to-be-or-not-to-be-a-data-scientist-13684ba7422?source=collection_archive---------5-----------------------

每次我试图想出一个合适的新标题时，快速的谷歌搜索都会让我意识到这个话题已经被讨论过很多次了，而且大多数相关的标题都被取了出来。我觉得标题有意义比独特更重要，于是就选了上面的这个。请不要评判我。

仍然值得讨论这个问题的原因是缺乏对转行、学习新技能和适应不断变化的生活的挑战部分的覆盖。在这篇文章中，我不会列出“成为数据科学家的 10 大资源”，但我会告诉你我从一名具有基本编程知识的机械工程师到一名从事深度学习的数据科学家的旅程。

从为什么开始

前阵子，我读了西蒙·西内克的书《从为什么开始》。这是我决心改变职业生涯的开始，它让我努力思考做我喜欢的事情。

图片来自 FramingTheDialogue.com 的。

如果你有时间，可以看看西蒙的 Ted 演讲，然后回来。如果你没有时间，直接跳过——这不是强制性的。

如何通过做自己喜欢的事情获得报酬

每天醒来兴奋地去工作，去解决有挑战性和有意义的问题——这是我的目标，这是我的原因。有了“为什么”,我就开始讨论“如何”和“什么”。事实证明，找出原因是一个相对简单的过程，从一些个人反思开始。相反，弄清楚如何做和做什么是一个更困难的过程，而不是一条直线。

当时我在石油和天然气行业工作，在上游石油和天然气行业担任项目经理，前途无量。我甚至还在攻读石油工程的硕士学位。虽然这很有趣，但我没有跳下床去上班。可以肯定的是，这份工作有许多积极的方面，我很喜欢。在项目团队中工作是一种独特的体验，需要建立有意义的关系，作为一个非常注重结果的人，我在建设实体项目中找到了乐趣。不幸的是，我没有找到我想要的智力挑战。

我决定只要有机会，我就会追随我的兴趣。当时，数据科学并不像今天这样普遍，但我知道数据是有价值的，这个领域正在快速发展。另外，我喜欢和它一起工作。

我发现自己在偏远的澳大利亚中部工作，一周工作两个星期，突然有了额外的时间。晚上，在每天工作 12 个小时管理项目后，我会抓紧时间吃晚饭，呆在房间里，然后编程。在两周的休假期间，我将继续开发股票市场交易工具(当时我已经参与了几年)，并开始掌握 web 抓取、结构化和非结构化数据的数据挖掘、数据清理、数据可视化和应用程序开发。

我当时并不知道，但这是成为一名数据科学家的核心部分——数据处理技能。除了在股票市场上赚几个钱之外，没有一件事是有目的的；我只是追求个人兴趣。在花了几年时间为澳大利亚市场进行交易、分析和开发工具后，我开始写一个金融专栏。有一段时间，我和妻子环游世界一年。这种情况一直持续到我去德国攻读双学位(机器人学硕士和 MBA)。大约在同一时间，我也开始“正式”自学数据科学。

这有助于我在攻读工程学位期间学习微积分、线性代数和微分方程。我有一些 C++和 Matlab 的经验，但我不能称自己为程序员。我还认为，成为一名数据科学家所需的原始数学技能并不复杂。Khan Academy 上的几本入门，YouTube 上的几个视频，就足以让你变得危险。

我的学业继续着，有点痴迷。我会在早上起床，学习 2-3 个小时，然后去上学。有了双学位，我打算为转行打下坚实的基础。它带有奖学金；这是著名的德国工程界，这是显而易见的。同时，我可以兼职学习数据科学。

原来我讨厌回到学校。结构、不灵活以及缺乏任何与数据科学相关的东西困扰着我。老实说，我从来都不是结构化学习的狂热爱好者，并且很享受在数据科学世界中记录我的冒险经历。我对这所大学或学生没有任何不满；这不是我想做的。我在学校学的是有限元分析和材料工程，我想做的就是回去研究机器学习。这是一个迷人的主题，其可能性令人难以置信。

回想起 Sinek 先生的话和我开始这段旅程的“为什么”,我觉得学校不会把我带到那里。当然，这将导致一个有趣的职业生涯，但我就是不喜欢它。和妻子聊了几个晚上后，我退出了这两个项目，开始了一份数据分析师的工作。这是获得数据工作报酬的第一步，我会在晚上继续学习机器学习。

几个月过去了，我学习得更多了。我所有的业余时间都花在了学习、编码、学习上。我学习了 Spark、Python，研究了大多数传统的机器学习方法，学会了理解神经网络的所有细节，并开始构建自己的项目。我和妻子搬到了保加利亚，我将在那里开办一家咨询公司，我继续研究深度学习。我身后有两股激励的风。

1. 如果我想和最有趣的人一起工作，解决令人兴奋的问题，我需要站在这个领域的最前沿。
2. 我每天早上起来都兴奋地想在我选择的领域里学到新的东西。

事后看来，坚持下去并不困难。我被一种兴趣和一种偏执驱使着。总是认为我知道的不够多，我继续学习。另外，我玩得很开心，所以感觉不像工作。

最终，我从书本中站起来，发现自己作为一名数据科学家已经相当精通。从第一天开始编程到现在已经四年了。我的工作让我能够从事前沿的深度学习模型。我们实施上个月可能已经出来的新模型设计，并开始产生新的独特想法。

关于从为什么开始的几点注意事项

我想在此稍作停顿，澄清我的原因、方式和内容:

• 为什么——我想每天醒来都兴奋地去工作，这样我的生活会更充实。
• 如何——在令我着迷的领域找到一份职业，与有动力和兴趣的人一起应对有趣的挑战，并在该领域的前沿工作。
• 什么？我碰巧是一名数据科学家

数据科学从来都不是目标。如果你决定成为一名数据科学家开始你的旅程，你可能会成为一名优秀的数据科学家。你也可能会发现你讨厌它。你愿意花两周时间清理十个来源的数据，再花一周时间进行特性工程，然后测试你的模型，发现它毫无价值吗？

你愿意理解螺母和螺栓——数学，概念，优化是如何工作的？当你的朋友去酒吧，在他们高薪的工程职业生涯中前进的时候，你会花时间在清晨和深夜学习吗？如果不是，那么数据科学(可能)不适合你。我说可能是因为总有例外。我试着为自己设定高标准，这可能不一定适用于其他人，所以对此要有所保留。

战斗当前

作为一个领域，数据科学正在快速变化。你越深入，就越难跟上。你需要致力于学习和研究，仍然愿意回到那些首要原则，与数据搏斗。你需要一系列令人眼花缭乱的技术、分析和个人技能。你停止学习的那一天，就是你开始落伍的那一天。想象一下，如果你不喜欢你正在做的事情，那会有多累。

精英管理

到目前为止，数据科学更多的是基于精英而不是证书。它向许多不同的人开放了这个领域，吸引了比其他领域更喜欢它的人。随着大学开始向人们收取正式学位的费用，数据科学的这一方面正在逐渐衰落——这并不是说这本身有什么问题，而是它将人们吸引到了一个否则他们不会花时间的领域。在数据科学这样的领域，如果你不热爱它，就很难跟上。没有动力，你会发现自己很快就会落后。

数据科学既艰难又令人沮丧

Via ForeverStudent.com

作为一名数据科学家，就像作为一名软件工程师一样，可能会非常令人沮丧、困难，并且需要大量的时间投入，但这是非常值得的。话虽如此，它可能不会满足你的为什么。对大多数人来说，肯定不是。我恳求你从为什么而不是什么开始。追随你的兴趣，因为这些兴趣也包含机会。可能不是数据科学(统计学上也不是)，但如果你专心致志，你会有所发现。每天都要学习，把精力集中在机会所在的地方。如果你这样做了，你会得到一份令人兴奋的职业，让你的生活变得更有意义。

我相信正确的方法可以让任何人爱上他们的职业。如果我的妻子正在阅读——对不起，但是你将不得不分享。

买还是不买？这是一个问题

原文：https://towardsdatascience.com/to-buy-or-not-to-buy-that-is-the-question-3a4d99330dcc?source=collection_archive---------11-----------------------

如何用图论区分积极消费者和橱窗购物者？

从实时信号中了解购物者的真实意图

“预测很难。尤其是关于未来。”尼尔斯·玻尔(也许)

即使电子商务销售额达到历史最高水平，大多数访问某个电子商务网站的人也更有可能不买东西就离开，反之亦然。

作为电子商务副总裁，如果知道我们的模型可以在你的店铺点击几下后识别出有动机的顾客，你会怎么做(剧透:只有六个)？对于积极主动的购物者和漫不经心的购物者，哪些是正确的互动策略？

任何一个优秀的销售助理都知道，消费者通过语言和身体行为展示出他们真正兴趣的清晰线索:他们如何在过道里走动，他们问什么问题，他们的穿着等等..如果这在现实世界中是真的，那么在数字世界中，当没有脸可以阅读时，会发生什么呢？

如果用户正在浏览我们的网站，用尽可能少的“点击”来检测她真正的购物意图肯定会非常有帮助:在大数据时代，我们实际上可以跟踪(匿名)浏览我们商店的用户，并精确记录他们的行动。我们能否利用消费者留下的所有数字面包屑，将预测的艺术转化为推销的艺术？

在 Tooso ，我们正在通过人工智能和机器学习帮助市场上一些最大和最具创新性的零售商转变网上购物。由于我们的渠道已经每天从几个电子商务网站获取数百万新事件，我们处于一个理想的位置，可以尝试使用数据来回答我们的问题:

人工智能能在他们的在线旅程中多久(如果有的话)发现真正想买东西的用户？

想象一下你的数码商店的可能性:如果你知道哪些用户会购买，哪些不会，你如何改变你的网站？Tooso 的产品专家正在与我们的零售客户合作，为不同类型的用户开发不同的驱动因素:如果用户的意图是购买，我们可以努力进行追加销售，优化购物车体验。

If the user wants to buy, let’s help him buy more.

另一方面，如果目的是浏览，我们可以尝试让用户受到启发并参与进来:增加品牌知名度，建议跨渠道行动，等等。

If the user is casually browsing, let’s get him involved.

在这篇博文中，我们将从数据科学的角度解释我们是如何完成这项任务的，并且我们将概述一些由于我们的进展而正在开发的产品功能。初步结果表明，只需在网站上进行六次操作，我们就能够可靠地预测购买客户！我们还希望通过对真实数据进行研究友好的许可，为零售业的人工智能社区做出进一步的贡献:更多信息请见结束语，现在是科学时间。

几个月前，我们启动了 Tooso 实验室。该项目的启动旨在通过将我们的愿景、技能组合和专有数据集与我们在行业和学术界的知名研究人员网络相匹配，为新旧人工智能问题带来新的跨学科解决方案；“点击流预测问题”是我们选择用新方法解决的第一个问题。

这份进展中的报告是 Tooso 实验室和 Lucas Lacasa 博士持续合作的结果，Lucas Lacasa 博士是玛丽女王大学应用数学高级讲师，一位了不起的物理学家，一位相当不错的篮球运动员，也是 Tooso 的好朋友。

从点击流数据到预测

"也许因为我永远不会成为人类，所以我对人类很感兴趣."杰夫林赛

我们将通过使问题更精确一点和上下文更明确一点来开始我们的深入探讨。你可以把你最喜欢的电子商务网站想象成一个网络，即一个正式的结构，其中节点是网站中的页面，而边是页面之间的链接:用户登陆该网站后，可以通过在每个页面/节点重复动作来导航网络，如下图所示:

Navigating the network: a shopper’s journey from landing page to the final checkout.

每个用户将在网络中无数可能的路径中仅选择一个:一些路径将是许多用户共同的(例如，从登录页面到主页)，一些将是相对罕见的(例如，通过产品描述中的一些链接从一个 SKU 到另一个)；一些路径会以购买结束(就像上面的红色路径)，但是大部分会在中途中断，也就是当用户离开商店而没有购买时。

多亏了我们的 Apache 许可的 Tooso Analytics 标签，我们的大数据仓库存储了用户路径中的所有动作，因此示例中的事件将被记录为类似下面的列表:

USER 123, TIME 1537517055, URL /landing123, PAGE TYPE landing
USER 123, TIME 1537517059, URL /category1, PAGE TYPE category
USER 123, TIME 1537517065, URL /index, PAGE TYPE home
USER 123, TIME 1537517100, URL /category2, PAGE TYPE category
USER 123, TIME 1537517200, URL /product-01231312, PAGE TYPE sku
USER 123, TIME 1537517210, URL /cart, PAGE TYPE cart
USER 123, TIME 1537517290, URL /checkout, PAGE TYPE checkout

如果我们不是取一个用户，而是取几千个用户，那么得到的集合将会是一个很长的路径列表，其中一些会包含一些购买事件，而大多数不会；列表中的每条路径都是一个独立的时间序列，由严格按时间顺序排列的单个事件组成。

我们的目标是训练机器很好地预测人类行为，这样就有可能从一些初始事件中了解用户是否会购买某些东西。

因此，我们的训练设置将涉及向我们的人工智能输入序列，以训练我们的预测模型:

Training settings: from labeled sequences to the trained model.

我们的离线预测设置将包括输入 1，2，..将 n 个事件添加到训练好的模型中，并记录对购买行为的预测，以测量几个序列长度的准确性(直觉上，事件越多，预测应该越好):

Offline prediction settings: the model predicts binary buying outcome at each time step in the sequence.

一旦我们对模型的准确性感到满意，就可以以一种简单明了的方式为具有在线预测的实时自适应产品提供动力(假设有一个可靠的系统来接收点击流数据并做出相应的反应)。

既然问题的边界已经明确设定，现在是真正有趣的时候了:我们如何教会机器预测人类购物者？

物理学拯救世界

"向酒吧女招待解释物理定律应该是可能的。"——阿尔伯特·爱因斯坦

从点击流数据中预测购物行为(或者更一般地说，导航模式)的问题已经在学术界和工业界用几种方法进行了研究:从高阶马尔可夫链(如这篇 PLOS 论文中)，到 RNN 论文中(如这篇由乐天支持的 SIGIR 论文)，最近的论文表明，即使一个简单的时间戳也可能是一个非常强大的预测特征。

作为 Tooso 实验室跨学科哲学的一部分，我们有兴趣以全新的眼光看待这个问题；特别是，我们从开发“廉价的”(从计算的角度来看)方法开始，与更传统的“繁重的”算法相比，这些方法可以在实时设置中有效地使用，而不会损失准确性。

我们的跨学科方法植根于物理学，特别是所谓的可见性图(书呆子警告:查看这篇 PNAS 论文)。如果您考虑一个通用时间序列，可以通过将可以“看到”彼此的数据点(作为节点)链接在一起来构建可见性图(例如，直观地，您可以在它们之间画一条直线，而不穿过中间点):

Getting edges out of a time series through the “visibility” criterion.

这种看似无害的转变开启了建模技术的宇宙，因为可见性图已经成功地用于描述时间序列的结构和各种设置中的潜在动力学(例如，预测阿尔茨海默病和湍流)。

成熟可见性分析的关键要素是“主题”，这是“接近”节点之间的连接模式，其中“接近”是通过在时间维度上遍历图形计算的滑动窗口来定义的。例如，对于尺寸为 4 的窗口，可能的图案/样式只有六个，并且它们可以通过简单的不等式检查容易地计算出来(全部细节在此):

For a window size of 4, there are only six possible motifs.

虽然看起来很简单，但这些图案已经被证明是一种有用的组合工具，可以用来描述混沌过程和其他类型的复杂数据。用这些新概念武装起来(感谢物理！)，如何才能接近我们在零售界的原始问题？极客读者可能已经知道答案:我们将把我们的用户轨迹转换成可见性图，并使用“主题”作为特征来回答我们的分类问题:用户会在这个会话中买东西吗？

意图分类的第一步

"一个好的预测者并不比其他人更聪明，他只是更好地组织了他的无知. " —匿名

作为我们的第一个游乐场，我们从我们的在线用户数据集中提取了大约 500，000 条真实客户的点击流轨迹。在对更一般的“购买与不购买”分类问题感兴趣的同时，第一个问题是通过可见性图用最简单的可能模型可以预测什么。

简单有两个天然的优点:首先，简单的模型更容易理解、调试和改进，为我们以后可能想要尝试的任何火箭科学的东西提供了良好的基线；其次，简单的模型更容易在实时、低延迟的环境中设计:因为我们的最终目标是改善我们合作伙伴网站上数百万用户的购物体验，所以在准确性、速度和维护成本之间取得平衡至关重要。

我们的基本预处理相当简单:对于每个轨迹，我们基于传统的电子商务事件类型(例如，1 =页面视图，2 =产品视图等)，将系列中的事件映射到整数(例如，1，2，3，4 …)。).因此，我们的示例路径为user 123:

URL /landing123, PAGE TYPE landing
URL /category1, PAGE TYPE category
URL /index, PAGE TYPE home
URL /category2, PAGE TYPE category
URL /product-01231312, PAGE TYPE sku
URL /cart, PAGE TYPE cart
URL /checkout, PAGE TYPE checkout

将成为序列:

1 -> 1-> 1 -> 1 -> 2 -> 3 -> 4

从如此创建的约 500，000 个整数序列中，我们提取了一个平衡样本(~50%/50%)的buy vs no-buy链，保留了序列标签，但移除了购买事件:当我们输入序列来训练我们的模型时，算法因此不能使用购买事件来预测购买(因为那将是人类欺骗多于人工智能)。看着这样转化的数据，连(训练有素！)人眼可以突出一些有趣的特征:

• 根据行业经验，我们预计buy序列通常比no-buy包含更多的“添加到购物车”事件，事实也确实如此；
• 在buy序列中的用户通常会少看件件商品，而不是多看件件商品，就好像他们的购买偏好在他们的头脑中更加清晰地表达出来。

由于我们的可视化图形机制，我们现在可以对过程采取更“整体”的观点，并实际使用上述特征作为我们的时间序列的一般图形描述的一部分。虽然有更多的数据需要准备(剧透:我们将在未来几个月发布一篇完整的研究论文)，但现在我们很乐意分享上述简单预测问题的结果:

Buy vs no-buy sequence prediction accuracy with different models.

这是什么意思？在我们的可视性图表示上的 SVM 分类器已经拥有 86%的预测准确性。这意味着，给定一个序列和一个标签buy对no-buy，该模型几乎可以在 10 次中分辨出 9 次哪个标签是正确的！

这是令人难以置信的第一步:通过利用原始时间序列的非常简单的特征，我们能够在数据中发现足够的模式，从而在预测购物行为方面取得非常重要的结果。

很明显，虽然这对于我们基于可见性的特征提取来说确实令人鼓舞，但一个更现实的用例——如我们的介绍部分所描述的——是仅从少数数据点预测购物行为:为了为我们的合作伙伴释放商业价值，我们真正想要的是以下问题的答案:

当用户轨迹中只有 1，2，3，… N 个事件时，该模型在计算购物事件是否可能在序列的后期发生方面有多好？

为了回答这个进一步的问题，我们从预处理的数据集中提取了每个轨迹的第一个 m 点( m = 4，5，…)；像往常一样，我们随机丢弃no-buy轨迹来平衡我们的类。跳过乏味的细节，这些是基于可见性的分类(通过十重交叉验证评估)的结果，用于 m = 4，5，6:

Prediction accuracy with SVM at different values of m (i.e number of actions taken in the sequence).

一点都不差！

在目标网站上仅仅六个动作之后(产品视图、页面视图等。)，模型 10 次中有 7 次能够准确判断出用户是否要买某个产品！

最后，请注意，我们在现有文献中做了一些健全性检查:尽管在实现细节上有很大不同，但该模型实现的总体准确性水平与一些最先进的同行评审的论文相当。因此，我们的主要贡献是双重的:

• 首次将可见性图理论应用于点击流预测场景；
• 仅使用极其简单、易于计算且理论上很容易理解的特性来实现最佳精度。

正如预期的那样，我们计划在未来几个月发布一份关于我们工作的完整研究报告，并进行一些更正式的比较。

下一步措施和结束语

“真正的奢侈是定制。”—拉普·艾尔坎恩

通过可见性图表进行购物预测是我们第一个“公开”的 Tooso 实验室项目:

我们确实相信更好的科学造就更好的商业，清晰的商业用例可以释放伟大科学的潜力。

我们认为，在我们拥有的资源、时间和机会范围内，为整个领域做出贡献是我们的使命和公司 DNA 的核心部分:生产优秀的产品和推进该领域并不是相互排斥的目标，但它们确实是一枚硬币的两面。

作为这一全新领域的下一步，我们设定了三个中期目标:

• 在 arXiv 上发布一篇研究文章的预印版本，包括模型的所有细节:预处理、特征选择、验证等。；如果时间和社区的兴趣允许的话，我们也可以选择准备一个更好的版本在这个空间的会议上展示；
• 对我们的模型做进一步的迭代:当然我们可以用这么少的信息获得如此大的成功，但没有理由就此止步:从搜索行为开始(当然！)，我们会更深入，看看用更复杂的特性会获得多少精度；
• 以研究友好型许可证发布部分原始数据集——仍需要完成一些重要的工作，以确保数据匿名、有用和一致，但进一步为零售业的人工智能社区做出贡献的前景令人兴奋。

在产品方面，我们的团队已经在与我们的业务合作伙伴讨论如何最好地利用我们新模型的预测，努力阐明有趣的“基于意图的”工作流程的细节。

Intent-based workflow, a.k.a.“to each according to his intention”.

无论这项激动人心的工作会产生什么样的产品功能，有一点是肯定无疑的:我们将越来越接近的完全购物个性化的承诺，让网上商店无缝地修改他们的行为，以适应每一个单独的客户。

真正的奢侈确实是定制。

再见，太空牛仔

我们总是从学术界和行业从业者那里寻找疯狂的新想法。如果你对我们空间里的问题感兴趣，从 NLP 到时间序列分析，请伸手与jacopo . taglia bue @ tooso . ai分享你的故事。

别忘了从 Linkedin 、 Twitter 和 Instagram 上的 Tooso 获取最新消息。

感谢

感谢安德烈·波洛尼奥利、亚历山大·维考特伦和整个 Tooso 团队对本文前几稿的有益评论。

特别感谢卢卡斯·拉卡萨，他确保我只是温和地毁掉了我们一起做的出色工作:所有剩下的错误当然都是我的，而且仅仅是我的。

算法出错:算法的易错性和经济组织

原文：https://towardsdatascience.com/to-err-is-algorithm-algorithmic-fallibility-and-economic-organisation-dbe18bb32abc?source=collection_archive---------4-----------------------

A precision-recall curve in a multi-label classification machine learning problem.

算法失败

深入挖掘当今一些最大的技术争议，你可能会发现一个算法失灵:【1】

• YouTube 广告争议:该算法将一些全球最大品牌的广告放在带有仇恨言论的视频上
• 脸书视频争议:该算法在其用户的 feeds 中发布暴力视频。
• 谷歌自动完成争议:该算法引导人们到新纳粹网站寻找关于大屠杀的信息

这些错误主要不是由数据中的问题引起的，这些问题会使算法具有歧视性，或者它们不能创造性地随机应变。不，它们源于更基本的东西:事实上，即使算法是基于无偏见的数据生成常规预测，它们也会出错。犯错是算法。

算法决策的成本和收益

我们不应该仅仅因为算法出错就停止使用它们。没有他们，许多受欢迎和有用的服务将无法生存。然而，我们需要认识到算法是容易出错的，它们的失败是有代价的。这指出了在更多(算法支持的)有益决策和更多(算法导致的)代价高昂的错误之间的重要权衡。平衡在哪里？

经济学是权衡的科学，为什么不像经济学家一样思考这个话题呢？这就是我在这篇博客之前所做的，创建了三个简单的经济学短文，着眼于算法决策的关键方面。这些是关键问题:

• 风险:什么时候我们应该把决策交给算法，这些算法需要有多精确？
• 监督:我们如何结合人类和机器的智能来达到预期的结果？
• 什么因素使我们能够并限制我们加速算法决策的能力？

接下来的两节给出了分析的要点及其含义。最后的附录更详细地描述了这些插图(有方程式！).

建模建模

风险:随波逐流

正如美国心理学家和经济学家希尔伯特·西蒙曾经指出的、‘在一个信息丰富的世界里，注意力成为一种稀缺资源’。这既适用于个人，也适用于组织。

正在进行的数据革命有可能超出我们处理信息和做出决策的能力，而算法可以帮助解决这一问题。它们是自动化决策的机器，有可能增加一个组织能够做出的好决策的数量。这解释了为什么他们首先在潜在决策的数量和频率超出人力处理能力的行业中起飞。【6】

是什么推动了这一过程？对于一个经济学家来说，主要问题是算法的决策会创造多少价值。理性的组织会采用期望值高的算法。

算法的期望值取决于两个因素:它的准确性(它做出正确决策的概率)，以及正确决策的回报和错误决策的惩罚之间的平衡。【7】高风险的决策(惩罚比奖励大)应该由高度精确的算法做出。你不会想要一个运行核电站的古怪机器人，但如果它只是建议你今晚看什么电视节目，那也没问题。

监督:小心

我们可以引入人类监督员来检查算法做出的决定，并修复他们发现的任何错误。如果算法不是非常准确(主管不会花很多时间检查正确的决策)，并且纠正错误决策的净收益(即额外的奖励加上避免的惩罚)很高，这就更有意义了。成本也很重要。一个理性的组织会有更多的激励去雇佣那些报酬不高，而且工作效率高的人(也就是说，只需要几个人就能完成工作)。

根据之前的例子，如果一个人类主管在一个电视网站上修复了一个愚蠢的推荐，这不太可能为所有者创造很多价值。核电站的情况完全不同。

规模:机器和现实之间的竞赛

当我们扩大算法决策的数量时会发生什么？它的增长有什么限制吗？

这取决于几个因素，包括算法在做出更多决策时是提高还是降低了准确性，以及加速算法决策的成本。在这种情况下，有两个有趣的比赛正在进行。

1.算法从其做出的决策中学习的能力与它从新决策中获得的信息量之间存在竞赛。新的机器学习技术有助于算法“从经验中学习”，使它们在做出更多决策时更加准确。然而，更多的决策也会降低算法的准确性。也许它被迫处理更奇怪的情况，或者它没有受过处理新情况的训练。【9】更糟糕的是，当一种算法变得非常流行(做出更多决策)时，人们就有更多的理由去博弈它。

我的先验知识是，降低算法准确性的“熵力”最终将胜出:无论你收集了多少数据，都不可能对复杂、动态的现实做出完美的预测。

2.第二场竞赛是在创建算法的数据科学家和检查这些算法决策的主管之间进行的。数据科学家可能会“击败”人类监管者，因为他们的生产率更高:一个单一的算法，或一个算法的改进，可以在数百万个决策中扩大规模。相比之下，主管需要单独检查每个决定。这意味着，随着决策数量的增加，该组织的大部分劳动力成本将用于监督，随着监督过程变得越来越大、越来越复杂，成本可能会螺旋上升。

最后会发生什么？

综合考虑，我刚刚描述的算法准确性下降和劳动力成本上升，可能会限制一个组织能够经济地做出的算法决策的数量。但是这是否发生以及何时发生取决于具体情况。

对组织和政策的影响

我上面讨论的过程有许多有趣的组织和政策含义。以下是其中的一些:

1.找到合适的算法-领域匹配

正如我所说，在风险很高的情况下做出决策的算法需要非常准确，以弥补出错时的高额罚款。另一方面，如果犯错误的惩罚很低，即使是不准确的算法也可能完成任务。

例如，亚马逊或网飞等平台的推荐引擎经常会给出不相关的推荐，但这并不是一个大问题，因为这些错误的惩罚相对较低——我们只是忽略它们。数据科学家希拉里·帕克(Hillary Parker)在最近一期的“不那么标准偏差”播客中提到，需要考虑模型准确性和决策环境之间的匹配性:

“大多数统计方法都已针对临床试验的实施进行了调整，在临床试验中，你谈论的是人们的生命和因错误治疗而死亡的人，而在商业环境中，权衡则完全不同”

由此得出的一个结论是，在“低风险”环境中的组织可以试验新的和未经证实的算法，包括一些早期的低精度算法。随着这些改进，它们可以转移到“高风险领域”。开发这些算法的科技公司通常将它们作为开源软件发布，供其他人下载和改进，从而使这些溢出成为可能。

2.在高风险领域，算法决策是有局限性的

在错误造成的惩罚较高的领域，如卫生或刑事司法系统，以及在处理更容易受到算法错误影响的群体时，需要更加谨慎地应用算法。【11】只有高度精确的算法才适合这些高风险的决策，除非有昂贵的能够发现并修复错误的人类监督人员作为补充。这将对算法决策产生自然的限制:你能雇佣多少人来检查更多的决策？人类的注意力仍然是更多决策的瓶颈。

如果政策制定者希望在这些领域更多、更好地使用算法，他们应该投资 R&D，以提高算法的准确性，鼓励采用其他领域的高性能算法，并尝试新的组织方式，帮助算法和它们的监管者更好地作为一个团队工作。

商业机构也不能幸免于这些问题:例如，YouTube 已经开始屏蔽浏览量少于一万的视频中的广告。在这些视频中，正确的算法广告匹配的回报可能很低(他们的收视率很低)，惩罚可能很高(这些视频中有许多质量可疑)。换句话说，这些决定的期望值很低，所以 YouTube 决定停止做出这些决定。与此同时，脸书刚刚宣布，它正在招聘 3000 名人工监督员(几乎是其现有员工的五分之一)，以调节其网络中的内容。你可以想象监督更多决策的需求会如何限制其无限扩大算法决策的能力。

3.众包监管的利弊

保持低监督成本和高决策覆盖率的一个方法是将监督众包给用户，例如通过给他们工具来报告错误和问题。YouTube、脸书和谷歌都这样做了，以回应他们的算法争议。唉，让用户监管在线服务会让人感到不公平和不安。正如法学教授 Sarah T Roberts 在最近一次关于脸书暴力视频争议的采访中指出的:

这种材料经常被打断的原因是因为像你我这样的人遇到了它。这意味着一大群人看到了它并标记了它，贡献了他们自己的劳动和未经同意的暴露给一些可怕的东西。我们将如何应对那些可能已经看到这一点并在今天受到创伤的社区成员？”

4.为什么你应该总是让一个人在循环中

即使错误的惩罚很低，让人类参与算法决策系统的循环仍然是有意义的。如果算法的准确性下降，他们的监督可以为性能的突然下降提供缓冲。当这种情况发生时，人类发现的错误决策的数量和修正它们的净收益都会增加。他们还可以敲响警钟，让每个人都知道算法有问题，需要修复。【十三】

这在错误造成延迟惩罚或难以衡量或隐藏的惩罚的情况下尤其重要(比如错误的建议导致自我实现的预言，或在组织外部产生的成本)。

这样的例子很多。在 YouTube 广告争议中，之前错误的巨额累积罚款只是在一段时间后才变得明显，当时品牌注意到他们的广告是针对仇恨视频发布的。美国大选后关于假新闻的争议是难以衡量成本的一个例子:算法无法区分真实新闻和恶作剧给社会带来了成本，这可能证明更强有力的监管和更多的人类监督是合理的。政客们在英国大选前呼吁脸书加大打击假新闻的力度时已经表明了这一点:

“看看到目前为止已经完成的一些工作，他们对他们可以获得的一些用户推荐的响应不够快或者根本不响应。他们能很快发现病毒传播。然后，他们应该能够检查这个故事是真是假，如果是假的，就屏蔽它，或者提醒人们这个事实是有争议的。不能只是用户提到故事的真实性。他们(脸书)必须判断一个故事是不是假的。”

5.从抽象模型到真实系统

在我们使用经济模型为行动提供信息之前，我们需要定义和衡量模型的准确性、惩罚和奖励、环境波动导致的算法性能变化、监管水平及其成本，而这仅仅是个开始。【14】

这是一项艰巨但重要的工作，可以利用现有的技术评估和评价工具，包括量化非经济成果的方法(例如在卫生领域)。人们甚至可以在实施算法决策之前，利用组织信息系统中的丰富数据来模拟算法决策及其组织的影响。我们看到了更多这类应用的例子，比如欧盟委员会正在运行的金融‘reg tech’试点，或者最近一篇关于价格歧视的经济学人文章中提到的‘共谋孵化器’。

Coda:算法时代的渐进社会工程

在去年《自然》杂志的一篇文章中，美国研究人员 Ryan Calo 和 Kate Crawford 呼吁“进行实用且广泛适用的社会系统分析，考虑人工智能系统对各方的所有可能影响[借鉴]哲学、法律、社会学、人类学和科学技术研究，以及其他学科 T11。卡洛和克劳福德没有把经济学家列入他们的名单。然而，正如这篇博客所表明的，经济学思维对这些重要的分析和辩论有很大的贡献。从收益和成本的角度思考算法决策，我们可以用来管理其负面影响的组织设计，以及更多决策对算法创造的价值的影响，可以帮助我们在何时以及如何使用它们方面做出更好的决定。

这让我想起了杰伦·拉尼尔在他 2010 年的著作《谁拥有未来》中提出的一个观点:“随着时间的推移，经济学必须越来越多地关注调节人类社会行为的机器的设计。一个网络化的信息系统比政策更直接、更详细、更直接地指导人们。换句话说，经济学必须转变为大规模、系统化的用户界面设计。

设计让算法和人类一起做出更好决策的组织，将是这一议程的重要组成部分。

承认

这篇博客得益于 Geoff Mulgan 的评论，灵感来自与约翰·戴维斯的对话。上图代表了多标签分类问题中的精确召回曲线。它显示了当一个人设置不同的规则(概率阈值)将观察结果放入一个类别时，随机森林分类算法出错的倾向。

附录:关于算法决策的三篇经济学短文

下面的三个插图是算法决策情况的非常简化的形式。我的主要灵感来自于乔·斯蒂格利茨(Joe Stiglitz)和拉吉·萨(Raj Sah)在 1985 年发表的一篇论文《人类易犯错误与经济组织》(Human fallability and economic organization),该论文作者模拟了两种组织设计——层级制和“多层级制”(扁平化组织)——如何应对人类错误。他们的分析表明，在层级较低的决策者受到上级监督的层级组织中，倾向于拒绝更多好的项目，而在代理人相互独立决策的多党制组织中，倾向于接受更多坏的项目。从他们的模型中得到的一个关键教训是，错误是不可避免的，最佳的组织设计取决于环境。

小插曲 1:算法说也许

让我们想象一下，一家在线视频公司在其目录中匹配广告和视频。这家公司拥有数百万个视频，因此依靠人工来完成这项工作在经济上是不可行的。相反，其数据科学家开发算法来自动完成这项工作。【16】公司寻找最大化匹配决策期望值的算法。这个值取决于三个因素:【17】

-算法精度(a ) :算法做出正确决策的概率(0 到 1 之间)。【18】

-决策奖励( **r** ) :这是算法做出正确决策时的奖励

-错误惩罚( **p** ) :这就是做出错误决定的代价。

我们可以结合准确性、收益和惩罚来计算决策的期望值:

*E = ar – (1-a)p [1]*

当算法决策的预期收益大于预期成本(或风险)时，此值为正:

*ar > (1-a)p [2]*

这就相当于说:

*a/(1-a) > p/r [3]*

做出正确决定的几率应该高于惩罚与收益之比。

输入人类

我们可以通过引入一名人类主管来降低出错的风险。这位人类主管可以识别并修复算法决策中的错误。这种策略对决策期望值的影响取决于两个参数:

-覆盖率( **k** ): k 是人工主管通过算法检查一个决策的概率。如果k是 1，这意味着所有的算法决策都由一个人来检查。

-监督成本( **cs(k)** ): 这是监督算法决策的成本。成本取决于覆盖率k，因为检查更多决策需要时间。

有人工监督的算法决策的期望值如下:【19】

Es = ar + (1-a)kr – (1-a)kp – cs(k) [4]

这个等式表明了这样一个事实，即一些错误被检测到并被纠正，而另一些则没有。我们从[4]中减去[3]以获得来自监管的额外期望值。经过一些代数运算，我们得到了这个。

(r+p)(1-a)k > cs(k) [5]

只有当监管的预期收益(取决于算法出错、错误被发现的概率，以及将错误转化为正确决策的净收益)大于监管成本时，监管才有经济意义。

按比例放大

在这里，我考虑当我们开始增加n时会发生什么，这是由算法做出的决策的数量。

预期值为:

E(n) = nar + n(1-a)kr – n(1-a)(1-k)p [6]

成本是C(n)

随着n的成长，这些东西是如何变化的？

我做了一些假设来简化事情:组织希望保持k不变，当 n 增加时，奖励r和惩罚p保持不变。【20】

这留给我们两个随着n增加而变化的变量:a和C。

• 我假设算法的准确性随着决策数量的增加而下降，因为降低准确性的过程比提高准确性的过程更强
• 我假设C，生产成本，只取决于数据科学家和主管的劳动。这两种职业都有工资wds和ws。

在此基础上，通过一些计算，我们得到了随着我们做出更多决策，预期收益的变化:

∂E(n)/∂(n) = r + (a+n(∂a/∂n))*(1-k)(r+p) - p(1-k) [7]

这意味着，随着决策的增多，总的预期收益会随着算法边际精度的变化而增加。一方面，更多的决策意味着从更正确的决策中获得更大的利益。另一方面，准确性的下降会产生越来越多的错误和损失。其中一些被人类管理者抵消。

这就是成本的情况:

∂C/∂n = (∂C/∂Lds)(∂Lds/∂n) + (∂C/dLs)(∂Ls/dn) [8]

随着决策数量的增加，成本也会增加，因为组织必须招聘更多的数据科学家和主管。

[8]等于说:

∂C/dn = wds/(∂Lds/dn) + ws/zs/(∂Ls/∂n) [9]

每种职业的劳动力成本与其工资直接相关，与其边际生产率成反比。如果我们假设数据科学家比主管更有生产力，这意味着大部分成本的增加将由主管劳动力的增加引起。

组织决策的预期价值(收益减去成本)通过决策的均衡数量 ne 最大化，其中额外决策的边际价值等于其边际成本:

r + (a+nda/dn)(1-k)(r+p) - p(1-k) = wds/(∂Lds/∂n) + ws/zs/(∂Ls/∂n) [10]

扩展ˌ扩张

上面，我通过对每个被建模的情况做一些强有力的假设来保持事情的简单。如果我们放松这些假设，会发生什么？

以下是一些想法:

各种错误:首先，分析没有考虑不同类型的错误(例如，假阳性和假阴性，不同确定程度的错误等。)可能会有不同的奖励和惩罚。我还假设了奖励和惩罚的确定性，而将它们建模为从概率分布中随机抽取更为现实。这种扩展将有助于将公平和偏见纳入分析。例如，如果错误更有可能影响易受攻击的人(他们遭受更高的惩罚)，并且这些错误不太可能被检测到，这可能会增加错误的预期惩罚。

人类也不是完美的:以上所有假设算法会出错，但人类不会。事实显然并非如此。在许多领域，算法可能是带有根深蒂固的偏见和成见的人类的理想替代品。在这些情况下，人类检测和解决错误的能力受到损害，这降低了招募他们的动机(这相当于他们生产力的下降)。组织通过投资于技术(如众包平台)和质量保证系统(包括额外的人力和算法监督层)来处理所有这些问题，这些系统管理人类和算法失误的风险。

非线性奖励和惩罚:之前，我假设随着算法决策数量的增加，边际惩罚和奖励保持不变。情况不一定如此。下表显示了这些参数随决策数量变化的情况示例:

获得这些过程的经验处理非常重要，因为它们可以确定一个组织在一个领域或市场中可以经济地做出的算法决策的数量是否有自然限制，这可能对其监管产生潜在影响。

尾注

【1】我在狭义上使用“算法”一词，指的是将信息转化为预测的技术(取决于接收预测、决策的系统)。有许多过程可以做到这一点，包括基于规则的系统、统计系统、机器学习系统和人工智能(AI)。这些系统在准确性、可伸缩性、可解释性和从经验中学习的能力方面各不相同，因此在分析算法权衡时应该考虑它们的具体特征。

人们甚至可以说，机器学习是一门科学，它管理因无法消除算法错误而导致的权衡取舍。著名的“偏差-方差”权衡就是一个很好的例子。

【3】有些人会说个性化是不可取的，因为它会导致歧视和“过滤泡沫”，但这是另一篇博文的问题。

【4】达尼·罗德里克的《经济学法则》为模型提供了一个令人信服的理由，认为它是复杂现实的简化但有用的形式。

在 2016 年《哈佛商业评论》的一篇文章中，Ajay Agrawal 和他的同事概述了机器学习作为一种降低预测成本的技术的经济分析。我看待算法的方式是相似的，因为预测是决策的输入。

【6】这包括电子商务和社交网站中的个性化体验和推荐，或者金融中的欺诈检测和算法交易。

【7】例如，如果 YouTube 向我展示了一个与我的兴趣高度相关的广告，我可能会购买该产品，这为广告商、视频制作者和 YouTube 带来了收入。如果它向我展示了一个完全不相关甚至是攻击性的广告，我可能会停止使用 YouTube，或者在我选择的社交网络上大吵大闹。

【8】强化学习构建使用先前行为的奖励和惩罚来做出新决策的代理。

【9】这就是谷歌 FluTrends 系统基于谷歌搜索预测流感爆发所发生的事情——人们改变了他们的搜索行为，算法崩溃了。

【10】在许多情况下，惩罚可能是如此之高，以至于我们决定永远不要使用一种算法，除非它受到人类的监督。

【11】不幸的是，在高风险的情况下实现算法系统时，并不总是小心谨慎。凯茜·奥尼尔的《数学毁灭的武器》举了很多这样的例子，从刑事司法系统到大学录取。

【12】问责机制和正当程序是人为监督的另一个例子。

【13】使用 Albert Hirschmann 的退出、声音和忠诚度模型，我们可以说监督扮演了“声音”的角色，帮助组织在用户开始退出之前发现质量下降。

附录标出了我的一些关键假设，并提出了扩展建议。

这包括使用随机对照试验方法对算法决策及其组织进行严格评估，如 Nesta 的创新增长实验室提出的方法。

【16】这一决定可能是基于类似的广告在与不同类型的视频匹配时的表现，基于观看视频的人的人口统计信息，或其他因素。

【17】本博客中的分析假设算法决策的结果是相互独立的。在算法产生自我实现预言的情况下，这种假设可能会被违反(例如，从逻辑上讲，用户更有可能点击她看到的广告，而她不是)。这是一个很难解决的问题，但是研究人员正在开发基于随机算法决策的方法来解决这个问题。

【18】这并不能区分不同类型的错误(如假阳性和假阴性)。我会在最后回到这个话题。

在这里，我假设人类管理者是完全准确的。正如我们从行为经济学中所知，这是一个非常强有力的假设。我在最后考虑这个问题。

【20】我考虑最后对边际奖惩做出不同假设的含义。

为了获得未来的混合演出，自由职业者必须比人工智能机器人领先一步

原文：https://towardsdatascience.com/to-land-hybrid-gigs-of-the-future-freelancers-must-stay-one-step-ahead-of-ai-bots-2f8998910b34?source=collection_archive---------11-----------------------

这是 1776 年 12 月下旬的美国殖民地。革命士兵在白雪覆盖、疾病缠身的军营中挨饿、冻死、消瘦。大多数人没有鞋子继续战斗，许多人烧掉了他们的衣服，以免在特别寒冷的夜晚被冻僵。与此同时，在没有希望从资金短缺的羽翼未丰的美国国会获得拯救的情况下，完美风暴正在酝酿:由于没有几场重大胜利，士兵入伍很快将在年底到期。在那种情况下，士兵们需要做出选择:重新应征入伍，然后因为一个不太可能获胜的原因饿死，或者回家照顾家人，因为他们的家园被外国统治。

由于害怕军队开小差，乔治·华盛顿想出了拯救革命的最后一招:越过冰雪覆盖的特拉华州，在圣诞节庆祝活动分散了保守党士兵的注意力，使他们毫无防备的情况下，袭击英军营地。由于 18 世纪的战争在冬天停止了，这次袭击将是意想不到的，英国人将毫无准备地保卫关键的特伦顿要塞。

尽管如此，第一任 美国情报局长还是准备被自己的游戏打败。一名保守党间谍得到了华盛顿计划的风声，决定警告英国人。他走近英国上校拉尔，小心翼翼地塞了一张纸条在上校手里。拉尔沉迷于一场激烈的国际象棋比赛，他把纸条塞进口袋，以免注意力分散。这是第二天在上校的战场坟墓的口袋里找到的。

在被国际象棋拯救和奇迹般地击败英国之后，最后的努力取得了胜利。结果，美国的革命精神复苏了，士兵们选择延长他们的入伍时间，导致了更多的战场胜利，并最终导致了美国的独立。

啊，象棋。美国人欠这项运动很多。但是，我们的独立只是开始。快进 242 年，国际象棋现在正引领我们进入一场新的革命:讽刺地被称为“智力革命”。

人工智能与人类合作在世界舞台上获胜 随着华盛顿的胜利，今天，顶级国际象棋专家正在将一种不同类型的智能——人工智能(AI)——与国际象棋策略配对，以击败对手。半人马国际象棋模型将人类的直觉和计算机化的国际象棋引擎结合在一起，该引擎拥有国际象棋历史上数以百万计的专家棋局。自由风格的玩家咨询引擎，找到完美的下一步，带领他们走向胜利。这种现代的人加人工智能模型允许棋手制定他们的竞争优势，再一次带领美国队——像总部位于 DC 华盛顿州的数据分析师 Nelson Hernandez 的自由风格国际象棋队——在世界舞台上获胜。

通过混合团队，自由职业者组成了未来的企业团队 由于像埃尔南德斯这样的胜利，领先的品牌开始注意到人工智能的能力。将混合人类加人工智能团队融入他们的商业实践，他们正在设计类似的竞争优势，以在全球范围内竞争。

金融产品网站 elMejorTrato.com 在阿根廷、巴西、哥伦比亚、墨西哥和智利拥有 2100 多万客户，它使用混合自由职业者和人工智能(AI)团队来提高回报和削减成本。例如，他们的销售团队由人工智能机器人和自由职业者组成。首席技术官兼 elMejorTrato.com 联合创始人雷内拉·克里斯蒂安表示，他们依靠人工智能算法自动化了约 57%的销售查询，销售额提高了 24%以上，年收益增加了 370 万美元。虽然所有的销售任务都曾经由自由职业者执行，但现在承包商只教授销售机器人最佳实践，并处理让机器人困惑的异常查询。

在一个害怕工作被机器人抢走的世界里，像克里斯蒂安的人工智能应用这样的商业用例给自由职业者带来了希望。为了探索自由职业者在未来工作中的地位，Mavenlink 与领先的第三方市场研究公司 research now合作，调查了不同行业的 300 多名高管对雇佣承包商的看法。结果是:

• 79%的商业领袖认为雇佣合同工是一种“竞争优势”而且，
• 令人惊讶的是，4/5 的高管表示，他们雇佣合同工来担任管理和高管职位。

调查结束后，Mavenlink 的首席执行官兼创始人 Ray Grainger 评论了自由职业者在企业界的未来地位:“在重大变革中，高管们被迫重新想象他们如何组织和管理劳动力，我们越来越多地看到承包商是未来的首选模式。”

很明显，前瞻性品牌正在推动一个自由职业者非常适合的经济。但是，尽管这看起来很新奇，新的团队结构即将出现。品牌正在从国际象棋中获得启示，创造专家-自由职业者/人工智能团队的混合组合，这肯定会改变我们对商业团队的看法。

聪明的自由职业者磨练他们的专业知识，以领先人工智能一步
Mavenlink 的研究结果证实，自由职业者将继续在混合团队中发挥关键作用，即使人工智能机器人学会完成更多任务。只有 6%的公司领导预见到他们对承包商的使用会减少。这是因为，虽然领导者可能会依赖人工智能来完成重复性任务，但受访者对雇佣持有专业学位(35%)和拥有 10 年以上经验(29%)的承包商特别感兴趣。这种竞争优势使品牌能够将自由职业者置于比人工智能机器人更需要磨练技能的角色中。

因此，随着自由职业者从重复性任务的执行者转变为上层管理人员、高管和高知名度项目，他们必须不断提高自己的技能以超越 bot 能力，从而配得上混合团队的机会。WorkFusion 的营销副总裁亚当·迪瓦恩解释说:就像在国际象棋中一样，“智能机器可以帮助企业在每个类别中移动指针，但最终将企业置于首位的是人的创造力和独创性。”

elMejorTrato.com 的 Christian 以自由风格的国际象棋选手为例，为确保战略布局，为自由职业者提供了一个简单的目标:培养成为人工智能机器人教师的技能。正如国际象棋引擎掌握着历史上最好的国际象棋选手教给它们的战略步骤一样，在商业领域，人工智能机器人必须首先掌握最佳实践，然后才能提出适用于每种情况的适当策略。因此，通过磨练他们的专业知识，就像自由风格的棋手一样，自由职业者可以获得与人工智能一起工作的位置，执行超出机器人能力的任务，并教会它们如何工作。

按照这个建议，自由职业者可能会觉得，从长远来看，他们是在有目的地训练他们的替代者。但是，事实并非如此。随着人工智能机器人满足客户当前对即时回答和服务的需求，这些能力将成为现状。因此，消费者会期待更多的关注和忠诚。反过来，随着消费者需求的上升，自由职业者必须不断教导他们的合作机器人来满足并超越他们。最终结果是:自由职业者享有更稳定的长期职业机会，只要他们不断磨练自己的专业技能。

在混合世界中生存，成为人工智能算法教师，把杂务留给机器人 像 Hernandez 的混合团队正在创造国际象棋的世界级竞争优势。这是人工智能与国际象棋专家配对的直接结果，国际象棋专家首先教授人工智能引擎最佳实践，然后最终决定胜负。

同样，为了抓住混合团队的商业机会，Mavenlink 和 Renella Christian 让自由职业者走上自我提升的道路。为了在以人为本的未来混合团队中获得一席之地，将重复性任务留给机器，努力成为最佳实践专家，从而超越机器人。要做到这一点，建立凭证和经验投资组合。首先，抽时间定期参加课程，参加会议，阅读与您的产品相关的最新最佳实践。然后，寻求与具有前瞻性思维的品牌合作的机会，从而体验和实践你所在领域的卓越。通过实践和体验卓越，你将为成为教师做好准备，而不是技术的受害者。

用小奥维·德米特里安的话说。作为 BlocksEdit.com 的创始人和 12 年的自由职业者，是时候“让机器人做家务了”

要更好的学习数据科学，用科学！

原文：https://towardsdatascience.com/to-learn-data-science-better-use-science-ffaae3d56bea?source=collection_archive---------5-----------------------

Learning Data Science? Make the most of your learning by using evidence-based methods! Students who take notes by hand perform better on conceptual assessments.

如果你正在学习一项新技能，想想你是如何学习的。

我的计划是再也不做学生了。我喜欢学习。我喜欢学习的过程，作为一名教师和科学家，我不断地参与这个过程。我以为我已经不再扮演学生的角色了。我错了。我回来了。然而，这一次，我在用一种新的方式思考我的学习过程——用一种科学的方式。

拥抱学习的科学

人们花了很多精力去理解我们是如何学习的。我发现，在学习数据科学时，牢记循证学习方法有助于我用 Python 编码、构建机器学习算法，以及成为学员而不是导师。以下三个想法帮助我保持专注和乐观。

(1)成长心态:

今年，我的孩子们从三年级回家，带着指引他们成长心态的讲义。他们的教室里有专门介绍这个概念的公告板，他们被教导说，固定的心态就是当你认为你的智力、技能和天赋是固定的，不会改变。相反，有一个成长的心态意味着相信特质可以发展和改变(Dweck 2006)。通过工作、研究和学习，一个人的智力、技能和才能可以得到发展。有很多关于如何在学校应用成长思维的方法，对于个人，甚至对于组织。我的孩子被教导说，发展成长思维就像说“我还不擅长长除法”一样简单。

如果你正在尝试一些新的东西，或者如果你休学了一段时间，现在又回来了，或者如果你正在一个非传统的轨道上进入一个分析领域…你可能已经有了一个成长的心态。如果你已经有了一个成长的心态，并且正在学习新的技能，我说抓住这个概念，拥抱它，培养它；它可能是帮助你攀登眼前的数据科学之山的要素之一。当我用跳板完成我的数据科学项目的第一个顶点项目的初步探索性数据分析阶段时，我引导我内心的三年级学生，并提醒自己“我还没有运行我的第一个机器学习算法。”

(2)主动学习:

简单来说，主动学习就是边做边学。在大学 STEM(科学、技术、工程&数学)课程中，主动学习方法改善了学生的学习( Freeman et al. 2014 )。一些教育工作者有意融入主动学习技巧。如果你参加了课堂辩论，在课堂讨论中发言，在讲座中被要求与邻座“思考-分享”,设计并完成了自己的研究实验，或者在课堂上做了报告，你就是一个积极的学习者。这里的对比是被动学习或“舞台上的圣人”，在传统的学术环境中，你可能通过听讲座的被动方法接收所有内容。已经进行了大量的研究来比较主动和被动学习，包括试图确定有效教学和学习的最佳循证方法( AAAS 2009 ， Derting 等人 2016 )。

如果你真的想成为一名数据科学家，如果你加入了数据科学训练营，如果你通过交互式在线教程学习 Python 或 R，在这些教程中，你可以输入代码并运行它(例如，DataCamp、Mode Analytics、Codecademy)，你将通过主动学习获得技能。你可能会遇到一些纯粹被动学习的在线讲座——这很好，并不意味着你不会学到概念和想法。但是当你学习数据科学和提高你的编码和分析技能时，你将会学习这些技能，因为你正在积极地实践它们。花点时间承认每个迷你项目、深夜代码调试、黑客成功和你的顶点项目的每一部分的重要性。

(3)手抄笔记:

最后一个学习概念很简单。研究表明，用笔和纸手工做笔记，可以增加你学习和记忆的信息量(穆勒&奥本海默 2014 )。与打字的学生相比，手写笔记的学生在概念评估中表现更好。显然，当你写下这个概念时，你与这个概念的联系比你在课堂上打笔记时更具体。当我在大学授课时，我在第一天描述这项研究，但我不要求学生手写笔记。我认为学生们可能有他们自己打笔记的原因，这是一种个人偏好。

结论:

现在我回到了学生座位上，我已经在几个笔记本上写满了凌乱而忙碌的笔记，关于支持向量机和 K 近邻分类器之间的关键差异，关于自然语言处理的方法，关于如何进行信息面试。我通过写下来来学习。我在边做边学。我正在学习所有关于数据科学的知识，因为我相信我可以发展新的技能。不管我课程的下一个大主题是什么:“我还没有掌握那种类型的分析”。

来源:

AAAS。2009.本科生物学教育的愿景与变革:行动的呼唤。华盛顿 DC:美国科学促进协会。

德廷，T.L .，埃伯特-梅，d .，汉高，T.P .，马赫尔，J.M .，阿诺德，b .，帕斯莫尔，H.A. 2016。STEM 高等教育中教师专业发展的评估:结果的可持续性。科学进展，2(3)，e 1501422–e 1501422。【http://doi.org/10.1126/sciadv.1501422

德韦克，卡罗尔。2006.心态:成功的新心理学。

Freeman、Eddy、S.L .、McDonough、m . Smith、M.K .、Okoroafor、n . Jordt、h .和 Wenderoth、M.P. 2014。主动学习提高了学生在科学、工程和数学方面的表现。美国国家科学院学报，111(23)，8410–8415。http://doi.org/10.1073/pnas.1319030111

穆勒私人助理奥本海默医学博士。2014.钢笔比键盘更强大:手写笔记优于笔记本笔记，《心理科学》，第 25 卷，第 6 期，第 1159-1168 页。https://doi.org/10.1177/0956797614524581

睡觉还是不睡觉——Fitbit 数据分析

原文：https://towardsdatascience.com/to-sleep-or-not-to-sleep-fitbit-data-analysis-a81d28acac8e?source=collection_archive---------13-----------------------

劳累的一天并不总是能让你晚上睡得更好！你在网上浏览的内容也会影响你的睡眠质量。

我是一个相当健康的人，喜欢踢足球、跑步，通常会努力追求更好的生活方式。不知何故，我仍然在努力管理我的夜间睡眠！

注:该分析基于有限的样本量，可能不具普遍性。这是一本有趣的读物！

通过这个博客，我把我的睡眠、健身和浏览历史结合起来，得出了一些相关性，其中一些“可能”是虚假的！

今年 5 月，我买了一个新的 Fitbit Versa，从那以后，我几乎全天候跟踪我的睡眠和锻炼情况。在那几个月里，我还做了全职实习，因此我的日程安排很好，没有太大变化。

工作日 —工作

周末——学习或旅行

虽然我是一个非常不稳定的睡眠者。有些日子我睡 9 个小时，有些日子我几乎不睡觉。要么是因为工作或不安，要么是因为温度不合适。我想找出最好的方法来保证晚上睡个好觉，这样第二天我就会精神饱满！

我从在线仪表板上提取了我的 fitbit 数据。它包含以下几列:

数据集 1(睡眠数据)

**'Start Time', 'End Time', 'Minutes Asleep', 'Minutes Awake','Number of Awakenings', 'Time in Bed', 'Minutes REM Sleep','Minutes Light Sleep', 'Minutes Deep Sleep'**

我对数据进行了注释，添加了一个“日期”列，对应于睡眠的夜晚。如果我在 9 月 16 日醒来，看到那行数据，我把它标注为 9 月 15 日。所以即使我在凌晨 12 点之前或之后睡觉，也会被标记为 09/15。

这张图片让你知道我的睡眠有多不稳定。

我的平均睡眠时间是 6.33 小时，标准差是 1.1 小时。理想情况下，我希望标准偏差低于 0.5！

是的最小已经 2 小时 5 分钟了！ (谢谢佐治亚理工！😄)

在床上的时间=睡着的时间+醒着的时间

睡眠分钟=快速眼动睡眠分钟+深度睡眠分钟+浅度睡眠分钟

所有这三种睡眠类型都与睡眠时间呈正相关。

然而，当你醒来时，即使是快速眼动或深度睡眠中的微小变化也会让你变得暴躁或疲倦。

为了更深入地探索，我绘制了我睡觉时间和睡觉时间的直方图。虽然分布看起来只是发生了移动，但峰高还是有一些差异，这表明还有其他因素导致这两个变量之间的关系发生变化(从而导致分钟清醒)。

下面的醒来次数和在床上的时间之间的联合图具有 0.74 的皮尔逊系数。这可能意味着，是的，在花在床上的时间和醒来的次数之间有一个强有力的正相关关系，但这不是唯一的影响因素。

醒来的次数可能取决于当天的压力或努力程度或其他一些因素。

数据集 2(健身活动数据)

最明显的选择是获取我的活动数据。

**['Date', 'Calories Burned', 'Steps', 'Distance', 'Floors','Minutes Sedentary', 'Minutes Lightly Active', 'Minutes Fairly Active', 'Minutes Very Active', 'Activity Calories']**

我添加了一周中的天的变量和一个周末标志，后跟时移变量，以获取前一天消耗的卡路里、步数、距离、楼层和所有活动特征的值。

fitbit 将活跃分钟数大致分为:

分钟久坐，分钟轻度活动，分钟相当活跃和分钟非常活跃

与睡眠数据不同，这四个类别之间没有直观的关系，你可以非常活跃，而不必花很多时间在相当活跃的类别中。

然而，如果你仔细观察，会发现在某些情况下，非常活跃的图形(粉色)落后于相当活跃的图形(棕色)。

不出所料，周末标志与活动分钟数有相当高的相关性。它也和分钟久坐高度负相关，暗示我不只是在沙发上度过周末。(抱歉网飞)

我很高兴的一个观察是，我的活动(消耗的卡路里或活动卡路里)与我前一天的活动 没有“高度”相关(负相关)，这意味着我不会因为前一天跑步或锻炼就休息。

在结合数据集 1(睡眠)和数据集 2(健康)时，我得到了一些有趣的假设。

我不得不深入挖掘，从数据中找出一些规律。是的，这不是分析应该做的，但我真的想了解我的活动和睡眠模式之间的关系。

1. 轻度活动分钟与清醒分钟数和卧床时间负相关。这意味着，当我那天稍微活跃的时候，我会获得更好的睡眠质量。此外，第二天晚上的睡眠也更好。这一切显然是在控制其他参数
2. 分钟非常活跃与分钟睡眠、醒来次数和在床上的时间有轻微正相关当前睡眠和下一个。这是因为高强度的体力消耗(足球/橄榄球和我的 5 公里跑步)会导致更高的肌肉恢复，这通常会将你踢出睡眠阶段，因此你会睡得更久。这也蔓延到第二天晚上！

数据集 3(网络使用数据)

我一直喜欢在 chrome 上跟踪自己的使用模式，并在 chrome 上安装了一个“Webtime tracker”插件。它追踪了我在每个网站上花费的时间(以秒为单位),并在我空闲 45 秒或离开页面或切换应用程序时停止计数。

所以是时候把这个也放进去了！

我把所有的网站分成 7 类；

通用、佐治亚理工学院、新闻、社交媒体、体育、视频流和工作

1. 乔治亚理工学院的相关浏览在工作日进行，这很令人惊讶，因为我本想在周末处理学校的事情。我想应该改变这一点！
2. 社交媒体在一周内要少得多。(是的，我是一名勤奋的实习生)
3. 周末视频流和体育活动非常多。这一周的体育价值有所上升，这可以归因于“世界杯”！
4. 最后，我再也没有把我的工作带回家，数据不会说谎(也许在周末做了一点)。我猜是启动和关闭 AWS 集群吧？)

我终于把 3 个数据集全部组合起来了！

我不知道为什么，但我很喜欢相关图。由此我想指出体育浏览和睡眠之间的关系。

1. 体育浏览与负相关与深睡同一天晚上正相关与浅睡。

深度睡眠促进身体恢复以及记忆和学习方面。这个阶段也被证明可以支持你的免疫系统。

浅睡促进精神和身体恢复。

这是 Fitbit 网站提到的。那么，看更多的体育比赛是否会导致更多的浅睡眠，从而有助于精神恢复以克服压力？我非常喜欢足球比赛(即使阿森纳没有比赛)，这很可能是真的。不过话说回来 相关性并不意味着因果关系！

1. 工作期间少视频流！是的，我是一名好员工！(迭代次数:P)
2. 所以在我的案例中，社交媒体与睡眠时间有直接关系。但社交媒体浏览和深度睡眠之间存在反比关系。这有什么意义？

更多社交媒体= >更多睡眠= >深度睡眠减少但浅度睡眠增加(精神恢复？有趣的..)

结论

1. 分钟相当活跃起着很好的作用，决定了我那天晚上睡着的分钟睡眠。所以，是的，你必须参加一些公平的活动来获得一个好的睡眠时间！
2. 此外，当天和之前的分钟轻度活动在确定夜间睡眠时起到良好的作用。如果你一天的光照活动较少，你的睡眠时间就会减少！但是根据你前一天的活动，你仍然有深度睡眠时间
3. 在我跑步去皮埃蒙特和/或踢足球的日子里，距离很远。这通常会导致大量消耗(增加相当活跃和非常活跃的时间)。此外，在工作日，距离更长，因为我上下班要走很长一段路。 前一天走过的距离也会影响当天的睡眠。因此，一夜的睡眠并不能完全克服体力消耗！
4. 非常活跃的时间对睡眠质量有相反的影响，这意味着过度劳累是不好的。过度劳累通常会导致睡眠期间身体恢复不一致，而且你往往会在晚上醒来更多。深度睡眠可能会增加，但这是以快速眼动为代价的。当快速眼动不一致时，你会醒来。通常情况下，当晚的深度睡眠会减少，第二天早上你会感到昏昏沉沉。然而，第二天晚上的睡眠更重要，这是你身体恢复的地方
5. 令人惊讶的是(或者不是),乔治亚理工学院在这份名单上得分很高，这意味着如果我有学校作业，我会睡得更少，晚上醒来更多(相关图表证实了这一点)。我不知道为什么。可能读研压力大吧！

我希望通过这个我至少能够减少我晚上睡眠时间的标准偏差，并且有一个更好更稳定的睡眠时间表！

[## jehlokhande93/FitbitAnalysis

分析从我的可穿戴设备收集的 fitbit 数据- jehlokhande93/FitbitAnalysis

github.com](https://github.com/jehlokhande93/FitbitAnalysis) [## Jeh Lokhande -数据科学家实习生- Cox Communications | LinkedIn

查看全球最大的职业社区 LinkedIn 上 Jeh Lokhande 的个人资料。Jeh 列出了 6 项工作…

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

要理解某些东西，请将其可视化:探索 2018 年平昌冬季奥运会的奖牌结果

原文：https://towardsdatascience.com/to-understand-something-visualise-it-exploring-the-medal-results-of-the-pyeongchang-winter-9cfab4bf0c21?source=collection_archive---------7-----------------------

我不太喜欢运动。但每隔两年，我突然发现自己对世界上最伟大的运动员的体育统计数据和比赛结果着迷了。奥运会激发了我潜在的体育爱好者，在这辉煌的两周里，我对体育运动百无聊赖。

今年，单调乏味的生活打破了我对冬季奥运会的兴趣。因此，当奥运会于 2 月 25 日结束时，我发现自己非常不了解各国在整个奥运会期间的表现。

很自然地，我浏览了标题，寻找谁赢得了什么的亮点。很快，奖牌榜就填满了我的浏览器窗口。

奥运会官方网站信息量很大，给了我每天的奖牌获得者，这太棒了。

但这并没有真正给我一个我一直在寻找的广泛的概览，所以我继续寻找。

时间以熟悉的格式提供了标准的最终奖牌数，所以越来越近了。但我仍然觉得我错过了过去两周发生的很多事情。

我一直在寻找一些更微妙的东西，最终导致这个来自彭博的奖牌追踪器。通过将奖牌与国家 GDP 和人口等有趣的变量结合起来，这一项脱颖而出。我喜欢能够在奖牌榜旁边的表格中看到这种情况。

但即便如此，我还是有疑问:是不是有一个国家自始至终主宰着奥运会？就奖牌数而言，有没有最后一分钟的逆转？顶级国家之间的奖牌分布有什么不同？

这些都是旧数据表无法回答的问题。

要理解某事，想象它

今年的冬奥会有很多精彩的视觉报道(特别是: NYT 、卫报、彭博)。但是一眼看去，我很难找到任何好的奖牌结果的可视化数据。所以我开始做我自己的。

这里应该注意的是，从技术上讲，表格是数据可视化。事实上，这是赋予数字视觉结构的最古老的记录形式之一。但是有些问题不能用表格来回答(或者即使可以，与其他形式的数据可视化相比，也要花费不合理的长时间)。

所以首先:谁赢得了平昌 2018？他们赢得的金牌总数也是最多的吗？谁是失败者？

当然，一个表格可以显示这一点。但是我想要能快速直观地告诉我这些信息的东西。

平昌 2018 谁赢了，怎么赢的？

我首先使用数据抓取器扩展从时间的奖牌结果表中抓取数据。如果你没听说过 Data Scraper，它很牛逼(TL；dr 这是一种不用写代码就能从网上抓取数据的快捷方式)。

除了奖牌类型的分类之外，我还想看到奖牌总数的可视化结果。我最近还受到了一些更抽象的体育数据的启发，即视觉运动员制作的海报。在 Adobe Illustrator 中修修补补了一段时间后，下面是我最终得到的结果。

对我来说，一系列被想象成小倍数的饼图是有意义的。圆圈的总大小代表获得的奖牌数(也是按照信息图中从多到少的顺序排列)。颜色分类显示金、银和铜。我还认为，在页面底部加入破纪录的事实，作为挪威今年在奥运会上如何占据主导地位的一点背景，是有意义的。

话虽如此，我的一位同事指出(相当正确)，从信息设计的角度来看，这是一个有争议的选择。在不太专业的情况下，使用每个饼图的半径大小和百分比分解开始混淆视觉隐喻，打破了信息设计中的可访问性和准确性规则。出于这个目的，我认为规则有时是要被打破的。我的目标是一个更抽象的概览；更准确的图形应该包括标签和/或悬停功能，以便于访问。

Illustrator 通常不是我的首选数据工具，但我很难找到可以将多个小饼状图作为模板的工具。我也没有时间从头开始编码，所以这似乎是一个合理的(虽然有点乏味)解决方案。我回答了我的第一组问题:现在我可以以表格之外的格式看到最终结果。

奥运会每天的奖牌总数是如何变化的？

太好了！现在我有一个漂亮的信息图表，总结了奖牌的结果。但它并没有真正重温每天是如何颁发奖牌的。它只显示总数。冬奥会激动人心的一部分是看着个别运动员为他们的国家取得成功，以及这将如何影响这个国家的奖牌总数。

这个有点棘手。首先，尽管我知道在哪里可以找到这些数据(olympics.org ),但这绝不是人们所说的“整洁”的数据。它存在于多个页面上。

获取这些数据的聪明、有效的方法是使用 urllib、requests 和 BeautifulSoup 的某种组合编写一些 Python 来创建一个 web scraper 并下载数据进行清理。不幸的是，这一天我感觉特别顽固，只是不停地点击使用 DataScraper(比使用 Python 花费的时间要长得多)。自我提醒:有一天我会更加自律，并看到用 Python 写脚本的长期好处，以备后用。

最终，我有一个非常混乱的数据集要开始清理。经过一番争论，我整理了所有的东西，以显示每一天，哪些国家获得了奖牌(以及他们获得了什么类型的奖牌)。

我使用了一个数据透视表来计算奥运会每天颁发的奖牌总数。因为开放数据很酷，你可以查看和使用我从谷歌电子表格中整理出来的任何数据。详细信息和注释在自述文件中。

最终，我终于能够开始想象。我一直想尝试新的 data viz 工具，所以我决定这将是我的首选工具。此外，他们有一个可视化选举竞赛的漂亮模板。我不会可视化选举数据，但通过对设置进行足够的修改，我能够重新标记和格式化，以匹配我的冬季奥运会数据。

我喜欢这种形式，因为它让你看到在两周内游戏是如何进行的。另外，我可以添加图像链接，包括国旗，而不是纯色泡沫。全交互版本允许你悬停在气泡上并重放图形。现在，这里有一个漂亮的 GIF 版本作为预览。

View the full interactive here

更大、更富有的国家更有可能获胜吗？

从历史上看，大国似乎在全球体育比赛中表现强劲。但是冬奥会也是这样吗？

这就是彭博桌开始派上用场的地方。我做了一个快速的抓取，把它放入一个电子表格中(查看这里的)。我知道，可视化这种可能的相关性的最佳图表可能是散点图/气泡图之类的东西，所以可视化的选项几乎是无限的。但是最近我发现 DataWrapper 已经成为我创建易于发布的快速图表的首选资源。

来自彭博的简单表格给了我一个问题的提示:美国排在第四位，但是像中国和英国这样的大城市不在前十位。但同样，可视化数据让一切变得更加清晰。虽然 GDP 和人口在某些情况下可能有所帮助，但它似乎不会在很大程度上影响冬奥会的成功。(免责声明:就 GDP 而言，中国和美国是两个相对较大的异常值，这不可避免地会影响相关性。话虽如此，挪威和荷兰与其他国家相比，都处于国内生产总值的中等水平，而且都在奥运会上表现出色，因此这似乎强化了一个事实，即较小的国家实际上可以取得成功。)

Full chart

滑雪板是兴奋剂。halfpipe 是怎么倒下的？

单板滑雪是冬奥会期间我最喜欢的项目。虽然我能够观看一些单板滑雪项目(slopestyle 很吸引人)，但我没有赶上所有的半管滑雪。这是一个大败笔。

奥运会官方成绩页面友好地提供了几乎每个项目的每次跑步的分数。所以在取下一些之后，我把它扔进了 DataWrapper，看看我能找到什么。

虽然每个滑雪者都有三次跑步，但我选择只包括前两次跑步，这样我就可以使用这个距离图。我感兴趣的是想象哪些滑雪板运动员是稳定的，哪些在压力下表现良好。不出所料，肖恩·怀特似乎是两者兼而有之。

然后，我把每个滑雪运动员按照他们的国家分组，以了解哪些国家培养出了最有天赋的滑雪运动员。将这张图表与奥运网站给你的视图类型进行比较。桌子不公平。

Full chart + link to data

外卖

桌子很棒。它们信息丰富、直观，是一种组织数字的通用方式。但是如果你想探索像奖牌成绩或比赛分数这样的信息，你必须将它们可视化。

我错过的冬奥会项目比我希望的要多。但以我自己有点书呆子气的方式，我觉得我可以通过钻研数据以不同的方式体验它们。

有问题吗？评论？很酷的数据集？在下面留言或者在 Twitter 上找到我。

今天我在和 Keras 午休的时候建立了一个神经网络

原文：https://towardsdatascience.com/today-i-built-a-neural-network-during-my-lunch-break-with-keras-65dae2c5d690?source=collection_archive---------3-----------------------

能够以尽可能少的延迟从想法到结果是做好研究的关键。

• Keras.io

所以昨天有人告诉我，你可以在 15 分钟内在 Keras 建立一个(深度)神经网络。当然，我根本不相信。上一次尝试(可能是 2 年前？)这仍然是相当多的工作，涉及编程和数学的综合知识。那是非常严肃的手艺。

所以晚上我花了一些时间研究了 Keras 文档，我必须说这看起来很简单。但是当我尝试的时候，我肯定会发现一些困难，对吗？习惯这些软件包有时需要几个月的时间。

第二天早上

于是第二天我就着手用自己的数据玩 Keras。首先，我开始在我们自己的内部包中重构一些代码，将数据转换成表格形式。这让我沮丧了一段时间。最后，回复邮件和问题占据了我一上午的时间。完成之后，我可以很容易地将我的一些数据导出到 csv 文件，用 Pandas 读取，转换成 Numpy 数组，我们就可以开始了。

午休时间

由于这是一个业余爱好项目，我部分牺牲了午休时间来做模型。Keras 和 Tensorflow 很快就安装好了，自从我上次尝试在 Windows 笔记本电脑上安装 Tensorflow 以来，非常容易。然后我实际上复制粘贴了 Keras 文档中的代码。我甚至不打算启动一个 github 库，这就是我所做的一切:

from keras.models import Sequential
from keras.layers import Dense
import numpy as npmodel = Sequential()
model.add(Dense(units=64, activation=’relu’, input_dim=1424))
model.add(Dense(units=2696))
model.compile(loss='mse', optimizer='adam')model.fit(predictors[0:80,], estimator[0:80,], validation_data=(predictors[81:,],estimator[81:,]), epochs=80, batch_size=32)
np.savetxt("keras_fit.csv", model.predict(data), delimiter=",")

这是什么？我正在建立一个模型，在一些密集的层上打耳光，完成它，拟合数据，并做预测。所有这些只用了不到 10 行代码。我今天不做任何超参数优化或智能层架构。但我必须说；呸，那太简单了！

下午

现在很好奇实际表现。所以我必须用一些基准来测试它。但是不要告诉我的经理我在这上面花了时间！(开个玩笑，他们鼓励一些探索和学习。)所以我将数据加载回我自己的测试框架，并运行一些其他算法。这是我的最终绩效指标的结果。

对于不到一个小时的模型制作来说，这是令人尴尬的好。我们研究了 1.5 年的超级秘密模型仍然胜过它(谢天谢地)。最重要的是，任何神经网络的一个大缺点当然是，对于它实际学到的东西，它是一个完全的黑匣子。而我们的秘密模型使用模式识别，我们可以在以后作为人类进行诊断。

结论

所以这也是我有史以来写得最快的文章，完全是在一种狂热的心态下写的。现在，我正在用一天中的最后几分钟写这篇文章，为制作 Keras 的人热烈鼓掌。以下是我的结论:

• Keras API:牛逼！
• Keras 文档:太棒了！
• Keras 成绩:牛逼！

任何想做一些深度/机器学习的人，我当然会建议从 Keras 开始。跑步是一件非常有趣的事情，你可以在以后学习和调整细节。

ToneNet:音乐风格的转变

原文：https://towardsdatascience.com/tonenet-a-musical-style-transfer-c0a18903c910?source=collection_archive---------2-----------------------

作者:南加州大学 Vesta 团队。

CSCI:599 深度学习及其应用

suraj Jayakumar(sjayakum @ USC . edu)、拉凯什·拉梅什(rakeshr@usc.edu)、(thalasta@usc.edu 帕拉德普·塔拉斯塔

简介:

最近，生成对抗网络在视觉领域的成功，如风格转换，启发我们在音乐领域尝试这些技术。音乐一代主要钻研两个最重要的东西:作曲和演奏。作曲侧重于宋立科的积木符号、音调、音高和和弦。而演奏则侧重于演奏者如何演奏音符。这种独特性定义了音乐的风格。

数据集和预处理:

我们有大约 200 首钢琴专用歌曲(MIDI 文件),分类为爵士乐和古典音乐，训练数据的平均长度约为 4 分钟。

首先，我们量化每一个 MIDI 文件，以符合特定的时间间隔，从而消除表演者的不精确性。其次，我们将输入的 MIDI 文件编码到一个 T ×P 矩阵中，其中 T 是歌曲中的时间步长数，P 是乐器中的音高数(例如，对于有 88 个键的钢琴，我们有 88 个音高)。此外，在矩阵的每个值中，我们使用 2-D 向量对关于音符的信息进行编码，即，[1-1]音符发音，[0-1]音符持续而[0-0]音符关闭。

类似地，我们生成 T ×P 形状的输出矩阵，但这里我们对歌曲的力度进行编码，即播放的下一个键的音量(1-127 ),而不是音符信息。

数据集链接:钢琴数据集【注:钢琴数据集配有 CC-BY 4.0 许可证。如果使用这个数据集，请参考这篇论文 :]

数据集链接(SeqGAN) : 诺丁汉数据库

建筑设计

序列间

序列到序列模型在过去被证明在各种领域对于风格转换非常有效，特别是在语言(机器翻译)中

基线— seq2seq

注意:基线架构在很大程度上借用了本文的内容。请参考同。还可以查看 Iman Malik 的 StyleNet，了解更多关于基线音乐风格转换的信息

歌曲的预处理 MIDI 文件被传递到具有动态 RNN 展开的编码器 LSTM，以处理不同歌曲中的不同时间步长并保持一致性。来自编码器的中间输出被传递到对应于其风格的 LSTM，其学习音乐流派的内部动态。

输入歌曲被反馈给相反流派的 LSTM。在风格转换过程中，输出被解码回一个 MIDI 文件，该文件代表风格转换后的 MIDI 文件。

基于注意力的 seq2seq

这个架构被进一步调整，以利用注意力机制，这样我们就可以对歌曲中我们希望网络更加重视的部分进行加权，尤其是中间的即兴部分。

来自编码器 LSTM 的输出通过注意机制传递(Luong 的版本)。这个包装器的输出被传递到解码器单元。

注意力计算发生在每个解码器时间步骤，其中我们计算与每个上下文向量相关联的注意力权重，该权重用于计算注意力向量，该注意力向量然后最终用于计算分数。

加工和后处理

要进行风格转换的歌曲(比如爵士歌曲)通过编码器传递到相反的风格(古典)，我们收集输出(古典输出)并使用此信息叠加到原始歌曲上，但使用 ToneNet 生成的古典速度。

车型评测

为了评估 ToneNet 的整体性能，我们将一首输入样本爵士乐歌曲传递到 ToneNet 上，并获得风格转换的古典歌曲。这种输出被反馈到网络中，我们试图将输入的歌曲重新生成为爵士乐类型，并与原始歌曲进行比较。原始歌曲和再生歌曲之间的这种数值 MSE 比较将决定 ToneNet 的性能。

VAE-甘

架构:

提出的架构是 VAE-甘(变分自动编码器生成对抗网络)的架构。通过将变分自动编码器与生成对抗网络相结合，我们可以在 GAN 鉴别器中使用学习到的特征表示作为 VAE 重建目标的基础。这使得训练过程明显更加稳定，因为生成器具有关于它试图生成的真实世界实体的信息，而不是在每次迭代中猜测真实世界实体应该是什么。此外，编码器学习图像到潜在空间的映射，这非常有用。

变型自动编码器

VAE 由两个网络组成，将数据样本 x 编码为潜在表示 z，并将潜在表示解码回数据样本。

VAE 损失减去预期对数似然(重建误差)和先前正则化项的总和

生成对抗网络

GAN 由两个网络组成:生成器网络 Gen(z)将潜伏期 z 映射到数据空间，而鉴别器网络分配 x 是实际训练样本的概率 y = Dis(x) ∈ [0，1]以及 x 由我们的模型通过 x = Gen(z)与 z∞p(z)生成的概率 1y。

在我们的设计中，我们用多个 88(时间步长数)X 88(音符数)图像来表示 midi 文件(钢琴轨道),其中每个像素值都是一个时间步长内给定音符的相应音量。

为什么是干的？

这是作为问题陈述的一个分支实现的，其中我们想要创建对应于不同类型的封面。这要求我们有能力从头开始创作完整的歌曲。对此的进一步扩展将是实现循环 GAN，其中该架构可以用作导致音乐风格转换的构建块。简单的 GAN 对于训练来说是不稳定的，并且我们丢失了潜在空间和生成的歌曲之间的映射。因此，我们使用 VAE 氮化镓架构。Midi 文件被转换成图像，以便更容易处理，因为基于卷积神经网络的 GAN 明显更稳定，更容易训练。

后处理

这里，输出包含 88×88 的图像，这些图像对应于生成的音乐的量化时间步长、音符和音量。我们需要将图像转换成相应的歌曲表示。我们正在构建一个新的 midi 文件，其量化间隔与我们在预处理过程中设置的相同，音符和音量与从生成的图像中获得的信息相对应。

结果

VAE-重建

利用噪声生成

想法

为什么建筑不起作用:- 我们认为它不起作用的原因是因为我们做了一个简单的假设，即只用时间步长、音符和音量来表达歌曲。还缺少其他关键部分，如音符开始和结束时间。由于量化，每个音符在输入中都表示为一个单独的笔画。这会给生成的音乐带来刺耳的声音。从结果可以明显看出，模型正在学习如何以相对较好的方式重建输入，并且生成的音乐在结构上与输入歌曲表示非常相似。例如，大多数音符被设定为 0 音量，平均每次有 2-3 个音符活跃，这表示正常的钢琴音乐。彼此靠近的音符通常一起演奏，重复的模式信息被采集。这表明模型运行良好，这里的错误在于世界假设，而不是用于完成这项任务的架构。

调查结果

VAE-GAN 明显比 GAN 更稳定。我们的许多简单的 GAN 实现导致生成器收敛到这样的模式

无论我们训练多少个纪元，发电机都不会改进。当使用 VAE-甘时，这种情况从未发生。

在训练模型时，动态调整学习速率非常有帮助。这是用来重新调整学习速度的确切代码。这确保了生成器和鉴别器都以稳定的速度改进，并且都不会超过对方。这里，learning_rate 是一个恒定值，它从 4e-4 开始，每个时期衰减 0.99。

generator _ learning _ rate = max(learning _ rate，min(learning _ rate (training _ loss _ gan _ g _ loss/training _ loss _ gan _ d _ loss)，gen_learning_rate20))

discriminator _ learning _ rate = min(learning _ rate，learning _ rate *(training _ loss _ gan _ d _ loss/training _ loss _ gan _ g _ loss))

未来前景

更好的输入和输出表示，更大的潜在空间，更多的训练样本，运行更多的时期。我们仍然相信这种架构可以用于进行音乐生成，但是存在某些限制，例如关于扩展序列的信息没有被保留，不像我们使用基于 LSTM 的模型那样。把这个扩展到 CycleGAN。

序列-GAN

这里使用的架构是 SeqGAN。以下步骤用于实现 SeqGAN 以生成音乐:

1. 建立一个递归发电机模型，在每个时间步从其 softmax 输出中取样。
2. 将采样序列传递给递归鉴别器模型，该模型区分采样序列和真实数据序列。
3. 在标准 GAN 损耗下训练鉴频器。
4. 用一个强化(政策梯度)目标训练生成器，其中每个轨迹被分配一个单独的情节奖励:由鉴别器分配给生成序列的分数。

生成式模型

基于 LSTM 的 RNN 模型被用于对映射输入嵌入表示 x1，.。。序列 x1，.。。，xT 转化为隐藏状态 h1，…，hT 的序列。

ht = g(ht1，xt)

softmax 输出层 z 将隐藏状态映射到输出令牌分布中。

p(yt|x1，.。。，xt) = z(ht) = softmax(c + V ht)，(10)

其中参数是偏置向量 c 和权重矩阵 v

判别模型

我们使用基于 CNN 的鉴别器，因为 CNN 最近在更准确地分类令牌序列方面非常有效。

我们首先将输入序列 x1，…，xT 表示为:

E[1:T] =x1 ⊕x2 ⊕…⊕xT

其中 xt ∈ Rk 是 k 维令牌嵌入，而⊕是构建矩阵 E[1:T] ∈ T×k 的串联算子。然后，核 w ∈ l×k 对 l 个令牌的窗口大小应用卷积运算，以产生新的特征图:

ci =ρ(w⊗e[I:I+L1]+b)，

其中，⊗算子是元素乘积的总和，b 是偏差项，ρ是非线性函数。我们在鉴别器的模型中使用 relu 作为非线性函数，并且 CNN 具有以下配置步长=[1，1，1，1]，padding =“VALID”。

最后，我们在特征图上应用最大时间池操作

c ̃=最大值

最后，我们应用基于汇集特征映射的高速公路架构，以在完全连接层之前增强性能，其中 sigmoid 激活给出了所生成的序列是真实的概率。

鉴别器交叉熵损失函数:

为什么 Seq-GAN

由于同样的原因，作为使用 VAE 干，我们尝试序列干创造相应的不同流派的封面。这要求我们有能力从头开始创作完整的歌曲。对此的进一步扩展将是实现循环 GAN，其中该架构可以用作导致音乐风格转换的构建块。简单的 GAN 对于训练来说是不稳定的，并且我们丢失了潜在空间和生成的歌曲之间的映射。因此，我们使用 Seq-GAN 架构，它可以像 RNNs 一样提供反馈。

预处理:

给定的音乐流被分成音符和和弦。音符按照我们用于其他模型的标准预处理进行处理

后处理:

生成的轨道被映射回它们各自的乐谱形式，并且 80 的恒定速度被用于再生。

思想:

SeqGANs 工作良好，这是因为从鉴别器到发生器中的 LSTMs 使用了反馈机制。这有助于序列生成，让它看过去生成的序列。尽管序列生成对于随机的新音乐输出工作良好，但是它不能用于控制风格转换的输出生成，因为编码器使用的潜在向量表示不能按照我们的输入音乐来指导生成。

模型评估:

我们使用 BLEU 作为评估度量来模拟离散钢琴键模式和连续音高数据模式的均方误差。

培训和设置

结果

序列对序列

INPUT JAZZ PIANO SONG FOR TONE-NET

OUTPUT CLASSICAL SONG (STYLE TRANSFERED)

正如你可以很容易地认为，有一个明确的风格转换输入歌曲(爵士乐)到一个新的流派(古典)。可以观察到，网络已经理解了古典流派的动态。该网络剪切了爵士音乐的高音，使得在古典形式的输出中听起来非常流畅和愉快。

序列-GAN

SEQUENCE-GAN OUTPUT

正如我们可以从上面的音频中发现的，对于给定的潜在输入，存在很多随机性。因此，我们必须控制这种随机性来生成音频，并在风格转换中使用 SeqGAN。

VAE 甘

VAE-GAN SONG OUTPUT

参考

1. [1] JazzML，https://github.com/evancchow/jazzml
2. [2]https://github.com/jisungk/deepjazz.deep jazz
3. [3] Magenta，Melody RNN(基于谷歌大脑的 LSTM 音乐生成)。
4. [4] WaveNet，【https://arxiv.org/abs/1609.03499】T4(wave net:原始音频的生成模型)。
5. [5]米迪特，https://arxiv.org/abs/1703.10847.
6. 【6】音乐风格的神经翻译，imanmalik.com/cs/2017/06/05/neural-style.html。
7. [7] SeqGAN:具有策略梯度的序列生成对抗网，https://arxiv.org/pdf/1609.05473.pdf
8. [8]使用学习的相似性度量自动编码像素以外的内容，https://arxiv.org/pdf/1512.09300.pdf

GITHUB 链接:https://github.com/sjayakum/csci599-final-project

就业可达性分析工具综述

原文：https://towardsdatascience.com/tools-for-analyzing-employment-accessibility-a-review-6f6466402224?source=collection_archive---------10-----------------------

我们实际上是如何进行这种分析的？

在我工作的俄勒冈州本德市，我们正处于制定 20 年交通计划的早期阶段。我们知道我们想要使用可达性指标来分析和比较未来的场景和潜在的交通项目，但是我们不确定具体如何去做。

随着这么多关于可达性映射的文章的出现，本德不可能是唯一一个环顾四周并想知道如何为自己测量的城市。这篇文章分享了我们学到的东西，希望能给其他有类似经历的城市一个好的开始。

或汽车或公共汽车或自行车。#悠悠悠悠

外面有很多闪亮的工具。当它们出现在我的电子邮件订阅源中时，看起来都很棒(我肯定它们都有好看的网站)，但是什么方法才真正符合我们的需求呢？尤其是对于像西雅图或纽约这样没有大都市资源的小城市来说。我调查了几种不同的工具和工作流程，看看它们是如何工作的，以及对 Bend 有什么意义。

从用户的角度来看，以下是我对以下内容的评论:

• 城市足迹
• 运输分析
• t 测试
• 自行车网络分析，由人供自行车
• 锤子方法:QGIS 和 Postgres
• Python 的乐趣:OSMnx(即将推出)
• 更贵的锤法:ArcGIS(即将推出？)

其中一些是开箱即用的解决方案，不需要 GIS 技能。其他的是原始代码或者需要一些使用来自 OpenStreetMap 的数据的经验，OpenStreetMap 是一个免费的、可编辑的、主要由用户贡献的地图。我注意到了所需的技能。我相信还有其他方法——使用评论部分添加一个链接到用户友好的解释或写一个简短的广告。

要求

我在模拟 2040 年的交通场景。我们的目标是使用就业可及性来比较交通基础设施和服务中不同投资的影响，能够回答如下问题:“如果有新的道路、新的自行车设施和缩短发车间隔的公交线路，我们未来的人口获得未来工作的难易程度如何？”。这意味着我需要一个可以接受大量自定义数据输入的工具(但是这篇文章应该是相关的，即使你没有这些需求)。

我想要一个能够回答以下问题“是”的工具:

• 它能模拟多种模式吗？
  我想计算行人、自行车、汽车和公共交通可达性的单独指标。
• 我能输入自定义的人口和就业数据吗？
  我正在为 2040 年的未来状态建模，所以我不想使用当前的人口普查数据。如果这些输入不必针对特定地理区域进行汇总/分解，则加分(例如，我希望能够向其提供我所获得的最佳数据，无论是在税收地段、人口普查区块还是 TAZ 级别)
• 我可以输入定制运输信息吗？
  我希望能够模拟新的道路，特别是自行车/ped 链接，以及对运输路线和头道的修改。对于自行车，我想限制网络，这样我就只在交通压力低的连接上安排人们的路线(LTS)。对于行人，我们有一个不完整的人行道网络，所以我想限制网络，这样我们就不会在没有人行道的繁忙道路上安排行人。

额外的奖励点是那些易于使用、便宜或免费、运行速度快、支持友好的工具。

城市足迹

它是什么:SIM-city——像规划软件一样运行土地使用方案，计算可达性，并使规划者能够回答“如果……会怎样”的问题，而不必向顾问支付大笔费用并等待其他人运行模型。自由！

30-min accessibility by transit, Bend. The menu bar illustrates all the things this can do, and also the fact that it can be a bit clicky

运作方式: Urban Footprint 收取年费。这相当实惠(大约 6k 美元/年),对于你所得到的成本来说，低得惊人。我不知道这些家伙是怎么赚钱的，tbh。如果你把数据贡献给城市足迹，费用会更低。你还需要为佛罗里达大学的工作人员支付一次性费用，让他们准备好你的“画布”,这样它就能与准确的土地利用数据保持同步。或者你可以直接用他们的底图数据，不用付定制费。Bend 正在经历一场增长热潮，因此这幅画布对我们来说似乎并不完全准确；我们本想对它进行定制，以适应大量的新开发。您的里程可能会有所不同。

书呆子因子:零。对于没有 GIS 背景的人来说，这是直观和用户友好的。对于那些希望能够查看、共享和摆弄数据分析而不需要专业软件的员工来说，这将是一个很好的工具。支持团队友好且乐于助人。准备输入数据发送到 UF 的人需要一些 GIS 经验。

它的优点:我觉得这是一个非常强大的工具，在一个平台上结合了土地利用和交通分析。这里有大量不同的特性和功能。用友目前可以计算行人、公交和汽车的可达性。除了就业可达性，它还可以计算到学校和公园等其他目的地的可达性。有 30 天的演示可以加分，这样你就可以看看它是否符合你的需要。

它没有做的事情(目前):用友的用户界面目前不能运行自定义路网*的场景。它使用当前的 OpenStreetMap (OSM)道路数据和公共可用的交通数据(以 GTFS 格式)。我无法定制这些输入，以便输入我自己的道路数据或将自行车分析限制在低压力设施上。开发团队告诉我们，通过一些定制($？)，这些功能将来可能会提供。如果您只是运行当前道路网的方案，应该没问题，但您应该确保您所在区域的 OSM 数据看起来完整。在这一页的底部有注释。

用友的界面有点点击，但我很乐意接受，以换取一堆功能。

*在幕后，有大量的附加功能，它们只是没有出现在用户界面中(还没有？).本演示文稿提供了更多信息。

其他评论:我们对数据定制过程有些琐碎的担忧。从法律上讲，我们不能将我们最详细的就业数据交给第三方，所以我们需要在发送数据之前汇总这些数据。路由引擎让行人跳过一个狭窄的峡谷，并在城镇的一部分涉水而过，但这种类型的问题只发生在非常特殊的地理环境下，并且对于许多路由引擎来说是常见的；这似乎是更详细分析的一个缺点。我们可以只手动调整输出数据中的结果。

总体来说:我真的很喜欢这个。它没有满足我们对这个特定项目的需求，因为我们需要如此多的定制基础设施输入，但它对其他应用程序可能非常有用。

输送分析

是什么:优雅的软件工具，旨在帮助规划者使用无障碍指标评估公共交通系统的变化。

Point-based accessibility: Drag-and-drop interface, easy to select the mode choice, nice results window

Regional accessibility results: Intuitive, interactive interface. (This is preliminary test data so don’t get too excited, fellow Bendites.)

工作原理:convetal 在该工具的托管版本中设置您的数据，并指导您如何使用它。联系他们定价(我没有，所以不能在里面称重)。

书呆子因素:使用该工具的托管版本，书呆子因素为零:非常直观，不需要特殊知识或经验。我没有在网络浏览器中登录这个工具的托管版本，而是在我的笔记本电脑上使用 Conveyal 发布的开源软件代码安装了整个系统，所以书呆子因素非常高。我建议采用前门方式。使用此工具后，如果您想要分析自定义道路网络，则需要一些使用 OSM 数据和 GIS 的经验。

它做得好:这是为了模拟公共交通的变化而设计的，天哪，它做得真好。分析采用 GTFS 公交数据，并使用它来可视化您的本地路线；该界面允许您与它们进行交互，以修改您的网络。真的很优雅。此外，分析允许您输入自己的道路网络数据(以 OpenStreetMap 的 PBF 格式)，这意味着我可以输入未来的交通网络来模拟未来的道路或限制自行车使用低压力设施。准备这些数据输入需要一些时间和精力。输入自定义的未来土地使用和人口数据非常简单，它将为您获取 2014 年的人口普查数据。计算运行得非常非常快。

这个工具还为我提供了各种输出:等时线、网格文件、图表和总体指标(例如，在 X 分钟内，Y%的 Bend 居民可以完成#####个工作)。它不仅仅返回我要求的结果，它还包括滑块，这样我就可以上下调整 X 或 Y。结果可以作为栅格下载。

它没有做什么(目前):这是一个比用友更专业的工具，所以它不是一个寻找通用土地使用和交通分析工具的地方(对我来说很好——那不是我现在正在寻找的)。我不确定如何计算公园或医院等土地使用地块的使用权，但我打赌这是 Conveyal 可以讨论的事情。有一些工作正在进行中，以适应这种分析低应力自行车设施，但这还不可用。

其他评论:convetal 有篇很棒的博客文章总结了他们关于可访问性的想法。准备输入数据让我想到将 OSM 数据与城市形状文件融合在一起有多难，以及对此工具的需求。

总的来说:这是我最终使用的——它完成了工作，比开发我们自己的分析方法更快更容易。这对运输机构来说尤其有利(毕竟这是它的设计初衷)。

t 测试

什么是 : TBEST(公交登机估计和模拟工具)是一种基于 ArcGIS 的交通工具，目前由俄勒冈州交通部开发。TBEST 具有许多详细的公共交通分析功能，它可以分析公共交通的可达性。

TBEST interface and Bend example

工作原理:该软件可以下载(免费)并与 ArcGIS 配合使用。它使用用户提供的输入道路网络、人口统计信息和 GTFS 数据。

书呆子因素:低，假设对 ArcGIS 有些熟悉。他们的网站上有培训材料，详细介绍了 TBEST 的功能和使用方法。

擅长领域:促进交通规划，提供非常详细的分析。TBEST 可以开发和运行未来的交通场景，预测未来的乘客量，充当 GTFS 编辑器，并促进人口统计、土地使用等的分析。离公交站很近。基于路线、停靠点和时间表来评估公交沿线的可达性分析。TBEST 还可以计算更详细的指标，比如基于所需传输次数的基于点的可访问性。

其他功能:TBEST 允许集成和编辑本地社会经济数据集(例如:MPO TAZ 文件，其中包含基本和未来一年的社会经济分布、来自区域交通需求模型的数据集、地块级别的土地使用数据以及为每个地块计算的一天中的人员交通活动级别。宗地数据由宗地编辑器补充，该编辑器允许规划者修改基准年的宗地分布，以代表未来一年的发展。)g

它没有做什么:其他模式的可访问性。行人进出公交系统的可达性是基于距离缓冲区而不是沿着道路/行人网络进行分析的。换句话说，该工具目前会告诉您附近的是什么，而不一定会告诉您从某个中转站可以到达的是什么。TBEST 中目前不支持汽车和自行车可达性分析。

总的来说:这不符合我的要求，因为它没有解决所有的模式。对于希望更好地了解和模拟其过境网络和潜在未来状态的过境机构来说，这可能是一个强有力的工具。

自行车网络分析，由人换自行车

是什么:对美国数百个城市道路网络的交通压力水平(LTS)进行的基于基础设施的评估。想将此作为自行车分析的一部分，但没有 LTS 的数据？这可能是一个有用的估计。这也计算了各种各样的可访问性指标*** ，但它们的准确性取决于您的 OSM 便利设施和景点数据的完整性 ***

工作原理:自行车爱好者利用 OSM 的数据，根据特定的 OSM 标签来推断道路网络的交通压力水平，并将其应用于美国各地的城市。分析是由 Toole 和 Azavea 完成的，他们对记录他们的方法学的检查结果感到惊讶，他们还公布了他们的权重和源代码。如果你更喜欢视频/音频，这里有一个关于他们流程的会议讨论。

你可以从网站下载计算的 LTS 网络。

Bicycle Network Analysis for Bend

它的作用:如果你很幸运，你所在的城市在列表中，你可以导出自行车网络数据以供使用。它还计算了一大堆可访问性指标，但是请阅读下面的注意事项。

它没有做什么:可达性指标基于 OSM 目前的便利设施等。对于像本德这样的城市来说，它并没有绘制出所有的便利设施，这可能会产生误导。对于一个已经绘制了详细地图的城市来说，这可以为您节省大量时间并为您进行计算。快乐中介:使用网络，对照你自己的工作/娱乐数据来运行。

总的来说: Bend 从以前的咨询合同和员工输入中获得了自己的、特定于城市的 LTS 数据。我们没有使用这个，但是它可能对其他人有价值。

锤子方法(QGIS 和 Postgres)

它是什么:一种使用免费工具的黑客方法，不需要特殊的用户界面、供应商费用或任何涉及合同的东西。这将使用与上述专用工具相同的方法——计算基于点的可达性，迭代“分析区域”网格，按人口对结果进行加权。区别？你可以自己完成计算的每一步，然后等待它运行一段时间。

工作原理: 克里斯·科勒写了这篇 QGIS 星球客座博文。它得到了安妮塔·格拉泽(QGIS 的守护神)的祝福，所以看起来是一个很好的开始。这将生成行驶时间等时线，并可适用于自行车和 ped 应用。这需要在分析网格上运行，并按人口进行加权，以便计算 X%人口的就业可达性。

书呆子因子:非常高。这需要 GIS 知识和使用开源软件包的经验——这不仅仅是运行 QGIS 的问题，还需要处理 Postgres 和命令行工具。

优势:避免专业软件和供应商合同。免费。强迫你理解分析过程。允许输入的无限定制。

它没有做什么:克里斯的博文没有提到公交。这是一个更难的问题，因为运输中涉及到路线、站点和时间表。我很有信心，如果你花些时间深入研究，会有某种 QGIS 插件来处理这个问题，但我不能保证。

总体而言:这是我们的备用方法，我真的很高兴我们不必使用它。步骤越多，出错的机会就越多……但你越能真正定制分析。你喜欢呆在一个只有电脑显示器灯光的黑暗房间里吗？厉害！这个可能是给你的(不是评判)。

Python 的乐趣: OSMnx (更多内容将陆续推出)

这个工具值得一提，它看起来真的很有用，但是我还没有时间去测试。

工作原理:这是一个基于 python 的工具，有很好的文档。它可以用于可访问性分析和许多其他应用程序。

书呆子因子:非常高。这比在 QGIS 中计算等时线更直接/自动化。但是它有一堆依赖关系。可能花更多的时间做准备，花更少的时间做分析。

擅长领域:避开专业软件和供应商合同。免费。强迫你理解分析过程。允许输入的无限定制。比 QGIS 方法更自动化。

它没有做什么:它没有解决中转问题。同样，我很有信心，如果你挖掘其他工具，会有办法解决这个问题。

总的来说:这是另一个我不必使用的备份，但这是我的一种愿望，并计划回来使用。

更昂贵的锤子方法:ArcGIS(更多内容即将推出)

是什么:如果我们使用基于 ESRI 的解决方案，我们的 it 部门会更高兴。如果你在市政府工作，那么你的 IT 部门可能也有类似的感受。网络分析功能不是 ArcGIS 许可的标准配置，由于某些原因，我们没有获得扩展模块。我们为此提交了一份内部申请。几个月后再来检查…

警告:我们的城市道路数据不是作为可路由网络构建的，因此可能需要额外的工作、开源工具或 OSM 数据来使该解决方案工作。

其他评论:OSM/开放数据社区和公共机构(比如我的)之间有时似乎有一条巨大的鸿沟，这条鸿沟实际上是在 ESRI 的道路上设置的。我了解到，无论一个工具有多好，除非它能以某种方式与 ArcGIS 兼容，否则许多机构都无法使用它。一些工具通过将结果作为栅格数据下载来实现这一点。如果在 ArcGIS 中有一种明确的使用方法(不需要命令行工具)，其他工具(如 Python 方法)会更有用。

注意:这些观点完全是我自己的，不代表本德市的观点。感谢 Seth Fitzsimmons 帮助我安装并运行了这些工具。

贸易工具

原文：https://towardsdatascience.com/tools-of-the-trade-f258362b44ec?source=collection_archive---------4-----------------------

视觉传达不一定要贵！这些是我最喜欢的——也是最实惠的——面向非营利组织和科学家的 dataviz 工具。

名称以粗体显示的工具是我经常使用的工具。其余的我已经看到了行动，并听说了他们的可用性的伟大的事情。

我错过了什么吗？请在评论中阐述你的观点！

静态可视化和设计

数据争论

• 微软 Excel——这个在技术上并不免费(或便宜)，但大多数组织已经有了。
• Google Sheets—Excel 的免费替代品。
• Python —行业使用较多的编程语言，有很棒的数据分析和 dataviz 包。
• R —学术界更多使用的编程语言，非常面向分析和统计，有很好的 dataviz 包。

装帧设计艺术

• Gimp—Photoshop 的免费替代品(仅限 Windows)。
• Pixlr 编辑器—Photoshop 的免费替代品(基于网络)。
• 亲和照片——Photoshop 的合理价格替代品。
• Inkscape—Illustrator 的免费替代品。
• 亲和力设计师——价格合理的插画师替代品。
• Adobe Creative Suite—可以使用 Illustrator、InDesign 和 Photoshop 来创建和修改 dataviz。Adobe 在网上和通过 TechSoup 为非营利组织提供折扣。

交互式数据可视化

对于程序员来说

• D3 . js—JavaScript 库，被认为是在线交互 dataviz 的行业标准之一。
• DC.js — DC 是 D3 的一个 JavaScript 便利库，帮助你更轻松地编写交互式仪表盘。
• 谷歌图表——谷歌的 dataviz 包有很多种图表类型，但是是为程序员设计的。

无代码的

• Tableau Public — Tableau 的免费产品。所有在免费帐户上完成的数据和可视化必须是公开可见的(没有私人数据)。
• Infogr.am —用于网站嵌入的拖放式图表创建。建立独奏和多图表创作。
• Datawrapper —快速简单的基于 web 的可视化创建器，但提供有限的图表选项。
• ChartBlocks —设计嵌入式交互式数据可视化的在线工具，有免费和付费两种方案。

其他交互式可视化

基于地图的工具

• 骑士实验室 StoryMapJS—StoryMapJS 引导用户通过一个空间故事。你选择站点并添加图片/视频，剩下的就交给它了。[ 阅读我的评论
• 谷歌我的地图——用感兴趣的点和区域创建一个可嵌入的地图。所有地图必须与谷歌帐户相关联。
• Google Earth Pro —从电子表格文件和 GIS 数据构建导游和解说地图。代码为 GEPFREE 的非营利组织免费。
• 地图盒子——谷歌产品的开源替代品。可定制性极强，但你会想要有一些 GIS /代码经验。

其他讲故事工具

• 如果你能使用 Google Sheets 并遵循指示，你也可以在你的网站上嵌入一个响应多媒体时间线。[ 阅读我的评论
• Knight Lab juxtapoejs—juxtapoejs 用一个滑块将两幅图像叠加在一起，来回切换。非常适合前后对比。

信息图表

• 【坎瓦】——拖放式图形设计，带有社交媒体模板。dataviz 有点弱，但它确实有风格。
• Piktochart —部分功能免费；更高级的功能需要适度的年费(可获得非营利折扣)。

书本学习

• 莎拉·达勒姆的《品牌提升》涵盖了为你的非营利组织建立凝聚力的来龙去脉
• ——由保罗·贾维斯教授，基本上是一个帮助 Hypsypops 起步的在线自由职业者 101 课程(附属链接)

自由职业者和商业工具

• Asana —项目管理 app，最多 15 个用户免费。
• Toggl —带浏览器扩展的灵活时间跟踪器。
• Teamweek —可视化任务规划器，我用它来制定工作计划和跟踪客户预定。
• —近乎免费的开票、付款处理、费用跟踪。****

原载于hypsypops.com。

利用大数据分析的十大行业

原文：https://towardsdatascience.com/top-10-sectors-making-use-of-big-data-analytics-be79d2301e79?source=collection_archive---------0-----------------------

大数据每天都在增长，并成为科技界一个非常流行的词。我们周围的许多人一直在谈论它，但他们知道它实际上意味着什么吗？

大数据不过是非结构化数据的集合。这些数据没有特定的格式，因此其数据集的大小通常很大，达到数十 TB，有时甚至超过数 Pb。术语“大数据”之前是使用数据库管理系统(DBMS)管理的超大型数据库(VLDBs)。

拥有如此多的业务相关数据为任何公司增加销售额或利润提供了一种非常合适的方式。但是为了做到这一点，我们需要利用大数据分析。那么什么是大数据分析？

大数据分析是检查大量不同数据集(即大数据)的过程，以发现隐藏的模式、未知的相关性、市场趋势、客户偏好和其他有用信息，从而帮助组织做出更明智的业务决策。在专业分析系统和软件的推动下，大数据分析可以为各种商业利益指明方向，包括新的收入机会、更有效的营销、更好的客户服务、更高的运营效率以及超越竞争对手的竞争优势。

此外，借助 Elasticsearch ，理解大数据变得更加容易。它用于网络搜索、日志分析和大数据分析。有许多其他工具，但 Elasticsearch 更受欢迎，因为它易于安装，无需额外软件即可扩展到数百个节点，并且由于其内置的 REST API 而易于使用。

如果利用大数据分析，以下是受益最大的 10 大行业:

1. 银行和证券:通过网络活动监视器和自然语言处理器监控金融市场，减少欺诈交易。交易所委员会或交易委员会正在使用大数据分析，通过监控股票市场来确保没有非法交易发生。
2. 通信和媒体:在多个平台(手机、网络和电视)上同时对全球事件进行实时报道。作为媒体的一部分，音乐行业正在使用大数据来关注最新趋势，这些趋势最终被自动调谐软件用来生成朗朗上口的歌曲。
3. 体育:了解特定地区不同赛事的收视模式，并通过分析监控单个球员和球队的表现。板球世界杯、国际足联世界杯和温布尔登等体育赛事特别使用大数据分析。
4. 医疗保健:收集公共卫生数据，以便更快地应对个人健康问题，并确定埃博拉等新病毒株的全球传播。不同国家的卫生部整合了大数据分析工具，以适当利用普查和调查后收集的数据。
5. 教育:为各种快速发展的领域更新和升级规定的文献。世界各地的大学都在使用它来监控和跟踪学生和教师的表现，并通过出勤率来反映学生对不同科目的兴趣。
6. 制造业:利用大数据提升供应链管理，提高生产力。制造企业使用这些分析工具来确保以最佳方式分配生产资源，从而获得最大收益。
7. 保险:从开发新产品到通过预测分析处理索赔，无所不包。保险公司使用业务大数据来跟踪需求最大、收入最高的保单方案。
8. 消费贸易:预测和管理人员配备和库存需求。消费者贸易公司通过提供积分卡和跟踪积分卡来发展他们的贸易。
9. 运输:为了更好的路线规划、交通监控和管理以及物流。这主要是由政府纳入，以避免交通拥挤在一个地方。
10. 能源:通过引入智能电表减少漏电，帮助用户管理能源使用。负荷调度中心正在使用大数据分析来监控负荷模式，并根据不同的参数辨别能耗趋势之间的差异，并以此作为一种纳入夏令时的方式。

早期的大数据系统大多部署在内部，特别是在收集、组织和分析大量数据的大型组织中。但是云平台供应商，如亚马逊网络服务( AWS )和微软，已经使得在云中建立和管理 Hadoop 集群变得更加容易。

慢慢地，许多公司开始转向大数据分析，以利用他们已经拥有的大量数据，但未能从中获得意义。

前 10 名 USAPL 原始国家总数

原文：https://towardsdatascience.com/top-10-usapl-raw-national-totals-4a80ee754be1?source=collection_archive---------16-----------------------

随着 2018 年 USAPL 全国锦标赛明天开始，让我们回顾一下以前的全国比赛，看看我们现在的运动员面临着什么。随着举重运动的日益发展，新的记录不断被创造，登上领奖台的竞争空前激烈。鉴于美国队这些年在 IPF 世锦赛上的表现，特别是今年比赛的成绩，可以有把握地说美国是世界上最强的举重国家。

操纵来自 OpenPowerlifting (使用 Python)的数据，我放大了在全国运动会上获得的 USAPL/IPF 原始总数( USAPL 承认以下国家记录:大学、高中、宪兵/消防、仅坐凳、仅深蹲、男子全国、女子全国和全国硕士)。我不包括阿诺德体育节的数字。

我保留除法运算，并考虑以下体重级别的男性和女性数据:

• 男子:59 公斤，66 公斤，74 公斤，83 公斤，93 公斤，105 公斤，120 公斤，120 公斤以上
• 女子:47 公斤，52 公斤，57 公斤，63 公斤，72 公斤，84 公斤，84 公斤以上

每个重量级的前 10 个总数如下所示。

前 10 名 USAPL 男士的原始总数

59 公斤

在 59 公斤级中，有四个最高纪录是由青少年创造的。就像我们将在下面的所有表格中看到的一样，去年在奥兰多举行的 Raw Nationals 在 USAPL 这个级别上取得了最高的总成绩。

66 公斤级

基思·麦克霍尼在 66 公斤级中获得最多的总成绩，连续 4 年在公开级别中名列第一。世界冠军查尔斯·奥克波科(总杆数 688 杆)今年会在华盛顿州斯波坎市取代他成为美国第一吗？

74 公斤

世界冠军泰勒·阿特伍德在 74 公斤级中获得最多的总成绩。他在去年全国赛上的成绩仅比今年世界纪录低 8 公斤。

83 公斤

在全国比赛中，83 公斤的最高纪录是由约翰·哈克保持的。由于他没有参加今年的全国赛，Russel Orhii 会再次获得第一名吗？肖恩·诺列加在今年的马萨诸塞州和罗德岛州锦标赛中总共获得 785 分，高于奥尔希在世界锦标赛中的 783.5 分。

93 公斤

世界冠军 LS McClain 将在今年的黄金时段与 Ashton Rouska 正面交锋。两人去年总共赚了 840 公斤，这将是一场值得观看的表演。

105 公斤

105kg 是我个人最喜欢看的。布莱斯·刘易斯和加勒特·布莱文斯在这个班里各有 3 个最高分。由于刘易斯今年没有参赛，让我们看看布莱文斯是否会获得第一名，他已经连续三年获得第二名。

120 公斤

丹尼斯·科尼利厄斯会回来拿第一吗？

120 公斤以上

除了说雷·威廉姆斯是全美最强的男人还能说什么？是赚钱的时候了。

十大 USAPL 女性原始总数

47 公斤级

希瑟·康纳是一个值得关注的人，他今年 3 月在阿诺德斯完成了 4 倍体重的硬拉，确保了 558 威尔克斯。

52 公斤级

三位女选手在 52 公斤级比赛中独领风骚——玛丽莎·英达、蒂娜·达内什曼德和苏珊娜·哈特维格-加里。这三位女性将在黄金时段进行正面交锋。

57 公斤级

世界冠军詹妮弗·米利肯今年将升级到 63 公斤级。在今年的全国比赛中，谁将取代她成为最强的 57 公斤级选手？

63 公斤

世界冠军珍妮·汤普森是 USAPL 运动员中总数最多的，为 6 人。她今年将再次面临激烈的竞争，詹妮弗·米利肯也加入了这个行列，对手是萨曼莎·卡尔霍恩，她今年以 221.5 公斤的成绩创造了新的硬拉世界纪录

72 公斤级

金伯利·沃尔福德拥有 4 项全国最高记录。虽然很不幸，她不再参加 USAPL/IPF 的比赛(因此，今年不会出现)，但我预计她将与克洛伊·道布林和克里斯汀·邓斯莫尔(首次以 72 公斤级的身份参赛)进行一场激动人心的对决。

84 公斤

世界冠军丹妮拉·梅洛在全国比赛中保持着最高的总成绩。她在今年的阿诺德斯继续以 572.5 分打破这一纪录，并保持着 571 分的世界纪录。

84 公斤以上

世界冠军博尼斯·布朗(前 Lough)会连续第五年重返榜首吗？

前 10 名 USAPL M/F 原始合计中最高合计数最多

如前所述，在 USAPL M/F 原始总额的前 10 名中，珍妮·汤普森拥有最多的最高总额，为 6。雷·威廉姆斯和金伯利·沃尔福德排名第二，各得 5 英镑；博尼卡·洛、苏珊娜·哈特维格-加里、基思·麦克霍尼、泰勒·阿特伍德和玛丽莎·英达各有 4 个孩子；丹尼斯·科尼利厄斯、布莱斯·刘易斯、李安·休伊特、加勒特·布莱文斯、迈克尔·图切勒、艾丽西娅·韦伯和大卫·里克斯各有 3 个。

美国一年比一年强大。像举重社区的许多人一样，我很兴奋地看到今年的比赛将如何改变我上面介绍的数字。这个项目的完整 Jupyter 笔记本将会出版…最终。

GitHub 上 100 个最常用的 R 函数

原文：https://towardsdatascience.com/top-100-most-used-r-functions-on-github-9caf2b81b314?source=collection_archive---------2-----------------------

Photo by Luca Bravo on Unsplash

互联网提供了大量可供分析的数据。有时，它甚至已经是易于使用的形式，例如，Google BigQuery 数据集中所有 GitHub 存储库的集合。我曾经想过 R 中哪些最常用的函数会影响 GitHub 的使用。

所有公共 Github 存储库的 BigQuery 数据集包含超过 3 TB 的数据。希望我们不需要所有东西，只需要 R 文件。我们将首先提取 big query-public-data:github _ repos . files 中 R 文件的 id，然后使用这些 id 从 big query-public-data:github _ repos . contents 中提取文件的内容。

选择所有 R 文件的 id:

SELECT *
FROM [bigquery-public-data:github_repos.files]
WHERE lower(RIGHT(path, 2)) = '.r'

选择 R 文件的内容:

SELECT *
FROM [bigquery-public-data:github_repos.contents]
WHERE id IN (select id from [bigquery-github-1383:Github.r_files])

内容摆在那里！当然，我们可以在这里继续，但是记住 Google BigQuery 不是免费的，我已经使用了大约 2 TB 的数据处理。1 TB 目前是 5 美元，但是如果你第一次注册 Google cloud 并获得 1 年 300 美元，你就可以省钱。您还可以限制处理的最大数据量，这样就不会在出现错误函数的情况下遇到问题。

由于我们也需要从 R 中提取数据，并且我稍后将使用它进行可视化，所以我将切换到 R，而不是在 BigQuery 和 R 之间来回运行。

最终文件的数据量为 1.2 TB。我可以下载它，但是它们将首先被放在 Google 云存储上，只有到那时才可供下载，所以我将使用 R 中的 bigrquery 包建立一个从 R 到 BigQuery 的连接。

big_query_data <- "certain-torus-206419"sql <- "SELECT content FROM [certain-torus-206419:Github.content_copy]"destination_table <- "certain-torus-206419:Github.r_2"content_r <- query_exec(sql, project = big_query_data, useLegacySql = FALSE, destination_table = destination_table, max_pages = Inf)

该软件包将自行处理授权，下载和处理数据只需 2 分钟。

最常用的 R 包及其功能

一旦我们得到了内容，我们就可以开始寻找功能。有两种方法——直接在 GitHub 文件中找到函数，或者在其他地方找到它们，并检查它们在 GitHub 代码中的外观。

第一种方法有一个问题——在不同的包中，不同的函数有时会使用相同的名称，之后我们可能很难区分它们。所以我会先找到所有函数及其包，然后检查它们在 GitHub 文件中的外观。

我想到的第一个想法是简单地运行 apropos(" ")来列出所有函数。然而，这个函数将只列出您环境中的函数，这可能是不完整的。所以，我决定从包装开始。我去看了所有的克兰套餐。我使用 Google Sheets 和这个公式(=ImportHtml( URL ，【表格】， num )从网页导入数据，列出所有包:

r 有 12 000 多个包！对 R 来说很好，但对我来说不是。当然，我们可以尝试列出所有函数，但我会从这一点出发进行优化。我们不太可能在很少使用的包中找到 100 个最流行的函数。所以，我会限制他们。我们先找一下排名前 100 的 R 包，以及其中的函数。希望这是之前由 Kan Nishida 在这里完成的。然而，我将使用类似的方法，用更多的原生 R 函数代替探索性的包。我还使用了稍微不同的语法来查找包，以包含括号后有空格的情况。这有助于在代码中增加大约 1500 个包的外观。

我找到了前 100 个函数。这真的很有意思，在过去的两年里这是如何改变的。

没有那么多，top4 一点都没变，我也没看到其他包有大的变化。

一旦我们知道了包，是时候获取这些包中的所有函数了。在此之前，我需要确保在我的环境中安装并上传了这些包。

安装是一个棘手的部分，我想控制我要安装什么，所以我一个接一个地安装，而不是用一个函数一次全部加载。不幸的是，手动步骤完成后，我将使用以下命令将它们上传到环境中:

 lapply(packages_100$value, require, character.only = TRUE)

然后通过以下方式获取所有已安装的软件包和功能:

functions <- sapply(search(), ls)

我必须说，我没有设法安装所有的 100 个软件包。唯一的原因是有些包不是 CRAN 包或运行 R 第二版(我用的是 3。).希望所有的前 50 名软件包都在那里，所以我认为忽略一些其他的不是问题。此外，当一个包因为某些原因(比如 limma )从 CRAN 中被删除时，我会有点怀疑。

总之，在清除了全球环境和数据集之后，我们有 99 个包，产生了超过 12000 个函数。挺好的！我可以过滤包含 R 文件内容的原始数据集，只包含这些包。

识别功能

现在我有两个选择。我可以尝试检测所有看起来像函数的单词(在 R 函数中可以包含大写/小写字母 _。和数字，我将排除运算符)，然后在列表中搜索相同的函数，或者尝试提取后跟“(”的函数。第一种方法将导致与英语中的单词相似的函数的更高外观。然而，第二种方法会忽略其他函数中函数的使用，比如 apply()，其中包含不带括号的函数。这两种方法都可能有失偏颇。因此，我将在更小的子集上运行这两种方法，看看是否有更好的方法。

我在 10000 行的子集上运行了 2 个方法，然后得到了计数差异高于 20%的结果:

结果有利于第二种方法——第一种方法排名较高的大多数函数要么是单字母函数，“a”文章、常用词，要么与软件包同名(这意味着它们将至少被计算两倍)。唯一出现的问题是 h2o 包装。这很奇怪，因为大多数函数都是标准形式，后面有一个括号。但是，让我们对接下来的 10000 行运行相同的脚本:

现在一切都很好，所以 h2o 包的问题只是一个非代表性子集的偏差。因此，第二种方法得到更准确的结果。

查找最常用的功能

另一件事是基础包和其他包之间的区别:当使用基础函数时，通常不会显式加载基础包。所以我将分别运行它们。

还有一个性能问题，我们的数据集相当大，大约 1.2 GB。检查所有的功能是一个更广泛的过程，会减慢这个过程。单独检查包将导致更少的处理。

要处理的过程如下:

-从字符串中提取所有可能的函数，

-取消包含功能的色谱柱，

-按封装和功能分组，

-计算每个实例的出现次数，

-对出现在所有函数列表中的实例进行过滤(对包和函数名使用内部连接)。

前 50 个函数的结果如下:

惊喜？不完全是，我们已经检查过 ggplot2 是最常见的包。

我将对基本函数重复这个过程。

这里也没有太多惊喜。

假设

我需要提到几个我没有考虑到的问题:

-自制函数内部的函数只计算一次。这是有疑问的，但我相信不会造成大的不同。但是，如果我愿意的话，我需要计算 function(x){}，并列出内部使用的函数，计算文件中新函数的使用次数，然后计算新函数的使用次数减 1，并添加到原始函数的总数中。在这里我相信这种复杂性不会获得更好的结果。此外，人们可以认为只计数一次更符合逻辑，因为函数实际上只使用一次。

-我没有计算是否有人重写了函数的行为。通常情况下，你不应该这样做，我希望真的很少有人这样做。

-我依赖的假设是，如果有人使用非基础包中的函数，她会显式地将该包添加到环境中。然而，情况并非总是如此。在没有对包名进行过滤的情况下，对 test 10000 行运行另一个脚本，比较对包的过滤和派生差异，我们发现，例如，ggplot2 包在多达 70%的文件中没有被加载。

嗯，不是最好的做法。我也相信非加载包的分布可能倾向于最常用的包。因此，结果可能有偏差，但是它有助于调出不太有名的包。

此外，它表明我们幸运地避免了分配在许多包中使用的常用函数的问题:

结果

所以我们来了！所有软件包中 GitHub R 上最常用的 100 个函数是:

它们中的绝大多数是基本函数，这是意料之中的，只有一些来自其他包的函数。

我还在GitHub(top _ 2000 _ functions . CSV)上传了一个包含 2000 个最常用函数的文件，所以你不需要运行所有代码来探索它们。

所有代码都在 GitHub 上。

印度黑客机器学习挑战赛前 15 名

原文：https://towardsdatascience.com/top-15-finish-in-indiahacks-machine-learning-challenge-a234d5fb4087?source=collection_archive---------6-----------------------

在几场艰苦的 Kaggle 比赛之后，Indiahacks ML challenge 看起来像是免费的！我对几千行代码记忆犹新，经过几周的努力，我在 800 多名参与者中排名第 14:)

出现的问题

• 市场细分(由 Hotstar 主持):基于每个用户之前的观看历史、观看的类型、每个节目的观看时间以及其他时间因素，我们必须预测特定的人群细分(auc 是误差度量)。现在这个细分市场的人口统计数据还不可用，我们所有的想法是观看特定类型/节目的人包含在这个细分市场中
• 路标预测(由 Here 主持):Here 的汽车在道路上行驶，捕捉各种路标的图像，顶部装有一个四向摄像头。给定这些图像周围的元数据，如每个凸轮与道路标志的角度、标志的纵横比，我们预测每个道路标志实际指向的位置(后、左、前或右)，m-logloss 是误差度量

我的方法 —我从几个启动脚本开始，以可理解的格式获取 jsons。像往常一样，用一个基本的随机森林提交获得了运行基础，它给出了一个相当高的准确性，只是用了给定的试探法。

这是为数不多的比赛之一，我真正关注的是可视化和理解问题陈述。通过比较不同类型的平均时间(热图),我发现板球显然不是我们细分市场的首选类型。

上图:所有工程特性相对于“细分市场”的热图

对于 roadsign 问题，我查阅了许多直方图，以了解哪些摄像机和各自的宽高比具有良好的预测能力。

上图:检测到左侧摄像头的 aspect_ratio 直方图，但路标指向前方。

市场细分—特征工程

• 特征整理:我通过观察它们与我们的目标变量的相关性来整理相似的特征。例如，“流派田径”、“流派羽毛球”、“流派拳击”、“流派板球”、“流派足球”、“流派方程式 1”、“流派方程式”、“流派曲棍球”、“流派印地亚夫萨”、“流派卡巴迪”、“流派体育”、“流派游泳”、“流派乒乓球”、“流派网球”、“流派排球”被组合成流派体育
• 一天中的时间:一天中的时间特征被分成正 _tod、超 _ 正 _tod 和剩余 _tod，同样基于它们与“段”的相关性
• 工作日/周末:我注意到周日是一个非常重要的特性，因为在 segment=0 行中，day_7 与其他日期的百分比更高。
• 流派:原 watch_time 考虑。此外，还考虑了一个类型的观看时间与总观看时间的比率。
• 节目标题分析 —取每个标题观看时间的均值、中值、总和。segment=1 行与 segment=0 行的比率。这些基于平均值/中值的特性很有意义。还比较了个人观看时间——与细分市场或总体人口的中位数相比，该节目的观看时间有多长
• 城市 —我试着开发一些基于城市的功能，但是没有得到太多的改进。

市场细分—洞察

热图对于判断某些功能的有效性非常有帮助。此外，具有 xgboost 功能重要性的验证管道帮助我缩小了我的假设——该细分市场的人口统计数据是中年全职妈妈。支持这一观点的数据:

• 几乎没人看板球，很多戏剧/家庭/爱情片都有人看。
• 一天中的高峰时间是下午(大约 14:00)和晚上(大约 22:00)。
• 周日对观看时间的贡献不如对其他人的贡献大。
• 顶级标题和观看次数，讲述了一个清晰的故事:)

路标预测—特征工程:

• 由于大部分特征是在纵横比和 detected_camera 中捕获的，所以我只使用了给定特征的一些变体:
• angle on right cam = angle on right cam - 50
• angle on rear cam = angle on rear cam - 180
• angle on left cam = angle on left cam - 220
• 生成了一些集合特征(基于检测到的 _cam 和目标的组合的平均角度)。也用了角度的不同 w.r.t 这些共同的方式。
• 截断的 ID —我认为截断的 ID(没有最后一个字符的 ID)可能会有一些影响，所以包括了具有相同 truncated_ID 的行的计数(可能表示同一辆汽车具有快速连续的快照)。

路标预测—洞察:

基本上，只要从前摄像头捕捉到图像，路标就很有可能显示“前方”。除了在汽车可能急转弯的情况下长宽比高度倾斜的情况，以及前置摄像头从一个奇怪的角度捕捉到的图像。长宽比本质上是，路标的视在高度除以路标的视在宽度，当汽车急转弯时，路标的视在宽度大部分是倾斜的。

模特— XGBoost 是爱情，XGBoost 是生活

对于这两个问题，我运行了一个优化的(但是普通的)xgboost，不管是好是坏。我尝试了我的常规 go-to，随机森林，GBM，和非常低效的 keras 网，也尝试了失败的堆叠。

如果我花更多的时间在堆积，糟糕的计划和管理上，我本可以获得一些名次。这个问题在过去的两场比赛中都出现过，显然不是一个理想的情况。

反正我在 Hotstar 问题上得了 0.9990232 的 AUC，在 roadsign 问题上得了 0.18053 的 logloss，对自己的表现还算满意。期待下个月的 zonals 舞台，激动！

所以是的，就是这样。一场比赛结束，另一场比赛开始。ML 会上瘾！

领导成功的数据分析计划的三大关键

原文：https://towardsdatascience.com/top-3-keys-to-leading-a-successful-data-analytics-initiative-cb6c4661d6fc?source=collection_archive---------9-----------------------

数据分析被称为 21 世纪最强大的决策工具。尽管它在过去的二十年里才逐渐成熟，但成千上万的企业、政府机构和非营利组织已经使用它来大幅提高生产率、减少浪费和欺诈、提高质量、改善客户服务、增加收入、优化战略、打击犯罪和恐怖主义，以及解决许多其他棘手的挑战。Elder Research 首席执行官 Gerhard Pilcher 和运营副总裁 Jeff Deal 合著了Mining Your Own Business，为希望更多了解这些强大工具并在其组织中发展分析能力的组织领导提供了一个易于阅读的数据挖掘和预测分析概述。

本博客摘自本书第三章，回顾了领导成功的数据科学计划的三个最重要的关键。

选择正确的项目

分析的第一步是决定要解决什么问题。首先确定一个在组织内被广泛认为是棘手问题的狭义问题。任何规模的组织都有许多数据分析可以帮助解决的问题。在选择最初的项目时，考虑一下哪些问题让你夜不能寐。如果没有紧迫的问题让你的组织中的人夜不能寐，如果没有人要求你创造的结果，这个项目很可能是浪费时间和金钱。思考哪些因素正在影响您的组织，您需要更好地了解这些因素？你非常想解决什么问题？为了确保成功，领导者应该将该计划视为实现组织总体目标的重要一步。参与项目的所有人都应该相信它的成功，他们应该愿意根据分析揭示的见解采取行动。该项目应该切实可行，有足够的资金和数据。

一些对我们的客户很有效的开始项目是减少欺诈、减少客户流失、预测成本和提高生产质量。限制你努力的焦点。例如，如果你的问题是欺诈，从识别和减少一种特定类型的欺诈开始，而不是一次跟踪每一种形式。最初项目的主要目的应该是证明数据分析的价值，并让人们了解其潜在的好处。获得认同是关键，因为分析最终将改变组织中人们的决策方式。

将这个初始数据分析项目主要视为未来全面计划的销售工具。使用它向各级管理层证明，数据分析的好处值得投入必要的时间、金钱和精力。

从小处着手

一些刚接触数据分析的公司试图推进得太快。他们没有在一个普通的初始项目上投资 75，000 美元左右，而是冲出去雇佣两三个有一些分析经验的人，花 500，000 美元购买软件，并宣布公司现在是“数据驱动的”。然而，在没有适当规划和组织认同的情况下推行数据分析计划，就像在没有足够承诺的情况下购买一件昂贵的家庭锻炼设备。这种设备起初看起来令人兴奋，但如果没有专门的养生方法，它很快就会闲置在地下室或作为卧室角落的衣架。

几年前，一家非常大的公司的经理要求我们帮助他们实现他们的愿景，将数据分析作为改造整个医疗保健行业的工具。在我们的四人团队与他们的十二人团队会面两天后，很明显，该组织的分析战略过于宏大，无法启动。这就好像他们试图用业余爱好者的模型火箭到达月球。经过两天的会议，这个潜在的项目在其不切实际的目标的重压下崩溃了。

相比之下，我们的另一个客户，美国最大的保险公司之一，做的一切都很正确。当我们参加最初的动员会时，项目负责人已经召集了主要的中小企业、高管、IT 人员和其他利益相关者。该公司向我们展示的项目涉及一个被广泛认可的、定义明确的痛点，该痛点与特定的保险业务相关。其明确的重点和狭窄的范围导致了高效的会议和大量的买进。

虽然让所有这些人参加一天半的会议费用很高，但投资是值得的。最初的项目非常成功，从那以后，该公司将数据分析应用于与这种相同类型的保险相关的其他问题。未来，他们计划将数据分析扩展到其他业务领域。

这个客户给我们留下了深刻的印象。我们很高兴地发现，负责数据安全的人非常有远见。她决心在法律允许的范围内尽一切可能提供我们倡议所需的信息。根据我们的经验，太多的数据安全人员害怕分享任何包含顾客或客户个人数据的信息。幸运的是，这个人付出了额外的努力来获取我们需要的数据，没有违反客户保密或法律。

领导力是关键

我们公司对自 1995 年成立以来的第一个十年中完成的项目进行的一项研究表明，90%以上是技术上的成功，但其中只有 65%得到了实施；也就是说，只有三分之二是商业上的成功。[1]导致业务成功率较低的原因有很多，但最大的一个原因是缺乏组织对实施的承诺。不幸的是，许多组织根本不愿意实施分析工作提供的建议，即使这些建议显然会带来重大改进。

为什么如此多的组织在数据分析项目上投入了大量的时间和金钱，却未能实施由此产生的建议？到这个阶段，他们已经支付了所有的成本，并且他们已经证明了样本外数据的回报。然而，如果不实施，他们将一无所获。

我们认为两个主要原因是缺乏强有力的领导和缺乏关键决策者的认同。(一个次要原因是未能理解结果，这是分析师和客户双方的失败。)为了实施数据分析建议，组织通常必须制定新的政策和程序，改变长期存在的流程，重新培训人员，甚至转变企业文化。

从一开始就让关键利益相关者参与进来，增加成功的可能性。如果你在没有利益相关者参与的情况下进行数据分析项目，然后在完成后告诉他们，“这是数据显示的结果，那么这个项目很可能会失败。现在好好利用吧。”

改变企业文化从来都不容易。这就是为什么成功的预测分析计划需要一个或多个“冠军”的强有力领导，他们热情地致力于分析，并在组织内赢得足够的尊重，以争取其他人的承诺。

因为数据分析项目的结果可能需要相当长的时间才能显现，坚持到底可能需要相当大的耐心和毅力。随着一个组织继续投入时间和金钱到计划中，一些领导者可能会变得焦虑甚至害怕。"如果这个项目不成功怎么办？"他们可能会开始思考。"我们只是把钱倒进下水道吗？"有时，其他人会建议其他解决问题的技术，领导者可能会试图将资金从数据分析计划转移到可能看起来更快、更便宜的替代方法。领导者应该不断提醒自己和所有参与者，快速解决方案很少能为复杂的问题提供有效的长期解决方案。勇敢、积极的领导是必要的，以确保数据分析计划坚持下去，直到成功开始显现。与此同时，分析师需要用早期发现的报告来鼓励那些从事这项工作的人。

摘要

一场管理革命正在商界和政界展开。未来几年，最成功的组织将具备分析能力。分析计划的领导者需要获得知识、愿景和激情，才能站在这场变革的前沿。如果您正在启动或领导一项分析计划，请牢记这些因素以确保成功:

• 选择一个支持组织整体目标的项目，并确保关键利益相关者的认同。
• 你最初项目的目标应该是证明分析的价值，并让人们了解它的潜在好处。
• 确保项目有足够的资金和数据。
• 从小处着手，利用结果为具有更大潜力的后续项目建立动力和领导支持。
• 积极的领导是必要的，以确保数据分析计划坚持下去，直到成功开始显现。
• 指派一名有领导支持的项目倡导者来指导结果的实施和采用。

Elder Research 可以帮助制定分析战略、评估能力、构建和部署解决方案，并指导您的分析团队。 请求咨询 与经验丰富的大数据分析顾问交流，了解更多信息。

[1]研究我们的过去——数据挖掘我们的数据挖掘——证明非常富有成效。通过确定将新模型和流程投入生产的主要非技术障碍，我们能够在未来避开大多数障碍，并在接下来的十年中大幅提高生产率。

有关系的

了解更多关于如何开始开创自己的事业

阅读博客打造高效的数据科学团队

阅读博客分析 101:评估项目价值

原载于www.elderresearch.com。

4 大被忽视的技术

原文：https://towardsdatascience.com/top-4-overlooked-technologies-aefa6590aff1?source=collection_archive---------2-----------------------

大约一年前，我“走出”了平时的工作，去旅行，自由写作，写作。这是一个阅读新技术和实验项目的机会，我一直试图继续跟踪。

在我读到的所有东西中，有四项技术对我来说很重要，或者至少是“大的，如果是真的”，尽管它们大多不为人知。

1.机器学习中的对抗模型

机器学习在科技媒体、GitHub 和教程中无处不在，但我发现了一个特别感兴趣的例子，它违背了对抗性机器学习的原则。自 2014 年以来，这些方法被用于分析和混淆分类器。在这里，正确识别熊猫的人工智能被骗(更有信心)说它正在看另一种动物:

更奇怪的是，去年 11 月，一个演示被打印出来:

Yen-Chen Lin 的令人敬畏的对抗性机器学习 repo 有一个论文和资源列表。

OpenAI 有一个 CleverHans repo 来衡量他们的模型相对于敌对模型的有效性。其思想是，在训练机器学习模型时，我们应该有目的地引入敌对图像，以提高模型的可靠性。

2.同态加密

同态加密一开始很难相信。您可以将加密的数据发送到服务器进行分析或算术运算，而无需给服务器实际数据的密钥。

我做了一个地理围栏项目，在这个项目中，你不用向服务器透露你的坐标就可以知道你是否在一个目标区域。我使用了 Paillier 密码系统，这是一个部分同态系统，在 GitHub 上有许多语言的开源实现。
目前其他实际例子很少，但最终您可以在云端搜索您的加密电子邮件和文档，或者在不暴露它们的情况下分析医疗记录(解决 HIPAA 问题)。

QuarkLabs 有一篇出色的文章，解释了你想知道的关于全同态加密的任何事情，全同态加密于 2009 年首次实现。

还有一个来自 IBM Research 和加州大学伯克利分校的演示:

使用同态加密的电子投票

3.智能合同

人们写了很多关于智能合约、以太坊和区块链的废话，所以我不会在这上面漫谈太多。这符合我的“未知”标准，即在野外很少能看到智能合约。

学术界、技术社区的某些领域和风险投资肯定会有兴趣。聪明的契约理论家提出了有趣的建议，从游戏到难民身份证到基本收入再到伊斯兰金融。但只有少数例子变得突出，然后被扑灭。预期结果和实际结果的不匹配有几个原因:

• 关于智能合约能做什么和不能做什么的误解(见我之前的帖子:在以太坊不能工作的应用)。可以将这些应用程序编写为通过区块链进行通信的程序，但是考虑到您需要一个可下载应用程序的网站，这些应用程序可以很容易地通过常规互联网或另一种 P2P 协议进行通信。
  在这个领域，重要的是创建一个可信的分布式契约。
• bug，比如清空 DAO 的 bug，以及最近在无效地址丢失以太网的一个交换 bug(上下文:潜在的 1200-1300 万美元被有效删除)。
• 理解以太坊、区块链、智能合约和有新闻价值的 bug。写入一个契约的错误不会使其他契约变得脆弱。
• 开发人员缺乏工具，因此将合同编译并发布到以太坊区块链要比想象中困难得多。看一个' hello world '的例子。
  我在 Solidity 中写了一个简单的“单词搜索”游戏，但我的代码什么也做不了。我试着运行我的电脑几天来下载以太坊区块链(这是不断受到攻击，这意味着你必须停止和升级 geth)，我从来没有达到一个点，我可以看到我的以太令牌或提交合同。

一些链接:

• Ether Studio 据报道是智能合约的 IDE，但它不再加载(？)
• OpenZeppelin 是一个在 Solidity(基于 JS 的语言)中构建契约的框架。

4.可验证编程

如果我们能在运行代码之前知道代码所有可能的结果，那会怎么样？在任务关键型系统中，工程师使用规范语言为他们的代码建立一个抽象模型。它帮助 AWS 发现了新的、意想不到的错误。这听起来很有趣，但是从像这样的帖子中，我还不能得到一个头脑中的画面，并确定我是否可以将它应用到我自己的代码中。

一个最近在 TLA+上的帖子提醒我再调查一下。这是一个很好的介绍，这些由图灵奖获得者莱斯利·兰波特的视频讲座也是如此。黑客新闻更多讨论。

如果像 TDD 和复杂层(比如 Elm，一种编译成 JavaScript 的函数式语言)这样耗时的实践能够成为 web 开发行业受尊敬的部分，那么一种对开发人员更加友好的可验证编程方法可能会成为一件事情。Rust 是一种有点新的语言，它有保证的内存安全赢得了开发人员的支持，并使它在一些领域超越了 C++。TLA+或类似的语言能鼓励他们的思维方式在普通开发者世界中获得牵引力吗？最近有这个铁锈和 TLA+ 的交叉。

从这个列表中毕业:量子的东西

一年前，我得到了一本关于后量子加密的书，因为它经常被忽视。现在我看到人们对量子计算机越来越感兴趣，许多 Arxiv 论文在 Twitter 和 Reddit 上流传。上个月，ri getti Computing(YC 的一家初创公司)召开了第一次湾区量子计算会议。

本月，我将在开源桥发表一篇关于量子计算的演讲，而我对 Revolution Conf 的类似提议输给了另一篇量子计算演讲。我现在可以相信我们已经升级到主流意识了！

不要错过下一个！

这些想法中的每一个都可以成为创业公司，有些已经是了！我知道开发者工具创业公司通常很难起步和盈利。但是看看这个帖子的建议:

为不具备构建所需工具技能的特定开发人员构建工具。例如，瞄准新的开发人员或只为他们工作的一部分编码的人。

构建一个模块网络，这些模块的相互依赖创造了非凡的价值，远远超出了平台之外单独开发的价值。

鉴于机器学习、智能合约开发和加密仍然超出大多数开发人员的经验，并且需要大量的设置(GPU 硬件或活跃的以太坊节点)，我认为新的创业公司可以在这些技术中获得坚实的立足点。

可验证的编程是一件更棘手的事情，但或许亚马逊会赞助 TLA+或一种新语言(考虑到 Mozilla 对 Rust 的支持，或来自苹果和谷歌的新语言，这并不太难想象)。

总的来说，我认为这些是值得开发并保存在你的开发者工具箱中的有趣技能。

每个数据科学家都应该阅读的五大业务相关书籍

原文：https://towardsdatascience.com/top-5-business-related-books-every-data-scientist-should-read-6e252a3f2713?source=collection_archive---------3-----------------------

这份改变思维方式的书籍精选清单将帮助你成为一名更好的数据科学家

根据 Drew Conway 的说法，数据科学独角兽是统计、编程和商业方面的专家。虽然已经说了很多并做了很多来帮助数据科学家变得更擅长数学和编码，但这篇文章帮助数据科学家提高了他们的商业思维。下面列出了一些关于商业和决策的书籍，最终将帮助你更好地理解和驾驭这个世界。

https://goo.gl/T3zjv7

这些书不是理论性的。相反，这些书读起来很有趣，因为它们有科学依据，并且传达了重要的教训。

让我们开始阅读。🤓 📚

精益创业 —埃里克·里斯(2011)

《哈佛商业评论》称精益创业改变了一切。他们是对的，这本书应该改变你所做的一切。它的主要信息是省略所有不必要的工作，专注于测试你论文中最危险的假设。关注构建-测量-学习循环。

首先，你创造一个最小可行的产品，尽可能快和便宜地测试你最危险的假设。第二，你衡量客户的反应。你获得了多少付费客户？第三，你从指标中学习并改进产品或转向另一个想法。

作为一名数据科学家，精益创业方法可以很容易地应用到您的工作中。尽快创建一个模型。根据预定义的指标评估模型。这种方法行得通吗？需要更多数据吗？然后，您改进模型，直到它满足您的需求，您转向另一个用例，或者您完全废除这个项目。

请记住，你在一个项目上投入了多少努力并不重要。如果你发现现在的方法行不通，你之前的努力从来没有白费。你创造了知识，这将有助于你未来的进步。

吴恩达实际上创建了一门课程来改进你的算法，并坚持精益原则。点击查看本课程的总结。

从零到一 —彼得·泰尔(2014)

经验丰富的硅谷企业家和投资者彼得·泰尔在这本即时经典中解释了他对商业的反直觉观点。本书最重要的观点是，你需要大胆创造全新的产品，并最终维持垄断。

泰尔认为，竞争最终会摧毁利润。提供类似产品的公司越多，你的利润空间就越小。考虑一下利润率，它描述了你每赚一美元实际能得到多少钱。根据 NYU 研究的数据，竞争激烈的建筑行业平均盈利 2c，而软件公司每 1 美元盈利 24c。作为一家企业，你需要不惜一切代价避免竞争。

Health tech was very profitable in 2015, while competitive distribution services were less profitable. Source: https://goo.gl/R3Xjb1

在你通过创造一种没有补充的产品从零到一之后，你需要创造一种垄断。垄断是保持健康利润的最有效的结构。谷歌或脸书永远不会承认他们拥有垄断地位，因为他们将面临更严格的监管审查，但他们是垄断者，他们从这一市场地位中受益。

这对您作为数据科学家的工作意味着什么？通过创造竞争对手无法提供的服务来支持你的公司！然后，通过拥有产品背后的技术或者创造网络效应，试图垄断产品。这可能意味着任何事情，从申请专利或提供最佳推荐服务，因为大多数用户使用你的服务。阅读泰尔关于如何创造和维持垄断的额外建议的书。

思考，快与慢 —丹尼尔·卡内曼(2011)

在这本广受好评的书中，诺贝尔经济学奖获得者丹尼尔·卡内曼总结了几十年来关于人类行为的开创性研究。这本书解释了为什么我们的大脑有时会让我们失望。你从阅读本书中获得的见解将帮助你避免自己推理中的陷阱，并影响他人的决策，使之对你有利。

这本书的关键是，我们有两个层次的思维，称为直觉，或第一层次，和理性思维，称为第二层次。这两个层次都很重要，但服务于不同的目的。

一级思维是低能耗的，并且是持续不断的。它会观察你的环境并迅速做出决定。一个实质性的威胁即将来临。我应该因为刚刚听到的故事而改变对某个话题的看法吗？我如何理解环境？这些都是一级回答的问题。

一旦出现更难的问题，二级思维就开始发挥作用。二级思维是缓慢、努力和可靠的，涉及数学运算或复杂的逻辑推理。每当你需要理性而不是直觉的时候，激活第二层思维。

Source: https://goo.gl/teTu5P

作为一名数据科学家，这意味着你应该意识到思维的两个层面。警惕通过 1 级寻找简单的答案。理解当一级思维试图在不关注必要的统计数据和事实的情况下快速得出结论。承认密集使用二级思维会耗尽你的能量，并及时补充健康碳水化合物。

《黑天鹅》 —纳西姆·塔勒布(2007)

哲学家/交易者/统计学家纳西姆·塔勒布在本书中解决了我们对不确定性机会的视而不见。黑天鹅轶事是一个不可预见事件的隐喻。例如，人们相信所有的天鹅都是白色的，因为他们见过的所有天鹅都是白色的。但是当探险家第一次在澳大利亚发现黑天鹅时，这打破了他们对天鹅的先入为主的观念。

根据这个故事，塔勒布指出了我们思维中的各种陷阱，以及它如何影响我们的决策。作为人类，我们喜欢创造故事来解释过去，并低估机会在未来影响中的重要性。

Picture of a black swan. Source: https://goo.gl/65dbcK

对于数据科学家来说，这本书教你意识到不确定性并拥抱它。业务在高度不确定的环境中工作，这可能迫使公司改变策略或转向另一个产品用例。去尝试不同的方法和模型，也许，甚至是偶然，你会发现正确的解决方案。你永远不知道未来会有什么惊喜。

好战略/坏战略 —理查德·鲁梅尔特(2011)

商业战略定义了一家公司做什么和不做什么。战略的目标是在市场上比竞争对手拥有优势。

鲁梅尔特深入解释了好策略和坏策略的基石。一个好的战略体现在深入的诊断、指导性政策和一套连贯的行动。糟糕的战略是通过关注花费以达到目标，从问题的细节中吓跑，以及关注战略、使命和愿景模板来识别的。

Good strategy beats bad strategy. Source: https://goo.gl/M6Tgdb

然而，鲁梅尔特这本书的关键观点是，公司应该利用所有可用的资源来执行战略。这意味着，作为一名数据科学家，你需要首先挑战和理解公司战略。第二，你需要把你建议的项目和公司战略结合起来。了解公司战略将有助于您 A)确定可通过数据科学实现的价值驱动因素，B)帮助您推进项目，以及 C)了解公司未来的发展方向。

关键要点

• 应用构建-测量-学习的精益方法
• 努力创造一种全新的产品，创造垄断
• 意识到直觉和理性思维
• 不要低估不确定性
• 理解商业战略并通过你的工作支持它

这些书将为你的思维增加另一个维度，并帮助你理解商业战略的某些方面。我鼓励你自己去探索和阅读这些书，它们包含了更多的智慧，读起来很有趣。

作为一名数据科学家，你想知道你的公司正在朝什么方向发展，为什么要实施某些措施，或者说服某人相信你的项目。我希望这些书能帮助你做到这一点。

如果你认为这篇文章是有帮助的，不要忘记展示你的💛穿过👏 👏 👏请在这里和 LinkedIn 上关注我，了解更多关于深度学习、在线课程、自动驾驶汽车和生活的信息。还有，你可能喜欢 这些 帖子。如果你知道另一本对数据科学家有帮助的商业书籍，请评论！干杯！🙇

说明性分析的 5 大问题以及如何克服它们

原文：https://towardsdatascience.com/top-5-issues-with-prescriptive-analytics-and-how-to-overcome-them-6f5cada83aa4?source=collection_archive---------20-----------------------

Stopwatch Gears by geralt, CC0

规定分析有点像类固醇的预测分析。正如在关于这个主题的早期文章中所指出的，规定性分析是对你通常的预测分析的有力补充。你不仅要预测未来的事件，还要利用这种预测来优化你的决策。
当你一头扎进机器学习和优化技术的熔炉，以理解和实施先进技术时，规定性分析提出了独特的挑战。向最终用户传达这一点也是一个挑战。
以下是您在实施此类系统时遇到的 5 大问题，以及解决这些问题的方法:

I .定义适应度函数

说明性分析要求您定义一个适应度函数。这个适应度函数应该奖励好的优化结果。要定义这个适应度函数，你需要对业务有很好的理解。
得到这个等式有时会很困难，因为它需要从一开始就与企业密切合作。根据我的经验，首先建立准备、建模和说明性分析的完整管道是有益的。这条管道在开始时可能过于简单。整个原型可以快速部署到 BI 系统或 Excel 中。从那里你可以有一个更好的方式与你的终端用户对话，因为他们已经可以体验结果。

二。无导数优化

Nelder-Mead optimization on the Himmelblau function. Depending on the start value you get different results. Image by Nicoguaro. CC BY 4.0

依赖于预测模型的适应度函数通常是不可微的。例外当然是像 GLMs 这样的简单模型。因此，您通常必须使用不需要梯度或 Hesse 矩阵的算法来优化您的适应度函数。这不包括神经网络中常用的优化器。

一般来说，可行的解决方案分为两大类。首先是进化优化家族，它总是一个伟大的竞争者。进化优化总是有支持者和反对者。所有优化问题的主要问题是收敛到一个最优值。虽然找到局部最优相对简单，但进化方法试图克服局部最优，并在完整的解空间中找到好的解。这种可能性的代价是，它们有更多的起始参数，这在很大程度上影响了结果的质量。这就是为什么运行时会成为进化方法的一个问题。第二类涉及近似梯度法。这些方法在内部计算梯度的数值近似值。之后，他们使用了通常的梯度下降思想的变体。众所周知的方法是单纯形法或鲍威尔法，但是当然还有更多的方法。

三。复杂约束

在许多情况下，您的参数会受到约束。当你的解决方案无法实现时，就会出现这种情况。这种情况的一个例子是负长度。限制的另一个原因可能是业务规则—可能不想提供低于 10 美元的价格。您可以用两种方式处理这些约束——您可以显式命名它们并让优化器知道它们，或者您可以将它们编码到您的适应度函数中。

有明确约束的问题

一些算法可以在它们的方法中加入约束。这方面的例子有 BYOBA 或进化优化。其他人不行。
如果你想要的算法支持约束，通常最好使用这个。在某些情况下，这样做是非常困难的。例如，您的约束取决于预测。在这种情况下，您很难在普通的优化器中使用它。在这种情况下，您很难在普通优化器中使用它。

适应度函数解决方案的问题

另一种方法是为你不想要的解决方案建立一个惩罚因子。您应该避免使用基于阈值的惩罚，例如:

#Fitness should be maximized.
def my_fitness(y_pred):fitness = y_predif (y_pred > threshold):fitness-=1e6return fitness

如果你这样做，你的适应度函数就会不连续。如果您在基于梯度的方法中使用它，这可能会非常糟糕。

或者，你也可以像这样对适应度使用惩罚:

def my_fitness(y_pred):fitness = y_predif (y_pred - threshold > kickin):fitness-= factor*abs(y_pred - threshold)return fitness

不好的一面是，这个适应度值已经不可理解了。在此之前，这是一个带有惩罚的阈值的绝对差值。现在它是一个适应度和惩罚函数的组合。
这里的缺点是你失去了可解释性。以前你可以把你的健康理解为收获。现在歪了。

四。全局约束

到目前为止，我们只讨论了可以逐行导出的约束。这些约束是根据机器运行或每个客户定义的约束。您可能会遇到需要使用来自其他示例的信息的约束。这方面的例子有:

找到最大利润的价格，同时确保你一个月有 1000 个客户。

这可能意味着您需要寻找无利可图的客户来满足这个业务约束。制造业的另一个例子:

为机器的这次运行找到最佳设置，但是设置不允许与上次运行的设置相差太多

在上面的场景中，即使其他解决方案具有更高的适应性，您也可以在最后一次运行的解决方案旁边取一个局部最小值。

解决方案 I —全局优化

实现全局优化的一种方法是同时优化所有客户，而不是单个客户或单独运行的机器。这允许您定义一个全局惩罚，您可以将它包含在适应度中。这样，您可以同时优化局部和全局约束。一个障碍是你需要同时改变所有的参数。如果你一个月有 10000 个客户，一个简单的二维优化问题可以变成一个 20000 维的问题。这使得数值优化更加困难。
另一个问题是实时部署。想想预测定价。您无法实时运行此优化。然而，你能做的是通过优化以前的数据来克服这一点，并将其作为另一轮机器学习的输入。

解决方案二—后处理

在某些用例中，进行后处理来满足全局约束也是可行的。这样做的一种方法是不仅导出最佳适应度，还导出其他次优数据点。然后，您尝试用这些候选点中的一个来替换您的最优值，以满足全局约束。

第五-稀疏输入数据

说明性分析在制造业中有一些重要的用例。一个常见的用例是控制机器或工厂的参数以获得最佳质量。这里的一个常见问题是，您只有“受控情况”的数据。
如果你对这些数据进行规范性分析，你会遇到一些问题，比如进入数据点数量很少的超空间区域——这使得你的预测不可靠。

解决方案 I —异常检测

Illustration of the LOF outlier detection algorithm. Points with high distances compared to their neighbors have a high outlier score. It’s not clear if that also means that they are hard to predict. From Wikipedia, Public Domain.

用有限的输入数据来克服这个问题的一个想法是使用异常检测方法来计算这个特定数据点的超空间有多密集。如果选择的数据点位于您没有足够的预测点的区域，您应该拒绝该数据点。这些方法的例子是局部离群因子(LOF)，一类 SVM 或高斯混合模型。

虽然乍一看去除这些“异常值”听起来很合理，但要证明这一点并不容易。您的预测性能可能不依赖于这种“稀疏性”。不举这些例子可能会导致不必要的拒绝，从而导致更差的表现。这也可能增加另一种对“通常”的偏见，因此可能是老式的解决方案。

解决方案二——数字双胞胎

一些植物有一个数字双胞胎。数字双胞胎的概念理应有自己的博客。这个概念是你有一个完整的整个工厂的数值模拟。这个孪生可以用来为超空间中的稀疏区域生成数据点。然后你可以用它来填充更多的例子，并且仍然可以可靠地预测。

Python 中排名前五的机器学习库

原文：https://towardsdatascience.com/top-5-machine-learning-libraries-in-python-e36e3e0e02af?source=collection_archive---------9-----------------------

copyright: https://unsplash.com/photos/_xhO_g8k1-w

在这篇文章中，我们将了解被 ML 专家广泛使用的 python 中排名前 5 的机器学习库。

所以，我们要学的是:

• Numpy
• 熊猫
• Matplotlib
• SciKit-Learn 和
• NLTK

Numpy

NumPy 是用 Python 进行科学计算的基础包。它主要用于解决矩阵问题。

创建一个 Numpy 数组:

创建一维数组:

创建一个由个零组成的数组:

创建编号的序列:

重塑一个数组:

有关数字的更多示例，请访问本笔记本。

熊猫

Pandas 是用 python 编写的最流行的机器学习库，用于数据操作和分析。

创建一个系列:

系列是一个一维标记的数组状对象。

创建数据帧:

数据帧 是一种二维标记数据结构。

数据帧的头部和尾部:

数据帧的统计描述:

访问单个和多个属性或列:

数据框架的一些基本任务:

数据帧上的条件搜索:

关于熊猫的更多例子，你可以访问笔记本。

Matplotlib

Matplotlib ，一个很棒的数据可视化库。

使用 Matplotlib 进行单属性分布:

results distribution

条形图:

Bar Chart

修改不同的参数:

Modified Bar Chart

饼图:

pie chart

关于 matplotlib 的更多例子，你可以访问这个笔记本。

sci kit-学习

一个提供了一系列 有监督 和 无监督 学习算法的库。这个图书馆主要集中在模型的建造上。

使用 Sci-kit Learn 的端到端模型:

在本例中，我们将使用这个简单的 学生成绩 数据集。数据集包含两个可能的结果0和1。

0表示学生未通过的考试，1表示通过。

我们的数据集包含标签，它只有两种可能的结果，这意味着它是一个监督分类学习问题。

• 第一步:导入必要的库

• 第二步:加载数据集

• 步骤 3:将数据集分成训练和测试子集

• 第四步:模型训练

• 第五步:模型评估

完整的笔记本可以在这个链接中找到。

NLTK

自然语言工具包(【NLTK】)是NLP(自然语言处理)的库。****

符号化:

根据 techopedia 的说法，记号化是将一系列字符串分解成单词、关键词、短语、符号和其他称为记号的元素的行为。

把一个句子标记成单词:

把一段文字分成句子:

使用 NLTK 进行词干分析:

词干是从词尾去除词缀的过程。

完整的笔记本可以在这个链接中找到。

今天就到这里:d。

完整的 GitHub 回购可以在这个 链接 中找到。

绿角数据科学家的 5 大错误

原文：https://towardsdatascience.com/top-5-mistakes-of-greenhorn-data-scientists-90fa26201d51?source=collection_archive---------0-----------------------

你参加了在线课程，并获得了第一份数据科学工作。避免这些错误，马上就能成功。

你为最终成为一名数据科学家做了充分的准备。你参加了 Kaggle 比赛，你狂看 Coursera 的讲座。你觉得自己已经准备好了，但是作为一名现实生活中的数据科学家，工作将会与你的预期大相径庭。

本文考察了早期数据科学家的 5 个常见错误。这份名单是与sébastien fou caud博士汇集在一起的，他在指导和领导学术界和工业界的年轻数据科学家方面拥有> 20 年的经验。这篇文章旨在帮助你更好地为现实生活中的工作做准备。

让我们开始吧。👩‍🏫👼🦄🐣

1.输入“一代卡格尔”

Source: kaggle.com on June 30 18.

您参加了 Kaggle 挑战赛，并锻炼了您的数据科学技能。你能把决策树和神经网络堆叠起来，这很好。说实话，你不会像数据科学家那样做太多的模型堆叠工作。请记住，一般来说，您将花费 80%的时间预处理数据，20%的剩余时间构建您的模型。

成为“卡格尔一代”的一员在很多方面都有帮助。数据通常是非常干净的，这样你就可以花时间调整你的模型。但是在现实工作中很少出现这种情况，在现实工作中，您必须从具有不同格式和命名约定的不同来源收集数据。

做艰苦的工作，练习你将使用 80%时间的技能，数据预处理。抓取图像或者从 API 中收集。收集天才的歌词。准备好解决特定问题所需的数据，然后摄取到笔记本中，实践机器学习生命周期。精通数据预处理无疑会让你成为一名数据科学家，对你的公司产生立竿见影的影响。

2.神经网络是治疗一切的良药

在计算机视觉或自然语言处理领域，深度学习模型优于其他机器学习模型。但是它们也有明显的缺点。

神经网络非常渴求数据。样本越少，决策树或逻辑回归模型往往越好。神经网络也是一个黑匣子。众所周知，它们很难解释和说明。如果产品所有者或经理开始质疑模型的输出，你必须能够解释模型。这对于传统模型来说要容易得多。

正如詹姆斯·勒在的这篇博文中所解释的，有很多很棒的统计学习模型。对他们进行自我教育。了解它们的优缺点，并根据您的用例的约束应用模型。除非你在计算机视觉或自然语音识别的专业领域工作，否则最成功的模型很可能是传统的机器学习算法。你很快就会发现，通常最简单的模型，如逻辑回归，是最好的模型。

Source: Algorithm cheat-sheet from scikit-learn.org.

3.机器学习是产品

在过去的十年里，机器学习既享受又遭受了巨大的炒作。太多的初创公司承诺，机器学习是解决任何问题的良药。

Source: Google Trends for Machine Learning of the past 5 years

机器学习本身永远不应该是产品。机器学习是创造满足客户需求的产品的强大工具。如果客户受益于收到准确的商品推荐，机器学习可以提供帮助。如果客户需要准确识别图像中的对象，机器学习可以提供帮助。如果企业从向用户展示有价值的广告中受益，机器学习可以提供帮助。

作为一名数据科学家，您需要以客户目标为主要优先事项来规划项目。只有这样，你才能评估机器学习是否有帮助。

4.混淆因果关系和相关性

大约 90%的数据是在过去的年中产生的。随着大数据的出现，机器学习从业者可以大量获得数据。有如此多的数据需要评估，学习模型发现随机相关性的机会增加了。

Source: http://www.tylervigen.com/spurious-correlations

上面的图像显示了美国小姐的年龄和被蒸汽、热蒸汽和热物体谋杀的总数。给定这些数据，学习算法将学习美国小姐的年龄影响特定对象谋杀数量的模式，反之亦然。然而，两个数据点实际上是不相关的，两个变量对另一个变量绝对没有预测能力。

当发现数据中的模式时，应用你的领域知识。这可能是一种关联还是因果关系？回答这个问题是从数据中得出行动的关键。

5.优化错误的指标

开发机器学习模型遵循敏捷生命周期。首先，您定义想法和关键指标。第二，你原型化一个结果。第三，你不断改进，直到满足关键指标。

在建立机器学习模型的时候，记得做人工误差分析。虽然这个过程是乏味的，并且需要努力，但是它将帮助您在接下来的迭代中有效地改进模型。参考下面的文章，从吴恩达的深度学习专业化中获得改善你的模型的额外技巧。

[## 构建你的机器学习项目的 22 个智慧金块

完成一个机器学习项目很难。此摘要帮助您构建您的机器学习项目，以…

towardsdatascience.com](/structuring-your-machine-learning-project-course-summary-in-1-picture-and-22-nuggets-of-wisdom-95b051a6c9dd)

年轻的数据科学家为公司提供了巨大的价值。他们刚刚参加完在线课程，可以立即提供帮助。他们通常是自学的，因为很少有大学提供数据科学学位，因此表现出巨大的承诺和好奇心。他们对自己选择的领域充满热情，渴望学习更多。要想在你的第一份数据科学工作中取得成功，就要小心上面提到的陷阱。

关键要点:

• 实践数据管理
• 研究不同模式的利弊
• 让模型尽可能简单
• 对照因果关系和相关性检查你的结论
• 优化最有前途的指标

如果你认为这篇文章是有帮助的，不要忘记展示你的💛穿过👏 👏 👏在 Medium 和 LinkedIn 上关注我，了解更多关于深度学习、在线课程、自动驾驶汽车和生活的信息。还有，把 这些 帖子查出来。请评论分享你的看法。干杯！🙇

2019 年值得关注的 6 大数字营销趋势

原文：https://towardsdatascience.com/top-6-digital-marketing-trends-to-look-out-for-in-2019-b5cdf7dcfe6?source=collection_archive---------2-----------------------

Photo by Scott Webb on Unsplash

毫无疑问，数字营销革命就在眼前，而且发展迅速。但是，随着新技术每天都在涌现，数字广告技术也在实时变化，仅仅跟上步伐已经不够了。保持领先地位需要展望未来，然后采取正确的措施让你的企业达到目标。

获得并保持领先优势

以下是 2019 年肯定会影响数字营销世界的六项重要发展。

1。世界正迅速转向虚拟和增强现实。还记得几年前围绕 Pokémon Go 的歇斯底里吗？各个年龄段的人走进汽车，在街上撞上另一个人，因为他们沉浸在这个令人兴奋的新现实中。游戏可能是大众解释和理解增强和虚拟现实(AR 和 VR)的方式，但品牌也有巨大的机会使用这些技术来改善客户体验。

自 2016 年以来，宜家一直在尝试虚拟现实游戏技术，当时这个知名家具品牌宣布推出虚拟现实厨房，宜家虚拟现实体验——这是一款购物应用程序，旨在让顾客在购买之前尝试不同的宜家解决方案。用户可以体验定制厨房的外观和感觉，例如，只需点击一下，在测试不同的饰面或橱柜解决方案时，可以轻松地在空间中移动。

最近， Nickelodeon 进入了 VR 和 AR 领域，为其移动应用程序添加了 AR 模式，并推出了 SlimeZone，“它的第一个多人社交 VR 体验。”儿童频道希望这些新的高科技附加物将“让孩子们在面对其他地方的干扰时保持在船上。”

2019 年，我们可能会看到更多品牌采取这样的大胆举措，以增加消费者体验价值的方式重新审视 VR 和 AR。

2。语音正在成为最终的搜索营销工具。ComScore 估计，到 2020 年，一半的搜索查询将是基于语音的——这一预测引起了精明的品牌营销人员的注意。语音识别技术只望做大做好，消费者张开双臂迎接智能语音搜索的便利。

为了走在这个趋势的前面，想想文本和语音搜索之间的区别。更具体地说，在询价时，考虑你的客户可能会说什么样的话，而不是 T2 语。用更具对话性的语气开始写作，以开发更符合语音搜索的内容，也是有意义的。最后，如果你还没有这样做，为移动优化你的网站——就像昨天一样。

目前，大多数语音搜索的使用都是基于实用性——人们在忙着或者开车的时候最常用它。但随着明年单词准确率的提高，以及消费者越来越习惯于满足自己的需求，预计会看到品牌在另一个平台上竞争，因为他们很难理解如何在语音搜索中被找到。

3。从小型企业到大型企业，人工智能解决方案无处不在。如果 2018 年是品牌开始尝试人工智能(AI)和机器学习(ML)应用的一年，那么 2019 年将是他们做对的一年。从聊天机器人到机器人流程自动化，提高效率、生产率和客户满意度的价值越来越明显。

2019 年，人工智能技术将把以客户为中心的营销提升到一个新的水平。巨大的差异，期望更好的趋势分析，增强的客户档案，甚至更复杂的个性化策略。

McAfee 内容营销副总裁 Lisa Matherly 表示:“营销人员应该考虑如何使用人工智能来了解潜在客户正在消费的内容，无论是营销生成的内容、支持或技术文档，还是用户生成的内容，这将带来更个性化的客户体验和更高的客户满意度。

当你开始挖掘你收集和存储的数据时，部署智能人工智能应用程序将帮助你精确地到达目标受众，提高效率，为非凡的客户体验铺平道路。

数字工作流程也将变得更容易，因为易于部署的人工智能解决方案可供更多寻求最大限度利用该技术的企业使用。例如，媒体机构可以通过使用智能算法来分析活动的表现，从而为他们的客户优化付费广告活动。借助自动 A/B 测试和实时自我更新的算法，可以即时进行必要的改进，以提高营销投资回报率。

在企业层面，软件即服务公司提供人工智能驱动的自动化和工作流解决方案，显著改善医疗保健、银行、保险等行业的数字化运营。

4。视频浏览量引领互联网流量。视频正在吞噬网络——我们几年前就认识到了这一现象，当时华盛顿邮报预测，到 2019 年，视频将占所有互联网流量的 80%。这是有道理的，因为平均注意力持续时间很短，大多数人宁愿看视频也不愿看博客。

意识到这一点，品牌们热情地发布现场活动和幕后瞬间的视频。他们创造视频技巧和窍门，以及任何他们能在两三分钟的短小精悍的片段中拼凑起来的东西。然而，视频营销只有在提供消费者想要的东西、他们想要的时间和方式时才会成功。

做得好，视频营销产生惊人的效果。根据 HubSpot 的说法，简单地在电子邮件中添加一个视频，点击率就会惊人地提高 200 %- 300 %,在登陆页面上添加一个视频，转化率会提高 80%。

明年，直播视频将继续爆发，但真正的区别将是原创性。鼓励用户参与的互动视频和富有想象力的视频营销将很快超越视频，成为电影。消费者很快就会感到厌倦——利用视频吸引和激发用户的品牌将会胜出。

5。本土广告的冲击正在推动营销变得更有创意。如今的消费者对广告有抵触情绪，广告拦截器的突然增多让营销人员越来越难以发出信息。

如果公司想在 2019 年接触新的消费者，他们必须努力让广告更自然地融入内容。

进入原生广告。

原生广告提供了一个急需的突破，打破了横幅广告等直白的技巧。然而，随着品牌拼命努力变得不那么令人讨厌，他们已经成功地模糊了原生广告和传统广告之间的界限。

“很难知道你在 Mashable 上看到的文章是真实的还是受赞助的本地文章，”National Positions 首席执行官伯纳德·梅(Bernard May)说。在未来，“平台可能会遇到这样一种情况，客户可能会要求更清晰地区分各种类型的内容……推动营销更具创造性，更少干扰，并在对话中占据更大的份额。”

Asian Absolute 的数字营销专家 Nedelina Payaneva 说，尽管消费者变得更加明智，但原生广告正在成为几个主要品牌营销组合的重要组成部分，包括 Airbnb、Lexus 和 Visa。

在未来几年，Payaneva 认为企业将通过 Instagram Stories 等社交媒体利用原生广告策略，展示用户很难识别(或意识到)为广告的内容。

6。程序化广告正在成为主流。2018 年，我们看到了程序化广告的增长。这项曾经只为媒体购买保留的技术正在火起来，预计到 2019 年将占全球数字显示广告的三分之二。买家和卖家都在自动广告购买上投入了大量资金——而且他们会继续这样做。

数字显示器正朝着 100%程序化的方向发展。但真正有趣的是传统媒体是如何跟风的。你可以期待看到这种从程序化到传统媒体的转变在 2019 年开始形成。

包装完毕

数字营销的前景是光明的。随着虚拟和增强现实激发新的参与，以及营销人员挖掘更大的创造力，品牌将更容易做到真实和响应客户的需求。

随着企业越来越熟悉人工智能和机器学习能力，它们将提供更好、更复杂、更个性化的体验。随着获得更多的数据、更好的见解和新的机会，未来将不会留下任何聪明的企业。

这篇文章的一个版本出现在和business 2 community。

保持竞争力的 9 大客户体验趋势

原文：https://towardsdatascience.com/top-9-customer-experience-trends-to-stay-competitive-cd765280601a?source=collection_archive---------8-----------------------

在现代场景中，企业通过更加以客户为中心，努力为买家创造最佳体验。那些成功提供最佳客户体验的品牌比其他品牌更频繁地尝到成功的滋味。

超过 82%的公司认为客户体验是一项重要的竞争优势和衡量绩效的重要标准。因为留住客户是任何以客户为中心的公司的目标，这里有一些顶级的客户体验趋势来帮助他们保持竞争力。

数据和分析的重要工具

以客户为中心的公司需要随着最终用户期望的变化而发展。最好的方法之一是采用新的业务技术，如数据分析工具，来跟踪不断发展的最终用户体验。

在未来 5 年，客户服务行业预计将发生多种变化，数据和分析工具将影响他们的一举一动。基于对客户要求和购买偏好的数据分析，公司正在努力实现服务的个性化。

据 Forbes Insights 称，“数据提升客户体验”，42%的企业领导者认为数据分析有助于他们提供卓越的体验。

数据分析还有助于他们更快地做出决策，并见证销售收入的大幅增长。

此前，只有少数企业能够使用数据和分析工具来改善客户体验。现在，随着技术的进步，客户关系管理工具甚至可以帮助中小企业与客户建立长期的关系。在分析工具的帮助下，他们可以个性化客户解决方案服务，并确保基于个人需求的定制客户服务体验。

语音识别技术

交互式语音应答技术可以改变解决客户问题的方式。语音识别软件可以通过高效的呼叫路由和自动化的自助服务，帮助客户连接设计良好的 IVR 系统。借助先进的语音识别和呼叫者的个性化数据，公司可以找出引发客户投诉的问题类型，以及快速跟踪客户查询解决流程的方法。

聊天机器人会要求客户尊重

如今，客户希望公司的代表能够 24 小时待命，即时解决他们的疑问。为了在一致的基础上向客户提供及时的支持，公司推出了聊天机器人这一重要工具。聊天机器人可以满足客户的期望，而没有任何倦怠的机会。聊天机器人的高级功能与人工智能和语音识别技术相结合，与用户进行交互，并为他们提供合适的解决方案。聊天机器人是由企业开发的，用于响应简短直接的查询，并提供自动回复。

热门阅读:如何在 Google 搜索中为网站和博客做更快的索引？

增强客户自助服务的能力

让客户自己解决问题是另一个流行的客户体验趋势。正因为如此，非语音交互被公司认为非常重要。他们允许客户通过电子邮件和网络聊天提出问题，并获得客户服务代表的实时响应，甚至无需浪费大量时间连接代理或浏览复杂的 IVR。通过自助渠道的客户服务，大量的查询可以在较短的时间内得到解决。客户可以通过任何媒介将他们的疑问上报给客户服务代表，并期望得到快速答复。此外，拥有自助服务计划的公司可以获得更高的客户保留率，因为实时查询解决方案可以确保更高的满意度。

迎合移动友好型客户的偏好

2017 年，移动搜索可能会比桌面搜索多产生 278 亿个查询。消费者在做出最终购买选择之前，使用移动设备来访问关于品牌及其产品的信息。为了留住更多的客户并保持市场竞争力，大多数公司现在都在适应移动友好一代的需求。不同品牌的移动应用程序允许客户向某个品牌的实时代理提出问题，并发布他们的请求。

方向清晰的渠道

虽然企业正在采用非语言渠道和直接电话来帮助客户通过他们选择的任何媒介与销售代表联系，但他们不能否认决策疲劳的可能性，因为太多的渠道没有什么方向。当客户采用一种渠道与客户代表沟通时，他们希望得到快速响应。销售代表的短暂延迟响应可能会导致完全放弃联系。因此，各公司都在关注提升渠道内对话和缩短响应时间的机会。对于全渠道客户体验，公司已经提出了像聊天到语音这样的高级功能。

热门阅读:印度动态快递业的角色

处理在线分享的客户体验

随着社交网络受众的指数增长，企业现在不得不处理在线分享的客户的好体验和坏体验。根据 Zendesk 的报告，大约 45%的顾客在社交媒体上分享负面评价，而只有 30%的顾客分享正面评价。任何企业的重点都应该是通过让客户在社交媒体平台上轻松分享经验，增加客户的积极回应。此外，通过考虑差评并立即采取纠正措施，公司可以对其现有和潜在客户产生积极的印象。

不再让客户等待

客户愿意等待高质量产品的日子已经一去不复返了。今天，企业提供产品或服务的速度足以保持竞争力。消费者希望品牌不仅在交付产品或服务时，而且在解决他们的疑问时做出快速反应。一个重视客户时间并在尽可能短的时间内倾听他们的要求和询问的公司很可能会成长。为了留住忠诚的客户，公司正在采用常见问题解答和自助服务支持的手段。除此之外，品牌还需要通过在所有可能的渠道(无论是聊天、网络还是手机)提供回电来降低放弃率。

授权代理改善人与人之间的体验

尽管企业正在向自动化自助服务支持过渡，但他们不能忽视现场代理在提供优质客户服务方面的关键作用。当自助服务支持和技术失败时，人类可以充当救星，即时解决客户查询。客户服务代理现在越来越有能力解决渠道内的用户问题，并为集成数字渠道提供最佳支持。当客户服务代理与技术一起使用时，公司可以向实现客户卓越迈出重要的一步。

在“客户时代”,企业只有通过不同的客户服务渠道提供一致的体验，才能繁荣发展。它需要一个复杂的方法，在这个方法中，多个部门共同努力实现客户满意的更大目标。

由卡尔帕娜·艾莉亚

Kalpana Arya 是 Techpillar 的内容和营销专家

数据科学的秘密—业务视角是您所需要的一切

原文：https://towardsdatascience.com/top-advice-for-a-data-scientists-eadaedbe7576?source=collection_archive---------4-----------------------

概述了许多新手犯的错误

一个数据科学家需要有批判性，并且总是注意一些其他人忽略的东西。因此，这里有一些建议，人们可以将其纳入日常的数据科学工作中，以便更好地开展工作:

1.当心干净数据综合症

即使在开始处理数据之前，你也需要问自己一些问题。这个数据有意义吗？错误地假设数据是干净的可能会导致错误的假设。除此之外，通过观察数据中的差异，您可以辨别出许多重要的模式。例如，如果您注意到某个特定的列缺少 50%以上的值，您可能会考虑不使用该列。或者你可能认为一些数据收集仪器有一些误差。

或者说，在一家女性化妆品公司，男女比例为 90:10。你可以假设干净的数据并显示结果，或者你可以用常识询问标签是否被调换。

2.明智地管理异常值

离群值可以帮助你更多地了解那些一天 24 小时都在使用你的网站/产品的人。但是在构建模型时包含它们会使模型产生很大的偏差。

3.留意异常情况

在上寻找一些不明显的东西。如果你发现了什么，你可能已经找到了金子。

例如， Flickr 一开始是一个多人游戏。只有当创始人注意到人们把它作为照片上传服务时，他们才转向。

另一个例子是:fab.com 最初名为 fabulis.com，是一个帮助同性恋者交友的网站。该网站最受欢迎的特色之一是“当日同性恋交易”。有一天，交易是汉堡包——一半的购买者是女性。这让团队意识到向女性出售商品是有市场的。因此 Fabulis 转向 fab，作为设计师产品的快闪销售网站。

4.开始关注正确的指标

• 小心虚荣指标:例如，活跃用户数量本身并不会泄露很多信息。我宁愿说“活跃用户增长 5% MoM”，也不愿说“10000 活跃用户”。即便如此，这也只是一个虚荣心指标，因为活跃用户总是会增加。我宁愿跟踪活跃用户的百分比，以了解我的产品性能如何。
• 尝试找出与业务目标相关的指标。例如，特定月份的平均销售额/用户。

5.统计数据也可能会说谎

对引用给你的每件事都要持批评态度。过去，统计数据曾被用于广告、工作场所和许多其他营销场合。人们会不择手段来获得销售或促销。

例如:你还记得高露洁声称 80%的牙医推荐他们的品牌吗？

这个统计数字初看起来相当不错。原来，在调查牙医的时候，他们可以选择几个品牌——而不是一个。所以其他品牌也可能像高露洁一样受欢迎。

另一个例子:“百分之九十九的准确率”并不意味着狗屎。让我创建一个癌症预测模型，我可以用一行代码给你一个 99%准确的模型。怎么会？只需对每一个预测“没有癌症”。因为癌症是一种非常罕见的疾病，所以 99%以上的情况下我都是准确的。然而我却一事无成。

6.理解概率是如何工作的

事情发生在 1913 年夏天，在摩纳哥的一个赌场里。赌徒们惊奇地看着赌场的轮盘连续 26 次落在黑色上。由于红色对黑色的概率正好是一半，他们确定红色是“应该的”。这是赌场的大日子。一个赌徒谬误的完美例子，又名蒙特卡洛谬误。

这在现实生活中也会发生。人们倾向于避免一长串相同的答案。有时为了得到一个看起来更公平或可能的决策模式而牺牲判断的准确性。

例如，如果招生官员已经连续批准了三份申请，他可能会拒绝下一份申请，即使该申请本应根据成绩被接受。

7.相关性不等于因果关系

数据科学家工具箱的圣杯。看清事物的本来面目。仅仅因为两个变量一前一后一起移动并不一定意味着一个导致另一个。过去有过这种令人捧腹的例子。我最喜欢的一些是:

• 查看消防部门的数据，你可以推断出派往火灾现场的消防员越多，造成的损失就越大。
• 在调查 80 年代纽约市的犯罪原因时，一位学者发现严重犯罪的数量与街头小贩出售的冰淇淋数量之间有很强的相关性！显然，有一个未被观察到的变量导致了这两者。夏天是犯罪最严重的时候，也是冰淇淋卖得最多的时候。所以卖冰淇淋不会导致犯罪。这两种犯罪都没有增加冰淇淋的销量。

8.更多的数据可能会有所帮助

有时候获得额外的数据可能会创造奇迹。通过从各个角度看问题，你也许能更接近真实世界。寻找额外的数据源。

例如，一个城市的犯罪数据可能有助于银行向居住在问题社区的人提供更好的信贷额度，从而提高底线。

原载于【mlwhiz.com】

你真正需要知道的顶级算法和数据结构

原文：https://towardsdatascience.com/top-algorithms-and-data-structures-you-really-need-to-know-ab9a2a91c7b5?source=collection_archive---------0-----------------------

source: geekrescue.com

如果你想成为一名软件工程师，但不知道从何入手，那就给你省点悬念:是算法和数据结构。

一旦你掌握了这些编程支柱的要点，你就会发现它们无处不在。你学习的算法和数据结构越多，它们就越有助于你成为软件工程师。

为了让你开始，让我们先深入研究一下搜索和排序，这是你离不开的两类算法。然后让我们快速浏览一下其余的景观，包括树、图表、动态编程等等。

搜索

粗略地说，有两类搜索算法你需要马上了解:线性和二进制。深度优先搜索(DFS)和广度优先搜索(BFS)也非常重要，但是我们将把它们留到下面的图形遍历部分。

线性搜索

线性和二进制算法如此命名是为了描述基于被搜索的输入大小的搜索将花费多长时间(时间复杂度)。

例如，使用线性搜索算法，如果您有 100 个项目要搜索，那么最糟糕的情况是，在遇到您想要的值之前，您需要查看输入中的每个项目。之所以称之为线性，是因为搜索所需的时间与搜索中的项目数量完全相关(100 个项目/输入=100 次检查/复杂性)

简而言之，线性=简单(算法没什么高明之处)。例如:假设你正在一排没有特定顺序的人中寻找你的朋友林。你已经知道林的长相，所以你只需要一个接一个地看着每个人，直到你认出或者认不出林。就是这样。这样做时，您将遵循线性搜索算法

二进位检索

二分搜索法之所以得名，是因为单词 Binary 的意思是“两个事物的或与之相关的”,算法的工作原理是将输入分成两部分，直到找到要搜索的项目。一半包含搜索项，另一半不包含。该过程继续进行，直到输入被拆分的点成为被搜索的项目。二分搜索法基本上只是一个高度自律的消除过程。它比线性搜索更快，，但它只适用于有序序列。

举个例子应该能更清楚地说明这一点。假设你想在一排人中间找到你的朋友宾(身高 5 英尺 5 英寸)，这些人的身高从左到右从矮到高排列。这真的是一条很长的线，你没有时间一个一个地看完整件事，把每个人的身高和宾的进行比较。你能做什么？

进入二分搜索法。你选择在队伍中间的人，测量他们的身高。他们身高 5 英尺 7 英寸。所以你马上就知道这个人，以及他们右边的人，不是宾。现在你已经把你的问题减半了，你把注意力转向线的剩余部分，再次选择中间的人。他们身高 5 英尺 4 英寸。所以你可以排除那个人和他们左边的任何人，再次把问题分成两半。诸如此类。经过五六次这样的分裂，你很快就找到了斌，而你找到林的时间只是他的几分之一。这样做，你就遵循了二分搜索法算法。

整理

作为开发人员，对项目列表进行排序是最常见的编程任务之一。这里我们来看两个最有用的排序算法:合并排序和快速排序。

合并排序

让我们假设，你需要从一个无序的群体中创建一个有序的人群，而不是遇到上面例子中有序的人群。你没有太多时间，所以你想出了一个加快速度的策略。

你先把挤在一起的一群人分成两部分。然后，你让两个组中的每一个再分成两个，如此类推，直到你完全与个人打交道。然后你开始将两个人配对，让每对中较高的一个站在另一个的右边。很快每个人都被组织成左右有序的一对。

接下来，您开始将有序对合并成有序的四个一组；然后将四个有序组合并成八个有序组；诸如此类。最后，你发现你有了一个完整的、按身高排序的人群，就像你上面遇到的那个人一样。不知不觉中，您已经按照 MergeSort 算法完成了您的壮举。

快速排序

QuickSort 有点太复杂了，不容易与人联系起来，所以让我们更接近代码。首先，让我们假设您有一个无序列表或数组，其中包含您想要排序的八个数字。

4    2    13   6    15    12    7    9

您可以使用合并排序，但是您听说快速排序通常更快，所以您决定尝试一下。您的第一步是在列表中选择一个称为轴心的数字。选择正确的枢轴数将决定快速排序的执行速度，选择好的枢轴有现成的公式可以遵循。但是现在，让我们保持简单，只使用数组中的最后一个数字作为我们的枢纽数字:9。

4    2    13   6    15    12    7    ***9***

为了便于下一步，我们将在数组的开头创建一个分隔符，并用井号表示。

#    4    2    13   6    15    12    7    ***9***

在我们的数组中，从左到右，我们的目标是将任何小于枢轴(9)的数字放在分隔符的左边，将任何大于(或等于)枢轴的数字放在分隔符的右边。我们从数组中的第一个数字开始:4。要将其移动到分隔符的左侧，我们只需将分隔符向上移动一个元素:

4    #    2    13   6    15    12    7    ***9***

我们对下一个数字做同样的事情:2。

4    2    #    13   6    15    12    7    ***9***

但是我们到了 13，它比枢轴数 9 大，并且已经在分隔符的右侧。所以我们不去管它。接下来我们来到 6，它需要到分隔符的左边。首先，我们把它和 13 交换位置:

4    2    #    6    13    15    12    7    ***9***

然后我们移动分隔符传递给它:

4    2    6    #    13    15    12    7    ***9***

接下来是 15，它已经在分隔符的右边，所以我们不去管它。那么我们有 12 个。同样的事情。但是 7，我们到达支点前的最后一个数字，需要和 6 一样的帮助才能移动。所以我们把 7 和 13 互换位置:

4    2    6    #    7    15    12    13    ***9***

然后，我们再一次移动分隔符传递给它:

4    2    6    7    #    15    12    13    ***9***

最后，我们来到我们的枢纽数字:9。按照与上面相同的逻辑，我们将 15 与 9 交换，以获得需要的枢纽数:

4    2    6    7   #    9    12    13    15

因为 9 左边的所有数字现在都小于 9，而 9 右边的所有数字都大于 9，所以我们完成了第一轮快速排序。接下来，我们将把分隔符两边的每一组四个数字作为一个新数组来应用快速排序。我们就不告诉你细节了，但是下一轮会给我们四对数字，让我们可以轻松地进行最后一轮的快速排序。最终结果将是下面的有序列表，它比简单的 MergeSort 花费更少的时间来生成:

2    4    6    7    9    12    13    15

排序算法备忘单

这些是最常见的排序算法，以及一些何时使用它们的建议。内化这些！到处都在用！

堆排序 : 当您不需要稳定排序，并且您更关心最坏情况性能而不是一般情况性能时。它保证为 O(N log N)，并使用 O(1)辅助空间，这意味着在非常大的输入上不会意外地耗尽堆或堆栈空间。

intro sort:这是一种快速排序，在达到一定的递归深度后切换到堆排序，以避开快速排序的 O(N)最坏情况。它几乎总是比普通的老式快速排序好，因为你得到了快速排序的一般情况，并保证了 O(N log N)性能。使用堆排序的唯一原因可能是在内存严重受限的系统中，O(log N)堆栈空间实际上非常重要。

插入排序 :当 N 保证很小时，包括作为快速排序或合并排序的基础情况。虽然这是 O(N)，但它有一个非常小的常数，是一个稳定的排序。

冒泡排序 ， 选择排序 :当你在做一些快速而肮脏的事情，由于某种原因，你不能只使用标准库的排序算法。与插入排序相比，它们唯一的优势是实现起来稍微容易一些。

快速排序 : 当您不需要稳定排序并且平均情况性能比最差情况性能更重要时。快速排序平均为 O(N log N)，最坏的情况下为 O(N)。一个好的实现使用 O(log N)辅助存储，以堆栈空间的形式进行递归。

归并排序 : 当你需要一个稳定的，O(N log N)排序时，这大概是你唯一的选择。它唯一的缺点是使用 O(N)辅助空间，并且常数比快速排序稍大。有一些就地归并排序，但是它们要么不稳定，要么比 O(N log N)差。即使是 O(N log N)就地排序也有比普通的合并排序大得多的常数，因此它们更多的是理论上的好奇，而不是有用的算法。

非比较排序:在一些相当有限的条件下有可能突破 O(N log N)障碍，按 O(N)排序！这里有一些值得一试的例子:

计数排序 : 在对有限范围内的整数进行排序时。

基数排序 : 当 log(N)显著大于 K 时，其中 K 为基数位数。

桶排序 : 当你能保证你的输入近似均匀分布时。

更多必备算法和数据结构

尽管搜索和排序是进入算法和数据结构世界时最受信任、最常用的两种方法，但如果不谈论以下几个最受欢迎的方法，对这一领域的任何调查都是不完整的:

树

你将会看到很多树，因为它们是最常见的数据结构之一。它们也是最容易描绘和理解的数据结构之一。几乎所有关于树的术语都来自于家谱的概念。根据节点(即家族成员)相对于树中其他节点的位置，该节点被称为父节点、子节点、兄弟节点、祖先节点、后代节点等。

如果树具有某些属性，那么在树中存储项目允许我们以更有效的方式找到项目。(参见下面的二叉查找树

图表

如果你想得到技术，树最终只是图的一个特例。所以在日常生活和计算机科学中，图无处不在也就不足为奇了。特别是，图的遍历是一件大事，有两种算法您可能想快速掌握:广度优先搜索(BFS)和深度优先搜索(DFS)。为了了解这两个基本算法需要什么，想象一下你在一座金字塔形状的摩天大楼的顶部，你需要搜索整个建筑来找到你的朋友 Fiz。然后你意识到金字塔大致相当于一个图，每个房间都是一个节点。

【广度优先搜索】

如果你从金字塔的顶端开始，一层一层地遍历金字塔，你将大致执行对你的朋友 Fiz 的广度优先搜索。查看下面的可视化，对这种类型的搜索及其行为有更好的直觉。

【深度优先搜索】

如果你一个电梯一个电梯地走，在垂直切片中遍历金字塔时，检查每一站最近的房间，而不是一层一层地走，你将大致执行深度优先搜索你的朋友 Fiz。同样，下面的可视化应该有助于使这一点更清楚。

source: geeksforgeeks.com

动态编程

如果你正面临一个巨大的、重量级的编程问题，你无法想象自己能解决，那么动态编程(DP)可能会帮助你。DP 会帮你把大问题变成小的子问题。每当 DP 解决一个子问题时，它保存结果，并最终将所有保存的结果放在一起，以便处理大问题。

哈希

近年来，我们查找数据的方式发生了巨大变化。虽然主要方法曾经是二分搜索法，但现在越来越多地成为散列查找。尽管我们在这里不做时间复杂度的比较，但可以说，当搜索包含数百万个条目的列表时，散列法通常要快得多。

字符串模式匹配

如果您听说过正则表达式(又名 regex)，那么您一定听说过字符串模式匹配。这里的想法是，你搜索的不是一个项目，而是许多项目共有的模式。例如，假设您正在一本书中搜索所有以问号结尾的句子:这是字符串模式匹配的工作。

还有更多…

我们已经走过了很多地方。但是我们仍然几乎没有暗示算法和数据结构世界的宏大范围。这里还有一些值得你深入研究的东西:

数据结构:数组
链表
栈
队列

算法:素性测试
快速傅立叶变换
二进制取幂
平方取幂

软件成功的道路是由算法铺就的

如果没有别的，以上所有的都应该让你明白，如果你想成为一名软件工程师，算法和数据结构将会为你铺平道路(甚至可能会支付报酬)。对于坚如磐石的基础，你可能想从搜索(线性和二进制)和排序(SortMerge 和 QuickSort)开始。一旦你掌握了这些编程支柱的要点，是时候学习关于树、图遍历(BFS 和 DFS)、动态编程和字符串模式匹配的一切了。但真正的目标是开始体验算法和数据结构:思考现实世界问题的逐步解决方案，并根据简单的数据结构描绘复杂的场景。如果你能掌握这一点，那么编码就会自然而然。

如果你喜欢这篇文章，我的个人博客(jasonroell.com)上有更多类似的内容。看看吧，祝你有美好的一天！

为什么数据科学不仅仅是？适合()。预测()

原文：https://towardsdatascience.com/top-examples-of-why-data-science-is-not-just-fit-predict-ce7a13ef7663?source=collection_archive---------4-----------------------

在这篇文章中，我将回顾一些我学到的让我从一名技术数据科学家变成一名优秀数据科学家的顶级概念

两个月前，我结束了在 YellowRoad 作为数据科学家的第二年，所以我决定对我的项目进行回顾性分析，我做得好吗？我发现了哪些有趣的方法？我犯了什么错误？最重要的是，我学到了什么？

在这篇文章中，我将回顾我学到的一些顶级概念，在我看来，这些概念使我从一个运行模型并可以很容易被 autoML 取代的技术数据科学家变成了一个优秀的数据科学家，即使不需要最先进的研究，也能在每个项目中提供价值。

1)数据泄露

根据 Kaggle 的说法，数据泄漏是在训练数据中创建意外的附加信息，允许模型做出不切实际的良好预测。或者更简单的定义，任何能让你的模型在研究中比在生产中表现更好的东西。我有一百万种类型的数据泄漏，有时是由于模型中的错误(比如将标签作为一个特性输入)，有时是由于数据集创建中的错误(比如创建一个包含未来信息的特性)，有时是由于业务逻辑中的错误(比如使用不能在生产中使用的特性)。关于数据泄漏最危险的事情是很难发现，有时只有当你发现测试集的准确率为 90%而生产的准确率只有 60%时，你才会发现泄漏。如果你想了解更多关于数据泄露的信息，你可以观看我的闪电谈话，从 11:15 开始(只有 10 分钟:)。

2)选择偏差

选择偏倚是指通过选择个体、群体或数据进行分析而引入的偏倚，这种方法不能实现适当的随机化(来自维基百科)。例如，如果您正在使用贴在脸书墙上的调查问卷构建一个训练集。回答这个问题的人可能和你年龄相仿，来自你的国家甚至城市，拥有你的社会经济属性。如果你只基于这些数据建立一个模型，当它投入生产时，它将暴露给更广泛的人群，你的模型对你的朋友有效的事实并不意味着它对每个人都有效。有时，选择偏差甚至比数据泄露更难，因为如果你可以监控所有群体的标签，你就可以使用这些标签进行训练。选择偏差也更难修复，你可以基于整个群体重新加权你的训练集，或者删除将训练集与整个群体区分开来的特征，但你不能真正评估这些方法是否有效。更多关于卢卡斯·伯纳蒂精彩演讲的选择偏见。

3)生产反馈回路

在许多机器学习应用程序中，生产工作流看起来是这样的:机器学习模型对用户行为进行预测，系统根据模型输出采取行动，用户对系统做出反应，模型根据用户行为进行重新训练。这种反馈循环中，模型对其未来训练集的影响会导致一些偏差。例如，在一个推荐引擎中，我们根据用户点击的项目进行排名，但是如果我们首先对一个项目进行排名，那么它的点击概率高于排名第 10 的项目。这样，我们的模型将永远不会学习新的东西，即使有些项目对用户来说更好。为了解决这个问题，我们通常使用 exploration，即使一个项目从模型中以某种概率得到低分，也将其排名靠前，或者相对于项目的先前排名重新调整模型标签，如果项目是从第二页被点击的，那么它比第一个项目被点击的指示更强。另一个例子是预测客户是否会归还贷款。我们不知道如果我们批准我们拒绝的贷款会发生什么，因此，我们正在为模型的下一个训练集创建一个偏差。

4)特殊交叉验证技术

在某些情况下，使用随机交叉验证是不够的，因为生产数据看起来与研究数据不同，我们需要使用特殊的交叉验证方法。例如，在时间序列数据集中，由于自然或特殊事件，数据分布通常会发生变化。如果我们将使用随机交叉验证，训练和测试数据分布将是相同的，我们不知道我们的模型是否对这种数据分布变化具有鲁棒性。因此，在时间序列中，我们需要使用滑动窗口交叉验证，而不是随机验证。关于时间序列交叉验证的更多信息，你可以在这篇文章中阅读。另一种特殊情况是当您的数据中有组时，例如在医学临床试验中，您在试验期间有同一患者的许多实例。为了确保我们的模型将推广到新的组，我们需要使用组交叉验证，其中每个文件夹包含几个组的所有示例，在测试时间，我们将测试新的组。

5)选择“正确的”评估指标

这是一个有点陈词滥调的句子，有时在真实场景中很难做到，但是你评估你的模型的方式应该与你的用例的业务需求高度相关。我会举一些例子，我有一个项目，在一个广告技术公司建设一个投标人，将决定支付多少印象。我们的方法是建立一个模型，预测公司可以从一个印象中赚多少钱，然后根据预测设定出价。在这个模型中，MSE 是一个糟糕的评估指标，尽管它可能是回归模型中最流行的指标。MSE 对大错误的惩罚比对小错误的多。在这个模型中，当公司设法以非常高的价格出售印象时，大多数大错误都是异常的。预测异常几乎是不可能的，所以即使在这些异常中，其他人也会提供与其他印象大致相同的出价。如果我们的预测会更低，我们有时仍然会购买这些异常，但如果我们对常规印象提供大量出价，我们会损失很多钱。另一个例子是排名模型，准确性和 MSE 显然与业务用例不匹配，但即使不同的排名指标也可以适合不同的用例。如果您只向用户呈现前 K 项，那么 K 处的回忆应该是您的评估指标。但是，如果你向用户展示一个长长的排序列表，并且他看到一个项目的概率随着排序的降低而降低，那么 NDCG 是一个非常好的度量。

6)从一个简单的模型开始

使用新的深度 Cnn Rnn 与 Gans 的残余变压器注意力和一些网络区块链层的流行语很酷，甚至非常酷，但这不是一个开始项目的好方法。从具有少量特征的简单模型开始有几个优点。调试模型和发现错误或数据泄漏更容易，你更好地理解模型的预测，并知道如何使它表现得更好，以及哪些研究方向更有前途，如果你看到数据中没有信号，你会很快失败，并花一点时间转移到你的下一个项目，这可能是最重要的优势，有时简单的模型足以满足你的业务需求，所以你节省了大量的研究和 GPU 时间。

7)不要使用ε型号

在 Kaggle 比赛中，获胜的模特通常是拥有数百种特征的 30 个模特的组合。这些模型通常比一个好模型或 2-3 个简单模型的集合好 0.01 点。这些复杂的模型被称为 epsilon 模型，因为它们只增加了一个 epsilon 的性能，但给生产系统带来了巨大的复杂性。每个模型甚至特征都是另一个潜在的漏洞，它需要更多的训练和推理时间以及更多的内存。在由于复杂性和性能导致的成本权衡中，除了模型的准确性与收入高度相关的特殊情况，较简单的模型胜出。

8)监控生产中的模型

在大多数实际应用中，由于业务决策、用户行为的变化、模型引起的变化等等，数据分布总是在变化。这意味着您的模型性能可能会随着时间的推移而下降。为了阻止这种现象，我们需要监控模型的性能，并在性能显著下降时重新训练模型甚至返回研究阶段。但是，在许多情况下，我们没有新的标签(例如，如果我们用 Mechanical Turk 标记我们的训练集)，或者我们在很长时间后发现了这些标签(例如，如果我们预测某个企业是否会归还其 5 年贷款)。在这些情况下，我们应该监视定型集和生产数据之间的数据变化，甚至监视模型预测概率分布的变化。这里是 Jannes Klaas 关于监控生产中的机器学习模型的精彩演讲。

感谢阅读:)

我希望这篇文章能给你一些启发，也希望你能从我过去的错误中吸取教训，以后不会再犯同样的错误。

希望你喜欢我的帖子，非常欢迎你阅读和关注我的博客。

数据科学的顶级 R 库

原文：https://towardsdatascience.com/top-r-libraries-for-data-science-9b24f658e243?source=collection_archive---------5-----------------------

courtresy: https://pixabay.com/en/statistic-survey-website-template-1606951/

在这里，让我告诉你一些关于 R 的一些很棒的库。我认为这些库是数据科学的顶级库。这些库具有广泛的功能，对于数据科学操作非常有用。我曾经使用过它们，并且仍然在日常的数据科学操作中使用它们。不浪费任何时间，让我带你开始可怕的 R 的东西。

这里提到的这些库是随机排列的，我不想给它们排名，因为它们都有自己的用处，对它们进行排名是不合理的。

1。Dplyr

Dplyr 主要用于 r 中的数据操作，Dplyr 实际上是围绕这 5 个函数构建的。这些函数构成了大部分的数据操作。您可以使用本地数据框和远程数据库表。您可能需要:

选择 某列数据。

过滤 您的数据以选择特定的行。

将 您的数据行排列成一个顺序。

改变 您的数据框以包含新列。

以某种方式总结 你的大块数据。

它还具有类似于的功能，由 和 管组成。

2。 Ggplot2

Ggplot2 是 r 中最好的数据可视化库之一。ggplot2 库实现了一种“图形语法”(Wilkinson，2005)。这种方法通过表达数据属性和它们的图形表示之间的关系，为我们提供了一种产生可视化效果的一致方法。Ggplot2 具有广泛的功能。

阅读这个 R 文档了解 ggplot2 函数，点击这里:https://bit.ly/2DBo0VK

3。Esquisse——我最喜欢的包，对 r 最好的补充**

不喜欢 ggplot2？使用 ggplot2 和它的功能有一些问题，那么这个包是给你的。这个包将 Tableau 最重要的特性带到了 r 中。只需拖放，几分钟就可以完成可视化。这实际上是对 ggplot2 的增强。此加载项允许您通过使用 ggplot2 包可视化数据来交互式地浏览数据。它允许您绘制条形图、曲线、散点图、直方图，然后导出图表或检索生成图表的代码。太棒了，不是吗？

4。生物导体

当你进入数据科学领域时，你会处理不同种类的数据。你可能不知道将来要处理什么样的数据。如果你在健康行业，那么相信我，你会发现这非常有用。我认为这个库在你研究基因组数据时非常有用。Bioconductor 是一个开源项目，托管了大量使用 r 分析生物数据的工具。要安装 Bioconductor 软件包，您需要安装bio manager。**

• 图形:geneplotter，hexbin。
• *注释:annotate，ann builder【https://bit.ly/2OUYdd5 *
• 5。闪亮
• 这是 r 中一个非常有名的包。当你想与你周围的人分享你的东西，让他们更容易理解和直观地探索它时，你可以使用 shiny。它是数据科学家最好的朋友。Shiny 让构建交互式网络应用变得更加容易。你可以在网页上托管独立的应用程序，或者将它们嵌入到 R Markdown 文档中，或者构建仪表盘。你也可以用 CSS 主题、 htmlwidgets 和 JavaScript 动作来扩展你闪亮的应用。
• 6。润滑剂
• 这个图书馆非常适合它的用途。主要用于数据角力。它使 r 中的日期-时间处理变得更加容易。使用这个库，您可以做任何您想做的关于日期算法的事情，尽管在这里理解和使用可用的功能可能有些复杂。当你在分析时间序列数据并想按月汇总数据时，你可以使用 lubridate 包中的 floor_date ，它可以很容易地完成你的工作。它具有广泛的功能。你可以在这里阅读文档:https://bit.ly/2AbTEpf
• 7。针织机

这个包用于 R 中的动态报告生成。knitr 的目的是允许通过有文化的编程方式在 R 中进行可再现的研究。这个包还支持将 R 代码集成到 LaTeX、Markdown、LyX、HTML、AsciiDoc 和 reStructuredText 文档中。您可以将 R 添加到 markdown 文档中，并轻松生成 HTML、Word 和其他格式的报告。如果您对可重复的研究感兴趣，并且对从数据分析到报告创建的自动化之旅感兴趣，这是一个必备工具。

8。Mlr

这个包在执行机器学习任务方面绝对不可思议。它几乎拥有执行机器学习任务的所有重要和有用的算法。它也可以被称为分类、回归、聚类、多分类和生存分析的可扩展框架。它还具有用于特性选择的过滤器和包装器方法。另一件事是，这里执行的大多数操作都可以并行化。文档中提到了广泛的功能:【https://bit.ly/2QflLy6】T2

9。昆达。词典**

这个包扩展了 quanteda 包的功能。它由用于文本分析的词典组成。它主要用于 quanteda，但也可以用于其他文本分析库，如 tm、tidytext 和 udpipe。通过 quanteda.dictionaries 包中的 liwcalike() 函数，您可以使用现有的或定制的词典轻松地分析文本语料库。你可以从他们的 github 页面安装这个包。

10。DT

它是 javascript 库 数据表的包装器。 用于数据显示，可以将 R 矩阵和数据框显示为交互式 HTML 表格。使用这个库，你可以用最少的代码创建一个可排序的表，实际上你可以只用一行代码创建一个可排序的、可搜索的表。你也可以设计你的桌子。数据表还在表中提供过滤、分页、排序和许多其他功能。

11。罗勒

RCrawler 是一个贡献的 R 包，用于基于域的 web 爬行和内容抓取。它增加了 Rvest 包所缺少的爬行功能。RCrawler 可以抓取、解析、存储页面、提取内容并生成可直接用于 web 内容挖掘应用程序的数据。爬行操作的过程是由几个并发进程或节点并行执行的，因此建议使用 64 位版本的 r。

12。插入符号

Caret 代表分类和回归训练。软件包中的主要工具之一是培训功能，可用于。使用重新采样评估模型调整参数对性能的影响。Caret 有几个功能，试图简化模型构建和评估过程，以及特征选择和其他技术。你只需要知道这个包就可以解决几乎所有有监督的机器学习问题。它为几种机器学习算法提供了统一的接口，并标准化了各种其他任务，如数据分割、预处理、特征选择、变量重要性估计等。

13。RMarkdown

R Markdown 允许您创建文档，作为您的分析的整洁记录。在可重复研究的世界里，我们希望其他研究人员能够容易地理解我们在分析中做了什么，否则没人能确定你正确地分析了你的数据。R Markdown 是 Markdown 的一个变种，它嵌入了 R 代码块，与knitter一起使用，可以轻松创建可复制的基于 web 的报告。使用 R Markdown，您可以将您的分析转化为高质量的文档、报告、演示文稿和仪表盘。

14。传单

这是一个 javascript 库，主要用于绘制和处理交互式地图。而且，你可以从 R 控制台直接使用这些地图。传单为您提供了不同的功能集，可用于样式和自定义您的地图。这个库的开发工作也很广泛。如果你想使用地图，一定要试试这个库。除了基本地图之外，您还可以为地图使用不同的单幅图块。

15。看门人

看门人使基本的数据清理变得容易，例如通过多个列找到重复项，使 R 友好的列名和删除空列。它也有一些很好的制表工具，比如添加一个总计行，以及生成带有百分比和简单的交叉标签的表格。而且，它的 get_dupes()函数是一种在数据框中查找重复行的优雅方式，可以基于一列、几列或整行。

其他值得一提的 R 库:

Ggvis

Plotly

Rcharts

Rbokeh

金雀花

StringR

1. 马格里特
2. Slidify
3. Rvest
4. 将来的
5. RMySQL
6. 红柱石
7. 先知
8. Glmnet
9. Text2Vec
10. 雪球 c
11. Quantmod
12. Rstan
13. 漩涡
14. 数据科学家
15. 如果我错过了任何重要的库，请在下面的评论区告诉我。
16. 所以，这就是，这些是你需要知道的一些顶级库，以便完成你的日常数据科学操作。
17. 表现出一些爱心，如果有帮助的话！
18. 感谢阅读！
19. Swirl
20. DataScienceR

If I’ve missed out any important library then do let me know down below in the comments section.

So, This is it, these were some of the top libraries that you need to know in order to get your day to day Data Science operations done.

Show some love, if it was helpful!

Thanks for reading!

亚马逊评论的主题挖掘

原文：https://towardsdatascience.com/topic-mining-on-amazon-reviews-ae76fc286c61?source=collection_archive---------15-----------------------

如何用 NLP 理解客户的声音？

互联网上充斥着对商品、商店和服务的评论。这些评论是产品经理更好地了解他们的客户的关键。在本教程中，我们将使用 RapidMiner 和 Python 对亚马逊评论进行主题建模。

看一看数据

我们正在分析的数据来自 kaggle 。总数据集由 564.033 条评论组成。除了文章的评论正文，我们还获得了一些更多的描述属性，如发布时间、有用性和用户产品 id。在这篇文章中，我们将重点放在文本本身。

Read In and sample process in RapidMiner.

由于运行时间的原因，我们将把评论的数量减少到 10，000。

预处理

像往常一样，在分析中，我们需要对数据进行一些预处理。对于这个分析，我们首先希望用 Transform Cases 操作符将所有内容转换成小写。稍后，我们还想删除像“the”这样的停用词。这些词在检测我们数据中的不同主题时没有用。如果它们有助于我们的建模，这通常是一个消极点——即产生一个“通用的”主题或类似的主题。

Preprocessing in RapidMiner. The left subprocess retrieves a frequency list and filters it for the top50 words.

我们进一步删除在文档中出现少于 50 次的所有单词。这有助于我们在获得良好结果的同时减少运行时间。

LDA 和检测到的主题

为了检测主题，我们运行潜在的狄利克雷分析，或简称 LDA。这是一个任务是在数据集中寻找主题的算法。我们使用 RapidMiner 的操作工具箱扩展中的 Extract Topics from Documents (LDA)操作符来实现这一点。这背后的实现来自于 MALLET ，在 R & Python 中也有。

LDA 算法需要设置一些参数。除了预处理决策，我们还需要定义要搜索的主题数量、狄利克雷分布的先验知识以及优化迭代的次数。在本例中，我们将重点关注主题数量的定性分析。对于先验，我们使用 MALLET 的参数自动调整，对于迭代，我们使用 1000。

Main Setup for the LDA in RapidMiner. The outer Loop Parameter Operator varys the number of topics in each iteration.

如果您想对超参数进行定量优化，您可以使用作为性能向量公开的模型诊断。这里的问题是，你添加的主题越多，大多数性能指标通常会变得越好。这有点像集群中的问题，集群内的距离越短，添加的集群越多。因此，我决定定性地做这件事，用最重要的词的词云来观察聚类。

Most important words per topic for a total of six topics. Topic_5 can be identified as a “general” topic including a lot of texts on general amazon services, while the other are product categories.

Most important words per topic for a total of 12 topics. The generic topic is split into two — Topic_0 and Topic_3.

你可以在单词 clouds 中清楚地看到，你添加的越多，一些主题似乎就分裂成了副主题。当选择 6 个主题时，您可以看到 Topic_5 是通用 amazon 和产品相关主题的混合。如果你有 12 个主题，这个主题可以分成主题 0、主题 3 和主题 5。相似性，你可以看到“咖啡”和“茶”在 6 个主题的设置中是一个很好的主题，但在 12 个主题中有两个。

当然，决定选择什么主题应该与你的商业目标相一致。如果你有兴趣单独跟踪茶评论的数量，你不应该选择 6。话题回顾。

话题挖掘可以做什么？

我们已经看到了如何实现主题建模，但通常问题是:我为什么要在业务中这样做？

将主题挖掘应用于您的客户或内部数据可以轻松快速地使您的分析团队(甚至是领域专家和业务分析师)能够直观地识别数据中的因果关系和相关性，并帮助他们解决具有挑战性的业务问题，如客户流失和员工满意度。

最受欢迎的应用是:

• 社交媒体评论分析
• 案例系统处理
• NPS 访谈分析

让我们来看看一些最常见的前进方式。

向下钻

手头有了主题分配，你可以把它放入普通的 BI 工具中。有没有一个特定的话题聚集的区域？我们在某个特定的周末遇到问题了吗？所有这些问题都可以从数据中找到答案。

分析话题趋势

有时候你对单一话题感兴趣。您想知道“交付时间”话题是否会随着时间的推移而增加。通过对每天与主题相关的文档数量进行时间序列预测，您可以创建一个警报信号。该信号通知用户或负责的业务单位，在作为主题的“交付时间”中存在峰值，并且在交付过程中可能存在瓶颈，从而允许企业解决该问题并保持良好的服务。

为进一步分析进行预处理

当然，您现在可以使用这些主题分布来进一步分析您的文本数据:

• 使用产品的主题分布作为进一步分析的输入，例如监督学习。
• 用于聚类以发现相似产品的主题分布。
• 对主题分布和其他属性进行异常检测，以发现“奇怪”的产品。

结论

在本文中，我们在亚马逊评论上使用了主题挖掘。正如你所看到的，这种技术可以很快使用，并产生可理解的结果。所有的流程、脚本和数据样本都可以在 my github profile 上找到。

Python 中的主题建模和潜在狄利克雷分配

原文：https://towardsdatascience.com/topic-modeling-and-latent-dirichlet-allocation-in-python-9bf156893c24?source=collection_archive---------0-----------------------

Photo Credit: Pixabay

主题建模 是一种用于发现文档集合中出现的抽象“主题”的统计建模。 潜在狄利克雷分配 (LDA)是主题模型的一个例子，用于将文档中的文本分类到特定主题。它建立了每个文档的主题模型和每个主题的单词模型，建模为 Dirichlet 分布。

这里我们将把 LDA 应用于一组文档，并把它们分成主题。我们开始吧！

数据

我们将使用的数据集是 15 年间出版的超过 100 万条新闻标题的列表，可以从 Kaggle 下载。

import pandas as pddata = pd.read_csv('abcnews-date-text.csv', error_bad_lines=False);
data_text = data[['headline_text']]
data_text['index'] = data_text.index
documents = data_text

看一眼数据。

print(len(documents))
print(documents[:5])

1048575

Figure 1

数据预处理

我们将执行以下步骤:

• 分词:将文本拆分成句子，句子拆分成单词。将单词小写，去掉标点符号。
• 少于 3 个字符的单词将被删除。
• 所有停用字都被移除。
• 单词被词汇化了——第三人称的单词变成了第一人称，过去时态和将来时态的动词变成了现在时态。
• 单词被词干化——单词被还原成它们的词根形式。

加载 gensim 和 nltk 库

import gensim
from gensim.utils import simple_preprocess
from gensim.parsing.preprocessing import STOPWORDS
from nltk.stem import WordNetLemmatizer, SnowballStemmer
from nltk.stem.porter import *
import numpy as np
np.random.seed(2018)import nltk
nltk.download('wordnet')

【nltk _ data】下载包 wordnet 到
【nltk _ data】C:\ Users \ Susan Li \ AppData \ Roaming \ nltk _ data…
【nltk _ data】包 wordnet 已经是最新的了！

真

编写一个函数，对数据集执行词汇化和词干预处理步骤。

def lemmatize_stemming(text):return stemmer.stem(WordNetLemmatizer().lemmatize(text, pos='v'))def preprocess(text):result = []for token in gensim.utils.simple_preprocess(text):if token not in gensim.parsing.preprocessing.STOPWORDS and len(token) > 3:result.append(lemmatize_stemming(token))return result

选择预处理后的文件进行预览。

doc_sample = documents[documents['index'] == 4310].values[0][0]print('original document: ')
words = []
for word in doc_sample.split(' '):words.append(word)
print(words)
print('\n\n tokenized and lemmatized document: ')
print(preprocess(doc_sample))

原始文档:

['雨'，'帮忙'，'浇灭'，'丛林大火']

标记化和词条化的文档:

['雨'，'救命'，'浇灭'，'灌木']

成功了！

预处理标题文本，将结果保存为‘processed _ docs’

processed_docs = documents['headline_text'].map(preprocess)
processed_docs[:10]

Figure 2

数据集上的单词包

从“processed_docs”创建一个字典，其中包含一个单词在训练集中出现的次数。

dictionary = gensim.corpora.Dictionary(processed_docs)count = 0
for k, v in dictionary.iteritems():print(k, v)count += 1if count > 10:break

0 播出

1 共产主义

2 分钟

**T5 3 许可 **

4

5 默认

6 机智

⑦谓

8 基础设施

9 保护

10 峰会

Gensim 过滤器 _ 极端情况

过滤掉出现在中的令牌

• 少于 15 份文件(绝对数量)或
• 超过 0.5 个文档(总语料库大小的一部分，而不是绝对数量)。
• 完成上述两个步骤后，只保留前 100000 个最常用的令牌。

dictionary.filter_extremes(no_below=15, no_above=0.5, keep_n=100000)

Gensim doc2bow

对于每个文档，我们创建一个字典，报告有多少
单词以及这些单词出现了多少次。将此保存到“bow_corpus ”,然后检查我们之前选择的文档。

bow_corpus = [dictionary.doc2bow(doc) for doc in processed_docs]
bow_corpus[4310]

[(76，1)，(112，1)，(483，1)，(3998，1)]

我们的样本预处理文档的单词预览包。

bow_doc_4310 = bow_corpus[4310]for i in range(len(bow_doc_4310)):print("Word {} (\"{}\") appears {} time.".format(bow_doc_4310[i][0], dictionary[bow_doc_4310[i][0]], 
bow_doc_4310[i][1]))

字 76(“bush fir”)出现 1 次。

字 112(“帮助”)出现 1 次。

字 483(“雨”)出现 1 次。

字 3998(“挫伤”)出现 1 次。

TF-IDF

使用模型创建 tf-idf 模型对象。' bow_corpus '上的 TfidfModel 并将其保存到' tfidf '，然后对整个语料库应用转换并将其命名为' corpus_tfidf '。最后，我们预览了第一份文档的 TF-IDF 分数。

from gensim import corpora, modelstfidf = models.TfidfModel(bow_corpus)
corpus_tfidf = tfidf[bow_corpus]from pprint import pprintfor doc in corpus_tfidf:pprint(doc)break

[(0，0.5907943557842693)，

(1，0.3900924708457926)

(2，0.49514546614015836)

(3，0.5036078441840635)】

运行 LDA 使用的包字

使用 gensim.models.LdaMulticore 训练我们的 lda 模型，并将其保存到“lda_model”

lda_model = gensim.models.LdaMulticore(bow_corpus, num_topics=10, id2word=dictionary, passes=2, workers=2)

对于每个主题，我们将探索在该主题中出现的单词及其相对权重。

for idx, topic in lda_model.print_topics(-1):print('Topic: {} \nWords: {}'.format(idx, topic))

Figure 3

你能用每个题目中的单词和它们对应的权重来区分不同的题目吗？

使用 TF-IDF 运行 LDA

lda_model_tfidf = gensim.models.LdaMulticore(corpus_tfidf, num_topics=10, id2word=dictionary, passes=2, workers=4)for idx, topic in lda_model_tfidf.print_topics(-1):print('Topic: {} Word: {}'.format(idx, topic))

Figure 4

还是那句话，能不能用每个题目里的词和对应的权重来区分不同的题目？

使用 LDA 词袋模型对样本文档进行分类的性能评估

我们将检查我们的测试文档将被分类到哪里。

processed_docs[4310]

['雨'，'帮助'，'挫伤'，'灌木']

for index, score in sorted(lda_model[bow_corpus[4310]], key=lambda tup: -1*tup[1]):print("\nScore: {}\t \nTopic: {}".format(score, lda_model.print_topic(index, 10)))

Figure 5

我们的测试文档最有可能成为我们的模型分配的主题的一部分，这就是准确的分类。

使用 LDA TF-IDF 模型对样本文档进行分类的性能评估。

for index, score in sorted(lda_model_tfidf[bow_corpus[4310]], key=lambda tup: -1*tup[1]):print("\nScore: {}\t \nTopic: {}".format(score, lda_model_tfidf.print_topic(index, 10)))

Figure 6

我们的测试文档最有可能成为我们的模型分配的主题的一部分，这就是准确的分类。

在看不见的文档上测试模型

unseen_document = 'How a Pentagon deal became an identity crisis for Google'
bow_vector = dictionary.doc2bow(preprocess(unseen_document))for index, score in sorted(lda_model[bow_vector], key=lambda tup: -1*tup[1]):print("Score: {}\t Topic: {}".format(score, lda_model.print_topic(index, 5)))

Figure 7

源代码可以在 Github 上找到。我期待听到任何反馈或问题。

参考:

Udacity — NLP

使用 Google Colab 为每个人进行主题建模

原文：https://towardsdatascience.com/topic-modeling-for-everybody-with-google-colab-2f5cdc99a647?source=collection_archive---------5-----------------------

Image from Pixabay

注意:Google Colab 笔记本已经针对 Python 3 进行了更新，包括 pyLDAvis 可视化，并改进了主题中热门单词和热门文档的原始显示。

您现在可以在文本中查找主题，而无需安装任何库或编写一行 python 代码。这一切都是由 Google Colab 实现的，这是一款定制的协作 Jupyter 笔记本，可以托管在 Google Drive 上。包含两个主题建模算法的奇妙的 Scikit-Learn 库默认安装在 Google Colab 上，这使得在文本中查找主题变得非常容易。

这篇博文和附带的 Google Colab 笔记本的目的是让主题建模能够被更广泛的受众所接受。诸如非负矩阵分解(NMF)和潜在狄利克雷分配(LDA)的主题建模算法在文档集合中寻找主要主题或主题。文档集合可以是短文档，如 tweets 或自由文本调查回复，也可以是长文档，如博客帖子或新闻文章。NMF 和 LDA 算法有两个有利于文本聚类的特点，这是其他算法如 k-means 所没有的。这两种算法都将文档集合作为输入，并返回主题中的主要单词和属于主题的文档——这一特性使得输出可解释。NMF 和 LDA 还支持主题之间的重叠(即文档可以属于多个主题)。我特别希望看到研究人员和定性内容分析师开始使用主题建模算法，现在他们可以了，这要归功于一个简单的 Google Colab 笔记本，它可以处理来自 Google Sheet 的数据。只需遵循以下简单步骤:

• 去 https://colab。研究。Google . com/Github/aneesha/Google colab _ topic modeling/blob/master/Colab _ topic modeling . ipynb
  以上网址将从 Github repo 中打开 Colab 笔记本。
• Colab 笔记本将会打开。只有将 Colab 笔记本保存到 Google Drive 文件夹后，您才能使用它。点击文件菜单，选择“保存一份拷贝到驱动器…”。
• 接下来，您需要在您的驱动器文件系统上找到 Colab 笔记本。点击文件菜单，选择“在驱动器上定位”。
• 该文件夹通常被称为“Colab 笔记本”。创建一个新的 Google 工作表并导入文本数据。文本数据需要两列，即 id 和 text。

Figure 1: The required columns in the Google Sheet

• 返回到 Colab 笔记本，输入 Google 工作表的名称。您可以更改代码，但会提供一个表单字段。单击位于单元格左侧的播放按钮，运行第一个笔记本单元格。您需要通过点击链接来授权访问您的 Google Drive。在授权过程结束时，您需要输入一个验证码。

Figure 2: Authorizing access to a Google Sheet

• 运行“从 Google Sheet 加载和预览数据”笔记本单元格。将显示数据集的前几行。
• 使用提供的表单字段设置需要生成的主题数、热门单词数和必须显示的热门文档数。

Figure 3: Specifying the NMF and LDA algorithm parameters

• 运行 NMF 或 LDA 细胞。将显示主题模型的输出。

Figure 4: Topics discovered by the NMF topic modeling algorithm

• 笔记本现在是你的了。你可以把它移到一个新的文件夹，并添加新的谷歌工作表进行分析。
• 就这样——没有更多的步骤了。

Google Colab 笔记本的发布能够对来自 Google Sheet 的文本数据进行主题建模，这消除了开始主题建模的所有技术障碍。NMF 和 LDA 主题建模算法可以应用于一系列个人和商业文档集合。让你开始的一些例子包括自由文本调查回复、客户支持电话记录、博客帖子和评论、匹配标签的推文、你的个人推文或脸书帖子、github 提交、招聘广告和技术文章。如果你想出一种新的方法来使用 Google Colab 笔记本应用主题建模，请在评论区发布你的例子。

纽约时报新闻数据集的主题建模

原文：https://towardsdatascience.com/topic-modeling-for-the-new-york-times-news-dataset-1f643e15caac?source=collection_archive---------0-----------------------

Credits: Mario Tama, News Getty Images

一种用于新闻主题分类的非负矩阵分解方法

为什么要主题建模？

我们生活在一个不断收集数据流的世界。因此，从收集的信息中寻找见解会变得非常乏味和耗时。主题建模是作为组织、搜索和理解大量文本信息的工具而设计的。

什么是主题建模？

在机器学习中，主题模型被具体定义为一种自然语言处理技术，用于发现文档集合中文本的隐藏语义结构，通常称为语料库。一般来说，每个文档指的是一组连续的单词，就像一个段落或一篇文章，其中每篇文章包含一组单词。

让我们以纽约时报数据集为例，其中每篇文章代表一个文档。我们想解决的问题是这些单词在一个文档中出现的频率。这将允许我们将每个文档分类到一个特定的主题。

NMF 是如何工作的？

通常使用两种主要的主题建模技术，潜在狄利克雷分布 (LDA)和非负矩阵分解 (NMF)。让我们把重点放在主题建模的后一个实现上，对纽约时报新闻数据集中的相似词进行聚类。

NMF 技术通过概率分布检查文档并在数学框架中发现主题。作为一个例子，我们首先用矩阵 X 作为我们的数据。这个矩阵由两个更小的矩阵 W 和 H 表示，当它们相乘时，近似重构 X 。

在实施 NMF 之前有一些先决条件。首先，数据 X 必须有非负的条目。没有丢失，但可能有许多零。第二，学习因式分解 W 和 H 必须有非负项。

如何实现 NMF？

这个问题中使用的数据由来自纽约时报的 8447 份文件组成。词汇量 3012 字(此处下载)。我们首先使用该数据构建矩阵 X ，其中 Xij 是单词 I 在文档 j 中出现的次数。因此， X 是 30，128，447，并且 X 中的大多数值将等于零。

这里，我们将一个 N × M 矩阵 X 分解成一个秩- K 近似值 W H ，其中 W 是 N × K ， H 是 K × M ，矩阵中的所有值为 W 和 H 中的每个值都可以随机初始化为一个正数，这里我用的是均匀(0，1)分布。

我们通过最小化以下散度损失对该数据实施并运行 NMF 算法，其中 W 和 H 包含非负值:

对于数据预处理和矩阵计算，您可以在本文底部的编码参考中找到我的原始代码。

现在让我们挑选一些我们想要排序的主题，以及我们预期目标函数会偏离的迭代次数。假设我们将等级设置为 25，并运行 100 次迭代，这也对应于学习 25 个主题。

我们可以看到目标图是下面迭代的函数。通过观察目标函数的散度，我们确保了用于聚类相似单词的模型是稳定的。

运行该算法后，我们希望规范化 W 的列，使它们的总和为 1。这也是为了确保我们得到的概率分布没有大于零的值。

现在，假设我们为每个话题选择 10 个单词。对于 W 的每一列，我们列出了具有最大权重的 10 个单词，并显示权重以显示我们预期的概率分布。 W 的第 i- 行对应于提供数据的“字典”中的第 i- 个单词。

主题建模结果

下表捕获了一组包含 25 个主题的文档，这是我们预期的结果。仔细查看结果，话题 7 指的是财经话题，医疗领域话题 13 ，娱乐领域话题 14 ，以及商业领域话题 24 。这些只是数百个话题中的 25 个，如果不是数百万的话，还有其他的可能性！

挑战: 你能猜出上面每个题目代表什么吗？下面评论下来！

编码参考

注意:代码是基于 NMF 背后的原始数学概念和直观计算实现的，但更方便的替代方法是使用 Python 库，如 scikit-learn 。

希望你喜欢！

Source: https://github.com/moorissa/nmf_nyt

Moorissa 是一名研究生，目前在哥伦比亚大学学习机器学习，希望有一天她可以利用这些技能让世界变得更好，一次一天。

用 NLTK 和 Gensim 在 Python 中进行主题建模

原文：https://towardsdatascience.com/topic-modelling-in-python-with-nltk-and-gensim-4ef03213cd21?source=collection_archive---------0-----------------------

在这篇文章中，我们将学习如何识别文档中讨论的主题，称为主题建模。特别是，我们将讨论潜在的狄利克雷分配 (LDA):一种广泛使用的主题建模技术。我们将应用 LDA 将一组研究论文转换成一组主题。

研究论文主题建模是一种无监督的机器学习方法，它帮助我们发现论文中隐藏的语义结构，允许我们学习语料库中论文的主题表示。该模型可以应用于文档上的任何种类的标签，例如网站上帖子上的标签。

该过程

• 即使我们不确定主题是什么，我们也会提前选择主题的数量。
• 每个文档都表示为主题的分布。
• 每个主题都表示为单词的分布。

研究论文文本数据只是一堆未标记的文本，可以在这里找到。

文本清理

我们使用下面的函数来清理我们的文本并返回一个令牌列表:

import spacy
spacy.load('en')
from spacy.lang.en import English
parser = English()def tokenize(text):lda_tokens = []tokens = parser(text)for token in tokens:if token.orth_.isspace():continueelif token.like_url:lda_tokens.append('URL')elif token.orth_.startswith('@'):lda_tokens.append('SCREEN_NAME')else:lda_tokens.append(token.lower_)return lda_tokens

我们使用 NLTK 的 Wordnet 来寻找单词、同义词、反义词等的意思。另外，我们使用 WordNetLemmatizer 来获取词根。

import nltk
nltk.download('wordnet')from nltk.corpus import wordnet as wn
def get_lemma(word):lemma = wn.morphy(word)if lemma is None:return wordelse:return lemmafrom nltk.stem.wordnet import WordNetLemmatizer
def get_lemma2(word):return WordNetLemmatizer().lemmatize(word)

过滤掉停用词:

nltk.download('stopwords')
en_stop = set(nltk.corpus.stopwords.words('english'))

现在我们可以定义一个函数来为主题建模准备文本:

def prepare_text_for_lda(text):tokens = tokenize(text)tokens = [token for token in tokens if len(token) > 4]tokens = [token for token in tokens if token not in en_stop]tokens = [get_lemma(token) for token in tokens]return tokens

打开我们的数据，逐行阅读，每行，为 LDA 准备文本，然后添加到列表中。

现在我们可以看到我们的文本数据是如何转换的:

import random
text_data = []
with open('dataset.csv') as f:for line in f:tokens = prepare_text_for_lda(line)if random.random() > .99:print(tokens)text_data.append(tokens)

[' social crowd '，' social '，' network '，' base '，' framework '，' crowd '，' simulation']
['detection '，' technique '，' clock '，' recovery '，' application']
['voltage '，' syllabic '，' companding '，' domain '，' filter']
['perceptual '，' base '，' coding '，' decision']
['cognitive '，' mobile '，' virtual '，' network '，' operator '，' investment '，' pricing '，'f '，'神经元']
['平铺'，'交错'，'多级'，'离散'，'小波'，'变换']
['安全'，'交叉'，'层'，'协议'，'无线'，'传感器'，'网络']
['客观性'，'工业'，'展示']
['平衡'，'分组'，'丢弃'，'提高'，'性能'，'网络']
['身体 qos '，'自适应'，'无线电'，'不可知论者'，'传感器'，'网络']
['设计'，'可靠性'，'方法论']
['上下文'，'

带有 Gensim 的 LDA

首先，我们从数据中创建一个字典，然后转换成单词袋语料库，并保存字典和语料库以备将来使用。

from gensim import corpora
dictionary = corpora.Dictionary(text_data)corpus = [dictionary.doc2bow(text) for text in text_data]import pickle
pickle.dump(corpus, open('corpus.pkl', 'wb'))
dictionary.save('dictionary.gensim')

我们要求 LDA 在数据中找出 5 个主题:

import gensim
NUM_TOPICS = 5
ldamodel = gensim.models.ldamodel.LdaModel(corpus, num_topics = NUM_TOPICS, id2word=dictionary, passes=15)
ldamodel.save('model5.gensim')topics = ldamodel.print_topics(num_words=4)
for topic in topics:print(topic)

(0，' 0.034 "处理器"+ 0.019* "数据库"+ 0.019* "发布"+ 0.019* "概述" ')
(1，' 0.051* "计算机"+ 0.028* "设计"+ 0.028* "图形"+ 0.028* "图库" ')
(2，' 0.050* "管理"+ 0.027* "对象"+ 0.027*

主题 0 包括像“处理器”、“数据库”、“问题”和“概述”这样的词，听起来像是与数据库相关的主题。主题 1 包括像“计算机”、“设计”、“图形”和“画廊”这样的词，它肯定是一个平面设计相关的主题。主题 2 包括像“管理”、“对象”、“电路”和“高效”这样的词，听起来像是企业管理相关的主题。诸如此类。

使用 LDA，我们可以看到具有不同主题不同文档，且区别是明显的。

让我们尝试一个新文档:

new_doc = 'Practical Bayesian Optimization of Machine Learning Algorithms'
new_doc = prepare_text_for_lda(new_doc)
new_doc_bow = dictionary.doc2bow(new_doc)
print(new_doc_bow)
print(ldamodel.get_document_topics(new_doc_bow))

[(38，1)，(117，1)]
[(0，0.06669136)，(1，0.40170625)，(2，0.06670282)，(3，0.39819494)，(4，0.066704586)]

我的新文档是关于机器学习算法的，LDA 输出显示主题 1 具有最高的分配概率，主题 3 具有第二高的分配概率。我们同意了！

记住以上 5 个概率加起来是 1。

现在，我们要求 LDA 在数据中找出 3 个主题:

ldamodel = gensim.models.ldamodel.LdaModel(corpus, num_topics = 3, id2word=dictionary, passes=15)
ldamodel.save('model3.gensim')
topics = ldamodel.print_topics(num_words=4)
for topic in topics:print(topic)

(0，' 0.029 "处理器"+ 0.016* "管理"+ 0.016* "辅助"+ 0.016* "算法" ')
(1，' 0.026* "无线电"+ 0.026* "网络"+ 0.026* "认知"+ 0.026* "高效" ')
(2，' 0.029* "电路"+ 0.029* "分发"+ 0.016。

我们还可以找到 10 个主题:

ldamodel = gensim.models.ldamodel.LdaModel(corpus, num_topics = 10, id2word=dictionary, passes=15)
ldamodel.save('model10.gensim')
topics = ldamodel.print_topics(num_words=4)
for topic in topics:print(topic)

(0，' 0.055 "数据库"+ 0.055* "系统"+ 0.029* "技术"+ 0.029* "递归" ')
(1，' 0.038* "分发"+ 0.038* "图形"+ 0.038* "重新生成"+ 0.038* "精确" ')
(2，' 0.055* "管理"+ 0.029* "多版本"+ 0.029*

皮尔戴维斯

pyLDAvis 旨在帮助用户解释符合文本数据语料库的主题模型中的主题。该软件包从拟合的 LDA 主题模型中提取信息，以通知基于 web 的交互式可视化。

可视化 5 个主题:

dictionary = gensim.corpora.Dictionary.load('dictionary.gensim')
corpus = pickle.load(open('corpus.pkl', 'rb'))
lda = gensim.models.ldamodel.LdaModel.load('model5.gensim')import pyLDAvis.gensim
lda_display = pyLDAvis.gensim.prepare(lda, corpus, dictionary, sort_topics=False)
pyLDAvis.display(lda_display)

Figure 1

显著性:衡量术语告诉你多少关于主题的信息。

相关性:给定主题的单词和给定主题的单词的概率的加权平均值，由主题的概率归一化。

气泡的大小衡量了主题相对于数据的重要性。

首先，我们得到了最显著的术语，意思是术语主要告诉我们与主题相关的事情。我们也可以看个别话题。

可视化 3 个主题:

lda3 = gensim.models.ldamodel.LdaModel.load('model3.gensim')
lda_display3 = pyLDAvis.gensim.prepare(lda3, corpus, dictionary, sort_topics=False)
pyLDAvis.display(lda_display3)

Figure 2

可视化 10 个主题:

lda10 = gensim.models.ldamodel.LdaModel.load('model10.gensim')
lda_display10 = pyLDAvis.gensim.prepare(lda10, corpus, dictionary, sort_topics=False)
pyLDAvis.display(lda_display10)

Figure 3

当我们有 5 或 10 个主题时，我们可以看到某些主题聚集在一起，这表明主题之间的相似性。这是一个多么好的方法来形象化我们到目前为止所做的事情！

试试看，找个文本数据集，有标签就去掉标签，自己建个主题模型！

源代码可以在 Github 上找到。我期待听到任何反馈或问题。

PLSA 的主题建模

原文：https://towardsdatascience.com/topic-modelling-with-plsa-728b92043f41?source=collection_archive---------3-----------------------

假设你有数百篇文章/句子。你想知道每篇文章/句子谈论什么话题。一篇描述对一家制药公司的指控的文章可能会谈论像政府、医药或商业这样的话题。我们的目标是将这些主题分配给文档。

执行这项任务的方法之一是概率潜在语义分析(PLSA)。

PLSA 或概率潜在语义分析是一种用于在概率框架下对信息建模的技术。潜在因为话题被当作潜在的或隐藏的变量。

型号:

可以用两种不同的方式来理解 PLSA。

1. 潜在变量模型
2. 矩阵分解

第一个帮助你很好地理解 PLSA 的数学。而第二种方法很容易用 Python 实现。

让我们正式定义出现在 PLSA 的变量。

我们有三组变量

1. 文件数: D={d1，d2，d3，…dN} ， N 为文件数。 di 表示 D 中带有文件的。注意——此处的文档也可以指句子。这两个词可以互换使用。**
2. 单词: W={w1，w2，…wM} ，M 是我们词汇量的大小。 wi 表示词汇表中的第 I 个单词 W.
   注:集合 W 被视为单词包。意思是索引 I 的赋值没有特定的顺序
3. 题目: Z={z1，z2，…zk} — 潜变量或隐变量。数字 k 是我们指定的参数。

指定了命名约定之后，让我们来看看第一种方法。

潜在变量模型:

如前所述，主题是隐藏变量。我们唯一看到的是文字和一套文件。在这个框架中，我们将隐藏变量与观察变量联系起来。

我们将 z 与( d，w) 联系起来的方式是，我们描述一个生成过程，我们选择一个文档，然后是一个主题，然后是一个单词。形式上，

1. 我们选择一个概率为 P(d) 的文档
2. 对于本文档中的每一个单词 dn，wi——从概率为 P(z|dn)的条件分布中选择一个话题 zi 。
   - 选择一个有概率的单词 P(w|zi)

如果不是完全清楚，也不用担心。我在数学上把一切都放在前面了。在进入方程之前，让我们讨论一下模型的两个假设。

假设 1——单词包:正如我们之前讨论的，单词在词汇表中的排序并不重要。更准确地说，联合变量(d，w)是独立采样的。

假设—条件独立:我们做的一个关键假设是单词和文档是条件独立的。有条件地聚焦这个词。这意味着—

P(w，d | z)= P(w | z) P(d | z)——*(3)

上述讨论下的模型可指定如下—

现在，

利用条件独立性，

使用贝叶斯规则，

模型中的参数是—

1. P(w | z)——有(M-1)*K 个。怎么会？对于每一个 z 我们都有 M 个单词。但是因为这 M 个概率的和应该是 1，我们失去了一个自由度。
2. P(z | d)——有(K-1)*N 个参数来确定。

使用期望最大化或似然函数的 EM 算法来确定上述参数。

可能性函数—

Likelihood function

对数可能性—

Log Likelihood

我们不会深入 EM 算法是如何工作的。这次讨论的主要目的是让你熟悉主题如何与观察到的变量、单词和文档相关联。如果你想了解它的数学，你可以在这里找到相关的论文。

矩阵分解模型

另一种表示 PLSA 的方法是矩阵分解模型。

考虑一个维度为 NM* 的文档-单词矩阵，其中 N 是文档的数量， M 是词汇表的大小。矩阵的元素是一个单词在文档中出现的次数。如果单词 wi 在文档 dj 中出现一次，那么元素 (j，i) = 1。

如果你想到这个矩阵，大部分元素都是 0。假设我们有一个 10 个单词的文档和 1000 个单词的词汇表。自然地，该行的 990 个元素将具有值 0。这样的矩阵称为稀疏矩阵。

矩阵分解的作用是将这个矩阵(姑且称之为 A )分解成低维矩阵(奇异值分解)

Pictorial representation of the above equation

L、U 和 R 的尺寸分别为 NK、KK 和 KM* 。

矩阵 U 是对角矩阵，取值为 AA* 的特征值的平方根，其中表示转置。对于任意给定的 k，你选择 L 的第 k 行，的第 k 元素， U 的第 k 列， R. 的第k列，记住， k 是我们设置的题目数。*

这个模型与潜变量模型没有太大的不同。这三个矩阵可以解释为—

1. L 包含文档概率 P(d|z)
2. U 是主题 P(z) 的先验概率的对角矩阵
3. R 对应单词概率 P(w|z)

所以如果你把三个矩阵相乘，你实际上做的是下面的等式——

请注意，这三个矩阵的元素不能为负，因为它们代表概率。因此，使用非负矩阵分解来分解 A 矩阵。

如果你想在 Python 中应用这个算法，你可以在这里找到一个例子。

感谢阅读！如果你喜欢这个博客，你可能想看看我的另一篇关于单词嵌入和 Word2Vec 的文章。

欢迎分享你的观点。很乐意在 LinkedIn 上与您联系

Tensorflow 中的地形/正则化特征学习[TF 中的手动反向投影]

原文：https://towardsdatascience.com/topographic-regularized-feature-learning-in-tensorflow-manual-backprop-in-tf-f50507e69472?source=collection_archive---------12-----------------------

Photo by Nick Dunlap on Unsplash

今天我想比较不同的正则化方法得到的不同结果，看看每种方法是如何影响梯度的。

情况 a) 0 范数自动编码器(p = 0)无正则化
情况 b) 0.5 范数自动编码器(p = 0.5 )
情况 c) 1 范数自动编码器(p = 1 )
情况 d)软化 1 范数自动编码器(p = 1.5 )
情况 e) 2 范数自动编码器(p = 2)
情况 f)软化 2 范数自动编码器(p = 2.5 )
情况 g) 3 个范数自动编码器(p = 3 )
情况 h) 4 个范数自动编码器(p = 4 )
情况 I)稀疏拓扑自动编码器(KL 发散方法)

请注意，这篇帖子是为了我未来的自己回顾这些话题以及纯粹的好奇。

审查向量规范

Video from this [website](http://Ritvik Kharkar)

如果任何人需要一个向量范数的基本审查，请观看上面的视频。

P 范数正则化/软化正则化

Image from this website website

L1 和 L2 正则化通常用于防止过拟合，但是从 P 范数正则化的定义中，我们实际上可以选择许多不同的 P 值正则化，今天让我们看看每个正则化项给出什么不同的结果。最后我会链接真正帮助我的视频。

Video from Alexander Ihler

现在当我看到 L2 范数的定义时，我感到困惑，根据 P 范数的方程,“适当的”L2 范数是由…

Image from this website

然而，当我们看到许多不同的机器学习教程时，我们会看到 l2 规范，如下所示。

Image from this website

这两项明显不同，也要注意导数也不同。此外，这种情况也发生在 L1 诺姆身上，我们不时会遇到 L1 诺姆'软化'版本。

Image from this website

上面的图片来自吴恩达的无监督学习课程。我们之所以用那个方程，是因为当|x|为零时，没有导数。然而，我们也可以简单地忽略这个事实，使用原始的绝对正则化，让导数只是权重的符号。(如下图。)

Image from this website and this website

不同 P 范数正则化函数的导数

在实现之前，让我们练习一下数学，手动计算不同 p 值的导数。

KL 散度的导数

image from this website

并且因为我们必须通过最小化 KL 散度来实现稀疏编码，所以让我们也导出关于 KL 散度损失函数的导数。如上所述，我们的数学检查。

地形稀疏编码

Image from this website

最后，我们有拓扑稀疏编码，我们的目标是学习具有一些有序方式的特征。(当输入类似的特征时，我们大脑中相互靠近的神经元就会激活。)

Image from this website

如上所述，当我们将拓扑结构的概念应用到我们的网络中时，我们可以看到，在学习过的过滤器中，彼此接近的过滤器倾向于激活相似的特征。如果有人需要衍生品方面的帮助，请点击此处。

情况 a) 0 范数自动编码器(p = 0)无正则化

左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度

在编码部分没有任何约束的情况下，我们可以清楚地看到，学习到的权重没有任何特定的顺序。好的一面是重建的图像非常清晰，然而，这是由于过度拟合。并且当我们观察梯度如何相对于输入变化时，我们可以看到大部分梯度变成灰色图像，不管图像中的数字是什么。下图显示了最终的结果。

情况 b) 0.5 范数自动编码器(p = 0.5 )

左上 →编码层权重的收敛过程
右上 →重建图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度

当我们添加 0.5 范数正则化时，我们可以立即注意到差异，在左上角的图像中，黑色方块立即出现。这表明学习到的权重为零，并且学习到的权重中存在大量漏洞。这是意料之中的，因为 p 值为 0.5 会促进稀疏性。此外，我们现在注意到，相对于输入的梯度开始显示类似边缘的数字符号。

案例 c) 1 范数自动编码器(p = 1 )

左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度

当 P 值设置为 1(也称为曼哈顿范数)时，当 P 值设置为 0.5 时，网络会生成类似的结果。这也是预料中的，然而如下所示，当与该值被设置为 0.5 的情况相比时，在最终时期学习的权重更亮。(向上滚动自己对比！)

案例 d)软化 1 定额自动编码器(p = 1.5 )

左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度

现在事情变得有趣了，吴恩达使用了这个不包含绝对函数的 L1 范数的软化版本。当我们观察学习到的权重时，我们可以直接看到结果的差异，现在我们可以观察到学习到的权重中间的数字。

情况 e) 2 个标准自动编码器(p = 2)

左上 →编码层权重的收敛过程
右上 →重建图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度

当我们使用标准的 L2 范数(不是软化版本)时，我们可以看到学习到的权重看起来与我们使用 1 范数的软化版本时的情况非常相似。然而，一个区别是梯度，当我们仔细观察输入的梯度时，我们可以观察到边缘变得更加清晰。

情况 f)软化 2 个标准自动编码器(p = 2.5 )

左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度

然而，当我们使用 L2 常模的软化版本时，我们得到(在我看来)更好的结果。其中所学习的重量代表每个手指的不同手笔画。不仅梯度更清晰，我们还可以观察到不同梯度之间更鲜明的对比。(相对于编码层的梯度)(当我们考虑它时，绝对函数在零处的导数是未定义的，并且我们已经软化了它，所以导数不是+就是-。然而，这似乎无助于学习更好的表达。此外，我们将权重初始化为具有零均值的高斯分布，这表明相对于原始权重的大部分导数必须被软化，并且这可以转化为噪声。)

例 g) 3 定额自动编码器(p = 3 )

左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度

当我们接近更高的 p 值时，我们仍然使权重变小，但是我们放弃了稀疏性。并且每个权重之间的关系变得更加相互独立。上面看到的结果与我们使用 p 值 2 时非常相似，在我看来没有太大的不同。

情况 h) 4 个范数自动编码器(p = 4 )

左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度

当我们将 p 值设置为 4(我们的最高值)时，我们可以立即注意到，与其他情况相比，学习到的权重看起来更加不同。学习的过滤器实际上类似于一个数字，但是具有相反的对比度。

情况 I)稀疏地形自动编码器(KL 发散方法)

左上 →编码层权重的收敛过程
右上 →重建图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度

最后，当我们通过分组矩阵将编码权重分组在一起时，我们可以看到一个结构正在形成。不仅仅是学习到的权重，还有梯度。当我们观察渐变时，现在它不像一个椒盐噪声类型的图像，而是看起来有某种一般的结构。

从学习到的权重(见底部)我们可以看到，每个细胞响应某种类型的数字，如 0 或 1。例如，在左/右角的图像似乎喜欢边缘，而中心更喜欢圆形的图像。

交互代码

对于 Google Colab，你需要一个 Google 帐户来查看代码，而且你不能在 Google Colab 中运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

要获取这篇文章的代码，请点击这里。

最后的话

如果有人想知道 L1 的一些优点和其他信息，请参见下面的，这很有趣，因为我们可以组合许多不同的正则化项来优化给定的函数，这本身就是一个优化问题。

Image from this website

此外，这篇博客的文章也是一篇很好的阅读材料,可以用来概括正则化术语。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你希望看到我所有写作的列表，请在这里查看我的网站。

同时，在我的推特这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。我也实现了广残网，请点击这里查看博文 pos t。

参考

1. NumPy . fill _ diagonal—NumPy 1.15 版手册。(2018).Docs.scipy.org。检索于 2018 年 9 月 17 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . fill _ diagonal . html
2. 稀疏编码:自动编码器解释。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 17 日，来自http://uf LDL . Stanford . edu/wiki/index . PHP/Sparse _ Coding:_ auto encoder _ Interpretation
3. 利用反向传播思想推导梯度。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 17 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/derivating _ gradients _ using _ the _ back propagation _ idea
4. Deep Learning 12_ 深度学习 UFLDL 教程：Sparse Coding_exercise（斯坦福大学深度学习教程） — 夜空中最帅的星 — 博客园. (2018). Cnblogs.com. Retrieved 17 September 2018, from http://www.cnblogs.com/dmzhuo/p/4994947.html
5. 练习:稀疏编码— Ufldl。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 17 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/Exercise:Sparse _ Coding
6. Wolfram|Alpha:让世界知识可计算。(2018).Wolframalpha.com。检索于 2018 年 9 月 19 日，来自http://www.wolframalpha.com/input/?I = y * log(y % 2Fx)+% 2B+(1-y)+*+log(+(1-y)% 2F(1-x))
7. 对数的导数—log(x)’。(2018).Rapidtables.com。检索于 2018 年 9 月 19 日，来自https://www . rapid tables . com/math/algebra/logarity/logarity _ derivative . html
8. 稀疏编码:自动编码器解释。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 19 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/Sparse _ Coding:_ auto encoder _ Interpretation
9. 稀疏编码:自动编码器解释。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 19 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/Sparse _ Coding:_ auto encoder _ Interpretation
10. 练习:稀疏编码— Ufldl。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 19 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/Exercise:Sparse _ Coding
11. 利用反向传播思想推导梯度。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 19 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/derivating _ gradients _ using _ the _ back propagation _ idea
12. 基于稀疏性的正则化。(2018).YouTube。检索于 2018 年 9 月 19 日，来自https://www.youtube.com/watch?v=jEVh0uheCPk&t = 123s
13. 线性回归(6):正则化。(2018).YouTube。检索于 2018 年 9 月 19 日，来自https://www.youtube.com/watch?v=sO4ZirJh9ds&t = 334s
14. 科学计算矩阵范数、收敛和矩阵条件数。— ppt 下载。(2018).Slideplayer.com。检索于 2018 年 9 月 19 日，来自https://slideplayer.com/slide/6006587/
15. 定义，F. (2018)。用极限定义求|x|的导数。数学栈交换。检索于 2018 年 9 月 19 日，来自https://math . stack exchange . com/questions/83861/finding-the-derivative-of-x-using-the-limit-definition
16. Anon，(2018)。[在线]可从以下网址获取:https://www . quora . com/What-is-the-derivative-of-the-absolute-value-of-x【2018 年 9 月 19 日获取】。
17. Anon，(2018)。[在线]可从以下网址获得:https://www . quora . com/What-is-the-advantage-of-the-L2-L1-L1-L2-诺姆-诺姆-特征标准化【2018 年 9 月 19 日获取】。
18. 模特，W. (2018)。为什么稀疏模型的 L1 范数？交叉验证。检索于 2018 年 9 月 19 日，来自https://stats . stack exchange . com/questions/45643/why-L1-norm-for-sparse-models
19. L1 和 L2 作为损失函数和正则化的区别。(2018).chioka . in . 2018 年 9 月 19 日检索，来自http://www . chioka . in/differences-between-L1-and-L2-as-loss-function-and-regulation/
20. 向量范数。(2018).YouTube。检索于 2018 年 9 月 19 日，来自https://www.youtube.com/watch?annotation _ id = annotation _ 1494666085&feature = iv&src _ vid = 5 ASL 5 eq 2 x0a&v = 5 fn 2j 8 wyn fw

总体最小二乘法与 OLS 和 ODR 的比较

原文：https://towardsdatascience.com/total-least-squares-in-comparison-with-ols-and-odr-f050ffc1a86a?source=collection_archive---------4-----------------------

线性回归分析的整体概述

目录:

1. OLS:快速回顾
2. TLS:解释
3. ODR:触及表面
4. 三种方法的比较及结果分析

总体最小二乘法(又名 TLS)是一种回归分析方法，旨在最小化响应变量(或观察值)和预测值(我们常说的拟合值)之间的误差平方和。最流行和标准的方法是普通最小二乘法(又名 OLS)，TLS 是采用不同方法的其他方法之一。为了获得实际的理解，我们将通过这两种方法以及正交距离回归(又名 ODR)来了解一下，这是一种旨在最小化正交距离的回归模型。

OLS:快速回顾

为了复习我们的知识，首先让我们回顾一下回归分析和 OLS。一般来说，我们使用回归分析来预测(或模拟)未来事件。更准确地说，如果我们有一堆过去收集的数据(这是一个自变量)和相应的结果(这是一个因变量)，我们就可以用我们刚刚收集的新数据来制造预测未来结果的机器。

为了制造更好的机器，我们应用回归分析并试图获得更好的参数，这是我们模型的斜率和常数。例如，让我们看看下图。我们求红色回归线的参数(而蓝色点是数据点(响应变量和自变量)，灰色线的长度是这个估计量计算出来的残差的量)。

A visual comparison between OLS and TLS

在 OSL，灰色线不是正交的。这是 OSL 和 TLS(以及 ODR)的主要区别。在 OSL，灰线平行于 y 轴，而在 TLS 中，灰线垂直于回归线。OLS 的目标函数(或损失函数)定义为:

这通过二次最小化来解决。我们可以从中获得参数向量(这就是我们所需要的)。

Numpy 为此提供了 numpy.linalg.lstsq，不过从头开始实现这个 正规方程 很容易。我们在下面的代码中得到 b 中的参数向量，并用它来预测拟合值。numpy.linalg.lstsq 期望常量 c 存在于最后一个索引处，所以我们需要切换列值的位置。

TLS:解释

让我们回到 TLS，考虑一下 TLS 优于 OLS 的原因。OLS 期望所有的样本数据都被精确地测量，或者没有误差地观察。然而，在实际情况下，或多或少会有观测误差。如果假设是合理的，OLS 可能是一个不一致的估计量，而不是理论假设的理想机器。TLS 可以考虑这个问题，它允许自变量和因变量都存在误差。我们希望最小化自变量的误差 E 和因变量的误差 F 。这些误差被认为包含观测误差和残差。

用 SVD 求解 X 和 Y 的协方差矩阵后，我们得到了下面的等式。是 的左奇异向量【xᵀy】【σ】是对角线上有奇异值的对角矩阵。

同样参数向量 B 定义为:

在下面的代码中(TLS 正规方程的实现)，我们计算了【E F】并添加了对 Xtyt 的返回。(Xtyt 只是 x 波浪号和 y 波浪号的意思。一个波浪号往往暗示一个近似值)垂直堆叠的向量【vxy vyy】是【xᵀy】v的右奇异向量的整个最后一列。用于计算参数向量【B】的 Vxy 和 Vyy 与此不同。 Vxy 和 Vyy 都是被截断的数量的×变量* 。*

第【n】列为错误n到最后一列为错误 F 。我们还可以通过Y =【X，E】B计算出估算的 Y 值，写在下面第 15 行。关于 Matlab 中更多数学过程和代码的参考，可以查看 这个 详细 pdf。**

(警告:对于非 Matlab、R、Julia 或 Fortran 用户，数组的索引从 1 开始)

ODR:触及表面

有一种回归模型旨在最小化正交距离。谢天谢地，Scipy 提供了 scipy.odr 包。我们可以在数据** 功能中设置误差值【wd】。这是一个权重矩阵，用于处理残差的不等方差(异方差)。如果我们事先知道误差有多大/多小，这种调整可以提高估计量。然而，在现实世界中，很难确定或估计这一点。这种加权也是提高加权最小二乘和广义最小二乘应用的有效方法之一。******

我们在【wd】中设置1×N的误差值数组，也就是说的误差值被应用到的数据点上。****

ODR 比其他国家更适合这个数据集。

三种方法的比较

让我们比较这三种方法，直观地看看它们的适用性。左图中灰色的上方三角形是自变量和因变量都包含错误的数据。右图显示了每个模型产生的每个数据点的误差。纵轴表示误差有多大。ODR 和 TLS 在二次曲线的中心拟合得非常好，然而，随着它们远离中心，它们的预测失去了精度。为了解释这一点，当拟合值的方差很小时，ODR 和 TLS 工作得很好。特别是当拟合值的方差如此大时，TLS 将不再正确工作，尽管当方差小时，在没有任何加权值的情况下预测拟合值是非常精确的。在这种情况下，我们需要应用迭代方法，例如梯度下降。

以确保每个模型的均方误差(又名 MSE)和拟合优度(或 R2 分数)。总的来说，ODR 更适合这个数据样本，但这取决于数据。我们需要逐一考虑这些模型，直到找到最佳模型。

参考资料:

总体最小二乘 PDF CEE 629 杜克大学

总体最小二乘维基

正交距离回归初级读本

我们浏览的样本数据:

哪些欧洲国家游客泛滥？(以及其他数据支持的欧洲旅游趋势)

原文：https://towardsdatascience.com/tourism-trends-in-europe-which-european-countries-are-overrun-with-tourists-f60c860bd23a?source=collection_archive---------5-----------------------

去年，当我第一次计划去意大利、西班牙和匈牙利等几个国家的欧洲度假时，我把研究重点放在寻找所有“必看”的旅游景点上。然而，当我回忆起那些旅行时，这些品牌景点没有一个在我的记忆列表中名列前茅。尽管明信片上的地方令人敬畏，但周围的环境几乎就像一个游乐园，街道两旁是游客陷阱餐厅，多语言菜单，街头企业家向像我这样的人出售各种仿制品。你在附近找不到当地人是有原因的。

事实证明，我度过的一些最美好的时光是在巴塞罗那传统的 Gràcia Barrio、奥斯陆肮脏但富有艺术气息的 grünerl kka 区以及罗马以美食为主的 Trastevere 街区漫步度过的。虽然所有这三个提到的地区都位于主要目的地的一英里范围内(因此仍然拥有游客的存在)，但这些景点提供了当地人如何生活的一瞥(更重要的是，ate)。

经过最近的两次旅行，我意识到下次我去欧洲时，我想去那些我能真正观察到文化的地方，一个没有受到游客太多影响的地方。

欧洲国家旅游(按 2015 年游客总数排序)

利用现有的最新乡村居民人口和旅游业数据，我决定专注于三个主要指标来回答我的问题*:

-2015 年游客总数(千人)

-五年期间游客抵达的百分比变化

-2015 年期间游客人数除以该国居民的比率

*在编写这些报告时，瑞典或斯洛伐克没有完整的数据，因此这两个国家都没有包括在本报告中。

当然，当你按年度游客数量对这些国家进行排名时，排名第一并不令人惊讶。法国在 2015 年以 8450 万游客领先，其次是西班牙(6850 万)和意大利(5070 万)。但是当你观察 2010 年到 2015 年游客的变化时，你会发现这些顶级旅游国家的旅游增长率有很大的不同。

从 2010 年到 2015 年，法国的旅游人数仅增长了 8.8%，是整体旅游人数排名前 10 位的国家中最低的。另一方面，希腊以令人印象深刻的 57.3%的旅游业增长率位列前十。

这里还需要注意的是，不仅像法国这样的主要旅游强国每年都有大量的游客，而且游客人数已经超过了当地居民。在法国，2015 年的 8450 万游客超过当地人口 26.4%。在西班牙，情况更糟，游客数量比当地人多 41.1%(然而西班牙的旅游业增长率是法国的三倍多)。然而，没有一个国家胜过奥地利，它的游客与居民的比率是令人难以置信的 306.8%。

欧洲国家的旅游业(按 2010 年至 2015 年游客到达的变化百分比排序)

说到时尚国家，世界上没有什么比冰岛更受欢迎的了。如果法国是星巴克，那么冰岛就是菲尔茨咖啡(有意冒犯，法国)。五年来，冰岛的游客数量增长了 163.6%。130 万国际游客超过当地冰岛人口 284%。

上面的地图描绘了每个国家，根据国际游客与实际居民的比例进行着色。

暗绿色表示游客比例较低的国家，而暗红色表示游客与居民比例较高的国家。较浅的阴影表示居民和游客的比例几乎相等。

去年我去过五个欧洲国家(意大利、瑞士、匈牙利、西班牙和挪威)，我不可能猜到意大利的游客与当地人的比例最低(81.8%)，我的意思是在 10 月下旬那里挤满了游客。说实话，我会赌匈牙利(145%)，但最近的想法，我意识到，虽然我注意到在布达佩斯完全没有美国游客，但毫无疑问，我记得有很多东欧游客。

在主要国家中，令我惊讶的是，尽管德国南部与卢森堡(187%)、法国(126%)、瑞士(114%)、奥地利(307%)和捷克共和国(109%)接壤，但它的游客/居民比率为 43%。

纵观所有人口超过 500 万的欧洲国家，几乎每个国家的游客数量都在大幅增长。当分析五年间游客数量的变化时(将这些国家按 20%的区间分组)，大多数国家的增长幅度在 20-40%之间，紧随其后的是增长相对较低的国家(旅游业增长< 20%)。

最后，结合这两个因素，这是一个象限图，只显示人口超过 500 万的国家。x 轴是游客与居民的比率，y 轴是 5 年来游客抵达的变化，圆圈的大小表示各个国家居民人口的规模。

游客与居民比率低&旅游业增长低

这些地区处于最佳状态，增长速度并不快。

虽然俄罗斯、乌克兰和芬兰等国家因其地理位置或各种其他旅行限制而在一定程度上有意义，但我对英国出现在这份名单中感到意外。

高游客与居民比率&旅游业高增长

这些地区的游客已经饱和，而且这种趋势也没有减缓。远在右上角的是希腊。追赶希腊的是匈牙利、西班牙、捷克、荷兰。

尽管我对冒险进入匈牙利等(相对而言)较少人去的领域感到自豪，但它确实属于这一类，这意味着我不是我想象中的那么时髦的旅行者。

低游客与居民比率&旅游业高增长

这些国家仍然很少被国际游客光顾，但这些美景的时间正在流逝。网格的最左边是罗马尼亚，游客/居民比率只有 10%，但它也越来越受欢迎。毫无疑问，更实惠的价格和旅游兴趣的扩大促成了东欧国家在短短五年内超过 65%的繁荣。这一部分还包括德国、土耳其和波兰。

高游客/居民比率&旅游业低增长

虽然这些国家可能已经到了无法回头的地步，但令人欣慰的是，它们的增长速度并不快。像法国和意大利这样的旅游大腕在这个名单上占据了重要位置，但是像挪威、瑞士和奥地利这样的小国也榜上有名。

感谢您阅读我最新的数据帖子。作为一名产品营销和数据分析专业人士，我对数据支持的讲故事充满热情。这些数据新闻帖子是我将真实数据与我个人的不同兴趣整合起来的方式，这些兴趣包括从旅行和娱乐到经济和社会问题的任何事情。如果您有任何评论、故事想法或预期的数据项目，请随时发送电子邮件至我的 dwpwriting <邮箱至> gmail < dot > com 或通过LinkedIn联系我。

使用 AWS CodeStar，在 10 分钟内将您的 ML 模型转变为 web 服务

原文：https://towardsdatascience.com/tourn-your-ml-model-into-a-web-service-in-under-10-minutes-with-aws-codestar-d9e0f4ae24a6?source=collection_archive---------13-----------------------

部署您的模型变得更加容易

Photo by Ryan Hutton on Unsplash

作为一名数据科学家，开发一个能够做出正确预测的模型本身就让人觉得非常值得。然而，您机器上的 hdf5 文件通常对您的公司或任何与您刚解决的问题有相同问题的人来说并没有真正的帮助。因此，下一步通常是为您的模型创建一个 web 服务，您可以通过 API 访问它。一种选择是编写一个 Flask 应用程序，您可以将其托管在您的服务器上。不幸的是，这种方法通常很复杂，而且扩展性不好。虽然有很多工具可以帮助设置和管理虚拟服务器，但是每个试图设置 EC2 实例的人都知道随之而来的麻烦。坚持使用 AWS，下一个选择是在 Lambda 上运行您的模型，通过 API Gateway 等公开它。由于至少需要管理四个不同的服务+代码，这种方法可能更简单，但仍然非常复杂。幸运的是，亚马逊认识到了这个问题，并在 2017 年推出了解决方案: AWS CodeStar 。

CodeStar 通过以直观易用的方式连接多个 AWS 服务，简化了应用程序的创建和部署流程。作为一个例子，我们将部署我的实现Rob RenaldsGibberish Detector，这是一个基于马尔可夫链的工具，用于检测一个字符串是包含真正的单词还是只是随机的“乱码”。我在德语文本上训练模型，并将其存储为 Python Pickle 文件。

到本文结束时，我们将拥有一个工作的 web 服务，它通过 GET 请求接收一个变量，通过 Python 代码运行模型，并将结果预测作为 JSON 返回。

步骤 1:创建您的 CodeStar 项目

Over 30 templates make it easy to set up your web service or app

因为我们的目标是建立一个 web 服务，所以我们可以选择第一个 Python 模板。因此，我们的服务将在 Lambda 上“无服务器”运行。以下三个步骤相对来说不言自明:

1. 我们决定一个项目名称，AWS 也将把它转换成一个 URL 友好的项目 id。稍后，这个项目 id 将成为 HTTP 端点的一部分。
2. 接下来，我们必须选择我们首选的 Git 存储库。如果您决定使用 GitHub，您可以选择更改存储库名称、描述，并将其设置为 public 或 private。CodeStar 将为您创建一个存储库，其中包含所有必需的文件，稍后会有更多相关内容。
3. 为了发挥它的魔力，CodeStar 需要获得许可来代表你管理我们管道中所有不同的工具。

Our AWS CodePipeline

步骤 2:连接到您的源存储库

CodeStar 的一个伟大之处在于，代码都是通过 Git 管理的，每次更新都会更新 Lambda 函数并自动部署。因为 AWS 会自动为您创建存储库，所以开始编码所需要做的就是一个git clone your_repository_url。

AWS CodeStar creates all the necessary files for you

步骤 3:在 AWS APIGateway 中创建 GET 参数

要更改 API 参数，我们需要在 AWS APIGateway 中打开我们的项目。最快的方法是在我们的仪表板的边栏上:项目->项目资源-> AWS APIGateway。

AWS APIGateway before our changes

第一步是添加一个方法请求。在本练习中，我们添加一个字符串参数，称为字符串。因为我们需要这个输入来运行我们的模型，所以我们可以将这个参数设为必需的。APIGateway 要求我们检查一个合适的请求验证器。因为我们只使用 URL 参数，所以验证器验证查询字符串参数和头就可以了。以下是结果页面的外观:

AWS APIGateway configuration for one URL parameter

步骤 4:编写 Lambda 函数

CodeStar 从您的 Git 存储库构建。因此，一旦完成，您就可以在您最喜欢的 IDE 和push中编写代码。默认情况下，创建的存储库包含以下项目:

• index.py:这个文件包含 Lambda 函数的代码。
• readme . MD:readme 文件包含有关后续步骤的基本信息以及到官方文档的链接。
• template.yml:你的“无服务器”AWS 架构的结构。
• 这个文件包含在构建过程中执行的附加命令。标准的命令预构建是单元测试的执行。
• tests/:包含带有上述单元测试的文件 test_handler.py 。

首先，我们必须使我们的模型文件可以被函数访问。最简单的方法是将文件添加到我们的 Git 存储库中。AWS Lambda 有相对宽松的存储限制，对于大多数用例来说应该足够了。一旦上传，Lambda 可以使用open以通常的方式访问文件。

最后，我们可以将我们的 Python 代码写入 index.py，它将成为我们的 Lambda 函数。根据我们在步骤 3 和 4 中的设置，我们可以通过event参数轻松访问 URL get-parameter:

req_name = event['queryStringParameters']['string']

你可以在 Github 上找到完整代码。在实现了主函数之后，我们必须更新单元测试。请记住，如果单元测试失败，服务将不会被部署。因此，我们会相应地更新所有内容:

我们现在要做的就是使用常用的命令:git add .、git commit和git push将模型文件和代码推送到项目存储库。一旦更改上线，CodeStar 将自动更新其代码基础，并构建和部署一切。您可以在仪表板的右侧找到状态。

How it should look like

最后的话

如果你跟着做了——恭喜你，你刚刚在不到 10 分钟的时间里公开了你的机器学习模型！您可以在仪表板上找到 API 的端点，添加参数，瞧。由于 AWS CodePipline 的集成，很容易保持您的模型更新，与 Amazon CloudWatch 的连接让您可以深入了解一旦您的功能在野外会发生什么。
通过 Lambda 公开你的机器学习模型只是你可以用 CodeStar 做的许多伟大事情之一。下一次，当你在设置任何涉及 5+服务的 AWS 工作流程时迷失了方向，看一看，也许 CodeStar 也能帮助你减少生产时间。

走向一个更好的无足轻重的小费模式:一个基本的启发式分析

原文：https://towardsdatascience.com/toward-a-better-footy-tipping-model-an-analysis-of-basic-heuristics-80de4235e768?source=collection_archive---------5-----------------------

这是我尝试开发一个关于无足轻重的小费的数据模型的系列文章的第一部分。你可以在这里阅读前奏和第二部* 在这里 。这篇文章使用的数据和代码在Footy Tipper*GitHub repo 中(在实验文件夹中)。所有数据来自 2010 年至 2017 年的 AFL 比赛。

Photo by Charles Van den Broek on Flickr

足球小费是澳大利亚人每周挑选澳大利亚规则足球(AFL)球队赢得比赛的流行消遣(就像填写三月疯狂括号，只不过每次都是一轮，当球队得分时，裁判会把手指变成手枪)。每个给小费的人都可以因正确选择赢家而得到一分，如果是平局，也可以得到一分。在赛季结束时，获胜者是得分最多的一方，预测每轮第一场比赛的差距作为决胜局。

有各种各样的试探法可以用来挑选本周的赢家和输家。在我与小费者和足球爱好者的交谈中，我发现普通参与者倾向于接受数据，例如哪个队更受青睐，哪个队是主队，每个队最近的表现如何，以及他们预计其他竞争对手会给谁小费，然后凭直觉处理这些信息，以这种方式得出他们对本轮的预测。

下面，我将介绍一些预测比赛结果的基本试探法，比较它们各自的准确性，然后对 AFL 比赛结果的赔率中包含的偏差进行更深入的分析。

基本启发式算法的准确性比较

下面是一个简单而合理的给 AFL 比赛小费规则的简要调查。这当然不是一个全面的列表，但对于一个并不真正关注球队目前比赛情况的人来说，每个启发都代表了一种在使用单个容易找到的数据点时实现高于 50%的准确率的方法。

启发 1:永远给主队小费

尽管很少有人会选择主队赢得每场比赛，但一个普遍公认的事实是，主场比赛比客场比赛更好，以至于季后赛系列赛都是围绕这一前提的接受而构建的，在线小费比赛通过默认客队来惩罚不付小费的人。

总是给主队小费时的准确率:57.29%

启发 2:总是给排名较高的团队小费

这虽然简单，但可能更接近于一个普通球迷可能给出的提示:参数是快速的两个词谷歌搜索(你甚至不必去另一个网站)，并且人们总是选择从赛季开始到当前一轮的历史上更成功的球队。当然，令人沮丧的事情确实会发生，1 号和 15 号之间的差别比 7 号和 8 号之间的差别要大得多。

总是给排名较高的团队小费时的准确率:68.00%

启发 3:总是提示胜算最大的人

从最终用户的角度来看，这是一种启发式方法，几乎与提示排名更高的团队一样简单，但它的行为几乎像一个复杂的黑盒集合模型:据我们所知，局外人可以获得与 oddsmakers 相同的数据，我们知道他们正在优化收入，但我们不知道什么过程——什么秘方——产生了人们押注的线赔率和点差。也许一群戴着软呢帽、穿着廉价西装、棱角分明的老人抽着雪茄，争论着悉尼究竟会以多少分击败圣基尔达；也许是一个分布式深度学习模型，日夜在 GPU 上运行，每 5 分钟计算一次赔率到 100 个有效数字；也许一个预言家会观察天空，看鸟儿在某一天是如何飞行的。在任何情况下，博彩赔率肯定代表了比前面描述的任何试探法多得多的数据的集合。

总是预测胜算最大的概率时的准确率:72.32%

试探法概述

如上面的平均准确率所示，启发式算法的可靠性随着其来源所考虑的数据输入数量的增加而增加。

• 计算主队只需要一个数据:哪个队在主场。
• 计算排名更高的球队需要更多的东西:两支球队在本赛季的累计胜场、平局、得分和对手的得分。
• 最后，在计算每场比赛的赔率时，可能会考虑上述所有因素，加上每支球队最近的胜率、他们的比赛统计数据、他们球员的个人统计数据、是否有球员受伤、每场比赛的正面交锋历史等等。

由于超过 4%的几率是最准确的启发式方法，我将使用它作为基准，来衡量我稍后将开发的机器学习模型的性能。因此，我将把进一步分析的重点放在检查投注赔率中的偏差上，目标是使用这些信息来帮助我的模型确定何时反驳赔率，希望最终实现更高的准确性。

博彩赔率分析

既然我们知道仅基于投注赔率的小费提供了最高的准确性，让我们探索在什么条件下投注赔率更准确或更不准确。赔率是由博彩公司设置的反馈回路决定的，博彩者基于感知的低效率而冒险(“卡尔顿不可能输给墨尔本超过 50 分！”)，然后这些公司根据总体博彩行为调整赔率，以实现收入最大化。这意味着博彩赔率代表了足球迷对每支球队获胜概率的传统看法，因为赔率制造者和赌博公众之间的任何差异都会很快得到解决。所以，问题是是否有偏见倾向于形成对球队获胜概率的总体看法。在什么情况下更有可能出现心烦意乱？如果我们能够理解博彩赔率何时以及为什么会不太准确，我们就可以在训练模型时强调这些特征，希望它能够更准确地预测比赛结果。

当价差很小时(大约在-25 和 25 点之间)，下注赔率不成比例地错误。这并不奇怪。然而，在每个点差值上，下注赔率正确的次数多于错误的次数，这意味着即使是在势均力敌的比赛中，你最好还是下注最有希望的一方。

主队的赔率

正如我们所展示的，在其他条件相同的情况下，主队的胜率要比客队略高一些(约 57%)。那么，奇怪的制造者是如何考虑到这一点的呢？他们对主队和客队有偏见吗？

赔率制定者在支持主队方面保持合理的平衡，选择他们获胜的概率为 57.68%，这与主队 57.29%的胜率一致。当选择主队时，赔率制造者的总体准确性提高了约 2%(当选择客场时，比平均水平差约 4%)，这表明他们更善于识别主场优势何时会成为决定性因素，何时不会。

主队的赔率:跨州比赛

除了被广泛接受的跨体育和联赛的主场优势的影响，AFL 起源的一个怪癖给我们的分析增加了一条皱纹。澳大利亚规则足球始于该国南部和西部的地区运动，橄榄球联盟是北部和东部的主要接触运动。事实上，澳大利亚足球联盟曾经是维多利亚足球联盟，即使现在联盟的 18 支球队中有 10 支位于维多利亚州，他们的主场距离彼此只有一小时多一点的车程(根据谷歌地图，1 小时 1 分钟)。因此，根据我的各种对话，关于主场优势的传统观点是，对于来自同一地区的球队来说，主场优势很小，甚至可能不存在，而当球队来自不同的州时，主场优势就更加重要了。

考虑到这一点，我将研究跨州比赛，看看在这些情况下主场优势的影响是否更大。

主场球队赢得了 58.16%的跨州比赛，总体上比主场球队多赢了大约一分，这表明额外旅行距离的影响是真实的，尽管很小。然而，奇怪的是，61.51%的时候支持跨州主场球队，大约多三分，这意味着传统智慧认为跨州效应是实际的三倍。这是一个证据，赌赔率往往会放大关于影响球队获胜概率的因素的传统智慧。跨州比赛的投注赔率准确率为 72.65%，比整体准确率高出不到半个点。上面的标准化混淆矩阵也显示了我们在所有匹配中看到的预测误差之间的类似平衡。

为排名较高的队伍下注

如前所述，比一支球队是否在主场比赛更强的获胜概率预测因素是他们是否比他们的对手更高(约 57%比约 68%)。因此，博彩公司通常青睐排名更高的球队是有道理的。问题是这种趋势有多强，在多大程度上得到了排名更高的球队的实际表现的支持。

尽管排名较高的球队只赢得了 68.00%的比赛，但赔率制造者选择他们赢得 82.45%的时间，这比我们在其他细分市场看到的不平衡要大得多。

通过观察混淆矩阵，我们发现，下注赔率错误地偏向于排名较高的球队的情况比偏向于排名较低的球队的情况更多。此外，就像挑选主队一样——更是如此——赔率制造者在识别更好的球队(根据他们的排名)何时会赢比差的球队何时会赢要好得多。

看起来真实的效果越强(主场优势，跨州比赛的主场优势，阶梯排名作为获胜的预测因素)，越不平衡的投注赔率变得有利于应该获胜的球队。即使这些偏差似乎不会显著影响投注赔率的整体准确性，但它们确实显示了一些赔率不太准确的情况，即当它们与传统观点相反时。这意味着，至少在势均力敌的比赛中，当赔率有利于排名较低和/或客场的球队时，偶尔给对手小费可能是值得的。

按团队下注的赔率

在组织形式上，AFL 比欧洲足球联盟更接近于美国体育联盟:赛季之间有一个选秀，在这个选秀中，烂队可以优先得到顶级业余球员，有工资帽，自由球员等等。这些规则中的许多都是为了促进球队之间的平等，防止一组球队进入决赛，而另一组球队年复一年地在阶梯的底部徘徊。尽管如此，在与足球迷的交谈中，我感觉到一些球队获得了常年赢家或输家的名声，而这些看法很难改变。这有可能影响 oddsmakers 如何对待不同的球队，将预测建立在声誉而不是实际表现的基础上。

Team win rate vs predicted win rate, sorted by difference between the two (predicted win rate — win rate)

正如胜率和预测胜率之间的百分比差异所表示的那样，似乎确实有一种倾向，即过分青睐有获胜记录的球队(山楂，悉尼)，而不太看好有失败记录的球队(布里斯班，黄金海岸)。

团队胜率与赔率制定者倾向于过分偏爱好团队而不偏爱坏团队之间的关系是存在的，但并不明显。此外，支持好团队的偏见，像其他被检查的偏见一样，对下注赔率的准确性没有太大影响，因为高准确性和低准确性在具有不同预测误差值的团队中传播。然而，似乎确实有一种模式，好的和坏的团队与高投注准确性相关联，而平庸的团队与低准确性相关联。

它有些嘈杂，但上面的图表明，oddsmakers 在预测坏队和好队的结果方面有些更好，但对那些赢了 40%到 60%比赛的平庸球队来说就有麻烦了。当预测势均力敌的比赛结果时，这种趋势符合下注赔率不太准确的一般模式。虽然我能理解在尝试与那些能够在一周击败顶级球队，而在下一周输给垫底球队的中游球队比赛时的挫败感，但这并不是一个非常有趣的观察结果。在势均力敌的比赛中翻牌是很难的一部分，但你需要做好这些才能有机会赢得底池。

最后

在这里探讨的简单试探法中，基于大量数据输入的试探法往往更好地预测 AFL 比赛结果，其中博彩赔率是最准确的预测因素。从不同的维度来分析比赛，显示出博彩公司在预测赢家和输家的能力上存在一些偏差和弱点。下注赔率往往会放大关于促成胜利的因素的传统智慧，有利于以高于胜率保证的比率从这些因素中受益的团队。然而，这些偏差对博彩赔率的表现几乎没有影响，较低的准确性通常集中在接近的比赛上，无论一个人的方法的质量和复杂程度如何，都很难预测。模型可以利用的一个轻微的弱点是，当下注赔率违背传统智慧，偏向排名较低和/或客场球队时，下注赔率的准确性会受到影响。

我没有提到的一个重要方面是时间。AFL 比赛数据可以按球队或主场对客场或高排名对低排名进行汇总，但它们代表的是按顺序发生的离散事件，过去的比赛不仅影响未来的比赛，而且球队在球场上的表现趋势会影响关于下周谁将获胜的传统观点，这反过来会影响下周比赛的投注赔率。然而，时间是一个很大的主题，所以我将在下一篇文章中深入探讨。

将数据运用到个人理财中

原文：https://towardsdatascience.com/toward-better-spending-outcomes-in-personal-finance-90fb5b4645e5?source=collection_archive---------9-----------------------

安泰米斯集团利用人力和金融资本，在充满活力的市场中为高潜力的创始人寻找机会，投资于这个交叉领域。

New York City at Night (NASA)

简介

T 交易数据和分析数据的技术为改善个人财务决策提供了一个强大的机会。好处远远超出了财务健康，影响到身体和精神健康。此外，利用这些数据可能是将个人银行业务模式与个人结果相结合的重要催化剂。

本文探讨了两个概念:

1) 基于交易数据的解决方案，使账户持有人能够做出更好的消费决策

2) 一种衡量此类解决方案对银行和最终用户价值的方法

思维实验

考虑一下…现在是 2020 年。当你起床查看手机时，你会收到银行新应用的一些通知。

早上好，莎拉，

没有超越您的目标的荣誉 : 根据您本月设定的 1 个月目标和您的相关“回报率”，我们在 ASOS 冻结了您的卡。您不必退回这些鞋子，节省了 7.99 美元的运费和 45 分钟的免费时间:)

提醒:根据您的健康目标设定，我们在所有快餐店维护您的信用卡。好消息:你离“Chopt”的免费沙拉只差一份了

节省费用:根据您前五年的航班预订情况，您通常会在 12 月 23 日至 12 月 26 日之间从纽约飞往芝加哥。下周预计是为这次旅行购买机票的最佳时间。我们可以在下周发送另一个提醒，但它们本周为 250 美元，预计下周将降至 225 美元。现在买还是等？

现在是 2022 年

\[$储蓄:你每年最大的支出是住房。如您所知，我们密切关注您所在社区的价格，以确保您获得公平的市场价格。根据你的账户注册，在过去的 6 个月里，你所在的巴特西区的一居室公寓价格下跌了 20%。您目前支付的金额似乎过高。如果可能的话，我们建议进行重新谈判。如果你愿意，我们可以促进谈话。只需向我们提供管理代理的详细信息。你怎么想呢?太疯狂了。我不希望我的银行做这些事情。或者‘有道理’。几个这样的会很酷。可能吗？“这怎么可能行得通，”我们认为，发现不健康的购买模式、不必要的费用、储蓄选项或未能坚持目标本身是有帮助的，但在不影响结果的情况下，它们真的有多大吸引力？银行和其他金融机构拥有几十年来客户的详细交易记录。因此，这些机构完全有能力产生影响，尽管开放银行业加速了这一环境，并带来了更多的挑战。数据科学形式的技术足够复杂，可以识别上述每一种模式，行为科学通过[推动](https://www.nobelprize.org/prizes/economics/2017/press-release/)取得了显著的成果。认识和确定消费模式仅仅是开始，在这个阶段我们的问题比答案多。然而，我们的研究发现了趋同趋势和 60 多家在该领域开展业务的早期公司——从聊天机器人到分类引擎，从机器人顾问的数字忠诚度，到短期贷款人和数据使能器的挑战者银行。根据这一分析，很明显，数据优先、自下而上的方法可以改善支出决策。然而，在剥离这些层面时，消费者的价值主张比零售银行更明显。因此，我们将这篇文章集中在四个主题上:> 教育和适应消费者:从 TransferWise 中学习 > > 不断变化的市场条件和客户期望 > > 监管的作用 > > 为什么时机合适，衡量什么有用？## **教育消费者并与消费者保持一致:从 TRANSFERWISE 中学习**七年前，TransferWise 带着一个新颖的想法进入外汇交易市场:大规模削弱竞争对手，并教育市场。他们的 100 多万客户群获得了极具竞争力的外汇汇率和最低的交易费用，从而获得了很高的客户满意度和保留率。许多银行注意到了 TransferWise 的成功(参考桑坦德银行内部备忘录[1])，但选择了等待和观望的方法，含蓄地打赌客户不会注意到，或者更糟的是，会注意到而不会接受更低成本的替代方案。> *transfer wise 的客户平均年龄为 30 岁，它的产品预示着消费者行为的转变和不断变化的银行业预期。*【2】***Figure 1: Comparison of TransferWise Fees to Leading UK Banks****[3]**(Eurozone Transfer £1k & £10k)****.***通过提供透明度，以转移方式建立信任；通过帮助提高金融知识，培养客户的信心；而且，通过提供低成本产品，确保了客户增长，增加了企业和用户的价值。TransferWise 的崛起反映了以客户为导向的方法的可行性和实现的潜力。货币化和保留的新方法表明，传统的终身客户价值模型与最终客户一致。这是一个为客户直接创造价值的独特机会，而不是以零和形式产生费用，如透支。高盛(Goldman Sachs)收购 Clarity Money(T1)并投资抵押贷款转换和经纪公司(mortgage switcher and broker)，[truss le(T3)以及摩根大通(JPMorgan)最近宣布推出免费应用程序](https://trussle.com/)[You-Invest(T5)与 robin hood(T7)竞争，突显了这一趋势。](https://www.chase.com/personal/investments/you-invest)## **不断变化的市场条件和客户期望**如果你想说服别人，就诉诸兴趣，而不是理性- 本·富兰克林银行理所当然地强调个人活期账户(PCA)持有者的低转换率。他们还指出，挑战者账户主要由二级账户持有人组成。然而，在当今的动态环境中，这些比率似乎具有误导性。> *从一个主要提供非数字化、类似商品的产品的时代转向一个竞争加剧、产品差异化和监管支持的数字化时代，意味着方向性的改变即将到来。*从 NPS 得分来看，客户对金融机构越来越警惕。尽管这一指标本身正在调整，但市场情绪依然存在。在某种程度上，这导致好奇的客户尝试竞争对手的“增值”创新功能，例如:* 控制/限制 * 自动分类 * 数字收据 * 照片账单支付 * 无期货交易费用 * 不收自动取款机费用 * 增加获得以前机构产品的机会 * 消费忠诚度/奖励 * 高收益利息 * 弹性透支 * 自动帐户/服务切换 * 替代贷款 * 四舍五入储蓄因此，包含上述组件的解决方案正在成为标准。杰夫·贝索斯通过描述亚马逊的第一天，提供了一种描述这一演变的有用方式。**Figure 2\. Day 1 at Amazon**从本质上讲，未能关注客户的公司和产品为亚马逊(和其他公司)打开了尝试的大门。这是一个相当简单的策略:通过测量来持续改进附加值和用户体验。这意味着从[客户的角度出发](https://www.sec.gov/Archives/edgar/data/1018724/000119312518121161/d456916dex991.htm)并相应地设定绩效指标。此外，更具体地说，与经常账户相关，EY 发现，对于考虑纯数字、非银行提供商的客户来说，获得不同产品和服务以及客户体验的要素仅次于更具吸引力的费率/费用。[4]***Figure 3: Online Experience, Products and Services Combine to Lead****[5]*这项研究强调了明确的市场趋势，研究还在继续。要点是，数据可用性、竞争对手的发展势头以及新的法规为测试和创建符合客户需求的解决方案提供了丰富的环境。## **调控的作用**我们正在密切关注对未安排透支的提议变更(正在接受 FCA 的审查)。这为构建数据驱动的系统、解决客户需求以及与客户保持一致提供了及时的机会。> *银行拥有帮助客户避免透支费用的数据，但使用这些数据需要改变方法，因为他们以前从这些费用中获得的收入超过了 PCA 的收入。****Figure 4: Analysis of UK PCA Value to Bank*** *(£ per main PCA customer per year)[6],[7]*然而，在与数据科学家和银行家交谈时，分析消费行为是困难的。不完整的数据、行为上的关联、数据的不当使用，更不用说集成了，都会造成严重的障碍。除了建立信任，消费者的脆弱性也是一个问题。谁在关注弱势客户？在这一领域，监管变得越来越严格，但更值得注意的是，商业模式应该是限制性的，或者基于对客户的附加值。示例:在对您的历史数据进行回溯测试后，我们创建了您定制的账户储蓄引擎。如果您选择使用这项服务，每年平均可节省 104 个小时和 138 美元。我们根据结果收费。## **为什么时机合适，衡量什么有用？**“对我最大的赞美就是有人问我的想法，并注意听我的回答。”——亨利·大卫·梭罗**Figure. 5\. Monzo and Revolut take a customer first approach**[8]简而言之，“把客户放在第一位”，市场指标，新的监管，受过教育，但脆弱的客户期望不同。大型银行对此时刻保持警惕，并积极努力更好地利用客户数据，在某些情况下，建立自己的解决方案。然而，在数据上实现技术，建立一个“酷”的市场验证产品，不受利益竞争的影响，以及吸引合适的人才是重大的内部障碍。根据上面强调的发展趋势，我们研究了替代银行解决方案，如 Monese、Revolut、N26、Monzo、Chime、“包容性金融服务提供商”支付宝和收益率为 4%的田弘余额宝货币市场基金。***Figure 6: Revolut — 1.5m+ customers inside 3 years****[9][10]****Figure 7: Yu’e Bao — $260b+ AUM in 5 years****[11]*客户价值可能不等于企业价值，但价值肯定能抓住用户的注意力。F/X 和高收益利息产品在上述公司中脱颖而出。精明的早期采纳者基于对价值主张的接近和了解而选择加入。这种“病毒式传播”依赖于客户对附加值的欣赏，以及在自己的网络中进行宣传或分享的意愿。在财务方面，TransferWise 认为增值比竞争对手的成本低 80-90%。注册一张卡后，Revolut 的基本服务是免费的。这些结果纯粹以财务节约来衡量。就对用户的价值而言，还有什么是重要的？节省的时间、与目标的一致性、理解、透明度和信心呢？搜索优惠券和交易节省的时间？追踪品牌忠诚度的价值？对谷歌或客服来说，提高了知识，减少了问题？更好地控制我们在哪里、什么时候和谁一起消费？改善个人消费模式的好处？这些因素能被实质性地衡量吗？我们正在考虑几个假设:* *我们可以识别客户数据中的模式，并主动或被动地使用它来改善支出结果(如下图所示)****Figure 8: Aligning Historical Spending Patterns with Desired Outcomes**** *每个人都处在消费健康谱的某个位置:无论是总体还是个人交易。****Figure 9: Spending Health Spectrum***## **我们感兴趣的东西**就财务健康而言，经常账户价值主张和有形客户价值之间存在脱节。帮助消费者做出更好的财务决策和结果的数据是可用的，但目前消费者并未以最佳方式利用这些数据。在金融机构遭受消费者情绪低落的关键时刻，向客户提供有意义的价值势在必行。市场上有明确的证据表明，这种方法可以提高客户参与度、评级、产品采用率和长期价值。由于我们正处于发展我们的假设和为这一风险概念招募创始团队的早期阶段，我们已经分享了对市场信号和监管的研究和初步想法。我们寻求创始人和顾问来推动这一主张，以及银行合作伙伴进行合作。请提出意见和问题。*我在* [*安泰美丝集团*](http://www.anthemis.com) *从事早期业务的市场识别、分析和开发工作，这里陈述的观点是我个人的观点。感谢 Kat，Archie，Dario，Leslie，SJ 和 Erica 的许多建议。*来源:[1]卫报 Money，2017 年 4 月[2]CBInsights，2017 年 6 月[3]Monito，2016 年 5 月[4]EY，2016 年[5]WSJ，穆迪，2018 年[6]Baringa，2016 年 1 月[7]FCA，2018 年 5 月[8]LinkedIn，2018 年[9]Revolut，2018 年 5 月[10]CBInsights，Tech.eu，2018 年[11]WSJ，穆迪# 走向再现性:平衡隐私和出版> 原文：<https://towardsdatascience.com/toward-reproducibility-balancing-privacy-and-publication-77fee2366eee?source=collection_archive---------4----------------------->在数据安全和研究披露之间的冲突中，会有一个金发女孩的选择吗？Photo by [Shiva Smith](https://www.pexels.com/@shiva-smyth-394854) on [Pexels](https://www.pexels.com/).数据科学是一个高度跨学科的领域，在学术/行业分界线的两侧(以及两者之间的任何地方)都呈爆炸式增长。这导致了从业者背景和哲学方面惊人的多样性，该领域的多样性转化为数据科学和高级分析组织的观点和政策的多样性。一些组织，无论是在学术界还是工业界，都有非常“学术”的天赋，领导者鼓励开发新颖的模型和方法，然后发布这些方法并参加会议。相反，其他小组则专注于根据行业标准按时创建可销售的数据产品，同时受到 NDAs 和其他数据的限制，而不太关注理论上的新颖性。大多数组织在这两者之间寻求某种程度的平衡，但是找到平衡点通常需要仔细考虑技术和组织的需求和目标。这些理念和环境的差异将数据科学领域分割成了基于数据和模型可用性的万花筒般的子集，这使得在不同环境之间转化发现变得非常困难。多种多样的软件许可、知识产权保护以及隐私和安全保障会使[复制，更不用说再现性，成为一个重大挑战](/data-sciences-reproducibility-crisis-b87792d88513)。然而，所有持久的职业，无论多么隐秘，都有一个共同点:从业者能够以有意义和富有成效的方式相互分享信息和最佳实践。建立强大的专业环境的唯一方法是让数据科学家能够相互分享问题和解决方案，因为没有人知道所有的答案。在许多前沿模型和大型数据集有访问限制的领域中，这可能是极其困难的。然而，其他领域已经克服了类似的挑战，数据科学越早从其前辈和相关领域获得灵感，就越早能够在信息共享方面制定严格的标准。但在此之前，我们必须先看看这个领域的现状。GNU, from the [Free Software Foundation](https://www.fsf.org/)# **寄养合作**自由和开放源码软件(FOSS)也许是软件可用性的最自由的方法之一。在这种情况下，开源意味着一个项目的代码库可以公开地被检查、修改和分发，而自由(就像“解放的”，而不是“极其便宜的”)意味着你可以用你可以访问的软件做任何你想做的事情。自由和开放源码软件有各种各样的模式，其中许多模式在什么是自由和什么是开放源码以及一个给定的软件是一个、两个还是两个都不是之间做出了令人困惑的区分。想到这一点最简单的方法是使用理查德·斯托尔曼对 4 种软件自由的定义:以你喜欢的方式运行程序的自由，研究和修改程序的自由，重新发布程序的自由，以及发布程序修改副本的自由。这种类型的模型，或者非常类似的东西，是学术软件的默认设置。大多数出版的学术著作都与某种公开可用的代码库相关，其中最常见的是 [GitHub](https://github.com/) 。但是这个模型很少提到可及性的负担，而且[这些已经成为学术界所有领域的共同问题，不仅仅是计算领域的问题](https://web.stanford.edu/~vcs/Nov21/hilary_spencer_rdcscsJan2010.pdf)。换句话说，坚持自由/开源软件概念的规则是一回事，但坚持其原则又是另一回事。出版物禁运、员工超负荷工作、服务器停机、IT 规则和政策，甚至补丁和更新等因素都会使在有意义的时间范围内重现或复制过去的实验变得困难。这些可访问性障碍并不总是恶意的，甚至不是有意的，但它们仍然是实践的一个重大障碍。在云计算的推动下，数据科学中的许多挑战已经减少。用电子邮件发送大量 zip 文件的日子已经一去不复返了。如果你在这个领域工作的时间够长的话，你可能还记得有一段时间你不得不将数据或软件刻录到 CD 上或加载到硬盘上，然后将整个东西邮寄给合作者。但是，尽管越来越多的人采用基于云的服务，仍然有一些负担需要解决。最重要的是，“云”实际上只是“其他人的硬件”的一个新术语，在其他人的系统上存储数据和工作通常是有成本的，无论是名义上的还是财务上的，或者两者兼而有之。理想情况下，研究产生的软件和模型都将成为免费访问的 Github 库(或类似库)的一部分。很多都是。然而，Github 仍然是一家私人公司，不管那里有多少模型或软件包，在它或任何其他平台上发布数据都有自己的问题。因为数据科学不仅仅是软件和代码。它还与从软件中产生模型所用的数据有关，这就是问题所在。我们不能总是使用公开可用的数据集来回答每个数据科学问题，试图这样做限制了我们探索现实生活现象的能力。我们不能总是公开我们的数据。Photo by [Steve Johnson](https://www.pexels.com/@steve) on [Pexels](https://www.pexels.com/).# **受限访问**虽然自由/开源软件看起来是一个适用于大多数研究软件的美好理想，但是自由/开源软件的概念并不总是适用于数据科学的每一个方面，尤其是在数据共享方面。适用于我们领域的一些最大的数据仓库必然有访问限制。这可能是由于各种各样的原因，但最常见的是隐私和安全。无论我们喜欢与否，这两种力量都不可避免地与数据科学的实践联系在一起。世界上大多数最大的数据集都由公司持有，对于这些公司来说，数据是其主要的(如果不是唯一的)产品或市场竞争优势。类似地，数据科学最成熟的领域之一，医学数据科学/信息学，有一系列广泛的数据隐私和同意法律，并且有充分的理由。其他不断发展的领域，如运营和制造数据科学，使用的数据可能会揭示关键的业务实践，甚至在关键基础设施的情况下会产生国家安全后果。这些挑战甚至可以进一步延伸到模型共享，尤其是随着“对抗性数据科学”领域的发展。根据系统的不同，如果你可以访问 API 或类似的接口，就有可能攻击机器学习和深度学习工具来[提取模型信息](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_tramer.pdf)，甚至[推断数据集成员关系](https://arxiv.org/abs/1610.05820)。这些信息可能足以让坏人造成严重伤害。由于这些重大的安全威胁，许多团体在最小化对他们的模型和数据的访问方面有既得利益。由于披露的不可逆转性，这一点尤其重要。数据集一旦公开发布，就几乎不可能再保护它，而且没有人知道该数据集以后会被用来做什么。在隐私方面，通常有关于数据隐私和可用性的非常严格的法规和法律。 [HIPAA](https://www.hhs.gov/hipaa/for-professionals/index.html) ，一套在美国保护健康信息披露的复杂规则和条例，是这种不断增长的法规体系的典型例子。随着健康信息和数据科学中新趋势的发现，HIPAA 规则也在不断更新，许多机构现在都有广泛的办公室和培训计划，致力于维护 HIPAA 合规性。GDPR 是一个更近的例子，一般隐私法规正变得越来越广泛，越来越具有技术意识。作为这些法规有多么重要的一个例子，想一想由于 GDPR 法案的生效，您收到了多少服务条款更新电子邮件。这只是一个地区的一个监管框架。这些规则和法规是保护公民和组织个人隐私和安全的强大力量，但它们的要求也增加了数据科学家对监管意识的需求，这在我们年轻的领域中有时会被忽视。对于数据科学家来说，重要的是理解并接受这些规定的原因，并找到在规定范围内工作的方法，以免我们成为害群之马。虽然哀叹隐私和安全在我们领域的负担可能很诱人，但整合这些安全措施的强大道德立场将极大地促进我们作为一个领域的未来成功。Photo by [Pixabay](https://www.pexels.com/@pixabay) on [Pexels](https://www.pexels.com/).# **平衡再现性、安全性和隐私性**数据科学的许多子领域正迅速走向严重的社会和监管障碍。在过去几年中，违规和道德上有问题的使用案例对数据科学这一领域以及我们许多人每天处理的数据的性质产生了负面影响。数据科学的“狂野西部”时代即将结束，这意味着我们需要超越“新算法、相同数据”和“相同算法、新数据”的范式。我们一些最强大的算法已经以意想不到的方式被公开利用，关于一些数据集中包含多少个人信息的更广泛披露让许多公众感到不安。至此，数据科学已经到了它的“青春期”。仍然存在严重不足的主题，迫切需要新方法和新数据来解决根本问题，但我们也需要共同扩大我们的工作，以公平地讨论和研究数据可用性以及如何在数据可用性与安全性之间取得平衡。大多数数据科学研究的核心是人类主体研究。我们大多数人都努力尽可能地去识别我们发表的研究的主题，但我们必须仔细区分安全性(在这种情况下，身份检索是不可能的)和模糊性(在这种情况下，身份检索简直令人讨厌)。我们还必须认识到，在许多情况下，由于新的研究和技术会随着时间的推移将强有力的安全措施转变为弱模糊，安全措施很容易被削弱。一个值得深入研究的有前途的数据安全方法是[差分隐私](https://www.accessnow.org/understanding-differential-privacy-matters-digital-rights/)。从本质上讲，差异隐私是一种在披露前用某种程度的统计不确定性“掺杂”原始数据的方式。然而，正如我们大多数人所知，有了足够大的数据集或足够的系统访问，许多类型的统计不确定性可以被建模和抽象掉。关于一个人在一天中的位置的一个不可靠的数据点可能相对难以验证。连续 100 天内关于一个人位置的 100 个不可靠的数据点远没有那么安全。这只是数据安全措施可能成为相对较弱的数据混淆措施的一个例子。仅仅将隐私注入数据点是不够的。我们还必须考虑受试者或数据集的终生“隐私预算”，而差异隐私的隐私预算难题尚未得到可靠解决。尽管如此，在这一点上，差分隐私是我们拥有的最好的可扩展选项之一。因此，差分隐私已经被几个主要的基于数据的组织采用，包括[苹果](https://images.apple.com/privacy/docs/Differential_Privacy_Overview.pdf)、[谷歌](https://security.googleblog.com/2014/10/learning-statistics-with-privacy-aided.html)和[美国人口普查](https://www2.census.gov/cac/sac/meetings/2017-09/statistical-disclosure-limitation.pdf)，其中每个组织对不确定性注入和隐私预算都有不同的方法。这些方法没有一个是完美的，但是这些实现导致了对它们的优点和缺点的重要研究。美国人口普查实际上在技术和监管领域都处于数据隐私和安全的前沿。他们甚至开发了一个经济模型来判断如何管理隐私和准确性之间的平衡。虽然这种方法可能不是最佳解决方案，但它是朝着正确方向迈出的重要一步，评估和管理隐私预算和数据准确性的方法可能会继续发展。不幸的是，尽管在公开期间对维护数据隐私的方法有很大的努力和兴趣，但在数据科学中很少有可用的方法来建模或算法隐私。这可能会让许多团体，尤其是私人数据公司，不愿分享他们在该领域通常具有开创性的工作。开源和开放获取显然可以有效地进行披露，但对于许多企业研究人员来说，如果允许的话，它们往往只是有选择地实施。迫切需要关于模型和方法披露的新的商业(和研究)伦理，特别是在与数据披露相结合时。我们如何评价一种新的建模方法？我们如何预测我们方法的新用例？我们甚至应该在披露决策中考虑估值吗？这些问题并不容易回答，而且在这一领域工作的数据科学家相对较少，使得这些问题变得更加难以回答。随着我们领域的发展，这种类型的“元数据科学”工作将变得越来越重要。数据和模型的可用性对该领域的发展至关重要，但随着我们的工作变得更加可见和公开，我们需要不断评估和实施我们的道德披露政策。在数据科学中，我们有一个个人隐私、企业安全和公共利益的多种道德模式相互碰撞的领域，将这些道德整合成一个单一、统一的整体，平衡最大允许披露水平和最高安全水平将需要大量工作。*走向再现性**迈向再现性是一个正在进行的系列文章，讨论数据科学和机器学习中再现性的当前挑战和潜在解决方案。每篇文章都聚焦于推动数据科学中* [*再现性危机的主要因素之一*](/data-sciences-reproducibility-crisis-b87792d88513) *。*# 走向防御性数据科学宣言> 原文：<https://towardsdatascience.com/towards-a-manifesto-of-defensive-data-science-a09fb9d37acd?source=collection_archive---------13----------------------->*数据科学家的世界你一无所获，却收获了更多的客户*我是一个非常糟糕的壁球运动员，但在一个短暂的时期内，当一个对手告诉我如何防守时，我成为了一个稍微更好的壁球运动员——而不是每次击球时都试图击出致胜球或吊球，稳定而深入地回击，以便我的对手最终更接近他们的后角，最终犯下错误。事实证明，遵循这一策略，我可以比全力以赴打好每一杆时赢得更多的分数。更好的是，在前两个点打完之后，我并没有因为跑来跑去而筋疲力尽——直到第四个点打了一半才停下来。数据科学有一点相同，因为人们经常试图用最精彩的镜头赢得每一分，而不是通过应用正确的工具，更不用说通过应用允许他们花费最少努力的正确工具。合适的工具会更容易实现，更容易理解，更容易交流。它将使用较少的计算能力来计算其结果。防御数据的本质在于算法的经济性。为了最新的事物而避开它的理由很容易被发现。最显而易见的是，在一种方法是尖端的和它难以实现之间有一种直观的关联。有些时候，这是因为方法本身就很复杂。在其他时候，这将是由于该方法缺乏成熟的现成解决方案(否则它不会是“前沿”)，所以需要做更多的工作来形成什么是可用的，以满足您的应用程序的特定需求。这里有比投入[不必要的努力](https://www.processexcellencenetwork.com/lean-six-sigma-business-transformation/articles/the-7-deadly-wastes-that-could-cost-your-company)更多的风险——尽管[新乡重夫](https://en.wikipedia.org/wiki/Shigeo_Shingo)会告诉你那已经够糟了。算法最简单的模型是最容易被顾客和客户接受的，可信的模型是最能赢得人心的。一个算法存在的时间越长，你的客户就越有可能见过它。越简单，他们就越有可能理解它，从而信任它。因此，你的发现可以传播给他人的观念是数据科学防御方法的主要目标之一。比过于复杂的算法更不必要的是错误问题的解决方案。正如约翰·图基(John Tukey)所说，“对*正确*的问题给出一个大致的答案，这通常是模糊的，远比对错误问题给出一个*精确*的答案好得多，后者总是可以变得精确。”发现正确问题的途径需要[时间与客户一起了解他们的需求](/selling-your-data-science-project-7e3e06f91ec6) —但是在这里花的时间越多，你越认真地试图理解问题背后的[问题，解决方案就越有价值。](https://en.wikipedia.org/wiki/5_Whys)找到了解决客户问题的可行方案后，下一个重要步骤是找到向客户解释的最佳方式，除非他们不可能不理解，否则不能指望或相信他们会理解。正如谚语所说，数据科学家 80%的精力花在清理数据上，80%的精力也花在向需要理解数据的人解释最终结果上。交流的可视化策略不同于发现的可视化策略。一个完整的解决方案必须包括允许客户自己发现的独特组件，以及确保客户正确理解您的发现的组件。因此，确保你的沟通不留任何侥幸心理是防御数据科学的另一个核心要点。当然，不管你认为你知道多少，也不管你认为你的算法有多好，你出错的可能性仍然存在。一个防御性的数据科学家欢迎被证伪——不仅仅是因为道德含义。通过提出明确的案例，并用数据支持，防御性数据科学家确保主题专家可以提出有用的批评，并通过在发布前将模型暴露给这些人，最大限度地提高了在任何人受到影响之前发现错误的可能性。李小龙信奉的哲学是“运动经济”——用最少的努力获得结果。当然，为了达到这种效果，李和他的学生刻苦训练，以完善他们的技术。实际上，他们在道场投入了最大的努力，特别是在打斗中尽量减少努力。防御性数据科学要求数据科学家付出努力来防止用户不必要的努力。# Raja Chatila 的抽象机器人理解> 原文：<https://towardsdatascience.com/towards-abstract-robotic-understanding-with-raja-chatila-d1c32e9c0f6d?source=collection_archive---------9----------------------->## TWiML Talk 118在这一集里，我们邀请到了 Raja Chatila，他是巴黎皮埃尔和玛丽·居里大学智能系统和机器人学主任，也是 IEEE 智能和自治系统伦理全球倡议的执行委员会主席。## 订阅:[iTunes](https://itunes.apple.com/us/podcast/this-week-in-machine-learning/id1116303051?mt=2)/[SoundCloud](https://soundcloud.com/twiml)/[Google Play](https://goo.gl/app/playmusic?ibi=com.google.PlayMusic&isi=691797987&ius=googleplaymusic&link=https://play.google.com/music/m/Ihs3mamzsef2akrfycfkq3sspti?t%3DThis_Week_in_Machine_Learning_%2526_AI_Podcast)/[Stitcher](http://www.stitcher.com/s?fid=92079&refid=stpr)/[RSS](https://twimlai.com/feed)Raja 和我就他的研究聊得很开心，他的研究涉及机器人的感知和发现。我们讨论了学习和发现之间的关系，特别是当它应用于机器人及其环境时，以及机器人感知和行动之间的联系。我们还深入探讨了应用于智能系统的启示、抽象教导、元推理和自我意识的概念。最后，我们触及这些系统的价值和伦理问题。# 和我一起参加人工智能峰会你是一名需要在企业中广泛的机器学习和人工智能机会上变得聪明的 IT、技术或业务领导者吗？或者，也许你组织中的某个人可以从这方面的提升中受益？(或者，也许你会从他们的升级中受益！)如果这听起来像你或你认识的人，你可能会对我即将举行的人工智能峰会感兴趣。把这个活动想象成一个为期两天的机器学习和人工智能的技术 MBA。你会清楚地了解:机器学习和深度学习如何工作(不需要数学知识) 如何在您的组织中识别机器学习和深度学习的机会 如何理解和利用计算机视觉和自然语言处理等技术 如何管理和标记数据以利用 ML 和 AI 以及如何建立 AI 优先的文化，并在您的业务中实施 AI。你将对整个人工智能和人工智能领域正在发生的事情有一个知情的观点，并将能够自信地与你的同事、客户和合作伙伴讨论机器学习和人工智能。我对这次活动和演讲者感到非常兴奋，你们将有机会向他们学习。欲了解更多信息，请访问[twimlai.com/aisummit](https://twimlai.com/aisummit)，如有疑问，请随时联系[我](http://twimlai.com/contact)。# 关于 Raja* [LinkedIn 上的拉贾](https://www.linkedin.com/in/rajachatila/?locale=en_US) * [ISIR 的拉贾](http://www.isir.upmc.fr/?op=view_profil&id=229)# 采访中提到* [在这里报名参加人工智能大会！](https://twimlai.com/ainy2018) * [看看@ShirinGlander 的伟大 TWiML 速写！](https://www.shirin-glander.de/) * [TWiML 呈现:系列页面](https://twimlai.com/series) * [TWiML 事件页面](https://twimlai.com/events) * [TWiML Meetup](https://twimlai.com/meetup) * [TWiML 简讯](https://twimlai.com/newsletter)由李·罗斯韦尔创作的《以后再谈》，由 CC 4.0 授权*原载于 2018 年 3 月 12 日*[*twimlai.com*](https://twimlai.com/twiml-talk-118-towards-abstract-robotic-understanding-raja-chatila/)*。*# 以深度认知迈向更轻松的深度学习生活> 原文：<https://towardsdatascience.com/towards-an-easier-deep-learning-life-with-deep-cognition-8fa8f41ca672?source=collection_archive---------16----------------------->## Deep Cognition 的深度学习工作室的新版本中出现了令人惊叹的新功能。你有深度学习模型但是你希望它在 TensorFlow 或者 MXNet？现在可以转换了！JupyterLab 已为您预先配置，H2O 现已作为预先配置的环境和新的集成功能提供给 Talend！深度学习有趣又神奇。现在做深度学习非常容易，你有很多很好的框架和库、平台等等。但我认为改变游戏规则的是[深度认知](https://medium.com/u/561cb78751ed?source=post_page-----8fa8f41ca672--------------------------------)。在他们的新版本中，他们为他们的深度学习工作室(DLS)添加了惊人的功能。顺便说一句，如果你想知道更多，就看看这个:[](https://becominghuman.ai/deep-learning-made-easy-with-deep-cognition-403fbe445351) [## 深度认知让深度学习变得简单### 在过去的一个月里，我有幸见到了 DeepCognition.ai 的创始人becominghuman.ai](https://becominghuman.ai/deep-learning-made-easy-with-deep-cognition-403fbe445351) [](/a-video-walkthrough-of-deep-cognition-fd0ca59d2f76) [## 深度认知的视频漫游### 大家好！在本文中，我将与您分享几个视频，带您浏览深度认知的平台…towardsdatascience.com](/a-video-walkthrough-of-deep-cognition-fd0ca59d2f76) 要尝试我将向您展示的新功能，您需要下载最新版本的 DLS:[](https://deepcognition.ai/products/desktop/) [## 深度学习工作室桌面### Deep Learning Studio - Desktop 是在您的硬件上本地运行的单用户解决方案。桌面版允许您…deepcognition.ai](https://deepcognition.ai/products/desktop/) # **提高不同深度学习框架之间的互操作性**深度学习工作室增加了一个功能，可以让用户将模型转换为 Tensorflow、Caffe、Keras2、MXNet、CNTK、Pytorch 或 ONNX。你现在可以复制转换后的代码，并在喜欢的深度学习框架中使用它。这太酷了，因为如果出于某种原因你需要创建 Pytorch 代码，但你只知道 Keras，现在你可以很容易地转换你的代码。# **JupyterLab 现已在深度学习工作室内可用**如果你没有听说过，JupyterLab 是 Jupyter 项目的下一代用户界面。它提供了经典 Jupyter 笔记本的所有熟悉的构建模块(笔记本、终端、文本编辑器、文件浏览器、丰富输出等)。)在一个灵活而强大的用户界面中，可以通过第三方扩展进行扩展。JupyterLab 是一个交互式开发环境，用于处理笔记本、代码和数据。最重要的是，JupyterLab 完全支持 Jupyter 笔记本。JupyterLab 提供了笔记本、文档和活动之间的高度集成:* 拖放以重新排列笔记本单元格，并在笔记本之间复制它们。 * 从文本文件(以交互方式运行代码块。py，。r，。md，。tex 等。). * 将代码控制台链接到笔记本内核，以交互方式探索代码，而不会因为临时的临时工作而弄乱笔记本。 * 使用实时预览编辑流行的文件格式，如 Markdown、JSON、CSV、Vega、VegaLite 等。JupyterLab 建立在一个扩展系统之上，该系统使您能够通过安装额外的扩展来自定义和增强 JupyterLab。现在在 DLS 你可以看到:# **H2O.ai 现已在 DLS 作为预配置环境提供**是的。朱庇特拉布的最后一张照片是对 H2O 的一个试探！现在也是 DLS 的一部分。H2O 是用于大数据分析的开源软件。由 [H2O.ai](http://h2o.ai) 公司生产。如果你想了解如何利用 H2O 改变你作为一名数据科学家的生活，我建议你看看[马修·丹乔](https://medium.com/u/2ba518663a6?source=post_page-----8fa8f41ca672--------------------------------)与 R 合作的商业数据科学课程(你可以使用此优惠券代码享受八五折优惠！):[](https://university.business-science.io/p/hr201-using-machine-learning-h2o-lime-to-predict-employee-turnover/?coupon_code=SAVE_15) [## DS4B 201-R:面向商业的数据科学### 了解如何使用 H2O 自动机器学习和石灰黑盒模型解决现实世界中的员工流动问题…大学.商业-科学. io](https://university.business-science.io/p/hr201-using-machine-learning-h2o-lime-to-predict-employee-turnover/?coupon_code=SAVE_15) 最后！# **Talend Open Studio 现已在深度学习工作室内可用**Talend Open Studio 为跨公共云、私有云和混合云以及内部环境的数据集成提供了单一平台。使用 Talend，您可以:* **功能强大，易于使用。**[Talend Open Studio for Data Integration](https://www.talend.com/products/data-integration/data-integration-open-studio/)，您可以免费下载和使用，它提供了设计和执行各种数据集成流程所需的所有功能，例如数据迁移(包括 ETL 和 ELT)和数据同步。凭借基于 Eclipse 的图形开发环境、900 多个组件和内置数据连接器、统一的元数据存储库、Java 代码的自动生成和强大的 ETL 测试功能，基于订阅的 Talend Data Integration 通过专门为企业级项目设计的功能(如团队协作工具、工业级部署和实时负载平衡)补充了 Talend Open Studio 的数据集成功能。 * **成熟的性能。**Talend Open Studio for Data Integration 于 2006 年推出，迅速赢得了市场份额，拥有数百万次下载和数十万用户。Talend 数据集成平台企业版的用户数以千计，包括一些世界上最大的公司。 * **节省大量成本。**与劳动密集型定制开发或专有软件相比，Talend 的开源解决方案可大幅节省成本。与用于数据集成的免费 Talend Open Studio 相关的节省是显而易见的，但是即使是基于订阅的 Talend 数据集成，成本也明显低于专有技术。 * **活跃的社区。**围绕 Talend 数据集成和应用集成解决方案的社区非常活跃。一些社区应用程序可用于共享问题、建议和代码。 * **由塔伦德撑腰。Talend 应用一个主要的和正在进行的 R&D；努力维护和改进其开源产品。该供应商提供专业质量的用户文档和培训材料，并为那些需要它的人提供一流的技术支持和专业服务。**现在集成到 DLS，像一个开放的工作室 ETL。如果你想改善你的数据集成工作流程，这是必须的。我真的认为 GUI 和 AutoML 是用深度学习完成事情的不远的将来。不要误解我，我喜欢编码，但是我认为我们明年要写的代码数量会减少。我们不能花这么多时间在世界范围内一遍又一遍地编写相同的东西，所以我认为这两个特性(GUI 和 AutoML)将帮助数据科学家提高生产率和解决更多的问题。下载新的 DLS，检查这个新功能，并与他人分享！感谢你阅读这篇文章。我希望你在这里找到了一些有趣的东西:)如果你有问题，请在 Twitter 上关注我:[](https://twitter.com/faviovaz) [## 法维奥·巴斯克斯(@法维奥·巴斯克斯)|推特### Favio Vázquez 的最新推文(@FavioVaz)。数据科学家。物理学家和计算工程师。我有一个…twitter.com](https://twitter.com/faviovaz) 和 LinkedIn:[](https://www.linkedin.com/in/faviovazquez/) [## Favio Vázquez -首席数据科学家- OXXO | LinkedIn### 查看 Favio Vázquez 在世界上最大的职业社区 LinkedIn 上的个人资料。Favio 有 17 个工作列在他们的…www.linkedin.com](https://www.linkedin.com/in/faviovazquez/) 那里见:)# 走向伦理机器学习> 原文：<https://towardsdatascience.com/towards-ethical-machine-learning-302e580f5815?source=collection_archive---------11----------------------->## 数据采集员道德责任探析我辞掉了工作，加入了一个密集的数据科学训练营。我理解大量可用数据背后的价值，这些数据使我们能够创建预测性的机器学习算法。除了在专业层面上认识到它的价值，作为消费者，我也从这些技术中受益。每当我发现自己陷入音乐的窠臼时，我都会依赖 Spotify 的 Discover Weekly。我经常惊讶于 Spotify 的算法和其他机器学习模型如何如此准确地预测我的行为。事实上，当我第一次坐下来写这篇文章时，我停下来看了一段 Youtube 视频。20 分钟后，我意识到 Youtube 的推荐算法有多好。虽然我非常清楚地看到了机器学习的好处，但认识到并减轻其潜在的危险也是必不可少的。虽然 Spotify 或 Youtube 推荐我不喜欢的歌曲或视频不会产生任何毁灭性的后果，但并非所有的机器学习算法都是如此。我第一次意识到机器学习的潜在后果是在我看到 Marshal Project 和 FiveThirtyEight 之间的合作时，他们讨论了机器学习在刑事司法系统中的使用。我认为机器学习只会给支离破碎的刑事司法系统带来好处。毕竟，美国占世界总人口的 5 %,却有世界 25%的被监禁人口。除了不成比例的监禁人口，美国的司法系统是建立在种族主义的警察和起诉，飙升的累犯率，以及对非暴力毒品罪犯过于严厉的惩罚。机器学习的引入难道不会对一个深陷危机的系统有所帮助吗？虽然乍一看，机器学习似乎除了帮助美国破碎的刑事司法系统之外什么也做不了，但在阅读了更多关于正在实施的一些努力之后，我意识到谨慎行事至关重要。确定一个人被捕后的命运是机器学习被引入刑事司法系统的一种方式，它体现了依赖机器学习做出可能改变生活的决定的风险。传统上，在一个人被逮捕后不久，法官就会面临一个困难的决定，即他们是否必须在监狱中等待出庭日期，这可能是几个月或几年，或者他们是否可以在家里等待出庭日期，有或没有限制。为了做出这一决定，法官必须分析被告，并且必须预测他们是否认为此人有逃跑的风险——如果被释放回家，此人将不会出庭受审，或者有犯下其他罪行的风险。事实上，一个人被赋予做出可能改变生活的决定的权力是不公平的，并且为有偏见的决定留下了空间。随着机器学习的进步，已经引入了各种技术，试图消除法官的偏见，并基于数据而不是个人的唯一判断做出决定。这些技术通常被称为风险评估工具，由非营利组织和营利公司开发。劳拉和约翰·阿诺德基金会(LJAF)开发的公共安全评估(PSA)就是这些风险评估工具之一。PSA 使用历史数据，根据与未能出庭的风险和再次犯罪的风险相关的分数，标记那些被视为高风险的人。似乎利用基于历史数据的算法可以减少决定个人命运的偏差，而不是将全部决定权交给一个法官，但许多人发现这些风险评估加剧了他们试图消除的歧视性做法。这些算法为模型特征分配分数，例如年龄、性别、收入、药物使用和以前的定罪。尽管 PSA 在 29 个城市和州使用，以及许多其他风险评估工具在全国范围内使用，但这些模型中使用的变量和权重的综合列表仍然是专有的，通常被称为“黑盒”。范德比尔特法学院刑事司法项目主任克里斯托弗·斯洛博金(Christopher Slobogin)表示，“风险评估应该是不被允许的，除非双方都能看到进入其中的所有数据。这应当是一个公开的、全面的对抗式诉讼程序。”如果我们想确保这些算法努力减少偏差，理解它们所基于的数据是很重要的。这些风险评估的透明度是无价的，因此公众以及依靠他们做出决定的法官可以充分理解导致他们提出建议的途径，包括这些建议所依据的原始数据。毕竟，正如 IBM Research 指出的，“人工智能系统的好坏取决于我们输入的数据。不良数据可能包含隐含的种族、性别或意识形态偏见。许多人工智能系统将继续使用坏数据进行训练，使这成为一个持续存在的问题。但我们相信偏见可以被驯服，能够解决偏见的人工智能系统将是最成功的。”作为数据科学家，我们必须认识到我们的道德责任，用无偏见的数据训练机器学习模型。出发点之一是允许透明度和制衡制度，以确保模型所基于的数据是公平和公正的。关于风险评估工具，理解所使用的数据是至关重要的，特别是考虑到困扰美国刑事司法系统的历史问题，如种族主义和对非暴力毒品犯罪的过于严厉的处理。我们必须理解这些数据，以便脱离这些偏见，而不是让它们永久化。减少机器学习算法偏差的一个步骤是通过纽约大学 AI Now 研究所提出的算法影响评估(AIAs)。AIA 从“黑盒”方法导致恶性循环的想法延伸而来，不断远离对这些算法的理解，并削弱解决可能由此产生的任何问题的能力。AI 现在建议使用 AIAs 来处理公共领域中机器学习的使用，创建一套标准要求。通过 AIAs，AI 现在旨在通过公开列出和解释所使用的算法系统向公众提供清晰度，同时允许公众对这些系统提出争议，开发审计和评估流程，并提高公共机构理解他们所使用的系统的内部能力。类似于使用 AIAs 来促进机器学习的透明度，国防高级研究计划局(DARPA)建议将可解释的人工智能(XAI)作为解决方案的一部分。如下图所示，XAI 致力于创造更多用户可以理解和信任的可解释模型。虽然在 DARPA 的网站上似乎还没有对 XAI 的任何清晰、简明的描述，但他们表示，XAI 原型一直在进行测试，目标是在去年 11 月完成第一阶段的系统评估。在网站上，他们还表示，“在项目结束时，最终交付的将是一个工具包库，由机器学习和人机界面软件模块组成，可用于开发未来可解释的人工智能系统”AIAs 和 XAI 只是组织朝着更道德、更透明的机器学习模型努力的两个例子。随着机器学习继续以爆炸式的速度增长，肯定会有更多的想法被引入，以确保这种监管。不管这些想法背后的具体细节如何，重要的是保持一个围绕机器学习模型的透明和理解的系统，在此期间，在机器学习过程的所有阶段都要仔细检查数据，以确保公平的做法，不会使偏见永久化。**来源:**[](https://www.themarshallproject.org/2015/08/04/the-new-science-of-sentencing) [## 量刑的新科学### 马修·康伦、鲁本·菲舍尔-鲍姆和安迪·罗斯贝克的互动图形www.themarshallproject.org](https://www.themarshallproject.org/2015/08/04/the-new-science-of-sentencing) [](https://fivethirtyeight.com/features/prison-reform-risk-assessment/) [## 是否应该根据尚未犯下的罪行来判刑？### 这个故事是与马歇尔计划合作制作的。长期以来，刑事判决都是基于…fivethirtyeight.com](https://fivethirtyeight.com/features/prison-reform-risk-assessment/) [](https://www.washingtonpost.com/news/fact-checker/wp/2015/07/07/yes-u-s-locks-people-up-at-a-higher-rate-than-any-other-country/?utm_term=.9de388bf6ac6) [## 是的，美国的入狱率比其他任何国家都高### 2015 年 7 月 7 日“一个严峻的事实是，美国的人口不到世界人口的 5 %,然而我们有…www.washingtonpost.com](https://www.washingtonpost.com/news/fact-checker/wp/2015/07/07/yes-u-s-locks-people-up-at-a-higher-rate-than-any-other-country/?utm_term=.9de388bf6ac6) [](https://hbr.org/2016/12/a-guide-to-solving-social-problems-with-machine-learning) [## 用机器学习解决社会问题的指南### 这是周日晚上。你是一个大城市的副市长。你坐下来看电影，向网飞寻求帮助…hbr.org](https://hbr.org/2016/12/a-guide-to-solving-social-problems-with-machine-learning) [](https://harvardlawreview.org/2018/02/bail-reform-and-risk-assessment-the-cautionary-tale-of-federal-sentencing/) [## 保释改革和风险评估:联邦判决的警示故事### 从新泽西州到德克萨斯州，再到加利福尼亚州，全国各地都在讨论、实施和诉讼保释改革…harvardlawreview.org](https://harvardlawreview.org/2018/02/bail-reform-and-risk-assessment-the-cautionary-tale-of-federal-sentencing/) [## 审前风险评估现已向所有感兴趣的司法管辖区开放；研究顾问委员会…### 纽约-劳拉和约翰·阿诺德基金会(LJAF)正在扩大访问一套资源，将有助于…www.arnoldfoundation.org](http://www.arnoldfoundation.org/laura-and-john-arnold-foundation-makes-pretrial-risk-assessment-available-to-all-jurisdictions-announces-expert-panel-to-serve-as-pretrial-research-advisory-board/) [](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3225350) [## 算法风险评估和青年的双刃剑。### 在判刑时，年轻可以被认为是一个减轻情节，因为它与减少…papers.ssrn.com](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3225350) [](https://www.research.ibm.com/5-in-5/ai-and-bias/) [## 人工智能和偏见- IBM 研究-美国### 五年内，有偏见的人工智能系统和算法的数量将会增加。但是我们会相应地处理它们…www.research.ibm.com](https://www.research.ibm.com/5-in-5/ai-and-bias/) [](https://medium.com/@AINowInstitute/algorithmic-impact-assessments-toward-accountable-automation-in-public-agencies-bd9856e6fdde) [## 算法影响评估:走向公共机构的可问责自动化### 2018 年 4 月 9 日更新:我们发布了一份新报告，完整描述了我们对算法影响评估的提议…medium.com](https://medium.com/@AINowInstitute/algorithmic-impact-assessments-toward-accountable-automation-in-public-agencies-bd9856e6fdde) [](https://ainowinstitute.org/) [## 爱现在研究所### 纽约大学的人工智能研究所是一个跨学科的研究中心，致力于理解…ainowinstitute.org](https://ainowinstitute.org/) [](https://www.darpa.mil/program/explainable-artificial-intelligence) [## 可解释的人工智能### 图一。对可解释的人工智能在机器学习方面的巨大成功的需求导致了人工智能的洪流…www.darpa.mil](https://www.darpa.mil/program/explainable-artificial-intelligence)# 毒理学家，把这当成你的干预:打破我们对 P 值的依赖> 原文：<https://towardsdatascience.com/toxicologists-consider-this-your-intervention-breaking-our-addiction-to-p-values-21aec86d4c62?source=collection_archive---------7----------------------->同事们，我们有个问题。请坐下。这听起来不太容易。我们被谎言所诱惑。我们的女妖:p 值。一场危机已经酝酿了好几年。这个谎言充斥着我们整个社会。我们已经说服自己，p 值是总结我们研究价值的最重要的值。我们培养了一代又一代的同事，让他们明白小于 0.05 的 p 值是对我们工作的认可。它根植于我们的价值观中——它根植于我们在药品、化学品和公共卫生方面做出决策的同事中。问题:我们被一个关于 p 值的弥天大谎骗了。我们中的一些人认为 p 值告诉我们研究的假阳性率(这根本不是真的)。我们社区中的其他人认为，p 值告诉我们，如果我们重复研究一百次，我们会看到与我们的研究一样大或更大的差异的概率。问题是，这两种观点都不正确。事实上，一个 p 值实际上是相当不同的。假设零模型为真，p 值实际上是特定研究中数据与零模型拟合程度的度量。是的，我说的是模特。换句话说，如果您的数据不太符合零模型(同样，假设零模型是真的，它可能是也可能不是)，那么您将有一个小的 p 值(更接近于 0)。如果您的数据非常符合零模型，那么您将有一个非常大的 p 值(接近 1)。这就是问题所在。我们被告知，如果我们有一个小的 p 值，特别是小于α值(通常α= 0.05)，那么我们可以拒绝零假设。不过，这实际上并不正确。“但是为什么呢？”你可能会问。嗯，原来原因有点复杂。我会尽最大努力保持简单，但我不能做出任何承诺——这变得非常棘手。# 失乐园当罗纳德·费雪设计 p 值时，他只是为了一个目的:告诉我们一项研究是否应该重复。就是这样。这就是 p 值的数学基础。然而，随着时间的推移，费舍尔的信息变得混乱。p 值成了一种统计学上的灵丹妙药——一种从那些没有信息的研究中识别“有价值”的研究的方法。这个想法变成了具有较大 p 值的研究价值较低——更可能是假阳性。人们开始接受费希尔的观点，并把它变得如此愚蠢，以至于 p 值失去了所有最初的意义。p 值不是意味着我们需要重复一项研究，而是成为了一个看门人。它是期刊的看门人。这些期刊反过来成为了工作的守门人。在资源有限的环境中，期刊之间的竞争加剧，科学家之间对期刊有限页数的竞争加剧，研究复制的想法开始逐渐消失。p-values 和 frequentist 方法的巨大吸引力在于，大多数毒理学家使用简单的软件就能轻松完成。GraphPad Prism 和其他易于使用的软件使得毒理学家能够轻松分析他们自己的数据。毒理学家现在可以生成他们自己的 p 值。这使得统计学家可以将他们的时间和精力集中在更复杂的问题上，并推进他们的研究领域。当然，有时毒理学家没有把他们的研究设计和他们的分析方法很好地匹配起来。当然，有时毒理学家实际上并没有很好地设计他们的研究。这些都是期刊的同行审稿人会注意到的，对吗？对吗？# 重返天堂2016 年，美国统计协会[发表了一份关于 p 值的声明](http://amstat.tandfonline.com/doi/abs/10.1080/00031305.2016.1154108)。这一陈述的关键是重申 p 值确实告诉我们特定研究的数据与特定模型的吻合程度。通常，该模型是零假设。为了让 p 值起作用，我们假设零假设为真。它继续揭穿了围绕 p 值的几个神话。ASA 还声明，科学界应该使用和探索 p 值的替代方法。包括我自己在内，有些人支持贝叶斯方法。我喜欢贝叶斯方法的地方在于它们非常透明。在贝叶斯世界中，你通常关心的数字是后验概率——这只是某个事件的概率，考虑到你的研究证据以及该事件的先验证据。这不同于大多数毒理学家经常使用的方式。在频率主义者的方法中，你真的只关心零假设，然后是你的研究数据。我从开始使用贝叶斯方法的人那里听到的一个担心是，他们不知道先验应该是什么。事实上，他们确信没有人做过他们正在做的事情。事实上，这可能是真的——也许你是唯一一个以前做过这项研究的人，它是 100%独一无二的。这很好——贝叶斯方法仍然有帮助。先验概率是我们对事件发生的知识或信念的概括。我是一个现实主义者——我知道大多数毒理学家不会进行试点研究。我不会相信很多毒理学家会这么做。但是假设你做了一个初步研究。太好了，我们可以在先验中使用这些信息！也许你做了剂量发现或范围发现研究——最棒的是，我们也可以在我们的先验中使用它！这是事情变得有趣的地方。如果您正在处理一个二元情况—活着/死了，头/尾，生病/好了，肿瘤/没有肿瘤—那么您可能会假设您的数据遵循伯努利分布。等等——你可能会问，我为什么要说分销？这是因为在贝叶斯统计中，我们使用分布来封装我们的不确定性。如果我什么都不知道，除了我们正在处理一个二元情况，而你只有一个试点研究，那么我会说，“让我们做伯努利，因为这是一个合理的假设。”另一方面，如果你看伯努利，并决定它使用太多或太少的不确定性，我们总是可以看不同的分布，并适当地参数化它。现在，如果我们没有进一步的信息会发生什么。我们有两条路可走——我们可以利用你作为毒理学家的培训、教育和经验，对先验知识做出有根据的猜测(我们通常会有某种偏见),或者我们可以直接说，“你知道吗，我完全不知道，所以让我们使用无信息先验知识。”一个非信息性的先验将最终整合为 1——所以在现实中，你的后验分布将完全由你的研究数据决定。大多数 Bayesians 人不喜欢使用无信息的先验知识——我不得不说，我在极少数情况下使用它们，我通常必须有一个非常好的理由，并且在我尝试之前对一个领域完全无知。说实话，你的前科可能会也可能不会对你的后验有很大影响——这真的取决于你带来的数据。我们可以在贝叶斯世界中拟合各种模型。关心剂量反应？是的，我们可以分析一下。在乎一剂吗？是的，我们也能做到。但是这是最好的部分——我们可以开始问决策者需要答案的真正有意义的问题。比如，“如果一个人暴露在毫克/千克/天的乙基甲基有害物质中 70 年，他患癌症的概率是多少？”然后，“如果我们把 Q 毫克/千克-天改为 Q/10 毫克/千克-天，现在概率是多少。”这些是决策者关心的有意义的问题。那是什么？你想在一个荟萃分析中整合多个研究——做贝叶斯分析时易如反掌。您将数据集链接在一起，使用先验知识作为您的先验，您的数据作为可能性，并计算后验。再简单不过了。我们对后验是 100%透明的。我们说，“假设我们的模型是正确的，事件 E 的概率是 x%。”任何人都可以就你的模型的适当性与你争论——他们应该这么做。但是为了使辩论有意义，他们需要把他们自己的反模型带到辩论中来，让他们的模型与你的模型相对抗。你知道吗，谁赢了，谁就拥有最符合数据的模型。最终，真正的赢家是科学。我不在乎我是否输掉了一场关于我的模型的有意义的辩论，因为我知道别人已经做出了一个更好的模型。最终，我们都赢了。我将了解更多关于更好的模型，使我成为一个更好的贝叶斯，科学界将有更好的数据和知识可用，最终，我们将停止谈论 p 值，并开始讨论在给定的一些情况下事件发生的概率。真的，我们最关心的不是预测在给定的环境下，某个事件发生的概率吗？# Python 中的 TPOT 自动机器学习> 原文：<https://towardsdatascience.com/tpot-automated-machine-learning-in-python-4c063b3e5de9?source=collection_archive---------4----------------------->TPOT graphic from the [docs](http://epistasislab.github.io/tpot/)在这篇文章中，我分享了我和 Python 中的自动机器学习(autoML)工具 [TPOT](http://epistasislab.github.io/tpot/) 的一些探索。目标是看看 TPOT 能做什么，以及它是否值得成为你机器学习工作流程的一部分。自动化机器学习不会取代数据科学家，(至少现在不会)，但它可能会帮助你更快地找到好的模型。TPOT 自称是你的数据科学助手。> TPOT 旨在成为一个助手，通过探索你可能从未考虑过的管道配置，给你提供如何解决特定机器学习问题的想法，然后将微调留给更受约束的参数调整技术，如网格搜索。所以 TPOT 帮助你找到好的算法。请注意，它不是为自动化深度学习而设计的——类似 AutoKeras 的东西可能会有所帮助。[**An example machine learning pipeline (source: TPOT docs)**](http://epistasislab.github.io/tpot/)TPOT 建立在 scikit learn 库的基础上，并严格遵循 scikit learn API。它可以用于回归和分类任务，并为医学研究提供特殊的实现。TPOT 是开源的，有很好的文档记录，正在积极开发中。它的开发是由宾夕法尼亚大学的研究人员带头进行的。TPOT 似乎是最受欢迎的 autoML 库之一，截至 2018 年 8 月，有近[4500 个 GitHub star](https://github.com/EpistasisLab/tpot/)。# TPOT 是如何工作的？[An example TPOT Pipeline](http://epistasislab.github.io/tpot/) (source: TPOT docs)TPOT 拥有其开发者所称的遗传搜索算法来寻找最佳参数和模型集合。它也可以被认为是一种自然选择或进化算法。TPOT 尝试了一条流水线，评估了它的性能，并随机改变了流水线的某些部分，以寻找性能更好的算法。> AutoML 算法不像在数据集上拟合一个模型那么简单；他们正在考虑多种机器学习算法(随机森林、线性模型、支持向量机等。)在具有多个预处理步骤(缺失值插补、缩放、PCA、特征选择等)的流水线中。)，所有模型和预处理步骤的超参数，以及在流水线内集成或堆叠算法的多种方式。*(来源:*[*【TPOT 文档】*](http://epistasislab.github.io/tpot/using/) *)*TPOT 的这种能力来自于自动高效地评估各种可能的管道。手动完成这项工作既麻烦又慢。# 运行 TPOTTPOT 分类器的实例化、拟合和评分类似于任何其他 sklearn 分类器。格式如下:``` tpot = TPOTClassifier() tpot.fit(X_train, y_train) tpot.score(X_test, y_test) ```TPOT 有自己的一键编码变体。注意，它可以自动将其添加到管道中，因为它将具有少于 10 个唯一值的特性视为分类特性。如果你想使用自己的编码策略，你可以对你的数据进行编码，然后*再*把它输入 TPOT。您可以为 tpot.score 选择评分标准(尽管 Jupyter 和多处理器内核的一个 bug 使您无法在 Jupyter 笔记本中拥有一个多处理器内核的自定义评分标准)。看来你不能改变 TPOT 在内部搜索最佳管道时使用的评分标准，只能改变 TPOT 选择最佳算法后在测试集上使用的评分标准。这是一些用户可能想要更多控制的领域。也许在未来的版本中会增加这个选项。TPOT 使用 tpot.export()将有关最佳性能算法及其准确度分数的信息写入文件。您可以选择 TPOT 运行时希望看到的冗长程度，并让它在运行时将管道写入输出文件，以防由于某种原因提前终止(例如，您的 Kaggle 内核崩溃)。# TPOT 要跑多长时间？简而言之，这要视情况而定。TPOT 被设计为运行一段时间——几个小时甚至一天。尽管使用较小数据集的不太复杂的问题可以在几分钟内看到很好的结果。您可以调整 TPOT 的几个参数，以便更快地完成搜索，但代价是对最佳管道的搜索不够彻底。它并不是为了对预处理步骤、特性选择、算法和参数进行全面的搜索而设计的，但是如果您将它的参数设置得更详尽一些，它可能会更接近。正如医生解释的那样:> …TPOT 将需要一段时间才能在较大的数据集上运行，但了解原因很重要。使用默认的 TPOT 设置(100 代，100 人口规模)，TPOT 将在完成前评估 10，000 个管道配置。为了将这个数字放入上下文中，考虑机器学习算法的 10，000 个超参数组合的网格搜索，以及该网格搜索需要多长时间。也就是说，有 10，000 个模型配置要用 10 重交叉验证来评估，这意味着在一次网格搜索中，大约有 100，000 个模型适合并评估了训练数据。我们将在下面看到的一些数据集只需要几分钟就可以找到得分较高的算法；其他人可能需要几天。以下是默认的 TPOTClassifier 参数:``` generations=100, population_size=100, offspring_size=None # Jeff notes this gets set to population_size mutation_rate=0.9, crossover_rate=0.1, scoring="Accuracy", # for Classification cv=5, subsample=1.0, n_jobs=1, max_time_mins=None, max_eval_time_mins=5, random_state=None, config_dict=None, warm_start=False, memory=None, periodic_checkpoint_folder=None, early_stop=None verbosity=0 disable_update_check=False ```每个参数的描述可以在[文档](http://epistasislab.github.io/tpot/api/)中找到。以下是几个决定 TPOT 将搜索的管道数量的关键因素:``` **generations:** int, optional (default: 100) Number of iterations to the run pipeline optimization process. Generally, TPOT will work better when you give it more generations(and therefore time) to optimize the pipeline. **TPOT will evaluate POPULATION_SIZE + GENERATIONS x OFFSPRING_SIZE pipelines in total** (emphasis mine).**population_size:** int, optional (default: 100) Number of individuals to retain in the GP population every generation. Generally, TPOT will work better when you give it more individuals (and therefore time) to optimize the pipeline. **offspring_size:** int, optional (default: None) Number of offspring to produce in each GP generation. By default, offspring_size = population_size. ```从 TPOT 开始，设置 *verbosity=3* 和*periodic _ check point _ folder = " any _ string _ you _ like "*是值得的，这样你就可以看到模型的发展和训练分数的提高。当管道元素的一些组合不兼容时，您会看到一些错误，但是不要担心。如果您正在多核上运行，并且没有使用自定义计分功能，请设置 n_jobs=-1 以使用所有可用的内核并加速 TPOT。## 搜索空间以下是 TPOT 从版本 0.9 开始选择的分类算法和参数:``` ‘sklearn.naive_bayes.**BernoulliNB**’: { ‘alpha’: [1e-3, 1e-2, 1e-1, 1., 10., 100.], ‘fit_prior’: [True, False] }, ‘sklearn.naive_bayes.**MultinomialNB**’: { ‘alpha’: [1e-3, 1e-2, 1e-1, 1., 10., 100.], ‘fit_prior’: [True, False] }, ‘sklearn.tree.**DecisionTreeClassifier**’: { ‘criterion’: [“gini”, “entropy”], ‘max_depth’: range(1, 11), ‘min_samples_split’: range(2, 21), ‘min_samples_leaf’: range(1, 21) }, ‘sklearn.ensemble.**ExtraTreesClassifier**’: { ‘n_estimators’: [100], ‘criterion’: [“gini”, “entropy”], ‘max_features’: np.arange(0.05, 1.01, 0.05), ‘min_samples_split’: range(2, 21), ‘min_samples_leaf’: range(1, 21), ‘bootstrap’: [True, False] },‘sklearn.ensemble.**RandomForestClassifier**’: { ‘n_estimators’: [100], ‘criterion’: [“gini”, “entropy”], ‘max_features’: np.arange(0.05, 1.01, 0.05), ‘min_samples_split’: range(2, 21), ‘min_samples_leaf’: range(1, 21), ‘bootstrap’: [True, False] }, ‘sklearn.ensemble.**GradientBoostingClassifier**’: { ‘n_estimators’: [100], ‘learning_rate’: [1e-3, 1e-2, 1e-1, 0.5, 1.], ‘max_depth’: range(1, 11), ‘min_samples_split’: range(2, 21), ‘min_samples_leaf’: range(1, 21), ‘subsample’: np.arange(0.05, 1.01, 0.05), ‘max_features’: np.arange(0.05, 1.01, 0.05) },‘sklearn.neighbors.**KNeighborsClassifier**’: { ‘n_neighbors’: range(1, 101), ‘weights’: [“uniform”, “distance”], ‘p’: [1, 2] }, ‘sklearn.svm.**LinearSVC**’: { ‘penalty’: [“l1”, “l2”], ‘loss’: [“hinge”, “squared_hinge”], ‘dual’: [True, False], ‘tol’: [1e-5, 1e-4, 1e-3, 1e-2, 1e-1], ‘C’: [1e-4, 1e-3, 1e-2, 1e-1, 0.5, 1., 5., 10., 15., 20., 25.] }, ‘sklearn.linear_model.**LogisticRegression**’: { ‘penalty’: [“l1”, “l2”], ‘C’: [1e-4, 1e-3, 1e-2, 1e-1, 0.5, 1., 5., 10., 15., 20., 25.], ‘dual’: [True, False] }, ‘xgboost.**XGBClassifier**’: { ‘n_estimators’: [100], ‘max_depth’: range(1, 11), ‘learning_rate’: [1e-3, 1e-2, 1e-1, 0.5, 1.], ‘subsample’: np.arange(0.05, 1.01, 0.05), ‘min_child_weight’: range(1, 21), ‘nthread’: [1] } ```并且 TPOT 可以堆叠分类器，包括多次相同的分类器。TPOT 的核心开发者之一在本期[中解释了它是如何工作的](https://github.com/EpistasisLab/tpot/issues/360):> 流水线`*ExtraTreesClassifier(ExtraTreesClassifier(input_matrix, True, 'entropy', 0.10000000000000001, 13, 6), True, 'gini', 0.75, 17, 4)*`执行以下操作: > > 使用提取树分类器拟合所有原始特征 > > 从提取树分类器中获取预测，并使用这些预测创建新要素 > > 将原始特征加上新的“预测特征”传递给第二个提取树分类器，并将其预测用作管道的最终预测 > > 这个过程被称为堆叠分类器，这是机器学习中一种相当常见的策略。这里是 TPOT 从 0.9 版本开始可以应用的 11 个预处理程序。``` ‘sklearn.preprocessing.**Binarizer**’: { ‘threshold’: np.arange(0.0, 1.01, 0.05) }, ‘sklearn.decomposition.**FastICA**’: { ‘tol’: np.arange(0.0, 1.01, 0.05) }, ‘sklearn.cluster.**FeatureAgglomeration**’: { ‘linkage’: [‘ward’, ‘complete’, ‘average’], ‘affinity’: [‘euclidean’, ‘l1’, ‘l2’, ‘manhattan’, ‘cosine’] }, ‘sklearn.preprocessing.**MaxAbsScaler**’: { }, ‘sklearn.preprocessing.**MinMaxScaler**’: { }, ‘sklearn.preprocessing.**Normalizer**’: { ‘norm’: [‘l1’, ‘l2’, ‘max’] }, ‘sklearn.kernel_approximation.**Nystroem**’: { ‘kernel’: [‘rbf’, ‘cosine’, ‘chi2’, ‘laplacian’, ‘polynomial’, ‘poly’, ‘linear’, ‘additive_chi2’, ‘sigmoid’], ‘gamma’: np.arange(0.0, 1.01, 0.05), ‘n_components’: range(1, 11) }, ‘sklearn.decomposition.**PCA**’: { ‘svd_solver’: [‘randomized’], ‘iterated_power’: range(1, 11) }, ‘sklearn.preprocessing.PolynomialFeatures’: { ‘degree’: [2], ‘include_bias’: [False], ‘interaction_only’: [False] }, ‘sklearn.kernel_approximation.**RBFSampler**’: { ‘gamma’: np.arange(0.0, 1.01, 0.05) }, ‘sklearn.preprocessing.RobustScaler’: { }, ‘sklearn.preprocessing.**StandardScaler**’: { }, ‘tpot.builtins.ZeroCount’: { }, ‘**tpot.builtins.OneHotEncoder**’: { ‘minimum_fraction’: [0.05, 0.1, 0.15, 0.2, 0.25], ‘sparse’: [False] } (emphasis mine) ```这是一个非常全面的 sklearn ml 算法列表，甚至包括一些您可能没有用于预处理的算法，包括 Nystroem 和 RBFSampler。最后列出的预处理算法就是之前提到的自定义 OneHotEncoder。请注意，该列表不包含神经网络算法。组合的数量几乎是无限的——您可以堆叠算法，包括相同算法的实例。管道中的步骤数量可能有一个内部上限，但可以说可能有太多的管道。如果您运行 TPOT 两次，它可能不会导致相同的算法选择(我发现，即使设置了 random_state，也可能不会，如下所述)。正如[文档](http://epistasislab.github.io/tpot/using/)所解释的:> 如果您正在处理相当复杂的数据集或短时间运行 TPOT，不同的 TPOT 运行可能会产生不同的管道建议。TPOT 的优化算法在本质上是随机的，这意味着它使用随机性(部分)来搜索可能的管道空间。当两个 TPOT 运行推荐不同的管道时，这意味着 TPOT 运行由于缺少时间而没有收敛*或*多个管道在数据集上执行或多或少相同的操作。少说多做。让我们用一些数据来检验一下 TPOT！# 数据集 1: MNIST 数字分类首先我们来看一个分类任务 sklearn 数据集中包含的来自 [MNIST 的流行手写数字分类任务。MNIST 数据库包含 70，000 张 28x28 像素的手写阿拉伯数字图像，从 0 到 9。](http://scikit-learn.org/stable/datasets/index.html)TPOT 是 Kaggle Docker 镜像的标准配置，所以你只需要在使用 Kaggle 的时候导入它——你不需要安装它。这是我的代码——可以在[这个 Kaggle 内核](https://www.kaggle.com/discdiver/tpot-with-mnist-digit-classification/)上获得，形式略有不同，可能有一些修改。``` # import the usual stuff import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import os# import TPOT and sklearn stuff from tpot import TPOTClassifier from sklearn.datasets import load_digits from sklearn.model_selection import train_test_split import sklearn.metrics# create train and test sets digits = load_digits() X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target, train_size=0.75, test_size=0.25, random_state=34)tpot = TPOTClassifier(verbosity=3, scoring="balanced_accuracy", random_state=23, periodic_checkpoint_folder="tpot_mnst1.txt", n_jobs=-1, generations=10, population_size=100)# run three iterations and time themfor x in range(3):start_time = timeit.default_timer()tpot.fit(X_train, y_train)elapsed = timeit.default_timer() - start_timetimes.append(elapsed)winning_pipes.append(tpot.fitted_pipeline_)scores.append(tpot.score(X_test, y_test))tpot.export('tpot_mnist_pipeline.py')times = [time/60 for time in times] print('Times:', times) print('Scores:', scores) print('Winning pipelines:', winning_pipes) ```如上所述，管道总数等于人口 _ 大小+世代 x 后代 _ 大小。例如，如果设置 population_size=20，generations=5，那么 subject _ size = 20(因为默认情况下 subject _ size 等于 population_size。因为 20 + (5 * 20 ) = 120，所以总共有 120 条管道。您可以看到，运行这个数据集根本不需要太多代码——这包括一个计时和重复测试的循环。有 10 个可能的类别，没有理由选择一个结果而不是另一个，准确性——TPOT 分类的默认——是这项任务的一个很好的衡量标准。下面是相关的代码部分。``` digits = load_digits() X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target, train_size=0.75, test_size=0.25, random_state=34)tpot = TPOTClassifier(verbosity=3, scoring=”accuracy”, random_state=32, periodic_checkpoint_folder=”tpot_results.txt”, n_jobs=-1, generations=5, population_size=10,early_stop=5) ```结果如下:``` Times: [4.740584810283326, 3.497970838083226, 3.4362493358499098] Scores: [0.9733333333333334, 0.9644444444444444, 0.9666666666666667]Winning pipelines: [Pipeline(memory=None,steps=[('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,learning_rate=0.1, loss='deviance', max_depth=7,max_features=0.15000000000000002, max_leaf_nodes=None,min_impurity_decrease=0.0, min_impurity_split=None, ...auto', random_state=None,subsample=0.9500000000000001, verbose=0, warm_start=False))]), Pipeline(memory=None,steps=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True)), ('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,learning_rate=0.5, loss='deviance', max_depth=2,max_features=0.15000000000000002, max_leaf_...auto', random_state=None,subsample=0.9500000000000001, verbose=0, warm_start=False))]), Pipeline(memory=None,steps=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True)), ('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,learning_rate=0.5, loss='deviance', max_depth=2,max_features=0.15000000000000002, max_leaf_...auto', random_state=None,subsample=0.9500000000000001, verbose=0, warm_start=False))])] ```请注意，只有 60 个管道——远远少于 TPOT 建议的——我们能够看到相当好的分数——在一个案例中，测试集的准确率超过 97%。## 再现性TPOT 每次都用相同的 random_state 集合找到相同的获胜管道吗？不一定。像 RandomForrestClassifier()这样的算法都有自己的 random_state 参数，这些参数没有被设置。如果你实例化一个分类器，然后像我们在上面代码中的 *for* 循环中所做的那样反复拟合，TPOT 并不总是找到相同的结果。我在 random_state 设置和 Kaggle 的 GPU 设置打开的情况下运行了三组非常小的 60 条管道。请注意，我们得到的管道略有不同，因此三个测试集的测试集得分也略有不同。下面是另一个例子，有少量的管道设置了随机状态，并使用了 Kaggle 的 CPU 设置。``` Times: [2.8874817832668973, 0.043678393283335025, 0.04388708711679404] Scores: [0.9622222222222222, 0.9622222222222222, 0.9622222222222222] Winning pipelines: [Pipeline(memory=None,steps=[('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,learning_rate=0.5, loss='deviance', max_depth=2,max_features=0.15000000000000002, max_leaf_nodes=None,min_impurity_decrease=0.0, min_impurity_split=None, ....9500000000000001, tol=0.0001,validation_fraction=0.1, verbose=0, warm_start=False))]), Pipeline(memory=None,steps=[('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,learning_rate=0.5, loss='deviance', max_depth=2,max_features=0.15000000000000002, max_leaf_nodes=None,min_impurity_decrease=0.0, min_impurity_split=None, ....9500000000000001, tol=0.0001,validation_fraction=0.1, verbose=0, warm_start=False))]), Pipeline(memory=None,steps=[('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,learning_rate=0.5, loss='deviance', max_depth=2,max_features=0.15000000000000002, max_leaf_nodes=None,min_impurity_decrease=0.0, min_impurity_split=None, ....9500000000000001, tol=0.0001,validation_fraction=0.1, verbose=0, warm_start=False))])] ```三次都发现了相同的管道。注意，在第一次迭代之后，运行时间要快得多。TPOT 似乎确实记得它什么时候见过一个算法，并且不会重新运行它，即使它是第二次拟合，并且你已经设置了 memory=False。如果设置 verbosity=3，当它找到这样一个以前评估过的管道时，您将看到以下内容:``` Pipeline encountered that has previously been evaluated during the optimization process. Using the score from the previous evaluation. ```## 运行时间更长，精确度更高如果制造大量管道，TPOT 怎么办？要真正看到 TPOT 在 MNIST 数字任务中的威力，你需要运行 500 多条管道。如果在 Kaggle 上运行，这至少需要一个小时。然后，您将看到更高的准确度分数，并可能看到更复杂的模型。如果你有大量的管道和一项重要的任务，你可能会看到一个机器学习算法的输出进入另一个算法的链式或堆叠式集合。``` 0.9950861171999883knn = KNeighborsClassifier(DecisionTreeClassifier(OneHotEncoder(input_matrix, OneHotEncoder__minimum_fraction=0.15, OneHotEncoder__sparse=False), DecisionTreeClassifier__criterion=gini, DecisionTreeClassifier__max_depth=5, DecisionTreeClassifier__min_samples_leaf=20, DecisionTreeClassifier__min_samples_split=17), KNeighborsClassifier__n_neighbors=1, KNeighborsClassifier__p=2, KNeighborsClassifier__weights=distance) ```在运行了一个多小时并生成了 600 多条管道后，这是 0.995 的平均内部 CV 准确度分数。内核在完成之前崩溃了，所以我没有看到测试集的分数，也没有得到输出的模型，但是这对 TPOT 来说看起来很有希望。该算法使用决策树分类器，将 TPOT 定制的 OneHotEncoder 分类编码输入 KNeighborsClassifier。这是一个类似的内部分数，不同的管道来自于近 800 个管道后的一个不同的 random_state。``` 0.9903723557310828 KNeighborsClassifier(Normalizer(OneHotEncoder(RandomForestClassifier(MinMaxScaler(input_matrix), RandomForestClassifier__bootstrap=True, RandomForestClassifier__criterion=entropy, RandomForestClassifier__max_features=0.55, RandomForestClassifier__min_samples_leaf=6, RandomForestClassifier__min_samples_split=15, RandomForestClassifier__n_estimators=100), OneHotEncoder__minimum_fraction=0.2, OneHotEncoder__sparse=False), Normalizer__norm=max), KNeighborsClassifier__n_neighbors=4, KNeighborsClassifier__p=2, KNeighborsClassifier__weights=distance) ```TPOT 发现了一个 KNN 管道，一个热编码，规范化和随机森林。花了两个半小时。前一个更快，得分更高，但有时这就是 TPOT 遗传搜索算法的随机性质。😉## MNIST 数字分类任务的要点1. 如果你给它足够的时间，TPOT 可以很好地完成这个图像识别任务。 2. TPOT 管道越多越好。 3. 如果你需要任务的再现性，TPOT 不是你想要的工具。# 数据集 2:蘑菇分类对于第二个数据集，我选择了流行的[蘑菇分类任务。](https://www.kaggle.com/mokosan/mushroom-classification/data)目标是根据标签正确确定蘑菇是否有毒。这不是图像分类任务。它被设置为一个二元任务，这样所有潜在危险的蘑菇被归为一类，而安全食用蘑菇则归为另一类。Yummy or deadly? Ask TPOT.我的代码可以在[这个 Kaggle 内核](https://www.kaggle.com/discdiver/tpot-mushroom-classification-task/)上获得。TPOT 通常可以在这个数据集上快速拟合出一个完美的模型。它在两分钟之内就完成了。这比我在没有 TPOT 的情况下使用许多 scikit-learn 分类算法、各种名义数据编码和无参数调整测试该数据集时的性能和速度好得多。在使用相同的 TPOTClassifier 实例和相同的随机状态集的三次运行中，TPOT 发现了以下情况:``` Times: [1.854785452616731, 1.5694829618000463, 1.3383520993001488] Scores: [1.0, 1.0, 1.0] ```有趣的是，它每次都找到不同的最佳算法。它找到了 DecisionTreeClassifier，然后是 KNeighorsClassifier，然后是带有 BernoulliNB 的堆叠 RandomForestClassifier。让我们更深入地探讨一下可再现性。让我们用完全相同的设置再运行一次。``` Times: [1.8664863013502326, 1.5520636909670429, 1.3386059726501116] Scores: [1.0, 1.0, 1.0] ```我们看到同一组三个管道，非常相似的时间，测试集上相同的分数。现在让我们试着将这个单元分成多个不同的单元，并在每个单元中实例化一个 TPOT 实例。代码如下:``` X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.75, test_size=0.25, random_state=25)tpot = TPOTClassifier(verbosity=3, scoring=”accuracy”, random_state=25, periodic_checkpoint_folder=”tpot_mushroom_results.txt”, n_jobs=-1, generations=5, population_size=10,early_stop = 5 ) ```第二次运行的结果现在与第一次运行的结果相匹配，并且花费了几乎相同的时间(分数= 1.0，时间= 1.9 分钟，管道=决策树分类器)。更高再现性的关键是我们在每个单元中实例化 TPOT 分类器的一个新实例。下面是 10 组 30 个流水线的时间结果，其中随机状态在训练测试分割上，TPOT 设置为 10。所有管道正确地对测试集上的所有蘑菇进行了分类。TPOT 在这项简单易学的任务上速度很快。# 蘑菇任务的收获对于这个基本的分类任务，TPOT 表现得又好又快。作为比较，[R 中蘑菇集上的这个 Kaggle 内核](https://www.kaggle.com/mokosan/mushroom-classification/notebook)非常好，探索了各种算法，非常接近完美的精度。但是，它并没有完全达到 100%,与我们实施 TPOT 相比，它确实花费了更多的准备和培训时间。我强烈认为 TPOT 可以为将来这样的任务节省时间，至少作为第一步。# 数据集 3:埃姆斯住宅预测接下来，我们转向回归任务，看看 TPOT 的表现。我们将使用流行的[爱荷华州艾姆斯房价预测数据集](https://www.kaggle.com/c/house-prices-advanced-regression-techniques)来预测房产销售价值。我的代码可以在[这个 Kaggle 内核](https://www.kaggle.com/discdiver/tpot-on-ames-housing-regression/)上获得。This house could be in Ames, Iowa, right?对于这个任务，我首先做了一些基本的缺失值插补。我用该列中最常见的值来填充缺失的数字列值，因为其中一些列包含序号数据。随着时间的推移，我会对列进行分类，并根据区间、序数或名义数据类型使用不同的插补策略。在顺序编码之前，字符串列缺失值用“缺失”标签填充，因为并非所有列都有最常见的值。TPOT 的 one hot 编码算法将为每个特征增加一个维度，这将表明该数据缺少该特征的值。TPOTRegressor 默认使用均方误差评分。这里有一个只有 60 条管道的运行。``` X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = .25, random_state = 33)# instantiate tpot tpot = TPOTRegressor(verbosity=3, random_state=25, n_jobs=-1, generations=5, population_size=10,early_stop = 5,memory = None) times = [] scores = [] winning_pipes = []# run 3 iterations for x in range(3):start_time = timeit.default_timer()tpot.fit(X_train, y_train)elapsed = timeit.default_timer() - start_timetimes.append(elapsed)winning_pipes.append(tpot.fitted_pipeline_)scores.append(tpot.score(X_test, y_test))tpot.export('tpot_ames.py')# output results times = [time/60 for time in times] print('Times:', times) print('Scores:', scores) print('Winning pipelines:', winning_pipes) ```这三次小试的结果。``` Times: [3.8920086714831994, 1.4063017464330188, 1.2469199204002508] Scores: [-905092886.3009057, -922269561.2683483, -949881926.6436856] Winning pipelines: [Pipeline(memory=None,steps=[('zerocount', ZeroCount()), ('xgbregressor', XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,max_depth=9, min_child_weight=18, missing=None, n_estimators=100,n_jobs=1, nthread=1, objective='reg:linear', random_state=0,reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,silent=True, subsample=0.5))]), Pipeline(memory=None,steps=[('xgbregressor', XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,max_depth=9, min_child_weight=11, missing=None, n_estimators=100,n_jobs=1, nthread=1, objective='reg:linear', random_state=0,reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,silent=True, subsample=0.5))]), Pipeline(memory=None,steps=[('stackingestimator', StackingEstimator(estimator=RidgeCV(alphas=array([ 0.1, 1\. , 10\. ]), cv=None, fit_intercept=True,gcv_mode=None, normalize=False, scoring=None, store_cv_values=False))), ('maxabsscaler-1', MaxAbsScaler(copy=True)), ('maxabsscaler-2', MaxAbsScaler(copy=True)), ('xgbr... reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,silent=True, subsample=0.5))])] ```运行很快完成，每次都找到不同的获胜管道。取分数的平方根得到均方根误差(RMSE)。RMSE 的平均价格在 3 万美元左右。对于 train_test_split 和 TPOTRegressor，尝试使用 60 个管道和 random_state = 20。``` Times: [9.691357856966594, 1.8972856383004304, 2.5272325469001466] Scores: [-1061075530.3715296, -695536167.1288683, -783733389.9523941]Winning pipelines: [Pipeline(memory=None,steps=[('stackingestimator-1', StackingEstimator(estimator=RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,max_features=0.7000000000000001, max_leaf_nodes=None,min_impurity_decrease=0.0, min_impurity_split=None,min_samples_leaf=12, min_sample...0.6000000000000001, tol=0.0001,validation_fraction=0.1, verbose=0, warm_start=False))]), Pipeline(memory=None,steps=[('xgbregressor', XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,max_depth=7, min_child_weight=3, missing=None, n_estimators=100,n_jobs=1, nthread=1, objective='reg:linear', random_state=0,reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,silent=True, subsample=1.0))]), Pipeline(memory=None,steps=[('stackingestimator', StackingEstimator(estimator=RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,max_features=0.7000000000000001, max_leaf_nodes=None,min_impurity_decrease=0.0, min_impurity_split=None,min_samples_leaf=12, min_samples_...ators=100, n_jobs=None,oob_score=False, random_state=None, verbose=0, warm_start=False))])] ```导致了截然不同的管道和分数。让我们用 720 条管道试一次更长的运行``` X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = .25, random_state = 20)tpot = TPOTRegressor(verbosity=3, random_state=10, #scoring=rmsle,periodic_checkpoint_folder=”any_string”,n_jobs=-1, generations=8, population_size=80,early_stop=5) ```结果:``` Times: [43.206709423016584] Scores: [-644910660.5815958] Winning pipelines: [Pipeline(memory=None,steps=[('xgbregressor', XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,max_depth=8, min_child_weight=3, missing=None, n_estimators=100,n_jobs=1, nthread=1, objective='reg:linear', random_state=0,reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,silent=True, subsample=0.8500000000000001))])] ```RMSE 是迄今为止最好的。收敛花了大半个小时，我们仍然在运行比推荐的小得多的管道。🤔接下来，让我们尝试使用均方根对数误差，这是 Kaggle 在本次比赛中使用的自定义评分参数。这是在另一个非常小的迭代中运行的，30 个管道分三次运行，random_state=20。我们不能使用一个以上的 CPU 核心，因为在 Jupyter 的一些 TPOT 算法中有一个自定义评分参数的错误。``` Times: [1.6125734224997965, 1.2910610851162345, 0.9708147236000514] Scores: [-0.15007242511943228, -0.14164770517342357, -0.15506057088945932] Winning pipelines: [Pipeline(memory=None,steps=[('maxabsscaler', MaxAbsScaler(copy=True)), ('stackingestimator', StackingEstimator(estimator=RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,max_features=0.7000000000000001, max_leaf_nodes=None,min_impurity_decrease=0.0, min_impurity_split=None,...0.6000000000000001, tol=0.0001,validation_fraction=0.1, verbose=0, warm_start=False))]), Pipeline(memory=None,steps=[('extratreesregressor', ExtraTreesRegressor(bootstrap=False, criterion='mse', max_depth=None,max_features=0.6500000000000001, max_leaf_nodes=None,min_impurity_decrease=0.0, min_impurity_split=None,min_samples_leaf=7, min_samples_split=10,min_weight_fraction_leaf=0.0, n_estimators=100, n_jobs=None,oob_score=False, random_state=None, verbose=0, warm_start=False))]), Pipeline(memory=None,steps=[('ridgecv', RidgeCV(alphas=array([ 0.1, 1\. , 10\. ]), cv=None, fit_intercept=True,gcv_mode=None, normalize=False, scoring=None, store_cv_values=False))])] ```那些分数并不可怕。这个小运行的 tpot.export 的输出文件如下。``` import numpy as np import pandas as pd from sklearn.linear_model import ElasticNetCV, LassoLarsCV from sklearn.model_selection import train_test_split from sklearn.pipeline import make_pipeline, make_union from tpot.builtins import StackingEstimator # NOTE: Make sure that the class is labeled 'target' in the data file tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64) features = tpot_data.drop('target', axis=1).values training_features, testing_features, training_target, testing_target = train_test_split(features, tpot_data['target'].values, random_state=42) # Score on the training set was:-0.169929041242275 exported_pipeline = make_pipeline( StackingEstimator(estimator=LassoLarsCV(normalize=False)), ElasticNetCV(l1_ratio=0.75, tol=0.01) exported_pipeline.fit(training_features, training_target) results = exported_pipeline.predict(testing_features) ```将来，我想在这个数据集上对 TPOT 做一些更长时间的运行，看看它的表现如何。我还想看看一些手动特征工程和各种编码策略如何提高我们的模型性能。# 抓到 TPOT 和卡格尔了我喜欢 Kaggle 的内核，但如果你想运行几个小时的算法，如 TPOT，这可能会超级令人沮丧。内核在运行时经常崩溃，你有时无法判断你尝试的提交是否被挂起，并且你不能像你希望的那样控制你的环境。Wall for banging head没有什么比 720 次管道迭代中的 700 次更好的了。我的 Kaggle CPU 利用率经常显示为 400%+并且在这个练习中需要多次重启。其他一些需要注意的事项:* 我发现我需要将我的 Pandas 数据帧转换成 Numpy 数组，以避免回归任务中的 XGBoost 问题。这是熊猫和 XGBoost 的一个已知问题。 * 一个 Kaggle 内核正在运行一个 Jupyter 笔记本。当 Jupyter 笔记本中的 n _ jobs > 1 时，TPOT 的自定义评分分类器不起作用。这是一个已知的[问题](https://github.com/EpistasisLab/tpot/issues/645)。 * 当你提交代码时，Kaggle 只会让你的内核代码写到一个输出文件。你看不到 TPOT 提交时的临时输出。确保文件名用引号括起来，不要用斜线。该文件将显示在 O *输出*选项卡上。 * 在 Kaggle 上打开 GPU 设置并不能加快大多数分析的速度，但可能会加快深度学习的速度。 * ka ggle 6 小时的可能运行时间和 GPU 设置使得在非大型数据集上无需配置即可免费实验 TPOT 成为可能。很难拒绝免费的。为了更多的时间和速度，你可以使用类似于 [Paperspace](https://www.paperspace.com/) 的东西。我在 Paperspace 上建立了 TPOT，虽然不是免费的，但也很轻松。如果你需要一个云解决方案来运行 TPOT，我建议你先在 Kaggle 上使用它，如果你需要几个小时以上的运行时间或更高的功率，就离开 Kaggle。# 未来方向TPOT 和 autoML 有很多有趣的方向可以探索。我想将 TPOT 与 autoSKlearn、MLBox、Auto-Keras 和其他公司进行比较。我还想看看它在处理更多种类的数据、其他插补策略和其他编码策略时的表现。与 LightGBM、CatBoost 和深度学习算法的比较也将是有趣的。机器学习的这个时刻令人兴奋的是，有这么多领域可以探索。关注 [me](https://medium.com/@jeffhale) 确保不会错过未来的分析。对于大多数数据集来说，仍然有大量的数据清理、特征工程和最终模型选择要做——更不用说预先提出正确问题这一最重要的步骤。那么你可能需要生产你的模型。TPOT 还没有进行彻底的搜索。所以 TPOT 不会取代数据科学家的角色——但这个工具可能会让你最终的机器学习算法更好更快。如果你使用过 TPOT 或其他 autoML 工具，请在评论中分享你的经验。我希望这篇介绍 TPOT 的文章对你有所帮助。如果你有，请在你最喜欢的社交媒体上分享，这样其他人也可以找到它。😀我写关于 [Python](https://memorablepython.com) 、 [SQL](https://memorablesql.com) 和其他技术主题的文章。如果你对这些感兴趣，请注册我的[邮件列表，那里有很棒的数据科学资源](https://dataawesome.com)，点击阅读更多内容，帮助你提高技能[。👍](https://medium.com/@jeffhale)[](https://dataawesome.com)投票快乐！🚀# 永久跟踪> 原文：<https://towardsdatascience.com/tracking-for-good-db4809c9f456?source=collection_archive---------3----------------------->**Top Left: Total Productive Hours | Top Right: Total Miles Travelled | Bottom Left: Total Blog Posts | Bottom Right: Total Duolingo EXP**## 我虔诚地使用 Beeminder 一个月所学到的。大约在过去的三十天左右，我一直在自己身上做实验。我试图努力追踪我生活的方方面面。可以说，这是我在吃自己的狗粮——过着一种在抽象层面上感觉良好的准动机生活。这是一个案例研究，这些是我的想法和结果。*这是对我之前文章的更新:*[](https://medium.com/@brennanbrown/planning-better-e0d60edbe271) [## 如何更好地创造和计划### 使用互联网和蜜蜂medium.com](https://medium.com/@brennanbrown/planning-better-e0d60edbe271) ## 一.自我跟踪的初始问题虽然我多年来一直是自我量化的粉丝，但我从未深入研究过。这有几个原因:*预先警告:我并不精通数据科学，这些论文只是我通过观察哪些对我有用，哪些没用，艰难地发现的东西。*1. **错误的数据集**。需要深入了解你自己和你每天实际使用的工具，才能知道你应该跟踪什么指标。我没能在[*Todoist*](https://en.todoist.com/app?lang=en)*——*上追踪我的待办事项清单，只是因为我意识到我是那种只会把工作写在纸上的人。) 2. **缺乏意义。类似地，追踪你追踪的东西必须有充分的理由——追踪必须能提供某种有益的帮助。一个强有力的、基于价值的目标会激励你坚持定期追踪。** 3. **缺乏威慑/鼓励**。对于*没有*做你想追踪的事情，应该有一个固有的惩罚，对于做了这件事，应该有一个奖励*。* 4. 缺乏自动化。在大多数情况下，我的数据集是用 API 或 [*IFTTT*](https://ifttt.com/discover) 收集的，或者有非常简单快速的手动输入。数据收集不应该是一件苦差事。 5. **数据不一致**。你所追踪的东西必须能够在一致的基础上产生数据。如果太频繁，你会太专注于跟踪本身。如果太不频繁，你最终会忘记跟踪。所有这些都是我发现 [Beeminder](https://medium.com/u/e60c422184be?source=post_page-----db4809c9f456--------------------------------) 对自我量化如此有效的原因。在大多数情况下，应用程序会为您完成所有的跟踪工作。你所要做的就是*的工作。* Beeminder 是一种[的关键习惯](http://jamesclear.com/keystone-habits)，如果你能养成在 Beeminder 上签到的习惯，你就可以把它作为你想改变或开始的任何其他习惯的起点。## 二。蜜蜂之道1. 想清楚你想在生活中改变什么。所有的自我量化跟踪都应该从这里开始。坚定的目标就是一切。例 1。*我想多写点。*例二。我想更积极地锻炼身体。 2. **找出定性目标有意义的量化。不要让含糊不清让你溜了——给你想要完成的事情一个确切的数字。例 1。*我想一年写 10 万字。*例二。我想一年跑/走 500 公里。** 3. 将你的定性目标转化为日常系统。上面的那些目标看起来令人畏惧，但是当你分解它们的时候，它们实际上更容易实现。例 1。 *10 万字/ 365 天≈每天 275 字*例 2。 *500 公里/ 365 天≈每天 1800 步* 4. 想办法跟踪这个新的每日系统。现在有很多针对特定指标的应用程序和工具，通常都有完善的 API，可以轻松传输和绘制数据。例 1。*利用*[*draft . in*](https://draftin.com)*同步 Beeminder 上的每日字数。*例二。*利用众多* [*健身应用*](http://www.active.com/fitness/articles/17-best-health-and-fitness-apps-of-2017) *和* [*可穿戴设备*](https://www.wareable.com/fitness-trackers/the-best-fitness-tracker) *在 Beeminder 上同步每日步数。*## 三。我在追踪什么[手动输入的一个很大的好处是，它可以作为我实现其他 Beeminder 目标的日常检查。](https://www.beeminder.com/brennanbrown/gratitude)[**写作**](https://www.beeminder.com/brennanbrown/writing) :另一个手动输入，这是我每天写的字数，每个数据点具体说明我主要写的是什么。通常要么只是日常日志写作或博客帖子。[**博客文章**](https://www.beeminder.com/brennanbrown/blogging) :跟踪我上传到 Medium 的文章数量。与其他活动不同，我追溯性地添加了我在 Medium 上的所有旧帖子，这些数据让我明白我真的需要开始发布更多。[**生产性**](https://www.beeminder.com/brennanbrown/productivity) **/** [**非生产性**](https://www.beeminder.com/brennanbrown/distraction) **时间:**这两者都通过时间记录器 RescueTime 进行跟踪。我试图每天完成一定数量的有成效的工作，无论是写作、编程还是参考/学习。我也试着限制我浪费在无脑和无结果的活动上的时间。[](https://www.beeminder.com/brennanbrown/fitness)**:记录我旅行的英里数，无论是走路、跑步还是骑自行车。我用 *Runkeeper* 追踪这个，没有花哨的可穿戴。它不计算我所有的旅行，只有当我特别记录一项活动时，它还会给我一张我的路线的 GPS 地图，这样我就可以看到那天我去了哪里。****[**编程**](https://www.beeminder.com/brennanbrown/github) :跟踪我推送到 GitHub 的提交数量(以及其他贡献，如报告的问题和拉请求)。我承认这不是最好的跟踪方式，因为代码在达到适合部署的程度之前不应该提交，但我目前正在开发 [*熨斗学校*](https://flatironschool.com/) 的课程，它会自动将我的作业实验室推送到我的 GitHub 帐户，这很酷。****社交媒体( [**)推特**](https://www.beeminder.com/brennanbrown/tweets)**/**[**insta gram**](https://www.beeminder.com/brennanbrown/photos)**)**:这可能对一些人来说是违反直觉的，但我很少使用任何社交媒体。通过跟踪我上传的照片和我写的推文，我被鼓励去寻找每天发生的有趣的事情，并与我的朋友和家人分享。****[**语言学习**](https://www.beeminder.com/brennanbrown/french) :追踪我在 Duolingo 上赚取的经验值。在过去的几年里，我一直在努力自学法语，虽然很难，但每天练习一点点对我记忆的帮助远远超过了偶尔的补习班。**## **四。每日系统****以下是我在 Beeminder 上追踪的事情，展示我今天的样子。这实质上是将理论付诸实践，并落笔。事实是，除了编程，这些习惯根本不会占用我一天的太多时间，事实上，我因此有了更多的时间放松或尝试新事物。**1. **以写下我感激的事情开始新的一天，并检查我在当前目标上的进展。** 2. **花十五或二十分钟在 Duolingo 和 TinyCards 上练习我的法语。** 3. **在我家附近散步或骑自行车。外出时拍摄任何有趣的东西。** 4. **花一两个小时编程。学习新的东西，很好的文档化，然后推送到 GitHub 上。** 5. **不要浪费时间漫无目的地浏览脸书或 Reddit。节约使用屏幕时间，当我想休息的时候做一些我真正喜欢的事情。(看一部纪录片，玩一个电子游戏，等等。)** 6. **花半个小时写我的日记或者写一篇博客。** 7. **在一天结束时，写一篇关于一天中发生的任何有趣事情的推文。**## **动词 （verb 的缩写）最后的想法*** **不要承诺任何不能让你兴奋的事情。对你的目标有自由意志的心理是必不可少的。如果你觉得你做的事情不仅仅是为了你自己，这将会是另一件苦差事。不要因为别人认为你应该而承诺什么。只有你。** * **对自己负责。我在我的脸书和推特个人资料里放了一个我的 Beeminder 账户的公开链接，这样任何人都可以看到我是否没有实现目标。我也写了这篇文章。利用公众压力作为动力和行善的工具。** * **任何事物都不会自己到位。自我的拼图有很多块，可能不会一下子全部拼起来。没有放之四海而皆准的方法，适合我的不一定适合你。T2 的普遍现象是良好价值观的重要性——如果你努力工作，幸运的 T4 法则最终会对你有利。** * **你的第一次尝试总是很糟糕。与上面类似，当你第一次尝试的时候，不要期望能搞定任何事情。我使用 Beeminder 快两年了，刚刚掌握了它的窍门。所有东西的初稿——不仅仅是写作——都将是垃圾。** * ****慢行。我没有尝试一下子开始追踪所有的事情。我从最小和最容易的(我已经在做的事情)开始，每周添加一些新的东西。如果经过一周的跟踪，我发现有些东西不好用了，我会直接删除它。没什么大不了的。**** * **成功的灵丹妙药就是认识到没有灵丹妙药。这只是许多艰苦的工作，并弄清楚如何为做这些艰苦的工作感到快乐。**# 使用 Kafka Streams 跟踪纽约市 Citi Bike 的实时利用率> 原文：<https://towardsdatascience.com/tracking-nyc-citi-bike-real-time-utilization-using-kafka-streams-1c0ea9e24e79?source=collection_archive---------8----------------------->## 卡夫卡流的实际使用案例“Blue Citibike bicycles are parked in a row at the World Trade Center.” by [Anthony Ginsbrook](https://unsplash.com/@aginsbrook?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)说到构建分布式实时流处理系统，我们是 Apache Kafka 的忠实粉丝。它可大规模扩展，具有简单的发布-订阅语义，并提供容错的持久数据存储。这是一个处理事件流数据的绝佳平台，例如点击事件、分布式日志、时间序列指标等。我们在之前的一篇文章中写过关于使用 Apache Kafka 构建实时分析的文章。但是在大多数用例中，数据流不是孤立处理的。当收到 Kafka 消息时，经常会查询一些有状态数据存储，以便获得足够的信息来处理该消息。例如，如果我们有一个接收客户订单的订单流，该订单很可能需要使用客户信息和/或产品元数据查询数据库才能进行处理，那么流数据如何与有状态数据(如数据库表)一起工作呢？这就是《T2》和《T3》出现的原因。Kafka Streams 是一组应用程序 API(目前在 Java & Scala 中)，无缝集成了无状态(流)和有状态(表)处理。这个设计的基本前提非常有趣。简而言之，它基于这样一个事实，即可以从变更数据捕获(CDC)流或事务日志记录中重建表。如果我们有一个变更日志流，那么表就是一个反映每个变更记录最新状态的本地存储。有了这个概念，流-流或流-表连接成为通过各种内部 Kafka 主题路由数据的统一操作。默认情况下，RocksDB 用于本地有状态存储，但也可以使用其他键值数据库。我鼓励你去读一下[的博客文章，这篇文章解释了设计卡夫卡作品的动机。这让我大开眼界。](https://www.confluent.io/blog/introducing-kafka-streams-stream-processing-made-simple/)在本帖中，我们将使用 Kafka Streams 来跟踪纽约市花旗自行车使用率的实时统计数据。CitiBikeNYC 发布了包含自行车出行的历史数据集和每个自行车站点信息和可用性的实时 [GBFS 反馈](http://gbfs.citibikenyc.com/gbfs/gbfs.json)。虽然历史数据集是洞察的宝库，但通过实时数据馈送可以更好地获得一些利用率指标。我们将计算两个重要的利用率实时指标。1. 目前可用自行车少于 10%的站点，计算方法为(可用自行车数量)/(站点容量)。该指标可以作为自行车可用性低的实时通知。 2. 每小时自行车周转率最高的站点，在滚动窗口中通过(站点自行车净变化)/(站点容量)计算。该指标可用于微调花旗自行车站再平衡战略。数据流看起来像这样。现在让我们开始编码。首先，由于 Citi Bike feed 是一个 Restful API，我们需要添加一个 Java 应用程序来轮询端点，并将 JSON 响应转换为流并发布到 Kafka 主题上。station_information 和 status JSON 的示例如下所示我们使用 [google http java 客户端](https://developers.google.com/api-client-library/java/google-http-java-client/)将 http 响应转换成 POJO(普通旧 java 对象)。然后我们将 station_information 和 statuses 对象的列表序列化为 string，并分别发布到它们命名的 Kafka 主题中。关于向/从 Kafka 序列化/反序列化消息注释。对于生产级系统，Apache Kafka Streams API 使用基于 [avro](https://avro.apache.org/docs/current/) 的序列化，并使用[模式注册表](https://docs.confluent.io/current/schema-registry/docs/index.html)存储 avro 模式。我觉得对于这篇文章来说，这增加了很多不必要的麻烦，所以我把这部分去掉，尽可能使用基于字符串的序列化模式。如果你对基于 Avro 的 SerDes(序列化/反序列化)感兴趣，请查看 [Avro Serdes 类](https://kafka.apache.org/10/documentation/streams/developer-guide/datatypes.html#avro)。现在我们有了来自 station_information 和 station_status 主题的数据流，让我们看看如何找到自行车利用率低于 10%的站点。完整的代码是[这里是](https://github.com/cloudboxlabs/blog-code/blob/master/citibikekafkastreams/src/main/java/com/cloudboxlabs/LowAvailability.java)。首先，我们用一系列配置构造一个 KakfaStreams 对象，包括 Kafka 引导服务器、文件系统上的本地状态和 Kafka 消费者选项。然后，我们可以连接转换的每个步骤，就像我们正在构建一个流数据管道一样。1. 从 Kafka 主题 status 的输入构建一个 KStream。我们大量使用 Java8 Lambda 表达式，将输入流数据映射到 POJO，并提取 num_bikes_available 指标2.从 Kafka 主题 station_information 的输入构建一个 KTable。您可能会问，为什么我们使用 KStream 表示站点状态，而使用 KTable 表示站点信息。还记得流和表二元性吗？表是变更事件流的结束状态。在这种情况下，我们希望捕捉每个站点的状态变化，因为它告诉我们可用自行车的数量如何随时间变化。另一方面，站点信息是静态数据，包括容量、名称、地理位置等。我们只关心每条数据的最新值，因此 KTable 允许我们将一系列更改压缩到最终快照中。3.现在是“这里发生了什么神奇的事情？”部分。让我们在 KStream 和 KTable 上做一个左连接。请记住，我们的指标是(可用自行车数量)/(车站容量)。分子来自 station_status 对象，但分母来自 station_information 对象，因此我们需要在这里做一个流表连接。这就是卡夫卡溪流的力量所在。能够在没有大量代码的情况下将一个不断发展的数据流与一个静态的本地存储连接起来是非常简单的。在加入流之后，我们过滤计算出的小于 10%的可用性，并将数据映射到人类可读的输出字符串。4.这一步并不是绝对必要的，但我们最终会将分析结果发布到 Kafka 的输出主题上，这样我们就可以检查它们了。5.如果我们启动一个控制台 Kafka 消费程序，我们可以看到输出如下``` station_id: 3699, longitude -73.98918, latitude 40.763603, bikes: 1, capacity: 30, ratio: 3.33% station_id: 3700, longitude -73.95334, latitude 40.779408, bikes: 3, capacity: 39, ratio: 7.69% station_id: 3704, longitude -73.941765, latitude 40.74375, bikes: 1, capacity: 19, ratio: 5.26% ```现在，让我们来看看如何在会话窗口中计算周转率。我们有类似的步骤来建立站信息和站状态的 KStream/KTable。这里的代码是。1. 我们计算的分析是(可用自行车数量的净变化)/ (station_capacity)，因此我们在这里引入了一个窗口聚合，我们可以折叠每个分组状态并计算净增量。聚合器接口接受一个初始化器和一个累加器。这类似于函数式编程中的 fold()或 reduce()操作。2.既然计算了自行车的窗口化净变化，让我们再次连接 station_information KTable，并将我们的分析输出到输出主题。3.输出如下所示。注意，本例中的关键字是一个窗口<string>，因为我们在流上应用了一个滚动窗口。</string>``` station_id: [472@1535061600000/1535065200000], turnover: 72.22% station_id: [473@1535061600000/1535065200000], turnover: 81.40% station_id: [474@1535061600000/1535065200000], turnover: 5.13% station_id: [476@1535061600000/1535065200000], turnover: 8.47% station_id: [477@1535061600000/1535065200000], turnover: 55.32% ```为了运行代码，按照这里的快速入门启动 Zookeeper、Kafka，创建主题并运行 Java 应用程序。总之，我们如何看待在实践中使用卡夫卡作品？答案是“看情况”。这要看你的数据是什么样子，业务逻辑有多复杂。Kafka Streams 站在 Apache Kafka 这个巨人的肩膀上，因此它无疑具有大规模分布式流数据平台的可扩展性和弹性。我们可以轻松地交替使用流数据和有状态数据，这说明了库 API 的设计有多好。如果你的数据在形式上非常简单，比如统计点击事件，排名页面浏览量，这是实时数据分析的一个很好的选择。另一方面，由于 Kafka Streams 的内部使用 Kafka pub-sub 作为存储主干，您必须不断地考虑如何在数据管道的每个阶段序列化/反序列化您的数据。这意味着如果你在你的应用程序中使用了大量的 POJO(Plain old java object ),你就有了额外的任务来指定如何序列化它们，以便将它们传递到管道中，不管是不是 Avro 模式。虽然可以理解，但它增加了额外的复杂性，我不确定在业务逻辑繁重的应用程序中这样做是否值得。在撰写本文时，Kafka Streams 没有基于 python 的 API，因此对于执行大量分析的数据科学家来说，这是一个非常陡峭的学习曲线。一如既往，你可以在 [Cloudbox Labs github](https://github.com/cloudboxlabs/blog-code/tree/master/citibikekafkastreams) 上找到这篇文章中讨论的完整代码。# 自动驾驶汽车跟踪行人> 原文：<https://towardsdatascience.com/tracking-pedestrians-for-self-driving-cars-ccf588acd170?source=collection_archive---------1----------------------->*第四章:用数据做酷事！*自动驾驶汽车在行驶时需要周围的世界地图。它必须能够连续跟踪路上的行人、汽车、自行车和其他移动物体。在这篇文章中，我将通过一种称为扩展卡尔曼滤波器的技术进行讨论，谷歌自动驾驶汽车正在使用这种技术来跟踪道路上的移动物体。下面是一个汽车在模拟器中跟踪行人的视频。激光雷达测量值为红色圆圈，雷达测量值为蓝色圆圈，估算标记为绿色三角形。有趣的是，与雷达相比，激光雷达的精确度有多高。经过一些试验，卡尔曼滤波器的精度可以提高到 0.09 的均方根误差。Kalman Filter in action链接到我的 [**GitHub**](https://github.com/priya-dwivedi/CarND/tree/master/Term%202/CarND-Extended-Kalman-Filter-P1) 用 C++实现上述视频的完整代码。在讨论卡尔曼滤波器之前，我想先谈谈汽车中使用的三种主要传感器——摄像头(前后)、激光雷达和雷达。Car Sensors — Camera, LIDAR and RADAR激光雷达使用激光进行测量，并生成周围世界的点云，为汽车提供相当准确的 x 位置和 y 位置值。它能够以非常高的精度探测汽车附近(20-40 米)的物体。然而，激光雷达在恶劣的天气条件下或传感器变脏时不是很准确。激光雷达云看起来像:LIDAR point cloud另一方面，雷达不太精确，但是能够提供对物体的位置和速度的估计。速度是使用多普勒效应估计的，如下图所示。雷达能够探测到离汽车 200 米远的物体。它也不易受天气条件的影响。RADAR estimating velocity of a car using Doppler effect卡尔曼滤波器是一种算法，可用于跟踪一段时间内移动行人的位置和速度，并测量与之相关的不确定性。它有两个主要步骤——一个**预测步骤**,预测行人在下一个时间步可能在哪里，假设他们以恒定的速度移动；一个**更新步骤**,使用传感器数据(激光雷达和雷达)更新我们的估计。并且这两个步骤无休止地重复。让我们更详细地讨论一下这个问题:首先，我们将行人的状态指定为一个四维向量，表示-位置 x，位置 y，速度 x，速度 y。以下是卡尔曼滤波器的主要步骤:1. 初始化 t=0 时行人的状态。我们通过读取传感器的第一个测量值来估计我们的位置和速度 2. 预测步骤——在 t=1 时，我们使用简单的物理方程来估计物体在恒定运动(固定速度，无加速度)下的可能位置> px(t+1 时)= px(t 时)+ vx* dt(时间差) > > vx(在 t+1 时)= vx(在 t 时)类似地，我们可以更新我们的 y 位置和速度估计3.测量值更新步骤-现在我们从雷达和激光雷达读取测量值，并使用它来更新我们在步骤 2 中计算的行人状态估计值。测量步骤后的新状态用于下一个预测步骤。如下图所示，此过程不断重复以更新当前状态:另一件要注意的事情是，在卡尔曼滤波器中，行人的状态被估计为具有均值和协方差的高斯(钟形曲线)。这是 1D 和 2D·高斯的长相:1 D Gaussian2D Gaussian这里有个有趣的问题？—如果我们有传感器测量，为什么还需要进行预测？用传感器(激光雷达/雷达)测量来更新状态不是最好的吗？这些应该很准确。对吗？不尽然！测量也可能有不确定性。设备制造商提供了传感器测量噪声的信息。此外，像雨/雾这样的局部环境条件会使传感器不太精确。不要盲目相信测量结果，这是一个很好的做法。通过组合信息，用于预测和测量的高斯函数成倍增加，当这种情况发生时，最令人惊奇的事情发生了，由此产生的不确定性降低了，如下所示。卡尔曼滤波方程有点复杂，你可以在维基百科上查看我还构建了一个无味卡尔曼滤波器，它能够适应非线性运动，并且在预测行人的状态时更加准确。我的 [Github](https://github.com/priya-dwivedi/CarND/tree/master/Term%202/CarND-Unscented-Kalman-Filter-P2) 也有 C++内置的无味卡尔曼滤波器。总的来说，构建我的第一个卡尔曼滤波器并使用它跟踪物体是一次很棒的经历，我对结果非常满意。**其他著述**:[https://medium.com/@priya.dwivedi/](https://medium.com/@priya.dwivedi/)PS:我住在多伦多，我希望将职业生涯转向深度学习。如果你喜欢我的帖子，并能把我联系到任何人，我将不胜感激:)。我的电子邮件是 priya.toronto3@gmail.com**参考文献:**[Udacity](https://www.udacity.com/) 无人驾驶汽车 Nano Degree——我感谢 Udacity 给我机会成为他们新的无人驾驶汽车项目的一部分。这是一次非常有趣的旅程。我使用的大部分代码都是在课堂讲课中建议的。# 使用机器学习跟踪街头艺术-更新> 原文：<https://towardsdatascience.com/tracking-street-art-with-machine-learning-updates-b6b24062d3d3?source=collection_archive---------11----------------------->Mural from Reyes, Revok and Steel from MSK ([https://www.fatcap.com/live/revok-steel-and-reyes.html](https://www.fatcap.com/live/revok-steel-and-reyes.html))感谢您关注[公共艺术](https://www.publicart.io)【⁰】项目，利用机器学习围绕街头艺术建立一个谱系。这个项目旨在创建一个记录世界各地街头艺术的中心，并使用现代图像分析技术为未来建立一个公共艺术的历史参考。Public Art iOS application作为一个快速更新，这个项目始于 2014 年，在 [Gary Chou 的轨道训练营](https://orbital.nyc/bootcamp/) [ ]期间，我建立了一系列小项目，探索软件和涂鸦如何在实验性的辅助项目中共存。其中一个副业项目是一项抓取 Instagram 图片的实验，并开发一个 iOS 来浏览你附近的街头艺术。这款功能不再完整的应用仍在 [iOS 应用商店](http://graffpass.com) [ ]。去年 8 月，我开始参加先锋锦标赛，这是一个每月一次的锦标赛，围绕着一个由全球各地从事有趣项目的有创造力的年轻人组成的社区。我决定通过整合我对机器学习的熟悉程度，围绕记录涂鸦重新开始这个项目。Kickstarter page9 月份，[我运行了一个“Quickstarter”，这是一个 100 美元的 Kickstarter 项目，令人惊讶的是，在朋友之外，我发现了一些完全陌生的人对这个项目感兴趣](https://www.kickstarter.com/projects/rememberlenny/new-public-art-foundation-a-genealogy-of-public-st/) [ ]。这个项目给了我进一步探索街头艺术和软件如何共存的信心。在同一个项目中，我开始继续从网上的公共资源中抓取更多的图片，同样，我发现我的旧方法有一个巨大的问题。虽然我仍然可以抓取 Instagram，就像我在 2014 年做的那样，但我需要用于历史目的的许多元数据不再可用。特别是，我没有地理数据，而地理数据是让这些图像变得有用的关键。我在这里简要地写了这个:[关于社交媒体的后中心化](https://medium.com/@rememberlenny/on-the-instagram-api-changes-f9341068461e)【⁴].PublicArt.io current website’s functional prototype从那以后，我把注意力从构建工具来抓取公共资源转移到构建一个可以在线存储公开记录的街头艺术的基础上。这将效仿许多已经在线的照片分享服务，灵感来自 Flickr、Instagram、Imgur 等等。这项服务的重点将仅仅是记录街头艺术，帮助收集艺术作品的图像，观看艺术家的作品，并向公众提供这些数据。我很自豪地宣布，来自乔治·梅森大学[⁶]墨卡托斯中心的[泰勒·考恩](http://marginalrevolution.com)[⁵]，已经将他的[新兴企业奖学金扩展到我的项目](https://marginalrevolution.com/marginalrevolution/2018/11/emergent-ventures-grant-recipients.html)[⁷].]Emergent Ventures虽然这个项目最初是个人资助的，但我对能够将我的时间扩展到构建工具上更有信心。有了这笔赠款，我相信我正在建造的东西有能力维持其成本并证明其价值。在我目前的探索状态之前，我正在尝试应用嵌入分析技术的图像特征提取工具来比较不同的街头艺术作品是如何相似还是不同。为了过度简化和简单解释:[图像特征提取工具](https://en.wikipedia.org/wiki/Feature_extraction)可以获取图像并量化单个参数的存在，其代表特征【⁸].该参数可以简化为一个单一的数字，然后可以跨图像进行比较。通过机器学习工具，特别是 [Tensorflow Inception 库](https://www.tensorflow.org/tutorials/images/image_recognition)【⁹】，可以从一张图像中提取数万个特征，然后用于与其他图像中的相似特征进行比较。通过这些嵌入，我能够产生非常有趣的三维空间视觉效果，展示某些艺术家是如何相似或不同的。[在最基本的情况下，模板涂鸦被映射到同一个维度空间，而涂鸦“炸弹”或更大的壁画会分别映射到相似的多维空间](https://twitter.com/rememberlenny/status/1038992069094780928)【⁰].在地理数据无法访问之前，我从 Instagram 上抓取了成千上万张图片，利用这些图片，[我分析了随着时间的推移，世界各地街头艺术的存在情况](https://twitter.com/rememberlenny/status/1058426005357060096) [ ]。由于 Instagram 的政策变化，这些数据不再与最初被编入索引的实际图像相关联，而是提供了对世界各地街头艺术和涂鸦的洞察。有趣的是，图像频率也提供了一种视觉，这种视觉回避了城市中心和街头艺术之间的明显关系。如果进一步分析，街头艺术和房地产价值、社区社会关系、政治参与和其他社会现象之间可能存在明显的相关性。在过去的几天里，我一直专注于综合我期望使用机器学习来分析街头艺术的各种手段。由于媒体对人工智能的歪曲以及机器学习在技术/营销领域的广泛意义，我自己也在纠结我的意思。在这个项目实施之前，我曾认为有可能建立物体检测模型来识别图像中不同类型的涂鸦。例如，故意破坏的表现不同于社区认可的壁画。我还想象有可能在更大的字母形式的涂鸦作品中找到识别特定字母的方法。我相信将定义良好的标签和数据集与一个可变的自动编码器相结合来生成基于机器学习的字母形式的片段会很有趣。更进一步，我认为有可能使用机器学习来检测一个地方的图像何时是“新的”，基于它在特定地方的先前图像中没有被检测到。我认为找到穿越美国的火车车厢的摄像头也很有趣，并建立一个管道来捕捉火车车厢上的涂鸦，识别火车车厢序列号，并跟踪火车车厢及其各自的艺术如何穿越这个国家。以上各点都是基于机器学习的分析技术的实际表达。虽然这些都是有趣的项目，但我暂时将我的注意力集中在以下六点上:识别艺术家的作品，跟踪类似的风格/影响，[地理定位图像](https://twitter.com/rememberlenny/status/1053626064738631681) [ ]，对风格进行分类，关联社会现象，并发现新的艺术。基于跟踪图像，内容，图像图像的频率，并使这些数据可供他人使用，我相信街头艺术可以创造更多的价值，并获得更多的尊重。基于最近的工作，我得到了一个功能齐全的应用程序，允许用户创建帐户，上传图像，将重要的元数据(艺术家/位置/创作数据)与图像相关联。虽然用户体验和设计不是我引以为豪的地方，但我会继续用现有的涂鸦鉴赏家测试当前的形式。当我继续分享这个项目时，如果你有任何兴趣或者想了解更多，请联系我。[0]:[https://www . public art . io](https://www.publicart.io) 【1】:[https://orbital.nyc/bootcamp/](https://orbital.nyc/bootcamp/) 【2】:[http://graffpass.com](http://graffpass.com) 【3】:[https://www . kickstarter . com/projects/remember Lenny/new-public-art-foundation-a-genetics-of-public-ST/updates](https://www.kickstarter.com/projects/rememberlenny/new-public-art-foundation-a-genealogy-of-public-st/updates) 【4】:[https://medium . com/@ remember Lenny/on-the-insta](https://medium.com/@rememberlenny/on-the-instagram-api-changes-f9341068461e)# 拖拉机、大数据和公司> 原文：<https://towardsdatascience.com/tractors-big-data-and-corporate-companies-ac40aaa46cee?source=collection_archive---------10----------------------->Photo by [Caique Silva](https://unsplash.com/@caiqueportraits?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)你好鲍勃鲍勃是一个农民。鲍勃是现代人，他有无人驾驶飞机、机器人和一辆闪亮的拖拉机帮助他耕种他的田地。不仅仅是帮助他，这些用于工业农业的工具产生数据，大量的数据。这些数据通常是 Excel 表格上的数百万个数字。它们可以提供关于温度、风速、水资源、土壤湿度、营养成分、植物健康等信息。这种快速产生的、廉价的、海量的数据对 Bob 来说没有任何意义。他能用它们做什么？**大数据，鲍勃和朋友们**[关于植物、气候和金融市场的数据](https://www.sciencedirect.com/science/article/pii/S0308521X16303754)对鲍勃来说是一个获得关于他的文化的最新和本地具体信息的绝佳机会。他的数据也与邻近农民的数据库进行比较。由于这一点，他可以精确地调整他的现场管理，以降低他的生产成本，增加他的利润。例如，Bob 知道他的植物每天的营养需求，因此他可以在正确的时间添加正确数量的肥料，而不会过度使用。当鲍勃掌握了商品市场的数据后，他可以在最佳时机出售他的作物，以获得最高利润。从数据中创建的信息使做出最佳决策变得更加容易，但是 Bob 无法独自管理所有这些数据，他需要专家的外部帮助。过去，那些专家是他的祖父和村里的智者；今天的专家属于私人公司。这些公司拥有存储、交换和分析大量数据的基础设施。数据的收集和交易是一项非常有利可图的活动。像 Acxiom 或 Experian 这样的数据经纪人专注于从世界各地获取数据，并对其进行管理和分发。它们确保了数据的可追溯性、匿名性和质量。数据分析师位于这个链条的末端。他们将数据转化为农民可以实施建议。数据分析创造了新的商业机会，吸引了愿意创建咨询机构的企业家来帮助农民增加利润。[印度的 FarmGuide](https://blog.farmguide.in/) 就是这样一家农业科技初创公司，它是“*整合机器学习和数据分析等技术，以创建定制信息来迎合农场企业和种植者*”。它通过向印度小农提供有关天气、市场机会和新作物种子的信息，帮助他们做出最佳决策。这些信息通过预先安排和预先录制的语音电话发送给农民，农民可以做出完全知情的决定。**大数据中的权力不对称**在获取数据的过程中，单独一个农民的作用可以忽略不计，但所有农民的共同作用是至关重要的。他们创造原始数据，然后由外部公司货币化。理想情况下，农民应该学习并接受使用大数据的培训，然而今天，大多数来自工业化农场的农民只是在孟山都等公司的指导下工作的简单特许经营者。这些农民可能会对他们的伴侣产生依赖，变得更加脆弱。公司可以接触到每个农民的秘密，例如土地质量、植物生长和作物产量……此外，农民不知道他的信息如何以及在哪里被保存或使用。农业大数据业务的全球领导者 Climate corp 承认农民对数据的所有权，但它并未授予[农民任何关于从这些数据中生成的分析和信息的权利](https://policyreview.info/articles/analysis/ethics-big-data-big-agriculture)。这些公司可用的专业知识和数据量给了他们力量。由于一个农民对这些公司没有太大的影响力，农民们组织起来组成合作社来谈判他们的权利。他们担心第三方(如另一家公司或政府)会在他们不知情和未同意的情况下获取他们的私人信息。即使农民通过大数据获得了关于他们农场的新见解，如果数据落入坏人之手，他们也会面临生存威胁。例如，产量数据可用于在商品金融市场上投机股票，这可能会减少收入并威胁农民的生计。**未来需要的不仅仅是数据**农业领域的大数据有可能彻底重构经济。越来越多的人意识到全球环境问题，许多人想解决它。消费习惯已经发生了变化。人们想要一种健康的、公平的、可持续生产的食品。有了用智能手机扫描二维码并了解水果生长方式的可能性，消费者将能够购买环保产品并抵制具有高负外部性的公司。尽管如此，这一由大数据推动的进步不应危及农民的生计。即使基于大数据的技术开启了令人兴奋的新机遇，我们也需要小心谨慎。社会科学和伦理必须赶上技术，以创建一个全球性的立法和保护数据提供商免受权力滥用。此外，有必要对农民进行大数据教育，并培训他们安全地利用大数据。**再见鲍勃，注意安全**Bob 创建数据。这些数据有着巨大的潜力。这有可能增加他的收入，养活和拯救世界。为了利用这种潜力，鲍勃需要好的盟友:能给他同等权力的专家——但不剥削他。我们需要回答的问题是:这些盟友在哪里？# 偏差-方差和精确-回忆权衡:如何瞄准最佳点？> 原文：<https://towardsdatascience.com/tradeoffs-how-to-aim-for-the-sweet-spot-c20b40d5e6b6?source=collection_archive---------6----------------------->## 如何在**偏差-方差&精确-召回权衡**中找到甜蜜点？理解在此过程中起主要作用的所有重要参数。权衡是介于理智但无聊的生活和复杂、冒险但冒险的生活之间的一件事。生活中的每一点，甚至每一秒我们都做出某种‘取舍’。冒险与否的权衡总是帮助我们找到最佳平衡点或中间地带。当我们让机器像人类一样思考时，它们也受到“权衡”的困扰。机器学习通常需要处理两个权衡，1. 偏差-方差权衡 2. 精确召回的权衡# 第 1 部分:偏差-方差权衡## 1.1 首先，什么是偏差，什么是方差？## 偏置:要理解它，就要知道它的大概意思。剑桥词典称，> 以不公平的方式支持或反对特定的人或事的行为，因为允许个人观点影响你的判断。→所以在统计学的世界里，它被定义为，> 统计偏差是统计技术或其结果的一个特征，由此结果的期望值不同于被估计的真实的潜在定量参数。受够了“书生气”的定义，让我们通过与现实世界更相关的类比来理解它。→用简单的英语来说，“机器学习技术无法捕捉真实关系是**偏见”。*** **低偏差**:预测数据点接近目标。此外，该模型对目标函数的形式提出了更少的假设。 * **高偏差**:预测数据点远离目标。此外，该模型对目标函数的形式提出了更多的假设。 * **低偏机器学习算法的例子:**决策树、k 近邻、支持向量机。 * **高偏差机器学习算法的例子:**线性回归，线性判别分析，逻辑回归。→因此，理想情况下，我们的主要目标是整体低偏置(但不总是如此)。具有高偏差的模型很少关注训练数据，并且过度简化了模型。它总是导致训练和测试数据的高误差。## 1.1.2 差异:再次要理解它，我们必须知道它的大致意思。剑桥词典称，> 两个或多个事物不同的事实，或它们不同的数量或数目。→所以在统计学的世界里，它被定义为，> 在概率论和统计学中，**方差**是随机变量与其均值的方差平方的期望值。通俗地说，它测量一组(随机)数从它们的平均值分散开多远。这又是一个“书生气”的定义。因此，让我们通过它在现实世界中的类比来弄清楚这个想法。→用简单的英语来说，“它是给定数据点或数值的模型预测的可变性，它告诉我们数据的分布”。这里的数据分布就是数据点和平均值之差的平方(即偏差的平方，σ)* **低方差**:数据点相互接近，结果接近函数。此外，该模型建议随着训练数据集的改变而对目标函数的估计进行小的改变。 * **高方差**:数据点分散，结果远离函数。建议随着训练数据集的改变而对目标函数的估计进行大的改变。 * **低方差机器学习算法的例子:**线性回归、线性判别分析、逻辑回归。 * **高方差机器学习算法的例子:**决策树、k 近邻、支持向量机。→因此，理想情况下，我们的总体目标是低偏置。(但并不总是)。高方差模型非常重视训练数据，不会对以前没有见过的数据进行归纳。结果，这样的模型在训练数据上表现得非常好，但是在测试数据上有很高的错误率。## 1.2.到目前为止，一切似乎都很好，那么偏差-方差权衡的结果是什么呢？→要理解这一点，首先我们必须理解误差，因为它们或多或少只与误差有关。不管使用什么算法，都不能减少不可约误差&从问题的选择框架中引入。由影响输入变量到输出变量的映射的未知变量等因素引起。→因此，为了最小化误差，我们必须最小化偏差和方差。→任何有监督的机器学习算法的目标都是实现低偏差和低方差。反过来，该算法应该实现良好的预测性能。你可以在上面的例子中看到一个总的趋势:* 参数或线性机器学习算法通常具有高偏差但低方差。 * 非参数或非线性机器学习算法通常具有低偏差但高方差。> 机器学习算法的参数化通常是一场平衡偏差和方差的战斗。→在机器学习中，偏差和方差之间的关系是不可避免的。* 增加偏差会减少方差。 * 增加方差将减少偏差。*Bias-Variance Trade-off as a Function of Model Capacity*→ *从上图我们可以解读如下:*I .高偏差和低方差使数据欠拟合，因为它错过了许多假设。此外，点数与预期预测值有偏差。二。低偏差和高方差过度拟合数据，因为模型过于关注训练数据，不能很好地概括。三。当两者都找到中间点或最佳点时，误差最小。左上是我们的目标。二。左下具有高偏差，因此它们远离目标，但由于低方差而彼此接近。三。右上点由于高方差而展开，但是由于低偏差而接近目标。四。右下方离目标很远，而且点数本身也是因为高方差和高偏差。→为了建立一个好的模型，我们需要在偏差和方差之间找到一个好的平衡，这样可以使总误差最小化。偏差和方差的最佳平衡不会使模型过拟合或欠拟合。这是通过在反复试验的基础上进行超参数调整来实现的# 第 2 部分:精确召回权衡## 2.1.首先，什么是精确，什么是回忆，或者其他术语？它们是*分类问题*的性能矩阵。我认为*分类*的每一个概念都可以用一个例子来解释。**例子:**假设你正在考虑给可能会再次光顾的顾客额外赠送一块方糖。但是你当然想避免不必要的分发方糖，所以你只把方糖给那些模型显示至少有 30%可能会再次光顾的顾客。Confusion Matrix* TP:被模型分类为*的将返回*，而实际上*已经返回了* * FP:被模型归类为*将返回*，但实际上*没有返回* *(类型 1 错误或告警)* * TN:被模型归类为*不会返回*，实际上*并没有返回* * FN:被模型归类为*不会返回*，但实际上*已经返回*。*(类型 2 错误或遗漏)**(注:我是假设读者了解‘混淆矩阵’，如果不了解，请先过一遍。)*Venn Dig for Precision & Recall**2.1.1 精度:**> 检索到的实例中相关实例的比例。→计算如下:TP / (TP + FP)→从上面的例子，我们可以解读为，“*被归类为会回归的，实际做了的比例是多少？”*→因此，精度表示我们的模型所说的相关数据点的比例实际上是相关的。**2.1.2 召回(又称灵敏度):**> 已检索的相关实例占相关实例总数的比例。→计算如下:TP /( TP + FN)→从上面的例子中，我们可以将它解释为，“*在那些实际返回的人中，有多少比例是这样分类的？”*→一般来说，灵敏度告诉我们******目标*** *被正确识别的百分比。*也称为“真阳性率”，可互换使用。在正确识别阳性的基础上选择模型时很有用，在这种情况下，就是给额外的方糖。*****→因此，回忆表示在数据集中找到所有相关实例的能力*****在继续之前，我们应该了解一些其他有用的术语。*******2.1.3 特异性(又称假阴性率):********→** *被正确识别的* ***阴性靶*** *的百分比。*在正确识别负面因素的基础上选择模型时很有用，在这种情况下，不会给出额外的方糖。****→计算为:TN/(TN + FP)****2 . 1 . 4 F1-分数:****→精确度和召回率的最佳结合我们可以使用所谓的 [F1 分数](https://en.wikipedia.org/wiki/F1_score)来组合这两个指标。****→F1 分数是精确度和召回率的调和平均值，在以下等式中考虑了这两个指标:********→我们使用[调和平均值而不是简单平均值，因为它会惩罚极值](https://stackoverflow.com/questions/26355942/why-is-the-f-measure-a-harmonic-mean-and-not-an-arithmetic-mean-of-the-precision)。精度为 1.0、召回率为 0.0 的分类器的简单平均值为 0.5，但 f 1 值为 0。******2.2 回到最初的问题，精确召回权衡还是精确 *vs* 召回？******→在任何一个模型中，您也可以决定强调精确度或召回率。也许你很缺方糖，所以你只想把方糖给那些你很有信心会再次光顾的人，所以你决定只把方糖给那些有 60%可能会再次光顾的顾客(而不是 30%)。****我们的精确度会提高，因为只有当你确信有人会回来的时候，你才会分发方糖。我们的召回率将会下降，因为将会有很多人最终会退回那些你没有足够信心给他们一块方糖的人。****精度:62% → 80% 召回:60% → 30%****→或者，如果你觉得方糖很丰富，你可以把它们分发给任何一个至少有 10%机会再次购买的人。****精确度:62% → 40% 召回率:60% → 90%****您可以使用此图表来跟踪精确度和召回率之间的权衡:********→更好的模型具有更高的精度和召回值。*** **你可以想象一个模型有 94%的准确率(几乎所有被标识为*的都将返回* do 事实上)和 97%的召回率(几乎所有*返回*的都被标识为这样)。** * **一个较弱的模型可能有 95%的精度，但 50%的召回率(当它识别某人为*将返回*，这在很大程度上是正确的，但它错误地标记为*不会返回*，而事实上是那些后来返回*的人中的一半返回*)。** * **或者这个模型有 60%的准确率和 60%的召回率****这些数字会让你对你的模型有多精确有一个很好的感觉，即使你实际上从来不想做任何预测。**# *****包装完毕:********就像现实世界中的权衡决策是基于当前环境做出的一样，这两种权衡也是如此。一天结束时，我们所要做的就是根据我们的需求做出判断。***# 交易策略:用 Backtrader 进行回溯测试> 原文：<https://towardsdatascience.com/trading-strategy-back-testing-with-backtrader-6c173f29e37f?source=collection_archive---------5----------------------->Photo by [Chris Liverani](https://unsplash.com/@chrisliverani?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)(我的[博客](https://kylelix7.github.io/Back-testing-with-Backtrader/)里也有这个帖子)在我的一篇[旧文章](https://medium.com/@kyle.jinhai.li/trading-strategy-technical-analysis-with-python-ta-lib-3ce9d6ce5614)中，我演示了如何计算技术指标，这些指标可以逻辑地结合起来建立交易策略。正如帖子中所强调的，在将策略应用于实际市场之前，应该先验证策略在回溯测试中的表现。> 回溯测试是将交易策略或分析方法应用于历史数据的过程，以查看该策略或方法预测实际结果的准确性。 > -摘自[投资答案](https://investinganswers.com/financial-dictionary/stock-market/backtesting-865)回溯测试就像机器学习中的交叉验证。但也不完全一样。回溯测试需要像交叉验证一样将数据分成两部分。一套用于训练，另一套用于验证。不同的是，训练测试分割可以随机进行交叉验证。在交易回溯测试中，你的数据是时间序列。您的训练数据必须比您的测试数据旧。否则你会偷窥未来，导致对你的策略的不正确衡量。因此，在回溯测试中，数据集的分割不能是随机的。回溯测试涉及真实世界中的市场模拟。实现自己的回溯测试库可能很难，而且容易出错。幸运的是，还有反向交易者。Backtrader 是一个非常棒的开源 python 框架，它可以让你专注于编写可重用的交易策略、指标和分析工具，而不是花时间构建基础设施。它还支持回溯测试，让你评估自己想出的策略！也就是说，这是一个免费的完整的技术人员建立自己的策略的解决方案。让我们开始浏览一下。## 安装和设置``` pip install backtrader[plotting] ```## 制定战略Backtrader 为您定义了一个[策略](https://www.backtrader.com/docu/strategy.html)界面。您需要创建一个实现此接口的类。一个重要的方法是 next()，你应该根据某一天的技术指标来决定是买进、卖出还是什么都不做。一个简单的策略是这样的。``` **import** backtrader **as** bt **class** **MyStrategy**(bt.Strategy):**def** __init__(self):self.sma = bt.indicators.SimpleMovingAverage(period=15)**def** next(self):**if** self.sma > self.data.close:*# Do something***pass****elif** self.sma < self.data.close:*# Do something else***pass** ```如你所见，backtrader 附带了一套通用的技术指标。意味着你不需要在你自己或 TA lib 上回复来计算技术指标。Backtrader 还提供模拟市场交易的功能。Once 可以在您的交易操作中根据美元或百分比计算佣金。``` cerebro.broker.setcommission(commission=0.001) ```下面是用脸书历史市场数据进行回溯测试的完整示例。注意，历史交易数据是从[雅虎财经](https://finance.yahoo.com/quote/FB/history?p=FB&.tsrc=fin-srch-v1)下载的。它还支持[熊猫数据帧](https://www.backtrader.com/docu/pandas-datafeed/pandas-datafeed.html)。我有一个关于收集熊猫[交易数据的帖子。这个例子由一个简单的 TestStrategy 和一段启动回溯测试的驱动代码组成。简单策略只考虑买入/卖出信号的 RSI。你应该为你选择的股票添加更多的逻辑。](https://medium.com/@kyle.jinhai.li/collect-trading-data-with-pandas-library-8904659f2122)``` **from** __future__ **import** (absolute_import, division, print_function,unicode_literals)**import** datetime **import** os.path **import** sys **import** backtrader **as** bt **class** TestStrategy(bt.Strategy):**def** log(self, txt, dt=**None**):dt = dt **or** self.datas[0].datetime.date(0)print(**'%s, %s'** % (dt.isoformat(), txt))**def** __init__(self):self.dataclose = self.datas[0].closeself.order = **None** self.buyprice = **None** self.buycomm = **None** self.sma = bt.indicators.SimpleMovingAverage(self.datas[0], period=15)self.rsi = bt.indicators.RelativeStrengthIndex()**def** notify_order(self, order):**if** order.status **in** [order.Submitted, order.Accepted]:**returnif** order.status **in** [order.Completed]:**if** order.isbuy():self.log(**'BUY EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f'** %(order.executed.price,order.executed.value,order.executed.comm))self.buyprice = order.executed.priceself.buycomm = order.executed.comm**else**: *# Sell* self.log(**'SELL EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f'** %(order.executed.price,order.executed.value,order.executed.comm))self.bar_executed = len(self)**elif** order.status **in** [order.Canceled, order.Margin, order.Rejected]:self.log(**'Order Canceled/Margin/Rejected'**)*# Write down: no pending order* self.order = **Nonedef** notify_trade(self, trade):**if not** trade.isclosed:**return** self.log(**'OPERATION PROFIT, GROSS %.2f, NET %.2f'** %(trade.pnl, trade.pnlcomm))**def** next(self):self.log(**'Close, %.2f'** % self.dataclose[0])print(**'rsi:'**, self.rsi[0])**if** self.order:**returnif not** self.position:**if** (self.rsi[0] < 30):self.log(**'BUY CREATE, %.2f'** % self.dataclose[0])self.order = self.buy(size=500)**else**:**if** (self.rsi[0] > 70):self.log(**'SELL CREATE, %.2f'** % self.dataclose[0])self.order = self.sell(size=500)**if** __name__ == **'__main__'**:cerebro = bt.Cerebro()cerebro.addstrategy(TestStrategy)cerebro.broker.setcommission(commission=0.001)datapath = **'FB.csv'** *# Create a Data Feed* data = bt.feeds.YahooFinanceCSVData(dataname=datapath,fromdate=datetime.datetime(2013, 1, 1),todate=datetime.datetime(2018, 8, 5),reverse=**True**)cerebro.adddata(data)cerebro.broker.setcash(100000.0)print(**'Starting Portfolio Value: %.2f'** % cerebro.broker.getvalue())cerebro.run()print(**'Final Portfolio Value: %.2f'** % cerebro.broker.getvalue())cerebro.plot() ```在执行结束时，你可以找出你的投资组合的最终价值。此外，你还可以根据时间绘制股票价格、技术指标、你的买入/卖出操作和你的投资组合价值。正如你所看到的，这个简单的策略对 FB 很有效，因为它抓住了一些买卖机会。这就是 backtrader 的回溯测试。如果你想深入了解，我建议你访问 [backtrader 的文档](https://www.backtrader.com/docu/introduction.html)了解更多高级用法。如果你想了解更多关于机器学习的知识，在 educative.io 网站上有一系列[有用的课程。这些课程包括像基本的 ML，NLP，图像识别等主题。编码和交易快乐！](https://www.educative.io/profile/view/6083138522447872?aff=VEzk)推荐阅读:[动手机器学习](https://www.amazon.com/gp/product/1492032646/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1492032646&linkCode=as2&tag=blog023b-20&linkId=e6994d31d10e7ac4d35d9889cfe5622e)[用于数据分析的 Python:与 Pandas、NumPy 和 IPython 的数据争论](https://www.amazon.com/gp/product/1491957662/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1491957662&linkCode=as2&tag=blog023b-20&linkId=be0bbd6ab4fd578397d9c14facc76911)[对冲基金真正在做什么](https://www.amazon.com/gp/product/1631570897/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1631570897&linkCode=as2&tag=blog023b-20&linkId=d7bb68173b008df1b500073e3a8d054e)我的帖子:[我关于 FAANG 访谈的帖子](https://medium.com/@fin.techology/my-posts-about-faang-interview-20e529c5f13f?source=your_stories_page---------------------------)[我的 YouTube 频道](https://bit.ly/3bBOjtJ)[我关于金融和科技的帖子](https://medium.com/@fin.techology/my-posts-about-finance-and-tech-7b7e6b2e57f4?source=your_stories_page---------------------------)[从 CRUD web 应用开发到语音助手中的 SDE——我正在进行的机器学习之旅](https://medium.com/@fin.techology/from-crud-app-dev-to-sde-in-voice-assistant-my-ongoing-journey-to-ml-4ea11ec4966e?)[全栈开发教程:将 AWS Lambda 无服务器服务集成到 Angular SPA 中](/full-stack-development-tutorial-integrate-aws-lambda-serverless-service-into-angular-spa-abb70bcf417f)[全栈开发教程:用运行在 AWS Lambda 上的无服务器 REST API 提供交易数据](/full-stack-development-tutorial-serverless-rest-api-running-on-aws-lambda-a9a501f54405)[全栈开发教程:在 Angular SPA 上可视化交易数据](/full-stack-development-tutorial-visualize-trading-data-on-angular-spa-7ec2a5749a38)[强化学习:Q 学习简介](https://medium.com/@kyle.jinhai.li/reinforcement-learning-introduction-to-q-learning-444c951e292c)# 交易策略:用 Python TA-Lib 进行技术分析> 原文：<https://towardsdatascience.com/trading-strategy-technical-analysis-with-python-ta-lib-3ce9d6ce5614?source=collection_archive---------3----------------------->Photo by [Vladimir Solomyani](https://unsplash.com/@till_indeman?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)(我的[博客](https://kylelix7.github.io/Trading-Strategy-Technical-Analysis-with-Python-TA-Lib/)里也有这个帖子)> 在金融领域，**交易策略**是一个固定的计划，旨在通过在市场上做多或做空来实现盈利回报。正确研究交易策略的主要原因是它的可验证性、可量化性、一致性和客观性。 > > 对于每一个交易策略，你都需要定义交易的资产、进场/出场点和资金管理规则。糟糕的资金管理会让潜在的盈利策略变得无利可图。 > > —来自[维基百科](https://en.wikipedia.org/wiki/Technical_analysis)策略分为基于基本面分析和基于技术分析。基本面分析关注公司的资产、收益、市场、股息等，而技术分析只关注股价和成交量。技术分析广泛使用技术指标，这些指标是根据价格和交易量计算出来的，用来洞察交易行为。技术指标进一步分类为波动性、动量、趋势、成交量等。有选择地组合一只股票的指标可能会产生很好的盈利策略。一旦建立了策略，人们应该[用模拟器回测](https://www.investopedia.com/terms/b/backtesting.asp)该策略，以在实时交易前测量性能([回报和风险](https://medium.com/@kyle.jinhai.li/efficient-frontier-optimize-portfolio-with-scipy-57456428323e))。我有另一个[帖子](https://medium.com/@kyle.jinhai.li/trading-strategy-back-testing-with-backtrader-6c173f29e37f)涉及反向交易者的反向测试。由于技术指标在构建策略中起着重要的作用，我将演示如何使用 [TA-Lib](https://www.ta-lib.org/) 来计算技术指标并构建一个简单的策略。(请不要直接使用策略进行实时交易，因为需要进行回溯测试)。如果你想自己算指标，参考我[上一篇](https://medium.com/@kyle.jinhai.li/trading-technical-analysis-with-pandas-43e737a17861)在[熊猫](https://pandas.pydata.org/)里怎么做。在这篇文章中，我将用 [RSI](https://en.wikipedia.org/wiki/Relative_strength_index) (一个动量指标)和[布林线](https://en.wikipedia.org/wiki/Bollinger_Bands) %b(一个波动指标)构建一个策略。高 RSI(通常高于 70)可能表明股票超买，因此这是卖出信号。低 RSI(通常低于 30)表明股票超卖，这意味着买入信号。布林线告诉我们两个波段之间的大部分价格行为。因此，如果%b 高于 1，价格可能会回落到区间内。因此，这是一个卖出信号。而如果低于 0，则认为是买入信号。这个策略是一个简单的投票机制。当两个指标认为是买入的时候了，它就发出买入指令进场。当两个指标都认为是时候卖出时，它就发出卖出指令退出。## 在 Mac 上安装 TA-Lib 和其他依赖项``` python3 -m venv tutorial-env source ~/tutorial-env/bin/activate pip install panda pip install pandas_datareader pip install matplotlib pip install scipy pip install cython brew install ta-lib pip install TA-lib ```## 计算布林线或 RSI``` **import** pandas_datareader.data **as** web **import** pandas **as** pd **import** numpy **as** np **from** talib **import** RSI, BBANDS **import** matplotlib.pyplot **as** pltstart = **'2015-04-22'** end = **'2017-04-22'** symbol = **'MCD'** max_holding = 100 price = web.DataReader(name=symbol, data_source=**'quandl'**, start=start, end=end) price = price.iloc[::-1] price = price.dropna() close = price[**'AdjClose'**].values up, mid, low = BBANDS(close, timeperiod=20, nbdevup=2, nbdevdn=2, matype=0) rsi = RSI(close, timeperiod=14) print(**"RSI (first 10 elements)\n"**, rsi[14:24]) ```输出``` RSI (first 10 elements)[50.45417011 47.89845022 49.54971141 51.0802541 50.97931103 61.7935595758.80010324 54.64867736 53.23445848 50.65447261] ```将布林线转换为%b``` **def** bbp(price):up, mid, low = BBANDS(close, timeperiod=20, nbdevup=2, nbdevdn=2, matype=0)bbp = (price[**'AdjClose'**] - low) / (up - low)**return** bbp ```根据指标计算持仓量``` holdings = pd.DataFrame(index=price.index, data={**'Holdings'**: np.array([np.nan] * index.shape[0])}) holdings.loc[((price[**'RSI'**] < 30) & (price[**'BBP'**] < 0)), **'Holdings'**] = max_holding holdings.loc[((price[**'RSI'**] > 70) & (price[**'BBP'**] > 1)), **'Holdings'**] = 0holdings.ffill(inplace=**True**) holdings.fillna(0, inplace=**True**) ```此外，我们应该得到基于持有量的交易行为``` holdings[**'Order'**] = holdings.diff() holdings.dropna(inplace=**True**) ```让我们想象一下我们的行动和指标``` fig, (ax0, ax1, ax2) = plt.subplots(3, 1, sharex=**True**, figsize=(12, 8)) ax0.plot(index, price[**'AdjClose'**], label=**'AdjClose'**) ax0.set_xlabel(**'Date'**) ax0.set_ylabel(**'AdjClose'**) ax0.grid() **for** day, holding **in** holdings.iterrows():order = holding[**'Order'**]**if** order > 0:ax0.scatter(x=day, y=price.loc[day, **'AdjClose'**], color=**'green'**)**elif** order < 0:ax0.scatter(x=day, y=price.loc[day, **'AdjClose'**], color=**'red'**)ax1.plot(index, price[**'RSI'**], label=**'RSI'**) ax1.fill_between(index, y1=30, y2=70, color=**'#adccff'**, alpha=**'0.3'**) ax1.set_xlabel(**'Date'**) ax1.set_ylabel(**'RSI'**) ax1.grid()ax2.plot(index, price[**'BB_up'**], label=**'BB_up'**) ax2.plot(index, price[**'AdjClose'**], label=**'AdjClose'**) ax2.plot(index, price[**'BB_low'**], label=**'BB_low'**) ax2.fill_between(index, y1=price[**'BB_low'**], y2=price[**'BB_up'**], color=**'#adccff'**, alpha=**'0.3'**) ax2.set_xlabel(**'Date'**) ax2.set_ylabel(**'Bollinger Bands'**) ax2.grid()fig.tight_layout() plt.show() ```下面，我用调整后的麦当劳收盘价(2015 年 4 月至 2017 年 4 月)用绿点(进场点)和红点(出场点)标出了行动。除此之外，RSI 指标和布林线也显示了这两个指标是如何影响交易的。从图中可以看出这个策略是好的。它捕捉了一对夫妇在此期间相对的一些低价和高价。应该进行回溯测试，以了解该策略与基准测试相比表现如何。## 结果在图表中这个帖子到此为止。如果你想了解更多关于机器学习的知识，educative.io 网站上有一系列[课程很有帮助。这些课程包括像基本的 ML，NLP，图像识别等主题。投资和编码快乐！](https://www.educative.io/profile/view/6083138522447872?aff=VEzk)***来自《走向数据科学》编辑的提示:*** *虽然我们允许独立作者根据我们的* [*规则和指南*](/questions-96667b06af5) *发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的* [*读者术语*](/readers-terms-b5d780a700a4) *。*推荐阅读:[动手机器学习](https://amzn.to/33KaKtN)[用于数据分析的 Python:与 Pandas、NumPy 和 IPython 的数据角力](https://amzn.to/3w8Vzqe)[对冲基金真正在做什么](https://amzn.to/33O3jlo)我的帖子:[我关于 FAANG 访谈的帖子](https://medium.com/@fin.techology/my-posts-about-faang-interview-20e529c5f13f?source=your_stories_page---------------------------)[我的 YouTube 频道](https://bit.ly/3bBOjtJ)[我关于金融和科技的帖子](https://medium.com/@fin.techology/my-posts-about-finance-and-tech-7b7e6b2e57f4?source=your_stories_page---------------------------)[从 CRUD web 应用开发到语音助手中的 SDE——我正在进行的机器学习之旅](https://medium.com/@fin.techology/from-crud-app-dev-to-sde-in-voice-assistant-my-ongoing-journey-to-ml-4ea11ec4966e?)[全栈开发教程:将 AWS Lambda 无服务器服务集成到 Angular SPA 中](/full-stack-development-tutorial-integrate-aws-lambda-serverless-service-into-angular-spa-abb70bcf417f)[全栈开发教程:用运行在 AWS Lambda 上的无服务器 REST API 提供交易数据](/full-stack-development-tutorial-serverless-rest-api-running-on-aws-lambda-a9a501f54405)[全栈开发教程:在 Angular SPA 上可视化交易数据(1)](/full-stack-development-tutorial-visualize-trading-data-on-angular-spa-7ec2a5749a38)[强化学习:Q 学习简介](https://medium.com/@kyle.jinhai.li/reinforcement-learning-introduction-to-q-learning-444c951e292c)# 交易:用熊猫计算技术分析指标🐼> 原文：<https://towardsdatascience.com/trading-technical-analysis-with-pandas-43e737a17861?source=collection_archive---------2----------------------->(我的[博客](https://kylelix7.github.io/Calculate-Technical-Analysis-Indicators-with-Pandas/)里也有这个帖子)在金融学中， [**技术分析**](https://en.wikipedia.org/wiki/Technical_analysis) 是通过研究过去的市场数据，主要是*价格*和*成交量*来预测价格走向的分析方法论。技术分析师依靠技术指标的组合来研究股票，并给出交易策略的见解。常用的技术指标有 [SMA](https://en.wikipedia.org/wiki/Moving_average#Simple_moving_average) 和[布林线](https://en.wikipedia.org/wiki/Bollinger_Bands)等。这是一份技术指标的清单。在之前的一个[故事](https://medium.com/@kyle.jinhai.li/collect-trading-data-with-pandas-library-8904659f2122)中，我讲过如何用熊猫收集这样的信息。在这个故事中，我将演示如何计算布林线，并用它来提供潜在的买入/卖出信号。**布林线****布林线**用于定义市场中的最高价和最低价，以表征金融工具或商品的交易区间。布林线是一个[波动](https://en.wikipedia.org/wiki/Volatility_(finance))指标。波段是由移动平均线(MA)组成的，有上波段和下波段。上下波段只是 MA 加和减标准差。标准差是波动性的度量。这就是为什么它是一个波动指标。``` Upper Band = (MA + *Kσ*)Lower Band = (MA − *Kσ*) ```MA 是典型的 20 天移动平均线，K 是 2。我将在这个例子中使用它们。example of Bollinger Bands先决条件环境设置(遵循此[帖子](https://medium.com/@kyle.jinhai.li/collect-trading-data-with-pandas-library-8904659f2122)中的步骤 1)数据:在本例中，我们将使用从之前的[帖子](https://medium.com/@kyle.jinhai.li/collect-trading-data-with-pandas-library-8904659f2122)中收集的 csv 文件(AMZN.csv)代码:``` **import** pandas **as** pd **import** matplotlib.pyplot **as** pltsymbol=**'AMZN'** *# read csv file, use date as index and read close as a column* df = pd.read_csv(**'~/workspace/{}.csv'**.format(symbol), index_col=**'date'**,parse_dates=**True**, usecols=[**'date'**, **'close'**],na_values=**'nan'**) *# rename the column header with symbol name* df = df.rename(columns={**'close'**: symbol}) df.dropna(inplace=**True**)*# calculate Simple Moving Average with 20 days window* sma = df.rolling(window=20).mean()*# calculate the standar deviation* rstd = df.rolling(window=20).std()upper_band = sma + 2 * rstd upper_band = upper_band.rename(columns={symbol: **'upper'**}) lower_band = sma - 2 * rstd lower_band = lower_band.rename(columns={symbol: **'lower'**})df = df.join(upper_band).join(lower_band) ax = df.plot(title=**'{} Price and BB'**.format(symbol)) ax.fill_between(df.index, lower_band[**'lower'**], upper_band[**'upper'**], color=**'#ADCCFF'**, alpha=**'0.4'**) ax.set_xlabel(**'date'**) ax.set_ylabel(**'SMA and BB'**) ax.grid() plt.show() ```输出Amazon price and its Bollinger Bands买入/卖出信号的解释大约 90%的价格波动在两个波段之间。因此，波段可以用来识别潜在的超买或超卖情况。如果股价突破了上限，这可能是一个超买状态(做空的迹象)。同样，当它突破低波段时，可能是超卖状态(多头的迹象)。但是布林线不是一个独立的系统，总是给出准确的买入/卖出信号。应该考虑频带的整体趋势来识别信号。否则，只有布林线，一个人可以不断地做出错误的订单。在上面的亚马逊例子中，趋势是上升的。因此，只有在低频带被标记时，才应该做多。更多信息可以在[这里](https://www.investopedia.com/trading/using-bollinger-bands-to-gauge-trends/)找到。这就是计算技术指标的简单方法🐼！如果你想了解更多关于机器学习的知识，educative.io 网站上有一系列[课程很有帮助。这些课程包括像基本的 ML，NLP，图像识别等主题。](https://www.educative.io/profile/view/6083138522447872?aff=VEzk)推荐阅读:[动手机器学习](https://www.amazon.com/gp/product/1492032646/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1492032646&linkCode=as2&tag=blog023b-20&linkId=e6994d31d10e7ac4d35d9889cfe5622e)[用于数据分析的 Python:与 Pandas、NumPy 和 IPython 的数据争论](https://www.amazon.com/gp/product/1491957662/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1491957662&linkCode=as2&tag=blog023b-20&linkId=be0bbd6ab4fd578397d9c14facc76911)[对冲基金真正在做什么](https://www.amazon.com/gp/product/1631570897/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1631570897&linkCode=as2&tag=blog023b-20&linkId=d7bb68173b008df1b500073e3a8d054e)我的帖子:[我关于金融和科技的帖子](https://medium.com/@fin.techology/my-posts-about-finance-and-tech-7b7e6b2e57f4?source=your_stories_page---------------------------)[我的 YouTube 频道](https://bit.ly/3bBOjtJ)[我关于 FAANG 访谈的帖子](https://medium.com/@fin.techology/my-posts-about-faang-interview-20e529c5f13f?source=your_stories_page---------------------------)[从 CRUD web 应用开发到语音助手中的 SDE——我正在进行的机器学习之旅](https://medium.com/@fin.techology/from-crud-app-dev-to-sde-in-voice-assistant-my-ongoing-journey-to-ml-4ea11ec4966e?)[全栈开发教程:将 AWS Lambda 无服务器服务集成到 Angular SPA 中](/full-stack-development-tutorial-integrate-aws-lambda-serverless-service-into-angular-spa-abb70bcf417f)[全栈开发教程:用运行在 AWS Lambda 上的无服务器 REST API 提供交易数据](/full-stack-development-tutorial-serverless-rest-api-running-on-aws-lambda-a9a501f54405)[全栈开发教程:在 Angular SPA 上可视化交易数据(1)](/full-stack-development-tutorial-visualize-trading-data-on-angular-spa-7ec2a5749a38)[强化学习:Q 学习简介](https://medium.com/@kyle.jinhai.li/reinforcement-learning-introduction-to-q-learning-444c951e292c)# 像人类一样准确地阅读交通标志> 原文：<https://towardsdatascience.com/traffic-signs-classification-for-self-driving-car-67ce57877c33?source=collection_archive---------4----------------------->*用数据做酷事*自动驾驶汽车将不得不实时解读我们道路上的所有交通标志，并在驾驶中考虑这些因素。在这篇博客中，我们使用深度学习来训练汽车以 93%的准确率对交通标志进行分类。我已经用 Python 分享了我的 [**GitHub**](https://github.com/priya-dwivedi/CarND/blob/master/CarND-Traffic-Sign-Classifier-P2/Traffic_Sign_Classifier_pd.ipynb) 的链接和全部代码。Traffic Signs!## **数据集**这个练习使用的数据集(可以从[这里](http://benchmark.ini.rub.de/?section=gtsrb&subsection=dataset)下载)由德国道路上看到的 43 个不同的交通标志组成。交通标志图像是从实际道路图像中裁剪出来的，因此处于不同的光照条件下，如下所示。Cropping stop sign from actual road images它总共有 5 万张图片。图像为 32x32 像素，并且是彩色的。**理解数据**任何建模练习的第一步都应该是熟悉所涉及的数据。这里有 43 个不同的交通标志。如下图所示，数据分布不均匀。一些标志只有 200 张图片，而另一些有超过 1200 张图片。如下图所示，可视化数据集中的图像，我们可以看到图像很小，具有不同的亮度，有些图像很模糊。此外，交通标志并不总是在图像的中心。Traffic Sign images from the dataset**数据预处理**在将图像输入神经网络之前，我对图像进行了归一化处理，使像素值介于 0 和 0.5 之间。我这样做是通过将所有像素值除以 255。这样做是因为当原始数据在 0 和 1 之间时，神经网络表现得更好。我决定使用彩色交通标志，而不是将其转换为灰色，因为人类使用标志的颜色进行分类，所以机器也可以受益于这些额外的信息。最后，我将数据集分为训练集、验证集和测试集。测试集是模型永远看不到的 30%的样本。## **模型架构**对于这个项目，我决定使用 LeNet 架构，这是一个简单的卷积神经网络(CNN)，在 MNIST 数据集上表现良好。如下所示，该模型有两个卷积层，后跟两个最大池层。第一个卷积层使用 5x5 的面片大小和深度为 6 的过滤器。第二个卷积层也使用 5x5 的面片大小，但深度为 16 的过滤器。在卷积之后，我们展平输出，然后使用两个完全连接的层。第一个有 120 个神经元，第二个有 84 个神经元。在所有层之间使用 RELU 激活。最后，我们有一个输出层，它使用 Softmax 将图像分为 43 类。LeNet ArchitectureLeNet 架构在这个问题上表现得非常好，在 30 个时期内，我们在验证样本上获得了 98%以上的准确率。请参见下面的准确度和损失图:Model training using LeNet Architecture从未接触过该模型的测试样本的准确度约为 93%,这是相当可靠的。如果我们使用图像增强——亮度、旋转、平移等方面的变化，精确度可以进一步提高。增加样本量。## **可视化神经网络**虽然神经网络可以是一个很好的学习设备，但它们通常被称为黑盒。我们可以通过绘制其特征图来了解神经网络正在学习什么——这是过滤器的输出。从这些绘制的特征地图中，可以看出网络对图像的哪些特征感兴趣。对于标志，内部网络要素地图可能会对标志的边界轮廓或标志的着色符号中的对比度做出高度激活的反应。查看这个[链接](https://cs231n.github.io/understanding-cnn/)，了解更多关于可视化神经网络的信息。让我们看看第一个卷积层的 6 个不同的过滤器如何响应“请勿进入”的标志。这里亮点反映了神经元被激活的地方。可以看出，网络集中在圆形标志和中间的扁平线上。Do Not Enter SignFeature map — Do Not Enter Sign相比之下，我们从没有交通标志的天空图像来看特征图。大多数过滤器是黑色的，这意味着神经网络无法识别该图像中的任何明显特征。这不是超级有趣吗！**其他著述**:[https://medium.com/@priya.dwivedi/](https://medium.com/@priya.dwivedi/)PS:我住在多伦多，我希望将职业生涯转向深度学习。如果你喜欢我的帖子，并能把我联系到任何人，我将不胜感激:)。我的电子邮件是 priya.toronto3@gmail.com**参考文献:**[Udacity](https://www.udacity.com/) 无人驾驶汽车 Nano Degree——感谢 Udacity 和巴斯蒂安·特龙给我机会成为他们新的无人驾驶汽车项目的一部分。这是一次非常有趣的旅程。我使用的大部分代码都是在课堂讲课中建议的。这里的图片和视频参考也在讲座中分享德国交通标志数据集:[http://benchmark.ini.rub.de/?section=gtsrb&分部=数据集](http://benchmark.ini.rub.de/?section=gtsrb&subsection=dataset)# 训练人工智能在你的浏览器中玩蛇> 原文：<https://towardsdatascience.com/train-ai-to-play-snake-in-your-browser-ca657097d707?source=collection_archive---------2----------------------->最近，我[写了一篇文章](https://medium.com/@peterbinggeser/designing-ai-solving-snake-with-evolution-f3dd6a9da867),讲述了我设计能够自己学习玩贪吃蛇游戏的人工智能的过程。人工智能的设计过程很复杂。许多早期的小决定会导致完全不同的结果。现在，经过一点清理后，任何人都可以在他们的浏览器中调整、调整和发展他们自己的蛇形人工智能。[## 设计人工智能:用进化解决蛇### 在你的浏览器中训练、调整和调整人工智能。pbingeser . github . io](https://pbinggeser.github.io/snake-ai/) ## 可调参数**群体规模—** 每一代要创建的神经网络的数量**精英百分比—** 用于培育下一代的优秀员工的百分比**美食积分—** 因食用美食而获得的积分**迈向美食得分—** 迈向美食的每一步所获得的分数**远离食物得分—** 远离食物每一步的得分**蛇的起始长度—** 每条蛇的初始长度，在网格单元中测量**网格分辨率—** 组成蛇的环境的网格单元的宽度(和高度)的数量**显示尺寸—** 每个贪吃蛇游戏占多少像素宽*(不影响游戏)*## **游戏性切换**1. 蛇撞墙就死了。 2. 蛇打自己就死了。 3. 蛇吃东西的时候会变长。耐心点。有时，有利的随机突变发生得很快，有时这些突变证明最好谨慎行事，有时它们似乎永远不会发生…# 🐍# 用 5 行代码训练图像识别人工智能> 原文：<https://towardsdatascience.com/train-image-recognition-ai-with-5-lines-of-code-8ed0bdd8d9ba?source=collection_archive---------0----------------------->在本文中，我们将简要介绍人工智能领域，特别是计算机视觉领域，所涉及的挑战，现有的应对这些挑战的现代解决方案，以及如何方便、轻松地应用这些解决方案，而无需花费太多时间和精力。几十年来，人工智能一直是一个研究领域，科学家和工程师们都在努力解开让机器和计算机感知和理解我们的世界，从而采取适当行动为人类服务的谜团。这项研究工作最重要的一个方面是让计算机理解我们周围每天产生的视觉信息**(图像和视频)**。这个让计算机感知和理解视觉信息的领域被称为计算机视觉。在 20 世纪 50 年代**到 80 年代**人工智能研究的兴起期间，计算机被人工告知如何识别图像、图像中的物体以及需要注意哪些特征。这种方法是传统的算法，被称为**专家系统**，因为它们需要人类费力地为每个必须识别的物体的独特场景识别特征，并以计算机可以理解的数学模型来表示这些特征。这涉及到大量繁琐的工作，因为有成千上万种不同的方法可以表示一个对象，并且有成千上万(甚至数百万)不同的场景和对象是唯一存在的，因此找到优化和精确的数学模型来表示每个对象或场景的所有可能的特征，并且对于所有可能的对象或场景，更多的工作将永远持续下去。****然后，在 **1990** 年代，引入了**机器学习**的概念，它开创了一个时代，不再告诉计算机在识别图像和视频中的场景和对象时要注意什么，而是我们可以设计算法，让计算机学习如何自己识别图像中的场景和对象，就像孩子通过探索学习理解他/她的环境一样。机器学习为计算机学习识别我们想要的几乎任何场景或物体开辟了道路。随着功能强大的计算机的出现，如 NVIDIA GPU 和最先进的图像识别深度学习算法，如 Alex Krizhevsky 等人在 2012 年推出的 T4 Alex net、Kaeming He 等人在 2015 年推出的 ResNet、Forrest Landola 等人在 2016 年推出的 SqueezeNet 和 DenseNet 可以将许多图片(更像计算机的图画书)放在一起，并定义一个人工智能模型来自己学习这些图片中的场景和对象的特征，并使用从学习过程中获得的知识来识别它之后将遇到的该类型场景或对象的所有其他实例。要训练一个人工智能模型，让它能够识别你希望它在图片中识别的任何东西，传统上需要大量应用数学方面的专业知识和深度学习库的使用，更不用说你必须经历的时间和压力来编写算法代码并使代码适合你的图像。这是我们提供解决方案的地方。我们在[**AI Commons**](https://commons.specpal.science)**的团队开发了一个 python 库，可以让你训练一个人工智能模型，它可以识别你希望它在图像中识别的任何对象，只需使用**5 行简单的 python 代码。**python 库是[**ImageAI**](https://github.com/OlafenwaMoses/ImageAI)**，这个库旨在让学生、开发人员和具有各种专业知识水平的研究人员使用 **5 到 15 行简单代码来构建具有最先进的计算机视觉功能的系统和应用程序。现在，让我们带你创建你的第一个人工智能模型，它可以识别你想要它识别的任何东西。************为了训练你的人工智能模型，你需要一个名为**数据集的图像集合。**一个数据集包含成百上千个你希望你的人工智能模型识别的对象的样本图像。**但是你不用担心！**我们不是要求你现在就去下载成千上万的图片，只是为了训练你的人工智能模型。对于本教程，我们提供了一个名为 [**IdenProf**](https://github.com/OlafenwaMoses/IdenProf) 的数据集。identified prof(可识别的专业人士)是一个数据集，包含 10 种不同专业人士的 **11，000 张**照片，人类可以通过他们的穿着模式来查看和识别他们的工作。照片在该数据集中的专业人员类别如下:******厨师********医生********工程师********农民********消防员********法官********机械师********先导********警察********服务员******这个数据集被分割成 **9000** (每个职业 900 张)张图片来训练人工智能模型，以及 **2000** (每个职业 200 张)张图片来测试人工智能模型在训练时的性能。IdenProf 已经被妥善安排，准备好训练你的人工智能模型，通过穿着方式识别专业人士。作为参考，如果您使用自己的图像数据集，您必须为您希望人工智能模型识别的每个对象或场景收集至少 500 张图片。要使用 **ImageAI、**训练您自己收集的任何图像数据集，您必须将图像排列在文件夹中，如下例所示:**``` **idenprof//train//chef// 900 images of chefs****idenprof//train//doctor// 900 images of doctors****idenprof//train//engineer// 900 images of engineer****idenprof//train//farmer// 900 images of farmers****idenprof//train//firefighter// 900 images of firefighters****idenprof//train//judge// 900 images of judges****idenprof//train//mechanic// 900 images of mechanics****idenprof//train//pilot// 900 images of pilots****idenprof//train//chef// 900 images of chef****idenprof//train//police// 900 images of police****idenprof//train//waiter// 900 images of waiters****idenprof//test//chef// 200 images of chefs****idenprof//test//doctor// 200 images of doctors****idenprof//test//engineer// 200 images of engineer****idenprof//test//farmer// 200 images of farmers****idenprof//test//firefighter// 200 images of firefighters****idenprof//test//judge// 200 images of judges****idenprof//test//mechanic// 200 images of mechanics****idenprof//test//pilot// 200 images of pilots****idenprof//test//chef// 200 images of chef****idenprof//test//police// 200 images of police****idenprof//test//waiter// 200 images of waiters** ```**现在，您已经了解了如何准备自己的图像数据集来训练人工智能模型，我们现在将继续指导您使用 **ImageAI 训练人工智能模型来识别专业人员。******首先你必须通过这个[链接](https://github.com/OlafenwaMoses/IdenProf/releases/download/v1.0/idenprof-jpg.zip)下载 **IdenProf** 数据集的 zip 文件。你也可以在 IdenProf GitHub 知识库中查看人工智能模型的所有细节和样本结果，这些人工智能模型经过训练可以识别职业，其链接如下。****[https://github.com/OlafenwaMoses/IdenProf](https://github.com/OlafenwaMoses/IdenProf)****因为训练人工智能模型需要高性能的计算机系统，我强烈建议你确保你要用于这次训练的电脑/笔记本电脑有**英伟达 GPU。**或者，你可以使用**谷歌 Colab** 进行这个实验，它提供了一个免费的 **NVIDIA K80 GPU** 用于实验。****然后你必须安装 **ImageAI** 及其依赖项。*******安装 Python 3.7.6 和 pip*******(如果您已经安装了 Python 3.7.6，请跳过本节)****[](https://www.python.org/downloads/release/python-376/) [## Python 版本 Python 3.7.6### 发布日期:2019 年 12 月 18 日现在 Python 3.7 有了更新的 bugfix 版本，取代了 3.7.6，Python 3.8 是…www.python.org](https://www.python.org/downloads/release/python-376/) ***安装 ImageAI 和依赖关系***(如果您已经安装了库，请跳过本节中的任何安装说明)**-张量流**``` pip install tensorflow==2.4.0 ```**-其他**``` pip install keras==2.4.3 numpy==1.19.3 pillow==7.0.0 scipy==1.4.1 h5py==2.10.0 matplotlib==3.3.2 opencv-python keras-resnet==0.2.0 ```***安装 ImageAI 库***``` pip install imageai --upgrade ```创建一个 python 文件，使用您想要的任何名称，例如 **"FirstTraining.py"** 。将 **IdenProf 数据集**的 zip 文件复制到 Python 文件所在的文件夹中。然后解压到同一个文件夹。然后将下面的代码复制到 python 文件中(例如 **FirstTraining.py** )。**就是这样！这就是你训练人工智能模型所需的全部代码。在您运行代码开始培训之前，让我们解释一下代码。**在第一行，我们导入了 ImageAI 的模型培训班。在第二行中，我们创建了模型训练类的一个实例。在第三行中，我们将模型类型设置为 **ResNet50** (有四种模型类型可用，分别是 **MobileNetv2** 、 **ResNet50** 、 **InceptionV3** 和 **DenseNet121** )。在第四行，我们将**数据目录**(数据集目录)设置为您解压缩的**数据集** zip 文件的文件夹。然后在第五行中，我们调用了 **trainModel** 函数，并指定了以下值: **number _ objects**:这是指 IdenProf 数据集中不同类型专业人员的数量。 **num _ experiments**:这是模型训练者为了达到最大精度而研究 idenprof 数据集中所有图像的次数。 **Enhance _ data(可选)**:这是告诉模型训练员在 IdenProf 数据集中创建图像的修改副本，以确保达到最大的准确性。 **batch _ size:**这是指模型训练器在研究完 IdenProf 数据集中的所有图像之前，一次研究的图像集的数量。 **Show _ network _ summary(可选)**:这是为了显示你正在用来训练人工智能模型的模型类型的结构。现在，您可以开始运行 Python 文件并开始培训。当培训开始时，您将看到如下结果:``` =====================================Total params: 23,608,202Trainable params: 23,555,082Non-trainable params: 53,120______________________________________Using Enhanced Data GenerationFound 4000 images belonging to 4 classes.Found 800 images belonging to 4 classes.JSON Mapping for the model classes saved to C:\Users\User\PycharmProjects\FirstTraining\idenprof\json\model_class.jsonNumber of experiments (Epochs) : 200Epoch 1/1001/280 [>.............................] - ETA: 52s - loss: 2.3026 - acc: 0.25002/280 [>.............................] - ETA: 52s - loss: 2.3026 - acc: 0.25003/280 [>.............................] - ETA: 52s - loss: 2.3026 - acc: 0.2500.............................., .............................., ..............................,279/280 [===========================>..] - ETA: 1s - loss: 2.3097 - acc: 0.0625Epoch 00000: saving model to C:\Users\User\PycharmProjects\FirstTraining\idenprof\models\model_ex-000_acc-0.100000.h5280/280 [==============================] - 51s - loss: 2.3095 - acc: 0.0600 - val_loss: 2.3026 - val_acc: 0.1000 ```让我们解释一下上面显示的细节:1.语句“**保存到 C:\ Users \ User \ PycharmProjects \ first training \ idenprof \ JSON \ model _ class . JSON**的模型类的 JSON 映射”意味着模型训练器已经为 iden prof 数据集保存了一个 **JSON** 文件，您可以使用该文件来识别带有自定义图像预测类的其他图片(进一步阅读时可获得解释)。2.线 **Epoch 1/200** 意味着网络正在执行目标 200 3 的第一次训练。线 **1/280 [ > …………………..]—ETA:52s—loss:2.3026—ACC:0.2500**代表本实验已经训练好的批次数 4。行 **Epoch 00000:保存模型到 C:\ Users \ User \ PycharmProjects \ first training \ iden prof \ models \ model _ ex-000 _ ACC-0.100000 . H5**是指本次训练后保存的模型。 **ex_000** 表示本阶段的实验，而**ACC*0.100000****和****val*ACC:0.1000**表示本次实验后测试图像上模型的精度(精度的最大值为 1.0)。此结果有助于了解可用于自定义图像预测的最佳执行模型。一旦你完成了对你的人工智能模型的训练，你就可以使用" **CustomImagePrediction** "类来执行图像预测，你就是达到最高准确度的模型。为了防止您由于无法访问 **NVIDIA GPU** 而无法自己训练人工智能模型，出于本教程的目的，我们提供了一个我们在 **IdenProf** 数据集上训练的人工智能模型，您现在可以使用它来预测数据集中 10 位专业人士中任何一位的新图像。经过 **61** 训练实验，该模型达到了超过 **79%** 的准确率。点击此[链接](https://github.com/OlafenwaMoses/IdenProf/releases/download/v1.0/idenprof_061-0.7933.h5)下载模型。此外，如果您自己没有进行培训，也可以通过此[链接](https://github.com/OlafenwaMoses/IdenProf/blob/master/idenprof_model_class.json)下载 idenprof 模型的 **JSON** 文件。然后，你就可以开始使用训练好的人工智能模型识别专业人士了。请按照下面的说明操作。接下来，创建另一个 Python 文件并给它命名，例如**firstcustomimagerecognition . py**。复制你在上面下载的人工智能模型或你训练的达到最高准确度的模型，并将其粘贴到你的新 python 文件所在的文件夹中(例如**firstcustomimagerecognition . py**)。另外，复制您下载的或者由您的训练生成的 **JSON** 文件，并将其粘贴到与您的新 python 文件相同的文件夹中。将属于 IdenProf 数据集中类别的任何专业人员的样本图像复制到与新 python 文件相同的文件夹中。然后复制下面的代码，并将其放入新的 python 文件中查看下面的样本图像和结果。``` waiter : 99.99997615814209chef : 1.568847380895022e-05judge : 1.0255866556008186e-05 ```那很容易！现在让我们解释一下上面产生这个预测结果的代码。上面的第一行和第二行代码导入了 ImageAI 的**CustomImageClassification** 类和 python **os** 类，其中 CustomImageClassification 类用于使用训练好的模型预测和识别图像。第三行代码创建一个变量，该变量保存对包含您的 python 文件(在本例中是您的**firstcustomimagerecognition . py**)和您自己下载或训练的 **ResNet50** 模型文件的路径的引用。在上面的代码中，我们在第四行创建了一个**CustomImageClassification()**类的实例，然后我们通过调用。第五行中的 setModelTypeAsResNet50() 然后我们将预测对象的模型路径设置为我们复制到第六行的项目文件夹文件夹中的人工智能模型文件(**iden prof _ 061–0.7933 . H5**)的路径。在第七行，我们设置了复制到第七行的文件夹中的 **JSON** 文件的路径，并在第八十行加载了模型。最后，我们对复制到文件夹中的图像进行预测，并将结果打印到**命令行界面**。到目前为止，你已经学会了如何使用 **ImageAI** 来轻松训练你自己的人工智能模型，它可以预测图像中任何类型的对象或对象集。> *如果您想通过链接了解更多有用和实用的资源，请访问下面链接的* ***图像识别指南*** *。*[](https://www.fritz.ai/image-recognition/) [## 图像识别指南### 现在我们知道了一些关于什么是图像识别，不同类型的图像识别之间的区别…www.fritz.ai](https://www.fritz.ai/image-recognition/) 你可以在官方 GitHub 知识库上找到使用 **ImageAI** 训练定制人工智能模型的所有细节和文档，以及包含在 **ImageAI** 中的其他计算机视觉功能。[](https://github.com/OlafenwaMoses/ImageAI) [## OlafenwaMoses/ImageAI### 这是一个开源 python 库，旨在使开发人员能够使用自包含的深度…github.com](https://github.com/OlafenwaMoses/ImageAI) 如果你觉得这篇文章很有帮助并且喜欢，请给它一个**的掌声**。此外，请随意与朋友和同事分享。你有什么问题、建议或者想要联系我吗？给我发邮件到[guymodscientist@gmail.com](mailto:guymodscientist@gmail.com)。我也可以通过账号 [@OlafenwaMoses](https://twitter.com/OlafenwaMoses) 在 twitter 上联系，通过[https://www.facebook.com/moses.olafenwa](https://www.facebook.com/moses.olafenwa)在脸书联系。**# 在 Python 中训练/测试分割和交叉验证> 原文：<https://towardsdatascience.com/train-test-split-and-cross-validation-in-python-80b61beca4b6?source=collection_archive---------0----------------------->大家好！在我上一篇关于 Python 中的[线性回归的文章之后，我认为写一篇关于训练/测试分割和交叉验证的文章是很自然的。像往常一样，我将对这个主题做一个简短的概述，然后给出一个用 Python 实现它的例子。这是数据科学和数据分析中两个相当重要的概念，被用作防止(或至少最小化)](https://medium.com/towards-data-science/simple-and-multiple-linear-regression-in-python-c928425168f9)[过度拟合](https://en.wikipedia.org/wiki/Overfitting)的工具。我将解释这是什么-当我们使用统计模型(例如线性回归)时，我们通常将模型拟合到训练集，以便对未经训练的数据(一般数据)进行预测。过度拟合意味着我们对模型的拟合过于依赖训练数据。很快就会明白的，我保证！# 什么是过度拟合/欠拟合模型？如上所述，在统计学和机器学习中，我们通常将数据分为两个子集:训练数据和测试数据(有时分为三个子集:训练、验证和测试)，并根据训练数据拟合我们的模型，以便对测试数据进行预测。当我们这样做时，可能会发生两种情况之一:我们使模型过拟合或者使模型欠拟合。我们不希望这些事情发生，因为它们会影响我们模型的可预测性——我们可能会使用一个准确性较低和/或不通用的模型(这意味着你不能根据其他数据概括你的预测)。让我们来看看欠拟合和过拟合的实际含义:## 过度拟合过度拟合意味着我们训练的模型已经训练得“太好”,并且现在与训练数据集太接近了。这通常发生在模型过于复杂的时候(例如，与观察值相比，特征/变量太多)。该模型在训练数据上非常准确，但在未训练或新数据上可能非常不准确。这是因为这个模型不是一般化的(或者说不是一般化的)，这意味着你可以对结果进行一般化，而不能对其他数据进行任何推断，而这正是你最终想要做的。基本上，当这种情况发生时，模型学习或描述训练数据中的“噪声”,而不是数据中变量之间的实际关系。显然，这种噪声不是任何新数据集的一部分，也不能应用于它。## 欠拟合与过度拟合相反，当模型拟合不足时，意味着模型不适合训练数据，因此错过了数据中的趋势。这也意味着该模型不能推广到新的数据。正如你可能猜到的(或者想出来的！)，这通常是一个非常简单的模型(没有足够的预测器/自变量)的结果。例如，当我们用线性模型(如[线性回归](https://medium.com/towards-data-science/simple-and-multiple-linear-regression-in-python-c928425168f9))拟合非线性数据时，也会发生这种情况。几乎不言而喻，这个模型的预测能力会很差(对训练数据，无法推广到其他数据)。An example of overfitting, underfitting and a model that’s “just right!”值得注意的是，适配不足不像适配过度那样普遍。然而，我们希望在数据分析中避免这两个问题。你可能会说，我们正试图找到一个中间地带之间的不足和过度拟合我们的模型。正如您将看到的，训练/测试分割和交叉验证有助于避免过度拟合多于欠拟合。让我们深入了解这两个问题！# 训练/测试分割我之前说过，我们使用的数据通常分为训练数据和测试数据。训练集包含一个已知的输出，模型学习这个数据，以便以后推广到其他数据。我们有测试数据集(或子集)来测试我们的模型对这个子集的预测。Train/Test Split让我们看看如何在 Python 中实现这一点。我们将使用 [Scikit-Learn 库](http://scikit-learn.org/stable/index.html)，特别是 [train_test_split 方法](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html)来完成这项工作。我们将从导入必要的库开始:``` import pandas as pd from sklearn import datasets, linear_model from sklearn.model_selection import train_test_split from matplotlib import pyplot as plt ```让我们快速浏览一下我导入的库:* **Pandas** —加载数据文件作为 Pandas 数据框并分析数据。如果你想了解更多关于熊猫的信息，请随时查看我的帖子！ * 从 **Sklearn** 中，我已经导入了*数据集*模块，因此我可以加载一个样本数据集，以及 *linear_model* ，因此我可以运行一个线性回归 * 从 **Sklearn，**子库 **model_selection** ，我已经导入了 *train_test_split* ，这样我就可以，嗯，拆分到训练集和测试集 * 从 **Matplotlib** 中，我导入了 *pyplot* 来绘制数据的图形好了，都准备好了！让我们加载[糖尿病数据集](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_diabetes.html)，将其转换为数据框并定义列名:``` # Load the Diabetes dataset columns = “age sex bmi map tc ldl hdl tch ltg glu”.split() # Declare the columns names diabetes = datasets.load_diabetes() # Call the diabetes dataset from sklearn df = pd.DataFrame(diabetes.data, columns=columns) # load the dataset as a pandas data frame y = diabetes.target # define the target variable (dependent variable) as y ```现在我们可以使用 train_test_split 函数来进行拆分。函数中的 *test_size=0.2* 表示应该保留下来进行测试的数据的百分比。一般是 80/20 或者 70/30 左右。``` # create training and testing vars X_train, X_test, y_train, y_test = train_test_split(df, y, test_size=0.2) print X_train.shape, y_train.shape print X_test.shape, y_test.shape(353, 10) (353,) (89, 10) (89,) ```现在，我们将根据训练数据拟合模型:``` # fit a model lm = linear_model.LinearRegression()model = lm.fit(X_train, y_train) predictions = lm.predict(X_test) ```如您所见，我们正在根据训练数据拟合模型，并尝试预测测试数据。让我们看看有哪些预测:``` predictions[0:5] array([ 205.68012533, 64.58785513, 175.12880278, 169.95993301,128.92035866]) ```注意:因为我在预测后使用了[0:5],所以它只显示了前五个预测值。删除[0:5]会使它打印出我们的模型创建的所有预测值。让我们绘制模型:``` ## The line / model plt.scatter(y_test, predictions) plt.xlabel(“True Values”) plt.ylabel(“Predictions”) ```并打印准确度分数:``` print “Score:”, model.score(X_test, y_test)Score: 0.485829586737 ```这就对了。以下是我所做工作的总结:我加载了数据，将其分为训练集和测试集，对训练数据拟合了回归模型，基于这些数据进行了预测，并对测试数据的预测进行了测试。看起来不错，对吧？但是训练/测试分割确实有它的危险——如果我们做的分割不是随机的呢？如果我们数据的一个子集只有某个州的人，有某个收入水平的员工，而没有其他收入水平的，只有女性或只有某个年龄的人，会怎么样？(想象一个由这些文件之一排序的文件)。这将导致过度拟合，即使我们试图避免它！这就是交叉验证的用武之地。# 交互效度分析在前一段中，我提到了训练/测试分割方法中的注意事项。为了避免这种情况，我们可以执行一种叫做[的交叉验证](https://en.wikipedia.org/wiki/Cross-validation_(statistics))。它非常类似于训练/测试分割，但是它适用于更多的子集。也就是说，我们将数据分成 k 个子集，并在其中的 k-1 个子集上进行训练。我们要做的是保留最后一个子集进行测试。我们可以对每个子集都这样做。Visual Representation of Train/Test Split and Cross Validation. H/t to my [DSI](https://generalassemb.ly/education/data-science-immersive) instructor, [Joseph Nelson](https://medium.com/u/690e8d667b35?source=post_page-----80b61beca4b6--------------------------------)!有很多交叉验证方法，我将介绍其中的两种:第一种是 **K 重交叉验证**第二种是**留一交叉验证** (LOOCV)## k 重交叉验证在 K 折叠交叉验证中，我们将数据分成 K 个不同的子集(或折叠)。我们使用 k-1 个子集来训练我们的数据，并将最后一个子集(或最后一个折叠)作为测试数据。然后，我们根据每个褶皱对模型进行平均，然后最终确定我们的模型。之后，我们用测试集来测试它。Visual representation of K-Folds. Again, H/t to [Joseph Nelson](https://medium.com/u/690e8d667b35?source=post_page-----80b61beca4b6--------------------------------)!这里有一个来自 K 折叠的 [Sklearn 文档](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html#sklearn-model-selection-kfold)的非常简单的例子:``` from sklearn.model_selection import KFold # import KFold X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) # create an array y = np.array([1, 2, 3, 4]) # Create another array kf = KFold(n_splits=2) # Define the split - into 2 folds kf.get_n_splits(X) # returns the number of splitting iterations in the cross-validatorprint(kf) KFold(n_splits=2, random_state=None, shuffle=False) ```让我们看看结果——褶皱:``` for train_index, test_index in kf.split(X):print(“TRAIN:”, train_index, “TEST:”, test_index)X_train, X_test = X[train_index], X[test_index]y_train, y_test = y[train_index], y[test_index]('TRAIN:', array([2, 3]), 'TEST:', array([0, 1])) ('TRAIN:', array([0, 1]), 'TEST:', array([2, 3])) ```如您所见，该函数将原始数据分割成不同的数据子集。再次，非常简单的例子，但我认为它很好地解释了这个概念。## 遗漏一项交叉验证(LOOCV)这是另一种交叉验证的方法，[省去一个交叉验证](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.LeaveOneOut.html#sklearn.model_selection.LeaveOneOut)(顺便说一下，这些方法不是唯一的两种，还有一堆其他的交叉验证的方法。在 [Sklearn 网站](http://scikit-learn.org/stable/modules/classes.html#module-sklearn.model_selection)查看。在这种类型的交叉验证中，折叠(子集)的数量等于我们在数据集中的观察数量。然后，我们对所有这些折叠进行平均，并用平均值构建我们的模型。然后，我们根据最后一次折叠测试模型。因为我们会得到大量的训练集(等于样本数)，这种方法计算量很大，应该在小数据集上使用。如果数据集很大，最好使用不同的方法，比如 kfold。让我们看看 Sklearn 的另一个例子:``` **from** **sklearn.model_selection** **import** LeaveOneOut X = np.array([[1, 2], [3, 4]]) y = np.array([1, 2]) loo = LeaveOneOut() loo.get_n_splits(X)**for** train_index, test_index **in** loo.split(X):print("TRAIN:", train_index, "TEST:", test_index)X_train, X_test = X[train_index], X[test_index]y_train, y_test = y[train_index], y[test_index]print(X_train, X_test, y_train, y_test) ```这是输出结果:``` ('TRAIN:', array([1]), 'TEST:', array([0])) (array([[3, 4]]), array([[1, 2]]), array([2]), array([1])) ('TRAIN:', array([0]), 'TEST:', array([1])) (array([[1, 2]]), array([[3, 4]]), array([1]), array([2])) ```再次，简单的例子，但我真的认为它有助于理解这个方法的基本概念。那么，我们应该用什么方法呢？多少折？我们有越多的折叠，我们将减少由于偏差引起的误差，但是增加由于方差引起的误差；显然，计算成本也会上升——折叠次数越多，计算时间就越长，并且需要更多内存。随着折叠次数的减少，我们减少了方差引起的误差，但偏差引起的误差会更大。这也将在计算上更便宜。因此，在大数据集中，通常建议 k=3。在较小的数据集中，正如我之前提到的，最好使用 LOOCV。让我们看看我之前使用的例子，这次是使用交叉验证。我将使用 *cross_val_predict* 函数返回测试切片中每个数据点的预测值。``` # Necessary imports: from sklearn.model_selection import cross_val_score, cross_val_predict from sklearn import metrics ```如您所知，之前我已经为糖尿病数据集创建了训练/测试分割，并拟合了一个模型。我们来看看交叉验证后的分数是多少:``` # Perform 6-fold cross validation scores = cross_val_score(model, df, y, cv=6) print “Cross-validated scores:”, scoresCross-validated scores: [ 0.4554861 0.46138572 0.40094084 0.55220736 0.43942775 0.56923406] ```如你所见，最后一次折叠提高了原始模型的分数——从 0.485 提高到 0.569。不是一个惊人的结果，但嘿，我们会采取我们能得到的:)现在，让我们在执行交叉验证后，绘制新的预测:``` # Make cross validated predictions predictions = cross_val_predict(model, df, y, cv=6) plt.scatter(y, predictions) ```你可以看到它与早期的原始情节有很大的不同。因为我用了 cv=6，所以是原图的 6 倍多。最后，让我们检查模型的 R 得分(R 是一个“表示从自变量可预测的因变量中方差的比例的数字)”。基本上，我们的模型有多精确):``` accuracy = metrics.r2_score(y, predictions) print “Cross-Predicted Accuracy:”, accuracyCross-Predicted Accuracy: 0.490806583864 ```这次到此为止！我希望你喜欢这篇文章。一如既往，我欢迎大家就您想阅读的主题提出问题、笔记、评论和请求。下次见！# 关于机器学习中训练、验证和测试集> 原文：<https://towardsdatascience.com/train-validation-and-test-sets-72cb40cba9e7?source=collection_archive---------0----------------------->这旨在成为任何需要在训练机器学习模型时了解各种数据集分割之间的差异的人的简短入门。对于这篇文章，我会引用 Jason Brownlee 的优秀文章中关于同一主题的基本定义，它非常全面，请查看更多细节。# **训练数据集**> **训练数据集**:用于拟合模型的数据样本。我们用来训练模型的实际数据集(神经网络中的权重和偏差)。模型*看到*并且*从该数据中学习*。# **验证数据集**> **验证数据集**:在调整模型超参数时，用于对模型拟合训练数据集提供无偏评估的数据样本。随着验证数据集的技能融入到模型配置中，评估变得更有偏差。验证集用于评估给定的模型，但这是为了频繁的评估。作为机器学习工程师，我们使用这些数据来微调模型超参数。因此，模型偶尔*会看到*该数据，但绝不会从该数据中“学习”。我们使用验证集结果，并更新更高级别的超参数。所以验证集影响模型，但只是间接的。验证集也称为开发集或开发集。这是有意义的，因为该数据集在模型的“开发”阶段有所帮助。# **测试数据集**> **测试数据集**:用于提供最终模型在训练数据集上的无偏评估的数据样本。测试数据集提供了用于评估模型的黄金标准。它仅在模型完全定型后使用(使用定型和验证集)。测试集通常用于评估竞争模型(例如，在许多 Kaggle 竞争中，验证集最初与训练集一起发布，而实际测试集仅在竞争即将结束时发布，测试集上的模型结果决定了获胜者)。很多时候，验证集被用作测试集，但这不是一个好的实践。测试集通常是精心策划的。它包含在现实世界中使用时，模型将面临的各种类别的仔细采样数据。A visualization of the splits## 关于数据集分割比率既然您已经知道了这些数据集的作用，您可能正在寻找关于如何将数据集划分为训练集、验证集和测试集的建议。这主要取决于 2 件事。首先是数据中的样本总数，其次是您正在训练的实际模型。有些模型需要大量数据来进行训练，因此在这种情况下，您应该针对更大的训练集进行优化。具有很少超参数的模型将易于验证和调整，因此您可能会减少验证集的大小，但是如果您的模型具有许多超参数，您也将希望拥有一个大的验证集(尽管您还应该考虑交叉验证)。此外，如果您碰巧有一个没有超参数或者不容易调优的模型，您可能也不需要验证集！总而言之，就像机器学习中的许多其他事情一样，训练-测试-验证分流比也非常具体地取决于你的用例，随着你训练和建立越来越多的模型，做出判断变得越来越容易。交叉验证的注意事项:很多时候，人们首先将他们的数据集分成两部分——训练和测试。在此之后，他们将测试集放在一边，并随机选择其训练数据集的 X%作为实际的 ***训练*** *集，剩余的(100-X)%作为* ***验证*** *集，其中 X 是一个固定的数(比如 80%)，然后在这些不同的集上对模型进行迭代训练和验证。有多种方法可以做到这一点，通常称为交叉验证。基本上，您使用训练集来生成训练集和验证集的多个拆分。交叉验证避免了过度拟合，并且变得越来越流行，K-fold 交叉验证是最流行的交叉验证方法。* [*查看本*](https://en.wikipedia.org/wiki/Cross-validation_(statistics)) *出更多。*如果你想进一步讨论这个问题，请在评论中告诉我。和你们许多人一样，我也是一个初学者，但我肯定会尽我所能帮助你们🙂最初发现于 [http://tarangshah . com/blog/2017-12-03/train-validation-and-test-sets/](http://tarangshah.com/blog/2017-12-03/train-validation-and-test-sets/)# 在人工神经网络上训练你的神经元> 原文：<https://towardsdatascience.com/train-your-neurons-on-artificial-neural-networks-featuring-keras-2757f51bb7ed?source=collection_archive---------8----------------------->Photo by [Lurm](https://unsplash.com/photos/kCrrUx7US04?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/search/photos/patterns?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)C**祝贺！你刚刚迈出了成为巫师的第一步。拿杯咖啡坐下。**神经网络像魔法一样工作！使用 ResNet50 用不到 50 行代码就可以实现一个图像识别神经网络，它会以相当高的准确度识别你的猫或狗的图片。这是纯粹的魔法，这在今天成为可能的本质，即使在理解了它是如何工作的之后，对我来说仍然像是魔法。理解深度学习不是知道这不是魔术而是纯粹的统计和代码，而是理解这种魔术是如何工作的。它是知道如何成为一个数据向导。我打算让这篇文章尽可能地让对神经网络了解很少或没有背景的人容易理解。在揭开它的神秘面纱之后，我们将在 Keras 上训练一个简单的神经网络(没有什么太复杂的。我们暂时不会深入到图像识别或 GANs 中去寻找乐趣。我将提供链接和其他资源，以便更好地直观理解，我强烈建议您在阅读本文时浏览它们。在文章的最后，我会添加我个人用来发展我对任何概念的理解的所有资源，我相信这些资源对于任何在这个领域入门的人来说都是非常棒的。来回答人们关于深度学习最常见和最受欢迎的问题之一:> 我学习深度学习和制作神经网络需要多少时间？是不是涉及很多复杂的数学(微积分和矩阵)？ > > 在深度学习中发展任何重要的技能都需要花费大量的时间。领域很大！当然，你可以凭直觉知道代码在做什么，然后立刻构建一些奇特的项目，但是你真的想这么做吗？至于第二部分，是的，它确实涉及大量的数学尤其是微积分。最初的主题很容易理解，但随着你在该领域的进展，复杂性成了一个切线斜率。我发现很多话题真的很难理解。但是有一次我联系了一个研究生，告诉他我发现数学对我的水平来说有点太复杂了。我得到的建议是我得到过的最好的建议之一:找出你为什么要学习深度学习？如果原因是为了挣钱或者跟风，很容易迷失方向。找到你想做的东西，并为之努力。老实说，这是我听到的最好的事情，我想它一直伴随着我。***拥抱！***# 神经网络是如何出现的关于神经网络和深度学习的工作和研究可以追溯到 20 世纪 50 年代，当时研究人员实际上使用了*电路来实现一个简单的神经网络*。这项研究的潜在灵感是实现我们实际的神经元如何工作，以及是否有可能实现一种可以以类似方式工作的机器。从那以后，关于这个话题的研究越来越多。但直到最近几年，我们才找到在日常生活中实现这些算法的方法，以最大限度地提高效率并降低复杂性。我们从感知器开始，最终出现了更有用的概念，如支持向量机、反向传播和针对不同应用的不同类型的神经网络。我们已经达到了这样一个阶段，我们可以使用一个预先训练好的模型，只需修改它的末端，使它适用于我们的使用(转移学习)，这就像把记忆从一个大脑转移到另一个大脑一样！*因此，我们有了这个完全基于数据的蓬勃发展的产业。*你可以通过以下链接了解更多关于神经网络的历史。它们真的很有趣，知道这些概念是如何产生的总是好的:Chris Bishop. Source: Wikipedia* [关于神经网络基础的研究论文](http://www.ijritcc.org/download/Research%20Paper%20on%20Basic%20of%20Artificial%20Neural%20Network.pdf) * [斯坦福大学 1940 年至 1970 年的历史](https://cs.stanford.edu/people/eroberts/courses/soco/projects/neural-networks/History/history1.html)> “机器学习的基础。。。深度神经网络” > > 克里斯·毕晓普# 神经网络如何工作理解神经网络的最好方法是用可视化的例子。在这一节的最后，我会提供一些很棒的资源，但重要的是要从文本上理解这个主题，或者为了更好的理解而阅读一遍。> 需要记住的一件重要事情是，人工神经网络与我们大脑中的神经网络密切相关。唯一的区别是，我们大脑的网络能够理解更广泛的领域，而人工神经网络仅限于一个或几个理解领域。你可以认为这是音乐家和音乐播放器之间的区别。一个音乐家可以发明、修改和演奏一种音乐类型等等。音乐播放器可以播放你输入的任何歌曲。它将能够一遍又一遍地播放同样的音乐，没有任何错误。一个音乐家在这里会失败，因为无论他多么努力，在再次演奏同一首曲子时总会有一些不同。也许一个和弦以一种微不足道的不同力量敲击着。但问题是，如果我们把音乐播放器想象成一个神经网络，它能够做音乐家能做的事情。但它仅限于一件事(或一个应用领域)。除了它能做的一件事，它什么也做不了，而且从不失败。神经网络通常以这种方式工作:* 你把信息输入到网络的输入端。 * 信息流经网络的边缘和节点。 * 最后，我们只剩下一个最终输出。这个输出不一定是一个数字，而是输出是一个对象的概率，以防我们对某个东西进行分类。因此，在分类的情况下，我们将剩下神经网络来告诉我们输出的概率。这是我们的网络的理解，它认为哪个输出与输入匹配得更好。Source: [https://www.extremetech.com](https://www.extremetech.com)一个神经网络由 3 种类型的层组成:**输入层(我们在其中输入)，隐藏层(处理发生的地方)和输出层(我们获得的结果)**。你可能想知道为什么我们堆叠神经元的“层”来构建神经网络，以及我们如何确定我们需要的层数或每层中的节点数。这是一个非常简短的主题，没有选择层数和节点数的硬性编码规则。有一些通用的方法，但是层数和节点数决定了你的模型的*过拟合*和*欠拟合*。因此，通常我们必须测试和评估我们的模型，以检查哪一个效果最好。说到层的概念，学习是将许多小信息包组合成一个大信息包的过程。假设让你解这个方程:“4 + 7”。你会立刻得出答案是 11。但是让我们想一想。这个信息是硬编码到你的大脑中的吗，无论何时你看到这个等式，你都可以推导出它等于 11？不会，举个例子:“1234 * 432”。我相信你需要一点时间来解决这个问题，但你最终会的。当我们看一个等式时，我们的大脑首先把它分解成小的信息包。在这种情况下，我们首先看到的是“4”、“7”和“+”运算符。我们的大脑假设“4”和“7”是操作数。我们大脑的下一步是决定我们需要对这两个数做什么运算，或者在我们的例子中做加法。所以我们的大脑最终决定，我们必须将这两个数字相加，输出结果是“11”。为什么我们这么快就评估了这两个数字，而不是另外两个更大的数字？这就是“权重”概念的由来。当我们在很小的时候就开始学习数学时，我们的大脑是在较小的数字例子上接受训练的。随着我们的成长，我们倾向于做更多这样的小操作。“2*2”是“4”，我们几乎不需要一个分数来确定这个原因，因为在我们的生活中，我们通常要处理这个方程成千上万次。每一次，我们的大脑都在输入“2*2”和“4”之间增加权重，就像我们的神经网络在每一层映射不同的神经元一样。这两层的边连接被赋予权重，随着时间的推移我们重复这个等式，权重继续增加。我们对输出为“4”感觉更积极，而我们肯定地知道输出不会是“5”(因此，连接输入和输出的边的权重是“0”)。确定神经网络输出的概念完全基于*“激活”*。神经网络的神经元只保存一个数字。在输入层的不同神经元中可能有不同的数目，或者可能没有(等于 0)。所有神经元的数据通过加权边流向下一层。边缘被加权以表示哪些神经元在决定我们的结果时更重要。当加权数据到达下一层神经元时，它会遇到一个激活函数。另外，我们称这个网络为*前馈神经网络*，因为信息向前流动。激活函数的作用是:它只是将输入转换为正值或负值，同时增加一些复杂性以支持梯度下降算法。通过将输入转换为带符号的值，我们可以确定神经元是否应该激活/激发，也就是说，它是否应该向前传递信息。神经元本质上决定这个输入对我们的下一步是否重要，或者如果我们就此停止会更好，因为它不会增加更多的价值，只会混淆我们的网络。但是，即使在激活之后，我们也可以预期一些不需要的值会到达输出，以防我们的神经网络无法访问足够多的信息，使其足够智能来识别这些差异。假设我们必须识别一个“5”，那么我们可能得到两个输出:一个“5”和一个“S ”,因为它们在某种程度上在视觉上是相似的。输出有一个 0 到 1 之间的数字，它告诉我们输出是我们实际答案的概率。因此，如果我们的神经网络完全愚蠢，它可能更喜欢“S”而不是“5 ”,但如果它相当聪明，它可能会说输入是“5”的概率是 0.78，而输入是“S”的概率是 0.52。我们的神经网络非常真实。他们不会说谎。如果他们感到不确定，他们会简单地告诉我们，他们认为两个或更多的输出是可能的，但他们觉得其中一个比其他的更有可能。以下是关于神经网络如何工作一些极好的视觉解释:* [3Blue1Brown 关于神经网络的 Youtube 视频](https://www.youtube.com/watch?v=aircAruvnKk&list=WL&index=5&t=0s) * [Brandon Rohrer 关于卷积神经网络的 Youtube 视频](https://www.youtube.com/watch?v=5aHRBCVTNKE) * [谷歌博客上关于神经网络内部运作的文章](https://www.blog.google/topics/machine-learning/understanding-inner-workings-neural-networks/)# 人工神经网络中的一些重要概念Source: [https://nbmpub.com/](https://nbmpub.com/)**反向传播:**反向传播的概念对于理解深度神经网络的训练非常重要。一开始，当我们的神经网络结构固定时，我们对模型的所有边初始化一些随机权重。之后，我们开始通过神经网络传递训练数据。当然，大多数时候，我们在开始时不会得到一个正确的输出，因为我们的模型没有为它调整，因为我们随机初始化了边的权重。这就是反向传播概念发挥作用的地方。当我们得到一个输出时，我们可以计算出与实际值相比的输出的*误差*。我们将这个误差反馈给我们的神经网络，并告诉它调整它的权重和模型参数，以最小化这个误差，从而提高它的准确性。这是使用梯度下降和链式法则完成的。([观看 RimstarOrg 的视频，它直观地解释了这个概念](https://www.youtube.com/watch?v=WZDMNM36PsM))如果你想理解这个概念背后的数学原理，这里有一个很好的资源解释了反向传播。[*Brilliant.org 上的反向传播*](https://brilliant.org/wiki/backpropagation/)**激活功能:**当一个神经元接收到一个输入时，该神经元被分配两个任务: **1。根据需要修改输入产生输出& 2。决定是否将其作为输出传递**。激活函数主要为我们提供了一个*非线性函数*，这对于训练神经网络来解决复杂问题是必不可少的。没有激活函数的神经网络只是一个线性回归模型。*为了实现反向传播，我们需要使用梯度下降，如果我们有一个线性函数*就不能实现。如果来自激活函数的输出是正的和相关的，神经元将把它传递给下一个神经元，否则忽略它。有许多种激活函数在它们自己的应用领域中更有效(举几个流行的例子，*二进制步进分类器，ReLU，Tanh* )。请参考以下资源，深入了解激活功能及其类型，以及如何为您的应用选择一种功能:* [激活功能维基百科](https://en.wikipedia.org/wiki/Activation_function) * [分析 Vidhya 文章](https://www.analyticsvidhya.com/blog/2017/10/fundamentals-deep-learning-activation-functions-when-to-use-them/) * [Quora 讨论](https://www.quora.com/How-should-I-choose-a-proper-activation-function-for-the-neural-network)**正则化:**在神经网络中需要正则化以避免过度拟合。“惩罚”一词与正规化的概念产生了很好的共鸣。有许多方法可以通过调整神经网络的参数来调整它。理解正则化技术的参考:* [根据安德烈·卡帕西的材料制作的幻灯片](http://Andrej Karpathy) * 詹姆斯·d·麦卡弗里的博客**迁移学习:**迁移学习可用于这样的情况:我们已经有了一个训练好的模型，我们想用它来完成与该模型所训练的任务相似的其他任务。想象一个被训练识别各种动物的模型。这个模型应该在一个大的训练集上被训练过。现在我们有了这个模型，但是我们不想识别所有的动物。我们想建立一个可以识别狗品种的模型。为此，我们不必训练一个全新的模型。我们已经有了一个高效的模型。我们需要做的就是根据我们的需要调整这个模型。**这种调整是通过改变预训练神经网络的最后一层来完成的，以便根据我们的需要进行预测。**一个很好的例子就是 *ImageNet* 模型，这是一个高效的预训练模型，可用于图像识别。我们可以直接在 Keras 中拉动模型，移除最后一层，并根据我们希望它识别的对象为其提供我们的最后一层。点击此处了解有关迁移学习的更多信息:* [关于图像再训练的 Tensorflow 教程](https://www.tensorflow.org/tutorials/image_retraining) * [CS231 课程笔记](http://cs231n.github.io/transfer-learning/) * [塞巴斯蒂安·鲁德的博客](http://ruder.io/transfer-learning/)【非常详细】**优化:**我们说神经网络优化，其实是指*减少目标函数中的误差，也就是均方误差函数(损失/代价函数)*。我们必须优化神经网络的权重以最小化目标函数。反向传播是目前最广泛使用的训练神经网络的优化技术，但它的范围在一定程度上是有限的。此外，还有其他优化方法可能会产生相同的结果，但可以显著减少训练时间，这是深度学习中的一个重要商品。这些其他优化技术易于使用，并且可以在训练 Keras 模型时使用参数进行设置。阅读优化技术很重要，因为我们在训练模型时会经常用到它们。这些是我用来了解其他优化技术基础的一些好资源:* [伊恩·古德菲勒深度学习著作中的优化相关章节](http://www.deeplearningbook.org/contents/optimization.html) * [学习优化神经网络——李柯和吉滕德拉·马利克的论文](https://arxiv.org/pdf/1703.00441.pdf) * 【CS231n 的参数更新部分**死亡神经元:**如果我们使用类似 ReLU( *整流线性单元*)的激活函数，我们可能会面临死亡神经元的问题。如果输出为正，ReLU 函数返回整数，如果输出为负(经过校正)，则返回零。有些情况下，神经元必须处理许多负值作为其输入，这些输入的梯度将始终为 0，因为负输入的梯度始终为 0。由于激活功能的这种性质，一些神经元可能永远不会因为训练集的性质而调整和死亡。一般来说，当使用 ReLU 激活时，我们会处理网络中的一些死亡神经元，但这不是问题。但在某些情况下，如果死亡神经元的数量过多，我们的训练可能会出现重大问题。*对此的解决方案可以是使用泄漏 ReLU 激活功能*。## 神经网络的类型神经网络的类型如此之多，以至于可能需要一整篇文章来讨论高级别的基本概念。Source: asimovinstitute.org每组应用程序都有一个神经网络。最受欢迎的肯定是*卷积神经网络* (CNN)，因为它在从图像中学习方面具有出色的能力，这是深度学习最常用的应用之一。但是你不能用 CNN，如果假设，你想开发一个程序，可以生成梵高风格的艺术。你需要使用*生成对抗网络* (GAN)。gan 是神经网络中最好的部分，我喜欢它！如果深度学习是魔法，那么 GANs 就是下一个维度。**谷歌大脑团队利用敌对网络开发了一种新的加密形式。这是一篇非常有趣的论文。一定要去看看！** [**官方论文来自 arXiv**](https://arxiv.org/pdf/1610.06918.pdf)旁边的图片总结了目前可用的所有类型的神经网络。一定要看一看。试着想想它们之间有什么不同。## Python 的深度学习库> 说到制造人工神经网络，数据科学社区拥有大量的工具和选择！一些最受欢迎的是:* [谷歌的 Tensorflow](https://www.tensorflow.org/) * [theno](http://deeplearning.net/software/theano/) * [微软认知工具包(CNTK)](https://www.microsoft.com/en-us/cognitive-toolkit/)对于初学者来说，使用这些库可能有点困难，因为对于完全陌生的人来说，理解它们的代码可能有点复杂。所以有更好的，*易于理解和直观的框架可用*，它使用上面提到的库作为它们的后端。因此，构建新模型变得非常容易，代码也很短，而且非常直观。最受欢迎的两个是:* [Keras](https://keras.io/#getting-started-30-seconds-to-keras) * [咖啡馆](http://caffe.berkeleyvision.org/)所有这些库都非常灵活，易于设置和开始。个人比较喜欢 Tensorflow 后端的 Keras。我非常喜欢 Keras 的一个原因是因为神经元层的堆叠和编译模型非常直观和简单。您可以随意查看所有代码示例，看看哪一个对您来说更直观。# Keras 简介Source: blog.keras.io如果要我说为什么我更喜欢 Keras 而不是其他框架，我只会说:“ **Keras 优先考虑开发者体验**”。这很重要。大多数框架在构建时都有一个主要目标，那就是使它们快速高效，由于这个原因，大多数时候它们错过了开发人员的体验，即开发人员使用它们和学习使用它们有多容易。Keras 支持 Python 从 2.7 到 3.6 的所有主要版本，根据对 Stackoverflow 和 arXiv 论文的分析，它是最受欢迎的深度学习库之一。Keras 还支持许多硬件配置，包括 Nvidia GPUs 和 Google TPUs，后者扩展到多 GPU 和分布式培训支持。下面是来自 Keras 主页的示例代码。你能猜出它在做什么吗？``` **from** keras.models **import** Sequential **from** keras.layers **import** Dense, Activationmodel = Sequential() model.add(Dense(32, input_dim=784)) model.add(Activation('relu')) ```***如果你能从样本代码中做出一些推论，你将❤️·克拉斯！******请浏览其主页上的*** [***Kera 入门***](https://keras.io/getting-started/sequential-model-guide/) ***指南，看看 Keras 在行动。***# 在 Keras 中实现神经网络好吧！所以这是最好的部分。我们将在 Keras 中实现一个非常简单的神经网络。(*《15 行代码之下》还有 yada yada！*)我们将向神经网络输入一个 8 位二进制值的样本。它必须识别出哪一个是奇数。下面是一个例子，说明我们将向神经网络输入什么，以及它应该产生什么输出:``` __________________________ Input | Output __________________________ 1 1 1 0 0 1 1 1 1 | 1 1 0 0 0 1 0 0 0 0 | 0 1 1 0 0 1 1 0 1 0 | 0 1 0 0 1 0 1 0 0 0 | 0 1 0 0 1 1 0 1 0 1 | 1 0 0 1 0 0 0 0 1 1 | 1 __________________________ . . . and so on. ```这个任务看起来相当简单！" n%2 "，我们就完事了。但话又说回来，目的不是将其作为一种应用，而是以最简单的方式演示神经网络如何学习。对于这个应用，我们将只需要 2 层神经元。我们现在不需要任何隐藏层，因为基本上不需要它们。你可以在左边的插图中看到我们的神经网络。我们将 Keras 与 Tensorflow 后端一起使用。``` *#We set the seed value with a constant number to get consistent #results every time our neural network is trained. #This is because when we create a model in Keras, it is assigned #random weights every time. Due to this, we might receive different #results every time we train our model. #However this won't be a general issue, our training set is small, #so we take this precaution* **import numpy as np np.random.seed(1) import tensorflow as tf tf.set_random_seed(1) import keras***#We create a training set of fifteen 8-bit binary numbers* **train_X = np.array([[0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,1,1], [0,0,0,0,0,1,0,0], [0,0,0,0,0,1,0,1], [0,0,0,0,0,1,1,0], [0,0,0,0,0,1,1,1], [0,0,0,0,1,0,0,0], [0,0,0,0,1,0,0,1], [0,0,0,0,1,0,1,0], [0,0,0,0,1,0,1,1], [0,0,0,0,1,1,0,0], [0,0,0,0,1,1,0,1], [0,0,0,0,1,1,1,0], [0,0,0,0,1,1,1,1]]) train_y = np.array([0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1]) test_X = np.array([[1,0,0,1,1,1,0,1], [1,0,0,0,0,1,1,0]])***#We create a Sequential model* **model = keras.models.Sequential()***#In the next line, we add both the required layers to our model #The input_dim parameter is the number of input neurons and the #first parameter, "1" is the number of neurons in our first hidden #layer(which happens to be the output layer)* **model.add(keras.layers.Dense(1, input_dim=8, activation='sigmoid'))***#Configuring the model for training* **model.compile(loss='binary_crossentropy', optimizer=keras.optimizers.SGD(lr=1.0), metrics=['accuracy'])***#We have defined all parameters, so we train our model with the training data we created. #epochs: Number of times the dataset is passed through the network #batch_size: Number of samples passed at a time* **model.fit(train_X, train_y, epochs= 20, batch_size= 5)***#Our Neural Network has been trained now. We pass two inputs to the #model to check the results it produce. #The results would be in the range of 0.98 or 0.02 cause we might #still be left with some error rate(which could've been fixed if we #used a bigger training set or different model parameters. #Since we desire binary results, we just round the results using the #round function of Python. #The predictions are actually in* **print([round(x[0]) for x in model.predict(test_X)])** ```我们清楚地知道，输入的第 8 位决定了数字是偶数还是奇数。但这并不为神经网络所知。它在创建时已被分配了随机权重。现在，我们知道，要判断一个偶数或奇数，我们只需要关心最后一位，因此直观地说，将最后一位连接到输出的神经元应该是唯一被激活的神经元(应该将权重设置为“1”)，而其余的应该在训练过程结束时死亡。这就是所发生的一切！神经网络确定输出误差，并使用反向传播，逐渐改变权重，直到前七个神经元全部死亡。因此，我们的神经网络决定一个偶数或奇数。> 恭喜你！你已经建立了你的第一个人工神经网络！## 进一步的学习资源正如我在开始时提到的，这里有一些优秀的资源可以用来开始深度学习。我从一般的路线走了弯路，以一种非常随意的方式学习，没有致力于一种资源，这不是一种非常有效的做法。但我发现的一件事是，在互联网上四处搜寻，寻找一个能教会你关于深度学习一切的最佳课程/书籍/视频，实际上是没有用的。可能有更多更好的学习资源可用，但我只提到其中的一些，因为我个人使用这些资源作为参考。Youtube 频道:* [编码序列](https://www.youtube.com/user/shiffman) * [3 蓝色 1 棕色](https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw) * [send ex](https://www.youtube.com/user/sentdex) * Siraj Raval * [布兰登·罗尔](https://www.youtube.com/user/BrandonRohrer)书籍(这两本书都可以在网上免费阅读):* [伊恩·古德菲勒的深度学习书籍](http://www.deeplearningbook.org/) * [Trevor Hastie 的《统计学习的要素》](https://web.stanford.edu/~hastie/ElemStatLearn/)一些网站:* [分析 Vidhya](https://www.analyticsvidhya.com/) * [机器学习掌握](https://machinelearningmastery.com/) * [EliteDataScience](https://elitedatascience.com/)关于论文，你可以去 arXiv.org 找。我还没有参加过任何课程，但我确实打算很快参加。社区中真正受欢迎的两门课程是:* [Fast.ai](https://www.fast.ai) * [Deeplearning.ai](https://www.deeplearning.ai/)# 用深度强化学习训练猎豹奔跑> 原文：<https://towardsdatascience.com/training-a-cheetah-to-run-with-deep-reinforcement-learning-6dca2975443a?source=collection_archive---------16----------------------->HalfCheetah Model featured by OpenAI Gym + MujoCo猎豹可能有点夸张，但使用深度强化学习，我能够训练一个基于猎豹的物理模型来运行！虽然这可能看起来并不令人兴奋，但让我这么说吧——在训练之前，代理(猎豹)没有任何关于运动的先验知识。它可以进入它的行动空间和观察空间，并且知道它必须尽可能地移动，但仅此而已！任何协调的运动都只是使用强化学习算法训练的产物。在这篇文章中，我将分解我如何训练我的代理运行，以及我用来这样做的 DRL 算法。Video of my trained Agent# 连续动作空间中的强化学习由于 half cheetah 模型使用连续的动作空间而不是离散的动作空间(即，其中一组实数被用作动作，而不是一组可能的选项)，所以基于值近似值的方法不能很好地工作。通常，值函数需要使用 argmax 来确定最优策略，这反过来会使处理连续动作空间变得非常不方便，因为动作空间需要离散化。因此，我们转向策略梯度方法作为我们的算法选择。与基于价值的方法相反，策略梯度直接逼近代理的策略！这反过来使得它非常方便地用于连续动作空间，因为不再需要使用 argmax 之类的东西(从而提高了准确性，并且通常需要较少的计算能力)。# DDPG 算法通常，策略梯度会在动作空间上产生一个概率分布，其中动作在从该分布抽样后返回。然而，在训练期间，概率分布变得更窄，最终导致特定动作(即最优动作)的峰值概率。*X axis would be the action space*DDPG 算法(深度确定性政策梯度)利用了这一事实——鉴于政策梯度产生的概率分布将总是收敛于特定的行动，DDPG 只产生单一输出。简单概述一下，DDPG 是一种被称为“参与者评价算法”的东西，它同时逼近一个价值函数(评价者)和一个政策函数(参与者)。直觉上，演员要对动作负责，而评论家帮助演员决定它的动作有多好。评论家通过使用称为 TD 误差的东西作为其梯度的损失来更新自身，而演员使用以下梯度进行更新:*As mentioned before, the critic is used to help the actor determine how good its action was — as such, the gradient of the critic is used in finding the gradient of the actor.*虽然这看起来非常复杂，但是实现起来非常简单。Gradients are divided by batch_size for normalization, as batches of data may be used as inputs.# 较小的变化虽然 DDPG 算法采用了许多在 DRL 使用的标准技术(例如，经验回放)，但它调整了两件事——目标网络的更新程序，以及如何执行探索。**目标网络:**DDPG 算法不是周期性地将目标网络设置为主要参与者和批评者网络，而是用“软”更新来更新目标网络。参考上面的代码片段，通过用当前主网络逐步替换少量(tau)目标网络来更新目标参数，从而使目标网络更新更稳定，并提高训练效率。**探索:**由于使用了连续的动作空间，诸如 epsilon greedy 的探索技术就不能再使用了。话虽如此，DDPG 通过在预测的行动中增加噪音来使用探索——这反过来又给政策增加了一些“随机性”。The noise can be generated with many different methods —a zero centered gaussian was used for my program.就是这样！在用 DDPG 训练了我的特工几百集之后，我的猎豹特工学会了跑步是最快的移动方式。# 结论DQNs 等基于值的方法可能对强化学习至关重要，但 DDPG 等算法提供的效用简直疯狂。虽然本文只关注它在训练猎豹奔跑中的应用，但潜在的影响要深远得多。以机器人技术为例——如果 DDPG 能够训练机器猎豹奔跑，那么是什么阻止了它训练更复杂的机器人呢？最终，我们仍然面临着一系列障碍，这些障碍目前阻止我们在复杂的机器人技术中使用深度 RL。然而，随着 DRL 不断发展，基于政策梯度的方法，如 DDPG，很可能有一天会成为这种技术的支柱。最后，这里是我文章中的一些摘录:1. 处理连续动作空间与处理离散动作空间非常不同 2. DDPG 是一种行动者批评策略梯度算法，它利用了正常策略梯度的分布在特定行动时达到峰值的事实 3. DDPG 使用噪音进行探索(随机性)，使用“软”目标网络更新来实现稳定性https://github.com/JL321/PolicyGradients-torch[DDPG 更新实现的代码可以在这里找到](https://github.com/JL321/PolicyGradients-torch)## 如果你喜欢这篇文章，一定要拍下这篇文章，并与你的网络分享！## 另外，如果你有兴趣关注我在媒体之外做的一些事情，那么请在 [LinkedIn](https://www.linkedin.com/in/james-l-3b150b134/) 上联系我！# 用深度强化学习训练面向目标的聊天机器人——第一部分> 原文：<https://towardsdatascience.com/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-i-introduction-and-dce3af21d383?source=collection_archive---------2----------------------->## 第一部分:介绍和培训循环在这个系列中，我们将学习面向目标的聊天机器人，并用 python 训练一个具有深度强化学习的聊天机器人！一切从零开始！这个系列教程的代码可以在这里找到。## 系列内容第一部分:介绍和培训循环[第二部分:DQN 代理商](https://medium.com/@maxbrenner110/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-ii-dqn-agent-f84122cc995c)[第三部分:对话状态跟踪器](https://medium.com/@maxbrenner110/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-iii-dialogue-state-d29c2828ce2a)[第四部分:用户模拟器和误差模型控制器](https://medium.com/@maxbrenner110/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-iv-user-simulator-and-a0efd3829364)[第五部分:运行代理和未来研究](https://medium.com/@maxbrenner110/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-v-running-the-agent-and-63d8cd27d1d)# 什么是面向目标的聊天机器人？面向目标(GO)的聊天机器人试图为用户解决特定的问题。这些聊天机器人可以帮助人们订票、寻找预定等。训练围棋聊天机器人有两种主要方式:使用编码器-解码器直接将用户对话映射到响应的监督学习，以及通过与真实用户或基于规则的用户模拟器的试错对话来训练聊天机器人的强化学习。通过深度强化学习训练的围棋聊天机器人是一个非常令人兴奋和成熟的研究领域，有许多实际应用！## 对话系统使用强化学习的围棋聊天机器人的对话系统分为三个主要部分:对话管理器(DM)、自然语言理解(NLU)单元和自然语言生成器(NLG)单元。此外，DM 被分成对话状态跟踪器(DST)或仅状态跟踪器(ST)和用于代理本身的策略，在许多情况下，代理由神经网络表示。此外，系统循环包含具有用户目标的用户。用户目标代表用户希望从对话中得到什么，在下图的情况下是餐馆预订。[](https://ilievskiv.github.io/2017/10/15/go-chatbots-intro/)Dialogue flow for a GO chatbot system在这个循环中，用户说出一些由 NLU 组件处理成所谓的*语义框架*的东西，语义框架是可以由代理处理的自然语言话语的低级表示。DST 将用户对话行为(语义框架)和当前对话的历史处理成代理策略可以使用的状态表示。然后，这个状态被输入到代理的策略或神经网络中，并以语义框架的形式输出一个动作。还可以查询数据库(DB)以向代理动作添加信息，例如餐馆信息或电影票信息。然后，代理(在此图中也称为“系统”)动作由 NLG 组件处理，该组件将其转换为用户可读的自然语言。## MiuLab TC-Bot[](http://aclweb.org/anthology/I17-1074)Dialogue flow for TC-Bot本教程和附带的代码是基于 MiuLab 的一个对话系统，名为 [TC-Bot](https://github.com/MiuLab/TC-Bot) 。他们的[论文](https://arxiv.org/pdf/1703.01008.pdf)的主要贡献是，它展示了如何使用基本规则模拟用户，以便与用真人训练代理相比，代理可以用强化学习非常快速地训练。其他论文也做了同样的事情，但是这篇论文是一个很好的例子(有代码！)如何制定一个成功的培训体系。## 用户模拟器和误差模型控制器我们将在后面的系列文章中更详细地介绍用户 sim，但是现在要理解它是一个基于确定性规则的模拟器，试图模拟一个真实的用户。在这种情况下，它基于用户议程建模，这意味着它使用代表用户 sim 的约束和需求的内部状态。这种内部状态跟踪当前的对话，以及完成当前目标还需要做什么。目标是从可用用户目标列表中随机挑选的，其中目标由一组约束和其他信息组成，这些约束和信息在用户 sim 试图实现其当前目标时指导用户 sim 的动作。误差模型控制器(EMC)被用于在语义框架的级别上向用户 sim 的动作添加误差，这被显示为改善训练的结果。## 对于这个系列教程，您应该知道什么下面是您应该知道的一些事情，这些事情不会在本系列中涉及，但是对于理解代码非常重要:* 非常了解如何用 python 编码 * 知道如何使用 python 中的[字典，因为我们会经常用到它们！](https://realpython.com/python-dicts/) * 知道如何编写简单的代码 [DQN](https://jaromiru.com/2016/10/21/lets-make-a-dqn-full-dqn/) * 知道如何用 [Keras](https://github.com/keras-team/keras) 制作一个非常简单的神经网络模型我们将使用 Python ≥ 3.5、 [Keras](https://github.com/keras-team/keras) (任何最新版本)，当然还有 numpy。现在让我们继续讨论我们将要使用的数据！在这一部分，我们将讨论`[train.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/train.py)`。# 电影票数据[**数据库**](https://github.com/maxbren/GO-Bot-DRL/blob/master/data/movie_db.txt) :该数据库为不同属性的电影票或*时段*。以下是其中几项(排名不分先后):它被组织成一个字典，关键字是长整型(类似整数)票的索引，值也是包含票代表的电影信息的字典。如您所见，并非所有的票据都有相同的属性，显然也不总是相同的值！[**数据库字典**](https://github.com/maxbren/GO-Bot-DRL/blob/master/data/movie_dict.txt) :另一个文件包含一个字典，其中的键是可以在一个标签中的不同槽，值是每个槽的可能值的列表。以下是一些不同的项目(截断值列表):[**用户目标列表**](https://github.com/maxbren/GO-Bot-DRL/blob/master/data/movie_user_goals.txt) :最后，我们将用户目标作为包含每个目标的请求和通知槽的字典列表。稍后我们将更详细地讨论这意味着什么。示例:该数据库的目标是让代理商找到一张符合用户约束的票，该约束由该集的用户目标给出。这不是一件容易的事，因为每张票都是独一无二的，而且大多数都有不同的位置！## 动作剖析理解这个系统中动作的结构是非常重要的。如果我们暂时忽略自然语言，用户 sim 和代理都以*语义框架*的形式作为输入和输出动作。动作包含意图、通知和请求槽。本教程系列中的 Slot 指的是键、值对，通常指的是单个通知或请求。例如，在字典`{‘starttime’: ’tonight’, ‘theater’: ’regal 16’}`中，`‘starttime’: ’tonight’`和`‘theater’: ’regal 16’`都是插槽。示例操作:意图代表行动的类型，如下所列。剩下的动作被分成包含约束的通知槽和包含需要填写的信息的请求槽。可能的关键字列表在`[dialogue_config.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/dialogue_config.py)`中列出，它们的值在上面提到的数据库字典中。通知槽是发送者希望接收者知道的信息。它由键列表中的一个键和该键的值列表中的一个值组成。请求槽包含一个键，发送方希望从接收方找到该键的值。所以它是密钥列表中的一个密钥，而值`‘UNK’`意味着“未知”,因为发送者还不知道什么值适用于这个槽。## 所有意图* 通知:以通知槽的形式提供约束 * 请求:请求用值填充请求槽 * 感谢:仅供用户使用；它只是向代理表明它已经做了一些好事，或者用户已经准备好结束对话 * 找到匹配项:仅由代理使用；向用户表明它有一个它认为将满足用户目标的匹配 * 拒绝:仅供用户使用；仅用于响应具有匹配意图的代理操作，表明匹配不符合其约束条件 * 完成:代理使用此功能来结束对话，并查看是否已完成当前目标，当情节持续时间过长时，用户操作会自动执行此意图## 状态ST 创建一个状态作为代理选择适当动作的输入。这是来自当前对话历史的有用信息的 numpy 数组。我们将在第二部分对此进行更深入的讨论。现在簿记已经完成，让我们进入训练循环和一些代码！# 培训代理Our training loop这个图代表了训练中一个完整循环的流程。该系统的 4 个主要部分是代理`dqn_agent`、对话状态跟踪器`state_tracker`、用户(或用户模拟器)`user`和 EMC `emc`。让我们来看看一轮比赛的各个阶段:1. 获取当前状态，该状态相当于之前的下一个状态，或者如果这是情节的开始，则获取初始状态，并将其作为输入发送到代理的 get action 方法 2. 获取代理的操作，并将其发送到 ST update 方法以获取代理操作:ST 在该方法中更新自己的当前会话历史，并使用数据库查询信息更新代理操作 3. 更新的代理动作作为输入被发送到用户的步骤方法中:在步骤中，用户 sim 制作其自己的基于规则的响应，并且还输出奖励和成功信息(未示出) 4. 用户操作被 EMC 注入了错误 5. 带有错误的用户操作被作为输入发送到用户操作的 ST 更新方法中:类似于带有代理操作的 ST 更新方法，但是，它只是在其历史中保存信息，而不是以重要的方式更新用户操作 6. 最后，从 ST 的 get 状态输出下一个状态，这完成了添加到代理的存储器中的该轮的当前经验元组Code of diagram一个重要的注意事项是，与任何 DQN 代理一样，内存缓冲区在某种程度上是在“预热”阶段填充的。与 dqn 在游戏中的许多用途不同，代理在这个阶段不采取随机行动。相反，在预热期间，它使用一个非常简单的基于规则的算法，这将在第二部分解释。如你所见，我们没有使用任何自然语言(NL)组件，所以动作总是语义框架。在本系列中，我们将培训不需要 NL 的 DM。NLG 和 NLU 与代理分开进行预训练，不需要了解如何用 DRL 训练代理。不要烦恼！你仍然会学到很多，老实说，学习如何用 DRL 训练代理比知道如何用监督学习训练 NL 组件有趣得多。看一看本系列的第五部分，看看在哪里可以学习添加 NL 组件！## 情节重置在我们开始热身和训练循环之前，这里是每集之前调用的集重置功能。还要注意的是,*对话和一集是一回事，我可以互换使用。*简而言之，剧集重置会刷新对象并获取该剧集的初始用户操作。## 预热代理首先，我们定义外部循环只运行到代理的内存被填充到`WARMUP_MEM`或者它的内存缓冲区完全满了。接下来，我们必须重置每个循环的情节，并获得初始状态。内部循环运行`run_round(state, warmup=True)`直到`done == true`意味着这一集结束。## 培训代理忽略一些额外的变量，循环与预热非常相似。到目前为止，主要的区别是，当剧集数量达到`NUM_EP_TRAIN`时，该方法结束其外部循环。## 训练模块的工作原理在一定数量的剧集(`TRAIN_FREQ`)的每个*周期*之后，代理人被训练其对经历的记忆。1. 如果该周期的成功率大于或等于当前最佳成功率(在`train_run()`开始时初始化为 0.0)，并且高于某个`SUCCESS_RATE_THRESHOLD`，则清空代理的内存。这是为了消除基于先前版本的代理模型的动作的旧经验，即由次优模型采取的动作。然后，这允许来自模型的更好版本的更新的体验填充存储器。这样，训练和表现是稳定的。 2. 接下来，代理的行为模型权重被复制到目标模型中，这是今天使用的所有 dqn 所需要的，以稳定学习。 3. 最后，代理被训练，这意味着当前的记忆被用于提高模型的权重。## 培训总结请看一下`[train.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/train.py)`中的完整代码，了解全貌！1. 加载数据库数据 2. 创建对象 3. 呼叫`warmup_run()` 4. 打电话给`train_run()`这就是 DRL 训练的围棋聊天机器人的主要训练循环。理解图表很重要。[接下来](https://medium.com/@maxbrenner110/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-ii-dqn-agent-f84122cc995c)我们将了解代理、它可以采取的行动种类、预热政策和内部权重优化流程。**那里见！**# 用深度强化学习训练面向目标的聊天机器人——第二部分> 原文：<https://towardsdatascience.com/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-ii-dqn-agent-f84122cc995c?source=collection_archive---------6----------------------->## 第二部分:DQN 代理人如果你还不知道什么是面向目标的聊天机器人，我们正在使用的数据库和我们对话系统的训练循环，看看这个系列教程的[的前一部分](https://medium.com/@maxbrenner110/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-i-introduction-and-dce3af21d383)！在这一部分，我们将深入探讨代理人，在这种情况下，代理人由 DQN 代表。本教程和附带的代码是基于 MiuLab 的 TC-Bot。本教程的代码可以在[这里](https://github.com/maxbren/GO-Bot-DRL)找到。我们将从`[dqn_agent.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/dqn_agent.py)`开始这一部分的工作。我们正在遵循的总体图表:Dialogue flow of a single round# 代理的目的是什么？面向目标(GO)的聊天机器人代理的目的是接受训练，以便熟练地与真实用户交谈，从而完成一个目标，例如找到一个符合用户约束的预订或电影票。代理的主要工作是采取一种状态，并产生一个接近最优的行动。具体来说，代理从对话状态跟踪器(ST)接收表示当前对话历史的状态，并选择要采取的对话响应。## 深度 Q 网(DQN)dqn 的细节超出了本教程的范围，所以请查看这些资源以了解更多信息:[编码一，](https://jaromiru.com/2016/09/27/lets-make-a-dqn-theory/) [以不同的方式编码一](https://becominghuman.ai/lets-build-an-atari-ai-part-1-dqn-df57e8ff3b26)现在让我们来看一些代码！## 代理的对话配置以下是代理使用的`[dialogue_config.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/dialogue_config.py)`中的对话配置常量:`agent_inform_slots`是座席代表通知的所有可能的关键值。`agent_request_slots`是代理请求的所有可能的键值。还显示了可能的代理操作。## 神经网络模型我们使用 [Keras](https://github.com/keras-team/keras) 来建立代理的模型。该模型是一个单隐层神经网络。这很简单，但是对这个问题有很好的效果。该代码片段中的实例变量被分配给`[constants.json](https://github.com/maxbren/GO-Bot-DRL/blob/master/constants.json)`中“agent”下的常量# 政策在给定的状态下，代理用来选择动作的策略取决于对话是处于预热阶段还是训练阶段。在训练前运行热身，通常使用随机策略来填充代理的记忆。在这种情况下，代理在预热期间使用非常基本的基于规则的策略。在训练中，行为模型被用来选择一个动作。在这种情况下，`use_rule`表示预热。这个方法返回动作的索引和动作本身。## 基于规则的策略在预热期间，采用一个简单的基于规则的策略。首先注意代理的重置方法，该方法仅用于重置该基于规则的策略的几个变量:该策略简单地请求请求槽列表中的下一个槽，直到它没有更多的请求为止，然后它采取“找到匹配”动作，最后在最后一轮采取“完成”动作。我们将在第三部分和第四部分讨论 match found 和 done 含义。下面是一个使用这个简单策略的单集示例:这个策略对于以某种有意义的方式热启动代理很重要。这是一个简单的策略，但比采取随机行动能改善结果。## DQN 政策培训期间使用:# 训练方法正如在系列的第一部分中所描述的,`dqn_agent.train()`在训练中每隔几集就会被调用一次。Note: Some of this code is based off of an awesome tutorial by [Jaromír](https://github.com/jaromiru) which can be found [here](https://jaromiru.com/2016/09/27/lets-make-a-dqn-theory/).我不打算遍历这段代码的大部分，因为它是非常基本的，你们中的许多人应该已经看到了 DQN 代码，看起来很像现在这样。然而，我要指出的是，与许多其他 DQN 训练方法不同的是，这个代码并不是随机抽取一批样本。相反，它会计算当前内存中有多少批次，然后根据这些批次训练权重。这有点奇怪，但对 TC-Bot 的原始代码是准确的。摆弄一下这个，看看你能否用不同的批量取样技术得到更好的结果！[](http://languagelog.ldc.upenn.edu/nll/?p=34864)在**摘要**中，该代理根据一个状态选择一个动作，该状态的策略要么是预热期间的一个简单请求列表，要么是训练期间的单个隐藏层行为模型。这种训练方法很简单，与其他 DQN 训练方法只有几处不同。尝试模型的架构，添加[优先体验回放](https://arxiv.org/abs/1511.05952)并制定更高级的基于规则的策略！[下一部分](https://medium.com/@maxbrenner110/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-iii-dialogue-state-d29c2828ce2a)将涵盖 ST 和查询系统！在那里，您将了解 ST 如何更新其历史/对对话的理解，以及状态准备是什么样的。# 用深度强化学习训练面向目标的聊天机器人——第三部分> 原文：<https://towardsdatascience.com/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-iii-dialogue-state-d29c2828ce2a?source=collection_archive---------8----------------------->## 第三部分:对话状态跟踪器如果你还不知道我们在哪里了解这个领域的培训和 DQN 代理，请查看前面的部分！这个代理的目标是为用户选择合适的电影票。在这一部分中，将解释状态跟踪器以及状态跟踪器所使用的数据库的查询系统。这个系列教程是基于 [TC-Bot](https://github.com/MiuLab/TC-Bot) 的。这个系列的 github 代码可以在[这里](https://github.com/maxbren/GO-Bot-DRL)找到。我们将与`[state_tracker.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/state_tracker.py)`和`[db_query.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/db_query.py)`一起工作。这是我们根据前两部分得出的图表:Dialogue flow of a single round# 对话状态跟踪器在面向目标的对话系统中，对话状态跟踪器(st)的主要工作是为代理准备状态。正如我们在前一部分所讨论的，代理需要一个有用的状态，以便能够对采取什么行动做出好的选择。ST 通过收集用户和代理采取的动作来更新其对话的内部历史。它还跟踪当前剧集中迄今为止包含在任何代理和用户动作中的所有通知片段。代理使用的状态是由来自 ST 的当前历史和当前通知的信息组成的 numpy 数组。此外，每当代理希望通知用户一个槽时，ST 查询数据库以获得给定其当前通知时有效的值。本质上，ST 为代理准备了一个状态，给出了它的情节历史和到目前为止在情节中由用户和代理发出的所有通知时隙，并且为代理查询数据库。## 重要的操作类型在继续之前，让我们回顾一下第一部分中一些值得注意的动作意图:*通知*、*请求*和*匹配找到*。**通知** 表示动作包含发送方希望提供给接收方的通知槽。**请求**例如，如果发送者请求一个日期(“UNK”的值)，那么接收者要采取的适当行动(尽管它不是必须的)将是通知原始发送者“明天”或某个其他值。只有代理可以向用户发送**匹配发现**动作。这意味着，当 ST 接收到代理操作时，它会找到一个与当前通知一起工作的票据，并用票据中的所有槽填充该操作的通知槽，此外还有实际的票据 ID 本身。然而，如果代理决定采取匹配发现操作，但是实际上没有有效的票据，那么操作通知槽保持为空，除非有没有匹配的特殊指示。这种动作类型很重要，因为代理必须在剧集中的某个点采取匹配发现动作，即*包含与用户的约束条件相匹配的标签*以在剧集中成功，这将在下一部分中解释。*最后注意:代理只能包含一个插槽，而用户 sim 操作可以包含多个插槽。*唯一的*例外*是匹配发现操作，因为它可能包含票据的所有插槽。下面是匹配找到操作的示例。# 更新状态跟踪器的历史记录`update_state_agent(self, agent_action)`将代理动作作为输入，并更新 ST 的历史和当前通知。`update_state_user(self, user_action)`将用户动作作为输入，并更新这两个变量。该类的重置方法(在`[train.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/train.py)`中的重置函数中调用)重置当前通知、历史以及回合数，该回合数指示剧集的当前回合:## 使用用户操作更新1. 用操作中的任何通知槽更新当前通知 2. 将操作附加到历史记录 3. 增加回合数(当前回合结束)## 使用代理操作更新在某些情况下，把代理的动作想象成原始的或者未填充的版本，把状态跟踪器想象成用数据库信息填充任何通知槽。如果代理操作是通知，则将在数据库中查询与当前通知不冲突的匹配值。如果该动作是找到的匹配，那么将查询数据库以寻找符合当前通知的匹配票据。对于所有其他意图，没有必要进行询问。注意:在对话配置中，下面的`self.match_key`被设置为`'ticket'`。意向动作`‘inform’`和`‘match_found’`以特定的方式处理。**处理意向动作** `**‘inform’**`1. 通过使用当前通知作为约束查询数据库来填充动作的通知槽(最初值为`‘PLACEHOLDER’`) 2. 用填充的通知槽更新当前通知**处理意图动作** `**‘match_found’**`1. 从数据库中获取一个票据列表，其中每个票据的槽与当前通知的槽(键和值)相匹配，当前通知充当约束 2. 如果有匹配的票据，则将代理操作的通知槽设置为此列表中票据的槽；此外，创建并设置代理动作的通知槽中的值`self.match_key`为该票据的 ID 3. 否则设置`self.match_key = ‘no match available’` 4. 用上面找到的新值更新当前通知中`self.match_key`的值*成功查询找到匹配的示例*操作:`{'intent': 'match_found', 'inform_slots': {'ticket': 24L, 'moviename': 'zootopia', 'theater': 'carmike 16', 'city': 'washington'}, 'request_slots': {}}`一个*不成功查询匹配发现动作的例子* : `{'intent': 'match_found', 'inform_slots': {'ticket': ‘no match available’}, 'request_slots': {}}`最后，将轮数添加到代理操作，并将代理操作附加到历史记录。请记住，动作是字典，在 python 中是可变的，所以发送到该方法中的原始代理动作实际上是由查询信息和轮数值自行更新的。# 状态准备st 最重要的工作是为代理提供当前事件历史的有用状态或表示。`get_state(self, done)`取一个 done bool，表示本轮结束后该集是否结束，并输出一个 numpy 形状的数组`(state size,)`。知道州的大小并不重要，因为它只是基于我们在州中存储了多少信息。但是如果您想删除或添加更多信息，您可以很容易地更改它。状态由关于剧集状态的有用信息组成，例如最后用户动作和最后代理动作。这是为了通知代理最近的历史，这足以让代理采取接近最佳的行动。此外，`round_num`被编码以让代理知道该集的紧急程度(如果该集接近其允许的最大回合数，代理可以考虑采取匹配发现动作以在太晚之前查看它是否有匹配)。最后，状态由关于当前通知的信息以及数据库中有多少项匹配那些当前通知的信息组成。有很多研究和工作被投入到状态跟踪中，例如编码信息的最佳方式以及在状态中提供什么信息。这种状态准备方法可能远非最佳，但需要进行大量调整来优化这一过程。请看一下第五部分中关于状态跟踪的参考资料。# 查询系统正如我们在上面看到的，状态跟踪器需要查询票据信息的数据库，以填充通知并匹配找到的代理动作。状态准备方法也使用它来为代理收集有用的信息。这里实现的查询系统可以用于任何与这个电影票数据库结构相同的数据库。我不打算详细介绍`[db_query.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/db_query.py)`中方法的实际实现，因为理解这一点并不能真正提高对这个对话系统如何工作的理解。然而，如果有足够的需求来实现完整的运行，那么我会做一个关于这个类的新帖子。**公共方法总结:**## 获取数据库结果`get_db_results(constraints) -> dict`:在`update_state_agent(self, agent_action)`中调用，以响应具有意图`‘match_found’`的代理动作，如上所述。查看数据库中的每个项目，如果项目槽包含所有约束键，并且具有这些槽的匹配值，则将该项目添加到返回字典中。因此，它在数据库中查找给定约束的所有匹配项。例如，假设数据库如下所示:``` {0: {'theater': 'regal 6', 'date': 'tonight', 'city': 'seattle'},1: {'date': 'tomorrow', 'city': 'seattle'},2: {'theater': 'regal 6', 'city': 'washington'}} ```约束条件是:`{'theater': 'regal 6', 'city': 'seattle'}`输出将是`{0: {'theater': 'regal 6', 'date': 'tonight', 'city': 'seattle'}}`,因为这是唯一包含所有约束键并匹配其所有值的项目## 填充通知槽`fill_inform_slot(inform_slot_to_fill, current_inform_slots) -> dict`:在`update_state_agent(self, agent_action)`中调用，以响应带有意图`‘inform’`的动作，如上所述。首先，它调用`get_db_results(current_informs)`来获取所有的数据库匹配。然后计算`matches[inform_slot_to_fill]`的值，并返回出现的最高值。例如，假设这些是从`get_db_results(constraints)`返回的匹配:``` {2: {'theater': 'regal 6', 'date': 'tomorrow', 'moviename': 'zootopia'},45 : {'theater': 'amc 12', 'date': 'tomorrow'},67: {'theater': 'regal 6', 'date': 'yesterday'}} ```如果`inform_slot_to_fill`是`'theater'`，那么这个方法将返回`{'theater': 'regal 6'}`，同样，如果`inform_slot_to_fill`是`'date'`，那么输出将是`{'date': 'tomorrow'}`。选择我们关心的键的多数值。## 获取插槽的数据库结果`get_db_results_for_slots(current_informs) -> dict`:调入`get_state(self, done=false)`。遍历整个数据库，统计当前通知中每个槽`(key, value)`的所有出现次数，并返回所有键的`key: count` 字典；此外，`'matching_all_constraints': #` 是状态中另一个有用的信息，它存储了多少数据库项匹配所有当前的通知槽。例如，使用与上面相同的数据库:``` {0: {theater: regal 6, date: tonight, city: seattle},1: {date: tomorrow, city: seattle},2: {theater: regal 6, city: washington}} ```如果 current informs 为:`{'theater': 'regal 6', 'city': 'washington'}`，则输出将为`{'theater': 2, 'city': 1, 'matching_all_constraints': 1}`，因为两个数据库项具有`‘theater’: ‘regal 6’`，一个数据库项具有`‘city': 'washington’`，并且一个数据库项匹配所有约束(项 2)。在**结论**中，状态跟踪器使用每个代理和用户动作来更新其历史和当前通知，以便在代理需要采取动作时为其准备有用的状态。它还使用一个简单的查询系统来为通知和匹配找到的操作填充代理通知槽。在[下一部分](https://medium.com/@maxbrenner110/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-iv-user-simulator-and-a0efd3829364)中，我们将学习用强化学习训练代理的最重要的部分之一:用户模拟器。我们将学习我们的用户 sim 将使用的特定规则来做出类似人类的动作！# 用深度强化学习训练面向目标的聊天机器人——第四部分> 原文：<https://towardsdatascience.com/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-iv-user-simulator-and-a0efd3829364?source=collection_archive---------9----------------------->## 第四部分:用户模拟器和误差模型控制器[](http://www.themattrix.com/matrix-moving-high-resolution-wallpaper-xjgs-hd-matrix-wallpaper-moving-animated-android-iphone-windows-7-gif-5-4-download/)[http://www.themattrix.com/matrix-moving-high-resolution-wallpaper-xjgs-hd-matrix-wallpaper-moving-animated-android-iphone-windows-7-gif-5-4-download/](http://www.themattrix.com/matrix-moving-high-resolution-wallpaper-xjgs-hd-matrix-wallpaper-moving-animated-android-iphone-windows-7-gif-5-4-download/)查看本系列之前的部分，包括训练循环、DQN 代理和状态跟踪器，天啊！这一部分解释了非常重要的用户模拟器和错误模型控制器。这个系列教程是基于 [TC-Bot](https://github.com/MiuLab/TC-Bot) 的。这个系列的代码可以在[这里](https://github.com/maxbren/GO-Bot-DRL)找到。这部分重点介绍的两个文件是`[user_simulator.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/user_simulator.py)`和`[error_model_controller.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/error_model_controller.py)`。我们正在遵循的图表:Dialogue flow of a single round# 用户模拟器用户模拟器用于模拟真实的用户，这样可以比真实用户被迫坐下来接受几个小时的培训更快地培训代理。聊天机器人领域的用户模拟器研究是一个热门的研究课题。本教程中涉及的是一个相当简单的确定性的基于规则的模拟器，基于 TC-Bot 的[用户 sim，有一些小的改动。这个用户模拟器，像目前大多数一样，是一个基于议程的系统。这意味着用户对于该情节具有目标，并且它根据该目标采取行动，同时跟踪内部状态，这允许它跟随对话以采取明智的行动。每一轮动作都是响应于主体动作而精心设计的，主要使用确定性规则和一些随机规则来创建不同的响应。](https://arxiv.org/pdf/1612.05688.pdf)## 什么是用户目标？用户目标是从真实对话或手工制作(或两者兼有)的语料库中抽取的。每个目标都由通知时段和请求时段组成，就像一个动作，但没有意图。从语料库中获取目标有几种标准方法。第一:在一集里，用户最初动作的所有时段(请求和通知)都有一个目标。第二:一集里所有用户动作的所有时段被组合起来，形成一个单一的目标。除了这种自动收集之外，一些手工制作的规则用于降低用户目标的多样性，以便它们对于代理来说更容易实现。幸运的是，TC-Bot 附带了我们将使用的用户目标的[文件，因此我们不需要自己从语料库中生成它们。](https://github.com/maxbren/GO-Bot-DRL/blob/master/data/movie_user_goals.txt)用户目标的通知时段模拟用户在寻找适合他们的票据时的约束。请求槽模拟用户获取关于什么票可用的信息。该系统与真实用户之间的主要区别在于，当用户更多地了解有哪些票可用时，他们可能会改变主意。这在这里不会发生，因为在一集里目标不会改变。*想想你可以用什么方法来增强这个系统，让它更像一个真正的用户！*最后注意，默认槽(在本例中为“ticket ”)被添加到每个目标的请求槽中。代理必须成功地通知一个值来填充默认时段，以实现目标并在一集中成功。来自第一部分的几个用户目标的例子:## 用户模拟器内部状态用户 sim 的内部状态(不同于来自状态跟踪器的状态)跟踪目标位置和当前对话的历史。它用于设计每一步的用户操作。具体来说，状态是 4 个槽字典和一个意图的列表:* Rest 槽:代理或用户尚未通知的来自目标的所有通知和请求槽 * 历史插槽:迄今为止用户和代理操作的所有通知插槽 * 请求槽:用户希望在不久的将来的操作中请求的请求槽 * 通知插槽:通知插槽，代理打算在当前正在制定的操作中通知插槽 * 意图:当前操作的意图## 用户模拟器动作用户可以采取的操作比可能的代理操作更加多样，有时甚至更加复杂。一个用户操作可以有多个请求槽或多个通知槽。在某些情况下，例如初始操作，它实际上还可以包含请求和通知槽。现在进入代码！## 对话配置以下是`[dialogue_config.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/dialogue_config.py)`中用户 sim 的对话配置常量:## 重置用户 sim 重置很重要，因为它选择新的用户目标，重置状态并返回初始动作。解剖学:1. 选择一个随机目标 2. 将默认位置(“入场券”)添加到目标中 3. 清除状态的所有方面 4. 将所有目标通知和请求槽添加到`‘rest_slots’`；在整个谈话过程中，他们都需要被告知 5. 将约束检查初始化为失败(在下面的成功约束中讨论) 6. 返回剧集的初始动作## 初始用户操作1. 初始操作必须始终是一个请求 2. 它还必须始终包含在`dialogue_config.py`中定义的`usersim_required_init_inform_keys`中列出的所有通知槽。在我们的例子中，这仅仅意味着槽`‘moviename’`，它也是每个用户目标中必需的通知槽，即它总是在初始动作中被通知 3. 必须包含来自目标的随机请求槽，而不是默认槽，除非这是唯一的一个## 分步方法用户响应 step 方法中的代理操作，该方法将代理操作作为输入。Step 接受这个动作和用户 sim 的内部状态，并返回一个精心制作的响应(动作)、标量奖励、完成布尔值和成功布尔值。这类似于 [openai gym environments](https://gym.openai.com/docs/) 中的 step 函数，目的相同！具体来说:1. 清除状态通知槽和意图，因为它们不需要逐轮结转，不像历史、休息和请求那样结转 2. 如果回合等于最大回合，则回复意图`‘done’`并设置`success = FAIL` 3. 否则，基于代理动作意图来设计动作。3.a)如果意图是`‘done’`，那么也计算该集是否算作代理的成功，并回复`‘done’` 4. 回应国家的意图，请求和通知槽 5. 计算该步骤的标量奖励 6. 返回响应、奖励、完成布尔值和指示成功的布尔值顺便说一句，意图`‘done’`的这两种使用是用户 sim 动作将其作为意图的唯一时间，即`‘done’`象征着对话的结束注意:`success` 可以是`NO_OUTCOME`如果该集没有完成，可以是`FAIL`如果该集已经完成并且失败，或者`SUCCESS`如果该集已经完成并且成功`[utils.py:](https://github.com/maxbren/GO-Bot-DRL/blob/master/utils.py)`中的奖励功能这个奖励函数通过给代理一个巨大的成功奖励来帮助它学习成功。让它学会避免失败，方法是给它一个大的失败惩罚，但没有成功的奖励那么大。我相信这有助于代理人不要太害怕为成功的巨大奖励而冒险，否则它可能会过早地结束一集以减少负面奖励。最终，像这样的奖励形成往往是一种平衡行为。试试这个奖励函数，看看是否能得到更好的结果。# 回应的类型一些回应的规则很复杂或者看起来很随意。但是*请记住，许多设计响应的规则都很复杂，因此用户 sim 卡可以更像人类，这将有助于代理与真实用户打交道。然而，这些绝不是最好的规则。*响应的重要*要求*:1. 对于用户动作:如果意图是`‘inform’`，那么必须有通知槽，但是*没有*请求槽，以便不与下面的要求#2 冲突 2. 对于用户动作:如果意图是`‘request’`，它可以让*同时拥有*通知和请求槽，但必须至少拥有请求槽:这是一个复杂的动作，目的是向请求添加信息，使其更像人类 3. 每当代理操作或用户操作包含通知槽时，该通知槽必须从 rest 槽中移除(如果在 rest 槽中键入),并在历史槽中添加/更新 4. 每当代理动作包含通知槽时，必须将其从状态请求槽中移除(如果键入状态请求槽)，并遵循上述要求 3## 对请求的答复用于响应请求的 4 种主要情况:案例 1)如果代理请求目标通知槽中的某个内容，但它没有被通知，则从目标本身通知它情况 2)如果代理请求目标请求槽中的某些东西，并且它已经被通知，那么从历史中通知它情况 3)如果代理请求目标请求槽中的某样东西，但它没有得到通知，那么也用随机通知请求相同的槽情况 4)否则用户 sim 不关心被请求的时隙；告知特殊值`‘anything’`为请求槽的值## 回复:通知两种主要的应对情况:情况 1)如果代理告知目标告知中的内容，而其告知的值不匹配，则告知正确的值情况 2)否则选择一些时隙来请求或通知2.a)如果国家有任何要求，则提出要求2.b)如果在休息时段有什么要说的，请选择一些内容2.c)否则用`‘thanks’`回应，真正的意思是“无话可说”；事实上，这向代理表明它的 rest 槽是空的，这是下面讨论的成功的必要条件## 成功限制在继续讨论“匹配发现响应”和“完成响应”之前，了解一集的成功限制很重要。请记住，目标通知槽代表找到的匹配必须包含的约束。以下是代理要取得成功必须做的事情:1. 带着`‘match_found’`的意图采取行动，检查比赛是否满足所有目标约束 2. 在`‘match_found’`之后采取意图为`‘done’`的动作，检查剩余槽是否为空这些成功约束需要匹配的票据，因为这是任务的目标，并且空的 rest 槽显示代理已经通知了所有目标请求槽。这有助于代理学会让用户在提交匹配之前提出问题(请求)。## 回复:找到匹配项1. 动作中的默认槽必须有一个实际的匹配 ID 作为值，而不是`‘no match available’`,这意味着它实际上找不到与当前状态跟踪器通知的匹配 2. 目标中的所有通知时段必须位于此操作的通知时段中，因为这些时段是票证本身的属性 3. 该操作的所有通知时段值必须与目标通知时段值相匹配 4. 如果所有这些都成功，那么`self.constraint_check`被设置为`SUCCESS`，否则设置为`FAIL`如果匹配成功，则回复 intent `‘thanks’`和任何仍处于请求状态的请求槽。否则回复意图`‘reject’`并且没有通知或请求槽。`‘thanks’`向代理表明该票据有效。`‘reject’`表示该票不起作用。## 回复:完成约束 1) `self.constraint_check`必须设置为`SUCCESS`，表示找到一个有效的匹配约束 2)剩余槽必须为空注意:如 step 方法所示，回复的意图是`‘done’`，没有槽# 误差模型控制器在从步骤接收到用户动作之后，它被发送到错误模型控制器(EMC)以注入错误。在 TC-Bot 中，发现这样做实际上有助于代理处理现实生活中的自然语言组件错误或用户在回复中出错。EMC 可以将错误添加到通知槽和用户动作的意图中。各通知槽中*动作的槽级错误类型:** 用该键的随机值替换该值 * 替换整个槽:随机键和该键的随机值 * 删除该插槽 * 对于一个插槽，上述所有 3 种错误的概率相等意图级别错误:* 用随机意图替换意图在**总结**中，我们在这里创建的用户模拟器使用简单的规则来创建类似人类的响应，目的是训练代理与现实生活中的用户打交道。错误模型控制器的目的是将错误添加到用户 sim 动作的意图和/或通知槽中，这提高了真实测试中代理的质量。在[的最后一部分](https://medium.com/@maxbrenner110/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-v-running-the-agent-and-63d8cd27d1d)中，我们将介绍如何实际运行我们创建的代码(来自[回购](https://github.com/maxbren/GO-Bot-DRL))以及今后的发展方向。T4:有很多需要改进的地方，还有很多研究要做！**最后部分再见！**# 用深度强化学习训练面向目标的聊天机器人——第五部分> 原文：<https://towardsdatascience.com/training-a-goal-oriented-chatbot-with-deep-reinforcement-learning-part-v-running-the-agent-and-63d8cd27d1d?source=collection_archive---------15----------------------->## 第五部分:代理运行及未来研究[](https://www.nasa.gov/mission_pages/shuttle/shuttlemissions/sts127/launch/index.html)[https://www.nasa.gov/mission_pages/shuttle/shuttlemissions/sts127/launch/index.html](https://www.nasa.gov/mission_pages/shuttle/shuttlemissions/sts127/launch/index.html)在前面的部分中，我们介绍了面向目标的代理的所有部分和代码！这是第五部分，也是最后一部分，我们将介绍如何运行代码以及未来的研究和改进！这个系列教程是基于 [TC-Bot](https://github.com/MiuLab/TC-Bot) 的。这个系列的代码可以在[这里](https://github.com/maxbren/GO-Bot-DRL)找到。在这一部分，我们将快速回顾一下`[user.py](https://github.com/maxbren/GO-Bot-DRL/blob/master/user.py)`和`[test.py.](https://github.com/maxbren/GO-Bot-DRL/blob/master/test.py)`# 运行代码您既可以培训代理，也可以测试经过培训的代理。此外，代替使用用户模拟器，你可以作为一个真正的用户自己输入动作。## 培训代理运行`train.py`，用给定的`constants.json`文件从头开始训练。改变常数值，看看是否能找到更好的超参数。## 保存和加载模型权重通过将`constants.json`中的`"save_weights_file_path”`设置为您想要保存行为和目标模型权重的相对文件路径，您可以将训练模型的权重保存在一个目录中。要加载保存的重量，将`"load_weights_file_path”`设置到相同的路径。例如，要加载回购中的权重，将其设置为`"weights/model.h5"`。权重文件必须是. h5 文件，这是 Keras 使用的文件类型。您可以加载已经训练好的重量，并对其进行更多训练！## 测试代理通过运行`test.py`并将`"load_weights_file_path”`设置为正确的文件路径，可以使用经过训练的权重对代理进行测试。## 用真实用户测试(或培训)代理您可以通过将`constants.json`中`“run”`下的`"usersim”`设置为`false`，以用户身份输入您自己的动作(而不是使用用户 sim)来测试代理。你在控制台中输入一个动作和一个成功指示器。动作输入的格式是:意图/通知槽/请求槽。动作输入示例:* 请求/电影名称:房间，日期:星期五/开始时间，城市，剧院 * 通知/电影名称:疯狂动物城/ * 请求//开始时间 * 完成//此外，控制台将询问代理是否成功的指示器(除了在一集的初始动作输入之后)。允许的输入是-1 表示失败，0 表示没有结果，1 表示成功。与训练有素的代理人一起玩得开心，并定性测试您的改进！## 结果我的数据是使用`[constants.json](https://github.com/maxbren/GO-Bot-DRL/blob/master/constants.json)`中设置的超参数收集的，并且是 10 次训练运行的平均值。常数:按*一段时间的最大成功率*/到该集为止的训练频率(每 100 集)列出的集数(每 40000 集中的 2000 集)表:# 未来的研究和实验我们刚刚编写的代码是一个非常简单的面向目标的聊天机器人系统的例子。用户 sim 不是太先进，不像 TC-Bot 在这个系统中没有自然语言组件。代理还有很大的改进空间，包括允许更复杂的操作。然而，这是进一步研究和试验这个主题的一个非常好的起点。这里有一些重要的地方需要改进或添加到现有的代码中，或者只是为了研究:## 自然语言[](https://www.csie.ntu.edu.tw/~yvchen/doc/SLT16_SyntaxSemantics.pdf)Diagram from an NTU and Microsoft paper在 TC-Bot 中添加自然语言组件，这样您就可以在更真实的对话环境中测试它。请记住，自然语言组件不是用这种深度强化学习循环来训练的，它们是用 LSTMs 使用不同的通常受监督的学习方法单独进行预训练的。这里有几个关于这个话题的资源:[媒体文章](https://medium.com/analytics-vidhya/building-a-simple-chatbot-in-python-using-nltk-7c8c8215ac6e)、 [NTU 论文](https://www.csie.ntu.edu.tw/~yvchen/doc/IS16_MultiJoint.pdf)、 [NTU 和微软](https://www.csie.ntu.edu.tw/~yvchen/doc/SLT16_SyntaxSemantics.pdf)当然还有 [TC-Bot](https://github.com/MiuLab/TC-Bot) 及其[论文](http://aclweb.org/anthology/I17-1074)。## 其他数据集和语料库我们只看到了这个系统如何与一个简单的电影票数据库一起工作。在与此数据库结构相同的另一个数据库上尝试它。请确保相应地更改对话配置，但记住这是一个简单的系统，它只能以找到单个项目来实现用户目标为目标。看看你是否能改变它来找到一个目标需要的多个项目！这里有一些谷歌数据集和一个来自 T2 斯坦福大学的数据集。但是外面还有很多。## 对话状态跟踪状态跟踪的发展可能是聊天机器人中最突出的话题。对于系统的状态跟踪器来说,*准备一个有用的状态让代理采取接近最优的行动是非常重要的。如果重要的信息丢失了，比如用户的行为是什么，那么代理就很难很好的回复。此外，这些信息的编码方式以及是否有无用信息也会影响所采取行动的优化。这里有一些关于 ST: [剑桥论文](https://arxiv.org/pdf/1506.07190.pdf)、[雅虎](https://www.sigdial.org/files/workshops/conference17/proceedings/pdf/SIGDIAL02.pdf)和[对话状态跟踪挑战](https://pdfs.semanticscholar.org/4ba3/39bd571585fadb1fb1d14ef902b6784f574f.pdf)的资源。*## 高级 DRL 算法虽然我找不到任何讨论这一点的论文或其他资源，但我尝试了更高级/不同的 DRL 算法，如 A3C、PPO、TRPO、ACKTR、基于模型的方法、基于混合模型的方法等。将是一个伟大的领域进行实验的围棋机器人！请记住，因为这段代码中的训练方法集中在使用内存和在特定时间刷新内存，所以新的训练方法必须伴随不使用内存池的算法(这是大多数算法)。## 高级用户模拟器目前有很多关于创建更像人类的用户模拟器的研究，因为这对于获得高质量的培训很重要。这里构建的用户 sim 是可靠的，但仍然可以大大改进。这篇[论文](http://alborz-geramifard.com/workshops/nips17-Conversational-AI/Papers/17nipsw-cai-collaboration-based-simulator.pdf)用于构建真实的用户模拟人生。## 复杂域[](https://www.microsoft.com/en-us/research/uploads/prod/2017/04/emnlp2017_arxiv.pdf)Hierarchical successor to TC-Bot这里涉及的电影票领域是 GO 聊天机器人的一个实际用例，但仍然非常简单。在大多数情况下，问题的复杂性在现实世界中是上升的，在这里也是如此。面向目标的问题往往是复合的和分层次的，这意味着问题实际上是一堆必须完成的子问题。这篇[论文](https://www.microsoft.com/en-us/research/uploads/prod/2017/04/emnlp2017_arxiv.pdf)解释了如何增强现有的 TC-Bot 框架，以允许完成更复杂的层次目标。这又可以添加到这里创建的代码中。## 更多资源* [高级实战训练](http://aclweb.org/anthology/N18-3006) * [用围棋机器人转移学习](https://arxiv.org/pdf/1802.00500.pdf) * [深度学习中的一切围棋机器人概述](https://arxiv.org/pdf/1809.08267.pdf) * [深度学习中的一切 GO 机器人的另一个概述](https://www.poly-ai.com/docs/naacl18.pdf) * [在聊天机器人上拥有大量资源的大型媒体帖子](https://medium.com/gobeyond-ai/a-reading-list-and-mini-survey-of-conversational-ai-32fceea97180)*用您目前所学的知识和编码进行实验！随着机器和深度学习的新功能，这个领域正在快速发展！***感谢您的关注，希望您能从这个系列和代码中获益良多！如有任何问题，欢迎随时评论！**# 训练朴素贝叶斯模型以识别电子邮件或文档的作者> 原文：<https://towardsdatascience.com/training-a-naive-bayes-model-to-identify-the-author-of-an-email-or-document-17dc85fa630a?source=collection_archive---------4----------------------->“brown track and field” by [Adi Goldstein](https://unsplash.com/@adigold1?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)在这个例子中，我们使用由两个不同的人写的一组电子邮件或文档。目的是训练一个朴素贝叶斯模型，使其能够根据文档/电子邮件中使用的单词来预测是谁写的文档/电子邮件包含本例中使用的文件的 Github 存储库可以在[这里](https://github.com/duranivan/naivebayes-email-author)找到。文件`nb_email_author.py`包含加载数据、训练模型以及查找训练和测试集预测得分的脚本。在这里，我们解释脚本的主要部分和结果。# **加载数据**脚本的第一部分加载数据。这里唯一的特殊性是‘pickle’用于反序列化原始数据文件(关于 pickle 和序列化/反序列化的更多信息，请看这个[链接](https://docs.python.org/3/library/pickle.html))。加载两个文件，一个包含电子邮件或文档，另一个只包含电子邮件的作者。一旦我们反序列化并加载文件，我们就有两个数组(列表)，一个名为`words`，一个名为`authors`，大小都是 17，578。`words`中的每个元素都是包含电子邮件或文档的单个字符串。“authors”中的每个元素不是 0 就是 1。像往常一样，我们使用 Scikit-learn 方法`sklearn.model_selection.train_test_split`将数据分成训练集和测试集。``` *from* sklearn.model_selection *import* train_test_splitfeatures_train, features_test, labels_train, labels_test = train_test_split(words, authors, *test_size*=0.1, *random_state*=10) ```# **文本矢量化**在机器学习中处理文本时，将文本转换成易于分析和量化的数据是很常见的。对于这一点，最常用的技术是 **tf-idf** 简称“词频-逆文档频”，基本反映了一个词在集合或语料库(我们的一组邮件或文档)中对一个文档(邮件)有多重要。**tf-idf** 是一个统计量，随着一个单词在文档中出现的次数而增加，由语料库中包含该单词的文档数量来惩罚( [Wikipedia](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) )。幸运的是，Scikit-learn 有一个方法可以做到这一点(`sklearn.feature_extraction.text.TfidfVectorizer`)。见文档[此处](http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfVectorizer.html)。因此，我们以如下方式将此方法应用于我们的数据:``` *from* sklearn.feature_extraction.text *import* TfidfVectorizervectorizer = TfidfVectorizer(*sublinear_tf*=True, *max_df*=0.5, *stop_words*='english')features_train = vectorizer.fit_transform(features_train) features_test = vectorizer.transform(features_test) ````TfidfVectorizer`设置矢量器。这里我们将`sublinear_tf`改为 true，用 **1 + log(tf)** 代替 **tf** 。这解决了“一个术语在一个文档中出现二十次”不代表“一次出现的重要性的二十倍”([链接](https://nlp.stanford.edu/IR-book/html/htmledition/sublinear-tf-scaling-1.html))的问题。因此降低了高频词的重要性(注意 **1+log(1) = 1** ，而 **1+log(20) = 2.3** )。此外，`stop_words`被设置为“英语”，因此在这种情况下，诸如“和”、“the”、“him”之类的停用词将被忽略，而`max_df=0.5`意味着我们将忽略文档频率高于 0.5 的术语(即，出现该术语的文档的比例)。接下来，我们对训练集和测试集的特征(在我们的例子中是术语或单词)进行拟合和转换。注意，对于训练集，我们使用`fit_transform`，对于测试集，我们只使用`transform`。这是有意义的，因为我们希望模型通过训练集学习词汇和文档频率，然后将训练特征转换为术语-文档矩阵。对于测试集，我们只想使用学习到的文档频率(idf)和词汇将其转换为术语-文档矩阵。**让我们用一个简化的例子来看看这个是什么样子的:**假设我们有以下训练语料库，同样，每个条目代表一个文档/电子邮件:``` corpus = ["This is my first email.","I'm trying to learn machine learning.","This is the second email","Learning is fun" ] ```现在，让我们来适应和改造它:``` vectorizer = TfidfVectorizer()X = vectorizer.fit_transform(corpus) print(X.__str__)*# <4x13 sparse matrix of type ‘<class ‘numpy.float64’>’ with 18 stored elements in Compressed Sparse Row format>* ````fit_transform`返回一个稀疏矩阵:``` print(X)*# (0, 10) 0.41263976171812644 # (0, 3) 0.3340674500232949 # (0, 7) 0.5233812152405496 # (0, 1) 0.5233812152405496 # (0, 0) 0.41263976171812644 # (1, 12) 0.4651619335222394 # (1, 11) 0.4651619335222394 # (1, 4) 0.4651619335222394 # (1, 6) 0.4651619335222394 # (1, 5) 0.3667390112974172 # (2, 10) 0.41263976171812644 # (2, 3) 0.3340674500232949 # (2, 0) 0.41263976171812644 # (2, 9) 0.5233812152405496 # (2, 8) 0.5233812152405496 # (3, 3) 0.4480997313625986 # (3, 5) 0.5534923152870045 # (3, 2) 0.7020348194149619* ```如果我们将`X`转换成一个 2D 数组，它看起来像这样(总共有 13 列，每一列代表一个单词/术语，为了简洁起见，奇数列被省略):``` vocabulary = vectorizer.get_feature_names()pd.DataFrame(*data*=X.toarray(), *columns*=vocabulary).iloc[:,0::2] ```TFIDF Matrix (Training Set)``` print(vocabulary)*# [‘email’, ‘first’, ‘fun’, ‘is’, ‘learn’, ‘learning’, ‘machine’, ‘my’, ‘second’, ‘the’, ‘this’, ‘to’, ‘trying’]* ```现在让我们假设我们有下面的“测试”文档:``` test = [“I’m also trying to learn python”] ```让我们转换一下，看看它:``` X_test = vectorizer.transform(test)pd.DataFrame(*data*=X_test.toarray(), *columns*=vocabulary).iloc[:, 0::2] ```TFIDF Matrix (Test Set)就这样，这就是文本或文档如何被矢量化以供进一步分析的过程。# **选择一组较小的特征**虽然选择一个较小的特征集并不是绝对必要的，但用太多的单词或特征来训练模型可能在计算上具有挑战性。在本例中，我们使用 Scikit-learn 的`SelectPercentile`来选择得分最高的特性([文档](http://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectPercentile.html)):``` *from* sklearn.feature_selection *import* SelectPercentile, f_classifselector = SelectPercentile(f_classif, *percentile*=10) selector.fit(features_train, labels_train)features_train = selector.transform(features_train).toarray() features_test = selector.transform(features_test).toarray() ```选择器使用`f_classif`作为得分函数，计算样本的方差分析 F 值。基本上，我们选择具有最大 F 值的术语(即，在不同类别或作者中，频率均值最有可能不同的术语或单词)。这是常见的，以便选择跨类的最佳区别特征(在最初的 38，209 个单词中，我们最终得到 3，821 个)。# **训练一个朴素贝叶斯模型**对于这个例子，我们使用高斯朴素贝叶斯(NB)实现(Scikit-learn 文档[这里](http://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html#sklearn.naive_bayes.GaussianNB))。在以后的文章中，我们将详细讨论朴素贝叶斯背后的理论。目前，值得一提的是，NB 是基于应用贝叶斯规则来计算一组单词(文档/电子邮件)由某人或某个类编写的概率或可能性(例如 **P("Chris"| "learn "、" machine "、" trying "，……)**)。然而，没有所谓的朴素贝叶斯法则。“天真”一词的出现是由于假设特征彼此独立(条件独立)，这意味着，对于我们的电子邮件分析，我们假设单词在句子中的位置是完全随机的(即，“am”或“robot”同样可能跟在单词“I”后面，这当然不是真的)。## **NB 带 Scikit-learn**一般来说，用 Scikit-learn 训练机器学习模型很简单，通常遵循相同的模式:* 初始化类模型的实例， * 拟合训练数据， * 预测测试数据(我们在这里省略了这一点)， * 计算训练集和测试集分数。``` *from* sklearn.naive_bayes *import* GaussianNB *from* time *import* timet0 = time() model = GaussianNB() model.fit(features_train, labels_train)print(f”\nTraining time: {round(time()-t0, 3)}s”)t0 = time() score_train = model.score(features_train, labels_train) print(f”Prediction time (train): {round(time()-t0, 3)}s”)t0 = time() score_test = model.score(features_test, labels_test) print(f”Prediction time (test): {round(time()-t0, 3)}s”)print(“\nTrain set score:”, score_train) print(“Test set score:”, score_test) ```结果如下:``` >>> Training time: 1.601s >>> Prediction time (train): 1.787s >>> Prediction time (test): 0.151s >>> Train set score: 0.9785082174462706 >>> Test set score: 0.9783845278725825 ```还不错！# 用 Python 中的 OpenCV 训练神经网络检测手势> 原文：<https://towardsdatascience.com/training-a-neural-network-to-detect-gestures-with-opencv-in-python-e09b0a12bdf1?source=collection_archive---------4----------------------->## 我如何用一个网络摄像头和一个梦想构建了类似微软 Kinect 的功能。Gesture → Prediction → Action*您可以在这里* *找到 Github 项目资源库中的* [*代码，或者在这里*](https://github.com/athena15/project_kojak) *查看* [*最终演示幻灯片。*](https://docs.google.com/presentation/d/1UY3uWE5sUjKRfV7u9DXqY0Cwk6sDNSalZoI2hbSD1o8/edit?usp=sharing)## 灵感想象一下，你正在为心爱的人举办生日聚会。每个人都玩得很开心，音乐在播放，派对很吵。突然，该吃生日蛋糕了！使用 Alexa 太大声了，而不是寻找你的手机或遥控器，如果你在谈话中简单地举起一只手，你的智能家居设备会识别这个手势，并关闭音乐，会怎么样？用同样的手势，你可以调暗灯光——正好可以看到生日蜡烛照亮生日男孩或女孩的脸。那不是很神奇吗？## 背景我对手势检测很好奇很久了。我记得当第一台微软 Kinect 问世时——我玩游戏、用手一挥就能控制屏幕，玩得非常开心。随着时间的推移，谷歌 Home 和亚马逊 Alexa 等设备的发布，手势检测似乎不再受到关注，而是转向了语音。尽管如此，我还是想知道，既然像脸书门户网站和亚马逊 Echo Show 这样的视频设备正在出现，它是否有可能经历一次复兴。考虑到这一点，我想看看是否有可能建立一个神经网络，它可以实时识别我的手势，并操作我的智能家居设备！## 数据，和我早期的模型我对这个想法很兴奋，并很快付诸实施，就像我从大炮中被射出来一样。我开始在[Kaggle.com](https://www.kaggle.com/benenharrington/hand-gesture-recognition-database-with-cnn)上使用手势识别数据库，并探索这些数据。它由 20，000 个带标签的手势组成，如下图所示。Odd images, but labeled and plentiful.当我读入图像时，我遇到的第一个问题是我的图像是黑白的。这意味着 NumPy 阵列只有一个通道，而不是三个通道(即，每个阵列的形状是(224，224，1))。因此，我无法将这些图像用于 VGG-16 预训练模型，因为该模型需要 RGB 3 通道图像。这是通过在图像列表上使用 np.stack，X_data:一旦我克服了这个障碍，我就开始建立一个模型，使用一个训练测试分割，这个分割完全展示了 10 个人中的 2 个人的照片。在重新运行基于 VGG-16 架构构建的模型后，我的模型总体上获得了 0.74 的 F1 分数。这已经很不错了，平均来说，随机猜测 10 个类别的准确率只有 10%。然而，训练模型从同质数据集中识别图像是一回事。训练它实时识别以前从未见过的图像是另一个问题。我试着调整照片的光线，使用深色背景——模仿模特训练过的照片。我还尝试了图像增强——翻转、倾斜、旋转等等。虽然这些图像比以前做得更好，但我仍然有不可预测的——在我看来是不可接受的——结果。我有一种挥之不去的感觉，我需要重新思考这个问题，并想出一个创造性的方法来使这个项目工作。***要点:在尽可能接近它在现实世界中可能看到的图像上训练你的模型。***## 重新思考这个问题我决定转向尝试新的东西。在我看来，训练数据的奇怪外观和我的模型在现实生活中可能看到的图像之间存在明显的脱节。我决定尝试建立自己的数据集。我一直在使用 OpenCV，一个开源的计算机视觉库，我需要一个工程师的解决方案，从屏幕上抓取图像，然后调整图像的大小，并将其转换为我的模型可以理解的 NumPy 数组。我用来转换数据的方法如下:简而言之，一旦你启动并运行相机，你就可以抓取帧，变换它，并从你的模型中得到一个预测:让网络摄像头和我的模型之间的管道连接是一个巨大的成功。我开始思考什么是适合我的模型的理想图像。一个明显的障碍是很难将感兴趣的区域(在我们的例子中是一只手)从背景中分离出来。## 提取手势我采用的方法是任何玩过 Photoshop 的人都熟悉的——背景减除法。这是一件美好的事情！从本质上说，如果你在你的手放进去之前拍摄一张场景的照片，你可以创建一个“遮罩”，它将删除新图像中除了你的手以外的所有东西。Background masking and binary image thresholding.一旦我从我的图像中减去背景，我就使用二进制阈值来使目标手势完全为白色，而背景完全为黑色。我选择这种方法有两个原因:它使手的轮廓清晰明了，并且它使模型更容易在不同肤色的用户中推广。这就产生了我最终用来训练我的模型的“剪影”般的照片。## 构建新数据集既然我可以在图像中准确地检测到我的手，我决定尝试一些新的东西。我的旧模型没有很好地概括，我的最终目标是建立一个可以实时识别我的手势的模型——所以我决定建立自己的数据集！我选择关注 5 个手势:我有策略地选择了 4 个手势，它们也包含在 Kaggle 的数据集中，这样我可以在以后对照这些图像交叉验证我的模型。我还添加了和平手势，尽管这个手势在 Kaggle 数据集中没有类似的。在这里，我通过设置我的网络摄像头来构建数据集，并在 OpenCV 中创建一个 click binding 来捕获和保存具有唯一文件名的图像。我试图改变框架中手势的位置和大小，这样我的模型会更健壮。很快，我就建立了一个包含 550 张剪影图片的数据集。是的，你没看错——我拍摄了 2700 多张照片。## 培训新模型然后我用 Keras & TensorFlow 构建了一个卷积神经网络。我从优秀的 VGG-16 预训练模型开始，并添加了 4 个密集层以及顶部的辍学层。然后，我采取了不同寻常的步骤，选择在我之前尝试过的原始 Kaggle 数据集上交叉验证我的模型。这一点很关键——如果我的新模型不能推广到以前没有训练过的其他人的手的图像，那么它并不比我的原始模型好。为了做到这一点，我对每个 Kaggle 图像应用了与应用于我的训练数据相同的变换——背景减除和二进制阈值处理。这给了他们一个我的模型所熟悉的相似的“外观”。L, Okay, and Palm gestures from Kaggle data set after transformation.## 结果模特的表现超出了我的预期。它对测试集中的几乎每个手势都进行了正确的分类，最终得到了 98%的 F1 分数，以及 98%的精确度和准确度分数。这是个好消息！然而，任何经验丰富的研究人员都知道，一个在实验室表现良好但在现实生活中表现不佳的模型价值不大。在我最初的模型上经历了同样的失败后，我谨慎乐观地认为这个模型将在实时手势上表现良好。## 智能家居集成在测试我的模型之前，我想添加另一个扭曲。我一直是一个智能家居爱好者，我的愿景一直是只用我的手势来控制我的 Sonos 和飞利浦 Hue 灯。为了方便地访问飞利浦 Hue 和 Sonos APIs，我分别使用了 [phue](https://github.com/studioimaginaire/phue) 和 [SoCo](https://github.com/SoCo/SoCo) 库。它们使用起来都非常简单，如下所示:使用 SoCo 通过 web API 控制 Sonos 可以说更加容易:然后，我为不同的手势创建了绑定，以便用我的智能家居设备做不同的事情:当我最终实时测试我的模型时，我对结果非常满意。我的模型在大部分时间里准确地预测了我的手势，我能够用这些手势来控制灯光和音乐。观看下面的视频进行演示:我希望你喜欢这个结果！感谢阅读。你可以在推特上找到我，这里是 T1，在 T2 的领英上找到我，这里是 T3。最近，我一直在为 Databricks 写内容，用简单的术语解释复杂的主题，就像[这个页面解释数据湖](https://databricks.com/discover/data-lakes/introduction)。最后，我定期给数据博客投稿。向前向上！# 训练随机森林以识别恶性乳腺癌肿瘤> 原文：<https://towardsdatascience.com/training-a-random-forest-to-identify-malignant-breast-cancer-tumors-49e8a69fc964?source=collection_archive---------5----------------------->在 Sklearn Python 库中，有一组可以导入的示例数据集。在这些数据集中，有一个二元分类乳腺癌数据集，是从威斯康星州的观察中提取的。我选择为一个个人项目研究这个数据集，因为它提出了一个我认为有影响力和有趣的主题(也是练习我在数据科学方面的技能的好方法)——**我的目标是训练一个分类模型来识别恶性乳腺癌肿瘤，准确率为> 95%** 。数据集可以按如下方式导入:Importing the Data Set# 构建用于比较的基线模型在对数据集进行任何分析之前，**通常最好建立一个基线分类模型，该模型可以用作基准**来决定机器学习模型是否有效。为了建立这个基线模型，我观察了数据集中“恶性”(标记为 1)和“良性”(标记为 0)观察值的分布。根据这些分类类别中哪一个更有可能(或发生率更高)，我预测每个观察结果都属于更有可能的类别。下图显示了两个目标类别的分布情况:Distribution of the Output Variable从该图可以看出，大约有 350 个“恶性”观察值和大约 220 个“良性”观察值。因此，如果每个观察结果都被预测为恶性，就会创建一个大约 61%准确的模型**——这个简单的模型将被用作未来比较的基准。**# **数据清理和预处理****在定义了简单的基线模型之后，我执行了一些快速的数据清理和观察，例如**检查空值**，**查看数据集中每个特性的数据类型**，以及**查看集合中观察值的总数**。在这种情况下，因为数据来自 Sklearn python 库中维护的示例集，所以不需要做太多的数据清理工作。如果数据集存储在 pandas 数据框中，可以使用以下命令检查每一列中 null 值的总数:********Checking for Null Values with Pandas****在这种情况下，**在数据集**中不存在空值，因此不需要替换/清除数据中的空值。此外，当检查每一列的数据类型时(使用熊猫数据框的**“dtypes”**属性)，发现所有数据都是类型**“float 64”**。因此，因为所有的特征都已经是数字的，所以不必进行数据清理来创建可以直接输入到机器学习模型中的特征。这个预处理阶段唯一有趣的发现是数据集只包含 569 个观察值。这是用于训练机器学习模型的非常少量的数据，并且可能在未来产生问题(即，模型的过度拟合或缺乏准确性)，因此在选择使用随机森林对数据进行分类时，这一点得到了充分的考虑(随机森林对过度拟合有很强的抵抗力，在此[阅读更多关于它们的信息](https://www.kdnuggets.com/2017/10/random-forests-explained.html))。**# ****探索性数据分析(EDA)******为了更好地理解数据集以及哪些特征可能对机器学习模型有用，进行了简单的数据分析和可视化。对数据集进行的第一个查询是可视化数据集中所有不同特征的相关性矩阵(在熊猫数据帧上使用**“corr”**方法计算相关性)。该关联图**揭示了哪些特征为问题提供了新信息，哪些特征与集合中的其他特征**相似。相关矩阵被绘制为热图，这使得数据集中各要素之间的相关性变得易于查看。看起来如下:********Correlation Heat Map for the Breast Cancer Data Set****在这种情况下，具有白色的特征对彼此高度相关，因此呈现出与问题相似的信息。例如，特征对(0，2)、(0，3)和(2，3)都高度相关。后来，当为机器学习模型选择特征时，考虑了这种高相关性，并且消除了与其他特征具有非常高相关性(> 98%)的特征。****除了可视化相关性，还对数据集中的每个特征进行了单变量分析和可视化。更具体地说，创建了特征值及其相关分类的散点图和每个目标类别的平均特征量图。单独查看每个特征的分布会使**更好地理解每个目标类别**之间哪些特征具有明显/可见的差异，从而揭示哪些特征在创建分类模型时会有用。这些可视化的一些结果如下:********Univariate Visualization Ex. 1****在这种情况下，特征 5 显示了两个目标分类类别之间值的**明显差异，其中分类为“良性”(0)的观察值似乎比分类为“恶性”(1)的观察值更高。因此，该可视化暗示特征 5 可能是包括在最终分类模型中的有用特征。**********Univariate Visualization Ex. 2****在上面的可视化中，特征 7 似乎在两个目标类别之间具有**相似的特征——散点图上 1 和 0 大致相似的位置以及相似的平均特征值。因此，这种可视化暗示了特征 7 在确定准确分类时对我们的模型可能不是那么有用。******当决定在训练机器学习模型中使用哪个特征时，在两个目标分类类别之间表现出显著特征差异的特征被保留，而没有表现出这种差异的特征被去除。一旦排除了这些特性，就创建了一个聚合可视化(使用 seaborn python 库中的 **"pairplot"** 方法)来查看集合中最有趣的特性的整体属性。结果如下:********Pair Plot of Selected Features****上面的图由每个观察值的分类值着色。对于配对图中的每个特征，可以注意到，在大多数情况下，可以注意到两个目标分类类别之间的值的差异。**# ****特征工程/选择******在数据集上执行简单的 EDA 之后，哪些特征将对机器学习模型有用变得非常清楚。因此，在选择/创建特征时没有做太多额外的工作。尝试用于自动特征选择的一些方法包括:*** **使用 Sklearn 创建多项式和交互式特征。** * **运行简单的随机森林，并根据要素对模型的重要性选择要素。** * **消除与集合中其他特征高度相关的特征。****创建多项式要素并没有提高随机森林模型的性能(精度实际上降低了)。然而，**使用随机森林的“feature_importances_”属性**过滤特征非常有用，并最终提高了最终模型的准确性。为了创建这样的过滤器，在现有特征集(不包括多项式特征)上训练默认随机森林，并且通过参考训练的随机森林的“feature_importances_”属性来确定每个特征的重要性。为重要性低的特征设置阈值**，重要性低于重要性阈值的所有特征都从数据集中删除**。测试了几个重要性阈值，以确定哪一个性能最好，结果如下:********Feature Filtering on Different Importance Thresholds****从上面的报告中可以看出，最佳过滤阈值是 0.008，准确率为 95.5%(高于我最初的目标！).在特征工程的最后一步之后，工作开始建立最终模型。**# **构建随机森林模型****对于这个实验，使用 Sklearn 随机森林分类器对数据进行分类。可以使用以下代码导入该模型并使其适合一组观察值:********Example of Constructing a Random Forest Classifier****上面的代码从 Sklearn 库中导入随机森林，用 50 棵树的大小实例化它( **n_estimators** 是将被构造来形成随机森林对象的决策树的数量)，并使随机森林适合一组测试数据。在这个实验中，使用 Sklearn.model_selection 中的 **"train_test_split"** 方法将数据分成训练集和测试集，该方法根据所需的比率将数据分成训练组和测试组。当随机森林使用分区的训练和测试数据进行训练时，结果如下:********Random Forest Accuracy****从上面可以看出，50 棵决策树的随机森林在数据集上获得了 95.77% 的**准确率！这超过了该实验最初设定的 95%的准确率目标。然而，在实验结束之前，对随机森林的不同数量的估计量进行了测试，以查看模型是否可以变得更加精确。此外，最高性能随机森林的**精度和召回**被观察以获得关于模型的整体质量的另一个度量。****# **测试不同的随机森林大小****选择了 25、50、75、100、125 和 150 的随机森林大小，并测试了每个模型的准确性，以确定哪种大小的随机森林最有效。结果如下:********Accuracy with Different Forest Sizes****在上面的报告中，可以看到最准确的森林大小是 125，准确率为 96.7%！这样的准确率远远高于 95%的最初目标，因此**该模型被选为表现最好的**，然后观察该模型的精确度和召回率以评估其整体质量。**# **精确度和召回率****因为原始数据集有些不平衡(目标分类类别不是均匀分布的)，**除了准确性**之外，对我的模型的质量进行度量是一种很好的做法——具有不平衡目标变量分布的模型可能会获得较高的准确性，但实际上并没有很好地拟合数据。因此，决定观察每个目标分类类别的模型的**精度**和**召回**。如果你对这些术语不熟悉，我推荐你阅读[这篇文章](http://scikit-learn.org/stable/auto_examples/model_selection/plot_precision_recall.html)来更好地理解它们。与准确度一样，精确度和召回率也是评估机器学习模型有效性的一个指标。使用以下代码可以观察随机森林模型的精度和召回率:********Code for Finding Precision and Recall****使用上述代码，评估了 125 估计量随机森林模型的精度和召回率，以获得以下结果:********Precision/Recall Score****该模型平均获得了 **99%的精确度和**99%的召回率，这是一个非常好的分数(1.0 是这两个分数的最高分)。观察到这一指标后，很明显随机森林分类模型与数据吻合得很好，准确率超过 96%，精确度/召回分数为 99% 。**# **结论****在这篇文章中，我使用 Sklearn 乳腺癌数据集建立了一个随机森林分类模型，将乳腺癌肿瘤分为“恶性”或“良性”。我最初的目标是获得一个至少 95%准确的模型。在对简单的 EDA 进行预成型以确定数据集中最重要的特征，分析各种选定特征的特征重要性，并测试不同大小的随机森林后，我得到了一个最终的模型，其准确率为 **96.7%** ！****如果你想看看这个项目的源代码，你可以看看为它创建的 [*GitHub 库*](https://github.com/wolfecameron/MachineLearning/blob/master/breast_cancer_classification.py) ！如果你有任何问题或者想关注我未来的帖子，请随时评论这篇帖子或者通过 [*LinkedIn*](https://www.linkedin.com/in/cameron-wolfe-9b2511144/) 与我联系。 ***非常感谢您的阅读！*****# 训练一个代理来打败网格世界> 原文：<https://towardsdatascience.com/training-an-agent-to-beat-grid-world-fac8a48109a8?source=collection_archive---------2----------------------->什么是网格世界？网格世界是一个大小为(Ny，Nx)的 2D 矩形网格，代理从一个网格方块开始，并试图移动到位于其他地方的另一个网格方块。这种环境是应用强化学习算法来发现网格上的代理的最佳路径和策略的自然环境，以便以最少的移动次数到达他们期望的目标网格方格。就我个人而言，我一直认为解决网格世界是开始学习强化学习的一个很好的方式，因为它直观的几何图形和它与许多现实世界应用的相关性。在我们的网格世界实现中，我们从左上角的网格角(0，0)开始代理，目标是以最少的步数(Ny + Nx 步)到达右下角的网格角(Ny-1，Nx-1)。代理只允许在*上、下、左、右*方向移动 1 个方格的动作。为了打败这个游戏，我们使用了一个*策略上的蒙特卡罗平均奖励抽样的强化学习算法，以及带有一个*ε贪婪代理*的*在网格世界环境*中导航。在这个实现中使用了奖励、状态-动作值和策略的表格形式(在这里适用于小网格尺寸)，上面的大部分理论可以在萨顿&巴尔托的“强化学习”教科书中找到。这个算法的 Python 代码实现可以在我的 Github 中找到:*> [**https://github . com/ankonzoid/learning x/tree/master/classical _ RL/grid world**](https://github.com/ankonzoid/LearningX/tree/master/classical_RL/gridworld)通过运行我们的代码，可以找到最佳策略的示例代码输出:``` Final policy:[[2 1 1 2 2 2 2][2 2 1 1 2 1 2][1 2 1 1 2 2 2][2 1 1 2 1 1 2][1 1 2 2 2 1 2][1 1 1 1 1 2 2][1 1 1 1 1 1 3]]action['up'] = 0action['right'] = 1action['down'] = 2action['left'] = 3 ```注意，在这种情况下不存在唯一的最优策略！只要最终训练的策略中的所有动作是“向下”或“向右”移动，那么我们将知道我们处于(非唯一的)最优策略。在本文的剩余部分，我们将在代码中简要介绍代理和环境的组成。更多我关于深度学习和强化学习的博客、教程、项目，请查看我的 [**中**](https://medium.com/@ankonzoid) 和我的 [**Github**](https://github.com/ankonzoid) **。**# 我们的 Python 代码中使用的方法的演练我发现通过定义 4 个不同的对象类，我们可以使代码在概念上更容易理解。具体来说，这些类是:(1)环境 (2)智能体 (3)大脑(智能体) (4)记忆(智能体)训练周期包括让代理通过采取行动、收集相应的奖励以及将其状态转换到其他状态来与环境进行交互。基于大脑通过处理存储在存储器中的事件的过去状态和动作历史而进行的操作，可以完成代理如何建立其未来决策。正是这种大脑和记忆的结合，提供了对什么样的状态和行动序列可以导致对代理人的高和低长期回报的评估。## **问题 1:** 我们如何设置环境？我们定义了一个 2D 网格，并开始定义代理在每个网格方格*上允许的动作，即代理可以在中间方格的所有 4 个方向上移动，在网格边缘的 3 个方向上移动，在网格角落的 2 个方向上移动。*我们还将智能体的起始状态定义为坐标(0，0)对应网格的左上角，将(Ny-1，Nx-1)定义为网格右下角的终止状态。至于对代理人的奖励，我们对到达期望的目标方格给予 R=+100 的奖励，以及 R=-0.1 的奖励，以激励代理人减少过多的移动次数来达到目标。## 问题 2:我们如何设置代理？我们在这里为代理选择一个ε贪婪策略，这意味着对于每个动作决策，代理尝试完全随机动作的概率为ε(不需要代理大脑)，否则它将贪婪地选择一个动作*，即 argmax{action} Q(state，action)* (需要代理大脑)。## 问题 3:我们如何设置大脑？我们初始化一个列表状态-动作值函数 Q(s，a ),它将被迭代更新以帮助代理的开发机制。回想一下，Q(s，a)表示对状态“s”应用动作“a ”,然后对剩余的状态转换遵循最优策略所收集的预期长期贴现或未贴现回报。特别是对于我们的网格世界示例代码，我们使用一种*奖励平均抽样*技术作为我们的 Q(s，a)更新方法，这是一种计算 Q(s，a)的简单方法，作为当(s，a)被代理体验时收集的平均总奖励(更多细节请参考萨顿&巴尔托)。Q(s，a)更新发生在每一集之后，其中我们获取从该集收集的总报酬，并且准确地更新代理在该集期间经历的(s，a)状态-动作对的 Q(s，a)值；正是记忆储存了这些信息，供大脑处理。## 问题 4:我们如何设置内存？记忆的目的是通过记录一个情节中发生的状态、动作和奖励来帮助大脑进行计算。因此，这就像在训练期间和之后反复更新我们的计数器一样简单。# 训练和可视化单词向量> 原文：<https://towardsdatascience.com/training-and-visualising-word-vectors-2f946c6430f8?source=collection_archive---------0----------------------->*用数据做酷事！*在本教程中，我想展示如何在 tensorflow 中实现 skip gram 模型，为您正在处理的任何文本生成单词向量，然后使用 tensorboard 将它们可视化。我发现这个练习非常有用，有助于我理解 skip gram 模型是如何工作的，以及在你将它们用于 CNN 或 RNNs 之前，感受一下这些向量捕捉到的关于你的文本的关系。我在 text8 数据集上训练了一个 skip gram 模型，该数据集是英文维基百科文章的集合。我用 Tensorboard 来可视化嵌入。Tensorboard 通过使用 PCA 选择 3 个主轴来投影数据，可以让您看到整个单词云。超级爽！你可以输入任何单词，它会显示它的邻居。你也可以分离出最接近它的 101 个点。参见下面的剪辑。你可以在我的 [Github](https://github.com/priya-dwivedi/Deep-Learning/blob/master/word2vec_skipgram/Skip-Grams-Solution.ipynb) repo 上找到完整的代码。为了可视化训练，我还查看了与一组随机单词最接近的预测单词。在第一次迭代中，最接近的预测字看起来非常任意，这是有意义的，因为所有的字向量都是随机初始化的``` **Nearest to cost:** sensationalism, adversity, ldp, durians, hennepin, expound, skylark, wolfowitz,**Nearest to engine:** vdash, alloys, fsb, seafaring, tundra, frot, arsenic, invalidate,**Nearest to construction:** dolphins, camels, quantifier, hellenes, accents, contemporary, colm, cyprian,**Nearest to http:** internally, chaffee, avoid, oilers, mystic, chappell, vascones, cruciger, ```训练结束时，该模型在寻找单词之间的关系方面变得更好。``` **Nearest to cost:** expense, expensive, purchase, technologies, inconsistent, part, dollars, commercial,**Nearest to engine:** engines, combustion, piston, stroke, exhaust, cylinder, jet, thrust,**Nearest to construction:** completed, constructed, bridge, tourism, built, materials, building, designed,**Nearest to http:** www, htm, com, edu, html, org, php, ac, ```## **Word2Vec 和 Skip Gram 型号**创建单词向量是这样的过程，即获取大量文本并为每个单词创建向量，使得在语料库中共享共同上下文的单词在向量空间中彼此非常接近。这些单词向量可以非常好地捕捉单词之间的上下文关系(例如，黑色、白色和红色的向量会很接近)，并且我们使用这些向量代替原始单词来执行 NLP 任务(如文本分类或新文本生成)会获得更好的性能。生成这些词向量有两种主要的模型——连续词袋(CBOW)和跳格模型。CBOW 模型试图预测给定上下文单词的中心单词，而 skip gram 模型试图预测给定中心单词的上下文单词。一个简单的例子是:CBOW:猫吃了 _____。填空，在这种情况下，是“食物”。跳过-gram: ___ ___ __ 食物。完成单词的上下文。在这种情况下，是“猫吃了”如果你对这两种方法的更详细的比较感兴趣，那么请看这个[链接](https://iksinc.wordpress.com/tag/continuous-bag-of-words-cbow/)。各种各样的论文已经发现 Skip gram 模型可以产生更好的单词向量，所以我一直致力于实现它## **在 Tensorflow 中实现 Skip Gram 模型**这里我将列出构建模型的主要步骤。请看我的 [Github](https://github.com/priya-dwivedi/Deep-Learning/blob/master/word2vec_skipgram/Skip-Grams-Solution.ipynb) 上的详细实现1. 预处理数据我们首先清理我们的数据。删除所有标点符号、数字，将文本拆分成单个单词。因为程序处理整数比处理单词好得多，所以我们通过创建一个 vocab to int 字典将每个单词映射到一个 int。代码如下。``` counts = collections.Counter(words) vocab = sorted(counts, key=counts.get, reverse=True) vocab_to_int = {word: ii for ii, word in enumerate(vocab, 0)} ```2.二次抽样经常出现的单词，如“the”、“of”和“for ”,不会为附近的单词提供太多的上下文信息。如果我们丢弃其中一些，我们可以从数据中去除一些噪声，反过来得到更快的训练和更好的表示。这个过程被[米科洛夫](https://arxiv.org/pdf/1301.3781.pdf)称为子采样。对于训练集中的每个单词，我们将根据其频率的倒数给出的概率将其丢弃。3.创建输入和目标skip gram 的输入是每个单词(编码为 int ),目标是该窗口周围的单词。Mikolov 等人发现，如果这个窗口的大小是可变的，并且更靠近中心单词的单词被更频繁地采样，那么性能会更好。“由于距离较远的单词通常比距离较近的单词与当前单词的关系更小，因此我们在训练示例中通过从这些单词中抽取较少的样本来降低距离较远的单词的权重……如果我们选择窗口大小=5，则对于每个训练单词，我们将在 1 和窗口大小之间随机选择一个数字 R，然后使用当前单词的历史中的 R 个单词和未来中的 R 个单词作为正确的标签。”```R = np.random.randint(1, window_size+1)start = idx — R if (idx — R) > 0 else 0stop = idx + Rtarget_words = set(words[start:idx] + words[idx+1:stop+1]) ```4.构建模型从 [Chris McCormick 的博客](http://mccormickml.com/2016/04/19/word2vec-tutorial-the-skip-gram-model/)中，我们可以看到我们将要建立的网络的大致结构。我们将把像“蚂蚁”这样的输入单词表示为一个热向量。这个向量将有 10，000 个分量(我们词汇表中的每个单词一个分量)，我们将在对应于单词“ants”的位置放置一个“1”，在所有其他位置放置 0。网络的输出是一个单一的向量(也有 10，000 个分量),它包含我们词汇表中的每个单词，随机选择的邻近单词是该词汇表单词的概率。在训练结束时，隐藏层将具有训练过的单词向量。隐藏层的大小对应于我们的向量的维数。在上面的例子中，每个单词都有一个长度为 300 的向量。您可能已经注意到，skip-gram 神经网络包含大量的权重……对于我们有 300 个特征和 10，000 个单词的 vocab 的示例，隐藏层和输出层各有 3M 个权重！在大型数据集上进行这种训练是不允许的，因此 word2vec 的作者引入了一些调整来使训练可行。你可以在[链接](http://mccormickml.com/2017/01/11/word2vec-tutorial-part-2-negative-sampling/)中了解更多信息。 [Github](https://github.com/priya-dwivedi/Deep-Learning/blob/master/word2vec_skipgram/Skip-Grams-Solution.ipynb) 上的代码实现这些来加速训练。5.使用 Tensorboard 可视化您可以使用 Tensorboard 中的嵌入投影仪来可视化嵌入。为此，您需要做几件事:* 在培训结束时，将您的模型保存在检查点目录中 * 创建一个 metadata.tsv 文件，将每个 int 映射回 word，以便 Tensorboard 显示单词而不是 int。将这个 tsv 文件保存在同一个检查点目录中 * 运行以下代码:``` from tensorflow.contrib.tensorboard.plugins import projector summary_writer = tf.summary.FileWriter(‘checkpoints’, sess.graph) config = projector.ProjectorConfig() embedding_conf = config.embeddings.add() # embedding_conf.tensor_name = ‘embedding:0’ embedding_conf.metadata_path = os.path.join(‘checkpoints’, ‘metadata.tsv’) projector.visualize_embeddings(summary_writer, config) ```* 通过将 tensorboard 指向检查点目录来打开它就是这样！给我一个❤️，如果你喜欢这个职位:)希望你拉代码，并尝试自己。如果你对这个话题有其他想法，请在这篇文章上发表评论，或者给我发邮件，地址是 priya.toronto3@gmail.com**其他著述**:[http://deeplearninganalytics.org/blog](http://deeplearninganalytics.org/blog)PS:我有自己的深度学习咨询公司，喜欢研究有趣的问题。我已经帮助几家初创公司部署了基于人工智能的创新解决方案。请到 http://deeplearninganalytics.org/[来看看我们。](http://deeplearninganalytics.org/)如果你有一个我们可以合作的项目，请通过我的网站或 priya.toronto3@gmail.com 联系我**参考文献:*** [Udacity](https://www.udacity.com/) 深度学习纳米度# 训练深度神经网络> 原文：<https://towardsdatascience.com/training-deep-neural-networks-9fdb1964b964?source=collection_archive---------3----------------------->## 深度学习配件深度神经网络是计算机视觉和语音识别领域的关键突破。在过去的十年里，深度网络使机器能够识别图像、语音，甚至以人类几乎不可能的精度玩游戏。为了达到高水平的准确性，需要大量的数据和计算能力来训练这些网络。然而，尽管涉及到计算的复杂性，我们可以遵循某些准则来减少训练的时间和提高模型的准确性。在本文中，我们将介绍其中的一些技术。## 数据预处理数据预处理的重要性只能通过这样一个事实来强调，即您的神经网络仅与用于训练它的输入数据一样好。如果重要的数据输入丢失，神经网络可能无法达到所需的精确度。另一方面，如果数据没有被预先处理，它会影响网络的准确性和性能。**均值减法(零居中)**这是从每个数据点中减去平均值使其以零为中心的过程。考虑神经元(单元)输入全为正或全为负的情况。在这种情况下，反向传播期间计算的梯度将是正的或负的(与输入的符号相同)。因此参数更新只限于特定方向，这反过来会使收敛效率低下。Mean subtraction (Zero centering the data)**数据正常化***归一化*是指将数据归一化，使其在所有维度上具有相同的尺度。通常的方法是将每个维度的数据除以其标准偏差。然而，只有当你有理由相信*不同的输入特征具有不同的尺度，但它们对学习算法*具有同等的重要性时，这才有意义。Normalization of data across both dimensions## 参数初始化*深度神经网络*对数百万或数十亿的参数并不陌生。这些参数的初始化方式可以决定我们的学习算法收敛的速度以及最终的精确度。最直接的方法是将它们全部初始化为零。然而，如果我们将层的权重初始化为全零，则对于层中的每个单元，计算的梯度将是相同的，因此对于所有单元，权重的更新将是相同的。因此，该层与单个[逻辑回归](/logistic-regression-detailed-overview-46c4da4303bc)单元一样好。当然，我们可以通过用一些小随机数初始化权重来做得更好。不是吗？好吧，让我们用一个 10 层深度神经网络来分析这个假设的有效性，每个神经网络由 500 个单元组成，并使用双曲正切激活函数。*【在继续下一步之前，请注意 tanh 激活】。*Tanh activation function*左边是 tanh 激活函数的图。随着我们继续进行，有几个要点需要记住:-** *该激活以零为中心。* * *输入为大正数或大负数时饱和。*首先，我们从具有零均值和 1 e-2 标准偏差的标准高斯初始化所有权重。```**W = 0.01 * np.random.randn(fan_in, fan_out)** ```不幸的是，这仅适用于小型网络。为了了解它对更深层次的网络造成了什么问题，用不同的参数生成了图。随着我们深入网络，这些图描绘了每一层的平均值、标准偏差和激活度。Mean, standard deviation and activation across layers注意，平均值总是在零附近，这很明显，因为我们使用的是以零为中心的非线性。然而，随着我们深入网络，标准差逐渐缩小，直到它崩溃为零。这也是显而易见的，因为我们在每一层用非常小的权重乘以输入。因此，计算的梯度也将非常小，因此对权重的更新将可以忽略。嗯不太好！！！接下来让我们尝试用非常大的数字初始化权重。为此，让我们从均值和标准差为零的标准高斯样本中抽取权重作为 **1.0** (而不是 **0.01** )。```**W = 1.0 * np.random.randn(fan_in, fan_out)** ```下图显示了所有层的平均值、标准偏差和激活度。Mean, standard deviation and activation across layers请注意，每一层的激活要么接近 1，要么接近-1，因为我们将输入乘以非常大的权重，然后将其馈送到 *tanh 非线性*(挤压到+1 到-1 的范围)。因此，当 tanh 在这些区域饱和时，计算的梯度也将非常接近于零(导数为零)。最后，对重量的更新也几乎可以忽略不计。实际上， [Xavier 初始化](https://medium.com/@shiyan/xavier-initialization-and-batch-normalization-my-understanding-b5b91268c25c)用于初始化所有层的权重。Xavier 初始化背后的动机是以这样一种方式初始化权重，使得它们不会在 tanh 激活的饱和状态中结束，即使用不太小也不太大的值进行初始化。为了实现这一点，我们在从标准高斯随机采样的同时，根据输入的数量进行缩放。``` **W = 1.0 * np.random.randn(fan_in, fan_out) / np.sqrt(fan_in)** ```然而，这在假设 tanh 用于激活的情况下工作得很好。如果有其他激活功能，例如 ReLu，这肯定会中断。毫无疑问，正确的初始化仍然是一个活跃的研究领域。## 批量标准化这与我们到目前为止所讨论的内容有些关联。请记住，我们在将输入输入到我们的网络之前对其进行了标准化。这样做的一个原因是考虑到网络中由*协方差偏移引起的不稳定性。*> 它解释了为什么即使在学习了从一些输入到输出的映射之后，我们还需要重新训练学习算法，以便在输入的数据分布改变的情况下学习从相同的输入到输出的映射。然而，这个问题并没有在这里得到解决，因为数据分布在更深的层中也可能发生变化。每一层的激活会导致不同的数据分布。因此，为了增加深度神经网络的稳定性，我们需要通过减去平均值并除以标准偏差来标准化每一层的数据*。[有一篇文章](/batch-normalization-in-neural-networks-1ac91516821c)对此进行了深入的解释。*## 正规化训练深度神经网络最常见的问题之一是*过拟合。*当你的网络在训练数据上表现出色，但在测试数据上表现不佳时，你就会意识到过度拟合。这是因为我们的学习算法试图拟合输入中的每个数据点，即使它们代表一些随机采样的噪声，如下图所示。[Source](https://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&cad=rja&uact=8&ved=2ahUKEwiu2L7c7a_dAhUG148KHUIhBjcQjB16BAgBEAQ&url=https%3A%2F%2Fmedium.freecodecamp.org%2Fdeep-learning-for-developers-tools-you-can-use-to-code-neural-networks-on-day-1-34c4435ae6b&psig=AOvVaw0zkZFmgiIZ1BtRgFgYTcDD&ust=1536648985107959)*正则化*通过惩罚网络的权重来帮助避免过度拟合。为了进一步解释，考虑为神经网络上的分类任务定义的损失函数如下:Loss function``` **J(theta) - Overall objective function to minimize. n - Number of training samples. y(i) - Actual label for ith training sample. y_hat(i) - Predicted label for ith training sample. Loss - Cross entropy loss. Theta - Weights of neural network. Lambda - Regularization parameter.** ```请注意，*正则化参数* (lambda)如何用于控制权重对最终目标函数的影响。因此，在λ取非常大的值的情况下，网络的权重应该接近于零，以便最小化目标函数。但是，当我们让权重崩溃为零时，我们会抵消层中许多单元的影响，因此网络并不比具有几个逻辑回归单元的单个线性分类器好。出乎意料的是，这将把我们扔进所谓的欠拟合状态，这并不比过拟合好多少。显然，我们必须非常小心地选择λ的值，以便最终我们的模型落入平衡类别(图中的第三个图)。## 辍学正规化除了我们所讨论的，还有一种更强大的技术来减少深度神经网络中的过拟合，称为*退出正则化*。> 关键思想是在训练网络时随机丢弃单元，以便我们在每次迭代中使用更小的神经网络。丢弃一个单元等同于在向前传播或向后传播期间忽略那些单元。在某种意义上，这阻止了网络适应一些特定的特征集。[Source](https://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&cad=rja&uact=8&ved=2ahUKEwj2-6regrDdAhXKtY8KHQ5TCjcQjB16BAgBEAQ&url=https%3A%2F%2Fwww.researchgate.net%2Ffigure%2FDropout-Neural-Net-Model-14_fig1_308916211&psig=AOvVaw2fUW3-YrCEO4K0NcnUO2KQ&ust=1536654624593452)在每次迭代中，我们会从网络中随机删除一些单元。因此，我们强迫每个单位不要依赖(不要给高权重)前一层的任何特定单位，因为它们中的任何一个都可能随机爆炸。这种分散权重的方式最终会缩小单个单元级别的权重，类似于我们在 L 2 正则化中所讨论的。*大部分内容可以归功于*[](http://cs231n.stanford.edu/) [## 斯坦福大学 CS231n:用于视觉识别的卷积神经网络### 计算机视觉在我们的社会中已经变得无处不在，在搜索、图像理解、应用程序、地图绘制…cs231n.stanford.edu](http://cs231n.stanford.edu/) *请通过您的评论让我知道文章中需要的任何修改/改进。*# 使用谷歌合作实验室训练甘斯！> 原文：<https://towardsdatascience.com/training-gans-using-google-colaboratory-f91d4e6f61fe?source=collection_archive---------5----------------------->在我们开始之前，我只想让读者明白，这篇文章旨在做两件事:1. Google Colab 入门(及其免费的 K80 GPUs😛) 2. 训练一个生成性的对抗网络(即使你是深度学习的新手或不熟悉，也没关系，只要享受输出就好了……哦，孩子😈)现在，你已经知道的*是什么，让我们直接进入主题:*# **什么是谷歌联合实验室？**如果你的电脑中没有足够好的 GPU 或 CPU，那么现在合作实验室是你最好的选择。Colaboratory 是 Google 的免费 Jupyter 笔记本环境，不需要设置，完全在云中运行。通常缩写为“ *Colab”，*这是目前可用的最佳选择。它完全免费使用，并且已经安装了许多 Python 库和包。它还在笔记本本身提供了一个终端接口，你可以通过 *pip* 安装任何其他的库。Colab 由强大的 K80 GPUs 支持，也支持本地运行时。这使得它比 Paperspace 或 AWS 等任何其他云平台都更好。所以现在就去拿你的 Google Colab 笔记本吧！😸[](https://colab.research.google.com/) [## 谷歌联合实验室### 编辑描述colab.research.google.com](https://colab.research.google.com/) # 什么是‘生成性对抗网络’？生成对抗网络(GANs)是深度学习中的下一个大事件。顾名思义，GAN 是各种深度学习模型的组合( *s* )，这些深度学习模型试图相互竞争，以满足任何深度学习项目中最基本的需求: ***生成*** ***更多数据以在*上训练😛**。在这里，我们将训练一个由两个模型组成的 GAN:1. 发电机。(它将试图从现有数据中生成*伪造数据*，并最终试图欺骗侦探，使其相信这是*真实数据*) 2. 鉴别器。(这将是我们的侦探😃试图找出生成器生成的伪造数据)这两个模型相互竞争，将会给我们最好的可能的 ***新的*** 和 ***看不到的*** 数据。如果您对深度学习更感兴趣，并且需要关于什么是 GAN 的更多细节，您可以稍后关注这篇文章:[](https://medium.com/@jonathan_hui/gan-whats-generative-adversarial-networks-and-its-application-f39ed278ef09) [## 什么是生成式对手网络？### 从无到有创造一些东西是最伟大的感觉之一，...简直是天堂。medium.com](https://medium.com/@jonathan_hui/gan-whats-generative-adversarial-networks-and-its-application-f39ed278ef09) # 我们自己培养一个甘吧！从现在开始，我们的讨论将遵循我的 Colab 笔记本的内容，您可以在这里找到:[](https://colab.research.google.com/github/rajaswa/Google_Collaboratory_Projects/blob/master/Digit_Generation_by_GAN.ipynb) [## 谷歌联合实验室### 编辑描述colab.research.google.com](https://colab.research.google.com/github/rajaswa/Google_Collaboratory_Projects/blob/master/Digit_Generation_by_GAN.ipynb) 这个笔记本已经实现了所有代码，并且已经运行过一次。您可以使用自己的笔记本从头开始，也可以一步一步地运行笔记本中的单元。## #第一步:Google Colab 没有这个项目的一些依赖项。所以我们将使用 colab 中的终端接口通过 *pip* 安装它们。(运行前三个单元格)Installing Pytorch, torchvision and tensorboardX via pip (run first three cells to install them)只是为了确保您确实从 Colab 获得了 GPU 支持，运行笔记本中的最后一个单元格(上面写着: *torch.cuda.is_available。*如果它返回一个 ***假*** 值，那么从顶部菜单改变运行时设置## #第二步:接下来，让我们导入所有需要的库并创建一个 logger 类，它将帮助我们监控我们的训练进度。(这并不重要，如果您没有完全理解 logger 类中正在做什么也没关系)## #第三步:我们将在这里使用的数据集是 MNIST 手写数字图像数据集。因此，让我们创建数据集类，下载数据集并初始化数据加载器，数据加载器将迭代地向模型提供数据。## #第四步:现在，让我们创建生成器和鉴别器模型。这些将是 3 层深度神经网络，在每个隐藏层中具有顺序->线性->泄漏 ReLU 函数。## #第五步:接下来，让我们创建噪声采样器(我们将馈送给生成器)，初始化优化器，初始化损失函数(我们使用 BCE 损失进行生成器和鉴别器之间的最小-最大对抗游戏)。我们还将定义一些函数，这些函数将在以后帮助我们定位或标记真假图像。然后，让我们为生成器和鉴别器模型定义训练函数。## #第六步:最后，让我们交叉手指，开始训练吧！😃*注意:众所周知，Colab 在 PIL 模块方面存在一些问题。如果出现任何与 PIL 相关的错误，只需重启内核，并使用顶部菜单中的运行时选项重新运行所有单元。*在这里，我们应该在 Colab 上训练 200 个纪元，大约需要 1.5-2 小时。笔记本已经训练了 139 个纪元，我们可以清楚地看到它在短短的 139 个纪元中提供了什么输出。你可以前进，训练它完成 200 个历元，以得到完美书写的数字。## #输出:最初，输出几乎都是有噪声的图像，但是几个时期之后，你会看到模型开始学习手写数字的模式:(从左到右，学习的进度)# 那么，我们实际上取得了什么呢？到目前为止，我们已经看到了如何轻松地使用 Google Colaboratory，以及如何使用 Colaboratory 的 GPU 支持来实现基本的 GAN。我希望这个小项目已经让你有足够的信心在 Colab 笔记本上编写代码、安装外部库、下载数据等。## 几个小时的训练有什么结果？正如我们可以在训练单元的输出中看到的，通过训练这个 GAN，我们得到了全新的手写图像。这里要注意的最重要的一点是，这些新形成的图像是 ***而不是从实际数据集中复制的*** (正如我们的侦探，鉴别者所确保的)。相反，它们是由生成器模型生成的*原始*图像。所以，这些是我们甘*培训前*从未见过的新图像。😏**## **所有这些与人工智能有一点点联系吗？无论如何，生成模型有什么特别之处吗？********为了通俗地提出这一点，让我们通过一个例子来看这个…..****既然我们在这里使用了手写数字数据，让我们考虑这样一种情况:你希望你的人工智能尽可能有效地读取、识别和正确分类人类手写数字*。为了实现这一点，你需要你的模型事先查看尽可能多的手写数字，也就是尽可能多的不同书写风格的手写数字。那么，你想如何获得更多的这些原始手写数字图像呢？是通过*一个人一个人地跑，让他们都写下所有的数字，最终手动收集成千上万的图像*还是通过*让 GAN 在几个小时内为你生成原始图像*？😏****你可以想象，这是一个非常简单的例子，有一个深度学习的数据集😛对于庞大而复杂的数据，生成模型的优势被进一步放大。**[](https://medium.com/@jonathan_hui/gan-some-cool-applications-of-gans-4c9ecca35900) [## GAN——GAN 的一些酷应用。### 在 GAN 开发的最初几年，我们取得了令人瞩目的进展。再也没有邮票大小的面部照片了…medium.com](https://medium.com/@jonathan_hui/gan-some-cool-applications-of-gans-4c9ecca35900)* *我希望这对你来说是一次有趣的经历。如果你还没有开始深度学习，我相信这本书已经让你渴望并有动力开始你的人工智能之旅，如果你还没有使用 Google Colab，我相信你现在会自信地开始使用它！😃***干杯！****快乐编码！***如果你觉得这很有趣，你可以联系我，在这里找到我在 Github 上的其他作品。**你可以在 LinkedIn [这里](https://www.linkedin.com/in/rajaswa-patil/)和我联系。*# 使用 CPU 上的自定义图像训练初始状态> 原文：<https://towardsdatascience.com/training-inception-with-tensorflow-on-custom-images-using-cpu-8ecd91595f26?source=collection_archive---------4----------------------->## 使用 Tensorflow 使用您自己的图像进行训练在我之前的帖子中，我们看到了如何在 CPU 上使用 Python API 使用 TensorFlow 进行[图像识别，而无需任何培训。我们使用的是](/tensorflow-image-recognition-python-api-e35f7d412a70) [Inception-v3](https://arxiv.org/abs/1512.00567) 模型，它已经被谷歌在 [1000 个类](http://image-net.org/challenges/LSVRC/2014/browse-synsets)上训练过，但是如果我们想用我们自己的图像做同样的事情呢。我们将使用迁移学习，这将帮助我们**重新培训**已经培训过的 Inception-v3 模型的最后一层，从头开始添加新的类别。在笔记本电脑上大约需要 30 分钟，没有任何 GPU。要了解更多信息，请参考这个[链接](https://www.tensorflow.org/tutorials/image_retraining)或者那些只想要 linux 命令的人去他的[链接](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets/#0)。我们将在 tensorflow 托管的免费下载的花卉数据上训练模型。在我们开始之前，让我们在我的 CPU 上对一个随机的蒲公英图像做一个测试。[dandelion-in-seed.jpg](https://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&cad=rja&uact=8&ved=0ahUKEwjryKGp9OjYAhXILY8KHdGuAF4QjRwIBw&url=https%3A%2F%2Fcantbeatemeatem.com%2Frecipes%2Fdandelion%2F&psig=AOvVaw1wwYluemWr3qaXdwYgm6Tv&ust=1516618228601337)结果是…我们将使用 Python 3 和 TensorFlow 1.4如果您的 tensorflow 不是最新的，请使用以下命令进行更新。``` pip install --upgrade tensorflow ```数据集的训练可以仅通过如下 4 个步骤来完成:## 1.下载面向诗人的张量流-2先新建一个文件夹 *Flowers_Tensorflow。*现在在这里打开命令提示符并键入…``` git clone https://github.com/googlecodelabs/tensorflow-for-poets-2 ```这将从 you Flower_Tensorflow 文件夹中的 tensorflow 存储库中下载“tensor flow-for-poets-2”*文件夹。**这个文件夹包含脚本、tf_folder 等文件。*## *2.下载数据集**去这个[链接](http://download.tensorflow.org/example_images/flower_photos.tgz)下载花数据。然后从文件夹中提取“flower_photos”文件夹。tgz 文件，并将其粘贴到 tf_files 文件夹中。这个文件夹包含 5 类雏菊，蒲公英，玫瑰，向日葵，郁金香和一个 LICENSE.txt 文件。*## *3.重新训练模型**在“tensorflow-for-poets-2”文件夹中打开命令提示符，然后键入*``` *python scripts/retrain.py --output_graph=tf_files/retrained_graph.pb --output_labels=tf_files/retrained_labels.txt --image_dir=tf_files/flower_photos* ```**> *注意:这是一行。只需从上面复制完整的东西，并粘贴到命令提示符。**按回车键后，程序将开始创建。C:/tmp/through/roses 等中的 txt 文件。它将产生大约 7300 个瓶颈。txt 文件，看起来像这样。****在这之后，它将开始训练并完成大约 4000 步，就像这样…****当您的计算机正在对新的花卉数据集进行训练时，让我分解命令并解释我们刚刚做了什么..**整个命令可以分为 4 个部分**调用/运行 retrain.py 脚本。*``` *python scripts/retrain.py* ```***在 tf_files 文件夹下新建一个图形文件**(训练完成后)。*``` *--output_graph=tf_files/retrained_graph.pb* ```***在 tf_files 文件夹下新建一个标签文件**(训练完成后)**。***``` *--output_labels=tf_files/retrained_labels.txt* ```***指向花卉数据集目录。***``` *--image_dir=tf_files/flower_photos* ```*注意:您可以在上面的命令中添加/更改参数****更改除 Inception-v3 之外的型号** [**Mobilenet 型号**](https://research.googleblog.com/2017/06/mobilenets-open-source-models-for.html)*``` ***--architecture mobilenet_1.0_224*** ```*****张量板*****``` ***--summaries_dir=tf_files/training_summaries/${write the architecture here}*** ```*****改变瓶颈目录*****``` ***--bottleneck_dir=tf_files/bottlenecks*** ```*****改变训练步骤*****``` ***--how_many_training_steps=500*** ```## ***4.测试新训练的模型******要测试该模型，只需下载任何图像并粘贴到“tensorflow-for-poets-2”中，然后键入(其中*image.png*是文件的名称)。***``` ***python scripts/label_image.py --image image.png*** ```***但是您可能会得到一个错误。************要解决此错误，请打开脚本文件夹中的 **label_image.py** 文件。********转到第 74 行并更改数值**或转到此[链接](https://github.com/googlecodelabs/tensorflow-for-poets-2/issues/3)。******改变:***``` ***input_height = 224 input_width = 224 input_mean = 128 input_std = 128 input_layer = "input"*** ```***收件人:***``` ***input_height = 299 input_width = 299 input_mean = 0 input_std = 255 input_layer = "Mul"*** ```***现在，我们已经作出了改变，让我们这样做在其他花卉。***## *****菊花**************[**daisy.jpg**](https://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&cad=rja&uact=8&ved=0ahUKEwj02KiwnunYAhULr48KHe37BeYQjRwIBw&url=http%3A%2F%2Fwww.goodskins.com%2Fdaisy%2F&psig=AOvVaw3jl08eqWC53X-ic06RvXGm&ust=1516629903620736)*********## *****玫瑰**************[keep-roses-alive-hero.jpg](https://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&cad=rja&uact=8&ved=0ahUKEwjqvNLsnunYAhUGu48KHZUfCAUQjRwIBw&url=http%3A%2F%2Fwww.more.com%2Flifestyle%2Fstylish-home%2Fhow-keep-roses-alive&psig=AOvVaw3vU5PtVniUHSuntps3c-70&ust=1516630440087963)*********## ***向日葵************[sunflower-450231_960_720.jpg](https://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&cad=rja&uact=8&ved=0ahUKEwiZhJqhpunYAhUMsY8KHdDEDsUQjRwIBw&url=https%3A%2F%2Fpixabay.com%2Fen%2Fsunflower-flower-yellow-plant-450231%2F&psig=AOvVaw3u8b-5SBxI3oxwESl8tGkg&ust=1516631588168987)*********## ***郁金香************[pink-tulips-4.jpg](https://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&cad=rja&uact=8&ved=0ahUKEwiZ8djzpOnYAhUBOI8KHZ9pBmsQjRwIBw&url=http%3A%2F%2Feskipaper.com%2Fpink-tulips-4.html&psig=AOvVaw2dOWNrv0icXGWtDQ2aiUup&ust=1516631977835689)************好了，让我们停止吧。找了这么多花我都想吐了…***## ***如果你想在移动平台上对一个视频直播进行同样的实验。******[](/tensorflow-on-mobile-tutorial-1-744703297267) [## 手机上的 TensorFlow:教程### 在 Android 和 iOS 上towardsdatascience.com](/tensorflow-on-mobile-tutorial-1-744703297267) ## 但是先鼓掌这个！！！*** ***我已经尽力让文章尽可能准确易懂。有什么意见，建议或者有什么问题，**写在评论里吧。********关注我[中](https://medium.com/@sagarsharma4244)、[脸书](https://www.facebook.com/profile.php?id=100003188718299)、[推特](https://twitter.com/SagarSharma4244)、 [LinkedIn](https://www.linkedin.com/in/sagar-sharma-232a06148/) 、 [Google+](https://plus.google.com/u/0/+SAGARSHARMA4244) 、 [Quora](https://www.quora.com/profile/Sagar-Sharma-71) 看类似帖子。********鼓掌吧！分享一下！跟我来。********乐意帮忙。荣誉……..***# ***你会喜欢的以前的故事:***1. ***[“张量流”中的“张量”到底是什么？](https://hackernoon.com/what-the-hell-is-tensor-in-tensorflow-e40dbf0253ee)******2.[纪元 vs 批量 vs 迭代](/epoch-vs-iterations-vs-batch-size-4dfb9c7ce9c9)******3. [TensorFlow 图像识别 Python API 教程 CPU 上](/tensorflow-image-recognition-python-api-e35f7d412a70)******4.[激活函数解释:神经网络](https://medium.com/towards-data-science/activation-functions-neural-networks-1cbd9f8d91d6)***# 免费在线训练机器学习模型(GPU，TPU 启用)！！！> 原文：<https://towardsdatascience.com/training-machine-learning-models-online-for-free-gpu-tpu-enabled-5def6a5c1ce3?source=collection_archive---------5----------------------->在大数据集上训练机器学习和深度学习模型所需的计算能力，一直是机器学习爱好者的巨大障碍。但是有了运行在云上的 jupyter notebook，任何有学习热情的人都可以训练并取得很好的成绩。在这篇文章中，我将提供关于各种服务的信息，这些服务为我们训练模型提供了计算能力。1. Google Colab 2. 凯格尔内核 3. 关于 GCP 的朱庇特笔记本 4. 亚马逊 SageMaker 5. Azure 笔记本# **1)Google Colab**Colaboratory 是谷歌的一个研究项目，旨在帮助传播机器学习教育和研究。Colaboratory (colab)提供免费的 Jupyter 笔记本环境，不需要设置，完全在云中运行。它预装了大多数机器学习库，它是一个完美的地方，你可以即插即用，尝试那些不存在依赖性和计算问题的东西。笔记本连接到你的 google drive，所以你可以随时访问它，也可以从 github 上传或下载笔记本。## **GPU 和 TPU 使能**首先，你需要为笔记本电脑启用 GPU 或 TPU。导航至编辑→笔记本设置，并从硬件加速器下拉列表中选择 TPU。用于检查 TPU 是否已启用的代码``` import os import pprint import tensorflow as tfif ‘COLAB_TPU_ADDR’ not in os.environ:print(‘ERROR: Not connected to a TPU runtime; please see the first cell in this notebook for instructions!’) else:tpu_address = ‘grpc://’ + os.environ[‘COLAB_TPU_ADDR’]print (‘TPU address is’, tpu_address)with tf.Session(tpu_address) as session:devices = session.list_devices()print(‘TPU devices:’)pprint.pprint(devices) ```## **安装库**Colab 安装了大多数 ml 库，但是您也可以轻松地添加没有预安装的库。Colab 支持`pip`和`apt`包管理器。``` !pip install torch ```apt 命令``` !apt-get install graphviz -y ```这两个命令在 colab 中都有效，别忘了还有**！**(感叹句)在命令之前。## **上传数据集**有许多方法可以将数据集上传到笔记本* 用户可以从本地机器上传文件。 * 从 google drive 上传文件 * 人们也可以直接从 kaggle 上传数据集**从本地上传的代码**``` from google.colab import files uploaded = files.upload() ```您可以浏览并选择文件。**从 google drive 上传文件**PyDrive 库用于从 google drive 上传文件``` !pip install -U -q PyDrivefrom pydrive.auth import GoogleAuth from pydrive.drive import GoogleDrive from google.colab import auth from oauth2client.client import GoogleCredentials# 1\. Authenticate and create the PyDrive client. auth.authenticate_user() gauth = GoogleAuth() gauth.credentials = GoogleCredentials.get_application_default() drive = GoogleDrive(gauth)# PyDrive reference: # [https://gsuitedevs.github.io/PyDrive/docs/build/html/index.html](https://gsuitedevs.github.io/PyDrive/docs/build/html/index.html)# 2\. Create & upload a file text file. uploaded = drive.CreateFile({'title': 'Sample upload.txt'}) uploaded.SetContentString('Sample upload file content') uploaded.Upload() print('Uploaded file with ID {}'.format(uploaded.get('id')))# 3\. Load a file by ID and print its contents. downloaded = drive.CreateFile({'id': uploaded.get('id')}) print('Downloaded content "{}"'.format(downloaded.GetContentString())) ```你可以得到你想要上传的文件的 id，并使用上面的代码。获取更多资源从[谷歌服务](https://colab.research.google.com/notebooks/io.ipynb)上传文件。**从 kaggle 上传数据集**我们需要安装 kaggle api 并添加认证 json 文件，可以从 kaggle 网站下载(API_TOKEN)。``` !pip install kaggle ```通过从本地机器上传文件，将 json 文件上传到笔记本。创建一个/。kaggle 目录``` !mkdir -p ~/.kaggle ```将 json 文件复制到 kaggle 目录更改文件权限``` !cp kaggle.json ~/.kaggle/ !chmod 600 ~/.kaggle/kaggle.json ```现在，您可以使用命令从 kaggle 下载任何数据集``` kaggle datasets download -d lazyjustin/pubgplayerstats ```现在你可以使用下面的方法从 kaggle 下载比赛数据，但是你必须参加比赛。``` !kaggle competitions download -c tgs-salt-identification-challenge ```在这里你可以在线培训和运行 fashion_mnist，没有任何依赖性[。](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/tutorials/keras/basic_classification.ipynb)对于每个对机器学习感兴趣的人来说，Colab 是一个很棒的工具，所有使用 colab 的教育资源和代码片段都在[官方网站](https://colab.research.google.com/)上提供，并附有[笔记本示例](https://colab.research.google.com/notebooks/)。# 2)Kaggle 核Kaggle Kernels 是一个云计算环境，支持可重复的协作分析。人们可以在 kaggle 内核中运行 Python 和 R 代码Kaggle 内核运行在远程计算环境中。他们提供所需的硬件。在撰写本文时，每个内核编辑会话都提供有以下资源:**CPU 规格**4 个 CPU 内核17gb 内存6 小时执行时间5gb 自动节省的磁盘空间(/kaggle/working)16gb 的临时暂存磁盘空间(外部/ka ggle/工作)**GPU 规格**2 个 CPU 内核14 千兆字节内存# 运行中的内核一旦我们在[kaggle.com](http://kaggle.com)创建了一个账户，我们就可以选择一个数据集来玩，只需点击几下鼠标，就可以运行一个新的内核。点击创建**新内核**你将拥有 jupyter 笔记本。底部是您可以使用的控制台，右侧是各种选项，如## 版本当你提交和运行一个内核时，你在一个独立于你的交互会话的会话中从上到下执行内核。一旦完成，您将生成一个新的内核版本。内核版本是您工作的快照，包括您编译的代码、日志文件、输出文件、数据源等等。内核的最新版本是在内核查看器中显示给用户的。## 数据环境当您为数据集创建内核时，数据集将被预加载到笔记本的输入目录中``` ../input/ ```您也可以点击**添加数据源**，添加其他数据集设置**分享:**你可以把你的内核私有，也可以把它公开，让别人可以学习你的内核。**添加 GPU:** 你可以在你的内核中添加单个 NVIDIA Tesla K80。与本地机器或您自己的虚拟机相比，使用内核的一个主要好处是内核环境已经预先配置了 GPU 就绪的软件和软件包，这可能非常耗时，而且设置起来令人沮丧。要添加 GPU，请从内核编辑器导航到“设置”窗格，然后单击“启用 GPU”选项。**自定义包**:内核有默认的包，如果你需要任何其他的包，可以通过以下方式轻松添加* 只要输入库名，kaggle 就会为你下载。* 输入用户名/回购名称这两种方法都能很好地添加定制包。Kaggle 是一个完美的平台，既可以提供数据，也可以通过计算来处理提供的大量数据。它还举办各种比赛，人们可以尝试提高自己的技能。更多关于 kaggle link [的资源请点击这里](http://blog.kaggle.com/)。如果你是 kaggle 的新手，你绝对应该尝试一下[泰坦尼克号数据集](https://www.kaggle.com/c/titanic)它有很棒的教程。其他关于 kaggle、colab 和机器学习的资源关注 [Siraj Raval](https://medium.com/u/54526471f9bf?source=post_page-----5def6a5c1ce3--------------------------------) 和[Yufeng](https://medium.com/u/2a2ae028a675?source=post_page-----5def6a5c1ce3--------------------------------)。由于我无法在这篇文章中涵盖在线培训 ml 模型的所有服务，这篇文章将有**第 2 部分**。学习和练习机器学习所需的所有资源都是开源的，可以在线获得。从计算、数据集、算法到各种高质量的在线免费教程，你需要的只是一个**互联网连接和学习的热情。**感谢你一直读到最后，我希望这篇文章会有用，因为它解决了那些开始走向机器学习和数据科学的人所面临的主要问题。如果你喜欢这篇文章，请让我知道，为文章鼓掌。欢迎查询，您可以关注我在[maithreyan surya](https://medium.com/u/f3acb9881998?source=post_page-----5def6a5c1ce3--------------------------------)中的帖子，也可以在这里给我发邮件[。](http://suryamaithreyan@gmail.com)有效使用 Colab 的视频简介:[https://www.youtube.com/playlist?list = pl 9 a 4 goxnjut 3 qyy 56 ay 6 q 9 z B2 nm 4c Q3 tu](https://www.youtube.com/playlist?list=PL9a4goxNJut3qyy56AY6Q9Zb2Nm4CQ3Tu)**机器学习有潜力改变世界，你也一样。**# 培训 MXNet 第 4 部分:分布式培训> 原文：<https://towardsdatascience.com/training-mxnet-part-4-distributed-training-91def5ea3bb7?source=collection_archive---------6----------------------->在[第 3 部分](https://medium.com/@julsimon/training-mxnet-part-3-cifar-10-redux-ecab17346aa0)中，我们使用了 [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) 数据集，并学习了如何调整优化参数。我们最终使用一个 [g2.8xlarge](https://aws.amazon.com/blogs/aws/new-g2-instance-type-with-4x-more-gpu-power/) 实例的所有 4 个 GPU 训练了一个 110 层的 ResNext 模型……这花了大约 12 个小时。在本文中，我将向您展示如何使用多个实例来显著加快训练速度。系好安全带。Training CIFAR-10 on 4 instances and 32 GPUs. Read on!## 创建主节点我们将使用运行**深度学习 AMI** 、 [Ubuntu edition](https://aws.amazon.com/about-aws/whats-new/2017/04/deep-learning-ami-for-ubuntu-v-1-3-apr-2017-now-supports-caffe2/) 的 [p2.8xlarge](https://aws.amazon.com/blogs/aws/new-p2-instance-type-for-amazon-ec2-up-to-16-gpus/) 实例。然而，您可以很容易地用任何类型的 EC2 实例或者甚至在您办公桌下运行的一堆 PC 上复制这一点:)让我们开始吧。我们将按照我们喜欢的方式配置主节点，然后我们将**克隆**它以向我们的 MXNet 集群添加更多实例。第一步是转到 EC2 控制台的市场部分，找到深度学习 AMI。然后，选择您想要使用的实例类型。请注意实例成本:一个 p2.8xlarge 每小时的成本是 7.20 美元。不要担心，您实际上可以使用任何实例类型，因为 MXNet 能够使用实例的 CPU 或 GPU。很明显，GPU 实例会比 t2.micros 快很多:)再点击几下就完成了。只需确保 **SSH 端口**是打开的，并且您已经为实例创建了一个新的**密钥对**(姑且称之为 *ec2* )。几分钟后，您可以使用 *ubuntu* 用户(不是 *ec2-user* )进入主节点。## 在 MXNET 中启用分布式培训默认情况下，在源代码发行版中没有启用分布式培训，这意味着我们可能必须从源代码中重新构建 MXNet。如果您的构建已经包括分布式培训，您可以跳过这一部分。深度学习 AMI 包括 MXNet 源代码:我们只需将它们变成我们自己的，并刷新到最新的稳定版本( **0.9.5** 在撰写本文时)。然后，我们需要配置我们的**构建选项**。最后一个实际上实现了分布式训练。现在我们可以构建和安装库了。不需要添加依赖项，因为它们已经包含在 AMI 中了。我在 32 个内核上运行并行 make，因为这是 p2.8xlarge 所拥有的。一旦安装了这个库，运行一个快速的 Python 检查是一个好主意。好的，这个看起来不错。我们继续吧。## 为分布式培训打开端口主节点和工作节点需要相互通信以共享**数据集**以及**训练结果**。因此，我们需要改变我们的安全组的配置来允许这样做。做到这一点最简单的方法是允许 MXNet 集群实例之间的**所有 TCP** 通信，即使用**相同安全组**的实例。为此，请转到 EC2 控制台，编辑主节点的安全组的入站规则。添加一条规则，允许**所有 TCP 流量**，并使用安全组的实际名称**限制**源流量。我们的实例现在已经准备好了。让我们创建工作节点。## 创建工作节点我们将基于主节点创建一个**新 AMI** 。然后，我们用它来发动工人。在 EC2 控制台中找到您的实例并创建一个映像。几分钟后，您将在 EC2 控制台的“Images”部分看到新的 AMI。您现在可以使用它来启动您的工作节点。这里没有什么复杂的:选择您想要启动的**实例类型**、实例的**数量**(在我的例子中是 3 个)和与主节点相同的安全组**。**再过几分钟，您的实例就准备好了。很可爱。记下每个实例的私有 IP 地址，我们马上会用到它们。## 配置集群让我们登录到主节点，移动到*工具*目录并查看启动器。这是我们将用来在所有节点(包括主节点)上开始训练的工具。它做两件事:* 使用 rsync，**在每个节点上复制 */tmp/mxnet* 中的数据集**。或者，我们可以通过与自制的 NFS 或亚马逊 EFS 共享节点上的数据集来避免这种情况。 * 使用 ssh，**运行开始训练的 python 脚本**。如您所见，其他协议也是可用的，但我们今天不讨论它们。## 创建主机文件*launch.py* 需要在一个文件中声明所有节点(包括主节点)的私有 IP 地址。它应该看起来像这样。## 配置 SSH我们需要主节点和工作节点之间的无密码 ssh 访问。如果您已经准备好了，可以跳过这一部分。为了简单起见，我们将在本地计算机上创建一个新的密钥对，并在集群中分发它。> **请**不要重复使用 *ec2* 密钥对，这是不好的做法。另外，有些人可能想在 AMI 中烘焙密钥对，以避免将它分发给所有实例，但是我建议不要这样做，因为这意味着将私钥存储在所有节点上，而不仅仅是主节点上。还有[宋承宪代理转发也不好](https://heipei.github.io/2015/02/26/SSH-Agent-Forwarding-considered-harmful/)。接下来，还是从我们的本地计算机，我们将把**公钥**复制到所有节点(包括主节点),只把**私钥**复制到主节点。最后，在主节点上，我们将启动 *ssh-agent* 并添加 *mxnet* 身份。现在，您应该能够从主节点登录到每个工作节点(包括主节点本身)。在继续之前，请确保此功能正常工作。如果是的话，你已经准备好训练了，伙计:)## 开展分布式培训下面是这个神奇的命令: *hosts* 文件中列出的 4 个节点将通过 *rsync* 接收一份 */tmp/mxnet* 中数据集的副本。然后，主节点将在每个节点上运行 *train_cifar10.py* 脚本，在所有 8 个 GPU 上训练一个 110 层的 ResNext 模型。> 如果您运行在 CPU 实例上，只需删除 GPU 参数。PS_VERBOSE 变量将输出额外的信息。万一出了问题，非常有用；)您可以通过登录不同的节点并运行' *nvidia-smi -l* '命令来检查进度。那么这有多快呢？正如我之前提到的，在一个 g2.8xlarge 实例的 4 个 GPU 上运行 300 个 epochs 需要大约 12 个小时。4 个 p2.8xlarge 实例的 32 个 GPU 加起来用了 **91 分钟！**这是一个**8 倍的加速**，这是有道理的，因为我们有**8 倍多的 GPU**。我曾经读到过，现在我亲眼看到了:**确实是线性缩放**！这让我想把它推到 256 个 GPU:毕竟它只需要 16 个 p 2.16 大:D最后但同样重要的是，我的同事 Naveen Swamy 和 Joseph Spisak 写了一篇非常有趣的[博文](https://aws.amazon.com/blogs/compute/distributed-deep-learning-made-easy/)，讲述了如何使用 AWS CloudFormation 自动完成大部分工作。如果你在 AWS 中运行所有的东西，这绝对值得一读。今天到此为止。非常感谢你的阅读和最近给我的友好支持。这对我意义重大！接下来:[第 5 部分——分布式培训，EFS 版](https://medium.com/@julsimon/training-mxnet-part-5-distributed-training-efs-edition-1c2a13cd5460)# 使用循环学习率从头开始训练对象检测(YOLOv2)> 原文：<https://towardsdatascience.com/training-object-detection-yolov2-from-scratch-using-cyclic-learning-rates-b3364f7e4755?source=collection_archive---------2----------------------->对象检测的任务是识别图像中的所有对象以及它们的类别标签和边界框。这是一项具有挑战性的计算机视觉任务，最近已被 Faster-RCNN、SSD、Yolo 等深度学习算法接管。这篇文章重点介绍了最新的 Yolo v2 算法，据说它是最快的(在 Titan X 上运行时，在低分辨率图像上大约 90 FPS)，比 SSD 更准确，在少数数据集上比 RCNN 更快。我将讨论 Yolo v2 的工作原理和训练步骤。如果你想更深入地了解物体检测算法，你可以参考[这里](http://cv-tricks.com/object-detection/faster-r-cnn-yolo-ssd/)和[这里](https://github.com/Nikasa1889/HistoryObjectRecognition/blob/master/HistoryOfObjectRecognition.png)。这篇文章假设你对[卷积层](https://www.youtube.com/embed/Oqm9vsf_hvU?start=265&end=396)，最大池，[批处理](https://www.coursera.org/learn/deep-neural-network/lecture/81oTm/why-does-batch-norm-work)有基本的了解。如果没有，我建议你在附加的链接中得到一个关于主题的简要想法。# Yolo v2:你只看一次在下图中，我们需要识别人、电视监视器和自行车的边界框。按照 Yolo 算法，我们将输入图像分成 N×N(这里是 13x13)个正方形。在每个方块中，Yolo 网络(下面讨论)预测 5 个具有不同纵横比的边界框。An example of 5 boxes is shown for a square positioned at (7, 9) from top left.对于每个边界框，Yolo 网络预测其在正方形内的中心位置、框的宽度、高度、图像宽度、高度和在该框中具有任何对象的置信度得分，以及属于 M 个类别中的每一个的概率。然而，不是每个边界框都有一个对象。给定这些预测，为了找到最终的边界框，我们需要执行以下两个步骤:1. 移除没有对象的边界框。移除预测置信度得分小于阈值 0.24 的边界框 2. 在声称有对象的边界框中，使用[非最大抑制](https://www.coursera.org/learn/convolutional-neural-networks/lecture/dvrjH/non-max-suppression)和[并集上的交集](https://www.coursera.org/learn/convolutional-neural-networks/lecture/p9gxz/intersection-over-union)去除了识别相同对象的冗余。Predicted bounding boxes# YOLOv2 网络:以上步骤是图像通过 Yolo 网络后得到最终包围盒所需的后处理步骤。然而，我们还没有讨论 Yolo 网络如何产生这种输出。在这里，我要讨论一下 Yolo 网络。YOLOv2 的架构可以在这里看到[。将鼠标悬停在块上可以看到可视化中每个块的详细信息。除了最后一个卷积块之外，每个卷积块都有 BatchNorm 归一化和泄漏 Relu 激活。](http://ethereon.github.io/netscope/#/gist/d08a41711e48cf111e330827b1279c31)Conv13_512 之后的重组层(参见[可视化](http://ethereon.github.io/netscope/#/gist/d08a41711e48cf111e330827b1279c31))是一个重组层。如果输入图像的尺寸为 3x416x416(通道 x 高度 x 宽度— CHW)，则 Conv13_512 的输出尺寸为 512x26x26 (CHW)。重组层将每一个交替的像素放入不同的通道。让我们以一个 4x4 像素的单通道为例，如下所示。重组层将大小减少一半，并创建 4 个通道，相邻像素位于不同的通道中。因此，来自 Conv13_512 的 Reorg 层的输出将是 2048x13x13。Reorg layer in YOLO v2concat 层接受 Reorg 层的输出(大小:2048x13x13)和 Conv20_1024 的输出(大小:1024x13x13)，并生成大小为 3072x13x13 的连接层。# 损失函数:目标函数是多部分函数，如YOLO v2 Loss function上述函数定义了迭代 t 的损失函数。如果边界框没有任何对象，则需要降低其对象置信度，并将其表示为第一损失项。因为边界框坐标预测需要与我们的先验信息对齐，所以为少数迭代(t < 12800)添加了减少先验和预测之间的差异的损失项。如果边界框 k 负责真值框，那么预测需要与表示为第三损失项的真值对齐。𝞴值是每个损失项的预定义权重。# 训练 YOLOv2:在训练 YOLOv2 之前，作者定义了一个架构，称为 Darknet-19，用于在 ImageNet 数据集上训练。Darknet-19 具有与 YOLOv2 网络相同的前 19 层(直到 Conv18_1024)，然后附加了 1024 个滤波器的 1x1 卷积，之后是全局 AvgPool 和 Softmax 层。Darknet-19 在 ImageNet 上训练，达到 91.2%的 top-5 精度，并且训练的权重直到层 Conv18_1024 稍后在训练 YOLOv2 网络时使用。我已经用 SGD 和 Adam 做了几次实验。我已经尝试过使用动量，如论文中提到的重量衰减。我不能在使用 SGD 的测试中得到 65.7 以上的地图。然而，亚当能够比 SGD 达到 68.2 地图表现更好。后来，我尝试了在精彩的[快速人工智能](https://www.youtube.com/embed/JNxcznsrRb8?start=1155&end=3447)讲座中解释的重启循环学习率。这是一个非常有趣的技术，因为我发现在使用 lr_find()找到的学习率开始训练后，测试精度在短短 4 个时期内就开始从以前的结果提高。我遵循的策略是:1. 使用 lr_find 技术发现学习率为 0.00025，我使用 PyTorch 重新实现了该技术 2. 用 n _ epochs 训练最后的层 5 个周期，每个周期加倍，得到 31 个 epoch。我在 PyTorch 中使用 CosineAnnealingLR 方法实现了循环学习率。 3. 以不同的学习速率训练所有层 3 个周期，每个周期的时期加倍。使用上述策略，我可以在测试中获得 71.8 的地图，这比论文中提到的策略要好，我也可以在更短的时间内获得。但离论文中提到的精度(76.8 图)还是有相当大的差距。我相信我还需要进一步尝试一些东西，以接近论文中提到的精度。1. 多尺度训练，因为我无法在 PyTorch 中定期重复多尺度训练 2. 为更多的时代而训练。 3. 处理困难样品(包围盒的宽度或高度【https://github.com/santoshgsk/yolov2-pytorch I will be adding the code soon. Hit the clap if you like the post and please do let me know your thoughts about this finding.I would like to thank Jeremy Howard and Rachel Thomas for their incredible effort of sharing useful tips on training neural networks.Please find the code here: [https://github.com/santoshgsk/yolov2-pytorch](https://github.com/santoshgsk/yolov2-pytorch)# 基于 Supervisely、Tensorflow 和 UNet 的城市道路场景分割训练> 原文：<https://towardsdatascience.com/training-road-scene-segmentation-on-cityscapes-with-supervisely-tensorflow-and-unet-1232314781a8?source=collection_archive---------0----------------------->自 2012 年 Alex Krizhevsky 发表他的开创性 AlexNet 以来，深度学习工具集已经走过了漫长的道路，从一堆 CUDA C++文件到像 Tensorflow 和 Caffe 这样的易用框架，配备了像 UNet 或 SSD 这样的强大架构。也有很多来自不同领域的免费数据集，如标志识别或图像字幕。现在每个人都可以建立和训练自己的模型。此时此地有这么多东西——还会出什么差错呢？Cooking data may be hard.不幸的是，有几件事你应该担心:1. 首先，你需要获得有趣的数据集。有时，这并不是一件容易的事情，因为一些链接断开了，一些数据集需要你发送请求并等待几天(或几周，或永远)。 2. 你必须小心统计和分布。如果不太了解你的数据，很容易花很多时间训练你的模型却没有结果。 3. 有时你想注释一些特定的东西，这些东西在公共数据集中还没有。例如，您可以在汽车牌照上标注实际的车牌号码或标记道路缺陷。 4. (在深度学习中)数据越多越好。将几个数据集组合在一起使训练更容易总是一个好主意。当然，您应该首先做一些预处理:例如，在一个数据集中，您只有“车辆”，而在另一个数据集中，您有“汽车”、“自行车”和“公共汽车”。重新映射类标签是必须做的事情。 5. 扩充也是一个让数据变大的好主意。是的，大多数框架都没有这个特性。在 [Deep Systems](https://deepsystems.ai) 这里，我们每天都会遇到这种困难。准备数据并不是构建模型的乐趣所在，但却非常重要，因此我们创建了一个服务来帮助解决上述所有问题(甚至更多！).在本文中，我们想向您介绍 [Supervise.ly](https://supervise.ly) ，并向您展示一个现实世界问题的例子:我们将在 Tensorflow、Keras 和名为 UNet 的有前途的架构的帮助下，在几个公开可用的数据集的组合上训练我们自己的道路分割模型。> **免责声明**:你可以跳过监督数据准备部分，自己做，但是可能会花更多的时间。# 准备城市景观Cityscapes 是一个来自 50 个城市的街道场景数据集。它有 5000 个高质量的注释帧和 30 个类，如“人行道”或“摩托车”。Cityscapes annotation example与类似数据集不同的是，Cityscapes 以多边形和点的形式提供标注，而不仅仅是大位图。## 步骤 1:下载数据集你可以在这里获得数据集[——你可能需要等一两天才能获得确认链接:数据集许可不允许分发。](https://www.cityscapes-dataset.com/downloads/)登录后，下载以下档案:`gtFine_trainvaltest.zip (241MB)`和`leftImg8bit_trainvaltest.zip (11GB)`。我们只对 Cityscapes 数据集的像素级子集感兴趣，所以您不必下载其他档案。现在，将下载的归档文件解压缩到一个文件夹中，这样您将以下面的结构结束:`gtFine`和`leftImg8bit`都包含类似`train`和`val`的文件夹，这些文件夹包含类似`aachen`的文件夹-城市。如你所见，Cityscapes 是一个大数据集。如果您愿意，可以使用整个 Cityscapes 数据集来完成本教程，但我们建议只留下几个城市:至少对于第一次尝试来说是这样。所以，最后，你应该有这样的东西:``` $ tree -d . ├── gtFine │ ├── train │ │ ├── aachen │ │ ├── bochum │ │ └── bremen │ └── val │ └── frankfurt └── leftImg8bit├── train│ ├── aachen│ ├── bochum│ └── bremen└── val└── frankfurt ```将整个目录打包到一个新的归档文件中，使用一种支持的超级导入格式:`.zip`、`.tar`或`.tar.gz`。现在我们准备向前迈进。## 第二步:注册 Supervise.ly[创建一个账户](https://app.supervise.ly/signup)——只需一分钟，完全免费。Signup page## 步骤 3:导入 Cityscapes 数据集太好了！现在你没有超级数据集——是时候创建你的第一个数据集了。你可以上传自己的图片，但现在我们将使用城市景观。打开“导入”页面，选择“开源数据集格式”选项。我们支持几个最流行的公共数据集。选择“城市景观”。在右侧，您会看到一个您必须上传的归档示例—这是我们在第一步中创建的文件。输入项目名称(对于本教程，输入“cityscapes”)并移动到最后一步:在您的计算机上选择准备好的存档并开始上传。您可以在“任务状态”页面监控进度。## 第四步:查看统计数据当你看到任务的状态是“完成”时，这意味着一切正常，你可以开始用你的图像做一些很酷的事情了。首先，我们来看看一些数字。打开你新创建的项目“cityscapes ”,进入“Statistics”页面。在这里你将会得到一些关于班级分布，人物区域和更多的信息。你可以从这里的数据中获得一些见解。例如，人们可以看到，只有 10%的图像至少有一辆公共汽车，或者电线杆多于汽车。## 步骤 5:导出数据我们不想改变数据集中的注释，所以我们可以直接跳到导出。Supervise.ly 最强大的功能之一是导出工具。它允许您使用简单的基于 JSON 的配置来建立转换管道。我们在那里支持许多有用的东西:* 图像裁剪和旋转 * 亮度和对比度校正 * 过滤掉一些数字 * 重新映射分类标签 * 分割数据集以进行训练和验证还有更多。您可以保存和传输这些配置，在不同的项目中使用它们，当然，不需要编码。为了培训 UNet，我们需要:* 将类别数量从 30 个减少到几个(例如，四个:“bg”、“车辆”、“道路”和“中性”) * 将图像调整为固定大小(例如，224x224) * 过滤掉非常小的数字(例如，小于面积的 0.15%) * 根据数据集名称(基本上按城市)拆分数据以进行训练和验证 * 用“中性”类填充背景 * 生成地面实况位图我们将使用 Supervise.ly 导出配置来完成上述所有工作。单击“导出”选项卡开始新的导出。在左侧，您可以使用 JSON 定义您的导出配置，或者通过按“添加层”按钮在 UI 中添加新的转换层。每一个改变都会更新右边，你会看到一个代表导出转换的图表。我们为本教程做了一个预定义的配置。您可以通过克隆我们的存储库来获得它:``` git clone [https://github.com/DeepSystems/supervisely-tutorials](https://github.com/DeepSystems/supervisely-tutorials) ```然后从`unet_training/src/experiment_001/config.json`文件中复制配置并将内容粘贴到左侧面板的编辑器中。你会看到类似上面截图的东西。让我解释一下这是怎么回事:你可以在[文档](https://docs.supervise.ly)中阅读更多关于导出和图层的内容。点击“开始导出”，输入本次导出的名称，Supervise.ly 将开始准备您的数据。您可以在“任务”页面上监控进度。导出完成后，您将看到“完成”状态。点击“三点”图标，然后点击“下载”。# 培训 UNet现在，您应该有一个包含理想图像的档案。让我们看一些图片。Folder “check” contains debug output with original and ground-truth images是时候训练我们的模特了。在 Github 库`supervisely-tutorials`中，我们已经做好了一切准备。解压文件夹`unet_training/data/cityscapes`中下载的档案。您将得到类似这样的结果:``` $ cd unet_training/data $ tree -d . └── cityscapes└── city2├── aachen│ └── train│ ├── check│ ├── gt│ └── orig└── frankfurt└── val├── check├── gt└── orig ```要开始训练，你需要 GPU Cuda，Tensorflow 和 libs。有可能解决所有的依赖并手动安装库或者(更好的主意！)只需构建并运行 docker 映像:``` cd unet_training/docker ./build.sh ./run.sh ```Docker 将构建包含 Tensorflow 和 GPU 支持的图像。它还会在容器内安装文件夹`src`和`data/cityscapes`。现在将 Jupyter 笔记本中的链接复制到您最喜欢的浏览器中。在上面的例子中，链接是`[http://localhost:8888/?token=48938f4268b9c230cd450fa614d33abbb0ed3f98c8c245fe](http://localhost:8888/?token=48938f4268b9c230cd450fa614d33abbb0ed3f98c8c245fe)`。导航到文件夹`experiment_001`并打开`unet_train.ipynb`。点击`Cell → Run All`运行笔记本。如果一切顺利，您将在几个时期后看到一些结果。The road is recognised (kinda). Do more epochs to get better results.经过一天的训练，你可以达到这样的效果(这里我们使用了更多的类):## 结论我们已经完成了从下载数据集到探索数据、使用 Tensorflow 和 Keras 进行导出转换和训练模型的每一步。你也可以尝试使用其他可用的道路场景数据集，像[的瞳孔数据集](https://www.mapillary.com/dataset/)——超级支持它。如果你有问题，我们很乐意帮助你。前期教程:[用 Supervisely 和 Tensorflow 进行车牌检测](https://medium.com/p/e84c74d4382c)。# 在数据科学方面培训您的员工？以下是如何选择正确的编程语言> 原文：<https://towardsdatascience.com/training-your-staff-in-data-science-heres-how-to-pick-the-right-programming-language-dda349354b18?source=collection_archive---------11----------------------->## 超越技术辩论，为您的团队获得最佳结果各个行业的企业都在投资数据科学教育项目。在科技教育公司 [Decoded](http://decoded.com) 工作时，我发现看到数据技能可以给各个领域带来巨大价值是一件令人着迷的事情——从银行和零售商，到慈善机构和政府。当着手这样一项计划时，我们的客户需要做出大量的战略决策。我们最常见的问题之一是:> "我们应该教我们的员工哪种编程语言？"数据科学社区定期讨论这个问题，快速的谷歌搜索会发现大量讨论每种语言的技术优点和优雅的博客和视频。但是从商业角度来看，决策通常取决于一系列不同的因素。这里有一个快速问答，可能会帮助你做出决定。## **问:对于数据科学或数据分析，我们的员工应该学习哪种编程语言？**Python 或者 r。这是目前最流行和最通用的两种语言。它们都是免费和开源的。每个都有数百个库，简化了转换、探索、分析和可视化数据的过程。在线数据科学社区 Kaggle 的年度调查“数据科学和机器学习的现状”提出了一个问题“工作中使用什么工具？”在[最新公布的调查结果](https://www.kaggle.com/surveys/2017)中，r 和 Python 出现在列表的顶部。76.3%的受访者使用 Python，59.2%使用 R。*(值得注意的是，接下来流行的物品并不是等价的工具。比如 SQL 是一种允许你查询数据库的语言，在数据分析的时候不会有太大帮助)。*接下来的编程语言远没有那么常用:C/C++占 19.2%，MATLAB 占 18.4%，Java 占 18.3%。所有这些语言都有自己的优点，但当涉及到学习数据科学时，它们就不那么容易理解、灵活和受支持了。## **问:好的，那么你为我们的学员推荐哪一款呢？Python 还是 R？**通常，最大的决定因素是您现有的数据科学团队是否已经偏好 Python 或 r。在一致的环境中工作有巨大的好处，因为:* 如果学习者遇到任何问题，他们可以利用现有的内部支持网络。 * 代码可以在团队之间共享和重用。 * 对于您的 IT 团队来说，白名单和安装可能会更简单。所以如果你现有的数据科学家主要用 Python，那就用 Python 吧。如果他们大部分时间都在休息，那就去休息吧## **问:如果我没有现有的数据科学团队，或者他们没有偏好，该怎么办？**Python。因为:* Python 是最流行的数据科学语言(也是发展最快的)。因此，您可以期待更好的在线学习和故障排除资源，以及支持现代数据分析常见任务的大量代码库。 * 对于 IT 团队来说，Python 通常比 R 更容易管理(例如[花旗风险投资刚刚投资了一个流行的 Python 数据科学平台 Anaconda](https://www.anaconda.com/blog/company-blog/anaconda-funded-citi-ventures/) )。 * Python 在数据科学之外的环境中也很流行(例如 web 开发)。这意味着学习者可以获得更广泛的教育资源，并将其应用到生活的其他领域。## **问:R 有什么优势吗？**是啊！Kaggle 的调查显示，虽然 Python 总体上更受欢迎，但 R 在统计学家中更受欢迎。r 可能是一个不错的选择，因为它是专门为统计分析而构建的。这意味着许多常见的统计工具都内置在 R 中(而 Python 更依赖于外部包)。传统上，R 也有更大范围的统计和专家可视化软件包。然而，随着 Python 越来越受欢迎，它也开始迎头赶上。如今，你在 R 中可以做的几乎任何事情都可以很容易地在 Python 中复制。好的，我想我已经做出了决定。如果事实证明我犯了一个可怕的错误呢？不要惊慌。你可能已经注意到了，Kaggle 的调查显示，76.3%的受访者使用 Python，59.2%的人使用 R——所以社区中有很大的重叠。大多数数据科学家都习惯使用这两种工具，即使他们固执地偏爱其中一种。学习任何一种语言都会使学习另一种语言变得简单得多。别忘了，除了编程本身，还有很多东西要学——从数学和统计概念，到数据管道和可视化。这两种语言都是探索这些主题的良好基础，并开始您作为数据科学家的旅程。# 基于 Kaggle 核的迁移学习和图像分类。> 原文：<https://towardsdatascience.com/transfer-learning-and-image-classification-using-keras-on-kaggle-kernels-c76d3b030649?source=collection_archive---------7----------------------->在我上一篇 [**帖子**](https://medium.com/@risingdeveloper/dog-vs-cats-detection-in-keras-beginner-super-friendly-intermediate-refreshing-expert-boring-f314872006c9) 中，我们训练了一只 **convnet** 来区分狗和猫。我们从零开始训练 convnet，得到了 80%左右的准确率。对于在非常少的数据集(4000 张图像)上训练的模型来说，这已经不错了。但是在现实世界/生产场景中，我们的模型实际上表现不佳。尽管我们建议调整一些**超参数**——历元、学习率、输入大小、网络深度、反向传播算法等——看看我们是否能提高我们的准确度。> 嗯，我试过了…事实是，在调音、重新调音、不调音之后，我的准确度不会超过 90%,在某个点上它是无用的。> 当然，有更多的数据会有助于我们的模型；但请记住，我们正在处理一个小数据集，这是深度学习领域的一个常见问题。但是唉！有一种方法…Image from pixabay> **转学走进…**但接下来你会问，什么是迁移学习？嗯，TL(迁移学习)是深度学习中常用的训练技术；其中已经为任务训练的模型被重新用作另一个模型的基础/起点。为了训练一个图像分类器，使其在图像分类上达到接近或超过人类水平的精度，我们需要大量的数据、强大的计算能力和大量的时间。这一点我相信我们大多数人都没有。知道这对于资源很少或没有资源的人来说是一个问题，一些聪明的研究人员建立了模型，在大型图像数据集上进行训练，如[**【ImageNet】**](http://www.image-net.org/)[**COCO**](http://cocodataset.org/)[**Open Images**](https://github.com/openimages/dataset)，并决定将他们的模型分享给公众以供重用。Image from [**Marvel comics**](https://www.google.com.ng/url?sa=i&source=images&cd=&cad=rja&uact=8&ved=0ahUKEwjQ2fmX3LPeAhWkAsAKHQVdDhcQMwhqKAAwAA&url=http%3A%2F%2Fmarvelcinematicuniverse.wikia.com%2Fwiki%2FThanos&psig=AOvVaw0B8RoTQmwXOotpH8y4U-DZ&ust=1541179772078051&ictx=3&uact=3)这意味着你再也不用从头开始训练图像分类器了，除非你有一个非常非常大的不同于上面的数据集，或者你想成为一个**英雄或者 thanos。**我知道你有疑问，比如…* 迁移学习为什么有效？井转移学习对图像分类问题有效，因为神经网络以越来越复杂的方式学习。也就是说，你在网络中走得越深，学到的图像特定特征就越多。**A neural network learns to detect objects in increasing level of complexity** | Image source: cnnetss.com让我们建立一些直觉来更好地理解这一点。在一个试图检测人脸的神经网络中，我们注意到网络学习检测第一层中的边缘，第二层中的一些基本形状以及随着深入的复杂特征。因此，这里的想法是，所有的图像都有形状和边缘，只有当我们开始提取更高层次的特征时，我们才能识别它们之间的差异，比如说脸上的鼻子或汽车的轮胎。只有这样我们才能说，好吧；这是一个人，因为它有鼻子，这是一辆汽车，因为它有轮胎。这里的要点是，神经网络的早期层将总是检测汽车和人的图片中存在的相同的基本形状和边缘。现在，将这种直觉用于我们区分狗和猫的问题，这意味着我们可以使用在包含不同类型动物的庞大数据集上训练过的模型。 这很有效，因为这些模型已经学会了动物的基本形状和结构，因此我们需要做的就是教会它(模型)我们新图像的高级特征。我想说的是，我们需要一个已经在大型图像数据集上训练过的网络，如 **ImageNet** (包含大约 140 万张标记图像和 1000 个不同类别，包括动物和日常物品)。 既然这个模型已经知道如何对不同的动物进行分类，那么我们可以利用这些现有的知识快速训练一个新的分类器来识别我们的特定类别(猫和狗)。> 我的意思是一个会煮鸡蛋的人应该知道如何煮水，对吗？既然我们对什么是迁移学习有了理解/直觉，我们就来谈谈**预训练**网络。**预训练**网络有不同的变体，每种都有自己的架构、速度、大小、优点和缺点。**Keras** 预装了许多类型的这些**预训练**模型。其中一些是:* **VGGNET**:Simon Yan 和 Zisserman 在他们 2014 年的论文 [*中介绍了用于大规模图像识别的超深度卷积网络*](https://arxiv.org/abs/1409.1556) 。 * **RESNET** :由何等人在 2015 年的论文 [*中首次提出，用于图像识别的深度残差学习*](https://arxiv.org/abs/1512.03385) * **INCEPTION**:“INCEPTION”微体系结构是由 Szegedy 等人在他们 2014 年的论文 [*中首次提出的，该论文名为“用卷积进行深入研究*](https://arxiv.org/abs/1409.4842) : * 例外(XCEPTION):例外是由 **Keras** 图书馆的创建者[弗朗索瓦·乔莱](https://twitter.com/fchollet)提出的。还有很多。其中一些架构的详细解释可以在 [**这里**](https://www.pyimagesearch.com/2017/03/20/imagenet-vggnet-resnet-inception-xception-keras/) **找到。**我们将在本教程中使用 **InceptionResNetV2** ，请随意尝试其他模型。InceptionResNetV2 model | Image source: [researchgate](https://www.researchgate.net/figure/Schematic-diagram-of-InceptionResNetV2-model-compressed-view_fig9_326421398)**InceptionResNetV2** 是来自 **INCEPTION** 系列的最新架构。它确实工作得很好，并且由于许多原因超级快，但是为了简洁起见，我们将留下细节并坚持在这篇文章中使用它。如果你对**盗梦空间**模式如何运作的细节感兴趣，那么就去 [**这里**](https://medium.com/@sh.tsang/review-inception-v3-1st-runner-up-image-classification-in-ilsvrc-2015-17915421f77c) **。**> 不那么简单的介绍结束后，让我们开始实际的编码。我们将使用第一个笔记本中几乎相同的代码，不同之处非常简单明了，因为 Keras 使调用预训练模型变得很容易。Fork your previous notebook on kaggle如果你遵循了我之前的 [**帖子**](/image-detection-from-scratch-in-keras-f314872006c9) 并且已经在 [**kaggle**](http://kaggle.com/) 上有了内核，那么简单地分叉你的笔记本创建一个新版本。我们将编辑这个版本。将为您创建上一个笔记本的分支，如下所示The new version opens like this.1. 关闭设置栏，因为我们的 GPU 已经被激活。请确认您的 GPU 已打开，因为这可能会极大地影响培训时间。 2. 取消提交消息。暂时不要提交您的工作，因为我们还没有做出任何更改。现在，从头开始一个接一个地运行代码块，直到到达我们创建 **Keras** 模型的单元格，如下所示。Keras model block点击箭头指向上方的 **+按钮**，在当前代码单元格的基础上创建一个新的代码单元格。empty code cell created> 现在，让我们称我们的预训练模型为…1. 这里我们导入 **InceptionResNetV2** 模型。 2. 这里，我们告诉 **keras** 下载模型的**预训练的**权重，并保存在变量**conv _ 基地中。** 为了配置我们实际下载的内容，我们传入一些重要的参数，例如: 3. *权重* [ **imagenet** ]:我们告诉 keras 获取在 **imagenet** 数据集上训练的 InceptionReNetV2。 4. *include _ top*[**False**]:这告诉 **Keras** 不要下载预训练模型的完全连接层。这是因为顶层(完全连接的层)进行最终分类。即在卷积层从输入图像中提取边缘、斑点或线条等基本特征后，全连接层将它们分类。由于我们只需要两个类(狗和猫)分类器，我们将删除前者并添加我们自己的分类器。**Removing the top classifier and adding our own**. Image source: [Deep Learning with Python](https://www.amazon.com/Deep-Learning-Python-Francois-Chollet/dp/1617294438) by Francois Chollet5.这里我们指定我们的输入维度。点击 **shift+Enter** 运行代码块。This error appears when your internet on kaggle is blocked.如果您在运行代码时遇到这个错误，那么您在 Kaggle 内核上的互联网访问被阻止了。要激活它，打开您的设置菜单，向下滚动并点击**互联网**并选择 ***互联网连接。*** 你的内核自动刷新。因此，您必须从头开始再次运行每个单元格，直到到达当前单元格。重新运行代码从 [**github**](https://github.com/fchollet/deep-learning-models) 上的 **keras** 库下载预训练的模型。Downloading our pretrained model from github我们可以给。 ***summary( )*** 我们下载的模型上的函数可以看到它的架构和参数个数。 你注意到一个令人欢呼的 5400 万 plus 参数。这是巨大的，我们肯定不能从头开始训练它。但是由于迁移学习，我们可以简单地重复使用它而无需培训。接下来，我们创建完全连接的层(分类器),并将其添加到我们下载的模型之上。这是我们要训练的分类器。即在将 **InceptionResNetV2** 连接到我们的分类器后，我们将告诉 keras 只训练我们的分类器，并冻结 **InceptionResNetV2** 模型。1. 我们从 keras 导入层和模型。 2. 我们创建一个序列模型。 3. **重要的**！别担心，我没有尖叫…这里我们将我们的**conv _ 基地(** InceptionResNetV2)添加到模型中。 4. 这里，我们展平来自**conv _ 基地**的输出，因为我们想把它传递给我们完全连接的层(分类器)。 5. 为了简单起见，我添加了一个输出为 256 ( **号不固定**)的**密集**网络，并使用了我们在我上一篇 [**帖子**](https://medium.com/@risingdeveloper/dog-vs-cats-detection-in-keras-beginner-super-friendly-intermediate-refreshing-expert-boring-f314872006c9) **中谈到的流行的 **ReLU** 激活。** 6. 我们像上次一样用一个**s 形**做最后一层。 7. 最后一层只有一个输出。(职业概率)见我上一篇 [**帖子**](https://medium.com/@risingdeveloper/dog-vs-cats-detection-in-keras-beginner-super-friendly-intermediate-refreshing-expert-boring-f314872006c9) 了解更多澄清。> 按住 **Shift+Enter** 运行您的代码。接下来，让我们预览一下我们的架构:Full model summary我们可以看到，我们的参数从大约 5400 万增加到将近 5800 万，这意味着我们的分类器有大约 300 万个参数。现在我们要冻结 conv 的**基地，只训练我们自己的。**Freeze!1. 我们在冻结**conv _ base(***492***)之前打印模型中的重量数。** 2. 在这里，我们将**conv _ 基地**图层的 ***可训练*** 属性设置为 False(我们不想训练你)。 3. 打印冻结 **conv_base 后的重量数(** *下降到刚好 4 个* **)。**几乎完成，只是一些小的变化，我们可以开始训练我们的模型。第一个小小的改变是将我们的学习率从我们上一款中的**0.0001(*1****e-5***)**略微提高到**0.0002(***2e-5***)。**经过一些试验后，我决定使用 **0.0002** ，它工作起来更好一些**。(**你可以*做*这里再调一些 **)**Increase the learning rate slightly接下来，运行**模型下的所有单元格。*编译*** 块，直到到达我们在模型上称之为 **fit** 的单元格。这里我们将改变最后一个参数，即**纪元**大小。我们将时段大小减少到 **20** 。当我们稍后绘制精度和损耗图时，其原因会更清楚。 **注:**我尝试了不同的数字后决定用 20。这就是深度学习中我们所说的 ***超参数*** 调优。# 终于，开始训练的时间到了。# 运行你的代码，去喝杯水。不，不是咖啡！水，因为水是生命。嗯，我还没来得及喝水，我的模特就训练完了。所以我们来评价一下它的性能。> 展示迁移学习力量的图片。We reach an accuracy of about 96% in just 20 epochs我们清楚地看到，在仅仅 20 个时期内，我们已经达到了大约 96%的准确度。超级快速准确。如果 ***狗 vs 猫*** 的比赛没有结束，我们用这个模型预测，我们就算不是第一，也一定会名列前茅。 请记住，我们仅使用了 25，000 张图片中的 4000 张。当我们使用所有 25000 幅图像结合我们刚刚学习的技术(迁移学习)进行训练时，会发生什么？A wise man thinking… Image source [**Pixabay**](https://pixabay.com/en/people-wisdom-wise-man-person-882078/)> 嗯，一位非常聪明的科学家曾经说过…> 拥有足够数据的不太花哨的算法肯定会比拥有少量数据的花哨算法做得更好。事实证明这是真的！好了，我们已经讨论了一段时间的数字，让我们来看一些图像…在不更改打印代码的情况下，运行单元块以绘制一些精度和损耗图。我们得到了下面这些图…那么我们能从这个情节中读到什么呢？我们可以清楚地看到，我们的验证准确性甚至从一开始就表现良好，然后在几个时期后就稳定下来了。现在你知道我为什么把我的纪元大小从 64 减少到 20 了。最后，我们来看一些预测。我们将使用相同的预测代码。只需运行代码块。> **运行我的后，我得到了 10 张图像的预测，如下所示…**Predictions for ten Images from our test set> 我们的分类器得到了满分 10 分。很好很简单，对吧？嗯，就是这样。这就是我停止打字的地方，让你去驾驭迁移学习的力量。所以，编码快乐…[**在 Kaggle **上链接到本笔记本****](https://www.kaggle.com/risingdeveloper/transfer-learning-in-keras-on-dogs-vs-cats) 。[**链接到本笔记本**](https://github.com/risenW/medium_tutorial_notebooks/blob/master/transfer-learning-in-keras-on-dogs-vs-cats.ipynb) 上的 Github **。**我引用了一些令人惊叹的帖子和文章。* [用于视觉识别的 CS231n 卷积神经网络](http://cs231n.github.io/)。 * Keras 的创建者 Francois Chollet 用 python 进行深度学习。 * [协进化神经网络基础知识](https://pythonprogramming.net/convolutional-neural-network-cnn-machine-learning-tutorial/)。 * [一个关于迁移学习的很棒的媒体帖子](https://medium.com/@14prakash/transfer-learning-using-keras-d804b2e04ef8)。 * [又一个关于盗梦空间模型的媒体帖子](/review-inception-v4-evolved-from-googlenet-merged-with-resnet-idea-image-classification-5e8c339d18bc)。 * [一种温和的迁移学习方法](https://machinelearningmastery.com/transfer-learning-for-deep-learning/)。> 欢迎提问、评论和投稿。> 在 [**twitter**](https://twitter.com/risingodegua) **上和我联系。** > > 在[**insta gram**](https://www.instagram.com/rising_developer/)**上跟我连线。**# 基于 Keras 的图像分类迁移学习> 原文：<https://towardsdatascience.com/transfer-learning-for-image-classification-using-keras-c47ccf09c8c8?source=collection_archive---------4----------------------->## 用几个简单的步骤训练一个图像分类器> 我为学习者写了一份名为《强大的知识》的时事通讯。每一期都包含链接和最佳内容的关键课程，包括引文、书籍、文章、播客和视频。每一个人都是为了学习如何过上更明智、更快乐、更充实的生活而被挑选出来的。 [**在这里报名**](https://mighty-knowledge.ck.page/b2d4518f88) 。在本教程中，您将学习如何为图像分类任务进行迁移学习。Keras 的高级 API 使这变得非常容易，只需要几个简单的步骤。迁移学习允许我们使用比我们从头开始训练时少得多的数据来训练深度网络。通过转移学习，我们实际上是*将模型从之前的任务中学到的“知识”转移到我们当前的任务中。这个想法是，这两个任务并不是完全分离的，因此我们可以利用模型通过大量训练学习到的任何网络参数，而不必自己进行训练。*迁移学习一直被证明可以提高模型准确性并减少所需的训练时间。更少的数据，更少的时间，更高的准确性。# 装东西我们要做的第一件事是准备我们的数据。对于 Keras 中的影像分类，最简单的方法是将您的数据分成每个类别的文件夹。例如，如果你的数据集有 3 个类:Pizza、Burger 和 Taco，那么你应该有 3 个名为 Pizza、Burger 和 Taco 的文件夹。你的每个文件夹都应该包含该特定类别的图像。您的文件夹结构应该如下所示:``` food_dataset ---> Pizza -------> p_1.jpg -------> p_2.jpg -------> p_3.jpg -------> .... ---> Burger -------> b_1.jpg -------> b_2.jpg -------> b_3.jpg -------> .... ---> Taco -------> .... ```接下来，我们可以选择要对其执行迁移学习的模型。Keras 为此提供了许多选项。在进行选择时，您可以大致相信(出于我们的目的)较小的模型(以 MB 为单位)会更快但不太准确，而较大的模型会更慢但更准确。截至今天的文章，MobileNet 是最快的，NASNetLarge 是最准确的。我们今天将选择 ResNet50 型号，它位于光谱的中间。查看下面的代码。我们从导入必要的模型和预处理函数开始。ResNet50 模型使用一些非常特殊的预处理进行训练，我们希望重用这些预处理，以便正确地重新训练它。请注意，当我们初始化基本模型时，我们是如何设置`include_top=False`的。这个设置很重要，因为这意味着我们**不会**在模型的末尾保留全连接(FC)层。这正是我们想要的，因为我们要为迁移学习训练我们自己的*全新的* FC 层。# 流动数据现在我们需要创建一个数据生成器，以自动的方式从我们的文件夹中获取数据并放入 Keras。为此，Keras 提供了方便的 python 生成器函数。我们定义了名为“food_dataset”的训练目录，其中包含我们之前设置的每类图像的文件夹。我们还定义了图像尺寸和批量大小；Keras 生成器将使用双线性插值法自动将所有加载的图像调整到`target_size`的大小。我们将向生成器添加一些额外的数据增强，翻转和旋转，以尝试提高我们模型的准确性。我们使用`flow_from_directory`函数创建我们的最终生成器，它将使用一个队列来保持加载和准备图像的连续流！# 弹出图层是时候建立我们迁移学习的最终模型了。如果将来要再次使用它，您可能会发现为此编写一个函数非常方便。下面有一个你可以从它开始。我们从冻结基本模型的所有层开始。我们不想训练这些层，因为我们试图利用网络从以前的数据集(在这种情况下是 ImageNet)中学习的知识。通过设置`layer.trainable=False`，我们告诉 Keras *而不是*在训练期间更新那些权重，这正是我们想要的！现在，我们可以添加 FC 层。我们在一个循环中这样做，因为许多网络有多个 FC 层，循环通过一个列表使事情变得简单明了。我们还将在每个 FC 层中添加一些 dropout，以减少过度拟合的机会(这部分是可选的)。最后，我们加上最终的 Softmax 层，建立 Keras 模型。一旦我们的功能都设置好了，创建最终模型就变得非常简单了。只需忽略 softmax 层的类的数量、列表中 FC 层的大小(因为我们对它进行了循环)和丢失概率。# 训练它最后一步是设置我们的训练，并点击大红色按钮，使所有运行！我们将使用 Adam 优化器，它的学习率值很小。我们选择 Adam 是因为它比 SGD 更快更容易使用。我们将学习率设置得很小，因为我们在这里只是微调我们的模型，特别是 FC 层；我们不寻求任何大的改变，只是微调。我们还将设置一些检查点，为以后保存权重。应用`fit_generator`函数运行整个训练团，可选择时期数、批量大小和数据混排。一旦训练全部完成，我们可以使用`history`输出来绘制我们的训练结果。瞧，转移学习！# 喜欢学习？在[推特](https://twitter.com/GeorgeSeif94)上关注我，我会在那里发布所有最新最棒的人工智能、技术和科学！也在 [LinkedIn](https://www.linkedin.com/in/georgeseif/) 上和我联系吧！# 从预先训练的模型中转移学习> 原文：<https://towardsdatascience.com/transfer-learning-from-pre-trained-models-f2393f124751?source=collection_archive---------0-----------------------># 如何快速简单地解决任何图像分类问题*本文教你如何利用迁移学习解决图像分类问题。为了演示的目的，给出了一个使用 Keras 及其预训练模型的实例。*The beauty of code by [Chris Ried](https://unsplash.com/photos/ieic5Tq8YMk?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/search/photos/programming-python?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)**深度学习**正在迅速成为人工智能应用的关键工具(LeCun et al. 2015)。例如，在计算机视觉、自然语言处理和语音识别等领域，深度学习已经产生了显著的成果。因此，对深度学习的兴趣越来越大。深度学习擅长的问题之一是**图像分类** (Rawat & Wang 2017)。图像分类的目标是根据一组可能的类别对特定图片进行分类。图像分类的一个经典例子是在一组图片中识别猫和狗(例如[狗对猫 Kaggle 比赛](https://www.kaggle.com/c/dogs-vs-cats))。从深度学习的角度来看，图像分类问题可以通过**迁移学习**来解决。实际上，图像分类中的几个最先进的结果都是基于迁移学习解决方案(Krizhevsky 等人 2012，Simonyan & Zisserman 2014，he 等人 2016)。潘&杨(2010)对迁移学习进行了全面综述。**本文展示了如何针对图像分类问题实现迁移学习解决方案。**本文提出的实现基于 Keras (Chollet 2015)，它使用编程语言 Python。按照这个实现，您将能够快速而轻松地解决任何图像分类问题。这篇文章是按以下方式组织的:1. 迁移学习 2. 卷积神经网络 3. 重新利用预先训练的模型 4. 迁移学习过程 5. 深度卷积神经网络上的分类器 6. 例子 7. 摘要 8. 参考# 1.迁移学习迁移学习是计算机视觉中一种流行的方法，因为它允许我们以省时的方式**建立精确的模型** (Rawat & Wang 2017)。使用迁移学习，你不是从零开始学习过程，而是从解决一个不同的问题时已经学到的模式开始。这样你可以利用以前的经验，避免从头开始。就当是深度学习版的[沙特尔](https://en.wikipedia.org/wiki/Standing_on_the_shoulders_of_giants)‘表情’站在巨人的肩膀上。在计算机视觉中，迁移学习通常通过使用**预训练模型**来表达。预训练模型是在大型基准数据集上训练的模型，用于解决与我们想要解决的问题类似的问题。因此，由于训练这种模型的计算成本，通常的做法是从出版的文献(例如，， [Inception](https://arxiv.org/pdf/1512.00567.pdf) ， [MobileNet](https://arxiv.org/pdf/1704.04861.pdf) )中导入和使用模型。Canziani 等人(2016 年)使用 ImageNet (Deng 等人，2009 年)挑战赛中的数据，对预训练模型在计算机视觉问题上的表现进行了全面综述。# 2.卷积神经网络迁移学习中使用的几个预训练模型都是基于大型**卷积神经网络****(CNN)**(Voulodimos et al . 2018)。总的来说，CNN 在广泛的计算机视觉任务中表现出色(Bengio 2009)。它的高性能和易于训练是过去几年来推动 CNN 流行的两个主要因素。典型的 CNN 有两部分:1. **卷积基**，由一堆卷积层和池层组成。卷积库的主要目标是从图像中生成特征。关于卷积层和池层的直观解释，请参考 Chollet (2017)。 2. **分类器**，通常由全连接层组成。分类器的主要目标是基于检测到的特征对图像进行分类。全连接层是其神经元与前一层中的所有激活具有全连接的层。图 1 显示了一个基于 CNN 的模型的**架构。请注意，这是一个简化版本，符合本文的目的。事实上，这种模型的架构比我们在这里提出的要复杂得多。**Figure 1\. Architecture of a model based on CNN.这些深度学习模型的一个重要方面是，它们可以自动学习**层次特征表示**。这意味着第一层计算的要素是通用的，可以在不同的问题域中重复使用，而最后一层计算的要素是特定的，取决于所选的数据集和任务。根据 Yosinski et al. (2014)，'*如果第一层特征是一般的，而最后一层特征是特定的，那么在网络的某个地方肯定有从一般到特定的过渡'*。因此，我们的 CNN 的卷积基(尤其是其较低层(那些更接近输入的层))指的是一般特征，而分类器部分以及卷积基的一些较高层指的是专门特征。# 3.重新利用预先训练的模型当您根据自己的需要重新调整预训练模型的用途时，您首先要删除原始的分类器，然后添加一个符合您的目的的新分类器，最后您必须根据三种策略之一对您的模型进行**微调:**1. **训练整个模型。**在这种情况下，您使用预训练模型的架构，并根据您的数据集对其进行训练。您正在从头开始学习模型，因此您将需要一个大的数据集(和强大的计算能力)。 2. 训练一些层，让其他层保持冷冻。如您所知，较低层指的是一般特性(与问题无关)，而较高层指的是特定特性(与问题相关)。这里，我们通过选择我们想要调整网络权重的程度(一个冻结的层在训练期间不会改变)来处理这种二分法。通常，如果你有一个小的数据集和大量的参数，你会保持更多的层冻结，以避免过度拟合。相比之下，如果数据集很大而参数数量很少，则可以通过为新任务训练更多的层来改进模型，因为过度拟合不是问题。 3. **冻结卷积基数。**这种情况对应于训练/冻结权衡的极端情况。主要思想是保持卷积基的原始形式，然后使用其输出来馈送分类器。您正在使用预训练模型作为固定的特征提取机制，这在您计算能力不足、数据集较小和/或预训练模型解决的问题与您想要解决的问题非常相似的情况下非常有用。图 2 以示意图的方式展示了这三种策略。Figure 2\. Fine-tuning strategies.与**策略 3** 的应用**简单明了**不同，**策略 1** 和**策略 2** 要求你**小心**卷积部分使用的学习速率。学习率是一个超参数，它控制着你调整网络权重的程度。当您使用基于 CNN 的预训练模型时，使用小的学习率是明智的，因为高学习率会增加丢失先前知识的风险。假设预训练模型已经被很好地训练，这是一个公平的假设，保持小的学习率将确保你不会过早和过多地扭曲 CNN 权重。# 4.迁移学习过程从实践的角度来看，整个迁移学习过程可以总结如下:1. **选择预先训练好的模型**。从大量可用的预训练模型中，您可以选择一个看起来适合您的问题的模型。例如，如果您正在使用 Keras，您可以立即访问一组模型，如(Simonyan & Zisserman 2014)、InceptionV3 (Szegedy 等人 2015)和 ResNet5(何等人 2015)。[在这里](https://keras.io/applications/)你可以看到 Keras 上所有的车型。 2. **根据规模-相似度矩阵对你的问题进行分类。**在图 3 中，你有一个“矩阵”来控制你的选择。该矩阵根据数据集的大小及其与训练预训练模型的数据集的相似性，对您的计算机视觉问题进行分类。根据经验，如果每个类的图像少于 1000 幅，则认为数据集很小。关于数据集相似性，让常识占上风。例如，如果您的任务是识别猫和狗，ImageNet 将是一个类似的数据集，因为它有猫和狗的图像。然而，如果你的任务是识别癌细胞，ImageNet 就不能被认为是一个类似的数据集。 3. **微调你的模型。**在这里，您可以使用大小-相似性矩阵来指导您的选择，然后参考我们之前提到的关于重新调整预训练模型用途的三个选项。图 4 提供了以下文本的可视化摘要。* **象限 1** 。大型数据集，但不同于预训练模型的数据集。这种情况会把你引向*策略 1* 。因为你有一个大的数据集，你可以从头开始训练一个模型，做任何你想做的事情。尽管数据集不同，但在实践中，使用预训练模型的架构和权重从预训练模型初始化模型仍然是有用的。 * **象限 2。**大型数据集，类似于预训练模型的数据集。你现在在啦啦世界。任何选择都可行。可能，最有效的选择是*策略 2* 。由于我们有一个大的数据集，过度拟合应该不是问题，所以我们可以想学多少就学多少。然而，由于数据集是相似的，我们可以通过利用以前的知识来节省大量的训练工作。因此，训练分类器和卷积基的顶层应该足够了。 * **第三象限。**小数据集，与预训练模型的数据集不同。这是计算机视觉问题的第 2-7 手脱衣牌。一切都和你作对。如果抱怨不是一个选项，你唯一的希望就是策略 2。很难在训练和冷冻的层数之间找到平衡。如果你深入研究，你的模型可能会过拟合，如果你停留在模型的浅层，你将不会学到任何有用的东西。很可能，您需要比象限 2 更深入，并且您需要考虑数据扩充技术(这里[提供了关于数据扩充技术的很好的总结](https://medium.com/nanonets/how-to-use-deep-learning-when-you-have-limited-data-part-2-data-augmentation-c26971dc8ced))。 * **象限 4。**小数据集，但类似于预训练模型的数据集。我向尤达大师询问过这个问题，他告诉我‘*是最好的选择，策略 3 应该是*’。我不知道你怎么想，但我不会低估原力。相应地，转到*策略 3* 。你只需要去掉最后一个全连接层(输出层)，把预训练好的模型作为固定特征提取器运行，然后用得到的特征训练一个新的分类器。Figures 3 and 4\. Size-Similarity matrix (left) and decision map for fine-tuning pre-trained models (right).# 5.深度卷积神经网络上的分类器如前所述，基于预训练卷积神经网络的迁移学习方法**产生的**图像分类模型**通常由**两部分**组成:**1. **卷积基**，进行特征提取。 2. **分类器**，根据卷积基提取的特征对输入图像进行分类。因为在这一节中我们关注分类器部分，所以我们必须首先说明可以遵循不同的方法来构建分类器。一些最受欢迎的是:1. **完全连接的层。**对于图像分类问题，标准方法是使用一堆完全连接的层，然后是 softmax 激活层(Krizhevsky 等人 2012 年，Simonyan & Zisserman 2014 年，泽勒& Fergus 2014 年)。softmax 层输出每个可能类别标签上的概率分布，然后我们只需要根据最可能的类别对图像进行分类。 2. **全球平均统筹。**林等人(2013 年)提出了一种基于全球平均池的不同方法。在这种方法中，我们没有在卷积基础之上添加完全连接的层，而是添加了一个全局平均池层，并将其输出直接馈入 softmax 激活层。Lin 等人(2013 年)详细讨论了这种方法的优缺点。 3. **线性支持向量机。**线性支持向量机(SVM)是另一种可能的方法。根据唐(2013)，我们可以通过在卷积基提取的特征上训练线性 SVM 分类器来提高分类精度。关于 SVM 方法的优点和缺点的更多细节可以在该文件中找到。# 6.例子在这个例子中，我们将看到**如何在图像分类的迁移学习解决方案中实现这些分类器**。根据 Rawat 和 Wang (2017)，'*在深度卷积神经网络上比较不同分类器的性能仍需要进一步研究，因此成为一个有趣的研究方向*。因此，看看每个分类器在标准图像分类问题中的表现会很有趣。你可以在我的 GitHub 页面上找到这个例子的完整代码。## 6.1.准备数据在本例中，我们将使用原始数据集的较小版本。这将允许我们更快地运行模型，这对于计算能力有限的人(像我一样)来说是非常好的。为了构建更小版本的数据集，我们可以修改 Chollet (2017)提供的代码，如代码 1 所示。Code 1\. Create a smaller dataset for Dogs vs. Cats.## 6.2.从卷积基中提取特征卷积基底将用于提取特征。这些特征将提供给我们想要训练的分类器，以便我们可以识别图像中是否有狗或猫。再次改编 Chollet (2017)提供的代码。代码 2 显示了所使用的代码。Code 2\. Extract features from convolutional base.## 6.3.分类器## 6.3.1.完全连接的层我们提出的第一个解决方案基于完全连接的层。这个分类器添加了一个全连接层的堆栈，该堆栈由从卷积基提取的特征提供。为了保持简单(和快速)，我们将使用 Chollet (2018)提出的解决方案，稍加修改。特别是，我们将使用 Adam 优化器而不是 RMSProp，因为 [Stanford 是这么说的](http://cs231n.github.io/neural-networks-3/#adam)(多么美妙的 *argumentum ad verecundiam* )。代码 3 显示了所使用的代码，而图 5 和图 6 显示了学习曲线。Code 3\. Fully connected layers solution.Figure 5\. Accuracy of the fully connected layers solution.Figure 6\. Loss of the fully connected layers solution.**成绩简述:**1. 验证精度约为 0.85，考虑到数据集的规模，这是令人鼓舞的。 2. 该模型严重过度拟合。训练曲线和验证曲线之间有很大的差距。 3. 由于我们已经使用了 dropout，我们应该增加数据集的大小来改善结果。## 6.3.2.全球平均池这种情况与前一种情况的区别在于，我们将添加一个全局平均池层，并将其输出馈送到 sigmoid 激活层，而不是添加一个完全连接的层堆栈。请注意，我们讨论的是 sigmoid 激活层，而不是 softmax 激活层，后者是 Lin 等人(2013)推荐的。我们改为 sigmoid 激活，因为在 Keras 中，要执行二进制分类，您应该使用 *sigmoid* 激活和 *binary_crossentropy* 作为损失(Chollet 2017)。因此，有必要对林等人(2013)的原始提案进行这一小小的修改。代码 4 显示了构建分类器的代码。图 7 和图 8 显示了最终的学习曲线。Code 4\. Global average pooling solution.Figure 7\. Accuracy of the global average pooling solution.Figure 8\. Loss of the global average pooling solution.**结果简述:**1. 验证精度与全连接图层解决方案的结果相似。 2. 该模型不会像前一种情况那样过度拟合。 3. 当模型停止训练时，损失函数仍在减小。或许，可以通过增加历元数来改进模型。## 6.3.3 线性支持向量机在这种情况下，我们将在卷积基提取的特征上训练线性支持向量机(SVM)分类器。为了训练这个分类器，传统的机器学习方法是优选的。因此，我们将使用 k-fold 交叉验证来估计分类器的误差。由于将使用 k-fold 交叉验证，我们可以连接训练集和验证集以扩大我们的训练数据(我们保持测试集不变，就像我们在前面的案例中所做的那样)。代码 5 显示了数据是如何连接的。Code 5\. Data concatenation.最后，我们必须知道 SVM 分类器有一个超参数。这个超参数是误差项的惩罚参数 C。为了优化这个超参数的选择，我们将使用穷举网格搜索。代码 6 展示了用于构建这个分类器的代码，而图 9 展示了学习曲线。Code 6\. Linear SVM solution.Figure 9\. Accuracy of the linear SVM solution.**结果的简要讨论:**1. 模型的精度约为 0.86，与之前解决方案的精度相似。 2. 过度合身指日可待。而且训练精度总是 1.0，这是不常见的，可以解释为过拟合的标志。 3. 模型的准确性应该随着训练样本的数量而增加。然而，那似乎不会发生。这可能是由于过度拟合。当数据集增加时，观察模型如何反应会很有趣。# 7.摘要在本文中，我们:* 介绍了迁移学习、卷积神经网络和预训练模型的概念。 * 定义了基本的微调策略，以重新调整预训练模型的用途。 * 描述了一种基于数据集的大小和相似性来决定应该使用哪种微调策略的结构化方法。 * 介绍了三种不同的分类器，它们可以用在从卷积基提取的特征之上。 * 为本文中的三个分类器提供了一个端到端的图像分类示例。我希望你有动力开始开发关于计算机视觉的深度学习项目。这是一个伟大的研究领域，每天都有令人兴奋的新发现出现。我很乐意帮助你，所以如果你有任何问题或改进建议，请告诉我！# 8.参考1.纽约州本吉奥市，2009 年。学习人工智能的深度架构。机器学习的基础和趋势，2(1)，第 1–127 页。2.Canziani，a .，Paszke，a .和 Culurciello，e .，2016 年。面向实际应用的深度神经网络模型分析。arXiv 预印本 arXiv:1605.07678。[3。Chollet，2015。喀拉斯。](https://keras.io/)4.[乔莱，女，2017。用 python 进行深度学习。曼宁出版公司..](https://amzn.to/2CeEySF)5.邓军，董文伟，索契，李，李力军，李，，李，2009 年 6 月。Imagenet:一个大规模分层图像数据库。计算机视觉和模式识别，2009。CVPR 2009。IEEE 关于(第 248–255 页)的会议。Ieee。6.何刚，张，徐，任，孙，2016。用于图像识别的深度残差学习。IEEE 计算机视觉和模式识别会议论文集(第 770-778 页)。7.Krizhevsky，a .，Sutskever，I .和 Hinton，G.E .，2012 年。基于深度卷积神经网络的图像网分类。神经信息处理系统进展(第 1097-1105 页)。8.LeCun、y . beng io 和 and Hinton，2015 年。深度学习。自然，521(7553)，第 436 页9.2013 年，林，硕士，陈，秦，严。网络中的网络。arXiv 预印本 arXiv:1312.4400。10.潘世杰和杨，2010。迁移学习研究综述。IEEE 知识与数据工程汇刊，22(10)，第 1345–1359 页。11.Rawat，w .和王，z .，2017 年。用于图像分类的深度卷积神经网络:综述。神经计算，第 29 卷第 9 期，第 2352–2449 页。12.Simonyan，k .和 Zisserman，a .，2014 年。用于大规模图像识别的非常深的卷积网络。arXiv 预印本 arXiv:1409.1556。13.Szegedy，c .，Vanhoucke，v .，Ioffe，s .，Shlens，j .和 Wojna，z .，2016 年。重新思考计算机视觉的初始架构。IEEE 计算机视觉和模式识别会议论文集(第 2818-2826 页)。14.唐，2013 年。使用线性支持向量机的深度学习。arXiv 预印本 arXiv:1306.0239。15.Voulodimos，a .，Doulamis，n .，Doulamis，a .和 Protopapadakis，e .，2018。计算机视觉的深度学习:简要综述。计算智能与神经科学，2018。16.约辛斯基、克鲁内、本吉奥和利普森，2014 年。深度神经网络中的特征有多大的可转移性？。神经信息处理系统进展(第 3320-3328 页)。17.泽勒医学博士和弗格斯研究中心，2014 年 9 月。可视化和理解卷积网络。在欧洲计算机视觉会议上(第 818-833 页)。斯普林格，查姆。# 感谢感谢[若昂·科埃略](https://www.linkedin.com/in/joaopcoelho/)阅读本文的草稿。***想了解更多？*** *我正在为那些想学习 Python 中机器学习基础知识的人建立一个互动的、基于群组的 5 周课程，并且不再怀疑他们是否能够在这个领域开始职业生涯。请* [*填写这份简短的调查问卷*](https://tinyurl.com/learn-machine-learning) *加入等候名单，并享受特别早到优惠。*# Tensorflow 中的迁移学习(CIFAR-10 上的 VGG19):第二部分> 原文：<https://towardsdatascience.com/transfer-learning-in-tensorflow-5d2b6ad495cb?source=collection_archive---------3----------------------->Photo by [Lacie Slezak](https://unsplash.com/@nbb_photos?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)这是 Tensorflow 中迁移学习的第二部分(CIFAR-10 上的 VGG19)。第一部分可以在这里找到[。前一篇文章已经给出了关于“迁移学习”、“模型选择”、“模型实现选择”、“知道如何创建模型”和“知道最后一层”的描述。](https://medium.com/@parkchansung/transfer-learning-in-tensorflow-9e4f7eae3bb4)简而言之，第一部分是训练和预测前的准备工作。在本文(第 2 部分)中，我将介绍如何加载预先训练的参数，如何重新缩放输入图像，如何选择批量大小，然后我们将研究结果。你可以在我的 Github 库上找到 [jupyter 笔记本。](https://github.com/deep-diver/CIFAR10-VGG19-Tensorflow)# 知道如何加载预先训练好的重量如果您从官方网站下载重量，并试图将它们加载到您自己的模型中，这将是一项艰巨的工作。这将在一个单独的故事中解释，我以后会写它。然而，如果您已经找到了一个方便的实现，那么这一步就没有必要了。事实上，几乎每个第三方实现都附带了实用函数。对于张量网，当你在 tf 上运行 pretrained()方法时。会话，它将开始下载预先训练好的参数并为您加载。这很简单。(提醒一下，logits 是 tensornets 自己创建的 VGG19 模型。VGG19())# 知道如何重新缩放原始图像(数据)以适合模型在第 1 部分中，我们看到 ImageNet 的输入图像的形状是(224，224，3)，我们准备了大小完全相同的 tf.placeholder。然而， [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) 中的图像有一个不同的形状，(32，32，3)，相当小。不同形状的图像不能输入到现有的模型中，因为矩阵乘法不起作用。相反，我们应该做的是将图像重新缩放到(224，224，3)。重新缩放的过程可以通过***skimage . transform***包来处理。***skim age . transform***包附带了[***resize***](http://scikit-image.org/docs/dev/api/skimage.transform.html#skimage.transform.resize)*方法。它有点像 ***resize(image，output_shape，…)*** 。有很多参数需要传递，但前两个是最重要的。您传递带有所需 output_shape 的原始图像，在我们的例子中是(224，224，3)，然后 ***resize*** 将返回重新缩放的图像。**在重新缩放图像之后，我们需要将它们堆叠在一个数组中，以便可以将一批图像输入到模型中。*# *批量**批量大小会受到您的设置环境和您选择的模型的影响。如第 1 部分所示，VGG16 和 VGG19 的尺寸相对较大。这意味着如果你批量分配大量的输入图像，物理内存将无法处理它。如果在 GPU 上运行，这个问题可能会更敏感，因为 GPU 通常内存较少。**就我而言，我已经在 11GB 内存的英伟达 GTX 1080Ti 上运行了培训。我已经试验过像 256 这样的大批量，并且随着时间的推移我减少了这个数量。原来我的 GPU 一次只能负担 32 的批量大小。*# *有效集内的精度测量**如果你在那里寻找一些简单的深度学习例子，你会发现他们试图评估整个有效集的准确性。但是，我发现 VGG16 和 VGG19 型号并不是这样。正如我在上一节中解释的那样，我的 GPU 一次只能处理 32 张图片，而我的有效图片集中有 5000 张图片。**因此，我决定对批处理中的有效集运行精度测量过程。*# *结果**下面的截图就是结果。我从测试集中随机抽取了 10 张图片。正如你所看到的，VGG19 模型在 CIFAR-10 图像数据集上学习得很好，即使它只有这么小的图像。***# *摘要**在结束这个故事之前，我想简单总结一下。** ***迁移学习**是**建立图像分类系统的良好起点*** * *选择**型号取决于**你的**物理(硬件)** **环境**和**你的团队的目标**(有多少种类？).* * *选择**模型实现**并不重要，但是**有助于简化整个过程**。* * *使用**第三方实现**时，要知道三件事。**‘如何创建模型？’、‘最后一层是什么？’，以及“如何加载预训练参数？**'* * ***重要的是**到**知道如何重新缩放**你自己的输入图像以适合所选的模型(使用 skimage.transform 包)。* * ***应根据您的物理(硬件)环境仔细考虑批次大小**。*# Tensorflow 中的迁移学习(CIFAR-10 上的 VGG19):第 1 部分> 原文：<https://towardsdatascience.com/transfer-learning-in-tensorflow-9e4f7eae3bb4?source=collection_archive---------2-----------------------># **简介***这个故事的第二部分可以在这里找到*[](/transfer-learning-in-tensorflow-5d2b6ad495cb)**。***这个故事介绍了如何用预训练的 VGG19 模型训练 CIFAR-10 数据集。我将使用 [tensornets](https://github.com/taehoonlee/tensornets) 中包含的 VGG19。本文的主要目标是理解迁移学习的概念，以及在这个过程中应该关注哪些步骤。你可以在这里找到这个故事的笔记本。**我之前写过一个[笔记本](https://github.com/deep-diver/CIFAR10-img-classification-tensorflow)和一个[故事](https://medium.com/@parkchansung/cifar-10-image-classification-in-tensorflow-5b501f7dc77c)关于建立经典 CNN 模型来训练 CIFAR-10 数据集。这样，我可以比较最先进的 CNN 模型和基本的 CNN 模型之间的性能。*# ***迁移学习********Winners of ILSVRC since ‘10****自 2012 年 AlexNet 出现以来，基于深度学习的图像分类任务得到了极大的改善。一路走来，已经提出了很多 CNN 模型。即使其中一些没有赢得 ILSVRC，但它们如 VGG16 因其简单和低损失率而受到欢迎。**即使使用高端 GPU，针对整个 ImageNet 数据库训练模型也需要几周时间。如果我们能够重用来自 ILSVRC 的经过验证的模型，这将是理想的，这样我们就不需要在训练和验证上花费大量时间。迁移学习正是我们想要的。**迁移学习就是从别人那里借用 CNN 架构及其预先训练好的参数。当我们在预训练参数的基础上训练我们自己的数据时，我们可以很容易地达到目标精度。*# *型号选择**在潜入之前，你必须选择选择哪种型号。这完全与你的物理环境和你的团队的目标有关。**由于 ILSVRC 要求模型对 1000 种图像进行分类，因此一些建议的模型无法显示出超强的性能。然而，如果你的目标是对 10 到 100 类图像进行分类，这些模型可能适合你的情况。**随着 CNN 模型的发展，最近的模型显示出相当复杂的结构。如果我们想要改变/修改整个层的某些部分，或者如果我们想要解决哪个部分是我们问题的瓶颈，理解模型在幕后如何工作是至关重要的。****from [AN ANALYSIS OF DEEP NEURAL NETWORK MODELS FOR PRACTICAL APPLICATIONS](https://arxiv.org/abs/1605.07678)**模型有多大？这通常与参数数量或层数有关。他们会提示你需要花多长时间进行训练。特别是，当你使用 GPU 硬件时，应该充分考虑参数的数量，因为 GPU 的内存资源有限。**对于我来说，出于某些原因，我选择了 VGG19 型号。**第一名**，尽管它没有赢得 ILSVRC，但它取得了第二名的好成绩。我只需要 10 类图像，所以我认为 VGG19 对于 CIFAR-10 已经足够了。**第二**，VGG19 架构很简单。如果你了解基本的 CNN 模型，你会立刻注意到 VGG19 看起来很相似。**第三个**，我有 11GB 内存的英伟达 GTX 1080Ti。这不是最好的选择，但我认为即使 VGG19 的尺寸很大，运行 VGG19 也足够了。**最后**，由于很多人使用 VGG16，我想尝试一下 VGG19。***# *模型实现的选择**实际上，您可以为所选的 CNN 模型使用自己的实现。因为来自 ILSVRC 的模型在他们的网页上分享他们的成果，包括权重，你可以下载(像 [VGG](http://www.robots.ox.ac.uk/~vgg/research/very_deep/) )并把权重注入到你的实现中。**然而，不实现模型本身，而是从文件和验证任务中转换/注入权重，这需要相当长的时间。幸运的是，Github 中有一些开源的实现。只需要在搜索你想要哪个 CNN 模型，你要像 Tensorflow 或者 PyTorch 一样达到哪个平台(框架)就可以了。**对于我来说，我用的是 Tensorflow，碰巧选择了 VGG19。我发现了两个开源实现， [tensornets](https://github.com/taehoonlee/tensornets) 和 [vgg-tensorflow](https://github.com/machrisaa/tensorflow-vgg) 。有趣的是，tensornets 提供了几乎所有流行的 CNN 模型，包括像 YOLO 这样的本地化模型。我想我将来可能会经常使用它们中的一些，所以这就是为什么我选择 tensornets 来熟悉它。*# *知道如何创建模型**没有比仔细阅读 README 文档更简单的方法来了解所选实现的用法。一般来说，第一步是知道如何创建/构建模型图。建立模型后，您可以将预先训练的参数(权重)加载到模型中。不用说，没有预先训练好的参数，就不是迁移学习而只是借用架构。**具体来说，对于张量网，VGG19()创建模型。你只需要指定两个自定义参数， ***is_training*** ，和 ***classes*** 。当您要针对 ImageNet 以外的数据集训练模型时，应将 ***is_training*** 设置为 ***True*** 。 ***classes*** 是要预测的图像的类别数，因此设置为 10，因为数据集来自 CIFAR-10。**需要记住的一点是，输入张量的形状应该始终是 ***【无，224，224，3】***。因为来自 ILSVRC 的每个模型都是在 ImageNet 提供的形状为(224，224，3)的图像上训练的，所以即使您自己的数据具有不同大小的图像，这也不应该改变。*# *了解最后一层**您选择的模型的实际实现通常会有所不同。您应该知道模型的最后一层是什么，以便应用损失函数、优化器和执行准确性测试。通过代码本身，你可以很容易地发现模型是如何构建的。以下截图摘自 tensornets github repo。****可以看到，tensornets 的 VGG19 返回最后一层作为 softmax 激活函数。稍微了解 Tensorflow 的话，***TF . nn . soft max _ cross _ entropy _ with _ logits()***函数用的有些重。然而，这个函数是为了同时应用 softmax 函数和交叉熵损失函数，所以这里不应该用于张量网。相反，可以使用仅提供交叉熵损失函数的***TF . losses . soft max _ cross _ entropy()***函数。除了应用内部 softmax 函数之外，这一个与前一个等效。**这是第一部分的全部内容。[在下一部分](/transfer-learning-in-tensorflow-5d2b6ad495cb)中，我会解释以下问题。*1. *如何进行预训练的负重？* 2. *如何重新缩放图像大小以适合？* 3. *怎么训练？如何衡量准确度？* 4. *表演**我的深度学习背景是[uda city { Deep Learning N](https://www.udacity.com/course/deep-learning-nanodegree--nd101)D&[AI-nd](https://www.udacity.com/course/ai-artificial-intelligence-nanodegree--nd898)with contentrations([CV](https://www.udacity.com/course/computer-vision-nanodegree--nd891)， [NLP](https://www.udacity.com/course/natural-language-processing-nanodegree--nd892) ，VUI)}，[Coursera Deep Learning . AI Specialization](https://www.coursera.org/specializations/deep-learning)(AI-ND 被拆分成了 4 个不同的部分，我是和之前版本的 ND 一起完成的)。还有，我目前正在服用 [Udacity 数据分析师 ND](https://www.udacity.com/course/data-analyst-nanodegree--nd002) ，已经 80%完成。**最近在 [neptune.ai](https://neptune.ai/) 上发现了一篇非常有用的关于迁移学习的博文。由于我的帖子有些过时，如果你有机会，请查看更多最新技术，更深入的解释。** *[迁移学习指南:包含 Keras 中图像和文本示例的实用教程](https://neptune.ai/blog/transfer-learning-guide-examples-for-images-and-text-in-keras)*# 迁移学习:利用大数据集的洞察力> 原文：<https://towardsdatascience.com/transfer-learning-leveraging-insights-from-large-data-sets-d5435071ec5a?source=collection_archive---------2----------------------->在这篇博文中，您将了解什么是迁移学习，它的一些应用是什么，以及为什么它是数据科学家的关键技能。迁移学习不是机器学习模型或技术；它更像是机器学习中的一种“设计方法论”。例如，另一种“设计方法”是主动学习。Originally published at [https://www.datacamp.com/community/tutorials/transfer-learning](https://www.datacamp.com/community/tutorials/transfer-learning)这篇博文是迁移学习系列的第一篇。你可以在这里找到第二篇博文，讨论迁移学习的两个应用[。](https://medium.com/@lars.hulstaert/applying-transfer-learning-in-nlp-and-cv-d4aaddd7ca90)在后续的博客文章中，我将解释如何将主动学习与迁移学习结合起来，以最佳方式利用现有的(和新的)数据。从广义上讲，当机器学习应用利用外部信息来提高性能或泛化能力时，它们使用迁移学习。**迁移学习:一个定义**迁移学习的一般思想是在只有少量标记数据的环境中，使用从有大量标记数据的任务中学到的知识。创建带标签的数据非常昂贵，因此最大限度地利用现有数据集是关键。在传统的机器学习模型中，主要目标是基于从训练数据中学习到的模式来概括看不见的数据。在迁移学习中，你试图从已经学习的不同任务的模式开始启动这一概括过程。本质上，你不是从一张白纸(通常是随机初始化的)开始学习过程，而是从已经学会的解决不同任务的模式开始。Being able to distinguish lines and shapes (left) from an image makes it easier to determine if something is a 'car' than having to start from the raw pixel values. Transfer learning allows you to leverage learned patterns from other computer vision models.Different approaches exist to represent words in NLP (a word embedding like representation on the left and a BoW like representation on the right). With transfer learning a machine learning model can leverage the relationships that exist between different words.知识和模式的转移在许多领域都是可能的。今天的帖子将通过查看这些不同领域的几个例子来说明迁移学习。目标是激励数据科学家在他们的机器学习项目中尝试迁移学习，并让他们意识到优势和劣势。我认为对迁移学习的良好理解是数据科学家的一项关键技能，原因有三:* 迁移学习在任何学习中都是必不可少的。人类并不是为了成功完成每一项任务或问题而被教会的。每个人都会遇到从未遇到过的情况，而我们仍然能够以临时的方式解决问题。从大量经验中学习并将“知识”输出到新环境中的能力正是迁移学习的意义所在。从这个角度来看，迁移学习和概括在概念层面上非常相似。主要区别在于迁移学习通常用于“跨任务转移知识，而不是在特定任务内概括”。因此，迁移学习本质上与所有机器学习模型中必需的一般化思想相关联。 * 迁移学习是确保深度学习技术在大量小数据设置中取得突破的关键。深度学习在研究中几乎无处不在，但许多现实生活中的场景通常没有数百万个带标签的数据点来训练模型。深度学习技术需要大量数据来调整神经网络中的数百万个参数。特别是在监督学习的情况下，这意味着你需要大量(非常昂贵的)标记数据。给图像加标签听起来微不足道，但例如在自然语言处理(NLP)中，需要专业知识来创建一个大的带标签的数据集。例如，Penn treebank，一个词性标注语料库，历时 7 年，需要许多训练有素的语言学家的密切合作。为了使神经网络成为可行的选择，迁移学习是减少所需数据集大小的一种方式。其他可行的选择正在转向更受概率启发的模型，这些模型通常更适合处理有限的数据集。 * 迁移学习有明显的优点也有缺点。理解这些缺点对于成功的机器学习应用至关重要。知识的转移只有在“适当”的时候才是可能的。在这种情况下，准确定义适当的含义并不容易，通常需要进行实验。你不应该相信一个开着玩具车到处跑的小孩会开法拉利。同样的原则也适用于迁移学习:虽然很难量化，但迁移学习是有上限的。这不是一个适合所有问题的解决方案。**迁移学习的一般概念***迁移学习的要求*迁移学习，顾名思义，需要将知识从一个领域转移到另一个领域的能力。迁移学习可以从较高的层面来解释。一个例子是 NLP 中的体系结构可以在序列预测问题中重用，因为许多 NLP 问题可以固有地简化为序列预测问题。迁移学习也可以从一个较低的层面来理解，你实际上是在一个不同的模型中重复使用一个模型的参数(跳格，连续单词袋，等等。).迁移学习的要求一方面是问题特定的，另一方面是模型特定的。接下来的两节将分别讨论迁移学习的高级和低级方法。尽管在文献中你会发现这些概念有不同的名称，迁移学习的总体概念仍然存在。*多任务学习*在多任务学习中，你同时在不同的任务上训练一个模型。通常，使用深度学习模型是因为它们可以灵活地适应。网络体系结构以这样的方式进行调整，即第一层用于不同的任务，随后是不同的任务专用层和不同任务的输出。总的想法是，通过在不同的任务上训练网络，网络将更好地一般化，因为模型需要在需要类似“知识”或“处理”的任务上表现良好。自然语言处理的一个例子是最终目标是执行实体识别的模型。除了纯粹在实体识别任务上训练模型，您还可以使用它来执行词性分类、下一个单词预测……因此，模型将受益于从这些任务和不同数据集学习到的结构。我强烈推荐 [Sebastian Ruder 关于多任务学习的博客](http://ruder.io/multi-task/)来了解更多关于多任务学习的内容。*特瑞*深度学习模型的一大优势是特征提取是‘自动’的。基于标记的数据和反向传播，网络能够确定任务的有用特征。网络“计算出”输入的哪一部分是重要的，以便例如对图像进行分类。这意味着特征定义的手动工作被抽象掉了。深度学习网络可以在其他问题中重用，因为提取的特征类型通常对其他问题也很有用。本质上，在特征化器中，你使用网络的第一层来确定有用的特征，但是你不使用网络的输出，因为它太特定于任务。鉴于深度学习系统擅长特征提取，如何重用现有网络来执行其他任务的特征提取？可以将数据样本输入网络，并将网络中的一个中间层作为输出。这个中间层可以被解释为原始数据的固定长度、经过处理的表示。通常，特征的概念用于计算机视觉的上下文中。图像然后被输入到预先训练好的网络(例如，VGG 或 AlexNet)中，并对新的数据表示使用不同的机器学习方法。提取中间层作为图像的表示大大减少了原始数据的大小，使它们更适合于传统的机器学习技术(例如，与原始数据相比，例如，128×128 = 16384 维，逻辑回归或 SVM 在图像的小表示(如 128 维)下工作得更好)。在下一篇博文中，我将更深入地讨论迁移学习的两个应用，它们都有具体的例子！如果你有任何问题，我很乐意在评论中阅读。如果你想收到我博客上的更新，请在 [Medium](https://medium.com/@lars.hulstaert) 或 [Twitter](https://twitter.com/LarsHulstaert) 上关注我！# 迁移学习—第一部分> 原文：<https://towardsdatascience.com/transfer-learning-part-1-4c2c7839a4b9?source=collection_archive---------26----------------------->什么是迁移学习(TL)，它与经典机器学习(ML)有什么不同？ML 的大谎言是训练数据的分布与模型将要使用的数据的分布相同。如果违反了这个假设，即数据在不同的特征空间上有不同的分布，会怎么样呢？当有足够的数据可用时，可以简单地根据新数据重新训练模型，并完全丢弃旧数据。这并不总是可能的。但是，有一种方法可以改善。如果已知训练数据和其他数据之间存在关系，则将从训练数据获得的知识转移(或转移学习)到其他数据的模型会有所帮助。迁移学习不同于经典的 ML 设置:不是在一个设置中学习，而是在一个设置中学习的知识被重用来提高在另一个设置中的学习。迁移学习受到人类学习者利用现有知识和技能的方式的启发:知道如何阅读文献的人比根本不知道如何阅读的人更有可能成功阅读科学论文。在监督学习的背景下，迁移学习意味着能够重用在一个设置中学习的特征和标签之间的依赖结构的知识，以改进在另一个设置中的依赖结构的推断。在 Dataswati，我们对这种迁移学习特别感兴趣，我个人也花了相当一部分时间研究这些问题。在这篇文章中，我将回顾迁移学习的不同方面，但首先，谈谈经典的监督机器学习设置。我们有一个数据集 *D* ，包含特征向量的样本( *x* ∈ 𝒳)和相应的标签(*y*∈𝒴):*d*= {(*Xi*，*伊* ) : *i* = 1 *，…，m* }。 *D* 由训练实例集*D*|*X*= {*Xi*:*I*= 1*，…，m* }，以及对应标签集 *D* | *Y* = { *伊* : *i* = 1 *，…，组成这里的 *m* 是样本大小。所有的配对( *x* ， *y* )都被假设为从同一个联合分布 *P* ( *X* ， *Y* )(独立同分布假设)中独立采样，反映了随机变量 *X* 和 *Y* 之间的相关性。换句话说，(*，*易*)是对所有 *i* 的一个实现( *X* ，*Y*)∽*P*(*X*， *Y* )。我们的目标是用 *D* 学习一个函数 *h* : 𝒳 → 𝒴 ( *h* 为“假设”)，使 *h* 逼近 *x* 和 *y* 之间的真实关系，这是对*p*(*y*|*x*=【的一些总结当我们在寻找一个好的 *h* 时，我们将我们的搜索限制在某类函数ℋ(例如线性模型)， *h* ∈ ℋ.如果ℋ不太复杂，样本量 *m* 足够大，我们可以学习“好” *h* (例如使用[经验风险最小化](https://en.wikipedia.org/wiki/Empirical_risk_minimization):*****ERM algorithm**其中 *l* 是某个损失函数)使得 *h* 不仅在( *x* 、 *y* ) ∈ *D* )上，而且在其他数据( *x* 、上提供了 *x* 和 *y* 之间真实关系的良好近似**如果我们没有足够的数据或者没有标签怎么办？有希望吗？**如果…会怎样** *…我们有几个不同的数据集，但具有相似的 X-Y 依赖结构？* * *…我们只有其中一些数据集的标签，而没有其他数据集的标签，我们希望在没有标签可用时进行预测？* * *…当我们有另一个具有大样本量和相似但不同的依赖结构的数据集时，我们想要学习对一个小样本量数据集的依赖？* * *…我们有所有这些的组合？**的确，有一种希望，叫做…… ……转移学习。**Pan，Yang 等人(2010)和 Weiss，Khoshgoftaar 和 Wang (2016)对深度学习热之前的迁移学习进行了概述。潘、杨等(2010)将领域定义为一个特征空间，并结合该空间上的概率分布=(， *P* ( *X* ))。一个任务被正式定义为𝒯 = (𝒴， *f* ，这里 *f* 为真，但未知(可能是随机的)函数 *f* : 𝒳 → 𝒴，我们试图用 *h* ∈ ℋ.来近似**为了定义迁移学习(TL)的基本类型，让我们考虑一个简化的设置，此时我们只有两个域，每个域一个任务:源域𝒟 *S* 和任务𝒯 *S* ，目标域𝒟 *T* 和任务𝒯 *T* 。在这个简单的设定中，TL 旨在通过使用𝒯 *S* 、𝒟 *S* 中的知识以及𝒯 *T* 、𝒟 *T* 、𝒯 *S* ≠ 𝒯 *T* 或𝒟 *S* ≠ 𝒟 *T* 来提高 *fT* 的学习。**下表总结了与传统 ML 相比的 TL 类型。****Types of transfer learning: inductive, transductive, and unsupervised**可以基于特征空间进行额外的分类:****Homogeneous and heterogeneous transfer learning**迁移学习最常见的情况是当特征空间和分布都不同时，任务也不同时。**潘、杨等人(2010)根据“传递什么”的问题对翻译策略进行了分类:** ***基于实例的迁移学习**。假设来自源域的一些数据可以在目标域中重用。这里使用了重要性抽样和实例重新加权。* * ***特征表示转移**。学习特征表示 *r* 以便于对 *r(X)* 和 *Y* 之间的相关性进行建模。然后用它来提高目标任务的性能。在神经网络的上下文中，可以在源域中训练监督模型，然后从最后一层中的一层获取表示，以转换目标域中的数据，然后在该转换的数据上训练另一个模型。* * ***参数传递**。假设源任务和目标任务共享一些参数或先验。简单情况下当 *hS* 、 *hT* ∈ ℋ、*hs*=*f*(*x*； *θS* )，*hT*=*f*(*x*； *θT* ，表示 *θS* 与 *θT* 部分相似。在神经网络的背景下，人们可以采用像 VGG 这样的预训练模型，并根据自己的特定任务数据重新训练最后几层(重新训练一小部分 *θS* )。**在这一系列的文章中，我将回顾一下目标语言的一些最新发展，包括领域适应、少量学习和多领域迁移学习的最一般的设置。**在同质直推 TL (𝒳 *S* = 𝒳 *T* = 𝒳)的框架中，领域适应(在来自一个联合分布的数据上训练一个模型，并在来自另一个联合分布的数据上使用它)在过去十年中受到了极大的关注，特别是在深度学习的背景下。**人们经常希望找到变换 *ϕS* 、 *ϕT* : 𝒳 → 𝒳̃，以便变换后的目标数据的分布与变换后的源数据的分布相同，即*p*(*ϕs*(*x*)=*p*(*ϕt*(*x*)对于 *X* ∈这里的希望是，我们可以有效地将在转换后的源数据上训练的模型应用于转换后的目标数据。**在分类(Ben-David 等人，2007 年，2010 年)和回归(Cortes 和 Mohri，2011 年)问题的背景下，从理论上研究了领域适应。Ben-David 等人(2007 年)研究了在源领域数据上训练的分类器可用于目标领域的条件。他们证明了目标域中误差的上限，该上限被表示为源域中误差的函数。他们在 Ben-David 等人(2010)中进一步扩展了他们的分析。总之，该理论表明，对于有效的域适应，需要在数据表示上训练模型，根据该数据表示不可能区分源域和目标域。**我首先提到一些通用方法。**Daumé III (2009)提出了一种非常简单的领域适应方法。Daumé III (2009)通过对源域和目标域应用简单的数据扩充(复制特征或填充零),然后在从两个域收集的扩充数据上训练模型，将域适应问题转化为监督学习问题。然而，他们的方法需要目标域中的标记数据( *DT* ∣ *Y* ≠ ∅).)**在目标域中没有标记数据的情况下，可以找到对齐源和目标分布的转换。Sun，Feng 和 Saenko (2016)提出了相关对齐(CORAL)算法，该算法对齐源和目标分布的二阶统计量。Sun，Feng 和 Saenko (2016)表明，CORAL 可以优于一些基于现代深度学习的方法。**Si、Tao 和 Geng (2010)使用基于 Bregman 散度的正则化进行跨域无监督降维，并提出了迁移学习感知版本的 PCA、Fisher 线性判别分析()、局部保持投影()、边际 Fisher 分析(MFA)和判别局部对齐()。Bregman 散度用于最小化源域和目标域中投影数据分布之间的差异。**潘等人(2011)在其转移成分分析()中使用最大平均差异()作为分布距离的度量。MMD 用于学习数据集的变换(传递分量),以便最小化分布距离。Long 等人(2013)提出了联合分布适应(JDA)，通过包括条件分布最小化的目标来推广 TCA。**最近，最优传输被成功地用于领域适应(Courty，Flamary，和 Tuia 2014Courty，Flamary，Tuia 等 2017；Courty，Flamary，Habrard 等人 2017)。最佳传输通过最小化分布之间的 Wasserstein 距离，找到一个域中的数据到另一个域的转换(Peyré，Cuturi 等，2017)。**在基于混合模型的学习环境中，Beninel 等人(2012 年)提出了一种映射源数据的方法，以便模拟转换数据的分布等于模拟目标的分布。**Glorot、Bordes 和 Bengio (2011)在情感分类的上下文中使用了基于特征表示的领域适应。使用包含四个不同领域数据的简化版亚马逊数据集，他们首先从所有领域收集数据，并使用堆叠去噪 Autoencoder (Vincent et al. 2008)对数据的词袋表示学习无监督的特征表示。然后，对于每个源-目标域对，他们在源数据的表示上训练二进制 SVM 分类器，并将其用于目标数据的表示。**Ganin 和 Lempitsky (2014)提出了一种神经网络架构，该架构将领域适应和深度特征学习结合在一个训练过程中。类似于对抗性训练(Goodfellow 等人，2014 年)，他们同时训练了两个模型:I)域分类器网络，用于区分转换后的源数据和目标数据；以及 ii)预测器网络，用于预测源域中的标签以及“愚弄”域分类器(通过其损失函数中的正则化项实现)。然而，他们引入了允许端到端训练的梯度反转层，而不是域分类器和预测器的交替训练。他们在一系列计算机视觉数据集上展示了他们方法的效率:SVHN、MNIST 和交通标志数据集。Ajakan 等人(2014 年)有效地将一个非常相似的模型应用于亚马逊评论情感分析数据集。Ganin 等人(2016)提出了对这种神经网络的扩展分析，即所谓的域对抗适应神经网络。**如需继续，[请点击此处](https://medium.com/dataswati-garage/transfer-learning-part-2-zero-one-few-shot-learning-8d23d2f8583b)。你会发现第二部分复习零/少投学习。在即将到来的第三部分，我还将回顾多域迁移学习，所以如果你不想错过这个故事，请确保[关注我们](https://medium.com/dataswati-garage)。**阿贾坎、哈娜、帕斯卡尔·日尔曼、雨果·拉罗歇尔、弗朗索瓦·拉维奥莱特和马里奥·马尔尚。2014."领域对抗性神经网络." *arXiv 预印本 arXiv:1412.4446* 。**本-大卫、沙伊、约翰-布利泽、科比-克拉默、亚历克斯-库勒萨、费尔南多-佩雷拉和詹妮弗-沃特曼-沃恩。2010."从不同领域学习的理论."*机器学习*79(1–2):151–75。**本-大卫，夏伊，约翰-布利泽，科比-克莱默和费尔南多-佩雷拉。2007."分析领域适应的表现."在*神经信息处理系统的进展*，137–44。**贝尼内尔、法里德、克里斯托夫·比尔纳奇、查尔斯·布维龙、朱利安·雅克和亚历山大·卢尔梅。2012.*统计学习中知识转移的参数链接模型*。新星出版社。**科尔特斯，科琳娜，和梅尔亚尔·莫赫利。2011."回归中的领域适应."在*算法学习理论国际会议*中，308–23。斯普林格。**库蒂、尼古拉斯、雷米·弗拉芒里、阿毛里·哈布拉和阿兰·拉科托马莫尼。2017."领域适应的联合分配最佳运输."在*神经信息处理系统的进展*，3730–9。**库蒂、尼古拉斯、雷米·弗拉芒里和德维斯·图伊亚。2014."正则化最佳传输的域适应."在*关于数据库中的机器学习和知识发现的欧洲联合会议*，274–89。斯普林格。**库蒂、尼古拉斯、雷米·弗拉芒里、德维斯·图伊亚和阿兰·拉科托马莫尼。2017."领域适应的最佳传输."IEEE 模式分析和机器智能汇刊 39(9):1853–65。**多梅三世，哈尔。2009.“令人沮丧的简单领域适应。” *arXiv 预印本 arXiv:0907.1815* 。**加宁，雅罗斯拉夫和维克多·兰皮茨基。2014."无监督领域适应反向传播." *arXiv 预印本 arXiv:1409.7495* 。**加宁、雅罗斯拉夫、叶夫根尼娅·乌斯季诺娃、哈娜·阿贾坎、帕斯卡尔·热尔曼、雨果·拉罗歇尔、弗朗索瓦·拉维奥莱特、马里奥·马尔尚和维克多·兰皮茨基。2016."神经网络的领域对抗训练."《机器学习研究杂志》17(1):2096–30。**格洛特，泽维尔，安托万·博德斯，约舒阿·本吉奥。2011."大规模情感分类的领域适应:一种深度学习方法."在*第 28 届机器学习国际会议(ICML-11)的会议录*，513–20 页。**古德菲勒、伊恩、让·普吉-阿巴迪、迈赫迪·米尔扎、徐炳、戴维·沃德-法利、谢尔吉尔·奥泽尔、亚伦·库维尔和约舒阿·本吉奥。2014."生成性对抗网络。"在*神经信息处理系统的进展*，2672–80。**龙、、、丁桂光、、孙、俞。2013."具有联合分布适应的转移特征学习."IEEE 计算机视觉国际会议论文集*，2200–2207。***潘、辛诺佳林、曾伟华、郭炳湘、杨强。2011."通过转移成分分析的领域适应."IEEE 神经网络汇刊 22(2):199–210。**潘、辛诺佳林、杨强等。2010."迁移学习综述."IEEE 知识与数据工程汇刊 22(10):1345–59。**佩雷、加布里埃尔、马尔科·库图里和其他人。2017.“计算最优运输。”**斯，斯，大成道，伯更。2010."转移子空间学习的基于 Bregman 散度的正则化."IEEE 知识与数据工程汇刊 22:929–42。**孙、、冯嘉实和凯特·桑科。2016."令人沮丧的简单领域适应的回归."在 *AAAI* ，6:8。**文森特、帕斯卡尔、雨果·拉罗歇尔、约舒阿·本吉奥和皮埃尔·安托万·曼扎戈尔。2008."用去噪自动编码器提取和合成鲁棒特征."第 25 届机器学习国际会议论文集，1096–1103。ACM。**魏斯、卡尔、塔希·科什戈夫塔尔和汪丁丁。2016."迁移学习综述."*大数据杂志* 3 (1): 9。***原载于 2018 年 11 月 19 日*[*medium.com*](https://medium.com/dataswati-garage/transfer-learning-part-1-c2f87de8df38)*。**# 迁移学习—第二部分> 原文：<https://towardsdatascience.com/transfer-learning-part-2-zero-one-few-shot-learning-94d972b6c022?source=collection_archive---------13----------------------->## 零/一/少量学习*这个故事的第一部分，请导航至*[*https://medium . com/dataswati-garage/transfer-learning-part-1-C2 f 87 de 8df 38*](https://medium.com/dataswati-garage/transfer-learning-part-1-c2f87de8df38)*。*当数据丰富时，很容易训练模型。通常情况并非如此，人们只能从几个例子中学习。一种极端形式的迁移学习在这里会有所帮助。想象一下，训练一个学习区分狗和狼的分类器，并且训练集中的所有狗都是牧羊犬。现在，你想对一张吉娃娃的图片进行分类。如果你有一些标记的吉娃娃图片，你可以试着用它们来适应你的模型。这是一个很少发生的学习问题。你的情况会变得更糟。想象一下，只有一个例子(一次性学习)或者根本没有标记的吉娃娃(零次学习)。如果有人试图使用你的狗/狼分类器对卡车进行分类，情况会变得更糟。你能调整你的模型来分类他的卡车吗？乍一看，少射/零射学习的最坏情况似乎几乎是不可解的。但是，有一个解决方案。想想 k 近邻(kNN)。如果我们有一个提取输入的最相关特征的数据表示，并使分类变得容易，我们可以将一个新的无标签示例映射到这个表示，并使用 kNN 来确定标签。你可以告诉我:但是，等等，你不是受限于你训练数据中的标签吗？如果所有最近的邻居都不在附近呢？你是对的。这还不是零镜头学习，但是这种方案可以用于少镜头学习。在观察了几个新类的例子之后，你可以希望学会用 kNN 来识别新类。当然，如果你只在牧羊犬/狼的图像上学习你的特征映射，并且吉娃娃相关的特征被从表示中排除，这可能会出错。## 零射击学习想象一下，现在我们有了一个很好的映射，它映射输入的空间的所有点都被标记了。在这种情况下，基于 kNN 的方法将起作用。这里的问题是构造这样一个标记空间以及从特征空间到这个空间的映射。我们可以采取更一般的方法来寻找一个好的代表。我们可以为标签和训练样本构建一个向量空间嵌入，使得训练样本和它的标签在这样一个公共空间中尽可能地相互靠近。这种方法在图像分类中被积极地使用:为图像和单词学习公共空间嵌入，并且单词用作标签。如果我们有一个嵌入多个标签的向量空间，反映单词标签之间的语义关系，使得单词标签“狗”、“猫”和“哺乳动物”彼此之间比“桌子”更接近，而“桌子”比“猫”更接近“椅子”，这不是很好吗？我们将能够将新图像映射到该空间，然后获取最近邻的标签，即使它不在训练图像集中。幸运的是，可以从大量的文本数据中以无监督的方式学习这样的单词嵌入，参见 [word2vec](https://en.wikipedia.org/wiki/Word2vec) (Mikolov 等人 2013 年)、 [fastText](https://en.wikipedia.org/wiki/FastText) (Bojanowski 等人 2017 年)、 [GloVe](https://en.wikipedia.org/wiki/GloVe_%28machine_learning%29) (Pennington、Socher 和 Manning 2014 年)，或最近的 Poincare 嵌入(Nickel 和 Kiela 2017 年)。使用标记的数据，可以学习狗/狼的图像到单词嵌入空间的嵌入，使得狗的图像被映射到“狗”单词向量的邻域。当一个新的例子被给出时，它被映射到嵌入空间，并且最近的词向量(最近邻居)被作为这个例子的预测标签。Socher 等人(2013 年)使用在维基百科文本上训练的预训练嵌入，他们学习了基于神经网络的图像到单词嵌入向量空间的映射。Taken from Socher et al. (2013)诺鲁齐等人(2013)提出了一种非常简单的方法来将图像嵌入到预训练的词向量嵌入空间中。在训练了多类别图像分类器之后，他们使用类别的预测概率来执行对应于类别标签的单词嵌入向量的概率加权平均。Romera-Paredes 和 Torr (2015 年)开发了一种基于线性变换的零炮学习方法，但该方法需要根据属性对标签和训练样本进行表征。然后，他们学习矩阵，当矩阵与属性向量结合时，给出了到公共空间的线性映射。这与其他方法类似，但更具限制性，因为到公共空间的映射不是从端到端的数据中学习的，而是需要辅助信息进行训练。关于零投学习的不同方法的比较，请参见冼等人(2018)。## 少量学习少量学习与[元学习](https://en.wikipedia.org/wiki/Meta_learning_%28computer_science%29)(学习如何学习)领域相关，需要一个模型从少量新数据中快速学习新任务。Lake 等人(2011)提出了一种受人类学习简单视觉概念(手写字符)启发的一次性学习方法。在他们的模型中，手写字符是人们在绘图时使用的笔画的嘈杂组合。他们提出了一个生成模型，该模型学习一个笔画库，并将该库中的笔画组合起来生成字符。给定一个用于一次性学习的新字符和一个用于评估的候选字符，两个字符都被建模为笔画的叠加，Lake 等人(2011)估计了候选字符由与新字符相同的笔画组成并且这些笔画以类似方式混合的概率。深度学习呢？首先，让我回到我们的 kNN 例子。是什么让 kNN 实现了少拍学习？这是记忆。记忆新的训练样本，然后当类似的新测试样本到达时，kNN 在其存储器中搜索类似的样本，并找到记忆的训练样本及其标签。然而，标准的深度学习架构不允许快速吸收(记忆)新数据，而是需要大量的训练。为了解决这个问题，可以将 kNN 与通过深度学习(深度学习+基于 kNN 的记忆)获得的数据表示相结合。或者，人们可以尝试以更直接的方式用记忆来增强深度神经网络，从而实现端到端的训练。Koch、Zemel 和 Salakhutdinov (2015)开发了基于最近邻分类的少镜头学习方法，通过连体神经网络学习相似性度量。连体神经网络是在 90 年代开发的(Bromley 等人，1994 年)，用于学习两个输入之间的相似性度量。暹罗网络由两个相同的子网(共享权重)组成，它们的输出端相连。每个子网接收自己的输入，整个网络的输出决定了两个输入之间的相似性。在 Koch、Zemel 和 Salakhutdinov (2015)了解了该指标后，使用了简单的最近邻分类器。桑托罗等人(2016 年)开发了一种使用记忆增强神经网络(MANN)的少量学习方法。他们模型的想法类似于神经图灵机(Graves，Wayne 和 Danihelka，2014 年):一个用外部存储模块扩展的神经网络，因此模型是可微分的，可以进行端到端的训练。由于他们的训练程序，他们迫使网络学习一般知识，而快速的内存访问允许将这些一般知识快速绑定到新数据。Vinyals 等人(2016 年)提出了一个神经网络模型，该模型实现了一个端到端的训练过程，该过程结合了特征提取和具有余弦相似性的可微分 kNN。他们使用一个网络来嵌入一小组已标记的图像(支持集)，使用另一个网络来嵌入一个未标记的图像到同一空间。然后，他们计算在支持集中的每个嵌入图像和嵌入的未标记图像之间计算的余弦相似性的 softmax 变换。这被用作来自支持集的标签的概率分布的近似值。然后，他们提出了一个改进方案，即使用整个支持集(上下文)来嵌入支持集中的每个示例以及未标记的测试示例(他们使用 LSTM 来实现这一点)。Taken from Vinyals et al. (2016)Ravi 和 Larochelle (2016)提出修改基于梯度的优化，以允许少量学习。在基于梯度的优化的一般观点中，在优化算法的每一步，优化器(比如 SGD)使用梯度信息来基于它们先前的值提出下一个参数。Ravi 和 Larochelle (2016)用参数更新历史、当前经验风险及其梯度的非线性函数取代了 SGD 更新规则(相对于梯度的线性)。具体来说，他们使用长短期记忆(LSTM)网络(Hochreiter 和 Schmidhuber 1997)来学习非线性更新规则，以训练神经网络。在他们的模型不可知元学习算法(MAML)论文中，Finn，Abbeel 和 Levine (2017)提出了适用于任何可以用梯度下降训练的模型的少镜头学习方法。引用作者的话:“实际上，我们的目标是找到对任务变化敏感的模型参数，这样，当在损失梯度方向上改变时，参数的小变化将对从任务分布中提取的任何任务的损失函数产生大的改进”。目标是为所有任务学习一个模型，以便它的内部表示很好地适合所有任务(可转移)。为了实现这一点，首先，在几个训练示例上，为单个任务上的一个或多个梯度下降步骤训练通用模型。这产生了一个稍微更适合特定任务的模型，一个特定于任务的模型。第二，特定任务模型用于评估其他任务的累积损失。该多任务损失然后被用于执行元优化步骤:用梯度下降来更新通用模型的参数。Taken from Wu et al. (2018)Wu 等人(2018)提出了用于少镜头预测(MeLA)的元学习自动编码器。该模型由元识别模型组成，它以新数据的特征和标签作为输入，并返回一个潜在代码。该代码被用作元生成模型的输入，该元生成模型生成特定于任务的模型的参数。也就是说，特定于任务的模型不是通过梯度下降来训练的，而是从对应于一个任务的几个例子中生成的。此外，生成的模型可以用几个梯度步骤来改进。从对应于任务的几个例子中生成模型的能力可以被解释为模型空间中的插值。为了使它成功，用于训练 MeLA 的任务应该足够相似。今天到此为止。感谢阅读。请关注我们，以免错过我们下一篇关于多领域/多任务迁移学习的文章。## 参考博雅诺斯基，皮奥特，爱德华·格雷夫，阿曼德·朱林和托马斯·米科洛夫。2017."用子词信息丰富词向量."计算语言学协会汇刊 5:135–46。Bromley、Jane、Isabelle Guyon、Yann LeCun、Eduard Sä ckinger 和 Roopak Shah。1994."使用“连体”时间延迟神经网络的签名验证."在*神经信息处理系统的进展*，737–44。芬恩，切尔西，彼得·阿贝耳和谢尔盖·莱文。2017."用于深度网络快速适应的模型不可知元学习."在 *ICML* 。格雷夫斯，亚历克斯，格雷格韦恩和伊沃丹尼尔卡。2014.“神经图灵机。” *arXiv 预印本 arXiv:1410.5401* 。Hochreiter，Sepp 和 Jürgen Schmidhuber。1997."长短期记忆"*神经计算*9(8):1735–80。科赫、格雷戈里、理查德·泽梅尔和鲁斯兰·萨拉胡季诺夫。2015."用于一次性图像识别的连体神经网络."在 *ICML 深度学习工场*。第二卷。莱克、布伦登、鲁斯兰·萨拉赫丁诺夫、杰森·格罗斯和约书亚·特南鲍姆。2011."简单视觉概念的一次性学习."在*认知科学学会年会的会议录*中。第 33 卷。米科洛夫、托马斯、伊利亚·苏茨基弗、程凯、格雷戈·S·科拉多和杰夫·迪恩。2013."单词和短语的分布式表示及其组合性."在*神经信息处理系统的进展*，3111–9。尼克尔、马克西米利安和杜韦·凯拉。2017."学习分层表示的庞加莱嵌入."在由 I. Guyon、U. V. Luxburg、S. Bengio、H. Wallach、R. Fergus、S. Vishwanathan 和 R. Garnett 编辑的《神经信息处理系统进展》30 中，6341–50。Curran Associates，Inc .[http://papers . nips . cc/paper/7213-poincare-embeddings-for-learning-hierarchical-presentations . pdf](http://papers.nips.cc/paper/7213-poincare-embeddings-for-learning-hierarchical-representations.pdf)。诺鲁齐、穆罕默德、托马斯·米科洛夫、萨米·本吉奥、约拉姆·辛格、黄邦贤·施伦斯、安德里亚·弗洛姆、格雷戈里·科拉多和杰弗里·迪恩。2013."语义嵌入的凸组合零镜头学习."abs/1312.5650。彭宁顿，杰弗里，理查德·索彻和克里斯托弗·曼宁。2014."手套:单词表示的全局向量."在*2014 年自然语言处理经验方法会议录*，1532–43。拉维，沙钦和雨果·拉罗彻尔。2016."作为少量学习模型的最优化."英寸罗梅拉-帕雷德斯，贝纳迪诺和菲利普·托尔。2015."一种简单得令人尴尬的零起点学习方法."在*机器学习国际会议*，2152–61。桑托罗、亚当、谢尔盖·巴图诺夫、马修·博特文尼克、金奎大·威斯特拉和蒂莫西·p·莉莉卡普。2016."记忆增强神经网络的元学习."在 *ICML* 。索彻、理查德、米林德·甘朱、克里斯托弗·曼宁和吴恩达。2013."通过跨模态迁移进行零射击学习."在*神经信息处理系统的进展*，935–43。Vinyals、Oriol、Charles Blundell、Timothy P. Lillicrap、Koray Kavukcuoglu 和金奎大·威斯特拉。2016."一次性学习的匹配网络."在*辊隙*中。吴、泰林、约翰·波利福伊、艾萨克·L·庄和马克斯·泰格马克。2018."用于少量预测的元学习自动编码器." *arXiv 预印本 arXiv:1807.09912* 。冼、、Christoph H. Lampert、Bernt Schiele 和 Zeynep Akata。2018."零起点学习——对好、坏、丑的综合评价."IEEE 模式分析与机器智能汇刊*。**原载于 2018 年 12 月 7 日*[*medium.com*](https://medium.com/dataswati-garage/transfer-learning-part-2-zero-one-few-shot-learning-8d23d2f8583b)*。*# 使用不同学习率的迁移学习> 原文：<https://towardsdatascience.com/transfer-learning-using-differential-learning-rates-638455797f00?source=collection_archive---------0----------------------->在这篇文章中，我将分享如何使用迁移学习将流行的深度学习模型用于自己的特定任务。我们将涵盖一些概念，如差异学习率，这甚至不是目前在一些深度学习库中实现的。这些是我作为国际研究员从 [fast.ai](http://www.fast.ai) 深度学习课程 2017 中了解到的。该课程内容将于 2018 年初作为 MOOC 向公众开放。## 那么什么是迁移学习呢？它是使用在一个过程/活动中学到的知识并将其应用于不同任务的过程。让我们举一个小例子，一个擅长 carroms 的玩家可以将该知识应用于学习如何玩台球游戏。## 因此，进入我们的机器学习/深度学习视角…这同样适用于我们的机器学习世界。让我们看看下面的图片。Transfer Learning Example比方说，模型 A 的任务是识别 1000 种物体，比如帽子、猫、垫子，我们手头就有这样一个训练有素的模型。现在让我们假设我们想要创建一个模型 B 来检测一个猫/狗分类器。即使我们有一个小数据集，我们也可以在模型 B 的训练过程中使用模型 A 的知识，并产生最先进的结果。## 但是为什么要使用迁移学习呢？每当我们想要使用机器学习来解决一个独特的问题时，我们很可能无法为我们的模型找到足够的数据。用较少的数据进行训练，结果不会太好。即使我们有大量数据，也有可能没有足够的资源(如 GPU)来获得高质量的结果。因此，迁移学习通过使用预先训练好的模型形式的知识来解决这些问题，这种模型是有人用大型数据集和资源创建的。## 好吧，那你是怎么做的？我们用 CNN 的一个网络图样本来理解一下。尽管实际上网络很大、很复杂并且包含各种其他单元。Sample CNN diagram最常用的方法是修改密集层，使网络输出适合我们手头的任务，并且只训练新增加的层。当任务相互关联，并且您有少量数据时，这种方法非常有效。例如，如果我们使用一个已经知道如何检测猫的预训练模型，如果我们想用少量数据创建一个猫/狗分类器，这种方法将会起作用。第二种方法是在训练中甚至包括更接近密集块(图中的蓝色块)的卷积块。如果我们有一个中等大小的数据集，并且任务之间没有那么紧密的联系，那么这就更理想了。第三种方法是使用预训练模型，但使用数据集训练所有层。这种方法效果很好，但是需要相对较大的数据集和 GPU 资源。如果我们选择这个选项，有几个很酷的技巧，我们将在下面介绍。## 混合第一种和第三种方法。如果我们决定使用第三种方法，最好将第一种方法应用于一些时期的训练，以使新添加的层权重达到更好的点。然后我们可以解冻所有的层，并遵循我们的第三种方法。## 不同的学习率:短语“不同的学习率”是指在我们的培训中，网络的不同部分有不同的学习率。其思想是将各层划分为不同的层组，并为每组设置不同的学习速率，以便获得理想的结果。简而言之，我们控制训练过程中网络各部分的权重变化率。## 为什么？有什么帮助？如果我们考虑上面的第三种方法，有一个小但重要的点值得注意。为了理解这一点，让我们回到 CNN 的示例图。Sample CNN with differential learning rate一般而言，红色图层学习边缘、形状等一般特征，中间的蓝色图层学习与数据集相关的特定细节。鉴于上面的陈述，过多地改变初始层的学习权重不是一个好主意，因为它们已经擅长于它们应该做的事情(检测像边缘等特征)。中间层将了解复杂的特性，如果我们稍微修改它们，这些特性可能在某种程度上有助于我们的任务。所以，我们想稍微调整一下。在这方面，不同的学习率有助于我们。我们现在可以把样本网络想象成三层组(红、蓝、绿)并设置不同的学习速率。最初的红色层将具有较小的学习率，因为我们不想过多地干扰它们，中间的蓝色层将具有比初始层更高的学习率，而最终的绿色层将具有最佳的最高学习率。初始层和中间层的学习率的多少取决于预训练模型和我们需要的模型之间的数据相关性。例如，如果任务是创建一个狗/猫分类器，并且我们的预训练模型已经擅长识别猫，那么我们可以使用较小数量级的学习率。但是如果我们的任务是在卫星图像/医学图像上创建一些模型，那么我们的学习率会稍微高一些。请注意，目前大部分深度学习库都不支持差异学习率。## 好吧，给我看看代码…无论我们讨论什么，我都会写一篇关于编码部分的详细文章。## 结论:根据手头的任务和资源，人们应该选择一种适当的迁移学习方法。一般来说，如果我们有大量的数据和资源，差异学习率的迁移学习会产生更好的结果。# 使用 Mobilenet 和 Keras 进行迁移学习> 原文：<https://towardsdatascience.com/transfer-learning-using-mobilenet-and-keras-c75daf7ff299?source=collection_archive---------1----------------------->在这本笔记本中，我将向你展示一个使用 Mobilenet 对狗的图像进行分类的例子。然后我会给你看一个例子，当它巧妙地错误分类一个蓝色山雀的图像。然后，我将重新训练 Mobilenet 并使用迁移学习，这样它就可以正确地分类相同的输入图像。只使用了两个分类器。但是这可以扩展到您想要的任何数量，受限于您可用的硬件数量和时间。Mobilenet 的源文件位于此处:[https://arxiv.org/pdf/1704.04861.pdf](https://arxiv.org/pdf/1704.04861.pdf)*MobileNets:面向移动视觉应用的高效卷积神经网络*，Howard 等， **2017** 。我们将使用 Mobilenet，因为它的架构是轻量级的。它使用深度方向可分离卷积，这基本上意味着它在每个颜色通道上执行单个卷积，而不是组合所有三个并将其展平。这具有过滤输入通道的效果。或者正如论文作者清楚解释的那样:“*对于 MobileNets，深度方向卷积对每个输入通道应用单个滤波器。逐点卷积然后应用 1×1 卷积来组合深度卷积的输出。标准卷积在一个步骤中将输入滤波并组合成一组新的输出。深度方向可分离卷积将其分为两层，一层用于滤波，另一层用于合并。这种因式分解具有显著减少计算和模型大小的效果*。Difference between pointwise and depth wise convolutions因此，Mobilenet 的总体架构如下，有 30 层1. 步幅为 2 的卷积层 2. 深度方向层 3. 逐点层，通道数量加倍 4. 跨距为 2 的深度方向层 5. 逐点层，通道数量加倍等等。Mobilenet full architecture这也是非常低的维护，因此表现相当好，高速。还有许多预训练模型，内存和磁盘中网络的大小与使用的参数数量成比例。网络的速度和功耗与 MAC(乘法累加)的数量成比例，MAC 是融合乘法和加法运算数量的度量。现在让我们进入代码！我的代码位于这里:[https://github . com/fer hat 00/Deep-Learning/tree/master/Transfer % 20 Learning % 20 CNN](https://github.com/ferhat00/Deep-Learning/tree/master/Transfer%20Learning%20CNN)让我们加载必要的包和库。让我们输入来自 Keras 的预训练模型。让我们对不同品种的狗的图像进行一些测试。Photo by [Jana Ohajdova](https://unsplash.com/@jankao?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)输出:``` [[('n02106662', 'German_shepherd', 0.9796372),('n02105162', 'malinois', 0.020184083),('n02091467', 'Norwegian_elkhound', 0.00015799515),('n02116738', 'African_hunting_dog', 5.2901587e-06),('n02105251', 'briard', 3.9127376e-06)]] ```Photo by [Vincent van Zalinge](https://unsplash.com/@vincentvanzalinge?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)输出:``` [[(‘n02099712’, ‘Labrador_retriever’, 0.73073703),(‘n02087394’, ‘Rhodesian_ridgeback’, 0.03984367),(‘n02092339’, ‘Weimaraner’, 0.03359009),(‘n02109047’, ‘Great_Dane’, 0.028944707),(‘n02110341’, ‘dalmatian’, 0.022403581)]] ```Photo by [Hans Ole Benonisen](https://unsplash.com/@hansob?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)输出:``` [[('n02113799', 'standard_poodle', 0.5650911),('n02113712', 'miniature_poodle', 0.37279922),('n02102973', 'Irish_water_spaniel', 0.053150617),('n02113624', 'toy_poodle', 0.0072146286),('n02093859', 'Kerry_blue_terrier', 0.0013652634)]] ```到目前为止一切顺利。它能很好地对每一种狗进行分类。但是让我们在一种鸟身上试试，蓝山雀。Photo by [Bob Brewer](https://unsplash.com/@brewbottle?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)输出:``` [[('n01592084', 'chickadee', 0.95554715),('n01530575', 'brambling', 0.012973112),('n01828970', 'bee_eater', 0.012916375),('n01532829', 'house_finch', 0.010978725),('n01580077', 'jay', 0.0020677084)]] ```你可以看到它认不出蓝山雀。它错误地将图像归类为山雀。这是一种原产于北美的鸟，与众不同:Photo by [Patrice Bouchard](https://unsplash.com/@patriceb?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)现在让我们来操作 Mobilenet 架构，重新培训最上面的几层，并采用迁移学习。为此，我们需要在一些图像上训练它。我将在蓝山雀和乌鸦上训练它。但是，与其手动下载它们的图片，不如使用谷歌图片搜索来获取图片。为此，我们可以导入一个很好的包。看看 https://github.com/hardikvasa/google-images-download现在让我们重用 MobileNet，因为它是非常轻量级的(17Mb)，冻结基础层，让我们添加和训练顶部的几层。注意，我将只训练两个分类器，蓝山雀和乌鸦。让我们检查模型架构我们将使用预训练的权重，因为该模型已经在 Imagenet 数据集上进行了训练。我们确保所有的重量都是不可训练的。我们将只训练最后几个密集层。现在让我们将训练数据加载到 ImageDataGenerator 中。指定路径，它自动批量发送训练数据，简化代码。编译模型。现在让我们训练它。在 GTX1070 GPU 上应该不到两分钟。``` Epoch 1/10 5/5 [==============================] - 5s 952ms/step - loss: 0.9098 - acc: 0.6562 Epoch 2/10 5/5 [==============================] - 3s 563ms/step - loss: 0.0503 - acc: 0.9686 Epoch 3/10 5/5 [==============================] - 3s 687ms/step - loss: 0.0236 - acc: 0.9930 Epoch 4/10 5/5 [==============================] - 4s 716ms/step - loss: 7.5358e-04 - acc: 1.0000 Epoch 5/10 5/5 [==============================] - 3s 522ms/step - loss: 0.0021 - acc: 1.0000 Epoch 6/10 5/5 [==============================] - 4s 780ms/step - loss: 0.0353 - acc: 0.9937 Epoch 7/10 5/5 [==============================] - 3s 654ms/step - loss: 0.0905 - acc: 0.9938 Epoch 8/10 5/5 [==============================] - 4s 890ms/step - loss: 0.0047 - acc: 1.0000 Epoch 9/10 5/5 [==============================] - 3s 649ms/step - loss: 0.0377 - acc: 0.9867 Epoch 10/10 5/5 [==============================] - 5s 929ms/step - loss: 0.0125 - acc: 1.0000 ```模型现在已经训练好了。现在让我们测试一些独立的输入图像来检查预测。输出:``` array([[4.5191143e-15, 1.0000000e+00]], dtype=float32) ```正如你所看到的，它正确地预测了乌鸦，因为蓝色山雀图像被注释掉了。Photo by [Jaime Dantas](https://unsplash.com/@jaimedantas?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)这可以进一步扩展到更多的图像，以使更多的分类器更好地概括，但这是实现 CNN 的迁移学习的最简单的方法和最快的方式。这当然取决于多快，多准确，你想在什么硬件上实现你的模型，以及你有多少时间。# 使用 pytorch 迁移学习—第 1 部分> 原文：<https://towardsdatascience.com/transfer-learning-using-pytorch-4c3475f4495?source=collection_archive---------0----------------------->有没有想过为什么 ML 模特每次都要从头学起？如果模型可以利用从识别猫、狗、鱼、汽车、公共汽车和许多其他事物中学到的知识来识别分心的汽车司机或识别植物疾病，会怎么样？在迁移学习中，我们使用预训练的神经网络来提取特征，并为特定用例训练新模型。不确定是什么..等到博客结束就好了。# 为什么是 PyTorch有很多框架像 Keras，Tensoflow，Theano，Torch，Deeplearning.4J 等都可以用于深度学习。在所有这些中，我最喜欢的是 Tensorflow 上的 Keras。Keras 适用于许多成熟的架构，如 CNN、前馈神经网络、用于时间序列的 Lstm，但当您试图实现本质上复杂的新架构时，它会变得有点棘手。由于 Keras 是以良好的模块化方式构建的，因此缺乏灵活性。Pytorch 是一个新成员，它为我们提供了以面向对象的方式构建各种深度学习模型的工具，因此提供了很大的灵活性。最近 PyTorch 正在实现许多复杂的架构。所以我开始探索 PyTorch，在这篇博客中，我们将介绍用很小的数据集和几行代码构建一个最先进的分类器是多么容易。我们将使用以下步骤构建一个用于检测蚂蚁和蜜蜂的分类器。1. 从[这里](https://download.pytorch.org/tutorial/hymenoptera_data.zip)下载数据集。2.数据增强。3.下载预训练的 resnet 模型(迁移学习)。4.在数据集上训练模型。5.如何衰减每第 n 个*时期的学习率。*## 下载数据集:从上面的链接下载数据集。它包含训练数据集中的 224 幅图像和验证数据集中的 153 幅图像。## 数据扩充:数据扩充是对现有照片进行更改的过程，如调整颜色、水平或垂直翻转、缩放、裁剪等。Pytorch 提供了一个非常有用的名为 torchvision.transforms 的库，它提供了许多有助于应用数据扩充的方法。transforms 附带了一个 compose 方法，它接受一个转换列表。``` data_transforms **=** { 'train': transforms**.**Compose([transforms**.**RandomSizedCrop(224),transforms**.**RandomHorizontalFlip(),transforms**.**ToTensor(),transforms**.**Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),'val': transforms**.**Compose([transforms**.**Scale(256),transforms**.**CenterCrop(224),transforms**.**ToTensor(),transforms**.**Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]), } ```## 迁移学习:我们将使用微软的 ResNet 模型，该模型在 2015 年赢得了 ImageNet 竞赛。它展示了深层网络是如何成为可能的。让我们不要进入 ResNet 的复杂性。我们将下载模型，大多数现代深度学习框架使加载模型更容易。ResNet 模型包括一组 ResNet 块(卷积和单位块的组合)和一个完全连接的层。该模型在 1000 个类别的 Imagenet 数据集上进行训练，我们将移除最后一个完全连接的层，并添加一个新的完全连接的层，该层输出 2 个类别，这表明图像是蚂蚁或蜜蜂的概率。``` model_conv **=** torchvision**.**models**.**resnet18(pretrained**=**True) **for** param **in** model_conv**.**parameters(): ----> 1param**.**requires_grad **=** False*# Parameters of newly constructed modules have requires_grad=True by default* num_ftrs **=** model_conv**.**fc**.**in_features model_conv**.**fc **=** nn**.**Linear(num_ftrs, 2) ----> 2**if** use_gpu:model_conv **=** model_conv**.**cuda() ----> 3 ```1. 我们告诉模型不要学习或修改模型的权重/参数。 2. 然后，我们向现有模型添加一个新的全连接层，以训练我们的模型对 2 个类别进行分类。 3. 如果你有 gpu 的话。cuda()在 GPU 中执行模型。我们的模型已经准备好了，我们需要将数据传递给训练。## 培训模式:对于培训模型，除了模型之外，我们还需要几样东西，例如:1. PyTorch 变量:包装 pytorch 张量的变量。它包含数据和与数据相关的梯度。 2. 损失函数:它有助于计算我们的模型有多好。我们将在这里使用分类交叉熵。 3. 优化器:我们将使用 SGD 来优化我们的梯度权重。在我们的例子中，我们只更新最后一层的权重。 4. 正向传播:这是我们通过模型传递数据的最简单的部分。 5. 反向传播:这是现代深度学习网络的关键，所有神奇的事情都发生在这里。其中优化器开始计算需要更新多少权重以减少损失或提高准确性。在大多数现代框架中，这是自动化的，因此我们可以专注于构建由深度学习支持的酷应用程序。``` if use_gpu:inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda()) --> 1 else:inputs, labels = Variable(inputs), Variable(labels)criterion = nn.CrossEntropyLoss() --> 2# Observe that all parameters are being optimized optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9) -->3# zero the parameter gradients optimizer.zero_grad()# forward outputs = model(inputs) --> 4 loss = criterion(outputs, labels)# backward + optimize only if in training phase if phase == 'train': --> 5loss.backward()optimizer.step() ```## 衰减学习率:大多数情况下，我们以较高的学习速率开始，这样我们可以更快地减少损失，然后在几个时期后，你想减少它，这样学习变得更慢。我发现 pytorch [教程](http://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html)中的这个函数非常有用。``` **def** **lr_scheduler**(optimizer, epoch, init_lr**=**0.001, lr_decay_epoch**=**7):"""Decay learning rate by a factor of 0.1 every lr_decay_epoch epochs."""lr **=** init_lr ***** (0.1******(epoch **//** lr_decay_epoch))**if** epoch **%** lr_decay_epoch **==** 0:**print**('LR is set to {}'**.**format(lr))**for** param_group **in** optimizer**.**param_groups:param_group['lr'] **=** lr**return** optimizer ```我们将每第 n 个时段的学习率降低，在上面的示例 7 中为 0.1。decay_rate 是可配置的。即使在较小的数据集上，我们也可以使用这种方法获得最先进的结果。想用 pytorch 在你的数据集上尝试迁移学习，代码驻留在[这里](http://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html)。对学习深度学习感兴趣的人，不要忘了看看令人惊叹的 MOOC [深度学习，作者是](http://course.fast.ai/)[杰瑞米·霍华德](https://medium.com/@jeremyphoward)的程序员。在[的下一部分](https://medium.com/@vishnuvig/transfer-learning-using-pytorch-part-2-9c5b18e15551)中，我们将讨论如何使用 VGG 更快地进行迁移学习的不同技巧。并比较它在 PyTorch 和 Tensorflow 中的表现。# 使用 PyTorch 进行迁移学习—第二部分> 原文：<https://towardsdatascience.com/transfer-learning-using-pytorch-part-2-9c5b18e15551?source=collection_archive---------1----------------------->在之前的博客中，我们讨论了神经网络如何使用迁移学习来完成各种计算机视觉任务。在这篇博客中，我们将探讨以下内容。1. VGG 建筑 2. 使用预卷积特征微调 VGG 3. 准确(性) 4. PyTorch 和 Keras 在 Tensorflow 上的性能比较## VGG 建筑:迁移学习中研究最多的深度学习模型之一是 VGG。我们将对 VGG 进行一个高层次的概述，以了解它是如何在迁移学习中得到最佳应用的。VGG 模型可以分为两种逻辑块1. **卷积块:**预训练的 VGG 模型在超过 1000 个类别的图像网络数据集上被训练。卷积块包含多个卷积层。初始层包含低级特征，如直线、曲线。这个模块中的最后卷积层包含更复杂的图像特征，比如手、腿、眼睛等等。下图捕捉了不同图层中捕捉的特征类型。从上面的图像中可以看出，预训练模型的卷积层捕捉到的特征可以用于大多数类型的图像问题。上述功能可能不适用于卡通动画、医学图像等问题，因为它们需要完全不同的功能。卷积层表现出两个重要的特性1. 与全连接层相比，所需的参数数量要少得多。例如，具有 3 * 3 * 64 大小过滤器的卷积层仅需要 576 个参数。 2. 卷积图层的计算开销很大，计算输出需要更长时间。**2。全连接块:**该区块包含密集(在 Keras 中)/线性(在 PyTorch 中)层，并有缺失。FC 层中要学习的参数数量巨大，但计算时间却少得多。因此，我们通常最终按原样从 VGG 模型的卷积块中提取预卷积特征，并且仅训练通常来自全连接块的 VGG 模型的最后几层。## **使用预卷积功能微调 VGG:**正如我们所知，卷积层的计算成本很高，因此计算一次卷积层的输出并使用它们来训练完全连接的层是有意义的。这种方法加快了使用迁移学习训练新模型的过程。例如，如果 1 次迭代需要 3 分钟来训练模型，则通过预先计算卷积层输出(假设需要 2 分钟),而对于 FC 块中的其余迭代，每次迭代只需要几秒钟。**预卷积特性:**我使用的是来自 **kaggle** 的 [**猫狗**数据集，包含 25000 张图片。我保留了 2000 张图片用于验证，剩下的 23000 张用于训练。](https://www.kaggle.com/c/dogs-vs-cats-redux-kernels-edition/data)**硬件基准测试于:**我在上面提到的实验中使用了英特尔 i7 处理器、64 gb 内存和 Titan X GPU。My Monster playing with NN weights :)为了计算卷积特征，我们让所有图像通过卷积层。幸运的是 pytorch 将 VGG 实现为两个逻辑块，由特征(卷积块)和分类器块(FC)组成。在下面的代码中，我们将使用 features 块来计算卷积层的输出。我们将它存储到 bcolz 数组中，以便进一步处理。Bcolz 数组提供了一个压缩和更快的方法来处理数组。``` model_vgg = models.vgg16(pretrained=True) for param in model_vgg.parameters():param.requires_grad = False def preconvfeat(dataset):conv_features = []labels_list = []for data in dataset:inputs,labels = datainputs , labels = Variable(inputs.cuda()),Variable(labels.cuda())x = model_vgg.features(inputs)conv_features.extend(x.data.cpu().numpy())labels_list.extend(labels.data.cpu().numpy())conv_features = np.concatenate([[feat] for feat in conv_features])return (conv_features,labels_list) ```我花了 **1 分 8 秒**来计算 23000 幅图像的训练数据集的特征。大小大约是 600 mb。**微调:**我们可以使用处理过的特征来训练完全连接的层。对于 **10 次迭代**，花费了 **25 秒**。使用 VGG 分类器块的代码段。``` for param in model_vgg.classifier[6].parameters():param.requires_grad = True train_model(model=model_vgg.classifier,size=dset_sizes['train'],conv_feat=conv_feat_train,labels=labels_train,epochs=10,optimizer=optimizer,train=True,shuffle=True) ```## 精确度:在运行该模型大约 30 个时期之后，即在不到几分钟的时间内，验证准确度达到 97%。通过增加批次归一化和降低压差值，可以进一步提高精度。在这个笔记本里，我已经包括了我尝试过的其他实验。## PyTorch VGG 和 Keras 在 Tensorflow VGG 上的性能比较；我在 Tensorflow 上使用 Keras 已经有一段时间了。所以我很想看看他们在时间方面的表现。我使用 PyTorch 版本 0.1.11 和 Tensorflow 版本 1.0.1 进行实验。进行的实验:在卷积层权重不变的情况下运行预训练的 VGG 模型。未计算任何卷积特征。运行了 10 个时期的 23000 幅图像。下面是我的结果。PyTorch — 15 分 19 秒Tensoflow 上的 keras—31 分 29 秒PyTorch 有数据加载器，可以一次使用多个线程来加载数据。当使用 6 个线程时，VGG 模型的性能提高到 11 分钟。**更新:根据下面的推文，我已经尝试使用 keras 和 6 个工人进行预处理，每个时期的性能从 3 分 21 秒提高到 1 分 40 秒。PyTorch 花了 6 个工人 1 分 11 秒。****结论:我在使用 Keras 和 pytorch 时所做的一些观察。Keras 太抽象，好上手，快速建立标准模型。预计性能将优于 PyTorch，但看起来并非如此，尽管 TensorFlow 有许多改进。另一方面，PyTorch 提供了类似于 Python NumPy 的 API 以及在 GPU 上操作的能力。学习曲线比 tensorflow 小得多，比 Keras 灵活得多。因此，如果你对深度学习充满热情，那么你绝对应该看看 PyTorch。****除了框架，我们还讨论了如何使用预卷积特性更快地训练模型。事实上，杰瑞米·霍华德在他的第二部分课程中，即将推出的** [**MOOC**](http://course.fast.ai/) **讨论了脸书如何使用这些预先令人费解的特性的一种有趣的方法。该方法指出，“当不同的团队在同一数据集上工作时，计算这些卷积特征并使其对所有团队可用是很有意义的。”。这种方法将在建立模型时节省大量时间。事实上，脸书也在用类似的方式处理这个问题。**你可以在这里找到与实验[相关的代码。](https://github.com/svishnu88/pytorch)你可以在 LinkedIn 上找到我# 使用新的 fastai 库实现世界级的结果> 原文：<https://towardsdatascience.com/transfer-learning-using-the-fastai-library-d686b238213e?source=collection_archive---------11----------------------->## 一个温和的介绍转移学习和 FastAI 图书馆的真实世界的例子，植物病害检测使用叶片图像。# 动机我目前正在做一个名为“程序员实用深度学习”的 fast.ai Live MOOC，将于 2019 年 1 月在 [fast.ai](http://www.fast.ai/) 网站上公开。以下代码基于该课程的第 1 课。我将使用位于 [Pytorch 1.0](https://hackernoon.com/pytorch-1-0-468332ba5163?gi=b61aa5bd7f45) 之上的 [fastai V1 库](http://www.fast.ai/2018/10/02/fastai-ai/)。fastai 库提供了许多有用的功能，使我们能够快速轻松地构建神经网络并训练我们的模型。我写这篇博客是为了在一个结构和复杂性都不同的数据集上实验课程示例，并展示使用 fastai 库是多么容易。在下面的例子中，你会看到在 [PlantVintage 数据集](https://plantvillage.psu.edu/)上进行迁移学习并获得世界级的结果是多么的简单。PlantVintage 数据包含植物叶片的图像，这些图像由作物上常见的 38 种疾病类别和一个来自斯坦福背景图像开放数据集的背景类别组成— [DAGS](http://dags.stanford.edu/projects/scenedataset.html) 。我从 Github Repo 上的[链接下载了数据。我对这个例子特别感兴趣，因为在我写这篇博客的时候，我为一个组织工作，该组织通过提供产品和技术解决方案来帮助农民发展他们的业务，以实现更好的农场管理。我们开始吧！](https://github.com/MarkoArsenovic/DeepLearning_PlantDiseases)PS:这个博客也作为 [jupyter 笔记本](https://github.com/aayushmnit/fastai_v3_experimentation/blob/master/Lesson-1-PlantVintage.ipynb)发布在我的 [GitHub](https://github.com/aayushmnit) 个人资料上。# 样板命令用下面三行开始笔记本是一个标准的做法；它们确保您对库所做的任何编辑都会自动重新加载到此处，并且显示的任何图表或图像都会显示在此笔记本中。``` %**reload_ext** autoreload %**autoreload** 2 %**matplotlib** inline ```# 导入快速人工智能库让我们导入 fastai 库，并将 batch_size 参数定义为 64。通常，图像数据库是巨大的，所以我们需要使用批处理将这些图像馈送到 GPU 中，批处理大小 64 意味着我们将一次馈送 64 个图像，以更新我们的深度学习模型的参数。如果由于 GPU RAM 较小而导致内存不足，可以将批处理大小减少到 32 或 16。``` **from** **fastai** **import** * **from** **fastai.vision** **import** * bs =64 ```# 看着这些数据当我们处理一个问题时，我们做的第一件事就是看一看数据。我们总是需要非常好地理解问题是什么，数据看起来是什么样的，然后才能想出如何解决它。查看数据意味着了解数据目录的结构，标签是什么，以及一些示例图像是什么样子。我们的数据已经在 train 和 validation 文件夹中进行了拆分，在每个子目录中，我们的文件夹名称表示该子文件夹中所有图像的类名。幸运的是，fastai 库有一个专门为此设计的方便函数，[imagedata bunch . from _ folder](https://docs.fast.ai/vision.data#ImageDataBunch.from_folder)自动从文件夹名称中获取标签名称。fastai library 有[棒极了的文档](https://docs.fast.ai/)来浏览他们的库函数，并附有如何使用它们的实例。一旦加载了数据，我们还可以通过使用。标准化为 ImageNet 参数。``` *## Declaring path of dataset* path_img = Path('/home/jupyter/fastai_v3_experimentation/data/PlantVillage/')*## Loading data* data = ImageDataBunch.from_folder(path=path_img, train='train', valid='valid', ds_tfms=get_transforms(),size=224, bs=bs, check_ext=**False**)*## Normalizing data based on Image net parameters* data.normalize(imagenet_stats) ```为了查看图像的随机样本，我们可以使用。show_batch()函数 ImageDataBunch 类。正如我们在下面看到的，我们有一些不同作物上的病害案例，加上一些来自 DAGS 数据集的背景噪声图像，这些图像将充当噪声。``` data.show_batch(rows=3, figsize=(10,8)) ```让我们打印数据库中存在的所有数据类。总的来说，我们有 39 个类的图像，如上面在动机部分提到的。``` print(data.classes) len(data.classes),data.c ```# 使用预训练模型进行迁移学习:ResNet 50现在我们将开始训练我们的模型。我们将使用一个卷积神经网络主干 [ResNet 50](https://medium.com/@14prakash/understanding-and-implementing-architectures-of-resnet-and-resnext-for-state-of-the-art-image-cf51669e1624) 和一个具有单个隐藏层的全连接头作为分类器。如果你想了解所有的架构细节，你也可以阅读 ResNet 论文。要创建迁移学习模型，我们需要使用 Learner 类中的函数 create_cnn，并从 models 类中输入一个预先训练好的模型。``` *## To create a ResNET 50 with pretrained weights* learn = create_cnn(data, models.resnet50, metrics=error_rate) ```create_cnn 函数创建的 ResNet50 模型冻结了初始层，我们将学习最后完全连接的层的权重。``` learn.fit_one_cycle(5) ```正如我们在上面看到的，通过使用默认设置运行五个时期，我们在验证数据集上的细粒度分类任务的准确度大约为 99.64%。让我们保存模型，因为我们稍后将对其进行微调。如果你想知道这个结果有多好，已经从这个 [Github 页面](https://github.com/MarkoArsenovic/DeepLearning_PlantDiseases)击败了浅层学习(只训练最后一层)基准 96.53%。``` learn.save('plant_vintage_stage1') ```FastAI 库还提供了一些功能来更快地探索结果，并发现我们的模型是否正在学习它应该学习的内容。我们将首先看到模型最容易混淆的类别。我们将尝试使用 ClassificationInterpretation 类来查看模型预测是否合理。``` interp = ClassificationInterpretation.from_learner(learn)interp.plot_top_losses(4, figsize=(20,25)) ```在这种情况下，该模型在从玉米植株上的灰色叶斑中检测北方叶枯病和在视觉上看起来非常相似的番茄叶中的早期/晚期叶枯病时变得混乱。这表明我们的分类器工作正常。此外，当我们绘制混淆矩阵时，我们可以看到大多数东西都被正确分类，这几乎是一个近乎完美的模型。``` interp.plot_confusion_matrix(figsize=(20,20), dpi=60) ```因此，到目前为止，我们只训练了最后的分类层，但如果我们想优化更早的层。在迁移学习中，调整初始层应该谨慎，学习速度应该保持在相当低的水平。FastAI 库提供了一个函数来查看训练的理想学习率，所以让我们来画一个图。lr_find 函数以多种学习速率运行数据子集的模型，以确定哪种学习速率最好。``` learn.lr_find() learn.recorder.plot() ```看起来我们应该保持我们的学习率低于 10e-4。对于网络中的不同层，我们可以使用切片函数在 10e-6 到 10e-4 之间对数分布学习速率。保持初始层的最低学习速率，并增加后续层的学习速率。让我们解冻所有层，以便我们可以使用 unfreeze()函数训练整个模型。``` learn.unfreeze() learn.fit_one_cycle(2, max_lr=slice(1e-7,1e-5)) ```正如我们通过训练所有层所看到的，我们将准确率提高到了 99.7%，与使用 Inception-v3 模型的 [Github 基准测试](https://github.com/MarkoArsenovic/DeepLearning_PlantDiseases)的 99.76%相当。# 结论Fast.ai 是[杰瑞米·霍华德](https://twitter.com/jeremyphoward)和他的团队的一个很好的倡议，我相信 fastai library 可以通过让构建深度学习模型变得超级简单来真正实现将深度学习民主化到每个人的动机。我希望你喜欢阅读，并随时使用我的代码来尝试它为您的目的。此外，如果对代码或博客帖子有任何反馈，请随时联系 LinkedIn 或给我发电子邮件，地址是 aayushmnit@gmail.com。# PyTorch 中卷积神经网络的迁移学习> 原文：<https://towardsdatascience.com/transfer-learning-with-convolutional-neural-networks-in-pytorch-dd09190245ce?source=collection_archive---------0----------------------->([Source](https://www.flickr.com/photos/pinks2000/19160002254))## 如何用 PyTorch 使用预训练的卷积神经网络进行对象识别虽然 Keras 是一个很棒的库，有一个简单的 API 来构建神经网络，但是最近关于 PyTorch 的兴奋终于让我有兴趣探索这个库。虽然我是一个盲目跟风炒作的人，但研究人员采用[和](https://hub.packtpub.com/what-is-pytorch-and-how-does-it-work/)将[纳入 fast.ai 库](https://www.fast.ai/2017/09/08/introducing-pytorch-for-fastai/)让我相信，深度学习的这个新条目背后一定有什么东西。由于学习新技术的最好方式是用它来解决问题，我学习 PyTorch 的努力从一个简单的项目开始:使用一个预先训练好的卷积神经网络来完成物体识别任务。在本文中，我们将看到如何使用 PyTorch 来实现这个目标，同时了解一些关于库和迁移学习的重要概念。> 虽然 PyTorch 可能不适合所有人，但在这一点上，还不能说哪个深度学习库会胜出，能够快速学习和使用不同的工具对于数据科学家的成功至关重要。这个项目的完整代码可以从 GitHub 上的 [Jupyter 笔记本中获得。这个项目诞生于我参与的](https://github.com/WillKoehrsen/pytorch_challenge/blob/master/Transfer%20Learning%20in%20PyTorch.ipynb) [Udacity PyTorch 奖学金挑战赛](https://www.udacity.com/facebook-pytorch-scholarship)。Predicted from trained network# 迁移学习方法我们的任务将是训练一个卷积神经网络(CNN)，它可以识别图像中的对象。我们将使用[加州理工学院 101 数据集](http://www.vision.caltech.edu/Image_Datasets/Caltech101/)，它包含 101 个类别的图像。大多数类别只有 50 幅图像，这通常不足以让神经网络学习到高精度。因此，我们将使用应用迁移学习的预先构建和训练的模型，而不是从头开始构建和训练 CNN。[转移学习](https://machinelearningmastery.com/transfer-learning-for-deep-learning/)的基本前提很简单:取一个在大数据集上训练的模型，*将其知识转移*到一个更小的数据集。[对于 CNN](http://cs231n.github.io/transfer-learning/) 的物体识别，我们冻结了网络的早期卷积层，只训练最后几层进行预测。这个想法是，卷积层提取适用于图像的一般、低级特征，如边缘、图案、梯度，后面的层识别图像中的特定特征，如眼睛或车轮。因此，我们可以使用在大规模数据集(通常是 Imagenet)中的不相关类别上训练的网络，并将其应用于我们自己的问题，因为图像之间存在通用的低级特征。加州理工学院 101 数据集中的图像与 [Imagenet 数据集](http://www.image-net.org/)中的图像非常相似，模型在 Imagenet 上学习的知识应该很容易转移到这项任务中。Idea behind Transfer Learning ([source](https://www.slideshare.net/xavigiro/transfer-learning-d2l4-insightdcu-machine-learning-workshop-2017)).以下是用于对象识别的迁移学习的一般概述:1. 加载在大型数据集上训练的预训练 CNN 模型 2. 冻结模型较低卷积层中的参数(权重) 3. 向模型添加带有多层可训练参数的自定义分类器 4. 根据任务可用的训练数据训练分类器层 5. 微调超参数并根据需要解冻更多层这种[方法已被证明在许多领域取得了成功](http://ruder.io/transfer-learning/)。这是一个很好的工具，并且通常是当遇到新的图像识别问题时应该尝试的第一种方法。## 数据设置对于所有的数据科学问题，正确格式化数据将决定项目的成败。幸运的是，加州理工学院 101 数据集图像是干净的，并以正确的格式存储。如果我们正确地设置了数据目录，PyTorch 可以很容易地将正确的标签与每个类关联起来。我将数据分成 50%、25%、25%的*培训、验证和测试*集，然后将目录构建如下:``` /datadir/train/class1/class2../valid/class1/class2../test/class1/class2.. ```按类别分类的训练图像的数量如下(我交替使用术语类别和种类):Number of training images by category.我们期望模型在有更多例子的类上做得更好，因为它可以更好地学习将特征映射到标签。为了处理数量有限的训练示例，我们将在训练过程中使用*数据扩充*(稍后将详细介绍)。作为另一个数据探索，我们还可以看看大小分布。Distribution of average image sizes (in pixels) by category.Imagenet 模型需要 224 x 224 的输入尺寸，因此*预处理*步骤之一就是调整图像的大小。预处理也是我们为训练数据实现数据扩充的地方。## 数据扩充[数据扩充](http://cs231n.stanford.edu/reports/2017/pdfs/300.pdf)的想法是通过对图像进行随机变换，人为增加我们的模型看到的训练图像的数量。例如，我们可以随机旋转或裁剪图像，或者水平翻转它们。我们希望我们的模型能够区分对象，而不考虑方向，数据扩充也可以使模型[对输入数据的变换不变](https://stats.stackexchange.com/questions/239076/about-cnn-kernels-and-scale-rotation-invariance)。不管面向哪个方向，大象还是大象！Image transformations of training data.增强通常仅在训练期间完成(尽管[测试时间增强在](https://blog.floydhub.com/ten-techniques-from-fast-ai/) `[fast.ai](https://blog.floydhub.com/ten-techniques-from-fast-ai/)`库中是可能的)。每个历元(通过所有训练图像的一次迭代)对每个训练图像应用不同的随机变换。这意味着，如果我们迭代数据 20 次，我们的模型将看到每幅图像的 20 个略有不同的版本。总的结果应该是一个学习对象本身的模型，而不是它们如何呈现或图像中的伪像。# 图像预处理这是处理图像数据最重要的一步。在图像预处理过程中，我们同时为我们的网络准备图像，并对训练集应用数据扩充。每个模型都有不同的输入要求，[，但是如果我们通读 Imagenet 的要求](https://github.com/pytorch/vision/issues/39)，我们会发现我们的图像需要是 224x224，并标准化到一个范围。为了在 PyTorch 中处理图像，我们使用了`transforms`，这是应用于数组的简单操作。验证(和测试)转换如下:* 调整大小 * 居中裁剪至 224 x 224 * 转换成张量 * 用平均值和标准偏差标准化通过这些变换的最终结果，是可以进入我们网络的张量。训练变换是相似的，但是增加了随机增强。首先，我们定义培训和验证转换:然后，我们创建`datasets`和`DataLoaders`。通过使用`datasets.ImageFolder`制作数据集，PyTorch 将自动将图像与正确的标签关联起来，前提是我们的目录如上所述设置。然后数据集被传递给一个`DataLoader`，一个迭代器，产生一批图像和标签。我们可以看到`DataLoader`的迭代行为，如下所示:``` # Iterate through the dataloader once trainiter = iter(dataloaders['train']) features, labels = next(trainiter) features.shape, labels.shape**(torch.Size([128, 3, 224, 224]), torch.Size([128]))** ```一批的形状是`(batch_size, color_channels, height, width)`。在训练、验证和最终测试期间，我们将遍历`DataLoaders`，一次遍历包含一个时期的完整数据集。每个时期，训练`DataLoader`将对图像应用稍微不同的随机变换，用于训练数据扩充。# 用于图像识别的预训练模型有了我们的数据，我们接下来将注意力转向模型。为此，我们将使用预训练的卷积神经网络。PyTorch 拥有许多模型，这些模型已经在 Imagenet 的 1000 个类的数百万张图像上进行了训练。完整的型号列表可以在[这里看到](https://pytorch.org/docs/stable/torchvision/models.html)。这些模型在 Imagenet 上的性能如下所示:Pretrained models in PyTorch and performance on Imagenet ([Source](https://pytorch.org/docs/stable/torchvision/models.html)).对于这个实现，我们将使用`VGG-16`。虽然它没有记录最低的错误，但我发现它很适合这项任务，并且比其他模型训练起来更快。使用预先训练好的模型的过程已经建立:1. 从在大型数据集上训练的网络中加载预先训练的权重 2. 冻结较低(卷积)层中的所有权重:根据新任务与原始数据集的相似性来调整要冻结的层 3. 用一个定制的分类器代替网络的上层:输出的数量必须设置成等于类的数量 4. 仅为任务训练自定义分类器层，从而为较小的数据集优化模型在 PyTorch 中加载预先训练好的模型非常简单:``` from torchvision import models model = model.vgg16(pretrained=True) ```这个模型有超过 1.3 亿个参数，但我们将只训练最后几个完全连接的层。最初，我们冻结模型的所有权重:``` # Freeze model weights for param in model.parameters():param.requires_grad = False ```然后，我们添加我们自己的自定义分类器，包含以下层:* 与 ReLU 激活完全连接，shape = (n_inputs，256) * 辍学几率为 40% * 与 log softmax 输出完全连接，shape = (256，n_classes)``` import torch.nn as nn# Add on classifier model.classifier[6] = nn.Sequential(nn.Linear(n_inputs, 256), nn.ReLU(), nn.Dropout(0.4),nn.Linear(256, n_classes), nn.LogSoftmax(dim=1)) ```当额外的层被添加到模型中时，它们被默认设置为可训练的(`require_grad=True`)。对于 VGG-16，我们只改变了最后一个原始的全连接层。卷积层和前 5 个全连接层中的所有权重都是不可训练的。``` # Only training classifier[6] model.classifier**Sequential((0): Linear(in_features=25088, out_features=4096, bias=True)(1): ReLU(inplace)(2): Dropout(p=0.5)(3): Linear(in_features=4096, out_features=4096, bias=True)(4): ReLU(inplace)(5): Dropout(p=0.5)(6): Sequential((0): Linear(in_features=4096, out_features=256, bias=True)(1): ReLU()(2): Dropout(p=0.4)(3): Linear(in_features=256, out_features=100, bias=True)(4): LogSoftmax()) )** ```网络的最终输出是我们数据集中 100 个类别中每个类别的*对数概率*。该模型共有 1.35 亿个参数，其中仅超过 100 万个将被训练。``` # Find total parameters and trainable parameters total_params = sum(p.numel() for p in model.parameters()) print(f'{total_params:,} total parameters.') total_trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad) print(f'{total_trainable_params:,} training parameters.')**135,335,076 total parameters. 1,074,532 training parameters.** ```## 将模型移动到 GPUPyTorch 最好的一个方面是可以轻松地将模型的不同部分移动到一个或多个 GPU 上，这样你就可以充分利用你的硬件。由于我使用 2 个 GPU 进行训练，我首先将模型移动到`cuda`，然后创建一个分布在 GPU 上的`DataParallel`模型:``` # Move to gpu model = model.to('cuda') # Distribute across 2 gpus model = nn.DataParallel(model) ```(此笔记本应在 gpu 上运行，以便在合理的时间内完成。cpu 的加速比可以轻松提高 10 倍甚至更多。)## 培训损失和优化训练损失(预测值和真实值之间的误差或差异)是[负对数似然](https://ljvmiranda921.github.io/notebook/2017/08/13/softmax-and-the-negative-log-likelihood/) (NLL)。(PyTorch 中的 NLL 损失预期对数概率，因此我们从模型的最终层传入原始输出。) [PyTorch 使用自动微分](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html)这意味着张量不仅记录它们的值，还记录每一次运算(乘法、加法、激活等)。)对价值有贡献。这意味着我们可以计算网络中任何张量相对于任何先前张量的梯度。这实际上意味着损失不仅跟踪*误差*，还跟踪*在模型中每个权重和偏差*对误差的贡献。计算损耗后，我们可以找到损耗相对于每个模型参数的梯度，这个过程称为[反向传播](http://neuralnetworksanddeeplearning.com/chap2.html)。一旦我们有了梯度，我们就用它们来更新优化器的参数。(如果一开始没有理解，不要担心，需要一点时间来掌握！这张幻灯片有助于澄清一些观点。)[优化器是 Adam](https://machinelearningmastery.com/adam-optimization-algorithm-for-deep-learning/) ，它是[梯度下降](https://www.kdnuggets.com/2017/04/simple-understand-gradient-descent-algorithm.html)的有效变体，通常不需要手动调整学习速率。在训练期间，优化器使用损失的梯度来尝试通过调整参数来减少模型输出的误差(“优化”)。*只有我们在自定义分类器中添加的参数才会被优化*。损失和优化程序初始化如下:``` from torch import optim# Loss and optimizer criteration = nn.NLLLoss() optimizer = optim.Adam(model.parameters()) ```有了预先训练好的模型、自定义分类器、损耗、优化器以及最重要的数据，我们就可以开始训练了。# 培养PyTorch 中的模型训练比 Keras 中的模型训练需要更多的动手操作，因为我们必须自己完成反向传播和参数更新步骤。主循环在多个时期上迭代，并且在每个时期上我们迭代通过火车`DataLoader`。`DataLoader`产生我们通过模型传递的一批数据和目标。在每个训练批次之后，我们计算损失，反向传播损失相对于模型参数的梯度，然后用优化器更新参数。我建议您查看[笔记本](https://github.com/WillKoehrsen/pytorch_challenge/blob/master/Transfer%20Learning%20in%20PyTorch.ipynb)了解完整的培训细节，但基本伪代码如下:我们可以继续迭代数据，直到达到给定的历元数。然而，这种方法的一个问题是，我们的模型最终会开始*过度适应训练数据*。为了防止这种情况，我们使用我们的验证数据和*提前停止*。## 提前停止[提前停止](https://en.wikipedia.org/wiki/Early_stopping)表示当验证损失在多个时期内没有减少时，停止训练。随着我们继续培训，培训损失只会减少，但验证损失最终会达到最小值，并趋于平稳或开始增加。理想情况下，我们希望在验证损失最小的时候停止训练，希望这个模型能够最好地概括测试数据。当使用早期停止时，在验证损失减少的每个时期，我们保存参数，以便我们可以稍后检索具有最佳验证性能的参数。我们通过在每个训练时期结束时迭代验证`DataLoader`来实现早期停止。我们计算验证损失，并将其与最低验证损失进行比较。如果损失是目前为止最低的，我们保存模型。如果损失在一定数量的时期内没有改善，我们停止训练并返回已经保存到磁盘的最佳模型。同样，完整的代码在笔记本上，但伪代码是:要了解提前停止的好处，我们可以查看显示训练和验证损失以及准确性的训练曲线:Negative log likelihood and accuracy training curves不出所料，随着进一步的培训，培训损失只会继续减少。另一方面，验证损失达到最小值并处于平稳状态。在某个时期，进一步训练是没有回报的(甚至是负回报)。我们的模型将只开始记忆训练数据，而不能推广到测试数据。> 如果不提前停止，我们的模型将训练超过必要的时间*和*将过度适应训练数据。我们可以从训练曲线中看到的另一点是，我们的模型没有过度拟合。总会有一些过拟合，但是第一个可训练全连接层之后的[下降](https://medium.com/@amarbudhiraja/https-medium-com-amarbudhiraja-learning-less-to-learn-better-dropout-in-deep-machine-learning-74334da4bfc5)防止训练和验证损失偏离太多。# 做出预测:推理在笔记本中，我处理了一些无聊但必要的保存和加载 PyTorch 模型的细节，但这里我们将直接进入最精彩的部分:对新图像进行预测。我们知道我们的模型在训练甚至验证数据方面做得很好，但最终的测试是它在以前从未见过的测试集上的表现。我们保存了 25%的数据，目的是确定我们的模型是否可以推广到新数据。用经过训练的模型进行预测非常简单。我们使用与训练和验证相同的语法:``` for data, targets in testloader:log_ps = model(data)# Convert to probabilitiesps = torch.exp(log_ps)ps.shape()**(128, 100)** ```我们概率的形状是(`batch_size`，`n_classes`)，因为我们对每一类都有一个概率。我们可以通过找到每个示例的最高概率来确定准确性，并将这些概率与标签进行比较:``` # Find predictions and correct pred = torch.max(ps, dim=1) equals = pred == targets# Calculate accuracy accuracy = torch.mean(equals) ```当[诊断用于对象识别的网络](https://www.coursera.org/lecture/machine-learning/model-selection-and-train-validation-test-sets-QGKbr)时，查看测试集的整体性能和单个预测会很有帮助。## 模型结果这是模型钉子的两个预测:这些都很简单，所以我很高兴这个模型没有问题！我们不想只关注正确的预测，我们很快就会看到一些错误的输出。现在，让我们评估整个测试集的性能。为此，我们想要迭代测试`DataLoader`并计算每个例子的损失和准确性。用于对象识别的卷积神经网络一般用 [topk 精度](https://stats.stackexchange.com/questions/95391/what-is-the-definition-of-top-n-accuracy)来衡量。这指的是真实的类是否在 k 个最可能预测的类中。例如，前 5 名准确率是指正确的类别在 5 个最高概率预测中所占的百分比。您可以从 PyTorch 张量中获得 topk 个最可能的概率和类，如下所示:``` top_5_ps, top_5_classes = ps.topk(5, dim=1) top_5_ps.shape**(128, 5)** ```在整个测试集上评估模型，我们计算指标:``` **Final test top 1 weighted accuracy = 88.65% Final test top 5 weighted accuracy = 98.00% Final test cross entropy per image = 0.3772.** ```与验证数据上接近 90%的前 1 名准确度相比，这是有利的。**总的来说，我们得出结论，我们的预训练模型能够成功地将其知识从 Imagenet 转移到我们更小的数据集。**## 模型调查虽然这个模型做得很好，但可能还需要采取一些措施来使它变得更好。通常，找出如何改进模型的最佳方法是调查其错误(注意:这也是一种有效的自我改进方法。)我们的模型不擅长识别鳄鱼，所以让我们来看看这一类别的一些测试预测:鉴于`crocodile`和`crocodile_head`之间的微妙区别，以及第二幅图像的难度，我要说我们的模型在这些预测中并非完全不合理。图像识别的最终目标是超越人类的能力，我们的模型就快实现了！最后，我们希望该模型在包含更多图像的类别中表现更好，因此我们可以查看给定类别的准确性与该类别中训练图像数量的关系图:在训练图像的数量和前 1 名测试准确度之间确实存在正相关。这表明*更多的训练数据增加可能是有帮助的* l，或者，甚至我们应该使用[测试时间增加](https://forums.fast.ai/t/change-to-how-tta-works/8474/3)。我们还可以尝试不同的预训练模型，或者构建另一个自定义分类器。目前，深度学习仍然是一个经验领域，这意味着经常需要实验！# 结论虽然有更容易使用的深度学习库，但 PyTorch 的[优势是](http://www.goldsborough.me/ml/ai/python/2018/02/04/20-17-20-a_promenade_of_pytorch/)[速度](https://www.netguru.co/blog/deep-learning-frameworks-comparison)，对模型架构/训练的每个方面的控制，使用[张量自动微分](/getting-started-with-pytorch-part-1-understanding-how-automatic-differentiation-works-5008282073ec)的反向传播的有效实现，以及由于 PyTorch 图形的[动态特性而易于调试代码](https://medium.com/intuitionmachine/pytorch-dynamic-computational-graphs-and-modular-deep-learning-7e7f89f18d1)。对于生产代码或您自己的项目，我不确定是否有令人信服的理由使用 PyTorch 而不是学习曲线较平缓的库，如 Keras，但是知道如何使用不同的选项是有帮助的。通过这个项目，我们能够看到使用 PyTorch 的基础知识以及*迁移学习*的概念，这是一种有效的对象识别方法。我们可以使用已经在大型数据集上训练过的现有架构，然后针对我们的任务调整它们，而不是从头开始训练模型。这减少了训练的时间，通常会带来更好的整体表现。这个项目的成果是迁移学习和 PyTorch 的一些知识，我们可以在此基础上构建更复杂的应用程序。我们确实生活在一个令人难以置信的深度学习时代，任何人都可以利用容易获得的资源建立深度学习模型！现在，走出去，通过构建自己的项目来利用这些资源。一如既往，我欢迎反馈和建设性的批评。可以通过推特 [@koehrsen_will](http://twitter.com/@koehrsen_will) 或者通过我的个人网站 [willk.online](https://willk.online) 找到我。# 用 PyTorch 迁移学习> 原文：<https://towardsdatascience.com/transfer-learning-with-pytorch-72a052297c51?source=collection_archive---------4----------------------->机器学习的未来如此光明，因为激励措施是全面一致的:大玩家急切地*开源工具*并投资*更快的硬件*以摆脱他们基于广告的商业模式。修补匠发现*小众应用*前所未闻。数据变得更加可替代，用于私人、公共、科学、休闲和不利用途。我可以就未来的完美风暴谈上几个小时(也许还有一些逆向思维)，但让我们坚持一件实际的事情:如何利用最近可用的**预训练机器学习模型**的上升。## **迁移学习**相关的任务需要一小部分*潜在能力来辨别看不见的数据*。例如，无论你是弹吉他还是弹钢琴，你都会比不习惯弹吉他的人更擅长弹奏和弦。用机器学习的术语来说，这意味着你可以复制其他人的训练成果，并对其进行调整，以快速分类[热狗和非热狗](https://www.theverge.com/tldr/2017/5/14/15639784/hbo-silicon-valley-not-hotdog-app-download)的图片，或者让其[生成相当新颖的产品评论](https://github.com/ahirner/generating-reviews-discovering-sentiment)。Sebastian Ruder 很好地概括了模型重用的复合收益。特别是，迁移学习改善了决定机器学习项目技术方面的所有维度:* **人的效率**。如果你想挤出最后一点信号，让模型变得可解释、易处理和健壮，你需要专家。多亏了学术研究，在相关任务中经过实战检验的架构应运而生。 * **计算效率**。最先进的论文通常在 2 到 8 个 GPU 的集群上训练大约两周。虽然，真的没有限制。有了迁移学习，你可以通过部分地或更少地改变内部参数来节省时间。 * **数据效率**。如果其他人在大型数据集上受过训练(他或她甚至不需要透露)，那么在大多数情况下需要的领域特定数据就更少。事实上，在不到 5MB 的下载中，你如何能够[重新利用一个型号](https://github.com/lizeng614/SqueezeNet-Neural-Style-Pytorch)是令人难以置信的。## 地标建筑迁移学习被广泛用于更好地区分特定的图像类别。 [Canziani 等人(2016)](https://arxiv.org/abs/1605.07678) 在 imagenet 数据集上比较了主要架构的计算效率。具体来说，根据您的设备限制，您可以将计算成本进一步划分为*训练时间、推理时间和内存需求*。在最近的一次兼职中，考虑到非常具体的限制，我需要更深入地挖掘。首先，新数据经常出现。第二，这些图像也是*潜在的专利*。因此，*再培训必须在本地中间层 GPU 上可靠地进行*，而不需要外部专家的纵容。从用户的角度来看，如果再培训能在一致的时间内给出一致的结果，那么它就是可靠的，就像你点击要完成的打印任务一样。因此，基准测试将使用一种简单的*优化方法，这种方法*比数据效率更有利于收敛。第三，对于一批大约四幅图像，每个预测需要接近实时地发生。因此，我们关心*推理次数*。最后，我们关心作为业务决策输入的图像(或图像的一部分)的确切类别。因此，我们将*最高精度*考虑在内。现在，为了通过不断发展的数据集将专家的成本降低到几乎为零，并使计算时间符合硬约束，让我们来看看业界最令人垂涎的工具之一的模型动物园:PyTorch。## 结果PyTorch 如今大受欢迎有几个原因。够公平:该框架相当完整、简洁，用代码动态定义了整个计算图，并且易于调试。torchvision 软件包中的一行代码可以加载六个原型:AlexNet、DenseNets、Inception、SqueezeNet 和 VGG。为了了解它们是如何产生的，我推荐[阅读](https://adeshpande3.github.io/adeshpande3.github.io/The-9-Deep-Learning-Papers-You-Need-To-Know-About.html)。不幸的是，API 不允许用自定义数量的类加载预先训练好的模型，而不用手动重新实现最终层。因此，我写了一个函数，从原理上解决了这个问题。它合并预先训练的参数，使它们不会干扰自定义输出层。因此，我们可以系统地比较所有可用架构中我们关心的性能指标。SGD with same momentum and learning rate for each model and 15 epochs on 2xK80图表中的模型仅在最终层(浅层)、针对整个参数集(深层)或从其初始化状态(从头开始)被重新训练。在所有运行中，双 K80 GPUs 运行了大约 75%。如数据所示，SqueezeNet 1.1 兑现了成为高效计算架构的承诺。因为再训练层和静态层的划分有些武断，仅仅基于浅再训练模型的结论太牵强。例如，VGG13 的最终分类器有 8194 个参数，而 ResNet34 的最终层更窄，有 1026 个参数。因此，只有对学习策略的超参数搜索才能使给定目标的比较真正有效。然而，对于这个数据集中的少量类(准确地说是二进制)，SqueezeNet 学习的速度快得令人难以置信。## 结论需要注意的一点是，在相同的训练时间内，深度再训练比浅度再训练产生的准确度要低。在其他任务中，我和其他模特也遇到过这种情况。我对此的理论是，从先前的局部最优解中拧出更深的卷积平均来说发生得很慢(小误差梯度)，并且是在随机初始化后的不太平滑的流形上。因此，参数在转换阶段结束并列。如果看不见的特征与原始数据相比在规模上有所不同，这种间歇性的混乱应该是特别真实的，这就是今天的玩具数据集的情况:有时近距离有蚂蚁，有时你观察到整个群体。所以事实上，你可能会被很好地建议选择更高的学习率，你调整的层数越多，或者在某个时候使用而不是[比例不变网络](https://github.com/msracver/Deformable-ConvNets)。为了评估由推理和重新训练时间组成的计算效率，这是一个很好的开始。如果你想进一步提高再训练的效率，你可以跳过[数据扩充](http://pytorch.org/docs/torchvision/transforms.html#transforms-on-pil-image)，缓存来自未训练层的结果。当然，结论会随着类的数量、前面提到的其他因素和特定的约束而不同。这就是为什么你想自己到达。为此，我[在 github 上发布了原始指标和附带代码](https://github.com/ahirner/pytorch-retraining)。重新训练快乐！# 熊猫中堆栈、融化、数据透视表的转换> 原文：<https://towardsdatascience.com/transformations-of-stack-melt-pivot-table-901292196d9e?source=collection_archive---------9----------------------->## 改变数据表示和恢复的 3 种方法Photo by [Outer Digit](https://unsplash.com/@weareouterdigit?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)完整笔记本在[https://gist . github . com/git githan/0ba 595 e 3e F9 cf 8 fab 7 deeb 7 b 8 b 533 ba 3](https://gist.github.com/gitgithan/0ba595e3ef9cf8fab7deeb7b8b533ba3) 或者，点击这个可滚动框右下角的“查看原始数据”并将 json 保存为。ipynb 文件在本文中，我将探索 python 的 pandas 数据操作库的 **dataframe.stack()、dataframe.melt()、dataframe.pivot_table** 如何在转换管道中相互交互，以重塑数据帧并恢复原始数据帧，同时通过遵循代码来了解许多注意事项。``` from IPython.core.interactiveshell import InteractiveShell InteractiveShell.ast_node_interactivity = “all”import pandas as pd ```默认情况下，jupyter 笔记本只显示每个单元格的最后一行。前两行让 jupyter 显示所有变量的输出，以方便避免将 print()放在我希望看到的每个变量周围。接下来，我们导入 pandas 库，在这里我们从。# 方法一:df→栈→reset_index →pivot →dfFigure 1``` df= pd.DataFrame([[0, 1], [2, 3]],index=['cat', 'dog'],columns=['weight', 'height'])print('{:*^80}'.format('dataframe')) dfprint('{:*^80}'.format('stacked dataframe')) df.stack() ```在这里，我们创建数据帧。然后，df.stack()将我们的单级列 df 转换为具有多索引索引的数据序列，方法是将这些列放入一个新的内部索引(索引级别 1 ),用于旧的外部索引(索引级别 0)中的每个值。外层看起来只有 2 个值[猫，狗]，但这只是为了整齐显示，实际上是 4 个值[猫，猫，狗，狗]。有用的注意事项来自:[*https://pandas . pydata . org/pandas-docs/stable/generated/pandas。DataFrame.stack.html*](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.stack.html) **如果列有多个级别，则新的索引级别取自指定的级别，并且输出是数据帧。**所以最好记住转换输出是数据序列还是数据帧。``` print('{:*^80}'.format('stacked dataframe with index in column')) df.stack().reset_index(level = 1) #AttributeError: 'Series' object has no attribute 'pivot_table' , so must convert to dataframe before pivot_table stacked = df.stack().reset_index(level = 1) ```这些值根据索引对齐，将数据帧从宽格式转换为长格式数据序列。因为 pivot_table 是一个 dataframe 方法，并不适用于 dataseries，所以我们可以使用 reset_index(level = 1)提取多索引的第 1 级，以准备转回。指定 level = 0 会将外部索引提取到列中。请注意，在 reset_index()之后会自动添加“level_1”作为列名。这将是额外的信息，可以在以后使用或清除并忽略。值上方的 0 列也会自动添加。在此阶段提取 0 级还是 1 级并不重要。您可以稍后简单地将输入切换到 pivot_table 的 index 和 columns 参数，以获得相同的输出(除了微小的 df.columns.name 差异)并恢复原始数据帧。``` print('{:*^80}'.format('pivot_table recovered original dataframe (with extra name for columns)')) recovered_df1 = df.stack().reset_index(level = 1).pivot_table(index = stacked.index, columns = 'level_1',values = 0) #pivot_table orders columns alphabetically,specifying values parameter prevents creation of useless multiindex column recovered_df1.columns.name = None #remove 'level_1' column.name recovered_df1 ```最后，我们通过从当前列名中选择来指定 pivot_table 中的索引和列参数，以描述最终的透视数据帧应该是什么样子。values 参数是可选的，但不指定它会将尚未在 index 或 columns 参数中指定的列名添加到当前列的外层，从而创建看起来很难看的多索引列，并使数据访问变得不必要的困难。# 方法 2:df→堆栈→转换为数据帧→透视→dfFigure 2``` print('{:*^80}'.format('dataframe')) df print('{:*^80}'.format('stack and convert to dataframe to expose pivot_table')) stacked_df = pd.DataFrame(df.stack()) stacked_df ```请记住，pivot_table 是一个 dataframe 方法，并不适用于数据序列，因此，我们可以使用 pd 从数据序列中直接构造一个 dataframe，而不是像第 1 部分那样使用 reset_index。DataFrame(df.stack())创建一个多索引的 DataFrame，使 pivot_table 方法可用，并更加努力地正确指定其参数。``` print('{:*^80}'.format('rather than unstack, pivot_table achieves the same')) idx_lvl0, idx_lvl1 = stacked_df.index.get_level_values(0), stacked_df.index.get_level_values(1) recovered_df2 = stacked_df.pivot_table(index=idx_lvl0,columns = idx_lvl1,values = 0) recovered_df2 ```index.get_level_values(0)是一种以 pandas.core.indexes.base.Index 对象的形式获取指定多索引级别(在本例中为 0)的索引值的方法，接受序列/列表的函数可以方便地使用该对象。在第 2 部分中，我们将每个级别的正确索引信息匹配到数据透视表的索引和列参数中，以恢复原始数据帧。第 2 部分比第 1 部分更清晰，因为没有 reset_index 来在 df.columns.name 中创建额外的“level_0”或“level_1 ”,我们在第 1 部分中将其设置为 None。# 方法三:df→融→加指数→支点→dfFigure 3``` print('{:*^80}'.format('dataframe')) df print('{:*^80}'.format('melting loses index information')) melted = df.melt() #melt appends columns into new "variable" column, while stack adds columns to new inner index layer (same information end up different places) melted ```与堆栈类似，melt 通过将压缩列放入单个列表中，将宽格式数据转换为长格式数据。不同的是，stack 将这个列表插入到内部索引中，而 melt 将这个列表作为一个名为' variable '(可以重命名)的新列插入。``` print('{:*^80}'.format('manually enrich index')) # until this is solved: [https://github.com/pandas-dev/pandas/issues/17440](https://github.com/pandas-dev/pandas/issues/17440) melted.index = ['cat','dog']*2 #list(df.index)*len(df.columns) for more generalizable index generation melted ```注意，melt 已经让索引中的猫狗信息消失了。这使得无法恢复原始数据帧。在这个问题([https://github.com/pandas-dev/pandas/issues/17440](https://github.com/pandas-dev/pandas/issues/17440))解决之前，我们必须手动添加回索引。``` print('{:*^80}'.format('pivot_table recovered original dataframe (with extra name for columns)')) recovered_df3 = melted.pivot_table(index = melted.index, columns = 'variable',values = 'value') recovered_df3.columns.name=None #remove 'variable' column.name recovered_df3 ```最后，带有正确参数的 pivot_table 将恢复我们的原始数据帧。与第 1 部分一样，为了精确恢复，从 df.columns.name 中删除了“variable”。# 结论我希望这些转换能让这些函数的初学者更好地理解 pandas 有多灵活。可以使用 set_index 和 reset_index 将相同的信息放在索引或列中，这取决于它们在何处发挥最大作用。例如，当信息在列中时，不使用 df.loc[df.col == value]进行筛选，而是将 col 设置为索引，然后使用 df.loc[value]就简单多了。信息是在索引中还是在列中也会极大地影响 pd.merge、pd.concat、dataframe.join 如何处理这样的数据系列/数据帧，但那将是另一篇完整的文章。Stack 允许信息从列到索引，反之亦然(使用 unstack())。Melt 将列组合成 id_vars，variable，value 的标准 3 列格式，以允许在用编辑的列值旋转回来之前对变量进行列处理。Pivot_table 是 3 个参数中最强大的，其他参数如 aggfunc(聚合)允许自定义函数，因此可能性是无限的。 最后，这里有一个对我帮助很大的实际例子:[http://pbpython.com/pandas-pivot-table-explained.html](http://pbpython.com/pandas-pivot-table-explained.html)# 用熊猫融化在 Python 中转换数据> 原文：<https://towardsdatascience.com/transforming-data-in-python-with-pandas-melt-854221daf507?source=collection_archive---------5----------------------->世界银行拥有互联网上最丰富的数据来源之一。这些数据有许多实际应用，如预测经济增长或[用机器学习预测贫困](http://www.worldbank.org/en/events/2018/02/27/machine-learning-poverty-prediction)。我最近用这些数据制作了一些撒哈拉以南非洲人均 GDP 增长的可视化表格([年化增长](https://public.tableau.com/profile/jake.huneycutt#!/vizhome/AfricanGDPperCap2000-2016Annualized/Sheet1)、[累积增长](https://public.tableau.com/profile/jake.huneycutt#!/vizhome/AfricanGDPperCap2000-2016/Sheet1))。然而，前进的道路上有一个巨大的路障。我的世界银行数据无法在 Tableau 上使用。Tableau 更适合数据库样式的格式，而不是您在 Excel 中看到的金融和经济数据的典型格式。我必须转换数据，使其在 Tableau 中工作。用 Python 来做这件事的一个方法是用[熊猫融化](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.melt.html)。Pd.melt 允许您将数据从“宽格式”转换为“长格式”，非常适合我的任务:获取“宽格式”经济数据，每列代表一年，然后将其转换为“长格式”数据，每行代表一个数据点。**获取数据**在我开始编码之前，我想向您展示如何访问数据。如果您只想了解 pandas.melt，请随意跳到下一部分(“用 Pandas Melt 进行改造”)。如果想做完整教程(取世行数据，做 Tableau 动画)，第一步是去[世行公开数据](https://data.worldbank.org/)网站。有许多不同的方法来获取人均国内生产总值数据。你可以点击主页上的“按指标浏览”(见下图中的橙色框)，然后向下滚动到“经济和增长”部分，在那里你会找到一些人均 GDP 指标。或者，您可以开始在搜索栏中键入您想要的度量。对于我的分析，我做了年化和累积人均 GDP 增长；这两个指标都需要稍微复杂一点，所以让我们简化一下，把重点放在“人均 GDP 增长率(年%)”上。一旦你选择了你的类别，你将得到世界数据。你可以点击“地图”查看国家和年份的数据。我们需要去“数据库”直接研究这些数据。我们将得到一个复杂的屏幕，看起来像下面的图片:在处理世界银行的数据时有一些挫折。如果你正在跟进，我建议尝试做一些比撒哈拉以南非洲增长更简单的事情。而是关注国家更少的南美。首先，我们需要“取消全选”然后我们将选择几个南美国家:阿根廷、巴西、智利、秘鲁和委内瑞拉。如果您想要更全面的演示，也可以随意将其他国家添加到您的数据集中(巴拉圭、乌拉圭、玻利维亚、厄瓜多尔、哥伦比亚、圭亚那、苏里南)。现在查看“时间”,确保检查了 2000 年至 2016 年的所有年份。在屏幕右上角找到“下载选项”并下载 Excel 文件。我们有一大堆看起来像这样的数据:问题是 Tableau 想要一种数据库风格的格式。我们需要我们的数据看起来更像这样:请注意，不同之处在于，数据库样式的格式为每个国家和日期提供了单独的一行，而不是为每个单独的年份提供列。在我们使用 pandas.melt 之前，我们需要先清理一下我们的数据。让我们删除无用的列，如“系列名称”、“系列代码”和“国家代码”我们还需要将日期更改为 mm/dd/yyyy 格式。我们可以在 Python 中做到这一点，但通常情况下，更简单的方法是只输入前两年的 12/31/yyyy(输入“yyyy”的年份)，然后使用 Excel 的 [fill 命令](https://support.office.com/en-us/article/create-a-list-of-sequential-dates-aa1c0fa7-c76a-4762-8bc9-46f1691defec)来完成剩下的工作。最后，删除底部的源数据(“数据库中的数据”，“上次更新”)。现在我们准备用 Python 来转换数据。**变身熊猫融化**首先，我们需要导入熊猫和数据集。这将取决于您的文件位置，但您的代码应该看起来像这样。``` import pandas as pddf = pd.read_excel('C:\PlaceYourDataComesFrom\data.xlsx', sheetname='data')print(df.head()) ```使用 df.head()确保数据正确加载。现在，我们将使用 pd.melt 来重新格式化它。``` d = pd.melt(df, 'Country Name', var_name='Date', value_name='GDPperCapGrowth%')print(d.head()) ```最后一步是用我们转换后的输出生成一个新的 Excel 文件。``` d.to_excel(r'C:\PlaceYouWantYourDataToGo\output.xlsx', sheet_name='GDPperCapGr', index=False) ```现在，转换后的数据在 Tableau 中应该工作得很好。**一点点 o' Tableau**由于这是一个熊猫融化教程，我不会花太多时间在 Tableau 上，但如果你想看看你的地图会是什么样子，你首先需要在你的电脑上 Tableau。你可以在 [Tableau 公共](https://public.tableau.com/en-us/s/)网站下载免费版本。公开展示画面。连接到 Excel 文件。加载转换后的 Excel 数据。单击 Tableau 底部的“Sheet 1 ”,您应该会看到您的数据。在“维度”部分，您会看到“国家名称”将它拖到屏幕中间的大框中(“拖放到此处”)。向下浏览“Measures”部分，您会看到“GDPperCapGr%”。将它拖到“颜色”框中。在“维度”部分找到“日期”,并将其拖动到“过滤器”框中。选择“全部”表示年份。现在，再次转到“日期”并将其拖动到“过滤器”上方的“页面”框中你会看到一个新的框出现在屏幕的最右边(我在下图中突出显示了它，被一个黑色的框包围着。)按下前进按钮，你会得到一个漂亮的人均 GDP 逐年增长的动画。在“标签”框中添加“国家名称”和“GDPperCapGr%”以添加标签。现在你有一个简单的(虽然还不优雅)Tableau 动画来玩。**结论**熊猫融化是一个非常强大的数据转换工具。如果你要处理大量广泛的经济和金融数据，它会特别有用；并且需要一种对数据库更友好的长格式。# 转换扭曲的数据> 原文：<https://towardsdatascience.com/transforming-skewed-data-73da4c2d0d16?source=collection_archive---------0----------------------->## 友好函数综述*注:以下代码用 Python 编写，摘自各种 Jupyter 笔记本。为了使文章更具可读性，行内注释被删除了。*扭曲的数据既麻烦又常见。通常需要转换倾斜的数据，并将其转换为 0 到 1 之间的值。用于这种转换的标准函数包括归一化、Sigmoid、对数、立方根和双曲正切。这完全取决于一个人试图完成什么。这里有一个我从 890 万行[亚马逊图书评论数据集](http://jmcauley.ucsd.edu/data/amazon/)中生成的倾斜列的例子。df。Helpful _ Votes 给出每篇书评收到的有用投票(相对于无用投票)的总数。## **df _ helper _ Votes 原始数据**``` **IN** df.Helpful_Votes.describe()**OUT** count 4.756338e+06 mean 5.625667e+00 std 2.663631e+01 min 0.000000e+00 25% 1.000000e+00 50% 2.000000e+00 75% 4.000000e+00 max 2.331100e+04 ```0, 1, 2, 4, 23311.那是相当大的一跳！删除异常值是一个选项，但不是我想在这里使用的。我的最终目标是建立一个机器学习算法来预测给定的评论是否有帮助，因此拥有最有帮助投票的评论是必不可少的。我将使用上面列出的函数来转换数据，并解释其优缺点。和大多数数据科学一样，没有正确的函数。这取决于数据和分析师的目标。规范化将所有数据点转换为 0 到 1 之间的小数。如果最小值为 0，只需将每个点除以最大值。如果最小值不为 0，则从每个点中减去最小值，然后除以最小值-最大值差。以下函数包括这两种情况。## **归一化功能**``` **IN** def normalize(column):upper = column.max()lower = column.min()y = (column - lower)/(upper-lower)return yhelpful_normalized = normalize(df.Helpful_Votes) helpful_normalized.describe()**OUT** count 4.756338e+06 mean 2.413310e-04 std 1.142650e-03 min 0.000000e+00 25% 4.289820e-05 50% 8.579641e-05 75% 1.715928e-04 max 1.000000e+00 ```归一化后，数据还是和以前一样偏斜。如果目标只是简单地将数据转换成 0 到 1 之间的点，那么规范化是一条可行的途径。否则，规范化应该与其他函数结合使用。接下来是 Sigmoid 函数。如果你以前没有见过乙状结肠，值得看一看。这是一条非常平滑的曲线，保证了 0 到 1 的范围。我们来看看它在 df 上的表现如何。有帮助的 _ 投票。## Sigmoid 函数``` **IN** def sigmoid(x):e = np.exp(1)y = 1/(1+e**(-x))return yhelpful_sigmoid = sigmoid(df.Helpful_Votes) helpful_sigmoid.describe()**OUT** count 4.756338e+06 mean 8.237590e-01 std 1.598215e-01 min 5.000000e-01 25% 7.310586e-01 50% 8.807971e-01 75% 9.820138e-01 max 1.000000e+00 ```明显的进步。新数据在预期的 0 和 1 之间，但最小值是 0.5。这在查看图表时是有意义的，因为在统计投票时没有负值。另一个需要考虑的问题是价差。这里，第 75 百分位在第 100 百分位的 0.2 以内，与其他四分位相当。但是在原始数据中，第 75 个百分位数与第 100 个百分位数相差 20，000 多，与其他四分位数相差甚远。在这种情况下，数据被扭曲了。sigmoid 函数可以调整以改善结果，但现在，让我们探索其他选项。接下来，对数。减少数据失真的绝佳选择。在 Python 中使用 log 时，默认基数通常是 *e* 。## 对数函数``` **IN** helpful_log = np.log(df.Helpful_Votes) helpful_log.describe()**OUT** RuntimeWarning: divide by zero encountered in log ```哎呦！被零除！这是怎么发生的？也许一个视觉会澄清事情。## 对数图Af Adrian Neumann — Eget arbejde, CC BY-SA 3.0, [https://commons.wikimedia.org/w/index.php?curid=1834287](https://commons.wikimedia.org/w/index.php?curid=1834287)啊，是的。日志的域严格大于 0。这是一条沿着 y 轴的垂直渐近线。当 x 接近 0 时，y 接近负无穷大。换句话说，0 被排除在域之外。我的很多数据点都是 0，因为很多评论没有收到有用的投票。为了快速解决问题，我可以在每个数据点上加 1。因为 1 的对数是 0，所以这样做很好。此外，由于*所有的*点都增加 1，所以保持了相同的分布。## 对数函数+ 1``` **IN** helpful_log = np.log(df.Helpful_Votes + 1) helpful_log.describe()**OUT** count 4.756338e+06 mean 1.230977e+00 std 9.189495e-01 min 0.000000e+00 25% 6.931472e-01 50% 1.098612e+00 75% 1.609438e+00 max 1.005672e+01 Name: Helpful_Votes, dtype: float64 ```非常好。新的范围是从 0 到 10，四分位数反映了原始数据。是时候正常化了。## 对数函数+ 1 标准化``` **IN** helpful_log_normalized = normalize(helpful_log) helpful_log_normalized.describe()**OUT** count 4.756338e+06 mean 1.224034e-01 std 9.137663e-02 min 0.000000e+00 25% 6.892376e-02 50% 1.092416e-01 75% 1.600360e-01 max 1.000000e+00 Name: Helpful_Votes, dtype: float64 ```这看起来很有道理。如果结果仍然有偏差，对数函数加归一化是转换有偏差数据的一种很好的方法。然而，这种情况有一个主要的缺点。为什么首先要将数据转换为 0 到 1 之间的值？通常百分比和概率会起作用。就我而言，我希望中位数在 50%左右。这里归一化后，中位数在 0.1。当数字太大时，可以尝试用分数指数作为变换的手段。考虑立方根。## 立方根``` **IN** helpful_cube_root = df.Helpful_Votes**(1/3) helpful_cube_root.describe()**OUT** count 4.756338e+06 mean 1.321149e+00 std 8.024150e-01 min 0.000000e+00 25% 1.000000e+00 50% 1.259921e+00 75% 1.587401e+00 max 2.856628e+01 ```这与 log 非常相似，但是这里的范围更大，从 0 到 28。## 立方根归一化``` **IN** helpful_cube_root_normalized = normalize(helpful_cube_root) helpful_cube_root_normalized.describe()**OUT** count 4.756338e+06 mean 4.624857e-02 std 2.808959e-02 min 0.000000e+00 25% 3.500631e-02 50% 4.410519e-02 75% 5.556906e-02 max 1.000000e+00 ```不出所料，新数据归一化后问题更多。现在中位数是 0.04，离 50%相差甚远。我喜欢玩数字游戏，所以我尝试了一些超能力。有趣的结果来自 1/log_max。我定义 log_max 为最大值的对数。(23311 的对数是 10.06。)## 对数最大根``` **IN** log_max = np.log(df.Helpful_Votes.max()) helpful_log_max_root = df.Helpful_Votes**(1/log_max) helpful_log_max_root.describe()**OUT** count 4.756338e+06 mean 9.824853e-01 std 3.712224e-01 min 0.000000e+00 25% 1.000000e+00 50% 1.071355e+00 75% 1.147801e+00 max 2.718282e+00 ```从 0 到 2.7 的范围非常吸引人。**对数最大根归一化**``` **IN** helpful_log_max_root_normalized = normalize(helpful_log_max_root) helpful_log_max_root_normalized.describe()**OUT** count 4.756338e+06 mean 3.614362e-01 std 1.365651e-01 min 0.000000e+00 25% 3.678794e-01 50% 3.941294e-01 75% 4.222525e-01 max 1.000000e+00 ```这看起来不错，但是数据非常集中在 25–75%的范围内，这个范围可能会延伸得更远。因此，尽管整体传播更令人满意，但在这里还不够。现在是我们最后一个标准函数，双曲正切函数。先来个图。这看起来很像乙状结肠。一个主要的区别是范围。双曲正切的范围是从-1 到 1，而 sigmoid 的范围是从 0 到 1。在我的资料里，从 df 开始。有帮助的 _ 投票都是非负的，我的输出会从 0 到 1。## 双曲正切``` **IN** helpful_hyperbolic_tangent = np.tanh(df.Helpful_Votes) helpful_hyperbolic_tangent.describe()**OUT** count 4.756338e+06 mean 7.953343e-01 std 3.033794e-01 min 0.000000e+00 25% 7.615942e-01 50% 9.640276e-01 75% 9.993293e-01 max 1.000000e+00 ```没有必要标准化，但没有突出的问题。双曲正切比 sigmoid 更扭曲数据。第 75 个和第 100 个百分位数之间有 0.001 的差异，比其他任何四分位数都要接近。在原始数据中，这一差异比其他四分位数之间的差异大 23，307，1000 倍。差远了。百分位数提供了另一种选择。每个数据点都可以根据其百分位数进行排序，pandas 提供了一个很好的内置方法。兰克，来处理这件事。一般的想法是，每个点接收其百分位数的值。在我的例子中，因为有许多数据点的有用票数很低，所以有不同的方法来选择这些百分点。我喜欢“最小”方法，在这种方法中，所有的数据点都接受给予组中第一个成员的百分位数。默认方法是“平均”，其中具有相同值的所有数据点取该组的平均百分位数。## 百分位线性化``` **IN** size = len(df.Helpful_Votes)-1 helpful_percentile_linearization = df.Helpful_Votes.rank(method=’min’).apply(lambda x: (x-1)/size) helpful_percentile_linearization.describe()**OUT** count 4.756338e+06 mean 4.111921e-01 std 3.351097e-01 min 0.000000e+00 25% 1.133505e-01 50% 4.719447e-01 75% 7.059382e-01 max 1.000000e+00 ```很有趣。百分位数线性化基本上与排名系统相同。如果第一个数据点和第二个数据点之间的差异应该与作为一个单位部分的所有数据点相同，则可以采用百分点线性化。不利的一面是，百分位数线性化消除了关键的偏斜迹象。这个数据看起来有点倾斜，因为有成千上万的 1 票和 2 票的评论，而不是因为有几个评论的投票数高得惊人。因为我主要是在处理一个排名系统，所以我把百分位数线性化和我自己的分段线性化函数结合起来。原木也发挥了作用。无论你的选择或风格如何，永远不要局限于标准选项。数学函数极其丰富，它们与数据科学的交集值得更多的认可和灵活性。我很想听听人们用来转换扭曲数据的其他函数。我听说过 boxcox 函数，尽管我还没有详细研究过它。*更多关于 Wade 的亚马逊书评项目的详情可以在他的 Github 页面查看，*[*helified _ Reviews*](https://github.com/coreyjwade/Helpful_Reviews)*。*# 通过一些想法将文本转化为句子嵌入> 原文：<https://towardsdatascience.com/transforming-text-to-sentence-embeddings-layer-via-some-thoughts-b77bed60822c?source=collection_archive---------11----------------------->“man standing on mountain peak” by [Sammie Vasquez](https://unsplash.com/@sammieeev?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)学习一个通用的分布式嵌入层是 NLP 问题中的一个重要步骤。从 Mikolov 等人(2013)开始，引入了许多监督学习和非监督学习方法来检索高质量的文本表示。Kiros 等人在 2015 年引入了 skip-thinks，其目标是提供句子级向量。看完这篇文章，你会明白:* 跳跃式设计 * 体系结构 * 履行 * 拿走# 跳跃式设计如果您不熟悉构建单词嵌入的跳格方法，您可以查看这个[博客](/3-silver-bullets-of-word-embedding-in-nlp-10fa8f50cc5a)了解更多细节。“women's white tank top on top of the hill” by [Cristina Gottardi](https://unsplash.com/@cristina_gottardi?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)Skip-thoughts 将 skip-grams 模型从单词嵌入扩展到句子嵌入。跳跃思维不是通过周围的词来预测上下文，而是通过周围的句子来预测目标句子。典型的例子是用上一句和下一句来预测当前句。Kiros et al. (2015)从上面的例子中，* 上一句:我回到了家。 * 我能看见台阶上的猫。 * 下一句:这很奇怪。第二，单词嵌入提供了更好的单词表示，而不考虑句子中的顺序。递归神经网络(RNN)可以处理句子中的单词顺序，但 skip-thoughts 也会考虑这个问题。作者证明了该模型能够捕获句子的语义和句法，从而可以将高质量的嵌入结果转移到下游问题。# 体系结构该模型遵循编码器-解码器框架架构来计算矢量。在神经网络层，它可以是 GRU(门控循环单元)，LSTM(长短期记忆)或注意机制。***编码器*** :输入的是每句话的词向量序列，传递给 RNN (GRU 或 LSTM)。经过训练的模型，将用于下游任务，如分类问题。***解码器*** :解码器的架构与编码器类似，只是引入了一些矩阵。此外，有两个解码器而不是一个。第一个是为了消耗上一个句子而决定的，而第二个是为了消耗下一个句子。不同之处在于它们彼此之间不共享解码器权重(隐藏状态),但是它们共享词汇向量。解码器帮助训练编码器，之后就不再使用了。“gray concrete post on seashore under gray sky” by [Perminder Klair](https://unsplash.com/@perminder_klair?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)**其思想是使用预先训练的嵌入(例如 word2vec)作为输入(即 x 或特征)和输出(即 y 或标签)是嵌入层的另一个维度。以便它可以“预测”每个单词的嵌入，即使它从未在训练数据中出现过。**Kiros et al. (2015). Showing the nearest neighbors of words after vocabulary expansion. For example, “chorepgraph” is OOV and the the nearest neighbors of words are “choreography“, “choreographs”.文中没有详细的解释，所以我进一步研究了源代码，以了解它是如何工作的。你也可以参考[源代码](https://github.com/ryankiros/skip-thoughts/blob/master/training/tools.py) (train_regresso 函数)来浏览它。根据 Kiros 等人的设计，有两种方法，即单跳和双跳。Uni-skip 指使用单向神经网络来构建句子嵌入，而 bi-skip 使用双向 RNN (LSTM 或 GRU)来构建句子嵌入。单跳(或双跳)的输出是句子的 2400 维(如果使用组合跳过方法，则是 4800 维)。我们可以通过给定下游任务(例如分类)输出来训练模型。# 履行最初的作者是 Kiros 等人，他们通过 Theano 实现了跳过思想。有 Pytorch，Tensorflow 和 Keras 版本可用。我将使用 Pytorch 版本来演示我们如何将数据转换成句子向量。对于其他人，您可以查看参考资料部分提到的 githubs。给定预先训练好的模型、词汇文件和输入(句子)，你将得到 2400 维向量的输出(对于 uni-skip)。# 拿走要访问所有代码，你可以访问我的 [github](https://github.com/makcedward/nlp/blob/master/sample/nlp-skip_thoughts.ipynb) repo。* skip-thoughts 和 skip-gram 都是**无监督学习**。 * Skip-thoughts 的目标是学习一个**句子级向量**而不是单词向量。 * 由于它是固定的句子表示，如果你的“句子”很长，它将消耗大量的内存。它不应该用于段落或文档嵌入。# 参考* Ryan Kiros、Yukun Zhu、Ruslan Salakhutdinov、Richard S. Zemel、Antonio Torralba、Raquel Urtasun 和 Sanja Fidler。[跳过思维向量](http://arxiv.org/abs/1506.06726) * s[kip-thinks the ano github](https://github.com/ryankiros/skip-thoughts) * [Skip-thought py torch github](https://github.com/Cadene/skip-thoughts.torch/tree/master/pytorch) * [Skip-Thoughts tensor flow github](https://github.com/tensorflow/models/tree/master/research/skip_thoughts) * [Skip-Thoughts Keras github](https://github.com/phdowling/skip-thought-keras)# 转变数据驱动的文化从顶层开始:如何让你的 CTO 接受数据驱动的战略> 原文：<https://towardsdatascience.com/transforming-the-data-driven-culture-starts-from-the-top-how-to-get-your-cto-to-embrace-c2e5af868eba?source=collection_archive---------7----------------------->Teamwork makes the (Data) Dream work在之前的一篇文章中，我讨论了为什么公司需要[数据战略，而不仅仅是更多的数据人员](/become-data-driven-or-perish-why-your-company-needs-a-data-strategy-and-not-just-more-data-people-aa5d435c2f9)，在这篇文章中，我想分解一下头号原因，为什么大多数想要成为数据驱动的公司都在为之奋斗，以及如何克服它。正如我在之前的帖子中所描述的那样，“[要么成为数据驱动，要么灭亡](/become-data-driven-or-perish-why-your-company-needs-a-data-strategy-and-not-just-more-data-people-aa5d435c2f9)”，在开始实施您的战略之前，任何组织都需要经历四个步骤。即； — *第一*，让专人负责数据， — *第二*，将组织的关键抱负与数据价值链结合起来，*第三*，根据这些抱负制定战略， — *第四*，吸引实现战略所需的人才。## 技术驱动还是数据驱动每当我讨论为什么有人需要对公司的数据负责时，我经常会注意到，首席技术官或开发部门的负责人对为什么有必要这样做最为关键。他们批评的原因不是来自对数据的不信任，而是来自这样一种观念，即大多数首席技术官看不到成为数据驱动的投资回报，更不用说引入一个完全负责数据的新高管了。大多数首席技术官将检查组织的短期和长期技术需求视为自己的责任，并利用资本进行旨在帮助组织实现其目标的投资，但直到现在，大多数公司尚未证明在分析、数据科学、大数据、机器学习和人工智能方面的资本投资，以说服大多数首席技术官做出这一决定。因此，当讨论作为驱动因素的数据时，CTO 的第一反应通常是技术不应该由数据战略决定，而是开发解决方案所需的技术应该是其他人可以获得数据并将结果用于决策的基础。举例来说，如果你正在建立一家科技公司，创始人处于发展的早期阶段，首席执行官将为客户的需求列出案例，他或她可能充当产品所有者(在没有 CPO 的情况下)，并列出需要建立什么来解决客户的问题。然后由 CTO 决定并创建构建它所必需的基础设施。大多数 CTO 会根据他们以前的经验来构建产品，使用他们最熟悉的堆栈，通常不会担心未来的需求。他们正在构建的最低可行产品需要解决最初的问题，随着公司的发展，首席技术官的工作将发生变化，寻找新的方法来扩展平台的基础设施和功能。因此，当你引入首席数据官、数据主管或其他任何负责数据的人时，就会带来看待基础设施和已构建内容的不同方式，这导致大多数首席技术官的本能反应。例如，一家正在开发应用程序的公司(想象下一个[优步](https://www.uber.com/)、 [Tinder](https://tinder.com/) 或 [WhatsApp](https://www.whatsapp.com/) )可以决定使用 [Apache Tomcat](http://tomcat.apache.org/) 作为应用程序服务器，使用 [JAVA](https://www.java.com/) 应用程序编写代码，使用 [PostgreSQL](https://www.postgresql.org/) 作为数据库，所有这些都在 Linux 服务器上运行。这听起来是一个很好的开始，但随着成功和增长的到来，引入数据驱动的工作方式和可扩展性，将需要对平台的核心进行重大改变，以允许真正实现数据驱动所需的分析和数据科学功能。## **如何对付一个有抵抗力的 CTO？**就在不久前，CTO 的角色被引入。在 20 世纪 90 年代末和 21 世纪初，首席信息官(CIO)负责监管 IT，但随着信息技术复杂性的不断升级，许多公司将 CIO 的部分职责分配给了 CTO。现在大多数新公司都是技术驱动的，所以首席信息官的角色已经完全被首席技术官取代了。在以信息技术为关键的大多数网络公司或其他技术导向型公司中，首席技术官负责确定如何利用技术来实施业务战略，但随后，首席技术官负责实际集成和运行技术，即“运营经理”的角色。随着大数据、机器学习和人工智能为公司提供了真正实现数据驱动的机会，首席技术官需要知道，CDO 或数据主管的角色不是取代或威胁首席技术官，而是成为在技术堆栈中实施新的数据驱动技术的合作伙伴。**提供数据驱动型公司将新技术融入现有体系的例子** 通过真正了解公司当前的基础设施、底层技术并研究哪些产品符合已构建的体系，CTO 数据主管可以将首席技术官转变为拥护者而不是反对者。通过展示核心基础架构如何保持不变，但数据是位于技术基础架构之上的层，CTO 可以看到，即使是非常小的投资也可以使技术变得更好。**从 MVP 开始，让结果自己说话** 幸运的是，在过去二十年中，设备的处理能力显著增强，以至于数据分析师/数据科学家可以使用像 [RStudio](https://www.rstudio.com/) 或 [Python](https://www.python.org/) 这样的应用来创建一个最小的可行产品。如果可以通过命令行访问数据库，有一些简单的方法可以将数据直接导入 RStudio 或 Python。使用不同的包，数据分析师可以创建仪表板，以显示分析如何为企业提供对存储在数据库中的数据的洞察。数据科学家可以更进一步，展示如何清理、处理和组织(大)数据，从而产生新产品或服务或增强现有产品或服务。在本地展示这一点，可以为可以与现有技术集成的生产版本打开大门。**创建一个非技术性用例来阐述您的观点** 随着业务从非数字化向数字化的转变，我们能够访问公司外部生成的数据。从营销、销售到人力资源，一切都产生数据，这些数据提供了改进和构建用例的机会，以展示数据驱动的潜力。该网站采用了 [Google Analytics](https://www.google.com/analytics/) ，使公司能够改善网站性能，增加销售线索或销售更多产品。通过 [Mailchimp](https://mailchimp.com/) 进行的电子邮件营销，通过 [HubSpot](https://www.hubspot.com/) 进行的客户关系管理，或者通过 [ADP](https://www.adp.nl/) 进行的人力资源管理，都提供了大量的数据，这些数据可用于提高转化率、交付周期或揭示对员工行为的洞察。通过使用非核心数据来改善业务，可以向董事会成员展示成为数据驱动型企业的好处，并为首席技术官的参与提供依据。## **不要勉强**最终，这一切都归结于改变一个组织的文化，不是通过推动或自上而下的执行，而是通过建立一个案例，说明为什么数据应该得到高管的充分关注。就像二十年前，当公司开始雇佣首席技术官时，因为技术驱动的方法创造了世界上最大的一些公司。信息时代的最新阶段，让那些真正接受数据驱动的工作方式的公司，有能力使自己与众不同，抢占市场份额和利润，而那些不愿意适应的公司则被搁置一旁。## 感谢阅读；)，如果你喜欢它，请点击下面的掌声按钮，这对我意义重大，也有助于其他人了解这个故事。通过联系 Twitter 或 Linkedin 让我知道你的想法。# 将 SQL 翻译成熊猫> 原文：<https://towardsdatascience.com/translating-sql-to-pandas-8f4ae0268899?source=collection_archive---------16----------------------->Photo by [Aaron Burden](https://unsplash.com/photos/Qy-CBKUg_X8?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/search/photos/autumn-aerial-landscape?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)## 两者都做相似或相同的事情，但方式不同就像一个有 SQL 背景的人和一个经常使用 SQL 的人一样，熊猫的第一步对我来说有点困难。我总是从 SQL 的角度思考，然后想知道为什么 pandas 如此不直观。但是随着时间的推移，我习惯了一种语法，并发现了这两者之间的联系。所以我决定创建一个翻译成熊猫语言的基本 SQL 命令的备忘单。## 挑选最简单的 SQL 语句如下所示:``` # Select everything from table1 SELECT * FROM table1 ```在 2010 年，熊猫看起来会像:``` df.head() ```尽管在默认情况下，pandas 将只显示前 5 行，但是 SQL 中的内容相当于 LIMIT 5 或 TOP (5)(取决于 DBMS)。同样，只需在终端中输入`df`,就会显示数据帧的第一行和最后 15 行。为了选择 SQL 中的特定列，我们将编写下一个查询:``` SELECT column1, column2 FROM table1 ```在熊猫身上会这样写:``` df[['column1', 'column2']] ```## 在哪里通常，我们希望选择具有特定标准的数据，在 SQL 中，这将使用 WHERE 子句来完成:``` SELECT column1, column2 FROM table1 WHERE column1 = 2 ```在熊猫中，相同的查询看起来略有不同:``` df[['column1', 'column2']].loc[df['column1'] == 2] ```WHERE 子句接受逻辑运算符——pandas 也是如此。所以这个 SQL 查询:``` SELECT * FROM table1 WHERE column1 > 1 AND column2 < 25 ```在熊猫中采用以下形式:``` df.loc[(df['column1'] > 1) & (df['column2'] < 25)] ```pandas 中的 or 运算符是“|”，而不是—“~”。注意括号——它是强制的。``` df.loc[(df['column1'] > 1) | ~(df['column2'] < 25)] ```SQL WHERE 子句还接受更复杂的比较，例如:LIKE、IN 和 BETWEEN 熊猫也有能力做到这一点——只是方式不同。让我们创建一个使用所有这些运算符的查询:``` SELECT * FROM table1 WHERE column1 BETWEEN 1 and 5 AND column2 IN (20,30,40,50) AND column3 LIKE '%arcelona%' ```pandas 中的相同查询(都是一行):``` df.loc[(df['colum1'].between(1,5)) & (df['column2'].isin([20,30,40,50])) & (df['column3'].str.contains('arcelona'))] ```关于这些方法的更多细节可以在文档中找到:[在](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.isin.html)，[在](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.between.html)，[之间，如。](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.str.contains.html)## 加入在数据科学家的日常工作中，连接表是一种常见的做法，在 SQL 中，我们使用 4 种不同类型的连接来连接表:内连接、左连接、右连接和全连接。该查询如下所示:``` SELECT t1.column1, t2.column1 FROM table1 t1 INNER JOIN table2 t2 ON t1.column_id = t2.column_id ```对于所有的连接，语法都是相同的，所以我们只需将 INNER 更改为剩下的 3 种类型中的任意一种。在 pandas 中，这个操作最好分两步完成——首先执行 join，然后选择我们需要的数据(尽管它可以在一行中完成):``` df_joined = df1.join(df2, on='column_id', how='inner') df_joined.loc[['column1_df1', 'column1_df2']] ```如果没有指定参数`on`和`how`，pandas 将使用索引作为键列来执行左连接。## 分组依据分组使我们能够获得关于数据的一些聚合信息:计数、总和、AVG、最小值、最大值等等:``` SELECT column1, count(*) FROM table1 GROUP BY column1 ```熊猫也有这种灵活性:``` df.groupby('column1')['column1'].count() ```我们必须在方括号中指定列名，以便在结果中只包含该列，否则我们将得到给定数据帧中每列的计数。如果我们想要得到按列 1 分组的列 2 中所有值的总和(例如，每个商店的总销售额)，并且只显示那些已经达到某个级别的值，比如说超过 1000 个单位，我们将在 SQL 中执行以下操作:``` SELECT store, sum(sales) FROM table1 GROUP BY store HAVING sum(sales) > 1000 ```在 pandas 中，我们没有 HAVING 子句的特权，但我们仍然可以通过两个步骤做到这一点:首先对数据进行分组，然后进行过滤:``` df_grouped = df.groupby('store')['sales'].sum() df_grouped.loc[df_grouped > 1000] ```## 以...排序为了在 SQL 中对结果进行排序，我们使用 ORDER BY 子句，它总是最后一个从数据库中获取结果。为了选择表中的所有值并按列 1 降序排序，我们编写了下一个查询:``` SELECT * FROM table1 ORDER BY column1 DESC ```在 pandas 中，同样的查询看起来像:``` df.sort_values(by=['column1'], ascending=False) ```这个对我来说是最直观最清晰的。虽然，当你练习更多的时候，所有这些语法差异不再困扰你。我们可以用 SQL 和 pandas 编写更复杂的查询，但是这种基本的对齐对我帮助很大，我相信对其他 SQL server 也有帮助。Pandas 是一个非常强大的库，让你以一种非常有效的方式提取、转换、清理你的数据。更多信息可以在我的文章[“在 Python 中提取和转换数据”](/extracting-and-transforming-data-in-python-63291f63d350)和[“在 Python 中清理和准备数据”](/cleaning-and-preparing-data-in-python-494a9d51a878)中找到感谢您的阅读，祝您有美好的一天！*原载于 2018 年 11 月 25 日*[*sergilehkyi.com*](http://sergilehkyi.com/translating-sql-to-pandas/)*。*# 大数据和小数据的透明数据挖掘> 原文：<https://towardsdatascience.com/transparent-data-mining-for-big-and-small-data-6564ca7bc004?source=collection_archive---------6----------------------->我和[塔妮娅](http://dbdmg.polito.it/tcerquitelli/)([@塔妮娅 _ 托里诺](https://twitter.com/tania_torino))和[弗兰克](https://www.law.umaryland.edu/faculty/profiles/faculty.html?facultynum=984)([@弗兰克帕斯夸莱](http://twitter.com/FrankPasquale))合编的[书现在出了！长话短说，这里有一个总结。算法正在越来越多地影响我们的生活，然而它们背后的过程是隐藏的——它们通常像黑盒一样工作。这本书为更好的算法提供了设计原则。世界知名专家介绍了各种旨在提高透明度的解决方案，这些方案不仅是算法上的，也是监管上的。](http://www.springer.com/gp/book/9783319540238)**前言**(说来话长)算法正越来越多地影响着我们的生活。他们通过推荐最小化风险的活动来促进健康习惯，通过从多个来源估计信用评分来促进金融交易，并通过描述购买模式来推荐购买什么。他们所做的一切不仅基于人们直接披露的数据，还基于从行为模式和社交网络中推断出来的数据。算法影响着我们，然而它们背后的过程却是隐藏的。他们经常作为黑盒工作。由于缺乏透明度，不道德行为是可能的。由于有偏见的训练数据，算法可以只为人口的子集推荐最小化健康风险的活动。他们可能会基于与种族不完全相关的因素拒绝抵押贷款，从而延续种族歧视。他们可能通过向有支付能力的人提供更高的网上购物价格来促进不公平的价格歧视。在秘密和复杂性的笼罩下，算法决策很可能会延续偏见和成见。这本书为更好的算法提供了设计原则。为了便于阅读，本书分为三个部分，分别针对不同背景的读者。*为确保透明采矿，解决方案首先应增加透明度(第一部分)，此外，它们不仅应是算法性的(第二部分)，还应是监管性的(第三部分)。*首先从第一部分开始，算法越来越多地被用于对公共产品(如健康、安全、金融、就业)做出更好的决策，透明度和问责制等要求也是急需的。[章节“数据的暴政？《数据驱动的社会公益决策的光明面和黑暗面》](https://link.springer.com/chapter/10.1007/978-3-319-54024-5_1)([pdf 预印本](https://arxiv.org/pdf/1612.00323.pdf))、Lepri *等人(* [@brulepri](https://twitter.com/brulepri?lang=en) 、@ [dsango](https://twitter.com/dsango) 、[@ brulepri](https://twitter.com/brulepri)[@ stja co](https://twitter.com/stjaco)[@ nuriaoliver](https://twitter.com/nuriaoliver)[@ ManuLetouze](https://twitter.com/ManuLetouze)*)*提出了一些关键观点在“后真相”政治时代——政治上使用“感觉真实”但没有事实依据的断言——新闻媒体也可能受益于透明度。如今，算法被用于制作、分发和过滤新闻文章。在“[启用算法媒体的责任:作为建设性和批判性透镜的透明性](https://link.springer.com/chapter/10.1007%2F978-3-319-54024-5_2)一章中，Diakopoulos([@ ndiakopoulos](http://twitter.com/ndiakopoulos))介绍了一个模型，该模型列举了可能被披露的关于这种算法的不同类型的信息。通过这样做，该模式实现了透明度和媒体问责制。更一般地说，为了支持整个网络的透明度，[普林斯顿网络透明度和问责制项目](https://webtap.princeton.edu)(第"[章普林斯顿网络透明度和问责制项目](https://link.springer.com/chapter/10.1007%2F978-3-319-54024-5_3) ") ( [pdf 预印本](http://randomwalker.info/publications/webtap-chapter.pdf))持续监控了数千个网站，以揭示用户数据是如何被收集和使用的，潜在地减少了信息不对称(更多更新来自 [@random_walker](https://twitter.com/random_walker?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor) )。更好算法的设计原则也是算法的本质，这就是为什么**第二部分**关注算法解决方案。达塔*等人*引入了一系列量化不同输入数据对输出的影响程度的方法(章节“[通过量化输入影响实现算法透明](https://link.springer.com/chapter/10.1007/978-3-319-54024-5_4)”)。这些措施被称为定量输入影响(QII)措施，有助于确定各种算法中的歧视和偏见，包括黑箱算法(只需要完全控制输入和完全观察输出)。但并不是所有的算法都是黑盒。基于规则的分类器可以很容易地被人类理解，但是它们已经被证明不如最先进的算法准确。这也是因为无效的传统训练方法。为了部分解决这个问题，Malioutov 等人在章节[用布尔压缩感知学习可解释分类规则](https://link.springer.com/chapter/10.1007/978-3-319-54024-5_5)中提出了训练基于布尔规则的分类器的新方法。这些方法不仅在理论上有充分的依据，而且在实践中也证明是准确的。尽管如此，深度神经网络所达到的精确度迄今为止还是无人能敌。大量的训练数据被输入到神经元的输入层，信息被处理到几个(中间)隐藏层，结果从输出层出来。为了揭示这些隐藏层，最近提出了神经网络内部功能的可视化方法。Seifert 等人提供了这些方法的综合概述，并且他们是在计算机视觉的背景下这样做的(第“[章计算机视觉中深度神经网络的可视化:调查](https://link.springer.com/chapter/10.1007%2F978-3-319-54024-5_6)”)。最后，**第三部分**详细介绍了与数据发布和处理相关的监管解决方案——在私有数据的基础上，创建模型，这些模型反过来又产生算法决策。这里有三个步骤。第一个问题涉及数据发布。当前的隐私法规(包括“最终用户许可协议”)没有为个人提供足够的保护。Hutton 和 Henderson (@ [tnhh](https://twitter.com/tnhh) )介绍了获得持续和有意义的同意的新方法(章节“[超越 EULA:改善数据挖掘的同意](https://link.springer.com/chapter/10.1007%2F978-3-319-54024-5_7)”)。第二步涉及数据模型。尽管从私人数据中生成，但算法生成的模型在严格的法律意义上并不是个人数据。为了将隐私保护扩展到这些新兴模型，Giovanni Comandè提出了一种新的监管方法(第"[章)监管算法的监管？第一伦理——算法的法律原则、问题和机遇](https://link.springer.com/chapter/10.1007%2F978-3-319-54024-5_8))。最后，第三步涉及算法决策。在章节“[中，一个监督组织在确保算法问责中能扮演什么角色？](https://link.springer.com/chapter/10.1007%2F978-3-319-54024-5_9)"，[算法手表](https://algorithmwatch.org)呈现(作者 [@spielkamp](http://twitter.com/spielkamp) )。这是一个监督和倡导倡议，分析算法决策对人类行为的影响，并使它们更加透明和可理解。在我们的社会中，数据挖掘有着巨大的潜力，但需要更多的透明度和问责制。这本书只介绍了一些开始出现的令人鼓舞的倡议。# 垃圾还是宝藏——如何判断分类算法是否有用> 原文：<https://towardsdatascience.com/trash-or-treasure-how-to-tell-if-a-classification-algorithm-is-any-good-cb491180b7a6?source=collection_archive---------8----------------------->这是一系列文章中的第四篇，旨在使机器学习对那些没有受过技术培训的人来说更容易理解。以前的文章介绍了机器学习的概念，展示了学习的一般过程，并描述了常用的算法。你可以在这里开始[](/what-is-machine-learning-891f23e848da)**系列。***在本系列的这一部分中，我们回顾了在评估分类算法的有效性和价值时的一些常见度量和注意事项。**首先，让我们假设已经在训练集上开发了一个算法，并且该算法具有良好的泛化能力。我们现在考虑如何在测试集上测量算法的性能。如果你没有理解我刚才说的话，你需要回到[这一期](/how-does-machine-learning-work-6dd97f2be46c)。*## *混乱矩阵**让我们假设我们的算法是一个简单的离散分类器，如果实例被预测为感兴趣的类的一部分(肯定)，则返回 p，否则返回 n(否定)。我们还假设，在测试集中的实际数据中，p '代表正实例，n '代表负实例。回想一下以前的一篇文章中关于真阳性(TP)、真阴性(TN)、假阳性(FP)和假阴性(FN)的定义:**TP = p 和 p '**TN = n 和 n '**FP = p 和 n '**FN = n 和 p '**在一个矩阵中显示其中每一个的总实例是有用的，该矩阵被称为*混淆矩阵*(或*误差矩阵*或*列联表*)，例如:****从混淆矩阵中可以计算出许多有价值的度量，如下所示:** ***精度** = (TP + TN)/(P + N)。准确度是所有被正确预测的实例的比例*。** * ****精度** = TP/P，精度是*准确预测阳性的比例*。** * ****TP 速率**或**召回**或**灵敏度**= TP/P’。TP 率是准确预测的阳性样本的比例*。*** * *****FP 率**= FP/N’。FP 率是被错误预测为阳性的阴性样本的*比例*。*** * ****特异性**= TN/N’= 1-FP 率。特异性是正确预测的阴性样本的比例*。******根据具体情况，数据科学家对所有这些指标都感兴趣。然而，特别令人感兴趣的是 TP 率和 FP 率之间的权衡。对于一个有价值的算法，它需要正确地分类正例(好处)，同时确保被错误地分类为正例(代价)的负例的数量保持在可接受的水平。***## ***混淆矩阵示例******让我们回到我们最初的例子从[分期付款 2](/how-does-machine-learning-work-6dd97f2be46c) 。让我们假设我们开发了一种算法，可以预测哪些工作申请是“高潜力”的。******该算法只返回“HP”或“Not HP”。我们通过 500 份以前的工作申请测试集运行我们的算法，并生成这个混淆矩阵:************因此，对于该算法，我们可以计算:**** ***准确率= 80%。五分之四的测试集实例被正确预测。*** * ***精度= 50%。一半的正面预测是准确的。*** * ***TP 率= 75%。四分之三的正面例子被正确预测。*** * ***FP 率= 19%。大约五分之一的负面例子被错误地预测为正面。*** * ***特异性= 81%。大约五分之四的负面例子被正确预测。******虽然 75%的 TP 率本身可能被认为是非常好的，但它是以 19%的 FP 率为代价实现的。这个 FP 率可能高得不可接受。假设可以实现 TP 速率和 FP 速率的可接受平衡，这取决于人类决策者与数据科学家的合作。通常有必要将数量作为决策的一部分。如果公司收到 5000 份申请，这意味着几乎有 1000 份会被错误地归类为“高潜力”，公司可能没有能力处理这些。***## ***ROC 图******考虑到 TP 速率和 FP 速率之间的折衷如此令人感兴趣，通过在二维图上绘制 TP 速率和 FP 速率来可视化和比较算法是很自然的。这样的图叫做 *ROC 图*。(接收机工作特性，这个术语源于第二次世界大战期间的工程和雷达发展)。*****使用我们上面的“高潜力”示例，并假设数据科学家开发了其他四种具有不同 TP 和 FP 速率的算法，我们可以使用 ROC 图来比较这些算法，下面绘制的算法 A 与上一节中讨论的算法 A 相同。我们可以立即确定算法 C 是性能最好的算法。算法 E 是一个完全随机的算法，它选择相同比率的真阳性和假阳性。算法 B 比真阳性更能识别假阳性。******## **ROC 曲线****现在让我们假设我们的算法是一个概率分类器，并返回实例落入某一类的概率。在这种情况下，混淆矩阵只能基于“截止”概率来确定。****使用我们的示例，我们可以想象算法可能已经为测试集中的每个应用程序计算了一个概率，并且公司可能已经决定尝试将截止值 0.8 作为被视为“高潜力”的最小概率。****因此，这种概率分类器对于不同的截止点将具有不同的混淆矩阵，因此 TP 率和 FP 率将根据所应用的截止点而变化。****在这种情况下，画出算法的 *ROC 曲线*是有帮助的，也就是画出当使用不同的截断点时 TP 率和 FP 率如何相对于彼此变化。随着截止点的降低，TP 率保持不变或增加。****因此，FP 率也必须保持不变或增加。这种曲线被称为*洛伦兹曲线*。****下面给出了我们的概率“高潜力”算法的 ROC 曲线的一个例子，给出了我们前面的例子中用 x 标记的具体截止点。********ROC 曲线可以与体积因素结合使用，以确定概率分类器的最佳截止点。如果数量是一个问题，例如如果组织的资源是有限的，那么就需要尽量减少误报。否则，更高水平的假阳性可以被接受为高 TP 率的折衷。**## **什么是“好的”ROC 曲线？****想象一下，我们开发了一个完全随机的概率分类算法，在每个截止点，以相同的速度识别真阳性和假阳性。如果我们在 ROC 图上绘制这样一个分类器，它看起来就像一条连接点(0，0)和点(100，100)的对角线。这种算法对我们没有价值，因为我们还不如用盲目的运气来分类我们的数据集。****通常，如果我们正在测量一个已经在测试集上开发并具有良好泛化能力的算法，该算法将明显优于随机分类器，其 ROC 曲线将采取凸形式，如这里所示的两个算法 A 和 B。********很明显，ROC 图上的“黄金区域”是左上角，这里有高 TP 率和低 FP 率。因此，数据科学家喜欢看到 ROC 曲线的顶点尽可能深入 ROC 图的这个角落。****在这种情况下，数据科学家可能会根据 ROC 曲线的比较，认为算法 B 比算法 A“更好”。**## **曲线下面积****假设观察到“好的”ROC 曲线的顶点尽可能位于 ROC 图的左上方，ROC 曲线下方的面积可以作为算法强度的一般指标。曲线占据的面积越大，曲线占据 ROC 图左上方“黄金区域”的可能性就越大。****因此，曲线下的*面积，或 *AUC* ，通常被用作概率分类器强度的一般指标。注意，随机分类器的 AUC 是 50%,因此理想情况下，一种有前途的算法将显示出显著高于此的 AUC，并且通常大于 80%。这是一个例子。******请注意，AUC 与基尼系数是线性等价的，基尼系数是衡量财富分配的一个常用宏观经济指标。具体来说，***基尼= 2 × AUC — 1* 。**AUC 作为概率分类器强度的一般度量表现得非常好。但是，应该谨慎使用。完全有可能产生高 AUC 的算法在 ROC 图上感兴趣的特定点表现不佳。下面举例说明了具有相似 AUC 的两种算法，但是这些算法的性能根据 ROC 图上的兴趣点而有很大不同。***## *摘要**总结这一期的观察结果:*1. *可以使用简单的混淆矩阵以及诸如准确度、TP 率、FP 率等度量来评估离散分类器。这些措施，结合对容量的考虑，可以帮助确定算法是否满足操作要求。* 2. *概率分类器可以使用 ROC 曲线绘制。曲线下面积(AUC)是算法预测效用的良好通用指标，AUC 大于 80%应为目标。然而，即使 AUC 很高，也有必要更深入地观察 ROC 图中感兴趣的特定点，并考虑体积因素，以确定是否存在符合操作要求的临界值。**下一次，为了结束这个系列，我将提供一个与机器学习相关的关键术语的词汇表‘备忘单’。找到它 [*这里*](/bluff-the-bots-a-glossary-of-key-terms-in-machine-learning-3d528c8d86f4) *。**# 基于机器学习和遗传算法的行程时间优化> 原文：<https://towardsdatascience.com/travel-time-optimization-with-machine-learning-and-genetic-algorithm-71b40a3a4c2?source=collection_archive---------2----------------------->机器学习和优化有什么关系？—一方面，在模型训练期间，当我们试图最小化模型和数据点之间的错误成本时，数学优化被用于机器学习。另一方面，用机器学习解决优化问题会怎么样？考虑一下:一个有 25 个包裹的 UPS 司机有 15 万亿条可能的路线可供选择。如果每个司机每天多开一英里，公司每年将损失 3000 万美元。虽然 UPS 拥有他们卡车和路线的所有数据，但他们不可能在每个司机带着 25 个包裹的情况下运行 15 万亿次计算。然而，这个旅行推销员问题可以用一种叫做“遗传算法”的东西来解决这里的问题是，这种算法需要一些输入，比如每对位置之间的旅行时间，而 UPS 没有这些信息，因为地址的组合甚至超过万亿。但是如果我们使用机器学习的预测能力来增强遗传算法呢？# **想法**简单来说，我们可以使用机器学习的力量来预测每两个位置之间的旅行时间，并使用遗传算法来为我们的送货卡车找到最佳的旅行路线。我们遇到的第一个问题是，没有商业公司会与陌生人分享他们的数据。那么，在没有数据的情况下，我们如何进行这样一个项目——其目标是帮助像 UPS 这样的服务？我们可以使用哪些数据集来很好地代表我们的送货卡车？那么，出租车呢？—就像送货车一样，是机动车辆，运送的是……人。幸运的是，出租车数据集是公开的，因为它们是提供给市政府的。下图说明了项目的设计:我们从出租车数据开始，使用这些数据来预测位置之间的行程时间，然后运行遗传算法来优化总行程时间。我们也可以倒着看图表:为了优化旅行时间，我们需要知道每对点从一个点到另一个点需要多长时间，为了获得这些信息，我们使用基于出租车数据的预测建模。# 数据和特征工程为了便于说明，让我们坚持使用[这个 Kaggle 数据集](https://www.kaggle.com/c/nyc-taxi-trip-duration/data)，它是纽约市提供的[完整出租车数据集](http://www.nyc.gov/html/tlc/html/about/trip_record_data.shtml)的样本。Kaggle 上的数据集通常处理得很好，并不总是需要很多工作(如果您想练习数据清理，这是一个缺点)，但查看数据以检查错误并考虑特征选择总是很重要的。既然我们得到了每个位置的坐标，让我们计算每对点之间的曼哈顿距离，并计算经度和纬度的差异，以获得方向感(从东到西，从北到南)。我们可以稍微清理一下时间戳，保留最初的特性，这些特性乍一看可能对我们没有用。当处理地理空间数据时，Tableau 是在 pandas 中映射数据点的一个非常有用的替代方法。在地图上快速初步检查显示，一些下车地点在加拿大，在太平洋，或在爱丽丝岛(自由女神像)，在那里汽车根本不去。如果没有内置的面向地理的包，删除这些点是一项非常困难的任务，但我们也可以将它们留在数据中，因为一些机器学习模型可以很好地处理离群值。In Tableau, we can quickly get a sense of our drop off locations and their density, as well as outliers.作为奖励，Kaggle 方便地为[提供了 2016 年](https://www.kaggle.com/mathijs/weather-data-in-new-york-city-2016)纽约市天气的数据。这是我们在分析中可能要考虑的事情。但是，因为有许多相似的天气条件——部分多云或大部分多云——让我们把它们分成几个主要的天气条件，以便对这些特定的特征有一个较小的变化。我们可以在熊猫身上这样做:``` sample_df["Conditions"] = sample_df["Conditions"].fillna('Unknown')weather_dict = {'Overcast' : 0, 'Haze' : 0,'Partly Cloudy' : 0, 'Mostly Cloudy' : 0, 'Scattered Clouds' : 0, 'Light Freezing Fog' : 0,'Unknown' : 1,'Clear' : 2, 'Heavy Rain' : 3, 'Rain' : 3, 'Light Freezing Rain' : 3,'Light Rain' : 3, 'Heavy Snow' : 4,'Light Snow' : 4,'Snow' : 4}sample_df["Conditions"] = sample_df["Conditions"].apply(**lambda** x: weather_dict[x]) ```# 选择正确的模型有了我们的数据和目标，简单的线性回归就不行了。我们不仅希望有一个低方差模型，我们还知道坐标虽然是数字，但对于给定的目标变量并不携带数值。此外，我们希望将路线的方向添加为正或负的数值，并尝试用天气数据集补充模型，这几乎是完全明确的。在一个巨大的数据集中有一些随机的异常值，可能有一些无关的特征，以及一些可能的分类特征，我们需要一个基于树的模型。具体来说，提升树将在这个特定的数据集上表现得非常好，并且能够容易地捕捉非线性关系，适应复杂性，并处理分类特征。除了标准的 XGBoost 模型，我们还可以尝试 LightGBM 模型，因为它速度更快，对分类特性的编码也更好。将这些特征编码为整数后，只需用分类变量指定列，模型就会相应地处理:``` bst = lgb.train(params,dtrain,num_boost_round = nrounds,valid_sets = [dtrain, dval],valid_names = ['train', 'valid'],categorical_feature = [20, 24]) ```这些模型很容易建立，但是很难微调和解释。Kaggle 方便地提供均方根对数误差(RMSLE)作为评估指标，因为它降低了误差幅度。使用 RMSLE，我们可以运行不同的树深度和学习率参数，并比较结果。让我们还创建一个验证“观察列表”集，以便在模型迭代时跟踪错误:``` dtrain = xgb.DMatrix(X_train, np.log(y_train+1)) dval = xgb.DMatrix(X_val, np.log(y_val+1))watchlist = [(dval, 'eval'), (dtrain, 'train')]gbm = xgb.train(params,dtrain,num_boost_round = nrounds,evals = watchlist,verbose_eval = **True**) ```# 遗传算法优化现在，机器学习部分只是项目的第一步。一旦模型被训练和保存，我们就可以开始遗传算法。对于那些不知道的人来说，在遗传算法中，一个优化问题的候选解群体朝着更好的解进化，每个候选解都有一组可以变异和改变的属性。基本上，我们从问题的随机解决方案开始，并尝试基于一些适合度来“进化”解决方案。结果不能保证是可能的最佳解决方案，但应该足够接近。假设我们在地图上有 11 个点。我们希望我们的送货卡车在同一天访问所有这些地点，我们想知道最佳路线。然而，我们不知道司机在每个点之间要花多长时间，因为我们没有所有地址组合的数据。这就是机器学习部分的用武之地。通过我们的预测模型，我们可以找出卡车从一个地点到另一个地点需要多长时间，并且我们可以对每一对点进行预测。当我们使用我们的模型作为遗传算法的一部分时，我们从每个点的随机访问顺序开始。然后，基于总旅行时间最短的适应度分数，该算法试图找到更好的访问顺序，从机器学习模型中获得预测。这个过程不断重复，直到我们找到一个接近理想的解决方案。# 结果在测试了这两个预测模型后，我惊讶地发现，没有天气数据的更基本的 XGBoost 比 LightGBM 表现略好，与 LightGBM 的 4.9 分钟相比，平均绝对误差为 4.8 分钟。在选择 XGBoost 并保存模型后，我将其传递给我的遗传算法，以生成一个样本解决方案并进行演示。这是最终结果的可视化:我们从一个给定的位置开始，遗传算法和机器学习可以为我们的送货卡车规划出最佳路线。请注意，在点 3–4–5–6 之间有一个小循环。如果你仔细看地图，你会看到建议的路线穿过高速公路，这是一个比住宅区更快更短的车程。此外，请注意，该演示并不是确切的路线规划，它只是建议访问顺序。# 后续步骤路线规划将是这个项目的下一个逻辑步骤。例如，可以整合 Google Maps API 并规划出每一对点之间的精确路径。此外，遗传算法假设一天中的静态时间。计算一天中的时间虽然重要，但要解决的问题要复杂得多，可能需要一种不同的方法来构建输入空间。如果您有任何问题、想法或建议，请随时通过 [LinkedIn](https://www.linkedin.com/in/vladimir-lazovskiy/) 联系我。代码和项目描述可以在 [GitHub](https://github.com/vlazovskiy/route-optimizer-machine-learning) 上找到。感谢阅读！# 趋势，季节性，移动平均，自回归模型:我的时间序列数据之旅> 原文：<https://towardsdatascience.com/trend-seasonality-moving-average-auto-regressive-model-my-journey-to-time-series-data-with-edc4c0c8284b?source=collection_archive---------3----------------------->GIF from this [website](https://giphy.com/gifs/animation-time-2d-3oz8xKaR836UJOYeOc/media)最近我一直在处理时间序列数据。我想回顾什么是时间序列，并使我对时间序列数据的理解更加一致。> **请注意，这篇文章是为了我未来的自己，也是为了让我对时间序列有更深入的了解。****定义**Image from this [website](https://en.wikipedia.org/wiki/Time_series)有多种不同的来源来定义术语“时间序列”，所以在这里我将尝试给出一个我自己容易理解的一般定义。Image from this [website](https://en.wikipedia.org/wiki/Time_series)> 一个**时间序列**是一系列按照时间顺序索引的[数据点](https://en.wikipedia.org/wiki/Data_point)。如上所述，wiki 给出了非常直截了当的定义，即按时间顺序排列的任何数据。现在让我们看看来自 [investopedia](https://www.investopedia.com/terms/t/timeseries.asp) 的定义。Image from this [website](https://www.investopedia.com/terms/t/timeseries.asp)> 时间序列是按连续顺序排列的数字数据点序列。如上所述，我们可以对时间序列数据有一个大概的了解。它可以是按顺序随时间记录的任何数据。一开始我们可以想到股票价格，但是视频、语言、歌曲和核磁共振扫描也可以想到时间序列数据。**时间序列数据的类型**Image from this [website](https://stats.stackexchange.com/questions/20053/how-to-aggregate-deal-with-time-series-data-in-multiple-markets)上面是一个股票价格的示例图像，我们可以观察到，x 轴上是时间指数，y 轴上是不同市场的股票价格。Image from this [website](https://www.wired.com/2016/12/watch-brain-flicker-activity-rests/)计算机视觉世界中时间序列数据的另一个很好的例子是视频(上面是 GIF)，因为我们在一个时间序列中一帧一帧地捕捉。我们可以清楚地看到 fMRI 扫描可以被命名为时间序列数据。**时序目标**Image from this [website](https://www.researchgate.net/figure/Raman-spectra-of-the-MCC-101-raw-material-with-123-water-content-top-and-of-the-MCC_fig11_8508180)时间序列的一个明显的用例是预测股票价格。(如果这很容易，许多数据科学家将会很富有。)但我想添加一些不同的用例，我们甚至可以使用 GAN 来预测给定视频的下一帧，或 MRI 扫描。想象一下，如果你体内有癌症，GAN 接收你的 MRI 扫描的几个序列并生成 MRI 扫描。(那会很酷。).所以一般来说，我们希望预测时间序列的下一个值。**趋势/季节性/噪音**Image from this [website](http://www.simafore.com/blog/bid/205420/Time-series-forecasting-understanding-trend-and-seasonality)在我们继续之前，我们需要讨论一些重要的东西，大多数时间序列数据可以由三个部分来描述。那就是趋势、季节性和偏差。**趋势** →随时间变化且不重复的一般系统线性或(最常见的)非线性成分 **季节性** →随时间变化且不重复的一般系统线性或(最常见的)非线性成分 **噪声** →在数据内非趋势/季节性的非系统成分**右图** → Python 代码创建可视化 **红线→**1985 年以来的苹果股价 **蓝线→** 苹果股价趋势 **绿线→** 苹果股价残差(噪声) **橙线** →苹果股价季节性(年度)趋势通过简单的代码和 [statsmodel](https://www.statsmodels.org/stable/index.html) 库，我们可以很容易地看到每个组件是如何相互关联的。我们可以观察到每年都有季节性的上涨，苹果股票价格的总趋势也是上涨的。**预测/预报方法****左/右图像** →标准窗口平均值/指数移动平均值当我们想要进行预测时，有许多不同的方法可以使用。我将提到我在研究中发现的方法。[**标准/指数移动平均**](https://en.wikipedia.org/wiki/Moving_average) →通过创建完整数据集不同子集的一系列[平均值](https://en.wikipedia.org/wiki/Average)来分析数据点的计算[**自动回归**](https://en.wikipedia.org/wiki/Autoregressive_model) →是一类[随机过程](https://en.wikipedia.org/wiki/Random_process)的代表；因此，在[自然](https://en.wikipedia.org/wiki/Natural_science)、[经济](https://en.wikipedia.org/wiki/Economics)等中，它被用来描述某些时变过程[**线性**](https://en.wikipedia.org/wiki/Linear_regression) **/** [**多项式回归**](https://en.wikipedia.org/wiki/Polynomial_regression) → [回归分析](https://en.wikipedia.org/wiki/Regression_analysis)其中[自变量](https://en.wikipedia.org/wiki/Independent_variable) *x* 与[因变量](https://en.wikipedia.org/wiki/Dependent_variable) *y* 之间的关系被建模为一个 *n* 次 p [多项式](https://en.wikipedia.org/wiki/Polynomial)(或 1 次线性)[**ARMA**](https://en.wikipedia.org/wiki/Autoregressive%E2%80%93moving-average_model)**→用两个多项式对[(弱)平稳随机过程](https://en.wikipedia.org/wiki/Stationary_stochastic_process)进行简洁描述的模型，一个用于[自回归](https://en.wikipedia.org/wiki/AR_model)，另一个用于[移动平均](https://en.wikipedia.org/wiki/MA_model)。****[**【ARIMA】**](https://en.wikipedia.org/wiki/Autoregressive_integrated_moving_average)**→是一个[自回归移动平均](https://en.wikipedia.org/wiki/Autoregressive_moving_average) (ARMA)模型的推广。这两个模型都符合[时间序列](https://en.wikipedia.org/wiki/Time_series)数据，以便更好地理解数据或预测序列中的未来点([预测](https://en.wikipedia.org/wiki/Forecasting))********[**季节性 ARIMA**](https://newonlinecourses.science.psu.edu/stat510/node/67/) →季节性 AR 和 MA 术语预测 *xt* 使用滞后时间为 *S* (季节性跨度)倍数的数据值和误差********[**ARIMAX**](https://robjhyndman.com/hyndsight/arimax/) →右手边有协变量的 ARIMA 模型********[**递归神经网络(LSTM)**](https://en.wikipedia.org/wiki/Long_short-term_memory) →一类[人工神经网络](https://en.wikipedia.org/wiki/Artificial_neural_network)其中节点之间的连接沿着一个序列形成一个[有向图](https://en.wikipedia.org/wiki/Directed_graph)，在该图中允许它展示一个时间序列的动态时间行为。************************如上所述，即使简单的自回归模型也能很好地拟合股票价格。请点击[此处](https://www.quora.com/Whats-the-difference-between-ARMA-ARIMA-and-ARIMAX-in-laymans-terms-What-exactly-do-P-D-Q-mean-and-how-do-you-know-what-to-put-in-for-them-in-say-R-1-0-2-or-2-1-1)阅读 ARMA、ARIMA 和 ARIMAX 之间的区别。**********交互代码******************对于 Google Colab，你需要一个 Google 帐户来查看代码，而且你不能在 Google Colab 中运行只读脚本，所以在你的操场上复制一份。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！********要获取这篇文章使用的代码，请点击这里。**********最后的话**********我希望继续我的研究，对时间序列有更深入的了解。因为我认为这是每个行业都存在的问题。********如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你希望看到我所有写作的列表，请[在这里查看我的网站](https://jaedukseo.me/)。********同时，在我的 twitter 上关注我[这里](https://twitter.com/JaeDukSeo)，访问[我的网站](https://jaedukseo.me/)，或者我的 [Youtube 频道](https://www.youtube.com/c/JaeDukSeo)了解更多内容。我还实现了[广残网，请点击这里查看博文](https://medium.com/@SeoJaeDuk/wide-residual-networks-with-interactive-code-5e190f8f25ec) t。**********参考******1. ****时间序列。(2018).En.wikipedia.org。检索于 2018 年 6 月 2 日，来自[https://en.wikipedia.org/wiki/Time_series](https://en.wikipedia.org/wiki/Time_series)**** 2. ****工作人员，I. (2006 年)。时间序列。Investopedia。检索于 2018 年 6 月 2 日，来自[https://www.investopedia.com/terms/t/timeseries.asp](https://www.investopedia.com/terms/t/timeseries.asp)**** 3. ****如何识别时间序列数据中的模式:时间序列分析？(2018).Statsoft.com。检索于 2018 年 6 月 2 日，来自[http://www.statsoft.com/Textbook/Time-Series-Analysis](http://www.statsoft.com/Textbook/Time-Series-Analysis)**** 4. ****stats models . TSA . seasonal . seasonal _ decompose-stats models 0 . 9 . 0 文档。(2018).Statsmodels.org。检索于 2018 年 6 月 2 日，来自[http://www . stats models . org/dev/generated/stats models . TSA . seasonal . seasonal _ decompose . html](http://www.statsmodels.org/dev/generated/statsmodels.tsa.seasonal.seasonal_decompose.html)**** 5. ****stats models:Python 中的统计数据— statsmodels 0.9.0 文档。(2018).Statsmodels.org。检索于 2018 年 6 月 2 日，来自[https://www.statsmodels.org/stable/index.html](https://www.statsmodels.org/stable/index.html)**** 6. ****b . desh pande(2018)。时间序列预测:理解趋势和季节性。Simafore.com。检索于 2018 年 6 月 2 日，来自[http://www . simafore . com/blog/bid/205420/Time-series-forecasting-understanding-trend-and-seasonity](http://www.simafore.com/blog/bid/205420/Time-series-forecasting-understanding-trend-and-seasonality)**** 7. ****移动平均线。(2018).En.wikipedia.org。检索于 2018 年 6 月 2 日，来自[https://en.wikipedia.org/wiki/Moving_average](https://en.wikipedia.org/wiki/Moving_average)**** 8. ****线性回归。(2018).En.wikipedia.org。检索于 2018 年 6 月 2 日，来自[https://en.wikipedia.org/wiki/Linear_regression](https://en.wikipedia.org/wiki/Linear_regression)**** 9. ****多项式回归。(2018).En.wikipedia.org。检索于 2018 年 6 月 2 日，来自[https://en.wikipedia.org/wiki/Polynomial_regression](https://en.wikipedia.org/wiki/Polynomial_regression)**** 10. ****自回归-移动平均模型。(2018).En.wikipedia.org。检索于 2018 年 6 月 2 日，来自[https://en . Wikipedia . org/wiki/auto regressive % E2 % 80% 93 moving-average _ model](https://en.wikipedia.org/wiki/Autoregressive%E2%80%93moving-average_model)**** 11. ****递归神经网络。(2018).En.wikipedia.org。检索于 2018 年 6 月 2 日，来自 https://en.wikipedia.org/wiki/Recurrent_neural_network**** 12. ****自回归模型。(2018).En.wikipedia.org。检索于 2018 年 6 月 2 日，来自[https://en.wikipedia.org/wiki/Autoregressive_model](https://en.wikipedia.org/wiki/Autoregressive_model)**** 13. ****ARIMAX 模型的混乱。(2010).Robjhyndman.com。检索于 2018 年 6 月 2 日，来自[https://robjhyndman.com/hyndsight/arimax/](https://robjhyndman.com/hyndsight/arimax/)**** 14. ****4.1 季节性 ARIMA 车型| STAT 510。(2018).Newonlinecourses.science.psu.edu。检索于 2018 年 6 月 2 日，来自[https://newonlinecourses.science.psu.edu/stat510/node/67/](https://newonlinecourses.science.psu.edu/stat510/node/67/)**** 15. ****statsmodels.tsa.ar_model。ar . predict-stats models 0 . 9 . 0 文档。(2018).Statsmodels.org。检索于 2018 年 6 月 2 日，来自[http://www . stats models . org/dev/generated/stats models . TSA . ar _ model。ar . predict . html # stats models . TSA . ar _ model。AR.predict](http://www.statsmodels.org/dev/generated/statsmodels.tsa.ar_model.AR.predict.html#statsmodels.tsa.ar_model.AR.predict)**** 16. ****Python，A. (2018)。Python 中使用 statsmodels 的自回归模型。堆栈溢出。检索于 2018 年 6 月 2 日，来自[https://stack overflow . com/questions/28094538/auto regressive-model-using-stats models-in-python](https://stackoverflow.com/questions/28094538/autoregressive-model-using-statsmodels-in-python)**** 17. ****Anon，(2018)。[在线]见:[https://www . research gate . net/figure/Raman-spectra-of-the-the-MCC-101-raw-material-with-123-water-content-top-and-of-the-the-MCC _ fig 11 _ 8508180](https://www.researchgate.net/figure/Raman-spectra-of-the-MCC-101-raw-material-with-123-water-content-top-and-of-the-MCC_fig11_8508180)【2018 年 6 月 2 日获取】。****\]