TowardsDataScience-博客中文翻译-2019-二十三-

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

TowardsDataScience 博客中文翻译 2019（二十三）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

用 BeautifulSoup 和 ElementTree 解析 eCFR

原文：https://towardsdatascience.com/ecfr-parsing-with-beautifulsoup-and-elementtree-8cf9d3ef8178?source=collection_archive---------21-----------------------

Photo by Fabian Irsara on Unsplash

想象一下，你正试图理解在标题 16 商业惯例下联邦法规(CFR) 中公布的一般和永久规则。目前，您拥有联邦法规电子代码(eCFR) 供您使用。然而，在浏览之后，你意识到要找到你需要的信息需要太多的点击。如果您可以提取所有内容并将其保存到一个数据集，会怎么样？嗯，你可以，有了像 ElementTree 和 BeautifulSoup 这样的 Python 库。

下面是我所有的全注释代码，我用它们中的任何一个库来解析 eCFR 标题 16 的 XML。作为奖励，我也只用 BeautifulSoup 写了 PySpark 代码，所以如果你对那个感兴趣，点击这里。

用 BeautifulSoup 解析

在上面的代码片段中，我导入了我需要的所有库——创建数据帧的 Pandas、发送请求的 requests、使用正则表达式的 re 和用于解析的 BeautifulSoup。然后，我向 url 发送请求以检索其数据，并将其存储在变量xml_bs中。然后我将xml_bs传递给bs，后者返回一个 BeautifulSoup 对象，将 XML 文档表示为一个嵌套的数据结构。

虽然代码被完全注释掉了，但我将在下一个代码片段中提供更多的上下文。我创建了一个空列表，迭代地追加我检索到的所有数据。然后，我使用.find_all()找到所有的DIV3元素，并将它们存储在变量chapters_bs中。从那里，我开始遍历我的soup对象，寻找与DIV3元素相关的属性或标签，并将它们保存到各自的变量中。我继续像这样嵌套我的 for 循环并访问父对象 prior，这允许我保留我的 XML 文档的层次结构。请注意，我在部分级别附加了我的所有数据。

上面接下来的几个步骤非常简单——我将我的数据保存到 Pandas DataFrame，编写一个 for 循环来删除任何前导或尾随空格，编写一个正则表达式来删除我的section_text列中的标签和 ASCII 字符，并显示我的数据的前五行。

使用 ElementTree 解析

同样，在上面的代码片段中，我导入了我需要的所有库——除了用于解析的 ElementTree 之外，所有库都是相同的。我向 url 发送了一个请求来检索它的数据，并将其存储在变量xml_et中。然后我传递xml_et到fromstring()，后者将来自我的响应内容的 XML 解析成一个元素，这个元素是解析树的根元素。

这里的大部分代码保持不变，但是我将从头到尾再看一遍，以防您跳过。我创建了一个空列表，迭代地追加我检索到的所有数据。然后，我使用.iter()找到所有的DIV3元素，并将它们存储在变量chapters_et中。从那里，我开始遍历我的root对象，寻找与DIV3元素相关的属性或标签，并将它们保存到各自的变量中。我继续像这样嵌套我的 for 循环并访问父对象 prior，这允许我保留我的 XML 文档的层次结构。请注意，我在部分级别附加了我的所有数据。

同样，上面接下来的几个步骤很简单——我将我的数据保存到 Pandas DataFrame，编写一个 for 循环来删除任何前导或尾随空格，编写一个正则表达式来删除我的section_text列中的标签和 ASCII 字符，并显示我的数据的前五行。

一如既往，感谢阅读。

Ecom 数据系列:什么是电子商务数据科学？

原文：https://towardsdatascience.com/ecom-data-cooler-series-what-is-data-science-f803d1e07cb4?source=collection_archive---------19-----------------------

让电子商务数据科学概念变得简单，一次一个主题。

大多数人都无法接触到数据科学。

Ecom Data Talk Episode 1: What is Data Science?

Photo by Mein Deal on Unsplash

大多数人都无法接触到数据科学。

在过去的一年里，作为一名企业家，我有机会与许多大大小小的电子商务商店以及娱乐/金融行业的客户合作。我发现的事实是，作为一名数据科学资深人士，我认为理所当然的事情(如业务增长的数据驱动型决策)在科技公司之外仍然很少发现或不存在。这种差距的存在让我对我们让数据科学变得可及的使命更有激情，现在比以往任何时候都更有激情。什么是无障碍？对我来说，获得意味着信息的可用性(意识)，手段的可用性(解决方案)，同时是可理解的和可负担的。由于意识(关于什么是可能的)仍然是一个这样的问题，让我们在我们的新系列——Ecom 数据冷却器谈话中谈论它。【你也可以在这里看视频

什么是数据科学？

数据科学是利用来自不同数据元素的信息来支持业务增长的实践。其主要目的是通过自动化和优化不同的运营领域，以及帮助利益相关者利用数据做出更好的决策，帮助企业更好地服务于客户。

这种做法本身并不新鲜；事实上，它已经以商业分析师和金融分析师的形式存在了几十年。数据科学的独特之处在于，在互联网和大数据时代，技术进步带来了新的挑战，使以前的数据分析方法变得低效和过时。因此，一批新的开拓者想出了更适合挑战的收集和总结数据的新方法。

这些新方法通常需要跨多个领域(如计算机编程和统计)的专门培训和经验，还需要其他技能，如商业敏锐度和沟通技巧，这就是为什么很难在所有领域都表现出色，而机构更难生产它们。

为什么数据科学很重要？我为什么要在乎？

数据无处不在，而且呈指数级增长。如果互联网是最大的均衡器，那么数据就是最大的区分器。当你看到亚马逊的图书和网飞的 DVD 时，这两家公司都是从相对较小的利基市场起步的，在这个领域都有巨头。他们能够取代竞争对手，市值增长到数千亿美元，很大程度上是因为他们对客户数据的深刻理解。他们知道你读什么，你看什么，你喜欢什么，你住在哪里，结合这些信息是非常强大的，他们能够通过提供更好的价值来更好地服务他们的客户，最终消费者做出了他们的选择，并用他们的钱投票。

你应该关心什么？你可能会说，John，我们没有时间和金钱来处理数据。的确，就在几年前，大多数财大气粗的公司都在竞相为数字时代转变业务。然而，随着云基础设施、开源工具和电子商务平台的出现，数据成本大幅下降。现在的问题是，大多数电子商务商店都没有充分利用他们的数据，这是一个巨大的增长机会。

为什么数据科学能为我做什么？

简而言之，就是要让业务指标清晰，让有待改进的领域浮出水面，帮助你更好地了解你的客户。除此之外，还有自动化工具和工具来帮助简化事情。例如，你是否正确地衡量了你的利润？如果你仍然使用总收入，包括运输成本和税收，那么你就做错了。你可能还想知道谁是你最好的顾客，他们一生中会花多少钱在你身上。换句话说，你想知道客户的客户终身价值，这对于大多数人来说是一个难以捉摸的指标。或者，你可能想分析客户的购物行为，以建立不同的细分市场，并个性化你的营销工作，我们都知道这是有效的，但有时并不简单。

还有更多的应用，但都归结为这三件事:从数据中提取洞察力，直观地总结它们，并推断未来的结果，以在今天做出更好的决策。

在数字时代，规模经济创造了垄断，垄断了数据、人才和资源市场。通过支付职业运动员水平的工资，科技巨头有效地使大多数人无法接触到数据科学。不一定是这样的。数据就是力量，我们希望将电子商务数据的力量还给人们，甚至是分数。立即加入我们，与您的数据一起成长。

由段制成

在 LinkedIn 或脸书上找到我们。

【tresl.co】原载于

Ecom 数据系列:什么是 RFM 分割？

原文：https://towardsdatascience.com/ecom-data-cooler-series-what-is-rfm-segmentation-8c4d6c2c0fc0?source=collection_archive---------22-----------------------

让电子商务数据科学概念变得简单，一次一个主题。

简单、有效的市场细分，提高打开、点击和转化

Ecom Data Talk Episode 2: What is RFM segmentation?

传统上，营销人员根据人口统计进行细分👨👩🐈👶。然而，今天大多数电子商务品牌更喜欢应用数据科学来开发基于购买行为的行为细分。例如，他们在🛒观看/购买什么产品？他们通过什么途径到达您的网站📍？(意识与意图)。此外，他们的 engagement🖱️水平如何(使用/打开/点击/查看)？

细分有什么好处？虽然有很多，但我会在这里列出我最喜欢的三个:

聚焦和个性化营销
降低营销成本
更好的产品开发

根据行为对客户进行分组可以实现情境化营销，而不是电子邮件群发，从而降低营销成本。通过锁定目标客户子集(细分市场！)有了类似的属性，你可能会获得更好的打开率、更高的转化率和广告支出回报率(ROAS)。最重要的是，你可以让未来的产品迎合顾客的口味。

什么是 RFM？

RFM 是一种用于分析客户价值的数据建模方法。它代表新近性、频率和货币，这只是描述客户行为的三个指标。最近度衡量的是从客户上次订购到今天的时间(通常以天为单位)。频率衡量客户的订单总数，货币是他们从这些订单中花费的平均金额。

Photo by Hoster on Unsplash

RFM 始于直销时代，至今仍是零售和电子商务中最简单、最有效的工具之一。要创建 RFM，您需要转换您的数据并从高到低分配一个分数。下面是一个简单的示例，它有三个级别(高、中、低)—在一列中对客户的订单进行排序，并为没有订单的客户分配 3 分，为有一个订单的客户分配 2 分，为有两个或更多订单的客户或回头客分配 1 分。这给你你的频率度量。然后，你重复这个过程的新近性和货币。最后，你会得到三个价值，每个价值代表 RFM 的一个支柱，描述了每个客户的价值，其中一个是最好的。

为什么 RFM 很重要？我为什么要在乎？

RFM 是必不可少的，因为它允许你快速地将你的客户从最好到最差进行排序和安排，并且它在描述客户行为方面非常有效。有了 RFM 分数，你可以创造许多有用的客户群。我们从 MVP 开始，他们是您的最佳客户，在所有三个维度上都有最高分。高消费的新客户在新近度和货币度上得分高，但在频率上得分低，因为他们最近才购买。相反，你有高价值的流失客户，他们已经有一段时间没有购买了。他们在最近和金钱上得分较高，但在最近上得分较低。最后，低价值客户在所有三个维度上都得分很低，不太可能有任何价值。你可以通过抑制这些用户来节省营销费用和提高打开率和点击率。

Photo by Austin Distel on Unsplash

你为什么要在乎？我们已经看到，前 5%的顾客平均花费是其他人的 10 倍，占总收入的三分之一。顶级客户往往有更高的平均订单价值，更有可能成为你品牌的忠实粉丝。忠诚的粉丝往往会产生口碑和推荐，这让他们更有价值。

简而言之，你应该花更多的时间让你的顶级客户开心，RFM 可以帮你弄清楚该关注哪里，做什么。

为什么 RFM 能为我做什么？

如果你还没有，开始利用 RFM 为你的营销活动创建客户细分，并开始优化。您可以:

为你的贵宾铺上红地毯。
为最有可能购买的客户设计培育活动。
为即将流失的客户创建个性化的优惠和提醒。
重新瞄准流失的高价值客户，赢回他们。

Photo by Alvaro Reyes on Unsplash

RFM 有更多的使用案例。您将能够创建更多相关的、情境化的活动，以不同的方式针对不同的客户。细分有助于提高打开次数和点击量，并带来更多的营销收入。如果你还没有这样做，你绝对应该这样做。我们的一位客户发现，多亏了 RFM，她在年度计划中多了 20%的高价值客户。

总之，RFM 代表近期、频率和货币，近期是最重要的。为什么？那是因为网购是非契约性的商业行为，人们可以自由来去。你只能假设顾客是“活着的”,并且对你感兴趣，当他们通过最近的购买告诉你这一点的时候。

找到你的 RFM。开始将你的客户从最好到最差进行分类，并将这些细分纳入你的营销活动中！

不要忘记，数据就是力量，我们希望将电子商务数据的力量还给人们。立即加入我们，与您的数据一起成长。

由段制成

在 LinkedIn 或脸书上找到我们。

原载于tresl.co

[1]彼得·s·法德尔、布鲁斯·g·s·哈迪·卡洛克·李、RFM 和 CLV: 使用等值曲线进行客户群分析 (2004)

时间序列分析的计量经济学方法 Python 中的季节性 ARIMA

原文：https://towardsdatascience.com/econometric-approach-to-time-series-analysis-seasonal-arima-in-python-28f5782ee23?source=collection_archive---------5-----------------------

自相关，时间序列分解，数据转换，Sarimax 模型，性能指标，分析框架

在这篇文章中，我们将讨论带有趋势和季节成分的时间序列数据的分析。将采用计量经济学方法来模拟数据的统计特性。这里的业务目标是预测。我们试图解释时间序列建模中涉及的各种概念，如时间序列成分、序列相关性、模型拟合、度量等。我们将使用 statsmodels 库提供的 SARIMAX 模型来模拟数据中的季节性和趋势。萨里玛(季节性 ARIMA)能够同时模拟季节性和趋势，不像 ARIMA 只能模拟趋势。

内容:

时间序列数据的定义
项目和数据介绍
季节分解和时间序列成分:趋势、季节性、周期、残差
时间序列数据的平稳性及其重要性
自相关和偏自相关
数据转换:对数转换和差分
模型选择和拟合
结论

从 GitHub 库访问完整的 Python 代码:https://GitHub . com/jahangimmadov/sarima/blob/master/Seasonal % 20 time % 20 series % 20 analysis . ipynb

1.时间序列数据的定义？

时间序列数据是在时间间隔内测量的一系列数据点。换句话说，数据是时间 f(t) = y 的函数。
数据点可以每小时、每天、每周、每月、每季度、每年测量，也可以用更小或更大的时间尺度测量，例如几秒或几十年。

2.项目和数据介绍

我们在本文中使用的数据是 2000 年至 2019 年间美国 20 个主要城市的月度房屋销售指数。(https://fred.stlouisfed.org/series/SPCS20RPSNSA)。您可以从这个来源免费下载许多不同的代表美国经济的经济时间序列数据。你可能会看到相同数据的两个不同版本，季节性调整和非季节性调整。在这篇文章中使用的版本没有进行季节性调整，因为我们想模拟季节性和趋势。你可能会问为什么人们要在行业中使用季节性调整的数据。嗯，有时企业可能想知道经济事件对特定数据的真实影响，这可能与一个季度重叠。在这种情况下，季节性可能会掩盖或低估/高估经济事件的影响。例如:取暖油生产商可能想研究汽油价格下降对取暖油价格的影响。然而，尽管取暖油是一种汽油物质，冬季取暖油的价格却在上涨。汽油价格的下降应该反映在取暖油价格的下降上。然而，冬季取暖需求很大，导致价格略有上涨。通过从时间序列数据中去除季节性影响，您可能会看到取暖油价格实际上呈下降趋势。价格的轻微上涨是季节性的影响。在第 3 节中，我们将更详细地讨论季节分解。

如果我们观察数据的时间序列图，我们可以观察到 2000-2006 年的增长趋势，由于严重的金融危机，从 2007 年到 2012 年房屋销售的下降趋势，以及到 2018 年的增长趋势。我们还可以观察数据中的季节性，因为通常住房市场在年初并不活跃，销售通常在年中达到高峰，到年底销售又会下降。似乎是温暖的季节，尤其是夏天是美国房地产市场的好季节。

3.季节分解和时间序列成分:趋势、季节性、周期、残差

时间序列数据 Y 由趋势、周期、季节性和残差的组合组成。显然，你可能会遇到没有趋势、周期或季节性的时间序列。因此，识别时间序列数据的组成部分是您的任务。术语的定义如下:

趋势— 长期向上或向下的运动。
周期— 因经济运动而产生的周期性变化。它不同于季节变化。周期是时间序列数据的自回归分量的变化。周期发生在较长的时间间隔内，例如每 6-10 年，而季节变化发生在较短的时间间隔内。
季节性 — 季节性影响导致的数据变化。冰淇淋的销量在夏天很高，取暖油的销量在冬天很高，但在夏天很低。
残差— 在时间序列数据中计算并去除其他分量后剩下的分量。它是随机、恒等和独立分布的。残差，R~ N(0，1)。

Statsmodels 库有一个函数叫做 seasonal_decompose，将时间序列 Y 分解成趋势、季节性和残差。虽然这是一个简单的分解算法，但在实践中，它非常直观，并且适用于 T、S 和 R 明显的时间序列数据。在解释下面的图表之前，我想谈谈这些组件之间的相互作用。
时间序列数据 Y 可以采用加法或乘法形式。在加法形式下，时间序列 Y 由时间序列分量之和构成，即 T，S，C，R:
Y = T+C+S+R

以乘法形式出现的时间序列 Y 是由时间序列分量的乘积形成:
Y = T * C * S * R

那么，房屋销售指数是乘法还是加法呢？如果你仔细观察住房指数的时间序列图，你可能会注意到，当趋势下降时(2008-2013 年)，季节性变化(季节性)变小，而当趋势上升时(2014-2019 年)，季节性变化变大。这种情况发生在乘法时间序列中，趋势 T 的小值导致小的 S，因为我们将 S 乘以 T。在加法时间序列中不会出现这种现象。

我们使用 statsmodels 中的季节性分解(原始数据，‘乘法’)函数将时间序列数据分解为趋势、季节性成分和残差。如果函数返回所有 3 个部分，即使您假设它们对于特定的时间序列数据不存在，也不要感到惊讶。在现实中，这些组件是由一个简单的算法生成的，这就是为什么分解函数不能说一个组件不存在，尽管计算出的值并不显著。因此，对于任何时间序列数据，您都会看到这三个组成部分。你必须知道如何阅读结果，并决定哪个模型(ARIMA 或萨里玛)适合数据。

Plot of seasonal decomposition from statsmodels library

我们将尝试自己将数据分解成组件，以便更好地理解它们的派生和用法。可以采用窗口大小= 12 的移动平均来计算趋势。下图与统计模型库生成的趋势非常相似。

Moving average with window size=12

Plot of Moving average window size=12

还记得乘法模型， Y = T C S R* 吗？将 Y 除以 T 可以得到 Y/T=CSR** 我们假设残差对于该数据来说太小，因为时间序列图看起来很平滑。我们的数据非常少，因此我们无法检测经济周期。我们把时间序列除以趋势得到一个季节成分， S=Y/T 。

Code snippet for seasonality decomposition

季节性的图形有点难理解，但是，这里给出的解释已经足够了。 y=1.2(红色标记)表示 2000 年 7 月-2000 年 7 月的销售额增加了 20% 。换句话说，六月的季节效应为+ 20% 或 1.2 *T。另一方面，2003 年 2 月的 y=0.8(绿色标记)显示销售额下降 20% 。因此，对于一些不属于这种特殊情况的时间序列数据，您可能会看到季节性影响非常小，即 y=0.0001 。它显示了一个非常小的季节性影响，甚至不应该被认为是显著的。

Seasonal Component

残差可以计算为 R = Y/(ST)*

Code snippet for residuals decomposition

Resiudals component

还有其他一些方法来检测季节性。在下面的图表中，绘制了每年的月度房屋销售，正如你所看到的，每年都遵循几乎相同的模式，只是略有不同。房屋销售在夏季较高，冬季较低。

Code snippet for the monthly home sales graph

Monthly sales per year

4.时间序列数据的平稳性及其重要性

当我们在时间序列数据中有趋势和/或季节性时，我们称之为非平稳的。

平稳性是指数据的统计属性，如平均值、方差和标准偏差在一段时间内保持不变。

为什么我们希望统计属性随着时间的推移保持不变？因为我们在建立模型的过程中对样本数据进行了统计假设(一个很好的例子是 OLS 假设),而模型只能在这些假设下运行。当数据的统计属性改变时，模型不再能够代表数据的真实性质。

这就是为什么我们的预测/预测结果将不再有效。改变均值/方差将要求我们拟合另一个模型，而这个模型可能在短时间内有效，我们必须再次放弃它并拟合一个新的模型。看，这个过程看起来是多么的低效和不可靠。在拟合模型之前，我们必须使时间序列数据稳定。我们可以通过转换数据使时间序列平稳。通常，差分用于使数据稳定。我们将在下面的第 6 节中讨论它。

那么，如何检验一个时间序列数据是否平稳呢？第一个是目测时间序列图，并确定趋势或季节性。如果它们中至少有一个存在，那么时间序列数据就不是静态的。其次，您可以将数据分成 3 组，计算每组的均值和方差，并确认每组的均值和方差是否有实质性差异。第三种选择是使用 statsmodels 库中提供的统计测试之一。

扩展的 Dickey-Fuller 检验是其中最流行的，其中零假设，h0 =数据不是平稳的。ADF 测试结果提供测试统计和 P 值。p 值> = 0.05 意味着数据不是平稳的，否则，我们拒绝零假设，说数据是平稳的。

我们假设你知道什么是假设检验，以及 P 值意味着什么。如果你对这些术语不太熟悉，那么看看 p 值，如果它小于 0.05 (p 值< 0.05) then data is stationary if p-value > = 0.05 数据不是静止的。ADF 检验证实原始时间序列数据不是平稳的，其 p 值约为 0.08

Code snippet for ADF test

Time series data is not stationary. Adfuller test pvalue=0.0803366374517756

5.自相关和偏自相关

在建模之前，我们必须看一下 ACF 和 PACF 图，因为从现在起我们将会大量使用这些图。

自相关图显示时间序列数据与其自身滞后值的相关性。例如，滞后=1 时的自相关表示 y_t 和 y_t-1 之间的相关性。在滞后=2 时，corr(y_t，y_t-2)。在滞后=12 corr(y_t，y_t-12)时。在这个特定的例子中，与时间 t-12、t-24 等的数据点高度相关的时间 t 的每个数据点表示季节性。

Autocorrelation plot of original home sales index data

下面的代码片段和散点图可以帮助您更好地理解滞后值之间的相关性，即自相关性。

Code snippet for correlation of lags

Correlation between lag values — highly correlated

回到 ACF 图，自相关图的蓝色阴影区域显示显著性水平。因此，阴影区域内的相关系数在这些滞后处表现出弱相关性，我们认为它们在分析中并不重要。
偏相关函数(PACF)给出了平稳时间序列与其滞后值的偏相关。

Partial autocorrelation plot of original home sales index data

PACF 去除了其他滞后的相关性贡献，给出了两个滞后之间的纯相关性，而没有其他滞后的影响。

我们使用 ACF 和 PACF 为 ARIMA 模型的 AR(p)和 MA(q)组件/特征选择正确的顺序。对于 AR 阶数 p，查看 PACF 图并选择一个滞后值，该值在相关性变得不明显之前具有显著的相关系数。对于 MA 订单 q，查看 ACF 图，并执行相同的操作。不要忘记你应该只从平稳时间序列的 ACF 和 PACF 图中得到这些值，而不是从上面的图中。上面给出的 ACF 和 PACF 图是原始数据的图，其是非平稳的。

6.数据转换:对数转换和差分

因此，让我们转换数据，使其稳定，这样我们就可以开始模型构建阶段。我们将原始数据分为训练数据和测试数据。训练数据将包含 2000 年至 2018 年的美国房屋销售数据，测试数据将包含 2018 年至 2019 年的数据。别忘了，你不能像对待横截面数据那样进行随机抽样。我们必须保持时间序列数据的时间行为(依赖于时间)。

房屋销售指数数据可以公式化为一个乘法模型，其中 Y= TSR。我忽略了周期，因为它实际上并不存在于该数据中。(S)ARIMA 模型是线性模型，如线性回归。我们无法将线性模型 SARIMA 拟合到由 Y = TSR 过程生成的数据。我们必须在拟合线性模型之前使 Y 为线性。从数学 中你可以知道 Log(ab) = log(a) + log(b)* 。我们必须对数据进行对数变换，使其呈线性。log(Y)= log(T)+log(S)+log(R)。 Log 变换使数据线性、平滑。

log_transformed_data = np.log(training_data)
plot_data_properties(log_transformed_data, ‘Log tranformed training data’)

Properties of log transformed data

有时，日志转换本身可以使数据保持不变，但这里的情况并非如此。

test_stationarity(log_transformed_data)
Time series data is not stationary. Adfuller test pvalue=0.22522944188413385

差分是一种基本的操作或数据转换。是时间=t 时的 y 和时间=t-x 时的 y 之差diff _ 1 = y _ t—y _ t-1

差分使数据保持不变，因为它从数据中删除了时间序列成分，而您得到的是不同时间段之间的变化。注意，一阶差分只带走了趋势，而不是季节性。数据仍然不是静态的，因为它包含了季节性的影响。

logged_diffed_data = log_transformed_data.diff()[1:]
plot_data_properties(logged_diffed_data, 'Log transformed and differenced data')

Log-transformed and 1st order integrated: non-stationary

test_stationarity(logged_diffed_data)
Time series data is not stationary. Adfuller test pvalue=0.20261733702504936

我们必须采用 12 阶差分来消除季节性。你可能会问，我们是如何决定采用 12 阶差，而不是 6 阶、8 阶或其他阶差的。通常，月数据的季节性滞后=12，周数据的季节性滞后=4，日数据的季节性滞后=30。或者你可以从 ACF 图中得到。对于这个特定的数据，第 12、24、36 个滞后高度相关。

数据现在是固定的。如果你看下图的直方图，它看起来像正常的钟形曲线。平稳数据是随机同分布的，图看起来像白噪声。白噪声只是平稳时间序列数据的一个例子。

seasonally_diffed_data = logged_diffed_data.diff(12)[12:]
plot_data_properties(seasonally_diffed_data, 'Log transofrmed, diff=1 and seasonally differenced data')

Stationary data

test_stationarity(seasonally_diffed_data)
Time series data is stationary. Adfuller test pvalue=0.0006264163287311492

7.模型选择和拟合

由于转换后的数据是稳定的，现在我们可以进入模型拟合阶段。我们之前简单聊过萨里玛。我想详细说明一下这个特殊的模型。季节 ARIMA 是 ARIMA 家族中的一个特殊成员，它可以对时间序列数据的季节成分进行建模。简单重述一下 ARIMA 的意思:

AR —自回归模型是对时间序列数据的滞后值进行回归。滞后值成为自变量，而时间序列本身成为因变量。

y = A0+a1 * y t-1+a2 * y t-2，…..，a_k*y_t-k.

这里的主要任务是选择多少时间步长作为独立变量。不要让时间序列或滞后值这个词迷惑你，它们只是自变量。在线性回归中，您可以查看自变量和因变量之间的相关性，并选择高度相关的变量作为您的特征。在这里你也应该这样做。但是，您不必计算滞后值和目标变量之间的相关性，因为您可以使用 PACF 来确定要使用多少滞后。平稳数据的 PACF 在滞后=1 时具有显著的自相关，而在滞后=2 时下一个自相关变得不显著。理想情况下，AR 订单 p 应该为 1。由于 AR(p)和 MA(q)项相互影响，从自相关图中观察到的初始 p 和 q 值不再可靠，应作为起点。我们必须在 p 上进行参数搜索，以找到最优值。初步猜测将有助于定义网格搜索使用哪些值。在这种情况下，p =[0–2]就足够了。

积分的顺序:基本上，你对数据求了多少次差。我们有过一次 d=1。当您设置参数 d=1 时，不要忘记使模型适合无差异数据，因为算法将对其进行区分。如果您将模型拟合到静态数据，那么您就不再需要差分。可以让 d=0。我们需要差分来使数据稳定。

MA —移动平均模型:时间序列 y 在残差 w 上回归

y = A0+a1 * w1+a2 * w2+…。+ a_k*wk

查看 ACF 图，确定 ARIMA 模型的 MA 阶(q)。ACF 建议 ARIMA 模型的 MA 部分的阶数 q=1。但是，我们应该进行网格搜索，以找到一个最佳模型。我建议查看值 q =[0–2]

季节性模型—季节性特征必须与 AR 和 MA 一起添加到模型中，它有 4 个参数(P、D、Q、s)。
认为 P、D 和 Q 参数类似于 ar、I 和 MA 参数，但仅用于序列的季节性成分。

看 PACF 选择 P，看 ACF 选择 Q。季节差异的数量是 d，季节效应的频率是 s。

P = 1 —因为我们在滞后=12 时有显著的相关性，但是，它们不够强，我们可能不需要在模型中有 AR 变量。这就是为什么我们应该在 P =[0–2]上进行网格搜索

D=1 —我们对季节性进行了一次差分

q = 1——根据 ACF 图，我们在滞后=12 时有很强的相关性。让我们也对参数 Q =[0–2]执行网格搜索。

s=12 —季节性频率，每 12 个月一次

下面的 best_sarima_model 函数对(P，D，Q)和(P，D，Q，s)参数进行网格搜索，以 AIC、BIC、HQIC 的统计指标作为评估标准，找到最佳模型。下 AIC，BIC，HQIC 意味着更好的模式。这些指标奖励拟合优度(对数似然)，惩罚过度拟合。在我们的例子中，有许多滞后特征会导致过度拟合。AIC、BIC 和 HQIC 平衡了可能性和自由度之间的权衡。你可以在他们的公式中看到这个属性。我不会深入讨论其他指标的细节，但会在下面举一个例子来支持我使用 AIC 的观点:

-k 是模型中估计参数的数量，换句话说，是特征(滞后项)的数量。
-L 是似然函数的最大值。
AIC = 2k — 2ln(L)

我在行业中见过许多只使用其中一个指标作为模型选择标准的例子，但您可能会遇到这样的情况:一个模型的 AIC 可能比另一个模型低，而 BIC 却较高。这就是为什么如果 3 个指标中有 2 个较低，就要尝试选择一个模型。

Code snippet for model selection

请注意，我们正在为对数转换数据拟合一个模型，因此。我们已经设置了 d=1 和 D=1 参数，以便模型自己进行差分。如果您要将模型拟合到静态数据，则必须将积分阶数(D，D)设置为 0。我们用上面确定的参数评估了 SARIMA 模型。下面的总结显示了最好的模式，或者说最低的 AIC，BIC，HQIC。最好的模型建议我们不需要有 AR 特征，只需要 MA 和季节性 MA 特征。

best_model, models = best_sarima_model(train_data=log_transformed_data,p=range(3),q=range(3),P=range(3),Q=range(3))

Model Summary of the best Sarima model

ARIMA 或萨里玛模型是通过使用最大似然估计和 OLS 假设适用于这一系列的模型。这些假设我不想在这里细说。这是另一篇文章的主题。然而，我们必须确认我们的模型符合这些假设。系数的 p 值< = 0.05。残差是平稳的和均方的。残差之间没有序列相关性。

Endog vs Residuals Scatter plot

Residuals Autocorrelation plot: No correlation

我们将预测 2018 年 1 月 1 日至 2019 年 1 月 1 日的房屋销售情况。我将使用 MAPE——平均绝对百分比误差来评估模型性能。我们得到的最佳模型是 SARIMA(order=(0，1，2)，seasonal_order=(0，1，1，12)。我更喜欢时间序列分析中的 MAPE 误差度量，因为它更直观。Sklearn 不提供 MAPE 度量，所以我们要自己编码。公式:

MAPE formula

Code snippet for MAPE

使用预测函数时，需要注意其参数的一些细微差别:

type =“levels”意味着预测值将与 endog/training 值处于同一水平，在我们的情况下，它们是经过对数变换的，根本没有差异。然后，如果你注意到我们用 np.exp()将预测值换算成原始数据。记住，np.exp(np.log(a)) = a .所以，np.exp(np.log(原始数据))=原始数据
dynamics = True，则使用 time = t 的预测值作为 time = t+1 的预测值。

preds_best=np.exp(best_model.predict(start=test_start_date,end='2019-01-01', dynamic=True, typ='levels'))
print("MAPE{}%".format(np.round(mean_abs_pct_error(test_data,preds_best),2)))MAPE:6.05%

我们大约制造。我们的预测误差为 6%。这并不意味着模型会在 6%的时间里表现不佳。相反，它转化为预测值将偏离实际值平均 6%。

用原始数据绘制预测值并查看结果。从下图中我们可以推断出什么？嗯，很多！该模型可以成功地捕捉季节效应，但是，不能捕捉趋势。房屋销售呈下降趋势，然而，该模型不能很好地捕捉它。它知道销量会下降，但由于季节效应，2018 年后会有下降趋势，这很难预测。这是因为我们得到的训练数据很少。

Forecasted data

如果我们有一个更大的数据集，我们可以识别一个经济周期，并对其建模。很可能，每 6-7 年的房屋销售就会减少一次。或者，如果这种下降趋势在 2019 年继续，我们对 2020 年的预测肯定会捕捉到这一趋势。

另一个更快捕捉趋势的选择是在模型中添加 AR 项。如果我们在模型中加入 1 或 2 个 AR 项，它可以更快地对趋势做出反应，并具有更少的 MAPE。下图显示了各型号的 MAPE。在 MAPE 测试中表现优于最佳模型的模型显示为绿色。

我们在模型中添加了 AR 术语，并且我们在测试指标方面有所改进。

agile_model = SARIMAX(endog=log_transformed_data,order=(1,1,2), seasonal_order=(1,1,2,12),enforce_invertibility=False).fit()
agile_model.summary()

Model summary

测试 MAPE 现在是 5.67%，比 6.05%有所提高，这是最优模型的测试 MAPE。

agile_model_pred = np.exp(agile_model.predict(start=test_start_date,end=’2019–01–01', dynamic=True, typ=’levels’))
print(“MAPE{}%”.format(np.round(mean_abs_pct_error(test_data,agile_model_pred),2)))MAPE:5.67%

然而，如果你看看 AIC、BIC 和 HQIC，我们会得到更高的值，这意味着我们牺牲了模型的通用性。我们知道我们只有很少的数据点大约 300 个，在线性模型中有 6 个特征可能会导致过度拟合。如果你看一下上面的模型总结，特征系数的 P 值为 ar。马萨诸塞州 L1。阿肯色州 L2。马萨诸塞州第 12 中学。S.L12 和马。S.L24 高于 0.05%。

8.结论

我们在上面已经讨论了许多不同的概念，这些概念在分析和模型构建阶段都会用到。以下步骤总结了我们采取的方法，可用作类似项目的指南或框架:

确定模型是乘法的还是加法的
识别时间序列的组成部分:趋势、周期、季节性、残差
将数据转换成线性
如果数据不稳定，则使其稳定
根据步骤 2，选择 ARIMA 或萨里玛模型
为每个模型变量/特征定义订单参数
做网格搜索，选择一个基于 AIC，BIC，HQIC 的最优模型
检查模型残差是否符合 OLS 假设
预测并计算预测误差:MAPE、梅等。

简单线性回归背后的计量经济学

原文：https://towardsdatascience.com/econometrics-behind-simple-linear-regression-ae5037de92c9?source=collection_archive---------17-----------------------

准确描述机器学习的方法之一是找出现实世界问题的数学优化。有时，当试图使用机器学习解决现实世界的问题时，我们可能希望检查某些因素是否与某种影响有任何关联。

例如，一个家庭的周收入是否与一段时间内在某个地方花在食物上的钱有关联。在这个特殊的例子中，家庭的周收入是预测变量(自变量 X)，在食物上的花费是响应变量(因变量 Y)。

简单线性回归是在因变量和自变量之间建立关系的方法。最简单的情况是检查单个动作是否与响应有任何关系。这被称为简单的线性回归。在本文中，让我们看看简单线性回归背后的计量经济学。

经济理论使用模型暗示了经济变量之间的许多关系。对于一个变量的给定值，这些模型用于估计/预测另一个变量的相应值。我们可以使用回归模型找到许多现实生活变量之间的关系，如收入-支出、学习时间-分数、身高-体重等。

1。)简单回归模型

y= β1+ β2x+e

简单线性回归对于寻找两个连续变量之间的关系很有用。

在这个模型中，我们通常指

y —因变量/解释变量/回归变量

x — 自变量/探索变量/回归变量

在这篇文章中，我们找到了收入和教育之间的关系。因此，相应的回归方程变成了

收益= β1+β2Educ+e
β2，β2 —模型参数(常数)
e —误差项/不可观测误差(包括除教育以外影响收益的因素)

人们可以使用工作人群的随机样本数据来估计这个模型的参数。

2。)假设:

我们的估计从关于误差项的一些假设开始。

a.)u 的平均值，总体中的误差项为 0。随机误差的期望值为 E(e) =0

b.)误差项，将有恒定方差， Var(e) =常数

c.)我们需要假设 u 的平均值不依赖于 x 。
x、u 都是独立的(对于给定的 x:u 不受影响)。即 E(e│x)=E(e)=0=f(e) 。

这意味着， E(y│x)= β1+β2x=f(y)

举例:让 e —员工的能力。同样的受教育年限，两个员工的能力不一样。

下面是一个总体回归函数，它将 f (y)解释为 x 的线性函数，其中对于任何 x，y 的分布以 f (y)为中心

Source: Principles of Econometrics, 4th Edition

3。)普通最小二乘
到目前为止，我们还没有看到数据。回归背后的基本思想是从样本中估计总体参数β1， β2 。让我们从一个总体中选择一个大小为 n 的随机样本{( 易 ): i = 1，2，…，n}。
对于每个观测样本的回归方程，
yi= β1+ β2xi+ei

下面是人口回归线，从人口和相应的误差条款

Source: Principles of Econometrics, 4th Edition

目的 : 利用数据确定变量之间的真实关系

未知 : 真实关系，参数

由于误差项 e ，实际结果与真实关系不同

4。)使用 OLS 导出参数估计

我们的估计从一些假设开始。让我们回忆一下之前的假设，

E(e│x)=E(e)=0
Cov(x，e)=E(xe)-E(x)E(e)
Cov(x，e)=0

原因 : E(e) =0(根据假设) Cov(x，e) =0(根据相同假设加上独立性)那么 E(xe) =0

我们现在有两个方程，

E(e) = 0 → (1)

E(xe) = 0 →(2)

用其他变量重写e:x，y，β1，β2

e = y — β1- β2x

在上述两个等式中代入 e

E (y — β1 — β2x) = 0

E [x(y — β1 — β2x)] = 0

现在我们有两个方程，两个未知数( β1，β2 )

E(X) 是总体分布的算术平均值。 E(X) =∑( Xi /n)

将上述方程整形如下
(∑(易- β1- β2x))/n=0
(∑ xi(易- β1- β2x))/n=0

使用上述等式求解 (β1，β2) 得到
Y- β2X= β1
(∑(xi-X)(易-Y))/(∑(xi-X) )= β2
其中 X，Y 是 x，y 的算术平均值

注:β2的分母，即 ∑(xi-X) 必须为> 0。但也有可能是零。
分母= 0 意味着 var(x) = 0

具有相同教育水平的每个人→β2-斜率估计量变得无穷大(形成一条平行于 y 轴的线)

因此，我们需要(x)中的一些变化来辨别(x)和(y)之间的关系
简而言之， β2 (斜率估计)是(x，y)之间的样本协方差除以(x)的样本方差

(Cov(x，y)/(Var(x))= β2

如果 x 和 y 正相关，斜率将为正
如果 x 和 y 负相关，斜率将为负
只需要 x 在我们的样本中变化就可以得到估计值。

5.)超越建筑模型

在建立经济模型时，确保独立变量中存在小的方差(因为这会导致回归方程的斜率无穷大)。建立模型后，我们需要检查估计量的性质。这些属性包括对偏倚、一致性和效率的测试。因为这些性质将决定我们的估计有多精确。

结束注释

我希望你喜欢阅读这篇文章。然而，在回归模型和应用中仍有很多东西需要探索，我鼓励你们去阅读“计量经济学原理—第 4 版，作者:Carter Hill | Grifftiths | LIM”。如果您有任何建议/推荐，请在下面的评论中留下您的反馈。

感谢阅读。

基于 Gretl 的计量经济学——建立银行流失的地理分割模型

原文：https://towardsdatascience.com/econometrics-with-gretl-building-a-geosegmentation-model-for-bank-churn-265cd6814866?source=collection_archive---------25-----------------------

使用逻辑回归、方差膨胀因子和优势比分析银行流失数据

格雷特是什么？

Gretl 是一个开源的统计软件包，是为计量经济学开发的，但也可以用于各种各样的数据。该程序是用 C++编写的，有许多扩展核心程序的社区源包。

该程序可以在这里下载，本教程中使用的数据可以在 Kaggle 这里找到。

看一看数据

可以从文件选择下载的 csv 文件将数据加载到 Gretl 中。程序会提醒用户数据没有更新，并询问是否应该尝试构建一个时间序列，对于这个数据集，我们不需要这样做。

有两个窗口，一个包含名为 string_table.txt 的变量字符串值，主 Gretl 窗口显示数据中存在的变量的完整列表。

虚拟变量

变量性别和地理位置需要进行数字编码，这可以在 Grelt 中通过右击主屏幕中的变量并选择 Dummify 来完成，然后对所有值进行编码。为了使事情更简单，展开 Geography 和 Gender 变量并编辑值的属性。例如，右键单击“地理”下的“法国”并选择“编辑属性”，将“名称”字段从 DGeography_1 更改为法国。

检查变量

Exited 是因变量，因为它是利息的结果，本案例研究考察了可能与一个人离开或留在银行有关的因素。RowNumber、CustomerID 和 Surname 等变量不会影响一个人是留在银行还是离开银行，因此不使用这些列。剩下的变量将是回归变量。

信用评分——客户的信用评分会影响他们的决策
地理 —客户所在的区域数据
性别——顾客的性别可能会影响他们的去留
年龄 —顾客的年龄
任期——客户与银行交易的持续时间——更长的任期可以建立忠诚度
余额——客户的银行余额——可能会影响促销、利率和账户费用
NumOfProducts —客户订购了多少产品——更多的产品可能会导致更高的入住率
HasCrCard——不管客户是否有银行信用卡——增加银行在客户生活中的存在
活跃会员 —过去 6 个月内客户与银行的活动——活跃客户更有可能留下来
估计工资 —银行对客户工资的估计——高收入者可能在银行有更多投资
退出 —客户是留在银行还是离开

构建模型

Gretl 使得数据建模变得非常容易。这是通过进入主窗口中的模型选项卡，导航至有限因变量(因为 exited 是一个离散变量)，然后导航至 logit(逻辑回归)，最后导航至 binary。

模型->有限因变量-> logit ->二元

然后，Gretl 将提示用户选择因变量(退出)和回归变量(上面的列表)。为了确定模型中变量的重要性，应勾选显示 p 值框。运行模型。

删除变量

运行第一次回归迭代会产生以下系数和 p 值:

Model iteration 1

可以看出，西班牙的 p 值最高，这表明它不是一个显著变量，因此我们可以将西班牙排除在模型之外。在没有西班牙的情况下再次对数据进行建模时，精度没有提高，R 平方值也略有增加:

Model iteration 2

HasCrCard 和 EstimatedSalary 被删除，因为这些变量具有次高的 p 值(高于 0.05)。在没有这两个变量的情况下再次运行模型后，精确度和 R 平方得分略有增加。理想情况下，不应该有 p 值超过 0.05 的变量，但任期在 0.087 左右。任期可能会被取消，但从逻辑上讲，客户与银行关系的持续时间对他们的去留有一定影响。现在，模型显示没有 p 值高于阈值的变量(除了任期):

Model iteration 3

对数转换—平衡

由于 balance 的范围很大，从 1000 美元到 2000 美元增加一个单位会产生双倍的效果，而从 10，000 美元到 11，000 美元增加一个单位只会产生 10%的增长，因此需要对值进行转换，以便进行缩放。为了做到这一点，将记录日志，并在每一行增加 1，以防余额为 0。

在 Gretl 中，这是通过定义一个新变量并输入等式 log10(balance + 1)来完成的。以下是用 log_balance 替换 Balance 的结果:

Model iteration 4

衍生变量——财富积累

派生变量可以更准确地表示一些字段，如余额和年龄。例如，随着年龄的增长，年轻人的余额可能较小，而老年人的余额可能较大。或者，一个年轻人可能有一份收入丰厚的工作，与可能失去储蓄的老年人相比，他可能有更多的存款。该指标可以更好地代表客户的财务状况。

为了创建这个衍生变量，银行账户的对数余额可以除以账户持有人的年龄。这个变量被称为财富积累。以下结果是用财富积累作为等式的一部分得出的:

Model iteration 5

处理多重共线性

模型中包含 Wealth_Accumulation、Log_Balance 和 age 可能会显示精度下降和高 p 值，因为可能存在多重共线性。Gretl 可以检查共线性和方差膨胀因子(VIF)。对数余额和财富积累的 VIF 比其他变量高得多:

VIF with Log_Balance and Wealth_Accumulation

当去掉 Log_Balance 时，财富积累系数缩小:

VIF with only Wealth_Accumulation

仅包含财富积累的模型的指标是:

Model performance with Wealth_Accumulation

采用财富积累的对数可能是比未转换变量更好的度量。包括对数平衡和对数财富积累显示了共线性的影响，两个 VIF 分数都在 700 左右。

这种共线性效应可以通过取财富积累的对数并将其包含在 Log_Balance 旁边的等式中来进一步观察:

VIF with Log_Wealth_Accumulation and Log_Balance

包含 Log_Balance 和 Log_Wealth_Accumulation 变量的模型的指标是:

Model performance with Log_Wealth_Accumulation and Log_Balance

仅使用 Log_Wealth_Accumulation 评估绩效时，衡量标准如下:

Model performance with only Log_Wealth_Accumulation

最终确定模型

当比较其中一个仅使用 Log_Wealth_Accumulation 而另一个仅使用 Log_Balance 的两个模型时，具有 Log_Balance 的模型导致更高的 R 平方得分(0.151006)，并且准确性仅差 Log_Wealth_Accumulation 准确性一个正确预测(8127 对 8128)。

结果——哪些变量影响最大？

为了确定哪些变量在确定银行流失率时最重要，需要计算每个系数的优势比。

计算优势比

简单逻辑回归方程:

赔率等式:

将比值代入逻辑回归方程(也称为对数比值):

取每边的指数:

简化:

将变量增加一个单位:

指数表明增加一个单位会导致倍增效应:

计算格雷特的优势比

这些比率可以在 Gretl 中使用功能包“优势比率”进行计算:

结论—银行可以瞄准谁来减少客户流失？

结果显示，最有影响力的变量是德国人、女性和积极成员。在这种情况下，优势比是看哪些因素导致客户离开。因此，当观察这家银行的客户流失时，一个住在德国或搬到那里的客户离开的几率增加了 2.1119 倍。此外，女性顾客离开的几率增加了 1.6934 倍。另一方面，成为活跃会员表明客户仍在银行工作。最终，如果银行想要减少客户流失并留住他们的客户群，他们必须瞄准他们的德国客户，尤其是德国女性，并努力增加这些客户在银行的活动。

数据科学经济学

原文：https://towardsdatascience.com/economics-of-data-science-648beaaf0af8?source=collection_archive---------37-----------------------

一条失败多于成功的道路

无论我们在哪里看，数据科学——也许就像凯西·科济尔科夫在的一篇文章中所说的那样，只是统计学、机器学习和分析的结合——正在火热进行中。产生了这么多数据，有这么多问题要问。

我们可以用这些数据做什么？

它会把我们带到哪里？

会改善我们的生活吗？

它如何改变世界？

让我们不要忘记…我们能从中赚钱吗？

首先，免责声明

正是这种不舒服的感觉让我们开始反思数据科学…这与很久以前一个人不太记得的梦所留下的感觉没有什么不同。

随着时间的流逝，在经历了太多的 WTF 时刻后，我们感到更加焦虑，这些点似乎连接得更清楚了。

他们似乎在暗示，在追逐专业知识、职业和商业的时候，我们可能不知何故在我们的理想和目标上分心了……或者被误导了……

数据科学是所谓的“21 世纪最性感的工作”的来源，它有一个强大的黑暗面，在赶时髦时似乎很容易被忽视。

慎选！

大家都去哪了？

如今，大多数大中型组织都有专门的分析团队。随着时间的推移，我们已经习惯于认为，如果我们密切了解我们的数据，我们可以用它来增加收入或降低成本。

为了鼓励我们，世界继续在工具、算法和技术上投入大量的时间和资金。然后，它教会我们将技术与人类行为结合起来，这样我们就可以专注于消费者真正想要的东西…..并以某种方式影响他们的非理性购买决策。

解决更大更好的问题，人类也许就能获得人工智能的圣杯——感知。

数据科学能给我们这一切吗？

从外面看，很难知道炒作在哪里结束，现实在哪里开始。在泡沫中，我们还有机会吗？

或许是一门生产科学

在数据科学中，和所有其他领域一样，项目会成功，也会失败。

通过…失败。好…坏。准时…迟到。赚钱…赔钱。似乎总是二元的。

搜索网页，很容易得出结论，浪费的数量一定很大。毕竟，失败的故事无处不在——2017 年 Gartner 的一项研究甚至声称 85%的项目崩溃和烧毁率！

假设这些数字是可信的，人们可能会不寒而栗地想象，有多少宝贵的时间和金钱永远浪费在生产率低下的经济荒原上。

不出所料，被引用最多的文章也是引用数字最多的文章。巧合吗？

不管是否有成效，在某种程度上，我们开始承认数据科学可能没有我们想象的那么重要。毕竟，它似乎什么也没有生产——没有食物，没有衣服，没有住所。

更有可能的是，它只会影响生产。更好，更快，也许更干净，永远更高。

但是这种情况发生的频率有多高？

从气泡内部

无论成功还是失败，我们只有自己的经历可以沉迷和评判。

虽然宣传我们在数据科学上的胜利很诱人，但真正让我们屈服的是失败。不一定是大的或坏的，而是在一个成功的项目之后发生的失败。

事情可能是这样的——在商业案例上花费数周时间乞求签署，煞费苦心地清理(如果你可以称之为)数据，绝望地希望有一个可靠的模型，令人头晕目眩的几个小时的分析……最后……洞察力被很好地、真正地可视化，准备好接受一面坚实的数字。

以前有效的方法。

然后，什么都没有了……..一个被沉默摧毁的项目，沉得无影无踪。为什么？

这么多问题没有得到解答。动摇的信心。那些阴险的自我怀疑开始蔓延。

接下来去哪里？

"教你的舌头说我不知道，你就会进步."哲学家迈蒙尼德(1135-1204)

鉴于数据科学的潜力塑造了我们如此多不确定的未来，也许有必要寻求那些经常被问及的问题的帮助，那些没有数据驱动答案的问题。

那么，我们敢不敢通过一个不同的、不那么透明的透镜来看待这个领域呢？一个有很多灰色阴影的？并探究隐藏之手的影响…其微妙的含义和微妙的细微差别只能来自人类在玩。

为了更好地理解为什么有些事情会以这种方式发生，数据科学项目是如何在勾选了所有选项后失败的…..而另一些人在他们可能不应该成功的时候成功了。

也许，仅仅是也许，我们可能会得到这个领域在世界上真实表现的线索。

(Sep 2019) Book Fair, Bangsar Village 2, Kuala Lumpur

ecoVIZ

原文：https://towardsdatascience.com/ecoviz-39a8e50c6c1?source=collection_archive---------31-----------------------

墨西哥城公共自行车共享系统的视觉探索

埃斯特万·卡斯蒂略·蒙德拉贡

杰洛尼莫阿兰达巴罗瓦

Cover page. The first 10,000 trips of September 2019

ecobici 网络是一个为大量用户提供服务的系统，因此，它是一个拥有 480 个站点的复杂系统，每月约有 600，000 次旅行。众所周知，骑自行车对健康有好处，可以节省用户的短途旅行时间，同时有助于保护环境，减少城市交通拥堵。

网络状态

由 ECOBICI 产生的数据量是巨大的，因为每个行程产生一个记录，这些行程中的每一个记录字段，例如:

用户的年龄和性别。
撤站和到站。
撤离和到达时间。
除其他外。

为了开始理解 ECOBICI 系统，让我们从开始可视化一周内的行程分布。

Figure 1. Distribution of withdrawals during a week of March 2019 every hour.

当我们将取款视为一个时间序列时，这些为工作日、周五和周末定义的模式立即凸显出来，让我们看看 2019 年 4 月每种类型的平均分布。

Figure 2. Withdrawal daily distribution in April 2019

看到工作日和周末之间的明显区别是很有趣的。除了星期五下午之外，工作日之间的分布似乎是相同的。在节假日，这在图 2 中。恰逢复活节假期周的日子，分布与周末几乎一致。工作日是出行次数最多的日子，这些日子具有双峰分布，高峰与工作日的出入时间一致。在周末，该系统在中午达到最大使用率。

工作日

工作日是最活跃的，在上午和下午有两个明显的高峰时间，看到前面的图表，我们可以毫无顾虑地确认工作日实际上是相同的，这就是为什么我们认为可视化工作日中的活动足以理解系统中的大多数活动。

以下视频显示的是 ECOBICI 在 2019 年 6 月 12 日的总活动量，选择这一天是因为在样本中是一个普通工作日，注意不要因为天气或其他原因选择非典型日。这一天共有 32，363 次出行，高峰时段每小时 3，738 次。

在高峰时段(大约早上 8 点和晚上 8 点)可以随意暂停。).

Figure 3. Activity throughout June 12, 2019

让我们花点时间来理解前面的图表，从而能够提取它给出的所有信息。让我们从把车站想象成每个圆圈开始。圆圈的大小对应于该站每小时的取款和到达的总和，140 次到达加上取款是该站每小时的最大活动。这些站里里外外都是彩色的。内部颜色响应每小时显示的余额，也就是说，在该站一小时内是否有更多的提款或到达。深红只代表撤回，深蓝代表到达，白色代表完美的平衡。外观颜色对应的是站点的状态，即 ECOBICI 在该时间段在该站点所占的自行车位比例，暗红色表示站点没有可用的自行车，白色表示站点已满。行程由两个站点之间的直线定义，显示每小时的行程次数。

视频的再现可以正确识别高峰时间，也可以看到早上公共交通附近的车站，如 Polanco 和 Buenavista 地铁站，是大多数旅行的起点，旅行的终点是高劳动力区域，如 Polanco 和 Reforma Avenue 的某些部分。这种现象在下午几乎完全相同，但方向相反，现在劳动力密集的区域变成了起点，而到达点是与更高范围的公共交通的交叉口。让我们来看看早高峰时段的一帧视频。

Figure 4. ECOBICI June 6 8:30 am. 2019

显示屏突出显示系统外围的饱和度。这表明该系统的大部分用户来自其他地方，他们可能对该系统的更广泛覆盖感兴趣。

此外，如果我们关注车站的状态(每个圆圈的边缘)，可以看到在到达和离开的每个突发之后，车站是满的和空的，具有许多到达的车站变得饱和(白色边界)，与具有许多撤回的车站变得空(黑色边缘)相反。

共享自行车系统的特殊动态表明，通过再平衡来强调库存优化，如 — Castillo，2019 所示。避免饱和和缝隙。

一点透视和尺度

ECOBICI 的用户是哪些人？通过工作日的旅行分布，我们可以推断，一般来说，这些用户对应于工作人员。让我们再深入一点，通过下面的图片来更好地理解他们的简介。

Figure 5. Percentage of trips by sex in September 2019

看到性别在使用上的巨大差异可能是一个警告，表明存在性别问题，在更深入的分析中，这种差异可以在每个车站中可视化，以表明在 ECOBICI 覆盖的城市全景中妇女或多或少的安全区域。

Figure 7. trips by age histogram in September 2019.

另一方面，年龄的分布突出了社会项目的机会领域，如将青少年纳入系统，或鼓励 40 岁以上的人参加体育活动的可能性。

现在，让我们稍微放松一下对 ECOBICI 的关注，从的规模获得一些视角，让我们看看这个城市所包裹的系统。

Figure 7. ECOBICI and Mexico city.

ECOBICI 占据了墨西哥城很小的面积！然而，重要的是要明白，墨西哥城的近三分之一被密尔沃基和埃尔阿胡斯科周围的森林地区占据，所以让我们通过放大一点来只关注市区。

Figure 8. ECOBICI, subway(orange dots) and urban area.

扩展该系统的机会是巨大的，包括可能与墨西哥州的城市地区整合，以及与覆盖范围更广的其他交通系统整合。这也引发了人们的想象，即能够将农村地区的山区生态社区纳入其他肯定会促进社会福利的可能项目中。

汇总系统信息

由于本文是一个可视化练习，我们创建了下面的图表，目的是可以在大尺寸的打印中观察到它。它显示了 2019 年 9 月期间 ECOBICI 的总活动量。如果我们放大图表，我们可以详细观察每个车站的名称、其活动、车站之间的流量以及系统附近的地铁站。

Figure 9. Flow during September 2019 (Click here to see image full size)

接近这种视觉化可以让你对一个可能的新自行车道和站点网络产生一个相当健壮的第一想法。免除要求，因为这些路线中的许多已经被占用，在公共道路上为这些生态自行车手和骑自行车的人留出一些咪表将认可他们，并为他们提供政府的安全保障，此外，即使对他们存在少数激励措施，也支持智能移动系统。扩大这些形式的流动性将改善许多目前处于红色数字的社会变量。

通过增加体育活动来增进健康。
由于碳氢化合物驱动的运输减少，空气质量提高。
道路拥堵减少。
减少其他公共交通系统的超载，特别是在著名的最后一英里。
除了使用自行车造成的其他已知影响之外。

结论

对当代社会项目规模的适当关注是其成功的最重要的变量之一，这就是为什么我们相信合作。我们还确信，公共解决方案的搜索和验证必须是一项集体工作，因此，在这个项目中开发的所有分析都可以复制，因为所有脚本都可以在这个公共存储库中获得。最初的西班牙文文章是在 Jupyter 笔记本中设计的，而内容 50%是用 Python 和 matplotlib 图形制作的，50%是用 R 和 ggplot 制作的，以提及一些被占用的自由软件库。我们自豪地宣布，它在由 CIMAT 举办的数据可视化竞赛中获得了第一名！

对数据的正确解读可以为公共政策的有效实施提供必要的杠杆，我们庆祝最近由交通部长发布的公告对 ECOBICI 系统的新招标，我们希望获胜者考虑现有的信息，以前的解决方案是成功的，但是它已经达到饱和。如果新的解决方案能更好地被妇女和年轻人以及来自不同殖民地的人们所采用，那就太好了。

我们希望除了在读者的头脑中产生其他的东西之外，这些形象化的东西足以支持我们的叙述。

二战期间气象站的 EDA

原文：https://towardsdatascience.com/eda-of-weather-stations-during-wwii-bddfff8e8872?source=collection_archive---------29-----------------------

与 GeoPandas 和 Seaborn 一起讲述一个不同的战争故事

第二次世界大战是人类历史上最致命的冲突之一，夺去了数百万人的生命，并塑造了我们至今的政治、社会和经济环境。除了武器和子弹，天气在冲突中也扮演了重要角色。

诺曼底登陆日本不应该在 6 月 6 日，但由于恶劣的天气条件而推迟了。太平洋剧院的部队不得不在战斗间隙承受相当大的降雨量。更不用说德军不得不面对温特将军。

气象站数据集

在战后几十年的今天，由于 国家环境信息中心 的努力，任何人都可以方便地下载战争期间许多国家的天气数据，但数据集也可以在 Kaggle (以及互联网上的许多其他地方)获得。

这里的目标是检查气象站在全球的空间分布情况，并了解有多少气象站位于不同的国家。假设你要用一点代码更新 NCEI 的地图。

用`DataFrames`制作地图

像往常一样，首先从工具箱中拿出工具:

除了通常的Pandas 等之外，为了制作地图，你将使用[GeoPandas](http://geopandas.org/)和[Shapely](https://shapely.readthedocs.io/en/stable/manual.html)包的组合，你可以安装:

现在你已经做好了一切准备，用Pandas读取数据集:

如果你从 Kaggle 下载数据集，你可能会看到两个文件:一个是实际的天气数据，另一个是关于气象站的信息，也就是你在上面读到的那个，所以我们将把天气分析留到另一个时间。数据集如下所示:

到目前为止，那只是另一个普通的DataFrame，所以你怎么能把它做成地图呢？首先，您需要创建另一个包含每个气象站的'Longitude'和'Latitude'的列，然后是apply和Point函数，这样GeoPandas就可以了解位置:

顺便说一下，您的DataFrame现在包含了'Coordinates'列，看起来像这样:

'Latitude'和'Longitude'的值共同构成一个Point像一个有序的对被绘制在一个笛卡尔平面上，有了这个信息你可以构成一个不同类型的DataFrame:一个由GeoPandas解释的GeoDataFrame。

最后，一切准备就绪，您可以看到二战期间全球气象站的分布:

GeoPandas可以读取你可能有的各种形状文件，但这里你使用的是来自自然地球的简单标准naturalearth_lowres形状。

从表面上看，气象站的数量并不令人印象深刻，甚至与我们今天拥有的气象站相差甚远。除了这里和那里的几个点，没有关于美国天气的数据，更不用说饱受战争蹂躏的欧洲，但从好的方面来看，我们有一些非洲和太平洋剧院的电台，显然巴西也有一些。在这一点上，你应该花一分钟考虑一下在战争期间保存天气信息有多困难，你会看到上面的数量是相当可观的。

总共有 161 个气象站，但是每个国家有多少个？使用Pandas，这个问题很容易回答。

各国气象站

活动这一部分的目标是groupby将每个站点分配到其所在的国家和count总数量，这可以通过Pandas轻松完成:

你不喜欢Pandas有多优雅吗？任务已经完成，但是用Seaborn的手来策划一下也无妨:

单个来看，大多数国家只有一个自己的气象站，而澳大利亚和日本等太平洋沿岸国家明显高于平均水平。查看这些信息的另一种方式是通过直方图，这也很容易通过Seaborn获得:

现在，正如你所看到的，这里考虑的大多数国家在二战期间只有一个空间站，但我们并没有抱怨。虽然直方图非常简单，但它能很好地展示任何时间序列的频率分布。

结论

第二次世界大战气象站数据集非常有趣，如果你是一个历史迷，它也可以提供一些不错的新的好奇心。它也是空中轰炸数据集的同伴，所以也来看看这个。

只需一点探索性数据分析(EDA)，您就可以提供关于数据的新见解和信息，因此有时简单是最好的，一些工具永远不会过时。

如果你想下载源代码和上面的图表，有一个资源库你可以直接到这里去获取。

干杯！

基于网络的图形 EDA x

原文：https://towardsdatascience.com/eda-on-graphs-via-networkx-a79d2684da53?source=collection_archive---------20-----------------------

利用 networkx 库探索生态小区生境分类学

介绍

探索性数据分析(EDA)旨在发现数据中隐藏的结构。基于手头的数据，EDA 可能包括特征和标签的相关性分析、样本的分布分析、散点图、直方图等等。EDA 对于从建模和预测阶段可以利用的数据中获得洞察力非常有用。

从某种意义上说，图是一种特殊的数据结构，因为已知某些样本(相邻顶点)在某种程度上更相关。与大多数 ML 数据集不同，图可能没有明确的特征。在这种情况下，发现图中的结构变得更加重要，因为这是唯一的事情。

在这个故事中，我们将考虑细菌栖息地的分类。作为语义搜索项目的一部分，我和赛仑·帕拉尔对这个分类法很感兴趣。个体生态位是细菌可以生存的环境层次。个体生境通过定义栖息地(顶点)之间的关系来指定层次，这是数据中唯一的交互类型。然而，每个顶点都与一个在本体中标识它们的 ID 和一个映射到真实名称的名称相关联。在 BioNLP 任务下共享了 OntoBiotope，其 2016 版可以在这里找到。

图表统计

我们对生态小区进行处理以创建一个无向图，其中两个节点是相邻的，如果它们之间有一个*关系。让我们先看看有多少个节点和边。注意，我们将 networkx 图存储在一个名为 graph 的变量中。*

print(graph.number_of_nodes(), graph.number_of_edges())
2320, 2528

由于个体生态位是一种分类学，因此预期边的数量少于具有这么多节点的常规图。为了分析图形结构，让我们计算深度、直径和最大团大小。为了计算深度，我们计算从根到每个其他节点的最短路径，并找到最大最短路径距离。

depths_graph = nx.shortest_path_length(graph, source='OBT:000000')
depth = max(depths_graph.values())
diameter = nx.algorithms.distance_measures.diameter(graph)
max_clique_size = nx.algorithms.clique.graph_clique_number(graph)print(depth, diameter, max_clique_size)
10, 20, 3

我们看到离根最远的节点距离为 10，而最远的节点对距离为 20。假设我们的图有一个树状结构，直径是深度的两倍是一个普通的结果。另一方面，我们可以看到它不是一棵树，因为它包含一个 3 的团，这是树的一个禁忌结构。下面我们可以看到一个来自个体生态位的 3-集团。

A 3-clique from OntoBiotope.

节点统计

看了一下整个图的结构，现在让我们单独考虑节点。中心性度量经常用于描述节点的特征。尽管有许多变体，我们将考虑唯一的度和特征值中心性，因为大多数变体的行为相似。多亏了 networkx，计算这些分数非常简单。

degree_cent = nx.degree_centrality(graph)
eigen_cent = nx.eigenvector_centrality(graph)

当我们分析结果时，我们看到实验介质在两种情况下都具有最高的中心性分数。这个节点位于深度 1，并且与许多栖息地相邻，因为它有一个相当全面的定义。

改进

基于我们目前的分析，我们可以说，生态小区是一个具有小集团和很少中心节点的松散连接的图。因此，我们需要丰富其内容，以获得更多的洞察力。为此，我们利用分类提供的 PubMed 摘要。在提供的摘要中，对这些栖息地的提及已经被注释。

假设在抽象中共存的栖息地是相关的，我们可以在图中使它们相邻。

当我们使用这个假设时，我们在现有的图中引入了更多的边，并创建了新的关系。我们现在可以重新计算之前的统计数据。

depths_graph = nx.shortest_path_length(enriched_graph, source='OBT:000000')
depth = max(depths_graph.values())
diameter = nx.algorithms.distance_measures.diameter(enriched_graph)
max_clique_size = nx.algorithms.clique.graph_clique_number(enriched_graph)print(enriched_graph.number_of_edges, depth, diameter, max_clique_size)
3610, 10, 16, 15

这里我们看到边的数量显著增加。相应地，直径从 20 缩小到 16，集团数量从 3 增加到 15，这是一个巨大的变化！另一方面，树的深度仍然相同，这意味着从根到叶子的距离没有改变。然而，根据直径的减小， 我们可以得出结论，新的路径是由树叶之间的共现关系引入的。

The larges clique in the enriched OntoBiotope

现在让我们观察中心性的变化。我们一起绘制两个图的度和特征值中心性的直方图。我们采用中心性分数的对数来处理小数字。

Degree centrality histograms of the original and enriched graphs.

在上面的直方图中，我们看到富集导致了向高中心性节点的转移。 这意味着某些节点在 PubMed 摘要中比其余的 被提及得多。因此，低中心性节点的频率降低。

Eigenvalue centrality histograms of the original and enriched graphs.

特征值中心性直方图具有不同于度中心性的特征。我们观察到，在初始图中，中心性主要集中在同一个箱中。使用浓缩物，将这群人分散到两边。 因此，富集在数据中创造了一种方差，这种方差可以被机器学习模型所利用。

结论

在这个故事中，我们从几个不同的方面分析了生物群落分类。在分析过程中，我们观察到该图的信息并不丰富，我们应用了基于文本共现的丰富。重新计算统计数据，我们已经看到中心性和扩大的子结构(如 15 人集团)的方差增加。请注意，EDA 是一个永无止境的迭代过程，它为建模阶段提供信息，也被建模阶段提供信息。如果你有兴趣，可以从这个回购开始关注我们项目的状态。

参考

[1]http://2016.bionlp-st.org/

用这段 Python 代码自动编辑你的视频！

原文：https://towardsdatascience.com/edit-your-videos-automatically-with-this-python-code-c704cc413a1?source=collection_archive---------13-----------------------

是的，这是真的，小心编辑！！谢谢 Python。

时候到了！我正在为商业科学和 T2 科学等令人惊叹的公司制作课程，我正在编辑视频，这是一件痛苦的事情！！我在这里给你展示的软件是由伟大的卡里克开发的。

该系统的目标是编辑视频中令人讨厌的沉默，我们犯的错误，以及几乎所有你喜欢的东西。

它不会把你的视频变成一个美丽的视频，但至少它会让你省下一小时又一小时听自己失败的时间。

如果你不是视频制作者，但你在网上观看视频，这可以帮助你更快地观看。我记得当我在学习的时候，我看了很多斯坦福和麻省理工的视频，花了我几个小时，很多时候教授甚至不说话。所以这个也能帮上忙。

装置

我在 MatrixDS 上测试了这个系统，matrix ds 是在几秒钟内免费推出终端和 Jupyter 笔记本的最佳工具之一。所以你可以在那里复制它。

您需要做的第一件事是克隆回购:

[## 卡里克/jumpcutter

自动编辑 vidx。这里解释一下:https://www.youtube.com/watch?v=DQ8orIurGxw-卡里克/jumpcutter

github.com](https://github.com/carykh/jumpcutter.git)

git clone [https://github.com/carykh/jumpcutter.git](https://github.com/carykh/jumpcutter.git)

然后安装要求:

cd jumpcutter
pip install --user -r requirements.txt

你还需要 ffmpeg。如果你在 Ubuntu 上:

sudo apt update
sudo apt install ffmpeg

如果您在 MatrixDS 中，您需要成为 root 用户，因此:

sudo su
apt install ffmpeg

使用

现在是有趣的部分！我制作了一个简单的视频来测试这一点。这里可以看到原视频:

我在 MatrixDS 里做的是把视频上传到克隆的 repo 的同一个文件夹里。然后在运行该命令后:

python3 jumpcutter.py --input_file auto_2.mp4 --sounded_speed 1 --silent_speed 999999 --frame_margin 2

我在几秒钟内就编辑好了我的视频。秒！！

您可以在这里看到结果:

这简直太棒了:)

现在还没有太多关于这个软件的文档，但是代码是开源的，所以你可以去回购看看所有的东西。

基本命令是

python jumpcutter.py --input_file path/to/file.mp4

您可以使用以下选项:

optional arguments:
  -h, --help            show this help message and exit
  --input_file INPUT_FILE
                        the video file you want modified
  --url URL             A youtube url to download and process
  --output_file OUTPUT_FILE
                        the output file. (optional. if not included, it'll just modify the input file name)
  --silent_threshold SILENT_THRESHOLD
                        the volume amount that frames' audio needs to surpass to be consider "sounded". It ranges from 0 (silence) to 1 (max
                        volume)
  --sounded_speed SOUNDED_SPEED
                        the speed that sounded (spoken) frames should be played at. Typically 1.
  --silent_speed SILENT_SPEED
                        the speed that silent frames should be played at. 999999 for jumpcutting.
  --frame_margin FRAME_MARGIN
                        some silent frames adjacent to sounded frames are included to provide context. How many frames on either the side of speech
                        should be included? That's this variable.
  --sample_rate SAMPLE_RATE
                        sample rate of the input and output videos
  --frame_rate FRAME_RATE
                        frame rate of the input and output videos. optional... I try to find it out myself, but it doesn't always work.
  --frame_quality FRAME_QUALITY
                        quality of frames to be extracted from input video. 1 is highest, 31 is lowest, 3 is the default.

是啊！你甚至可以通过一个 YouTube 视频链接，它会下载原来的视频，并改变视频创建一个新的。为此，该命令将如下所示:

python3 jumpcutter.py --url [https://youtu.be/2MjlMpEzDA8](https://youtu.be/2MjlMpEzDA8) --sounded_speed 1 --silent_speed 999999 --frame_margin 2 --frame_rate 3

仅此而已。

可爱的作品。顺便说一下，这些代码只有 203 行代码！这些天来，Python 的力量让我感到惊讶。

感谢你阅读这篇文章。如果您有任何问题，请在此写信给我:

[## 法维奥·瓦兹奎——science y Datos | LinkedIn 创始人/首席数据科学家

加入 LinkedIn ‼️‼️重要提示:由于 LinkedIn 技术限制，我现在只能接受连接请求…

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

祝学习愉快:)

教育技术和算法透明性

原文：https://towardsdatascience.com/edtech-algorithmic-transparency-76b7985fa018?source=collection_archive---------16-----------------------

对卡米拉·坎贝尔 SAT 成绩的调查提醒人们透明和可解释的人工智能的重要性

Photo by NeONBRAND on Unsplash

围绕佛罗里达州高中生卡米拉·坎贝尔的 SAT 分数调查的最近新闻为日益增长的教育技术领域中围绕算法透明度的问题提供了一个有趣的视角，该分数被大学委员会标记为可能作弊。虽然很可能只有一部分用于标记考试的过程是自动化的，但双方的回应凸显了在越来越被不透明算法主导的教育领域将变得司空见惯的问题。

背景

据 CNN 和其他媒体报道，Campbell 的第二次 sat 考试取得了 330 分的进步，但在发现她的答案与其他学生的答案非常相似后，被大学委员会扣留并进行调查。由民权律师本·克伦普代理，坎贝尔请求及时公布她的 SAT 成绩，以便她被大学录取并申请奖学金。克伦普说:“【1230 分(分数)对她是否能进入梦想中的大学以及她是否负担得起有很大影响。

大学委员会发布了一份声明，澄清了他们的审查过程，该过程着眼于各种因素，以确定学生的分数是否应该因涉嫌作弊而被保留或取消。作弊的证据可能包括一个学生的答案与一组其他学生的答案之间的高度相似性，存在(在该组中)以前被取消分数的学生，答案与被没收的“小抄”的相似性，以及学生的测试手册中没有草稿。大学委员会发给坎贝尔的这封信引用了“(她)在考试的一个或多个得分部分的答案与其他考生的答案基本一致”作为将考试标记为审查的原因。虽然在原始文章或评论声明中没有说明，但这个初始标志可能是该过程中唯一自动化的部分。

人工智能与教育技术的相关性

不管审查过程的结果如何，也不管坎贝尔对公布分数的要求如何，围绕这个故事的言论凸显了对教育科技行业来说很重要的几个问题，即在人工智能和机器学习方面投入巨资作为其未来。

透明度

克伦普向美国有线电视新闻网明确表示，过程的透明度是一个关键问题，他说“她现在被指控作弊。为什么呢？他们说，‘哦，你只需要相信我们的话，我们发现有些事情是错的，’”，T4 补充道，“他们需要告诉我们(他们看到了什么)。”

这提醒我们，当大部分技能或能力评估完全自动化时，透明度是多么重要。大学委员会最初的信，以及他们后来发布的声明，试图通过概述他们的过程来解决这个问题，但它的不完整性留下了许多问题。—标记过程是自动化的吗？答案需要有多相似才能被标记出来？这个截止日期是如何选择的？高于此临界值的相似性的假阳性率是多少，它是如何确定的？—这些问题的答案是存在的，但是它们是否已经有效地传达给了相关的利益相关者？

欧洲委员会人工智能高级专家组(AI HLEG)已经为他们所谓的“值得信赖的人工智能”起草了道德准则，并且他们提供了关于透明度的特别建议。他们建议供应商“以清晰和主动的方式向利益相关者提供关于人工智能系统的能力和局限性的信息……”，进一步建议他们必须“努力促进人工智能系统的可审计性，特别是在关键的环境或情况下。尽可能地设计你的系统，使之能够追踪个人决策到你的各种输入；数据、预先训练的模型等。此外，定义人工智能系统的解释方法。”

一个担忧可能是:大学董事会能提供多少信息而不冒人们试图“玩弄系统”的风险？用 AI HLEG 的话说，“要注意不同目标之间可能存在根本性的矛盾(透明度可能会为滥用敞开大门；识别和纠正偏见可能与隐私保护形成对比)。沟通并记录这些权衡。”

Crump 选择关注透明度的事实很能说明问题，EdTech 的教训是，在部署评估算法之前，必须充分考虑这些问题。

有责任

Crump 公布分数的另一个重点是相互问责的问题。他认为“他们希望这些学生对他们负责，但是这个系统不对任何人负责。…好吧，这一次，他们也必须对此负责。”

这一信息应该会引起那些开发和部署算法解决方案来评估、评分、测量和预测人类技能和行为的人的强烈共鸣。机器所做决策的后果以潜在的重要方式影响着现实中的人，当出现问题时谁该负责的问题变得越来越恰当。 Forrester Consulting 的一项调查(受毕马威国际公司委托)发现，62%的受访者将归咎于开发导致自动驾驶汽车事故的故障软件的公司，54%的人还将归咎于安装该软件的制造商，以及本可以手动控制的司机(这是一个“选择所有适用的”问题)。在 EdTech 中的类比是，创建人工智能软件的供应商在出现错误的情况下陷入困境，紧随其后的是购买该软件的学区或机构以及选择使用它来代替直接人工评估的教育工作者。

这并不意味着大学委员会做错了什么，或者人工智能没有令人难以置信的潜力来改革和民主化教育，但 Kamilah Campbell 案件提出的问题确实给了 EdTech 创新者停下来仔细考虑开发过程中每一步的透明度和问责制问题的理由。

用 BCI.js 在 Node.js 中进行脑电运动想象分类

原文：https://towardsdatascience.com/eeg-motor-imagery-classification-in-node-js-with-bci-js-d21f29cf165?source=collection_archive---------14-----------------------

检测与想象动作相关的脑电波

脑机接口(BCI)允许只使用你的思想来控制计算机和其他设备。实现这一点的一种流行方法是用脑电图(EEG)检测运动想象。本教程将介绍运动想象的检测和分类。我把它分成了五个部分:

加载数据
特征抽出
训练分类器
测试和分析结果
改善结果

您可以在其 GitHub repo 中找到本教程中使用的完整代码和数据。

第 1 部分—加载数据

首先，为项目创建一个新目录。然后，在项目目录中，将数据下载到名为“data”的文件夹中。我们将使用在 http://bnci-horizon-2020.eu/database/data-sets 的发现的‘四级运动想象(001–2014)’数据集。我已经将数据集制作成 CSV 文件，您可以从下面下载:

右手训练. csv
右手测试. csv
双脚测试. csv
foots-training . CSV

您还可以使用 bash 的这个脚本或 PowerShell 的这个脚本下载数据。

如果您想试验来自不同主题或数据集的数据，可以使用。mat 文件可以在本教程的 GitHub repo 中找到。您还可以在 data/ 目录中找到包含其他想象运动的 CSV 文件。

我们将使用 BCI.js 将数据加载到 Node.js 中。如果你没有安装 Node.js，可以在这里下载。

一旦安装了 Node.js 和 NPM，通过在项目目录中运行以下命令来安装 BCI.js

npm install bcijs

现在我们可以从项目目录的根目录下的 classify.js 开始。首先需要 BCI.js 并加载相关的 CSV 文件。由于 CSV 加载方法是异步的，我们必须将它们包装在一个异步函数中，并使用 await 关键字，这样 Node.js 在文件加载之前不会继续:

第 2 部分—特征提取

一旦数据被加载，我们将使用公共空间模式 (CSP)作为特征提取方法的一部分。CSP 试图设计数据，使得当想象脚运动时，第一个信号将具有高的方差，而最后一个信号将具有最低的方差，而当想象右手运动时则相反。考虑到这一点，我们可以使用每个 CSP 信号的方差作为分类的特征向量。

本教程遵循 Christian Kothe 在他的 CSP 讲座中描述的方法。如果你想了解更多，他有关于 CSP 和 BCIs 的精彩讲座。

现在我们可以开始研究特征提取方法了。CSV 中的每 750 个样本来自单独的 3 秒试验。我们可以使用 BCI.js 中的 windowApply 方法从每个试验中选择数据。第三个参数是窗口的大小，最后一个参数是窗口每次迭代应该走多少步:

对于每次试验，我们将数据分成大约四分之一秒的窗口或时段，我们可以使用 CSP 生成一个特征向量。取方差的对数使数据更加正态分布，这将有助于以后训练分类器。

我们传递 epochSize/2 作为窗口步长，因此窗口之间有 50%的重叠。方法 bci.features.logvar 用于计算每个 CSP 信号方差的对数。值“columns”被传递，因为在 2d 数组“cspSignals”中，每一列是一个信号，每一行是一个样本。最后，我们将每次试验的特征连接成一个长的特征向量阵列。

第 3 部分—训练分类器

现在我们有了特征，让我们学习一个分类器。线性判别分析(LDA)是 BCIs 的一种常用分类器。它使用训练集数据的均值和标准差来绘制两个类之间的分界线(或更高维度中的超平面)。你可以在 https://bci.js.org/examples/lda/找到关于 LDA 如何工作的视频演示。

要学习 LDA 分类器，您可以使用 ldaLearn 方法:

第 4 部分—测试和分析结果

现在我们已经学习了一个分类器，让我们使用测试集来评估它。为此，我们将使用 ldaProject 方法。当预测是第一类时，它返回负数，当预测是另一类时，它返回正数。如果它返回一个接近零的值，那么它对分类就更加不确定。

一旦我们使用 ldaProject 来预测训练集数据的类别，我们就可以使用混淆矩阵来评估它的性能。混淆矩阵将数据放入 2x2 矩阵中，其中每个单元代表以下内容:

我们可以使用混淆矩阵方法计算这个混淆矩阵。最后，我们计算平衡的准确度(脚运动的准确度和右手运动的准确度的平均值)，以查看我们的分类器执行得有多好(完整的脚本可在此处找到):

通过运行这段代码，我们获得了以下结果:

混淆矩阵:

1243  275
198   1342

平衡精度:

0.84513

这是一个不错的结果，在 3058 个特征中，2585 个被正确分类。然而，当 ldaProject 返回值接近零时，我们可以通过让分类器返回“unknown”来实现更高的准确性。

通过过滤掉 LDA 预测接近零的值，我们可以看到添加“未知”会如何影响我们的结果:

通过这种修改，我们得到以下结果:

混淆矩阵:

925  81
67   940

平衡精度:

0.92647

34.17%的分类被返回为未知。虽然这是一个很高的百分比，在每秒四个分类的情况下，大约每三个结果中就有一个被丢弃仍然会产生相当快的响应时间。代价是，我们达到了 92.6%的准确率。通过一些改进，我们可以得到更高的结果。

第 5 部分—改善结果

带通滤波

我们可以通过对数据进行带通滤波来去除噪声和不需要的频带，从而进一步改善结果。在 Christian Kothe 关于 CSP 的讲座中，他建议在 7 到 30 赫兹之间进行过滤。我们可以使用 fili 添加一个带通滤波器:

npm install fili

然后，修改特征提取方法以包括带通滤波器:

这一修改为我们提供了以下结果:

混淆矩阵:

898  54
54   960

平衡精度:

0.94501

除了准确率上升到 94.5%，分类为未知的结果的百分比下降到 21.4%。

在修改后的代码中，您可以看到我们将 filterOrder 设置为 128。高阶滤波器意味着它可以更精确地过滤 7 到 30 Hz 之间的频率。Fili 包含一个关于滤波器阶数如何影响滤波器的互动演示。例如，传入以下参数:

类型:FIR，Fs: 250，Fc: 7，Fc2: 30，FIR 阶数:32，计算:Sinc 带通

我们得到:

但是将滤波器阶数从 32 改为 128，我们得到:

在第一个例子中，只有大约 19 Hz 保持接近 100%,而其他频带被最小化。然而，在具有高阶滤波器的第二示例中，7 和 30 Hz 之间的值保持接近 100%,而其他频带被过滤到大约 0。

最后，如果我们允许更多的未知数，我们可以达到更高的精度。通过将分类方法中的阈值从 0.5 更改为 1，我们将未知百分比增加到 47.7%，并得到以下结果:

混淆矩阵:

672  16
22   599

平衡精度:

0.97066

逻辑回归

我们还可以将 LDA 视为一种降维方法，并将输出传递给逻辑回归，逻辑回归估计样本在每个类别中的概率。为此，我们可以使用 js-regression :

npm install js-regression

上述代码将 58.4%归类为未知，并给出以下结果:

混淆矩阵:

568  10
11   451

平衡精度:

0.97944

就是这样！

这是我的第一个教程。我感谢任何反馈，并将回答任何问题。如果你对更多与 BCI 相关的帖子感兴趣，你也可以在 Twitter 上找到我。

GitHub 上的 BCI.js:

[## pwstegman/bcijs

JavaScript — pwstegman/bcijs 中的脑电信号处理和机器学习

github.com](https://github.com/pwstegman/bcijs)

BCI.js:

[## bcijs

脑电信号处理和机器学习

www.npmjs.com](https://www.npmjs.com/package/bcijs)

其他库:

fili —一个用于 JavaScript 的数字过滤器库

js-regression —线性回归和逻辑回归的 JavaScript 实现

早在 2017 年，我就开始了 WebBCI 的工作，后来它变成了 BCI.js。我后来在 WebBCI 上发表了一篇论文，并讨论了初步的基准测试以及用 JavaScript 处理脑电图的有效性。如果你很好奇或者想在发表的作品中使用 BCI.js，请查看我关于这个主题的论文:

页（page 的缩写）Stegman，C. Crawford 和 J. Gray，“WebBCI:建立在现代网络技术上的脑电图工具包”，载于《增强认知:智能技术》，2018 年，第 212-221 页。

剑桥分析公司的脸书广告对 2016 年美国总统大选的影响

原文：https://towardsdatascience.com/effect-of-cambridge-analyticas-facebook-ads-on-the-2016-us-presidential-election-dacb5462155d?source=collection_archive---------8-----------------------

剑桥分析公司(Cambridge Analytica)是一家广告公司，是 SCL 集团的一个分支，成立于 2013 年，但截至 2018 年 5 月 1 日已经停业。该公司有一个政治和商业部门，从他们的网站上看，政治部门“将预测数据分析、行为科学和创新的广告技术结合到一个获奖的方法中。”该公司在共和党初选中为特德·克鲁兹竞选团队工作，并成功帮助他获得第二多的选票，仅次于唐纳德·特朗普。该公司随后在大选中为特朗普竞选团队工作，并帮助他获胜。《剑桥分析》在特德·克鲁兹共和党初选中采用的策略之一是根据脸书用户的个性向其投放有针对性的广告。然而，该公司被迫删除了 2015 年通过脸书获得的所有数据(在川普和希拉里之间的大选之前)，因此最有可能的是，这种策略只被克鲁兹竞选团队使用。这篇文章将阐述前面提到的三种策略(行为科学、数据分析、创新广告技术)在运行微目标脸书广告时是多么的重要。此外，本文将描述广告的成功是如何被媒体、首席执行官 Alexander Nix 以及揭发者和前雇员 Christopher Wylie 限制和夸大的，原因各不相同。

在分析脸书广告的效果之前，重要的是要更详细地了解该公司的动机，以及它为什么成为主流新闻话题。该公司旨在通过向不同的人展示同一问题的不同广告来说服用户以某种方式投票。说服是通过收集脸书页面上用户喜好的信息，并使用这些数据创建预测个性的模型来完成的。亚历山大·科岗领导的全球科学研究机构剑桥分析公司被发现违反了脸书的服务条款，因此脸书要求科岗提供数据的所有公司，包括剑桥分析公司，在 2015 年删除所有脸书的数据。数据删除发生在特朗普和克林顿之间的 2016 年大选开始之前，因此剑桥分析公司声称，他们没有使用 GSR 的任何数据来帮助特朗普的竞选活动。当一名前雇员转变为揭发者克里斯托弗·威利(Christopher Wylie)接近媒体时，关于该公司的新闻曝光了。Wylie 和媒体关注了两个方面。一个方面是剑桥分析公司获取用户脸书数据行为的合法性，第二个方面是脸书广告的有效性及其道德问题。鉴于许多调查仍在进行中，法律影响超出了本文的范围，但将对脸书广告的成功进行评估。

要理解剑桥分析公司的脸书广告策略，你必须理解行为科学、数据分析和创新广告技术是如何结合在一起的。行为科学是指与人类或动物、行为和行动相关的研究领域。剑桥分析公司的最终目标是说服用户投票支持他们的客户，这包括显示最有可能导致行为改变的信息。下面的例子摘自 Alexander Nix 在 Concordia 峰会上的发言，说明了在传达信息时牢记行为科学的重要性。想象你正在沙滩上散步，看到了下面左边的标志。

Image sources: http://massrealestatelawblog.com/wp-content/uploads/sites/9/2012/07/public-beach-sign.jpg https://encryptedtbn0.gstatic.com/images?q=tbn:ANd9GcQUmyDglOdnQ6JC2AqpK6b0veP97Zw5LwScJIdTVZsoX-YyXMoa

左边的标志可能会让你转身离开，但如果你看到右边的标志，你会有更强烈的冲动这样做。这两个标志的动机都是为了确保你离开该地区，但右边的标志引起了更强烈的共鸣，可能是对所有人来说，因为害怕受到鲨鱼的攻击。在这个例子中，在看到右边的信息后，每个人可能都有最强烈的冲动采取行动离开海滩。然而，在政治领域，根据预先存在的信仰和价值观，不同的人可能更容易被不同的信息所说服，以支持同一个候选人或问题。剑桥分析公司因此假设，如果他们有一个衡量某人个性的标准，他们可以策划一个对他们来说最有说服力的广告。因此，他们将能够通过使用个性化的、有针对性的广告来说服许多具有不同个性的不同人对某一特定问题或候选人持有相同的观点。

为了通过使用行为科学来说服潜在的投票者以某种方式投票，人们需要一些关于广告目标是谁的信息。为了做到这一点，Cambridge Analytica 首先必须找到一种方法来获取数百万用户的原始数据。然后他们必须利用这些数据来预测用户的个性。这就是数据分析——从原始数据中提取有用信息的科学——的用武之地。《剑桥分析》求助于心理学家、剑桥大学研究员亚历山大·科岗。克里斯多佛·怀利当时是该公司的一名员工，负责处理与科岗的关系，科岗成立了一家名为全球科学研究(GSR)的公司。然后，科岗创建了一项调查，询问受访者的个性，并使用第三方在线调查供应商 Qualtrics 通过向每个人支付几美元来招募参与者。该调查要求受访者同意访问他们的脸书数据，包括他们喜欢的页面。

至关重要的是，科岗还可以访问受访者朋友的页面赞，因为这是脸书为开发者提供的一项功能。科岗在向英国议会“数字、文化、媒体和体育委员会”提交的证词中提到，从 2006 年到 2015 年，脸书 API 的核心功能是，只要用户的朋友没有关闭某些安全设置，你就可以收集他们的数据。没有更改脸书上某些隐私设置的被调查者的朋友，默认情况下也放弃了访问他们的页面赞。大约 270，000 人参加了此次调查，这使得科岗能够访问大约 3，000 万人的数据。这种挖掘数据的方法不是数据泄露，因为用户同意将他们的数据交给 GSR，参加调查的用户的朋友可能已经更改了他们的隐私设置，以确保 GSR 不会提取他们的数据。然而，也许脸书可以更好地向用户传达这种隐私设置的存在。目前，脸书在其服务条款中提到了这一点，这可能是大多数人没有仔细阅读。或许脸书可以在这方面再下功夫，让用户做一个小测验，确保他们在创建账户之前完全理解服务条款的内容。剑桥分析公司然后使用每个用户的脸书数据来预测他或她的个性。他们旨在通过对个人用户的五个关键人格特征进行评分来量化人格:开放性，责任心，外向性，宜人性，神经质，这是指大 5 或海洋人格模型。每个人在每个属性上的得分是通过检查每个用户的脸书页面喜好并根据页面喜好创建个性预测模型来确定的。

剑桥分析网站上提到的最后一个策略是创新广告技术。它指的是该公司旨在接触用户的更个性化的方式，包括脸书广告。Nix 将这种技术描述为向数百万用户显示相同信息的一揽子广告的对立面。他解释了“今天的交流变得越来越有针对性。这个房间里的每一个人都是个性化的。因此，创新广告技术(Nix 称之为 Concordia summit 上的演示，addressable ad tech)依赖于使用行为科学和数据分析后获得的结果，并通过高度个性化的渠道向观众展示，其中之一是脸书广告。

瑞典乌普萨拉大学的应用数学教授大卫·森普特在他的书《寡不敌众》中分析了剑桥分析公司模型的准确性。该公司使用回归模型来预测个性，他将回归模型描述为“利用我们已经掌握的关于一个人的数据，并使用这些数据来预测我们不知道的关于他或她的一些事情的模型。”(Sumpter，第。45).基于用户的个性，不同的广告出现在同一个问题上，希望说服不同的用户相同的信息。下面是亚历山大·尼克斯在协和女神峰会上的演讲中的一个例子。

这两个广告的动机都是为了说服观众支持第二修正案，该修正案允许人们拥有和携带武器的权利。高度新批判主义和责任感的人，倾向于担心很多，更喜欢秩序，所以左边的信息会引起更多的共鸣。封闭和随和的人把别人的需要放在自己的前面，但不喜欢新的体验，所以右边的信息会引起更大的共鸣。Christopher Wylie 认为这越界了，不再是说服，而是操纵。他声称，该公司在“道德灰色地带”运营，“试图通过抓住选民的弱点来操纵他们。”然而，“使用不正当的方法来颠覆公众的选举偏好并不是什么新鲜事，”在美国，这已经成为“选举的重复伴侣”，所以人们不应该对使用所谓的操纵策略感到惊讶。

基于个性的微目标用户的想法似乎比传统的营销方法更微妙，在传统的营销方法中，相同的信息显示给每个人。Sumpter 在他的书《寡不敌众》中分析了剑桥分析公司回归模型的准确性。他使用了由心理学家 Michal Kosinski 和他的同事创建的公开可用的数据集，他们创建了一个包含 2 万名脸书用户的匿名数据库。在 2 万名脸书用户中，19742 名是美国用户，其中 4744 名注册了他们喜欢的政党民主党或共和党，还喜欢了 50 多个脸书页面。Sumpter 首先旨在测试回归模型的准确性，因此创建了一个基于脸书·佩奇喜好预测政党忠诚度的模型。他的结论是，回归模型“对铁杆民主党人和共和党人非常有效”，但“没有揭示出 76%的用户没有把他们的政治忠诚放在脸书身上”。52–53).他还描述了为什么仅仅因为这个模型揭示了，例如，民主党人倾向于喜欢哈利波特，并不一定意味着其他哈利波特迷喜欢民主党人。因此，民主党采用的旨在让哈利波特迷投票的策略，不一定对他们有利。Sumpter 遇到的另一个限制是，“回归模型只有在一个人获得了 50 个以上的‘喜欢’时才有效，要做出可靠的预测，需要几百个‘喜欢’”(sum pter pg。53).他发现，在那个数据集中，只有 18%的用户“喜欢”50 个以上的网站。然而，这个问题似乎仅限于 Sumpter 使用的数据集，因为 2013 年的一项研究显示，美国人均脸书页面赞数为 70，而且这个数字一直在稳步上升。

可以说，剑桥分析公司专门用来预测性格的回归模型的最大局限性是，他发现脸书喜欢的性格预测模型的准确性。Sumpter 使用的数据集包含每个人在海洋人格模型上的得分信息。首先，Sumpter 创建了一个回归模型，根据脸书·佩奇的喜好来确定性格。然后他从数据集中随机选择两个人，根据模型对每个人的神经质水平做出的预测，根据神经质程度对他们进行排名。Sumpter 然后根据数据集中给出的两个个体的实际数据，将此与基于神经质的排名进行比较。他发现模型产生的排名与正确排名的匹配率只有 60%。然后，他在其他四种性格特征上尝试了这种方法，得到了大约 60%非常相似的结果。预测最准确的特征是开放性，但即使如此，预测的准确率也只有 67%。

亚历山大·科岗和亚历山大·尼克斯证实了从人们喜欢的脸书·佩奇来预测他们性格的困难。亚历山大·科岗在英国议会“数字、文化、媒体和体育委员会”的证词中表示，声称回归模型导致准确的结果是“科学上荒谬的”。在他提交给议会的书面证据中，他表示，该算法预测的每个人格特质的分数比随机猜测每个特质的分数更准确。然而，这比仅仅猜测每个人在每个属性上都正好处于中间更不准确，例如，同样内向和外向，同样封闭和开放，等等。此外，该模型只对 1%的人正确预测了所有五种性格特征，但对 6%的人预测错误。

科岗声称，他不知道从他的应用程序中收集的数据会被用来创建这样的回归模型。他认为，有一种更有效的方法来获取数据，在脸书做有针对性的广告。剑桥分析公司利用亚历山大·科岗生成的数据，根据海洋模型来预测人们的性格。因此，剑桥分析公司只能在科岗收集信息的 3000 万人中投放广告。他认为，更好的方法是利用脸书广告平台。脸书广告平台使开发者能够建立类似于人工选择的受众的受众。科岗描述了如何更容易地获得某些人的细节，这些细节准确地代表了特定的人格特征，然后使用脸书的工具来创建一个相似的观众，以达到与原始群体具有相同人格特征的一群人。

首席执行官亚历山大尼克斯自己证实了这些结果。他在给英国议会“数字、文化、媒体和体育委员会”成员的证词中声称。他认为科岗的数据集不是很有用，这只是他们 2016 年美国总统大选整体战略的一小部分。他在 Concordia 峰会上的演讲中，尼克斯公开吹嘘自己有能力运用脸书数据来调整一个对选举产生重大影响的极其强大的工具，我们该如何回应他的这一承认呢？答案来自尼克斯自己的证词，他声称自己过去在向潜在客户推销自己的公司时使用了夸张手法。这一观点得到了科岗的证实，他提到“尼克斯正试图推广(人格算法)，因为他有强大的经济动机来讲述剑桥分析公司如何拥有秘密武器的故事”。54).

尼克斯不是唯一一个夸大该公司对 2016 年大选影响的人。考虑到主流媒体的头条新闻，大多数人可能会相信那些预测脸书·佩奇性格的回归模型，推而广之，剑桥分析公司的模型非常准确。因此，我们如何引起标题的共鸣，如《连线》杂志的“脸书如何比你的朋友更了解你”，《美国消费者新闻与商业频道》和《每日电讯报》的“脸书比你的家庭成员更了解你”，以及《纽约时报》的“脸书比任何人都了解你”？所有这些文章都引用了同一个研究，由吴友友、米哈尔·科辛斯基和大卫·斯蒂尔韦尔进行，题为“基于计算机的人格判断比人做出的判断更准确”克里斯托弗·威利(Christopher Wylie)在向英国议会“数字、文化、媒体和体育委员会”作证之前提交的书面证据中也引用了同样的研究，并表示这是该公司方法成功的证据。这项研究首先让参与者参加一个有 100 个问题的测试，以确定他们在海洋人格模型上的分数。然后，该研究将使用每个人的脸书页面喜好创建的回归模型的预测能力与个人的朋友、亲戚、同事和配偶的预测能力进行了比较。他们通过让这些人回答一份有十个问题的问卷来衡量其他人的预测能力。他们发现回归模型与 100 项测试的相关性比其他人在 10 项问卷中的答案更好。然而，研究人员自己也承认，“我们的研究是有限的，因为人类法官只能使用一份关于五大特征的 10 项长的问卷来描述参与者。实际上，他们掌握的知识可能比问卷中评估的要多。”(悠悠)

因此，这些文章得出的结论，如美国消费者新闻与商业频道一篇文章的第一行“大学研究人员发现，通过使用你的脸书“喜好”来判断你的性格，计算机可以比你最亲密的朋友家人更好地确定你的性格”，与现实相比，是远远夸大的。布莱恩·康纳利(Brian Connelly)研究工作场所的个性，他也是多伦多大学管理系的副教授，斯卡伯勒声称，尽管引用的研究论文“有趣且具有挑衅性”，但“媒体正在耸人听闻地报道这些发现”(Sumpter。Pg。55).他说，反映这项研究结论的准确新闻标题应该是“初步调查结果表明，脸书和你的一个密友一样了解你(但我们坚持要看看脸书是否能预测你的行为)”。55).

然而，在克里斯托弗·威利(Christopher Wylie)的推动下，媒体声称剑桥分析公司的微观目标对帮助特朗普当选产生了巨大影响。在克里斯托弗·威利(Christopher Wylie)提交给英国议会“数字、文化、媒体和体育委员会”(Digital，Culture，Media and Sport committee)的书面证据中，他引用了一系列研究作为证据，“强调了使用社交媒体、自然语言或互联网点击流数据进行心理分析或大众说服的功效。”然而，在这些研究中，只有少数几个涉及到预测脸书喜欢的人的性格。在这些人当中，没有一个人得出结论说这样的模型会“打破脸书”，或者它们如此强大，以至于应该被称为“心理战工具”，正如 Wylie(《卫报》)所描述的那样。此外，Wylie 还声称，他成为告密者的原因之一是因为公司的脸书战略帮助 Trump 赢得了选举。他声称“唐纳德·特朗普让你意识到这有更广泛的影响”(《卫报》)，但没有提到脸书的数据在大选前被该公司删除了。

媒体夸张的一个突出例子是 2018 年 3 月 21 日特雷弗·诺亚在“每日秀”上的一个片段。诺亚认为剑桥分析公司的模型非常准确，并播放了一系列片段来支持这种说法。第一个片段来自 CNN 的一个故事，主持人说“根据你在脸书的喜好，可以预测你的水平高于你妻子对你的评价，也高于你父母或朋友对你的评价。”第二封信来自 Christopher Wylie，他表示，该公司“将试图找出我们认为你存在的任何精神弱点或脆弱性，并试图扭曲你对周围现实的感知。”诺亚随后暗示，特朗普竞选团队使用了这些数据，并表示剑桥分析公司(Cambridge Analytica)的运营水平高于传统广告，并播放了一段视频，视频中称“唐纳德·特朗普(Donald Trump)总统竞选团队雇佣的数据公司利用从数千万不知情的脸书用户那里秘密获取的信息，直接瞄准潜在的美国选民”，“整个行动围绕着欺骗、虚假的基层支持和一种似乎接近电子洗脑的战略”。诺亚没有展示这些片段的完整背景，只是展示了一些小片段，此外，剑桥分析公司删除了，或者至少声称删除了所有脸书的数据，并且根本没有使用这些数据来帮助川普，这一点根本没有提到。所有剪辑中的说法都是夸张的，并且没有提供这些说法背后的科学依据。

鉴于有证据表明该公司的回归模型不像声称的那样准确，有必要研究一下这种夸张背后的一些潜在原因。简单和耸人听闻的故事和标题可能会获得更好的收视率，因为这类文章过于简单，点击诱饵的性质。此外，关于唐纳德·特朗普从剑桥分析公司的脸书广告中获益的说法也是不准确的，因为该公司很可能在特朗普和希拉里之间的大选开始之前就删除了脸书的数据。然而，与更平衡的故事相比，批评特朗普的两极分化的故事可能会获得更高的收视率。此外，Wylie 离开公司时并不友好。他创建了一家名为 Eunoia Technologies 的竞争公司，该公司主要从事微定位和心理建模，就像剑桥分析公司一样。他也收到了《全球科学研究》的数据，随后被要求删除。然后，他“未能成功地向一个亲英国退出欧盟的派别推销他的服务，但确实从一个加拿大立法实体获得了一份 10 万美元的合同”(Freeze)，并“向共和党政治活动家科里·莱万多夫斯基(Corey Lewandowski)推销了可以代表唐纳德·特朗普(Donald Trump)2016 年总统竞选活动部署的微瞄准工具”(Mac)。因此，他有动机质疑剑桥分析公司的道德，并为公司创造负面宣传，这可能解释了他在描述公司努力的影响时的夸张。

剑桥分析公司(Cambridge Analytica)经营的脸书广告对 2016 年美国总统大选的影响被首席执行官 Alexander Nix、媒体和 Christopher Wylie 夸大了。回归模型还不太准确，脸书的微目标广告策略可能没有用于川普的竞选。虽然剑桥分析公司(Cambridge Analytica)在脸书投放的广告可能对 2016 年美国大选没有太大影响，但这只是社交媒体微定向广告领域的开始。脸书每月有 23 亿活跃用户，每天有 15 亿活跃用户，脸书是一个独一无二的工具。事实上，你的朋友可以通过一个小测验提取你在脸书的数据，这可能会让很多人感到惊讶。因此，随着世界各地脸书用户数量的持续增长，脸书负有向用户明确传达隐私选项的重要责任。这仅仅是使用微定位脸书广告的开始，如果你在选举前看到脸书的政治广告引起你强烈的共鸣，不要感到惊讶。

作品被引用

伯格尔哈尔。"恶意国内:剑桥分析反乌托邦."计算机，2018 年第 51 卷第 5 期，第 84–89 页。，doi:10.1109/mc.2018.2381135。

戴维斯，哈利。"特德·克鲁兹利用公司收集了数百万不知情的脸书用户的数据."《卫报》，《卫报新闻与媒体》，2015 年 12 月 11 日，www . The Guardian . com/us-News/2015/dec/11/senator-ted-Cruz-president-campaign-Facebook-user-data

别动，科林。"克里斯托弗·威利(Christopher Wylie)策划的商业计划揭示了举报人对大数据的野心和焦虑."《环球邮报》《环球邮报》2018 年 5 月 5 日www . The Globe and Mail . com/politics/article-business-plan-hatched-by-Christopher-wylie-sheds-light-on-whistle/。

肯尼迪，梅里特。"“他们不在乎”:举报者称剑桥分析公司旨在破坏民主." NPR ，NPR，2018 年 3 月 27 日，www . NPR . org/sections/the two-way/2018/03/27/597279596/they-don-t-care-believer-says-Cambridge-analytic a-seeks-underb-democr。

拉夫迪贾斯汀。"普通脸书用户喜欢多少页面？" — Adweek ，Adweek，2013 年 4 月 11 日，www . Adweek . com/digital/how-number-pages-do-the-average-Facebook-user-like/。

麦克莱恩。"剑桥分析公司的告密者希望他的新公司与特朗普竞选团队的经理合作." BuzzFeed News ，BuzzFeed News，2018 年 3 月 28 日，www . BuzzFeed News . com/article/Ryan MAC/Cambridge-analytic a-Chris-wylie-eunoia-trump-campaign。

麦克考斯兰、菲尔和安娜·谢克特。"与川普有关的顾问从脸书数百万人那里收集数据."NBCNews.com，NBC 环球新闻集团，2018 年 3 月 17 日，www . NBC News . com/News/us-News/Cambridge-analytic a-harved-data-millions-unscened-Facebook-users-n 857591。

新闻，4 频道。"前剑桥分析公司首席执行官亚历山大尼克斯面临国会议员(完整版)." YouTube ，YouTube，2018 年 6 月 6 日，www.youtube.com/watch?v=weQ9E6e3aJot = 5747s。

新闻卫报。"剑桥分析报告密者克里斯托弗·威利出现在国会议员面前——观看直播."YouTube ，YouTube，2018 年 3 月 27 日，www.youtube.com/watch?v=X5g6IJm7YJQ&t = 4872s。

尼克斯，亚历山大。 YouTube ，协和女神，2016 年 9 月 27 日，www.youtube.com/watch?v=n8Dd5aVXLCc。

史密斯，戴夫。"微型杀伤性武器:我们的“喜欢”如何劫持民主."走向数据科学，走向数据科学 2018 年 10 月 17 日，走向 sdata Science . com/weapons-of-micro-destruction-how-our-like-劫持-民主-c9ab6fcd3d02 。

寡不敌众:从脸书和谷歌到假新闻和过滤泡沫——控制我们生活的算法。布鲁姆斯伯里适马，2018。第五章

特雷弗·诺亚每日秀。"电子洗脑:剑桥分析公司阴险的脸书战略|每日秀." YouTube ，YouTube，2018 年 3 月 21 日，www.youtube.com/watch?v=t7epj5tK54M。

基于计算机的性格判断比人类做出的更准确。2015 年 1 月 27 日，美国国家科学院，www.pnas.org/content/112/4/1036?， PNAS sid = fef de0 d 1-d260-40e 6-84d 3-a 1992208031 a。

英国，RT。“现场:剑桥分析研究员亚历山大科岗向国会议员作证。” YouTube ，YouTube，2018 年 4 月 24 日，www.youtube.com/watch?v=hpzc26bzp1M&t = 5106s。

基于马尔可夫聚类的有效社区发现

原文：https://towardsdatascience.com/effective-community-detection-with-markov-clustering-d5c6abee11b2?source=collection_archive---------24-----------------------

这个帖子最早出现在amethix.com

“如果智能是一块蛋糕，蛋糕的大部分是无监督学习，蛋糕上的糖衣是监督学习，蛋糕上的樱桃是强化学习”。

这句来自脸书人工智能首席执行官 Yann LeCun 的名言强调了人类是如何依赖无监督学习的。利用马尔可夫聚类进行有效的社区发现。他们用这种方法来理解他们周围的世界。事实上，孩子们在没有太多监督的情况下就学会了辨认物体和说话。相比之下，复杂的深度学习算法需要数百万仔细注释的数据。这对于在物体检测和语言生成等任务中达到类似人类的性能是必要的。

这篇文章为你提供了一个利用马尔可夫聚类进行有效社区发现的好方法。

在这个领域中，一个人可以将聚类视为以无监督方式从数据中学习有趣模式的最有用的工具之一。

聚类方法

无论是对电子邮件进行分类还是进行客户细分，聚类在大多数时候都是可行的方法。这种方法包括将数据集分成组(或聚类)，使得属于同一聚类的对象比属于不同聚类的项目更相似。可以根据特定的度量来计算这种相似性，该度量当然可以随着要解决的问题而改变。

数据科学家在表格数据的探索性数据分析中使用聚类算法，如 k-means、层次聚类或 DBSCAN。还有另一种类型的数据也很常见:网络。在网络分析行话中，研究人员将聚类网络数据称为社区检测。在这种情况下，集群代表社区。分别参考【1】和【2】获得关于聚类网络的社区检测和最新算法的更多细节。

这篇文章的目的是揭示一种被称为马尔可夫聚类(MCL)的特定算法的一些最重要的特性。研究人员设计这种算法主要是为了执行社区检测。但是，也可以使用 MCL 对表格数据进行聚类。在参考文献[3]中提供了 MCL 算法的更多技术解释，并且在[4]中详细描述了该方法在聚类生物序列中的应用。现在让我们刷新一些图论的概念，这将有助于理解 MCL 技术的工作机制。

图和随机漫步

在之前的帖子中提到过，自然界中的许多系统都可以用图来表示。图只不过是由边连接起来的一组节点。社交网络可能是最熟悉的图表例子。节点代表用户，而连接任意两个节点的边代表两个用户相互交互的事实。

分析图表并从模拟中获得洞察力的一种常见方法是所谓的随机漫步。这里有一个例子来阐明随机漫步的含义。假设有一个游客，他从家乡出发，准备去几个城市旅游。人们可以把城市看作是图中的节点。只要有可能从一个城市直接到达另一个城市，这样的节点就通过边连接。让我们假设前面提到的游客被惊喜惊呆了。她没有提前计划她的旅行，她随机选择了下一个城市。

数学表示

从数学的角度来看，游客的旅行是一个被称为随机行走的随机过程。一个自然的问题可能会出现:从长远来看，我们的游客下一步会去哪些城市？这个问题的答案取决于这些城市之间的联系。例如，如果城市形成分离良好的集群(连接组件)，并且游客在这些集群中的一个内开始她的旅行，她可能永远无法到达其他集群中的任何城市。
模拟图上的随机行走准确地代表了 MCL 算法背后的思想。

MCL 算法

MCL 算法的目的是找到一个聚类结构。这是通过模拟图上的随机游走直到达到平衡来实现的。
我们需要采取的第一步是获得上述图表。

在网络数据的情况下，要执行的唯一任务是计算邻接矩阵 a。这样的矩阵完美地描述了网络。这种矩阵的定义是:如果从顶点 i 到顶点 j 有一条边，Aij= 1，否则为 0
在表格数据的情况下，必须构建一个相似矩阵。这是通过计算所有现有记录(即表的行)之间的成对相似性来实现的。这种相似性矩阵表示一个加权图。这种图的节点表示观察值，边具有对应于它们之间的相似性得分的权重。

扩张和通货膨胀

通过适当缩放邻接矩阵或相似矩阵，可以获得马尔可夫矩阵。这是一个概率矩阵，表示一个节点到达它所连接的另一个节点的机会。
最后，一旦建立了马尔可夫矩阵，就可以通过交替使用两个叫做展开和膨胀的操作符来模拟图上的随机游走。

扩展允许随机漫步机走更长的路径。例如从一个节点到另一个节点需要大量的步骤。
膨胀通过支持可能性较大的遍历而不是可能性较小的遍历来改变转移概率。

扩张和膨胀的结合将提高每个集群内部的行走概率。此外，它将减少集群之间的行走。这是因为同一个集群内的路径比不同集群之间的路径更长。

这样的行为长期会出现。扩展和膨胀操作的迭代导致图形分离成不同的连接部分。因此，与许多需要用户预先指定预期聚类数的聚类算法(有时会出错)不同，MCL 算法提供了一种将数据划分为聚类的方法，这种方法是从图拓扑本身自然产生的。

Python 中的一个实际例子

让我们看看如何在 Python 中使用 MCL 算法，以及如何通过马尔可夫聚类来执行有效的社区检测。
首先用pip install markov_clustering[drawing]和networkx包安装实现算法所需的包，进行图形分析和可视化。

然后执行下面的代码

# Import libraries
import markov_clustering as mc
import networkx as nx

# Load network data
G = nx.karate_club_graph()

# Build adjacency matrix
A = nx.to_numpy_matrix(G)

# Run MCL algorithm
result = mc.run_mcl(A)
clusters = mc.get_clusters(result)

# Draw clusters
mc.draw_graph(A, clusters, node_size=50, with_labels=True, edge_color="silver")

在上面的代码中，我们使用 MCL 算法来检测 Zachary 的空手道俱乐部中的集群，也称为社区，这是一个测试社区检测算法的流行基准。扎卡里空手道俱乐部是一个大学空手道俱乐部的社交网络。该网络捕获了一个空手道俱乐部的 34 名成员，记录了在俱乐部外互动的成对成员之间的联系。

在研究过程中，管理者(节点 0)和指导者(节点 33)之间产生了冲突，导致俱乐部分裂为两个子图。一半的成员围绕着教官组建了新的社团，另一部分的成员则找到了新的教官或者放弃了空手道。

如下图所示，MCL 算法很好地检测到了网络中两个不同社区的存在，这两个社区的成员大多与管理员或教师有交互:

在这篇文章中，我们看到了如何通过组合简单的概念，如随机漫步、图形、相似矩阵，来构建一个称为马尔可夫聚类的社区检测算法。此外，我们强调了如何构建一个相似性图，然后在这样的图上运行一个有效的社区检测算法(如马尔可夫聚类或其他最先进的方法)来发现表格数据中的聚类。

跟随播客【https://datascienceathome.com/】
别忘了加入我们新的不和谐频道的对话。那里见！

参考

[1] S. Fortunato，“图形中的社区检测”，《物理报告》，第 486 卷，第 3-5 期，第 75-174 页，2010 年 2 月。

[2] Z. Yang 等，“人工网络上社区发现算法的比较分析”，《科学报告》第 6 卷，文章编号:30750 (2016)

[3] S. Dongen，“图的聚类算法”，技术报告，CWI(数学和计算机科学中心)，荷兰阿姆斯特丹，2000 年。

[4] A. J. Enright 等人，“大规模检测蛋白质家族的有效算法”，核酸研究，第 30 卷，第 7 期，第 1575-1584 页，2002 年。

原载于 2019 年 8 月 21 日https://amethix.com。**

其他人的有效数据可视化

原文：https://towardsdatascience.com/effective-data-visualization-for-other-humans-695e54a5dc71?source=collection_archive---------9-----------------------

Credit: Markus Spiske — Unsplash

TL；灾难恢复—执行不当的数据可视化可能会向您的受众传达误导和潜在有害的信息。我们有责任维护我们传达给受众的信息中数据的完整性。

我们都知道数据的驱动力。它为组织制定明智的决策和影响结果提供了见解。目标很简单。开发解决方案，以技术和非技术受众都能有效利用的方式组织和呈现数据。今天，我们将讨论数据可视化的一些基础知识，以便有效地交流从数据中获得的见解，从而有效地吸引观众。

像任何科学一样，在您的方法中定义一致的方法将有助于简化您的过程，以利用数据可视化来最大化其有效性。想象一下，一篇长长的研究论文打印在一个内容结构复杂的无格式文档上。读者不会从这种格式的论文中获得多少教育价值。

规范化可视化数据的方法

Credit: Olia Gozha — Unsplash

让我们从基础开始。

你想了解的任何东西都可以分解成可观察到的片段。这种科学形式在数据科学和统计学中很常见。简而言之，我们正在探索收集、发现和分析关于我们想要研究和观察的事物的大量信息的实践。

作为人类，传输到我们大脑的大部分信息都是视觉的。因为我们处理图像的速度比处理文本的速度快得多，所以利用数据可视化可以优化我们从数据中获得的价值。

[## 30 分钟内 39 项关于人类感知的研究

这些是我 2016 年 4 月在 OpenVis 上的演讲笔记。最初这个演讲应该叫做…

medium.com](https://medium.com/@kennelliott/39-studies-about-human-perception-in-30-minutes-4728f9e31a73)

为了从我们的数据中有效地呈现洞察力，挑战的一部分是决定哪种可视化技术将为最终用户提供最大的价值。系统地，我们可以对数据进行分类，并实例化一种标准化的方法。

我们将使用一个简单的例子，收集 1950 年美国 45 个职业的声望和特征的样本数据。这些数据可以从 Python3 的 datasets 包中的 Rdatasets 项目中公开获得。

import statsmodels.api as smdf = sm.datasets.get_rdataset('Duncan', package='carData').data
df

以下是返回的结果数据集:

 **[type]  [income]  [education]  [prestige]**
accountant          prof      62         86        82
pilot               prof      72         76        83
architect           prof      75         92        90
author              prof      55         90        76
chemist             prof      64         86        90
minister            prof      21         84        87
professor           prof      64         93        93
dentist             prof      80        100        90
reporter              wc      67         87        52
engineer            prof      72         86        88
undertaker          prof      42         74        57
lawyer              prof      76         98        89
physician           prof      76         97        97
welfare.worker      prof      41         84        59
teacher             prof      48         91        73
conductor             wc      76         34        38
contractor          prof      53         45        76
factory.owner       prof      60         56        81
store.manager       prof      42         44        45
banker              prof      78         82        92
bookkeeper            wc      29         72        39
mail.carrier          wc      48         55        34
insurance.agent       wc      55         71        41
store.clerk           wc      29         50        16
carpenter             bc      21         23        33
electrician           bc      47         39        53
RR.engineer           bc      81         28        67
machinist             bc      36         32        57
auto.repairman        bc      22         22        26
plumber               bc      44         25        29
gas.stn.attendant     bc      15         29        10
coal.miner            bc       7          7        15
streetcar.motorman    bc      42         26        19
taxi.driver           bc       9         19        10
truck.driver          bc      21         15        13
machine.operator      bc      21         20        24
barber                bc      16         26        20
bartender             bc      16         28         7
shoe.shiner           bc       9         17         3
cook                  bc      14         22        16
soda.clerk            bc      12         30         6
watchman              bc      17         25        11
janitor               bc       7         20         8
policeman             bc      34         47        41
waiter                bc       8         32        10

回顾此处可用的数据类型，我们有一组 45 个职业观察值(行)，包含以下特征:

职业:所担任角色的标识。
类型:具有以下级别的因子:教授、专业和管理；wc，白领；bc，蓝领。
收入:1950 年美国人口普查中年收入 3500 美元或以上(2017 年美元约合 36000 美元)的职业在职者的百分比。
教育:1950 年高中毕业生占在职人员的百分比(如果我们愤世嫉俗的话，我们会说这在 2017 年大致相当于博士学位)
声望:在一项社会调查中，认为该职业声望“好”或更好的受访者的百分比

理解这一切。

如果您是一名开发人员，并被要求使用上述数据的图形或图表来提供见解，这个简单的请求可能是一项令人生畏的任务。您希望在数据集中向最终用户传达什么？这张表格对声望和职业之间的关系提供了什么样的见解？

我们可以缩小我们的关注点，通过将我们的集合解构为更小的片段，使用数据可视化来帮助我们理解数据的复杂性。

选择正确的视觉很重要

Credit: Harry Quan — Unsplash

不管图表内容的准确性如何，选择错误的图表可能会向您的受众传达误导和潜在有害的信息。我们有责任维护我们发送的信息的完整性。此外，使用错误的视觉效果会错误地分类原本准确的信息。我们可以通过在正确的数据可视化下对数据进行分类来最小化这些错误。

用于比较数值的条形图

比较不同类别数量的一个实用方法是使用条形图。在我们的数据集中，我们可以在职业集合中比较职业类型的数量。

The x-axis represents the different categories, and the y-axis indicates the unit of measurement.

条形图易于解释，并允许最终用户快速比较不同离散类别数据的数量或频率。离散数据指的是我们计数的东西，而不是测量的东西。比如我们有六个 wc 职业类型。我们没有 6.3333 wc 职业类型。

下面是 Python3 中用于生成条形图的代码。

from matplotlib import pyplot as plttypeCounts = df['type'].value_counts()
typeCounts.plot(kind='bar', title='Type Counts')plt.xlabel('Type')
plt.ylabel('Number of Occupation Type')
plt.show()

用于可视化连续数据分布的直方图

连续数据是指沿标尺的测量值。与离散数据相反，C 连续数据，或者说定量数据，是由测量的T21【而不是我们统计的数值来表示的。对于我们的数据集，记录了收入、教育和声望的百分比值，以量化数据样本中某个类别的度量。**

使用直方图，我们可以有效地向我们的观众展示哪个百分比组的高中毕业率最高。使用直方图，我们可以有效地显示我们的连续数据集的分布或形状。

Our distribution of high school graduates shows more occupations were more common in the lower percentage groups of students who graduated from high school.

下面是 Python3 中用于生成直方图的代码。

from matplotlib import pyplot as pltdf['education'].plot.hist(title='High School Graduates', bins=19)
plt.xlabel('Percentage')
plt.ylabel('Frequency')
plt.show()

用于比较相对数量的饼图

当您试图比较整体的各个部分时，饼图会很有用。与条形图相比，饼图可用于定义特定类别的完整上下文的可视化表示。我们可以通过将这些值分类来比较相对数量。有效使用时，饼图可以有效地显示整个数据集的比例。

从条形图中比较职业类型之间的频率，我们可以使用饼图生成更有效的比例可视化。

In comparison to the bar chart, proportions are easier to identify in a pie chart

用于比较定量值的散点图

我们可以把定量数据归类为你可以归类的东西。换句话说，这是包含独特性质的信息，您可以识别数据集并将其分类为可见的部分。

当您想要可视化和探索数字特征之间的关系时，散点图是引人注目的。此外，散点图有助于识别属于异常值的数据点，即明显超出观察数据集范围的值。让我们通过可视化声望与收入水平的对比来看看职业数据。

Notice the top left and bottom right are mostly empty. Higher income generated higher prestige evaluated, and low-income occupations made less prestige.

通过这种方法，您可以使用散点图有效地演示两个变量是如何相关的。你可以充分地想象一种关系的程度，并向观众突出一个变量如何影响另一个变量。

下面是生成散点图的相应代码:

from matplotlib import pyplot as pltoccupations = df[['prestige', 'income']]
occupations.plot(kind='scatter', 
                     title='Occupations', x='prestige', y='income')plt.xlabel('Prestige')
plt.ylabel('Avg Income %')
plt.show()

数值变化的折线图

我们经常想在一段时间内评估我们的数据集。折线图是一种非常有用的可视化技术，可以显示数值如何随着一个系列而变化。

对于这个例子，我们将从数据集包的 Longley 数据集中分析 1947-1962 年间的美国宏观经济变量。

import statsmodels.api as smdf = sm.datasets.longley.load_pandas().data
df **[TOTEMP]  [GNPDEFL] [GNP]   [UNEMP]  [ARMED]  [POP]    [YEAR]**
0   60323.0     83.0  234289.0  2356.0  1590.0  107608.0  1947.0
1   61122.0     88.5  259426.0  2325.0  1456.0  108632.0  1948.0
2   60171.0     88.2  258054.0  3682.0  1616.0  109773.0  1949.0
3   61187.0     89.5  284599.0  3351.0  1650.0  110929.0  1950.0
4   63221.0     96.2  328975.0  2099.0  3099.0  112075.0  1951.0
5   63639.0     98.1  346999.0  1932.0  3594.0  113270.0  1952.0
6   64989.0     99.0  365385.0  1870.0  3547.0  115094.0  1953.0
7   63761.0    100.0  363112.0  3578.0  3350.0  116219.0  1954.0
8   66019.0    101.2  397469.0  2904.0  3048.0  117388.0  1955.0
9   67857.0    104.6  419180.0  2822.0  2857.0  118734.0  1956.0
10  68169.0    108.4  442769.0  2936.0  2798.0  120445.0  1957.0
11  66513.0    110.8  444546.0  4681.0  2637.0  121950.0  1958.0
12  68655.0    112.6  482704.0  3813.0  2552.0  123366.0  1959.0
13  69564.0    114.2  502601.0  3931.0  2514.0  125368.0  1960.0
14  69331.0    115.7  518173.0  4806.0  2572.0  127852.0  1961.0
15  70551.0    116.9  554894.0  4007.0  2827.0  130081.0  1962.0

回顾此处可用的数据类型，我们有一组 16 个观察值，包含以下六个特征:

总就业人数:总就业人数
GNPDEFL : GNP 缩减指数
GNP : GNP (国民生产总值)
失业人数
武装:武装力量的规模
POP :人口
年:年(1947-1962)

让我们为样本数据创建人口变化的可视化。通过这种方法，您可以快速向受众传达数据中的趋势或模式。

From this chart, we can see the population sizes increase from year to year and shows an increasing trend.

下面是生成折线图的相应代码:

df.plot(title='Population', x='YEAR', y='POP')plt.xlabel('Year')
plt.ylabel('Population')
plt.show()

用于可视化分布的箱线图

也称为盒须图，您可以将这种方法用于只有一个变量的数据集。这个数据称为单变量数据。

让我们以纯文本和箱线图的形式来看看 Longley 数据集中的失业数据集。

Transforming patternless text into a perceptible visual form.

**[Unemployment]**
0         2356.0
1         2325.0
2         3682.0
3         3351.0
4         2099.0
5         1932.0
6         1870.0
7         3578.0
8         2904.0
9         2822.0
10        2936.0
11        4681.0
12        3813.0
13        3931.0
14        4806.0
15        4007.0

箱线图跨四分位数分布数据，并显示第 25 和第 75 百分位之间的数据。在图的方框内，我们可以看到第 50 个百分位数值内的数据范围，以及绿线中显示的中值和。

以下是箱线图的相应代码:

import pandas as pd
import statsmodels.api as sm
from matplotlib import pyplot as pltdff = sm.datasets.longley.load_pandas().data
df = pd.DataFrame({'Unemployment': dff['UNEMP']})
print(df) # tableplt.figure()
df['Unemployment'].plot(kind='box',title='Unemployment')

比较和缩放您的视觉效果

为了从数据中获得最大价值，您需要通过比较数据之间的关系来最大限度地发挥信息的价值。让我们利用到目前为止我们探索的一些技术来优化我们的数据可视化的有效性。

比较变量分布

如果我们用箱线图来比较两个或更多变量的分布会怎么样？拥有多个变量被称为双变量 (2)变量或多变量 (2+)变量。

让我们比较一下样本中失业、总就业和 GNP 数据的分布。

 **[Unempl..]  [Total Emp]   [GNP]**
0         2356.0      60323.0    234289.0
1         2325.0      61122.0    259426.0
2         3682.0      60171.0    258054.0
3         3351.0      61187.0    284599.0
4         2099.0      63221.0    328975.0
5         1932.0      63639.0    346999.0
6         1870.0      64989.0    365385.0
7         3578.0      63761.0    363112.0
8         2904.0      66019.0    397469.0
9         2822.0      67857.0    419180.0
10        2936.0      68169.0    442769.0
11        4681.0      66513.0    444546.0
12        3813.0      68655.0    482704.0
13        3931.0      69564.0    502601.0
14        4806.0      69331.0    518173.0
15        4007.0      70551.0    554894.0

让我们从一个常见的问题开始。以下是相应的箱线图。注意到我们的方框图中有什么可能误导人的地方了吗？

No good! This data is not scaled correctly, giving misleading results.

这个情节告诉你什么？我也不确定。这张图不好，因为我们的数据不成比例。

让我们看看下图中的缩放版本。

Scaled proportionally

当比较数据时，观察中的变量必须具有相同的度量和尺度。确保按比例缩放数据。这个数据不是特别有用，但它是为了在相同的尺度上演示数据。

以下是多元盒图的相应代码:

import pandas as pd
from matplotlib import pyplot as plt
import pandas as pd
dff = sm.datasets.longley.load_pandas().datadf = pd.DataFrame({'Unemployment': dff['UNEMP'],
                  'Total Emp': dff['TOTEMP'],
                  'GNP': dff['GNP']})scaler = MinMaxScaler()
df[['Unemployment', 'Total Emp', 'GNP']] = scaler.fit_transform(df[['Unemployment', 'Total Emp', 'GNP']])df.plot(kind='box', title='Distribution', figsize = (10,8))
plt.show()

有效地突出一种趋势

有时对于数据集，您会希望通过数据可视化来强调特定的趋势。之前，我们讨论了如何散点图你的数据。对于许多数据点，使用趋势线是一种有效的技术，可以使数据中的趋势变得清晰。

在这里，我们将构建一个散点图，以及我们时间段内总就业人数的趋势线。

趋势线

在这里，我们让最终用户清楚地看到，总就业人数和我们的时间段之间存在一个共线性。共线性关系是一种变量，它的值随着另一个变量的增加而减少。

以下是相应散点图和趋势线的代码:

dff = sm.datasets.longley.load_pandas().datadf = pd.DataFrame({'Year': dff['YEAR'],
                  'Total Emp': dff['TOTEMP']})df.plot(kind='scatter', title='Total Emp vs. Year', x='Year', y='Total Emp')plt.plot(np.unique(df['Year']), 
         np.poly1d(np.polyfit(df['Year'], 
                              df['Total Emp'], 
                              1))(np.unique(df['Year'])),  
         color='orange')plt.show()

结论

Credit: Frank Mckenna — Unsplash

我们不断创新解决方案，以简化我们数据中的复杂性，并揭示以其他方式无法观察到的模式。为了有效地管理数据，我们探索了将数据解构为人脑可以有效消化的可管理片段的方法。

对于软件开发人员、分析师、产品经理和研究人员来说，我们如何将我们的发现传达给受众，这最终会推动我们为更大的整体所做工作的价值。

谢谢你。

如果你希望更深入地研究数学和数据可视化，我推荐你参加微软的 EdX DAT256:机器学习的基本数学。

参考

[## Longley 数据集—stats models v 0 . 10 . 0 RC2+14 . gceea 76 ce 6 文档

朗利数据集包含各种美国宏观经济变量，这些变量被认为是高度共线的。它已经被使用…

www.statsmodels.org](http://www.statsmodels.org/dev/datasets/generated/longley.html) [## CLPS 1091 S01:研究方法和设计

我们都健忘。我相信我们都有过这样的时刻，当我们走进一个房间，却忘了我们为什么去那里…

blogs.brown.edu](https://blogs.brown.edu/clps-1091-s01-spring-2017/2017/05/02/humans-visual-creatures/) [## 数据集包—stats models v 0 . 10 . 0 RC2+8 . g 551671 aa 1 文档

Rdatasets 项目提供了对 R 的核心数据集包中可用的数据集和许多其他常见 R…

www.statsmodels.org](https://www.statsmodels.org/dev/datasets/index.html) [## 课程| DAT256x —模块 04 | edX

机器学习的基本数学](https://courses.edx.org/courses/course-v1:Microsoft+DAT256x+1T2018/course/) [## 伟大的数据可视化看起来像什么:12 个复杂的概念变得简单

也许今天是艰难的一天。也许你醒晚了。你错过了你的锻炼，然后你的公共汽车，然后关闭电梯…

blog.hubspot.com](https://blog.hubspot.com/marketing/great-visualization-examples) [## 直方图—了解直方图的属性、它们显示的内容以及何时和如何使用…

直方图-了解直方图的属性，它们显示的内容，以及何时和如何使用它们

statistics.laerd.com](https://statistics.laerd.com/statistical-guides/understanding-histograms.php) [## 什么是散点图以及何时使用它

散点图是强大的数据可视化工具，可以传达大量信息。本教程将解释…

chartio.com](https://chartio.com/learn/dashboards-and-charts/what-is-a-scatter-plot/)

有效的微服务:10 个最佳实践

原文：https://towardsdatascience.com/effective-microservices-10-best-practices-c6e4ba0c6ee2?source=collection_archive---------0-----------------------

权威指南

正确实施微服务架构的 10 个技巧

Effective Microservices: 10 Best Practices

在之前的一篇文章中: 微服务架构:简要概述以及为什么你应该在你的下一个项目中使用它 ，我已经详细讨论了微服务架构以及在现代软件开发中使用它的优点/缺点。那么，微服务架构到底是什么？以下是我的定义:

微服务架构是关于将软件系统分解成可独立部署的 autonomus 模块，这些模块通过轻量级、语言不可知的方式进行通信，它们共同实现业务目标。

软件系统是复杂的。由于人脑只能处理一定限度的复杂性，大型软件系统的高复杂性导致了许多问题。大型复杂的软件系统很难开发、增强、维护、现代化和扩展。多年来，有许多尝试来解决软件系统的复杂性。70 年代期间，的模块化软件开发被的戴维·帕纳斯和埃德格·w·迪杰斯特拉引进来应对复杂情况 20 世纪 90 年代， 分层软件架构 被引入，以应对商业应用的复杂性。自本世纪初 、面向服务的架构 脱颖而出，开发复杂的业务应用。 微服务架构 是处理现代软件应用复杂性的最新方法论。一个问题可能会出现:为什么我们突然需要一种新的软件开发方法？简而言之，在过去的十年里，与软件开发相关的整个生态系统发生了显著的变化。如今，软件使用敏捷方法开发，使用 CI/CD 部署在 Container+Cloud 上，保存在 NoSQL 数据库上，在现代浏览器或智能手机上呈现，机器通过高速网络连接。由于这些因素，微服务架构在 2012 年诞生。****

微服务或整体:

主要有两组人对微服务和整体服务持相反的观点。对于一个团体来说，微服务架构完全是关于货物崇拜或炒作驱动的开发，这只是技术上瘾的开发人员的游乐场。对于另一群人来说，微服务架构是“统治一切的架构”，它可以消除任何软件系统的复杂性。在我看来，微服务和整体架构是相辅相成的。对于从长远来看是精益的应用程序，整体架构是正确的方法。另一方面，对于大型复杂或有可能变得大型复杂的应用，微服务架构是正确的解决方案。现代软件开发如此庞大，以至于微服务架构和整体架构将以 SQL 和 NoSQL 共存的方式共存。

最佳实践:

以正确的方式设计微服务架构是非常具有挑战性和困难的。与为所有人提供一个解决方案的整体架构相反，微服务架构为不同的问题提供不同的解决方案。如果选择了错误的解决方案，那么微服务架构只是一个定时炸弹，注定要爆炸。设计糟糕的微服务架构比一整块还糟糕。为微服务架构定义一套最佳实践也很有挑战性。我曾经在一些会议上看到一些著名的受人尊敬的软件工程师提出了微服务架构的最佳实践，但这是适得其反的。

在这里，我提出了一些最佳实践，这些实践将有助于开发有效的微服务应用程序，其中目标项目应该存在 6 个月以上，团队规模为中型到大型(6 个以上的开发人员)。完全公开，还有一些关于微服务架构最佳实践的其他帖子，例如 微服务架构的特征by马丁福勒或 微服务模式 by 克里斯理查森 或采用 微也有一些很棒的演讲，例如 微服务模式和反模式斯蒂芬·蒂尔科夫大卫·施米茨微服务原则***萨姆·纽曼微服务失败的 10 个技巧*** 此外，我还整理了一些书籍，这些书籍对于设计微服务至关重要，包括:****

*** [## 5 本最佳微服务书籍

以正确的方式设计微服务架构的必备书籍

towardsdatascience.com](/5-best-microservices-book-db981ef9c433)

1。领域驱动设计:开发微服务的最大挑战是将一个大型复杂的应用程序分割成小的、自治的、可独立部署的模块。如果微服务没有以正确的方式划分，那么将会有紧密耦合的微服务，它们将具有整体式服务的所有缺点和微服务的所有复杂性，也称为分布式整体式服务。幸运的是，在这方面已经有一个非常有用的解决方案。Eric Evans【当时的软件工程顾问，在不同公司的商业应用中遇到了反复出现的关于软件复杂性的问题，并在 2004 年出版的《 领域驱动设计:解决软件核心的复杂性 》一书中总结了他的宝贵见解。该书概述了三个核心概念:

软件开发团队应该与业务部门或领域专家紧密合作。
架构师/开发人员和领域专家应该首先进行战略设计:找到有界的上下文和相关的核心领域和无处不在的语言、子域、上下文图。
然后，架构师/开发人员应该进行战术设计，将核心域分解成细粒度的构建块:实体、值对象、聚合、聚合根

关于领域驱动设计的详细讨论超出了本文的范围，但是你应该阅读 DDD 的原著 领域驱动设计:解决软件核心的复杂性Eric Evans或者稍微现代一点的 DDD 的书 实现领域驱动设计 【红皮书】Vaughn Vernon 如果将一个大型系统划分为核心域和子域，然后将核心域和子域映射到一个或多个微服务，那么我们将得到理想的松耦合微服务。

****2。数据库每微服务:将复杂的应用拆分成微服务模块后，下一个挑战出现了，数据库怎么办？我们是否应该在微服务之间共享数据库。问题的答案是双刃剑。一方面，在微服务之间共享数据库会导致微服务之间的强耦合，这与微服务架构的目标正好相反。即使数据库中很小的变化也需要团队间的同步。此外，在一个服务中管理数据库的事务和锁定也非常具有挑战性。但是管理多个分布式微服务之间的事务/锁定是一项艰巨的任务。另一方面，如果每个微服务都有自己的数据库/私有表，那么在微服务之间交换数据就打开了挑战的潘多拉魔盒。因此，许多杰出的软件工程师提倡在微服务之间共享数据库，作为一种实用的解决方案。然而，在我看来，微服务是关于可持续和长期的软件开发。因此，每个微服务都应该有自己的数据库(或私有表)。

3。微前端:不幸的是，大部分后端开发人员对前端开发有一种落后的看法，认为前端开发很简单。由于大多数软件架构师是后端开发人员，他们很少考虑前端，并且前端通常在架构设计中被忽略。在微服务项目中，后端通常与数据库非常好地模块化，但只有一个整体前端。在最好的情况下，他们考虑一个最热门的温泉(反应，角，Vue)来开发整体前端。这种方法的主要问题是，前端单片和后端单片一样糟糕，正如我之前描述的。还有，当前端因为浏览器的变化而需要现代化的时候，那么它就需要一个大爆炸式的现代化(这就是为什么那么多公司还在使用过时的 Angular 1 框架的原因)。网络很简单，但是非常强大，并且提供了内在的超越性。有许多方法可以开发基于 SPA 的微前端:使用 iFrame、Web 组件或 via (Angular/React)元素。**

4。持续交付:微服务架构的一个关键 USP 就是每个微服务都可以独立部署。如果您有一个包含 100 个微服务的系统，并且只有一个微服务需要更改，那么您可以只更新一个微服务，而不涉及其他 99 个微服务。但是在没有自动化的情况下独立部署 100 个微服务(DevOps，CI/CD)是一项艰巨的任务。为了充分利用这种微服务特性，需要 CI/CD 和 DevOps。使用没有 CI/CD、DevOps、自动化的微服务架构，就像买了最新的保时捷，然后用手刹开。难怪 CI/CD 被微服务专家 马丁福勒 列为使用微服务架构的三大先决条件之一。

5。可观察性:微服务架构的主要缺点之一是软件开发变得简单，但却牺牲了运营。有了一个整体，监控应用程序就简单多了。但是有许多微服务在容器上运行，整个系统的可观察性变得非常关键和复杂。甚至日志记录也变得复杂起来，要将来自许多容器/机器的日志聚集到一个中心位置。幸运的是，市场上已经有很多企业级的解决方案。例如， ELK/Splunk 为微服务提供日志记录。 Prometheus/App Dynamics 提供行业级监控。微服务世界中另一个非常重要的观察工具是跟踪。通常，对一个微服务的一个 API 请求会导致对其他微服务的多个级联调用。为了分析微服务系统的延迟，需要测量每个微服务的延迟。 Zipkin/Jaeger 为微服务提供出色的跟踪支持。

6。统一技术栈:微服务架构告诉我们，对于一个微服务，要采取最适合那个微服务的编程语言和框架。不应该从字面上理解这种说法。有时，微服务可能需要新的技术堆栈，例如，对于 CPU 繁重/高性能任务，可能会选择 C++/Rust 等编程语言。如果一个微服务配合机器学习，也许 Python 是更好的选择。但是在没有任何坚实理由的情况下使用不同的编程语言/框架会导致太多的编程语言和框架而没有任何真正的好处。想想这样一个场景，一个微服务是用 Spring Boot + Kotlin+ React + MySQL 开发的，另一个是用 JakartaEE+Java+Angular+PostgreSQL 开发的，下一个是用 Scala+Play Framework+VueJS+Oracle 开发的，那么维护不同的编程语言、数据库、框架将需要大量的工作，而不会有太大的收益。

7。异步通信:微服务架构中最具挑战性的设计决策之一是服务之间如何通信和共享数据。当每个微服务都有自己的数据存储时，这就更加重要了。通常，一个微服务可以独立存在，但它不能单独实现所有的业务目标。所有的微服务一起工作来实现业务目标，并且一起工作，它们需要交换数据或触发其他微服务来完成任务。微服务之间最简单和最常见的通信方式是通过同步 REST API，这是一个实用但短期的解决方案。如果服务 A 调用服务 B，服务 B 调用服务 C，服务 C 同步调用服务 D，那么延迟就会增加。此外，由于微服务大多是分布式系统，它们可能会失败。同步微服务通常会导致故障级联，即一个服务中的故障会导致其他服务中的故障。微服务之间的同步通信也导致了微服务之间的紧密耦合。对于长期解决方案，微服务应该异步通信。微服务之间的异步通信有多种方式:通过消息队列(如 Kafka ),通过异步 REST (ATOM)或 CQRS。

8。微服务优先:许多专家认为，对于新项目，最好从松散耦合的整体架构开始，因为微服务架构需要大量的初始工作来设置操作。在他们看来，一旦项目变得足够成熟,“精心”设计的整体可以很容易地转化为微服务。然而，在我看来，这种方法在大多数情况下都会失败。实际上，Monolith 内部的模块是紧密耦合的，这使得它很难转变为微服务。此外，一旦应用程序投入生产，在不分解应用程序的情况下将其转变为微服务将会困难得多。因此，我的建议是，如果最终有计划使用微服务架构，就从微服务开始。

9。基于库的基础设施:在微服务软件开发的早期，网飞主要使用 Java 编程来开发微服务。他们还开发了许多库(网飞 OSS 栈包括 Hystrix，Zuul )。许多公司效仿网飞，开始使用 librariesNetflix OSS。后来，许多公司(包括网飞)发现，由于庞大的体积和冷启动问题，Java 并不是开发微服务的事实语言。网飞后来采用了多语言微服务模式，并决定不再进一步开发网飞 OSS，这导致了跟随者公司陷入困境。因此，与其在特定语言库(如基于 Java 的网飞操作系统)上大量投资，不如使用框架(如服务网格、API 网关)更明智。****

10。组织方面的考虑:差不多 50 年前(1967 年)， 梅尔文·康威 给出了一个观察，一个公司的软件架构是受组织结构限制的(康威定律)。尽管这一观察已有 50 年历史，但麻省理工学院和哈佛商学院最近发现，该定律在现代仍然有效。如果一个组织计划开发微服务架构，那么它应该相应地制定团队规模(两个“美式”披萨团队:7 个 2 人)。此外，该团队应该是跨职能的，理想情况下将有前端/后端开发人员，运营工程和测试人员。只有更高的管理层也相应地改变他们的观点和视野，微服务架构才会起作用。***

如果你觉得这很有帮助，请分享到你最喜欢的论坛上( Twitter，脸书，LinkedIn )。高度赞赏评论和建设性的批评。感谢阅读！

如果你对微服务架构感兴趣，也可以看看我下面的文章:

***** [## 微服务架构及其 10 个最重要的设计模式

微服务架构、每个微服务的数据库、事件源、CQRS、Saga、BFF、API 网关、扼杀者、电路…

towardsdatascience.com](/microservice-architecture-and-its-10-most-important-design-patterns-824952d7fa41) [## 透过宣传看:模块化整体软件架构真的死了吗？

现代软件开发中模块化整体软件体系结构的真实性检验

medium.com](https://medium.com/@md.kamaruzzaman/looking-beyond-the-hype-is-modular-monolithic-software-architecture-really-dead-e386191610f8) [## 微服务架构:简要概述以及为什么您应该在下一个项目中使用它

微服务架构的背景以及微服务架构相对于整体架构的优势

towardsdatascience.com](/microservice-architecture-a-brief-overview-and-why-you-should-use-it-in-your-next-project-a17b6e19adfd)*****

R 中有效的通知机制

原文：https://towardsdatascience.com/effective-notification-mechanisms-in-r-82db9cb8816?source=collection_archive---------29-----------------------

在这里，我们探索不同的 R 通知机制，并看看每种机制的优缺点。

Photo by Prateek Katyal on Unsplash

想象一下，运行一个聚类算法需要 4-5 个小时才能完成，现在你要么等待它完成，要么随着你的耐心减少，每小时检查一次，看看这个过程是否已经完成。

想象所有这样的场景，然后想象一个通知机制，它会让你知道进度或者一旦完成就通知你。

我们是来讨论这个问题的。

让我们从最简单的通知机制开始这篇短文，这个机制被亲切地称为“beepr”。

beepr

顾名思义，它只是在函数被调用时发出声音。代码是这样的:

library(beepr)
beep()

你也可以从 10 种你想要的声音中选择。这是一个非常简单易用的软件包，关于可用声音的更多细节，你可以参考这里。

RPushbullet

这是我个人最喜欢的一个，RPushbullet 利用push pulletAPI 跨设备发送通知。它可以是任何东西，浏览器/android/ios，只要你在设备上安装了 pushbullet 你就好。

**Step 1:** Install pushbullet app in your phone/browser
**Step 2:** Access pushbullet settings from your browser and get the token/key for your account.
**Step 3:** Run
*library(RPushbullet)
pbSetup()* **Step 4:** Once you run the above step you will be asked to enter the token and select the registered device in the r console itself, do that.
**Step 5:** Run a similar code with your message and you are done
*pbPost("note", "Clustering Completed", "Clustering completed in 4hrs 13mins")*

这不仅仅是笔记，你也可以发送链接，文件作为一个信息和通知将显示在注册的设备。

通常这是我发现最有用的一个。它非常容易安装，也是所有解决方案中最实用的，不管你的代码是运行在服务器上还是桌面上。

`notifier`

这是一个基于桌面的通知包，可以用来在 macOS，Windows 和 Linux 上发送桌面通知。这里有一篇关于 macOS 实现这个的文章。但不幸的是，我无法让它在我的 Windows 10 机器上工作，它总是出现这样或那样的错误。但是步骤很简单，如果你能做到，请告诉我。

#install.packages("devtools") if devtools is not installed
devtools::install_github("gaborcsardi/notifier")library(notifier)
#composing the first notification message

notify(
  title = "Here goes the Title",
  msg = c("Hello","World")
  )

这张图是 macOS 用的，取自这里。这也是在桌面环境中获得通知的一种非常方便的方法，但是如果您的代码在服务器上运行，这种方法就没什么用了。

邮件

通过 mailR 包，你可以从 r 发送电子邮件。但是我不喜欢使用这个，你必须在脚本中传递用户 id/密码，这不太安全。但你仍然感兴趣的是下面的代码。

install.packages(“mailR”)
library(mailR)send.mail(from = “[sender@gmail.com](mailto:sender@gmail.com)”,
 to = c(“[recipient1@gmail.com](mailto:recipient1@gmail.com)”, “Recipient 2 <[recipient2@gmail.com](mailto:recipient2@gmail.com)>”),
 replyTo = c(“Reply to someone else <[someone.else@gmail.com](mailto:someone.else@gmail.com)>”),
 subject = “Subject of the email”,
 body = “Body of the email”,
 smtp = list(host.name = “smtp.gmail.com”, port = 465, user.name = “gmail_username”, passwd = “password”, ssl = TRUE),
 authenticate = TRUE,
 send = TRUE)

如果需要的话，你可以参考这篇文章以获得更多的细节和解决谷歌不太安全的应用程序问题的方法。

`RDCOMClient — Outlook`

这是另一个特别有帮助的方案，如果你在日常生活中必须展望未来的话。安装和运行起来非常简单

library(RDCOMClient)
## init com api
OutApp <- COMCreate("Outlook.Application")
## create an email 
outMail = OutApp$CreateItem(0)
## configure  email parameter 
outMail[["To"]] = "test@test.com"
outMail[["subject"]] = "some subject"
outMail[["body"]] = "some body"
## send it                     
outMail$Send()**#edit to add attachment** outMail[["Attachments"]]$Add(path_to_attch_file)**#edit to change “from” (send from secondary mailbox)** outMail[["SentOnBehalfOfName"]] = "yoursecondary@mail.com"

加上发送附件和从另一个邮箱发送的额外优势，这在各种情况下都很有用。

现在就这些了，现在有了这些，在 R 中实现通知就容易多了，希望能让我们的生活轻松一点。

寻找深度学习论文的有效方法

原文：https://towardsdatascience.com/effective-way-for-finding-deep-learning-papers-daa27415ad16?source=collection_archive---------12-----------------------

Woman holding book on bookshelves — Photo by Becca Tapert on Unsplash

最近，我看到了一段吴恩达教授的精彩视频，他在斯坦福大学的计算机科学课上解释了如何在人工智能领域出类拔萃。

我将在下面改写他的话。

深度学习发展得足够快，即使你已经学习了深度学习的基础，当你从事特定的应用时，你也需要阅读研究论文，以掌握最新的想法。

吴教授分享了一个简单而有效的阅读计划技巧。它包括以下步骤:

选择一个你感兴趣的主题(例如语音识别、文本摘要、用 GANs 生成图像)。
列出 10-20 篇论文/文章/博客文章。
逐渐将此列表扩展到 50+篇论文。

此外，他还提出了几个寻找资源的地方，包括 Twitter 、机器学习 subreddit 、 NIPS 、 ICML 和 ICLR (后 3 个是机器学习会议)。

遵循这个技巧，我想到了一个问题:

找到合适的论文集需要花费多少时间和精力？

在奉献了几个小时并最终成功地找到了一套我渴望的论文和文章后，我决定分享我的经验并在这一旅程中帮助他人。

如何开始？

第一步是决定一个特定的主题/问题。就我而言，我有兴趣了解更多关于深度学习如何应用于任何类型贷款(抵押贷款、个人贷款、信用卡等)的信用风险评估。)

一旦你有了主题，最好把所有与它相关的关键词列下来。对我来说，这些是:信用，贷款，借贷，抵押贷款，风险，评估，分数，银行，金融。

当你搜索一篇论文/文章/博客文章时，将这些关键词与“深度学习”、“机器学习”或“神经网络”结合起来，以获得所需的结果。

在网上寻找资源

寻找合适的资源可能需要 1 小时到 1-2 天的时间。这真的取决于你有多大决心找到“完美”的试卷。然而，人们应该避免在研究上花费不必要的时间，只要他/她找到 3-4 篇论文，实际的阅读就可以开始了。下面列出了几种查找资源的有效方法。

标准谷歌搜索

有目共睹的是，谷歌搜索上述关键词是第一步。不幸的是，我没有发现这种方法如此有效，因为结果通常不包括实际的解决方案，而是主题的概述，适合任何读者。

然而，如果你搜索谷歌学术，找到你需要的东西的可能性要高得多。

探索顶级机器学习会议

第二步是浏览过去几年会议的所有标题，并提取听起来有趣的内容。例如，让我们看看 NIPS 会议并尝试找到提交的论文列表。

首先，转到https://nips.cc/，将年份从 2019 年改为 2018 年、2017 年等。

对于每一年，将 URL 从https://nips.cc/Conferences/2019更改为https://nips.cc/Conferences/2019/Workshopbook并点击回车。包含今年所有论文摘要的“研讨会手册”PDF 将开始自动下载。

最后，浏览各章节，挑选与你的主题相关的论文。

其他会议的网站上也有“研讨会手册”，您可以通过类似的方式获得。

搜索最流行的在线研究论文库

这类网站包括arxiv.org、语义学者、科学导报等。在每个平台上使用您预定义的关键字和“高级搜索”选项来查找感兴趣的资料。

注意:有些文件可能是私有的，需要购买。请记住，如果你是学生(来自任何大学)，你可以免费获得这些论文。您也许可以使用您的学生凭据登录并获取 pdf。否则，请向您的学校寻求进一步的指导。

深入研究一篇论文

找到一套与你的主题完全匹配的论文的过程可能是乏味且耗时的。你很可能会找到相关的论文(在相同或相邻的领域)，但不完全是你需要的。

不要忘记，研究人员是基于以前的发现来完成他们的工作的，每篇论文都包括大量的参考文献。

下面是我如何利用上面的陈述找到我想要的东西:

在看了 NIPS 2018 研讨会的书籍后，我发现了一个很棒的研讨会，名为“人工智能在金融服务中的挑战和机遇:公平性、可解释性、准确性和隐私的影响”。
大多数论文并不完全是关于评估信用价值，而是关于让金融领域使用的深度学习模型更具解释力的新方法。
我认为，为了让作者讨论模型的可解释性，他们必须查看(并引用)实际的算法。令人惊讶的是，我发现最初的 3-4 个参考正是我所需要的。

这种方法帮助我扩展了资源列表，找到了真正有用的材料。

过滤噪音

在这最后一节，我想回顾一下我在选择特定论文时所关注的几件事。这有助于我过滤大部分噪音，让我专注于更少但质量更高的来源。

作者 —论文可以由不同领域的不同研究人员发表。我通常会在 LinkedIn 或 Twitter 上查找作者的姓名和机构。例如，一篇由大型银行/金融机构的研究人员撰写的关于深度学习的信用风险评估的论文是一个优质材料。此外，好学校(斯坦福、麻省理工、蒙特利尔大学)和公司(脸书、谷歌、百度)通常拥有最强的研究人员。
发表日期 —深度学习领域正在快速发展，因此 5 年前的一篇论文在今天可能无关紧要。我倾向于寻找更近期的材料，但从不忽视很久以前的好论文，尤其是如果它介绍了一种突破性的技术。
被引用次数 —如果一篇论文没有被引用，通常这并不自动意味着它不是一篇高质量的材料。我经常看被引用的次数，只是为了了解论文的受欢迎程度，但这从来不是决定性因素。

这就是我有效搜索研究论文和文章的方法。如果你有任何意见或建议，请在评论区分享。

谢谢你的阅读。希望你喜欢这篇文章🤩我祝你今天过得愉快！

有效挖掘专利数据的真正价值

原文：https://towardsdatascience.com/effectively-exploiting-the-real-value-of-patent-data-990fbb3d0a43?source=collection_archive---------15-----------------------

B ig 数据 在制造和运营的所有领域越来越可用，这为实现有竞争力的数据驱动型经济提供了价值。随着数据可用性的增加，支持和 工业 4.0 的数据可用性增加，这为更好的决策和战略制定带来了巨大的机遇，从而推出了下一代创新和颠覆性技术。

O 在过去的二十年里，专利分析和知识产权分析领域有了长足的发展( Trippe，2003； Aristodemou 等人，2018 。随着专利数据的数字化(1984 年的 BACON 项目)以及过去几十年来数据质量和分析技术的不断改进，世界上最大的技术信息库已经变得越来越容易获取，成本也在迅速降低。

在最近的一项研究中，我们使用了技术路线图方法来探索专利分析的未来，我们确定了 11 项优先技术，如人工智能和人工神经网络，行业专家认为这些技术在专利分析领域中以更高的比率被采用是非常重要的。

Fig. 1 Future of Patent Analytics Technology Roadmap Enablers (Source: Aristodemou and Tietze, 2017)

我们确定了采用这些计算机科学技术的需求，以补充决策流程并提供决策支持( Aristodemou 和 Tietze，2017 )。此外，我们确定了 4 个使能支柱，它们可以促进上述目标的实现；即技术开发周期和方法、立法、持续发展和合作(图 1)。

在全球创新经济中，知识产权的重要性正在迅速增加，并且变得更加复杂。人工智能(AI)、大数据分析和区块链等新技术可用于应对知识产权领域面临的日益严峻的挑战。我们将知识产权分析(IPA)** 定义为:**

分析大量知识产权信息的数据科学，以发现关系、趋势和模式，从而做出决策。

Fig. 2 Artificial Intelligence Methods used with Intellectual Property Data (Source: Aristodemou et al., 2018)

具体来说，在最近发表在《世界专利信息》特刊上的一篇论文中，我们回顾了 57 篇最近发表的文章，该论文题为【TechMining 的知识产权信息高级分析。在元数据分析之后，我们将它们分为 4 大类:、知识管理、技术管理、经济价值以及信息的提取和有效管理，然后确定其中使用的具体方法和算法。图 2 显示了文献中使用的知识产权分析方法的拓扑结构，如 Aristodemou 等人在 2018 年中所讨论的。很明显，研究中存在所有三种学习模型类型:监督、半监督和非监督模型；大多数文章都集中在人工神经网络的使用上。此外，还值得注意的是，所使用的大多数方法都是在数据预处理阶段，即在运行任何算法之前准备专利数据。这显示了这些技术在以这样一种方式构建专利数据中的重要性，使得模型是可感知的和可理解的。用计算机科学的语言来说，这表明了“垃圾输入垃圾输出”(GIGO)** ，或者换句话说“合理输入合理输出”(SIRO) 对于任何模型的重要性。**

C 因此，公司需要密切注意保护和利用这些隐藏在数据本身中的有价值的信息。过去，知识产权安全的重点是保留员工掌握的知识，而现在，重点正转向利用、连接、分析和保护数据。凭借强大的算法和计算机速度，我们现在能够根据个人和组织的需求提取和分析大量数据。****

Fig. 3 Data Analysis mini-Technology Roadmap Summary (Source: Aristodemou and Tietze, 2017)

这可以通过图 3 中的微型技术路线图部分实现。在短期内，重要的是稳定和建设一个有效的、以目标为导向的基础设施。随着对现有分析技术的进一步理解，这将在如何使用分析工具来避免黑盒方面建立透明度。随后可以开发定制的方法，使用人工智能方法对中期专利数据进行有效的数据分析，从长期来看则是一个完全适应的系统。使用开源社区和开放数据的其他举措可以促进这些过程。重要性在于从专利中获得的技术价值和专利的经济价值之间的联系，即市场愿意为一项这样的发明及其利益支付多少钱。****

参考资料:

**Aristodemou，l .，& Tietze，F. (2018 年)。知识产权分析(IPA)的最新发展:一篇关于人工智能、机器学习和深度学习方法的文献综述，用于分析知识产权(IP)数据。世界专利信息，55 37–51。【https://doi.org/10.1016/j.wpi.2018.07.002 **
Aristodemou，l .和 Tietze，f .，2017 年。探索专利分析的未来。英国剑桥大学制造研究所技术管理中心(CTM)洞察报告，ISBN:978–1–902546–84–1。请访问:https://www . IFM . eng . cam . AC . uk/insights/innovation-and-IP-management/exploring-the-future-of-patent-analytics/
Trippe，a . j .(2003)“Patinformatics:任务到工具”，世界专利信息，25(3)，第 211–221 页。doi:10.1016/s 0172–2190(03)00079–6

关于作者:

Leonidas Aristodemou 是人工智能、技术和创新管理领域的博士研究员。他是剑桥大学制造研究所(IfM)技术管理中心(CTM)创新和知识产权管理(IIPM)小组的成员。他目前是伦敦艾伦图灵研究所的访问学者。他目前的研究围绕着大数据的使用、应用机器学习和知识产权分析；更具体地说，他分析知识产权数据的大数据集，并使用深度学习模型预测技术价值/影响。预计这将改善创新管理模式中的技术战略决策过程。

轮廓

领英:https://www.linkedin.com/in/leonidasaristodemou/

**剑桥:【http://www.eng.cam.ac.uk/profiles/la324 **

图灵:https://www . Turing . AC . uk/people/博士生/leonidas-aristodemou

有效地预处理文本数据第一部分:文本清洗

原文：https://towardsdatascience.com/effectively-pre-processing-the-text-data-part-1-text-cleaning-9ecae119cb3e?source=collection_archive---------3-----------------------

本文的内容直接来源于 Francois Chollet 的《使用 Python 进行深度学习》和 Manning、Raghavan 和 Schütze 的《信息检索导论》。本文中使用的一些信息图表也取自上述书籍。

文本是一种数据形式，在人类历史中已经存在了几千年。所有影响所有宗教的神圣文本，所有诗人和作家的作品，他们那个时代最聪明的头脑做出的所有科学解释，所有定义我们的历史和未来的政治文件，以及各种明确的人类交流，这些“所有”都定义了以我们所谓的文本形式存在的数据的重要性。

在我之前的文章 有效的数据预处理和特征工程， 中，我已经用三个主要步骤解释了预处理的一些一般过程，这三个步骤是“转换成向量、归一化和处理缺失值”。本文将介绍将文本数据转换成某种形式的向量的前传步骤，更多的是关于数据清理。

文本只是一个单词序列，或者更准确地说，是一个字符序列。但是，当我们通常处理语言建模或自然语言处理时，我们更关心作为一个整体的单词，而不仅仅是担心我们的文本数据的字符级深度。这背后的一个原因是，在语言模型中，单个字符没有很多“上下文”。像' d '，' r '，' a '，' e '这样的字符不单独包含任何上下文，但当以单词的形式重新排列时，它们可能会生成单词“read”，这可能解释了你可能正在做的一些活动。

矢量化只是一种将单词转换成长串数字的方法，这些数字可能具有某种复杂的结构，只有使用某种机器学习或数据挖掘算法的计算机才能理解。但即使在此之前，我们也需要对文本执行一系列操作，以便我们的文本可以被“清洗”掉。数据“清理”的过程可能因数据来源的不同而不同。文本数据清理的主要步骤如下所示，并附有解释:

删除不需要的字符

这是文本清理过程中的主要步骤。如果我们从 HTML/XML 源中删除一些文本，我们需要去掉所有的标签、HTML 实体、标点符号、非字母和任何其他可能不属于该语言的字符。这种清理的一般方法包括正则表达式，可以用来过滤掉大部分不需要的文本。

有些系统保留了重要的英文字符，如句号、问号、感叹号等。考虑一个例子，你想对人类生成的推文进行一些情感分析，你想把推文分类为非常生气、愤怒、中性、高兴和非常高兴。简单的情绪分析可能会发现很难区分快乐的情绪和非常快乐的情绪，因为有些时候只有语言无法解释。

考虑语义相同的两个句子:

“这菜不错。”，还有“这个。食物。是。很好！！！！！！！!"。

明白我想说什么了吗？同样的词，但完全不同的情感，唯一能帮助我们看出不同的信息是过度使用的标点符号，这显示了某种“额外”的感觉。

由非字母组成的表情符号也在情感分析中发挥作用。“😃，😦，-_-，😄，xD”，所有这些，当被正确处理时，可以帮助进行更好的情感分析。即使你想开发一个系统来分类某个短语是不是讽刺，这样的小细节也是有帮助的。

撇号是一种重要的标点符号，需要小心处理，因为许多文本都可以基于撇号。像“不是，不应该，没有，本来会，可能不会，你们都已经”这样的术语就像一种疾病一样渗透到在线文档中，幸运的是，我们也有治愈这种疾病的方法。这里的是一个很好的词典，收录了所有这些单词的缩写，你可以用它来将包含撇号的单词转换成正式的英语术语，用空格隔开。

以正确的格式编码

有多种数据编码可供选择，如 UTF-8 编码、拉丁编码、ISO/IEC 编码等。UTF-8 是大多数电脑最常用的编码之一，因此将文本转换为 UTF-8 编码总是一个好主意。但是，根据应用程序和您的编程环境，您也可以用其他格式编码。

标记化和资本化/去资本化

标记化就是把一个句子拆分成单词的过程。

Tokenization of a sentence

您可能已经意识到，上面的例子不仅标记了句子，还确保了所有的单词都是小写的。这个例子不仅划分了个体实体，而且摆脱了所涉及的资本主义(没有双关的意思)。资本化和去资本化同样取决于应用程序的用途。如果我们只关心术语，而不是它们的“存在强度”，那么所有小写的术语都应该没问题，但是如果我们想区分任何情感，那么大写的东西可能意味着不同于小写的东西。请参见下面的示例:

“我们去高地吧！”

同样，后者比第一句表现出更多的热情。

移除/保留停用字词

这个清理步骤还取决于预处理后您最终将对数据做什么。停用词是使用非常频繁的词，它们太频繁了，以至于有点失去了它们的语义。像“of，are，the，it，is”这样的词是停用词的一些例子。在文档搜索引擎和文档分类等应用中，关键字比一般术语更重要，删除停用词可能是一个好主意，但如果有一些应用，例如歌曲歌词搜索或搜索特定引用，停用词可能很重要。考虑一些例子，比如“生存还是毁灭”，“看看你让我做了什么”等等。这些短语中的停用词实际上起着重要的作用，因此不应该被删除。

有两种常见的删除停用词的方法，这两种方法都相当简单。一种方法是对所有出现的单词进行计数，并提供计数的阈值，并去除出现次数超过指定阈值的所有术语/单词。另一种方法是有一个预定的停用词列表，它可以从标记/标记化句子列表中删除。

当在基于语义/情感分析的系统上工作时，一些人类表达，如“哈哈哈，lol，lmfao，brb，wtf”也可以是有价值的信息，但是对于需要更正式类型的应用程序的系统，这些表达也可能被删除。

打破附字

文本数据可以包含连接在一起的单词，单词之间没有空格。社交媒体上的大多数标签都是像“# AwesomeDay、#DataScientist、#BloggingIsPassion”等。天啊。这样的术语也需要注意，一个简单的方法是根据大写字母拆分这些术语，如果我们保留大写字母，这是可能的。如果我们不想保留大写，那么这个步骤应该在标记化步骤中执行，就在所有内容都变成小写之前。

词汇化/词干化

词干化和词元化的目标都是将一个单词的屈折形式，有时是衍生相关形式减少到一个共同的基本形式。“也就是说，词干化/词汇化有助于我们将全部术语的数量减少到某些“根”术语。

组织者，组织者，组织者，有组织的所有这些都可以归结为一个词根，也许是“organiz”。

词干提取是一种简单的方法，通过定义在单词末尾去掉一些字符的规则来减少单词的词根，希望在大多数情况下能得到好的结果。

Examples of stemming

词汇化相对来说是一种更系统的方法，做词干化做的同样的事情，但是涉及一些词汇和词法分析。

同样，词干化和词汇化过程应该只在需要的时候执行，因为单词的词缀包含可以利用的附加信息。比如“更快”和“最快”的词根相同，但语义却互不相同。因此，如果您的应用程序只与术语相关，正如大多数搜索引擎和文档聚类系统所做的那样，那么词干化/词条化可能是一个选项，但对于需要考虑一些语义分析的应用程序，词干化和词条化可能会被放弃。

拼写和语法纠正

这些技术是在处理文本数据时获得更好结果的好方法。在一个场景中，你需要为一些正式的用例训练一个聊天机器人，并且你有很多可用的人类对话文本数据，那么你可能要执行拼写和语法纠正，因为如果你的聊天机器人在垃圾上得到训练，它也可能会犯很多错误。此外，由于计算机不擅长区分“awesome”和“awesum ”,同一单词的这两个变体最终将具有不同的特征向量，并将被不同地处理。我们不希望发生这种情况，因为这两个术语都是相同的，只是有一个拼写错误。人为错误不应该对计算机的学习方式产生影响，这一点很重要。如果计算机开始犯和人类一样的错误，那么它们将和那些经常犯错的人一样没用。

总结这篇文章，数据清理就是去除数据中的“噪音”。但是您的应用程序决定数据中哪些内容是噪声，哪些不是噪声。一旦你弄清楚你需要从数据中保留什么，丢弃什么，那么你肯定会有一个按你计划的方式工作的应用程序。

如果你已经执行了上面提到的步骤，或者甚至是其中的一些步骤，那么现在你应该有一个由多个列表组成的矩阵 X ，其中每个列表都包含一个句子中经过清理和标记的单词。现在，下一步是使用一种技术，将所有的标记化列表转换成向量 v 。这个问题将在接下来的文章中讨论，标题为“有效地预处理文本数据第二部分:实现”。

对于任何疑问/评论/批评，我都愿意进行建设性的沟通。

数据科学快乐！

运行全卷积网络的有效方法

原文：https://towardsdatascience.com/efficient-method-for-running-fully-convolutional-networks-fcns-3174dc6a692b?source=collection_archive---------14-----------------------

全卷积(深度神经)网络(fcn)通常用于计算机视觉任务，如语义分割、超分辨率等。它们最好的特性之一是它们适用于任何大小的输入，例如不同大小的图像。然而，在大规模输入(如高分辨率图像或视频)上运行这些网络可能会消耗大量 GPU 内存。在这篇文章中，我将介绍一个简单的方法来缓解这个问题。所提出的算法将 GPU 内存使用率降低到只有 3–30%。

什么是全卷积网络？

一个完全卷积的网络(从现在开始:FCN)是一个仅由卷积层组成的网络。如果你对卷积层不熟悉，这里的是初学者指南。为了简单起见，在这篇文章中，我们将关注图像，但这同样适用于视频或其他类型的数据。

A fully convolutional network for segmentation. input and output images from Nvidia dev blog

对于图像处理中的许多任务，要求输入和输出图像具有相同的尺寸是很自然的。这可以通过使用具有适当填充的 fcn 来实现(TensorFlow 中的‘相同’)。因为这是一个标准程序，从现在开始我们假设它成立。

在这种架构下，输出图像中的每个像素都是对输入图像中的相应补片进行计算的结果。

这个斑块的大小称为网络的感受野(RF)。

这是一个关键点。我们将很快看到算法如何使用这个属性

FCN with one layer: 3x3 convolution. each output pixel corresponds to a 3x3 patch in the input image

FCN with 2 layers: each is a 3x3 convolution. each output pixel corresponds to a 5x5 patch in the input image

上面我们可以看到带有一个(顶部)和两个(底部)3×3 conv 层的 fcn 的插图。在一层(顶部)的情况下，右侧的蓝色输出像素是对左侧蓝色输入面片的计算结果。当有两层(底部)时，我们在输入和输出之间有一个特征图。特征图中的每个绿色像素(中间)都是在一个 3×3 绿色输入面片(左侧)上计算的结果，与一个图层的情况相同。类似地，每个蓝色输出像素(右)是对蓝色 3x3 特征图块(中)的计算结果，该特征图块源自 5x5 蓝色输入块(左)。

所以..有什么问题？

如前所述，理论上，我们可以将网络应用于任何输入大小。然而，实际上，计算通过网络的正向传递需要在内存中保存巨大的特征图，这会耗尽 GPU 资源。我在研究视频和 3d 图像时遇到了这个限制。网络根本无法在我们花哨的 NVIDIA v100 GPUs 上运行，这促使我开发了这个解决方案。

通过 FCN 传递大量输入的有效方式

传统 CNN 以完全连接的层结束。因此，每个输出像素都是整个输入的计算结果。在 fcn 中情况并非如此。正如我们所见，只有来自输入的感受野大小的小块影响单个输出像素。因此，要计算单个输出像素，不需要将整个特征图保存在内存中！

换句话说:

我们可以一次计算一小部分输出值，同时只传递输入中必要的像素。这大大减少了 GPU 的内存使用！

让我们来看看下面的例子:
我们的输入是一个 28x28 的图像，如下图所示。由于内存限制，我们可以通过最大 12x12 的网络补丁。最简单的方法是从原始输入(下图中的轮廓)输入 12×12 的面片，并使用 12×12 的输出面片来构建 28×28 的输出图像。

Each output pixel is the result of a different patch passing through the network. For example, orange pixels are the result of passing the orange 12x12 patch.

不幸的是，这种方法不会产生与一起传递整个 28x28 输入相同的结果。原因是边界效应。

解决边界效应

为了理解这个问题，让我们看看下图中标记的红色像素。周围的红色方块代表感受野，在本例中大小为 5x5，跨越蓝色和橙色区域。为了正确计算红色输出像素，我们需要同时计算蓝色和橙色像素。因此，如果我们像在天真的方法中那样分别运行蓝色和橙色的补丁，我们将没有必要的像素来精确地计算它的值。显然，我们需要另一种方法。

Red — a boundary pixel and the receptive field around it

那么我们如何才能让它变得正确呢？我们可以使用重叠的补丁，这样每个 5×5 补丁将包含在通过网络的 12×12 补丁之一中。重叠量应该比感受野(RF -1)少 1 个像素。在我们的例子中，感受野 RF=5，所以我们需要 4 个像素的重叠。下面的动画演示了不同的图像补丁如何在给定的限制下通过网络传递。它显示了每个 12×12 输入面片(轮廓)在输出(填充)中贡献了更少量的像素。例如，蓝色方形轮廓比蓝色像素填充的区域大。

Overlapping patches. For example, orange pixels are the result of passing the orange 12x12 patch.

回到我们标记的红色像素。现在，如下图所示，由于重叠，它可以正确计算。它的 5x5 周围补丁完全包含在橙色 12x12 补丁中(轮廓)

实际上，每个像素都有一个 12×12 的小块包含其感受野大小的周边 。 这样我们可以确保同时运行整个 28x28 图像的效果。

red — a boundary pixel and the receptive field around it

结果

下表给出了一些关于 GPU 内存使用和运行时间的实验结果。正如所承诺的，内存消耗是显着减少！

注意:尽管每个图像的运行时间较慢，但是使用这种方法我们可以并行传递多个图像，因此节省了时间。例如，在第 3 行中，使用该算法我们可以同时运行 13 个图像，这将花费与使用直接方法仅运行 6 个图像一样多的时间。

with patch by patch algorithm GPU memory usage is reduced by 67%-97% compared to standard method

实验在 NVIDIA Tesla K80 GPU 上运行。

感谢本·范斯坦、因娜·格里涅维奇、阿维夫·内塔尼亚胡和阿耶莱特·萨皮尔斯坦

EfficientDet:可扩展和高效的对象检测综述

原文：https://towardsdatascience.com/efficientdet-scalable-and-efficient-object-detection-review-4472ffc34fd9?source=collection_archive---------10-----------------------

谷歌大脑团队最近发表了另一篇基于他们预览工作的对象检测论文，EfficientNet。该论文的作者提出了一种可扩展的检测架构，同时在广泛的资源限制范围内实现更高的准确性和效率。与其他检测网络相比，EfficientDet 网络系列可实现类似的性能，同时减少参数和触发器的数量。

效率净值汇总

在深入研究 EfficientDet 纸之前，我们首先需要了解 EfficientNet 纸。与 EfficientDet 不同，该网络旨在提升 ImageNet 域中的网络性能。EfficientNet 论文中的核心概念是网络在多个维度(输入分辨率、深度、宽度)上的复合扩展。EfficientNet 不是只扩展网络的一个或两个维度，而是扩展网络的所有维度。

如上图所示，传统方法只增加了网络的一个维度(宽度、深度或分辨率)。这可以通过手动调整缩放系数来提高模型的性能，但是找到正确值的过程是一个冗长的过程，并且经常导致次优的精度和效率。

当在 EfficientNet 中执行复合缩放时，使用固定的缩放系数统一执行每个维度中的调整。例如，当给定 2^N 计算资源时，我们可以通过α^N 增加网络深度，通过β^N 增加宽度，通过γ^N 增加图像大小，其中α、β和γ是通过在原始小模型上的小网格搜索确定的常系数。使用多目标神经架构搜索来执行找到基础效率 Net-B0 的过程。然后，从找到的基线网络开始，应用复合缩放方法来放大网络的维度。

要了解更多关于 EfficientNet 论文的信息，我建议在这里阅读论文。

效率检测

在 EfficientDet 论文中，做出了两个主要贡献:(a) BiFPN 允许双向快速多尺度特征融合。(b)一种新的复合缩放方法联合放大主干、特征网络、盒/类网络和分辨率。使用 BiFPN 和新的复合缩放，形成了一系列高效的 Det 网络，在准确性和效率方面优于以前的对象检测器。

BiFPN

BiFPN 的目标是以自上而下的方式有效地聚合多尺度特征。上图显示了基于 FPN 的不同汇总方法的比较。从(a)开始，典型的 FPN 网络融合了从 3 级到 7 级的多尺度特征。PANet 架构(b)在 FPN 之上增加了一个额外的自底向上的路径，以有效地利用较低层次的特性。节点之间的连接也可以通过使用神经结构搜索来找到。如(c)所示，这些连接不同于人类构建的连接。

通过比较这三种架构，作者观察到 PANet 比 FPN 和 NAS-FPN 实现了更好的准确性，但代价是更多的参数和计算。从 PANet 架构开始，为了提高模型效率，EfficientDet 的作者首先删除只有一个输入边的节点，并创建 PANet 架构的简化版本，如(e)所示。直觉是，如果一个节点只有一条输入边而没有特征融合，那么它对旨在融合不同特征的特征网络的贡献将会更小。然后，如果节点处于同一级别，作者会从原始输入向输出节点添加一条额外的边。这样做是为了在不增加太多成本的情况下融合更多功能。最后，与只有一个自上而下和一个自下而上路径的 PANet 不同，双向(自上而下和自下而上)路径被视为一个要素网络图层，并多次重复同一图层以实现更高级别的要素融合。最终提出的 BiFPN 架构如(f)所示。

当特征被融合在一起时，利用加权特征融合。由于不同分辨率下的不同输入特征对输出特征的贡献不相等，因此在进行特征融合时，每个输入的额外权重充当比例因子。具体而言，使用上式所示的快速归一化融合。通过在每个ω后应用 relu 来确保每个ω的正定性，并添加ϵ以避免数值不稳定。

复合缩放

网络复合扩展的目的是扩大基线模型(EfficientDet D0)的规模，以涵盖广泛的资源限制。一个简单的复合系数φ联合放大了主干网络(BiFPN)、类/箱网络和分辨率的所有维度。在 EfficientNet 论文中使用了网格搜索，但使用了基于启发式的缩放方法，因为对象检测器比图像分类模型具有更多的缩放维度。

(a)主干网络:使用与 B6 efficient net-B0 相同的宽度/深度比例系数来恢复 ImageNet-pretrained 检查点。

(b) BiFPN 网络:使用等式(1)，BiFPN 网络的宽度以指数方式增长，深度以线性方式增加，以将深度值舍入为小整数。

(c)盒/类预测网络:预测网络的宽度固定为总是与 BiFPN 相同，但是预测网络的深度使用等式(2)线性增加。

(d)输入图像分辨率:由于在 BiFPN 中使用特征级别 3–7，输入分辨率必须能被 2⁷ = 128 整除，因此使用等式(3)图像的分辨率线性增加。

结果

使用复合比例方法，可生成一系列 EfficientDet 网络(efficient det D0–07)。上表显示了 COCO 数据集上模型的单尺度性能。与以前的检测机相比，EfficientNet 型号在各种精度或资源限制下实现了更高的精度和效率。请注意，EfficientDet-D0 模型实现了与 YOLOv3 相似的精度，但触发器数量减少了 28 倍。此外，与 RetinaNet 和 Mask-RCNN 相比，EfficientDet-D1 实现了相似的精度，但参数减少了 8 倍，触发器减少了 25 倍。

对于那些想了解 EfficientDet 更多信息的人，我建议阅读整篇文章。下面提供了链接。

参考

[## EfficientNet:重新思考卷积神经网络的模型缩放

卷积神经网络(ConvNets)通常是在固定的资源预算下开发的，然后按比例放大用于…

arxiv.org](https://arxiv.org/abs/1905.11946) [## EfficientDet:可扩展且高效的对象检测

模型效率在计算机视觉中变得越来越重要。在本文中，我们系统地研究了各种模型

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

高效地寻找昂贵函数的根

原文：https://towardsdatascience.com/efficiently-finding-a-root-of-an-expensive-function-80431c035bb?source=collection_archive---------34-----------------------

解释了二次插值，用 Python 编写了示例代码

Photo by Josh Riemer on Unsplash

有时候在科学编程中，你需要使用一个平滑的实值函数 f ( t )来计算开销。具体来说，你可能需要找到函数值变为零的地方。我最近在我的开源天文图书馆工作时遇到了这个问题。我想知道月出月落的时间。这包括计算地球的自转和月球绕地球的轨道，以确定在特定地理位置的观察者所看到的月球何时穿过地平线。

在我的例子中， f ( t )是观察者在时间 t 看到的月亮在地平线以上或以下的视在角高度。找到月出或月落时间意味着找到 t 的值，使得 f ( t )=0。用数学术语来说，我想找到函数 f 的根。

评估 f ( t )包括计算月球位置，这需要上千次浮点运算。我想尽量减少我不得不评估 f ( t )的次数，因为我找到了一个足够好的值 t 。我寻找精确到几秒钟以内的时间。

解决这类问题的一个相当好的方法是在开根之前找到时间 t ₀，在开根之后找到另一个时间 t ₁。假设你知道时间间隔足够小，在它里面不会有一个以上的根。(在我的例子中，我知道一个小时内不可能有一次以上的月出。)

假设你确定 f ( t ₀) < 0，f( t ₁) > 0。情况看起来是这样的:

There must be at least one root in the interval indicated by the arrow.

鉴于 f 是一个连续函数，在 t ₀和 t ₁之间至少有一个 t 的值，使得 f ( t )=0。连续函数不可能不经过零就从负值变成正值。

为了取得进展，我们在区间中间的时间 t ₂评估函数:

假设你发现 f ( t ₂) < 0。现在你已经了解了一些新的信息。你已经发现根一定在更窄的区间内的某个地方t₂<ttt<tt₁:

The uncertainty of the root’s location has been cut in half.

或者，如果您发现 f ( t ₂) > 0，您可以将您的搜索限制在左边的半区间，t₀<t<t₂.

无论哪种方式，您都可以将音程切成两半，并选择哪一半必须包含根。重复这样做被称为二分搜索法。您可以不断迭代，直到时间间隔变得相当小。

如我所说，二分搜索法是一种相当快速的方法。但是在某些条件下，使用二次插值比二分搜索法求函数的根要快得多。以下是条件:

该功能为平滑连续。
该函数在很小的区间内很好地近似为抛物线t₀<t<tt₁.非正式地说，在给定的区间上，函数有少量的曲率。
在函数值过零的 t ₀和 t ₁之间，必须有恰好一个 t 的值。换句话说，函数在给定的时间间隔内必须有唯一的根。

设置类似于上面的二分搜索法，在三个等间距的参数值 t 处评估函数。不同的是，你求的是经过三点的唯一二次函数。二次函数在小间隔上逼近昂贵函数 f 的值。二次函数看起来像这里的红色曲线:

Finding an approximate root using a quadratic curve.

一旦有了通过三点的抛物线的公式，就可以使用二次公式来求解抛物线与 t 轴相交的 t 的值。

那么你如何找到抛物线呢？让我们一步一步来。首先，我们将把在范围t₀≤t≤t₁内变化的时间变量 t 替换为一个抽象参数 x ，它具有更方便的范围 1≤ x ≤+1。这将使数学更简单。

花点时间来验证一下

如果 t = t ₀，那么x= 1；
如果 t = t ₂，那么x= 0；
而如果 t = t ₁，那么 x =+1。

第三种情况为真，因为₂位于₀和₁的中间，因此分子和分母相等。

第二步是写一个通用的抛物线函数 p ( x ):

总是恰好有一条抛物线通过这三个点。我们的下一个目标是找到导致抛物线 p ( x )通过我们为昂贵函数 f 评估的三个点的 Q 、 R 和 S 的值。我们写出反映这一要求的三个线性方程:

根据已知值 f ( t ₀)、 f ( t ₂)和 f ( t ₁)解这个三线性方程组，我们发现:

在继续之前，你的算法必须检查特殊情况。如果 Q =0，表示直线，而不是抛物线，通过所有三点。换句话说，p(x)=Rx+S。求根求x=S/R。当 Q=0 时，还需要检查 R =0，以避免被零除。这种情况下，线是水平的，因此没有零交叉。否则，如果 Q 不为零，则继续执行以下步骤来寻找 0、1 或 2 个实根。

为了找到当 Q ≠0 时二次曲线 p ( x )的根，我们使用熟悉的二次公式:

下一个特例是平方根R4QS是否为负。如果R4QS<0，则 p ( x )没有实根。当 p ( x )对于 x 的所有值总是为正或总是为负时，就会发生这种情况。因为抛物线从不穿过零点，所以您的求解器必须报告失败。

您必须在自己的应用中决定如何处理R4QS= 0 的情况。当平方根为零时，表示 p ( x )有一个切根，表示抛物线的顶点刚好接触横轴，但不穿过横轴，如下:

在我的天文学代码中，把这算作月出或月落是没有意义的。所以我选择将R—4QS≤0 视为失败。这种行为反映在下面的示例 Python 代码中。

如果你已经排除了上面提到的特例，现在你有两个候选值 x ，这要感谢二次公式中的运算符。您的代码应该检查这两个值，看看它们中的哪一个(如果有的话)在 1≤ x ≤+1 的范围内。超出此范围的任何值 x 都应该被丢弃，因为它超出了您指定的搜索间隔。即使您想使用这些异常值中的一个，抛物线也不能被认为是原始函数 f 在搜索区间之外很远的一个很好的近似。

在我的天文学用例中，我知道先验地我的搜索区间必须包含至多一个有效根。因此，如果 x 的两个值满足搜索间隔，我也会报告失败。

假设您最终得到了唯一的有效值 x ，最后一步是将 x 转换回您的独立变量 t :

现在你知道了。通过仅评估一个昂贵的函数三次，并且假设该函数在封闭区间内是充分抛物线的，我们现在有了一个很好的近似 t ，使得 f ( t )=0。

但是 t 有多准呢？这个问题没有简单的答案。您将不得不试验您自己的函数和区间大小来找出答案。

您可能会发现混合方法很有帮助:首先使用二分搜索法缩小足够小的区间(基于实验测试)，然后使用二次插值完成这项工作。我自己的算法(参见天文引擎的 Python 版本中的函数Search)使用了一种更复杂的混合算法，试图猜测二次插值的非常小的区间，这种算法在大多数时候都有效。当猜测不正确时，它退回到二分搜索法。在我的性能测试中，这与“纯”二分搜索法一样准确，但是计算时间只有 1/6。

Python 示例代码

以下是示例 Python 代码，演示了如何使用二次插值来寻找近似根。您可以随意使用函数QuadraticInterpolate作为自己应用程序的起点。

用于假新闻检测的自组织网络分析

原文：https://towardsdatascience.com/ego-network-analysis-for-the-detection-of-fake-news-da6b2dfc7c7e?source=collection_archive---------9-----------------------

结合网络分析和自然语言处理来确定推特上“假新闻”的来源

Twitter network of verified users with over 1 million followers. Circles (nodes) represent users and the lines connecting the circles represent one user “following” another. Colors represent classes determined through modularity clustering.

虽然“假新闻”在互联网时代之前就已经存在很久了，但今天似乎比以往任何时候都更难确定新闻来源的可靠性。在对这个话题做了一些研究后，我发现有人正在用图论做一些的工作，看看我们是否可以使用机器学习来帮助检测假新闻的来源。我对网络的力量和我们可以从中获得的信息非常感兴趣，所以我决定看看是否可以建立一个分类模型，在自我网络中找到模式，以检测假新闻。

什么是自我网络？

自我网络(在人类社会网络分析中也称为个人网络)由称为自我的焦点节点和与自我直接连接的称为 Alters 的节点组成，边显示自我与祭坛之间或祭坛之间的链接。自我网络中的每一个改变者都有自己的自我网络，所有的自我网络结合起来形成社会网络。在这样的网络中，自我可以是人，也可以是商业环境中的产品或服务。在下图中，我看到了所有 Twitter 认证用户的自我网络，这些用户拥有超过 100 万的追随者。每个圆圈代表一个经过验证的 twitter 用户节点(圆圈的大小与总粉丝数有关)，连接它们的线或边代表彼此“追随”的节点(感谢为我提供 Twitter 边列表的 Luca Hammer )。请务必查看他的媒体中关于探索和可视化网络数据的精彩帖子。这个图形可视化，以及您将在本文中看到的所有其他图形可视化，都是使用 Gephi 创建的。

出于这个项目的目的，我决定分析严格验证的 Twitter 网络，因为我觉得用户有一种自然的趋势，即更信任 Twitter 官方验证的来源。

训练数据问题:我如何决定哪些节点代表假新闻源？

在这个项目开始时，我面临的最大问题可能是如何确定哪些 Twitter 帐户被归类为我的训练数据的假新闻来源。没有一个普遍认可的方法来确定新闻是否是假新闻，如果有，它首先就不是一个问题。但是我必须从某个地方开始。幸运的是，我能够在 ICWSM 2015 年论文“cred bank:一个带有相关可信度注释的大规模社交媒体语料库”附带的 CREDBANK 数据中找到一个奇妙的数据集。如果你有时间，我强烈建议看看报纸，但这里有 TLDR:

总的来说，CREDBANK 由 6000 多万条推文组成，分为 1049 个现实世界的事件，每个事件都由 30 名亚马逊机械土耳其的工作人员进行注释以提高可信度(以及他们选择注释的理由)。CREDBANK 的主要贡献是编制了一个独特的数据集，以系统和全面的方式将社交媒体事件流与人类可信度判断联系起来

通过将这个数据集与 Twitter 网络数据相结合，我能够创建自己的数据集来训练分类模型。该数据包括 69，025 个经过验证的用户，以及他们之间的所有连接。在这些用户中，66，621 个被确定为真实新闻的来源，2，404 个被确定为虚假新闻的来源。我认为是假的消息来源是那些超过 5%的推文被亚马逊土耳其人可信度评级机构评为部分准确以下的人。

网络 EDA

This is the network graph of all sources in my dataset. Blue dots and lines represent NOT fake sources and red dots and lines represent fake sources.

Same graph as above, but with fake sources only

在收集和组织数据之后(我使用图形数据库 Neo4j 来存储网络数据)，第一步是对网络数据进行初步的探索性分析。在我最初的分析中，我使用了两种网络算法，特征向量中心性和 PageRank。特征向量中心性算法仅在数据样本上运行，因为在大型网络上计算中心性度量需要相当长的时间。

特征向量中心性是网络中节点影响力的度量。基于到高得分节点的连接比到低得分节点的同等连接对所讨论节点的得分贡献更大的概念，相对得分被分配给网络中的所有节点。高特征向量分数意味着一个节点连接到许多本身具有高分数的节点。

PageRank 被广泛认为是一种检测图中有影响力的节点的方法。它不同于其他中心性算法，因为一个节点的影响取决于其邻居的影响。

来源-https://github . com/neo4j-graph-analytics/graph-algorithms-notebooks

我使用 Python 库 NetworkX 的实现这些算法来确定上面显示的统计数据。

如您所见，尽管真实源的特征向量中心性度量的分布要大得多，但总体而言，虚假源和真实源的数字非常相似。我将不得不寻找一些其他的方法来区分这两种类型的节点。

通过鲁汶社区检测进行聚类

社区检测的 Louvain 方法是一种用于检测网络中的社区的算法。它最大化每个社区的模块性得分，其中模块性通过评估社区内的节点与它们在随机网络中的连接程度相比有多密集来量化节点到社区的分配的质量。

我决定在网络数据上运行这个算法，看看是否有假的来源被放在类似的类中。在下面的第一幅图中，我用每个节点被分配到的类的颜色来可视化网络图。第二张图片只包含假消息来源。

看起来绝大多数的假新闻来源被放在了紫绿类，很明显所有的假新闻来源主要位于网络图的一个区域。这确实很好地消除了 25838 个真实来源(通过这种聚类方法将 25838 个节点放在没有任何虚假来源的类中)，但仍然不足以完全隔离虚假新闻来源。为此，我不得不求助于 node2vec。

Node2Vec

根据斯坦福网络分析项目，node2vec 的创建者:

node2vec 框架通过优化邻域保持目标来学习图中节点的低维表示。目标是灵活的，并且该算法通过模拟有偏的随机行走来适应网络邻域的各种定义。具体来说，它提供了一种平衡探索-开发权衡的方法，这种权衡反过来又导致表示服从从同质到结构等价的等价谱。

基本上，node2vec 算法将使我能够在不止一个维度(具体来说，对于这个项目，是 128 个维度)上嵌入所有节点，作为为图上的节点位置设计新功能的一种方式。对于我的模型，我使用了算法的这个实现。

以下是我选择的参数:

不幸的是，即使为每个节点设计了这 128 个新特性，我最初建立分类模型的尝试也没有成功。由于大的类别不平衡(不到 4%的节点是假源)，我的算法总是预测所有的源是真实的。我需要一些其他的区别特征来帮助这些分类算法。

单词嵌入

node2vec 的想法实际上来自单词嵌入，这是一种矢量化策略，通过训练神经网络从文本语料库中计算单词向量，从而产生高维嵌入空间，其中语料库中的每个单词都是该空间中的唯一向量。在这个嵌入空间中，向量相对于其他向量的位置捕获语义。

我决定在递归神经网络中使用每个 Twitter 用户的档案描述进行分类。网络内部的嵌入层计算单词嵌入向量。这个神经网络的输出将是 Twitter 账户描述来自真实或虚假账户的概率。然后，我将结合 node2vec 的特征使用这些概率来构建最终的集成分类模型。以下是递归神经网络的细节:

Model Summary

最终分类模型

我使用 node2vec 的特征和神经网络的概率对支持向量机和 XGBoost 模型进行了网格搜索。由于高类别不平衡(预测所有“真实”将导致大约 96.5%的准确率)，我决定将我的搜索集中在具有高召回率和高准确率的模型上。

XGBoost 和 SVM 网格搜索结果

下图显示了我的 XGBoost 和 SVM 分类器的最佳参数，以及最终模型的混淆矩阵:

XGBoost

SVM

正如你在上面看到的，XGBoost 模型在精确度上表现稍好，而 SVM 模型在召回率上表现稍好。

结论

这些分类模型表现得相当好，尤其是考虑到大的类别不平衡。很明显，单词嵌入功能在模型检测真阳性的能力方面有很大的不同。虽然我想严格根据网络特征对节点进行分类，但可能不足以区分那些被分类为假的节点。然而，我确实认为网络分析在检测假新闻方面有很大的潜力。我遇到的一些问题只是与网络的巨大规模有关(正如我之前提到的，由于其规模，我无法计算整个网络的中心性度量)，并且在数据中肯定会发现更多的模式。

如果你想查看我的项目回购和我的全部分析，你可以在这里找到:https://github.com/briansrebrenik/Final_Project

使用的工具:

Neo4j 图形数据库
Gephi
斯坦福网络分析项目的 Node2Vec
Node2Vec 算法实现
网络 X
Keras
纸张空间渐变

数据来源:

来自 Credbank 的“假新闻”数据
推特网边缘来自卢卡·哈默

特征向量和特征值——你需要知道的一切

原文：https://towardsdatascience.com/eigenvectors-and-eigenvalues-all-you-need-to-know-df92780c591f?source=collection_archive---------1-----------------------

Image by joiom - https://pixabay.com/illustrations/seamless-pattern-background-seamless-1822616/

“Eigen”——词的起源

" Eigen "是一个德语单词，意思是“自己的”、“合适的”或“有特点的”。

什么是特征向量和特征值？

让我们看看维基百科对特征向量和特征值有什么说法:

如果 T 是从向量空间 V 经过域 F 到自身的线性变换并且 v 是 V 中不是零向量的向量，那么 v 是 T 的特征向量如果T(这个条件可以写成如下等式

T ( v ) = λ v

其中 λ 是 F 域中的标量，称为特征值、特征值，或者与特征向量 v 相关联的特征根。

看起来很困惑，对吧？我们先分解一下，了解什么是线性变换。

线性变换

假设 A 是一个 m×n 大小的矩阵。给定一个向量

那么 t 是从 R^n 到 R^m 的线性变换

这是怎么用的？假设您想要沿 x 轴将 2d 向量缩放 2 倍，沿 y 轴缩放 3 倍。假设向量 v 是[1，4]，那么在缩放之后它应该是[2，12]。这可以通过以下方式完成:

对于一个向量来说，这可能看起来微不足道。但是假设您有 n 个想要缩放的 2d 向量，您可以通过一次矩阵乘法操作一次转换所有这些向量。线性变换广泛应用于计算机图形学、游戏引擎、统计学等领域。

这种操作不仅仅限于缩放，我们还可以将线性变换矩阵用于翻转矢量、旋转矢量、剪切矢量等。如果你对这个话题感到不舒服，我推荐你看一下 3Blue1Brown 关于线性变换的教程。

回到特征向量和特征值

假设我们在 2d 空间中有一个正方形，正方形上的每个点都是一个向量，我将只使用 3 个向量，如下所示。

假设我们沿着 y 轴将正方形缩放 2 倍，如下所示

Scaling by a factor of 2 along y-axis

如果你注意到红色矢量在线性变换后具有相同的比例和方向。绿色矢量的比例发生变化，但方向仍然相同。而黄色向量既没有相同的比例，也增加了与 x 轴的角度，因此其方向也改变了。如果我们仔细观察，除了红色矢量和绿色矢量之外，其他所有矢量的方向都改变了。因此我们可以说红色和绿色向量是特殊的，它们是这个线性变换的特征 。这些向量被称为该线性变换的特征向量。并且它们由于变换而在尺度上的变化被称为它们的特征值**。其中对于红色矢量的特征值是 1，因为它的比例在变换前后是恒定的，而对于绿色矢量，它的特征值是 2，因为它放大了 2 倍。****

让我们看看另一个线性变换，我们沿着 x 轴剪切正方形。

Shear along x-axis

如果你猜红色向量是本征向量，你猜对了，它的本征值是 1。

如果我们顺时针旋转这个正方形 90 度。

Rotate by 90 degrees clockwise

这里没有特征向量(学术人士会认为这种情况下有复杂的特征向量，但这已经超出了本文的范围，所以为了简单起见，我们还是坚持没有特征向量的情况)。如果我们把正方形旋转 180 度，而不是 90 度。

Rotate by 180 degrees clockwise

这里所有的向量和三个彩色向量都是特征值为-1 的特征向量。

让我们来看一个特例，我们沿着 x 轴和 y 轴相等地缩放正方形。

Scaling equally along x and y axis

这里所有的向量都是特征向量，它们的特征值就是比例因子。

现在让我们回到维基百科对特征向量和特征值的定义:

如果 T 是从向量空间 V 经过域F 到自身的线性变换，并且 v 是 V 中不是零向量的向量，那么 v 是 T 的特征向量如果 T 这个条件可以写成如下等式

T ( v ) = λ v

其中 λ 是域 F 中的标量，称为与特征向量 v 相关联的特征值、特征值或特征根。

让我们看看这个等式是如何工作的，在第一种情况下，我们沿着 y 轴将一个正方形缩放了 2 倍，其中红色向量和绿色向量是特征向量。

Scaling by a factor of 2 along y axis

线性变换前:

线性变换后:

我们可以使用下面的等式显示线性变换后的结果:

让我们把这个问题扩大到三维。假设我们沿着 z 轴旋转一个立方体，那么沿着 z 轴的向量就是特征值为 1 的特征向量。

如果我们超过 3 维，就很难想象和计算出特征向量。即使在 2d 或 3d 中的某些情况下，也不是那么容易。那么我们如何计算特征向量呢？

我们知道对于任何特征向量 v，

假设变换矩阵是 a。因此，

从以上两个等式我们可以推断出，

将这些术语放在一起，

现在λ只是一个标量。因为 A 是一个矩阵，如果我们能把它转换成一个矩阵，我们就可以把 v 作为一个公式化。为此，我们可以将λ乘以单位矩阵 I。因此，

现在，对于右侧的 0，要么(A-λI)应该是 0，要么/和 v 应该是 0。但是如果你还记得特征向量的定义，它是非零向量。所以(A-λI)应该总是 0，v 才是特征向量。我们可以通过计算矩阵的行列式来计算矩阵运算是否为 0。

因此，

让我们用同样的例子来看看这是否可行，即沿着 y 轴将一个正方形缩放 2 倍。

这里，变换矩阵 A 可以表示为:

现在我们知道了，

输入 A 的值并进一步求解:

我们知道，

求解λ = 1，我们得到:

这意味着对于 v2=0 任何向量，该向量是特征值为 1 的特征向量。对于任何垂直矢量都是如此，在我们的例子中是红色矢量。

求解λ = 2，我们得到:

这意味着对于 v1=0 任何向量，该向量是特征值为 2 的特征向量。对于任何垂直矢量都是如此，在我们的例子中就是绿色矢量。

特征向量的重要性

特征值在数学中如此重要的原因太多了。以下是我现在想到的一些应用:

主成分分析在降维和目标/图像识别中的应用。(参见 PCA
通过计算图像的特征向量进行人脸识别(见特征脸)。
物理学——稳定性分析，旋转体的物理学(见稳定性理论)。
谷歌用它来为你的搜索结果排名页面(见 PageRank )。

实际的失误

华盛顿州的塔科马海峡大桥在建造了 4 个月后于 1940 年倒塌。这被拍成电影，后来被戏称为“盖尔平”。

它的崩溃可以用特征值来解释。在许多大学物理教科书中，该事件被描述为基本强迫共振的例子，风提供了与自然结构频率相匹配的外部周期频率，即使桥梁故障的真正原因是气动弹性颤振，而不是共振。不要进入辩论，坚持这个博客的目的是解释特征向量和特征值，这个自然频率可以用最小幅度的特征值来表征。

我希望你现在理解了特征向量和特征值背后的理论。如果你想获得更多关于特征向量的直觉，我推荐这个视频教程

图像的弹性变形

原文：https://towardsdatascience.com/elastic-deformation-on-images-b00c21327372?source=collection_archive---------16-----------------------

当前技术发展如此之快，我们的处理能力比以往任何时候都强。我们现在能够保存大量的数据，并对它们进行处理以获得相关信息。然而，即使我们有强大的硬件基础设施，如果我们没有足够的数据来训练我们的算法，我们也无法取得令人满意的结果。数据是 ML 和 DL 问题中最重要的部分。如果我们没有庞大的数据集，这些领域的所有快速发展都是不可能的。

大多数情况下，我们无法找到大量不同的数据类型，我们需要从现有的数据集创建新的数据集。为此，我们可以应用几种技术和算法。今天，我将主要关注图像数据集。图像用于物体检测、图像分类等几个问题。我们需要训练我们的模型同一对象类型的许多不同版本，以便为将来的目的快速确定它。然而，我们可能没有足够的数据集，这是大多数问题的瓶颈。

为了解决这个问题，我发现了一个非常棒的 Python 库。它被称为“增强器”。它有许多不同的技术来从数据集生成新的图像。Augmentor 真的很快，它每秒可以创建大约 100 张图像。它能自动增强图像。我用 Augmentor 用几种技术来创建手绘的条形图。首先，您可以通过以下方式快速安装 Augmentor

pip install Augmentor

之后，您需要将它添加到您的项目中，并创建一个管道。流水线只是图像操作的一系列操作。

import Augmentor
p = Augmentor.Pipeline('./pathToImages')

一旦实例化了管道对象，就可以向其中添加操作。你可以在这里找到增强器文档。操作示例有:

p.rotate(probability=0.7, max_left_rotation=10, max_right_rotation=10) 
p.zoom(probability=0.5, min_factor=1.1, max_factor=1.5)

每个操作都有一个概率值，用于指定一旦图像通过管道，应用该操作的可能性有多大。

如果您想随机应用类似鱼眼的操作，并且不想旋转或缩放以保留一些图像特征，我会推荐这样的管道:

p.random_distortion(probability=1, grid_width=3, grid_height=3, magnitude=5)
p.gaussian_distortion(probability=1, grid_width=3, grid_height=3, magnitude=5, corner='bell', method='in')

我将把这条管道应用到我的数据集中。下面是我的数据集中的一个例子:

它创建了惊人的图像数据集。当我将示例结果应用于反色 Python 绘图时，我会分享它们。

管道准备就绪后，您可以通过以下方式调用来创建数据集:

p.sample(10000)

简单地说，它使用您的数据集创建随机增强的 10.000 图像样本，并扩展您的限制。默认情况下，它们存储在目录的输出文件夹中，但是您可以在实例化管道对象时更改它。如果您只想处理一次图像以对数据集应用操作，则可以调用:

p.process()

你可以用它来裁剪或调整你的图像，为此你还需要给你的操作赋予概率 1。

Augmentor 还提供了许多不同的其他操作。您可以对图像应用几何和透视变换。但是，这些转换可能会导致图像上的信息丢失，如下图所示。

p.shear(0.5, 10, 10)  #Size Preserving Shearing
p.skew_tilt(0.5, magnitude=0.2) #Perspective Transforms

在这些例子中，我也使用随机删除角，因为大多数时候人们不会在绘图中画出完美的形状，而边缘在真实的绘图中也不会出现。为了实现这个想法，您可以使用一个简单的函数，如；

def remove_corners(image):
    img=cv2.imread(image,0)
    corners = cv2.goodFeaturesToTrack(img, 100, 0.01, 10)
    corners = np.int0(corners)

    for corner in corners:
        n = random.randint(1,4)
        if(n != 3):
            x,y = corner.ravel()
            cv2.circle(img,(x,y),3,255,-1)
    return img

我将此功能应用于文件夹中的图片。顶部的图像是源数据集，下面是应用了“移除角点”功能的图像。

OpenCV 很容易做到这一点。它读取图像，找到图像内部的角点，并对它们进行着色，以消除它们。我添加了简单的概率方法来从均匀分布中确定 75%的角点，并移除它们以向我们的数据集添加一些随机方法。

Elasticsearch 遇见 BERT:用 Elasticsearch 和 BERT 构建搜索引擎

原文：https://towardsdatascience.com/elasticsearch-meets-bert-building-search-engine-with-elasticsearch-and-bert-9e74bf5b4cf2?source=collection_archive---------7-----------------------

在这篇文章中，我们使用一个预先训练好的 BERT 模型和 Elasticsearch 来构建一个搜索引擎。Elasticsearch 最近发布了带矢量场的文本相似度搜索。另一方面，您可以使用 BERT 将文本转换成固定长度的向量。所以一旦我们用 BERT 把文档转换成向量，存入 Elasticsearch，就可以用 Elasticsearch 和 BERT 搜索相似的文档。

本文通过以下架构实现了一个包含 Elasticsearch 和 BERT 的搜索引擎。这里我们用 Docker 把整个系统分为三个部分:应用、BERT、Elasticsearch。目的是使每项服务更容易扩展。

System Architecture

我在这篇文章中只展示了重要的部分，但是整个系统都是在下面的 GitHub 库中用docker-compose.yaml编写的。请查看存储库:

https://github.com/Hironsan/bertsearch

这个职位的计划是:

下载预先训练好的 BERT 模型
设置环境变量
下水码头集装箱
创建弹性搜索索引
创建文档
索引文件

1.下载预先训练好的 BERT 模型

首先，下载一个预先训练好的 BERT 模型。以下命令是下载英语模型的示例:

$ wget [https://storage.googleapis.com/bert_models/2018_10_18/cased_L-12_H-768_A-12.zip](https://storage.googleapis.com/bert_models/2018_10_18/cased_L-12_H-768_A-12.zip)
$ unzip cased_L-12_H-768_A-12.zip

2.设置环境变量

你需要设置一个预先训练好的 BERT 模型和 Elasticsearch 的索引名作为环境变量。这些变量在 Docker 容器中使用。下面是一个将 jobsearch 指定为索引名和的示例。/cased_L-12_H-768_A-12 作为模型的路径:

$ export PATH_MODEL=./cased_L-12_H-768_A-12
$ export INDEX_NAME=jobsearch

3.启动码头集装箱

现在，让我们使用 Docker compose 启动 Docker 容器。这里要启动三个容器:应用程序容器、BERT 容器和 Elasticsearch 容器。查看 docker-compose.yaml 了解更多详情。

$ docker-compose up

注意，我建议你应该给 Docker 分配更多的内存(8GB 以上)。因为 BERT 容器需要大内存。

4.创建弹性搜索索引

您可以使用 create index API 向 Elasticsearch 集群添加新的索引。创建索引时，可以指定以下内容:

索引的设置
索引中字段的映射
索引别名

例如，如果您想要创建带有title、text和text_vector字段的jobsearch索引，您可以通过以下命令创建该索引:

$ python example/create_index.py --index_file=example/index.json --index_name=jobsearch
# index.json
{
  "settings": {
    "number_of_shards": 2,
    "number_of_replicas": 1
  },
  "mappings": {
    "dynamic": "true",
    "_source": {
      "enabled": "true"
    },
    "properties": {
      "title": {
        "type": "text"
      },
      "text": {
        "type": "text"
      },
      "text_vector": {
        "type": "dense_vector",
        "dims": 768
      }
    }
  }
}

注意:text_vector的dims值必须与预训练的 BERT 模型的 dims 相匹配。

5.创建文档

一旦创建了索引，就可以为一些文档编制索引了。这里的要点是使用 BERT 将文档转换成矢量。产生的矢量存储在text_vector字段中。让我们将您的数据转换成一个 JSON 文档:

$ python example/create_documents.py --data=example/example.csv --index_name=jobsearch
# example/example.csv
"Title","Description"
"Saleswoman","lorem ipsum"
"Software Developer","lorem ipsum"
"Chief Financial Officer","lorem ipsum"
"General Manager","lorem ipsum"
"Network Administrator","lorem ipsum"

完成脚本后，您可以获得如下所示的 JSON 文档:

# documents.jsonl
{"_op_type": "index", "_index": "jobsearch", "text": "lorem ipsum", "title": "Saleswoman", "text_vector": [...]}
{"_op_type": "index", "_index": "jobsearch", "text": "lorem ipsum", "title": "Software Developer", "text_vector": [...]}
{"_op_type": "index", "_index": "jobsearch", "text": "lorem ipsum", "title": "Chief Financial Officer", "text_vector": [...]}
...

6.索引文档

将数据转换成 JSON 后，可以将 JSON 文档添加到指定的索引中，并使其可搜索。

$ python example/index_documents.py

7.打开浏览器

去 http://127.0.0.1:5000 。下面是一个求职的例子。你可以看到“我在找律师”查询返回类似“法律助理”和“律师”的工作。

结论

在这篇文章中，我们用 Elasticsearch 和 BERT 实现了搜索引擎。虽然 BERT 的执行速度有问题，但是像这种架构一样把 BERT 当成一个独立的容器，很容易伸缩，所以我认为问题是可以解决的。希望这篇文章对你有用。

https://github.com/Hironsan/bertsearch

对一些可疑统计数据的天真解释；大选数据探索。(第一部分)

原文：https://towardsdatascience.com/election-data-exploration-israel-2019-general-election-cd3c2b0f2f05?source=collection_archive---------26-----------------------

放眼 2019 年以色列大选。当然，有些结果看起来很奇怪，但是有证据证明确实存在渎职行为，或者有更简单的解释吗？

我最喜欢的统计学类比(Cassie Kozyrkov 所做的)是对英美法律体系的类比。
【无效假设】被推定无罪(导致无罪释放)，而对其的拒绝只能是因为提出了“排除合理怀疑”的有罪证据。“我们选择的 P 值是超出合理怀疑的水平。(视所涉问题而有所不同)

你的故事始于社交媒体上的一个帖子。在一个特定的投票站，下面的“异常”正在流传。
所有政党都得到了“非常整数”的选票

这些看起来确实很可疑。好了，我们开始吧。

TL；博士和免责声明

在这个多部分系列中，在某些情况下，我将能够对 表面上可疑的结果 给出简单、无辜的数学解释。在其他情况下我不会。注意，投票箱有一万多个，所以 即使是罕见的数值异常，预计 也会出现几次。

入门指南

我开始寻找其他异常。也许整数太明显了，但是一个政党获得三分之一选票的几率有多大呢？一半？

直方图时间

True Data: Here is a histogram of the vote fraction of a specific party in all polling stations; Note the most common values are reduced small rationals: 1/2, 1/3, 3/7, 1/4, 2/5, 1/5, 4/9. weird, right?

谋杀吗？！？我们“抓到他们”了吗？

在我回答之前，你能不能想出一个解释来解释为什么恰好 1/2 这么受欢迎？[花一分钟时间]

[节拍]

好吧，小有理分式有更多的优势。300 个中有 100 个，303 个中有 101 个，这样就可以得到正好是的 1/3。但是要得到 200/601，你必须有一个非常具体的选票统计，和一个非常具体的政党的选票统计。所以这些价值观并不常见。这足以解释这件怪事吗？下面是一个简单模型的结果(我们随机选择投票站的总票数，以及特定政党的总票数，给定该政党的全国总票数)

The small rationals making an appearance again, even in a random model. (described in appendix B)

无损直方图

那么，现在我们对数据中的这些有理数有了一个简单的解释，那么看待我们的数据有什么好的方法呢？如果我们让直方图从一开始就做它想做的事情，即绑定数据，会怎么样？如果我们取 100 个箱，我们可以看到箱 50 是否比箱 51 或 49 更有可能，从而做出判断。

Binning makes the rational anomalies disappear.

看起来我们没有足够的证据定罪。在零假设为真(没有捏造)的世界里，提出的证据实际上相当合理，一点也不令人惊讶。这并不是说没有一个计票结果被捏造并被设定为某个特定政党的 1/2 选票的情况，这只是而不是看起来的阴谋(几十个投票站同意相同的比例。)

接下来

这篇文章将是系列文章的第一篇。在接下来的几周里，我将探索其他异常现象。
我将重温引发这一切的异常现象，并探索政党之间一些怪异的理性关系。(即一方获得另一方的 1/2 或两倍)

如果你注意到其他一些奇怪的线，你想让我看看，评论，我会看看。

准备好

激起你对这一排选票的兴趣(来自一个投票站)。
注意重复出现的理性关系。例如25–25–75–150；27–135它还有数字 21，23，24，25，25，26，27 。可疑，当然。有罪？

Is that weird enough to be suspect or just a coincidence? find out next week.

附录 A —加载数据的代码。

每个投票站的计票结果都在这里https://media21.bechirot.gov.il/files/expb.csv

这里有一些样本 python，用于加载该文件(11K 行)，并将列重命名为 English，这样您可以自己查看，并发现一些更可疑的结果。
还包括生成上述直方图的代码。

* [## 谷歌联合实验室

编辑描述

colab.research.google.com](https://colab.research.google.com/gist/avishalom/e89aca0c1a852cc548db0d35a5c9ea8e/load-election-data.ipynb)

附录 B 简化模型

拟合每个投票站的有效投票数的正态分布(以 400 为中心，sigma=100，忽略 800 处的峰值)

以及给定国家党分数的每个党的票数的泊松分布，从与该党每次投票的国家投票分数相匹配的分布中选取λ。

我知道这有点过于简单，例如，PCA 解释不同城市不同政党的投票趋势会更好。但是现在这已经足够好了，它为所有那些小的有理数提供了一个可行的理由。*

用 Python 实现选举投票模拟、误差幅度和中心极限定理

原文：https://towardsdatascience.com/election-poll-simulation-margin-of-error-and-central-limit-theorem-with-python-43f96909a4c6?source=collection_archive---------10-----------------------

在学习中心极限定理(CLT)时，我错过了一些更基本的东西，比如一些显示样本大小如何影响该定理所告诉的结果的图表，它与选举投票等概念的关系以及一些相关代码。有很多很好的文章解释了什么是 CLT，为什么它很重要，以及它背后的数学原理，下面是我找到的一些很好的链接:

理解中心极限定理
一个小样本能告诉我们大量人口的什么情况？—第一部分
中心极限定理—维基百科
可汗学院统计课程视频

在本文中，我更侧重于模拟选举投票，使用可变大小的样本，并将其作为中心极限定理的材料。在这篇文章的最后，你应该了解一些:

如何使用 Python 生成随机样本和简单图形；
什么是中心极限定理；
选举投票的人数如何影响其结果和对结果的信心；
如何选择样本的大小，以使您的投票或测试具有预期的误差幅度和置信度。

为了更好地使用本文，您还应该熟悉正态分布和 Z 检验，因为我们将使用它来分析我们的选举投票结果，并支持中心极限定理。

这里是 Kaggle 上这篇文章所用代码的链接。

模拟选举投票

注意:这段代码更侧重于演示而不是性能，有其他更快的方法来模拟这一点。

假设我们将在两个候选人 Alice 和 Bob 之间进行总统选举，并且我们想要尝试预测谁将是获胜者。假设有一个方法，如果一个人对 Alice 投票，则返回 1，否则返回 0。注意，我使用了二项式分布生成器来创建伯努利随机变量:

This function should return 0 or 1 according to a Bernoulli Distribution with Mean = 0.53. It is like a biased coin simulation.

如果我们能问世界上所有的人他们会投票给谁，我们就能发现获胜者和全体人口投票背后的分布。然而，这通常是不可能的，所以我们做选举民意调查，询问一小群人的意见，试图估计真实的人口结果。比方说，对于每一个不同的日子，我们能够从 n 个人那里获得投票选项:

This method could have an output with a list like this one: [1, 0, 0, 0, 0, 1, 1, 0, 1, 0]

然后假设，在 5 天的时间间隔内，我们每天采访 100 个人，询问他们的候选人是谁。这样，我们将有 5 个相同分布的不同样本，每个样本的大小为 100。由于读取一组 500 个元素并不简单，我将显示每天的平均值:

In my case I got this output [0.51, 0.48, 0.45, 0.51, 0.54], could we say that Alice would win with only those samples?

现在想象一下，我们有无限的金钱和时间，所以我们可以在 5 天、50 天、500 天、1000 天、10000 天和 100000 天做同样的事情。让我们看看使用直方图来总结结果会发生什么:

Result of the previous embedded code section

对于仅仅 5 天，直方图没有太大帮助，但是随着我们增加天数(样本)，我们可以开始看到一个钟形分布。

随着天数的增加，直方图应该开始变得越来越呈钟形，均值越来越接近人群的真实均值，这是一种直觉，因为大多数日子的样本均值应该与其原始分布相似。然而，正如您所看到的，我们不需要无限长的时间来猜测谁会在这种情况下获胜。

我之前提到的“直觉”可以用中心极限定理(CLT)来解释。据维基百科:

中心极限定理(CLT)证明，在某些情况下，当添加独立的随机变量时，即使原始变量本身不是正态分布的，它们的正态和也趋向于正态分布(非正式的“钟形曲线”)。该定理是概率论中的一个关键概念，因为它意味着适用于正态分布的概率和统计方法可以适用于许多涉及其他类型分布的问题。

有很多文章解释了这个定理的数学背景及其结果，但是现在我想把重点放在这个定理在我们的选举投票例子中的实际应用上。

对我们来说，这个定理的重要结论是如果你从任何概率分布中得到多个样本，这些样本的均值集合趋向于正态分布。这样，我们就有了一个数学背景来假设任何采样结果都遵循正态分布。

现在你应该问“然后呢？”。对于任何给定的正态分布，如果我们知道它的均值和方差，我们可以找到一个大小为 2Y 的值的区间，随机变量可能以 C%的概率假设该区间。例如，回到我们的选举投票，我们可以发现 Alice 会有 X%的选票，误差为 Y%,对我们的结果有 C%的信心。因此，如果我执行选举投票 100 次，C%100 次，Alice 将以 X%的选票加上 Y%的误差幅度获胜。

让我们用一个有趣的公式来应用这些概念，这个公式是从中心极限定理推导出来的，用来求这些值。它让我们使用样本的平均值(s 条)和样本的大小(n)来估计真实总体平均值的标准差(σ):

当与真实总体平均值比较时，估计的标准偏差σ与我们估计的误差成比例。这样，理想的情况是σ为零。实现这一点的一个方法是增加样本量。在下面的直方图中，我将模拟多次投票，保持样本数量不变(100)，但增加样本大小 n，这与我在之前的直方图中所做的不同:

Result of the previous embedded code section

请注意，随着样本量的增加，x 轴间隔变得越来越小，条形越来越接近平均值，这表明我们获得了更精确的结果。在现实生活中，我们无法获得这样大小的样本，但是，由于中心定理的限制，我们可以计算任何大小为 n 的样本的误差幅度，检查其显著性，如果幅度对我们来说不够大，就增加 n 值。

为此，我们需要像处理正态分布一样处理数据。我们使用估计的标准偏差来应用 z 检验，找到满足我们期望的误差范围和期望的置信度的值的区间。回到第一天，从我的 100 人样本中，我可以说 Alice 将赢得 95%信心的误差幅度是多少？

得到这些值后，我们可以查阅标准的正态表，看看有多少标准差满足期望的置信度。基于这个规则，我们知道两个标准差的间隔应该覆盖 95%的情况。

基于 z 测试的误差范围测试步骤:

获取样本；
计算样本均值和样本标准差；
利用中心极限定理求其与总体真实均值的估计标准差；
使用一个标准的正态表或者这个规则来知道我们的区间应该包含多少标准差来满足我们期望的置信度；
因为我们想要 95%的置信度，我们需要 2 个标准差。

下面是对我们的选举投票方法执行 z 测试的方法:

Method to get the mean with some margin of error from our election poll simulation. For example, I got this output when I executed it in my machine: {‘error’: 0.09981983770774223, ‘mean’: 0.53}

如果当 n =100 时，您从最后一次代码执行中获得错误值，您会注意到它相当大(几乎 10%)，所以这对我们没有太大帮助，因为我们将有一个介于 43%和 63%之间的区间。

如果你还记得估算总体真实均值的标准差的公式，你会注意到，当我们增加 n 时，我们减少了标准差。所以，这解释了为什么越来越多的人参与投票会给我们带来更精确的结果。让我们分析一下在选举投票场景中增加样本量的影响:

Result of the previous embedded code section

在样本量为 10 的情况下，我们有几乎 30%的误差( ergh ！)，然后有 100 个人时，我们有 10%，我们开始从只有 1000 个人时得到好的值(3%)。当样本量大于或等于 1000 时，样本均值也稳定在 0.53 左右。

这是一个很好的结果，因为我们也可以使用一些预先计算的表格，如这个来发现我们应该使用哪个样本大小来获得所需的误差幅度，请注意，这些值几乎与我们在之前的图表中获得的值相同。

最后，我们可以说，如果我们以 95%的置信度对 10000 人进行民意调查，Alice 将以 53%的选票获胜，误差幅度为+-1%。让我们用我们的方法来检查这个结果:

This method call returned: {‘error’: 0.009978328316907597, ‘mean’: 0.5329} which is what I said on the previous paragraph, yay!

CLT 之后呢？

现在，您已经了解了如何衡量您的投票、控制样本大小以及讨论其结果。这一知识的一个有趣的应用是进行零假设检验(你可以在许多学术研究和 cia 中找到的那个著名的 p 值的来源)。

查看汗学院的视频，了解如何对一个问题进行零假设检验，以检查一种新药是否真的有效。

也请让我知道你对这个故事的想法，如果文本有错误，请发评论，或者如果你喜欢阅读，请点击鼓掌按钮。再见！

Python 中函数式编程的要素

原文：https://towardsdatascience.com/elements-of-functional-programming-in-python-1b295ea5bbe0?source=collection_archive---------0-----------------------

了解如何使用 Python 中的 lambda、map、filter 和 reduce 函数来转换数据结构。

Photo by Markus Spiske on Unsplash

“面向对象编程通过封装活动部分使代码可以理解。函数式编程通过最大限度地减少活动部分，让代码变得可以理解。”:迈克尔·费哲

世界上有多种编程语言，它们可以被分类的类别也是如此。一个编程范例就是这样一种方式，它试图根据编程语言的特性或编码风格对它们进行分类。编程范式本质上是一种编程风格或方式。

大多数时候，我们将 Python 理解为一种面向对象的语言，其中我们以类、对象和方法的形式对数据建模。然而，面向对象编程也有几种替代方案，函数式编程就是其中之一。

以下是业界流行的一些传统编程范例:

Conventional programming paradigms: Content Source Wikipedia

函数式编程

The Functional Programming Paradigm

根据维基百科， 函数式编程 是一种编程范式，一种构建计算机程序的结构和元素的风格，它将计算视为数学 函数避免改变状态和可变

上述定义起初听起来可能令人困惑，但它本质上试图提出以下几个方面:

FP 依赖于函数，一切都是用函数来完成的。此外，FP 关注于定义做什么，而不是执行一些动作。该范例的功能被视为一级功能。这意味着函数被像其他对象一样对待，我们可以将它们赋给变量或者传递给其他函数。
函数式编程中使用的数据必须是不可变的，即永远不应该改变。这意味着如果我们需要修改列表中的数据，我们需要用更新的值创建一个新的列表，而不是操作现有的列表。
用 FP 写的程序应该是无状态。无状态函数不知道它的过去。功能程序应该像第一次执行任务一样执行每一项任务。简单地说，函数只依赖于作为参数传递给它们的数据，而不依赖于外部数据。
懒惰是 FP 的另一个特性，我们不会计算我们不需要的东西。工作只在需要时做。

如果这有意义的话，这里有一个 OOP 和 FP 之间的比较图表，它会让事情变得更加明显。

Original Image: www.educba.com**

Python 提供了 lambda、filter、map 和 reduce 等特性，可以很容易地演示函数式编程的概念。本文中使用的所有代码都可以从相关的 Github 库中获得，或者可以通过点击下图在 my_binder 上查看。

λ表达式

****Lambda 表达式——也称为“匿名函数”——允许我们在一行中创建和使用一个函数。当我们需要一个只使用一次的短函数时，它们很有用。它们通常与 map、filter 和 sort 方法结合使用，我们将在本文后面看到这些方法。

让我们用 Python 写一个函数，计算5x + 2的值。标准方法是定义一个函数。

现在让我们使用 Lambda 函数来计算相同的表达式。为了创建一个 lambda 表达式，我们键入关键字 lambda，后面跟着输入。接下来，我们输入一个冒号，后跟将作为返回值的表达式。

这个 lambda 函数将接受输入 x 并返回5x + 2，就像前面的函数f一样。然而，有一个问题。Lambda 不是函数的名称。这是一个 Python 关键字，说明后面是一个匿名函数。那么我们如何使用它呢？一种方法是给它一个名字。

让我们称这个λ表达式为g。现在，我们可以像使用其他函数一样使用它。

具有多个输入的 Lambda 表达式。

下面的例子展示了 lambda 函数如何在有或没有输入值的情况下使用。

没有输入的 Lambda 表达式。

现在，让我们看看 Lambda 函数的一个常见用法，我们没有给它命名。假设我们有一个美国前七任总统的列表，我们希望按照他们的姓氏对这个列表进行排序。我们将创建一个 Lambda 函数来提取姓氏，并将其用作排序值。

map、filter 和 reduce 函数简化了使用列表的工作。当与 lambda 表达式一起使用时，它们通过在一行代码中完成大量工作，使我们的生活变得更加轻松。

地图功能

map 函数将函数应用于 iterable 的每一项，产生结果。当与列表一起使用时，Map通过将函数应用于 input_list 中的所有项目，将给定的列表转换成新的列表。

句法

**map(function_to_apply, iterables)**

使用

假设我们有一个计算立方体体积的函数，给定其边(a)的值。

**def volume(a):
    """volumne of a cube with edge 'a'"""
    return a**3**

如果我们需要计算许多不同边长的立方体的体积，该怎么办？

**# Edge length in cm
edges = [1,2,3,4,5]**

有两种方法可以做到这一点——一种是使用直接方法，另一种是使用映射函数。

现在让我们看看如何使用一行带有 map 函数的代码来完成这项任务。

map 函数接受两个参数。第一个是函数，第二个是我们的列表、元组或任何其他可迭代的对象。这里，map 函数将音量函数应用于列表中的每个元素。

这里需要注意的一点是，map 函数的输出不是一个列表，而是一个 map 对象，它是结果的迭代器。但是，我们可以通过将映射传递给 list 构造函数，将它转换成一个列表。

例子

现在让我们来看一个例子，它演示了如何使用lambda函数和map函数。我们有一个包含五个人的姓名和身高的元组列表。每个高度都是厘米，我们需要把它转换成英尺。

我们将首先使用 lambda 表达式编写一个转换器函数，它将接受一个元组作为输入，也将返回一个元组。

过滤功能

' filter' 函数从那些 iterable 的元素中构造一个迭代器，对于这些元素函数返回 true。这意味着 filter 函数用于从列表、元组或其他数据集合中选择某些数据，因此得名。

句法

**filter(function, iterable)**

使用

让我们看一个例子，我们想从一个给定的输入列表中获得所有大于 5 的数字的列表。

我们首先创建一个 lambda 函数来测试输入，看它是否大于 5。接下来，我们传入数据列表。filter 函数将只返回函数为真的数据。同样，返回值不是一个列表，而是一个过滤器对象。这个对象必须被传递给一个列表构造函数来获得输出。

例子

当数据包含缺失值时，会出现一个有趣的“filter”函数用例。这是一个包含一些亚洲国家的列表。请注意，许多字符串是空的。我们将使用过滤函数来删除这些丢失的值。我们将传递 none 作为第一个参数，第二个参数是之前的数据列表。

这将过滤掉在布尔设置中被视为 false 的所有值。

Reduce 函数

' r educe 函数有点不寻常，从 Python 3 开始，它不再是一个内置函数。相反，它被移到了functools 模块。“reduce”函数通过从左到右对序列的项目累积应用一个函数，将给定列表转换为单个值，

句法

**reduce(func, seq)**

其中 reduce 不断地将函数func()应用于序列 seq 并返回一个值。

使用

让我们借助一个简单的例子来说明reduce函数的工作原理，这个例子计算一组整数的乘积。

下图显示了计算的中间步骤:

Source: Working of ‘Reduce’ function in Python

然而，Python 的创始人吉多·范·罗苏姆不得不这样评价“reduce”函数:

如果真的需要就用 functools.reduce 然而，在 99%的情况下，显式 for 循环更具可读性。

上述程序也可以用显式 for 循环来编写:

例子

“reduce”函数可以在一行代码中确定包含整数的列表的最大值。Python 中确实有一个名为max()的内置函数，它通常被用作max(list_name)。

列表理解:映射、过滤和归约的替代

列表理解是一种在 Python 中定义和创建列表的方法。在大多数情况下，列表理解让我们在一行代码中创建列表，而不用担心初始化列表或设置循环。

它也是 lambda 函数以及 map()、filter()和 reduce()函数的替代品。有些人认为这是编写函数的一种更为复杂的方式，也更容易理解。

句法

****

使用

让我们试着用list comprehensions.复制上面章节中使用的例子

列表理解与地图功能

我们将 map 函数与 lambda 函数结合使用，将高度列表从厘米转换为英尺。让我们用列表理解来达到同样的结果。

列表理解与过滤功能

我们使用了 filter 函数来删除亚洲国家列表中缺少的值。让我们用列表理解来得到同样的结果。

列表综合与归约功能

同样，我们可以用列表理解快速确定包含整数的列表的最大值，而不是使用 lambda 和 reduce。

我们在上面使用了一个生成器表达式，它类似于列表理解，但是用圆括号代替了方括号。

列表理解是一个多样化的主题，需要一篇自己的文章。记住这一点，这里有一篇我写的文章，它不仅涵盖了 python 中的列表理解，甚至还涵盖了字典、集合和生成器理解。

** [## 理解 Python 中的“理解”

理解和实现 python 中的列表、字典、集合和生成器。

towardsdatascience.com](/comprehending-the-concept-of-comprehensions-in-python-c9dafce5111)**

结论

map、filter 和 reduce 函数极大地简化了使用列表和其他可迭代数据集合的过程。有些人对使用它们有所保留，特别是因为列表理解似乎更友好，然而它们的有用性不能被忽视。

参考

不要害怕函数式编程
函数式编程 HOWTO
λ，滤波，缩小，贴图

强化学习中的资格痕迹

原文：https://towardsdatascience.com/eligibility-traces-in-reinforcement-learning-a6b458c019d6?source=collection_archive---------5-----------------------

有时候向后看并没有那么糟糕

Photo by Didier Provost on Unsplash

更新:学习和练习强化学习的最好方式是去 http://rl-lab.com

什么是资格痕迹？

简而言之，合格轨迹是一种数学技巧，可以提高强化学习中时间差方法的性能。

资格跟踪的好处如下:

提供一种以在线方式(不要等待剧集结束)和在没有剧集的问题上实现蒙特卡罗的方法。
提供一种使用短期记忆向量的算法机制。
通过存储单个向量 存储器而不是特征向量列表来提高计算效率。
学习是不断进行的，而不是在一集结束时等待结果。

前瞻性的观点

请记住，在中，时间差和蒙特卡罗方法基于未来奖励更新状态。这可以通过直接向前看一步或者等待一集结束来实现。

这种方法被称为前瞻。

In Forward View we look ahead n steps for future rewards

在 TD(0)中，我们向前看一步，而在蒙特卡洛中，我们向前看，直到这一集结束，我们收集贴现结果。然而，有一个中间地带，我们向前看 n 步。

n 步前瞻视图

正如上一节所解释的，展望未来可能会有所不同，从向前一步到一集结束，就像蒙特卡洛的情况一样。因此，n 步是某种中间地带。
请记住，在蒙特卡洛中，我们执行剧集，获取它们的回报 G i 并对这些回报进行平均，以计算状态值。
请注意，每集的长度(步数)可能会因集而异。它不是常数！

类似地，我们将对 n 步前瞻进行同样的操作。就像在蒙特卡洛一样，每集的步数不一定相同。
NB。在本节中，我们不再将一个情节称为必须通过达到终止状态而终止的多个步骤，而是简单地称为多个步骤(终止状态不再是一个要求)。

因此，让我们定义所有这些迭代的平均回报，如下所示:

其中 G( 𝛌，t)是所有收益 G(t，t+n)的加权平均值，g(t，t+n)是单个剧集的收益，其中每集从 t 开始，到 t+n 结束，n 从 1 到无穷大。𝛌是一个值在[0，1]之间的权重。
在所有加权平均中，权重之和必须为 1，这是因为

重要备注:很容易注意到，对于 n 较大的剧集，𝛌对 n 次方的贡献变小，G(t+n)的贡献也会很小。
但是嘿！我们已经知道，通过使用收益定义中的贴现因子γ(ɣ):

但是请记住，这是一个不同的问题，例如在蒙特卡洛，V(s)是从已经播放的剧集中计算出的所有回报 Gi 的平均值。所有的地理标志对 V(s)的贡献是相等的，即使奖励会根据它们与州 s 的距离而打折扣。

在这里，问题是不同的，所有 Gi 对 V(s)的贡献并不相同，但是它们是加权的，并且每个权重随着每集内的步数而变小。

下图显示了每集如何根据长度进行加权。

这张照片显示了重量如何随着时间(或 n 步)的增加而变小。

简而言之，如果一个情节在 3 步之后终止，与其回报相关联的权重远远大于在 T 步处终止的情节(其中 T 远大于 3)。
同样重要的是注意到重量呈指数下降。

让我们重写当剧集在时间 T 终止时的返回。
注意，时间步长 T 之后的返回总是 Gt(这是时间步长 T 时的返回),这仅仅是因为不再有状态，并且最后看到的返回是在 T。

当𝛌为 0 时，Gt 的表达式显示的是 TD(0)的公式(注意这个上下文中的 0 到幂零按照惯例是 1，更多信息见这个维基百科文章)，当𝛌为 1 时，Gt 就变成了蒙特卡洛的公式。

问题还没有解决！

所有这些细节，但我们仍然没有解决问题…

因为每个状态的更新依赖于当前不可用的后来的事件或奖励，所以前瞻视图实现起来有些复杂。

但到目前为止，我们一直在这么做！
我们正在向前看 n 步…
然而，这将通过采用一种新的方法来改变:向后看。

后视 TD( 𝛌)

假设一个代理人在一个环境中随机行走，发现了一个宝藏。然后他停下来向后看，试图知道是什么让他找到了这个宝藏？自然，靠近宝藏的台阶比远离宝藏的台阶更有价值。因此，较近的位置比较远的位置更有价值，因此它们被赋予更大的价值

这是如何实现的，是通过一个叫做合格痕迹的向量【E】。
具体地，合格痕迹是状态 E(s) 或状态动作 E(s，a) 的函数，并保存 V(s)的衰减值。

那么，我们如何从向前看过渡到向后看，资格跟踪在其中的作用是什么？

还记得我们说过的前视，每个情节对当前状态的贡献随着情节中的步数(n)呈指数衰减(𝛌的 n 次方)。
使用相同的逻辑，当我们处于状态 s 时，我们不是向前看，看到一集的衰减回报(Gt)向我们走来，而是简单地使用我们拥有的值，并使用相同的衰减机制将其向后抛出。

例如，在 TD(0)中，我们将 TD 误差定义为:

该误差将向后传播，但是以衰减的方式。
类似于随着距离渐行渐远的声音。
我们实现这一点的方法是将𝜹乘以每个州的资格跟踪。

其中 Et 更新如下:

Backward View propagates the error δ to previous states

符号 1(St = s)意味着，当我们处于状态 s 时，我们分配完整的值，当它向后传播时，它以指数形式衰减。

对于所有状态，合格的跟踪更新从 E(s) = 0 开始，然后当我们经过每个状态(由于执行动作)时，我们递增 E(s)以增加状态的值，然后对于所有的，我们通过ɣ𝛌 (E(s) = ɣ𝛌 E(s)衰减 E(s)

与 n 步前向视图相比，合格轨迹的主要优点是只需要一个轨迹向量，而不是存储最后 n 个特征向量。

使用资格跟踪的算法

以下是几个使用资格跟踪的算法。

结论

资格跟踪是一种在时间差“目标”和蒙特卡罗“回报”之间进行加权的方式。这意味着我们不使用一步 TD 目标，而是使用 TD(λ)目标。
换句话说，它微调目标以获得更好的学习性能。

资源

《强化学习:导论》，萨顿&巴尔托著

伊丽莎白·沃伦在 2020 年总统竞选中领先:Python 中的一项分析

原文：https://towardsdatascience.com/elizabeth-warren-is-leading-the-2020-presidential-race-an-analysis-in-python-967e272d15da?source=collection_archive---------27-----------------------

Photo by Element5 Digital on Pexels

在这篇文章中，我们将使用 python Google trends API py trends 来分析哪些领先的民主党候选人被搜索得最多。

要安装 pytrends，请打开命令行并键入:

pip install pytrends

接下来打开一个 IDE(我使用 Spyder)并导入 pytrends:

from pyrtends.request import TrendReq

接下来，我们指定主机语言、时区和有效负载。我们将主机语言指定为英语(“en-US”)，时区为中部标准时区，即“360”，我们可以将 google 属性过滤器(gprop)保留为空字符串。我们还设置了 category = 0，对应与该关键字相关的所有类别。

让我们来看看乔·拜登从 2019 年 1 月到 2019 年 10 月在纽约的数据:

pytrends = TrendReq(hl='en-US', tz=360)
pytrends.build_payload(['Biden'], cat=0, timeframe='2019-01-01 2019-10-31',  gprop='', geo='US-NY')

然后，我们将 dataframe 定义为结果 pytrends 对象，并打印前五行:

pytrends = TrendReq(hl='en-US', tz=360)
print(df.head())

我们还可以使用 seaborn 和 matplotlib 来绘制“Biden”搜索的时间序列:

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pdsns.set()
df['timestamp'] = pd.to_datetime(df.index)
sns.lineplot(df['timestamp'], df['Biden'])plt.title("Normalized Searches for Biden in NY")
plt.ylabel("Number of Searches")
plt.xlabel("Date")

让我们为怀俄明州的拜登做同样的事情:

我们也可以看看纽约的桑德斯:

为了进行比较，我们可以覆盖拜登，桑德斯和沃伦在纽约的搜索:

Biden(blue), Sanders(orange), Warren(green)

根据谷歌趋势数据，伊丽莎白·沃伦似乎比拜登和桑德斯更受欢迎。我们也可以看看怀俄明州的同样情况，那里有 68%的共和党人:

Biden(blue), Sanders(orange), Warren(green)

沃伦在怀俄明州也一直领先。看看几个摇摆州会很有意思。让我们来看看密歇根州:

Biden(blue), Sanders(orange), Warren(green)

沃伦在密歇根州遥遥领先，尽管该州被认为是战场州。

爱荷华州有:

Biden(blue), Sanders(orange), Warren(green)

最后让我们看看佛罗里达州:

Biden(blue), Sanders(orange), Warren(green)

值得注意的是，在撰写本文时，《纽约时报》报道称，根据民调显示，拜登领先(26%)，沃伦紧随其后(21%)。有趣的是，尽管拜登领先，但在民主党、共和党和摇摆州，越来越多的人在寻找沃伦。

在美国各州进行这种分析，看看沃伦是否一直处于领先地位，这将是一件有趣的事情。

最后，为了使这些代码易于重用，我们可以将它们封装在一个函数中:

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd 
from pytrends.request import TrendReqdef get_searchs(candidate, state):
    pytrends = TrendReq(hl='en-US', tz=360)
    pytrends.build_payload([candidate], cat=0, timeframe='2019-01-01 2019-10-31',  gprop='',geo='US-{}'.format(state))    
    df = pytrends.interest_over_time()

    print(df.head())

    sns.set()
    df['timestamp'] = pd.to_datetime(df.index)
    sns.lineplot(df['timestamp'], df[candidate])

    plt.title("Normalized Searches for Biden, Warren and Sanders in {}".format(state))
    plt.ylabel("Number of Searches")
    plt.xlabel("Date")

例如，我们可以调用函数在马萨诸塞州进行搜索，如下所示:

get_searches('Biden', 'MA')
get_searches('Sanders', 'MA')
get_searches('Warren', 'MA')

我们得到了下面的图:

Biden(blue), Sanders(orange), Warren(green)

感谢您的阅读。这篇文章的代码可以在 GitHub 上找到。

ELMo:上下文语言嵌入

原文：https://towardsdatascience.com/elmo-contextual-language-embedding-335de2268604?source=collection_archive---------4-----------------------

使用 ELMo 的深度语境化语言表示创建语义搜索引擎，以及为什么在 NLP 中语境就是一切

Semantic sentence similarity using the state-of-the-art ELMo natural language model

本文将探索自然语言建模的最新进展；深层语境化单词嵌入。重点在于如何使用最先进的 ELMo 模型来检查给定文档中的句子相似性，并创建一个简单的语义搜索引擎。完整的代码可以在 Colab 笔记本这里查看。

语境在自然语言处理中的重要性

众所周知，语言是复杂的。上下文可以完全改变一个句子中单个单词的意思。例如:

他踢了桶一脚。

我还没有划掉我的清单上的所有项目。

水桶装满了水。

在这些句子中，虽然单词 bucket 总是相同的，但它的意思却非常不同。

Words can have different meanings depending on context

虽然我们可以很容易地破译语言中的这些复杂性，但创建一个能够理解给定环境文本中单词含义的不同细微差别的模型是困难的。

正是由于这个原因，传统的单词嵌入(word2vec、GloVe、fastText)有所欠缺。每个单词只有一种表达方式，因此它们不能捕捉每个单词的意思是如何根据周围的环境而变化的。

介绍 ELMo 深层语境化的词汇表征

输入 ELMo。它由 AllenNLP 在 2018 年开发，超越了传统的嵌入技术。它使用深度的双向 LSTM 模型来创建单词表示。

ELMo 不是一个单词及其对应向量的字典，而是在单词使用的上下文中分析单词。它也是基于字符的，允许模型形成词汇表外单词的表示。

因此，这意味着 ELMo 的使用方式与 word2vec 或 fastText 完全不同。ELMo 没有在字典中“查找”单词及其相应的向量，而是通过将文本传递给深度学习模型来动态创建向量。

一个可行的例子，ELMo 的实际使用不到 5 分钟

我们开始吧！我将在这里添加主要的代码片段，但是如果您想要查看完整的代码集(或者确实想要通过点击笔记本中的每个单元格来获得奇怪的满足感)，请在这里查看相应的 Colab 输出。

根据我最近的几篇帖子，我们将使用的数据是基于现代奴隶制的回报。这些都是公司的强制性声明，以传达他们如何在内部和供应链中解决现代奴隶制问题。在这篇文章中，我们将深入探究 ASOS 的回归(一家英国在线时装零售商)。

如果你有兴趣看到在这个数据集上进行的 NLP 实验的迷你系列中的其他帖子，我在本文的结尾提供了这些的链接。

1。获取文本数据，清理并标记

令人惊讶的是，使用 Python 字符串函数和 spaCy 做到这一点是多么简单。这里我们通过以下方式进行一些基本的文本清理:

a)删除换行符、制表符、多余的空格以及神秘的“xa0”字符；

b)使用空格将文本分成句子。sents 的迭代器。

ELMo 既可以接收句子字符串列表，也可以接收列表(句子和单词)列表。这里我们选择了前者。我们知道 ELMo 是基于字符的，因此对单词进行标记不会对性能产生任何影响。

nlp = spacy.load('en_core_web_md')#text represents our raw text documenttext = text.lower().replace('\n', ' ').replace('\t', ' ').replace('\xa0',' ') #get rid of problem chars
text = ' '.join(text.split()) #a quick way of removing excess whitespace
doc = nlp(text)sentences = []
for i in doc.sents:
  if len(i)>1:
    sentences.append(i.string.strip()) #tokenize into sentences

2。使用 TensorFlow Hub 获取 ELMo 模型:

如果您还没有接触过 TensorFlow Hub，它可以为 TensorFlow 提供大量预先训练好的模型，从而节省大量时间。对我们来说幸运的是，其中一个模特是埃尔莫。我们只需要两行代码就可以加载一个完全训练好的模型。多么令人满意…

url = "[https://tfhub.dev/google/elmo/2](https://tfhub.dev/google/elmo/2)"
embed = hub.Module(url)

为了在 anger 中使用这个模型，我们只需要多几行代码来将它指向我们的文本文档并创建句子向量:

# This tells the model to run through the 'sentences' list and return the default output (1024 dimension sentence vectors).
embeddings = embed(
    sentences,
    signature="default",
    as_dict=True)["default"]#Start a session and run ELMo to return the embeddings in variable x
with tf.Session() as sess:
  sess.run(tf.global_variables_initializer())
  sess.run(tf.tables_initializer())
  x = sess.run(embeddings)

3。使用可视化来检测输出

令人惊讶的是，观想作为一种更好地理解数据的方式经常被忽视。图片说明千言万语，我们将创建一个一千字的图表来证明这一点(实际上是 8511 个字)。

这里，我们将使用主成分分析和 t-SNE 将 ELMo 输出的 1024 个维度减少到 2 个，以便我们可以查看模型的输出。如果你想了解更多，我在文章的最后提供了关于如何实现这一点的进一步阅读。

from sklearn.decomposition import PCApca = PCA(n_components=50) #reduce down to 50 dim
y = pca.fit_transform(x)from sklearn.manifold import TSNEy = TSNE(n_components=2).fit_transform(y) # further reduce to 2 dim using t-SNE

使用神奇的 Plotly 库，我们可以在任何时候创建一个美丽的，互动的情节。下面的代码显示了如何呈现我们的降维结果，并将其连接到句子文本。根据句子的长度，还添加了颜色。当我们使用 Colab 时，最后一行代码下载 HTML 文件。这可以在下面找到:

[## 句子编码

交互式句子嵌入

drive.google.com](https://drive.google.com/open?id=17gseqOhQl9c1iPTfzxGcCfB6TOTvSU_i)

创建它的代码如下:

import plotly.plotly as py
import plotly.graph_objs as go
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplotinit_notebook_mode(connected=True)data = [
    go.Scatter(
        x=[i[0] for i in y],
        y=[i[1] for i in y],
        mode='markers',
        text=[i for i in sentences],
    marker=dict(
        size=16,
        color = [len(i) for i in sentences], #set color equal to a variable
        opacity= 0.8,
        colorscale='Viridis',
        showscale=False
    )
    )
]
layout = go.Layout()
layout = dict(
              yaxis = dict(zeroline = False),
              xaxis = dict(zeroline = False)
             )
fig = go.Figure(data=data, layout=layout)
file = plot(fig, filename='Sentence encode.html')from google.colab import files
files.download('Sentence encode.html')

探索这种可视化，我们可以看到 ELMo 在根据语义相似性对句子进行分组方面做了出色的工作。事实上，该模型的有效性令人难以置信:

Download the HTML for yourself (link above) to see ELMo in action

4。创建语义搜索引擎:

现在我们确信我们的语言模型运行良好，让我们将它应用到语义搜索引擎中。这个想法是，这将允许我们通过搜索查询的语义接近度而不是关键字来搜索文本。

这实际上很容易实现:

首先，我们获取一个搜索查询，并对其运行 ELMo
然后，我们使用余弦相似度将它与文本文档中的向量进行比较；
然后，我们可以从文档中返回与搜索查询最接近的“n”个匹配项。

Google Colab 有一些很棒的特性来创建表单输入，非常适合这个用例。例如，创建一个输入就像在变量后添加 #@param 一样简单。下面显示了字符串输入的情况:

search_string = "example text" #@param {type:"string"}

除了使用 Colab 表单输入，我还使用了“IPython.display.HTML”来美化输出文本，并使用一些基本的字符串匹配来突出显示搜索查询和结果之间的常见单词。

让我们来测试一下。让我们看看 ASOS 在他们现代奴隶制的回归中，在道德准则方面做了些什么:

A fully interactive semantic search engine in just a few minutes!

这太神奇了！匹配超越了关键词，搜索引擎清楚地知道‘伦理’和道德是密切相关的。我们发现符合诚信准则以及道德标准和政策的内容。两者都与我们的搜索查询相关，但不直接基于关键字链接。

我希望你喜欢这篇文章。如果您有任何问题或建议，请留下您的意见。

雪花数据仓库中的 ELT 数据流水线——使用流和任务

原文：https://towardsdatascience.com/elt-data-pipelining-in-snowflake-data-warehouse-using-streams-and-tasks-ae6eb7c083de?source=collection_archive---------5-----------------------

在我之前的帖子中:

使用 Azure Portal Web UI 为雪花数据仓库在 Azure Blob 存储上构建 Snowpipe

https://medium . com/@ qiuyujx/building-snow pipe-on-azure-blob-storage-using-azure-portal-we b-ui-for-snow flake-data-warehouse-f0cdd 7997250

Snowpipe 被引入用于自动发现云存储(例如 Azure Blob 存储)中的新数据文件，然后将数据加载到某个表中。

Snowpipe 是实现上述目的的一个非常方便的工具。然而，Snowpipe 本身只被认为是 ELT 的“E”(提取)，因为在 Snowpipe 创建语句中只允许使用COPY INTO命令。换句话说，我们可以用它轻松实现以下目标:

加载不同格式的数据文件，如 CSV、JSON、XML、Parquet 和 ORC
采用和调整数据源以获得更好的兼容性，比如剥离 JSON 的外部数组和 XML 的外部元素
更改列名
更改列顺序
省略列
将数据/时间字符串解析为数据/时间对象

因此，出于以下原因，数据流水线的其余部分需要流和任务:

一些数据转换可能是必要的，比如数字计算和字符串连接。
数据源不是典型的三范数格式，需要根据一定的关系加载到多个表中。
ELT 作业可能不限于追加表，还包括更复杂的需求，如要实现的 SCD(渐变维度)。

因此，我们不得不在雪花中涉及其他对象来完成数据管道。

雪花溪流

雪花流对象用于跟踪对表的任何更改，包括插入、更新和删除，然后可以被其他 DML 语句使用。steam 对象的一个典型用法是 CDC(变更数据捕获)

标准视频点播附加流

我们可以在 Snowflake 中定义两种类型的流，标准流和仅附加流。标准流将捕获对表的任何类型的更改，而仅追加流只捕获插入的行。前者可用于一般目的，而后者可用于典型的 ELT 模型中，当我们只对摄取的新行感兴趣时。

例如，我们可以使用 Snowpipe 从云存储中的 CSV 文件自动获取数据，并复制到临时表中。然后，一个流将捕获这个批量插入动作，并记录这些新行的偏移量。

流偏移

雪花流在物理上不存储、包含或复制任何数据。它只是在当前时间拍摄跟踪表的快照(例如，在创建流时)，然后流会将对此表所做的每个更改记录为附加元数据。表格的前一版本和当前版本之间的差异称为偏移。

当其他 DML 语句使用流的偏移量时，偏移量将被重置，并且流将所使用的数据视为表的“先前”版本。典型的消耗流偏移量的 DML 语句是INSERT INTO ... SELECT ... FROM STREAM。

以下是流消费流的一个示例:

假设一个表中已经有一百万行。我们在这个表上创建一个流，这个流没有偏移量，因为这个表的当前版本是快照。
假设有 1000 行从 Snowpipe COPY INTO语句插入到表中。
该流将这 1000 行记录为其偏移量。
假设现在我们从流中读取这 1000 行，并将它们插入到另一个表中。
该流现在将没有偏移量，因此它将是空的，因为我们已经消耗了先前的偏移量。

很明显，雪花流是为英语教学过程设计的。例如，我们有一个高频率的数据被接收到数据库中，我们每 5 分钟消耗一次数据。该流将保证我们每次使用新数据时没有遗漏和重叠。这确实是一个在其他数据库管理系统中实现起来很复杂的逻辑，或者我们可能需要使用额外的编程语言来实现这一点。

流列

因为 stream 实际上是原始表的快照，所以原始表中的所有列也可以在 stream 中访问。例如，如果原始表有 3 列名为col1、col2和col3，那么我们可以简单运行

SELECT col1, col2, col3
FROM the_stream;

检索此流中的偏移量。

此外，还有 3 个额外的列是专门针对流对象的元数据:

METADATA$ACTION表示该行的更改类型。可以是INSERT也可以是DELETE。请注意，没有“更新”操作。一行的更新将由两行表示，一行是前一行的DELETE，另一行是新行的INSERT。您会发现这非常方便，因为通过比较这两行，您可以在流中获得关于更新了哪些特定字段的信息。
METADATA$ISUPDATE表示该行是否因更新而生成。这个列是一个额外的指示器，它允许您获得所有带有INSERT和DELETE的行，但实际上是因为更新而生成的。
METADATA$ROW_ID是特定行的唯一 ID。即使该行被更新，它也不会改变，并且在将来的任何进一步的偏移更新中保持不变。

这是一张来自官方文档的图片，非常清晰地展示了数据流。

Image courtesy: https://docs.snowflake.net/manuals/user-guide/streams.html

雪花任务

雪花任务就是这样一种对象，它可以安排 SQL 语句作为重复事件自动执行。

是的，我对每个任务都使用“an”SQL 语句。目前，这是雪花任务的一个限制。希望在未来的更新中，它将支持事务适当的BEGIN和COMMIT关键字，以便我们可以在一个事务中执行一系列 SQL 语句，并利用任务来调度该事务。

尽管有这样的限制，雪花确实提供了多 SQL 语句调度的方法，这被称为任务树。顾名思义，我们可以在一个树形结构中定义多个任务。几个小贴士:

一个任务可以有多个任务作为其子任务，所以子任务将在父任务完成时执行。
一个任务只能有一个父任务。
因此，任务树实际上只是一棵树，而不是 DAG。所以，你可以考虑它可以做“fork”，但是没有“join”。

下面是一个简单任务树的图表。

Image courtesy: https://docs.snowflake.net/manuals/user-guide/tasks-intro.html

触发任务

触发任务有两种方式，一种是通过定义计划，另一种是通过另一个任务触发。

雪花支持两种类型的任务调度定义，“CRON”表达式和时间间隔。CRON 表达式可以定义任务将被触发的确切日期/日期/时间，它非常强大，可以实现任何简单到复杂的需求，例如

在每天的特定时间运行任务
在一周中某一天的某个时间运行任务
支持时区
支持夏令时

关于 CRON 表达式的具体语法，请访问这个免费网站进行详细的解释和实验:

[## 免费在线克隆表达式生成器和描述-FreeFormatter.com

使用易于使用的在线界面生成 quartz cron 表达式。将 cron 表达式转换成可读文本…

www.freeformatter.com](https://www.freeformatter.com/cron-expression-generator-quartz.html)

另一种调度定义的方法要简单得多，就是简单的定义时间间隔。例如，如果我希望任务每 5 分钟触发一次，那么就这样定义它:

SCHEDULE = '5 MINUTE'

触发任务的另一种方式是定义父任务，这被认为是构建任务树。例如，如果我们想在TASK1结束时触发TASK2，只需简单定义:

CREATE TASK TASK2
...
AFTER "TASK1"
AS
<SQL>

有条件的任务

可以通过“WHEN”子句用条件来定义任务，该子句用于决定是否应该执行该任务。

这是一个非常方便的功能。例如，如果您用您的“根任务”设置一个条件，当条件不满足时，整个任务树将根本不会运行。

此外，如果这种“条件测试”发生在雪花的云服务层(使用元数据而不是对表的 SQL 查询)，则这种条件测试的成本为零，因此如果条件不满足，则没有成本。

通过流使用任务

雪花任务和流被一起用来构建数据管道是非常常见的。一个非常典型的使用模式是:

Snowpipe 将原始数据加载到临时表中。
雪花流是在 staging 表上创建的，因此被摄取的新行将被记录为偏移量。
然后，雪花任务通过一些 DML 语句消耗流偏移量，以进一步将数据加载到生产表中，可能包括一些更复杂的转换。
在实践中，会有一个任务树来执行多个 SQL 语句，以便执行复杂的转换，有时会将转换后的条目填充到多个生产表中。
一些中间表可能需要由任务树中的任务创建。
在任务树的最后可能会有一些任务来清理一些临时表。

我们已经介绍了需要集成 Snowpipe 和 Stream 的典型场景。现在，对于流和任务，还有一个非常典型的使用模式，那就是系统变量SYSTEM$STREAM_HAS_DATA。

具体来说，变量SYSTEM$STREAM_HAS_DATA将返回一个布尔值，表明在可消费的流中是否存在偏移。因此，我们可以简单地将这个条件放在任务定义的“WHEN”子句中。因此，如果流中没有新内容，任务将不会被执行。例如:

CREATE TASK mytask1
  WAREHOUSE = mywh
  SCHEDULE = '5 minute'
WHEN
  SYSTEM$STREAM_HAS_DATA('MYSTREAM')
AS
  INSERT INTO ... ;

在这个例子中，只有当流“MYSTREAM”中存在消耗性偏移时，才会执行任务“mytask1”。否则，将跳过该任务，并在 5 分钟后再次检查状况。

还有一个提示

请记住，默认情况下，刚刚创建的任务将被暂停。有必要通过如下方式“改变”任务来手动启用此任务:

ALTER TASK mytask1 RESUME;

未来作品

本文从理论上介绍了雪花流和任务。画出了使用 Snowpipe -> Stream -> Task 构建 ELT 数据管道的概貌。在下一部分中，我将使用一个真实的示例数据源来构建 ELT 数据管道，使用这些雪花组件和必要的 SQL 脚本演示，这将更具实践性。

[## 通过我的推荐链接加入灵媒-陶

作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…

medium.com](https://medium.com/@qiuyujx/membership)

如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和成千上万的其他作者！(点击上面的链接)

资源

雪花溪流官方文档:【https://docs.snowflake.net/manuals/user-guide/streams.html

雪花任务官方文档:
https://docs . snow flake . net/manuals/user-guide/Tasks-intro . html

免费在线 CRON 表达式生成器:
https://www . free formatter . com/CRON-expression-generator-quartz . html

阐释强化学习中的策略迭代——杰克的租车问题

原文：https://towardsdatascience.com/elucidating-policy-iteration-in-reinforcement-learning-jacks-car-rental-problem-d41b34c8aec7?source=collection_archive---------12-----------------------

[1]: Generalized Policy Iteration

在这篇博文中，我将尝试通过使用强化学习中的策略迭代算法来解决 Jack 的租车问题，从而阐明该算法。这个问题和它的变体分别在萨顿和巴尔托的书(强化学习:导论，第二版)中的例子 4.2 和练习 4.5 中给出。

问题陈述

杰克为一家全国性的汽车租赁公司管理着两个地点。每天，都会有一定数量的客户来到每个地点租车。如果杰克有一辆车，他就把它租出去，国家公司给他 10 美元。如果他在那个位置没有车，那么生意就没了。汽车在归还的第二天就可以出租了。为了帮助确保汽车在需要的地方可用，Jack 可以在两个地点之间连夜移动汽车，每移动一辆汽车的费用为 2 美元。

我们假设每个位置请求和返回的汽车数量是一个泊松随机变量。回想一下，如果 X 是泊松随机变量，那么

假设第一个和第二个位置的租赁请求的λ是 3 和 4，返回请求的λ是 3 和 2。

为了稍微简化问题，我们假设每个位置不能超过 20 辆汽车(任何额外的汽车都返回给全国性的公司，因此从问题中消失),并且在一个晚上最多可以将五辆汽车从一个位置移动到另一个位置。我们将贴现率γ设为 0.9，并将其公式化为一个连续的有限马尔可夫决策过程，其中时间步长为天，状态为一天结束时每个位置的汽车数量，而行动为一夜之间在两个位置之间移动的汽车净数量。

但是解决这个问题意味着什么呢？

解决这个问题意味着解决两件事，首先，杰克应该在一夜之间在每个地点之间移动多少辆车，以最大化他的总期望回报，即，在给定的情况(状态)下，他的策略(政策)应该是什么；其次，如果杰克知道这个策略，他如何比较哪些情况比其他情况更好(价值)？

初始设置

让我们先用代码写出我们知道的最初的东西。从问题中，我们知道杰克可以获得两种类型的奖励，第一种是他租车时的 10 美元奖励，第二种是他从一个位置移动到另一个位置的每辆车的-2 美元奖励(注意，后一种奖励是负的)。

现在我们定义一个 poisson_ class，它取一个参数λ，计算对应的概率质量函数。它有两个数据成员α和β，表示 pmf 值大于ε(此处为 0.01)的 n 值的区间[α，β]。我们将ε以下的 pmf 值设置为零，然后对结果分布进行归一化。

例如，对于λ = 3，数据成员α、β和 val 的值为:

策略迭代算法

在我们继续之前，为了确保所有的读者都在同一页上，让我们快速修改一下这里的术语价值和策略的含义。

在我们的汽车租赁示例中，系统在任何时候的状态都是一对两个数字，第一个和第二个位置的汽车数量。给定一个状态，杰克必须选择一个动作，即他可以从第一个位置移动到第二个位置的汽车数量，反之亦然。根据问题，可以在-5 到+5 之间变化，其中+n 代表 Jack 将 n 辆车从第一个位置移动到第二个位置。

策略是从状态到行动的映射，例如，给定一个状态，Jack 应该在一夜之间移动多少辆车。现在，假设杰克有某个策略π，那么给定这个π，一个状态(比如 s)的值就是杰克从 s 出发，之后跟随π时会得到的期望回报。

[1]: The Policy Iteration Algorithm

如上图所示，策略迭代算法由三部分组成。让我们在解决租赁问题的背景下分别讨论这些组件。

第一部分是初始化。如上图所示，我们任意初始化值和策略矩阵。将它们初始化为零也可以。请注意，给定一个策略，我们为每个状态定义一个值，因为我们的状态是一对两个数字，其中每个数字取 0 到 20 之间的值，因此我们用形状矩阵(21 x 21)来表示值。策略取一个状态，输出一个动作；因此，它也可以用相同形状的矩阵来表示。

第二个组成部分是政策评估。通过政策评估，我们的意思是遵循这个政策，任何国家的价值应该是什么。如上所述，给定一个政策π，一个状态(比如 s)的值就是杰克从 s 出发，之后跟随π时会得到的期望回报。

这种与状态值相关联的期望概念可以写成上图所示的形式，由此可以推导出贝尔曼方程，如图所示。

这个贝尔曼方程形成了在策略评估组件中显示的值更新的基础。

Value Update

在许多这样的更新之后，V(s)收敛到一个几乎满足(最多有一些θ误差)贝尔曼方程的数，因此代表状态 s 的值。

第三个组成部分是政策改进。给定一个状态(比如 s)，我们指定π(s)等于使期望报酬最大化的动作。我们说，当任何状态下的行动最大化步骤都没有引起策略的变化时，策略变得稳定。

我们循环运行策略评估和改进组件，直到策略变得稳定。

结果

上图以热图的形式显示了通过评估和改进后的策略。回想一下，策略由包含[-5，5]范围内的动作值的矩阵表示。

给原来的租赁问题增加了非线性

让我们看看，如果我们在上面的问题中加入一些非线性因素，会发生什么:

Jack 在第一个地点的一名员工每天晚上乘公交车回家，并且住在第二个地点附近。她很乐意免费接送一辆车到第二个地点。每增加一辆车仍然要花 2 美元，所有向相反方向移动的车也是如此。
此外，Jack 在每个位置都有有限的停车位。如果超过 10 辆汽车在一个地点过夜(在任何汽车移动之后)，那么使用第二个停车场必须产生 4 美元的额外费用(与有多少辆汽车停在那里无关)。

可以很容易地添加这些条件来修改原始代码。如果需要，我们将有一个额外的奖励-第二个停车场 4 美元(注意，这个奖励是负的)。

生成的策略(通过评估和改进)如下图所示。

结论

我们使用动态规划解决了上述问题。我们存储了中间值和策略矩阵，并在策略评估和改进功能中使用它们。然而，为了使用贝尔曼更新，我们需要知道环境的动态，就像我们在租赁示例中知道奖励和下一个状态的概率一样。如果只能从底层分布中采样，不知道分布本身，那么可以用蒙特卡罗方法来解决相应的学习问题。

Github 库:https://github.com/thunderInfy/JacksCarRental

参考

[1]萨顿和巴尔托(2017 年)。强化学习:导论。剑桥，麻省理工学院出版社

[2] S. David 关于通过动态规划进行规划的讲座(【https://www.youtube.com/watch?v=Nd1-UUMVfz4】T2)。

电子邮件自动化、分析和可视化

原文：https://towardsdatascience.com/email-automation-analytics-and-visualization-53b022e0f9a0?source=collection_archive---------8-----------------------

使用 Python 的 Imapclient、Smtplib、Pandas 和 Matplotlib 库的详细教程

Image by ribkhan on Pixabay

介绍

阅读、回复甚至整理电子邮件往往会耗费大量时间。虽然今天有许多电子邮件客户端竭尽全力使这方面的生活变得更容易，但如果能够以编程的方式执行与电子邮件相关的任务，这将非常有用。让我们考虑一个这种方法可以派上用场的场景——电子邮件混乱。现在，可以说互联网上充斥着如何减少电子邮件混乱的建议。虽然所有这些技巧都有可能帮助你今后更有效地使用你的电子邮件，但如果目前你的收件箱已经到了无法恢复的地步，手动清理几乎是不可能的，那该怎么办？一个典型的例子是——我妻子的收件箱里有来自 300 多个不同发件人的 35000 多封电子邮件。她确信这些邮件大多与营销有关，但她认为，单独退订这些邮件太费力了，这也是有道理的。本文的第一部分讨论了这个问题，并解释了如何使用 python 的 imapclient 和 smtplib 库发送、检索、分类、删除和取消订阅电子邮件。

另一方面，让我们假设你是一个电子邮件组织忍者，完全控制着你的收件箱，一丝不苟地给每一封邮件贴上标签并归档。你可能会对一些关于你的电子邮件的统计数据感兴趣，比如谁给你发的电子邮件最多，你的流量是多少，或者你典型的电子邮件回复时间是多少。这篇文章的第二部分正是为了这个目的，演示了如何使用 Pandas 分析电子邮件数据，以及如何使用 Matplotlib 创建可视化工具

请注意，虽然这里使用 Gmail 来说明各种概念，但代码可以通过一些小的修改与任何电子邮件客户端一起工作，因为大多数情况下只使用通用 Python 库，而不是客户端特定的 API。此外，请记住，这里显示的教程只是这些 Python 电子邮件库所能实现的一小部分。所以我强烈建议您以此为起点，然后扩展它以满足您的需求。我们将只看运行这个项目所需的关键代码片段。你可以在我的 GitHub 库中找到完整的代码。

第 1 部分:自动化

步骤 1:连接到服务器并登录

在使用 Python 访问您的电子邮件之前，您需要更改您的 google 帐户设置，以允许访问不太安全的应用程序。否则，google 将阻止您的代码尝试登录该帐户。现在，出于安全原因，我建议在运行完代码后，将该设置改回默认状态。

Less secure app access in Gmail

完成后，我们可以使用该帐户的用户名和密码登录到服务器。在运行时接受您的用户名和密码作为用户输入，而不是硬编码，这总是一个好的做法。

Establishing connection to the IMAP and SMTP servers

IMAP (Internet 邮件访问协议)是一种标准协议，它指定了如何与电子邮件服务器通信以检索邮件。由 RFC3501 定义。Imapclient 是一个 python 第三方库，它在底层使用 python 的标准 imaplib 库，但提供了一个更干净、更易于使用的 API，特别是在解析和错误处理方面。SMTP(简单邮件传输协议)和 Smtplib 相当于发送邮件的 IMAP 和 Imapclient。

导入这些库之后，我们连接到服务器并创建一个 IMAP 对象和一个 SMTP 对象。对于不同的电子邮件服务，这里使用的服务器名称是不同的。根据许多提供商的要求，我们为 IMAP 启用了安全套接字层(SSL)加密，为 SMTP 启用了传输层安全性(TLS)加密。同样，加密类型和端口号取决于提供商。

步骤 2:搜索和检索电子邮件

我们可能希望对多个文件夹执行搜索操作。为此，让我们首先获取可用文件夹的列表。

List of email folders

我们使用 pprint 模块使文件夹列表看起来更易读。您可以看到，用户创建的文件夹和 Gmail 自己的文件夹(技术上来说，是标签)都显示出来了。您可以选择遍历多个文件夹来搜索电子邮件，但是对于本教程，只使用收件箱文件夹。

Searching for emails

这里，我们首先告诉 Python 将内存分配从默认值 10，000 字节增加到 10，000，000 字节。如果没有这一点，万一我们的搜索返回大量的电子邮件，Python 可能会引发一个异常。注意 _MAXLINE 命令属于 Imaplib 库，而不是 Imapclient 库。在下一行中，我们使用 select_folder()方法选择要搜索的文件夹。将 readonly 关键字设置为 true 可防止此文件夹中的邮件被意外删除。

然后我们搜索四个月时间范围内的电子邮件。search()方法接受各种各样的搜索关键字，允许您按发件人、收件人、主题或正文内容、可见、不可见、已回答或未回答的标志等进行搜索。例如，要搜索来自特定发件人的邮件，搜索关键字应为['FROM '，' sender@example.com']。IMAPClient 类的文档包含了更多关于这个的信息。

搜索结果存储在 UIDs 变量中，该变量是符合搜索条件的每封电子邮件的唯一整数 id 列表。这个 ID 稍后将用于检索相应的消息。

步骤 3:对检索到的邮件进行分类

Categorizing emails

一旦我们有了 uid 列表，我们就使用 get_gmail_labels()方法根据它们的标签对邮件进行分类。请注意，这个特殊的方法是专门针对 Gmail 的。要在其他电子邮件客户端实现这一点，我建议循环遍历之前获得的文件夹列表，并基于此进行分类。这里使用的分类完全是任意的，主要是为了说明这个过程。例如，一封邮件可以被分配所有三个标签——“已加星”、“重要”和“收件箱”。此处的代码会将该邮件归入“已加星”类别。

步骤 4:提取消息属性

Extracting email attributes

在这个片段中发生了很多事情。首先，我们创建几个列表，用于保存电子邮件的不同属性。然后，我们遍历 uid 列表，并使用 fetch()方法检索对应于特定 ID 的消息体。当我们使用 pprint()打印 raw_message 的内容时，看起来是这样的。

Contents of the raw message

我们可以看到，这打印出了一个嵌套的字典，并且“Body[]”键的内容是一种非常模糊的格式。实际上，它是 RFC 822 T1 格式的，用于 IMAP 服务器。另一个模块 pyzmail——可以用来解析这些原始消息，并将它们转换成 PyzMessage 对象，从这些对象中可以找到“发件人”、“收件人”、“主题”、“正文”等字段。可以很容易得到。Pyzmail 是一个高级库，可以解析 imapclient 下载的电子邮件，并将其转换为简单的字符串值。它本质上掩盖了相当复杂的 MIME 结构和编码/解码。

The PyzMessage object

请记住，在某些邮件中，日期的格式可能略有不同。如果你想把它分成日、年、时间等，你需要写适当的代码。get_decoded_header()方法在这里特别有用，因为它可以用来从任何消息头中提取信息。为了理解这里到底发生了什么，我们显示了电子邮件的原始内容，如下所示。

Displaying the original email contents in Gmail

Some of the headers in the original message

这些是 get_decoded_header()方法正在访问的头。例如，get_decoded_header('Subject ')将产生与 get_subject()相同的输出。我们将所有这些不同的属性存储在列表中，以便在以后的分析代码中使用它们。

关于列表-取消订阅标题的注意事项—包含此标题并使取消订阅变得简单和一键操作过程被认为是良好的电子邮件实践，但它可能不会出现在所有邮件中。如果没有链接，这里给出的逻辑将不起作用。这篇是一篇很棒的文章，详细解释了这一点。我们这里的目的是提取退订链接，然后使用其中的信息自动退订不必要的电子邮件。我们只关心那些带有退订邮件地址的退订链接，而不关心那些带有需要点击才能退订的 http 链接的链接。

最后，请记住，检索消息和提取不同的属性不是一个超快的过程。处理大约 1000 封邮件大约需要 2-3 分钟。

步骤 5:删除和取消订阅

提取了各种电子邮件属性后，我们可以根据使用这些属性构建的一个或多个条件删除多封邮件或取消订阅邮件列表。例如，我们可以选择删除过去六个月收到的所有邮件，或者退订来自特定发件人的电子邮件或主题中包含特定单词的电子邮件。

Deleting messages

在上面的代码片段中，我们在收件箱中搜索主题中包含单词“Best Buy”的所有邮件，并获取它们的唯一 id。然后，我们使用 delete_messages()方法将所有这些消息标记为\Deleted，并使用 expunge()方法删除它们。请注意，有些客户端会在没有等待 expunge()调用的情况下删除邮件。由于 Gmail 标签的设置方式，这里的情况略有不同。我们将标签\Trash 添加到邮件中，以便立即将它们移动到 Trash 文件夹中。如果我们遵循前面的方法，邮件将被存档，但不会被删除。

自动退订需要一些额外的代码，因为它涉及到发送电子邮件到从退订链接提取的地址。必须进行一些解析工作，从链接的“mailto”部分提取地址，从“subject”部分提取主题(如果适用)。具体来说，它展示了如何从退订链接中提取相关信息。

Extracting information from the unsubscribe link

您可以看到退订链接是 html 格式的。所以用 Python 的 urllib 模块和 re 模块从中分离出地址和主题。一旦我们有了这个，我们就可以使用 smtplib 模块发送退订电子邮件。

Unsubscribe from emails

让我们来看一下这段代码。首先，电子邮件库 MIMEmultipart 方法允许我们构造多部分消息。然后，我们遍历 uid 列表，根据搜索条件找到退订链接。在本例中，我们尝试取消订阅 Groupon 电子邮件。如前所述，一旦我们从取消订阅链接中提取了地址和主题，我们就创建消息对象，并为其分配“to”和“subject”属性。最后，我们使用 send_message 方法发送退订电子邮件。如果返回一个空字典，则表明发送成功，并且没有电子邮件发送失败的地址。

步骤 6:断开与服务器的连接

Disconnecting from the IMAP and SMTP servers

一旦我们完成了各种电子邮件操作，我们断开与服务器的连接。这是通过对 smtp 对象使用 quit()方法和对 imap 对象使用 logout()方法来实现的。

第 2 部分:分析和可视化

熊猫数据框

在本节中，我们将使用 Pandas 和 Matplotlib 模块来分析一些统计数据并将其可视化。在此之前，让我们将在上一节中获得的数据写入 excel 表中。如果您想在 Python 之外执行任何分析，这可能会很有用。我们将使用如下所示的 openpyxl 库来完成这个任务。

Writing email data to excel

这里，我们首先创建一个 workbook 对象，然后创建一个 worksheet 对象。接下来，我们编写各种标题，如日期、时间、发送者等。进入表格的第一行。然后，我们用上一节中的电子邮件数据列表填充相应的列。最后，我们保存电子表格。如果你想了解更多关于通过 Python 使用 excel 的信息，请参考这些文档页面，它们解释了用于读取和编写电子表格的模块。

接下来，我们用熊猫来读这个 excel 表。Pandas 是一个强大的 Python 模块，提供了大量的数据分析工具。它通常被称为 Python 语言的 SQL。你可以在这里阅读更多信息

Using Pandas to read an excel sheet

这里的数据变量包含 DataFrame，它本质上是一个二维或多维的结构。以下代码片段不言自明，显示了如何从该结构中选择、过滤和打印数据。

Printing the whole dataframe

Printing the first five rows

Printing the last five rows

Printing only two columns from a random sample of ten data points

Filtering based on substring match

使用 Matplotlib 进行可视化

本教程的最后一节展示了如何使用 matplotlib 库来创建一些有助于更好地理解数据的可视化。为此，我们使用了包含 3000 多封电子邮件的数据集

每周邮件流量

Weekly email traffic

这张图向我们展示了一周中不同日子的电子邮件总量分布情况。我们在这里看到一些周一忧郁的迹象，然后电子邮件数量在接下来的四天里或多或少地稳定下来，最终在周末逐渐减少。这里的第一行代码用于按照正确的顺序排列不同的类别(一周中的每一天)。如果没有这个，默认情况下将使用字母顺序对类别进行排序。

2。每小时的电子邮件流量

Hourly email traffic

在这个图中，我们看到了一天中收到的电子邮件的分布。不知什么原因，中午似乎有一个明显的高峰。在这里的代码中，我们首先根据发送/接收来过滤电子邮件。然后，我们在排序之前提取时间戳的小时部分。

3。热门发送者

Top senders

此条形图显示了特定时间段内前二十名发件人及其发送的电子邮件数量。value_counts()方法用于计算特定条目的出现次数，nlargest()方法用于输出出现次数最多的条目。tolist()方法将一个数据序列转换成一个列表。Groupon 似乎是这里最大的罪犯！

4。主题词统计直方图

Subject word count

这是一个直方图，显示了电子邮件主题中使用的字数分布。看起来大约五到十个单词是这里的首选范围。为了对单词进行计数，主题字符串被分割成单词列表，并且该列表的长度作为单独的列存储在数据框中。

5。主题行中的常用词

Common subject words

这是一个有趣的条形图，显示了电子邮件主题行中经常出现的单词。这里的代码稍微有点复杂。首先，使用 split()方法分隔主题中的单词。使用 fillna()方法将空的主题条目转换为字符串“none”是一个好主意，因为空条目可能会在以后产生问题。接下来，我们将 2d 列表转换成一个小写单词列表。在这个分析中，我们对诸如“the”、“is”等常用词不感兴趣。因此，我们使用这些单词创建了一个例外列表，并过滤掉所有包含三个或更少字母的单词。最后，我们将单词和它们的频率分成两个不同的列表，并绘制它们。这里出现频率高的词表明大多数被分析的电子邮件都与营销相关。

结论

到目前为止，我们已经很好地理解了如何使用 Python 执行与电子邮件相关的任务，使用 Pandas 分析电子邮件统计数据，并使用 Matplotlib 可视化它们。这些概念可以扩展到各种应用，包括一些涉及机器学习的应用。以下是一些可能的使用案例:

使用电子邮件的内容构建和训练一个垃圾邮件分类器，并将其性能与 Gmail 或 Outlook 中的内置分类器进行比较。
使用 K-means 等聚类算法对相似的电子邮件进行分组。
使用自然语言处理技术的情感分析
电子邮件营销分析—点击率、跳出率、响应时间等。

资源

GitHub 上的完整代码
RFC 3501 协议
Imapclient 文档
列表-退订标题
Xlrd 文档
Openpyxl 文档
熊猫文档

用于拼写纠正的嵌入

原文：https://towardsdatascience.com/embedding-for-spelling-correction-92c93f835d79?source=collection_archive---------15-----------------------

Photo by Da Nina on Unsplash

尽管自 70 年代以来一直在进行自动拼写纠正，但在缺乏大量用户数据的情况下，仍然很难解决。

噪声文本对于许多 NLP 任务来说是有问题的，因为它导致基于机器学习的技术的准确性降低，并且增加了诸如 Word2Vec 或 GloVe 之类的流行技术不能处理的词汇表外(OOV)单词的数量。

因此，作为管道预处理的一部分，我们探索了几种方法来主动纠正输入数据的拼写，以提高下游任务的准确性。在这里，我们将重点讨论如何通过字符级嵌入来解决这个问题。我们的工作可以从头开始训练，使用和可视化，可以通过点击【1】链接下载和实验。

介绍

拼写错误可以分为三类，需要不同的处理方法:

实词错误 : ' 三个'拼成'有'****

真实的单词错误是最难纠正的，因为它们依赖于上下文，为了纠正它们，我们必须分析所有的数据来检查语义一致性和语法。根据所使用的算法，我们引入了错误地纠正准确句子的可能性，并增加了大量的处理时间。处理这个问题最常见的方法是 seq2seq 模型或使用统计数据，如 ngram 令牌。

2。简短形式 : ' you' 拼写为' u'

简写形式的特点是与想要表达的单词共用几个字母。就 编辑距离 而言,“u”比“你”更接近“我”,因此基于字典的方法不太有效。

3 。非单词错误 : ' fast' 拼写为' fsat'****

非单词错误是最常见的，大多是由错别字引起的，这将是我们这里的重点。

拼写纠正可以分为三个主要任务:

以一个句子作为输入，确定哪些单词拼写错误。
从拼写错误的单词中，查找替换的候选列表。
从列表中选择合适的候选人。(在自动校正的情况下)

因为我们只对非单词错误感兴趣，所以确定哪些单词拼写错误只需对照字典进行检查，尽管必须特别注意专有名词。

候选人选择

有几种不同的方法来选择候选人:

最简单的方法是计算你的单词和整个词典之间的编辑距离。虽然这种方法很准确，但是非常昂贵。
语音算法【2】如 Soundex、Phonex 或 Metaphone。这些算法将任何字符串编码成一个短序列，允许字符串索引的发音。“hurry”和“hirry”都将返回“H600”。通过预处理您的整个词典并按语音代码索引，您可以很容易地找到发音相似的候选词。运行时很快，但它只纠正语音错误。
计算你的单词的可能拼写错误列表(插入、删除、换位或替换)，并将其与你的字典匹配。虽然这比简单的方法要好，但是由于拼写错误的集合以 54 * length+25 的速率增加，所以速度非常慢。更多解释见Peter nor vig【3】的优秀文章。
对称拼写校正采用前面的想法，并通过计算字典和拼写错误的单词的拼写错误来扩展它。详见 符号拼写【4】。这种技术既准确又非常快，但代价是大量的预计算和磁盘空间，并且需要字典的频率列表。

字符级嵌入

我们已经探索了解决这个问题的另一种方法，即使用单词嵌入在字符级别表示单词。流行的单词嵌入方法，如 Word2Vec，试图通过语义来表示单词，因为这对各种任务非常有用。然而，通过使用基于字符的模型，有可能基于单词拼写来构建单词嵌入。

这个想法类似于语音算法，其目的是在相同的单一度量(字符串或浮点数)下表示相似的单词，但是我们通过使用 n 维嵌入来扩展这个想法。

我们的方法如下:

训练模型以产生字符级单词嵌入
向量化我们的整个字典，并建立一个有效的搜索索引
矢量化拼写错误的单词并查找最近的邻居

该模型使用两层 LSTM 来构建选定大小的嵌入。更高的维度以更长的计算时间为代价提供更精确的结果，对于我们的使用，我们已经满足于维度 150。该模型通过向其传递一组单词来训练，这些单词要么是两个完全不同的单词，要么是单词及其拼写错误。训练目标是使相似元组的两个嵌入之间的差异的范数最小化*，并使不同单词的差异最大化。*****

已经使用 600k 单词的字典生成了训练数据，并且为每个单词生成了编辑距离 1 或 2 的几个拼写错误。我们对 AZERTY 键盘上原始字符附近的拼写错误赋予了更高的概率(因为我们是用法语工作的),以便模型支持这些错误。由于缺乏明确的训练指标，很难准确知道何时停止训练，但在经历了几百万次训练后，我们对结果感到满意。

一旦经过训练，该模型就可以用于向量化单词。通过使用 PCA 将它们投影到 2D 平面上，我们可以获得以下可视化:

**python usage_visualisation.py**

The original model we used was developed by IntuitionEngineering.

成功！相似的单词似乎在向量空间中被分组在一起。

这本身不是很有用，所以现在我们要对整个 60 万单词字典进行矢量化。在现代 CPU 上，这个过程大约需要 10 分钟。

最后一步是构建一个索引，它允许有效地搜索最近的向量。由于我们不需要 100%的准确性，更关心计算速度，我们将使用NMS lib【5】，一个专门用于 ANN(近似最近邻)搜索的库。

这个库允许我们在索引中搜索给定向量的 k 个最近邻。我们可以调整 k 个最近邻的数量，以恢复计算时间与精确度之间的平衡。一旦我们得到了最近邻的列表，我们可以使用编辑距离进一步过滤，只保留相关的建议。

这为我们提供了以下输出(法语):

**python usage_correction.py 'langqge'**

编辑距离 1:
langqge:[' langage ']

编辑距离 2:
langqge : ['langages '，' lange '，' langé'，' langage']

结果

我们已经在通过我们的拼写错误生成器生成的语料库(大约 4k 个句子)上测试了我们的模型。我们的衡量标准是准确性，我们将准确性定义为在候选列表中找到正确单词的百分比。

在整个语料库中，chars2vec 模型的准确率为 85%，而标准语音算法的准确率约为 40%。结合这两种方法，我们有 90%的准确率。主要的瓶颈是 4 个字符或更少的单词，它们的性能不好。

这是意料之中的，因为:

那么大的单词在短编辑距离内有很多邻居。
3 个字母的单词中的打字错误比 10 个字母的单词更有影响力，这使得模型更难在向量空间中正确地映射单词。

校正选择

虽然我们前面的例子直接给出了我们想要的答案，但在编辑距离内经常有几个候选人，必须做出选择。

我们尝试了两种不同的方法:

概率性:使用建立在大型语料库上的频率列表，选择最常用的词。明显的缺点是一些不常用的单词可能永远不会被选择，虽然这种方法非常简单，但却提供了很好的准确性。
语义:根据候选词与句子中周围单词的语义相似性对候选词进行排序。这可以通过取一个预先训练的跳格词 2Vec 并计算嵌入的候选词和周围词(或整个句子)之间的平均距离来完成。虽然计算量很大，但这对于具有良好语义的单词给出了非常好的结果，尽管对于可以在任何上下文中使用的单词如“there”、“I”、“are”不是非常有效。

根据经验，我们发现语义方法对于较长的、不常用的单词非常有效，而概率方法对于较短的单词更好。将这两种方法与手工制作的规则相结合，我们在随机生成的语料库上获得了大约 70 %的正确率。

未来工作:N-grams 令牌

理想的方法是将两者结合起来，而不是在语义和频率之间进行选择。这可以通过使用单词 N 元语法的频率表来实现。

为了建立这些表，在非常大的语料库上对 N 个单词的连续序列进行计数和编译。对此可用的最佳资源是 谷歌图书 N-gram【6】**，它是通过分析各种语言的大约500 万本图书而构建的。****

‘Spelling Correction’ bi-gram occurrences

原始数据可通过此链接【7】获得，尽管由于文本数量庞大，下载并将其编译成可用状态需要大量时间。

结论

使用字符级嵌入可以获得良好的整体性能，尤其是对于较长的单词。通过手工制作的预处理规则和适当的候选项选择，这为现有的拼写校正解决方案提供了一种体面的替代方案。

进一步的工作将包括与预先存在的流行解决方案和 n-gram 令牌的使用适当的基准。在此期间，这个包可以免费试用:char 2 vec【1】。

[1]https://github.com/Lettria/Char2Vec

[2]https://en.wikipedia.org/wiki/Phonetic_algorithm

[3]https://norvig.com/spell-correct.html

https://github.com/wolfgarbe/SymSpell

https://github.com/nmslib/nmslib

https://books.google.com/ngrams/

[7]http://storage . Google APIs . com/books/n grams/books/datasetsv 2 . html

利用深度学习嵌入图

原文：https://towardsdatascience.com/embedding-graphs-with-deep-learning-55e0c66d7752?source=collection_archive---------9-----------------------

稀疏表示是分类器的天然杀手。当前的图形数据结构，如邻接矩阵和列表，都受到这种稀疏性的困扰。本文将讨论矩阵分解、DeepWalk 和 Node2Vec 等技术，这些技术将稀疏图数据转换成低维连续向量空间。

Converting Adjacency Matrices to low-dimensional continuous vector spaces.

This diagram shows the results of embedding a graph on the left into a 2-dimensional representation which can be plotted and clustered based on metrics such as Euclidean distance

历史上，矩阵分解一直是降低图形数据维数的流行方法。这包括 SVD(奇异值分解)和 MDS(多维标度)等技术。这些技术的问题在于，它们本质上具有矩阵乘法的运行时间(通常为 n，尽管是 n^(2.37)和 n^(2.77，这些都可以通过诸如库珀史密斯-维诺格拉德或斯特拉森算法之类的巧妙技巧来实现。

对于许多问题来说，n 次运行时间并不太可怕。然而，对于有数千甚至数百万用户的图形表示来说，这是灾难性的。此外，当新用户和连接添加到图表中时，必须重新计算。twitter 转发或媒体关注者等社交网络图是动态的，不断发展的。

我们可以使用深度学习，而不是使用矩阵分解来表示图形！

DeepWalk(链接如下)是第一篇优雅地阐述深度学习用于表示图的论文之一。

[## 深度行走:社交表征的在线学习

我们提出了 DeepWalk，一种学习网络中顶点潜在表示的新方法。这些潜在的…

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

DeepWalk 的灵感来自于图形表示和文本标记之间的相似性。天真地说，文本标记被编码为一个热点向量。例如，你可以用一个很长的向量来表示词汇表的大小，并为每个单词保留一个索引。单词“tiger”的编码如下:

One-hot encoding of text
[ 0 0 .. 0 0 1 0 0 .. 0 0 ] = "tiger"

自然，这些文本的稀疏表示破坏了下游任务(如情感预测)的分类模型。拯救者是跳格模型的引入(如下图所示):

Skip-gram 模型的工作原理是在句子之间滑动上下文窗口，并建立一个深度神经网络，该网络将单词标记作为输入，并将其映射到上下文窗口中出现的其他单词的预测。中间表示(在上图中表示为“投影”)是文本标记的低维表示。

DeepWalk 采用了这个想法，并将其扩展到图形数据。然而，文本数据自然包含某种非常适合上下文窗口的结构。DeepWalk 的作者通过随机行走构造邻域来模拟这种结构，因此得名“DeepWalk”。

上图用于描述随机漫步。从节点“Connor”开始，我们以概率 a、b、c 和 d 前往 Erika、Daniel、Ben 或 James。在 DeepWalk 中，a = b = c = d，但在 Node2Vec 中，这些概率在整个行走过程中都是参数化的。

沿着图随机行走会产生如下邻域:

Examples of Vertex Neighborhoods
(Connor, James, Jon, Bob, Joe)
(Connor, James, Jon, James, Connor)
(Connor, Erika, Connor, Daniel, Connor)

然后，上下文窗口滑过这些邻域，并训练一个跳格模型。

训练跳格模型的两个重要想法是分层 Softmax 和负采样。该图像突出了分层 Softmax 的思想。

Image taken from Galina Olejnik’s explanation: “Hierarchical softmax and negative sampling: short notes worth telling” which can be found on towards data science: https://towardsdatascience.com/hierarchical-softmax-and-negative-sampling-short-notes-worth-telling-2672010dbe08

想象一下一个 facebook 网络，其中有数百万用户需要预测顶点邻域。这将导致 softmax 层具有数百万个隐藏单元。这种灾难可以通过在二叉树中构造顶点空间并预测沿树的路径来避免。例如，如果网络中有 8 个用户，那么只需要 3 个值就可以从根节点遍历到任何一个单独的节点。

下一个想法(在 Word2Vec 中是至关重要的想法)是负采样。负采样基本上抛弃了直接预测上下文窗口中的单词的思想，而是将上下文预测任务视为二元分类问题。一旦你有了一个上下文对，你就随机抽样否定对，然后让模型标注这个单词是否出现在上下文中。

Example of negative sampling, coffee and Gorilla do not appear in the context window and are thus labeled as ‘0’ in the binary classification task.

另一个在 DeepWalk 上构建的有趣的论文是 Node2Vec(链接如下):

[## node2vec:可扩展的网络特征学习

网络中节点和边上的预测任务需要在学习所使用的工程特征方面进行仔细的努力

arxiv.org](https://arxiv.org/abs/1607.00653?context=cs)

Node2Vec 分解了使用随机行走来构造顶点邻域的思想。首先看两种遍历图形的极端方法，面包优先和深度优先搜索:

他们发现，如果你在深度优先搜索中遍历节点，得到的嵌入将捕捉到同质性。同向性指的是具有小的最短路径距离的节点应该在新的表示中彼此靠近地嵌入。他们还发现，如果在广度优先搜索中遍历节点，得到的嵌入将捕获结构等价。上图中的结构等价很容易解释，尽管 u 和 s6 没有共享任何邻居，但它们都是各自社区的中心。

Node2Vec 的作者因此建议将随机游走参数化，以便它可以构建更多的语义顶点邻域:

总之，本文介绍了 DeepWalk 和 Node2Vec，并展示了它们如何使用深度学习将图形嵌入到低维表示中。与必须重新计算的矩阵分解方法相比，跳跃图模型方法具有适应网络变化的优点。感谢您的阅读，如果您想回顾这篇文章，请查看下面的视频！

无嵌入深度学习 NLP 模型

原文：https://towardsdatascience.com/embeddings-free-deep-learning-nlp-model-ce067c7a7c93?source=collection_archive---------20-----------------------

什么是单词嵌入

Photo by Edward Ma on Unsplash

单词嵌入(例如 word2vec，GloVe)在几年前被引入，并从根本上改变了 NLP 任务。有了嵌入，我们不需要在大多数 NLP 任务中导致非常高维特征的一键编码。我们可以用 300 个维度来代表超过 100 万个单词。

不同种类的嵌入，如字符嵌入，句子嵌入(如跳读和推断)，上下文嵌入(如 ELMo 和 BERT )是近年来发展起来的。我们一直都需要嵌入层吗？有时这可能不可行，因此 Ravi S .和 Kozareva Z .引入了无嵌入深度学习模型。

设备上

我们可以在云中或内部轻松分配 1 GB 内存和 16 个 CPU 来部署 sexy 模型。我们不需要牺牲模型准确性来减少模型占用空间，也不需要在大多数企业级基础架构中产生大量的大型模型。

有时，我们别无选择，只能将模型部署到设备，而不是利用云基础架构。原因可以是

Sensitive Data:数据可能无法从设备发送到云端
Network:高速网络可能无法覆盖。

因此，如果我们将模型部署到智能 Swatch 或物联网设备等设备，则需要一个非常小的模型。没有人想在你的 Android Wear 操作系统中加载 1 GB 的型号。将模型部署到设备时面临的挑战:

Small memory footprint
Limited storage
Low computational capacity

自治神经网络

因为目标是将模型部署到小型设备。它不能是高资源需求的。因此，SGNN 的目标是:

Tiny memory footprint:加载预训练嵌入时没有初始化。
On-the-fry:将输入文本实时转换为低维特征。

投影神经网络

Ravi S .和 Kozareva Z .利用投影神经网络模型架构来减少内存和计算消耗，而不是使用具有高占用空间的原始神经网络。

其思想是在训练阶段训练两个神经网络(即训练器网络和投影网络)。全网优化教练机网络损耗、投影网络损耗和投影损耗。

Projection Neural Network Architecture (Ravi S. 2017)

模型架构

SGNN Model Architecture (Ravi S. and Kozareva Z., 2018)

On-the-fry Computation:将(函数 F 和 P)文本实时转换为中间结果和项目层，无需查找预定义的矢量。
Hash Function Projection:通过修改版本的位置敏感散列 (LSH)将高维特征减少到低维特征，这允许将相似的输入投射到相同的桶。
Model Optimization:在投影层使用二进制特征(0 或 1)实现非常低的内存占用。

实验

Ravi S .和 Kozareva Z .通过Switchboard Dialog Act Corpus (SwDA)和ICSI Meeting Recorder Dialog Act Corpus (MRDA)对 SGNN 进行了评估，结果非常好。

SwDA Data Result (Ravi S. and Kozareva Z., 2018)

MRDA Data Result (Ravi S. and Kozareva Z., 2018)

拿走

越来越多复杂的模型架构被发布，以在不同的学科中实现最先进的结果。然而，它可能不适合小型设备，如物联网设备或移动设备，因为这些设备中资源有限。
当交付一个令人惊叹的模型时，准确性并不是唯一的关注点。在某些情况下，必须考虑速度和模型复杂性。我们可能需要牺牲精确性来得到一个轻量级的模型。

关于我

我是湾区的数据科学家。专注于数据科学、人工智能，尤其是 NLP 和平台相关领域的最新发展。你可以通过媒体博客、 LinkedIn 或 Github 联系我。

参考

拉维..2017. ProjectionNet:使用神经投射学习高效的设备上深度网络。

拉维 s 和科扎列娃 z，2018。用于设备上短文本分类的自治神经网络。

在非 NLP 上下文中嵌入 Word2Vec 详细信息

原文：https://towardsdatascience.com/embeddings-with-word2vec-in-non-nlp-contexts-details-e879b093d34d?source=collection_archive---------12-----------------------

Photo by Charles Gao on Unsplash

探索使用基于 Word2Vec 的模型在业务上下文中创建项目嵌入的细节。

本文档要求熟悉 wor2vec[1，2，3]类模型和深入学习的文献。

在本文档中，我们将探讨在非 NLP 业务上下文中使用 Word2Vec 类模型创建嵌入向量的细节。我们将使用 Instacart Dataset[4，31]创建产品嵌入，评估模型体系结构/参数，并将生成的嵌入用于项目/购物篮相似性/互补性预测。

示例代码[31]可从 Gensim 获得。

为什么是 Word2Vec？

正是计算效率、可扩展性和“带负采样的 SkipGram”(SGNS)体系结构[2]使它变得特别。当您还将 SGNS 可视化为双编码器模型[5]时，正是输入层的易扩展性使其更加特殊。

对 SGNS 体系结构和参数有扎实的了解是:

评估业务上下文中的嵌入创建[6]
在进一步的下游模型/任务中使用这些嵌入[12，13]
评估其他嵌入模型(Node2Vec、Graph 神经网络、Transformers、FastText、Bert…)。

为什么要用 Word2Vec 创建嵌入？

大家可能已经知道，嵌入可以作为具有不同输入和输出的复杂多层监督模型的副产品来生成。这不是最佳的嵌入生成模型。原因何在？

您希望嵌入能够真正反映数据集中存在的目标/业务功能(例如，协作过滤)。要实现这一点，您可能希望模型中的嵌入参数仅参与模型输出的计算，而不涉及其他层或参数。在 SGNS 模型中，唯一的参数是嵌入参数，而模型输出只是 Target(In)和 Context(Out)嵌入参数的点积。所以你的目标函数仅仅用这些嵌入参数来表示。这是将目标函数语义注入到嵌入向量参数中的最佳方式；因此，您可以按原样有效地使用/评估嵌入，或者将它们用作其他下游模型的输入。

相反，在具有附加输入参数或嵌入层之上的层的模型中，目标函数与嵌入参数和模型中的其他参数一起表示。因此，在这种情况下，仅评估嵌入参数(例如，嵌入向量空间中的相似性)将是目标函数的次优表示。

从技术上来说，并加以总结；在网络中，您不希望将具有可学习参数的附加层放在嵌入层之上(或附近)。在嵌入层的上方应该有相似性函数(例如，点积> sigmoid)。见下文。

Embedding Generation Model Architectures

作为补充说明；与上述架构相比，对于一些业务案例，您可能希望您的嵌入反映多个任务(例如，点击概率和喜欢概率)。如果任务是相关的，你可以通过创建多任务学习模型的嵌入来实现更好的概括[22，23，24]。选择取决于您的架构设计。

非 NLP 设置中的 word 2 vec

Word2Vec 和 Doc2Vec 的非 NLP 改编的标志性论文有；分别是 Prod2Vec[7]和 Meta-Prod2Vec[8]。您可以嵌入任何对象，只要您可以为该对象定义相应的上下文/环境；无论是顺序的(例如搜索日志、产品交互序列[7])还是图表9，10，27。正确定义你的上下文的能力[11]是你的模型最关键的部分，其次是你的其他 SGNS 参数。

根据订单生成产品嵌入(Instacart 数据集)

Instacart 数据集[4]包含来自 200，000 多个 Instacart 用户的超过 300 万份杂货订单，其中每个订单包含一系列购买的产品。我们将为每个产品创建嵌入向量。我们将不使用任何产品/用户侧信息，并且仅将数据集中固有的协同过滤语义嵌入到嵌入向量中。尽管这些生成的产品嵌入可以单独用于对产品相似性/互补性和当前/下一篮子/项目推荐进行建模；理想情况下，为了获得更高的模型精度，您应该考虑具有附加输入功能的更高级的模型。与检索/排名架构一样，您也可以简单地考虑并使用这些嵌入作为检索阶段模型(向量相似性搜索),并进一步使用选择的嵌入作为具有附加输入特征的更复杂的排名模型的输入。(检索/排名模型[12])。

对偶嵌入空间

SGNS 为每个对象学习两个不同的嵌入向量；入和出向量(也称为目标和上下文向量)。为什么每个对象需要两个不同的向量？许多人在下游任务[26]中通过平均输入和输出向量来使用单个向量，或者丢弃输出向量而只使用输入向量。还可以通过在训练时在模型中使用共享嵌入参数层来学习单个嵌入向量(具有共享参数的暹罗网络[25])。

那么为什么要为每个对象创建两个单独的向量呢？让我们检查技术和逻辑推理。

技术:让我们把心态从 NLP 转移到 Instacart 数据集；“词”变成了“产品”，“句”变成了“订单筐”。产品的上下文是当前订单篮中的其他产品。对于产品“一袋香蕉”，考虑我们对目标(入)和上下文(出)使用相同向量的情况。“一袋香蕉”在语义上不会出现在其自身的上下文中(上下文是订单篮)。通过对“一袋香蕉”使用相同的向量 v；分配一个低概率的 p(“一袋香蕉”|“一袋香蕉”)是不可能的，因为给 v v 分配一个低值是不可能的。

逻辑:使用双重输入输出向量使我们能够评估产品在目标或上下文环境中的概率。因此，我们可以计算乘积相似性(输入向量中的余弦相似性)或乘积互补性(输入和输出向量之间的余弦相似性)。最终，这种“双重嵌入空间”架构形成了用于生产的更高级的相似性/互补性预测模型的基础[16，17，18，19，20]。

Word2Vec Model in Tensorflow(Also refered as Dual Encoder Model, Siamese Networks or Dual Tower Networks)

模型参数

让我们评估 SGNS 参数；

窗口大小:设置窗口大小取决于任务。在 Airbnb 案例[11]中，列表嵌入是通过用户的列表点击会话序列生成的，在会话中被连续点击的列表可能比在会话中第一个和最后一个被点击的列表在语义上更相关。因此，设置一个小的窗口大小(3-6)可能适合于缩小序列中的相关性窗口。数据越多，可以使用的窗口越小。

然而，在 Instacart 数据集的情况下，订单购物篮中的产品与购物篮中的所有其他产品相关，因为我们的目标函数是“购物篮级别”内的相似性/互补性预测。因此，我们的窗口大小是每个订单的篮子大小计数。作为一个额外的理论说明，如果您的数据集足够大，并且如果您在每个时期的订单篮中打乱产品的顺序，您可以使用较小的窗口大小；并且可以实现与使用更大的窗口尺寸相同的结果。

数据集生成:目标上下文 ( In-Out)数据对是使用窗口大小参数从数据集构建的。对于每个目标，您可以为以下目标向数据集添加额外的数据对:

添加目标元数据以实现更好的泛化(Meta-Prod2Vec)[8]。例如，目标产品类别
将其他对象嵌入到相同的嵌入空间中，例如品牌[8],例如目标品牌
添加额外的目标-上下文对以影响或添加额外的关联到嵌入向量[11]

纪元:纪元的数量对结果没有边际影响，您可以通过离线收敛评估轻松决定。但是，请注意，原始 Word2Vec 代码[36]和 Gensim 等库不使用小型批处理(没有小型批处理，模型参数会随数据集中的每个数据更新)，因此与使用小型批处理的模型相比，增加历元数不会产生相同的效果。

候选采样:候选采样算法实现了高效的任务学习架构，而无需计算整个标签类的完整 softmax，29]。由于 SGNS 使用负抽样方法[2]，抽样分布生成和相关抽样参数在建立成功的 SGNS 模型中起着至关重要的作用。那么，如何设置负采样架构呢？

一般采样-使用采样分布参数从相同的输入数据集中提取负样本(详见下文)。
特定于上下文的采样—使用目标上下文选择阴性样本。在 Instacart 案例中，对于特定产品，您可以从相同的产品类别/通道中选择阴性样品。这种“硬否定”技术使模型能够更快更好地收敛。然而，你需要在这方面投入资源，因为你需要能够为每个目标选择否定。可以在小批量训练期间检索负分布，或者可以预先生成静态负分布数据集。这种选择取决于您的培训硬件、分布式培训架构和成本。

负采样噪声分布参数( α ): 使用频率平滑参数(α)从您的分布中采样负样本，其中项目的频率被提升到α的幂。使用α，您可以调整选择流行或稀有物品作为否定的概率。

α=1 是均匀分布-使用数据集中的原始项目频率。
0
α=0 is unigram distribution — item frequency is 1 in dataset.
α<0 — low-frequency items are weighted up.

阴性样本数(k): 对于我们抽样分布中的每个目标，选择 k 个阴性样本。在下一节中，我们将评估 k 和α之间的相关性。

评估-订单篮中的下一个产品预测

我们将使用 Instacart 数据集，通过预测当前订单篮中的下一个商品来评估模型参数(k，α)。

样本代码[31]。(为清楚起见，使用 Gensim。)

在训练数据集上训练我们的模型之后，使用测试集，我们将在客户的订单篮子中隐藏一个随机产品，并通过使用篮子中的其他产品来预测隐藏的产品。我们将通过平均篮子中产品的目标嵌入来计算“篮子向量”。然后，利用计算出的“篮子向量”，我们将在上下文(外部)向量空间中搜索最近的项目，并将最近的项目作为推荐呈现。这个推荐基本上就是“这里有推荐给你的产品，以你已经放在篮子里的东西计算”。下面是采用不同 k 和α的命中率@10 分析。

Hitrate@10

我们看到高α (α=0.75，α=1)时精度低。直觉存在；在高α的情况下，流行的高频项目/用户支配分布，并降低模型的泛化能力。

随着α的降低，我们预测更多“不太频繁”的产品，这导致更好的模型得分，在α=0 时达到最大值。那么你会为这个模型选择哪个α呢？我会选择α=-0.5，因为尽管它的得分低于α=0，但我会认为它在在线评估中的得分会更高，假设它会为客户提供更多样化的推荐(意外发现，新奇)。

α和 k 的相关性:

与高α(α>0)；增加 k，会降低精度。直觉是；在高α的情况下，你推荐的是不能反映真实分布的流行/高频项目。如果你在这种情况下增加 k，你会选择更多的流行/高频项目作为负项，这导致进一步过度拟合不正确的分布。端点是；如果想推荐高α的热门单品，没必要进一步增加 k。

用低α(α<0)；增加 k，增加精度。直觉是；α值较低时，你会从尾部推荐更多不同的商品(不常见的商品)。在这种情况下，如果增加 k，就会从尾部选择更多的负样本，使模型能够看到更多不同的项目，从而很好地适应多样化的分布。端点是；如果你想推荐不同的低α的项目(新奇的，意外的),你可以进一步增加 k 直到它开始过量。

注意:不要忘记使用余弦距离进行评估(标准化向量的点积)。如果使用欧氏距离，可能会过分强调数据集中的频繁项；并且还可能由于您嵌入的初始化值而错误地表示不常见的项目。

进一步分析

到目前为止，我们已经分析了 Word2Vec。它的优势在于简单性和可伸缩性，但这也是它的弱点。使用 Word2Vec，不容易合并项目属性或项目-项目关系属性(图形结构)。这些额外的项目/交互特征对于更好的模型概括/准确性以及缓解冷启动问题是必需的。

是的，您可以使用 Meta-Prod2Vec [8]添加项目功能，使用图随机游走模型([9，10])也可以添加节点功能。但问题是，所有这些添加的‘特征’都是 id，而不是矢量；也就是说，它们是存储在后端的特性的 id。对于最先进的模型，您可能希望使用矢量作为项目特征(例如，编码的项目图像矢量)。此外，添加的项目特征没有加权，因此，每个项目属性对项目和模型输出的影响不会作为参数学习。

Word2Vec 的另一个缺点是它是直推式的；这意味着当一个新项目被添加到可用项目列表中时，我们必须重新训练整个模型(或者继续训练模型)。

使用相对较新的归纳图神经模型[34，35]，我们可以添加项目/关系特征作为可学习的向量，并且还可以获得训练模型看不到的新项目的嵌入。

图形神经网络研究是未来几年令人兴奋的领域。

结论

本文档的主要要点；

非自然语言处理环境下基于 Word2Vec 的模型分析。
模型参数分析，主要是α和 k 之间的相关性，用于业务上下文的相似性/互补性预测。

未来的文档将继续探索更高级的嵌入模型和下游深度模型。

[1]向量空间中单词表示的有效估计(【https://arxiv.org/abs/1301.3781】T2

[2]词和短语的分布式表征及其组合性(【https://arxiv.org/abs/1310.4546】

[3] word2vec 解释:推导 Mikolov 等人的负采样单词嵌入法(https://arxiv.org/abs/1402.3722)

[4]2017 年 Instacart 在线杂货购物数据集”(https://www.instacart.com/datasets/grocery-shopping-2017)

[5]万物嵌入:神经网络时代的搜索(https://youtu.be/JGHVJXP9NHw)

[6]Embeddings @ Twitter(https://blog . Twitter . com/engineering/en _ us/topics/insights/2018/embeddingsattwitter . html)

[7]收件箱中的电子商务:大规模的产品推荐(【https://arxiv.org/abs/1606.07154】T2

[8] Meta-Prod2Vec —使用边信息进行推荐的产品嵌入(【https://arxiv.org/abs/1607.07326】T4)

[9]深度行走:在线学习社交表征(https://arxiv.org/abs/1403.6652)

[10] node2vec:网络的可扩展特征学习(https://cs.stanford.edu/~jure/pubs/node2vec-kdd16.pdf)

[11]在 Airbnb 使用搜索排名嵌入的实时个性化(https://www . KDD . org/KDD 2018/accepted-papers/view/Real-time-personal ization-using-embedding-for-Search-Ranking-at-Airbnb)

[12]深度神经网络为 YouTube 推荐(https://ai.google/research/pubs/pub45530)

[13]推荐接下来看什么视频:多任务排名系统(https://dl.acm.org/citation.cfm?id=3346997)

[14] Word2vec 适用于建议:超参数问题(https://arxiv.org/abs/1804.04212)

[15]用于信息检索的神经模型(https://youtu.be/g1Pgo5yTIKg

[16]从购物篮和浏览会话中推断互补产品(https://arxiv.org/pdf/1809.09621.pdf

[17]使用四元组网络的互补相似性学习(https://arxiv.org/abs/1908.09928)

[18]推断可替代和互补产品的网络(https://arxiv.org/abs/1506.08839)

[19]用于互补产品推荐的上下文感知双表征学习(https://arxiv.org/pdf/1904.12574.pdf)

[20]指数家族嵌入(【https://arxiv.org/abs/1608.00778】T2

[21]大规模网络中的袖珍结构嵌入(【https://youtu.be/B-WFdubGkIo】T4)

[22]在 Pinterest 学习视觉搜索的统一嵌入(https://arxiv.org/abs/1908.01707)

[23]深度神经网络中多任务学习的概述(https://ruder.io/multi-task/)

[24]利用多门混合专家对多任务学习中的任务关系进行建模(https://www . KDD . org/KDD 2018/accepted-papers/view/Modeling-Task-Relationships-in-Multi-Task-Learning-with-Multi-gate-Mixture-)

[25] DeepFace:缩小与人脸验证中人类水平性能的差距( DeepFace:缩小与人脸验证中人类水平性能的差距)

[26] GloVe:单词表示的全局向量(https://nlp.stanford.edu/projects/glove/)

[27]图卷积网络:综合评述(https://rdcu.be/bW6sK)

[28]关于单词嵌入—第 2 部分:逼近软最大值(https://ruder.io/word-embeddings-softmax/)

[29]候选抽样-张量流(https://www.tensorflow.org/extras/candidate_sampling.pdf

[30]使用负采样优化 Skip-Gram 的计算效率(https://aegis 4048 . github . io/Optimize _ Computational _ Efficiency _ of _ Skip-Gram _ with _ Negative _ Sampling)

[31]https://github . com/boraturant/word 2 vec _ insta cart _ Similarity _ complementary

[32] CS224W:带图的机器学习(【http://web.stanford.edu/class/cs224w/】T2

[33]图的节点嵌入算法(【https://youtu.be/7JELX6DiUxQ】T4)

[34]大型图上的归纳表示学习(https://arxiv.org/abs/1706.02216)

[35]关系归纳偏差、深度学习和图形网络(https://deep mind . com/research/open-source/graph-nets-library)

https://code.google.com/archive/p/word2vec/

在 Jupyter 笔记本/Google 联合实验室上使用 Rasa 的紧急聊天机器人

原文：https://towardsdatascience.com/emergency-chatbot-using-rasa-on-jupyter-notebook-google-colaboratory-2be9059f87cc?source=collection_archive---------13-----------------------

Picture by the author

聊天机器人是典型的人工智能工具，广泛用于商业目的。

通过这篇文章，我的目标是解释紧急聊天机器人的目的，如何将一个想法发展成一个空机器人，作为一个有优点和缺点的堆栈，以及为什么我使用 Jupyter 笔记本来解决它。

在 2018 年夏天，我和另外两个家伙有了建造聊天机器人的想法，尽管在最初的几个月合作之后，我已经和 Rasa 单独进行了这个项目。我的紧急聊天机器人的想法是在夏天意大利发生恶劣天气悲剧后产生的。在这些情况下，人们需要紧急帮助，同时他们也处于恐慌状态。因此，首先，紧急聊天机器人将是一种在危险情况下使用的社交工具，开发技术将有助于及时挽救生命。也许有机会在一起出售保险的应用程序中部署这个紧急聊天机器人。

我们开始用 python 编写一些脚本，但在那之后，我们发现了 Rasa，并决定使用这个框架，因为 Rasa 是一个用 python 编写的开源 NLP 工具包，具有预构建的架构，可以根据您的需要进行定制。Rasa Stack 是为短消息构建的，能够执行任务，所以只要有一个想法，你就可以开始用句子填充这个框架，形成用于训练你的机器人的数据集，然后你配置 NLU 模型，创建对话模式和对话的框架。

Picture by the author

为了这个项目，我遵循了"Justina petraiyte "Jupyter 笔记本的步骤。选择使用 Jupyter 笔记本电脑是因为它有助于数据科学家之间的工作共享，尽管不可能在生产中使用它来部署机器人，但可以在网络上共享笔记本电脑并在云上运行它。有几个工具，但谷歌合作实验室表现很好，是我的最佳选择。

要理解机器人如何工作，必须知道对话的基本流程:用户给出一个输入，代理解析这个输入并运行一个 NLP 任务，代理根据从对话中提取的实体给用户一个答案。

意图将用户输入映射到响应。它可以被视为对话中的一个对话回合。在每个意图中，都定义了用户话语、实体和如何响应的示例。

实体是用于从输入中识别和提取有用数据的关键字。意图让你的机器人理解特定用户输入背后的动机，而实体则用来挑选用户提到的特定信息，包括链接到实体的实体值

现在的问题是，Rasa 堆栈是如何工作的？

Rasa 框架分为 Rasa NLU 和 Rasa 核心 python 库。第一个是自然语言理解模块，用于意图分类和实体提取，目的是教会聊天机器人如何基于机器学习理解用户输入。

使用 Rasa Core，您可以通过训练基于深度学习设置的对话管理来教聊天机器人如何做出响应。

Picture by the author

当用户输入到来时，它被传递给 i 解释器(拉萨·NLU)，目的是提取意图、实体和其他结构化信息。后续步骤由 Rasa 核心管理。跟踪器用于在内存中存储对话历史，它维护对话状态。策略决定在对话的每一步采取什么行动。它是与一个特征器一起生成的，该特征器创建了跟踪器给出的当前对话状态的向量表示。最后，执行一个动作，向用户发送一条消息并传递一个跟踪器实例。

让我们开始紧急聊天机器人之旅吧！！！

看Rasa _ Emergency _ Chatbot _ Colab笔记本。

首先，让我们安装 Rasa 库:我已经使用了 Rasa NLU 0.12.3 和 Rasa 核心 0.9.6，虽然在此期间更新版本已经实现。

现在我们准备使用保存在“ nlu.md ”文件中的数据集开始自然语言理解过程(“# #”代表意图的开始)。

在该数据集中，用户输入示例按意图分组。在紧急聊天机器人中，数据集包含以下意图:

“问候”、“确认”、“紧急 _ 空中 _ 救援”、“紧急 _ 保险 _ 号码”、“紧急 _ 道路 _ 求助”、“紧急 _ 消防”、“紧急 _ 救护车”、“紧急 _ 警察”。

拥有六个实体:“警察”、“道路 _ 救助”、“救护车”、“空中 _ 救援”、“消防”、“保险”。

实体和实体值(同义)使用降价链接 syntex 进行标记:实体值。

在 Rasa NLU 模型中，传入消息由一系列组件处理。这些组件在所谓的处理流水线中一个接一个地执行。有用于实体提取、意图分类、预处理等的组件。每个组件处理输入并创建输出。

在文件“ config.yml ”中嵌入了处理管道:Spacy 库提供了标记化和词性，Spacy featuriser 为每个标记查找手套向量，并将这些集合起来以生成整个句子的表示。Scikit-learn 分类器训练支持向量机模型，ner_crf 训练条件随机场来识别实体。使用支持向量机是因为它们是短信的一个很好的分类器，正如 Kaggle competition 所展示的那样:“在煮什么？”。

用混淆矩阵对模型进行评估，并用一个新句子测试其性能。

Picture by the author

此时，Rasa 核心用于教导聊天机器人如何使用深度学习模型做出响应:在 Keras 中实现的 LSTM 神经网络。

在这一步中，两个文件是相关的:“ stories.md 和“ domain.yml ”。

第一个表示对话管理模型的训练数据:实际对话的草稿，包括用户的意图和实体以及机器人的动作。在一个典型的故事中:

“##”代表一个故事的开始；

“*”代表用户以意图形式发送的信息；

“-”代表机器人采取的行动。

动作是你的机器人作为对用户输入的回答而运行的表达式。在 Rasa 核心中，有三种类型的操作:

默认动作 (action_listen，action_restart，action _ default _ fallback)；
utter actions ，以“utter_”开始，用作发送给用户输入的消息；
自定义动作(任何其他动作)，可用于任意代码。

在紧急情况下，具有 API 的聊天机器人创建定制动作，该定制动作使聊天机器人能够根据用户输入为救护车实体、警察实体或消防实体检索答案。聊天机器人将通过从槽“组”中检索值来知道应该给出哪种类型的答案。

“ domain.yml ”代表对话的框架，它有预期的用户输入、机器人应该预测的动作、如何响应以及存储什么信息。

领域由五部分组成:意图、槽、实体、动作和模板。

在模板中有链接到机器人动作的消息。

插槽代表机器人的记忆，它们存储用户或外界收集的键值。在紧急情况下，聊天机器人槽通过返回动作中的事件来设置；由实体及其值表示的分类槽。

Picture by the author

现在，对话管理模型将被训练，创建一个代理，并包括决定在对话的每一步采取何种行动的策略。

用于训练历史的模型是长短期记忆(LSTM ),这是一种奇特的递归神经网络，基本上扩展了它们的记忆。由于有内部存储器，RNN 的算法是第一个记住输入的算法，这使得它非常适合处理顺序数据的问题。苹果 Siri 和谷歌语音搜索都使用它们。

经过 10-15 分钟的训练(取决于是否使用 GPU ),你就可以玩紧急聊天机器人了。

虽然 Rasa 有广泛的文档，但我很难找到 Rasa NLU 关于支持向量机实现的文档。Rasa 的另一个弱点是当机器人不理解用户输入时使用的回退操作，因此机器人应该向用户发送默认模板消息，并恢复到导致回退的用户消息之前的对话状态。

我还没有使用这种类型的行动，因为它没有以一种适当的方式工作，机器人将继续建议不正确的答案；网站上使用的 Rasa 机器人“Sara”也是如此。

尽管有这些缺点，我认为 Rasa 是非常通用的，有机会用许多工具将其部署到生产中，并不断发展。

特别感谢 Lorenzo Invernizzi 和 Frenk Locmelis 为这个项目做出的最初贡献。

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

我的 Github 库:https://github.com/claudio1975/chatbot

参考文献:

【https://github.com/RasaHQ/rasa-workshop-pydata-berlin

https://github.com/RasaHQ/rasa-workshop-pydata-dc

https://arxiv.org/abs/1712.05181

https://rasa.com/docs/

使用 Flask +容器化+在 AWS 上部署的机器学习 Web 应用程序

原文：https://towardsdatascience.com/emojify-machine-learning-web-app-using-flask-containerization-deployment-on-aws-14a9bdb75535?source=collection_archive---------8-----------------------

构建和部署机器学习 web 应用的直观指南。

PC: Unsplash

在本教程中，我将分享我在使用 Flask 构建一个简单的端到端机器学习 web 应用程序并随后将其部署到 AWS 上的学习。只有当用户可以通过 web 应用程序交互地使用 ML 模型时，它的目的才能得到很好的服务。传统的 Jupyter 笔记本电脑只提供了一个交互式控制台，对于将它应用到 web 应用程序上没有多大用处。

Flask 是一个用 Python 编写的微框架，可以帮助我们快速开始构建应用程序。我们将使用 Keras 中的长短期记忆(LSTM)单元来训练来自深度莫吉数据集的数据。然后，我们将最终模型保存为 HDF5 文件，并在以后用于预测目的。最终的应用程序将像这个链接中提到的那样工作。让我们更深入地探讨如何使用 Docker 容器在 AWS 中构建和部署整个 web 应用程序。这个项目的代码可以在我的 Github repo 中找到。

内容

数据

2.数据提取和处理

3.嵌入层

4.双向 RNN 模型

5.训练模型

6.构建 Flask 应用程序

7.使用码头集装箱的集装箱化

8.将 Docker 映像推送到 AWS ECR

9.在 AWS EC2 上部署 Flask 应用程序

数据

我们将使用 深度莫吉 数据集，特别是 PsychExp 数据集来构建模型。数据集由 7840 个样本组成，其中每一行包含一条文本消息和编码为一个热点向量的标签。这些标签属于这 7 类中的一类——快乐、恐惧、愤怒、悲伤、厌恶、羞耻、内疚。数据集中的一行示例如下:[ 1\. 0\. 0\. 0\. 0\. 0\. 0.] I am very happy today.

数据提取和处理

Extracting text and labels from the pickled dataset.

在这个函数中，我们从 pickle 文件中提取文本和标签，然后将它们写入一个文本文件。

Separating Labels and Texts

在读取文本文件函数中，我们返回一个包含文本消息和标签的列表。然后，我们将消息和标签分离到单独的列表中。

对于任何 ML 模型，我们都必须以数字格式输入数据，以便进行处理。类似地，为了在 7 个类别中分类我们的输入文本，我们必须将我们的输入句子转换成单词向量表示。为此，我们将使用预先训练的 50 维手套单词嵌入。

上面的“read_glove_vector”函数返回给定单词的索引列表、给定索引的单词以及每个单词对应的 50 维表示。

嵌入层

在构建嵌入层之前，让我们知道为什么要使用嵌入层。让我们考虑我们有 1000 个单词的文本语料库。文本中每个单词的一个热编码将是具有 999 个零和 1 个非零值的向量。这些向量非常稀疏，不太适合大型数据集。在单词嵌入中，单词由密集向量表示，其中每个向量是单词在连续向量空间中的投影。因此，单词嵌入帮助将单词投影到一个更低的维度，而不是将单词投影到一个更高的维度。此外，单词嵌入帮助我们捕捉单词之间的关系，否则使用一个热编码向量难以捕捉。让我们看看如何为我们的应用程序实现这个嵌入层:

这里，嵌入层的第一个参数是手套单词嵌入中的单词总数，第二个参数是每个单词在向量空间中表示的维度。

双向 RNN 模型

双向 RNN 有两个网络，一个正向训练信息，另一个反向训练信息。因此，这些模型可以访问过去和未来的数据，而标准的 LSTM 模型只能访问过去的数据。

Bi-Directional LSTM

让我们在使用 Keras 的应用程序中看到它的实现。

LSTM Model

在这里，我们正在构建一个深度递归神经网络，它包含一个具有批量归一化和丢失的双向 LSTM。此处使用 Softmax 激活来获得跨 7 个类别的概率分布。

这是一个简化的图像，显示了我们整个 LSTM 模型的架构。

Architecture of our Neural Network

训练模型

我们将使用分类交叉熵作为损失函数，因为我们将在 7 个类别中对输出进行分类。我们将试图在每个时期最小化这种损失，以便它在测试数据上表现良好。Adam optimizer 用于帮助我们加快训练过程。准确性是我们在这里用来评估模型的性能指标。

X_train = pad_sequences(train_tokenized, maxlen = maxlen)
X_test = pad_sequences(test_tokenized, maxlen = maxlen)model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])model.fit(X_train, np.array(y_train), epochs = 30, batch_size = 32, shuffle=True)

然后，我们将使用 Tensorflow 的 save_model 来保存 Keras 模型，以便我们稍后可以加载它来给出预测。经过 30 个周期的训练，准确率达到了 86%。

model.save('emoji_model.h5')
model = load_model('emoji_model.h5')

构建 Flask 应用程序

首先我们必须使用命令- **pip install flask** 安装 flask。然后创建一个名为 application.py 的文件，这是我们应用程序的主要后端文件。

首先，我们必须实例化 Flask 类的一个对象。然后，我们使用 load_model 函数加载已经训练好的模型。我们还为文本标记器保存了一个 pickle 文件，以便它可以用于标记未来的文本输入。有两条路线-预测和更新。“预测”路由接收输入文本字段中输入的值，我们使用 tokenizer 对象对文本进行标记。我们使用加载的模型对输入文本进行预测，然后以 JSON 格式返回响应。“更新”路线用于在预测值不正确时更新预测值，以便针对新输入对模型进行微调。虽然这可能不是在大规模系统中更新模型的正确方法，但我想尝试一下模型再训练是如何工作的。为了返回预测的正确表情响应，创建了以下 Javascript 文件。

另一个 Javascript 文件可以通过从下拉列表中选择值来帮助我们进行更新操作，并向“update”路由发送 POST 请求来更新值。我不太擅长构建 UI，因此前端部分可以根据我们的需要进行更改。

我们将使我们的应用程序在主机 0.0.0.0 和端口 5000 上运行。我们也将在 Docker 文件中对此进行配置。这是在我们的 localhost 中运行后的最终应用程序的样子。

使用码头集装箱的集装箱化

Docker 是一个开源应用程序，允许用户使用容器创建、管理和部署应用程序。使用 Docker 运行的应用程序驻留在它们自己的环境中，并且拥有运行应用程序所需的依赖关系。Docker 可以使用以下链接 安装在 Mac 上。 安装 docker 后移动到我们终端中的应用文件夹。创建一个 docker 文件，指导 docker 安装依赖项并在构建 Docker 映像时执行其他命令。

上面的 docker 文件指示 Docker 从 Docker hub 安装 python，然后创建一个‘app’目录来复制我们 web app 的所有内容。然后它会安装 requirements.txt 文件中提到的所有包。则暴露端口 5000 以从容器外部访问应用程序。默认情况下，使用 CMD 命令运行 application.py 文件。我们将把 docker 图像命名为“flaskapp”。现在我们必须使用以下命令构建 docker 映像。

docker build -t flaskapp:latest .

“.”在这个命令的末尾，复制当前目录中的所有文件来构建镜像。然后，我们将使用上面创建的 docker 映像在端口 5000 运行 docker 容器。该命令如下所示:

docker run -p 5000:5000 flaskapp

通过在浏览器的端口 5000 上启动应用程序，检查应用程序是否可在容器外部访问。

将 Docker 映像推送到 AWS ECR

我假设在 AWS 中已经创建了一个帐户。如果没有，任何人都可以按照这个链接 免费上手。 我们必须使用**pip install awscli --upgrade --user**在桌面上安装**awscli**，以便直接从终端执行 AWS 中的操作。我们必须从我们的终端使用命令**aws configure** 来配置我们的 AWS 凭证，在这里我们输入我们的访问密钥 ID、秘密访问密钥、默认区域和输出格式。

我们将使用 AWS 弹性容器注册表来存储和部署我们的 docker 容器映像。为了存储 Docker 图像，我们必须首先在 AWS ECR 中创建一个存储库。这是使用以下命令完成的:

aws ecr create-repository --repository-name ml_flask_app

然后，为了获得访问 AWS ECR 的权限，我们输入以下命令-

$(aws ecr get-login --region region_name --no-include-email)

然后，我们在本地用创建的存储库标记我们的 flaskapp 容器。在这里，每个用户的 account_id 和 region name 是不同的。

docker tag flaskapp:latest aws_account_id.dkr.ecr.region_name.amazonaws.com/

然后，我们必须将本地 docker 映像推送到在 AWS ECR 中创建的存储库中。

docker push aws_account_id.dkr.ecr.region_name.amazonaws.com/ml_flask_app

在 AWS EC2 上部署 Flask 应用

将图像推送到 AWS ECR 后，我们必须创建一个 EC2 实例，在其中我们可以为 web 应用程序提供服务。AWS 在免费层范围内提供了许多实例，我们可以利用这一点。我们将启动一台 Linux 机器，其中大部分配置都是默认设置的，只有安全组进行了如下更改:

SSH ->仅从我们的 IP 和

自定义 TCP ->端口 5000。

这些安全组规则是我们的 web 应用程序运行所必需的。一旦实例启动并运行，我们可以通过在终端中的‘PEM’文件所在的同一文件夹中输入以下命令来 ssh 到实例中。

ssh -i "test_ml_app.pem" [ec2-user@ec2-12-345-67-89.us-east-1.compute.amazonaws.com](mailto:ec2-user@ec2-18-191-94-75.us-east-2.compute.amazonaws.com)

一旦我们登录到实例中，我们可以使用下面的命令安装 docker 并启动它。

sudo yum install -y docker
sudo docker service start

我们必须像以前一样通过再次输入 aws configure 命令来配置 AWS 凭证。然后输入以下命令，以便添加 ec2 用户来在 Linux 机器上执行 docker 命令。

sudo groupadd docker
sudo gpasswd -a ${USER} docker
sudo service docker restart

然后退出该实例，并再次使用 ssh 进入该实例。运行以下命令从 AWS ECR 中提取 docker 映像，然后在 Linux 机器中运行 docker 容器。

docker pull account_id.dkr.ecr.region_name.amazonaws.com/ml_flask_app_:latestdocker run -p 5000:5000 account_id.dkr.ecr.region_name.amazonaws.com/ml_flask_app

从实例详细信息页面获取实例的公共 IP，并在浏览器中启动时添加端口 5000。瞧啊。！！这款应用终于在 AWS 上运行了。

让我们检查一些给出错误预测的输入。

现在，我们将为上述输入更新标签为“Sad”的模型。

在那里！！该模型已经更新了其对新输入文本的响应，并将尝试改进其对未来输入的预测。

因为这是我的第一个博客，我请求你们分享你们对这个博客的内容和质量的看法。如果有任何疑问，我非常乐意帮忙。你可以在 Linkedin @Sri ram Muralishankar上和我联系。

参考资料:

深度莫吉数据集-【https://github.com/bfelbo/DeepMoji/tree/master/data
Coursera 序列模型教程-https://github . com/kul bear/deep-learning-coursera/blob/master/Sequence % 20 Models/Emojify % 20-% 20 v2 . ipynb
AWS 文档-https://docs.aws.amazon.com/
码头文件-https://docs.docker.com/

情绪检测:一个机器学习项目

原文：https://towardsdatascience.com/emotion-detection-a-machine-learning-project-f7431f652b1f?source=collection_archive---------0-----------------------

一个关于情感检测的计算机视觉项目

情绪检测( n.):

识别人类情感的过程

如果有人给你看一张某人的照片，并让你猜猜他们的感受，你很可能会有很好的想法。如果你的电脑也能做到这一点会怎么样？如果它能变得比你更好呢？这似乎是一个荒谬的想法，对不对？

在我的上一篇博客(读作: 揭秘人工智能 )中，我说过我会解释一个项目，展示所讨论的概念是如何应用的。

下面的博客包含了我们在 InspiritAI 项目期间所做的一系列事情的回忆，虽然它确实显示了进行情绪检测所需的大量代码，但这绝不是训练模型的最快方法。使用多个 ML 和 AI 模型来查看它们之间的差异。

情绪检测的三个主要组成部分如下:

图像预处理
特征抽出
特征分类

面部检测:

人脸检测是情感检测中的一个重要步骤。它会删除图像中不相关的部分。这里有一种在图像中检测人脸的方法。

import dlib
import numpy as npfrontalface_detector = dlib.get_frontal_face_detector()def rect_to_bb(rect):
    x = rect.left()
    y = rect.top()
    w = rect.right() - x
    h = rect.bottom() - y
    return (x, y, w, h)def detect_face(image_url):
    try:
        url_response = urllib.request.urlopen(image_url)
        img_array = np.array(bytearray(url_response.read()), dtype=np.uint8)
        image = cv2.imdecode(img_array, -1)rects = frontalface_detector(image, 1)if len(rects) < 1:
    return "No Face Detected"for (i, rect) in enumerate(rects):
    (x, y, w, h) = rect_to_bb(rect)
    cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)plt.imshow(image, interpolation='nearest')
plt.axis('off')
plt.show()

另一种方法是使用 dlib 的预训练人脸检测器模型，该模型也将在下一点中使用。

面部标志:

面部标志是人脸图像上的一组关键点。这些点由它们在图像上的(x，y)坐标定义。这些点用于定位和表示面部的显著区域，例如眼睛、眉毛、鼻子、嘴和下颌线。

我们使用的面部标志模型是 Dlib 的预训练面部标志检测模型，它检测人脸上的 68 个二维点。

您可以像这样加载模型:

import dlib
import numpy as npfrontalface_detector = dlib.get_frontal_face_detector()landmark_predictor=dlib.shape_predictor('./shape_predictor_68_face_landmarks.dat')def get_landmarks(image_url):
    try:
        url_response = urllib.request.urlopen(image_url)
        img_array = np.array(bytearray(url_response.read()), dtype=np.uint8)
        image = cv2.imdecode(img_array, -1) except Exception as e:
        print ("Please check the URL and try again!")
        return None,None
    faces = frontalface_detector(image, 1) if len(faces):
        landmarks = [(p.x, p.y) for p in landmark_predictor(image, faces[0]).parts()] else:
        return None,None

    return image,landmarksdef image_landmarks(image,face_landmarks):
    radius = -1
    circle_thickness = 4
    image_copy = image.copy()
    for (x, y) in face_landmarks:
        cv2.circle(image_copy, (x, y), circle_thickness, (255,0,0), radius)
        plt.imshow(image_copy, interpolation='nearest')
        plt.axis('off')
        plt.show()

使用该模型后，您的输出应该如下所示:

在这个模型中，面部特征的具体标志是:

Jawline = 0–16
Eyebrows = 17–26
Nose = 27–35
Left eye = 36–41
Right eye = 42–47
Mouth = 48–67

区分两种情绪的一种方法是看这个人的嘴和眼睛是否张开。我们可以找到嘴部各点之间的欧几里德距离，如果一个人感到惊讶，这个距离会比他们没有惊讶时更大。

数据预处理

在使用数据之前，重要的是要经过一系列被称为预处理的步骤。这使得数据更容易处理。

我们将使用由五个情感标签组成的 fer2013 数据集的修改版本。

数据集存储在 CSV 文件中。CSV 文件中的每一行都代表一个实例。每个实例都有两个列属性:

以字符串格式存储的图像像素
目标标签的整数编码

共有 20，000 个图像平均分布在五种情绪中。这些图像是 48*48 灰度的裁剪图像。CSV 文件由以字符串形式存储的图像的扁平数组组成

The target labels are integer encoded in the csvfile. They are mapped as follows:0 — -> Angry
1 — -> Happy
2 — -> Sad
3 — -> Surprise
4 — -> Neutral

加载数据集

import pandas as pd
import numpy as np
import matplotlib.pyplot as pltlabel_map={"0":"ANGRY","1":"HAPPY","2":"SAD","3":"SURPRISE","4":"NEUTRAL"}df = pd.read_csv("./ferdata.csv")df.head()

该数据集包含图像的原始像素值。

拆分数据

正如上次讨论的那样，数据需要分成两个不同的集合:

训练集:算法会一遍又一遍地读取或“训练”它，以尝试和学习它的任务。
测试集:算法在这些数据上进行测试，看看它的效果如何。

from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(dataX, dataY, test_size=0.1,random_state=42,stratify =dataY)

使数据标准化

标准化是将不同的变量放在同一尺度上的过程。它重新调整数据，使平均值为 0，标准差为 1。这种转换以数据为中心。

from sklearn.preprocessing import StandardScalerscaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

线性模型

k-最近邻

KNN 是一种非参数学习算法，这意味着它不对数据的分布做出任何假设。我们使用点之间的欧几里得距离作为数据。

from sklearn.neighbors import KNeighborsClassifierknn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, Y_train)
predictions = knn.predict(X_test)

要确定模型的准确性:

from sklearn.metrics import accuracy_scoreprint(accuracy_score(Y_test, predictions)*100)

我们的准确率约为 50%，所以我们尝试了一些非线性模型。

您可以尝试将原始像素值输入到模型中，并查看它如何影响模型的准确性。

非线性模型

多层感知器

MLPs 是神经网络的一个子类。它们由一层或多层神经元组成。输入层是输入数据的地方，之后可能有一个或多个隐藏层。预测来自输出层。

from keras.models import Sequential
from keras.utils import to_categorical
from keras.layers import Dense, Dropout, Flatten, Activation
from keras.losses import categorical_crossentropy
from keras.callbacks import EarlyStopping, ModelCheckpoint
from keras.models import load_model
from keras.optimizers import Adam, SGDmlp_model = Sequential()mlp_model.add(Dense(1024, input_shape = (2304,), activation = 'relu', kernel_initializer='glorot_normal'))mlp_model.add(Dense(512, activation = 'relu', kernel_initializer='glorot_normal'))mlp_model.add(Dense(5, activation = 'softmax'))mlp_model.compile(loss=categorical_crossentropy, optimizer=SGD(lr=0.001), metrics=['accuracy']) checkpoint = ModelCheckpoint('best_mlp_model.h5',verbose=1,
monitor='val_acc', save_best_only=True,mode='auto')mlp_history = mlp_model.fit(X_train, y_train, batch_size=batch_size,
epochs=epochs, verbose=1, callbacks=[checkpoint], validation_data(X_test, y_test),shuffle=True)

我们使用像素的准确率大约是 50%，当我们使用面部标志之间的距离而不是像素值时，准确率有所提高。然而，我们想要更精确的模型，所以我们决定使用 CNN。

卷积神经网络

width, height = 48, 48X_train = X_train.reshape(len(X_train),height,width)X_test = X_test.reshape(len(X_test),height,width)X_train = np.expand_dims(X_train,3)X_test = np.expand_dims(X_test,3)cnn_model = Sequential()cnn_model.add(Conv2D(5000, kernel_size=(4, 4), activation='relu', padding='same', input_shape = (width, height, 1)))cnn_model.add(BatchNormalization())cnn_model.add(MaxPooling2D(pool_size=(3, 3), strides=(4, 4)))cnn_model.add(Dropout(0.2))cnn_model.add(Flatten())cnn_model.add(Dense(2000, activation='relu'))cnn_model.add(Dropout(0.2))cnn_model.add(Dense(5, activation='softmax'))checkpoint = ModelCheckpoint('best_cnn_model.h5', verbose=1, monitor='val_loss',save_best_only=True, mode='auto')cnn_model.compile(loss=categorical_crossentropy,
optimizer=Adam(lr=0.001, beta_1=0.9, beta_2=0.999), 
metrics=['accuracy'])cnn_history = cnn_model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, callbacks=[checkpoint], 
validation_data=(X_test, y_test),shuffle=True)cnn_model.save('cnn_model.h5')

为了提高性能，你可以改变下降，密集层的数量和激活功能。我们还使用名为 VGG 的 CNN 进行迁移学习，这是一种用于图像分类的预训练卷积神经网络。

E 估价

使用 VGG 得到的结果最好，其正确率约为 68–70 %,但即使是线性模型也做得非常好。虽然 50%的准确率看起来不算多，但这仍然比你随机选取一张图片和一个标签要高。在这一点上，你大约有 20%的几率是正确的。

然而，在这个特定的数据集中，VGG 的表现甚至比人类更好。CNN 和 MLP 之间的区别在于，CNN 提取他们自己认为重要的特征，而我们将像素或界标作为特征提供给 MLP。

更多关于 KNNs、CNN、MLPs 和其他基本机器学习主题的信息，请点击此链接。

特别感谢 Adeesh Goel 组织了这次令人惊叹的研讨会，查看 facebook 页面【InspiritAI】，感谢 Tyler Bonnen 担任如此出色的导师并指导我们完成该计划，并感谢我的团队成员 Khushi 和 Harsh。

基于图卷积网络的情感识别

原文：https://towardsdatascience.com/emotion-recognition-using-graph-convolutional-networks-9f22f04b244e?source=collection_archive---------9-----------------------

使用图形对对话进行分类

最近，深度学习在自然语言处理(NLP)方面取得了很大进展。随着许多新发明(如注意力和变形金刚)的出现，BERT 和 XLNet 等先进模型应运而生，许多任务(如文本情感识别)变得更加容易。本文将介绍一种新的方法，利用图形从对话中进行情感识别。

什么是情感识别？

简单地说，情绪识别(ERC)是对一项书面任务背后的情绪进行分类的任务。给定一段文字，你能说出说话者是生气、高兴、悲伤还是困惑吗？它在医疗保健、教育、销售和人力资源方面有许多广泛的应用。在最高层面上，ERC 的任务是有用的，因为许多人相信，它是构建能够与人对话的智能人工智能的垫脚石。

An example of using ERC to power a health assistant (image taken from [1])

目前，大多数 ERC 所基于的两个主要创新是递归神经网络(RNN)和注意力机制。LSTMs 和 GRUs 等 rnn 按顺序查看文本。当文本很长时，模型对开始部分的记忆会丢失。注意力机制通过对句子的不同部分进行不同的加权很好地解决了这个问题。

然而，RNNs+Attention 仍然很难从相邻序列和说话者(基本上任何对话的所有非常重要的部分)中考虑个性、主题和意图的上下文。再加上缺乏个性/情感的标记基准数据集，不仅难以实施，而且难以衡量新模型的结果。本文将总结最近的一篇论文，该论文通过使用一种相对较新的称为图卷积网络的创新解决了大部分问题: DialogueGCN:一种用于对话中情感识别的图卷积神经网络 [1]。

背景很重要

在对话中，上下文很重要。一个简单的“还好”可以表示“还好吗？”，“好的！”或者“好吧…”取决于你和对方之前说了什么，你现在的感觉如何，对方的感觉如何，紧张程度以及其他许多事情。有两种类型的上下文很重要:

顺序语境:一个句子在一个序列中的意义。这种语境处理过去的词如何影响未来的词、词的关系以及语义/句法特征。在 RNN 模型中，顺序上下文被考虑在内。
说话人层面的语境:说话人之间和说话人内部的依赖。这种语境涉及说话者之间的关系以及自我依赖性:即你自己的个性会改变并影响你在对话过程中的说话方式。

正如你可能猜到的，大多数模型很难考虑说话者级别的上下文。事实证明，使用图形卷积神经网络可以很好地模拟说话者级别的上下文，这正是 DialogueGCN 采用的方法。

用图形表示对话

一段对话中有 M 说话人/当事人分别表示为【1】p【2】，。。。，p【M】。每一个话语(有人发的一段文字)都表示为u【1】u【2】，。。。，【N】。ERC 的最终目标是准确地预测每个话语是高兴、悲伤、中立、愤怒、兴奋、沮丧、厌恶还是恐惧。**

整个对话可以构建成一个有向图:

A conversation graph with 2 speakers and 5 utterances. [CORRECTION IN BOTTOM RIGHT IMAGE: For the arrow going from U1 to U2, one of the labels should be W1->2, not W2->1]

G = (V，E，R，W)

话语是节点( V )。边是节点【E】之间的路径/连接。关系是边的不同类型/标签【R】。权重代表一条边的重要性【W】。
两个节点v【I】和v【j】之间的每条边都有两个属性:关系( r )和权重( w )。我们稍后会详细讨论这个问题。
图形是指向的。所以，所有的边都是单向的。从v【I】到v【j】的边缘不同于从v【j】到v【I】的边缘。

从图中可以注意到的一点是，每个话语都有一条边与其自身相连。这代表了话语与其自身的关系。用更实际的话来说，这就是一个话语如何影响说话者的思想。

上下文窗口

图形表示的一个主要问题是，如果一个会话非常长，那么一个节点可能有许多条边。因为每个节点都与其他节点相连，所以随着图形大小的增加，它的比例是二次方的。这在计算上非常昂贵。

为了解决这个问题，在 DialogueGCN 中，图形的边是基于具有特定大小的上下文窗口构建的。所以对于一个节点/话语 i ，只有过去的大小和未来的大小话语连接在一个图中(在 i- 大小到 i+ 大小范围内的任意节点)。

A context window of size 1 around the third utterance

边缘权重

使用注意函数来计算边权重。设置注意函数，使得对于每个节点/话语，输入的边权重总和为 1。边权重是常数，在学习过程中不会改变。

简而言之，边权重表示两个节点之间连接的重要性。

关系

边的关系取决于两个因素:

说话人依赖:谁说了 【我】 ？谁说出了v【j】？
时态依存:是【I】在【j】之前说出，还是反过来？

在一次对话中，如果有MM(说话人【j】)M(说话人【j】) 2(是否【I】【T57)****

我们可以列出上面示例图中的所有关系:

A table of all the possible relations in our example

这是同一张图，根据表格标注了边的关系:

Edges are labelled with their respective relation (refer to table above)

在我们例子中，我们有 8 种不同的关系。在高层次上，关系是 edge 的一个重要属性，因为在对话中谁说了什么以及何时说了什么非常重要。如果彼得问一个问题，珍妮回答，这与珍妮先说答案，然后彼得问问题(时间依赖)是不同的。同样，如果 Peter 问 Jenny 和 Bob 同样的问题，他们可能会有不同的回答(说话者依赖)。

将关系视为定义连接的类型，边权重表示连接的重要性。

模型

DialogueGCN 模型使用一种称为图形卷积网络 (GCN)的图形神经网络。

就像上面一样，所示的例子是针对 2 个说话者 5 个话语的图。

Figure 3 from [1]

在阶段 1 中，每个话语【I】被表示为特征向量，并被给予顺序上下文编码。这是通过在顺序上下文编码器中使每个话语通过一系列 gru 来完成的。阶段 1 不需要图形结构。具有连续语境的新话语表示为【g【1】……。g【N】文中。这是对 GCN 的输入。

在阶段 2 中，该模型构建了一个类似于上一节中讨论的图，并且将使用特征变换将说话者级别的上下文添加到该图中。具有连续语境和说话者层次语境的话语由【1】……h【N】表示。这是 GCN 的产量。

边和节点的外观差异(虚线与实线，不同的颜色)代表不同的关系。例如，绿色的g【1】到绿色的g【3】，用绿色的实边表示表中的关系 1。

特征变换—嵌入说话者级上下文

GCN 最重要的步骤之一是特征转换——基本上是 GCN 如何将说话者级别的上下文嵌入到话语中。我们将首先讨论所使用的技术，然后描述它的直觉来自哪里。

特征转换有两个步骤。在步骤 1 中，对于每个节点【h[I]，聚集相邻节点信息(上下文窗口大小内的节点)以创建新的特征向量【h[I]。

该函数可能看起来很复杂，但其核心只是将它想象为网络中的一层，具有由【0】和W【r】表示的可学习参数。添加的一个东西是常数c【I，r】它是一个归一化常数。可以提前设置，也可以用网络自己学习。

如前所述，边权重是恒定的，不会在过程中改变或学习。

第二步，同样的事情基本上再做一遍。聚集邻居信息，并将类似的函数应用于步骤 1 的输出。

Equation 2 (Step Two)

再次， W 和W【0】表示在训练过程中修改的可学习参数。

在高层次上，这一两步过程实质上是对每个话语的所有相邻话语信息进行归一化求和。在更深的层次上，这种两步转换植根于简单的可区分的消息传递框架 [2]。这项技术被从事图形卷积神经网络工作的研究人员用于关系数据建模【3】。如果你有时间，我强烈推荐你按照这个顺序阅读这两篇论文。我相信 DialogueGCN 的特性转换过程所需的所有直觉都在那两篇论文中。

GCN 的输出由h【1】表示…..【N】图上。

在阶段 3，原始顺序上下文编码矢量与说话者级别上下文编码矢量连接。这类似于将原始层与后来的层组合起来，以“总结”每一层的输出。

然后，连接的特征向量被送入全连接网络进行分类。最终输出是模型认为话语是不同情绪的概率分布。

使用具有 L2 正则化的分类交叉熵损失来完成模型的训练。使用这种损失是因为模型正在预测多个标签(情感类别)的概率。

结果

基准数据集

之前我们提到缺乏基准数据集。这篇论文的作者能够通过使用标记的多模态数据集(文本以及视频或音频)来解决这个问题，然后提取文本部分，并完全忽略任何音频或视频数据。

DialogueGCN 在以下数据集上进行评估:

IEMOCAP: 视频格式的十个不同说话者的双向对话。话语被标记为快乐、悲伤、中性、愤怒、兴奋或沮丧。
AVEC:人类和人工智能代理之间的对话。话语有四个标签:化合价([-1，1])、唤醒([-1，1])、期待([-1，1])和力量([0，无穷大])。
MELD: 包含电视剧《老友记》中的 1400 段对话和 13000 句话语。MELD 还包含补充的听觉和视觉信息。话语被标记为愤怒、厌恶、悲伤、喜悦、惊讶、恐惧或中性之一。

MELD 具有预定义的培训/验证/测试分割。AVEC 和 IEMOCAP 没有预定义的分割，所以 10%的对话被用作验证集。

DialogueGCN 与 ERC 的许多基线和最新模型进行了比较。一个特殊的艺术模型状态是 DialogueRNN 由同一论文的作者。

DialogueGCN vs. other models on the IEMOCAP dataset (table taken from [1])

在 IEMOCAP 的 6 个类别中的 4 个类别中，DialogueGCN 相对于包括 DialogueRNN 在内的所有模型显示出显著的改进。在“愤怒”类别中，DialogueGCN 与 DialogueRNN 基本持平(GCN 在 F1 得分上仅差 1.09)。只有“兴奋”类别显示出足够大的差异。

DialogueGCN 能够在 AVEC 和梅尔德上产生类似的结果，击败现任 DialogueRNN。

DialogueGCN vs. other models on the AVEC and MELD datasets (table taken from [1])

从结果中可以清楚地看出，将说话者级别的上下文添加到对话图内在地提高了理解。DialogueRNN 很好地捕捉了连续上下文，但缺乏对说话人上下文进行编码的能力。

分析

实验的一个参数是上下文窗口的大小。通过扩展尺寸，能够增加特定话语的边数。人们发现，尽管计算成本更高，但尺寸的增加改善了结果。

作者做的另一个有趣的实验是消融研究。一次拆除一个编码器，并重新测量性能。发现说话者级别的上下文编码器(阶段 2)比顺序上下文编码器(阶段 1)稍微重要一些。

还发现错误分类往往发生在两种情况下:

类似的情绪类如“沮丧”和“愤怒”，或“兴奋”和“高兴”。
像“好的”或“是”这样的简短话语。

因为使用的所有数据集都是多模态的，并且包含音频和视频，所以可以通过集成音频和视觉多模态学习来提高这两种情况下的准确性。虽然分类错误仍然会发生，但值得注意的是，DialogueGCN 仍然在准确性方面带来了非常显著的提高。

关键要点

背景很重要。一个好的模型不仅要考虑对话的连续语境(句子的顺序，哪些单词与其他单词相关)，还要考虑说话者层面的语境(谁说了什么，他们什么时候说的，他们如何受到其他说话者和他们自己的影响)。与传统的基于顺序和注意力的模型相比，整合说话者级别的上下文是一大进步。
序列不是表示对话的唯一方式。如果这篇论文展示了一件事，那就是数据的结构可以帮助捕捉大量的上下文。在这种情况下，说话者级别的上下文更容易以图形格式编码。
图神经网络是自然语言处理中一个很有前途的研究方向。聚合邻居信息的关键概念虽然在概念上很简单，但在捕捉数据关系方面却非常强大。

感谢阅读！

你可以在中、 Linkedin 或【kshen3778@gmail.com】与我联系

原文：https://arxiv.org/abs/1908.11540

来源:

[1]戈萨尔、迪潘威&马朱姆德、纳沃尼&茯苓、苏扬亚&恰亚、尼亚提&格尔布克、亚历山大。(2019).DialogueGCN:用于对话中情感识别的图形卷积神经网络。

[2] Michael Schlichtkrull、Thomas N Kipf、Peter Bloem、Rianne Van Den Berg、Ivan Titov 和 Max Welling。2018.用图卷积网络建模关系数据。欧洲语义网会议，593-607 页。斯普林格。

[3]贾斯汀·吉尔默、塞缪尔·舍恩霍尔茨、帕特里克·F·赖利、奥里奥尔·维尼亚尔斯和乔治·E·达尔。2017.量子化学的神经信息传递。《第 34 届机器学习国际会议论文集》第 70 卷，第 1263-1272 页。JMLR。org。

为硬件设计和制造领域的公民数据科学家提供支持

原文：https://towardsdatascience.com/empowering-a-citizen-data-scientist-for-hardware-design-manufacturing-6f5af585594?source=collection_archive---------25-----------------------

利用先进的人工智能工具提高硬件设计和制造专业人员的工作效率

作者:帕萨·德卡和罗希特·米塔尔

什么是公民数据科学家？

专家数据科学家依靠自定义编码来理解数据。用例可以是数据清理、数据插补、创建分段、查找数据中的模式、构建监督模型以预测目标、分类/回归问题的特征重要性分析、了解结果的可能原因、查找可能影响结果的可调参数，甚至深度学习问题的图像预处理等。

如上所述，公民数据科学家是高级分析的超级用户。但公民数据科学家的特质不同于专家数据科学家。他们的主要职责在统计和分析领域之外，他们是专家数据科学家的补充。公民数据科学家更有背景，对业务领域有独特的视角，更关注应用分析技术的业务问题，对与业务优先级相关的问题有更大的兴趣，并有能力证明业务价值。

在制造组织中，硬件设计工程师或工厂车间制造工程师也可以戴上公民数据科学家的帽子。优化设计流程或提高工厂的生产能力/产量可能是他们的目标，以便从流程中获得更多商业价值。

利用内部构建的硬件工具自动执行高级分析:

我们为硬件专业人员构建了一个高级分析工具。所谓硬件，我们指的是半导体和电路板级系统。我们的目标是使包括 AI 和 ML 在内的分析民主化，以便公民数据科学家可以更加专注于商业价值，而无需花费时间编写程序/代码来执行高级分析。我们的工具在不断发展，我们已经在工具中内置了一些功能:

自动数据预处理和数据清理

自动特征分析包括但不限于:

过滤方法，如皮尔逊相关、方差分析、线性判别分析、卡方检验

递归特征消除

主成分分析(PCA) &了解特性的影响→了解数据中具有各自过载特性的片段

主成分分析降维

无监督学习问题的各种聚类技术

深度学习能力:

图像识别:使用流行的 CNN 模型创建像素特征，并在 ImageNet 图像上预先训练权重(【http://www.image-net.org/】T2)

使用上一步中的特征自动寻找分类问题的最佳模型

通过对数据训练各种模型，自动找到最佳监督模型(分类/回归)。这是一个关键特性，使未经培训的专业人员能够利用 ML 解决他们的问题。

可以根据特定的制造需求增加额外的功能。例如，通过超参数调整或 ROC 阈值来微调模型的假阳性和假阴性。不太常见的用例特定建模。

以下是关于 ML 功能的模块化流程:

深度学习能力的模块化流程如下:

数据集内的搜索模式示例:

我们的“分析模式/片段”模块(内置于我们的工具中)可自动洞察数据中与特征权重相关的现有片段。我们的工具自动对数据进行主成分分析，并自动绘制一个由特征权重解释的信息方差图。此外，它还提供关于数据中现有模式/聚类的智能自动建议。我们发现这种能力在根据特性重要性寻找产品测试失败模式时非常有用。下面是使用我们的工具进行模式分析的流程:

结论:

我们已经建立了一个先进的分析工具，并不断增强其功能。我们的目标是在我们组织的硬件工程/制造社区中普及 AI & ML 的使用。借助我们的工具，我们在许多设计和制造用例上实现了良好的投资回报，例如产量提高、生产量优化、硬件材料缺陷检测、识别优化硬件设计的可调参数等。我们看到越来越多的人采用我们的工具，并设想引入特定但通用的可重用分析，这将满足我们组织内各种子组织的关键业务用例。

参考资料:

https://scikit-learn.org/stable/

【https://www.tensorflow.org/

http://www.image-net.org/

启用 ML 实验

原文：https://towardsdatascience.com/enable-ml-experiments-4ba8c3c8bdc2?source=collection_archive---------17-----------------------

向前

最近受到 Dmitry Petrov 关于机器学习模型和数据集版本化实践和机器学习项目中数据版本化的演讲的启发。

在大多数当前的 ML 系统中，缺乏有效和系统的方式 s 来以敏捷、持续和可维护的方式通过数据科学将数据的价值传递到市场中。

马丁·福勒关于连续交付机器学习 (CD4ML)的优秀著作中已经指出了一个解决方案。

这篇文章提出了一个关于系统地进行 ML 实验的思路，这是机器学习应用程序持续交付的重要一步。

工作流程—模型

数据科学与软件开发的不同之处在于它是基于实验的，而不是基于特性的。

工作流模型的核心思想是 ML 实验的编码和随之而来的优势(版本化、可再现性、自动化)。

实验

ML 实验被建模为位于 git 分支中的 ML 管道代码

ML 实验的组件视角是:

ML Experiment = Code + Data + Model

所有这三个元素都可以编码成“管道代码”或元数据。

所以 ML 实验的另一个角度:

# ML experiment can be perceived as procedure which takes data as input and ML model as output along with a score telling how good the model performsroutine ML Experiment(data):
body        
    pipeline code
    ...return ML Model, score

一般来说，这个过程遵循常见的模式，例如，Olson 的一篇论文中的所示的模式。

【压缩】数据和模型—元数据

git 系统很难跟踪大型数据集。解决方法是通过为每个数据和模型创建一个元数据文件来“分而治之”。

元数据很小(因此适合 git 系统),同时包含恢复原始数据和模型的所有信息。[参见:版本控制 ML 模型

“管道”代码— DAG

ML 管道代码通常用 DAG ( 有向无环图 )建模，这也是 Apache Spark、Apache Airflow 和大多数现代数据操作工具的基础数据模型。

这就是为什么 dvc 管道 也可以整合成 阿帕奇气流 。

工作空间

Workspace 是 ML 实验的快照，建模为 git 分支上的提交。可以用 git 标签做书签。ML 实验是工作空间的进化。

工作空间包括我们在给定的时间点重现实验所需的所有信息。

工作区有两种常见的操作。

改变一个工作区

这可能是数据更改:

# first create metadata
$ dvc add dataset.csv
# then put metadata under version control
$ git add dataset.csv.dvc

这可能是管道代码更改:

$ dvc run new-pipeline-script
$ git add new-pipeline-script.dvc

恢复一个工作区

检查代码和元数据，使用元数据恢复数据集

$ git clone [https://gitlab.com/wutianchen/blog-enable-ml-experiments.git](https://gitlab.com/wutianchen/blog-enable-ml-experiments.git)
$ git checkout tags/baseline
# Now we have code and metadata restored, to completely restore the workspace from that.
# dvc looks for metadata and checkout data according to the path stored in metadata.
$ dvc checkout
$ dvc pull

工作流—示例

工作区的结构，例如 ML 实验，如上图所示。工作区应该一直使用 s3 这样的远程云 BLOB 作为后端存储。但是在这个演示中，local-remote 被用作远程存储的模拟，因此云提供商帐户不是重现它的必要条件。(git repo for demo 可以在 这里找到 )

此外，工作空间可以“安装”到远程计算单元，如 AWS EC2、AWS Sagemaker 来进行计算，但是本地桌面也足够了。

实验:基线

快速浏览基线实验(存储库/标签:基线)。包括三个流水线步骤( data_preparation.dvc 、 model_selection.dvc 、 model_evaluation.dvc )。

数据准备步骤将整个数据集作为输入，并输出四个数据集 iris_train_X.csv、iris_train_Y.csv、iris_test_X.csv、iris_test_Y.csv。这些信息记录在管道元数据(data_preparation.dvc)中

基线模型的性能被写入一个名为 auc.metric 的文件，该文件稍后可用于 e 实验比较。跟踪 ML 实验度量和管理模型比较的更好选择是MLflowtracking(其中不在本文的讨论范围内)。

实验:特征多模型

现在，从基线实验开始，我们想通过进行另一个实验来探索和提高系统的性能，尝试新的想法。

恢复基线实验工作空间在另一个分支进行新实验 【特征-多模型】

$ git clone [https://gitlab.com/wutianchen/blog-enable-ml-experiments.git](https://gitlab.com/wutianchen/blog-enable-ml-experiments.git)# checkout baseline and create feature branch
$ git checkout -b feature-multiple-models tags/baseline# restore remote dataset into workspace
$ dvc checkout
$ dvc pull

22。添加更改和

通过尝试一堆模型来试验增强 model_selection.dvc 的新想法，并最终选择在训练数据集上具有最佳性能的模型。

3。在特征多模型分支 上运行新的 ML 实验

$ dvc run -d data/iris_X_train.csv -d data/iris_Y_train.csv -o model/model.pickle -f model_selection.dvc python code/model_selection.py# keep model_selection.dvc under git control
$ git add model_selection.dvc
$ dvc run -d data/iris_X_test.csv -d data/iris_Y_test.csv -d model/model.pickle -M auc.metric -f model_evaluation.dvc python code/model_evaluation.py
$ git add model_evaluation.py

现在，我们有了一个新的模型和分数来衡量新模型在测试数据集上的性能。

4。比较两个实验(基线和特征多模型)

$ dvc metrics show -a

产出:

working tree:
        auc.metric: 0.896551724137931
feature-multiple-models:
        auc.metric: 0.8275862068965517
master:
        auc.metric: 0.8275862068965517

在新想法上观察到性能提升，因此我们希望保留它。

5。存储工作区和

$ dvc add
$ dvc push
$ git add .
$ git commit -m “add feature-multiple-models”
$ git tag -a "improved-multiple-models" -m "feature-multiple-models"
$ git push origin feature-multiple-models --tags

6。合并回发布分支

因为我们现在有了一个得分更高的模型，我们可以通过将它合并到主分支中来发布新的模型。

$ git checkout master
$ git merge master feature-multiple-models

在它被合并回主版本后，我们有两个选择:

保留特征多模型以供进一步分析
删除特征-多模型分支

编后记

我们以系统的方式建立了进行 ML 实验的基本工作流程，并用一个例子展示了它的可用性。但它只是触及了这个领域的表面。这一行还可以包含更多的主题，例如:

高级实验场景:特征-pca 和特征-滤波器-噪声

想象一下，两个数据科学家在两个实验分支上协同工作，但又分开工作(程序与实验相同:特征多模型)。数据科学家 1 希望对要素运行 PCA。数据科学家 2 想要过滤原始数据集的记录以清理数据。

问题是我们如何解决这两个实验的合并冲突。

谁打谁？

分数较好的实验总是赢吗？那会不会太合适了？
有没有可能把两个实验的方法结合起来？

2。实验对比、管理和自动化

对于大型项目，我们可能会有成百上千个实验分支。可视化，比较实验和合并实验将变得越来越困难。

有为 ML 实验管理搭建的商业解决方案，比如 Neptune。向他们学习会很有趣。

[## 海王星-机器学习平台

2016 年 1 月，deepsense.ai 在 Kaggle 上赢得了露脊鲸识别大赛。竞赛的目标是自动化…

deepsense.ai](https://deepsense.ai/neptune-machine-learning-platform-post/)

3。AutoML

最后但同样重要的是，由于 ML 实验的编纂，实验过程也可以以某种方式自动化，这导致了一个热门的研究领域 autoML[参见:自动化机器学习的过去、现在和未来 ]。

快乐实验！😃

结论

机器学习是基于实验的
ML 实验=代码+模型+数据
ML 实验可以首先被编码，然后被版本化和自动化
使用 git 分支对 ML 实验建模
使用 git commit 对 ML 实验工作区建模
使用 git 标记来标记实验，以便进一步恢复和比较

更聪明地编码:如何轻松地将分类编码集成到您的机器学习管道中

原文：https://towardsdatascience.com/encode-smarter-how-to-easily-integrate-categorical-encoding-into-your-machine-learning-pipeline-89debe3ce24c?source=collection_archive---------26-----------------------

自动化特征工程通过简化 ML 管道中一个关键的、但手动密集的步骤，解决了应用机器学习中最大的问题之一。然而，即使在特征工程之后，处理非数字数据以供机器学习算法使用也是不可避免的，并且提出了自己的一系列独特挑战。

这篇文章既是分类编码的指南，也是对用于自动分类编码的 Python 库的介绍，Python 库的设计考虑到了易于集成到 T2 特征工程工作流程中。

分类编码:是什么/为什么

当谈到自动机器学习时，传统上主要关注的是选择特定的算法或细化模型的参数，但应用机器学习的大部分工作往往源于过程中的其他步骤。例如，必须首先从原始数据中提取相关的预测变量、特征——这一步被称为特征工程，是必不可少的，但它也可能是应用 ML 过程中最需要手动操作的步骤之一。

类似地，处理非数字数据几乎是每个机器学习过程的关键组成部分。在应用机器学习中，两种最常见的数据类型是数字数据(如年龄:5、17、35)和分类数据(如颜色:红、蓝、绿)。处理数字数据通常比处理分类数据更容易，因为机器学习算法对不知道上下文的数学向量进行操作。

相比之下，许多机器学习模型无法直接处理分类数据。分类值没有任何内在的数学关系，因此我们必须先对数据做一些工作，然后才能将其输入到机器学习模型中。将分类数据转化为可用的、机器学习就绪的数学数据的过程称为分类编码。

分类编码 API:在哪里

为了创建普遍适用于任何机器学习流水线的编码器，必须考虑需要对数据进行分类编码的三种不同情况:训练数据、测试数据和我们训练的 ML 模型将对其执行预测的新输入数据。

分类编码库旨在处理所有三种情况，以便与其相邻的特征工程和机器学习模型训练步骤无缝集成。下面的流程图说明了在机器学习管道中使用分类编码的典型工作流程。

在标准的机器学习管道中，在对数据集执行特征工程后，您会得到一个数据表，称为特征矩阵，其中包含与手头的预测问题相关的特征。在机器学习管道的这一点上，我们必须首先对我们的数据执行训练测试分割——我们需要训练数据来训练我们的模型，并测试数据来验证它。

下面是我们代码的基本设置。你可以在这个 Jupyter 笔记本上获得完整的代码。

import categorical_encoding as ce
import featuretools as ft
from featuretools.tests.testing_utils import make_ecommerce_entitysetes = make_ecommerce_entityset()
f1 = ft.Feature(es["log"]["product_id"])
f2 = ft.Feature(es["log"]["purchased"])
f3 = ft.Feature(es["log"]["value"])
f4 = ft.Feature(es["log"]["countrycode"])features = [f1, f2, f3, f4]
ids = [0, 1, 2, 3, 4, 5]
feature_matrix = ft.calculate_feature_matrix(features, es,
                                             instance_ids=ids)print(feature_matrix)product_id  purchased  value countrycode
id                                          
0    coke zero       True    0.0          US
1    coke zero       True    5.0          US
2    coke zero       True   10.0          US
3          car       True   15.0          US
4          car       True   20.0          US
5   toothpaste       True    0.0          ALtrain_data = feature_matrix.iloc[[0, 1, 4, 5]]
print(train_data)product_id  purchased  value countrycode
id                                          
0    coke zero       True    0.0          US
1    coke zero       True    5.0          US
4          car       True   20.0          US
5   toothpaste       True    0.0          ALtest_data = feature_matrix.iloc[[2, 3]]
print(test_data)product_id  purchased  value countrycode
id                                         
2   coke zero       True   10.0          US
3         car       True   15.0          US

我们必须分别处理这两组而不是直接编码整个特征矩阵的原因是因为在转换数据之前必须训练许多编码器。例如，目标编码器依赖于某个类别的平均值——将测试数据的值合并到我们的编码中会导致标签泄漏。

因此，在用我们选择的方法初始化我们的编码器之后(见上面如何决定选择哪个编码器)，我们拟合(和转换)我们的训练数据，并且我们只转换而不拟合我们的测试数据。在我们对数据进行编码后，我们当然会得到编码后的数据，我们还会生成特征。

enc = ce.Encoder(method='leave_one_out')

train_enc = enc.fit_transform(train_data, features, train_data['value'])

test_enc = enc.transform(test_data)print(train_enc)PRODUCT_ID_leave_one_out  purchased  value  COUNTRYCODE_leave_one_out
id                                                                       
0                       5.00       True    0.0                      12.50
1                       0.00       True    5.0                      10.00
4                       6.25       True   20.0                       2.50
5                       6.25       True    0.0                       6.25print(test_enc)PRODUCT_ID_leave_one_out  purchased  value  COUNTRYCODE_leave_one_out
id                                                                       
2                       2.50       True   10.0                   8.333333
3                       6.25       True   15.0                   8.333333

在机器学习管道的最后一步，我们将获得新的数据，我们现在使用我们训练的模型来执行预测。为此，我们利用上一步生成的特征，利用 Featuretools 的calculate_feature_matrix()功能立即创建编码数据——我们不必创建单独的编码器，也不必再次经历整个编码过程。现在，我们有数据可以立即应用到我们的机器学习模型中。

fm2 = ft.calculate_feature_matrix(features, es, instance_ids=[6,7])
print(fm2)product_id  purchased  value countrycode
id                                          
6   toothpaste       True    1.0          AL
7   toothpaste       True    2.0          ALfeatures_encoded = enc.get_features()

fm2_encoded = ft.calculate_feature_matrix(features_encoded, es, instance_ids=[6,7])

print(fm2_encoded)PRODUCT_ID_leave_one_out  purchased  value  COUNTRYCODE_leave_one_out
id                                                                       
6                       6.25       True    1.0                       6.25
7                       6.25       True    2.0                       6.25

分类编码:何时/如何

分类编码最难的部分有时可能是找到正确的分类编码方法——有许多研究论文和研究致力于分析分类编码方法对不同数据集的性能。通过汇编使用相同编码方法的数据集所共有的所有公共因素，我创建了以下流程图，作为找到最适合您的数据的方法的指南。请注意，这个流程图是一个起点，您可以随意尝试不同的编码方法，甚至是这里没有列出的方法，看看哪种方法最适合您的特定数据和机器学习问题。

也就是说，这个流程图反映了常用分类编码方法的基本原则。此外，如果你想要一个更全面的分类编码指南，这里有一个 Jupyter 笔记本，它涵盖了每种分类编码方法及其更详细的应用场合。

分类编码方法

编码方法可以大致分为几类。

经典编码器

经典编码器是最简单易懂的，这使得它们在 ML 从业者中非常有用和受欢迎。

如果您不确定使用哪种编码方法，一键编码几乎总是一个好的起点。由于其易于使用和理解、通用性和准确性，它是分类编码的首选方法。

已经位于分类编码库中的经典编码器有:顺序编码器、一键编码器、二进制编码器和散列编码器。下面是代码示例，详细说明了每一个是如何实现的。如果你想继续学习，这些例子也可以在 Jupyter 笔记本中找到。

# Creates a new column for each unique value. 
enc_one_hot = ce.Encoder(method='one_hot')
fm_enc_one_hot = enc_one_hot.fit_transform(feature_matrix, features)
print(fm_enc_one_hot)product_id = coke zero  product_id = car  product_id = toothpaste  \
id                                                                      
0                        1                 0                        0   
1                        1                 0                        0   
2                        1                 0                        0   
3                        0                 1                        0   
4                        0                 1                        0   
5                        0                 0                        1   

    purchased  value  countrycode = US  countrycode = AL  
id                                                        
0        True    0.0                 1                 0  
1        True    5.0                 1                 0  
2        True   10.0                 1                 0  
3        True   15.0                 1                 0  
4        True   20.0                 1                 0  
5        True    0.0                 0                 1# Each unique string value is assigned a counting number specific to that value.
enc_ord = ce.Encoder(method='ordinal')
fm_enc_ord = enc_ord.fit_transform(feature_matrix, features)
fm_enc_ordPRODUCT_ID_ordinal  purchased  value  COUNTRYCODE_ordinal
id                                                           
0                    1       True    0.0                    1
1                    1       True    5.0                    1
2                    1       True   10.0                    1
3                    2       True   15.0                    1
4                    2       True   20.0                    1
5                    3       True    0.0                    2# The categories' values are first Ordinal encoded,
# the resulting integers are converted to binary,
# then the resulting digits are split into columns.
enc_bin = ce.Encoder(method='binary')
fm_enc_bin = enc_bin.fit_transform(feature_matrix, features)
fm_enc_binPRODUCT_ID_binary[0]  PRODUCT_ID_binary[1]  PRODUCT_ID_binary[2]  \
id                                                                     
0                      0                     0                     1   
1                      0                     0                     1   
2                      0                     0                     1   
3                      0                     1                     0   
4                      0                     1                     0   
5                      0                     1                     1   

    purchased  value  COUNTRYCODE_binary[0]  COUNTRYCODE_binary[1]  
id                                                                  
0        True    0.0                      0                      1  
1        True    5.0                      0                      1  
2        True   10.0                      0                      1  
3        True   15.0                      0                      1  
4        True   20.0                      0                      1  
5        True    0.0                      1                      0# Use a hashing algorithm to map category values to corresponding columns
enc_hash = ce.Encoder(method='hashing')
fm_enc_hash = enc_hash.fit_transform(feature_matrix, features)
fm_enc_hashPRODUCT_ID_hashing[0]  PRODUCT_ID_hashing[1]  PRODUCT_ID_hashing[2]  \
id                                                                        
0                       0                      0                      0   
1                       0                      0                      0   
2                       0                      0                      0   
3                       0                      1                      0   
4                       0                      1                      0   
5                       0                      0                      0   

    PRODUCT_ID_hashing[3]  PRODUCT_ID_hashing[4]  PRODUCT_ID_hashing[5]  \
id                                                                        
0                       0                      1                      0   
1                       0                      1                      0   
2                       0                      1                      0   
3                       0                      0                      0   
4                       0                      0                      0   
5                       1                      0                      0   

    PRODUCT_ID_hashing[6]  PRODUCT_ID_hashing[7]  purchased  value  \
id                                                                   
0                       0                      0       True    0.0   
1                       0                      0       True    5.0   
2                       0                      0       True   10.0   
3                       0                      0       True   15.0   
4                       0                      0       True   20.0   
5                       0                      0       True    0.0   

    COUNTRYCODE_hashing[0]  COUNTRYCODE_hashing[1]  COUNTRYCODE_hashing[2]  \
id                                                                           
0                        0                       0                       1   
1                        0                       0                       1   
2                        0                       0                       1   
3                        0                       0                       1   
4                        0                       0                       1   
5                        0                       1                       0   

    COUNTRYCODE_hashing[3]  COUNTRYCODE_hashing[4]  COUNTRYCODE_hashing[5]  \
id                                                                           
0                        0                       0                       0   
1                        0                       0                       0   
2                        0                       0                       0   
3                        0                       0                       0   
4                        0                       0                       0   
5                        0                       0                       0   

    COUNTRYCODE_hashing[6]  COUNTRYCODE_hashing[7]  
id                                                  
0                        0                       0  
1                        0                       0  
2                        0                       0  
3                        0                       0  
4                        0                       0  
5                        0                       0

贝叶斯编码器

贝叶斯编码器和经典编码器之间最显著的区别在于，贝叶斯编码器除了使用分类变量之外，还使用因变量的信息。此外，它们只输出一列，这消除了有时会影响其他编码器的任何高维度问题。

除了 One-Hot 编码，LeaveOneOut 编码是我强烈推荐的另一种分类编码方法。

已经在分类编码库中实现的贝叶斯编码器有:Target 和 LeaveOneOut。我在下面提供了它们的代码示例:

# Replaces each specific category value with a weighted average of the dependent variable.
enc_targ = ce.Encoder(method='target')
fm_enc_targ = enc_targ.fit_transform(feature_matrix, features, feature_matrix['value'])
print(fm_enc_targ)PRODUCT_ID_target  purchased  value  COUNTRYCODE_target
id                                                         
0            5.397343       True    0.0            9.970023
1            5.397343       True    5.0            9.970023
2            5.397343       True   10.0            9.970023
3           15.034704       True   15.0            9.970023
4           15.034704       True   20.0            9.970023
5            8.333333       True    0.0            8.333333# Identical to target except leaves own row out when calculating average
enc_leave = ce.Encoder(method='leave_one_out')
fm_enc_leave = enc_leave.fit_transform(feature_matrix, features, feature_matrix['value'])
fm_enc_leavePRODUCT_ID_leave_one_out  purchased  value  COUNTRYCODE_leave_one_out
id                                                                       
0                   7.500000       True    0.0                  12.500000
1                   5.000000       True    5.0                  11.250000
2                   2.500000       True   10.0                  10.000000
3                  20.000000       True   15.0                   8.750000
4                  15.000000       True   20.0                   7.500000
5                   8.333333       True    0.0                   8.333333

您可能会发现，在某些情况下，您会更喜欢当前位于库中的编码器的不同实现(例如，对于我的目标编码实现，我有一个用于平均值计算的特定权重)。如果您希望进行修改，比如采用不同的权重来计算平均值，请随意创建一个新的编码器类，进行修改，并使用编码器 API 调用您的新类。

替代编码器

第三组编码器是对比编码器——它们通过在类别中寻找数学模式来工作。您可以考虑常见的对比度编码方法，如赫尔默特、求和、后向差分或多项式编码。

此外，还存在其他贝叶斯编码器，例如 James-Stein、M-Estimator 或证据权重。请随时尝试编码方法，找到最适合您的数据的方法。然而，如果你需要一个好的起点，看看库中已经实现的默认经典/贝叶斯编码器。One-Hot 和 LeaveOneOut 编码是最流行的编码器，这是有原因的。

摘要

分类编码是特征工程和机器学习中的一个重要步骤，但处理分类数据可能会很棘手且耗时。利用上述指南来确定如何开始更智能地编码，以及如何将分类编码库应用于任何功能工具机器学习管道。请随时尝试多种分类编码方法 API 为您提供了灵活性，让您可以调整自己版本的通用编码器，使其最适合您的特定数据集。

最终，分类编码通过与特征工程以及模型创建、训练和应用的无缝集成，使您更容易处理机器学习管道中的分类数据。

试试分类编码库，并在 Github 上留下任何反馈！我们总是欢迎任何新的编码方法实现。有关更多信息和说明，请查看自述文件和指南。

原载于 2019 年 8 月 26 日https://blog.featurelabs.com。

加密您的数据

原文：https://towardsdatascience.com/encrypting-your-data-9eac85364cb?source=collection_archive---------6-----------------------

使用 Python 进行对称加密

Unlock the Lock

美国泄密者爱德华·斯诺登和前国家安全局(NSA)局长迈克尔·海登说美国有了“牢不可破的端到端加密技术”更加安全斯诺登继续说道，“我可以向你保证……有一件事:如果我在某件事情上与国家安全局局长并肩站在一起，那一定有一个非常好的理由。”

任何与数据打交道的人都有责任确保敏感数据不会面临被盗的风险。已经实施的网络安全政策往往被当作一个最低限度的检查清单，而事实证明，这是不够的。2018 年，T-Mobile、Quora、脸书和 18 家其他大公司都屈服于数据泄露。不幸的是，数据伦理和数据安全经常被忽视。将这篇文章作为加密您自己的数据的快速教程，请进一步学习如何在数据库系统上正确地实现加密。

Insert hologram of padlock

加密的思想很简单:发送方可以用加密密钥对数据进行加密，然后接收方用解密密钥对数据进行解密。对称加密意味着加密密钥和解密密钥是相同的。这是效率较低的方法，因为密钥的传递可能会被数字截获。不对称加密意味着加密密钥和解密密钥不同。不对称加密或公钥加密是通过使用公钥和私钥来实现的。私钥用于解密数据。

好的加密密钥应该不小于 2048 位。由于巨大的计算负担，很少使用大于这个值的键；然而，这种大小的密钥已经足够好了，因为一台普通的计算机需要 140 亿年才能破解一个 2048 位的证书，而没有人有时间做这个。

Sweet Brown

瑟里奥特先生指出，没有任何借口不加密你的数据。它在您的设备上，因此您有责任对您使用的数据进行加密，尤其是当您使用敏感数据时。我现在有一个数据库，里面有我朋友的名字、社保号码和他们最害怕的事情。如果任何人得到这个信息，它可能意味着危险！

让我们来看看如何使用对称密钥系统最好地加密这个熊猫数据帧的步骤。下面的模型简化了加密过程。

Symmetric Encryption

在开始之前，我们需要安装 Python 加密模块。此模块的文档可在这里找到。危险材料层激起了我的兴趣。此外，检查他们的开源项目！

C.R.E.A.M.

我想加密我的非常敏感的数据，所以我打算先将它保存为一个文件—一个 CSV 文件。

导入加密模块并创建新密钥。每次运行这段代码，都会打印一个新的密钥。密钥是一个 Base64 编码器字符串的字节对象。

我们需要保存一个密钥，这样我们就可以用它来加密。为了保存密钥，我们可以将其写入文件。下面的代码会将它保存在您当前工作的文件夹中的一个文件中。

如果您想要检索密钥，我们可以从用 read bytes 保存的文件中检索密钥。

如果您想创建一个新的带密码的加密密钥，您也可以这样做。使用这种方法，将为使用的每个新密码创建一个新的加密密钥。您需要创建一个 salt ，使用 OS 模块可以轻松完成。

我们可以复制并粘贴输出，并在下面的代码中将其指定为 salt。

有了所有这些参数，我们就可以简单地更改提供的密码，我们将被分配一个新的密钥。每个唯一的密码都有一个唯一的密钥。

有了我们的密钥，我们现在可以加密和解密一个文件，甚至是一个字符串！使用下面的代码，你可以加密一个文件。

文件现在看起来像这样:

Encrypted!

要解密，我们可以简单地切换一个文件名和一些如下所示的命令:

现在你应该有三个文件。原始文件、该文件的加密版本和该文件的解密版本。只要您有密钥，您就可以删除原始文件，只保留加密版本。正确的密钥管理对于加密的有效性至关重要。钥匙应始终保存在一个单独且安全的地方。您不应该将加密密钥保存在一个文件或同一个文件夹中。这就像把前门的钥匙放在门垫下面一样。

你甚至可以加密你的加密密钥！这被称为密钥加密密钥(KEK ),应该与它解锁的数据隔离开来。最佳实践包括用主加密密钥和主签名密钥保护您的 KEKs。对数据的不同部分使用不同的键也是一个好的做法。这可能很困难，因为它要求用户知道每次加密或解密数据时要获取哪个密钥。遵循适当的加密协议有可能减少你被黑客攻击的机会，但不幸的是，大多数程序员在数据安全方面做得很少。太多的开发人员遵循 HIPAA 或公司政策等指导原则所要求的清单，但是这些指导原则通常不足以对数据泄露进行适当的防御。这里有一些你应该避免的常见加密错误。

权力越大，责任越大，如果您在计算机上处理敏感数据，保护这些数据就是您的责任。自学加密的细节和最佳实施方法应该可以防止数据泄露发生在您身上。练习加密你的文件，因为你永远不知道谁会在看。

从人脸中检测亲缘关系的端到端解决方案。

原文：https://towardsdatascience.com/end-to-end-solution-of-detecting-kin-relationship-from-faces-c70b9e9ecda6?source=collection_archive---------24-----------------------

这篇博客将一步一步地指导你如何用 Keras 构建一个深度神经网络模型，从无到有，最后用 Flask 将其部署到网络上。这个问题是由 Kaggle 主办的一个比赛，可以在这里找到。

Photo by Priscilla Du Preez on Unsplash

定义我们的目标:

你的鼻子长在你身上了吗？

血亲往往有共同的面部特征。现在，东北大学的研究人员希望改进他们的面部图像分类算法，以弥合研究与 DNA 结果等其他家族标记之间的差距。

由于以下几个原因，这项技术在实践中仍然鲜为人知:

1.用于亲属关系识别任务的现有图像数据库不够大，不足以捕捉和反映世界上家庭的真实数据分布。

2.许多隐藏因素会影响家族面部关系，因此需要一个比最常用于更高级别分类(例如面部识别或对象分类)的计算机视觉算法更具判别力的模型。

因此，我们将建立一个复杂的模型，通过仅仅基于他们的面部图像来确定两个人是否有血缘关系。

数据:

我们将使用 Families In the Wild (FIW) 提供的数据，这是最大、最全面的自动亲属识别图像数据库。

FIW 的数据集是从名人的公开图片中获取的。有关他们贴标过程的更多信息，请访问他们的数据库页面。

文件描述:

文件夹“train”由名为(F0123)的族的子文件夹组成，这些族文件夹包含个人的子文件夹(MIDx)。同一个MIDx文件夹中的图片属于同一个人。同一F0123文件夹中的图像属于同一家族。

列车文件夹如下所示:

Train Folder

“train”的每个子文件夹如下所示:

每个个人文件夹都包含此人的面孔:

文件夹“test”包含需要与另一个随机图像测试是否有血缘关系的人脸图像。

下面显示的文件“train_relationships.csv”包含训练标签。记住，不是每个家庭成员都有亲属关系。例如，父母和他们的孩子是亲戚，但彼此不是。

train_relationships.csv

设置所需的库以便在需要时使用:

注意:如果您的系统中不存在库“keras_vggface ”,导入时可能会出错。要下载它，您可以参考/运行/使用以下代码:

!pip install git+https://github.com/rcmalli/keras-vggface.git

深入数据文件夹并分析 train_relationship.csv 文件，我发现了一些问题。例如:在 train_relationship.csv 文件中有一个‘f 0039/mid 1’和‘f 0039/mid 3’的关系，但是在 train 文件夹中没有‘f 0039/mid 3’的文件夹。

我能看到一些类似的问题是因为缺少了下面的文件夹
f 0039/mid 4
f 0041/mid 5
f 0041/mid 7
f 0051/mid 5
…等等。

解决上述问题的一个简单方法是忽略这些空目录，只考虑那些对我们可用的目录。

加载数据并将其分成训练和验证集。

“val_images”包含文件夹名称以“F09”开头的系列文件夹，而“train_images”包含所有其他系列文件夹。

现在，这两个文件夹也包含空目录，这是我们上面讨论过的问题。是时候忽略它们了:

我们有“train”和“val ”,它们分别包含用于培训和验证过程的系列文件夹。

在定义了这个问题的目标之后，我们探索并理解了我们所拥有的数据的本质，我们也克服了我们所面临的一个简单的问题。现在是做一些建模的时候了。回想一下我们一开始为自己设定的目标:

"预测，给定两张脸是否有血缘关系."

所以基本上我们手头有一个分类问题需要解决。

深度学习模型:

与以前的经典方法相比，使用深度学习架构，人脸识别的任务显示出高度提高的准确性。当用巨大的数据集训练时，最先进的模型现在甚至可以胜过人类。

对于我们的问题，我们将使用两种不同的架构，在一系列人脸识别基准数据集上取得了最先进的结果。这两个系统都可以用来从人脸中提取高质量的特征，称为人脸嵌入，然后可以用来比较两张相似或不相似的人脸。

1- Facenet :是谷歌的研究人员在 2015 年开发的人脸识别系统。它以图像为输入，预测 128 维向量或人脸嵌入。所以简单来说，这个矢量/人脸嵌入现在用数字来表示输入的人脸。

2- VGGFace :它是由牛津大学视觉几何组(Visual Geometry Group)的研究人员开发的，该组是图像处理领域最著名的小组之一。它将图像作为输入，并预测 2048 维向量或人脸嵌入。

这两个模型将作为我们的基础模型，也就是说，我们将把我们的输入图像对传递给这两个模型，并获得代表输入人脸的人脸嵌入。一旦我们建立了下面的实际模型，就很清楚了。

输入:

我们有两个人脸图像，图像 1 和图像 2，我们的两个基本模型将采取这些图像中的每一个。Facenet 会把 image_1 和 image_2 作为 input_1 和 input_2。VGGFace 会把 image_1 和 image_2 作为 input_3 和 input_4。

注:不同型号的图像输入尺寸不同。

在将输入图像通过两个基本模型后，我们将得到两个图像的人脸嵌入。我们有

来自 Facenet 模型的图像 1 的 x1-面部嵌入

来自面网模型的图像 2 的 x2 面嵌入

来自 VGGFace 模型的图像 1 的 x3-人脸嵌入

来自 VGGFace 模型的图像 2 的 x4-人脸嵌入

我们可以将这些嵌入直接用于我们的分类任务，方法是将它们通过密集的 FC 层，但不是这样做，而是将这些嵌入组合或合并以获得更好的结果，这将是一个很好的特征工程技巧。

例如:对向量 x1 求平方可以给出关于 image_1 的更多信息。

像这样，我们可以使用许多不同的组合，如加法(x1，x2)乘法(x3，x4)等。这方面的代码如下所示:

我们已经准备好了模型架构。下一步是开始用一些损耗和优化器来训练它。在训练模型之前，我们需要定义一些帮助函数，它们将在训练和推理步骤中帮助我们。

read_img_fn '将采用输入图像的路径，并返回具有预定义大小的相同图像。请记住，我们对不同的基本模型使用不同的图像输入尺寸。与此类似，另一个函数‘read _ img _ vgg’将为 VGGFace 模型做同样的事情。

一个特殊的辅助函数“生成”用于生成具有某个固定 bath_size 的成批图像对。对于每一批，它将返回四个图像的组合(每一对用于两个模型的输入)和标签。

损失函数和模型配置:

正如我们在开始时讨论的，这是一个二元分类问题。我们将使用二元交叉熵或对数损失作为这个问题的损失函数。

为了配置模型，我们将使用准确性作为工具来跟踪性能，而训练和优化器将是学习率= 1e-5 的 Adam。

训练:

最后，我们准备好训练上面定义的模型。使用回调在各个点存储和使用训练好的模型，训练的最终代码看起来是这样的。

您可以看到，我们正在使用“生成”辅助函数来生成批量大小为 16 的图像。在几个时期的训练之后，模型收敛，并且精度没有从那里提高。

最后，用文件名' facenet_vgg.h5 '保存训练好的模型。

评估:

现在，我们可以使用这个训练好的模型来预测给定两个输入图像的概率。为此，我们将使用 Kaggle 提供的“sample_submission.csv”文件。该文件包含成对的图像，模型需要预测亲属关系的概率。

然后将这个文件“face_vgg.csv”提交给 Kaggle 来检查分数。我们的模型表现良好，在私有 lb 上给出的 AUC 分数为“0.887”，在公共 lb 上给出的 AUC 分数为“0.881”。

由此，我们可以说，我们复杂的深度学习模型在这项任务中表现良好，并准备投入生产。

生产途径:

我们将使用基于 Python 的微型 web 框架 Flask 在本地主机上制作一个简单的 web 服务器，它将充当 API，并帮助最终用户与我们训练过的模型进行通信。所以现在任何人都可以访问我们的模型。

首先，让我们使用 Flask 构建一个简单的 web API 来演示事情是如何工作的。

我们需要制作两个不同的文件。

1- app.py —后端的 Flask 脚本

from flask import Flask, request, render_template
app = Flask(__name__)[@app](http://twitter.com/app).route('/')
def hello_world():
    return render_template('index.html')

上面的代码将导入必要的文件并启动 Flask 实例。函数 hello_world()将把我们的主页呈现给用户。

2-index.html-用户将在前端看到的主页 html 文件。

<!DOCTYPE html>
<html>
<head>
    <title>Flask</title>
</head>
<body>
<p>Hello world</p>
</body>
</html>

现在我们有了我们需要的两个文件。运行 app.py 文件后，用户将能够看到“Hello world”页面。

在构建之前，让我们首先想象一下事物如何工作的整体结构。用户将看到一个网页，要求他/她上传两个图像文件，他/她需要看看他们是否有血缘关系。在后端，我们的 Flask 脚本将访问这两个图像，并在其上运行所需的操作。它将获取图像，执行预处理，然后将它们传递给我们训练好的模型。最后，该模型将预测概率，并在前端投射给用户。

现在，我们将开始构建我们的亲属预测 API。

这是我们项目布局的样子——

**/Kin-Prediction
   ├── templates
       └── index.html
       └── end.html** **├── static
       └── Image1
       └── Image2
   ├── venv/
   ├── app.py
   ├── facenet_vgg.h5**

项目文件夹包含我们的烧瓶需要的所有文件。

文件夹模板将包含前端的 HTML 文件，Flask 将在需要时使用这些文件进行渲染。

静态文件夹将包含用户将上传用于预测的图像。

“facenet_vgg.h5”是我们训练好的模型，需要保存在目录中，以便 Flask 可以直接使用它。

app.py 文件是将运行并执行所有后端操作的主 Flask 脚本。

app.py 中的以下函数将为用户呈现主页。

@app.route('/')
@app.route('/home')
def upload_image():
    return flask.render_template('index.html')

index.html 的文件如下所示:

<html>
<head>
    <meta charset="UTF-8">
    <title>Kin Relationship</title>
</head>
   <body  style="background-color:gray;"  >
      <form action = "http://localhost:5000/upload" method = "POST"
         enctype = "multipart/form-data"  align="center">
         First Image:<label>
         <input type = "file" name = "file1" /></label>
         Second Image<label>
         <input type = "file" name = "file2" /></label>

         <label>
         <input type = "submit" value="Predict"/> </label>

      </form>
   </body>
</html>

该页面将如下所示:

选择图像并点击预测按钮后，这两幅图像都将被上传并保存到我们的本地目录文件夹中，该文件夹是“静态”的。Flask 将从那里访问图像并执行所需的操作，最后预测概率。

app.py 文件中的代码如下所示:

最后，flask 将使用图像和预测来呈现模板“end.html”。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Prediction</title>
</head>
<body style="background-color:powderblue;">
<div>
{% for i in image_name %}

<img src=" {{url_for('static', filename=i) }} " style="width:250px;height:300px;"  hspace="200">

{% endfor %}

</div>

<h1 style="font-family:verdana;"> Probablity of two persons having kin relation is {{pred}} </h1>
</body>
</html>

就是这样。我们的模型已经准备好并正在本地主机上运行。你可以在这里下载并参考完整代码。

我试着这样做，首先用我和我爸爸的照片，然后用妈妈和爸爸的照片。在这两种情况下，模型都工作得非常好，并分别预测高概率(血缘相关)和低概率(血缘不相关)。

视频:

这是展示上述实验的视频。

待办任务:

1-我们可以将它部署在基于云的 web 服务上，而不仅仅是在本地服务器上运行，比如 Heroku，这样任何地方的任何人都可以访问你的模型。

2-目前，我们的模型只拍摄人脸图像，因为它只在人脸上进行训练。如果给定一个人的完整图像，它将不起作用。我们可以构建一个不同的解决方案来处理这个问题。

3-使用先进的 CSS 和 javascript，我们可以设计我们的前端看起来不错。

谢谢你在这个博客中走了这么远。希望你喜欢。有什么建议可以通过 Linkedin 联系我。

参考资料:

1-https://www . ka ggle . com/c/recogniting-faces-in-the-wild/overview

2-https://blog . keras . io/building-a-simple-keras-deep-learning-rest-API . html

3-https://heart beat . fritz . ai/brilliant-初学者-模型部署指南-133e158f6717

4-https://www . curious ly . com/posts/deploy-keras-deep-learning-project-to-production-with-flask/？FB clid = iwar 1t 8 efuozsh 0s 5t TN 9 b-evbnwp 1 nwr 89 wayzdg 5 e _ twa pwk 1 bggvqzrc 2u # build-rest-API

在 Apache PySpark 中引入时间序列数据的端到端插值

原文：https://towardsdatascience.com/end-to-end-time-series-interpolation-in-pyspark-filling-the-gap-5ccefc6b7fc9?source=collection_archive---------5-----------------------

Photo by Steve Halama on Unsplash

任何处理数据的人都知道现实世界中的数据通常是不完整的，清理数据会占用你大量的时间(有人知道 80/20 法则吗？).最近从 Pandas 搬到 Pyspark，我已经习惯了 Pandas 提供的便利，而 Pyspark 由于它的分布式特性有时会缺乏这些便利。我一直特别缺少的一个特性是插值(或填充)时间序列数据的直接方式。虽然填充缺失值的问题已经被讨论过几次(例如，这里的[]这里的 ])，但是我找不到一个来源，它详细描述了生成底层时间网格然后填充缺失值的端到端过程。这篇文章试图填补这个空白。从缺失条目的时间序列开始，我将展示我们如何利用 PySpark 首先生成缺失的时间戳，然后使用三种不同的插值方法(向前填充、向后填充和插值)填充缺失的值。使用在一组房屋中收集的传感器读取数据的例子来演示这一点。这篇文章的完整代码可以在我的 github 中的找到。

准备数据并可视化问题

为了演示这个过程，首先，我们生成一些测试数据。数据集包含两所房子的数据，并使用 sin()和 cos()函数为一组日期生成一些传感器读取数据。为了生成缺失值，我们随机丢弃一半的条目。

Creating the sensor data test set

Raw data set

下图显示了缺失值清晰可见的数据。

Read Data with Missing Entries

为了并行化数据集，我们将 Pandas 数据帧转换为 Spark 数据帧。注意，我们需要用 10⁹除日期时间，因为熊猫日期时间和火花的时间单位是不同的。我们还添加了列‘read time _ exist’来跟踪哪些值丢失了。

import pyspark.sql.functions as func
from pyspark.sql.functions import coldf = spark.createDataFrame(df0)
df = df.withColumn("readtime", col('readtime')/1e9)\
       .withColumn("readtime_existent", col("readtime"))

现在我们的数据框架看起来像这样:

Read Data prepared for interpolation with PySpark

插入文字

对读取的日期时间重新采样

第一步是对读取时间数据进行重新采样。如果我们和熊猫一起工作，这将是直接的，我们可以使用resample()方法。然而，Spark 在分布式数据集上工作，因此没有提供等效的方法。在 PySpark 中获得相同的功能需要三个步骤。在第一步中，我们按“房子”对数据进行分组，并为每栋房子生成一个包含等距时间网格的数组。在第二步中，我们使用 spark SQL 函数explode()为数组的每个元素创建一行。在第三步中，使用所得结构作为基础，使用外部左连接将现有读取值信息连接到该基础。下面的代码展示了如何做到这一点。

注意，这里我们使用的是 spark 用户自定义函数(如果你想了解更多关于如何创建 UDF 的知识，你可以看看这里的。从 Spark 2.3 开始，Spark 提供了一个 pandas udf，它利用 Apache Arrow 的性能来分布计算。如果您使用 Spark 2.3，我建议您研究一下这个，而不是使用(性能很差的)内置 UDF。

结果表的摘录如下所示:

可以看到，readtime _ existent 列中的 null 表示缺少读取值。

使用窗口函数的向前填充和向后填充

当使用向前填充时，我们用最新的已知值填充缺失的数据。相反，当使用向后填充时，我们用下一个已知值填充数据。这可以通过结合使用 SQL 窗口函数和last()和first()来实现。为了确保我们不会用另一个缺失值填充缺失值，可以使用ignorenulls=True参数。我们还需要确保设置了正确的窗口范围。对于向前填充，我们将窗口限制为负无穷大和现在之间的值(我们只查看过去，不查看未来)，对于向后填充，我们将窗口限制为现在和无穷大之间的值(我们只查看未来，不查看过去)。下面的代码展示了如何实现这一点。

请注意，如果我们想使用插值而不是向前或向后填充，我们需要知道前一个现有读取值和下一个现有读取值之间的时间差。因此，我们需要保留 readtime _ existent 列。

from pyspark.sql import Window
import syswindow_ff = Window.partitionBy('house')\
               .orderBy('readtime')\
               .rowsBetween(-sys.maxsize, 0)

window_bf = Window.partitionBy('house')\
               .orderBy('readtime')\
               .rowsBetween(0, sys.maxsize)

# create series containing the filled values
read_last = func.last(df_all_dates['readvalue'],  
                      ignorenulls=True)\
                .over(window_ff)
readtime_last = func.last(df_all_dates['readtime_existent'],
                          ignorenulls=True)\
                    .over(window_ff)read_next = func.first(df_all_dates['readvalue'],
                       ignorenulls=True)\
                .over(window_bf)
readtime_next = func.first(df_all_dates['readtime_existent'],
                           ignorenulls=True)\
                    .over(window_bf)# add columns to the dataframe
df_filled = df_all_dates.withColumn('readvalue_ff', read_last)\
                        .withColumn('readtime_ff', readtime_last)\
                        .withColumn('readvalue_bf', read_next)\
                        .withColumn('readtime_bf', readtime_next)

插入文字

在最后一步中，我们使用向前填充和向后填充的数据，通过一个简单的样条来插值读取日期时间和读取值。这也可以使用用户定义的函数来完成。

这给我们留下了一个包含所有插值方法的单一数据帧。它的结构是这样的:

Interpolated read data

形象化

最后，我们可以将结果可视化，以观察插值技术之间的差异。不透明点显示插值。

Original data (dark) and interpolated data (light), interpolated using (top) forward filling, (middle) backward filling and (bottom) interpolation.

我们可以清楚地看到，在上面的图中，间隙已被上一个已知值填充，在中间的图中，间隙已被下一个值填充，而在下面的图中，差异已被插值。

总结和结论

在这篇文章中，我们看到了如何使用 PySpark 来执行时间序列数据的端到端插值。我们已经演示了如何使用重采样时间序列数据，以及如何将Window函数与first()和last()函数结合使用来填充生成的缺失值。然后，我们看到了如何使用用户定义的函数来执行简单的样条插值。

希望这篇帖子有助于填补 PySpark 中关于端到端时间序列插值的文献空白。

原发布于https://walken ho . github . io。

Python 中的主题建模:潜在狄利克雷分配(LDA)

原文：https://towardsdatascience.com/end-to-end-topic-modeling-in-python-latent-dirichlet-allocation-lda-35ce4ed6b3e0?source=collection_archive---------0-----------------------

http://getwallpapers.com/image/398564

深入分析

如何开始使用 Python 中的 LDA 进行主题建模

前言:本文旨在提供潜在主题的综合信息，不应被视为原创作品。这些信息和代码通过一些在线文章、研究论文、书籍和开源代码被重新利用

介绍

简而言之，主题模型是一种统计语言模型，用于揭示文本集合中隐藏的结构。在实际和更直观的情况下，你可以把它想象成一项任务:

降维，不要将文本 T 在其特征空间中表示为{Word_i: count(Word_i，T) for Word_i in Vocabulary}，而是在主题空间中表示为{Topic_i: Weight(Topic_i，T) for Topic_i in Topics}

无监督学习，可以比作聚类，在聚类的情况下，主题的数量和聚类的数量一样，是一个输出参数。通过进行主题建模，我们建立了单词簇，而不是文本簇。因此，文本是所有主题的混合，每个主题都有特定的权重

标记，抽象文档集合中出现的最能代表其中信息的“主题”。

有几种现有的算法可以用来执行主题建模。最常见的有潜在语义分析(LSA/LSI)、概率潜在语义分析(pLSA)和潜在狄利克雷分配(LDA)

在本文中，我们将仔细研究 LDA，并使用 python 2.7 中的 sklearn 实现来实现我们的第一个主题模型

理论概述

LDA 是一个生成概率模型，它假设每个主题是一组潜在单词的混合，每个文档是一组主题概率的混合。

http://chdoig.github.io/pytexas2015-topic-modeling/#/3/4

我们可以将 LDA 的生成过程描述为，给定 M 个文档， N 个单词，以及之前 K 个主题，模型训练输出:

psi ，每个题目的字数分布 K

φ，每个文档的主题分布 i

LDA 的参数

Alpha 参数是代表文档-主题密度的狄利克雷先验集中参数——随着更高的 Alpha，文档被假定为由更多的主题组成，并导致每个文档更具体的主题分布。

Beta 参数是表示主题-词密度的相同的先验集中参数— 在高 Beta 的情况下，主题被假定为由大多数词组成，并且导致每个主题的更具体的词分布。

LDA 实施

完整的代码可以在 GitHub 的 Jupyter 笔记本上找到

加载数据
数据清理
探索性分析
为 LDA 分析准备数据
LDA 模型训练
分析 LDA 模型结果

加载数据

对于本教程，我们将使用在 NeurIPS (NIPS)会议上发表的论文数据集，该会议是机器学习社区中最负盛名的年度活动之一。CSV 数据文件包含了从 1987 年到 2016 年(29 年！).这些论文讨论了机器学习中的各种主题，从神经网络到优化方法，等等。

让我们从查看文件的内容开始

# Importing modules
import pandas as pd
import osos.chdir('..')# Read data into papers
papers = pd.read_csv('./data/NIPS Papers/papers.csv')# Print head
papers.head()

Sample of raw data

数据清理

因为这个分析的目标是执行主题建模，所以让我们只关注每篇论文的文本数据，忽略其他元数据列。此外，为了演示，我们将只查看 100 篇论文

# Remove the columns
papers = papers.drop(columns=['id', 'event_type', 'pdf_name'], axis=1).sample(100)# Print out the first rows of papers
papers.head()

去掉标点/小写

接下来，让我们对 paper_text 列的内容进行简单的预处理，使它们更易于分析，并得到可靠的结果。为了做到这一点，我们将使用一个正则表达式来删除任何标点符号，然后小写文本

# Load the regular expression library
import re# Remove punctuation
papers['paper_text_processed'] = \
papers['paper_text'].map(lambda x: re.sub('[,\.!?]', '', x))# Convert the titles to lowercase
papers['paper_text_processed'] = \
papers['paper_text_processed'].map(lambda x: x.lower())# Print out the first rows of papers
papers['paper_text_processed'].head()

探索性分析

为了验证预处理是否有效，我们将使用 wordcloud 包制作一个单词云，以获得最常见单词的可视化表示。这是理解数据和确保我们在正确的轨道上的关键，以及在训练模型之前是否需要更多的预处理。

# Import the wordcloud library
from wordcloud import WordCloud# Join the different processed titles together.
long_string = ','.join(list(papers['paper_text_processed'].values))# Create a WordCloud object
wordcloud = WordCloud(background_color="white", max_words=5000, contour_width=3, contour_color='steelblue')# Generate a word cloud
wordcloud.generate(long_string)# Visualize the word cloud
wordcloud.to_image()

为 LDA 分析准备数据

接下来，让我们将文本数据转换成一种格式，作为训练 LDA 模型的输入。我们从标记文本和删除停用词开始。接下来，我们将标记化的对象转换成语料库和词典。

import gensim
from gensim.utils import simple_preprocess
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwordsstop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])def sent_to_words(sentences):
    for sentence in sentences:
        # deacc=True removes punctuations
        yield(gensim.utils.simple_preprocess(str(sentence), deacc=True))def remove_stopwords(texts):
    return [[word for word in simple_preprocess(str(doc)) 
             if word not in stop_words] for doc in texts]data = papers.paper_text_processed.values.tolist()
data_words = list(sent_to_words(data))# remove stop words
data_words = remove_stopwords(data_words)print(data_words[:1][0][:30])

import gensim.corpora as corpora# Create Dictionary
id2word = corpora.Dictionary(data_words)# Create Corpus
texts = data_words# Term Document Frequency
corpus = [id2word.doc2bow(text) for text in texts]# View
print(corpus[:1][0][:30])

LDA 模型训练

为了简单起见，除了输入主题数量之外，我们将保持所有参数的默认值。对于本教程，我们将建立一个有 10 个主题的模型，其中每个主题是关键字的组合，每个关键字对主题有一定的权重。

from pprint import pprint# number of topics
num_topics = 10# Build LDA model
lda_model = gensim.models.LdaMulticore(corpus=corpus,
                                       id2word=id2word,
                                       num_topics=num_topics)# Print the Keyword in the 10 topics
pprint(lda_model.print_topics())
doc_lda = lda_model[corpus]

分析 LDA 模型结果

现在我们已经有了一个训练好的模型，让我们来想象一下主题的可解释性。为此，我们将使用一个流行的可视化软件包， pyLDAvis ，该软件包旨在以交互方式帮助:

更好地理解和解释单个主题，以及
更好地理解主题之间的关系。

对于(1)，您可以使用不同的λ参数值，手动选择每个主题来查看其最常用和/或“相关”的术语。当你试图给每个主题指定一个人类可以理解的名称或“含义”时，这很有帮助。

对于(2)，探索主题间距离图可以帮助你了解主题如何相互关联，包括主题组之间潜在的更高层次的结构。

import pyLDAvis.gensim
import pickle 
import pyLDAvis# Visualize the topics
pyLDAvis.enable_notebook()LDAvis_data_filepath = os.path.join('./results/ldavis_prepared_'+str(num_topics))# # this is a bit time consuming - make the if statement True
# # if you want to execute visualization prep yourself
if 1 == 1:
    LDAvis_prepared = pyLDAvis.gensim.prepare(lda_model, corpus, id2word)
    with open(LDAvis_data_filepath, 'wb') as f:
        pickle.dump(LDAvis_prepared, f)# load the pre-prepared pyLDAvis data from disk
with open(LDAvis_data_filepath, 'rb') as f:
    LDAvis_prepared = pickle.load(f)pyLDAvis.save_html(LDAvis_prepared, './results/ldavis_prepared_'+ str(num_topics) +'.html')LDAvis_prepared

结束语

在过去十年中，机器学习变得越来越受欢迎，计算可用性的最新进展导致人们寻求如何整合新方法来推进自然语言处理领域的方法呈指数增长。

通常，我们将主题模型视为黑盒算法，但是希望这篇文章能够阐明底层的数学、其背后的直觉，以及让您开始处理任何文本数据的高级代码。

在下一篇文章中，我们将更深入地了解如何评估主题模型的性能，调整其超参数以获得更直观和可靠的结果。

参考文献:

[1]主题模型—维基百科。https://en.wikipedia.org/wiki/Topic_model

[2]主题建模的分布式策略。https://www . ideas . Illinois . edu/bitstream/handle/2142/46405/paralleltopicmodels . pdf？sequence=2 & isAllowed=y

[3]主题地图—软件—资源— Amaral 实验室。https://amaral . northwestern . edu/resources/software/topic-mapping

[4]文本挖掘中的主题建模综述。https://thesai . org/Downloads/volume 6 no 1/Paper _ 21-A _ Survey _ of _ Topic _ Modeling _ in _ Text _ mining . pdf

感谢阅读。如果你有任何反馈，欢迎评论这篇文章，在 LinkedIn 上给我发消息，或者给我发邮件(shmkapadia[at]gmail.com)

如果你喜欢这篇文章，请访问我在 NLP 上的其他文章

[## 评估主题模型:潜在狄利克雷分配(LDA)

构建可解释主题模型的分步指南

towardsdatascience.com](/evaluate-topic-model-in-python-latent-dirichlet-allocation-lda-7d57484bb5d0) [## 自然语言处理(NLP)简介

自然语言处理简介

medium.com](https://medium.com/@shashank.kapadia/introduction-to-natural-language-processing-nlp-2a8fae09ed03) [## 构建块:文本预处理

本文是关于自然语言处理的后续文章的第二篇。这一系列…的目的

towardsdatascience.com](/building-blocks-text-pre-processing-641cae8ba3bf) [## 语言模型简介:N-Gram

本文是关于自然语言处理的第三篇文章。这一系列…的目的

towardsdatascience.com](/introduction-to-language-models-n-gram-e323081503d9)

端到端作者识别:离线与在线方法

原文：https://towardsdatascience.com/end-to-end-writer-identification-off-line-vs-on-line-approach-634b832d2b9b?source=collection_archive---------38-----------------------

对两个样本笔迹是否由同一人书写进行分类。

Photo by Estée Janssens on Unsplash

动机:

每个人都有自己独特的笔迹，有自己的特点和小细节，使其与众不同。如果我们随机选取两个由两个人书写的笔迹样本，我们可能会注意到笔画的构成方式、字母之间的间距和其他细节是不同的。在这篇文章中，我们将训练一个模型来尝试区分两个样本笔迹是否是同一个人写的。

数据集:

我们将使用 IAM 在线手写数据库,它给出了每个书写者的多个手写样本，以及手写样本构建过程中记录的笔画顺序。

该数据集使我们有机会使用两种不同的方法来解决书写者识别问题:

离线设置:

Static representation of handwriting

在离线设置中，我们有手写最终结果的静态图像。这给出了笔迹外观的全局表示。这种类型的表示可能最适合用作视觉模型的输入。

在这个设置中，我们将制作两个像上面这样的图像到一个连体视觉模型(在我们的例子中是 Resnet50 ),并尝试预测这两个样本是否是同一个人写的。

Simplified illustration of the off-line model

对图像进行预处理，以去除边缘上多余的空白，并将其大小归一化为(128，1024)，同时小心地保持前后相同的纵横比，以免使笔迹变形。

对每幅图像使用相同的编码器，为每幅图像产生固定长度的表示，然后将这两种表示组合起来，并提供给完全连接的层，最终进行预测。

由于我们有每个书写者的一组笔迹，我们将使用该信息通过选择来自同一书写者的两个样本来创建正面样本，并通过选择来自两个不同书写者的样本来创建负面样本。我们还确保相同的作者不能同时出现在训练集和评估集中。

在线设置:

Handwriting with individual strokes details

由于我们也将手写内容表示为一系列手写笔画，每个笔画路径的坐标为(x，y ),因此我们可以将此信息用作分类器的输入。这个坐标序列给出了产生最终手写结果所需的步骤，一次一行。它更详细地描述了这位作家与众不同的特点。

输入这种格式的最自然的方式是每个子笔画的图像序列，然而，每个手写有几十个笔画，每个笔画有多个子笔画线。由于内存问题，这使得它不实用，并且可能不是非常有效。这就是为什么我们必须将原始的线坐标作为一个(x，y)数序列提供给一个像 GRU 这样的顺序模型。

Simplified illustration of the on-line model

这有一个更轻的内存使用，我们将展示它可以很好地工作在一个比图像编码器小得多的模型上。

结果:

在线 Resnet 模型验证准确率: 88%
离线 GRU 模型验证准确率: 92%

这意味着，当应用于看不见的书写者时，GRU 模型可以以 92%的准确率分辨出两组笔迹是否出自同一个人之手。鉴于数据集的规模较小，这些结果令人鼓舞。

未来可能的改进:

有多种方法可以改进这个项目->

参数调整。
更好的(x，y)笔画序列预处理和特征工程。
寻找更真实的手写数据集(墨水笔在纸上),而不是手写的电子记录。
使用笔迹伪造的数据集作为用于训练/评估的硬负样本。

结论:

这是一个非常有趣的机器学习应用，因为它证明了每个人的笔迹都可以被识别。它还表明，在找到最佳方法之前，可以考虑用多种方法来模拟同一个问题。

数据:http://www . fki . INF . unibe . ch/databases/iam-on-line-手写-数据库/download-the-iam-on-line-手写-数据库

代号:https://github.com/CVxTz/handwriting_forensics

内生性介绍

原文：https://towardsdatascience.com/endogeneity-the-reason-why-we-should-know-about-data-part-i-80ec33df66ae?source=collection_archive---------4-----------------------

为什么我们应该了解我们的数据

描述不同类型内生性的例子

一个冰淇淋小贩在海滩上卖冰淇淋。他收集了两年的总销售额(Y)和销售价格(X)的数据。他将数据交给数据科学家，请他找出最佳销售价格。数据科学家拟合一个线性回归模型，Y = alpha+beta X+error，通过对利润函数=(X-cost)(alpha+beta X)求微分找到最优。

然而，冰淇淋供应商过去常常随着需求的增加而提高冰淇淋的价格。他忘了向数据科学家提及他的定价策略。线性回归认为，随着销售价格的增加，销售额增加(β> 0)或者斜率没有预期的那么负。因此，该模型得出的最优售价至少是次优的(如果对业务无害的话)。

一家商店给顾客赠送定制的优惠券。有不同的优惠券(有不同的优惠)。商店收集顾客反馈数据，即他们是否使用优惠券(Y)和优惠券详情(X)。他们想知道每张优惠券的有效性，以便将来可以定制并发送给不同的客户。

数据科学家拟合一个模型来预测每个客户从每张优惠券购买(下个月或接下来几个月)的概率。同样，商店有一个策略，他们发送优惠券给谁，他们发送什么优惠券(而不是随机优惠券)。例如，如果他们认为顾客即使没有优惠券也会购买，他们就不会发送优惠券，或者如果他们认为某人可能会购买，他们就会发送更多的优惠券。这一策略没有向数据科学家公开。如果将更多优惠券发送给具有更高购买机会的顾客，也可能给出有偏见的优惠券“有效性”。

富人变得更富，穷人变得更穷(概念上类似于后面解释的示例 2，但此示例旨在表明内生性不仅限于数据科学)。这在社会学上也叫马修效应。努力工作帮助电影艺术家赢得奖项。制片人希望与获奖的艺术家建立联系，因为他们将奖项与表演质量联系在一起，因此他们获得了更好的机会，从而获得了更多的认可和更多的奖项(同样，富人变得更富)。

所有这些例子都违背了实验设计的基本原则之一——随机化。很多时候，一个公司无法承担随机化。在现场实验中，受试者被随机分配到不同的处理水平(或者我们应该随机设置自变量的值并观察因变量)。但是在上面的例子中，这被违反了(因为独立变量依赖于特定的策略——由冰淇淋供应商/商品商店/电影制片人)。

换句话说，独立预测变量(X)应该是外生而不是内生。外生变量不受其他因素驱动(可观察或不可观察)。在第一个例子中，价格由温度决定。在第二个例子中，优惠券是由过去的销售推动的)。内生变量与误差项相关，我们来解构一下。

模型中的响应(Y)应该用独立变量(X)来解释，所有不能用 X 来解释的都包括在误差项中。(我们知道线性回归中多重共线性的问题和不利影响——在多重共线性的情况下，X1 由 X2 解释)。如果有一个因素可以解释 Y 但没有被观察到，比如 Z，它就包含在误差中。但是如果 Z 可以解释任何 X(在例 1 中，Z =温度，X =价格)，误差项与 X 相关(因此，价格是内生变量)。因此，当我们有一个与 Y 相关的 Z，但它也与 X 相关，并且不包括在模型中时，内生性问题就出现了。

内生性有多种来源——如果供应商根据时间改变位置会怎样，如果供应商根据队列改变价格会怎样。内生性的来源可以大致分为:

省略变量(如冰激凌示例所解释的，价格是内生变量，温度是省略变量)。
s 同态性(例 2)其中 X 引起 Y，Y 引起 X，这是最常见的，也是最难的一个。在省略变量的情况下，如果结构信息是已知的，那就很简单了(这将在本博客的第 2 部分中讨论)。示例 2 是优惠券导致销售和销售导致给顾客更多优惠券的同时性的示例。在例 1 中，如果卖方基于队列长度改变作为控制的价格(在动态规划或顺序控制理论中研究的),这是队列导致价格和价格导致队列的同时性。同时也可能是自选造成的。**
选择偏差(例 3)如果取样有偏差，我们无法确定治疗对受试者的影响。例如，如果我们收集周末或高档社区的冰淇淋销售数据。如果我们的样本主要包括获奖者，我们会高估演员的表演质量。赫克曼博士就此课题获得了诺贝尔经济学奖(此处)。

修订一些定义:

P(X=x，Y=y)是一个联合分布
P(X=x|Y=y)是给定 Y 时 X 的条件分布
P(X=x) = sum [ P(X=x|Y=y)P(Y=y)除以所有 y]是 X 的边际
如果 P(X=x，Y=y) = P(X=x)P(Y=y)，那么 X 独立于 Y

我希望下面的陈述现在更有意义(简单地说就是自变量被战略性地设定或者其中自变量是内生的):

当自变量的边际分布不独立于因变量的条件分布时，内生性就产生了。

如果不考虑内生性呢？

这些例子说明了两个原因:首先，模型中自变量的实际影响可能被低估或高估。其次，基于模型推断的决策可能是次优的。
当数据科学家在不考虑内生性的情况下拟合模型时，模型拟合更好(增加了对错误事物的信心)。第二部分解释了这项索赔。

内容大量取自这里和这里。此处，我们将在处浏览所讨论的冰淇淋供应商案例。这里将介绍同时性和本文中使用的参考文献。

原载于 2019 年 6 月 2 日 https://medium.com**T21。

处理第一类内生性

原文：https://towardsdatascience.com/endogeneity-the-reason-why-we-should-know-about-data-part-ii-c1487d69aeed?source=collection_archive---------16-----------------------

为什么我们应该了解我们的数据

用冰淇淋小贩的例子来解释第一类内生性

在这里我们通过例子讨论了内生性的含义，内生性的几种可能来源以及它为什么重要。这一部分集中在冰淇淋供应商的例子，以深入探讨为什么我们应该小心内生性。线性回归模型由下式给出:

Sales _ I = alpha+beta Price _ I+error _ I(m1) error _ I ~ N(0，var_e)

在第一部分之后， Price_i 是一个内生变量，因为它可以用 temperature_i 来解释。从而| cov(Price_i，error_i)| > 0。设 Price_i ~N(p，var_p) 。

考虑到 Sales_i 和 Price_i 的分布为二元正态分布，我们可以推导出 S ales_i|Price_i. 的条件分布，这是一个标准推导，其推导可以在这里检查。

如左图所示，如果忽略内生性:
1。我们没有计算真实系数，导致次优，因为我们正在计算 alpha' 和 beta' 。
2。与模型的差异( Sales_i|Price_i )低于实际差异。
这可能会给我们错误的信心认为模型表现(适合)得很好。

补救措施

使用温度 _i 预测价格' _i ，并将价格 _i 替换为 m1 中的价格' _i 。这里，温度 _i 称为工具变量(IV) ，这种方法称为 IV 方法
用 Temperature_i 预测 Price'_i 求 E_i = Price_i-Price'_i 并使用:
Sales _ I = alpha+beta Price _ I+gamma E _ I+error _ I(m2)
如果有内生性，gamma 的质量会从 0 偏移。或者干脆，|gamma| > 0 有把握(统计显著)。这种方法被称为控制功能方法。

省略变量的内生性需要问题结构的知识，但如果知道，这是很简单的。然而，找到合适的 IVs 是非常困难的。可以采取预防措施，因为发现薄弱或错误的静脉注射会导致更坏的结果。

下面的陈述是我的意见和主张，可能是错误的:

的高度非线性函数逼近【Sales_i=f(Price_i) 例如，随机森林/隐马尔可夫模型/深度学习可以处理内生性，因为底层非线性隐结构旨在找到 Price_i。在因子分析或 SVD 中，如果该问题被处理为 Sales_i 和 Price_i 的联合 pdf，则隐藏/潜在因子类似于 IVs。

更普遍和困难的内生性问题是同时性的情况。此处介绍了关于同时性的讨论。

原载于 2019 年 6 月 2 日 https://medium.com*。***

处理第二类内生性

原文：https://towardsdatascience.com/endogeneity-the-reason-why-we-should-know-about-data-part-iii-50380e0d996e?source=collection_archive---------17-----------------------

为什么我们应该了解我们的数据

处理第二类内生性的文献中的例子

通过介绍和处理一种“更简单”形式的内生性(第一类)，这部分探讨了更困难的同时内生性问题。当 Y 引起 X，X 引起 Y 时，同时发生(富者愈富)。

这个问题很难回答。添加工具变量(iv)可能对
2 没有帮助。这是最常见的，也很难诊断(或识别)3。X 是 i.i.d. 的标准假设不成立(一月份优惠券数量的影响可能会持续到三月份)。

如果不纠正同时性，错误模型的不良影响和对错误模型的信心仍然对同时性有效(如第二部分省略变量所述)。在大多数向客户发放优惠券的公司中，优惠券是根据某种策略决定的(这可能是之前的数据科学家构建的模型)。

博客不能涵盖同时性。因此，一些关于在哪里同时阅读的例子。

例 1。药品明细:制药公司向医生投放广告。他们在处方量较高的医生身上花费更多。数据科学家可以在模型中使用滞后处方，其中当前处方不仅取决于当前的详细程度，还取决于以前的处方。

例二。电影/产品/节目在不同的城市相继上映，这取决于在影院上映的竞争电影以及来自电影先前上映城市的电影评论。因此，在哪里和哪个城市上映电影的决定取决于电影的表现。选择合适的工具变量(或使“其他事物等于”)的控制变量，内生性是可以处理的。思路是:驱动前几个城市票房的外生变量会驱动下一个城市的票房。因此，找到正确的 IVs 有助于对抗同时性。在论文中，他们使用竞争电影的指标作为 iv。

例 3。一家公司可能会根据 R、F、M 值(非常常用:新近度、频率和货币)向买家发放优惠券。t-1 时的 RFM 可用作控制变量(因为它们与 t 时的误差无关)。也可以考虑控制函数(第二部分)方法，其中 R、F、M 回归为 t-1 时 R、F、M 的函数，R、F、M 的预测值和实际值之间的差异用作销售建模时的独立变量。

例 4。在冰淇淋供应商示例中，可以使用价格和 error_i 的联合概率分布，而不是使用温度作为 IV。虽然 IVs 控制方法模型需要数据收集的精确结构，但它并不总是可用的。例 1 中考虑的模型假设了响应模型的知识(X|Y 如何导致 Y ),这也是未知的。Copula 方法是一种使用回归量 X 和 error_i 的联合分布的无模型方法。Copula 是一种将 m 维多元分布耦合到 m 个一维边际的函数。这种方法使用最大似然法来获得联合分布。

我希望这三个部分能让你明白了解数据来源的重要性(数据是如何创建或收集的)。虽然现代机器学习方法能够通过省略变量来处理内生性，但是同时在建立模型之前需要一些头脑风暴。

这些参考资料是:

内生性的非技术性指南(博客第一、二部分的基础论文)
药品详情:市场研究杂志
用户评论对电影表现的影响:市场营销科学
用 copulas 处理内生性:营销科学
税收优惠券:管理科学

原载于 2019 年 6 月 2 日 https://medium.com**的 。

英国的能源——能源性能证书分析

原文：https://towardsdatascience.com/energy-in-the-uk-analysis-of-the-energy-performance-certificates-585665721b9c?source=collection_archive---------30-----------------------

Photo by Heidi Sandstrom. on Unsplash

自从我发表了关于伦敦智能电表和可能的数据分析的文章后，我定期收到人们的消息，他们有兴趣将智能电表数据和家用监视器的能效联系起来。我在本文中写道没有直接的方法将智能电表数据、acorn 和家庭能效联系起来，但是围绕家庭能源和能效的其他数据集仍然有一些有趣的事情要做。

很久以来，我一直想写一篇关于我在以前的工作中测试过的有趣工具的文章，这就是来自数据库的 DSS，它对于处理数据的人来说非常有趣。在这篇文章中，我将介绍这个工具和其他数据集。

什么是大台库 DSS

Dataiku DSS 是由法国公司 Dataiku 开发的产品，在其网站上被定义为“数据科学家、数据分析师和工程师团队的协作数据科学软件平台，以更有效地探索、原型化、构建和交付他们自己的数据产品”。

简而言之，它是一个简化公司中数据/模型处理和共享的工具，我真的邀请你去看看他们的网站，那里描述了许多商业案例和平台的功能。但是需要知道的是平台有两种版本:

免费版:我在我的机器上托管的这个项目中使用的(但是有一个版本也可以在 dataiku 服务器上免费托管)
企业版:提供更多的数据连接器(Hive 等)和更少的限制，网站上没有公布价格，因为我认为这是基于客户的需求，但我听说它并不便宜。但是有一个 2 周的免费试用来测试这项服务。

免费版的安装非常简单，你可以在所有可能的操作系统上安装它。在展示完数据后，我将深入研究该软件的功能。

描述数据

对于这个项目，我将使用以下数据源:

EPC:这是英国的多份业绩证书的集合(大约 1500 万)
Nomis data :该网站收集了不同人口普查期间(最近一次是 2011 年)在英国收集的多种信息

让我们看一下数据集的更详细描述。

经济和计划委员会(Economic and Planning Council)

首先，什么是 EPC？这很简单，它是一个家庭的能源性能评级，下图中有一个例子。

例如，它就像可以在设备上找到的那个，并且它需要在每个新租户或房东处被刷新。住房、社区和地方政府部开放的数据源非常完整(超过 1500 万份证书)，并且不仅仅是对这些数据的简单评级(数据字典)，还有关于玻璃、能耗和建筑面积等信息。

Nomis 数据

Nomis 网站“是国家统计局提供的一项服务，免费提供来自官方来源的最详细和最新的联合王国劳动力市场统计数据”，该网站上有在不同人口普查期间收集的关于联合王国公民的多种信息。有很多详细的信息，人口普查的数据主要用于创建我在关于智能电表的文章中定义的 ACORN 组。

从这个门户网站上，我提取了英国公民在地区层面上的信息:

职业
资格
国家统计-社会经济分类
人口

让我们现在就开始吧。

决策支持系统中的数据处理

为此项目提取的所有数据都是 csv 文件，下面的动画演示了在 DSS 中创建数据集的过程。

在 DSS 中可以很容易地拖放文件，你可以对数据、质量等有一个总体的了解。在免费版本中，也可以连接 SQL 数据库，非常简单。

对于这个项目，想法是连接来自 EPC 的数据和 Nomis 数据，因此有很大一部分证书处理要在地区级汇总并连接到 Nomis 数据。

有一个完整过程的概述

下图显示了准备 EPC 数据集的流程，该数据集可与 Nomis 数据连接。

有一个准备阶段(使用画笔)，其中有一个正确的列选择，处理邮政编码以获得区号。

与上一步一样，第二步是准备数据集，以找到家庭的最新 EPC(检查日期的正确格式)。

为了获得数据集中每户家庭的最后检查日期，有一个 group by(过程图像上的正方形三角形圆圈图标)函数，下面的动画中有一个过程的图示。

现在我们已经清理了 EPC，并在另一个表中列出了每个家庭的最后检查日期，这两个数据集之间用连接函数进行了连接(流程中的连接标志)，现在有一个连接菜单的显示，您可以在其中选择连接键和所选的列。

最后，根据每个地区的功能、家庭类型、供暖系统类型和 EPC 等级进行分组。

最后一步是使用 python 脚本，通过 pandas 的 pivot 函数(每个等级的 EPC 计数和家庭类型)获得地区级别的汇总信息，但我也可以使用 DSS 的 pivot 函数。

瞧，我们有了汇总到区一级的 EPC 数据，这让我们了解了这一级别的家庭评级和家庭类型。

使用 join 函数可以很容易地将这些数据与 Nomis 的数据连接起来。

我使用了 DSS 的一些内部函数来执行 join，groupby，但是我可以使用:

构建数据集的 python 或 R 脚本
如果是 SQL 表，则为 SQL 脚本
“大数据”配置中的 Hive 或 impala

现在数据可用了，让我们做一个分析和一个仪表板来总结一些结果。

决策支持系统中的数据分析

这些分析将会是超高水平的，这只是为了展示 DSS 的特性。

这是我用 DSS 制作的仪表板的动画。

这个仪表板的构建要比 Tableau 容易得多(我的观点)，但是他们共享这种拖放方法来构建每个非常有用的图表。

有一种方法可以使用实验室工具直接从数据集进行一些分析，其中可以使用内部函数(例如确定相关性)或使用一些脚本来分析数据，在这种情况下，我选择 python 来使用 seaborn 进行一些绘图。

分析部分真的很酷，我认为它可以满足很多需求，但另一个令人印象深刻的部分是基于处理的数据建立模型的 ML 部分。

决策支持系统中的模型服务

因此，构建模型有多种方法，但首先让我们定义这一部分的目的:

“根据位置、总建筑面积和家庭供暖类型建立一个能量等级估算器”

DSS 为您提供了三个“级别”来构建模型，但老实说，这是相同的界面，只是您在模型配置部分的旅程是从菜单的更高层次开始的。

在构建模型的菜单中，可以:

准备培训和测试集
选择评估指标
拿起功能
选择网格搜索的模型和参数
在测试部分之后比较模型

有一个简单的动画概述了模型构建器的特性。

有趣的是，您可以使用预构建的函数(我假设 scikit 学习函数)，或者编写自己的 python 代码。就过程和结果的可视化而言，测试模型的工具确实令人印象深刻。

很好的一点是可视化的结果，例如一个非常容易理解的决策树(用这个工具分解)。

在你找到合适的模型后，会有一个 API 生成器来嵌入这个模型。在这个空间中，您可以定义一些测试请求来查看运行中的模型。

为了展示这个模型，免费版没有激活这个特性(或者我错过了使用它)，但是它看起来非常直观。

现在是总结的时候了。

对项目的反馈

我将强烈推荐在能源领域工作/感兴趣的人去钻研 EPC 数据，因为他们是英国房产市场知识的一个很好的来源。总的来说，对我这个最法国的外国人来说，这么说很痛苦，但英国政府在收集和共享数据方面做得很好，政府平台上有非常有趣的数据集可供数据科学家使用(在法国，我们在这个问题上起步很晚，但事情正在慢慢改变)。

对于 Dataiku DSS 来说，它是一个伟大的工具，无论数据科学家是否试验过，我都能感觉到这个工具是由数据科学家为数据科学家设计的，有太多的功能我没有使用过，比如所有的协作部分，深度学习等等。有多个内部功能可以使数据处理更容易，这真的很酷，但如果 Dataiku 决定放弃这些功能(或使其成为高级功能)，如果数据人员不知道如何加入 groupby 等，数据管道传输可能会很困难，但我真的很喜欢 Dataiku 没有让用户使用他们的内部功能，而是让其他方法操作数据的可能性(例如 SQL)成为可能。

在我的日常工作中，DSS 能满足我的需求吗？没有，因为我目前有多种工具可供我使用来完成我的工作，我需要在数据端和开发端的灵活性来试验和部署东西，但这个工具绝对值得尝试，因为它可以满足没有我的需求的数据团队的需求(他们在世界各地有很多)。

最初发表于 的古怪数据家伙 。

比特币挖矿和人工智能的海量计算

原文：https://towardsdatascience.com/energy-smart-bitcoin-mining-dd7bd2d2a3fa?source=collection_archive---------27-----------------------

走向数据科学

能源(各种形式)就是金钱！另一种方式是智能节能，并在加密活跃的世界和不断增长的人工智能部署中应对能源挑战。

Energy-Smart Bitcoin Mining by Stephane Bilodeau

Energy-Smart Massive Computing for Bitcoin Mining and AI in TowardsDataScience by Stephane Bilodeau

为什么比特币消耗这么大？

这应该被认为是原始的，秘密矿井目前产生大量的热量，然后在许多工业、农业、建筑等领域排放它们。燃烧丰富的化石燃料来产生热量。密码可以非常有效地将电能转化为大量热能。因此，明智地使用，数据挖掘可以更有效，因为取暖费用可以抵消。

区块链还将允许许多数据库操作从昂贵的位置分布到远程位置，不仅提供能源效益。

Photo by Dmitry Moraine on Unsplash

为了创造比特币，数以吨计的服务器，即“采矿机器”，被连接到加密货币网络。他们负责检查兑换比特币的人所做的交易。因此，连接到该系统的计算机的总功率(和消耗)解释了该系统疯狂的碳足迹。

比特币网络确实存在能耗的问题。尽管每年处理不到 1 亿笔金融交易，但它消耗大量能源。相比之下，传统金融业每年处理 5000 亿笔交易。如果我们考虑数据中心使用的能源量，比特币每笔交易消耗的能源比世界上所有银行消耗的总和还要多。

对计算能力的高需求

开采加密货币比开采黄金消耗更多的能源也就不足为奇了。众所周知的研究，尤其是去年年底发表在《自然》杂志上的一篇文章已经证实了这一点。

对于所产生的美元价值，计算机密集型的“开采”数字货币的过程比物理开采黄金、铂或稀土金属消耗更多的能源。《自然》杂志上的这项研究对开采加密货币的能源和碳成本进行了有趣的量化。只有铝矿的每美元消耗量超过了主要加密货币的消耗量。

Credit: Quantification of energy and carbon costs for mining cryptocurrencies by Krause and Tolaymat published in Nature 2018

开采贵金属是一项艰苦的工作，需要大型机器、大型熔炉和苛刻的化学物质来提取像黄金和铜这样的资源。在加密挖掘方面，大量的“虚拟”工作用于挖掘数字货币。许多数字货币——比特币是最著名的例子——是通过让计算机研究越来越难的数学问题而产生的。

随着比特币等数字货币越来越受欢迎，能源需求只会上升——这不仅仅是因为对采矿的兴趣增加。人们担心的不仅仅是消耗的能源数量，还有这种能源所代表的导致气候变暖的碳排放量。

回想一下，需要大的计算能力，既要管理比特币的流动，也要挖矿。这种加密货币的良好运行因此爆炸了功耗。科学杂志 Joule 的另一项研究也估计，用于比特币的电力每年将产生 2200 万吨二氧化碳，这一数字与约旦或斯里兰卡等国家的数字非常接近。加密货币对环境有什么影响？对于这个问题，剑桥大学试图通过提出剑桥比特币电力消耗指数工具来部分回答。

剑桥大学的工具模拟了世界各地比特币矿工的操作。它使用的平均电力成本约为每千瓦时 0.05 英镑，以及比特币网络的能源需求。最后，假设世界上所有的比特币挖矿机都以不同的效率运行。

Cambridge Bitcoin Electricity Consumption Index

后者每三十秒显示一次与比特币相关的全球消费。在撰写这些文章时，star 加密货币将消耗 7.23 千兆瓦，每年总消耗估计为 61.88 太瓦时(太瓦/小时)……超过瑞士、科威特、希腊或阿尔及利亚，但略低于捷克共和国或奥地利。

大规模计算:人工智能也受到关注

去年，OpenAI 发表了一份分析，记录了过去六年计算能力的爆炸，这推动了人工智能的进步。这篇文章发现，自 2012 年以来，最大规模的人工智能训练中使用的计算能力每 3.5 个月翻一倍。

下面的图表显示了用于训练选定结果的总计算量，这些结果相对而言是众所周知的，使用了大量的计算时间，并提供了足够的信息来估计所使用的计算。一个 petaflop/s-day (pfs-day)由一天每秒执行 1015 次神经网络运算组成，或总共约 1020 次运算。这个计算时间参数是一种心理上的便利，类似于能量的 kW-hr。顺便说一下，能耗往往会随着千万亿次浮点运算成比例增加…

Credit: Dario Amodei & Danny Hernandez, openai.com

计算的改进一直是人工智能进步的关键组成部分，所以只要这一趋势继续，就值得为远远超出今天能力的系统的影响做好准备。但人工智能和机器学习的能源供应也需要改善。

海量计算:人工智能也可以成为解决方案的一部分

如果没有很好的组织，人工智能将产生与使用能源的加密货币完全相同的问题，但甚至更大。

AI 使用相同或相似的芯片技术，因此每个设备产生的热量相似。简单地消除产生的热量或者更糟的是通过使用空调来消除热量是一个可怕的原始解决方案。在部署第一代这些技术之后，当前这种去除免费但不需要的能量的方法应该会消失。如果不是这样，与我们将面临的功耗和人工智能、机器学习、预测分析所需的所有连接对象的散热量相比，我们看到的加密活性物将是很小的。

因为，所有的能源都是物有所值的，散热应该作为一种能源而不是纯粹的能源浪费。

绿化数字化运营

因此，让我们将能源挑战转化为机遇，提出解决方案。包括人工智能、可再生能源和混合储能在内的清洁技术的结合提供了很好的选择。利用采矿作业产生的废能回收和热量转换来提供能源。在以前的文章中讨论了许多选项:

[## 绿色还是绿色，这是一个秘密问题！

加密货币能源范式的必要变革。

medium.com](https://medium.com/@smbilodeau/to-be-green-or-not-to-be-that-is-the-crypto-question-536f302f4498) [## 组合效应对抗蝴蝶效应

人工智能促进储能，为可再生能源提供弹性和效率…

towardsdatascience.com](/the-combo-effect-against-the-butterfly-effect-bf7dd7a507a0)

当政府间气候变化专门委员会( IPCC )不断重复呼吁面对全球变暖要谨慎时，这种耗能技术的使用显然受到质疑。

设想一种基于“空间证明/时间证明”安全性的“绿色”加密货币的解决方案已经存在。因此，质疑公共当局参与开发这些绿色技术是有意义的。

所以，让我们现在就开始改进，趁这个领域还处于起步阶段。反过来，这将绝对有助于利用我们看到的人工智能、机器学习、预测分析等越来越多的使用即将面临的能源挑战。

Photo by Bruna Fiscuk on Unsplash

作者，夏羽·比洛多，ing。是清洁技术领域的企业家，致力于创新，尤其是在储能、可再生能源和人工智能领域。他是 Smart Phases ( Novacab )的创始人兼首席技术官、 Engineers Canada 的研究员以及 Energy Central 和 Medium 的专家撰稿人。

你也可以看看 TowardsDataScience 和 The Startup 中的其他文章，主要讨论能源和人工智能，或者颠覆性融资，包括新的脸书天秤座加密货币和其他区块链技术:

[## 以眼还眼，以暴制暴

我们如何利用颠覆性技术和前瞻性领导来应对颠覆性气候

medium.com](https://medium.com/swlh/an-eye-for-an-eye-a-disruption-for-a-disruption-141b317ac52b) [## 绿色还是绿色，这是一个秘密问题！

加密货币能源范式的必要变革。

medium.com](https://medium.com/@smbilodeau/to-be-green-or-not-to-be-that-is-the-crypto-question-536f302f4498) [## 人工智能，服务于能源转型？

虽然人工智能在能源领域已经取得了多年的进展，但许多人担心有一天…

www.energycentral.com](https://www.energycentral.com/c/cp/artificial-intelligence-serving-energy-transition) [## 人工智能和储能将从哪些方面改变能源领域？(第二部分)

全球能源行业在生产、销售和分配能源的方式上面临着根本性的变化。还有一些…

www.energycentral.com](https://www.energycentral.com/c/gn/what-ways-will-artificial-intelligence-and-energy-storage-change-energy-sector) [## 没有智能储能，就没有快速(足够)的能量转换！

人工智能和储能 fast 需要强耦合，以便与可再生能源实现高效过渡，从而对抗狂暴的…

towardsdatascience.com](/no-fast-enough-energy-transition-without-intelligent-energy-storage-72cfbd3c096b)

ENet——一种用于实时语义分割的深度神经架构

原文：https://towardsdatascience.com/enet-a-deep-neural-architecture-for-real-time-semantic-segmentation-2baa59cf97e9?source=collection_archive---------7-----------------------

论文摘要

Fig 1. A conversation between a semantic segmented guy and a toon

这是一篇论文的论文摘要: ENet:一种用于实时语义分割的深度神经网络架构 by亚当·帕兹克 论文:https://arxiv.org/abs/1606.02147

概观

ENet(高效神经网络) 提供实时执行逐像素语义分割的能力。ENet 的速度提高了 18 倍，所需的 FLOPs 减少了 75 倍，参数减少了 79 倍，精度与现有模型相当或更高。在 CamVid、CityScapes 和 SUN 数据集上进行了测试。

Fig 2. Semantic Segmentations using ENet

方法

Fig 3. ENet Architecture

以上是完整的网络架构。
它分为几个阶段，如表中的水平线和每个块名后的第一个数字所示。
报告输入图像分辨率为512 * 512时的输出尺寸

Fig 4. Each module of ENet in detail

的直观表示:初始块如 (a)
- 所示，瓶颈块如 (b) 所示

每个瓶颈模块由:

1x1 投影降维
-一个主卷积层(*conv* )(要么— 正则，扩张或满)(3x 3)
-1x1 扩展

如果瓶颈是缩减采样，则最大池图层将被添加到主分支。此外，第一个 1x1 投影被替换为跨距=2 的 2x2 卷积。

它们将激活填充为零，以匹配特征映射的数量。

conv有时是非对称卷积，即一系列5 * 1和1 * 5卷积。

对于regularizer，他们使用空间落差 :
-瓶颈前带p = 0.012.0
-瓶颈后带p = 0.1

所以，

阶段 1，2，3— 编码器 —由 5 个瓶颈块组成(除了阶段 3 不下采样)。
阶段 4，5— 解码器 —阶段 4 包含 3 个瓶颈，阶段 5 包含 2 个瓶颈
后跟一个fullconv，它输出维度为C * 512 * 512的最终输出，其中C是滤波器的数量。

还有几个事实:
-他们没有在任何投影中使用偏差项
-在每个卷积层和激活之间，他们使用批量归一化
-在解码器中，MaxPooling 被替换为 MaxUnpooling
-在解码器中，Padding 被替换为没有偏差的空间卷积
-在最后一个 ( 5.0 )上采样模块
中没有使用池索引-网络的最后一个模块是完全卷积，它单独
-每个分支都有一个空间落差，第一阶段为p = 0.01，随后阶段为p = 0.1。

结果

使用 SegNet[2]作为基准，在

CamVid (道路场景)
城市风景(道路场景)
SUN RGB-D (室内场景)
上对 ENet 的性能进行基准测试，因为它是最快的分割模型之一。使用 cuDNN 后端使用 Torch7 库。

推理速度是使用 NVIDIA Titan X GPU 以及在 NVIDIA TX1 嵌入式系统模块上记录的。输入图像大小为 640x360 时，达到 10fps 以上。

Fig 5. Inference Time Comparison on the two different GPUs with SegNet as the baseline

Fig 6. Hardware requirements for SegNet and ENet

基准

用于亚当 。 ENet 收敛速度非常快，在每个数据集上，使用 4 个 Titan X GPUs 的训练只需要大约 3-6 个小时。

分两个阶段执行:
-首先，他们训练编码器对输入图像的降采样区域进行分类。
-然后追加解码器，训练网络执行上采样和逐像素分类。

学习速率— 5e-4
L2 重量衰减 2e-4
批量大小 10

自定义等级称重方案定义为

Fig 7. The formula for the custom class weighing scheme

其中 c = 1.02
并且类权重被限制在【1，50】的区间内

Fig 8. Performance on CityScapes Dataset

Fig 9. Performance on CamVid Dataset

Fig 10. Performance on SUN RGB-D dataset

参考

A. Paszke，A. Chaurasia，S. Kim 和 E. Culurciello。Enet:用于实时语义分割的深度神经网络架构。arXiv 预印本 arXiv:1606.02147，2016。
V. Badrinarayanan，A. Kendall，R. Cipolla，“Segnet:用于图像分割的深度卷积编码器-解码器架构”，arXiv 预印本 arXiv:1511.00561，2015 年。

我最近也转载了这篇论文，可以在这里找到:https://github . com/iArunava/ENet-Real-Time-Semantic-Segmentation

感谢阅读！一定要看报纸！

如果我发现其他有趣的见解，我会更新的！

对行走分数算法进行逆向工程

原文：https://towardsdatascience.com/engineer-walkscore-4dc1730b976c?source=collection_archive---------20-----------------------

使用机器学习建立可行走性评分

Heatmap of Predicted Walk Scores throughout Seattle, WA

我住在西雅图，最近搬到了另一个社区。根据步行评分的专有算法，我从西雅图最适合步行社区的第 9 名升至第 30 名。我仍然可以很容易地走到当地的咖啡店和理发店，但仅此而已！我可以说，我已经搬到了一个不太适合步行的社区，但不清楚如何量化这个数值，也不清楚步行性得分是多少。

我之前使用过步行评分 API 作为预测电动滑板车位置聚类的数据源。Walk Score 是一个网站，它获取一个地址，并使用专有算法和各种数据流在 0-100 的范围内计算其可步行性。

作为一个喜欢步行到达目的地的人(还有徒步旅行！)，我很好奇是什么推动了这些产生可步行性分数的专有算法。我开始提出以下问题:

专有的 Walk Score 算法可以被逆向工程吗？

2.在构建可行走性评分时，哪些特征是重要的？

为了回答这些问题，我通过收集一组不同的粒度西雅图市数据和步行分数 API 数据来建立一个自定义数据集，以训练机器学习模型来预测步行分数。我能够训练一个模型，在测试集数据上达到 0.95 的 R。r 平方解释了特征集的方差在多大程度上解释了行走分数的方差。

本质上，我能够逆向工程的步行评分方法，并重新创建专有的算法，他们的步行评分。对于一个位置的步行性来说，最重要的特征是 1000 米范围内的餐馆数量、人口普查区域内的人口密度、1000 米范围内的超市数量以及与最近的商业区的距离(以米为单位)。

数据源和机器学习管道

The Full Data Pipeline for Reverse Engineering the Walk Score Methodology

数据

我从随机生成大西雅图地区的经纬度坐标开始。有了大约 7800 个唯一地理位置的列表后，我利用 Walk Score API 返回每个唯一地理位置的可步行性分数。然后，我开始收集反映一个地点周围区域可步行性的数据。

数据来源:

OSMnx : Python 包，允许您从 OpenStreetMap 的 API 下载空间几何图形和模型、投影、可视化和分析街道网络。
步行评分 API :返回任何地点的步行性评分。
LocationIQ API :附近兴趣点(PoI) API 返回给定坐标周围指定的 PoI 或地点。
西雅图城市分区:分区指定使用类别(例如，独栋住宅、多户住宅、商业、工业等。)
西雅图人口普查数据:为人口普查区和地理标识符内的人口普查区提供人口和平方英里面积
美国人口普查地理编码器 API :对于给定的地理位置，API 返回人口普查区域和唯一的地理标识符。这对于正确合并分区和普查数据至关重要。

特征工程

由于 LocationIQ API 每日请求的限制，我将数据收集阶段延长了两周。这给我留下了大约 7800 个独特的地理位置，然后我设计了 27 个特征来训练机器学习模型，以预测整个西雅图的步行能力。

Full Feature Set

这些功能分为四类:

基于便利设施:指定半径内的公交车站、公园、餐馆、学校和所有便利设施的数量(大多数便利设施使用 1000 米半径)

2)普查得出:分区类别和人口密度

Geolocation Observations Grouped by Zoning Category

3)基于距离:邻近最近的高速公路、最近的主要道路、最近的次要道路、最近的住宅道路、最近的工业分区

4)步行网络结构:交叉口数、平均迂回度、平均街道长度、每个节点平均街道数

A single geolocation plotted on top of the OSMnx library for Walk Network Structure feature generation

模型开发

我训练了三个机器学习模型:随机森林回归、梯度推进回归和极端梯度推进回归。我用收集到的三分之二的数据来训练这些模型，剩下的三分之一用于测试。

Extreme gradient boosting model predictions (R² of 0.95) of Walk Score against the one-third test set.

极端梯度推进回归在预测步行分数方面做得很好，在三分之一测试集(约 2300 个样本)上实现了 0.95 的 R 。该模型具有最佳的测试集精度(RMSE)。

黑盒子里有什么？

对 Walk Score 方法进行逆向工程的目的是为了了解算法中的关键特征。我们想知道是什么让一个地方适合步行，而不仅仅是分数！通过检查极端梯度增强模型的特征重要性，1000 米内的餐馆数量占主导地位，是最重要的特征。其他重要的模型特征包括给定人口普查区域的人口密度、所有便利设施的数量、1000 米范围内超市的数量以及与最近商业区的距离(以米为单位)。

The number of restaurants, supermarkets and total amenities within 1000 meters, population density and proximity to commercial zoning are the most important features for predicting a location’s Walk Score.

结论

步行分数已经是一个有用的决策工具，可以根据步行、骑自行车和交通偏好来决定在哪里居住和开发房地产。现在，了解 Walk Score 方法以及构建算法的功能是很有帮助的。我们现在知道了根据步行分数使一个位置可步行的输入。

当前的模型是在西雅图市范围内训练的，那里的城市特征是相似的。还可以收集其他特征来增强步行评分的预测能力，例如地形测量和最近舒适距离计算。模型预测可以很容易地扩展到其他领域，因为 Walk Score API 和用于生成要素的基础数据源(美国人口普查、OSMnx、城市分区、LocationIQ)可以广泛使用。

密码

该项目的代码可以在我的 GitHub 上找到

评论或提问？请发电子邮件至:perryrjohnson7@gmail.com 或联系LinkedIn

工程遇到数据科学——如何平衡数据科学和敏捷之间的紧张关系

原文：https://towardsdatascience.com/engineering-meets-data-science-how-to-balance-the-tension-between-data-science-and-agile-2d547d231443?source=collection_archive---------23-----------------------

几个月前，我开始管理一个关于机器学习和深度学习的研究小组。

Photo by Austin Neill on Unsplash

我有很多管理开发和工程团队的经验，但这是我第一次接触这些主题、算法和工作方法。

一方面，我有一个研究团队，他们说需要时间来调查问题和阅读更多的材料，无法承诺日期和准确性水平。

另一方面，我让我的初创公司的管理层询问时间表、结果和承诺。

这是我的第一份流程草案，我认为这是正确的，可以满足研究团队的需求和管理层的需求，在某种程度上是中间的:

产品定义问题并创建描述需求的用户故事。
研究团队阅读相关文章，并寻找其他数据科学团队面临的类似问题。
数据团队收集相关数据，需要有人(内部或外部)标注。
该团队尝试了一些算法和方法，并返回了关于结果的输入——例如，在我们的案例中，我们展示了一个混淆矩阵，展示了错误发生的位置，这允许我们对混淆的区域采取行动。
在这里，我们可以对产品进行一些迭代，有时会对问题的定义进行一点点修改，这样不会损害特性，并提高成功率。
一旦我们有了足够好的结果，我们就开发一个 API 和一个特性。我们称之为生产化。

这个过程定义了步骤，但是仍然存在关于承诺时间表和承诺准确性的问题。

我向几个脸书小组介绍了我的过程和我仍然面临的公开问题，还组织了一次圆桌会议，听取工程经理管理一个研究团队和几个研究团队经理的意见。

以下是与会者提出的一些观点:

在我工作的地方，有一个额外的 POC 阶段，客户与我们试图解决的问题相关。我们将对他们的数据运行算法，然后根据结果改进模型。
在我的案例中，改进模型需要处理数据本身，添加特性并改进现有的特性。当涉及到客户时，我们需要他们的输入，同样，我们会添加我们以前没有想到的功能，或者我们会修改模型。
关于时间表。在 POC 结束之前，时间表是按周定义的:一周测试模型，一周测试原型，一周在两个不同的客户机上运行。在我的领域(安全)，有时我们需要改变整个问题的定义并重新开始。一旦 POC 成功，也就是说客户认可了它，模型就交给另一个团队进行开发。
我们增加了一个回顾阶段，研究人员必须致力于目标，如果他们没有满足自己的期限，他们会进行回顾，以了解什么可行，什么不可行。
我们了解到，最重要的是设定非常准确和具体的目标，并在中间设置检查点。
部署到生产环境并不是流程的结束。我们需要矩阵来跟踪算法的性能。我们需要警报。额外的迭代来改善结果。添加更多数据。有时候会有死胡同，我们要重新开始。
我认为管理数据科学项目最困难的事情之一是时间表的不确定性和任务成功的可能性。信任和开放的沟通渠道对于克服可能的障碍至关重要。有些人可能不同意我的观点，但是我不太相信研究项目的时间估计。当我觉得这是我的经理需要的东西时，我已经这样做了(同时添加了所有需要的免责声明并反映了所有可能的失败点)。在我目前的工作场所，我根本不这么做。我对时间表有自己的预期，但当它需要更长时间时，我总是可以解释原因:我们发现了我们不知道的事情，基线比我们想象的更差，任务更难。这又回到了信任。我可以把工作分成几个冲刺阶段，但这是人为的，对我没有任何好处。现在对我来说重要的是传达项目的所有依赖项、步骤以及不确定性。如果经理是一个因不确定性而感到压力的人，数据科学家可以少交流，更努力地工作，希望它足够好，这正是事情出错的地方。矩阵和 KPI 需要在检查可能性和满足业务需求后与研究团队一起设置。这听起来微不足道，但我不知道有多少次我听到一位同事说——我需要达到 90%的准确率，因为我的经理(不是数据科学家)将它作为一个目标，而没有问一些重要的问题。如果你只达到 85%会发生什么？有没有非算法的方法来弥补缺失的 5%？基线是什么？算法是什么？目前精度如何？90%是合理的目标吗？如果这比达到 85%要困难得多，那么这种努力值得吗？矩阵也应该迭代设置。我们可以有一个最终目标，但是它应该对研究过程中出现的事情有一定的灵活性。
我们的一些工作使用了敏捷方法。我们做了很多调整，并正在学习如何做对我们自己。我们每周举行两次全队“站立”活动，并为团队设立了一个特雷罗董事会。我们一起计划并进行回顾。这使我们更加透明，并改善团队中的合作和互助。在一个团队中工作，每个人都知道其他成员在做什么，这对团队中的每个人都是有价值的。在数据科学中，进步不是线性的。但是，设定短期目标仍然很重要，特别是对于该领域的初级人员，这样我们就有了方向感，知道自己在做什么，要去哪里。与客户一起试验也很重要，这样我们就知道一个特性如何满足业务需求，以及它是否为客户解决了正确的问题。
以类似于管理程序员的方式管理数据科学家非常重要。数据科学家必须了解业务需求，包括时间表。他们应该能够向他们的经理解释与其工作相关的所有必要的技术资料。这里面没有什么你作为管理者不应该能够理解的。数据科学家应该愿意编码(至少一点点),以减少对开发人员、开发/运营等的依赖。虽然研究任务有许多未知因素，并且很难承诺一个截止日期和具体结果，但设定明确的里程碑并将其分解为短期任务是至关重要的，这些任务有明确的 DoD，可以在 sprints 中管理。
样本任务可以包括导入数据、清理数据源、进行单个实验等。我建议在短时间内监控 KPI，作为 sprint 的一部分，这样你就可以在信息完全透明的情况下做出管理决策，而不是设定一个 3 个月的 KPI 目标并努力实现它。
如果在研究中有几个方向可以选择，我建议为每个选择设定一个时间框架，然后回顾在此期间取得的成果。作为管理者，你应该能够决定停止一个研究方向，转向另一个方向。有时候，为了整个项目的利益，你必须做出艰难的决定，违背研究人员的意愿，开辟一条非生产性的研究道路。

和给数据科学家的一些建议:
你能帮助你的经理成功(并让自己得到赏识)的最好办法是:
*学会清楚地解释你的工作，以便你的经理能做出好的商业决策。学习如何处理截止日期和短期里程碑。这会让你更有效率，实际上你会获得更多。
*如果你觉得某条研究路线行不通，尽快告诉你的经理。这并不意味着你失败了——这只是意味着一条研究道路走进了死胡同，这就是研究工作的方式。
处理里程碑和短期任务，并全程监控 KPI，这些都非常重要。对于研究人员和数据科学家来说，唯一真正困难的事情是提前计划太多，并给出非常准确的时间估计。
我们仍然应该能够给出时间表，但是经理应该灵活，并且理解计划可能会在项目的整个生命周期中频繁地改变，因为，例如，有时整个建模方法需要改变，或者数据不符合预期。
此外，确保数据科学家在短周期内工作也很重要，不要消失在几个月的研究中，而是在整个过程中与客户/产品进行一些互动。
最好的方法是尽快交付最简单的概念验证，与客户一起测试，然后根据客户的反馈进行调整或构建更复杂的内容
我作为数据科学家的两点意见:是的，数据科学团队和数据科学家应该使用时间表。无结构的工作环境对每个人都不利。然而，请记住，数据科学家的时间表比开发人员的时间表更“软”。分类/预测问题的解决方案可以在不同的层次上实现。简单的解决方案可以在更紧的时间表内用更少的数据实现。复杂的问题需要更多的数据，并且具有更大的不确定性。据此规划研究路线图，根据经验，从低挂的果实开始。作为一名经理，确保你理解对你的产品至关重要的任务中模糊性的重要性，以及你能做些什么来帮助研究。
数据科学家应该知道如何编码，因为无知可能会削弱他们。然而，作为一名经理，你要确保你在明智地使用你的工具。有时，将技术工作交给熟练的程序员，让数据科学家从事他们擅长的工作会更有好处。

我自己从所有这些中得出的结论是，尽管传统的敏捷并不是 100%适合数据科学领域，但设定目标和时间表仍然很重要。如果数据科学团队和管理层之间的关系良好，并且双方相互信任，时间表和准确性承诺可以发挥作用，但应被视为软承诺，假设一切都可以回顾、解释和借鉴。

从分享的不同观点中，从与如此多不同的经理和数据科学家的会面中，从倾听他们的意见和他们要说的话中，我学到了很多。我希望读完这篇文章后，你也一样。

我要感谢米莉·库利艾尔、希尔·梅厄、莱娜·卡彭、阿伊莱特·萨奇托、米哈尔·古特曼、达纳·阿韦尔布赫、塔马·阿米蒂、雷切尔·吕德默、因巴尔·罗森斯托克和因巴尔·瑙尔对本次讨论的深刻见解和贡献。

用机器学习增强增强现实

原文：https://towardsdatascience.com/enhancing-ar-with-machine-learning-9214d2da75a6?source=collection_archive---------8-----------------------

在 AR 应用之上分层 ML 扩展了它们的有用性。

随着增强现实(AR)技术的改进，我们开始看到超越营销和简单可视化的用例。这些包括产品可视化、远程协助、强化学习、质量控制和维护。

苹果的 Measure 是我最喜欢的 AR 应用之一。这是一种用智能手机进行物理测量的简单可靠的方法，它证明了 AR 跟踪已经变得多么强大。

Apple’s Measure in action. The results are accurate within ±1 cm!

在其核心，AR 是由先进的计算机视觉算法驱动的。但是我们可以做得更多。通过在核心 AR 技术之上分层机器学习系统，可能的用例范围可以大大扩展。在接下来的部分中，我将向您展示如何操作。

AR 就是计算机视觉。

AR 技术经常使用 SLAM ( 同时定位和映射 ):一种计算机视觉算法，它比较相机帧之间的视觉特征，以便映射和跟踪环境。结合来自智能手机陀螺仪和加速度计的传感器数据，可以实现非常可靠的跟踪。

像苹果、谷歌和 6D.ai 这样的公司都在孜孜不倦地改进这些算法。这意味着，作为开发者，我们将能够使用 AR 不断构建更好、更可靠的应用程序。

6D.ai mapping the world in real time.

你可以把 AR 应用想象成一组技术层。在的核心，AR 框架如 ARKit 和 ARCore 实现了计算机视觉算法来做跟踪和映射。如果使用 Unity3D ， AR Foundation 提供了跨多个 AR 框架的统一 API。在边缘，有您的特定应用使用的代码和资产。

A hierarchy of AR technologies, going from the core to the edge.

边缘的计算机视觉。

AR 技术堆栈的核心框架通常提供整洁的额外功能，如图像跟踪、姿势估计，以及最近的 ARKit 3，人物遮挡。这些功能中有许多是由机器学习提供动力的。

但是还有更大的潜力！

事实上，用机器学习来丰富 AR 应用程序是合适的，因为:

摄像机一直开着，收集图像数据。
在 AR 中跟踪的对象可以可靠地在相机图像中定位。
AR 可视化是向用户展示信息的一种很好的方式。

Wouldn’t it be nice if this app could learn the difference between rugs, tables, lamps and windows?

每当 AR 应用程序处理可以从环境中收集有用信息的情况时，可以添加一层由机器学习驱动的计算机视觉。

你可能想:

📖阅读标牌上的文字。
👀检测用户正在查看哪种类型的对象。
👫判断一个人穿的是哪件衣服。
❌检测物体是否有视觉缺陷或异常。

Auto-filling the inspection report for a damaged sticker in Kanda’s ARC.

在 Kanda ，我们正在使用 AR ( 代号 ARC )进行质量控制和维护的申请。在 AR 框架之上使用定制的机器学习层，该应用可以检测相关资产的视觉缺陷以在检查过程中提供一种“自动填充”。这是为了让一线工人的生活更轻松。

该应用程序利用了被检查的资产已经在 AR 中被跟踪的事实。这提供了从相机帧中精确裁剪对象所需的位置信息。然后，我们使用定制的神经网络来检测裁剪图像中的视觉缺陷。

LEGO Hidden Side using object detection to locate the kit.

今年，乐高发布了他们的隐藏面 AR 主题。附带的 AR 应用程序利用对象检测(使用 Vuforia )来定位相机框架中的乐高套件，并在其上渲染 3D 世界。我认为这很棒！

AR demo from Wikitude and Anyline to read & submit utility meter data.

Anyline 提供了一个 SDK 来做文本识别，可以用在 AR 中。在上面的演示中，AR 被用来轻松地定位和选择实用程序箱。然后，使用 OCR(光学字符识别)自动读取其能耗表。

这比手工输入数据要快得多(也更准确),这也是为什么意大利主要能源供应商爱迪生已经在使用 Anyline 的技术。

解决技术挑战。

用机器学习增强 AR 应用时的一个主要挑战是对低延迟的要求。最常见的情况是，定制的机器学习层需要实时提供信息，因此模型必须在设备的硬件上运行，而不是在云中运行。

有时候，你的问题可以用现有的软件产品来解决，比如 Vuforia 和 Anyline 提供的产品。当你需要一些定制的东西时，你必须弄清楚如何在你想要的应用平台上有效地运行机器学习模型。

Kanda’s ARC being developed in Unity3D.

Kanda 的 AR 应用 go-to 开发平台是 Unity3D 。这是一个游戏引擎，允许高效的 3D 编程和计算机图形。虽然在这个平台上集成了几个边缘机器学习系统，但我很高兴地告诉你，Unity3D 不是为机器学习推理而制造的。

然而，【Unity 的一个新项目(代号Barracuda)，正在成为 Unity3D 的一个高效(而且相当易用)的机器学习推理机！

Enter The Matrix - Compute Shaders make matrix multiplications real fast!

梭鱼使用 计算着色器 在设备硬件上高效运行模型。这些程序运行在显卡上，但是(不同于常规着色器 ) 它们可以用于非图形任务。

为了增加交易的甜头，计算着色器可以利用许多平台上的图形硬件:MacOS、iOS、Android、Windows、PS4、Xbox。这意味着用 Unity3D 进行机器学习推理可以快速且跨平台🤩

总之。

由于过去几年取得的技术进步，AR 应用程序在它们能做什么方面超出了预期。

由于相机图像始终可用，这些应用程序还提供了使用视觉数据丰富体验的独特机会:例如，使应用程序能够阅读文本，找到物体或检测异常。这些功能可以由构建在核心技术之上的定制机器学习层来支持。

我们已经到了这篇文章的结尾。我希望你对如何使用机器学习来增强 AR 应用程序有一些想法，以及在开始时需要注意什么🤓

利用深度多时相超分辨率增强卫星图像

原文：https://towardsdatascience.com/enhancing-satellite-imagery-with-deep-multi-temporal-super-resolution-24f08586ada0?source=collection_archive---------8-----------------------

DeepSUM 赢得欧空局的 PROBA-V 超分辨率挑战

Modified ESA Copernicus Sentinel data, licenced under CC BY-SA 3.0 IGO.

“你能增强它吗？
我们多少次从电视节目中听到这种比喻，多少次嘲笑计算机怪胎能够从一幅图像中提取出如此荒谬的细节？

虽然电视节目实现的不可能的图像增强理应受到嘲笑，但实际上存在数学和物理表明有可能提高图像分辨率的场景。多幅图像超分辨率(MISR) 就是这种情况，强调多幅图像的使用。

MISR 拍摄了一幅图像的多个低分辨率(LR)版本，并试图将它们组合起来，以恢复场景的高分辨率(HR)版本的细节。诀窍在于 LR 图像彼此略有不同，并且由于 LR 采集而在一个图像中丢失的信息可能仍然存在于另一个图像中。

下面是一个简单的例子来说明这个原理。假设你有一个真正的高分辨率图像，像素呈棋盘状，但你只能观察到四个低分辨率图像，每个图像的高分辨率像素只有四分之一。然而，还假设第一个 LR 图像在两个方向上从 HR 图像采样奇数索引的像素，第二个 LR 图像垂直地采样偶数，水平地采样奇数，第三个采样奇数/偶数，第四个采样偶数/偶数。无需使用任何魔法，只需从 LR 图像中提取像素并以正确的顺序交错，就可以重建精确的 HR 图像！

Toy example of multi-image super-resolution.

卫星图像是 MISR 大放异彩的最好例子。地球观测卫星，如 PROBA-V 或 Sentinel constellation ，获取同一场景的多幅图像，因为它们在轨道运行期间会定期重访该场景。这是监测环境、评估洪水等自然灾害风险或通过检测一段时间内影响一个地区的变化来了解人类活动和气候变化的影响的一项重要工作。因此，有丰富的多时相数据可用于提取更多信息，而不是查看单个图像。通过 MISR 方法提高空间分辨率有助于为科学家提供更高质量的产品。

然而，总的来说，MISR 比上面的玩具例子要困难得多。特别是，在试图合并多时卫星图像时遇到的主要问题是:

未注册图像:现有 LR 图像间的位移难以准确获知；
绝对亮度变化:虽然场景可能大致相同，但可能会因光照条件而出现不同；
云:它们可能会遮挡部分场景，它们的阴影会影响地形亮度；
时间可变性:场景内容因自然现象或人类活动而随时间变化。

Example of temporal variability. PROBA-V challenge dataset. Courtesy: ESA ACT.

PROBA-V MISR 挑战和 DeepSUM

2018 年 11 月 1 日，欧洲航天局开始了一项公开挑战，以增强 PROBA-V 卫星获取的图像。PROBA-V 是一颗小型卫星，专门用于研究地球植被，其数据有助于遏制世界各地沙漠的蔓延和毁林活动。

PROBA-V 获取地面分辨率为 300 米的图像，重访时间为 1 天。然而，它也获取更高分辨率的图像(每像素 100 米)，尽管频率较低，大约每五天一幅。为这种情况开发 MISR 算法特别有趣，因为它可以通过利用更频繁的低分辨率图像来帮助提高高分辨率图像的时间可用性。

挑战赛的公共数据集正是为此而建立的。一个场景在一个月内获得的多个低分辨率图像是可用的，并且还提供了该场景的地面实况高分辨率版本。

一场激动人心的比赛开始了，许多团队贡献了他们自己的解决方案。在经历了上周的忙碌和令人难忘的通宵之后，2019 年 6 月 1 日，在 DeepSUM，都灵理工大学图像处理和学习实验室提出的方法成功击败了由蒙特利尔学习算法研究所(MILA)和 Element AI 成员组成的团队 rarefin 的激烈竞争，赢得了挑战。

DeepSUM 是一个端到端的可训练卷积神经网络，它处理大量低分辨率输入图像，以在其输出端提供超分辨率图像。

DeepSUM

在高层次上，网络由三个主要阶段组成:

SISRNet:该部分独立处理输入图像(通过双三次放大进行预处理),以提取有助于描述其内容和提高其分辨率的特征；
RegNet:它使用 SISRNet 学习的特征来估计将图像的特征图彼此对齐的过滤器；
FusionNet:它缓慢地组合所有图像的特征，以生成对双三次上采样和注册输入的平均值的残差校正。

总的来说，DeepSUM 的设计和训练是由明确解决影响我们上面讨论的遥感图像 MISR 的问题的思想来指导的。下面是解决这些问题的方法:

未注册的图像 : RegNet 使用网络的特征空间而不是像素空间来解决注册问题。这些特征捕获更高层次的结构，并且对于噪声和其他复杂的扰动更加鲁棒，使得由 RegNet 产生的配准滤波器比直接从像素比较(例如，图像互相关)中导出的滤波器更好。损失函数还考虑到超分辨率图像和高分辨率地面实况可能相互偏移；
绝对亮度变化:用于训练网络的损失函数包含使其对全局亮度变化不变的项；
云 : DeepSUM 支持使用质量掩码，例如由云检测器计算的二进制掩码，来指导其内部工作。特别地，遮罩用于让网络知道一些图像在哪里具有不可靠的像素，以便可以用来自其他图像的地面内容来填充它们，从而使隐藏层更加稳定。损失函数还考虑了这样一个事实，即如果所有图像在同一区域都有一个掩膜，则无法预测高分辨率地形；
时间可变性 : FusionNet 使用小的 3D 卷积来学习过滤器，允许以最鲁棒的方式合并多个图像。

Example from validation set (scene: imgset0103). Top row: 3 low-resolution images. Bottom-left: DeepSUM super-resolved. Bottom-right: ground truth.

今后

虽然多图像超分辨率对于遥感界来说是一个非常重要的问题，正如大量科学文献所证明的那样，但很少有作品使用深度学习来解决它。欧空局的挑战提供的新数据集肯定会引起人们的兴趣，新技术将在未来几个月和几年出现。我们将期待激动人心的新发展。

用动画增强静态图

原文：https://towardsdatascience.com/enhancing-static-plots-with-animations-ca987801a6b0?source=collection_archive---------24-----------------------

使用 gganimate 增加 ggplot2 的可视化效果

这篇文章旨在向你介绍使用托马斯·林·彼得森的gganimate包在 r 语言中制作ggplot2可视化动画。

如果我按照我在这篇帖子中解释的简单模型来预测(或在澳大利亚称为 tip)AFL 的获胜者，这篇帖子将会可视化我将会获得的理论奖金。分析中使用的数据是从 AFL Tables 网站上收集的，是我写的关于 AFL 人群的一个更大系列的一部分。更广泛的项目可以在这里找到。

library(tidyverse)
library(lubridate)
library(scales)
library(gganimate)# set themes
theme_set(theme_minimal() +
 theme(axis.title.x = element_text(size = 16, hjust = 1), 
 axis.title.y = element_text(size = 16), 
 axis.text = element_text(size = 13),
 plot.title = element_text(size = 19)))# create a colour pallette
colours <- c(“#5EB296”, “#4E9EBA”, “#F29239”, “#C2CE46”, “#FF7A7F”, “#4D4D4D”)# — — — Read in data — — -#
afl <- read.csv("[https://raw.githubusercontent.com/JaseZiv/AFL-Crowd-Analytics/master/data/cleaned_data/afl_model_data.csv](https://raw.githubusercontent.com/JaseZiv/AFL-Crowd-Analytics/master/data/cleaned_data/afl_model_data.csv)", stringsAsFactors = F)# Data pre-processing — — — — — — — — — — — — — — — — — — — — — — — — — — -# make all variables character type to make splitting and string manipulation easier
afl <- afl %>% 
 mutate_if(is.factor, as.character) %>% 
 mutate(team1_score = as.numeric(team1_score),
 team2_score = as.numeric(team2_score)) %>% 
 mutate(fav_team = ifelse(AwayLineClose < 0, team2, team1)) %>% 
 mutate(winning_team = ifelse(winner == “Home”, team1, ifelse(winner == “Away”, team2, “Draw”))) %>% 
 mutate(fav_win = ifelse(fav_team == winning_team, “Yes”, “No”)) %>% 
 filter(season >= 2014,
 !str_detect(round, “F”)) %>%
 mutate(tip = ifelse(abs(AwayLineClose) < 3, team1, fav_team))# function to calculate odds
calculate_odds_available <- function(tip, winning_team, team1, team2, HomeOddsClose, AwayOddsClose) {
 if(tip == winning_team) {
 odds_available <- ifelse(tip == team1, HomeOddsClose, AwayOddsClose)
 } else {
 odds_available <- 0
 }
}# apply function and calculate returns
afl <- afl %>% 
 mutate(odds_available = mapply(calculate_odds_available, tip, winning_team, team1, team2, HomeOddsClose, AwayOddsClose),
 game_return = odds_available * 10,
 game_profit = game_return — 10)# create a df that calculates total winnings per round
money_per_round <- afl %>% 
 group_by(season, round) %>% 
 summarise(total_profit = sum(game_profit)) %>% ungroup()# add a round 0, where all seasons start at $0
zeros <- data.frame(season = (2014:2019), round = 0, total_profit = 0)# join zeros df on to money_per_round
money_per_round <- money_per_round %>% rbind(zeros)# create a df that sums up winnings cumulatively
total_money <- money_per_round %>% 
 arrange(season, round) %>% 
 group_by(season) %>% 
 mutate(cumulating_winnings = cumsum(total_profit)) %>% ungroup()

我们开始吧

好的，所以当我写第一篇文章的时候，我采取的第一步是创建一个 ggplot2 可视化来绘制我使用我的简单策略会得到的收益(或损失)。

这是结果:

total_money %>%
 ggplot(aes(x= round, y= cumulating_winnings, 
 group = season, colour = as.character(season))) +
 geom_line(size = 1) +
 geom_point(size = 2, colour = “black”) +
 labs(x= “Round”, y= “Cumulative Wins/Losses”, colour = “Season”) +
 scale_x_continuous(limits = c(0, 27), 
 labels = c(0, 3, 6, 9, 12, 15, 18, 21, 24), 
 breaks = c(0, 3, 6, 9, 12, 15, 18, 21, 24)) +
 scale_colour_manual(values = colours) +
 ggtitle(“2017 WOULD’VE BEEN A BAD YEAR”) +
 theme(legend.position = “bottom”)

The legend is hard to follow here

还不错，但肯定可以改进。在我看来，随着六季的绘制，这个传说很难映射到这条线本身。还有，除了 2017 赛季特别差，其他赛季轮次之间的变化很难看到。

此外，以这种方式绘制数据，如果不花费太多精力关注我在哪里会赚钱，在哪里会赔钱，就很难实现。

标签和注释

呸——你不能简单地把季节加为标签——你什么都看不到！

total_money %>%   
ggplot(aes(x= round, y= cumulating_winnings, **group** = season, colour = **as**.character(season))) +   
geom_line(size = 1) +   
geom_point(size = 2, colour = "black") +   
geom_hline(yintercept = 0, linetype = 2, size = 2) + **# added in horizontal line at $0**   
geom_text(aes(label = season), hjust = -1, size = 6) + **# season labels added**   
scale_colour_manual(values = colours) +   
labs(x= "Round", y= "Cumulative Wins/Losses") +   scale_x_continuous(limits = c(0, 27), labels = c(1, 3, 6, 9, 12, 15, 18, 21, 24), breaks = c(1, 3, 6, 9, 12, 15, 18, 21, 24)) +   scale_y_continuous(labels = dollar) + **# y-axis formatted to dollar format using scales**   
annotate("text", x= 26, y= 6, label = "Break Even $", size = 6) + **# added text to break even line**   
ggtitle("2017 WOULD'VE BEEN A BAD YEAR") +   
theme(legend.position = "none") **# turned legend off**

That didn’t work!

相反，只有一个季节标签适用，并适用于每条线的运行结束。这个看起来好多了。

如我们所见，静态图表中添加了更多元素，包括:

添加盈亏平衡线；
将 y 轴格式化为美元格式；和
添加标签和移除图例

这大大提高了剧情的可读性。

total_money %>% 
ggplot(aes(x= round, y= cumulating_winnings, **group** = season, colour = **as**.character(season))) + 
geom_line(size = 1) + 
geom_point(size = 2, colour = “black”) + 
geom_hline(yintercept = 0, linetype = 2, size = 2) + **# added in horizontal line at $0** 
geom_text(data = total_money %>% filter(round == max(round)), aes(label = season), hjust = -0.3, size = 6) + **# season labels added, but only one label per season** 
scale_colour_manual(values = colours) + 
labs(x= “Round”, y= “Cumulative Wins/Losses”) + scale_x_continuous(limits = c(0, 27), labels = c(1, 3, 6, 9, 12, 15, 18, 21, 24), breaks = c(1, 3, 6, 9, 12, 15, 18, 21, 24)) + scale_y_continuous(labels = dollar) + **# y-axis formatted to dollar format using scales** 
annotate(“text”, x= 26, y= 6, label = “Break Even $”, size = 6) + **# added text to break even line** 
ggtitle(“2017 WOULD’VE BEEN A BAD YEAR”) + 
theme(legend.position = “none”) **# turned legend off**

Looking better…

你好动画！

虽然上面的图表看起来好多了，但没有夸张！

输入来自gganimate的动画！

使用动画情节允许我们删除更多的元素。通过标签和动画的正确组合，y 轴不再是必要的——在每一轮中，我们可以跟踪我们的输赢，而盈亏平衡线为我们提供了一个参考点。

这里做的其他事情包括使用fps(每秒帧数)减慢帧的速度，并将transition_reveal()中的range调整为比它转换的回合长(即调整范围为c(0,25))。这允许动画在完成循环后暂停。

最后，为了增加输出的大小，根据您的喜好调整width和height参数。

total_money_anim <-  total_money %>%   
ggplot(aes(x= round, y= cumulating_winnings, **group** = season, colour = **as**.character(season))) +   
geom_line(size = 2) +   
geom_point(size = 3, colour = "black") +   
geom_hline(yintercept = 0, linetype = 2, size = 2) +   geom_text(aes(label = paste0(season, ": ", dollar(cumulating_winnings))), hjust = -0.3, size = 6) +   scale_colour_manual(values = colours) +   
labs(x= "Round", y= "Cumulative Wins/Losses") +   scale_x_continuous(limits = c(0, 27), labels = c(1, 3, 6, 9, 12, 15, 18, 21, 24), breaks = c(1, 3, 6, 9, 12, 15, 18, 21, 24)) +   scale_y_continuous(labels = dollar) +   
annotate("text", x= 26, y= 6, label = "Break Even $", size = 6) +   ggtitle("2017 WOULD'VE BEEN A BAD YEAR") +   
theme(legend.position = "none", axis.text.y = element_blank(),          axis.title.y = element_blank(), panel.grid.major.y = element_blank(), panel.grid.minor.y = element_blank()) +   transition_reveal(round, range = c(0, 25)) animate(total_money_anim, width = 900, height = 900, fps = 5)

Animations make things so much better

希望这给了你一些灵感，让你开始制作一些你自己的动画形象。

如果你有任何问题或建议，请在评论中告诉我。

本帖原创，发布在不怪数据博客【https://www.dontblamethedata.com】

增强交叉熵损失的能力用于图像分类

原文：https://towardsdatascience.com/enhancing-the-power-of-softmax-for-image-classification-4f8f85141739?source=collection_archive---------25-----------------------

交叉熵损失已经在许多分类任务中取得了最先进的结果。但是，对于其类具有相似特征的数据集，它不会像预期的那样执行。原因是，交叉熵损失无法学习区分度不够的可分离特征。为了解决这个问题，已经提出了许多方法。一个非常有效的方法是用角距离(边距)来分离学习到的特征，这将在本文中解释。

使用 SoftMax 和交叉熵损失进行训练

首先，让我们在 mnist 数据集中训练一个 VGG16 Cnn 模型(Simonyan & Zisserman，2014)(图 1)。

Figure 1: VGG16 model for Mnist

mnist 数据集中的每个图像都有(28x28x1)个维度，但是我们在 VGG16 网络中只能馈送一个以(32x32x1)为下限的图像。因此，在每个图像的边界添加了额外的零填充，以达到最小输入大小。此外，“通道优先”顺序被证明可以加速 GPU 中的训练，因此维度被转换为(1x32x32)。除了标准的 VGG16 架构之外，我们还可以添加全连接的层，然后使用 SoftMax 为每个类生成最终预测。最后一个完全连接的层也可以用于提取特征。这些特征可以使用 2D 或 3D 欧几里德空间中的 PCA 或 T-SNE 等降维技术来绘制，以提供关于训练的见解。

在 VGG16 训练之后，我们可以使用它的权重在看不见的图像(测试集)中进行预测。测试集中最后一个全连接层(特征)的神经元的输出在下面使用 PCA 在 3D 欧几里得空间中被可视化。

很快有人可以理解，仅使用交叉熵损失的训练不能提供足够的类内紧密度和类间差异，以用于具有相似特征(例如人脸)的数千个类的数据集。

注意当使用 PCA 降低维度时，总方差下降，因此特征的拓扑是近似的。例如，在图 2 中，红点(代表一个类别的要素)之间的距离相对较大。如果它们被投射到 PCA1 中，它们的最终距离将相对较小。因此，红色要素的差异很小，该类的可视化结果也不准确。

Figure 2: Dimensionality reduction using PCA

转换交叉熵损失

变换的思想是将所有特征分布在超球面上，并在每类特征之间增加一个角裕度，以增强它们的区分能力(刘等，2017)。

首先让我们回忆一下交叉熵损失函数:

我们可以重写逻辑

作为第一项加上第二项的内积

其中θ是权重和特征之间的角度。此外，如果我们将权重标准化，将偏差归零

请注意，的最终预测值仅取决于角度θ(刘等，2017)。因此，交叉熵损失函数被转换为

我们应该做的另一个修改是归一化特征向量的范数，以消除径向方向上的变化。因此，特征位于半径为“s”的超球面的表面上，并且学习仅依赖于余弦值来开发辨别能力(王等人，2018)。

通过这种修改的交叉熵损失，我们的网络可以学习用角度边界分隔的特征，但这并不意味着它足够强，可以满足我们最初的假设。因此，我们将在权重和特征之间添加附加的角度裕度损失，以同时增强类内紧凑性和类间差异。已经提出了许多角裕度罚值，但是加性罚值比其他罚值具有更好的几何属性，与超球流形上的测地距离精确对应(邓，郭，薛，& Zafeiriou，2018)。添加余量后的最终转换交叉熵损失如下所示:

在图 3 中示出了修改的整个过程

Figure 3: Visualization of the whole Cross-Entropy loss modification

在最后一个全连接层的测试集中计算的特征在下面使用 PCA 在 3D 欧几里得空间中被可视化。

正如我们所观察到的，由于附加的角度裕度“m”(上面的 0.5)，每一类的特征都非常紧凑，并且可以与其他类分开。因此，这种方法适用于包含成千上万个类别的数据集，这些类别的特征不具有很高的区分度。

在 tf.keras 中，我们可以简单地修改 SoftMax 层来实现这种所需的行为。以下是使用两个输入(要素，正确 _ 标签)进行训练的修改后的 SoftMax 图层的代码:

完整的代码可以在我的 github 链接中找到。您可以试验不同的“m”值，以查看其在最终可视化中的影响。

进一步分析

移除特征提取器中的 ReLU

上述层的第一个输入是作为最后一个全连接层的输出的特征。现代 CNN 通常在几乎每一层之后使用 ReLU 非线性，使得输出位于范围[0，+∞]内。如果 ReLU 存在于使用上述交叉熵损失备选方案的网络中的最后一个全连接层之后，则可以放置特征的角度是有限的。从该层的顶部移除 ReLU(Liu 等人，2017)可以有利于特征学习，因为特征可以分布在更宽的空间中。

从另一个角度标准化权重

我们看到权重的归一化给出了更好的几何解释。权重的归一化也可以帮助解决训练数据不平衡的问题，因为同一类中的样本数量越大，与该类相关联的权重的范数就越大。因此，对修正的交叉熵损失中的权重范数进行归一化，解决了这个问题(刘等，2017)。

消除偏见

通过将偏差归零，修正的交叉熵损失具有清晰的几何解释，因此变得更容易分析(刘等人，2017)。通过实验，这对特征分布没有直接影响，并且学习的特征同样强。

参考

邓军，郭军，薛，n .，& Zafeiriou，S. (2018，1)。ArcFace:深度人脸识别的附加角裕度损失。 arXiv 电子版，arXiv:1801.07698。

刘文伟，文，于，李，李，宋，李(2017，4)。用于人脸识别的深度超球面嵌入。 arXiv 电子版，arXiv:1704.08063。

Simonyan，k .，& Zisserman，A. (2014，9)。用于大规模图像识别的非常深的卷积网络。 arXiv 电子印花，arXiv:1409.1556。

王，洪，王，周，钟，季，谢，龚，周。。。刘，W. (2018，1)。CosFace:深度人脸识别的大幅度余弦损失。 arXiv 电子印花，arXiv:1801.09414。

开明的数据实验室笔记本

原文：https://towardsdatascience.com/enlightened-datalab-notebooks-35ce8ef374c0?source=collection_archive---------13-----------------------

具有专用存储桶、IAM 权限和安全防火墙配置

Photo by Tim Gouw on Unsplash

通往云计算专业知识的道路充满了令人苦恼的漫长下午，以及无数未完成的博客帖子。当您想要快速启动一个虚拟机，并在浏览器中从笔记本开始使用 Python 时，您经常会遇到这些挫折。为什么我不能写我的桶？是什么阻止笔记本在我的浏览器中工作？ 为什么 SSH 进入机器看不到任何文件？甚至可能是“Docker 是什么？”

本文旨在帮助其他数据科学家，他们正在冒险进入谷歌计算平台(“GCP”)堆栈，或者可能在开始新的 Kaggle 竞争时重新访问它。关注我在 Twitter 上的 #FullStackDS 帖子，获取类似的帖子。

DataLab 笔记本是 GCP 的产品，用于从私有环境连接到谷歌计算引擎(“GCE”)实例(或 VM)。它使用了 Jupyter Notebook 的基础设施和 Docker，并且可以链接到 R/Julia/Python/Bash 等中的其他内核。——如果你想变得非常奇特。设置 DataLab 笔记本的技巧在于配置防火墙、IAM 权限以及理解一些独特的 Linux 命令。我还没有找到一篇解决这些复杂问题的文章。一旦你克服了这个困难，旋转起来就非常容易了。让我们通过一个完整的可重复设置来引导您。

设置您的项目

在我们开始之前，如果你还没有在 GCP 设立账户，你会想要的。对于首次用户，有 300 美元的信用和 12 个月的免费试用。要不，我们开始吧https://console.cloud.google.com。

从左上角的“汉堡包菜单”(*看起来像汉堡包)，我们将从主菜单中选择主页。接下来，让我们使用主页上的“创建项目”(下面突出显示)。创建项目允许用户在共享环境中创建多个虚拟机。它还允许分开计费。

接下来，从New Project页面，我们将我们的项目命名为“DistributedScraping ”,并单击CREATE.

在主屏幕上，你应该会在下拉列表中看到项目DistributedScraping。我们还想从页面的右上方打开免费的云外壳，下面用绿色圈起来——它还没有连接到任何 GCE 实例。请注意，黑色命令行云 Shell 本身是一个免费的 Linux 机器，我们将使用它来设置防火墙、IAM 权限，并从中创建 DataLab 笔记本。

为私人浏览器访问设置防火墙

在启动 DataLab GCE 实例之前，我们需要设置对 localhost 网关的访问，该网关在 GCP 项目中受到保护，并通过安全的 SSH 连接进行链接。默认情况下，DataLab 同时使用端口 8081 和 22。源范围设置为“0.0.0.0/0”，这允许在每次重新启动后链接到您的笔记本—每次启动和停止 DataLab Docker 实例时都会创建一个新的外部 IP。在更高级的设置中，我们可以分配一个固定的外部 IP，并为其分配一个源范围。我们将在下面的 on 命令中建立防火墙规则。

在 Google Cloud Shell 中，在一长行中输入 Github Gist 中的代码。上面的代码突出显示了项目名称和防火墙规则名称。

接下来，我们需要从开放云 Shell 配置我们当前的项目:

启动数据实验室笔记本

下表显示了机器类型名称的成本/尺寸。我们将在这里创建一个 8 核低内存机器，每小时 23 美元。我们可以通过使用另一个 linux 标志来获得更低的可抢占价格——我不会在这里深入讨论。您可以通过访问此链接来选择您自己的机器类型。在我的下一篇文章中，我们将探索来自 DataLab 的高级抓取——包括来自 Python 的并行代理和 selenium 抓取，因此我们希望使用比标准双核机器更大的实例。

在云 Shell 中运行下面的代码，创建您的 DataLab GCE 实例，用一个轻量级的 Docker 容器包装；它包括“us-west1-a”地区的一台 8 CPU/核心计算机，名称为“iptest”:

运行上面的 linux 行之后，我们将看到下面的输出。通过在云外壳中单击，访问用绿色圈出的 enable API 链接。这将启动一个新的浏览器选项卡，并根据您的 GCP 受保护环境提供对新创建的虚拟机的访问。

选择 ENABLE 按钮后，在您的云 Shell 中再次输入相同的命令来创建机器。不知道为什么这需要两步…？

输出应该如下所示，这将传播您的 SSH 密钥并设置您的 GCE DataLab 实例。接下来，单击 Web Preview 按钮(下面用绿色圈出)，将端口从“8080”(默认)更改为“8081”，然后选择 LAUNCH AND PREVIEW 链接(步骤如下所示)。

您也可以不使用上述方法从浏览器重定向。只需将下面的链接粘贴到您的浏览器中，或者在云外壳文本的输出中找到它。我发现我必须尝试几次，才能让安全重定向生效。保持耐心！会有用的…

http://localhost:8081/

探索您的数据实验室笔记本

选择+NOTEBOOK 按钮(下面用绿色圈起来的)，启动一个新的“Untitled Notebook.ipynb”。我们将在下面浏览几个 Hello World 示例，在这些示例中，我将向您展示如何设置对您的 DataLab 存储(“存储桶”)的读/写访问权限，该存储桶是自动创建的，自动备份在与您的虚拟机同名的文件夹下。

运行下面的…

从新启动的选项卡中，我们需要选择右上方的下拉内核，从工作簿中选择 Python3。注意，由于某种原因，当前默认设置为 Python2(？).现在，在键盘上使用Shift + Enter，从print('hello world')函数之后的第一个单元格(代码块)开始。瞧，成功了！“你好世界！”。

让我们设置对我们新创建的 bucket‘distributed scrpping’的读/写访问，您可以访问 Hamburger > > Storage > > Browser extension。

在这里，我们需要访问我们的“GCE 电子邮件”,作为“服务帐户”进行绑定。在您的云 Shell 中运行下面的gcloud命令，手动在文本输出中搜索 serviceAccounts:email ，并在接下来的 Linux 命令中使用。

现在，我们将服务帐户绑定到自动创建的 DataLab bucket。

现在让我们升级游戏，尝试一个高级的 helloworld，w 将一个 CSV 和 TXT 写入我们的桶中，并用 Python 将它们读回到 DataLab 笔记本中。注意，那个“！”在行首，是穿插 Python 代码的单行 bash 脚本(非常酷！).

在浏览器中将以下代码输入到您新创建的笔记本中。

输出:

如果你想扩展这种探索，谷歌有一个很棒的 YouTube 视频[ Datalab:云中的笔记本(AI Adventures) ]，它涉及到使用谷歌的 BigSQL 分布式关系数据库产品 BigQuery 进行读/写/管理。

注意:每小时/每天/每周自动备份iptest存储桶。即使您删除了您的 DataLab 虚拟机，这种情况仍会存在。我不确定我们能在哪里控制这个特性；请注意，这种数据存储是有象征性成本的。

检查虚拟机状态并关闭

从主屏幕左上角的汉堡图标，导航至计算引擎>>虚拟机实例。这里您将看到iptes，我们的 DataLab GCE 实例正在运行(注意绿色的勾号)。即使您关闭了选项卡，GCE 实例也会继续计费。记住选中机器上带有蓝色箭头的框，然后在每次使用完实例后停止机器(从页面的右上角开始)!

另请注意，每次重启时，您都必须重新安装 Linux 软件包和更新，但您将保留备份在distributedscraping/iptest桶中的所有数据——可以通过存储> >浏览器扩展从汉堡图标访问这些数据。

确保确认您的实例已停止(灰显)。

停机后重新连接。

在云 Shell 中，启动之后，只需运行下面的 linux 命令来重新启动 DataLab。同样，连接到iptest后，您可以通过 http://localhost:8081/ 访问笔记本电脑。

datalab connect iptest

如果您出于任何原因需要 SSH 到机器，请在本地机器上使用下面的 from SDK 命令，或者在浏览器中使用 Cloud Shell。注意，您在这里找不到任何文件，因为它们都是通过 project bucket 链接的。这也适用于没有安装 DataLab 笔记本 Docker 映像的一般 GCE 实例——并允许在该上下文中进行ls探索。

gcloud compute ssh 'iptest' --zone=us-west1-a 
            --ssh-flag='-D' --ssh-flag='10000' --ssh-flag='-N'

你现在自由了！

Photo by Jünior Rodríguez on Unsplash

感谢您花时间完成本次探索。这应该可以让您开始使用 DataLab 笔记本电脑。我让您深入研究连接到远程实例的细节，为您的特定需求设置权限，并以可重复的方式分享您的发现。像往常一样，使用此处的所有内容需要您自担风险。在下一篇文章中，您将很快成为一名网页抓取忍者。\\

无头、分布式、虚拟(啊呀！):data lab 笔记本中使用 Python 进行的无畏网络抓取

集成学习:来自 1994 年美国人口普查数据库的案例研究

原文：https://towardsdatascience.com/ensemble-learning-a-case-study-from-the-1994-us-census-database-8180342819fe?source=collection_archive---------24-----------------------

Photo by 3dman_eu via Needpix.

在我们开始理解什么是集成学习以及它是如何工作的之前，我们需要知道在这个案例研究中使用的数据集。

使用的数据集是 1994 年美国人口普查数据库的子集，该数据库由 Barry Becker 提供，可在 UCI 机器学习库获得。该库的预测任务是确定一个 人一年的收入是否超过 50K，为此提供了以下属性和值:

高收入:目标阶层。
年龄:连续。
工作类别:私人，自我雇佣非公司，自我雇佣公司，联邦政府，地方政府，州政府，无薪，从未工作。
fnlwgt :连续。
教育:学士、部分大学、11 年级、HS-grad、Prof-school、Assoc-acdm、Assoc-voc、9 年级、7-8 年级、12 年级、硕士、1-4 年级、10 年级、博士、5-6 年级、学前教育。
教育编号:连续。
婚姻状况:已婚配偶、离婚、未婚、分居、丧偶、无配偶、已婚配偶。
职业:技术支持、工艺修理、其他服务、销售、行政管理、专业、搬运工人、清洁工、机器操作员、检查员、行政文员、农业、渔业、运输、私人服务、保安服务、武装部队。
关系:妻子、亲生子女、丈夫、非家庭成员、其他亲属、未婚。
种族:白人，亚洲太平洋岛民，美洲印第安爱斯基摩人，其他人，黑人。
性别:女，男。
资本收益:持续。
资本损失:持续。
每周小时数:连续。
本土国家:美国、柬埔寨、英国、波多黎各、加拿大、德国、美国外围地区(关岛-USVI 等)、印度、日本、希腊、韩国、中国、古巴、伊朗、洪都拉斯、菲律宾、意大利、波兰、牙买加、越南、墨西哥、葡萄牙、爱尔兰、法国、多米尼加共和国、老挝、厄瓜多尔、台湾、海地、哥伦比亚、匈牙利、危地马拉、尼加拉瓜、苏格兰、泰国、南斯拉夫、萨尔瓦多、特立尼达岛&多巴哥、秘鲁、香港、荷兰。

什么是集成学习？

Photo via Verde Valley Nursery

集成学习是一种结合其他机器学习模型来优化和创建更好模型的技术。

有一些不同类型的集合方法，如:助推，堆叠，粘贴，装袋和随机森林。在本案例研究中，重点是最后两种方法。

装袋粘贴:是什么？它是如何工作的？

Photo via Giphy

BootstrapAggregating或 Bagging 是一种结合了自举和聚合方法的技术。第一种方法是用替换将数据集分成 n 个子集，第二种方法的思想是创建 n 个模型，每个子集一个模型，然后将它们聚集在一起以产生最终预测。

粘贴方法的工作原理与装袋相似，但不同之处在于引导步骤，在该步骤中，分割是在没有替换的情况下进行的。

那随机森林呢？

Photo via Dribbble

随机森林是一种特殊类型的集成算法，它使用多个决策树来构建其模型。每棵树都用数据集的不同部分来训练。通常，这种分割与 bagging 技术类似，最终模型由几个决策树模型组成，这些模型组合起来产生模型的预测。

嗷，该编码了！

Via Github

对于这个项目，我们将使用 python 作为编程语言，库: pandas 和 scikit-learn 。首先，让我们了解一下我们数据的面:

# load the dataset
income = pd.read_csv("income.csv")
income.head()

在继续之前，我们需要对数据进行预处理，将分类变量转换为数值变量。在这个过程之后，这是一个数据样本:

现在，我们将使用两个伟大的 scikit-learn 特性，称为管道和 GridSearchCV ，它们允许我们自动测试不同模型的几个超参数。

# split-out train/validation and test dataset
X_train, X_test, y_train, y_test = train_test_split(income.drop(labels="high_income",axis=1),                                                    income["high_income"],test_size=0.20,random_state=seed,shuffle=True,stratify=income["high_income"])

# The full pipeline as a step in another pipeline with an estimator as the final step
pipe = Pipeline(steps = [("clf",RandomForestClassifier())])# create a dictionary with the hyperparameters
search_space = [{"clf":[DecisionTreeClassifier()],
                 "clf__criterion": ["gini","entropy"],
                 "clf__splitter": ["best","random"],
                 "clf__random_state": [seed],
                 "fs__score_func":[chi2],
                 "fs__k":[4,6,8]},
                {"clf":[RandomForestClassifier()],
                 "clf__n_estimators": [200,300],
                 "clf__criterion": ["gini","entropy"],
                 "clf__max_leaf_nodes": [32,64,128],
                 "clf__random_state": [seed],
                 "fs__score_func":[chi2],
                 "fs__k":[4,6,8]},
                {'clf' [BaggingClassifier(DecisionTreeClassifier(random_state=42))],
                 "clf__base_estimator__criterion": ['gini','entropy'],
                 "clf__base_estimator__splitter": ['best','random'],
                 "clf__oob_score": [True],
                 "clf__n_estimators": [200,300],
                 "clf__bootstrap":[True],
                 "fs__score_func":[chi2],
                 "fs__k":[4,6,8]},
                {'clf': [BaggingClassifier(DecisionTreeClassifier(random_state=42))],
                 "clf__base_estimator__criterion": ['gini','entropy'],
                 "clf__base_estimator__splitter": ['best','random'],
                 "clf__oob_score": [False],
                 "clf__n_estimators": [200,300],
                 "clf__bootstrap":[False],
                 "fs__score_func":[chi2],
                 "fs__k":[4,6,8]}]# create grid search
kfold = KFold(n_splits=num_folds,random_state=seed)grid = GridSearchCV(estimator=pipe, 
                    param_grid=search_space,
                    cv=kfold,
                    scoring=scoring,
                    return_train_score=True,
                    n_jobs=-1,
                    refit="AUC", verbose=10)

# fit grid search
best_model = grid.fit(X_train,y_train)

这种配置允许算法使用所有可用的核心，这将以并行方式测试 960 个不同配置的决策树、随机森林和 bagging 分类器(以决策树作为内部模型)。

在此过程之后，GridSearchCV 生成的最佳模型是一个随机森林模型，具有以下配置:

在我们定义这是否是最佳模型之前，让我们检查模型的准确性以训练和测试数据集。这种比较的目的是验证模型是欠配还是过配。

正如我们在上面看到的，两个集合的精度都很好，更重要的是，训练和测试精度的值非常接近。因此，这个结果表明 GridSearchCV 产生的最佳模型具有很好的通用性。

在随机森林分类器中，我们可以设置一个名为 bootstrap 的超参数，它定义天气样本是否将被替换训练。尽管选择的最佳模型的参数为假，这试图帮助模型最小化过拟合的机会，但当参数设置为真、时，其他几个模型也呈现出类似的结果，如下图所示。

因此，对于这个数据集，不管 bootstrap 变量的值如何，我们都取得了很好的结果。然而，由于可能的过度拟合，bootstrap 等于 true 时会出现最坏的结果。

了解特性的重要性

Via Giphy

现在，让我们检查数据集的每个特征对于我们的模型的重要性。对于这个任务，我们使用了两个工具:特征重要性，来自随机森林分类器和库SHAP(SHapleyA加性 exPlanations)其中是解释任何机器输出的统一方法

左图由 scikit-learn 的 feature_importances 制作，右图由 SHAP 制作。重要的是要看到两个结果呈现相似的结果，并且 4 个最重要的特征是相同的，仅改变了位置。有了这些结果，就很容易知道对模型影响最大的信息，这极大地有助于理解和解决问题。

集成学习案例研究:模型可解释性

原文：https://towardsdatascience.com/ensemble-learning-and-model-interpretability-a-case-study-95141d75a96c?source=collection_archive---------23-----------------------

这是一篇由两部分组成的文章的第一部分，在这篇文章中，我们将探索 1994 年人口普查收入数据集，它包含诸如年龄、受教育年限、婚姻状况、种族、以及许多其他信息。我们将使用该数据集将人们的潜在收入分为两类:年收入低于或等于 5 万美元的人(编码为 0)和年收入高于 5 万美元的人(编码为 1)。

在第一部分中，我们将使用这个数据集来比较简单决策树和集成方法的性能。稍后，我们还将探索一些工具来帮助我们解释为什么模型遵循可解释的人工智能(XAI) 的一些原则来做出决策。

我们需要做的第一件事是看一看选择的数据集，以便更好地了解它。所以，让我们开始吧！

1.准备数据

我们将使用没有空值的数据集的预处理版本。首先，我们加载基本库和数据集本身，并查看数据帧信息:

import   as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
plt.style.use('ggplot')# load the dataset
income = pd.read_csv("income.csv")
income.info()

Figure 1: DataFrame information

如我们所见，数据集有 32561 个观察值和 15 列，其中 14 列是特征，一列是目标变量( high_income )。有些特征是分类的(类型对象)有些是数值的(类型 int64 )，所以我们需要为它们执行不同的预处理步骤。

为了实现这一点，我们将创建两个管道:一个对分类特征执行预处理步骤，另一个对数字特征执行预处理步骤。然后，我们将使用 FeatureUnion 将这两条管道连接在一起，形成最终的预处理管道。为此以及本文中的后续步骤，我们需要从 scikit-learn 库中导入必要的模块:

from sklearn.base import BaseEstimator
from sklearn.base import TransformerMixinfrom sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import FunctionTransformerfrom sklearn.pipeline import Pipeline
from sklearn.pipeline import FeatureUnionfrom sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import RandomizedSearchCVfrom sklearn.metrics import make_scorer
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrixfrom sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import BaggingClassifier

使用 BaseEstimator 和transformer mixin类，我们可以创建两个定制的转换程序放在我们的管道上:一个将数据分成分类和数字特征，另一个预处理分类特征。这两种变压器如下所示:

# Custom Transformer that extracts columns passed as argument
class FeatureSelector(BaseEstimator, TransformerMixin):
    #Class Constructor 
    def __init__(self, feature_names):
        self.feature_names = feature_names #Return self nothing else to do here    
    def fit(self, X, y = None):
        return self #Method that describes what we need this transformer to do
    def transform(self, X, y = None):
        return X[self.feature_names]# converts certain features to categorical
class CategoricalTransformer( BaseEstimator, TransformerMixin ):
    #Class constructor method that takes a boolean as its argument
    def __init__(self, new_features=True):
        self.new_features = new_features #Return self nothing else to do here    
    def fit( self, X, y = None ):
        return self #Transformer method we wrote for this transformer 
    def transform(self, X , y = None ):
        df = X.copy()
        if self.new_features:
            # Treat ? workclass as unknown
            df['workclass']= df['workclass'].replace('?','Unknown') 
            # Two many category level, convert just US and Non-US
            df.loc[df['native_country']!=' United-States','native_country'] = 'non_usa'
            df.loc[df['native_country']==' United-States','native_country'] = 'usa' # convert columns to categorical
        for name in df.columns.to_list():
            col = pd.Categorical(df[name])
            df[name] = col.codes # returns numpy array
        return df

有了这些定制的转换器，我们就可以构建预处理管道。我们需要做的第一件事是创建 X 特征矩阵和 y 目标向量:

# Create the X feature matrix and the y target vector
X = income.drop(labels="high_income", axis=1)
y = income["high_income"]# the only step necessary to be done outside of pipeline
# convert the target column to categorical
col = pd.Categorical(y)
y = pd.Series(col.codes)# global variables
seed = 108

之后，我们提取分类和数字特征名称，并在定义了要在每个特征中使用的步骤之后创建 2 个管道。对于分类管道，我们使用 FeatureSelector 只选择分类列，然后使用 CategoricalTransformer 将数据转换成所需的格式；至于数字管道，我们也将使用 FestureSelector，这次只选择数字特征，随后使用 as StandardScaler 来标准化数据。代码如下所示:

# get the categorical feature names
categorical_features = X.select_dtypes("object").columns.to_list()
# get the numerical feature names
numerical_features = X.select_dtypes("int64").columns.to_list()# create the steps for the categorical pipeline
categorical_steps = [
    ('cat_selector', FeatureSelector(categorical_features)),
    ('cat_transformer', CategoricalTransformer())
]# create the steps for the numerical pipeline
numerical_steps = [
    ('num_selector', FeatureSelector(numerical_features)),
    ('std_scaler', StandardScaler()),
]# create the 2 pipelines with the respective steps
categorical_pipeline = Pipeline(categorical_steps)
numerical_pipeline = Pipeline(numerical_steps)

现在我们可以使用 FeatureUnion 类来水平连接这两个管道，这样我们最终只有一个最终预处理管道:

pipeline_list = [
    ('categorical_pipeline', categorical_pipeline),
    ('numerical_pipeline', numerical_pipeline)
]# Combining the 2 pieplines horizontally into one full pipeline 
preprocessing_pipeline =FeatureUnion(transformer_list=pipeline_list)

就这样，现在你所要做的就是对数据执行所有预处理步骤，调用预处理 _ 管道对象的 fit_transform 方法，将 X 矩阵作为参数传递！简洁明了。

2.训练第一个模型

在训练任何机器学习模型之前，我们必须将数据分成训练和测试组。为此，我们使用训练 _ 测试 _ 分割功能:

# split-out train/validation and test dataset
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=seed, shuffle=True, stratify=y)

我们将使用的第一个模型是一个简单的决策树分类器。为了充分利用管道的全部功能，我们可以创建一个完整的管道，第一步通过预处理管道，第二步通过所需的分类模型:

# we pass the preprocessing pipeline as a step to the full pipeline
full_pipeline_steps = [
    ('preprocessing_pipeline', preprocessing_pipeline),
    ('model', DecisionTreeClassifier(random_state=seed))
]# create the full pipeline object
full_pipeline = Pipeline(steps=full_pipeline_steps)

通过这种方式，如果我们想要尝试不同的模型(正如我们稍后将要做的)，我们所要做的就是更新这个管道的‘model’步骤！

下一步是使用 RandomizedSearchCV 执行模型超参数调整。随机搜索不如常规网格搜索彻底，因为它不会测试超参数的每个可能组合。另一方面，它的计算成本更低，使我们能够在低端硬件中实现“足够好”的结果，同时调整多个超参数。使用 n_iter 参数，我们将迭代次数限制为 50。

我们还将使用stratified fold来执行交叉验证。与常规的 KFold 不同，它保留了样品在褶皱间的分布，可能会产生更好的结果。

最后一步是用我们需要调优的超参数构建一个 param_grid 字典。完整的代码可以在下面看到。注意我们是如何将 full_pipeline 对象作为 RandomizedSearchCV 估计器传递的，然后我们在结果对象上调用 fit 方法，就像我们调用任何其他 sklearn 模型一样。这样，当我们想要测试其他模型时，我们所要做的就是改变管道上的模型，并创建一个新的参数网格来传递，就这么简单！

# Create the grid search parameter grid and scoring funcitons
param_grid = {
    "model": [DecisionTreeClassifier(random_state=seed)],
    "model__criterion": ["gini","entropy"],
    "model__splitter": ["best","random"],
    "model__max_leaf_nodes": [16, 64, 128, 256],
    "model__max_depth": np.linspace(1, 32, 32)
}scoring = {
    'AUC': 'roc_auc', 
    'Accuracy': make_scorer(accuracy_score)
}# create the Kfold object
num_folds = 10
kfold = StratifiedKFold(n_splits=num_folds, random_state=seed)# create the grid search object with the full pipeline as estimator
n_iter=50grid = RandomizedSearchCV(
    estimator=full_pipeline, 
    param_distributions=param_grid,
    cv=kfold,
    scoring=scoring,
    n_jobs=-1,
    n_iter=n_iter,
    refit="AUC"
)# fit grid search
best_model = grid.fit(X_train,y_train)

对于决策树分类器，我们正在调整以下参数:

标准:定义了度量树节点上分割质量的函数；
拆分器:定义在每个树节点选择拆分的策略；
max_leaf_nodes: 限制树中叶子节点的最大数量；
max_depth: 限制树可以生长的最大深度；

随机搜索完成且最佳模型符合我们的数据后，我们可以进行预测并衡量模型的性能:

# final Decision Tree model
pred_test = best_model.predict(X_test)
pred_train = best_model.predict(X_train)print('Train Accuracy: ', accuracy_score(y_train, pred_train))
print('Test Accuraccy: ', accuracy_score(y_test, pred_test))print('\nConfusion Matrix:')
print(confusion_matrix(y_test,pred_test))
print('\nClassification Report:')
print(classification_report(y_test,pred_test))

Figure 2: Decision tree performance

3.集成方法

集成方法是将几个基本模型结合起来以产生一个最佳预测模型的模型。RandomForestClassifier是一个典型的例子，因为它结合了几个更简单的决策树来生成输出。这样，就有可能克服决策树模型的几个局限性，比如它的过度拟合倾向。

3.1.装袋分级机

我们要使用的第一个集成方法是 BaggingClassifier 。名称 bagging 来自 bootstrap aggregating ，它的工作原理是将数据分成几个随机的子样本 ，然后用于训练每个独立的基本估计器。该策略可以以两种方式之一执行:替换，这意味着样本可以多次用于同一个估计器；无需更换，意味着每个样品只能使用一次(这种方法称为粘贴)。

装袋通常比粘贴产生更好的结果，它还有一个巧妙的锦囊妙计:袋外 评估。由于样本是替换抽取的，并且同一样本可以随机使用多次，因此训练集上的一些样本可能永远不会用于训练任何基础估计量！这意味着我们可以使用这些样本进行进一步的模型评估！

因此，考虑到所有这些，我们将更新我们之前的管道，以使用 BaggingClassifier 和决策树作为基本估计器。为此，我们所要做的就是更改管道定义中的‘模型’步骤，并重新定义 RandomizedSearchCV 参数搜索空间，如下面的代码片段所示:

# we pass the preprocessing pipeline as a step to the full pipeline
full_pipeline_steps = [
    ('preprocessing_pipeline', preprocessing_pipeline),
    ('model', BaggingClassifier(
        DecisionTreeClassifier(max_features="auto", splitter="random", max_leaf_nodes=128, random_state=seed),
        random_state=seed
    ))
]# create the full pipeline object
full_pipeline = Pipeline(steps=full_pipeline_steps)# Create the grid search parameter grid
param_grid = {
    "model": [BaggingClassifier(
        DecisionTreeClassifier(max_features="auto", splitter="random", max_leaf_nodes=128, random_state=seed),
        random_state=seed
    )],
    "model__n_estimators":  np.arange(100, 1000, 100),
    "model__max_samples":[0.8, 1.0], 
    "model__max_features": [0.8, 1.0],
    "model__bootstrap": [True],
    "model__oob_score": [True],
}scoring = {
    'AUC': 'roc_auc', 
    'Accuracy': make_scorer(accuracy_score)
}# create the Kfold object
num_folds = 10
kfold = StratifiedKFold(n_splits=num_folds, random_state=seed)# create the grid search object with the full pipeline as estimator
n_iter=25grid = RandomizedSearchCV(
    estimator=full_pipeline, 
    param_distributions=param_grid,
    cv=kfold,
    scoring=scoring,
    n_jobs=-1,
    n_iter=n_iter,
    refit="AUC"
)

# fit grid search
best_bag = grid.fit(X_train,y_train)

对于打包分类器，我们正在调整以下参数:

n_estimators: 定义要使用的估计器(在这种情况下是决策树)的总数；
max_samples: 从 X 中抽取的用于训练每个基本估计量的样本的最大百分比；
max_features: 从 X 中提取的特征的最大百分比，用于训练每个基本估计量；
bootstrap: 设置为 False 时，抽取样本而不替换(粘贴)。当设置为真时，用替换(装袋)抽取样本。因为我们要使用开箱得分，所以我们必须将该参数设置为 True
oob_score: 设置为 True 时，返回最佳模型的开箱得分；

随机搜索完成且最佳模型符合我们的数据后，我们可以检查调整后的模型超参数，进行预测并测量模型的性能:

print(f'Best score: {best_bag.best_score_}')
print(f'Best model: {best_bag.best_params_}')

Figure 3: Best Bagging model

pred_test = best_bag.predict(X_test)
pred_train = best_bag.predict(X_train)print('Train Accuracy: ', accuracy_score(y_train, pred_train))
print('Test Accuraccy: ', accuracy_score(y_test, pred_test))
print("Out-of-Bag Accuracy: ", best_bag.best_params_['model'].oob_score_)print('\nConfusion Matrix:')
print(confusion_matrix(y_test,pred_test))
print('\nClassification Report:')
print(classification_report(y_test,pred_test))

Figure 4: Bagging performance

如我们所见，该模型达到的所有 3 个精确度彼此非常接近，表明该模型对新数据具有良好的泛化能力，因此可能不会过度拟合。

3.2.随机森林分类器

我们将训练的最后一个模型是 RandomForestClassifier 。使用它的过程与上面给出的过程相同，可以在下面的代码片段中看到:

# we pass the preprocessing pipeline as a step to the full pipeline
full_pipeline_steps = [
    ('preprocessing_pipeline', preprocessing_pipeline),
    ('model', RandomForestClassifier(random_state=seed))
]# create the full pipeline object
full_pipeline = Pipeline(steps=full_pipeline_steps)# Create the grid search parameter grid and scoring funcitons
param_grid = {
    "model": [RandomForestClassifier(random_state=seed)],
    "model__max_depth": np.linspace(1, 32, 32),
    "model__n_estimators": np.arange(100, 1000, 100),
    "model__criterion": ["gini","entropy"],
    "model__max_leaf_nodes": [16, 64, 128, 256],
    "model__oob_score": [True],
}scoring = {
    'AUC': 'roc_auc', 
    'Accuracy': make_scorer(accuracy_score)
}# create the Kfold object
num_folds = 10
kfold = StratifiedKFold(n_splits=num_folds, random_state=seed)# create the grid search object with the full pipeline as estimator
n_iter=50grid = RandomizedSearchCV(
    estimator=full_pipeline, 
    param_distributions=param_grid,
    cv=kfold,
    scoring=scoring,
    n_jobs=-1,
    n_iter=n_iter,
    refit="AUC"
)# fit grid search
best_rf = grid.fit(X_train,y_train)

对于 RandomForestClassifier ，我们正在调整以下参数:

标准:定义了度量树节点上分割质量的函数；
max_leaf_nodes: 限制树中的最大叶节点数；
max_depth: 限制树木可以生长的最大深度；
n_estimators: 定义森林中使用的树木总数
oob_score: 设置为 True 时，返回最佳模型的出袋分数；

正如我们之前所做的，在随机搜索完成且最佳模型符合我们的数据后，我们可以进行预测并衡量模型的性能:

print(f'Best score: {best_rf.best_score_}')
print(f'Best model: {best_rf.best_params_}')

Figure 5: Best Random Forest model

pred_test = best_rf.predict(X_test)
pred_train = best_rf.predict(X_train)print('Train Accuracy: ', accuracy_score(y_train, pred_train))
print('Test Accuraccy: ', accuracy_score(y_test, pred_test))
print("Out-of-Bag Accuracy: ", best_rf.best_params_['model'].oob_score_)print('\nConfusion Matrix:')
print(confusion_matrix(y_test,pred_test))
print('\nClassification Report:')
print(classification_report(y_test,pred_test))

Figure 6: Random Forest performance

与 BaggingClassifier 相似，精确度彼此非常接近，表明对看不见的数据具有良好的泛化能力，因此没有过拟合。由于这是我们发现的性能最好的模型，我们将在本文的剩余部分中使用它作为例子。

4.模型可解释性

在某些情况下，从你的模型中获得好的预测可以说和理解为什么给出答案一样重要。在这些情况下，我们可以利用可解释的人工智能(XAI) 的概念，并试图使模型更容易被人类理解。

一种方法是分析模型结果中每个特征的重要性。幸运的是，随机森林有一个内置属性可以告诉我们这一点，它叫做 feature_importances_ 。下面的代码显示了访问和绘制这些信息的步骤:

# lets get the random forest model configuration and feature names
rf_model = best_rf.best_params_['model']
features = np.array(X_train.columns)# Transforming the test data.
new_X_test = preprocessing_pipeline.fit_transform(X_test)
new_X_test = pd.DataFrame(new_X_test, columns=X_test.columns)# get the predicitons from the random forest object
y_pred = rf_model.predict(new_X_test)# get the feature importances
importances = rf_model.feature_importances_# sort the indexes
sorted_index = np.argsort(importances)
sorted_importances = importances[sorted_index]
sorted_features = features[sorted_index]# plot the explained variance using a barplot
fig, ax = plt.subplots()
ax.barh(sorted_features , sorted_importances)
ax.set_xlabel('Importances')
ax.set_ylabel('Features')

Figure 7: Feature importances

这是一个简单而有效的例子，可以让你从数据和模型推理中获得更多的洞察力。有了剧情，我们可以看到最重要的特征是 education_num ， capital_loss ， fnlwgt ， capital_gain ，以及 race 。

为了更进一步，我们将简要探索两个第三方库，它们使我们能够获得不同的可视化: ELI5 和 SHAP。

4.1.使用 ELI5 进行模型解释

ELI5 是一个 Python 包，帮助调试机器学习分类器，解释它们的预测。它为一些机器学习库提供支持，包括 scikit-learn 和 XGBoost。

有了它，我们能够以两种主要方式查看分类模型:第一种是检查模型参数并分析模型如何全局工作(类似于默认的特征重要性属性)；第二个是检查单个预测，以弄清楚为什么模型会做出这样的决定。

对于第一个用例，我们使用 show_weights() 函数，如下面的代码片段所示:

import eli5# lets get the random forest model configuration and feature names
rf_model = best_rf.best_params_['model']
features = np.array(X_train.columns)eli5.show_weights(rf_model, feature_names=features)

Figure 8: ELI5 feature weights

正如我们在上面的图像中看到的，结果与我们从树特征重要性中获得的结果非常相似。

至于第二个用例，我们可以使用 explain_prediction() 函数来检查和分析模型的各个预测。为了测试这一点，我们检查了一个真正的负面预测(实际值为 0，预测值也为 0)和一个真正的正面预测(实际值为 1，预测值也为 1):

# predicting a person earns less than 50k/year (true negative)
index = 4
print('Actual Label:', y_test.iloc[index])
print('Predicted Label:', y_pred[index])
eli5.explain_prediction(rf_model, new_X_test.iloc[index], feature_names=features)# predicting a person earns more than 50k/year (true positive)
index = 7
print('Actual Label:', y_test.iloc[index])
print('Predicted Label:', y_pred[index])
eli5.explain_prediction(rf_model, new_X_test.iloc[index], feature_names=features)

Figure 9: ELI5 true negative prediction example

Figure 10: ELI5 true positive prediction example

因此，有助于模型预测这些特定观察结果的最有影响力的特征分别是种族和教育 _ 数量。

4.2.SHAP 的模型解释

SHAP(SHapley Additive exPlanations)库是解释任何机器学习模型输出的统一方法。与 ELI5 类似，它也支持几个机器学习库，包括 scikit-learn 和 XGBoost。

为了将它的功能用于我们的随机森林模型，我们首先需要创建一个 TreeExplainer 对象，并为模型获取所谓的 shap_values 。这个过程如下面的代码所示:

import shap
shap.initjs()# Create the explainer object
explainer = shap.TreeExplainer(rf_model)
print('Expected Value:', explainer.expected_value)# get the shap values from the explainer
shap_values = explainer.shap_values(new_X_test)

正如我们对 ELI5 所做的那样，我们也可以使用 SHAP 库来解释单个模型预测，如下所示，这些数据点与我们之前处理的数据点相同:

# predicting a person earns less than 50k/year (true negative)
shap.force_plot(explainer.expected_value[0],
                shap_values[0][4], X_test.iloc[4])# predicting a person earns more than 50k/year (true positive)
shap.force_plot(explainer.expected_value[1],
                shap_values[1][7], X_test.iloc[7])

Figure 11: SHAP true negative prediction example

Figure 12: SHAP true positive prediction example

此外，还可以一次显示多个预测，如下图所示为数据集的前 1000 个样本:

shap.force_plot(explainer.expected_value[0],
                shap_values[0][:1000,:], X_test.iloc[:1000,:])

Figure 12: SHAP prediction explanation for the first 1000 samples

在同一个图中，还可以分析不同特征在最终模型预测中的影响。为了测试这一点，我们对图进行了配置，以显示 education_num 特性对相同样本的重要性:

Figure 13: SHAP education_num effect for the first 1000 samples

最后，我们可以使用 summary_plot 函数来绘制按类划分的特性重要性:

shap.summary_plot(shap_values, X_test)

Figure 14: SHAP feature importances by class

我们可以看到，得到的结果与树内置特性重要性和 ELI5 库得到的结果非常相似。

5.结论

我们几乎没有触及机器学习领域中几个重要主题的表面，如管道、超参数调整、集成方法和模型可解释性。还有更多的内容要介绍！

在这个系列的下一部分，我们将看看新的集成方法的“酷小子”:梯度增强。我们将看看由 XGBoost 库提供的实现，敬请关注！

整体方法:装袋、助推和堆叠

原文：https://towardsdatascience.com/ensemble-methods-bagging-boosting-and-stacking-c9214a10a205?source=collection_archive---------0-----------------------

理解集成学习的关键概念。

Credit: Nietjuh on Pixabay

本帖与 巴蒂斯特·罗卡 共同撰写。

介绍

“团结就是力量”。这句老话很好地表达了机器学习中非常强大的“集成方法”的基本思想。粗略地说，通常信任许多机器学习竞赛(包括 Kaggle 的竞赛)的顶级排名的集成学习方法是基于这样的假设，即将多个模型组合在一起通常可以产生更强大的模型。

这篇文章的目的是介绍集成学习的各种概念。我们将为读者提供一些必要的答案，以便更好地理解和使用相关方法，并能够在需要时设计合适的解决方案。我们将讨论一些众所周知的概念，如 boosting，bagging，random forest，boosting，stacking 和其他许多集成学习的基础。为了使所有这些方法之间的联系尽可能清晰，我们将尝试在一个更广泛的逻辑框架中呈现它们，我们希望这将更容易理解和记忆。

概述

在这篇文章的第一部分，我们将提出弱学习者和强学习者的概念，我们将介绍三种主要的集成学习方法:打包、提升和堆叠。然后，在第二部分，我们将重点放在装袋，我们将讨论的概念，如自举，装袋和随机森林。在第三部分中，我们将介绍 boosting，特别是它的两个最流行的变体:自适应 boosting (adaboost)和梯度 boosting。最后，在第四部分，我们将给出堆栈的概述。

什么是系综方法？

集成学习是一种机器学习范式，其中多个模型(通常称为“弱学习者”)被训练来解决同一问题，并被组合以获得更好的结果。主要假设是，当弱模型被正确组合时，我们可以获得更准确和/或更稳健的模型。

单一弱学习者

在机器学习中，无论我们面对的是分类还是回归问题，模型的选择对于有机会获得好的结果都是极其重要的。这种选择取决于问题的许多变量:数据的数量、空间的维度、分布假设…

低偏差和低方差是模型的两个最基本的预期特征，尽管它们通常以相反的方向变化。事实上，为了能够“解决”一个问题，我们希望我们的模型有足够的自由度来解决我们正在处理的数据的潜在复杂性，但我们也希望它没有太多的自由度来避免高方差和更健壮。这就是众所周知的偏差-方差权衡。

Illustration of the bias-variance tradeoff.

在集成学习理论中，我们称弱学习者(或基础模型)模型，这些模型可以作为构建模块，通过组合其中的几个来设计更复杂的模型。大多数时候，这些基本模型本身表现不佳，要么是因为它们有较高的偏差(例如，低自由度模型)，要么是因为它们有太多的方差而不稳定(例如，高自由度模型)。然后，集成方法的思想是试图通过将这些弱学习者中的几个组合在一起来减少偏差和/或方差，以便创建实现更好性能的强学习者(或集成模型)。

结合弱学习者

为了建立集成学习方法，我们首先需要选择要聚合的基本模型。大多数时候(包括在众所周知的 bagging 和 boosting 方法中),使用单个基础学习算法，因此我们有以不同方式训练的同质弱学习器。于是我们得到的系综模型被称为是“齐次的”。然而，也存在一些使用不同类型的基本学习算法的方法:一些异类弱学习器然后被组合成“异类集成模型”。

重要的一点是，我们对弱学习者的选择应该与我们聚合这些模型的方式一致。如果我们选择具有低偏差但高方差的基础模型，则应该使用倾向于减少方差的聚合方法，而如果我们选择具有低方差但高偏差的基础模型，则应该使用倾向于减少偏差的聚合方法。

这就给我们带来了如何组合这些模型的问题。我们可以提到三种主要的元算法，旨在组合弱学习者:

bagging ，通常考虑同质的弱学习者，并行地相互独立地学习它们，并按照某种确定性的平均过程组合它们
boosting ，通常考虑同质的弱学习者，以一种适应性很强的方式顺序学习它们(基础模型取决于前面的模型)，并按照确定性策略组合它们
堆叠，通常考虑异类弱学习者，并行学习它们，并通过训练元模型来组合它们，以基于不同的弱模型预测输出预测

非常粗略地说，我们可以说 bagging 将主要集中于获得方差小于其分量的集合模型，而 boosting 和 stacking 将主要试图产生比其分量偏差更小的强模型(即使方差也可以被减小)。

在接下来的部分中，我们将在给出堆栈的简要概述之前，详细介绍 bagging 和 boosting(这比 stacking 使用得更广泛一些，并且允许我们讨论集成学习的一些关键概念)。

Weak learners can be combined to get a model with better performances. The way to combine base models should be adapted to their types. Low bias and high variance weak models should be combined in a way that makes the strong model more robust whereas low variance and high bias base models better be combined in a way that makes the ensemble model less biased.

专注于装袋

在平行方法中，我们让不同的学习者相互独立地适应，因此，可以同时训练他们。最著名的方法是“bagging”(代表“bootstrap aggregating”)，旨在产生一个比组成它的单个模型更健壮的集合模型。

拔靴带

让我们从定义自举开始。这种统计技术包括通过随机抽取替换的 B 观测值，从大小为 N 的初始数据集生成大小为 B 的样本(称为 bootstrap 样本)。

Illustration of the bootstrapping process.

在某些假设下，这些样本具有非常好的统计特性:在第一近似值中，它们可以被视为直接来自真实的底层(通常未知)数据分布，并且彼此独立。因此，它们可以被视为真实数据分布的代表性独立样本(几乎同分布样本)。为了使这种近似有效，必须验证假设是双重的。首先，初始数据集的大小 N 应该足够大，以捕捉基本分布的大部分复杂性，以便从数据集采样是从真实分布采样的良好近似(代表性)。第二，与引导样本的大小 B 相比，数据集的大小 N 应该足够大，以使样本不太相关(独立性)。请注意，在下文中，我们有时会提到 bootstrap 样本的这些属性(代表性和独立性):读者应该始终记住这只是一个近似值。

例如，Bootstrap 样本通常用于评估统计估计量的方差或置信区间。根据定义，统计估计量是一些观察值的函数，因此是一个具有来自这些观察值的方差的随机变量。为了估计这种估计量的方差，我们需要对从感兴趣的分布中抽取的几个独立样本进行评估。在大多数情况下，考虑真正独立的样本需要的数据比实际可用的数据多得多。然后，我们可以使用 bootstrapping 来生成几个 bootstrap 样本，这些样本可以被视为“几乎具有代表性”和“几乎独立”(几乎同分布样本)。这些 bootstrap 样本将允许我们通过评估每个样本的值来近似估计量的方差。

Bootstrapping is often used to evaluate variance or confidence interval of some statistical estimators.

制袋材料

当训练模型时，无论我们是在处理分类问题还是回归问题，我们都会获得一个接受输入、返回输出并根据训练数据集定义的函数。由于训练数据集的理论方差(我们提醒数据集是来自真实的未知基础分布的观察样本)，拟合的模型也易变:如果观察到另一个数据集，我们将获得不同的模型。

bagging 的想法很简单:我们希望拟合几个独立的模型，并“平均”它们的预测，以获得一个方差较低的模型。然而，在实践中，我们无法拟合完全独立的模型，因为这需要太多的数据。因此，我们依靠 bootstrap 样本的良好“近似属性”(代表性和独立性)来拟合几乎独立的模型。

首先，我们创建多个 bootstrap 样本，这样每个新的 bootstrap 样本将作为另一个(几乎)独立于真实分布的数据集。然后，我们可以为这些样本中的每一个拟合一个弱学习者，并最终聚合它们，这样我们就可以“平均”它们的输出，从而获得一个方差小于其分量的集成模型。粗略地说，由于 bootstrap 样本近似独立且同分布(i.i.d .)，所以学习的基础模型也是如此。然后，“平均”弱学习者的输出不会改变预期的答案，但会减少其方差(就像平均 i.i.d .随机变量保持期望值但减少方差一样)。

因此，假设我们有 L 个大小为 B 的 bootstrap 样本(L 个独立数据集的近似值)

我们可以拟合 L 个几乎独立的弱学习者(每个数据集一个)

然后将它们聚合到某种平均过程中，以便获得具有较低方差的集合模型。例如，我们可以这样定义我们的强模型

有几种可能的方法来集合并行拟合的多个模型。对于回归问题，单个模型的输出可以被平均以获得集合模型的输出。对于分类问题，每个模型输出的类可以被视为一个投票，获得大多数投票的类由集成模型返回(这被称为硬投票)。仍然对于分类问题，我们也可以考虑所有模型返回的每个类别的概率，平均这些概率并保留平均概率最高的类别(这被称为软投票)。如果可以使用任何相关的权重，平均值或投票可以是简单的，也可以是加权的。

最后，我们可以提到，装袋的一大优势是它可以并行。由于不同的模型相互独立地拟合，如果需要，可以使用密集的并行化技术。

Bagging consists in fitting several base models on different bootstrap samples and build an ensemble model that “average” the results of these weak learners.

随机森林

学习树是集成方法非常流行的基础模型。由多棵树组成的强学习者可以称为“森林”。组成一个森林的树木可以选择浅的(很少的深度)或深的(很多深度，如果没有完全生长的话)。浅树的方差较小，但偏差较大，因此对于我们将在下文描述的顺序方法来说，浅树是更好的选择。另一方面，深树具有低偏差但高方差，因此是主要集中在减少方差的 bagging 方法的相关选择。

随机森林方法是一种装袋方法，其中深树(安装在引导样本上)被组合以产生具有较低方差的输出。然而，随机森林还使用另一种技巧来使多个拟合的树彼此之间的相关性降低:在生长每棵树时，我们不是只对数据集中的观察值进行采样来生成引导样本，而是对特征进行采样，并且只保留它们的随机子集来构建树。

对特征进行采样实际上具有这样的效果，即所有树并不查看完全相同的信息来做出决策，因此，它降低了不同返回输出之间的相关性。采样优于特征的另一个优点是它使决策过程对缺失数据更加稳健:具有缺失数据的观测值(来自或不来自训练数据集)仍然可以基于只考虑数据未缺失的特征的树进行回归或分类。因此，随机森林算法结合了 bagging 和随机特征子空间选择的概念来创建更鲁棒的模型。

Random forest method is a bagging method with trees as weak learners. Each tree is fitted on a bootstrap sample considering only a subset of variables randomly chosen.

专注于提升

在顺序方法中，不同的组合弱模型不再相互独立地拟合。想法是迭代地拟合模型，使得在给定步骤的模型训练依赖于在先前步骤拟合的模型。“Boosting”是这些方法中最著名的，它产生的集成模型通常比组成它的弱学习者更少偏差。

助推

Boosting 方法和 bagging 方法的工作原理是一样的:我们建立一系列模型，这些模型被聚合起来以获得表现更好的强学习者。然而，与主要旨在减少方差的 bagging 不同，boosting 是一种以非常自适应的方式依次拟合多个弱学习者的技术:序列中的每个模型都被拟合，从而给予数据集中被序列中的先前模型处理得不好的观察值更多的重要性。直观地说，每个新模型都将其努力集中在最困难的观察上以适应到目前为止，因此我们在过程结束时获得了一个具有较低偏差的强学习者(即使我们可以注意到增强也可以具有减少方差的效果)。像 bagging 一样，Boosting 可以用于回归以及分类问题。

由于主要致力于减少偏差，通常考虑用于提升的基础模型是具有低方差但高偏差的模型。例如，如果我们想使用树作为我们的基础模型，我们将在大多数情况下选择只有几个深度的浅决策树。促使使用低方差但高偏差模型作为弱学习器进行增强的另一个重要原因是，这些模型一般来说拟合的计算成本较低(参数化时自由度较少)。事实上，由于适合不同模型的计算不能并行进行(不像 bagging)，因此依次适合几个复杂的模型可能会变得过于昂贵。

一旦选择了弱学习者，我们仍然需要定义它们将如何被顺序拟合(当拟合当前模型时，我们考虑来自先前模型的什么信息？)以及它们将如何聚合(我们如何将当前模型聚合到以前的模型？).我们将在以下两个小节中讨论这些问题，尤其是描述两个重要的提升算法:adaboost 和梯度提升。

简而言之，这两种元算法在顺序过程中如何创建和聚集弱学习者方面有所不同。自适应增强更新附加到每个训练数据集观察值的权重，而梯度增强更新这些观察值。这种主要差异来自两种方法试图解决寻找最佳模型的优化问题的方式，该模型可以写成弱学习器的加权和。

Boosting consists in, iteratively, fitting a weak learner, aggregate it to the ensemble model and “update” the training dataset to better take into account the strengths and weakness of the current ensemble model when fitting the next base model.

适应性增压

在适应性增强(通常称为“adaboost”)中，我们试图将我们的集成模型定义为 L 个弱学习器的加权和

找到这种形式的最佳集合模型是一个困难的优化问题。然后，我们不是试图一次解决它(找到所有系数和给出最佳总体加性模型的弱学习器)，而是利用一个更易处理的迭代优化过程，即使它可能导致次优解。更具体地，我们逐个添加弱学习器，在每次迭代中寻找最佳可能对(系数、弱学习器)以添加到当前集成模型。换句话说，我们递归地定义(s_l)是这样的

其中，选择 c_l 和 w_l，使得 s_l 是最符合训练数据的模型，因此，这是对 s_(l-1)的最佳可能改进。然后我们可以表示

其中 E(。)是给定模型的拟合误差，e(。,.)是损失/误差函数。因此，我们通过“局部地”优化构建并将弱学习者逐个添加到强模型来逼近最优，而不是在总和中对所有 L 个模型进行“全局”优化。

更具体地，当考虑二进制分类时，我们可以表明 adaboost 算法可以被重写为如下进行的过程。首先，它更新数据集中的观测值权重，并训练新的弱学习器，特别关注被当前集成模型错误分类的观测值。第二，它根据表示该弱模型性能的更新系数，将弱学习器添加到加权和中:弱学习器表现越好，它对强学习器的贡献越大。

因此，假设我们面临一个二进制分类问题，在我们的数据集中有 N 个观察值，我们希望对给定的弱模型族使用 adaboost 算法。在算法的最开始(序列的第一个模型)，所有的观察值具有相同的权重 1/N。然后，我们重复 L 次(对于序列中的 L 个学习者)以下步骤:

用当前观测值权重拟合最佳弱模型
计算更新系数的值，该更新系数是弱学习者的某种标量评估度量，其指示该弱学习者应该在多大程度上被考虑到集成模型中
通过添加新的弱学习器乘以其更新系数来更新强学习器
计算新的观察值权重，该权重表示我们希望在下一次迭代中关注哪些观察值(聚集模型错误预测的观察值的权重增加，而正确预测的观察值的权重减少)

重复这些步骤，然后我们按顺序建立我们的 L 模型，并将它们聚合成一个简单的线性组合，通过系数加权来表示每个学习者的表现。注意，存在初始 adaboost 算法的变体，例如 LogitBoost(分类)或 L2Boost(回归),其主要区别在于它们对损失函数的选择。

Adaboost updates weights of the observations at each iteration. Weights of well classified observations decrease relatively to weights of misclassified observations. Models that perform better have higher weights in the final ensemble model.

梯度推进

在梯度提升中，我们试图建立的集成模型也是弱学习者的加权和

就像我们提到的 adaboost 一样，在这种形式下寻找最优模型太难了，需要迭代的方法。自适应增强的主要区别在于顺序优化过程的定义。事实上，梯度推进将问题转化为梯度下降问题:在每次迭代中，我们将弱学习器拟合到当前拟合误差相对于当前整体模型的梯度的相反值。让我们试着澄清这最后一点。首先，系综模型上的理论梯度下降过程可以写成

其中 E(。)是给定模型的拟合误差，c_l 是对应于步长的系数

与步骤 l-1 中关于集合模型的拟合误差的梯度相反。这个(相当抽象)与梯度相反的函数实际上只能对训练数据集中的观测值进行评估(我们知道其输入和输出):这些评估被称为附属于每个观测值的伪残差。此外，即使我们知道这些伪残差的观测值，我们也不想向我们的集合模型添加任何类型的函数:我们只想添加弱模型的新实例。因此，自然要做的事情是将弱学习者拟合到为每个观察计算的伪残差。最后，按照一维优化过程(线搜索以获得最佳步长 c_l)计算系数 c_l。

因此，假设我们想要对给定的弱模型族使用梯度推进技术。在算法的最开始(序列的第一个模型)，伪残差被设置为等于观察值。然后，我们重复 L 次(对于序列的 L 个模型)以下步骤:

将最佳可能的弱学习器拟合到伪残差(近似与当前强学习器的梯度相反)
计算最佳步长的值，该值定义了我们在新的弱学习器的方向上更新集成模型的程度
通过添加新的弱学习器乘以步长(形成梯度下降的步长)来更新集成模型
计算新的伪残差，该伪残差指示对于每个观测，我们接下来将在哪个方向上更新集合模型预测

重复这些步骤，然后我们按顺序建立我们的 L 模型，并按照梯度下降法聚合它们。请注意，自适应提升试图在每次迭代中精确地解决“局部”优化问题(找到最佳弱学习器及其系数以添加到强模型)，而梯度提升则使用梯度下降方法，并且可以更容易地适应大量损失函数。因此，梯度增强可以被认为是 adaboost 对任意可微损失函数的推广。

Gradient boosting updates values of the observations at each iteration. Weak learners are trained to fit the pseudo-residuals that indicate in which direction to correct the current ensemble model predictions to lower the error.

堆叠概述

堆垛与装袋和助推主要有两点不同。第一次堆叠通常考虑异质弱学习者(组合不同的学习算法)，而 bagging 和 boosting 主要考虑同质弱学习者。第二，堆叠学习使用元模型来组合基本模型，而打包和提升遵循确定性算法来组合弱学习器。

堆垛

正如我们已经提到的，堆叠的想法是学习几个不同的弱学习器，通过训练一个元模型来组合它们，以基于这些弱模型返回的多个预测来输出预测。因此，我们需要定义两件事情来构建我们的堆叠模型:我们想要适合的 L 个学习者和组合它们的元模型。

例如，对于分类问题，我们可以选择 KNN 分类器、逻辑回归和 SVM 作为弱学习器，并决定学习神经网络作为元模型。然后，神经网络将把我们三个弱学习器的输出作为输入，并基于它学习返回最终预测。

所以，假设我们要拟合一个由 L 个弱学习者组成的堆叠系综。然后，我们必须遵循以下步骤:

将训练数据分成两部分
选择 L 个弱学习者，并使它们适合第一层的数据
对于 L 个弱学习者中的每一个，对第二个文件夹中的观察值进行预测
使用弱学习者做出的预测作为输入，在第二层上拟合元模型

在前面的步骤中，我们将数据集分成两部分，因为已经用于弱学习者训练的数据预测与元模型的训练不相关。因此，将数据集分成两部分的一个明显的缺点是，我们只有一半的数据来训练基本模型，另一半的数据来训练元模型。然而，为了克服这种限制，我们可以遵循某种“k-fold 交叉训练”方法(类似于在 k-fold 交叉验证中所做的),使得所有的观察都可以用于训练元模型:对于任何观察，弱学习者的预测都是利用在 k-1 fold 上训练的这些弱学习者的实例来完成的，这些弱学习者不包含所考虑的观察。换句话说，它包括在 k-1 个折叠上的训练，以便在剩余的折叠上进行预测，并且迭代地获得对任何折叠中的观察结果的预测。这样做，我们可以为数据集的每个观察值生成相关的预测，然后在所有这些预测上训练我们的元模型。

Stacking consists in training a meta-model to produce outputs based on the outputs returned by some lower layer weak learners.

多层堆叠

堆叠的一个可能扩展是多级堆叠。它包括用多层进行堆叠。作为一个例子，让我们考虑一个 3 层堆叠。在第一级(层)中，我们拟合已经选择的 L 个弱学习者。然后，在第二个层次，不是在弱模型预测上拟合单个元模型(如前一小节所述)，而是拟合 M 个这样的元模型。最后，在第三级，我们拟合最后一个元模型，该元模型将前一级的 M 个元模型返回的预测作为输入。****

从实践的角度来看，注意，对于多层堆叠集成模型的不同层的每个元模型，我们必须选择几乎可以是我们想要的任何东西的学习算法(甚至是已经在较低层使用的算法)。我们还可以提到增加级别可能是数据昂贵的(如果不使用类似 k-folds 的技术，则需要更多数据)或者时间昂贵的(如果使用类似 k-folds 的技术，则需要拟合大量模型)。

Multi-level stacking considers several layers of stacking: some meta-models are trained on outputs returned by lower layer meta-models and so on. Here we have represented a 3-layers stacking model.

外卖食品

这篇文章的主要观点如下:

集成学习是一种机器学习范式，其中多个模型(通常称为弱学习器或基础模型)被训练来解决同一问题，并被组合以获得更好的性能
主要假设是，如果我们以正确的方式组合弱学习者，我们可以获得更准确和/或更鲁棒的模型
在 bagging 方法中，相同基础模型的几个实例在不同的引导样本上并行(彼此独立地)训练，然后在某种“平均”过程中聚集
在 bagging 方法中对(几乎)独立同分布拟合模型进行的这种平均操作主要允许我们获得一个方差低于其分量的集合模型:这就是为什么具有低偏差但高方差的基础模型非常适合 bagging 的原因
在 boosting 方法中，相同基础模型的几个实例被顺序训练，使得在每次迭代中，训练当前弱学习器的方式取决于先前的弱学习器，更具体地说，取决于它们如何对数据进行操作
boosting 方法中使用的这种迭代学习策略适应于先前模型的弱点来训练当前模型，主要允许我们获得比其分量具有更低偏差的集成模型:这就是为什么具有低方差但高偏差的弱学习器很适合 boosting 的原因
在堆叠方法中，不同的弱学习器彼此独立地被拟合，并且元模型在其上被训练以基于由基本模型返回的输出来预测输出

在这篇文章中，我们已经给出了集成学习的基本概述，尤其是该领域的一些主要概念:自举、bagging、随机森林、boosting (adaboost，gradient boosting)和堆叠。在被搁置的概念中，我们可以提到例如用于 bagging 的 Out-Of-Bag 评估技术，或者非常流行的“XGBoost”(代表 eXtrem Gradient Boosting)，这是一个实现梯度增强方法以及大量其他技巧的库，这些技巧使学习更加高效(并且易于处理大数据集)。

最后，我们想通过提醒集成学习是关于组合一些基本模型以便获得具有更好性能/特性的集成模型来结束。因此，即使装袋、助推和堆叠是最常用的集合方法，也有可能出现变体，并且可以设计成更好地适应某些特定问题。这主要需要两件事:充分理解我们所面临的问题…并且有创造力！

感谢阅读！

我们与巴蒂斯特·罗卡的最后一篇文章:

** [## 机器学习中不平衡数据集的处理

面对不平衡的班级问题，应该做什么，不应该做什么？

towardsdatascience.com](/handling-imbalanced-datasets-in-machine-learning-7a0e84220f28) [## 马尔可夫链简介

定义、属性和 PageRank 示例。

towardsdatascience.com](/brief-introduction-to-markov-chains-2c8cab9c98ab)**

集合方法，从直觉到实施

原文：https://towardsdatascience.com/ensemble-methods-or-democracy-for-ai-bac2fa129f61?source=collection_archive---------27-----------------------

民主、投票和多样性如何让人工智能受益

Taken by me: somewhere I learned a great deal. Somewhere I miss.

简介:一个正确的民主故事

我的目的是帮助你对什么是系综方法以及它们如何工作建立一种直觉。本文首先假设没有关于这个主题的知识。具体来说，这个介绍是关于获得一个心智模型。心智模型是为了帮助你在你熟悉的概念和你将要学习的新概念之间找到相似之处。

在一篇关于机器学习的文章中谈论民主、投票和多样性似乎无关。尽管如此，这些相同的概念也适用于人工智能世界，就像它们在我们的世界中一样。我冒昧地在我的标题和整篇文章中采用了相当轻松的语气。我的希望是你在娱乐的同时继续学习。

在许多情况下，几个稍有根据的猜测比一个非常有根据的猜测要好。这是群众的智慧战胜了个人的专长。这样的群体包括各种视角，一旦聚集起来，就会产生比最准确的个人视角更准确的元视角。但是，尽管这带来了很多好处，但必须满足几个假设:

这些猜测至少要稍加训练。换句话说，它们应该比随机更好。从一群无知的文盲的投票中不会有太多的好处。
观点应该是不同的，要么是他们思考和猜测的方式不同，要么是他们获得的经验不同。一个人人都学到完全相同的东西的群体是思想封闭的；全对的时候达成共识，全错的时候达成共识。视角越多样，你能看到的角度就越多。

第 1 部分:像创造者一样的机器

也许我们按照自己的形象创造了机器学习模型，并让它们用 democ 来统治自己..整体方法。

大数定律

我要你抓起一枚硬币，扔几次，然后记录下你得到的东西。在 10 次投掷中，不可能有 5 次是正面，5 次是反面。更不可能的是，在 100 次投掷中，50 次是正面，50 次是反面...即使你的硬币完全平衡，你也不太可能得到相同数量的正面和反面。如果你扔一枚硬币，而这枚硬币是经过制作和测量的，80%的情况下都是反面，那也差不多。你不可能在 10 次投掷中得到 8 条尾巴，或者在 20 次投掷中得到 16 条尾巴，或者在 100 次投掷中得到 80 条尾巴…

抛一枚公平的硬币很多次，得到大多数正面或反面，这种情况并不少见。例如，你可以将一枚硬币抛 10 次，得到 8 个正面和 2 个反面。头或尾落地的概率是相等的；正面是 0.5，反面是 0.5。那么为什么有可能得到一个结果的绝大多数。为什么不总是在每 10 次投掷中得到 5 次正面和 5 次反面，因为它们都是同样可能的结果？

在试图解释为什么会发生这种情况时，人们有时会陷入赌徒的偏见:因为到目前为止，由一枚公平硬币进行的大多数投掷都是正面朝上，所以下一次投掷更有可能是正面朝下。好像硬币在记录以前的结果，当它出错时会觉得有责任回来。但事实并非如此，因为每次折腾都是独立事件。这给我们带来了一个基本问题:结果的概率意味着什么？

看看这个 Wolfram 模拟吧，也许还能修补一下。继续无限制，你可以随时从右上角的“+”回到初始设置。你回来的时候我会在这里，从你离开的地方继续。

6 coins tossed 1000 times. The proportion of heads is plotted against the number of tosses.

你看到的是 6 枚公平币(0.5 概率正面)，每枚抛 1000 次(根据演示描述)。随机种子是一个用来产生随机性的值，如果需要的话，可以重现相同的随机性。灰色水平线始终设置为人头概率值，这里为 0.5。

在每个实验中，随着投掷次数的增加，正面的比例接近正面的概率线。如果我们继续增加投掷的次数，最终正面的比例将等于正面的概率。不管你重复多少次实验，也不管你为硬币分配的概率值是多少，这都是正确的。这就是大数定律。

总结一下，我们看到使用 6 个相似的硬币，每一个都投掷 1000 次，使得正面的比率更接近正面的概率。我们也可以投掷 6000 枚类似的硬币，我们会注意到类似的结果；人头比例总会收敛到人头概率。

将大数定律应用于机器学习

有时候，你尽最大努力训练一台机器，而一个 51%准确率的模型就是你所能展示的全部。如果你发现自己处于如此可怕的时期，不要绝望，用大数法则来代替。

一台 51%正确的机器只比随机机器好一点点。但是如果你可以把它复制成 1000 个模型，然后把他们的个人答案汇总成一个投票，大多数投票的答案在 73%的情况下都是正确的。有了 10000 个这样的模型，投票的答案在 97%的时候都是正确的。这是因为获得大多数好答案的概率随着模型数量的增加而增加。

A. Géron, Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (2019)

这可以通过掷硬币再次形象化。随着投掷次数的增加，有 51%正面概率的硬币将有越来越多的正面概率。

如果你想自己验证更多的模型可以增加他们选出正确答案的概率，你可以计算累积二项式概率:

Formula for computing the cumulative binomial probability

要将此公式应用于 1000 个模型，每个模型的精确度为 0.51，您必须将 501 个模型集体投票得出正确答案的二项式概率、502 个模型集体投票得出正确答案的二项式概率……以及 1000 个模型集体投票得出正确答案的二项式概率相加。但是生活就是为了活着，你可以用这个二项式概率计算器来代替。

The first value is p, the second is n, and the third is x. The last cumulative probability is what you’re looking for.

当然，为同一项任务构建数千个模型在计算上似乎并不高效。但是我们从一个相当糟糕的情况开始，将精确度设置为比随机猜测略好。通常情况下，在训练了几个模型并选择了最好的模型后，您会求助于使用这种方法。通过组合一组合适的模型，你可以用更少的模型获得实质性的改进。但是，尽管这带来了很多好处，还是要满足一些假设。

快速术语:在机器学习中，一组模型被称为集合。

满足所需的假设

机器和它们的创造者一样，受益于群体的智慧，前提是它们满足相同的主要假设:

模型的准确性应该高于随机猜测。这可以通过在数据集上训练模型并在选择表现最佳的模型之前评估它们的准确性来满足。
模型应该相互独立。这可以通过多种方式来满足:

对每个模型使用不同的算法。
使用相同的算法并在来自训练数据集的实例的不同子集上训练每个模型。
使用相同的算法并在来自训练数据集的特征的不同子集上训练每个模型。
结合了前面的两个选项:相同的算法、不同的实例和用于训练每个模型的不同特征。

快速术语:上面的第二个选项被称为打包(简称引导聚集)当随机抽样子集允许实例被选择不止一次时(我们称之为替换抽样)。但是，在不替换的情况下进行采样时，称为粘贴。第三种选择叫做随机子空间方法。第四个选项叫做随机补丁方法。

下一部分将通过提供实际例子来阐述。

第二部分:召唤他们的词语

巨蟒嘶嘶地向他们将要学习的树招手

让他们学习的东西

我们将要使用的数据集叫做 make_moons 。我们将使用它来生成 500 个具有 2 个特征的实例。每个实例将属于“0”类或“1”类。

Plot of the generated dataset.

下一步是分割数据集，用于训练和测试目的。

不同的算法，相同的数据

我们将使用三种不同的算法创建三个模型:决策树分类器、逻辑回归分类器和支持向量分类器。我们将训练他们将实例分为两类。然后我们会问他们，根据他们学到的知识来猜测 X_test 中的每个实例是属于 0 类还是 1 类。最后，我们将通过比较他们的猜测(预测)与实际标签 y_test 来评估他们的准确性。

SVC 模型是最精确的，具有 0.896 的精确度。让我们把这三个模型结合成一个整体模型。

The ensemble’s accuracy is 0.904, outperforming the SVC model.

上面的代码创建了一个称为 VotingClassifier 的集合。每次要求集成预测一个实例是 0 类还是 1 类时，三个模型各自进行预测，集成输出多数投票的类。这叫做硬投票。

软投票另一方面稍微领先一步，可以带来更好的准确性。除了简单地要求单个分类器进行预测，我们还可以要求它们输出一个对其预测的置信度的度量。因此，将有可能根据置信度度量来为预测赋予或多或少的可信度。

With soft voting the accuracy increased to 0.912

相同的算法，不同的数据

我们可以依靠复制相同的模型来制作合奏，并为每个单独的模型教授不同的东西。下面的代码实现了第 2 部分末尾讨论的打包技术。

The single SVC model has 0.896 accuracy. An ensemble of 100 SVC models has 0.904 accuracy.

随机子空间是另一种使用不同数据来教导集合的单个模型的方式。它不是从训练集中随机抽取实例，而是随机抽取特征。对于我们的数据集不实用，因为我们只有两个特征 x1 和 x2，但对于更复杂的数据集绝对值得尝试。要使用它，只需将上面代码中的“max_samples”替换为“max_features”。

最后，随机补丁结合了装袋和随机子空间。要使用它，请设置“最大样本数”和“最大特征数”的值。

更进一步

[## 模拟抛硬币实验和大数定律- Wolfram 演示项目

也许解释大数定律的最简单的方法就是抛硬币实验。如果一个公平的硬币(一…

demonstrations.wolfram.com](https://demonstrations.wolfram.com/SimulatedCoinTossingExperimentsAndTheLawOfLargeNumbers/#more) [## 二项式概率计算器

常见问题二项式实验有以下特点:实验涉及重复…

stattrek.com](https://stattrek.com/online-calculator/binomial.aspx) [## 使用 Scikit-Learn、Keras 和 TensorFlow 进行机器实践学习，第二版

通过最近的一系列突破，深度学习推动了整个机器学习领域。现在，甚至…

www.oreilly.com](https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/) [## 迈赫迪-胺/型号-统一

带有代码示例的 Jupyter 笔记本 github.com](https://github.com/Mehdi-Amine/models-unified/blob/master/Ensemble_Methods.ipynb)

深度网络的集合

原文：https://towardsdatascience.com/ensembles-of-convolutional-networks-3f81f59978a3?source=collection_archive---------10-----------------------

模型集成指的是将来自多个统计模型的预测进行组合以形成一个最终预测的实践。这为模型表现能力的多样性提供了机会。这个概念类似于诸如寻求多个医生的意见之类的轶事。模型集合是对传统机器学习模型的一种非常常见的增强，例如将决策树升级到随机森林。与机器学习模型相比，深度模型需要很长时间来训练，因此形成每个都从零开始训练的深度模型的集合是不实际的。这篇文章介绍了 Minetto 等人设计的名为“Hydra”的 CNN 系综的新奇之处。这种设计通过对集合中的模型使用共享的特征提取器网络来节省计算时间。以下是这篇论文的链接:

[## Hydra:用于地理空间土地分类的卷积神经网络集成

我们在本文中描述了 Hydra，一个用于地理空间土地分类的卷积神经网络(CNN)的集成…

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

很快，下图总结了九头蛇的主要思想:

FMoW is the dataset used for their specific task, the Hydra’s body consists of many neural network layers assembled according to the ResNet and DenseNet design. Each of the Hydra’s heads consists of a fully-connected layer trained on different partitions of the FMoW dataset. The ImageNet weights are used to initialize the network.

深度网络可以被模块化并被认为由两个组件组成，一个特征提取器和一个分类网络。在上图中，两个强大的深度 CNN 架构， ResNet 和 DenseNet 用于从图像中提取特征，这些特征被传递到多个分类' heads '中。提取特征会降低输入的维数，从 224 x 224 x 3 的图像降低到 4096 x 1 的向量。从九头蛇身体中提取的向量被用作九头蛇头部的输入，因此 4096×1 向量变成了与类的数量一样大的类预测向量。

训练是为了微调九头蛇头部的重量，使它们能够适应手头的任务。上图中另一个有趣的细节是 ImageNet 权重。这被用作九头蛇身体重量的转移学习初始化方法。然后使用 FMoW(世界功能地图)土地分类数据集对这些权重进行微调，Minetto 等人正在为此训练他们的网络。在微调这些权重后，完全连接的层被切掉，并被九头蛇的头取代。希望在这个解释之后你能明白为什么他们选择把它命名为九头蛇。九头蛇是某种多头龙，类似于多头龙，集合卷积神经网络的每个头共享相同的身体。

The idea is further simplified in the image above, subsets of the data are used to fine-tune each classification network / ‘Head’ of the Hydra

这样做的一些有趣的特征是，它促进了模型中功能和数据的多样性。功能多样性可以通过在每个水螅头的全连接层中添加新奇的东西来实现，甚至可以重塑特征提取向量并再次对其进行卷积。然而，实现数据多样性是一个更有趣的范例，本文也对此进行了研究。

集成模型通常通过将初始数据集(比如说有 m 个实例)划分为 k 个桶(每个桶有 m / k 个实例)来实现数据多样性。来自每个桶的数据被用来微调九头蛇头上的重量。这种方法也可以扩展到合并扩充数据，并有许多建设的可能性。几何变换或色彩空间操作等数据增强技术可用于创建额外的多样化数据桶，以微调九头蛇的头部。论文作者讨论了使用在线数据扩充节省内存的重要性，与离线扩充相反。离线扩充是指扩充数据，然后将每个修改的数据实例写入内存。

当以这种方式组合模型时，最后要考虑的是如何组合模型的预测。简单的解决方案可以是多数表决，其中输出来自每个头的最大类概率，或者是多数表决，其中来自每个头的 softmax 输出被求和，并且来自结果向量的最大值是最终预测。这被称为集合模型的解算法。他们有很多方法来发挥创意，测试不同的假设，例如为自己具有最佳分类性能的九头蛇头部分配更高的权重，或者搜索具有最少相关预测的头部子集。

感谢您的阅读，我认为这篇论文非常有趣，建议查看一下！模型的集合遭受较慢的推理时间，但对于较高的预测精度是一个有希望的解决方案。Hydra 架构是一种有趣的、名副其实的集成深度神经网络的方法。

我目前正致力于在喀拉斯实现九头蛇网络，并想分享我遇到的一个帮助我开始的细节。首先，您需要训练特征提取器的权重，并使用如下简单的方法保存它们:

model.save('HydraBody.h5')

然后，您需要将这些重量加载到每个头部，这可以通过命名 HydraBody 的每一层来实现，例如:

model.add(Conv2D(32, (3,3), name = 'Conv1')

命名每个层就是将基础权重加载到与保存的权重的架构不完全匹配的模型中的方式。

感谢阅读！

进入分析领域:从训练营到从事数据科学工作

原文：https://towardsdatascience.com/enter-analytics-from-boot-camp-to-working-in-data-science-8a5a6f563d7d?source=collection_archive---------15-----------------------

当在网上搜索新兵训练营时，似乎总是有很多不同的观点。他们有很多，有些比其他人更贵，他们都有稍微不同的侧重点，同时声称他们可以在短短 12 周内培养出分析师、全栈开发人员和/或数据科学家。以我的经验来看，教育往往可以归结为你得到你投入的东西，我参加数据可视化和分析训练营的经历也不例外。

为什么要给我一个新兵训练营？

我一直对计算机感兴趣，但从未想过计算机科学适合我。在成长的过程中，我从来没有觉得自己擅长数学，所以在学习数学的时候我并没有那么努力。高中的时候，我修了一门 Java 的课程和一门计算机网络基础的课程。他们都没有吸引我，所以我决定保持计算机的爱好，并最终在大学学习科学和技术通信。

当我找到大学毕业后的第一份工作，在一家软件公司做实习技术撰稿人时，我第一次尝到了计算机科学的真正含义。我爱上了一种我从未见过的语言:SQL。当我的实习结束时，因为我喜欢这家公司，我决定在他们的支持团队中工作。它给了我一个每天写作的机会，学习像 SQL 这样的技术技能，并了解软件开发生命周期。

在后勤部门爬了大约六年的梯子后，我觉得自己撞上了一堵墙。我已经变成了一个整天阅读和编写 SQL 的产品专家。虽然我有一些技能，但我觉得要进入下一个级别就要拿到我没有的证书。此外，我对分析数据的兴趣也开始高涨。例如，我痴迷于股票市场。

一天晚上在研究一些股票时，我看到一则广告，上面写着“在大学短短 24 周内学会数据分析……”因为它是通过我的母校大学宣传的，所以我决定点击链接并下载一本小册子。在做了更多的研究后，我了解到这是一个由一家名为 Trilogy 的公司组织的编码训练营，它专注于使用 VBA、Python 和 JavaScript 等编码语言教授数据可视化和分析技能。新兵训练营很贵，尽管我不喜欢高中时的编程，但我认为作为一个人我已经足够成熟了，可以再试一次。我报名参加了新兵训练营，希望它能带我走上数据分析之路！

启动新兵训练营

在研究我所从事的工作时，我读了很多关于人们不喜欢他们的老师的评论。在这方面，我非常幸运，有一个很棒的老师。他谦逊、耐心、知识渊博，并且善于保持课堂的趣味性。参加提供课堂教学的新兵训练营的好处之一是面对面地结识志同道合、积极上进的人。这让我结交了一些新朋友，因为我们都在努力重返学校，努力应对快节奏的内容。

我带着很少的 Python 经验参加了这个课程。我编写了几个脚本，从金融网站上收集一些股票数据，并使用 scikit——学习制作一些预测模型，但我的大部分技术技能是 SQL。在新兵训练营的前三分之一，我们已经学习了 Excel 和 VBA 的基础知识，并开始使用 python、API 和 JSON 数据。这是一个压倒性的内容，但它真的让我把自己的注意力和学习。我的空闲时间蒸发了，因为我把它用于家庭作业。

创建项目组合

新兵训练营的重点是创建一个能引起雇主兴趣的项目组合。它们大多是团队项目，这很好，因为它迫使我们制定合并代码的策略，并给了我们团队开发的经验。我们可以组建自己的小组，选择我们想要的任何主题(大部分)，然后去参加比赛。只要我们满足最低要求，我们几乎没有任何限制。

如果你是一个优秀的人，或者有任何语言的经验，那么这个项目就是一个展示自己的好机会。我的同学中有些人拥有高等学位，而这个班级的集体背景也很广泛。有相当多的人拥有博士或 MBA 学位，也有一些人一生中从未写过一行代码。因为很多人来自不同的领域，所以不乏有趣的项目主题。这些项目也给了我们一个练习表达技巧的机会，因为一旦完成，我们就必须向全班展示。

你可以在这里看到我的一些项目:

生成葡萄酒推荐
可视化世界杯数据
提取转换加载漫画数据和 MySQL
分析中西部谋杀数据
可视化期权交易

Generating Wine Recommendations

对新兵训练营的批评

我们在很短的时间内讨论了很多…事实上，几乎涉及了太多的话题。就在你开始适应并准备做更高级的事情时，他们改变了话题。在课堂之外，你想把事情带向什么方向，这真的取决于你自己。例如，我最关注 python，因为我想进入数据科学领域。

我真希望在课堂上更多地关注分析。尽管我们学习了一些基本的统计学和基本的分析技术，但还是有一大部分课程是关于 web 技术的，比如 HTML、CSS 和 JavaScript。我理解把它放在那里，这样我们可以学习编写交互式仪表板和网页来展示我们的项目，但它最终占了全班的三分之一。我并不介意，因为我在一家基于网络的软件开发公司工作，所以理解 JavaScript 适用于我的工作，但班上的其他人发现学习 HTML 和 CSS 没有什么价值。他们讨论基本网页设计的另一个原因是为了更容易进入网页抓取。

课程更侧重于可视化数据，而不是分析数据，如果这是你想学的，那可能会很好。我希望在我的作业上得到更多的反馈，这样我就可以衡量我的分析做得如何。我们涉及的唯一统计数据是高斯分布、标准差、方差分析、卡方检验、student-t、假设检验和其他一些统计函数，我不记得它们来自 SciPy Python 库。

如果你没有编码或 comp-sci 经验，我建议你先查阅一些在线资源来获取一些知识，因为这门课程的节奏真的很快。除了 Excel、VBA、Python 和 JavaScript，课程还涉及 SQL、R、tableau、机器学习和大数据。我离开新兵训练营时接触了各种各样的语言，但要记住所有的语言是不可能的，因为我们只是简单地介绍了一下。我不得不通过额外的在线课程来补充课堂学习，以加深对语言的理解。

新兵训练营后的生活

在新兵训练营之后，我觉得我完成了很多，并且能够发展编码技能的基础。它为我的职业发展打开了大门。完成认证几个月后，我在我的雇主的数据科学团队中找到了一份软件产品分析师的工作。现在我有机会与经验丰富的数据科学家、软件工程师、数据工程师和数据分析师一起工作。我对编码和数据科学产生了热情。除了编码和职业发展，我还在新兵训练营结交了一些新朋友，我仍然希望能不时见到他们。新兵训练营让我的生活变得更好，因为我拼命工作并保持积极的态度，即使我不得不牺牲很多时间并致力于学习新的东西。

My last day before starting my new career post boot camp

最后的想法

新兵训练营并不适合所有人，如果你正在考虑参加一个，一定要研究一下这个课程提供了什么。如果你认为你已经准备好做这份工作，他们绝对可以改变你的生活，让你走上一条新的道路。新兵训练营为我工作，但是我已经知道 SQL 并且已经对数据有热情。如果你还在观望，看看所有免费的 MOOCs 或在线内容，它们可以帮助你决定这些主题是否适合你。

如果你有兴趣看我在新兵训练营完成的一些任务和项目，可以看看我的 github。

[## bendgame -仓库

对游戏、金融、数据分析、技术写作和牛肉干感兴趣。阻止或报告 Python GNU 通用…

github.com](https://github.com/bendgame?tab=repositories)

谢谢大家！

如果你喜欢这个， 在 Medium 上关注我 获取更多
通过订阅 获得对我的内容的完全访问和帮助支持
我们来连线一下LinkedIn
用 Python 分析数据？查看我的 网站

—埃里克·克莱本

企业技术 101:五种实践如何让你的组织成为领导者或失败者

原文：https://towardsdatascience.com/enterprise-technology-101-how-five-practices-can-make-your-organization-a-leader-or-a-loser-4ef2d693fd32?source=collection_archive---------12-----------------------

为什么是我？

作为一名技术专家——领导定制软件解决方案的设计、开发和部署近 20 年——有许多有趣的事情，其中之一就是有机会通过观察试验和错误来进行经验性学习。这些机会的多样性增强了这种学习。

项目涉及许多类型的技术:客户端-服务器、应用程序开发、数据仓库、电子商务、在线分析处理、预测分析、人工智能、软件即服务(SaaS)、平台即服务(PaaS)和机器学习。类似地，项目跨越了许多行业和应用领域:电信、政府、电子商务、教育、金融、医疗保健、制药、生物医学和零售。

在很大程度上，它使我能够欣赏“灰胡子”的价值，这些人已经存在了很长时间，经历了很多，这是我自己的胡子变白的时机。在任何行业中，所有这些经验学习的一个关键应用价值是洞察什么有效、何时有效、为什么有效以及效果如何。我们的优势在于利用了大量职业经历的心理数据库。

当遇到某个人或某个组织谈论他们的信息技术需求时，这一点通常会发挥作用—他们有什么不能用的，他们希望他们有什么，等等。这是一个重要的话题，因为如果所做的决定没有提高他们的能力，或者但愿不会降低他们的能力，将会花费大量的成本和时间。还有机会成本。如果某一类型的系统被错误地开发或实现，在被替换之前，他们的竞争优势损失了多少时间和精力？

使这些分析更加难以正确的是软件制造商和实施者用数十亿美元营销决策者。随波逐流，选择架构、软件、企业系统、应用程序等，通常感觉更安全。每个人似乎都在选择。然后，如果出了差错，至少在“每个人”都推荐的防御中，数字是安全的。当然，真正的诀窍是第一次就做对。

五大修行

在看到如此多的技术选择和组合以及观察它们的实际价值和寿命的过程中，我们学到了一些重要的经验教训:

专注于任务——每种工具都有其用途，尽管这一点往往考虑不周。如果你了解任务概况，你可以将选择限制在那些用于这些目的的工具上，至少可以接近最佳选择。例如，高净值个人喜欢购买喷气式飞机——为了舒适、安全、自我(和主要的税收减免)。湾流喷气式飞机 (III，IV，V，V-SP)已经流行了几十年——通过它们的水平椭圆形窗户来揭示。这些飞机可搭载 9-14 名乘客从美国出发进行跨国旅行或海外旅行；然而，我的预测是，他们通常只是让一些人飞到更近的目的地。任务的错误工具。他们本来可以买一架更小(更快)的喷气式飞机，平均载 X 个人 Y 英里(如果他们在乎的话，还可以省钱)。

在软件中，这通常在应用程序和企业系统中发挥作用——最初是关系数据库(例如 MS Access、 Oracle 、MySQL 等)。)，然后是企业资源规划(ERP) ( SAP ， PeopleSoft ， J.D. Edwards 等。)，然后是客户关系管理(CRM) (Salesforce，Redtail 等)。).在这里，大多数套餐都有特色。在 ERP 中，它是行业——SAP 是制造业，PeopleSoft(被甲骨文收购前)是人力资源部，JD Edwards(也被甲骨文收购前)是会计部，等等。 Salesforce 顾名思义，是为那些试图跟踪他们的潜在客户和客户的销售人员准备的。

显而易见，为特定目的而设计的工具几乎总是会超越为另一个目的而改造的工具的性能。然而，由于这里解释的原因，这通常是企业或应用程序在信息技术中采用和使用的失误。

2.最大限度地减少定制 —一个常见的错误是，软件制造商的增长方法通常是采用特定于任务的应用程序，并试图将其应用于整个市场的每个人，这可能并确实会花费数百万美元和数年时间。抽象地说，大多数人都会同意这样的观点，即任何一种工具表面上可以满足每个人的需求，这违背了常识，属于“好得难以置信”的范畴。这在任何行业都是一种虚幻的希望。

然而，每年都有成千上万的组织犯这样的错误，这主要是由于无知和软件制造商经常使用的一种阴险的方法来构建和营销他们的产品——可定制化。他们的销售人员(根据我的经验，Salesforce 在这方面臭名昭著)会告诉你，“是的，这是一个通用平台；但是您或我们可以将它定制成您曾经梦想的一切。”他们非常希望您同意这样做，原因有三:(1)定制服务非常昂贵，并且通常比计划的时间长得多，这为他们提供了一个全新的、主要的、长期的“服务”收入来源(2)客户在软件上投资越多，他们就越有可能保留它更长时间，以试图证明其花费是合理的，并从他们的投资中获得回报，从而通过最小化替换它的动机来阻碍竞争；(3)定制会产生“供应商锁定”，因为组织变得依赖于构建的流程，除非他们能够替换该流程(定制越多，替换就越难)，否则无法改变，并且他们无法更换组件，因为它们都是绑定在一起的。

那么，为什么公司不识破这种以牺牲买方利益为代价来维护卖方利益的营销策略呢？

3.雇用或替换 缺失/错误的人才 —当您遇到组织投资了不符合其使命的工具，或过度定制通用工具，以至于供应商将他们锁定在昂贵的环境中时，对话可以从询问他们的首席技术官(CTO)在这些决策背后的理论开始。最常见的回答是，“我们没有/以前没有 CTO。”没错。第二个常见的问题是:“那么，当您的 IT 人员每三年对软件更新换代时的需求和选项进行独立客观的分析时，他们是如何看待这个决定的？”最常见的第二个答案是:“我们的 IT 人员从来没有做过 36 个月的需求/工具评估，以了解我们的新需求或市场如何变化”，与“他们是 XYZ 开发商，所以他们总是建议我们使用 XYZ，否则他们就失业了。”第三个常见问题是“嗯，一定有人做过总拥有成本(TCO)评估，了解每年许可 XYZ、派每个人参加所有活动以及保留所有定制人员的成本，对吗？”你开始明白了。最常见的回答是:“不会；据我所知，从来没有人做过 TCO，我们可能甚至不知道今天决策的总成本。”

4.使 IT 能力民主化&数据—IT 用户倾向于以三种方式使用它:(A)报告；分析；以及(C)功能。除了这三种消费信息的方式之外，很难找到太多最终用户的需求——阅读信息、分析信息或操纵信息来执行任务。过去，人们需要满屋子的程序员来完成这项工作；然而，今天，市场上充斥着专门的拖放工具，几乎任何人都可以通过在线课程或经验学习来做这些事情。最终用户知道他们的需求，他们经常改变或发展。因此，今天，允许最终用户社区、部门、分部等通常是最有意义的。，只需雇用一名数据演示人员专门负责这项任务，并为他们提供数据。如果一个部门不能证明一个全职人员的合理性，那么有更多临时需求的部门可以简单地分担某人的工作。这消除了总是令人沮丧、耗时且昂贵的记录需求的过程，以及每次用户需要新的报告或分析时长达六个月的构建或开发周期。

满足信息和分析需求的一个非常有效和有价值的方法是使用像 Tableau 这样的产品来构建动态(而不是静态)的仪表板。一旦构建完成(同样是拖放式的，这样即使有几十个部分也可以在几周内完成)，系统会自我更新最终用户想要知道的所有关键数字，跟踪目标进展、地理信息、质量、增长速度等。此外，他们可以移动，以便终端用户想要的所有信息和分析在他们的智能手机或平板电脑上随时可用。快速、信息丰富、易于构建和维护且成本低廉。

最终用户消费数据的第三种方式——功能——需要更多的投资，但如果做得好，比许可、定制和维护大型企业系统要容易得多，也便宜得多。几乎每个领域都有一个专业应用程序，可以执行这些专业人员需要的所有功能——“开箱即用”(好吧，我通过回忆软件还装在盒子里的时候来与自己约会)。挑一个领域:电信、网络安全、投资管理、财务规划、零售管理、资金筹集、录取等。他们都有几家公司提供专用解决方案，他们通常只需要一个数据源。因为定制专业应用程序的需要或理由较少，所以维护费用较低(例如，不需要给昂贵的开发人员发工资，不需要参加开发人员会议，等等。).因为他们为更小的团队服务，所以也需要更少的席位或副本来获得许可——这是第二个成本节约。但最大的节约是机会成本。这些专业公司每个季度都在创新新的特性和功能集，以成为其狭窄领域中最具竞争力的产品——与拥有大型定制企业应用程序的组织相反，这些组织试图永远(通常无法)跟上创新专家的步伐，然后用新的东西更新旧的通用系统。

信息技术能力的民主化也是该行业可能的发展方向。20 世纪 90 年代是客户端-服务器、多对一的私有结构。2000 年代是互联网商务和内部网的开端，是安全的组织范围的互联网私有区域，而不是局域网(LAN)。2010 年是软件即服务(SaaS)时代，应用程序从安全的互联网或内部网网站和大数据中流出。21 世纪 20 年代将开始是平台即服务(PaaS)，其中组织通过从集中商店下载应用程序来创建自己的生态系统，这很可能演变为功能即服务(FaaS)，其中最终用户可以下载一个迷你应用程序，该应用程序做一件事来制作自己的特性和功能集。大型软件应用终结的开始就在这里。这是技术能力的终极民主化，我们很可能在 2030 年看到它无处不在。

5.一切都是关于数据——2017 年，一份不亚于的权威出版物《经济学家认为“世界上最有价值的资源不再是石油，而是数据”(The Economist，2017)。最明智地使用数据的组织将拥有巨大的竞争优势，而要最明智地使用数据，就意味着您必须拥有数据。一个简单的陈述经常不被遵守。

如今，获取数据流、存储在中央存储库中(如数据仓库)和开源数据库中(如 MySQL )相对容易，并且可以分析大量信息并从中得出推论和结论。在过去的几十年里，数据存储和处理能力是稀缺的，因此也是昂贵的。今天，它们不再稀缺，因此成本极低。一个技术支持人员的成本比一个技术支持人员的成本低，这是技术行业中报酬相对较低的技能组合，一个组织可以存储一个世纪以来与他们的组织联系过的每个人的每条可获取的信息。此外，基础设施即服务(IaaS)提供商，如亚马逊网络服务、谷歌云或微软 Azure 可以实时扩展容量和数据库，并提供只有情报机构才能超越的冗余和安全水平(事实上，中情局也向 AWS 支付了 6 亿美元来存储他们的数据)。对于绝大多数组织来说，现场服务器存储和维护的时代早已过去。

成千上万的表可以存储这些“平面文件”(原始数据)，仪表板和专业部门应用程序接收和使用这些文件。这样做的软件成本很低，维护只需要一两个数据库管理员，这在技术层次中也是低成本的。

这种摄取数据流的能力以低廉的价格存储并提供给用户进行跟踪、分析和处理，以满足他们的需求，这也是基础设施和数据科学的先决条件，数据科学是技术、人工智能和统计的交叉，支持预测分析和机器学习。技术细节很复杂，但自罗马以来，组织的领导者很可能已经理解并渴望数据科学能够预测性地回答关键问题，如:(1)您是否想知道客户为什么购买您的产品/服务，以及这些因素在多大程度上影响了他们的决策？(2)您是否希望将您的所有客户或潜在客户根据他们的购买行为划分为不同的群体，以了解如何精心策划沟通，以及如何最大限度地提高他们做出回应的可能性？(3)您是否希望能够通过了解未来几年您可能会有多少客户、他们会购买什么以及您可能会有多少收入和利润来进行规划？如果你收集了原始数据，并使之可用，那么数据科学很容易得出所有这些答案。

结论

所以，谁在乎？在我职业生涯的大部分时间里，我也从事过一般管理工作，尽管是在技术领域，但在我有限的时间和注意力中，无处不在的问题总是:我需要处理这个问题吗？不管是好是坏，答案都是肯定的。为什么？因为不知道或不遵循这样的实践可能会使组织每年不必要地花费数百万美元或更多，导致他们软化并失去他们的竞争优势或优势，并由于期望结果而没有必要的工具来实现它们而使他们的员工士气低落。相反，通过遵循这些实践，组织每年可能会节省数百万美元甚至更多——即使是在相对较小的组织中——并将这些资源重新投资于新的人才和竞争优势，引领他们的市场，并使他们努力吸引和留住的人才对每天来工作感到兴奋。你更喜欢哪种情况？

参考

经济学人。(2017 年 5 月 6 日)。世界上最有价值的资源不再是石油，而是数据。摘自经济学人:https://www . Economist . com/leaders/2017/05/06/The-worlds-most-valued-resource-is-not-alone-but-data

使用主成分分析和核主成分分析的实体嵌入

原文：https://towardsdatascience.com/entity-embedding-using-pca-and-kernel-pca-798b8b2e8c2f?source=collection_archive---------25-----------------------

使用 scikit-learn 的无监督实体嵌入

Photo by Zara Walker on Unsplash

在关于这个主题的上一篇文章中，我们介绍了一种基于分类特征值的相似性来学习分类特征嵌入的方法。提醒你一下，我们要解决的问题是，很难找到一个好的分类特征变量到向量空间的映射(或嵌入)。常用的 1-hot 编码方法会产生许多额外的列，而分类特征对模型的影响太大，降低了模型的泛化能力。另一方面，顺序编码不会增加列数，但是如果选择不当，会降低数据的线性可分性，并损害模型性能。

理想的分类特征嵌入将避免创建太多的新列，但是从另一方面保持大多数数据的线性可分性。一种方法是在处理表格数据的神经网络中使用实体嵌入层。在之前的故事中，我们提出使用谱图理论来寻找分类特征的最佳嵌入。然而，该方法仅使用类别相似性，而不使用类别的概率分布。但是根据我们的经验，我们知道类别的概率分布在寻找最佳嵌入时起着非常重要的作用。例如，如果几个类别只有很少的记录，将它们绑定到单个值“other”中是有意义的，因为这将减少列的数量，并且不会对模型性能造成太大影响。

自动化这个决定的一个方法是使用 PCA 算法，或者类似的算法 MCA 。想法是在 1-hot 编码完成后使用 PCA(使用 MCA 需要额外的转换)。选择最高特征值向量，我们可以在低维向量空间中表示类别。主成分分析会将高频类别放得很远，但会将低频类别放得很近。让我们在人工例子上演示一下。和以前一样，我们考虑一周中的某一天特性，其中 0 表示星期一，6 表示星期日。假设大部分数据在周末出现，那么我们将创建一个合成数据集来演示我们的概念。

array([ 23,  21,  23,  19,  20, 456, 438])

我们看到周六和周日的数据比平日多得多。我们将在这个分类变量上拟合 PCA，但是只留下两个具有最高特征值的分量(即那些捕获最大方差的分量)

让我们绘制这些组件，看看这些类别是如何映射到二维向量空间的:

我们可以看到，周日和周六的向量彼此相距很远，但也与一周中的其他日子相距很远(周一和周四的向量相同，因此它们在图中标记为一个点)。

我们的方法是对每个分类变量进行 PCA 分析，而不是对整个数据集。如果分类变量是相对独立的，这种策略是合理的(在特征工程中我们应该总是做依赖性测试！).如果两个分类变量之间有很强的相关性，那么我们就可以把这些变量的联合概率分布表示为两个分类分布的乘积。在这种情况下，我们将不得不对两个类别的组合进行 1-hot 编码和 PCA，如果有许多组合只有很少的观察值或没有观察值，这将提供很差的结果。

核主成分分析

这里我们将发展我们在前面的工作中提出的思想，即使用类别相似度函数来影响类别嵌入。为此，我们可以使用一种众所周知的方法，称为核 PCA ，核函数将被表示为对称矩阵。请注意，内核矩阵必须是正定义的。

与之前的笔记本类似，让我们将周六和周日与工作日区分开来，看看这是如何影响类别嵌入的:

array([[1\. , 0.9, 0.8, 0.7, 0.5, 0.1, 0.3],
       [0.9, 1\. , 0.9, 0.8, 0.5, 0.1, 0.2],
       [0.8, 0.9, 1\. , 0.9, 0.5, 0.1, 0.2],
       [0.7, 0.8, 0.9, 1\. , 0.6, 0.1, 0.2],
       [0.5, 0.5, 0.5, 0.6, 1\. , 0.7, 0.5],
       [0.1, 0.1, 0.1, 0.1, 0.7, 1\. , 0.8],
       [0.3, 0.2, 0.2, 0.2, 0.5, 0.8, 1\. ]])

array([[ 1.03305649, -0.19636025],
       [ 1.05001289, -0.38425859],
       [ 1.0480194 , -0.38846218],
       [ 1.01195609, -0.38461521],
       [ 0.29211243, -0.54331321],
       [-0.25333403, -0.22797924],
       [ 0.04688558,  0.32797451]])

我们在这里可以看到，除了星期二和星期三之外，工作日的间隔更远，这两天的值几乎相同(在图上用一个点表示)。

结论

我们看到核分类嵌入可以通过使用 PCA 而不是拉普拉斯公式来改进。仅仅对单个分类变量使用 PCA 是非常有用的，因为它允许将类别映射到低维向量空间，而不牺牲线性可分性。当在类别相似性的概念上增强时，应用核 PCA 来捕获概率分布和类别的相似性变得可能，这甚至进一步提高了线性可分性。

有几种方法来定义核函数。如果未知先验，则可以通过测量给定类别值的数据概率分布之间的 Wasserstein 距离从数据中导出，然后，例如，取负指数函数以得到正定义的矩阵:

使用 t-SNE 的实体嵌入

原文：https://towardsdatascience.com/entity-embedding-using-t-sne-973cb5c730d7?source=collection_archive---------17-----------------------

众所周知的降维工具可以用于分类特征嵌入。

Photo by Leon Koye on Unsplash

我们已经讨论了一些嵌入分类特征的可能方法:核 PCA 和光谱编码。这种嵌入的目标是将分类特征映射到低维空间中的向量。与 1-hot 编码相比，这种映射的优点是大大减少了过拟合。然而，如果嵌入选择不正确，我们可能会丢失信息并使学习更加困难。为了增加嵌入的质量，我们使用类别相似度信息(我们可以设定先验或通过计算条件概率分布的相似度)。核 PCA 方法也使用分类变量的概率分布，而谱编码不使用。为了完整性，我们也将使用 t-SNE 方法，我们可以讨论它的优点和缺点。

t-SNE 代表t-分布式随机邻居嵌入，最初是为了高维数据的可视化而提出的。与 PCA 相反，它是一种非线性方法，其目标是保持数据点之间的相似性。它引入了从原始数据 x 到低维向量 y 的非线性转换，并使用学生 t 分布对数据点之间的相似性进行建模:

Credit: Wikipedia

点集 y 通过最小化分布 Q 与原始分布 P 的 KL 散度来找到:

Credit: Wikipedia

最小化可以使用梯度下降来完成。

为了演示该方法如何工作，我们将使用只有一个分类变量星期几的合成数据集，0 表示星期一，6 表示星期日:

array([ 23,  19,  15,  19,  22, 429, 473])

在这里，我们特意添加了更多周六和周日的数据，以了解 t-SNE 将如何考虑原始数据的概率分布。提醒你一下，拉普拉斯方法不受源数据概率分布的影响，而主成分分析和核主成分分析则受影响。

内核函数与前面示例中的相同

array([[1\. , 0.9, 0.8, 0.7, 0.5, 0.1, 0.3],
       [0.9, 1\. , 0.9, 0.8, 0.5, 0.1, 0.2],
       [0.8, 0.9, 1\. , 0.9, 0.5, 0.1, 0.2],
       [0.7, 0.8, 0.9, 1\. , 0.6, 0.1, 0.2],
       [0.5, 0.5, 0.5, 0.6, 1\. , 0.7, 0.5],
       [0.1, 0.1, 0.1, 0.1, 0.7, 1\. , 0.8],
       [0.3, 0.2, 0.2, 0.2, 0.5, 0.8, 1\. ]])

t-SNE 的 Scikit-learn 实现实际上希望我提供度量函数，所以我们将内核矩阵转换回距离矩阵

array([[-0\.        ,  0.21072103,  0.4462871 ,  0.71334989,  1.38629436,  4.60517019,  2.40794561],
       [ 0.21072103, -0\.        ,  0.21072103,  0.4462871 ,  1.38629436,  4.60517019,  3.21887582],
       [ 0.4462871 ,  0.21072103, -0\.        ,  0.21072103,  1.38629436,  4.60517019,  3.21887582],
       [ 0.71334989,  0.4462871 ,  0.21072103, -0\.        ,  1.02165125,  4.60517019,  3.21887582],
       [ 1.38629436,  1.38629436,  1.38629436,  1.02165125, -0\.        ,  0.71334989,  1.38629436],
       [ 4.60517019,  4.60517019,  4.60517019,  4.60517019,  0.71334989, -0\.        ,  0.4462871 ],
       [ 2.40794561,  3.21887582,  3.21887582,  3.21887582,  1.38629436,  0.4462871 , -0\.        ]])

这里的适马是一个需要调整的重要超参数。t-SNE 方法的另一个重要的超参数是困惑分数，但在我们的情况下，它可以保留为默认值或设置为 sigma。

在第一个例子中，我们使用了没有核的 t-SNE，这意味着一周中所有日子之间的距离是 1。这就是你仅仅使用 1-hot 编码所得到的结果。请注意，嵌入似乎是随机分布的，这与 PCA 不同，PCA 即使在没有核的情况下也使用初始数据概率分布来嵌入数据，这样可以最大化它们的线性可分性。让我们看看如果使用核函数会得到什么结果:

这里的结果更有意义。星期一到星期四被分组在一起以保持它们的相似性。星期五、星期六和星期天彼此相距甚远，与其他日子也相距甚远。有趣的是，星期五比星期六更接近星期天。

结论和讨论

t-SNE 是类别嵌入的选项之一。通常，t-SNE 不会进行概化(因为它将无法绘制未知数据)，但对于分类特征来说，这并不重要，因为新数据将具有现有类别之一。一个更大的问题是，如果没有内核，它将无法工作，这与 PCA 相反，即使没有给定内核，PCA 也会给出合理的结果。就像核 PCA 一样，它使用概率分布来映射数据，即使是以不同的方式。如果核 PCA 试图在结果向量空间中实现平滑，t-SNE 更关心保持相似性。这可能会指导您决定哪种方法更适合您的模型。

你可以在我的 github 库中找到这个故事的代码。

熵、交叉熵、KL 散度和二元交叉熵

原文：https://towardsdatascience.com/entropy-cross-entropy-kl-divergence-binary-cross-entropy-cb8f72e72e65?source=collection_archive---------5-----------------------

基于熵的损失函数的基础

熵

对我来说,(香农)熵的定义乍一看并不是直觉。必须抽象一点才能理解它的意思。这里有一个解释流程，可能对你们中的一些人有用。

想象一个抛硬币机，它抛出一枚硬币，并发出一个信号，指示抛硬币的结果。对于一个公平的硬币，有两个概率相等的 0.5 的可能结果。机器需要多少比特的信息来传达结果？现在是 1 点。正面说 0，反面说 1。换句话说，我们需要多少个二元答案(是/否)问题来决定结果？是 1，对“是正面吗？”会告诉我们结果是什么。

Figure 1: Fair Coin Toss Example

想象扔两枚硬币。四种可能的结果(hh，ht，th，tt ),等概率 0.25。在这种情况下，我们需要两位或二进制答案问题(00，01，10，11)来了解发生了什么。对于三个硬币，它将是 3，以此类推。

Figure 2: Two Coin Toss Example

那么这个“位数”是多少呢？这是传递掷硬币结果所需的最少位数。有一枚硬币的投币机需要向接收器发送一位(0 或 1)来传达给定的投币输出是什么。类似地，两台和三台投币机必须分别发送 2 位和 3 位来传递输出。使用“对数”的定义，这个数也是可能结果的二进制对数。即，例如:2 的 3 次方= 8 => 8 个可能的结果需要 3 个二进制位来表示结果。这也是事件的“熵”。

Figure 3: Is Entropy the binary log of count of possible outcomes?

那么熵是我们交流结果所需的最小位数吗？不完全是，但这是个不错的开始。想象一下这个场景:如果掷硬币的结果不一样，会怎么样？如果我们使用硬币，它总是落在头上呢？即正面的概率是 1，反面的概率是 0。嗯，那机器总会发一个“1”。从那个信号中我们什么也学不到。

如果在两次抛硬币的例子中，概率不相等呢？如下图所示，我们可以想出一个编码方案来表示输出，这样对于不同的结果它是不同的。我们不能真正应用“可能结果的二进制对数”，因为仍然有四种可能的结果，但它的概率并不相等，所以“2 位”并不是普遍需要的。

Figure 4: Four not-equally-likely Possibilities Example

这里我们需要调整一下我们定义熵的方式。我们真正感兴趣的，不是我们需要多少比特的数据来交流结果，而是“我们真正从交流的内容中学到了多少信息”，而不考虑实际用于交流的物理比特。

换句话说，我们希望用熵来表示结果中有多少“信息内容”——不管它是如何传达给我们的。我们希望它是对信息内容的定量测量，也就是与事件相关的不确定性。它将是“0”，意味着“我什么也没学到”或“我对结果完全确定”，对于一个有偏见的硬币来说，它总是正面朝上。“1”代表掷硬币的公平结果，意味着“我学到了很多”或“我最不确定”掷硬币的公平结果，因为它可能是正面或反面。这种不确定性或信息内容是由熵来衡量的。

虽然在某种程度上，这可能会给我们传达结果所需的比特数带来理论上的限制，但我们不要以此作为定义的基础。比特是完整的——没有“半个比特”。但是我们对熵的最新定义是对传播中“新闻”的一种度量。与面积、长度、重量等其他测量方法非常相似。，它是连续的，可以是任何数或分数。这就是熵的性质#1 。

我们将回到图 1 和图 2 的例子来介绍这个度量的另一个属性。当我们处理包含同样可能结果的事件时，度量应该随着可能结果的数量而增加。图 1 具有“1”位熵，图 2 具有“2”位熵，依此类推。这是熵的性质#2 。

旁注:这种可能结果的数量为 2 的幂的同等概率实例实际上是我们可以应用“我学到了什么，即信息熵”=“交流结果所需的位数”的理论极限的地方。在许多其他情况下，这种“最短代码”只是一种理论上的限制，实际上，可能需要比消息中的信息更多的比特来传达事件的结果。

我在边注中说了“许多其他情况”，因为除了这样的场景之外，在可能结果的数量不是 2 的幂且概率不等的场景中，也有可能实现理论上的“最短代码”。在有可能对结果进行分组的场景中，分组是均匀分布的，我们可以实现这一点。看看下面这个有三种结果的例子。

Figure 5: Three not-equally-likely Possibilities Example

回到确定我们需要多少个二元问题来导出结果，首先，我们可以问“结果是 x1 吗？”—这类似于将 x1 归入一个组，将 x2、x3 归入另一个组。这两个组成为结果的概率相等(x1 的概率= 50% = x2 和 x3 的概率之和= 33.33% + 16.66%)。如果答案是“不是”，那么我们可以问“是 x2 吗？就这样，我们需要问的决定结果的最大问题是 2。

这个“如果结果是 x1，我只需要一个问题，否则我需要问最多两个问题”的等价位表示在表格图示中提供。下面的图 6 提供了同样的二叉树视图。与前面的例子相反，在这个非等概率例子中，您可能会注意到，表示结果所需的位数因结果而异。如果我们希望提出更少的问题或更少的问题来表示这种来源的结果，那么使用第一位或第一个问题来确定最可能的结果是否已经发生是有意义的。

这将我们引向熵的第三个属性。如果一个选择可以分解为两个连续的选择，即在上面的例子中，在 x1，x2，x3 之间的选择被分解为在(x1)和(x2，x3)之间的选择，那么原始熵应该是各组的各个熵的加权和。换句话说，二叉树表示的节点处的总期望熵=来自两个子节点的熵的加权和，其中权重是特定子节点为真的概率。

Figure 6: From “[A Mathematical Theory of Communication](http://A Mathematical Theory of Communication)” by C. E. Shannon

那么，我们如何定义这个衡量标准呢？让我们回到“可能结果的二元对数”的定义——我们看到它不适用于非等概率结果。如果你想一想，在一个事件中，具有同等可能性结果的可能结果的数量与概率的倒数相同。即在掷硬币的游戏中，可能结果的数量= 2 = 1/0.5。其中 0.5 是结果的概率。对于两次抛硬币的例子，可能结果的数量= 4 = 1/0.25。因此，也许定义它的正确方式不是“可能结果的二进制对数”，而是“1/p 的二进制对数”，其中“p”是给定结果的概率。虽然这是一个结果，事件的香农熵可以描述为事件的预期信息内容。

Figure 7: From “[A Mathematical Theory of Communication](http://A Mathematical Theory of Communication)” by C. E. Shannon

使用这个定义，我们到目前为止看到的不同例子的信息内容和预期熵在下面的图 8 和图 9 的表格中给出。在每一个例子中，我们可以注意到这三个特性都得到了满足。该度量是连续的，单调增加(比较单次和两次公平抛硬币的例子),根据期望值的定义，它是单个熵的加权和。

Figure 8: Single Coin Examples with Shannon Entropy defined

Figure 9: Four Possibilities Examples with Shannon Entropy defined

让我们更仔细地看看这个不公平抛硬币的例子。您可能会注意到，与磁头相关的信息内容将是(1/0.9) = 0.15 位的二进制对数。与之相比，普通硬币有 50%的正面概率，二进制对数为(1/0.5) = 1 位。有偏向的硬币具有较少的与正面相关的信息，因为它 90%的时候是正面，即几乎总是正面。有了这样一枚硬币，得到一条尾巴要比得到一个头有新闻价值得多。这就是为什么与尾部相关的信息是(1/0.1) = 3.32 位的二进制对数，比与头部相关的信息多得多。

换句话说，结果越罕见，我们需要问的问题就越多，以确定它是否发生过。“小行星在我们的太阳系吗？”也许是我们在探索更深、更难的问题来规划它的进程之前需要回答的第一个问题。在我们确认极不可能发生的与地球相撞的情况发生之前，我们可能会问更多的问题。这就是说，更不寻常的结果或具有很多不确定性的场景需要学习更多与该结果相关的信息。使用“最少比特数来表示”只是“信息发送者”表达同一事物的一种非常具体的方式。熵是与事件相关的信息价值的量度。

下面是概率为 p 和(1-p)的两种可能性的熵图，这将有助于注意到一些有趣的观察结果，重申我们在上面看到的。我们可以注意到，在概率为 1 和 0 的两种极端情况下，H 都是 0。在这两种情况下，我们都没有真正学到任何东西。当可能性相等时，它是最高的。这也是有意义的，因为在这种情况下，不涉及偏见，事情完全是随机的，任何事情都可能发生。

Figure 10: From “[A Mathematical Theory of Communication](http://A Mathematical Theory of Communication)” by C. E. Shannon

交叉熵和 KL 散度

让我们回头看看图 9 中的例子。想象一下，我们正计划对“掷两枚硬币”事件的结果的交流进行建模。假设我们开始时假设这些硬币是公平的，因此我们预测所有结果的概率相等，因此开始使用两位来表示结果，如图 9 的左侧表格所示(都是 0.25)。一段时间后，我们观察到这些不是真正公平的硬币，真实的概率分布如图 9 的右侧表格所示(0.5，0.25，0.125，0.125)。

Figure 9: Four Possibilities Examples with Shannon Entropy defined

现在，很明显我们在这里效率不高。这两种分布的期望熵是不同的，1.75 对 2，不同结果的个体信息内容是不同的，并且显然我们的编码方案可以更好。例如，我们不需要两个比特来表示概率为 0.5 的第一个结果，一个比特就可以了。

我们如何知道这里的低效率有多高？这正是交叉熵和 KL 散度帮助我们做的。交叉熵是使用针对预测分布 q 优化的编码方案时，真实分布 P 下的预期熵。图 10 中的表格演示了交叉熵的计算方法。结果的信息内容(aka，用于该结果的编码方案)基于 Q，但是真实分布 P 被用作计算期望熵的权重。这是分布 P，q 的交叉熵，kull back–lei bler 散度是 PQ 的交叉熵 H 和 P 的真实熵 H 之差。

Figure 11: Cross Entropy and KL Divergence

(P||Q)的 KL 给出了当使用针对 Q 优化的编码方案来表示真实分布 P 时所需的平均额外比特。换句话说，如果我们开始使用真实分布 P 而不是之前的分布 Q 来表示相同事件，这将是我们将实现的信息增益。如果 P 是预测的分布，并且如果为 P 优化的编码方案被用来表示真实的分布 q，那么这当然是不同的

仔细观察公式和直觉，KL 散度，尽管它是两个分布之间差异的度量，但它不是真正的度量，即 KL (P||Q) <> KL for (Q||P)。然而，很容易看出，随着 Q 越来越接近 P，这种差异会减小，当 P=Q 时，这种差异将为 0，如图 12 所示。

Figure 12: Moving Q towards P

这就是我们在训练神经网络时使用的损失函数。当我们遇到图像分类问题时，训练数据和相应的正确标签代表 P，即真实分布。NN 预测是我们的估计 q。这种单标签分类中涉及的数学相对更简单，因为对于给定的标签，P 将是 1，而对于其他标签，P 将是 0。

Figure 13: Loss Function in Image Classification

将事情写成一个等式(并应用幂法则得到-1):

Figure 14: Cross Entropy

二元交叉熵

在多类分类问题中，“n”代表类的数量。在图 13 的例子中，这是 4。在二进制分类问题中，也就是说，就像掷硬币一样，类别/输出的数量是 2，并且任何一个都应该是正确的，并且一个的概率是(1-另一个的概率)，我们可以将它写如下:

Figure 15: Binary Classification

我们也可以将这种二进制交叉熵表示用于多标签分类问题。在图 13 所示的示例中，这是一个多类分类问题，其中只有输出可能为真，即只有一个标签可以标记到图像。在我们可以有多个标签与图像相关联的情况下，即每个标签或其自身输出的概率可以是 0 到 1 之间的任何值，并且它们彼此独立，我们仍然可以利用交叉熵来弥补我们的损失。每个标签分类本身是一个独立的二进制交叉熵问题，全局误差可以是所有标签的预测概率上的二进制交叉熵之和。

从这一点开始，sigmoid vs softmax 在多分类 vs 多标签问题中的适当用法应该变得更加明显。虽然有点啰嗦，但希望这篇文章能对这些函数的工作原理有所澄清。

熵、电梯推销和让团队工作！

原文：https://towardsdatascience.com/entropy-elevator-pitch-and-getting-teams-to-work-e3099679b74f?source=collection_archive---------17-----------------------

Image credits

在我们公司进行的一轮有趣的面试中，有一轮是文化面试——通常我们有一组精选的“文化”面试官来做。我知道大多数公司都会进行某种形式的人力资源调查，但这一调查之所以突出，不仅是因为我们对我们公司列出的每一种文化价值观都进行了大量的实际调查，以了解候选人与这些价值观的一致程度，还因为有不可忽视的拒绝率？！因此，在一轮文化面试中，文化面试官对一位在前几轮面试中表现出色的候选人并不热心，面试官给出的理由是，这位候选人到处都是，特别是在他为什么要加入我们公司的问题上。

一开始，这似乎是最模糊、最不客观的说法，尤其是在被委以评估候选人的客观任务时。所以，作为一个文化轮采访者，有这样的评价(！)或者有比看上去更多的东西——在整个陈述中几乎有一些潜在的客观性！不过现在我想把你们的注意力转移到科学中最有趣的概念之一——熵，尽管在这个时间点上我可能会像“一样到处跑。**

All over the place?! (Photo Credits)

简单地说，熵是衡量一个系统随机程度的指标。或者系统中的不确定性。在你决定这篇文章是为统计学家还是物理学家写的之前，让我用简单的术语快速解释一下熵的含义，以及为什么它与评估一轮文化面试这样模糊的事情有联系！

Figure 1

想象一个容器中有气体分子，用网格线标出，如图 1 所示。想象一下如果气体分子被画出来，这个图形会是什么样子。

Figure 2

Figure 3

这张图更接近图 2 还是图 3？

我觉得你脑海中的画面更有可能是图 3 而不是图 2。现在，答案不是因为你知道气体分子的热力学，而是因为在没有先验信息的情况下，你的大脑可能无法确定特定的模式，只会想象最不确定的状态，如图 3 所示。

熵抓住了这一点，克劳德·香农提出了以下有趣的公式，他是杂耍家、独轮车手和数学家。

H = -𝛴pᵢ * log(pᵢ)

注意，在本文中，pᵢ是气体分子出现在特定网格单元 I 中的概率

如果你费心去做数学计算，图 3 的≅3.14，因为任何气体分子成为任何网格单元的概率是相等的(⅑).而对于图 2，h . ≅0.57(因为两个过度拥挤的网格单元构成了它们之间几乎 70%的气体分子)。

显而易见的是，熵越大，随机性就越大。或者更大的不确定性。在没有先验信息情况下，人们会假设任何系统都具有极大的随机性。这里面没有什么有趣的东西。所以熵也可以被解释为一个系统有多无趣的度量——熵越大，事情看起来就越无聊！

在信息论世界中，熵还有另一个定义，正如你很快就会意识到的，这个公式正是互联网的核心。 H 表示表示系统所需的最小位数(二进制数)。因此，如果一个系统是完全随机的，就要花很长的描述来解释这个系统。因此，图 2 的描述比图 3 简洁了近 5 倍。正如你在图 3 中看到的，没有太多的目的，看起来是“随机”的。另一方面，图 2 似乎有某种目的——如果我们试图解释，分子似乎越来越接近底部网格中的原点。

因此，熵似乎是一个系统中目的(或实际上缺乏目的)的度量。暂停一会儿，试着解释你现在追求的东西的目的——它可能是你正在做的一份工作，一项活动，甚至是你正在经营的一家公司。

‘Elevator Pitch’ (Image credits)

你是用一篇长文，还是一段，还是一行来回答的？你有没有发现自己“到处跑”？如果你能用一句话解释清楚，那可能就是人们所说的“电梯营销”。祝贺你——你已经能够实现你所做的相当低的熵。而且熵越低，目的性越大，越有意思。也许这就是为什么创业界的投资者不断向你索要电梯推介的原因！或许，当这些点连接起来时，候选人不幸地得到了关于文化问题的最大熵答案？！现在看起来，评估熵实际上是一种非常客观的方法来处理这些主观的任务。

最大熵原理指出，一个系统最有可能处于最不确定的状态——即最大熵状态，除非有给定的约束。假设这个系统是你试图建立的组织或者你领导或工作的团队。你认为团队/组织中的个人表现如何？在这个节骨眼上，你想到的是图 3 还是图 2 或者别的什么？

这就是你的线索——描绘理想状态，努力减少熵。如果你的团队是一致的，那么熵就会减少，不确定性就会减少。现在的诀窍是在团队动态、个人的冲突动机、市场因素等等中做到这一点。但是最小化熵确实减少了不确定性，并且完成了更多的工作。所以如果你是团队的一员，你的工作不仅仅是做好你的工作，还要参与降低你团队的整体熵。事实上，我会更进一步说，在一个组织中减少熵的人实际上是领导者——他们的角色和责任是调整、澄清混乱和简化系统状态。

People all over the place => ‘High’ Entropy? (Image credits)

令人惊讶的是，我们意识到关键似乎又在于简化。顺便说一下，在热力学领域，熵被定义为系统中不能用来做功的能量的度量——所以作为领导者和团队成员，你在这方面的工作被砍掉了。顺便说一句，在团队和业务的背景下，有一些统计技术可以估计熵，我就不赘述了(为了最小化本文本身的熵，但是如果你有兴趣，可以 ping 我！).

最后，简洁和简单中不仅有一点(装饰性的)优雅，有时还有更大的目的性、确定性和产出。熵也是这么说的！

PS:出于对数学的好奇，对 Shannon 是如何偶然发现这个概念的好奇，这里有一个伟大的线程在同一个线程中结束，我花了一些时间来理解这个公式的推导。

熵:决策树如何做决策

原文：https://towardsdatascience.com/entropy-how-decision-trees-make-decisions-2946b9c18c8?source=collection_archive---------0-----------------------

非常有效的机器学习算法背后的简单逻辑和数学

你是一名训练中的数据科学家。从编写第一行 Python 或 R 代码开始，您已经走过了漫长的道路。你对 Scikit 了如指掌。你现在花在卡格尔身上的时间比脸书还多。您对构建令人敬畏的随机森林和其他基于树的集合模型并不陌生，它们可以完成这项工作。然而，如果不彻底，你什么都不是。你想要更深入地挖掘和理解流行的机器学习模型背后的一些错综复杂的东西和概念。我也是。

在这篇博文中，我将介绍熵的概念，作为统计学中的一个一般主题，这将允许我进一步介绍信息增益的概念，并随后解释为什么这两个基本概念形成了决策树如何基于我们提供给它们的数据来构建自己的基础。

没错。那我们继续吧。

熵是什么？用最通俗的术语来说，熵只不过是无序的度量。(你也可以把它当成纯度的衡量标准。你会明白的。我喜欢无序，因为它听起来更酷。)

熵的数学公式如下-

Entropy. Sometimes also denoted using the letter ‘H’

其中“Pi”只是我们数据中某个元素/类“I”的频繁出现概率。为了简单起见，假设我们只有两个类，一个正类和一个负类。因此，这里的“我”可以是+或(-)。因此，如果我们的数据集中总共有 100 个数据点，其中 30 个数据点属于正类，70 个数据点属于负类，那么‘P+’将是 3/10，而‘P-’将是 7/10。很简单。

如果我用上面的公式计算这个例子中我的类的熵。这是我会得到的。

这里的熵大约是 0.88。这被认为是一种高熵，一种高水平的无序(意味着低水平的纯度)。熵的度量值介于 0 和 1 之间。(根据数据集中类的数量，熵可以大于 1，但这意味着同样的事情，非常高的无序度。为了简单起见，本博客中的例子将具有介于 0 和 1 之间的熵)。

请看下图。

Provost, Foster; Fawcett, Tom. Data Science for Business: What You Need to Know about Data Mining and Data-Analytic Thinking

x 轴测量每个气泡中属于正类的数据点的比例，y 轴测量它们各自的熵。很快，你可以看到图表的倒“U”形。熵在极端情况下是最低的，这时气泡要么不包含正实例，要么只包含正实例。也就是说，当气泡是纯的时，无序度为 0。当气泡在正负两种情况下平均分配时，熵在中间最高。极度无序，因为没有多数。

为什么熵是用以 2 为底的对数来度量的，或者为什么熵是在 0 和 1 之间度量的，而不是其他范围，这有关系吗？不。这只是一个度量。知道它是怎么来的并不重要。知道如何阅读它以及它告诉我们什么是很重要的，这一点我们刚刚在上面做了。熵是对无序或不确定性的度量，机器学习模型和数据科学家的目标通常是减少不确定性。

现在我们知道如何测量无序。接下来，我们需要一个度量标准，在给定额外信息(特征/独立变量)的情况下，测量目标变量/类别中这种无序的减少。这就是信息增益的用武之地。数学上它可以写成:

Information Gain from X on Y

我们简单地从 Y 的熵中减去给定 X 的 Y 的熵，来计算给定关于 Y 的额外信息 X 的关于 Y 的不确定性的减少，这被称为信息增益。这种不确定性减少得越多，从 x 获得的关于 Y 的信息就越多。

让我用一个简单的列联表来举例说明，然后我将把所有这些放在一起，看决策树如何使用熵和信息增益来决定在数据集上训练时根据什么特征来分割它们的节点。

举例:列联表

Contingency Table

这里，我们的目标变量是负债，可以采用两个值“正常”和“高”，我们只有一个称为信用评级的特征，可以采用值“优秀”、“良好”和“差”。总共有 14 个观察值。其中 7 个属于正常负债类，7 个属于高负债类。所以这是一个平均分配。对顶行进行总结，我们可以看到有 4 个观察值对于功能信用评级具有极佳的价值。此外，我还可以看到我的目标变量是如何划分为“优秀”信用评级的。对于其信用评级值为“优秀”的观察，有 3 个属于正常负债类别，只有 1 个属于高负债类别。我同样可以从列联表中计算出其他信用评级的值。

对于这个示例，我将使用这个列联表来计算我们的目标变量本身的熵，然后在给定关于特征、信用评级的附加信息的情况下计算我们的目标变量的熵。这将允许我计算“信用评级”为我的目标变量“负债”提供了多少额外的信息。

那我们就开始吧。

我们的目标变量的熵是 1，由于类标签“正常”和“高”之间的平均分裂而处于最大无序状态。我们的下一步是给定关于信用评分的额外信息，计算我们的目标可变负债的熵。为此，我们将计算每个信用评分值的负债熵，并使用每个值中结束的观察比例的加权平均值将它们相加。当我们在决策树的上下文中讨论这个问题时，我们为什么使用加权平均值将变得更清楚。

给定特征信用评级，我们得到了目标变量的熵。现在我们可以从信用评级中计算负债的信息增益，看看这个特征的信息量有多大。

了解信用评级有助于我们减少目标变量负债的不确定性！这难道不是一个好的功能应该做的吗？为我们提供目标变量的信息？这就是决策树如何以及为什么使用熵和信息增益来确定在哪个特征上分裂它们的节点，以更接近预测每次分裂的目标变量，并且还确定何时停止分裂树！(当然除了像最大深度这样的超参数)。让我们看看另一个使用决策树的例子。

示例:决策树

考虑一个例子，我们正在构建一个决策树来预测给一个人的贷款是否会导致注销。我们的全部人口由 30 个实例组成。16 个属于注销类，另外 14 个属于非注销类。我们有两个特性，分别是可以取两个值-->“< 50K” or “>50K”的“Balance”和可以取三个值-->“OWN”、“RENT”或“OTHER”的“Residence”。我将向您展示决策树算法如何使用熵和信息增益的概念来决定首先分割哪个属性，哪个特征提供更多信息，或者减少两个目标变量中更多的不确定性。

特点一:平衡

Provost, Foster; Fawcett, Tom. Data Science for Business: What You Need to Know about Data Mining and Data-Analytic Thinking

圆点是分类正确的数据点，星号是未注销的数据点。在属性平衡上分割父节点给我们 2 个子节点。左侧节点获得了总观察值中的 13 个，其中 12/13 ( 0.92 概率)观察值来自注销类，而只有 1/13( 0.08 概率)观察值来自未写入类。右节点得到总观察值的 17，其中 13/17( 0.76 概率)观察值来自非注销类，4/17 ( 0.24 概率)来自注销类。

让我们计算父节点的熵，看看通过平衡分裂，树可以减少多少不确定性。

分割特征，“平衡”导致目标变量的信息增益为 0.37。让我们做同样的事情为功能，“住宅”，看看它如何比较。

特色二:住宅

Provost, Foster; Fawcett, Tom. Data Science for Business: What You Need to Know about Data Mining and Data-Analytic Thinking

在 Residence 上分割树给了我们 3 个子节点。左边的子节点得到总观察值中的 8 个，其中 7/8 (0.88 概率)观察值来自注销类，而只有 1/8 (0.12 概率)观察值来自非注销类。中间的子节点得到总观察值中的 10 个，其中 4/10 (0.4 概率)观察值属于核销类，6/10( 0.6 概率)观察值属于非核销类。右边的子节点得到总观察值中的 12 个，其中 5/12 ( 0.42 概率)观察值来自注销类，7/12 ( 0.58)观察值来自非注销类。我们已经知道了父节点的熵。我们只需要计算分裂后的熵来计算“居住”的信息增益

从特征、平衡中获得的信息几乎是从住所中获得的信息的 3 倍！如果你回头看一下图表，你可以看到平衡分裂的子节点看起来确实比驻留的子节点更纯粹。然而，最左侧的居住节点也非常纯粹，但这是加权平均值发挥作用的地方。尽管该节点非常纯，但它具有最少的总观测值，并且当我们从驻留分裂计算总熵时，一个结果贡献了其纯度的一小部分。这一点很重要，因为我们寻求的是一个特性的整体信息能力，我们不希望我们的结果被一个特性中罕见的值所扭曲。

就其本身特性而言，Balance 比 Residence 提供了更多关于我们的目标变量的信息。它减少了我们的目标变量中更多的无序。决策树算法将使用此结果，使用 Balance 对我们的数据进行第一次拆分。从现在开始，决策树算法将在每次分割时使用这个过程来决定下一个要分割的特征。在现实世界的场景中，对于两个以上的特征，首先对信息最丰富的特征进行分割，然后在每次分割时，需要重新计算每个附加特征的信息增益，因为它与每个特征本身的信息增益不同。熵和信息增益必须在已经进行了一次或多次分裂之后计算，这将改变结果。决策树会重复这个过程，直到它变得越来越深，直到它达到预定义的深度，或者没有额外的分裂可以导致超过某个阈值的更高的信息增益，该阈值通常也可以被指定为超参数！

你有它！你现在知道什么是熵和信息增益，以及它们是如何计算的。您了解决策树如何独自或在基于树的集合中决定分割要素的最佳顺序，并决定在给定数据上训练自己时何时停止。如果你必须向某人解释决策树是如何错综复杂地工作的，希望你不会做得太糟糕。

我希望你能从这篇文章中获得一些价值。如果我遗漏了什么，或者有什么不准确的地方，或者如果你有任何反馈，请在评论中告诉我。我将非常感激。谢谢你。

熵——热力学和信息论的支柱

原文：https://towardsdatascience.com/entropy-the-pillar-of-both-thermodynamics-and-information-theory-138d6e4872fa?source=collection_archive---------7-----------------------

“唯熵易得”

——安东·契诃夫

熵是一个模糊但强大的术语，它构成了热力学和信息论中许多关键概念的主干。物理科学家在 19 世纪首次发现了它，并将其作为工业革命中许多革命性技术的指导原则。然而，当这个术语出现在数学家克劳德·香农的开创性著作一个关于交流的数学理论中时，它也帮助点燃了信息时代的火花。那么，一个术语怎么能对两个相关但完全不同的领域中相隔约一个世纪的突破负责呢？

能量&热力学

首先，让我们从熵在物理科学中是如何解释的开始。热力学第一定律规定，在任何封闭系统中，能量既不能创造，也不能消灭。第二定律又称熵定律，规定在开放系统中，能量总是从较高的浓度流向较低的浓度，以达到热力学平衡。这在实践中意味着什么？这意味着随着时间的推移，你的咖啡杯最终会变冷，饮料中的冰会融化，或者，当火焰的能量转移到铁分子时，放在火中的工具会变热，但当能量分布到新的周围环境时，它会冷却下来。

Coffee and ice water both trend towards thermodynamic equilibrium (room temperature) over time.

熵这个术语本身指的是给定系统中的无序状态。集中可用的能量被认为是有序的，而分散不可用的能量被认为是无序的。

熵只朝一个方向运动——朝着平衡——除非受到系统外部力量的作用，即使如此，像生物系统这样的外部力量也只是暂时成功地逆转了熵过程，并最终软化(通过死亡)。任何植物或动物都是一个复杂的能量系统，通过抵消熵过程，从环境中收集可用的有序能量，然后排放掉营养物质的废物来生存。但生命系统的能量吞吐量最终会降解其物理结构，导致有机体崩溃和死亡(希望已经完成了繁殖的最终目标)。不再有生命的能量体将分解并消散到周围的环境中——以及热力学平衡中。

理论上，熵只有在导致宇宙热寂时才会停止稳步前进——这是一种没有自由能的终极状态。地球上和太空中的一切最终都会膨胀、爆炸、死亡，并通过真正最大的封闭系统——宇宙——平均分配自由能量。这样看来，熵是一个类似万有引力的普遍定律，因为它在生物物理学的最小和最大尺度上都起作用。

经济是有机体，不是洗衣机

熵也适用于经济。通过从周围环境中获取可用能量并将其转化为无序能量，有机体内部的熵过程也适用于有机体群体。社会以两种形式获取低熵能源:存量和流量。储量包括稀土矿物、化石燃料和其他由数千年复杂的长期地球过程产生的陆地沉积物。水流来自可再生资源，如风能、水能和太阳能，其中也包括生物质能(作为太阳能的间接延伸)。鉴于每个来源的性质，存量在数量上是有限的，而流量在速度和数量上都是有限的。文明，像有机体一样，有新陈代谢。他们处理能量。

(ourfiniteworld.com)

工业革命第一次将经济的主要能源投入从流动转向陆地储备。依赖水流的两种工作形式&马拉犁和风帆，被依赖化石燃料的机械化农业和蒸汽动力船所取代。我们利用沉睡了数百万年的太阳能化石，将文明从地球生物流的束缚中解放出来，并创造了人口和 GDP 的飞速增长。

尽管这种转变带来了不可否认的经济和物质优势，但它也带来了加速熵增过程和增加气候系统无序度的副作用。虽然能源总量在整个经济过程中保持不变(太阳能除外)，但生产过程所需的矿物开采和化石燃料消费表现出一种质变，使能源从有序走向无序。这样，熵形成了稀缺的基础，因为人类无法将能量从无序状态转移到有序状态；如果没有熵，从物理上讲，将大气中的二氧化碳转变成一块煤是可能的，就像当轮胎在路面上降解时，可以捕获并重新配置橡胶颗粒一样。

说到底，我们的经济使用的东西和的能源。尽管我们的价值代表——货币在经济中无限循环，但它所代表的实物商品也遵循熵定律。当前的经济体系就像一个无限生长的有机体。我们的心脏输送血液，让我们活着，但随着时间的推移，这种力量会磨损我们的细胞。我们变老了，退化了。

那么熵如何应用于数据科学呢？

现在我们已经了解了熵是如何指代能量的，让我们看看它是如何应用于通信和信息理论的。我认为这段摘自吉米·索尼和罗布·古德曼为克劳德·香农写的传记《一颗正在玩耍的心》，是一个关于熵起源的有趣故事:

香农带着他的信息解决不确定性的想法——这将成为他工作的核心——和一个谦逊的问题走近这位伟人。他应该怎么称呼这个东西？[约翰]冯·诺依曼马上回答:“说信息减少了‘熵’。”首先，这是一个很好的、坚实的物理词汇。更重要的是，”他继续说道，“没有人知道熵到底是什么，所以在辩论中你总是占优势。"

Claude Shannon (The Daily Beast)

在接受香农对熵的定义之前，分解一下他对信息的定义可能会有所帮助。香农理论的基本思想是，交流信息的信息价值取决于信息内容令人惊讶的程度。实践中一个很好的例子就是字母在语言中的使用频率。从概率上讲，如果一个字母的实例是一个事件，那么每个给定事件最有可能的结果遵循这个概率分布:

字母越多，信息中的不确定性就越少。但这也取决于信的稀有程度。例如，以下哪个信息包含更多的信息，1 还是 2？

1._AT

2.高温

选项“1”包括两个概率相对较高的字母，在这里你可以通过填写缺失的字母拼出各种单词:“蝙蝠”、“猫”、“帽子”、“胖子”、“Sat”等。选项 2 包括相对难以捉摸的字母“H”，它还有一些单词选项，如“Hat”或“Hit”，但没有选项 1 多。因此，方案 2 传达了更多的信息，因为它在更大程度上减少了不确定性。

因此，如果信息是不确定的，熵必然是需要解决的不确定性。一个事件的稀有性，或者说它的“惊奇性”，决定了它的信息内容(如果你玩过 Scrabble，你就会知道如果我们抽到字母“Q”，选项会有多有限)。每当我们交流一条信息，总的熵、无序、不确定性，或者无论你想怎么称呼它，都会按比例减少。那么这个比例量是多少呢？

Shannon 计算出与每个可能的数据值相关联的信息熵的度量是该值的概率质量函数的负对数:

熵通过识别随机事件的结果来测量所传达的预期信息量，其中可能的结果是概率函数。这意味着掷骰子比掷硬币具有更高的熵，因为掷骰子的每个结果(⅙)的概率都小于正面或反面()。以图形方式查看关系有助于:

(Wikipedia)

通过传达正面的结果，我们知道没有出现反面。

在机器学习中，熵的数学解释用于计算许多算法的信息增益度量。例如，决策树选择许多不同属性中的一个，也称为特征或独立变量，以重复地将样本分成子集。在每次分割时，算法选择一个属性来分割样本，并继续这样做，直到所有子集都是纯的，或者换句话说，子集中的每个单独样本共享相同的分类或目标值。

Using entropy in decision trees.

为了测量样本子集的纯度，该算法需要一个定量的度量来客观地选择在每个给定的节点上分裂哪个特征。这就是熵产生的原因。在每一步，算法计算哪个属性将显示最高的信息增益，然后决定拆分。它还计算分割前后不确定性的预期减少量；如果它减少，分割被保留，算法进行到下一步。如果它没有减少，它就达到了纯净，它就休息了。这样，它既负责选择要分割的特征，也负责暂停该过程。

热力学和信息论有联系吗？

熵无情地流过决策树，就像它无情地流过一杯咖啡进入空气一样。在能量方面，它向热力学平衡进军；在信息论中，它走向纯粹。

在其核心，熵的能量解释和熵的信息论解释汇聚在同一点——物理学的基本定律。交流需要能量，利用能量需要交流。根据 Shannon 的说法，一条信息的熵值提供了一条消息的最短可能平均长度的绝对限制，或者它可以被压缩多少，而不会在传输时丢失信息。半导体、手电筒和用莫尔斯电码敲锅都需要人类的能量，我们的通信将永远争取最有效的传输方式。

在能源方面，我们试图通过限制我们的消耗量和消耗效率来最小化熵。我们的目标是找到有序的能量来源，抵制熵对我们身体的影响。在通信中，我们通过寻找信息和减少不确定性来最小化熵。在某种程度上，通过交流减少无序，我们可以停止能量的熵过程；一个狩猎采集者可以使用语言与另一个人交流，以警告被狮子吃掉，这两者都减少了 1 的不确定性。狮子在哪里(信息熵)和 2。被狮子吃掉的过程(能量熵)。这种沟通行为减少了所有可能事件的概率空间，让我们能够更高效、更有效地行动。理解这一强有力的定律在数字和物理领域如何运作的本质是理解热力学和信息时代之间联系的关键。

EPL 幻想游戏周-1 统计和智能玩家选择的算法建议

原文：https://towardsdatascience.com/epl-fantasy-gameweek-1-stats-and-algorithm-recommendations-for-smart-picks-23b4c49cae8?source=collection_archive---------22-----------------------

GW 1 统计更新，算法逻辑更新和更多…

链接到以前的文章:

如果你刚刚第一次登陆这个博客，请务必阅读原始博客，它更详细地描述了我们如何使用 Python 编写一个球员推荐算法，该算法使用 Moneyball 方法每周选择最佳的 EPL 幻想队。以下链接:

[## EPL 幻想是一个星期了，我们的算法已经准备好了！

我们击败 EPL 幻想游戏的摇钱树方法

towardsdatascience.com](/epl-fantasy-is-one-week-away-and-our-algorithm-is-ready-to-play-78afda309e28) [## 用 Python 和数据科学击败梦幻英超

我们对 EPL 梦幻联盟的摇钱树方法

towardsdatascience.com](/beating-the-fantasy-premier-league-game-with-python-and-data-science-cf62961281be)

本周有什么新鲜事？

我们在算法中加入了额外的逻辑，允许您每周动态更新以下指标，以优化长期投资回报预期:

宣布本周你想用什么阵型——算法聪明地挑选出最大化预算的选择阵型。因此，如果您声明一个 4–4–2 编队，代码将得到您最好的 4-DF，4-MD 和 2-ST 的 ROI，然后用您能负担的剩余预算填充剩余的点，仍然最大化 ROI。
宣布预算分配 —我们现在可以动态设置我们希望每个职位花费总预算的多少%。所以，你可以说 GK = 10%，DF = 25%，MD = 40%，ST = 25%，算法只会在 GKs 上花 1000 万美元，DFs 上花 2500 万美元，MDs 上花 4000 万美元，STs 上花 2500 万美元。这样，如果你决定从 5-3-2 阵型转换为 3-5-2 阵型，你可以相应地改变预算，在进攻和防守球员上花更多的钱。
宣布对手实力 —幻想已经有了一个 FDR 属性，可以查看下一个对手的团队实力。我们得到了这个数据，目前正在查看未来 3 场比赛的 AVG _ 对手 _ 实力，并告诉我们的算法跳过选择一名球员，如果他们球队的 AVG_FDR ≥ 3.5。我们可以动态地改变截止数，也可以控制我们是否希望预测 1、2、3 或更多场比赛。现在，我们使用接下来的三场比赛，因为我们试图避免每周进行太多的转会，所以我们想确保当我们为我们的球队挑选球员时，他们至少在接下来的 2-3 场比赛中有很高的投资回报率预期，然后我们才会考虑将他们转移或放在替补席上。

当前幻想对手实力排名:

请注意，我们也可以随着赛季的进展和相对团队实力的变化而动态更新。但首先，我们发现这个排名已经足够了。

 ('LIV', 5),
 ('MCI', 5),
 ('ARS', 4),
 ('CHE', 4),
 ('MUN', 4),
 ('TOT', 4),
 ('BOU', 3),
 ('BUR', 3),
 ('CRY', 3),
 ('EVE', 3),
 ('LEI', 3),
 ('NEW', 3),
 ('SOU', 3),
 ('WAT', 3),
 ('WHU', 3),
 ('WOL', 3),
 ('AVL', 2),
 ('BHA', 2),
 ('NOR', 2),
 ('SHU', 2)

游戏周 1 统计:

下面你可以看到每个职位的前 10 名 ROI 玩家。请记住，投资回报率是按总积分/玩家成本计算的，因此，如果一些玩家目前的价格过高，你可能看不到他们有很多积分。这一切都将在几周内汇聚起来，更稳定、表现最佳的玩家最终将出现在投资回报率排行榜的前列。

投资回报率排名前十的门将

投资回报率排名前十的防守球员

投资回报率排名前 10 的中场球员

投资回报率排名前 10 的前锋

一旦我们积累了几个星期的数据，我计划还包括其他有趣的统计数据，如前 10 名球员的、【总奖励点数】、【每分钟点数】和团队统计数据，如、【总团队投资回报率】、、、【AVG 玩家投资回报率】等。因此，我们可以开始识别“表现不佳”和“表现出色”的团队，以及“定价过低”和“定价过高”的球员。

Gamesweek 2 最佳团队推荐:

首先，我们需要定义我们的阵型，预算分配，以及哪些球队我们不会因为高 FDR(对手实力)分数而选择球员。

团队形成:第 2 周的 3–4–3 形成
预算分配:GK = 1000 万美元，DF = 2400 万美元，MD = 43 美元，ST = 2300 万美元
从玩家选择中排除的队伍:

下面你可以看到在接下来的 3 周内，AVG 最难对付的球队:

 ('Arsenal', 4.0),
 ('Burnley', 4.0),
 ('Spurs', 4.0),
 ('Brighton', 3.67),
 ('Southampton', 3.67),
 ('Bournemouth', 3.33),
 ('Liverpool', 3.33),
 ('Norwich', 3.33),
 ('Sheffield Utd', 3.33),
 ('Wolves', 3.33),
 ('Aston Villa', 3.0),
 ('Leicester', 3.0),
 ('Man City', 3.0),
 ('Man Utd', 3.0),
 ('Newcastle', 3.0),
 ('Watford', 3.0),
 ('Crystal Palace', 2.67),
 ('Everton', 2.67),
 ('Chelsea', 2.33),
 ('West Ham', 2.33)

根据这些 AVG FDR 分数，我们的算法将在接下来的 2-3 个比赛周内避免选择来自阿森纳、伯恩利、马刺、布莱顿和南安普顿的球员，直到 AVG FDR 分数下降到 3.5 以下。

gw2 的最终团队建议:

请注意，下面的这些选择仅基于一周的数据，这意味着许多这些选择可能基于暂时的投资回报率分数而言有点过早，从长远来看可能不成立。也就是说，我们预计在至少 4-5 周的数据之后，这些数字将开始向更准确的长期投资回报预期靠拢。在那之前，你可能会看到一些随机的玩家名字，而看不到一些你通常期望看到的可靠玩家。尽管如此，这些初始统计数据可以让我们了解哪些球员/球队目前“炙手可热”，并可能帮助我们找到一些价格低廉、投资回报率高的初始隐藏“宝石”，这些宝石目前可能定价过低，但如果他们持续表现，从长远来看将获得大量价值。

由于我们不能每周完全更换我们的团队，我们将使用上述建议和当前的 ROI 统计来为我们的团队选择 1-2 个替代者——“算法”，并尝试在游戏周 2 期间优化最大 ROI。请注意，我们最初的球队选择是基于上个赛季的 ROI 统计数据，因此需要几周时间和统计数据更新才能开始删除上个赛季的一些“表现不佳”和“定价过高”的球员，并开始添加当前赛季的一些更热门的“表现过度”和“定价过低”的球员。

请随时与我们联系，就我们如何进一步改进该算法提出想法和建议，或者就您可能希望我们在未来的博客帖子中计算和可视化的其他有趣的统计数据提出建议。

祝大家在 GW2 期间好运！

EPL 幻想 GW10 回顾和 GW11 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw10-recap-and-gw11-algorithm-picks-8f30b5e680b3?source=collection_archive---------20-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

如果这是你第一次登陆我的幻想 EPL 博客，你可能想先看看第一部分、第二部分、第三部分、第五部分和第九部分，以熟悉我们的整体方法和我们随着时间的推移所做的改进。我在这个项目中的犯罪搭档是 Andrew Sproul，他和我一样对数据科学、人工智能和幻想 EPL 充满热情。

本周我们将保持简短，因为我们已经在前面的博客中描述了我们的方法和主要更新。

GW9 世界排名前十的选手

上周末世界排名前 10 位的选手表现非常好！我们认为我们在剧透警报上做得很好……60 分，我想这还不算太差——仍然接近 64 分的前 10 名玩家的最低分。因此，如果你的得分在 65-75 分之间，你会感觉非常好。

EPL 100 强球员最佳混合团队

当我们谈论世界前 100 名球员的话题时，让我们看看谁是他们球队中按位置选择的前 10 名球员，以及 GW9 最喜欢的球队阵型。

前 100 名最佳守门员

前 100 名中最受欢迎的捍卫者

前 100 名最佳中场球员

前 100 名中入选最多的前锋

这里最有趣的变化是，与前几周相比，很多顶级玩家放弃了 Pukki。对于大多数顶级球员来说，似乎瓦迪和亚伯拉罕是可靠的两个选择，但正如你在上面看到的，在第三前锋的选择上有很多差异。

我们使用这些数据和当前的球员价格来创建下面的球队，这是由前 100 名中最受欢迎的球员组成的:

这是一个看起来不错的团队，银行里还有 110 万英镑可以用来玩和测试不同的配置。

前 100 名 Fantasy 用户选择最多的团队

似乎大多数球员现在都在使用3–4–3 阵型，试图优化他们的进攻球员所获得的总积分，这些球员通常有更高的机会获得助攻、进球和总积分。

GW9 团队绩效总结和总体统计

听起来我们在上周博客结尾的祈祷起作用了！经过几个星期的干旱，我们最终得分高于平均水平。我们再次失败的一个地方是挑选我们的队长 Auba T1，他连续第二周只给了我们 2 分:(我们也因为没有在西汉姆和曼联不失球而丢了很多分，这两场比赛直到比赛的后期都接近不失球。如果我们至少有一场不失球，而且我们是瓦迪的队长，我们会有接近 100 分。

GW10 整体统计数据为我们的 GW11 精选提供信息

下面让我们从调整后的未来三个比赛周的对手难度等级(FDR)开始:

看起来这周我们有很多球队的赛程都很艰难——曼城、南安普顿、利物浦、水晶宫和维拉。我们的算法是这样写的，它不会在本周推荐从这些球队购买球员。赛程相对轻松的球队(如果 EPL 有这种东西的话:P)有热刺、曼联、诺维奇、埃弗顿和伯恩利，所以从这些球队得到球员可以在接下来的三场 2-3 场比赛中得到回报。

美国东部时间 11 月 1 日上午 9 点最新伤情更新

以下数据来自一个独立网站，该网站更新最新受伤情况的频率比 Fantasy 网站高得多:

接下来，让我们通过 ROI 和 pts_per_90min 统计数据来看看顶级球员:

投资回报率排名前十的守门员

90 分钟内排名前 10 的守门员

按投资回报率排名的前 10 名防守队员

按 pts _ per _ 90 分钟排名前 10 的防守队员

投资回报率排名前十的中场球员

90 分钟 pts _ per _ 强中场

投资回报率排名前十的前锋

射手前 10 名由 pts_per_90min

GW9 算法选择

提醒一下，我们的算法会考虑调整后的每队阵型预算，并尝试最大化主要 11 名球员的每个位置的支出，然后让你的替补获得良好的 ROI 值。大多数星期我们都在玩 3–4–3 的阵型，现在我们知道世界排名前 100 的球员都选择同样的阵型，我们会更倾向于继续使用它。根据当前的投资回报率得分，在接下来的三场比赛中过滤掉任何具有 AVG 对手难度(FDR≥75%)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

注意:由于高 FDR，我们无法从利物浦或曼城挑选球员，这使得这支球队看起来比通常银行里有很多钱的球队更弱，但至少我们得到了一个有趣的实验，有很多更便宜、高 ROI 的球员，意识到来自大球队的球员实际上是多么高价。

就我们自己的球队而言，我们决定不做任何重大改变，只是将加扎尼加作为一项长期投资，因为他在对阵利物浦的比赛中表现出色，我们觉得对于像热刺这样更强大的球队来说，他是一个非常便宜的门将。拥有两个相对便宜的门将有望让我们在未来最大限度地在球员身上花钱。

鉴于沃特福德的防守非常薄弱，我们希望最终能在我们的队长身上赢得一些分数，但我们将拭目以待。

团队统计

看看最佳/最差防守和进攻可以有几种不同的用法——例如，如果一个最佳进攻队与一个最差防守队比赛，你可能想让你的进攻中场或前锋担任队长。此外，当你查看这些位置的算法建议时，你可能想优先考虑防守最好的球队的 DF 和 GK。

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是指已经玩了总可能游戏时间的至少 25% 的任何玩家。例如，总可能分钟数=周数* 90 分钟= 10* 90 = 900。所以，我们把所有至少打了 900/4 = 225 分钟的球员都算作是该队的现役球员。

非常有趣，但并不令人惊讶的变化:我们有了一个新的领导者——莱斯特！！！他们的平均每名球员得分和平均每名球员投资回报率在上周 9-0 获胜后飙升。顶部的其余部分变化不大。

阿森纳和曼联慢慢开始走出下半区，但是热刺和埃弗顿仍然有很多价格过高和表现不佳的球员，15-16 名球员轮换。

最终想法:

因为我们上次的祈祷似乎起了作用，我们将再次以“最后的祈祷”结束。然而，上周我们搞砸了我们的一个祈祷，我们说“保佑我们的队长本周有额外的速度、力量和射门准确性”，这听起来很好，但我们实际上没有祈祷进球和助攻，所以…我们没有得到任何东西:P 现在是时候验证一句古老的谚语了——“有求必应”。本周，我们向幻想之神祈祷，祈求他们给我们一点怜悯，保佑我们西汉姆不失球，队长得分至少 6 分，但希望更多！

一如既往——感谢您的阅读，祝您周末好运！

EPL 幻想 GW11 回顾和 GW12 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw11-recap-and-gw12-algorithm-picks-63eca649e022?source=collection_archive---------37-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

本周我们将保持简短，因为我们已经在前面的博客中描述了我们的方法和主要更新。

GW11 世界排名前 100 的选手

上周末世界排名前 100 的选手表现非常好！我们对自己的总得分也很满意——79 分，非常接近 AVG 世界排名前 100 名球员的得分——83 分。所以，如果你的得分在 70-80 分之间，你会感觉非常好。

此外，有趣的是，到目前为止，本赛季前 100 名球员中的大多数都在 720-740 分之间。只有前 10 名玩家的总得分超过 750 分，前 3 名玩家的总得分为> 770 分。

EPL 100 强球员最佳混合团队

当我们谈到世界前 100 名球员的话题时，让我们看看谁是他们球队中按位置排名的前 10 名球员，以及 GW11 最受欢迎的球队阵容。

前 100 名最佳守门员

前 100 名中最受欢迎的捍卫者

前 100 名最佳中场球员

前 100 名中入选最多的前锋

这里最有趣的变化是，普基最终被奥巴姆扬从三前锋的位置上赶了下来。对于大多数顶级球员来说，似乎瓦迪和亚伯拉罕是可靠的两个选择，但正如你在上面看到的，在第三前锋的选择上有很多差异。

我们使用这些数据和当前的球员价格来创建下面的球队，这是由前 100 名中最受欢迎的球员组成的:

这是一个看起来不错的团队，银行里还有 170 万英镑可以用来玩和测试不同的配置。

前 100 名 Fantasy 用户选择最多的团队

似乎大多数球员现在都在使用3–4–3 阵型，试图优化从他们的进攻球员那里获得的总积分，这些球员通常有更高的机会获得助攻、进球和总积分。

GW11 团队绩效总结和总体统计

听起来我们的祈祷又起作用了！我们的得分再次高于平均水平，并最终选择了一名优秀的队长——塔米·亚伯拉罕，12 x2 = 24 分。替补席上也没有留下太多的分数，所以总体来说，我们本周最大化了我们的预期投资回报率，这感觉不错:)过去两周最大的失望是我们在西汉姆球员上的投资根本没有得到回报，所以我们很遗憾没有得到蒂勒曼斯、奇尔韦尔或索因库，而不是克雷斯韦尔和亚莫连科。我们会在周末对阵伯恩利的比赛中给他们最后一次机会，然后卖掉他们，因为西汉姆接下来有两场伦敦德比——热刺和切尔西。

为我们的 GW12 选秀权提供信息的 GW11 整体统计数据

下面让我们从调整后的未来三个比赛周的对手难度等级(FDR)开始:

布莱顿、皇宫、曼城和切尔西是仅有的 FDR 得分超过 75%的球队，利物浦正好在分界点。我们的算法是这样写的，它不会在本周推荐从这些球队购买球员。赛程相对轻松的球队(如果 EPL 有这种东西的话:P)有曼联、阿森纳、埃弗顿、伯恩利和沃特福德，所以从这些球队得到球员可以在接下来的三场 2-3 比赛中得到回报。

美国东部时间 11 月 6 日晚 8 点最新伤情更新

以下数据来自一个独立网站，该网站更新最新受伤情况的频率比 Fantasy 网站高得多:

接下来，让我们通过 ROI 和 pts_per_90min 统计数据来看看顶级球员:

投资回报率排名前十的守门员

90 分钟内排名前 10 的守门员

按投资回报率排名的前 10 名防御者

pts _ per _ 90min 排名前 10 的防守队员

投资回报率排名前十的中场球员

90 分钟 pts _ per _ 强中场

投资回报率排名前 10 的前锋

射手前 10 名由 pts_per_90min

GW9 算法选择

提醒一下，我们的算法会考虑调整后的每支队伍的预算，并尝试最大化 11 名主力队员在每个位置的花费，然后让你的替补获得良好的 ROI 值。根据当前的投资回报率得分，在接下来的三场比赛中过滤掉任何具有 AVG 对手难度(FDR≥75%)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

注: 因为高 FDR，我们不能从利物浦、曼城或切尔西挑选球员，这使得这支球队看起来比通常银行里有很多钱的球队更弱，但至少我们得到了 一个有趣的实验，有很多更便宜、高 ROI 的 球员，意识到来自大球队的球员实际上是多么高价。我们在上面插入了马内和亚伯拉罕，只是因为我们不想在银行里留下超过 1200 万美元的存款。

就我们自己的团队而言，我们决定投资一些来自狼队的更便宜的球员，因为他们接下来的 4-5 场比赛是与牌桌上中下水平的对手比赛，希望从他们那里获得一些不错的投资回报，并腾出预算在未来获得一些更昂贵的球员。

团队统计

查看最佳/最差防守和进攻可以有几种不同的用法——例如，如果最佳进攻队与最差防守队比赛，你可能想让你的进攻中场或前锋担任队长。此外，当你查看这些位置的算法建议时，你可能想优先考虑防守最好的球队的 DF 和 GK。

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是指已经玩了总可能游戏时间的至少 25% 的任何玩家。例如，总可能分钟数=周数* 90 分钟= 11* 90 = 990。所以，我们把所有至少打了 900/4 = 247.5 分钟的球员都算作是该队的现役球员。

莱斯特仍然以最高的平均每名球员得分高居榜首。有趣的是，利物浦刚刚被谢菲尔德联队取代进入前三名，因为利物浦的现役球员数量从 13 名下降到 15 名，这降低了球队总 AVG 投资回报率，可能是因为在过去几场比赛中引入了拉拉纳和公牛，他们现在被算作现役球员。切尔西、伯恩茅斯和狼队在过去几周表现出色后也在攀升。

西汉姆、阿森纳、热刺和埃弗顿仍然是 avg_team_roi 排行榜下半部分的一些较大的球队，他们有许多价格过高和表现不佳的球员，16-17 名球员轮换。

最终想法:

因为我们上次的祈祷似乎起了作用，我们将再次以“最后的祈祷”结束。本周，我们向幻想之神祈祷，祈求他们给我们一些怜悯，保佑我们的三名西汉姆球员——克雷斯韦尔、亚莫伦科和罗伯托——至少得到 12-15 分。我们真的很想在下周卖掉它们之前，从它们身上榨取一些最后的价值。

一如既往——感谢您的阅读，祝您周末好运！

EPL 幻想 GW12 回顾和 GW13 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw12-recap-and-gw13-algorithm-picks-38a045497a73?source=collection_archive---------38-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

本周我们将保持简短，因为我们已经在前面的博客中描述了我们的方法和主要更新。

GW11 世界排名前 100 的选手

与总平均得分 48 相比，上周末世界排名前 100 位的选手表现非常好！仍然有一些前 100 名选手的分数在 50-60 之间，所以如果你的分数接近或超过这个范围，你仍然可以对自己感觉很好。

此外，有趣的是，到目前为止，本赛季前 100 名球员中的大多数都在 800-820 分之间。只有前 10 名玩家的总分超过 820 分，前 2 名玩家的总分超过 850 分。

EPL 100 强球员最佳混合团队

当我们谈论世界前 100 名球员的话题时，让我们看看谁在他们的球队中最受欢迎，以及 GW11 最受欢迎的球队阵容。

前 100 名最佳守门员

前 100 名中最受欢迎的捍卫者

前 100 名最佳中场球员

两个有趣的新名字是马夏尔和普利西克，马迪森也被更多的前 100 名玩家选中，并成为第四大首选。

前 100 名中入选最多的前锋

现在很明显，人们终于克服了对 Pukki 的炒作，他已经下降到第五位，他的价格现在也下降到 670 万英镑(Pukki 是幻想中的 EPL 的比特币吗——所有的短期炒作都没有长期价值？—只有时间会证明…)。与上周相比，另一个有趣的变化是吉梅内斯相当积极地跃居第三，这很可能是由他的状态和狼队被认为容易的计划决定的。

我们使用这些数据和当前的球员价格来创建下面的球队，这是由前 100 名中最受欢迎的球员组成的:

看起来不错的团队，在关键位置上有很多尝试不同选择的余地，同时仍然保持一个坚实的球员核心。

前 100 名 Fantasy 用户选择最多的团队

尽管如此，3–4–3 仍然是首选阵型，旨在优化他们的进攻球员获得的总积分，这些球员通常有更高的机会获得助攻、进球和总积分。

GW12 团队绩效总结和总体统计

遗憾的是，我们从亚莫连科和克雷斯韦尔身上榨取最后一分钟价值的祈祷没有奏效，我们必须摆脱这些“失去的资产”。不幸的是，我们在 3-4 周前对西汉姆球员的大胆投资没有得到回报，所以已经严重损害了我们的整体投资回报率。尽管如此，我们还是以 54 分(高于 AVG 的 48 分)度过了不错的一周，如果维拉没有在对狼队的比赛中取得第 95 分钟的进球，我们会从特拉奥雷和赛斯那里得到更多……:(好消息是，我们连续第三周选择了一位不错的队长——塔米·亚伯拉罕，8 x2 = 16 分。我们也没有在替补席上留下太多分数，所以总体来说，我们本周最大化了我们的预期投资回报率，这感觉不错:)

为我们的 GW12 选秀权提供信息的 GW12 整体统计数据

下面让我们从调整后的未来三周的对手难度等级(FDR)开始:

布莱顿、皇宫、埃弗顿和西汉姆是仅有的 FDR 得分超过 75%的球队，维拉和纽卡斯尔正好在分界点。我们的算法是这样写的，它不会在本周推荐从这些球队购买球员。赛程相对轻松的球队有阿森纳、南安普顿、莱斯特、诺维奇和利物浦，所以从引进新球员，这些球队可以在接下来的三场 2-3 场比赛中获得回报。

美国东部时间 11 月 20 日上午 9 点最新伤情更新

以下数据来自一个独立网站，该网站更新最新受伤情况的频率比 Fantasy 网站高得多:

接下来，让我们通过 ROI 和 pts_per_90min 统计数据来看看顶级球员:

投资回报率排名前十的门将

有趣的是，看到拉姆斯代尔、舒梅切尔和福斯特(T21)越来越接近巅峰。

90 分钟内排名前 10 的守门员

投资回报率排名前十的防守队员

后卫前 10 名 pts_per_90min

投资回报率排名前十的中场球员

有趣的是，我们在这里没有看到任何大牌中场球员，因为他们的价格是上面列出的中场球员平均价格的两倍，考虑到他们的低价格，他们的表现相当好，使他们的总投资回报率比萨拉赫和斯特林等人好得多。

90 分钟 pts _ per _ 强中场

当只看每 90 分钟比赛时间的得分，不考虑价格时，我们可以看到名单上一些得分最高的中场球员，表明他们仍然是伟大的资产，其价值已经被市场定价，因此产生的投资回报率比投资回报率图表中一些被低估和表现过度的中场球员低得多。

投资回报率排名前十的前锋

射手榜前 10 名由 pts_per_90min

GW13 算法选择

提醒一下，我们的算法会考虑调整后的每队阵型的预算，并尝试最大化 11 名主力球员的每个位置的支出，然后让你的替补获得良好的 ROI 值。根据当前的投资回报率得分，在接下来的三场比赛中过滤掉任何具有 AVG 对手难度(FDR≥75%)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

在我们看来，这是一支相当平衡的球队，银行里有整整 240 万英镑，可以尝试不同的球员配置。

就我们自己的团队而言，我们最终摆脱了克雷斯韦尔和亚莫连科，取而代之的是索因库和蒂勒曼斯。我们希望我们有钱买 TAA，但是我们不想在替补上花太多的钱，所以我们会在接下来的几周内设法得到他或者罗伯特。

团队统计

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是指已经玩了总可能游戏时间的至少 25% 的任何玩家。例如，总可能分钟数=周数* 90 分钟= 12* 90 = 1080。所以，我们把所有至少打了 1080/4 = 270 分钟的球员都算作该队现役球员。

在利物浦战胜曼城后，情况发生了变化，曼城由于伤病轮换使用了一些新球员，使曼城的整体球队投资回报率下降到第四位，并将利物浦挤到第二位。我们也可以看到切尔西、狼队和曼联在过去 2-3 场比赛中的一些稳定表现后越来越接近前 5 名。

底部看起来与过去几周相似，阿森纳和马刺仍在努力增加他们的整体团队投资回报率和平均每名球员得分。

最终想法:

本周，我们将保持谦虚，只想向幻想之神请求至少一个帽子戏法和我们队长 Auba 的一次助攻:)到目前为止，他的投资回报还不错，但由于 1100 万英镑的高价，我们需要看到他很快有更多的进球，以提高他的总投资回报率，并证明他长期留在我们的球队是合理的。

一如既往——感谢您的阅读，祝您周末好运！

EPL 幻想 GW13 回顾和 GW14 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw13-recap-and-gw14-algorithm-picks-f5161c390ece?source=collection_archive---------30-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

本周我们将保持简短，因为我们已经在前面的博客中描述了我们的方法和主要更新。

GW13 世界排名前 100 的选手

与平均得分 49 相比，世界排名前 100 位的球员又度过了强劲的一周！尽管如此，还是有一些前 100 名选手的分数在 50-60 之间，所以如果你的分数接近或超过这个范围，你仍然可以对自己感觉很好。

现在我们有三个玩家突破 900 大关，相当可观！

EPL 100 强球员最佳混合团队

当我们谈论世界前 100 名球员的话题时，让我们看看谁在他们的球队中最受欢迎，以及 GW11 最受欢迎的球队阵容。

前 100 名最佳守门员

前 100 名中最受欢迎的捍卫者

前 100 名最佳中场球员

前 100 名中入选最多的前锋

看起来现在有更多的人选择了拉什福德，也有一些顶级球员对奥巴姆扬很固执，仍然让他留在他们的球队，希望获得一些投资回报。

我们使用这些数据和当前的球员价格来创建下面的球队，这是由前 100 名中最受欢迎的球员组成的:

看起来不错的团队，在关键位置上有很多尝试不同选择的余地，同时仍然保持一个坚实的球员核心。

前 100 名 Fantasy 用户选择最多的团队

然而3–4–3 仍然是首选阵型，旨在优化他们的进攻球员获得的总积分，这些球员通常有更高的机会获得助攻、进球和总积分。

GW13 团队绩效总结和总体统计

对我们来说，体面的一周，59 分，高于平均水平 49 分。我们的队长人选还不错，但我们对 Auba 的期望更高。

GW13 整体统计数据为我们的 GW14 选秀权提供信息

下面让我们从调整后的未来三个比赛周的对手难度等级(FDR)开始:

阿斯顿维拉、布莱顿、埃弗顿、伯恩茅斯和伯恩利是仅有的 FDR 得分超过 75%的球队。我们的算法是这样写的，它不会在本周推荐从这些球队购买球员。赛程相对轻松的球队有阿森纳、南安普顿、莱斯特、谢菲尔德联队和切尔西，所以从招募新球员，这些球队可以在接下来的三场 2-3 场比赛中获得回报。

美国东部时间 11 月 27 日晚 9 点最新伤情更新

以下数据来自一个独立网站，该网站更新最新受伤情况的频率比 Fantasy 网站高得多:

接下来，让我们通过 ROI 和 pts_per_90min 统计数据来看看顶级球员:

投资回报率排名前十的守门员

90 分钟内排名前 10 的守门员

按投资回报率排名的前 10 名防守队员

按 pts _ per _ 90 分钟排名前 10 的防守队员

投资回报率排名前十的中场球员

90 分钟 pts _ per _ 强中场

投资回报率排名前十的前锋

射手前 10 名由 pts_per_90min

GW14 算法选择

提醒一下，我们的算法会考虑调整后的每队阵型预算，并尝试最大化主要 11 名球员的每个位置的支出，然后让你的替补获得良好的 ROI 值。根据当前的投资回报率得分，在接下来的三场比赛中过滤掉任何具有 AVG 对手难度(FDR≥75%)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

在我们看来，这是一支相当平衡的球队，银行里有整整 120 万英镑，可以用来试验和尝试不同的球员配置。

就我们自己的球队而言，我们决定不做任何突然的举动，只是摆脱了我们的第二个 GK——里卡多——并以 400 万英镑的价格得到了一名非上场门将，以便为下周的更多转会腾出资金。在上周淘汰万-比萨卡之前，我们给了他最后一次机会来拿分。

团队统计

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是任何已经玩了总可能游戏时间的至少 33.33% 的玩家。例如，总可能分钟数=周数* 90 分钟= 13* 90 = 1170。所以，我们把所有至少打了 1080/3.3 = 351 分钟的球员都算作该队现役球员。

在我们将比赛的最短时间增加到 1/3 后，莱切斯特遥遥领先。看起来他们或多或少使用相同的 11 名球员，他们一直表现得相当稳定，给了他们比其他人高得多的 avg_palyer_roi 和 avg _ team _ ROI。随着越来越多的球员进入 Pep 轮换，曼城的 avg_team_roi 统计数据甚至下降了，最近的表现也不那么令人信服。

最终想法:

大家感恩节快乐，别忘了疯狂的 12 月 EPL 马拉松赛将于下周 12 月 3 日(周二)开始，所以别忘了在周二早上准备好你的替补！！！

EPL 幻想 GW14 回顾和 GW15 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw14-recap-and-gw15-algorithm-picks-713fc6858d4d?source=collection_archive---------42-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

本周我们将保持简短和甜蜜，因为我们在 GW14 和 GW15 之间只有一天，所以让我们在时间结束前完成这些替换！

GW14 世界排名前 100 的选手

对于世界排名前 100 位的球员来说，这一周相对艰难，他们中的许多人的得分接近或低于 51 的平均 GW 得分！甚至有一名球员只得到 30 分，其他几名球员的得分在 30-45 分之间，所以如果你的得分接近平均水平 51 分或以上，请知道你比世界上大多数顶级球员都做得好！

EPL 100 强球员最佳混合团队

当我们谈论世界前 100 名球员的话题时，让我们看看谁在他们的球队中最受欢迎，以及 GW14 最受欢迎的球队阵容。

前 100 名最佳守门员

前 100 名中最受欢迎的捍卫者

前 100 名最佳中场球员

有趣的是，在这里可以看到儿子现在已经上升到了第四位，而英镑现在下降到了第九位。

前 100 名中入选最多的前锋

最受欢迎的前锋的有趣变化是，许多人因为受伤而放弃了塔米·亚伯拉罕，因为他的良好状态和南安普顿轻松的赛程而得到了丹尼·英斯。

我们使用这些数据和当前的球员价格来创建下面的球队，这是由前 100 名中最受欢迎的球员组成的:

前 100 名 Fantasy 用户选择最多的团队

本周我们在阵型上有了一个有趣的变化，因为很多人决定只用 2 个前锋来比赛，并且使用3–5–2 或者 4–4–2作为 3–4–3 的阵型，仍然有相当多的人喜欢。

GW14 团队绩效总结和总体统计

对我们来说，体面的一周 57 分，高于平均 51 分，正好处于世界前 100 名球员的平均水平，所以我们对自己的表现相当满意！我们的队长选择结果相当不错(谢谢 VAR！！！当他错过了第一个点球时，奥巴让我心脏病发，我们从他那里得到了 13x2 = 26pts。不幸的是，我们的后卫和门将都没有得到回报，我们在凯利的替补席上留下了 6 分，所以如果运气再好一点或者至少不失球，事情可能会更好。

为我们的 GW15 选秀权提供信息的 GW14 整体统计数据

下面让我们从调整后的未来三个比赛周的对手难度等级(FDR)开始:

沃特福德、埃弗顿、伯恩茅斯和阿斯顿维拉是仅有的 FDR 得分超过 75%的球队。我们的算法是这样写的，它不会在本周推荐从这些球队购买球员。赛程相对轻松的球队有利物浦、水晶宫、南安普顿、莱斯特和谢菲尔德联队，所以从招募新球员，这些球队可以在接下来的三场 2-3 场比赛中获得回报。

GW15 算法选择

提醒一下，我们的算法会考虑调整后的每支队伍的预算，并尝试最大化 11 名主力队员在每个位置上的花费，然后让你的替补获得良好的投资回报。根据当前的投资回报率得分，在接下来的三场比赛中过滤掉任何具有 AVG 对手难度(FDR≥75%)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

在我们看来，这是一支相当平衡的球队，银行里有整整 120 万英镑，可以用来试验和尝试不同的球员配置。

就我们自己的团队而言，我们最终摆脱了万-比萨卡，他被证明是一个非常糟糕的投资:(而且由于塔米·亚伯拉罕的受伤，我们还卖掉了他，让 TAA 和丹尼·英斯取代了他们的位置。由于沃特福德的防守薄弱，选择瓦迪当队长。

团队统计

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是指已经玩了总可能游戏时间的至少 33.33% 的任何玩家。例如，总可能分钟数=周数* 90 分钟= 14* 90 = 1260。所以，我们把所有至少打了 1260/3.3 = 378 分钟的球员都算作该队现役球员。

莱斯特队本周又赢了一场比赛，扩大了他们的领先优势，但在大多数比赛中，他们仍然只使用 11 名主力球员作为核心。伯恩利、狼队、切尔西和维拉在平均每名球员得分和整体球队投资回报率方面也越来越接近前四名。

最终想法:

首先也是最重要的——不要忘记在美国东部时间周二中午之前准备好你的替补，因为新 GW 将于 12 月 3 日周二开始。就本周我们的球队而言，如果我们能从我们的队长瓦迪那里得到至少 12 分，从我们的新交易——英格斯和 TAA 那里得到每个球员至少 6 分，我们会非常高兴:)我们在最近的过去做了几笔糟糕的投资，所以我们希望我们的运气能够好转，我们的两个新球员能在下周和接下来的 2-3 周开始有所回报。

EPL 幻想 GW17 回顾和 GW18 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw17-recap-and-gw18-algorithm-picks-169856317716?source=collection_archive---------27-----------------------

EPL 幻想博客

我们的钱球方法的幻想 EPL(队 _id: 2057677)

如果这是你第一次登陆我的幻想 EPL 博客，你可能会想看看我的媒体简介中我最初的 EPL 博客，以熟悉我们的整体方法和我们随着时间的推移所做的改进。我在这个项目中的犯罪搭档是 Andrew Sproul，他和我一样对数据科学、人工智能和幻想 EPL 充满热情。

GW17 世界排名前 100 的选手

对于世界排名前 100 的球员来说，这又是一个非常强大的一周，平均 72 分，相比之下，普通人的 GW 平均得分为 56 分！尽管如此，还是有一些得分在 50-60 分之间的前 100 名玩家(包括世界上得分只有 56 分的 t op 玩家)，所以如果你的得分接近或超过那个分数，你仍然可以对自己感觉很好。

EPL 100 强球员最佳混合团队

当我们谈论世界前 100 名球员的话题时，让我们看看谁在他们的球队中最受欢迎，以及 GW17 最受欢迎的球队阵容。

前 100 名最佳守门员

前 100 名中最受欢迎的捍卫者

前 100 名最佳中场球员

前 100 名中入选最多的前锋

我们使用这些数据和当前的球员价格来创建下面的球队，这是由前 100 名中最受欢迎的球员组成的:

看起来不错的团队，在关键位置上有很多尝试不同选择的余地，同时仍然保持一个坚实的球员核心。

前 100 名 Fantasy 用户选择最多的团队

看起来我们回到了一个更具攻击性的3–4–3 阵型，成为首选，所以人们回到了试图优化从进攻球员身上获得的分数——MD 和 ST。

GW17 团队绩效总结和总体统计

对我们来说不是很强的一周，只有 48 分，仅低于平均 56 分。卖掉 KDB 来得到拉什福德和凯恩，到目前为止被证明是错误的举动，所以我们把自己挖进了一个更深的洞，只有拉什福德和凯恩的出色表现才能在接下来的几场比赛中把我们挖出来。不幸的是，我们还和特拉奥雷一起在板凳上留下了 10 分，所以对我们来说这是非常不幸的一周

GW17 整体统计数据为我们的 GW18 选秀权提供信息

下面让我们从调整后的未来三周的对手难度等级(FDR)开始:

对于我们的算法来说，这将是非常非常艰难的一周，曼城、莱斯特和利物浦都有相对困难的计划，所以我们的算法不会从这些球队中做出任何选择。赛程相对轻松的球队有维拉、水晶宫、谢菲尔德、曼联、热刺、切尔西。

按投资回报率和 90 分钟出场次数统计的顶级球员

根据上周一位读者的要求，我现在将公布投资回报率最高和最低的 50 名玩家，这样我们的读者就可以看到更多高投资回报率的玩家，并远离价格过高和表现不佳的玩家。

投资回报率排名前 50 的玩家

注意在这个列表中看到大量的 DFs 和 GK 是正常的,因为它们比攻击玩家便宜得多，允许它们产生更高的整体投资回报率。尽管如此，你可以在那里找到相当数量的攻击球员，到目前为止，他们是一个很好的长期投资。

按投资回报率排名的后 50 名玩家

在这份名单中，我们看到了更多的进攻球员，他们的价格过高，本赛季到目前为止表现不佳。注意像杰西·林加德、本杰明·门迪、谢默斯·科尔曼、克里斯提安·埃里克森这样的名字，他们上赛季表现出色，身价不菲，但本赛季却受伤或表现不佳。

投资回报率排名前十的门将

90 分钟 pts _ per _ 强门将

投资回报率排名前十的防守球员

pts _ per _ 90min 排名前 10 的防守队员

投资回报率排名前十的中场球员

90 分钟 pts _ per _ 强中场

投资回报率排名前十的前锋

90 分钟前 10 名射手

GW17 算法选择

提醒一下，我们的算法会考虑调整后的每队阵容预算，并尝试最大化 11 名主力球员的每个位置的支出，然后让你的替补获得良好的 ROI 值。根据当前的投资回报率得分，在接下来的三场比赛中过滤掉任何具有 AVG 对手难度(FDR≥75%)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

由于我们的算法没有选择来自曼城、利物浦和莱斯特的球员，除了德·布鲁因被选为总积分最高的总经理，这支球队的银行里还有很多钱。

就我们自己的球队而言，在上周出售 KDB 的糟糕举动后，我们没有太多可以做的，所以现在我们必须坚持那个决定，因为计划是在莱切斯特比赛后将他买回来。本周我们进行了一次转会——格里利什进:蒂尔曼斯出——因为维拉的赛程比较轻松，而莱斯特的赛程比较艰难。我们也在考虑卖掉 TAA，这样我们下周就可以为 KDB 腾出一些资金，但我们还没有下定决心。

团队统计

查看最佳/最差防守和进攻可以有几种不同的用法——例如，如果一个最佳进攻队与一个最差防守队比赛，你可能想让你的进攻中场或前锋担任队长。此外，当你查看这些位置的算法建议时，你可能想优先考虑防守最好的球队的 DF 和 GK。

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是任何已经玩了总可能游戏时间的至少 33.33% 的玩家。所以，我们把所有至少打了 460 分钟的球员算作该队现役球员。

在几场更强劲的表现之后，谢菲尔德联队现在已经攀升到 team_ROI 排行榜的第二位。

最终想法:

我们只是对接下来几周不停的 EPL 行动感到兴奋，我们希望我们的博客能帮助你做出一些好的转会选择，为你的假期带来一些额外的快乐。如果有一个 EPL 圣诞老人(我不是指每年圣诞老人大会期间充斥纽约街头的那种:P)并且他们正在阅读我的博客，我们会要求他们从拉什福德和凯恩那里获得大量积分，作为我的早期节日礼物。

一如既往，感谢您的阅读，我们希望您享受假期和令人兴奋的 EPL 行动！

EPL 幻想 GW18 回顾和 GW19 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw18-recap-and-gw19-algorithm-picks-497361641eae?source=collection_archive---------24-----------------------

EPL 幻想博客

我们的钱球方法的幻想 EPL(队 _id: 2057677)

如果这是你第一次登陆我的幻想 EPL 博客，你可能会想看看我在本赛季开始时写的一些原始 EPL 博客(GW1-GW9)，以熟悉我们的整体方法和我们随着时间的推移所做的改进。我在这个项目中的犯罪搭档是 Andrew Sproul，他和我一样对数据科学、人工智能和幻想 EPL 充满热情。

GW17 世界排名前 100 的选手

对于世界排名前 100 的球员来说，这不是一个伟大的一周，平均 53 分，相比之下，普通人的 GW 平均得分为 38！有一些前 100 名选手的分数在 30-40 分之间(包括国际象棋世界冠军————芒努斯·卡尔森——只有 26 分)，所以如果你的分数接近或超过这个分数，你仍然可以对自己感觉很好。

EPL 100 强球员最佳混合团队

当我们谈论世界前 100 名球员的话题时，让我们看看谁在他们的球队中最受欢迎，以及 GW18 最受欢迎的球队阵容。

前 100 名最佳守门员

前 100 名中最受欢迎的捍卫者

前 100 名最佳中场球员

前 100 名中入选最多的前锋

我们使用这些数据和当前的球员价格来创建下面的球队，这是由前 100 名中最受欢迎的球员组成的:

看起来不错的团队，在关键位置上有很多尝试不同选择的余地，同时仍然保持一个坚实的球员核心。

前 100 名 Fantasy 用户选择最多的团队

看起来我们回到了一个更具攻击性的3–4–3 阵型，成为首选，所以人们回到了试图优化从进攻球员身上获得的分数——MD 和 ST。

GW18 团队绩效总结和总体统计

总的来说，这是我们坚实的一周，53 分，高于平均水平 38 分。我们的大部分分数来自于我们的廉价球员，拉什福德和凯恩再次令人失望，到目前为止变成了一笔非常大的投资:(我们再次没有选择正确的队长——凯恩只有 4 分。

为我们的 GW19 选秀权提供信息的 GW18 整体统计数据

下面让我们从调整后的未来三周的对手难度等级(FDR)开始:

对于我们的算法来说，这将是又一个奇怪的选人周，狼队、利物浦队和莱斯特队有一个相对困难的计划，所以我们的算法不会从这些球队中进行任何选人。赛程相对轻松的球队有维拉、水晶宫、伯恩利、曼联、热刺、切尔西。

美国东部时间 12 月 24 日上午 7 点最新伤情更新

以下数据来自一个独立网站，该网站更新最新受伤情况的频率比 Fantasy 网站高得多:

按投资回报率和 90 分钟出场次数统计的顶级球员

投资回报率排名前 50 的玩家

按投资回报率排名的后 50 名玩家

投资回报率排名前十的守门员

后卫前 10 名 pts_per_90min

投资回报率排名前十的防御者

后卫前 10 名由 pts_per_90min

投资回报率排名前十的中场球员

90 分钟 pts _ per _ 强中场

投资回报率排名前十的前锋

90 分钟前 10 名射手

GW19 算法选择

提醒一下，我们的算法会考虑调整后的每支队伍的预算，并尝试最大化 11 名主力队员的每个位置的花费，然后让你的替补获得良好的 ROI 值。根据当前的投资回报率得分，在接下来的三场比赛中过滤掉任何具有 AVG 对手难度(FDR≥75%)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

由于我们的算法没有选择来自利物浦、莱斯特、谢菲尔德或狼队的球员，除了伦德斯特拉姆被总得分选为最佳后卫，这支球队的银行里还有很多钱。

就我们自己的球队而言，我们决定不做任何改变，保留下一个比赛周的自由转会，在那里我们将试图让 KDB 回来，如果可能的话，也许还有其他一些关键球员。我们之前选择凯恩作为队长，希望他最终能回报我们的投资。

团队统计

看看最佳/最差的防守和进攻可以有几种不同的用法——例如，如果一个最佳进攻队与一个最差防守队比赛，你可能想让你的进攻中场或前锋担任队长。此外，当你查看这些位置的算法建议时，你可能想优先考虑防守最好的球队的 DF 和 GK。

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是任何已经玩了总可能游戏时间的至少 33.33% 的玩家。所以，我们会把所有至少打了 490 分钟比赛的球员都算作该队的现役球员。

曼城和狼队领先利物浦，因为他们上周表现出色，利物浦没有参加。

最终想法:

我们只是对接下来几周不停的 EPL 行动感到兴奋，我们希望我们的博客能帮助你做出一些好的转会选择，为你的假期带来一些额外的快乐。如果有一个 EPL 圣诞老人，并且他们正在阅读我们的博客，我们会要求他们给我一个哈里·基恩的帽子戏法和至少一个拉什福德的进球作为我的节日礼物。

一如既往，感谢您的阅读，我们希望您享受假期和令人兴奋的 EPL 行动！

EPL 幻想 GW20 重述和 GW21 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw20-recap-and-gw21-algorithm-picks-24b0ab22bcee?source=collection_archive---------32-----------------------

EPL 幻想博客

我们的钱球方法的幻想 EPL(队 _id: 2057677)

GW20 世界排名前 100 的选手

尽管有很多替补和轮换，世界顶级球员在去年的 GW 上确实表现不错，平均 70 分，相比之下普通人的 GW 平均得分为 54 分！

EPL 100 强球员最佳混合团队

当我们谈论世界前 100 名球员的话题时，让我们看看谁在他们的球队中最受欢迎，以及 GW20 最受欢迎的球队阵容。

前 100 名最佳守门员

前 100 名中最受欢迎的捍卫者

前 100 名最佳中场球员

前 100 名中入选最多的前锋

我们使用这些数据和当前的球员价格来创建下面的球队，这是由前 100 名中最受欢迎的球员组成的:

看起来不错的团队，在关键位置上有很多尝试不同选择的余地，同时仍然保持一个坚实的球员核心。

前 100 名 Fantasy 用户选择最多的团队

看起来由于某种原因 86 名顶级球员选择了 3–5–2阵型，很可能是因为每个人在他们的首发阵容中都有 Vardy，但他最终没有上场，所以他被 MD 或 DF 自动取代。

GW20 团队绩效总结和总体统计

总的来说，这是我们坚实的一周，65 个百分点，高于平均水平 54 个百分点。我们最高兴的是，我们早期的投资——拉什福德和凯恩终于得到了回报，我们终于找到了一位 8 x2 = 16 分的体面队长。

为我们的 GW21 选秀权提供信息的 GW20 整体统计数据

下面让我们从调整后的未来三周的对手难度等级(FDR)开始:

看起来纽卡斯尔、南安普顿、谢菲尔德联队、利物浦和维拉有一个相对困难的计划，所以我们的算法不会从这些球队中做出任何选择。赛程相对轻松的球队有伯恩茅斯、狼队、莱斯特、切尔西、曼城和布莱顿。

按投资回报率和 90 分钟出场次数统计的顶级球员

投资回报率排名前 50 的玩家

按投资回报率排名的后 50 名玩家

投资回报率排名前十的守门员

90 分钟得分前 10 的守门员

投资回报率排名前十的防御者

后卫前 10 名由 pts_per_90min

投资回报率排名前十的中场球员

90 分钟 pts _ per _ 强中场

投资回报率排名前十的前锋

90 分钟前 10 名射手

GW21 算法选择

看起来这是一个相当平衡的团队，银行里还留有一些钱来试验不同的配置。

就我们自己的球队而言，我们决定只做一个改变，吉梅内斯>拉什福德，因为狼队的赛程更轻松，而且吉梅内斯在最后一场比赛中休息，而不是拉什福德。这也让我们在银行里有了一些额外的钱，下周可以进行更多的转账。

团队统计

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是任何已经玩了总可能游戏时间的至少 33.33% 的玩家。所以，我们会把所有至少打了 540 分钟比赛的球员都算作该队的现役球员。

统计数据开始在这里很好地趋同，因为更稳定的表现和合理的价格球员现在占据了前 5-8 名。一些拥有昂贵球员的球队正在努力追赶并提高他们的整体投资回报率，这些球队是马刺、阿森纳、埃弗顿和西汉姆。

最终想法:

首先，我们要感谢 EPL 圣诞老人上周满足了我们的愿望，从拉什福德和凯恩那里获得了一些不错的投资回报。本周，我们希望瓦迪在上一场比赛取得不错的突破后能够强势回归，并取得几个进球，我们也希望我们的一名转会球员——希门尼斯——上一场比赛也休息了，也将带着新鲜的双腿回来，并取得一些进球/助攻。

一如既往，感谢您的阅读，我们希望 2020 年带给您健康、快乐和激动人心的 EPL 行动！新年快乐！！

EPL 幻想 GW3 重述和 GW4 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw3-recap-and-gw4-algorithm-picks-bc384ce1374b?source=collection_archive---------26-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

如果这是你第一次登陆我的幻想 EPL 博客，你可能想先看看第一部分、第二部分、第三部分和第四部分，以熟悉我们的整体方法和我们随着时间的推移所做的改进。

GW3 团队绩效总结和总体统计

我们上周的表现好于平均水平，总共得了 51 分，由于恩多姆贝勒和坎特的受伤，只有 10 名球员参加了比赛。如果拉什福德没有错过那个点球，我们会做得更好。见下文:

GW3 Total Points

本周有什么新消息？

现在已经有至少 4 场比赛了，我们将开始发布团队统计以及顶级防守/进攻，累积团队投资回报率，每支团队的总活跃球员数，开始识别整体上表现不佳/表现超过或使用大量团队轮换的团队，从长远来看，这将使从这些团队中选择球员的价值降低。

GW3 整体统计数据为我们的 GW4 选择提供信息

首先，我们将查看 FDR_score(接下来 3 个对手的难度),以决定我们可能要从哪些球队中排除挑选球员:

Watford, Brighton, Leicester, and Norwich FDR ≥ 3.56

由于接下来三场比赛的平均对手实力较高，我们的算法将不会从以下球队中选择球员— 沃特福德，布莱顿，莱斯特和诺维奇(抱歉普基球迷:P)。接下来三场比赛赛程相对轻松的好球队是:曼城、切尔西、埃弗顿、曼联和西汉姆。

接下来，我们将按职位看一下前 10 名 ROI 玩家是谁:

投资回报率排名前十的守门员

按投资回报率排名的前 10 名防御者

投资回报率排名前十的中场球员

投资回报率排名前 10 的前锋

GW3 算法选择

提醒一下，我们的算法会考虑调整后的每队阵型的预算，并尝试最大化 11 名主力球员的每个位置的支出，然后让你的替补获得良好的 ROI 值。本周我们将打4–3–4阵型。根据当前的投资回报率得分，过滤掉任何在接下来的三场比赛中与 AVG 对手有困难(FDR ≥ 3.56)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

看起来不错的球队，银行里还有整整 400 万美元，这主要是因为我们在我们的算法开始获得最高投资回报率之前，限制了我们的算法选择的高价球员的数量。也就是说我们使用这个建议作为指导方针，并且通常会做一些我们自己的自定义更改，因为我们不能做全部 9 个替换:)

下面是我们这个周末比赛的队伍:

我们选择本周不要巴恩斯和皮特，尽管算法推荐了他们，因为伯尼将对阵利物浦，预计他们可能表现不佳。如果算法仍然推荐它们作为值，下周将很可能得到其中一个。我们选择亚伯拉罕而不是巴恩斯，因为他上场时间更长，而且他的每 90 分钟得分非常好。我们因为恩多姆贝尔的受伤而换下了他，为了节省下周的开支，我们买下了道格拉斯·路易斯。

团队统计

查看最佳/最差防守和进攻可以有几种不同的用法——例如，如果一个最佳进攻队与一个最差防守队比赛，你可能想让你的进攻中场或前锋担任队长。此外，当你查看这些位置的算法建议时，你可能想优先考虑防守最好的球队的 DF 和 GK。

最佳五种防御

最差 5 项防御

最佳 5 次进攻

最严重的 5 种犯罪

观察这些的一个副作用是，如果狼队的进攻没有改善，我们将不得不从一个更成功的进攻团队中换来一个更有效的前锋吉梅内斯(可能是普基或巴恩斯)

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是指至少玩了总可能游戏时间的 25% 的任何玩家。例如，总可能分钟数=周数* 90 分钟= 4 * 90 = 360。所以，我们把所有在队中至少打满 90 分钟的球员都计算在内。

上表中值得注意的有趣事实——曼城、利物浦、水晶宫、切尔西和西汉姆(17！！！使用更多的替补，轮换不同的球员。这意味着我们必须小心，从长远来看，我们投资这些球队的哪些球员。尽管曼城有 15 名现役球员，他们的总成本为 1.13 亿美元，但他们仍然是 avg_pts_per_player 最高的球队，这意味着许多现役球员迄今为止表现良好，价格也不算过高。切尔西、阿森纳和马刺在 avg_player_roi 排名中意外地处于下半部分，所以看起来这些球队目前为止表现不佳与他们球员的成本相比(价格过高)。伯恩利、阿斯顿维拉和狼队是综合团队投资回报率排名前三的球队，因此看起来他们的许多球员价格偏低，目前很有价值，但当然，如果他们的核心球员不能保持良好的表现，这种情况在未来 3-4 周内可能会很快改变。

最终想法:

到目前为止，这不是我们最好的开始，但是我们都知道，在一场有如此多变数和未知的比赛中，运气是一个很大的因素，但是总的来说，我们对自己的选择很满意。在前三周，我们已经遭受了一些伤病、点球失误和门将失误，这让我们损失了很多分数，除此之外，没有了 Pukki，我们做得还不错。至少在接下来的 2-3 周比赛中，我们仍然有一张王牌和一支相当平衡的球队，所以让我们给统计数据一些时间来收敛，并在几周内重新评估我们的选择逻辑，并决定我们是否需要做出一些调整。

一如既往——感谢您的阅读，祝您周末好运！

EPL 幻想 GW4 重述和 GW5 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw4-recap-and-gw5-algorithm-picks-867d3993b386?source=collection_archive---------33-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

如果这是你第一次登陆我的幻想 EPL 博客，你可能想先看看第一部分、第二部分、第三部分、第四部分和第五部分，以熟悉我们的整体方法和我们随着时间的推移所做的改进。

本周有什么新消息？

现在我们已经有 4 场比赛了，我们开始加入一个新的统计数据——“pts _ per _ 90min”，这可以帮助我们发现高价值的球员，他们没有开始前几场比赛，但最近获得了更多的上场时间，并迅速攀升，例如凯文·德布鲁因，塔米·亚伯拉罕和塞尔吉奥·阿奎罗。

我们编写了一个算法，使用这个 pts_per_90min stat 而不是 ROI 来选择最佳团队。我们需要重新校准算法来获得更多的防守者，但为了时间的缘故，我将只发布当前的球队选择，让你们知道哪些球员可能是一个长期的好投资，如果他们保持接近 90 分钟的上场时间。

以下是 pts_per_90min 统计中每个位置排名前 10 的球员。一些有趣的名字开始在这里出现，以发现那些在 GW1-GW2 期间没有得到很多时间，但在过去几周内开始获得上场时间的球员——来自 GKs 的阿德里安、科伦钱伯斯、 DFs 的乔尔·马蒂普、亚瑟·马苏阿库、凯文·德布鲁因、亚历克斯·艾奥比和来自 MDs 的哈里·威尔逊我们可能会决定在这个 GW 投资其中一些玩家，即使他们的投资回报率还没有达到，因为没有足够的游戏时间，假设这些玩家在未来的大多数游戏中游戏时间将接近 90 分钟。

GK 前 10 名 pts_per_90min

前 10 名 DF pts_per_90min

前 10 名 MD pts _ per _ 90 分钟

每 90 分钟前 10 名

GW4 团队绩效总结和总体统计

上周我们又一次表现得比平均水平好，但也比 61 分好不了多少。我在考虑让亚伯拉罕代替斯特林做队长，这本来是一个好的选择，但是，唉…我们都知道在 EPL 的幻想中“本可以，本应该”的痛苦

GW4 整体统计数据为我们的 GW5 选择提供信息

首先，我们将查看 FDR_score(接下来 3 个对手的难度),以决定我们可能要从哪些球队中排除挑选球员:

因为在接下来的三场比赛中对手的平均实力很高，我们的算法将不会从以下球队中选择球员——沃特福德，莱斯特，谢菲尔德联队和诺维奇(抱歉普基球迷:P)。接下来三场比赛赛程相对轻松的好球队是——曼城和伯恩利。

接下来，我们将按职位来看一下投资回报率前 10 的玩家是谁:

投资回报率排名前十的守门员

投资回报率排名前 10 的防御者

投资回报率排名前十的中场球员

投资回报率排名前十的前锋

GW3 算法选择

提醒一下，我们的算法会考虑调整后的每队阵容预算，并尝试最大化 11 名主力球员的每个位置的支出，然后让你的替补获得良好的 ROI 值。本周我们将打 4-3-4 阵型。根据当前的投资回报率得分，过滤掉任何在接下来的三场比赛中与 AVG 对手有困难(FDR ≥ 3.56)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

考虑到曼城接下来的赛程相当轻松，这个配置看起来一点也不差。我们考虑过使用我们的外卡，但是我们通常不喜欢在赛季早期使用，尤其是在国际比赛结束后，因为有时教练会让主要球员休息，他们回来时可能很累或者受了轻伤。

下面是我们下周的团队:

最终花了 8 分得到阿德里安、德布鲁因和阿尤，但我们认为考虑到阿德里安的便宜价格和曼城的轻松赛程，从长远来看这是值得的。我们真的很想得到阿圭罗，但只有一个完整的团队改造，包括通配符的使用将允许这一点。

团队统计

最佳五种防御

最差的 5 种防御

最佳五大犯罪

最严重的 5 种犯罪

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是指任何至少玩了总可能游戏时间的 25% 的玩家。例如，总可能分钟数=周数* 90 分钟= 4 * 90 = 360。所以，我们把所有在队中至少打满 90 分钟的球员都计算在内。

作为一个整体球队，切尔西、热刺和伯恩茅斯的表现低于上赛季的预期，平均而言，他们的球员价格似乎过高。曼城、利物浦、莱斯特、埃弗顿、曼联按照目前的表现，到目前为止价格似乎还不错。伯恩利和狼队的平均投资回报率也很高，因为他们的球员成本更低。

最终想法:

第一次我们花了 8 分进行了 3 次转会，所以很好奇他们是否会在接下来的 2-3 周内得到回报。让我们的手指交叉为阿德里安更多的不失球和凯文·德布鲁因的许多行动。希望有一个进球或者助攻。

一如既往——感谢您的阅读，祝您周末好运！

EPL 幻想 GW5 重述和 GW6 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw5-recap-and-gw6-algorithm-picks-6e529e0a9227?source=collection_archive---------29-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

因为我已经在以前的博客中详细解释了我们的整体方法和算法背后的逻辑，所以我现在将保持这篇博客更加简洁，只提供统计数据和快速评论。

GW5 团队绩效总结和总体统计

我们经历了有史以来最糟糕的一周，这让我们很受伤，因为我们决定在转会上花 8 分来得到更多失望的曼城球员。我们也摆脱了得分的拉什福德，得到了阿德里安，后者没有像我们预期的那样零失球。由于所有这些不幸的决定，我们得到了 39 分。

每 90 分钟点数统计

我们将利用这一统计数据在我们的最终团队中补充一些目前投资回报率较低的球员，但他们正在开始恢复状态，并在过去几周内接近 90 分钟的比赛。

GK 前 10 名 pts_per_90min

前 10 名 DF pts_per_90min

前 10 名 MD pts _ per _ 90 分钟

每 90 分钟前 10 名

GW4 整体统计数据为我们的 GW5 选择提供信息

首先，我们将查看 FDR_score(接下来 3 个对手的难度),以决定我们可能要从哪些球队中排除挑选球员:

由于在接下来的三场比赛中对手的平均实力很高，我们的算法将不会从以下球队中选择球员— 莱斯特，布莱顿和南安普顿。接下来三场比赛赛程相对轻松的好球队是:曼城马刺、诺维奇和伯恩利。

接下来，我们将按照职位来看一下投资回报率前 10 的玩家是谁:

投资回报率排名前十的守门员

按投资回报率排名的前 10 名防御者

投资回报率排名前十的中场球员

投资回报率排名前 10 的前锋

GW6 算法选择

提醒一下，我们的算法会考虑调整后的每队阵型的预算，并尝试最大化 11 名主力球员的每个位置的支出，然后让你的替补获得良好的 ROI 值。本周我们将打3–4–3阵型。根据当前的投资回报率得分，过滤掉任何在接下来的三场比赛中与 AVG 对手有困难(FDR ≥ 3.56)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

本周，我们试图修改选择逻辑，将 pts_per_90min 统计中的一些顶级玩家纳入顶级 ROI 玩家组合中

如果你仍然有你的外卡，并且你有一群受伤的球员，这可能是一个很好的投资组合，鉴于城市，诺维奇和马刺预计在接下来的 3 场比赛中会有一个相对容易的赛程。我们可能会在下周结束使用我们的通配符，这取决于下周的伤病和整体表现，所以请继续关注下一篇博客。

鉴于我们上周花费了太多积分，无法承受太多新的转会，以下是我们下周的团队:

我们做的唯一一次转会是用坎特威尔换来坎特，因为坎特没有保险，坎特威尔的价格开始攀升，我们想在价格超过 500 万英镑之前投资。

团队统计

最佳五种防御

最差的 5 种防御

最佳五大犯罪

最严重的 5 种犯罪

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是指已经玩了总可能游戏时间的至少 25% 的任何玩家。例如，总可能分钟数=周数* 90 分钟= 5* 90 = 450。所以，我们把所有在该队上场时间至少达到 450/4 = 112.5 分钟的球员都算在内。

一些有趣的名字开始出现在拥有不错 avg_player_ROI 的球队中——曼联、莱斯特、阿斯顿维拉、西汉姆、热刺和伯恩利与领头羊——利物浦和曼城一起进入前 8。在表现不佳的一方，我们有很多价格过高的球员——沃特福德，切尔西，水晶宫，伯恩茅斯和纽卡斯尔。

最终想法:

我们很想使用我们的通配符，选择文章开头分享的最佳球队，但我们决定等待，因为欧洲比赛和没有足够的时间来澄清哪些球员有更严重的伤病。此外，教练倾向于让关键球员在欧洲比赛中休息，所以我们不认为这是一个外卡的好时机。

一如既往——感谢您的阅读，祝您周末好运！

EPL 幻想 GW7 重述和 GW8 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw6-recap-and-gw7-algorithm-picks-ace06104fe72?source=collection_archive---------15-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

GW7 团队绩效总结和总体统计

你可能还记得，前一周我们的队长 KDB 真的收获了金牌，但本周我们的塔米·亚伯拉罕却收获了臭鸡蛋:(更令人沮丧的是，亚伯拉罕击中了门柱，并有三次一对一的机会，但却没有转化其中的一次，所以从技术上来说，我们的选择是好的，但球员就是没有兑现。这再次证明了选择一个合适的队长是多么重要。你可以在下面看到我们的分数— 只有 41 分，低于平均水平所以对我们来说这不是一个好的一周。

每 90 分钟点数统计

我们将利用这一统计数据在我们的最终团队中补充一些目前投资回报率较低的球员，但他们正在开始恢复状态，并在过去几周内接近 90 分钟的比赛。

Creswell，Yarmolenko，Chambers，Son 和丹尼·英斯是一些有趣的名字，如果我们假设他们将继续每场至少打 60 分钟，他们可能值得投资。

以下是 pts_per_90min 统计中每个位置排名前 10 的球员:

每 90 分钟 GK 前 10 名

90 分钟内前 10 名 DF 点数

90 分钟内前 10 名医学博士

每 90 分钟前 10 名

GW7 整体统计数据为我们的 GW8 选择提供信息

首先，我们将查看 FDR_score(接下来 3 个对手的难度),以决定我们可能要从哪些球队中排除挑选球员:

看起来很多球队都面临着艰难的赛程——曼联、水晶宫、利物浦、莱斯特、纽卡斯尔和狼队，所以我的算法在本周的选择非常有限。赛程比较轻松的球队有热刺、阿森纳、埃弗顿、曼城和西汉姆联(T21)。

接下来，我们将按职位看一下前 10 名 ROI 玩家是谁:

投资回报率排名前十的守门员

按投资回报率排名的前 10 名防御者

投资回报率排名前十的中场球员

投资回报率排名前十的前锋

GW8 算法精选

提醒一下，我们的算法会考虑到调整后的每支队伍的预算，并试图最大化 11 名主力队员在每个位置的花费，然后让你的替补获得良好的 ROI 值。本周我们将打 3–4–3 阵型。根据当前的投资回报率得分，过滤掉任何在接下来的三场比赛中与 AVG 对手有困难(FDR ≥ 3.56)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

我们最终决定使用我们的通配符！考虑到最近的伤病，我们没有合适的球员配置来应对阿森纳、曼城和西汉姆联应该有的轻松赛程，以及利物浦接下来三场比赛有些困难的赛程，我们选择了它。

下面是我们的团队基于 ROI 统计和 pts_per_90min 统计得出的未来一周的数据:

你可以看到我们的一些选择与 Algo 的建议不同——在法比安斯基受伤后，我们得到了罗伯特，因为西汉姆有一个更轻松的赛程，并且在 7 大防守名单中。我们也选择了梅特兰-奈尔斯和奥巴姆扬-T21，因为阿森纳的赛程应该很轻松，但是我们对这个选择有点紧张，因为我们都知道阿森纳是多么不可预测。由于通配符整个星期都是活跃的，我们可能会在最后一刻改变主意，但现在这是我们的团队。

团队统计

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是任何已经玩了总可能游戏时间的至少 25% 的玩家。例如，总可能分钟数=周数* 90 分钟= 7* 90 = 630。所以，我们把所有在该队至少打了 630/4 = 157.5 分钟的球员都算在内。

就的 avg_pts_per_player 而言，利物浦终于取代曼城成为第一球队，这是因为克洛普使用的轮换比瓜迪奥拉少得多——正如你所见，克洛普使用大约 12 名球员的核心，而瓜迪奥拉给了 16 名球员很多上场时间。其他球队似乎使用更少的轮换，从而给你更多的长期投资回报，是莱斯特，西汉姆，伯恩利，狼队，谢菲联曼联和马刺。在表现不佳的一方，我们有许多高价球员和球队轮换——沃特福德，切尔西，纽卡斯尔，布莱顿，水晶宫，诺维奇，埃弗顿，南安普顿和阿森纳。

最终想法:

我们正在开发一个令人兴奋的新功能，它将扫描世界上前 100 名玩家的球队，并将我们的算法预测与前 100 名 EPL 幻想用户最常挑选的球员进行比较。我们将尝试将这一点纳入决策过程，让我们的算法优先考虑在前 100 名球队中出现频率最高的球员。所以，请继续关注几周后即将发布的功能。

一如既往——感谢您的阅读，祝您周末好运！

EPL 幻想 GW6 重述和 GW7 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw6-recap-and-gw7-algorithm-picks-d502259faa75?source=collection_archive---------26-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

因为我已经在以前的博客中详细解释了我们的整体方法和算法背后的逻辑，所以我现在将保持这篇博客更加简洁，只提供统计数据和快速评论。

GW6 团队绩效总结和总体统计

我们上周在只有 10 名球员的情况下做得相对较好，主要是因为我们真的在我们的队长 KDB 身上获得了金牌，这只是证明了从长远来看运气是这场比赛中的一个巨大因素，因为选择正确的队长真的可以决定你一周的成败。我们在用坎特换坎特威尔的问题上损失了很多分数，但是 EPL 的数据显示坎特受伤了，这误导了我们的算法:(所以受伤数据的准确性问题是另一个问题，从长远来看，这是一个很大的因素。

每 90 分钟点数统计

我们将利用这一统计数据在我们的最终团队中补充一些目前投资回报率较低的球员，但他们正在开始恢复状态，并在过去几周内接近 90 分钟的比赛。

我们可以看到一些有趣的名字出现在这里，例如:卡勒姆·钱伯斯、塞尔日·阿吉耶、阿隆·克雷斯维尔、尼古拉斯·奥塔门迪、安德烈·亚莫伦科、卢卡斯·托雷拉、神奇的纳坎巴等等。这些球员在过去的几场比赛中获得了更多的比赛时间和相当多的分数，可能值得投资。

以下是 pts_per_90min 统计中每个位置排名前 10 的球员:

每 90 分钟 GK 10 大得分

90 分钟内前 10 名 DF 点数

90 分钟内前 10 名医学博士

每 90 分钟前 10 名

GW6 整体统计数据为我们的 GW7 选择提供信息

首先，我们将查看 FDR_score(接下来 3 个对手的难度),以决定我们可能要从哪些球队中排除挑选球员:

看起来很多球队都有一个艰难的赛程——T2、曼联、水晶宫、埃弗顿、莱切斯特、纽卡、谢菲尔德和南安普顿——所以我的算法在本周的选择非常有限。赛程比较轻松的球队有马刺、诺维奇、切尔西、伯恩利和维拉。

接下来，我们将按职位来看一下投资回报率前 10 的玩家是谁:

投资回报率排名前十的守门员

投资回报率排名前 10 的防御者

投资回报率排名前十的中场球员

投资回报率排名前十的前锋

GW6 算法选择

提醒一下，我们的算法会考虑调整后的每队阵容预算，并尝试最大化 11 名主力球员的每个位置的支出，然后让你的替补获得良好的 ROI 值。本周我们将打 3–4–3 阵型。根据当前的投资回报率得分，过滤掉任何在接下来的三场比赛中与 AVG 对手有困难(FDR ≥ 3.56)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

本周，我们试图修改选择逻辑，将 pts_per_90min 统计中的一些顶级玩家纳入顶级 ROI 玩家组合中，以增加期望值

我们决定不使用我们的通配符，因为我们觉得我们特别为这个星期有一个体面的配置，加上幻想数据团队总是在更新伤病方面很慢，所以我们期待一些最后一分钟的伤病消息可能会从周中的杯赛中出来，我们不想冒这个险。不过，我们正在考虑下周使用我们的通配符，所以请继续关注。

下面是我们下周的阵容，只有一名球员转会——迪奥普换切斯特防守。队长有几个不错的选择——亚伯拉罕、希门尼斯、萨拉赫、TAA，所以这是一个艰难的选择，但我们选择了塔米·亚伯拉罕，因为切尔西正在主场迎战布莱顿。

团队统计

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是指已经玩了总可能游戏时间的至少 25% 的任何玩家。例如，总可能分钟数=周数* 90 分钟= 6* 90 = 540。因此，我们把所有在该队上场时间至少达到 450/4 = 135 分钟的球员都算作现役球员。

一些有趣的名字开始出现在拥有不错 avg_player_ROI 的球队中——伯恩利、莱斯特、西汉姆、马刺、谢菲尔德联队和维拉与领头羊——利物浦和曼城一起进入前 8。在表现不佳的一方，我们有很多价格过高的球员——沃特福德，切尔西，水晶宫，诺维奇，埃弗顿，南安普顿，狼队和阿森纳。

最终想法:

我现在对世界上的顶级球员做了一些挖掘，从长远来看，选择一个合适的队长是多么重要，这一点变得非常明显。不可思议的是，他们几乎总是选择得分最高的球员作为队长。这给了我一个想法，我应该开始考虑写一个队长推荐系统，看看我是否能提出一些可行的东西。如果你对我训练我的模型应该看的统计有任何想法/建议，请给我发消息。

一如既往——感谢您的阅读，祝您周末好运！

EPL 幻想 GW8 重述和 GW9 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw8-recap-and-gw9-algorithm-picks-b618c5291762?source=collection_archive---------39-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

如果这是你第一次登陆我的幻想 EPL 博客，你可能想先看看第一部分、第二部分、第三部分、第四部分和第五部分，以熟悉我们的整体方法和我们随着时间的推移所做的改进。我在这个项目中的犯罪搭档是 Andrew Sproul，他和我一样对数据科学、人工智能和幻想 EPL 充满热情。

这个星期有什么新闻？

我们很高兴地宣布，本周我们整合了三项新功能:

EPL 100 强选手最佳混编团队
调整后的 FDR(夹具难度等级)
更准确的伤情更新

下面是每个新功能的简要介绍，以及我们的新算法产生的一些见解和发现的可视化。

100 强 EPL 选手最佳混编团队

我们使用 Selenium 编写了一个 web scraper，它扫描世界上排名前 100 位的球员的球队，并返回他们每周挑选的球队阵容以及他们选择的完整球队。长期的想法是每周跟踪他们的选择，并找出第 8 周前 100 名球员中的哪些人也将在赛季结束时进入前 100 名。这将帮助我们区分真正一致的幻想用户，并允许我们对他们的每周选择进行更完整的分析，帮助他们在整个赛季保持强劲的表现。

下面你可以看到目前前 100 名 Fantasy 用户对每个位置选择最多的玩家:

最佳守门员

大多数选定的捍卫者

最佳中场球员

入选最多的前锋

我们使用这些数据和当前的球员价格来创建下面的球队，这是由前 100 名中最受欢迎的球员组成的:

前 100 名 Fantasy 用户选择最多的团队

下面你可以看到上周顶尖选手挑选的阵型。似乎大多数顶级球员选择了3–4–3 阵型，很可能试图优化他们的进攻球员所获得的总积分，这些球员通常有更高的机会获得助攻、进球和总积分。

调整后的 FDR(夹具难度等级)

我们的第二个新功能的灵感来自于这样一个事实，即我们现在有足够的来自过去八个游戏周的数据，可以开始调整 EPL 幻想数据团队在赛季初根据他们自己对历史团队表现的计算提供的原始团队实力评级。下面是原始团队实力指数的样子:

正如你所看到的，这看起来有点太死板，而且在大部分中间分数中没有足够的细微差别。我们的目标是根据当前赛季的团队表现构建我们自己的团队实力指数，然后将其与上面的原始 FDR 指数相结合，这将为我们提供最终的动态调整团队实力分数，该分数将根据团队在整个赛季中每周的表现随时间而变化。

Team_Strength_Index =(总积分+进球数+进球数)

为了使数据正常化，我们使用了每个指标的百分位数，因此数据分布保持在 0-100 之间的标准化范围内。例如，利物浦现在有24 分，在这个指标的第 100 百分位，他们也有最好的防守，GA = 6，第二好的进攻，GF = 14，分别在第 100 和第 95 百分位。所以，他们当前赛季的总表现/实力得分= 100+ 100 + 95 = 295。您可以在下面看到所有其他团队的分数:

这个动态的分数允许我们在两端发现更多的异常值，并区分真正好的团队和真正差的团队。如你所见，沃特福德、诺维奇、埃弗顿、南安普顿和纽卡斯尔与其他球队相比都表现不佳。曼联、狼队和伯恩茅斯的平均得分为 152 分，只有五支球队超过了第 75 百分位——利物浦、曼城、阿森纳、莱斯特和伯恩利，切尔西和水晶宫紧随其后。

接下来我们要做的是应用一个最小最大值定标器，取上面这个分布的 z 分数，对它们求平方，得到一个类似的数据分布，但是在一定的范围内，我们可以将它与原始 FDR 分数混合:

最终的混合分数是我们的动态团队力量 z 分数和原始刚性 FDR 分数的 AVG(参见下面的新团队排名):

正如你所看到的，这看起来比最初的 FDR 表公平得多，最初的 FDR 表将团队放在严格的整数分数桶中，分数范围从 2-5，不允许任何细微差别。今后，我们将使用这种调整后的 _FDR 分布来通知我们的算法选择。话虽如此，让我们看看罗斯福本周的数据:

如你所见维拉、水晶宫、南安普顿、曼联和沃特福德在接下来的三场比赛中似乎有更难的特点，所以我们的算法会避免从这些球队中挑选球员。切尔西、伯恩茅斯、西汉姆、曼城、阿森纳和莱斯特似乎赛程相对轻松，所以从这些球队中挑选球员可能是一项不错的投资。

更准确的伤势更新

我们本周增加的最后一个新功能是抓取一个比幻想网站更新 EPL 受伤新闻更频繁和更准确的网站，所以我们可以将它纳入我们的算法，避免挑选没有在幻想网站上更新的受伤球员。我们从以下网站获取受伤数据:

[## 英超受伤和停赛-英超受伤

西汉姆联队:铁锤帮确认罗伯特·斯诺德格拉斯退出了苏格兰 2020 年欧洲杯阵容…

www.premierinjuries.com](https://www.premierinjuries.com/)

至此，我们结束了我们的功能更新部分，并继续我们每周发布的幻想 EPL 博客的核心格式。

GW8 团队绩效总结和总体统计

嗯…GW8 是艰难的，我相信这也适用于我们的大多数读者:)大多数大球队和昂贵的球员失望，这导致了所有幻想用户的 AVG 总得分为每个幻想队 38 分，这是非常低的。我们实际上比 AVG 做得更好，有44 分，所以我们并不太沮丧，但是我们觉得我们的外卡的时机没有发挥作用并且再次我们没有选择一个好的队长，尽管如果奥巴在第 95 分钟进球的话事情会好一点。

GW8 整体统计数据为我们的 GW9 选秀权提供信息

让我们通过 ROI 和 pts_per_90min 统计数据来看看顶级球员:

投资回报率排名前十的守门员

90 分钟内排名前 10 的守门员

按投资回报率排名的前 10 名防御者

pts _ per _ 90min 排名前 10 的防守队员

投资回报率排名前十的中场球员

90 分钟 pts _ per _ 强中场

投资回报率排名前 10 的前锋

射手前 10 名由 pts_per_90min

GW9 算法选择

提醒一下，我们的算法会考虑调整后的每队阵型的预算，并尝试最大化 11 名主力球员的每个位置的支出，然后让你的替补获得良好的 ROI 值。大多数星期我们一直在玩3–4–3阵型，现在我们知道世界排名前 100 的球员大多选择相同的阵型，我们会更倾向于继续使用它。根据当前的投资回报率得分，在接下来的三场比赛中过滤掉任何具有 AVG 对手难度(FDR ≥ 3.21)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

正如你所看到的，甚至还有 0.7%的预算可以使用，并为一些关键职位尝试不同的选择。由于我们上次使用了通配符，我们无法选择上面的完整配置。相反，我们进行了两次转移:

Pukki — OUT — Vardy — IN

英镑—出局— KDB —入局

鉴于莱切斯特相对轻松的赛程，我们的替补是由我们想要得到 Vardy 的愿望决定的，为了做到这一点，我们必须卖掉 Sterling，这很好，因为我们认为他的价格有点过高，如果他从伤病中恢复并持续比赛，KDB 比他更有价值，这是最新的伤病更新所说的。此外，斯特林本周只为英格兰踢了两场比赛，所以他很可能不会在本周末为曼城踢满 90 分钟。

对于队长，我们在塔米·亚伯拉罕和瓦迪之间犹豫了一下，但选择了塔米，因为到目前为止纽卡在最差的 5 个防守名单中，而伯恩利在最好的 5 个防守名单中，所以我们期待切尔西比莱斯特进更多的球。我们对希顿和克雷斯韦尔的受伤感到紧张，梅特兰-奈尔斯不会上场，但我们会看到…

团队统计

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是指已经玩了总可能游戏时间的至少 25% 的任何玩家。例如，总可能分钟数=周数* 90 分钟= 8* 90 = 720。所以，我们把所有至少打了 720/4 =【T20 =】180 分钟的球员都算作该队现役球员。

统计数据现在开始很好地融合，我们可以开始注意到一些有用的见解。例如由于曼城的球员轮换率更高，他们的 avg_player_roi stat 显著下降,因为到目前为止，他们在比赛期间至少轮换了 16 名活跃球员，而其他大多数球队的活跃球员为 13-14 名。切尔西、热刺、曼联、埃弗顿和伯恩茅斯由于更高的球员轮换和许多高价球员，整体表现仍然不佳。

在 avg_pts_per_player 和 avg_player_ROI 统计数据的上半部分，我们可以发现伯恩利、莱斯特、西汉姆、狼队、谢菲尔德联队和阿斯顿维拉是使用更紧密的 13-14 岁现役球员核心的球队，这些球员也表现出色，价格偏低，这使得从这些球队购买球员成为一项良好的长期投资。当然，利物浦和曼城位居前两名，但是他们的大部分球员都相当昂贵，所以人们必须明智地从这两支球队购买球员，并寻求长期价值。

最终想法:

我们计划的下一个令人兴奋的功能是在即将到来的比赛中纳入来自体育博彩者的系数，因为大多数主要博彩公司都有数据科学家和分析师团队，他们使用大量数据来估计最佳系数，所以我们认为我们可以借鉴他们的工作，并使用这些系数以某种方式通知我们的算法选择，或者至少进一步调整我们的 FDR 分数。

一如既往——感谢您的阅读，祝您周末好运！

EPL 幻想 GW9 重述和 GW10 算法精选

原文：https://towardsdatascience.com/epl-fantasy-gw9-recap-and-gw10-algorithm-picks-d595f02b6d6e?source=collection_archive---------27-----------------------

我们的钱球方法的幻想 EPL(队 _id: 2057677)

这个星期有什么新闻？

在受到幻想之神又一周的惩罚后，我们决定引入一个新的安慰功能，主要是为了让像我和安德鲁这样的人对他们糟糕的 GW 统计数据感觉良好:)

十大奇幻用户统计——每周我们都会绘制出世界前 10 名玩家在那一周的表现，包括前 10 名玩家的 AVG、最小和最大得分。这可以用来衡量我们自己的表现，所以如果我们度过了糟糕的一周，但我们的分数仍然接近前 10 名，那么我们至少可以自我感觉更好:)请享受下面的第一份“安慰食物”……(你可以感谢我们的这一善举:P 通过给文章一些掌声和分享，它可以帮助将博客推向趋势部分，这有助于它获得更多的观众。提前感谢！)

GW9 世界排名前十的选手

因此，如果你本周得分接近 44 分，你实际上可以自我感觉良好，因为这是世界前 10 名球员的 AVG 得分。而如果你和我们一样得了 32 分:(，要知道 Top10 里还有一个球员得分比你少——25 分！

现在我们让你感觉温暖和模糊，是时候面对另一个艰难的 GW9 的音乐，看看所有其他有趣的数据。

EPL 100 强球员最佳混合团队

当我们谈论世界前 100 名球员的话题时，让我们看看谁是他们球队中按位置选择的前 10 名球员，以及 GW9 最喜欢的球队阵型。

前 100 名最佳守门员

前 100 名中最受欢迎的捍卫者

前 100 名最佳中场球员

前 100 名中入选最多的前锋

我们使用这些数据和当前的球员价格来创建下面的球队，这是由前 100 名中最受欢迎的球员组成的:

这是一个看起来不错的团队，银行里还有 210 万英镑可以用来玩和测试不同的配置。

前 100 名 Fantasy 用户选择最多的团队

GW9 团队绩效总结和总体统计

我们认为这不会比去年的 GW 更糟糕，但显然——它会……正如你在下面看到的，我们最终只得到 32 分——低于 AVG 本周的 37 分。我们实际上可以做得更好，但是5 名防守队员中有 4 名神秘受伤，所以我们最终只和 1 名防守队员，以及总共 9 名队员一起比赛。鉴于这一点，以及我们选择了一个糟糕的队长(再次！？)，我们觉得自己做得还行。至少我们对 Vardy 的投资现在有了回报:)

GW8 整体统计数据为我们的 GW9 选秀权提供信息

下面让我们从调整后的未来三周的对手难度等级(FDR)开始:

看起来本周我们有很多球队的赛程都很艰难——维拉、南安普顿、利物浦、水晶宫和热刺。我们的算法是这样写的，它不会在本周推荐从这些球队购买球员。赛程相对轻松的球队(如果 EPL 有这种东西的话:P)有伯恩茅斯、曼联、诺维奇、切尔西和西汉姆、所以从这些球队得到球员可以在接下来的三场 2-3 比赛中得到回报。

GW9 算法选择

提醒一下，我们的算法会考虑调整后的每队阵型的预算，并尝试最大化 11 名主力球员的每个位置的支出，然后让你的替补获得良好的 ROI 值。大多数星期我们一直在玩3–4–3阵型，现在我们知道世界排名前 100 的球员大多选择相同的阵型，我们会更倾向于继续使用它。根据当前的投资回报率得分，在接下来的三场比赛中过滤掉任何具有 AVG 对手难度(FDR ≥ 3.15)的球队，并从可用选择列表中删除受伤的球员，我们的算法选择了以下球队作为当前花费全部 1 亿美元预算的最佳球队:

我们在那里插上了马内，尽管利物浦的 FDR 本周很高，因为我们有太多的剩余预算，不想留下太多的额外资金。如果你好奇的话，该算法最初的选择是阿达马·特劳雷的马内，剩余约 600 万美元。

就我们团队而言，考虑到本周晚些时候的欧洲比赛，我们决定等到周五再决定制造什么样的替补。上周我们已经因为 3-4 个意外的伤病焦头烂额，所以我们希望本周至少有 11 名健康的球员，而不是像上周那样只有 9 名。

团队统计

最佳 7 项防御

最差的 7 种防御

最佳 7 项犯罪

最糟糕的 7 项罪行

累积团队投资回报统计

下面你可以看到球队，按累积玩家投资回报率排序。请注意，活跃玩家是指已经玩了总可能游戏时间的至少 25% 的任何玩家。例如，总可能分钟数=周数* 90 分钟= 9* 90 = 810。所以，我们把所有至少打了 810/4 = 202.5 分钟的球员都算作是该队的现役球员。

列斯特、谢菲尔德联队、狼队、伯恩利队、西汉姆联和维拉队的排名开始变得有趣起来。正如你所看到的，所有这些球队都只使用13-14 名核心球员，并且到目前为止表现超出预期，这使得从这些球队获得球员在长期预期 ROI 方面是一项很好的投资。

下半区有一些常见的嫌疑人，但也有一些球队，如热刺、埃弗顿、曼联、阿森纳和切尔西，主要是因为球员轮换率较高对 AVG 为 15-16，以及球队表现不佳，有许多价格过高的球员，这似乎不是一个好的投资。

最终想法:

今天我们将以“最后的祈祷”来结束，而不是“最后的想法”。我们向幻想之神祈祷，希望他们本周能给我们一些怜悯，保佑我们有一个由 11 名健康球员组成的完整阵容，这样我们至少可以最大化我们的期望，结束我们的糟糕表现。另外，如果他们本周祝福我们的队长有额外的速度、力量和投篮准确性，我们也不会不高兴:)

一如既往——感谢您的阅读，祝您周末好运！

EPL 幻想是一个星期了，我们的算法已经准备好了！

原文：https://towardsdatascience.com/epl-fantasy-is-one-week-away-and-our-algorithm-is-ready-to-play-78afda309e28?source=collection_archive---------14-----------------------

(团队编号:2057677)

我们击败 EPL 幻想游戏的摇钱树方法

这是我们去年文章的延续，我和我的朋友 Andrew Sproul 写了一些 Python 代码来创建一个球员推荐系统，用于每周根据球员成本、上场时间和每花一美元的总点数(ROI)来选择最佳的 EPL 梦幻队。

您可以在这里阅读完整的文章，其中详细解释了我们的分析和代码逻辑:

https://towards data science . com/beating-the-fantasy-premier-league-game-with-python-data-science-cf 62961281 be

这个新博客将尝试每周跟踪我们球队的进展，并在每周转会窗口关闭前发布球队的建议。下面你可以看到我们的算法根据上赛季每个球员的赛季末总 ROI 统计数据为 EPL 2019-2020 赛季的开始推荐的球队。

游戏周 1 最佳投资回报率团队:

GK:
[('乔丹·皮克福德'，5.5)，('卢卡什·法比安斯基'，5.0)]
DF:
[('维吉尔范迪克'，6.5)，('安德鲁·罗伯特森'，7.0)，('路易斯·切廷莫雷拉马里尼奥'，6.0)，('埃梅里克·拉波尔特'，6.5)，('塞萨尔·阿兹皮利奎塔'，6.0)
MD:【T8][('穆罕默德萨拉赫'，12.5)，('拉希姆斯特林'，12.0)，('瑞安弗雷泽'，7.5)，('卢卡

注意:我们需要修复代码，因为正如你在上面看到的，算法只选择了 14 个球员，而不是 15 个，但我们将在未来几天内尝试修复这个问题。

我在 EPL 幻想中调整后的团队名称——“算法”

因为我们的推荐系统目前没有考虑每支球队面对的对手，所以我对算法推荐的实际球队做了一些定制调整。我仍然选择上个赛季投资回报率超过 20%的球员，而且只比最初推荐的球员低几个百分点。以下是我为游戏周 1 选择的配置:

最终注释:

正如你们大多数以前玩过 EPL 幻想游戏的人所知道的那样，运气仍然是游戏中的一个主要因素，因为伤病和选择哪些球员留在替补席上以及谁是你选择的队长，所以仍然有很多人工决策和随机噪音涉及到赛季结束时最终赢家的最终结果。也就是说，我们仍然很兴奋地测试我们能比普通玩家做得更好，只要遵循简单的钱球方法，并试图在赛季结束前优化总预算以获得最大投资回报。

我们还将在整个赛季中努力改进代码，使其更加动态，我将尽我所能在这里发布更新。

同时，祝所有玩家好运，如果有任何问题，请随时联系我们！

更新:

下面你可以看到我们团队在游戏周 1 中的表现:

链接到新博客，其中包含更新的算法规则和游戏周 2 的最佳 ROI 团队建议，如下所示:

https://medium . com/@ pruchka/EPL-fantasy-game week-1-stats-and-algorithm-recommendations-for-smart-picks-23 B4 c 49 CAE 8

Erlang/Elixir 解决方案:为质量而奋斗

原文：https://towardsdatascience.com/erlang-elixir-solutions-struggle-for-quality-2bd0a63de057?source=collection_archive---------25-----------------------

@jcutrer

今天，我们将讨论日志、量化指标以及如何观察它们，以提高团队反应速度，并在发生事故时减少系统等待时间。

Erlang/OTP 作为开发分布式系统的框架和思想，为我们提供了规范的开发方法、合适的工具和标准组件的实现。让我们假设我们已经开发了 OTP 的潜力，并且已经从原型一直到生产。我们的 Erlang 项目在生产服务器上感觉非常好。代码库在不断发展，新的需求和功能一起出现，新的人加入团队。一切都很好吗？然而，有时可能会出错，任何技术问题加上人为因素都会导致崩溃。

由于您无法涵盖所有基础并预见所有潜在的故障和问题危险，因此您必须通过适当的管理和软件解决方案来减少系统等待时间。

任何信息系统都存在不同性质的故障风险，例如:

硬件和电源故障
网络故障:配置错误以及固件损坏或过期
逻辑错误:从算法编码问题到出现在子系统和系统边界的架构相关问题
安全问题以及网络攻击和黑客攻击，包括内部伪造

首先，我们来划分一下责任。基础设施监测将涉及网络软件和数据传输网络。这种监测可以在 zabbix 的帮助下进行。关于它的设置已经写了很多，我们不打算重复。

从开发人员的角度来看，访问和质量问题与错误和性能问题的早期检测以及对它们的快速响应密切相关。为此，您需要特定的方法和评估工具。好吧，让我们试着找出量化指标。通过在项目开发和运行的不同阶段对它们进行分析，我们可以显著地提高其质量。

构建系统

让我们再次回顾一下，工程方法在测试和开发软件中是多么重要。Erlang/OTP 提供了两种测试框架:eunit 和 common test。

我们可以使用成功的或有问题的测试的数量、它们的运行时间和测试覆盖率作为对代码库及其动态的主要评估的度量。这两个框架都使我们能够在 Junit 中保存测试结果。例如，对于 rebar3 和 ct，您需要将以下内容添加到 rebar.config 中:

{cover_enabled，true}。
{cover_export_enabled，true}。
{ct_opts，[
{ct_hooks，[{cth_surefire，[{path，" report . XML " }]} }
]}。

成功和失败测试的数量使得建立趋势图成为可能。

通过查看它，您可以评估团队的表现并测试回归。例如，你可以在 Jenkins 中使用测试结果分析器插件得到这样的图形。度量的使用允许您注意到并防止中断或减慢项目测试，并在发布之前修复问题

应用指标

除了操作系统指标，应用程序指标也应包括在监控中。它可能是每秒页面浏览量、支付次数和其他重要指标。

在我自己的项目中，我使用代码模板 ${application}。${metrics_type}。${name} 用于命名指标。这种命名有助于获得如下度量列表

messaging . systime _ subs . messages . delivered = 1654

messaging . systime _ subs . messages . proxied = 0

messaging . systime _ subs . messages . published = 1655

messaging . systime _ subs . messages . skipped = 3

我们拥有的指标越多，就越容易了解一个复杂系统中正在发生的事情。

Erlang 虚拟机指标

应该特别注意 Erlang 虚拟机监控。“让它崩溃”的思想真是太棒了，正确使用 OTP 肯定会帮助您恢复应用程序和进程。但是别忘了 Erlang VM 本身:虽然很难让它崩溃，但还是有可能的。所有潜在的情况都是基于资源耗尽。让我们列出最受欢迎的几个:

原子表溢出。

原子作为标识符，其主要目的是提高代码的可读性。一旦创建，它们将永远留在 Erlang VM 内存中，因为它们不会被垃圾收集器清除掉。这是为什么呢？垃圾收集器在每个进程中处理这些进程数据。反过来，原子可能分布在多个进程的数据结构中。默认情况下可以创建 1，048，576 个原子。在关于杀死 Erlang VM 的文章中，您可能会遇到类似的情况:

用[list _ to _ atom(integer _ to _ list(I))| | I

as an illustration of the above-mentioned effect. This problem looks quite artificial and unlikely to happen in real systems. There have been cases, though… For instance, in an an external API handler in queries analysis binary _ to _ atom/2代替binary _ to _ existing _ atom/2，或者用 list_to_atom/1 代替list _ to _ existing _ atom/1。

要监控原子状态，可以使用以下参数:

Erlang:memory(atom _ used)—原子使用的内存
Erlang:system _ info(atom _ count)—系统中创建的原子数量。

与 Erlang:system _ info(atom _ limit)一起，可以计算原子的利用率。

流程泄露。

值得一提的是，当达到 process_limit (+P 参数 erl)时，erlang vm 并没有崩溃，而是陷入了失修状态——在这种情况下，甚至连接到它似乎都是不可能的。最终，由于内存分配给泄漏进程而耗尽内存将导致 erlang vm 崩溃。

为了监控流程状态，让我们使用以下参数:

Erlang:system _ info(process _ count)—本地节点上当前存在的进程数。与Erlang:system _ info(process _ limit)一起，您可以计算进程的使用情况。
erlang:memory(processes)—当前为 Erlang 进程分配的内存总量。
Erlang:memory(processes _ used)—Erlang 进程当前使用的内存总量。

邮箱溢出。

生产者流程在没有确认挂起的情况下向消费者流程发送消息就是一个很好的例子。与此同时，消费者流程中的 receive 由于丢失或错误的模式而忽略消息。因此，所有邮件都存储在邮箱中。如果处理器无法处理，Erlang 有一种机制可以减慢发送方的速度。然而，在可用内存耗尽后，虚拟机还是会崩溃。

在 etop 的帮助下，您可以了解您是否有任何邮箱溢出问题。

$ erl-name etop @ host-hidden-s etop-s Erlang halt-output text-node dest @ host-set cookie some _ cookie-tracing off-sort msg _ q-interval 1-lines 25

有问题流程的数量可以作为持续监控的衡量标准。为了识别这些过程，可以使用以下函数:

top_msq_q()->

[{P，RN，L，IC，ST} || P = 1000，[{，RN}，{，IC}，{_，ST}]

This list can also be logged. In this case, the analysis of the problem is simplified after getting a notification from monitoring.

二进制溢出。

大型(超过 64 字节)二进制文件的内存是在堆上分配的。分配的内存单元有一个引用计数器，显示可以访问它的进程的数量。重置计数器后，将执行清理。就这么简单，没错。然而，有一些小问题。例如，有可能出现一个进程会产生太多的垃圾，以至于系统没有足够的内存来进行清理。

erlang:内存(二进制)作为监控的指标。它显示了为二进制文件分配的内存。

总之，我们已经提到了所有导致虚拟机崩溃的案例。然而，继续监控其他同样重要的参数似乎是合理的，这些参数可能会直接或间接影响应用程序的正常运行:

ETS 表内存: erlang:内存(ets) 。
编译模块的内存: erlang:内存(代码)。如果您的解决方案不使用动态代码编译，则可以排除此参数。
应该有一个具体的参考 erlydtl。如果您动态编译模板，beam 会被创建并加载到 vm 内存中。它还会导致内存泄漏。
系统内存:二郎:内存(系统)。显示了运行时 erlang 使用的内存。
总内存利用率: erlang:内存(总)。当前为 Erlang 进程分配的内存总量。
关于减少的信息: erlang:统计(减少)
准备执行的所有进程的计数:Erlang:statistics(run _ queue)
Vm 正常运行时间:Erlang:statistics(runtime)—使您无需分析日志就能了解是否有重启
网络活动: erlang:统计(io)

向 zabbix 发送指标

让我们创建一个包含应用指标和 erlang vm 指标的文件。我们会在 N 秒内更新一次。对于每个 erlang 节点，指标文件必须包括所有应用程序指标和 erlang vm 指标。最终，我们应该有这样的东西:

messaging . systime _ subs . messages . delivered = 1654

messaging . systime _ subs . messages . proxied = 0

messaging . systime _ subs . messages . published = 1655

messaging . systime _ subs . messages . skipped = 3

….

erlang.io.input = 2205723664

erlang.io.output = 1665529234

erlang.memory.binary = 1911136

erlang.memory.ets = 1642416

Erlang . memory . processes = 23596432

Erlang . memory . processes _ used = 23598864

erlang.memory.system = 50883752

erlang.memory.total = 74446048

erlang.processes.count = 402

erlang.processes.run_queue = 0

erlang.reductions = 148412771

….

在zabbix _ sender的帮助下，我们将把这个文件发送到 zabbix，在那里可以使用图形表示，并且可以创建自动化和通知触发器。

现在，在我们的监控系统中，有了指标以及自动化和通知触发器，我们有机会避免失败和故障。这是因为我们能够提前对所有偏离全功能模式的危险做出反应。

中央日志收集

如果一个项目中只有几台服务器，那么没有集中的日志收集也是可行的。然而，当出现具有大量服务器、集群和环境的分布式系统时，就需要处理日志收集和查看。

为了在我的项目中执行日志记录，我使用 lager。在从原型到生产的过程中，项目会经历以下日志收集阶段:

最简单的日志记录是将日志下载到本地文件，甚至是 stdout (lager_file_backend)
集中日志收集，例如使用 syslogd 并将所有日志自动发送到收集器。对于这样的方案， lager_syslog 是最优的。但是，主要的缺点是，您必须访问日志收集器服务器，找到包含所需日志的文件，并以某种方式过滤事件，以搜索调试所需的事件。
集中日志收集，保存到带有过滤器和搜索机会的存储库中。

现在，是时候讨论使用后一种日志收集类型的优点、缺点和量化指标了。我们将通过某个实现的例子来实现它——lager _ click house，我在我的大多数项目中都使用它。关于 lager_clickhouse 有几件事要说。这是一个将事件保存到 clickhouse 的大型后端。到目前为止，这是一个内部项目，但有计划将其公开。在 lager_clickhouse 开发过程中，有必要绕过某些 clickhouse 特性。例如，使用事件缓冲是为了不要过于频繁地查询 clickhouse。努力得到了回报，工作稳定，表现良好。

这种保存到存储库的方法的主要缺点是创建了一个额外的实体——click house。在这种情况下，你必须编写保存事件的代码，以及搜索和分析事件的用户界面。此外，对于一些项目，使用 tcp 发送日志可能是至关重要的。

在我看来，优点超过了所有可能的缺点:

快速方便地搜索事件:

按日期过滤，而不必在包含各种事件的中央服务器上搜索一个或多个文件。
按环境过滤。来自不同子系统(通常来自不同集群)的日志被写入同一个存储。目前，有一种按标签划分的方式。每个节点都可以用一个或一组标签来标记，这些标签在节点的配置文件中定义。
按节点名过滤。
根据发送消息的模块名称进行过滤。
按事件类型过滤
文本搜索

下面的屏幕截图展示了日志查看器界面的一个示例:

2.完全自动化该过程的可能性。通过实现日志存储，可以获得关于错误数量、关键问题和系统性能的实时数据。实时分析这些数据并施加一些限制，我们可以为系统的非功能状态生成警告，并以自动模式处理它:执行脚本来管理问题并发送通知:

在严重错误的情况下
在爆发错误的情况下
某个度量标准是事件生成速度，因为日志中会出现许多新事件。您几乎总能知道单位时间内由 project 生成的日志的估计值。如果超过了，肯定是出问题了。

紧急事件自动化主题的进一步发展是 lua 脚本的实现。任何开发人员或管理员都可以编写脚本来处理日志和指标。脚本带来了灵活性，使您能够创建自动化和通知的个人场景。

结果

指标和日志，以及分析它们的适当工具，对于了解系统内的流程和调查事件至关重要。我们对系统的了解越多，就越容易分析其行为并在早期阶段解决问题。如果我们的措施没有很好地发挥作用，我们总是有图表和详细的日志供我们使用。

您如何利用 Erlang/Elixir 解决方案？在生产中遇到过什么有趣的案例吗？

神经网络中的误差分析

原文：https://towardsdatascience.com/error-analysis-in-neural-networks-6b0785858845?source=collection_archive---------5-----------------------

误差分析是对误差的分析。呵呵！你不必告诉我这些。事实上，整个错误分析都是直观的。但是，在实际项目中，人们往往会忽略一些要点。我们可以把这看作是一种复习，当挫折让我们忘记了基本知识时，我们可以检查一下。

有了 Pytorch 和 Tensorflow 等丰富的库，现在大多数机器学习算法都是现成的——只需实例化一个对象，并用你拥有的数据训练它。你已经准备好了！

这可以解决琐碎的教科书问题，比如读取 MNIST 数字。我们可以尝试一些配置，很快就能达到接近 100%的准确率。但是生活并不是那么简单。当我们试图解决“真正的”问题时，事情变得越来越复杂。

开发一个神经网络模型不仅仅是实例化一个 Python 对象。当我意识到我的模型不像我希望的那样准确时，我该怎么办？该不该加层？我应该修剪模型吗？我应该改变一些超参数吗？这就是错误分析的用处。

什么是错误分析

从形式上来说，错误分析指的是检查被您的算法错误分类的 dev 集合示例的过程，以便我们可以理解错误的潜在原因。这可以帮助我们优先考虑哪个问题值得关注以及关注的程度。它为我们处理错误提供了方向。

错误分析不仅仅是最后的补救操作。应该是主流发展的一部分。通常，我们从一个小模型开始，这必然会有低精度(高误差)。然后我们可以开始评估这个模型并分析误差。当我们分析并修正这些错误时，我们可以随着模型一起成长。

常见的误差来源

我们会遇到几个误差源。每个模型都有自己独特的误差。我们需要分别看待它们。但是，典型的原因是:

标签错误的数据

大部分的数据标注都追溯到人类。我们可以从网络、调查或各种其他来源提取数据。基本的输入来自人类。人类很容易出错。因此，我们应该承认，我们所有的训练/开发/测试数据都有一些错误标记的记录。如果我们的模型构建良好，训练得当，那么它应该能够克服这样的错误。

模糊的分界线

当正面和负面明显分开时，分类算法工作良好。例如，如果我们试图对一只蚂蚁和一个人的图像进行分类；分界很清楚，这应该有助于加快训练过程。

但是，如果我们要在男性和女性照片之间进行分类，就没那么简单了。我们非常了解极端情况。但是，界限并不那么清楚。这种分类自然容易出错。在这种情况下，我们必须在这条模糊的分界线附近进行更好的训练——也许在这条线附近提供更多的数据。

尺寸过拟合或欠拟合

让我们考虑一个简单的例子来理解这个概念。假设我们正在研究一个图像分类器来区分乌鸦和鹦鹉。除了大小，喙，尾巴，翅膀..最明显的区别是颜色。但是有可能这个模型不知道这种区别。因此，将小乌鸦归类为鹦鹉。

这意味着，模型无法从可用数据中学习维度。当我们注意到这一点时，我们应该尝试收集更多的数据，这些数据可以训练网络基于颜色而不是其他参数进行分类。

类似地，模型可能会过度拟合某个特定维度。假设在一个猫/狗分类器中，我们在错误记录中注意到许多深色狗被分类为猫，而浅色猫被分类为狗。这意味着，训练数据没有足够的记录来针对这种错误分类训练模型。

许多其他人

这些只是几种误差源。可能还有更多——可以通过分析错误集来发现。让我们不要“过度适应”我们的理解，将我们的分析局限于这些类型的错误。

每个错误分析都会向我们展示一组新的问题来源。但是正确的方法是识别欠拟合或过拟合的任何倾向-作为一个整体或在一个特定特征或一组特征上或在一些输入特征的特定值附近。

眼球装置

现在我们知道我们的模型有误差，并且可能有几个误差源。但是，我们如何识别哪一个呢？我们在训练集中有数百万条记录，在开发集中至少有几千条。测试集还没有出现。

我们无法评估训练集中的每条记录。我们也不能评估 dev 集中的每个记录。为了识别我们的模型产生的错误类型，我们将 dev 集分成两部分——眼球集和黑盒集。

眼球集是我们实际评估的样本集。我们可以手动检查这些记录，猜测错误的来源。因此眼球集应该足够小，以便我们可以手动工作，并且足够大，以便获得整个 dev 集的统计表示。

在分析眼球集合中的误差时，我们可以识别不同的误差源以及每个误差源的贡献。有了这些信息，我们就可以开始研究主要的误差源。当我们进行适当的修复时，我们可以继续挖掘更多的错误来源。

请注意，分析应仅基于眼球集。如果我们使用整个开发集进行分析，我们将会过度适应开发集。但是如果 dev 集不够大，我们必须使用它的全部。在这种情况下，我们应该注意到我们有过度适应开发集的高风险——并相应地计划其余部分。(也许我们可以使用一个循环开发集——每次尝试时，我们从训练集中挑选一个新的开发集。)

偏差和方差

当我们进行误差分析时，我们识别一个特定的参数或问题区域；或者我们注意到误差相当一致。我们从这里怎么走？我能得到更多的数据吗？这听起来可能合乎逻辑。但并不总是如此。更多的数据可能并不总是有所帮助——超过某一点，任何更多的数据都可能是多余的。我需要更丰富的模型吗？通过过度拟合，仅仅丰富模型就可以极大地改善数字。这也不对！那么我们如何决定方向呢？

偏差和方差让我们对此有了很好的了解。简而言之，如果训练集和开发集的误差都很大，那么我们就有很大的偏差。而如果训练集是好的，但开发集是坏的，我们有很高的方差。偏差本质上意味着输出对所有数据都是坏的。方差意味着输出对某些数据是好的，对其余的是坏的。

如果我们的模型在训练集上有 60%的准确率。我们自然称之为高偏差。有了这种准确性，我们甚至可能不想检查 dev 集。但是，如果训练集误差比我们的目标好得多，留下 dev 集，我们可以称之为高方差。这是因为，模型的行为在可用数据上变化很大。

人们可以直观地说，如果我们有一个高偏差，这意味着我们不适合。这可能是因为某个特定的特征没有被正确处理，或者模型本身不够丰富。基于此，我们可以更新解决方案以提高性能——通过增强特定的功能或模型本身。

另一方面，高方差意味着我们没有对它进行足够的训练。我们需要更多的数据，或者对现有数据进行更好的处理。有了这个，我们也许能训练出一个更好的模型。

减少偏差

机器学习模型只能从它可用的数据中学习。输入数据中有些错误是不可避免的。这不是人类的错误，而是对模型进行分类或测试的人类的真正局限性。例如，如果我不能区分一对同卵双胞胎，我就没有办法生成标记数据并教机器去做！

这种限制被称为不可避免的偏见。剩下的是可以避免的偏见——我们需要关注这一点。因此，当我们进行错误分析，当我们试图找出错误的主要原因时，我们应该考虑可避免的偏差，而不是作为一个整体的偏差。

如果我们的误差分析告诉我们，可避免的偏差是误差的主要来源，我们可以尝试以下步骤

增加模型尺寸

高偏差意味着模型不能从可用的数据中学习到它能学到的所有东西。当模型没有足够的学习能力时，就会发生这种情况。如果模型只有两个参数，那么它只能知道这两个参数。除此之外，任何新的训练数据都将覆盖它从以前的记录中学习到的内容。该模型应该有足够的参数来学习，只有这样它才能保存完成所需工作所需的信息。

因此，解决高偏差的主要方法是建立一个更丰富的模型。

允许更多功能

我们数据清理的一个主要步骤是减少所有冗余特征。事实上，没有一个功能是真正多余的。但是有些没有其他的有意义。特征约简实质上丢弃了价值较低的特征，从而丢弃了一些低价值的信息。

这是一个好的开始。但是，当我们注意到我们拥有的特征不能携带所需的信息时，我们必须重新进行特征减少步骤，并允许更多的特征通过。这可以使模型更丰富，并给它更多的信息来学习。

减少模型正则化

所有的正则化技术本质上都保持模型参数接近于零。即防止每个参数“学习过多”。这是确保模型保持平衡的好方法。但是，当我们意识到模型无法学习足够的知识时，我们应该降低正则化级别，以便网络上的每个节点都能够从可用于训练的数据中学习更多的知识。

避免局部最小值

局部最小值是高偏差的另一个常见来源。我们可能有丰富的模型和大量的数据。但是，如果梯度下降停留在局部最小值，偏差将不会减少。有不同的方法来避免局部最小值——随机开始(用不同的初始值反复训练它)。由于每个都采用不同的路径，因此避免了局部最小值)。或者，我们可以给梯度下降增加动量，这也可以防止下降过程中出现浅最小值。

更好的网络架构

仅仅增加神经元和层数并不一定能改善模型。使用适当的网络体系结构可以确保新的层确实为 it 增加了价值。

研究人员在过去已经面对并解决了这些问题，并为我们提供了良好的模型架构，可以用来在偏差和方差之间进行更好的权衡——例如 AlexNet 、 ResNet 、 GoogleNet 和更多。与这样的架构保持一致可以帮助我们避免很多问题。

减少方差

如果误差分析指出误差的主要原因是高方差，我们可以使用这些技术之一来减少它。

添加更多培训数据

这是首要的解决方案。当我们没有足够的数据来训练网络达到最佳性能时，就会产生差异。所以主要的行动点应该是寻找更多的数据。但这有其局限性，因为数据并不总是可用的。

添加正则化

L1 或 L2 正则化被证明是减少过度拟合问题的技术，从而避免高方差。本质上，它们使每个参数更接近于 0。这意味着，不允许任何参数学习太多。如果单个参数包含大量信息，模型就会不平衡，导致过度拟合和高方差。

L1 和 L2 正则化技术有助于防止这样的问题。L1 正则化更快并且计算更简单。它生成稀疏模型。自然，L2 更精确，因为它处理更精细的细节。

提前停止

当我们用可用的训练数据训练模型时，每一次迭代都会使模型对可用的数据更好一点。但是，这种迭代次数过多会导致过度拟合。人们必须为此找到中庸之道。最好的方法是尽早停止——而不是意识到我们已经超越了极限。

减少功能

特征数量越少，模型就越轻，因此过度拟合的范围就越小。我们有几个特征选择算法，如 PCA，可以帮助我们确定一个最小和正交的特征集，可以提供一种更简单的方法来训练模型。

领域知识还可以帮助我们减少功能的数量。我们还可以使用从错误分析中获得的见解来确定应该如何改变特性集，以便获得更好的性能。

减小模型尺寸

高方差或过度拟合通常意味着我们有太多的参数需要训练。如果我们没有足够的数据来训练这些参数中的每一个，初始化值的随机性会保留在参数中，从而导致不正确的结果。

缩小模型大小对它有直接影响。

使用稀疏模型

有时，我们知道模型的大小是必要的，减小大小只会减少功能。在这种情况下，我们可以考虑训练一个稀疏模型。这给出了更好的模型和更小的方差的良好组合。

模型架构

与减少偏差类似，方差也是由模型架构决定的。研究人员为我们提供了良好的模型架构，可以用来在偏差和方差之间进行更好的权衡。与这样的架构保持一致可以帮助我们避免很多问题。

摘要

我们看到，在我们训练的模型中可能有许多错误的原因。每个模型都有一组独特的误差和误差源。但是，如果我们遵循这种分析的正式方法，我们可以避免每次都重新发明轮子。

逃离实验室

原文：https://towardsdatascience.com/escaping-the-lab-ffb2278c6864?source=collection_archive---------33-----------------------

Structure Validation Concept

“生物信息学最有趣最重要的部分是……”

蛋白质组学。这就是我们的模块负责人(以及之前的生物信息学课程主任】李·拉科姆在我们专注于蛋白质信息学的一开始就试图说服我们的。从 1950 年 Pehr Edman 的工作到两次获得诺贝尔奖的弗雷德里克·桑格的努力，再到蛋白质芯片和微阵列的最新高通量技术，这个领域在短时间内取得了很大的进步。

尽管进展如此迅速，蛋白质表达的实验验证的进展却明显缓慢。我们了解了两种主要方法，其主要特征是是否涉及抗体。埃德曼开发了后者的第一个例子，此后被质谱盖过。在更受欢迎的免疫测定法中，特异性抗体通过与蛋白质结合来检测和确认蛋白质的存在。这两种方法都可以产生非常精确的结果，但是成本差异很大。不幸的是，更便宜的免疫检测依赖于从动物身上提取的抗体，这些抗体不能存活。此外，这些抗体的很大一部分没有通过验证测试(，在某些情况下，包括所有的)，并且无论如何都没有被使用。

Basic concept of ELISA: an immunoassay technique for detecting proteins (Sigma-Aldrich)

随着研究蛋白质变得越来越容易，开发抗生素替代品的紧迫性也随之增加。抗微生物肽、抗细菌单克隆抗体等正逐步走向对抗抗生素耐药性的最前沿。放大来看，在更大范围内进行药物开发的计算机模拟方法正在帮助医药、商业和伦理领域的两个宿敌改善关系。将实验从物理实验室转移到计算环境中可以节省时间和成本，并且在抗体生产方面有额外的好处，即从药物研究的早期阶段完全去除该过程。

An example of just how skewed the costs of drug development are (Next Phase)

随着模块的继续，我们了解到 TeSS 、 ELIXIR 的培训电子支持系统，该系统专为浏览和学习各种生命科学资源而构建。特别是对我们来说，这是一个参与结构生物信息学工作流程并了解如何从获得蛋白质结构(或模拟预测版本)到识别功能域和探索突变影响的机会。人们很快发现，无需进入实验室，就可以为最昂贵的药物开发、发现和临床前试验阶段做出贡献。

我们被分配了一种药物，并被要求就我们的发现制作一份适合行业的一页报告，作为使用出色的免费在线分发工具所能完成的工作的例子。你可以在下面看到我的努力。

这用了不到一周的时间，一分钱也没花。显然这只是一个起点，但是它给出了一个更好的概念，即使用当今可用的开源和开放访问资源可以快速收集和整理多少信息。

用于语义分段的 ESPNetv2

原文：https://towardsdatascience.com/espnetv2-for-semantic-segmentation-9e80f155d522?source=collection_archive---------15-----------------------

如今，许多现实世界的应用，如自动驾驶汽车，都涉及到视觉场景理解。语义分割是为视觉场景理解开辟道路的主要任务之一。然而，这是计算机视觉中计算量最大的任务之一。本文概述了在 ESPNetv2 论文中使用的高效语义分割网络。

ESPNet vs ESPNet v2:ESPNet v2(在 CVPR 19 上被接受)是一个通用架构，可以用于建模可视化和顺序数据。 ESPNetv2 用深度扩展的可分离卷积扩展了 ESPNet (在 ECCV'18 接受)并将其推广到不同的任务，包括图像分类、对象检测、语义分割、和语言建模。

源代码:我们的源代码以及不同数据集上的预训练模型可在Github上获得。

语义分割

语义分割是一个细粒度的推理任务，它预测图像中每个像素的标签。前景-背景和全场景分割任务示例如下。

Figure 1: Top row visualizes a foreground-background segmentation task (e.g. The PASCAL VOC dateset) while the bottom row visualizes a full scene segmentation task (e.g. The Cityscapes dataset).

编码器-解码器网络概述

大部分高效的分割网络，包括 ENet 和 U-Net ，都采用了编解码结构。简而言之，编码器-解码器结构包括两个组件:(1)编码器和(2)解码器。编码器将 RGB 图像作为输入，并通过执行卷积和下采样操作来学习多尺度的表示。作为下采样操作的结果，空间分辨率和精细细节丢失了。解码器通过执行上采样和卷积运算来逆转这种损失。下图显示了一个普通的编码器-解码器网络。

Figure 2: A vanilla encoder-decoder network. The green boxes in encoder and the decoder represents convolutional layers while the red and orange boxes represent down-sampling and up-sampling layers respectively.

按照惯例，编码器和解码器使用跳跃连接共享信息。这些跳跃连接已经被证明非常有效。更多详情见 U-Net 。

ESPNetv2 中的分段架构

像 ESPNet 一样，ESPNetv2 也使用编码器-解码器架构来进行语义分段，但是，它使用更强大和高效的编码和解码块:(1)用于编码器的极其高效的扩展卷积空间金字塔(EESP)模块，以及(2)用于解码器的高效金字塔池(EPP)模块。

编码器的 EESP 模块:为了提高计算效率，EESP 模块用高效的深度扩展卷积替换了 ESP 模块中计算量大的标准卷积层。图 3 比较了电潜泵和 e ESP 模块。有关这些区块的更多详细信息，请参阅我们的论文 ESPNetv2。

Figure 3: Comparison between the ESP module and the EESP module. Each convolutional layer (Conv-n: n×n standard convolution, GConv-n:n×n group convolution, DConv-n: n×n dilated convolution, DDConv-n: n×n depth-wise dilated convolution) is denoted by (# input channels, # output channels, and dilation rate). HFF denotes hierarchical feature fusion. See ESPNet and ESPNetv2 papers for more details.

解码器的 EPP 模块:子采样允许学习尺度不变表示。这些操作非常有效，是不同(和流行的)计算机视觉算法的关键组件，包括 SIFT 和卷积神经网络。为了让 ESPNetv2 能够有效地学习比例不变表示，我们引入了一个有效的金字塔池(EPP)模块，如图 4 所示。为了高效和有效，EPP 将 N 维特征映射到低维空间，比如说 M 维(N>M)，然后使用深度卷积学习**和不同尺度和**的表示。让我们假设我们有 b 分支。我们连接这些 b 分支的输出，以产生一个 bM 维空间的输出。为了便于学习更丰富的尺度间表示，我们首先打乱这些 bM 维特征图，然后使用组卷积将它们融合。然后应用逐点卷积来学习在组卷积之后获得的特征图之间的线性组合。

请注意，EESP 和 EPP 中的基本操作是相同的，即重新采样。在 EESP 中，使用扩张卷积来实现重采样，而在 EPP 中，使用上采样和下采样操作来实现重采样。

Figure 4: EPP module allows to learn scale-invariant representations efficiently. Point-wise, depth-wise, and group-wise convolutions are represented in blue, green, and purple respectively.

ESPNet 和 ESPNetv2 之间的比较

表 1 给出了使用两个广泛使用的数据集(Cityscapes 和 PASCAL VOC 2012)的在线服务器对 私有测试集 进行的定性性能比较。我们可以清楚地看到，ESPNetv2 比 ESPNet 更高效、更准确。

请注意，ESPNetv2 在图像大小为 384x384 的情况下获得了 68 的显著平均交集(mIOU)分数；为许多深度和重量级细分架构提供了具有竞争力的性能(更多详细信息，请参见PASCAL VOC 2012 排行榜)。PASCAL 数据集上广泛使用的图像大小是 512x512(或 500x500)。

Table 1: The performance of the ESPNet and the ESPNetv2 is compared in terms of FLOPs and the accuracy (in terms of mean intersection over union) on the private test set of two widely used datasets.

浓缩咖啡过滤器:分析

原文：https://towardsdatascience.com/espresso-filters-an-analysis-7672899ce4c0?source=collection_archive---------15-----------------------

我有几台浓缩咖啡机，我决定更深入地了解浓缩咖啡过滤器本身。我已经为我的金特快买了 VST 过滤器，它们绝对让我的浓缩咖啡变得更好，就像白天和黑夜一样。它们是按照严格的规格设计的；证据就在浓缩咖啡里。不摆弄机器，我怎么能确定它的过滤器是否有价值呢？我决定调查一下。

这项调查的一部分是因为购买了一台非常旧的意大利 Enrico 咖啡机。我一时兴起买了这个，因为我本来打算买一个便宜的商业 Gaggia，但它很可能是偷来的。我发现这台 Enrico 机器很便宜，然后我出发去旧金山南部，从一艘又旧又脏的船上的一个老人那里买下它。幸运的是，我没有被谋杀和吃掉。

Enrico 没有配备过滤篮，但我想我会找到一个简单的。我错了；这对恩里科来说是一个常见的问题。我确实在另一个篮子里找到了一个解决方案，一个朋友打磨了它的边缘，这样它就能适合了。我还必须添加 3D 打印件来保持它在 portafilter 中的设置。在这种迷雾中，我决定如果我继续我买咖啡机的坏习惯，我至少应该知道它们值不值。

杠杆式浓缩咖啡机由三个主要部件组成:一个煮水器、杠杆和过滤器。在恩里科号的情况下，锅炉状况良好，所以我不太担心。浓缩咖啡需要一个好的拉杆，但一个好的工匠可以从一个垃圾机器中拉出好的镜头。在我以前的办公室里，有一个咖啡先生，我从那个垃圾里拍出了好照片。过滤器通常可以更换，但有时在旧机器中，过滤器的尺寸很奇怪，所以这很棘手。

概观

对于数据，我有一些机器或访问一些，我想到了一个测量过滤器属性的好方法是通过图像处理。我的目标是测量以下内容:

孔大小
孔径变化
空穴分布
空穴分布的方差
到最近洞的距离分布
过滤器的总开口面积

我用 iPad 以最大亮度背光照明每个滤镜，然后用蓝色圆圈标注每个滤镜，以便更容易找到滤镜。

处理

我首先用多个滤镜拍摄了一张图像，但后来，我发现滤镜位于图像中心和 iPad 上的单个图像在准确性和比较方面更好。然而，这第一个图像作为一个伟大的平台，展示了图像处理完成，能够衡量我想要的。像素之间的距离是用 iPad 的长度估算的。

处理图像

缩放和注释

滤镜提取轮廓

填充并标记的过滤器轮廓

仅过滤

滤孔提取

放大的单个过滤器:

有一个奇怪的模式，几乎就像过滤器是在一个辊和展平。这种模式只有在像素保持在某个阈值以上时才会出现。

数据分析

1。孔径

首先，我们将查看每个过滤器的孔尺寸。最初，孔洞大小是通过确定每个孔洞阈值以上的像素面积并确定直径来计算的。然而，结果并没有显示我正在寻找的细节，因为它是基于整个像素。

对于不熟悉盒图的人来说，这是一个图例:

下面是仅由阈值(th)以上的像素确定的孔直径的方框图。正如你所看到的，一些过滤器没有显示出任何大小的变化，仅仅是因为该方法在分辨率方面无效。

取而代之的是，我确定了一个面积，这个面积是由穿过这个洞的光的强度来加权的。如果一个像素完全是白色，它的权重为 1。这允许对孔径进行亚像素估计。彩色图是与盒状图相同的数据，其中方案是喷射颜色方案，所以红色是分布中的最大计数，深蓝色接近零。

最终的清单扩展到我所有的机器和一些额外的。差异很大，我的标准是 VST 滤波器。他们声称过滤器上的孔径存在+/-0.02 毫米的差异。根据这些测量结果，他们肯定能做到这一点。

让我们调整图表，专门查看分布情况，不要担心具体的孔直径。这张图表显示了为什么我的金快速过滤器是可怕的相比，VST 的。然而， Odea Giro 却相当令人印象深刻。我没想到会有这么多。 Kompresso 和 Flair 也表现非常出色，这是对优质机器的赞美。

2。孔分布

对于孔分布，我计算了所有孔的所有质心之间的 Delaunay 三角剖分，然后查看连接过滤孔的所有边的距离。人们可以假设相似的距离将允许咖啡均匀地流过过滤器。

下面左边是一个 VST 过滤器从每个洞的三角测量。唯一的问题是有两种不同的边长:正方形和对角线。右边的图是点与点之间的距离分布，这种双峰分布并不能提供一个可用的度量标准。我对每个模态的标准差更感兴趣。

让我们看看是否可以使用一些颜色分布来理解同一个图形上的比较和多个分布。左边的方框图具有欺骗性，因为许多滤波器明显是双峰的。在右边，我们可以清楚地看到分布的差异。正方形网格过滤器都是双峰的，但 Flair 和炉顶过滤器(陆丹蓝和 Keleidos)。

3.到最近洞的距离

这个指标背后的想法是，浓缩咖啡是关于液体流量的。水进来，浓咖啡出来；浓缩咖啡流出的每一条路径都是一个洞。因此，如果水通过圆盘的任何部分并到达底部，人们会希望到最近的孔的距离在过滤器上是均匀的。

让我们用一个滤镜来想象一下:VST 替身

1.在左侧处，是过滤器上所有孔的图像，按照 jet 配色方案中的相对孔尺寸进行着色，其中红色较大，蓝色较小。

2.中间的和左边的是同一个图像，但是为了便于观察，所有的孔都被放大了。

3.在右侧是到 jet 配色方案中最近的孔的距离的图像，其中蓝色更近，红色更远。

这个指标应该提供一个表面上更容易理解的分布，如下图所示，带有一个箱线图和一个彩色分布。有趣的是，Flair 的最近距离如此之低，而 Kim Single/Double 的差异要大得多，这可能解释了这些过滤器中最好的浓缩咖啡比 VST 过滤器差。

从更高的角度来看，我们可以看到一些不同之处。首先，在所选择的差异度量中，什么是好的浓缩咖啡过滤器有很大的差异。第二，到最近的孔的距离以及孔的直径为机器的好坏提供了特别的洞察力。最后，一杯浓缩咖啡的客观质量很难通过这些机器以一种公平的方式来确定，但在我看来这是一个好的开始。

总的来说，意式浓缩咖啡机比看起来有更多的不同。过滤器是我制作始终如一的浓缩咖啡的关键之一。敬请期待:我计划如上所述发布颜色表示中的所有滤镜。

如果你愿意，可以在 Twitter 和 YouTube 上关注我，我会在那里发布不同机器上的浓缩咖啡照片和浓缩咖啡相关的视频。你也可以在 LinkedIn 上找到我。

我的进一步阅读:

我的咖啡设置

工匠咖啡价格过高

被盗浓缩咖啡机的故事

平价咖啡研磨机:比较

浓缩咖啡:机头温度分析

Python 中的基本概率:排列和组合

原文：https://towardsdatascience.com/essential-probability-in-python-permutations-and-combinations-7323a2ea39e5?source=collection_archive---------10-----------------------

概率论并不难，至少在数据科学入门所需的水平上是如此。自从你最后一次接触这个话题可能已经有一段时间了，如果你觉得生疏了，这篇文章可能只是一个回到正轨的方法。

Photo by Brett Jordan on Unsplash

如果你刚开始学习数据科学，快速的谷歌搜索会发现整个领域基于的 4 个主要数学主题:

线性代数
结石
统计数字
可能性

最近我讲了线性代数和微积分，所以如果你对这个话题生疏了，也可以随意阅读这些文章。然而，今天我想介绍概率论中的两个重要概念:组合和排列。

让我们从概率本身的基本定义开始:

概率是对事件发生的可能性进行量化的度量。概率量化为一个介于 0 和 1 之间的数字，粗略地说，0 表示不可能，1 表示确定。事件发生的概率越高，事件发生的可能性就越大。[1]

整个概率领域都很重要，因为不确定性和随机性几乎出现在你生活的每个方面，因此对概率有很好的了解将有助于你做出更明智的决定，也有助于理解不确定性。

在深入排列和组合之前，有一个重要的术语需要讨论一下——阶乘。

什么是阶乘？

好问题。根据维基百科:

正整数 n 的阶乘，用 n 表示！ 是所有小于等于 n[2]的正整数的乘积

您可以使用以下公式计算阶乘:

这里有一个快速动手的例子:

现在你可能想知道如何在 Python 中计算阶乘。虽然我确信各种库中存在现成的函数，但是定义自己的函数真的很容易，这正是我们要做的。

这里有一个简单的递归函数可以完成这项工作:

现在我们可以用这个函数来验证上面的例子:

好吧，那太好了，但是在现实世界中你什么时候会用到阶乘呢？

假设在某场比赛中有 5 个人，你想知道这 5 个人有多少种方式可以获得第一、第二和第三名。你可以抓起一张纸，写下每一种可能的结果，但是为什么呢？如果有 100 个人呢？

下面是如何使用阶乘来解决前面的任务:

简而言之，这叫做排列。

排列

让我们再次从定义开始，好吗:

在数学中，排列是将一个集合的成员排列成一个序列或顺序的行为，或者，如果该集合已经排序，则重新排列(重新排序)其元素。[3]

有两种主要的方法来计算排列，你是否允许重复会有所不同。让我们用一个例子来解决这个问题。

你有一个用户可以注册的网站。他们需要提供一个长度正好为 8 个字符的密码，并且字符不能重复。我们首先需要确定英语字母表中有多少个字符和数字:

字母数量:26
位数:10

总共有 36 个。所以 n = 36 。 r 则为 8 ，因为密码需要 8 个字符长。一旦我们知道了这一点，就很容易计算出唯一密码的数量，给出以下公式:

如果你继续手动计算:

或者甚至在 Python 中，这真的是一个微不足道的任务:

好吧，酷，但是我想允许我的用户重复字符。没问题，在这种情况下，我们谈论的是重复排列，公式甚至更简单:

你已经知道什么是n(36)，什么是r(8)，那么下面是解决方法:

同样，Python 中的实现很简单:

有很多密码选项。继续大声读出这个数字，我谅你也不敢。

组合

接下来的日常日程是组合。你可能想知道这些是什么，它们和排列有什么不同。让我们一步一步来。首先，这里有一个定义:

组合是从一个集合中选择项目，这样(不同于排列)选择的顺序是无关紧要的[4]

要把重点说清楚，可以考虑下面这句话:入选一个团队的一群人是同一个组，顺序无所谓。这就是组合背后的全部理念。如果你为这个团队选择了 5 名成员，你可以按名字、身高或其他因素对他们进行排序，但本质上你仍然是同一个团队——排序无关紧要。

所以，让我们用一个公式来形式化这个想法。一次取的一组 n 对象的组合 C 的数量计算如下:

现在你可以用这个等式来解决下面的问题:有多少种方法可以从 10 个人中选出 5 个人组成一个足球队？

无论排序如何，组都是相同的。那么我们来看看， n 会等于 10 ， r 会是 5 :

使用 Python 也可以轻松做到这一点:

太好了！但是现在你可能想知道是否存在一种允许重复的组合。答案是肯定的。我现在解释一下。

想象一下，你正在做一个三明治，由于某种原因，你只能使用 10 种原料中的 4 种。然而，配料不必是独特的，例如，你可以放三次奶酪和一次意大利腊肠。很好，见鬼，我也是一个喜欢奶酪的人，所以向你致敬。

但是你如何将这个想法形式化，并以数学的方式表达出来呢？答案再一次变得相当简单:

让我们用公式算出上面的例子。 n 将再次成为 10 ( 因为有 10 种不同的配料)，并且将成为 4 ( 因为你只能选择 4 个)😗*

同样，您可以使用 Python 进行验证:

干净利落。这对于一篇文章来说已经足够了。

在你走之前

虽然组合和排列在数学上很简单，但诀窍在于以这种方式来表示现实世界的问题。换句话说，在日常生活中提取 n 和 r 有时会很棘手。

虽然我在这方面帮不了你，但我希望这篇文章能让你知道，一旦获得了【n】和【r】，你能做些什么。

感谢您的阅读，一如既往，请不要犹豫，在评论区留下您的想法。

喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。

** [## 通过我的推荐链接加入 Medium-Dario rade ci

作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…

medium.com](https://medium.com/@radecicdario/membership)**

资源

[1]https://en.wikipedia.org/wiki/Probability

[2]https://en.wikipedia.org/wiki/Factorial

[3]https://en.wikipedia.org/wiki/Permutation

[4]https://en.wikipedia.org/wiki/Combination

初级概率和统计

原文：https://towardsdatascience.com/essential-statistics-for-data-science-ml-4595ff07a1fa?source=collection_archive---------15-----------------------

基本问题 4 毫升

期望值、方差、标准差、协方差、相关、协方差矩阵和相关矩阵介绍

为了获得有用的结果，数据科学家/ML 工程师必须分析数据并应用正确的模型。概率和统计是可以提高这种技能的两个研究领域。因此，我决定强调这一点，并就 Essential probNstats 4 ML 项目撰写我的第一篇文章。它的内容是基本的概率或统计概念，每个数据科学家和 ML 工程师都应该知道。

预期值

随机变量的期望值是该变量的平均值。例如，给定变量 X = [1，2，3，4，5，6]，它表示一个六面骰子，其中每一面出现的概率完全相同，当掷骰数接近无穷大时，其期望值为 E[X] = 1 ⅙ + 2 ⅙ + 3 ⅙ + 4 ⅙ + 5 ⅙ + 6 ⅙ = 3.5。期望值的等式是:

其中 x 是一个随机变量，具有分别以概率(p₁，p₂，…，pₖ)出现的有限数量的有限结果(x₁，x₂,…，xₖ)。如果所有的概率都相等(p₁ = p₂ = … = pₖ)，就像六面骰子的情况一样，那么期望值就等于简单平均值(或算术平均值)。此外，因为概率之和等于 1，所以期望值可以被认为是加权平均值，概率就是权重。

方差和标准差

方差给定一组(随机)数字，测量这些数字与其平均值相差多远。更正式地说，是随机变量(本例中为 X )与其期望值的方差的期望值，通常表示为 σ 、 s 或 Var(X) 。

通过“拆开”外部期望值和(i=1，…，n)的 X=xᵢ，其中 n 是 x 的总体大小，我们得到:

如果所有的概率都相等(p₁ = p₂ = … = pₙ)，那么方差可以写成:

这也被称为总体方差，因为我们使用 X 的所有数字(总体)进行计算。

相比之下，我们可以用一个变量总体的样本来计算方差。这被称为样本方差，用于人口太大而无法计算的情况。如果我们选择这种技术，公式是不同的:

ȳ是样本 y 的平均值(期望值), n 是该样本的总体规模。请注意，n 减去 1，这使得方差无偏。我不会详细讨论这种偏见，但是你可以在这里阅读它的来源。

找到方差后，我们可以计算该变量的标准差，即其方差的平方根。

它也由 σ 符号表示。标准差衡量一组数字的变化量。高值表示这些数字可能远离平均值。

但是为什么要计算随机变量与其算术平均值的平方，而不仅仅是简单的偏差呢？

假设以下示例中的数字是数字与其平均值的偏差的输出。

outputs of deviations of numbers from their mean

在第一个例子中，平均值是(4+4–4–4)/4 = 0，因此标准差也是 0。这显然不是这些数字变化量的指标。如果我们计算绝对值的平均值，(|4|+|4|+|-4|+|-4|)/4=4，我们得到的不是 0。这看起来是一个很好的指标，但是如果我们在第二个例子中计算平均值呢？(|1|+|-6|+|7|+|-2|)/4=4 该值与第一个值相同，即使数字分布得更远。通过对数字求平方并计算其标准差，两种情况下的输出分别为√((4 +4 +4 +4 )/4)=4 和√((7 +1 +6 +2 )/4)=4.74…这看起来不错，因为第二种情况有更大的标准差。

协方差和相关系数

协方差是两个随机变量联合概率的度量。它显示了这些变量的相似性，这意味着如果一个变量的较大值和较小值主要对应于第二个变量的值，则协方差为正。如果情况相反，那么协方差就是负的。如果它近似等于零，则变量彼此独立。对于两个变量 x 和 y，它通常表示为 cov(X，y)或 σ(X，Y) 并且它的正式定义是:它们与它们各自的期望值(算术平均值)的偏差的乘积的期望值。

通过“拆开”外部期望值，但是对于(i = 1，…，n ),x=xᵢ和 Y=yᵢ之间的 pᵢ具有相等的概率，我们得到:

更普遍的是:

以上是人口协方差。我们可以使用适用于样本方差的相同规则来计算样本协方差。我们只是使用无偏版本:从每个变量中取相同数量的大小为(n)的观测值，计算它们的期望值并用 1/(n-1)代替 1/n。

协方差的一个特例是当两个变量相同时(一个变量与其自身的协方差)。在这种情况下，它等于该变量的方差。

现在，如果我们将两个变量的协方差除以它们的标准差的乘积，我们将获得皮尔逊相关系数。它是协方差的归一化，因此它具有+1 和-1 之间的值，并且用于使量值可解释。

协方差和相关矩阵

它是一个方阵，描述了两个或多个变量之间的协方差。随机向量 X 的协方差矩阵通常由 Kxx 或σ表示。例如，如果我们想计算三个变量(X，Y，Z)之间的协方差，我们必须如下构造矩阵:

每个单元格都是行变量与其对应的列变量之间的协方差。你可能已经注意到，矩阵的对角线包含了协方差的特殊情况(一个变量与其自身的协方差),因此代表了该变量的方差。你可能观察到的另一件事是，矩阵是对称的，对角线下的协方差值与对角线上的相同。

使用相同的逻辑，可以构建皮尔逊相关系数矩阵，其中每个协方差除以其对应变量的标准偏差的乘积。在这种情况下，对角线总是等于 1，这表示总的正线性相关。

摘要

我们看到了一些基本概念，如期望值、方差、标准差、协方差、相关性、协方差矩阵和相关矩阵。这些构成了研究更复杂的概率或统计概念的基础，并且是许多重要算法(如 PCA)的构建模块。

参考

布朗利，J. (2019)。机器学习的线性代数基础:探索 Python 中数据的数学语言。(1.7 版)。

皮尔斯罗德。(2019 年 10 月 10 日)。“标准差和方差”。数学很有趣。于 2019 年 12 月 10 日从http://www.mathsisfun.com/data/standard-deviation.html检索

维基百科贡献者。(2019 年 12 月 10 日)。预期值。在维基百科，免费百科。检索于 2019 年 12 月 11 日 12:08，来自https://en.wikipedia.org/w/index.php?title=Expected_value&oldid = 930177129

维基百科贡献者。(2019 年 12 月 9 日)。方差。在维基百科，免费百科。检索时间:2019 . 12 . 11 12:09，发自【https://en.wikipedia.org/w/index.php?title=Variance】T2&oldid = 929926047

维基百科贡献者。(2019 年 12 月 2 日)。标准差。在维基百科，免费百科。检索到 2019 年 12 月 11 日 12:09，来自https://en.wikipedia.org/w/index.php?title =标准差& oldid=928934524

维基百科贡献者。(2019 年 12 月 7 日)。协方差。在维基百科，免费百科。检索时间:2019 年 12 月 11 日 12:10，来自https://en.wikipedia.org/w/index.php?title=Covariance&oldid = 929639677

维基百科贡献者。(2019 年 10 月 21 日)。皮尔逊相关系数。在维基百科，免费百科。检索时间 2019 年 12 月 11 日 12 点 11 分，来自https://en.wikipedia.org/w/index.php?title = Pearson _ correlation _ coefficient&oldid = 922293481

假设检验的要点和要避免的错误

原文：https://towardsdatascience.com/essentials-of-hypothesis-testing-and-the-mistakes-to-avoid-b50079d35ee5?source=collection_archive---------16-----------------------

[## 想在数据科学方面变得更好吗？

当我在我发布独家帖子的媒体和个人网站上发布新内容时，请单击此处获得通知。](https://bobbywlindsey.ck.page/5dca5d4310)

假设检验是科学方法的基石，也是科学进步的基石。它允许你调查你感兴趣的事情，并告诉你你应该对结果感到多么惊讶。侦探会告诉你是否应该继续调查你的理论，或者把精力转移到其他地方。你吃的减肥药真的有效吗？你到底需要多少睡眠？人力资源部要求的团队建设练习真的有助于加强你和同事之间的关系吗？

社交媒体和新闻充斥着“研究表明这一点”和“研究表明那一点”，但是你怎么知道这些研究是否有效呢？对他们来说有效意味着什么？虽然研究肯定会受到数据收集过程的影响，但本文的大部分内容将专注于实际的假设检验本身，以及为什么熟悉它的过程将为您提供一套必要的技能，来执行可重复、可靠和可操作的检验，从而使您更接近真相，并对研究提出质疑。

在任何假设检验中，你都有一个默认假设(零假设)和你感兴趣的理论(替代假设)。无效假设是假设你正在研究的任何干预/理论都没有效果。例如，如果你正在测试一种药物是否有效，无效假设会表明该药物没有效果，而另一个假设会假定它有效果。或者你可能想知道公司网站的重新设计是否真的对销售产生了影响——零假设是重新设计对销售没有影响，另一个假设是有影响。

假设检验有点像和朋友唱反调，但你们两个都出去收集数据，进行可重复的测试，并确定你们中的哪一个更有可能是正确的，而不是只是兜圈子。本质上，拥有一个零假设确保你正在研究的数据不仅与你的任何理论一致，而且与你的理论的否定不一致(即零假设)。

假设检验的工作原理

一旦确定了你的无效假设和替代假设，你需要进行测试。跳过一堆数学公式，大概是这样的:

进行一次实验(这是你收集数据的地方)。
假设零假设为真，让 p 值成为得到至少和你得到的结果一样极端的结果的概率。
如果 p 值相当小(即< 5%), your results are statistically significant which gives you evidence to reject the null hypothesis; otherwise, the null hypothesis can’t be ruled out just yet.

You might be wondering why a p-value of 5% could mean that your results are statistically significant. Let’s say your null hypothesis is that condoms don’t have an effect on STD transmission and you assume this to be true. You run your experiment, collect some data, and turns out you get some results that were very unlikely to get (meaning the probability of getting those results was really small). This might cause you to doubt the assumption you made about condoms having no effect. Why? Because you got results that were very rare to get, meaning your results were significant enough to cast doubt on your assumption that the null hypothesis was true.

Just like with most things in life, you want to minimize your probability of being wrong, including when performing a hypothesis test. So consider the ways you could be wrong when interpreting the results of a hypothesis test: you can either reject the null hypothesis when it’s actually true (a Type I error), or fail to reject it when it’s actually false (a Type II error).

Since you can’t decrease the chance of both types of errors without raising the sample size and you can’t control for the Type II error, then you require that a Type I error be equal to 5% which is a way of requiring that any statistically significant results you get can only have a 5% chance of being a coincidence. It’s damage control to make sure you don’t make an utter fool of yourself and this restriction leaves you with a 95% confidence when claiming statistically significant results and a 5% margin of error.

The statistically significant results in the above condom example could have been a fluke, just coincidence, but it’s only 5% likely. Even though there’s sound reason for having a small p-value, the actually threshold of 5% happens to be a convention created by Ronald Fisher, considered to be the father of modern statistics. This convention exists so that when a scientist talks about how they achieved statistically significant results, other scientists know that the results in question were significant enough to only be coincidence at most 5% of the time.

A Fuzzy Contradiction

For the mathematically literate, the null hypothesis test might resemble a fuzzy version of the scaffolding for a proof by contradiction whose steps are as such:

Suppose hypothesis, H ，则为真。
既然 H 为真，那么有些事实 F 不可能为真。
但是 F 是真的。
因此， H 为假。

与假设检验的步骤相比:

假设零假设， H 而非为真。
既然 H not 为真，那么接下来某个结果 O 是非常不可能的。
但是 O 确实被观测到了。
所以， H 不的可能性很小。

矛盾证明和假设检验步骤的区别？绝对数学确定性与可能性。你可能会认为统计学和数学一样具有确定性，但事实并非如此。统计学是一个推理框架，因此，它依赖于可能不完整或被篡改的数据；更不用说这些数据可能来自一个设置不当的实验，为过多的混淆变量留下了足够的空间。这个领域充满了不确定性，任何统计学家能够给出的最佳答案都是可能性，而不是确定性。

实际上在做假设检验

现在谈谈假设检验的技术细节。尽管统计学课程总会想办法把水搅浑，但幸运的是，测试本身并不太复杂。一旦你理解了这些细节，你就可以让计算机为你进行计算。为简单起见，假设您正在通过查看样本均值对干预对总体的影响进行假设检验。但是请记住，这个过程与其他测试非常相似。

首先，在没有干预的情况下，从你选择的人群中收集足够的数据(最好至少 30 个样本)，并计算其平均值 μ而不是。这被称为样本均值，代表总体均值，因为中心极限定理告诉你，随着样本越来越大，样本均值越来越接近总体均值。由于样本均值是一个统计量，它属于一个特殊的抽样分布，即中心极限定理所说的正态分布。

接下来，计算 μ而非的标准差，它等于 σ/sqrt(n) 其中 σ 是总体标准差， n 是样本的大小。但是既然你不知道 σ 到底是什么，你可以用样本标准差 S 来估计它，这个标准差是从有干预的人群的数据中找到的。因此，使用干预从您的群体中收集 30 多个样本，并计算其平均值 μ 和样本标准差 S 。

现在假设零假设为真，问自己，得到 μ 的概率是多少？另一种说法是， μ 距离 μ而非有多少标准差，得到结果至少距离 μ而非那么多标准差的概率是多少？如前所述，这种概率称为 p 值。

嗯，要计算 μ not 离 μ 有多少标准差，你从 μ 中减去 μ not ，除以 μ not 的标准差。结果称为标准分数或 Z 分数。

(μ-μ not)/(S/sqrt(n))

现在，得到一个至少和你得到的一样极端的标准分数的概率是多少？这与询问至少 (μ-μ not)/(S/sqrt(n)) 偏离 μ not 的概率是多少是一样的。这取决于你的替代假设的形式。

如果你的替代假设是μ≦μnot，那么标准分数的概率就是一减去正态分布的概率密度函数(pdf)的 -(μ-μ not)/(S/sqrt(n)) 到 (μ-μ not)/(S/sqrt(n)) 的积分。举个例子，如果 (μ-μ not)/(S/sqrt(n)) = 2 ，那么“1 减去上面的积分”就会求出曲线下阴影区域的面积(这就是你要找的概率):

如果你的替代假设是 μ > μ not ，那么标准分数的概率就是正态分布的 pdf 从(μ-μnot)/(S/sqrt(n)到 ∞ 的积分。假设标准分数为 2，如上例所示，这相当于试图在下图中找到面积:

同样，如果你的替代假设是 μ < μ而不是，那么标准分数的概率就是正态分布的 pdf 的 -∞ 到 (μ-μ not)/(S/sqrt(n)) 的积分。就像上面的例子一样，这一次你试图找到以下区域:

现在你已经找到了结果的概率(通过标准分数)，你可以用这个概率来决定是否拒绝零假设。假设这个概率是 3%。因此，在假设零假设为真的情况下，你在干预措施实施后从人群中收集的数据有 3%的概率发生。但它还是发生了！所以也许零假设终究不是真的。你不确定，但证据似乎表明你可以拒绝。

调整显微镜

如前所述，假设检验是一种有一定精确度的科学工具，因此，你必须仔细决定给定实验所需的精确度。一个不足的假设测试不足以检测你试图观察的任何效果。这就好比用放大镜来观察你的一个脸颊细胞。但是放大镜太弱了，无法观察这么小的东西，你还不如根本不去做这个测试。通常情况下，当研究一个小群体时，如果群体差异产生的影响刚好大到足以超过 5%的 p 值阈值，那么测试就不够有力。

乔丹·艾伦伯格在他的书《如何不犯错》中给出了一个动力不足测试的很好的例子。他提到《T4 心理科学》杂志上的一篇文章，文章发现处于排卵期的已婚女性更有可能投票给总统候选人米特罗姆尼。共有 228 名妇女接受了调查；在生育高峰期接受调查的女性中，40.4%的人表示支持罗姆尼，而在其他不排卵的已婚女性中，只有 23.4%的人表示支持罗姆尼。在如此小的人口规模下，两组女性之间的差异大到足以通过 p 值测试并拒绝零假设(即已婚女性的排卵对支持米特罗姆尼没有影响)。艾伦伯格在第 149 页继续说道:

差别太大。在喜欢米特罗姆尼的已婚女性中，有近一半每月花大量时间支持巴拉克奥巴马，这真的有可能吗？没人会注意到吗？如果一旦排卵期开始，真的会有政治上的右倾，那看起来可能会小很多。但这项研究的规模相对较小，这意味着一个更现实的效应强度评估可能会被 p 值过滤器拒绝，这是自相矛盾的。

过度研究存在相反的问题。假设进行了这样一项过度研究(即一项大规模人群研究),它表明服用一种新的降压药会使患中风的几率增加一倍。现在有些人可能会因为害怕中风而选择停止服用降压药；毕竟你有两倍的可能性。但是，如果中风的可能性最初是 8000 分之一，一个非常接近于零的数字，那么这个数字翻一番，8000 分之 2，难道还是真的接近于零吗？两次一个很小的数字还是很小的数字。

这就是标题——一项被过度压制的研究对微小的影响非常敏感，这些影响可能被认为具有统计学意义，但可能并不重要。如果一名心脏病患者在阅读了“中风几率增加一倍”的标题后，决定停止服用降压药，从而导致心肌梗塞，该怎么办？被压倒的研究拿着显微镜观察一个高尔夫球，从树木中漏掉了森林。阅读或听到此类标题时必须小心，必须提出问题。也就是说，在现实世界中，一项强有力的研究比一项弱有力的研究更受欢迎。如果测试有重要的结果，你只需要确保你以实际的方式解释这些结果。

可复制研究的重要性

xkcd on significance

在这篇文章的开头，你看到了如果零假设是真的，你仍然有 5%的可能拒绝它而选择另一个。这就是为什么你只能说你对你得到的结果有 95%的信心，因为 20 次中有 1 次，你的结果实际上根本不重要，而是由于随机的机会。而这正是上面漫画所指的。测试 20 种不同的软糖与痤疮的联系，毫不奇怪，20 种中有 1 种显示有联系。

这应该会让人们深刻认识到可复制研究的重要性，可复制研究需要遵循相同的研究步骤，但使用新的数据。用新数据重复你的研究有助于确保你不是那种只做了一次研究就发现绿色软糖对痤疮有显著统计学效果的幸运科学家。

结束语

假设检验是科学研究中的天赐之物。它允许将精力集中在更有前途的研究领域，并提供了挑战普遍持有的信念和防御有害行为的机会。既然你已经知道了如何进行假设检验，并意识到了其中的陷阱，我希望它不仅能提升你的职业价值，还能提升你的个人生活价值。

如果你喜欢我在这里写的东西，一定要看看我的 个人博客 ，在那里我有在媒体上看不到的文章。

原载于 2019 年 2 月 19 日bobbywlindsey.com。

从小的随机样本中进行估计——理解潜在的概率！

原文：https://towardsdatascience.com/estimating-from-small-random-samples-understanding-the-underlying-probabilities-at-play-91663f77669d?source=collection_archive---------25-----------------------

假设你被要求证明一个特性有多有用。比方说，你必须估计你的平台上有多少用户会从你的产品的某个特性或变化中受益。

Sampling from a population

你从 1%的用户中挑选一个“随机统一样本”。他们现在可以看到该功能。在一周的时间里，你已经计算出有 1000 个用户在积极地使用这个特性。

现在是时候让这个特性在整个流量中推广了。现在，您必须回答管理层提出的问题，即有多少用户可能从该功能中受益。

你会说 100，000，因为在 1%的随机统一样本中，有 1000 人喜欢它。听起来合理吗？

我就在这里停下来，问这个问题。

假设真的有 10 万人会喜欢这个功能并从中受益。你从这 1%的样本中得到 1000 这个数字的机会(或概率)是多少？

我认为这是人们容易感到困惑的地方。我听过回答说百分百确定。理由是这是一个完全随机的样本，或者准确地说，是随机的均匀样本！

你可以暂停阅读这篇文章，看看上面是否有道理，并找出其中的谬误。

解决这个问题的方法如下:我们需要找到以下条件概率

P(n=1000|N=100000)

其中 N=对这 1%样本感兴趣的人数，N =总体感兴趣的人数。

P(n|N)实际上是一个二项分布。让我们看看如何。

感兴趣的用户落入该样本的机会是(1 / 100)或样本百分比 s，假定它是随机均匀分布。结果是下面的公式:

代入 n = 1000 和 N = 100000 以及 s = 0.01 的值，我们得到

换句话说，期望值 1000 只有 1.2%的机会

再回忆一下，二项分布的均值是:

所以期望值确实是 1000，但是概率相当低！

我认为理解这一点很重要。我知道对 1%的随机流量样本进行测试看起来没有多大意义。让我们继续探索，看看吧！

因此，让我们尝试将样本量增加到 10%。预期值为 10，000。让我们计算同样的概率。

换句话说，尽管样本量更大，概率还是下降到了 0.4%。

另一方面，让我们尝试一个非常非常小的样本量 0.01%。

得到“期望值”10 的概率现在已经上升到接近 12.5%。

正如我们所预期的，样本量越大，我们应该能够以更高的概率获得真实值，但似乎发生了相反的情况。这里的谬误是什么？

在这一点上，重要的是不仅要看个体概率，还要看概率的分布。

Probability Distribution of “n”, given sample size = 1% and N = 10000

这表明“n”的值将主要在 900 到 1100 之间。假设我们得到 N 是 1050，我们对 N = 1050 * 100 = 105,000 的估计不是 100000。这是一个 5%的误差，人们可能会认为这不符合标准。

Probability distribution of ’n’, given sample size = 10% and N = 100000

Probability distribution of ’n’, given sample size = 0.01% and N = 100000

从上面的分布图可以看出，如果采样的“N”结果是 5，那么 N 的估计值将是 50，000，这是 50%的误差！

这就把我们带到了一个我们到目前为止还没有谈到的重要统计数据——方差。让我们看看不同样本量下的方差。

让我们看看不同 s 值的标准差。

随着样本量的增加，标准偏差急剧减小。即使样本量为 1%，标准偏差也只是平均值的 3%。

这个标准差如何帮助我对误差可控有信心？我来介绍一个概念，叫切比雪夫不等式。不要被公式弄得不知所措——我会马上解释的。

这仅仅意味着一个值偏离均值 k 个标准差的几率小于(1 / k)！

应用切比雪夫不等式，我们知道一个值距离平均值至少 3 个标准偏差的概率是 1/(3*3)小于 1/9 或大约 10%。

因此，在我们的具体示例中，如果您选择 1%的采样率，您至少可以 90%确定您获得的值与平均值的偏差不超过 10%!

我认为 90%的置信度，不超过 10%的误差，对于实际应用来说应该足够了！

PS:对于更善于观察的人来说，有一个固有的假设，即我们在此之前知道 N。这是一个稍微高级一点的话题，但是只要 N 足够大，比如说大于 5000，1%的采样率就足够了。这表明可能需要 N 的某种先验知识——至少是 N 所在的范围。

概括地说，这些教训是:

a)从样本中收集的值不会成为您想要的精确测量值，并且会与精确测量值有偏差。重要的是要了解精确测量存在多少偏差或误差。

b)选择较大的样本量可最大限度地减少偏差。在大多数情况下，1%的采样率就足够了。

这篇文章也出现在 印度分析杂志上。

估计 R 中的非线性相关性

原文：https://towardsdatascience.com/estimating-non-linear-correlation-in-r-62c6571cb1db?source=collection_archive---------6-----------------------

在本帖中，我们将学习在 r 中使用非线性相关估计函数。我们还将看几个例子。

背景

相关估计通常用于各种数据挖掘应用中。根据我的经验，非线性相关在各种过程中相当普遍。由于这个原因，非线性模型，例如 SVM，被用于回归、分类等。然而，估计两个变量之间非线性相关性的方法并不多。

通常估计线性相关性。然而，数据可能具有非线性相关性，但几乎没有线性相关性。在这种情况下，非线性相关变量有时会在高维数据的数据探索或变量选择过程中被忽略。

我们开发了一种新的非线性相关估计量nlcor。该估计器在数据探索和非线性预测模型(如 SVM)的变量选择中非常有用。

安装`nlcor`

要在 R 中安装nlcor,请遵循以下步骤:

安装开发工具包。你可以从曲柄开始操作。您可以直接在 R 控制台中输入:

> install.packages("devtools")

2.加载 devtools 包。

> library(devtools)

3.通过在 R 控制台中键入以下命令，从 GitHub 库中安装nlcor。

> install_github("ProcessMiner/nlcor")

非线性相关估计量

在这个包中，我们提供了一个在nlcor中使用自适应局部线性相关计算的非线性相关估计方法的实现。函数nlcor返回非线性相关估计值、相应的调整后 p 值以及可视化非线性关系的可选图。

相关估计将在 0 和 1 之间。该值越高，非线性相关性越强。与线性相关不同，负值在这里是无效的。由于多个局部相关计算，相关估计的净 p 值被调整(以避免假阳性)。该图显示了局部线性相关性。

下面，我们将通过几个例子来展示它的用法。在给出的例子中，x和y之间的线性相关性很小，然而，它们之间存在可见的非线性相关性。该包包含这些示例的数据，可用于测试该包。

nlcor包有几个样本x和y向量，在下面的例子中演示。

首先，我们将加载包。

> library(nlcor)

例 1。具有循环非线性相关性的数据。

> plot(x1, y1)

数据的线性相关性是，

> cor(x1, y1)
[1] 0.008001837

正如所料，相关性接近于零。我们使用nlcor来估计非线性
相关性。

> c <- nlcor(x1, y1, plt = T)
> c$cor.estimate
[1] 0.8688784
> c$adjusted.p.value
[1] 0
> print(c$cor.plot)

该图显示了数据中存在的分段线性相关性。

例 2。具有非均匀分段线性相关性的数据。

> plot(x2, y2)

数据的线性相关性是，

> cor(x2, y2)
[1] 0.828596

这一数据的线性相关性相当高。然而，数据中存在
显著且更高的非线性相关性。该
数据模拟了一个点之后相关性改变其方向
的场景。有时，变化点位于中间，导致
线性相关性接近于零。此处我们展示了一个
变化点偏离中心的例子，以表明该实施在
非均匀情况下有效。

我们使用nlcor来估计非线性相关性。

> c <- nlcor(x2, y2, plt = T)
> c$cor.estimate
[1] 0.897205
> c$adjusted.p.value
[1] 0
> print(c$cor.plot)

从图中可以看出，nlcor可以估计非均匀场景中的分段相关性。此外，非线性相关性高于线性相关性。

例 3。具有更高和多个频率变化的数据。

> plot(x3, y3)

数据的线性相关性是，

> cor(x3, y3)
[1] -0.1337304

线性相关性预期很小，尽管由于某种线性
而不接近零。

这里我们展示了我们可以细化相关性
计算的粒度。

默认设置下，nlcor的输出为:

> c <- nlcor(x3, y3, plt = T)
> c$cor.estimate
[1] 0.7090148
> c$adjusted.p.value
[1] 0
> print(c$cor.plot)

从图中可以看出，nlcor忽略了一些地方关系。我们可以通过改变refine参数来改进相关估计。refine的默认值设置为 0.5。可以设置为0和1之间的任意值。值越大，细化程度越高。

但是，更高的细化会对 p 值产生不利影响。也就是说，得到的相关性估计在统计上可能是不重要的(类似于过度拟合)。因此，建议避免过度细化。

对于该数据，我们使用refine = 0.9重新运行相关性估计。

> c <- nlcor(x3, y3, refine = 0.9, plt = T)
> c$cor.estimate
[1] 0.8534956
> c$adjusted.p.value
[1] 2.531456e-06
> print(c$cor.plot)
Warning: Removed 148 rows containing missing values (geom_path).

如图所示，nlcor可以识别粒度分段相关性。在该数据中，p 值仍然非常小——相关性具有统计显著性。

摘要

这个包提供了一种有效的启发式算法来计算数值向量之间的非线性相关性。启发式算法通过自适应地识别多个线性相关的局部区域来估计整体非线性相关。这里用几个例子来说明它的用法。

引用

打包‘nlcor’:计算非线性相关性

@文章 {ranjan2020packagenlcor，
title = { Package ' nlcor ':Compute Nonlinear Correlations }，
作者={Ranjan，Chitta and Najari，Vahab}，
期刊={Research Gate}，
年份={2020}，
doi = { 10.13140/rg . 2 . 2 . 33716 . 68480 }
}

Chitta Ranjan 和 Vahab Najari。“软件包‘nlcor’:计算非线性相关性”。在:研究门(2020)。doi:10.13140/rg . 2 . 2 . 33716.68480

nlcor:非线性相关

@ article{ ran Jan 2019 nlcor，
title={nlcor:非线性相关}，
author={Ranjan，Chitta and Najari，Vahab}，
journal={Research Gate}，
year={2019}，
doi = { 10.13140/rg . 2 . 2 . 10123 . 72488 }
}

Chitta Ranjan 和 Vahab Najari。“nlcor:非线性相关”。In:研究门(2019)。doi:10.13140/RG

使用 R 中的阿尔法形状算法估计 3D 图像的体积

原文：https://towardsdatascience.com/estimating-the-volume-of-a-3d-image-using-the-alpha-shape-algorithm-in-r-61169ac00020?source=collection_archive---------21-----------------------

在这篇文章中，我将描述一种估计 3D 图像中物体体积的方法。我在这里展示的方法——阿尔法形状算法——最近在黑客马拉松 Hacktaferme 上获得了三等奖。

本文概述:

1.解释估计 3D 点云的体积的困难以及由阿尔法形状/凹面外壳算法提出的解决方案。

2.展示如何导入和可视化。R 中的 obj 图像并访问数据点矩阵。

3.将 alpha shape 算法应用于。obj 图像来估计体积和理解 alpha 参数的效果。

4.结论和替代解决方案

1.1.为什么我们需要一种算法来估算 3D 形状的体积？

起初，估计点云的体积似乎很简单。如果我们有一个如下所示的 3D 立方体，那么我们可以使用我们在物理课上学过的公式。

Usual 3D Cube that we work with

Usual Formula for Estimating 3D Volume

如果我们有一个不同的形状，我们可以用已知的体积公式，用立方体或其他几何形状来填充它，这些的总和就是总体积，对吗？

Estimating volume on a complicated 2D shape by cutting the area in pieces.

但是在现实生活中，我们没有立方体。还有，我们没有形状。我们实际上有一个点云，这是实际的困难:找到点云的形状，这样我们可以把它切成几块，并计算每块的体积。

In an image, we have a point cloud, not a pre-defined shape. This is because of the functioning of a 3D camera which takes many points on a surface rather than complete shapes.

绘制点云轮廓有两种方法:凸形和凹形。凸形意味着一个形状不会向内弯曲，或者我们可以说不可能通过穿过形状的外部来连接形状内部的两个点。凹面是相反的:它向内弯曲，我们可以在它里面的两点之间画一个点，这个点穿过它的外面。

Concave shape (left) vs a convex shape (right).

凸轮廓是一个相对容易的问题:以最小的体积(或 2D 的表面)在所有点周围取凸的形状。但是凹轮廓估计是困难的。困难在于同一个点云可能有多个凹轮廓，并且没有数学方法来定义哪个轮廓是最好的！

The convex contour has a fixed solution, the concave contour has not.

由于凹轮廓允许向内的线，最小凹轮廓形状可以在该点云中找到几乎为 0 表面的形状，这将是一个巨大的低估。另一方面，我们看到凸轮廓是一个严重的高估。

我们需要调整凹度的大小，我在这里给出的解决方案是阿尔法形状算法。

1.2.阿尔法形状算法是如何工作的？

为了计算点云的 alpha 形状，我们需要定义一个 alpha。alpha 为 1 将导致凸包。那么α越接近零，我们形状的轮廓就越灵活。

步骤 1:使用 Delauney 三角测量法寻找凸包

在这些点之间绘制三角形，以便这些三角形之间没有重叠(这就是所谓的 Delauney 三角剖分)。这给了我们凸包(迄今为止，凸包是我称之为轮廓的官方术语)。

步骤 2:使用一个半径为 alpha 的圆过滤这个结果

那些三角形的边都有一定的长度。我们知道凸包太大了，所以我们需要删除一些三角形边界来制作一个更好的凸包。

准确的选择标准是:围绕三角形的每条边画一个尽可能大的圆。如果
1，选择边框。这个圆不包含另一个点
2。这个圆的半径小于α

Finding the alpha shape for the shape on the left (already applied Delauney Triangulation) using a large alpha (middle) and a small alpha (right). The large alpha has resulted here in the convex solution (middle) and the smaller alpha has given a concave hull (right). Another (small) alpha could have given a different concave hull.

2.在 R 中导入、可视化和访问. obj 3D 图像

为了在实践中应用凹壳算法，我们需要将 3D 图像导入到我们的编程环境中。在这个例子中，我将使用现有的 R 库。

要导入图像文件，可以使用 readobj 包中的 read.obj 函数，如左图所示。

Executing this code on a 3D image will open a viewer window to inspect your 3D object.

然后使用 rgl 库来获得可视化效果。首先，使用函数 tinyobj2shapelist3d 将您的 obj 对象转换为 shapelist ，然后使用函数 shade3d 生成一个 3d 查看器窗口，您可以使用鼠标来旋转和扭曲图像。

The viewer in R gives this interactive representation of the .obj 3D image. In my example it were 3D pictures of cows.

来访问您的。将 obj 文件导入 R 后，执行以下命令:

现在我们有了数据点的矩阵(3D 点云),我们可以开始使用 Alpha Shape 算法来估计它周围的凹面外壳，并从那里计算体积。

3.应用 alpha 形状算法并理解 alpha 参数

为了估计凹面外壳及其体积，我们使用 R 包 alphashape3d ，它有一个函数 ashape3d 在给定 xyz 矩阵和 alpha 值的情况下创建 alpha 形状，此外，还有一个 plot 函数显示发生了什么，还有一个 vvolume _ ashape3d给我们估计的体积。

完整代码如下所示，alpha 值为 0.35:

Two concave hulls of a .obj 3D image using the alpha shape algorithm with on the left alpha = 0.05 and on the right alpha = 0.35.

现在，您可以调整 alpha 参数，以制作出您需要的形状。一种方法是看形状，看哪一个最合适。另一种方法是使用验证数据来校准 alpha 形状算法:测试不同的 alpha 值，看看哪个值给出了最正确的体积估计。

你甚至可以考虑使用网格搜索来优化 alpha，这就是我们在黑客马拉松中所做的。我们的目标是从 3D 图像开始估计一头奶牛的体重，因此我们对总共 74 张图像进行了从 0 到 1、步长为 0.05 的阿尔法网格搜索，以选择与观察到的奶牛体重相关性最大的阿尔法。这导致了 0.35 的 alpha，这并没有导致体积的最佳估计，但它确实给了我们一个有用的变量，用于进一步的机器学习。

4.结论和替代解决方案

在本文中，我解释了 alpha shape 算法，并展示了如何使用它从点云中估算 3D 对象的体积。这种方法的最大优点是它允许凹形，而凸形方法是不可能的。

阿尔法形状必须校准，我已经提出了几个想法来做到这一点，即使没有校准数据。尽管校准 alpha 需要一些时间，但这种方法对于建模 3D 形状来说是一个很大的附加值，并且是 3D 图像处理的一个很好的切入点。祝你好运！

估计机器学习模型中的不确定性—第 1 部分

原文：https://towardsdatascience.com/estimating-uncertainty-in-machine-learning-models-part-1-99fde3b0cbc1?source=collection_archive---------6-----------------------

作者:Dhruv Nair，数据科学家，Comet.ml

"我们要求严格界定怀疑和不确定的领域！"

——道格拉斯·亚当斯，《银河系漫游指南》

为什么不确定性很重要？

让我们想象一下，我们正在为建筑公司 ABC 建筑公司建造一个计算机视觉模型。该公司对其空中现场监控流程的自动化感兴趣，并希望我们的算法能在他们的无人机上运行。

我们愉快地开始工作，将我们的算法部署到他们的无人机舰队上，回家后认为这个项目取得了巨大的成功。一周后，我们接到 ABC 建筑公司的电话，说无人机不断撞上他们停在所有工地上的白色卡车。你冲到其中一个站点检查视觉模型，并意识到它错误地预测白色卡车的一侧只是明亮的天空。鉴于这一预测，无人机会径直飞向卡车，以为那里什么也没有。

对现实世界中的数据进行预测时，最好对模型的预测可信度进行评估。如果需要模型来做出对人们生活有实际影响的决策，这一点尤其正确。在自动驾驶汽车、医疗保健、保险等应用中，不确定性测量有助于防止严重事故的发生。

不确定性的来源

当对任何过程建模时，我们主要关心两种类型的不确定性。

随机不确定性:这是我们试图解释的过程中固有的不确定性。例如，由于与周围空气的复杂相互作用，从桌子上方的相同位置落下的乒乓球每次都会落在稍微不同的点上。这一类的不确定性在实践中往往是不可减少的。

认知不确定性:这种不确定性归因于对最适合解释数据的模型的知识不足。这种不确定性是可以减少的，因为对手头的问题有了更多的了解。例如，通过向模型添加更多参数、收集更多数据等来减少这种不确定性。

那么我们如何估计不确定性呢？

让我们考虑这样一个例子，一家面包店试图根据进入面包店的顾客数量来估计它在一个给定的月内将出售的蛋糕数量。我们将尝试使用一个简单的线性回归模型来模拟这个问题。然后，我们将尝试从我们现有的可用数据中估计该模型中不同类型的认知不确定性。

Equation for Linear Regression

这个模型的系数受制于采样不确定性，我们不太可能从样本数据中确定模型的真实参数。因此，提供这些系数的一组可能值的估计将告知我们当前模型能够如何恰当地解释这些数据。

首先，让我们生成一些数据。我们将从经过缩放和移位的单位正态分布中对我们的 x 值进行采样。我们的 y 值只是这些 x 值的扰动。

import numpy as npfrom numpy.random import randn, randint
from numpy.random import seed# random number seed
seed(1)# Number of samples
size = 100x = 20 * (2.5 + randn(size)) 
y = x + (10 * randn(size) + 50)

我们得到的数据最终看起来像这样

Distribution of Sample Data

我们将从使用 bootstrap 抽样估计模型参数的不确定性开始。Bootstrap 采样是一种通过采样替换原始数据集来构建新数据集的技术。它生成我们数据集的变体，并能给我们一些直观的参数范围来描述数据。

在下面的代码中，我们运行 1000 次 bootstrap 采样迭代，将线性回归模型拟合到每个样本数据集，并记录系数，以及每次迭代时模型的截距。

from sklearn.utils import resamplecoefficients = []
intercepts = []for _ in range(1000):
    idx = randint(0, size, size)
    x_train = x[idx]
    y_train = y[idx]

    model = LinearRegression().fit(x_train, y_train)

    coefficients.append(model.coef_.item())
    intercepts.append(model.intercept_)

最后，我们从记录的系数中提取 97.5，2.5 个百分点。这给了我们系数和截距的 95%置信区间。使用百分位数来确定区间还有一个额外的优点，就是不需要对系数的抽样分布进行假设。

upper_coefficient = np.percentile(coefficients, 97.5)
upper_intercept = np.percentile(intercepts, 97.5)lower_coefficient = np.percentile(coefficients, 2.5)
lower_intercept = np.percentile(intercepts, 2.5)

我们现在可以使用这些系数来绘制能够描述数据的曲线族的 95%置信区间。

Confidence Interval for Model Parameters

现在让我们估计模型预测的不确定性。我们的线性回归模型预测蛋糕的平均销售数量，假设有 x 名顾客来到商店。我们预计不同的 x 值会在y 中产生不同的均值响应，我们将假设对于一个固定的 x ，响应 y 是正态分布的。

Visualizing the conditional mean

基于这一假设，我们可以使用来自我们预测的残差来近似以为条件的 y 中的方差。有了这个方差，我们就可以计算平均响应的标准误差，并使用它来建立平均响应的置信区间。这是我们对 y 的真实平均响应的近似程度的度量。这个值越小越好。**

****

Confidence Intervals of the Mean from the Standard Error of the Model

条件均值的方差取决于系数和截距的方差。标准误差就是这个方差的平方根。由于条件均值的标准误差与 x 的值与均值的偏差成正比，所以我们可以看到，随着它越来越接近 x 的均值，它会变得越来越窄。

有了置信区间，面包店就能够确定给定数量的顾客将出售的蛋糕的平均数量的区间，然而，他们仍然不知道给定数量的顾客他们可能出售的蛋糕的可能数量的区间。

置信区间仅说明 y 的平均响应的漂移。对于给定的 x 值，不提供 y 所有可能值的区间。为了做到这一点，我们需要使用一个预测区间。

预测区间以与置信区间相似的方式导出。唯一不同的是，我们在计算标准误时，包含了我们因变量 y 的方差，导致区间更宽。

Prediction Interval for the Model Predictions

结论

在评估不确定性系列的第一部分中，我们研究了在一个简单的回归模型中评估认知不确定性来源的方法。当然，当数据和模型的规模和复杂性增加时，这些评估会变得更加困难。

当我们处理大型神经网络时，自举技术不起作用，并且通过标准误差估计置信区间和预测区间仅在对模型残差和参数的采样分布进行正态假设时才起作用。当这些假设被违反时，我们如何衡量不确定性？

在本系列的下一部分，我们将着眼于在更复杂的模型中量化不确定性的方法。

作者:Dhruv Nair，数据科学家，Comet.ml

估计机器学习模型中的不确定性—第 3 部分

原文：https://towardsdatascience.com/estimating-uncertainty-in-machine-learning-models-part-3-22b8c58b07b?source=collection_archive---------18-----------------------

看看这个系列的第一部()和第二部(*)***

作者:Dhruv Nair，数据科学家，Comet.ml

在关于不确定性估计的系列文章的最后一部分中，我们讨论了大型模型的自举等方法的局限性，并展示了如何使用 MC Dropout 来估计神经网络预测的不确定性。

到目前为止，我们研究的方法包括在数据集或模型参数中创建变量来估计不确定性。这里的主要缺点是，它要求我们要么训练多个模型，要么进行多次预测，以便计算出我们的模型预测的方差。

在有延迟约束的情况下，诸如 MC 丢弃之类的技术可能不适合用于估计预测间隔。我们能做些什么来减少估计区间所需的预测次数？

用极大似然法估计区间

在本系列的第 1 部分中，我们假设因变量 μ(y|x) 、的平均响应呈正态分布。

MLE 方法包括建立两个模型，一个用于估计条件平均响应 μ(y|x) ，另一个用于估计预测响应中的方差 σ 。

首先，我们将训练数据分成两半。前半部分模型 mμ 使用前半部分数据作为常规回归模型进行训练。然后，该模型用于对数据的后半部分进行预测。

第二个模型， mσ 使用数据的后半部分进行训练，并将 mμ 的残差平方作为因变量。

****

最终预测区间可以用以下方式表示

这里 α 是根据高斯分布的期望置信水平。

让我们试一试

我们将再次使用自动 MPG 数据集。请注意，在最后一步中，训练数据是如何再次拆分的。

****Mean Variance Estimation Method**dataset_path = keras.utils.get_file("auto-mpg.data", "[http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data](http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data)")column_names = 
['MPG','Cylinders','Displacement','Horsepower','Weight',
                'Acceleration', 'Model Year', 'Origin']
raw_dataset = pd.read_csv(dataset_path, names=column_names,
                      na_values = "?", comment='\t',
                      sep=" ", skipinitialspace=True)dataset = raw_dataset.copy()
dataset = dataset.dropna()origin = dataset.pop('Origin')dataset['USA'] = (origin == 1)*1.0
dataset['Europe'] = (origin == 2)*1.0
dataset['Japan'] = (origin == 3)*1.0train_dataset = dataset.sample(frac=0.8,random_state=0)
test_dataset = dataset.drop(train_dataset.index)mean_dataset = train_dataset.sample(frac=0.5 , random_state=0)
var_dataset = train_dataset.drop(mean_dataset.index)**

接下来，我们将创建两个模型来估计数据的均值和方差

**import kerasfrom keras.models import Model
from keras.layers import Input, Dense, Dropout
dropout_rate = 0.5def model_fn():
    inputs = Input(shape=(9,))
    x = Dense(64, activation='relu')(inputs)
    x = Dropout(dropout_rate)(x)
    x = Dense(64, activation='relu')(x)
    x = Dropout(dropout_rate)(x)
    outputs = Dense(1)(x)

    model = Model(inputs, outputs)

    return modelmean_model = model_fn()
mean_model.compile(loss="mean_squared_error", optimizer='adam')var_model = model_fn()
var_model.compile(loss="mean_squared_error", optimizer='adam')**

最后，我们将标准化我们的数据，并开始训练

**train_stats = train_dataset.describe()
train_stats.pop("MPG")
train_stats.transpose()def norm(x):
    return (x - train_stats.loc['mean'])/ train_stats.loc['std']normed_train_data = norm(train_dataset)
normed_mean_data = norm(mean_dataset)
normed_var_data = norm(var_dataset)
normed_test_data = norm(test_dataset)train_labels = train_dataset.pop('MPG')
mean_labels = mean_dataset.pop('MPG')
var_labels = var_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')**

训练好均值模型后，我们可以使用它对数据集的后一半进行预测，并计算残差的平方。

**EPOCHS = 100mean_model.fit(normed_mean_data, mean_labels, epochs=EPOCHS, validation_split=0.2, verbose=0)mean_predictions = mean_model.predict(normed_var_data)
squared_residuals = (var_labels.values.reshape(-1,1) - mean_predictions) ** 2var_model.fit(normed_var_data, squared_residuals, epochs=EPOCHS, validation_split=0.2, verbose=0)**

让我们来看看这种方法产生的音程。

你会注意到高度不准确的预测在平均值附近有更大的间隔。

使用分位数回归估计区间

如果我们不想对我们的响应变量的分布作出假设，而想直接估计我们的目标变量的上限和下限，该怎么办？

分位数损失可以帮助我们估计目标百分位数反应，而不是平均反应。也就是说，预测我们目标的 0.25 分位数值将告诉我们，给定我们当前的一组特征，我们期望 25%的目标值等于或小于我们的预测。

如果我们训练两个独立的回归模型，一个用于 0.025 百分位，另一个用于 0.9725 百分位，我们实际上是说我们预期 95%的目标值落在这个区间内，即95%的预测区间****

分位数回归损失函数

让我们试一试

Keras 没有默认的分位数损失，所以我们将使用来自 Sachin Abeywardana 的跟随实现

**import keras.backend as Kdef tilted_loss(q,y,f):
    e = (y-f)
    return K.mean(K.maximum(q*e, (q-1)*e), axis=-1)model = model_fn()
model.compile(loss=lambda y,f: tilted_loss(0.5,y,f), optimizer='adam')lowerq_model = model_fn()
lowerq_model.compile(loss=lambda y,f: tilted_loss(0.025,y,f), optimizer='adam')upperq_model = model_fn()
upperq_model.compile(loss=lambda y,f: tilted_loss(0.9725,y,f), optimizer='adam')**

由此产生的预测如下所示

这种方法的一个缺点是它倾向于产生非常宽的间隔。您还会注意到，间隔并不是关于中间估计值(蓝点)对称的。

评估预测间隔

在上一篇文章中，我们引入了两个指标来评估我们区间预测的质量，PICP 和 MPIW。下表比较了我们用来估计神经网络中不确定性的最后三种方法的这些度量。

神经网络中不确定性估计技术的比较

我们看到，均值-方差估计方法产生最小宽度的区间，这导致其 PICP 分数的降低。MC 下降和分位数回归产生非常宽的区间，导致完美的 PICP 分数。

MPIW 和 PICP 之间的平衡是一个开放性的问题，完全取决于模型的应用方式。理想情况下，我们希望我们的区间尽可能紧凑，具有较低的平均宽度，并且在大多数情况下还包括我们的目标值。

结论

这些技术可以很容易地在您现有的模型上实现，只需很少的更改，并且为您的预测提供不确定性估计，使它们更值得信赖。

我希望你喜欢我们关于不确定性的系列。请继续关注此空间，了解更多精彩内容！！

从零到精通的期望和差异

原文：https://towardsdatascience.com/estimation-of-expectation-and-variance-from-zero-to-mastery-4a6e8a2038cf?source=collection_archive---------22-----------------------

直觉和数学理解从随机变量到贝叶斯统计

介绍

期望和方差是一个基本而又重要的话题。为了解决统计问题和理解机器学习，数据科学家必须深入理解这一主题。

让我们做一个快速测试来检查你的理解。

你如何从 PDF 或 CDF 中得到期望和方差？
如果 PDF 或 CDF 没有明确定义，还有什么其他方法？
什么是渐近方差？我们如何计算它，为什么它很重要？
给定我们的特征，目标变量的条件期望和条件方差是什么？如何应用于线性回归？
期望和方差如何应用于贝叶斯统计？

Photo from Escape Adulthood

基本形式和意义

预期

直观上，期望是随机变量的大量独立实现的平均值。假设 X 是我们对日降雪量的观测值，我们想估计平均降雪量。所以我们在 X 上观察了 n 个数据点，得到一个平均值——μ。

当我们得到一个分布时，我们将所有事件的值相加——x 表示一个概率。

The expectation from PMF for discrete random variables

The expectation from PDF for continuous random variables

差异

方差衡量每个数据点与平均值之间的差异。

当样本量接近无限大时，可以解释为1/观察次数*总和(每次观察值-均值)

记住方差还有另一种形式，你可能已经遇到过了。下面是推导过程

Derivation of another form of variance

这两个公式本质上是一样的。

采样离散

记住，给定样本，统计是任何可计算的东西。如果用和上面一样的公式得到样本量小的样本方差，结果会有偏差。这意味着它没有足够好地逼近潜在的人口方差。所以你需要将有偏方差乘以 n/(n-1) 得到无偏样本方差。

无偏样本方差= 1/(观察次数-1)*总和(每个观察值-平均值)

渐近方差

一、渐近是什么意思？在统计学中，它只是意味着接近无穷大的极限。这是中心极限定理的核心，当 样本量增加 时，基础样本分布越来越接近总体参数，我们说它最终将接近正态分布，呈钟形，对称形式，两边都有尾部。

也就是说，渐近方差仅仅意味着方差是基于样本数量接近无穷大的假设而近似得到的。

估计

当我们的总体分布未知时，我们估计基本分布的参数。然而，得到一个平均值并不容易，因为如果基础分布不稳定，它并不总是最好的选择。

这里有一些有用的方法来得到一个好的估计。

最大似然估计

最大似然估计是统计学中最重要的估计方法。该方法旨在找到描述观测数据的最可能的参数。要做到这一点，我们只需对我们的 pdf 取一个关于参数的偏导数，并将其设置为零。如果求导太难，有一个叫做对数似然法的技巧，我们只需对函数的自然对数求导，就能得到局部最大值。

这里有一个例子，你观察 x，发现他们遵循一个 xθe^(-x /θ的 pdf，并带有一个参数θ，你想找到一个估计量，最好地描述了基础数据。所以你取了 n 个样本，对对数似然性求导。通过以下计算，您发现最能描述基础数据的估计量是 sum(Xi )/n

Example of MLE

以下是一些负面属性:

计算复杂性。上面的例子只有一个参数。如果有多个呢？有时分布有太多的参数，对它求导是很昂贵的。
对损坏的数据不是很健壮。由于最大似然估计是基于求导，我们可能无法达到全局最大值。

达美尔法

如果我们需要求一些样本的渐近方差怎么办？如果我们的样本量很大就好了，我们可以用中心极限定理来推导它们。然而，如果我们的样本量不够大，而我们仍然想估计我们人口的潜在分布，该怎么办呢？如果我们连一个定义明确的 PDF 都没有，那么我们甚至不能用 MLE 来估计我们的分布呢？

它叫德尔塔法，利用泰勒逼近从中心极限定理得到类似的渐近结果。我不会在这里过多地谈论泰勒级数，但它是一种用微分来逼近基本函数的方法。德尔塔的方法也是如此。它对我们的参数求导，并近似具有正态分布特性的另一种形式的方差。

费希尔信息

在多元假设检验中，我们希望检验期望和方差是否都等于我们提出的参数。如果我们想找出方差的方差呢？费希尔信息给你一个均值和方差之间的协方差矩阵。有两种计算方法。

似然函数的二阶导数的期望值为负
似然函数的一阶导数的方差

矩法

这个方法允许你计算任意顺序的统计数据。比如计算 E[X ]和 E[X]可以让你同时得到期望和方差。此外，您可以将兴趣参数从一种方式映射到另一种方式。

m 估计

这种方法非常灵活。m 估计可用于估计给定𝑥的𝑌的均值、中值和分位数，甚至无需假设统计模型。

条件性和线性回归

总期望定律

E(X) = E(E[X|Y ])

一个简单的例子可以说明这个规律。假设你去买杂货。每次旅行花费多少取决于你去的是好市多(P = 0.4)还是沃尔玛(P=0.6)。平均来说，你在好市多花了 100 美元，在沃尔玛花了 80 美元。然后，您希望找出食品杂货成本的期望值，计算结果为 100 * 0.4+80 * 0.6 = 88 美元。

条件期望和条件方差

这个主题对于推导回归函数至关重要。它解释了为什么我们的函数是 Y = a+bx，它是极小值。

假设你预测给定 X 的 Y，你推导出 f(x，y)= 2X+Y 存在于[0，1]的样本空间中，给定 X 的 Y 的条件期望是什么？预测 Y 周围的可变性呢？

Conditional expectation of X given Y

这里我们确实需要理解贝叶斯规则来推导给定 y 的 X 的条件 pdf。如果你需要复习一下，我将在本文的结尾谈到它。

但首先，你需要找到边际 PDF ，它可以很容易地从关于 y 的联合 PDF 中整合出来。

要找到条件期望和条件方差，需要进行以下推导。

贝叶斯统计

介绍

比方说，如果下雪，我们在一天中以 0.2 的概率去杂货店，如果不下雪，以 0.6 的概率去杂货店。一天下雪的概率是 0.1。然后我们问自己，假如那天我们决定呆在家里，下雪的概率有多大？

例子

在贝叶斯统计中，我们结合我们的新观察来更新先验，以获得后验分布。假设我们从一袋 4 枚硬币中挑选一枚，他们的偏好分别是 0.2，0.4，0.6，0.8。你随机选一枚硬币，然后扔出去。结果是六分之三的头着地。给定这些信息，你将如何更新硬币袋的偏差？

它与方差有什么关系？

这个想法是标准差捕捉不确定性，从而给我们关于后验分布的信息。这个意义上的先验可以用 Jeffrey 的先验代替，它取 Fisher 信息的平方根。如果没记错的话，费雪信息只是基于 MLE 计算方差的另一种方式。

下次当有时要求你计算一个基本分布的期望或方差时，你要澄清一些假设:数据的函数是可计算的吗？我们的样本量是多少？我们的数据是假设正态分布的吗？我们假设任何条件吗？它是用来做什么的？这些问题将帮助你理解如何正确地计算它。

估计器、损失函数、优化器——最大似然算法的核心

原文：https://towardsdatascience.com/estimators-loss-functions-optimizers-core-of-ml-algorithms-d603f6b0161a?source=collection_archive---------7-----------------------

为了理解机器学习算法如何从数据中学习以预测结果，理解训练算法所涉及的基本概念是必不可少的。

我假设你有基本的机器学习知识，也有概率和统计的基本知识。如果没有，请浏览我之前的帖子这里和这里。这篇文章涉及到一些理论和数学，所以请耐心听我说，一旦你读到最后，当我们把这些点联系起来的时候，它会变得完全有意义。

source

评估者

估计是一个统计术语，用于在给定一些数据的情况下，找到未知参数的一些估计值。点估计是试图对某些感兴趣的量提供单一的最佳预测。

感兴趣的数量可以是:

单一参数
参数向量，例如线性回归中的权重
整体功能

点估计量

为了区分参数的估计值和它们的真实值，参数**θ**的点估计值用**θˆ** 表示。设**{x(1) , x(2) ,..x(m)}**为**m** 独立同分布的数据点。那么点估计量是数据的任何函数:

点估计量的这个定义是非常通用的，它允许估计量的设计者有很大的灵活性。虽然几乎任何函数都可以作为估计量，但好的估计量是其输出接近生成训练数据的真实基本θ的函数。

点估计也可以指输入和目标变量之间关系的估计，称为函数估计。

函数估计

这里我们试图预测一个给定输入向量 x 的变量 y .我们假设有一个函数**f(x)**描述了 y 和 x 之间的近似关系.例如

我们可以假设**y = f(x) + ε**，其中**ε** 代表**y** 中从**x**不可预知的部分。在函数估计中，我们感兴趣的是用模型或估计**fˆ**来近似**f** 。函数估计真的就跟估计一个参数**θ**一样；函数估计量**fˆ**简单来说就是函数空间中的点估计量。例如:在多项式回归中，我们要么估计一个参数***w*** ，要么估计一个从***x*** 到**y**的函数映射。

偏差和方差

偏差和方差衡量估计量中两种不同的误差来源。偏差
测量函数或参数与真实值的预期偏差。另一方面，方差提供了对任何特定数据采样都可能导致的与预期估计值的偏差的度量。

偏见

估计量的偏差定义为:

其中期望值是对数据(被视为来自随机变量的样本)的期望值，而***θ***是用于定义数据生成分布的***θ***的真实基础值。

一个估计量**θˆm**被称为是无偏的，如果**bias(θˆm) = 0**，这意味着
即**E(θˆm) = θ**。

方差和标准误差

估计量的方差**Var(θˆ)**，其中随机变量是训练集。或者，方差的平方根被称为标准误差，标为标准误差**SE(ˆθ)**。估计量的方差或标准误差提供了一种方法，可以衡量我们从数据中计算出的估计值在从基础数据生成过程中独立地对数据集进行重新采样时会如何变化。

正如我们可能希望估计量显示低偏差一样，我们也希望它具有相对较低的方差。

讨论了估计量的定义之后，现在让我们来讨论一些常用的估计量。

最大似然估计量

最大似然估计可以定义为从样本数据中估计参数(如均值或方差)的方法，使得获得观测数据的概率(似然性)最大化。

考虑一组从真实但未知的数据生成分布**Pdata(x)**中独立抽取的**m** 示例**X = {x(1), . . . , x(m)}**。设**Pmodel(x; θ)**是由**θ**索引的相同空间上的概率分布的参数族。换句话说，**Pmodel(x; θ)**将任何配置**x**映射到估计真实概率**Pdata(x)**的实数。
然后**θ**的最大似然估计量定义为:

因为我们假设例子是同分布的，所以上面的等式可以写成乘积形式:

由于各种原因，这种产品在许多情况下可能不方便。比如容易出现数值下溢。同样，为了找到这个函数的最大值/最小值，我们可以对这个函数 w.r.t **θ**求导，并使其等于 0。因为我们这里有产品的术语，我们需要应用链式法则，这对于产品来说是相当麻烦的。为了获得更方便但等价的优化问题，我们观察到取似然的对数并不改变其 arg max，而是方便地将乘积转换成和，并且由于 log 是严格递增的函数(自然对数函数是单调变换)，它不会影响***θ***的结果值。

所以我们有:

两个重要属性:一致性和效率

一致性:随着训练样本的数量趋近于无穷大，参数的最大似然估计收敛于参数的真值。

效率:一种测量我们有多接近真实参数的方法是通过期望均方误差，计算估计和真实参数值之间的平方差，其中期望超过来自数据生成分布的**m**训练样本。该参数均方误差随着**m** 的增加而减小，并且对于**m** 大的情况，克莱姆-拉奥下界表明没有一致的估计量具有比最大似然估计量更低的均方误差。

出于一致性和效率的原因，最大似然法通常被认为是机器学习的首选估计方法。

当示例的数量足够少以产生过拟合行为时，可以使用诸如权重衰减之类的正则化策略来获得最大似然的有偏版本，其在训练数据有限时具有较小的方差。

最大后验概率估计

遵循贝叶斯方法，允许先验影响点估计的选择。该图可用于根据经验数据获得未观察量的点估计。MAP 估计选择最大后验概率的点(或在连续θ的更常见情况下的最大概率密度):

其中在右手边，**log p(x|θ)**是标准对数似然
项，**log p(θ)**对应于先验分布。

与完全贝叶斯推理一样，MAP 贝叶斯推理的优势在于
利用了先验带来的、在
训练数据中找不到的信息。这些附加信息有助于减少
标测点估计值的差异(与最大似然估计值相比)。然而，这是以增加偏差为代价的。

损失函数

在大多数学习网络中，误差被计算为实际输出***y*** 和预测输出***ŷ***之差。用于计算该误差的函数被称为损失函数，也称为成本函数。

到目前为止，我们的主要焦点是通过 MLE 或 MAP 进行参数估计。我们之前讨论它的原因是 MLE 和 MAP 都提供了导出损失函数的机制。

让我们看看一些常用的损失函数。

均方误差(MSE): 均方误差是最常见的损失函数之一。MSE 损失函数广泛用于线性回归中作为性能度量。要计算 MSE，您需要将预测值和实际值之间的差异进行平方，然后在整个数据集内进行平均。

其中,***y(i)***是实际预期输出,***ŷ(i)***是模型预测。

机器学习中使用的许多成本函数，包括 MSE，都可以从 MLE 中导出。

为了了解我们如何从 MLE 或 MAP 中导出损失函数，这里涉及到一些数学，您可以跳过它，进入下一部分。

从最大似然法导出均方误差

线性回归算法学习取一个输入**x** 并产生一个输出值***ŷ***。选择从**x** 到***ŷ***的映射以最小化均方误差。但是我们如何选择 MSE 作为线性回归的标准呢？让我们从最大似然估计的角度来解决这个问题。我们现在不再产生单一的预测***ŷ***，而是将模型视为产生条件分布**p(y|x)**。

我们可以将线性回归问题建模为:

我们假设**y** 为正态分布，其中***ŷ***
为分布的平均值，方差固定为用户选择的某个常数**σ²** 。对于许多应用来说，正态分布是一个明智的选择。在事先不知道实数的分布形式的情况下，正态分布是一个很好的默认选择。

现在回到前面定义的对数可能性:

其中***ŷ(i)***是对第 I 个输入**x^(i)**的线性回归的输出，**m** 是训练样本的数量。我们看到前两项是常数，因此最大化对数似然意味着最小化 MSE，如下所示:

我们立即看到，最大化相对于***θ***的对数似然产生了与最小化均方误差相同的参数估计***θ***。这两个标准具有不同的值，但最优位置相同。这证明了使用 MSE 作为最大似然估计程序的合理性。

交叉熵损失(或对数损失):交叉熵度量两个概率分布之间的散度，如果交叉熵大，则意味着两个分布之间的差异大，而如果交叉熵小，则意味着两个分布彼此相似。

交叉熵被定义为:

其中 P 是真实标签的分布， Q 是模型预测的概率分布。还可以看出，交叉熵损失也可以从 MLE 中导出，我不会用更多的数学来烦你。

让我们进一步简化我们的模型:

n——观察次数
M —可能的类别标签数量(狗、猫、鱼)
y —一个二进制指示符(0 或 1)表示分类标签***C*** 是否是正确的分类用于观察***O***
p —模型预测的观察概率

二元分类

在二进制分类中(M=2)，公式等于:

在二进制分类的情况下，将每个预测概率与实际的类输出值(0 或 1)进行比较，并计算分数，该分数基于与期望值的距离来惩罚该概率。

形象化

下图显示了给定真实观测值(y= 1)的可能测井曲线损失值的范围。随着预测概率接近 1，测井曲线损失缓慢下降。然而，随着预测概率的降低，测井曲线损失迅速增加。

对数损失惩罚这两种类型的错误，但特别是那些有把握和错误的预测！

多级分类

在多类分类(M>2)中，我们取观测值中每个类预测的测井损失值的总和。

二元或两类预测问题的交叉熵实际上被计算为所有示例的平均交叉熵。Log Loss 使用负 Log 来提供一个简单的比较指标。之所以采取这种方法，是因为正对数数字< 1 returns negative values, which is confusing to work with when comparing the performance of two models. See 这个帖子详细讨论了交叉熵损失。

ML 问题和相应的损失函数

让我们看看机器学习模型中常用的输出层和损失函数有哪些:

回归问题

预测一个实值量的问题。

输出层配置:一个带线性激活单元的节点。
损失函数:均方误差(MSE)。

二元分类问题

把一个例子归为两类中的一类的问题。这个问题被设计成预测一个例子属于第一类的可能性，例如，你给这个类赋值 1，而给另一个类赋值 0。

输出层配置:一个带 s 形激活单元的节点。
损失函数:交叉熵，也称对数损失。

多类分类问题

把一个例子归为两类以上的问题。这个问题被设计成预测一个例子属于每一类的可能性。

输出层配置:使用 softmax 激活功能的每个类一个节点。
损失函数:交叉熵，也称对数损失。

讨论了估计量和各种损失函数之后，让我们理解优化器在 ML 算法中的作用。

优化者

为了最小化预测误差或损失，模型在经历训练集的示例时，更新模型参数***W***。这些误差计算在绘制***W*** 时也被称为成本函数绘制 ***J(w)***，因为它决定了模型的成本/惩罚。因此最小化误差也称为最小化成本函数。

但是你具体是怎么做的呢？使用优化器。

优化器用于更新权重和偏差，即模型的内部参数，以减少误差。

最重要的技术和我们如何训练和优化我们的模型的基础是使用梯度下降。

梯度下降:

当我们绘制成本函数***J(w) vs w***时。它表示如下:

从曲线中可以看出，存在一个参数值***W*** ，其成本***Jmin***最小。现在我们需要找到一种方法来达到这个最低成本。

在梯度下降算法中，我们从随机模型参数开始，计算每次学习迭代的误差，不断更新模型参数，以更接近产生最小成本的值。

重复直到最小成本:{

}

在上面的等式中，我们在每次迭代后更新模型参数。方程的第二项计算每次迭代时曲线的斜率或梯度。

成本函数的梯度被计算为成本函数***J*** 相对于每个模型参数***Wj*** ， ***j***取特征数量**[1 to n]**的值。***α***，阿尔法，是学习率，或者说我们希望以多快的速度向最小值移动。如果*α*太大，我们可以超调。如果***α***太小，意味着学习的步骤很小，因此模型观察所有示例所花费的总时间会更多。

梯度下降有三种方式:

批量梯度下降:使用所有的训练实例来更新每次迭代中的模型参数。

小批量梯度下降:小批量梯度下降不是使用所有的例子，而是将训练集分成更小的称为“b”的批量。因此，小批量“b”用于在每次迭代中更新模型参数。

随机梯度下降(SGD): 在每次迭代中仅使用单个训练实例更新参数。训练实例通常是随机选择的。当有成千上万或更多的训练实例时，随机梯度下降通常是优化成本函数的首选，因为它比批量梯度下降收敛得更快。

其他一些常用的优化器:

阿达格拉德

Adagrad 专门针对单个特征调整学习率:这意味着数据集中的一些权重将具有不同于其他权重的学习率。这对于缺少大量输入示例的稀疏数据集非常有用。不过，Adagrad 有一个主要问题:随着时间的推移，自适应学习率往往会变得非常小。下面的一些其他优化程序试图消除这个问题。

RMSprop

RMSprop 是由 Geoffrey Hinton 教授在他的神经网络课上开发的 Adagrad 的特殊版本。不是让所有的梯度累积动量，而是只在一个固定的窗口中累积梯度。RMSprop 类似于 Adaprop，它是另一种优化器，旨在解决 Adagrad 留下的一些问题。

圣经》和《古兰经》传统中）亚当（人类第一人的名字

Adam 代表自适应矩估计，是使用过去梯度计算当前梯度的另一种方式。亚当还利用了动量的概念，将先前梯度的分数添加到当前梯度中。这个优化器已经变得相当普遍，并且实际上被接受用于训练神经网络。

我刚刚简要介绍了这些优化器，请参考这篇文章，了解关于各种优化器的详细分析。

我希望现在你明白当你写的时候下面发生了什么:

*# loss function: Binary Cross-entropy and optimizer: Adam
**model.compile(loss='binary_crossentropy', optimizer='adam')** **or**# loss function: MSE and optimizer: stochastic gradient descent
**model.compile(loss='mean_squared_error', optimizer='sgd')***

感谢阅读。

参考资料:

[1]https://www.deeplearningbook.org/contents/ml.html

[2]https://machine learning mastery . com/loss-and-loss-functions-for-training-deep-learning-neural-networks/

https://blog.algorithmia.com/introduction-to-optimizers/

[4]https://jhui . github . io/2017/01/05/Deep-learning-Information-theory/

[5]https://blog . algorithm ia . com/introduction-to-loss-functions/

https://gombru.github.io/2018/05/23/cross_entropy_loss/

[7]https://www . kdnugges . com/2018/04/right-metric-evaluating-machine-learning-models-1 . html

[8]https://rohanvarma.me/Loss-Functions/

[9]http://blog.christianperone.com/2019/01/mle/

爱沙尼亚:全球创业公司和人工智能应用的跳板

原文：https://towardsdatascience.com/estonia-a-springboard-for-global-startups-and-ai-applications-d4d66598656b?source=collection_archive---------22-----------------------

人工智能正在席卷全球。爱沙尼亚在人工智能生态系统中处于什么位置？爱沙尼亚企业为人工智能做好准备了吗？

我们知道，与小公司相比，亚马逊、百度、脸书和谷歌等科技巨头拥有人工智能优势，如收集海量数据、接触顶级人才、对 R&D 的巨额投资。然而，人工智能提供的可能性不仅仅是为最大的公司和最大的经济体保留的。

爱沙尼亚正在寻找吸引国际人才和投资的方法；另一方面，它的面积小，资源有限，这就要求公共行政和政府有效地工作。难怪在爱沙尼亚，政府和公司都注意到了人工智能技术解决当前人口和经济挑战的潜力，因为人工智能仅在北欧对 GDP 的影响预计就相当可观:占 GDP 的 9.9%(1.8 万亿)。

爱沙尼亚今天在人工智能准备方面处于什么位置？

在欧洲，人工智能的准备程度非常高，但即使是最先进的国家也落后于美国的人工智能前沿。然而，欧洲捕捉人工智能全部潜力的能力在不同国家之间差异很大。根据欧洲人工智能生态系统的地图，四个国家在推动欧洲人工智能生态系统方面表现突出——英国、法国、德国和西班牙——并且以拥有欧洲最具活力和最成熟的人工智能景观而闻名。

根据罗兰·贝格和法国数字公司的研究，爱沙尼亚拥有从人工智能应用中受益的良好先决条件，并正在成为欧洲有影响力的人工智能玩家。

尽管欧盟人工智能应用的领导者是 67%人工智能创业公司的所在地，爱沙尼亚和其他北欧和波罗的海国家显示了密度动态，即每人口规模的创业公司数量很高。

与主导者和其他致力于人工智能战略的政府相比，爱沙尼亚认为自己是初创公司和人工智能应用的人工智能实施领导者。

例如，到 2020 年，爱沙尼亚政府已经在公共服务领域推出了 50 种不同的人工智能应用，该国最知名的规模化企业(Taxify、TransferWise、Pipedrive)以及早期人工智能初创公司(Sixfold、AlphaBlues、Feelingstream)已经转向数据和机器学习，以最大限度地提高其产品交付。

与此同时，爱沙尼亚并没有让人工智能狂潮和需要快速实施的人工智能妥协数据隐私和安全。爱沙尼亚计划确保人工智能应用程序的安全，以保护其人民和私人数据。爱沙尼亚希望成为根据隐私和安全要求开发人工智能应用的地方。

AI 实现的时代

技术专家李开复在他的书《人工智能的超能力》中认为“人工智能研究的许多困难但抽象的工作已经完成，现在是企业家卷起袖子开始将算法转化为可持续业务的时候了。”

目前哪些爱沙尼亚公司正在实施这一技术？

但首先你可能会问，是什么让一个创业公司变成了“AI 创业公司”。对于这篇文章，我们将人工智能的生产者和使用者都称为“人工智能初创公司”。很难计算爱沙尼亚创业公司和公司的总数，因为人工智能不是一种单一的技术，而是由各种元素组成。

在这篇文章中，我们将研究 13 个人工智能公司的例子，从早期创业公司到成熟的规模化公司，并展示一些政府人工智能应用程序，这些应用程序使用数据和机器学习来重塑产品，实现自动化，另一方面，展示一些更具变革性的公司，这些公司利用数据创建了新的商业模式。

星舰科技

Starship 打造了世界上第一个随时随地为你服务的包裹递送机器人。

星际飞船机器人是先进的设备，可以在半径 3 公里(2 英里)的范围内运送物品。他们的交付平台将开启一个即时、不定期交付的新时代，同时显著降低运输成本。为了让机器人尽可能安全和自主，机器人必须了解他们在哪里，周围世界正在发生什么——人类、汽车、骑自行车的人、障碍物——并预测接下来会发生什么。为了实现这一点，Starship 开发了一种软件，可以处理来自摄像机、雷达和其他传感器的输入，以实时做出驾驶决策。他们还分析历史数据，以明确了解如何进一步改进机器人。

Source: Starship Technologies

Taxify (自 2019 年 3 月 7 日起更名为 Bolt)

爱沙尼亚出生的 Taxify 已经成为世界上发展最快的独角兽，在超过 25 个国家拥有超过 1500 万乘客。Taxify 使用数据和尖端技术来了解数百万人如何在城市中移动，并利用这种洞察力来改善城市交通。这意味着接近 10 亿个峰值请求，数十万兆字节的数据，数十亿个坐标。Taxify 开发实时机器学习来改善产品、运营和决策制定，例如预测驾驶时长、为乘坐定价、优化营销活动等。

数据科学和机器学习有助于 Taxify 预测乘客在任何时间、任何地点拥有适量车辆的需求，预先计算价格并提高效率，方法是帮助乘客根据城市中数百万次之前完成的行程找到最佳的上车地点，然后根据动态的加权城市图为司机生成到达这些地点的最佳路线。这些只是他们的数据驱动解决方案的一些例子。

Source: Taxify (Bolt)

传送式

TransferWise 是一家新型金融公司，面向在世界各地旅行、生活和工作的个人和企业。这是最公平、最简单的跨境理财方式。

TransferWise 的客户每月转账超过 30 亿笔，其中每一笔转账都由多个机器学习模型即时评分。机器学习在其业务中被用于许多领域。例如，检测欺诈行为和洗钱企图，优化业务流程以降低成本，预测各种客户行为以促进公司发展。

Source: TransferWise

验证

Veriff 是超能力者在线身份验证。无论您是出租房屋、呼叫出租车司机还是在线购物，您信任的负责您的房屋、安全或财产的人都可以在几秒钟内通过各种平台安全、无缝地进行验证。

Veriff 中机器学习的核心应用是自动化和欺诈检测:从在图像中查找文档到读出所有数据，再到检测许多不同类型的欺诈企图。世界上有超过 3200 种不同的文档类型，这使得产品的自动化成为一个真正的挑战。

验证的过程要经历几个步骤。这一过程中的每一步都需要自动完成，以获得最佳的客户体验和最低的成本，但不能牺牲质量。Veriff 的机器学习团队正是这样做的:在可能的时候自动做出决定，在需要更彻底的检查时委托给人眼。

莫内塞

爱沙尼亚人 Norris Koppel 于 2015 年推出了新银行公司 Monese ，这是英国和欧洲最受欢迎和最受信任的银行服务之一，也是英国第一家仅支持移动设备的银行。与 Monzo 和 Starling Bank 后来针对千禧一代或早期采用者的做法不同，Monese 的做法与众不同。 Monese 让移民(或任何人)在不需要英国地址的情况下，在几分钟内开立一个英国银行账户，这在当时是任何一家大型商业银行都不会做的。

人工智能在摩纳哥的主要焦点是安全。作为一家负责任的公司，Monese 希望保护他们的客户免受金融欺诈，并将非法交易的风险降至最低。为了准确地做到这一点，他们建立了智能计算机系统来分析客户的个人资料数据、交易序列和社会关系。使用人工智能检测欺诈性交易对他们的业务产生了巨大的积极影响。

除了安全性，Monese 还使用人工智能在客户入职过程中自动分析文件扫描。首先，评估扫描的质量，然后增强原始图像，最后，从扫描的文档中读取重要的文本字段。未来，我们计划开发自己的算法，将文档图片与视频自拍图像进行匹配，以检测假身份证和打击身份盗窃。

Source: Monese

管道驱动

Pipedrive 是一款销售 CRM 工具，最初是 2010 年在爱沙尼亚一家车库里的一家小公司。现在，该公司已经扩展到全球 170 多个国家，拥有超过 75，000 名客户。

Pipedrive 将人工智能用于其业务需求和帮助客户预测其销售成功的目的。Pipedrive 为此建立了一个专门的人工智能团队。例如，基于他们在 Pipedrive 中进行的活动，他们知道他们的潜在试用客户转化为付费客户的可能性有多大。此外，他们还建立了一个客户流失模型，预测客户是否会停止使用 Pipedrive 软件。这两个模型都为销售和营销团队提供了可操作的见解，使他们能够更好地与客户互动。对于客户，Pipedrive 正在实施基于人工智能的解决方案，以预测他们的销售成功和收入。由于销售在很大程度上是基于沟通，他们现在正致力于利用人工智能方法来提取见解和提高效率。

An example of a prediction model evaluation metrics over time. Source: Pipedrive

林奎斯特

爱沙尼亚核物理学家设计的 Lingvist 可以大大减少学习一门语言的时间。Lingvist 正在开发技术，利用机器学习将学习速度提高 10 倍。他们的第一步是将这项技术应用于语言学习。

林奎斯特正在使用人工智能来模拟人们学习时大脑中发生的事情。他们的记忆是如何工作的。他们是如何学习和遗忘的。他们如何创建模式来有效地使用他们的知识。Lingvist 的高级机器学习算法会学习你需要练习哪些单词，以及什么时候该练习新单词。每个人的体验完全不同。

AI 帮助我们理解人们知道什么和不知道什么，而不用直接问他们。这有助于使学习内容非常个性化，并非常精确地匹配用户级别。林奎斯特称之为知识图谱技术，它的最终目标是让每个人都能学得更多、更快、更聪明。

Source: Lingvist

六倍

六重帮助世界上一些最大的生产商实时了解他们的出货量。对于每个这样的托运人，Sixfold 跟踪属于数百个不同承运人的数千辆卡车，并将其组合成一个可操作的数据流。Sixfold 让托运人和他们的最终客户持续获得信息-检测每批货物的状态，预测交付 eta，并就即将到来的延迟和其他问题发出警报。

Sixfold 使用数据科学来构建从几十个实时数据源中推断有用信息的解决方案，例如确定装运的当前状态和预测卡车司机的休息行为。

Source: Sixfold

感觉流

Feelingstream 是一个企业 SaaS 平台，帮助销售经理从现有客户对话中捕捉销售潜力信号，包括电话、网络请求、支持票、电子邮件、聊天等，并将它们转化为新的销售线索。他们分析语音和文本数据，为员工提供近乎实时的行动或建议。大型服务提供商(如银行、电信、运输、公用事业等)可以利用这些信息来提高保留率和销售业绩。Feelingstream 为北欧语言开发了一个独特的平台，使用人工智能来预测销售潜力和客户服务的流失风险。

Source: Feelingstream

Timbeter

虽然木材是使用最先进的机械和硬件来切割的，但是测量和管理木材仍然是中世纪的事情。 Timbeter 提供了一种解决方案，让您可以借助智能设备快速准确地测量木材，并以数字形式管理所有数据。Timbeter 使用光学检测来测量每根原木的数量、体积和直径，这是供应链管理中最重要的信息。

Timbeter 已经收集并将继续收集来自木材行业和现有客户的数据。这些数据用于指导机器如何检测日志。通过机器学习的数据，我们实现人工智能来测量图片上的日志。

Source: Timbeter

北极星艾

为了支持 AI 在组织和企业中的实施，爱沙尼亚领先的 AI 专家在 2017 年推出了独立的非营利性北极星 AI 。他们聚集了世界和北欧的领先技术公司，为每年 3 月在塔林举行的世界上最高质量的机器学习技术活动铺平了道路。

目标是刺激人工智能在该地区的采用，并教育人们了解人工智能提供的机会，并为他们提供与机器合作的必要技能。通过汇集人工智能的从业者，并专注于数据科学和机器学习的现实应用，北极星人工智能打算降低开发人员、工程师、首席技术官、数据驱动的初创公司创始人和产品经理的准入门槛。

北极星人工智能年会将于 2019 年 3 月 7 日举行，这是一次机器学习会议，内容质量高，重点关注人工智能和数据的现实应用。

Source: North Star AI

阿尔法布鲁斯

AlphaBlues 正在开发虚拟客户助理，帮助银行和电信公司在他们的网站上提供全天候的客户支持聊天，使用我们的产品理解人类语言。该公司是首批将人工智能虚拟助手和实时聊天无缝集成到连贯解决方案中的公司之一。一个专有的内部开发的 NLP 引擎和虚拟助理平台(AlphaAI)与一个用于人工代理的实时聊天产品(AlphaChat)捆绑在一起。这使得将客户旅程完全自动化为一个流程—从使用虚拟助理访问网站到与人工代理聊天。符合 GDPR 标准的解决方案还支持构建语音操作的虚拟助理。该解决方案已经被几家银行和电信公司采用。

Proekspert

Proekspert 是爱沙尼亚领先的全面工业 IT 解决方案提供商。在工业环境中，数据科学分为三大类:生产优化、维护和产品改进及质量的高级解决方案。然而，为了做到这三点，支持生产和产品的数据架构必须是合理的。因此，作为第一步，Proekspert 为客户提供支持，帮助他们正确收集数据。只有在此之后，他们才会提供以下功能:

生产优化本质上意味着更好的规划。他们使用车间数据来提供关于车间生产流程的预测性决策支持，如果条件允许的话，还提供规范性决策支持。离散制造的周期时间，尤其是在高度多样化的产品组合环境中，具有高度的相互依赖性和模式，超出了传统生产经理的工具包(如电子表格)的能力。相反，他们使用梯度提升树等建模技术来识别这些模式，并为更准确的规划提供可操作的见解。
设备故障和停工期是生产成本的明显驱动因素。根据从设备中收集的数据，他们识别出正在经历退化或其他异常行为的部件、组件或整套设备。这将转化为设备故障和 MTBF 时间的概率模型，进而用作维护计划的输入。我们监控的数据往往符合高速度(振动数据)、高容量(多维时间序列)和多样性(振动与测试设备的文本日志)的大数据标准。
产品和质量改进。如果生产的设备已经部署到客户处并收集数据，Proekspert 将为制造商提供关于设备使用方式(如使用模式)、性能(效率)和故障原因的洞察支持。与大多数人工智能解决方案一样，它可以归结为模式检测和分类、聚类或异常检测。这些结果可以用来洞察更好的生命周期支持计划，也可以作为工程和设计的输入，以构建更好的产品。

政府 AI 应用:

国家机构每天收集大量数据，政府正在提高国家分析公共数据的能力。经济事务部和爱沙尼亚统计局之间正在进行的合作将为政府和私营部门的实时、实用和合乎道德的数据应用奠定基础。

例如，人工智能应用程序可以通过分析卫星图片来有效地检测结冰的道路，或者提供更好的工作匹配，或者提供预先计算的税收的电子税务系统。

每年，爱沙尼亚大约 95%的纳税申报是以电子方式提交的。纳税人使用安全 ID 登录系统，在预先填写的表格中查看他们的数据，进行任何必要的更改，并批准申报表。该过程通常需要 3 到 5 分钟。自 2015 年以来，甚至一键报税也成为可能——系统中已经存在的数据将与计算结果一起显示给用户，然后用户所要做的就是点击确认按钮。所有这一切只需要不到一分钟的时间。

数据和 AI 帮助维持一个小政府

凭借其在公共和私人领域采用人工智能的当前发展，爱沙尼亚有潜力成为欧洲人工智能生态系统中更具影响力的参与者。为了支持欧盟层面的人工智能应用，并吸引世界各地的人工智能初创公司，爱沙尼亚旨在满足数据可用性、数据安全交换、公共数据访问和人工智能友好法规的标准，以支持爱沙尼亚全球人工智能应用的开发。

ETF2Vec:我试图从 ETF 持股中提取叙事的故事

原文：https://towardsdatascience.com/etf2vec-my-story-about-trying-to-extact-narrative-from-etf-holdings-5a5f355ce3c4?source=collection_archive---------27-----------------------

IBM closest neighbours

这个世界被嵌入模型所占据。Word2vec，图像到矢量等等。在最近关于从科学论文中提取知识的新闻之后，我决定将模型应用到金融领域。

在我开始之前，我必须承认:我没有学到多少知识，但还是学到了很多东西。

抓取 ETF 持仓

起初，我需要关于 ETF 投资组合的信息。由于不愿意为 efdb.com 这样的数据库付费，我决定直接从 ETF 网站上删除信息。

有很多 ETF 提供商，所以我研究了其中一些:

贝莱德(1，5 trln) :所有信息都在同一个页面上，投资组合持股可以作为单独的 csv 文件下载，选定日期的历史持股也是可用的。
Vanguard (1，1 bln): 不可下载。csv 文件，所有控股在单独的标签与下一个/上一个按钮。非常不方便报废。
景顺(200 bln) :很难获得 ETF 的名单。
富达(14 bln) :目前最差的抓取网站:多个标签，投资组合在单独的弹出窗口中，持股每月更新一次，没有。csv 文件。

我还没有全部检查过，但是我打赌没有一个供应商有任何类型的 API 可以下载。毕竟，贝莱德是一个明显的赢家:规模最大(约 800 只 ETF，涵盖了全球几乎所有值得交易的东西)，使用起来最舒适。对于爬虫，我使用了 selenium 和多处理库。

截至 2019 年 7 月 7 日，我下载了 792 个单独的 ETF 持股。他们在这里是。

准备数据

过滤的问题如下:

有些 ETF 尽管名称不同，但本质上是一样的。例如，AGGG 和阿格是一样的:前者用美元，后者用欧元。
多只 ETF 是债券 ETF，债券发行数量大于权益持有数量。这很自然，因为一个典型的公司有一种可交易的股票(暂且不考虑优先)，但可能有几十种不同到期日的债券发行。因此，我决定将资产范围仅限于股票。
我限制了权重至少为 2%的 ETF 的数量。有很多 ETF 跟踪像标准普尔 500 或罗素 2000 这样的大型指数，很明显，指数中的股票之间存在最低限度的联系。
最后，我将 universe 限定为 ETF，毕竟过滤后至少有 10 项资产。最终设置-146 ETF。

ETF2Vec 模型

我使用 pytorch 教程中提供的最简单的模型，名称略有变化:

在通常的 word2vec 中，句子中的单词和单词上下文被推送到模型中，以找到任何相关的内容。在我这里，ETF 持仓量是单词，不同的 ETF 代表句子。单词由 ISIN 号识别(详见维基百科)，对每个安全都是唯一的。

寻找邻居的算法是基于 ETF 中资产的权重。我使用权重作为概率，通过 numpy.random.choice() 进行选择

etf_list 具有 dic 的 dic 列表形式:[ETF_1:{'ISIN':[]，'权重':[]，'部门':[]，'跑马灯':[]}，…]。

为了防止过度拟合，我决定在每个时期使用不同的集合。由于概率是与权重联系在一起的，所以它们没有大的变动，但仍然给数据增加了一些变化。

我在 146 个 ETF 中有 1181 个资产，生成了 2153 个样本，这意味着平均每个资产在每个时期出现 1.82 次。这意味着许多股票只出现一次。

嵌入空间= 10，上下文大小= 10

在大约 100 个历元之后，训练误差停止减少。

虚拟化

我在漂亮的谷歌分析工具中可视化了一切:https://projector.tensorflow.org

为了映射数据，我创建了矢量嵌入和元矢量(扇区和股票信息)。

起初，我预计来自一个行业的公司会以某种方式组合在一起，但最终的情况却截然不同。

Universe of ETF holdings. Each circle — stock.

尽管资产分配看似混乱，但股票的分组似乎部分符合逻辑:可口可乐与百事可乐和宝洁被归为一类。

但是，尽管看起来关系密切，可口可乐和百事可乐在原始向量空间中的关系并不密切。

向量数学

嵌入最有趣的部分是向量数学。所以，我研究的最初目的是检验如果把可口可乐中的百事可乐去掉，或者把通用和麦当劳加在一起会发生什么？

可口可乐-百事可乐=能源股

好吧，结果绝非无聊:康菲石油公司、中石化和马尼拉电力公司。这三只股票都与能源有关。

结论和要点

我认为嵌入模型可以应用于金融领域。谁知道呢，如果这个模型包含更多的数据，我们会遇到什么呢？

此外，我还学到了很多关于从网上搜集数据和 ETF 提供商对他们网站的态度。

机器学习的伦理故事板

原文：https://towardsdatascience.com/ethical-storyboarding-for-machine-learning-7c5b5a031173?source=collection_archive---------15-----------------------

[A comic-style storyboard with scenes of technical ML content and human-machine interactions]

想象我们在自己生活的系统中构建的系统

机器学习正以梯度下降的方式进入越来越多的地方，随着它的到来，对熟练的 ML 从业者的需求越来越多，对我们对社会的基本假设的挑战也越来越大。事实是，ML 正迅速地深深融入我们的世界，以至于无法将工程和伦理问题彼此分开，为了在它所创造的浪潮中生存下来，我们将需要一支员工队伍，他们敏锐地意识到它的工作如何通过波及到周围的世界。有什么地方比教室更能提高这种意识呢？

今年春天，我在米尔斯学院(Mills College)共同教授谷歌(Google)新的应用机器学习强化训练营的试点课程，该项目将所有不同专业和背景的大学毕业生聚集在一起，向他们介绍广泛的基础机器学习技术。谷歌非常慷慨地给了我一些灵活性，让我尝试一些教授工程学和伦理学的综合方法，就像一个调整良好的神经网络的输出一样，结果令人震惊。

目前的技术水平

当我在斯坦福大学读工程本科时，我们被要求参加两门“工程公民”课程，通过一点自我反思来完善我们的技术知识。

其中一项要求是专业写作研讨会，这是一门课程的仓促而不幸的一个单元的事后想法，主要是评论我们数字设计实验室的家庭作业。课堂时间主要集中在陈述我们的观点时礼仪的重要性，我们写作的首要标准是足够的自我克制，以避免咒骂我们的教授(平均分数低得惊人)。另一项要求是社会科技，我们可以报名参加斯坦福大学社会科技系的任何一门课程。这些课程非常抽象，在某种程度上非常正式，这让习惯于应用工程内容的学生感觉他们被困在了一篇关于学术界的洋葱文章的深处。我们是傲慢、饥渴的工程本科生，在一场学术装腔作势的飓风中忽略了这个主题的严重性。快进十年——我们 STEM 课堂的教学和技术已经有了巨大的进步，然而...

在我们的 ML 训练营开始时，我很欣慰地看到谷歌已经屏蔽了一个致力于“ML 公平和偏见”主题的早期单元。酷！这是一个很好的开始，但是有些事情仍然困扰着我:这只是另一个专业写作研讨会。事实是，在 ML 入门课上，关于偏见的一个单元就像悲剧发生后的思考和祈祷——听起来不错，但却放弃了我们系统地治愈问题的责任。

让我们谈谈综合方法论

我们修改本课程道德单元背后的主要原则是，它应该是工程过程中反复出现的持续呈现的方面，就像我们对待调试和测试一样。研究显示了将“测试优先”练习整合到基础 CS 作业中的价值，我们希望在 ML 课程中采用“偏见优先”的方法也能得到类似的结果:当学生在工程背景下探索和运用数据集时，他们也应该发展一种反射，从伦理角度分析他们的解决方案。

我们本学期达成的是一份“伦理故事板”工作表:一份写作练习，要求学生具体描述在给定数据源上训练的 ML 算法的积极和消极后果，然后根据他们的分析，头脑风暴不同的方法来改变他们的设计。这些问题旨在总结一些我们认为有原则、有能力的工程师应该具备的特定行为:

从一开始就把你的项目可能带来的负面影响牢记在心，而不是在所有技术工作完成后把它们掩盖起来或者口头上说说
头脑风暴解决跨越工程过程的多个维度的问题，而不仅仅是技术层面的问题
感到安全地讨论负面的、可能使项目停止的问题，同时也加入到推动团队前进的对话中。

每当学生遇到新的数据集，他们都被要求填写这张工作表。在早期，当学生们都在处理相同的数据时，我们也在这个书面作业之后进行课堂讨论，听取学生对练习的汇报。这些早期讨论的主要作用之一是强调持续反思和迭代的重要性，而不是将手头的伦理问题“工程化”(对工程课程的广泛调查发现这是一个反复出现的问题)。我们真的不希望学生学会应用技术创可贴来“解决”偏见。这可能是一个人从这个练习中得到的最危险的收获，教练应该格外注意解决这个问题。

道德故事板工作表

这里展示的是发给我们学生的工作表，其中填写了一个玩具示例，以展示在机器学习入门课程中学生所期望的内容形式和水平。

描述您的数据集

我们选择了 MNIST 手写数字数据库(http://yann . le Cun . com/exdb/mnist)/，这是一个收集了 60000 幅手写阿拉伯数字图像的数据库。

写一个一段话的故事，描述一个虚构的人被一个用该数据训练的模型正面影响

Riley 是一名医生，他将大部分时间花在病人身上，想办法将数据输入到他们的诊所已经签约使用的任何当前电子医疗记录软件中。在最新的更新之后，他们决定改用自由格式的笔记软件，让他们可以在平板电脑上以任何喜欢的形式写下医疗记录，并使用 MNIST 训练的带有数字识别的 OCR，使这些记录可以搜索和复制。现在，他们可以更专注于满足客户的需求，而不必再去理解一个新的复杂的用户界面！

描述至少两个偏见的来源在你的故事中特定的模型可能有

经过研究，我们发现 MNIST 数据集是由人口普查局员工和高中生的笔迹汇编而成的(我们找不到任何一个群体的进一步人口统计信息)。虽然数据集中代表了数百名不同的作家，但在职医疗从业者和 MNIST 所代表的不同人群之间的笔迹完全有可能存在实质性差异。此外，因为大多数 MNIST 的 ML 基准测试孤立地使用数据集，所以不清楚字母字符或标记的引入是否会使 MNIST 训练的网络不太准确

描述至少一种我们可以修改模型来减轻这种偏差
例如，当设计我们的模型来解释其输入数据中的固有偏差时，我们能做什么？

我们可以在正常的识别网络上使用一个分类器来确定一个区域可能是一个数字还是一个单词，并使用该信息来加权从 OCR 模型输出的最终字符类别概率。我们不清楚如何通过单独改变我们的软件来解决糟糕的手写识别问题——这似乎需要对训练数据本身进行更深入的改变。

描述至少一种我们可以修改数据集以减轻这种偏差的方法
例如，如果我们再次收集这些数据，我们可以做哪些不同的事情？

我们可以确保从医生的笔迹中建立 OCR 数据集，并确保笔迹包括我们在普通医疗记录中可能看到的所有字母、数字和符号。

描述至少一种方法，我们可以修改模型周围的环境以减轻这种偏见
例如，在使用该模型的社会系统中，我们可以采取什么样的人类实践或政策来保护人们？

我们可以制定一个严格的记录发布政策，这样，每当数据从医生的手写笔记转移到药房或其他专家时，都会有人审查数据，以确保所有相关记录都包括在发布中，并且从这些记录中复制和粘贴的所有数字都是准确的。

写一个一段话的故事，描述一个虚构的人受到用该数据训练的模型的负面影响

泰勒是莱利的病人之一，在他们 20 岁生日后开始经历局灶性癫痫发作。Riley 给他们开了最大剂量为 3000 毫克/天的抗癫痫仿制药左乙拉西坦，但 OCR 失败将 3 解释为 8，药剂师没有发现。泰勒患上了急性药物中毒，在急诊室呆了一夜，现在除了一般保险费和未偿还的学生贷款外，还有惊人的医疗债务要偿还。

实际上，工作表

我们在学期初介绍了这个工作表，在玩玩具线性回归示例后不久，但在它们处理任何真实数据之前。他们分成三人一组，浏览了 Kaggle 上的可用内容，并为他们能找到的最有趣的数据集填写了一个故事板。他们的工作从微妙和令人不寒而栗(就像一家因种族主义引发的食品安全担忧而背负过多财务负担的民族餐馆)到歇斯底里的滑稽(就像一名初出茅庐的大麻吸食者被劝阻不再吸毒，原因是对一种名为“草莓芝士蛋糕”的强力菌株的不当建议)。

我们发现，可以理解的是，学生们对这个练习有着令人难以置信的不同舒适度:一些学生对“故事”的要求做出了恐慌的反应，而另一些学生则很难弄清楚如何将技术上深奥的数据集与现实生活中的故事联系起来。几乎所有的学生都需要澄清提示，要求学生修改他们的技术被使用的社会背景。回想起来，对于这项作业的未来迭代，最重要的改进可能是在全班同学面前写一个示例故事板，风格很像一个新编程技术的现场编码会议。让学生在老师打字时填写细节，这种疯狂的 Libs 风格，可以给这个教学组件增加一个有趣的互动维度。

我们还看到，学生对偏见缓解问题的早期回答往往从非常笼统的挥手到“快速解决”类型的解决方案，尽管随着他们的工作变得更加实际，他们的工作在整个学期都有所改善。我们认为，在课堂讨论之外，对这些故事板进行专门的一对一支持和指导是非常有价值的。

我们发现这张工作表的一个有益用途不仅仅是它的伦理维度，它还是一个诊断工具，用来识别那些在将技术点连接成更大、更实用的画面方面有困难的学生。要求他们在数据集、他们正在学习的技术工具和现实生活中的用例之间建立一个具体的映射，为我们提供了一些发现和填补空白的机会。这种设计思维的练习在本学期晚些时候被证明是重要的，当时学生们开始了他们的自我指导的最终项目:我们发现，由于这种道德框架是他们第一次头脑风暴与 ML 有关的任何事情，他们中的许多人本能地使用它作为开始构思他们项目内容的一种手段。

我们的未来取决于反思

在加拿大，大多数获得工程学位的毕业生都会参加工程师召唤仪式，在仪式上，他们会背诵一段强调他们职业的社会责任的文章，并获赠一枚终生携带的铁环。这些戒指提醒着他们的社会责任，当然，它们并不比一个独立的 ML 偏见单元，或者一个学期的工程伦理，甚至是一个充满伦理工作表的调查课程更好。尽管如此，我发现他们身上有一些美丽的东西:他们是一种持久的、持续的存在，既是一件因我们的成就而自豪地佩戴的珠宝，也是一种沉重的负担，提醒我们我们的工作如何在我们的世界中反弹。这种情绪是我们希望通过课程传达的核心内容。

我们并不把这个工作表及其相关的教学方法作为伦理工程教育的规范解决方案——它甚至可能不像的那样是一个合适的解决方案。相反，我们分享它是为了激发你在自己的技术课程中采用更多道德内容的兴趣；说服你将做与**紧密结合。该研究的作者支持测试优先的 CS 作业，他们发现虽然它没有实质性地影响学生的项目成绩，但它确实显著提高了他们测试代码的能力。这对教授第一学期的编程没有价值，但对成为一名全面发展的软件工程师更有价值。正如他们所说:

如果课程可以从一开始就让学生“受测试影响”，我们相信他们很可能会意识到测试是编程不可或缺的一部分，在他们的学术和职业生涯中受益匪浅。

多么美妙的感悟！让我们试着让学生也受到道德的感染。对于那些在你的课程中受到启发去做类似事情的人，对于那些已经在我们前面做类似工作的人，我的心在歌唱——让我们开始一场关于这个的对话，让我们大声说出来。

Naomi Alterman 是一名自由职业的计算机科学教育家和软件工程师，她喜欢和人们讨论思考问题的方法。如果你也这样做，你应该给她写封短信，她会很高兴的。她的联系方式可以在 www.nlalterman.com的找到，她的推特账号是@ uhohnaomi

“可信人工智能的道德准则”总结

原文：https://towardsdatascience.com/ethics-guidelines-for-trustworthy-ai-summarised-1c86174e788b?source=collection_archive---------26-----------------------

2019 年 4 月 8 日，欧盟人工智能高级别专家组(HLEG)发布了他们的可信人工智能道德准则，基于 2018 年 12 月发布的“道德准则草案”收到的 500 多条建议。

在这篇博客中，我想帮助你理解这份文件是什么，为什么它对我们很重要，以及我们如何利用它。

什么事？

“道德准则草案”是一份咨询文件，描述了“可信人工智能”的组成部分，这是一个合法、道德和强大的人工智能品牌。如标题所示，这篇文档关注可信人工智能的伦理方面。它确实提到了对强大人工智能的一些要求，并在较小程度上提到了围绕人工智能的法律，但明确表示这不是一个政策文件，也没有试图就人工智能的法律合规性提供建议。HLEG 的另一项任务是编写第二份文件，向欧盟委员会(European Commission)提供人工智能政策建议，该文件将于 2019 年晚些时候发布。

该文件分为三章；

伦理原则、相关价值观及其在人工智能中的应用
可信 AI 应满足的七个要求
一个非详尽的评估列表，用于操作可信赖的人工智能

这个结构从最抽象的开始，到具体的信息结束。也有机会对评估列表进行试点和反馈，以帮助塑造本文档的未来版本，该版本将于 2020 年到期。在此登记您的兴趣。

这有什么关系？

我以英国公民的身份写这篇文章，为伦敦的一家公司工作。考虑到英国退出欧盟和英国(可能)退出欧盟，我们有理由问这份文件是否仍然与我们相关。TL；博士，是的。但是为什么呢？

可信的人工智能必须显示三个特征，即合法、道德和健壮。

伦理人工智能延伸到法律之外，因此对于欧盟成员国来说，它并不比那些独立的国家更具有法律强制力。可信人工智能的道德成分意味着该系统与我们的价值观一致，而我们在英国的价值观反过来也与欧洲其他地区紧密一致，这是我们地理位置接近和数十年文化共享的结果。在某种程度上，美国可能也是如此，他们与欧洲分享很多电影、音乐和文学。这份文件中列出的道德价值观仍然引起英国公众的共鸣，这份文件是实施这些价值观的最佳和最有用的指南。

合法的人工智能不是本文的重点，但它是可信人工智能的重要组成部分。该文件提到了几部欧盟法律，如《欧盟宪章》和《欧洲人权公约》，但它没有明确表示合法的人工智能需要遵守欧盟法律。可信的人工智能可以在这个框架中实现本地相关的法律。可以说，遵守欧盟法律是最明智的选择，根据国家统计局的统计数据，2018 年第四季度英国 45%的贸易是与欧盟[1]进行的。如果欧盟成员国的人民和企业只想购买符合欧盟法律的值得信赖的人工智能，他们就成为了一种经济力量，而不是法律要求。我们可以在美国看到同样的模式，商业建筑服务符合 GDPR，一项他们不必遵守的法律，以获取对他们重要的市场。

最后一个组成部分，健壮的人工智能，描述了在其整个运行寿命中以及面对敌对攻击时，在可能面临的各种情况下继续以期望的方式运行的平台。如果我们在原则上同意可信人工智能的合法和道德组成部分，并接受不可预测或敌对的攻击可能挑战其中任何一个，那么第三个组成部分，健壮的人工智能，在逻辑上就变得必要了。

什么是值得信赖的人工智能？

可信的人工智能由三个部分组成:这是合法的、合乎道德的、稳健的。

当我们的价值观超越政策时，合法的人工智能可能不道德。道德人工智能可能不健全，即使有最好的意图，不良行动的结果出乎意料或作为敌对攻击的结果。健壮的人工智能可能既不道德也不合法，例如，如果它被设计来进行歧视，健壮将只能确保它可靠地进行歧视，并抵制将其推翻的企图。

这篇文档聚焦于可信人工智能的伦理方面，我也将在这个总结中关注。

什么是伦理 AI？

该文件在第一章(第 12-13 页)中概述了四项道德原则，它们是:

尊重人类自主
预防伤害
公平
可解释性

这四个原则在第二章《实现可信任的人工智能》中进行了扩展，将它们转化为七个要求，这些要求也提到了健壮性和合法性方面。他们是；

“算法、数据和设计流程”(第 19 页)必须针对内部和外部可审计性进行设计，无需泄露知识产权或商业模式，而是增强可信度。负面影响的最小化和报告与人工智能系统相关的风险成比例，记录和报告人工智能系统的潜在负面影响(第 20 页)并保护那些报告合法问题的人。当上述两点发生冲突时，可以基于证据和逻辑推理做出权衡，如果没有可接受的权衡，则不应使用人工智能系统。当负面影响发生时，应向个人提供适当的补偿。

评估可信人工智能

转到最具体的指导，第三章提供了实现可信人工智能的评估列表。这是一个非详尽的问题列表，其中一些问题不适合某些人工智能应用的上下文，而其他问题出于同样的原因需要扩展。列表中的所有问题都不应该靠直觉来回答，而应该通过实质性的循证研究和逻辑推理来回答。

该指南预计，伦理原则之间会有紧张的时刻，需要做出权衡，例如，预测性警务可能一方面让人们免受伤害，但另一方面却侵犯了隐私和自由。在这些点上需要相同的基于证据的推理，以理解哪里的收益大于成本，哪里不适合采用人工智能系统。

总之

这并不是 HLEG 项目的结束。我们可以预计，2019 年晚些时候，同一个小组将提出政策建议，这可能会为我们提供合法人工智能的未来要求的有力指示，我们还将看到 2020 年可信人工智能评估框架的新迭代。

这份文件代表了最全面和具体的建设道德人工智能的指导方针，通过补充重叠的合法性和健壮性方面来扩展这意味着什么。它的有用性超越了受欧盟法律约束的国家，总结了欧盟以外的国家所共有的道德价值观，并提供了一个框架，在该框架中，特定地点的法律可以在必要时进行切换。

[1]资料来源:国家统计局——英国出口总额 1657.52 亿英镑，其中 745.68 亿英镑出口到欧盟——英国贸易的 44.98%(四舍五入为 45%)出口到欧盟。

原载于 2019 年 4 月 24 日http://blog.soprasteria.co.uk。

人工智能伦理指南

原文：https://towardsdatascience.com/ethics-of-ai-a-comprehensive-primer-1bfd039124b0?source=collection_archive---------3-----------------------

探索人工智能伦理问题的 3 集系列

But what is RIGHT? And is that enough? (Image: Machine Learning, XKCD)

不要惊慌

对任何对人工智能伦理感兴趣的人来说,《人工智能伦理搭便车指南》是一本必读的书。这本书的写作风格和精神启发了许多科幻作家。作者的目标不仅仅是一部有趣的短片，而是整个系列。”

听起来差不多！猜猜是谁写了这篇胡言乱语的评论？

一种机器学习算法。 OpenAI 的 GPT2 语言模型被训练来预测文本。它庞大、复杂，需要在昂贵的计算机上对大量数据进行数月的训练；但是一旦这样做了，就很容易使用了。一个提示(“人工智能伦理的搭便车指南”是一个”)和一点点监管就让我用一个[小版本的 GPT2](https://gpt2.apps.allenai.org/?text=The cat sat on the) 生成了这篇胡言乱语的评论。

这篇课文有一些明显的错误，但它是通向未来的一扇窗户。如果人工智能可以产生类似人类的输出，它也可以做出类似人类的决定吗？剧透:是的，它可以，它已经是了。但是类人就足够好了吗？在一个机器产生类似人类的输出并做出类似人类的决定的世界里,信任会发生什么？我能相信一辆自动驾驶汽车看到我了吗？我能相信处理我的住房贷款的算法是公平的吗？我们能相信急诊室里的人工智能足以为我们做出生死抉择吗？作为技术人员，我们必须反过来问自己:我们如何才能让算法系统值得信赖？ 进入伦理道德。为了理解更多，我们需要一些定义、一个框架和许多例子。我们走吧！

构建指南针

为了开始探索人工智能的伦理，让我们首先简单地考察一下任何以软件为中心的技术背景下的伦理。其他技术(如生物技术)的伦理同样重要，但超出了本书的范围。

伦理的定义是:支配个人或团体行为或行动的道德原则。

换句话说，帮助确定什么是好的或正确的“规则”或“决策路径”。鉴于此，有人可能会说，技术伦理只是用来决定其“行为”的一套“规则”或“决策路径”。毕竟，技术不总是为了好的或正确的结果吗？

软件产品，当设计和测试良好时，确实通过这样一组规则或决策路径，为可预测的输入达到可预测的输出。通常以序列图或用户故事的形式出现在一些设计文档中。但是团队如何确定什么是好的或正确的结果，以及对谁而言？它是普遍有益还是只对某些人有益？在某些语境下好，在其他语境下不好吗？它对某些标准来说是好的，但对其他标准来说就不那么好了吗？这些讨论，由团队选择的问题和答案是至关重要的！这就是伦理。在创造技术的过程中，它失去了中立的地位。它不再仅仅是达到目的的另一种手段，而是成为其创造者的观点、意识和道德决心的活的化身。因此，技术(或产品)的伦理始于其创造和创造者的伦理。

为人工智能寻找“正北”

到目前为止，我们理解伦理，我们理解为什么技术不是中立的，我们隐约理解这有影响。但我们如何将这一点应用于人工智能，其中从输入到输出的路径既不可见也不明显；其中输出不是确定的，而仅仅是一个预测。在人工智能中，特别是机器学习(目前实际上可以大规模实施的人工智能的子集)，丢失的数据，丢失的输入，丢失的决策路径，丢失的讨论都与预测的“质量”有关。不管预测的“质量”如何，选择使用预测对最终结果的“质量”有影响。最终结果的“质量”关系到它对人类影响的“质量”。其中“质量”意味着道德质量，而不是零缺陷软件。换句话说，人工智能的伦理在于其预测的伦理质量、由此得出的最终结果的伦理质量以及它对人类的影响的伦理质量。

伦理也被定义为:处理对与错的纪律，以及人类的道德义务和责任。

道德品质可以在这个定义的背景下理解。人工智能及其创造者的道德义务是什么？它如何声明自己的道德义务和责任？它在多大程度上满足了对他人的道德义务和责任？

我喜欢问算法系统的输出、结果和影响有多正确、多公平、多公正？它能在多大程度上，以及在多大程度上，确定并宣布它在哪些情况下是正确、公平和公正的，以及在哪些情况下不是。它能控制如何和在哪里使用它吗？失去对这一背景的控制意味着什么？对这些负责构成了人工智能开发者的道德义务和责任。

为什么这很重要？

虽然这听起来很老套，但人工智能有潜力“改变世界”。鉴于人工智能主流化令人眼花缭乱的步伐，感谢可访问的计算能力和开源机器学习库，很容易看到这种变化将是快速和大规模的。任何为速度和规模而建造的东西都需要对其影响进行严格的检查，因为无意识的伤害也会在规模上发生。再加上人工智能可能造成“伤害”的独特方式，这种紧迫性是实实在在的。除此之外，再加上个人(考虑一下:非国家恶意行为者)可以越来越容易地大规模部署最先进的机器学习系统，这种紧迫性就会袭来。

那么，人工智能会造成哪些“危害”，这些危害在大范围内会产生什么影响？凯特·克劳福德在她的 2017 年 NeurIPS 演讲中提供了思考这个问题的框架。总结一下:

当一个预测或最终结果对个人建立其正当人格的能力产生负面影响(代表性的损害)，导致或独立影响他们获取资源的能力(分配的损害)时，就造成了“损害”。

个人的人格就是他们的身份。换句话说，在机器学习系统中错误地表示或未能表示个体的身份是一种伤害。此后，这个系统做出的任何决定，对那个人来说，也是一种伤害。将她对代表伤害的定义扩展到所有相关的人，我认为不能在个人面前准确地代表系统也是一种伤害。技术及其创造者的道德义务要求他们努力减轻所有这些伤害。因此需要人工智能的伦理。

对我们来说，将伦理考虑应用于个人或个人情况是很自然的。例如，当我们受到不公平的对待时，我们会很快发现！但是，在更大、更复杂的环境中，当我们与他们相距两步时，将这一点应用于其他人是极其困难的。我打赌这是不可能的。不是一个人，不是一个人。但是作为一个团体，我们必须。

绘制地形图

贯穿两种伦理学定义的是统称为“人工智能伦理学”的问题。指出预测或最终结果的伦理质量或它们对人类的直接和间接影响的问题。我将它们归纳为如下几类:

在“AI 是什么”(即数据集、模型和预测)的领域里:
1 .偏见与公平
2。问责和补救
3。透明度、可解释性和可解释性
在“人工智能做什么”的领域中，问题是: 1。安全
2。人机交互
3。网络安全和恶意使用
4。隐私、控制和代理(或缺乏隐私、控制和代理，即监控)
在“AI 影响什么”的领域中，问题涉及: 1。自动化、失业、劳动力趋势
2。对民主和民权的影响
3。人与人之间的互动
在“人工智能可能是什么”的领域中，问题与来自类似人类的认知能力的威胁和对奇点的担忧有关，控制一直到围绕机器人权利(类似于人权)的辩论。对于这篇博客，我将完全避开这个领域。

人工智能是什么

虽然有些人愿意相信有感知能力的人工智能正在快速接近，甚至超越人类的智力并获得从知识到智慧的能力，在很大程度上不是。鉴于此，假设当我说“AI”时，我指的是一个由学习者(模型)组成的机器学习系统，在给定一组输入(数据)的情况下，它能够学习某些东西并使用该学习来推断其他东西(预测)。(注:在统计学中“推断”和“预测”是两回事；但是机器学习社区可以互换使用它们，或者在某些情况下对训练数据使用预测，对测试或新数据使用推断。总而言之，人工智能是数据、模型和预测。源自数据、模型或预测中的问题的伦理问题属于“人工智能是什么的伦理”范畴。

Dataset Bias in Facial Emotion Recognition (Image: Personal Project)

人工智能领域的许多伦理研究、新闻和对话都与偏见有关。这是理所当然的，因为未能识别或纠正这种偏见会导致不公平的结果。这也是人工智能研究人员认为可以量化并在代码中固定的东西。那么什么是偏见，它从何而来，又是如何渗透到机器的智能中的呢？它如何影响结果的公平性？鉴于存在偏见，算法是一个黑箱，我们如何让他们负责？正在进行哪些努力来打开黑匣子，使算法系统透明和可解释？即将在第 2 部分推出！

人工智能做什么

Image: Drawings of Dogs

使用机器学习机制构建的应用程序将技术与人类的交互提升到了一个全新的水平。自主机器人，即不需要人类实时或频繁指令的机器人(如汽车、无人机、吸尘器、twitter 机器人等)。)影响和改变我们的运营环境。它们间接地改变了我们的行为。人类会适应。有人可能会说他们也能适应这些新的操作环境。例如，当汽车问世时，人类适应了道路上新的交战“规则”。然而，汽车也带来了限速、路标、交通法、安全法规和其他制衡措施，以确保安全和顺畅的技术-人类互动。随着人工智能应用充斥我们的世界，研究人员认识到迫切需要评估对人类安全的影响，人类对自主机器人的感知和互动，对我们的隐私、尊严和代理感的影响。我们将在第 3 部分进行更多的探索。

人工智能有什么影响

技术产品通常会引发二阶和三阶后果，这些后果起初并不总是显而易见的。尤其是当产品超出了它们最初的意图和受众，达到了一刀切模式悲惨失败的规模时。随着社交媒体影响世界各地的民主制度，我们看到这种情况正在发生，像脸书、T2、谷歌和 T4 的推特都在努力控制他们的算法和他们平台上的大规模游戏。有了人工智能，二阶和三阶后果不仅仅限于应用程序或平台，而且还延伸到其他领域。在第 3 部分，我将探讨人工智能如何影响就业，以及在许多情况下如何加剧机会和收入的不平等。我还将探讨它如何影响人与人以及人与社会的互动。随着真人和自动机器人之间的界限开始在网上变得模糊，随着人类受到大量“信息”的轰炸，通常是虚假的，信任的概念以及因此而产生的安全性是如何被动摇的。请继续关注第三部分。

额外资源

道德的定义(韦氏词典)
伦理学的定义(牛津英语词典)
数学毁灭的武器(凯西·奥尼尔著)
人工智能道德入门套件(Rachel Thomas，Fast.ai 联合创始人)
技术实践中的伦理(马库拉应用伦理中心，SCU)
走向伦理人工智能(Eirini Malliaraki 的批判性阅读清单)

这是探索人工智能伦理的三部分系列的第一部分。 第二部分，此处可用 ，潜进什么是艾的伦理。 第三部分，此处可用 ，着眼于人工智能做什么和人工智能影响什么的伦理。

非常感谢 雷切尔·托马斯*卡蒂克·杜赖萨米 和 斯里拉姆·卡拉 对初稿的反馈。一个大声喊出来也给这个领域所有牛逼的人， 其中很多都是女性 。他们是我的英雄。*

面部识别的伦理:如何使商业使用公平透明

原文：https://towardsdatascience.com/ethics-of-facial-recognition-how-to-make-business-uses-fair-and-transparent-98e3878db08d?source=collection_archive---------14-----------------------

随着计算机视觉和面部识别的日益普及，企业努力采用创新来保持领先地位。埃森哲的数据科学家报告称，在安全、客户互动、零售、营销等领域。他们预测未来将会充满科技入侵。

在这个未来，不同的场景是可能的。这引发了不可避免的讨论。当一群利益相关者表达对面部识别技术可能被滥用于监控目的的担忧时，亚马逊的认可就是如此。不是徒劳的。

通常，实施基于人工智能的创新(如面部识别)的主要理由是为了增加投资回报率。这种情况不能不引发伦理问题。组织应该如何解决人工智能的缺点？是时候把事情搞清楚了。

建造人工智能是有原因的，而不仅仅是因为一个人可以

人工智能的普及在 1965 年的会议后获得了动力，当时科学界首次联合起来研究复制人脑的方法，并使机器能够进行只有人类才能做的活动。从那时起，计算能力和数据科学领域的积极经验显著增加。

迄今为止，最新的技术堆栈、人工智能库和框架允许程序员构建广泛的基于人工智能的解决方案和应用程序，以满足各种业务需求。虽然使用了一些提供的技术堆栈，但他们可能对开发的核心原则关注不够。也就是说，伦理原则。他们中有太多的人可以创建高质量的应用程序，但是很少有人问自己关于构建一些新颖的东西的伦理方面。

作为面部识别领域的世界领导者之一，微软表达了对人工智能伦理的担忧。他们想出了 6 个核心原则来帮助开发更有意义。

道德用途的六大支柱

微软公司的 Brad Smith 分享了他的观点，他说:“先进技术不再脱离社会、我们的个人和职业生活。这意味着面部识别的潜在用途数不胜数。”该技术不仅能够影响业务发展战略，还能够影响通信、日常个人生活、日常任务、一个或另一个组织在市场上的声誉以及其在员工中的声誉。

一些使用面部识别技术的案例暴露了算法偏见，并引发了对透明度和合法性的质疑。让我们举个例子，谷歌照片中的图像识别算法揭露了种族偏见，或者奥兰多国际机场的 T2 面部扫描系统引起了人们对扫描准确性的担忧，事实上没有严格的规定来处理被错误识别的乘客。鉴于这一切，在创建和使用面部识别系统时，关注观察指南似乎是明智的。这里有 6 个基本原则:

公平
可靠性和安全性
隐私和安全
包容性
透明度
有责任

收集和处理敏感数据的道德准则已经引起了面部识别采纳者的注意。为了巩固成果，每个特定的组织都将法规视为最重要的问题，这一点至关重要。

玩公平透明的游戏

创新似乎令人毛骨悚然，除非它们能很好地向公众解释清楚。在权衡所有利弊和部署面部识别软件时，一个组织肯定会面临合理收集和使用个人数据进行面部识别的问题。坚持以下原则有助于事情朝着正确的方向发展:

告知在任何公共区域使用该技术的情况。这有助于避免可能出现的尴尬讨论，讨论让访问者不知情和侵犯隐私的合法性。
警惕数据集。面部识别系统的智能取决于训练数据集的包容性。例如，全面的数据可以帮助避免种族偏见。但是完美总是遥不可及。理想情况下，最好制定一个策略，说明如何对待面部识别错误识别的人。每个组织都可以采取具体措施，确保以平衡的方式解决问题，并树立良好的形象。
分享关于个人数据存储的信息。面部识别系统的工作可能会引发对敏感数据进一步使用的偏见。每个组织的另一个责任是确保数据的私有和安全存储。组织应该准备好解释处理个人数据的原因，告知任何无意的滥用，并有明确的证据表明数据的使用是完全透明和合法的。
培训和提高认识。任何新技术都会带来社会利益和社会担忧。但这并不意味着逃避现实。SAS 公司的 Oliver Schabenberger 承认“即使对许多老练的用户来说，人工智能仍然是一个黑盒子。”更重要的是，他建议是时候照亮这个黑匣子了，换句话说，观察它的工作，解释使用它的利弊。如果组织中的每个人都理解使用数据进行人脸识别的原则，他们就会平静地应对偏见。这种对新技术的信念是不可或缺的。

任何技术的使用都可能是好的或坏的。人工智能正在飞速发展，以帮助人类将当今的现实变得更好。然而，无意义的技术发展可能会导致社会误解，引发伦理争论。提前思考并牢记规则——这有助于打造面部识别的辉煌未来。

喜欢这篇文章吗？在这里找到更多故事:https://indatalabs.com/blog

挖掘数据科学的力量！

伦理学，技术的新前沿

原文：https://towardsdatascience.com/ethics-the-new-frontier-of-technology-815454f0d158?source=collection_archive---------25-----------------------

内部人工智能

可信人工智能之路

我们在创造怪物吗？

随着人工智能(AI)和机器学习(ML)应用融入我们生活的越来越多的方面，越来越多的声音表达了对道德影响的担忧，算法偏见(“算法，中立的幻觉”)和黑盒模型(“ X-AI，黑盒和水晶球”)缺乏透明度和可解释性的担忧。

我们正在建造超出我们智力理解能力的系统。谁能认真地假装他们理解自动驾驶汽车使用的上亿行代码？

人工智能正在朝着更加自主和类似人类的认知活动快速发展，如自然语言处理和计算机视觉。算法需要越来越少的监督才能发挥作用。在某些情况下，他们甚至开始重写自己的代码。这些“通用算法”会进化，就像生物体自然进化一样。难怪一些学术研究实验室现在正在寻找理解算法的方法，把它们当作野生动物看待，观察它们在世界上的行为。

这是否意味着我们正在创造怪物？

Photo by freestocks on Unsplash

弗兰肯斯坦的生物逃离我们控制的神话，以及对机器人杀手消灭人类的恐惧，都在助长炒作。在这个话题上，不乏制造恐慌和试图吸引我们注意力的媒体文章。然而，我认为现实完全不同。正如过去的许多技术突破一样，技术进步比社会进步更快。随着意识的建立，实践将会改变，行为准则、最佳实践和安全措施将会发展，人工智能的使用将会变得更加(自我)规范。

算法没有伦理、道德、价值观或意识形态，但人有。关于人工智能伦理的问题是关于制造和使用人工智能的人的伦理问题。

承担责任

事实上，组织已经在为更加道德和负责任地使用人工智能做准备。由福布斯 Insights 在全球 300 多名 C 级高管中进行的一项由 SAS、埃森哲和英特尔最近进行的研究明确确立了可信人工智能的重要性。文化挑战，特别是缺乏信任，被认为是阻止更广泛和更快采用人工智能的主要障碍。

大多数组织似乎正在采取行动，实施治理和监督系统来监控 AI 应用程序的输出。例如，超过一半的人至少每周审查一次人工智能系统的输出。在最成功和最成熟的组织中，这个数字上升到了 74%。

Organizations are gearing up for more ethical and responsible use of AI

伦理问题现在是创新者、技术专家和商业领袖最关心的问题。许多公司引入了伦理委员会来审查人工智能的使用，并为其员工提供伦理培训。

一些工程师有理由担心他们正在开发的技术的可能用途。最近，来自非营利人工智能组织 OpenAI 的研究人员创建了一个文本生成系统，可以对提示做出长达一页的响应，模仿从幻想散文到虚假名人新闻故事和家庭作业的一切。OpenAI 通常向公众发布其项目。然而，在这种情况下，由于担心可能的恶意使用，它决定不公开这项技术。

Photo by Lianhao Qu on Unsplash

业界已经出台了许多举措和框架来解决这个问题。例如，F.A.T.E .(公平、问责、透明、可解释)社区创建了一套原则，以帮助组织在使用人工智能时引入道德规范，应对偏见的挑战，并一致地解释模型结果。像谷歌这样的大玩家已经决定公开宣传他们使用人工智能的道德原则。2018 年 5 月，谷歌首席执行官桑德尔·皮帅宣布了一系列原则，包括不在与武器或监控相关的应用中使用人工智能，并建立“对社会有益”的人工智能应用，避免产生或加强偏见，并对人们负责。为更大利益而工作的值得称赞的努力也非常适合一家在人工智能领域投入大量资金的公司的公关活动。但趋势很明显，不容忽视。

数据科学应该是一个受监管的职业吗？

今天，数据科学家通常专注于数据分析和算法的基础科学。他们喜欢尝试新的语言和新的技术，尝试新事物，并且“处于边缘”。但是让人工智能走出实验室进入现实世界需要的不仅仅是科学。数学实际上是容易的部分。其他人也需要参与进来:

商业领袖必须设定愿景，并用商业术语定义期望的结果。他们还必须参与探索数据和见解的迭代过程，在此过程中细化业务目标。
领域专家理解数据，能够指导数据科学家做出正确的假设，选择正确的数据集，提出正确的问题，并解释结果。
IT 团队必须提供一个可控的环境来管理数据科学家开发的模型。他们有责任获取模型并将它们嵌入到应用程序中以供使用。根据业务目标和技术约束，模型必须部署在需要的地方，例如，云中、数据库中、边缘或数据流中。这个过程需要工程和数据科学团队之间的紧密协作。

所有这些人都有责任确保人工智能应用程序是值得信赖和符合道德的。然而，当每个人都有责任时，也许没有人负责。我认为，数据科学家也许应该承担更广泛的责任，监督从数据到发现和部署的端到端分析生命周期。在与工程团队、领域专家和商业领袖的合作中，他们应该充当良好实践的守护者吗？

这就引出了一个问题:数据科学是否应该成为一个受监管的职业。我们是否应该建立一套职业行为准则，对数据科学家进行严格评估，并规定责任和义务？

Photo by MD Duran on Unsplash

如果我们考虑到当前数据科学家人才的短缺，为人工智能的道德发展和使用建立标准甚至更为关键。许多新的数据科学家正在进入市场，但缺乏处理工作道德方面的意识和经验。当然，这种短缺不会通过 40 美元的在线课程来解决，这个角色完全职业化还需要时间。

人工智能监管环境的演变

然而，也有一种观点认为，这种监护应该是一个新的 C 级角色的责任。正如欧盟在某些情况下要求设立数据保护官(DPO)一样，我不会对未来几年出现新的角色感到惊讶，或者对现有角色(如首席分析官)承担新的法律责任。这将为人工智能技术的开发和使用提供必要的监督和问责。

人工智能显然已经提上了商业领袖和政策制定者的议事日程。许多政府和私人组织已经开始发布指导方针和最佳实践，为人工智能的使用提供保障。这需要一些时间，但适当的监管将随之而来，与欧盟 GDPR 非常相似。

GDPR 已经建立了强有力的规则来保护个人数据和个人数据隐私的基本权利。有很多关于 GDPR 是否包括解释权的讨论。根据 GDPR，数据主体有权:

了解自动决策；
质疑自动化系统的输出；和
如果决策对数据和逻辑有重大影响，则获取关于数据和逻辑的有意义的信息

这只是一个开始！更多的是在布鲁塞尔做饭…

Photo by Guillaume Périgois on Unsplash

欧盟委员会已经成立了欧洲人工智能高级小组，由来自学术界、民间社会和工业界的代表组成。这个多学科小组的目标是:

作为数字单一市场的一部分，为人工智能开发一个全欧洲战略，通过协调投资、规则和方法的一致性来提高欧洲在世界舞台上的竞争力；和
为可信和道德的人工智能制定指南和最佳实践，这可能会导致另一个类似于 GDPR 的法规。

因此，法律框架正忙于赶上人工智能应用的创新和新实践。然而，越来越明显的是，生产值得信赖和负责任的人工智能的能力是交付道德和商业价值的必要条件。一枚硬币的两面！

更多信息，请阅读我关于这个主题的另外两篇博客:

算法，中立的假象
X-AI，水晶球和黑盒

数据科学中的 ETL 和 DI:在金融市场数据仓库中的应用

原文：https://towardsdatascience.com/etl-and-di-in-data-science-usage-in-financial-markets-data-warehouses-21df4e1ebb42?source=collection_archive---------15-----------------------

我开始从事量化交易的回溯测试已经有几个月了。最初，所有的焦点都集中在核心活动上:策略和应该使用哪些回溯测试引擎，但是一旦项目开始滚动，其他现实世界的小挑战就需要注意了。

系统和专业的方法回溯测试的努力不仅需要机器学习、统计分析和数据分析的花哨活动，还需要数据仓库阶段的一点简陋的脚手架和管道。

在我之前的文章 如何存储金融市场数据用于回溯测试 中，我讨论了回溯测试所使用的检索策略。使用传统的实际仓库术语，如果我们在那篇文章中讨论了数据拾取挑战，那么在本文中我们将讨论数据存放策略。

将数据供应和输入到您的数据仓库涉及数据分析业务中不太光彩但同样相关的方面:保持原始数据流动，因为没有适当质量的数据输入，任务注定会失败。

内部与外部提供商

基本上有两种方法可以遵循:

与第三方数据馈送供应商签订合同，并根据需要使用他们的 API。将会有集成成本，但是您不需要构建、提供或操作您自己的数据仓库。
将不同来源的数据储存在您自己的数据仓库中。将会有集成成本，加上与构建、维护和操作您的数据仓库相关的成本。

虽然第一个选项应确保一致和高质量的数据(前提是您选择高质量的数据馈送提供商)，但它有几个局限性:

高质量的饲料很贵——大型投资公司使用的高质量饲料确实非常贵。这将限制你可以获得的资产数量，也可能限制你在其他领域或市场探索策略的创造力。数据馈送成本会危及项目预算，而项目预算可以分配给更有价值的资源和活动。
当天的第三方数据馈送通常有时间限制。虽然有理由怀疑回溯测试遥远时间的日内数据的好处(市场在发展，人们对算法交易在过去几年的影响有共识)，但测试长期策略总是一个好主意。原因是，只有在你计算大量数据的情况下，才能获得关于特定日内策略在市场机制中表现的见解，因为市场机制可能会持续数年。在你的策略中不去面对或分析市场机制的影响将会带来灾难性的后果，所以你依赖的数据越多越好。
第三方数据馈送中的期货和期权合约可能不会按结算日期分割。虽然大多数策略可能希望关注一个累计的连续期货合约——这在现实世界中并不存在，但它是一个方便的回溯测试的人工制品——但你可能会对评估不同结算日期的合约的差异、趋势或成交量峰值感兴趣。在这种情况下，找到符合这一要求的第三方数据馈送供应商可能会很困难。
为分析引擎来回移动大型数据集可能会对性能产生影响，尽管当前的网络性能(尤其是在云服务中)会使这成为一个小问题。
某些第三方供应商对客户针对服务的请求数量施加限制；这种限制通常与服务的成本有关，我们已经讨论过了。

使用第三方供应商的好处显而易见。它简化并外部化了持续输入和存储大量数据的问题，提供了一个一致的 API，该 API 通常会增加额外的财务数据。一个高质量的第三方数据源还将提供股票现金资产的价格分割和股息信息，一些供应商还提供基本面数据。

相反，从长远来看，构建自己的数据仓库可能会降低成本，前提是有足够的资源来快速构建。缺点显而易见:

开发时间会更长。你将不得不处理几个数据源和延迟的时间提供者，该项目将需要定制和辅助开发，以确保你可以覆盖所有的资产和市场，你想以后分析。
您仍然需要一次性历史数据来预配置您的数据仓库。如前所述，使用长历史数据集进行计数是相关且必需的。如果你今天就开始积累数据，至少在一两年后才会有用。
你需要适当的在线硬件资源。可能是问题较少的问题，因为云平台现在是一种商品，大量的存储和计算能力可以以相当便宜的价格作为服务购买。
您需要适当的操作程序来确保监控和数据质量。虽然您可能认为一旦平台开发完成就不会有任何问题，但是零维护项目是不存在的。必须定义一个适当的操作计划——它可以很简单，但必须存在——为此，您需要身边有熟练的资源。当你决定寻求内部解决方案时，这可能是你面临的主要障碍。

主要的优势基本上是潜在的项目整体价值收益(您的项目将有肌肉和数据)和潜在的成本节约。作为数据仓库的所有者还有一个优势，那就是可以完全控制存储什么以及如何利用它，并且可以对计算密集型的回溯测试场景产生重大影响。

毫无疑问，关键因素是成本。仅仅是构建自己的数据仓库或使用外部提供商的决定并不能决定成本:总体节省或成本很大程度上取决于可用的团队和资源。

总的来说，根据我的经验，建立和维护你自己的数据仓库可以提供可观的成本节约当且仅当已经有可用的资源来建立和维护这个项目。最后，集成第三方提要并不像人们想象的那样简单，仍然需要某种临时存储库，因此构建自己的数据存储库并不困难。

相反，如果您的项目使用标准的回溯测试软件，并且您的资源缺乏处理企业级数据仓库项目的经验，那么明智的做法是不要插手。这种情况在行业中很常见，因为人们倾向于关注和专注于回测软件。购买外部数据馈送的主要优势可能是它将操作需求降至最低。

为金融市场数据构建数据仓库并不是火箭科学——金融市场中的数据模型极其简单和一致——但正如生活中任何严肃的事情一样，它肯定需要团队中有技能和经验的资源。它提出了开发、部署和操作任务，虽然性质上并不复杂，但仍需要妥善处理。

我们的生产级平台之旅

在我们的项目中，我们决定构建自己的定制解决方案。原因是:

现有入门级回溯测试工具执行标准统计分析的功能较差。
现有的回溯测试工具在定性(而非定量)或其他基于人工智能的分析中缺乏功能。
现有回溯测试工具 API 和语言的陡峭学习曲线。
处理大型日内数据集时的性能问题。

我们的项目需求很快从孤立的测试、想法和概念演变成一个旨在获得生产级解决方案的正式项目。

这种演变的原因是，当第一次回溯测试活动开始时，很明显准备数据和策略的开销比预期的要高得多。在验证结果时，我们还发现了许多导致对结果缺乏信心的操作问题。即使在纯定量领域——现有的回溯测试解决方案大放异彩——开销也非常高。

我们发现需要一个具有数据管理、数据集成、调试、数据流、作业调度、图表、报告和验证功能的适当的框架环境。这些组件并不构成实际分析和测试的一部分，但它们对生产力有着巨大的影响，如此之大，以至于它们可以单独决定任务的成败。从长远来看——定量业务无疑是一个非常漫长的旅程——这样的环境将提供巨大的回报，并能够快速测试、验证、抛弃和采用战略。

为什么数据集成(DI)和提取-转换-加载(ETL)简化了集成并提供了进一步的分析可靠性

正如上一段所讨论的，从项目的早期阶段就可以清楚地看出，需要一个明确的解决方案来解决数据管理、集成、调试、制图、报告和验证等问题。

在评估了几个备选方案(包括 Jupyter 笔记本电脑等数据科学中的经典选项)后，结论很明显:所有这些解决方案都是为起草、评估和原型制作小概念而构建的。绝不是说，它们可以用来构建任何大型项目所需的协作、开发和生产环境。

在对所需的主要组件进行快速评估和起草后，我们发现一个好的解决方案是利用现有的数据集成平台(它基本上进一步扩展了 ETL —提取转换加载—概念)来处理所有基本任务，并提供一个成熟的流程、作业、转换、调试和报告环境。

虽然数据集成不参与实际的回溯测试分析，但它将简化构建解决方案所需的不同流程和工作的编排；在我们的项目中，它已经被证明是一个非常有效和有用的伙伴。

Flow excerpt to provision EUREX Futures intraday data: the visual approach mixed with lightweight custom Java code lead to full implementation of the data provisioning project leg in just two weeks. Easy to maintain, monitor and self-documented.

数据集成(DI)平台(有几种，包括商业的和开源的)将提供成熟的、企业级的和可扩展的框架来处理数据处理需求。这种基本级别的集成和操作在任何涉及长期处理多个数据源的项目中都是一个不变的需求，金融市场也不例外。

与流行的观点相反，数据集成平台的主要好处与避免或最小化定制编码无关；它们涉及有效地自我记录流程，并在开发和生产环境中为流程和作业框架提供适当的调试、调度、监控和报告工具。这些要点是真正的关键优势。

在我们的案例中，我们决定使用 Hitachi Vantara 作为我们的数据集成解决方案，它可以通过使用 Java 自定义类轻松扩展，学习曲线也非常容易。我并不是在推销这个解决方案，而是利用其中一个，结果可能与其他解决方案一样好。我们发现 Hitachi Vantara 在资源方面有点庞大，但它具有良好的性能和与 Java 的出色集成——这一点与我们的情况相关，因为我们团队的 Java 技能很强，并且部分 AI 分析正在用 Java 进行原型开发。

采用该解决方案后，我们设法在两周左右的时间内解决了所有主要的数据供应问题，包括学习曲线和平台安装。我们发现它是一个非常有用的工具，对于开发和生产环境都是如此，并且它代表了加速项目的巨大支持。

摘要

量化交易需要大数据集来测试、训练和评估。它既与长期历史记录相关，也与评估不同市场机制的策略相关，还能不断向我们的存储库提供新数据。这就需要一个数据仓库或一个外部数据源来按需提供数据。

我们可以为想要评估的资产和市场购买订阅服务。这将提供一种更容易的方法来检索数据，但如果市场数量很大，并且我们利用高质量的数据，这可能会很昂贵。如果您的项目缺乏企业级数据集成项目的实践经验，这可能是明智的选择。

构建您自己的存储库并不复杂，如果您的项目按时使用正确的资源，这可能是一个好主意。在这种情况下，内部数据仓库只需付出非常有限的努力，就可以实现显著的节约。在朝着这个方向发展的情况下，利用数据集成平台被证明是有帮助的，可以简化开发和生产环境，并增加我们的数据分析和流程的可信度。

欧洲电视网、蒙特卡洛分析和战术投票的检测

原文：https://towardsdatascience.com/eurovision-monte-carlo-analysis-and-the-detection-of-tactical-voting-8d5fe04acb99?source=collection_archive---------19-----------------------

这些年来，欧洲电视网如何变得更具战术性，但也更平衡。

欧洲电视网颂歌

对于那些不知道的人，我敢打赌，欧洲电视网歌曲大赛是一年一度的音乐比赛，在这场比赛中，一个(松散的)联盟团体(主要是)欧洲国家在电视直播中相互合作，为对方推荐一首获胜的歌曲。在 X 因素的风格，竞争是由选民电话决定的。

每个国家都给他们的前 10 个选择打分，分值范围从[1，2，3，4，5，6，7，8，10，12]。非零分值只能给一次(例如，法国只能给一个国家打 12 分)。

很长一段时间以来，欧洲电视网一直是我罪恶的快乐。我作为第三种文化的孩子在非洲、欧洲和亚洲长大。欧洲电视网对流行文化的奇异融合，其接受和开放的自由氛围，结合其对竞争、地缘政治和阴谋耳语的脚踏实地的帮助，一直对我有吸引力。除了纯粹的娱乐价值，我一直认为它是大多数多边主义尝试的一个相当有代表性的模拟:有价值，混乱，不可避免的战略。

不仅如此，数据科学的时机已经成熟。事实证明我不是唯一这么想的人。预测比赛结果是卡格尔组织的第一次比赛。更幸运的是，Data World 的优秀人员维护了竞赛历史上所有国家发出和收到的投票的最新数据。

研究问题:战略投票变得“更糟”了吗？

让多边类比再持续一会儿，直到我让它死去，欧洲电视网并不是没有派系和诽谤者。近年来，越来越多的人(主要来自西欧国家)抱怨说，竞争现在基本上是一场战略投票集团(主要包括西欧和东欧)的游戏，其中东欧大量的后苏联小国意味着，很久以前的传统赢家(见爱尔兰，自 20 世纪 70 年代开始以来，仍然是“最多胜利”的纪录保持者)几乎没有获胜的机会。这种争论甚至导致了 2006 年对分数分配方法的审查，该审查引入了一个比大众投票更“客观”的评委小组来代表 50%的分数授予标准。

出现的问题是:

1。)欧洲电视网有策略投票吗？

2。)这些年来，战略投票的数量增加了吗？

Git hub 代码库可以在这里找到:【https://github.com/InternetGareth/EuroVision

探索数据

在深入研究之前，最好先看看数据的结构。首先，看起来数据不仅包括决赛的投票，还包括多轮比赛(四分之一决赛、半决赛等)的投票。这一点值得后面分析的时候记住。

Imported DataFrame

需要记住的第二个问题是，对于所有年份，但特别是如果分析仅限于最终结果，国家的数量和值将会逐年变化。

The total countries in the final changes each year

最后，只是为了确认一下，数据捕捉到了比赛的任意点数方案:{0，1–8，10，12 }

网络分析

我采用的第一种方法是将所有数据导入 Python 中的 Networkx 包，并应用一些基本的社区检测。投票的数据框架可以表示为一个网络，其中节点是竞争中的国家，边是国家之间给予和接受的投票。给定这些参数，我们可以认为这个网络是双向和加权的。

社区检测

一旦数据是这种格式，我决定尝试一些社区检测，看看是否确实有一些基于地理的投票块。在这个例子中，我使用了 Louvain 模块性作为我的检测算法。本质上，该算法试图根据最大化“社区”内的边与“社区”外的边的密度比的标准来优化社区及其成员的数量。

Modularity: Objective function to maximize in Louvain community detection Source: https://en.wikipedia.org/wiki/Louvain_Modularity

以下是过去 5 年投票(2013–2018)中所有比赛阶段(半决赛、决赛等)的分析结果:

Community detection for 2013–2018, all competition stages

看起来有一些关于东方和西方正在进行投票的看法是真实的。两个最大的社区是:

绿色:主要是西欧/北欧国家。
蓝色:主要是巴尔干/东欧国家。

使用 Jaccard 指数检测社区变化

因此，我们有一些证据表明，在过去几年里，各国确实倾向于整体投票。我的下一步是试图想出一种方法来跟踪这些块是否随时间而改变。我选择使用一个 Jaccard 指数来比较社区如何随着时间的推移保持一致性。Jaccard 指数是一个非常简单的指标:它是两个集合的交集:(A∩B)/A∪B。对于像国家列表这样直接的东西，它让我很好地了解了这些社区随着时间的推移有多相似。具体来说，我编写了一个算法:

每年检测到的社区(基于当年和前 3 年所有国家之间的投票总数)
对于每个社区，将其与去年的“最佳”匹配进行比较(比较时 Jaccard 最高的社区)
对于所有匹配，计算当年的平均加权 Jaccard 分数

然后，该值将告诉我投票群体/社区随时间保持一致的程度，以及是否有投票行为发生巨大变化的年份。结果如下。请注意，因为 Lauvain 算法通过查找局部解来优化速度，所以每次运行它都会产生稍微不同的结果。为了解决这一问题，每年重复检测 50 次，并给出每个加权平均 Jaccard 指数的 95%置信区间:

Weighted average Jaccard Index between detected voting communities (current year compared to previous year)

这告诉我们，在 2004-2006 年间，发生了一些事情，从根本上“动摇”了参与竞争的投票群体。事实证明，对此有一个很好的解释；2004 年以前，只有进入决赛的国家才能投票选出冠军。2004 年后，改变了这种做法，允许那些没有进入决赛的国家仍然可以投票。因此，我们似乎是解释战略投票的一部分:通过向退出的国家开放竞争投票，投票“社区”自 2004 年以来发生了显著变化。

使用蒙特卡罗分析深入研究策略投票

我现在知道有不同的选民群体，他们在 2004 年经历了一次重新洗牌。然而，为了让投票真正具有“战略性”，人们会期望它是对等的:即各国一直相互投票。幸运的是， Derek Gatherer (2004) 有一篇很棒的论文，描述了一种基于蒙特卡罗方法的检测策略投票的方法。该方法采取以下步骤:

选择一个时间段(例如 5 年)

2。对于每一年，计算一个国家给另一个国家的所有可能点的无偏概率密度函数。这相对容易:所有非零点数类别都有 1 / (N-1)次机会，其中 N 是投票国家的数量。零点类别将有(N-10)/N 次机会。其中 10 是非零点类别的数量。

Example probability distribution for votes given in year 2000

3。对这些年的投票进行蒙特卡洛模拟,计算一个国家在该时间段内给予一个国家的总票数的概率分布。同样，这只是一个从每年的分布中随机抽样和合并总点数的问题。以下是 2000 年至 2005 年期间 2000 次运行模拟的示例。正如我们所料，这是严重倾斜到零，因为大多数国家不会使削减赢得积分。平均而言，在 2000 年至 2005 年期间，你可以期望从任何其他国家收到总共约 2.3 张选票。

Frequency distribution of total votes given by a country to another county: Mont Carlo Simulation for years 2000 to 2005

4。与实际投票模式进行比较:如果实际投票数在分布的 5%范围内，则投票被视为“偏袒”。如果对方国家投桃报李，投票被认为是“战略性的”。

结果

使用上述方法，我能够发现国家之间的战略投票，以及它们多年来的变化。下图显示了(I)标准化交易率(战略关系)，定义为(交易总数/可能的交易总数)和(I)战略关系国家的百分比。

本质上，这是对同一趋势的两种度量，但是将它们分开考虑是有用的。

% Countries in deals , and the rate of deal making

更仔细地观察其自身轴上的交易达成率，我们可以更清楚地看到，随着时间的推移，交易达成率大幅增加(测量的趋势与交易中国家的百分比非常相似):

因此，我们现在知道，这些年来，不仅投票群体发生了显著变化，而且互惠投票(即策略投票)似乎也在增加。那么，西方各州的抱怨是正确的吗？嗯…是也不是…

映射投票社区

那么这些战略联盟是谁呢？有必要绘制一些样本，让我们了解谁在与谁合作。以下是使用蒙特卡罗方法发现的战略联盟，以 5 年为增量:

1995 年至 2000 年

Cyprus and Greece have each other’s back in the late 1990s

As do the infamous Scandinavian / Northern voting block

The beginnings of the eastern voting block emerge

2000 年至 2005 年

The Balkans get strategic: an opening up of voter eligibility increases volume of strategic alliances, where regional solidarity encourages the growth of a new voting block in Eastern Europe.

And some countries forget to join the party….

2005 年至 2010 年

The web of alliances gets more complex as the years go by, but is still defined by centers in Scandinavia, Eastern Europe, and the Balkans

And the U.K. wonders why it never wins any more…

结论

2004 年投票规则的变化对竞争产生了重大影响:竞争变得更具战略性，但这可能更多地是由于 2004 年投票规则的修订，该修订将更多的地区团结带入了投票中(而不是东方国家的任何阴谋活动！).

战略性投票增加:这些年来，战略性投票一直在增加，在 2004 年修订规则之前，这种趋势一直呈上升趋势。它似乎也没有受到引入“客观”评判小组的影响。

然而，这更多的是其他国家在西方玩自己的游戏:值得注意的是，抱怨这一点的国家(大多是年龄较大的西欧选手)发明了战略投票的游戏:特别是斯堪的纳维亚投票区，还有英国-马耳他-爱尔兰的联系。

我将留给你们关于欧洲电视网的许多教训的最后一个想法，这在目前看来是恰当的。值得记住的是，人们通常会认为一些国家相对实力的下降并不是绝对的实力“下降”,而是世界其他国家崛起的成功故事。

规避机器学习恶意软件分类器

原文：https://towardsdatascience.com/evading-machine-learning-malware-classifiers-ce52dabdb713?source=collection_archive---------8-----------------------

为了乐趣和利益！

介绍

在这篇文章中，我将详细介绍我在今年 DEFCON AI Village 上宣布的机器学习静态规避比赛中获胜时使用的技术。比赛的目标是获得 50 个恶意的 Windows 可移植可执行(PE)文件，以逃避三个机器学习恶意软件分类器的检测。这些文件不仅需要躲避检测，而且还必须保持它们原来的功能和行为。

本次比赛由残局、MRG-艾菲塔斯和 VM-Ray 赞助。比赛非常有趣，获胜后会有一份令人敬畏的奖品！

了解你的敌人

这是一场白盒竞赛；这意味着我可以完全访问所有的模型参数和源代码。因此，首先要做的是打开模型，看看引擎盖下发生了什么。

马尔康夫

第一个模型是在 Windows 可执行文件的原始字节上训练的神经网络。MalConv 是在 PyTorch 中实现的，如果您已经熟悉神经网络，那么代码相对简单明了:

文件作为表示文件字节的整数序列(0–255)传递给 MalConv。MalConv 内部的嵌入层将每个字节映射到一个数字向量。向量序列然后可以由附加的神经网络层处理。该模型输出两个数字，表示输入为良性和恶意的概率。

已经有大量关于躲避 MalConv 的文献了。最简单的攻击是在可执行文件的末尾添加一些好看的东西。这是一个特别好的技巧，因为当恶意软件执行时，添加的数据(也称为覆盖)不会加载到内存中。因此，我们可以在不改变文件功能的情况下，在覆盖层中放置任何我们想要的东西。MalConv 寻找良性和恶意字节模式，以便做出决定。覆盖攻击的目的是用与良性文件相关的模式将其淹没。

非负 MalConv

第二个模型实际上与第一个模型相同，但赋予各层的权重不同。顾名思义，非负 MalConv 在训练期间被约束为具有非负权重矩阵。这样做的目的是防止像 MalConv 那样的小攻击。当操作得当时，非负权重使得二元分类器单调；这意味着添加新内容只会增加恶意得分。这将使规避模型变得非常困难，因为大多数规避攻击都需要向文件中添加内容。对我来说幸运的是，非负 MalConv 的这个实现有一个微妙但关键的缺陷。

非负防御仅对具有代表样本恶意性的单一输出分数的二元分类器有效。这个版本将输出分成两个分数:一个是恶意的，一个是良性的。然后，softmax 函数将分数转换为每个类别的概率。这种结构使得非负权重的训练毫无意义。附加内容仍然可以将良性分数任意推高。随着良性分数升高，softmax 功能会降低恶意分数，即使存在相同数量的恶意内容。所以所有针对 MalConv 的攻击在这里也会起作用。

如果你对更多的数学细节感兴趣，看看这篇论文的附录 A。作者证明了具有非负权重的 softmax 网络就其可以学习的内容而言本质上等价于无约束网络。这就是为什么一个适当的防御必须使用单一输出；我们不希望网络学会寻找良性内容。

Excerpt from paper: http://ci.louisville.edu/zurada/publications/chor-zur-tnnls.pdf

余烬

Ember 实际上是一个由 Endgame 维护的数据集。随着数据集而来的是一个经过训练的基准模型(我也称之为 Ember)。Ember 是一个 lightgbm 模型(一组增强的决策树),根据从 Windows PE 文件解析的几个特征进行训练。

Ember 特性解析的源代码位于这里。查看所有特征是如何被解析的对于精心设计攻击非常有用。提取的特征包括:

字节直方图
字节熵
截面信息(名称、大小、熵、属性)
导入表库和条目
导出的函数
一般文件信息(各种东西的大小和数量)
标题信息(机器、架构、链接器、版本等。)
字符串(关于文件中字符串的各种统计信息)
数据目录(名称、大小、虚拟地址)

数字特征按原样使用，而散列技巧用于将其余特征(如部分名称)转换成数字向量。乍一看，Ember 看起来更难糊弄。许多功能与文件的结构或我们无法改变的特征有关。记住，我们必须在保持原有功能的同时躲避检测！

Ember 的漏洞在于，一些功能可以被攻击者任意控制。lightgbm 模型在整个树集合的多个位置使用这些特征。我们可以通过操纵特征来利用模型的复杂性，以便沿着导致规避的路径推动决策。

准备

竞赛代码附带了一个脚本，用于针对一个文件运行所有三个模型。我修改了脚本来评估恶意软件的整个目录，并使用牛郎星来添加一个有趣的视觉记分牌:

Initial scan of original malware files.

头骨表情符号代表一个模型检测到了恶意软件，而快乐的脸代表一种逃避。有趣的是，49 号文件已经避开了 MalConv，所以我们可以免费得到 1 分！

规划

在花了几分钟弄清楚如何用表情符号进行策划后，我决定是时候考虑如何应对这场比赛了。棘手的部分是找到同时影响所有三个模型的有效操作，或者至少影响一个模型，但不会对其他模型发出危险信号。我决定将重点放在有希望同时影响所有三个模型的攻击上。

覆盖层

如上所述，PE 文件可以附加任意内容。这些额外的字节被称为覆盖，当 Windows 执行文件时，它们不会被加载到内存中。因此，在这里添加字节不会改变恶意软件的功能。

松弛空间

除了覆盖之外，在每个部分的末尾还有空间来添加额外的字节。PE 部分需要与内存量的 2 次方对齐。当实际内容没有填满整个空间时，该部分被填充。可执行文件不会访问这部分内存，所以我们也可以自由地改变这个空间。

新章节

除了向现有部分添加字节，我们还可以创建新的部分。新的部分不会破坏文件的功能，因为在现有的代码中没有对它们的引用。这给了我们足够的空间来添加任何我们想要的内容。

聚焦功能

因为 MalConv 模型将所有东西都视为字节(没有结构上下文)，所以对他们来说，我们只需关注用他们认为是良性文件的模式来压倒他们的决定。然而，余烬的特征结构要求我们实际考虑可能阻碍它的细节。

我们可以操作的最明显的特征是字节直方图和字节熵。字节直方图只是计算文件中每个字节值的归一化频率。因为我们可以添加包含任何内容的部分，所以将字节分布强制为我们想要的任何目标分布是微不足道的。

我们也有体面的控制部分信息功能。我们可以通过使用松弛空间来改变截面的熵。我们也可以改变部分的名称，这可以把我们带到 Ember 决策树的不同分支。

最后，字符串特性也非常容易被操纵。同样，因为我们可以添加包含任何内容的新部分，所以我们可以根据自己的需要调整字符串统计。

亲爱的

以上所有修改都可以使用 Ember 用来解析特性的同一个库来完成: lief 。LIEF 项目非常棒，我绝对推荐你去看看。我用它来解析恶意软件，进行修改，并重建 PE 文件；挺神奇的！

这里有一个简短的演示，展示了修改 PEs 是多么容易:

一般的工作流程是:解析 PE，进行任何修改，构建新的 PE，保存到磁盘。

验证虚拟机

我还安装了 Windows 虚拟机来进行逆向工程。重要的是观察被改变的文件，以确保它们的行为与原始恶意软件相同。每当我需要一个废弃的 Windows 虚拟机，我就从这里拿一个。

Watching the Procmon output of an altered file being executed.

攻击时间

我的计划是从简单开始，然后根据需要增加复杂性。新的部分似乎是最有希望的攻击途径，因为它为我们提供了对 Ember 的功能以及文件的原始字节进行重大更改的能力。我编写了下面的函数，以便添加一个节并用一个常数值填充它:

我在每个部分添加之后都重新构建了 PE，这样 lief 就可以为我处理所有的寻址。也可以手动分配地址。

作为一个实验，我在每个文件中添加了一个包含 100，000 个常量字节的新部分，并在迭代常量(0–255)时监控了规避率。几个不同的值都成功了，但是值 169 (0xA9)引起了最多的逃避:

Evasion success from adding a section filled with 100,000 0xA9’s to each file.

这个简单的攻击摧毁了两个神经网络模型。如果我们没有发现非负模型中的错误，这个结果应该会提醒我们。单调分类器不应该受这个简单加法的影响。

恩伯勇敢地面对这种幼稚的攻击。我必须想出一个更聪明的方法来改变它的分数。

融入其中

接下来，我去了微软的下载页面，抓取了一份随机的良性可执行文件(下载链接)。我运行了该文件的模型，以确认其得分非常低。我的计划是模仿这个文件中已知的好的特征，希望引起对 Ember 的回避。

我在文件上运行了命令行实用程序字符串。该实用程序从二进制文件中解析出所有可打印的字符串。我发现一大块字符串似乎包含微软的最终用户许可协议(EULA)。我抓取了这一部分，并将其保存到一个文本文件中。

显然，一些最常见的 Windows PE 文件碰巧是由微软制作的。因此，当训练恶意软件分类器时，训练集很可能有一堆标记为良性的 Microsoft 文件。我的想法是利用这种可能性，从我下载的文件中添加一些东西到我们的恶意软件中。像微软 EULA 这样的东西可能会出现在许多良性文件中。这应该使字符串统计、字节分布和熵更像一般的良性文件。

我编写了下面的函数，从保存的文件中读入字符串，并将它们放在我们的恶意 PEs 的一个新部分中:

我利用这次攻击向每个文件添加了 75 个新的部分(竞争对手有一个文件大小的限制，我必须遵守这个限制)。我还加入了之前的攻击来维持我们在 MalConv 的逃避。新的结果很有希望:

Evasion results from combined “String Attack” and “Constant Attack”.

最后润色

我只剩下几个文件可以逃避了。经过进一步分析，这些文件中有几个被打包了。我的操作打乱了他们的拆包程序，因此破坏了功能。

更糟糕的是，至少有一个文件似乎有代码来检测它是否被篡改过:

This file has code to check itself for tampering…

我的第一个想法是在调试器中打开文件，修补汇编指令，检查篡改。不幸的是，该文件也有反调试代码，基本的反调试程序无法绕过。

The file also has anti-debug mechanisms.

我感觉自己很快就要掉进一个危险的兔子洞，所以我后退一步，仔细考虑了一下。

幸运的是，防篡改机制只检查 PE 中加载到内存中的部分。因此，虽然我不能添加新的部分，我应该仍然能够操纵覆盖！

我已经看到我的字符串攻击没有强大到足以在这些文件上欺骗 ember。我需要一种不同的方法来找出什么内容应该添加到覆盖图，以引起规避。我求助于我的简单的第一个座右铭，并编写了以下代码来系统地尝试每个字节值的条带，如果它们降低了 Ember 的分数，就将它们添加到文件中。这以贪婪的方式继续下去，直到文件被回避或者变得太大。

我用 Ember 替换了另外两个模型，并使用相同的方法添加所需的字节来避开这些模型。同样，因为我向覆盖图中添加了字节，所以打包、功能或防篡改检查都没有受到影响！我回去对所有文件进行了攻击，发现它能够普遍导致规避。

Perfect Score!

结论

通过相对简单的修改，所有 50 个文件都躲过了恶意软件分类器的检测。幸运的是，所有的模型都有可以被利用的漏洞。如果非负 MalConv 模型被正确地实现，一个完美的分数甚至是不可能的。

读者可能已经熟悉了最近的发现一个简单的方法来规避一个众所周知的基于机器学习的反病毒产品。虽然没有一个竞争分类器是生产系统，但这些结果应该作为对基于机器学习的恶意软件检测器的设计者的警告。很难找到一组能够区分良性和恶意文件，同时在敌对威胁模式下相对安全的功能。正如这里看到的，小细节真的很重要！

再次感谢残局、MRG-艾菲塔斯和 VM-Ray 带来了一场有趣且相当愉快的比赛。希望我们看到更多的 InfoSec 公司进入这一审查级别，并参与更广泛的机器学习/安全社区。

评估主题模型:潜在狄利克雷分配(LDA)

原文：https://towardsdatascience.com/evaluate-topic-model-in-python-latent-dirichlet-allocation-lda-7d57484bb5d0?source=collection_archive---------0-----------------------

深度剖析

构建可解释主题模型的分步指南

前言:本文旨在提供潜在主题的综合信息，不应被视为原创作品。这些信息和代码通过一些在线文章、研究论文、书籍和开源代码被重新利用

在之前的文章中，我介绍了主题建模的概念，并通过使用 Gensim 实现，在 python 中使用潜在的 Dirichlet 分配(LDA)方法来开发您的第一个主题模型。

基于这种理解，在本文中，我们将更进一步，概述通过主题一致性度量来定量评估主题模型的框架，并使用 Gensim 实现来共享 python 中的代码模板，以实现端到端的模型开发。

为什么要评估主题模型？

https://tinyurl.com/y3xznjwq

我们知道，概率主题模型，如 LDA，是文本分析的流行工具，提供了语料库的预测和潜在主题表示。然而，有一个长期的假设，即这些模型发现的潜在空间通常是有意义和有用的，并且由于其无监督的训练过程，评估这些假设是具有挑战性的。此外，有一个没有黄金标准的主题列表来与每个语料库进行比较。

然而，同样重要的是确定一个经过训练的模型客观上是好是坏，以及有能力比较不同的模型/方法。要做到这一点，就需要一个客观的质量衡量标准。传统上，并且仍然对于许多实际应用来说，为了评估是否已经学习了关于语料库的“正确的东西”，使用隐含知识和“目测”方法。理想情况下，我们希望在一个可以最大化和比较的单一指标中捕获这些信息。

让我们大致了解一下评估中常用的方法:

眼球模型

前 N 个单词
主题/文档

内在评估指标

捕获模型语义
主题可解释性

人类的判断

什么是主题

外部评估指标/任务评估

模型擅长执行预定义的任务吗，比如分类

自然语言是杂乱的，模糊的，充满了主观的解释，有时试图清除模糊会使语言变成一种不自然的形式。在本文中，我们将探讨更多关于主题一致性的内容，主题一致性是一种内在的评估标准，以及如何使用它来定量地证明模型选择的合理性。

什么是话题连贯？

在理解话题连贯性之前，我们先来简单看一下困惑度。困惑度也是一种内在的评估度量，广泛用于语言模型评估。它捕捉了一个模型对它以前没有见过的新数据有多惊讶，并作为一个拒不接受的测试集的归一化对数似然性来衡量。

专注于对数似然部分，您可以将困惑度量视为测量一些新的看不见的数据给定之前学习的模型的可能性。也就是说，模型在多大程度上代表或再现了保留数据的统计数据。

然而，最近的研究表明，预测可能性(或等价地，困惑)和人类的判断往往不相关，甚至有时略有反相关。

针对困惑进行优化可能不会产生人类可解释的主题

这种困惑测量的限制成为更多工作的动机，试图模拟人类的判断，从而主题连贯性。

主题连贯性的概念将许多测量方法结合到一个框架中，以评估由模型推断的主题之间的连贯性。但在此之前…

什么是话题连贯？

主题连贯性测量通过测量主题中高得分单词之间的语义相似度来对单个主题评分。这些度量有助于区分语义上可解释的主题和统计推断的工件。但是…

什么是连贯？

如果一组陈述或事实相互支持，就说它们是连贯的。因此，一个连贯的事实集可以在涵盖所有或大部分事实的上下文中进行解释。连贯事实集的一个例子是“这项运动是一项团队运动”，“这项运动是用球进行的”，“这项运动需要巨大的体力”

一致性度量

让我们快速看一下不同的一致性度量，以及它们是如何计算的:

C_uci 测度是基于滑动窗口和给定顶词的所有词对的逐点互信息(PMI)
C_umass 基于文档同现计数、一前分割和对数条件概率作为确认度量
C_npmi 是使用归一化逐点互信息(npmi)的 C_uci 一致性的增强版本
C_a 基于上下文窗口、顶部单词的成对比较以及使用归一化逐点互信息(NPMI)和余弦相似度的间接确认测量

当然，主题模型评估的概念和连贯性测量还有很多。但是，请记住本文的长度和目的，让我们将这些概念应用到开发一个至少比使用默认参数更好的模型中。此外，我们将重新利用已经可用的在线代码来支持这一练习，而不是重新发明轮子。

模型实现

完整的代码可以从 GitHub 上的 Jupyter 笔记本中获得

加载数据
数据清理
短语建模:二元语法和三元语法
数据转换:语料库和词典
基础模型
超参数调谐
最终模型
可视化结果

加载数据

对于本教程，我们将使用 NIPS 会议上发表的论文数据集。NIPS 会议(神经信息处理系统)是机器学习社区最负盛名的年度活动之一。CSV 数据文件包含从 1987 年到 2016 年(29 年！).这些论文讨论了机器学习中的各种主题，从神经网络到优化方法，等等。

让我们从查看文件的内容开始

**import zipfile
import pandas as pd
import os

# Open the zip file
with zipfile.ZipFile("./data/NIPS Papers.zip", "r") as zip_ref:
    # Extract the file to a temporary directory
    zip_ref.extractall("temp")

# Read the CSV file into a pandas DataFrame
papers = pd.read_csv("temp/NIPS Papers/papers.csv")

# Print head
papers.head()**

数据清理

因为这个分析的目标是执行主题建模，所以我们将只关注每篇论文的文本数据，而忽略其他元数据列

**# Remove the columns
papers = papers.drop(columns=['id', 'title', 'abstract', 
                              'event_type', 'pdf_name', 'year'], axis=1)

# sample only 100 papers
papers = papers.sample(100)

# Print out the first rows of papers
papers.head()**

移除标点符号/小写字母

接下来，让我们对 paper_text 列的内容进行简单的预处理，使它们更易于分析，并得到可靠的结果。为此，我们将使用正则表达式删除所有标点，然后将文本小写

**# Load the regular expression library
import re

# Remove punctuation
papers['paper_text_processed'] = papers['paper_text'].map(lambda x: re.sub('[,\.!?]', '', x))

# Convert the titles to lowercase
papers['paper_text_processed'] = papers['paper_text_processed'].map(lambda x: x.lower())

# Print out the first rows of papers
papers['paper_text_processed'].head()**

分词并进一步清理文字

让我们把每个句子标记成一个单词列表，去掉标点符号和不必要的字符。

**import gensim
from gensim.utils import simple_preprocess

def sent_to_words(sentences):
    for sentence in sentences:
        yield(gensim.utils.simple_preprocess(str(sentence), deacc=True))  # deacc=True removes punctuations

data = papers.paper_text_processed.values.tolist()
data_words = list(sent_to_words(data))

print(data_words[:1][0][:30])**

短语建模:二元和三元模型

二元模型是在文档中频繁出现的两个词。三元模型是三个经常出现的词。我们例子中的一些例子有:“back_bumper”、“oil_leakage”、“maryland_college_park”等。

Gensim 的短语模型可以构建和实现二元模型、三元模型、四元模型等。短语的两个重要参数是最小计数和阈值。

这些参数的值越高，单词就越难组合。

**# Build the bigram and trigram models
bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100) # higher threshold fewer phrases.
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)  

# Faster way to get a sentence clubbed as a trigram/bigram
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)**

移除停用词，制作二元模型，并使其词条化

模型准备好了。让我们定义函数来删除停用词，制作三元模型和词汇化，并按顺序调用它们。

**# NLTK Stop words
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords

stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])

# Define functions for stopwords, bigrams, trigrams and lemmatization
def remove_stopwords(texts):
    return [[word for word in simple_preprocess(str(doc)) if word not in stop_words] for doc in texts]

def make_bigrams(texts):
    return [bigram_mod[doc] for doc in texts]

def make_trigrams(texts):
    return [trigram_mod[bigram_mod[doc]] for doc in texts]

def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
    """https://spacy.io/api/annotation"""
    texts_out = []
    for sent in texts:
        doc = nlp(" ".join(sent)) 
        texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
    return texts_out**

让我们按顺序调用函数。

**!python -m spacy download en_core_web_sm
import spacy

# Remove Stop Words
data_words_nostops = remove_stopwords(data_words)

# Form Bigrams
data_words_bigrams = make_bigrams(data_words_nostops)

# Initialize spacy 'en' model, keeping only tagger component (for efficiency)
nlp = spacy.load("en_core_web_sm", disable=['parser', 'ner'])

# Do lemmatization keeping only noun, adj, vb, adv
data_lemmatized = lemmatization(data_words_bigrams, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV'])

print(data_lemmatized[:1][0][:30])**

数据转换:语料库和词典

LDA 主题模型的两个主要输入是词典(id2word)和语料库。让我们创造它们。

**import gensim.corpora as corpora

# Create Dictionary
id2word = corpora.Dictionary(data_lemmatized)

# Create Corpus
texts = data_lemmatized

# Term Document Frequency
corpus = [id2word.doc2bow(text) for text in texts]

# View
print(corpus[:1][0][:30])**

Gensim 为文档中的每个单词创建一个唯一的 id。上面显示的产生的语料库是(word_id，word_frequency)的映射。

例如，上面的(0，7)意味着，单词 id 0 在第一个文档中出现了七次。同样，单词 id 1 出现三次，依此类推

基础模型

我们拥有训练基本 LDA 模型所需的一切。除了语料库和词典，您还需要提供主题的数量。除此之外，alpha 和 eta 是影响主题稀疏性的超参数。根据 Gensim 文档，两者都默认为 1.0/num_topics prior(我们将对基本模型使用默认值)。

chunksize 控制在训练算法中一次处理多少个文档。增加块大小将会加快训练速度，至少只要文档块容易放入内存。

通道控制我们在整个语料库上训练模型的频率(设置为 10)。通行证的另一个词可能是“时代”。迭代在某种程度上是技术性的，但本质上它控制了我们对每个文档重复特定循环的频率。将“遍数”和“迭代数”设置得足够高很重要。

**# Build LDA model
lda_model = gensim.models.LdaMulticore(corpus=corpus,
                                       id2word=id2word,
                                       num_topics=10, 
                                       random_state=100,
                                       chunksize=100,
                                       passes=10,
                                       per_word_topics=True)**

查看 LDA 模型中的主题

上面的 LDA 模型是用 10 个不同的主题构建的，其中每个主题是关键字的组合，并且每个关键字对主题有一定的权重。

您可以使用LDA _ model . print _ topics()*查看每个主题的关键字以及每个关键字的权重(重要性)*

**from pprint import pprint

# Print the Keyword in the 10 topics
pprint(lda_model.print_topics())
doc_lda = lda_model[corpus]**

计算模型复杂度和一致性分数

让我们计算基线一致性分数

**from gensim.models import CoherenceModel

# Compute Coherence Score
coherence_model_lda = CoherenceModel(model=lda_model, texts=data_lemmatized, dictionary=id2word, coherence='c_v')
coherence_lda = coherence_model_lda.get_coherence()
print('Coherence Score: ', coherence_lda)**

连贯性得分:0.301

超参数调谐

首先，让我们区分模型超参数和模型参数:

模型超参数可视为机器学习算法的设置，由数据科学家在训练前进行调整。例如随机森林中的树的数量，或者在我们的例子中，主题的数量 K

模型参数可以被认为是模型在训练期间学习的内容，例如给定主题中每个单词的权重

现在我们已经有了默认 LDA 模型的基线一致性分数，让我们执行一系列敏感性测试来帮助确定以下模型超参数:

主题数量(K)
狄利克雷超参数α:文档主题密度
狄利克雷超参数β:词主题密度

我们将按顺序执行这些测试，通过保持其他参数不变，一次执行一个参数，并在两个不同的验证语料库集上运行它们。我们将使用 C_v 作为我们选择的性能比较指标

**# supporting function
def compute_coherence_values(corpus, dictionary, k, a, b):

    lda_model = gensim.models.LdaMulticore(corpus=corpus,
                                           id2word=dictionary,
                                           num_topics=k, 
                                           random_state=100,
                                           chunksize=100,
                                           passes=10,
                                           alpha=a,
                                           eta=b)

    coherence_model_lda = CoherenceModel(model=lda_model, texts=data_lemmatized, dictionary=id2word, coherence='c_v')

    return coherence_model_lda.get_coherence()**

让我们调用这个函数，并在主题、alpha 和 beta 参数值的范围内迭代它

**import numpy as np
import tqdm

grid = {}
grid['Validation_Set'] = {}

# Topics range
min_topics = 2
max_topics = 11
step_size = 1
topics_range = range(min_topics, max_topics, step_size)

# Alpha parameter
alpha = list(np.arange(0.01, 1, 0.3))
alpha.append('symmetric')
alpha.append('asymmetric')

# Beta parameter
beta = list(np.arange(0.01, 1, 0.3))
beta.append('symmetric')

# Validation sets
num_of_docs = len(corpus)
corpus_sets = [gensim.utils.ClippedCorpus(corpus, int(num_of_docs*0.75)), 
               corpus]

corpus_title = ['75% Corpus', '100% Corpus']

model_results = {'Validation_Set': [],
                 'Topics': [],
                 'Alpha': [],
                 'Beta': [],
                 'Coherence': []
                }

# Can take a long time to run
if 1 == 1:
    pbar = tqdm.tqdm(total=(len(beta)*len(alpha)*len(topics_range)*len(corpus_title)))

    # iterate through validation corpuses
    for i in range(len(corpus_sets)):
        # iterate through number of topics
        for k in topics_range:
            # iterate through alpha values
            for a in alpha:
                # iterare through beta values
                for b in beta:
                    # get the coherence score for the given parameters
                    cv = compute_coherence_values(corpus=corpus_sets[i], dictionary=id2word, 
                                                  k=k, a=a, b=b)
                    # Save the model results
                    model_results['Validation_Set'].append(corpus_title[i])
                    model_results['Topics'].append(k)
                    model_results['Alpha'].append(a)
                    model_results['Beta'].append(b)
                    model_results['Coherence'].append(cv)

                    pbar.update(1)
    pd.DataFrame(model_results).to_csv('./results/lda_tuning_results.csv', index=False)
    pbar.close()**

调查结果

让我们从确定主题的最佳数量开始。下表列出了两个验证集的主题数量的一致性分数 C_v，以及固定的 alpha = 0.01 和 beta = 0.1

随着一致性分数似乎随着主题数量的增加而增加，在变平或大幅下降之前，选择 CV 最高的模型可能更有意义。在这种情况下，我们选择 K=8

接下来，我们要选择最佳的α和β参数。虽然有其他复杂的方法来处理选择过程，但对于本教程，我们选择 K=8 时产生最大 C_v 得分的值

阿尔法=0.01

β= 0.9

K=8

这大约产生。比基线得分提高了 17%

最终模型

让我们使用上面选择的参数来训练最终的模型

**num_topics = 8

lda_model = gensim.models.LdaMulticore(corpus=corpus,
                                           id2word=id2word,
                                           num_topics=num_topics, 
                                           random_state=100,
                                           chunksize=100,
                                           passes=10,
                                           alpha=0.01,
                                           eta=0.9)**

可视化主题

**import pyLDAvis.gensim_models as gensimvis
import pickle 
import pyLDAvis

# Visualize the topics
pyLDAvis.enable_notebook()

LDAvis_data_filepath = os.path.join('./results/ldavis_tuned_'+str(num_topics))

# # this is a bit time consuming - make the if statement True
# # if you want to execute visualization prep yourself
if 1 == 1:
    LDAvis_prepared = gensimvis.prepare(lda_model, corpus, id2word)
    with open(LDAvis_data_filepath, 'wb') as f:
        pickle.dump(LDAvis_prepared, f)

# load the pre-prepared pyLDAvis data from disk
with open(LDAvis_data_filepath, 'rb') as f:
    LDAvis_prepared = pickle.load(f)

pyLDAvis.save_html(LDAvis_prepared, './results/ldavis_tuned_'+ str(num_topics) +'.html')

LDAvis_prepared**

结束语

我们从理解为什么评估主题模型是必要的开始。接下来，我们回顾了现有的方法，并触及了主题一致性的表面，以及可用的一致性度量。然后，我们使用 Gensim 实现构建了一个默认的 LDA 模型，以建立基线一致性得分，并回顾了优化 LDA 超参数的实用方法。

希望这篇文章能够揭示潜在的主题评估策略，以及其背后的直觉。

参考文献:

http://qpleple.com/perplexity-to-evaluate-topic-models/
https://www . Amazon . com/Machine-Learning-probability-Perspective-computing/DP/0262018020
https://papers . nips . cc/paper/3700-reading-tea-leaves-how-humans-interpret-topic-models . pdf
https://github . com/matti lyra/pydataberlin-2017/blob/master/notebook/evaluationunsupervisedmodels . ipynb
https://www . machine learning plus . com/NLP/topic-modeling-gensim-python/
http://SVN . aksw . org/papers/2015/WSDM _ 话题 _ 评价/public.pdf
http://palmetto.aksw.org/palmetto-webapp/

感谢阅读。如果您有任何反馈，请对本文发表评论，在LinkedIn上给我发消息，或者给我发电子邮件(shmkapadia[at]gmail.com)****

如果你喜欢这篇文章，请访问我的其他文章

**** [## Python 中的主题建模:潜在狄利克雷分配(LDA)

如何开始使用 Python 中的 LDA 进行主题建模

towardsdatascience.com](/end-to-end-topic-modeling-in-python-latent-dirichlet-allocation-lda-35ce4ed6b3e0) [## 构建块:文本预处理

本文是关于自然语言处理的后续文章的第二篇。这一系列…的目的

towardsdatascience.com](/building-blocks-text-pre-processing-641cae8ba3bf) [## 语言模型简介:N-Gram

本文是关于自然语言处理的第三篇文章。这一系列…的目的

towardsdatascience.com](/introduction-to-language-models-n-gram-e323081503d9)****

评估机器学习算法

原文：https://towardsdatascience.com/evaluating-a-machine-learning-algorithm-81746c947ad3?source=collection_archive---------24-----------------------

“下一步做什么？”的工具箱

随着易于使用的机器学习库的丰富，应用它们并在大多数情况下实现 80%以上的预测准确率通常是很有吸引力的。但是，‘下一步该怎么办？’这个问题困扰着我，也可能困扰着其他有抱负的数据科学家。

我在 Coursera 上“机器学习——斯坦福在线”的课程期间，吴恩达教授帮我顺利通过。我希望这篇简要介绍了他在一次讲座中的解释的文章能够帮助我们许多人理解“调试或诊断学习算法”的重要性。

首先，让我们说出所有的可能性或‘下一步尝试什么？’当假设在其预测中出现不可接受的大误差，或者需要改进我们的假设时:

我们将再次访问该表，做出明智的选择，并创建我们的 工具箱 。

上述诊断将基本上帮助我们找到偏差方差权衡。
让我们用一个简单的图来简单地形象化这个概念，来说明过拟合(高方差)和欠拟合(高偏差)。

偏差方差权衡

从根本上说,“最佳模型”的问题是在偏差和方差之间找到一个最佳平衡点。这里有一个链接，链接到杰克·范德普拉斯在《Python 数据科学手册》中解释的偏差方差权衡。

以下代码可视化了我们的假设在多项式的不同次上的拟合。
请注意，过拟合和欠拟合也可以在不同的正则化参数和训练集大小上可视化。

源代码: Scipy 讲义

%matplotlib inline
import numpy as np
import matplotlib.pyplot as pltdef generating_func(x, err=0.5):
    return np.random.normal(10 - 1\. / (x + 0.1), err)from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeaturesn_samples = 8np.random.seed(0)
x = 10 ** np.linspace(-2, 0, n_samples)
y = generating_func(x)x_test = np.linspace(-0.2, 1.2, 1000)titles = ['d = 1 (under-fit; high bias)',
          'd = 2',
          'd = 6 (over-fit; high variance)']
degrees = [1, 2, 6]fig = plt.figure(figsize=(9, 3.5))
fig.subplots_adjust(left=0.06, right=0.98, bottom=0.15, top=0.85, wspace=0.05)for i, d in enumerate(degrees):
    ax = fig.add_subplot(131 + i, xticks=[], yticks=[])
    ax.scatter(x, y, marker='x', c='k', s=50)model = make_pipeline(PolynomialFeatures(d), LinearRegression())
    model.fit(x[:, np.newaxis], y)
    ax.plot(x_test, model.predict(x_test[:, np.newaxis]), '-b')ax.set_xlim(-0.2, 1.2)
    ax.set_ylim(0, 12)
    ax.set_xlabel('house size')
    if i == 0:
        ax.set_ylabel('price')ax.set_title(titles[i])

fig.savefig('graph-Images/bias-variance.png')

验证曲线

1.变化的模型复杂性

源代码: Scipy 讲义

生成更大的数据集

from sklearn.model_selection import train_test_split

n_samples = 200
test_size = 0.4
error = 1.0

# randomly sample the data
np.random.seed(1)
x = np.random.random(n_samples)
y = generating_func(x, error)

# split into training, validation, and testing sets.
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=test_size)

# show the training and validation sets
plt.figure(figsize=(6, 4))
plt.scatter(x_train, y_train, color='red', label='Training set')
plt.scatter(x_test, y_test, color='blue', label='Test set')
plt.title('The data')
plt.legend(loc='best');

绘制不同模型复杂性的验证曲线

from sklearn.model_selection import validation_curve

degrees = np.arange(1, 21)

model = make_pipeline(PolynomialFeatures(), LinearRegression())

# The parameter to vary is the "degrees" on the pipeline step
# "polynomialfeatures"
train_scores, validation_scores = validation_curve(
                 model, x[:, np.newaxis], y,
                 param_name='polynomialfeatures__degree',
                 param_range=degrees,
                 cv = 5)

# Plot the mean train error and validation error across folds
plt.figure(figsize=(6, 4))
plt.plot(degrees, validation_scores.mean(axis=1), lw=2,
         label='cross-validation')
plt.plot(degrees, train_scores.mean(axis=1), lw=2, label='training')

plt.legend(loc='best')
plt.xlabel('degree of fit')
plt.ylabel('explained variance')
plt.title('Validation curve')
plt.tight_layout()

Image Source: Python Data Science Handbook by Jake VanderPlas

2.变化正则化参数

生成数据集和绘制不同正则化参数的验证曲线不在本讨论范围内。还感兴趣吗？请参考杰克·范德普拉斯的 Python 数据科学手册

我们知道，基函数(多项式特征、高斯特征等)的引入。)到我们的线性回归中使得模型更加灵活。

但是，它会带来风险吗？
是的，答案是 过拟合

原因:我们的模型过于灵活，无法捕捉训练数据集中的异常值或极值。
解决方案:正规化

正则化是一种回归形式，它将模型参数惩罚或约束或正则化为零。

当我们有很多特征时，这种方法很有效，每个特征都对我们的预测有所贡献。
因此，我们保留了所有的特征，但是减少了参数的大小或值。

Image Source Code: Python Data Science Handbook by Jake VanderPlas

学习曲线

源代码: Scipy 讲义

针对固定模型复杂性(d = 1 和 d = 15)，随着样本数量的增加，绘制训练和测试误差图

# A learning curve for d = 1, 15
for d in [1, 15]:
    model = make_pipeline(PolynomialFeatures(degree=d), LinearRegression())from sklearn.model_selection import learning_curve
    train_sizes, train_scores, validation_scores = learning_curve(
        model, x[:, np.newaxis], y,
        train_sizes=np.logspace(-1, 0, 20),
        cv = 5)# Plot the mean train error and validation error across folds
    plt.figure(figsize=(6, 4))
    plt.plot(train_sizes, validation_scores.mean(axis=1),
            lw=2, label='cross-validation')
    plt.plot(train_sizes, train_scores.mean(axis=1),
                lw=2, label='training')
    plt.ylim(bottom=-.1, top=1)plt.legend(loc='best')
    plt.xlabel('number of train samples')
    plt.ylabel('explained variance')
    plt.title('Learning curve (degree=%i)' % d)
    plt.tight_layout()plt.show()

固定模型复杂度(d = 1)的可变样本量—高偏差估计量:

它欠拟合数据，因为训练和验证分数都很低，或者学习曲线已经收敛到一个较低的分数。
我们可以预期，添加更多的训练数据不会有所帮助
重温‘下一步尝试什么？’工作台修复偏高

固定模型复杂性(d = 15)的可变样本量—高方差估计量:

由于训练分数远高于验证分数，因此过度拟合数据。
随着我们向这个训练集添加更多的样本，训练分数将继续降低，而交叉验证分数将继续增加，直到它们在中间相遇。
我们可以预期，添加更多的训练数据将会有所帮助。

Image Source Code: Python Data Science Handbook by Jake VanderPlas

正如我所承诺的，这里有我们的 工具箱——“下一步尝试什么？” 它与验证和学习曲线一起，将帮助我们做出明智的决策。

参考

Coursera 的“机器学习—斯坦福在线”讲座，主讲人吴恩达教授
杰克·范德普拉斯的《Python 数据科学手册》
犀利的讲稿

感谢您的阅读！如果你觉得这有帮助或者没有帮助，请在评论中告诉我。
如果此文对您有帮助， 分享一下 。

访问 Jupyter 笔记本— 点击此处

领英

[## Eklavya Saxena -东北大学-马萨诸塞州波士顿| LinkedIn

东北大学精通数据科学的研究生，在以下领域有 2 年以上的工作经验

linkedin.com](https://linkedin.com/in/EklavyaSaxena)

GitHub

[## eklavyasaxena/评估机器学习算法

工具箱——“下一步要做什么？”有了大量易于使用的机器学习库，它经常吸引…

github.com](https://github.com/eklavyasaxena/Evaluating-a-Machine-Learning-Algorithm)

基于错误和基于排名的真实推荐系统评估

原文：https://towardsdatascience.com/evaluating-a-real-life-recommender-system-error-based-and-ranking-based-84708e3285b?source=collection_archive---------6-----------------------

Photo credit: Pixabay

评级预测

在我的上一篇帖子 re: 构建和测试带惊喜的推荐系统中，惊喜围绕着各种机器学习算法来预测用户对项目的评分(即评分预测)。它要求用户给予 明确的 反馈，比如要求用户在购买后给一本书打 0 到 10 颗星的分数。然后我们用这些数据来建立用户的兴趣档案。这样做的问题是，不是每个人都愿意留下评级，所以数据往往是稀疏的，就像我们之前看到的这个图书穿越数据集:

Figure 1

大多数推荐系统试图预测如果用户对相应的书籍进行评级，他们会在其中放入什么。如果有太多的“南”，推荐者就没有足够的数据来理解用户喜欢什么。

然而，显性评级是伟大的，如果你能说服你的用户给你评级。所以，如果你有奢侈的数据和用户评分，那么评价指标应该是或者 MAE 。让我们展示一个带有惊奇库的 Movielens 数据集的例子。

ratings_prediction.py

顶级的

从在线购物网站到视频门户网站，前 N 名推荐系统无处不在。它们向用户提供他们可能感兴趣的 N 个项目的排序列表，以鼓励浏览和购买。

亚马逊的推荐系统之一是“前 N 名”系统，它向个人提供一个顶级结果列表，如下所示:

Figure 2

亚马逊给我的“前 N 名”推荐包括 9 页，第一页有 6 个项目。一个好的推荐系统应该能够识别某个用户感兴趣的一组 N 个项目。因为我很少在亚马逊买书，我的“Top-N”差得很远。换句话说，我可能只会点击或阅读我的“前 N 名”列表中的一本书。

以下脚本为测试集中的每个用户产生了前 10 个推荐。

top-N.py

下面是我们预测的用户 Id 2 和用户 Id 3 的前 10 名。

Figure 3

命中率

让我们看看我们的 10 大推荐有多好。为了评估 top-10，我们使用命中率，也就是说，如果用户对我们推荐的前 10 名中的一个进行了评级，我们就认为它是“命中”。

计算单个用户命中率的过程:

在培训数据中查找该用户历史记录中的所有项目。
有意删除其中一项(留一项交叉验证)。
使用所有其他项目来为推荐者提供信息，并要求提供前 10 项推荐。
如果被删除的项目出现在前 10 个推荐中，那么它就是成功的。如果没有，那就不算成功。

HitRate.py

系统的整体命中率是命中数除以测试用户数。它衡量我们能够推荐删除评级的频率，越高越好。

非常低的命中率仅仅意味着我们没有足够的数据来处理。就像亚马逊的点击率对我来说会非常低，因为它没有足够的我的图书购买数据。

按评级值列出的命中率

我们也可以通过预测的评分值来分解命中率。理想情况下，我们希望预测用户喜欢的电影，所以我们关心高评分值而不是低评分值。

RatingHitRate.py

我们的命中率细分正是我所希望的，评分 5 的命中率远远高于 4 或 3。越高越好。

累积命中率

因为我们关心更高的评级，所以我们可以忽略低于 4 的预测评级，以计算> = 4 的评级的命中率。

CumulativeHitRate.py

越高越好。

平均交互点击排名

前 N 名推荐系统排名评估的常用指标，仅考虑第一个相关结果出现的位置。我们会因为推荐一个用户排名靠前而不是靠后的项目而得到更多的信任。越高越好。

AverageReciprocalHitRank.py

你的第一个现实生活中的推荐系统很可能是低质量的，你为新用户准备的成熟的推荐系统也是如此。但是，这仍然比没有推荐系统好得多。推荐系统的目标之一是我们在推荐系统中学习用户/新用户的偏好，以便他们可以开始从系统接收准确的个性化推荐。

然而，如果你刚刚起步，你的网站是全新的，推荐系统不能为任何人提供个性化的推荐，没有任何人的任何评价。然后，这就变成了一个系统性的自举问题。

Jupyter 笔记本可以在 Github 上找到。享受这周剩下的时光。

参考:用机器学习和人工智能构建推荐系统

面板数据多层次模型在 MLB 促销中的应用

原文：https://towardsdatascience.com/evaluating-bobblehead-promotion-in-mlb-an-application-of-multi-level-model-on-panel-data-8f5c6fc9e044?source=collection_archive---------13-----------------------

2015 年，我看了 money ball——这是一个关于 MLB 的小市场球队 Oakland A 如何利用数据科学/统计数据，以有限的预算组建一支强大的球队，击败其他富有和著名的球队，并在 2002 赛季连续 20 场比赛获胜的故事。这是我第一次了解到数据分析可以如此强大，这也激励我追求这一数据职业生涯。因此，我决定在这个关于 MLB 的项目中应用数据建模，但在另一个方面:评估营销推广。该数据集来自 Thomas Miller 所著的《营销数据科学:用 R 和 Python 进行预测分析的建模技术》一书。你可以在这里 下载数据集和我的 R 代码进行分析。

我讨厌失败多过我想要赢。

—比利·比恩，奥克兰 A 公司总经理，2002 年

一—简介

在美国，职业棒球大联盟(MLB)球队的主场比赛(81 场)比国家篮球协会(41 场)和国家足球联盟(8 场)的总和还要多。结果？球迷不太可能出席每场比赛。一年四季都有很多选择。鉴于目前的市场形势，有这么多种类的新娱乐作为棒球比赛的竞争对手，找到销售门票的方法就更加重要了。

因为门票销售是许多球队的主要收入来源，所以了解哪种促销活动可以说服球迷前来对一支球队的可持续性至关重要。什么样的促销活动将导致美国职业棒球大联盟(MLB)比赛上座率的最大增长？答案很可能是摇头娃娃赠品。自 1999 年以来，MLB 队的宣传部门一直利用这些小人来吸引更多的观众，因为球迷们喜欢这样。

然而，有太多的因素，无论是场内还是场外，都会影响一个人是否参加 MLB 比赛的决定。除了促销，粉丝还会考虑游戏的时机、天气、胜率，以及游戏是否是跑马灯游戏【1】。因此，有时棒球营销人员无法理解摇头娃娃促销对上座率的真正影响。我们的分析旨在回答一个核心问题:提供摇头娃娃赠品可以增加多少销售额，增加多少，以及这一结果在 MLB 团队中如何变化。

了解这一点可以帮助我们在推广摇头娃娃时，为推广棒球部门提供完善的建议。

我们的报告包含以下部分:

II —数据特征

III —模型选择和解释

四、建议和结论

五、附录

二—数据特征

该数据集提供了 2012 赛季所有 MLB 球队的出勤信息。每行说明一个游戏的属性，这些属性可以分为 4 个桶:时间(月份、日期、星期几、白天/晚上)、天气(温度、天空)、团队(home_team、对手)和促销(帽子、衬衫、烟花、摇头娃娃)。所有这些变量都会或多或少地影响比赛的上座率。

Table 1: Dependent and Independent variables of the dataset

我们真正关心的是摇头晃脑对出勤率的影响。我们想知道提供摇头晃脑如何影响出席率，以及这种影响是否因团队或提供摇头晃脑的时间而异，其他条件保持不变。

这是面板数据，包括横截面和时间序列数据。在这种情况下，数据集提供了在赛季的不同时间和不同团队中对摇头娃娃推广的观察。因此，摇头晃脑的影响可能不仅随时间而变化，而且在不同的团队中也是如此。让我们通过我们的可视化来确认它。

您可以在此了解更多关于面板数据的信息。

甲) 主场 _ 球队出勤

Figure 1: Avg. attendance varies among MLB teams

MLB 有富有的球队和不那么富有的球队。像纽约扬基队、洛杉矶道奇队、费城费城人队、旧金山巨人队……这样的大市场球队和像坦帕湾雷队、奥克兰运动家队、西雅图水手队……这样的小市场球队之间的受欢迎程度是不同的。这些大市场球队通常有更高的收入、更多的预算、更多的明星球员，因此比小市场球队吸引更多的观众。在这个市场中，品牌名称是决定每场比赛上座率的关键因素。

“我们试图解决的问题是，有富有的团队，也有贫穷的团队。然后是五十英尺的垃圾，然后是我们。这是一场不公平的游戏。”

—比利·比恩，奥克兰 A 公司总经理，2002 年。

b)摇头出席

从图 2 中我们观察到:

●一些球队在有摇头晃脑的比赛和没有摇头晃脑的比赛之间的上座率有明显差异，例如旧金山巨人队和费城人队。

●一些球队没有体验到明确的效果或没有足够的数据来产生明确的效果，如波士顿红袜队、圣地亚哥教士队、科罗拉多洛基队、明尼苏达双城队。

●大多数球队的上座率都有所增加:休斯顿太空人队、西雅图海洋队、辛辛那提红人队、多伦多蓝鸟队等。

Figure 2: Attendance difference between games with bobbleheads and without bobblehead / The number of games with and without bobbleheads among teams.

然而，这种增长是摇头娃娃促销的结果吗？不完全是。从下图中，你可以看到很大一部分摇头晃脑是在周六和周日提供的，这两天通常是一周中最拥挤的日子。人们可能会去看比赛，因为在周末即使没有摇头晃脑。因此，我们有动力确定摇头晃脑的结果是出席人数的真正增加。此外，摇头娃娃在工作日和周末参加人数增加有什么不同吗？

Figure 3: Bobblehead offering and attendance by days of week

c)其他类型的出勤晋升

衬衫、帽子、烟花(在同一张图上):图 4 显示帽子和衬衫的促销对出席率有轻微影响。在这三者中，烟火似乎对出席人数影响最大。平均而言，有烟花的游戏有 34，400 人参加，而没有烟花的游戏只吸引了 30，600 名粉丝。

Figure 4: Variation in attendance by Cap, Shirt and Fireworks

d)季节性影响

除了一些球队(波士顿红袜队、旧金山巨人队、费城费城人队、密尔沃基酿酒人队和圣路易斯红衣主教队)的上座率在几个月内保持稳定外，其他球队似乎有一些季节性影响，6 月和 7 月的上座率最高，4 月、8 月和 9 月的上座率有所下降。

e)天气(温度，天空)出勤

从上面的图表中，我们没有看到温度和游戏上座率之间的明确关系。此外，天空条件似乎是一个重要因素。球迷们倾向于在多云或晴朗的日子去棒球场。他们不想在雨天或有穹顶的时候出去。

f)推论

这种可视化为我们提供了在我们的模型中应该包含哪些独立变量的提示。对于大多数变量，我们看到它们和出勤率之间的相关性。因此，我们将在建模步骤中加入 home_team、月份、工作日、天气(除了温度)。

三—型号选择

聚合

聚合方法帮助我们找出摇头晃脑对整个团队和时间的出席率的平均影响。使用线性回归模型，我们检验了游戏中是否提供摇头晃脑促销与该游戏的出席率之间的关系。我们知道摇头晃脑的系数是 4494，这意味着提供摇头晃脑会使棒球比赛的上座率平均增加 4494。

聚合方法的问题在于，它未能证明 MLB 团队在摇头推广影响方面的异质性。在接下来的部分中，我们将使用另外两种方法来帮助我们识别这种变化。

2。分组

分组方法有两个核心问题:

●摇头娃娃推广的时机是一个重要因素吗？如上所述，很大一部分摇头晃脑是在周末提供的。如果在工作日提供摇头晃脑，对出席率有什么影响吗？

●城市的规模是一个重要因素吗？我们都知道 MLB 的上座率因城市而异，因为每个城市都有不同的生活水平、球迷基础和替补人数。所有这些异质性都会影响摇头晃脑影响出席率的方式。为了简化，我们只基于城市人口作为第一异质性因素，因为它表明有多大的球迷基础。

为了回答第一个问题，我们将我们的数据集分成两组:发生在工作日的游戏和发生在周末的游戏。之后，我们对数据的每个子集应用线性回归。结果表明，周末提供摇头晃脑的效果与平日提供摇头晃脑的效果存在差异。平均而言，工作日的摇头晃脑增加了 6，628 名观众(平均 24.7%)，而周末的摇头晃脑仅增加了 2，938 名观众(平均 8.9%)。这可以用以下事实来解释:在周末，不管是否有摇头娃娃赠品，许多球迷都会去看棒球；而在工作日，他们需要更多的激励来参加比赛。

关于第二个问题，我们获得了一个关于城市人口的新数据集，基于此，我们将数据集分为两组:一组主队来自小城市(意味着人口少于 100 万)，另一组来自大城市(意味着人口大于 100 万)。有 9 支队伍驻扎在大城市，21 支队伍驻扎在小城市。

同样，线性回归结果显示，来自大城市的团队的摇头效应和来自小城市的团队的摇头效应之间存在差异。平均而言，大城市的摇头晃脑增加了 7，638 人(24.2%)，而小城市的摇头晃脑仅增加了 2，485 人(8.5%)。虽然城镇人口不同，但当没有摇头晃脑时，平均上座率可能不会在团队之间变化太大(平均 31.5K 对 29.2K)。当提供摇头晃脑时，大城市的上座率比小城市提高了很多。这可能是因为大城市比小城市有更大的粉丝群，有更多的增量粉丝被摇头晃脑的赠品所吸引。

当谈到摇头娃娃推广时，使用分组方法让我们对棒球的多样性有了更多的了解。然而，在这种方法中仍然存在某种程度的聚合，这可能会清除我们可以提供给棒球营销人员的有用信息。我们希望找到一种能够在团队层面上展示异质性的方法，多层次模型是我们下一步的尝试。

3。多级模型

虽然聚合模型在赛季的所有比赛中提供了固定的截距和固定的摇头摆尾斜率，但多级模型【2】假设这种效应会因球队而异，因为我们在这种情况下将其视为第一级。还有斜率和截距的固定效应，分别是 3997 和 32004。这可以解释为参赛队伍平均增加了 3997 人。(请注意，此固定斜率与总量法(4494)中的斜率略有不同，因为总量法中的斜率是游戏的平均增量)。

下图显示了作为多级模型结果的变化斜率和截距。

这里，截击的随机效应展示了 MLB 团队不同的出席水平。还有，摇头晃脑的随机效果是各队对固定效果的偏离。因此，我们可以通过将固定效果添加到随机效果中来得出每个团队的最终平均效果。这是我们的最终结果:

Figure 8: The verying final average effects of bobblehead on MLT teams

●洛杉矶道奇队享受了摇头晃脑对上座率的最大积极影响(平均而言，摇头晃脑增加了 13，766 个上座率)，其次是多伦多蓝鸟队(约 8，838)，以及亚特兰大勇士队(6，678)。

●另一方面，旧金山巨人队是唯一一支承受摇头晃脑对上座率产生负面影响的球队(平均而言，他们的比赛上座率减少了 1023 人)。此外，芝加哥白袜队、华盛顿国民队、纽约大都会队和芝加哥小熊队的门票销售也略有增加。

●圣地亚哥教士队、科罗拉多落基山队、明尼苏达双城队、波士顿红袜队、底特律老虎队等 13/30 支球队没有看到摇头晃脑的明显效果(随机效果~ 0)，因为我们没有这些球队足够的摇头晃脑观察数据(最少 3 次观察)。

●拦截中的随机效应只是说明了每个团队平均出席水平的差异。

四—建议&结论

摇头娃娃推广被证明能有效提高棒球上座率。MLB 推广部团队预计每场比赛平均增加 4428 名观众。然而，由于许多因素导致团队之间存在巨大的异质性，摇头晃脑的影响也在团队之间从大约 13，700 下降到负数。洛杉矶道奇队是受到摇头晃脑影响最大的球队，而旧金山巨人队在升级中略受影响。

该分析也给了我们一些关于何时何地应该实施摇头晃脑赠品活动的见解。虽然大多数有摇头晃脑的游戏都是在周末，但我们的分析表明摇头晃脑在周末的影响不如在工作日。周末的摇头晃脑增加了 8.9%的出席率，而工作日的出席率为 24.2%。此外，大城市的球队应该比小城市的球队更多地考虑提供摇头娃娃推广，因为他们有更大的粉丝群，因此他们可以吸引更多的粉丝带着摇头娃娃去棒球场。

对于进一步的研究，我们建议使用更大的数据样本，对摇头娃娃推广进行更多的观察，以获得更有意义的结果。在上面的分析中，有 13/30 个团队，我们不能推断摇头晃脑的最终效果，因为我们只有每个团队 0-2 次摇头晃脑的观察。我们建议至少收集 3 个观察值。

参考:

1，促销对美国职业棒球大联盟比赛上座率的影响，阿曼达·舍恩罗克，2009 年

2、了解面板数据回归，马达夫·米什拉

3、多级模型的简单说明

关于作者: 我是加州大学戴维斯分校的 MBA 学生。我对营销分析、建模、机器学习和数据科学充满热情。本文属于我 MBA 项目下的独立学习。非常感谢我的同学 Jamie Ho 对这个项目的贡献。如果您有任何意见、反馈或问题，请随时通过 mapnguyen@ucdavis.edu 联系我，或通过LinkedIn联系我。快乐造型！

评估分类模型

原文：https://towardsdatascience.com/evaluating-categorical-models-e667e17987fd?source=collection_archive---------20-----------------------

当您有分类数据时，您可以建立几个模型来根据给定的数据预测新的观察值。您可以构建逻辑回归、决策树、随机森林、助推模型等等。你如何比较它们，如何确定哪种型号是最好的？

混淆矩阵

假设我们有一个二元分类数据集，我们的目标是预测某事是真还是假。我们建立了几个模型，现在我们需要一种方法来组织我们的结果。一种方法是通过使用混淆矩阵。我们的模型预测数据为真或为假。我们可以按照下面的指南将数据组织成一个混乱矩阵:

The confusion matrix with an explanation of each category of results.

我们的模型既可以在一个观察值实际为真时预测它为真( TP )，在它实际为真时预测它为假( FN )，在它实际为假时预测它为假( TN )，在它实际为假时预测它为真( FP )。混淆矩阵将有和目标变量的类别一样多的列和行，因此它将总是一个正方形。我们可以组织我们的结果，并通过挑选具有最高真实预测的模型来确定哪个模型是最好的？

精确度、召回率、准确度和 F1 分数

不同的情况需要不同的评估指标。例如，为垃圾邮件过滤器和医学测试建立的分类模型需要进行不同的判断。如果垃圾邮件过滤器将一封重要的电子邮件标记为垃圾邮件(假阳性)，比将一封垃圾邮件标记为非垃圾邮件(假阴性)要麻烦得多。根据预测的假阳性有多少来判断模型的标准被称为精度。如果医学测试告诉患病的患者他们是健康的(假阴性)，这将比当他们实际上是健康的(假阳性)时告诉患者他们可能生病更成问题，因为测试的管理者可以建议进一步的测试来验证患者的健康。当你实际上并不健康的时候，寻求进一步的测试比走来走去认为你是健康的要好。根据预测到的假阴性的数量来判断模型的标准被称为召回。

也可以使用其他指标。准确性通过做出多少个正确的预测来判断模型。F1 分数是精确度和召回率的调和平均值。您必须决定哪个指标最适合您的情况。

The equations of some binary categorical model evaluation metrics.

结论

以上指标用于评估二元分类模型。当添加多个类别时，我们必须调整我们的评估指标。Python 的 Scikit-Learn 库有方法来可视化混淆矩阵和评估模型。您必须决定哪个评估指标最适合您的项目。

评价分类模型 II:敏感性和特异性

原文：https://towardsdatascience.com/evaluating-categorical-models-ii-sensitivity-and-specificity-e181e573cff8?source=collection_archive---------10-----------------------

上周我讨论了二元分类模型的评估指标。这些二元模型的预测可以分为四组:真阳性、假阳性、假阴性和只考虑一类的真阴性。

The confusion matrix for a binary classification model

当添加其他类别时，预测可能会落入其他组。有多少个类别，就有多少种方法来计算每个评估指标。下面我将介绍这些类型的多分类模型的评估指标。

The confusion matrix for a multi-categorical classification model

定义灵敏度和特异性

二元分类模型可以用精确度、召回率、准确度和 F1 度量来评估。我们不必指定指标适用于哪个组，因为模型只有两个选项可供选择；观察值要么属于该类，要么不属于该类，模型可能是正确的，也可能是不正确的，因此有混淆矩阵的四个部分。当模型有多个类别作为预测选项时，我们必须计算适用于每个类别的指标。

敏感度是评估模型预测每个可用类别的真阳性的能力的指标。特异性是评估模型预测每个可用类别的真实否定的能力的指标。这些指标适用于任何分类模型。计算这些指标的公式如下。

The equations for calculating sensitivity and specificity

你可能已经注意到回忆的方程式看起来和敏感度的方程式一模一样。何时使用任一术语取决于手头的任务。

计算灵敏度和特异性

上面的多分类模型可以预测每个观察值的类别 A、B 或 C。当有两个以上可能的预测选项时，必须为每个可能的类别计算这些度量。灵敏度的计算如下:

Sensitivity calculations for multi-categorical classification models

特异性决定了模型预测观察值是否不属于特定类别的能力。当观察实际上属于除了正在考虑的类别之外的每一个其他类别时，它需要模型性能的知识。特异性的计算如下:

Specificity calculations for multi-categorical classification models. The color shade of the text on the right hand side is lighter for visibility.

摘要

多类别分类模型可以通过每个可能类别的敏感性和特异性来评估。一个模型对预测一个类别很有效，但对其他类别可能很糟糕。这些评估指标允许我们为不同的目的分析模型。您必须决定哪个评估指标最适合您的项目。

评估 Python 中的机器学习分类问题:重要的 6+1 度量

原文：https://towardsdatascience.com/evaluating-machine-learning-classification-problems-in-python-5-1-metrics-that-matter-792c6faddf5?source=collection_archive---------6-----------------------

评估您的 ML 分类项目性能的指南

Photo by Franck V. on Unsplash

机器学习分类和评估模型可能是一项艰巨的任务。本文将试图通过解释“混淆矩阵”、评估指标以及二元分类问题的 ROC AUC 来消除这种“混淆”。对于每个部分，还提供了一个示例 Python 代码，以帮助读者理解 Python 中的机器学习二进制分类和评估。

分类 vs 回归

数据科学家通常利用机器学习(ML)工具和库来开发代码，这些代码在不使用显式指令的情况下有效地执行特定任务，而是依靠模式和推理来预测连续变量或变量的类别/类别。一般来说，我们可以把这些 ML 问题分为三类:

回归:这些问题涉及到预测一个连续变量，比如温度、价格、年龄等。例如:

"根据房子的特点，它的售价是多少？"
"客户将在这个网站上订购多少产品？"

二元分类:这些问题通常涉及需要是/否或 1/0 结果的问题。例如:

“这是欺诈交易吗？”
“这个客户会订购这个产品吗？”

多类分类:这些类似于二元分类，但是在这种情况下，问题涉及在两个以上的类别之间进行选择。例如:

“这是什么样的交易？借方、贷方等。”
"这位顾客对哪类产品感兴趣？"

评估二元分类问题

通常，在回归和分类模型中，数据集被分为训练数据集和测试数据集。然后，该模型在“训练数据集”上进行训练和拟合，并用于基于“测试数据集”进行预测，以评估性能。这种训练/测试分割的原因是为了模拟未来的数据集，也是为了避免模型过度适应训练数据集。这种方法的好处是测试数据集中目标的实际值是已知的，这对于评估模型是至关重要的。 但是这个测评是怎么做的呢？

对于二元分类问题，可以计算多种度量来评估预测模型的性能。这些指标是基于所谓的“混淆矩阵”计算出来的。

混乱矩阵

《关于混淆矩阵的理论》把矩阵描述为:

混淆矩阵包含关于由分类系统完成的实际和预测分类的信息。通常使用矩阵中的数据来评估这种系统的性能。

下面给出的这个矩阵是所有二进制分类问题的基础，并且广泛用于机器学习模型中。表中的缩略语也有描述。

正在这种情况下就是 的类息 。例如，“识别欺诈交易”。

真阳性(TP): 当模型预测为阳性，并且它们实际上为阳性时(例如，欺诈交易被识别为欺诈)。

真阴性(TN) :模型预测为阴性，实际为阴性(例如，非欺诈交易被识别为非欺诈)。

假阳性(FP)(也称为 I 型错误):当模型预测为阳性，但实际上却为阴性时(例如，非欺诈性交易被识别为欺诈性交易)。

假阴性(FN)(也称为第二类错误):当模型预测为阴性，但它们为阳性时(例如，欺诈性交易被识别为非欺诈性交易)。

通常，第二类错误(FN)具有更严重的后果，而在 ML 中，目标是最小化第二类错误。另一方面，第一类错误的后果较小。然而，在理想情况下，一个完美的模型应该没有这些错误。

让我们用 Python 写一个函数来创建混淆矩阵。 Scikit Learn (SKLearn)库有一个 [metrics](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html) 包，其中包含了 [confusion_matrix](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html) 方法。

# Importing the metrics package from sklearn library
from sklearn import metrics# Creating the confusion matrix
cm = metrics.confusion_matrix(y_test, y_pred)# Assigning columns names
cm_df = pd.DataFrame(cm, 
            columns = ['Predicted Negative', 'Predicted Positive'],
            index = ['Actual Negative', 'Actual Positive'])# Showing the confusion matrix
cm_df

重要的六项指标

在统计书籍中有许多评估混淆矩阵的度量，但其中六个在 ML 问题中使用得更广泛。

准确度是正确预测占预测总数的比例。

准确率= (TP + TN) /所有预测

误分类为(1-准确性)，指预测总数中的所有错误预测。

灵敏度(又名回忆) 表示“在所有实际阳性中，我们预测为阳性的有多少”，可以解释为:

灵敏度(回忆)= TP / (FN + TP)

特异性(又名选择性或真阴性率，TNR) 表示“在所有实际阴性中，我们预测多少为阴性”，可以写成:

特异性= TN / (TN + FP)

精度(又名阳性预测值，PPV) 表示“在所有预测的阳性病例中，有多少实际上是阳性的”，或

精度= TP / (TP + FP)

F1 得分是精确度和灵敏度的调和或加权平均值，是分类问题精确度的一种广泛使用的测量方法。其计算方法如下:

F1 得分= 2 (精度灵敏度)/(精度+灵敏度)

Python 中的这个函数将计算并报告混淆矩阵的这六个指标。

# Creating a function to report confusion metricsdef confusion_metrics (conf_matrix):# save confusion matrix and slice into four pieces TP = conf_matrix[1][1]
    TN = conf_matrix[0][0]
    FP = conf_matrix[0][1]
    FN = conf_matrix[1][0] print('True Positives:', TP)
    print('True Negatives:', TN)
    print('False Positives:', FP)
    print('False Negatives:', FN)

    # calculate accuracy
    conf_accuracy = (float (TP+TN) / float(TP + TN + FP + FN))

    # calculate mis-classification
    conf_misclassification = 1- conf_accuracy

    # calculate the sensitivity
    conf_sensitivity = (TP / float(TP + FN)) # calculate the specificity
    conf_specificity = (TN / float(TN + FP))

    # calculate precision
    conf_precision = (TN / float(TN + FP)) # calculate f_1 score
    conf_f1 = 2 * ((conf_precision * conf_sensitivity) / (conf_precision + conf_sensitivity)) print('-'*50)
    print(f'Accuracy: {round(conf_accuracy,2)}') 
    print(f'Mis-Classification: {round(conf_misclassification,2)}') 
    print(f'Sensitivity: {round(conf_sensitivity,2)}') 
    print(f'Specificity: {round(conf_specificity,2)}') 
    print(f'Precision: {round(conf_precision,2)}')
    print(f'f_1 Score: {round(conf_f1,2)}')

加一指标:ROC AUC[或受试者工作特征曲线下面积(ROC)]

据维基百科:

受试者操作特征曲线，或 ROC 曲线，是一种图示，说明了二元分类器系统在其辨别阈值变化时的诊断能力。ROC 曲线是通过在各种阈值设置下绘制真阳性率(TPR)对假阳性率(FPR)来创建的。在机器学习中，真阳性率也称为灵敏度、召回率或检测概率[4]。

我们可以利用 ROC 曲线来可视化阳性和阴性类别之间的重叠。为此，我们可以遵循以下步骤:

1)将分类阈值设置为 0，这意味着所有预测都被分类为第 1 类(阳性)。

2)计算该阈值的灵敏度和 1-特异性。

3)绘制数值(x = 1-特异性，y =敏感性)。

4)提高小数字的分类阈值(如 0.005)。

5)重复步骤 1–4。

6)重复直到阈值等于 1(这意味着所有预测都是 0 类，负的)。

这个过程的结果看起来会像这个图表。曲线下面积(AUC)是我们可以用于分类模型的另一个评估指标。45 度线是 AUC 为 0.5 的基线。完美模型的 AUC 为 1.0。AUC 越接近 1.0，预测越好。

ROC Curve (from https://www.medcalc.org/manual/roc-curves.php)

让我们用 python 构建一个 ROC AUC，使用Logistic Regression模型。

# The codes below is partly copied from the code written by Matt Brem, Global Instructor at General Assembly.# Importsimport matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression# Train/test split
X_train, X_test, y_train, y_test = train_test_split(X,y, random_state = 42)# Instantiating a logisitic regression model
logreg = LogisiticRegression()
logreg.fit(X_train, y_train)    # model fitting
y_pred = logreg.predict(X_test)   # Predictions# Calculating class probabilities
pred_proba = [i[1] for i in logreg.predict_proba(X_test)]pred_df = pd.DataFrame({'true_values': y_test,
                        'pred_probs':pred_proba})# The codes below is motly copied from the code written by Matt Brem, Global Instructor at General Assembly.# Create figure.
plt.figure(figsize = (10,7))# Create threshold values. 
thresholds = np.linspace(0, 1, 200)# Define function to calculate sensitivity. (True positive rate.)
def TPR(df, true_col, pred_prob_col, threshold):
    true_positive = df[(df[true_col] == 1) & (df[pred_prob_col] >= threshold)].shape[0]
    false_negative = df[(df[true_col] == 1) & (df[pred_prob_col] < threshold)].shape[0]
    return true_positive / (true_positive + false_negative)

# Define function to calculate 1 - specificity. (False positive rate.)
def FPR(df, true_col, pred_prob_col, threshold):
    true_negative = df[(df[true_col] == 0) & (df[pred_prob_col] <= threshold)].shape[0]
    false_positive = df[(df[true_col] == 0) & (df[pred_prob_col] > threshold)].shape[0]
    return 1 - (true_negative / (true_negative + false_positive))

# Calculate sensitivity & 1-specificity for each threshold between 0 and 1.
tpr_values = [TPR(pred_df, 'true_values', 'pred_probs', prob) for prob in thresholds]
fpr_values = [FPR(pred_df, 'true_values', 'pred_probs', prob) for prob in thresholds]# Plot ROC curve.
plt.plot(fpr_values, # False Positive Rate on X-axis
         tpr_values, # True Positive Rate on Y-axis
         label='ROC Curve')# Plot baseline. (Perfect overlap between the two populations.)
plt.plot(np.linspace(0, 1, 200),
         np.linspace(0, 1, 200),
         label='baseline',
         linestyle='--')# Label axes.
plt.title(f"ROC Curve with AUC = {round(metrics.roc_auc_score(pred_df['true_values'], pred_df['pred_probs']),3)}", fontsize=22)
plt.ylabel('Sensitivity', fontsize=18)
plt.xlabel('1 - Specificity', fontsize=18)# Create legend.
plt.legend(fontsize=16);

Sample Output of the Above Code

多类分类的混淆矩阵

评估多类分类问题与评估二元问题没有什么不同，但是在这种情况下，将为每个类单独计算上面讨论的度量。在具有N类的分类模型中，混淆矩阵将是NxN，左轴显示实际的类(如测试集中已知的)，顶轴显示预测的类。矩阵的每个元素𝑖,𝑗将是被分类为预测类别𝑗.中的具有实际类别𝑖的项目的数量

亚马逊 AWS ML 文档提到:

与二元分类问题的过程不同，您不需要选择分数阈值来进行预测。预测答案是具有最高预测分数的类别(即标签)。在某些情况下，您可能希望仅在预测的答案得分较高时才使用它。在这种情况下，您可以选择预测分数的阈值，根据该阈值您是否接受预测答案。

Multi-Class Confusion Matrix (from Amazon AWS website https://docs.aws.amazon.com/machine-learning/latest/dg/multiclass-classification.html)

亚马逊 AWS 文档中也提到:

多分类中使用的典型度量与二分类情况中使用的度量相同。在将所有其他类分组为属于第二类之后，通过将每个类视为二元分类问题来计算每个类的度量。然后，对所有类别的二进制度量进行平均，以获得宏平均(平等对待每个类别)或加权平均(按类别频率加权)度量。

将所有这些整合在一起…

正如本文中所解释的，有许多度量标准可以用来评估分类模型的性能。本文介绍了二进制分类模型、评估此类模型的指标，并提供了一组 python 代码片段来帮助读者进行此类评估。

还讨论了多类分类并与二元分类进行了比较。

尼克·米奈博士(LinkedIn 简介 )是一位资深顾问和富有远见的数据科学家，代表了领导技能、世界级数据科学专业知识、商业敏锐度和领导组织变革能力的独特组合。他的使命是推进人工智能(AI)和机器学习在行业中的实践。

评估机器学习模型的公平性和偏见。

原文：https://towardsdatascience.com/evaluating-machine-learning-models-fairness-and-bias-4ec82512f7c3?source=collection_archive---------5-----------------------

引入一些工具来轻松评估和审核机器学习模型的公平性和偏见

评估机器学习模型的偏差正成为不同行业和数据研究人员越来越普遍的关注点。模型公平性是机器学习中一个相对较新的子领域。在过去，对歧视的研究是从分析人类驱动的决策和这些决策背后的基本原理中产生的。由于我们开始依赖预测性 ML 模型为保险和银行等不同行业做出决策，我们需要实施策略来确保这些模型的公平性，并在预测过程中检测任何歧视行为。

随着 ML 模型变得越来越复杂，解释它们变得越来越困难。预测模型通常是一个黑盒函数，它接受某个输入( x )并输出一个预测( y )。假设一家保险公司希望使用一个预测模型来衡量接纳客户的风险。输入( x )可以包括特征或属性，例如种族、年龄、性别、民族、教育水平和收入。他们还可以根据模型预测来决定是否应该要求一个人支付更高的保费，这些预测研究了我刚才提到的相同属性。在美国的银行和金融行业，这可能会有一些法律影响，因为它不批准正确申请人的信贷请求，违反了平等信贷机会法案(公平贷款)。

随着预测模型的使用迅速增长，并被部署为做出获取某些服务(如银行贷款、信誉或就业)的明智决策，现在重要的是审计和解释这些模型的输出决策，并在早期阶段进行公平设计。在本文中，我将讨论 5 种工具，它们可以用来探索和审计预测模型的公平性。

1- FairML:

Source: https://github.com/adebayoj/fairml

FairML 是一个用 python 编写的工具箱，用于审计机器学习模型的公平性和偏见性。这是一种量化模型输入重要性的简单方法。它使用四种输入排序算法来量化模型对模型输入的相对预测依赖性。

关于安装和演示代码，可以参考库的主 Github repo。

[## 阿德巴约/fairml

在 GitHub 上创建一个帐户，为 adebayoj/fairml 的发展做出贡献。

github.com](https://github.com/adebayoj/fairml)

2-石灰

Lime 是一个开源项目，旨在解释和说明机器学习模型是如何工作的。Lime 的伟大之处在于它支持的机器学习或深度学习模型的广泛范围。我可以解释文本分类，多类分类，图像分类和回归模型。

这里有一个使用 Lime 来理解和探索做出预测性决策的决策标准的快速演示。在这个例子中，我训练了一个使用 20 个类别新闻组数据集的文本分类器。以下文本被归类为 comp.windows.x 类别。

现在，让我们用 Lime 来探究这篇课文中哪些特定的词最有分量来得出这个决定。

如你所见，客户端，应用程序这几个词最有分量。我们来做个小实验。我将从上面的文本中删除这两个单词，并放置另一个单词，然后再次尝试预测。

你可以看到单词空格引入了偏见并完全改变了预测，尽管文本的上下文仍然相同。

要了解代码是如何工作的，可以参考代码库和下面链接中的示例代码:

[## 市场营销/市场营销

Lime:解释任何机器学习分类器的预测— marcotcr/lime

github.com](https://github.com/marcotcr/lime)

3- IBM AI 公平 360

AI Fairness 360 是一个开源库，它使用一系列偏差缓解算法来检测和缓解机器学习模型中的偏差。这个库非常全面，充满了评估偏倚的指标。

他们创造了一种互动的体验，在这种体验中你可以看到衡量标准并测试能力。

他们还创建了 G 指南材料,可以指导哪些度量标准可以用于哪些用例。

[## IBM/AIF360

数据集和机器学习模型的一套全面的公平指标，对这些指标的解释，以及…

github.com](https://github.com/IBM/AIF360)

该库依赖于一系列偏差缓解算法，例如:

优化预处理( Calmon et al .，2017 ): 它提出了一种学习数据变换的优化，具有三个目标:控制区分度、限制单个数据样本中的失真、保持效用。
异类冲击清除器( 费尔德曼等人，2015 )
均衡赔率后处理( 哈特等人，2016 )

还有很多。

4- SHAP

SHAP 可以通过将博弈论与局部解释联系起来，解释任何机器学习模型的输出。它使用一些漂亮的 JS 可视化来解释模型。

有关其工作原理的详细解释和指导，请参考下面的链接

[## slundberg/shap

解释任何机器学习模型输出的统一方法。-slund Berg/shap

github.com](https://github.com/slundberg/shap)

5-谷歌假设工具

Smile Detection Example

Google What-If Tool (WIF)是一个 tensorboard 插件，用于理解黑盒分类或回归 ML 模型。它有多个演示，互动体验和全面的文件。

[## 张量流/张量板

TensorFlow 的可视化工具包。通过在 GitHub 上创建帐户，为 tensorflow/tensorboard 的发展做出贡献。

github.com](https://github.com/tensorflow/tensorboard/tree/master/tensorboard/plugins/interactive_inference)

总之，ML 模型中的任何偏差都是由于注释数据的人员中存在的某种偏差，或者是由于偏斜或缺少特征或任何其他需要挑选和调查的原因而存在于数据本身中。未能捕捉这些特征并概括数据来训练模型会导致模型偏差。有偏见的机器学习模型可能会导致做出不公平/有偏见的决策，从而影响最终用户。因此，所有利益相关者都应该集中精力检测他们开发的模型中是否存在偏见，这一点非常重要。

评估推荐系统:均方根误差还是平均绝对误差？

原文：https://towardsdatascience.com/evaluating-recommender-systems-root-means-squared-error-or-mean-absolute-error-1744abc2beac?source=collection_archive---------11-----------------------

推荐系统的准确性通常通过两个主要指标来评估:均方根误差(RMSE)和平均绝对误差(MAE)。两者都很好，因为它们允许容易的解释:它们都与原始评级的规模相同。然而，根据数据集的上下文，使用其中一个可能更好。我们来探究一下原因。

成本和收益:

Source: the Surprise Library Docs, where R is the predicted Ratings Matrix.

平均误差(MAE)的一个大的特征是在误差项中不会对极值产生任何偏差。如果有异常值或较大的误差项，它会将这些与其他预测进行同等加权。因此，当您不真正关注异常值的重要性时，在关注评级准确性时，MAE 应该是首选。要获得推荐系统的整体视图或表示，请使用 MAE。

Source: the Surprise Library Docs, where R is the predicted Ratings Matrix.

均方根误差的一个趋势是，当残差(误差项)被平方时，它倾向于不成比例地惩罚大误差。这意味着 RMSE 更容易受到异常值或糟糕预测的影响。

根据定义，RMSE 永远不会像梅一样小。然而，如果误差项遵循正态分布，T. Chai 和 R. R. Draxler 在的这篇论文中表明，在给定足够数据的情况下，使用 RSME 允许误差集的重构。另一方面，MAE 只能准确地重建 0.8 的数据集。此外，RSME 不使用绝对值，这在计算距离、梯度或其他度量时更方便。这就是为什么机器学习中的大多数成本函数都避免使用 MAE，而是使用误差平方和或均方根误差。

长尾的重要性:

Source: Recommender Systems: The Textbook by Charu Aggarwal

推荐系统的数据集通常只有很少的项目包含最多的评价，而大多数项目只有很少的评价。这影响了准确度测量，因为对流行项目的准确度预测通常不同于对稀疏评级项目的准确度预测。这个问题的一个解决方案是，在计算 RSME 或 MAE 时，给每个商品一个特定的权重，这是由商家决定的。这些可以允许推荐系统如何评估所有项目的更准确的表示。

来源及延伸阅读:

大量信息来源于 Chai 和 Drexler 的这篇论文，https://www . geosci-model-dev . net/7/1247/2014/gmd-7-1247-2014 . pdf

以及 Charu Aggarwal 的《推荐系统:教科书》第七章的讨论。

评估 NLP: BLEU 中的文本输出风险自担

原文：https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213?source=collection_archive---------5-----------------------

刚进入 NLP 的人经常问我一个问题，当系统的输出是文本，而不是输入文本的某种分类时，如何评估系统。这种类型的问题，你把一些文本放入你的模型，并从中获得一些其他文本，被称为序列到序列或字符串转换问题。

这些问题真的很有趣！序列到序列建模的一般任务是 NLP 中一些最困难任务的核心，包括:

文本摘要
文本简化
问题回答
聊天机器人
机器翻译

这种技术完全出自科幻小说。有了如此广泛的令人兴奋的应用，很容易理解为什么序列到序列建模比以往任何时候都更受欢迎。真正不容易的是评估这些系统。

不幸的是，对于那些刚刚起步的人来说，对于应该使用什么样的指标来评估你的模型，没有简单的答案。更糟糕的是，评估序列到序列任务的最流行的度量标准之一 BLEU 有重大缺陷，特别是当应用于它从未打算评估的任务时。

幸运的是你，你已经找到了这篇有深度的博文！在这篇文章中，我将介绍这个流行的度量标准是如何工作的(别担心，我会尽量减少方程)。我们将看看 BLEU 的一些问题，最后，你如何在你自己的工作中最小化这些问题。

Orange painted blue on a blue background. (There, uh, aren’t a lot of eye-catching photos for NLP evaluation metrics as it turns out.)

一个非常困难的问题

BLEU 最初是为了测量机器翻译而开发的，所以让我们来看一个翻译示例。下面是语言 A(又名“法语”)中的一段文本:

你好，曼杰特罗伊斯·费尔伯特。

这里有一些 B 语言(又名“英语”)的参考译文。(注意，一些说英语的人称榛子为“filberts”，所以这两个都是非常好的翻译。)

我已经吃了三颗榛子了。

我吃了三块榛子。

这里的是一个生成的“神经”翻译。(在这种情况下，“神经”是“雷切尔用她的大脑想出了一个可能的翻译”，但假装这是由你正在训练的网络生成的。)

我吃了三颗榛子。

现在，这里有一个非常困难的问题: 我如何给这个翻译分配一个单一的数字分数，告诉我们仅使用提供的参考句子和神经输出，它有多“好”？

为什么需要单个数值分数？很棒的问题！如果我们想使用机器学习来建立一个机器翻译系统，我们需要一个单一的实数分数放入我们的损失函数。如果我们还知道潜在的最佳得分，我们就可以计算两者之间的距离。这使我们能够在系统训练时向系统提供反馈，即潜在的变化是否会通过使分数更接近理想分数来改善翻译，并通过查看相同任务的分数来比较经过训练的系统。

您可以做的一件事是查看输出句子中的每个单词，如果它出现在任何参考句子中，则给它打分 1，如果没有出现，则给 0。然后，为了标准化该计数，使其始终介于 0 和 1 之间，您可以将某个参考译文中出现的单词数除以输出句子中的总单词数。这给了我们一个叫做的度量单位精度。

所以，对于我们的例子，“我吃了三个榛子”，我们在至少一个参考句子中看到输出句子中的所有单词。除以输出中的单词数，4，您最终得到这个翻译的得分为 1。到目前为止一切顺利！但是这句话呢？

三三三三。

使用同样的标准，我们也会得出 1 分。这并不好:我们需要某种方式来告诉我们正在训练的系统，像第一个这样的句子比第二个这样的句子更好。

你可以根据每个单词在任何参考句子中出现的最高次数，通过限制次数来调整分数。使用这种方法，我们的第一句仍然会得到 1 分，而我们的第二句只会得到 0.25 分。

这让我们摆脱了“三三三三”的问题，但对于像这样的句子没有帮助，因为某种原因，单词是按字母顺序排列的:

我吃了三颗榛子

用我们现在的方法，这句话得 1 分，最高分！我们可以通过计数来解决这个问题，不是单个单词，而是相邻出现的单词。这些被称为 n-grams ，其中 n 是每组的字数。单字、双字、三字和四字分别由一个、两个、三个和四个单词组成。

对于这个例子，让我们使用二元模型。一般来说，BLEU 分数是基于一元、二元、三元和四元精度的平均值，但为了简单起见，我们在这里只坚持二元。同样为了简单起见，我们不会添加一个“单词”来告诉我们在句子的开头和结尾有一个句子边界。根据这些原则，单词按字母顺序排序示例中的二元模型是:

[吃了榛子]

[榛子一号]

[我三]

如果我们用同样的方法计算单词，我们现在得到的分数是 0；最差的分数。我们的“三三三三”示例也得到 0 分，而不是现在的 0.25 分，而第一个示例“我吃了三颗榛子”的得分是 1 分。不幸的是，这个例子也是如此:

我吃过了。

解决这个问题的一个方法是将我们目前的分数乘以一个惩罚比我们的参考译文短的句子的标准。我们可以通过比较它和长度最接近的参考句子的长度来做到这一点。这就是简短的代价。

如果我们的输出和任何参考句子一样长或者更长，惩罚是 1。因为我们用它乘以我们的分数，这不会改变最终的输出。

另一方面，如果我们的输出比任何参考句子都短，我们用最接近的句子的长度除以我们的输出长度，从中减去 1，然后将 e 提高到整个句子的幂。基本上，最短的参考句子越长，我们的输出越短，简短惩罚就越接近于零。

在我们的“我吃了”例子中，输出句子是两个单词长，最接近的参考句子是四个单词。这给了我们 0.36 的简洁性损失，当乘以我们的双字母精度分数 1 时，我们的最终分数下降到只有 0.36。

这种方法着眼于输出和参考翻译之间的 n-grams 重叠，对较短的输出进行惩罚，被称为 BLEU (“双语评估替角”的缩写，人们实际上只在解释缩写词时才会说)，由 IBM 的 Kishore Papineni、Salim Roukos、Todd Ward 和 Wei-朱婧于 2002 年开发。这是 NLP 中一个非常流行的度量，特别是对于系统输出是文本字符串而不是分类的任务。这包括机器翻译和越来越多的自然语言生成。这是我在这篇文章开始时提出的一个非常困难的问题的解决方案:开发一种方法，给一个翻译分配一个单一的数字分数，告诉我们它有多“好”。

它也有很大的缺陷。

布鲁的问题

此时，您可能会疑惑，“ Rachael，如果这个指标有这么大的缺陷，您为什么要向我们介绍如何计算它呢？“主要是给你看这个指标有多合理。这是相当直观的，其基本思想是，你可以通过与参考翻译进行比较来评估机器翻译系统的输出，这在 NLP 中具有极大的影响力(尽管并非没有批评者)。

BLEU 也当然有一些长处。在 NLP 工作的人们最关心的是它对研究人员来说有多方便。

计算起来既快又容易，尤其是与让人工翻译来评估模型输出相比。
它无处不在。这使得将您的模型与相同任务的基准进行比较变得容易。

不幸的是，这种便利性导致人们过度使用它，即使对于它不是度量标准的最佳选择的任务。

尽管我只举了一个句子的例子，BLEU 一直被认为是一个语料库级别的测量方法。获取语料库中每个句子的 BLEU 分数，然后对它们进行平均，这将人为地抬高你的分数，如果你试图在你做的地方发表作品，你肯定会被评论者批评。

即使它没有被过度应用，在你选择花费时间和计算追求更好的 BLEU 分数之前，你应该知道这个指标有严重的限制。虽然有很多关于 BLEU 缺点的讨论，但我认为最重要的四个问题是:

它不考虑意义
它不直接考虑句子结构
它不能很好地处理形态丰富的语言
它不太符合人类的判断

让我们逐一讨论这些问题，这样我可以向您展示为什么我认为这些是问题。

BLEU 不考虑意义

对我来说，这是不仅仅依靠 BLEU 来评估机器翻译(MT)系统的最有说服力的理由。作为机器翻译的人类用户，我的主要目标是准确理解原文中文本的潜在含义。我很乐意接受输出句子中的一些句法或语法怪异，只要它符合原文的意思。

BLEU 不衡量意义。它只奖励在参考系统中有精确匹配的 n 元文法的系统。这意味着一个虚词(如“an”或“on”)的差异与一个更重要的实词的差异一样严重。这也意味着一个翻译有一个完全有效的同义词，只是没有出现在参考翻译中，这将受到惩罚。

让我们看一个例子，这样你就能明白为什么这是一个问题。

原文(法语): J'ai mangé la pomme。

参考译文:我吃了苹果。

基于 BLEU，这些都是“同样糟糕”的输出句子。

我吃掉了苹果。

我吃了一个苹果。

我吃了土豆。

作为一个机器翻译系统的最终用户，我实际上对前两句没什么意见。尽管它们与参考译文不完全相同，但它们表达了意思。然而，第三句完全不能接受；它完全改变了原来的意思。

基于 BLEU 的指标之一， NIST ，通过对不匹配的 n-grams 进行加权来解决这个问题。因此，在更常见的 n-gram(如“of of”)上的错配将受到更低的惩罚，而在更罕见的 n-gram 上的错配(如“水牛”)将受到更高的惩罚。但是，虽然这解决了给予虚词太多权重的问题，但它实际上使惩罚同义词的问题(如“ambled”代表“walked”)变得更糟，因为这些同义词只出现在更罕见的 r-gram 中，因此被赋予更高的惩罚。

BLEU 不考虑句子结构

也许你不相信“即使你弄乱了几个关键词，完全改变了句子的意思，你仍然可以得到很好的 BLEU 分数”这句话。也许一些语法会说服你？

句法是对句子结构的研究。这是一个研究领域，它允许我们正式地模仿像“我用望远镜看到了狗”这样的句子，这可能意味着要么我在用望远镜看狗，要么狗拿着望远镜。这两种意思之间的差异只能通过模拟句子中的单词可以彼此具有不同关系的事实来捕捉。

我不是世界上最伟大的句法学家(差得远)，但即使是我也知道自然语言中有很多重要的内部句法结构，如果你随机打乱一个句子中单词的顺序，你要么得到 1)无意义的单词，要么得到 2)意义非常不同的东西。

幸运的是，在开发系统以自动建模该结构方面已经做了大量的工作，这被称为解析。

不幸的是，BLEU 并没有建立在这些研究之上。我可以理解你为什么想要避免它，因为解析往往是相当计算密集型的，每次求值都必须解析所有的输出确实会增加一些开销。(尽管有一些度量标准，如 STM 或子树度量标准，直接比较引用和输出翻译的解析。)

然而，不考虑句法结构的结果意味着表面词序完全混乱的输出可以得到与那些更加连贯的输出相同的分数。

Callison-Burch 等人(2006 年)对此有一个很好的说明。对于这组参考句子:

Orejuela 在被带到美国飞机上时显得很平静，这架飞机将把他带到佛罗里达州的迈阿密。

Orejuela 在被护送到飞往佛罗里达州迈阿密的飞机上时显得很平静。

Orejuela 看起来很平静，因为他正被带到美国飞机上，飞机将带他去佛罗里达州的迈阿密。

Orejuela 看起来很平静，因为他被带到了美国飞机，将带他到佛罗里达州的迈阿密。

他们生成了这个机器翻译。

当他被带上飞往佛罗里达州迈阿密的美国飞机时，显得很平静。

这不是一个完美的翻译——这个人的名字被省略了，在句子的后半部分“will”后面没有动词——但也不是完全没有意义。然而，这个例子是:

在飞往佛罗里达州迈阿密的美国飞机上，他看起来很平静。

踢球者？第一个和第二个输出得到完全相同的 BLEU 分数，尽管第一个输出显然是更好的英语翻译。

BLEU 不能很好地处理形态丰富的语言

如果像地球上的大多数人一样，你碰巧使用英语以外的语言，你可能已经发现了这个指标的问题:它是基于单词级匹配的。对于形态丰富的语言来说，这很快就会成为一个问题。

语素是语言中最小的意义单位，组合在一起构成单词。英语中的一个例子是“cats”中的“s ”,它告诉我们不止有一只猫。一些语言，如土耳其语，在一个单词中有很多语素，而其他语言，如英语，通常每个单词的语素较少。

想想秘鲁人所说的 Shipibo 语中的下列句子。(这些例子来自 Pilar Valenzuela 的《Shi pibo-koni bo 中的言据性，以及 Panoan 中的类别比较概述。)

你好，我好。

Jawen jemaronki ani iki。

这两个都是英语句子“她的村庄很大”的完全可以接受的翻译你可能会注意到，以“jemar-”开头的中间词在两个句子中有不同的结尾。不同的词尾是不同的词素，表明说话者对村庄很大这一事实有多确定；最上面的意思是他们确实去过那里，最下面的是他们从别人那里听说的。

这种特殊类型的语素被称为“据实性标记”，而英语没有这种标记。然而，在 Shipibo 中，你需要这两个语素中的一个来使句子合乎语法，所以我们的参考译文肯定会有这两个语素中的一个。但是，如果我们没有碰巧生成我们在参考句子中的单词的精确形式，BLEU 会为此惩罚它…即使两个句子都很好地捕捉了英语的意思。

蓝色不太符合人类的判断

如果你的眼睛开始呆滞，当我进入语法位，现在是时候调回来了。

构建机器翻译、聊天机器人或问答系统的最终目标是什么？你最终希望人们使用它，对吗？如果一个系统不能提供有用的输出，人们就不会使用它。因此，你实际上想要优化的是使用你的系统的人喜欢它的程度，这是有道理的。我们使用的几乎所有指标都被设计成不同的近似方式。

当 BLEU 第一次被提出时，作者确实做了一些行为测试，以确保该测量与人类判断相关。(并为此向他们表示祝贺！不幸的是，随着研究人员做了更多的实验来比较 BLEU 分数和人类的判断，他们发现这种相关性并不总是很强，其他指标往往更接近人类的判断，这取决于具体的任务。

例如，Turian 等人(2003 年)发现，在三种度量中，BLEU 与机器翻译的人类判断的相关性最差，简单 F1 与人类判断的相关性最强，其次是 NIST。 Callison-Burch 等人 (2006)研究了为共享任务开发的系统(就像学术上的 Kaggle 竞赛，但没有奖金),发现这些系统的相对排名非常不同，这取决于你是在看 BLEU 分数还是人类评估员的判断。而孙 (2010)比较了三个不同的指标——BLEU、GTM 和 TER——再次发现，BLEU 评分与人类判断的相关性最小。

换句话说:如果你想让人们喜欢使用你的系统，你不应该只关注获得更高的 BLEU 分数。

我不是唯一有所保留的人

也许你仍然不相信 BLEU 并不总是这项工作的合适工具。那也行；事实上，我赞成你的怀疑态度！然而，我并不是唯一一个不热衷于这一指标的 NLP 从业者。这里有一些同行评议论文的快速链接，这些论文对 BLEU 的其他一些缺点进行了更多的讨论。

同行评审论文:

Reiter (2018)对使用 BLEU 和人类判断进行评估的 ACL 论文进行了元综述，并发现它们仅在机器翻译系统的系统级审查中一起使用。
Sulem 等人 (2018)建议不要使用 BLEU 进行文本简化。他们发现，BLEU 分数不能很好地反映语法或意义保留。
Novikova 等人 (2017)表明，BLEU 以及其他一些常用的指标，在评估 NLG(自然语言生成)任务时，不能很好地映射到人类的判断。
Ananthakrishnan 等人 (2006)列出了几种对 BLEU 的具体反对意见，并对 BLEU 得分较高的英语/印地语翻译中的具体错误进行了深入探究。

这里有一些未经同行评审的资源。(虽然它们可能不会让看你写的研究论文的同行评议者信服，但它们可能更容易说服你的老板。)

其他资源:

Amazon Research 的 Matt Post 对预处理对 BLEU 分数的影响进行了精彩的讨论。
本文由从事翻译工作的 Kirti Vashee 撰写，从译者的角度讨论了 BLEU 的问题。
Yoav Goldberg 做了一个非常好的演讲，其中包括在 2018 年自然语言生成国际会议上讨论为什么不应该为 NLG 使用 BLEU。您可以在此处找到幻灯片(搜索“BLEU 可能会误导”以获得相关幻灯片)。特别是，他和他的合作者发现，他们的句子简化模型即使通过添加、删除或重复信息也能获得很高的 BLEU 分数。
Ana Marasovi 的博客文章" NLP 的泛化问题，以及研究人员如何解决它"讨论了包括 BLEU 在内的个体指标如何无法捕捉模型处理与他们在训练期间接触到的数据不同的数据的能力。

那么你应该用什么来代替呢？

我想让你在评估以文本为输出的系统时使用的主要东西是小心，尤其是当你正在构建最终可能会投入生产的东西的时候。对于 NLP 从业者来说，思考我们的工作将如何被应用，以及什么可能出错，这真的很重要。想想这个因为脸书把一篇说“早上好”的帖子翻译成“攻击他们”而被捕的巴勒斯坦人！我不是特别针对脸书，我只是想指出，NLP 产品的风险可能比我们有时意识到的要高。

仔细挑选我们优化的指标是确保我们工作的系统实际可用的重要部分。例如，对于像机器翻译这样的任务，我个人认为惩罚意义上的巨大变化是非常重要的。

也就是说，有很多自动评估指标可以替代 BLEU。它们中的一些将更适合不同的任务，因此值得花一些时间来评估什么是适合您的特定项目的最佳选择。

两种流行的方法实际上是 BLEU 的衍生，旨在帮助解决它的一些缺点。

NIST ，正如我上面提到的，根据其稀有程度对 n-grams 进行加权。这意味着正确匹配一个罕见的 n-gram 比正确匹配一个常见的 n-gram 更能提高你的分数。
ROUGE 是 BLEU 的修改版，侧重于召回而非精确。换句话说，它查看参考翻译中有多少 n 元语法出现在输出中，而不是相反。

还有许多方法可以用来评估不基于 BLEU 的序列对序列模型。其中一些是从机器学习的 NLP 的其他领域采用的方法。

困惑是信息论中的一种度量，更常用于语言建模。它衡量单词的学习概率分布与输入文本的匹配程度。
单词错误率，或称 WER ，是语音识别中常用的指标。它测量在给定参考输入的情况下，输出序列中的替换(“an”代表“the”)、删除和插入的数量。
F 值，也就是通常所说的 F1，是精确度(有多少预测是正确的)和召回率(有多少可能的正确预测被做出)的平均值。

其他的是专门为序列到序列任务开发的。

STM，或子树度量(我在上面提到过)比较参考和输出翻译的解析，并惩罚具有不同语法结构的输出。
METEOR 类似于 BLEU，但包括额外的步骤，如考虑同义词和比较词干(这样“running”和“runs”将被视为匹配)。与 BLEU 不同的是，它被明确设计用来比较句子而不是语料库。
之三，或翻译错误率，衡量将原始输出翻译转变为可接受的人工翻译所需的编辑次数。
TERp ，或 TER-plus，是 TER 的扩展，它还考虑了释义、词干和同义词。
hLEPOR 是一种度量标准，更适合于像土耳其语或捷克语这样形态复杂的语言。除其他因素外，它还考虑词类(名词、动词等)。)可以帮助捕获语法信息。
像赫莱波里一样，里伯斯并不依赖与英语具有相同品质的语言。它旨在为亚洲语言——如日语和汉语——提供更多信息，而不仅仅是单词边界。
MEWR 可能是列表中最新的指标，我发现它特别令人兴奋:它不需要参考翻译！(这对于可能没有大型并行语料库的低资源语言来说非常好。)它结合使用单词和句子嵌入(捕捉意义的某些方面)和困惑来给翻译评分。

当然，我这里没有足够的空间来涵盖研究人员在这里开发的所有自动化指标。尽管如此，请随意在评论中加入一些你最喜欢的，以及你为什么喜欢它们！

所以你的意思是…这很复杂？

这几乎是问题的核心。语言是复杂的，这意味着自动测量语言是困难的。我个人认为，为自然语言生成开发评估指标可能是目前 NLP 中最困难的问题。(如果你和我一样感兴趣的话，实际上在 NAACL 2019 上有一个 n 即将举行的研讨会。)

也就是说，有一个很好的方法可以确保你的系统确实在做人类喜欢的事情方面做得更好:你可以问真实的人他们是怎么想的。人工评估曾经是机器翻译的标准，我认为它仍然有一席之地。是的，它很贵，而且，是的，它需要更长的时间。但至少对于即将投入生产的系统，我认为你应该至少和人类专家进行一轮系统评估。

不过，在你进入那一轮之前，你可能需要使用至少一个自动评估指标。我强烈建议你使用 BLEU 当且仅当:

你在做机器翻译
你在评估整个语料库和
你知道指标的局限性，并准备接受它们。

否则，我会花时间找到一个更适合您的特定问题的指标。

关于作者:

Rachael 是 Kaggle 的数据科学家(有趣的是，ka ggle 从未举办过使用 BLEU 作为评估指标的比赛)。她有语言学博士学位，还有一只名叫古斯塔夫的刺猬。如果你有兴趣看更多她的 NLP 教程和项目，你可以在这里查看。

对机器学习的规避攻击(或“对抗性例子”)

原文：https://towardsdatascience.com/evasion-attacks-on-machine-learning-or-adversarial-examples-12f2283e06a1?source=collection_archive---------7-----------------------

机器学习的安全性

你的 ML 模型比你想象的要容易骗

Source.

机器学习令人兴奋。然而，就像任何新的技术或发明一样，ML 不仅带来了新的惊人能力——但不幸的是，也带来了新的漏洞。

之前我已经讨论过如何以结构化的方式考虑这些漏洞(或者如何为你的 ML 开发一个“威胁模型”)。这一次，我将深入探讨如何通过所谓的规避攻击在推理时间利用您的 ML 系统。

没有时间浪费了，让我们开始吧。

逃避机器学习

当网络被输入一个“对立的例子”——一个仔细扰乱的输入，看起来和感觉上与人类未经篡改的副本完全一样——但完全摆脱了分类器时，规避攻击就发生了。

Source.

尽管所有关于对立例子的宣传都是“新”现象，但它们实际上并不那么新。对抗性 ML 的领军人物之一 Battista Biggio 的一篇论文指出，攻击机器学习领域最早可以追溯到 2004 年。当时，在垃圾邮件过滤的背景下研究了对立的例子，表明线性分类器可以很容易地被垃圾邮件内容中几个精心制作的变化所欺骗。

完整时间表:

对立例子的“新奇”真正来自于它们是在深度学习的背景下被发现的。2013 年，谷歌人工智能的 Christian Szegedy 致力于理解神经网络如何“思考”,但却发现了一个所有神经网络似乎都拥有的有趣特性——很容易被微小的干扰所愚弄。鉴于深度学习已经变得如此之大——对抗性例子和对抗性 ML 领域已经成为焦点。

当谈到对立的例子时，我将主要使用计算机视觉论文——但实际上它们同样适用于任何类型的机器学习系统，从复杂到不复杂。以下是我个人最喜欢的一些:

图片:用对抗眼镜糊弄人脸检测。

视频:DEFCON上的隐身 t 恤。

音频:语音转文本转录。

语言:情感分析和文本推导。

强化学习:赛船。

恶意软件:利用 RL 躲避恶意软件分类器。

为什么会有对抗性的例子存在？

这是个很好的问题。到目前为止，对于这种情况的原因，机构群体还没有达成共识。存在许多假设。

试图解释对立例子的第一个也是最初的假设来自 Szegedy 自己的论文，其中他们认为它们的存在是由于流形中低概率“口袋”的存在(即太多的非线性)和网络的不良正则化。

后来出现了一种相反的理论，由 Goodfellow 首创，认为事实上对立的例子是由于现代机器学习，特别是深度学习系统中太多的线性而发生的。Goodfellow 认为，像 ReLU 和 Sigmoid 这样的激活函数基本上是中间的直线(在这里，碰巧我们更喜欢保持梯度，以防止它们爆炸或消失)。所以在一个神经网络中，你有大量的线性函数，所有的都延续着彼此的输入，都在同一个方向。如果你对一些输入(这里或那里的几个像素)添加微小的扰动，这些扰动在网络的另一端积累成巨大的差异，它就会吐出乱码。

第三个也可能是今天最普遍采用的假设是倾斜边界。简而言之，作者认为，因为模型永远不会完美地拟合数据(否则测试集的准确性将一直是 100%) —在分类器的边界和采样数据的实际子流形之间，总会存在对立的输入口袋。他们还从经验上揭穿了前两种方法，所以如果你是技术人员，这篇文章值得一读。

还有其他一些非常数学化的解释:

缺乏足够的训练数据
构建鲁棒分类器的计算困难

最后是我个人的最爱。麻省理工学院最近的一篇论文认为，对立的例子不是一个错误——它们是神经网络看待世界的一个特征。仅仅因为我们人类局限于三维空间，不能区分噪声模式，并不意味着这些噪声模式不是好的特征。我们的眼睛只是糟糕的传感器。因此，我们在这里真正处理的是一个比我们自己更复杂的模式识别机器——而不是把我们不理解的模式称为“对立的例子”,我们应该接受这个世界比看起来更复杂(明白吗？).

Source.

如果整篇论文太长——我强烈推荐这篇11 分钟的博客摘要。

顺便说一句，那篇论文独特地解释了与对立例子相关的另一个真正有趣的现象——它们的可转移性。以前的工作指出，对立的例子很容易在不同的模型和不同的数据集之间转移。没错——你可以在狗和猫之间训练一个模型，但你可以在输入中加入相同的敌对噪音,愚弄一个在热狗和非热狗之间训练的完全不同的模型。因为麻省理工学院的论文指出，噪音实际上是一种特征，所以图像领域的其他图像(无论是猫、狗、热狗还是不是热狗)都共享它是有道理的。迷人的东西。

攻击者的能力和敌对的例子

攻击者对目标系统的了解(或他们的"能力")非常重要。他们对你的模型和它是如何构建的了解得越多，他们就越容易对它发起攻击。

在 Calypso 我们将闪避攻击分为五个独立的类别:

那些使用渐变的
那些使用置信度分数的
那些使用硬标签的
那些使用代理模型的
暴力攻击

根据定义，基于梯度的攻击需要访问模型的梯度，因此是一种白盒攻击。这些无疑是最强大的，因为攻击者可以利用他们对模型如何思考(其梯度)的详细理解来数学优化攻击。

这也是最适合攻击硬化模型的技术。事实上，的研究已经表明，如果攻击者能够访问模型的渐变——他们将总是能够编造一套新的对抗性例子来欺骗模型。这就是为什么对立的例子如此重要的原因——通过模糊性获得安全性除此之外，防御它们实际上是相当困难的(稍后将详细介绍)。

迄今为止，三种最强大的基于梯度的攻击是:

EAD (L1 标准)
C & W (L2 标准)
马德里(李定额)

置信度得分攻击使用输出的分类置信度来估计模型的梯度，然后对上述基于梯度的攻击进行类似的智能优化。这种方法不需要攻击者了解模型的任何信息，因此属于黑盒类型。

迄今为止，三种最强大的基于信任的攻击是:

动物园
SPSA
NES

硬标签攻击只依赖模型输出的标签(“猫”、“狗”、“热狗”)，不需要置信度得分。这使得攻击更加愚蠢——但可以说更加现实(你知道有多少公共端点输出分类分数？).这一类别中最强大的攻击仍然是边界攻击。

代理模型攻击与基于梯度的攻击非常相似，只是它们需要一个额外的步骤。当对手无法访问模型的内部，但仍想发起白盒攻击时，他们可以尝试首先在他们的机器上重建目标的模型。他们有几个选择:

如果目标模型作为一个 oracle 可用，攻击者可以通过重复查询端点和观察输入输出对来了解它(我在这里将更多地讨论这种“逆向工程”攻击
如果目标模型应用于标准的分类任务(例如人脸检测)，攻击者可能只是猜测模型被训练的架构和数据，并使用它来构建副本
如果攻击者没有任何信息，由于我们之前讨论的可转移属性，他们可以简单地使用任何现成的图像分类器，并生成不完美但功能强大的对抗示例

最后，还有蛮力攻击。这些攻击根本不使用优化来生成对立的例子，而是求助于简单的东西，如:

随机旋转/平移图像
应用公共扰动
添加具有大 SD 的高斯噪声

如何针对对抗性的例子进行辩护？

简而言之——很难。我们真的是进退两难。让我们检查两大类辩护——经验辩护和形式方法。

让我们从正式方法开始，因为它们讨论起来更快。你们当中那些在芯片设计或航空航天&国防等行业工作过的人应该对形式化方法很熟悉。对其他人来说——形式方法是一种数学技术，用于保证软件/硬件系统的健壮性。在大多数软件中，如果你设计或构建错误，可能会导致一些停机时间和一些愤怒的客户评论——但它可能不会杀死任何人。然而，在某些行业，这样的缺陷是不可接受的。你不能制造了 1 亿个芯片却发现芯片的某个部分有缺陷——你也不能把一架飞机放在空中，除非你已经用数学方法验证了每个组件都按预期工作。

形式方法的工作方式非常简单，就是尝试每一种可能的场景，然后看看它是如何进行的。在规避攻击的世界里，这意味着试图在一定的干扰半径内产生每一个可能的敌对例子。例如，假设您有一个只有两个灰度像素的图像，比如 180 和 80。那么让我们假设你决定在每个方向上的扰动范围为 3。这给了你(3+1+3)或 49 种组合来尝试——如果你想正式验证这些组合中没有一个是敌对的，你就必须将每一个都放入你的模型中，看看另一端会出现什么。

二维无色图像的 49 种组合。一幅 1000 x 1000px 的彩色图像，每个方向的扰动范围都是 3，会怎么样？这是要检查的(3+1+3)^(3*1000 *** 1000 个)组合(excel 拒绝提供数字)！

希望你能很快发现正式方法的问题——从计算的角度来看，它们并不便宜，而且通常完全难以处理。事实上，当应用于神经网络时，目前最先进的形式方法技术不能验证超过几层深度的网络。因此，目前这是一个有价值的——但难以实现的愿望。

如果你确实想更深入地了解神经网络的形式方法，这里有一些不错的论文:

Reluplex:验证深度神经网络的高效 SMT 求解器
深度神经网络安全验证
用混合整数规划评估神经网络的鲁棒性

否则，让我们继续进行实证防御。经验辩护顾名思义，就是依靠实验来论证辩护的有效性。例如，你可能攻击一个模型两次——首先是一个正常的、不设防的版本，然后是一个加固的版本——观察每个版本有多容易被欺骗(希望加固的模型表现得更好)。因此，正式方法试图计算每一种可能的情况，并在这样做的过程中验证不存在对立的例子——经验方法采取“你看它有效，为什么要计算”的方法。

让我们来看看一些更受欢迎的类型:

对抗训练
梯度掩蔽
输入修改
侦查
额外课程

对抗性训练——传授当今最受关注、也可以说是最有效的防守。在对抗训练期间，防御者用训练池中包含的对抗例子来重新训练模型，但是用正确的标签来标记。这教导模型忽略噪声，并且仅从“鲁棒的”特征中学习。

对抗性训练的问题在于，它只能保护你的模型免受与最初训练样本相同的攻击。因此，如果有人随后发起使用不同算法优化的攻击，或者发起适应性攻击(即针对防御模型的白盒攻击)，他们就能够再次欺骗分类器，就好像没有防御措施一样。

你可能会想，嗯，你可以不断地重新训练你的模型，一遍又一遍地包括新伪造的对立例子——但在某些时候，你已经向训练集中插入了如此多的虚假数据，以至于模型学习的边界基本上变得无用。

也就是说，如果目标只是让攻击者更难绕过分类器，那么对抗性训练是一个可靠的选择。实际上也有很多创造性的方法来做这件事:

在的合奏
梯级在
AT的稳健优化方法
通过光谱归一化

接下来，渐变蒙版。基本上是不防。有一段时间，敌对的 ML 社区认为，因为需要梯度来计算对模型的强大攻击，隐藏梯度应该可以解决这个问题。防御性蒸馏非常受欢迎——但很快被证明是假的。

梯度掩蔽不能作为一种防御策略的原因是因为对立例子的可转移性。即使你成功隐藏了模型的渐变——攻击者仍然可以构建一个代理，攻击它，然后转移例子。

输入修改发生在输入在被传递到模型之前，以某种方式被“清理”以消除敌对噪音。例子包括各种去噪解决方案(自动编码器、高级代表性去噪器、颜色位深度减少、平滑、重整 GANs 、 JPEG 压缩、fova tion、像素偏转、通用基函数变换等等。

接下来，检测。一些检测方法与输入修改密切相关，因为一旦输入被清除，就可以将其预测与原始预测进行比较，如果两者相差很远，则很可能输入已被篡改。下面是几个的例子。

其他的就不一样了。他们实际上训练了一个独立的检测网络，其唯一的工作就是决定一个输入是否是敌对的。此外，还有许多检测防御措施，用于检查在输入馈送/预测流程的不同点计算的原始统计数据:

在上输入本身
关于卷积滤波器
在 ReLU 激活时
在逻辑上

总的来说，输入修改和检测方法很棒，因为它们可以应用于已经训练好的模型，并且不需要数据科学家回到原点。在卡里普索，我们是这种防守的忠实粉丝。

最后，还有额外(空)类方法。这个想法很简单。分类器是在一个非常特殊的数据分布上训练的，根据定义，当超出这个范围时，分类器是没有线索的。因此，与其强迫分类器在它显然不知道标签是什么的时候猜测标签，为什么不给它弃权的选项呢？这就是空类所支持的(论文)。

总而言之，经验防御是不完美的——但它们是有效的，有时只需要几行代码。是的，不可否认，他们是攻击者的一场永无止境的猫捉老鼠游戏，新的游戏通常会很快被打破——但是如果你认为攻击者像电一样(总是选择阻力最小的路径)——我们的工作就是让他们的生活足够艰难。

结束语

唷！这是一篇很长帖子——但希望你觉得它有趣且有用。

最后一点，如果你是一名工程师而不是数学家，并且更喜欢通过做来学习，那么人工智能伦理研究所&机器学习有一个关于对抗性鲁棒性的优秀开源工具集合。去玩吧。

否则，如果你已经完成了规避攻击，但还想了解更多关于 ML 安全的知识，我推荐你阅读我的其他关于 ML 安全威胁模型和中毒和隐私攻击的帖子。

确保每个人的安全。

洗过熊猫吗？

原文：https://towardsdatascience.com/ever-washed-a-panda-c94d23c47667?source=collection_archive---------25-----------------------

熊猫数据帧清理简介

通常在数据科学中，我们会对项目的目标感到兴奋。“我要用回归模型来预测燃油效率，并让我的结果达到 5%以内的准确度！”我们很想马上就去实践这个想法。在头脑中开始一个伟大的目标可能是一个巨大的动力，但是要小心跳过任何项目中最重要的部分之一的危险:数据清理。它也许并不华丽，也许你并没有拯救世界，但是用一个比我更聪明的人的话来说:

A wise old tree teaches life lessons

在匆忙进行预测之前，真正了解一个数据集是建立健康、持久关系的最佳方式。

At the panda wash! woah woah woah at the…

相信我，数据奖励我们慢下来从各个角度考虑问题。让我们问一些基本的问题:当我们看我们的数据时，我们看到了什么？我们应该看吗？每一列的意图是什么？这些值是字面意义上的还是分类意义上的？该列中的值如何与其他列中的值相关联？我知道这些问题看起来很简单，但是从小处着手可以帮助你抓住一些你在匆忙中可能会错过的东西。你可能会惊讶于简单的问题会引出更复杂的问题。

好了，是时候穿上我们的雨衣，拿起海绵和橡胶扫帚，变得有点脏了。

出于这个练习的目的，我们会说我正试图根据可用的数据来预测游戏分数。我将使用 kaggle 的游戏评论数据集，可以在这里找到:https://www . ka ggle . com/egrinstein/20-years-of-games/downloads/20-years-of-games . zip/2

当我们查看数据时，我们看到了什么？我们应该看吗？

让我们从导入 pandas 开始，将 csv 文件读入数据帧:

import pandas as pd
df = pd.read_csv('ign.csv')df.head()

a first look at our dataframe

从一开始，我就能看出一些问题。首先，看起来这个 csv 文件有自己的索引列。保留这两个都是多余的，所以让我们通过专门调用 csv 索引列来去掉我们的。

df = pd.read_csv('ign.csv',index_col='Unnamed: 0')

2.每一列的意图是什么？这些值是字面意义上的还是分类意义上的？

我们有两个可能包含分数的列:score_phrase，看起来像文本，score，看起来像数字。在上下文中，这两列似乎都表示分类数据。让我们看看它们的数据类型和值:

df.score_phrase.value_counts()Great          4773
Good           4741
Okay           2945
Mediocre       1959
Amazing        1804
Bad            1269
Awful           664
Painful         340
Unbearable       72
Masterpiece      55
Disaster          3
Name: score_phrase, dtype: int64df.score.describe()count    18625.000000
mean         6.950459
std          1.711736
min          0.500000
25%          6.000000
50%          7.300000
75%          8.200000
max         10.000000
Name: score, dtype: float64

所以看起来 score_phrase 有 11 个不同的文本值，可以很容易地转换成 11 个数字排名。分数似乎是一个数字排名系统，从 0 到 10。现在是做决定的时候了。我用分数吗？score_phrase？还是两者的混合？让我们在做决定之前获得更多的信息。

在同一个数据集中同时包含 score 和 score_phrase 列似乎很奇怪。我假设 score_phrase 可能基于 score 列中的分数，让我们来看看。下面，我将在数据帧中查找灾难的行，以查看分数列中的值。我将对 score_phrase 的所有唯一值进行同样的操作。

score_dict = {'Disaster': [],
              'Unbearable': [],
              'Painful': [],
              'Awful': [],
              'Bad': [],
              'Mediocre': [],
              'Okay': [],
              'Good': [],
              'Great': [],
              'Amazing': [],
              'Masterpiece': []}for name in score_dict.keys():
    score_dict[name] = df.loc[df.score_phrase == name].score.values
    print(name,
          score_col_dict[name].min(),
          score_col_dict[name].max())Disaster 0.5 0.8
Unbearable 1.0 1.9
Painful 2.0 2.9
Awful 3.0 3.9
Bad 4.0 4.9
Mediocre 5.0 5.9
Okay 6.0 6.9
Good 7.0 7.9
Great 8.0 8.9
Amazing 9.0 9.9
Masterpiece 10.0 10.0

为了确保万无一失，让我们用一个方框图来看看我们的结果，0 代表灾难，10 代表杰作:

看起来 score 列中的值直接影响 score_phrase 值，所以我们可以完全去掉 score_phrase 列。

现在，让我们再来看看我们的数据框架:

editors_choice 列似乎也是一个二元 yes 或 no 列。让我们把它变成 0 和 1，这样更容易处理。

df.editors_choice = df.editors_choice.astype('category')
df.editors_choice = df.editors_choice.cat.codes

Change the editors_choice column

既然我们已经做了更明显的事情，是时候做出更深思熟虑的决定了。对我们的预测有用的信息是什么？书名？虽然标题肯定很重要，但我不认为它们会影响收视率，只会影响游戏的发现。网址？这只是一个工具，让人们使用数据集来了解每一个。平台呢？你发布游戏的平台会影响你的评分吗？我会说是的。让我们把它再修剪一下。

那些年、月和日的不同列又是怎么回事呢？将它们放在一个日期时间列中会更好吗？应该如何看待站台柱的不同价值？流派呢？这些都是很好的问题，重要的是不仅要问和回答这些问题，还要问和回答更多关于数据集的问题。一旦你最终清理了所有的东西并完全理解了数据，那么也只有到那时你才应该继续。

Don’t be hasty

每个数据科学家都需要阅读这些模拟故事

原文：https://towardsdatascience.com/every-data-scientist-needs-to-read-these-simulation-stories-7be0531e782f?source=collection_archive---------18-----------------------

使用智能模拟解决的业务用例

专注于机器学习算法以使其预测模型更好的数据科学家，经常忽视通过模拟进行随机控制的力量。凭借他们对概率和统计分布的丰富知识，模拟不再是陌生的概念，可以提供更快更直观的结果。在我的经历中，有些情况下，模拟比预测模型揭示了更多可操作的见解。我奉献这篇文章来解释一些极其常见的商业情况，以及模拟是如何成为救世主的！

模拟是指由已知关系定义的系统或过程的表示。

模拟，允许我们建立一个世界的数学模型，并在计算机上运行几次。这使我们能够评估各种决策，并从中做出选择。也就是做决策。这是试图用更简单的语言来描述模拟。让我们深入研究数学和代码。当谈到统计和概率时，R 当然是我的首选语言，因此我用 R 写了所有的代码来模拟不同的过程。

1.航空公司机票超售——明智还是不明智？

航空业巨头说，达美航空公司不断面临的问题是，订了票的顾客没有出现在航班上。为了减少损失，他们倾向于超额预订一些额外的机票。例如，飞机上有 50 个座位。平均有 10%买票的人不露面。每张票的价格是 100 美元。由于超额预订，如果最后一分钟乘客不能登机，他们将获得 250 美元的补偿。应该超订多少座位才能使预期收益最大化？
解决方案在下面注释良好的代码中。56 是预定座位的最佳数量，以最大化预期利润，如代码片段下面的图表所示。

Profits with different No. of seats booked

2.在两个股票投资组合中选择

有一个概念是在给定期限内重组股票投资组合。它也有年度收益(5%)和亏损上限(30%)。假设股票的年回报率服从正态分布，均值= 3%，标准差= 5%。如果你可以选择投资另一项 10 年期传统固定 1%年回报存款，你会选择哪一项？
解决方案在下面的代码中。如图所示，几乎 77%的重组投资组合的回报率超过 1%。因此，这是一个更好的选择。

3.33 扇门。一辆车。许多山羊。留下或交换。你还记得那个游戏节目吗！！

在一个有 33 扇门的游戏节目中，一扇门后有一辆车，另一扇门后有一只山羊。你选了一扇门，主人为你打开了另一扇有山羊的门。你会换门还是留在你选择的门上？

4.像黑色星期五这样的促销活动，开放收银台的最佳数量是多少？

一年中最关键的购物日，大型零售商(如沃尔玛)必须在顾客等待时间和成本之间取得平衡。很少，他们的目的是试验不同的排队系统，以更好地了解他们的客户。比方说，总共有 20 个计数器。每个营业柜台的运营成本为 20 美元，等待超过 10 分钟的顾客会被“惹恼”,每位顾客将被罚款 1 美元。假设每个柜台都有自己的队列，到达的顾客随机加入一个队列，保持开放的最佳结账柜台数量是多少？
注:基于排队系统理论，顾客到达间隔时间和服务时间假设为无记忆分布。伽玛分布最适合它。下面是解决问题的模拟代码。正如我们所见，在这种情况下，15 个开放式收银台的成本最低。

致读者…

上面列出的业务用例是非常标准的，不需要在您的专业领域中完全复制。尽管如此，我有信心，一些修改版本的那些实例可以遇到，现在，你知道鸭汤食谱攻击他们！！

感谢阅读。如果你在任何其他的另类模式中使用过模拟的力量，请分享评论。

每个人都有权利知道地球正在发生什么:走向全球公域

原文：https://towardsdatascience.com/everybody-has-a-right-to-know-whats-happening-with-the-planet-towards-a-global-commons-5a1ad4ba0bdd?source=collection_archive---------9-----------------------

遥感、传统实地观测、数据科学和可重复研究对监测环境的关键作用

合著: 汤姆·柯林斯伊赫萨尼·惠勒罗伯特·麦克米伦**

自 2004 年以来， OpenStreetMap 一直是构建世界开放地图的主要平台。最近，通过分布式工作和共同所有权建立地理信息的概念已经产生了几个鼓舞人心的企业；比如——街头级影像平台。然而，目前 OpenStreetMap 和 mapi pile 都只关注城市和城市地区。地球的其他地方呢？制作公开的全球环境变量地图怎么样，比如土地覆盖、土地使用、气候、土壤、植被和生物多样性？一些盈利和非盈利组织已经开始这样做了，提供了绘制世界土地利用(【https://osmlanduse.org】T4)、土地覆盖(https://geo-wiki.org)、生物多样性(https://gbif.org)、森林动态(https://globalforestwatch.org)、天气(https://openweathermap.org)和地形(https://opentopography.org)等平台。这些开放的数据源很棒，但是很分散。如果将组合成一个完整和一致的“开放地图”式的世界环境系统，这样的信息会更加有效。如果实现的话，这样一个系统可以成为任何人都可以像维基百科一样自信地跟踪我们环境的现状和变化的地方。为了促成这一想法，OpenGeoHub 基金会最近推出了一款网络地图应用和一项名为“land GIS”的数据服务。

了解我们环境历史的重要性

如果我们不知道昨天发生了什么，我们怎么能判断今天呢？任何人要想了解生态系统服务及其对环境的价值，首先必须了解过去的环境状况。过去选定的某个点(在环境科学中通常称为“基线”)是最终的参考点，使我们能够量化环境退化/恢复的规模以及所涉及的潜在成本/收益。跟踪环境历史的一个典型的、被广泛认可的例子是全球年地表温度的变化状况(见图 1)。

Fig 1: Global temperature reconstruction from proxy data of Marcott et al (2013). This example indicates two major patterns: 1) mean annual temperature of the planet fluctuates systematically due to glacial and interglacial periods, and 2) the rate of increase of mean annual temperature due to human-induced CO2 emission (last 100 years) is unprecedented. Graph by: Klaus Bitterman.

如果我们关注上图中过去的几百年，我们会注意到地球可能一直在变冷而不是变暖。全球年气温的预期(【自然】)趋势与【人为引起】趋势有明显差异。在这种情况下，它是全球变暖效应，我们现在知道这主要是由于化石二氧化碳排放(化石燃料工业，交通，农业)。 Ricke 等人(2018) 估计，每增加一吨化石碳排放的社会成本(“每增加一吨二氧化碳排放所导致的与气候损害相关的全部经济成本”)平均为每排放一吨二氧化碳当量 417 美元。我们仍然在 2017 年人均排放了约 4.9 tCO2(美国为 15.7 tCO23.8 其他 G20 国家的 tCO2 根据 Olivier 和 Peters，(2018) ，这意味着 2017 年二氧化碳排放的总社会成本约为 15.4 万亿美元！即使把 Ricke et al. (2018) 估算的数字换成美国环保局使用的保守数字(40 美元)，我们也可以看到，CO2 排放具有严重的经济后果。因此，环境管理和计算环境破坏的社会成本很可能成为一项主要的经济活动(也就是说，如果我们的全球文明所运行的当前经济体系要生存下去的话)。

前面的例子说明了地表温度等物理变量如何与二氧化碳排放量的测量值相关联，然后可以根据经济成本对二氧化碳排放量进行评估。但是我们的星球有着多种多样的景观、气候带和地质材料，并且地球的这些不同部分对全球事件和过程有着不同的反应。为了更好地展示这些过程的地理分布，科学家们以不同的空间分辨率绘制了全球地图。使用这些图意味着我们不仅知道每个物理变量的平均变化的单个值，而且还知道变化最显著的地方的 T2，并且通常还知道是什么在驱动 T5(图 2a)。此外，在记录和量化全球环境动态时，科学家记录了科学上认可的特定严格变量的动态，我们可以将其称为土地管理指标(图 2b)。

Fig. 2: Difference between the historic, actual and potential values of land management indicators (a), and examples of some common environmental variables and land management indicators (b) of importance for monitoring the status of the Earth’s environment.

在这里，并不是所有的土地管理指标都同样重要。一些变量是人类生活质量的直接指标，当用于预测潜在的未来自然灾害、生态系统服务的收益或损失等时，其价值可达数十亿甚至数万亿美元(见前面的二氧化碳排放例子)。例如,《联合国防治荒漠化公约》(《荒漠化公约》)选择了以下三个土地退化关键指标:

土地覆被分类，
土地生产力，
生物量中的地上和地下碳，

保持这三项中的每一项不变，或者至少不显著恶化，是朝着土地退化中立迈出的一步。****

谈到土地管理指标，现在越来越重要的是能够【绘制过去】**【预测未来】，即制作不同时期的土地管理指标图，同时保持相同的空间参考。记录过去 10，000 年土地利用变化的完整全球数据集的一个例子是 海德数据集 ( Klein Goldewijk 等人，2011 年)，该数据集包括 10 种主要土地利用类型、人口密度和城市及农村地区覆盖率的时间序列图像，由荷兰环境署(PBL)制作和分发。人们可以很快观察到，大多数这样的历史时间序列图都有同样的问题，那就是它们对于在更远的过去发生的事件和条件的确定性相对较低。由于这个原因，海德只能在 10 公里的相对粗糙的空间分辨率下使用，随着我们回到前工业时代，空间模式的可靠性急剧下降。2019 年，我们可以以精细的空间分辨率绘制几乎所有世界森林和树冠高度的地图。但是 100 年前的森林所在的位置(更不用说 2000 年前了)就很难重建了。**

地图的空间分辨率往往定义了一个系统的大部分技术规格和地图的可用性( Hengl 和 MacMillan，2019 )。从管理的角度来看，地球的陆地可以划分为离散的空间单元或像素，理想情况下对应于地球表面的等面积块。例如， What3Words 公司(图 3)为每个 3⨉3m 像素分配了三个常用词的唯一组合(总土地面积估计为 148，939，063 平方公里，超过了 1.65⨉10^13 的唯一像素！).通过使用 with 单词，你可以与 3⨉3m 空间街区内的其他人联系。我们现在还可以将所有关键土地管理指标的值附加到每个独特的像素上，然后跟踪它们随时间的变化。这种精细的土地管理应用于农业用地时，被称为“精准农业】。正如我们将在后面的章节中看到的，在 2019 年以 1-5 米的分辨率绘制地球陆地地图当然是可行的，但也将需要大规模的计算基础设施。

Fig. 3: What3words map browser screenshot showing pixelation/discretization of the Earth’s surface.

迄今为止，我们认为需要监测的最重要的全球土地变量类型是土地覆盖、土地使用、温度、降水、蒸汽压力不足、空气传播的微粒、火灾、地上和地下生物量、气体排放、有效光合作用、动植物种类及其特征、土壤水和土壤宏观和微观动植物。这些变量类型的变化可进一步解释为得出土地管理指标，然后可用于跟踪业绩和估计潜在的财务损失或收益。通过长时间监测这些指标，并对其精确的空间分布进行建模，我们可以评估环境的各种潜在状态，预测未来状态，并使用这些信息不断改善和优化土地管理。

天空中的眼睛

如同在许多科学领域一样，减少量化土地退化方面的政治偏见或争议的一个方法是依靠强大的技术和客观的测量。自 20 世纪 60 年代以来，很明显，跟踪全球植被状况的最有效方法是使用基于卫星的遥感系统(RS)作为连续地球观测(EO)的基础。从 2008 年开始， NASA 和 USGS 制作了所有的 Landsat 影像，免费开放象征性地开启了遥感数据的新时代朱等 2019 。事实证明，国家机构开放遥感数据也能产生经济效益。朱等人(2019) 估计，仅美国用户 2011 年的生产率节约就达 17 亿美元，国际用户增加 4 亿美元，这几乎足以支付整个项目的历史费用(仅从 2011 年的利润中计算)！支持改进资源管理的应用将不可避免地导致 EO 应用呈指数级增长，这些趋势将在未来几十年保持积极(欧玛，2016)；郭氏，2018 )。开放 EO 数据对于自然保护和土地恢复项目尤为重要( Turner 等人，2014 年；吉布斯&三文鱼，2015 。近 20 年来，NASA 和 USGS 一直在维护和共享从他们的 MODIS 图像中获得的土地产品的时间序列； 哥白尼全球地勤(CGLS；由 VITO NV 主持)提供了类似的土地管理指标列表，包括植被指数、吸收的光合有效辐射(FAPAR)和干物质生产率。在最近发射了欧盟资助的哥白尼哨兵和日本宇宙航空研究开发机构(JAXA)的先进陆地观测卫星 ALOS 之后，基于 EO 的环境监测项目蓬勃发展。除了多光谱图像，德国航空航天中心(DLR) TANDEM-x 项目现在已经产生了可能是最精确的全球地表模型(包括全球森林冠层高度地图)，空间分辨率为 12 米，垂直精度前所未有( Martone et al. 2018 )。该数据集的 100 m 分辨率版本最近已免费发布，供研究和教育使用。德国航天中心的下一代地形/高程测绘将专注于更精细的分辨率(5 米)和更快的重访时间(< 1 个月)，以便我们能够越来越多地跟踪地表高程或体积位移的所有细微变化。以下三个趋势现在普遍适用于所有 EO 项目(欧玛，2016；赫罗德等人 2016 ):

空间分辨率不断提高，重访时间越来越快。
降低单位面积的收购、储存和加工成本。
更先进的技术允许穿透云层和植被(主动传感器)并提高检测材料和组织的准确性。

现在越来越难以掩盖糟糕的土地管理或空气或水污染。公开(或廉价)获得的图像的空间分辨率现在正朝着亚米级精度快速发展。在 2019 年 行星实验室 已经创建了一个图像融合系统，支持在 3 m 空间分辨率 ( Houborg 和 McCabe，2018 )下推导每日归一化差异植被指数(NDVI)和叶面积指数(LAI)。同样，one sol 公司已经从 Sentinel-2 和 LandSat7/8 图像中自动提取了农场边界和作物状态(目前仅在欧洲和美国),因此，即使是较小规模的农场及其植被指数也可以逐块进行跟踪。这些系统正从只有原始图像转变为按土地管理单位(如田地)对土地管理指标进行预处理的估计。我们预计，在未来几年，掩盖任何森林砍伐(甚至是一些树木的损失)将变得越来越困难？)、生物量损失(Landsat 7/8 和 Sentinel 2)、土壤损失、二氧化碳排放(Sentinel 5)，甚至是地球上任何地方的更小规模的废物堆(行星实验室)。我们认为这些都是好的趋势，也认为这种意识跨越国界无缝延续是好的，也就是说，它使我们有能力不分国界地识别糟糕的土地管理者或环境污染者。人们有权了解过去、现在和未来全球土地的状况。这种全球环境意识很可能是全球化最积极的方面之一。

可重复的研究是建立对地图信任的基础

在前面的章节中，我们讨论了遥感影像如何直接和客观地测量环境状况，它现在如何变得越来越容易获取，以及因此遥感数据的应用数量和整体市场如何可能呈指数增长。但大多数国家和企业都没有能力处理如此庞大的数据量，更不用说利用它们将传递的新型信息了。例如，要归档所有 LandSat 场景，你需要数 Pb 的存储空间，更不用说处理这些数据的大型基础设施了。举例来说，行星实验室声称每天获得 50 万亿像素的新数据。为了应对如此大规模的数据挑战，谷歌开发了一种云解决方案，用于处理美国宇航局、欧空局和 JAXA 的所有图像以及所有其他公开可用的图像: 谷歌地球引擎 (GEE) ( 戈雷利等人 2017 年)。几个研究小组已经使用 GEE 基础设施推导出全球森林砍伐/森林覆盖变化地图( Hansen 等人，2013 )、地表水动力学( Pekel 等人，2016 )、土地覆盖( Song 等人，2018 )和农田分布 ( Xiong 等人，2017 )，仅举几个最著名的例子。最近在遥感杂志上关于 GEE 的特刊列出了更多 GEE 的应用。

GEE 真的让本科生能够在没有任何研究预算的情况下以 30 米的分辨率绘制世界地图。GEE 是否应该成为获取、存储和分发土地管理指标的通用解决方案？听起来是个完美的选择。拥有同一原始遥感数据的多个副本肯定会效率低下。谷歌还考虑周到地支付处理成本，这(相对而言)考虑到他们的基础设施规模可能很小。但是 GEE 是有代价的。首先，向 GEE 上传和下载较大的数据集包括一个期望，即用户将需要增加他们的 Google Drive 或 Google 云存储的容量。第二个更严重的限制是谷歌的使用条款指出:

5.服务的贬值。Google 可以在任何时候因任何原因停止任何服务或任何部分或功能，而不对客户承担任何责任。

换句话说，像谷歌这样的公司可以在任何时候停止 GEE，并且在法律上不承担任何后果，因为这些是所有 GEE 用户在开始服务时已经接受的使用条款。另一个问题是:我们能信任谷歌吗？如果谷歌开发人员在他们的代码中犯了一个错误怎么办？虽然 GEE 中使用的许多算法都是基于开源软件的，但是理解在生成地球图像之前 Google 服务器上发生的事情并不容易。一个由欧盟资助的项目 OpenEO (开放地球观测)现在着眼于确保 【跨云后端再现性】 。它开发了一种语言(API)，可以用来向不同的云后端提出问题，包括 GEE。通过这种方式，它旨在使比较和验证他们的结果变得相对简单，但也找到例如进行特定类型计算的最便宜的选项。 O2R 项目 有许多关于如何备份和共享代码和数据以及以相对较低的成本实现计算再现性的实用技巧。

EO 是客观监测土地动态的基础，但并不是所有的土地管理指标都可以单独使用遥感技术直接制图。一些土地管理指标需要通过在点位置插入取样(即观察/测量)值或使用预测制图方法来估算。有些变量更复杂，不能仅使用光谱反射率来绘制。例如，还没有 EO 系统可以用来直接估算土壤有机碳(SOC)密度。这样做的技术尚不存在，因此，我们需要使用点样本和预测映射来尝试估计每个像素的 SOC。幸运的是，现在有越来越多的带有环境变量的点数据通过开放数据许可和国际倡议跨境提供。已建立的野外观测汇编包括: 全球生物多样性信息设施 观测、 全球历史气候网 站数据、 WoSIS 土壤剖面数据库 【点】、 sPlot 全球植物数据库 、鸟类，仅举几个最广为人知的例子。如今，越来越多的点数据测量和观测也是通过公民科学和众包项目贡献的，如in naturalist(图 4)Geo-wiki、 公民气象观测计划 和类似项目( Irwin，2018 )。甚至商业公司现在也开放共享他们的专有数据，并将其用于全球数据挖掘项目(当然前提是他们的用户同意)。例如，温度、压力、噪音水平等的连续测量。来自 Netatmo 气象站(估计全球售出超过 15 万台设备)。许多用户也乐于分享他们手机设备上的天气测量数据。Plantix app 目前正在制作一个植物病害和生长异常照片的全球数据库。我们在此仅提及几个主要的全球或大陆数据存储库和计划。当然，还有更多的本地语言版本的存储库。

随着地面观测和测量的全球汇编变得更大和更一致，越来越需要从中提取增值的全球地图。现在，人们越来越有兴趣使用亿亿级高性能计算来处理新兴的新型原位观测网络，以提高高分辨率天气预报、农业管理和地球系统建模的质量和成本效益。未来几年一个特别令人兴奋的发展可能是一种混合的基于过程的建模+机器学习方法，它结合了最好的数据和我们最好的地球物理/地球化学知识(赖希斯坦等人 2019 )。

Fig. 4: iNaturalist.org: a Citizen Science system. Screenshot showing geographical density and type of data (usually field photographs with description and interpretation of species names etc) contributed.

总而言之，建立数据信任的最有希望的途径似乎是实现计算的可再现性(记录所有处理步骤，并提供再现完全相同的结果所需的所有相关元数据)。现在有越来越多的健壮的方法来实现可重复性，即使对于计算量相对较大的项目也是如此。由于与新的地球观测卫星发射相关的免费遥感数据的提供越来越多，似乎主流数据分析将从本地网络转移到(虚拟)云和大地球数据立方体，即通过基于网络的工作流进行数据分析( Sudmanns et al. 2019 )。在这种情况下，地球观测站仍将是一个有价值的(希望)越来越值得信赖的地方，用来处理全球公共遥感数据，并制作新的有价值的环境状况地图。但社会也需要更开放的非营利基础设施，如 OpenStreetMap，以确保长寿。无论如何，全球实地观测资料库、公民科学和机器学习将在生成更全面的土地管理指标的更可靠地图方面发挥越来越大的作用。

OpenLandMap.org:我们对全球土地共享的贡献

我们(OpenGeoHub 基金会)最近开始提供托管和数据科学服务，通过一个我们称为“土地地理信息系统”的系统，帮助制作和共享关于多种环境措施的实际和潜在状态的最新、完整记录(可能达到完全可再现的水平)的数据集，该系统可通过https://openlandmap.org获得(图 5)。最初， LandGIS 通过一个允许交互式查询和叠加的简单网络制图界面，提供关于土壤特性/类别、地形、地质、土地覆盖/使用/退化、气候、当前和潜在植被的新数据和现有数据。这是一个真正的开放土地数据和服务系统，任何人都可以贡献和共享全球地图，并使成千上万的研究人员和企业能够访问它们。

LandGIS in action: a 6-minutes video tutorial on how to access, use and download data.

土地地理信息系统基于以下六个主要支柱:

开放数据许可证(开放数据共享开放数据库许可证和/或知识共享署名共享)将数据副本放在zenodo.org，
通过 github 库可获得大部分代码的完整记录的、可复制的程序，
基于使用开源软件实现的最新总体机器学习技术的预测，
基于使用开放地理空间联盟 (OGC)标准的数据分发:GDAL、WMS、WCS 等。
针对高流量使用优化的网络服务的多样性(云优化的地理 IFFs)，
管理、开放的用户和开发人员社区。

我们为我们自己的数据挖掘和空间预测过程的 LandGIS 结果做出了贡献，包括潜在自然植被的制图(例如 Hengl 等人 2018 )和土壤属性和类别的 3D 制图。但是，我们也托管其他人提供的地图，特别是如果数据已经过同行审查并有完整记录的话。

Fig. 5: LandGIS interface showing predicted global distribution of USDA great groups (soil types) based on a global compilation of soil profiles. Data available for download at doi: 10.5281/zenodo.1476844*.*

为了说明我们产生有用信息以改善全球土地管理的一般方法，考虑土壤类型制图的例子。美国农业部和美国地质勘探局已经投入了数十年，甚至可能是数十亿美元，主要通过土壤分类系统 【美国农业部土壤分类学】 来收集土壤数据，并生成和维护关于土壤的知识。经过几十年的实地工作和对数千份土壤样本的实验室分析，美国农业部和美国地质调查局产生了一个包含超过 350，000 份土壤类型实地观察结果的储存库(在这种情况下，我们重点关注土壤大类群)。我们将这些点数据与其他国家和国际汇编相结合，产生了世界上最一致和最完整的美国农业部土壤大群体训练数据集。然后，我们将这些点覆盖在代表土壤形成因素的约 300 个全球协变量层上，然后使用随机森林拟合空间预测模型( Hengl 等人，2017 )。尽管我们在美国以外(大多数训练点位于美国)仅实现了有限的分类准确性，但拥有足够大的训练数据集使我们能够为基本上没有训练点的国家制作土壤类型的初始地图(分辨率相对较高，为 250 m )(图 6)。因为我们有完全自动化的叠加、建模和空间预测，一旦我们获得更多关于土壤类型的观测结果，我们就可以更新这些初始预测，并逐渐制作更好、更可用/有用的地图。

Fig. 6: Example of a general workflow of how LandGIS can be used to recommend optimal soil use practices at a farm scale based on accurately predicting the soil type (in this case: USDA soil great groups*). Note we run a circular process where with each new contribution (training points) we can produce increasingly more detailed / more accurate soil maps.*

正在开发的其他 LandGIS 功能包括:

多用户:为环境活动的各种参与者提供相关和有用的功能，包括土地所有者、社区领袖、科学咨询机构、商业承包商、捐助者和投资者。
多模块:整合环境管理中的各种活动，包括项目发现、农场尽职调查、筹资、实施、自动土地管理 KPI(关键绩效指标)跟踪。
与企业 IT 和社交媒体的集成:实现增强的安全性、数据保护和互操作性特性。
基于上下文的定制和丰富:空间自动填充的用户数据(节省手动设置工作)、基于对等活动的功能、针对特定条件的基于位置的警报(例如霜冻警告、温度阈值等)。
集成“区块链”功能，支持环境令牌交易。

因此，总的来说，仍然需要一个 OpenStreetMap 类型的系统，以允许存档和共享环境变量和土地管理指标。有了 LandGIS 和 OpenLandMap.org，我们已经证明了使用“旧的遗留数据”可以立即产生新的、增值的信息。我们展示了技术和知识转移的机会(从数据丰富的国家到数据贫乏的国家)，我们认为这是一个双赢的局面。我们将用于生成 LandGIS 图层的所有代码作为开源代码发布，允许任何人完全复制最先进的空间分析，包括作为商业服务的基础。我们已经将所有数据作为开放数据发布，允许任何人，包括企业，在这些土壤和其他环境数据的基础上进行构建——希望以我们甚至无法想象的方式。**

请引用为:

托米斯拉夫·亨格尔，汤姆·柯林斯，伊奇萨尼·惠勒，罗伯特·麦克米伦。(2019 年 3 月 27 日)。每个人都有权利知道地球正在发生什么:走向全球公域。中等(走向数据科学)，http://doi.org/10.5281/zenodo.2611127

参考资料:

吉布斯，H. K .，&萨蒙，J. M. (2015)。绘制世界退化土地图。应用地理，57，12–21。https://doi.org/10.1016/j.apgeog.2014.11.024
Gorelick，m . Han cher，m . Dixon，m . Ilyushchenko，s .，Thau，d .，& Moore，R. (2017)。谷歌地球引擎:面向所有人的全球地理空间分析。环境遥感，202，18–27。https://doi.org/10.1016/j.rse.2017.06.031
Hansen，M. C .、Potapov，P. V .、Moore，r .、Hancher，m .、Turubanova，S. A. A .、Tyukavina，a .、… & Kommareddy，A. (2013 年)。21 世纪森林覆盖变化的高分辨率全球地图。科学，342(6160)，850–853。https://dx.doi.org/10.1126/science.1244693
Hengl、de Jesus、J. M .、Heuvelink、G. B .、Gonzalez、M. R .、Kilibarda、m .、Blagoti、a .、…、Guevara、M. A. (2017 年)。SoilGrids250m:基于机器学习的全球网格土壤信息。PLoS one，12(2)，e0169748。【https://doi.org/10.1371/journal.pone.0169748 号
****Hengl，Walsh，M. G .，Sanderman，j .，Wheeler，I .，Harrison，S. P .，& Prentice，I. C. (2018)。潜在自然植被的全球制图:对估计土地潜力的机器学习算法的评估。PeerJ，6，e5457。【https://doi.org/10.7717/peerj.5457 ****
t .亨格尔，麦克米伦，r . a .(2019 年)。荷兰瓦赫宁根 R. OpenGeoHub 基金会预测土壤制图，370 页，ISBN:978–0–359–30635–0。http://soilmapper.org
Herold，m .，See，l .，Tsendbazar，n .，& Fritz，S. (2016 年)。走向一体化的全球土地覆盖监测和绘图系统。遥感，8(12)。http://dx.doi.org/10.3390/rs8121036
Houborg 和 m . McCabe(2018 年)。通过 CubeSat，Landsat 和 MODIS 数据的融合在 3 m 分辨率下每日反演 NDVI 和 LAI。遥感，10(6)，890。https://doi.org/10.3390/rs10060890
欧文(2018)。不需要博士:公民科学如何改变研究？自然，562，480–482。https://doi.org/10.1038/d41586-018-07106-5
Klein Goldewijk、A. Beusen、M. de Vos 和 G. van Drecht (2011 年)。过去 12，000 年人类引起的土地利用变化的 HYDE 3.1 空间显示数据库，全球生态学和生物地理学 20(1):73–86。https://dx.doi.org/10.1111/j.1466-8238.2010.00587.x
郭(2018 年)。生态学的遥感革命。自然 556，137。https://doi.org/10.1038/d41586-018-03924-9
Marcott，S. A .，Shakun，J. D .，Clark，P. U .，& Mix，A. C. (2013)。过去 11300 年区域和全球温度的重建。科学，339(6124)，1198–1201。https://dx.doi.org/10.1126/science.1228026
Martone，m .，Rizzoli，p .，Wecklich，c .，González，c .，Bueso-Bello，J. L .，Valdo，p .，… & Moreira，A. (2018 年)。来自串联 X 干涉 SAR 数据的全球森林/非森林地图。环境遥感，205，352–373。https://doi.org/10.1016/j.rse.2017.12.002
奥利维耶、j . g . j &彼得斯、J.A.H.W. (2018)。全球二氧化碳和温室气体排放总量趋势:2018 年报告。第 3125 号报告。PBL 荷兰环境评估机构，海牙。
****纽约州欧玛市(2016 年)。用于地表成像的中高分辨率地球观测的进展:演变、未来趋势和对可持续发展的贡献。空间研究进展，57(1)，110–126。【https://doi.org/10.1016/j.asr.2015.10.038 ****
Pekel，J. F .，Cottam，a .，Gorelick，n .，& Belward，A. S. (2016)。全球地表水及其长期变化的高分辨率制图。自然，540(7633)，418。https://doi.org/10.1038/nature20584
赖希斯坦，m .，坎普斯-瓦尔斯，g .，史蒂文斯，b .，荣格，m .，登茨勒，j .，&卡瓦尔海斯，N. (2019)。数据驱动的地球系统科学的深度学习和过程理解。自然，566(7743)，195。https://doi.org/10.1038/s41586-019-0912-1
里克，k .，德鲁埃，l .，卡尔代拉，k .，塔沃尼，M. (2018)。国家层面的碳社会成本。自然气候变化，8(10)，895。https://doi.org/10.1038/s41558-018-0282-y
Song，X. P .，Hansen，M. C .，Stehman，S. V .，Potapov，P. V .，Tyukavina，a .，Vermote，E. F .，& Townshend，J. R. (2018)。1982-2016 年全球土地变化。自然，560(7720)，639。https://doi.org/10.1038/s41586-018-0411-9
Sudmanns，m .，Tiede，d .，Lang，s .，Bergstedt，h .，Trost，g .，Augustin，h .，…，T. (2019)。大地球数据:地球观测数据管理和分析的颠覆性变化？。国际数字地球杂志，1–19。https://doi.org/10.1080/17538947.2019.1585976
Turner，w .，Rondinini，c .，Pettorelli，n .，Mora，b .，Leidner，A. K .，Szantoi，z .，… & Koh，L. P. (2015 年)。免费和开放的卫星数据是保护生物多样性的关键。生物保护，182，173–176。https://doi.org/10.1016/j.biocon.2014.11.048
熊，j .，Thenkabail，P. S .，Gumma，M. K .，Teluguntla，p .，Poehnelt，j .，Congalton，R. G .，… & Thau，D. (2017)。使用谷歌地球引擎云计算的非洲大陆自动农田制图。摄影测量与遥感杂志，126，225–244。https://doi.org/10.1016/j.isprsjprs.2017.01.019
****Zhu，z .，Wulder，M. A .，Roy，D. P .，C. E .，Hansen，M. C .，Radeloff，V. C .，… & Pekel，J. F. (2019)。免费和开放的陆地卫星数据政策的好处。环境遥感，224，382–385。【https://doi.org/10.1016/j.rse.2019.02.016 ****

每个人都想成为一只猫

原文：https://towardsdatascience.com/everybody-wants-to-be-a-cat-6dd6190c5d9c?source=collection_archive---------31-----------------------

fast.ai《程序员实用深度学习》第六课

我正在学习 fast.ai 的杰瑞米·霍华德和雷切尔·托马斯的“程序员实用深度学习”课程，并在博客上记录我的经历。由于非常慷慨的 fast.ai 社区已经为每一课做了详细的笔记(参见第六课的笔记这里)，我只是写下讲座的部分内容，并附上我需要停下来思考几次的 Jupyter 笔记本。

我需要回顾的第一个主题出现在关于数据扩充的仿射变换的讨论中。“仿射”又是什么意思？与线性有关。我咨询了谷歌，找到了很多解释，都非常清晰，但是数学堆栈交换的这个对我来说很有用:线性函数只是缩放，但是仿射函数缩放并移位。

第六课剩下的大部分时间，我都在理解卷积。杰里米说，文件中的所有图片都是关于猫的，因为西尔万·古格喜欢猫，而且他写了大部分文件(尽管西尔万说他不喜欢猫，事实上，只是把它们放在文件中以吸引人们阅读文件，这很有趣)。

因此，让我们探索回旋，并保持与暴躁猫(RIP)猫的主题。

Jeremy 使用 Bret Victor 的图像内核动画来说明卷积运算是如何工作的。给定一个矩阵，其元素表示图像的像素，卷积采用该矩阵的一个元素，并使用如下所示的 3 x 3 矩阵(通常为正方形)对所选元素/像素周围的元素值进行逐元素矩阵乘法，该像素位于矩阵的中心。如果像素靠近图像的边缘，我们可能需要“填充”矩阵，如 Francesco Visin 的动画所示。最后，我们将所有的乘积相加得到一个值(所以用线性代数术语来说，我们只是在做点积)。

使用下面显示的带有“锐化”内核的 Grumpy Cat 图像，我们看到内核将通过将其乘以 5 来强烈强调它“正在看”的像素(中心的像素)，同时通过将其乘以 0 或-1 来削弱其周围的像素，从而增加它们之间的对比度。

类似地，使用“模糊”内核，我们看到该内核将相关像素的值降低到 0.25，但将周围像素的值降低得更多，这降低了整体对比度。

有时候，当学习一些东西时，可能会觉得“是的，所有这些都很有道理，我完全明白了，”然后你试图解释它，并意识到你实际上对你刚才听到的几乎一无所知。停下来向别人解释你刚学到的一个概念，即使那个人是虚构的(或者一个博客；) )，是一种高效确定自己是否真正理解的方法！

这一刻对我来说是其中之一:我们正在通过一系列卷积运行张量，每个卷积都减少了高度和宽度，但增加了输出通道的数量，当我们完成时，我们得到了下图所示的张量。

https://www.youtube.com/watch?v=U7c-nYXrKD4&feature=youtu.be&t=5630

512 感觉有点正常，是 2 的幂，但是为什么我们在 11 停下来，特别是对于其他两个维度？

我几乎没有写出来，因为为了弄清楚，我只是看了视频，看了几十遍笔记，最后，我觉得我没有什么要补充的。但为了理解它，我不得不按照与视频/笔记中显示的不同的顺序为自己写下它，所以这里是那篇文章，以防它对其他人有所帮助。

所以让我们后退。我们从表示图像的张量开始，该张量有 3 个通道(红色、蓝色和绿色)，高度为 352 像素，宽度为 352 像素。这是张量的形状:

我们有很多图像，这么多这样的张量，但是 PyTorch 希望我们使用每个图像的小批量，所以正如 Jeremy 所说的，我们可以用特殊值None索引到数组中，这创建了一个新的单位轴，给我们一个形状为[1, 3, 352, 352]的秩为 4 的张量。这是一个小批量的 1 图像，它有 3 个通道，高 352 像素，宽 352 像素。我必须不断检查的一件事是，shape 函数在高度和宽度之前返回通道，但当我们将张量视为多维矩阵时，我们将维度列为高度 x 宽度 x 通道数。所以在矩阵术语中，上面的张量的维数是 352 x 352 x 3(记住 1 不是矩阵的维数；就是小批量的大小)。

然后我们通过一系列的激活来运行张量，从一个 2 维卷积Conv2d开始，使用大小为 2 的步幅。这意味着它不是“看”矩阵的每个元素，而是“看”所有其他元素，“跳过”其中的一半。这就是导致高度和宽度减半，输出通道数量翻倍的原因。

因此，当我们通过第一个卷积层运行张量时，我们获得一个 352 x 352 x 3 的维度矩阵，并通过 64 个步长为 2 的卷积(或内核)运行它，我们得到一个(352 / 2) x (352 / 2) x 64 的维度矩阵；也就是说，它是 176 x 176 x 64，或者用 PyTorch 形状来表示，如下所示:

然后，我们运行张量通过两个以上的层:BatchNorm2d和ReLU，它们不会改变形状，然后池层MaxPool2d，它会改变形状为 88 x 88 x 64。我发现杰森·布朗利的对卷积神经网络池层的温和介绍对理解池层如何工作非常有帮助。

我们不断地对这些层进行多次检查，时不时地，我们将高度和宽度各除以 2，并将内核的数量加倍。因此，在某一点上，我们有 44 x 44 x 256，然后是 22 x 22 x 512，最后是我们想知道的 11 x 11 x 512 矩阵。

所以我认为我们在高度和宽度上停留在 11，仅仅是因为 11 是一个奇数！如果我们将 11 除以 2，我们会得到 5.5，这对于矩阵来说不是一个合适的维数。感觉上我花在追逐张量上的时间和答案的简单性不成比例。尽管如此，我对立体体操的理解肯定比以前好得多，所以我想这很了不起！

在 GitHub 上的 pets 笔记本中查看完整代码，下周第 7 课再见！

关于此主题的其他帖子:

第一课:fast . ai 入门

第 2 课:对妊娠试验结果进行分类

第二课(续):深度学习能比鸽子表现更好吗？

第三课:一万种行不通的方法

第四课:预测服务员的小费

第五课:但是泡菜去哪里了？

我是加州大学东湾分校的数学讲师，也是一名有抱负的数据科学家。在 LinkedIn 上和我联系，或者在 Twitter 上和我打招呼。

日常生活和微观预测

原文：https://towardsdatascience.com/everyday-life-and-microprediction-f76c1721872a?source=collection_archive---------29-----------------------

Photo by @chengfengrecord

具有人工智能的 B2C 预测和安全工具

作为个体，我们有权利使用人工智能来尝试预测日常生活中的行为吗？举个例子，你应该能够预测雇佣特定保姆的风险吗？2018 年，Predictim 发布了一项服务，承诺通过扫描他们在网络、社交媒体和在线犯罪数据库上的存在来审查可能的保姆。可以说是个人使用的 AI 安全。

Predictim 提供了一种新的创新方法，使用人工智能和替代数据来即时审查人们。

可以说，Predictim 没有获得任何形式的巨额投资(种子期 10 万美元)。然后在 2018 年末，推特和脸书宣布 Predictim 已经被禁止。乔尔·西蒙诺夫和萨尔·帕萨似乎没有采取进一步的行动来创办一家新公司。事实上，在社交媒体跟踪的好名字或坏名字中，我现在看到 Joel Simonoff 是 NASA 的机器学习研究员。

什么是好的，什么是不好的？

然而，初创公司的兴衰提出了一个有趣的问题，即我们如何使用技术来预测并根据这些预测采取行动。在 Predictim 中，有一个明显的内在种族主义的例子。人工智能对尊重和态度的扫描，对家庭领域的伦理如此缺乏理解，似乎是一种明显的侵犯。什么是好的，什么是不好的？

我们似乎仍然认为，公司收集我们在家里的行为的预测信息是没问题的，只要他们用雄辩的声音说话，或者如果你在网上找到了你想要的答案。我们的 fitbit(测量健康信息)、手机(情境感知、位置信息)和社交媒体(心理特征、偏好)也是如此。

这些具有更大框架的预测工具肯定会有与保姆应用一样糟糕或更糟糕的偏差，但我们也许可以在另一个时间讨论这个问题。

微观预测

你可能听说过微观管理:这是一种管理风格，管理者通过这种方式密切观察和/或控制和/或提醒他/她的下属或员工的工作。然而，它可以在工作环境之外的关系中引用。

大声说出微观预测，我或多或少把它作为一个的讨论点。预测并不是什么新鲜事，在某种程度上，你可以说它是让我们与众不同的一部分:

“象征性抽象思维 : 很简单，这是我们思考不在物理上存在的物体、原理、观念的能力。它赋予我们复杂语言的能力。这是由较低的喉头(比所有其他动物允许更广泛的声音)和复杂语言的大脑结构支持的

多么美妙的象征性抽象思维，然而它回避了这样一个问题，即预测什么或不预测什么是否有一个限度。甚至可能会有关于如何预测的问题，或者更有可能是法律，因为伦理考虑会转化为监管。事实上，预言在各种科学中的支配地位可以追溯到很久以前，许多提到的王子被尼可罗·马基亚维利作为早期的例子估计早在1513 年就已经被分发。使用定量信息并收集这些信息以更好地做出决策的想法。

在这种预测背景下保护权利的最近例子是欧盟通用数据保护条例 (GDPR)和 FDA 考虑监管医疗保健中的机器学习。

机器学习 (ML)是对算法和统计模型的科学研究，计算机系统使用这些算法和统计模型来有效地执行特定任务，而不使用明确的指令，而是依靠模式和推理。

没有明确的指导方针，似乎对什么可以做什么不可以做有一个模糊的认识。人类学家 Marilyn Strathern 写了一篇更早的文章，名为《T2:未来的亲属关系和文化研究》(1995 年)。其中她谈到了我们对什么是人工或非人工的概念，提到了它是如何随着时间的推移而变化的。这种人工或技巧并不是一成不变的，被认为是自然的变化。

为什么要做微预测？

微观管理通常被认为有负面的含义，主要是因为它显示了工作场所缺乏自由。微预测作为一个话题可能需要进一步讨论，我还没有定义它，因为我还不知道如何以一种好的方式使用它。然而，为了激发更多的兴趣，我想用 Predictim 关于伦理学的评论来结束我的文章:

“我们非常重视道德和偏见，”Predictim 的首席执行官萨尔·帕萨(Sal Parsa)在电话中小心翼翼地告诉我。“事实上，在过去的 18 个月里，我们训练了我们的产品、我们的机器、我们的算法，以确保它是合乎道德的，没有偏见。我们把敏感的属性，受保护的职业，性别，种族，从我们的训练集中去掉。我们持续审计我们的模型。除此之外，我们还增加了人工审核流程。”

Brian Merchant 于 2018 年 6 月 12 日在 Gizmodo 撰文

这听起来耳熟吗？如果是，谁有权侵犯或使用用户数据？

我不确定我是否会支持根据这一标准对保姆进行扫描，但我会支持保险公司或信用评分吗？

基于狭义的人工智能技术结合社交媒体或其他来源等非传统数据的信用评分可能是一个有趣的领域，可以继续监测，因为新公司正在涌现，并以可能令人不安的新方式应用机器学习。

偏见:对一个人或一群人的倾向或偏见，尤其是以一种被认为不公平的方式。在人类学领域，我们讨论种族中心主义:根据源于自身文化标准和习俗的先入之见来评价其他文化。

我们如何使用技术或谴责技术的使用是令人着迷的。

我一定会进一步探讨这个问题。

这是#500daysofAI 的第 22 天，希望你喜欢。

–

什么是#500daysofAI？

我在挑战自己，用#500daysofAI 写下并思考未来 500 天的人工智能话题。这是我发明的一个挑战，让自己一直思考这个话题，分享我的想法。

这是受电影《夏日 500 天》的启发，主角试图找出爱情失败的原因，并在此过程中重新发现他生活中真正的激情。

数据科学领域的每个人都有冒名顶替综合症，不管怎样，做一个领导者吧

原文：https://towardsdatascience.com/everyone-in-data-science-has-impostor-syndrome-be-a-leader-anyway-6ca4a3397c6a?source=collection_archive---------15-----------------------

作为一名领导者，我如何利用我的冒名顶替综合症来提升自己。

Photo by Jessica Rockowitz on Unsplash

“永远不要拿自己和别人比较。只拿今天的你和前一天的你做比较。”
― 未知作者

我和一位前雇员就她目前的职位进行了一次随意的交谈。我们拐弯抹角地谈到了领导力。当她告诉我，我是我们组织中最好的领导者时，她说有一些好的领导者，但我是她所知道的唯一一个“伟大的领导者”,这几乎是漫画家的双重转折。

我立刻想到了两个想法。首先，这是令人难以置信的谦逊和善良。第二，她错了——或者至少，她不可能是诚实的。

正是这种第二种想法经常在我们的脑海中出现。我们给它起了个名字叫“冒名顶替综合症”,因为它让我们觉得好像我们只是在假装别人对我们的期望，或者在我们身上看到的东西。我们相信任何时候我们都会被发现我们的欺诈行为。

这篇文章不是关于冒名顶替综合症的背景，它来自哪里，是什么原因造成的，如何治愈它——因为已经有太多关于这方面的文章了。

我想说的是，作为领导者，我们需要如何做好自己的工作，而不让冒名顶替综合症破坏我们的工作。根据我的经验，这不一定会使人虚弱，实际上可以积极地引导。

我的经历和其他人的经历很相似。如果我花些时间想想我在哪里，我经常觉得我随时都会被“发现”,每个人都会意识到我不适合我的工作或职位。在某些时候，我开始怀疑自己的想法。

最近尤其如此，因为我发现自己在领导一个数据科学团队，同时学习编码和机器学习的基础知识。然而，我自己的情况是一个很好的提醒，因为我看到了许多新的(和经验丰富的)数据科学家的自我怀疑和非理性的内疚，他们将自己比作神话中的独角兽。悄悄感叹他们不懂足够的编码，或者不够高级的统计，或者他们的数据可视化不都是四维的，交互的！

“我有什么资格做这些决定？!"“当我没有正确的答案，或者更有可能的是，当我给出错误的答案时，那些指望我的人会怎么样？”或者“他们意识到错误地把这件事托付给我只是时间问题。”

随着这些疑虑的蔓延，它们会导致焦虑，有时甚至是恐惧，这取决于情况的严重性。如果你对此耿耿于怀，它会给你的生活带来巨大的破坏，扼杀你成为一名有效领导者的能力。

两个回答

为什么？因为如果你屈服于对能力不足的恐惧，它会有两种结果。第一个反应是，你变得越来越关心自己的名声，变得“足够聪明”，有“正确的答案”，并且需要被咨询或负责做每一个决定。

这对一个团队和一个组织来说可能是毒药。我最不喜欢的表现方式是我所说的“信息囤积”。在信息囤积中，人们认为他们的权力与他们所知道的或他们对组织中重要信息的控制紧密相关。这可能看起来像人们不愿意分享他们的代码(或为他们为什么做出某些决定辩护)，在其他领域，他们似乎不合理地捍卫他们的分析结论，而没有充分解释他们的方法。

他们最终试图控制谁知道什么，这可能是非常有害的。作为一名领导者，他们不会培训或授权员工，因为他们担心员工知道的会比他们多。作为同事，他们不值得信任，因为他们没有准确地告诉你他们在组织中的位置。

在这两种情况下，他们对组织的损害都超过了他们的信息所增加的价值。通常，他们认为他们的有用性和声誉的关键是依赖于这些信息。这种洞察力清楚地表明了真正发生了什么:自我怀疑和不安全感。

第二个回答显然更加积极。同样对知识差距的恐惧会让你发现你需要在团队中学习更多的领域。它可以促使你花更多的时间与团队交谈，在你试图更多地了解他们的工作时，问一些关于他们工作的深刻问题。或者你可以寻求外部学习，这必然会给团队带来外部视角和价值。

这种反应来自相同的情绪冲动，但是你决定以不同的方式采取行动是将它引向积极方向的关键。

决策

冒名顶替综合症的另一个方面是，你可能对做出一些你需要做出的决定没有信心。很好。一旦你身居要职，你应该感受到某些决定的分量。你应该反思自己对它们的直觉反应。随着你越来越远离组织的一线工作，这一点变得越来越真实。

再次强调，认识到这一点，但要克服这种不适。这就是为什么你在这个位置上…不是因为你知道所有的答案，而是因为别人不需要代替你做决定。

你的冒名顶替综合症也可以成为你的盟友。不要假装知道正确答案，而是依靠那些知道的人。这些人通常就是给你带来决策的人。

针对选择提出针对性的后续问题。询问选择的利弊。问问他们有什么推荐。问他们还有谁会有相反的意见。答案通常就在这段对话的某个地方。

以此为基础，从你的角度来看组织。然后做决定。你不会总是对的。但在许多情况下，一个最终错误的答案也比一个从未给出的答案要好。(另外，你从这些错误中学到了很多！)

恐惧不一定会让人瘫痪。关于冒名顶替综合症的文章、书籍和社交媒体帖子层出不穷，好的一面是，似乎每个人都不时会经历这种情况。

用它来加强你的自我意识

我喜欢冒名顶替综合症的另一个原因是，它驱使我每天都表现出最好的一面。当我担心自己不够好时，我会决定每天都努力变得更好。

为此，我为自己设定了具体的目标。它们看起来很小，但即使是朝着它们努力的行为，也能让你的态度从冒名顶替综合症的负面后果中恢复过来。我的清单很简单:

每天向我的团队学习一件事。
努力认识到自己的错误并从中吸取教训。
到处寻找我如何成为更好的领导者的正面和负面例子。

帮助我实现这些目标的一个策略是每天睡前写日记，检查我做得不够好的地方，或者遇到做了我想做的事情的人。如果我没有时间写日记，即使花十分钟向自己讲述一天的经历并强调一些重要的方面也会有所帮助。

在这些情况下，如果你试着从别人的角度而不是从你自己的角度来思考这些情况，这将有助于你打破自己只顾自己的叙述，尝试更客观地看待你的行为如何影响他人。

此外，每天我都会在我需要学习的数据科学技能清单上增加一个小项目。然后，我要么在业余时间找一个项目来做，要么在午休时间找一个小的练习会，在那里我可以把它分解成简单的步骤来帮助我更好地理解我的团队在做什么。

是对被发现的恐惧促使我变得更好。因为不是我的家人，社交媒体上的陌生人，或者我的故事的读者导致了我不够好的焦虑。是我团队中的人，那些指望我做好我的工作并在他们工作时给他们目的、方向、机会和感激的人。

我认为这是关键…引导你的冒名顶替综合症，让你变得比昨天更好。接受冒名顶替综合症强加的谦逊这一课，随时向团队中的任何人开放学习。

因为任何人都不可能开始学习他认为自己已经知道的东西——爱比克泰德《论文集》第二卷

每个人都需要自己的聊天机器人

原文：https://towardsdatascience.com/everyone-needs-their-own-chatbot-72cb210c0161?source=collection_archive---------17-----------------------

个人聊天机器人将成为“第二个你”，当你不能或不愿意在线时，可以方便地管理你的在线状态

Friends Helping GIF By Pyx Health

聊天机器人自 1964 年就已经出现了，但直到 2016 年，当脸书向它们开放其 Messenger 平台时，聊天机器人才成为我们生活的数字世界中无处不在的一部分。

聊天机器人有几个名字，包括“数字对话”、“虚拟助手”和“互动人物”，但它们的功能是模拟计算机程序和人类用户之间的真实对话。它们的交互性、“真实”感和动态响应性使它们非常受欢迎。目前，据估计，仅在 Facebook Messenger 上就有超过 30 万个聊天机器人，仅在 2018 年就与约 14 亿人互动。

与只驻留在一个给定 URL(互联网地址)的网站不同，聊天机器人被设计为“生活”在多个平台上。例如，同一个聊天机器人可以同时存在于一个专用的 Facebook Messenger 频道和一个网站的弹出窗口中。在脸书于 2016 年向聊天机器人开放其 Messenger 平台后，几乎所有其他受欢迎的消息应用程序也这样做了，包括 Skype、Whatsapp、Kik、Twitter、Viber 和微信。

聊天机器人及其近亲语音助手也可以通过亚马逊广受欢迎的“智能扬声器”系列以及谷歌的家用设备和安卓手机和平板电脑访问。大多数人都熟悉语音助手，如 Siri、Alexa 和 Cortana，但这些都依赖于数十亿美元的人工智能引擎来执行功能。大多数语音助手“聊天机器人”在范围上要简单得多，例如猎犬，它允许你呼叫优步或访问你在 NPR 上的个性化新闻提要；莱拉，它允许你免提访问你的日历或你的音乐播放列表之一；以及 Butleroy ，它可以帮助你智能地响应会议和日程安排请求。

Bbva Dudas GIF

脸书——聊天机器人的栖息地

凭借早期的领先优势，脸书仍然是聊天机器人最受欢迎的“家”，包括“基于按钮的”和语音激活的聊天机器人。目前，大多数聊天机器人都服务于商业目的，据估计，到 2020 年，80%的企业将使用聊天机器人。即使是传统上最慢采用新技术的银行，也有望在 2020 年通过聊天机器人提供服务。然而，目前聊天机器人的主要业务用例是用于营销目的，如线索生成、线索资格和销售渠道，或者用于提供客户服务，特别是回答常见问题和提供基本信息，如您企业的地址、电话号码和营业时间。

脸书强烈鼓励使用聊天机器人。脸书的广告部门允许你购买直接点击聊天机器人的广告。考虑到聊天机器人的转换率明显高于电子邮件或直接营销等传统媒体，难怪如此多的企业采用聊天机器人。聊天机器人也可以用于电子商务目的，允许用户直接从聊天机器人内部购买物品。在美国等国家，至少有三分之一的成年人表示愿意直接从聊天机器人那里购买商品，而且这个数字预计还会增长。

除了直接在脸书的 Messenger 应用上运行，脸书还允许聊天机器人直接在脸书页面上“直播”。这使得企业无论在哪里都能联系到他们的客户，无论是通过 Messenger 应用程序直接一对一，还是在企业的脸书页面上留下评论。在过去的两年里，脸书已经显著升级了聊天机器人提供这种多通道响应的能力，赋予聊天机器人更大的权力和范围。由于聊天机器人一年 365 天，一天 24 小时工作，它们“永远在线”,无论何时何地在线，都能联系到客户。

但是，虽然聊天机器人被设计成可以在脸书上无缝运行，但底层代码实际上并不存在于脸书的平台上。要让一个聊天机器人在脸书上运行，你要么需要主持并自己编写代码，要么使用流行的聊天机器人框架，提供诸如 Chatfuel 或 Manychat 之类的服务。这些平台专为不知道如何编码或只是想避免编写代码所需的费用和时间的聊天机器人构建者设计，每个人都可以快速轻松地创建聊天机器人。

Chat Conversation GIF By Madebydot

运行聊天机器人

Chatfuel 成立于 2015 年，最初设计用于 Telegram(当时唯一允许聊天机器人的消息应用程序)，现在只为脸书聊天机器人提供支持。通过一个直观的拖放式构建系统，任何人都可以创建一个聊天机器人，并在几分钟内将其安装并运行在脸书上。Chatfuel 提供了一个免费层，允许您的 chatbot 与多达 5，000 名用户进行交互，在需要升级到付费订阅计划之前，可以充分发挥其所有功能。Chatfuel、Manychat、Mobile Monkey 和他们的数百个竞争对手提供免费模板，你可以很容易地修改这些模板以满足你的需求。

对于懂一点编码的聊天机器人创建者来说，更强大的聊天机器人框架存在，其中最受欢迎的是谷歌的 DialogFlow ，IBM 的 Watson ，以及微软的 Bot 框架。虽然缺点是它们需要更多的技术知识来启动和运行聊天机器人，但这些框架通常允许更多的集成或能够将同一个聊天机器人插入许多渠道，包括社交消息应用程序、网站、移动应用程序内部，甚至通过 Twilio 等手机短信服务。

无论是像 Chatfuel 这样的拖放界面，还是像 DialogFlow 这样的动手编码框架，聊天机器人都依赖于一种叫做 API 的东西，以便提供更丰富、更动态的体验。API 是一种允许在不同网站或互联网服务之间交换信息的协议。例如，一个推荐附近餐馆的聊天机器人可能会使用谷歌地图的 API 来查找您当前位置附近的餐馆，并与 Yelp 的 API 进行交叉索引，以找到该地区排名最高的餐馆。由于 API 请求必须精确编码才能工作，这使得大多数高级聊天机器人对于大多数人来说过于复杂。

Ryan Seslow GIF

聊天机器人不仅用于商业

但是聊天机器人不仅仅是简单的商业应用。一些最受欢迎的聊天机器人提供服务，如提供定制的天气预报或玩游戏，如问答游戏。聊天机器人最有趣的新兴用途之一是充当个人化身。聊天机器人的未来不是作为企业的“代言人”或可以玩游戏或提供信息的匿名服务，而是作为个人的替身。

一家利用这一新趋势的公司是 AIBRO。虽然目前只有测试版，但 AIBRO 计划为个人用户提供创建无代码聊天机器人的能力，以作为他们的个人化身。想象一下，有一个聊天机器人知道你的朋友、家人和同事之间的区别，并且能够根据你自己独特的输入同时与他们进行智能对话。

Introducing AIBRO, personal chatbot creation system

与手机拥有量激增同时出现的是一种被称为或“害怕错过”的现象因为总有一些有趣的事情在某个地方发生，不可能有一个人能够跟上，导致 FOMO 对某些事情的焦虑。现在，无论人们在哪里，都可以一天 24 小时联系到 T4，同样，许多人也希望总是得到回应。此外，人们被期望回复来自任何人的所有信息，不管它们的优先级如何。

AIBRO 的使命是让个人能够不必担心 FOMO，同时也能够在最方便的时候回复消息。此外，由于并非所有消息都具有相同的优先级，即一些消息可能被视为垃圾邮件、低优先级消息或来自您现在不想回复的人的消息，因此 AIBRO 的聊天机器人将允许个人自动回复这些消息，同时过滤掉需要单独处理的优先级较高的消息。换句话说，AIBRO 的聊天机器人将允许你自动回复你讨厌的叔叔或垃圾邮件业务，敦促你注册他们的服务，同时让你手动回复更高优先级的事情，如来自你母亲的消息或当前的爱情兴趣。

Enviar Dinero Bizum GIF

个人聊天机器人:下一步是什么？

在不久的将来，很可能每个人都将拥有一个可以智能回复信息的个人聊天机器人。对于潜在的雇主来说，个人聊天机器人可以回复用户的简历(CV)，并回答有关用户经验和技能水平的问题。对于家庭成员和亲密朋友，个人聊天机器人将能够回复状态更新。个人聊天机器人将能够过滤掉垃圾短信或任何被认为是令人讨厌的东西，这些东西还没有达到完全屏蔽或静音的水平。个人聊天机器人将成为“第二个你”，当你不能或不愿意在线时，它可以让你高效方便地管理你的在线状态。

尽管聊天机器人在各种网络媒体上越来越受欢迎，但它的未来才刚刚开始。人们可以想象这样一个世界，你自己的个人聊天机器人不仅可以与商业聊天机器人互动，还可以与其他人的个人聊天机器人互动。聊天机器人将有助于了解你的个人偏好，为你带来精确定制的新闻和信息，并让你更容易与其他人交流。简而言之，聊天机器人将很快帮助你减少总是在线的需求，给你带来你想要的准确信息(包括个人信息)——以及你想要的时间。在短短的几年内，问题将不再是你是否有一个私人聊天机器人，而是你如何在没有聊天机器人的情况下生活。

数据科学家应该了解的关于数据管理的一切*

原文：https://towardsdatascience.com/everything-a-data-scientist-should-know-about-data-management-6877788c6a42?source=collection_archive---------0-----------------------

(*但不敢问)

NIST Big Data Taxonomy (Source: WikiCommons)

由黄家仪 & 罗伯特·贝内特

要成为一名真正的“”数据科学家，或者许多博客作者和雇主所说的“独角兽”，你必须掌握数据科学过程的每一步——从存储数据到将成品(通常是预测模型)投入生产。但大部分数据科学培训侧重于机器/深度学习技术；数据管理知识通常被认为是事后的想法。数据科学学生通常通过存储在笔记本电脑上的文本文件中经过处理和清理的数据来学习建模技能，而忽略了数据香肠是如何制作的。学生们通常没有意识到，在行业环境中，从各种来源获取原始数据为建模做准备通常是 80%的工作。由于企业项目通常涉及大量数据，而他们的本地机器无法处理这些数据，因此整个建模过程通常发生在云中，大部分应用程序和数据库托管在其他地方数据中心的服务器上。即使学生找到了一份数据科学家的工作，数据管理也常常成为一个独立的数据工程团队负责的事情。因此，太多的数据科学家对数据存储和基础设施知之甚少，这往往会损害他们在工作中做出正确决策的能力。本文的目标是提供一个路线图，说明 2019 年的数据科学家应该了解的数据管理知识——从数据库类型、数据存储和处理的位置和方式，到当前的商业选项——以便有抱负的“独角兽”可以自己更深入地探索，或者至少学到足够的知识，以便在面试和鸡尾酒会上听起来像一个独角兽。

非结构化数据和大数据工具的兴起

IBM 305 RAMAC (Source: WikiCommons)

数据科学的故事实际上是数据存储的故事。在前数字时代，数据存储在我们的头脑中、泥板上或纸上，这使得汇总和分析数据极其耗时。1956 年，IBM 推出了第一台带磁性硬盘的商用计算机， 305 RAMAC 。整个装置需要 30 英尺 x 50 英尺的物理空间，重量超过 1 吨，公司可以以每月 3200 美元的价格租赁该装置，存储高达 5 MB 的数据。自那以来的 60 年里，DRAM的每千兆字节价格从 1965 年的 26.4 亿美元降至 2017 年的 4.9 美元。除了价格大幅降低之外，数据存储也变得更密集/更小。305 RAMAC 中的磁盘每平方英寸存储 100 位，相比之下，今天典型的磁盘每平方英寸存储超过 1 万亿位。

数据存储成本和规模的大幅降低使当今的大数据分析成为可能。凭借超低的存储成本，构建数据科学基础架构以从海量数据中收集和提取见解成为企业的一种有利可图的方法。随着不断生成和传输用户数据的物联网设备的大量出现，企业正在收集越来越多的活动数据，从而创造出大量高容量、高速度和高多样性的信息资产(或大数据的“三个 v”)。这些活动中的大多数(例如，电子邮件、视频、音频、聊天消息、社交媒体帖子)都会产生非结构化数据，这些数据几乎占当今企业数据总量的 80%,并且在过去十年中其增长速度是结构化数据的两倍。

125 Exabytes of enterprise data was stored in 2017; 80% was unstructured data. (Source: Credit Suisse)

这种大规模数据增长极大地改变了数据存储和分析的方式，因为传统的工具和方法无法应对“大数据的三个 v”新技术的发展能够以更快的速度和更低的成本处理不断增长的数据量和数据种类。这些新工具还对数据科学家的工作方式产生了深远的影响，使他们能够通过执行分析和构建以前不可能实现的新应用程序来利用海量数据。以下是我们认为每个数据科学家都应该了解的主要大数据管理创新。

关系数据库& NoSQL

关系数据库管理系统 (RDBMS)出现于 20 世纪 70 年代，将数据存储为具有行和列的表格，使用结构化查询语言(SQL)语句来查询和维护数据库。关系数据库基本上是表的集合，每个表都有一个严格定义它们存储的数据的属性和类型的模式，以及标识特定列或行以便于访问的键。RDBMS 曾经被甲骨文和 IBM 统治，但是今天许多开源选项，像 MySQL 、 SQLite 和 PostgreSQL 一样流行。

RDBMS ranked by popularity (Source: DB-Engines)

由于一些非常吸引人的特性，关系数据库在商业世界中找到了一个家。数据完整性在关系数据库中是绝对重要的。RDBMS 满足了原子性、一致性、隔离性和持久性(或 ACID 兼容)的要求，它通过施加许多约束来确保存储的数据是可靠和准确的，这使它们成为跟踪和存储诸如帐号、订单和支付等事物的理想选择。但是这些限制伴随着代价高昂的权衡。由于模式和类型的限制，RDBMS 在存储非结构化或半结构化数据方面非常糟糕。僵化的模式也使得 RDBMS 的建立、维护和发展更加昂贵。建立一个 RDBMS 需要用户事先有具体的用例；对模式的任何改变通常都是困难且耗时的。此外，传统的 RDBMS 被设计成在单个计算机节点上运行，这意味着当处理大量数据时，它们的速度要慢得多。分割 RDBMS 以便在保持 ACID 合规性的同时进行水平扩展也极具挑战性。所有这些属性使得传统的 RDBMS 不适合处理现代大数据。

到 2000 年代中期，现有的 RDBMS 不再能够处理一些非常成功的在线业务的不断变化的需求和指数级增长，因此开发了许多非关系型(或 NoSQL)数据库(下面是一个关于脸书在数据量开始增长时如何处理 MySQL 的局限性的故事)。当时没有任何已知的解决方案，这些在线企业发明了新的方法和工具来处理他们收集的大量非结构化数据:谷歌创建了 GFS 、 MapReduce 和BigTable；亚马逊创造了dynamo db；雅虎创造了Hadoop；脸书创造了卡珊德拉和蜂巢；LinkedIn 创造了卡夫卡。这些企业中的一些开源他们的工作；一些发表了研究论文，详细介绍了他们的设计，导致了数据库与新技术的扩散，NoSQL 数据库成为行业中的主要参与者。

An explosion of database options since the 2000’s. Source: Korflatis et. al (2016)

NoSQL 数据库与模式无关，并提供存储和操作大量非结构化和半结构化数据所需的灵活性。用户不需要知道在设置期间将存储什么类型的数据，并且系统可以适应数据类型和模式的变化。NoSQL 数据库旨在将数据分布在不同的节点上，通常具有更好的水平伸缩性和容错性。然而，这些性能优势也是有代价的——NoSQL 数据库不符合 ACID 标准，并且不能保证数据的一致性。相反，它们提供“最终一致性”:当旧数据被覆盖时，它们会返回暂时有点错误的结果。例如，谷歌的搜索引擎索引不能在人们同时搜索给定术语时覆盖其数据，因此当我们搜索时，它不会给我们最新的结果，但它会给我们最新的、最好的答案。虽然这种设置在数据一致性绝对必要的情况下(比如金融交易)是行不通的；对于需要速度而不是精确的任务来说，这很好。

现在有几种不同种类的 NoSQL，每一种都有特定的用途。键值存储，如 Redis 、 DynamoDB 和 Cosmos DB ，只存储键值对，并提供检索与已知键相关的值的基本功能。当速度很重要时，它们最适合简单的数据库模式。宽列存储，如 Cassandra 、 Scylla 和 HBase ，将数据存储在列族或表中，用于管理大型分布式系统中数 Pb 的数据。文档存储，如 MongoDB 和 Couchbase ，以 XML 或 JSON 格式存储数据，以文档名为键，以文档内容为值。这些文档可以包含许多不同的值类型，并且可以嵌套，这使得它们特别适合跨分布式系统管理半结构化数据。图形数据库，如 Neo4J 和 Amazon Neptune ，将数据表示为相关节点或对象的网络，以便于数据可视化和图形分析。图形数据库对于分析异构数据点之间的关系特别有用，比如在欺诈预防或脸书的朋友图中。

MongoDB 是目前最受欢迎的 NoSQL 数据库，它为那些一直在努力用传统 RDBMS 方法处理非结构化数据的企业带来了巨大的价值。下面是的两个行业例子:大都会人寿花费数年试图在 RDBMS 上建立一个可以处理其所有保险产品的中央客户数据库后，内部黑客马拉松的某人在几小时内用 MongoDB 建立了一个，并在 90 天内投入生产。市场研究公司 YouGov 每小时收集 5g 数据，通过从 RDBMS 迁移到 MongoDB，节省了 70%的存储容量。

数据仓库，数据湖，&数据沼泽

随着数据源的不断增长，使用多个数据库执行数据分析变得效率低下且成本高昂。20 世纪 80 年代的出现了一种叫做数据仓库的解决方案，它将企业所有数据库中的数据集中起来。数据仓库通过创建来自不同来源(内部和外部)的单一数据存储库，支持数据从运营系统流向分析/决策系统。在大多数情况下，数据仓库是一种关系数据库，它存储经过处理的数据，这些数据是为收集业务洞察力而优化的。它收集来自事务系统和业务应用程序的具有预定结构和模式的数据，这些数据通常用于运营报告和分析。

但是，由于进入数据仓库的数据需要在存储之前进行处理，对于今天的大量非结构化数据，这可能需要大量的时间和资源。作为回应，企业开始在维护数据湖2010 年的，这些数据湖存储了企业任何规模的所有结构化和非结构化数据。数据湖存储原始数据，无需首先定义数据结构和模式就可以建立数据湖。数据湖允许用户运行分析，而不必将数据移动到单独的分析系统，使企业能够从以前无法进行分析的新数据源中获得洞察力，例如通过使用来自日志文件、点击流、社交媒体和物联网设备的数据构建机器学习模型。通过使所有企业数据随时可供分析，数据科学家可以回答一系列新的业务问题，或者用新数据解决旧问题。

Data Warehouse and Data Lake Comparisons (Source: AWS)

数据湖体系结构的一个常见挑战是，如果没有适当的数据质量和治理框架，当数 TB 的结构化和非结构化数据流入数据湖时，对其内容进行分类通常会变得极其困难。数据湖可能会变成数据沼泽，因为存储的数据变得太乱而无法使用。许多组织现在呼吁更多的数据治理和元数据管理实践，以防止数据沼泽的形成。

分布式&并行处理:Hadoop、Spark、& MPP

虽然存储和计算需求在过去几十年中飞速增长，但传统硬件并没有跟上发展的步伐。企业数据不再适合标准存储，处理大多数大数据分析任务所需的计算能力可能需要几周、几个月，或者根本不可能在标准计算机上完成。为了克服这一缺陷，许多新技术发展到包括多台计算机协同工作，将数据库分布到数千台商用服务器上。当一个计算机网络被连接并一起工作来完成相同的任务时，这些计算机就形成了一个集群。一个集群可以被认为是一台单独的计算机，但是它可以显著地提高性能、可用性和可伸缩性，而不是一台更强大的机器，并且通过使用商用硬件来降低成本。 Apache Hadoop 是分布式数据基础设施的一个例子，它利用集群来存储和处理大量数据，并支持数据湖架构。

Evolution of database technologies (Source: Business Analytic 3.0)

当你想到 Hadoop 时，想想“分发”Hadoop 由三个主要组件组成:Hadoop 分布式文件系统(HDFS)，一种跨多个(分布式)物理硬盘存储和跟踪你的数据的方式；MapReduce，一个跨分布式处理器处理数据的框架；还有另一个资源协商器(YARN)，它是一个集群管理框架，协调诸如 CPU 使用、内存和网络带宽在分布式计算机之间的分配。Hadoop 的处理层是一项特别值得注意的创新: MapReduce 是一种两步计算方法，用于以可靠、容错的方式处理分布在大型商用硬件集群中的大型(多 TB 或更大)数据集。第一步是将您的数据分布在多台计算机上(Map ),每台计算机对其数据片并行执行一次计算。下一步是以成对的方式组合这些结果(Reduce)。谷歌在 2004 年发表了一篇关于 MapReduce 的论文，这篇论文被雅虎程序员采用，他们于 2006 年在开源的 Apache 环境中实现了这篇论文，为每个企业提供了使用商用硬件存储前所未有的海量数据的能力。尽管这一想法有许多开源实现，但谷歌品牌名称 MapReduce 仍然存在，有点像 Jacuzzi 或 Kleenex。

Hadoop 是为迭代计算而构建的，在单次操作中从磁盘扫描大量数据，将处理分布在多个节点上，并将结果存储回磁盘。在传统数据仓库环境中需要 4 个小时运行的查询 zettabytes 的索引数据，使用 Hadoop 和 HBase 可以在 10-12 秒内完成。Hadoop 通常用于生成复杂的分析模型或大容量数据存储应用，如回顾性和预测性分析；机器学习和模式匹配；客户细分和流失分析；和活动档案。

但是 MapReduce 批量处理数据，因此不适合处理实时数据。阿帕奇 Spark 于 2012 年建造，以填补这一空白。Spark 是一个并行数据处理工具，它通过处理内存中的数据来优化速度和效率。它在相同的 MapReduce 原理下运行，但通过在内存中完成大部分计算，并且仅在内存满或计算完成时写入磁盘，运行速度要快得多。这种内存计算允许 Spark“在内存中运行程序的速度比 Hadoop MapReduce 快 100 倍，在磁盘上快 10 倍。”然而，当数据集如此之大以至于RAM 不足成为一个问题(通常数百 GB 或更多)时，Hadoop MapReduce 可能会优于 Spark。Spark 还拥有一套广泛的数据分析库，涵盖了广泛的功能: Spark SQL 用于 SQL 和结构化数据； MLib 用于机器学习， Spark Streaming 用于流处理， GraphX 用于图形分析。由于 Spark 的重点是计算，它没有自带存储系统，而是运行在各种存储系统上，如亚马逊 S3、Azure 存储、Hadoop 的 HDFS 和 T21。

In an MPP system, all the nodes are interconnected and data could be exchanged across the network (Source: IBM)

Hadoop 和 Spark 并不是唯一利用集群处理大量数据的技术。另一种流行的分布式查询处理计算方法叫做大规模并行处理(MPP) 。与 MapReduce 类似，MPP 将数据处理分布在多个节点上，这些节点并行处理数据以获得更快的速度。但与 Hadoop 不同，MPP 用于 RDBMS，并利用了一种“无共享”架构 —每个节点都用多核处理器处理自己的数据片，这使得它们比传统的 RDBMS 快很多倍。一些 MPP 数据库，如 Pivotal Greenplum ，有成熟的机器学习库，允许数据库内分析。然而，与传统的 RDBMS 一样，大多数 MPP 数据库不支持非结构化数据，即使是结构化数据也需要一些处理来适应 MPP 基础设施；因此，为 MPP 数据库建立数据管道需要额外的时间和资源。由于 MPP 数据库符合 ACID 标准，并且速度比传统 RDBMS 快得多，因此它们通常用于高端企业数据仓库解决方案，如 Amazon Redshift、Pivotal Greenplum 和 Snowflake 。举一个行业例子，纽约证券交易所每天接收 4 到 5tb 的数据，并进行复杂的分析、市场监控、容量规划和监控。该公司一直在使用无法处理工作负载的传统数据库，加载该数据库需要数小时，并且查询速度很慢。迁移到 MPP 数据库后，他们的日常分析运行时间减少了 8 个小时。

云服务

另一项彻底改变企业大数据分析能力的创新是云服务的兴起。在云服务出现之前的糟糕日子里，企业必须从软件和硬件供应商那里购买内部数据存储和分析解决方案，通常需要支付前期永久软件许可费以及每年的硬件维护和服务费。除此之外，还有用于构建和维护内部基础架构的电力、冷却、安全、灾难保护、IT 员工等成本。即使存储和处理大数据在技术上是可能的，但大多数企业发现大规模存储和处理大数据的成本过高。使用内部基础架构进行扩展还需要大量的设计和采购流程，这需要很长的实施时间，并且需要大量的前期资金。因此，许多潜在的有价值的数据收集和分析的可能性被忽略了。

“As a Service” providers: e.g. Infrastructure as a Service (IaaS) and Storage as a Service (STaaS) (Source: IMELGRAT.ME)

当云服务在 2000 年代末推出时，内部部署模式开始迅速失去市场份额——在过去十年中，全球云服务市场每年增长 15%。云服务平台提供对各种服务(从虚拟计算到存储基础设施再到数据库)的订阅，通过互联网以现收现付的方式交付，为客户提供对灵活、低成本存储和虚拟计算资源的快速访问。云服务提供商负责所有硬件和软件的购买和维护，通常拥有庞大的服务器和支持人员网络来提供可靠的服务。许多企业发现，他们可以利用云服务显著降低成本和提高运营效率，并且能够利用现成的云资源及其内置的可扩展性更快地开发和生产产品。通过消除构建内部基础设施的前期成本和时间投入，云服务还降低了采用大数据工具的门槛，并有效地为中小型企业普及了大数据分析。

有几种云服务模式，公共云是最常见的。在公共云中，所有硬件、软件和其他支持基础设施都归云服务提供商所有和管理。客户与其他“云租户”共享云基础设施，并通过 web 浏览器访问他们的服务。一个私有云通常由具有特殊安全需求的组织使用，如政府机构和金融机构。在私有云中，服务和基础架构仅由一个组织专用，并在私有网络上维护。私有云可以是内部的，也可以由其他地方的第三方服务提供商托管。混合云将私有云与公共云结合起来，让组织能够获得两者的优势。在混合云中，数据和应用程序可以在私有云和公共云之间移动，以获得更大的灵活性:例如，公共云可以用于高容量、低安全性的数据，而私有云可以用于敏感的关键业务数据，如财务报告。多云模式涉及多个云平台，每个平台提供一个特定的应用服务。为了实现组织的目标，多云可以是公共云、私有云和混合云的组合。组织通常选择云计算来满足其特定的业务、位置和时间需求，并避免供应商锁定。

案例研究:为推荐应用初创公司构建端到端数据科学基础设施

Machine learning packages for different types of data environment (Source: Kosyakov (2016))

构建一个可行的数据科学产品不仅仅是用 scikit-learn 构建一个机器学习模型，酸洗它，并将其加载到服务器上。它需要了解企业生态系统的所有部分如何协同工作，首先是数据从哪里/如何流入数据团队，数据处理/转换的环境，企业可视化/呈现数据的约定，以及模型输出如何转换为其他一些企业应用程序的输入。主要目标包括建立一个易于维护的过程；其中模型可以被迭代并且性能是可再现的；模型的输出可以很容易地被其他涉众理解和可视化，以便他们可以做出更明智的商业决策。实现这些目标需要选择正确的工具，以及了解业内其他人在做什么和最佳实践。

让我们用一个场景来说明:假设你刚刚被一家度假推荐应用初创公司聘为首席数据科学家，该公司预计每天从用户那里收集数百千兆字节的结构化(客户资料、温度、价格和交易记录)和非结构化(客户的帖子/评论和图像文件)数据。您的预测模型将需要每周用新数据重新训练，并根据需要即时提出建议。既然你希望你的应用能大获成功，那么你的数据收集、存储和分析能力就必须是高度可扩展的。你将如何设计你的数据科学过程和生产你的模型？完成工作需要哪些工具？因为这是一家初创公司，而你是首席——也许是唯一的——数据科学家，所以这些决策就由你来做。

首先，您必须弄清楚如何建立数据管道，从数据源接收原始数据，处理数据，并将处理后的数据提供给数据库。理想的数据管道具有较低的事件延迟(能够在收集数据后立即查询数据)；可扩展性(能够随着产品的扩展处理大量数据)；交互式查询(支持批处理查询和较小的交互式查询，允许数据科学家探索表和模式)；版本控制(在不关闭管道和丢失数据的情况下对管道进行更改的能力)；监控(当数据停止进入时，管道应该生成警报)；和测试(不间断地测试管道的能力)。也许最重要的是，它最好不要干扰日常业务运营——例如，如果您正在测试的新模型导致您的运营数据库陷入停顿，就会有人被解雇。构建和维护数据管道通常是数据工程师的责任(有关更多详细信息，本文对为初创公司构建数据管道进行了出色的概述)，但数据科学家至少应该熟悉该过程、其局限性以及访问已处理数据进行分析所需的工具。

接下来，您必须决定是建立内部基础设施还是使用云服务。对于初创公司来说，当务之急是在不增加运营资源的情况下扩展数据收集。如前所述，内部基础设施需要巨大的前期和维护成本，因此云服务往往是初创公司的更好选择。云服务允许根据需求进行扩展，并且只需要最少的维护工作，因此您的小型员工团队可以专注于产品和分析，而不是基础架构管理。

Examples of vendors that provide Hadoop-based solutions (Source: WikiCommons)

为了选择云服务提供商，您必须首先建立分析所需的数据，以及最适合这些数据类型的数据库和分析基础架构。由于在您的分析管道中既有结构化数据又有非结构化数据，您可能希望建立一个数据仓库和一个数据湖。数据科学家需要考虑的一件重要事情是，存储层是否支持构建模型所需的大数据工具，以及数据库是否提供有效的数据库内分析。例如，一些 ML 库(如 Spark 的 MLlib)不能有效地与作为数据主要接口的数据库一起使用——数据必须在操作之前从数据库中卸载，随着数据量的增长，这可能会非常耗时，并且当您必须定期重新训练您的模型时，这可能会成为一个瓶颈(从而导致另一个“头重脚轻”的情况)。

对于云中的数据科学，大多数云提供商都在努力开发自己的本机机器学习能力，使数据科学家能够利用存储在自己平台上的数据轻松构建和部署机器学习模型(亚马逊有 SageMaker ，谷歌有 BigQuery ML ，微软有 Azure Machine Learning )。但是这些工具集仍在开发中，并且经常不完整:例如， BigQuery ML 目前只支持线性回归、二元和多类逻辑回归、K-means 聚类和 TensorFlow 模型导入。如果您决定使用这些工具，您必须彻底测试它们的能力，以确保它们做您需要它们做的事情。

选择云提供商时要考虑的另一个主要问题是供应商锁定。如果您选择专有的云数据库解决方案，您很可能无法访问本地环境中的软件或数据，并且转换供应商需要迁移到不同的数据库，这可能成本高昂。解决这个问题的一个方法是选择支持开源技术的厂商(这里是网飞解释他们为什么使用开源软件)。使用开源技术的另一个优势是，它们往往会吸引更大的用户群体，这意味着您可以更容易地雇佣有经验和技能的人在您的基础设施中工作。解决这个问题的另一种方法是选择第三方供应商(如 Pivotal Greenplum 和 Snowflake )，它们使用其他主要的云提供商作为存储后端来提供云数据库解决方案，这也允许您在多个云中存储数据，如果这符合您的创业公司的需求。

最后，既然你希望公司发展壮大，你就必须实施一个强大的云管理实践来保护你的云并防止数据丢失和泄露——比如管理数据访问和保护接口和 API。您还需要实施数据治理最佳实践来维护数据质量，并确保您的数据湖不会变成数据沼泽。

如您所见，企业数据科学项目中有比调整机器学习模型中的超参数更多的东西！我们希望这种高层次的概述已经让您兴奋地学习更多关于数据管理的知识，并可能学到一些东西来打动饮水机旁的数据工程师。

免责声明:本文表达的观点是我们自己的观点，不代表我们过去或现在雇主的观点。

关于 Javascript 对象的一切

原文：https://towardsdatascience.com/everything-about-javascript-object-part-1-854025d71fea?source=collection_archive---------12-----------------------

Object in Javascript

近JavaScript 中的一切都是除了之外的对象六个是不是对象是——***null***、***undefined***、、字符串、、数字、、布尔、、符号、。这些被称为原始值或原始类型。****

任何不是原始值的东西都是一个对象。这包括数组、函数、构造函数和对象本身。

是啊！函数和数组也是对象，我们将在本文后面看到。

目标

从概念上讲，对象在所有编程语言中都是一样的，也就是说，它们代表了我们希望在程序中用特征/属性和方法来表示的真实世界的事物。

例如，如果你的对象是一个学生，那么它将拥有姓名、年龄、地址、id 等属性和updateAddress、updateName等方法。

在 JavaScript 中，把一个对象想象成一个包含条目的列表，列表中的每个条目(一个属性或一个方法)都由一个键值对存储在内存中作为引用。

让我们看一个对象示例。

const firstObj = {
  1: "deepak",
  "age": 28
}

firstObj是一个有 2 个属性 1，年龄和值为deepak和28的对象。

JavaScript 对象在创建方式上有些不同。对class本身没有要求，可以使用文字符号来声明。

对象创建

在 javascript 中，我们可以用多种方式创建对象，让我们来看看每一种方式。

Object literal(D \直接方式)。对象文字是用大括号括起来的逗号分隔的键值对列表。对象文字属性值可以是任何数据类型，包括数组文字、函数、嵌套对象文字或原始数据类型。

var student = {
  id: 1,
  name: "deepak",
  age: "27",
  updateAddress: () => {
   // logic to update address
  },
  grade: ['A', 'A+', 'A']
}

注意:上面的学生对象键可以通过点符号访问，即student.id、student.name或通过方括号符号访问，即student[‘id’]、student[‘name’]等

2.Object.create()。方法使用旧对象的指定原型和属性创建新对象。

注意:每个 JavaScript 函数默认都有一个prototype对象属性(默认为空)。方法或属性可以附加到此属性。

// syntax - Object.create(prototype[, propertiesObject])
var newStudent = Object.create(student); 
// this create a new object with old object added in its prototype // chain

下面是对象__proto__的输出

Object in Javascript

我们现在可以使用我们在这里学习的方法向newStudent对象添加新的属性和数据。

注意:newStudent将可以访问父student对象的键和值，因为它已经被添加到了newStudent原型链中，这是我们在 javascript 中进行继承的一种方式。也就是说，*newStudent*会存储一个到*student*对象的链接。当读取一个属性时，这个父对象也被参考。

父级可以有父级，依此类推。重复这一过程，直到我们到达一个没有任何父对象的对象，即父对象是null。

3.Object Instance。结合使用Object构造函数和"new"关键字允许我们初始化新的对象。

让我们看一个例子

const newObj = new Object();
newObj.name = ‘Deepak’;
newObj.location = ‘Delhi, India’;

然而，上述使用new Object()的方法不太适合需要创建多个同类对象的程序，因为这将涉及为每个此类对象重复编写上述代码行。

为了处理这个问题，我们可以使用下一种方法

4.Object construtor。当我们需要一种方法来创建一个可以多次使用的对象“类型”而不必每次都重新定义对象时，构造函数会很有用，这可以通过使用对象构造函数来实现。

让我们看一个例子

function Vehicle(name, model) { 
   this.name = name; 
   this.model = model; 
} 

let car1 = new Vehicle('Fiesta', '2019'); 
let car2 = new Vehicle('DC avanti', '2018');

我们创建了两个属性相同但值不同的对象。

5。 Object.assign()。这是从其他对象创建新对象的另一种方法。

注意:我们将在下一部分讨论可枚举/所有权，所以请原谅我。

它将所有可枚举的自身属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。让我们通过一个例子来理解:

var obj = { a: 1 };
var copy = Object.assign({}, obj);
console.log(copy); // { a: 1 }

Object.assign()有很多用例，比如对象克隆、合并对象等。

6。 Object.fromEntries() 。M 方法将一个键值对列表转换成一个对象。让我们看一个例子

const entries = new Map([
  ['foo', 'bar'],
  ['baz', 42]
]);const obj = Object.fromEntries(entries);console.log(obj);
// expected output: Object { foo: "bar", baz: 42 }

注意:创建对象的最好方法是通过文字符号，因为它在源代码中占用较少的空间。对于正在发生的事情，这是显而易见的，所以使用new Object()，您实际上只是输入了更多内容，并且(理论上，如果没有被 JavaScript 引擎优化)执行了一个不必要的函数调用。此外，文字符号在同一行代码中创建对象并分配属性，这与其他符号不同。

如何添加/更新和删除对象的属性

如前所述，对象的属性可通过点或括号符号添加。让我们看一个例子

const a = {};
a.name = 'deepak';
a['city'] = 'delhi';
a[1] = 'dope';

这里，name和city是对象属性。

一个对象只能包含一个具有一个值的键。我们不能让一个键有两个不同的值。

属性名可以是字符串、数字、特殊字符或动态属性，但如果属性名不是字符串，则必须用括号符号来访问。因此，如果我们需要访问上面例子中的属性*1*，我们可以执行*a[1]*，但是*a.1*将返回一个语法错误。然而，属性情况，即*a.name*或*a["name"]*将会起作用。

a.first name = 'deepak' // will return syntax error
a['first name'] = 'deepak' // will work

要更新一个属性，我们可以再次使用上述两种符号类型。如果我们向已经创建的属性添加值，那么该值将被更新或创建。

a.city = 'new york';

上面将城市值从delhi更新为new york。

我们也可以通过像**Object.defineProperties()** 或 **Object.defineProperty()**这样的Object函数方法来创建和更新对象的属性

Object.defineProperties(a, {
  pincode: {
    value: 10012,
    writable: true
  },
  property2: {}
});console.log(a.pincode); // 10012

要删除一个对象的属性，我们可以使用delete关键字，我们可以同时使用这两种符号。

delete a['city'];
delete a.city;

如果成功删除属性，返回值delete为true。要不然就是false。

你知道不允许属性更新或删除的方法吗？如果是，请在下面评论。如果不是，请不要担心，我会带着更多的问题深入下一篇文章。

如何迭代对象属性？

实际编码时会有这样的情况，我们想要访问所有的对象键值对。

使用循环——for in 和 for of 循环

对于中的 for，它遍历一个对象并逐个返回属性。

for (const key in a) {
   console.log(key, a[key]);
}

Key 将一个接一个地拥有所有属性，a[key]将返回值。For in 循环也迭代原型链，并且也将返回父键，所以如果您看到更多的键，请不要感到惊讶。为了避免看到更多的键，我们可以做一个hasOwnProperty检查，只获取当前对象的键。

在的 for 的情况下，在可迭代对象上迭代。更多阅读请点击这里。

对象函数中有各种方法帮助访问对象属性和值，而不是原型链。

**Object.keys()** 或 **Object.getOwnPropertyNames()** 。返回一个字符串键数组。

const keys = Object.keys(a) 
// return ["name", "first name", "city", "1"];const newKeys = Object.getOwnPropertyNames(a);
// return ["name", "first name", "city", "1"];keys.map(key => console.log(a[key])); 
// return ["deepak", "deepak", "new york", "dope"];

2。 **Object.values()** 。返回一个数值数组。

const keys = Object.values(a);// return ["deepak", "deepak", "new york", "dope"]

3。 **Object.entries()** 。返回一个由[key, value]对组成的数组。

const data = Object.entries(a);// returns 
[ ["1", "dope"], ["name", "deepak"], ["first name", "deepak"], ["city", "new york"]]

从上面我们可以看出，一个物体的属性出现的顺序并不是固定的。

如何检查对象中的属性存在

有三种方法可以检查对象中是否存在该属性。

使用 **hasOwnProperty**。此方法返回一个布尔值，该值指示对象是否将指定的属性作为自己的属性，而不是父/继承属性。

console.log(a.hasOwnProperty(1)); // return true;
console.log(a.hasOwnProperty('1')); // return false;const b = Object.create(a); // this will add a as parent of b
console.log(b.hasOwnProperty(1)); // return false

注意:*hasOwnProperty*返回 true，即使属性的值是*null*或*undefined*。

如果我们在一个对象中使用hasOwnProperty作为属性名会怎么样？在下面评论你的想法。

2。在操作符中使用—**in**操作符返回true如果指定的属性在指定的对象或其原型链中，即在其父对象中。

console.log(1 in a); // return true;
console.log('1' in a); // return false;const b = Object.create(a); // this will add a as parent of b
console.log(b.hasOwnProperty(1)); // return true

注意:*hasOwnProperty* 只检查当前对象属性，而 *in* 运算符检查当前+父属性

3.使用定制的功能

通过自定义方法检查属性是否存在有多种方法。其中一个是通过Object.keys获得的 eg。

Object.keys(a).indexOf(1) !== -1 // return true

在你的自定义方法下面写下注释来做同样的事情😃。

什么是按引用复制/共享和按值复制，它如何应用于对象？

不同之处在于，通过值，我们的意思是每次创建新的内存分配，而在引用的情况下，我们指向已经创建的内存空间。

在 javascript 的上下文中，所有的原始数据类型都是通过值方法分配内存的，对于一个对象来说，根据实现的不同，它可以通过值或引用进行复制。

// pass by value
let a = 5; 
let b = a;a = 6;
console.log(b) // return 5 as each time a new memory is allocated// pass by reference
const a = {x: 1};
const b = a; a.x = 3;
console.log(b.x) // it returns 3 as its a shared memory between a and b

什么是对象的浅层和深层复制/克隆？

浅层拷贝和深层拷贝的核心区别在于如何将属性复制到新对象中。

在浅拷贝中，新对象与旧对象共享数据，即在上述示例中，使用=创建a对象的浅拷贝b。所以按引用传递在大多数情况下是浅层拷贝。

此外，浅层副本将复制顶级属性，但嵌套对象在原始对象(源)和副本对象(目标)之间共享。

浅层复制的另一种方法是使用Object.assign(),这将在开始部分讨论。让我们看看这个例子

let obj = {
  a: 1,
  b: {
    c: 2,
  },
}let newObj = Object.assign({}, obj);
console.log(newObj); // { a: 1, b: { c: 2} }

obj.a = 10;
console.log(obj); // { a: 10, b: { c: 2} }
console.log(newObj); // { a: 1, b: { c: 2} }newObj.b.c = 30;
console.log(obj); // { a: 10, b: { c: 30} }
console.log(newObj); // { a: 20, b: { c: 30} }

正如我们在上面的obj.b.c = 30中看到的，这是Object.assign()的一个缺陷。Object.assign只做浅仿。newObj.b和obj.b共享对该对象的相同引用，因为没有制作单独的副本，而是复制了对该对象的引用。

在深度复制中，新对象将拥有自己的一组键-值对(与原始对象具有相同的值)，而不是共享。

让我们来看看做深度复制的一些方法

JSON.parse(JSON.stringify(object))

let obj = { 
  a: 1,
  b: { 
    c: 2,
  },
}

let newObj = JSON.parse(JSON.stringify(obj));

obj.b.c = 20;
console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 2 } } (New Object!)

上面的问题是我们不能复制值为undefined或Symbol的用户定义的对象函数或键。

let obj = { 
  a: 1,
  b: { 
    c: 2,
  },
  d: () => {}
}

let newObj = JSON.parse(JSON.stringify(obj));

console.log(newObj); // { a: 1, b: { c: 2 } } (New Object!)

此外，这种方法不适用于圆形对象。

注意:圆形对象是具有引用自身的属性的对象。

let obj = { 
  a: 'a',
  b: { 
    c: 'c',
    d: 'd',
  },
}

obj.c = obj.b;
obj.e = obj.a;
obj.b.c = obj.c;
obj.b.d = obj.b;
obj.b.e = obj.b.c;

let newObj = JSON.parse(JSON.stringify(obj));

console.log(newObj);

上面会抛出一个错误说converting circular structure to JSON.

2。使用 ES6 扩展运算符—

let obj = {
  one: 1,
  two: 2,
  nested: {
    three: 3
  },
}

let newObj = { ...obj }; 
console.log(newObj); // { one:1, two:2, nested: {three: 3}} 
(New Object!)

不过nested还是被浅浅的抄了。

如何比较两个物体？

对象的相等操作符==和严格相等操作符===的工作方式完全相同，即只有当两个对象共享相同的内存引用时，它们才相等。

例如，如果两个变量引用同一个对象，则它们相等:

*const a = {};
const b = a;console.log(b == a); // return trueconst c = {};
console.log(c == a); //return false*

如果您想加入我的电子邮件列表，请考虑在这里输入您的电子邮件地址和关注我的medium阅读更多关于 javascript 和Github的文章，查看我的疯狂代码。如果有什么不清楚或者你想指出什么，请在下面评论。

Javascript 执行上下文和提升
Javascript —生成器-产出/下一个&异步-等待🤔
理解 Javascript‘this’关键字(上下文)。
Javascript 数据结构与映射、归约、过滤
Javascript- Currying VS 部分应用
Javascript ES6 —可迭代程序和迭代器
Javascript —代理
Javascript —作用域

如果你喜欢这篇文章，请随意分享，以帮助他人找到它！

谢谢！

把你的深度学习模型训练到一个 web app 之后的一切。

原文：https://towardsdatascience.com/everything-from-your-deep-learning-model-to-a-web-app-279cd733f3d4?source=collection_archive---------10-----------------------

使用流行的 web 框架 Flask + Heroku 是一个云平台，可以帮助您轻松部署。

Frameworks For Deploying Any Model.

数据科学项目的一个常规生命周期是从一个用例开始，从我们想要解决的问题类型所需的所有来源中提取数据，分析数据并执行一些功能工程，构建一个统计模型以对未来数据进行良好的概括，并部署到生产和监控中，通常用于执行措施，并在需要时使用新数据重新训练模型。

但是，大多数时候，人们最终会停留在建立统计模型的阶段，他们不会将他们的模型放到互联网上进行真实世界的测试，因为 像前端和后端开发 这样的新技术技能需要学习将模型部署到网络中。

当然，有一些简单的方法可以做到这一点，这将使我们的工作变得更简单，即使你应该知道一些基本知识，甚至不到你第一次部署的 20%。在这篇文章中，您将学习如何做一个部署部分表单基础。

在开始这篇文章之前，让我用我用 flask 和 Heroku 构建的项目激励你们，欢迎你们来演示。

[## 作物:植物病害标识符

想知道你的植物感染了什么类型的疾病，然后上传一张(番茄、土豆)植物的图片并进入…

cropify.herokuapp.com](https://cropify.herokuapp.com/)

你将从这篇文章中学到什么。

训练后将模型权重保存到磁盘。
部署需要哪些技能？
设置和安装烧瓶。
下载一个不错的 html5 前端模板。
写代码上传到 Github。
部署到赫罗库。

1.保存模型权重。

大多数人都知道这一步，通常称之为序列化。在训练了一些问题解决用例的模型之后。每个人通常保存他们的整个模型(架构+权重+优化器状态),或者只保存他们选择的 python 或 API 库(Pickle，Keras)的权重，以防止再次训练模型。有一件事你应该知道，如果你想只保存重量，你需要在加载前将它的架构作为一个 JSON 或 YAML 文件，否则它会显示一个错误“只读模式”。

假设您已经完成了训练，并希望在几天后预测某个对象的省时模型将是一个好主意，因为无需再次训练，您可以简单地加载重量并进行预测。

2.部署所需的技能类型。

2.1 Web 框架。

你应该知道 web 框架的一些基础知识互联网上有很多可供选择的框架，如 Angular.js、Node.js 和 ASP.net，PHP 许多框架，但数据科学家也喜欢 python 和 R(经常用于统计分析),我们也可以使用最流行的 web 框架如 Django 和 Flask 用 python 编写 web 应用程序。

Flask 和 Django 是构建 web 应用的两个选择。

Flask vs Django.

当然，Flask 是一个轻量级的、完全灵活的 WSGI，易于学习和实现，但只用于小型和大型项目，但经常用于小型项目，每个人都喜欢它的简化版本。您只需 5 行代码就可以启动您的 web 应用程序。

Django 是一个每个人都喜欢的全栈框架，通常用于开发大型应用程序。几乎你可以做很多事情，但当你习惯它时，需要时间。它涉及一些相互关联的概念。所以，你需要在写代码之前学习这些。

结论: Flask 和 Django 有一些相似的概念。从 flask 开始它涵盖了基础知识，并且熟悉了一些概念，比如(模板和渲染)。通过 flask 开发了一些应用程序之后，你可以向 Django 过渡了。

2.2 HTML+CSS+Java Script 的一些基础知识。

是啊，前端和后端开发但是我们不会为 UI 部分和后台操作写太多代码。如果你不想让你的 web 应用程序有好的用户界面，这是完全可选的，在这种情况下，你不会太多地处理这种标记和样式，对于一个具有完全响应和异常处理的好看的网站，你需要学习一些概念。但是，相信我，会很简单的。我们只是从 bootstrap 网站或 html5 网站下载一个好看的模板。

只要对代码做一些修改，你就可以用你所有的东西创建并运行一个漂亮的网站。在几节之后，我们将在下面看到这一部分。

3.设置和安装烧瓶。

要安装 Flask，您需要 pip 或 conda(如果您已经安装)。在安装 flask 之前，你需要为你的 flask 项目创建一个虚拟环境，因为不会与库冲突。我们只使用我们的项目所需的任何库及其首选版本。因此，创建一个虚拟 env 将非常有用。

Pip install Flask

安装完成后，通过在终端中导入 jupyter notebook(或)中的 flask 库来检查它是否安装正确。

4.为你的项目获得一个好的 UI 模板。

您可能希望在 UI 中展示您的专业项目。然后你需要做一个前端的部分。幸运的是，我们在互联网上可以获得所有现成的代码下面列出的一些代码是完全免费的。

[## HTML5 以上

由@ajlkn 设计并在 Creative Commons 许可下发布的响应式 HTML5 和 CSS3 站点模板。

html5up.net](https://html5up.net/) [## 由引导团队构建和策划的引导主题。

Bootstrap Themes 是由 Bootstrap 的创建者策划的最好的模板和主题的集合。我们收集的…

themes.getbootstrap.com](https://themes.getbootstrap.com/)

Twitter Bootstrap 是一个使用 CSS 和 Javascript / jQuery 的工具包。这是一个前端框架，所有内置的 CSS 类，你只需要导入一个，它会为你的网站做所有的样式。您可以在没有太多 CSS 知识的情况下开始工作。它还创建了一个响应迅速的网站。当然你得懂 HTML(建站基础)。

选择一个最适合你的项目 UI 的模板，删除模板中你觉得没用的部分。

5.开始写代码。

首先，我将解释我正在部署的一个 web 应用程序的使用案例，该应用程序将有助于检测植物的疾病(仅针对番茄和马铃薯两个类别),分析并提供生物和化学补救措施，以克服损失并进一步控制受影响的植物。如果你对补救措施中的农业内容感到困惑，我收集了一些视频，通过位于结果附近的视频按钮，帮助你在实践中进行解释。

你可以在我下面的 Github 链接中找到上面项目的代码。我将一步一步地详细解释代码。

[## mani kanta-mun nangi/Keras-Custom-Model-Deployment-Using-Flask-And-Heroku

此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…

github.com](https://github.com/Manikanta-Munnangi/Keras-Custom-Model-Deployment-Using-Flask-And-Heroku)

首先，您应该知道 flask 项目中文件的结构。它将看起来像下面一个。

Flask files structure.

不用担心模特文件夹里的文件。你可以理解模型文件夹中的文件无非是模型权重(h5)、架构(JSON)和数据库(db。这些是我的项目文件，但开始时，你需要有文件夹。不要改变文件夹的名称，因为它们是 flask 想要的格式。

首先，两个文件夹是 pycache 和。vscode 用于 visual studio 代码(vs code)配置文件，它将在您在 visual studio 中编码时生成。所以，不用担心。

文件夹:

Models == >模型权重、JSON 和任何数据库文件。

2.Static == >这是 CSS、javascript 文件以及 flask 中使用的图像将存储在该文件夹中的位置。

3.模板== >有 index.html(名字不用改)等 HTML 文件。

4.Uploads == >在进行预测之前，图像文件应该存储在某个文件夹中，就是这个。

文件:

app.py == >运行 flask 并在 web 服务器上工作的主要代码。

Procfile == >您使用 Procfile 来告诉 Heroku 如何运行您的应用程序的各种文件。

requirements.txt == >列出您的项目所使用的包，以便 Heroku 在上面安装 dynos(容器)。

。要忽略的 GitHub 文件。

。gitattributes == >大文件存储路径(Git LFS)当你想上传超过 100mb 的文件时，Git LFS 就派上了用场。

5.2 烧瓶脚本。

5 行代码就能让你的网络应用启动并运行。

烧瓶样板代码。

在 Index.html写 hello world 或任何要显示的文本。

<!doctype html>
<html>  
<body>       
<h1> Hello world</h1>   
</body>
</html>

@ app . route('/')其中@ decorator 用来包装另一个函数，扩展其他函数的行为。

渲染 _ 模板 渲染 Html 文件。 app.run()启动 webserver 并提供一个本地主机 URL。打开 http://127.0.0.1:5000/ 查看您的 web app，

烧瓶基础完成。编写模型预测函数。

在 app.py 文件中创建一个预测函数，该函数通过 flask 中的请求模块获取我们的图像，并用 model 对其进行处理，并将结果返回给 result.html 进行显示。

== >使用请求功能从 flask 模块获取图像文件。

== >将用户上传的图像保存到名为“上传”的文件夹中。在预测之前，它应该在内存中。

==> leaf_predict 是一个函数，返回用户上传的图片是否有叶子。这是使用卷积自动编码器完成的，我将在下一篇文章中讨论。如果返回变量是 leaf，那么我们的模型将开始预测，除非它不会。

==> Model_predict 函数用于对上传的图像进行预处理，我们接受了调整大小、图像到数组、标准化和扩展维度，然后编译和预测等方面的培训。

==> Info() 功能是从数据库文件中获取疾病信息(。sqlite)。它将在 model_predict 返回疾病名称后检索疾病信息。为了检索，我们编写代码来检查疾病名称和 SQLite 数据库疾病名称是否相同，如果相同，我们将疾病信息返回到结果页面。

==> 最后返回无..为什么？？在' POST ' 方法之后，request.files 设置缺省为 None。

如果你想得到一个清晰的图片和更多的代码，你可以通过我的 Github 查看。

检查它将是超级简单的。这是一个大项目，所以我离开你审查剩余的代码和理解，所以你可以得到工作流。

5.3 输入表单的 Html 脚本。

用 Vs 代码或者你选择的任何 IDE 获取你下载的引导或者 Html 文件。

但是的主要部分是通过 Html 按钮获取图像数据，所以我们在提交表单数据后，应该调用 app.py 中的预测函数

表单数据 Html。

< form action = "/predict" 功能用 POST 方法提交后进行唤起。
“file”制作一个上传文件的按钮 **accept=" image/"** 只获取所有格式的图像，如(jpg，jpeg，png…)*
必需的变量在最后使得用户提交表单时必须输入图像。
最后，

5.4 Returning Results with Html.

After prediction, we want to display results it can be done with Html again. first, we need to pass the result through the “predict” function in the app.py to result.html file.

Results through Html.

result.html disease info code.

After Building entire model with flask .Now, it’s time to upload your work to Github.

Uploading all code to Github for Heroku cloud 从 GitHub 获取代码，而不是使用 Heroku CLI 进行部署。

在把你的项目推给 Heroku 之前，你需要有两个 Heroku 需要的关于如何运行应用程序的文件。Procfile 和 requirements.txt

Procfile:

*web: gunicorn app:app --bind 0.0.0.0:$PORT*

Gunicorn 是 Python 的开源 web 服务器。它允许 Heroku 部署我们的应用程序。你需要用 pip 安装它以防你没有安装。
我们让我们的服务器启动 app.py，使用 app name，Flask 的实例是第二个参数，第一个参数是 app 的名称。[app:app]= = >[app 的名称:它的 Flask 实例(name)]

**from* flask *import* Flaskapp = Flask(__name__)*

港口和主机将由 Heroku 负责。

Requirements.txt:

将项目中使用的所有包放入一个文件中。您可能知道这个命令

*pip freeze > requirements.txt*

冻结命令显示所有软件包及其当前版本。我们使用“>”操作符将冻结命令的结果复制到名为 requirements.txt 的文件

6.部署到赫罗库。

Heroku with Github.

有了 Heroku，工作变得更简单，因为它负责一切，因为它是一个平台即服务(PAAS)* 这意味着它确实设置了基础架构、预安装的操作系统和冗余服务器、运行时环境。除了一些您应该手动执行的步骤。***

要遵循的步骤:

通过 Heroku 官方网站创建一个 Heroku 账户。
登录后，创建应用程序。

Create a new app in Heroku.

3.将您的项目命名为 name.herokuapp.com，并将部署方法设置为 Github。****

Connect to Github.

4.这里，我们将我们的 GitHub 帐户与选择我们的项目存储库联系起来。****

5.手动部署验证 procfile 并安装 requirements.txt 文件中的所有库压缩到 slug 编译器，负责将应用程序缩放到 dyno 以供执行。如果压缩到 slug 后整个项目超过 300MB，您的应用程序停止处理您的应用程序。因为他们在有限的时间内限制了免费访问帐户的 slug 大小。

Look for Slug, buildpacks, and config settings.

6.我的 slug 大小低于 300MB，框架使用了 python 和 git LFS，链接到大型文件系统(LFS)的文件在 Heroku 中不受支持。****

所以我们需要将 configs 作为 key“HEROKU _ build pack _ GIT _ LFS _ REPO”添加到 value“https://@ github . com/username/repository . GIT”令牌是唯一的个人访问令牌。
你需要在 GitHub >设置> Heroku 的开发者设置中注册，才能访问你的 LFS 文件，还需要链接到 buildpacks 来安装 https://github.com/raxod502/heroku-buildpack-git-lfs.git 的 LFS。

7.最后，点击 deploy 部分的 deploy 按钮，您就完成了您的项目，人们可以通过互联网访问。****

Finally, Deploy.

如果你有任何错误，很好地解决日志和调试你的错误，谷歌它，你一定会得到解决方案。

需要记住的要点:

如果你是一个学习基础知识的初学者，使用 flask 框架。
使用来自 bootstrap 或 html5.net 网站的模板，它们是免费的。根据您的项目对模板进行更改。
开始和 Heroku 一起工作，这看起来很容易，因为你经常工作。
最后，试着做一些能提升你技能的项目，从小项目中获得核心基础知识，然后再去做大项目。

这是一篇很长的文章，我希望你们喜欢它，并从这篇文章中学到了一些基础知识。尝试使用我的 GitHub 中的代码。我很快又想出了另一篇文章。

快乐学习:)

一切都是数据

原文：https://towardsdatascience.com/everything-is-data-f08e291c4b11?source=collection_archive---------23-----------------------

为什么我们需要数据来改善世界？

坐在我的客厅里，我和我的朋友们争论哪些专业可以保证一个人拿到最好的薪水。我争辩说任何工程相关的专业都提供最好的薪水，而我的朋友说是商业。

我们决定在谷歌上搜索哪个专业工资最高，但谷歌搜索提供了模糊的结果，因为不同的文章选择了任何一方。因此，我们对“哪个专业薪水更高”这个问题感到困惑。商科还是工科？”

因此，我在 Kaggle 上寻找数据集，希望找到一个数据集来探索并找到问题的答案。幸运的是，我找到了两个数据集，而不是一个。第一个是基于专业的薪资数据集，而第二个是基于学院区域的薪资数据集。

结合这两个数据集并对其进行分析，我们发现在加州拥有一个工程专业可能会提供最好的起薪。人们还发现，在美国东北部地区，工程专业的学生可能提供最好的职业中期工资。

回顾我的这个迷你项目，我看到了如何利用数据来回答我们每天都感兴趣的问题的力量。数据科学是一个可以用来教人们如何分析数据的领域，以便对如何改善我们周围的世界有更好的想法。

为什么是数据科学？

数据以多种格式存在，可以通过不同的方法收集。一旦它们被收集起来，人们可以分析和探索它们，以找出如何改善生活的不同方面，从体育到创新。

通过找出他们无能背后的原因，公司可以使用树形分类器来找出他们做错了什么。公司还可以利用销售和业绩的结果来预测他们能从某一特定受众身上赚多少钱。

利用数据科学来改善我们生活的世界是深不可测的。作为人类，我们发现数据科学可以用来回答以前没有答案的问题。为了回答这些问题，近年来越来越多的人涌入数据科学领域。

尽管大量的人正在成为数据科学家，但数据科学领域仍然有大量的职位空缺。《哈佛商业评论》在一篇文章中将数据科学命名为 21 世纪最性感的工作之一，这是因为它令人困惑的氛围和解决问题的能力。文章可以在这里找到。

什么是数据科学？

数据科学是能够使用数据并应用数据科学技术(如数据收集、数据可视化、机器学习等)来解决问题的能力。它是独一无二的，因为它既不需要密集的演算来建立一个机械装置，也不需要有争议的技巧来赢得法庭案件。

与医学、法律和工程等职业非常不同，它更像是一种现代技能，不仅可以用来回答令人困惑的问题，还可以应用于医疗保健、体育和商业等所有其他领域，提供突破性的启示。

数据科学是一个结合了数学、统计、计算和演示技能的领域。大量使用 R 和 python 等编码语言可以让人们有能力运行适当的代码来获得结果。有了扎实的数学和统计学知识，一个人可以很容易地弄清楚如何进行计算和解释数字。

通过书面文字或公开演讲有效展示您的发现的能力，使得最终与每个人分享数据分析的结果变得更加容易。

数据科学的魅力

人们拍照，购物，在他们最喜欢的餐馆吃饭，去充满异国情调的地方旅游。在一个约有 75 亿人口的世界里，从所有这些活动中可以获得数万亿千兆字节的数据，用于增强人类的能力。关于这些数据的疯狂事实是，它正以指数速度增长。

我们所做的可以被记录为原始数据，并被处理成有用的信息，这些信息可以用于治疗疾病，发明更好的社交媒体应用程序和高效地运送包裹。我相信数据科学才刚刚起步，我们人类还有很长的路要走。总之，一切都是数据；数据就是一切。

你想知道的关于计算机视觉的一切。

原文：https://towardsdatascience.com/everything-you-ever-wanted-to-know-about-computer-vision-heres-a-look-why-it-s-so-awesome-e8a58dfb641e?source=collection_archive---------0-----------------------

下面来看看为什么这么牛逼。

Computer Vision in Action🤖📹 Photo by the author

最强大和最引人注目的人工智能类型之一是计算机视觉，你几乎肯定已经在许多方面体验过，甚至不知道。让我们来看看它是什么，它是如何工作的，为什么它这么棒(而且只会变得更好)。

计算机视觉是计算机科学的一个领域，它专注于复制人类视觉系统的部分复杂性，并使计算机能够像人类一样识别和处理图像和视频中的对象。直到最近，计算机视觉只能在有限的能力下工作。

由于人工智能的进步以及深度学习和神经网络的创新，该领域近年来能够实现巨大飞跃，并能够在一些与检测和标记物体相关的任务中超过人类。

计算机视觉发展背后的驱动因素之一是我们今天生成的数据量，这些数据随后被用来训练和改善计算机视觉。

YOLO Multi-Object Detection And Classification. Photo by the author

随着大量的视觉数据(每天有超过 30 亿张图片在网上被分享)，分析这些数据所需的计算能力现在已经可以使用了。随着计算机视觉领域随着新的硬件和算法的发展，物体识别的准确率也在提高。在不到十年的时间里，今天的系统已经从 50%的准确率达到了 99%，这使得它们在对视觉输入做出快速反应方面比人更准确。

计算机视觉的早期实验始于 20 世纪 50 年代，到 20 世纪 70 年代，它首次被用于商业用途，以区分打字和手写文本，今天，计算机视觉的应用已经呈指数增长。

到 2022 年，计算机视觉和硬件市场预计将达到 486 亿美元

计算机视觉是如何工作的？

神经科学和机器学习中的一个主要公开问题是:我们的大脑到底是如何工作的，我们如何用自己的算法来近似它？现实是，大脑计算的工作和综合理论非常少；因此，尽管神经网络应该“模仿大脑的工作方式”，但没有人能确定这是否是真的。

同样的悖论也适用于计算机视觉——因为我们无法决定大脑和眼睛如何处理图像，所以很难说生产中使用的算法有多接近我们自己的内部心理过程。

在某种程度上，计算机视觉就是模式识别。因此，训练计算机如何理解视觉数据的一种方法是给它输入图像，大量的图像数以千计，如果可能的话，数以百万计的已被标记的图像，然后对这些图像进行各种软件技术或算法的处理，使计算机能够在与这些标记相关的所有元素中寻找模式。

例如，如果你给电脑输入一百万张猫的图片(我们都喜欢它们😄😹)，它会让它们接受算法，让它们分析照片中的颜色、形状、形状之间的距离、物体彼此的边界等等，以便识别“猫”的含义。当它完成时，如果输入其他未标记的图像，计算机将(理论上)能够利用它的经验找到猫的图像。

让我们暂时把我们毛茸茸的猫朋友放在一边，让我们更专业一点🤔😹。下面是存储亚伯拉罕·林肯图像的灰度图像缓冲区的简单说明。每个像素的亮度由一个 8 位数字表示，范围从 0(黑色)到 255(白色):

Pixel data diagram. At left, our image of Lincoln; at center, the pixels labeled with numbers from 0–255, representing their brightness; and at right, these numbers by themselves. Photo by Nguyen Dang Hoang Nhu on Unsplash

{157, 153, 174, 168, 150, 152, 129, 151, 172, 161, 155, 156,
 155, 182, 163,  74,  75,  62,  33,  17, 110, 210, 180, 154,
 180, 180,  50,  14,  34,   6,  10,  33,  48, 106, 159, 181,
 206, 109,   5, 124, 131, 111, 120, 204, 166,  15,  56, 180,
 194,  68, 137, 251, 237, 239, 239, 228, 227,  87,  71, 201,
 172, 105, 207, 233, 233, 214, 220, 239, 228,  98,  74, 206,
 188,  88, 179, 209, 185, 215, 211, 158, 139,  75,  20, 169,
 189,  97, 165,  84,  10, 168, 134,  11,  31,  62,  22, 148,
 199, 168, 191, 193, 158, 227, 178, 143, 182, 106,  36, 190,
 205, 174, 155, 252, 236, 231, 149, 178, 228,  43,  95, 234,
 190, 216, 116, 149, 236, 187,  86, 150,  79,  38, 218, 241,
 190, 224, 147, 108, 227, 210, 127, 102,  36, 101, 255, 224,
 190, 214, 173,  66, 103, 143,  96,  50,   2, 109, 249, 215,
 187, 196, 235,  75,   1,  81,  47,   0,   6, 217, 255, 211,
 183, 202, 237, 145,   0,   0,  12, 108, 200, 138, 243, 236,
 195, 206, 123, 207, 177, 121, 123, 200, 175,  13,  96, 218};

这种存储图像数据的方式可能与你的期望背道而驰，因为数据在显示时当然看起来是二维的。然而，事实就是如此，因为计算机内存只是由一个不断增长的线性地址空间列表组成。

How pixels are stored in memory. Photo by the author

我们再回到第一张图，想象一下加一个彩色的。现在事情开始变得更加复杂。计算机通常将颜色解读为一系列 3 个数值——红、绿、蓝(RGB)——在相同的 0-255 范围内。现在，除了它的位置，每个像素实际上有 3 个值供计算机存储。如果我们给林肯总统着色，那将导致 12×16×3 个值，或 576 个数字。

Photo by the author

一幅图像需要大量的内存，一个算法需要迭代大量的像素。但是，为了训练一个具有有意义的准确性的模型，特别是当你谈论深度学习时，你通常需要成千上万的图像，越多越好。

计算机视觉的演变

在深度学习出现之前，计算机视觉可以执行的任务非常有限，需要开发人员和人类操作员进行大量的手动编码和努力。例如，如果您想要执行面部识别，您必须执行以下步骤:

创建一个数据库:你必须以特定的格式捕捉所有你想追踪的对象的个人图像。
给图像加注释:然后，对于每一张单独的图像，你必须输入几个关键数据点，比如两眼之间的距离、鼻梁的宽度、上唇和鼻子之间的距离，以及其他几十个定义每个人独特特征的测量数据。
捕捉新图像:接下来，你必须捕捉新图像，无论是照片还是视频内容。然后你必须再次经历测量过程，在图像上标记关键点。你还必须考虑图像拍摄的角度。

在所有这些手动工作之后，应用程序最终能够将新图像中的测量值与存储在其数据库中的测量值进行比较，并告诉您它是否与它正在跟踪的任何配置文件相符。事实上，几乎没有自动化，大部分工作都是手动完成的。误差幅度仍然很大。

机器学习为解决计算机视觉问题提供了一种不同的方法。有了机器学习，开发人员不再需要手动将每个规则编码到他们的视觉应用程序中。相反，他们编写了“特征”程序，即可以检测图像中特定模式的小型应用程序。然后，他们使用统计学习算法，如线性回归、逻辑回归、决策树或支持向量机(SVM)来检测模式和分类图像，并检测其中的对象。

机器学习帮助解决了许多传统软件开发工具和方法面临的历史性挑战。例如，几年前，机器学习工程师能够创建一个软件，它可以比人类专家更好地预测乳腺癌的生存窗口。然而，构建该软件的功能需要数十名工程师和乳腺癌专家的努力，并花费了大量时间进行开发。

深度学习提供了一种完全不同的方法来进行机器学习。深度学习依赖于神经网络，这是一种通用功能，可以解决任何通过示例表示的问题。当你为神经网络提供许多特定类型数据的标记示例时，它将能够提取这些示例之间的共同模式，并将其转换为数学方程，这将有助于对未来的信息进行分类。

例如，创建一个具有深度学习的面部识别应用程序只需要你开发或选择一个预构建的算法，并用它必须检测的人的面部样本来训练它。给定足够多的例子(大量的例子)，神经网络将能够检测人脸，而无需进一步的特征或测量指令。

深度学习是做计算机视觉非常有效的方法。在大多数情况下，创建一个好的深度学习算法可以归结为收集大量的标记训练数据，并调整参数，如神经网络的类型和层数以及训练时期。与以前的机器学习类型相比，深度学习的开发和部署更加容易和快速。

目前大多数计算机视觉应用，如癌症检测、自动驾驶汽车和面部识别，都利用了深度学习。由于硬件和云计算资源的可用性和进步，深度学习和深度神经网络已经从概念领域进入实际应用。

破译一幅图像需要多长时间

总之不多。这就是为什么计算机视觉如此令人兴奋的关键:尽管在过去，即使是超级计算机也可能需要几天或几周甚至几个月才能完成所有需要的计算，但今天的超高速芯片和相关硬件，以及快速可靠的互联网和云网络，使这一过程变得快如闪电。曾经至关重要的因素是许多从事人工智能研究的大公司愿意分享他们的工作脸书、谷歌、IBM 和微软，特别是通过开源他们的一些机器学习工作。

这允许其他人在他们的工作基础上进行，而不是从零开始。因此，人工智能行业正在发展，不久前需要几周才能完成的实验今天可能只需要 15 分钟。对于计算机视觉的许多现实应用来说，这个过程都是在几微秒内连续发生的，所以今天的计算机能够做到科学家所说的“情境感知”

计算机视觉的应用

计算机视觉是机器学习中的一个领域，其中的核心概念已经被集成到我们每天使用的主要产品中。

自动驾驶汽车中的 CV

但不仅仅是科技公司在利用机器学习进行图像应用。

计算机视觉使自动驾驶汽车能够了解周围的环境。摄像机从汽车周围的不同角度捕捉视频，并将其输入计算机视觉软件，然后实时处理图像，以找到道路的尽头，阅读交通标志，检测其他汽车，物体和行人。然后，无人驾驶汽车可以在街道和高速公路上行驶，避免撞到障碍物，并(希望)安全地将乘客送到目的地。

人脸识别中的 CV

计算机视觉在面部识别应用中也发挥着重要作用，这种技术使计算机能够将人的面部图像与他们的身份进行匹配。计算机视觉算法检测图像中的面部特征，并将它们与面部轮廓数据库进行比较。消费设备使用面部识别来验证其所有者的身份。社交媒体应用使用面部识别来检测和标记用户。执法机构也依靠面部识别技术来识别视频中的罪犯。

增强现实和混合现实中的 CV

计算机视觉在增强和混合现实中也发挥着重要作用，这种技术使智能手机、平板电脑和智能眼镜等计算设备能够在现实世界的图像上覆盖和嵌入虚拟物体。AR gear 使用计算机视觉来检测现实世界中的物体，以便确定设备显示屏上放置虚拟物体的位置。例如，计算机视觉算法可以帮助 AR 应用程序检测桌面、墙壁和地板等平面，这是建立深度和维度以及在物理世界中放置虚拟对象的一个非常重要的部分。

医疗保健中的简历

计算机视觉也是医疗技术进步的重要组成部分。计算机视觉算法可以帮助自动化任务，如检测皮肤图像中的癌性痣，或在 x 射线和 MRI 扫描中发现症状。

计算机视觉的挑战

帮助电脑看东西是非常困难的。

发明一台像我们一样看东西的机器看起来是一项艰巨的任务，不仅因为很难让计算机做到这一点，还因为我们不完全确定人类的视觉最初是如何工作的。

研究生物视觉需要了解像眼睛这样的感知器官，以及对大脑内感知的解释。尽管像任何涉及大脑的研究一样，还有很长的路要走，但在绘制过程图表和发现系统使用的技巧和捷径方面，已经取得了很大进展。

Credit For The Image Goes To: Mike Tamir

许多流行的计算机视觉应用包括尝试识别照片中的事物；例如:

物体分类:这张照片中的物体属于哪一大类？
物体识别:这张照片中给定的物体是哪种类型？
实物验证:实物在照片里吗？
物体检测:照片中的物体在哪里？
物体地标检测:照片中物体的关键点是什么？
物体分割:图像中有哪些像素属于物体？
物体识别:这张照片里有什么物体，它们在哪里？

除了识别之外，其他分析方法包括:

视频运动分析利用计算机视觉来估计视频中物体的速度，或者摄像机本身的速度。
在图像分割中，算法将图像分割成多组视图。
场景重建创建通过图像或视频输入的场景的 3D 模型。
在图像恢复中，使用基于机器学习的过滤器从照片中去除模糊等噪声。

任何其他涉及通过软件理解像素的应用都可以安全地称为计算机视觉。

结论

尽管最近取得了令人印象深刻的进展，但我们仍然没有接近解决计算机视觉问题。然而，已经有多个医疗机构和企业找到了将由 CNN 支持的 CV 系统应用于现实世界问题的方法。而且这种趋势不太可能很快停止。

如果你想联系我，顺便说一句，你知道一个好笑话，你可以在 Twitter 或 LinkedIn 上联系我。

感谢阅读！😄 🙌

你想知道的关于 K 近邻的一切

原文：https://towardsdatascience.com/everything-you-ever-wanted-to-know-about-k-nearest-neighbors-dab986e21b60?source=collection_archive---------20-----------------------

五分钟后

Photo by Nina Strehl on Unsplash

k 近邻算法是最简单、最容易理解的机器学习算法之一。它可以用于分类和回归任务，但在分类中更常见，所以我们将从这个用例开始。不过，这些原则在这两种情况下都适用。

下面是算法:

定义 k
定义距离度量，通常是欧几里得距离
对于一个新的数据点，找到最近的 k 个训练点，并以某种方式组合它们的类别——通常是投票——以获得一个预测的类别

就是这样！

一些好处:

不需要任何传统意义上的训练。你只需要一个快速的方法来找到最近的邻居。
易于理解和解释。

部分否定:

您需要定义 k，这是一个超参数，因此它可以通过交叉验证进行调整。k 值越高，偏差越大，k 值越小，方差越大。
您必须选择一个距离度量，根据度量的不同，可能会得到非常不同的结果。同样，您可以使用交叉验证来决定使用哪个距离。
它并没有真正提供哪些特性可能是重要的见解。
由于维数灾难，它可能会受到高维数据的影响。基本上，维度的诅咒意味着在高维度中，很可能接近的点并不比平均距离近多少，这意味着接近并没有太大的意义。在高维度中，数据变得非常分散，这就造成了这种现象。网上有很多关于这方面的好资源，我就不多说了。

基本假设:

对于我们的目标类或值，接近的数据点共享相似的值。

投票方式

多数投票:选出 k n 个最近的邻居后，对这些邻居的班级进行“投票”。新的数据点被分类为邻居的大多数类。如果您正在进行二元分类，建议您使用奇数个邻居，以避免票数相等。然而，在一个多类问题中，更难避免平局。一个常见的解决方案是降低 k ，直到平局被打破。最常见类别的投票分数也可以作为该类别的概率得分。
距离加权:不是直接对最近的邻居 k 进行投票，而是根据该实例与新数据点的距离对每一票进行加权。一种常见的加权方法是基于新数据点和训练点之间的距离。新的数据点被添加到总权重最大的类别中。这不仅减少了平局的机会，而且还减少了数据失真的影响。

距离度量

欧几里德距离，或 2 范数，是一种非常常见的距离度量，用于 k- 最近邻。然而，可以使用任何标准。p-定额定义为

因此，对于 p 的任何值，您可以定义两点之间的距离: x 和 y.

搜索算法

如上所述，除了准备一种快速查找相邻点的方法之外，没有真正的训练。假设您的数据集包含 2000 个点。对一个点的 3 个最近邻居的强力搜索不需要很长时间。但是如果数据集包含 2，000，000 个点，强力搜索可能会变得非常昂贵，尤其是在数据的维度很大的情况下。其他搜索算法为了更快的运行时间而牺牲了穷举搜索。KDTrees 或 Ball trees 等结构用于加快运行时间。虽然我们不会深入这些结构的细节，但了解它们以及它们如何优化您的运行时间(尽管训练时间确实会增加)是很重要的。

半径邻居分类器

一个非常相关的算法是半径邻居分类器。这与最近邻分类器的想法相同，但不是查找 k- 最近邻，而是查找给定半径内的所有邻居。设置半径需要一些领域知识；如果您的点紧密地聚集在一起，您可能希望使用较小的半径来避免几乎每个点都投票。

k-邻居回归量

为了将我们的问题从分类转变为回归，我们所要做的就是找到第 k 个最近邻的加权平均值。我们使用与上述相同的加权方法，计算这些最接近值的加权平均值，而不是取多数类。在这种情况下,“多数投票”只是邻居的简单平均值，而“距离加权”是由距离加权的平均值。

代码！

让我们看看这一切是如何与一些 Python 代码结合在一起的:

Source: https://gist.github.com/tfolkman/1f122eb101011edc4a1456c70aef07fd

一旦运行，您将获得:

Best Params: {'n_neighbors': 5, 'p': 1, 'weights': 'uniform'} 
Train F1: 0.9606837606837607 
Test Classification Report:             
                  precision    recall  f1-score   support            
          0       0.97         0.88    0.93       43  
          1       0.93         0.99    0.96       71  
avg / total       0.95         0.95    0.95       114  
Train Accuracy: 0.9494505494505494 
Test accuracy: 0.9473684210526315

还不错！希望这篇文章能帮助你更好地理解 K 近邻是如何工作的，以及如何在 Python 中实现它。如果你想学习更多的机器学习算法，一定要看看《Scikit-Learn 和 TensorFlow 的动手机器学习》这本书。

这篇文章也可以在这里找到。

加入我的 邮箱列表 保持联系。

关于深度学习模型中的“激活函数”，你需要知道的一切

原文：https://towardsdatascience.com/everything-you-need-to-know-about-activation-functions-in-deep-learning-models-84ba9f82c253?source=collection_archive---------0-----------------------

这篇文章是你的一站式解决方案，可以解决你脑海中出现的与深度学习模型中使用的激活函数相关的每个可能的问题。这些基本上是我关于激活函数的笔记，以及我对这个话题的所有知识都集中在一个地方。所以，不做任何不必要的介绍，让我们直接进入正题。

内容

什么是激活功能，它在网络中做什么？
为什么需要它而为什么不用线性函数代替？
激活功能的理想特征是什么？
使用各种非线性激活
值得注意的来自最新研究的非线性激活
如何(和哪个)在深度神经网络中使用它们

什么是激活函数？

简单地说，激活函数是添加到人工神经网络中的函数，以便帮助网络学习数据中的复杂模式。当与我们大脑中基于神经元的模型进行比较时，激活功能最终决定向下一个神经元发出什么信号。这也正是激活函数在人工神经网络中的作用。它接收前一个单元的输出信号，并将其转换成某种形式，可以作为下一个单元的输入。下图总结了这种比较。

Source: cs231n by Stanford

为什么需要它？

在网络中具有非线性激活函数有多种原因。

除了前面讨论的生物相似性，它们还有助于根据我们的要求，将神经元的输出值限制在一定的范围内。这一点很重要，因为激活函数的输入是 W*x + b ，其中 W 是单元的重量，而 x 是输入，然后有偏置 b 加到其上。如果不受某个限制，这个值可以非常大，特别是在具有数百万个参数的非常深的神经网络的情况下。这将导致计算问题。例如，有一些激活函数(如 softmax)为不同的输入值(0 或 1)输出特定的值。
激活函数中最重要的特征是其将非线性加入神经网络的能力。为了理解这一点，让我们考虑如下图所示的多维数据:

使用三个特征(图中的体重、收缩压和年龄)的线性分类器可以给我们一条穿过三维空间的线，但它永远无法准确地学习使一个人成为吸烟者或不吸烟者的模式(手头的分类问题)，因为定义这种分类的模式仅仅是非线性的。人工神经网络出现了。如果我们使用具有单个细胞但没有激活功能的人工神经网络会怎样。因此，我们的输出基本上是 W*x + b. ，但这是不好的，因为 W*x 也有 1 度，因此是线性的，而这基本上等同于线性分类器。****

如果我们堆叠多层。让我们将 nᵗʰ图层表示为 fₙ(x).的函数所以我们有:

o(x) = fₙ(fₙ₋₁(….f₁(x)

然而，这也不够复杂，尤其是对于具有非常高的模式的问题，例如在计算机视觉或自然语言处理中面临的问题。

为了使模型获得学习非线性模式的能力(也称为更高程度的复杂性)，在它们之间添加了特定的非线性层(激活函数)。

激活功能的理想特征

消失梯度问题:使用过程梯度下降来训练神经网络。梯度下降包括反向传播步骤，该步骤基本上是链式法则，以获得权重的变化，从而减少每个时期后的损失。考虑一个两层网络，第一层表示为 f₁(x，第二层表示为 f₂(x).整个网络是 o(x) = f₂(f₁(x)).如果我们在反向传递过程中计算权重，我们得到 o(x) = f₂(x)*f₁(x).这里 f₁(x)本身是由动作 (W₁x₁ + b₁)组成的复合函数，其中动作是层 1 之后的激活函数。再次应用链式法则，我们清楚地看到 f₁`(x) = 行为 (W₁x₁ + b₁)*x₁，这意味着它也直接依赖于激活值。现在想象这样一个链式法则在反向传播时经过多层。如果 Act ()的值在 0 和 1 之间，那么几个这样的值将相乘以计算初始层的梯度。这降低了初始层的梯度值，并且这些层不能正确地学习。换句话说，由于网络的深度和激活将值移至零，它们的梯度趋于消失。这被称为消失梯度问题。所以我们希望我们的激活函数不会将梯度移向零。
以零为中心:激活函数的输出应该在零处对称，这样梯度就不会移动到特定的方向。
计算开销:激活函数在每一层之后应用，在深度网络中需要计算上百万次。因此，它们的计算成本应该很低。
可微分:如上所述，使用梯度下降过程训练神经网络，因此模型中的层需要可微分或至少部分可微分。这是一个功能作为激活功能层工作的必要条件。

使用各种非线性激活

乙状结肠:乙状结肠的定义是:

此激活功能仅出于历史原因，从未在实际模型中使用过。计算量很大，会导致消失梯度问题，并且不是以零为中心的。这种方法一般用于二分类问题。

软最大值:软最大值是乙状结肠的一种更一般化的形式。用于多类分类问题。与 sigmoid 类似，它产生 0–1 范围内的值，因此被用作分类模型中的最后一层。
Tanh:Tanh 定义为:

如果你把它比作 sigmoid，它只解决了一个以零为中心的问题。

ReLU : ReLU (整流线性单元)定义为 f(x) = max(0，x):

这是一个广泛使用的激活函数，尤其是对于卷积神经网络。它易于计算，不会饱和，也不会导致梯度消失的问题。它只有一个问题，那就是不以零为中心。它受到“垂死的热路”问题的困扰。因为所有负输入的输出都是零。导致一些节点完全死亡，什么也学不到。

ReLU 的另一个问题是激活爆炸，因为它的上限是 inf。这有时会导致节点不可用。

泄漏 ReLU 和参数 ReLU :定义为 f(x) = max(αx，x)

the figure is for α = 0.1

这里α是一个超参数，一般设置为 0.01 。显然，漏 ReLU 在一定程度上解决了“将死 ReLU”的问题。注意，如果我们将α设置为 1，那么泄漏 ReLU 将变成线性函数 f(x) = x，并且将是无用的。因此， α的值永远不会接近 1。如果我们分别为每个神经元设置 α 作为超参数，我们得到参数 ReLU 或 PReLU 。

ReLU6 :基本上是正向的 ReLU 限制，定义为 f(x) = min(max(0，x)，6)

这有助于停止激活爆炸，从而停止梯度爆炸(去 inf ),以及正常 ReLUs 发生的另一个小问题。

一个人想到的想法是，为什么不将 ReLU6 和 LeakyReLU 结合起来，以解决我们在以前的激活功能中遇到的所有已知问题。流行的 DL 框架没有提供这种激活功能的实现，但我认为这是一个好主意。

值得注意的非线性激活来自最新研究

Swish :这是 Ramachandran 等人在 2017 年提出的，定义为 f(x) = x*sigmoid(x) 。

与 ReLU 相比，它的性能稍好，因为它的图形与 ReLU 非常相似。但是，因为它不会像 ReLU 在 x = 0 时那样在某一点突然改变，所以在训练时更容易收敛。

但是，Swish 的缺点是计算量很大。为了解决这个问题，我们来到了 Swish 的下一个版本。

硬切换或 H 切换:这被定义为:

最好的部分是，它几乎类似于 swish，但它的计算成本更低，因为它用 ReLU(线性类型)代替了 sigmoid(指数函数)。

如何在深度神经网络中使用？

****Tanh 和 sigmoid 导致巨大的消失梯度问题。因此，不应使用它们。
****从你网络中的 ReLU 开始。激活层是在重量层(类似 CNN、RNN、LSTM 或线性致密层)之后添加的，如上文所述。如果你认为模型已经停止学习，那么你可以用一个 LeakyReLU 来代替它，以避免垂死的 ReLU 问题。然而，泄漏的 ReLU 会稍微增加计算时间。
如果您的网络中也有批量定额层，则在激活功能生成 CNN-批量定额- 行为 之前添加。虽然批处理规范和激活函数的顺序是一个有争议的话题，有些人说顺序无关紧要，但我使用上面提到的顺序只是为了遵循最初的批处理规范论文。
激活函数在其默认的超参数中工作得最好，这些超参数在流行的框架中使用，如 Tensorflow 和 Pytorch。然而，可以调整 LeakyReLU 中的负斜率，将其设置为 0.02 以加快学习。

那是所有的乡亲们😃

我已经尝试解决每一个与激活功能相关的问题，但是，如果我错过了什么，请在下面评论。

可以在我的 Github 上看更多深度学习相关的东西，关注我的Linkedin**。**

我之前的一些文章:

** [## 关于 Auto-Deeplab 你需要知道的一切:谷歌关于细分的最新消息

搜索图像分割模型

towardsdatascience.com](/everything-you-need-to-know-about-auto-deeplab-googles-latest-on-segmentation-181425d17cd5) [## 关于 MobileNetV3 及其与以前版本的比较，您需要了解的一切