ARIMA 参数可以改变，以获得不同的预测行为。我已经定义了一个用户定义的方法，它接受三个参数的训练集和值。该函数首先创建 ARIMA 模型。然后对模型执行 fit()和 forecast()。Forecast()返回预测值。

将这几行复制并粘贴到您的笔记本上:

ARIMA(……)创造了 ARIMA 模式。Fits()通过卡尔曼滤波器以最大似然法拟合 ARIMA(p，d，q)模型，Forecast()返回基于拟合的 ARIMA 模型的估计值。

我们可以认为 Fit()是一个生成误差最*的最佳拟合曲线的过程。关于这个话题的更多内容，请见我的博客:我的预测模型——回归分析有多好？

p，q，d 参数可以调整以获得更好的结果。

这是一个我们如何传递时间序列数据并使用 ARIMA 根据实际观察数据预测值的示例:

通过运行该脚本，我们可以看到预测值:

我们传入随机值作为训练集。然后 ARIMA 模型进行拟合，预测下一个值为 15.219305

我们还可以将外生变量、日期、时间序列的频率等传递给 ARIMA 模型。

最后，让我们使用 Python 中的 ARIMA 来预测汇率

既然我们已经了解了如何使用 python Pandas 来加载 csv 数据，以及如何使用 StatsModels 来预测价值，那么让我们结合本博客中获得的所有知识来预测我们的样本汇率。

复制并粘贴这段代码。它是我们在这个博客中学到的所有概念的结合。

按 Alt+Enter。Python 将开始用实际数据循环调用 ARIMA 模型。70%的数据用于训练模型，其余 30%用于测试准确性。每次产生新的预测值。

实际值和预测值将打印在笔记本上。

最后，实际值与预测值将绘制在图表上

查看均方误差

我还导入了一个额外的库 sklearn ，我将在未来的博客中使用它。

复制粘贴这一行:

“从 sklearn.metrics 导入 mean_squared_error”导入库。

最后打印均方差:

均方误差计算实际数据和预测数据之间差异的平均值，并告诉您您的模型有多好。更多信息可以在我的博客里找到: 我的预测模型—回归分析 有多好

通过运行下面的代码，我们可以查看实际值、预测值以及折线图和总均方误差:

如您所见，我们打印了实际值和预测值。此外，我们用红色绘制了 MSE 为 1.551 的预测值。

完整的笔记本，请访问这里。

进一步的改进

预测汇率可以通过以下方式改进:

• 不断更新模型参数
• 通过输入影响汇率及其相关性的其他因素
• 模型参数也可以通过机器学习和优化技术来更新。
• 最后，可以强调因素及其相关性，以确保预测的汇率考虑到极端情况。

最终注释

本文演示了如何使用 python 通过 ARIMA 模型预测汇率。金融市场可以向任何方向移动，这使得准确预测汇率变得非常困难，如果不是不可能的话。话虽如此，通过 ARIMA 预测汇率的唯一目的是帮助我们做出精心计算的决定，以实现回报最大化和风险最*化。预测汇率取决于 ARIMA 模型的假设，该模型基于自回归、综合和移动平均概念。

ARIMA 是一个简单而强大的模型。它假设历史价值决定现在的行为。它还假设数据不包含异常，是稳定的，并且模型参数以及误差项是恒定的。

尽管 ARIMA 没有将市场数据中的压力、经济和政治条件或所有风险因素的相关性作为预测汇率的输入，但上面展示的简单示例可用于预测正常情况下稳定货币的运动，在正常情况下，过去的行为决定了现在和价值。

如果您有任何反馈，请告诉我。

在构建预测模型之前，您应该了解的预测基础知识

原文：https://towardsdatascience.com/forecasting-fundamentals-you-should-know-before-building-predictive-models-299a18c2093b?source=collection_archive---------10-----------------------

预测，还是不预测，这是一个问题。

人类文明史与我们尝试预测方法的历史交织在一起。当我们的祖先观察天空来预测天气时，数据科学家开发并训练机器学习模型来预测销售、风险、事件、趋势等。准确的预测是一项重要的组织能力，做得好的企业将会有很大的生存优势。

应该预测什么

在预测项目的早期阶段，需要决定应该预测什么，什么时候可以准确预测，以及什么时候预测不会比扔硬币好。

例如，如果需要对房地产市场进行预测，则有必要询问是否需要对以下方面进行预测:

• 任何类型的财产，或独立/半独立/联排别墅/公寓分开？
• 是按地区分组的房产平均销售价格，还是仅针对总销售额？
• 周数据，月数据还是年数据？

需要注意的关键是并不是所有的预测都比掷硬币好。事件或价值的可预测性取决于几个因素，包括:

• 我们是否发现并理解了影响结果的大部分因素？
• 这些因素有“大”数据吗？
• 预测是否会影响我们试图预测的事情？

例如，24 *时天气预报可以非常准确，因为这三个条件通常都满足。另一方面，很难预测下一滴雨滴落入你眼中的概率，明天的并发汇率会上升或下降或下周的比特币价格。

时间跨度和数据可用性方面的预测类型

是否需要提前几分钟、6 个月或 10 年的预测？就时间跨度而言，有 3 种类型的预测:

• 短期预测:一至三个月的正常范围
• 中期预测:时间周期一般为一年
• 长期预测:预测超过两年的结果

在大多数预测情况下，随着事件的临近，与我们预测的事物相关的不确定性会减少。换句话说，我们预测的越近，我们就越准确。

根据数据可用性，预测可以分为两种类型。

• 定性预测:如果没有可用数据，或者可用数据与预测无关。
• 定量预测(时间序列预测):如果过去的数字信息可用；过去的模式将延续到未来。

用于定量预测(时间序列预测)的数据通常以固定的时间间隔观察，例如每*时、每天、每周、每月、每季度、每年。目标是估计历史观察序列将如何延续到未来。

预测方法

方法的选择取决于可用的数据和事件的可预测性或要预测的价值。

由于缺乏历史数据，判断性预测是定性预测的唯一选择。例如，预测新政策、新产品或新竞争对手的影响。

最简单的时间序列预测方法仅使用待预测变量的历史值，并排除可能影响其行为的因素，如竞争对手的活动、环境或经济条件的变化等。下图显示了使用过去 10 年的销售数据对 2017 年的房屋销售预测。

house sales prediction for 2017 with past 10-year sales data

在本文中，我们将讨论什么是预测、预测类型和预测方法。预测显然是一项具有挑战性的活动。在以后的文章中，我将探讨一些常用的预测方法，包括指数平滑法、ARIMA 模型、动态回归模型、LSTM 等。

“你看到这些伟大的建筑了吗？没有一块石头留在另一块石头上，不被拆毁。”( 马克 13:1–2)

让预测在未来到来之前向你展示它。

预测欧元区的 GDP

原文：https://towardsdatascience.com/forecasting-gdp-in-the-eurozone-54778f79912e?source=collection_archive---------6-----------------------

使用欧盟统计局数据和 ARIMA 模型预测欧元区季度 GDP(国内生产总值)

这一分析使用了欧盟统计局的公共数据集来预测所有欧元区国家未来的季度 GDP 总量。欧盟统计局是位于卢森堡的欧盟统计局。它的任务是为欧洲提供高质量的统计数据。欧盟统计局提供了一系列重要而有趣的数据，政府、企业、教育部门、记者和公众可以在工作和日常生活中使用这些数据。特别是，使用了欧元区(欧盟 19 国)季度 GDP(国内生产总值)数据集。欧元区由 19 个国家组成:奥地利、比利时、塞浦路斯、爱沙*亚、芬兰、法国、德国、希腊、爱尔兰、意大利、拉脱*亚、立陶宛、卢森堡、马耳他、荷兰、葡萄牙、斯洛伐克、斯洛文*亚和西班牙。

国内生产总值(GDP)是在一段时间(季度或年度)内生产的所有最终商品和服务的市场价值的货币度量。它通常用于确定一个国家或地区的经济表现。

用于获取数据集的欧盟统计局软件包和用于 ARIMA 建模的预测软件包。

关于 ETL 步骤的更多细节可以在实际代码中找到，在文章结尾的链接中。

探索性分析

在探索性分析期间，我们试图发现时间序列中的模式，例如:

• 趋势时间序列中涉及长期增减的模式
• 季节性由于日历(如季度、月份、工作日)
• 周期性存在一种模式，其中数据呈现非固定周期(持续时间通常至少为两年)的上升和下降

下面是 1995 年以来欧元区国家季度 GDP 的时间序列图。

上面的时间序列图中有一些输出:
-我们可以说总体趋势是积极的
-趋势中没有明显的增加/减少的可变性
-看起来有一些季节性，但需要进一步调查
-没有周期性
-在 2008-2009 年左右，GDP 增长出现了明显的中断

下面用一个季节性图来研究季节性。季节图类似于时间图，只是数据是根据观察数据的单个“季节”绘制的。

这增强了我们对时间序列中季节性的信心。似乎每年的第四季度总是最高的，而第一季度是最低的。第二次和第三次差不多。

滞后图将帮助我们了解时间序列中是否存在自相关。查看时间序列数据的另一种方法是将每个观察值与之前某个时间发生的另一个观察值进行对比。例如，您可以根据 yt1 绘制 yt。这被称为滞后图，因为你是根据时间序列本身的滞后来绘制的。基本上，它是时间序列和时间序列滞后值之间的散点图。

滞后 4 (1 年)有很强的季节性，因为所有季度线图遵循几乎相同的路径。

下面是自相关函数图。与滞后图相关的相关性形成了所谓的自相关函数(ACF)。超出置信区间(蓝线)的香料表明具有特定滞后的自相关具有统计显著性(不同于零)

看起来在所有滞后上都有显著的自相关，这表明了时间序列中的趋势和/或季节性。

我们还可以使用 Ljung-Box 检验来检验时间序列是否是白噪声。白噪声是一个纯粹随机的时间序列。下面是第四阶段的测试。

##  Box-Ljung test
## 
## data:  gdp_ts
## X-squared = 319.62, df = 4, p-value < 2.2e-16

Ljung-Box 检验 p 值很*< 0.01, so there is strong evidence that the time series is not white noise and has seasonality and/or trend.

Modelling

ARIMA (Auto-regressive integrated moving average) models provide one of the main approaches to time series forecasting. It is the most widely-used approach to time series forecasting, and aim to describe the autocorrelations in the data.

The final fitted model was produced by the auto.arima() function of the forecast library. It rapidly estimates a series of model and return the best, according to either AIC, AICc or BIC value. After fitting the ARIMA model, it is essential to check that the residuals are well-behaved (i.e., no outlines or patterns) and resemble white noise. Below there are some residual plots for the fitted ARIMA model.

##  Ljung-Box test
## 
## data:  Residuals from ARIMA(2,1,1)(0,1,1)[4]
## Q* = 6.1916, df = 4, p-value = 0.1853
## 
## Model df: 4\.   Total lags used: 8

We can say that the model is fairly good, since the residuals are closely normally distributed, have no real pattern and autocorrelations are not significant.
最终模型是一个季节性 ARIMA(2，1，1)(0，1，1)【4】。季节性差异和第一次差异都被使用，由模型每个部分的中间槽表示。此外，选择了一个滞后误差和一个季节性滞后误差，由模型每个部分的最后一个槽表示。使用了两个自回归项，由模型中的第一个槽表示。没有使用季节性自回归术语。

最后，对预测模型的准确性进行了检验。下面是对模型准确性的测试，使用 2017 年所有四个季度和 2018 年第一季度作为测试集。

##                     ME     RMSE     MAE         MPE      MAPE      MASE
## Training set -1763.393 18524.64 13332.4 -0.08197817 0.6440916 0.1939318
## Test set     47152.498 49475.29 47152.5  1.68398118 1.6839812 0.6858757
##                    ACF1 Theil's U
## Training set 0.06526246        NA
## Test set     0.09563655 0.6768184

测试集的 MAPE(平均绝对百分比误差)为 1.68，因此我们可以得出模型的预测精度在 98.3 % 左右。

下面是欧元区国家 2018-19 年季度 GDP 预测的时间序列图。

• 看起来国内生产总值将在未来几年保持增长。特别是对未来几个季度的预测是:

 Quarter       Forecast   Lo 80   Hi 80   Lo 95   Hi 95
 2018 Q2        2887406 2853687 2921524 2835996 2939748
 2018 Q3        2892970 2841213 2945670 2814191 2973955
 2018 Q4        2990005 2917818 3063978 2880312 3103876
 2019 Q1        2888631 2805996 2973700 2763213 3019742
 2019 Q2        2973066 2870171 3079650 2817151 3137610
 2019 Q3        2976688 2859234 3098966 2798945 3165717
 2019 Q4        3076720 2939974 3219827 2870063 3298258

• 到 2019 年底，国内生产总值很有可能在今年的一个或多个季度突破三万亿€的关口

使用其他预测方法开发的模型更多，如指数平滑(具有趋势和季节性 Holt-Winters 的指数平滑方法)& 指数三次平滑，但 ARIMA 模型表现更好。

全 R 码

用蒙特卡罗模拟预测软件项目的完成日期

原文：https://towardsdatascience.com/forecasting-software-projects-completion-date-through-monte-carlo-simulation-c1baa5bcf976?source=collection_archive---------6-----------------------

Photo by Jonathan Petersson on Unsplash

如今，我们正在使用一种比确定性方法更具概率性的方法来管理我们的过程。这意味着我们使用不同的统计方法来预测未来，而不是盲目的估计。但是等等…不可预测性难道不是让我们从瀑布式转变为敏捷的主要原因之一吗？

是的，不确定性是软件开发所固有的。例如，一个人不可能在一个项目的开始就预测一个系统的所有特性。

但是，如果我们能预测接下来几周的行为会怎样呢？

这就是我们试图通过收集指标并对其进行蒙特卡洛模拟来实现的目标。

要了解我们如何收集指标，我建议您阅读以下帖子:

• 我们为什么喜欢度量标准？学习提前期
• 我们为什么喜欢度量标准？吞吐量和燃耗图表
• 我们为什么喜欢指标？累积流程图

大多数人不使用任何度量来管理他们的项目。你可以想象有多少人使用复杂的统计模型来预测项目的完成。然而，在你当前的项目中拥有这些知识将会帮助你更快更好的交付。

在本帖中，你将看到我们如何使用蒙特卡罗模拟从一个简单的预测方法到一个更加精确和稳健的方法。此外，我们将以简单明了的方式解释蒙特卡罗模拟是如何工作的，然后在这个简单的例子和我们的现实世界方法之间进行类比。知道你的项目什么时候可能结束可以帮助你管理项目的预算，给利益相关者更好的反馈，给你信心，你确实在控制你的项目。

为什么不是其他方法？

长期以来，我们一直在尝试其他的预测方法，但它们都有一些缺点。在这里，我们列出了其中的一些，以及我们如何和为什么选择使用蒙特卡洛。

平均吞吐量

你们中的一些人可能已经想到了一个简单的方法，我们将使用平均吞吐量来预测项目的结束。然而，正如你在这篇博文中看到的 指标的力量:不要用平均值来预测最后期限 ，那将是一个极其幼稚的方法，而且它不起作用。

线性回归方法

作为第一种方法，我们使用线性回归，基于我们累积的吞吐量，来预测项目何时结束:

但是，我们发现了两个不同的问题，我们在进行分析时没有考虑到:

• 我们必须保持待办事项列表中的项目数量不变，以便进行预测，这非常有偏差。
• 经过一些分析后，我们发现吞吐量和交付时间都不符合正态分布，因此计算线性回归是没有意义的(参见 以不同的方式看待交付时间 和 线性回归 的假设)。

手动设置方法

首先，我们专注于避免第二个问题，我们开始使用一个更节俭的模型，它使用了我们知道有些倾斜的方法，但是我们可以更好地控制它们。

我们手动添加了吞吐量性能，这将导致每个不同的预测在某个日期到达积压。这种预测方法来自对我们吞吐量历史的百分位数的研究。

我们有了更好的结果，因为我们可以手动更改预测，因此可以根据项目的当前状态进行调整。但是第一个问题，事实上我们没有考虑到积压订单的变化，这让我们更进一步，尝试蒙特卡罗模拟。

蒙特 卡罗模拟

*基百科将蒙特卡洛方法定义为

蒙特卡罗方法各不相同，但往往遵循一种特定的模式:

定义可能输入的域。

根据域内的概率分布随机生成输入。

对输入执行确定性计算。

汇总结果。

乍一看，这似乎很难或很复杂，但实际上比看起来要简单得多。你可以把它看作是预测的强力方法。我们将给出一个简单的例子，然后展示我们在现实世界中的表现。Larry Maccherone 做了一个很好的模拟，可以更好地解释这一点。

骰子游戏

假设你在玩一个骰子游戏，目标是用最少的掷数得到 12 点。这里最好的玩法是连续两次掷骰子，你都得到 6，最差的是 12 次掷骰子得到 1。我们要计算的是 N 次运行后结束博弈的概率。

考虑到每一次掷骰子有 6 种可能的结果，即骰子的 6 个面，那么在 1 次掷骰子中完成游戏的概率是多少？

零。因为如果骰子只到 6 点，你就不能到 12 点。

第二卷呢？

就是连续得到两个 6 的概率，这是基本统计:

第三卷呢？

现在你可以用很多方法达到 12 点，其中一些是:(3，3，6)，(3，4，5)，(3，5，4)，(3，4，6)，(5，5，2)，(4，4，4)等等。这个计算背后的统计数据并不简单，对吗？这就是蒙特卡罗模拟派上用场的时候。

蒙特卡洛模拟成千上万次掷骰子，然后分析结果。例如，要知道在第三轮完成游戏的概率，它将掷骰子三次，将点数相加并存储结果。之后，它将重复这些步骤 5000 次，并总结每一个点数总和得到的掷数:

现在它所做的是将所有产生大于 12 的和的事件相加，然后除以事件总数。在这种情况下:

同样的方式，我们做了第三轮，我们可以做第四，第五，等等。

现实世界

现实世界的解决方案非常类似于掷骰子的例子。唯一的区别是，我们也改变了目标(游戏场景中的 12 分)，以考虑待办事项中的变化。

所以现在每一轮的可能结果(骰子的两面)就是我们的吞吐量历史。同样，我们是吞吐量的“滚动骰子”,我们需要滚动积压的骰子，以便给它增长的机会。在这种情况下，可能的结果将是积压的增长率(BGR)。

让我们慢慢开始。假设我们的项目历史是这样的:

因此，我们每一轮的吞吐量可能是集合{2，3，0，2，5，0，1，3，3}，积压可能是{0，2，1，1，2，1，0，2，0}。我们不排除重复的数字，因为有了它们，我们可以保持拥有一个数字而不是其他数字的更高概率。

现在，我们可以将相同的基本原理应用到骰子游戏中。在第一周，总吞吐量达到积压量或更多的概率是多少？一些可能的结果如下:

然后，我们将运行许多这样的程序，看看有多少程序的吞吐量总和大于 backlog 总和，然后将结果除以运行次数。这样做，我们就有可能在第一周结束项目。在接下来的一周，我们将做同样的事情，但是每一轮掷骰子两次，然后对吞吐量和积压量求和。

这种方法的一个问题是，在项目开始时，backlog 的行为不同于在项目中间或结束时。在开始时，通常增长要快得多，因为我们更好地理解了我们项目的问题和细微差别，在最后，增长基本上来自于精炼的故事。

为了解决这个问题，我们不考虑整个 BGR 历史作为可能的结果，而只考虑积压的最后 10 个 bgr，这将使我们对积压最近的表现有更好的了解。

使用新的最后 10 个 BGR 方法得出的未来 10 周的结果显示在图表中:

如您所见，我突出显示了图表的三个不同区域，以说明我认为可以从图表中获得的信息:

• 第一个区域，红色的，是我们完成项目的概率低于 50%的几周。这意味着告诉项目的利益相关者你将在接下来的 4 周内完成它是非常危险的。
• 下一个区域，橙色区域，显示了我们完成项目的概率在 50%到 75%之间的几周。我要说的是，如果利益相关者向你施压，要求你快速交付，那么这几周，如果你有信心，你就能完成。
• 绿色区域是一个更无风险的区域，在那里你完成项目的概率大于 75%。我建议你总是优先考虑基于这个领域而不是其他领域来估计你的项目的结束，但是我们都知道我们不能总是那么安全。

我们在过去的项目中测试了蒙特卡洛模拟，它看起来工作得很好，但是，和任何其他统计方法一样，在项目中几周后，它比开始时好得多。

摘要

预测一个项目什么时候可能结束看起来太“胡说八道”了，但是这个方法真的很容易实现，并且让我们对我们的项目有更好的预测和理解。重要的是要弄清楚，这种方法是一种统计方法，因此它不是失败证明。主要目标是在我们的工具包中增加一个元素，让项目管理变得简单一点。

为了帮助你预测软件项目的完成日期，我们制作了一个简单版本的电子表格供你下载，这样你不用做太多工作就可以运行模拟。

要了解更多关于蒙特卡洛模拟的信息，我推荐以下参考资料:

• Troy Magennis 的书— 预测和模拟软件开发项目:使用蒙特卡罗模拟对看板& Scrum 项目进行有效建模
• 丹*尔·瓦坎蒂的网站、书籍和博客:可操作的敏捷
• Joel Spolsky 关于循证计划的博客文章

本文原载于http://blog . platafomatec . com . br/2016/08/forecasting-software-projects-completion-date-through-Monte-Carlo-simulation/。

预测可变差旅费用的准确率达到 95%

原文：https://towardsdatascience.com/forecasting-variable-travel-expenses-with-95-accuracy-5aa615203db5?source=collection_archive---------17-----------------------

首席财务官的自动机器学习

更新:我开了一家科技公司。你可以在这里找到更多

组织每年在差旅费上花费数百万美元，其中很大一部分是可变的，很难估计。除了在预订时已知的机票和住宿之外，餐饮和杂费等额外费用是未知的，可能对总费用有很大影响。

在本文中，我们将在几分钟内建立一个模型，该模型可以根据员工的职位、目的、目的地、住宿和机票计算出可变费用，对公布的数据有 95%的准确性，并且无需编写任何代码。数据准备和模型构建将由 AuDaS 处理，AuDaS 是由 [Mind Foundry](http://mind foundry.ai) 构建的自动化数据科学团队。

数据准备

费用数据是从安大略省养老金委员会下载的，包含其员工自 2010 年以来的费用报销。目标是使用截至 2017 年的数据来预测 2018 年的总支出。

Uploading the data into AuDaS

特征工程

数据集包含每次旅行的开始和结束日期，因此我们将要求 AuDaS 计算持续时间，因为这可能会对总花费产生很大影响。

然后，我们将使用 RegEx 转换删除数据中的$符号，以便进行格式化。

然后，我们将删除包含可变费用的列，以避免数据泄露，因为它们已经包含在我们希望预测的总支出中。这样做之后，AuDaS 检测到有一些丢失的值，并建议用户如何纠正它。

在整个过程中，AuDaS 在工作流程中增加了一些步骤，作为审计跟踪。您可以返回到数据集的先前版本，也可以导出工作流。在我们的例子中，我们将把这个工作流导出到包含 2018 年养老基金支出的测试集中。这将自动重现数据准备步骤，并允许我们在对其进行训练后，轻松地在其上部署我们的模型。

数据探索

现在我们已经清理了数据，我们可以访问直方图视图来提取初始的洞察力。我们也可以改变比例来查看稀疏分布的值。

我们的直接收获是，最常见的目的地是多伦多，董事会成员出差最多。似乎没有一个关键的模式，这就是为什么我们要使用机器学习来揭示更复杂的关系。

自动化建模

我们将要求 AuDaS 建立一个回归模型来预测总支出。

AuDaS 自动保留训练集的 10%用于最终验证。它还使用 10 重交叉验证来训练模型，以避免过度拟合。这保证了由 AuDaS 训练的模型在生产中表现良好。一旦我们满意了，我们现在就可以按开始按钮开始训练了。

训练是使用 Mind Foundry 的专有贝叶斯优化器 OPTaaS 实现的，opta as 允许 AuDaS 有效地在可能的回归管道的大搜索空间中导航。

AuDaS 提供了所选管道、模型和参数值以及性能统计的完全透明性。AuDaS 还为找到的最佳模型提供了特征相关性。

在这种情况下，住宿和机票费用以及目的地和目的地城市伦敦是可变费用的最强预测因素。首席信息官的头衔似乎也是总支出的一个很好的指标。既然我们对模型的准确性感到满意，我们就可以查看它的模型健康状况了。在我们的情况下，它是好的，我们可以放心地将其应用于测试数据集。

在测试数据集上运行训练好的模型之后，我们得到了每个条目的预测。AuDaS 会自动忽略模型训练中未使用的列。这意味着我们可以很容易地将实际总支出与预测支出进行比较。为此，我们可以导出数据并在 excel 中访问它。

在计算了每一列的总数后，我们可以看到 AuDaS 达到了 95%的准确率。

为什么这很重要

能够在一定程度上准确预测总支出对首席财务官来说是非常有价值的。在大公司，每季度的差旅支出可能达到 1 亿美元，甚至更多。可能会有相当大差异，分析人员通常会使用电子表格，根据不同部门的累积输入来估计预算需求。部门经理做了大量工作来积累有关未完成项目和过去支出的信息，增加了一些应急余量。同样的方法不仅适用于差旅费，也适用于许多成本预测情况。通过机器学习，业务线经理和财务可以在几分钟内做出更加准确的预测。最重要的是，这些模型可以实时运行，并在情况变化时提供高级警告。这避免了在关键的季度最后几周臭名昭著的旅行和成本禁运，因为预算已经达到。

了解更多信息

如果你想知道澳洲是否能解决你的问题，请填写这张简短的表格。如果你对 OPTaaS 感兴趣，你可以使用这个更短的表格获得一周免费试用的资格！

以下是这一过程的完整视频:

你可以在下面阅读更多 AuDaS 案例研究教程:

[## 信用卡聚类

营销人员面临的首要挑战是了解他们的销售对象。当你知道你的买家…

towardsdatascience.com](/credit-card-clustering-6a92657ac99) [## 利用自动化机器学习优化您的电子邮件营销策略

对于全球超过 1 万亿美元的企业来说，优化销售营销支出是一个价值 10 亿美元的问题…

towardsdatascience.com](/optimize-your-email-marketing-strategy-with-automated-machine-learning-e1bfb8cc171b) [## 利用 AuDaS 在几分钟内解决 Kaggle Telco 客户流失挑战

AuDaS 是由 Mind Foundry 开发的自动化数据科学家，旨在允许任何人，无论是否有…

towardsdatascience.com](/solving-the-kaggle-telco-customer-churn-challenge-in-minutes-with-audas-2273fed19961)

团队和资源

Mind Foundry 是牛津大学的一个分支机构，由斯蒂芬·罗伯茨(Stephen Roberts)和迈克尔·奥斯本(Michael Osborne)教授创建，他们在数据分析领域已经工作了 35 年。Mind Foundry 团队由 30 多名世界级的机器学习研究人员和精英软件工程师组成，其中许多人曾是牛津大学的博士后。此外，Mind Foundry 通过其分拆地位，拥有超过 30 名牛津大学机器学习博士的特权。Mind Foundry 是牛津大学的投资组合公司，其投资者包括牛津科学创新、牛津技术与创新基金、、牛津大学创新基金和 Parkwalk Advisors 。

使用 Python 和 Tableau 进行预测

原文：https://towardsdatascience.com/forecasting-with-python-and-tableau-dd37a218a1e5?source=collection_archive---------1-----------------------

我写了一本关于脸书先知的书，已经由 Packt 出版社出版了！这本书在亚马逊上有售。

这本书涵盖了使用 Prophet 的每个细节，从安装到模型评估和调整。十几个数据集已经可用，并用于演示 Prophet 功能，从简单到高级，代码完全可用。如果你喜欢这篇中帖，请考虑在这里订购:【https://amzn.to/373oIcf】T4！在超过 250 页的篇幅中，它涵盖的内容远远超过了媒体所能教授的内容！

非常感谢你支持我的书！

我是 Greg Rafferty，湾区的数据科学家。你可以在我的 github 上查看这个项目的代码。如有任何问题，请随时联系我！

在这篇文章中，我将展示如何在 Tableau 中使用 Python 代码来构建一个实现时间序列预测的交互式仪表板。如果你只是想先玩一下仪表盘，探索一下 SARIMAX 算法，请在这里下载完整的 python 实现的仪表盘，或者在 Tableau Public 上下载这个稍微有点笨的版本(Tableau Public 明智但令人失望地不允许上传外部脚本，所以我不得不用硬编码的数据集来伪造 Python 脚本)。

因为当你想不出一个好名字的时候，试试一个旅行箱

去年，Tableau 发布了 10.2 版本，其中包括与 Python 的集成。不过，如何使用它并不是非常简单，所以当一个客户要求一个时间序列预测仪表板时，我想我会弄清楚的。 ARIMA 模型没有内置到 Tableau 中(Tableau 的预测模块使用指数平滑，在这种特殊情况下，我确实需要使用 ARIMA 算法的更高预测能力，所以tabby似乎是我唯一的选择。

我不会详细介绍如何安装 TabPy(提示:pip install tabpy-server)，也不会详细介绍如何安装 Python(我想，如果你想在 Tableau 中运行 Python 代码，你可能已经知道如何使用 Python 了。如果没有，从这里开始。)

一旦安装了 TabPy 发行版，您将需要导航到包含在 /site-packages 中的源代码，然后进入 tabpy-server 目录(在我的例子中，是在默认位置安装了 Anaconda 3 的 MacOS 上，/anaconda3/lib/python3.7/site-packages/tabpy_server)。从那里运行sh startup.sh或python tabpy.py来启动服务器。您需要指示 Tableau 不断地嗅探端口 9004，这是 Tableau 和 Python 的通信方式。为了做到这一点，在 Tableau 内部，

1. 转到帮助→设置和性能→管理外部服务连接…
2. 输入服务器(如果在同一台计算机上运行 TabPy，则为 localhost)和端口(默认为 9004)。

And you’re off to the races!

如果到目前为止你有任何困难，试试这个教程。

ARIMA:如果你的公文包听起来笨重，那就用首字母缩略词

ARIMA 代表一个独立的整体平均值。在本教程中，我使用了它的更高级的兄弟，SARIMAX(SeasonalAuto-RegressiveIintegratedMovingAaverage with eXogen 回归变量)。好吧，那是什么？

先从回归说起。你知道那是什么，对吧？基本上，给定一组点，它会计算出最能解释图案的直线。

接下来是 ARMA 模型(自回归移动平均)。自回归部分意味着它是一个基于以前的值预测未来值的回归模型。这类似于说明天会很暖和，因为前三天都很暖和。(附注:这就是时间序列模型比标准回归复杂得多的原因。数据点不是相互独立的！).均线部分其实根本不是均线(别问我为什么，我也不知道)。这仅仅意味着回归误差可以建模为误差的线性组合。

如果 ARMA 模型不太符合你的数据，你可以试试 ARIMA。额外的 I 代表集成。这个术语解释了先前值之间的差异。直觉上，这意味着明天很可能和今天一样的温度，因为过去一周没有太大变化。

最后，我们转到萨里马克斯。S 代表季节性-它有助于对重复模式进行建模。这些季节性模式本身并不一定每年都会发生；例如，如果我们在一个繁忙的城市地区模拟地铁交通，模式将每周重复一次。而 X 代表外源性的(抱歉。这个不是我想出来的)。这个术语允许将外部变量添加到模型中，比如天气预报(尽管我在本教程中的模型没有添加任何外部变量)。

一个 SARIMAX 模型采用 SARIMAX(p，D，q) x (P，D，Q)m 的形式，其中 P 是 AR 项，D 是 I 项，Q 是 MA 项。大写的 P、D 和 Q 是相同的术语，但与季节成分有关。*写的 m 是模式重复之前的季节周期数(因此，如果您正在处理月度数据，就像在本教程中一样，m 将是 12)。在实现时，这些参数都是整数，数字越*越好(即不太复杂)。对于我的模型，我选择的最适合模型的参数是 SARIMAX(2，1，2) x (0，2，2)12。

我进行了网格搜索以得出这些术语。我试图最*化的错误是赤池信息标准 (AIC)。AIC 是一种衡量模型与数据拟合程度的方法，同时降低了复杂性。在 Tableau 仪表板中，我报告均方误差，因为这更直观。

这样一来，让我们看看如何在 Tableau 中实现它！

航空乘客数据

如果你想跟进，你可以在我的 github 上下载打包的 Tableau 工作簿。我使用的是航空乘客数据集(https://www.kaggle.com/rakannimer/air-passengers)，其中包含了 1949 年至 1961 年间航空乘客数量的月度数据。让我们来看看发生了什么:

（舞台上由人扮的）静态画面

我希望我的仪表板是完全交互式的，这样我可以更改所有的 p、d 和 q，同时观察它们对模型的影响。因此，首先(这里的“第一”，我指的是“第二，在您连接到上面链接的航空乘客数据集之后”)，让我们为这些变量创建参数。

你需要创建 8 个参数: AR(时滞)、 I(季节性)、 MA(移动平均线)、月预测、期、季节性 AR(时滞)、季节性 I(季节性)、季节性 MA(移动平均线)。确保所有的数据类型都是整数，否则 Python 稍后会抛出一些错误(并且 TabPy 非常无益地拒绝为您提供错误行号)。对于月预测和期间，我使用了一个允许值范围，从 1 到 48(对于月预测)和 1 到 24(对于期间)。接下来我们需要创建一个名为预测日期的计算字段，这样 Tableau 将扩展 x 轴以包含预测值。在计算字段中，输入:

DATE(DATETRUNC('month', DATEADD('month', [Months Forecast], [Month])))

我们还将创建一个乘客数量计算字段，以确保我们的 SARIMAX 数据与实际数据相符:

LOOKUP(SUM([#Passengers]), [Months Forecast])

最后，还有一个名为过去与未来的计算字段，我们稍后将使用它将预测格式化为不同的颜色:

IF LAST() < [Months Forecast]
THEN 'Model Forecast'
ELSE 'Model Prediction'
END

计算机编程语言

好了，终于！在蟒蛇身上。让我们创建我们的第一个脚本。创建一个计算字段并将其命名为预测。在字段中，粘贴以下代码:

我们还将创建一个名为均方误差的计算字段，这样我们就可以在图表上有一个漂亮的动态标题:

现在，将预测日期拖到列架上，将乘客数量和预测拖到列架上。使其成为双轴图表，并使轴同步。将过去与未来放在预测卡的色标上，就大功告成了！那很容易，不是吗？(不，实际上不是。令人尴尬的是，我花了很长时间才弄明白如何让这些脚本工作，而且 Tableau 极其无益的不显示错误发生在哪里的习惯使得故障排除成为一项令人沮丧的工作。为了增加一点趣味，将这些参数添加到侧栏中，这样您就可以交互地更改它们。哦！我差点忘了那个时髦的标题。右键单击标题→编辑标题… →并键入以下代码:

下面是最终的仪表板应该是什么样子。如果你想让它看起来和我的一样，你会有一些格式化任务要处理，或者你可以下载我的仪表板在这里并完成它。Tableau Public 不允许上传任何外部脚本，很遗憾，这意味着我不能分享如下所示的确切版本。相反，我只是运行了数百个 SARIMAX 参数的排列，并将每个预测保存到一个 csv 文件中，这个版本虽然没有那么漂亮，也没有那么酷，但可以直接在 Tableau Public 这里上玩。

如你所见，模型相当不错！这就是 SARIMAX 的强大之处:它准确地模拟了随着时间推移的总体增长趋势，全年季节的起伏，甚至是随着时间的推移数据的增长方差(波峰高点和波谷低点之间的距离增加)。你需要*心选择你的参数，如果你不*心，一些有趣的事情会发生。例如，我表现最差的模型是这样的(看看这个误差幅度！):

法医深度学习:Kaggle 相机模型识别挑战

原文：https://towardsdatascience.com/forensic-deep-learning-kaggle-camera-model-identification-challenge-f6a3892561bd?source=collection_archive---------7-----------------------

数据扩充的重要性

From https://habr.com/company/ods/blog/415571/

大约一年前，在 kaggle.com 举办了一场名为 IEEE 信号处理学会——相机型号识别的计算机视觉挑战赛。任务是分配哪种类型的相机用于捕捉图像。比赛结束后，亚瑟·库津、阿图尔·法塔霍夫、伊利亚·基巴尔丁、鲁斯兰·道托夫和我决定写一份技术报告，描述如何解决这个问题，并分享我们在这个过程中获得的一些见解。它被接受参加在西雅图举行的第二届网络犯罪调查大数据分析国际研讨会，我将于 2018 年 12 月 10 日在那里发表演讲。在这篇博文中，我想写一个文本的扩展版本。

这篇论文有五位作者:

亚瑟·法塔霍夫、亚瑟·库津、伊利亚·基布丁和其他队员以 0.987 的成绩获得第二名。

我是以 0.985 分获得第九名的队伍中的一员。

我们的解决方案非常相似，所以我们决定写一份技术报告。深圳大学大数据研究所的研究生鲁斯兰(Ruslan )自愿帮我做文本，这对这篇论文至关重要。

在下文中，我将把第二名团队的方法称为“我们的”解决方案。此外，我将跳过一些对整体信息不重要的技术细节。第二名解决方案的代码可在 GitHubhttps://GitHub . com/iki bardin/ka ggle-camera-model-identificati on上获得。比赛结束后，我们使用我们开发的洞察力进行了一系列单独的实验。这里的工作主要是基于这一进一步的调查。

图像处理的许多应用之一是相机模型检测。例如，在法医学领域，可能至关重要的是要知道一张图片是使用谷歌 Pixel 还是 iPhone 拍摄的，以确定谁可能是非法或有罪照片的所有者，甚至确定谁是知识产权的合法所有者。这种系统还可以用于检测诽谤、中伤或传播假新闻的肇事者。

计算机中的图像存储为数字矩阵和附带的元数据。在最简单的情况下，相机模型应该存储在图像元数据中，这使得相机识别成为一个基本问题。但是图像元数据可能不可靠，并且很容易被恶意用户操纵。

还有另一种更复杂但更可靠的方法。采集完成后，数码相机中的图像将经过一系列后处理步骤，从而生成图像保真度和内存占用优化的图像。这些算法非常复杂，高度非线性。例子可以包括去马赛克、噪声过滤、修正镜头失真等。不同的算法用于各种相机模型，这意味着它们中的每一个都创建特定于模型的工件，人们可以将其用作机器学习管道的特征。

当然，有很多关于这个主题的文献。它的大部分提出了手动特征提取的步骤，在此基础上使用 SVM 或类似的分类算法。例如，当我面对这个问题时，我想到的第一个想法是拍摄一张图像，减去它的平滑版本，并计算这种差异的不同统计数据，如均值、中值、标准差和不同的量，并在其上训练 xgboost。关于如何进行这种相机型号检测的第一篇论文之一非常接近我刚才描述的内容。其他文章提出了一些更复杂的东西，但方法非常相似，基于领域知识的手动特征提取，并在此基础上使用逻辑回归、决策树或 SVM。

将这种方法推广到新的相机型号也很困难。假设我们想为一个新的、刚刚发布的模型进行相机检测。专家应该花多长时间来找出哪些特征有助于将它与其他模型区分开来？

另一方面，深度学习方法可以解决这两个问题。总的来说，深度学习是一头强大的野兽，如果你知道如何驯服它，它可能会帮助你创建高度准确的黑盒模型。

当你在查阅文献并试图理解哪种方法是“最好的”时，这是不可能的。几乎每篇论文都告诉你它们是最先进的。处理的方法是在同一个数据集上评估不同的方法。这种比较不会给你一个总体上哪种算法更好的答案，而是在给定的数据集上，哪种算法更好。这并不意味着在相似的数据集上算法排名是相同的，比如在 CIFAR 上最先进的架构可能在 ImageNet 上表现不佳，反之亦然。但这样的统一对比总比没有好。

对于相机检测任务，IEEE 信号处理协会组织了一次挑战，其中 582 个团队有两个月的时间和一个实时排行榜来比较他们的方法。582 是一个很大的数字，这确保了问题会被不同背景和技能的人所攻击。一些参与者在工业界和学术界从事法医工作，以此谋生。其他人，比如我，有使用计算机视觉技术的经验，但是没有意识到甚至存在像相机识别这样的问题，并且有人有兴趣解决它。

组织者准备了一个由 2750 张图片组成的训练集，这些图片来自 10 台相机——每台相机 275 张。

我们需要区分的相机型号有:

1. 索* NEX-7
2. 摩托罗拉摩托 X
3. 摩托罗拉 Nexus 6
4. 摩托罗拉 DROID MAXX
5. LG Nexus 5x
6. 苹果 iPhone 6
7. 苹果 iPhone 4s
8. HTC One M7
9. 三星银河 S4
10. 三星 Galaxy Note 3

为了让这个问题不那么无聊，组织者使用了 20 部不同的手机来收集图像:10 部用于训练，10 部用于测试。这意味着在训练期间，您的模型可能不会学习与后处理算法相关的相机模型特定的功能，而是过度适应特定手机特定的伪像。

测试集中的图像是用相同的 10 个相机模型捕获的，但是使用第二个设备。例如，如果 iPhone 6 的火车数据图片是用 Ben Hamner 的设备(相机 1)拍摄的，那么测试数据中的图像是用 Ben Hamner 的第二个设备(相机 2)拍摄的，因为他在风筝冲浪时丢失了海湾中的第一个设备。

此外，火车中的图像是全尺寸的，而在测试中，只使用了中央 512x512 作物。其原因是径向失真在图像的侧面更加明显。一些论文显示了纯粹基于径向畸变特征的有希望的结果。他们能增加多少附加值还不清楚，但组织者决定阻止参与者利用他们。

这还不是全部。在许多情况下，通常存储在电脑上的图像会受到不同转换的影响，如 jpeg 压缩、gamma 转换、对比度、亮度、调整大*等。

从实践的角度来看，有一个健壮的模型来进行这样的转换是很好的。以下类似的逻辑组织者用以下变换之一修改了一半的测试图像:

• 质量因子= 70 的 JPEG 压缩
• 质量因子= 90 的 JPEG 压缩
• 通过因子 0.5 调整大*(通过双三次插值)
• 通过因子 0.8 调整大*(通过双三次插值)
• 通过因子 1.5 调整大*(通过双三次插值)
• 通过因子 2.0 调整大*(通过双三次插值)
• 使用 Gamma = 0.8 进行 gamma 校正
• 使用 Gamma = 1.2 进行 gamma 校正

Jpeg compression with quality [5, 15, 25, 35, 45, 55, 65, 75, 85, 95]

Gamma Transform with quality [0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75]

正如我上面提到的，在不同的图像主机上有数 Pb 的图像，我们可以从中提取相机模型。Kaggle 的各种比赛对外部数据有不同的规则，但在这种情况下，这是允许的。一般来说，所有允许外部数据的竞赛都有一条规则，强制所有参与者也可以访问这些数据。在任何此类比赛中，论坛上都有一个主题，参与者可以分享他们计划使用的数据和预先训练的模型。

这次比赛是个例外。管理员忘记在规则中加入关于共享数据的句子。这改变了游戏。

深度学习模型的好处在于，由于容量大，它们通常会受益于用于训练的数据量。同样重要的是，许多火车标签可能是错误的。这很好。只要错误标签的百分比低于 15%，你就没事。你使用的数据越多，你的模型就越好。

参与者可能不是法医专家，但他们肯定知道更多数据对 DL 更好的事实。这改变了竞争的态势。通常，在竞争中，您会试图从给定的数据集中获取最多的信息。经过一些实验后，你选择一个性能良好的模型，聪明地选择你的增强，探索领域知识，花时间制定一个智能训练计划，损失函数等。如果你没有更好的选择，所有这些都很重要。但是我们做到了。

Flickr，Yandex，Fotki，Wikipedia commons 都被废弃了，该团队拥有的原始图像数据总量约为 500Gb。我们可以使用所有这些数据，但是为了加速训练并潜在地提高模型的质量，我们进行了过滤。

对于训练，我们想要未经处理的数据，这意味着不受 Photoshop 或 LightRoom 或类似图像编辑软件的影响，不调整大*，并且是高质量的。

首先，我们删除了元数据中包含 Photoshop 和 LightRoom 的图像。其次，我们删除了 Jpeg 质量低于 95 的图像。第三，我们知道不同的相机以固定的尺寸拍摄照片。如果图像的大*与我们预期的不匹配，我们认为它被调整了大*。我们删除了不符合这些标准的图片。

这并不意味着我们得到的所有图像都是未经处理的，比如有人可能使用 10%质量的 jpeg 压缩，然后再使用 99%质量的 jpeg 压缩。实际上它仍然是 10%，但是对于我们的软件来说，很难发现它是 10 而不是 99。我不想说“困难”，我想说不可能，但是回想一下，在研究这个问题时，我看到过试图识别“双重 jpeg 压缩”的论文。再说一次，我甚至不知道有这样的问题存在。

过滤后，我们有 78807 个废弃的图像，它们被认为是原始的和未经处理的。阶级分布不均匀。正如人们所料，并非所有手机都同样受欢迎，或者手机型号与机主拍照并上传到互联网的频率之间存在相关性。因此，对于某些类，我们有更少的图像。

Camera model classes with the number of samples each part of the dataset. The table presents the final dataset, which contains external and organizers datasets.

From https://habr.com/company/ods/blog/415571/

总的来说，这是一个从 ImageNet 学习的过程。你拿一个预先训练好的网络，去掉预测 1000 个类的最后一层，换成预测你需要什么的一层。在我们的例子中，这个数字是 10。在此之后，您使用分类交叉熵来计算您的损失，并训练网络。第一名和第 50 名的区别通常不在于你使用的网络类型，而在于培训程序和进行培训的人。从实践的角度来看，深度学习仍然是炼金术多于科学。因此，当一个人从事不同的工作时，发展出来的直觉是至关重要的。

对 PyTorch 有影响力的网络有一个很好的列表，那就是雷米·卡登 https://github.com/Cadene/pretrained-models.pytorch的回购。人们可以使用类似的 API 访问不同的网络和预先训练的权重，从而快速进行实验。这种回购被挑战的参与者广泛使用。团队试验了 Resnet、VGG、DPN 和所有其他类型的网络。

对于这个问题，一个经验主义的结论是 DenseNet 工作得稍微好一点，但是团队之间的差异是如此之*，以至于它是真是假还不清楚。

什么是 DenseNet？DenseNet 是一种体系结构，它将在 Resnet 类型的网络中使用跳过连接的思想推进了一步。

https://arthurdouillard.com/post/densenet/ https://arxiv.org/abs/1608.06993

更多被跳过的连接给被跳过的连接之神！

DenseNet 论文的作者将卷积块中的所有层连接起来。跳跃连接简化了梯度的流动，使得训练深度网络成为可能。在 skip connections 成为主流之前，处理只有 19 层的 VGG19 是一件痛苦的事情。在引入它们之后，具有 100 层以上的网络可以处理非常高级的抽象功能，不再是训练的问题。

还认为损失曲面变得更平滑，防止训练陷入许多局部最*值。

https://arxiv.org/abs/1712.09913

除此之外，网络比较规范。一组卷积块，具有批范数和 ReLu 层，在块之间有最大池。全球平均池和密集层在最后。有必要提及的是，存在全局平均池层的事实允许我们使用不同大*的图像作为输入。

有些人认为 DenseNet 总是优于 Resnet，因为它是后来推出的，并成为 2017 年 CVPR 最佳论文。事实并非如此。在最初的文章中，DenseNet 在 CIFAR 上显示了良好的结果，但是在更多样化的 ImageNet 数据集上，更深的 Densenet 需要在准确性上匹配更浅的 ResNet 网络。

DenseNet 比 Resnet 好/差？看情况。在星球:从太空挑战中了解亚马逊，DenseNet，我们的团队在 900+中获得了第 7 名，在这个相机检测问题上表现更好。但在 ImageNet 上，情况更糟。

我与我的合作者进行了一次讨论，有人提出跳过连接不仅提供了良好的光滑损失表面，而且还降低了模型容量。这可能解释了为什么 DenseNet 在像 CIFAR 这样的非多样性问题中表现得更好。尽管如此，人们需要增加网络的深度，以弥补更多样化的 ImageNet 数据集的容量损失。基于这种推测，人们可能会想到 DenseNets 工作良好的用例是当数据集不是非常多样化并且不需要大容量时。尽管如此，区别性特征是高水平的，这可能需要非常深的网络。

摄像机检测任务属于这一类吗？我不知道。经验上是的，但是证据不足。

将智能正则化添加到训练过程的标准方法是使用增强。不同的问题可能受益于不同的增强，同样，你的直觉越好，你就可以选择更好的增强及其参数。

对于这个问题，我们使用:

• 二面角组 D4 变换:旋转 90 度、180 度、270 度和翻转。
• 伽玛变换。我们从[80，120]范围内统一选择伽马参数。
• 参数从 70 到 90 均匀采样的 JPEG 压缩。
• 重新缩放变换，从[0.5，2]范围中选择比例。

在代码中，使用相册库，它可以被描述为:

import albumentations as albu def train_transform(image, p=1):
    aug = albu.Compose([albu.RandomRotate90(p=0.5),
                        albu.HorizontalFlip(p=0.5),
                        albu.RandomGamma(gamma_limit=(80, 120), p=0.5),
                        albu.JpegCompression(quality_lower=70, quality_upper=90, p=0.5),
                        albu.RandomScale(scale_limit=(0.5, 2), interpolation=cv2.INTER_CUBIC, p=1)
                        ], p=p)
    return aug(image=image)['image']

Left is the original image from my recent rock-climbing trip to Bishop, and right is flipped and a bit darker. The latter is the effect of the gamma transformation. Jpeg compression was also applied, but it is hard to find its effects because quality [70:90] is relatively high.

组织者告诉我们，他们使用三次插值来调整大*。如果我们没有这些信息，我们可以在不同插值之间交替使用。一般来说，竞争激烈的 ML 社区经常使用这个技巧，但是我还没有在文献中看到它。

无论如何，如果我们想要添加这种改变，代码会更复杂，但仍然相对透明。

import albumentations as albu def train_transform(image, p=1):
    scale_limit = (0.5, 2) aug = albu.Compose([
        albu.RandomRotate90(p=0.5),
        albu.HorizontalFlip(p=0.5),
        albu.RandomGamma(gamma_limit=(80, 120), p=0.5),
        albu.JpegCompression(quality_lower=70, quality_upper=90, p=0.5),
        albu.OneOf([albu.RandomScale(scale_limit=scale_limit, interpolation=cv2.INTER_NEAREST, p=0.5),
                    albu.RandomScale(scale_limit=scale_limit, interpolation=cv2.INTER_LINEAR, p=0.5),
                    albu.RandomScale(scale_limit=scale_limit, interpolation=cv2.INTER_CUBIC, p=0.5),
                    albu.RandomScale(scale_limit=scale_limit, interpolation=cv2.INTER_AREA, p=0.5),
                    albu.RandomScale(scale_limit=scale_limit, interpolation=cv2.INTER_LANCZOS4, p=0.5),
                    ], p=0.5),
    ], p=p)
    return aug(image=image)['image']

原始图像的分辨率很高。在全分辨率下重新调整它们是不明智的。因此我们连续收获了两季。一个在调整大*之前，一个在调整大*之后。

import albumentations as albu def train_transform(image, p=1):
    aug = albu.Compose([
        albu.RandomCrop(height=960, width=960, p=1),
        albu.RandomRotate90(p=0.5),
        albu.HorizontalFlip(p=0.5),
        albu.RandomGamma(gamma_limit=(80, 120), p=0.5),
        albu.JpegCompression(quality_lower=70, quality_upper=90, p=0.5),
        albu.RandomScale(scale_limit=(0.5, 2), interpolation=cv2.INTER_CUBIC, p=1)
        albu.RandomCrop(height=480, width=480, p=1),
    ], p=p)
    return aug(image=image)['image']

使用初始学习率为 0.001 的 Adam optimizer 对网络进行 100 个时期的训练。

为了获得更好的精度，当学习率在不同值之间振荡时，我们还使用了循环学习率方法。

正如你从这张图片中所猜测的，学习率在 17 世纪左右下降了。

同时，在 42°左右和 53°左右有两个连续衰减的损耗峰。在训练过程中，网络往往会陷入局部最*值，而这些振荡有助于摆脱它们。

在推断时，我们执行测试时间增加，平均来自测试图像的不同 480x480 裁剪的预测。

我们还对估计不同的转换如何在推理时降低模型的准确性感兴趣。

绿色表示训练中使用的参数范围。

正如预期的那样，在模型被训练的范围内，精确度没有显著降低。这表明，如果使用深度学习方法并拥有足够数量的数据，增加所应用的增强的范围可能会导致更稳健的模型。

我们想要回答的另一个问题是，如果我们在测试时减少输入到网络的作物的输入大*，精确度会如何？

我会认为网络正在学习的特性是如此的局部化，以至于不需要大规模的裁剪，但是看起来事实并非如此。为了使 10 个类别的准确率达到 90%以上，人们需要至少 250x250 的作物，这可能意味着后处理算法会在网络捕捉的像素之间创建长距离相关性。

我们还希望验证，当训练数据量增加时，模型的准确性也会提高。从图中可以看出，这种情况并没有发生。我想我们的最低数据点 25k 对于高质量的模型来说已经足够了。如果我们需要检测的不是 10 个，而是 1000 个类别，那么作为训练数据的函数，模型质量的提高可能会更明显。

总结:

• 来自 ImageNet 的迁移学习即使对于像照相机检测任务中的那些低级特征也工作得很好。
• DenseNet 表现更好，但我们认为，人们可以从 Cadene 的列表中选择任何预训练网络，它会表现类似。
• 在训练期间应用增强可能有助于使模型更健壮。
• 如果你能得到更多的标签数据，那就去得到它。在许多(但不是全部)问题中，使用大量数据的蛮力可能比复杂的解决方案更容易使用。尽管利用领域知识可以增加重要的额外推动力。

课文中跳过的内容:

• 添加额外的输出来判断图像是否被操纵有意义吗？
• 像检查点平均这样的技巧。
• 其他架构表现如何？
• 如何完成这项任务？
• 如何利用测试中的类是平衡的？
• 如何将伪标签应用于此任务。
• 讨论我们尝试了什么，但它在这个任务中不起作用。
• 网络了解到的特征有哪些？
• 此问题评估标准的细微差别。

所有这些话题都很重要，但我并不认为它们有很大的影响力，或者我更愿意对每一个话题进行单独的讨论。

P.S .参加 2018 年 12 月 10-13 日在美国西雅图举行的 2018 年 IEEE 大数据国际会议的人。参观第二届网络犯罪调查和预防大数据分析国际研讨会的研讨会并问好:)

帮助编辑:埃里克·加塞德伦

2018 年需要关注的四大分析趋势

原文：https://towardsdatascience.com/four-analytics-trends-to-keep-an-eye-on-in-2018-854646e390f6?source=collection_archive---------12-----------------------

Courtesy:Flickr

当你想到 2018 年的分析时，是什么让你早上起床？是 AI 在我们生活中的突出地位、数据的民主化还是高级分析让你感到兴奋？让我们接受这一点，去年是多事之秋，自助分析、物联网分析以及聊天机器人变得越来越智能。感受到这些发展，2018 年应该成为分析行业加速创新的又一年-当然会有一些预期和意外的中断！激动吗？毫不费力地阅读我们在 2018 年要关注的四大分析趋势！

人工智能聊天机器人不再是镇上的“新手”，很快将成为所有操作的主要驱动力！

“Siri，今晚我该看哪部电影？或者“谷歌，告诉我去办公室的最佳路线”，熟悉这些日常对话？想象一下没有他们的生活吧！可以吗？不太可能，对吧？考虑到它们对我们繁忙生活的影响。2017 年，围绕智能推荐有太多的噪音，人工智能聊天机器人可以识别我们的情绪，并相应地回应我们。不仅是关于天气或交通拥堵的更新，聊天机器人将会发展，还可能有助于搜索财务运营指标或获得“为什么”和“如果”问题的答案，从而实现商业和消费者空间的转型。尽管这可能需要几年时间才能成熟，但我们可以预计 2018 年也不会有多少成功故事。

增强现实:从卷轴到现实，增强现实正在并将改变我们周围的世界

还记得 2016 年 7 月，数百万人如何穿过公园，走过人们的坟墓，进入教堂，寻找增强现实版的神奇宝贝角色。记忆犹新，对吧？虽然口袋妖怪的狂热已经消退，但增强现实却没有，我们可以在 2018 年看到一些更先进和更动态的 AR 模式。随着企业已经在使用 AR 来增强制造和研究流程或提供新的客户体验，人机交互将会增强。为什么这对分析行业很重要？根据 Gartner 副总裁 David Cleary 的说法，“增强分析是一个特别具有战略意义的增长领域，它使用机器学习来为广泛的企业用户、运营人员和公民数据科学家自动化数据准备、洞察发现和洞察共享。”因此，是的，在几年内，所有的资源消耗和时间敏感的分析将大大变得容易和流畅的增强分析！

物联网分析:2018 年，每个行业的银弹？

2017 年，是“互联互通”收获巨大的一年。尽管存在大量安全问题，但围绕物联网还是有很多投资和采用。2018 年怎么样？物联网分析会像 2017 年一样激动人心吗？不可忽视的是，物联网今年也将继续扩展，几乎每秒钟都会有越来越多的设备联网。尽管零售、医疗、和工业/供应链行业一直在使用物联网来提高投资回报率，但今年我们可以看到越来越多的公司将物联网用于更加个性化的营销工作。此外， Business Insider 预测，到 2021 年，企业在物联网解决方案上的支出将达到 6 万亿美元。根据这一预测，我们将看到许多风险投资家继续向物联网的承诺投入资金，这凸显了物联网在几乎每个行业改善客户体验的潜力！

区块链科技:实现新形式的数据货币化

所有人都同意，2017 年是区块链取得巨大增长的一年？许多人认为我们已经处于采用的“早期多数”阶段，并且我们正在朝着完全采用区块链的方向前进。与任何新技术一样，数据的重要性也在增长。今年，我们可能会看到区块链变得更加主流，医疗保健和零售等行业也开始使用它来处理数据，以防止黑客攻击数据泄露。根据戴尔 EMC 服务首席技术官 Bill Schmarzo 的说法，区块链技术还“有可能通过消除促成交易的中间人，使数据和分析的共享和货币化民主化。”因此，是的，组织将加快对这些虚拟货币的数据分析过程，以揭示强大的趋势、欺诈和洞察力，并做出明智的决策！

如何搭上虚拟货币涨势？请继续阅读，了解更多信息。

虽然很难说这些分析趋势会以多快的速度在我们的生活中体现出来，但我们相信 2018 年将再次成为多事之秋。将会有关于安全、治理以及最重要的消费者接受和适应这些创新和变化的能力的问题。唯一可以确定的是，今年的未来会有所不同，非常有希望！敬请关注！

四个破碎的系统& 2018 年的四大技术趋势

原文：https://towardsdatascience.com/four-broken-systems-four-tech-trends-for-2018-bd4698a3bef0?source=collection_archive---------11-----------------------

我受邀在未来女性活动上发表关于 2018 年科技趋势的演讲。未来女性是一场由现任和有抱负的女性企业家组成的运动。我非常钦佩这类女性，所以我很荣幸被邀请来演讲。此外，这是一个多么吉祥的方式来结束这一年，被要求思考未来，所以这里有一些关于这个巨大的话题的想法。

免责声明:我来自天体物理学，偏爱数据科学、统计学和目前归入机器学习和人工智能范畴的算法家族。

如何看待技术趋势这个话题？关于这方面的报道、刊物、文章、领域 - 具体、分析、、信息图。如何在这个时髦词汇的海洋中航行，并试图理解它对我们明年或以后的人意味着什么？我的出发点是问:

什么坏了？哪些在 2017 年行不通的，在 2018 年应该会更好？

虽然这个列表可能很长，但我想到了 4 个系统，它们在 2017 年表现出了多么不合适、不准确或彻底崩溃。

1.社会和政治工程

2017 年，社交媒体网络证明，它们并不像以前宣称的那样是一股团结的力量，在世界各地的人们之间建立桥梁。事实上，社交媒体平台恰恰相反，它分化了社区，分裂了社会，暴露了深刻的意识形态分歧，并以 YouTube 评论中首次发现的恶意和攻击性进行辩护。事实证明，南非本身并没有*到可以不被旨在煽动党派观点的推特机器人所注意。

我们已经看到公关公司改变公众舆论，加剧政治动荡，外国国家 利用社交媒体平台影响其他国家的投票和选举。我们已经看到政治预测者，从传统的民意测验专家到前沿的统计分析师都搞错了。

很明显，这没用。

2.传统(技术)教育

每年都有很多声音描述教育系统是如何崩溃的。虽然这可能是真的，而且太大了，无法在这里解决，但我认为专注于技术教育会很有趣，因为那里正在发生一些非常有趣的事情。

问题是，许多公司认为他们不能雇佣大学毕业生，因为他们(T2)不能像这些公司所希望的那样立即投入运营。南非的毕业生失业是一个问题。有一些努力。金伯利的 Sol Plaatjie 大学于 2014 年成立，专注于数据科学。像 Coursera 、 edX 、 Udacity 和 others 这样的大规模开放在线课程平台现在不仅提供课程，还提供专业学位，或者纳米学位，这些学位捆绑了一组急需的技能。这些在线学位在就业市场上越来越受到重视，以至于许多大公司，如微软，在这些平台上开设了许多认证课程。

让这个领域的创新变得有趣的另一个方面是不同商业模式的出现，以及除了赚钱之外的其他激励手段的使用。我想到的例子有 Insight 数据科学奖学金、 Ecole 42 以及它的南非版本，最优秀的我们认为代码 _ 。在这些科技教育机构中，学生不负责学费，但需要他们培养的人才的企业负责。这极大地改变了游戏的可访问性。Ecole42 和我们认为 code_ 在资格方面没有任何先决条件。没错。有人可能在 15 岁就辍学了，但仍然被录取，只要他们通过了在线解决问题技能测试。它不是对知识的测试，而是对人们如何处理问题的测试。这是大多数学校都不教的。

3.数据管理

今年我们已经看到了历史上一些最大的数据泄露事件，以及一些最大的掩盖事件。无论是优步、Equifax 还是雅虎，至少有一个漏洞最有可能影响到我们每一个人。在南非，我们已经看到一个数据泄露事件泄露了身份证号码和其他个人信息，这些信息可能被用于身份盗窃。

这里的问题是激励、所有权和风险都以错误的方式分配。我们都从系统中受益，大公司利用我们的数据来销售有针对性的广告，作为交换，我们愿意将我们的数据交给他人，这样我们就可以免费使用社交网络、网络平台和搜索引擎。当出现漏洞时，问题就来了。虽然这些大公司可能拥有数据，但他们不承担违规带来的风险。这种风险——身份盗窃、信用卡滥用等等——仍然由我们自己——消费者——承担。因此，应用能够抵御越来越聪明的黑客攻击的适当数据安全措施的动机不在于拥有和保存数据的大公司。完整的报告存在于被盗数据经济中；事实证明，在黑暗网络上，一个身份并不昂贵。

这些待售的身份不是大公司的信息，而是你我的。很明显这没用。

这个问题如此严重，以至于有些人投入巨资试图改变这种状况。这里面有很多钱。

4.人工智能应用传播其创造者的偏见

今天使用的人工智能算法主要建立在机器学习算法的基础上，这些算法经过编程，然后根据数据进行训练。这为算法和训练阶段的偏差留下了空间，后者可能是最能揭示问题的。AI 的偏见已经在 2017 年被多家主要刊物彻底记录。(请点击所有这些链接了解更多信息，有些文章可能在付费墙后面)。

下面的两个例子说明了这些偏见有多普遍。

第一张图片是谷歌图片搜索“正面”的屏幕截图，带有额外的彩色图片过滤器和知识共享许可，允许我在其他地方显示图片。寻找一张脸，我得到了一个雕像，一幅画，一座建筑，两只动物，但只有一个黑人。这实质上意味着，当搜索一张脸的图像时，黑色的脸出现的频率不会比动物和建筑物之类的错误更高！这不仅是对世界面孔的拙劣表现，也是一种完全有偏见的信噪比。

在第二个案例中，我的一个朋友玩了剑桥大学(Cambridge University)开发的在线人工智能服务，该服务通过分析推文或 facebook 帖子获得人口统计数据。不用说，我的朋友、我自己和一大群女科学家立即被贴上了男性标签，提出了一个合理的问题:“在人工智能时代，泛化是合理的吗？”。

答案当然是否定的。因此，这显然是行不通的。如果我们要信任我们的人工智能，我们都需要改进它，并记住人工智能会错过的边缘情况。我们必须比人工智能更聪明(我们也能)。

这涵盖了 2017 年的一些重大破事，以我谦卑和人性偏见的观点来看。现在谈谈我(和许多其他人)预见的一些有趣的技术趋势。

2018 年，技术可能会对我们的生活产生怎样不同的影响？

同样，这不是一个详尽的清单。我刚刚确定了四个有趣的趋势，我渴望看到发展。这个列表有一个偏差，因为这主要是对消费者可见的技术，如果不是直接的消费者技术的话。在工业和研究领域有着迷人的技术发展，我们无法直接看到，这是一个全新的探索世界。

1.与机器人一起工作和生活

几年来，这已经成为许多科学家的标准，但这仍然有助于科学研究。从用于寻找水污染源头的机器鳗鱼到学校认可的隐形 T2 机器斑马鱼，机器人技术正以创造性的方式应用于尖端领域。离我们更近的是，机器人手术正在成为许多医生的现实(伴随着过渡期的自然痛苦)，因此也成为病人的现实。更有趣的是，价格实惠、外观自然的个性化智能假肢的兴起。有了 3D 打印，假肢不再需要看起来像商店橱窗里的人体模型，它们可以适合任何个人。随着神经修复术的进步，现在这是真正的机器人生活。

我认为，我们还将看到机器人更多地进入我们的物理空间。除了电话号码末尾的机器人，或者管理我们的社交媒体，我们将开始看到它们。任何自动驾驶车辆实际上都是机器人，无论是自动驾驶汽车、穿梭车、卡车，还是无人驾驶飞机、室内或室外，机器人正在变得可见，它们将很快成为我们生活环境的一部分。

2.消失的界面

在过去，我们会出去购买一些技术来访问一些东西，无论是听音乐的随身听，玩游戏的游戏机，还是阅读电子邮件的电脑。现在，这种情况似乎越来越少，我们不再需要购买更多的技术，而是回来坚持使用几十年来我们一直使用的一些产品，这些产品似乎会一直存在下去；汽车，手表，电话，娱乐系统。我们喜欢的一切的界面开始存在于那些对象中，但是在它们之间无缝导航。我们从手机上听音乐，但当我们开始开车时，汽车会接管它，它会接下一个电话，等等。

界面现在正在消失，无处不在，这为未来几年带来了一些非常有趣的机遇和挑战，从界面/交互设计到数据和隐私。期待看到 2018 年这个趋势会如何发展。

1. 人工智能作为一种商品

人工智能是不可避免的。它将贯穿我们的大部分工作。人工智能有一些非常有趣的创造性应用，例如根据难民被重新安置的地点优化他们获得就业的机会，到你的普通聊天机器人。不同的是，现在人工智能正在变得商品化，因此，任何人都可以将其纳入他们的产品和服务。这种商品化有三个主要方面:

• 开源软件
  tensor flowSparkpy brainopen nn等。一些最好的人工智能和机器学习库是开源的。不再躲在专有的微调算法后面。除此之外，还有丰富的免费在线课程，几乎任何人都可以学习将机器学习和人工智能应用到自己的业务中。
• 例如，如果没有大量数据来训练机器学习算法，那么可以通过 API 轻松访问预先训练的引擎。比方说，每次调用分析一张图片或一些文本，都不再非常昂贵。所有大公司都有一套全面的人工智能 API 可供使用；微软 Azure 的认知服务，谷歌的云服务——比如针对语音、视觉和自然语言，或者亚马逊的认知。
• 边缘计算
  在我看来，这是一个特别有趣的问题。以前，如果你环顾互联设备的世界，你几乎可以说物联网主要是一堆互联的传感器，收集数据并在其他地方集中分析，因此需要连接。现在，世界各地的芯片制造商已经意识到 GPU 革命——图形处理单元(通常在游戏电脑中发现)比普通 CPU、中央处理器——笔记本电脑和手机中的芯片等更有效地用于机器学习和人工智能。去年我们已经看到了主要芯片制造商在发布了一系列公告，这是一种为人工智能设计的新型芯片；神经形态计算(称为神经形态，指大多数人工智能使用的神经网络)。芯片就是芯片，它们往往价值数十亿，而且价格低廉。这将在传感器所在的边缘带来负担得起的人工智能硬件能力。我相信这将改变我们对世界上人工智能应用的看法，我很高兴看到这将引领我们走向何方。

4.区块链

最后，我必须提一下这种“房间里的大象”技术，我不是这方面的专家。我了解它的工作原理，但不要问我加密货币和交易所之间的具体区别。区块链是加密货币的基础技术，据观察，在中央当局不再受信任的地方，这些加密货币提供了有吸引力的替代方案。他们也吸引了有着邪恶目的的组织。这让我想到了区块链科技的两个特点，正是这两个特点让它成为了游戏规则的改变者:

• 可信的分散化取代不可信的集中式系统
• 数字人工制品的独特性

第一点是，为什么加密货币在中央经济当局陷入困境或不受信任的国家如此有吸引力。它可以应用于合同、供应链等。第二点是前所未有的。在此之前，用数字人工制品区分原作和复制品的能力是不可能的。这可以保证艺术品的真实性，限制版权材料的复制等。

我将把它留在这里，不做进一步的开发，但我认为重要的是不要被围绕加密货币的所有宣传所蒙蔽，要看到这项技术的独特性，也许要看看它可以在任何行业中实现什么。2018 年无疑会看到一些有趣的应用从加密货币价值波动的噪音中出现。

最后

因为这是写给企业家的，所以我决定思考一下机会在哪里。我的印象是，光有技术和要解决的问题是不够的，还需要正确的经济激励模式，这里有大量创造力的空间，这是我试图说明的。

如果你有时间继续读下去:

我想强调的最后一点是经济激励的“超越企业社会责任”思想。

在这篇文章中，有两个双赢的例子，一点也不仁慈。第一个是 we think code_(和 Ecole 42)的商业模式。通过资助学校，雇佣他们毕业生的公司可以被视为自私地照顾他们的利益，即解决他们所需人才的稀缺问题，但事实上远不止如此。在南非，一个有工作的人常常要养活整个家庭，通常也是一个大家庭，特别是如果他们进入编码学校时没有主要资格证书，这有助于减轻贫困的可怕影响。因此，除了这种模式本身的双赢之外，还有一个额外的积极副作用。

第二个例子是大赦国际申请重新安置难民，以增加他们找到工作的机会。虽然这个例子不是来自私营部门，学术界的回报/货币是科学出版物，这显然导致了至少一个。但它也应用了尖端技术来造福那些利益往往被放在最后的人。此外，结果，更高的就业机会，直接导致更好的融合，看到融合是双向的，也导致更多的宽容。因此，除了这个项目的双赢之外，还有一个额外的积极副作用。

底线是，通过进一步关注而不仅仅是一个单一的受益者，一个人可以围绕价值/财富/健康创造和技术的生成链进行创新，这是不可能改变的。

针对实时分析的大数据堆栈四败一胜

原文：https://towardsdatascience.com/four-fails-and-a-win-at-a-big-data-stack-for-realtime-analytics-4f82f651d476?source=collection_archive---------8-----------------------

构建一个用户友好的应用程序来实时分析大数据(即保持响应时间低于 60 秒)是一项挑战。在大数据世界中，你要么进行批量分析，没有人真正关心查询时间(大多数企业)；或者你在做流媒体(优步、脸书和 kin)，在这种情况下，查询时间至关重要，但数据总量很大——每个用户只看到或使用很*一部分，并且后台正在进行批处理作业。

我正在开发一个 web 应用程序，该应用程序使非数据科学家用户能够实时构建和可视化地理数据的复杂分析，随着我们的数据和用户以及我们产品复杂性的增长，我们不得不修改堆栈以满足性能标准。我们的问题似乎应该是一个常见的问题，但奇怪的是，在用户友好的时间框架内对大量数据进行密集只读计算的指导非常少。

How analyses look in the web app

一年前，我还不是大数据领域的专家，这个领域有足够多的工具、术语和观点，很难知道从哪里开始。我还不知道所有的答案，但我已经想出了足够的办法，可以试探性地、谦恭地帮助其他人朝着对我们有用的堆栈前进。

失败 1:幼稚的 Postgres

首先，我会说不到万不得已不要修改你的堆栈。这可能是数据应该被视为大的时候——当您现有的基础设施难以应对时。我们愉快地用 SQL 做了很长时间的事情。Postgres 是一个令人惊叹的数据库，我的经验是，通过正确的索引和构造良好的查询，可以实时聚合和查询多达 8000 万行的表。

(虽然我提到了地理空间领域，但在本文中，我并不是在谈论地理计算，比如使用 PostGIS 。它们在计算上非常昂贵，但是我们在最初的 ETL/数据摄取过程中完成了大部分工作。)

不幸的是，执行所有必要的数据库*护、找出正确的索引以及编写和重写查询可能相当痛苦。您还必须将数据正确地存储在整齐规范化的行和列中。

失败 2:反规范化

还是你？总的来说，保持 SQL 数据的规范化和单一的真实来源是好的，但是复杂和频繁的表连接会降低性能。由于我们无法再满足用户的需求，我们不得不停止愚蠢的查询，并对一些较大的表进行反规范化。比如说，

这需要我们在 ETL 步骤中做更多的工作，并确保良好的数据治理，但这大大提高了速度。为了在团队规模保持不变的情况下弥补额外的时间，我们从自托管 Postgres 迁移到 AWS Aurora Postgres。性能没有改变，但它确实消除了一些数据库管理难题。

失败三:极光

只不过这也带来了新的性能问题。我们的应用程序的最大特点之一是，它可以根据用户指定的标准，对城市的微*六边形区域进行评分和聚类。一个城市可能由 50 万个六边形组成；对于每一个妖术，用户可能想要根据其夜间居民和白天工作者的中值收入和心理特征，以及它离最近的星巴克有多远来评价它。这需要大量的数据和计算。

迁移到 Aurora 让我们失去了将数据保存在自己机器的内存缓存中的能力。当不同的用户试图依次或者更糟的是同时给不同的城市打分时，数据被拉入(大概是从 S3)并从我们的虚拟机中弹出。这种数据加载时间，就像某种页面抖动一样，大大超过了计算时间:最终结果是，当数据可用时，一个城市的得分需要 3 分钟——对于打算实时进行的事情来说，这本身不是一个很好的结果——迅速增加到 10 分钟或超时。

现在，在大数据领域，我可以说，我并没有参与太久，目前“没有人因为收购 IBM 而被解雇”的是 Apache Spark。我努力着手创建一个 Spark 机器集群，看看它是否能有所帮助。

由于我们现在处理的表有数亿行，Postgres 运行缓慢，如果我们的应用程序要扩展，就必须对数据进行分区，并在多个节点上进行计算。

次要胜利 1:集群

多亏了 Kubernetes 和 Kops，在 AWS 上创建一个集群并不困难。

此时，您将获得一批新的 AWS 资源，包括集群主机和计算节点的实例。Docker 容器可以部署到这些实例中，由于 Kubernetes magic，它们将能够相互通信，与同一 VPC 上的其他机器通信，如果您选择通过暴露的负载平衡器与外界通信。

借助 Helm ，我能够快速启动并运行一系列 Spark 节点，以及一些用于 HDFS 文件存储的 Hadoop 节点。

失败 4:火花

我发现 Spark 很难管理，很难使用(它都是 Java 的，并且是为 Java 应用程序设计的，尽管 PySpark 的承诺可能会让您相信)，而且总体来说没有那么快。

我确信 Spark 可以在一些人的批处理工作流中发挥作用，并且我知道它也有流扩展。然而，即使是简单的工作也需要几分钟来启动机器，这使得它在实时用例中毫无用处。

此外，HDFS 跑得并不快，现在我们有了 S3，这看起来有点无关紧要了。

此外，如果你像我一样来自 Python 生态系统，就不可能不去想念我们所拥有的大量工具。如果你是这样的人，并且你今天正在开始或发展一个大数据项目，我知道有一个更好的方法。

胜利:与 Dask 一起分发*猫

Pandas 处理数字数据的速度已经是最快的了。数组计算以本机速度进行(感谢 Cython ),并且经常利用向量指令(感谢 NumPy)。

尽管如此，我一直认为 Pandas 实际上是用于处理数据的 ETL 和分析部分；更像是一个数据科学工具，而不是一个可以部署到生产中的库。我错了:

*猫已被广泛应用于生产和金融领域

Dask ，Anaconda 背后的同一批人制作的分布式计算库，将大型数据帧划分到不同的节点上，在这些节点上调度并行计算(构建一个图，像 Spark 一样将计算延迟到最后一分钟)，收集结果并管理分布式数据。它与*猫集成在一起，并且在很大程度上可以与*猫互操作，所以一起工作是一种乐趣。

(不是 100%；有些事情，例如在多列上索引一个数据帧，对于一个分区的数据帧没有意义)。

而且速度很快:每个节点都利用了 Pandas 及其矢量化的代码。分布式计算不是免费的；Dask 需要一些时间和网络延迟来构建图形和调度每个节点的计算，以及在最后合并/减少数据。如果能够将整个数据帧放入内存，基本的 Pandas 会更快——如果我们扩展我们的基本机器，这是可能的，但这不会永远持续下去:我们仍然需要在某些时候水平扩展我们的平台。

用 Dask 编码很大程度上是熟悉的。例如，下面是 SQL SELECT MAX(col + col2) FROM table WHERE zip_code IN ('94105', '94106') AND day_of_week IN (1,2,3)的替换

from dask.distributed import Client
import dask.dataframe as dd
c = Client('172.x.x.x:8786')
df = dd.read_parquet('s3://my-bucket/mydatafile.parquet')
df = c.persist(df)
subset = df[df["zip_code"].isin(['94105', '94106']) & df["day_of_week"].isin([1,2,3])]
df["sum"] = df["col1"] + df["col2"]
print(df["sum"].max().compute())

将 Dask 部署到我之前制作的 Kubernetes 集群中也是相当容易的:他们有自己的掌舵图记录在这里。我们的基础设施现在看起来像这样:

• 单片 Node.js 后端
• 它调用 Python 微服务(用 Flask 构建，并将任务队列与 SQS 集成)
• 连接到集群并指示节点
• 从 S3 下载他们的数据部分(使用预先分区的 Parquet 文件非常快，因为从每个节点的读取是并行发生的)
• 用 Dask/Pandas/NumPy 处理其数据
• 并向后端返回一个 JSON 响应，后端将其转发给客户端 webapp

在 Postgres 中需要几分钟的分析，如果需要从持久存储中读取数据，则通常需要更长时间，现在不到 30 秒就可以返回到客户端。

结论

如果你有钱花，尤其是如果你还没有证明产品/市场适合，就去找供应商解决方案。一个快速的、面向列的内存 SQL 数据库不需要对我们的流程和代码做太多的修改。

否则，对于作为 SaaS 的一部分实时处理大数据，我建议看看 Dask 是否能满足您的需求:它速度快，可水平扩展，允许您使用您习惯的相同库以相同的方式编写代码，并且它目前正在生产中使用(至少被我们使用)。

显然，我认为 Dask 杀死了 Spark，但是如果你感兴趣的话，Dask 的作者确实给出了一个更微妙的观点。

傅立叶变换及其数学

原文：https://towardsdatascience.com/fourier-transformation-and-its-mathematics-fff54a6f6659?source=collection_archive---------1-----------------------

信号分解、时域和频域

source

简介

傅立叶变换(FT)将信号分解成组成它的频率。

这是什么意思？

所以，我们来举个例子。让我们有一个信号 S1。

S1: x-axis is time and the y-axis is amplitude

如果我们想在某个特定的时间测量这个信号的强度。我们用它的 振幅 来衡量。

所以，信号 S1 的振幅是 1

如果我们对另一个信号进行同样的操作，选择相同的时间点，测量其幅度。让我们有另一个这样的信号 S2

S2: x-axis is time and the y-axis is amplitude

同样，信号 S2 的幅度是 2

现在，我们同时发出这两个信号(S1 和 S2)会发生什么？

因此，当我们在同一时刻发射这两个信号时，我们会得到一个新信号，它是这两个信号幅度的之和。这是因为这两个信号被加在一起。

S3=S1+S2: x-axis is time and the y-axis is amplitude

所以，S3 的幅度= S1 的幅度+S2 的幅度= 1 + 2 = 3
所以，信号 S3 的幅度是 3

现在，有趣的问题是:

如果只给我们信号 S3(也就是信号 S1 和 S2 之和)。我们能恢复 S1 和 S2 的原始信号吗？

是的。这就是傅立叶变换的作用。它接收一个信号，并将其分解成组成该信号的频率。

在我们的例子中，傅立叶变换会将信号 S3 分解成其组成频率，如信号 S1 和 S2

但是，我们怎么才能恢复原来的信号呢？傅立叶变换能为我们做什么？

y-axis is the strength of the signal (amplitude)

假设上图中的三个信号是 S1、S2 和 S3，当我们将这三个信号合并在一起时，我们得到的是红色的信号，实际上是 S1+S2+S3。

傅立叶变换的作用是将我们从时域转移到频域。

万一有人在疑惑，我们要从频域回到时域怎么办？

我们可以通过使用逆傅立叶变换(IFT) 来实现。但我们不会在本文中讨论这个问题。

信号产生和相移

如果我们想描述一个信号，我们需要三样东西:

1. 信号的频率，它显示了在我们的周期内发生了多少次。
2. 振幅显示信号的高度或信号的强度。
3. 相移至于信号从哪里开始。

我们举的第一个例子非常简单，每个信号都有相同的频率和相位差，只有不同的幅度。

现在我们来看一个稍微复杂的例子，我们来看上面例子中的单个信号，因为为了更好地理解傅里叶变换，我们需要仔细观察单个信号。

下面是我们在上面看到的原始信号。

Signal 1

Signal 2

Signal 3

频率:如果我们仔细观察这三个信号，我们会注意到所有三个信号的频率都是不同的。

如果在同一时间段内，信号 1 中有 n 个波，则信号 2 中有 2n 个波，反之亦然。

相位:同样，当我们仔细观察信号实际上是从哪里开始的。我们会发现，当信号 1 开始于(0，0) 时，信号 2 开始于(-0.5，0) ，如果我们追踪波形以在 0 处与 y 轴相交。因此，在 0，我们已经有了信号的最大幅度。这就是我们所说的相移。

振幅:三个信号的振幅不同，信号 1 的振幅为 1，信号 2 和信号 3 的振幅分别为 2 和 3。

这一切都包含在一个优雅而超级简单的数学公式中。因此，在上述示例中，如果 x 轴表示为 x，y 轴表示为 y，我们可以将y生成为t的函数，如下所示:

使用这个公式，我们可以产生我们想要的任何类型的信号，然后我们可以将它们合并在一起并进行处理。例如，如果我们合并信号 1、2 和 3。我们会得到这样的信号:

Signal 1 + Signal2 + Signal3

傅立叶变换背后的数学原理

傅立叶变换背后的主要思想是:

时域中的任何连续信号都可以由一个无限正弦系列唯一且明确地表示。

这意味着什么？

这意味着，如果我们有一个信号，并且这个信号是由某个函数x(t)产生的，那么我们可以得出另一个函数f(t)，这样:

因此，信号有多强并不重要，我们可以找到一个类似于f(t)的函数，它是一系列正弦曲线的之和，实际上可以完美地代表信号。

现在的问题是，我们如何在上面的等式中找到系数，因为这些值将决定输出的形状，从而决定信号。

因此，为了获得这些系数，我们使用傅立叶变换，傅立叶变换的结果是一组系数。因此，我们使用X(F)来表示傅立叶系数，它是频率的函数，我们通过求解积分得到，如下所示:

这个积分中棘手的部分实际上是表示复数的i。所以，我们大概记得i² = -1或者i = √-1。记住复数的形式是a + *i*b 可能会有所帮助。所以，它有一个实部和虚部。

此外，当我们实际求解上述积分时，我们会得到这些复数，其中a和b对应于我们要寻找的系数。

然而，我们确实有三个问题需要处理:

1. 如何应对*i* 。
2. 如何处理离散信号？

所以，我们从第二个开始。

要理解离散傅里叶变换，我们首先需要理解如何对连续信号进行采样？

根据*基百科介绍，在信号处理中，采样是将连续时间信号还原为离散时间信号。下面是一个信号形式如何随采样速率变化的示例:

假设原始信号是在一秒钟内振幅为 2、频率为 5 的信号:

sampling rate = 1000

现在，当我们降低采样率时，让我们看看信号的形状是如何变化的:

sampling rate = 50

当我们进一步降低采样率时，我们得到:

sampling rate = 15

所以，底线是 : 采样速率越高，信号质量越好，我们也可以区分更多频率。

现在，我们知道了如何对信号进行采样，接下来我们来看看称为离散傅里叶变换的算法的修改。

离散傅里叶变换

时域中任何长度为 N 的采样信号都可以由一系列有限的正弦曲线唯一且明确地表示。

所以，在我们的新定义中，我们不用再处理无穷大了。

有什么区别？

在标准傅立叶变换中，我们使用时间函数x(t)来产生连续信号。在离散情况下，我们没有函数，只有数据集，即通过对连续信号进行采样获得的一组点。因此，我将使用{x}来捐赠一个数据集，使其包含来自采样的读数，这样:

离散傅立叶变换将为我们做的是它将把{x}的数据集变换成另一个包含傅立叶系数的数据集{X}，使得:

如果我们看一下傅立叶变换的定义，{X}中的每个X都是一个复数，它包含频率的a和b分量。

但是，两个数据集 ***{x}*** 和 ***{X}*** 怎么会有相同的长度呢？

如果我们想一想，驱动{x}数据集长度的是采样率，因为在一段时间内，我读取的数据点数量正好是采样率，对吗？如果我们考虑另一个数据集{X}，我们说过频率是单位时间内出现的次数。因此，如果我以某一频率进行采样，我无法识别频率高于采样频率的信号，因为我们没有获得足够的数据点。

因此，如果我们以非常低的采样速率获得非常高频率的信号，我们根本无法识别这些信号。因此，我们可以通过应用傅立叶变换识别的频率数量实际上也是由采样速率决定的。

因此，现在我们有了数据集{x}，我们将得到{X*k}* ，这样它就是{X}中的一个元素，它们是我的傅立叶系数，这样:

Fourier Transform

这本质上就是离散傅里叶变换。我们可以进行这种计算，它将产生一个形式为a + *i*b的复数，其中我们有两个傅立叶级数的系数。

现在，我们知道如何对信号进行采样，以及如何应用离散傅立叶变换。我们想做的最后一件事是，我们想通过使用所谓的欧拉公式来去掉复数*i*，因为它在mllib或systemML中不受支持，该公式表示:

Eulers Formula

所以，如果我们把欧拉公式代入傅里叶变换方程，我们得到

我们还知道cos(-θ) = cos(θ)和sin(-θ) = -sin(θ)，如果我们在上面的等式中使用它，等式可以简化为:

实际上，我们可以将上述等式分解为两部分，即:

现在，如果我们将上面的等式与一个复数的等式a + *i*b相比较，那么我们得到相应的值为:

所以，现在我们可以把这些值放入*f(t)*的方程中，得到结果。

结论

在实践中，我们使用一种称为快速傅立叶变换的离散傅立叶变换的微*修改，因为离散傅立叶变换非常简单、基本且缓慢。如果我们真的想在生产环境中做些什么，这是不合适的。离散傅立叶变换的计算复杂度是二次时间O(n²)，用于比较的快速傅立叶变换是准线性时间O(nlogn)。快速傅立叶变换通过利用傅立叶变换中的不对称性来实现这一点。

框定狩猎…

原文：https://towardsdatascience.com/framing-the-hunt-913f9a0eae6a?source=collection_archive---------7-----------------------

这是我如何成功地从地球科学转向数据科学系列的第三篇文章。来刷新一下，这里是第一集和第二集。

好了，现在每个人都赶上了，我给你们留下了一个悬崖衣架。我去了一个编码“训练营”，非常热衷于网络，但是从来没有真正去了解我如何选择寻找哪些机会。我拥有石油和天然气行业之外很少有人能与之相关的技能和丰富的行业经验，以及越来越多的人脉。

对于我的正式求职，我有一套宽松的目标，可以缩*为两个标准:

1. 在西雅图找工作(最好是我爱上了西雅图)

What geoscientist wouldn’t fall in love with their very own volcano?

2.一些支持“技术”产业的东西(不管 T4 真正的意思是什么)

好吧，含糊，我知道。我可以用很多方法来寻找答案。就其最基本的形式而言，找工作有两种方法，一种是窄范围的，一种是宽范围的。作为一名数据科学家，我将简要回顾一下 我对这些因素的 定义，以及它们如何影响我的求职目标。

缩*范围

这种方法适合那些确切知道自己想要什么并且不会降低要求的人。

更明确地说，我将它定义为具有以下标准:

1. 有一个“数据科学家”的头衔或胸围
2. 角色完全符合个人对数据科学的看法(例如，机器学习重点或“大数据”要求)
3. 从事特定行业(如初创企业、公司、顾问)

优点 :

1. 你确切地知道你想要什么，并能使你的面试策略与之相匹配。
2. 你会有你喜欢的头衔和角色，但是你可能会被限制在你所在的特定公司。

缺点 :

1. 你为那些没有正式贴上“数据科学家”标签，但实际上是数据科学家的机会留下了盲区。回想一下，直到 2008 年左右，数据科学这个术语才被完全创造和接受。一些组织仍然使用较老的术语，如分析师或统计师，而不是数据科学家。
2. 你可能最终会把自己定位成一个专家，未来的行动没有多少回旋的余地。
3. 你可能最终会让你原本喜欢的美好事物与你擦肩而过。与此相关的还有“未知，未知”类别。你不知道你不知道什么。听听推销，你可能会找到你真正喜欢的东西。

谁应该考虑这种策略:

1. 一个有可靠理由支持他们调查的人。你以前在类似的组织中担任过类似的角色。大多数来自石油和天然气行业的地球科学家还不知道这一点。如果你有，就把自己当成“独角兽”吧。
2. 在数据科学领域寻找第二份工作(或以后工作)的人。我通常不会向这个领域的新人推荐这种策略，即使是对我们这些处于职业生涯中期的人。

再说一遍，大多数人都不完全属于这一类。求职者希望认为他们知道自己想要什么。见鬼，有一段时间，我以为我很清楚自己想要什么。但是，我建议采用第二种方法，即大范围方法。

最终，我会认为<10% of geoscientists who are pivoting to data science will fall into this category. Of this, most of them will be going into data science roles within the energy industry.

Wide Scope

For most experienced professionals pivoting to the field of data science, the wide scope provides the best “bang for your buck”.

In this approach a job seeker:

1. Casts their net wide. Look into all titles holistically. Data Scientist, Data Analyst, Business Analyst, Decision Scientist, Business Systems Analyst, Business Intelligence…
2. Reads into the details. Look into job descriptions holistically. Not all job descriptions are created equal. One company’s Data Scientist is another company’s Data Analyst. Another company’s Data Scientist is simply a Data Analyst at another.
3. Looks at a variety of opportunities across business types and industries.

有利 :

1. 更多的选择和机会。这种方法可以让你在公司面试你的时候控制和面试他们。因为你有更多的选择，它允许你在驾驶座上。
2. 你可以开始承认未知，未知列表。了解你以前从未接触过的行业和职能。例如，作为一名勘探地球科学家，我打赌你从未直接与社交媒体营销团队打交道。你甚至可能会被它吓跑。你和他们谈过了吗？在你尝试以前的大学生活之前，不要把他们排除在外。
3. 你仍然可以从一个狭窄范围的方法中得到你想要的东西。这些工作仍然存在，你仍然可以申请。这就需要和更多不同的人交谈，来强化你对下一个角色的期望。

弊 :

1. 一些职称可能会让你更难转换到另一家有不同职称的公司。真的不应该有关系，角色和职责应该为王，但如果你是冷申请(即没有内部推荐)，有时会归结为简历排序的算法。

谁应该考虑这种策略:

1. 人人 。大家都要考虑一下。如果你没有，你就没有适当地缩*你的范围。开始大，削减，如果你必须。

最终，我相信这应该是 90%以上转向数据科学的地球科学家的策略。除非你是一个“独角兽”，拥有无缝过渡到一个新行业或留在能源行业的背景，否则你应该使用这种策略。

这个分析对我个人来说意味着什么？

让我们回到我在本文开始时提出的两个主要目标:

1. 在西雅图找工作(最好是，我爱上了西雅图)——我把这个扩展到了许多城市，包括波斯顿、三藩市/海湾地区和 DC 地区
2. 支持“技术”行业的东西(不管它真正的意思是什么)——这扩展到了“技术”、金融、保险等等，我没有特别歧视任何行业，并听取了每一个向我抛出的建议

既然我们已经想好了范围。你实际上是如何理解和阅读数据科学领域的工作描述的？你需要整齐地满足所有的需求吗？如何申请每个职位？你应该对公司进行个性化设计还是使用一种简单的方法？

这是一个很大的难题。下周，我将介绍我在寻找第一个数据科学职位时最常看到的不同类型的“数据科学”帖子。

继续进入第 4 集、第 5 集、第 6 集、第 7 集和第 8 集。

关于“独角兽”和“紫色松鼠”的描述，请参见这篇文章。

极端类别不平衡下的欺诈检测

原文：https://towardsdatascience.com/fraud-detection-under-extreme-class-imbalance-c241854e60c?source=collection_archive---------3-----------------------

数据科学中的一个热门领域是欺诈分析。这可能包括信用卡/借记卡欺诈、反洗钱或网络安全。所有这些领域的一个共同点是阶级不平衡的程度。一般来说，交易总数中只有一*部分是真正的欺诈。以信用卡诈骗为例。在给定用户的 1000 次交易中，只有 1 次是真正的欺诈。这可能是因为客户的信用卡信息被盗，或者供应商的 PoS 设备受损。需要尽快抓住这个问题，以最大限度地减少对客户和供应商的经济损失。同时，我们需要注意假阳性。很自然，如果信用卡在没有发生实际欺诈的情况下被银行冻结，信用卡所有者会不高兴。在这篇博客中，我将介绍一些常用策略，用于揭露金融和网络不端行为，同时最大限度地减少假警报。

无监督学习模型

当交易记录没有被标记时，无监督学习模型是有用的。对于互联网流量数据来说尤其如此，因为没有明确的方法来判断特定的互联网交易本质上是否是恶意的。在这种情况下，异常检测是常见的。

异常检测

想象你在浏览互联网时有某种行为。你在浏览 YouTube 时传输了一定量的数据，通过脸书信使发送了一定量的数据。现在，让我们将它汇总到整个组织中。平均而言，端点将具有可预测的端口使用率。现在，假设其中一个端点碰巧使用某个端口(它通常从不使用)来访问服务器端口(该端口可能因发送恶意软件而被列入黑名单)。这可能是潜在的端口扫描，甚至是公司网络上的 torrent 使用。另一个例子可能是一个或多个端口的突然高使用率，这表明 DDoS 攻击。有很多无监督学习算法，从 K-Means 到高斯混合模型。

对于时间序列数据，可以查看数据点的标准偏差来寻找异常值。时间序列中的某些异常值可能显示不同的模式，可以使用傅立叶变换或隐马尔可夫模型来检测。

更多细节，请查看我关于基于聚类的无监督学习的博客。

监督学习模型

某些欺诈检测数据集带有标签。就拿信用卡诈骗来说吧。如果银行怀疑有欺诈行为，他们可以打电话给持卡人，检查卡是否真的被盗。该信息可以用作新模型构建的训练数据。正如我将在本节中介绍的那样，监督学习模型也有自己的一系列机遇和挑战。

标签错误的数据

在欺诈检测问题中，数据集已经严重失衡。想象一下，除此之外还有贴错标签的数据？可惜现实世界没有 Kaggle 干净。你会得到极其杂乱的数据。我个人的一般策略是使用 K-Means 来可视化数据，以检查标记是否真的有意义。

然而，这是非常主观的，将取决于用例。如果做得好，我们可以得到一个更可靠的数据集来训练我们的模型。不利的一面是，有目标泄露的可能。

模型复杂性

自然，对于大多数欺诈检测用例，模型往往更复杂。考虑到所需的粒度和特性工程水平，简单的线性回归可能没有帮助。也就是说，人们需要意识到过度拟合他们的数据集。学习曲线通常有助于检查模型是否具有高偏差或高方差。

如果模型是高度偏向的，那么就有可能研究更复杂的东西，比如决策树、随机森林甚至神经网络。通常，在金融机构中，通常使用系综模型。某些工程特征在单独的模型上工作得最好(通常是由于方差的巨大差异)。或者甚至将无监督学习模型与有监督模型结合使用(特别是当错误标签的可能性很大时)。

关于学习曲线、集合模型和其他基础知识的复习，请查看我的数据科学面试指南。

惩罚模型

你可以使用相同的算法，但给他们一个不同的角度来看问题。惩罚分类对模型施加了额外的成本，用于在训练期间对少数类进行分类错误。这些惩罚会使模型偏向于更多地关注少数群体。通常，类别惩罚或权重的处理专用于学习算法。有惩罚版本的算法，如惩罚 SVM 和惩罚 LDA。

性能指标

评估模型性能最常用的方法是分类得分。然而，当只有 2%的数据集属于一个类别(欺诈)，而 98%属于其他类别(非欺诈)时，错误分类分数实际上没有意义。你可以达到 98%的准确率，但仍然没有发现任何欺诈行为。此外，请记住，在处理欺诈时，我们关心误报。在这一部分，我将讨论一些可供选择的性能指标。

混淆矩阵

在分析误分类时，混淆矩阵是一种常见的偏好。矩阵的每一行代表预测类中的实例，而每一列代表实际类中的实例

对角线代表已被正确分类的类别。这很有帮助，因为我们不仅知道哪些类被错误分类，还知道它们被错误分类为什么。

精确度、召回率和 F1 分数

为了更好地了解错误分类，我们经常使用以下指标来更好地了解真阳性(TP)、真阴性(TN)、假阳性(FP)和假阴性(FN)。

精度是正确预测的正观测值与总预测正观测值之比。

回忆是正确预测的正面观察值与实际类中所有观察值的比率。

F1-Score 是准确率和召回率的加权平均值。

F1 分数越高，模型越好。对于所有三个指标，0 是最差的，而 1 是最好的。

ROC 曲线

接收器操作特性或 ROC 曲线是欺诈分析(以及数字信号处理)领域中非常流行的指标。

45 度线是随机线，其中曲线下面积或 AUC 是 0.5。曲线离这条线越远，AUC 越高，模型越好。一个模型能得到的最高 AUC 是 1，其中曲线形成一个直角三角形。ROC 曲线也可以帮助调试模型。例如，如果曲线的左下角更接近随机线，则暗示模型在 Y=0 处分类错误。然而，如果右上角是随机的，则意味着误差发生在 Y=1 处。此外，如果曲线上有尖峰(而不是平滑的)，这意味着模型不稳定。对付诈骗模特，ROC 是你最好的朋友。更多信息，请阅读接收器工作特性曲线解密(Python 语言)。

重新取样

我的最后一个建议是重新采样。如果有可能获得更多的数据来使这些类更加平衡，这将是最简单和最好的方法。如果没有，创建合成数据也是一种可能。本节将介绍这些方法。

过采样

对模型中的欺诈记录进行过采样有助于改进分类。但是，要意识到它需要代表真实世界(相对于非欺诈，欺诈实际上很少发生)。SMOTE 和 ADASYN 是这方面的常用算法。自动编码器也可用于创建合成欺诈数据。

欠采样

欠采样非欺诈是另一种被使用的技术。基于聚类方法(例如 K-Means)生成质心是一种常见的策略。

结束语

理想情况下，我在这篇博客中提到的内容将帮助你想出更好的方法来应对欺诈模型(无论是工作、学校还是 Kaggle 竞赛)。我提到的许多事情可以在我的其他博客中找到更多细节:

[## 数据科学面试指南

数据科学是一个相当大且多样化的领域。因此，做一个万事通真的很难…

towardsdatascience.com](/data-science-interview-guide-4ee9f5dc778) [## 基于聚类的无监督学习

无监督机器学习是一种机器学习任务，它从神经网络中推断出一个描述隐藏结构的函数

towardsdatascience.com](/clustering-based-unsupervised-learning-8d705298ae51) [## Scikit-Learn 上决策树和集成的研究

现在科技界最热门的话题之一是机器学习领域。应用范围从…

medium.com](https://medium.com/@sadatnazrul/study-of-decision-trees-and-ensembles-on-scikit-learn-e713a8e532b8)

池保护器:利用网络分析防止支付欺诈

原文：https://towardsdatascience.com/frauddetection-f801b781410b?source=collection_archive---------14-----------------------

一个典型的组织会因欺诈损失大约5%的收入。对于规模较*的企业来说，情况可能更为严峻，因为它们通常受到的保护更少，承受损失的能力也更弱。通过Insight Data Science Fellowship，我为一家支付服务初创公司提供咨询，该公司因欺诈遭受了重大损失。这家公司，我们称之为公司 A，为用户提供了一个平台来集中他们的钱进行一次购买。例如，假设爱丽丝和鲍勃要去克里斯家参加聚会，他们都想分摊费用。在这种情况下，Chris 创建了一个池，他、Bob 和 Alice 都参与其中。克里斯然后取出钱来支付聚会的费用。然而，有可能稍后爱丽丝决定她不想为聚会付钱。她可以对自己向泳池支付的费用提出异议，而不是要求克里斯退款。如果她拿到了钱，而克里斯已经提取了资金池的余额，A 公司就只剩下支票了！这样的交易被称为退款。

• User avatars in this picture are created by Freepik (https://www.freepik.com/free-photos-vectors/people)

按存储容量使用计费旨在保护消费者。例如，在上面的案例中，如果 Chris 多收了她的钱并且拒绝退款，Alice 可以对她的付款提出异议。尽管如此，一些用户滥用退款流程，故意从公司 A 偷窃。由于不可能了解公司 A 每笔退款交易背后的真实动机，我从公司的角度将所有退款视为欺诈交易，因为它们都会给公司造成直接损失，并使用这种启发式方法在数据中找到可能指出真正欺诈的模式。

概观

在 2017 年的前三个季度，我所工作的公司因退款而损失了大约一半的交易费收益。记录显示，不到 1%的用户和不到 1%的交易会导致这种严重的损失。为了防止潜在的退款，该公司已经开始努力提取特定于用户和交易的特征，以建立一个欺诈检测模型。鉴于欺诈通常不是一个孤立的事件，我认为利用用户网络环境中的用户信息来增强模型是有价值的。具体来说，我发现用户的池社区和社交网络影响他们欺诈行为的机会，这可以用来提高公司 A 预测欺诈的能力。

泳池社区

在公司 A 的平台上进行的每一笔交易都将一群用户联系在一起。经过多年的支付，一个丰富的、潜在的强大的网络结构开始形成。关于这些泳池社区的第一个问题是:泳池的大*重要吗？下面是涉及按存储容量使用计费的池与完全合法的池的池大*的频率分布。总的来说，合法交易更有可能发生在中等规模的池中，有趣的是，有退款的大部分池的规模为 1。一号池一开始就是奇怪的实体(人们试图与自己分担成本吗？)这强烈表明用户只是利用它们来实施欺诈。下面的数据表明，阻止甚至标记从 1 号池中的提款将会减少三分之一以上的退款频率，同时减少不到 10%的合法交易。假设交易金额和费用不会随着池的大*而变化太大，这些数字表明，与交易费用损失相比，像阻止大*为 1 的池这样的简单政策转变将节省大约两倍的费用，从而对公司的底线产生重大影响。

对于更大的池，分析池的组成可以让我们了解人们如何相互影响。将罪责归咎于个人可能取决于他们所交往的人，而不是他们犯下的任何欺诈行为，这种行为被称为“牵连犯罪”。下图显示了每个池中涉及按存储容量使用计费的欺诈用户与完全合法用户的百分比分布。按存储容量使用计费池组中有很大一部分池包含超过 10%的欺诈用户。这强烈表明，处于欺诈环境中会增加人们申请退款的倾向。

社交网络

除了池社区，用户的社交网络也可能与他们提交退款的机会有关。我们鼓励该平台的用户使用他们的脸书帐户进行注册。下面我展示了脸书的欺诈用户友谊网络，其中圆圈上的每个点代表一个用户，每个用户都标有一种颜色，表示他或她已提交的退款数量。连接线代表用户在平台内的脸书连接。与上一节显示欺诈用户倾向于群集相反，当涉及到实际的社会联系时，欺诈用户似乎是独立的。此外，有许多欺诈用户在记录上没有一个脸书朋友，可能是因为他们选择不将他们的脸书账户链接到该公司的平台。

Facebook friendship network of fraudulent users

我们可以使用每个用户的“度中心性”来量化用户在网络中的重要性，即用户的朋友数量除以网络中的用户总数。下面的分布显示，与合法用户相比，在按存储容量使用计费用户组中没有朋友的用户的频率要高得多。合法用户往往有更多的朋友，如果我们进一步查看二级连接，并测量用户朋友的平均朋友数量(分布如下所示)，情况也是如此。换句话说，与欺诈用户的朋友相比，合法用户的朋友也有更多的朋友。

预测退款交易

上面讨论的网络特性本身显然是强大的。为了利用他们的集体力量，我将他们与公司 A 已经拥有的基于用户和基于交易的功能结合到一个单一的机器学习模型中。选择了一个随机森林模型来将每个交易分类为欺诈或合法。使用网格搜索来调整模型参数，这产生了具有 1300 棵树和最大深度 10 的模型。受试者工作特征(ROC) 曲线(左下)显示该模型具有很高的预测性。“完美”模型的曲线下面积(AUC)为 1.0，表明它对每个样本进行了完美分类，而“抛硬币”模型的 AUC 为 0.5。我训练的最终模型的 AUC 为 0.97。

由于欺诈的成本(每月约 4800 美元)比调查合法交易的成本(每月约 300 美元)高得多，A 公司主要对实现高召回率的模型感兴趣。混淆矩阵(中上)显示最终模型的召回率为 74.8%。与 61.0%的无网络功能的原有型号召回相比，这相当于在公司当前规模下，每年大约增加价值 8，600 美元的欺诈防范。虽然模型的精确度从 74.3%下降到 53.8%，但欺诈防范节省的成本远远超过了增加的调查成本。突出在此项目中构建的网络要素的重要性是它们的重要性-这些要素由模型中 4 个最重要的要素中的 3 个组成(上图最右侧仅显示了重要性> 0.08 的要素)。我工作过的公司已经在努力将这种模式纳入他们的平台，这将有助于调查人员在案件结束前标记案件，转化为实际的节约。

未来工作

在模型参数的网格搜索中，我当前的模型在优化过程中使用 AUC 作为度量。虽然这种选择可以产生具有高总体预测能力的模型，但我们可以使用 F_beta 分数来更好地优化模型，以降低退款造成的总损失，同时考虑调查成本。F_beta 分数是精确度和召回率的加权调和平均值。一方面，召回率高的车型可以减少退换货带来的损失；另一方面，模型的精确性也很重要，因为每一项交易的调查都伴随着成本。因此，为了平衡损失和成本，需要以 F_beta 作为优化度量来网格搜索更好的模型。F_beta 分数中的权重 beta 可以从退款的平均损失和调查的平均成本中得出。我与该公司的未来工作将是利用损失和成本的知识来优化模型，以便我们可以降低退款造成的总损失，同时最大限度地减少合法交易的标志。

关于惠宗 ( )领英 )

我目前是纽约市的 Insight 数据科学研究员，也是西北大学应用物理学的博士生。我的研究生研究主要集中在用于基因治疗的聚合基因递送系统的计算研究。在使用深度学习技术开发聚合物凝胶化的预测模型时，我对数据科学产生了兴趣。在这个项目中，我看到了数据驱动的方法如何解决有趣和相关的问题，我期待着继续沿着这个方向前进！

冻结 Keras 模型

原文：https://towardsdatascience.com/freezing-a-keras-model-c2e26cb84a38?source=collection_archive---------2-----------------------

如何为服务和其他应用程序冻结模型

“landscape photography of snowy mountain and body of water” by Joel & Jasmin Førestbird on Unsplash

简介

Keras 已经成为工业界和学术界开发和测试神经网络的主要 API 之一。由于其各种后端可能性，它结合了用户友好的语法和灵活性，这意味着你可以用 TensorFlow，Theano 或 CNTK 编写并在 Keras 中调用它。

一旦你用 Keras 设计了一个网络，你可能想在另一个 API 中，在网络上，或者在其他媒介上服务它。做上述许多事情的最简单的方法之一是使用预先构建的 TensorFlow 库(例如用于 C++环境中的模型推理的 TensorFlow C++ API )。为了做到这一点，由于这些 API 的后端工作方式，您很可能不得不“冻结”您训练过的 Keras 模型。不幸的是，为了轻松地做到这一点，您必须在 Keras 的 TensorFlow 实现中重新训练您的模型。然而，幸运的是，如果你知道你的目标是什么，这个过程非常简单，这要归功于 Keras 集成到 TensorFlow 的方式，以及 TensorFlow 为此任务提供的各种其他材料。

当我最初研究如何在 C++环境中为模型提供服务时，我从类似的帖子中找到了几个可能的答案，比如关于堆栈溢出的帖子，以及关于介质的帖子。类似地，一些人已经制作了各种很棒的开源包来做到这一点，比如 keras2cpp 。然而，我发现这些文章缺乏一些关键的细节，并且经常使用复杂的技术，这些技术在写作时是必要的，但由于 TensorFlow 的更新，这些技术已经大大简化了。

我希望这篇文章提供了一个简单的、最新的演练，展示了如何为任何一般需求冻结 Keras 模型，而不仅仅是为了在 C++环境中服务。虽然本文中描述的方法是专门为转换 Keras API 中编写的模型(本机或 TensorFlow 实现)而编写的，但它也可以用于任何用本机 TensorFlow 编写的模型。

为什么我需要转换我的模型？

如果您的模型经过训练并保存在 Keras API 中，那么您可能已经保存了模型的 hdf5 文件，其中网络架构和权重一起保存在一个文件中。这个文件可以被调用并加载回 Keras API 进行推理。然而，遗憾的是，TensorFlow APIs 无法识别这种文件类型，而且存储、加载和执行推理也不必要太大。

同样，如果你在 TensorFlow Python API 中编写一个模型，那么训练过程将使用 Google 的 ProtoBuf 库保存一个 TensorFlow 图，以及一系列检查点文件。该图存储了关于带有Variable ops 的网络架构的信息，而检查点文件包含了训练不同阶段的权重值(取决于训练期间您的会话检查点的频率)。这些通常可以在 TensorFlow Python API 会话中加载用于推断，在此期间，来自检查点文件的权重被插入到图中的Variable ops 中。然而，当仅仅执行推理时，这是低效的。另一方面，一个保存的 Keras .h5文件仅仅是图形和最终状态检查点文件的组合，同时仍然保持超参数存储为Variable ops。(注:以上不需要详细了解，我只是给想要更详细解释的人补充一下。)

冻结模型意味着生成一个包含图和检查点变量信息的单一文件，但是将这些超参数作为常量保存在图结构中。这消除了保存在检查点文件中的额外信息，例如每个点的梯度，这些信息包括在内，以便可以重新加载模型并从您停止的地方继续训练。因为这在为纯粹用于推理的模型服务时是不需要的，所以它们在冻结时被丢弃。冻结模型是一个谷歌.pb文件类型的文件。

要求

冻结推理模型的要求很简单，但是，根据您的应用程序，您可能需要安装各种其他包来实际执行推理:

• 将 Keras 与 TensorFlow 后端一起使用
• 尽管安装了 TensorFlow 应该可以自动运行，但您需要确保 TensorBoard 在您的计算机上运行
• 从 TensorFlow 存储库中，将 freeze_graph.py python 脚本复制到您的工作目录中。或者，您可以使用定制设计的freeze_graph函数，我们将在后面看到。

转换模型

为了生成包含必要信息的.pb文件，TensorFlow 编写了freeze_graph.py文件，该文件在被调用时将合并 TensorFlow 图形和检查点文件。使用这个 Python 脚本通常是明智的，因为它是由 TensorFlow 团队编写的，他们确保它可以与他们内部的文件格式一起工作。但是，为了使用它，您必须首先拥有正确格式的图形和检查点文件。Keras API 不会自动生成这个文件，所以您需要重新训练模型来生成它们。

有两种相对简单的方法来获取以正确格式保存的训练模型以进行冻结。如果您直接使用 Keras API，那么您将需要切换到在 TensorFlow 环境中实现的 Keras API。

注意:这应该只需要在导入阶段进行更改，例如，您将拥有from tensorflow.keras.layers import Convolution2D而不是from keras.layers import Convolution2D。

第一种方法调用模型，然后将其转换为 TensorFlow 估计器，后者将处理训练。第二个要求理解 TensorFlow 会话是如何工作的，因为这种方法训练网络就像你用本地 TensorFlow 编写的一样。实施这些训练方法后，您将能够运行freeze_graph以获得正确的输出。

让我们通过一个例子来演示这个过程。在这里，我们将把一个简单的 Keras 模型转换成一个估计量，用于对 MNIST 数据集进行数字分类。

首先，我们在 TensorFlow 中实现的 Keras API 中构建模型，确保命名您的输入和输出层，因为我们稍后将需要这些名称:

Defining the model, note we do not define an input layer here since the type of input layer depends on which method you choose for training

选项 1:转换为估计值

一般来说，这种方法可能是两种方法中最简单的，但是，由于处理定制估计器的性质，它可以很快变得更复杂，这取决于您想要如何训练模型。如果您只熟悉原生 Keras API 中的训练模型，那么这是最相似的训练模型的方式。TensorFlow 1.4 引入了将 Keras 模型转换为 TensorFlow 估算器的功能，本教程对此进行了描述。

要将上述模型转换成估算器，首先使用 TensorFlow 中实现的普通 Keras API 编译模型，然后使用model_to_estimator()函数:

Converting the model into an Estimator, here the checkpoint files and graph will be saved in the model directory

现在estimator_model表现得像一个张量流估计器，我们可以相应地训练模型。有关如何培训评估员的指南，请参见文档。

对于训练，定义一个输入函数并相应地训练模型:

模型现在已经训练好了，并且graph.pbtxt和检查点.ckpt文件将保存在./Keras_MNIST模型目录中。

选项 2:像原生张量流模型一样训练

另一种方法是通过启动张量流会话并在会话中训练来训练模型。这需要对会话如何工作有更详细的了解，这超出了本文的范围，我建议读者参考这个 MNIST 教程作为这种培训的例子。然而，与示例不同的是，您不需要在 native TensorFlow 中编写模型，相反，我们可以调用上面的模型，只需更改输入层:

剩下的就可以从教程中遵循了。

冻结模型

现在模型已经训练好了，图形和检查点文件也制作好了，我们可以使用 TensorFlow 的freeze_graph.py将它们合并在一起。

注意:确保freeze_graph.py与您想要冻结的检查点和图形文件在同一个目录中。

或者，我发现由摩根开发的简化版更不容易标记错误。

Simplified freeze_graph implementation by Morgan

此函数使用图形重新启动临时会话，以恢复最近的检查点。使用这种实现的另一个优点是，您不必确保指定了正确的检查点文件，或者处理语法上更加密集的freeze_graph.py输入。

我们需要知道输出节点的名称，作为函数的引用点。这和我们用不用freeze_graph的简化版是一样的。你给最后一层起的名字是不够的，打开 TensorBoard 会给出一个可视化的图形。

TensorBoard output showing input to ‘metrics’ node

在这个例子中，我们想要的是进入“度量”节点的张量，叫做output_node/Softmax。

这将在模型目录中生成一个冻结的图形。

关键要点

1. Keras 模型可以在 TensorFlow 环境中训练，或者更方便的是，变成一个语法变化很*的估计器。
2. 要冻结一个模型，你首先需要生成检查点和图形文件，以便调用freeze_graph.py或上面的简化版本。
3. TensorFlow 上有许多标记为 Keras GitHubs 的问题，以及关于冻结模型的堆栈溢出，其中许多问题可以通过了解需要生成的文件以及如何指定输出节点来解决。
4. 输出节点可以很容易地从 TensorBoard 可视化中找到，但它并不总是你指定的最后一层的名称。

使用异构网络嵌入的朋友推荐

原文：https://towardsdatascience.com/friend-recommendation-using-heterogeneous-network-embeddings-54f95babdb13?source=collection_archive---------22-----------------------

想象一下史努比没有伍德斯托克或者卡尔文没有霍布斯，老友记没有瑞秋，蝙蝠侠没有罗宾或者无忌没有布鲁。社交平台的繁荣依赖于成员找到相关朋友进行互动的能力。网络效应是驱动应用程序增长或花费时间和每日活跃用户的因素。这对于 Hike 来说更加重要，因为 Hike 是一个亲密朋友的网络。因此，我们需要确保找到朋友、邀请他们并将其添加到网络中很容易。

从一个人第一次开始徒步旅行，提供朋友建议作为登车体验的一部分是至关重要的。我们的数据显示，在加入后的最初几分钟内找到朋友的新用户，其留存率明显高于没有找到朋友的用户。因此，好友推荐算法的功效对于平台的增长和参与度至关重要。

“Society friendship and love, Divinely bestow’d upon man” — William Cowper, The Solitude of Alexander Selkirk

在像 Hike 这样活跃的现实社会网络上设计一个朋友推荐系统意味着:

1. 好友建议需要相关 —由于屏幕空间有限，一次只能显示几个好友建议，这意味着我们需要推荐相关的人
2. 好友推荐需要顺利进行这样新用户可以毫不费力地加入网络
3. 它需要以未来为中心。网络在不断发展，每天都有新用户加入，添加朋友，老用户之间建立友谊等等。基于当前网络，我们希望能够预测网络中即将发生的变化，并相应地提出建议

在 Hike，我们在自然语言处理(NLP)、计算机视觉、相关性和推荐、网络分析等领域部署了最先进的机器学习算法。(ML @ Hike 概述)。我们的朋友建议模型是使用深度学习和网络分析的高级研究建立的。我们对此进行了深入研究，并开发了一个框架，用于在具有多种边缘类型的异构网络上进行图形表示学习，以进行朋友推荐。这对我们来说非常好，除了商业收益，当这项研究被提名发表在 2019 年 4 月的欧洲信息检索会议(ECIR)上时，我们非常兴奋。

朋友推荐问题符合社交网络中的经典链接预测问题。我们将平台上的用户表示为位于一个图上，图中的边是用户之间的连接。给定一个社交网络在时间 t 的快照，我们能否准确预测在从时间 t 到给定的未来时间 t` 的间隔期间将被添加到网络的边？简而言之，网络的当前状态可以用来预测未来的链接吗？传统的链路预测方法是基于分析网络中节点“接近度”的测量。具体而言，如果两个节点的邻域有很大的重叠，则这种方法将指示它们很可能共享一条链路。共同邻居、Jaccard 系数、Adamic-Adar 度量、是已经被设计用于评估节点邻域之间的重叠的不同度量。还有使用节点特征来训练分类模型的监督机器学习技术。这些功能并不总是容易获得，因此需要大量的功能工程。

两个节点的节点嵌入可以被组合以形成连接它们的边的表示。在链接预测的情况下，这种边缘嵌入可以被给予分类器，以预测边缘是否可能存在。

最近，在开发用于学习图形表示的方法方面已经有了很多工作。这些表示捕捉节点与其邻居的关系。我们可以使用这些图形表示来跳过我们的模型的手动特征工程，并且可以使用节点向量来训练模型，以解决诸如链接预测、节点分类和社区检测之类的问题。这种表现形式已被证明比手工设计的特征更有效。其思想是学习一种映射，该映射将节点投影到低*向量空间中，从而保持相邻关系。嵌入生成通常遵循两个步骤:

1. 网络中每个节点的样本邻域，例如通过生成从节点发出的随机行走。这些示例捕获了节点之间的上下文关系。
2. 一种 skip-gram 类型的模型，它将随机行走作为输入，并将节点投影到低*空间。

一个类比是文本文档中的单词嵌入(word 2 vec)——随机游走是句子的网络对应物。两种流行的节点嵌入方法如下:

Deepwalk 方法学习同构网络中的节点嵌入。首先，我们从每个节点开始，生成固定数量的选定长度的无偏且均匀的随机行走。Skip-gram 算法用于从随机行走中获得节点嵌入，随机行走期望捕获网络节点的上下文属性——出现在相同上下文中的节点具有相似的向量嵌入。

学习同构节点嵌入的另一个重要方法是 node2vec，其中随机行走偏向于导航节点的邻域，使得它们可以从广度优先搜索(BFS)过渡到深度优先搜索(DFS)遍历。BFS 和 DFS 之间的插值由一个参数指定，为了获得良好的性能，这需要进行大量调整。

朋友推荐可以被定义为二元分类问题，该问题从一对用户获取特征，并且如果是朋友对，则学习将它们映射到 1，否则映射到 0。我们可以利用网络嵌入来获取用户特征。如果 u，v 是两个用户，并且 vec_u，vec_v 分别是对应的节点嵌入，我们可以以各种方式组合这些嵌入来创建分类模型的输入，例如

• 串联，vec =**vec _ u⊕vec _ v
• 平均值，vec =(vec _ u+vec _ v)/n
• 哈达玛乘积，vec =vec _ uvec _ v*

注意，这些都是向量运算。向量 vec 可以认为是边< u，v >的嵌入。然后将 vec 输入机器学习模型，如逻辑回归、神经网络等。训练分类器需要模型“学习”的已知朋友和非朋友对的大量标记数据

D = { < u，v >，label}，其中 label ∈ {0，1}

为了评估，保留了一个测试集。这种模型可以通过各种度量来评估，例如

ROC 曲线下面积(AUC)

-k 处的精度(P @ k)

为了在 Hike 等真实世界的活跃社交网络上测试朋友推荐模型，人们还需要评估该模型在应用程序上的功效，这可以通过比较前 k 名推荐的点击率(CTR)来完成。

Hike 的社交图谱相当独特。网络是高度异构的，具有多种节点类型，例如用户、帖子、主题等。以及多个边缘类型，例如友谊、喜欢、评论、关注等。对于朋友推荐系统，我们假设一个徒步旅行的用户网络是同类型的，但是这个网络的边是异构的，在节点之间有多种类型的边。为了便于说明和扩展，我们使用了具有三种边缘类型的异构网络:

“联系人”—如果用户在彼此的联系人中

“朋友”——如果用户是徒步旅行的朋友

“聊天”——如果用户在一段时间内至少聊过一次

这允许在两个节点之间存在多条边，例如，如果用户出现在彼此的联系人列表中，是朋友并且在过去的一个月中交换了聊天消息，则在他们之间将存在三条边。Hike 网络比以前使用网络嵌入方法对链接预测进行的研究要大得多。边缘类型的异质性对于我们的网络也是非常独特的，我们的网络在数学上可以描述为具有多种边缘类型的多图。我们数据中的另一个混淆因素是，在我们的验证数据中，46%的节点对没有共同的朋友——有许多孤立和松散连接的节点。这些挑战增加了朋友推荐问题的难度。

DeepWalk 和 Node2vec 的适用性仅限于具有一种类型的节点和节点间单一类型的边的同构网络。为同构网络设计的现有网络嵌入方法可能不直接适用于异构网络。最近， metapath2vec 提出了一种异构网络的嵌入技术，它定义了元路径(一系列节点类型)来限制随机游走。然而，如何定义这样的元路径并不明显，因为我们通常缺乏对路径和元路径以及元路径长度的直觉。此外，对于具有不同边类型和两个节点之间的多条边的异构网络(异构多图)，没有直观的方式来定义边类型的元路径。在 metapath2vec 中，提出了一种在具有图像和文本节点的多模态网络中学习节点嵌入的深度架构。然而，它不能推广到一个多图，其中一对节点之间存在不同类型的边。对于异构网络，Deepwalk 有一些简单的扩展。

无偏随机行走是通过分配穿过两个节点之间的任何边的相等概率来生成的。这增加了随机行走到与当前节点有多条边的节点的概率。一个限制是，在 Hike 网络中，接触边远远多于朋友，聊天连接甚至更少。因此，随机漫步有更高的机会通过接触边，在某些情况下完全避免聊天边。

一个简单的解决方案是，随机游走受主导边类型的影响，随机游走是这样生成的，即有相等的概率跳到每个边类型上。这通过随机选择边缘类型来实现，然后在所选边缘类型中随机选择边缘。实际上，不同的边类型对随机游走的贡献不同，并且会有不同的权重。我们没有直观的方法来获得这些权重。

这些方法的主要缺点是，没有明显的方法来找出如何对每种边类型的随机游走进行偏置；没有理由认为边类型具有同等的重要性。

我们提出了一种方法来自动估计每个边缘类型的贡献，以获得边缘的最终嵌入。我们展示了与朋友推荐问题的相关性。计算过程如下:

1. 将 Hike 网络分为朋友子网、联系人子网和聊天子网，用户分别通过友谊、联系人列表和聊天连接。这些子图中的每一个都是同质的。
2. 使用 Deepwalk 或 Node2Vec 从每个子网中获取节点嵌入。我们现在有了一个节点在多个空间中的表示。
3. 在每个同质嵌入空间中，从节点嵌入计算边缘嵌入
4. 为链路预测训练统一的异构边缘嵌入。

用于学习统一表示的模型基于多输入神经网络，该网络从不同空间获取同质边缘嵌入，并将它们组合以在新空间中形成嵌入，该新空间具有来自 3 种边缘类型的贡献。下图显示了神经网络体系结构，其中节点嵌入被连接以产生边嵌入:

与其他最先进的技术相比，这种方法表现出优越的性能。我们报告了 AUC 分数比 Deepwalk 方法提高了 20%,并且在 5 处的精确度提高了 4.4%。我们还通过发送最可能的友谊作为应用内通知进行了用户实验，我们观察到比基线提高了 7.6%。

简单说一下工程方面——该系统有离线和在线组件。在离线系统中，社交图每天重新计算，节点嵌入被计算并存储在像 FIASS 这样的可扩展系统中，该系统建立索引以促进快速相似性搜索。如前所述，我们还基于神经网络训练了一个新的推荐模型。用户的朋友建议是以在线方式创建的，其中我们查找用户的节点嵌入并执行最近邻搜索以获取候选集，然后使用神经网络模型对其进行评分。布隆过滤器检查确保不会为用户重复推荐。以这种方式生成的前 k 个推荐在 Hike 应用程序上的不同推荐部件中提供。该系统如下图所示:

改进对远足的朋友推荐是我们团队本季度的一项关键 OKR 指标，我们已经达到了本季度的改进指标。在这次旅程中，我们开发了一个框架，用于在具有边缘异构性的图上进行图形表示学习，本文中介绍的模型基于我们即将在 2019 年 ECIR 会议上发表的研究论文🏆😎

原载于 2018 年 12 月 18 日blog . hike . in。

使用生成的谷歌表单进行更友好的数据标注

原文：https://towardsdatascience.com/friendlier-data-labelling-using-generated-google-forms-d25e3e9f6aa6?source=collection_archive---------7-----------------------

手动标记数据是无人喜爱的机器学习琐事。如果你能给别人一个愉快的工具来完成这项任务，你就不必担心要求别人帮忙。让我向您展示:使用 Google App 脚本生成的 Google 表单！

Google App Scripts allow you to build automation between Google Apps

人们给数据加标签的常规方式是在电子表格中输入标签。我通常也会这样做，但是在最近的一项任务中，我需要标记文本段落。你曾经尝试过阅读电子表格中的文本段落吗？..简直是地狱！幸运的是，当我试图找出一种方法使标签过程不那么累的时候，我遇到了一种使用 Google App Script 根据电子表格文档中的数据自动生成表单的方法。

Nasty! Nobody wants to strain their eyes trying to read documents in spreadsheet cells!

创建将生成我们表单的脚本

首先，我们只需从包含我们想要收集标签的数据的 Google 电子表格中进入应用程序脚本编辑器:

Opening the App Script editor from a Google Spreadsheet

使用应用程序脚本(pssst！这只是 JavaScript)我们可以读取电子表格数据，并向其他谷歌应用程序(在这种情况下，谷歌表单)发送命令。

使用表单进行标记的好处在于，您可以通过指定数据输入类型来保证用户输入的一致性。例如:

号码范围:

form.addScaleItem()
.setTitle(dataToLabel)                    
.setBounds(1, 10)        
.setRequired(true);

二进制标签:

form.addCheckboxItem()
.setTitle(dataToLabel)
.setChoices([
           item.createChoice('Is a cat')
           ])

多类标签

form.addMultipleChoiceItem()
.setTitle(dataToLabel)
.setChoices([
         item.createChoice('Cats'),
         item.createChoice('Dogs'),
         item.createChoice('Fish')   
])

在 App Script API docs 中查看更多输入类型的详细信息(或者手动创建 Google 表单时只查看不同的输入类型)。

您可以从我的 Github 中获取我用来生成用数字 0 到 10 标记文本文档的表单的脚本:

[## ZackAkil/更友好的数据标签

更友好的数据标注代码资源，用于生成标注数据的 google 表单。

github.com](https://github.com/ZackAkil/friendlier-data-labelling/blob/master/Code.gs)

在你写好剧本(或者复制粘贴)之后；然后选择脚本的入口点并运行它！警告:第一次做的时候，你可能需要通过一些授权环节。

Make sure to select the entry point function of the script before running.

使用生成的表单

脚本运行后，您可以前往您的 Google 表单，在那里您应该会找到一个全新的表单！你可以把表格发给任何你想贴标签的人:

Finally you can send your labellers a convenient link to a familiar Google Form that they can use to carry out the labelling task.

访问数据标签

完成标记后，您可以将标签作为电子表格查看，并导出为 CSV 格式:

It’s pretty straight forward to get the labels out as a CSV.

希望这能让你在未来的机器学习工作中少一点头痛！

本文中使用的完整脚本和数据集可以在我的 Github 上找到:

[## ZackAkil/更友好的数据标签

更友好的数据标注代码资源，用于生成标注数据的 google 表单。

github.com](https://github.com/ZackAkil/friendlier-data-labelling)

Frieze London 2018(第二部分):自然语言处理

原文：https://towardsdatascience.com/frieze-london-2018-part-2-natural-language-processing-66d0627f39af?source=collection_archive---------18-----------------------

第二部分:5.6k Instagram 和 3.2k Twitter 帖子的自然语言处理

介绍

Frieze 是一家国际艺术商业特许经营公司，1991 年以杂志起家，但后来发展成为一家组织一些年度日历上最重要的艺术博览会和活动的机构。

自 2003 年以来，每年 10 月，Frieze 都会在伦敦摄政公园的中央组织一次大型当代艺术展，吸引成千上万的人。来自 20 多个国家的 150 多家画廊通常会参加盈利性艺术博览会。

然而，Frieze 现在已经不仅仅是一个艺术博览会。
“楣周”已经成为一个文化娱乐周，人们纯粹是为了观赏而参加，这里有一个雕塑公园，甚至主要的拍卖行也举办他们的中期当代拍卖会，以配合楣周。

本文的目的是通过展示我对关于艺术博览会的 5.6k Instagram 和 3.2k Twitter 帖子的自然语言处理分析的发现，更好地了解 Frieze London 2018。

请向下滚动，通过交互式数据可视化查看我的分析！

数据和方法

这一事件的官方标签是#frieze。在通过 Twitter API 和 Instagram API 收集了事件发生时包含这个标签的 9000 个帖子之后，我首先清理了 Python 笔记本中的文本数据。

然后，我使用谷歌的 langdetect 库 过滤掉非英语推文，并从 NLP 分析中删除所有转发，这样就不会出现重复。在这些步骤之后，我剩下了 7400 个独特的帖子。接下来，我使用谷歌云自然语言 API 来获取每条推文的情感。

最后，我使用 gensim 库的 Word2Vec 模型来获取整个 tweets 语料库中与单词“frieze”相关的每个单词的单词嵌入向量。Word2Vec 用于从大型文本语料库中计算单词之间的相似度——卡*塔·加内桑的文章就是一个很好的解释。

一旦我有了每个单词的向量，我就使用 scikitlearn 库来执行主成分分析(PCA)以进行降*，并绘制出与“frieze”最相似的单词(最近邻居)。

你可以在这里查看我的 Kaggle 内核这篇文章的所有分析。

分析帖子

在这一节中，我将展示我的自然语言处理(NLP)分析的发现。下面，我报告以下三个指标:

1. 每日推文的情感分析；
2. 词频和标签频率分析；
3. Word2Vec 模型的输出:主成分分析(PCA)和最近邻分析。

情感分析

每条推文的情绪是使用谷歌的云 NLP API 计算的。下面的条形图显示了每天推文的平均情绪，其中-1 表示非常消极的情绪，+1 表示非常积极的情绪。

不幸的是，我们看到，随着展会的进行，人们对 2018 年伦敦奥运会的热情逐渐降低。开始时为 0.47，到周日时一路下跌至 0.37。然而，到了交易会的最后一天，它又反弹到了 0.47！

Figure 1: Line chart showing the average sentiment of the tweets per day

文本频率分析

下面的条形图显示了一个词和一个标签在所有社交媒体帖子中出现的次数，分别在左侧和右侧。不出所料，“中楣”出现的次数最多。

但是，因为标签也出现在社交媒体帖子的主体中，所以在计算单词频率时，它们成为了一个混淆变量。因此，我采取措施将 hashtag 计数从单词计数中移除。

然而，下面的结果并不能很好地告诉我们人们对该事件的看法。我们只发现名词而不是形容词。我们可以使用一些机器学习技术来尝试挖掘一些形容词。

Figure 2: Bar graphs showing the count of words and hashtags appearing in all the tweets

最近的邻居

Word2Vec 是神经语言机器学习模型。它采用大量的文本，在这种情况下，来自 9000 个社交媒体帖子的文本作为输入，并产生一个向量空间，通常有数百个*度，每个唯一的单词对应于空间中的一个向量——单词嵌入。然后使用主成分分析将 Word2Vec 空间的*度降低到 x 和 y 坐标。

重要的是，Word2Vec 用于从 9000 条推文中捕捉单词之间的相似性和关系。具体来说，空间中距离较近的对象意味着它们是相似的。“最近邻”是来自 Word2Vec 模型的少数几个基于余弦度量相似性得分与“frieze”最相似的单词。

Figure 3: PCA output of the nearest neighbours of #frieze from the Word2Vec model

上面的散点图使用两个不同的语料库显示了“frieze”的最近邻居；一个包含标签，一个没有标签。

在带有标签的语料库中，我们看到许多与“frieze”最近的邻居实际上就是标签；比如《friezelondon 2018》《friezeartfaire》《friezemasters》。有趣的是，“regentspark”和“sculpture”出现在附近，可见雕塑公园的受欢迎程度。

不幸的是，很少有形容词或描述性词语来描述人们对艺术博览会的看法。在没有标签的语料库中，我们看到一些描述性的词，如“谢谢”、“最好”和“亮点”，但同样，这些词很少告诉我们人们对事件的看法。需要更深入的分析。

结论

所以你有它！我已经展示了我对关于艺术博览会的 5.6k Instagram 和 3.2k Twitter 帖子进行 NLP 分析的结果。我的发现没能告诉我们人们对博览会的看法。

在未来的研究中，我将致力于更深入的分析。有这么多的 NLP 库，我很可能会在未来使用 GloVe 、 Tensorflow 或 Bert 重新审视这个分析。

下次…

在我的下一篇文章(第 3 部分)中，我将展示我的计算机视觉分析的发现。期待看到哪些艺术品出现的次数最多。敬请关注。

感谢阅读！

Vishal

我是一名文化数据科学家，是伦敦 UCL 学院*的研究生。我对城市文化的经济和社会影响感兴趣。我欢迎反馈和建设性的批评。* 你可以在Twitter或LinkedIn、insta gram或我的 网站 上与我取得联系。

从大数据到微服务:如何通过 AWS lambdas 为 Spark 训练的模型提供服务

原文：https://towardsdatascience.com/from-big-data-to-micro-services-how-to-serve-spark-trained-models-through-aws-lambdas-ebe129f4849c?source=collection_archive---------6-----------------------

通过预先训练的 Spark 模型为端点供电的快捷方式

介绍

“我们选择它是因为我们要处理海量数据。另外，听起来真的很酷。”—拉里·佩奇

恭喜你！你用 Spark 训练了你的决策树，得到了一个很好的模型。现在呢？

你想利用你的模型来提供实时预测，但在 Spark 中没有简单的方法来获得网站或应用程序所需的交互性:如果你正在构建，比如说，欺诈检测，在每个用户动作时，你都想触发实时预测并采取相应的行动——时间是关键！

我们需要的是一种 快速简单 的方式，从我们的大数据模型转向一种微服务，一次只按需提供一个预测。

当然，可能会有更好的选项满足您的需求，并且味道更好:您可能事先知道测试集(在这种情况下，请参见这里的中的示例)；您可能乐于处理传入的流数据，并定期访问缓存以进行接近实时的预测(例如，选项 B 在此处详述)；最后，你可能喜欢 JVM，并寻找一些完善的、现成的东西(在这种情况下，你应该完全检查一下 Mleap )。

相反，我们在这里要做的是分享一个纯 Pythonic 式的端到端工作流，它将在几分钟内让您从 Spark 中训练的模型到服务于预测的公共端点。

我们的工作流程基于以下“原则”:

• 它是你所了解和喜爱的 Python，从头到尾(加上一个非常*的 yml 文件)；
• 这涉及到一些语言解析(在也是如此，我们确实热爱语言)；
• 它不会涉及部署服务器，甚至不会显式地编写端点(对于中等工作量也是免费的)；
• 我们将使用决策树来演示工作流，但同样的想法可以很容易地扩展到其他 Spark ML 算法。

不仅仅是一种部署 Spark 模型的方法(以及其他方法),我们将有机会看到一个真正的数据工程挑战，以及将一个模型规范从一种语言翻译成另一种语言是多么有趣(嗯，如果你喜欢这种事情)。

这是“懒于开发”系列的上一篇文章的概念性续篇，那篇文章的特色是 AWS Lambdas(还有什么？)和 Tensorflow 模型。

先决条件

在深入研究代码之前，请确保:

1. 有一个可用的 Spark 集群:为了方便，我们使用了由微软 Azure 提供的 Linux Spark 2.2，但是当然我们所说的任何东西也可以很容易地应用于其他设置；
2. 设置一个 AWS 帐户，它将用于将我们的代码部署到 AWS Lambda 。
3. 设置无服务器，可以按照这里的说明轻松安装(记住还要设置您的 AWS 凭证！).

你可以在我们的公共 GitHub repo 中找到所有代码:开始工作吧。

前传:在 Spark 中训练一个机器学习模型

Spark 机器学习库的内部工作不是本文的重点:如果你在这里，你可能已经知道如何训练你的模型——如果你知道，跳到下一节，因为我们唯一需要的是一个文本文件中训练模型的序列化版本。我们决定在 Spark 上包含一个*部分来共享一个端到端的、自包含的用例，所以我们只需要做最少的工作来获得一个经过训练并准备好使用的玩具模型。

SPARK 初学者注意事项:如果您已经为您的集群使用了 Azure 部署，您可以遵循微软的指南开始查询一些样本数据和/或花一些时间使用集群提供的示例笔记本。

The PySpark folder in Azure Jupyter contains several ready-made notebooks to get you started.

repo 中包含的 decision_tree_training 笔记本只包含加载一些数据并获得训练好的模型的基本步骤。我们使用的数据集是钞票认证数据集的 csv 版本(此处也有)，有四个连续变量作为预测变量，两个目标类，在数据集中用 1/0 标识:多亏了 Spark，我们可以用简单的 SQL 语法快速了解类的分布情况:

Notebooks will let you easily display basic statistics of your datasets, with tables and simple charts.

为了训练我们的决策树模型，我们只需要将数据转换为标签点，并将结果 RDD 馈送到机器学习库。

经过快速计算后，模型终于可以使用了！请记住，我们的目标是将我们在 Spark 上学到的知识转化为现成的无服务器端点，因此我们需要一种方法来提取我们在培训期间学到的数据知识，以便它可以在运行时应用于我们堆栈中的其他地方。幸运的是，决策树可以只用一行代码导出:

serialized_model = model.toDebugString()

serialized_model 包含在训练期间推断的决策规则列表，例如:

DecisionTreeModel classifier of depth 5 with 37 nodes
  If (feature 0 <= 0.23874)
   If (feature 1 <= 7.2797)
    If (feature 0 <= -0.36279)
     If (feature 2 <= 6.6779)
      If (feature 1 <= 5.496)
       Predict: 1.0
...
...
...

作为一个简单的 python 字符串，可以使用标准的 Spark 方法或通过简单的复制+粘贴将它导出到一个文本文件中(可以在 repo 中找到通过数据集训练生成的模型的副本)。

解决方案概述

下面详细介绍了我们快速而有效的解决方案。

Solution overview: from CSV to a lambda-powered endpoint.

从左至右:

• 我们从 Spark 读取一个 CSV 文件开始(当然，这里用您拥有的任何数据管道来代替)；
• 我们训练我们的 ML 模型(一个决策树)并使用 Spark 序列化选项来使它——可以说— 可移植；
• 我们编写了一个 Python 函数(细节如下),它将读取序列化的模型，并生成模型的 Python-runnable 版本；
• 我们在 AWS 中部署了一个基本的 lambda 函数，它将加载 Python-runnable 模型，并利用 API Gateway 向外界公开它的预测。

很明显，所有的神奇之处在于将模型从其 Spark 表示“移植”到 Python 可运行的代码中。在下一节中，我们将看到如何以一种有原则且优雅的方式来完成它:输入 DSL 解析。

作为形式语义学练习的模型转换

“这些是我的原则。如果你不喜欢他们，好吧，我还有其他人。”—格劳乔·马克斯

主要的见解(也是大部分的乐趣——在 Tooso 我们做了很多语言相关的东西！)是将问题视为一个语义挑战:我们有一种形式语言(Spark 序列化语言)，我们为它提供了一种模型理论意义上的解释，即我们需要找到一种系统的方法来将 Spark 模型的语法组件与 Python 数据结构配对，这样我们就可以通过这些结构运行预测，同时保留原始模型中的信息。听起来很难？让我们先用一个例子来建立我们的直觉(熟悉形式语义学思想的读者可以安全地跳过下一段)。

让我们拿正式的玩具语言 L 来说，这样定义:

• 字母表由整数 1、2 … 10 和运算符“+”组成
• 一个良构公式 (wff)是形式为 A + B 的任何符号序列，其中 A 和 B 是整数或 wff。

为了产生有效的句子，我们只需要应用(一次或多次)语言规则。例如，我们可以这样做:

A + B > 2 + B > 2 + 9

为了得到 wff‘2+9’，或者我们可以这样做:

A + B > 2 + B > 2 + A + C > 2 + 9 + C > 2 + 9 + 7

其中我们将第二步中的 B 展开为一个新的 wff‘A+C’，然后用整数填充公式得到‘2+9+7’。显然，在 L 中并不是所有的公式都是可以接受的:例如，下面这些都是无效的:

2 9 +
+ 2 9
2 9
12 + 2

L 是一种非常简单的语言，具有 no 的内在含义:虽然人类不可避免地会认为‘2+9+7’是基于 L 的算术运算2 + 9 + 7 (18)的表示，但是到目前为止 L 中并没有任何指定的东西可以证明这一结论(例如，很容易想象一个外星种族将+的含义与*互换:如果我们给他们的话)).为了赋予 L- 句子“自然”的算术含义，我们需要语义学家所说的模型(不要与机器学习模型混淆)，也就是说，我们需要以一种原则性的方式指定我们如何将“含义”附加到 L 句子上。由于“意义”是一个相当抽象的概念，我们将满足于更简单且对我们的教程直接有用的东西:我们将使用另一种正式语言 Python 来给出 L. 的解释

因此，我们的语义将是从 L 句子到 Python 指令的映射，这具有可操作性的非次要好处(这样我们就可以用 L 句子做运算)

我们的(粗略定义的)模型 M 可以如下:

• 整数 1，2 … 10 映射到 Python int 1，2 … 10
• 运算符“+”映射到 Python lambda lambda x, y : x + y
• 像 A + B 这样的一个 wff 映射到 Python 函数map(+, [A], [B]))，即一个 wff 是用实际值在'+'操作中“填充槽”的结果。

有了 M 的武装，我们现在可以将我们无意义的 L 语句翻译成易于理解的 Python 命令，这样‘2+9’就可以被视为一种 L 的方式来表达下面的代码:

map(lambda x, y: x + y, [2], [9]))

更复杂的东西会按预期进行翻译，因此“2 + 9 + 7”将变成:

map(lambda x, y: x + y, map(lambda x, y: x + y, [2], [9]), [7])

我们的建模语言 Python 很酷的一点是，表达式可以被运行，这样，既然它们有了意义，L-句子就可以被看作是进行算术计算的简洁的 Python 指令:对于所有的L-表达式，我们可以关联一个相应的、唯一的 Python 代码来运行那个表达式。

既然我们理解了模型构建的含义，我们可以回到 Spark 序列化模型的原始语言，即产生“wff”的语言，例如:

DecisionTreeModel classifier of depth 5 with 37 nodes
  If (feature 0 <= 0.23874)
   If (feature 1 <= 7.2797)
    If (feature 0 <= -0.36279)
     If (feature 2 <= 6.6779)
      If (feature 1 <= 5.496)
       Predict: 1.0
...
...
...

我们的目标是以一种有原则的方式给这些字符串赋予一个“Python 含义”，以便每个字符串都有一个相应的、唯一的 Python 代码来运行该决策树。

我们利用 lark 构建了我们的 spark2python 服务(在这个项目之前我们从未使用过它，我们非常喜欢它！)，这是一个很棒的工具，给定一个语法规范和一个目标字符串，它将生成一个“解析树”，一个组成字符串的语法片段的嵌套表示。我们跳过了带有 L 的树，因为这种语言足够简单，但是如果你想一想我们是如何构建“2 + 9 + 7”句子的，就很容易看出它的结构:首先将 2 和 9 相加，然后将结果相加为 7。

 +
          7
  +
2   9

当 lark 解析一个 Spark 模型时，结果是一个嵌套了 if/else 块的树(如预期的那样):一旦我们有了解析树，我们就可以逐个节点地导航它，并用等价的 Python 片段替换(非常类似于上面的L)Spark 令牌，我们可以对目标值的特征向量运行这些 Python 片段。

如果您查看处理程序中的 predict 函数(AWS lambda 入口点，见下文),您可以很容易地了解运行时发生的情况:客户端在调用服务时将一个特征向量作为查询参数传递；启动时初始化的 Spark2Python 类，加载 lark 语法并解析序列化的模型字符串。

当客户端提供的特征向量到达映射服务时， run_instruction 将开始遍历所有 if/else 块:对于每个节点，组成等式测试的令牌将被映射到相应的 Python 对象。例如，这个火花节点:

(feature 0 <= 0.23874)

将等效于 Python 表达式:

map(lambda x, y: x <= y, [feature_vector[0]], [0.23874])

将根据客户端作为输入提供的向量中的特征 0 来评估结果表达式。当到达一个预测节点时，例如:

Predict: 1.0

给定特征向量和存储的模型，程序将停止并向客户端返回预测值。

虽然 run_instruction 看起来令人生畏，但一旦上述直觉得到巩固，它实际上是一个相当简单的概念:程序将递归地遍历 if/else 树结构的分支，并在每次遇到适当的节点时运行等效的 Python 代码。这就是服务执行的“自动”转换的全部内容！

Runtime comparison of the input features with the model decision rules: at each node a decision is made and the corresponding branch is explored until a prediction is reached.

重要的是要理解我们的语义到底有多普遍。由于我们为 Spark 模型建立了正式的语法，然后定义了结果树的递归 Python 解释，所以我们“保证”所有未来的模型，无论有多长或如何嵌套，都将被系统正确执行，就像我们保证所有现在和未来的L-句子都可以被 Python 评估一样。俗话说，循环是人，递归是神。

(我们将在下面讨论这个问题，但是是的，显然有一个更简单的选择，那就是直接顺序解析模型文件。“蛮力”是有效的(利用 Python 和 Spark if/else 结构中的同构)，但是 DSL 方法不仅更优雅，而且也是尝试新事物的好借口，比如 lark 。

使用 AWS Lambda 服务模型

我们的承诺是在几分钟内为您的原型开发提供一个微服务，不需要服务器，只需要 Python 代码就可以了。实现这一点的方法是使用一个 AWS Lambda 来包装我们训练好的模型，并使用无服务器框架来发布我们的服务，让全世界都能看到！

并不缺少关于 Lambda 函数剖析的教程和解释(我们自己的版本是这里是)。对于那些在过去三年中被冷冻在石墨中的人，要点如下:

无服务器计算是一种云计算模式，允许您部署特定的功能/服务，而无需考虑底层硬件、操作系统甚至容器:计算是根据需要进行的，您只需为功能实际运行的时间付费。

无服务器功能由云提供商根据需要进行管理、运行和水平扩展，使开发人员能够自由地专注于业务逻辑，而不是部署/管理应用层。

AWS Lambdas 可以在 cron 上或通过几个“触发器”(队列中的新消息、s3 中的对象创建、通过 API 网关的 http 请求等)来调用。)，允许复杂的转换链和基于事件的管道。虽然使用 AWS 控制台来手动部署和管理 lambda 函数是完全可能的，但我们发现使用部署框架将使您的项目保持整洁、自包含和自动版本控制。

在这个项目中，所需的基础设施简单得令人尴尬(只有一个函数)，它被捕获在serverless.yml文件中(env 变量有合理的默认值，但是可以随意使用您的名称/资源)。函数名为预测，函数定义在handler.py文件中；最后，“触发器”是一个 http GET 请求，因此对 /predict 路由的调用将被路由到我们的函数。如果您对命名约定、目的地的 AWS 区域和分段满意，我们离工作端点就差两个简单的命令了。首先，我们需要确保项目中的vendored文件夹(或者任何你想用的名字:确保文件夹在那里！)包含该项目的依赖项(在 included requirements.txt中列出)；打开终端，将 cd 放入项目文件夹，然后键入:

pip install -t vendored/ -r requirements.txt

(请注意，在我们的例子中，依赖项是纯 Python，所以不需要担心 Linux 兼容的二进制文件；然而，作为使用 lambdas 时的一般最佳实践，您应该有一个合适的系统，比如这个系统，以确保您为 AWS 容器上传正确的依赖项！)

最后，(在安装了无服务器的情况下)，只需在终端中键入:

serverless deploy

无服务器将我们的函数部署到我们选择的 AWS 数据中心，并且自动为我们设置 API 网关，这样一个新的公共 URL 将可用，并且该 URL 将把所有的 /predict 调用路由到该函数。完成后(由于需要创建所有资源，第一次部署会多花一点时间)，您将得到类似如下的输出:

Serverless successful deployment output in the terminal.

为了确保一切按预期运行，打开浏览器并测试一个示例 GET 调用，例如:

https://YOUR-LAMDBA-URL/predict?features=-0.4629,4.496,6.59,2.0

其中YOUR-LAMBDA-URL是在上面的部署中创建的 URL。您应该会收到类似如下的响应:

Testing runtime prediction with a GET call directly from the browser.

恭喜你:你的大数据模型现在可以通过你的微服务获得了！通过交换模型文件(或者甚至用更多的处理程序/代码开关同时部署多个模型),您现在已经准备好使用这个模板并在不到一分钟的时间内部署任何决策树。

杂项注释和最终想法

“如果我们有数据，让我们看看数据。如果我们只有意见，那就用我的吧。”—吉姆·巴克斯代尔

像往常一样，我们设法保持教程的要点清晰简洁。我们忽略了一系列主题，因此下面是一个列表，按照笔记和临别感想的随机顺序，列出了我们在使用微服务服务大数据时所学到的内容。

• 虽然“正式保证”Spark 序列化模型将被服务正确评估，但我们在谨慎方面犯了错误，并为主要功能添加了一些非常简单的单元测试:在 Tooso 时，我们通常利用 pytest 来完成这些任务，我们鼓励您也这样做！
• 可能有人会说，整个语言映射的事情是太多了:给定 Spark 模型文件的特定结构(即多行、缩进格式)，将一个 txt 文件逐行翻译成一个 py 文件比形式语义简单得多！这确实是真的，我们在 playground 文件夹中为喜欢这种实用解决方案的读者提供了一个 10 分钟的脚本:虽然比 repo 的其余部分测试得更少，但代码是不言自明的，可以很容易地改进成一个可靠的转换工具，以生成 py 文件来“嵌入”特定的 Spark 决策树。如上所述，DSL 方法更有趣，也更通用:如果 Spark 模型彻底改变了序列化格式，一种新的 lark 语法就足以让原则性方法适应。
• 有人可能会说，整个语言映射的东西太少了:既然语言翻译如此有趣，为什么不加入一些机器学习呢？事实证明，深度学习最近通过 Seq2Seq models 等实现了一些令人印象深刻的翻译改进:一个想法可能是完全抛弃语义方法，用神经网络的方式来面对问题，即通过产生 Spark 模型和 Python 程序对，并训练 NN 来猜测映射函数。虽然这个看起来确实很有趣，但是我们想要一个更快的方法在两种格式之间转换；此外，在其他领域的类似尝试强调了一个不*的挑战:由于 Seq2Seq 人工语言输出有时几乎是正确的，我们如何说服我们的计算机运行看起来像 Python 但实际上不是 Python 的代码？
• 当运行决策树时，我们很容易选择在内存中*护和遍历该树；虽然这对于我们的目的来说很方便，但它不是唯一的(甚至可能不是最好的)选项。即使不考虑编译解析树，一个简单的选择是将模型持久化到 py 文件中:我们可以将解析树转换成 Python 函数，并在端点被调用时加载/执行后者。现在，我们让读者去探索这种可能性和其他可能性！
• 我们的 lark 语法读起来相当简单，但有些难看:我们喜欢设置 lark，但我们没有时间去超越对可用选项的直接掌握，所以我们只是直接寻找一些易于共享和使用的东西(例如，整个语法建立在instructions和full_comparison之间的递归关系上，这样比较可能包含 if/else 块，其内容本身可能是 if/else 块)。这里有很大的改进空间:只要记住，通过改变语法，树遍历函数将需要相应地调整。
• 对现有设置的一个简单扩展是使用 s3 作为共享卷来存储模型(和语法)。如果您的 Spark 管道将日常训练的模型序列化为例如my-s3-bucket/YYYYMMDD/model.txt，那么 lambda 可以通过使用 env 变量从my-s3-bucket中读取，以通过YYYYMMDD命名约定指定哪个模型是需要的。

作为最后的临别笔记，应该清楚的是，这些想法更多的是最终解决方案的草图，而不是准备投入生产的完整服务(在家里尝试一下，但可能还不是在办公室)。

撇开书呆子的兴趣不谈，这篇文章的总体理念是支持某种“数据科学家的自助式开发”:根据我们在 Tooso 和类似公司的经验，对于快节奏的分布式团队来说，创造/发明/破坏东西的人拥有快速、廉价(AWS lambda 对于前 100 万个请求 T10 是免费的)的低开销工具来自己构建复杂的数据管道是至关重要的，至少在开发阶段是如此。

但是，如果你非常喜欢这些想法，以至于想要将它们生产化，你至少应该考虑以下改进:进行一些一般的类重构以更好地抽象功能，压缩 lambda 部署中的文本文件，在类/端点级别引入适当的错误处理，考虑内存中与持久模型解释(如上所述)，提高测试覆盖率，在查询时检查端点参数的一致性(例如，检查所提供的特性是否与训练好的决策树所期望的相匹配)，等等。

编码快乐！

再见，太空牛仔

如果你想要一些其他的无服务器的灵感，查看一下我们关于如何建立一个网络分析平台的帖子或者我们关于服务 ML 模型的 T2 教程。

请在此分享您的反馈和意见，或在jacopo . taglia bue @ tooso . ai告诉我们您的大数据故事。

别忘了在 Linkedin 、 Twitter 和 Instagram 上获取来自 Tooso 的最新消息。

感谢

感谢 Tooso 联合创始人、来自 Makersight 的 Luca Bigon、Davide Romano 和 Matt McKinney 对这篇博文之前的草稿提出的有益评论:所有剩下的错误显然完全是我自己的。

从生物学到人工智能:感知机

原文：https://towardsdatascience.com/from-biology-to-ai-the-perceptron-81abfdc788bf?source=collection_archive---------20-----------------------

Python 中受生物启发的线性分类器

创造能像人类一样行动和推理的机器是一项长期的任务。虽然近年来人工智能(AI)和机器学习取得了很多进展，但一些基础工作在 60 多年前就已经奠定了。这些早期概念的灵感来自于生物神经网络(如人脑)的工作原理。1943 年，麦卡洛克和皮茨发表了一篇论文，描述了基于“全有或全无”活动特征的(人工)神经元在网络中的关系。这种“全有或全无”的特征是指生物神经元要么对刺激做出反应，要么保持沉默，没有中间状态。对这种行为的直接观察可以在人脑的微电极记录中看到。在这篇关于人工神经网络的初步论文之后，Frank Rosenblatt 于 1957 年发表了一篇题为“感知机——一种感知和识别自动机”的论文。感知器是一种受监督的线性分类器，它使用可调权重将输入向量分配给一个类别。与 1943 年麦卡洛克和皮茨的论文类似，感知机背后的想法是模拟生物神经元的计算来创造一个可以学习的代理。下面我们将看看感知器背后的思想，以及如何用 Python 代码实现它。

Hardware implementation of the Perceptron (Mark I)

这个想法

你的大脑包含数十亿个神经元，每个神经元都可以被视为一个处理单元，它整合输入并根据阈值标准创建二进制响应。在生物学术语中，输入是在神经元树突处的膜去极化，其向体细胞传播。如果去极化足够强，神经元将通过产生动作电位作出反应，动作电位将沿着轴突传播。在轴突末梢，神经递质将被释放到突触间隙中，这将使下游神经元的树突去极化。此过程的更详细描述可在这里找到。现在真正的线索是生物神经元网络可以学习如何对其输入做出反应。这种特性的术语是可塑性，正是这种特性使得静态软件和能够适应其环境的智能代理有所不同。然而，1943 年麦卡洛克和皮茨的论文并没有解决这个问题，而是关注神经元之间的关系。另一方面，感知器为可塑性问题提供了一个优雅的解决方案:权重。感知器的每个输入都乘以一个权重，然后将结果相加。因此，通过改变输入的权重，我们可以改变感知器的反应。下图给出了感知器如何工作的示意图。

Figure 1: Schematic outline of the Perceptron

在图 1 的左侧，输入表示为 x1、x2、x3…xn。每个输入乘以权重 w0，w1，w2，… wn。在这个乘法步骤之后，结果被累加并通过激活函数。在感知器的情况下，激活函数通过 亥*塞阶跃函数 类似于生物神经元的“全有或全无”特性。这意味着任何≤0 的值将被转换为 0，而任何值> 0 将变为 1。我们可以把上面的也写成:

其中 w 是权重向量， x 是输入向量， b 是偏差项。在图 1 中，我们已经将偏差作为 1(红色方块)包含在输入向量中，并作为 w0 包含在权重向量中。在这种情况下，我们只需要计算输入和权重向量的点积。但仍有一个问题:我们如何调整权重？毕竟这就是感知机的学习方式。思考这个问题的一种方式如下。我们的感知器应该根据输入做出二进制决定(0 或 1)。假设我们有两个数据点，一个属于类 1，另一个属于类 0，感知器必须学习每个数据点的类。下面的图 2 显示了该任务。

Figure 2: Geometrical interpretation

从图 2 中我们可以看到，这个问题可以被视为寻找一个决策边界，也称为超平面(红色虚线)，，它将两个组分开。红色虚线以上的一切都是 0 类，超平面以下的一切都是 1 类。超平面由垂直于它的权重向量 w’定义(红色实线向量)。因此，计算输入向量与权重向量的点积并将结果传递给激活函数将给出输入的分类。因此，如果我们看看数据点 1，我们也可以将其绘制为一个向量，并垂直于它绘制另一个超平面(黄色实线)。接下来，查看输入向量 2，我们可以再次绘制一个垂直于它的超平面(蓝色实线)。由于分隔两组的超平面需要垂直于我们正在寻找的权重向量，从图 2 中可以明显看出，w’必须位于黄色和蓝色超平面之间(标记为“用于 x 的范围】)。因此，按照上述内容，我们可以实现如下学习规则。

首先，我们将权重向量中的所有值设置为零，包括偏差项。在二*输入的情况下，如图 2 所示，这意味着: w = [0 0 0]。然后，我们将偏差 1 添加到第一个输入向量，得到 X(1) = [1，x1，x2]。现在我们计算 X1 和 w 的点积。这个计算的结果是 0。通过激活函数传递 0 会将 X1 分类为 0 类，这是正确的。因此不需要更新 w 。对 X(2)做同样的事情也会得到类 0，这是错误的，因此我们需要通过以下学习规则更新 w :

在这种情况下，这意味着从正确的类(1)中减去我们的结果(类 0)，将结果乘以当前输入向量，并将其添加到 w 。这将导致:w=【1 x1，x2】。如果有更多的数据点，我们将对每个输入向量继续这一过程，并且随着每次迭代，我们将更接近描述线性分离我们两组的超平面的权重向量。为了测试这一点，我们接下来将用 Python 代码实现感知器。

实施

为了开发我们的感知器算法，我们将使用通过 scikit-learn 生成的玩具数据。我们将使用 NumPy 实现所有其他功能。包含本文所有代码的完整 Jupyter 笔记本可以在这里找到。下面的代码将创建并可视化我们的玩具数据集。

# Import libraries 
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
import numpy as np# Generate dataset
X, Y = make_blobs(n_features=2, centers=2, n_samples=1000, random_state=18)# Visualize dataset
fig, ax = plt.subplots(1, 1, figsize=(5, 5))
ax.scatter(X[:, 0], X[:, 1], c=Y)
ax.set_title('ground truth', fontsize=20)
plt.show()

Figure 3: Data for testing the Perceptron algorithm.

图 3 显示了我们刚刚创建的两个集群，正如我们可以看到的，它们可以被一个超平面线性分离，这是感知器工作的先决条件。接下来，我们需要将偏置项添加到输入向量中，并用零初始化权重向量。

# Add a bias to the X1 vector
X_bias = np.ones([X.shape[0], 3])
X_bias[:, 1:3] = X# Initialize weight vector with zeros
w = np.zeros([3, 1])

好了，现在我们都准备好编码感知器算法了。从下面的代码中我们可以看到，这是一个非常简单和优雅的算法。因为不能保证感知器一遍就收敛，所以我们会在不断应用学习规则的同时，将所有训练数据连续 10 次馈入感知器，只是为了确保这一点。

# Define the activation function
def activation(x):
    return 1 if x >= 1 else 0# Apply Perceptron learning rule
for _ in range(10):
    for i in range(X_bias.shape[0]):
        y = activation(w.transpose().dot(X_bias[i, :])) # Update weights
        w = w + ((Y[i] - y) * X_bias[i, :]).reshape(w.shape[0], 1)

让我们来看看结果。下面的动画形象地展示了感知器是如何搜索一个分离两个聚类的超平面的。正如我们所看到的，它最终提出了一个解决方案，其中一个 1 类数据点位于超平面上。这个解决方案实际上是正确的，因为我们在前面的激活函数中指定:return 1 if x >= 1 else 0如果您感兴趣，您可以使用下面的激活函数重新运行上面的代码，看看结果如何变化:return 0 if x <= 0 else 1

结论

最后，在我们结束对以上的一些思考之前。正如我们看到的，感知器算法是一种实现监督线性分类器的简单方法。然而，它也有缺点。例如，当组不是线性可分时，它不起作用。此外，它是一个在线算法，这意味着我们一次只能传递一个训练示例，如果我们有一个更大的数据集，训练过程会很慢。尽管有这些限制，感知器实际上是一个重要的概念，启动了第一次人工智能炒作。具有讽刺意味的是，几年后，当它无法实现关于它的重大承诺时，它也结束了它。

如果你想要这个项目的完整代码，你可以在这里找到它。当然，你也可以在 Twitter 上关注我，或者通过 LinkedIn 联系我。

[## 阿克卡斯滕/感知器

在 GitHub 上创建一个帐户，为 akcarsten/Perceptron 的开发做出贡献。

github.com](https://github.com/akcarsten/Perceptron/blob/master/perceptron.ipynb)

从脑电波到具有深度学习的机器人运动:导论。

原文：https://towardsdatascience.com/from-brain-waves-to-arm-movements-with-deep-learning-an-introduction-3c2a8b535ece?source=collection_archive---------5-----------------------

用神经网络可视化和解码大脑活动。

你可以在这个在线合作笔记本中找到这篇文章的所有代码，你可以直接在你的浏览器上运行它。这里是 GitHub 回购。

在推特上关注我的工作更新和更多:【https://twitter.com/normandipalo

神经系统是一个极其复杂的结构。在你的全身，超过十万公里长的神经连接着你的脊髓和大脑。这个“网格”传输控制每个动作的电脉冲。每一个命令都来自你的大脑，一个更神奇的神经元结构，它通过电激活信号进行交流。理解和解释脑电模式是神经科学家和神经生物学家最大的梦想之一，但事实证明这是一项极具挑战性的任务。

一种记录大脑活动的非侵入性方法是脑电图(EEG) 。这是一种允许使用放置在患者头皮上的电极来记录脑电压波动的技术。通常，大约 30 个这样的电极被放置在头皮周围，允许记录脑电波的整体活动。总之，大脑活动和 EEG 信号之间的关系是复杂的，除了特定的实验室测试之外，对其了解甚少。因此，一个巨大的挑战是学习如何“解码”，从某种意义上说，这些脑电图扫描，可以允许控制机器人假肢和其他设备使用非侵入式脑机接口(BCI) 。

Example of brain waves recorded with EEG. CC BY-SA 2.0, https://commons.wikimedia.org/w/index.php?curid=845554

作为强数据驱动的学科，深度学习最近在相关模式识别任务中的突破，创造了一种使用神经网络分析这些电信号的新方法。在这篇文章中，我们将看到这个主题的介绍:我们将阅读由 Kaggle 竞赛提供的脑电图数据，该竞赛旨在检测哪些脑电图模式对应于特定的手臂和手势，如抓住或举起物体。在用不同的方式对数据进行预处理之后，我们将设计一个神经网络来执行这种分类。我也将展示一些大脑活动的数据可视化，以给出我们正在处理的数据的一个总体概念。该研究领域的最终目标是开发负担得起且有用的假肢装置，通过用大脑控制假肢，帮助截肢者重新获得轻松完成基本任务的能力。类似的技术也可以应用于读取肌肉电激活，从而通过分析激活的肌肉来解码一个人试图执行的运动类型。

你可以在这个在线合作笔记本中找到这篇文章的所有代码，你可以直接在你的浏览器上运行它。下面是 GitHub 回购。

数据简介

如果你有一个 Kaggle 帐户你可以在这里免费下载数据。正如您将看到的，该数据仅由几个组成。csv 文件。这些文件分别是:

• 用作模型输入的 EEG 数据，由放置在患者头皮上的 32 个电极记录。数据以 500 赫兹的频率记录。
• 测试人员试图实现的运动的逐帧标签，在 6 个可能的标签中。

这些数据是通过记录不同人类测试者执行简单动作(如抓取和举起物体)时的脑电图来收集的。因此，数据集被分成不同的剧集，但也有不同的主题。我们将在稍后的准确度预测中看到，脑电波可能是非常个人化的，因为一个模型可以非常准确地预测同一个人在看不见的情节中的意图，但是如果训练不够多样，在对新测试人员做同样的事情时可能会有困难。

因此，目标是创建一个神经网络，该网络将 EEG 读数作为输入，并输出测试者试图实现的这 6 个可能动作的概率分布。由于“无动作”不是一个可能的类，我们可以将其添加为一个类，或者将所有可能的输出设置为 0 到 1 之间的值，并使用阈值来决定是否检测到该动作。如果每个动作都低于阈值，我们就认为它没有动作。

Position of electrodes, source: https://www.kaggle.com/c/grasp-and-lift-eeg-detection/data

我制作了这些电极活动的动画数据可视化。由于采样频率相当高(500 Hz)，我使用了一个简单的 3 步低通滤波器来平滑数据，我用前 100 帧创建了一个动画，大约 1/5 秒。

Activations of the 32 electrodes in the first 1/5 of second.

我们还可以将时间数据可视化为 2D 热图，其中纵轴是时间(从顶部开始向下)，横轴表示 32 个电极。

EEG temporal heatmap. (time starts from top and goes down)

这也非常有用，因为正如我们将看到的，它将允许我们使用时空卷积。

数据预处理

这些原始数据应该进行预处理，以适应学习阶段。例如，与所执行的动作的相对低的变化率相比，EEG 的非常高的采样频率会导致许多问题:数据变化非常快，但是动作实际上保持不变，因此波动几乎可以被认为是噪声。此外，时态模型会接收大量快速变化的数据，而分类输出从不改变。

第一个可能的步骤是用低通滤波器对数据进行滤波。即使简单的移动平均也是可行的:通过这种方式，我们减轻了数据的高频变化，同时保留了更有用的低频结构，因为我们将分类的运动具有非常低的变化频率(最多 1Hz)。之后，我们可以对数据进行二次采样，即我们可以每 10、100 等只保留一个数据点。这也有助于减少时间*度，降低数据的相关性，在某种意义上使其更加时间稀疏。

可以采用许多其他预处理技术，但是为了简单起见，我们可以在这里停下来，开始设计我们的神经网络。

神经网络设计和实验

处理时态数据时，我们首先想到的架构之一是递归神经网络。这些网络具有动态结构，因此内部状态允许它们对时间数据进行编码，因此它们也基于过去的输入来计算输出。我在 Keras 设计了一个 LSTM 网络，用时序结构给它输入训练数据。结果很好，但在这个特殊的例子中，我更感兴趣的是展示一个常用于图像的卷积神经网络如何能够很好地处理时态数据。

如前所述，在某种意义上，我们实际上是在处理时空数据:上面显示的热图的垂直轴代表时间演变，而水平轴显示各种电极，并且接近的电极几乎总是在人类头皮上空间上接近。这意味着我们实际上可以用卷积提取有用特征:2D 核可以对时间和空间中的模式进行编码。想象一个 3x3 卷积核:它能够在热图中描绘的矩阵上，通过对三个不同的时间步长(3 个核行)以及三个不同的电极(3 个核列)进行加权求和来提取特征。因此，具有许多内核的 CNN 可以发现电极的激活如何在有限的时间周期内相对于期望的运动而变化的特征。

我在 Keras 中实现了一个简单的 CNN 来检查它在这个数据集上的性能。你可以在这个在线合作笔记本中找到这篇文章的所有代码，你可以直接在你的浏览器上运行它。下面是 GitHub 回购。

import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.layers import Embedding
from keras.layers import LSTM, CuDNNLSTM, BatchNormalization, Conv2D, Flatten, MaxPooling2D, Dropout
from keras.optimizers import Adammodel = Sequential()
#model.add(CuDNNLSTM(128, input_shape = (time_steps//subsample, 32)))
model.add(Conv2D(filters = 64, kernel_size = (7,7), padding = "same", activation = "relu", input_shape = (time_steps//subsample, 32, 1)))
model.add(BatchNormalization())
#model.add(MaxPooling2D(pool_size = (3,3)))
model.add(Conv2D(filters = 64, kernel_size = (5,5), padding = "same", activation = "relu", input_shape = (time_steps//subsample, 32, 1)))
model.add(BatchNormalization())
#model.add(MaxPooling2D(pool_size = (3,3)))
model.add(Conv2D(filters = 64, kernel_size = (3,3), padding = "same", activation = "relu", input_shape = (time_steps//subsample, 32, 1)))
model.add(BatchNormalization())
#model.add(MaxPooling2D(pool_size = (3,3)))
model.add(Flatten())
#model.add(Dropout(0.2))
model.add(Dense(32, activation = "relu"))
model.add(BatchNormalization())
# model.add(Dropout(0.2))
model.add(Dense(6, activation = "sigmoid"))adam = Adam(lr = 0.001)model.compile(optimizer = adam, loss = "categorical_crossentropy", metrics = ["accuracy"])model.summary()

为了检查我们模型的性能，正如 Kaggle 竞赛中所建议的，我们检查了 AUC 分数。如果你不熟悉 AUC 是什么，我建议这个清晰直观的解释。您可以在在线笔记本中自行查看，通过快速培训阶段，我们可以达到 0.85 左右的 AUC 分数。

通过训练不同的神经网络架构以及预处理技术等，可以实现许多改进，但这种概念的介绍性证明显示了神经网络从这种数据中学习的显著能力。

结论

在这篇文章中，我们介绍了脑电图的脑电信号，这是一种非侵入性和相对简单的记录用户头皮有用信号的方法。我们看到了一些数据的直观可视化，以及如何使用神经网络从中提取运动意图等特征。我相信，由于深度学习，更广泛的各种数据科学技术，平台和逐年增长的竞赛，这个领域(机器人假体，脑机接口)将有一个深刻的推动。

这些技术的影响将是巨大的。拥有可以以自然方式控制的低成本假体可以极大地改善数百万人的生活。

我建议你去看看symbion 项目，这是一个最近开始的项目，一些有才华的人试图拼凑一个低成本、智能手臂假体，可以通过肌肉激活来控制，以真正实现这种设备的大众化。

在推特上关注我的工作更新和更多:https://twitter.com/normandipalo

从业务问题到数据科学任务

原文：https://towardsdatascience.com/from-business-question-to-data-science-task-55a49f471a0c?source=collection_archive---------15-----------------------

数据科学任务的六种类型

每一个分析的开始，都应该有一个问题。在商业世界中，这是一个典型的与商业运作、战略或产品相关的问题。作为一名数据科学家，我的工作是将问题转化为数据科学任务。听起来很简单，但确实至关重要，因为要解决的特定数据科学任务定义了可以从数据和分析中得出的结论。

我在数据分析&洞察部门工作，在我的 Meetup 简介中，我说“我试图将数据转化为洞察”，在我的工作日，我经常大声说“我们需要创造(可操作的)洞察，并以数据为导向”——但这实际上意味着什么呢？这是我的数据哲学系列的第一部分，我试图剖析并理解“将数据转化为见解”的实际含义。

数据科学任务的六种类型

Jeffery T. Leek 和 Roger D. Peng 在" 中定义的问题是什么？ “六种日益复杂的数据科学任务:

在这篇文章中，我省略了“机械的”数据科学任务，因为它在日常数据科学问题和任务中很少出现(至少在我的日常工作中我从未遇到过)。

描述性和探索性数据分析

What is the number of active users per month? Is there a seasonal trend in the number of active users?

第一个例题是描述性问题。目标是获得现有数据样本的摘要。第二个示例问题是探索性问题，任务是总结，但也是探索潜在的相关性和趋势。通常，它的目标是处理数据，形成新的想法和假设，这些想法和假设可能会导致新的数据收集和实验。描述性和探索性任务中使用的方法范围从五数字汇总到与探索性数据分析相关的更复杂的方法(由约翰·图基大力推广)。对于示例描述性问题，我们将计算每月活跃用户的平均数量
(可能已经有了置信区间)；对于示例探索性问题，我们将从时间序列图开始。

推理数据分析

Is the user activity really different between customers that bought the product in May vs. June?

在推理问题的情况下，任务是量化观察到的模式是否可能超出现有的数据样本。统计推断
包括，例如统计假设检验。对于上面的示例问题，我们可以使用零假设进行统计测试，假设两个月之间的活动相同，使用替代假设假设活动不同。假设零假设为真，测试计算结果的可能性。如果非常*(即 p 值*于
预定义的显著性水平)，我们拒绝零假设，并认为存在显著差异。

推断性数据分析是我们开始产生可操作见解的地方，因为我们确保结果在数据样本之外有效，并且结果不是偶然的。然而，重要的是要理解，显著的差异并不一定意味着与业务相关的差异。人们还应该调查影响的大*，看看这种差异是否真的对业务有明显的影响。这被称为实用或
临床意义并且很可能是未来博客文章的一部分。

预测数据分析

Which of our users are most likely to churn?

推理数据分析可在群体层面(例如，在您的所有客户中)产生可操作的见解。如果问题是为个人发现可操作的见解，那么任务就是预测性数据分析。在这样的任务中，给定一组其他特征(自变量)，我们预测个体的一个特征(因变量)。要为示例预测性问题构建预测模型，我们需要一个数据样本，该数据样本具有描述客户是否流失(是/否)的目标特征“流失”,以及一组描述客户行为(产品活动、客户服务呼叫等)的描述性特征。).给定来自搅动用户和活跃用户的例子，我们可以将任务建模为二元分类问题。

一个成功的预测模型(通过定义的绩效衡量指标来衡量)会为特定的个人产生可操作的洞察力。因此，如果模型表明某个特定客户可能会流失，我们应该定义一个行动来防止流失。不幸的是，这个模型并没有告诉我们应该采取什么行动——最佳行动是你需要在实验中找到的。在这种情况下，通常不容易正式评估业务影响，整体成功是我们构建预测模型的好坏与触发行动的好坏的结合。如果我们还想估计最优行动，那么这个任务就叫做规定性分析，这也是未来博客文章的主题。

因果数据分析

Why are our users churning?

因果推理是关于“为什么”这个问题的 —理解描述我们业务或特定业务流程的特征之间的因果关系。在因果数据分析中，我们希望找出如果一个特征被改变，另一个特征会发生什么:平均起来，特征之间的关系的方向和大*是什么。在我们的示例问题中，我们可以(应该)问一个更详细的问题，例如，“用户流失是因为我们展示了太多的广告吗？”。为了回答这样一个问题，我们可以利用我们已有的观察数据的统计模型，或者进行特定的随机实验并收集实验数据来明确回答这个问题。第二个选项是当您执行 A/B 测试时会发生什么。这也是我们可以做的来回答我们的示例问题:进行 A/B 测试，其中一组用户看到较少的广告，并监控两组用户之间的流失率。

随机数据分析是这篇博文中描述的五个数据分析中最困难的任务。然而，如果做得好，它会产生最清晰的可操作的洞察力，因为我们实际上了解我们特征之间的因果关系。显然，因果推理的背后有更多的东西，我计划在以后的博客中写更多。现在，永远不要忘记
"cum hoc ergo proper hoc":相关性并不意味着因果关系！

从买方角色到数据科学中的职业角色

原文：https://towardsdatascience.com/from-buyer-personas-to-career-personas-in-data-science-f677873f2e02?source=collection_archive---------9-----------------------

image credit: BRIDGEi2i.com

场景 :班加罗尔一个新办公室里一个不太大的会议室。

时间戳 : 17 年前。

人物:一群背景和教育程度各异的年轻人:统计学家、计量经济学家、经理、顾问、投资银行家和信用评级师。

:作为第一批开始证明围绕“分析”的宣传是真实的公司之一，每个人都有在数据行业留下印记的远大梦想。

:梦想是伟大的，但对于这个新的、尚未定义的行业，什么构成了职业成长和职业道路？

听起来像一本新书的开场白？

当我们加入分析行业时，这是我们许多人的现实，当时用数据解决问题尚未开始其爆炸性的旅程。今天，随着越来越多的人接受数据科学的力量，年轻人蜂拥加入这一职业，这个问题仍然被提出。

如果我从事分析，我可以期待什么样的职业？

时髦的词语和天花乱坠的宣传给那些纠结于如何建立深度和广度的年轻人制造了更多的困惑；是选择早期专业化还是尝试直到他们找到自己的定位。

image credit: BRIDGEi2i.com

嗯，我想通过这篇文章回答的是，在分析领域的职业生涯与你看待任何其他职业选择的方式没有任何不同。它始于吉姆·科林斯经典著作《从优秀到卓越》中讨论的基本原则(刺猬原则)。

image credit: BRIDGEi2i.com

上图中的交叉点就是你在职业生涯中想要达到的位置。

关于数据科学家的工作以及他或她需要具备的独角兽式技能组合，已经有很多文章。在我看来，并不是所有的数据科学专业人员都需要具备所有这些技能；事实上，他们不能。

然而，这个职业需要一套多学科的技能，最适合解决商业问题，而不仅仅是那些看起来像是彼此克隆的人。

作为分析专家，我们习惯于创建买家角色来更好地了解我们的客户，并细分适合他们的产品。让我们在这里应用同样的逻辑。

我将在分析领域创建四个职业角色——四个完全不同的人，他们拥有不同的技能，在行业中有着非常成功的职业生涯。就像电影里说的那样，与你的老板或前任老板的任何相似之处纯属巧合。

image credit: BRIDGEi2i.com

四个角色。四种不同的选择。

你认为他们在开始职业生涯时知道自己最终会选择哪个方向吗？

大概不会。

他们是否拥有与独角兽数据科学家相同的技能？

肯定不是。

相反，他们所拥有的是:

• 理解和解决问题的强烈好奇心
• 愿意学习、忘却、再学习和帮助
• 倾向于扮演重要的角色，而不是担心指定
• 增加接触，发现自己的优势
• 导师和更广泛的网络来探索新的机会

他们找到了自己的路。

正如我们为不同的买家角色设计不同的优惠一样，并非所有的分析工作都是一样的。这个行业有跨越多个角色的角色。那么，为什么我们只是试图创造克隆？是的，随着这个行业如此活跃，发展速度如此之快，我们将很快看到新的角色演变，从“商业模式破坏者”到“梦想设计师”，再到“全脑营销者”。

所以，祝你们所有在这个领域刚刚开始职业生涯的人，也祝那些目前正处于十字路口、决定角色的人一切顺利。

正如一幅著名的漫画所说:

你不能呆在森林的角落里等着别人来找你。有时候你必须去找他们。

——**丨*丨*

在其中一个角色中认出你自己？让我知道这是否有助于你思考你的分析职业选择。我很想听听你的想法。

(本文最早出现在 BRIDGEi2i 博客 上，作者是 Prithvijit Roy，bridge i2i Analytics Solutions)**

如果你喜欢这篇文章，请给它一个掌声，并留下评论，以便它达到更多的专业人士和有志之士！

从经典的人工智能技术到深度强化学习

原文：https://towardsdatascience.com/from-classic-ai-techniques-to-deep-learning-753d20cf8578?source=collection_archive---------3-----------------------

建造能够从例子、经验甚至从人类水平的另一台机器学习的机器是解决 AI 的主要目标。换句话说，这个目标就是创造一台通过图灵测试的机器:当一个人与它互动时，对于这个人来说，他不可能断定他是在与一个人互动还是与一台机器互动。

深度学习的基本算法是在 20 世纪中期开发的。自那以后，该领域作为随机运筹学和计算机科学的一个理论分支得到了发展，但没有任何突破性的应用。但是，在过去的 20 年里，大数据集、特别标记的数据和使用图形处理器单元的计算机能力的增强之间的协同作用，这些算法已经在更复杂的技术、技术和推理逻辑中得到发展，能够实现几个目标，如降低语音识别中的单词错误率；在一场图像识别比赛中降低错误率[Krizhevsky 等人 2012]并在围棋中击败一名人类冠军[Silver 等人 2016]。吴恩达将这一成功归因于深度神经网络正确学习复杂函数的能力，以及其与输入数据成比例增长的性能。

如今，每个人都可以使用机器学习来创建一些有趣的项目，例如，在石油和天然气行业:

[## 石油和天然气工程项目中的数据科学。

探索性数据分析

towardsdatascience.com](/datascience-in-oil-and-gas-engineering-projects-daace6e6c7f)

或者享受探索泰坦*克号事故数据的乐趣:

[## 泰坦*克号数据集的特征工程和算法精度

机器学习最流行的数据集之一对应于泰坦*克号事故

towardsdatascience.com](/feature-engineering-and-algorithm-accuracy-for-the-titanic-dataset-5891cfa5a4ac)

然而，深度学习是一种机器学习，它允许由多个处理层组成的计算模型学习具有多个抽象级别的数据表示。【le Cun et al 2015】要理解这项技术，了解机器学习的主要技术很重要:

机器学习技术分为两种:监督学习，它训练一个模型，该模型以已知数据集(一个带标签的训练集)作为输入，并生成一个可以预测新数据未来输出的模型。无监督学习获取数据集(未标记)并在数据中寻找模式或内在结构，它通常作为聚类数据工作。一些最重要的机器学习技术在表 1 中进行了分类。

Table 1. Some machine learning techniques

如果您想更详细地了解这些技术，请查看下一篇文章，在这篇文章中，我用图形和简单的代码解释了它们:

[## 监督学习算法:解释和简单代码

监督学习算法采用一组已知的输入数据(学习集)和已知的数据响应(学习集)

towardsdatascience.com](/supervised-learning-algorithms-explanaition-and-simple-code-4fbd1276f8aa)

此外，强化学习问题涉及学习从经验中最大化数字奖励信号，也就是说，如何将步骤映射到行动(或创建策略)以最大化奖励效用。这种类型的机器学习不从标记数据的训练集中学习，它从与其环境的交互中学习。它尝试几种途径以最大化长期积累的报酬，也叫效用。强化学习的特点是:学习系统的行动影响其后来的输入，它没有直接的指示，如采取什么行动，以及行动的后果，包括奖励信号，发挥了长时间[萨顿和巴尔托 1998]。

利用高效算法进行无监督或有监督的知识发现 特征学习

深度学习是一种基于 20 世纪中期开发的一些基本算法的机器学习。其中大多数用于神经网络，下一节我们将展示一些最重要的机器学习算法。

机器学习中最强大的技术之一是神经网络，因为它可以在不同类型的机器学习的补充中实现，如接下来的会议所示。受人类大脑的启发，神经生理学家沃伦麦卡洛克和逻辑学家沃尔特皮茨提出了一种神经网络，它由高度连接的功能网络组成，这些功能网络映射了从输入到所需输出的路径。这是第一种数学方法。通过迭代修改连接的权重来训练网络。[M .沃伦，W .皮尔茨 1943 年]

神经网络具有从复杂或不精确的数据中获取意义的非凡能力，可用于提取模式和检测太复杂而无法被人类或其他计算机技术注意到的趋势。一个经过训练的神经网络可以被认为是它所分析的信息类别中的“专家”。然后，可以使用该专家对感兴趣的新情况进行预测，并回答假设问题。”【梅林等人，2002 年】

同样受到神经科学的启发，Rosenblatt[Rosenblatt et al f . 1958]开发了感知器，这是一种用于学习二进制分类器的算法，它将每个神经元的输出映射为 0 或 1；它采用输入向量 x，权重向量 w 并评估标量积是否超过阈值 u，即如果 wx-u>0 则为 f(x) = 1，否则为 0。在简单的层神经网络中，这种算法不是很有用，因为二进制分类是有限的。

另一方面，强化学习算法是从动态规划原理发展而来的。动态规划是一组可以解决所有类型的马尔可夫决策过程的算法。[贝尔曼 1957 年动态规划] MDP 是在随机情况下建模决策的数学模型。它们通常用图来表示，其中节点是状态，线是从一个状态到另一个状态的动作，从每个状态开始，每个动作都有一定的概率独立于过去的状态或动作而发生。每个新状态给出一个奖励(正面或负面)。解决 MDP 问题意味着建立一个使所有奖励总和最大化的政策。如果处于某一状态的概率不是 100%，问题就变成了部分可观测 MDP (POMDP)

贝尔曼首先提出了一个可以解决这个问题的方程。[1957 Bellman]这个递归公式提供了遵循期望最高回报的特定政策的效用。解这个方程意味着找到最优策略，这个问题很难解决，因为这个方程涉及一个最大化函数，它是不可求导的。这个问题使得强化学习领域没有任何相关的进展，直到 1989 年 Watkins 提出了 Q 学习算法[Watkins，1989。它通过计算状态对行为的量来解决问题。(莎莎)

最后利用时间差分(TD)学习算法保证解的收敛性。它是由 R. S. Sutton 在 1988 年提出。[Sutton et al 1988]自从他第一次使用它以来，它已经成为解决强化学习问题的参考。它确保大多数国家的参与，有助于解决伴随勘探-开采困境而来的挑战。

推理技术与深度学习的整合

当神经网络发展到不止一层时，深度学习就开始了。在几层神经元中工作只是走向深度学习和数据挖掘的第一步。在这一部分，我们将揭示第一部分的技术是如何集成到多层神经网络中的，它们共同开发了深度学习的基础。

最初，感知器被认为是解决一层神经网络，它作为一个一*分类器。这种技术在例如语音或图像分类中不是很有用，因为该技术必须对输入的不相关变化不敏感，例如照片的方向、照明、缩放，但是它们应该对区分图像和另一个图像(例如狼和狗)的细节敏感。

当多层感知器(MLP)在 1986 年由 Rumelhart 用一种称为梯度下降反向传播技术开发出来时，感知器开始只在多层网络中有用。反向传播是算法的集合，旨在分配正确的权重，使神经网络在学习中具有较低的误差。反向传播中最重要的方法之一是随机梯度下降(SGD)，这是一种算法，旨在使用微积分概念作为偏导数的链规则来最*化错误率[Rumelhart 等人，1986]。在该技术中，目标相对于神经元的输入的导数可以通过相对于该神经元的输出(即下一个神经元的输入)反向计算来计算。该技术传播所有导数或梯度，从顶部输出开始，一直到底部，然后直接计算每个链接的相应权重。

自 MLP 和 SGD 以来，在解决神经网络方面没有太多的进展，直到 1997 年提出了另一种称为长短期记忆 LSTM 的反向传播方法[Hochreiter et al 1997]，它缩短了正常的梯度下降法，并引入了递归网络的概念来学习长范围的依赖性。它倾斜得更快，解决了以前从未解决过的复杂的人工长时间滞后的任务。

在深度学习论文中，LeCun 解释了其对深度学习形成的重要性:“长期短期记忆(LSTM)网络使用特殊的隐藏单元，其自然行为是长时间记忆输入。一个称为存储单元的特殊单元的作用就像一个累加器或门控漏神经元:它在下一个时间步长与自己有一个权重为 1 的连接，因此它复制自己的实值状态并累积外部信号，但这种自我连接受到另一个单元的乘法门控，该单元学会决定何时清除存储器的内容【LeCun 等，Nature 2015】，

LSTM 网络可以训练某种类型的网络，称为递归神经网络(RNN)，可以为涉及顺序输入的任务进行训练，如语音和语言[Graves et al 2013]。RNN 在明年非常有用，但它没有解决深度学习的问题。

科学家还开发了另一种更容易训练的网络，这意味着它需要更少的例子来获得神经元之间连接的正确权重，并且它还可以进行更好的分类。这种网络被称为卷积神经网络(CNN ),其特征在于相邻层之间具有完全连通性。它首先出现在[Lecun et al 1989]中，应用于手写邮政编码识别。作者解释了 CNN 中的卷积层和池层是如何直接受到视觉神经科学中细胞的经典概念的启发。CNN 是发展计算机视觉的第一步。

结合神经网络和强化学习的系统是深度强化学习(DRL)的基础。在这种情况下，处于状态的代理使用深度神经网络来学习策略；根据这个策略，代理在环境中采取行动，并从特定的状态中获得奖励。奖励供给神经网络，它产生一个更好的政策。这是在一篇著名的论文《用深度强化学习玩雅达利》(playing Atari with deep reinforcement learning)[Mnih，V. et al 2013]中开发和应用的，在这篇论文中，他们学习一台机器直接从像素开始玩雅达利游戏，经过训练，这台机器输出了优秀的结果。

后来，AlhpaGo 团队开发了一个深度强化学习系统，使用了本次会议中引用的所有技术(LSTM，美国有线电视新闻网，RNN)，创建了一个能够学习玩围棋的人工智能系统，被训练观察专家，被训练与自己对弈，并最终击败世界冠军 Lee Sedol。这是人工智能的一个突破，因为由于游戏的复杂性，科学家认为让一台机器赢得这场游戏需要更多年的时间。[西尔弗等人，2016 年]

感谢阅读！！！

如果你想继续阅读这样的故事，你可以在这里订阅！

我喜欢与贝叶斯网络一起工作:它们允许人类学习和机器学习协同工作，即贝叶斯网络可以从人类和人工智能的组合中开发出来。除了跨越理论和数据之间的界限，查看下一个帖子来了解更多信息:

[## 贝叶斯思*导论:从贝叶斯定理到贝叶斯网络

假设世界上存在一种非常罕见的疾病。你患这种疾病的几率只有千分之一。你想要…

towardsdatascience.com](/will-you-become-a-zombie-if-a-99-accuracy-test-result-positive-3da371f5134)

参考书目

1。贝尔曼河(1957 年)。一个马尔可夫决策过程(编号 P-1066)。兰德公司圣莫*卡加州。

2。贝尔曼(1957 年)。动态编程。新泽西州普林斯顿:普林斯顿大学出版社。

3。Bottou，L. (2014 年)。从机器学习到机器推理。机器学习，94 (2)，133–149 页。

4。Ciresan 博士，Meier，u .，& Schmidhuber，J. (2012 年)。用于图像分类的多列深度神经网络。计算机视觉和模式识别(CVPR)(第 3642-3649 页)。

5。F. Vernadat，企业现代化技术:业务流程的应用，收款管理，经济学，1999 年

6。GONZALES N .:对“项目成熟度评估流程的实施:在汽车上的应用”的贡献，博士论文，2009 年 12 月 3 日

7。Graves，a .，Mohamed，A.-r .，& Hinton，G. (2013 年)。基于深度递归神经网络的语音识别。声学、语音和信号处理(icassp)，2013 年 ieee 国际会议。

8。赫布，国防部长(1949 年)。行为的组织。威利。

9。辛顿，G. E .，达扬，p .，弗雷，B. J .，&*尔，R. M. (1995 年)。无监督神经网络的唤醒-睡眠算法。科学，268 (5214)，1158–61。

10。Juang，B. H .，& Rabiner，L. R. (1990 年)。语音识别的隐马尔可夫模型。技术计量，33 (3)，251–272。

11。Krizhevsky，a .，Sutskever，I .，& Hinton，G. E. (2012 年)。基于深度卷积神经网络的图像网分类。神经信息处理系统进展 25(第 1097-1105 页)。

12。LeCun，y . beng io，& Hinton，G. (2015)。深度学习。自然，521，436–444。

13。LeCun，y .，Boser，b .，Denker，J. S .，Henderson，d .，Howard，R. E .，Hubbard，w .，& Jackel，L. D. (1989)。反向传播算法在手写邮政编码识别中的应用。神经计算，1，541–551。

14。勒昆，y .，博图，l .，本吉奥，y .，& H

国家能源研究所，P. (1998 年)。基于梯度的学习在文档识别中的应用。IEEE 会议录，86 (11)，2278–2323

15。利特曼博士(1994 年)。马尔可夫博弈作为多主体强化学习的框架。《第十一届机器学习国际会议论文集》(第 157 卷，第 157–163 页)。

16。麦卡洛克，沃伦；沃尔特·皮茨(1943)。“神经活动中固有的思想逻辑演算”。数学生物物理学通报。5 (4): 115–133.

17。麦卡洛克，沃伦；沃尔特·皮茨(1943)。“神经活动中固有的思想逻辑演算”。数学生物物理学通报。5 (4): 115–133.

18。非线性动力系统的建模、模拟和控制。泰勒和弗朗西斯，伦敦(2002 年)

19。Mnih，v .，Kavukcuoglu，k .，Silver，d .，Graves，a .，Antonoglou，I .，Wierstra，d .，& Riedmiller，M. (2013 年)。用深度强化学习玩雅达利。arXiv 预印本 arXiv:1312.5602。

20。罗森布拉特，F. (1958)。感知器:大脑中信息存储和组织的概率模型。心理评论，65，386–408 页。

21。鲁梅尔哈特，丁顿，g .&。通过反向传播误差学习表征。自然，323 (9)，533{536。

22。S. Hochreiter 和 J. Schmidhuber。长短期记忆。神经计算，9(8):1735–1780，1997。

23。西尔弗，d .，黄，a，，C. J .，盖兹，a .，西弗尔，l .，德里斯切，G. V. D .。。哈萨比斯博士(2016)。用深度神经网络和树搜索掌握围棋。自然，529 (7585)，484–489。

24。萨顿，R. S. (1988)。学会用时差法预测。马赫。学习。, 39.

25。萨顿，R. S .，&巴尔托，A. G. (1998)。强化学习:导论(第 1 卷第 1 号)。剑桥:麻省理工学院出版社。

26。沃特金斯，c . j . c . h .(1989)，从延迟奖励中学习。博士论文，剑桥大学。

从数据分析师到数据科学家

原文：https://towardsdatascience.com/from-data-analyst-to-data-scientist-f67a724ea265?source=collection_archive---------3-----------------------

Source: Matterport mask RCNN

一个人如何从数据分析师转型为数据科学家？

1. 去 LinkedIn 网站。登录。
2. 点击“编辑我的个人资料”。
3. 找到“数据分析师”这几个字，换成“数据科学家”。

搞定了。哇，那很容易。

不幸的是，生活没那么简单。在这里，我们承认，要从或多或少的数据中发掘洞察力，需要付出艰苦的努力。

有很多关于从数据科学起步的好文章(例如这里的和这里的)，但是关于从数据分析师转型的文章却很少。

在开始之前，我有必要尝试一下这两个角色的定义。

数据分析师收集、处理结构化数据并应用统计算法，以获得收益并改进决策。

一个数据科学家有类似的目标，但也有强大的处理大量非结构化数据的技能，可能接近实时处理。他们发现重要的信息，并能够对来自各种来源的数据进行清理、处理和运行高级算法。他们有很强的讲故事和想象技巧。

我经常遇到有才华的分析师，他们渴望开始他们的数据科学之旅，却因缺乏机会和不确定从哪里开始而沮丧。这促使我写了这篇文章。

为什么要成为数据科学家？

呃，事实上有很多原因…

影响 —产生巨大商业利益的潜力。一个被高层倾听并帮助塑造未来方向的机会。

精通— 在一个快速发展的领域中，有无数迷人的问题需要通过各种方法来解决。例如，建立一个图像识别器或文本分类器来识别社交媒体上的有毒评论。

相关性——有人预测人工智能最终会取代我们的工作。一种安全的方法是让 it 部门创造自动化，而不是等待自己被自动化。

报酬/机会— 乘坐大游艇四处旅行，在按摩浴缸里喝香槟。也许不会，但是薪水会相对较高。好的数据科学家很少，需求量很大；让那成为你，生活应该是美好的。

Data science — loads to learn (left) , robots taking our jobs (middle) and good pay but remember that The Wolf a Wall Street ended in tears! (right)

我已经是数据科学家了吗？

大多数分析师都有良好的基础，但需要多年的努力来发展技能，以便在复杂的结构和/或大型数据集上全面应用尖端方法。也就是说，不需要很长时间就可以开始取得成功，甚至达到超出我们早期预期的水平。

那么，我们在朝着什么技能努力呢？这个问题可能没有正确的答案，但是一个复杂的数据科学项目可能有一个包含许多元素的复杂管道。在数据科学发展的最初几年，人们可能会期望至少触及以下合理的部分:

数据科学语言 — Python/R

关系数据库 — MySQL、Postgress

非关系数据库 — MongoDB

机器学习模型 —例如，回归、提升树 SVM、NNs

图形 — Neo4J，GraphX

分布式计算 — Hadoop、Spark

云 — GCP/AWS/Azure

API 交互 — OAuth，Rest

数据可视化和 Webapps — D3，RShiny

专业领域— 自然语言处理、光学字符识别和计算机视觉

Boosted Trees models are popular in data science competitions

RShiny dashboards can be an effective way to develop an interactive means for others to explore data.

获得这些技能需要很多时间(可能比你的学位课程还要长)。即使是世界上最优秀的人也还有很多东西要学。然而，我们总是可以知道更多，不应该担心我们有局限性。如果我们每天都能变得更好一点，我们都有潜力在某一天达到相当高的技能水平。

决心和坚韧会比我们原始的智力更好地为我们服务。

行动（或活动、袭击）计划

在做其他事情之前，我们需要一些基本技能:

1. 从正确的哲学开始。十年前，等待数周时间被送去上数据软件课程可能是可以接受的。那些日子早已过去。到处都有奇妙的材料。让学习持续不断。不断练习技能。
2. 学习一门语言，发展你的数学技能——Python 和/或 R 是大多数人的起点。在像 Coursera 和 Udemy 这样的网站上有大量的免费培训。许多 Python 用户喜欢使用 Anaconda 和 Jupyter 笔记本。很多 R 用户喜欢 R Studio 。在数字方面，吴恩达机器学习课程和斯坦福神经网络课程都非常棒，学习起来非常愉快。
3. 解决问题——最好是你工作场所的真实问题，与商业专家和数据工程师一起工作。这是最好的端到端开发形式。
4. 进入ka ggle竞赛 — Kaggle 任务被划分范围和清理，但是没有比和其他几千人一起做一个具有挑战性的问题更好的方法来提高建模技能了。不要担心等级。从操场比赛开始，然后从那里开始。每个人都有起点，试一试吧。
5. 了解该领域的领导者在说什么 —有些人喜欢称之为“数据科学的摇滚明星”。这个*组做出了令人着迷的贡献，非常值得你花时间去做。留意像杰弗里·辛顿、吴恩达、扬·勒昆、雷切尔·托马斯和杰瑞米·霍华德这样的人。
6. 使用有效的工作方式——一旦奠定了基础，就开始使用版本控制系统来改进你的工作流程，例如 GitHub 来部署和*护代码。考虑集装箱化的码头工人。
7. 有效沟通——我们需要能够推销我们的作品。高管们喜欢闪亮的演示，所以一定要朝着你能在关键演示上展示的东西努力。

Lots of great materials on youtube. Andrew Ng’s state of artificial intelligence is fascinating.

Twitter can be another useful medium. Learn from the best such as Rachel Thomas.

获得正确的设置

即使拥有世界上所有的技能，如果你的组织没有合适的工具和环境，那么等待你的将是一场艰苦的斗争。很可能总是有我们无法控制的因素，所以我们需要考虑我们能够影响什么。

1. 迁移到正确的团队 —最简单的计划。大多数大中型组织都至少有一个*型数据科学团队。加入它。
2. 与合适的人合作 —如果不可能快速跳槽，那么就创造一个机会，与你认识的知识最渊博的数据科学家一起工作。例如，发现一个可以自动化的问题，然后与专家合作，而不是委托他们去做。
3. 支持合适的工具和环境—组织并不总是确定是否以及如何投资数据科学工具。他们需要担心传统分析交付的繁忙计划。安全和审计都需要时间来发展，所以他们只会听到有明显好处的强有力的业务案例。抓住机会支持适当的环境、工具和培训。
4. 开发清晰的用例 —了解您的业务以及如何应用数据科学。用一个*的概念证明将两者联系起来。利用成功来支持获得更多工具和环境的案例。
5. 与懂得比你多的有才能的人一起工作— 成为拥有你不具备的技能的高技能多元化团队的一员。你不仅会获得更多，还会潜移默化地学到他们的一些知识。

结论

现在是开始行动的最佳时机。今天就开始学习，尽快着手解决一个真正的问题。将没有回头路。坚持不懈，用你的成就给自己惊喜。珍惜这个机会。

从特征分解到行列式:带有直观例子的机器学习基础数学第 3/3 部分

原文：https://towardsdatascience.com/from-eigendecomposition-to-determinant-fundamental-mathematics-for-machine-learning-with-1b6b449a82c6?source=collection_archive---------13-----------------------

为了理解机器学习算法的数学，特别是深度学习算法，从基础到更高级建立数学概念是必不可少的。不幸的是，数学理论在许多情况下太难/抽象/枯燥，难以消化。想象你正在吃一个比萨饼，喝一杯可乐总是更容易和更有趣。

这篇文章的目的是为基础数学理论提供直观的例子使学习体验更加愉快和难忘，那就是鸡翅配啤酒，薯条配番茄酱，里脊配葡萄酒。

包含 3 门课程的机器学习基础数学课程组织如下:

从标量到张量:带有直观例子的机器学习基础数学第 1/3 部分

• 什么是标量、向量、矩阵和张量？
• 标量、向量和矩阵之间的加法
• 标量、向量和矩阵之间的乘法
• 单位矩阵和逆矩阵
• 对角矩阵和对称矩阵

从范数到正交:机器学习的基础数学与直观示例第 2/3 部分

• 向量的 1-范数，2-范数，最大范数
• 正交和标准正交向量
• 正交矩阵

从特征分解到行列式:带有直观例子的机器学习基础数学第 3/3 部分

• 矩阵的特征分解:特征值和特征向量
• 跟踪运算符
• 方阵的行列式

在本文中，我们将通过直观的例子，从特征分解到行列式来浏览第 3/3 部分。

矩阵的特征分解:特征值和特征向量

为什么我们需要分解？如果我们想发现事物的本质，分解是一种有效而实用的方法。假设你刚交了一个新朋友，把他/她分解成以下四个组成部分，可以帮助你迅速对具体的人建立更深入的了解。

同样的数学方法。一个整数可以分解成质因数，比如 20 = 2 * 2 * 5，也就是说 20 不能被 3 整除，20 的任何整数倍都会被 5 整除。

特征分解是一种将矩阵分解成一组特征向量和特征值的方法。非零向量 v 是方阵 A 的特征向量，如果它满足特征值方程:

其中 λ 是一个标量，称为向量 v 对应的特征值。

矩阵 A 的特征分解由下式给出

其中 V 为方阵，其第 I 列为矩阵 A 的第 I 个特征向量，diag(λ)为对角元素为对应特征值的对角矩阵。

例如，一个真实的矩阵:

可以通过非奇异矩阵 V 的乘法分解成对角矩阵:

上述两个向量方程可以由单个向量方程表示:

通过将 λv 移至左侧，我们可以得到

其中向量 V 非零，因为矩阵 V 是非奇异的。因此，

根据行列式矩阵的定义，我们可以有:

将解放回到上面的向量方程中:

解方程，我们有

因此矩阵对进行本征分解所需的矩阵为:**

举个例子，

跟踪运算符

线性代数中，方阵的迹被定义为主对角线上元素的和:

比如有一个 33 的矩阵 一个 ，*

****

trace 运算符的一些基本属性如下:

更一般地，轨迹对于将最后一个因子移动到第一个位置是不变的，这被称为循环置换，即，

方阵的行列式

什么是行列式？为什么我们需要了解如何计算矩阵的行列式？行列式的值在机器学习中有什么意义？

表示为 det( A )的方阵的行列式是可以从矩阵的元素中计算出来的值。对于一个 2*2 矩阵，它的行列式是:

对于 3*3 矩阵，行列式定义为

在 4*4 矩阵的情况下，行列式为

Photo credit to Wikipedia

行列式等于一个矩阵的所有特征值的乘积，我们可以用行列式把一个矩阵映射成一个实标量。您可以使用 numpy.linalg.det 来计算数组的行列式。

scipy

行列式是机器学习算法中一个重要的数学概念，例如广泛使用的降*解决方案:主成分分析(PCA)。正如我们所知，一个矩阵可以被视为空间的线性变换，其行列式的值可以被认为是用这个矩阵变换空间时得到的乘法变化，可以是旋转、缩放或方向变化等。

恭喜你！您已经完成了第三部分，也是最后一部分机器学习的基础数学和直观示例。

“哪里有数字，哪里就有美。”—普罗克洛斯

基础数学理论的美妙之处在于它们永远不会过时。十年后的 2028 年，软件开发人员和数据科学家可能不会再使用 Python 或 TensorFlow 了。但标量还是标量，矩阵还是矩阵，张量还是张量。矩阵求逆的充分必要条件和现在一样。基础数学能够经受时间的考验。你可以在这个系列中投资一周或一个月。幸运的是，收获是你可以终身应用的知识和技能，因为“数学是一种思*方式。”

报名参加🦞:的 Udemy 课程

具有机器学习和统计的推荐系统

https://www.udemy.com/course/recommender-system-with-machine-learning-and-statistics/?referralCode=178D030EF728F966D62D

从探索到生产——弥合深度学习的部署差距(第 1 部分)

原文：https://towardsdatascience.com/from-exploration-to-production-bridging-the-deployment-gap-for-deep-learning-8b59a5e1c819?source=collection_archive---------7-----------------------

这是关于深度学习模型探索、翻译和部署的两个博客系列的第一部分。两者都涉及许多技术，如 PyTorch、TensorFlow、TensorFlow Serving、Docker、ONNX、NNEF、GraphPipe 和 Flask。我们将协调这些技术，使用更具挑战性但不太受欢迎的 EMNIST 数据集来解决图像分类的任务。第一部分介绍 EMNIST，我们用 PyTorch 开发和训练模型，用开放的神经网络交换格式 ONNX 翻译它们，并通过 GraphPipe 服务它们。第二部分介绍 TensorFlow 服务和 Docker，以及一种相当业余的方法，在这种方法中，我们构建了一个服务于我们模型的简单 web 应用程序。你可以在 GitHub 上找到所有相关的源代码。在这里你可以找到第二部分。

弥合差距，迈向人工智能驱动的社会

吴恩达是人工智能摇滚明星。作为斯坦福大学的教授，Coursera 和 deeplearning.ai 的联合创始人，他极大地推动了人工智能教育和应用。他可以被认为是这个领域学生最多的老师，这为他赢得了很大的权威。由此，他创造了人工智能这个术语，称之为点燃新工业革命的新电力。但是，与这种说法的轻松形成对比的是，将电力从实验室输送到数百万家庭和工厂需要付出巨大的努力。它需要人力、大量投资和切实可行的解决方案来将其从理论付诸实践，并使之成为大众的一件理所当然的事情。吴恩达也知道这件事。

回到艾的类比，情况是相似的。在人工智能方面有无数的研究，在医疗保健、交通运输或商业方面也有越来越多的实际应用——仅举几例。然而，大多数人仍然远远没有积极地将人工智能视为日常生活的一部分。可能有政治、社会或文化因素减缓适应。公平地说，当我们谈论人工智能时，我们也需要更精确地了解我们的意思。狭义人工智能和广义人工智能之间的区别表明，我们还没有越过许多人实际谈论人工智能时所指的那一点。

不管怎样，为了解决缺乏大众参与和理解的问题，我们需要 让人工智能更容易接近。在他在 2017 年人工智能前沿会议上的演讲中，吴恩达分享了他对人工智能社会的愿景，以及为人们提供所有工具来实现这一愿景的必要性。在我看来，这与更好地弥合勘探和生产之间的差距是齐头并进的。我指的是从概念和开发阶段到部署的机器学习模型的步骤。模型部署赋予模型生命，使它们对大众来说是可访问的，并允许我们看到它们的真实性能。按照吴恩达的类比，我们可以将人工智能的探索-翻译-部署与电力的产生-运输-消耗进行比较。为了让人们能够做到这一点并弥合差距，我决定写一篇博客，整合从探索到部署神经网络模型的不同技术。

使用 PyTorch 的 EMNIST 图像分类模型，使用 ONNX 的翻译，使用 GraphPipe 的部署

在这个从探索到生产的教程中，我们将使用神经网络解决一个监督学习任务，并通过 web 服务提供预测。我们将其分为以下 4 个步骤:

• 数据探索
• 模型开发
• 模型翻译
• 模型部署

从探索阶段开始，我将首先介绍 EMNIST 数据集并概述其特征。其次，我们继续构建和探索神经网络，通过为图像分配正确的数字和字符标签来学习输入和输出之间的正确映射。几次迭代将很快为我们提供令人满意的精度水平。请注意:我不会在这里详细讨论数据科学主题，因为这不是这篇博客的重点，所以数据和模型探索将是相当肤浅的，进一步的模型调整留给你。在第三步中，是时候离开实验室卷起袖子了:我们将模型转换成独立于框架的表示。在最后一部分，我们导入这个表示，将它转换成一个可部署的模型，并配置推理接口，使它对用户可用。

数据探索:EMNIST 数据集

手写数字的 MNIST 数据集是数据科学事实上的 Hello World (在 Iris flower 数据和 Boston pricing 之间)。 EMNIST 由美国国家标准与技术研究所(NIST)提供。它通过手写字符(大写和*写)的图像来扩展数字。28x28 像素和单一颜色通道(灰度)的图像具有与 MNIST 相同的格式。整个数据集包含来自 62 个类别(10 个数字、26 个*写字符和 26 个大写字符)的 814，255 个图像。对于那些对更多细节感兴趣的人，可以看看 2017 年相应的论文。由于其易于访问、有限的大*和易于掌握的结构，MNIST 已经成为各种深度学习教程的真正普及点。然而，在我看来，它也被过度使用了。因此，我决定对这篇博文的实用部分更进一步，它离现有内容不太远，但足以增加一些多样性。

NIST 以两种不同的格式提供 EMNIST 数据集:二进制和 Matlab。我决定继续使用 Matlab 格式，如果你喜欢走同样的路，欢迎你使用合适的装载机。读取图像和标签为我们提供了 697 932 个训练和 116 323 个测试示例，这几乎是我们在这里保留的 6:1 训练-测试分割。下面，您可以从数据集中看到一些示例:

EMNIST 带来的一个问题是高度不平衡的阶级分布。所有这 10 个数字构成了训练和测试数据集中大约一半的实例。在信件内部，也有两方面的巨大不平衡。首先，跨越大写和*写字母。这尤其适用于英语中一些最常用的字母，如 e 、 s 、 t 或 o 。第二，在大写字母和*写字母之间有很大的不平衡，这反映了语言中不同的使用频率。然而，还有一个好的方面:字母份额在整个训练和测试数据分布中几乎保持不变。

这种不平衡的数据会妨碍分类模型正确地学习正确的模式-标签匹配。有很多方法可以预测这一点，各有利弊。我们可以对类进行缩减采样以实现均匀分布。我们可以通过复制代表性不足的类实例或创建合成样本来增加数据的采样。但是，我们也可以调整稍后的训练损失计算，使得未被充分代表的类获得更高的权重，以便分类错误同等地影响损失，而不管它们的潜在频率。但是，按照我的说法，这不应该是我们关心的问题。

模型探索:使用 PyTorch 开发神经网络模型

根据我们对数据的第一印象，我们可以开始探索有用的模型。这通常是一个迭代过程，包括建立一个模型，训练它，并评估它在我们的测试数据上的性能，以估计它的泛化能力。然后，我们选择最好的一个(或多个)并将其投入生产。

关于我们如何在数据科学中失败的简短说明

这个过程也包括很多失败，如果你失败得快，学得也快，这绝对没问题。因此，我一般区分三种失败:

• 技术的
• 数学的
• 性能方面

技术失败是由于 API 的不正确使用导致了不可编译的模型或运行时错误。例如，在神经网络中实现一个完全连接的层，我们必须定义该层的权重矩阵期望的单元数和输出单元数。如果我们现在将该层堆叠在不满足定义的*度的输入层之上，则模型定义过程或实例化将导致错误。这种类型的问题通常很简单，或多或少容易检测和纠正。它专注于我们脑海中的模型的现有概念的实现。

数学识别和修复失败会变得更加复杂。由于高偏差和/或高方差而表现出一般预测质量的模型大多属于这一类。这意味着一个模型被正确地定义并成功地在训练数据上运行——从技术的角度来看——但会导致不合逻辑或完全糟糕的结果，因为该模型没有学习到从输入到输出数据的适当映射。我们可以将这些问题归因于不利的超参数或不适当的模型架构。例如，我们可以选择一个过高的学习率，并看到我们的损失函数大幅振荡，而不是收敛。这类问题通常涉及更深入的原因分析，有时需要大量的反复试验。他们的解决方案从经验、领域知识和对理论基础的扎实理解中受益匪浅。

性能方面的失败是达不到我们期望的车型的特征。这些期望可以是面向质量或效率的，并且与分类准确度、假阳性的可容忍量有关，但是也与训练持续时间、模型复杂性或关于后来的可扩展性的推断时间有关。在这个失败的最高阶段，我们看到的模型在技术上是正确的，并成功地从我们的数据中学习。但是我们仍然对他们学习的内容和方式不满意。例如，我们可以在图像上训练浅层神经网络来正确地对它们进行分类，并且我们的模型以 60%的分类精度收敛。因此，我们可能对其结果不满意，并可能增加模型的复杂性以提高准确性。

选择正确的深度学习框架

正如我们所看到的，一个模型需要通过不同的质量关。一般来说，需要多次迭代来驱动我们的方法通过它们。特别是对于初学者，我因此建议使用支持快速失败和学习的框架，以及促进我们理解为什么失败。当我开始构建我的第一个神经网络时，TensorFlow 的版本是 1.0。现在我们正在接近 2.0 版本。它是最广泛采用的深度学习框架，具有强大的社区，并由 Google 支持。我已经习惯了用它来解决问题的有时相当不自然的方式。与之相反的是，PyTorch 已经成为一个强大的竞争对手，得到了社区和脸书的大力支持。TensorFlow 是一个成熟的框架，具有一些有用的功能，如用于可视化的 TensorBoard 和用于模型部署和生产的 TensorFlow，但它也有一点静态图形范例的缺点，这会减慢失败和学习的速度。在这里，PyTorch 更好地集成了 Python 数据科学生态系统，而是使用了一种动态图形范式，让您可以轻松快速地探索变量并对故障做出响应。然而，它缺少一些功能和成熟性，而且人们还必须提到，TensorFlow 正以其急切的执行模式预测动态图，该模式宣布将成为“2.0 的核心功能”。我把这篇博客作为一个机会来更加熟悉 PyTorch，特别是探索我们如何从不同的世界中获得最大的收益。为此，我将把重点放在 TensorFlow 和 PyTorch 这两个最重要的框架上，并避免比较其他框架，如 CNTK 或 Caffee。

PyTorch 中的神经网络建模

回到 EMNIST 和我们的数字和字母分类问题:
在本节中，我们构建了两个不同的模型，并在 EMNIST 训练数据集上对它们进行训练。首先，一个简单的线性模型将输入与输出单元完全连接起来，并对输出单元应用 softmax 函数来预测与最高输出值相关的类。其次，我们通过添加两个也完全相互连接的隐藏层来增加这个浅层神经网络的深度。作为损失函数，我们使用平均交叉熵。为了反向传播损失并执行梯度更新，我们使用 Adam 优化器，该优化器在随机梯度下降中对逐渐减*的学习速率使用自适应动量。此外，我们使用每个具有 128 个图像的*批量，并且训练五个时期。在看到我的 JuPyter 笔记本内核芯片有将近 100 GB 的压缩内存后，我决定不使用所有测试实例进行评估，而是随机抽取 5%的子集用于每个评估步骤。然而，我们应该使用整个测试数据集，并在训练后分批评估，以获得对两个模型的泛化能力的更可靠的感知。参考这个笔记本的代码，自己试试。

线性模型

首先，我们加载 EMNIST 数据集，并为后面的训练过程设置一些信息变量:

接下来，我们从 NumPy 数组中轻松地创建 PyTorch 张量作为基本数据构建块。此外，我们将灰度图像的像素值归一化为单位间隔，并将它们展平。在 PyTorch 中，我们不必为分类任务对标签进行一次性编码。这是 PyTorch 内部处理的。这里我们唯一需要注意的是以整数格式提供它们:

现在，我们将线性模型定义为一个继承自torch.nn.Module的新类。我们通常在构造函数中定义模型，并覆盖forward方法。在训练期间，我们向它传递输入数据，它执行正向传播并返回输出层的结果。这是 PyTorch 中一个模型的最*配置，具有简单的可扩展性，我们将在第二个模型中看到:

在我们建立模型之后，我们创建一个模型实例并定义损失函数(最*化的标准)。此外，我们通过为优化过程传递模型参数和适当的学习率来设置 Adam 优化器:

为了控制总的训练持续时间，我们定义了历元的数量，即训练数据的完整遍数，以及适当的批量大*。为了在整个训练过程中跟踪和可视化模型性能，我们还提供了一些保持训练和测试数据集的损失和准确性的列表。最后，我们定义评估的频率:

现在，我们可以建立一个贯穿各时期和批次的训练程序。每次迭代，我们从训练数据中抽取一批，重置之前累积的梯度，执行向前传递以获得预测，并计算由预测和真实值之间的偏差导致的损失。我们通过调用它的backward()函数来反向传播这个损失，并执行相应地调整网络参数的参数更新。可选地，我们采用当前模型，并将其应用于测试数据进行评估。现在我们都准备好开始训练程序了。

下面是我们从中得到的:测试准确率收敛到 68%左右。通常，我们现在会进入一些更深层次的错误分析，例如，通过参考混淆矩阵来识别哪些类别的模型是特别错误的，或者通过根据它们的逆频率来调整我们的损失函数加权代表不足的类别。

为了说明从 PyTorch 中现有的模型定义进行扩展是多么容易，我宁愿通过添加两个隐藏层来将现有的架构扩展到深度神经网络。没有一个体面的讨论是什么构成了 DNNs 实际上是深的，让我们去做它，简单地调整一下我们的网络。然而，如果你想有所准备，请咨询古德菲勒、本吉奥和库*尔这里。

深度神经网络

一旦我们设置了周围的参数和跟踪能力，交换或调整模型是相当容易的。我们可以在现有的基础上定义更多的类，或者按照上面已经显示的结构定义全新的模型。在这里，我们通过扩展层数以及定义将这些层相互连接的操作来类似地定义 DNN。这里，我们应用指数线性单位函数来激活隐藏层的逻辑。

最后，我们观察 DNN，以达到更准确的线性模型分类结果。当然，我们坚持使用更精确的模型，因为它在测试数据集上表现得更好，大约有 78%的精确度。这种性能作为泛化能力的代理，我们希望使用我们期望在新数据上很好地泛化的模型。

不言而喻，这些结果远非真正令人满意和严谨。相反，它们用于说明目的。我们可以用层次模型结构扩展我们的方法，首先区分数字和大*写字母，然后再进行识别。我们也可以转向使用卷积神经网络。然而，这里的重点不是模型调整，而是更好地将探索与生产联系起来。因此，我们在这一点上完成了模型开发，并继续进行模型转换。

模型转换:使用 ONNX——开放式神经网络交换格式

在模型探索和选择之后，我们不得不考虑如何将模型投入生产。部署依赖于框架的模型可能具有挑战性。一般来说，有两种范例可以在更高的层次上实现这一点:一方面，可以使用用于建模和训练的框架，例如通过实现嵌入前向传播的 web 服务。另一方面，人们可以跨越框架边界，混合使用各种技术。我个人更喜欢使用不同世界的精华，并希望说服你也这样做——通过轻松和一些指导。话虽如此，让我们跨越鸿沟，超越界限。

首先，我们阐述了在生产中部署机器学习模型的一些标准:

• 高性能和可扩展性
• 灵活性
• 互通
• 到期日

该解决方案需要处理请求的并发性和频率，并在传输、预处理、前向传播和后处理方面高速处理这些请求。如果资源耗尽，还需要快速适应传入的请求，特别是在容错(可靠性)方面。灵活性是指语言支持、配置和模型处理。互操作性涉及以最少的努力支持多种框架和格式。最后，如果没有满足某些标准，那么成熟度从一开始就可以获得回报。成熟促进采纳，从而促进讨论、解决问题以及想法的多样性和数量。这使得从新事物开始变得更容易。然而，如果解决方案在某些点上已经非常好了，这并不重要，因为在开始时，很少有人采用它。

https://onnx.ai/

开放式神经网络交换格式(ONNX)

ONNX 代表 开放神经网络交换格式 ，号称是“可互换 AI 模型的新开放生态系统”。它提供了一种标准格式来表示深度学习模型，并通过在框架之间轻松共享模型来实现互操作性。它由亚马逊、脸书和微软支持，自 2017 年以来一直存在。ONNX 格式定义了计算图形模型。在他们的 GitHub 页面上有很多关于从不同框架导出和导入的教程。Caffee2，微软认知工具包，MXNet，PyTorch 原生支持 ONNX。还有用于 TensorFlow 和 CoreML 的连接器。随着 TensorFlow 2.0 公告指出“交换格式的标准化”，我们也可能希望 TensorFlow 很快就能原生支持 ONNX。然而，在 GitHub 正在进行的讨论中，我们可以看到一些官员犹豫不决的反应。总的来说，ONNX 可以被视为 PMML预测模型标记语言(PMML) 的现代、可访问和专注于深度学习的继任者，用于以框架非特定的方式表示预测模型和数据转换。

幸运的是，PyTorch 已经集成了 ONNX，因此提供了功能来将模型导出为 ONNX protobuf 格式。因此，我们用torch.onnx.export导出我们的模型，并向它传递模型、保存它的路径和示例输入。由于模型导出本身通过跟踪工作，我们需要提供这个示例输入。这意味着调用导出会触发模型使用该输入执行向前传递，并记录参与计算输出的操作符的踪迹。因此，该示例也可以是随机数据，但是需要与我们为模型输入指定的形状相匹配。最后，我们还可以指定模型参数的名称。现在，我们可以将其应用于训练好的深度神经网络dnn_model以获得输出文件:

模型部署:高效模型服务器实现的 GraphPipe 和 Docker

Oracle 最近发布了 GraphPipe 来“简化机器学习模型部署，并将其与特定于框架的模型实现分离。”GraphPipe 的机器学习传输规范使用了谷歌的 flatbuffers 。它为 TensorFlow、caffee2 和 ONNX 提供参考模型服务器，并为 Go、Java 和 Python 提供客户端实现。集成 ONNX 支持扩展了它对更多深度学习框架的支持。尽管它接受 ONNX 作为独立于框架的模型格式，但 GraphPipe 使用特定于框架的模型服务器。通过调整模型服务器配置和标准化客户端-服务器通信，GraphPipe 在服务器效率和性能方面表现出色。各个模型服务器嵌入到他们网站上提供的 Docker 容器中。ONNX 模型服务器接受 ONNX 模型以及 caffee2 NetDef 格式的模型。TensorFlow 模型服务器处理 TensorFlow 模型、SavedModel 和 GraphDef 格式。以下是 GraphPipe 如何处理请求的总结:

本质上，GraphPipe 请求的行为类似于 TensorFlow-serving predict 请求，但是使用 flatbuffers 作为消息格式。Flatbuffers 类似于 google protocol buffers，具有避免在反序列化步骤中进行内存复制的额外好处。flatbuffer 定义提供包括输入张量、输入名称和输出名称的请求消息。GraphPipe 远程模型接受请求消息，并为每个请求的输出名称返回一个张量。远程模型还必须提供关于它所支持的输入和输出的类型和形状的元数据。

ONNX 和 GraphPipe 并不是促进互操作性和部署简易性的唯一技术。几乎在 GraphPipe 发布的同时，Khronos Group 发布了其神经网络交换格式(NNEF) 作为支持互操作性的新标准。此外，使用Glow——一个用于神经网络硬件加速器的编译器,有了另一种将不同框架的模型转换成通用标准的方法。请随意检查它们，不要忘记分享您的经验。在这篇博文中，我们现在将集中讨论 ONNX 和 GraphPipe，然后回到实际部分。说到这里，让我们回到我们的 EMNIST 图像分类模型，并通过 GraphPipe 提供它。代码可以参考这款 JuPyter 笔记本。

首先，确保你的机器上安装了 Docker。其次，用docker pull sleepsonthefloor/graphpipe-onnx:cpu和docker pull sleepsonthefloor/graphpipe-tf:cpu拉动 graphpipe-tf 和 graphpipe-onnx 容器图像。第三，使用pip install graphpipe 安装 GraphPipe 客户端来测试我们的模型。更多信息，请参考用户指南。这些参考资料使用简单，让我们可以通过运行的模型服务器快速提供深度学习模型。我们继续使用 ONNX 模型，并使用端口 9000 从存储库的根目录启动我们的模型服务器。为此，我们必须首先创建value-inputs，这是使用 graphpipe-onnx 服务模型所需的。不幸的是，用户指南中关于如何设置value_inputs.json的信息非常少:

--value-inputs string value_inputs.json for the model. Accepts local file or http(s) url.

然而，我们可以遵循示例性 Squeezenet 输入的结构，假设外部列表描述每个请求的批量大*，内部列表保存输入*度:

{"data_0": [1, [1, 3, 227, 227]]}

{"flattened_rescaled_img_28x28": [1, [1, 784]]}

现在可以用下面的命令启动模型服务器了:

docker run -it — rm \
 -v “$PWD/models:/models/” \
 -p 9000:9000 \
 sleepsonthefloor/graphpipe-onnx:cpu \
 — value-inputs=/models/dnn_model_pt.value_inputs.json \
 — model=../models/dnn_model_pt.onnx \
 — listen=0.0.0.0:9000

不幸的是，我们失败了，并显示以下日志消息(有关完整的日志，请参阅笔记本):

terminate called after throwing an instance of ‘caffe2::EnforceNotMet’
 what(): [enforce fail at tensor.h:147] values.size() == size_. 784 vs 1229312

这似乎是一些张量形状没有按照预期设置。然而，如果没有 Caffee2 的相关知识，这可能很难调试。因此，我们尝试直接从 GitHub 加载两个资源(dnn_model_pt.value_inputs.json和dnn_model_pt.onnx)，但也失败了。尽管 Squeezenet 的例子起了作用，但是在 GraphPipe 中，试图在我们自己的 ONNX 模型中复制这个例子是一个很大的麻烦。然而，随着 graphpipe-tf 成为 TensorFlow 模型服务器，似乎有了一条出路。多亏了 ONNX，我们可以轻松地从 ONNX-model 中生成 TensorFlow 模型导出，并尝试通过 GraphPipe 服务于该模型。因此，我们只需安装 ONNX TensorFlow 连接器。因此，让我们再试一次:

将 ONNX 模型转换成 TensorFlow protobuf 后，我们用以下代码启动 Docker 容器:

docker run -it — rm \
 -v “$PWD/models:/models/” \
 -p 9000:9000 \
 sleepsonthefloor/graphpipe-tf:cpu \
 — model=/models/dnn_model_tf.pb \
 — listen=0.0.0.0:9000

为我们的终端带来以下内容:

INFO[0000] Starting graphpipe-tf version 1.0.0.10.f235920 (built from sha f235920)
INFO[0000] Model hash is ‘e3ee2541642a8ef855d49ba387cee37d5678901f95e8aa0d3ed9a355cf464fb2’ 
INFO[0000] Using default inputs [flattened_rescaled_img_28x28:0] 
INFO[0000] Using default outputs [Softmax:0] 
INFO[0000] Listening on ‘0.0.0.0:9000

现在看起来好多了。尽管最初有些困难，但我们只用了几行代码就快速部署了我们的模型。这就是为什么我们现在想知道我们部署的行为是否与我们训练的行为相似。

因此，我们最终使用一些针对容器化模型服务器的 REST 接口的测试数据查询来验证部署。为此，我们使用已经安装的 GraphPipe 客户端实现:

Predicted Label / True Label: 2 == z ? — False !
Predicted Label / True Label: r == r ? — True !
Predicted Label / True Label: 3 == 3 ? — True !
Predicted Label / True Label: h == h ? — True !
Predicted Label / True Label: 2 == 2 ? — True !
Predicted Label / True Label: j == j ? — True !
Predicted Label / True Label: 5 == 5 ? — True !
Predicted Label / True Label: 2 == 2 ? — True !
Predicted Label / True Label: 7 == 7 ? — True !
Predicted Label / True Label: 8 == 8 ? — True !

这是后端发生的情况:

…
INFO[0113] Request for / took 773.621µs 
INFO[0113] Request for / took 859.584µs 
INFO[0113] Request for / took 810.67µs 
…

太好了，我们的模型充满活力，能够快速响应请求，并显示出与训练时相似的准确性。请随意尝试更多的例子来证明一些不那么可疑的统计意义；-)

我们现在在哪里，下次去哪？

有很多东西要读，但希望也有很多东西要学。这是我从这项工作中得到的，我希望你能分享经验或提供更多反馈:

• PyTorch 在易用性方面表现出色，并且本身支持 ONNX 互操作性，尽管它缺乏集成的部署解决方案。
• TensorFlow 在成熟度和效率方面表现出色，我们希望它也能在互操作性方面表现出色，使 ONNX 支持成为必然。
• ONNX 是一个令人信服的促进模型互操作性的中介。我希望看到它在未来集成更多的连接器，比如 onnx-tf 。
• GraphPipe 既有用又简洁，但也有一些初期问题。TensorFlow 的集成在盒子的右边工作，而 ONNX 模型不是这种情况。

如果你准备继续，在这里找到第二部。感谢阅读、鼓掌、分享，不要忘记注意差距。

感谢我的同事 弗洛里安·威廉 、简·本德和迈克尔·廷普兰提供的宝贵反馈。

从探索到生产——弥合深度学习的部署差距(第二部分)

原文：https://towardsdatascience.com/from-exploration-to-production-bridging-the-deployment-gap-for-deep-learning-part-2-9e33cc8dfe5e?source=collection_archive---------7-----------------------

这是关于深度学习模型探索、翻译和部署的两个博客系列的第二部分。两者都涉及到很多技术，比如 PyTorch、TensorFlow、TensorFlow Serving、Docker、ONNX、NNEF、GraphPipe、Flask 。我们将协调这些技术，使用更具挑战性但不太受欢迎的 EMNIST 数据集来解决图像分类的任务。在第一部分中，我们介绍了 EMNIST，使用 PyTorch 开发和训练模型，使用开放神经网络交换格式(ONNX)翻译它们，并通过 GraphPipe 服务它们。

本部分通过添加两种额外的模型部署方法来结束本系列。TensorFlow Serving 和 Docker 以及一种相当业余的方法，在这种方法中，我们构建了一个服务于我们模型的简单 web 应用程序。这两个部署都将提供 REST API 来调用预测。你会在 GitHub 上找到所有相关的源代码。如果您喜欢从头开始，请在这里找到关于数据科学的第部分。

我们将使用我们在第一部分中生成的来自 PyTorch 和 TensorFlow 的经过训练的模型文件。你可以在 GitHub 上的models文件夹中找到它们。

模型部署:TensorFlow 服务和 Docker

这确实是我们第二次在这个系列中使用 TensorFlow 服务。我们第一次使用它是作为 GraphPipe 的一部分，它提供了参考模型服务器和调整模型服务器配置。我们现在不使用元框架，而是直接转向 TensorFlow。参考这个 JuPyter 笔记本按照步骤去体验深度学习模型部署的另一种方式。

第一步，我们必须加载我们的 ONNX 模型，并使用 ONNX TensorFlow 连接器创建它的 TensorFlow 表示:

接下来，我们定义加载模型的路径，并创建一个SavedModelBuilder。这个实例是生成路径和创建模型的 protobuf 导出所必需的。在 TensorFlow 服务术语中，该特定保存路径也称为源。

为了给我们的模型构建一个合适的签名(某种类型的接口)，让我们回顾一下模型由什么组成:

External Input: ['flattened_rescaled_img_28x28']
External Output: ['softmax_probabilities']{'weight_1': <tf.Tensor 'Const:0' shape=(512, 784) dtype=float32>,
 'bias_1': <tf.Tensor 'Const_1:0' shape=(512,) dtype=float32>,
 'weight_2': <tf.Tensor 'Const_2:0' shape=(256, 512) dtype=float32>,
 'bias_2': <tf.Tensor 'Const_3:0' shape=(256,) dtype=float32>,
 'weight_3': <tf.Tensor 'Const_4:0' shape=(62, 256) dtype=float32>,
 'bias_3': <tf.Tensor 'Const_5:0' shape=(62,) dtype=float32>,
 'flattened_rescaled_img_28x28': <tf.Tensor 'flattened_rescaled_img_28x28:0' shape=(1, 784) dtype=float32>,
 '7': <tf.Tensor 'add:0' shape=(1, 512) dtype=float32>,
 '8': <tf.Tensor 'add_1:0' shape=(1, 512) dtype=float32>,
 '9': <tf.Tensor 'add_2:0' shape=(1, 256) dtype=float32>,
 '10': <tf.Tensor 'add_3:0' shape=(1, 256) dtype=float32>,
 '11': <tf.Tensor 'add_4:0' shape=(1, 62) dtype=float32>,
 'softmax_probabilities': <tf.Tensor 'Softmax:0' shape=(1, 62) dtype=float32>}

我们可以识别三个完全连接的层以及我们的输入和输出张量。后者是入口和出口，特别重要的是构建所谓的签名定义。这些签名定义了服务环境和我们的模型本身之间的接口。这是模型部署的第一步，接下来是在 Docker 中启动服务器并进行适当的部署测试。

签名定义构建

在本节中，我们将创建适当的签名(分类和预测)并将它们添加到模型图中。之后，我们使用我们的SavedModelBuilder实例进行实际的导出

为了创建合适的签名，我们必须从输入和输出张量中推断出TensorInfo对象。TensorInfo对象是类 JSON 对象，包含Tensor的名称、数据类型和形状。我们简单地获取输入和输出张量的引用，并使用build_tensor_info为它们创建TensorInfo对象:

应用于output_tensor，我们得到output_tensor_info并看到张量持有与我们的 62 个不同 EMNIST 标签相关的*度 1 x 62 的 softmax 激活:

name: "Softmax:0"
dtype: DT_FLOAT
tensor_shape {
  dim {
    size: 1
  }
  dim {
    size: 62
  }
}

现在，我们已经准备好构建分类和预测签名，如下所示。它们只是将TensorInfo对象与适当的名称和方法名的声明结合起来:

定义后的prediction_signature看起来像这样:

inputs {
  key: "images"
  value {
    name: "flattened_rescaled_img_28x28:0"
    dtype: DT_FLOAT
    tensor_shape {
      dim {
        size: 1
      }
      dim {
        size: 784
      }
    }
  }
}
outputs {
  key: "scores"
  value {
    name: "Softmax:0"
    dtype: DT_FLOAT
    tensor_shape {
      dim {
        size: 1
      }
      dim {
        size: 62
      }
    }
  }
}
method_name: "tensorflow/serving/predict"

最后，我们将两个签名添加到模型中，并执行导出:

我们现在可以找到类似于包括元数据(签名)的序列化模型图定义的saved_model.pb。此外，我们的构建器添加了包含序列化图形变量的文件夹variables。不幸的是，签名构建过程增加了额外的复杂性。说实话，我还没得到它的效用。毕竟，人们也可以使用张量名称本身，而不需要任何额外的包装。但是，如果您想尝试一下，可以在相关 TensorFlow 文档中找到更多信息。

通过 Docker 容器中的 TensorFlow 服务模型

嘿，看起来我们刚刚创建了一个可服务的，它是 TensorFlow 为客户用来执行计算的对象提供语音服务。是时候真正为可服务对象服务了。但是，TensorFlow 中的服务一般是如何工作的？简而言之，TensorFlow Serving 由下图中描述的五个组件组成: Servables 、 Loaders 、 Sources 、 Manager 和 Core 。它们一起工作如下:我们运行一个模型服务器，告诉管理器它应该监听的源，以便它可以探索新的服务对象。在我们的例子中，我们使用一个文件系统。当我们将一个模型保存到那个文件系统时，源通知管理器关于一个新检测到的可服务的，这使得它成为期望的版本。源提供了一个加载器，它告诉管理器加载模型所需的资源。管理器同时处理请求，决定是否以及何时加载模型。根据版本策略，它可以卸载旧版本或保留旧版本。成功加载模型后，管理器可以开始服务客户端请求，将句柄返回到非常新的可服务或其他版本，如果客户端明确请求的话。客户端可以使用 gRPC 或 REST 发送推理查询。

https://www.tensorflow.org/serving/overview

到目前为止，一切顺利——让我们再练习一次:安装 Docker 后，我们用docker pull tensorflow/serving提取 TF 服务容器映像，并简单地用下面的命令启动模型服务器:

docker run -p 8501:8501 --name emnist_model \
--mount type=bind,source=$(pwd)/../models/tf_emnist,target=/models/tf_emnist \
-e MODEL_NAME=tf_emnist -t tensorflow/serving &

这将启动 dockerized 模型服务器，并将其端口 8501 发布到我们主机上的同一个服务器。这个端口为我们的模型提供了一个 REST API。此外，我们将目录( source )挂载到容器( target )中，在那里我们喜欢保存我们的 servables。因此，每次我们导出较新的模型版本时，TF serving 都会在容器中识别它们并触发加载过程。我们现在可以直接看到服务进程以及由核心、管理器和加载器完成的任务。

2018-10-13 13:38:15.518130: I tensorflow_serving/model_servers/server.cc:82] Building single TensorFlow model file config:  model_name: tf_emnist model_base_path: /models/tf_emnist
2018-10-13 13:38:15.518416: I tensorflow_serving/model_servers/server_core.cc:462] Adding/updating models.
2018-10-13 13:38:15.518455: I tensorflow_serving/model_servers/server_core.cc:517]  (Re-)adding model: tf_emnist
2018-10-13 13:38:15.638251: I tensorflow_serving/core/basic_manager.cc:739] Successfully reserved resources to load servable {name: tf_emnist version: 1}
2018-10-13 13:38:15.638370: I tensorflow_serving/core/loader_harness.cc:66] Approving load for servable version {name: tf_emnist version: 1}
2018-10-13 13:38:15.638411: I tensorflow_serving/core/loader_harness.cc:74] Loading servable version {name: tf_emnist version: 1}
2018-10-13 13:38:15.639975: I external/org_tensorflow/tensorflow/contrib/session_bundle/bundle_shim.cc:360] Attempting to load native SavedModelBundle in bundle-shim from: /models/tf_emnist/1
2018-10-13 13:38:15.641451: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:31] Reading SavedModel from: /models/tf_emnist/1
2018-10-13 13:38:15.659090: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:54] Reading meta graph with tags { serve }
2018-10-13 13:38:15.660035: I external/org_tensorflow/tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
2018-10-13 13:38:15.672728: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:162] Restoring SavedModel bundle.
2018-10-13 13:38:15.673671: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:172] The specified SavedModel has no variables; no checkpoints were restored. File does not exist: /models/tf_emnist/1/variables/variables.index
2018-10-13 13:38:15.673710: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:138] Running MainOp with key saved_model_main_op on SavedModel bundle.
2018-10-13 13:38:15.677101: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:259] SavedModel load for tags { serve }; Status: success. Took 35653 microseconds.
2018-10-13 13:38:15.678135: I tensorflow_serving/servables/tensorflow/saved_model_warmup.cc:83] No warmup data file found at /models/tf_emnist/1/assets.extra/tf_serving_warmup_requests
2018-10-13 13:38:15.684767: I tensorflow_serving/core/loader_harness.cc:86] Successfully loaded servable version {name: tf_emnist version: 1}
2018-10-13 13:38:15.686409: I tensorflow_serving/model_servers/server.cc:285] Running gRPC ModelServer at 0.0.0.0:8500 ...
[warn] getaddrinfo: address family for nodename not supported
2018-10-13 13:38:15.686843: I tensorflow_serving/model_servers/server.cc:301] Exporting HTTP/REST API at:localhost:8501 ...
[evhttp_server.cc : 235] RAW: Entering the event loop ...

测试模型服务器

再次测试的时候到了！让我们对我们的模型服务器使用一些测试图像，并评估它们的分类准确性。此时，使用我们的预测签名中定义的输入和输出定义将是直观的。然而，这并不是那么简单，我们创建了一个用instances注释的数据有效负载作为我们的 POST 请求的输入，并接收一个响应对象，我们需要用predictions处理它的内容:

在我们的 1000 个测试例子中，我们最终得到的准确率为 78.3% ，这与我们的训练结果一致。最后让我们看看下面的一些例子。我们可以发现该模型很难区分大写的 O 和 0 ，这一点都不容易。

模型部署:Flask Webservice

在本节中，我们将转向我们的最终部署方法。因此，我们在一个简单的 web 服务中嵌入了模型推理，并构建了一个允许用户上传图像进行分类的极简前端。为此，我们使用了 Flask ，这是一个简洁的 Python web 开发框架，基于 Werkzeug 和 Jinja2。我们将在包本身中实现模块emnist_dl2prod.emnist_webserver，但是你可以参考这个 JuPyter 笔记本获得更多信息。

本节包括三个部分:

1. 构建模型包装类
2. 实现 web 服务和前端
3. 运行并测试我们自己的 EMNIST 网络服务器

1.构建模型包装类

我们从下面的模型包装类开始。为了创建一个新的实例，我们必须提供之前使用SavedModelBuilder保存的模型的路径。这里，我们使用tf.saved_model的加载器功能来加载和恢复我们的模型。我们还创建了一个会话，在这个会话中，我们恢复了构成我们的SavedModel的图形定义和变量。此外，模型类还实现了一个run方法，以便稍后轻松执行单个实例或批量推理。此方法只是对展平和规范化的图像数据(浮点值在 0 和 1 之间)运行会话，并返回所有 62 个类的 softmax 激活。

2.实现 web 服务和前端

接下来，我们转向 Flask 和一些 HTML，因为我们将简单的 REST webservice 与极简前端相结合，以上传图像并可视化分类结果。首先，我们创建两个 HTML 文件，img_upload.html和result.html。第一个页面实现了一个图像上传界面和一个按钮来提交图像数据，这在内部触发了预处理和分类过程。后一个文件类似于显示上传图像本身的模板，当然也显示分类结果。结果是检测到的(最有可能的)类以及我们的模型得出的 softmax 分数。让我们仔细看看这中间发生了什么。上传图片时，上传页面触发以下重定向:url_for('process_img_upload')。此重定向通过后请求提供了以下方法:

emnist_result是一个字典，我们用它来最终用适当的值呈现我们的结果页面。这也需要临时保存上传的图像并检查文件类型是否正确。在后一部分，我们使用skimage读取图像，直接产生一个 NumPy 数组——数据科学家的宠儿。然后，我们对图像数组进行预处理(归一化+展平)和分类，简单地调用我们的模型包装器实例的run作为classify_img的一部分。这将返回 softmax 激活值，并将最高激活的索引映射到适当的标签。最后，我们通过向字典添加 softmax 值和标签来完成我们的请求结果，并调用show_emnist_result来呈现结果页面。

除了我们的前端展示，我们还实现了一个方法，用一个适当的响应对象来回答 POST 请求，而不是呈现任何 HTML 模板:

3.测试和性能评估

又到了收获我们劳动果实的时候了。我们启动我们的网络服务器，让我们处理一些例子。您可以使用python emnist_webserver.py或使用随软件包安装的命令emnist-webservice来启动它。无论哪种方式，您都应该在终端中显示类似于以下内容的内容:

[2018-10-14 11:07:26] INFO:__main__:Set up temporary media folder for webserver: /Users/mkurovski/Python/emnist_dl2prod/src/emnist_dl2prod/tmp_flask_media
 * Serving Flask app "emnist_webserver" (lazy loading)
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: off
[2018-10-14 11:07:26] INFO:werkzeug: * Running on [http://0.0.0.0:5000/](http://0.0.0.0:5000/) (Press CTRL+C to quit)

太好了！让我们去参观一下:

为了方便测试，您可以在库中找到包含 10 个字符的文件夹test_images。试几个吧！我们选择一个图像并点击Get Result,然后“瞧”,我们在 softmax 激活中看到 e 和 99.74% 的概率。在后端，我们收到了进一步的确认，表明一切都按预期进行:

[14/Oct/2018 11:11:26] "POST /emnist/result HTTP/1.1" 200 -
[14/Oct/2018 11:11:26] "GET /emnist/img_upload/img_upload_1539508286216.png HTTP/1.1" 200 -

在相关的 JuPyter 笔记本中，您将看到我们后面的实现的一些示例，我们也想在这里尝试一下。出于评估和测试的目的，您可以将eval_serving_performance作为emnist_dl2prod.utils的一部分。该方法从测试或训练数据中创建一定量的请求，将它们发送到指定的端点，并评估响应的准确性及其时间。我们将在下一部分更详细地讨论它。这里，让我们在刚刚创建的终端上尝试一下:

这将一些结果可视化，并告诉我们请求的平均准确性:

Accuracy on 1000 test images: 77.60%

77.6% —耶！这看起来与我们的训练经验非常一致。
太好了！我们实现了自己的 web 服务，成功地证实了我们在生产中的培训结果。到了决赛的时候了——所有这些方法在定性和定量意义上如何相互比较？

结论:比较不同部署的吞吐量和预测准确性

这是我关于深度学习模型探索、翻译和制作的综合博客系列的最后一部分。借助 Docker、TensorFlow、GraphPipe、PyTorch、ONNX 和 Flask 等众多技术，我们构建了从勘探到生产的桥梁。所有的方法都是从 PyTorch 探索和 ONNX 翻译开始的。它们的不同之处在于我们部署每个解决方案的方式。我们从 GraphPipe 和 Docker 开始提供一个处理 REST 调用的简短包装器。我们继续使用 TensorFlow 在 Docker 容器中提供服务。这有点冗长和复杂。最后，我们使用 Flask 构建了自己的 web 服务器，并嵌入了模型推理调用。我们还将最后一种方法与极简前端相结合。这是最冗长的，但也是最容易理解的部署方式。然而，我不建议将它用于大规模生产系统，它有助于捕捉模型推理、客户端-服务器通信和前端如何相互连接。现在，让我们看看这些方法在定性和定量方面是如何相互比较的。

首先，让我们从易用性和实现努力的角度来看一下定性。在我看来，Flask 是最简单的方法 GraphPipe 紧随其后。服务 ONNX 模型的 GraphPipe 中的一些意外故障导致了问题。然而，转移到 TensorFlow 很容易地解决了我们当时的问题。使用 TensorFlow 服务，事情会变得有点复杂，因此它在这方面占据第三位。就我们的实现程度而言，GraphPipe 是明显的赢家，只需要很少的代码来部署我们的模型。TensorFlow 服务需要多一点，但仍然做得很好。签名的定义在这里增加了一些冗长。Flask 紧随其后，因为它比 GraphPipe 花费更多的精力，这对于构建自己的解决方案来说似乎是不言而喻的。

但是，作为数据科学家和工程师，我们更感兴趣的是仅仅作为直觉的数字。因此，我还对这些部署在给定请求吞吐量的情况下如何进行比较以及它们是否返回一致的结果感兴趣。参见这款 JuPyter 笔记本进行对比。我在一个只有一个 CPU 的谷歌云计算实例上测试了所有解决方案。然而，为了避免糟糕的网络连接导致的测量偏差，我在这里展示了本地托管每个服务的结果。我们涵盖了各种场景:发送单个实例请求和批处理请求，每个都有 128 个示例。对于这两个场景，我们使用单个客户端线程，没有异步请求，以保持与 Oracle 评估 GraphPipe 的方式一致。然后，我们计算在一致的持续时间内成功请求的数量，并获得每秒的吞吐量作为性能指标。参见emnist_dl2prod.utils:eval_throughput了解我们吞吐量测试的实施。需要注意的是，不同设置下的绝对数字可能会有所不同。然而，这不应该是我们关心的问题，因为我们更感兴趣的是这些方法如何相互比较而不是它们各自的绝对性能。因此，让我们来看看单实例请求吞吐量。我们清楚地看到 TensorFlow 的服务性能优于 GraphPipe 和 Flask，每秒处理超过 200 个单实例请求，其中 GraphPipe 和 Flask 分别超过大约 150 个和 125 个。

如果我们研究使用的批处理推理案例，并且顺序已经改变，差异会变得更大。GraphPipe 显然脱颖而出，在相同时间内，它提供的图片数量大约是 TensorFlow 的三倍。TensorFlow 服务在处理请求方面排名第二，比 Flask 服务高出约 70-80%。

这与甲骨文的说法相当一致。然而，在我们的例子中，震级并没有变得那么极端。

https://oracle.github.io/graphpipe/#/guide/user-guide/performance

总之，在批量推断方面，GraphPipe 比 Flask 和 TensorFlow 要快得多。然而，TensorFlow 服务明显优于单个实例推理，这一点值得注意。如果我们不批量处理传入的请求并为其提供 GraphPipe，我们最好继续使用 TensorFlow 服务。但是，如果我们的问题允许，或者如果我们可以批量处理传入的请求，我们最好使用 GraphPipe。

观点

哇，这是很多，我希望你仍然喜欢它。请你自己尝试一下，分享一下你的经验，让我们试着介意一下探索和制作之间的差距。有大量的技术支持我们，甚至更多的技术将会出现。特别是，我预计 ONNX 将成为深度学习框架不可或缺的一部分，GraphPipe 将超越其目前的地位。有了这些和其他的贡献，我们可以让事情变得更容易生产，让人工智能通过改变人们的生活来为人们服务。

从虚构到现实:人工神经网络初学者指南

原文：https://towardsdatascience.com/from-fiction-to-reality-a-beginners-guide-to-artificial-neural-networks-d0411777571b?source=collection_archive---------3-----------------------

(这篇文章和许多类似的文章来自我在 jasonroell.com 的个人博客。看看吧！)

对人工智能的兴趣正在达到新的高度。2016 年是人工智能初创公司和资金创下纪录的一年，2017 年肯定会超过它，如果它还没有超过的话。根据 IDC 的数据，到 2020 年，认知系统和人工智能方面的支出将增长超过 750%。从最*的初创公司到最大的公司，从智能手机应用程序到公共健康安全系统，对人工智能的兴趣和投资涵盖了商业和技术领域的所有领域。技术领域的大牌都在人工智能上投入巨资，同时将其融入商业模式，并越来越多地用于他们的产品中:虚拟助理(如 Siri)、计算机视觉、语音识别、语言翻译和许多其他应用。但是 AI 背后实际的 IT 是什么？简而言之:人工神经网络(ANN)。在这里，我们来看看它们是什么，它们是如何工作的，以及它们如何与激发它们的生物神经网络相关联。

定义人工神经网络

术语人工神经网络用于指代数学模型或模拟大脑神经网络中基本计算特征的实际程序。

神经元

来源:http://www . robots . ox . AC . uk

虽然生物神经元是极其复杂的细胞，但它们在输入和输出方面的基本计算性质相对简单。每个神经元有多个树突和一个轴突。神经元从其树突接收输入，并通过其轴突传递输出。输入和输出都采用电脉冲的形式。神经元将其输入相加，如果总电脉冲强度超过神经元的触发阈值，则神经元沿着其单个轴突触发新的脉冲。轴突进而沿着其分支突触分发信号，这些分支突触共同到达数千个相邻的神经元。

来源:数据营

神经元和晶体管之间有一些基本的相似之处。它们都是各自领域信息处理的基本单位；它们都有输入和输出；他们都和邻居有联系。然而，神经元和晶体管之间也有很大的不同。晶体管是简单的逻辑门，通常连接到不超过三个其他晶体管。相比之下，神经元是高度复杂的有机结构，与大约 10，000 个其他神经元相连。自然地，当涉及到执行需要数千个并行连接的认知壮举时，这种丰富的连接网络使神经元比晶体管具有巨大的优势。几十年来，工程师和开发人员一直在设想如何利用这一优势，让计算机和应用程序更像大脑一样运行。最后，他们的想法已经成为主流。虽然晶体管本身不会很快看起来像神经元，但它们运行的一些人工智能软件现在可以模仿基本的神经处理，而且只会越来越复杂。

神经元建模

感知器

来源:http://cs231n.github.io/neural-networks-1/

感知器，或单层神经网络，是最简单的神经计算模型，也是构建的理想起点。你可以把感知器想象成一个神经元。然而，感知器没有树突，而是简单地有输入: x1，x2，x3，…，xN。此外，感知器没有轴突，而是只有一个输出: y = f(x) 。

重量

感知器的每个输入(x1，x2，x3，…，xN)都有一个权重(w1，w2，w3，…，wN)。如果某个权重*于 1，就会削弱其输入。如果大于 1，就会放大。在稍微复杂一点但被广泛采用的感知器模型中，还有一个输入 1 ，具有固定权重 b ，称为偏差，用作训练感知器的目标值。

激活功能

也被称为传递函数，激活函数决定了感知器输出的值。激活函数的最简单形式是某种类型的阶跃函数。它模仿生物神经元在达到其触发阈值时触发，如果总输入超过给定的阈值量，则输出 1，否则输出 0。然而，为了得到更真实的结果，需要使用一个非线性的激活函数。其中最常用的是 sigmoid 函数:

f(x)= 1 / (1+e^-x)

这个基本公式有许多常用的变体。然而，所有的 sigmoid 函数在绘制时都会采用某种形式的 S 曲线。当输入为零时，输出也为零。然而，当输入值变为正值时，输出最初(大致)呈指数增长，但最终在水平渐近线表示的固定值处达到最大值。这个最大输出值反映了生物神经元可以产生的最大电脉冲强度。

添加隐藏层

在更复杂、更现实的神经模型中，至少有三层单元:输入层、输出层和一个或多个隐藏层。输入层从系统试图解释、理解、感知、学习、记忆、识别、翻译等的外部世界接收原始数据。相比之下，输出层传输网络最终处理后的响应。然而，位于输入和输出层之间的隐藏层是驱动最先进的人工神经网络的机器学习的关键。

大多数建模假设各层完全连接。在完全连接的神经网络中，一层中的所有单元都连接到其相邻层中的所有单元。

反向传播

你可以认为反向传播是神经网络中允许网络学习的过程。在反向传播过程中，网络处于不断训练、学习、调整和微调的过程中，直到它更接近预期的输出。反向传播通过使用损失函数比较预期输出和实际输出进行优化。结果是一个误差值，或成本，反向传播使用它来重新校准神经元之间的网络权重(以找到最相关的特征和输入，从而产生期望的输出)，通常是在众所周知的梯度下降优化算法的帮助下。如果存在隐藏层，那么该算法也重新校准所有隐藏连接的权重。每一轮重新校准后，系统再次运行。随着误差率变*，每一轮重新校准都变得更加精确。在反向传播网络的输出与预期输出紧密匹配之前，这个过程可能需要重复数千次。在这一点上，可以说网络是完全训练有素的。

考虑清楚

随着人工智能投资和开发达到新的高度，这对人工智能爱好者和有抱负的开发人员来说是一个激动人心的时刻。然而，重要的是首先要好好看看人工智能背后的 it:人工神经网络(ANN)。这些计算模型模拟了生物神经网络中的基本计算特征。神经元变成感知器或简单的单元；树突成为输入；轴突成为输出；电脉冲强度成为连接权重；神经元的触发强度函数成为单元的激活函数；一层层的神经元变成了一层层完全连接的单元。将所有这些放在一起，您可以按原样运行您完全训练好的前馈网络，或者您可以训练和优化您的反向传播网络以达到所需的值。很快，你就可以拥有你的第一个图像识别器，自然语言处理器，或者任何你想出来的新的人工智能应用程序。

感谢您的阅读，如果您喜欢这篇文章，请分享这篇文章，或者订阅我在 JasonRoell.com 的博客，或者在 LinkedIn 上关注我，我在那里发布了我认为普通程序员甚至技术爱好者都感兴趣的技术话题。

祝你有美好的一天，继续学习！

从前四到甜蜜的 16 岁:我如何预测锡拉丘兹将颠覆密歇根州立大学

原文：https://towardsdatascience.com/from-first-four-to-sweet-16-how-i-predicted-syracuse-would-upset-michigan-state-32fc95c96fa4?source=collection_archive---------14-----------------------

正如其他人注意到的那样，NCAA 锦标赛的前两轮相当疯狂。用我自己对冷门的定义(一场被排名比对手低至少 4 位的弱队获胜)，仅在周日就有 4 场冷门。到目前为止，总共有 10 场冷门，已经超过了每场比赛 9 场的平均水平。还有 15 场比赛要打！

周日的所有冷门都令人震惊，但也许最令人震惊的是锡拉丘兹大学对密歇根州立大学的胜利。在周日最受欢迎的北卡罗来纳、泽*尔、辛辛那提和密歇根州之间，斯巴达有最大的分差8 分，这意味着密歇根州有 80%的胜算。与大多数年份一样，汤姆·伊佐的队伍是一个深入发展的威胁，他们确实被许多专家选为进入最后 4 强的。

但是你不会在我的范围内找到第二轮之后的密歇根州立大学，因为我的不安预测模型预见到了这一点。我的模型使用机器学习来检测冷门让锡拉丘兹有 81%的机会击败密歇根州立大学，进入甜蜜的 16 强。

老实说，我很震惊地看到这场比赛的爆冷概率如此之高。对密歇根州立大学的热爱不仅限于公众和专家；甚至先进的评级系统也将密歇根州立大学列为全国最好的球队之一。

今天，我仔细观察这两个团队，以理解为什么我的模型正确地预测了这场混乱。

冷门评论:雪城超过密歇根州立大学

是什么因素让这款游戏进入冷门警戒？我将着眼于这场比赛的三个突出特点。

锡拉丘兹大学的赛程对 11 号种子选手来说异常艰难

锡拉丘兹大学参加了 ACC，这是一个汇集了通常被认为是全国最好的发电站项目的会议。今年橘子有一个残酷的会议名单，包括北卡罗莱纳州两次，弗吉*亚两次，杜克大学和克莱姆森，扔在一个非会议游戏对堪萨斯的好措施。关于锡拉丘兹的整体记录的问题让他们在锦标赛上泡沫，但在他们的 13 场比赛中，9 场输给了 NCAA 锦标赛球队。Sports-reference.com 将他们的赛程排在全国第 19 位，相比之下密西根州排在第 56 位。

11 种子球队通常都这么难打赛程吗？答案是响亮的不。

Syracuse played a much tougher schedule than typical 11-seeds

在左侧，我显示了 2003 年至 2017 年所有 11 号种子的赛程评级强度，以及他们的锦标赛对手的赛程强度。在所有 11 个种子队中，只有 7 支球队今年的赛程比锡拉丘兹更艰难。

橙衣军团今年面临特别好的进攻，因为他们的对手平均进攻效率在全国排名第十。虽然 4 场对抗 10 大进攻(杜克，北卡 2x，堪萨斯)的比赛确实产生了 4 场失利，但防守精英进攻的经验可能有助于橙衣军团遏制斯巴达的强大进攻。密歇根州立大学在这个赛季平均每场比赛得 80 分。对锡拉丘兹，他们得了 53 分。

对于一个 3 号种子来说，密歇根州立大学在保护球方面表现平平，在历史上也不擅长制造失误。

1-3 号种子队通常是平衡的队伍，在球场两端都很强。密歇根州立大学队也不例外，他们的进攻效率排名第 13，防守排名第 11。但是在所有的三号种子队中，密歇根州立大学在比赛的一个方面一直很糟糕:制造失误。

营业额百分比衡量的是在营业额中所占的百分比，并根据球队的进攻和防守分别计算。下面我展示了自 2003 年以来所有三号种子队的防守失误率和进攻失误率。

Michigan State had the lowest defensive turnover rate among all 3-seeds since 2003

在整个赛季中，斯巴达人的防守只迫使对手 14%的失误。这是自 2003 年以来三号种子选手的最低水平。而且，密歇根州立大学没有平衡这种低防守失误率和进攻中特殊的控球保护，因为他们 19%的财产都以失误告终。这是三粒种子的中间位置。

赢得篮球比赛是不是一定要赢得翻身仗？不总是这样，特别是对于像密歇根州立大学这样的精英得分球队。但是更好的控球保护通常会有所帮助，随着锡拉丘兹大学周日以 14 比 12 赢得了翻盘战，并且仅以 2 分之差获胜，我相信密歇根州立大学会很乐意有几个这样的球员回来。

这场 3 对 11 的比赛有着极其罕见的精英教练对决

毫无疑问，密歇根州立大学的汤姆·伊佐和锡拉丘兹大学的吉姆·伯海姆都是教练精英，在比赛中名列前茅。在他们两人之间，他们拥有 2 次全国冠军，12 次四强出场，16 次常规赛冠军。他们都已经在名人堂了。这是一些严重的硬件。

在最初几轮比赛中，顶级锦标赛球队的教练通常会面对简历不如自己丰富的教练，但在这里肯定不是这样。3 号种子教练在第二轮面对这样的精英教练比赛的几率有多大？几乎没有。

This 3 vs 11 game was an extremely rare match-up of elite coaches

对于自 1985 年以来的所有 3 对 11 比赛，我显示了两位教练的比赛经验，用数字表示他们曾经走过的最远回合(添加了一些水平“噪声”以查看数据点)。通常情况下，3 号种子教练面对 11 号种子教练，他们没有深入的比赛。事实上，54%的情况下，3 号种子教练面对的是一个从未赢过锦标赛的 11 号种子教练。

在这种情况下，两位教练之前都参加过(并赢得了)全国决赛。自 1985 年锦标赛扩大到 64 支球队以来，这种情况只发生过一次，而且即使是这一次也有资格赛。2013 年，11 号种子明*苏达队的教练是 Tubby Smith，他早在 1998 年就在肯塔基州赢得了戒指。

这里的重点不一定是博海姆是一个比伊佐更好的教练。只是当 3 号种子在第二轮面对 11 号种子时，3 号种子教练通常不必与名人堂成员决斗。在这一次，策略无疑发挥了作用。当落后 3 分时，博海姆明智地拒绝了密歇根州立大学任何扳平 3 分的机会，而是选择故意犯规并放弃 2 次罚球。密歇根州立大学赢得或平的唯一机会是在最后一秒绝望的半场投球。它失败了，彻底颠覆了。

结束语

这一分析强调了这两个团队之间一些真正有趣的趋势，但我不能肯定地说，这些是预测这场比赛的主要因素。我的模型使用每个团队的许多特征来预测沮丧的可能性，而这些只是导致沮丧的等式的一部分。

我希望你喜欢我沮丧的预测。谁会是下一个成为冷门牺牲品的队伍？点击 @ 在 Medium 或 Twitter 上关注我，了解更多信息！

从游戏到金融科技:我的 DS 之旅

原文：https://towardsdatascience.com/from-games-to-fintech-my-ds-journey-b7169f08b6ad?source=collection_archive---------5-----------------------

Source: Tech in Asia, https://www.techinasia.com

作为一名分析师和数据科学家(DS)在游戏行业工作了五年后，我决定过渡到创业生活，加入一家金融技术部门的公司。虽然这是一个新的领域，有新类型的问题需要解决，但我在游戏行业发展的许多技能仍然与我的新角色相关。这篇文章的目标是展示如何在一个领域学习数据科学技能可以转移到新的意想不到的机会。

我的新角色的一个关键区别是从企业对消费者(B2C)到企业对企业(B2B)的转变。我现在不是对数百万消费者进行分析，而是构建数据产品，帮助数百家非营利组织和营利性公司。对产品分析的关注也越来越少，而是更多地关注为我们的最终用户提供准确的数据。我现在不是探索来自视频游戏和视频流媒体服务的跟踪数据，而是研究来自各种不同数据源的数据，包括房地产销售和政治捐款。

我在新职位的主要目标是建立预测模型，为美国富裕家庭提供准确的资产净值估算。数据源是不同的，我们的客户是企业而不是消费者，但是数据科学的许多关键功能可以很好地跨越这些领域。以下是我在这个新角色中运用到的一些技能。

探索性数据分析(EDA) 能够挖掘数据集对于任何领域都很重要。数据科学家应该能够可视化数据的分布，识别异常值，并找到数据中的相关性。

探索性分析的目标通常是确定数据中是否有预测结果的信号。例如，在游戏行业中，一个常见的目标是识别用户是否会流失或在游戏中失败。这可以表示为一个分类问题，但通常提供汇总统计数据，如漏斗分析，就足以为游戏团队提供反馈。在我的金融科技角色中，一个共同的目标是识别与净值相关的特征，并确定我们是否可以设计出额外的特征来提高我们对净值估计的准确性。

以下是我在这些领域中调查的问题类型:

• 游戏:新的订阅模式会蚕食销售额吗？
• FinTech: 政治献金和净资产有关联吗？

我使用了类似的方法来探索这些类型的问题，包括用于数据管理的 SQL 和用于可视化和相关性分析的 R。

实验 Twitch 的核心原则之一是实验决定，数据科学团队使用 A/B 测试和分阶段推出的组合来实现这一目标。实验的一个重要元素是能够衡量变化的结果，并确定变化是否对用户行为产生了重大影响。在我目前的角色中，我们经常需要确定营销活动是否对我们的客户产生了可衡量的影响，类似的方法可以用于这类任务。在这两种情况下，我都使用 bootstrapping 来测量实验中治疗组和抵制组之间的差异，并测试统计显著性。

以下是这些不同领域的实验例子:

• 游戏:一款应用的重新设计是否提高了移动用户的留存率？
• 金融科技:营销活动推动了收入增长吗？

类似的方法可以用来衡量这些实验的影响，即使这些领域是非常不同的。

预测建模 大多数数据科学角色的另一项重要技能是构建预测模型。在游戏行业，这通常涉及到建立模型来预测可能购买游戏或游戏失败的用户。如果您可以检测出哪些用户最有可能执行这些操作，您可以推动用户采取所需的操作，例如发送电子邮件让玩家登录并领取游戏内奖励。预测模型的另一个用途是评估特征的重要性，以便指导游戏设计。例如，在电子艺界，我建立了一个回归模型,该模型确定，探索更多剧本的用户通常比专注于优化少数特定剧本的玩家拥有更低的保留率。

当改变领域时，我必须做出的改变之一是使用新的度量来评估预测模型的性能。对游戏行业分类任务有用的指标，如 F1 得分和 ROC，并不能很好地转化为金融科技领域的任务，如预测房屋的价值。对于此回归任务，您可以使用相对误差、相关系数或其他误差指标，如平均对数误差。

以下是我为这些领域建立的预测模型的例子:

• 游戏:哪些用户最有可能购买订阅？
• 金融科技:哪些家庭最有可能向非营利组织捐款？

与 EDA 类似，相同的工具可以用于构建跨这些领域的预测模型，我在这两个领域中都使用了 R 来构建原型模型。

数据产品 除了原型预测模型之外，数据科学家还应该有一个适当的流程来扩展模型以进行部署。在游戏行业，这通常涉及将模型规范交给工程团队，而在我目前的职位上，我更多地参与模型的产品化。在这两个领域中，您可以使用一种中间模型格式，比如 PMML 来分离模型训练和模型部署任务。

在这两个领域中，我构建了批处理模式的数据产品，每周计算数百万条记录的值:

• 游戏:计算订阅转换分数。
• FinTech: 为房地产创建估价。

我执行这些任务的工具集在角色之间发生了变化。我以前与工程团队一起构建定制解决方案，现在已经转向使用开放工具，如 PMML 和 Apache Beam，来生产模型。

结论 在我的数据科学职业生涯中，我从游戏行业转向了金融科技，并在新的岗位上使用了许多不同的数据源，但我在游戏中开发的许多技能都得到了很好的转化。探索性分析、实验、预测性建模和构建数据产品对所有数据科学家来说都是有用的技能，与他们所应用的领域无关。

我的日常工作重心也发生了变化，但这是因为角色类型和领域的变化。我已经从专注于产品分析的角色转变为更专注于机器学习的角色。我花更少的时间构建仪表板，花更多的时间编写代码和提交 PRs。

本·韦伯是意外收获数据的首席数据科学家，我们的任务是确定世界上每个家庭的净资产。

如果你今年参加 GDC，请随时在 twitter 上给我发消息。

从 Keras 模型到角度应用

原文：https://towardsdatascience.com/from-keras-model-to-angular-application-491d3f6c4455?source=collection_archive---------10-----------------------

介绍

与 TensorFlow 合作服务我想，如果也能为 Keras 模特服务，那就太棒了。 Keras 的优势是显而易见的——它大大简化了模型开发，并允许比纯 TensorFlow 框架更快地尝试模型。

另一个动机是，我想让客户端独立于庞大的 TensorFlow 框架，并使用非常有限的一部分服务功能。当然，我想直观地显示结果，而不需要通过枯燥的 JSON 输出:-)

用 TensorFlow 服务 Keras 模型

Keras 提供高级神经网络 API，能够在 TensorFlow 、 CNTK 或 Theano 之上运行。基本上，它抽象了那些框架，更容易理解和学习，并且允许你用更少的代码做更多的事情。

TensorFlow Serving 是一款用于托管机器学习模型的软件。它的主要用途—高性能生产服务。它是用 C++编写的，使用了客户端用于计算的 Servables 的概念。

如何与 TensorFlow 服务器对话

TensorFlow Serving 提供 gRPC API 用于执行回归、预测和推理任务。这种 gRPC API 比 HTTP 协议上的 REST API 具有更好的性能，但是不能被 Web 应用程序简单地使用。因此，在我看来，gRPC 是内部客户的完美选择，但是它应该被一个向外部世界提供 REST API 的服务所包装。

犬种检测器

对于我的示例应用程序，我使用了一个狗品种检测器，它是我在 Udacity 纳米学位课程期间实现的。我们想要解决的问题是给定一幅狗的图像进行品种检测。该模型利用了卷积神经网络(CNN)架构，并在 ImageNet 数据集模型上进行预训练(我选择了 DenseNet 201 )。该模型是用 Keras 库实现的。

应用的第二部分是一个 Node.js 服务，包装 TensorFlow 服务的 gRPC API，对外提供 REST API。该服务尽可能少地依赖 TensorFlow 它使用修改过的 protobufs 文件和 gRPC 库来处理服务器请求。因此，我们不需要在这里安装任何巨大的 TensorFlow 包。

最后一部分是一个非常简单(也不太好)的 Angular 应用程序，它允许选择狗的图像，向我们的包装服务发送请求，并显示品种。

代码可以在我的 GitHub repo 中找到。如果你觉得有用，可以随意复制、修改和使用:-)

从模型到应用

让我们深入研究一下实现细节。这里有 3 个主要部分:

• 使用 Keras 创建和训练模型，并为 TensorFlow 服务做准备
• 实现一个向外界提供 REST API 的包装器服务
• 创建一个简单的狗品种预测和结果显示的应用程序

犬种检测器模型

我不想用很多代码把文章弄乱。相反，我将提供实现的链接，并解释我遇到的主要挑战。

我创建模型的方法相当简单(你可以在dog _ breed _ detector _ trainer . py中遵循它)，Francois Chollet 在 Keras 博客中对此做了很好的解释。这些步骤是:

• 用权重加载预训练的 DenseNet 201，不加载顶层，并从预训练的网络中提取所谓的瓶颈特征。我已经在data _ extractor . py中实现了这个。
• 创建一个简单的顶层模型，该模型使用提取的要素作为输入，并且只有全局平均池和完全连接的图层。模型本身在dog _ breed _ detector _ model . py中实现。
• 训练顶级模特并保存检查点。这里 可以找到 。
• 创建“连接”预训练的 DenseNet 201 和训练的顶部模型的最终模型。这在final _ model . py中实现。
• 为 TensorFlow 服务准备并保存最终模型。你可以在这里 找到 。

主要挑战是找到一种合适的方法将 Keras 模型转换为 TensorFlow，并为 TensorFlow 服务做准备。基本上，我们这里有两个任务:将 Keras 模型转换为 TF 估计器，并将估计器导出为 TensorFlow 服务。

从版本 1.4 开始，我们可以将 Keras 模型转换为 TF 估计量——只需调用 model_to_estimator() 函数，就大功告成了！

tf_estimator = model_to_estimator(keras_model=model)

现在，我们可以保存估计器，用于这里描述的。这只是一个对 export_savedmodel() 函数的调用，带有一个用于服务的接收器函数。这样一个函数在最终模型之上创建了一个附加层，并负责输入解析。在我们的例子中，它将输入的 JPEG 图像转换成一个 3D 张量，可以被模型使用。

tf_estimator.export_savedmodel(export_dir,
    serving_input_receiver_fn,
    strip_default_attrs=True)

为了创建、训练和准备服务模型，首先安装 unzip (用于解压缩下载的带有狗图像的档案):

sudo apt-get update
sudo apt-get install unzip

然后克隆存储库，切换到模型服务目录，下载并解压缩狗图像，并训练模型:

git clone [https://github.com/Vetal1977/tf_serving_keras.git](https://github.com/Vetal1977/tf_serving_keras.git)cd tf_serving_keras/model_servingcurl [https://s3-us-west-1.amazonaws.com/udacity-aind/dog-project/dogImages.zip](https://s3-us-west-1.amazonaws.com/udacity-aind/dog-project/dogImages.zip) --output dogImages.zipunzip dogImages.zip
mv dogImages dog_images
rm dogImages.zippython dog_breed_detector_trainer.py

我的环境包括:

• 康达 4.3.14
• Python 3.5.4
• TensorFlow 1.8 的 GPU 版本
• Keras 2.1.6

Node.js 包装服务

第二个组件是一个包装器服务，它向外界提供 RESTful API，并将 gRPC 与 TensorFlow 服务器对话。附加要求—尽可能减少对 TensorFlow 的依赖。我为服务实现选择了 Node.js 和 Typescript。

第一步是准备 proto bufs——我把它们从官方仓库中拿出来，扔掉所有我不需要的东西。你可以在这里修改我的版本。我动态加载 protobufs，即在运行时，然后创建一个预测服务，如下所示:

this.tfServing = grpc.load(this.PROTO_PATH).tensorflow.serving;
this.client = new this.tfServing.PredictionService(
    this.tfServerUrl, grpc.credentials.createInsecure());

动态加载的优点是——您不需要通过每次修改 protobufs 来重新生成 Typescript 代码。缺点是性能下降。因为我只加载了一次 protobufs，所以这个缺点并不严重。

现在，当通过 REST 接口调用服务时，我们获取输入数据(图像作为 base64 编码的字符串)并向 TensorFlow 服务器创建 gRPC 请求—请在源中找到详细信息。

包装器服务是一个 Node.js express 应用程序，使用inverisfy进行依赖注入，使用 inverisfy express 实用程序 进行 REST API 实现。

我的服务的 API 基本路径是 /api/v1 ，我的控制器实现了唯一的端点 /predict_breed ，它允许图片上传并在 TensorFlow 服务器上调用狗的品种预测。要构建一个项目，请执行以下命令(我假设您已经克隆了 repo):

cd tf_serving_keras/detector-api
npm install
npm build

我的环境包括节点 8.11.3 和 npm 6.1.0。

角度应用

最后一部分是一个简单的角度应用，带有一个按钮来选择一个图像目录和一个区域，用于显示带有预测品种名称的图像。这里没有什么新奇的东西——我使用这个指南创建了一个新的 Angular 项目，并根据我的需要扩展了代码。

与包装器服务对话的客户端在detector . service . API . client . ts中实现。实现的注意事项——我有一个抽象类,它声明了一个预测方法和它的两个实现——上面提到了其中一个，第二个是我尝试使用一个全新的tensor flow Serving RESTful API。稍后我会提供一些评论。

我们需要注意 CORS 机制。 Angular HttpClient 依赖于 XMLHttpRequest ，我不得不将的后续头添加到我的 Node.js 包装服务中，以获得应用程序中的响应:

'Access-Control-Allow-Origin': '*'

这是一个典型的应用程序屏幕，上面有狗的图像和预测的品种:

要构建一个项目，执行以下命令(我假设您已经克隆了 repo):

cd tf_serving_keras/detector-app
npm install
npm build

使用 Docker 进行本地测试

老实说，我懒得分别启动和运行所有 3 个组件:-) Docker 和 Docker Compose 让我的生活更轻松。我需要 3 个 Docker 容器——一个用于托管我的模型的 TensorFlow 服务，一个用于包装服务，一个用于我的应用程序。我安装了以下版本:Docker 18.03.1-ce 和 Docker Compose 1.21.2。

TensorFlow 服务的 Docker 图像

在创建 Docker 映像之前，您必须有一个为 TensorFlow 服务的导出模型——请参见上文如何操作。上次为 TensorFlow 服务创建 Docker 容器花费了很多精力。从那以后事情发生了变化，现在我们可以用 apt-get 安装服务组件，而不需要克隆存储库和自己构建服务器。

echo "deb [arch=amd64] http://storage.googleapis.com/tensorflow-serving-apt stable tensorflow-model-server tensorflow-model-server-universal" | sudo tee /etc/apt/sources.list.d/tensorflow-serving.listcurl https://storage.googleapis.com/tensorflow-serving-apt/tensorflow-serving.release.pub.gpg | sudo apt-key add -sudo apt-get update && sudo apt-get install tensorflow-model-server

我创建了一个 Dockerfile ，在这里我执行了那些命令，复制了为服务模型准备的内容并启动了服务器。如果要创建 Docker 映像，请执行以下命令:

cd tf_serving_keras/model_serving
<activate your Python environment>
python dog_breed_detector_trainer.py
docker build -t model-serving:latest -f Dockerfile .

Node.js 包装服务的 Docker 图像

包装器服务的 Dockerfile 基于节点 8.11.3 镜像。它将源文件复制到映像，构建它们并启动服务。没什么特别的，都是标准的。

角度应用的 Docker 图像

我的应用程序的 Dockerfile 使用了多阶段构建。首先，我们使用 Node 8.11.3 image 构建应用程序，然后使用 Nginx image 将其隐藏在 Nginx 服务器后面，这在生产环境中很有意义。

将它们组合在一起

我们不会也不应该一个接一个地创建 3 个 Docker 容器。相反，我们将它们组合在一起，并用 Docker Compose 使它们彼此可见。在 docker-compose 文件中，我有 3 个服务，属于同一个网络。应用依赖于包装器服务，包装器服务依赖于 TensorFlow 服务。这些服务公开了容器端口，并且可以通过它们的名称相互通信。

要运行完整的应用程序，请执行唯一的命令

cd tf_serving_keras
docker-compose -f docker.compose.yaml up

打开浏览器，进入本地主机。您应该能够看到应用程序，选择图像并看到结果。不要忘记关闭容器

docker-compose -f docker.compose.yaml down

尝试 TensorFlow Serving 1.8 及其 RESTful API

当我准备好我的实现时，我发现从 1.8 版本开始 TensorFlow 服务也提供了 RESTful API。这是一个相当新的功能，我想尝试一下。

不幸的是，它有一些问题。首先，对于 CORS 机制，您必须有一种特殊的代理，因为您不能更改服务器代码。最受欢迎的是 cors-anywhere 。我创建了一个*包装器并将其打包到 Docker 容器中。如前所述，我在应用程序中实现了一个客户端，它通过 REST 直接与 TensorFlow 服务器对话。

其次，应该将图像数据包含在发送给服务器的 JSON 对象中。对于大图像，这不是一个正确的方法，我总是倾向于使用多部分/形式数据来实现这个目的。

如果您想尝试，请查看客户端源代码，并使用

docker-compose -f docker.compose.cors.yaml up

GPU 支持

如果你有一台装有 NVidia 显卡的电脑，并且安装了 CUDA 和 CUDnn 库，那么我们也可以在 Docker 中使用它们。但是我们需要做一些准备:

• 确保 Docker Compose 的版本至少是 1.19.0
• 安装 NVidia 容器运行时。我使用了以下命令:

curl -s -L https://nvidia.github.io/nvidia-container-runtime/gpgkey | \
  sudo apt-key add -distribution**=$(**. /etc/os-release;echo $ID$VERSION_ID**)**curl -s -L https://nvidia.github.io/nvidia-container-runtime/$distribution/nvidia-container-runtime.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-runtime.listsudo apt-get updatesudo apt-get install nvidia-container-runtime

• 通过 Docker 注册该运行时。我对守护程序配置文件使用了该方法:

sudo tee /etc/docker/daemon.json <<EOF
{
    "runtimes": {
        "nvidia": {
            "path": "/usr/bin/nvidia-container-runtime",
            "runtimeArgs": []
        }
    }
}
EOF
sudo pkill -SIGHUP dockerd

现在快跑

docker-compose -f docker.compose.gpu.yaml up

你应该得到一个 GPU 驱动的应用程序版本。你可以在资源库中找到支持 GPU 的 Dockerfile 和 Docker-compose 文件。

注意:可能需要几个*时才能看到系统启动并运行。原因是——我们仍然需要编译 TensorFlow 的 GPU 版本来创建一个合适的 Docker 图像。

结论

对我来说，实现从 Keras 模型到 UI 的完整深度学习应用程序是一次很好的体验。我尝试和使用了一些新的东西，并且为了在本地运行和测试所有东西，我需要解决一些挑战。我希望这对您的目的也有用:-)

从迷因到机器:将我们自己转移到人工智能宠物

原文：https://towardsdatascience.com/from-memes-to-machines-transferring-ourselves-to-our-ai-pets-1a9578279f93?source=collection_archive---------2-----------------------

“人无想法，想法有人。”—卡尔·荣格

理查德·道金斯在他的书《自私的基因》中谈到了一种迷因。他将迷因定义为任何在人类文化中表现得像基因的东西。它有一种繁殖机制，通过几代人的突变、繁殖或减少来实现。他说的目的是淡化基因是自然选择的唯一单位。

模因可以像曲调一样简单，也可以像文化意识形态一样复杂。我们的身份与拥有我们的迷因密切相关。即使缺乏基因相似性，我们还是会强烈偏向那些分享我们认为重要的迷因的人。如果一个家庭成员被一种对立的迷因如政治观点所占据，我们可以认为他们是蔑视。我们甚至会对那些分享表面模因的人表现出偏见，比如喜欢同一个音乐艺术家或运动队。

我们不能用机器进行生物繁殖，但将我们的迷因传递给我们的人工智能后代可能同样令人本能地满足。由于诸多不便，生物繁殖在高智商人群中已经过时了。这是痛苦的，它使我们的心智能力紧张，使社会交往紧张，减少了我们的物质资源。然而，生孩子被认为是我们能拥有的最有意义的经历之一。既然如此多的人致力于他们的事业，我们可以说，在这些个体中，模因的培养比生物繁殖的经验更丰富。

机器的迷因

我设想这个过程是在虚拟环境中进行的训练，在虚拟环境中，我们通过与我们有高度相似情绪控制输出的虚拟宠物来传递我们的想法。就像电影中的动画角色一样，它的身体将能够合成类似人类的表情和声音。然而，与电影中的角色不同，我们将教虚拟宠物他们表情的含义。

从一些基本技能开始，人工智能将把我们脸上的表情、声音和我们展示给他们的图像拼凑在一起。由此，他们将合成他们自己的表达方式，他们将因此受到我们的奖励和谴责。

这个过程将非常类似于从出生起抚养一个被收养的孩子。尽管没有生物学上的联系，但通过共同的经历和模因的传递，人们会感到一种亲密感。

这个可数字化定制的宠物将被设计成保存我们的迷因，并以一种独特的方式向我们表达新的、令人愉快的想法，但有一些问题很难忽视。如果人工智能宠物根据我们教给它的东西对道德状况做出反应，那么人工智能本身有道德吗？道德是需要同理心还是仅仅是一种技能？

可以说，道德是因为社会原因而进化的。它提供了一个共同的界面，让我们一起工作，以收集更多的资源。

人工智能将通过迷因与我们互动，其中最重要的是道德准则，以实现共同繁荣。饲养人工智能宠物的过程将在人和机器之间产生深刻的人类共性。本质上，通过培养一个虚拟的 AI，我们正在设计理想的交流界面。

无痛苦的养育？

我想把这个想法延伸到一个有些人可能认为亵渎神明的问题。如果我们如此巧妙地设计这种体验，以至于成为一个人工智能的父母比成为一个亲生父母更让人本能地满足，那会怎样？如果我们把它设计成最*化痛苦和最大化便利呢？

这一过程的成功是否意味着我们的灭绝或进化，或者两者都不是？最终结果会带来一个“耶稣基督”的人工智能吗？一个完美的人，他的每一个动作都代表着我们所信仰的理想。好莱坞如此痴迷于邪恶的人工智能，我想知道他们是否想过世界上有耶稣基督的可能性。毫无疑问，它不会那么引人注目。

耶稣对世界

自从我的我已经开始问亵渎神明的问题:如果一个虚拟的国家充满了耶稣基督，需要多少个人工智能魔鬼才能摧毁它？我们会发明一种可怕的箔片来对抗它吗？

结论

在这篇文章中，我可能掉进了哲学思考的兔子洞(毫无疑问，有些是有价值的)，但我目前感兴趣的主要问题是将我们的迷因转移到我们的机器上的工程问题。这是一个需要很长时间来实现的过程，我可能永远没有机会，但我会在未来的帖子中提出一些想法。

从中年母亲到编码学员:通过技术重塑

原文：https://towardsdatascience.com/from-middle-aged-mom-to-coding-mentee-reinvention-through-tech-77b3e5772240?source=collection_archive---------3-----------------------

作为一个女人，一个母亲，一个中年人，我一直想恰当地讲述我的重塑故事。把你以前的大部分职业选择抛向空中，让它们随风而去，然后选择新的(有挑战性的)东西，这不适合胆*的人。但这令人振奋，也许会激励更多处于职业生涯中期的人考虑做出类似的转变。我要感谢 Chipy 导师项目让我开始记录它——我很幸运被选为今年秋季的学员之一，写博客是项目要求之一。

Oh those career choices…just some weed seeds, blowing away in the wind of change…

多年来，我是一名文科和艺术学院的大学教授，陷入了一个经典的兼职陷阱——在多份工作之间奔波，试图找到足够的工作来*持生活。在那之前，我是博物馆馆长。我有文化史博士学位。这些似乎都不能为转向编码或数据科学工作奠定基础。但我一直对数据充满热情，对更好的东西有着贪婪的胃口。我研究的课题之一是广义上的地图，这当然是数据可视化的一种形式。从当地政治到食品合作社的志愿者项目工作让我接触到了更高层次的 Excel，从命令行工作，并创建我自己的图形和图表。

Phoenix from the flames???

当我在学术生涯中筋疲力尽时，我看看我能做些什么。我自学了如何用 Wordpress 制作一个基础网站,并为我的学术研究积累了一个关注的重要社交媒体(有趣的是:我的成名是因为我是一名纹身历史学家)。我开始寻找自由职业的机会。一个老朋友把我和她的一个老朋友联系了起来，一个新的职业生涯开始了。

我成了众包人体图像网站MyBodyGallery.com的唯一正式员工。你可以在我为新妈妈们可以编码项目写的的短文中读到更多关于这方面的内容。在这里可以说，它打开了许多大门，从了解定制代码站点的后端到学习如何使用 SQL。我知道下一步是解决正确的编码。我对数据的兴趣和经验使得数据科学训练营变得显而易见。我选择了大会的，并彻底享受了这种体验(即使连续三个月每周 5 天都要上课，每天晚上都要做作业，每个周末都要做项目，这种睡眠剥夺让我想起了身为婴儿父母的痛苦)。

I’m not sure I’ve been able to take a proper nap since February…zzzzzzzzz….

我为我在训练营的顶点项目感到自豪——它将我的纹身研究与数据科学结合起来，为一个计算器创建了一个预测模型，它将告诉一个崭露头角的作者有多少图书馆最终可能拥有他们的书……仅仅基于书名。它并没有成为我所希望的工具的全部，但是它确实有助于标题的选择。你可以在我的 Github 上了解更多信息。

但是和大多数 bootcamp capstone 项目一样，我甚至没有足够的时间来真正做我想做的事情:让这个计算器真正出现在现实世界中。我想把它放在我创办的一个新生的数字人文基金会的网站上，这个基金会就是纹身历史和文化中心。这就是 Chipy 导师计划的用武之地。我很高兴能成为 web dev track 的一员，在那里我开始将这些技能添加到我的工具包中(感谢 Joe Jasinski 作为我非常耐心和有帮助的导师)。现在这有点令人生畏，但我总是喜欢陡峭的学习曲线。请继续关注，看看这个计算器是如何工作的！

A mock-up of what the calculator page might look like

如果我不抓住这个机会谈一谈重返学校和抽出时间学习编程的斗争，同时又是一个单身母亲，那我就是失职了。命运给了我一个耐心而独立的女儿，她能理解妈妈的忙碌，并能忍受被拖着去面对各种情况。营业时间训练营起作用了，因为她在学校的时候我也在学校。Chipy 非常乐于助人，让她跟我一起参加了我的第一个 Python 项目之夜。她花了一个晚上的时间建造了一个新的《我的世界》世界，然后在会议结束时带他们参观了一下这个世界，交了几个成年朋友(冥界之门和龙蛋之类的东西)。Chipy 董事会非常乐于看到他们是否可以开始正式的儿童保育或教育经历，以帮助处于类似情况的其他人(感谢雷·伯格把我的想法带给整个董事会)。我已经让这位老姐参加了几个编码营和精彩的编码、游戏、学习的课程，也许她可以在未来几年帮助解决技术领域的性别失衡问题。我希望通过看到我永不停止学习和挑战自己，她不会满足于一个没有出路的职业生涯。也许在我参加这个项目的几个月里，她可以代替那只花栗鼠成为花栗鼠的吉祥物:)

Shout-out to Target’s excellent Cat and Jack brand for the “Create with Code” shirt (these are Lego sculptures the kiddo made while she was hanging at General Assembly on a no-school day)

从范数到正交性:带有直观例子的机器学习基础数学第 2/3 部分

原文：https://towardsdatascience.com/from-norm-to-orthogonality-fundamental-mathematics-for-machine-learning-with-intuitive-examples-57bb898e69f2?source=collection_archive---------9-----------------------

为了理解机器学习算法的数学，特别是深度学习算法，从基础到更高级建立数学概念是必不可少的。不幸的是，数学理论在许多情况下太难/抽象/枯燥，难以消化。想象你正在吃一个比萨饼，喝一杯可乐总是更容易和更有趣。

这篇文章的目的是为基础数学理论提供直观的例子使学习体验更加愉快和难忘，那就是鸡翅配啤酒，薯条配番茄酱，里脊配葡萄酒。

包含 3 门课程的机器学习基础数学课程组织如下:

从标量到张量:带有直观例子的机器学习基础数学第 1/3 部分

• 什么是标量、矢量、矩阵和张量？
• 标量、向量和矩阵之间的加法
• 标量、向量和矩阵之间的乘法
• 单位矩阵和逆矩阵
• 对角矩阵和对称矩阵

从范数到正交:带有直观示例的机器学习基础数学第 2/3 部分

• 向量的 1-范数，2-范数，最大范数
• 正交和标准正交向量
• 正交矩阵

从特征分解到行列式:带有直观例子的机器学习基础数学第 3/3 部分

• 矩阵的特征分解:特征值和特征向量
• 跟踪运算符
• 方阵的行列式

在本文中，我们将通过直观的例子，从范数到正交性讨论第 2/3 部分。

向量的 1-范数，2-范数，最大范数

如何度量一个矢量的大*？一种方法是使用范数函数:

• 1-范数:在机器学习应用中，当 0 和非 0 元素之间的差异很重要时，通常使用 1-范数。

例如，向量 v 的 1 范数可以计算为:

• 2-范数:通称欧氏范数，是原点到向量 x 所标识的点的欧氏距离。

Photo credit to wikipedia

通常使用平方 2-范数而不是 2-范数本身来度量向量的大*。原因是平方 2 范数可以计算为:

这比计算 2-范数本身更方便。下面的例子说明了如何计算向量 v: 的 2-范数

• 最大范数:向量中元素的最大绝对值，可以写成:

下面的例子显示了向量 v: 的最大范数的计算

正交和标准正交向量

向量 u 和向量 v 彼此正交当且仅当它们的点积为 0:

例如，在三*欧几里得空间中，

在几何学中，两个正交向量在欧几里得空间中相互垂直:

Photo credit to ubisafe

向量 u 和向量 v 是一对正交的向量的意思是:

它可以扩展到 3-D 欧几里得空间中的下列方程:

举个例子，

因此，我们说，向量 u 和向量 v 是正交的。

正交矩阵

正交矩阵是行和列正交的正方形矩阵:

例如，以下矩阵是正交的，因为:

这意味着如果一个矩阵的转置等于其逆矩阵，则该矩阵是正交的:

因此，正交矩阵是机器学习中感兴趣的，因为矩阵的逆的计算非常便宜。我们需要注意的是，正交矩阵中的行和列不仅是正交的，而且是正交的。

恭喜你！你已经用直观的例子完成了机器学习基础数学的三分之二。你能做到的！

下一步: 从特征分解到行列式:带有直观例子的机器学习基础数学第 3/3 部分

从病人到 Python:成为“数据科学家博士”的思考

原文：https://towardsdatascience.com/from-patients-to-python-thoughts-on-becoming-a-dr-data-scientist-d01aa583b08a?source=collection_archive---------2-----------------------

“当我长大后，我想成为一名医生，因为我想让我的灵魂迷失在点击通知和写便条中。”

说没有孩子。

回到我的时代，我们住院医生用纸和笔写笔记。我们对图表的抱怨包括在特别长的 H+Ps 后严重的手抽筋，或者试图辨认难以辨认的鸡肉划痕。你可以想象当医院转向电子健康记录时我们的喜悦心情(EHR)。对我来说，在 AOL IM 和在线视频游戏中长大后，打字变得轻而易举，笔记也终于清晰可辨。

然后一些邪恶的想法开始给 EHR 增加“功能性”。

几年后，“功能性”导致了我们今天看到的 EHR 这个九头蛇怪物。你砍掉了一个脑袋，解决了一个订单输入故障，EHR 九头蛇又长出了三个脑袋，在它们的位置上弹出了通知窗口。

我正在为执业医师量身定做这个职位。如果那是你，那么我正在向唱诗班宣讲当前的医疗保健基础设施对我们的工作流程和患者护理的影响。然后，你会明白为什么我想在十年的医学训练后回到学校。如果我们要给系统带来改变，并说服我们的同事改变现状，那么我们最好知道我们到底在说什么。

为什么是数据科学？

也许是 2012 年《哈佛商业评论》的标题，“数据科学家:21 世纪最性感的工作”唉，我后来才知道，不是所有的数据科学家都生来平等，也不是所有人都天生性感(尽管我们在努力)。数据科学不是固定的描述；这是一个连续体。它涵盖了从清理和组织数据、限制统计分析中的偏差等极其无趣的事情，到有效地向你的受众传达可操作的发现。熟悉从原始数据到有意义的结论的流程似乎比在游戏的后期追求一个直接的编程学位更有用。

选择加州大学伯克利分校的数据科学硕士( MIDS )项目并不难。虽然听起来不像他们会说话的头，但我真的，真的，真的很喜欢做 MIDS 的学生。它仍然是一个相对年轻的项目，课程不断发展，并且是在线的(除了沉浸周，在那里你可以与科技公司接触)，但它在一个国际知名的机构提供了坚实的课程和令人惊叹的师资，有大量的社交机会。不要告诉我不知道你的在线课程的同学——当你两年来每周都看到相同的人时，你会情不自禁地结交一些亲密的朋友(大声喊出 socal-4eva 和 da-mids slack channels！).

MIDS Immersion Week 2017, whereeveryone looks wierd in 3D

所以，对于所有执业医师来说，你应该如何对待这个进入科技世界的信念飞跃呢？

现实一点。

首先，你需要评估你的技能、金钱和时间。举个例子，我有一个博士后研究员基金，这个基金比我作为全职临床医生的正常收入低 30%。另一方面，我一个月有 3 周的研究时间。你可以尽情嫉妒，但请记住，当你开着玛莎拉蒂的时候，我还在吃拉面和鸡蛋(或者至少在为一辆玛莎拉蒂付款)。但我从未上过编码或计算机科学(CS)课程，我认为时间应该是最重要的。你的资助也是一个考虑因素，因为研究生课程并不便宜。当然，Coursera、Udacity 和 Khan Academy 的在线课程非常优秀，许多数据科学家都通过他们的教学促进了自己的职业发展。交几千拿个证好还是交几万拿个毕业证好？作为一名医疗科技行业的新人，我迫切需要在简历上获得街头信誉，所以我选择了后者。

要谦虚。

你不再是精英了。一点也不接近。当然，你挺过了医学院、住院医师和董事会，但是假设你真的没有任何计算机科学背景，当你还在疯狂地谷歌"如何做矩阵乘法"时，你知道比你* 15 岁的孩子将会讨论 LSTM 矩阵的*数我花了几个星期才明白，你可以通过点击 tab 键来自动完成命令行。老实说，我只是觉得我的教授打字非常非常快。不要让我开始参加 Kaggle / kegel 竞赛。最后，准备好 1:3 的家庭作业时间比例——你的同学花在家庭作业上的每一个*时，你都要花三倍的时间。虽然我不想说太多，但现在重温这一点还为时过早。

坚持不懈。

在我的第一个 Python 入门课程中，我认真考虑过放弃，如果我不是更讨厌放弃的话，我会放弃的。有时候，特别是当我住院和随叫随到的时候，抽出时间去上课或参与集体项目是如此的令人生畏，以至于我想蜷缩成一团哭出来。相反，我给自己倒了一杯威士忌，然后开始喝。这很像医学院，在那里学习不是短跑；这是一场马拉松。

不要脸。

对于医生来说，我们的招聘信息相当简单。事实证明，对于未来如何使用自己的数据科学技能，需要进行大量的自我反省。当我面对我在这个项目上投入的金钱和时间，却发现没有适合我描述的人的工作时，我没有预料到那段深深的、黑暗的绝望时期。我不符合数据科学家的特征，精通 SQL，对机器学习(ML)技术了如指掌。我也不是医学信息学家，他们对 EHR、SNOMED 和其他领域的所有东西都有深刻的理解。因此，在毕业前一年，我开始随机联系医疗技术行业的人或数据科学家。如果我在 techcrunch 上读到一篇关于他们的文章，或者看到一个转发的帖子引发了我的兴趣，我会联系他们。在我的巅峰时期，我每周发出 5-10 条信息，大约有 5%的回复，这导致了 30 分钟的电话聊天或谷歌聊天。在这样做了整整一年后，一些随机的信息让我收到了一些采访请求，其中包括一个关于我未来的家 Curai 的请求，我非常兴奋和感激几个月后就可以开始工作了。

冒名顶替。

进入硅谷是令人生畏的。在 SV 有很多聪明的人，他们似乎都互相认识并且穿着 Allbirds 。此外，每三个人中就有一个以几百万美元的价格卖掉了一家初创公司。当你遇到有工程学或计算机科学背景的了不起的医生时，我会想，“谁他妈的需要我？”我那了不起的丈夫改变了我的想法，他向我介绍了“骗子综合症”的概念，在这种情况下，我们不合理地低估了自己的表现和才能。查一下吧，它发生在我们最好的人身上。

要骄傲。

这是我从这次经历中得到的最重要的教训——有很多才华横溢的软件工程师和统计学家可以让我的基本逻辑回归和张量流图相形见绌。但当面对这样的疑问时，我想起了当初为什么要投身数据科学。我可以带来一些纯数据科学家做不到的东西。医疗保健系统需要像你和我这样的人，他们从临床战壕中幸存下来并理解 NLP 和 ML 概念，因为我们可以帮助将我们在医院或患者护理中看到的问题转化为工程师、统计学家、首席执行官、风投、UI 开发人员和其他重要决策者可以理解的术语。有了这些超能力，我们可以开始改变医疗保健系统，这是我们医生知道我们需要的。

祝你好运，希望胜率永远对你有利。

以最*的努力从科学到生产

原文：https://towardsdatascience.com/from-science-to-production-in-minimum-effort-acc9d0db6ec2?source=collection_archive---------20-----------------------

热链接:
---丹泽尔部署框架-

在过去的一年里，我在我工作的组织中完成了许多数据科学项目，我花了数百个*时与数据科学家同事一起工作。
由于数据科学领域非常年轻，所以我的同事以及一般的数据科学家来自不同领域也就不足为奇了。数学、统计学、物理学甚至心理学，这种多样性是非常积极的，因为每个人都从各自的领域带来了自己的优势和观点。我自己来自软件工程，这自然让我从一个工程师的角度来审视过程。

理工科之间的差距

完成一个数据科学项目需要很多技能。
一个人应该对算法的本质有数学理解和直觉，拥有创建和测试问题假设的统计知识，熟悉算法和最先进的解决方案等等。
要成为一名优秀的数据科学家，工程和编程技能不一定要达到专家级水平。不知道什么是 HTTP 动词，不知道如何管理工作人员和经纪人的任务队列，也不知道如何构建浏览器中的监控仪表板，完全有可能成为顶级的现场研究员。另一方面，生产系统需要相当高级的工程技能。

从我的工程角度来看，我已经注意到，一旦数据科学项目必须从研究阶段进入生产阶段，科学和工程之间的差距就会显现出来。
我见过数据科学家与框架斗争，花费不必要的时间学习超出他们必要技能范围的工具。
另一方面，我看到生产团队(来自数据科学家团队)交付的项目，他们不理解也不知道如何整合到他们组织的生产周期中。
由于这个问题是真实存在的，并且经常发生，我决定采取措施，用开源 Python 包来弥补这个差距。

见见丹泽尔

在我打开以德古拉为主题的编辑器开始编写框架之前，我已经坐下来定义了需求:

1. 首先是数据科学家。对于数据科学家来说，框架应该有尽可能少的学习开销，并抽象出繁重的工作。
2. 又瘦又快。框架内的开发应该是快速的，结果应该尽可能的精简。
3. 生产就绪。使用生产级的工具和实践，它的输出应该能够很容易地交付给生产工程师使用。

三个要求，几十个*时的代码，几个月的测试和真正的生产使用，后来丹泽尔包诞生了，现在开源供公众使用。

Denzel 是部署机器学习训练模型的最*框架。
一旦你有了一个保存在磁盘上的训练好的模型，你需要做的就是实现四个简单的 Python 函数，丹泽尔会给你:

1. 码头集装箱化项目
2. 向最终用户公开 API 以与您的模型进行交互
3. 任务管理系统排队并执行预测
4. 在浏览器 UI 仪表板中监控您的部署

这里的一个重要方面是码头集装箱化的结果。这意味着任何知道如何在生产中管理 docker 容器的人都可以应用任何生产工具(如 Kubernetes、Rancher 等)。)以及在任何地方扩展和部署项目的无限可能性。此外，所有主要的云提供商都支持 docker 部署。所有这一切都不需要数据科学家自己学习 docker、API 构建、任务管理或 UI 设计。

该项目得到了我的雇主数据科学集团有限公司的全力支持，目前正在许多不同的部署中使用。
它为我们的数据科学家节省了大量不必要的时间，并为我们的客户提供了一种将我们的解决方案集成到他们的生产系统中的便捷方式。

Denzel 目前处于 alpha 阶段，这意味着功能仍将被添加到其中，开源是了解数据科学界真正需要它的最佳方式。

为了使用它，查看文档，尤其是教程，一个*时左右加上 60 行代码之后，你就可以部署你的模型了。

希望你喜欢这次阅读，丹泽尔将为你服务。

部署愉快:)

从 Scikit-学习到 TensorFlow:第 1 部分

原文：https://towardsdatascience.com/from-scikit-learn-to-tensorflow-part-1-9ee0b96d4c85?source=collection_archive---------1-----------------------

介绍

在过去的一年半时间里， TensorFlow 无论是在采用率还是在计算速度方面都以惊人的速度增长。

Image Source: Unreasonable Popularity of TensorFlow [http://deliprao.com/archives/168]

TensorFlow 已经成为最受欢迎的机器学习(ML)算法开发库。然而，它似乎也把自己建立成了一个库，需要对会话和图形进行定义，这是相当乏味和耗时的。虽然它在有效计算梯度以训练CNN、 RNNs 和lstm方面做得很好，但这还不是全部。

在这一系列帖子中，我想讨论如何将 TensorFlow 用作通用 ML 库。更具体地说，我们将讨论它如何类似于 scikit-learn ，另一个在数据科学家和开发人员中非常流行的 ML 库。

转向 TensorFlow 的理由

虽然 scikit-learn 拥有高度优化的算法，但在面对大量数据点时，它缺乏扩展能力。然而，TensorFlow 提供了许多优于 scikit-learn 的优势:

• 高性能 ML 模块
• 可定制性
• 纵向扩展以满足大数据点的需求
• 能够利用 GPU 并在地理上分散的 GPU 设备之间进行培训
• 设备无关计算
• 利用 Google Cloud 在训练好的 ML 模型上进行推理
• 高度灵活的 Apache 2.0 许可而 scikit-learn 是基于 BSD 许可(虽然两者都是商业可用的，但是 Apache 2.0 不太容易出现专利诉讼)

目标

• 了解 scikit-learn 和 TensorFlow 之间的相似功能，这些功能将允许 scikit-learn 用户无缝使用 TensorFlow。
• 使用 scikit-learn 和 TensorFlow 开发一个程序来对来自鸢尾花数据集的花卉品种进行分类，以了解构建这样一个系统所需的工作。
• 展示 TensorFlow 如何简单地实现新想法的原型。

功能级相似性

scikit-learn 受欢迎的原因之一是由于它的简单

classifier.fit() / classifier.predict() 

对于所使用的任何分类器都保持不变的方法。这种简单的用户体验使开发人员能够专注于算法及其参数，而不是担心需要调用哪些 API 来完成手头的任务。

另一方面，我们在 TensorFlow 中有受 scikit-learn 启发的高级 API 。TensorFlow 中的这些函数的工作方式与 scikit-learn 非常相似，具有类似的 fit 和 predict 方法以及允许进一步微调的其他功能。

在我们深入研究使用 TensorFlow 的高级 API 调用开发我们的分类框架之前，让我们讨论一下 TensorFlow 的低级计算框架。TensorFlow 使用计算图来执行所有计算。计算被表示为tf.Graph对象的实例，其中数据被表示为tf.Tensor对象，并且使用tf.Operation对象对这些张量对象进行操作。然后使用tf.Session对象在会话中执行该图。很明显，使用 TensorFlow 的低级 API 创建一个分类框架需要测试一个简单的 ML 原型。这也是我们讨论 TensorFlow 的高级 API 与 scikit-learn 的 API 进行对比的原因之一。我们将在以后的文章中讨论低级 API 及其用法。

示例代码

我们使用 scikit-learn 的 SVM 模块和 TensorFlow 的高级 API 构建了一个分类器，根据花的特征对花进行分类。在这种情况下，数据集提供了 4 个不同的特征，如萼片宽度、萼片长度、花瓣宽度和花瓣长度，以将花分类为三个花卉品种之一(鸢尾、杂色鸢尾和海滨鸢尾)。)

这个项目的代码可以在我的 GitHub 页面上找到。

Image source: TensorFlow Quickstart [https://www.tensorflow.org/get_started/tflearn]

如果我们看看上面 GitHub 链接上的笔记本，我们可以看到数据加载和拆分功能是由两个框架共享的。我们在 scikit-learn 中定义了一个 SVM 分类器，如下所示:

*# ------------------------------------------*
*# Scikit Learn Implementation*
*# ------------------------------------------*
*# Use support vector classification*
classifier_sk = svm.SVC()*# Use the train data to train this classifier*
classifier_sk.fit(x_train, y_train)*# Use the trained model to predict on the test data*
predictions = classifier_sk.predict(x_test)
score = metrics.accuracy_score(y_test, predictions)

在上面的代码片段中，我们简单地定义了一个支持向量分类器 svm。SVC() ，其对象用于训练和预测。使用 fit() 实现训练，而使用 predict() 方法调用实现预测。我们最后计算这个四行代码片段最后一行的精度值。

另一方面，在 TensorFlow 中，我们可以使用深度神经网络(DNN)分类器来完成相同的任务。我们使用 TensorFlow 的 contrib 模块下的 DNNClassifier 如下:

*# ------------------------------------------*
*# TensorFlow Implementation*
*# ------------------------------------------**# Extract the features from the training data*
feats = tf.contrib.learn.infer_real_valued_columns_from_input(x_train)*# Building a 3-layer DNN with 50 units each.*
classifier_tf = tf.contrib.learn.DNNClassifier(feature_columns=feats, 
                                               hidden_units=[50, 50, 50], 
                                               n_classes=3)*# Use the train data to train this classifier*
classifier_tf.fit(x_train, y_train, steps=5000)*# Use the trained model to predict on the test data*
predictions = list(classifier_tf.predict(x_test, as_iterable=True))
score = metrics.accuracy_score(y_test, predictions)

在上面的代码片段中，我们可以看到如何为几乎相同数量的行(构建 DNN，除了用于将输入数据转换为要素的附加行。)这一额外的行完成了将输入数据转换成密集的、固定长度的浮点值的任务。

向张量流迁移的路径

虽然从一个框架转移到另一个框架的任务通常令人畏惧，有时令人沮丧，但 TensorFlow 似乎有一座桥梁，允许开发人员从一个不同的框架平稳过渡。 contrib.learn 模块提供了这样一个桥梁，允许从 scikit-learn 或 Keras 到 TensorFlow 的熟悉路径。

TensorFlow 还具有足够的适应性，可以包含针对生产质量使用进行了高度优化的阅读器，同时支持 ML 社区使用的大多数文件格式。这使得开发人员可以避免依赖其他框架，如*猫(它完成了读取文件的繁重工作，但仍然需要手动将数据输入 ML 框架。)在今年早些时候举行的 TensorFlow 开发峰会上，TensorFlow 阅读器也表现出了高性能。

摘要

在这篇文章中，我们开始探索使用 scikit-learn 和 TensorFlow 开发一个分类器来完成一个简单的任务。我们讨论了高级 TensorFlow API 如何类似于 scikit-learn 的 API。你可以在我的 GitHub 页面访问这篇博客中讨论的代码。

在下一篇文章中，我打算介绍更多的 scikit 模块及其 TensorFlow 对应模块。你有什么特别的想法吗？给我发推特 @krtk 或者在 LinkedIn 上联系我。

从 Scikit-学习到 TensorFlow:第 2 部分

原文：https://towardsdatascience.com/from-scikit-learn-to-tensorflow-part-2-66c56985d6c7?source=collection_archive---------1-----------------------

从我们离开的地方继续，我们从 scikit-learn 开发人员的角度更深入地研究如何使用 TensorFlow 开发机器学习(ML)算法。如果您想知道迁移到 TensorFlow 的原因、动机，请阅读我之前的帖子，了解迁移到 TensorFlow 的原因和一个简单的分类程序，该程序强调了 scikit-learn 和 TensorFlow 开发的相似性。

在之前的文章中，我们比较了 scikit-learn 和 TensorFlow 中 fit 和 predict 范式的相似性。在这篇文章中，我想展示我们可以用 Scikit-learn 的数据处理和报告工具开发一个 TensorFlow 分类框架。这将提供一个很好的方法来交织这两个框架，从而得到一个简洁明了的框架。

利用机器学习

机器学习(ML)问题无处不在。然而，这里的问题是，一旦你开始用 ML 解决问题，每一个新问题看起来都像是 ML 问题，就像那句老话所说的:

如果你只有一把锤子，所有的东西看起来都像钉子

一个理解 ML 的人和一个使用 ML 的人有一个重要的区别，那就是，当不是使用 ML 来解决问题的时候。如果您可以通过简单的规则轻松地找到解决方案，那么您可能不需要使用 ML。例如，你不需要一个 ML 算法来预测所有的自行车和汽车是交通方式或者用正确的拼写替换常见的拼写错误的单词。

如果规则变得难以处理，并且如果有太多的参数来确定这样的规则，我们将需要 ML。例如，我们将要求 ML 预测明天的天气，因为它取决于许多因素，如季节、地点、其他因素，如厄尔*诺，这使得编写规则很困难，而且往往不准确。我们可能需要 ML 的另一个例子是当数据变得人类不可能仔细阅读并找到模式时，这是 ML 似乎做得很好的一个领域。以电子邮件垃圾邮件或火腿为例，我们根据电子邮件中的文本(正文+主题)将电子邮件分类为垃圾邮件。如果垃圾邮件的模式是有限的，这个任务就很容易。然而，发送此类电子邮件的“王子”往往会找到新的方法让我们都变得“富有”，这使得我们有必要开发 ML 框架来帮助我们对抗垃圾邮件。

说了这么多，让我们来看看一个本来就很难发现规则的问题，以及一个获得高精度和召回率的棘手问题。

问题是

我们将使用威斯康星州乳腺癌诊断数据检测癌症的存在。这个数据集是一个二元分类问题(恶性或良性)，有 569 个实例(数据点)，允许我们执行分类任务。

这篇文章中描述的所有代码都可以在我的 GitHub repo 这里获得。

数据处理-sci kit-learn

我们利用 Scikit-learn 的高效数据加载工具来获取我们的数据。乳腺癌数据集可在这里获得。Scikit-learn 允许我们加载的其他数据集的列表可以在这里找到。让我们加载数据集并查看数据的一些属性。

from sklearn.datasets import load_breast_cancer
cancer_data = load_breast_cancer()print("Number of instances in the dataset: %d" % len(cancer_data.target))>> Number of instances in the dataset: 569 

让我们讨论一下在训练数据之前，按原样使用数据与扩展功能的影响。缩放数据可以使特征标准化。这意味着数据以零为中心，并调整到标准偏差为 1。换句话说，我们将数据限制在[0，1]之间，而不改变数据的原始分布。这确保了分类器不会在大*度空间中搜索最优权重，而是将搜索空间限制在[0，1]之间。这种缩放对分类器的性能有很大的影响，这可以在下面的实验部分看到。我们尝试了两个实验，一个有特征缩放，另一个没有特征缩放。

实验一:按原样使用数据[D1]

我们按原样使用来自 SKLearn 的数据，使用内置的训练、测试分离器简单地加载变量

from sklearn.model_selection import train_test_split
in_train, in_test, out_train, out_test = train_test_split(cancer_data[‘data’], 
 cancer_data[‘target’])

实验二:缩放数据[D2]

对于第二个实验，我们使用 SKLearn 中可用的预处理功能来缩放数据。

from sklearn.preprocessing import StandardScaler
data_scaler = StandardScaler()# Fit train data 
data_scaler.fit(in_train)in_train = data_scaler.transform(in_train)
in_test = data_scaler.transform(in_test)

网络-张量流

我们设计了一个类似于我的早期文章的神经网络，以保持网络的简单方法，而不是理解数据预处理和过度拟合的影响。我们使用 TensorFlow 的 DNNClassifier ，它在 TensorFlow 的 contrib 模块中可用。我们定义一个有三层的网络，每层有 <个单元> 个隐藏单元。在我们的实验中，我们首先通过改变输入的预处理方式来评估以下网络的性能，其中单位=50 。然后选择性能最佳的输入进行进一步实验，以了解过拟合，其中我们保持数据不变(在 D1 和 D2 中最好)并改变单位。网络结构描述如下:

feature_columns = tf.contrib.learn.infer_real_valued_columns_from_input(in_train)
classifier_tf = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns, 
 hidden_units=[units, units, units], 
 n_classes=2)
classifier_tf.fit(in_train, out_train, steps=1000)

上面的网络所做的是定义一个全连接网络，也称为多层感知器，其输入来自我们刚刚加载的数据。多层感知器可以描述如下:

Multi-layer Perceptron [source: deeplearning.net]

在我们的例子中，输入是从癌症数据集加载的数据，而输出是一个二进制值，表示输入是恶性的还是良性的。

实验三:隐藏单元的数量[H1]

这两个实验的目的是了解隐藏单元的数量对每层的影响，这也将提供对过度拟合的洞察。

在这个实验中，我们首先选择 D1 或 D2(如上所述),然后改变网络每层的隐藏单元数量。这个实验的隐藏单元的数量保持在 H1=10。

实验四:隐藏单元的数量[H2]

我们用比 H1 更多的隐藏单元进行了第四次实验。这将能够适应数据中的更多变化，但是可能最终会记住数据，因此无法在测试数据上很好地执行。我们运行类似于上面 H1 的实验，然后运行 H2=50 的网络。

报告-sci kit-学习

我们使用 Scikit-learn 的报告功能来了解我们的分类器是如何执行的。我们使用分类报告和混淆矩阵来理解我们的分类器的表现。

分类报告生成一个矩阵，其中包含使用预测输出和实际输出值计算的关键指标。报告的指标是每个类别的精确度、召回率和 f1 分数，以及所有类别的平均值。

report = metrics.classification_report(out_test, predictions, 
 target_names=cancer_data.target_names)
print(report)

虽然分类报告提供了关键指标，但是混淆矩阵提供了每个测试数据点所属的类别。混淆矩阵显示了分类器在对一个类别进行预测时有多强，同时显示了分类器在对其他类别下的数据进行分类时的弱点。

# Plotting the confusion matrix using matplotlib
%matplotlib inline
confusion = metrics.confusion_matrix(out_test, predictions)# Plot non-normalized confusion matrix
plt.figure()
plot_confusion_matrix(confusion, classes=cancer_data.target_names,
 title=’Confusion matrix, without normalization’)

分类报告描述了整体性能，而混淆矩阵提供了分类到每个类别下的数据点的准确数量。

结果

我们首先进行实验，以了解数据标准化是否有助于更好的分类。因此，我们选择 H1，在 D1 和 D2 进行实验。结果如下:

与 H1+D1 的表演

 precision    recall  f1-score   support

  malignant       0.94      0.88      0.91        51
     benign       0.94      0.97      0.95        92

avg / total       0.94      0.94      0.94       143Prediction Accuracy: 0.937063

H1+D2 的表现

 precision    recall  f1-score   support

  malignant       0.96      0.93      0.95        46
     benign       0.97      0.98      0.97        97

avg / total       0.96      0.97      0.96       143Prediction Accuracy: 0.965035

从我们的实验中可以明显看出，数据缩放在分类准确性方面提供了 ~3% 的改进。这让我们选择 D2(数据与缩放)为我们的实验与 H2。

H2+D2 的表现

 precision    recall  f1-score   support

  malignant       0.96      0.92      0.94        53
     benign       0.96      0.98      0.97        90

avg / total       0.96      0.96      0.96       143Prediction Accuracy: 0.958042

技术性能分析

H1+D2 和 H2+D2 的性能指标没有提供多少关于分类器在数据点数量方面在其他类别中表现如何的洞察力。这就是混淆矩阵为进一步分析提供更好的图像的地方。

Confusion matrix for H2 + D2

Confusion matrix for H1 + D2

上述矩阵更清楚地显示了 H1 和 H2 分类器的性能差异。尽管 H2 的隐藏单元数量是 H1 的五倍，但它在测试数据上的表现却不如 H1。混淆矩阵提供了每个类别下被错误分类的点数的准确分布。

结论

在这篇文章中，我们看到了如何使用 Scikit-learn 和 TensorFlow 来执行不同的分类实验，并查看每个分类器的性能。我们还对数据预处理和网络参数进行了简单的实验，以理解不同的概念。

这篇文章中描述的所有代码都可以在我的 GitHub repo 这里找到。

让我知道你希望我在下一篇文章中讨论什么话题，请在下面评论。我在推特上，如果你想在那里和我联系的话！

从无到有:50 行 Python 中的人工智能平衡术

原文：https://towardsdatascience.com/from-scratch-ai-balancing-act-in-50-lines-of-python-7ea67ef717?source=collection_archive---------3-----------------------

Ours will do a little bit better than this in the end 😃

大家好！今天我想展示如何用 50 行 Python 语言教会一台机器平衡一根杆子！我们将使用标准的 OpenAI Gym 作为我们的测试环境，并且只用 numpy 创建我们的代理。

手推车杆子问题是我们必须左右推动手推车来平衡上面的杆子。这类似于在我们的指尖垂直平衡一支铅笔，除了一*(相当有挑战性！)

在我们开始之前，你可以在 repl.it 查看的最终演示。

RL 速成班

如果这是你第一次学习机器学习或强化学习，我会在这里介绍一些基础知识，这样你就会对我们在这里使用的术语有所了解:)。如果这不是你的第一次，你可以继续往下跳，制定我们的政策！

强化学习

强化学习(RL)是一个研究领域，致力于教导代理(我们的算法/机器)执行某些任务/动作，而不明确告诉它如何做。把它想象成一个婴儿，随意地移动它的腿；幸运的是，如果婴儿站直了，我们会给它一颗糖/奖励。同样，代理人的目标将是在其一生中最大化总报酬，我们将决定与我们想要完成的任务相一致的报酬。对于站立的例子，当直立时奖励 1，否则奖励 0。

一个 RL 代理的例子是 AlphaGo，代理已经学会了如何玩围棋来最大化它的奖励(赢得比赛)。在本教程中，我们将创建一个代理，它可以通过向左或向右推手推车来解决平衡手推车上的杆子的问题。

状态

What a game of pong looks like, in case you need a refresher

一个状态就是游戏目前的样子。我们通常处理游戏的数字表示。在乒乓游戏中，可能是每个球拍的垂直位置和 x，y 坐标+球的速度。在*车杆的情况下，我们的状态由 4 个数字组成:*车的位置，*车的速度，杆的位置(作为一个角度)和杆的角速度。这 4 个数字作为一个数组(或向量)提供给我们。这很重要；理解状态是一组数字意味着我们可以对它做一些数学运算，以决定我们想要根据状态采取什么行动。

政策

策略是一个函数，它可以获取游戏的状态(例如棋盘棋子的位置，或者手推车和杆子的位置)并输出代理在该位置应该采取的动作(例如移动骑士，或者把车推到左边)。在代理采取我们选择的行动后，游戏将更新下一个状态，我们将再次将它输入策略以做出决定。这种情况一直持续到游戏以某种方式结束。政策非常重要，也是我们所寻求的，因为它是代理背后的决策能力。

点积

两个数组(向量)之间的点积就是将第一个数组的每个元素乘以第二个数组的相应元素，然后将所有元素相加。假设我们想要找到数组 A 和 B 的点积，它将简单地是 A[0]B[0] + A[1]B[1]…我们将使用此操作将状态(这是一个数组)乘以另一个数组(这将是我们的策略)。我们将在下一节中看到这一点。

发展我们的政策

为了解决我们的车杆游戏，我们希望让我们的机器学习一种策略或政策来赢得游戏或最大化我们的奖励。

对于我们今天要开发的代理，我们将把我们的策略表示为一个由 4 个数字组成的数组，这些数字表示状态的每个组成部分有多“重要”(手推车位置、杆子位置等)。)然后我们将策略数组与状态进行点积，以输出一个数字。根据数字是正数还是负数，我们将向左或向右推手推车。

如果这听起来有点抽象，让我们挑选一个具体的例子，看看会发生什么。

假设手推车在游戏中处于中心位置，并且静止不动，杆子向右倾斜，并且也向右倾斜。它看起来会像这样:

关联的状态可能如下所示:

那么状态数组将是[0，0，0.2，0.05]。

现在，凭直觉，我们会想通过向右推手推车，把杆子拉直。我从一次训练中获得了一个好的策略，它的策略数组是:[-0.116，0.332，0.207 0.352]。让我们手动快速计算一下，看看这个策略作为这个州的一个动作会输出什么。

这里我们将点积状态数组[0，0，0.2，0.05]和策略数组(粘贴在上面)。如果数字是正数，我们向右推，如果数字是负数，我们向左推。

结果是肯定的，这意味着在这种情况下，政策也会把车推到右边，这正是我们想要的结果。

现在这一切都很好，很明显，我们需要的是 4 个像上面这样的神奇数字来帮助解决这个问题。现在，我们如何得到这些数字？如果我们只是随机挑选呢？效果如何？让我们找出答案，并开始挖掘代码！

启动你的编辑器！

让我们在 repl.it 上打开一个 Python 实例。它允许您快速调用大量不同编程环境的云实例，并在一个强大的云 IDE 中编辑代码，该 IDE 在任何地方都可以访问！

安装软件包

我们将从安装这个项目所需的两个包开始:numpy 帮助进行数值计算，OpenAI Gym 作为我们代理的模拟器。

只需在编辑器左侧的包搜索工具中键入gym和numpy，然后单击加号按钮安装包。

奠定基础

让我们首先将刚刚安装的两个依赖项导入到我们的main.py脚本中，并设置一个新的健身房环境:

接下来，我们将定义一个名为“play”的函数，它将被给予一个环境和一个策略数组，并将在该环境中播放该策略数组并返回分数，以及在每个时间步长的游戏快照(观察)。我们将使用分数来告诉我们该策略的执行情况，并使用快照来观察该策略在单个游戏中的表现。这样我们可以测试不同的政策，看看他们在游戏中表现如何！

让我们从函数定义开始，并将游戏重置为开始状态。

接下来，我们将初始化一些变量来跟踪游戏是否已经结束，策略的总得分，以及游戏过程中每一步的快照(观察)。

现在我们将简单地玩游戏很多时间步骤，直到健身房告诉我们游戏结束。

上面的大部分代码主要只是在玩游戏和记录结果。我们政策的实际代码只有这两行:

我们在这里做的只是策略数组和状态(观察)数组之间的点积运算，就像我们在前面的具体例子中展示的那样。然后我们根据结果是积极的还是消极的来选择 1 或 0(左或右)的行动。

到目前为止我们的main.py应该是这样的:

现在我们要开始玩一些游戏，找到我们的最优策略！

玩第一个游戏

现在我们有一个函数来玩这个游戏，并告诉我们的策略有多好，我们将希望开始生成一些策略，并看看它们做得有多好。

如果我们一开始只是尝试插入一些随机策略会怎么样？我们能走多远？让我们使用numpy来生成我们的策略，这是一个 4 元素数组或 1x4 矩阵。它将在 0 和 1 之间选择 4 个数字作为我们的策略。

有了这个策略，以及我们在上面创建的环境，我们可以让他们参与进来并获得分数。

只需点击 run 来运行我们的脚本。它应该输出我们的策略得到的分数。

这个游戏的最高分数是 500，很有可能你的政策并不顺利。如果你的有，恭喜你！今天一定是你的幸运日！虽然仅仅看到一个数字并不是很有价值，但是如果我们能想象我们的代理如何玩游戏，那就太好了，下一步我们将设置它！

监视我们的特工

为了观察我们的代理，我们将使用 Flask 来设置一个轻量级服务器，这样我们就可以在浏览器中看到代理的表现。Flask 是一个轻量级的 Python HTTP 服务器框架，可以服务于我们的 HTML UI 和数据。我将保持这一部分的简短，因为渲染和 HTTP 服务器背后的细节对于培训我们的代理并不重要。

我们首先要将Flask安装成一个 Python 包，就像我们在前面几节中安装gym和numpy一样。

接下来，在脚本的底部，我们将创建一个 flask 服务器。它将在/data端点上公开游戏的每一帧记录，并在/上托管 UI。

此外，我们需要添加两个文件。一个是项目的空白 Python 文件。这是 repl.it 如何检测 repl 是处于评估模式还是项目模式的技术问题。只需使用“新建文件”按钮添加一个空白 Python 脚本。

之后，我们还想创建一个index.html来托管渲染 UI。这里就不深究细节了，只是简单的把这个index.html上传到你的 repl.it 项目。

您现在应该有一个如下所示的项目目录:

现在有了这两个新文件，当我们运行 repl 时，它应该也能回放我们的策略是如何执行的。有了这些，让我们试着找到一个最优策略！

策略搜索

在第一遍中，我们简单地随机选择了一个策略，但是如果我们选择了几个策略，并且只保留了做得最好的一个，那会怎么样呢？

让我们回到播放策略的那一部分，我们不只是生成一个策略，而是编写一个循环来生成几个策略，并跟踪每个策略的表现，只保存最佳策略。

我们将首先创建一个名为max的元组，它将存储目前为止我们看到的最佳策略的分数、观察值和策略数组。

接下来，我们将生成并评估 10 个策略，并将最佳策略保存在 max 中。

我们还必须告诉我们的/data端点返回最佳策略的回放。

此端点:

应改为:

你的 main.py 看起来应该类似于 this now :

如果我们现在运行 repl，我们应该得到 500 的最高分，如果不是，尝试再运行一次 repl！我们也可以看到政策平衡的极点完美无缺！哇，太简单了！

没那么快

也可能不是。在第一部分中，我们在几个方面做了些手脚。首先，我们只在 0 到 1 的范围内随机创建策略数组。这只是发生了工作，但是如果我们把大于操作符反过来，我们会看到代理将会灾难性地失败。要亲自尝试，请将action = 1 if outcome > 0 else 0更改为action = 1 if outcome < 0 else 0。

这似乎不太可靠，因为如果我们只是碰巧选择了*于而不是大于，我们就永远找不到可以解决这个游戏的策略。为了缓解这种情况，我们实际上也应该生成带有负数的策略。这将使找到一个好的政策变得更加困难(因为许多负面的政策都不是好的)，但是我们不再通过将我们的特定算法适用于这个特定的游戏来“作弊”。如果我们试图在 OpenAI 健身房的其他环境中这样做，我们的算法肯定会失败。

为了做到这一点，而不是有policy = np.random.rand(1,4)，我们将改变为policy = np.random.rand(1,4) - 0.5。这样，我们策略中的每个数字将介于-0.5 和 0.5 之间，而不是 0 到 1。但是因为这更困难，我们还想搜索更多的策略。在上面的 for 循环中，我们不遍历 10 个策略，而是通过将代码改为for _ in range(100):来尝试 100 个策略。我也鼓励你先尝试遍历 10 个策略，看看现在用负数得到好的策略有多难。

现在我们的 main.py 应该看起来像这样:

如果你现在运行 repl，不管我们使用的是大于还是*于，我们仍然可以为游戏找到一个好的策略。

没那么快 Pt。2

但是等等，还有呢！即使我们的政策可能能够在一次运行中达到最高 500 分，它能每次都做到吗？当我们生成了 100 个策略，并选择在单次运行中表现最好的策略时，该策略可能只是非常幸运，也可能是非常糟糕的策略，只是碰巧表现非常好。这是因为游戏本身具有随机性(每次的起始位置都不同)，所以一项政策可能只在一个起始位置有效，而在其他位置无效。

因此，为了解决这个问题，我们需要评估一项政策在多次试验中的表现。现在，让我们采用之前发现的最佳策略，看看它在 100 次试验中表现如何。

在这里，我们玩 100 次最佳策略(max的索引 2)，并记录每次的分数。然后，我们使用numpy计算平均分数，并将其打印到我们的终端。“已解决”没有明确的定义，但应该只比 500 差几分。你可能会注意到，有时候最好的政策实际上可能是不合格的。但是，我将把修复工作留给您来决定！

完成=真

祝贺你！🎉我们已经成功地创造了一个人工智能，可以非常有效地解决 cart pole，而且相当高效。现在有很大的改进空间，这将是后续系列文章的一部分。有些事情我们可以深入调查:

• 找到一个“真正的”最优策略(将在 100 个单独的行动中表现良好)
• 优化我们必须搜索以找到最佳策略的次数(“样本效率”)
• 对保单进行适当的搜索，而不是随意挑选。
• 解决其他环境。

如果您有兴趣在您的下一个项目中使用预训练模型和开箱即用的工作代码来尝试更多的 ML，请查看 ModelDepot ！

从零开始:贝叶斯推理，马尔可夫链蒙特卡罗和大都会黑斯廷斯，用 python 编写

原文：https://towardsdatascience.com/from-scratch-bayesian-inference-markov-chain-monte-carlo-and-metropolis-hastings-in-python-ef21a29e25a?source=collection_archive---------0-----------------------

Credit: Adi coco unsplash

你好，欢迎阅读“从零开始”系列的第一篇文章，在这里我解释并实现/构建任何从零开始的东西。

我为什么要这么做？因为在目前的情况下，我们拥有如此强大的库和工具，可以为我们做很多工作。大多数有经验的作者都很清楚实现这些工具的复杂性。因此，他们利用它们为来自不同背景的用户提供简短、易懂和切题的阅读。在我阅读的许多文章中，我无法理解这个或那个算法在实践中是如何实现的。它们的局限性是什么？为什么要发明它们？什么时候应该使用它们？

正如希拉里·梅森所说:

“当你想使用一种你并不深刻理解的新算法时，最好的方法是自己实现它，以了解它是如何工作的，然后使用一个库来受益于健壮的代码。”

这就是为什么，我提议从零开始解释和实现:贝叶斯推理(有点简略)，马尔可夫链蒙特卡罗和 Metropolis Hastings，用 Python。

笔记本和 pdf 版本可以在我的知识库中找到: joseph94m

先决条件:基本概率、微积分、Python。

1-简介

在我的许多阅读中，我遇到了一种叫做马尔可夫链蒙特卡罗的技术，或者更通常的说法，MCMC。对这种方法的描述大致如下:MCMC 是一类从概率分布中取样的技术，可用于估计给定一组观察值的参数分布。

当时，我并没有多想。我想，“哦，这只是另一种采样技术”，我决定在我实际需要的时候读读它。这种需要从未出现过，或者它出现了，而我错误地使用了其他东西来解决我的问题。

1.1-那么为什么现在有兴趣呢？

最近，我看到了一些关于 MCMC 及其一些实现的讨论，特别是 Metropolis-Hastings 算法和 PyMC3 库。Markov Chain Monte Carlo in Python 一个完整的现实世界实现，是最吸引我注意的文章。在这篇文章中，William Koehrsen 解释了他是如何通过将该方法应用于现实世界的问题来学习该方法的:估计代表其睡眠模式的逻辑函数的参数。

The assumed model

Koehrsen 先生使用 Metropolis-Hastings 算法的 PyMC3 实现来计算α和β的分布空间，从而推导出最可能的逻辑模型。

1.2-那我为什么要说这些呢？

在本文中，我打算从头实现 Metropolis-Hastings 算法，为一个虚拟数据示例和一个真实世界的问题寻找参数分布。

我想如果我把手弄脏了，我也许最终能理解它。我只会用 numpy 来实现算法，用 matplotlib 来画漂亮的东西。或者，scipy 可以用来计算密度函数(我将在后面讨论)，但我也将展示如何使用 numpy 实现它们。

1.3-文章的流程

在第 1 部分，我将介绍贝叶斯推理，MCMC-MH 及其数学组成部分。在第 2 部分中，我将解释使用虚拟数据的 MH 算法。最后，第 3 部分将提供 MCMC-MH 的一个实际应用。

第 1 部分:贝叶斯推理，马尔可夫链蒙特卡罗，和大都会黑斯廷斯

2.1-概率哲学的鸟瞰图

为了讨论贝叶斯推理和 MCMC，我将首先解释什么是概率的贝叶斯观点，并把它放在它的历史背景中。

2.1.1-频率主义者 vs 贝叶斯思*

概率有两种主要的解释:贝叶斯和频率主义者。

从频率主义者的角度来看，概率代表事件发生的长期频率。一个频繁投资者可以说，从长远来看，掷硬币得到反面的概率等于 0.5。每一个新的实验，都可以被认为是同一实验的无限可能重复序列中的一个。主要观点是，不相信一个频繁主义者的概率观点。事件 x 在 n 次试验中发生的概率大致如下:

并且当 n — > ∞时达到真概率。常客永远不会说“我 45%(0.45%)确定今天午餐有千层面”，因为从长远来看这不会发生。通常，频率主义方法被称为目标方法，因为其中没有信念和/或先前事件的表达。

另一方面，在贝叶斯思*中，概率被视为信念的表达。因此，贝叶斯理论完全有理由说“我 50%(0.5%)确定今天午餐有千层面”。通过结合先验信念和当前事件证据，人们可以计算出后验，即今天有千层面的概率。贝叶斯思*背后的想法是，随着更多证据的提供，不断更新信念。因为这种方法处理的是信念，所以它通常被称为关于概率的主观观点。

2.1.2-贝叶斯推理

在决策哲学中，贝叶斯推理与贝叶斯概率观密切相关，它操纵先验、证据和可能性来计算后验。给定某个事件 B，事件 A 发生的概率是多少？这可以用贝叶斯的著名公式来回答:

使用:

在我们的例子中，我们最感兴趣的是贝叶斯公式的具体表述:

也就是说，我们希望找到θ的最可能分布，即解释数据的模型参数 d。

A supposed portrait of Thomas Bayes, an English statistician, philosopher, and theologian. Image Credit: Wikipedia Commons

计算这些概率中的一些可能是乏味的，尤其是证据 P(D)。此外，还会出现其他问题，比如确保共轭的问题，我不会在本文中深入探讨。幸运的是，一些技术，即 MCMC，允许我们从后验样本中进行采样，并绘制参数分布，而不必担心计算证据，也不必担心共轭性。

2.1.3-马尔可夫链蒙特卡罗

MCMC 允许我们从分布中抽取样本，即使我们不能计算它。它可用于从参数的后验分布(我们希望知道的)中取样。它已经在许多应用中取得了成功，例如在给定一组观测值和一些先验信念的情况下计算参数的分布，以及在物理和数字通信中计算高*积分。

底线:它可以用来计算给定一组观察值和先验信念的参数分布。

2.1.4-大都会-黑斯廷斯

MCMC 是一类方法。Metropolis-Hastings 是 MCMC 的具体实现。与吉布斯采样和拒绝采样相反，它在高*空间中工作得很好。

这项技术需要一个简单的分布，称为建议分布(我喜欢称之为转移模型)Q(θ′/θ)，以帮助从一个棘手的后验分布 P(θ=θ/D)中抽取样本。

Metropolis-Hastings 使用 Q 在分布空间中随机行走，根据样本的可能性接受或拒绝跳转到新位置。这种“无记忆”随机游走是 MCMC 的“马尔可夫链”部分。

每个新样本的“可能性”由函数 f 决定。这就是为什么 f 必须与我们要采样的后验概率成正比。 f 通常被选择为表达该比例的概率密度函数。

要获得参数的新位置，只需取我们当前的θ，并提出一个新的θ’，这是从 Q(θ’/θ)中抽取的随机样本。通常这是一种对称分布。例如，具有平均值θ和一些标准偏差σ的正态分布:Q(θ′/θ)= N(θ，σ)

为了决定是否接受或拒绝θ’，必须为每个新提出的θ’计算以下比率:

使用贝叶斯公式，这可以很容易地重新制定为:

The evidence P(D) is simply crossed out during the division

这也相当于:

Where f is the proportional function mentioned previously.

接受的规则可以表述为:

Note: The prior components are often crossed if there is no preference or restrictions on the parameters.

这意味着如果一个θ'比当前的θ更有可能，那么我们总是接受θ'。如果它比当前的θ更不可能，那么我们可能接受它或以递减的概率随机拒绝它，可能性越*。

简而言之，Metropolis-Hastings 算法执行以下操作:

Metropolis-Hastings algorithm

第 2 部分:虚拟数据示例

3.1-步骤 1:数据生成

我们从均值μ= 10、标准差σ= 3 的正态分布中生成 30，000 个样本，但我们只能从中观察到 1000 个随机样本。

3.2-第二步:我们想要什么？

我们希望使用 1000 个观察样本找到σ{观察值}的分布。你们当中那些狂热的数学家会说，有一个计算σ的公式:

为什么我们要取样什么的？这只是一个虚拟数据的例子，真正的问题在第 3 部分，这里很难直接计算参数。另外，在这里，我们不是试图找到σ的值，而是试图计算σ的概率分布。

3.3-步骤 3:定义 PDF 和过渡模型

从图 1 中，我们可以看到数据是正态分布的。通过取 1000 个样本值的平均值，可以很容易地计算出平均值。通过这样做，我们得到μ{observed} = 9.8(尽管附带说明，我们也可以假设μ未知，并对其进行采样，就像我们对σ进行采样一样。然而，我想让这个开始的例子简单一些。)

3.3.1-对于过渡模型/方案分配

我心中没有具体的分布，所以我会选择一个简单的:正态分布！

注意σ′与σ{new}和σ{current}无关。它只是指定了参数空间的标准偏差。它可以是任何需要的值。影响算法的收敛时间和样本之间的相关性，我后面会讲到。

3.3.2-用于 PDF

由于 f 应该与后验、成正比，我们选择 f 为下面的概率密度函数(PDF)，对于数据集 D 中的每个数据点 di:

Since μ is constant, we can practically consider that σ is equivalent to θ

3.4-步骤 4:定义我们何时接受或拒绝σ

3.4.1-验收公式

如果这个比值不大于 1，那么我们将其与闭集[0，1]中的一个均匀生成的随机数进行比较。如果比值大于随机数，我们接受σ{new}，否则拒绝。这确保了即使一个样本比当前的可能性*，我们可能仍然想要尝试它。(类似于模拟退火的概念)

3.4.2-可能性

一组观察值 D 的总可能性是:

This must be computed for both new and current sigma in order to compute the ratio in equation (1)

3.4.3-先验 P( μ，σ)

对于σ{new}和σ{current}可以采用的值，我们没有任何偏好。唯一值得注意的是，它们应该是积极的。为什么？直观地说，标准差衡量的是离差。离差是一个距离，距离不能是负数。

数学上:

而且一个数的平方根不能是负的，所以σ总是正的。我们在事前严格执行这一点。

3.4.4-最终验收表

在我们的例子中，我们将记录先验和似然函数。为什么要日志？仅仅是因为它有助于数值的稳定性，即乘以数千个*值(概率、可能性等..)会导致系统内存下溢，log 是一个完美的解决方案，因为它将乘法转换为加法，并将*正数转换为非*负数。

我们从等式(1)得到的接受条件变为:

这种形式可以通过从对数中取出平方根和乘法来进一步简化，但是不要介意，现在已经有足够的数学了！

3.4.5-那次咆哮的实施

实现很简单，对吧？！

3.6-步骤 6:使用初始参数运行算法，并收集接受和拒绝的样本

该算法接受 8317 个样本(每次新运行时可能会有所不同)。最后 10 个样本包含以下σ值:

[2.87920187, 3.10388928, 2.94469786, 3.04094103, 2.95522153, 3.09328088, 3.07361275, 3.08588388, 3.12881964, 3.03651136]

让我们看看算法是如何得出这些值的:

因此，从 0.1 的初始σ开始，算法很快收敛到预期值 3。也就是说，这只是 1D 空间中的采样…所以这并不奇怪。

尽管如此，我们仍将σ值的最初 25%视为“老化”,因此我们放弃它们。

3.6.2-让我们可视化 σ 的轨迹和轨迹的直方图

σ最可能的值约为 3.1。这比原始值 3.0 多了一点点。这种差异是由于我们只观察到原始人群的 3.33%(30，000 人中的 1，000 人)

3.6.3-预测:我们的模型在预测最初的 30，000 人口时表现如何？

首先，我们对σ的最后 75%的接受样本进行平均，我们从正态分布中生成 30，000 个随机个体，μ=9.8，σ=3.05(最后 75%的接受样本的平均值)，这实际上比最可能的值 3.1 更好。

瞧:

现在，进入正题！

4-第 3 部分:真实世界的例子

Sunspots. Credit Wikipedia commons

太阳黑子是太阳表面(光球)的一个区域，其特征是温度低于其周围环境。这些降低的温度是由磁场通量的集中引起的，它通过类似于涡流制动器的效应抑制对流。太阳黑子通常成对出现，磁极相反。它们的数量根据大约 11 年的太阳周期而变化。

我们将研究的数据是“月平均太阳黑子总数”，从 1749 年 1 月到 2018 年 11 月的每个月。这些数据由世界数据中心收集、整理并公开发布，用于制作、保存和传播国际太阳黑子数。

4.1-让我们绘制这些年的数据，看看分布情况可能是什么样的

4.2-似乎我们可以用伽马分布来模拟这种现象，每 12 年有一个新的周期重置

γ分布γ是一族双参数的连续概率分布。参数是形状 A 和尺度 b。一个伽马分布的随机变量 X 记为 X ~γ(A，b)，在我们的例子中，X 是太阳黑子的数量。两个参数 a 和 b 是我们想要计算其分布的未知数。

Gamma function with different parameters. Credit: Wikipedia Commons

例如，在第一个周期中，太阳黑子数从 1749 年底的 300 个左右的最高值开始，并在 6 年后的 1755 年下降到最低值。然后这个数字在 1761 年和 1762 年再次上升到最大值，然后在 1766 年再次下降，以此类推。。。

让我们通过绘制太阳黑子数直方图来确定:

4.3-事实上，计数频率似乎确实遵循伽马分布

对于 PDF，f，γ分布为:

其中γ是γ函数:γ(a)=(a-1)！(不要与伽马分布混淆！)

按照与虚拟数据示例中相同的过程，我们可以从这个 pdf 中写下对数似然性(参见下面的代码)。或者，可以使用 scipy.stats.gamma，b)。pdf(x)函数来计算它。但是，请注意，scipy 的实现比我实现的要慢几个数量级。

因为 a 和 b 必须是严格正的，所以我们在前面的例子中强制这样做:

运行代码并收集样本:

从 a=4 和 b =10 开始，该算法接受了 8561 对样本，a 的最后一个值是 0.98848982，b 的最后一个值是 84.99360422，这与初始值相差甚远。

与虚拟数据示例一样，让我们看看算法是如何得出这些值的:

从图 10、11 和 12 可以看出，该算法很快收敛到[a=1，b=85]区域。

提示:当算法开始大量拒绝样本时，这意味着我们已经达到了可能性的饱和区。通常，这可以被解释为已经达到了我们可以从中采样的最佳参数空间，即，算法几乎没有理由接受新值。这在图 11 和 12 中有所标记，其中算法不再接受*范围之外的任何值。

4.3.1-我们认为 a 和 b 值的最初 50%是“老化”,所以我们放弃它们。让我们来看一下 b 和 b 的轨迹以及轨迹的直方图。

4.4-预测时间

首先，我们对 a 和 b 的最后 50%的接受样本进行平均，并从γ分布中生成随机个体。a{average}=0.9866200759935773，b { average } = 83.70749712447888。

预测是:

4-评估

4.1-建议书分发的评估

我们如何指定分布 Q 的参数？我们应该远离当前样本θ，还是保持相对接近？这些问题可以通过测量接受样本之间的自相关来回答。我们不希望遥远的样本过于相关，因为我们正在尝试实现马尔可夫链，即样本应仅依赖于其先前的样本，自相关图应显示样本 I 和 i-1、i-2、…i-k 之间的相关性快速呈指数下降

通过为每个滞后 k 计算以下函数来定义自相关:

The lag 𝑘, is basically the range ahead of sample 𝑌i in which we would like to measure the correlation.

下图显示了从 1 到 100 的 a、b 和 k 的自相关性。k=0 的滞后意味着我们正在测量样本与其自身的相关性，因此我们期望它等于 1。k 值越高，相关性应该越低。

在我们的例子中，我们很幸运有足够低的相关性。一般来说，我们可能希望自动设置建议分布的参数 Q。常见的方法是不断调整提案参数，使 50%以上的提案被拒绝。或者，可以使用增强版的 MCMC，称为哈密顿蒙特卡罗，它减少了连续采样状态之间的相关性，并更快地达到稳定分布。

6-结论

虽然这种算法背后的抽象可能看起来难以理解，但实现实际上非常简单，并给出了令人惊叹的结果。事实上，概率编程的伟大之处在于，你只需要写下模型，然后运行它。不需要计算证据，或者确保一些约束性的数学属性。

我希望阅读这篇文章的每个人都觉得它很有趣，很有见地。如果有积极的反馈，将会有更多本系列的文章“从零开始”，在那里我从零开始解释和实现东西(显然！)，所以如果你喜欢的话，请一定要建议你接下来想让我讲的内容！

欢迎任何问题，我会尽我所能回答！反馈是非常受欢迎的，因为这是我的第一篇文章，我希望改进。

参考资料:

Peter Driscoll，“径向速度数据集的最*二乘法和贝叶斯拟合技术的比较”

Carson Chow，“MCMC 和数据拟合模型”

约翰·h·威廉姆森，“数据基础——概率”

西蒙·罗杰斯，“机器学习的第一课”

致谢:

另一位媒体作家， Vera Chernova ，写了一篇文章:“如何通过三个步骤将 Jupyter 笔记本嵌入媒体文章:1–2–3！”

朋友和数据科学家同事马克·艾斯丘和康斯坦丁诺斯·约安*迪斯在本文发表前给予了反馈。

从拓扑数据分析到深度学习:不劳无获

原文：https://towardsdatascience.com/from-tda-to-dl-d06f234f51d?source=collection_archive---------2-----------------------

Source

今天，我将尝试给出一些关于 TDA(用于拓扑数据分析)的见解，这是一个快速发展的数学领域，肯定会很快完全集成到机器/深度学习框架中。为了说明这一理论的威力，本文后面将给出一些用例。

快速历史

拓扑数据分析，也缩写为 TDA ，是从应用拓扑学和计算几何的各种著作中出现的一个新领域。它的目的是提供良好的数学，统计和算法的方法来利用数据中的拓扑和潜在的几何结构。你通常会发现它适用于三*数据，但经验表明，TDA 揭示了在其他情况下也很有用，如时间序列。

Example of Mapper construction based on the height function

拓扑学定义的理论多种多样，在机器学习或者深度学习中的影响力也在不断增长。那些曾经对那些能够带来关于数据的意想不到的见解的开箱即用的理论感兴趣的人可能会对接下来的事情感兴趣！然而，关于这篇文章，我将把重点放在可视化的例子上，为了便于理解，我将自己限制在一*和二*空间。

持久性同源性

在流传最广的理论中，有持久性同源性。这是一种旨在计算不同空间分辨率下空间的拓扑特征的方法。通过构建，这些特征更有可能代表潜在空间的真实特征(而不是采样、噪声或特定参数选择的假象)，因为它们与数据点的空间关系有着内在联系。为了计算一个空间的持续同调，它必须首先被表示为一个嵌套的单纯复形(基本上是一个由一组点和它们的关系组成的图，又名二*空间中的线和三角形)。这个家族叫做过滤。一般来说，这种过滤的构造是基于距离函数的定义，其值用于索引族中的复合体。因此，这个距离的选择非常重要，并为那些对公制学习感兴趣的人提供了思考的食粮

Visual Construction of the Simplicial Complex

持久性同调理论允许我们用一个持久性 条形码或持久性 图唯一地表示一个过滤的单纯复形的持久性同调。条形码图用一条水平线表示每个持久性发生器，水平线从它出现的第一个过滤级别开始，到它消失的过滤级别结束，而持久性图用其 x 坐标出生时间和其 y 坐标死亡时间为每个发生器绘制一个点(下面给出了示例)。视觉上，在二*中，你独立地考虑每个点:你围绕那些点画一个半径递增的圆，直到你找到一些交点(出生时间)。你继续绘制，直到你覆盖了一些点，破坏了一些先前创建的结构(死亡时间)。您最终得到组件(出生和死亡日期)，这些组件通过那些持久性图和条形码来表示。

持久性图表

为了更好地形象化这个理论，让我们考虑一*时间序列的例子，记为 f 。我们想通过下面的规则来关注 f 的临界点:当引入一个新的组件时，我们说创建它的局部最*值代表该组件。当我们传递一个局部最大值并合并两个分量时，我们将最大值与代表这两个分量的两个局部最*值中较高的(较年轻的)值配对。另一个最*值现在是合并产生的组件的代表。当 x 和 y 通过这种方法配对时，我们定义这对的持久性为f(y)——f(x)。持久性在持久性图中通过将每一对映射到点( f(x)，f(y) )来表示，该点的坐标是相应的临界值，如下所示。

Value-Based Persistence of a 1D Signal

矢量化和表示法

太好了，但是下一步该怎么办呢？！？从持续图中提取的向量的不一致性问题是机器学习应用的真正缺点。为了在不深入研究新型神经网络的情况下解决这个问题，我们必须转换以前的持久性表示，以某种方式收集相同的信息，这可能是相当大的。对于机器学习来说，提取外围的持久点可以表示很好的特征，但是图表中包含的一些底层信息可能会在这个过程中丢失。

在这里，我将强调三种可能性:贝蒂曲线、T2 持续景观和 T4 持续图像。(整个计算都要归功于 Gudhi 包，它是由法国团队 DataShape 为 INRIA 开发的。)以下结构即将成为 scikit-learn 兼容产品。同时，我向你推荐我对应的 Github 库的持久化构造，以及图表的表示。让我们通过下面的例子来想象一下。曾经梦想用算法计算你手上的手指数量的人会对即将到来的事情感到高兴…

TDA Representation of a 3D Object: Finger Characterization

我们从这个结果中得到什么。首先，您通过持久性图和条形码以图形方式观察到有 5 个突出显示的组件。不出所料，那是 5 根手指！然而，其中一个组件位于无穷大:这对应于在考虑过滤的上层时遇到的第一个点，自动给定一个无穷大的值。因此，你的持久性景观只清楚地代表了四个较*的手指。这是在应用 TDA 时要记住的事情！

贝蒂曲线:让我们考虑一个持久性条形码，我们对其半径空间进行矢量化。条形码图的每个组成部分都被称为一个函数，在定义它的半径上取值为 1，在其他任何地方取值为 0。这些函数的总和定义了贝蒂曲线。

暂留景观:暂留图的每个组成部分都由一个三角函数引用(斜率为 1)。这些三角形函数的叠加给出了不同平面上的山脉的外观结构，我们迭代地从中提取上层景观。

余辉图像:余辉图的每个分量成为特定方差的二*高斯分布的中心。通过创建相应的分布叠加矩阵，就获得了图像。

人们应该注意到下面这一点:即使手指的数量清楚地出现(对应于远离对角线的点)，仍然存在拓扑噪声的概念(靠近对角线的点)。因此，持久性景观通常更好使用，因为它们或多或少对它保持健壮，因为它们更好地描述了数据集的大多数持久性对象。然而，拓扑噪声有时是有用的信息，特别是在处理标准偏差对分类非常重要的时间序列时…

深度学习管道

一旦您为所有的示例构建了相应的持久性表示，您可能想知道如何使用它。贝蒂曲线有点容易馈入一个 1D 卷积网络，而持续图像适合一个 2D 卷积网络。

关于持久性景观，它变得有点棘手。对于那些想知道如何充分利用它而不手工制作自己的功能的人，这里有一个我构建的解决方案。基本上是联系到持久性剪影的思想，是从持久性图中得到的三角函数的加权和。新创建的层对应于这些持续景观的加权和，得到持续轮廓的移动平均结构作为输出。输出是一个一*信号，你可以把它输入一个 1D 卷积网络。我会在接下来的工作中进一步发展这个想法！😃

Credits: Gaijin et al.

这个理论有很多可能性，这些结果和深度学习之间的接口目前仍在开发中。许多想法将会出现，这使得这个话题变得非常热门和有趣！敬请关注即将到来的文章，如果你想了解更多，别忘了给你鼓掌；)！

参考

• 我的 GitHub 资源库
• 持续理论:从颤动表象到数据分析 是
• 谷棣项目
• 同调与拓扑持续
• 几何和拓扑推论

从失败的通过到通过的仪式:作为数据科学教育工具的泰坦*克号数据集

原文：https://towardsdatascience.com/from-tragedy-to-educational-tool-the-titanic-data-set-at-a-data-science-rite-of-passage-91e95f336af8?source=collection_archive---------8-----------------------

皇家邮轮泰坦*克号的沉没是现代史上最著名的悲剧之一。它在历史上作为一个值得注意的事件的地位在很大程度上是由于它在 1997 年被重新改编成电影，其中泰坦*克号既作为背景又作为电影名称。当泰坦*克号的故事创下纪录时，它成为了一个标志性的悲剧，成为了第一部票房超过 10 亿美元的电影，并一直保持这一头衔，直到 2010 年《阿凡达》上映。很明显泰坦*克号的沉没在一般社会中是受欢迎的；几家公司已经宣布，他们将开始以 105，129 美元的价格为客户提供泰坦*克号残骸的水下潜水之旅，这些公司表示，这个数字相当于经通胀调整后泰坦*克号头等舱机票的价格。它在数据科学社区中的流行是因为它是一种有用的教育工具；泰坦*克号悲惨航行的数据为数据科学学生提供了许多教育可能性。

The Titanic at Southampton, England, one of the ports where it picked up passengers before it began its trip across the Atlantic.

使用 Titanic 数据集—本质上是一个逗号分隔的值(。csv)文件复制了船上的乘客声明——在现代数据科学世界中，这已经成为某种仪式。该数据集提供了大量实践各种基础数据科学技能的机会。一个已经变得流行的可能的学习练习，尽管它也是一个有点病态的练习，是在表面水平上分析泰坦*克号数据集，这对数据科学学生和新手来说是完美的，以获得对乘客在哪个等级和他们生存可能性之间关系的见解。对数据集的分析进一步揭示了数据中的一种模式，这种模式对许多人来说可能是直观的，并且得到了数据集证据的支持，即乘客乘坐的舱位等级越低——头等舱、二等舱或三等舱——泰坦*克号沉没时，你生还的可能性就越*。

除了这个特定的数据集，专业的数据科学家可以被要求研究任何主题，无论是什么，都必须以数据为基础。作为一个人，你不会带着偏见或预先存在的假设行事，而只是作为数据的推动者，在数据集中分析和寻找模式，而不管你找到的模式可能是什么。有了这些无偏见地发现的模式，你和你的团队(如果合作的话)可以开始评估这些模式的意义。如上所述，Titanic 数据集在分析数据、识别数据中的模式以及评估数据中的模式的意义方面尤其丰富。仅此一点就能使泰坦*克号数据集成为一个强大的教育工具，但这并不是使用这个特殊数据集成为某种仪式的唯一原因。

泰坦*克号的原始数据更加混乱。这提供了一个练习清理数据集以便于分析的教育机会。然而，即使在混乱的状态下，泰坦*克号数据集在分析后仍然显示出无数的模式-使这个数据集成为崭露头角的数据科学家的完美缩影，以从多个角度练习他们使用数据集的基本技能。这反过来意味着有几个机会来练习评估数据模式，以最终回答他们想要回答的问题。正是这些可能的技能应用机会，以及前面提到的机会，将这个流行的数据集变成了一个无处不在的教育工具，这个领域的大多数人都遇到过，如果不是自己工作的话。

尚不清楚这种使用泰坦*克号数据集的趋势是何时开始的，但就在几年前，它的受欢迎程度甚至进一步上升。这是因为几年前，一家提供免费在线数据集的公司和网站 Kaggle 在 GitHub 上发布了一项比赛，要求数据科学家想出一种方法来预测泰坦*克号沉没时是否有任何随机乘客幸存或死亡。这可能始于一场 Kaggle 比赛，但它的普及程度甚至更远。一个简单的谷歌搜索显示了数百篇博客文章，所有技能水平的数据科学家在这些文章中解释了他们制定的预测方法。更多关于泰坦*克号数据集的不同可能研究问题的谷歌搜索返回了大量由数据科学家撰写的博客文章，这些文章讲述了他们的解释，并解释了他们在解决问题时使用的方法，他们开始在脑海中分析泰坦*克号数据集。

Courtesy of Stephen Millborrow

这艘“不沉之船”的沉没已经过去了 100 多年，泰坦*克号的故事通过电影被纪念也已经过去了 20 多年，但在数据科学领域，它的相关性是非常当前的。它的持续相关性依赖于数据集丰富的可能性，这为数据科学家提供了一次又一次练习技能的机会，无论他们的技能水平如何。因此，对于那些处于数据科学创新前沿的人来说，巨大的数据集仍然是一个受欢迎的教学和学习工具。它的受欢迎程度似乎不会很快改变。

来自《什么是 numpy？🤔到“我爱 numpy！💪🏼"

原文：https://towardsdatascience.com/from-what-is-numpy-to-i-love-numpy-a130285e333d?source=collection_archive---------2-----------------------

Numpy 或“数字 python”是用于科学计算的核心 Python 库，Numpy 也很快，因为它与 C 库绑定。

常规 python 列表与 Numpy 数组:

这种差异主要是由于“间接性”——Python 列表是指向 Python 对象的指针数组，每个指针至少有 4 个字节，即使是最*的 Python 对象也有 16 个字节(4 个用于类型指针，4 个用于引用计数，4 个用于值——内存分配器四舍五入到 16)。NumPy 数组是一个统一值的数组，单精度数字每个占用 4 个字节，双精度数字占用 8 个字节。不太灵活，但是您为标准 Python 列表的灵活性付出了很多！这就是 numpy 数组比 Python list 更紧凑的原因。

来源:😊

目录:

1. 装置
2. 基本数字阵列
3. 另一个很酷的内置方法

安装:👨🏼‍💻

有两种安装方式:使用 pip 或 anaconda。如果你没有安装 anaconda，我会使用 pip，但是我推荐使用 anaconda 🐍相反。

conda install numpy

或者

pip install numpy

基本 Numpy 数组:👓

Numpy 数组有两种不同的类型:vetrices 和 matrices。Vetrices 是严格的一*数组，而 Matrices 是二*的(注意:二*数组可以包含一行和一列)。在这一节中，我想介绍 Numpy 数组和几个函数的基本实现。

import numpy as np

这就是 numpy 显示二*数组的方式。在这种情况下，上面显示的二*数组的形状是(3，3)。3 个用于其行，3 个用于其列。

• shape: shape 是一个描述符，用于从给定的 np 数组中返回元组中的行数和列数。
• 整形:为你的 np 数组分配一个新形状的函数

注意:当你试图改变二*数组的形状时，请注意数组中有多少个元素。

举例:

当一个(3，3) 2d 数组总共有 9 个元素时，如果将其列整形为(3，5)或任何大于 3 的数，这是不可能的。但是在另一方面，仍然有可能重新成形为(9，1)，九行和一列。

numpy_array.reshape(3, 5)

会给你:

Traceback (most recent call last):
  File "practice_one_numpy.py", line 9, in <module>
    two_darray.reshape(3, 5)
ValueError: cannot reshape array of size 9 into shape (3,5)

内置方法🐍：

这里有几个很酷而且可能是有用的数字内置方法😉。

• arange:返回具有给定间隔的均匀分布的值
• 眼睛:创建一个单位矩阵
• random.rand:创建一个给定形状的从 0 到 1 的随机数数组。

如果您想了解更多关于 numpy 的信息，请查看此资源。🐍。谢谢你😁

前沿人工智能技术正以前所未有的方式影响着金融科技的业务运营！

原文：https://towardsdatascience.com/frontier-ai-technologies-that-are-impacting-fintech-business-operations-like-never-before-99737daf197f?source=collection_archive---------8-----------------------

金融公司在采用新技术和创新方面总是领先于其他公司！难怪这些了解未来的公司体验到了最好的人工智能——从欺诈检测到风险管理，甚至预测不良贷款。

这一部分的挑战也是独特的，变化正以极快的速度到来。他们面临着数据量、信息量、复杂性和碎片化的问题。即便如此，机器学习、自然语言处理、大数据和分析、数据挖掘、自动化和物联网(IoT)等人工智能技术正在取得重大成果。

以下是人工智能技术为金融科技创造前所未有的商业运营改进的主要领域。关注领先的新兴公司以及这些推动他们走向积极业务成果的强大技术是值得的。

1.欺诈检测:

欺诈检测可能是人工智能领域最大的一块。这也是最重要的，预计到 2020 年将成为 3B 的一个美元市场。

为了理解金融科技领域欺诈的含义，让我们考虑一个常见的例子。随着越来越多的人在日常交易中使用网上银行，他们将会创造成千上万的印象和数据点。通过几个设备和接触点，这些服务将被不断地访问。银行必须建立非凡的灵活性，及时快速地识别和定位可疑行为。

欺诈检测解决方案依靠大规模数据挖掘和数据分析技术来得出答案。该系统基于强大的神经网络算法，能够系统地处理相当大的数据集，同时识别和标记不一致。它们非常敏感，因此即使是微*的不一致和违规也能被准确地发现。

每笔交易都要扫描数千个数据点，模糊查找被用来“发现”相关的模式、异常和巧合；无论是对用户，还是对特定交易，甚至是对一段时间内发生的类似交易。与过去更加手动和耗时的方法相比，使用人工智能进行几微秒的欺诈检测是一个飞跃！

2.生物认证和令牌化:

认证和授权是我们这个高度数字化、基于知识的世界的重要方面。在这里，访问是由可验证的凭证定义的入口。

身份验证和授权之所以重要，是因为一旦提供了访问权限，就很大程度上无法收回。或者，一旦未经授权的访问被允许，就会产生灾难性的后果。

生物认证和令牌化使用人工智能技术来创建更强的系统。例如，利用语音识别和自然语言处理的设备通过其声纹来识别和授权人员。使用物联网并将使用心电图与智能系统集成的设备，其中两个系统相互通信并传递信息，唯一目的是识别某人。此外，与眼白中的静脉图案匹配的设备，或用于完美识别的“眼纹”。

令牌化也有几个用例，其中令牌被用作一种方便交易的手段。卡的详细信息、姓名和账号等敏感个人信息被分离出来，单独存储在另一个位置。在欺诈者破解这个令牌的情况下，他/她将无法使用它或识别信息所属的人。

3.自动化:

自动化在整个金融科技行业得到了广泛应用。当然，有几个明显的优势。但是，让组织能够应对不断增长的数据量的冲击是一个主要问题。

此外，还通过优化、改进客户服务等方式大幅降低了成本、减少了冗余、降低了风险、提高了预测能力、敏捷性和响应能力。

当自动化与机器学习和深度学习在预测分析和报告、营销和活动管理、语音识别和响应、数据输入、客户关系管理(CRM)以及机器人流程自动化(RPA)等功能中相结合时，优势会进一步扩大。

一家名为“WorkFusion”的公司正在彻底改变这一领域。与金融公司合作，提供人工智能支持的优势和双赢。例如，本案例研究描述了 WorkFusion SPA 如何通过 RPA、AI 和人员的独特组合，帮助 Six Financial 应对其不断增长的数据处理挑战。

4.区块链:

这项创新的新技术有潜力改变商业运作的方式。产生共享信任并确保数据完整性。从零售银行到保险和财富管理，甚至投资银行，各种规模和类型的金融服务机构都将从中受益。

关键在于这项技术是如何工作的——它从分布式基础设施开始，在这个基础设施中，关于交易的信息被安全地共享。然后，一个用户网络支持和验证每一个独特的交易，确认其准确性。在最后阶段，记录被透明地添加到每个人都可以访问的区块链中。

区块链不是天生的 AI 技术。但人工智能可以赋予它更多的力量。例如，在能源密集型的开采过程中，人工智能算法可以通过优化和平衡来降低消耗。联邦学习系统和数据分片技术可以提高效率，增强快速增长的区块链的可扩展性。区块链可以抵御黑客攻击，但是底层和应用程序更容易受到攻击。这可以通过机器学习来改变，人工智能算法可以帮助安全的应用程序部署。

这项技术用途广泛。它用于资产创建(例如，在加密货币的生成中)、资产转移(例如，在艺术品交易商和画廊多次买卖艺术品时保留记录)和数据核对(例如，钻石行业用于标记“血钻”或假货)。)

5.实时警报和通知:

随着规范分析的出现，分析系统可以规定未来的路径，世界不再停滞不前。我们在快速前进。

客户期望通过任何设备和渠道获得准确的实时警报和通知，这是目前行业的基准。很难想象今天的一笔交易会在月底才生成一份对账单。标准变化很快。

大数据挖掘、物联网、机器学习和更多这样的人工智能技术正在为更快、更敏捷的系统创造可能性。不断发展的组织正在利用这些优势！

推荐系统的前沿&多样性

原文：https://towardsdatascience.com/frontiers-of-recommendation-systems-diversity-f668adad502c?source=collection_archive---------5-----------------------

批判性阅读:来自 2011 年 ACM RecSys 和管理科学的论文

Alaska Frontiers. Photo Credit: US Dept of Interior

介绍

最近，我一直试图了解推荐系统如何影响用户体验的多样性。在我开始自己的项目之前，我想看看聪明人都做了些什么。因此，我阅读了来自 ACM RecSys 关于多样性的 2011 年研讨会的全部论文，以及来自管理科学的相关论文。这些论文的作者已经成为音乐流媒体行业的重要参与者。例如，奥斯卡·塞尔马目前担任潘多拉公司的研究主管。所以我非常兴奋地看到他们的研究如何塑造了他们的产品。

在这篇文章中，我想与你分享我的文献综述。我的目标是:

• 把所有的文件归档在一个统一的框架下；
• 为每篇论文创建一个摘要；
• 批判性地评估每篇论文。

放弃

1. 从 2011 年到现在已经 7 年了。那么，为什么我称这个推荐系统的前沿为&多样性呢？当然，从那时起，已经有一些关于这个主题的论文被发表了；但是 2011 年是 RecSys 最后一次举办关于推荐系统多样性的研讨会。我想阅读这些论文作为我的种子，在我的文献综述的下一个迭代中，我将从中扩展。
2. 我们大多数人认为文学评论是必要的罪恶。然而，随着时间的推移，我已经学会了接受这个过程。它让我接触到许多不同的观点，并帮助我形成一个鸟瞰图。这有两个好处:(1)我不重新发明轮子；(2)我能识别该领域的公开挑战，这有助于我成为更好的贡献者。
3. 本文假设读者已经熟悉基本的推荐算法。如果你是推荐系统的新手，Medium 上有一些写得很好的教程。我个人最喜欢的是 Kelly Peng 的 我是如何为香水——建立一个推荐系统的，这是一个非常棒的端到端项目，包括网络清理、直觉、代码和令人着迷的最终演示。

行动纲要

2011ACM rec sys论文多是关于推荐系统的设计。

• 优点:引入了许多不同的指标&算法，用于多样化的推荐。
• 缺点:在理解对用户体验的潜在影响时，常用的技术是交叉验证；精确度和召回率仍然是流行的指标。虽然这种方法通常用于信息检索文献，但它可能不适合推荐系统。一个新的推荐系统，一旦实现，改变的不仅仅是对个人用户的推荐。更重要的是，它改变了项目/用户网络的全局拓扑，这将馈入推荐系统。不幸的是，在 2011 年的 ACM RecSys 中，这个问题的动态性质很少受到关注。
• 值得注意的例外是 Oscar Celma 和 Perfecto Herrera 的论文。他们在 Last.fm 上实施了一项实验，使用了 233 名受试者。虽然这是正确的一步，但有限的受试者数量限制了他们研究动态、一般均衡效应的能力。

相比之下，管理科学论文关注消费者行为和福利分析。

• 优点:作者对消费者行为进行了建模，并通过模拟研究了他们的选择和效用如何受到常见推荐系统的影响。
• 缺点:我们不知道效用函数是否准确地描述了真实的顾客；如今企业实现的推荐算法可能更加复杂。

大多数论文提供了单一的视角。

我不怪他们。学术界奖励严谨——自然，一次对一件事严谨更容易。也就是说，我认为了解该领域的最佳方式是采取多视角、多学科的方法。这正是我希望在下一节中完成的。

假设空间

推荐会增加多样性吗？

• 【H1】建议增加多样性:与实体店不同，互联网有无限的货架空间。随着用户浏览数以百万计的商品，市场将从热门商品转向利基市场。
• 【H2】推荐减少多样性:尽管货架空间无限，但屏幕空间有限。如果推荐系统一直推荐高度相似的项目，它会降低感知的多样性。
• 【H3】推荐增加个体多样性；但是降低了总体的多样性:单个地，用户得到了大量不同项目的推荐。但是，如果每个人都被推荐了同一套不同的商品，就会降低对多样性的感知。

最后一点很抽象，所以让我给你举个例子:

• 网店之前:假设每个人只吃 1 种水果，因为他们当地的店都是这么卖的。爱丽丝吃苹果，鲍勃吃香蕉，凯特琳吃樱桃，迪伦吃苹果。当他们互相拜访时，他们会接触到新的水果。
• 网店消灭本地店铺后:RS 有可能只推荐(苹果、香蕉)给大家，因为这些是最受欢迎的商品。你期望人们更快乐，因为现在他们可以吃更多种类的水果。然而令人惊讶的是，他们可能仍然会抱怨多样性的减少。这是因为无论他们去哪里，他们都只能吃到东西(苹果、香蕉)——因为这种意外收获的美妙感觉现在已经消失了。

用户重视多样性吗？

• 【H6】熟悉感胜出:当我们听到一首新歌时，这是一种精神负担。所以大多数用户更愿意呆在他们的舒适区。
• 【H7】多样性胜:你对自己喜欢的歌，播放多次后，就厌倦了。这是边际收益递减的基本规律。
• 【H8】相关性+多样性:事实介于两者之间——用户只重视与他们“相关”的多样性。如何定义相关性？这似乎是一个悬而未决的问题，作者提出了许多不同的定义。

我的观察

• 最佳的 rs 设计取决于用户的偏好:如果用户重视熟悉度，那么推荐系统(RS)应该推荐相似的项目；如果用户看重多样性，那么 rs 应该推荐多样化的物品；如果用户只看重相关的多样性，那么 rs 应该推荐相关的、多样化的项目。如果不首先了解用户偏好，我们就不知道最佳 RS 应该是什么样子。
• 2011 年大部分论文潜水员不研究用户偏好。相反，他们对用户的偏好做出假设:他们是否关心多样性，如果是，以什么方式？我认为下一代报纸应该更加关注理解用户偏好。
• 变化是，用户是高度异质的: (1)一些用户可能喜欢呆在他们的舒适区内，而另一些用户更喜欢探索；(2)根据使用情况、一天中的时间、他们生活的时间、心情等，相同的用户可能想要熟悉的或陌生的。迄今为止，所提出的推荐算法都是“一刀切”的。这种部署很危险，因为在现实中，用户是高度多样化的，同一用户会随着时间的推移而变化。

一般性讨论到此结束。在接下来的部分中，我将深入研究每篇论文。

目录

潜水员 2011 年论文

• 主题演讲:推荐系统的新颖性和多样性研讨会，第五届 ACM 国际推荐系统会议。
• 最大化集合推荐多样性:一种图论方法
• ❤️论推荐系统中的意外:或者如何期待意外的❤️
• 一种评估新推荐的新方法
• 基于融合的提高意外收获率的推荐系统
• 遗忘问题:利用遗忘项提高推荐多样性
• 推荐收藏的框架
• ❤️帮助用户感知推荐多样性❤️

管理科学论文

• ❤️大片文化的兴衰:推荐系统对销售多样性的影响️️❤️个人最爱！如果您想偷窥，请滚动至底部:)

1.潜水员主题演讲

摘要

• 确定推荐系统的关键挑战是:增加新颖性和多样性，同时仍然实现用户兴趣的公平匹配。

商业正在以特殊的方式考虑新奇和多样性；而研究人员才刚刚开始“寻找在推荐模型、算法、理论和评估方法中加入新颖性和多样性的原则基础”。但仍有很大的空间进行进一步研究，这也是 2011 年潜水研讨会的动机。

• 关键问题: (1)如何衡量新颖性和多样性？(2)如何增强新颖性和多样性？(3)如何提高建议的新颖性和多样性？(4)如何评估推荐系统？

2 .最大化聚合推荐多样性:图论方法

摘要

• 回想一下，推荐是一个两阶段的过程: (1)预测评分；(2)选择前 N 个预测评级作为推荐。提高多样性可以通过(1)或(2)来实现。本文属于后一类。
• 本文的目标是增加总体多样性。聚合多样性，因为消费者重视多样性，而且许可不太受欢迎的商品更便宜。
• 将多样性最大化转化为最大流问题。具体来说，(1)有 2 组顶点:用户和项目；(2)如果我们向用户 u 推荐项目 I，那么有一个优势 iu；(3)优化目标是最大化用户-项目匹配的数量，服从容量约束。

数据

• 运动神经元
• 网飞 C 奖
• 我会非常担心选择偏差，以及基于这个样本的概括结论。作者将数据集局限于具有“显著”评级历史的用户和电影，而没有详细说明什么是显著的。修剪后，MovieLens 的数据留给他们(2830 名用户，1919 项)，网飞竞赛的数据留给他们(3333 名用户，2091 项)。与实际数据量相比，所选评估样本非常*！MovieLens 10M 数据集有(72，000 个用户，10，000 部电影)；MovieLens RecSys HetRec 2011 拥有(2，113 个用户，10197 部电影)；网飞竞赛数据有(48 万用户，17，000 项)。

韵律学

• 聚合多样性的度量是被推荐的项目总数。
• 成功度量:“给定精度水平下的分集增益”。

评论

• 这是长尾巴吗？提高 MovieLens 前 2K 电影和网飞前 2K 电影的覆盖率不是我对长尾的想法。我猜这些可能是我已经接触过的过去 10-20 年的顶级电影。我会很有兴趣看:(1)推荐电影列表；(2)在理想的实验中，该算法在多大程度上扩展到具有有限评级的更大数量的用户和项目。
• #物品并不能很好的衡量多样性。例如，如果你看了一个关于早上 5 点起床的视频，你得到了 10 个以上的推荐，你会认为这是一个多样化的推荐吗？大概不会。
• 它仍然严重依赖传统的协作过滤器来预测收视率。这是有问题的，原因有两个:(1)它不能预测新项目的评分；(2)对于探索型用户来说，这可能太保守了——你得到的推荐仅仅是与你最“相似”的用户的多样性；或者通常同时出现的项目。因此，如果你是一个刚刚开始形成自己身份的人，你可能会被归类；如果你对来自其他社会经济背景的人在做什么感到好奇，你将很难突破。

3.❤️论推荐系统中的不可预测性:或者如何预测不可预测的❤️

摘要

• 这是为数不多的模拟用户偏好的论文之一。本质上，所提出的算法所做的是剔除所有明显的推荐项目。
• 本文的一大贡献是作者对不同多样性度量的关注:新颖性定义为用户以前不知道的项目；意外之喜是一种既新奇又愉快的经历；多样性意味着物品种类的增加；意外是字面上意想不到的项目。
• 关于提议指标的关键观察:以上指标并不完全重叠。从他们的角度来看，好的推荐既出人意料，又能引发积极的情绪。我完全同意这个好的推荐系统的定义。
• 效用函数取决于:一个用户总体上喜欢电影的程度；用户对推荐电影的喜爱程度；用户对冗余和不相关的容忍度；用户是否期望推荐；最后，特质噪音。
• 经验挑战:衡量意外性和用户满意度。

韵律学

• 对于单个用户，unexpecteness =[RS \ E]/N，其中 RS 是我们的推荐系统生成的推荐项目；e 是由“原始”推荐系统生成的推荐项目(即，已经评级的项目、用户喜爱的类别、项目的评级数量、同一导演、同一组主角、共享超过 20 个标签等)。);n 是推荐项目的长度。
• 项目相似度度量: (1)对于协同过滤器:皮尔逊相关系数、余弦相似度、雅克卡系数；(2)对于基于内容的相似性，两部电影之间所有属性的加权平均值。

用户偏好参数

• 用户总体上喜欢电影的程度；
• 用户对冗余和不相关的容忍度是多少？

这两个参数是用回归法计算出来的。

数据

• RecSys HetRec 2011 年发布的 MovieLens 数据:(2，113 个用户，10197 部电影)

评估指标

• RMSE，平均绝对误差，精确度，召回率和假阳性率。

评论

• 这是我 2011 年最喜欢的论文 diveRecSys : 它仔细定义了不同的指标，并花了大量时间讨论用户偏好。
• 我希望看到用户偏好参数的分布。这将帮助我们了解用户是否有不同的偏好，如果有，主要的聚类是什么。
• 正如作者指出的，为了验证这个推荐的算法，我们需要进行真实的实验。单纯的交叉验证是不够的。具体来说，我认为使用这种方法得到的用户偏好参数可能过于保守。历史评级是通过 2 个步骤产生的:(1)用户通过网站推荐或其他渠道了解项目；(2)用户然后观看他们知道的项目，并对它们进行评级。我们知道(1)受到 CF 或 CB 的严重影响，因为大多数现有的网站已经运行这些算法。因此，我们可能会得出这样的结论:普通用户对冗余的容忍度比他们实际承受的要高。这是因为生气的用户会直接退出平台，或者花更少的时间或更少的电影评分。所有这些用户都不会在数据集中被捕获，我们只剩下对冗余有更高容忍度的用户。因此，将这个用户群的发现推广到普通人群是非常危险的。
• 我希望看到明确的长期动态模型。一旦部署，推荐算法将改变物品网络的拓扑结构和用户的相似性，从而引发难以在模拟中捕捉的反馈循环。

4.一种评价新颖推荐的新方法

摘要

• 提出一个基于网络的指标来衡量推荐的新颖性。表明协同过滤器是偏向流行的。具体来说，如果你只跟踪“相似艺术家”链接，从热门艺术家开始到达尾部艺术家的概率大约为 0。从尾部艺术家开始也没有帮助，因为知道一个尾部艺术家的用户通常也知道其他相关的尾部艺术家。从“中间”艺术家开始似乎更好:更容易同时接触到非常受欢迎的艺术家和尾部艺术家。
• 用户分析:对(288 个对象，5，573 首歌曲)实验表明，用户更喜欢由协作过滤器推荐的歌曲，而不是由基于内容的算法推荐的歌曲，即使基于社交的算法推荐的歌曲不那么新颖。

数据

• Last.fm 上 288 个受试者的实验数据

构建网络

• 每个节点都是一首歌。
• 如果 Last.fm 的 API 认为两个节点相似，则这两个节点之间存在链接。

基于网络的新颖性度量

一旦每个项目位于头部、中部或尾部，下一步就是将项目的相似性网络的属性与长尾信息相结合。执行两个主要分析。首先，我们测量曲线每个部分的项目关系。也就是说，对于属于头部的每个项目，计算位于头部、中部和尾部的相似项目的百分比(类似地，对于中部和尾部的项目也是如此)。这衡量最受欢迎的项目是否与其他受欢迎的项目相关联。其次，我们测量一个项目在长尾中的位置和它的入度之间的相关性。这使我们能够检测网络中的集线器是否是最受欢迎的项目。

实验

• 使用 CF、CB 或混合方法生成建议。
• 受试者是否知道推荐给他们的曲目，以及他们如何根据歌曲的前 30 秒在 1-5 的范围内对它们进行评分。

评论

• 我喜欢他们创建的 Markov 转移矩阵来表明 CF 是受欢迎程度有偏差的。
• 我也喜欢他们如何用实验来评估建议。
• 我们从实验中看到的矛盾的结论是，尽管存在受欢迎程度的偏差，CF 仍然优于 CB 和混合方法。我们是否应该得出结论，用户暗地里渴望熟悉感？我们应该断定基于 CF 的变体是解决方案吗？这些结论听起来还为时过早。本文中实现的 CB 和混合算法可能过于原始。我们不知道未来改进的 CB 或 HY 或其他算法是否会优于 CF。
• 基于原始数据，CF 推荐给用户的曲目有 71.69%的时间是未知的。这似乎是一个可观的数字，尽管我怀疑它夸大了 CF 的发现率。这是因为受试者只能看到音轨的前 30 秒，人们很难从前奏中分辨出一个艺术家/歌曲。

5.基于融合的推荐系统提高奇遇度

摘要

• “以融合为基础”是什么意思？假设你喜欢两样东西:苹果和橘子。这两样东西的共同特点是它们都是水果。所以基于此，我推断你喜欢水果，并可以向你推荐其他水果。
• 作者声称这种方法速度很快，并且可以生成“新颖”的项目。
• 我不相信:(1)如果我在吃苹果和橘子，很可能我已经知道其他水果。所以其他水果对我来说并不新奇；(2)我确信现有的 CB 和/或 CF 已经推荐了相同的项目。我很想知道这个基于融合的推荐系统的边际贡献是什么。

6.遗忘问题:利用遗忘项目提高推荐多样性

评论

• 遗忘物品并不新奇。
• 同样，你也不能通过挖掘被遗忘的物品来提高推荐多样性。它已经包含在现有的多样性措施中。

7.推荐收藏的框架

摘要

• 本文是关于生成播放列表的公式化问题。
• 它强调了语境的重要性。
• 目前，它与推荐多样性没有直接关系。所以我暂时跳过。

8.❤️帮助用户感知推荐多样性❤️

摘要

• 用户感知的多样性！=客观多样性。好的 UI 有助于用户更好地感知推荐多样性。

实验

• 样本量: 20 人
• 方法:受试者内实验。每个用户都有两个用户界面。在这两个 ui 之间，推荐项目保持不变，但组织方式不同。第一 UI 具有列表格式；而第二个用户界面是按类别分类的，带有帮助用户理解类别的编辑注释。
• 结果:用户对第二代用户界面更加满意。他们还认为第二个用户界面推荐了更多样化的项目集合——即使两个用户界面推荐了相同的项目集合。

评论

• 我很喜欢这篇论文的主题。很有新意。
• 也就是说，样本量太*了。同样值得注意的是，在 20 名参与者中，有 10 名是中国人，据报道他们的职业是学生、研究助理、工程师和界面设计师。鉴于参与者和本文作者之间的共同国籍和职业，我不能排除这些是作者的朋友同事的可能性，他们听说过实验的设计/实施。毕竟，这篇论文是在瑞典写的，令人惊讶的是大多数实验对象都不是瑞士人。

❤️ 9.百视达文化的下一个兴衰:推荐系统对销售多样性的影响️️(2009)❤️

摘要

• 研究问题:推荐者是否有可能增加个体多样性，但降低总体多样性？
• 方法论:建立理论模型+模拟

公制的

• 多样性是用基*系数来衡量的。

假设

• 每个用户一次购买 1 件产品
• 只有两种产品，在没有推荐的情况下，购买概率为(p，1-p)。
• 当公司推荐一种产品时，它被接受的概率为 r。
• 该公司的推荐系统是使用历史市场份额生成的。为简单起见，当市场份额≥0.5 时，推荐者会推荐该产品。

消费者偏好

• 每个消费者被表示为 2D 属性空间中的一个点。
• P【消费者 c 对产品 P 的认知】是产品到消费者的距离、产品的受欢迎程度以及消费者对受欢迎或类似物品的认知如何随距离衰减的函数。
• P[消费者 c 购买产品 p]= P[消费者 c 购买产品 p | c 知晓产品 P] P[消费者 c 知晓产品 P]。*假设它是消费者 j 和产品 c 之间相似性的增函数，它也可以修改为包括品种寻求的可能性。
• 消费者效用函数建模为多项式 logit。

福利影响

• 认知效应:推荐者帮助消费者意识到良好的产品契合度。
• 显著性效应:推荐者增加了某种产品的显著性，这可能是也可能不是一个好的产品契合度——因为 CF 根据流行度对产品进行排名。
• 如果推荐者只是增加了更适合的产品的认知度，福利会明显增加。
• 福利可能下降，如果突显效应增加了不适合的受欢迎产品。

未来工作邀请

• "未来，实证研究将有助于确定意识与显著性效应的相对强度."

后续步骤

这标志着我关于这个话题的第一轮文献综述的结束。下一步包括(1)第二轮文献综述，针对 2011-2018 年间发表的论文；(2)拿出自己的模型来解释 last.fm 这个好奇的案例。

对 DataViz 工具的不满

原文：https://towardsdatascience.com/frustrations-with-dataviz-tools-de27cbcd2ff1?source=collection_archive---------8-----------------------

Slide rule (U.S. Air Force photo by Airman 1st Class Keenan Berry)

我对目前可用于数据可视化工作的工具范围感到沮丧。它们正在迅速扩散，但经常试图解决完全相同的问题，并从相似的角度解决它们。一些用例确实被很好地覆盖了，但是很多没有——除非我错了；如果是这样，请告诉我我遗漏了什么产品！

几个被很好覆盖的案例:

使用 R / Python 进行科学分析/发布

统计分析和数据争论是核心。图表可以一个接一个地制作，非常简单，通常看起来并不美观。(你可以把它们发表在科学杂志或你的数据博客上，但不能发表在其他地方。)

我大概有 25%的时间在这里工作，直到……

信息海报设计:R/其他+插画

如果你想要复杂的布局，你需要布局软件，通常是 Illustrator。多个图可以很容易地排列在一起，具有不同的层次和共性。视觉吸引力和可视性很高，完全集成了排版、插图和其他页面设计元素。

我经常从事这方面的工作，工具也很不错。我只是和 Illustrator 有时在本质上更技术性。

简单的交互式图表/仪表盘:大量在线产品

使用 Tableau 或 Plotly 或任何其他数量的服务，您可以制作简单、清晰的图表。它们可以被组合到仪表板中，并且至少是最低限度的交互(悬停状态，打开/关闭变量，也许是一些切片)。

通过 D3 高度定制的互动 Vizzes

从头开始建造你想要的任何东西。非常适合在线。学习曲线高。

这条路我还没走过。Javascript 对我来说是一种非常没有吸引力的语言。交互性也不是那么重要。

少了什么

用于基本打印就绪图形的高度可定制工具

“可定制”和“基本”似乎是对立的，但它们不应该是对立的。我愿意做(大量)前期工作来定义一种风格，然后输入数据，以非常快地获得该风格的结果。这是因为我经常需要为打印文档制作一些基本的图表——我也不是指 Word 文档，而是真实的、设计好的跨页。所以我需要严格遵守预先定义的布局、排版规则等的图表。

尽管有上百万种工具可以制作简单的图表，但没有一种工具可以充分定制。交互式 viz 工具并不适合静态显示，R 中的主要库也不能被正确控制。这很糟糕，但我看到的最好的工具是 Illustrator 的内置图表，可以最*化定制(这些可以追溯到十多年前！).

理想的解决方案:Adobe 为图表制作了一个创意套件应用程序。

一个 DataViz 迷你语言

我不想从线条构建图表(太详细了！)但我也不想要一个试图自动为我制作饼状图的系统(太抽象了！).这种语言的目的应该是通过利用算法思*来促进创新设计；所以需要一些技能和劳动力，但你也不一定要成为 web 开发人员。

我认为我们需要一种真正专注于数据的语法，即去掉所有与网络相关的东西；这是高级的，是为数据迭代而设计的(尽管我通常很喜欢函数式语言)。

现有的解决方案都是推某种解决方案和思考。也许这只是我的背景，但这些通常似乎不太正确。例如，在 R 的 ggplot 中有“图形的语法”，或“格子”显示，这吸引了统计学家们；或者 D3 和它的各种库，这对于专注于 responsive/DOM/等等的 javascript 人来说是有意义的。我认为图形更像一个设计师，也许是一个老式的计算机爱好者。

换句话说，为什么我们要从数据中的属性(比如范围/域)或者从盒子中构建东西？这在技术上是有道理的。但是它对人类探索数据可视化的可能性有意义吗？我想多想想:

• 等级和布局，以及一些标准化的选择
• 以及计算机将如何得出值；也就是说，数据是如何通过计算机将采取的过程映射到像素/矢量上的

我认为海龟图形可以成为一个灵感:因为一只海龟画一条线或点很像人类的手，以特定和明显的顺序。对数据进行循环可以直观地构建出在绘制时以特定方式变化的模式。

简而言之，我们有很好的工具给那些完全不想成为技术人员的人，以及那些想最大限度地成为技术人员的人。我们有很好的互动和在线展示工具。但是据我所知，我们没有好的工具，将算法思*和设计焦点融合在一起；这既适用于印刷，也适用于网络。

如果有的话我会买的！

成就感在于创造一些东西

原文：https://towardsdatascience.com/fulfillment-lies-in-the-creating-something-d118db307405?source=collection_archive---------15-----------------------

这篇博文旨在提供对生成性对抗网络及其数学的完整直观理解，包括它的张量流实现。

注意:读者应该对深度学习有一个基本的了解。

在 2014 年的一篇论文中，蒙特利尔大学的博士生伊恩·古德菲勒介绍了一篇名为《生成对抗网络》的论文，他在米兰的导师包括约舒阿·本吉奥和亚伦·库*尔。这篇论文被引用了 5000 多次，并得到了所有深度学习主要先驱的评论。阅读下面 Yann Lecun 对 Gan 的评论。

生成对抗网络是近十年来机器学习中最有趣的想法——Yann le Cun(脸书人工智能主任)

这清楚地表明，生成对立网络做了一些真正有趣的事情。从现在起，我们将把生成性对抗网络称为甘的网络。Gan 很有趣，因为他们可以学习近似数据分布(也称为模仿真实数据)，这是非常强大的，因为现在它可以生成现实中不存在的图像、音频剪辑、视频。在某种意义上，你可以认为甘是艺术家。的一句名言解释了甘的直觉。

我不能创造的东西，我不理解——理查德·费曼(美国理论物理学家)

甘的作品产生的效果非常强大，2018 年 10 月，佳士得数码屋(Christie's digital house)一家法国公司在一场拍卖中以 432，000 美元的价格出售了一幅由甘创作的肖像(图 1.0)。

fig 1.0 Portrait by a Gan. source: here

为什么要生成对抗性模型？

这部分是 OpenAI 关于甘的博文摘要。这个想法是，如果 Gan 在创建数据方面变得更好，那么它也能够比任何其他算法更好地理解世界上存在的数据。随着他们学习数据的底层表示，他们将会更好地理解它。Gan 属于生成模型类，基于可微分生成网络的方法，因此它们是实现这一点的方法之一，其他一些流行的方法有:

1. 变型自动编码器。
2. Rnn 的像 LSTM 的或者 PixelRnn 的。
3. RNN-RBM 顺序输出。
4. 卷积玻尔兹曼机器等等。

稍后将详细介绍这些模型，但想法是一样的，所有这些架构都试图了解定义数据的底层表示。生成模型通常属于一个活跃的研究领域，称为表示学习，即从未标记的数据中学习表示。以上所有的工作方式都不同，但他们都试图学习概率分布。

甘的作品如何？

Gan 的想法很容易理解，它由两个架构组成:一个是鉴别器，用于估计样本为真实样本的概率；另一个是生成器，用于生成接近真实样本的数据。随着时间的推移，鉴别器在鉴别方面变得更好，而生成器在生成更接近真实样本的样本方面变得更好(图 1.1 用于说明)。这两个模型的目标是相反的，因为当生成器最大化鉴别器出错的概率的同时，鉴别器尽力预测正确的标签(真的或假的)。如果你仔细想想一个模型在帮助另一个变得更好，这个想法也会变得有趣。

fig 1.1. Block Diagram of Gan’s. source: here

考虑图 1.2。这里 p(x)(右边蓝色的一个)是图像的真实分布，pθ(x)(绿色的一个)是从通过我们的神经网络的高斯分布中提取的点。最初，这些点将是完全随机的，但与训练一样，我们的模型参数θ被优化以最*化两个分布之间的差异(通过使用 KL 散度或任何其他手段)。

fig 1.2 source: here

发生器和鉴别器可以是相同或不同的结构，在 Gan 的最初论文中，他们通过提供随机噪声作为发生器的输入来使用多层感知器，并且另一个多层感知器模型被用作鉴别器，其检测样本 a 是产生的还是真实的。在本文的后面部分，我们将通过使用一种基于卷积的架构(称为 DCGAN(深度卷积生成对抗网络))来构建我们自己的生成神经网络，但首先让我们将 GAN 背后的数学放入正确的位置。我会尽量让数学简单，但要确保你的基础知识顺序正确。

制定目标函数

目标是通过将随机噪声 z 作为输入经过神经网络 G(z； θg )其中 θg 是生成器神经网络的参数，把任何一个神经网络看成 a，**Universal function approximator**，我们还将定义另一个神经网络 D(x；θd )鉴别器，这个网络将给出概率 d(x) 【在 0 到 1 之间】 x 来自真实数据而不是 Pg，当 G 被训练来最*化 log(1D(G(z))时，D 被训练来预测正确的标签。G 的最*化项 log(1D(G(z)))是有意义的，因为最初，概率 D(G(z))会很低，因为发生器刚刚开始产生样本，鉴别器很容易预测样本是真的还是假的，所以 log(1D(G(z))的总体结果很大。所以当 G 的目标是最*化时，D 的目标是最大化，把这整个情况看作一个最*-最大博弈 V(D，G)

fig 1.3 Loss function of Gan’s source here

打破上面的等式，

首先，Ex∞pdata(x)[log(D(x))]—期望[最大化生成的样本 x 是实数]。

第二，Ez∞pz(z)[log(1D(G(z))]—期望[最*化生成的样本不是真实的。]

上述等式本质上是一个最*-最大博弈，其中一个人试图最*化，另一个人试图最大化。让我们以机器学习中的 L2 正则化为例来理解这种最*-最大博弈情况。在正则化中，正则化项防止权重非常*，但同时优化器最*化总体目标函数，这通常导致*的权重值。这种情况类似于 gan 的最*-最大情况，但不同之处在于，Gan 的最*化和最大化都是由优化器本身控制的。

理想情况下，D(x)的最佳值应该是 0.5，这意味着它不能区分真样品或假样品，即

d∫(x)=Pdata(x)/(Pdata(x)+Pg(x))和 Pg = Pdata。

同时训练 D(x；θd )和 G(z； θg 理论上看起来不错但实际操作中我们通常训练 D(x；θd )对于我们每次训练 G(z； θg )使得鉴频器始终强于发生器。

生成性对抗网络训练。

考虑下面给出的图。

fig 1.4 source here

这个想法很简单，训练网络进行一些迭代，直到结果看起来令人满意。

重复以下步骤 N 次迭代:

步骤 1:对于 n 次迭代中每一次，K 次迭代:
1.select a mini-batch of noise samples (z1....zm) 2.select a mini-batch of real-data samples (r1....rm) 3.train the discriminator with using max-min loss function [eq(1)] over m samples.

第二步:对于下一次迭代:
1.select a mini-batch (z1.....zm) from p(z) 2.train the generator by minimizing the log probability of generator making mistake.

最初的论文提到了使用 SGD 进行训练，但建议使用更强大的优化器，如 Adam、Adagrad、rms-prop 等。

什么是 DCGAN？

DCGAN 或深度卷积生成对抗网络是对以前的 GAN 的一大改进。虽然理论上甘的架构看起来很简单，实际操作起来却很难训练出一个甘。原因是，梯度必须流过鉴别器和发生器，由于这个事实，Gan 的训练变得不稳定。我们将在本文的后面部分讨论这些主题，但首先，让我们试着理解 DCGAN 的架构。

DCGAN 本身是一类基于深度卷积的架构，由两个卷积神经网络组成，具有以下约束条件(根据原始论文，阅读:此处为)。以下约束是在执行广泛的模型搜索后得出的。

1. 用步长卷积替换所有池层，通过这种方法，网络不是依赖池层(最大池或平均池)来执行空间下采样，而是自己学习。
2. 移除所有完全连接的层以创建更深层次的架构，因为完全连接的层会影响网络的收敛。
3. 使用批处理标准化来稳定深层之间的梯度流。
4. 对生成器中的所有层使用 ReLu 激活，除了使用 tanh 的输出层和使用 sigmoid 或 softmax 的鉴别器。

在 DCGAN 的原始论文中提出的体系结构包含一个产生噪声的输入层以及发生器中的四个去卷积层和鉴别器中的四个卷积层以及一个输出层。

fig 1.5 DCGAN architecture. source here

如果你不知道转置卷积，那么看看 Naoki Shibuya 的博客文章。

构建深度卷积生成对抗网络。

本次演示的代码取自于tensor layerDCGAN 的原始实现，经过修改后可用于 Sully Chen 数据集和分层可视化，以真正理解网络是如何学习的。该数据集是为训练自动驾驶汽车而建立的，它包含 63k 张道路驾驶图像，以及相应的转向角和其他值，如油门踏板等。他们使用这个数据集的主要想法是看看 Gan 能多好地模拟真实的驾驶场景，如其他行人、车辆等。如果你从更大的角度来看，这个实验很棒，因为现在你不需要依赖安装在你车前的摄像头来捕捉道路图像，你只需要坐在一个房间里就可以产生无尽的数据。虽然用生成的图像来训练自动驾驶汽车的想法有多好？我将把它留待进一步讨论。

注意:模型的所有权重都使用 Glorot 初始化器初始化。典型的 Glorot 初始化如下所示，

步骤 1: std_dev = sqrt(2.0/(扇入+扇出))
步骤 2:权重=正态分布(平均值=0.0，stddev)

如果你想了解更多关于 Glorot 初始化器或者为什么使用它，点击这里。

Tensorflow 实现的生成器

让我们看看生成器的代码。代码的流程如下:

1.定义发生器参数，如输出图像大*，过滤器参数，伽玛初始化。

2.输入层的*数为 100，即 100 个随机数，由均值= 0、标准偏差= 1.0 的均匀分布生成。

3.输入层与 64 864*64 单元的密集层相连。

4.重塑致密层高度= 64，宽度= 64，深度= 512

5.使用批量归一化进行归一化，gamma 采样自均值= 1.0、std_dev=0.02 且 ReLu 激活的均匀分布。

6.DeConv2d 或简单转置卷积层，内核=(5，5)，步幅= (h=2，w=2)，深度 64 *4，零填充。

7.使用 ReLu 激活进行批处理标准化。

8.DeConv2d 或简单转置卷积层，内核=(5，5)，步幅= (h=2，w=2)，深度 64 *4，零填充。

9.使用 ReLu 激活进行批处理标准化。

10.DeConv2d 或简单转置卷积层，内核=(5，5)，步幅= (h=2，w=2)，深度 64 *4，零填充，双曲正切激活。

鉴别器的张量流实现

1. 定义模型参数，如输出图像大*，过滤器参数，伽玛初始值。
2. 卷积层，内核大*= (5，5)，步距= (h=2，w=2)，具有 Relu 激活和零填充。
3. 卷积层，内核大*= (5，5)，步距= (h=2，w=2)，具有 Relu 激活和零填充。
4. 使用 gamma =正态分布(平均值= 1.0，标准差= 0.02)进行批量标准化。
5. 卷积层，内核大*= (5，5)，步距= (h=2，w=2)，具有 Relu 激活和零填充。
6. 使用 gamma =正态分布(平均值= 1.0，标准差= 0.02)进行批量标准化。
7. 卷积层，内核大*= (5，5)，步距= (h=2，w=2)，具有 Relu 激活和零填充。
8. 使用 gamma =正态分布(平均值= 1.0，标准差= 0.02)进行批量标准化。
9. 展平图层。
10. 带有 1 个隐藏单元的输出层，带有 Sigmoid 激活。

让我们将生成的结果与真实结果进行比较

我不得不说结果看起来比预期的更有希望。在此之前，让我们看看真实数据图像是什么样的(下面的样本是从真实数据集中随机抽取的，目的是看看 gans 在理解数据方面有多好)。

fig 1.6 Random samples from train dataset source

现在生成的样本，

epoches from 1st to 3rd

epoches from 4th to 7th

fig 1.7 Incremental progress shown using epoches as progress points.

如您所见，第一个时期模型的样本只能获得数据的本质，但随着时期数量的增加，输出变得更好，在第 10 个时期，输出变得更好。这个网络被训练了 30 个 epoches，让我们来想象一下。从 epoches 11 到 epoches 排列成一行的图像。

fig 1.8 Generated samples from 11th epoch to 30th(some results skipped)

接近最后一个时代，结果开始捕捉甚至微*的建筑，如轮胎，灌木等。尽管效果不错，但生成器有时仍无法捕捉道路和山脉之间的模糊边缘，导致两者融合。结果仍然是完全可以接受的。

发电机和鉴频器损耗。

Gan 的会聚不稳定，这直接反映在损耗值的变化中。下面提供了我们 gan 架构的损耗值。

Epoch: [ 2/30] [ 139/ 997] time: 0.4634, d_loss: 0.67223823, g_loss: 0.71121359
Epoch: [ 2/30] [ 140/ 997] time: 0.4640, d_loss: 1.28069568, g_loss: 1.98622787
Epoch: [ 2/30] [ 141/ 997] time: 0.4628, d_loss: 1.44974589, g_loss: 0.46058652
Epoch: [ 2/30] [ 142/ 997] time: 0.4819, d_loss: 1.02387762, g_loss: 1.69937968
Epoch: [ 2/30] [ 143/ 997] time: 0.4781, d_loss: 0.59786928, g_loss: 1.81390572
Epoch: [ 2/30] [ 144/ 997] time: 0.4632, d_loss: 0.96302533, g_loss: 0.62419045
Epoch: [ 2/30] [ 145/ 997] time: 0.4622, d_loss: 0.62077224, g_loss: 1.15416789
Epoch: [ 2/30] [ 146/ 997] time: 0.4726, d_loss: 0.57695013, g_loss: 1.11101508
Epoch: [ 2/30] [ 147/ 997] time: 0.4843, d_loss: 0.64481205, g_loss: 1.35732222
Epoch: [ 2/30] [ 148/ 997] time: 0.4617, d_loss: 0.46775422, g_loss: 1.74343204
Epoch: [ 2/30] [ 149/ 997] time: 0.4668, d_loss: 0.60213166, g_loss: 0.84854925
Epoch: [ 2/30] [ 150/ 997] time: 0.4637, d_loss: 0.75188828, g_loss: 1.56600714
Epoch: [ 2/30] [ 151/ 997] time: 0.4644, d_loss: 0.80763638, g_loss: 0.80851054
Epoch: [ 2/30] [ 152/ 997] time: 0.4685, d_loss: 0.66286641, g_loss: 0.79960334
Epoch: [ 2/30] [ 153/ 997] time: 0.4619, d_loss: 0.64668310, g_loss: 1.32020211
Epoch: [ 2/30] [ 154/ 997] time: 0.4742, d_loss: 0.46545416, g_loss: 1.55003786
Epoch: [ 2/30] [ 155/ 997] time: 0.4970, d_loss: 0.94472808, g_loss: 0.49848381
Epoch: [ 2/30] [ 156/ 997] time: 0.4768, d_loss: 0.78345346, g_loss: 1.03955364

我们可以清楚地观察到鉴频器和发电机损耗值上升和下降了多少。与 gans 训练相关的问题将在本博客的后半部分讨论。

使用发生器和鉴别器的分层可视化来解释 Gan

在我们看到的大多数应用中，涉及到神经网络，它们就像一个黑盒，即从一方给出数据并得到输出。我们通常不了解网络内部发生了什么，即使是在抽象的层面上，所以我决定在这个方向上迈出一步，并试图了解生成器和鉴别器中每一层的输出发生了什么，网络是如何生成或鉴别数据的。

注:所有分层输出都是在 Sully Chen 上用 30 个历元训练网络后归一化前得到的。

发电机

第 1 层: 正如所料，最初网络只产生一些噪声。

fig 1.9 1st Layer output

第二层: 网络开始生成一些模式。

fig 1.10 2nd Layer output.

第三层: 有用的模式出现了。

fig 1.11 3rd Layer output

第 4 层: 将应用 tanh 激活的最终图案。

fig 1.12 4th Layer Output

鉴别器

第 1 层: 我们知道较低层用于提取简单的特征，如水平或垂直边缘检测，在我们的实验中观察到了同样的情况。

fig 1.13 1st Layer output.

第二层: 第二层的输出在第一层输出后完成。我们能理解的不多，但所有这些对网络本身都很重要。

fig 1.14 2nd Layer output.

第三层: 尺寸变*，预测仅与网络相关。

fig 1.15 3rd Layer output.

第四层: 网络越深入，很难做出任何解读，但网络就是这么做的。

fig 1.15 4th Layer output.

这些可视化让我们对网络如何预测以及每一层的输出发生了什么有了一些基本的了解，但我们只是触及了表面，要了解这些网络在做什么还有很多。这个开发的完整代码可以在我的 github 这里找到。

甘的问题

理论上，gan 的工作听起来不错，似乎应该收敛到全局最*值，但实际上，当生成器 G 和鉴别器 D 都表示为神经网络时，收敛的机会急剧下降，并且在大多数情况下，收敛将停止在鞍点。

在训练甘时，主要观察到以下问题

1. 纳什均衡问题:这个问题主要是由于 Gan 最*-最大公式而存在的。在这种情况下，一个函数的两个部分只能在一个点上达到最佳值，在静止状态下，它保持不稳定。下面的例子摘自深度学习书籍，考虑一个函数 F(u，v) = uv，其中我们必须最*化 u 的值和最大化 v 的值，那么当 u=v=0 时，F(u，v)的唯一最优值存在。
2. 模式崩溃:在这种情况下，Gan 无法捕获所有类别的数据，只能生成某些类型的模式。通常这种问题不会发生，但如果发生，可能会有问题。
3. 梯度递减:当鉴别器或生成器的梯度变得很*时，这种情况很常见，它几乎停止了另一个的学习。这主要发生在鉴别器的情况下，因为它变得更好，因此梯度变得如此之*，以至于生成器无法学习分布。为了避免这个问题，建议在实际训练整个 gan 之前不要训练鉴别器。

稳定 Gan 仍然是深度学习领域的一个活跃的研究领域，许多学术机构和组织都在从事这方面的工作。如果你有兴趣更多地了解与甘退房相关的当前问题，这是的博客文章，作者 Jonathan hui 。

应用程序

虽然 Gan 的建立牢记合成数据，并从本质上制作模型，以了解更多关于构成真实世界数据的表示，但不幸的是，Gan 的大多数当前使用并不友好，许多甚至是灾难性的，其中一个著名的例子是 deep fakes ，其想法是创建人说或做某事的假图像。这些企图会对社会和国家造成严重损害。尽管如此，gan 还是有一些很酷的应用，

1. 在网上服装行业，顾客可以在实际购买之前，通过试穿人工生成的虚拟版本来了解服装的外观。
2. 生成卡通人物，而不是依赖昂贵的软件。
3. 而不是依赖于工作室。一个经典的例子是最近中国国家新闻机构新华社上传了一段人工智能新闻主播而不是真人的报道。虽然他们没有透露他们的模式是什么，但我在这里采取了有根据的猜测。

摘要

生成对抗网络是目前深度学习中最有前途的技术之一。它们是建立在非常简单且感觉最普通的想法上的。我们的，似乎是甘的一个很好的实验，我会在我的博客里写更多的。完整的代码可以在这里找到。

参考

甘的初始论文:的

DCGAN 论文:https://arxiv.org/abs/1511.06434

tensorlayer dcgan 实现:https://github.com/tensorlayer/dcgan

CNNVIS(可视化库):【https://github.com/InFoCusp/tf_cnnvis

open ai 的生成模型博客

甘的问题:https://medium . com/@ Jonathan _ hui/Gan-why-it-so-hard-training-generative-advisory-networks-819 a86b 3750 b

github/carpedm 20/DCGAN-tensor flow

应用课程

Glorot 初始化器:andyl Jones . Tumblr . com/post/110998971763/an-explain-of-Xavier-initial ization

深度学习书籍:www.deeplearningbook.org/

成熟的推荐系统

原文：https://towardsdatascience.com/full-fledged-recommender-system-3bdf52b1eb69?source=collection_archive---------11-----------------------

人工智能应用的快速崛起，处理器和内存成本的降低，使得过去十年推荐系统取得了令人难以置信的进步。鉴于它们在零售业中日益上升的重要性，它们无疑是人工智能中更受欢迎的话题之一。

http://thedatascientist.com/wp-content/uploads/2018/05/recommender_systems.png

然而，创建一个成熟的、可投入生产的推荐系统可能是一项有点复杂的任务，需要非常系统的方法。在这篇文章中，我将一步一步地指导你如何创建一个推荐系统。

如果你参加过 AI 训练营和课程，你可能知道几乎每一个都包括开发一个基于评分/星级从 1 到 5 的推荐系统(是的，你知道那个有标准电影数据集的)。虽然这些都是很好的入门练习，但它们缺乏现实生活中的例子。当开发一个推荐系统时，你很可能也想参与"用户评论"，它包含了许多需要包含在模型中的重要特性。对于用户评论，准备好使用 NLP。

在本教程中，我们将使用来自 Yelp 网站的数据来表示一个餐馆推荐问题。数据集包含业务 id、用户 id、评分和评论。基于用户的搜索，任务是推荐三家餐馆。这个例子最好使用 Jupyter 笔记本(你可以在这里找到 j upyter 笔记本和数据)。)

首先，我们需要创建我们的工作流程管道。我们的复杂模型就是从这个管道开始构建的。

管道:

现在，让我们按照管道开始构建我们的模型。

在第一步中，我们接收来自用户的输入，比如“素食比萨饼，便宜，有各种配料。”

第二步，我们对输入进行标记，得到:“蔬菜、披萨、便宜、多样、顶级。”

第三步，将这些令牌与业务功能相匹配。如何才能获得业务特征？这部分完全取决于我们的创造力和特征工程技能。我使用下面描述的特性创建了一个业务特性矩阵。行是业务类别，列是业务特征。如果某个功能在用户评论中，则分配“1”，如果某个功能不在评论中，则分配“0”在这种情况下，计算评论的词频-逆词频(tf-idf ),并手动选择与餐馆企业相关的词。接下来，找到与餐馆类型和菜单相关的单词(从餐馆在线找到)。最后，合并来自 tf-idf 和收集的 internet research & menu lookup 的两组特性。

以下是业务特征矩阵的示例快照:

Business Features Matrix

第四步，过滤出与用户输入相关的商家。我们如何做到这一点？以用户输入的第一个词为例:“蔬菜。”转到业务特征矩阵中的蔬菜一栏，在与蔬菜对应的业务中填入所有的 1。对其他特征(单词)重复相同的过程。

第五步，通过使用受限的波尔兹曼机器(RBM)，预测用户是否会喜欢商家提供的选择。这一步将创建一个单行，在列中包含企业。如果用户喜欢这些选择，相应索引中的元素将为 1，否则为 0。

在第六步中，从与用户搜索标准相关的餐馆的搜索结果中取出前三个选择。

在第七步中，考虑另一个场景，用户的搜索是边缘的，RBM 不能返回三个餐馆。尽管对于大型数据集来说，这种情况不太可能发生，但我们仍然应该考虑例外情况。在这种情况下，使用自动编码器来预测每个企业的评级。这将返回一个与 RBM 非常相似的数组，但是这次数组将包括从 1 到 5 的数字(等级),而不是 0 和 1

在第八步中，根据评级，取前三个预测，并将它们与 RBM 预测合并。

在第九步中，如果我们仍然不能为用户找到三家餐馆(此事件再次发生的概率非常低)，根据他们的总体评分选择前三家餐馆(请注意，此评分与第八步中的评分不同。不要混淆，自动编码器的预测也返回从 1 到 5 的等级)。

在第十步中，如果我们想向用户推荐新的餐馆，我们将使用协同过滤和基于内容的过滤技术来找到用户会喜欢的餐馆。这是如何工作的？

我们定义了企业和用户的相似度函数。例如，如果用户 A 和 B 的口味相似，推荐系统将向用户 A 推荐用户 B 也喜欢的餐馆，反之亦然。这就是协同过滤的主要思想。

另一方面，如果用户 A 喜欢素食场所，提供素食选择的商家也会彼此相似。将向用户推荐其他素食餐馆。这是基于内容的过滤。请看 jupyter 笔记本如何创建业务和用户相似性函数。

协同过滤和基于内容的过滤技术不能用于该数据集，因为该数据集对于推荐系统来说太*。皮尔逊相关的经验法则是 25。(https://www . research gate . net/post/What _ is _ the _ minimum _ sample _ size _ to _ run _ Pearsons _ R)，我们的数据集平均每个商家有 2 个评分。如果您使用较大的数据集，您可能希望使用这些技术，因为它们非常强大！

最后，在步骤十一，向用户推荐排名前三的餐厅。

我希望这篇教程能让你对推荐系统有更好的理解。你可以从这里访问完整的代码和数据。敬请关注“如何部署推荐系统。

谢谢你

面向数据科学家和其他非 Web 开发人员的完整堆栈基础知识，第 2 部分:jQuery、D3、AJAX 和 Flask

原文：https://towardsdatascience.com/full-stack-basics-for-data-scientists-and-other-non-web-developers-part-2-jquery-d3-ajax-and-90f629c6b952?source=collection_archive---------5-----------------------

这是关于基本的全栈 web 开发工具的 2 部分系列的第 2 部分，数据科学家需要这些工具来在 web 上构建基本的交互式可视化。第一部分涵盖了 HTML 和 CSS。在这一部分中，我们将实现我们的承诺，教你如何制作交互式可视化，包括目前最流行的 web 编程语言 JavaScript，两个最流行的库 jQuery 和 D3.js，以及一个优秀的 Python 后端框架 Flask。

Java Script 语言

基本上，HTML 用于在页面上放置元素，CSS 用于设置这些元素的样式，包括将它们放置在页面上相对于彼此的特定位置，Javascript 用于在元素被放置在页面上后对其进行操作。例如，D3.js 只是一堆处理特定 HTML 元素类的代码——即，支持向量图形 (SVG)元素，如矩形和圆形。

Javascript 可以用来以你能想到的所有方式操纵元素。它可以改变元素的样式，或者直接改变样式，或者给元素分配一个不同的 CSS 类。它可以在页面上移动元素。

这些都可以用普通的 Javascript 来完成。然而，我们甚至不会在这里深入讨论如何做到这一点，因为最好的做法是使用目前最流行的 Javascript 库、 jQuery 来完成这样的任务。

jQuery

jQuery 允许您使用$语法轻松地选择页面上的元素，特别是如果它们有一个指定的“id”或“class”的话。您可以使用与 CSS 类似的语法选择特定类的所有元素，例如，$(".fruit")选择所有具有类fruit的元素，$("#banana")将只选择具有 id 的banana的元素。

一旦我们做到了这一点，就有了相对直观、简单的语法来操作这些元素。例如，假设我们已经选择了页面上 class fruit的所有元素；默认情况下，jQuery 会将它们读入一个数组，所以我们可以使用下面的$和each语法遍历它们并更改它们的属性:

var bananas = $(".banana");
bananas.each(function() {
  $(this).text("My text now says 'banana'");
  $(this).addClass("fruit");
}

你明白了。我们将在下面的函数中广泛使用这种模式。

还有另外两个基础工具，每个数据科学家都应该知道，它们被用来构建这个数独应用[D3.JS](https://d3js.org)和[AJAX](http://adaptivepath.org/ideas/ajax-new-approach-web-applications/)。

D3。射流研究…

你可能在网上看过非常酷的[D3.JS](https://bl.ocks.org/mbostock)可视化。我认为这些展示了D3.JS的力量是很棒的，但是华而不实的演示从根本上来说是为了记忆和让正在发生的事情看起来像魔术，而不是照亮表面下正在发生的事情。事实上，你说“他们是怎么做到的？”是好设计的标志。这是相反的——我想让你确切地知道我是怎么做的！

所以，华丽的 D3 可视化掩盖了 D3 在做什么。 D3 到底在做什么？D3 是一个 Javascript 库。基本上，它选择和操作页面上的 HTML 元素——就是这样。它使用的语法虽然需要时间来适应，但却非常有表现力和简洁。在我看来，初学者纠结 D3 的很大一部分原因。他们的头脑中没有这样的思*模式:

• 一个页面上存在 HTML 元素——即使这些是像<svg>或<circle>这样的元素(通常是 D3 操作的元素),它们仍然是 HTML 元素。
• D3。JS 只是使用 Javascript 来操作这些元素——仅此而已。

那是 D3。我们一会儿会谈到它是如何在数独应用程序中使用的。首先:什么是 AJAX，我们为什么要了解它？

创建交互式、快速动态网页应用的网页开发技术

AJAX 代表异步 Javascript 和 XML。它用于以下在现代 web 上非常常见的用例:当一个页面加载时，它最初只是加载向用户显示“初始”页面所需的所有 HTML 和 CSS 想象一下脸书在你的新闻提要上加载前几个条目。但是，一旦在页面上执行了操作(例如，用户向下滚动或单击按钮)，您可能希望用新信息更新页面上的内容。此外，这些信息可能必须来自外部来源，比如服务器。为了做到这一点，Javascript 有一个名为 AJAX 的内置函数，它可以向外部服务器或函数发出请求，获取所需的信息，然后根据这些信息更新页面上的内容，完成所有这些——这是关键部分— ,而无需重新加载页面。AJAX 是你可以向下滚动脸书新闻提要的原因，脸书不必把你带到一个包含“第二页”信息的新网站——它发出一个 AJAX 请求，得到的响应只是被添加到当前页面。

最后，让我们介绍一个更接近核心数据科学工具包的工具:Flask。

瓶

对于这个项目来说，Flask 允许您定义不同的路径，将 Javascript 数据路由到实际操作这些数据的 Python 函数。因此，如果您想拥有一个接受一个数字并将其乘以 2 的 Python 函数，您可以定义一个multiply路由，在该路由后面有一个 Python 中的multiply_by_two函数，并让 Javascript 调用该路由(使用 AJAX，我们将会看到)。或者，如果你想有一个函数，例如，接受一个数独板，并从板上消除一个数字作为候选，你也可以这样做。理论上，我们可以用 Javascript 完成所有这些工作。但是，因为 Python 是数据科学的标准语言，也因为它是一种比 Javascript 更简洁的通用语言——以及(真正的原因)Peter Norvig 用 Python 写了他的文章“如何解决每一个数独”——我们将使用 Python 编写数独函数，并使用 Flask 和 AJAX 在两者之间建立接口。

这些工具如何组合在一起

数独应用的代码是这里是。我们现在将介绍各种功能及其作用。

当用户导航到数独应用程序的时，他们正在前往烧瓶应用程序中的路线[/](https://github.com/SethHWeidman/Sudoku_solver/blob/master/main.py#L28)。

当用户点击“逐步求解”并点击“开始”时，它调用 Python 路由[sudoku_action](https://github.com/SethHWeidman/Sudoku_solver/blob/master/main.py#L44)。Flask 知道如何将单选按钮的值作为一个request对象读入数据，该对象的值是一个可以通过request.form访问的字典。特别是，它可以计算出使用[request.form['type']](https://github.com/SethHWeidman/Sudoku_solver/blob/ac6c36495657ead14dd7fa69c0d26a969b986923/main.py#L56)选择了哪个单选按钮。如果它检测到“逐步求解”已被选中，它将简单地呈现 HTML 模板[sudoku_action.html](https://github.com/SethHWeidman/Sudoku_solver/blob/master/templates/sudoku_action.html)。

该模板将立即启动callFlaskUpdateOne功能:

function callFlaskUpdateOne() {      
  $.ajax({        
    url: {{ url_for('update_one')}},
    data: extractData(),
    type: 'POST',
    success: function(response) {
      updateClasses(response['values']);  
      displayMessage(response['message'])
      highlightCell(response['peer']);          
      callFlaskUpdateOne();        
    },        
    error: function(error) {
      console.log(error);
    }    
  })  
};

这个函数使用 jQuery 中特定的ajax函数。作为参数，该函数需要

• 一个url，定义在哪里进行函数调用。
• data，告诉它向那个函数发送什么数据。
• 请求的type，对于我们的目的来说是一个POST请求。

所以:启动这个函数首先调用函数update_one的 Python route。将发送到该函数的数据在extractData() 函数中。这个函数的目标是从实际的网页中获取关于数独板当前状态的所有数据。这样做的方式是我们到目前为止所学概念的直接应用，它利用了这样一个事实，即我们可以将关于数独板的实际数据存储在 Python 和 Javascript 都能理解的结构中。

Python 和 JavaScript 都“理解”的数独棋盘结构就是这个结构

{‘A1’: ‘123456789’, 'A2': '1245', 'A3': 8, ...} 

也就是说，它是一本有 81 个词条的词典。这些物品的 81 个键是字母 A-I 和数字 1-9 的 81 种组合。作为值，它们是包含所有尚未从方块中消除的数字的字符串。此外，每个[cell](https://github.com/SethHWeidman/Sudoku_solver/blob/master/templates/sudoku_action.html#L11)都被赋予了一个职业[sudoku-solving](https://github.com/SethHWeidman/Sudoku_solver/blob/master/templates/sudoku_action.html#L11)和一个[name](https://github.com/SethHWeidman/Sudoku_solver/blob/master/templates/sudoku_action.html#L11) 属性，对应于前面提到的名字字母组合之一，比如D5。

因此，在任何给定的时间，我们都可以使用 jQuery 提取具有该类名的所有 HTML 元素，然后简单地遍历每个元素，并将“data”中的元素赋值为将 HTML 元素的“name”作为其键，将 HTML 元素的 text 作为其值。

function extractData() {
      output_dict = {};
      var numbers = $(".sudoku-solving");
      numbers.each(function() {
         output_dict[$(this).attr('name')] = $(this).text();
      })
      return output_dict;
    };

注意，在以output_dict开始的行中，我们使用[]符号在字典中查找元素，就像我们在 Python 中一样。

然后，我们用ajax函数中的行和data: extractData()将数据发送给 Python。这是一个很好的例子，说明了 HTML、CSS、jQuery 和 AJAX 是如何交互的，我们将在这个应用中介绍的其他功能也是根据类似的原理运行的。

一旦 Python 接收到数据，它就以相同的形式将数据发送回 Javascript ，除了 Python Sudoku 代码已经修改了数据，以便从棋盘上的一个单元格中删除一个数字作为候选。它还向 Javascript 发回一条将显示在屏幕上的“消息”,以及一个表示已经去掉数字的单元格的“对等体”:

return jsonify(values=new_values, message=message, peer=peer)

(阅读经典的 Peter Norvig 数独文章并查看[sudoku.py](https://github.com/SethHWeidman/Sudoku_solver/blob/master/python/sudoku.py)中的[eliminate_one](https://github.com/SethHWeidman/Sudoku_solver/blob/master/python/sudoku.py#L96)功能)

此响应由ajax功能:success: function(response)接收；收到此响应后，将运行几个 JavaScript 函数:

updateClasses(response['values']);          displayNewData(response['values']);          displayMessage(response['message'])          highlightCell(response['peer']);

让我们一个接一个地看一下:

更新类

第一个功能是updateClasses。这个函数循环遍历每个数独cells。对于这些单元中的每一个，它查看从 Python 接收回的数据，看它接收到的数据的长度是否为 1，这意味着单元被“求解”。如果是这样，它将移除一个名为[sudoku-not-solved](https://github.com/SethHWeidman/Sudoku_solver/blob/master/static/stylesheets/style.css#L18)的 CSS 类，该类对单元格中尚未求解的数字进行样式化(例如，定位和调整大*)。移除了该类之后，它添加了一个新的 CSS 类[sudoku_number](https://github.com/SethHWeidman/Sudoku_solver/blob/master/static/stylesheets/style.css#L2),其效果是增加该单元格中剩余数字的大*，并使其在父单元格中居中:

function updateClasses(input_sudoku) {
  var numbers = $(".sudoku-solving");
  numbers.each(function() {
    var candidate_numbers = input_sudoku[$(this).attr("name")];
    if (candidate_numbers.length == 1) {
       $(this).text(candidate_numbers);               $(this).addClass("sudoku_number"); 
       $(this).removeClass("sudoku-not-solved"); 
      }    
    });  
  };

显示新数据

一旦更新了类，就调用“displayNewData”函数。这个函数简单地遍历页面上的所有元素，并根据 Python 接收到的数据更新它们的文本。

function displayNewData(update_sudoku) {     
  var numbers = $(".sudoku-solving");
  numbers.each(function() {       
    $(this).text(update_sudoku[$(this).attr('name')]);
    });
  };

显示消息

现在我们到了涉及 D3 的部分。在将原始的数独放到页面上时，一个<svg>元素被附加到数独板的底部，宽度为 500，高度为 100。

var message_area = d3.selectAll(".update_message")
  .append("svg")
  .attr("width", 500)
  .attr("height", 100);

完成 AJAX 请求后，JavaScript 会收到一条消息。使用 D3，我们将消息附加到 SVG 对象，并将其放在对象底部附近的y=80处，并使其透明。然后，我们使用 d3 做一个过渡，将文本向上移动到y=50并移除透明度，这样它就好像“出现”在屏幕上。然后，我们暂停 500 毫秒，然后我们从屏幕上移除对象，再用半秒钟将文本移回y=80，并使其再次透明。以下是所有这些的代码:

function displayMessage(message) {    
var variable_message = message_area.append("text")
  .text(message)
  .attr("x", 100)
  .attr("y", 80)
  .attr("fill", "red")
  .attr("opacity", 0)
  .transition()
  .duration(500)
  .attr("y", 50)
  .attr("opacity", 1)
  .transition()
  .duration(500)
  .transition()
  .duration(500)
  .attr("y", 80)
  .attr("opacity", 0);
};

该函数突出显示一个特定的单元格，即 Python 代码返回的单元格。首先，它使用 Python 返回的函数名选择单元格。然后，它使用 JavaScript 函数setTimeout暂停 2 秒钟，然后从单元格中删除这个类。这比我想象的要简单:CSS 中的[highlighted-cell](https://github.com/SethHWeidman/Sudoku_solver/blob/ac6c36495657ead14dd7fa69c0d26a969b986923/static/stylesheets/style.css#L89) 类处理得很好。下面是 Javascript 代码:

function highlightCell(cell) { $('#'.concat(cell)).addClass('highlighted-cell')
  setTimeout(function() {
    $('#'.concat(cell)).removeClass('highlighted-cell');
  }, 2000)
};

把这些放在一起

所以，每三秒钟，我们做以下事情:

1. 使用 jQuery 从页面中提取数据。
2. 调用 Python 来获取“新数据”以显示在板上。
3. 通过更新页面上事物的类别，使页面上任何有一个数字的单元格“变大”。
4. 实际显示新数据。
5. 在屏幕底部的 SVG 上显示消息。
6. 突出显示已更新的单元格。

看到它的实际应用

导航到sethweidman.com/app/sudoku。这个应用程序预装了我在谷歌上找到的第一个“简单数独”。点击“运行数独”来看看它的行动！

结论

即使您自己不是 web 开发人员——我想大多数人都不是——我也希望这个由两部分组成的系列文章能让您了解 web 开发的基本工具是如何工作的，这样您至少可以更自信地参与到团队关于应该构建什么以及应该如何构建的讨论中。对于正在阅读这篇文章的数据科学家来说:我相信，如果你花时间学习这些工具，你会成为更有效的数据科学家，这样你就可以构建可视化，更好地向你的老板、客户甚至同事说明你正在做什么——毕竟，我们在 Metis 教授这些工具是有原因的！

面向数据科学的全栈 web 开发

原文：https://towardsdatascience.com/full-stack-web-dev-for-data-science-28f1f0bc22d1?source=collection_archive---------13-----------------------

一口大*的数据科学第 4 集

如果你像大多数数据科学家一样，你进入这个领域可能是因为你对算法或者数学感兴趣。因此，当意识到成为一名有效的数据科学家实际上意味着知道的远不止如何在 scikit-learn 中建立管道时，可能会有点震惊。

真正的数据科学通常需要了解足够多的 devops 来部署和容器化您的模型，以及足够多的 web 开发来执行抓取、用户跟踪和集成任务，这些任务是许多人日常数据科学工作流的一部分。

但是您如何知道使用哪些库和框架，以及学习什么呢？这是韦斯利本周一直在问的问题，这促使他在导师柳文欢的帮助下，探索每个优秀的数据科学家都应该知道的一些工具:Docker、Flask 和 AWS。

从普查数据中观察到的情况

原文：https://towardsdatascience.com/fun-with-census-data-2643ecd266c4?source=collection_archive---------5-----------------------

有一段时间，我想尝试用 Python 做一些基本的数据分析和可视化。所以，我从 2010 年美国人口普查中得到了一些文件。我处理的数据中有一些关于每个州的有趣事实，从 1910 年开始每十年一次(甚至是那些还没有加入联邦的州！).所以我提出了一些问题，然后开始工作。

注意:我在一个 Jupyter 笔记本上为此工作，你可以在这里查看。

群体大*

问题 1 :是什么让一个州的人口在十年间不断增长？([1]).

一个州今年的规模会影响下一年的增长吗？这次我可以选择任何一种方式。这种积极的关系需要“社会证明”——也许人们想搬到像纽约和加利福*亚这样的大州，那里有很多令人兴奋的事情发生。另一方面，也许人们想搬到更*的州，那里生活更安静，土地更便宜。

我没想到的是，几乎没有任何关系。对于数据集中的每一年，我计算了一年中各州的人口规模(该州的总人口数)与其未来十年人口增长百分比之间的相关性。

两者之间的相关性有时为正，有时为负，相关系数([2])的绝对值从未超过 0.25。很明显，没有任何关系。

即使是 1980 年，也显示了所有测量年份中最强的相关性，其相关性的 p 值为 p≈0.054，足以拒绝在 0.05 的显著性水平上存在相关性的假设。

人口密度

问题 1(修改后):也许我们需要提出一个更严格的问题。如果我们测量人口密度(即每平方英里的人口数量)而不是人口增长率(T10 ),我为正反两种情况提出的因素可能更有意义。如果你住在中央谷，像加利福*亚这样的大州并不令人兴奋——你需要住在大城市之一，那里有大量的人住得很近。即使你住在一个*州，你也需要更少的邻居来确保更便宜的土地和更安静的生活。

那么人口密度呢？一个州每平方英里的人口数量影响其人口增长吗？嗯，有时候。如果我们像以前一样做同样的事情——计算一年内一个州的人口密度与其未来十年人口增长之间的相关性，这就是我们得到的结果。

我们可能会变得更暖和一点。自 1960 年以来，一直存在微弱的负相关性，这意味着致密态比稀疏态增长得更慢。然而有趣的是，相关性最大的十年显示出相反的情况。1930-1940 年的人口增长是怎么回事，这期间的相关性是 r≈0.436，p 值是 p≈0.001？简而言之，沙尘暴。这绝对是一次大规模的州际人口迁移，是美国历史上最重大的事件之一。在沙尘暴期间，超过 350 万人从平原州移民到西部。事实上，捕虾最快的前五个州都来自大平原(达科他州、内布拉斯加州、堪萨斯州和俄克拉荷马州)。([3]).

但这是另一篇文章的内容。

众议院分配

每次人口普查都决定了每个州在美国众议院的席位。这是通过一个叫做分配的过程，实质上是给每个州一个免费的席位，然后使用一个法律规定的公式来分配第 51 个席位，然后是第 52 个，以此类推，直到第 435 个。([4]).

自 1930 年以来，美国人口增加了一倍多，而众议院拥有 435 个席位，因此每 10 年每名代表的人数都在增加。

很明显，随着时间的推移，个人的投票权被稀释了。此外，众所周知议院的代表性不平等，部分原因是不公正的选区划分。这让我不禁要问，众议院中的不平等代表性是否也达到了历史最高水平。

问题 2:现在州与州之间的众议院代表差距有多大？与前十年相比如何？

为了衡量这一点，我用每个代表人数的标准差来衡量每十年的“分布”。一个完全公平的年份的标准差应该是 0。

事实证明，用这种标准衡量，近代历史上的情况比过去好得多。这并不奇怪，因为不公正的选区划分已经存在了几个世纪。但是我不会因此得出任何结论，因为这并不严格，最好是逐区检查差异，而不是以州为单位。

问题 3:就每个代表的人数而言，哪个州最好，哪个州最差？这个问题的答案可能有点令人惊讶。作为一名加利福*亚人，我的第一个猜测是像加利福*亚和纽约这样的大州是最差的代表。但事实证明完全不是这样。人口众多的州正好位于中间。每个代表的最高和最低值的州都相对较*。

结论

这比我想象的要困难得多，但也很有趣。在以后的文章中，我想在更细粒度的层次上研究数据。例如，挖掘国会选区的数据会很有趣，而且可能会得出与我在这里发现的不同的分摊结论。

感谢阅读。请提出任何建议、批评或想法！

脚注

1. 在这里，各州的人口增长是以过去十年的百分比来衡量的。因此，如果德克萨斯州在 1930 年有 1000 名居民，在 1940 年有 1500 名居民，那么其 1940 年的人口变化将是 0.5。
2. 我用的是皮尔森的 r 。
3. 来源:https://en.wikipedia.org/wiki/Dust_Bowl。
4. 这些被称为优先级值，它们本身就有一个有趣的故事

有趣的*图像数据集

原文：https://towardsdatascience.com/fun-with-small-image-data-sets-8c83d95d0159?source=collection_archive---------1-----------------------

棒球还是板球？美元还是加元？

假设您想为自己的特定任务构建一个图像分类器。你可能认为你需要收集大量的数据。令人惊讶的是，少量的训练图像足以产生合理的准确率(90–100%)。我将在这里讨论两个案例研究:将图像中的运动分类为棒球或板球，并将钞票图像识别为美元或加拿大元。

我目前正在旧金山参加 Fastai 深度学习课程。到目前为止非常有趣。我尝试的两个案例(板球对棒球和美元对加元)都是基于第一课。该课程使用预先训练的模型 resnet 34(Fastai 的一位同学在此提供了关于 resnet 模型的更多细节)作为起点。使用 fastai 框架非常简单快捷。下面是这个难题主要部分的一个例子——调用学习者数据对象的 fit 方法来训练模型。

第一课是深入研究使用卷积神经网络(CNN)模型来获得非常受欢迎的狗与猫 Kaggle 比赛的最新结果。我强烈建议你在这里看看。课程是以 Jupyter 笔记本的形式，你需要有某种深度学习机器设置(流行的选择是 AWS，Paperspace 实例；或者定制的深度学习装备)。 Crestle 是另一个选项，让您几乎无需任何设置即可开箱运行 Jupyter 笔记本。

板球 vs 棒球

板球和棒球是两项有着相似“特征”的运动，所以我试图区分它们。为了收集用于训练和测试的图像，我分别使用 Google Image 搜索了 Cricket 和 Baseball 这两个术语。我为每项运动下载了 20 张图片，并将它们分成训练( 15 张图片)和测试( 5 张图片)组。我能够用 15 幅训练图像获得 90%的合理准确度(9/10 的测试图像被正确分类)。这里有一些图片被分类的例子。预测分数越接近 0 表示棒球图像。

在玩了这个模型之后，我发现 0.1 的学习率给出了很好的结果。由于训练图像的数量很少，所以我使用试错法来找到一个好的学习率。下面是一张分类错误的图片。

通过多次运行该模型并改变超参数，时不时地得到 100%是可能的。我不确定 100%的准确率是否意味着太多，因为测试图像的数量很少。接下来，我想用大量的有效图片来尝试一下，看看这个模型是如何推广的。

美元对加元

这次我用美钞做了同样的实验，分别用 7 张美元和加拿大元的图像进行训练，用 5 张图像进行测试。这一次，分类器能够轻松达到 100%的准确率。以下是一些示例结果——预测得分越接近 0，意味着美元钞票是加拿大的。

另一种分析分类模型结果的常用方法是使用混淆矩阵，它沿着负 45°对角线显示正确分类的分类变量。在这种情况下，没有美元被错误分类，因此我们看到下面的[5，0][0，5]模式。

结论

许多领域都受到数据收集问题的困扰(生物医学图像、工业设置)。收集足够的图像数据可能很难或者非常昂贵。然而，我们不一定需要 1000 张图像来使用预先训练的模型构建我们自己的定制分类器。这对于原型制作和快速实验来说是个好消息。以下是一些值得进一步探索的方向:

1. 自动下载定制图像，以便构建更好、更定制的分类器
2. 确定更适合*型数据集的技术/实践。将它们应用于收集数据困难/昂贵的领域
3. 尝试一些有趣的例子:船 vs 潜艇？这个人戴没戴眼镜？

PS:这周我开始破解其中的一个问题。本系列的第二部分，阅读 人类是否戴着眼镜 ？

*图像数据集的乐趣(第 2 部分)

原文：https://towardsdatascience.com/fun-with-small-image-data-sets-part-2-54d683ca8c96?source=collection_archive---------4-----------------------

人类是戴眼镜的吗？ 第一部看这里。

在这篇博客中，我们将看到如何训练一个分类器来识别人是否戴着眼镜。我们从一个预先训练好的模型和从 Google 图片搜索下载的 260 张训练图片开始。像第一部分中的一样，我们将使用 Fastai 课程的第一课 Jupyter 笔记本的修改版本。

早先玩 10 张图片很有趣，但随着我们进入更严肃的乐趣，我们想处理 100 张甚至 1000 张图片。为此，我使用了 Hardikvasa 的一个漂亮的*脚本。这是一个 Python 程序，可以在谷歌图片上搜索关键字/关键词，并可以选择下载所有图片。

我首先为“戴眼镜”和“不戴眼镜”两种情况下载了 200 个演员(男/女)的图像。我手动扫描图像以删除有缺陷的图像(jpg 文件损坏、错误的图像等),然后将图像分为 135 幅训练图像和 20 幅验证图像——包括“戴眼镜”和“不戴眼镜”的情况。

训练图像数量:135 x 2(带眼镜和不带眼镜)

Sample Training data-set (with glasses)

Sample training data-set (with no glasses)

使用学习率为 0.01 的普通 resnet 模型，我能够获得合理的准确度 77.5 % (31/40 的测试图像被正确分类)

为了提高我们的模型的准确性，我们可以尝试几种技术，如增强、优化最佳学习速率、对不同层使用不同的学习速率以及测试时间增强等。我们将在这里介绍两种技术:

(1)增强是一种将神经网络暴露于我们从现有数据集创建的更多数据的方法。这是通过以不影响图像解释的方式随机改变图像来实现的，例如水平翻转、缩放和旋转。

Applying augmentation transforms to a sample image (flipping, zooming in etc)

增强主要是为了减少过度拟合(这意味着我们的模型正在学习识别训练集中的特定图像，但没有足够好地概括，因此我们在验证集上获得了良好的结果)。使用训练数据集的增强，我能够获得更好的准确性— 87.5 % (35/40 的图像被正确分类)

(2)不同的学习速率和解冻层:我们在这里使用的 resnet 模型由几层组成。通常，早期的层识别基本特征，如线条、渐变等。每一层都逐步建立在前一层的基础上，因此，随着我们进入后面的层，所识别的“特征”的复杂性会增加。因此，我们预计后面的层对于新的数据集需要较少的微调。这里，我们将对不同的层使用不同的学习速率:前几层将处于 1e-4，中间层处于 1e-3，而我们的 FC 层将像以前一样处于 1e-2。如下图所示，使用增强和差异学习率的组合足以给我们的数据集带来 100%的准确率！重复实验几次，我注意到准确率大部分时间都徘徊在 97.5 到 100 %以上。

结论:我们的模型能够准确预测人是否戴眼镜。尽管训练图像数量如此之少，但看到这种深度学习模型的功效令人兴奋。在数据收集阶段，我不知道会发生什么，但我对结果感到惊喜。

深度学习的函数式编程

原文：https://towardsdatascience.com/functional-programming-for-deep-learning-bc7b80e347e9?source=collection_archive---------0-----------------------

在我开始在 ThinkTopic 的最新工作之前，“函数式编程”和“机器学习”的概念完全属于两个不同的世界。一个是随着世界转向简单性、可组合性和不变性以*护复杂的扩展应用程序，编程范式越来越受欢迎；另一个是教电脑自动完成涂鸦和制作音乐的工具。重叠在哪里？

我与这两位合作得越多，就越开始意识到这种重叠既是实际的，也是理论上的。首先，机器学习不是一项独立的努力；它需要迅速融入工业中复杂的缩放应用。其次，机器学习——尤其是深度学习——在设计上是有功能的。给定正确的生态系统，以完全功能化的方式执行深度学习有几个令人信服的理由:

• 深度学习模型是组合的。函数式编程就是组合高阶函数链来操作简单的数据结构。神经网络以同样的方式设计，将一层到下一层的函数变换链接在一起，对输入数据的简单矩阵进行操作。事实上，深度学习的整个过程可以被视为优化一组组合函数，这意味着模型本身具有内在功能。
• 深度学习组件是不可变的。当函数对输入数据进行操作时，数据不会改变，一组新值被输出并传递。此外，当权重被更新时，它们不需要被“变异”——它们可以被新值替换。理论上，对权重的更新可以以任何顺序应用(即，它们不相互依赖)，因此不需要跟踪连续的可变状态。
• 函数式编程提供了简单的并行性。最重要的是，纯函数和可组合函数很容易并行化。并行意味着更快的速度和更强的计算能力。函数式编程为我们提供了基本上免费的并发性和并行性，使得在深度学习中使用大型分布式模型变得更加容易。

关于函数式编程和深度学习的结合，有许多理论和观点，从数学论证到实践概述，但有时只有在实践中才能看到它，这才是最有说服力的(也是最有用的)。在 ThinkTopic，我们一直在开发一个叫做 Cortex 的开源机器学习库。在这篇文章的其余部分，我将介绍函数式编程背后的一些想法，并将它们用于异常检测的 Cortex 深度学习模型。

Clojure 基础

在继续我们的 Cortex 教程之前，我想介绍一些 Clojure 的基础知识。Clojure 是一种函数式编程语言，它擅长两件事:并发和数据处理。对我们来说幸运的是，这两件事对机器学习都非常有用。事实上，我们使用 Clojure 进行机器学习的一个主要原因是，每天都要为训练准备数据集(数据操作、处理等)。)很容易超过实现算法的工作，特别是当我们有一个像 Cortex 这样的坚实的学习库时。使用 Clojure 和。edn(而不是 C++和 protobuf)，我们可以在 ML 项目上获得杠杆和速度。

要更深入地了解这门语言，请看这里的社区指南。

从基础开始:Clojure 代码由一堆在运行时计算的表达式组成。这些表达式包含在括号中，通常被视为函数调用。

(+ 2 3)          ; => 5
(if false 1 0)   ; => 0

有 4 种基本的集合数据结构:向量、列表、散列映射和集合。逗号被视为空白，所以通常会被省略。

[1 2 3]            ; vector (ordered)
'(1 2 3)           ; list (ordered)
{:a 1 :b 2 :c 3}   ; hashmap or map (unordered)
#{1 2 3}           ; set (unordered, unique values)

列表前面的单引号只是防止它被当作表达式来计算。

Clojure 还附带了很多内置函数来操作这些数据结构。Clojure 的部分优点在于，它被设计为针对很少的数据类型提供很多函数，而不是针对很多数据类型中的每一种都提供一些专门的函数。作为一种 FP 语言，Clojure 支持高阶函数，这意味着函数可以作为参数传递给其他函数。

(count [a b c])              ; => 3(range 5)                    ; => (0 1 2 3 4)(take 2 (drop 5 (range 10))) ; => (5 6)(:b {:a 1 :b 2 :c 3})        ; use keyword as function => 2(map inc [1 2 3])            ; map and increment => (2 3 4)(filter even? (range 5))     ; filter collection based off predicate => (0 2 4)(reduce + [1 2 3 4])         ; apply + to first two elements, then apply + to that result and the 3rd element, and so forth => 10

当然，我们也可以用 Clojure 写自己的函数，用defn。Clojure 函数定义遵循形式(defn fn-name [params*] expressions)，它们总是返回主体中最后一个表达式的值。

(defn add2
  [x]
  (+ x 2))(add2 5)     ; => 7

let表达式在“let”的词法范围内创建和绑定变量。也就是说，在表达式(let [a 4] (...))中，变量“a”在内括号内(且仅在内括号内)取值为 4。这些变量被称为“局部变量”

(defn square-and-add
  [a b]
  (let [a-squared (* a a)
        b-squared (* b b)]
    (+ a-squared b-squared)))(square-and-add 3 4)       ; => 25

最后，有几种方法可以创建匿名函数，既可以赋给局部函数，也可以传递给高阶函数。

(fn [x] (* 5 x))          ; anonymous function#(* 5 %)                  ; equivalent anonymous function, where the % represents the function's argument(map #(* 5 %) [1 2 3])    ; => (5 10 15)

基本就是这样！现在我们已经学习了一些 Clojure，让我们把乐趣放在函数式编程上，回到一些 ML 上。

皮质

Cortex 是用 Clojure 编写的，是目前规模最大、发展最快的使用函数式编程语言的机器学习库之一。本文的其余部分将介绍如何在 Cortex 中构建最先进的分类模型，以及这样做所需的函数式编程范例和数据扩充技术。

数据预处理

我们的数据集将是由 Kaggle 在这里提供的信用卡欺诈检测数据。事实证明，这个数据集非常不平衡，在 284，807 个案例中，只包含 492 个正面欺诈案例。也就是 0.172%。这稍后会给我们带来问题，但首先让我们看看数据，看看这个模型做得如何。

为了确保个人数据的匿名性，除了“时间”和“数量”之外的所有原始特征都已经被转换成 PCA 成分(其中每个条目代表一个新变量，该变量包含来自原始数据的最相关的信息)。稍微研究一下数据就会发现，第一个“时间”变量相当不具信息性，所以我们在读取数据时会忽略它。下面是我们的初始代码:

皮层神经网络期望以图谱的形式输入数据，这样每个图谱代表一个单独的标记数据点。例如，一个分类数据集可能看起来像[{:data [12 10 38] :label “cat”} {:data [20 39 3] :label “dog“} ... ]。在我们的 create-dataset 函数中，我们读入 csv 数据文件，将除最后一列之外的所有列指定为“数据”(或特征)，并将最后一列指定为标签。在该过程中，我们基于分类类别将标签转变为独热向量(例如[0 1 0 0])，因为我们的神经网络的最后一个 softmax 层返回类别概率的向量，而不是实际的标签。最后，我们从这两个变量创建一个映射，并将其作为数据集返回。

模型描述

在 Cortex 中创建模型相当简单。首先，我们将定义一个超参数图，供以后在训练中使用。然后，为了定义一个模型，我们简单地将这些层串在一起:

network-description是神经网络的矢量层。我们的模型包括:

• 输入层
• 具有 ReLU 激活功能的全连接(线性)层
• 辍学者
• 另一个全连接的 ReLU 层
• 通过 softmax 函数传递的大*为 2 的输出层。

在第一层和最后一层，我们都需要指定一个:id。这个 id 指的是我们的网络应该查看的数据图中的键。(回想一下资料图长得像{:data [...] :label [...]})。对于我们的输入层，我们传入:data id 来告诉模型为它的前向传递获取训练数据。在我们最终的网络层中，我们提供了:label作为:id，因此模型可以使用真实标签来计算我们的误差。

培训和评估

这就是变得有点困难的地方。训练函数本身实际上并不复杂——Cortex 为训练提供了一个很好的高级调用，所以我们所要做的就是传入我们的参数(网络、训练和测试数据集等)。).唯一的警告是，系统期望一个有效的“无限”数据集用于训练，但 Cortex 提供了一个函数(infinite-class-balanced-dataset)来帮助我们转换它。

复杂的部分是f1-test-fn。事情是这样的:在训练期间，train-n函数期望被提供一个:test-fn,该函数评估模型的执行情况，并确定它是否应该被保存为“最佳网络”有一个默认的测试函数评估交叉熵损失，但这个损失值不是那么容易解释，它不太适合我们的不平衡数据集。为了解决这个问题，我们将编写自己的测试函数。

但是我们如何测试这个模型的性能呢？分类任务中的标准度量是准确性，但是在像我们这样不平衡的数据集中，准确性是一个相当无用的度量。因为正面(欺诈性)例子仅占我们数据集的 0.172%，即使是专门预测负面例子的模型也能达到 99.828%的准确率。99.828%是一个相当不错的准确率，但如果亚马逊真的使用了这种模式，我们可能会面临犯罪和信用卡欺诈。

谢天谢地，亚马逊没有使用这种模式，我们也不会。一组更能说明问题的指标是精度、回忆和 F1(或更一般的 F-beta)分数。

Precision and recall visualized. Source: https://en.wikipedia.org/wiki/Precision_and_recall

通俗地说，precision 会问这样一个问题:“在我猜测的所有正面例子中，实际上是正面的占多大比例？”回忆提出了这样一个问题:“在所有实际上是积极的例子中，我正确地猜测为积极的占多大比例？”

F-beta 分数(传统 F1 分数的推广)是精确度和召回率的加权平均值，也是以 0 到 1 的范围来衡量的:

当 beta = 1 时，我们得到2 * (precision * recall) / (precision + recall)的标准 F1 度量。一般来说，beta 代表召回应该比 precision 重要多少倍。对于我们的欺诈检测模型，我们将使用 F1 分数作为我们的最高分数来跟踪，但我们也将记录精确度和召回分数来检查平衡。这是我们的f1-test-fn:

该函数在测试集上运行当前网络，计算 F1 分数，并相应地更新/保存网络。它还打印出我们在每个时期的评估指标。如果我们现在在 REPL 中运行(train)，我们会得到一个高分，它看起来像这样:

Epoch: 30
Precision: 0.2515923566878981
Recall: 0.9186046511627907
F1: 0.395

哈哈。这太糟糕了。

数据扩充

问题来了。还记得我说过我们高度不平衡的数据集会给我们带来问题吗？该模型目前没有足够多的正面例子可供借鉴。当我们在 train 函数中调用experiment-util/infinite-class-balanced-dataset时，我们实际上创建了每个正面训练实例的数百个副本来平衡数据集。结果，该模型有效地记忆了那些特征值，而不是实际学习类别之间的区别。

解决这个问题的一种方法是通过数据扩充，在这个过程中，我们根据已经有的例子生成额外的人工数据。为了创建真实的正面训练示例，我们将向每个现有正面示例的特征向量添加随机数量的噪声。我们添加的噪声量将取决于正类中每个特征的方差，因此方差大的特征将被大量噪声增强，反之亦然。

以下是我们的数据扩充代码:

augment-train-ds 获取我们的原始训练数据集，计算必须达到 50/50 类别平衡的扩充数量，并通过基于允许的方差(get-scaled-variances)添加随机噪声向量(add-rand-variance)将这些扩充应用于我们现有的样本。最后，我们将扩充的示例连接回原始数据集，并返回平衡的数据集。

在训练期间，模型将会看到大量不切实际的正面例子，而测试集仍然只有 0.172%的正面例子。因此，虽然模型可能能够更好地了解两个类之间的差异，但它会在测试过程中过度预测正面的例子。为了解决这个问题，我们可以要求一个更高的确定性阈值来预测测试期间的“肯定”。换句话说，我们可以要求模型至少有 70%的把握，而不是要求模型至少有 50%的把握来对一个例子进行分类。经过一些测试，我发现最佳值设置为 90%。这个代码可以在源代码的vec->label函数中找到，并在f1-test-fn的第 31 行被调用。

使用新的、增强的数据集进行训练，我们的高分看起来像这样:

Epoch: 25
Precision: 0.8658536585365854
Recall: 0.8255813953488372
F1: 0.8452380952380953

好多了！

结论

一如既往，该模型仍可改进。以下是后续步骤的一些想法:

• 所有的 PCA 特征都是信息性的吗？查看正例与反例的值在特征中的分布，并删除任何无助于区分这两个类别的特征。
• 有没有其他的神经网络架构，激活函数等。表现更好？
• 有没有不同的数据扩充技术可以表现得更好？
• 与 Keras/Tensorflow/Theano/Caffe 相比，Cortex 中的模型性能如何？

该项目的源代码可以在这里找到。我鼓励你尝试这些后续步骤，测试新的数据集，并探索不同的网络架构(我们在 conv 网上有一个很棒的图像分类示例供参考)。Cortex 正在向它的 1.0 版本推进，所以如果你有任何想法、建议或反馈，一定要让我们知道。黑客快乐！

用 purrr 实现 R 语言中的函数式编程

原文：https://towardsdatascience.com/functional-programming-in-r-with-purrr-469e597d0229?source=collection_archive---------0-----------------------

Want replication without repetition? Use purrr!

当您第一次开始使用 R 时，您可能正在编写简单的代码。

print("Hello world!")5 * 6x <- c(1, 2, 3, 4, 5)

这很好，你正在学习 R 中的字符串、数学和向量！

然后你开始做一些基本的分析。你想看看你是否能找到一些数字的平均值。

employee <- c('John Doe','Peter Gynn','Jolie Hope')
salary <- c(21000, 23400, 26800)
startdate <- as.Date(c('2010-11-1','2008-3-25','2007-3-14'))# form dataframe and take mean of salary column
employ_data <- data.frame(employee, salary, startdate)
mean(employ_data$salary)# output
[1] 23733.33

最终，您有希望接触到tidyverse，并且您会发现这个“为数据科学设计的 R 包的固执己见的集合”是如何使 R 中的数据分析更容易和更可读的！

mtcars %>% 
  group_by(cyl) %>% 
  summarize(mean(mpg))# A tibble: 3 x 2
    cyl `mean(mpg)`
  <dbl>       <dbl>
1  4.00        26.7
2  6.00        19.7
3  8.00        15.1

一切都很顺利！在这一点上，你很可能已经取代了 Excel，还有 SPSS 或其他一些统计软件套件！但是你会遇到一个问题，你需要重复使用一个函数。

您可以使用类似下面的代码来计算一些因变量和一组自变量的单向方差分析:

aov_mpg <- aov(mpg ~ factor(cyl), data = mtcars)
summary(aov_mpg)aov_disp <- aov(disp ~ factor(cyll), data = mtcars)
summary(aov_disp)aov_hp <- aov(hp ~ factor(cyl), data = mrcars)
summry(aov_hpp)aov_wt <- aov(wt ~ factor(cyl), datas = mtcars)
summary(aov_wt)

但是您复制粘贴了 3 次代码，糟糕的是，您犯了一些*的拼写错误，从而引发了一个错误！(以上代码导致错误！)

此外，如果您意识到您实际上想要运行这些 ANOVAs 来计算齿轮数而不是气缸数，会怎么样呢？你必须回去把factor(cyl)呼叫改成factor(gear) 4x！这不是很有效率，而且你更有可能以错误结束，因为你必须多次输入所有的内容！

再举个例子怎么样。

让我们根据气缸的数量，计算重量和每加仑行驶里程之间的线性关系的 R 平方值。

我在下面写了代码，为来自mtcars数据集的 4 缸汽车做了这些。这是一个最坏的情况，你知道一些dplyr代码(dplyr::filter)，但是不习惯使用管道。这很好，你完成了你的目标，但大量的编码！你必须为 6 缸和 8 缸汽车复制这个代码，甚至更多的代码…

# create df for 4 cylinder cars
cyl_4 <- filter(mtcars, cyl == 4)# create a linear model on 4 cyl cars
lm_4 <- lm(mpg ~ wt, data = cyl_4)# get the summ
lm_4_summary <- summary(lm_4)# get the r.squared value
lm_4_r_squared <- lm_4_summary["r.squared"]# check the value
lm_4cyl_r_squared# output
$r.squared
[1] 0.5086326

或者，你可以对管道做同样的事情。输入要少得多，但是对所有 3 个子集都这样做意味着我们必须多次复制粘贴，所以如果你最终想除了 mpg ~ wt 之外还作为 mpg ~ disp 的线性模型这样做，你就必须再复制代码 3 次，再修改 3 次。这可能看起来没什么大不了的，但是一旦你开始按比例增加代码(比如 10+倍或 100+倍，等等)，最终将是一件大事。

lm_4cyl_rsquared <- mtcars %>% 
  filter(cyl == 4) %>%
  lm(mpg ~ wt, data = .) %>% 
  summary() %>% 
  .$"r.squared"# output
[1] 0.5086326

为了解决这个最*化 重复 并进一步复制的问题，我们可以直接进入purrr！要阅读更多关于purrr的内容，Hadley Wickham 推荐了“R for Data Science”中的迭代章节，或者你也可以看看purrr 文档。最后，珍妮·布莱恩在这里有一个很棒的咕噜咕噜教程。你可以单独加载purrr，但是它也作为tidyverse库的一部分被加载。

I used to be all meep — meep — PANIC about purrr!!

now I’m all like
map %>%
map %>%
PARTY!

purrr允许您将 映射 函数到数据。恰当地说，purrr中的基本功能叫做map()！map 函数通过对每个元素应用一个函数并返回一个与输入长度相同的向量来转换它们的输入。

map()的基本参数有: .x —列表或原子向量(逻辑、整数、双精度/数字和字符)
.f —函数、公式或原子向量

基本上map()采用一个函数(.f)并将其应用于数据(.x)。

回到我们从线性模型中获取 R 平方的例子，我们使用下面的代码和purrr。

*mtcars %>%
  split(.$cyl) %>%
  map(~ lm(mpg ~ wt, data = .)) %>%
  map(summary) %>%
  map_dbl("r.squared")# output
4         6         8 
0.5086326 0.4645102 0.4229655*

这将在 5 行代码中根据气缸数量生成我们所有 3 个线性模型的输出！这就是purrr的妙处，函数的高效缩放！

让我们来分解我们的线性模型 R 平方码。

我们采用 mtcars 数据集，根据气缸数量将其分成数据子集，将 mpg by wt 的线性模型应用于每个数据子集，应用汇总函数，然后得出 r.squared 值。然而，尽管purrr是可读的，我们还是需要了解一些使用它的习惯。

*mtcars %>%
  split(.$cyl) %>%
  map(~ lm(mpg ~ wt, data = .)) %>%
  map(summary) %>%
  map_dbl("r.squared")# output
4         6         8 
0.5086326 0.4645102 0.4229655*

对于我们这里的代码，你可能已经注意到我们有一个“.”在代码中放置了两次。这是数据的占位符，我们可以在下面看到。的“.”指示左侧数据，在本例中为mtcars。我们的 split 调用将mtcars数据帧分成 3 个数据帧，每个数据帧存储在一个列表中。这可能看起来很奇怪，但是它允许map循环遍历我们的 3 个数据帧，并在其中的每一个上单独复制lm()函数。

*# piped
mtcars %>% 
  split(.$cyl)# base R
split(mtcars, mtcars$cyl)# output
List of 3
 $ 4:'data.frame': 11 obs. of  11 variables:
  ..$ mpg : num [1:11] 22.8 24.4 22.8 32.4 30.4 33.9 21.5 27.3 26...
  ..$ cyl : num [1:11] 4 4 4 4 4 4 4 4 4 4 ...
  ..$ disp: num [1:11] 108 146.7 140.8 78.7 75.7 ...
  ..$ hp  : num [1:11] 93 62 95 66 52 65 97 66 91 113 ...
  ..$ drat: num [1:11] 3.85 3.69 3.92 4.08 4.93 4.22 3.7 4.08 ...
  ..$ wt  : num [1:11] 2.32 3.19 3.15 2.2 1.61 ...
  ..$ qsec: num [1:11] 18.6 20 22.9 19.5 18.5 ...
  ..$ vs  : num [1:11] 1 1 1 1 1 1 1 1 0 1 ...
  ..$ am  : num [1:11] 1 0 0 1 1 1 0 1 1 1 ...
  ..$ gear: num [1:11] 4 4 4 4 4 4 3 4 5 5 ...
  ..$ carb: num [1:11] 1 2 2 1 2 1 1 1 2 2 ...
 $ 6:'data.frame': 7 obs. of  11 variables:
  ..$ mpg : num [1:7] 21 21 21.4 18.1 19.2 17.8 19.7
  ..$ cyl : num [1:7] 6 6 6 6 6 6 6
  ..$ disp: num [1:7] 160 160 258 225 168 ...
  ..$ hp  : num [1:7] 110 110 110 105 123 123 175
  ..$ drat: num [1:7] 3.9 3.9 3.08 2.76 3.92 3.92 3.62
  ..$ wt  : num [1:7] 2.62 2.88 3.21 3.46 3.44 ...
  ..$ qsec: num [1:7] 16.5 17 19.4 20.2 18.3 ...
  ..$ vs  : num [1:7] 0 0 1 1 1 1 0
  ..$ am  : num [1:7] 1 1 0 0 0 0 1
  ..$ gear: num [1:7] 4 4 3 3 4 4 5
  ..$ carb: num [1:7] 4 4 1 1 4 4 6
 $ 8:'data.frame': 14 obs. of  11 variables:
  ..$ mpg : num [1:14] 18.7 14.3 16.4 17.3 15.2 10.4 10.4 14.7...
  ..$ cyl : num [1:14] 8 8 8 8 8 8 8 8 8 8 ...
  ..$ disp: num [1:14] 360 360 276 276 276 ...
  ..$ hp  : num [1:14] 175 245 180 180 180 205 215 230 150 150 ...
  ..$ drat: num [1:14] 3.15 3.21 3.07 3.07 3.07 2.93 3 3.23 2.76...
  ..$ wt  : num [1:14] 3.44 3.57 4.07 3.73 3.78 ...
  ..$ qsec: num [1:14] 17 15.8 17.4 17.6 18 ...
  ..$ vs  : num [1:14] 0 0 0 0 0 0 0 0 0 0 ...
  ..$ am  : num [1:14] 0 0 0 0 0 0 0 0 0 0 ...
  ..$ gear: num [1:14] 3 3 3 3 3 3 3 3 3 3 ...
  ..$ carb: num [1:14] 2 4 3 3 3 4 4 4 2 2 ...*

类似地，这个“.”in 或 first map 调用是数据的占位符，但在这种情况下，它将循环遍历由前面的管道生成的 3 个数据帧的列表。你可以看到我们得到了一个 3 个lm()输出的列表，我们需要map一个对每个输出的总结调用来访问 R 平方。

*mtcars %>%
  split(.$cyl) %>%
  map(~ lm(mpg ~ wt, data = .))# output
$`4`Call:
lm(formula = mpg ~ wt, data = .)Coefficients:
(Intercept)           wt  
     39.571       -5.647$`6`Call:
lm(formula = mpg ~ wt, data = .)Coefficients:
(Intercept)           wt  
      28.41        -2.78$`8`Call:
lm(formula = mpg ~ wt, data = .)Coefficients:
(Intercept)           wt  
     23.868       -2.192*

接下来，我们将总结函数映射到每个列表项，以获得具有 R 平方值的更清晰的输出。我们现在有了统计输出的其余部分，包括 p 值和 R 平方。

*mtcars %>%
  split(.$cyl) %>%
  map(~ lm(mpg ~ wt, data = .)) %>%
  map(summary)# output
$`4`Call:
lm(formula = mpg ~ wt, data = .)Residuals:
    Min      1Q  Median      3Q     Max 
-4.1513 -1.9795 -0.6272  1.9299  5.2523Coefficients:
            Estimate Std. Error t value Pr(>|t|)    
(Intercept)   39.571      4.347   9.104 7.77e-06 ***
wt            -5.647      1.850  -3.052   0.0137 *  
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1Residual standard error: 3.332 on 9 degrees of freedom
Multiple R-squared:  0.5086, Adjusted R-squared:  0.454 
F-statistic: 9.316 on 1 and 9 DF,  p-value: 0.01374$`6`Call:
lm(formula = mpg ~ wt, data = .)Residuals:
     Mazda RX4  Mazda RX4 Wag Hornet 4 Drive        Valiant       Merc 280 
       -0.1250         0.5840         1.9292        -0.6897         0.3547 
     Merc 280C   Ferrari Dino 
       -1.0453        -1.0080Coefficients:
            Estimate Std. Error t value Pr(>|t|)   
(Intercept)   28.409      4.184   6.789  0.00105 **
wt            -2.780      1.335  -2.083  0.09176 . 
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1Residual standard error: 1.165 on 5 degrees of freedom
Multiple R-squared:  0.4645, Adjusted R-squared:  0.3574 
F-statistic: 4.337 on 1 and 5 DF,  p-value: 0.09176$`8`Call:
lm(formula = mpg ~ wt, data = .)Residuals:
    Min      1Q  Median      3Q     Max 
-2.1491 -1.4664 -0.8458  1.5711  3.7619Coefficients:
            Estimate Std. Error t value Pr(>|t|)    
(Intercept)  23.8680     3.0055   7.942 4.05e-06 ***
wt           -2.1924     0.7392  -2.966   0.0118 *  
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1Residual standard error: 2.024 on 12 degrees of freedom
Multiple R-squared:  0.423, Adjusted R-squared:  0.3749 
F-statistic: 8.796 on 1 and 12 DF,  p-value: 0.01179*

我们上一张地图有点不同。你可以看到我们这次使用了map_dbl。这表明我们希望我们的输出是 dbl 或数字结果。我们得到了很好的命名数字！

*mtcars %>%
  split(.$cyl) %>%
  map(~ lm(mpg ~ wt, data = .)) %>%
  map(summary) %>%
  map_dbl("r.squared")# output
        4         6         8 
0.5086326 0.4645102 0.4229655*

如果我们没有指明map_dbl，而是使用了map，我们将得到一个相同结果的列表。

*mtcars %>%
  split(.$cyl) %>% 
  map(~ lm(mpg ~ wt, data = .)) %>%
  map(summary) %>%
  map("r.squared")# output
$`4`
[1] 0.5086326$`6`
[1] 0.4645102$`8`
[1] 0.4229655*

您也可以使用map_dfr，它将输出绑定到数据帧的行中。

*mtcars %>%
  split(.$cyl) %>% 
  map(~ lm(mpg ~ wt, data = .)) %>%
  map(summary) %>%
  map_dfr("r.squared")# output
# A tibble: 1 x 3
    `4`   `6`   `8`
  <dbl> <dbl> <dbl>
1 0.509 0.465 0.423*

purrr和purrr中的其他函数有无限的应用，这极大地增强了 r 中函数式编程的能力。我希望本指南能激励您将purrr添加到工具箱中，并探索这个有用的tidyverse包！

作为purrr更多应用的一个简短的引子，我将留给你这个例子。我在开始时提到了计算多个变量的 ANOVAs。自己分解一下这个例子，看看大家怎么看！(您可以将这段代码复制粘贴到 R 中，但是需要先加载tidyverse和broom包)。

*mtcars %>%
  mutate(cyl = factor(cyl),
         am = factor(am)) %>%
  select(mpg, disp, hp) %>%
  map(~ aov(.x ~ cyl * am, data = mtcars)) %>%
  map_dfr(~ broom::tidy(.), .id = 'source') %>%
  mutate(p.value = round(p.value, 5))*

最后，我要感谢几个#r4ds slack 社区成员，他们帮助我理解了 purrr: Frank Farach，Michael Kuehn 和 Kent Johnson。

如果你有兴趣加入这个由杰西·梅根领导的社区，在这里查看她的帖子，愿原力与你同在！

数据科学的功能

原文：https://towardsdatascience.com/functions-of-data-science-4afd5341a659?source=collection_archive---------10-----------------------

Data Visualization, a key skill of the For Product function

数据科学是一个宽泛的术语，包括组织内许多不同职能的工作角色。这篇文章介绍了一种在数据科学领域对不同工作职能进行分类的方法，并确定了这些专业的有用技能。

以下是我在职业生涯中体验到的数据科学的四大关键职能，这些职能通常与职位联系在一起:

• 对于产品(推理科学家)
• 作为产品(应用科学家)
• 运营部(系统科学家)
• As 操作(ML 工程师)

我用两个*度来划分工作职能:

• "For" vs "As": 数据科学家是支持正在构建某种东西(For)的团队，还是支持他们自己构建某种东西(As)？
• 产品与运营:数据科学家构建的是面向客户的东西(产品)还是对业务运营至关重要的后端系统(运营)？

第一个*度的关键区别在于数据科学团队是否在构建数据产品。如果一个数据科学团队拥有系统的一部分，那么这个团队就负责实现发现。如果团队与另一个执行调查结果实施的团队合作，那么数据科学就是一个支持角色。第二个*度区分数据科学团队的成果是否对客户直接可见。例如，网飞推荐系统是面向客户的，因为它影响向用户显示的标题和作品，而欺诈检测系统可能对运行在线游戏至关重要，但对用户不可见。

我自己曾在许多不同的职能部门工作过:在 Twitch，我被安插在移动产品团队，负责产品分析(针对产品)，在 Twitch，我负责应用科学，专注于构建面向客户的数据产品(作为产品)，在 Twitch，我监督一名科学家，专注于预测平台的运营指标，如页面加载时间(针对运营)。我还没有在 As 运营部门工作过，但我所知道的最常见的例子是 Quantcast 和 Pinterest 等公司使用的广告竞价系统。

产品的数据科学 这是我在游戏行业经历过的最常见的数据科学角色类别。在 Daybreak Games、EA 和 Twitch，许多数据科学家的角色侧重于分析，为产品经理或游戏制作人提供支持。许多数据科学团队渴望构建数据产品，但是没有工具和基础设施来拥有自己的数据产品。我也见过这种角色被称为推理数据科学家或决策科学家。

该角色的主要职责之一是为团队提供见解，然后用于改进产品和公司路线图。这可以包括围绕战略的高层次分析，或者关于特定产品性能的更多战术分析。出色地履行这一职责通常需要以下技能:

• 探索性分析:这涉及到使用脚本和 SQL 来探索和总结数据集，并回答以下问题:我们能否确定哪些行为对于监控产品健康状况很重要？我们能否确定哪些因素与此行为相关？
• 实验:如果产品团队做出改变，你如何评估影响？这可能包括 A/B 测试和分阶段推出。
• 影响:如果数据科学团队不断地处理关于数据的特别问题，而不是拥有一些自主性来寻找有用的见解，那么这个角色就更像是一个商业智能功能。担任这一角色的成功数据科学家能够获得团队的认可，将他们的发现应用到产品中。

拥有强大的书面和口头交流能力对于所有这些数据科学功能也很重要。这对产品支持功能特别有用，可以影响其他团队。

数据科学作为产品 这是另一个专注于改进产品的数据科学角色，但与之前职能的区别在于，其中一个关键产出是支持面向客户产品的数据产品。在 Twitch，应用科学团队符合这一功能，并使用机器学习来构建产品，如用于军团联盟的冠军探测器。

该职能的职位可能包括应用科学家或机器学习工程师。这也是一个经常向工程经理而不是分析或科学经理汇报的角色。以下是一些对这类角色有用的技能:

• 机器学习:虽然预测建模是所有数据科学功能的先决条件，但这一角色需要更多处理不同类型数据源(包括文本、图像和视频)的实践经验。还需要了解如何扩展这些预测模型。
• 原型制作:在分配大部分资源来构建系统之前，能够构建数据产品的 MVP 是很有用的。
• 软件工程:构建这种规模的数据产品需要能够部署在分布式环境中的系统编程语言的知识。数据产品的代码需要健壮且可*护。

数据产品通常是实时系统，该职能部门的数据科学家需要能够扩展预测模型的知识。

运营数据科学 我在 Twitch 的时候，这个功能还处于起步阶段。该职位的主要职责是了解不同的因素如何影响我们产品的运营指标，如页面加载时间。我们将这个角色称为系统科学家，因为它需要对我们的基础设施和可能影响各种系统度量的各种因素建立深刻的理解。

这一特殊角色的重点是系统性能下降的根本原因分析，但该职能更广泛的重点是建立模型，以更好地了解各种内部和外部因素如何影响系统。它需要以下技能:

• 系统基础设施:理解不同的因素如何影响运营指标需要对用于构建产品的系统和基础设施有深入的了解。例如，跟踪页面负载需要了解 cdn、缓存和 API 调用依赖关系。
• 预测:为了检测指标中的异常，有必要建立基线和预期行为。预测可以用来模拟影响系统行为的因素。
• 警报:这个角色可能还负责确定何时向其他团队发出异常系统行为的警报。重要的是能够设置何时提醒团队的阈值，而不会有太多的误报。

系统科学是一个较新的工作职能，比其他数据科学角色需要更多的基础设施知识。

数据科学作为运营 这是一个数据科学角色，通常是工程团队的一部分，目标是构建运营业务所需的数据产品，而不是面向客户的产品。构建自动广告竞价系统是这种角色的一个例子，构建欺诈检测系统是另一个例子。与数据科学产品组的主要区别在于，这些系统往往更加自动化。例如，由于数据的规模和实时要求，广告竞价系统可以使用相同的系统进行培训和生产，而面向客户的数据产品通常可以在较*的规模上进行原型化和迭代。

以下是一些对此功能有用的技巧:

• 分布式系统:该功能需要构建分布式系统的知识，这可能包括 Spark 或其他用于扩展流程的云技术。在意外收获，我们使用云数据流。
• 在线学习:这些系统的实时要求通常意味着批量学习过程是不合适的，相反，需要利用在线方法来更新模型。
• DevOps: 构建运行业务功能的数据产品意味着*护这些系统，而这是 DevOps 责任最大的数据科学角色。

这是一个我没有经验的功能，但我认为它是数据科学中最有价值的角色之一。

结论 数据科学术语可能执行各种不同的功能。为团队制定一个清晰的章程是很重要的，这样你就能够恰当地雇佣员工并支持组织的需求。这些职能需要不同的技能组合，数据科学家的首选职能可能会在职业生涯中发生变化。

本·韦伯是意外收获数据的首席数据科学家，我们的任务是确定世界上每个家庭的净资产。我们目前正在招聘产品数据科学和产品数据科学职能部门的角色。

R 和 rvest 函数:外行指南

原文：https://towardsdatascience.com/functions-with-r-and-rvest-a-laymens-guide-acda42325a77?source=collection_archive---------2-----------------------

如果有一个主题在使用 R 后很难理解，那就是函数。从编写函数到学习如何调试函数，一切都没有明确的指导。此外，已经出现了一些旨在帮助完成这项任务的工具，但是在解决您的问题时，似乎很难理解如何利用这些工具。这篇博客旨在让您了解 R 中有哪些函数，如何在任务中使用它们，并在 RStudio 中轻松调试它们，以诊断到底发生了什么。

最近，我有机会去苹果酒节，学习和尝试新的苹果酒。我不是苹果酒的最大粉丝，所以很自然地，我选择尝试几乎所有可用的啤酒，并想比较我品尝的味道。如果有人问我的味蕾，我会说我喜欢尚迪和*麦啤酒。我尝过的啤酒都不太合我的口味，但不知何故，味道比我预期的要好。如果能有一种方法来比较这两种啤酒，那肯定会很有帮助。我一直想知道为什么我喜欢美国淡啤酒，甚至是一桶啤酒。使用 rvest，我们可以很容易地从 RateBeer 中获取每种啤酒的必要数据，以帮助相互比较，确定它们可能有哪些相似之处。

但是首先…一些我们需要处理的事情

在我们开始之前，需要建立一些基本规则，这样你就可以让自己走上正确的轨道，完成手头的任务。一开始，通过编程与网络互动很容易让人觉得是未知的领域，就像喝第一杯啤酒一样:我在哪里，我怎么会在这里？但是，不要害怕，因为这个博客将为你提供资源，使你不会迷失在这个深渊中。

工具时间:

为了从这篇博客中获得最大的价值，你需要以下工具:

• RStudio
• Visual Studio 代码
• 基特克拉肯

你可能会问，我们为什么需要这些？用正确的工具武装自己有时是成功的一半:如果你没有解决问题的必要工具，很难弄清楚如何理解手头的问题。除了这些工具，我还强烈建议你考虑使用沙盒环境，使用 Docker 或 RStudio Cloud，因为 R 在不同操作系统上的编码存在一些问题。如果您想了解更多关于如何为 R 创建自己的自定义沙盒环境的信息，您可以查看这个博客了解更多信息，或者查看 RStudio Cloud。

https://medium . com/@ peterjgensler/creating-sandbox-environments-for-r-with-docker-def 54e 3491 a 3

https://rstudio.cloud/

概括地说，有两种获取 web 数据的通用方法:

• API 的——API 被称为应用编程接口
• 网络抓取——更像是一种暴力的方法

好吧，那么 API 到底是什么呢？我应该用它吗？

API 是一个信使，它接收请求，然后向您返回响应

API 已经设置好了，因此您可以轻松地与服务进行交互。假设我想要获取明*阿波利斯的火灾数据。

[## 明*阿波利斯确认 2013 年火灾-数据集

有关此数据的问题，请联系

数据世界](https://data.world/minneapolismn/8baeeaebfd9d489d9ee6c9ae0fed3988-0)

如果我愿意，我可以通过 data.world 的 API 轻松获取这些数据:

[## API 文档

为所有 OAS (Swagger)和 RAML 规范托管 API 文档。由 Stoplight.io 提供动力。文档、模拟、测试…

apidocs.data.world](https://apidocs.data.world/v0/data-world-for-developers)

另一方面，网络抓取是一种更加暴力的获取网络数据的方式。并不是所有的网站都有 API 可以使用，这意味着可能需要搜索才能找到。我们如何检查我们是否能抓取一个网页？简单，检查 robots.txt 文件。有关 robots.txt 文件用途的更多信息，请观看此视频:

对于我们的例子，我们使用的是网站 RateBeer，所以让我们看看他们的文件，看看是否有限制:

【https://www.ratebeer.com/robots.txt

User-agent: Mediapartners-Google
Disallow:

User-agent: *
Allow: /

查看 RateBeer 的 robots.txt 文件，我们可以看到它们允许抓取，因为它们不允许任何东西，所以我们可以继续。

吃个三明治，喝杯咖啡，然后去看下面列出的 RStudio 的网络研讨会。RStudio 有两个很棒的网络研讨会，分别涉及 API 和深度网络搜集，我们希望第 2 部分:

[## 从 web 部件 2 中提取数据

从 web 中提取数据第 2 部分下载资料描述互联网是一个数据宝库，如果你…

www.rstudio.com](https://www.rstudio.com/resources/webinars/extracting-data-from-the-web-part-2/)

网上研讨会的幻灯片可在此处找到:

https://github . com/r studio/webinars/blob/master/32-Web-Scraping/02-Web-Scraping . pdf

在我看了上面列出的网上研讨会后，我对所有这些话题都很迷茫，这是理所当然的。学习用于设计网站的网络技术不是一件容易的事情，在刚开始的时候会非常困难。如果您想了解更多资源，我强烈建议您观看《用户 2016》中的这些非常相似的幻灯片，并做好准备:

https://github . com/ropensci/user 2016-tutorial/blob/master/03-scraping-data-without-an-API . pdf

大多数用 R 开发的 web 抓取包都是为了抓取网页的 HTML 或 CSS 部分，而不是呈现在浏览器中的 Javascript 内容。Javascript 编写起来要复杂得多，可以用 RSelenium 完成，但不适合胆*的人:

[## 鲁本斯西/硒元素

RSelenium——Selenium 远程 WebDriver 的 R 客户端

github.com](https://github.com/ropensci/RSelenium)

理解和奠定基础

为了得到我们的数据，我们首先需要设置一些函数来获取每种啤酒的变量。现在，为了简单起见，我只挑选了三瓶啤酒，但是我希望这个例子能够说明一个函数在投入使用时是多么强大。让我们来看看:

为了比较每种啤酒，我们首先需要找到一种方法来获得每种啤酒的属性。Ratebeer 为我们提供了每种啤酒的基本统计数据:

Pollyanna Eleanor Beer Descriptive statistics

正如您在上面看到的，我们对每种啤酒的描述性统计很感兴趣，但是我们如何找到与该元素的确切联系呢？由于这些网页上没有关于每种啤酒的 JavaScript，我们可以简单地利用工具找到我们感兴趣的元素的 CSS 或 Xpath。最简单的方法是

现在，为了从网站中提取数据，我们首先需要下载网页，然后尝试通过 CSS 标签或 xpath 选择我们感兴趣的元素。毫无疑问，这可能是一个痛苦的过程，原因有二:

• CSS 标签应该(但没有)与 rvest 一起工作，因为 selectr 有一些问题(这促使找到 CSS 标签):https://github . com/sjp/selectr/issues/7 # issue comment-344230855
• 或者，您不知道所选择的路径是否是您想要的元素的正确路径，这种情况比我愿意承认的更常见

现在，起初，这似乎是一个几乎不可能的任务，但不用担心。我们仍然可以使用 xpath 来选择我们感兴趣的内容，以便进一步使用。

有两个工具非常有助于为您希望提取的元素找到正确的 XPath:Selectorgadget 和 chrome developer tools。

选择器*工具

Selectorgadget 是一个点击式 CSS 选择器，专门用于 Chrome。只需安装 chrome 扩展，然后点击你感兴趣的元素就可以了。这将选择与该对象相关的所有元素。接下来，选择你不想要的黄色的东西。这就对了。

Using SelectorGadget

有关 SelectorGadget 的更多信息，请访问:

[## SelectorGadget:指向并单击 CSS 选择器

SelectorGadget 是一个开源工具，使复杂网站上 CSS 选择器的生成和发现变得轻而易举…

selectorgadget.com](http://selectorgadget.com/)

如果您需要额外的示例，也可以在这里找到详细的演练:

[## 选择 orgadget

Selectorgadget 是一个 javascript bookmarklet，它允许你交互式地计算出你需要什么样的 css 选择器…

cran.r-project.org](https://cran.r-project.org/web/packages/rvest/vignettes/selectorgadget.html)

Chrome 开发者工具

如果从 SelectorGadget 获取正确的 xpath 有问题，也可以尝试使用 Chrome 开发者工具，它们对用户非常友好。

只需点击视图-开发者工具，这将加载开发者工具。

接下来，点击鼠标*按钮与网页互动。这将使您的光标能够显示是什么代码在驱动页面上的每个元素。

在下面的截图中，我们可以看到我们用鼠标选择的内容，以及驱动该特定元素的相应代码。

Chrome Developer Tools selecting element on page

点击上面的蓝色区域，如上所示。在本例中，我们对 stats 容器感兴趣，因为它包含了我们想要比较的指标。这将把你锁定在那个元素上，这样你的光标就不会试图为其他元素选择 HTML 或 CSS。现在右键单击 html 代码中突出显示的区域(红框)，然后选择 copy->Copy XPath。这将允许您找到特定元素在页面上的最具体路径。

完美！现在我们有了元素的 xpath，我们可以开始编写从 xpath 中提取数据的函数了。

设置功能

让我们总结一下到目前为止我们所取得的成就。至此，我们首先确定了我们到底想要完成什么:收集每种啤酒的基本统计数据。然后我们找到了必要的 xpath，它标识了网页上我们感兴趣的元素。使用 rvest，我们可以编写一个脚本，允许我们

在 RStudio 的幻灯片(演讲开始时的链接)中概述了，在我们的功能中，对于给定的网页，我们需要完成三个“核心活动”。仔细想想，它们是有道理的:

• 拉下网页
• 确定我们想要的元素
• 提取并拉出元素
• 整理元素使其可用

rvest 包中有三个函数允许我们轻松地执行这些步骤。然而，由于我们想要在多个 URL 上执行这些步骤，我们可以像这样设置我们的函数:

library(magrittr) #for pipes
library(dplyr) #for pull function
library(rvest) #get html nodes
library(xml2) #pull html data
library(selectr) #for xpath element
library(tibble)
library(purrr) #for map functions
library(datapasta) #for recreating tibble's with ease#Sample Data
sample_data <- tibble::tibble(
  name = c("pollyanna-eleanor-with-vanilla-beans","brickstone-apa","penrose-taproom-ipa","revolution-rev-pils"),
  link = c("[https://www.ratebeer.com/beer/pollyanna-eleanor-with-vanilla-beans/390639/](https://www.ratebeer.com/beer/pollyanna-eleanor-with-vanilla-beans/390639/)",
           "[https://www.ratebeer.com/beer/brickstone-apa/99472/](https://www.ratebeer.com/beer/brickstone-apa/99472/)",
           "[https://www.ratebeer.com/beer/penrose-taproom-ipa/361258/](https://www.ratebeer.com/beer/penrose-taproom-ipa/361258/)",
           "[https://www.ratebeer.com/beer/revolution-rev-pils/360716/](https://www.ratebeer.com/beer/revolution-rev-pils/360716/)"
  )
)#the function:get_beer_stats1 <- function(x){
    read_html(x) %>%
    html_nodes(xpath = '//*[[@id](http://twitter.com/id)="container"]/div[2]/div[2]/div[2]') %>%
    html_text()
}

我们还可以编写函数，使其在值发生变化时更加明确，从而更容易在 RStudio 中单步调试:

get_beer_stats2 <- function(x){
  url <- read_html(x)
  html_doc <- html_nodes(url, xpath = '//*[[@id](http://twitter.com/id)="container"]/div[2]/div[2]/div[2]')
  stats <- html_text(html_doc)
  return(stats)
}

等等，我想我们应该确保每一个动作都被精确地记录下来，这样他们的电脑就能理解了？难道我们不需要某种 for 循环，在每个 URL 之后作为一个计数器来增加吗？为什么我们不使用 dplyr::pull 命令将向量从数据帧中直接取出来进行迭代呢？

使用 purrr 的一个问题是理解如何以正确的心态思考你所面临的问题。思考这个问题，我们可以从以下几个角度着手:

• 我有一个 URL 的数据框架，我想迭代每一行(或 URL)，并为每个 URL 执行一组给定的操作
• 我有一个包含一列 URL 的数据框架，对于每个 URL，我想对每个 URL 进行操作
• 将数据帧中的 URL 列视为一个向量，我希望对向量中的每个元素进行操作

你看，purr 的主要工作函数 map，被设计成迭代包含一堆元素的对象，然后允许你作为用户专注于写一个做一些动作的函数。在 R 中，大多数时候这些对象要么是列表、列表列，要么只是一个向量。这样，它允许您拥有这样的工作流:

• 确定您想对给定的元素做什么
• 把“收据”变成一个函数
• 在对象上应用带有 purr 的配方(如有必要，创建一个新列来存储结果)

好了，现在让我们将刚刚创建的函数应用于我们的数据，看看它是否有效:

sample_data_rev <- sample_data %>%
  mutate(., beer_stats = map_chr(.x = link, .f = get_beer_stats1))

在我们继续之前，让我们分析一下到底发生了什么。首先，我们用管道连接 dataframe，并说我们想用 mutate 添加一个新列。接下来，我们使用 map_chr(或 vector)创建一个定义为字符列的新列，然后应用我们的自定义函数。

在 RStudio 中获取数据和调试

既然我们的核心函数已经定义好了，如果我们想看看值是如何变化的，我们可以使用 RStudio 遍历我们的函数。只需转到以下位置即可启用调试模式:

调试->出错->错误检查器

接下来，简单地用 debug 包装您的函数，如下所示:

debug(
get_beer_stats1 <- function(x){
    read_html(x) %>%
    html_nodes(xpath = '//*[[@id](http://twitter.com/id)="container"]/div[2]/div[2]/div[2]') %>%
    html_text()
}
)

当运行调用函数的代码时，将进入调试模式，以便查看代码中的值是如何变化的:

sample_data_rev <- sample_data %>%
  mutate(., beer_stats = map_chr(.x = link, .f = get_beer_stats1))

扩展我们的例子，让我们说，我们有可能导致一些打嗝的网址。我们如何创建一个函数来轻松处理这些错误呢？

purr 为我们提供了错误处理函数，来包装我们的函数，以优雅地处理错误。我们可以使用 possibly 函数添加错误处理:

sample_data_rev <- sample_data %>%
  mutate(., beer_stats = map_chr(.x = link,    possibly(get_beer_stats1, otherwise= "NULL")))

可能非常类似于 try-catch，它允许我们用不同的错误处理函数来包装我们创建的函数。乍一看，这可能有点令人困惑，但是一旦您正确地设置了它，这是有意义的。

编码和 R:进入深渊

在我们继续前进之前，值得注意的是，下面是我称之为“深渊”的地方，或者叫魔多。注意，这不适合胆*的人，所以如果你觉得你已经准备好了，那就继续吧。否则，去做个三明治，*睡一会儿。

Mordor, aka how Encoding feels in R

对我来说，用 R 编码让我想起了《指环王》中的魔多。这就像一些永无止境的坑，几乎濒临死亡。不过不用担心，你会得到很好的照顾。我们走吧。

我们有了数据，应该都准备好清理了，对吧？没有。为什么会这样呢？前面我们提到我们的工作流程由以下步骤组成:

• 拉下网页
• 确定我们想要的元素
• 提取并拉出元素
• 整理元素使其可用

这种工作流程的部分问题是，它假设一旦我们从网页中取出数据，它就应该“准备好，马上下船”，不幸的是，来自 web 的数据并非如此。你看，来自网络的数据必须被编码，发现甚至检测编码问题可能是一个真正的麻烦，因为你可能不会发现，直到你的分析过程的更下游，像我一样。

在我们进入下一步之前，我鼓励你先阅读下面的文章。这将有助于为理解我们的文本数据到底出了什么问题以及帮助检测问题根源的策略打下基础:

[## 面向初学者的字符编码

什么是字符编码，我为什么要关心？

www.w3.org](https://www.w3.org/International/questions/qa-what-is-encoding) [## r 代表数据科学

这本书将教你如何用 R 做数据科学:你将学习如何把你的数据放入 R，把它放入最…

r4ds.had.co.nz](http://r4ds.had.co.nz/data-import.html#readr-strings)

重复一下，我们的计算机(或机器，真的)以字节为单位存储数据。然后，这些字节被编码成不同的语言环境，如 UTF-8 或 ANSI。根据您如何设置您的平台(或机器)的本机编码，R 可能会给您带来很多麻烦。根据经验，无论您的平台的原生编码是什么，只要有可能，尝试与 UTF-8 接口总是最好的，因为它导致的困难最少。找出编码问题的根源可能是一项挑战，因此以下工具将有所帮助:

• textclean 包—用于检测编码文本的问题
• rvest —如果不确定，适合尝试猜测编码
• data pasta——有利于轻松地重新创建 tibble
• stringi- brute force 查看 unicode 是否与我们正在查看的内容匹配，并清除它
• base::charToRaw —查看字符串的原始字节
• 工具::showNonASCII 和 iconv 显示非 ASCII 字符
• Unicode 检查员-https://apps.timwhitlock.info/unicode/inspect
• Unicode 表-【http://www.utf8-chartable.de/

我们的一般工作流程如下:

• 检测或识别文本中的问题
• 尝试修复编码

在我们继续之前，我强烈建议您确保可以通过 Tools-Global Options-Code 查看 RStudio 中的空白，并显示空白字符。

Configuring whitespace characters in RStudio

此外，进入 Visual Studio 代码，并通过查看-切换渲染空白进行同样的操作。

Toggle Render Whitespace in Visual Studio Code

让我们举一*段代码作为例子。假设你得到这个数据:

bad_data <- tibble::tribble(
 ~id, ~value,
 390639, “RATINGS: 4 MEAN: 3.83/5.0 WEIGHTED AVG: 3.39/5 IBU: 35 EST. CALORIES: 204 ABV: 6.8%”,
 99472, “RATINGS: 89 WEIGHTED AVG: 3.64/5 EST. CALORIES: 188 ABV: 6.25%”,
 361258, “RATINGS: 8 MEAN: 3.7/5.0 WEIGHTED AVG: 3.45/5 IBU: 85 EST. CALORIES: 213 ABV: 7.1%”
)> Encoding(bad_data$value)
[1] "UTF-8" "UTF-8" "UTF-8"

我们如何检测它是否有问题？从上面我们可以看到，数据编码为 UTF-8，所以我们应该没问题……对吗？这不就是网页告诉我们的编码吗？是的，但是深入研究数据，似乎有一些字符没有被正确转换。那么，我们究竟如何“纠正”一个坏的 UTF-8 文件呢？

第一圈火:发现问题

首先，我们可以尝试使用 datapasta 重新创建数据帧，如下所示，希望我们能看到一些东西

datapasta::tribble_paste(bad_data)

幸运的是，当我们这样做时，我们可以看到一些有趣的事情:

Odd red spaces in our data?

好的，所以在我们的数据中有一些奇怪的红色空格…那到底意味着什么呢？如果我们将输出粘贴到 Visual Studio 代码中，我们可以看到一些特殊的东西:

看了上面的截图，好像有点不对劲。为什么蓝色箭头的地方没有空格？似乎有点奇怪。假设我们想看的不仅仅是 3 瓶啤酒，而是几百瓶，也许几千瓶啤酒，这可行吗？当然，但是一定有更好的方法，而且有:

#Truncated Output
textclean::check_text(bad_data$value)

=========
NON ASCII
=========

The following observations were non ascii:

1, 2, 3

The following text is non ascii:

1: RATINGS: 4   MEAN: 3.83/5.0   WEIGHTED AVG: 3.39/5   IBU: 35   EST. CALORIES: 204   ABV: 6.8%
2: RATINGS: 89   WEIGHTED AVG: 3.64/5   EST. CALORIES: 188   ABV: 6.25%
3: RATINGS: 8   MEAN: 3.7/5.0   WEIGHTED AVG: 3.45/5   IBU: 85   EST. CALORIES: 213   ABV: 7.1%

*Suggestion: Consider running `replace_non_ascii`

textclean 包是 qdap 包的衍生包，设计用于处理文本数据，但需要 rJava 才能正常工作。textclean 是来自 qdap 生态系统的一个端口，并且更轻便，因此允许我们使用它来检测我们文本的问题。正如我们在上面看到的，有很多错误，但这允许我们验证非 ascii 字符存在于我们的文本中，因此如果我们现在不处理它们，会引起我们的头痛。

现在，如果你和我一样，试图掌握字符串中到底发生了什么可能是一个挑战:我们如何知道这些问题发生在字符串中的哪个位置？幸运的是，base-r 提供了一些优秀的工具来帮助检测这一点:

> iconv(bad_data$value[[2]], to = "ASCII", sub = "byte")
[1] "RATINGS: 89<c2><a0><c2><a0> WEIGHTED AVG: 3.64/5<c2><a0><c2><a0> EST. CALORIES: 188<c2><a0><c2><a0> ABV: 6.25%"
> tools::showNonASCII(x$value[[2]])
1: RATINGS: 89<c2><a0><c2><a0> WEIGHTED AVG: 3.64/5<c2><a0><c2><a0> EST. CALORIES: 188<c2><a0><c2><a0> ABV: 6.25%

工具包和 R 中的 iconv 都让我们看到，果然，这里出现了一些由<>指示的奇怪字符。

如果您想更好地了解这些字符到底是什么，我们可以将 datapasta 的 tribble_paste 的原始输出插入到 Tim Whitlock 的 Unicode Inspector 中，我们可以看到，毫无疑问，我们有一个名为“No Break Space”的字符

No Break Space

和各自的 UTF-16 代码。为了验证，我们可以插入带有前缀\u 的代码，以及上面的代码，果然:

str_detect(bad_data$value[[2]], “\u00A0”)

第二个火环:修复 UTF-8

有用！现在我们需要想办法修复绳子。要修复字符串，我们可以通过 rvest、textclean 或 stringi:

bad_data <- tibble::tribble(
 ~id, ~value,
 390639, “RATINGS: 4 MEAN: 3.83/5.0 WEIGHTED AVG: 3.39/5 IBU: 35 EST. CALORIES: 204 ABV: 6.8%”,
 99472, “RATINGS: 89 WEIGHTED AVG: 3.64/5 EST. CALORIES: 188 ABV: 6.25%”,
 361258, “RATINGS: 8 MEAN: 3.7/5.0 WEIGHTED AVG: 3.45/5 IBU: 85 EST. CALORIES: 213 ABV: 7.1%”
)
#' for reference
#' [https://stackoverflow.com/questions/29265172/print-unicode-character-string-in-r](https://stackoverflow.com/questions/29265172/print-unicode-character-string-in-r)
#' stringi also uses mostly UTF-8, which is very comforting to know
#'[https://jangorecki.gitlab.io/data.table/library/stringi/html/stringi-encoding.html](https://jangorecki.gitlab.io/data.table/library/stringi/html/stringi-encoding.html)
str_detect(x$value, "\u00A0")
ex1 <- textclean::replace_non_ascii(bad_data$value)
ex2 <- rvest::repair_encoding(bad_data$value)

textclean 将消除它检测到的值，而 rvest 将尝试保留该值。虽然 rvest 可以(而且确实提供了这种能力)，但它并没有很好地可靠地清理文本数据。相反，stringi 为我们提供了函数 str_trans_general，它允许我们保持每个字符之间的三个空格不变。这将允许我们稍后使用这些空格作为分隔符来进一步清理数据。

bad_data$value <- stringi::stri_trans_general(bad_data$value, “latin-ascii”)

放大:用更大的数据量进行编码

现在，这听起来很棒，但也许你和我一样，发现大量啤酒数据(比如 2GB)，并发现可能有一些编码问题…..我们可以尝试在导入后运行一个函数来清理数据，但这可能需要相当多的时间。有没有更好的方法来处理这个烂摊子？是的，有。输入 iconv:

[## ICONV

iconv 程序将文本从一种编码转换为另一种编码。更准确地说，它从编码转换…

www.gnu.org](https://www.gnu.org/savannah-checkouts/gnu/libiconv/documentation/libiconv-1.15/iconv.1.html)

iconv 是一个 GNU 命令行实用程序，它帮助强制将数据转换成正确的形式，同时还试图保留尽可能多的数据。

让我们以这里的数据为例:

[## RateBeer 评论 petergensler 数据集

来自 https://snap.stanford.edu/data/web-RateBeer.html 的数据

数据世界](https://data.world/petergensler/ratebeer-reviews)

现在，乍一看，数据似乎有点乱，但让我们集中精力尝试将数据转换成 UTF-8。首先，让我们使用 r 中的 gunzip 将文件解压缩到一个目录中。

#Gunzip Ratebeer 
gunzip(filename = “~/petergensler/Desktop/Ratebeer.txt.gz”,
 destname = “~/petergensler/Desktop/Ratebeer.txt”, remove= FALSE)

这个命令中的~仅仅意味着相对于您机器上的主目录。只需在终端中键入 cd，您就会被带到您的主目录。

接下来，我们可以使用 bash 通过 wc -l 确定这个文件中有多少行，我们还可以看到 bash 认为 file -I 的编码是什么:

wc -l Ratebeer.txt22212596 Ratebeer.txtfile -I Ratebeer.txtRatebeer.txt: text/plain; charset=utf-8

好的，这看起来没问题，但是有 2200 万行，修复起来会很麻烦。iconv 使这一过程变得轻而易举:

Approach 1:
iconv −f iso−8859−1 −t UTF−8 Ratebeer.txt > RateBeer-iconv.txtApproach 2:
iconv -c -t UTF-8 Ratebeer.txt > Ratebeer-iconv.txt

对于方法一，我们尝试获取我们认为应该是什么样的文件，并指定我们希望它是 UTF-8，并尝试覆盖它。方法二是一种更加暴力的方法，因为我们简单地告诉 iconv 我们想要转换到 UTF-8，并创建一个新文件。沃伊拉！如果需要的话，我们现在可以以原始行的形式读取文件，没有任何问题，这都要感谢 iconv。

需要注意的一点是，虽然 R 确实有一个 iconv 函数，但我发现命令行实用程序更适合我的需要，您可以简单地在 RMarkdown notebook 中放一个 bash 块。使用命令行。

第 5 部分:清理数据

现在我们已经获得了数据，并清理了编码，让我们看看是否可以尝试将基本统计数据放入它们各自的列中。乍一看，这似乎很简单，因为我们只需要在一个分隔符上拆分统计数据列，这应该很好。但是当然，我的一种啤酒没有另一种那么多的元素，因此乍看之下造成了很大的破坏(好像编码已经够有挑战性了)。

简单回顾一下，我们的数据如下:

bad_data <- tibble::tribble(
                                    ~name,                                                                         ~link,                                                                                      ~beer_stats,
   "pollyanna-eleanor-with-vanilla-beans",  "[https://www.ratebeer.com/beer/pollyanna-eleanor-with-vanilla-beans/390639/](https://www.ratebeer.com/beer/pollyanna-eleanor-with-vanilla-beans/390639/)",  "RATINGS: 4   MEAN: 3.83/5.0   WEIGHTED AVG: 3.39/5   IBU: 35   EST. CALORIES: 204   ABV: 6.8%",
                         "brickstone-apa",                         "[https://www.ratebeer.com/beer/brickstone-apa/99472/](https://www.ratebeer.com/beer/brickstone-apa/99472/)",                           "RATINGS: 89   WEIGHTED AVG: 3.64/5   EST. CALORIES: 188   ABV: 6.25%",
                    "penrose-taproom-ipa",                   "[https://www.ratebeer.com/beer/penrose-taproom-ipa/361258/](https://www.ratebeer.com/beer/penrose-taproom-ipa/361258/)",   "RATINGS: 8   MEAN: 3.7/5.0   WEIGHTED AVG: 3.45/5   IBU: 85   EST. CALORIES: 213   ABV: 7.1%",
                    "revolution-rev-pils",                   "[https://www.ratebeer.com/beer/revolution-rev-pils/360716/](https://www.ratebeer.com/beer/revolution-rev-pils/360716/)",   "RATINGS: 34   MEAN: 3.47/5.0   WEIGHTED AVG: 3.42/5   IBU: 50   EST. CALORIES: 150

理解手头任务的部分关键是双重的——我们希望将数据拆分到每个列中，但是使用:来保持键-值对关系。

final_output <- bad_data %>%
  # create a new list column, str_split returns a list
  mutate(split = str_split(string, "  ")) %>%
  # then unnest the column before further data prep
  unnest() %>%
  # you can now separate in a fixed 2 length vector 
  separate(split, c("type", "valeur"), ": ") %>%
  # then get the result in column with NA in cells where you did not    have value in string
  spread(type, valeur) %>%
  rename_all(str_trim) %>%
  select(-string, -link)
#> # A tibble: 3 x 6
#>     ABV `EST. CALORIES`   IBU     MEAN `WEIGHTED AVG` RATINGS
#> * <chr>           <chr> <chr>    <chr>          <chr>   <chr>
#> 1  6.8%             204    35 3.83/5.0         3.39/5       4
#> 2  7.1%             213    85  3.7/5.0         3.45/5       8
#> 3 6.25%             188  <NA>     <NA>         3.64/5      89

请理解，当我第一次运行这个脚本时，第一行代码一开始就失败了--这是由于编码问题，但是直到实际尝试使用 spread 函数时，我才收到错误消息。

起初，这看起来有点复杂，尤其是如果您不熟悉 list-column 的话。当我第一次看这段代码时，str_split 似乎有一个非常奇怪的行为，几乎是代码的一个不必要的负担。取消 list-column 嵌套几乎创建了一个类似笛卡尔的连接，它接受每条记录，然后使每一行都有每一个值的每一种可能的组合，从而使传播和动态传播成为可能。

现在我们的表看起来像这样:

> head(final_output)
# A tibble: 4 x 7
                                  name   ABV `EST. CALORIES`   IBU     MEAN RATINGS `WEIGHTED AVG`
                                 <chr> <chr>           <chr> <chr>    <chr>   <chr>          <chr>
1                       brickstone-apa 6.25%             188  <NA>     <NA>      89         3.64/5
2                  penrose-taproom-ipa  7.1%             213    85  3.7/5.0       8         3.45/5
3 pollyanna-eleanor-with-vanilla-beans  6.8%             204    35 3.83/5.0       4         3.39/5
4                  revolution-rev-pils    5%             150    50 3.47/5.0      34         3.42/5

由此，有趣的是，收视率最高的啤酒没有平均评论，但波利安娜似乎得分最高。

结束语

当你读完这篇文章时，我会鼓励你尝试喝点啤酒(或你选择的饮料)，并尝试收集相关数据。你注意到了什么？ABV(饮料能有多烈)和啤酒的平均点评分数有关联吗？我希望这篇教程能够帮助你深入了解如何在尝试解决问题时利用 R，并且你已经了解了更多关于 R 编码的知识，以及在面临这些挑战时有所帮助的工具。我在下面概述了我的一些想法，因为我一直在思考这些数据是如何在这么多方面挑战我的，不仅仅是在 R 方面，而是在我的个人工作流程中。

编码

在过去的几天里，我一直在和 R 一起工作，我一直注意到的一件事是，当 R 失败时，很难明确地告诉它何时失败以及失败的原因。作为一个 R 的新手，我认为这使得诊断什么工具可能会失败变得非常困难，因为 R 不会很快失败，也不会很难失败。我们字符串的编码:

• 读取 html 失败了吗？
• 仅仅是 tidyr 与 UTF-8 有问题，还是这是一个更深层次的问题？
• 如果 base r 有如此多的编码问题，这是任何项目的“坚实基础”吗，无论是否与工作相关？

经历了大量的编码问题后，很明显，如果你使用的是 Windows，编码对 R 来说可能是一场灾难。对我个人来说，我实际上看了 TIBCO 发布的另一个版本的 R，名为 TERR:

[## TIBCO 企业版 R 运行时

在 TIBCO Enterprise Runtime for R 文档中，您可以找到关于创建和分发…

docs.tibco.com](https://docs.tibco.com/products/tibco-enterprise-runtime-for-r)

因为太多 base-r 的编码问题太麻烦了。这些问题虽然很*，但我认为几乎传达了一个关于 R 核心的信息:它根本不是一个稳定的基础。从开发的角度来看，使用函数而不信任输出是非常不利的。tidyverse 无疑为新来者提供了许多正在开发的新包，但我认为这提出了一个好问题:您应该在生产管道中使用 R 吗，或者甚至是为了分析的目的？当你没有碰到这些问题的时候，一切看起来都很顺利，但是一旦你碰到了，调试起来真的很痛苦，尤其是对于一个语言新手来说。

咕噜图 vs dplyr:骑行线

乍一看，purrr 似乎是一个理想的包，但是如果没有正确的用例，就很难使用它。在我们的例子中，我们有 URL，我们想应用一个函数。

然而，虽然 purrr 被设计为将函数应用于对象，但大多数时候我们只是对应用函数感兴趣，比如通过谓词函数将 POSIX 转换为 datetime:

library(lubridate)
library(dplyr)
x <- data.frame(date=as.POSIXct("2010-12-07 08:00:00", "2010-12-08 08:00:00"),
                orderid =c(1,2))
str(x)
x <- mutate_if(x, is.POSIXt, as.Date)
str(x)

当您需要使用自定义函数迭代元素时，Purrr 确实很出色，但是如果您所做的只是在工作流中使用 mutate_if，就很难掌握了。相反，如果您从未见过 dplyr 中的这些新功能，也很难理解它们能为您做些什么。

作为一种函数式编程语言，r 有很多优点:它允许您轻松地操作数据，并且有大量的函数可供您使用。如果有什么不同的话，我写这篇文章时面临的最大挑战之一就是在寻找解决方案时到底从哪里开始:R Manual、堆栈溢出、特定的包，甚至是 RStudio 社区。在正确的人手中，使用正确的技能，R 可以成为一个强大的工具，但不适合胆*的人。你怎么想呢?你认为 R 对于你的日常任务来说足够强大吗，或者你认为 base-r 有时感觉不稳定吗？

科幻极客的数据处理基础——第二部分——走向 RDD

原文：https://towardsdatascience.com/fundamentals-of-data-processing-for-scifi-geeks-part-ii-apache-spark-rdd-3d4b2c6f39f?source=collection_archive---------3-----------------------

在阅读本文之前，请阅读第一部分。这个博客有一个代码库，里面有可运行的例子:https://github.com/actions/dp_fundamentals

在第一部分中，我们在科幻多*扩展概念和数据处理系统之间做了一个类比。我们引入了迭代器作为一种以转换形式构建数据处理计划的方式，以及执行这些转换并产生结果的动作。
在本系列的这一部分，我们将扩展到第二*空间，并开始通过多个内核和系统同时处理我们的数据。

就像布料是由许多线缝合在一起构成的一样，我们向第二*数据处理的扩展将需要多个迭代器。数据处理将利用可用的 CPU 内核在多个计算线程上同时工作。

分割

就像你不能不用一根线来做一件衣服一样，我们也不能并行处理一大堆数据。为了处理数据，我们必须对数据进行分区。上次我们处理了《威廉莎士比亚全集》。我们已经知道如何计算整个文件的字数。为什么我们不试着扩大加工规模。为此，我们需要将它分成多个部分。我能想到许多分裂的方法。我们可以按页拆分，有几千个*文件；我们可以按故事拆分，有几个大*不同的有意义的文件；我们可以简单地把这个大文件切成几个相等的部分。哪种方法效果最好？最长的答案是——“视情况而定”。

数据分区的快速经验法则是—使用固定数量的大*相等的分区。

稍后我们将研究不同的方法，并逐渐得出结论。

现实生活中分区是如何形成的。

事实上，我们很少对巨大(或不巨大)的文件进行分区。通常，这些数据来自连续不断的点击量、消息、IOT 报告指标或威廉·莎士比亚写的文本行。当数据到达时，形成分区。在接下来的部分中，我们将讨论如何使用我们将要构建的机器来处理连续流。

现在我们假设我们的数据已经被分区了。关于分区的进一步讨论可以在本文的附录中找到。

并行数据处理

现在，我们建立了开始讨论并行处理的基础。
多线程的想法总是会引发很多问题:
-我需要多少个线程？
-我怎么做同步？
-我如何获得我的计算结果？

Fork-join 公共线程池

分叉连接模型正是我们需要开始的。这有助于将工作分成更*的任务。每个任务串行工作，而多个任务并行执行。执行整个作业的主线程将等待任务完成并收集结果。
Fork-join 比喻是这样的:
-当任务开始执行时，它分叉成单独的线程。
-当任务完成后，它加入主线程并返回结果。

source: wikipedia:Fork–join_model

为了更容易想象，可以把一个公共线程池看作一条有几条车道的高速公路。每条车道都是一个运行线程，而每个任务都是一辆在其中一条车道上行驶的汽车。当汽车行驶时，CPU 正在处理我们的数据迭代器的元素。当迭代器被清空时，这辆车退出高速公路。

池中的线程数量或高速公路中的线路数量等于 CPU 中的核心数量。我目前使用的笔记本电脑有两个超线程内核，所以总共有 4 个内核。我的公共 fork-join 池有 4 个线程——每个内核一个。我们并不真的需要更多，线程越少，一些内核就越空闲。定义良好的数据处理程序持续利用所有内核。

在 java 中，对公共池的访问是使用 ForkJoinPool 完成的。common pool()API 调用。

处理一个分区

这里我们定义了我们的任务，它将处理一个分区并返回部分字数。我们将使用我们在第一部分中构建的字数统计函数。

将这一切结合在一起

让我们创建另一个任务，它将启动分区的并行处理，并将结果汇总在一起。

在任务的构造函数中，我们迭代我们的分区。我们为每个分区创建一个处理任务，并立即开始在一个可用的线程上运行它。我们使用方法 ForkJoinTask::fork 。在计算方法中，我们将任务结合在一起，并将分区计数汇总成最终计数。

运行作业剩下的工作就是将我们的任务提交给池:

基本计算图

如果我们要可视化我们的代码，我们可以看到我们刚刚构建了一个非常简单的计算图，其中一个 WordCountTask 派生出多个任务进行并行处理并协调结果。当我们为更复杂的处理建立机器时，计算图的概念将是重要的。

走向 RDD

看着上面我们的并行化代码并不能让我满意。Fork Join 模型为在线程上运行任务提供了很好的抽象，但它并不真正符合我们对数据处理的推理方式。直接处理线程池和调度任务可能会变得很麻烦并且容易出错。只是一个简单的代码洗牌的*例子，它可以改变行为。
下面是 WordCountTask 的版本，看起来很工整。

虽然代码看起来是在做同样的事情，但重要的区别是它将串行执行。一个分区将在另一个分区之后被处理，而我们所做的只是放错了 join 调用的位置。很难发现这种差异，问题也不会变得明显，直到我们将它部署到生产中，并意识到任务需要 4 倍的时间才能完成。

我们需要更好的并行数据处理模型。希望是为我们安排任务的那个。

在第一部分中，我们将迭代器作为一种机器来构建一个作为转换链的执行计划，然后使用一个动作来执行该计划。

让我们看看代码的组成部分，并尝试构建一个抽象，这将有助于我们将数据处理扩展到二*空间，并将其并行化，以充分利用我们的计算能力。

我们的第一个类正在处理一个分区。仔细看看我们的代码，我们需要知道的只是分区号 partitionId 。我们能够从 partitionId 构建处理链。然而，我们以后可能需要更多的信息。

接下来，我们使用 wordCount 方法处理一个分区。然而，wordCount 方法做了很多事情。查看内部，执行以下操作:

1 从一个分区文件构建了一个迭代器。

2.在这个迭代器上附加了一个转换链。

3.准备运行操作以获取分区级别的结果。

接下来我们使用 WordCountTask 来

4.构建一个计算图，并在我们的计算线程池中执行。

5.合并部分结果(另一个动作)。

现在让我们想象一下新的结构，它包装了一组分区迭代器。这种结构会像迭代器一样为我们构建处理链，我们将能够运行我们的操作，而无需考虑多线程和任务调度。这几乎就是 Apache Spark 背后的团队所做的。他们的基本想法被称为 RDD——弹性分布式数据集。虽然我们不会在这个模块中重新构建 Apache Spark，但是我们将研究这个机制背后的基本思想。

这是第一步。我们的抽象 RDD:

• 知道它的分区，
• 有能力访问分区数据的计算方法
• 意识到它的依赖性，以便能够建立一个计算图。
• 有权访问 ForkJoinPool 来运行作业。

在我们过于简化的 RDD 中，我们将 ForkJoinPool 等同于 sparkContext ，我们稍后将解决这个问题。

让我们看看它是如何为我们工作的，并在分区文件上创建一个 RDD:

1. FilePartition 是分区的自定义实现，它引用数据所在的实际文件。
2. 我们实现了 RDD，它允许我们通过从分区构建迭代器来访问分区文件数据。

接下来，我们需要做的就是将方法从文件添加到我们的 RDD 类中。

**static** RDD<String> fromFile(Path directoryPath){
    **return new** PartitionedFileRDD(directoryPath);
}

地图分区

在我们的并行字数统计代码中，我们学习了如何处理一个分区，然后同时处理我们的分区。地图分区法有助于我们概括这一过程。我们将通过将一个 RDD 的分区迭代器映射到另一个 RDD 的分区迭代器来转换我们的 RDD。

首先，我们需要认识到，很多时候，我们会有一个依赖项，所以围绕这个特定的情况编写一些助手方法会有所帮助。

**public** RDD(RDD parent) {
    **this**.**sparkContext** = parent.getSparkContext();
    **this**.**dependencies** = Arrays.*asList*(**new** Dependency() {
        @Override
        **public** RDD rdd() {
            **return** parent;
        }
    });
}

**public** <P> RDD<P> getParent(){
    **return** (RDD<P>)**this**.**dependencies**.get(0).rdd();
}

现在我们准备建造我们的混凝土 RDD:

**private class** MapPartitionsRDD<T,O> **extends** RDD<O>{

    Function<Iterator<T>, Iterator<O>> **converter**;

    **public** MapPartitionsRDD(RDD parent, Function<Iterator<T>, Iterator<O>> converter) {
        **super**(parent);
        **this**.**converter** = converter;
    }

    @Override
    **protected** List<Partition> getPartitions() {
        **return** getParent().getPartitions();
    }

    @Override
    **protected** Iterator<O> compute(Partition partitionId) {
        Iterator<T> preComputed = (Iterator<T>)getParent().compute(partitionId);
        **return converter** .apply(preComputed);
    }
}

最终为 RDD 找到了新方法:

**public** <O> RDD<O> mapPartitions(Function<Iterator<T>, Iterator<O>> converter){
    **return new** MapPartitionsRDD<T, O>(**this**, converter);
}

让我们准备使用 RDDs 重写我们的 wordCount 方法。这是它看起来的样子。

我们现在有一个简单的方法来处理分区。我们使用的函数调用非常类似于我们处理迭代器时的函数调用。然而代码看起来还是有点乱。MapPartitions 要求我们使用分区迭代器。

让我们介绍几个熟悉的方法，使我们的 RDD 更干净。这些方法将帮助我们停止考虑分区，让我们像处理迭代器一样处理分布式数据集。

平面地图

**public** <O> RDD<O> flatMap(Function<T, Iterator<O>> splitter){
    **return this**.mapPartitions(pi->pi.flatMap(splitter));
}

地图

**public** <O> RDD<O> map(Function<T, O> mapper){
    **return this**.mapPartitions(pi->pi.map(mapper));
}

现在缺少的是我们的动作，它将从迭代器中收集结果。我们需要一些模拟的减少RDD 的方法。在 RDDs 的世界中，它被称为“聚合”。

总计

让我们首先设计这个方法应该如何工作。如果我们看一下并行字数统计的原始实现，您会发现我们调用了两次 reduce 方法。作为作为我们的PartitionProcessingTask的一部分执行的串行字数统计方法的一部分，对每个分区进行了一次缩减。第二次 reduce 是为了将分区结果放在一起，作为 WordCountTask 的一部分。 现在我们有了处理分区的机制，我们可以将这两个调用放在一个方法中:

我们定义了分区缩减器，就像在串行字数统计方法中一样。它计算我们在每个分区的字数。接下来，我们定义了结果聚集器，它将来自每个分区的结果聚集在一起。我们使用熟悉的代码，这些代码我们已经在代码的不同部分使用过了。

现在我们有了启动事物的方法 aggregate。好的一面是，当我们讨论并行数据处理时，我们几乎已经建立了它。

我们的方法 aggregate 只是概括了我们在构建第一个并行字数统计方法时所做的工作。它很好地结合了 RDD 和 ForkJoinPool 来包装分区迭代器的处理以及结果的聚合。我们来讨论一下这是怎么回事。

1. 我们必须为开始参数选择一个供应商。我们正在处理一个迭代器上对 reduce 的多次调用。我们需要能够在每次进行缩减时获得 start 参数的新副本。因此，我们需要根据请求提供新起点的能力。
2. 分区聚合器是分区迭代器的 reduce 方法的组成部分。不像迭代器 reduce，我们还没有完成。
3. 组合器组合我们从处理每个分区中得到的结果。

新代码还不错。我们不必处理任务调度或考虑并行处理。我们在那里所做的就是写下我们的逻辑，并让 RDD 机器来处理。

附录

什么分区方案最好？

既然我们已经了解了并行处理是如何工作的，我们可以考虑划分模式了。

如果我们有相同大*的分区，并且分区的数量等于核心的数量，那么一切看起来都很好。它看起来就像上面的图表。
不幸的是，这个世界并不理想。假设我们有 5 个分区和 4 个内核。

我们的总处理时间会立即翻倍，而数据量只会增加 25%。

现在，让我们想象一下，我们将文本按页面分割，并有数千个分区。这个方案非常灵活，但是我们会有与调度这么多任务和处理这么多文件相关的开销。

最终没有完美的答案。划分方案需要考虑底层技术和处理要求。

分区代码

这是我们的复合文件的分区代码:https://github . com/actions/DP _ fundamentals/blob/master/src/main/Java/fundamentals/ll processing/data splitting . Java

科幻极客的数据处理基础——第一部分

原文：https://towardsdatascience.com/fundamentals-of-data-processing-part-i-f6a6914e1fec?source=collection_archive---------8-----------------------

如果你对科幻感兴趣，你可能读过《三体问题》三部曲。我强烈推荐你去读一读，以防你没有看到这本书。

作者刘提出的一个最引人入胜的想法是质子多*膨胀的想法。他将质子描述为高度复杂的 11 *结构，看起来很*(0.8418±0.0007fm。)因为它的*度是坍缩的。一个先进的文明可以通过扩大质子的坍缩*度来获得巨大的能量。三体世界的居民能够在二*空间中扩展一个质子，以建造一个跨越半个星球的巨大球面镜。这面镜子是用来在长时间黑暗中控制白天光线的。

我们还不能扩大质子的*度，但*的东西可以变大，大的东西可以变*的想法是数据处理的基础。

让我们从我们的“质子”开始，我们将要展开它。在数据处理领域，我们从一个记录开始。记录可以是巨大点击流中的一次点击，可以是用户上传的一张图片，可以是 IOT 设备的一次测量，可以是一次医疗测试结果……记录是您的基石。现在让我们试着对你的记录进行多*扩展，看看能做些什么。

这个博客有一个代码库，里面有可运行的例子:https://github.com/actions/dp_fundamentals

*度 1 —迭代器

迭代器可能是最简单也是最吸引人的数据结构。你可能有最强大的数据结构，比如多*树或很酷的散列，这些都不能做迭代器能做的。一个迭代器可以遍历一个数据集，你甚至无法想象它能适合你的内存，它所需要的只是一个常量内存来容纳一条记录。真正的迭代器是你的一*扩展工具。让我们更详细地看一下。

**public interface** Iterator<E> { **boolean** hasNext(); E next();}

迭代器给了你获取数据的潜力。请注意，hasNext 方法不需要每次都返回 true。迭代器可以扩展非常大的数据集，甚至是永无止境的数据流。

迭代器允许你在执行这些计算之前建立一个计算链。让我们让迭代器更强大:

**abstract class** Iterator<I>{

    .....

    */**
     * map function apply an operation to every element of the
     * iterator at the moment of iteration
     ** ***@param mapper*** *mapper function
     ** ***@param <O>*** *Returning type
     ** ***@return*** *new iterator over processed data
     */* <O> Iterator<O> map(Function<I, O> mapper) {

        Iterator<I> origin = **this**;

        **return new** Iterator<O>() {
            @Override
            **boolean** hasNext() {
                **return** origin.hasNext();
            }

            @Override
            O next() {
                **return** mapper.apply(origin.next());
            }
        };
    }
    .....

}

我们介绍的第一种方法是 map 。方法映射在我们迭代时处理数据。我们一次处理一条记录。当我们调用 map 时，我们还没有处理数据。我们刚刚构建了一个以迭代器形式处理数据的计划。随着数据的到来，我们可以一次处理一个。

在实际执行处理之前构建执行计划的能力是构建数据处理管道的基础。执行规划可带来优化、容量规划、弹性、可扩展性和其他必要特性，从而实现持续可靠的数据处理。

平面地图

**abstract class** Iterator<I>{

....
<O> Iterator<O> flatMap(Function<I, Iterator<O>> splitter) {

        Iterator<I> origin = **this**;

        **return new** Iterator<O>() {

            *//initialize current iterator as empty iterator* Iterator<O> **current** = Iterators.*empty*();

            @Override
            **boolean** hasNext() {
                **if** (**current**.hasNext()){
                   **return true**;
                }
                **if**(origin.hasNext()){
                    **current** = splitter.apply(origin.next());
                    **return** hasNext();
                } **else** {
                    **return false**;
                }
            }

            @Override
            O next() {
                **return current**.next();
            }
        };
    }

....
}

让我们试着理解一下 flatMap 实际上是做什么的，为什么它是数据处理中最重要的功能。

如果您可以将数据集的每个元素转换为其他元素的迭代器，那么 flatmap 将产生一个迭代器，它将迭代所有结果迭代器的所有元素。同样，请注意，除了存储一行所需的内存之外，我们没有使用更多的内存。出于多种原因，Flatmap 的确不同凡响。它可以一次完成变形和过滤。注意，原始迭代器的一些元素可以转换成空迭代器，因此在输出中不存在。从技术上来说，可以用 Flatmap 写出很多有帮助的数据处理方法。

我们将看到如何使用 flatMap 来处理和过滤数据。

在这个例子中，我们迭代一个相当大的文件的行，并将这个迭代器转换成文件中有意义的单词的迭代器。

迭代一个数据文件。

下面是我们如何在一个文件上构建一个迭代器。请注意，我们不是将整个文件读入内存，而是只获取我们立即需要的内容。

现在我们开发了一个强大的机器来转换迭代器，让我们看看如何从迭代器中得到结果。

**abstract class** Iterator<I>{...
    **abstract boolean** hasNext();

    **abstract** I next();

    <O> O reduce(O start, BiFunction<O, I, O> aggregator){
        O current = start;
        **while**(hasNext()){
            current = aggregator.apply(current, next());
        }
        **return** current;
    }...
}

Reduce 是一个简单的方法，它将迭代器折叠成最终结果。我们需要的是将两个元素折叠成一个，然后随着迭代不断折叠的能力。

例子

顶级元素

Integer[] data = {**10**,**20,30**,**40**,**50**,**60**,**71**,**80**,**90**,**91**};

**int** k = 3;
PriorityQueue<Integer> top = Iterators.*overArray*(data)
        .reduce(**new** PriorityQueue<Integer>(k), (topn, el)->{
            **if**(topn.size()<k){
                topn.offer(el);
            } **else**{
             **if**(topn.peek()<el){
                 topn.poll();
                 topn.offer(el);
             }
            }
            **return** topn;
        });

字数

这是一个例子，所有的东西都聚集在一起。我们阅读了一个大文件——莎士比亚全集。FlatMap 帮助我们将每一行拆分成单词，并一次性过滤掉无意义的行。Reduce 将计数聚集在一起。

作业——改进行处理，更好地提取有意义的单词。结合两个例子，得出前三个最受欢迎的词。

转换与行动

如果我们仔细看看我们的例子，我们可以用迭代器做两种类型的活动。这些可以分为两种类型——转换和动作。

像贴图、平面贴图、滤镜或 linesFromFile 、、这样的变换并不能真正做什么。他们只是建立了一个步骤链，这将发生在结果迭代器被遍历的时候。您可以构建最复杂的转换链，但是在有人对结果迭代器调用 next 之前，实际上不会发生任何计算。

像 reduce 这样的动作实际上是遍历一个迭代器来调用转换并产生结果。

扩大企业

现在我们知道了迭代器的基础知识以及如何使用它们。是时候添加更多的转换和操作了。

filter —更容易使用的方法来对过滤后的数据产生新的迭代器。如果你注意的话，我们已经用它从单词列表中删除了空字符串。

—当我们想知道元素在迭代器中的位置时会有帮助。我们只需在现有的迭代器中添加 counter。

取——在第一个迭代器的前 n 个元素上产生一个迭代器。您将看到它如何限制作为 wordCount 输出一部分的打印字数。

forEach—是一个动作，它遍历迭代器，对每个值应用一个函数。它不返回任何内容。如果我们必须将转换的结果保存到文件、数据库或其他存储中，这是非常有用的。

收藏——是一个动作。它遍历迭代器并将数据收集到 java list 中。

范围 — 在一个数字范围内迭代。将其视为 i 结构的的替代品。基本上只是一个围绕 reduce 的简单包装。**

over array—遍历数组中的元素

from Java——将 Java 迭代器，没有我们有用的方法，转换成支持转换和动作的迭代器。

结论

这里描述的迭代器是一个简单的工具，它帮助您在实际处理数据之前建立数据处理计划。它可以帮助处理看似无穷无尽的数据，只使用有限的内存。迭代器可以被想象成一*数据扩展，为扩展到“更高*度”打下基础。特别是在内核、机器和数据中心之间并行处理。

拍手，喜欢，分享是你想了解更多关于多*数据扩展的知识。

阅读第二部分学习如何扩展到第二*度。

放弃

注意:该实现仅为演示目的而特意简化。生产就绪实现稍微复杂一些。

未来实验室人工智能峰会悬崖笔记

原文：https://towardsdatascience.com/future-labs-ai-summit-cliff-notes-8ac185cef212?source=collection_archive---------5-----------------------

NYU 足球中心，2017 年 10 月 31 日

我昨天参加了未来实验室的人工智能峰会，作为了解该领域最新发展的一种方式。我喜欢这些活动，因为它们是相对亲密的，而且演讲者都在这个被广泛误解的前沿技术的采煤工作面。

我主要感兴趣的是了解组成人工智能(机器学习/深度学习等)的组成技术如何应用于现实世界的问题。我相信写一写人工智能是如何被应用的对揭开这项技术的神秘面纱和减少现在充斥的疯狂炒作大有帮助。

我冒昧地做了一些讲座的笔记，但是这些笔记并不全面，也没有涵盖所有的讲座。我只写了与产品直接相关的笔记，或者谈论了与实践者相关的人工智能技术的内在特征/行为。欢迎提问/评论。

利用神经网络:一个 ML 应用的故事

谷歌纽约研究主管科瑞娜·科尔特斯

Corinna 的演讲侧重于她和她的团队如何应对使用深度模型部署“智能回复”功能的挑战，最初是在谷歌收件箱内，后来是在 Gmail 上。

她首先提到，机器学习对谷歌产生了巨大影响，许多应用因此被注入了新的功能。接受过这种待遇的 app 包括；

• 谷歌翻译(提高准确性)
• Google 相册(自动字幕和物体识别)
• 语音识别(准确性提高)
• 收件箱/Gmail(智能回复)

智能回复

Gmail Autopilot, April 1 2009

智能回复的灵感来自谷歌 2009 年愚人节的恶作剧 Gmail 自动驾驶。这个恶作剧提出了一个系统，它能够推断电子邮件的内容，并根据可调的预设为你构建一个回复。

智能回复拉开了 2014 年秋季的序幕。它广泛使用 LSTMs(长短期记忆),这是一种递归神经网络的形式。我不会深入讨论这些，但是在这里可以找到一个很好的资源。

Corinna 继续提到，LSTMs 提供了一个强大的技术框架来构建智能回复功能。然而，该团队面临 3 个关键挑战；

如何控制特性的输出

为了求解产量，Corinna 和她的团队发现了以下结果:

• 不合语法和不恰当的答案是有问题的
• 他们找到的解决方案是使用固定的响应(数百万个固定的响应，而不是动态生成新的响应)
• 响应被人工净化(使用标签传播在语义上聚集在一起)
• 从不同的集群中挑选响应，以确保响应随时间的多样性
• 为边缘案件制定了规则。例如，如果你试图用“你闻到了”这样的电子邮件来欺骗智能回复，它甚至不会尝试回复。

如何加快推理速度

通过改进 LSTMs 的构造方式来改进推理。团队实现了前馈架构和非对称散列。由于实现了这种智能回复，实现了一些令人印象深刻的性能改进；

• 智能回复现在比最初发布时快了 100 倍
• 智能回复现在占所有手机回复的 10%

如何生成可扩展的架构

Corinna 和她的团队所做的工作导致了 Adanet 的开发，这是一个允许算法自适应学习并进一步改善底层神经网络的框架。更多信息在这一块由 Wired 提供。

人工智能的社会和伦理影响:我们的责任是什么？

执行董事苔丝·波斯纳 AI4ALL

这个演讲是一股新鲜空气，因为之前的大部分演讲都钻研了大量不必要的技术术语。Tess 的演讲讨论了人工智能领域出现的系统性高层次问题。这是一个相当短的演讲，所以我用要点格式写了下来。

• 未来 10 年人工智能为美国国内市场带来 1.49-2.95 万亿美元的机会。
• 在人工智能行业，我们正面临一个巨大的多样性问题

Bernard Parker, left, was rated high risk; Dylan Fugett was rated low risk. Image credit: Josh Ritchie for ProPublica

• 这在很大程度上表现为偏见。Tess 用 Northpointe 开发的 COMPAS(替代性制裁的矫正罪犯管理概况)软件举例说明了这一点。这个软件已经由独立的第三方在进行了广泛的测试，并被证明对黑人被告有偏见。
• 偏见也存在于谷歌翻译等日常工具的微妙互动中。

Gender bias present in translation between certain languages

导致上述例子的一些问题包括:

• 不同人群的准入门槛目前非常高
• 人工智能中的同质文化
• 对场地的感知有限
• 早期缺乏对技术概念的技术接触
• 很少有相关的榜样
• 缺乏对等支持

AI4all 试图解决的一个角度包括:

• 教育下一代人工智能领导者
• 建立人工智能意识，教育未来消费者
• 扩大促进人工智能技术的有益用途

版权法能否修复 AI 的隐性偏见问题？

作者阿曼达·莱文多夫斯基——NYU 法学院助教

这个演讲也激起了我的兴趣，因为它向社会结构提出了一个有趣的挑战——特别是版权法。Amanda 提出了一个令人信服的论点，认为版权法通过限制可用于训练算法的数据集类型，导致隐含的偏见，给社会造成了巨大的损害。同样，下面的要点总结了这次谈话；

• AI 有偏见是因为人有偏见
• 我们生活在一个充满偏见的社会，这些偏见主要通过有偏见的数据进入我们的人工智能系统
• AI 需要好的数据。垃圾进，垃圾出。
• AI 有版权问题
• 许多算法已经用安然公司的电子邮件进行了训练。这个由 50 万封电子邮件组成的语料库包含了大约 150 个用户的数据，其中大部分是安然公司的高级管理人员。这些是联邦能源管理委员会在调查期间发布的。
• 考虑到这些数据代表了安然内部的系统性欺诈行为，认为这些数据被用于训练算法是令人困惑的。
• 低摩擦和可访问的数据是训练人工智能系统的主要数据来源，尽管电子邮件的内容和创建它们的环境会产生负面影响。
• 因此，版权法可能会偏袒人工智能系统。这是版权法需要改革的主要原因。

聊天机器人的未来——机器人与机器人交谈

原文：https://towardsdatascience.com/future-of-chatbots-bots-talking-to-bots-388112a204f5?source=collection_archive---------13-----------------------

The future of integration with conversation

我最近在考虑一个项目。我们正在开发一个应用程序，其中一部分涉及到在餐馆预订。大多数餐馆没有自动预订系统——你可以插入的支持许多餐馆的 API 很少。

支持每一家餐馆的唯一可靠的方法是给这些餐馆打电话，用传统的好方法预订——和一个人交谈。然而，为了省钱，我们正在探索让机器人打电话的想法，而不是使用现代语音技术。理论上，这是非常可能的，尽管需要收集大量的数据来完成。

巧合的是，我也是 Vesta.ai 的技术顾问，这是一家为餐馆开发聊天机器人技术的公司。他们的目标是制造一个可以代替服务员的聊天机器人。你可以进来，坐下来，开始和一个*的智能扬声器说话来点菜。然而，该公司计划将这项技术扩展到通过电话接听电话。

于是很自然的想到这两个项目，我开始怀疑。如果这两种技术都成为主流，会发生什么？我们会让机器人和机器人说话吗？几乎不可否认的答案是——是的。但问题是，这将是一个边缘案例，一个我们将看到社会从人类供电系统向人工智能供电系统过渡的退化技术的幽默例子。或者，对话最终会成为集成两个软件的工程选择吗？

在考虑答案时，我要求你比较和对比集成系统的两种方式:

鉴于所有这些，相信自然语言集成可能会成为真正的工程选择似乎有些疯狂。但是我要提请注意这样一个事实，即假设的自然语言集成的许多负面影响随着长期趋势而减轻:

• CPU 能力和网络容量继续呈指数增长，降低了额外 CPU 和网络成本的重要性
• 通用 NLP 工具每天都在改进，减少了对专业知识和定制数据集的需求
• 人工智能专业知识正变得越来越广泛，这得益于它在科技行业的时尚地位
• 无论如何，公司越来越多地为人类创建对话界面，使机器对机器集成的重用变得容易

从长期趋势来看，有利因素同样越来越诱人:

• 随着变化速度的加快，*护基于 API 的集成变得越来越昂贵，这要求我们不断更新代码以跟上变化
• 随着越来越多的人进入技术行业，允许半技术或非技术人员理解系统的设计变得更有价值
• 有越来越多的系统需要集成，每个集成都需要单独创建和*护，即使它们的行为非常相似

所有这些趋势的结合似乎意味着，随着时间的推移，相对于传统的集成，两个系统之间的自然语言集成将变得越来越有价值。

一开始，它会从*处着手。它将从日益流行的为人类设计的机器人中衍生出来。一些有进取心的程序员会创建自然语言集成，只是为了证明这是可以做到的。一些机器人对机器人的对话可能是由于交易双方自动化程度的提高而偶然产生的。

然后，当项目进展缓慢，工程师面临交付压力时，自然语言集成可能被认为是临时的黑客修复或一次性计划，出于对其便利性的好奇，但从未打算成为永久的。但是，当这些集成投入使用，天不会塌下来，这种疯狂的思考 API 的方式将越来越成为一种可接受的工程选择，尽管被归入某些边缘情况。

不过我预测，随着人工智能行业继续向前发展，我们试图自动化越来越多的流程和工作，我们将需要以指数增长的速度在不同的组织之间创建集成。这些集成将需要以越来越复杂的方式进行交互，这需要代表人类进行越来越多的监督。有了它，自然语言集成将从一个深奥的概念，一个黑客玩具，变成一种占主导地位的主流技术。

在不同的集成之间分担工作的好处太大了，不容忽视。因此，不是人类越来越适应技术世界，而是技术世界将越来越像我们。即使在最深的层次，我们的机器也可能开始用人类的语言相互交流。机器人会和机器人说话。

仅供参考:本帖原载于www . electric brain . io。

面向未来的创业:医疗保健中的数据网络效应

原文：https://towardsdatascience.com/future-proof-your-startup-data-network-effects-in-healthcare-32d54de710af?source=collection_archive---------3-----------------------

在医疗创业公司激烈的竞争环境中，不断创新和改进是成功的关键。一个满足于满足市场需求的产品的公司会为下一个新事物创造机会让它过时。创新缓慢的公司可能会保持其地位，但会被利用网络和数据网络效应的创业公司超越。如果你的创业是数据驱动的，围绕网络建立的，强烈考虑使用以下现象来推动增长。

网络效应

由于社区分裂、互操作性问题和不利因素等原因，网络效应在数字医疗领域很大程度上没有得到充分利用。这个概念是众所周知的:

网络效应:网络效应描述了随着越来越多的人使用同一服务，一项服务如何变得对用户更有价值

科技领域的无数公司，如脸书、LinkedIn 和优步，都将网络效应作为增长黑客，它与业内许多最根深蒂固的巨头有关。

Source: Kinesis

如果你仍然怀疑网络和数据网络效应的实际好处，理解梅特卡夫定律可以帮助你相信:

梅特卡夫定律:网络的价值与系统上连接的用户数量的平方成正比。

一些人认为梅特卡夫定律应该改进，以显示网络价值遵循 n*log(n)曲线，其中 n 是用户数量。无论哪种方式，都会很快偏离线性回归。由于增长显然与网络的价值相关，因此很容易理解为什么初创公司争相利用这一现象。

数据网络效应

网络效应有一个强大且更模糊的兄弟:数据网络效应，它遵循相同的原则，在医疗保健领域有许多使用案例。虽然人工智能和机器学习产品比比皆是，但数据网络效应可以不费吹灰之力就将*麦从谷壳中分离出来。

数据网络效应:数据网络效应描述了随着越来越多的人使用同一服务，一项服务如何变得更智能(通常通过机器学习)

The Data Network Effect Flywheel. Source: CB Insights

数据驼峰到数据转储

让数据网络效应开始并不总是容易的，也不一定适用于每一次创业。开始有两个关键部分:

1. 你需要访问数据，不管是你的还是别人的，从中学习。如果你不能生成自己的数据，从利用其他来源的数据开始可能是有用的，比如网络搜集，或者公开可用的数据集。
2. 你需要激励用户在你的产品中创建他们自己的数据。这意味着让你的初创公司处理潜在的大型数据基础设施，并雇佣机器学习工程师来构建反馈回路的算法部分。

用例:Mediktor

数据网络效应也推动了采用，这通常是医疗保健领域最关键的挑战。症状检查器初创公司 Mediktor 利用了数据网络效应。他们的产品建立在机器学习算法的基础上，这些算法已经在患者记录结果的大型数据集上进行了训练。一个模型适合这个训练数据，以预测你得了什么病，以及你应该做什么来最有效地恢复。对于每一个输入数据的新用户，算法都会学习和改进。产品会自我学习变得更聪明。随着准确率的提高，越来越多的人想要使用该产品，循环往复。

结论