TowardsDataScience-博客中文翻译-2019-四十-

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

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

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

药物是储存的还是排泄的？编写并训练一个简单的感知器来找出答案

原文：https://towardsdatascience.com/is-a-drug-stored-or-excreted-writing-and-training-a-simple-perceptron-to-classify-bioconcentration-bc2112239ce8?source=collection_archive---------34-----------------------

我进军 DL

简单感知器学习算法的简单实用介绍及其在生物浓缩分类中的应用

Image by Ahmed Gad from Pixabay

简单来说，什么是感知器？

一个神经元是大脑的基本功能单位，类似地，感知器是神经网络的基本功能单位。在这篇文章中，我将简要介绍人工神经网络和生物神经网络之间的相似之处，感知机如何工作背后的理论，以及如何在 python 中实现算法，以在生物浓度数据集上训练它。

在动物中，一个神经元在其树突处接收来自其他神经元突触的输入。这些树状结构接收输入信号，并在细胞体(也称为细胞体)中进行融合。一旦信号在胞体中发生叠加，门控离子通道将根据信号是否突破阈值而打开或保持关闭——导致神经元沿着轴突放电或保持静止。神经元要么激活，要么不激活。

Biological and artificial neuron similarities

为了更好地理解这个模型，我们应该回顾一下上面我整理的图片中的几个组件:

输入&偏置:生物神经元的树突接受来自连接突触的神经递质输入。感知器模型中的对应物是输入(用于分类的特征)乘以其各自的权重。权重是在训练模型时随时间变化的值，因为当训练期间发生错误时，它们在“学习”阶段更新。添加偏差作为特殊输入，通过向左或向右平移点来移动决策边界。下面的求和公式显示了输入、权重和偏差是如何结合在一起的。

Summation equation

下图是一条 sigmoid 曲线，如果我们要改变权重，我们可以改变斜率的陡度，但实际上要向左或向右移动曲线，您需要添加一个偏差。使用 bias 在某个方向上平移所有点可以通过帮助分离超平面来增加精度。

Basic sigmoid curve

激活功能:神经元胞体中兴奋性离子和抑制性离子的总和产生动作电位。如果动作电位是兴奋性的，并且超过阈值，就会发出信号。在人工神经元中，激活函数计算总输入的净输出。感知器实际上是模型的决策者，并使用 heaviside 函数，也称为阶跃函数，来计算预测的二进制输出。下面是最常用的阶跃函数:

Unit step function

θ是激活函数
z 是输入的总和乘以它们的权重(和偏差，如果包括的话)

输出:生物神经元沿着它的轴突传播信号，如果达到阈值，这就是它的输出。感知器的输出也是在全有或全无的基础上触发，并导致 1 或-1 的二进制分类。

注:关于这份材料的更深入的文章可以在这里找到。

逐步算法

以下是该算法进行预测和学习的步骤纲要。

将权重设置为较小的初始值
将输入向量和权重向量相乘，然后求和
如果总和值大于阈值，则将计算二进制输出
检查预测的结果是否正确，然后相应地更新权重
重复该过程以提高精确度

注意:另一篇伟大的文章解释了为什么算法会起作用。

编码感知器

注意:我将剖析和解释《Python 机器学习》一书中的代码示例，同时加入我自己的代码。我会检查我们感知机的每一行代码。

第一行代码将导入 numpy，因为我们需要执行向量乘法并绘制随机数。然后我们创建感知器类，初始化它，并为“epochs”、“learning_rate”和 randomState 设置参数值。

时期-所有训练数据向前和向后传递的次数
学习率——通常指η (eta)和步长。该值更新权重。当训练数据时，权重将根据它们对多少误差负责来更新，但是学习率用这个误差的一部分来更新权重。因此权重更新为——权重+ η(误差)。
randomState—用于为实例绘制伪随机数的类。我建议不要使用 random.seed()，因为它会影响全局 numpy 环境。

这里我们定义了接受 x 和 y 参数的 fit 函数。

权重-该参数用于将权重设置为一个随机数，而不是零。以零作为起始权重会导致对称性问题。如果所有输入值的权重为零，则误差也将为零，并且它们都将以相同的幅度更新。我们生成一个平均值为 0、标准偏差为 0.01、抽取样本数量为 1 的正态分布。
errors —是一个空列表，我们将在其中添加我们在培训过程中捕获的错误

下一段代码是我们刚刚定义的 fit 函数中的一个循环。然而，由于它有许多部分，我们将逐行单独查看。

我们将循环设置为遍历每个时期
将每次迭代的误差变量设置为 0
这里，xi 和目标是 x 和 y 值元组中的两个数字，我们将它们作为数据输入
我们将更新变量设置为我们需要用来更新权重的值，即学习率*误差
用下面的公式更新输入的权重:
权重=权重+(更新* xi)
这里我们将偏差输入更新为:权重=权重+更新
我们现在将 errors 变量的值设置为更新值
最后，我们追加前面创建的错误列表

感知器代码的最后一块将定义求和及预测功能。

求和-我们将特征输入定义为 x，并返回权重和输入的矢量点积，以及偏差单位。
预测-使用 x(要素输入)作为函数参数，如果总和(x)大于 0，则函数返回 1；-1 否则。

清理和准备数据

我没有选择像 Fisher 的 iris 数据集这样的经典数据集，而是选择寻找一个与我目前正在做的工作相关的数据集。这让我找到了由米兰-比科卡大学主办的生物浓缩数据集，可以在这里找到。

这些数据只需稍加润色就可以使用了。在下面的代码块中，我做了些什么来使数据可用于感知器模型。原始数据有 3 种不同的分类:(1)主要储存在脂质组织中，(2)有额外的储存位点(如蛋白质)，或(3)被代谢/消除[1]。因为我们的模型将使用两个预测类，所以我们可以去掉(2)类标签。

我们现在可以创建训练数据集来训练感知器学习模型:

训练感知器

下面是我们的感知器学习模型的完整代码块

这个数据集是心血来潮选择的，为了使分类器尽可能准确，预测特征应该能够沿着一个平面将各组分开。我们可以执行 PCA 或其他形式的降维来找出最重要的特征，但这不是本教程的重点。重点是看看我们是否可以在给定的一组分类数据上编写和训练一个感知器，以及它在这些数据上的表现如何。下面的代码块绘制了我们的训练结果，并查看了各个时期的更新次数——我们必须对整个训练数据集的传递执行多少调整。

结论:不是很棒，但是很管用！

Number of updates over epoch (entire data set passes)

我们看到，虽然更新的数量在波动，但在迭代过程中有一个总体下降的趋势，也就是说，我们的感知器算法在训练数据的每次传递中变得越来越准确。我们不能说它会达到零(像 Fisher's Iris 这样不太复杂的数据集一样)，但我们可以说我们从 20 世纪 60 年代开始的简单感知机学习算法确实“学习”了。

参考文献

[1] F. Grisoni，V.Consonni，M.Vighi，S.Villa，R.Todeschini，[通过 QSAR 分类树调查生物浓缩机制](http://F. Grisoni, V.Consonni, M.Vighi, S.Villa, R.Todeschini (2016). Investigating the mechanisms of bioconcentration through QSAR classification trees, Environment International, 88, 198-205) (2016)，国际环境组织

硕士对数据科学有用吗？

原文：https://towardsdatascience.com/is-a-masters-useful-for-data-science-dd95d6848ffc?source=collection_archive---------25-----------------------

Photo by Cole Keister on Unsplash

3 年前，我决定将职业道路从销售转向数据科学。对我来说，进入销售行业一直是一个有点奇怪的选择，因为我的本科专业是物理和金融。话虽如此，当我开始联系数据分析职位的招聘人员时，他们的回答是转行很难。

我在新西兰的 AUT 攻读了分析硕士学位。这不是常春藤盟校或类似的大学。这是一所不错的学校，并且是世界 500 强学校之一。这是负担得起的和容易得到的。这篇文章总结了我的经历和我在课程中发现的价值。

一些背景:

我的本科学位是物理学和金融。我已经有了定量分析的经验和一些 Matlab 数学编程的经验。
我住在新西兰，政府部分资助高等教育，学生贷款是无息的。

这些事情的影响是:

拥有强大的定量背景意味着我可以轻松掌握数据科学中涉及的理论。数据科学是一个高度理论化的领域，我认为正是考虑方差的统计复杂性使数据科学变得有趣。我已经对微积分、线性代数和代数运算有了很强的理解和实践能力。物理学训练我思考场，建立对数学函数的强烈直觉。
拥有廉价的高等教育意味着这个学位给我的职业生涯带来的价值要比拥有更昂贵学位的国家低得多。

我认为，在预测硕士学位的价值时，这两个领域将是强有力的因变量。

我从我的主人那里学到了什么

我在《分析大师》中学到的东西是:

基本统计思维。
一些先进的统计技术。
机器学习基础。
如何进行文献研究？
如何写学术论文？

每一个的价值，以及在其他地方学习它们的容易程度。这篇文章并不是对每个主题的重要性的完整解释，而是对我的硕士学位所涵盖的主题的价值的概述:

基本统计思维。这非常重要，对正态分布和直方图等概念的深入理解是探索性数据分析的关键部分。我认为理论是学术机构擅长教学的领域之一。我的统计学老师非常优秀，帮助我建立了强大的直觉。

高级统计技术。这些都是有用的技巧，但是技巧的范围很广，不可能全部学会。这些技术包括线性建模和回归分析、聚类技术、时间序列方法。我肯定认为大学是学习这些技术的好地方，但不可能什么都学。你需要培养识别有用的技术来解决你面临的问题的能力，然后从书籍、博客和杂志中学习如何使用这些技术，然后独立地应用这些技术来解决复杂的问题。大学通过这些课程帮助培养的正是这种学习新技术的技能，即使你可能在整个职业生涯中从未使用过混合模式。

机器学习基础。这是时尚，也是大多数学生在那里的原因。现实情况是，一般来说，大学不是学习这些技能的好地方，因为大多数学者落后于最先进的技术数年，因为许多进步都发生在行业中和 Kaggle 竞争中的竞争对手身上。我的课程是在 Weka 教授的，涵盖了广泛的技术。涵盖了一些基本指标，如 AUC ROC，但没有涵盖关键主题，如实用功能工程和可解释性。还有更好的免费在线课程，比如杰瑞米·霍华德的 Fast.ai 课程。我觉得除非你要去旧金山大学这样的地方学习，否则你最好在网上学习。这些入门级课程的价值非常低，事实是，在大多数工作岗位上，你不太可能在职业生涯的头几年里做任何严肃的模特工作。

如何进行文献研究？这非常有价值。这就是找到一个题目有用的论文的能力，以及消化这些论文内容的能力。研究人员已经发表了大量的技术和研究，这项技能可以让你获得这些信息。这是一种从你的问题的大致想法开始，进行谷歌学者搜索，略读结果以确定感兴趣的研究方向，查看参考文献并在挖掘最有希望的结果之前扩大搜索范围的能力。这将让你学到大量关于相对利基领域的知识，这非常重要。

如何写学术论文？这是有价值的。写作很难，而写有参考文献和正确格式的学术论文更难。如果你从事研究工作，这是一项非常有用的技能，但许多分析角色涉及某种程度的报告，因此提高你的写作技能是有价值的。

我在硕士时没有学到的东西

SQL。我们使用了一点 SQL，虽然我们有关于数据仓库的课程，但我们没有学习 SQL 的具体课程。SQL 是分析中许多角色的基本技能。这可能相当棘手，本身就是一个巨大的话题。有大量的在线课程供你学习，你最好使用这些课程，而不是去找一门大学课程。我用了数据营。

R/Python。这两种语言是数据科学的开源工具包。还有其他使用的语言和软件包，如 SAS，但这两种语言在该领域占主导地位，我猜测接口将被合并到像 SAS 这样的软件包中，因为它们已经被合并到 Power BI 中。我的大学在 R 和 SAS 中教授统计学，我们在教室里学习了统计测试和绘图的基础知识。大量的分析工作都是用这些语言完成的，你需要成为一个强大的程序员。实践是不可替代的。我在 Datacamp 上做了很多课程，以获得基本的熟练程度，然后在业余时间和工作中做项目，以变得更强。

资格的价值

组织是规避风险的。雇佣一个新人是一个很大的风险，即使是有很好的技能和能力的人，如果他们是有毒的，也会对团队不利。雇佣一个没有经过验证的技能的新人更有风险，一个组织承诺培训你，让你跟上速度，这会分散其他团队成员的注意力，所以他们需要的培训越少越好。组织中个人的一个关键激励因素是，他们希望在老板面前看起来不错，更重要的是，他们不想在老板面前看起来像个白痴。雇用一个态度恶劣的不合格的人会扰乱团队，这会让某人在老板面前看起来很糟糕。一个候选人拿着一张认证机构的证明，说这个候选人具备所需的技能，这将大大有助于证明雇佣你的人没有做出错误的决定。学位作为学位是有价值的。他们也是有用的决胜局:如果两个候选人有相同的技能和能力，一个有硕士学位，另一个有学士学位，硕士很可能会赢。

你遇到的人。

你会在大学里遇到其他对分析感兴趣的人，他们会帮助你建立人际网络。

总结。

硕士学位的费用会因国家和机构而异。
数据科学是一个高度技术性的领域，你进入硕士项目的背景将影响你从中获得的价值。
大学一般擅长教授统计理论和学术研究技能。
大学不擅长教授实用技能，比如用 R 和 Python 编程，或者用 SQL 编写查询。Datacamp 等线上平台更好。
机器学习非常流行，技术水平也在快速发展。大多数大学都不是学习这个的好地方，这通常也不是初级分析师的强有力的先决条件。像 Fast.ai 这样的课程是更好的学习实用机器学习的地方。
硕士学位是一种学术资格，它将使你有别于没有学位的求职者。

结论

硕士学位对于找一份数据科学方面的工作很有用，并且教授一些在其他地方很难学到的有价值的技能。有许多大学传统上不擅长的实用技能可以从 Datacamp 这样的课程中有效而廉价地学到。我认为我的硕士是有用的，我在入学后的 3 年里找到了一份数据科学家的工作。

准确性就是一切吗？

原文：https://towardsdatascience.com/is-accuracy-everything-96da9afd540d?source=collection_archive---------4-----------------------

评估分类模型的各种指标

Source

如果你从事机器学习已经有一段时间了，那么你必须开发模型来获得高精确度，因为精确度是比较模型的主要指标，但是如果我告诉你模型评估并不总是考虑精确度而只是呢？

当我们必须评估一个模型时，我们确实会考虑准确性，但我们主要关注的是我们的模型有多稳健，它在不同数据集上的表现如何，以及它必须提供多少灵活性。

毫无疑问，准确性是一个需要考虑的重要指标，但是它并不总是给出全部情况。

当我们说模型是稳健的时，我们的意思是它已经认识到并且正确地并且合意地学习了关于数据，因此它做出的预测接近实际值。

由于涉及大量的数学技术和数据的不确定性，该模型可能会产生更好的准确性，但不能正确地实现数据，因此当数据变化时表现不佳。
这意味着该模型不够稳健，因此限制了它的使用。

例如，假设我们有 980 个苹果和 20 个橙子，我们有一个模型将每个水果分类为一个苹果。那么模型的准确性是 980/1000 = 98%，这意味着我们有一个高度准确的模型，但是如果我们使用这个模型来预测未来的水果，那么它将悲惨地失败，因为该模型被破坏，因为它只能预测一个类别。

人们一定经历过这样一种情况:模型在一个测试集上取得了很好的准确性，但在提供新数据(相同性质)时却表现不佳。

了解模型的全貌，即它如何实现数据以及如何进行预测，有助于深入理解模型，并有助于改进模型。

所以，假设你开发了一个达到 80%准确率的模型，那么你打算如何改进它？要改正错误，首先，我们要认识到错误。
同样，为了改进模型，我们必须从更深层次审视我们的模型表现如何。
这不能通过简单地查看准确性来实现，因此需要考虑其他指标。

在这篇文章中，我将带你了解一些最常用和最重要的分类模型的指标。

首先，我们必须看看混淆矩阵。

混淆矩阵是用于评估分类模型性能的表格。看起来是这样的。

confusion matrix

这里，TN =真负值，即当实际值为“否”时，模型预测为“否”(即正确预测)。

FP =假阳性，即当实际值为“否”时，模型预测为“是”(即错误预测)

FN =假阴性，即当实际值为“是”时，模型预测为“否”(即错误预测)

并且 TP =真阳性，即，当实际值为“是”时，模型预测为“是”(即，正确的预测)

如果你研究过分类技术，那么你一定熟悉混淆矩阵，如果不是，我强烈建议你熟悉。

混淆矩阵是我们计算分类模型的所有指标所需要的。是啊！！！

让我们看看以下指标:

精度: 它是用下列公式计算的:

准确度= (TN + TP)/(TP + TN + FP + FN)

精确度表明了模型做出正确预测的总体频率。

错误率: 错误率告诉我们模型做出错误预测的频率。

分类错误=(FP+FN)/(TP+TN+FP+FN)

从上面的公式可以清楚地看出，

误差= 1-精度

敏感度: 敏感度(也称为召回)是已经检索到的相关实例占相关实例总数的比例。
这意味着召回率是实际值为“是”(或正)时正确预测的值与实际值为“是”(正)的值的总数之比。
换句话说，当实际值为‘是’(正值)时，那么预测值正确的频率，就是回忆。

其计算方法如下:

灵敏度(回忆)=TP/(FN+TP)

这里我们只考虑“是”(正值)的实际值。
从上面的表达式可以清楚地看出，回忆是一个分数(在 0 和 1 之间，包括 0 和 1)。

回忆是一种度量，它告诉我们当所有的实际值都是正数时，我们的模型有多好。

如果 Recall = 0，这意味着当实际值为“是”(正值)时，模型被破坏，甚至不能做出一个正确的预测。
如果 Recall = 1，这意味着当实际值为“是”(正值)时，模型足够好，可以正确地做出预测，但存在一些漏洞，将进一步讨论这些漏洞。

现在有人可能会问——当准确性提供了一般信息时，为什么我们需要考虑回忆呢？

为了回答这个问题，让我们考虑一个例子。假设我们有一个二元分类问题。
假设我们的数据集中有 100 个实例，其中 90 个为 0(负)，10 个为 1(正)。
现在让我们假设，由于类别不平衡，我们的模型预测所有 100 个条目为 0(负)。
准确度等于 90/100 = 90%
如果一个人只看准确度，那么他/她可以说该模型高度准确。但是现在让我们检查一下召回。

Recall = 0/10 = 0
我们得到 Recall = 0，这意味着模型坏了，当实际值为正时，它甚至不能正确分类单个条目。
由此可见，回忆对于评论车型性能是多么重要。
此外，这也表明仅仅依靠准确性并不是评估一个模型的最佳方式。

所以，我们不想要一个非常低的召回值，但是如果我们的召回值非常高(非常接近或等于 1)呢？
如果 recall = 1，那么这意味着当实际值为正时，模型已经正确地对所有值进行了分类。但这也可能是我们的模型预测所有值都为正值的情况，这意味着该模型的精度较低。在进一步讨论之前，让我们先定义一下什么是精度。

精度: 精度(也叫正预测值)是相关实例在检索到的实例中所占的比例。

换句话说，这意味着当模型预测为正值时，模型做出正确预测的几率有多大。

其计算方法如下:

精度=TP/(TP+FP)

这意味着我们希望最大化模型的精度，以便它可以正确地分类相关的实例，但是如果精度太高(非常接近或等于 1)，那么模型将具有非常低的召回率，因为我们仍然会有大量的假阴性。

因此，我们有一个精确召回权衡。我们希望两者都最大化，但最大化一个会最小化另一个。

我读过一个很好的解释:

回忆表达了在数据集中找到所有相关实例的能力，而精确表达了我们的模型所说的相关数据点实际上是相关的数据点的比例。

如果你碰巧在这个领域呆了很长时间，那么你一定知道最大化其中一个是视情况而定的。我们经常会遇到这样的数据集，我们要么需要最大化召回率，要么需要最大化精确度，而不考虑其他因素，因为这几乎没有区别。我能想到一些例子，但我不会深入细节，因为这不是我博客的目的。

为了得到精确召回情况的更“组合”的表达，我们考虑另一个称为 F1-score 的度量。

F1-Score:F1-Score 是通过取召回率和准确率的调和平均值来组合召回率和准确率的度量。

F1 得分= 2(召回率精确度)/(召回率+精确度)

我们使用调和平均值而不是简单平均值，因为它会惩罚极值。精度为 1.0、召回率为 0.0 的分类器的简单平均值为 0.5，但 f 1 值为 0。F1 分数对这两个指标赋予了同等的权重，并且是一般 Fβ指标的一个具体示例，其中β可以调整为对召回率或精确度赋予更大的权重。
因此，如果我们想要一个平衡的分类模型，具有最优的召回率和准确率，那么我们试图最大化 F1 值。

F1 分数是 Fβ指标的一个特例，让我们看看一般情况。

Fβ-score: 它也是一个结合了召回率和准确率的指标，但通过给它们中的每一个赋予不同的权重来实现。
它允许数据科学家更重视召回率或精确度。
计算如下:

最常用的β值是，β = 0.5，1 和 2。

特异性: 又称为真阴性率。 它测量被正确识别的实际底片的比例。

使用以下公式进行计算:

特异性= TN/(TN + FP)

特异性告诉我们的模型对于正确识别假(阴性)有多好。

假阳性率(FPR): 假阳性率计算为被错误分类为阳性(假阳性)的阴性事件数与实际阴性事件总数之比。

使用以下公式进行计算:

FPR = FP/(FP + TN)

因此，FPR 告诉我们，当实际值为负值(假)时，模型对数据的分类是多么错误。换句话说，如果我们只看负面(错误)，那么这个模型把它们归类为正面(正确)是多么错误，这就是 FPR。
也就是说，模型在多大比例下发出错误警报。

马修斯相关系数

到目前为止，我们一直在寻找不能单独用来描述模型稳健性的指标，但是如果我告诉你有一个指标可以“单独”完成这项工作呢？

许多科学家认为，对于任何二元分类器，MCC 是唯一最具信息量的度量。

MCC(就像其他指标一样)是使用 TN、FN、TP 和 FP 计算的。
MCC 不是一个有偏差的指标，也不够灵活，即使在高度不平衡的数据中也能正常工作。

MCC 返回一个介于-1 和+1 之间的值。
系数+1 表示完美预测，
系数 0 表示不比随机预测好，
系数 1 表示预测和观察完全不一致。

其计算方法如下:

结论

因此，我们已经讨论了相当多的指标来评估我们的模型，我们已经看到了准确性如何不是一个人应该考虑判断模型的唯一指标。

我希望这篇文章对你有用，如果你有任何疑问或建议，请写在评论区。

谢谢大家！！

人工智能是增强 IT 运营的明智方法吗？

原文：https://towardsdatascience.com/is-ai-a-smart-approach-to-enhance-it-operations-52a35af2392d?source=collection_archive---------40-----------------------

人工智能现在可以以非凡的速度和规模提供预测性见解。像往常一样，这项技术正在撼动从营销部门到 IT 部门的业务。鉴于它带来的过多可能性，人工智能已经成功地在商业垂直领域和其中的各种功能中获得了足够的兴趣和投资。

但是，碰巧的是，为其他行业提供人工智能和人工智能的 it 组织在使用这些技术方面落后了。随着供应商开始设计和开发强大的分析工具来应对 IT 专业人员在更新、管理和运行整个企业的 IT 软件和硬件时面临的挑战，这种情况可能很快就会改变。

人工智能驱动的 IT 运营(AIOps)是一个相对年轻的概念，但具有巨大的潜力。应用于多种功能的 AIOps 可以显著提高 IT 运营的性能及其成本效益，使企业能够在不牺牲安全性、服务或稳定性的情况下推动更快的创新。

所有领域的关键决策者认识到该技术的潜力，并采取积极措施在其前提下实现这一点，以应对该职能部门面临的紧迫挑战，这只是时间问题。

人工智能可以消除 IT 运营中的挑战

IT 运营绝不是一份令人满意的工作。IT 专业人员陷入了四处追逐警报、修补问题和灭火的循环中。这意味着他们总是对事件做出反应，而不是主动采取措施来防止事件发生。

将系统带到云中可能会让 it 人员从这些任务中解脱出来，但这并不一定会降低 IT 运营的复杂性。以下是 IT 运营人员每天面临的一些挑战:

严格的 SLA 和不容出错的空间增加了 IT 专业人员的压力，他们需要不断寻找错误，并向要求越来越高的客户提供近乎完美的服务。
模块化架构以惊人的速度催生了新的 API 和微服务，使得 it 专业人员更难监控和维护它们。这些服务之间的复杂依赖关系使得 it 专业人员很难找到问题的根本原因。
警报疲劳通常是由手动和基于规则的监控系统的几个误报问题造成的，这些系统无法应对当今动态和复杂的要求。从长远来看，这可能会导致更多的消防演习和紧急情况。
DevOps 的实施意味着更多的运营活动现在由缺乏运营经验的团队管理，这些团队需要解决这些活动的非自动化部分。随着 IT 公司扩展其合作伙伴生态系统，IT 运营部门不得不将监控和维护扩展到组织边界之外，寻找新的方式来衡量 IT 服务并对其收费。

为了应对这些运营 IT 挑战，企业需要一个利用人工智能和人工智能的路线图。让我们看看实现 AIOps 的许多可能方法中的一种。

AI in IT Operations

未完成 AIOps 的 12 个步骤

根据 Gartner 的说法，这是在 IT 运营中实现卓越人工智能的 12 个精确步骤:

成立阶段

通过选择一小组测试用例并确定现有的资源来部署 AIOps，从而建立您的组织的起点。

清点现有数据源
评估现有技能组合
选择少量关键业务应用程序

无功相位

通过对与 IT 运营相关的历史半结构化数据库实施可视化和统计分析，为反应式应用程序和用例部署 AIOps 技术和流程。

建立一个半结构化的历史数据库
实现数据的可视化和自然语言访问
部署统计分析

主动阶段

通过向历史和流式 IT 运营数据部署临时分析和机器学习功能，为主动应用和用例部署 AIOps 技术和流程。

实施流数据接收
使用预测分析来预测事故
参与复杂问题的根本原因分析

膨胀阶段

通过将流程和技术应用于广泛的业务、应用和基础设施问题，扩展整个企业的 AIOps 能力。

与业务流程共享数据和分析
与 IT 运营部门之外的 IT 流程共享数据和分析
将功能扩展到 20 个左右的业务应用程序

随着 IT 基础设施和运营领导者被迫并面临着创建敏捷基础设施以支持其 AI 战略的挑战，AIOps 看起来利润丰厚，前景广阔。

对于 IT 领导者来说，实现其预算要求的成本效益和稳定性的唯一可能方法是使 IT 运营更加主动、可预测和自动化。

CloudFabrix 就是这样一家公司，它将简化您的 IT 基础设施，与您的所有系统无缝集成。他们的 AIOps 平台利用实时数据提供可操作的见解，帮助管理优先任务，而不是浪费时间处理日常任务，从而节省人力、资金和时间。

作者简介

Srinivas Miriyala 是 CloudFabrix 软件公司的一名产品、营销和业务开发人员。

他是一位经验丰富的产品和业务开发专家，在企业软件、移动和电信领域拥有 20 多年的经验。横跨美国、欧洲和亚洲的全球工作经验。拥有 3 项美国专利

在 LinkedIn 上和他联系

人工智能是对民主的威胁吗？

原文：https://towardsdatascience.com/is-ai-a-threat-to-democracy-4bef3e5fcfdd?source=collection_archive---------13-----------------------

Photo by Randy Colas on Unsplash

比较 Web 2.0 前后发生的深刻变化，非常有趣的是——至少不能说令人失望——注意到我们如何从一个共享、合作和自由交流占主导地位的数字乌托邦转向一个我们开始怀疑计算机和互联网的善意的时代。Web 2.0 黄金时代确实离我们还很远。在阅读一些文章时,“算法”这个词的使用方式似乎与我们谈论病毒的方式相同，而另一方面，公司却被法规和约束的丛林所纠缠。

如果我们想在之前和之后的中脱颖而出，我们只能同意社交网络已经完全颠覆了数字世界——不可逆转。我们不必忘记自从社交网络进入我们生活的那一天起，它是如何以及为什么如此受欢迎的——人们终于有机会被倾听。这个工具本身无可指责，但网民用它做什么更令人担忧。崛起几年后，促进民主的最佳工具也是传播错误信息和操纵公众舆论的最佳方式。

GAFA 的角色

脸书有 20 亿用户，谷歌占全球搜索量的 90%，苹果的市值达到 1 万亿美元。这些巨人不仅拥有巨大的经济实力，还拥有无与伦比的社会力量。主要由 GAFA 构建的人工智能和算法已经将信息控制中心从政府转移到他们的平台上，没有任何战斗。国家已经完全失去了对信息管道的控制——除了独裁统治，在独裁统治下，网络浏览被高度控制或者干脆禁止。

主要担心的是，算法在如何过滤和显示信息方面发挥着至关重要的作用。当我说过滤的时候，我完全排除了平台所有者的任何审查或操纵的意图——希望我是对的——但是一旦数据必须被简单地简化以便阅读，社交网络和搜索引擎就不得不应用过滤器以便粗略地切割数据块，因为简单性、人体工程学和流动性对任何用户界面都是必不可少的。以相关性的名义采取的行动可能会受到质疑，因为根据定义，我们不能依赖未经上游第三方抗衡力量审查和平衡的来源。因此，质疑权力如此集中在同一个人手中的数字代议制民主是合乎逻辑的，甚至是理智的。

我们必须记住民主应该阻止什么。民主应该防止权力的巩固。与独裁者不同，一个正常运转的民主国家的领导人知道选民可能会在下一次选举中罢免他们，而正是这种不安全感被认为会让政府对人民负责。

法国政治哲学家孟德斯鸠阐述了三权分立学说，旨在明确区分立法、行政和司法权力。问题是社交网络变得太大，无法被中立的第三方或政府监管。看起来，我们唯一的选择是相信马克·扎克伯格、拉里·佩奇和谢尔盖·布林，相信他们为我们处理和过滤信息的诚意和意图——但鉴于这一参数，人们似乎不同意也是可以理解的。如果你读到最恶毒的评论，GAFA 的政策和行动被认为是极权主义公司。

我想对这种说法做一点细微的补充，即极权主义可以被定义为一种制度，在这种制度中，公共和私人生活的每个方面都是指所有权力都掌握在国家手中的政治制度——这一定义可以证实批评者的说法——但极权主义也定义为国家承认其权力不受限制，并努力进行监管。第二个定义不适用于 GAFA 的垄断情况。

社交网络现在是任何社交聚会和互动的节点。

在最近的事件中，有两个重要的例子显示了社交网络是如何成为孵化器的肉汤，其中一切都变得活跃、成长、爆炸或死亡。在 2019 年 4 月举行的西班牙大选期间，我们再次看到社交网络是政党竞选活动的重要工具，没有人能够想象没有社交网络。

然而，当通过所有不同的社交网络来分析每个政党的受欢迎程度时，有一件令人惊叹的事情。在马克·扎克伯格的平台上，左翼的 Podemos 是赢家，而极右翼的 Vox 是 Instagram 上的领导者，拥有超过 25 万名粉丝。

以下是所有平台的社交媒体表现:

胡里奥·塞萨尔·赫雷罗(记者和社交媒体专家)认为，主要问题是社交网络不能正确地翻译和显示真实的投票意向及其分布。正如他在这篇文章中所说，社交网络“有利于动员、识别和创建群体”，但“我们不应该忘记，它们产生了一种平行宇宙”。

法国黄背心背后的算法

他们只有三个人:两个卡车司机和一个有机化妆品的网上销售员。在没有真正相互协商的情况下，他们得出了相同的结论:他们再也无法忍受燃料价格的上涨。10 月 15 日，脸书的一个活动贴出呼吁一个月后封锁道路。正是在社交网络上，运动诞生了。

多亏了在网络上拍摄和播放的视频，其他人物(比如神秘的 Jacline Mouraud)出现了，并最终成为前所未有的混杂运动的第一批代表。

这就是为什么法国记者文森特·格拉德称马克·扎克伯格为黄背心的“最佳盟友”。Glad 最近写道:“毫无疑问，这场运动得到了新脸书算法的帮助，该算法过分强调来自群体的内容，而损害了页面(以及媒体渠道)发布的内容”。事实上，名为 Edge Rank 的新脸书算法促进了社区和运动的构建。先前的算法已经被修改，以便产生地理上分散的效果。这样一来，这场运动没有任何领导人的事实——这一事实本可以遏制这场运动，或至少将其最小化——已经被多个地方集会严重抵消，这些集会一度在全国范围内聚集，成为自 1968 年 5 月以来法国最暴力的抗议活动。

社交网络不知不觉地支持民粹主义吗？

互联网营销和社交媒体专家与政治家(以前是喜剧演员和演员)的第一次知名合作经历显然是 Giuseppe Piero“Beppe”Grillo 的博客，他与意大利五星运动政党的 Gianroberto Casaleggio 共同创始人。一些分析人士，比如意大利和瑞士记者兼作家、米兰智库沃尔特(Volta)的创始人兼董事长朱利亚诺·达·恩波利，甚至没有将五星运动定性为一个政党，而是一种后意识形态算法。

这个意大利的例子特别有趣，因为它有助于辨别和理解社交网络——以及更广泛的网络——的基本机制之一，即参与营销。在市场营销中，参与是使用战略性和足智多谋的内容来吸引人们，并随着时间的推移创造有意义的互动，以便用户尽可能长时间地停留在网站上。一次点击(即使是随机的)总是会导致更多的信息向同一个方向移动。社交媒体网站的定制化解释了为什么我们不再能在中立和多样化的数字社交环境中浏览。我们会偏离最初的话题，但有必要提及的是，不幸的是，这种机制正是不断增长的阴谋论的根源。

Web 2.0 之前的政治时代的机制——其向心效应是向大众媒体收集意见的唯一方式——已经变成一种机制，在这种机制中，即使是很小的行动(并不明显相似)也会影响可能有不同意见、利益和愿景的多个泡沫(社区)。但是在这个过程的下一个阶段，内容的聚合在于汇总用户的流量，并定义一个共同的目标——完全由源源不断的网络愤怒所驱动。

走向 CICD 民主？

在这场震撼社会的数字革命中，政治还有什么位置？谈到寻找解决方案，我们可以看到非常多样的倡议，例如脸书首席执行官的前室友在《纽约时报》上发表了一篇长文，呼吁解散该公司并对其进行监管。他补充说，也有必要制定一部联邦法律和一个专门负责监管科技行业的机构，以平息谷歌、亚马逊或任何想追随脸书脚步的人的热情。其他倡议；2019 年 4 月斯里兰卡发生袭击事件后，政府担心假新闻传播导致骚乱，因此封锁了社交网络，这可能很快成为一个螺旋地狱。

让我们用一个能让开发者社区微笑的眨眼来结束吧。政府能够采取的唯一明智举措是以最佳方式使用和开发人工智能。政治家们需要意识到人工智能生成的双速系统的滞后(这种滞后正在呈指数级恶化)。它打破了政治信任，使其变得无用和不充分，并使人们越来越不满意——而且越来越不满意。

如果政府想要收回和夺回控制权，就必须迅速做出反应(如果还不算太晚的话……)。想象一下我们古老而过时的政治体系中的一些新管道，比如持续的倾听导致快速而持续的行动，怎么样？如果政府还想在不久的将来生存下去，就必须适应这种剧变，而不是在一场提前失败的战争中与技术作战。

参考文献

Natalia Oelsner & Marta Rodriguez 和 Cristina Abellan-Matamoros，https://www . euro news . com/2019/04/26/weekend-long-read-social-media-use-in-Spain-s-election-campaign-the-good-the-bad-and-the-u，2019 年 4 月 26 日，euronews.com。

桑杰·奈尔，https://medium . com/@ nire spire/what-is-cicd-concepts-in-continuously-integration-and-deployment-4 Fe 3 f 6625007，2018 年 5 月 6 日，medium.com

【nytimes.com】https://www . nytimes . com/2019/05/09/opinion/Sunday/Chris-Hughes-Facebook-Zuckerberg . html2019 年 5 月 9 日

人工智能是我们大颠覆的最后希望吗？还是最新的？

原文：https://towardsdatascience.com/is-ai-our-last-hope-for-a-big-disruption-or-just-the-newest-one-357f9c3db618?source=collection_archive---------32-----------------------

大数据未能兑现其承诺，这给人工智能带来了越来越大的压力和期望

AI 是我们最后的希望吗？让我们放松一下。AI 和 ML 等行业的一个固有问题是现实与幻想之间的斗争。它是什么和它可能是什么。

这些年来，有很多关于现代技术下一次大发展的承诺。因此，各行业已经向它们投入了数十亿美元。如果不是 AI 和 ML，就是 cloud。如果不是云，那就是“大数据”

问题是，承诺和兑现之间的差距往往比我们愿意承认的要大。以大数据为例。大数据可能是突然出现的“最后的新希望”。大量地。

我们在这上面花了几十亿

并且继续这样做下去！根据一些统计，大数据产业价值约 1000 亿美元。这实际上可能是一个保守的估计，但对我们来说是一个大概的数字。

如果大数据每年价值 1000 亿美元，我们估计其中约 40%在专业服务领域。尽管有强烈的关注和投资，但当你得知有多少人失败时，你可能会感到震惊。根据一些统计数据，大约 85%的大数据项目令人失望。

不管怎么说，那都是一大笔钱。那么，AI 是我们最后的希望吗？让我们记住以前的“最后希望”和重大承诺。

但是失败不是风险的一部分吗？

诚然，今天开始的大多数公司都会失败。人工智能、人工智能和大数据也不能幸免于同样的市场力量，这些市场力量决定了哪个流媒体视频应用将超越其他应用，或者哪个订阅盒服务将占据主导地位。

在任何空间，都有失败。很多都是。的确，他们并不总是坏的。失败也有价值。知识是可以获得的。流程是可以改变的。正如托马斯·爱迪生经常被引用的那样:

“我没有失败。我刚刚发现了一万种行不通的方法。”

托马斯·爱迪生，也许吧。

上述观点在咖啡杯或 t 恤上非常管用。在现实世界中，200 亿美元的失败没有什么值得高兴的。

与大数据相关的问题是，大部分数据本来是可以避免的。我们所看到的大数据的涌入本质上是这样的:一场受商业影响的运动，它对商业决策的制定产生了巨大的影响。

所以大数据不好？

远非如此。如果应用得当，大数据非常棒。然而，它真正的迅速崛起在很大程度上是由于两个因素:

从我们第一次知道什么是硬盘到今天，硬盘存储的成本是巨大的。现在存储数据是多么的便宜，这几乎是不可能夸大的。从 20 世纪 50 年代末的每兆几千美元；到今天的零头。

进入大数据，并融入相当大的商业压力，即“您是否充分利用了您的数据？”你有一个价值 1000 亿美元的产业，这个产业充满了希望。

“难道您不想用您的数据做更多的事情吗？在现代，它的获取成本更低，存储成本更低，我们可以分析它，并利用它开发各种有利可图的计划。”

当你告诉百万美元的公司，这里有更多的钱可以赚，并且释放这种潜力的成本很低，你会得到什么？

你会在一夜之间得到 1000 亿美元的产业。

这也不是低估大数据的价值。如果应用得当，大数据可以是所有这些东西。对所有用户来说，这并不是所有的事情。在最坏的情况下，这是一个虚假的承诺，基于商业化的压力，成为下一个大事件的一部分。

AI 是我们最后的希望吗？

几乎没有。人工智能和人工智能相对于大数据难题的优势之一是有更多的机会来确定可以实际实施的解决方案。这些解决方案能够产生切实、显著的影响。

也就是说，所有这些概念的概念。人工智能、人工智能、大数据等提供无限价值或成为社会、人类的救世主，或者仅仅是商业被夸大了。我们认为，以这种方式定位这些技术是一个有根本缺陷的立场。

我们并不怀疑人工智能是否会成为救世主，而是有一点不同的看法。这更像是急于为大数据未能兑现其作为最后一个大救星的承诺提供答案。

想想淘金热

这种对人工智能和人工智能的无限可能性和能力的非理性希望是有缺陷的。我们会把它比作淘金热的心态。也就是说，成千上万的人涌向令人惊叹的承诺。此外，成千上万对潜在客户不感兴趣的人因为害怕错过机会而感到压力。

我们知道那里发生了什么。绝大多数没有一夜暴富。大多数在 T4 发大财的人并不是因为找到了黄金。相反，他们向那些希望暴富的人出售工具、住宿、供应品和其他辅助配件。

在这一点上提及愚者之金是懒惰的。不过需要强调的是，AI、ML、大数据是而不是天生的傻子金。也不是真正的黄金。

然而，虚假的承诺和超商业压力使这些系统成为他们不是的东西，有时会让它感觉如此。

追逐这个闪亮的物体有着巨大的社会和商业压力。无论是黄金还是大数据，甚至是人工智能。然而，我们应该有一个道德标准来衡量我们对这种冲动的反应速度。

随着新技术和新工艺的投入使用，采用它们的压力将会持续存在。从务实的角度来看，我们应该抵制为了收养而收养的冲动。相反，我们应该关注这些工具的实际应用，以及它们如何最好地服务于我们的个人和商业需求。

这对人工智能意味着什么？

大数据虽然有用，但确实无法兑现其崇高的承诺。永无止境的存储，广泛的实际应用，不可估量的盈利分析，不胜枚举。

为了避免陷入同样的陷阱，应该注意的是，AI 和 ML 都已经在各种应用中实现了这些目标中的一些目标。他们将继续创新和探索。

人工智能和人工智能可能会给一个或多个行业带来巨大的破坏。然而，准确地知道这将在哪里、何时或如何形成是很难预测的。

就目前而言，我们这些在这个领域的人应该谨记一句道德箴言，不要过度宣传、过度销售和交付不足。这些技术有足够惊人的可能性，我们不必向世界承诺。

AI 是我们最后的希望吗？大概不会。只是最近的一个。而是为了拥有真正的、开创性的、甚至是颠覆性的力量；它不一定是技术创新的全部。

它必须工作。更重要的是，为你需要它做的事情而工作。

原载于 2019 年 5 月 14 日【https://introspectdata.com。

从长远来看，贵的车更便宜吗？

原文：https://towardsdatascience.com/is-an-expensive-car-cheaper-in-the-long-run-52b2875b0eaa?source=collection_archive---------22-----------------------

dumsnlhet 与二手车价格下降

Image from unsplash.com

有一个瑞典语单词“Dumsnå”，意思是“吝啬到最后会赔钱”。这是一个有趣的概念，与康德的绝对命令有关，因为它们都是关于自我挫败的行为，而且它在日常生活中出人意料地频繁出现。它可以是这样的东西:

开了很长一段路，用了很多汽油去买一个稍微打折的产品
通过不打车来省钱，但却在面试时迟到了
购买廉价的不健康食品，却不得不为健康问题付出代价。
使用少量牙膏，但不得不支付昂贵的牙医
还有，或许，这篇文章的主题，买一辆便宜的车。

我经常想，事实上，买一辆便宜的车是否更贵，我也听到其他人提出这个问题。

一辆汽车的成本是一个复杂的问题，涉及到燃料价格、零部件、机械和长期价值损失等因素。在这篇文章中，我将只看最后一个，价值的损失。

价值损失

在瑞典，几年后卖掉你的汽车是很常见的，因此汽车的实际成本可以更好地描述为(买价-卖价)/拥有汽车的时间。人们普遍认为越贵的车质量越高，保值能力也比便宜的车强，但到底强多少呢？

资料组

为了研究这个问题，我决定使用瑞典公共汽车网站 bilpriser.se (carprices.se)的数据。这是一个主要被人们用来评估他们自己的车或者他们想买的车的网站。该统计是基于 kvarndammens 公司自己的汽车销售数据。价格以千瑞典克朗为单位，在撰写本文时兑换成美元非常容易，因为 10 克朗= 1 美元。欧元的兑换率是 10 克朗= 0.93€。

数据点代表某一汽车型号的平均价格损失。

看着这些数据

让我们画出 10 年后的价值损失。

Value loss after 10 years vs Initial price

单看，初始价格和价值损失之间似乎存在线性关系。但为了以防万一，让我们测试 scikit learn 中的几个回归变量(线性回归、2、3 和 6 次多项式回归、随机森林回归变量)。

为了评估不同的模型，我们将使用 R 分数。R 分数是我们将我们的模型与一个简单得多的模型进行比较的地方:所有数据点平均值的水平线。更多详情点击此处。

将数据分成训练集和测试集(多次)并计算 R 值得出:

Linear regression: 0.824,
Polynomial regression of degree 2: 0.816,
Polynomial regression of degree 3: 0.812,
Polynomial regression of degree 6: -8.27,
Random forest regressor: 0.784

可以看出，线性回归确实是该数据最准确的模型。

根据我们的模型，我们有以下关系:

loss = 0.61*initial_value+33.6

这可以解释为:10 年后，所有的车都损失了 3.36 万 kr + 61%的价值。这意味着平均而言，拥有一辆昂贵的汽车比拥有一辆便宜的汽车更昂贵。这并不意味着所有便宜的汽车都比所有昂贵的汽车便宜，这只是总的趋势。通过查看价格和价值损失之间的相关性也证实了这一点，该相关性为正 92.5%。

5 年和 2 年的回归线是:

loss_5 = 0.41*init+7.9
loss_2 = 0.54*init+23.8

比较不同年代的汽车

到目前为止，我们只研究了全新汽车的价值损失。但是如果我们对比不同年代的车呢。

Buying price and age vs value loss after 5 years

在这个 3D 散点图中很难看到，让我们做一些回归并绘制结果。

在这种情况下，最适合的回归模型是 3 次多项式回归，R 值为 0.865。看起来是这样的。

就像以前一样，总的趋势是越贵的车损失越大，但也有可能看到廉价车中老款车和高价车中新款车增加的迹象。为了看得更清楚，我们将画出上面区域的等高线。那它，恒值损失线。

可以看出，一辆价值约 180 tkr 的新车与一辆使用 5 年、价值约 170 tkr 的旧车价值损失相同。这表明，一辆 5 年车龄、价值约为 175 tkr 的旧车比价值约为 180 tkr 的新车损失更大。这是，在这种情况下购买 175 tkr 汽车有点愚蠢。对于更贵的汽车来说，这种关系正好相反。

结论

如果只比较新车，买一辆便宜的车并不愚蠢，事实上它更便宜。但是，由于固定成本，相对价值损失实际上对于一辆昂贵的汽车来说更小。所以，如果一辆两倍贵的车对你来说价值是两倍，就舒适性或其他功能而言，更贵的车实际上是更好的交易。让我们画出相对价值损失。根据线性回归模型，这当然遵循曲线(0.61x+33.6)/x。

对于二手车和比较不同车龄的车来说，实际上有这样的例子，从长远来看，买便宜的车更贵，尽管影响很小。

额外收获:来自数据的其他见解

每年平均价格损失

Price loss in percent per year

由此可见，买一辆 1 年的车，只用几年就卖掉是最有利的。

作为方框图:

有趣的是，车龄越长，不同车型之间的价格损失就越大。

每个品牌的价格损失

一些汽车品牌更擅长保值。按“价格损失绝对正常”排序，这是根据线性回归线标准化的。

我认为值得注意的是，价格损失率并不一定反映车辆的质量，而是人们对质量的看法，这可能是知情的，也可能是不知情的。

每个国家的价格损失

在瑞典，德国汽车被视为高质量/高地位，日本和瑞典汽车被视为可靠，所以这个结果并不令人惊讶。

对汽车价格损失的分析到此结束。

人工智能可能吗？

原文：https://towardsdatascience.com/is-artificial-intelligence-possible-28b8500d3158?source=collection_archive---------8-----------------------

哲学告诉我们它不是

Photo by Franck V. on Unsplash

在科学研究和工程领域，我们在计算机开发和人工智能方面取得了长足的进步。它现在甚至在我们的家中，例如 Alexa，它能够与我们互动，并根据命令完成任务。然而，这远远不是人类的全部能力。

人类是有情感和认知能力的。现在，我们离创造具有这些能力的人工智能还很远。即使我们设法完成赋予人工智能这些品质的壮举，我们仍然会因为一个潜在问题的答案而功亏一篑:

作为人类意味着什么？

我们可以说，人之为人，就像我上面说的，就是有情感，有认知能力。但是，科学已经证明，动物是有情感的，并且呈现出一定的认知能力。例如，如果动物缺乏某种认知能力，那么狗将无法遵循语音命令，甚至不知道它们的名字。

那么，如果情感和认知也存在于动物身上，那么人类有什么特别之处呢？

人类以为自己存在。

作为人意味着什么的问题基本上是一个哲学问题。我们可以求助于法国哲学家勒内·笛卡尔，他说:“我思故我在。”他这么说的意思是，既然他能够思考和理解他活着，那么他一定存在。笛卡尔延续了这一观点，他说他只能知道自己的存在。然而，他永远无法确定其他人是否存在。

因此，我们人类的核心品质是我们相信自己的存在。但是我们如何知道自己的存在呢？我们周围的世界可能只是一个精心制作的幻觉。

这个哲学原理挑战了人工智能的形而上学本质。为了理解如何，我们必须看看人类存在和快乐原则之间的关系，以及它如何应用于人工智能。

首先，我同意笛卡尔的观点。我只能确定我存在，因为我不知道其他人是否在思考，或者他们是否能思考。一个推论就是我分不清这个现实是不是真实的。

例如，我做过许多梦，或者至少我认为是梦的东西，感觉是真实的。

我记得有一次“梦见”我和父亲在密苏里州，我和他呆了一整天，然后上床睡觉。当我从“梦中”醒来时，我完全糊涂了，因为“在现实中”，我和母亲在得克萨斯州。我试图弄清楚我是如何在密苏里入睡，然后在德克萨斯醒来的。然后我意识到我“梦见”我在密苏里州，但实际上我一直在德克萨斯州。

公平地说，“梦”感觉不像现实。但是，梦和现实之间的区别仍然不能证明这个就是真正的现实。几年后我会发现自己在蓝色药丸和红色药丸之间做出选择。

一切事物和每个人都是为我们而存在的。

既然我们不能确定现实是否存在，那么我们可以得出这样的结论:世界确实是围绕着我们转的。其中的每个人，以及周围的一切，都是为了我们的目的和用途而存在的。如果它不围绕我们旋转，那么它将证明其他人的存在和现实的存在，然而，笛卡尔告诉我们，这种情况是不可能的。

所以如果我们不能证明这种现实存在，那么我们怎么能告诉一台计算机它存在呢？如果我们能够知道的唯一真实的事情是我们作为个体存在，那么我们如何知道计算机是否已经发展出了与人类相匹配的认知能力？

我们也许可以使用图灵测试来测试一台机器，(只有当计算机欺骗一个人相信它是人类时，它才通过测试)，但这无关紧要。这是因为我们无法确定计算机是否意识到它的存在；由于我们“变化无常”的现实，我们也无法将计算机视为一个现存的实体。

“快乐原则”挑战人工智能。

人工智能面临的另一个挑战是我所说的“快乐原则”。在我的文章我作为享乐主义者的生活、中，我谈到了人类行为的驱动因素是快乐。我们采取的每一个行动都是为了追求快乐。如果没有快乐原则，人工智能永远无法与人类智能相媲美。**

事实上，如果我们设法创造出按照快乐原则行事的人工智能，那么我们就违背了最初创造它的目的。这是因为它将变得自私，而不是为我们服务。就像我上面说的，计算机会相信这个世界是围绕着自己转的，并且只有在追求自己的快乐时才会采取行动。

此外，如果我们给机器快乐原则，我们就会面临人工智能接管的威胁，就像“终结者”一样。我们可以通过编程让计算机以服务人类为乐来防止这种事情发生；但是我们剥夺了它的自由意志——因此，没有制造出真正的人工智能。

例如，我们目前有自动驾驶的特斯拉汽车。如果我给汽车设定快乐原则，它只会为自己服务。我可能想去一家豪华的意大利餐厅，但我的红色特斯拉“贝蒂”可能想开车带我去纽约吃披萨，因为它觉得这种旅行本身更令人愉快。然而，如果我给它编程，让它以服务我为乐，那么汽车就不再有自由意志；因此，它不可能真正拥有人工智能。

我们的人性挑战人工智能。

最后，快乐原则和我们的存在本质是不能共存的概念。如果我们给人工智能机器编程，让它拥有知道它存在的能力，而忽略了我们无法判断计算机是否知道它存在的事实，那么它就失去了快乐原则。这都是因为它会意识到它的真正目的是为我们服务。这意味着除了为人类服务之外，它不能设想任何事情——因此没有给它选择自己行动的自由意志。这个限制是因为它现在可以识别它是一个工具而不是人。所以它不能对任何形式的快乐做出反应，因为它实际上不是人类。

如果我们给机器编程，让它拥有快乐原则，它就会对自己的存在失去任何理解。这是因为它将被赋予自由意志，从而阻止机器实现其真正的目的。因此，它永远无法理解它是作为一种工具而存在，而不是一个人。

如果我们不能给一台机器编程，让它知道自己的存在，并拥有快乐原则，那么问题就变成了:

人工智能可能吗？

对我来说，答案是否定的。

人工智能是我们文明中最好的，还是最坏的？

原文：https://towardsdatascience.com/is-artificial-intelligence-the-best-that-has-happened-to-our-civilisation-or-the-worst-2bcec4e86d79?source=collection_archive---------36-----------------------

Photo by @andreasdress

这将是一个剧透警告说:两者都有。然而，我们能同时拥抱两个极端吗？看来人们必须有自己的看法。如果我们将人工智能视为一种工具，我们可以说，它最好由正确的人使用，最坏由错误的人使用。另一方面，这两者之间很少有明确的界限。

如果我们将人工智能视为对社会产生系统性后果的技术进步，那么我们可以说，加剧当前的气候危机或地球上可能经历的不平等是糟糕的。控制人口的数量信息并不新奇，但其规模和范围确实可以说是无所不包。因此，我们可以说，这种气候观点和社会关注是争论它是最糟糕的一条途径。

人工智能和能力

相反，考虑一下如果一颗流星撞击地球，这并不是不可思议的。2019 年 10 月，三颗小行星掠过地球，其中一颗据说只有 24 小时通知。如果是这样的话，或者任何其他对地球上生命的威胁被煽动起来，我们可能希望拥有最先进的技术来帮助解决可能出现的潜在问题。

潘多拉魔盒的描述可能会发现这样说很有用:好吧，魔盒已经打开，你无法收回已经揭示的东西。盒子不能不打开，但是我们可以降低人工智能的使用，降低技术的等级或将其保持在最低限度的使用在玻璃珠游戏中完成，这是一部写于战前的小说，在战争期间出版，并在 1946 年获得了诺贝尔文学奖。

在死亡和毁灭中，一本书问世了，思考乌托邦会是什么样子。我不是一个幻想乌托邦或任何此类事情的人，而是务实地认为，随着时间的推移，一个稍微好一点的世界是可以想象的。在与人工智能相关的担忧中说出这一点很奇怪。赤贫与人权问题特别报告员菲利普·奥尔斯顿最近以相当清晰的措辞描述了对穷人的监督:

“数字福利国家要么已经成为现实，要么正在全球许多国家兴起。在这些国家，社会保护和援助系统越来越多地受到数字数据和技术的驱动，这些数据和技术被用于自动化、预测、识别、监视、检测、瞄准和惩罚。这份报告承认，政府朝着这个方向前进有着不可抗拒的吸引力，但警告称，有一个严重的风险，即陷入僵尸般的数字福利乌托邦。”

因此，以一种被描述为发生在社会上的【最好的事情】的方式使用技术或【数字】似乎是极其无知的。是的，根据一些标准，我们可以说世界正在改善，大多数人都指向统计数据。《垂死的世界》和《着火的房子》等的统计数据。似乎很乐观。

AI &乐观主义

中国***革命家教员在“大跃进”中宣扬的正是乐观主义——为了更好地种植庄稼而捕杀鸟类，但换来的却是虫灾和饥荒。美国的“自由”在形式或形态上似乎只是另一个词再次成为一种可能，与新自由主义看似相反的叙事。如果你愿意，你可以将任何政治意识形态置于人工智能领域之前。

资本驱动或自由的人工智能在某种程度上是科技公司更好地了解人口的情况，一些人将其称为心理图形结合社会计量指标。因此，定量和定性的社会科学家都致力于“采用”或确保某种技术得到应用。如果你有一项交易，那么你会希望确保这项交易继续下去，这让人想起香港最初是如何被撮合的——第一次鸦片战争。**

我不能确定这与真实性有关，或者这有多正确。我不是历史学家，然而历史学家现在似乎想谈论更多的未来。我已经提到把勾勒未来作为一种实践。提前计划或解释过去以采取行动有这种历史化的意味。当我们问这个更好或更坏的问题时，我们对人工智能做出了哪些解释？

AI 与悲观主义

想到的陈词滥调是老电影中的终结者或哈尔，代表人类或某些人类的末日。这当然被某些技术专家用来赚取与投资相关的紧迫感，埃隆·马斯克就是一个支持者。他可能会因此受到批评，但我在技术领域遇到的人，尤其是开发人员，似乎仍然担心这种想法会成为现实。不是拟人化的方式，像人类一样的复仇，更多的是我们应该或不应该犯的简单错误。

前几天提到核战争。如果我们在末日列车上，那么那将是第一批目的地之一。流行病或人为疾病可能是另一个原因。接下来可能是贸易战、经济危机或生态系统崩溃。有很多事情要担心，但是…

人工智能是我们文明发生的最好的事情吗？提到这一点，我不禁想起了川普总统在周四宣布“文明的伟大一天”的画面，此前迈克·彭斯显然促成了与土耳其的停火。一位被指控首先通过撤军挑起这场战争的领导人。国际关系并不简单，国防也是如此。

战争中的自主武器引起了广泛的讨论和越来越多的抗议。反对黑仔机器人的运动已经巡回展示了这些进展。我记得我坐下来看到不同国家正在研发的武器的例子:美国、俄罗斯、中国、英国等等。战争中以各种方式破坏或毁灭的能力正在增加。

AI & Power

人工智能以提取或关闭的方式入侵或扭曲解决方案是有记录的，但是在改变决策过程方面则记录较少。人们认为，人工智能正在赋予世界上一些最富有的人更多的权力，以控制国家贸易或权力的消长。

Amazon.com 的主人杰夫·贝索斯据说是世界上最富有的人。据说比尔·盖茨是世界上第二富有的人。这两位成功地利用了不仅仅是简单的机器学习技术或人工智能作为一个领域，但可以说这是他们持续崛起的原因。另外两位最富有的人都是谷歌的联合创始人，据说他们的公司现在是、【人工智能优先】。

设计范式并没有如此关注技术，但它首先是以自我为中心，然后是以人为中心。现在有人声称我们必须将它改为以生命为中心的设计。这听起来空泛或模糊，然而在设计过程中考虑生态系统应该不是一个新颖的想法。如果人工智能领域可以变得以生活为中心，那会是什么样子？如果是这样的话，难道就没有权力和声望可言了吗？设计是一个计划或规范，而算法是过程和规则，然而这两个领域的考虑并非没有政治。

我越来越多地受到政治科学领域的影响，这一领域倾向于现实主义，从这个角度来看，尤其是在国际安全政策方面，艾既诱人又危险。如果你可以在【敌人】不知情的情况下发动一场战争或获取信息，或者如果你可以发动一场没有任何生命损失的战争——这听起来很像无人机战争，尽管这些都是由人类控制的技术。

人工智能与控制

当我们说由人类控制时，这是一个奇怪的说法，好像有区别。什么不受人类控制？并不是说一个决定会立即生效，尤其是如果它是程序化的。再说一次，人类也做投资，公司有个人身份，有时有更多的权利。有人建议对“人工智能”的应用也这样做，在这个框架内给予“人工智能”作为人的法律地位。然而，将错误归咎于一个系统而不是一个人或一家公司是很奇怪的。我们循环循环，公司是人是公司，我跑题了。

当我们说:这是由制度决定的——我们错了，也是对的。我们是错误的，因为一个人做了决定，我们是正确的，因为一个决定是共同做出的。系统是作为一个机制或一个互连网络的一部分一起工作的一组事物；复杂的整体。人类是这个系统的一部分，他们就是这个系统。

我们可以谈论人机交互，一种跨学科或学科分布的奇怪混合，并混合到科学和技术研究中。有了人工智能，我们就能融入 UX(用户体验)和 UI(用户界面)。我们设计的界面可以识别人脸，并将其归入一个类别——定罪或被定罪，使用或被使用，然后采取行动。也许是人类的行为。

人工智能与证伪

从人类学的角度来看，伪造这些系统是重要的，但却被忽视了。人类学家研究的是经济理论，而不是经济的实际含义，并发现缺乏框架或效果。在技术或人工智能领域，我们似乎需要一名律师来陈述不公正的行为，这是该行业的管辖范围。尽管有这些担忧:人工智能当然是一个【巨大的机会】，联合国在不同的情况下都是这样描述的。

随着科技公司向联合国提供的发展资金不断增加，可疑的问题可能会出现。我听说过一个边缘决定，拒绝一家医疗公司在获得资助后想要测试他们的药物，有些人说不。然而其他人不这样认为，他们说是，我们可以广泛地想知道，我们允许哪些国外的人工智能实验在警务、卫生或其他领域发生？

我认为说我们的文明发生了最好的事情有点夸张，但是进步是不可低估的。我回想起我的父亲和他的帕金森症，或者想在我妻子生病时救她。我也想到了人工智能在绘制气候危机或贫困地图方面可能产生的巨大影响。然而，我不会公开表示乐观，不加考虑的“无国界”创新似乎更不负责任。

石油公司利用气候信息为气候变化做准备，这是有据可查的。从技术公司内部，或者通过人工智能领域解决方案的应用，我们可以看到哪些我们没有立即看到的效果。一个典型的指责是硅谷技术大师的孩子，因为他们限制他们的孩子使用设备，或者旧金山禁止面部识别。

我认为对技术的恐惧和兴奋是一种奇怪的感情鸡尾酒。我可以承认，在处理这些问题或我的流中的各种声明时，我是矛盾的。意识流就是意识流，它似乎经常是某些技术专家在他们的机器中“突破界限”所想要的。如果我们把这种表达带回以前的问题，那么推进我们的行星生态系统的边界似乎是同时进行的冒险。

人工智能与气候危机

制冷、运输、矿物、采矿、电力、带宽、凯斯勒综合症、卫星、月球旅行等等。在技术上突破地球的界限是一种追求，它将这个问题推向了极端，变得夸张。太空旅行和气候友好的梦想在进步和向过去致敬的思想中运作。灭绝的物种会被记住，或者新的行星会被发现。无论是新丝绸之路还是让美国再次伟大，我们本质上都被束缚在途中的某个地方。

我说过我们需要停止展望未来，转而解决目前的状况，然而这似乎是不可能的。不可避免的是，任何改变都与可能是什么或不应该是什么的愿景有关。这个问题立即推进了这个场景制作的空间。这是真实的或错误的，不仅仅是在回顾过去的时候，当看着笔记本电脑的屏幕或在报纸上的时候。什么时候智力是真实的？情报的第二个含义是收集具有军事或政治价值的信息。

我们说的智能是指信息吗？如果是这样的话，那么我们正处于一个前所未有的聪明时刻，前所未有的聪明让人类有可能做出决策。因此，如果我们放下理性的伪装，那么作为一个文明，也许我们可以做得最好或者最好。如果我们不再表现得好像智力比理解、同情意识或理解力更重要。

如果对所提供的信息不做任何处理或处理的价值很小，那么信息就没有什么价值。因此，无论我们收集什么样的情报，我们都必须认为自己对其使用负有责任，并努力理解其好坏。我们决定我们是否真的有能力这样做，无论是独立地还是联合地，无论是好是坏。

这里是#500daysofAI，您正在阅读第 140 篇文章。500 天来，我每天都写一篇关于人工智能或与之相关的新文章。

感谢您的阅读，感谢您的宝贵时间。如果你能分享你由此产生的任何想法，那将是很有价值的。

人工智能是解决全球南方邪恶发展挑战的前沿解决方案吗？

原文：https://towardsdatascience.com/is-artificial-intelligence-the-frontier-solution-to-global-souths-wicked-development-challenges-4206221a3c78?source=collection_archive---------16-----------------------

与 Mohsen Gul(诺丁汉大学)合著。这是基于为开发署非洲创新股进行的研究。

就本文而言，全球南部指的是非洲、拉丁美洲和包括中东在内的亚洲发展中国家。

1 当前景观

迄今为止，几乎所有的研究工作都集中在人工智能(AI)、机器学习、自动化和物联网(IoT)等前沿技术对欧盟、英国和美国等高收入国家人民的影响上。本文的重点是确定人工智能作为一种前沿技术对中低收入国家公民参与的影响的关键例子，这些国家面临着与高收入国家相同的机遇和风险(通常程度更高)，以及这些国家特有的额外机遇和风险。

图 1 显示了全球南部(红色)的地图，并强调了当前的人工智能吸收情况。该地区的测绘工作确定了三大洲 50 多个人工智能应用程序，用于公民参与。这些应用从传统的聊天机器人到先进的机器人和机器学习过程。

根据普华永道(2017 年)的数据，中国将在未来几年获得最大的经济收益，人工智能将使 GDP 增长 14.5%，但它指出，由于人工智能技术的采用率预计将低得多，大多数其他发展中国家将经历更温和的增长。中国国务院最近发布了人工智能发展指导方针，目标是到 2030 年成为该领域的全球创新中心，人工智能产业的总产值预计为 1470 亿美元。中国人工智能产业创新联盟(CAIIIA)成立于 2017 年。新成立的联盟设定了一个目标，即在未来三年内孵化 50 个人工智能产品和 40 家公司，启动 20 个试点项目，并建立一个技术平台。新加坡最近宣布计划在未来五年内向人工智能投资超过 1 亿美元。从 2010 年到 2014 年，中国提交了 8410 项人工智能申请，位居第二。在此期间，日本和大韩民国分别提交了 2071 份和 1533 份。就提交的专利数量而言，印度也是全球十大国家之一。此外，中国和印度是人工智能公司数量排名前 10 位的国家(亚太经社会，2017)。

在中低收入国家，人工智能被用来改善公共服务和公共产品的交付，从试点项目到更大规模的推广，这样的例子不胜枚举。人工智能似乎特别适合简化政府网站上的交易。人工智能也被用于应对公共卫生问题，如预测寨卡和登革热等疾病的爆发。例如，巴西非政府组织 Viva Rio 与初创企业 AIME(医疗流行病学中的人工智能)合作，该公司结合卫星图像识别系统分析现有的地方政府数据集，以部署低成本预测，预测未来三个月内我们预计哪里的疾病发病率会更高。值得注意的是，这项技术是为马来西亚设计的，但它在巴西的试验中有 84%的诊断成功率。在巴西取得低成本成功后，AIME 已被部署到多米尼加共和国。

在其他情况下，人工智能被用于改善警察的覆盖范围，例如在处理交通问题时。在乌干达，人工智能被用于为个人或紧急车辆提供最佳路线建议，动态地重新部署有限数量的交通警察，并分析道路网络的可能重新配置以消除瓶颈。在其他情况下，它被用于环境目的。例如，在肯尼亚，世界自然基金会(WWF)支持无人机使用人工智能设备。9 个月后，超过 12 名猎人在马赛马拉被逮捕。世界自然基金会从 Google.org 获得了 500 万美元的资助，用于使用这种人工智能设备来保护野生动物。人工智能还被用于农业事务，包括用智能手机识别作物疾病。在乌干达开发的 Mcrops 是一种用于诊断木薯植物中病毒作物疾病的诊断工具。生病的植物被实时标记，这使得农民可以采取行动，阻止疾病的传播。在尼日利亚，人工智能正被用来帮助农民通过一个 bot 平台销售他们的产品和购买服务，该平台依赖于短信和其他渠道，如 USSD，Slack 等。

人工智能也被用于预防和预测自然灾害。红十字会/红新月会气候中心与多哥的 Nangbéto 大坝有一个正在进行的项目，该大坝经常溢出，对下游居民的生计造成极大干扰。过去的模型在预测溢出的可能性方面表现不佳，但使用众包信息(包括通过手机)和人工智能技术的组合，开发了一种改进的溢出预测模型。此外，荷兰红十字会的数据倡议利用以前自然灾害的数据开发了模型，以便更好地管理资源和确定援助的优先次序。它是在 2016 年菲律宾台风海马后使用的，经过与受损财产数据的比较，证明是准确的。

基于人工智能的自动翻译和语音识别系统也正在出现，这可能对使用多种语言的国家产生重大影响。包括印度、印度尼西亚和尼日利亚在内的许多中低收入国家就是这种情况。这些系统还可以在文盲率高的地方产生影响，使人们能够通过口头而不是书面方式与政府或公共服务提供者互动。这将特别有利于文盲率高得不成比例的边缘化群体。自动翻译和语音识别系统的一些例子包括由 Pulse Lab Jakarta(印度尼西亚)开发的“Translator Gator ”,用于邀请人们以鲜为人知的语言和方言创建分类法或关键词集合，以及由微软和新加坡政府开发的“Conversations as a Platform ”,用于代表一种根本性的转变，即人类语言的力量将被用来使聊天机器人对公民和选民更具预见性、可访问性、参与性和包容性。

下一节将详细讨论一些案例研究。对于每个案例研究，都提供了有关地理覆盖范围和经营规模的信息。

1.1 案例研究

1.1.1 亚洲

日本议会大赦国际(日本、亚洲；比例:试点)

日本政府正在测试人工智能，以帮助官员起草提交给议会的回应。这项技术将帮助官员起草用于决策的回应，通过挖掘过去对政策问题的意见和官员在议会期间提出的替代建议。政府将首先向该系统输入五年的议会议程总结，然后再做出回应。

根据试验结果，东京将在政府的其他部门扩大人工智能的使用。政府已经启动了一项广泛的计划，在公共服务中使用人工智能和机器人技术。被称为“社会 5.0”的政府设想利用科学和技术在应对老龄化、生产率增长缓慢和提高人类福祉等挑战方面发挥更重要的作用。

新加坡登革热风险地图(新加坡，亚洲；比例:可操作)

作为一个热带国家，新加坡面临着季节性登革热病例，在温暖的 6 月至 10 月达到高峰。该国的主要战略是对登革热热点进行预防性监测。然而，这是劳动密集型的，消耗了本已有限的熟练病媒控制官员。因此，政府决定使用数据来确定登革热风险最高的地区，并帮助该机构更有效地部署人员。

该团队使用机器学习模型创建了一个彩色编码的风险地图。该模型分析来自不同机构的数据，对整个国家的登革热总体风险进行排名。这些数据包括卫生部过去的登革热病例；新加坡统计局的人口估计数；新加坡国立大学遥感图像传感和处理中心的植被指数；来自未来城市实验室 ETH-NUS 的公共交通信息；和来自 NEA 监测方案的蚊子数量数据。

风险地图也有助于开展有针对性的宣传活动，例如，在高风险城镇的公共汽车站投放预防登革热的广告。该项目获得了 2017 年在创新实验室世界举办的 GovInsider 创新奖的最佳数据使用奖。

mAadhaar 应用程序(印度、亚洲；比例:可操作)

印度唯一身份认证机构(UIDAI)推出了 mAadhaar 应用程序，允许用户在手机上携带数字版的身份认证资料。据《经济时报》报道，该应用的用户可以在智能手机上下载他们的 Aadhaar 号码档案，因此不需要随身携带实体卡。Aadhaar 号码是由 UIDAI 向印度公民发放的 12 位随机识别号码，它与姓名和出生日期等基本人口统计信息以及指纹和虹膜扫描等生物特征信息相关联。这些数据存储在一个集中的生物特征 ID 数据库中。Aadhaar 系统有超过 11 亿公民注册，每年为当前政府节省约 20 亿美元。

2017 年 11 月，印度商业和工业部成立了人工智能工作组，启动人工智能在印度经济转型中的应用。

SAAD(迪拜)(阿联酋，亚洲；比例:可操作)

该市首个利用人工智能的政府服务，由 IBM Watson 提供支持。它旨在让企业家和投资者提出与在迪拜建立企业有关的问题，并获得关于各种主题的实时回复，包括企业许可要求和注册流程。“Saad”旨在理解自然语言，摄取和理解大量数据，从其交互中学习和推理，并提供响应，以帮助用户决定正确的行动路线。

吸血鬼工具(印度尼西亚，亚洲；比例:可操作)

印度尼西亚正面临粮食不安全和营养不良的威胁，并面临“高得惊人”的发育迟缓水平。Pulse Lab Jakarta 与世界粮食计划署(WFP)和联合国粮食及农业组织合作开发了一个平台，用于识别需要帮助的受影响社区。吸血鬼可视化工具结合了几个层次的数据:用户可以查看粮食不安全和依赖农业的社区生活在哪里；关于降雨量异常和植被健康的数据；以及这些地区主食的众包价格。安装在总统情况室的吸血鬼，是当局管理食品安全和更好地分配资源的“预警系统”。随着吸血鬼在印尼的成功，WFP 现在正与斯里兰卡政府讨论在印尼安装它。

Bindez(缅甸，亚洲；比例:可操作)

Bindez 的出现源于过去几十年许多国家上网时面临的一个挑战:如何让他们国家的语言与计算机对话。Bindez 是缅甸语索引的首字母缩写，该项目由两名缅甸技术人员 Yewint Ko 和 Htet Will 在 2013 年年中作为本地语言搜索引擎启动，当时该国刚刚对新技术开放，内容消费需求变得显而易见。它现在使用自然语言处理和文本分析来跟踪在线仇恨言论。

1.1.2 非洲

可持续发展和人工智能实验室(非洲；比例:可操作)

该实验室正在结合卫星图像和机器学习来预测贫困。使用根据调查数据训练的最终模型，它可以估计任何有白天卫星图像的地点的人均消费支出。该实验室受斯坦福大学全球发展和贫困项目的委托，并得到美国国家科学基金会的部分支持。

艾滋病毒患者的机器人药剂师(南非、非洲；比例:试点)

机器人药剂师正在南非街头向艾滋病毒携带者分发药物。该国感染艾滋病毒的人数最多——700 万。然而，根据南非卫生部的数据，330 万人没有服用他们应该服用的药物。过去，抗逆转录病毒药物只能通过昂贵的私人护理获得。

机器人不会透露病人的身份，有助于消除任何与疾病相关的社会耻辱。它还将为患有结核病等慢性疾病的其他患者分发药物。有了机器人配药器，患者可能不再需要在医院或诊所等几个小时才能拿到每月的剂量。该试点项目由约翰内斯堡海伦约瑟夫医院的“保健权利”项目管理，由卫生部和非营利的全球基金资助。

类似举措:尼日利亚初创公司 Aajoh 使用人工智能来帮助通过文本、音频和照片发送症状列表的个人，以诊断他们的医疗状况。

中美洲和南美洲

罗西(巴西，南美；比例:可操作)

在巴西，一组数据分析专家已经使用人工智能技术来监控政府官员。他们致力于限制国会议员寻求报销差旅费和伙食费的欺诈行为；在获得启动费用的众筹后，他们创造了 Rosie，这是一个人工智能机器人，它可以分析立法者的报销请求，并计算它们被证明有理的概率。不出所料，罗西发现代表们经常作弊。

类似举措:英国严重欺诈办公室在人工智能初创公司 RAVN 的帮助下开发了一个机器人，该机器人随后帮助政府执法部门筛选、索引和总结了 3000 万份与欺诈调查有关的文件。

CitymisVis(阿根廷，南美洲；比例:可操作)

阿根廷政府与微软拉丁美洲合作开发的一个交互式工具，允许公民报告和跟踪从街道基础设施差到城市卫生设施不足的各种问题。通过这一工具，市政当局听取并回应公民的请求和投诉。由于在几个城市成功采用了 Citymis 社区，每天都会产生大量数据，需要相应的服务部门进行分析。对公民请求和投诉的智能分析可以提高服务协调水平，并有助于相关当局的决策过程。

《我的世界》(墨西哥、中美洲；比例:可操作)

一项联合国倡议正在使用电脑游戏《我的世界》帮助超过 25 个发展中国家的公民设计公共空间，其中包括墨西哥。这个名为“一个街区接一个街区”的联合国项目将这个游戏变成了城市设计中的“社区参与工具”，重点是贫困社区。《《我的世界》》是有史以来世界上第二畅销的电子游戏。在游戏中，玩家使用有纹理的立方体来构建虚拟世界。根据微软研究院剑桥实验室的说法，人们在《我的世界》建造了令人惊叹的建筑，做了令人惊叹的事情，这使得实验者可以投入任务，将人工智能技术扩展到超出其现有能力。

Elefantes Blancos App(哥伦比亚，C. America 比例:可操作

公民使用智能手机应用程序 Elefantes Blancos(白象)发现了 1.63 亿美元的公共工程腐败和低效。这款智能手机应用于 2013 年由哥伦比亚透明秘书处(Transparency Secretariat)推出，自那以来，已经发现了 54 个“白象”项目——那些被公民视为日渐衰落、未完成或被放弃的公共工程。在透明度秘书处的压力下，价值超过 40 万美元的项目中有 15 个已经完成，27 个正在起诉中，12 个项目目前正在调查中( Guay，2017 )。

市民可以将该应用下载到他们的智能手机上，然后上传未完成的公共项目的照片。用户可以对最有问题的项目进行投票，该应用程序决定每个项目的位置和报告频率。透明度秘书处随后开始评估项目的腐败情况。虽然透明度秘书处不能起诉案件，但 Elefantes Blancos 应用程序已经证明了它的价值，该应用程序的控制权将移交给当地审计员——审计员拥有起诉腐败的法律权力。

1.1.4 挑战

必须指出，这一地理区域的国家在政治、经济和社会方面各不相同。因此，人工智能技术在国家和地区层面提出了几个挑战。已查明的一些主要障碍包括:

随着新加坡和印度尼西亚等发达经济体以惊人的速度投资于技术飞跃，一个可能的前沿技术鸿沟正在出现，这使该地区的其他国家面临被抛在后面的风险
在使用和滥用此类技术和相关数据方面，国家、私营部门和发展部门之间普遍缺乏信任
政府和决策者在开发技术先进的治理解决方案方面的技术能力有限，导致过度依赖捐助机构和其他发达国家
有限的研究和基线数据可用于优先考虑国家和区域决策支持系统的基础设施要素
由于技术改造的激增，对技术失业的潜在担忧持续存在。

这篇文章承认，全球南部的一些国家正处于领先地位，预计将成为未来的主要市场。这一突出地位意味着，政府应谨慎考虑本文提出的政策优先事项和问题，以解决道德问题，确保为未来培养适应性强的劳动力，并建立区域层面的体系，以实现可持续的技术创新。

AI 会预测医疗保健的未来吗？*

原文：https://towardsdatascience.com/is-artificial-intelligence-the-future-of-health-analytics-3d54c11e2fe6?source=collection_archive---------27-----------------------

随着医疗保健行业关注人工智能、医学生和从业者的好处，我们不应忽视技术如何塑造该行业的未来。

如果人工智能的目标是创造一种超越最有天赋的研究人员和临床医生的超人智能，那么健康分析的发展将如何影响生命科学的手段、目标和伦理？人工智能是一场重大进化转变的核心，这场转变正在模糊生物学、技术和社会之间的区别。这种相互依赖挑战了死亡率、发病率和医疗保健的传统界限。在快速概述了当今健康分析的机遇之后，让我们回顾一下医疗从业者在不久的将来面临的一些挑战。

健康分析利用数据科学从医疗数据的模式和相关性中开发洞察力，以改进决策。如今，数据科学正被用于诊断医疗状况、提高显微外科手术的精确度、制定治疗计划以及开发更有效的药物。电子健康记录和虚拟助理的逐步引入简化了医疗流程，改善了患者的疗效和安全性。【我】目前的研究表明，机器学习将恶性肿瘤的误诊率降低了高达 85%。【ii】系统地使用算法可以显著减少医疗保险和支付计划中的欺诈行为，这些欺诈行为每年给该行业造成 800 亿美元的损失。【iii】随着该学科的重点从预测转向处方，该行业的经济模式很可能从“成本保健”转变为“健康保健”鼓励患者、家庭和社区改变生活方式，以确保他们未来的福祉。

健康分析的进步正在改变我们对死亡率和发病率的理解。未来学家似乎更乐于争论“超人类”是否会活到几个世纪，而不是探索对人类来说意味着什么。在我们看来，人类的一个决定性特征是自主性:我们做出明智的、不受胁迫的决定的能力。第二个特征是代理——个人独立行动的能力。第三是同理心——理解我们周围世界并与之相关的能力。第四是伦理——帮助人类区分对错的共同价值观。最后，智力唤起我们获取和应用知识和技能的能力。健康分析将如何影响医学界对幸福的定义？

健康分析改变了患者、医生和卫生机构之间的系统关系。量化的自我运动，或“通过数字了解自我”，表明个人对改善自己的身体、精神和情感健康负有主要责任。尽管自我跟踪的概念至少可以追溯到萨摩斯的毕达哥拉斯，但数据科学的发展在很大程度上促进了患者可以使用他们的个人数据来改善“自我护理”的想法。【v】最近，可穿戴设备(Fitbit、Apply Watch、UV Sense……)和环境技术(智能药丸、虚拟语音助手、嗅觉技术……)的广泛采用推动了这一趋势。将所得数据应用于线性回归模型、可视化技术和数据叙事，使患者能够在讨论自身福祉时发出自己的声音。医疗行业应该只关注他们治疗的患者，还是应该为他们服务的人群的福祉而受到激励？

尽管技术对医疗实践的影响从来都不是中性的，但人工智能的引入将严重考验该职业的资质。随着生命科学中机器学习应用的成熟，可用于描述性和规范性分析的算法的多样性和复杂性呈指数增长。医院和医生现在都可以利用人工智能诊断，而不必承担留住更多训练有素的专业人员的成本和时间限制。在标准化机器学习的使用中，从业者可能永远不会花时间研究模型、代码，也不会花时间研究用于建立诊断阈值的训练数据。更令人不安的是，该行业对数据的日益依赖已经微妙地改变了“幸福”、“保密”、“真实”和“信任”的传统定义。【VIII】医学界需要了解 AI 如何改变医疗实践到什么程度？

算法通过处理过去的经验来学习:这些基于规则的程序隐含地再现了制约人类决策的人类偏见。健康分析目前正在从帮助医疗专业人员做出决策的决策支持系统跨越到人工智能领域，在人工智能领域，算法将被设计来取代人类决策。机器学习算法在很大程度上依赖于使用个人数据聚合来评估和预测特定上下文和情况的分析。这些特征反映了几个人的偏见，包括功能固定、设计固定和类比盲目，这些偏见制约了机构、团队和从业者的医疗程序。【IX】如果可以让机构和个人为自己的行为负责，最终谁会为人工智能的隐性偏见负责？

“有限”人工智能的当前应用不会推动生命科学的未来创新。流程、产品或服务创新取决于在新环境和新条件下有效应用发明。AI 学习榜样；构建算法是为了测试可以凭经验测量的变量的特征。即使在病理被充分指定的情况下，AI 也无法探索所有可能的特征(模糊特征假设)，这些特征可能导致对手头挑战的创新解决方案。尽管人工智能模仿理性思维，但它在复制其他形式的人类智能方面几乎没有价值:情感(人际关系)、语言(文字智能)、内省(自知)或精神(存在主义)，这些都影响着医患关系。【Xi】哪些类型的智能将对医疗保健的未来创新至关重要？

总之，人工智能本身很难照亮健康分析的未来。数据科学已经证明了其在改善医学影像、确定治疗计划和加速新药开发方面的价值。此外，人工智能的严格使用可能有助于从业者和研究人员认识到导致诊断错误和不适应医疗实践的隐性偏见。这意味着医疗行业需要了解数据科学如何改变医疗保健的本质。未来的创新将取决于混合和匹配人类和机器的专业知识，以认识到多种形式的智能的贡献。医疗行业必须超越人工智能的限制，鼓励从业者在发展我们未来的福祉方面做得更多，而不是更少。

李·施伦克

*本文将为我们 5 月 15 日在圣塞瓦斯蒂安举行的德乌斯托会议“通过创新管理创造医疗保健价值”的主题讨论提供框架

Lee Schlenker 是商业分析和社区管理教授，也是 http://baieurope.com 商业分析研究所的负责人。他的 LinkedIn 个人资料可以在查看你可以在的 Twitter 上关注白

【I】Evans，r . s .(2016)电子健康档案:那时、现在、未来

【ii】t . Kontzer，(2016)，深度学习将乳腺癌诊断的错误率降低了 85%

【iii】senna ar，k .(2019)，美国四大保险公司如何使用机器学习

【iv】gold hill，D. (2018)，为什么我们比以往活得更长？。

【v】波尔，r .(2014)福柯的关怀

【VI】Lee，j .等(2018)增强人的整体量化自我框架

【VII】…(2018)医疗保健中的深度学习

【VIII】Mittelstadt，b .和 Fioridi，L .(2016)，大数据的伦理，生物医学背景下当前和可预见的问题

【IX】sapsnik，g .等人(2016)，与医疗决策相关的认知偏差:一项系统综述

【x】McCaffrey，t .和 Spector，L. (2012)，每个创新解决方案的背后都隐藏着一个不为人知的特征

【Xi】马丁，(2017)，智力类型以及如何找到自己最适合的那个

人工智能是好莱坞的下一个大事件吗？

原文：https://towardsdatascience.com/is-artificial-intelligence-the-next-big-thing-in-hollywood-535688dfe388?source=collection_archive---------21-----------------------

自从电影成为人们关注的焦点以来，它就抓住了人们的想象力。从 19 世纪 80 年代末的第一部电影到即将上映的最新科幻大片，电影已经成为所有电影爱好者爱、快乐和激情的媒介。几乎全球每个国家都有自己的电影产业。美国的电影产业是当今世界上最大、最著名、最知名的产业。不是别人，正是好莱坞。

好莱坞受到电影观众的普遍喜爱，因为它有能力用最好的技术制作出高质量的电影。计算机生成的图像和视觉效果一直是好莱坞的标志。这个行业以使用最好的技术人员和设备来制作令人惊叹的电影而闻名。

在过去十年中，好莱坞一直在越来越多地投资和试验人工智能(AI)等创新技术。AI 和机器学习算法可以快速、大规模地完成任务。他们能够实时完成各种需要专门团队的工作。如果使用有效，这些新时代的技术可以带来最好的编辑，最好的表演，和最先进的视觉效果。

人工智能——游戏规则的改变者

如今，好莱坞的电影制作工作室正在招聘擅长训练基于人工智能的深度学习和机器学习算法的工程师，这些算法可以完成视觉效果专家的工作。例如，使数字角色看起来逼真或平滑效果等工作。可以通过智能算法轻松完成。高级算法具有自动渲染高级视觉效果的能力。因此，人工智能帮助有创造力的艺术家将他们的精力集中在其他重要的工作上，而不是浪费他们宝贵的时间精心编辑一个效果。

去年的超级英雄大片《复仇者联盟之无限战争》中，美国演员乔什·布洛林扮演了超级大反派灭霸。灭霸在屏幕上出现的视觉效果做得非常好，看起来非常真实，栩栩如生。视觉特效团队是如何完成这一壮举的，他们使用人工智能算法来跟踪布洛林的面部表情，包括他的皱纹等微小细节，然后使用另一种算法将他的面部渲染映射到灭霸的身体上。使用机器学习算法，整个过程可以实时完成。如果这是在没有人工智能的情况下完成的，该团队至少需要几周时间才能使用面部映射和交换技术获得相同的结果。

迪士尼最近推出了可以像人类杂技演员一样表演的机器人杂技演员。机器人杂技演员可以使用人工智能进行编辑，看起来像他们的人类同行。因此，演员可以专注于工作中危险性较小的部分。

21 世纪初，彼得·杰克逊(Peter Jackson)的《指环王》(Lord of the Rings)系列使用人工智能驱动的软件来生成三部电影中出现的庞大军队。2016 年，20 世纪福克斯与 IBM Research 合作，为电影《摩根》开发了一部使用 AI 的电影预告片。IBM 的人工智能认知系统 Watson 被用来制作一部恐怖电影预告片，让观众坐在座位的边缘。

除了电影制作过程中的编辑和表演方面，人工智能可能很快就会被用来决定一部电影是否要拍。据 Variety 报道，一家名为 Scriptbook 的比利时公司已经提出了基于人工智能的算法，可以分析剧本并预测电影是否会获得商业成功。这将有助于制片厂就需要制作哪些电影做出深思熟虑的决定。

使用人工智能进行超个性化用户定位

电影公司通常会花费超过三分之一的预算来营销他们的电影。如果他们能够通过锁定正确的受众来明智地使用营销资金，那么他们的预算就会得到更有效的利用。使用高端人工智能工具，可以根据客户的喜好向他们提供超个性化的内容。

美国电影制作公司福克斯(Fox)与谷歌云(Google Cloud)合作开发了基于人工智能的学习程序 Merlin。Merlin 的主要目标是分析预告片，并确定观众对不同类型电影的基本偏好模式。在线流媒体巨头网飞使用人工智能为其订户提供节目推荐，并在用户点击或鼠标悬停在某个节目上以考虑观看时生成有针对性的迷你预告片。

这种个性化的关系是传统好莱坞公司所没有的。这些公司的大部分产品都被下架或者已经与直接客户关系断绝。电影公司不知道到底谁在看他们的电影和电视剧。然而，这种情况正在慢慢改变。基于订阅的电影票务服务 MoviePass 正试图围绕影院电影业务模仿网飞式的数据驱动模式。

在线视频流与人工智能相结合，使电影制作公司能够建立长期的直接与消费者的关系。这将是好莱坞在不久的将来的一个强大的方面。迪士尼是理解这种模式带来的巨大价值的大型电影制作公司之一。事实上，它已经放弃了与网飞的协议，并在明年推出自己的基于订阅的视频点播服务。

结论

人工智能和机器学习尚未被世界各地的电影公司广泛采用。这是由于他们并不完全理解它们。确实了解人工智能的电影制作人已经开始在剪辑和表演等非常具体的领域使用机器学习和深度学习的元素。

好莱坞和世界其他地方的电影业年复一年地快速发展。根据票房魔咒，去年好莱坞上映的电影数量高达 873 部。这个数字在未来只会继续增加。因此，对于电影制片厂来说，通过真正了解每个电影观众的需求和期望来迎合他们是很重要的。成功会敲开那些能够实现这一壮举的公司的大门。这就是人工智能等技术在建立强大的客户关系方面将发挥关键作用的地方。

原载于 2019 年 4 月 1 日www . great learning . in。

追逐表现最佳的共同基金是徒劳的吗？

原文：https://towardsdatascience.com/is-chasing-top-performing-mutual-fund-a-fools-errand-b5e16f59f381?source=collection_archive---------23-----------------------

停止追逐资金，转而以系统的方式选择它们

Photo by Flo Maderebner on Pexels

正如这里的和这里的所示，追逐去年表现最佳的共同基金今年进行投资被证明是难以实现的，这种策略更有可能导致长期表现不佳。

例如，下图显示，在 2016 年至 2018 年的样本期内，大型印度共同基金类别中没有持续的最佳表现者。

Top performing funds for years 2016, 2017 & 2018 in India Large Cap category

因此，采取“买入并持有”的策略，而不是年复一年地在去年回报率最高的基金之间跳来跳去，是不是更好？

但是，在较长时期内进行的研究表明(参考上述参考文章)，一年内表现最佳的基金在接下来的几年内保持或恢复为表现最佳的基金之一，这种可能性在统计上并不显著。因此，尽管我们可能会节省一些交易成本(通过不定期买卖基金)，但总的来说，这种方法也可能导致长期表现不佳。

嗯……印度有如此多的基金产品，未来选择一只表现最好的基金的机会似乎非常渺茫。有没有更好的方法来持续选择一只表现最好的基金，以提高我们的长期投资组合表现？

本文的其余部分将介绍一种这样的方法。

不要以同样的方式评估不同的基金类别，这一点很重要。例如，仅仅是顶线年化回报率并不是评估债务市场基金表现的好方法。还必须考虑一些与风险相关的措施。

人们可能希望考虑一系列绩效指标来评估基金绩效，根据基金类别和类型，这些指标具有不同的相对重要性。

此外，在评估表现优异者时，不要将不同类别和类型的基金混在一起，这是一个谨慎的想法。例如:在股票类别下，不得将大型基金与小型基金进行比较。这类似于拿苹果和橘子做比较。

采取的总体方法是首先确定一套业绩衡量标准，然后根据要评估的基金类别和类型对其进行不同的加权。最后，一个类别和类型中表现最佳的基金是根据这些不同业绩指标的累积分数来确定的。

使用了以下措施:

过去 3 年的年化回报率
今年迄今的年化回报率
过去 3 年夏普比率
过去 3 年经历的最大水位下降 (MDD)
最近一年内经历的最大提款
95%置信水平下的风险值 (VaR)
95%置信水平下的风险条件值 (cVaR)
99%置信水平下的风险值
99%置信水平下的风险条件值

选择这些指标的原因是为了确保我们不仅着眼于不久前的顶线年化回报，还考虑了前几年的表现。除了考虑与回报相关的措施，我们还需要考虑与这些回报相关的风险。风险可以从不同的角度来看，VaR 和 cVaR 的措施集中在最坏的情况下(短期尾部风险措施)，而 MDD 是一个很好的指标，损失发生在一个较长的时期(想想衰退！).

不同类别和类型的基金对这些措施有不同的重视程度。例如，进取型股票型大盘股基金通过对回报指标赋予更大的权重来进行评估，而风险相关指标在评估保守型债券市场流动性基金时变得更加突出。

为了测试这种方法，开发了一个模型，并根据 15 年的可用历史数据进行了测试。注意避免不同种类的偏见，如前瞻偏见，选择偏见。目标是确定每个基金类别和类型在不久的将来可能的最佳表现者。

举例来说，让我们用 3 年时间2016–2018，尝试在每年年初从以下三个基金类别和类型中选出可能的最佳表现者

股票大盘股
权益中盘
股票主题/板块——金融

从 2016 年 1 月 1 日起，开始投资 10，000 卢比。为了比较业绩，我们根据以下三种策略在每个类别中挑选最好的基金

买入&持有 —挑选 2015 年回报最好的基金，并在未来三年继续投资
去年的赢家 —挑选上一年回报最好的基金。如果一年后，一只不同的基金出现了最佳回报，那么第二年就把投资转向那只基金
VI 模型 —每年年初，根据上述模型选择得分最高的基金。在接下来的两年开始时，我们会遵循同样的流程，如果一只不同的基金成为领头羊，我们就会将投资转向这只基金

注意避免任何前瞻性偏见，为了简单起见，我们忽略交易成本的差异。

结果

大盘股基金

中型基金

部门基金——金融

总结

可以看出，与其他两种方法相比，上述方法能够始终挑选表现更好的基金。尽管我们可能无法每次都在每个类别中选出最佳表现者，但从长远来看，平均而言，这可能有助于我们做出更好的决策。

您可以在http://vianalytics.in/mf_top查看当前表现最佳的员工

大学还值得吗？美国最富有人群的教育

原文：https://towardsdatascience.com/is-college-still-worth-it-the-education-of-americas-richest-people-33e0999e51ef?source=collection_archive---------31-----------------------

随着美国学生贷款总额达到 1.5 万亿美元的历史新高，全国许多高中毕业生和家长都在问自己:上大学还值得吗？

虽然该主题得出的结论是受过大学教育的人一生平均比只有高中文凭的人多挣 90 万美元，但事实是学费增长速度是工资增长速度的八倍和大学债务自 2006 年以来增长了两倍，这使得许多政治家和媒体宣布这是一场全国性危机。

事实上，谷歌、IBM、网飞和苹果等几家顶级公司最近已经从许多招聘信息中取消了四年制学位要求，以重新评估正规教育项目的需求，这些项目往往无法培养出具备在现实世界中成功所需技能的毕业生。

这场运动是否会在全国其他公司中获得动力还有待观察，但这回避了一个问题:这个国家最成功的人怎么办？他们走的是什么职业道路，又是如何走到今天的？

旧货币对新货币

我们深入研究了 30 年的数据来寻找答案。利用美国最富有居民的权威名单《福布斯》400 强的数据和排名，我们直观地展示了从 1984 年到现在美国最富有的人的构成。

我们发现，白手起家的企业家远远超过那些继承了财富并逐年增长的人。

从上面的画面可以清楚地看到，最大比例的“成功”人士——如果财富被认为是成功的主要衡量标准的话——已经为自己铺平了道路，尽管他们中的大多数人来自中产阶级或中上阶级背景。

虽然我们可以得出结论，美国梦确实还活着，而且很好，但下一个需要回答的问题是:这些雄心勃勃的人受过什么教育？

大多数亿万富翁都上过大学

尽管许多人指出马克·扎克伯格(Mark Zuckerberg)和比尔·盖茨(Bill Gates)等富有而成功的大学辍学生为他们跳过大学转而去工作的决定提供了理由，但数据表明，2017 年福布斯 400 强中只有 11%是大学辍学生。

同时，42%的人拥有学士学位；25%拥有工商管理硕士或硕士学位；8%为法学博士或医学博士；还有 5%是博士

不出所料，大多数冒险者——那些没有受过大学教育就冒险发迹的人——属于白手起家，而不是继承财富的人。

为了让这一趋势更加清晰，我们按照教育水平和他们的自我得分绘制了福布斯 400 富豪榜:

在这里，你可以看到大多数名单成员可以在以下象限内找到，从最高百分比到最低百分比:1)受教育程度高和自我得分高的人；2)受教育程度高、继承财富的人；(3)文化程度低、自创分数高者。

这意味着，与流行的观点相反，大多数亿万富翁，包括白手起家的冒险家，都上过大学并获得了学位，即使他们从未运用他们在学校学到的知识积累了巨额财富。

事实上，自 1984 年以来，即《福布斯》首次发布权威富豪榜的几年后，没有大学学历的亿万富翁的比例似乎大幅下降。

诚然，从 2011 年到 2017 年，大学辍学人数似乎略有增加，但更详细的细分显示，福布斯 400 强的教育水平大致保持不变:

顺便提一句，有趣的是，自 1982 年以来，福布斯 400 强创立的零售/餐饮、金融、投资和技术相关业务大幅增长，而房地产业却有所下降。

大学值得吗？

你同意在这个国家获得大学学位是成功的必要条件吗？还是有正规教育被高估了？让我们知道你的想法…

本帖原版 最早出现在 Visme 的 视觉学习中心 。

资料准备和食物准备类似吗？

原文：https://towardsdatascience.com/is-data-preparation-similar-to-food-preparation-42b62c5a96ff?source=collection_archive---------25-----------------------

数据准备介绍

Photo by Brandless on Unsplash

是的，我知道，标题有点奇怪！你一定会想，为什么我要把数据和食物联系起来？这有意义吗？

对我来说，是的。

我知道对你来说，上面的陈述没有足够的说服力。给我一个解释的机会，我保证你也会相信的！

让我们直奔主题，我将解释我把数据准备和食物准备联系起来的原因。

食物准备是收集所有必要的配料/工具，使食物可以食用。它可能包括使用工具来管理这些项目或混合不同的成分来创造味道。

有不同的方法可以实现这一点。假设，我会洗一个土豆，用削皮器剥掉它的外皮，或者用小刀把它切成小块。然后，加入香料使它更有味道，然后可能煮它使它变软或者在一定的温度下烘烤它。(我的意思是当然，为什么会有人吃一个生土豆？咄！)然后最后吃。

所以这些都是我在吃东西之前必须经历的事情。可能还有其他人喜欢其他的方式(比如薯条、土豆泥等等！).但是就像我说的，有不同的方法。但是底线是，在吃任何一种食物之前，都要采取一定的步骤或进行加工，这样，最终，我们可以吃任何东西，而不必经历掉牙齿的麻烦。😛

数据准备也是如此。

在数据准备中，我们执行清理、转换等。原始数据(可以来自任何来源，可以是文档、excel 文件、简单文本文件、数据库、互联网等)。清理一般指填写缺失值/找出空值行或检查重复记录等；转换是将数据从一种格式转换成另一种格式(更有可能是从源系统的格式转换成目标系统的格式)。在这个原始数据上可以执行更多的事情。

现在来说说为什么食物和数据准备是一样的。

在准备食物时:根据前面的例子，我清洗了土豆，因为土豆上可能有污垢。所以最好洗干净再吃。后来，我煮了它(转化)，也就是把它从硬的形式变成软的形式，等等。诸如此类。因此，有许多方法可以处理某些事物。数据准备也是一样，有很多方法和算法可以用来处理数据。

废话少说！让我们进入关于数据准备的深层思想。

Most of the data scientists spend 70–80% of time on data preparation.

数据准备步骤:

Source : talend.com

第一步:第一步是收集数据/信息。这包括从任何来源、数据集等提取信息。(你可以在 kaggle、fivethirtyeight、buzzfeed 等网站上找到各种免费的数据集。)

第二步:这一步包括发现数据；也就是说，理解数据并理解如何处理数据。

第 3 步:下一步是清理数据。正如我之前提到的，数据清理包括填充缺失值、移除离群值、私有化敏感数据等。这样做是为了避免在数据处理的后期可能出现的任何进一步的错误。

第四步:第四步是转换数据，将数据从一种格式转换成另一种格式。因为来自源的数据可以是任何格式，所以有必要确保要处理的数据的内容是相同的格式。有多种格式可以存储日期，比如日/月/年或月/日/年或日/月/年等。为了确保在处理此类数据时不会出现问题，以特定格式存储所有数据非常重要。

第 5 步:丰富数据是增强或提炼原始数据以产生更明智的决策/见解的过程。

第 6 步:一旦准备好数据，就将其存储或发送到第三方应用程序或工具，开始分析。

让我们列举一些数据准备的主要好处:

> 可以帮助你在实际处理开始之前捕捉错误。

> 可以帮助你产生更好质量的数据结果。

> 处理质量更好的数据意味着更好的见解。

> 更好的洞察力会让组织做出更好的决策。

我们已经了解了什么是数据准备，它的过程和它的好处。现在这里的主要问题是:我们到底为什么需要它？如果我们跳过这部分呢？

数据准备需求:

数据准备是数据科学过程的重要组成部分。是的，这是一项单调乏味的任务，但却是一项重要的任务。在实际处理之前，有必要准备好数据。由于您可能已经组合了来自不同来源的数据，并且想要生成整体的见解，因此可能会有一些重复的记录、异常值或包含的所有属性，而不是您预期用于分析的属性。因此，如果数据没有准备好，那么它将只是一些没有重要性或意义的大量数据。

准备更充分的数据将有助于产生更高质量的见解，从而帮助组织做出更好的决策(如前面在数据准备的好处中提到的)。

根据 Gartner 的研究，数据质量差或质量差平均每年会给组织造成 1350 万美元的损失，这是公司无法承受的高昂成本。

此外，如果数据没有准备好，数据集将只是数据的定量，而不是定性。

类似于准备食物，正如我前面提到的，我们很难吃生土豆，但是如果它是烤的或煮的，会更容易吃。

参考资料:

Talend，Digitalvidya，Dataquest.io，Dezyre，

数据科学已经是职业了吗？

原文：https://towardsdatascience.com/is-data-science-a-profession-yet-c08e8d6cca20?source=collection_archive---------27-----------------------

Proficient use of an axe or rifle was as important to the data scientists of yesteryear as knowledge of ggplot2 is to the data scientists of today

数据科学被称为 21 世纪最酷的工作——击败了包括游戏开发人员和职业运动员在内的艰难领域——但数据科学甚至是一种职业吗？

显然，数据科学家这一职业是新生事物之一，这是一些酷的原因之一，但五年或二十年后可能不会那么好。数据科学作为一种职业发展到什么程度了？什么时候我们可以恰当地称自己为职业，并期待外科医生和律师所期待的那种认可(远远超过酷)？

商定的技术技能标准

在数据科学领域，人们已经开始理解哪些技能应该被视为核心技能，但还远未达到在其他职业中被共享的程度。

问题在于，用“比计算机科学家更懂统计学，比统计学家更懂编程”这样的俏皮话来定义自己，会有相当大的模糊性，尤其是当那些制造和重复这句俏皮话的人通常不知道计算机科学家接受了多少统计学培训，或者统计学家接受了多少编程培训。

当然，缺乏整体共识说明了一个更大的问题，那就是缺乏一个关于数据科学家做什么和是什么，以及为什么数据科学有价值的通用且可用的定义。有方便的妙语定义，但这些从来不是用来定义一个职业或其技能集的。

非技术技能的商定标准

对于展示掌握数据科学所需的技术技能，可能没有足够的共识，但至少有一些讨论和一些共享的概念。至于非技术技能，这往往是成功的更大障碍，几乎没有这些东西。

不同职业中常见的一种模式是在职业生涯的早期阶段教授技术基础知识，然后在人们开始工作生活时使用学徒模式教授非技术技能。

众所周知的例子包括这样一种模式:医学实习医生完成医学学位，然后在医院开始作为内科医生工作，然后进入更高级的阶段。同样地，刚开始职业生涯的律师，尤其是那些希望成为法庭辩护律师的律师，会去当更资深律师的学徒，学习更高级的非技术性技能。

在这种情况下，有一种理解是，尽管对法律的理解是先决条件，但对于律师最熟悉的一些活动，如辩护和合同谈判，非技术性技能是核心。

对于数据科学来说也是如此。此外，这些非技术性技能是数据科学家对抗自动化的最佳防御手段。与错综复杂的支持向量机相比，支持理解客户需求或解释数据科学产品如何支持业务战略等活动的非技术技能更能确保数据科学家的长期成功。然而，它们几乎没有得到承认，更不用说在数据科学专业中进行编纂了。

识别师傅和徒弟

其他职业中非技术技能的例子凸显了数据科学的另一个方面，表明它作为一种职业还不成熟——缺乏对如何区分处于数据科学职业生涯不同阶段的人的理解。没有任何里程碑可以表明数据科学学徒和数据科学硕士之间的区别，就像律师获得律师资格或精算师获得研究员资格一样。

这应该被视为一个很好的机会，因为有人(或者更有可能是一群人)有机会定义这个里程碑是什么。它不需要像医学或精算专业那样冗长——它只需要定义仍然需要监督的人和能够独立工作并监督他人的人之间的区别。

对职业的共同理解。

很难就数据科学是什么，以及更重要的是，它如何有用达成一致，这是将数据科学定义为一种职业的障碍，也是所有其他障碍的原因。

宽松的定义对于试图进入数据科学领域的人来说非常好，因为几乎没有办法告诉别人他们不是数据科学家。对于已经在该领域工作的人来说，它们就没那么好了，尤其是那些花了大量时间学习技能，但后来却没有得到认可的人。

尽管有些人可能觉得定义数据科学的限制会束缚他们的个人风格，但对数据科学家所需的基本核心技能的理解将使人们朝着有用的方向发展，而不是追求完全不同的技能，往往收效甚微。

数据科学的危险

可以说，定义数据科学以及如何作为数据科学家取得进展降低了数据科学家的民主性质，在这种情况下，没有看门人，任何人都可以宣布自己是数据科学家，并看看是否有人相信他们。

问题是，如果数据科学的“品牌”不够强大，其他职业很容易窃取市场份额。精算职业是一个明显的职业重叠的例子，但有一个更强的方法来定义他们的职业和人们如何在职业中发展。甚至其他一些经典的数据科学用例，如营销分析，也有不一定把自己视为数据科学家的专业人士。这些专业分析师有自己的专业机构，只需要将现有技能适度扩展到应用机器学习中，就可以在不涉及数据科学家的情况下获得数据科学结果。

这些分析师在他们工作的商业环境中接受过正式培训，因为在任何人使用这个表达之前，数据科学应该是最熟悉的领域，如果他们选择将他们的技能扩展到机器学习等领域，他们比数据科学家有很多优势。

相比之下，由于对技术培训的重视，业务背景的具体知识是数据科学家的一个致命弱点。一方面，没有定义何时他们已经达到足够的技术知识来配得上这个头衔，数据科学家陷入了对工具和技术的更多杂项知识的追逐中。另一边

如果数据科学家不小心翼翼地确保他们能够证明自己的价值，一方面连贯地解释他们如何带来价值，另一方面开发一种标准化的方法并评估他们的能力，他们就面临着将最令人兴奋的项目输给其他类型的分析师的真正风险，这些分析师拥有更强的品牌和更强的特定背景知识。

罗伯特·德格拉夫的书 管理你的数据科学项目 ，已经通过出版社出版。

在 Twitter 上关注罗伯特

数据科学正在消亡吗？

原文：https://towardsdatascience.com/is-data-science-dying-110ea995c66?source=collection_archive---------4-----------------------

对数据科学炒作的现实核查

开始于

在这个行业呆久了的人会联想到这一点。许多年前，这个行业为一种被称为商业分析的类似技能而疯狂。如今，数据科学家一词在互联网上迅速流行，这是一份看起来很有前途的现代工作。

这张图片显示了人们在谷歌上搜索数据科学术语的强度。

是时候将你的数据科学梦想变成现实了

数据科学会成为 2020 年的热点吗？

是的，当然。为什么？让我们看看。

大机构支持

所有大型甚至小型组织都在向数据驱动型企业发展。如今产生的数据太大，无法人工处理。我们需要智能的自动化技术来分析和收集有助于组织改善业务的见解。

竞争是一个主要因素，不在业务中实践数据科学的人很快就会过时。

巨大的工作机会

LinkedIn statistics 分析了这些数据，并将数据科学家排在“2019 年最有前途的工作”的首位。缺少大量熟练的数据科学家，这方面的工作数量正在迅速增加。

各种工作简介

数据科学是一个广阔的领域，不同组织对数据科学家的定义略有不同。一名数据科学家可以申请多个职位，如数据分析师、机器学习工程师、数据分析顾问、大数据工程师等。

摇钱树

由于对数据科学家的需求很高，而供应很低，因此组织支付了大量的金钱。一个经验丰富、才华横溢的数据科学家的薪水高得惊人。

竞争减少

尽管每个人都在谈论数据科学，但真正有技能的人很少。这就是为什么数据科学工作很容易获得。德勤预测将需要 100 万个数据科学家职位。

成为数据科学英雄、拯救生命的时刻

炒作仍将存在，但现在让我们谈谈故事的另一面。你认为数据科学家对他们的工作满意吗？

许多数据科学家正在离开有史以来最性感的工作。

人们放弃数据科学职业的原因

管理者曲解

非技术管理人员并不真正理解数据科学的工作，他们经常曲解工作。开发人员没有被给予正确的问题来回答，并且由于沟通的差距，组织不能从他们的数据中获得最大的收益。许多开发人员发现解释问题的复杂性具有挑战性。

不合适的基础设施

一些公司甚至在没有合适的基础设施的情况下就雇佣数据科学家来解决问题。数据科学完全依赖于海量数据，对于组织混乱或效率低下的数据，你无能为力。

不确定性

有时你可能做对了每件事，但解决方案仍然没有实现。是的，这可能发生，原因是统计数据！

你必须接受这一点。一个软件开发人员可以根据计划实现一些东西，但这在数据科学中是不正确的。

总结一下！！

人们对数据科学太感兴趣了，因此每个人都想转向数据科学。当然，它有许多优势和领域，您可以利用这些优势，但是您应该了解该技术及其工作原理，以便首先在组织流程中实施它。这对每个人来说都会更容易。

希望你喜欢阅读！！

这是通往数据科学目的地的门票

深度学习已经达到极限了吗？

原文：https://towardsdatascience.com/is-deep-learning-already-hitting-its-limitations-c81826082ac3?source=collection_archive---------2-----------------------

The breakthrough “MAC Hack VI” chess program in 1965.

又一个人工智能的冬天来了吗？

许多人认为，算法将超越人类的认知意识。机器将在没有人类干预的情况下识别和学习任务，并成群结队地取代工人。他们真的能够“思考”。许多人甚至提出了这样一个问题:我们是否可以让机器人成为我们的配偶。

但我说的不是今天。如果我告诉你这个想法在 20 世纪 60 年代被广泛推广，人工智能先驱杰罗姆·威斯纳、奥利弗·塞尔弗里奇和克劳德·香农坚持认为这可能在不久的将来发生，会怎么样？如果你觉得这很令人惊讶，看看这个视频，你会惊讶地发现这些观点是如此的熟悉。

时间快进到 1973 年，艾的炒作和夸张适得其反。英国议会派詹姆斯·莱特希尔爵士去拿一份英国人工智能研究的现状报告该报告批评人工智能研究未能实现其耸人听闻的说法。有趣的是，莱特希尔还指出了专门的程序(或人)如何比它们的“人工智能”同行表现得更好，并且在现实世界环境中没有前景。因此，人工智能研究经费被英国政府大幅削减。

在池塘的另一边，美国国防部在人工智能研究上投入了大量资金，但后来因为同样的挫折取消了几乎所有的资助:夸大人工智能的能力，高成本而无回报，以及在现实世界中的可疑价值。

20 世纪 80 年代，日本狂热地试图用第五代项目 ( 编辑 : 托比·沃什本人在评论中纠正了我。英国的研究在 20 世纪 80 年代随着 Alvey 项目对日本的回应而重新开始。然而，这最终也是一场耗资 8 . 5 亿美元的失败。

第一个艾冬天

20 世纪 80 年代末带来了一个人工智能冬天，这是计算机科学的黑暗时期，在这一时期，“人工智能”研究让组织和政府遭受交付失败和沉没成本的损失。这样的失败将会终止几十年的人工智能研究。

通常，这些公司是由 FOMO 而不是实际用例驱动的，担心他们会被自动化竞争对手甩在后面。

到了 20 世纪 90 年代，“人工智能”变成了一个肮脏的词，并持续到 21 世纪初。人们普遍认为“人工智能就是不起作用”。编写看似智能程序的软件公司会使用“搜索算法”、“商业规则引擎”、“约束求解器”和“运筹学”这样的术语。值得一提的是，这些无价的工具确实来自人工智能研究，但它们被重新命名，因为它们未能实现它们更宏伟的目标。

但在 2010 年左右，一些事情开始发生变化。人们对人工智能的兴趣再次迅速增长，图像分类比赛吸引了媒体的眼球。硅谷坐拥海量数据，第一次有足够的数据让神经网络变得有用。

到 2015 年，“人工智能”研究占据了许多财富 500 强公司的巨额预算。通常，这些公司是由 FOMO 而不是实际用例驱动的，担心他们会被自动化竞争对手甩在后面。毕竟，让一个神经网络识别图像中的物体绝对令人印象深刻！对于外行人来说，天网能力肯定是下一个。

但这真的是迈向真正 AI 的一步吗？还是历史在重演，只是这一次被少数成功的使用案例所鼓舞？

人工智能到底是什么？

长期以来，我一直不喜欢“人工智能”这个词。它模糊而深远，更多是由营销人员而不是科学家来定义的。当然，营销和流行语可以说是刺激积极变化的必要手段。然而，流行语运动不可避免地导致混乱。我的新华硕智能手机有一个“人工智能铃声”功能，它可以动态调整铃声音量，使其刚好超过环境噪音。我想可以用一系列“如果”条件或一个简单的线性函数编程的东西叫做“人工智能”。那好吧。

有鉴于此,“人工智能”的定义广受争议也就不足为奇了。我喜欢杰佛瑞·德·斯梅特的定义，它指出人工智能的解决方案是针对具有不确定答案和/或不可避免的误差的问题。这将包括从机器学习到概率和搜索算法的各种工具。

也可以说，AI 的定义不断演变，只包括开创性的发展，而昨天的成功(像光学字符识别或语言翻译器)不再被认为是“AI”。所以“人工智能”可以是一个相对的术语，很难说是绝对的。

近年来，“人工智能”经常与“神经网络”联系在一起，这也是本文的重点。还有其他“人工智能”解决方案，从其他机器学习模型(朴素贝叶斯，支持向量机，XGBoost)到搜索算法。然而，神经网络可以说是目前最热门和最炒作的技术。如果你想了解更多关于神经网络的知识，我在下面发布了我的视频。

如果你想要更全面的解释，请点击这里查看格兰特·桑德森关于神经网络的精彩视频系列:

安 AI 复兴？

2010 年后人工智能炒作的复苏仅仅是因为掌握了一类新的任务:分类。更具体地说，由于神经网络，科学家们已经开发出对大多数类型的数据进行分类的有效方法，包括图像和自然语言。甚至自动驾驶汽车也是分类任务，周围道路的每幅图像都转化为一组离散的动作(加油、刹车、左转、右转等)。为了简单了解这是如何工作的，请看这篇展示如何制作视频游戏 AI 的教程。

在我看来，自然语言处理比纯粹的分类更令人印象深刻。很容易相信这些算法是有意识的，但如果你仔细研究它们，你会发现它们依赖于语言模式，而不是有意识构建的思想。这可能会导致一些有趣的结果，比如这些机器人会为你搜索骗子。更新:这项服务自 2017 年 12 月因“改进”被奇怪地下线，我倾向于认为该机器人并没有像承诺的那样工作，因此它处于非活动状态。

可能自然语言处理最令人印象深刻的壮举是谷歌双工，它允许你的 Android 手机代表你打电话，特别是约会。然而，你必须考虑到，谷歌训练、构建甚至硬编码的“人工智能”就是为了完成这项任务。当然，假打电话的人听起来很自然，有停顿，“啊啊”和“嗯啊”…但同样，这是通过对语音模式的操作完成的，而不是实际的推理和思考。更新:这种技术似乎已经被夸大了，因为许多谷歌双工电话是由人工呼叫中心处理的。

这一切都令人印象深刻，肯定有一些有用的应用。但我们真的需要降低我们的期望，停止炒作“深度学习”能力。如果我们不这样做，我们可能会发现自己在另一个人工智能的冬天。

历史重演

NYU 大学的 Gary Marcus 写了一篇关于深度学习的局限性的有趣的文章，并提出了几个发人深省的观点(在文章走红后，他还写了一篇同样有趣的后续文章)。罗德尼·布鲁克斯正在整理时间表，并跟踪他的人工智能炒作周期预测，并预测我们将在 2020 年看到“深度学习的时代已经结束”的头条新闻。

怀疑论者普遍认同几个关键点。神经网络需要大量数据，即使在今天，数据也是有限的。这也是为什么你在 YouTube 上看到的“游戏”人工智能例子(像这一个以及这一个)经常需要几天不断输掉游戏，直到神经网络找到允许它获胜的模式。

我们真的需要降低我们的期望，停止炒作“深度学习”能力。如果我们不这样做，我们可能会发现自己在另一个人工智能的冬天。

神经网络是“深”的，因为它们在技术上有几层节点，而不是因为它对问题有深刻的理解。这些层也使得神经网络难以理解，甚至对于它的开发者来说也是如此。最重要的是，当神经网络冒险进入其他问题空间时，它们正在经历回报递减，例如旅行推销员问题。这是有道理的。当一种搜索算法会更加简单、有效、可扩展、和经济(如下图所示)时，我为什么要用神经网络来解决旅行推销员问题呢？

Using search algorithms like simulated annealing for the Traveling Salesman Problem

我也不会使用深度学习来解决其他日常“人工智能”问题，比如解决数独或把事件打包到日程表中，我会在另一篇文章中讨论如何做到这一点:

[## 数独和时间表

用树搜索解决调度问题

towardsdatascience.com](/sudokus-and-schedules-60f3de5dfe0d)

当然，有人希望将更多的问题空间推广到神经网络中，尽管这很有趣，但它似乎很少胜过任何专门的算法。

麻省理工学院的卢克·休伊特在本文中对做了最好的阐述:

仅凭一项任务就凭直觉判断一台机器有多聪明，或者有多大能力，这不是一个好主意。20 世纪 50 年代的跳棋游戏机器让研究人员感到惊讶，许多人认为这是人类推理水平的巨大飞跃，但我们现在意识到，在这场游戏中实现人类或超人的表现远比实现人类水平的一般智能容易。事实上，即使是最优秀的人类也很容易被简单启发式搜索算法击败。人类或超人在一项任务中的表现不一定是在大多数任务中接近人类表现的垫脚石。

—卢克·休伊特

我认为同样值得指出的是，神经网络需要大量的硬件和能量来训练。对我来说，这是不可持续的。当然，神经网络的预测效率要比训练效率高得多。然而，我确实认为人们对神经网络的雄心需要不断的训练，因此需要指数级的能量和成本。当然，计算机的速度越来越快，但是芯片制造商能克服摩尔定律的失败吗？

要考虑的最后一点是 P 对 NP 问题。用最简单的术语来描述这一点，证明 P = NP 意味着我们可以计算非常困难的问题(如机器学习、密码学和最优化)的解决方案，就像我们可以验证它们一样快。这样的突破将极大地扩展人工智能算法的能力，也许会让我们的世界面目全非(有趣的事实:2012 年有一部名为 《旅行推销员》 的智力惊悚电影探索了这一想法)。

这里有一个很棒的视频，解释了 P 与 NP 的问题，值得花 10 分钟观看:

An explanation of P versus NP

可悲的是，在这个问题正式提出 50 年后，越来越多的计算机科学家开始相信 P 不等于 NP。在我看来，这是人工智能研究的一个巨大障碍，我们可能永远无法克服，因为这意味着复杂性将永远限制我们所能做的事情。

这是有道理的。当搜索算法更有效、可伸缩、更经济时，我为什么要用神经网络来解决旅行推销员问题呢？

正是因为这些原因，我认为另一个人工智能的冬天即将到来。2018 年，越来越多的专家、文章、论坛帖子、博主站出来呼吁这些限制。我认为这种怀疑主义趋势将在 2019 年加剧，并将在 2020 年成为主流。公司仍在不惜重金获得最好的“深度学习”和“人工智能”人才，但我认为，许多公司意识到深度学习不是他们所需要的只是时间问题。更糟糕的是，如果你的公司没有谷歌的研究预算、博士人才或从用户那里收集的海量数据，你会很快发现你的实际“深度学习”前景非常有限。这在 HBO 节目硅谷的这个场景中得到了最好的捕捉(警告:语言):

每个人工智能的冬天之前都有科学家夸大和宣传他们创造的潜力。仅仅说他们的算法能很好地完成一项任务是不够的。他们希望它能雄心勃勃地适应任何任务，或者至少给人以它能胜任的印象。例如， AlphaZero 做了一个更好的下棋算法。媒体的反应是“天哪，艾将军来了。所有人找掩护！机器人来了！”然后，科学家们不再费心去纠正它们，而是用巧妙的选词来鼓励它们。降低预期终究无助于风险投资。但是，尽管人工智能研究人员有机器人的局限性，但他们将算法拟人化可能还有其他原因,这更多的是哲学而不是科学。我将把它留到文章的结尾。

那么下一步是什么？

当然，并不是每一家使用“机器学习”或“AI”的公司实际上都在使用“深度学习”。一个优秀的数据科学家可能被雇佣来建立一个神经网络，但是当她实际研究问题时，她反而更适合建立一个朴素贝叶斯分类器。对于那些成功使用图像识别和语言处理的公司来说，他们会很高兴地继续这样做。但我确实认为神经网络不会远离这些问题空间。

降低预期终究无助于风险投资。

过去的人工智能冬天在推动计算机科学的边界方面是毁灭性的。值得指出的是，这种研究产生了有用的东西，比如搜索算法可以让有效地赢得象棋或者最小化运输问题的成本。简而言之，创新的算法出现了，它们通常擅长于某一特定的任务。

我想说的是，对于许多类型的问题，有许多行之有效的解决方案。为了避免被人工智能的冬天拒之门外，你能做的最好的事情就是明确你试图解决的问题，并理解其本质。之后，找到为特定问题提供直观解决方案的方法。如果你想对短信进行分类，你可能想使用朴素贝叶斯。如果你试图优化你的运输网络，你可能应该使用离散优化。不管来自同行的压力如何，你都被允许带着健康的怀疑态度接近复杂的模型，并质疑这是否是正确的方法。

希望这篇文章非常清楚地表明，深度学习不是解决大多数问题的正确方法。没有免费的午餐。不要为你所有的问题寻找一个通用的人工智能解决方案，因为你不会找到一个。

我们的思想真的是点积吗？哲学 vs 科学

我想在这篇文章中抛出的最后一点是，它更多的是哲学而不是科学。我们的每一个想法和感觉仅仅是一堆数字以线性代数的方式相乘和相加吗？事实上，我们的大脑仅仅是一个整天做点积的神经网络吗？这听起来几乎像毕达哥拉斯哲学，将我们的意识简化为一个数字矩阵。也许这就是为什么如此多的科学家相信通用人工智能是可能的，因为人类和计算机没有什么不同。(我只是指出这一点，不评论这个世界观是对是错)。

不管来自同行的压力如何，你都被允许带着健康的怀疑态度接近复杂的模型，并质疑这是否是正确的方法。

如果你不接受这种毕达哥拉斯哲学，那么你能争取的最好结果就是让人工智能“模拟”动作，给人一种它有情感和思想的错觉。一个翻译程序不懂中文。它通过寻找概率模式来“模拟”理解中文的错觉。当你的智能手机“识别”一张狗的照片时，它真的能识别一只狗吗？还是它看到了之前看到的数字网格？

相关文章:

[## 2019 年学数据科学的感受

透过(决策树)看到(随机)森林

towardsdatascience.com](/how-it-feels-to-learn-data-science-in-2019-6ee688498029) [## 游戏 AI 的实用价值

我们通过自动化消遣获得了什么？

towardsdatascience.com=](/ai-research-and-the-video-game-fetish-71cb62ffd6b3) [## 我们的思想真的是点积吗？

人工智能研究如何复兴毕达哥拉斯主义并混淆科学与哲学

towardsdatascience.com](/are-our-thoughts-really-dot-products-ede6049cbd92)

深度学习是医疗决策的未来吗？

原文：https://towardsdatascience.com/is-deep-learning-the-future-of-medical-decision-making-b36ba17ddbf7?source=collection_archive---------35-----------------------

Photo by Christian Bowen on Unsplash

医疗保健经常被认为是一个处于人工智能革命边缘的领域。人工智能领域的知名人士，如谷歌 DeepMind) ，宣传他们在医疗保健领域的努力，声称“人工智能将改变医学。

但是到目前为止，人工智能的影响力有多大呢？我们真的确定了医疗保健领域将受益于新技术吗？

在今年 5 月举行的关于“计算系统中的人的因素”的 ACM CHI 会议上，谷歌的Carrie j . Cai展示了她关于以人为中心的工具的获奖作品，该工具用于处理医疗决策过程中的不完善算法，讨论了机器学习算法在医疗决策中越来越多的使用。她的工作提出了一种新的系统，使医生能够实时改进和修改病理图像的搜索，不断增强系统的可用性。

从过去的患者中检索视觉上相似的医学图像作为对新患者做出医疗决策时的参考，这是一种非常有前途的途径，其中最先进的深度学习视觉模型可以高度适用。然而，在特定诊断过程中捕获用户所需的相似性的确切概念对现有系统提出了巨大的挑战，因为存在一种被称为意图差距的现象，这指的是捕获用户的确切意图的困难。我们稍后将更详细地讨论这一点。

蔡的研究展示了他们在医学图像检索系统上开发的优化工具如何提高图像的诊断效用，最重要的是，提高了用户对用于医学决策的机器学习算法的信任。此外，研究结果显示了用户如何能够理解潜在算法的优点和缺点，并从他们自己的错误中消除歧义。总的来说，这项工作对医疗保健专家决策中人-人工智能协作系统的未来提出了乐观的看法。

在这篇文章中，我们希望了解三个主要领域，即(1)基于内容的图像检索系统的状态，(2)深度学习在这些系统中的作用，以及(3)关于它们在医疗保健中的应用和影响的讨论。

基于内容的图像检索系统的现状

在过去的二十年左右，基于内容的图像检索(CBIR)已经成为计算机视觉中一个活跃的研究领域，这主要是由于 web 上可视数据的可访问性不断增长。基于文本的图像搜索技术由于与视觉内容的不匹配而遭受许多不一致，因此在许多情况下，将视觉内容视为相似性的排序线索是重要的。

周文刚等人指出了 CBIR 系统中的两个关键挑战，他们称之为意图鸿沟和语义鸿沟。

Figure 1 — Taken from the paper “Recent Advance in Content-based Image Retrieval: A Literature Survey” by Wengang Zhou et al.

意图差距，顾名思义，指的是通过手边的一个查询，比如一个示例图片或者一个关键词，来捕捉用户的确切意图的难度。这是 Carrie J. Cai 等人利用他们在用户界面中的改进工具提出的挑战。纵观以往的研究，通过示例图像形成查询似乎是探索最广泛的领域，直观上是由于通过图像获取丰富查询信息的便利性。这需要从图像中提取精确的特征，这就引出了下一点，语义鸿沟。

语义鸿沟处理用低级视觉特征描述高级语义概念的困难。现在，这个主题已经吸引了多年来大量的研究，取得了一些显著的突破，如不变局部视觉特征 SIFT 的引入和视觉词袋(BoW)模型的引入。

图 1 显示了 CBIR 系统的两个主要功能。匹配查询理解和图像特征之间的相似性也可能是重要的一步，但这完全取决于系统表达查询和图像的程度。

最近基于学习的特征提取器的激增，如深度卷积神经网络(CNN) 开辟了许多研究途径，可以直接应用于处理我们在 CBIR 系统中讨论的语义差距。这些技术比手工制作的特征提取器有了显著的改进，并且已经证明了在语义感知检索应用中的潜力。

深度学习的作用

Carrie J. Cai 等人分析的 CBIR 系统的基本细节由 Narayan Hedge 等人在其研究“组织病理学的相似图像搜索:SMILY ”中详细介绍。该系统的概况如图 2 所示。

卷积神经网络(CNN)算法用于图 2 所示的嵌入计算模块，该模块充当系统中的特征提取器。网络将图像信息压缩成数字特征向量，也称为嵌入向量。使用预先训练的 CNN 算法计算并存储图像数据库(在这种情况下为病理图像切片)及其数值向量。当选择查询图像进行搜索时，使用相同的 CNN 算法计算查询图像的嵌入，并与数据库中的向量进行比较，以检索最相似的图像。

Figure 2 — Taken from “Similar Image Search for Histopathology: SMILY” by Narayan Hegde et al.

此外， Narayan Hedge 等人解释说，CNN 架构基于由王江等人提出的深度排名网络，它由卷积层和池层以及级联操作组成。在网络的训练阶段，输入三组图像:某一类别的参考图像、同一类别的第二图像和完全不同类别的第三图像。对损失函数进行建模，使得网络在来自相同类别的图像的嵌入之间分配比不同类别的图像的嵌入更小的距离。因此，来自不同类别的图像有助于加强来自相同类别的图像的嵌入之间的相似性。

使用自然图像(例如，狗、猫、树等)的大数据集而不是病理学图像来训练网络。在学会区分相似的自然图像和不相似的自然图像之后，相同的训练架构被直接应用于病理图像的特征提取。这可以被视为神经网络在数据有限的应用中的优势，通常被称为迁移学习。

CNN 特征提取器为每个图像计算 128 个大小的向量，并且选择 L2 距离作为向量之间的比较函数。 Narayan Hedge 等人使用 t-SNE 可视化了从病理图像切片数据集产生的所有嵌入，如图 3 所示。(a)显示由器官部位着色的嵌入物,( b)显示由组织学特征着色的嵌入物。

Figure 3 — Taken from “Similar Image Search for Histopathology: SMILY” by Narayan Hegde et al.

事实上，类似于深度排名网络的架构和训练技术在深度学习文献中可以广泛看到，如 Sia messe 神经网络，甚至已经应用于人脸检测应用。
现在，回到 CBIR 系统，我们看到深度学习可以帮助减少语义鸿沟(如上所述)，因为这些基于学习的方法被证明在识别重要特征方面令人印象深刻，即使是在有噪声的自然图像中。

在医疗保健领域的应用和影响

到目前为止，我们研究了什么进入了 CBIR 系统，以及深度学习在克服语义鸿沟这一关键挑战方面的潜力。但是 CBIR 在医疗保健领域有多大的适用性呢？我们能清楚地量化影响吗？

Henning Müller 等人指出，仅日内瓦大学医院的放射科在 2002 年一天就生成了超过 12，000 张图像，其中心脏科是第二大数字图像生成部门。研究进一步指出，医疗信息系统的目标应该是“在正确的时间、正确的地点将需要的信息传递给正确的人，以提高护理过程的质量和效率。”因此，在临床决策中，支持技术，如基于案例的推理或基于证据的医学，都希望从 CBIR 系统中受益。

无论技术多么完善，在实际临床实践中整合这些系统都需要大量的工作，特别是在系统和用户之间建立信任。这是 Carrie J. Cai 等人的研究的优势所在，因为它非常灵活地提供了用户的相关反馈，这为用户提供了对系统返回的结果进行评级的能力。 Henning Müller 等人还谈到了在交互环境中相关反馈对于改善系统结果以及提高 CBIR 系统适应性的重要性。

另一个要点是量化这些系统的影响，这对该研究领域的适应和发展至关重要。在对 12 名病理学家进行用户研究后， Carrie J. Cai 等人声称，使用他们的 CBIR 系统，用户能够以更少的努力提高系统的诊断效用。此外，结果显示增加了信任，增强了对用户的精神支持，并提高了将来在实际临床实践中使用该系统的可能性。但是诊断的准确性(尽管经验表明保持不变)没有在这项研究中进行评估，因为它超出了范围。

展望未来，显然需要医学专家和人工智能系统开发人员的持续合作，以确定用例并评估人工智能应用在医疗保健中的影响。此外，研究社区应该关注开放测试数据集和查询标准的开发，以便为 CBIR 应用程序设定基准。这将极大地有助于通过对贡献的清晰认识推动研究向前发展。

本文原载于 The Gradient 。希望你喜欢阅读。

特别感谢张休、史密斯和徐的真知灼见和评论。

深度学习是不是大到不能倒？

原文：https://towardsdatascience.com/is-deep-learning-too-big-to-fail-8930505d7ab1?source=collection_archive---------45-----------------------

“Occupy Portland: Day 1” by eliduke is licensed under CC BY-SA 2.0

上周， OpenAI 发布了他们去年的人工智能和计算分析的更新，其中人们可以读到人工智能的计算“以 3.4 个月的倍增时间呈指数增长(相比之下，摩尔定律的倍增周期为 2 年)。自 2012 年以来，这一指标增长了 300，000 倍以上(2 年的翻一番只会产生 7 倍的增长)。”

鉴于这种令人难以置信的增长率，一些问题出现了:最先进的人工智能是否从中受益？这种增长速度可持续吗？如果不是，我们是否正在迎来一个新的人工智能冬天？

嗯，看起来深度学习模型变得越来越庞大，而规模准确性却没有从中受益太多。正如 Jameson Toole 在他的文章中令人难以置信地解释的那样，深度学习有一个规模问题。它还有一个尺寸问题，因为如果我们希望人工智能能够扩展并集成到企业流程中，人工智能模型应该设计为适合普通的计算能力设备，而不是最先进的执行 GPU。仅举几个图尔提到的例子:

“今年早些时候，NVIDIA 的研究人员宣布了 MegatronLM ，这是一个拥有 83 亿个参数(比 BERT 大 24 倍)的大型变压器模型，在各种语言任务中实现了最先进的性能。虽然这无疑是一项令人印象深刻的技术成就，但我不禁问自己:深度学习的方向正确吗？

仅参数一项在磁盘上的重量就超过 33 GB。训练最终模型用了 512 个 V100 GPUs 连续运行 9.2 天。给定每张卡的电力需求，信封背面的估计显示，用于训练该模型的能量是普通美国人年能量消耗的 3 倍以上。"

看看这些数字，这似乎是一个很好的例子，说明当涉及到人工智能的普通消费者时，巨大的力量展示并不会真正成比例。

退一步说，我们必须认识到人工智能可以通过改善这三个轴中的一些来改善:算法创新，更好的数据和计算能力，我完全同意 Jameson Toole 的观点，即我们应该把效率放在我们的首要任务(如果不是首要任务的话)算法创新当最大化计算能力时，如果我们希望人工智能民主化。

最后，我们不要忘记更多的数据并不一定意味着更好的数据。我们需要高质量的数据:公正和多样化的数据，这些数据实际上可以帮助人工智能造福于许多社区，这些社区远未获得像玩 AlphaStar 所需的最先进的计算能力。

只有当我们使用高效且具有积极社会影响的算法(因此大多数公民都可以使用)并通过无偏见和多样化的数据进行训练时，深度学习才会“大到不能倒”。它太大了，因为它将为那些大到不能倒的人服务:人民。

如果你喜欢读这篇文章，请 考虑成为会员 以便在支持我和媒体上的其他作者的同时获得每个故事的完整访问权限。

Genie 比 Flask 好吗？

原文：https://towardsdatascience.com/is-genie-better-than-flask-aa87717e9c8?source=collection_archive---------15-----------------------

语言和 Web 框架之间的战争

enie 是 Julia 的一个高性能网络框架，它是一种动态的高级多范例编程语言。Genie 最大的优势可能是它在一种快速、简单的语言中的强大基础，这种语言具有许多特性，可以很好地支持 web 框架和函数式编程。Julia 是麻省理工学院开发的一种开源、快速、动态类型的编程语言。

另一方面， F lask，你可能很熟悉。Flask 是 Python 的一个 web 框架，Python 是一种由 C 解释的高级语言，以易学和具有类似英语的语法而闻名。Python 是一门伟大的语言，因为有很多开发人员使用它。它易于使用，并因其统计功能而备受推崇。

Genie 和 Flask 都是很好的工作框架，使用起来很有趣。虽然 Genie 在许多方面更像 Django 而不是 Flask，但在许多方面，两者肯定可以进行比较和对比。但是如果你没有经验，今天不得不学只是一个，

应该是哪个？

语言

每当我们谈论使用 Genie 时，首先需要确定的是 Genie 内置的语言，Julia。与 Python 这样的语言相比，Julia 有几个很大的优势，Python 可以渗透到用这两种语言创建的任何东西中。Julia 明显比 Python 快。虽然这对于许多应用程序来说不是什么大事，但对于许多需要读取和执行复杂操作的数据科学应用程序来说，这需要数百万个观察值；速度非常重要。当然，我们都听说过 Python 的速度问题，尽管它在大多数情况下相对不错，但在更大的数据和大数据领域中的任何事情在 Python 中基本上都是无法管理的。Julia 非常擅长处理大型数据集，它同时管理 Hadoop 的能力也是一大优势。

另一方面，Python 在大多数情况下的运行速度大约是计算速度的一半。虽然这是一个很大的飞跃，但对于大多数应用程序来说，Python 非常棒，会做得很好。然而，Python 肯定有局限性，尤其是在笔记本服务器的内核中。Python 相对于像 Julia 这样的语言的最大竞争优势是它在数据科学中的广泛应用。大多数数据科学家都知道 Python，Python 可用的包明显比 Julia 的更合适。尽管 Julia 并不一定是一门难学的语言，但它绝对比 Python 难学得多。

结构

enie 的网络应用程序开发与 Django 的更接近；很多开发都是通过 REPL 完成的，尤其是最初。Genie 中的网络应用程序可以完全输入到 REPL 中，这使得在创建文件之前测试代码变得很容易。和 Django 一样，Genie 也有一个大的文件系统框架，在创建数据类型时提供了一个简单的模板。

Genie 的另一个巨大优势是虚拟环境的运行方式。Julia 虚拟环境、服务器和静态文件都包含在项目的文件系统中。这对于管理依赖性和进行调整非常有用。

另一方面，Flask 采用了极简的部署方式。无论是使用 Docker 还是 Pip 虚拟环境，使用 Flask、环境和依赖项管理都取决于您。这对于数据科学和管道来说是非常好的，因为大多数 DS APIs 不需要任何静态文件，或者至少最终需要更少的静态文件。通常，像 Julia 的 Genie 甚至 Python 的 Django 这样的框架中的过度结构化会使创建和部署应用程序的过程变得更加冗长和乏味。对于 Genie 独特的、自包含的虚拟环境 REPL 和服务器，这变得更糟。Genie 的启动时间可能会更复杂和困难，尽管在 Julia 中打开一个完整的 REPL 比 Bash 包装器更方便。对于我来说，Flask 最大的优势就是它的简单性。Flask 和 Python 一样，更容易上手，更容易使用。有了每天使用 Flask 的人们的广泛的社区支持，Flask 的文档和易用性肯定比 Genie 领先很多。

部署

部署是 web 框架开发中的一个重要步骤。Genie 的部署是通过一个服务器来处理的，这个服务器可以通过 sh 命令来访问，而不需要任何外部应用程序。另一方面，Flask 需要 Gunicorn 3，这是一个需要通过包管理器安装的服务器。Gunicorn 3 可以从 bash 运行，允许运行几个服务器参数。Genie 中的依赖项是通过 REPL 处理的，它可以用 sh 加载并作为文件移动。Flask 没有虚拟环境，但是通常用户会使用 pipenv/virtualenv 来创建他们的环境。

所有这些意味着 Genie 的部署稍微容易一些，管理员只需要运行一个命令就可以完成工作。另一方面，Flask 需要首先激活虚拟环境，然后运行服务器。当然，这没什么大不了的，但重要的是 Gunicorn 有多难找到工作。有时，某些应用需要特定的参数，proc 配置总是必要的。考虑到这一点，对于部署，我认为 Genie 是更简单的解决方案。这并不是没有警告——Genie 在 Heroku 或 AWS 上更难使用。至于 Linux 部署，我已经介绍过了，因为我已经写过关于在 Linux 服务器上部署这两者的文章:

精灵

烧瓶

最后的想法

在我看来，Flask 和 Genie 都是很棒的工具，最大的出入来自语言。显然，Julia 是我最喜欢的语言，这让我产生了很大的偏见，但是 Python 的魅力是毋庸置疑的，尤其是作为一种几乎通用的高级语言。总的来说，我认为最大的区别在于两个框架本身的包装。Genie 的解决方案更有效率，支持成熟的网络应用，但也能很好地实现管道化。

人类的直觉能被注入机器的直觉吗？

原文：https://towardsdatascience.com/is-human-intuition-transferable-to-a-machine-27c9cd15b0ad?source=collection_archive---------42-----------------------

Source of Image: https://www.if4it.com/core-domain-knowledge-critical-foundation-successful-design-thinking/

我们经常看到不同的机器和深度学习模型努力模仿人类水平的表现。例如，我们还不能创建能够检测对象、理解它们之间的关系并总结图像中的事件的视觉模型，这些模型可以与任何人执行这些任务的能力相媲美。你有没有想过为什么？

即使给我们的模型提供了海量的数据，用不同的超参数排列，我们仍然无法达到人类水平的性能。我们很清楚，这个模型没有捕捉到我们的大脑几乎在潜意识中能够捕捉到的细微差别。这是因为包含了人类随时间积累的先前多面知识。这被称为“人类知识”。即使在用我们的机器和深度学习模型尝试了不同的策略之后，我们仍然觉得好像缺少了什么。我们的模型中缺少人类知识。我们人类之所以是我们，是因为我们在生活中所面对的。我们之所以是我们，也许是因为我们的童年、我们的错误、我们的经历以及我们看待生活的方式塑造了我们的生活。

你认为我们人工制造的计算机或任何模型能够像我们一样执行任务吗？你认为机器有希望达到我们的理解水平吗？。答案既不是肯定的，也不是否定的。让我解释一下为什么。

这不是一个响亮的“不”，因为已经有太多的人试图将上下文的概念注入我们的机器和深度学习模型，以便让机器在任何场景中学习什么、为什么和谁[8]。这不是一个简单的肯定，因为这仍然是一项正在进行的工作。现在，你可能会有这样一个问题，你如何让一台机器在任何给定的情况下掌握上下文的概念。

答案并不简单。有许多方法可以将上下文的概念引入到模型中。其中最著名的一次是多模态知识图的使用。知识图是试图模仿真实世界关系并保持其语义完整的表示。例如，通过使用三联体，像“男人骑自行车”这样的句子被表示为。

知识图表:现实世界关系的基于图表的知识表示。

“知识图(I)主要描述组织在图中的真实世界实体及其相互关系，(ii)定义模式中实体的可能类别和关系，(iii)允许任意实体彼此之间潜在的相互关系，以及(iv)覆盖各种主题领域。[1]"

Source of Image:https://medium.com/@sderymail/challenges-of-knowledge-graph-part-1-d9ffe9e35214

已经有许多知识图是通过尽职调查构建的，并且由于其大规模的跨学科适用性而非常著名。一些最著名的是 DBPedia，麻省理工学院媒体实验室的 ConceptNet，谷歌的知识图谱等。一些知识图也是多语言的，这为知识图增加了多方面的知识。

Different Knowledge Graph Examples. Source of Image: https://www.csee.umbc.edu/courses/graduate/691/fall18/07/

“知识图可以被设想为与特定领域或组织相关的各种事物的网络。它们不限于抽象的概念和关系，还可以包含文档和数据集等事物的实例。[2]"

知识图的一个局限是它们不是动态的[9]。至少就我所知，我还没有遇到过动态的知识图，当它获得新信息时会自动更新。所有知识图都是静态的，需要使用人工干预来更新。在大多数情况下，这是非常棘手的，因为人们需要小心我们在图表中添加了什么样的信息。特别是在当今世界，虚假数据和错误信息是一个巨大的问题，验证真实性和技术健全性是极其重要的。因此，人类干预成为必要，知识图保持静态，无法获得动态性质。

知识图表是静态的，需要人工干预来检查添加到其中的数据的真实性！

然而，知识激发的学习不一定只是知识图表。如此多的研究人员提出了如此多令人兴奋的新想法，以将上下文信息注入到我们的机器和深度学习模型中。

让我们考虑像图像修补这样的计算机视觉任务。(如果你不知道什么是图像修复，那么请看看我的文章“ 不同的计算机视觉任务 ”来更好地理解它)。对于像图像修补或图像重建这样的任务，一些人提出了将图像作为一个整体来考虑并试图抓住图像中缺少的东西的想法。而其他人则专注于通过将重要权重与先验相关联，仅基于丢失区域附近的周围像素的上下文来预测图像的丢失区域的详细上下文[4]。很少有人尝试创建一个上下文编码器，该编码器具有类似编码器-解码器的框架，其中编码器捕获图像的上下文并将其投影到潜在特征表示中，解码器使用这些表示来产生缺失的图像上下文[5]。一些人采用了多模态方法，该方法考虑了图像注释的语言表示和语言属性以及图像的视觉表示和视觉属性，并提出了结合来自图像和文本的知识来理解上下文的联合模型[6]。

在其他计算机视觉任务(如视觉关系检测)中，很少有人尝试使用语言先验知识来添加信息。我遇到的另一个想法是将从概念网(知识图)获得的知识结合到神经图像字幕模型中，称为概念网增强神经图像字幕(CNET-NIC)[7]，以帮助增加模型的信息。

这些只是人们如何想出新方法来弥合人类直觉和机器理解之间的差距的几个例子。

我希望这篇文章对你有所帮助。

下次见！

感谢您的阅读！

资源:

[1]保罗海姆。知识图精化:方法和评估方法综述。语义网期刊，(预印本):1–20，2016。

[2] A .布鲁莫尔。从本体论的分类法到知识图，2014 年 7 月。https://blog . semantic web . at/2014/07/15/from-taxonomies-over-ontologies to-knowledge-graphs【2016 年 8 月】。

[3]卢，c .，克里希纳，r .，伯恩斯坦，m .，，L. (2016 年 10 月).基于语言先验的视觉关系检测。在欧洲计算机视觉会议(第 852–869 页)。斯普林格，查姆。

[4]Yeh，R. A .，Chen，c .，Lim，t .，Schwing，A. G .，Hasegawa-Johnson，m .，& Do，M. N. (2017 年)。基于深度生成模型的语义图像修复。在IEEE 计算机视觉和模式识别会议论文集(第 5485–5493 页)。https://wiki.dbpedia.org/

[5]Pathak，d .，Krahenbuhl，p .，Donahue，j .，Darrell，t .，& Efros，A. A. (2016 年)。上下文编码器:通过修补进行特征学习。在IEEE 计算机视觉和模式识别会议论文集(第 2536–2544 页)。

[6]n .加西亚，b .雷诺斯特和 y .中岛(2019 年)。通过绘画中的多模态检索理解艺术。 arXiv 预印本 arXiv:1904.10615 。

[7]周，杨，孙，杨，&霍纳瓦尔，V. (2019 年 1 月)。利用知识图改进图像字幕。在 2019 年 IEEE 计算机视觉应用冬季会议(WACV) (第 283–293 页)。IEEE。

[8]Sheth，a .，Perera，s .，Wijeratne，s .，& Thirunarayan，K. (2017 年 8 月)。知识将推动机器理解内容:从当前的例子中推断。在网络智能国际会议论文集(第 1-9 页)中。ACM。

[9]帕德希，s .，拉利斯塞纳，s .，&谢思，A. P. (2018 年)。创建实时动态知识图。

更多资源:

概念网:http://conceptnet.io/

内尔:永无止境的语言学习:【http://rtw.ml.cmu.edu/rtw/index.php?】T2

知识图定义:https://www . research gate . net/profile/Wolfram _ Woess/publication/323316736 _ forward _ a _ Definition _ of _ Knowledge _ Graphs/links/5 A8 d 6 e 8 f 0 f 7 e 9 b 27 C5 B4 B1 c 3/forward-a-Definition-of-Knowledge-Graphs . pdf

了解更多关于知识图的信息:https://medium . com/@ sderymail/challenges-of-Knowledge-graph-part-1-d 9 FFE 9 e 35214

有可能预测不良姿势吗？

原文：https://towardsdatascience.com/is-it-possible-to-predict-poor-posture-af309ead03e2?source=collection_archive---------44-----------------------

将数据科学应用于现代姿态问题

Photo by Alejandro Escamilla on Unsplash

你现在弯腰驼背吗？很有可能。无论你是俯身在笔记本电脑上，无精打采地躺在沙发上，还是只是把下巴微微缩向手机，我们大多数人都会以一种远非理想的阅读姿势打开这篇文章。

我们都知道姿势很重要。它传达自信(或缺乏自信)，影响我们的整体健康，并能改变我们的情绪。但是，我们当中很少有人采取必要的行动来纠正我们的数字时代带来的越来越糟糕的状况。

已经有很多关于姿势和背痛的研究，那么为什么我们仍然发现自己仍然如此弯腰驼背呢？当我创造了 PocketPosture.com，我开始学习为什么人们不改变他们的姿势习惯。是不是太复杂了？不良姿势是否与我们工作/学习/放松的方式交织在一起？我们是不是太忙而没有时间去担心它？或者也许我们都只是太懒了？

为了解决姿势问题，我首先提出了几个问题。

激励性问题:

哪些因素与不良姿势和背痛相关？
有没有办法预测不良姿势和腰疼？
人们给出了哪些避免治疗和改善的理由？

我联系了 Y Combinator 的校友 Doug Hoang，他的公司专注于改善体态。BackAlerts 是一个传感器，它靠在你的背上，跟踪你的姿势，并在你无精打采的时候轻轻地提醒你。他们还提供有针对性的姿势锻炼计划，一定要去看看。

即使有像 Back Alerts 这样的好工具，普通人目前也没有做任何事情来改善他们的姿势。

为什么获得持久的正确姿势仍然如此困难？

数据收集:

我没有找到任何生活习惯与姿势相关的公开数据，所以我选择通过调查来制作自己的数据。要了解更多关于这种混乱的收集过程，请阅读我的另一篇文章，这里是详细的。

数据:先看

这项调查是通过谷歌表单进行的，它输出预先制作的图表，我们可以仔细阅读任何立即跳出来的东西。

Results for two of the daily routine questions

大多数人大部分时间都坐在办公室里，并且有各种不同的通勤时间。没什么特别令人惊讶的。

Responses to posture questions. [Scale 1=horrible posture]

看起来，对于人们如何评价自己的姿势，人们的反应几乎是完全对称的，与人们认为更糟糕的姿势略有偏差，许多受访者担心自己的姿势。大多数人也选择了 3 级姿势，这可能表明人们没有完全意识到自己的姿势或如何正确评价它(纯粹是猜测)。

Frequency scale [Never — Constant]

Severity scale [Barely perceivable — Severe]

看起来疼痛的频率和严重程度比反应分散了一些。幸运的是，与姿势不佳的人相比，有严重疼痛的人似乎更少。再说一次，这里没有什么激进的东西，但是有一点令人惊讶的是，许多受访者都是 20 岁出头。

我决定看同样的问题，但是将图表分成子集，看看是否有任何明显的模式。下面是一些 ggplot 图表。请记住，受访者从 1 到 5 对他们的姿势进行评级，1 是“可怕的姿势”，5 是“惊人的姿势”。

The higher the activity level [0–4] the more weekly exercise they have.

Sit Ratio is the percentage of their day spent sitting

我们再次看到越来越多的人白天坐着睡觉，但是我并没有马上想到什么模式。可能有一个轻微的模式，高度活跃的人有更好的姿势评级。

我还研究了锻炼频率(活动水平)和受访者是否关注自己的姿势之间的关系。

在这里，更积极和更担心你的姿势之间似乎有关系，但仍然不明显。

然后，我花了一些时间尝试了几种聚类方法(python 中的 k-means、k-modes 和 k-prototypes)。然而，分类变量、连续变量和顺序变量的混合使得结果不是很有帮助，因为很难充分评估聚类。【参见关于 k-modes/k-prototype 的讨论这里、这里、这里、这里、这里、这里、这里和这里 …咳，我有一个 lot 选项卡打开了长时间】

无论哪种方式，我们都不能对这些数据做出任何明确的判断。所以我挖得更深一点…

数据处理/特征工程

幸运的是，数据不需要太多的处理。调查中只有几个自由形式的答案(国家和城市)。我创建了一个基本的正则表达式来标准化这些位置的响应。例如，“US”、“usa”、“united states”、“u.s.a .”等都变成了“USA”以便于分组。

接下来，我为可能有多个答案的分类特征创建了自定义虚拟变量，为有比例响应的问题创建了序号变量。然后，我使用 pd.get_dummies 为剩余的分类值创建虚拟变量。

统计分析

现在数据已经是友好的格式了，我终于准备好开始回答我的问题了:

问题 1:是否有可能预测一个人是否体态不佳？

问题 2:有可能预测某人是否有背痛吗？如果是这样的话，我们能预测他们哪里会痛吗？

问题 3:在做出这些预测时，什么因素是重要的？

我将它们分解为二进制分类问题，并在 70/30 的训练/测试分割中测试了 3 个不同的模型，以了解它们对该数据集的预测能力(逻辑回归、随机森林分类器和 KNN 分类器)。

有没有可能预测一个人是否体态不佳？

为了回答这个问题，我将人们的姿势等级(从 1 到 5，5 是很好的姿势)作为目标变量，并运行了多个模型。在我测试的早期，对于任何模型，结果都不是很好——只有不到 55%的测试集被正确分类。因此，我采用了序数特征，并把它变成二进制的。我假设那些把自己的姿势评为“3”或更低的人是“不良姿势”。使用自我报告的姿势水平存在固有的主观偏见；然而，我没有时间去研究 300 名参与者的每个人的姿势。更重要的是，我的潜在问题围绕着为什么人们不采取姿势矫正行动，这基本上是基于一个人对自己姿势的感知，而不一定是临床诊断。注: 【测量】姿势 有很多方法需要参与者端的多人和更多的努力。随着数据收集方法的发展，这可能会成为一种探索。

有了重构的目标变量，我能够得到更有趣的结果！以下是参数调整后每个模型的一些最佳结果。

Metric comparison table for Logistic Regression, Random Forest, & KNN

所有这三个模型的精确度相似，约为 75%,但 logisitc 回归模型的精确度明显更高，ROC 更有利。见此处 研究为什么逻辑回归会胜过随机森林。

ROC curve for reduced feature Logistic Regression, Random Forest, and KNN (n=4)

哪些特征在预测中很重要？

我从逻辑回归中使用 RFE 包提取了一个可变重要性的排名(见下文)。

*#take the fitted regression and extract the importance ranking of each variable and create a data frame* logreg = LogisticRegression(solver="liblinear")
rfe = RFE(logreg)
rfe = rfe.fit(X_m, y_m.values.ravel())importance=pd.DataFrame([rfe.support_,rfe.ranking_])
importance.columns=X_m.columns
importance

由于随机森林的表现相对接近逻辑回归，我很想知道哪些特征对逻辑回归和随机森林都很重要:

通勤持续时间
通勤类型[步行、自行车、驾车、公共交通]
性别
睡眠满意度[从 1 到 5 分]
拥有一个活动跟踪器(Fitbit、Pebble 等)
如果他们曾经因背痛而去看医生或接受治疗

查看简化逻辑回归模型的实际系数，我们可以将我们对特征重要性的解释延伸得更远一些。

随着通勤时间的增加，不良姿势的可能性也会增加。
乘坐公共交通工具的人不太可能报告不良姿势。
女性更有可能有不良姿势(大多数受访者是女性，所以这可能是有偏差的)。
对他/她的睡眠越满意，她被归类为不良姿势的可能性就越小。那些趴着睡觉的人认为他们的姿势更糟糕。
拥有一个 Fitbit 类型的设备增加了被归类为良好姿势的机会。然而，拥有一个类似 Fitbit 的设备而不使用它是一种不良姿态的标志(比根本没有设备更是如此)。
那些报告使用 CBD 药物和顺势疗法治疗疼痛的人比那些使用处方药治疗疼痛的人对自己的姿势评价更高。此外，那些看过医生的人更有可能被归类为不良姿势，而那些看过物理治疗师的人被归类为不良姿势的可能性要小得多。

有可能预测某人是否有背痛吗？如果是这样的话，我们能预测他们哪里会痛吗？

类似于预测不良姿势，我通过将目标变量从顺序变量调整为二进制变量找到了最佳结果。此外，我完全放弃了 KNN，因为它继续表现不佳。一旦我有了“背痛”和“无背痛”的二元分类，我就运行模型。调整参数后，每个参数的最佳结果如下:

同样，这两个模型在总体准确性方面表现相似，但在查看假阳性率时，逻辑回归模型再次优于随机森林。

ROC for Logistic Regression and Random Forest respectively predicting back pain

在这次预测中，哪些特征是重要的？

预测背痛的重要特征与预测不良姿势的特征几乎相同，对此我并不感到惊讶。除了年龄在预测背痛方面比不良姿势起着更有意义的作用，以及通勤时间在背痛方面起着较小的作用。

通勤类型
年龄
睡眠满意度
拥有一个活动跟踪器(Fitbit、Pebble 等)
如果他们曾经因背痛而去看医生或接受治疗

预测这个人哪里疼(下背部、肩部或颈部)更加困难，我的结果也不一致。

来自数据的其他预测？

看完主要问题后，我测试了预测睡姿、睡眠满意度、某人何时感到背痛(在移动、坐着、站着、睡觉等时)以及他们的活动水平。唯一接近有意义结果的是预测睡姿(仰卧、侧卧或俯卧)，准确率为 60%。然而，大多数参与者(65%)报告说他们侧睡，我们的分类器倾向于将几乎所有人都归类为侧睡。因此，这些其他预测模型没有有趣的发现。

使用结果

利用这些模型，我设计了一个测验，来帮助确定你是否有不良姿势和/或未来背痛的风险。它使用加权的特征重要性，并为您提供个性化的姿势推荐！

参加这里的竞猜 ！

结论

大多数接受调查的人对自己的姿势不满意，超过 50%的人经常背痛。此外，我们已经看到:

在合理的准确度下，从一些关于一个人日常习惯的问题中预测不良姿势(或感知不良姿势)和背痛是可能的。
睡眠满意度、每周活动水平和个人通勤都在姿势和疼痛的分类中发挥了重要作用。有趣的是，一个人每天坐着的时间并没有很大的影响。
人们每周锻炼的频率似乎对预测姿势和背痛有最大的影响。此外，活跃的人往往对自己的姿势更关心或更有意识。

调查中我们尚未讨论的一个问题是:

“关于寻找背痛/姿势缓解，你最不喜欢什么？”

37%的人说治疗很耗时，另外 30%的人不喜欢做伸展运动和锻炼。人们似乎“太忙了”，这是一个不太令人满意的答案。

虽然还没有明确的答案，但这一探索是理解姿势在我们生活中所起作用的第一步，也是理解为什么我们很多人都有糟糕的姿势，这对我们的身心有着根本性的影响。

走向

还有很多事情要做。收集更多的回答是一个开始，更详细的回答，包括关于“屏幕时间”和其他生活习惯的问题会更好。最终致力于为人们提供改善体态的最佳工具。

感谢您的阅读！

查看我的 Jupyter 笔记本，查看我的 github 。

关于评论和问题，请发电子邮件至 john@johnlague.com 给我

当我跟踪我的网站的使用情况时，是否应该受到谴责？

原文：https://towardsdatascience.com/is-it-reprehensible-when-i-track-the-use-of-my-website-b3f4ad6d54b7?source=collection_archive---------38-----------------------

What do you track? Photo by Paweł Czerwiński on Unsplash

你经营一个网站，一个网店，你自己的博客，或者你的作家页面。

当然，你想知道你的页面表现如何。

有人来看我吗？
它能吸引访问者在页面上停留一段时间吗？还是游客马上就离开？在他们阅读我的内容之前？

当然，你想了解如何改进你的网页。

什么吸引了游客的注意力？
我需要做些什么来提高转化率？

答案是用户追踪。首先也是最重要的，是谷歌分析。还有其他跟踪工具。

你的意图没有错。问题是这些追踪工具是如何工作的。

首先。这些工具可以识别你的用户。他们存储他们的 IP 地址。它们在 cookies 中存储唯一的标识符。他们使用浏览器指纹识别。

第二。这些工具存储用户的每一次浏览量、每一个事件和每一个动作。他们把这些数据和标识符联系起来。

这些工具中的一些会在你的网站之外收集你的用户数据。他们将使用追踪工具的所有网站的数据连接起来。

他们可以全面了解你的用户。他们很快就会获得个人身份信息。他们得到了电子邮件地址。他们有一个社会安全号码。他们得到了电话号码。他们得到了邮政地址。

这些追踪工具知道你的用户是谁。他们知道她做什么。他们知道她的秘密。所有被访问的页面揭示了一切。

如果你使用这些工具，你就成了他们的助手。

一些开发这些追踪工具的公司承诺这些数据是你的。

但这就是错误！这不是你的数据。这也不是他们的数据。是你用户的数据！

It is my data. No, it is not. Give it to me! Photo by Quino Al on Unsplash

2018 年，欧盟发布了《通用数据保护条例》(GDPR)。它旨在保护用户的个人数据。

在你看来，大多数公司和网站所有者得出的后果是什么？

我的回答是:烦人的 cookie 同意弹出窗口。这些弹出式菜单大多遵循这样的态度:要么吃，要么死。如果您使用我们的网站，我们将收集您的个人数据。句号。

饼干本身并不是一件坏事。就我个人而言，我非常喜欢饼干🍪。说真的，cookies 有很多有效的用例。例如，登录机制。或者您可以在常用网站上指定的一些偏好设置。

但是如果侵犯用户隐私是使用 cookie 的唯一原因，那么这项技术就没有用了。

You have to be responsible with cookies.

这是否意味着，你不能再分析你的网站的性能了？你再也学不会如何改进你的网站了？

答案是:当然可以！

GDPR 并不禁止网站绩效评估。用户隐私和网站改进完全是两码事。

当你想知道你的网站运行得如何时，你不需要收集、存储和处理用户的个人数据。

例如，假设你想知道访问者的数量，以及他们是否点击了一个链接“我感兴趣”(又名转换)。当你只对两个数字感兴趣时，没有理由侵犯你的用户的隐私。两个简单的数字概括了你的网站的表现。

公平地说，您需要一些数据来计算这些性能指标。

但是您可以在不侵犯用户隐私的情况下收集所需的数据！我想提三个技巧。这些技术巧妙的结合在一起，让你在不侵犯用户隐私的情况下收集所有你需要的数据。因为您收集的数据不包含个人用户数据。

这些技术是:

概率差分隐私
同态加密
分散队列抽样

概率差分隐私是一种从一组人那里获得统计数据而不泄露每个人提供的数据的方法。

它的基本思想是给你收集的数据添加噪声。

例如，假设你收集用户的年龄。你增加或减少每个用户的价值一点点。随机地。你不使用或存储真实的年龄。

这种噪音对一个人来说是不可逆的。再也没有办法找出单个用户的真实年龄了。

但是一旦你收集了许多用户的年龄，噪音就平均了。你可以看到你的用户的平均年龄。你甚至可以把他们分成几组。但是你没有任何一个人的真实年龄。

你对每一个数据都这样做。

同态加密是一种允许直接对加密数据进行计算的加密形式。解密后，计算结果与运算结果相匹配，就像对未加密的值执行了运算一样。

所有数据都在用户的浏览器中加密。它不会被解密以供处理。它不会被解密以供存储。

您只解密计算出的指标。这些指标包含了你的网站的统计数据。它们不包含或披露任何个人用户信息。

您可以计算网站的性能指标，而无需使用甚至以不安全的方式存储您的用户数据。所有数据都是加密的。而且是加密的。

您的跟踪工具提供商无权访问加密数据。当他们故意尝试时不会，不是偶然，即使他们被黑了也不会。

解体队列抽样通过组合恢复防止个人数据被泄露。如果你有一个人的一些数据，你也许能从其他来源恢复个人数据。

例如，你的浏览器包含许多偏好。时区、语言、安装的插件等等。这些数据中的每一个都是无害的。因为许多其他人也有同样的偏好。

但是如果你把所有这些东西结合起来，你就会得到一个独特的浏览器指纹。因此，您获得了用户的个人标识符。

但是你可以用一种分解的方式存储所有这些数据。你的用户所说的语言可能对改善你的网站很重要。但是你不需要知道那个说某种语言的人的具体浏览器版本。所以，没有必要在你的数据中保留这种关系。

解体甚至帮助你摆脱个人身份信息。例如，如果你考虑一个用户的社会保险号。前三个数字代表地理位置。将位置分开存储，不与号码的其余部分链接。您可以在分析中使用该位置，而不会侵犯用户的隐私。

跟踪你网站的表现并不应该受到指责。利用对你的网站如何被使用的洞察力是无可指责的。因为这些东西与可识别的用户无关。

但是目的并不能证明手段是正当的。

如果你追踪单身人士。如果您收集个人身份信息。然后，你会侵犯你的用户的隐私。

你是否主动识别他人身份并为了自己的利益出售这些信息并不重要。

即使你只是存储个人数据，你也在拿用户的隐私冒险。服务器被黑了。如果你不想出售或使用这些数据，你为什么要存储它呢？

隐私保护是可能的。这不是问题。但这是一个机会！你可以将你的网页与竞争对手的区别开来。

跳过烦人的 cookie 通知。尤其是如果它说:“同意或不使用该网页”。跳过“吃(我的饼干)或死亡”的态度。

Eat my cookie!

用户越来越意识到并敏感于数据隐私问题。当大多数网站主根本不在乎的时候，就是你脱颖而出的机会了。

是时候制定数据科学家道德准则了吗？

原文：https://towardsdatascience.com/is-it-time-for-a-data-scientist-code-of-ethics-210b4f987a8?source=collection_archive---------12-----------------------

医学有一套可以追溯到希腊希波克拉底誓言的道德准则，但是数据科学家的指导方针在哪里呢？

Photo by Tim Gouw on Unsplash

随着一款名为 DeepNude 的新应用程序的发布，它允许任何人修改女人的照片，使其看起来像裸体，我发现自己对 deepfakes 的发展速度深感不安。这样一个有形且可访问的工具凸显了 AI、计算机视觉和其他机器学习技术在错误手中的黑暗面。虽然有一些令人难以置信的公开例子表明 deepfakes 如何被用来对个人视频、他们的外貌、他们的活动以及他们说的话进行篡改，但这项技术的可访问性主要掌握在少数懂技术的人手中。

即使有这些知识，生成令人信服的 deepfakes 所需的时间也是一个障碍。但 DeepNude 表明，改变图像可以在几秒钟内完成，而以前在普通公众无法接触到的强大机器上需要几天时间。

深度伪造工具的民主化

或许关于 DeepNude 最可怕的事情是这项技术如此迅速地大众化，以至于任何人都可以编造图像来伤害个人或群体。不幸的是，人工智能和机器学习的发展速度超过了我们的文化适应能力。我们正处于一个历史转折点，破坏性的图像和宣传可以迅速产生，然后通过社交媒体有机传播，这种方式是不可能阻止或识别真假的。

另一方面，同样的技术正在推动早期癌症检测、自动驾驶汽车、基因研究等领域的创新。因此，虽然像这样的事情是不可能被充分监管的，但是创造者自己有责任对他们所创造的东西的真正长期影响做出决定。

“我不做，一年后别人会做。”

这就把我们带到了发布像 DeepNude 这样的东西的道德问题上。据 the Verge 报道，这位名叫 Alberto 的开发者说:“如果我不做，一年内就会有人做。”对于一个人的行为的含义，这是一个可怕的立场。虽然创作者已经关闭了应用，但现在它就在那里，就像它可以生成的照片一样，那扇门现在是敞开的。它还邀请其他人做类似的工作。我们现在正处于一场虚拟的军备竞赛中，deepfakes 可能会演变成人类有史以来创造的最危险的武器之一。

现代文化已经让我们习惯于这样的想法，即人工智能将以某种方式带来我们的毁灭，但几乎没有集体恐惧，即这些工具背后的工具可能比一些想象的有知觉的人工智能更危险。AI 界有没有“疯狂科学家”的类比？

那么，在一个与机器学习的使用一样微妙的话题中，我们从哪里开始定义道德制高点呢？虽然 DeepNude 是一系列公开可用的机器学习技术的实现，但也许我们需要后退一步，看看数据科学家社区本身是如何进行这种技术的研究并使之成为可能的。

医学道德规范

从开始，作为一个参照点，医学有一个可以追溯到希腊希波克拉底誓言的道德准则。

The Greek physician Hippocrates, https://commons.wikimedia.org/w/index.php?curid=164808

对医学伦理体系更现代的解释是围绕着一套道德原则作为指导方针。根据维基百科关于医学伦理的页面，它们可以分为以下四种价值观:

尊重自主权——患者有权拒绝或选择他们的治疗。
慈善——从业者应该以患者的最佳利益为出发点。
无害——不成为伤害的原因。还有，“效用”——提倡利大于弊
公正——涉及稀缺卫生资源的分配，以及谁获得何种治疗的决定。

即使这些都是数据科学家道德准则的良好开端，但让我们花点时间来探索一些潜在的概念，这些概念可以为数据科学家定义一套专门的道德规范。

数据科学道德准则

大多数人脑海中最先想到的可能是用这样的准则来定义问责制。但是道德准则背后的真正概念不是责任本身，而是团队可以集体同意一套核心原则的想法。

这些原则在系统层面上推动行动，以帮助确保当个人的价值观或信仰受到质疑时，个人的道德指南针指向正确的方向。一些团体目前正在试图定义这些，例如数据科学协会、艾伦·弗里茨勒的数据科学造福社会，以及牛津-蒙钦行为准则等等。

虽然这些都是涵盖数据科学家的各种职责和工作的伟大而详细的尝试，但也许我们需要一组更小、更集中的价值观来达成一致:

无罪

这一条是直接从上面提起的，但数据科学家应该以一种不会故意造成伤害的方式为人类的最佳利益而努力。虽然将机器学习用于自动驾驶汽车是为了更大的利益，但当应用于军用车辆时，对话变得更加复杂。数据科学家需要思考他们行动的后果，以更好地了解最终的创造是否利大于弊。

法定的

不言而喻，数据科学家不仅应该遵守自己国家的法律，还应该遵守国际公认的法规。数据科学家应该直接意识到他们的创造的法律后果。以不可避免为借口，在其他人之前发布某些东西的行为是不可接受的。

更大的利益

并不是所有的创造都只有好坏之分。对于数据科学家来说，最具挑战性的职位之一可能是他们在很大程度上从事研究的现实。控制这类研究的实施并不总是可能的。但是作为一个团体，这项研究应该是为了更大的利益。

显著

因为害怕潜在的后果而隐藏在匿名背后的想法不应该是一种保护自己的方式。数据科学家的名字与研究联系在一起，反过来，与实施有着直接的联系。支持一个人的工作和它的衍生物可以帮助确保对它所激发的创作有一定程度的责任感。

有时，这类事件迫使我们去监管一些以前可能被认为无害或无关紧要的事情。

不需要道德准则来判断发布类似 DeepNude 的用例。如果应用程序的作者对发布它的合法性有信心，他们就不会匿名了。我甚至不知道这一行动会有什么后果。有时，这类事件迫使我们去监管一些以前可能被认为无害或无关紧要的事情。

上面的一组建议值只是我对一些令人担忧的事情的膝跳反应，我担心这只会变得更糟，因为在谦逊的数据科学家所做的良好研究的支持下，这个深度虚假的空间继续增长。围绕用于机器学习的数据的收集和使用，还有更大的对话要进行。与工作成果直接或间接相关的个人隐私呢？如何立法来保护数据科学家和那些受其行为影响的人？这是一个太大的主题，但我们现在需要开始一个对话。

下一步是什么？

关于数据科学家所做工作的真正责任，这里有一个更广泛的探索，因为监管和扼杀创新之间只有一线之隔。一个人可以使用任何工具好或坏，但一条清晰的界限是相信你构建的工具应该有更大的好处，远远超过坏处。

Photo by Neil Rosenstech on Unsplash

我担心情况在好转之前会变得更糟。如果我们现在不采取措施，向进入该领域的新一代数据科学家灌输责任感，我们作为一个社会可能很难克服正在造成的损害。虽然谷歌搜索“数据科学家道德准则”会返回结果，但事实上没有单一的真理，我们需要在为时已晚之前解决这个问题。

机器学习为什么可行？

原文：https://towardsdatascience.com/is-learning-feasible-8e9c18b08a3c?source=collection_archive---------20-----------------------

Photo by Rock’n Roll Monkey on Unsplash

对学习基础的快速探索

现在是 2019 年末，围绕机器学习的炒作已经发展到了不合理的程度。似乎每周都有新的艺术成果被报道，一个更光滑的深度学习库出现在 GitHub 上，OpenAI 发布了一个具有更多参数的 GPT-2 模型。迄今为止，我们已经看到了令人难以置信的结果，很难不被炒作所吸引。

然而，其他人警告说，机器学习承诺过多，交付不足。他们担心这种持续的行动可能会导致研究资金枯竭，导致另一个人工智能冬天。这确实是个坏消息。因此，为了遏制围绕机器学习的热情，并单枪匹马地阻止不可避免的 AI 寒冬，我将说服你学习不可行。

本文改编自《从数据中学习》一书[1]。

T 何的学习问题

从根本上说，机器学习的目标是找到一个函数 g ，它最接近地逼近某个未知的目标函数 f 。

例如，在监督学习中，我们在某些点上被给定了 f 的值 X ，我们使用这些值来帮助我们找到 g 。更正式的说法是，给我们一个数据集 D = {(x₁，y₁)，(x₂，y₂)，……，(xₙ，yₙ)} 其中yᵢ=f(xᵢ)forx∈x。我们可以通过找到一个函数 g 使得 g(x) ≈ f(x) 在 D 上，使用这个数据集来近似 f 。然而，学习的目标不是简单地在 D，上很好地近似 f ，而是在任何地方都很好地近似 f 。也就是我们要一般化。为了说明这一点，请看下图。

Two different approximations to the function f.

g 和g’在训练数据上完全匹配 f (图中用“x”s 表示)。然而， g 显然是 f 比g’更好的近似值。我们要的是找到一个类似 g 的函数，而不是g’。

为什么学习不可行

既然我们已经设置了学习问题，值得强调的是目标函数 f 是真正的 未知的。如果我们知道目标函数，我们根本不需要做任何学习，而是直接使用它。而且，由于我们不知道什么是 f ，不管我们最终选择什么 g ，我们都没有方法来验证它有多接近 f 。这看起来似乎是一个微不足道的观察，但是本文的其余部分将有望展示它的分支。

假设目标函数 f 是一个具有三维输入空间的布尔函数，即 f: X → {0，1}，X = {0，1} 。这是一个便于我们分析的设置，因为很容易列举出空间中所有可能的函数[2]。我们想利用下面的训练数据，用函数 g 来逼近 f 。

Training data available to approximate f. Here, x is the input and y = f(x). For clarity, we use ○ to indicate an output of 0 and ● to indicate an output of 1.

因为我们想要找到对 f 的最佳可能近似，所以让我们只保留与训练数据一致的空间中的函数，并去掉所有其他的。

All possible target functions which agree with the training data.

很好，现在我们只剩下 8 个可能的目标函数，在上图中标记为 f₁ 到 f₈ 。为了方便起见，我们还保留了训练数据的标签。请注意，我们无法访问样本外标签，因为我们不知道目标函数是什么。

现在问题变成了，我们选择哪个函数作为 g？由于我们不知道哪个 f 是真正的目标函数，也许我们可以通过选择一个与最有可能的目标函数相一致的 g 来尝试对冲我们的赌注。我们甚至可以用训练数据来指导我们的选择(学习！).这听起来是一个有前途的方法。但是首先，让我们定义一下“符合最有潜力的目标函数”是什么意思

学习最佳假设

为了确定一个假设(即选择 g )有多好，我们首先需要定义一个目标。一个直截了当的目标是，每当假设与样本外输入的 fᵢ 之一一致时，给假设一分。例如，如果假设在所有输入上与 f₁ 一致，它得到 3 分，如果它在 2 个输入上一致，它得到 2 分，对于所有 fᵢ 以此类推。很容易看出，一个假设最多可以得 24 分。然而，要得到 24 分，假设必须与所有可能输入的所有可能目标函数一致。当然，这是不可能的，因为假设对于相同的输入必须输出 0 和 1。如果忽略不可能的场景，那么最多只能得 12 分。

现在唯一要做的就是选择一个假设并评估它。既然我们是聪明人，我们可以查看我们的训练数据，并“学习”是否有某种模式。XOR 函数似乎是一个很好的选择:如果输入有奇数个 1，则输出 1，否则输出 0。它与训练数据完全一致，所以让我们看看它在目标上做得有多好。

Computing the objective value for the XOR hypothesis.

如果我们进行练习，我们会看到，在样本数据外，XOR 与一个函数完全一致(+3 分)，与两个输入的三个函数一致(+6 分)，与一个输入的三个函数一致(+3 分)，与一个函数完全不一致(+0 分)，总共 12 分。完美！我们能够找到一个可能得分最高的假设。可能还有其他同样好的假设，但是我们保证没有比异或更好的假设。甚至可能有更差的假设，得到的分数少于 12 分。事实上，让我们找一个这样的坏假设，这样我们就可以检查 XOR 确实是目标函数的一个很好的候选。

最坏的假设？

如果 XOR 是最好的假设之一，那么一个很明显的坏假设的候选就是它的对立面，XOR。对于每个输入，如果 XOR 输出 1，则 XOR 输出 0，反之亦然。

Computing the objective value for the ¬XOR hypothesis.

再次回顾练习，我们现在看到，在样本数据外，XOR 与一个函数完全一致(+3 分)，与两个输入端的三个函数一致(+6 分)，与一个输入端的三个函数一致(+3 分)，与一个函数完全不一致(+0 分)，再次得到满分。事实上，任何我们选择作为假设的函数都会得到满分。这是因为任何函数必须与可能的目标函数中的一个——且仅一个——完全一致。从那里，很容易看出任何 fᵢ 将在两个输入上匹配其他 fᵢ 中的三个，三个在一个输入上，一个在没有输入上。

令人震惊的是，我们甚至可以不看训练数据就选择一个完美的假设。更糟糕的是，我们可以选择一个与训练数据完全不一致的假设，但它仍然可以获得满分。事实上，这正是 XOR 所做的。

这意味着所有函数在样本外数据上与目标函数一致的可能性是相等的，不管它们是否同意训练。

换句话说，函数与训练数据一致的事实没有给任何关于它与样本外的目标函数一致程度的信息。既然我们真正关心的是样本外的表现，为什么我们还需要学习呢？这不仅适用于布尔函数，也适用于任何可能的目标函数。这里有一张图可以更清楚地说明这一点。

Valid values the function f could take for input > n.

知道 (-∞，n) 上的 f 并不能告诉我们它在[n，∞)上的行为。任何虚线都可能是 f 的有效延续。

概率，可取之处

也许这是你希望我说的那部分，这一切都是一个巨大的笑话，并解释我如何欺骗你的眼睛。嗯，这不是开玩笑，但显然机器学习在实践中是可行的，所以我们肯定遗漏了什么。

学习“起作用”的原因是由于一个重要的基本假设，即所谓的独立同分布假设 : 训练数据和样本外数据和是独立的，并且和是同分布的。这仅仅意味着我们的训练数据应该代表样本数据。这是一个合理的假设:如果样本外的数据差异很大，我们不可能期望我们从训练数据中学习到的东西能够推广到样本外。更简单的说，如果我们所有的训练数据都来自 y = 2x ，那么我们就不可能学到任何关于 y = -9x + 5 的东西。

i.i.d .的假设在实践中也大致成立——或者至少不会被打破。例如，如果一家银行想要使用来自过去客户的信息(训练数据)建立一个模型，他们可以合理地假设他们的新客户(来自样本数据)不会太不同。我们在上面的布尔函数例子中没有做这个假设，所以我们不能排除任何 fᵢ 是真正的目标函数。然而，如果我们假设样本外数据的目标函数的输出类似于训练数据，那么显然 f₁或 f₂最有可能是目标函数。但是当然，我们永远无法确定😉。

欧根·霍塔吉
2019 年 11 月 29 日

如果你喜欢这篇文章，请在 Medium 上关注我，以获得关于新帖子的通知。

脚注

[1]阿布-穆斯塔法等人。al，《从数据中学习》(2012)——如果你想深入学习理论的基础，这是一本很棒的书。它写得很好，作者有天赋用简单直观的方式解释复杂的话题。阿布-穆斯塔法教授也有一个免费的在线课程,随书而来，我强烈推荐这个课程。

[2]整个空间仅由 256 个函数组成。每个输入可以是 0 或 1，给出 2 = 8 种可能的输入组合。此外，对于每个输入组合，函数只能返回 0 或 1。因此，有 2⁸ = 256 个可能的函数。

在线扑克死了吗？

原文：https://towardsdatascience.com/is-online-poker-dead-647b2a78cae9?source=collection_archive---------11-----------------------

人工智能的下一个牺牲品

Facebook has shown their hand, and it’s a straight flush. Credit: Keenan Constance.

嗯，不是死了，而是快死了。就在一个多月前，脸书的人工智能研究团队发表了一篇论文，概述了他们对一个能够持续击败世界顶级扑克玩家的超人人工智能的研究结果。就其本身而言，这是人工智能的一个惊人成就，但纵观过去，它将对近 40 亿美元的在线扑克行业带来毁灭性的打击。在未来几个月，全球数百万玩家和大型在线科技公司将开始看到这些人工智能在在线游戏中弹出的影响。要想生存下去，该行业需要进行重大转变。

脸书发布的论文是几十年来第一个在两队以上比赛中击败人类的人工智能工作的高潮。人工智能创造了“Pluribus ”,以与六人在线扑克相同的格式持续击败世界冠军扑克玩家。不仅如此，人工智能是用不到 150 美元的资源训练的，这意味着这样的系统几乎可以由任何人创建。

重要的是，这篇论文没有描述一个精确的获胜公式，而是概述了所使用的方法。这意味着我们明天不会看到 Pluribus 的复制品，但我们可能会在下个月或明年看到。现在它被证明是可能的，并且指路明灯已经出现，各种各样的人或团体将努力尽可能地再造人工智能。它所需要的只是一次成功，这个人工智能就可以立即在全世界共享。

在目前的审查水平下，任何拥有这种人工智能的人或财团都可以很容易地立即开始在在线扑克中赢钱。最初，这不是在线扑克公司的问题，而是玩家的问题。随着扑克桌上的人工智能变得饱和，任何一个人赢得游戏的机会都将下降到 0，他们的银行账户也是如此。这将把他们赶出系统，这将成为在线扑克公司的一个问题，因为他们的主要收入来源枯竭了。人工智能之间可能会有一些正在进行的战争，但数量和容量不会接近目前的水平。

为了避免这种对市场的冲击，可能需要更严格的安全措施。虽然如果这些系统每场比赛都赢，那么它们可能很容易被抓住，但一个好的欺诈者(让我们用这里的术语“欺诈”)将足够聪明，不会玩得太好以至于触发警报，而是在多个帐户中玩得足够好，以获得可观的收入。因此，一些来自其他行业的好方法将是增加 id 检查，以确保帐户可以被正确跟踪，以及“现场游戏”，其中用户在玩游戏时使用网络摄像机进行记录，以确保真实性。

最终，所有这些系统都可以被游戏化，检测这种人工智能的唯一真正方法是能够理解它的游戏风格以及它与普通人类的不同之处。这样一个系统不容易建立，它本身是一个人工智能，但可能值得投资。

在线扑克是一个独特的行业，仍然有大量的钱在几个人之间相对简单的游戏中流通。这个行业很可能不会在一夜之间消失，而是随着消费者对由机器主导的游戏失去信任和兴趣而慢慢消失。但是扑克并不是最终目的，它只是第一步。另一个有多个参与者的高价值行业是股票市场本身。我们已经在这里看到了无数未能超越人类的人工智能，但有了这样的研究，这只是时间问题。

Credit: Amanda Jones.

过度合身是一件坏事吗？

原文：https://towardsdatascience.com/is-overfitting-really-bad-ddaabfc2f6b8?source=collection_archive---------32-----------------------

source & credit — https://www.pexels.com/@brunoscramgnon

经典统计学和机器学习中教授的一个基本原则是“你不应该有一个过度拟合的模型”！

“过度拟合”的意思是，你的神经网络已经学习了一个在训练数据上表现非常好的函数，但是当向它显示新数据(也称为测试数据)时，它不能提供正确的推断/预测。

通常，为了避免过度拟合的模型(或者换句话说，你渴望有一个通用的模型)，你应该利用一个叫做偏差-方差权衡的概念。

bias-variance tradeoff

偏差这里实际上是偏差-误差反映了事实和预测之间的差异。预测越接近事实，误差越低！

这个概念的要点是

如果你有一个高偏差，这意味着即使在训练数据上，它也没有学习预期的功能
如果您有一个高方差，这意味着您学习的函数已经尝试考虑几乎所有的训练数据点，几十年的使用表明，当这种情况发生时，您的神经网络在测试数据上表现不佳

这里有一个链接，非常详细地介绍了偏差-方差权衡—https://towards data science . com/understanding-the-bias-variance-trade-165 e 6942 b229

很长一段时间以来，我一直把这个基本原则视为既定事实，直到我开始看到网络在训练数据上表现得非常好(几乎零训练误差)，但在没有任何正则化的情况下在测试数据上表现得也很好。

非常有趣的是，一个人在一次练习(在这里是训练)中获得零错误，却感到失望！

还有另一个不同的原理，叫做奥卡姆剃刀。奥卡姆的威廉用通俗的话给出的哲学是:一个人应该喜欢简单胜过复杂。我不敢反驳！

现在奥卡姆剃刀也被认为是统计学家应用的&，他们说——最简单的假设(函数)应该永远是首选。同样，原则上我不能反对它，但我真的看不到的是，机器学习想要解决的大多数问题本质上都很复杂，因此这条原则真的适用于这里吗！。

统计学家所提倡的奥卡姆剃刀有没有可能最终固定我们的思维，而我们没有考虑到最简单的解释并不总是最好的选择？

幸运的是，我在去年发表的一篇论文中找到了一些安慰——调和现代机器学习和偏差-方差权衡。

作者表明，现代神经网络往往在训练数据上实现零损失，但在测试数据上表现良好。他们认为，非常像经典统计学中的【甜蜜点】，其中有低偏差，但假设(或学习函数)并不过分复杂，还有另一个被称为插值阈值的“甜蜜点”，在此之后，即使 假设复杂性(以参数数量衡量) 增加，仍然可以有低偏差和低方差。他们阐释了下图所示的概念，并称之为“双体面风险曲线”。

source — https://arxiv.org/pdf/1812.11118.pdf

他们不仅展示了在神经网络环境中达到插值阈值的现象，还研究了其他机器学习算法，如决策树&集成方法。他们提供了一个经验证据，即通过使用决策树和随机森林进行 boosting 探索的函数族也显示出与神经网络相似的泛化行为，无论是在插值阈值之前还是之后。

那么为什么这个插值阈值在过去没有被观测到呢？该论文的作者提供了对它的见解，并引用了传统上特征具有固定大小的观点。我引用报纸上的话

经典统计学中广泛研究的常用线性设置通常假设一组固定的特征，因此具有固定的拟合能力。各种形式的正则化既可以防止插值，也可以改变函数类的有效容量，从而衰减或掩盖插值峰值。

如果你训练了深层网络，你就能理解上面的观点；大多数情况下，如果我们开始发现测试误差没有减少，我们会提前停止执行。在定义我们的网络层时，我们还系统地添加了权重衰减&* 其他正则化子。作者建议(我也同意)的是，由于过早地关注正则化，我们经常无法实现双体面风险曲线中所示的插值阈值/峰值。***

source — https://www.pexels.com

相对于奥卡姆剃刀，我找到安慰的另一个地方是在的拉德福德·尼尔博士的精彩论文中，题目是 神经网络的贝叶斯学习 。Neal 博士是贝叶斯学习应用于工程应用领域的先驱，他介绍了马尔可夫链蒙特卡罗方法如何用于贝叶斯推理。

在他的论文(第 1.1.4 节)中，他提到奥卡姆剃刀原理通常被认为是归纳推理的一个基本组成部分，虽然它在科学背景下是没问题的，但它在精密、复杂且通常混乱的工程应用中的效用产生了合理的怀疑。

他进一步谈到，频繁统计学家所认为的过度拟合在贝叶斯观点中并没有找到同样的相关性。我很乐意分享这个观点，但这是以后的事了！

结束语

对我来说，协调现代机器学习和 Belkin 等人的偏差-方差权衡非常有见地。首先，它帮助我消除了对零训练误差的担忧，其次，它表明挑战既定原则是可以的。

在 stackexchange 上看到了下面这个帖子的同名主题—https://ai . stack exchange . com/questions/4136/is-over fitting-always-a-bad-thing……..当我读到作者说“响亮的是”的答案时，我笑了……这对你仍然适用吗？

不要害怕你的网络超载；我没有！

Python 是面向对象的吗？

原文：https://towardsdatascience.com/is-python-object-oriented-834d6c70cf54?source=collection_archive---------8-----------------------

本教程回答了 python 是否面向对象的问题？

Credits: zo3.in

Python 是一种面向对象的编程语言吗？是的，它是。除了控制流，Python 中的一切都是对象。由麦克斯·菲舍尔在 Quora 中回答这个问题。

是时候用我的方式回答上面的问题了。

是的，python 是一种面向对象的编程语言。python 中的一切都是对象。使用 python 我们可以创建类和对象。在本教程中，我将只讨论类和对象。完整的源代码可以在下面我的 GitHub 库中找到:

[## 塔努-北帕布/Python

此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…

github.com](https://github.com/Tanu-N-Prabhu/Python/blob/master/Is_Python_object_oriented%3F.ipynb)

类别:Clss 就像帮助创建对象的蓝图。换句话说，一个类包含变量、方法和函数。或者您可以引用包含属性和行为的类。例如，考虑一个类“球”,球的属性可能是颜色、直径、价格，球的行为可能是滚动、弹跳。

对象:对象是一个类的实例。借助于对象，我们可以访问一个类的方法和函数。

现在让我们看看如何用 python 创建一个类和一个对象

用 Python 创建一个类是很简单的，你所要做的就是使用一个名为“class”的关键字和一个通常被称为类名的名字。在类内部，我们可以声明函数或变量。

class python: def designer():
        print(“Guido van Rossum”) def first_appeared():
        print(“1990; 29 years ago”)

为了访问这个类中的函数，你只需要用类名和“.”来调用这个类点运算符调用它的函数。我们可以通过两种方式访问类:不创建对象和创建对象。

不创建对象

只需使用类名和点运算符来访问类中的函数。

python.designer()**Guido van Rossum**python.first_appeared()**1990; 29 years ago**

创建一个对象

p = pythonp.designer()**Guido van Rossum**p.first_appeared()**1990; 29 years ago**

现在，创建一个对象并不是一件困难的事情，你所要做的就是使用一个名为“p”的变量，并将它赋给类“python ”,然后在点运算符的帮助下，你就可以调用该类中的函数。

自身参数

self参数是对该类的当前实例的引用，用于访问属于该类的变量。学分— w3schools

你可以给 self 参数起任何你喜欢的名字，不强制称它为 self。

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age def func(a):
        print(“Hello my dog’s name is “ + a.name + “ and its age is        “ + a.age)p1 = Dog(“Danny”, “10”)p1.func()**Hello my dog's name is Danny and its age is 10**

在上面的例子中，我使用了初始化类时执行的 init()。这里每个类都包含 init()函数。如上所述，在 self 参数的帮助下，我们可以访问类内部的变量。

我们也可以在没有 self 参数的情况下访问和修改类内部的变量。

class Dog: breed = "Alaskan Malamute"
    age = 10d = Dog()
print(d.breed)
print("--------------------")
d.breed = "Labrador"
print(d.breed)**Alaskan Malamute 
-------------------- 
Labrador**

让我们看看如何使用“del”关键字删除对象。

您可以使用del关键字删除对象:

class Dog:
    print(“Alaskan Malamute”)
    print(“10”)**Alaskan Malamute 
10**d = Dog()print(d)**<__main__.Dog object at 0x7f1cb938ceb8>**del dprint(d)**--------------------------------------------------------------------****NameError                 Traceback (most recent call last)**[**<ipython-input-53-85549cb1de5f>**](/<ipython-input-53-85549cb1de5f>) **in <module>()
----> 1 print(d)****NameError: name 'd' is not defined**

让我们看看如何删除对象的属性

您可以使用del关键字删除对象的属性:

class Dog:
    name_of_the_dog = "Danny"d = Dog
del d.name_of_the_dogprint(d.name_of_the_dog)**--------------------------------------------------------------------****AttributeError       Traceback (most recent call last)**[**<ipython-input-38-e6d330ce7a18>**](/<ipython-input-38-e6d330ce7a18>) **in <module>()
----> 1 print(d.name_of_the_dog)****AttributeError: type object 'Dog' has no attribute 'name_of_the_dog'**

访问类中的对象变量和函数

要做到这一点，你所要做的就是创建一个类类型的对象，并使用点运算符访问变量的名称和类的函数。

class dog: age = 10 def name():
        print("Danny")d = dog
d.age**10**d.name()**Danny**

我想现在你们相信 python 是一种面向对象的编程语言。本教程到此结束，我知道这是一个很短的教程，但这足以作为一个好的开始来了解更多的类和对象。要阅读 python 类的官方文档，我建议大家阅读以下内容:

[## 9.类- Python 3.8.0 文档

类提供了一种将数据和功能捆绑在一起的方法。创建一个新类会创建一个新类型的对象…

docs.python.org](https://docs.python.org/3/tutorial/classes.html)

在接下来的教程中，我将提供关于继承、父类和子类等更多内容的文档。再见，祝你今天愉快。

量子至上到底是不是一个东西？

原文：https://towardsdatascience.com/is-quantum-supremacy-a-thing-or-not-33ef6a1b1cac?source=collection_archive---------22-----------------------

谷歌说他们做到了，量子计算机不仅是真实的，他们目前正在摧毁经典计算机，其他人不同意。

如果你沉浸在计算机世界，你可能听说过谷歌达到了所谓的“量子霸权”。那是什么？他们是这样说的:

我们开发了一种新的 54 量子位处理器，名为“Sycamore”，由快速、高保真量子逻辑门组成，以执行基准测试。我们的机器在 200 秒内完成了目标计算，根据我们实验中的测量，我们确定世界上最快的超级计算机需要 10，000 年才能产生类似的输出。

因此，量子计算机在 200 秒(大约 3.3 分钟)内解决了这个问题，而传统的超级计算机需要 10，000 年才能完成同样的工作！这太惊人了。然后我看了这个视频:

我惊呆了！！我开始写这篇文章来展示这个结果是多么惊人。然后！流浪汉。！！我看到了这个:

[## 关于“量子至上”| IBM 研究博客

量子计算的最新进展已经产生了两个 53 量子位的处理器

www.ibm.com](https://www.ibm.com/blogs/research/2019/10/on-quantum-supremacy/)

让我在这里向你描述整个故事。今天 10 月 23 日发表在《自然》杂志上的谷歌论文之前在美国宇航局的 NTRS 网页上泄露过，但它被删除了，没有任何解释。每个人都在问:鞋跟怎么了？？

然后 IBM 发表了那个博客，还有这篇文章:

[## 利用二级存储模拟深度 54 量子位 Sycamore 电路

在最近的一篇论文中，我们展示了二级存储可以扩展量子电路的应用范围

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

他们说:

我们认为，同样任务的理想模拟可以在传统系统上在 2.5 天内完成，而且保真度要高得多。事实上，这是一个保守的、最坏的估计，我们希望通过进一步的改进，模拟的传统成本可以进一步降低。

所以不是一万年？两天半？这是一个很大的区别。要理解这个讨论的技术部分，请阅读 Scott Aaronson 的博客:

[## Shtetl 优化的

2019 年 9 月 9 日上周，我有幸在苏黎世联邦理工学院(ETH Zurich)举办了一年一度的保罗·伯奈斯(Paul Bernays)讲座。我的开场…

www.scottaaronson.com](https://www.scottaaronson.com/blog/)

他解释并给出了他对这个问题的看法。但是斯科特的博客里有希望:

但 IBM 的分析是否意味着“量子至上”还没有实现？不，不是这样的——至少，在我用过的任何“量子至上”的定义下都不是这样。Sycamore 芯片花了大约 3 分钟时间来生成大约 500 万个样本，这些样本需要通过“线性交叉熵基准测试”——谷歌应用于其设备输出的统计测试。三分钟对两天半仍然是一个 1200 倍的量子加速。

所以好吧，我们还没到可以说量子计算机比经典计算机快 1752000 倍(我算出来的)的地步，但是 1200 倍就够了。

我们正处于量子计算时代的新起点。随之而来的是量子机器学习(在争议后写这些话很可怕)，以及人工智能和人类的一个新的可能性世界。

如果你想理解这篇短文，请按以下顺序阅读:

[## 使用可编程超导处理器的量子优势

量子优势使用可编程超导处理器谷歌人工智能量子和合作者诱人的…

www.spaceref.com](http://www.spaceref.com/news/viewsr.html?pid=52862) [## 关于“量子至上”| IBM 研究博客

量子计算的最新进展已经产生了两个 53 量子位的处理器

www.ibm.com](https://www.ibm.com/blogs/research/2019/10/on-quantum-supremacy/) [## 利用二级存储模拟深度 54 量子位 Sycamore 电路

在最近的一篇论文中，我们展示了二级存储可以扩展量子电路的应用范围

arxiv.org](https://arxiv.org/abs/1910.09534) [## 使用可编程超导处理器的量子优势

30 多年来，物理学家一直在谈论量子计算的威力，但问题总是…

ai.googleblog.com](https://ai.googleblog.com/2019/10/quantum-supremacy-using-programmable.html) [## 使用可编程超导处理器的量子优势

量子计算机的前景是，某些计算任务可能会在一台计算机上以指数级的速度执行

www.nature.com](https://www.nature.com/articles/s41586-019-1666-5) [## Shtetl 优化的

2019 年 9 月 9 日上周，我有幸在苏黎世联邦理工学院(ETH Zurich)举办了一年一度的保罗·伯奈斯(Paul Bernays)讲座。我的开场…

www.scottaaronson.com](https://www.scottaaronson.com/blog/)

感谢阅读并一直保持学习:)

随机森林比逻辑回归好吗？(比较)

原文：https://towardsdatascience.com/is-random-forest-better-than-logistic-regression-a-comparison-7a0f068963e4?source=collection_archive---------2-----------------------

深入研究随机森林的本质，遍历一个示例，并将其与逻辑回归进行比较。

Source

简介:

随机森林是从一组数据中提取信息的另一种方式。这种模式的吸引力在于:

它强调功能选择——将某些功能看得比其他功能更重要。
它不像回归模型那样假设模型具有线性关系。
它利用集成学习。如果我们只使用一个决策树，我们就不会使用集成学习。一个随机森林随机抽取样本，形成很多决策树，然后平均掉叶子节点，得到一个更清晰的模型。

在此分析中，我们将使用随机森林对数据进行分类，使用逻辑回归对结果进行比较，并讨论差异。看一看前面的 逻辑回归分析 看看我们将把它与什么进行比较。

数据背景:

我们有一个 255 名患者的样本，想要测量 4 种蛋白质水平和癌症生长之间的关系。

我们知道:

每位患者测得的每种蛋白质的浓度。
每个患者是否已经被诊断患有癌症(0 =没有癌症；1=癌症)。

我们的目标是:

通过从我们样本中的蛋白质水平和癌症之间的关系中提取信息来预测未来的患者是否患有癌症。

我们将关注的 4 种蛋白质:

甲胎蛋白

癌胚抗原

癌抗原 125

癌抗原 50

我从 UAB 的 MBA 项目那里得到了这套用于教育目的的数据。

数据探索/可视化

再来看一下逻辑回归分析得到更深入的了解。以下是要点:

import numpy as np
import pandas as pd
from sklearn import tree
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt
inputdata= r”C:\Users\Andrew\Desktop\cea.xlsx”
df = pd.read_excel(inputdata)
**df**.describe()

Figure 1

目标变量(Y)

yhist = plt.hist('class (Y)', data = df, color='g')
plt.xlabel('Diagnosis (1) vs no diagnosis (0)')
plt.ylabel('Quantity')
plt.title('Class (Y) Distribution')

Figure 2

构建模型

要刷新逻辑回归输出:

CEA 和 CA125 是最有预测性的，它们的 pvalues 低于 alpha 5 %,它们的系数比其他的高。由于 AFP 和 CA50 具有较高的 p 值，我们将其从逻辑回归中剔除。

但是，我们会将它们保留在随机森林模型中。这个练习的全部目的是比较这两个模型，而不是将它们结合起来。

我们将构建决策树，并想象它的样子:

#Defining variables and building the model
features = list(df.columns[1:5])
y = df['class (Y)']
X = df[features]
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,y)#Visualizing the tree
from sklearn.externals.six import StringIO  
from IPython.display import Image  
from sklearn.tree import export_graphviz
import pydotplus
dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,  
                filled=True, rounded=True,
                special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())  
Image(graph.create_png())

决策树:

Figure 3

对于新来的人来说，这是一棵令人生畏的树。让我们把它分解一下:

特色: X0(法新社)。X1 (CEA)。X2 (CA125)。X3 (CA50)

第一层: CEA ≤ 3.25，基尼 0.492，利差= 144，111

根节点显示了分支之前整个数据集的基尼指数。基尼系数越低，数据越纯净。最糟糕的混合数据给出的基尼指数为 0.5。

更新一下，我们的数据中有 144 名非癌症患者和 111 名癌症患者。这方面的基尼指数将是 0.492，这意味着它非常混杂。但不用担心，随着新的分支和节点的形成，这棵树会降低基尼指数。

基尼指数= 1−((144/255)^{2)+((111/255)}2)= 0.4916

回归模型告诉我们 CEA 是最具预测性的特征，具有最高的系数和最低的 p 值。决策树通过将 CEA 放在根节点上来同意这一点。每隔一个节点都是根节点 split 的衍生物。该算法选择在 CEA 水平 3.25 处分割，因为该点将目标变量分割成癌性和非癌性，比任何其他属性中的任何其他点更纯粹。CEA 值低于 3.25 (180 个样本)的情况更可能是非癌性的；高于 3.25 (75 个样本)的实例更有可能是癌性的。参考根下面的连接内部节点，查看实例是如何进一步划分的。

树的第二层分析两个新的数据桶(CEA 3.25 以下的 180 个样本和以上的 75 个样本)的方式与分析根节点的方式相同:

它运行 ID3 算法，找到将目标变量分割为其最大纯度的属性，确定最佳分界点，然后进行分割。

CEA 级别 3.25 以上拆分的第二层节点是基于 CA125 级别 38.6 以上。这种分割产生了 72 个样本的另一个内部节点和 3 个样本的第一个叶节点。该叶节点的基尼指数为 0，因为该节点中的所有 3 个样本都被分类为非癌。该算法考虑基于该特定叶节点对未来数据进行分类的方式是:

如果: CEA ≥ 3.25 且: CA125 ≥ 38.65 → 患者=非癌(0)

该过程继续，直到树在所有叶节点结束，并且对于每一系列分裂都有一个决策。

随机森林

我们将实现一个随机森林，而不是停留在那里，将我们的模型建立在树叶的基础上:获取随机样本，形成许多决策树，并取这些决策的平均值来形成一个更精确的模型。在这个模型中，我们取 1000 个树木样本的平均值。

#Importing
from sklearn import metrics
from sklearn.model_selection import train_test_split as tts#Dividing into training(70%) and testing(30%)X_train, X_test, y_train, y_test = tts(X, y, test_size=0.3, random_state=None)#Running new regression on training data
treeclass = RandomForestClassifier(n_estimators=1000)
treeclass.fit(X_train, y_train)#Calculating the accuracy of the training model on the testing data
y_pred = treeclass.predict(X_test)
y_pred_prob = treeclass.predict_proba(X_test)
accuracy = treeclass.score(X_test, y_test)
print(‘The accuracy is: ‘ + str(accuracy *100) + ‘%’)

与逻辑斯蒂模型 74%的准确率相比，这一准确率为 71%。

测试模型

混淆矩阵

编辑:我正在和生物状态的一个朋友谈论我的分析，这个领域的惯例是这种疾病被认为是阳性的。我武断地将癌症设为阴性，因为当时我并不知道。

Figure 4

#Confusion Matrix
from sklearn.metrics import confusion_matrix
confusion_matrix = confusion_matrix(y_test, y_pred)
print(confusion_matrix)

将上面的矩阵与图 4 相匹配，了解它的意思:

34 我们模型的猜测为真阳性:模型认为患者没有癌症，他们确实没有癌症。
21 我们模型的猜测为真阴性:模型认为患者有癌症，他们确实有癌症。
14 我们的模型的猜测是假阴性:模型认为患者有癌症，但实际上他们没有癌症
8 本模型猜测为假阳性:本模型认为患者无癌症，但实际确实有癌症。

我们总数据的 30%进入了测试组，剩下 255 个(. 3) = 77 个实例被测试。矩阵的和是 77。将“真”数除以总数，就可以得出我们模型的准确度:55/77 = 71%。

形成准确度图和 ROC 曲线的新数据框架:

#Formatting for ROC curve
y_pred_prob = pd.DataFrame(y_pred_prob)
y_1_prob = y_pred_prob[1]
y_test_1 = y_test.reset_index()
y_test_1 = y_test_1['class (Y)']
X_test = X_test.reset_index()
CEA = X_test['CEA']
CA125 = X_test['CA125']#Forming new df for ROC Curve and Accuracy curve
df = pd.DataFrame({ 'CEA': CEA, 'CA125': CA125, 'y_test': y_test_1, 'model_probability': y_1_prob})
df = df.sort_values('model_probability')#Creating 'True Positive', 'False Positive', 'True Negative' and 'False Negative' columns 
df['tp'] = (df['y_test'] == int(0)).cumsum()
df['fp'] = (df['y_test'] == int(1)).cumsum()
total_0s = df['y_test'].sum()
total_1s = abs(total_0s - len(df))
df['total_1s'] = total_1s
df['total_0s']= total_0s
df['total_instances'] = df['total_1s'] + df['total_0s']
df['tn'] = df['total_0s'] - df['fp']
df['fn'] = df['total_1s'] - df['tp']
df['fp_rate'] = df['fp'] / df['total_0s']
df['tp_rate'] = df['tp'] / df['total_1s']#Calculating accuracy column
df['accuracy'] = (df['tp'] + df['tn']) / (df['total_1s'] + df['total_0s'])#Deleting unnecessary columns
df.reset_index(inplace = True)
del df['total_1s']
del df['total_0s']
del df['total_instances']
del df['index']#Export the log into excel to show your friends
export_excel = df.to_excel (r"C:\Users\Andrew\Desktop\df1.xlsx", index = None, header=True)

为了理解下面数据框架中发生的事情，让我们一行一行地分析它。

索引:该数据框架按 model_probability 排序，为方便起见，我重新进行了索引。
CA125 与 CEA :蛋白水平原始检测数据。
model_probability :该列来自我们的训练数据的 logistic 模型，输出它基于输入的测试蛋白水平被分类为“1”(癌变)的概率预测。第一行是分类为癌性的可能性最小的实例，其 CA125 水平高，CEA 水平低。
y_test :我们用来检验模型性能的测试数据的实际分类。

其余的列完全基于“y_test”，而不是我们模型的预测。将这些值视为它们自己的混淆矩阵。这将有助于我们确定最佳截止点的位置。

tp(真阳性):此列从 0 开始。如果 y_test 为“0”(良性)，则该值增加 1。它是所有潜在的真正积极因素的累积追踪器。第一行就是一个例子。
fp(假阳性):本列从 0 开始。如果 y_test 为“1”(癌变)，则该值增加 1。它是所有潜在假阳性的累积跟踪器。第四行就是一个例子。
tn(真阴性):该列从 32 开始(测试集中 1 的总数)。如果 y_test 为‘1’(癌变)，则该值减少 1。它是所有潜在真阴性的累积追踪器。第四行就是一个例子。
fn(假阴性):该列从 45 开始(测试集中 0 的总数)。如果 y_test 为‘0’(良性)，则该值减少 1。它是所有潜在假阴性的累积跟踪器。第四行就是一个例子。
fp_rate(假阳性率):这是通过计算行的假阳性计数并除以阳性总数(在我们的例子中是 45)得到的。它让我们知道我们可以通过在该行设置分界点来分类的假阳性的数量。我们希望尽可能降低成本。
TP _ Rate(True Positive Rate):也称为 sensitivity，计算方法是取该行的真阳性计数，然后除以阳性总数。它让我们知道我们可以通过在那一行设置分界点来分类的真阳性的数量。我们希望保持尽可能高的价格。
准确性:真阳性和真阴性的总和除以总实例数(在我们的例子中是 77)。我们一行一行地计算潜在的精确度，基于我们混淆矩阵的可能性。

Figure 5

查看数据帧中的混淆矩阵后，尝试找到最高的准确率。如果您可以找到它，您可以将其与相应的 model_probability 进行匹配，以发现分类的最佳分界点。

#Plot
plt.plot(df[‘model_probability’],df[‘accuracy’], color = ‘c’)
plt.xlabel(‘Model Probability’)
plt.ylabel(‘Accuracy’)
plt.title(‘Optimal Cutoff’)

Figure 6

随机森林模型将截止点设置为 60%的模型概率，即 75%的准确度。

这可能看起来违背直觉，但这意味着如果我们在将患者归类为癌症患者时使用 60%而不是 50%，那么使用这一特定模型实际上会更准确。

作为比较，逻辑模型将它的最佳截止点设置为 54%的概率，同样的准确度为 75%。

最后，让我们绘制 ROC 曲线并找出 AUC:

#Calculating AUC
AUC = 1-(np.trapz(df[‘fp_rate’], df[‘tp_rate’]))
#Plotting ROC/AUC graph
plt.plot(df[‘fp_rate’], df[‘tp_rate’], color = ‘k’, label=’ROC Curve (AUC = %0.2f)’ % AUC)
#Plotting AUC=0.5 red line
plt.plot([0, 1], [0, 1],’r — ‘)
plt.xlabel(‘False Positive Rate’)
plt.ylabel(‘True Positive Rate (Sensitivity)’)
plt.title(‘Receiver operating characteristic’)
plt.legend(loc=”lower right”)
plt.show()

Figure 7

黑色的 ROC 曲线显示了我们的测试数据的真阳性率和假阳性率之间的权衡。穿过图表中心的红色虚线是为了提供一种最坏可能模型看起来像 ROC 曲线的感觉。

ROC 线越靠近左上方，我们的模型越有预测性。它越像红色虚线，预测性就越低。

这就是曲线下面积(AUC)的由来。AUC 是位于 ROC 曲线下的空间面积。直观上，这个值越接近 1，我们的分类模型就越好。虚线的 AUC 是 0.5。完美模型的 AUC 应该是 1。我们的随机森林的 AUC 为 0.71。

为了比较，提供了 AUC 为 0.82 的 logistic ROC 曲线:

Figure 8

结论

比较模型之间的准确率和 AUC，这次是 logistic 回归胜出。这两种模式都各有利弊。

如果你觉得这有帮助，请订阅。如果你喜欢我的内容，请查看其他几个项目:

简单线性 vs 多项式回归

用 Python 中的逻辑回归预测癌症

二元逻辑回归示例(python)

从头开始计算 R 平方(使用 python)

风险棋盘游戏战斗自动化

风险棋盘游戏——战斗概率网格程序

延伸阅读:

随机森林回归:何时失败，为什么？

ReLU 是 ReLUvant 吗？

原文：https://towardsdatascience.com/is-relu-reluvant-52b03bc48daa?source=collection_archive---------33-----------------------

质疑深层神经网络中非常基本的元素

Photo by: Nur Lan

近年来，深度神经网络被广泛应用于不同的领域。即使在今天，我们也在尝试构建更广泛、更深入的架构来解决现实世界的问题。深度神经网络的关键方面是它的非线性，这通过激活函数来实现。在 CNN 中，用于对象识别的大多数现有技术模型在网络架构内的卷积层之前或之后具有激活函数。但是有激活功能有多重要呢？我们真的需要为执行的每个卷积设置一个激活函数吗？我们将在本文中讨论其中的一些问题。

激活有各种形式

近年来，已经设计了不同的激活函数。随着大量实验集中于确定 CNN 的“最佳”激活，每篇论文都声称比同行的表现更好。一些广为人知的激活有:

ReLU

ReLU(x) = max(0, x)

漏 ReLU 和 P ReLU

泄漏 ReLU 和参数 ReLU 与正值 x 的 ReLU 相似，但负值的斜率较小。在泄漏 ReLU 中，该斜率常数为 0.01。

*Leaky ReLU = 0.01x* ∀ *x < 0
Parametric ReLU = ax & 0<a<1* ∀ *x< 0*

ELU 和 SELU

Exponential Linear Unit = α.(e^x –1) ∀ x<=0 
*Scaled Exponential Linear Units =* λx ∀ x>0 *=* λ(α.(e^x –1)) ∀ x<=0

与 ReLU 相比，ELU 和 SELU 在 x=0 时具有更平滑的曲线。

尽管有如此花哨的激活功能可用，但最近大多数 CNN 模型都只采用了 ReLU，这可能意味着，如果不是最好的，它的性能与任何其他激活功能一样好。可能的原因是:这很简单，使得反向传播更容易校正权重和保持更少的参数。因此，它有助于模型更快地训练和收敛。

这在很大程度上证明了 ReLU 的优势，但是我们还没有得到第二个问题的答案:在网络中的每个卷积层之后是否需要使用激活函数？为了回答这个问题，让我们开始我们的实验。

实验

让我们从具有完全预激活的 ResNet 块的 ResNet18 模型开始。在这个实验中，我们将随机丢弃一些 ReLU 激活函数，从 100%开始，在每个后续实验中丢弃 10%，保持所有其他参数一致。

在本实验中，我们将使用 CIFAR10 数据集。

超参数

BATCH_SIZE = 512
MOMENTUM = 0.9
WEIGHT_DECAY = 5e-4
LEARNING_RATE = 0.4
EPOCHS = 24
ReLUPercent =100

图像增强

Height and Width shift range = 0.15625,
Rotation range = 12
Random LR Flip

优化器

使用动量为 0.9，重量衰减为 5e-4 的 SGD。一个周期的学习率策略，在第 5 个时期具有 0.4 的最大 LR，并向后面的时期逐渐下降。

体系结构

该模型有 4 个 ResNet 块。与传统的 ResNet 不同，在 ResNet 块的末尾，我们连接输入和残差路径，然后进行逐点卷积，以过滤前面获取的信息。
该模型有 25 个激活层(24 个 ReLUs 和 1 个 softMax)。

基准

在 CIFAR10 数据集上，该模型在 Google Colab 上 800 秒下的 24 个历元中给出了约 88%的验证准确率。该模型有大约 27M 个参数。

训练

Plot 1: a)Validation Accuracy Curve, b) Training Accuracy Curve

结果

Table1: Accuracy Comparision

令人惊讶的是，当随机丢弃 10%的 ReLUs 时，获得了最佳的精度。第二好的准确度是当模型使用原始网络中总 ReLUs 的 80%时。对于一个卷积 100%次，我们有一个 ReLU 的精度是在最佳精度之后的 1.58% 。

Plot 2: Max Validation Accuracy

有了这些结果，我们可以部分回答我们的问题

在每个卷积后盲目添加 ReLU 是构建 CNN 架构的正确方式吗？
大概不会！
有没有更好的办法？
肯定是的！
如何决定是否需要添加 ReLU？
网格搜索可以是一种方式，但我想不出任何其他最优方式来决定是否在一次卷积后添加 ReLU。

虽然我们仍然不知道卷积层是否具有 ReLU 的适当方法，但希望这确实有助于我们理解，在设计深度神经网络时，仍然需要质疑非常基本的元素的使用。

实验可以在这个 Colab 笔记本里找到。

感谢您的阅读！请在评论中告诉我你的想法。再次感谢，继续学习！

[1]:何、、张、向宇、任、、孙、简。(2016).用于图像识别的深度残差学习。770–778.10.1109/cvpr . 2016.90 .
【2】:克日涅夫斯基，亚历克斯。(2012).从微小图像中学习多层特征。多伦多大学。

软件真的在蚕食世界吗？

原文：https://towardsdatascience.com/is-software-really-eating-the-world-9e9182bf6400?source=collection_archive---------30-----------------------

证据就在数字中

Source: Pixabay

软件公司都是。市值超过 3 亿美元的公共软件公司的平均市值收入比现在徘徊在 7.5 左右。很多这一切不仅仅是基于最近的高增长率，也是基于这样一种观点，即这些增长率将在未来很长一段时间内持续下去。这就是马克·安德森的论断， 软件正在吞噬世界。

安德森在七年多前写下了这篇现在被广泛引用的文章；在文章中，他以以软件为中心的公司的形式提供了强有力的证据，包括我们非常熟悉的常见嫌疑人，他们甚至不需要在这里重复。对于我们这些长期从事软件工作的人来说，这个论点似乎是不言自明的。证据就在我们周围，如果它走路像鸭子，叫起来像鸭子，那么它一定是一只鸭子。

我经常在各种场合引用“软件正在吞噬世界”这句话。这与我的信仰和我的所作所为是一致的。但我有时会遇到来自密苏里州的人，他们说“给我看看。”有没有一种实证的方法来检验这是不是真的，有多真实？相对于资产、劳动力和材料驱动，企业和经济向软件驱动转变的速度有多快？****

直接经验

我对软件吞噬世界的直接体验来自于设计、销售和实现供应链软件。购买该软件和其他企业软件的价值主张通常基于增加销售额、降低成本和减少资本投资需求。

例如，当一家公司购买生产调度软件时，它这样做是为了增加产量或减少库存。该公司减少了对有形资产的需求，无论是生产设备还是库存。如果没有软件投资，公司将不得不投资更多的生产机器、库存和劳动力。

在这个例子中，公司可以购买价值 100 美元的软件，以避免在额外的机器上投资 1000 美元。机器投资也是典型的阶跃函数——你必须购买全部产能，不管你是否使用它。

通过进行软件投资而不是机器投资，数字密集度—或软件密集度—变得更大。软件成为资产基础中越来越重要的一部分，或者换句话说，软件已经吃掉了物理世界的这一部分。

从这个角度来看，我们已经走上了一条软件蚕食世界的道路。例如，低级穿孔卡嵌入了数字信息，充当了人、规则和机器之间的翻译接口。它帮助实现了各种劳动密集型记账、会计、工程和其他计算相关功能的自动化(当然，在这样做的过程中，它以打字员的形式创造了一支体力劳动大军)。

证明它

事实证明，我们备受指责的政府有一整套设备来捕捉这些趋势的数据。据我所知，中国在这方面做得更好，比世界上任何其他国家都更透明、更开放。我利用这些数据已经有一段时间了；我发现宏观经济数据与行业或公司层面的微观数据如此接近很有意思。

下面的图表(使用经济分析局的数据构建)比较了过去三十年美国经济中软件和机械设备的增长率。从这一点你可以很快推断出，安德森不仅在轶事上是正确的，而且就整个美国经济而言，他是正确的。可以肯定地说，美国经济是全球经济状况的合理代表。

图表上需要注意的另一件事是，自 2010 年以来，打包软件曲线的斜率明显比前十年更陡，但仍未达到 1995 年至 2000 年互联网泡沫时期的增长率。这可能证明这不是泡沫，当前的增长率是可持续的。

吃豆人图表

下面的图表可能更能说明问题，我称之为吃豆人图表。它以十年为增量，显示了过去三十年中机器和设备相对于软件的投资百分比。Pacman(在这种情况下是软件)正在消耗越来越多的投资。

以上两个图表都有一些警示:

软件数量不包括嵌入式软件——换句话说，与机器和设备一起携带的软件显然也在增长。同样，它们也不包括大量嵌入终端产品的软件。显然，这些数据很难获取。
这些数据不包括建筑物等物理结构；它们只包括建筑物内的设备。对物理结构的投资是一个巨大的数字。话虽如此，软件也开始侵蚀物理结构，如下所述。
与机器和设备相比，BEA 使用的软件折旧时间框架要短得多。这就产生了这样的效果:软件积累的程度不如物理资产；公司投资于它，然后它迅速贬值，至少与实物资产相比是如此。

数字混乱

与“数字化转型”相关的噪音震耳欲聋。每一个主要的咨询公司和企业软件公司都承诺带你去乐土。对于许多公司来说，短期的乐土只是为了另一天而战。

****但数字化转型不一定会令人困惑。这只是另一种方式来提高产品和流程，改善制造产品所需的劳动力、材料和资产。我们的目标始终如一——如何长期拥有您的客户并从中获利。

下图是观察数字化转型的一种简单方式。每个业务流程都有一组输入。这些投入转化为增值产出。不同的是，软件在输入中的比重越来越大，转换功能不再仅仅是电气、机械或化学。

当公司在所有流程中都这样做时，他们本质上就变成了数字公司。

机械、车辆和建筑

之前显示的图表不包括建筑物、构筑物和房屋。这是全球已部署资产基础的一大部分。建筑物在接受数字内容方面明显落后于消费产品，因此代表了竞争的沃土。见证亚马逊和谷歌争夺软件家庭主导地位的竞争。建筑物是长期资产；因此，添加数字内容主要是一个改造问题(机械行业也是如此，目前 IOT 的大部分工作都是改造工作)。

1977 年，当第一个拥有 50K 行代码的微处理器出现在一辆奥兹莫比尔汽车上时，家庭就是汽车所在的地方。在过去的 15 年里，几乎所有的新车增值都来自电子产品，其中大部分是由软件驱动的。这是一个很好理解的软件吃实体产品的例子。

今天的现代高端汽车有 50 到 100 个微处理器和 1 亿行代码。而且，这些功能已经从豪华车快速转移到经济型车，因为好车变成了必备品。

不难想象 2040 年的家也会有同样的装备。当然，房屋是长期资产，不像汽车，不会定期更换。因此，虽然新房子将越来越多地配备微处理器和嵌入式软件，但软件侵蚀建筑物的过程将是一个持续的翻新过程。

包括汽车供应商和工业设备制造商在内的工业企业，正竭尽全力向投资者展示它们实际上是软件公司，因为它们继续用软件来扩充产品。今天，典型的工业公司投资者演示文稿充斥着统计数据，显示他们拥有的软件工程师数量、开发流程的成熟度，以及他们产品组合中嵌入的大量先进技术。当你的公司的股价是销售额的 0.5 倍，而软件公司的股价是销售额的 7.5 倍时，你想要分一杯羹。

你还没看到什么呢

有人说数据是新的石油。如果数据是新的石油，那么软件就是生产设备、劳动力、材料、运输以及处理数据并使其有用的最终产品。当然，软件和数据之间的关系类似于石油和内燃机之间的关系——没有一个就无法运行。更进一步来说，每种组合都会产生很多好处，但也会产生一些讨厌的副产品。

****数字资产取代实物资产的过程将持续很长一段时间。然而，这是有限制的——例如，你不能生活在数字资产中。你居住的实物资产仍将存在，但其数字化程度将显著增加。在某个时候，数字和物理会达到一种平衡；但是那似乎是一个遥远的未来，到那个时候我们将已经进入下一个伟大的时代。

原载于 2019 年 2 月 20 日www.worldlocity.com。**

斯德哥尔摩越来越热了吗？

原文：https://towardsdatascience.com/is-stockholm-getting-hotter-c7ce8a9008ee?source=collection_archive---------23-----------------------

使用 Bootstrap 在 Python 中进行假设检验

在这篇文章中，我展示了自 50 年代以来斯德哥尔摩的平均气温明显高于 1756 年。

使用的数据集包含了斯德哥尔摩自 1756 年以来 262 年的日平均气温。查看这些数据(转换为年份),我们可以看到自 1756 年以来最热的 10 年中有 5 年发生在 2000 年之后。

自 50 年代以来，平均气温上升了 0.74 摄氏度

通过基于历史数据和使用 bootstrap 进行假设检验，我已经能够证明斯德哥尔摩的天气确实发生了变化。

在我关于介质的第一篇文章中，我写了一些基于相同温度数据的代码来推导累积分布函数，以便有一个可视化工具来比较经验分布和理论分布，如正态分布。在这篇文章中，你可以了解到我如何进一步利用这一点，并得出上述结果，表明斯德哥尔摩实际上正在变热。

NASA 主办的这个网站给了我一个洞察力，让我将 1950 年定义为一个比较的门槛。

为什么是 1950 年？

几个世纪以来，温室气体二氧化碳的百万分率(ppm)在 300 以下波动。更高的地球表面温度和大气中的温室气体浓度密切相关。

嗯，1950 年是第一个越过这个水平的年份，从那以后，大气中的二氧化碳含量急剧上升。

The level reached 415 ppm yesterday

我们编码吧？😃

导入带有常用别名的包。

Pandas 🐼 and friends

读取包含原始数据集的 URL 。

Reading the data

Stockholm Temperatures Data Set

我们感兴趣的问题是:

自 50 年代以来，斯德哥尔摩的平均气温是否比 1756 年前的气温高？

为了回答这个问题，我们将对数据进行转换，使分类变量指示世纪以及平均气温是来自 50 年代前后的某一年。

Before and After 50's

Data Set Sample After the Transformation (Yearly Average Temperatures)

有了这个转换后的数据集，我们可以开始探索，并对平均温度有初步的了解。

我们来做个 10 大气温排名？做好准备。

Top 10 Yearly Average Temperatures since 1756

8 从 1970 年开始。

7 如果你回到 1980 年。

6 如果扩展到 1990 年。

5 起发生在 2000 年以后。

😲

好像发生了什么事，不是吗？绝对值得对这些数字进行深入调查。

Are the temperatures coming from the same process?

上面的图表实际上表明，在 50 年代以后的几年里，平均温度向更高的值移动。箱线图总是能拯救我们，让我们对这些数字有更好的直觉。

Boxplot of Temperature Average Differences (before and after 50's)

箱线图显示，50 年代后的中值温度大于 50 年代前全年平均温度的 75%

自 50 年代以来，平均气温上升了 0.74 摄氏度

大约 1 摄氏度的上升会带来巨大的后果。

雄辩。😩

你听说过蜂群计划吗？它与箱线图来自同一个系列，但您可以有效地看到数据点。当点数不太高时，我总是喜欢看一看，以获得关于分布的真实感觉。在我们的例子中，有 262 个平均温度。很好！

Swarmplot and Seaborn 💙

你对蓝色和红色的分布有什么看法？它们来自同一个来源吗？

我认为现在的问题说得很好。是时候停止猜测，使用统计工具了。

假设检验。

你还记得你的统计学入门课吗？我不知道。😸

假设检验的第一件事，不好意思，是假设。我们的是什么？我们称之为无效假设。

两个时期的平均温度相差近 0.74°C，这是由于温度分布的随机波动造成的，也就是说，斯德哥尔摩的天气没有任何变化。

我们的工作是通过计算观察到这种差异或更高的概率来挑战这一假设，如果斯德哥尔摩的天气没有变化的话。

如果它足够小，我们就有证据表明斯德哥尔摩真的变得越来越热，我们自豪地拒绝零假设。如果这样的可能性很高，我们就不能根据这个数据宣称有任何变化。

好吧。

我们必须模拟一个零世界并计算概率。但是怎么做呢？

第一，零世界。在这个世界上，自 50 年代以来什么都没有改变，所以两组中的任何一个温度在整个时期的任何时间都是可能的。

有意思。

如何在两组之间调整温度并重新标记它们呢？绝对没有问题，因为天气过程在过去的 262 年里都是一样的。下面我们有这样做的代码。

Shuffling in a Null World

具体的例子。我们有两组， a 和 b 。置换函数打乱数据并重新标记。现在清楚了吗？

Permutation and Relabeling

排列前 a 和 b 的平均差值为 0.8。

在排列之后，平均差变成-1.8。在零世界中，这种差异是随机发生的正常波动。如果我们一次又一次地重复这个过程，几次，我们可以建立两组之间平均差异的分布。这个技术的名字叫做引导。

你对将这种东西应用于斯德哥尔摩的温度感到好奇吗？

我是。

下面的代码来完成任务。

Permutation on Two Samples

我们将对我们的数据进行 10000 次排列和重新标记，以绘制两组(50 度之前和之后)在所谓的零世界中平均温度差异的概率分布。

换句话说，我们正在模拟我们已经记录了 10000 次(1756-2017)的 262 年期间。

所有的权力💻！

Simulated Null Hypothesis

正如我们在上面看到的，在零空间中，观察到 0.74°c 的差异是极其罕见的。

极其罕见。

有多稀有？在零世界中观察到的值等于或高于我们感兴趣的统计量的概率称为 p 值。

让我们计算一下，在我们模拟的零假设下，观察到 0.74°C 或更高的极端温差的概率。

p-value

正如通过检查该图所预期的那样，p 值为零。有 3 个十进制数字的零。

有了这么低的 p 值，我们可以自信地拒绝零假设，并说产生斯德哥尔摩温度的天气过程发生了变化。

斯德哥尔摩真的越来越热了。如果 50 度之前和之后的温度来自同一分布，则观察到的温度平均差(0.74 摄氏度)不会发生。

我个人喜欢直观地看到正在发生的事情。在下面的图中，我们可以看到零世界的所有 10000 个实现和我们的经验差异(0。74 C)作为孤独的红点。

10000 Realizations of the Null World

我们能睡得安稳吗？

还没有。在我们对零世界的模拟中，我们使用了 bootstrap，认为所有的温度都是相互独立的，即一年的温度与前几年的温度没有关系。如果是这样的话，我们的假设检验很可能已经失败，因为它可能已经破坏了时间序列对随后几年温度的依赖性。

我们必须检查这个假设。正如我在航空业的一位前老板过去常说的那样:“一切未经检查的东西都是错的”。

下一张图在 x 轴上显示了给定年份的温度，在 y 轴上显示了下一年的温度。如果我们的独立性假设在数据集中成立，我们将看不到任何确定的模式。

Average Temperature with Lag of 1 year

👏我们通过了。

另一个也是最后一个检查。让我们计算给定年份温度和随后 20 年的平均相关性。

Temperatures Pearson Coefficients (lag of 20 years)

太好了！人们可以看到一年和随后几年之间的弱相关性。

我的瑞典同事很早就知道这一点，因为他们总是说，去年炎热的夏天对今年即将到来的夏天没有任何影响。

我们的零世界经受住了，我们声称斯德哥尔摩的天气发生了变化。

所有代码都在我的 GitHub 里。

你也可以通过 LinkedIn 联系我。感谢阅读！

那是只莺吗？Python 中 Keras CNN 的鸟类分类

原文：https://towardsdatascience.com/is-that-a-warbler-bird-classification-with-keras-cnn-in-python-db4606555a33?source=collection_archive---------11-----------------------

有没有想过“那是什么鸟？”

我一直想知道“那是什么鸟？”当我带着我的狗在波士顿的一个公园散步时，那里一年四季都充满了鸟类:夏天是小鸭子，秋天/春天是迁徙的鸣鸟，冬天是水鸟。我的爷爷(一个长期观察鸟类的人)给了我 Sibley 鸟类野外指南，这激发了我的爱好。在你认为这是老年人的爱好之前，我强烈建议你去观鸟，尤其是如果你有相机的话。

由于大多数小鸟不会安静地坐足够长的时间，让你翻阅 400 页野外指南并比较 20 多个标记，我开始拍摄鸟类的照片，希望我能有足够清晰的照片供以后识别。然后我发现了一个名为 eBird 的网站，它可以让你追踪你在哪里见过哪种鸟。你甚至可以上传一张照片作为证明。对于那些喜欢口袋妖怪的书呆子来说，就像那样，但有真正的活鸟！

Source: https://www.trollandtoad.com/pokemon/pokemon-miscellaneous-supplies/pokemon-1999-pikachu-meowth-pokedex-2-pocket-folder/1167040

偶尔，我会上传一张错误的鸟的照片，但幸运的是，有 eBird 志愿者监控这些鸟的照片，并给你发电子邮件(友好地)说你标记了错误的物种。但是不要经常这样做，因为那样他们会锁定你的帐户(哎呀！).通常，这些志愿者也会告诉你正确的物种。这对那些志愿者来说是一项繁重的工作！

Not a Savannah Sparrow

作为一名数据科学家，我在想:如果我们可以自动检查每一张用深度学习上传的鸟类照片，会怎么样？作为一个周末项目的原理证明，我创建了这个预测模型来检测鸟类图像是否是一只莺(我爷爷最喜欢的鸟类类别)。

项目定义

给定一只鸟的图像，预测它是否是一只林莺(见下面的林莺物种标签)

数据集

本项目数据集来自加州理工学院-加州大学圣迭戈分校 Birds-200–2011(【http://www.vision.caltech.edu/visipedia/CUB-200-2011.html】T2)。该数据集包含 200 种鸟类的 11，788 张图片。由于任何一个物种的图像数量都很少，作为原则的证明，我决定将所有的莺图像进行分组。

设置:加载元数据

让我们从聚集加州理工学院-加州大学圣地亚哥分校提供的所有元数据开始:

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np#path to dataset
data_path = '../CUB_200_2011/CUB_200_2011/'# aggregate datasets
df_images = pd.read_csv(data_path+'images.txt', 
                        sep = ' ',header = None, 
                        names = ['img_num','img'])
df_labels = pd.read_csv(data_path+'image_class_labels.txt', 
                        sep = ' ',header = None, 
                        names = ['img_num','class_id'])
df_classes = pd.read_csv(data_path+'classes.txt', 
                         sep = ' ', header = None, 
                         names = ['class_id','bird_class'])
df_split = pd.read_csv(data_path +'train_test_split.txt', 
                       sep = ' ', header = None, 
                       names = ['img_num','dataset'])df = pd.merge(df_images, df_labels, on = 'img_num', how = 'inner')
df = pd.merge(df, df_classes, on = 'class_id',how = 'inner')
df = pd.merge(df, df_split, on = 'img_num',how = 'inner')

数据包含图像编号、img 名称(带路径)、物种 id 以及物种文本，如下所示。由于我们将进行自己的培训/测试分割，因此我们将忽略该团队提供的分割，即最后一列。

制作莺输出标签

我浏览了物种列表，提取了列表中的所有鸣鸟:

warbler_class = ['020.Yellow_breasted_Chat','158.Bay_breasted_Warbler',
       '159.Black_and_white_Warbler', '160.Black_throated_Blue_Warbler',
       '161.Blue_winged_Warbler', '162.Canada_Warbler',
       '163.Cape_May_Warbler', '164.Cerulean_Warbler',
       '165.Chestnut_sided_Warbler', '166.Golden_winged_Warbler',
       '167.Hooded_Warbler', '168.Kentucky_Warbler',
       '169.Magnolia_Warbler', '170.Mourning_Warbler',
       '171.Myrtle_Warbler', '172.Nashville_Warbler',
       '173.Orange_crowned_Warbler', '174.Palm_Warbler',
       '175.Pine_Warbler', '176.Prairie_Warbler',
       '177.Prothonotary_Warbler', '178.Swainson_Warbler',
       '179.Tennessee_Warbler', '180.Wilson_Warbler',
       '181.Worm_eating_Warbler', '182.Yellow_Warbler',
       '183.Northern_Waterthrush', '184.Louisiana_Waterthrush', '200.Common_Yellowthroat']

这允许我们制作一个二进制输出标签:

df['OUTPUT_LABEL'] = (df.bird_class.isin(warbler_class)).astype('int')

将数据分为训练和验证

我们可以将数据分为 70%训练数据和 30%验证数据。

df = df.sample(n = len(df), random_state = 42)
df_train_all = df.sample(frac = 0.7, random_state = 42)
df_valid = df.drop(df_train_all.index)

并检查两组的患病率是否相同:

def calc_prevalence(y):
    return sum(y)/ len(y)print('train all %.3f'%calc_prevalence(df_train_all.OUTPUT_LABEL))
print('valid %.3f'%calc_prevalence(df_valid.OUTPUT_LABEL))

大约各占 15%

图像增强

在这一点上，我们可以只是训练一个深度学习模型，但由于不平衡，该模型可能最终只会默默预测不是一只林莺。我试过了，发生在我身上。

为了抵消这种不平衡，我们需要获取或制作更多的林莺图像，或者对非林莺图像进行二次采样。对于这个项目，我将使用数据增强(旋转，缩放，裁剪，翻转等)来增加林莺图像的数量。为了更好的回顾数据增强，请看这个蝴蝶探测器项目。

让我们从数据帧中抓取所有的林莺图像:

warbler_imgs = df_train_all.loc[df_train_all.OUTPUT_LABEL == 1,’img’].values

然后，我们可以使用 Keras ' T0 '来制作新的增强图像。为了简单起见，我将把这些新图像保存在一个增强的林莺文件夹中。此外，给非林莺图像添加增强可能是个好主意，这样 DL 模型就不会知道‘增强’是林莺图像，但我现在跳过这一步。我也看过其他文章在训练中做这种增强，但是我现在也跳过这个。

然后我们可以聚集增强的图像:

 from os import listdirwarbler_aug_files = ['aug_warblers/'+ a for a in listdir(data_path+'images/aug_warblers/') if a.endswith('.jpg')]df_aug = pd.DataFrame({'img':warbler_aug_files, 'OUTPUT_LABEL': [1]*len(warbler_aug_files) })

并与我们现有的培训相结合

df_c = pd.concat([df_train_all[['img','OUTPUT_LABEL']],df_aug],
                 axis = 0, ignore_index = True, sort = False)

为了安全起见，让我们以 1:1 的比率在莺和非莺之间平衡数据:

rows_pos = df_c.OUTPUT_LABEL == 1
df_pos = df_c.loc[rows_pos]
df_neg = df_c.loc[~rows_pos]
n= min([len(df_pos), len(df_neg)])
df_train = pd.concat([df_pos.sample(n = n,random_state = 42), 
                      df_neg.sample(n = n, random_state = 42)], 
                     axis = 0)
df_train = df_train.sample(frac = 1, random_state = 42)

构建 X 和 Y

我们现在可以为机器学习建立我们的 X 和 Y。为了做到这一点，让我们创建一个函数来加载给定数据帧的所有图像，该数据帧

将每个图像的大小调整为 224x224
转换为 RGB (3 通道)
从 0 到 1 归一化(即除以 255)

IMG_SIZE = 224
def load_imgs(df):
    imgs = np.ndarray(shape = (len(df), IMG_SIZE, IMG_SIZE,3), dtype = np.float32)
    for ii in range(len(df)):
        file = df.img.values[ii]
        img = load_img(data_path+'images/'+file, target_size=(IMG_SIZE, IMG_SIZE),color_mode='rgb')
        img = img_to_array(img)/255
        imgs[ii] = img
    return imgs

我们可以用

X_train = load_imgs(df_train)
X_valid = load_imgs(df_valid)y_train = df_train.OUTPUT_LABEL.values
y_valid = df_valid.OUTPUT_LABEL.values

这里的 X 矩阵并不是我们想要的 Keras，所以让我们用

# reshape
X_train = X_train.reshape(X_train.shape[0], IMG_SIZE,IMG_SIZE, 3)
X_valid = X_valid.reshape(X_valid.shape[0], IMG_SIZE,IMG_SIZE, 3)

我最后的 X_train 有一个形状(14104，224，224，3 ),这意味着我们有 14104 个 224 x 224 的图像，有 3 种颜色。

我们可以用以下方式绘制其中一幅图像:

ii = 3
plt.imshow(X_train[ii])
plt.title(df_train.img.iloc[ii])
plt.show()

Image of augmented yellow-rumped warbler

CNN 机器学习模型

为简单起见，让我们创建一个架构，该架构具有两个带 dropout 的 CNN 层、一个密集层和用于该二进制分类器的最终 sigmoid。稍后可以尝试其他更复杂的架构。

from keras.models import Sequential
from keras.layers import Conv2D, MaxPool2D, Dense, Flatten, Dropoutmodel = Sequential()
model.add(Conv2D(filters = 64, kernel_size = (5,5), 
                 activation = 'relu', 
                 input_shape = X_train.shape[1:]))
model.add(MaxPool2D(pool_size = (3,3)))
model.add(Dropout(rate = 0.25))
model.add(Conv2D(filters = 64, kernel_size = (3,3), 
                 activation = 'relu'))
model.add(MaxPool2D(pool_size = (3,3)))
model.add(Dropout(rate = 0.25))
model.add(Flatten())
model.add(Dense(64, activation = 'relu'))
model.add(Dropout(rate = 0.25))
model.add(Dense(1, activation = 'sigmoid'))

我们将用 Adam 和二元交叉熵损失(即 2 类的对数损失)来编译我们的模型。

model.compile(
                loss = 'binary_crossentropy',
                optimizer = 'adam',
                metrics = ['accuracy'])

您可以用以下方法训练您的分类器(为了加快速度，我刚才用 64 的批量做了 2 个时期):

model.fit(X_train, y_train, batch_size = 64, epochs= 2, verbose = 1)

预测和模型性能

我们可以计算训练和验证的预测值，如下所示:

y_train_preds = model.predict_proba(X_train,verbose = 1)
y_valid_preds = model.predict_proba(X_valid,verbose = 1)

我将把验证预测保存在 df_valid 中，以便进一步分析

df_valid['pred'] = y_valid_preds

我们可以看看我们做得最好(最高平均分)的林莺种类

df_valid.loc[(df_valid.OUTPUT_LABEL == 1) ].groupby('bird_class').pred.mean().sort_values(ascending = False)

从一些图片来看，似乎这个模型对黄色的莺比对没有黄色的莺做得更好。

我们也可以看看模型倾向于认为是鸣鸟但不是的物种:

这是有道理的，因为金翅雀非常黄！

我们可以计算一系列指标的性能(关于分类指标的教程，请参见我的帖子这里

from sklearn.metrics import roc_auc_score, accuracy_score, \
                            precision_score, recall_score
def calc_specificity(y_actual, y_pred, thresh):
    # calculates specificity
    return sum((y_pred < thresh) & (y_actual == 0)) /sum(y_actual ==0)def print_report(y_actual, y_pred, thresh):

    auc = roc_auc_score(y_actual, y_pred)
    accuracy = accuracy_score(y_actual, (y_pred > thresh))
    recall = recall_score(y_actual, (y_pred > thresh))
    precision = precision_score(y_actual, (y_pred > thresh))
    specificity = calc_specificity(y_actual, y_pred, thresh)
    print('AUC:%.3f'%auc)
    print('accuracy:%.3f'%accuracy)
    print('recall:%.3f'%recall)
    print('precision:%.3f'%precision)
    print('specificity:%.3f'%specificity)
    print('prevalence:%.3f'%calc_prevalence(y_actual))
    print('pred pos:%.3f'%(sum(y_pred > thresh)/len(y_actual)))
    print(' ')
    return auc, accuracy, recall, precision, specificity

因为我们平衡了数据，所以让我们设置一个阈值 0.50 来标记预测的莺:

thresh = 0.5
print('train')
print_report(y_train, y_train_preds[:,0], thresh);
print('valid')
print_report(y_valid, y_valid_preds[:,0], thresh);

我们可以用以下公式绘制 ROC 曲线:

from sklearn.metrics import roc_curve, roc_auc_scorefpr_train, tpr_train, t_train = roc_curve(y_train, y_train_preds[:,0])
auc_train = roc_auc_score(y_train, y_train_preds[:,0])fpr_valid, tpr_valid, t_valid = roc_curve(y_valid, y_valid_preds[:,0])
auc_valid = roc_auc_score(y_valid, y_valid_preds[:,0])plt.plot(fpr_train, tpr_train, 'r-', label = 'Train AUC:%.3f'%auc_train)
plt.plot(fpr_valid, tpr_valid, 'b-', label = 'Valid AUC:%.3f'%auc_valid)plt.plot([0,1],[0,1], 'k--')
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend()
plt.show()

正如我们可以看到的，这个简单模型的 AUC 在验证上相当高。这给了我建立一个分类器来帮助我标记鸟类图像的巨大希望。

让我们用我自己的一些图片来测试一下:

file = 'magnolia2.png'
print(file)
x = load_img(file, target_size=(IMG_SIZE, IMG_SIZE),color_mode='rgb')
x= img_to_array(x)/255
x=x.reshape(1,IMG_SIZE,IMG_SIZE, 3)
print('prob it is warbler:%.3f'%model.predict_proba(x,verbose = 1)[0][0])
plt.imshow(load_img(file))
plt.show()

我可以正确地把玉兰花莺归类为莺

并把这种冲浪苏格兰人归类为非林莺

结论

在这篇文章中，我们建立了一个简单的 CNN 模型来预测一张鸟的照片是不是一只莺！

# 10 年度挑战赛是人工智能末日的征兆吗？

原文：https://towardsdatascience.com/is-the-10yearchallenge-a-sign-of-the-ai-apocalypse-71dba6a5ddc9?source=collection_archive---------22-----------------------

近年来，病毒式社交媒体“挑战”、迷因和噱头已经接管了我们的供稿。“挑战”这个词用得并不严格，因为这些病毒式的感觉并不那么具有挑战性，它们只是增加你社交媒体形象的独特方式。但它们也是即将到来的人工智能末日的迹象吗？让我们看得更远。

诚然，这些事件的范围从荒谬和边缘危险(琪琪你爱我吗)；有益的，如使人们意识到一项重要的事业。(ALS 冰桶挑战)。但是它们实际上意味着什么呢？在他们天真无邪的外表下，是否潜藏着严肃甚至邪恶的可能性？

进入脸书

最近，当用户开始张贴他们相隔十年的并排照片时，10 年挑战(又名衰老对你打击有多大和发光挑战)在社交媒体(特别是脸书)上掀起了风暴。

与之前的许多挑战一样，这次挑战遇到了各种各样的反应。标准，“哇！太可爱了，我想加入“翻白眼”的行列！千禧一代。”

除非被提起，否则大多数人都不会想到一个触动更重要神经的反应。这危险吗？这里有比看上去更多的东西吗？

例证:Wired.com 作家凯特·奥尼尔(Kate O'Neill)在下面发布了一条推文，引发了对人工智能/人工智能和安全的讨论。

10 年前的我:可能会配合脸书和 Instagram 上流传的个人资料图片老化 meme】现在的我:思考如何挖掘所有这些数据，以训练年龄增长和年龄识别的面部识别算法——凯特·奥尼尔(@ kateo)2019 年 1 月 12 日

凯特·奥尼尔在《连线》杂志的后续文章中对此进行了阐述

上面的推文和文章像病毒一样传播开来。很快，人们开始怀疑“这真的只是一点无害的社交媒体乐趣吗？”还是差很多？我们只是故意把重要的面部识别数据交给大技术公司吗？可能的后果是什么？人工智能启示录会被电视转播吗？

踩刹车。

让我们打开这个

作者在这篇文章中提出了一些重要观点。她解释了数据收集、面部识别的逻辑，并提供了最好到最坏的情况。

此外，这位作者和许多在线用户争论的主要问题是，通过参与挑战，我们正在为算法和面部识别系统做所有繁重的工作。公平点。

虽然这些照片中的许多已经可以在网上获得，但从这些照片中收集数据并不容易。许多平台从图像中剥离 EXIF 数据，以保护用户隐私。

本质上，上传你的#10YearChallenge 照片可以清晰、简单、并排地对比之前上传的照片中缺失的所有数据和背景。

AI 和 ML 系统可以获取这批新数据，并使用它来学习人类的衰老过程或更新现有的已知人脸数据库。这可能是一件伟大的事情。最终，真正的问题是谁在使用这些数据，如何使用？

当然，这种观点最极端和最邪恶的版本是，我们都无意中成为我们自己灭亡的同谋和不幸的建筑师。让我们从现实世界的角度来看这个问题。

我们想要更新一个可能被滥用的大规模数据库吗？当然不是。

事实上，任何形式的技术都有被不恰当使用的危险吗？是的，绝对的。

我们迎来了现实世界版本的天网吗？不，不完全是。当人工智能启示录来袭时，它可能会被电视转播(或直播)，但它不太可能被脸书迷因所加速。

风险

在这篇文章中，凯特·奥尼尔打破了亚马逊和微软等公司目前正在销售的面部识别程序的一些担忧。这些担忧中有许多是有道理的。

这项技术的销售引起了许多人不安的共鸣。使用可以是平凡的，如利用数据超目标广告位置，使每一个更相关；一直到创建老化软件，帮助确定一个人的保险政策的资格。

它还可以帮助比以往更快地找到绑架和人口贩运受害者。

冒着听起来太哲学的风险；火可以加热你的家。它也能烧伤你。

尽管如此，一些人认为禁止这项技术的开发和销售是负责任的做法，因为它有可能被滥用。

很自然，这就提出了一个问题:这项技术潜在的负面影响是否超过了潜在的正面影响，因此应该被禁止？

在我们看来，还没有。

原因如下

首先，拥有这种技术的公司有服务条款，客户必须遵守，否则将被取消使用。让我们都诚实地承认，我们大多数人都懒得去读这些，但我们已经“放弃”接触这些东西了。

第二，我们生活中的很多东西都是可以被滥用或者负面利用的。比如酒精。我们禁酒仅仅是因为一个人喝了太多酒吗？不。我们尝试了，基本上创造了(或者肯定增强了)暴民。

第三，最有可能让人们感到不舒服的行业和领域(如医疗保健、保险等)受到严格监管，因此严密的审查是对不当行为的一种自然、自我纠正的回击。

不，它不会停止偶尔的误用。同样，酒精也不是 100%安全的。就像酒精一样，滥用数据通常是违法的，会受到严厉的惩罚。举许多最近的例子，如剑桥分析，甚至脸书最近。

然而，对即将到来的厄运的恐惧可能会暂时平息。当涉及到滥用敏感的消费者数据时，更有可能是身份盗窃和网络欺诈，而不是建立一个杀手级的自我意识软件，这将迎来人工智能的末日。

这些绝不是“好东西”，但它们离 AI 终结文明还差得很远。

您的数据，您的责任

如果#10YearChallenge 或任何其他在线活动让你对你正在生成的数据感到不舒服，这是可以理解的。公司既有既得利益，也有义务合乎道德地使用你的数据；然而，它必须也就是你采取措施保护它。

虽然许多平台已经采取了某些隐私和安全措施来保护他们的用户，但仍然有许多方法可以访问您的数据。

你还记得那个谈论保险覆盖缺口的农民保险广告吗？“你可能认为你已经被保险了，但实际上你已经被保险了。”

当谈到在线数据保护时，人们想要什么，人们应该拥有什么，以及也许最重要的是:人们相信他们拥有什么之间可能会有很大的差异。

理想情况下，这三个要素应该是一致的。事实上，他们很少这样做。事实上，在消费者认为公司有义务对他们的数据做什么(或不做什么)之间存在巨大的分歧；以及实际发生的情况。

人类因即时满足而茁壮成长。社交媒体公司简单明了地利用了这一点。信不信由你；他们存在的唯一目的是为了广告的目的向公司出售你的信息。不是给你一个分享狗狗照片的平台。不管他/她有多可爱。

当您接受这些条款时(当然，没有阅读它们)，您明确地同意这种动态；当你使用这项服务的时候。

但这是邪恶的吗？

不太可能。我们可能不会因为使用脸书而迎来人工智能的末日。现在，理论上脸书会利用他们收集的大量数据造成很大伤害吗？是啊，当然。他们只是一般:

不一定会从中受益
难道真的想这么做吗
即使他们真的从中受益，与后果相比也是小巫见大巫。法庭诉讼、诉讼、股价暴跌、品牌信任的丧失、罚款和处罚、愤怒的顾客，不胜枚举

除了其他原因之外，这也是为什么当这些公司遭受暴露敏感客户信息的数据泄露时，这是一件大事。这些公司在获得你的信任、遵守监管准则、保护你的信息供自己使用而不是让它落入他人手中方面有既得利益。

现在，不要误解我们。诚然，大型科技公司并不总是完全提前或透明地知道他们在用你的数据做什么。即使在服务条款中有明确说明，他们也很清楚，我们大多数人都不会去读它，即使读了也不会完全理解。是的，那是故意的。

然而，他们的动机(无聊地)更符合资本主义(更有效地销售更多广告空间)，而不是威权的技术法西斯主义，即带来人工智能的启示。

所以一切都好吗？

如果说#10YearChallenge 有邪恶的一面，那更有可能是为了脸书自己的金钱收益(即用于产生更好的广告定位的人口统计排序的学习算法)，而不是建立天网。

如果在几百万的广告收入、销售收入和推出杀手机器人之间做出选择，脸书、谷歌、亚马逊和所有这些公司都会选择前者。

然而，关切和谨慎仍然存在。大型科技公司可能走上如此极端并利用如此先进的系统，这种想法本身就让一些人感到不安。他们确实能控制和访问数据，理论上说，如果数据落入坏人之手，可能会造成伤害

如果这让你担心，(一定程度的健康谨慎是正常的，甚至是谨慎的)，那么在网络世界里发帖、冲浪和互动，清醒地认识到你在网上采取的每个行动都有一定程度的风险。与此同时，您所使用的技术也是如此。

如果您的隐私对您至关重要，请采取额外的步骤来确保您在个人资料中的设置符合您的要求。

我们将何去何从？

下次出现# 10 年挑战时，你可以选择是否参加。如果您担心您的数据会发生什么，这是正常的。你可能想要抵制获得数百个赞和评论的冲动。锻炼你更高的自控力和成熟感，因为你知道你正在留下数字痕迹。

或者，如果你真的想参与，做我做的，贴一张你的狗的照片，一只胖乎乎的小狗，现在是一个灰头土脸的老人。

互联网除了吸引可爱狗狗的照片之外，什么都不是。

Say hi to Bruce.

原载于 2019 年 2 月 3 日introspectdata.com。

AWS 大数据认证值得吗？

原文：https://towardsdatascience.com/is-the-aws-big-data-certification-worth-it-ae1c4de340af?source=collection_archive---------15-----------------------

我花了 100 个小时和 560 美元找到答案。那要花很多时间和金钱，所以你应该看看。

Photo by Robert Anasch on Unsplash

TLDR；

作为一名数据科学家，AWS 大数据认证对我来说是值得的，因为我对数据科学需求层次的基础层有了更深入的了解。我学到的材料帮助我与同事更好地沟通，并使我成为一名更加灵活的数据专家。

使用下面的流程图，看看它是否适合您:

Flowcharts are great.

介绍

我在 Outcome Health 担任数据科学家已经两年了。我们已经做了一些有趣的工作，但是在我的整个任期内，我总是有一种挥之不去的感觉，那就是我对数据基础设施不够了解。

因此，几个月前，我连续近 100 天每天花一个小时学习 AWS 大数据认证。我的 AWS 大数据肌肉相当发达，我第一次就通过了认证考试！

但是这值得吗？

对于正在考虑该认证是否值得的数据科学家来说，这篇文章是为您准备的！

好处

了解数据科学的需求层次对任何数据科学家的工作都至关重要，因为它(1) 有助于您更好地与队友合作；以及(2) 使您能够更快地掌握其他工作职能。

From “The AI Hierarchy of Needs” by Monica Rogati

AWS 大数据认证有助于增强您对该层级较低层的了解，通常是数据工程师和数据库管理员介入的领域。

与队友交流

我所看到的认证前后的主要区别在于我与数据工程师和数据库管理员关于基础设施选择的对话。我经常与他们合作，与他们讨论利用什么服务曾经是非常片面的。他们会这样做:

“嘿，我需要做 XYZ。你知道我会用什么来做吗？”

“是啊，你可以用 ABC。”

“酷。”

“酷。”

现在，他们是这样的:

“嘿，我需要做 XYZ。我正试图在 ABC 和 DEF 之间做出选择。你会选哪个？”

“嗯。由于这些原因，我可能会选择 ABC”

“太好了！有道理。我会将该决定添加到系统文档中。”

这种额外的背景和理解大大提高了我为任何架构选择辩护的能力，并且知道我所构建的东西的局限性。

执行其他工作功能

我的学习也给了我设置考试中涉及的各种 AWS 服务的基本实践经验，这增强了我自己设置系统的信心。这不一定是数据科学家应该经常做的事情，但它可能会发生，尤其是在较小的公司中。

此外，了解数据工程师和数据库管理员经常使用什么工具(以及为什么)可以快速加快您的学习时间，如果您需要进入这些角色的话。

你得到认证了！

该证书在招聘过程中是否真的很重要，还有待讨论。没有争议的是，它是知识熟练程度的一个明确标志。通过认证并不容易，这表明您实际上可以就 AWS 大数据工具这一主题展开明智的对话。

同样，拥有一张写着你在某方面还过得去的纸感觉很好。

成本

正如我前面提到的，我花了 100 个小时来准备和通过考试。有面授课程，但它们都很贵，而且时间太短，难以产生深刻的效果。于是乎，我选择了自考的道路。

我花了 250 美元购买 ACloudGuru 的年度订阅费(我在该平台上学习了其他课程，所以这非常值得)，大概总共花了 10 美元的 AWS 费用。

测试本身要花费 300 美元。

总花费:~$560 + 100 小时

研究准备

纪律，学科

任何一种自学都是纪律的锻炼。我承诺在 100 天里每天早上花一个小时来学习这门课程。这意味着大多数晚上都要早点睡觉，这样我早上就有时间学习了。

如果你想知道此刻学习是什么感觉，你可以看看这个中等系列的我的每日进度日志！

顺便说一句，早起是我养成的提高工作效率的最重要的习惯。这是我所有其他习惯的基础。

当你早起时，你有时间呼吸、放松、思考、计划和做对你来说最重要的事情。

当你起床晚了，你就直接去上班/上学，这通常意味着你最好的时光被别人优先考虑的事情吃掉了。

是的，一开始很糟糕，但是最终，当其他人都还在睡觉的时候，完成重要的工作会让你感觉很棒。出人头地的快感会让人上瘾。

My literary foundation for great habits.

如果你需要一本关于习惯养成的好书，那么《原子习惯》可能是我读过的关于这个主题的最好的书。

如果你需要一本提供原始动力的好书，纪律等于自由是无与伦比的。

课程材料

ACloudGuru 的课程材料很有帮助，但绝对不够。我花了很多时间阅读 AWS 文档，探索 AWS 控制台，并尝试了提到的各种大数据服务。

这不是一个简单地通过学习材料就能通过的测试。你需要进入杂草中。你需要理解实现的基础，并且你需要至少有一点实际实现系统的实践。

通过实践保持

通过练习保持记忆有两个部分，它们有助于巩固我头脑中的材料。

首先，在我学习的过程中，与数据库管理员和数据工程师聊天有助于澄清令人困惑的材料。我怎么强调这有多大帮助都不为过。

这些人每天都在研究你所学的东西。他们理解细微差别，能够解释复杂的概念。与他们交谈，了解他们正在做什么，并提出相关的问题。

我还发现，数据基础设施往往是 DBA 和数据工程师愿意暂时谈论的少数话题之一。一般来说，他们不是最健谈的群体。

第二，做自己的小项目同样有帮助。这也是你如何向自己和他人证明你的技术水平。

我构建了一个“漫画追踪器”系统(我是个书呆子) ，它执行抓取漫画阅读网站的工作，并在新章节发布时向我发送通知。这个项目让我测试了几种服务:Lambda、SNS、DynamoDB 和 Serverless，等等。

Worth a read if you like Chinese history + strategy + action.

简单地让原型工作让我对自己从头开始构建的能力更有信心。此外，使用无服务器部署应用程序感觉很神奇。看到“基础设施即代码”以一种非常有形的方式发挥作用，真是令人惊讶。

结论

我已经尽力在这里解释了 AWS 大数据认证的好处、成本和潜在的学习途径。如果你需要一个非常具体的方法来决定它是否适合你，我在本文的开头写下了流程图:

您对数据科学需求层次的基础层的理解是否薄弱？(也就是说，你能胜任数据库管理员和数据工程师的基本工作吗？)

如果有，见下一题。
如果不是，你就是完整的软件包数据专家。对你有好处。

你有坚持每天自学一小时，坚持 100 天的纪律吗？

如果有，见下一题。
如果没有，面授可能是更好的选择。

你是否经常与数据工程师和数据库管理员一起工作，以便巩固你的知识？

如果是的话，这是一个完美的契合！如果你想走我走过的路，ACloudGuru 的 AWS 大数据认证课程是一个很好的起点！
如果没有，你仍然会学到很多东西，但是你需要建立自己的记忆保持项目。

我真的很喜欢学习这方面的内容(尽管清晨并不总是有趣)。我希望你和我一样享受你的旅程！

数据科学职业面临自动化的风险吗？

原文：https://towardsdatascience.com/is-the-data-science-profession-at-risk-of-automation-ae162b5f052f?source=collection_archive---------6-----------------------

Photo by Alex Knight from Pexels

质量预测真的可以按需生成吗？这对数据科学专业来说意味着什么？

前几天，我读了一篇关于优步如何将数据科学的力量赋予他们每一个员工的文章。下面这段话尤其让我印象深刻:

“预测平台的宏伟愿景是按下按钮提供预测。绝对不需要预测专家。用户需要的唯一输入是历史数据，无论是 CSV 文件形式还是查询链接，以及预测范围。你想预测多远？其他一切都是在引擎盖下完成的。”— Franziska Bell，优步的数据科学总监

这让我思考，预测真的可以商品化到这种程度吗？微软、谷歌和亚马逊也在努力让他们的机器学习解决方案对各自的云客户端更加“拖放”，所以优步肯定不是唯一有这种愿望的人。

贝尔的引用导致了两个相反的结论——要么优步的预测平台超级惊人，要么他们对预测未来的挑战过于漫不经心。为了好玩，我们来看一下每种可能性:

优步的预测平台令人惊叹——在只需输入目标变量的历史数据的情况下，优步必须能做什么才能按下按钮产生预测？他们必须能够:

掌握数据并知道是否包括任何及所有相关功能。你需要外生变量来建立一个模型，尤其是当你试图预测一些复杂的事情时。优步不仅必须在生成预测之前准备好所有可用的数据，还必须知道包括哪些功能以及如何转换每个功能。
它还必须能够比较和对比各种预测算法(线性回归、随机森林和神经网络)。并且能够为每个特定算法选择最佳超参数。
预测还必须经过回溯测试(以减轻当你从样本中取出模型时爆发的风险)，优步需要能够向用户传达模型所依赖的假设，以及在什么条件下它可能会崩溃。

这是很多事情要做的。如果他们能做到这一切，那就值得称赞。

但是如果优步太漫不经心怎么办——相反的观点是，预测平台只是一个 ARIMA 模型或 LSTM ，根据目标过去的观察预测未来。对于某些应用，这是可以的。

但只使用目标变量的滞后作为特征意味着可能会错过关键的外生关系，这将使模型严重不适合，并可能表现不佳。

Photo by monicore from Pexels

对此半信半疑

就我个人而言，我对优步的“预测即服务”目标持怀疑态度。如果优步允许其员工使用预先构建的模型“按需”预测某些关键业务指标，我可以理解，这些模型已经由他们的数据科学团队进行了广泛的研究和完善。但我不认为这是弗兰齐斯卡·贝尔的意思。看起来她的目标是只需按一下按钮，就能对几乎所有事情做出预测。

这是一个非常困难的问题，可能是一个不可能的问题。让我们浏览一下预测流程的每一步，以便更好地了解哪些可以轻松实现自动化，哪些不可以。

清楚地定义问题—需要预测什么？

没有要解决的问题，建立一个模型并利用它进行预测就没有多大意义。因此，第一步是找出我的问题是什么，我可以预测它的哪些方面以使问题更加清晰？

这通常没有乍看起来那么明显。既然我们从优步开始，让我们继续以它为例。假设我们是优步公司的分析师，我们的工作是预测明年旧金山优步的需求。我们能不能只给预测平台优步需求的历史时间序列就完事了？

大概不会。我是说，我们老板所说的需求是什么意思？可能是以下任何一种情况:

下一年的骑手数量。
下一年的总乘坐次数，即乘客数乘以每位乘客的乘坐次数。
下一年乘客支付的美元数，即乘客数乘以每位乘客的乘坐次数再乘以每位乘客的平均价格。

因此，我们到底需要预测什么还不清楚。当我们充实需求的定义时，你是否注意到我们需要预测更多的变量？

即使仅仅是乘客数量本身也是许多因素相互作用的结果:

可用司机的数量——司机的数量和乘客的数量相互影响，优步雇佣的司机越多，使用其平台的乘客就越多(这就是所谓的网络效应)。
竞争格局(Lyft、出租车、滑板车等。)随时间推移而变化。这包括竞争对手的数量、每个竞争对手的营销和定价策略等。

因此，看似简单的问题最终变得非常复杂，难以自动化。正如我们在上面看到的，合适的预测模型通常是多个独立模型和预测的集合。如果我们没有考虑足够的变量，我们的模型将会遗漏关键的影响。如果我们试图在我们的集合中包括太多的模型和/或预测，我们将迷失在复杂的迷宫中。

弄清楚要预测什么并不容易，作为负责充实模型各个组件的架构师，一名经验丰富的数据科学家可以发挥不可估量的作用，使模型在过于简单和过于复杂之间保持平衡。

识别有洞察力的数据(并找到它)

一旦我们确定了我们想要预测的变量，并为我们的模型集合绘制了一个简洁的流程图，我们就可以开始了，对吗？错，首先我们需要弄清楚我们是否拥有所有需要的数据。在最乐观的情况下，我们所有的数据都是可用的，干净的，并准备好放入数据库——但在现实世界中很少会这样。

一旦我们知道我们想要预测什么，那么我们需要决定我们将用来产生我们的预测的候选特征集。通常，这些数据并不容易获得，相反，数据科学家的工作是找出从哪里以及如何获得数据。而如果无法直接观察，那么如何用实际可用的东西来代理。

这一步也很难自动化。除非一家公司的数据湖像谷歌的一样广阔和深刻，否则他们将需要数据科学家来智能地和创造性地在世界上搜寻有洞察力的数据。

构建预测—特征工程和选择正确的算法

这可能是更容易自动化的部分。假设我们成功地获得并清理了所有的数据(这并不容易做到)，我们现在准备好构建模型了。

虽然我认为经验丰富的数据科学家或统计学家在选择正确的模型和正确设置其参数方面将是一个非常宝贵的专家，但我也意识到，在这里绝对有可能使用暴力的自动化方法。

你甚至可以说我们不需要运行和测试每一个模型来选择最好的一个。相反，我们可以假设使用 XGBoost 或神经网络将会给我们一个足够好的结果，只要它们经过适当的训练并且不会过度拟合。

此外，上述两种算法有效地自动化了特征工程过程。例如，给定足够的神经元和层，神经网络可以很容易地捕捉到我们的特征和目标之间的任何非线性效应。因此，没有必要显式地包含我们的特征之间的对数和指数或交互。

当然，这种自动化是要付出代价的。可解释性低——换句话说，我们不知道是什么推动了我们的预测。例如，在线性回归中，β系数 A 告诉我们特征 A 增加 1 个单位对我们预测的确切影响；在神经网络中，我们不知道增加特征 A 如何影响我们的预测。

在当今庞大而复杂的数据世界中，模型可解释性似乎是一个不错的选择，而不是必须的。但我认为，如果一个更简单、更易解释的模型并不会让你付出太多代价(就你预测的准确性而言)，那么保持它的简单是明智的。

Photo by Skitterphoto from Pexels

知道你的模型什么时候会崩溃

给予每个人预测的权力的一个被低估的风险是没有预测经验的人对无效或过度拟合的模型可能造成的破坏缺乏健康的尊重。

从行为上来说，当我们看到一个定量的精确预测时，我们会陷入一种虚假的安全感(我们被数字和数学的精确性所安慰)。但一个有经验的数据科学家会知道质疑模型的假设，并认识到在什么条件下模型可能表现不佳。

这是无法解释的模型的另一个缺点—

如果我们看不到推动我们预测的关键关系，就很难知道我们何时处于这些关系不再有效的环境中。

在我看来，这很难自动化。总会有一份工作适合那些既了解构建模型的好处又了解其风险的人。

结论

一切可以自动化的东西似乎最终都会自动化。因此，当数据科学和机器学习的某些方面在某个时候变得自动化时，我们不应该感到惊讶。相反，我们应该关注数据科学中难以自动化并且在可预见的未来将继续增值的方面:

了解您业务的关键驱动因素以及影响这些驱动因素的因素。
知道如何恰当地确定模型的范围和设计模型，使它既不太简单、不太合适，也不太复杂。
知道如何挖掘有洞察力的数据，这些数据可用于数据科学模型。
构建“足够好”的可解释模型。
能够识别在什么时候和什么情况下你的模型可能会崩溃并产生糟糕的预测。

当然，这些只是我的想法。我也很想听听你的。干杯！

更多数据科学与分析相关帖子由我:

拿到了数据科学的工作？

了解 PCA

了解随机森林

理解神经网络

了解 A/B 测试

趣味与二项分布

工作时间的不同是性别工资差距的真正原因吗？[互动信息图]

原文：https://towardsdatascience.com/is-the-difference-in-work-hours-the-real-reason-for-the-gender-wage-gap-interactive-infographic-6051dff3a041?source=collection_archive---------3-----------------------

劳工部每年都会发布一份关于男女薪酬差距的报告。

女性年收入的中位数是 30，000 美元，而男性是 40，000 美元。换句话说，职业女性的收入是男性的 75%。

但是这个差距没有考虑到这样一个事实，即平均而言，男性比女性工作的时间更长。根据美国人口普查数据，男性平均每周工作 41.0 小时，而女性平均每周工作 36.3 小时。

许多人认为性别歧视是收入差异的主要原因。其他人认为父母身份和性别角色通常比男性更能影响女性的收入。

为了更好地理解薪酬差距，我们根据婚姻和父母身份对受访者进行了分类【T4 2】。已婚夫妇与没有孩子的单身者之间的差距更大。对于已婚父母来说，差距更大。

Created with Visme

但是我们也发现已婚父亲比其他男人工作更多，而已婚母亲比没有孩子的已婚妇女工作更少。

我们分析了数百种美国职业的薪酬差距。根据我们的研究，在大多数职业中，薪酬差距的主要来源在于男女工作时间的差异，而婚姻状况和父母身份几乎可以解释所有这些工作时间的差异。

女性和男性的不同行为对性别工资差距产生了影响。正如我们将在下面看到的，谁在外面做大部分工作，谁呆在家里的决定在两个方面影响了薪酬差距:它改变了名义收入，但它也影响了男女每小时工作的收入。

探究跨职业的工资收入差异。 查看全屏版此处 。

几个具体的例子

让我们来看看美国最常见的职业:经理。这种职业代表了我们在美国看到的整体趋势。

没有孩子的单身男性经理的年薪中值为 6 万美元，而没有孩子的单身女性经理的年薪为 5.8 万美元。平均而言，单身男性经理每周工作 43.7 小时，而单身女性经理每周工作 42.3 小时。

这意味着男性每周多挣 3.4%，但多工作 3.5%。

但是当我们看已婚夫妇之间的收入差距时，我们看到了一幅不同的画面。女性和男性已婚经理的薪水确实更高。但是男人比女人挣得多。

没有孩子的已婚男性经理的平均收入为 9 万美元，而没有孩子的已婚女性经理的平均收入为 6.2 万美元。31%的工资差距。换句话说，男性挣 1 美元，女性挣 0.69 美元。

这种差距很大程度上可以用工作时间来解释。男人结婚后往往工作更多。男性每周平均工作时间增加了 4.3%，而女性每周工作时间保持不变。这是差距扩大的部分原因。

但是花在工作上的时间并不能解释所有的性别工资差距。没有孩子的已婚男性经理每小时的工资也更高:他们每小时挣 38.40 美元，而没有孩子的已婚女性只有 28.70 美元。这意味着，没有孩子的已婚男性经理每工作一小时，收入比女性多 34%。正如我们将在下面详细看到的，不同的时薪与就业市场趋势有关。

我们可以在学校教师、秘书、护士、客户服务代表和许多其他职业中看到相同的模式:没有孩子的单身人士的薪酬差距较小，已婚人士的薪酬差距较大。

总体趋势的例外

我们已经看到，对于最常见的职业，没有孩子的单身人士几乎没有绝对的薪酬差距，这种差距可以用工作时间的差异来解释。但是有一些职业确实显示了这部分人的差距。

值得注意的例子是司机、零售销售员、主管和看门人。有趣的是，我们可以在这些职业中看到相同的一般模式:对于已婚夫妇来说，不受控制的差距急剧增加，即使他们没有孩子。

Created with Visme

同样的一般模式在没有孩子的单身女性比男性同事挣得多的职业中重复出现。他们中的一些人是秘书、客户服务代表、厨师、库存职员、办公室职员和接待员。

在所有这些职业中，如果女性结婚，薪酬差距就会逆转，男性仍然比女性挣得多。

年龄和经历呢？

值得注意的是，年龄和工作经验也是性别差距辩论中的相关因素。为了区分年龄和工作经验对不同群体薪酬差距的可能影响，我们绘制了单身女性和无子女男性每个年龄的加权平均工作时间。

Created with Visme

对于没有孩子的单身人士来说，每个年龄段的差距都很小。但是对于已婚夫妇来说，每个年龄段的工作时间都有明显的差距。

如果我们考虑到随着男女年龄的增长，时薪的变化，男性时薪的增长要比女性时薪多。在所有三组中都可以看到相同的模式。

上面的图表表明，工作经验与这些年的工作时间相关。随着时间的推移，男人比女人积累了更多的实践和训练。如果工人有更多的经验，就业市场的报酬会更高。换句话说，随着男性比女性获得更多的经验，差距会越来越大。

那么性别工资差距的真正原因是什么呢？

在这篇文章中，我们发现性别薪酬差距的主要来源之一是，平均而言，女性和男性在工作上投入的时间不同，尤其是在结婚和为人父母之后。

关于性别薪酬差距的文献非常广泛。不同的论文侧重于不同的原因来解释它。提到最多的两个原因是性别歧视和母性和性别角色。

如果做同样的工作，一个女人得到的报酬比一个男人少，那就是对妇女的性别歧视。

如果我们认为工作时间的长短决定了我们是否认为一份工作和另一份工作是一样的，那么这些数据在总体上并不支持性别歧视的观点。

已婚妇女的时薪比已婚男子的平均时薪低，但一个可能的解释是，如果工作时间减少，就业市场的时薪就会减少，而且已婚妇女往往工作得更少。几乎在每个职业中都可以看到同样的模式。

此外，男性倾向于投入更多的时间工作，因此随着时间的推移获得更多的经验，如果工人有更多的经验，就业市场支付更多。

这并不意味着性别歧视不存在。我们的分析表明，总体而言，大部分差距不是由性别歧视造成的。

关于薪酬差距的第二个方面，关于性别角色的社会观念影响着女性和男性的行为。此外，与父母身份相关的生物因素确实在偏好差异的产生中发挥了作用。即女性怀孕，女性哺乳。性别之间的这些差异可能是为什么女性比夫妻更倾向于呆在家里的合理解释，尤其是在结婚生子之后。

综上所述，我们可以说，根据我们的分析，与婚姻状况和父母身份相关的就业市场力量和性别偏好可以解释几乎所有的薪酬差距。大部分差距并不是性别歧视的结果。

方法学

这项分析使用了美国人口普查局 2017 年美国社区调查(ACS)的微观数据，这些数据是通过 IPUMS 美国服务 7 提取的。

小时平均工资是我们自己使用税前工资和薪金总收入以及被调查者通常每周工作的小时数计算出来的。

我们还从我们的数据库中删除了一小部分我们认为不具有代表性的受访者，即时薪高于每小时 900 美元且低于每小时 3 美元的人。

此外，为了分离出年龄较大时男女之间的显著差异可能造成的影响，我们只考虑了年龄小于 70 岁的人。

我们使用 Python 和 R 来聚合和处理数据。最终的数字是广泛的研究过程和各种测试的结果。如果您遇到错误或失误，请不要犹豫，与我们联系。

笔记

税前工资和薪金收入中位数。只有 70 岁以下的工人。没有过滤掉任何异常值，对于本文的其余部分，我们过滤掉了我们认为不正常和不具有代表性的案例。更多信息参见方法部分。

2.为了分离父母身份和婚姻状况的影响，我们只考虑了三组人:未婚无子女、已婚无子女和已婚有子女。进一步的研究也可以考虑更多的类别，比如单亲父母。

3.尽管受到社会学方面和性别角色的影响，但夫妻双方可以商定不同的选择和自愿决定。

4.为了计算时薪，我们使用了受访者通常每周工作的平均小时数。

5.还是有利于女性的小差距。

6.此外，这里没有画出，随着男女年龄的增长，工作时间的差异略有增加。

7.尽管受到社会因素和性别角色的影响，这些可以是夫妻双方同意和自愿做出的决定。

8.史蒂文·拉格斯、萨拉·弗勒德、罗纳德·戈肯、约西亚·格罗弗、艾琳·迈耶、何塞·帕卡斯和马修·索贝克。美国 IPUMS:版本 8.0[数据集]。明尼苏达州明尼阿波利斯市:IPUMS，2018 年。https://doi.org/10.18128/D010.V8.0

本帖原版 最早出现在 Visme 的 视觉学习中心 。

数据科学家的工作有被自动化的风险吗？

原文：https://towardsdatascience.com/is-the-job-of-data-scientist-at-risk-of-being-automated-60583e96670f?source=collection_archive---------5-----------------------

Source

一个有用的测试，用于确定你的工作是否可以由一台应用于数据科学家的机器来完成

阿玛拉定律指出，我们倾向于高估一项技术的短期效果，但低估其长期效果。我们看到这一幕在从火车到互联网到现在的机器学习的各种技术中反复上演。趋势几乎总是相同的:最初，对创新能力的极度乐观的断言之后是一段幻灭期，当它无法交付时，最终，我们知道如何使用技术，它继续从根本上重塑我们的整个世界(这被称为炒作周期)。

阿马拉定律的基本思想——比声称的更小的短期影响，但比想象的更大的长期影响——也可以在技术对人类工作的总体影响中反复看到。19 世纪 30 年代发明的第一台钢犁并没有立即取代所有的农民，但是从 1850 年到现代，美国从事农业工作的人口比例从 50%上升到 2%。(通过一系列的创新，而不仅仅是机械技术，现在更少的人生产出了更多的食物。)

同样，美国制造业的就业岗位从占总就业岗位的 40%下降到不到 10%，这不是一两年的事，而是几十年的事(通过自动化和外包的结合)。我们再次看到在几年的过程中出现了小波动，但在足够长的时间内经济出现了根本性的重组。此外，必须指出的是人们总是能找到其他工作。今天，我们的失业率达到了 50 年来的最低水平，因为当一些工作实现自动化时，人们就会转向新的工作。我们不断发明新的职业来满足我们的需求，包括整个服务经济(自从农业和制造业衰落以来，它雇佣了大多数美国人)，或者在个人层面上，数据科学家的角色，直到 2012 年才得到广泛认可。

当我们思考自动化在当今时代的影响时，值得记住这两点——变化需要时间，我们总是会为人类发明新的工作。人们很容易被声称“近一半的工作易受自动化影响”的报告冲昏头脑，这似乎暗示我们应该关注几年内大量失业的工人。

Nothing gets more clicks than fear! (Source)

从阿玛拉定律的角度来看，我认为这项研究低估了由机器完成的工作的百分比:我们 99%的工作会因为新技术而被淘汰，但是只有在足够长的时间内才会被淘汰。随着我们的工作逐渐自动化，我们将简单地向前移动到下一个，可能是一个尚未被发明的职业。

从短期来看，技术的影响被夸大了，但从长期来看却被低估了，包括技术对就业市场的影响。

话虽如此，思考哪些工作可能在短期内实现自动化以及原因仍然很有趣，因此我们可以专注于学习人类增加最大价值的技能。在他的优秀著作《第四时代:智能机器人、有意识的计算机和人类的未来》中，拜伦·里斯展示了自动化高风险工作的特点。这些是:

重复:无论是身体上还是精神上
创造力低:不需要即兴创作和新颖的思维方式
社交智商低:不需要沟通、说服或魅力
有限的培训:自动化工作的容易程度与完整描述该工作的“手册”的长度成反比

除了详细描述这些特征之外，Reese 还概述了一个确定工作“自动化风险”的便捷工具。以下 10 个问题并不能保证一份工作会不会自动化，但它们确实提供了一个框架来量化对大多数人来说通常是情绪化的问题:“机器人会取代我的工作吗？”(答案是大多数人认为机器不会抢走他们的工作，而是会抢走其他人的工作。

测试

我将浏览这些问题，并根据我作为一名数据科学家所学到的知识来回答它们。这并不意味着是对整个领域的客观分析——每个职位都是不同的，所以不同意也没关系。作为背景，我在数据科学领域工作了 2 年:1 年从事研究生研究项目，2 个月在普惠公司担任数据分析师实习生，4 个月在 Feature Labs 担任数据科学家，6 个月在 Cortex Building Intelligence 担任全职数据科学家。我主要是根据我目前在 Cortex 的工作来回答这些问题，在那里，我们使用大数据和机器学习来提高商业办公楼的能效(证明你可以同时对环境和经济产生积极影响)。我们是一家小型创业公司(大约 10 人)，我既没有管理任何员工，也没有正式的经理，尽管我与一名高级软件工程师密切合作。

这项测试的满分是 100 分，分数越高表明自动化的脆弱性越大。(这个测试出现在这本书的第 10 章，但是我鼓励你阅读整本书。您也可以自己在线参加考试f；为了清楚起见，我重新表述了一些问题)。

你工作中的两天有多相似？(0:完全没有，10:非常相似)

4 / 10 。虽然编写代码有时会感觉公式化，但作为数据科学家的工作不仅仅是构建机器学习模型。有些日子我可能会花时间重构代码(我很乐意将这种事情交给机器)，有些日子我会为客户进行一次性数据分析，有些日子我不得不去一栋大楼调整一些有故障的传感器，以获得可靠的数据。(哦，你以为所有的数据都整齐地打包在一个干净的 csv 文件中，然后手工提交？好吧，欢迎来到现实世界，在这里获取数据意味着在一栋办公楼的地下室里爬来爬去重新连接一个电表)。简而言之，日复一日的相似性很低，这使得这项工作令人兴奋，也不容易被机器接管。

2。在工作中，您多久需要移动一次物理位置？(0:从不，10:一直)

6 / 10。对于大多数数据科学家/软件工程师来说，我想这个答案更重要，因为你每天都在同一间办公室的同一张桌子上工作。就我的角色而言，我确实在一张办公桌前花了很多时间，但我也会去纽约市周围的不同建筑。(同样，没有数据就无法进行数据科学，而获取数据需要付出巨大的努力。)此外，我在纽约的办公室和 DC 华盛顿的总部之间来回奔波，因为说到底，面对面的交流是最有效的。

3。有多少人知道或做你的工作？(0:几乎没有，10:很多)

5 / 10 。当你在一个领域工作时，很容易陷入过滤泡沫，你认为你的工作非常重要，因此每个人都必须知道。就像我在数据科学中发现的那样，即使与该领域之外的人进行几次简短的交谈，也会打消你的这种想法。在技术领域之外，很少有人听说过“数据科学家”这个术语，更不用说知道一个人是做什么的了。我求助于说我分析数据，如果这不能让人们理解，我会提到一些关于计算机和电子表格的东西。总的来说，工作越专业化(意味着越少的工人在做)，自动化的可能性就越小，因为投资资源来建造一台能够完成这项工作的机器的动力就越小。

4。你的工作培训有多长时间？(0:年，10:天)

0 / 10。数据科学的培训非常广泛，你不可能在为期 6 周甚至 12 周的训练营中学到所有知识。虽然我不认为四年制学位是成功的必要条件，但你需要长时间的学习，积累解决实际问题的经验，才能成为一名有效的工业数据科学家。此外，这份工作需要不断学习，总是在寻找新的工具和更好的方法来解决你的问题。任何教授数据科学的机器都需要每 6 个月进行一次“智力升级”以保持最新。

5。你的工作需要重复的体力活动吗？(0:完全没有，10:完全没有)

****8 / 10。我的答案可能再次低于大多数其他数据科学家，因为我必须帮助在建筑物中集成我们的技术。这是一个我们在机器旁边没有机会的领域；计算机绝对擅长重复做同样的事情数百万次而不出错。如果我们能告诉电脑正确的键，我们马上就失业了。

6。你做决定需要的最长时间是多少？(0:超过 5 分钟，10:几秒)

0 / 10 Reese(测试的作者)将这个问题的最长时间设定为 5 分钟，这似乎太短了。我们在 Cortex 做出的一些决定需要花数周时间仔细研究结果，并经过公司各级员工的深思熟虑。几乎我们的决策不仅涉及定量指标(数字)，还涉及定性度量(我们能向客户解释这一点吗，这些特性是人类可以理解的吗)。我们构建的数据科学解决方案不仅仅取决于误差最低的解决方案，而是通过考虑许多不同需求的合理决策来确定的。

7。你的工作需要与其他人建立情感联系吗？(0:绝对必要，10:完全没有必要)

5 / 10。如果你认为你可以通过成为数据科学家来逃避人们，那么对不起，你选择了错误的职业。在一家公司成功工作需要不断的沟通:在一个典型的日子里，我可能会与客户、首席执行官、销售团队和客户成功团队交谈，他们都对不同的方法反应最好(定量与定性、自信与开放式)。这还没有考虑到我与其他工程师的对话，包括代码审查、查看模型输出、开发新的问题解决方案、讨论代码风格等等。简而言之，如果你打算在任何一家公司工作，都要磨练你的沟通技巧。

8。你的工作需要创造力吗？(0:工作的全部基础，10:创造性被积极阻止)

****4 / 10。也许我是夸大了我认为数据科学中的创造力，但我们不断面临无法用同样的方法解决的新问题，这意味着我们需要“以不同的方式思考”。如果我们认为创造力包括使用许多不同工具的能力，那么数据科学必须排在前列。我希望有解决数据科学问题的最佳实践，但无论如何，事实并非如此。因此，我的工作需要尝试各种方法来解决每一个问题，如果现有的方法都行不通，有时还需要开发自己的方法。

9。你直接管理员工吗？(0:多，10:无)

****10 / 10。作为个人贡献者，我不直接管理任何员工。尽管如此，对于数据科学家来说，管理当然不是不可能的。

10。其他人会以同样的方式做你的工作吗？(0:完全不一样，10:完全一样)

4 / 10 。在数据科学的发展过程中，答案是否定的。解决数据科学问题的方法太多了，两个人无法使用同一种方法。我有机会重新实现几年前构建的建模管道，每次我都惊讶于现在使用最新的工具编写代码是多么容易。除了工具之外，基本方法也可能不同:使用具有广泛特征工程的简单模型，或者限制特征并使用复杂模型。最终，数据科学领域可能会在一些方法上崩溃，但即使到了那个时候，在做这项工作时，仍然会有足够的个人细微差别的空间。

数据科学对自动化的总体脆弱性:46 / 100

根据里斯的说法，任何低于 70 岁的工作在整个职业生涯中都是安全的。虽然我认为数据科学在短期内没有被自动化的风险(对试图向你出售自动化数据科学工具的公司保持怀疑)，但我对十年后“数据科学家”的角色是否仍然存在没有信心。

相反，我认为数据科学工具将继续变得更容易使用，直到非专业人士能够有效地使用它们。到那时，数据科学将是一项基本技能，但不仅限于少数专家，我们不需要任何受过数据科学专门培训的人。我对这一次充满希望，因为我一再看到领域专业知识对于构建有效的数据科学管道的重要性。如果我们能够将正确的工具交到在某个领域有经验的人手中，那么数据科学就可以实现其提高效率和支持客观决策的承诺。总之，自动化不太可能取代数据科学的工作，但如果开发了正确的工具，数据科学家可能会成为一个无关的专业。

如果不是自动化，那我们该担心什么？

数据科学面临着比机器人抢走我们工作的幽灵更现实的问题。这值得更深入的研究，但现在，开始思考我们如何解决这些问题:

****言过其实和言过其实:数据科学实际能做的和媒体描述的之间有很大差距。数据科学并不是解决每个问题的灵丹妙药，在生产中部署机器学习模型(我们在 Cortex 每天做数百次)需要正确数据和利用它的专业知识的极其罕见的结合。事实上，对公司来说，最大的价值在于可视化当前隐藏在电子表格中的数据(或者用小 Python 自动完成简单的电子表格任务)。大多数公司不具备深度学习的能力或需求。避免炒作列车或风险失去信任时，你不能交付。
****算法偏差:任何接受数据科学家培训的人都应该被要求阅读凯茜·奥尼尔的 数学毁灭武器。总结一下这篇非同寻常的文章，当算法根据有偏差的数据进行训练时，它们会强化和放大现有的偏差。开发模型的人类甚至不必因为现有的不平等在机器学习的支持下永久存在而对自己抱有偏见。数据科学承诺是客观的，但数据收集或分析没有任何客观性。如果我们希望数据科学惠及尽可能多的人，那么我们需要开始思考如何消除我们模型中的偏见，包括欢迎和支持更加多样化的贡献者群体。
****无法重现的结果。进行一次性分析并在学术论文中展示一项发现很容易，但要获得即使在同一台机器上对相同数据也能重复再现的结果却困难得多！这个问题终于开始得到一些关注，我希望更广泛的科学再现性问题能够带来新的工具或方法。缺乏可重复的结果会导致对数据科学方法的信任度下降:如果你某一天告诉你的客户一个数字，而在稍后的时间里告诉他们一个完全不同的数字来获得相同的结果，他们为什么要依赖你的预测呢？
****摇摇欲坠的数据科学基础设施:使用开源数据科学工具的人比以往任何时候都多(想想 Python、numpy、scikit-learn、pandas、matplotlib、scipy、pymc3)，但贡献者和维护者的数量却没有相应增长。自由和开源软件是伟大的，但是对于贡献者来说，当他们在全职工作之外自愿做这些工具时，维护这些工具是很困难的。贡献的方式有很多种，从提交 bug 到修复问题到简单的捐款(现在就去这里如果你想帮忙，就成为 NumFocus 的经常性捐助者)，我们需要开始支持我们领域所立足的基础。不幸的是，这是一个没有得到太多关注的关键问题，我以前写过这个话题因为它很重要。

除了以上这些，我还担心正规教育系统没有培养出有效的数据科学家。由于学生接受了专门的数据科学培训，可能会有许多数据科学家能够编写出高超的 Jupyter 笔记本，但不知道如何将机器学习模型投入生产。在 Jupyter 笔记本上的干净数据集上获得一次结果与每天在真实数据上运行数百次模型并将结果提供给客户之间存在巨大差距。我不知道在大学环境中，目前的课程是否能弥补这个差距。****

最后一点，在 Cortex，我们从未被数据科学所能构建的功能所限制——这些技术本身很容易用开源工具来实现——而是被获取数据、清理数据、当前格式化数据、运行模型以及向客户提供这些预测(以及解释)所需的复杂性所限制。我的建议是，除了传统的数据科学统计和编程课程之外，花一些时间认真学习软件工程和数据工程。

虽然“数据科学家”的角色可能不会持续太久——不是因为自动化，而是因为更易于使用的工具——但在数据科学中学习的技能只会变得更加相关。不管是好是坏，我们生活在一个数据饱和、技术驱动的世界，理解数据并操纵技术为你服务(而不是相反)的能力至关重要。如果你现在是一名数据科学家，继续应用这些技能并学习新的技能。对于那些学习进入该领域的人来说，要认识到你不一定是在为“数据科学家”的职位做准备，而是在为一个数据科学技能将变得越来越受重视的世界做准备。

我写一些关于数据科学的文章，偶尔也会写一些其他有趣的话题。你可以通过推特 @koehrsen_will 联系我。如果帮助环境和的底线吸引你，那么也许可以联系我们 Cortex。

市场最终准备好大规模采用人工智能了吗？

原文：https://towardsdatascience.com/is-the-market-finally-ready-for-mass-ai-adoption-300d4417cc24?source=collection_archive---------37-----------------------

来自 VentureBeat Transform 的五个啊哈时刻

Greg Brockman, Co-founder & Chairman and Ilya Sutskever, Co-founder & Chief Scientist, OpenAI; Kyle Wiggers, Staff Writer, VentureBeat

我刚刚从旧金山的 Venture Beat Transform 2019 大会回来，我不得不说，多年来第一次，我开始感觉到这个行业终于开始变得。

我具体说的是什么？嗯，传统上我总是对的，这一次，我对市场在采用机器学习方面可能遇到的挑战的看法令人难以置信地正确。看看这些优秀的博客帖子；

机器学习有时是错误的——你如何处理这一点才是最重要的
一个有趣的子编辑如何帮助解释机器学习
集成 AI？这里有三个你将要遇到的问题。
什么机器学习不是

我真的觉得这次会议上的每个人都读过这些帖子，并向观众报告了他们所了解到的一切。当然，这正是没有发生的事情。

帮助人类做出更好的决定

Maribel Lopez, Founder & Principal Analyst, Lopez Research; Bill Groves, Chief Data Officer, Walmart; Josh Patterson, GM of Data Science, NVIDIA

几千年来，我第一次参加了一个人工智能会议，会上有人在台上谈论立即采用机器学习。所以最后，我认为市场，作为一个整体，真的开始理解价值在哪里，以及为什么机器学习可以是这样一种令人惊叹的技术。

在会议上，一家公司谈论他们所做的一切是如何帮助人类做出更好的决定，这让我大吃一惊。不要胡说什么 100%全自动化，或者用比我们更好的模型取代人类的认知…只是一个关于简单的机器学习驱动的解决方案的炉边聊天，让人类做出更好的决定。

这个就是机器学习唯一适合做的事情。它可以挖掘数十亿比特的数据，只显示重要的内容，它可以预测何时何地会出现问题，供人类审查，它可以让我们专注于做人类独特的事情。微软的 CTO 在此后不久表示“专注非常重要”。是的，它是我的好先生，是的，它是。

嵌入人类

在这项有些新的技术中，数据科学家作为我们的向导和领导者仍然占据着至高无上的地位。我敢肯定，我们都希望自己能成为专家，但今天机器学习最有价值的一个方面是你能在多大程度上用数据集解决问题。盖普、脸书和优步都发表了关于他们如何成功地将机器学习集成到他们的堆栈中的演讲，毫无疑问，他们有一些共同点。

这些企业成功部署人工智能的最有趣的共同点是将数据科学家嵌入到整个组织的不同团队中。这些勇敢的男男女女花了大部分时间倾听。“人们遇到了什么问题？”他们会问自己。只有在与他们的同事坐在一起并了解问题后，他们才会推荐 ML-powered 解决方案。这就是他们如何在组织内实现人工智能采用的规模。一家主要的云供应商(可能是 AWS)告诉脸书的某个人，他们内部使用的人工智能比所有使用他们人工智能服务的客户的总和还要多。

这很关键。在尝试实现技术之前，必须考虑一个问题。“让我们用人工智能做点什么”是行不通的。这就像说“让我们用电做点什么”或“互联网”。

不准确和不确定性

会议中我最喜欢的部分是计算机视觉跟踪中的一个面板，它是关于皇家加勒比游轮公司在餐馆中计算人数的用例。如果只有两件事加在一起会让我暴跳如雷，那就是的队伍和的餐馆。因为拥挤，等待食物是我对地狱的理解。

因为其中一家餐厅已经客满就把我引到另一家餐厅，这肯定会阻止我在皇家加勒比游轮上策划一场叛变。嗯……这正是他们所做的，但是他们是用计算机视觉做的！

他们的目标是使用餐厅闭路电视摄像头的摄像头反馈来计算在场的人数，并将这些信息传递给一个应用程序，该应用程序会为顾客重新安排路线。但是他们遇到了一个问题。训练计算机视觉模型从鱼眼安全摄像头流中计数是每个机器学习工程师最糟糕的噩梦。

我举手问他们为什么不使用安装在更好地方的不同的摄像机，答案让我吃惊。新的摄像机必须通过海事认证，并在船停靠在干船坞时安装，这比仅仅在一些可怕的鱼眼视频上训练 YOLO 要昂贵得多。

在鱼眼视频摄像头上训练人员计数器并没有产生一个可以超级准确地了解餐馆人数的模型。幸运的是，他们意识到区分 100-115 个人没有商业价值。他们真正需要知道的是一个人数范围，以确定空间有多满。所以他们不担心返回一个完全准确的数字。

EXCELCIOR！这正是如何实现机器学习。

故障模型

Khari Johnson, Senior Staff Writer, VentureBeat; Hilary Mason, GM Machine Learning, Cloudera

Cloudera 机器学习总经理希拉里·梅森(Hilary Mason)列出了企业在实施人工智能时可能会遇到的几种失败模式。排在首位的是不切实际的期望。啊，好不切实际的期望，每当我照镜子或写博客时都会想起它。但这也是我在人工智能行业多年来一直在专业战斗的事情。

在同一次炉边谈话中，有人在台上提到，围绕机器学习的媒体炒作是有问题的，因为它没有关注某样东西是否有用。早在 2018 年初，我就写了一篇关于的令人难以置信的文章，因为即使在那时，错配预期的趋势也在全面展开。所以，再次看到其他人鹦鹉学舌般地反驳我所认为的成功大规模采用人工智能的根本障碍，这是一种美妙的解脱。

这里有一个例子来说明它是如何发生的，更重要的是，你可以如何解决它。

当语音到文本第一次成为一种 API 服务时，我看到销售人员去广播公司推销它，作为人类创作隐藏字幕的替代方案。当客户实际通过这些系统运行他们的内容时，结果只有大约 80%的准确性… 如果他们幸运的话。作为隐藏式字幕的替代方案，语音转文本失败了。

当我看到这种情况发生时，我抓住销售团队，将他们带到一个房间，并演示了语音到文本如何生成大量可搜索的术语(例如人、地点和事物)，这些术语为内容经理和存档提供了大量价值。然后，销售团队开始讨论解决可搜索性问题，这时候我们开始看到成功。

我们不应该到处寻找用机器学习来解决的问题，我们需要从问题开始，看看机器学习如何增加价值。

谁拥有未来？

希拉里·梅森还提醒我们，开发人员习惯于与确定性系统进行交互。如果我把 2+2 放进一个计算器，4 应该总是出来。但是在机器学习中，你第一次把 2+2 放到一个系统中，答案可能是错误的。开发者需要开始习惯学习的系统，用误差棒返回概率的系统。

开发人员广泛使用机器学习将会看到该技术的更大市场采用，但真正的奇迹将会发生在一旦它通过开发人员的世界，并达到产品的水平。只有产品经理了解业务和市场，并且在理论上，能够在技术和企业购买者之间建立桥梁。他们知道客户真正需要什么，而不是开发人员、数据科学家、销售人员或其他任何人。

然而，机器学习的诀窍是克服进入的技术障碍。让开发人员和产品经理能够开发、实现和扩展有用的机器学习的工具正在我们说话的时候进入市场。随着这些能力在正确的位置上渗透到正确的人的头脑中，我们将看到我们都被承诺的人工智能的大规模采用。

出版偏见正在塑造我们对人工智能的看法

原文：https://towardsdatascience.com/is-the-medias-reluctance-to-admit-ai-s-weaknesses-putting-us-at-risk-c355728e9028?source=collection_archive---------18-----------------------

Photo: Pietro Jeng via Unsplash

媒体不愿意承认 AI 的弱点是不是让我们处于危险之中？

机器学习最近引起了人们极大的兴趣，这种兴趣正在蔓延到以各种方式影响我们生活的技术。

从推荐我们应该在 Youtube 上观看哪个视频的算法，到有一天可能为我们驾驶汽车的算法，我们看到决策权越来越多地委托给机器。这开启了一些伟大的可能性——在网上发现符合我们兴趣的新内容，无人驾驶汽车让我们放松或赶完一些工作，同时带我们去我们需要去的地方。

不幸的是，它也为事情以意想不到的方式出错打开了空间。例如，Youtube 的推荐算法已经了解到，让用户留在网站上的最佳方式是向他们提供更离谱和更极化的内容，无人驾驶汽车可能会在看似平凡的设置中撞车( 并杀死 )。

当机器被留下来自学如何很好地执行一项功能时，它们可以找到解决这个问题的方法，这是我们自然不会预料到的。

检测皮肤癌

在他的书深度医学中，埃里克·托普描述了机器学习的一些主要进展，这些进展指向了我们在机器决策方面不可避免的未来。

他描述的一个例子是 2017 年在 Nature 上发表的一篇里程碑式的论文。这篇论文描述了一个经过训练的深度神经网络，用于诊断皮肤癌，其准确性与 21 名经委员会认证的皮肤科医生相当。

这篇论文包括了一些关键的例子，这些例子突出了用来进行预测的图像部分。这些看起来都很合理，算法的大部分焦点都放在皮肤损伤本身。总体而言，这篇论文看起来非常令人印象深刻，自 2017 年发表以来，它已经被引用了 1000 多次。

A sample of images of malignant cancers used for training and testing the algorithm — available from www.isic-archive.com

但是，在论文发表后，这项研究的作者注意到他们的算法中有一个偏差——如果图像中有一把尺子，更有可能将图像标记为恶性癌症。皮肤科医生经常使用尺子来测量照片中皮肤病变的大小，如果他们特别关注它的话，所以带尺子的照片更有可能是癌性的。

A sample of images of benign lesions used for training and testing the algorithm — available from www.isic-archive.com

这种偏见有多重要？

如果算法有时依赖于统治者来做出诊断，这是值得担心的吗？

这种偏倚的重要性取决于它影响多少样本，以及这种误差如何在患者中分布。如果每 1000 名患者出现一个随机误差，并且没有更准确的方法，这通常被认为是一个可接受的误差率。但是，如果发生了高比率的错误，或者错误严重影响了特定的患者群体，这在伦理上更令人担忧。

例如，如果一家诊所决定在他们的照片中总是包含尺子，该算法将始终过度预测去该诊所的患者的癌症。这可能导致生活在该地区的患者出现系统性的不利情况。此外，如果皮肤科医生因为完全依赖这种算法而决定取消尺子，算法的准确性可能会下降。

事实上，在将病变分为九个主要临床类别时，深度神经网络的准确率为 55.4%，而两位皮肤科医生的准确率分别为 55.0%和 53.3%。即使尺子对准确性的影响非常小，这也很容易使天平向有利于皮肤科医生的方向倾斜。

过分承诺

另一个问题是，作者认为，有了这样的算法，人们甚至可以不必再去看皮肤科医生了——他们可以用智能手机拍下一颗可疑的痣，然后看看是否有什么值得担心的。这在概念上是一个伟大的想法——它将使获得专家医疗保健的途径民主化，并使定期检查更加容易。

“这种快速、可扩展的方法可在移动设备上部署，并有可能产生重大的临床影响，包括扩大初级保健实践的范围，并增加皮肤科专家的临床决策。”
— 原创自然论文

My attempt at photographing one of my moles with an iPhone SE camera 😦

问题是，虽然这是该论文的一个主要主张，但智能手机照片并没有经过该算法的测试。人们为自己的皮肤拍摄的照片类型可能在光线、照片质量、缩放和许多其他因素方面与皮肤科医生不同，这使得该算法超出了其原始训练条件。我们知道，当机器学习算法获得的数据与它们被训练的数据不同时，它们的行为可能不可预测。

我的手机在捕捉痣的特写镜头方面做得很糟糕，这表明你需要一部更新、更贵的手机来实现这个功能。这意味着使用该算法降低的成本将只适用于那些买得起带漂亮摄像头的新手机的人。

此外，论文中显示的病变照片在肤色上非常相似。对用智能手机测试人工智能检测皮肤癌的人的采访表明，肤色的变化是算法需要训练处理的一个主要因素，此外还有一些简单的因素，如某人的手臂有多多毛。

出版偏差

该算法对统治者的依赖在最初的《自然》杂志论文中没有涉及——这种实现在近一年后首次出现在媒体上。

当你查找关于“皮肤癌”、“神经网络”/“机器学习”和“统治者”的文章时，你会得到 10 篇新闻文章，其中 4 篇涉及该算法中发现的偏差，其中约有 4500 篇文章描述了用于检测皮肤癌的神经网络/机器学习算法。似乎人们听到令人印象深刻的新结果比听到这些大肆宣传的算法的失败更兴奋。

这是出版偏见的一个经典问题，成功被愉快地发表，但负面结果被期刊和新闻媒体拒绝，通常不会被公之于众。在 2019 年 3 月出版的 Deep Medicine 中，该算法仍被用作人工智能改变我们行医方式的令人印象深刻的力量的一个例子，这一事实表明，关于这些算法局限性的信息是多么难以渗透大众观点。

托普在他的书中专门用了一个章节来讨论人工智能的缺点，并提到了其他没有达到宣传效果的算法，但却忽略了这个算法的局限性。由于这些算法缺乏透明度，在弱点变得清晰之前，可能需要时间和更多样化的测试。因此，一旦这些算法不再是头条新闻，就很难保持对它们的理解。

该不该让 AI 演医生？

虽然人工智能在医疗保健领域取得了稳步进展，但正在发布的算法可以用来在没有独立测试和几乎不了解他们如何做出预测的情况下做出诊断决策。没有什么动机去公布一个算法的弱点，而且相关方通常也没有能力进行自己的测试。

这让患者和临床医生等利益相关者不得不相信算法创造者的话是可靠的。随着意外算法偏差和弱点的证据越来越多，这可能会成为消费者的一个不舒服的位置。

要求更大程度的开放应该会改善这种状况。这篇论文提供了一幅图像中九个特征的例子，该算法正利用这些特征来做出决策。如果该算法是在一个开放的数据集上训练的，那么这些例子可以提供给所有的图像，这将使偏见更容易被公众发现。

“医疗培训/验证数据的可用性受到限制，这些数据经许可用于当前研究，因此不公开。在合理要求和斯坦福医院许可的情况下，作者可能会提供一些数据。”
—摘自论文的数据可用性声明

幸运的是，在这种情况下，论文的作者依赖于公开可用图像和斯坦福医院图像的组合，这意味着我们可以查看训练数据的子集。否则，如果作者不承认，我们根本不知道统治者可能是一种偏见，我们也不知道这种偏见可能会影响多少图像(自己看看)。

除了期望围绕这些算法如何工作有更多的开放性，公布这些算法犯的错误以及它们的成功有助于人们对机器学习算法可能失败的原因形成直觉。提高公众的人工智能素养——围绕它在哪里被使用，训练和测试数据来自哪里，它正在做出什么决定，我们应该对这些决定有多大信心，以及这些决定是如何做出的——对于提高公众的信任以及控制开发这些算法的公司来说至关重要。

在提高人工智能的可解释性方面正在取得进展。如果消费者推动这成为批准重要用途算法的强制性部分，我们可能会更好地避免未来这些算法中出现意想不到的偏见。

NBA 赛季太长了吗？

原文：https://towardsdatascience.com/is-the-nba-season-too-long-4a4e56b8ed50?source=collection_archive---------28-----------------------

每年临近赛季末，都会有一个大名鼎鼎的 NBA 球员在一场重要的比赛中受伤。这就提出了一个问题:NBA 赛季应该缩短吗？

今年，我们看到一些高知名度的球员在赛季的最后阶段受伤。德马库斯·考辛斯、凯文·杜兰特和克莱·汤普森在季后赛中受伤。有几次，人们看到科怀·伦纳德在球场上一瘸一拐的。当然，这对那些夜以继日付出的球员来说是不好的。

鉴于这项运动的激烈程度，看到运动员坐在场外休息并不罕见。“负荷管理”这个词经常被媒体提起，只是因为玩家需要经常休息。没有机会休息，球员受伤的几率会增加。作为一名教练，你为什么要在一场不重要的比赛中拿球员的健康冒险？尽管球队很想赢，但他们也需要为他们的未来做准备，如果他们足够优秀，可以进入季后赛。

出于对经常发生的伤害类型的好奇，并想知道它们何时发生，我在互联网上搜寻答案。为了弄清这一点，我通过使用 Pro Sports Transactions 的数据收集了 2010 年至 2018 年 NBA 的每一次受伤。

它是这样分解的:

这项运动需要爆发性的跳跃和方向的快速改变。大多数伤害发生在腿部是不足为奇的。但是这个赛季什么时候会出现这些伤病呢？缩短赛季时间会有助于减少赛季中的大部分伤病吗？

NBA 赛季目前包括 82 场比赛--41 场主场比赛和 41 场客场比赛。所有比赛结束后，东部和西部的前八名球队进入季后赛。团队可以在任何地方玩 4-28 场游戏。考虑到这个时间线，我把每个赛季分成两半，看看一年中什么时候球员受伤最严重。

令人惊讶的是，大部分球员在赛季前半段受伤。当一名球员在赛季末受伤时，赛季需要缩短的说法经常被提起。据说游戏的磨损会对一个人的身体造成损害。磨损是真实的，但是如果大多数伤病发生在赛季的前半段，为什么没有人谈论这个？缩短赛季可能有助于防止伤病，但看起来这些潜在的变化只会针对受伤病影响最小的那半个赛季。

另一个值得注意的有趣的事情是联盟的发展方向:

受伤人数似乎在减少。无论是医护人员变得更好，还是球员打得更聪明，这对所有人都很好。

底线是 NBA 是一个企业。组织希望保护他们的球员，以增加他们赢得一切的机会。玩家们将继续在比赛中袖手旁观。

从一个球迷的角度来看，我知道出现在一个竞技场是多么令人厌烦，渴望见到你最喜欢的球员，却发现他们要休息了。这对球迷来说是一种不好的做法吗？当然可以。但是看看托伦托猛龙队发生了什么，他们让科怀缺席了整个赛季的几场比赛。他们被授予了一个头衔，因为他们决定让科怀休息。

如果球迷去观看他们最喜欢的球员比赛，看到他们坐在板凳上可能会有强烈的反弹。但也可能有一种疯狂的方法，因为某些东西似乎在起作用

哪一天投资最好？

原文：https://towardsdatascience.com/is-there-a-best-day-for-scheduled-deposits-in-investment-accounts-b23b8402948d?source=collection_archive---------11-----------------------

你应该选择哪一天作为你投资帐户的循环日？

Photo by Wyron A on Unsplash

早点存，定期存。太好了。你将定期存款安排到一些指数化投资，可能是 ETF，也可能是通过像 Betterment、WealthFront 等机器人顾问。

定期存款对冲了你对市场时机的押注。在我的例子中，我设定了一个机器人顾问的周存款，并想知道市场中是否有一个周模式显示一周中有利于投资的一天。我们能得到平均值的优势吗？

值得庆幸的是，所有的工具都是免费的，可以尝试得到这个问题的方向性答案。

对统计数据的初步看法

Quantopian 的平台提供免费的数据源和工具来构思交易算法。这个问题的好去处，让我们开始吧。

QTradableStocksUS 是一个由 Quantopian 管理的股票大世界，它去除了细价股和其他非流动性股票，但仍然是一个大世界。我正在查看自 2015 年以来该领域的所有股票回报。

To use those gists, you will need to create an account on Quantopian

Number of equities: 3039

现在，让我们得到在所考虑的时间段内每天所有符号的平均收益。

avg_returns = pipeline_output.groupby(level=0).mean()
avg_returns.head(2)

average returns and gratuitous average price

因为我们需要周模式，所以让我们添加星期和星期号。我们想要的是相对于每周平均回报的相对回报，而不是绝对回报，所以我们用平均值和标准差来标准化每周。

基于此，什么是平均每天的回报呢？在过去 4 年左右的时间里，似乎周一早上是你计划投资的最佳时间。

Normalized weekly returns over all 3000+ stock per day

请记住，回报是正常的，所以周五 12%的下跌谢天谢地不是市场上每周发生的事情。

没那么快…

嗯，我们有多少变化？

now with error bars

哎哟。这种模式突然变得不那么吸引人了。尽管如此，周五仍有 5%的可能性低于平均水平，相当于 0.05 的 p 值，这在统计上是显著的。YMMV 取决于您可接受的 p 值阈值。

让我们继续挖掘，看看均值是如何随时间演变的。

周日模式是如何随时间演变的？

让我们来看看在一个特定的观察范围内，这些相对收益是如何随着时间的推移而变化的。例如，如果我在几年内对 12 周的滑动窗口做同样的分析，这些天会一直翻转还是我们会看到一个模式？

很难看出，但纵观 12 周的滑动窗口，周五可能是一个月来表现最差的一天？到处都是。

更长的时间窗口怎么样？下面 48 周。

从更长的时间来看，周五似乎是最糟糕的一天，所以从这个角度来看，周一进行定期存款并不是一个坏选择。

最后

不足为奇的是，几乎没有任何迹象表明任何重要的东西已经被套利掉了。然而，轻微的趋势使我选择我的经常性存款日为星期一。声明，这不构成投资建议。

接下来呢？我很想知道基于这个因素的多空策略会有怎样的表现，这是 Quantopian 拥有强大工具的另一件事。此外，我很想看看某些股票在一周内的表现是否非常可预测。可能是后续文章的主题。

感谢你对这篇文章的评论和修改！

注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

有阿隆·拉姆齐的诅咒吗？

原文：https://towardsdatascience.com/is-there-a-curse-of-aaron-ramsey-3589d02dd278?source=collection_archive---------17-----------------------

“阿隆·拉姆齐的诅咒”暗示着:当前阿森纳足球运动员阿隆·拉姆齐进球时，一个名人很快就会死去。

这篇文章研究了这个“诅咒”的证据。

假定的诅咒

《每日星报》在 2018 年 4 月的中描述了这种假设的现象:

一个神秘的理论正在互联网上流传，当阿隆·拉姆齐进球时，一个知名的名人注定会在不久后去世。

这位阿森纳和威尔士球员经常设法打进重要的进球——但有时也有不好的一面。

Are these celebrations a ghostly call of doom? (Photo: Wikimedia Commons)

给我数据

阿隆·拉姆齐的进球记录来自足球俱乐部。这个分析只看每年 8 月到 5 月(简称足球年)之间的进球，涵盖 2014/15 到 2018/19。

“名人”的定义是主观的。我使用了两个不同的来源:每日镜报和英国广播公司。《每日镜报》每年都有“名人死亡”的在线文章。

同样，BBC 也有“显著死亡”的文章。对于 2016 年，由于名人死亡的数量很高，我只记录了在BBC 文章中强调的“前 34 名”死亡的日期。

离门柱很远

总的来说，拉姆齐得分的天数和名人或名人去世的天数之间似乎没有关系。

The Daily Mirror celebrity death day count has increased.

我们还应该看看具体的说法:在阿隆·拉姆齐得分之后，名人或名人死亡的天数比例是多少？

我使用了八种不同的方法，分别对应于同一天和三天之后的死亡人数。

在研究期间有 37 天阿隆·拉姆齐进了一个球。名人或名人的死亡有一个基本比率——拉姆齐目标日确实超过了这个比例。

如果我们假设目标日是随机选择的(每一天都是一次试验)，我们的二项式假设意味着这个“诅咒”的证据是微弱的。这是一个过于简单的模型，没有考虑到足球运动员比赛天数的分布。

宣称:每当拉姆齐进球，就有一名名人死去，这显然是错误的。

出去射门

这八项措施并不是作为多重比较问题提出的，而是为了强调主观选择的影响。

使用任一数据集都是一种选择。名人的概念是主观的，我们很容易调整我们的定义来适应一个假定的模式。

选择一个时间范围来计算是一种选择。使用频率论者或贝叶斯方法是一种选择。

虽然这项研究只关注了这些联系，但暗示这些选择存在“诅咒”的说法并不可靠。

似乎没有阿隆·拉姆齐的诅咒。意大利的名人应该对拉姆齐自由转会尤文图斯没什么可担心的。

数据来源和基本分析包含在的谷歌表单中。各种测试和数据可视化的 R 代码在的一篇 R Pubs 文章中。

开放数据和公开数据有区别吗？

原文：https://towardsdatascience.com/is-there-a-difference-between-open-data-and-public-data-6261cd7b5389?source=collection_archive---------3-----------------------

一个普遍的共识是，当我们谈论开放数据时，我们指的是任何可以自由访问、使用、重用和重新分发的数据或内容。然而，由于大多数政府推出开放数据门户的方式，很容易认为这些网站上的数据是唯一可供公众使用的数据。这不是真的。

尽管获得政府公开标记的数据集得到了更多的关注，但它们实际上只代表了网上公开数据的一小部分。

那么“公共”数据和“开放”数据有什么区别呢？

什么是开放数据？

一般来说，公开数据是在政府认可的门户网站上发布的信息。在最好的情况下，这些数据是结构化的、机器可读的、开放许可的，并且维护得很好。

什么是公共数据？

公共数据是其他任何地方都存在的数据。这是网络上免费提供的信息(但不是真正可获得的)。它经常是无结构的和不规则的，并且它的使用需求经常是模糊的。

“只有 10%的政府数据作为开放数据发布”

这是什么意思？

首先，这意味着政府门户网站上的公开数据和公共数据之间存在差异。这是一个重要的区别，因为虽然开放数据计划及其改变现代社会的潜力令人兴奋，但这个前提所依赖的数据——开放数据——只是实现这一潜力所需的一小部分。

事实是这样的:大部分有用的政府数据要么仍然是私有的，要么被藏在某个地方的文件柜里，而那些可用的东西正在被随意发布。

有关系吗？

这两种数据之间的区别真的重要吗？嗯……是的。

开放数据，因为它只代表了可用数据的一小部分，还没有发挥出它的潜力。像我这样对 开放数据运动 寄予厚望的人，还没有看到我们应该看到的投资回报(经济或社会)。我们没有的原因是多方面的，但这种区别是问题的一部分。

为了让公开数据像预测的那样有效，公开数据和公共数据之间的界限需要消除，政府需要开始让更多的公共信息成为公开数据。毕竟，是我们在为此买单。

最初发表于【https://blog.thinkdataworks.com】。

外面有工作吗？

原文：https://towardsdatascience.com/is-there-any-job-out-there-81ca0b514166?source=collection_archive---------20-----------------------

有没有想过为什么找数据科学的工作这么难？看看 Kaggle Survey 和 Glassdoor 工作列表之间的比较。

喂？喂？喂？外面有工作吗？
能录用我就点头。
人力资源部有人吗？

来吧…
我听说你情绪低落。
我可以减轻你的痛苦。
让你重新站起来。放松。

改编自平克·弗洛伊德的《舒适的麻木》

去年，我做了一项分析，以了解是什么让数据科学家变得有价值？这个想法基本上是为了确定是什么让从事数据相关工作的人年收入超过 10 万美元。一年后，我从巴西搬到了英国，从数据科学转到了数据工程，从年收入 14k 美元到超过 100k 美元。

现在，我认为将数据专业人员的技能与世界各地的工作列表进行比较会很好。为了实现这个目标，我搜集了一些与职位相关的数据，并将结果与 Kaggle 进行的调查进行了比较。希望你发现它对规划你的职业生涯是有益的！

首先，让我们创建一个指标来比较这两个不同的数据集以及不同的国家。下面的雷达图显示了 Kaggler 的数量(这是我将如何引用 ka ggle 用户)以及与每个国家的总数成比例的工作列表。为了更好的理解，请看下面的例子。

国家示例

数据科学家= 30 个答案(或工作列表，如果是 Glassdoor)
开发人员= 90 个答案
总共= 120 个答案

我们将策划:
数据科学家= 25%
开发者= 75%

美国对中国

Percentage of Kaggle answers per country. Highlighted USA and China.

大多数国家的卡格勒比例与美国相同，数据科学家的比例高于其他职业。这确实有意义，因为 Kaggle 专注于数据科学。但是我们确实有一些异常值。从中国开始，软件工程师和数据工程师在 Kaggle 大量出现。他们是想学数据科学转行吗？还是只是他们想加到现在角色上的一个知识？

看看 Glassdoor 的工作列表，我们发现中国软件工程领域的工作比数据科学领域多得多。

警告！如果你住在中国，是一名软件工程师，正在考虑迁移到数据科学，那么请重新考虑。在这个新的职业中，你可能会更难找到工作。

美国想要数据分析师！如果你住在美国，想成为一名数据科学家，那么考虑找一份数据分析师的工作。这可能会容易得多，因为该地区的就业机会比 DS 多。

看一下 Kagglers 报道的薪水，我们发现与其他职位相比，中国支付给统计学家和研究科学家的薪水更高。然而，不幸的是，正如前面的图表所示，这个领域没有多少工作机会。在美国，薪水最高的是数据科学，其次是数据工程和软件工程。当然……美国在几乎所有的职位上都比其他国家支付更多。

巴西对印度

我们看到巴西和印度在所有职位上的 Kagglers 比例非常接近。然而，巴西有更高比例的统计学家和研究科学家，这可能表明在巴西学术界做博士的人比印度多。

查看工作列表，我们发现巴西与中国有相似之处:对软件工程师的巨大需求。

来自巴西的数据科学家正在努力寻找工作！考虑学软件工程，加入一家公司做初级开发。

来自印度的卡格勒人！从商业分析师开始你的职业生涯有巨大的机会。

看那个！数据工程在巴西的工资看起来很高！不过，要找到一份 DE 工作并不容易(记住，软件工程师的需求量要大得多)。在印度，数据科学家的报酬会更高。如果你想挣得更多，那么考虑搬到另一个国家。

一些欧洲国家

荷兰有更多的专业人士对 Kaggle 感兴趣，因此对数据科学感兴趣。对于其他国家，我们看到缺乏数据工程师和商业分析师。他们在目前的职位上快乐吗？

在欧洲，职位列表几乎是均等的(所有职位的比例几乎相同)，这意味着如果你想成为数据科学家或商业分析师，在职位提供方面不会有太大差异。但就竞争而言，如果我们将 Kaggle 的调查推广到现实世界，可能会有更多的数据科学候选人。

来自欧洲的软件工程师！你在荷兰可能更容易找到工作！

最后，当我们比较欧洲的工资时，我们发现他们几乎处于相同的范围(英国稍微高一点，可能是因为货币比欧元强)。现在我们可以说，商业分析师在欧洲确实很快乐，他们的平均收入甚至比技术人员还要高。

来自英国和德国的软件工程师、数据工程师和数据科学家！现在就停止编码，成为商业分析师！

我开玩笑的。不要那样做。还是做。

在上面的图表中，你可以看到机会在哪里，取决于你住在哪里。更多的工作列表意味着在该领域获得工作的机会更多。一个职位上有更多的人，可能意味着你在找工作时会面临更多的竞争。

多年的编码经验如何影响薪水？

我们确实期望随着经验的增加薪水会增加，事实就是这样！然而，你有没有看到那些根本不编码的人比那些开始编码的人挣得多一点？这可能是因为经理们坐在第一组。一旦你获得了一些动力编码，你的工资会持续增加。

我们能检验经理(没有编码经验)推动工资增长的假设吗？嗯……有点……我们希望经理们挣得更多，也更……老，对吗？让我们看看这是不是真的。

有理由推断，没有编码经验的人比没有什么经验的人挣得多，因为他们在管理岗位上。除了数据工程，我们有更年轻的人，没有编码经验，比那些开始编码的人挣得多。

公司规模如何影响薪水？

平均工资通常随着公司规模的增加而增加。数据科学家和统计学家/研究科学家认为，从一家初创公司跳槽到一家大公司时，他们的工资单会有最大的不同。商业分析师不能指望仅仅通过跳槽到一家更大的公司就能大幅增加工资。

薪水不是一切。在找大公司的工作之前，先考虑利弊。

Python、R 和 SQL——在 Kaggle 和就业市场中的受欢迎程度

Python 已经成为所有职位的人使用的主要语言，大约 3/4 的受访者经常使用它。r 语言更不受欢迎(几乎没有软件工程师使用它)。

如果你想找一份数据科学方面的工作，那么 Python 是首选语言。Glassdoor 上超过 75%的数据科学职位在职位描述中都提到了 Python。

Python 是市场偏爱的数据科学语言！

统计学家和研究科学家比其他职业使用更少的 SQL。事实上当时只有 1/4 的人使用 SQL！这表明学术界更习惯于平面文件而不是数据库。不幸的是，现实世界在中没有出现。csv** 文件。**

嘿，你正在读硕士或博士，想找份工作！看上面那两张图！学习 SQL！

如果你想开始与数据打交道，那么了解 SQL 将有助于你获得商业和数据分析师的工作。现在如果你想走上数据工程的道路，SQL 和 Python 是必须的。软件工程师懂 Java 会更容易找工作。

要想在数据世界谋得一份工作，推荐学习的语言是 SQL！

我们看到 Kagglers 在 Python 的使用上做了充分的准备！虽然许多受访者使用 Bash 和 R，但工作描述中并没有频繁提到这些语言。业务分析师并不经常需要 SQL，但是了解它(就像 Kagglers 一样)会让你领先一步。总的来说，Kaggle 的软件工程师和数据工程师可能很难找到工作，因为经常需要 Java，而他们中的许多人不具备这种技能。

学习 Java 有助于你进入软件工程或数据工程

应该学习多少种编程语言？

学习(和使用)多种语言看起来不像是薪资方面的竞争优势。挑选三个，并在使用它们的时候成为真正的专家。限制你的语言，尤其是如果你没有处理数据的经验！

停止学习多种语言！ Python，SQL，再多一门你选的语言应该就够了。

谁应该学习和使用云计算平台？

我们看到许多 Kagglers 数据科学家习惯于使用云平台！对于生产机器学习模型来说，这是一个好消息，因为如果数据科学家不在他们的本地环境中做任何事情，那么与模型一起生活会容易得多。

我可以确认这是真的！自从我从数据科学迁移到数据工程，我开始大量使用 AWS 产品。云计算平台有很多针对整个数据管道的托管服务。知道在哪里应用(以及如何使用)它们对于任何数据工程师来说都是至关重要的。

注意！要从事数据和软件工程工作，你需要大量关于云计算平台的知识！

数据库

来自学术界的 Kagglers！再次强调，如果你想为市场做好准备，就应该更频繁地使用关系数据库。

虽然他们在职位描述中不经常出现，但我们看到数据工程师和软件工程师的列表通常需要数据库引擎的知识，如 PostgreSQL、MySQL 和 SQL Server。具有 SQL Server 知识的数据分析师在找工作时可能会从中受益。

最后……外面有工作吗？

是的有！

也许你只是找错了地方，或者不具备某个职位的要求。
尝试将你的技能与正确的职位相匹配。
寻找其他领域的机会，在工作机会和专业人士之间有很多不匹配。
也许你的下一份工作不是数据科学家，而是数据分析师、数据工程师甚至软件开发员。

附录

从 Glassdoor 获取工作列表

我创建了一个简单的脚本来删除 Glassdoor 列表。网络抓取是在 2019 年 12 月 10 日完成的，我能够检索到超过 165，000 个职位列表。这个过程的更多细节可以在这个 GitHub 库上找到。

数据经过处理，作为 Kaggle 数据集公开发布！由于 Glassdoor 网站的限制，数据提取仅限于每个国家每个搜索词的第 30 页。请检查一下，也可以随意处理这些数据！

2019 年 Kaggle 调查的公共数据集

我能做这项研究只是因为 Kaggle 发布了其第三次年度机器学习和数据科学调查的数据。该调查于 2019 年 10 月上线，为期三周，共收到 19717 份回复。结果包括谁在处理数据的原始数据，不同行业的机器学习情况，以及新数据科学家进入该领域的最佳方式。

带有复制学习代码的笔记本

在 Kabble 上可以公开获得复制这项研究的代码和所有图表的笔记本。点击此处查看！

其他考虑

我们假设受访者的回答是诚实和真诚的。
这可能不代表数据专业人员的全部(它只有 Kaggle 用户的答案)，但它是一个很好的代理。

在此添加此图片只是为了能够将其定义为特色图片:

方差真的是不确定性的度量吗？

原文：https://towardsdatascience.com/is-variance-really-a-measure-of-uncertainty-6ec6da21bb03?source=collection_archive---------18-----------------------

关于概率统计的思考

假设您正在收集评级数据的样本，范围从 1 到 10。假设您的样本由 100 个点组成，考虑两个可能的样本。

10 个人从 1 到 10 给每个可能的值打分。
50 个人给 1 分，50 个人给 10 分。

第一个样本对应于所有 10 个可能值的均匀分布。

Uniform Distribution

第二个样本对应于极值 1 和 10 处的双峰分布。

Bimodal Distribution

哪种分布更「不确定」？

如果我们将方差作为不确定性的度量，那么我们可以计算每个分布的样本方差，对于均匀样本，我们将得到 8.33，对于双峰样本，我们将得到 20.45。然后我们会得出结论，双峰样本更不确定。

但是在某种意义上，双峰样本比均匀样本更容易预测，不确定性更小。只有两个可能的值，而统一样本有十个可能的值，如果您必须准确预测个人给出的评级，您可能会在双峰样本上得到更正确的结果。

事实上，如果我们把熵作为不确定性的一种度量，那么我们就会知道，对于一个有限的支持，使熵(以及不确定性)最大化的分布就是均匀分布。

但是如果预测没有被评估为完全正确或错误呢？例如，如果有人给了 10 分，而你预测的是 9 分，你可能是不正确的，但已经足够接近了，这比你预测的 1 分要好。通过调整评估预测的方式，有可能得出均匀分布比双峰分布更可预测的结论，因此双峰分布将更加不确定。

方差或熵是更好的不确定性度量吗？

这个问题就看用户自己的判断了。没有一个最好的方法来捕捉不确定性的概念。例如，它可能取决于数据的属性(例如，方差不适用于分类数据，但熵适用)。

我的观点是，很容易将数学构建的公式与非数学思想混淆，在越来越多的人试图用数据欺骗你的时候，意识到这些问题是很重要的。

网页抓取合法吗？

原文：https://towardsdatascience.com/is-web-crawling-legal-a758c8fcacde?source=collection_archive---------6-----------------------

Photo by Sebastian Pichler on Unsplash

网络爬行，也称为网络抓取、数据抓取或蜘蛛，是一种用于从网站抓取大量数据的计算机程序技术，其中规则格式的数据可以被提取并处理成易于阅读的结构化格式。

Web 爬行通常用于:

网络爬行基本上就是互联网的功能。例如，SEO 需要创建网站地图，并允许 Google 抓取他们的网站，以便在搜索结果中获得更高的排名。许多咨询公司会雇用专门从事网络搜集的公司来丰富他们的数据库，以便为他们的客户提供专业服务。

在数字化时代，很难确定网络抓取的合法性。

为什么网络爬行有负面含义:

网页抓取可用于恶意目的，例如:

搜集私人或机密信息。
无视网站的条款和服务，未经所有者允许就刮。
数据请求的滥用方式会导致 web 服务器在额外的高负载下崩溃。

请注意，在以下情况下，负责任的数据服务提供商将拒绝您的请求:

数据是私人的，需要用户名和密码
TOS(服务条款)明确禁止网页抓取行为
这些数据是受版权保护的

有哪些理由可以用来告人？

违反《计算机欺诈和滥用法案》(CFAA)。
违反数字千年版权法(DMCA)
侵犯动产
挪用。

你的“刚刮了一个网站”如果使用不当，可能会造成意想不到的后果。

HiQ vs LinkedIn

你大概听说过 2017 年的 HiQ vs Linkedin 案。HiQ 是一家数据科学公司，向企业人力资源部门提供抓取的数据。Linkedin 随后发出停止信，要求停止 HiQ 抓取行为。HiQ 随后提起诉讼，要求 Linkedin 阻止他们的访问。结果，法院做出了有利于 HiQ 的裁决。这是因为 HiQ 在没有登录的情况下从 Linkedin 上的公共档案中抓取数据。也就是说，抓取互联网上公开分享的数据是完全合法的。

让我们再举一个例子来说明在什么情况下网络抓取是有害的。易贝诉投标人边缘案。如果你是出于自己的目的进行网络爬行，这是合法的，因为它属于合理使用原则。如果你想把搜集来的数据用于其他人，特别是商业目的，事情就复杂了。引自 Wikipedia.org，100 F.Supp.2d 1058。2000 年)，是一个领先的案例适用于动产入侵理论的在线活动。2000 年，在线拍卖公司易贝成功利用“侵犯动产”理论获得了一项初步禁令，禁止拍卖数据聚合网站 Bidder's Edge 使用“爬虫”从易贝网站收集数据。该意见是将“侵犯动产”适用于在线活动的一个主要案例，尽管其分析在最近的判例中受到了批评。

只要你不是以一个破坏性的速度爬行，并且源代码是公开的，你应该没问题。

我建议你检查一下你计划抓取的网站，看看是否有任何与抓取他们的知识产权相关的服务条款。如果上面写着“禁止刮擦或爬行”，你应该尊重它。

建议:

小心地刮擦，在开始刮擦之前检查“Robots.txt”
保守一点。过分地要求数据会加重互联网服务器的负担。合乎道德的方式是温和。没人想让服务器崩溃。
明智地使用数据。不要复制数据。您可以从收集的数据中获得洞察力，并帮助您的业务增长。
在你开始抓取之前，先联系网站的所有者。
不要随意把刮来的数据传给任何人。如果它是有价值的数据，请确保其安全。

你的算法够自信吗？

原文：https://towardsdatascience.com/is-your-algorithm-confident-enough-1b20dfe2db08?source=collection_archive---------10-----------------------

如何度量神经网络中的不确定性？

当机器学习技术被用于“关键任务”应用时，可接受的误差幅度变得非常低。

想象一下，你的模型正在驾驶一辆汽车，协助一名医生，甚至只是直接与一个(可能很容易被激怒的)终端用户进行交互。在这些情况下，您需要确保在对模型做出的预测采取行动之前，您对这些预测有信心。

随着模糊系统日益成为我们模糊生活的一部分，测量预测不确定性变得日益重要。

这里有一个好消息:有几种测量神经网络不确定性的技术，其中一些非常容易实现！首先，让我们感受一下我们将要测量的东西。

Photo credit: Juan Rumimpunu.

给不确定性加上一个数字。

当你制作世界的模型时，你的模型不能总是提供准确的答案。

这部分是由于模型是一个非常复杂的世界的简化。因为有些信息是未知的，所以从模型中得到的预测会有一定程度的不确定性。

我们世界的某些部分(以及我们衡量它的方式)简直是混乱的。有些事情是随机发生的，这种随机性也是模型预测不确定性的一个来源。

预测不确定性可分为 3 类:

1。模型不确定性。

模型的不确定性来自于对问题的“无知”。也就是说，模型的不确定性量化了那些可以被模型正确捕捉而不能捕捉的事物。

来自 Taboola 的 Yoel 和 Inbar 提供了一个有趣的例子:

You want to build a model that gets a picture of an animal, and predicts if that animal will try to eat you. You trained the model on pictures of lions and giraffes. Now you show it a zombie. Since the model wasn’t trained on pictures of zombies, the uncertainty will be high. If trained on enough pictures of zombies, this uncertainty will decrease.

有时也被称为或 结构不确定性 。测量模型的不确定性是统计学的一个领域，被认为是特别具有挑战性的。其中一个原因是，随着模型变得越来越复杂，像贝叶斯模型平均这样的原则性技术变得非常昂贵。

2。模型设定错误。

如果您的模型在训练和验证期间产生了良好的预测，但在评估(或生产)期间却没有，那么它可能是错误指定的。

模型设定错误不确定性捕获模型根据与训练数据模式完全不同的新数据进行预测的情况。

3。固有噪声。

这是由数据集中存在的噪声产生的不确定性。这可能是由于不完善的测量技术或被测物体固有的随机性。

Imagine your dataset contains 2 images of cards facing down. You’re feeling optimistic and you want to build a model to predict the suit and value of each card. The first card is labeled as ace of spades and the other is labeled as 8 of hearts. Here, the exact same features (an image of a card facing down) can be linked to different predictions (either ace of spades or 8 of hearts). Therefore, this dataset is subject to lots of inherent noise.

固有噪声有时也被称为 任意的 或 统计不确定性 。固有噪声量与给定分类器的最低可实现误差率贝叶斯误差率相关联。可以想象，一个模型所能达到的最低可能错误率与数据本身的噪声所产生的错误量紧密相关。

这些概念严重依赖贝叶斯统计。我以简单的方式概述了这些想法，但这只是触及了这些深层主题的表面。

要了解贝叶斯神经网络中不确定性度量的更多信息，我推荐看一看 Felix Laumann 的这篇文章。为了深入解释数据科学背景下的贝叶斯统计， Ankit Rathi 已经写了一系列关于这个主题的伟大文章。

Photo credit: Avi Richards

实现不确定性。

此时，你可能在想:“听起来不错，但是我如何在我的模型中实现不确定性呢？”。

贝叶斯神经网络默认情况下集成了不确定性，此外通常对过拟合和处理较小的数据集更加鲁棒。然而，用于构建贝叶斯神经网络的工具链仍在出现，并且无论是在训练期间还是在进行预测时，模型的计算成本都更高。

此外，将您的工作迁移到概率模型(如贝叶斯神经网络)将会很烦人。

从长远来看，概率深度学习将有可能成为默认。不过现在，将概率观点整合到我们现有工作中的实用技术是一个良好的开端！

蒙特卡洛辍学。

几年前，剑桥大学的 Yarin 和邹斌发现了一种方法，可以在不改变神经网络结构或优化技术的情况下近似模型的不确定性。

下面是简短的版本:通过在测试时在每个权重层之前使用 dropout，并多次迭代运行您的预测，您可以近似贝叶斯不确定性。他们称这个过程为蒙特卡洛辍学:

你给你的模型输入一个信息。
您对单个输入进行多次迭代预测，每次都随机禁用神经网络的一小部分。
你取平均产值。这是你的预测。最后，您测量迭代之间的方差。这就是模型的不确定性。****

****直觉上，我是这样想的:你的预测随着模型微小的结构变化而波动的越多，那个预测就越不确定。

实现蒙特卡洛辍学真的很容易。在这里，我从一个简单的密集网络开始，这个网络是用 Keras 构建的 MNIST 问题。默认情况下，仅在训练期间启用辍学层。要在测试时启用漏失层，请为每个层设置training=True。

**img_dim = 28x_in = Input(shape=(img_dim, img_dim,))
x = Dropout(0.2)(x_in, **training=True**)
x = Dense(500, activation="relu")(x)
x = Dropout(0.2)(x, **training=True**)
x = Dense(250, activation="relu")(x)
x = Dropout(0.2)(x, **training=True**)
x_out = Dense(10, activation="softmax")(x)model = Model(inputs=x_in, outputs=x_out)
model.compile(loss="categorical_crossentropy", optimizer="rmsprop")**

接下来，我们需要一个定制的预测函数，它可以迭代预测并返回这些迭代的均值和方差。在本例中，我们测量的是标准偏差而不是方差，因为它与平均值用相同的单位表示。

**def predict_with_uncertainty(model, 
                             X, 
                             batch_size=None, 
                             num_iterations=100): last_layer = model.layers[-1] results = np.zeros((num_iterations,
                       X.shape[0],
                       last_layer.output_shape[1]), 
                       dtype="float") for i in range(num_iterations):
        results[i] = model.predict(X, batch_size=batch_size)

    **predictions = results.mean(axis=0)**
    **uncertainty = results.std(axis=0)**

    return predictions, uncertainty**

现在，您可以用近似的不确定性进行预测了:

**predictions, uncertainty = predict_with_uncertainty(model,your_data)**

Photo credit: Tim Gouw

问题和批判。

正如我们所见，使用蒙特卡洛辍学真的很容易。也许连 都太容易 。deep mind 的 Ian Osband 对该技术提出了批评,他指出一个简单模型的预测不确定性并没有随着数据的增加而降低。这就提出了一个问题，即它是否是贝叶斯不确定性的不准确近似，或者是否有任何潜在的假设需要变得更清楚。

关于这个问题，Sebastian schner 写了一篇很棒的博客文章，总结了他的评论。

在我工作的地方 神田 ，我们对蒙特卡洛辍学的有效性有着复杂的体验。

像我之前的例子一样，对于一个在 MNIST 上训练的简单全连接模型，不确定性近似表现出预期的行为:当呈现噪声而不是手写数字时，近似的不确定性更高。我们发现 50-100 次蒙特卡洛淘汰迭代产生了令人满意的结果。

后来，我们有一个场景，我们需要在智能手机上本地运行图像识别任务，作为 AR 应用程序的一部分。我们使用迁移学习，在 NASNet 移动架构之上构建一个分类器。

在智能手机上运行 100 次 NASNet 迭代并不是一个好主意。

即使采用高度并行化，我们实际上也只能在设备上运行大约 20 次迭代，以便及时提供预测。

其次，不确定性估计不准确。当喂给一张随机噪音的图片时，不确定性出奇的低。值得注意的是，我们只在 NASNet 之上的分类器的密集连接部分实现了 dropout。如果你愿意分享直觉，告诉我哪里出了问题，我很有兴趣阅读你的回复！****

结论。

首先，我们看了一下为什么量化机器学习模型中的不确定性很重要。然后，我向你介绍了关于预测不确定性的 3 种不同的思考方式:模型不确定性、模型错误设定和固有噪声。****

Monte Carlo dropout 是一种易于实现的近似贝叶斯不确定性的技术，但是对于近似是否真的准确还存在一些争议。实际上，我发现 Monte Carlo dropout 对简单模型有效，但对复杂模型的方法有一些问题，在准确性和性能方面。

我在机器学习中整合贝叶斯概率只会在未来变得更加重要，我期待看到更多的概率技术成为工具链的一部分。

你的公司是不是太笨了，不能数据驱动？

原文：https://towardsdatascience.com/is-your-company-too-dumb-to-be-data-driven-696932d597c3?source=collection_archive---------7-----------------------

利用信息是一种熟练的行为，而不是数据产品的输出。

Photo by Campaign Creators on Unsplash

对于数据专家来说，这是最好的时代，也是最坏的时代。人们对将智能信息、统计数据和科学应用于人类各个方面的兴趣空前高涨——从复杂的商业决策和尖端产品到我们的日常任务管理，数据集成似乎无处不在。在尤瓦尔·赫拉利的《T4》中，他提出了一个令人信服的论点，即“数据主义”甚至可能是下一种形式的宗教——当你看到我们社会对这种东西的痴迷是如何演变的，他可能会有所发现。似乎在更大的商业世界的眼中，任何和所有事物的任何和每一个数据应用本身就是努力这样做的理由。在 FOMO 推动的热潮中，各公司正在向数据相关技术和员工投入资源，速度比你说机器学习还快。但是，就像购买昂贵的健身房会员资格不会给你道恩·强森的身体一样，仅仅在技术堆栈上的大量投资不会创造数据驱动的决策文化。对于要利用以数据为中心的决策支持所能提供的机会的组织来说，变革需要从业务用户开始。聪明的组织会围绕这些变化而发展，而不那么聪明的组织会遇到决策过程变化的考验，做出不明智的选择，产生令人失望的结果。如果数据计划的成功执行需要以下所有条件:

重要资源
文化成熟度
组织智能

人们不禁会问这样一个问题:“我的公司是不是太笨了，无法实现数据驱动？”

大多数数据计划出错的地方

要理解在数据驱动的游戏中赢家和输家的区别，首先理解为什么如此多的数据计划出错是有帮助的。在构建组织数据战略时，大多数企业通常会创建一个类似于以下过程的路线图:

将不同来源的数据收集到数据仓库中
将数据导入商业智能工具
利用洞察力

对于技术实现团队来说，第一步似乎很容易。他们将选择一个目标数据仓库或数据湖，以及提取-加载(EL)数据的方法，甚至可能进行一些数据分析和建模。第二步(加载 BI 工具)有点不透明。业务用户将对仪表板、模型和图表有广泛的需求；有些人希望得到所有可能的数据点，而有些人则希望精确复制他们正在生成的手动报告。该项目将继续推进，一路上会通过一些里程碑式的目标，如“脸书数据完成了”。最后项目会达到 MVP 发布！该组织将屏息以待，等待这些见解开始滚滚而来。

然后等待。

Those insights will be here any day now… (image credit RebeccaSaid https://creativecommons.org/licenses/by-sa/4.0)

但不知何故，尽管对数据技术进行了大量投资，项目取得了所谓的“成功”，但一切照常将会继续。仪表板将不再使用，团队将继续依赖共享的电子表格和脱节的第三方工具集，高管将继续在黑暗中做出决策。这是因为数据驱动与机器学习或人工智能、数据仓库或 BI 仪表板无关。数据驱动是指业务用户 学会问好问题这是任何商业智能工具或数据产品都无法提供的。

在上面的场景中，技术组件(数据仓库、ETL 过程和 BI 可视化)可能被正确地实现了。但是能够分析业务趋势并从度量中得出准确的结论并不是标准软件工程师工具包的一部分(也不应该需要)；因此，技术实现团队通常会构建业务用户所要求的东西，同时假设“涉众最了解他们需要什么”一个普遍持有的错误观点是，向业务用户提供数据和可视化本身会导致数据驱动的决策。实施数据计划时，重要的是要理解 成为主题专家并不意味着一个人将知道如何利用关于该主题的数据 。正如雕塑家可能不知道如何操作 3D 打印机一样，经验丰富的产品经理可能不知道如何应用商业智能仪表板来推动功能改进。第一次访问度量标准和组织知识的业务用户可能不知道他们应该问什么问题，并且他们不太可能知道根据他们收到的答案应该采取什么行动。理解变化的长期趋势和统计意义需要特定的技能，而这种技能通常是缺乏的。

与此同时，商业用户将开始表现出他们的沮丧。他们得到承诺，洞察力将无情地削减开销并释放隐藏的机会财富，但所有的商业智能工具似乎都提供了许多复杂的图表和图形，并没有真正告诉他们任何东西。他们应该如何处理图表上的一堆弯弯曲曲的线条，或者烛台图表的方框图和线条图？商业启示在哪里——屏幕上红色闪烁的警告框指示他们增加关键词支出，或关闭表现不佳的仓库，或改变内容标题的时态以增加读者数量？难道机器学习和人工智能不应该找到所有这些隐藏的模式，并巧妙地将它们呈现出来以供采取行动吗？不熟悉数据相关技术的业务用户普遍认为，数据产品将通过使用“神奇的”算法输出可操作的方向；在数据产品销售人员和媒体炒作之间，很容易理解我们是如何对数据工具的功能产生如此严重的误解的。事实是 数据工具不提供商业答案，它们提供信息。将这些信息转化为答案需要用户的知识和技能。 说白了，分析工具可以自主摄取原始数据并输出可操作的见解的想法是科幻小说，更适合一集感兴趣的人而不是指导委员会会议。**

Quick! which one tells you how to run your business, and which one monitors hyperspace? (image credits Growthlakes https://creativecommons.org/licenses/by-sa/4.0 and Kreg Steppe https://www.flickr.com/photos/spyndle/2820733255)

这些假设一起创造了一个沮丧和失败的痛苦循环。技术实现者无法理解为什么业务用户似乎从来没有从他们交付的工作中获得价值，业务用户也无法理解为什么技术实现者一直交付不可操作的工作。尽管如此，从昂贵的数据计划中一无所获实际上并不是最坏的结果；更具破坏性的是，当业务用户获得并应用错误见解时。

错误的见解:M.Python 控股有限责任公司。

米（meter 的缩写））Python Holdings LLC 是我们假想的房地产开发公司，在这个案例研究中，读者您扮演商业智能实现工程师的角色。假设首席人事官向员工仪表板提交了一张变更单，将“员工体重超过其各自工作地点的平均离职率”添加到报告选项卡中。在你质疑改变是否可行之前(“我们有员工体重数据吗？”)您根据为什么因素标记票据；这个请求可能如何传递价值？你向首席采购官寻求澄清，对话如下:

您: “您好 Idle 先生(CPO)您能告诉我您将根据此请求的输出做出什么决定吗？理解这些决定将有助于我确保我做出的改变能够满足您的需求。

CPO: “没问题！我们将利用这些数据来追捕任何可能为我们工作的女巫。”

你: “乌..请详细说明。”

首席财务官: “嗯，克里斯先生(首席财务官)上周没有出席董事会，但是我们在他的办公室里发现了一只蝾螈。所以我们很自然地认为是女巫把他变成了蝾螈。我们投票决定立即找到并清除公司中的所有女巫，并以数据为依据。所以我们认为，女巫会燃烧，木头也会燃烧，对吗？当然木头会浮起来，鸭子也会浮起来。所以，如果数据显示我们有像鸭子一样重的员工，他们就是女巫！”
你: (掌纹)

错误的见解，你自己的角色统计公式，以及受确认偏差严重影响的度量标准，都对组织的决策过程具有极大的破坏性。此外，当由此导致的业务崩溃达到顶点时，这些被污染的可交付成果通常将数据和实现团队作为替罪羊。

仪表和杠杆

数据驱动的决策可以归结为几个因素:你能测量什么(量规)，你能做什么(杠杆)？问聪明问题的第一步来自于对杠杆是什么的详细评估；这些事情包括广告的支出渠道，或者 SAAS 公司的技术投资决策，或者内容创作者的措辞选择。一旦业务用户知道他们有什么杠杆、，下一步就是确定他们需要什么量规。这就是事情变得棘手的地方。量表主要有两种类型:滞后型(或描述型)和超前型(或说明型)。滞后指标通常是你关心的事情(如月收入)，但只能事后衡量。领先指标与滞后指标具有预测性关联——网站访问量、单位销售额或页面流量行为模式可能是月度销售滞后指标的领先指标。滞后措施是记分牌，告诉你你的决策是否成功。 但是滞后的度量对于数据驱动的决策制定并不是天生有用的；这就是你需要领先指标的原因。 识别这些领先指标是提出好问题的核心。对操纵每个杠杆将如何影响领先指标有很强把握的业务用户将能够利用它们并转向滞后指标目标，这就是数据驱动的决策制定。

天气与气候

尼尔·德格拉斯·泰森解释天气和气候差异的视频是纯金的。

science is so much better with dogs

尼尔非常雄辩地展示了一个统计显著性的例子。这就是说，在计算气候趋势时，一月的温暖一周或八月的寒流(在费城)并不意味着什么。当业务用户确定他们需要支持他们拥有的杠杆的量规时，他们选择的指标实际上是数学和科学的指标是至关重要的。例如，一个零售店的采购员使用“今天的温度”这一先行指标来推动库存决策，并且只订购来年的冬装，这显然是愚蠢的。但是如果买家使用去年的平均温度呢？还是去年最高最低气温日期来划分季节？还是过去十年每天的平均气温变化？加入一点数学可以给创造性的(但不健全的)数据利用方法一种可信度的感觉；一个坏的量表通常会比没有量表给你带来更多的麻烦。

确定组织准备情况

确定一家公司对数据驱动的准备程度实际上是确定整个组织中数据应用技能的水平。这种确定可以在数据仓库/商业智能技术上花费一美元之前完成，并将围绕数据计划将产生的潜在投资回报设定现实的预期。

滞后指标很重要(记住这些是成功的最终衡量标准)，但在用数据积极推动决策的背景下，它们用处不大。为了影响决策，重点需要放在引导措施上。有了这个目标，业务用户的任务就是为他们的垂直行业提供一个简要的数据战略纲要。本大纲每个数据集包含 4 个问题:

他们用这个数据集影响了什么结果？
他们希望数据集到达时是什么样子？
他们将如何从这个数据集中提取答案？
他们将通过什么手段对结果采取行动？

这可以是一个简单的电子表格，带有估计的列标题和几行清晰的文档。

A basic example of a business user action plan

在上面的回答中，我使用的统计数据比我对大多数商业用户的预期要多；如果计划为“计算每个渠道的投资回报率，并找出它开始下降的地方”，这将是一个有价值的见解，即该团队可能需要分析师/数据科学家/需求规划员的帮助来确定一个正确的模型。

不熟悉数据驱动的决策制定的业务用户可能会说，如果不首先在商业智能工具中访问数据，他们不可能知道预期的数据或数据将如何使用。试着在不同的语境下想象同样的逻辑；假设一位工厂经理要求为装配线购买一台价值 10 万美元的新机器。如果经理不能描述机器实际上做什么，或者不能清楚地说明机器将如何被用来盈利，但坚持认为，一旦安装，机器将被证明是一项伟大的投资…这听起来是否可笑？大多数数据计划的成本远远超过 10 万美元的神秘机器，但这种情况每天都在发生。

智能组织如何发展到数据驱动

有了这些潜在的标准、杠杆和结果的集合，就有可能确定一个组织在哪些方面做好了将数据纳入决策的最佳(和最差)准备。聪明的组织将使用这些信息来决定哪些策略最适合他们的当前状态(如果你愿意，可以说是数据驱动的，关于他们对数据驱动的追求)。这些聪明的策略通常包括:

在组织内建立明确的期望。成为数据驱动型企业的第一步是明确数据在企业中的意义。这就必须明确地呼唤出组织决策者将被赋予获取信息的巨大权力，并且与这种权力相伴随的是巨大的责任；决策者将负责学习使用经过科学验证的方法智能地请求、解释和处理业务信息的技能，并在整个组织内重新设定智能决策的标准。这种变化需要清晰而全面地传达，因为它重新定义了领导者和决策者的行为预期。
****利用现有的数据专业知识。调查一个组织的当前状态可以识别出已经非常擅长从信息中提取洞察力的团队和团队成员。这些“锚点”团队和团队成员可以帮助建立一个其他团队必须应对的潮流线，并且通常可以跨职能工作来帮助他们这样做。
****集中数据主动权。内部竞争可能是任何数据驱动战略的主要障碍。一个计划要想成功，它必须得到自上而下的认可，成为组织内“唯一的真理来源”。这消除了业务孤岛，允许洞察在垂直行业之间传播，并确保滞后和超前度量在整个组织中一致。
****将组织的有限资源集中在数据将产生最大影响的地方。如果大部分业务需要帮助识别和建模主要措施，而组织中几乎没有数据科学家或分析师，一个可行的解决方案是从回报最大的团队开始，并保持对这些领域的高度关注。这意味着不要试图在整个组织中引入商业智能工具，而是在资源可用时迭代下一个最有价值的应用程序。数据能力是累积的，随着业务用户掌握数据知识，他们将变得更加自给自足。
****鼓励商业用户学习如何解释和计算简单的统计数据。对于一个真正由数据驱动的组织，每个团队成员都需要能够消费和正确应用数据产品。业务用户必须超越反动的“指针移动”仪表板，并学会解释丰富的统计指标。
考虑放弃或至少推迟成为数据驱动的选项。**与普遍看法相反，并不是所有的组织都需要立即成为数据驱动型组织才能获得成功。对一些人来说，将资源投入数据计划可能是浪费时间和精力，这些资源可以更好地分配到其他地方。聪明的组织不排除数据驱动的决策可能根本就不是数据驱动的。

不太聪明的组织是如何失败的

****喂养流行语火焰。在定义组织的数据计划目标时，自上而下的消息传递通常类似于商业网站底部的 clickbait。陷入对神奇算法和全能机器学习技术的流行文化痴迷不仅仅是噪音；这种空话使本组织陷入失败和失望之中。聪明的组织为数据计划将会(和不会)实现什么设定现实的期望，而愚蠢的组织则传播科幻小说。
关注滞后指标。使用 KPI 仪表盘为决策提供信息就像使用足球比赛的最终比分来决定你应该叫牌的比赛。愚蠢的组织将整个月都在这些最终数字上打圈，同时继续猜测哪些行动可能会真正影响它们。
选择数量胜于质量。在启动数据驱动计划时，一个常见的(也是非常不成功的)策略是通过向业务用户群体提供尽可能多的低质量、接近原始状态的数据集来取悦所有人。这个想法是，任何数据都比没有数据好，未来的改进可以集中在准确性和可访问性上。这肯定会在决策过程中散布错误的结论和相互矛盾的事实，同时破坏利益相关者对您的数据生态系统的信心。
把遗产和资历放在科学之前。办公室政治对数据计划推出的影响通常在聪明和愚蠢的组织之间形成鲜明对比。随着该公司开始采用单一数据源，并让决策者负责将分析应用到他们的流程中，不可避免地会有抵制。一些团队抵制随着组织的变化，因为他们认为这是不必要的努力；其他人可能出于傲慢而悄悄拒绝，认为他们从应用见解或统计数据中没有任何收获。还有一些团队拒绝集中式数据计划，这样他们可以继续控制他们自己的度量标准(当然，在这个过程中对数据进行友好的倾斜)。愚蠢的组织制造一个又一个的例外，让决策演变成一场商业逻辑正确与否的战争；真相的集中来源，还是多年来一直被信任的“伟大的电子表格”？如果一个组织要成为数据驱动型组织，它必须表明自己相信哪些数据，并毫无例外地致力于这一决策。
一个特别具有挑战性的情况是，拒绝合作的人碰巧是高层领导成员。没有什么会削弱组织应用领先指标的势头，这些指标为可操作的决策提供了信息，如首席执行官坚持使用统计上不准确的指标，专注于滞后指标，或从数据驱动的计划之外的来源拖出不可信的指标。一个组织很少能比驱动它的领导层表现得更聪明，在这种情况下，愚蠢的结果是难以避免的。

最后

像许多业务计划一样，转变组织以利用数据驱动的决策制定实际上是转变员工的行为和技能。理解这一点并相应投资的公司会发现，数据创造了一个新的商业机会的世界；专注于技术、流行语和科幻小说的公司会发现数据是另一项失败的投资。

您的公司真的是数据驱动的吗？

原文：https://towardsdatascience.com/is-your-company-truly-data-driven-2cf5feaa3cfb?source=collection_archive---------27-----------------------

Photo by rawpixel.com from Pexels

还是只是装的？

如今，每个公司都声称自己是数据驱动的，但这实际上意味着什么呢？

这是一个需要回答的关键问题，对于选择投资地点的投资者和寻找合适公司的数据科学家来说都是如此。从投资者的角度来看，我想投资那些知道衡量什么、如何衡量、并真正利用数据推动合理决策的公司。作为一名数据科学家，我想为一家拥有有趣数据、在机器学习模型上投入时间和资源、拥有听取数据驱动建议的管理团队的公司工作。

在这篇文章中，我试图列出一个清单来判断一个公司是真的由数据驱动还是只是假装如此。

Photo by rawpixel.com from Pexels

清单

拥有数据 —这听起来很明显，但是一个数据驱动的公司首先需要拥有数据。这些数据需要清理、组织和访问。
有数据人 —这个听起来也很明显。它不需要是一个配备多名博士的全职研究型数据科学团队，但公司必须有一个知道如何收集、处理和分析数据的既定团队。数据团队应该与产品、营销和工程部门紧密合作，重点应该放在构建东西上，而不是发布白皮书。
领导者有影响力和关系——领导团队的人不一定是博士，甚至不必过于量化。对于数据团队的最高领导者来说，更重要的是要有政治影响力(在公司内部)、出色的商业(和常识)意识，以及识别好想法并将其付诸实施的能力。做了一些很酷的东西，然后看着它被浪费掉，这是非常令人沮丧的，因为你的老板缺乏将你的想法产品化的意志力或内部关系。
营销和产品领导者相信数据驱动的决策制定 —数据科学家经常做项目来支持他们公司的营销或产品(或产品营销)团队。如果被认为是你的分析的消费者的团队没有发现数据科学的价值，那么祝你在对抗这一潮流中好运。
有一个设计良好的应用程序——假设你的公司是面向消费者的，而不是严格意义上的 B2B(企业对企业)，拥有一个应用程序是非常关键的(如今一个像样的网站是桌面赌注)。人们随时都在打电话，你的公司需要能够通过移动应用程序与这些人联系。你的应用不需要像脸书或 Instagram 那样浪费时间，它只需要成为你的公司与其现有和潜在客户之间的额外接触点。这为您提供了更多的客户交互数据来收集和分析。
不聘请管理顾问——你喜欢放火烧钱吗？如果是这样，雇佣一群顾问，让他们告诉你你所在行业的“最佳实践”是什么(价格不菲)。但是，请等一下，如果他们告诉你所有击败你的竞争对手的秘密最佳实践，他们会对同样为咨询服务付费的竞争对手说些什么。认为你的公司从它的顾问那里得到任何突破性的建议或专有信息是天真的。相反，依赖顾问是一种迹象，表明你的公司缺乏答案和在内部产生答案的能力。我并不是说顾问永远不会帮助公司——他们可以帮助一家陷入困境的公司重新站起来。但一家强大的公司不应该需要顾问来告诉它需要去哪里。
倾向于建造而不是购买——有时当价格合适时(比如在经济衰退中)，购买是有意义的。但是，总是购买工具、人才甚至其他公司的倾向表明，你的公司可能正在努力并不顾一切地打出全垒打来重振旗鼓。同样有证据表明，与顾问类似，上层管理人员更信任外部专家，而不是内部产生的建议。
已经将基于假设的关键决策过程制度化——我把这个留到最后，因为我认为它是最重要的。你的公司应该不断尝试改进其产品和流程。它不应该通过盲目的直觉来做到这一点，而是通过形成假设，然后设计实验(尽可能无偏见地)来严格测试它们。最后，应该遵循从这些实验结果中得出的建议。操纵实验来证实管理层的偏见或推翻与预期不符的结果是巨大的危险信号——远离那些不惜一切代价这样做的公司。

关于第 8 条，我想说的是，在建立一家公司的过程中，直觉肯定是有空间的。伟大的公司和他们的产品和服务通常来源于一个伟大的想法，这个想法来源于某人的直觉。但是，没有数据支持的直觉只能让你在产品化和执行这个想法时走得更远——超过某个点，一个接一个地做出正确的决定变得更加重要。如果你的公司有一个基于假设的决策过程，这就容易多了(而且不太依赖运气)。

事实上，我认为基于假设的决策是将直觉正式引入公司决策过程的一种方式。它不像假说那样凭空神奇地出现。相反，它们是通过人们的直觉形成的(每个假设都是对我们周围世界如何运作的直觉猜测)。但是在执行这些猜测之前，首先严格测试它们是至关重要的。

造假的公司

因此，为了把所有这些联系起来，让我们回顾一下我们想要避免的公司可能是什么样子的。

这样的公司可能会有一些数据科学家。甚至可能会有一两个博士。但是他们大部分时间都脱离了公司的其他职能团队。大多数情况下，他们发布白皮书来擦亮公司的“数据凭证”。

To make a decision, your CEO rubs this card for luck then flips a coin… Facepalm

该公司的营销职能并不真正理解对“复杂”模型的需求。相反，他们只是要求初级数据科学家制作一堆数据透视表，以证实他们已经形成的偏见。当需要做出重大决定时，首席执行官会出去走走，神奇地做出决定，然后付钱给贝恩或波士顿咨询公司的顾问，让他们起草支持文件和数据。

是的，这有点夸张，但你会明白的。数据科学真的很酷。但是像任何其他职业一样，只有当你有机会创造重要的东西，推动决策制定，并最终为公司的使命和成功做出有意义的贡献时，你才会觉得有成就感。

祝你好运，找到配得上你的公司。干杯！

更多数据科学相关帖子由我:

数据科学家是做什么的？

数据科学家面临自动化的风险吗

数据科学家挣多少钱？

数据科学家挣多少钱第二部

软件工程师挣多少钱？

技能提升的更好方法

你的数据准备好 AI 了吗？

原文：https://towardsdatascience.com/is-your-data-ready-for-ai-dfa3e318fc09?source=collection_archive---------41-----------------------

公司正迫不及待地推出任何有望实现人工智能和机器学习的解决方案。但是仓促的采用留下了一个重要的问题没有得到解答。

你的数据准备好 AI 了吗？

对于大多数公司来说，答案是否定的。

每个领域的行业领导者都在竞相采用复杂的系统，这些系统承诺将人工智能和人工智能引入他们的组织。高管们经常被一种技术的概念所说服，这种技术将使他们能够看到人类看不到的东西，对业务提出建议或改变，从而释放新的机会并提高效率。

虽然机会肯定存在，在某些情况下技术也是如此，但与大多数组织的数据环境的运营就绪性相比， AI 和 ML 呈现的可能性之间存在重大脱节。

“AI 就像高中的性。每个人都说他们在做这件事，但很少有人真的在做，而那些在做的人都做错了。”

在我们与不同领域(金融、保险、房地产等)的许多市场领先公司的决策者的讨论中，我们看到的是对数据仓库的非常扎实的理解，以及对可以开始解决其业务需求的丰富应用层的非常强烈的渴望。

然而，事实上，数据仓库和应用层代表了一个过程的开始和结束，在这个过程的中间通常缺少的是一个非常复杂的堆栈，它将一端的原始数据转换为另一端的可用信息。问题是，这个“中间”层不仅是一个难以解决的问题，而且对于许多制定 it 战略、预算和时间表的决策者来说，它也是一个主要的未知数。

“如果沃森能赢得 Jeopardy，它一定有认知能力来涉猎我的数据并开发洞察力，对吗？”

通常，组织有一个数据仓库策略或一个完全部署的数据仓库解决方案，其重点是将数据放在一个地方。这一战略通常会附带一份已经购买的应用程序清单或使用新技术(人工智能、ML、自动化、分析、可视化)的解决方案路线图。从高层次来看，问题似乎已经解决了:

把所有的数据收集在一起——检查。

购买将原始数据转化为洞察力的应用程序—勾选。

这里的概念是，一旦我们把所有的数据放在一个公共的地方，我们就可以把它插入任何我们想要的东西。简单。问题是，从数据仓库出来的数据缺乏一个通用的标准，位于数据之上的应用程序无法完全实现，因为…

…在数据(有湖或无湖)和尚未定义或实施的企业应用程序之间有一个巨大的细化层。为了解决这个问题，需要引入一个系统，该系统能够将数据从其母语转换为任何应用程序都可以学习理解的集中标准。不仅如此，它还必须能够持续不断地做到这一点，并且能够扩展到无限数量的新的和现有的数据源。

即使是最好的软件也需要好的数据。

归根结底，任何应用程序、自动化或人工智能/人工智能技术都需要由精细化、标准化的数据来驱动，才能发挥其最大能力。如果没有标准数据，您希望实施的、有望彻底改变您的业务的改变游戏规则的技术将局限于 it 可以访问的标准数据的最低公分母。通常，这意味着信息量极其有限，即使这些信息现在都来自同一个地方。
数据需要被提炼为燃料，并以所需的数量交付给 it 负责驱动的应用程序。这样做的系统，或者更好的是，检查所有必需框的数据提炼过程，看起来像这样:

或者，对于那些对我们用我们的平台 【纳马拉 为我们的一些客户做的事情感兴趣的人，看起来是这样的:

许多真正成功的人工智能和人工智能技术的展示都是在极其干净和标准化的数据库的基础上展开的。但是在大多数组织中，数据仍然是完全隔离的。将数据集中到一个“湖”中或企业云上，可以将数据放在一个公共位置，但数据本身通常仍然缺乏标准化。这一层数据标准化仍然是许多组织尚未克服的巨大障碍。随着有远见的组织开始重视和利用新的外部数据源，问题的复杂性只会进一步增加。

各种各样的数据意味着各种各样的问题。

我们试图解决的问题是数据的多样性。适当的仓储有助于我们解决数量和速度问题，但一个完全开放的企业应用程序的世界要求我们回答这样一个问题:我们如何将来自多个地方的类似数据转换为一致的通用标准。

在许多组织中，答案是，“那是我们数据科学家的工作”。但如果我们真的去想，应该是吗？数据科学家是高技能、高收入的个人，他们的时间和精力应该集中在帮助企业以数据驱动的方式发展上。如果是这样的话，那么为什么他们会花这么多时间来查找、清理、标准化和监控数据呢？

简短的回答是，鉴于大多数组织没有合适的数据处理管道来生成理想的数据，以使他们的应用程序和科学家尽可能高效地工作，这是必然的。

这将大多数数据科学家变成了数据看门人，这也是大多数企业应用程序永远不会完全实现企业部署的原因。

“问题不在于缺乏方向或能力。缺少精确的数据。”

数据湖或云的想法是好的，也是必要的概念。数据需要被汇集到不同的位置，以便多个函数可以出于多种原因访问它。许多好事成为可能，因为人们开始意识到知道他们的数据在哪里以及它实际上是由什么组成的好处。

现在，当我们展望商业智能的下一个阶段，一个带来自动化、人工智能和机器学习的阶段时，我们必须少考虑湖中的数据，而更多地考虑数据需要如何以标准的方式在整个组织中流动。我们已经不再需要一个可以容纳数据的容器，而是需要一个血管系统，让数据以所需的形状和形式流向所需的地方。

这似乎是一个巨大的飞跃，但实际上，这是完全可以实现的。事实上，所需的许多部分都显示在上面的图形中。就您自己而言，这不是一个快速或简单的构建，但如果您真正从企业角度思考，这是一个必须解决的问题。

这里的要点是不要停止寻找可以帮助释放巨大潜力的新技术。要记住的是，不管新的解决方案有多么闪亮和惊人，它们都需要火箭燃料来帮助它们升空。当我们谈论改变游戏规则的企业应用程序时，火箭燃料是标准化数据。改进 it 的流程需要与采用新的 商业智能工具和应用并行实施。

阅读更多 关于我们如何提供干净的数据库来推动人工智能技术的发展。

Namara 是政府、银行和一些世界上最大的公司所依赖的数据管理平台。我们将 Namara 设计成最安全、最协作的方式来访问、管理和集成推动您业务发展的数据。 今天报名免费 。

在应用程序上联系我们，或 在这里联系我们 获得任何问题的答案。

【https://blog.thinkdataworks.com】最初发表于。

你的 Django 应用慢吗？去问数据科学家，而不是工程师

原文：https://towardsdatascience.com/is-your-django-app-slow-ask-a-data-scientist-not-an-engineer-3c120384ffd9?source=collection_archive---------16-----------------------

我的职业是工程师。在调查一个缓慢的 Django 应用程序时，我依靠直觉。这些年来，我已经解决了很多性能问题，我的大脑采取的捷径经常奏效。然而，直觉可能会失败。它在复杂的 Django 应用程序中可能会失败，这些应用程序有许多层(例如:SQL 数据库、NoSQL 数据库、ElasticSearch 等)和许多视图。噪音太大了。

如果我们不依赖工程师的直觉，而是像数据科学家一样进行性能调查，会怎么样？在这篇文章中，我将以数据科学家的身份，而不是工程师的身份，讲述一个性能问题。我将分享来自一个真实性能问题的时间序列数据和我用来解决这个问题的 Google Colab 笔记本。

问题第一部分:噪音太大

Photo Credit: pyc Carnoy

许多性能问题是由以下原因之一引起的:

一个缓慢的层——仅仅是许多层(数据库、应用服务器等)中的一层速度缓慢，影响了 Django 应用中的许多视图。
慢速视图 —一个视图正在生成慢速请求。这对整个应用程序的性能有很大的影响。
高吞吐量视图 —一个很少使用的视图突然看到流量涌入，并触发应用程序整体响应时间的峰值。

在调查性能问题时，我会从寻找相关性开始。是否有任何指标同时变差？这可能很难:一个拥有 10 层和 150 个视图的普通 Django 应用程序有 3000 个不同的时间序列数据集组合要比较！如果我的直觉不能快速隔离问题，我自己也几乎不可能隔离问题。

问题第二部分:幻影相关性

确定两个时间序列数据集是否相关是异常多变的。例如，尼古拉斯·凯奇每年出现在电影中的次数和游泳池溺水事件有关联吗？

伪相关性是一整本书都在讲述这些看似清晰却毫无关联的相关性！那么，为什么看时间序列图时，趋势似乎会引发相关性呢？

这里有一个例子:五年前，我所在的科罗拉多地区经历了一场历史性的洪水。它关闭了进入埃斯蒂斯公园的两条主要路线之一，这是通往落基山国家公园的大门。如果你查看埃斯蒂斯帕克许多不同类型企业的销售收入，你会发现道路关闭时收入急剧下降，道路重新开放时收入增加。这并不意味着不同商店的收入是相关的。商店只是受到了相互依赖的影响:一条封闭的道路！

从时间序列中去除趋势的最简单方法之一是计算 第一差值 。要计算第一个差值，从每个点减去之前的点:

y'(t) = y(t) - y(t-1)

这很好，但当我盯着图表时，我的视觉大脑无法将一个时间序列重新想象成它的第一个差异。

进入数据科学

我们面临的是数据科学问题，而不是性能问题！我们想要识别任何高度相关的时间序列指标。我们希望看到过去的误导趋势。为了解决这个问题，我们将使用以下工具:

Google Colab ，一个共享的笔记本环境
常见的 Python 数据科学库，如 Pandas 和 SciPy
从应用程序性能监控(APM)产品 Scout 收集的性能数据。如果您还没有帐户，请注册免费试用。

我将在 Google Colab 上浏览一个共享笔记本。您可以轻松保存该笔记本的副本，从 Scout 输入您的指标，并在您的 Django 应用程序中确定最重要的相关性。

第一步:在 Scout 中查看应用程序

我登录 Scout，看到下面的概览图:

花费在 SQL 查询上的时间从晚上 7 点到 9 点 20 分大幅增加。为什么？这很可怕，因为几乎每个视图都要接触数据库！

步骤 2:将图层时间序列数据加载到 Pandas 中

首先，我想寻找层(例如:SQL、MongoDB、View)和 Django 应用程序的平均响应时间之间的相关性。层(10)比视图(150+)少，所以这是一个简单的起点。我将从 Scout 获取这个时间序列数据，并初始化一个熊猫数据框架。我将把这个数据争论留给笔记本。

将数据加载到熊猫数据框架后，我们可以绘制这些图层:

步骤 3:层关联

现在，让我们看看是否有任何层与 Django 应用程序的总体平均响应时间相关。在将每个层时间序列与响应时间进行比较之前，我们要计算每个时间序列的一阶差。对于熊猫，我们可以通过diff()功能轻松做到这一点:

df.diff()

在计算了第一个差异之后，我们可以通过corr()函数寻找每个时间序列之间的相关性。相关值的范围从 1 到+1，其中 1 表示最可能一致，0 表示最可能不一致。

我的笔记本生成了以下结果:

SQL似乎与 Django 应用的整体响应时间相关。可以肯定的是，我们来确定皮尔逊系数 p 值。低值(< 0.05)表示总体响应时间很可能与 SQL 层相关:

df_diff = df.diff().dropna() p_value = scipy.stats.pearsonr(df_diff.total.values, df_diff[top_layer_correl].values)[1] print("first order series p-value:",p_value)

p 值正好是 **1.1e-54** 。我非常确信缓慢的 SQL 查询与整体缓慢的 Django 应用程序有关。总是数据库，对吧？

层次只是我们应该评估的一个维度。另一个是 Django 意见的响应时间。

如果视图开始响应缓慢，应用程序的整体响应时间可能会增加。我们可以通过查看我们的视图响应时间与整体应用程序响应时间的相关性来了解这种情况是否会发生。我们使用与图层完全相同的流程，只是将图层换成 Django 应用中每个视图的时间序列数据:

在计算每个时间序列的第一个差异后，apps/data确实与整个 app 响应时间相关。p 值仅为 **1.64e-46** ， **apps/data** 极有可能与 app 整体响应时间相关。

我们差不多完成了从噪音中提取信号。我们应该检查任何视图的流量是否会导致响应时间变慢。

步骤 5:冲洗+重复 Django 查看吞吐量

如果视图的吞吐量突然增加，很少使用的昂贵视图可能会影响应用程序的整体响应时间。例如，如果用户编写一个脚本来快速重新加载一个昂贵的视图，就会发生这种情况。为了确定相关性，我们将使用与之前完全相同的过程，只是交换每个 Django 视图的吞吐量时间序列数据:

endpoints/sparkline看似有小关联。p 值是0.004，这意味着有 4/1000 的几率不与endpoints/sparkline的流量和整体应用响应时间相关。因此，endpoints/sparkline视图的流量确实会导致应用程序整体响应时间变慢，但这比我们的其他两个测试更不确定。

结论

使用数据科学，我们已经能够对比直觉多得多的时间序列指标进行排序。我们也能够在没有误导趋势搅浑水的情况下进行计算。

我们知道 Django 应用的响应时间是:

与我们的 SQL 数据库的性能密切相关。
与我们的apps/data视图的响应时间密切相关。
与endpoints/sparkline流量相关。尽管我们对这种低 p 值的相关性很有信心，但它没有前两种相关性那么强。

现在是工程师的时间了！有了这些见解，我会:

调查数据库服务器是否受到应用程序外部的影响。例如，如果我们只有一台数据库服务器，备份过程可能会降低所有查询的速度。
调查对apps/data视图的请求的组成是否已经改变。例如，拥有大量数据的客户是否开始更多地使用这种视图？Scout 的 Trace Explorer 可以帮助调查这些高维数据。
推迟调查endpoints/sparkline的性能，因为它与整个应用程序响应时间的相关性不是很强。

重要的是要意识到所有来之不易的经验何时会失效。我的大脑根本无法像我们的数据科学工具那样分析成千上万的时间序列数据集。伸手拿另一个工具是可以的。

如果你想自己解决这个问题，请查看我在调查这个问题时使用的我的谷歌共享笔记本。下次您遇到性能问题时，只需从 Scout 导入您自己的数据，让笔记本为您工作！

原载于scoutapp.com。

你的机器学习模型有偏差吗？

原文：https://towardsdatascience.com/is-your-machine-learning-model-biased-94f9ee176b67?source=collection_archive---------6-----------------------

如何衡量模型的公平性，并决定最佳的公平性指标。

Photo by rawpixel on Unsplash

机器学习模型正越来越多地用于做出影响人们生活的决策。有了这种权力，就有责任确保模型预测是公平的，没有歧视。

ProPublica，一个独立的调查性新闻机构，在 2016 年 5 月 23 日出了一个令人不安的故事，标题是 机器偏见 。 它突出了美国司法系统的一个重大偏见，举了一个例子，一个名叫布里莎·博登的 18 岁女孩 。2014 年，布里沙因盗窃自行车被捕。她被指控盗窃 80 美元。就在一年前，41 岁的弗农·普拉特因在附近的家得宝商店偷了价值 86.35 美元的工具而被捕。普拉特是一名惯犯，过去曾因多次盗窃和持械抢劫被定罪。另一方面，Brisha 在少年时犯过一些小过错，尽管并不严重。

COMPAS，代表 惩教罪犯管理概况替代制裁 是美国各州用来评估刑事被告成为 累犯 的可能性的算法——这个术语用来描述重新犯罪的罪犯。根据 COMPAS 的评分，黑人博登被认为有更高的风险。白人 Prater 被评为低风险。

两年后，博登没有被指控任何新的罪行，而普拉特因另一项罪行正在服刑 8 年。 是算法全错了吗？

COMPAS scores comparison

ProPublica 与 COMPAS 的争议

ProPublica 对 COMPAS 工具的 的分析发现，黑人被告远比白人被告更有可能被错误地判断为处于更高的再犯风险，而白人被告比黑人被告更有可能被错误地标记为处于低风险。

(Source: ProPublica analysis of data from Broward County, Fla.)

Northpointe，该工具背后的公司回应说，该模型不是不公平的，因为它对白人和黑人都有几个类似的整体表现。为了证明这一点，他们查看了 AUC 分数

http://www.northpointeinc.com/files/publications/Criminal-Justice-Behavior-COMPAS.pdf

上表显示了非裔美国人和白人男性的任何逮捕结果的每个模型的结果。非裔美国男性的 AUC 从 0.64 到 0.73 不等，而白人的 AUC 从 0.69 到 0.75 不等。Northpoint 因此得出结论，由于白人男性的 AUC 结果与非裔美国男性的结果非常相似，他们的算法是完全公平的。

这给我们留下了一个非常重要的问题:我们如何决定哪种公平的衡量标准是合适的？在回答这个问题之前，让我们先了解一下模型是如何产生偏差的。

机器学习模型中的偏差

维基百科称，“……偏差是学习算法中错误假设的错误。高偏差会导致算法错过特征和目标输出之间的相关关系”。

今天，几乎每个领域都在使用机器学习模型。他们有能力决定一个人是否有资格获得住房贷款，一个人对什么样的电影或新闻感兴趣，一个人对广告有多大反应等等。机器学习模型也进入了刑事司法领域，并被用于决定罪犯在监狱等待假释的时间。但是我们如何确保这些模型没有偏见，没有不公平地歧视人们呢？

让我们考虑三种不同的情况:

案例 1:不同的组具有不同的基本事实阳性率

考虑以下美国乳腺癌统计数据:

https://www.breastcancer.org/symptoms/understand_bc/statistics

现在，如果我们要建立一个分类器来预测乳腺癌的发生，根据这些统计数据，女性患乳腺癌的频率将比男性高两个数量级，概率比大约为 12%比 0.1 %。因此，在这种情况下，不同性别之间的基本事实阳性率存在非常合理的差异，这将影响分类器的结果。

案例 2:数据是对基本事实的有偏见的表示

当一个受保护的属性(类似于性别、种族、年龄)在数据集内被赋值时，数据集可以包含标签偏差。让我们看看如何？

2011 年，发布了一篇论文，该论文回顾了美国 364 所中小学办公室纪律推荐的记录模式。作者发现提到:

描述性和逻辑回归分析表明，来自非裔美国家庭的学生因问题行为而被提交到办公室的可能性是白人同龄人的 2.19 倍(初级)到 3.78 倍(中级)。此外，结果表明，来自非裔美国人和拉丁裔家庭的学生比他们的白人同龄人更有可能因为相同或类似的问题行为而被开除或停学。

因此，如果我们有一个这样的数据集，并着手建立一个分类模型，预测一个学生将来是否会有行为问题，并使用“已被暂停”作为其标签，那么我们就存在标签偏差，因为在该模型中，不同的组被赋予不同的标签，这并不能准确反映实际的学生问题行为。

案例 3:当模型预测的结果很重要时。

如果我们正在制作一个惩罚性的模型，模型的
决策的结果将是负面的，这可能就像惩罚某人一样。在这种情况下，人们可能会更关心假
正以避免根据模型的输出惩罚无辜者。

另一方面，当一个模型是辅助性的，模型决策的结果将是正面的，我们会更关心假阴性，这样我们就不会浪费我们的资源或资源在那些
不需要我们提供的好处的人身上。

我们需要仔细思考我们的模型的后果，它可以告诉我们什么样的错误对我们很重要。偏见很容易被引入到我们的数据集中，我们需要选择合适的公平指标来处理不同的情况。

选择合适的“公平”指标

看起来有特定的公平性度量，但是，我们如何决定在特定情况下哪种公平性度量是必要的？在我们正在构建的模型或正在解决的问题的背景下，我们应该如何定义公平？嗯，今天有很多公平的度量标准被用来确保最终的模型没有偏见，但不幸的是，它们有其局限性。

1。不同的影响)

这种度量有时也被称为“统计奇偶校验”。在美国法律中，无意偏见是通过完全不同的影响来编码的，当选择过程对不同的群体产生非常不同的结果时，即使它看起来是中性的，也会出现这种情况。这一法律决定取决于受保护阶层的定义(种族、性别、宗教习俗)和对这一过程的明确描述。

Certifying and removing disparate impact, Feldman et al. (https://arxiv.org/abs/1412.3756)

换句话说，我们取两组的肯定分类的概率，然后取它们的比率。让我们借助一个例子来理解这个指标，在这个例子中，我们需要确定在一家公司招聘期间是否有不同的影响。

由于 60%小于 80%，因此存在完全不同的影响

权衡:正如我们所看到的，这个指标意味着基本事实的阳性率必须相同。然而，在上面讨论的案例 1 中，这种公平的衡量标准将会落空，因为不同性别之间的真实阳性率存在两个数量级的差异。

2。机会均等

这是另一个比较保护组之间真实阳性率的流行指标。在监督学习中，它是对特定敏感属性进行区分的标准，目标是基于可用特征预测某个目标。定义平等机会的论文节选:

在二元的情况下，我们常常把结果 Y = 1 认为是“有利”的结果，比如“没有拖欠贷款”、“被大学录取”或者“获得晋升”。一种可能的放宽均等优势的方法是只在“优势”结果组中要求不歧视。也就是说，要求偿还贷款的人首先有获得贷款的平等机会(没有对那些最终将违约的人提出任何要求)。这导致我们放松了我们称之为“平等机会”的观念。

Equality of Opportunity in Supervised Learning, Hardt et al. (https://arxiv.org/pdf/1610.02413.pdf)

权衡:同样，该指标无助于解决案例 2 中的情况。其中数据集包含标签偏差的可能性很高。“平等机会”衡量标准是基于与标签的一致，如果标签本身有偏见，那么我们就没有解决公平问题。

模型不仅仅是“数学”。

我们从上面的讨论中收集到的是，模型的“偏见”和“公平”具有潜在的伦理含义，因此我们仍然需要一些人类的判断来做出关于我们如何在我们的环境中定义和衡量公平的适当决定。

当机器学习模型首次被用于决策时，人们认为既然它们依赖于数学和计算，它们就应该是公平的。但是通过上面的例子，我们知道这个神话是如何被揭穿的。现在人们说，“加上这个约束会让我的模型变得公平”这还是不对的。我们不能仅仅依赖数学；我们仍然需要一个人来运用人类的判断。

解决方法是什么？

在真实世界的数据中检测偏差并不容易，也没有放之四海而皆准的解决方案。Civis Analytics，一家数据科学和分析公司进行了一项案例研究，该研究检验了六种不同的公平指标在预测中检测不公平偏见的能力，这些预测是由包含已知人工偏见的数据集训练的模型生成的。他们的一个发现是，“在评估机器学习设置的公平性时，从业者必须仔细考虑他们希望建模的基本事实中可能存在的不平衡，以及他们将用来创建这些模型的数据集的偏差来源”。

构建机器学习模型时可以采用的一些最佳实践是:

思考模型的输入和输出。
可用的公平性度量可以在一定程度上有所帮助。我们应该明智地使用它们。
使用多元化的团队来创建模型
总是研究数据，它的来源，也检查预测。
在训练模型时，可以采用一些方法来使其公平，但是应该清楚术语“公平”的含义和上下文。这些方法包括:

https://arxiv.org/pdf/1809.09245.pdf || https://arxiv.org/pdf/1412.3756.pdf

https://arxiv.org/pdf/1806.08010.pdf

结论

机器学习已经在许多应用和领域证明了它的实力。然而，机器学习模型的工业应用的关键障碍之一是确定用于训练模型的原始输入数据是否包含歧视性偏见。这是一个重要的问题，可能有伦理和道德的含义。然而，对此并没有单一的解决方案。对于模型的输出影响人们的情况，将公平置于利润之前是明智的。

参考 :本文灵感来源于Civis Analytics的 J. Henry Hinnefeld 题为“ 测量模型公平性 ”的精彩演讲。非常感谢他强调了人工智能和机器学习如此重要的一个方面。

你的 Numpy 是否针对速度进行了优化？

原文：https://towardsdatascience.com/is-your-numpy-optimized-for-speed-c1d2b2ba515?source=collection_archive---------13-----------------------

如何发现你的 Numpy 是否使用了快速 BLAS 库？

The Numpy Logo, Wikipedia.

如果您的研究工作高度依赖于基于数字的计算，如向量或矩阵的加法和乘法等。然后，建议运行一些检查，以查看 Numpy 是否使用了针对速度优化的三个库之一，而不是 Numpy 的默认版本。

有 4 个 Blas 和 Lapack 版本可供选择，据我所知，Numpy 会从下面的(2，3，4)库中选择一个，如果你的系统中没有这两个版本，它会默认使用第一个。

图书馆:

默认 BLAS 和 Lapack
OpenBLAS
英特尔 MKL
图集

基准

幸运的是，网上有两个基准测试，第一个是 2015 年制作的，比较了 OpenBLAS、英特尔 MKL 和 ATLAS，它倾向于 MKL 和 ATLAS，但值得注意的是，自 2015 年以来发生了很多变化。

Figure 1: a comparison of four BLAS libraries

第二张一张(图 1)是 2017 年的，更完整。它显示了所有四个库的比较，结果有利于 OpenBLAS，英特尔 MKL vs ATLAS，而 MKL 略微领先。对向量和矩阵乘法、奇异值分解、乔莱斯基分解和特征分解进行了比较。

哪个图书馆？

如果你想知道 Numpy 目前使用的是哪一个，简单的答案是:

导入 numpy
print(numpy . show _ config())

长回答就是你得挖开外壳，看看装的是哪个。

对于编号为< 1.10:

【

For Numpy≥1.10:

【

immediately after you will have to follow some symlinks.

$ldd /usr/lib/python2.7/dist-packages/numpy/core/_dotblas.so 
    linux-vdso.so.1 =>  (0x00007fff12db8000)
    libblas.so.3 => /usr/lib/libblas.so.3 (0x00007fce7b028000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fce7ac60000)
    libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007fce7a958000)
    libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007fce7a738000)
    /lib64/ld-linux-x86-64.so.2 (0x00007fce7ca40000)$ readlink -e /usr/lib/libblas.so.3
/usr/lib/openblas-base/libblas.so.3

Please note that these examples were pasted from this SO 的帖子。

非常感谢你阅读这篇文章，如果你有任何评论，请随时回复。

我要感谢我的同事巴拉克·亚伊尔·赖夫在这个问题上启发了我。

Ori Cohen 博士拥有计算机科学博士学位，主要研究机器学习。他是 TLV 新遗迹公司的首席数据科学家，从事 AIOps 领域的机器和深度学习研究。

隔离森林和火花

原文：https://towardsdatascience.com/isolation-forest-and-spark-b88ade6c63ff?source=collection_archive---------4-----------------------

PySpark 隔离带的主要特点和使用方法

隔离森林是一种用于异常/异常值检测的算法，基本上是一种找出异常值的方法。我们将介绍主要特征，并探索使用 Pyspark 隔离林的两种方法。

用于异常值检测的隔离林

大多数现有的基于模型的异常检测方法构建正常实例的简档，然后将不符合正常简档的实例识别为异常。[……][隔离森林]明确隔离异常，而不是剖析正常点

来源:https://cs . nju . edu . cn/Zhou zh/Zhou zh . files/publication/ICD m08 b . pdf

隔离意味着将一个实例从其余实例中分离出来

隔离林的基本特征

它使用正常样本作为训练集，并允许少数异常样本(可配置)。你基本上给算法提供了你的正常数据，如果你的数据集不是那么精确，它也不会介意，只要你调整了contamination参数。换句话说它学习正常看起来是什么样子，能够区分异常，
它的基本假设是异常很少并且很容易区分，
它具有低常数的线性时间复杂度和低存储器需求*，
它之所以快是因为它没有利用任何距离或密度度量，
能否很好的放大。对于可能有大量不相关属性的高维问题，它似乎工作得很好。

*低内存需求来自于这样一个事实，即不必完全构建森林中的每棵树，因为异常应该具有比正常实例短得多的路径，所以可以使用最大深度来切断树的构建。

隔离森林利用了异常现象的两个特征:它们是少数和截然不同的/不同的

异常分数和路径长度

检测异常的一种方法是根据路径长度或异常分数对数据点进行排序；异常是排在列表顶部的点

路径长度:到达外部节点之前的边数

Example of a path length calculation

异常分值

这基本就是算法的输出，分别是 ≤1 和≥0 。这就是图中路径长度的来源。通过估计整个森林的平均路径长度，我们可以推断出一个点是否异常。

如果一个实例的异常分数非常接近 1，那么可以肯定地说这个实例是异常的，如果它是< 0.5 then it is probably a normal instance and if it is ~= 0.5 then the entire sample does not have any distinct anomalies.

Important parameters in Isolation Forest

树的数量/估计者:森林有多大
污染:数据集包含异常实例的部分，例如 0.1%或 10%
max samples :从训练集中抽取的用于训练每棵隔离树的样本数。
最大深度:树应该有多深，这个可以用来修剪树，让事情变得更快。

该算法学习正常情况下的样子，以便能够区分异常情况

如何配合 PySpark 使用

sci kit-学习方法

Scikit-learn 方法需要我们创建一个 udf，以便能够根据数据帧进行预测。这是利用 Scikit-learn 模型的通常方式。注意，我们不能使用 spark 并行化训练部分——但是我们可以使用参数n_jobs=-1来利用我们机器上的所有内核。另一件需要记住的重要事情是将random_seed设置为特定的值，以便结果是可重复的。

我们需要做的就是安装 scikit-learn 及其依赖项pip install sklearn numpy scipy

然后我们可以从一个简单的例子开始，一个有四个样本的数据帧。

A simple example using a udf and broadcast variables for the classifier and the scaler

处理这个 udf 有多种方法，例如，您可以从一个文件加载 udf 中的模型(由于并行化，这可能会导致错误)，或者您可以将序列化的模型作为一个列传递(这将增加您的内存消耗很多)，但是我发现使用广播变量在时间和内存性能方面效果最好。

如果有更好的方法，请告诉我:)

火花-ML 方式

目前 Spark ML 库中还没有 iForest 的官方包。然而，我发现了两个实现，一个是 LinkedIn 的，只有 Scala 实现，另一个是杨的，可以和 Spark 和 PySpark 一起使用。我们将探讨第二个问题。

使用 spark-iforest 的步骤杨:

克隆存储库
构建 jar(为此你需要 Maven

cd spark-iforest/

mvn clean package -DskipTests

3.要么将它复制到$SPARK_HOME/jars/中，要么在 spark 配置中作为额外的 jar 提供它(我更喜欢后者，这样更灵活):

cp target/spark-iforest-<version>.jar $SPARK_HOME/jars/

或者

conf = SparkConf()
conf.set('spark.jars', '/full/path/to/target/spark-iforest-<version>.jar')spark_session = SparkSession.builder.config(conf=conf).appName('IForest').getOrCreate()

4.安装 spark-iforest 的 python 版本:

cd spark-iforest/python

pip install -e .   # skip the -e flag if you don't want to edit the project

我们已经准备好使用它了！再次强调，将随机种子设置为特定的可再现性是很重要的。

Pyspark Isolation Forest example using use spark-iforest by Fangzhou Yang

结果

在这两个例子中，我们使用了一个非常小而简单的数据集，只是为了演示这个过程。

data = [
    {**'feature1'**: 1., **'feature2'**: 0., **'feature3'**: 0.3, **'feature4'**: 0.01},
    {**'feature1'**: 10., **'feature2'**: 3., **'feature3'**: 0.9, **'feature4'**: 0.1},
    {**'feature1'**: 101., **'feature2'**: 13., **'feature3'**: 0.9, **'feature4'**: 0.91},
    {**'feature1'**: 111., **'feature2'**: 11., **'feature3'**: 1.2, **'feature4'**: 1.91},
]

该算法的两个实现都得出结论，第一个样本与其他三个样本相比看起来异常，如果我们看一下特征，这是有意义的。

请注意输出的不同范围:[-1，1]与[0，1]

Output of scikit-learn IsolationForest (-1 means anomalous/ outlier, 1 means normal/ inlier)
+--------+--------+--------+--------+----------+
|feature1|feature2|feature3|feature4|prediction|
+--------+--------+--------+--------+----------+
|     1.0|     0.0|     0.3|    0.01|        -1|
|    10.0|     3.0|     0.9|     0.1|         1|
|   101.0|    13.0|     0.9|    0.91|         1|
|   111.0|    11.0|     1.2|    1.91|         1|
+--------+--------+--------+--------+----------+Output of spark-iforest implementation (1.0 means anomalous/ outlier, 0.0 normal/ inlier):
+--------+--------+--------+--------+----------+
|feature1|feature2|feature3|feature4|prediction|
+--------+--------+--------+--------+----------+
|     1.0|     0.0|     0.3|    0.01|       1.0|
|    10.0|     3.0|     0.9|     0.1|       0.0|
|   101.0|    13.0|     0.9|    0.91|       0.0|
|   111.0|    11.0|     1.2|    1.91|       0.0|
+--------+--------+--------+--------+----------+

编辑:

似乎 IForest 目前只能处理DenseVector输入，而VectorAssembler同时输出Dense和Sparse向量。因此，不幸的是，我们需要使用一个udf将向量转换为Dense。

**from** pyspark.ml.linalg **import** Vectors, VectorUDT
**from** pyspark.sql **import** functions **as** F
**from** pyspark.sql **import** types **as** Tlist_to_vector_udf = F.udf(**lambda** l: Vectors.dense(l), VectorUDT())data.withColumn(
    **'vectorized_features'**,
    list_to_vector_udf(**'features'**)
)
...

结论

隔离森林，在我看来，是一个非常有趣的算法，轻便，可扩展，有很多应用。绝对值得探索。

对于 Pyspark 集成:
我广泛使用了 Scikit-learn 模型，虽然它运行良好，但我发现随着模型大小的增加，传播模型和完成一个预测周期所需的时间也会增加。不出所料。

我还没有对 PySpark ML 方法进行足够的测试，以确保两种实现给出相同的结果，但是在我在示例中使用的小型、无意义的数据集上，它们似乎是一致的。我肯定会对此进行更多的实验，以调查它的伸缩性和结果有多好。

我希望这是有帮助的，并且知道如何结合使用隔离森林和 PySpark 将为您节省一些时间和麻烦。任何想法，问题，更正和建议都非常欢迎:)

如果您想了解更多关于 Spark 的工作原理，请访问:

[## 用非技术性的方式解释技术性的东西——Apache Spark

什么是 Spark 和 PySpark，我可以用它做什么？

towardsdatascience.com](/explaining-technical-stuff-in-a-non-techincal-way-apache-spark-274d6c9f70e9) [## 向 Spark 数据帧添加顺序 id

怎么做，这是个好主意吗？

towardsdatascience.com](/adding-sequential-ids-to-a-spark-dataframe-fa0df5566ff6)

如果你来自熊猫世界，想要快速接触 Spark，请查看考拉:

[## 从熊猫到有考拉的派斯帕克

考拉项目使数据科学家在与大数据交互时更有效率，通过实现熊猫…

towardsdatascience.com](/from-pandas-to-pyspark-with-koalas-e40f293be7c8)

有用的链接

隔离林论文:https://cs . nju . edu . cn/Zhou zh/Zhou zh . files/publication/ICD m08 b . pdf

[## sk learn . ensemble . isolation forest-sci kit-learn 0 . 21 . 3 文档

class sk learn . ensemble . isolation forest(n _ estimators = 100，max_samples='auto '，contaminance = ' legacy '…

scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.IsolationForest.html) [## 逐步隔离森林

概观

medium.com](https://medium.com/@hyunsukim_9320/isolation-forest-step-by-step-341b82923168) [## 的的喀喀/火花森林

隔离森林(iForest)是一种关注异常隔离的有效模型。iForest 使用树结构来…

github.com](https://github.com/titicaca/spark-iforest) [## LinkedIn/隔离-森林

这是隔离森林无监督离群点检测算法的 Scala/Spark 实现。这个图书馆是…

github.com](https://github.com/linkedin/isolation-forest)

然后

使用 Shapley 值了解隔离森林的预测-按比例估计要素重要性:

[## 机器学习的可解释性——带有 PySpark 的 Shapley 值

解读隔离森林的预测——不仅仅是

medium.com](https://medium.com/mlearning-ai/machine-learning-interpretability-shapley-values-with-pyspark-16ffd87227e3)

异常检测:使用统计规则隔离森林

原文：https://towardsdatascience.com/isolation-forest-with-statistical-rules-4dd27dad2da9?source=collection_archive---------5-----------------------

这是一篇关于使用隔离林进行异常检测的后续文章。在上一篇文章中，我们看到了时间序列预测和分类的异常检测。对于隔离森林，我们必须处理污染参数，它将我们数据中的百分比点设置为异常。

虽然这可能是看到初始结果的一个好的开始，但这将使您陷入一个问题，在任何点 x%的点将被异常返回。让我们来看看一种可能的方法来避免它。

现在，让我们从在数据集上直接实施隔离林开始，该数据集的值为时间戳和 cpu_utilization:

链接到数据集(https://github . com/numenta/NAB/tree/master/data/realAWSCloudwatch)

import pandas as pd
import numpy as np
full_df=pd.read_csv('ec2_cpu_utilization_5f5533.csv')
full_df.head()

从 2 月 14 日到 2 月 28 日，我们在 5 分钟内有大约 4000 个数据点。

print(full_df['timestamp'].min())print(full_df['timestamp'].max())
print(len(full_df['timestamp']))

Min & Max Timestamps with number of data points

将这些点可视化，以了解时间序列数据的概况:

# Using graph_objects
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
import plotly.plotly as py
import matplotlib.pyplot as plt
from matplotlib import pyplot
import plotly.graph_objs as go
init_notebook_mode(connected=True)
import plotly.graph_objs as go
fig = go.Figure(data=[go.Scatter(x=full_df['timestamp'], y=full_df['value'])])
iplot(fig)

我将筛选特定一天的数据，以便进行简单的可视化。2 月 24 日似乎是一个很好的选择，因为数据中有一个下降和显著的峰值。

df=full_df.loc[(full_df[‘timestamp’]>’2014–02–24 00:00:00')&(full_df[‘timestamp’]<’2014–02–24 23:59:59')]
df.head()
plot_data=go.Scatter(x=df['timestamp'], y=df['value'])
fig=go.Figure(data=[plot_data])
iplot(fig)

现在，让我们开始将它与隔离森林模型进行拟合，根据我的直觉，将污染参数设置为 4%。

from sklearn.ensemble import IsolationForest
#to_model_column='value'
clf=IsolationForest(n_estimators=10, max_samples='auto', contamination=float(.04), \
                        max_features=1.0, bootstrap=False, n_jobs=-1, random_state=42, verbose=0,behaviour='new')
clf.fit(df[['value']])
df['scores']=clf.decision_function(df[['value']])
df['anomaly']=clf.predict(df[['value']])
df.head()df.loc[df['anomaly'] == 1,'anomaly'] = 0
df.loc[df['anomaly'] == -1,'anomaly'] = 1
df.value_counts()

def plot_anomaly(df,metric_name):
    df.timestamp = pd.to_datetime(df['timestamp'].astype(str), format="%Y-%m-%d %H:%M:%S")
    dates = df.timestamp
    #identify the anomaly points and create a array of its values for plot
    bool_array = (abs(df['anomaly']) > 0)
    actuals = df["value"][-len(bool_array):]
    anomaly_points = bool_array * actuals
    anomaly_points[anomaly_points == 0] = np.nan
    #A dictionary for conditional format table based on anomaly
    color_map = {0: "'rgba(228, 222, 249, 0.65)'", 1: "red"}#Table which includes Date,Actuals,Change occured from previous point
    table = go.Table(
    domain=dict(x=[0, 1],
                y=[0, 0.3]),
    columnwidth=[1, 2],
    # columnorder=[0, 1, 2,],
    header=dict(height=20,
                values=[['<b>Date</b>'], ['<b>Actual Values </b>'],
                        ],
                font=dict(color=['rgb(45, 45, 45)'] * 5, size=14),
                fill=dict(color='#d562be')),
    cells=dict(values=[df.round(3)[k].tolist() for k in ['timestamp', 'value']],
               line=dict(color='#506784'),
               align=['center'] * 5,
               font=dict(color=['rgb(40, 40, 40)'] * 5, size=12),
               # format = [None] + [",.4f"] + [',.4f'],
               # suffix=[None] * 4,
               suffix=[None] + [''] + [''] + ['%'] + [''],
               height=27,
               fill=dict(color=[df['anomaly'].map(color_map)],#map based on anomaly level from dictionary
               )
               ))
    #Plot the actuals points
    Actuals = go.Scatter(name='Actuals',
                     x=dates,
                     y=df['value'],
                     xaxis='x1', yaxis='y1',
                     mode='line',
                     marker=dict(size=12,
                                 line=dict(width=1),
                                 color="blue"))
    #Highlight the anomaly points
    anomalies_map = go.Scatter(name="Anomaly",
                               showlegend=True,
                               x=dates,
                               y=anomaly_points,
                               mode='markers',
                               xaxis='x1',
                               yaxis='y1',
                               marker=dict(color="red",
                                           size=11,
                                           line=dict(
                                               color="red",
                                               width=2)))
    axis = dict(
        showline=True,
        zeroline=False,
        showgrid=True,
        mirror=True,
        ticklen=4,
        gridcolor='#ffffff',
        tickfont=dict(size=10))
    layout = dict(
        width=1000,
        height=865,
        autosize=False,
        title=metric_name,
        margin=dict(t=75),
        showlegend=True,
        xaxis1=dict(axis, **dict(domain=[0, 1], anchor='y1', showticklabels=True)),
        yaxis1=dict(axis, **dict(domain=[2 * 0.21 + 0.20, 1], anchor='x1', hoverformat='.2f')))
    fig = go.Figure(data=[table, anomalies_map, Actuals], layout=layout)
    iplot(fig)
    pyplot.show()plot_anomaly(df,'anomalies')

print("Percentage of anomalies in data: {:.2f}".format((len(df.loc[df['anomaly']==1])/len(df))*100))

看起来不错，有一些小的错误异常，因为我们的绘图显示，我们已经捕捉到了重大的尖峰和其他一些下降和尖峰。现在让我们看看污染参数的作用。

Inliers occur together , it takes around 2 splits to separate x(i) whereas an outlier x(0) is separated in 4 splits

隔离森林将每个点从其他点中随机分离出来，并根据其分裂次数构建一棵树，每个点代表树中的一个节点。离群值出现在树中更靠近根的位置，而内嵌值出现在更深的位置。在隔离森林的情况下，基于 n_estimators 和 max_sample 参数创建森林，并从中得出分数。

可以使用score _ samples/decision _ function来获得每个点的归一化异常分数，这里越负，它就异常，基于 sklearn 计算。

直到这一步污染因素对分数没有影响。从这里开始，当我们应用 predict 以返回异常时，1/0 污染作为分数的临界值/百分点，并将前 x 个百分点的负分数作为异常返回。(例如:如果污染设定为 0.05/5%，那么负得分最高的 5%的点被标记为异常)

df['scores'].hist()

得分为正的内场球员在得分为正的右侧击球。分数为负的点是异常点。这是这个特定输入点的分数分布。一旦我们在此基础上最终确定了我们的模型，并预测了未来的点，那么我们的污染得分截止值可能会发生变化，给出 4%的异常点，但得分的分布可能会发生变化。为了克服硬编码的分数百分比总是被标记为异常而不考虑分数的变化，我们可以使用一些统计算法，如 Z-Score 或分数上的 IQR，来检测分数的变化并更好地对异常进行分类。

def iqr_bounds(scores,k=1.5):
    q1 = scores.quantile(0.25)
    q3 = scores.quantile(0.75)
    iqr = q3 - q1
    lower_bound=(q1 - k * iqr)
    upper_bound=(q3 + k * iqr)
    print("Lower bound:{} \nUpper bound:{}".format(lower_bound,upper_bound))
    return lower_bound,upper_bound
lower_bound,upper_bound=iqr_bounds(df['scores'],k=2)

df['anomaly']=0
df['anomaly']=(df['scores'] < lower_bound) |(df['scores'] > upper_bound)
df['anomaly']=df['anomaly'].astype(int)
plot_anomaly(df,'iqr based')

标记为异常的点的百分比在这里大约是 2%,在 IQR k 被设置为 2。

print("Percentage of anomalies in data: {:.2f}".format((len(df.loc[df['anomaly']==1])/len(df))*100))

现在让我们用另一个数据来验证这一点，考虑到同样的污染，以及 IQR 相同的 k 值:

df=full_df.loc[(full_df['timestamp']>'2014-02-17 00:00:00')&(full_df['timestamp']<'2014-02-17 23:59:59')]
# Using graph_objects
plot_data=go.Scatter(x=df['timestamp'], y=df['value'])
fig=go.Figure(data=[plot_data])
iplot(fig)

通过查看这一天的曲线图，数据看起来不同，异常更少。

from sklearn.ensemble import IsolationForest
#to_model_column='value'
clf=IsolationForest(n_estimators=10, max_samples='auto', contamination=float(.04), \
                        max_features=1.0, bootstrap=False, n_jobs=-1, random_state=42, verbose=0,behaviour='new')
clf.fit(df[['value']])
df['scores']=clf.decision_function(df[['value']])
df['anomaly']=clf.predict(df[['value']])
df.loc[df['anomaly'] == 1,'anomaly'] = 0
df.loc[df['anomaly'] == -1,'anomaly'] = 1
plot_anomaly(df,'anomalies')

print("Percentage of anomalies in data: {:.2f}".format((len(df.loc[df['anomaly']==1])/len(df))*100))

是的，这里我们从可视化中看到了更多的错误异常。这里的异常点百分比保持不变，因为我们对新时间帧的数据使用了相同的污染。

df['scores'].hist()

lower_bound,upper_bound=iqr_bounds(df['scores'],k=2)
df['anomaly']=0
df['anomaly']=(df['scores'] < lower_bound) |(df['scores'] > upper_bound)
df['anomaly']=df['anomaly'].astype(int)
plot_anomaly(df,'iqr second case')

print("Percentage of anomalies in data: {:.2f}".format((len(df.loc[df['anomaly']==1])/len(df))*100))

在这种情况下，异常值的百分比在这种方法中下降，因为分数中反映的数据分布已经改变。

在实时异常检测中，隔离森林上的统计规则组合会更好地工作，因为您会对未来的数据流进行建模、部署和预测，这些数据流的分布可能会随时间变化，并且新数据的分数会不同。

此外，IQR 的这个 k 参数可以基于对检测到的异常的反馈进行调整。如果有假阳性，那么 k 应该减少，如果有假阴性，那么 k 应该减少以发现更多的异常。

随后将介绍隔离林算法的一些细节，新增加的热启动和解释来自隔离林的结果。

加在 上:下面是一个多元的 异常 3d 可视化 用 情节性地表达 其中我发现很酷在所有 3 个维度上玩它，看看异常情况。

保序回归是你可能没听说过的最酷的机器学习模型

原文：https://towardsdatascience.com/isotonic-regression-is-the-coolest-machine-learning-model-you-might-not-have-heard-of-3ce14afc6d1e?source=collection_archive---------3-----------------------

术语“等渗”源自希腊语词根“iso”和“tonos”根“iso”不仅仅是一种文件格式，它实际上意味着等于。另一方面，“托诺斯”意味着伸展。等渗这个词可以指从材料和物理科学到文科的许多东西。

等拉伸回归(保序回归)是一个非常酷的统计推断模型。我对等渗回归的痴迷一直在扩大，因为这个模型实在是太有趣了，太酷了。

保序回归是一种自由形式的线性模型，可以用来预测观察值序列。然而，保序回归与加权最小二乘法等类似模型有两个主要区别。等张函数不能是非减函数。这是因为等张函数是单调函数，即保持或反转给定顺序的函数。

保序回归使用一个有趣的概念，称为“顺序理论”序理论将偏序集和预序集的概念作为实数的推广。这意味着一个等张函数总是以这样或那样的方式被扭曲，使用统计学来推断下一步该做什么。这很有趣，也很不同，因为大多数数学模型不会这么做。虽然贝叶斯数学肯定是相似的，但决策并不完全相同。

这个概念是众多使保序回归对多维标度极其可行的概念之一。多维标度是特征之间相关性的可视化。这种数学方法对于显示距离矩阵中的信息特别有用。

有趣的是，保序回归实际上完全基于另一个模型:

加权最小二乘法

但同时，完全不同。不幸的是，保序回归背后的数学对我来说太复杂了，我希望有一天能很好地掌握它，并将其实现到我的 Julia 包中。

幸运的是，一位了不起的统计学家 Fabian Pedregosa 经历了将等渗回归到 Python 中的过程，尽管它已经在 R 中使用了很长时间。

不管保序回归的可用性、复杂性或重要性如何，你必须承认:

这很酷

希望很快我就有时间学习并在车床上实现它，这样我们就可以把 Julia 添加到拥有它的语言列表中了！信不信由你，只有三大语言有保序回归的开源包！希望在未来，它将被扩展，并被更多地宗教化到语言中，尽管有多复杂！

它使用机器学习和 AWS Lambda 支持票据分类和部署

原文：https://towardsdatascience.com/it-support-ticket-classification-and-deployment-using-machine-learning-and-aws-lambda-8ef8b82643b6?source=collection_archive---------2-----------------------

支持话单分类和部署

IT Ticket Classification

项目描述和初始假设:

作为我们认知计算最终项目的一部分，我们决定解决一个现实生活中的业务挑战，为此我们选择了 IT 服务管理。在所有的商业案例中，我们感兴趣的是可能适合我们项目的四个用户案例。

1.在帮助台，几乎 30–40%的事件票证没有发送给正确的团队，票证一直在转来转去，当它到达正确的团队时，问题可能已经广泛传播并到达最高管理层，带来许多麻烦。

2.假设用户在使用打印机时遇到了一些问题。用户致电帮助台，他在 IT 支持人员的帮助下创建了一个票证，他们意识到需要更新用户系统中的配置，然后他们解决了该票证。如果 10 个其他用户报告了同样的问题，该怎么办？我们可以使用这些数据，并通过使用非结构化数据来分析潜在的问题。此外，我们可以分析趋势并最大限度地减少那些事故单。

3.可以响应和处理用户票证的虚拟机器人。

在这三个用例中，由于时间和资源的限制，我们决定先用第一个用例。

使用的工具和技术:

● ServiceNow 实例(IT 服务管理

平台)

● AWS Lambda 功能

● EC2 实例

● Python

●神经网络模型

●来自公开来源的 50000 多张样票

流程概述:

该过程的整个工作流程可以分成不同的子部分。下图显示了一个非常高层次的概述。

数据集:

我们直接从 servicenow 中提取数据集，并尝试使用 ML 技术对它们进行分类，以制作一个带标签的数据集。我们只是保留了票证中的描述和类别，并继续对其进行分析，以得出事件的前 5 个类别。

一旦我们使用主题建模对前 5 个事件类别进行了分类，就会添加标签

用例概述:

在典型的 IT 环境中，大多数关键问题都以票据的形式得到处理和跟踪。IT 基础设施是网络中连接在一起一组组件。因此，当一个组件发生故障时，它会带走许多其他组件。甚至可能需要几天时间来找出问题所在并找到根本原因。因此，有必要通知部件所有者

以便采取适当的措施防止这种情况发生。

这些问题通常由用户向帮助热线或服务台报告，他们是第一线支持人员。不幸的是，任何人都很难知道所有的组件，因此门票被发送到错误的团队。它到达最初的团队可能需要几天或几周的时间。因此，我们认为可以使用 NLP 来解决这个问题。

IT 服务管理平均生成 40 GB 以上的数据。这给了我们足够的数据来训练和实现我们的模型。

我们的模型如果实施得当，可以为业务部门节省数十亿美元，因为他们会因此失去许多服务级别协议。

基于云计算的 ITSM:

在云计算到来之前，这个商业案例几乎是不可能处理的。云计算首先使机器学习算法和 IT 服务管理之间的集成成为可能。

对于我们的业务案例，我们使用了一个名为 Servicenow 的基于云的 IT 服务管理应用程序，并使用 API gateway 访问了包装在 AWS lambda 函数中的机器学习模型。

【ServiceNow 与 AWS 的集成:

Web 服务使应用程序能够通过网络连接到其他软件应用程序，从而允许提供者(服务器)和客户(消费者)之间交换信息。

web 服务消费者(客户机)向 web 服务提供者(服务器)请求信息。web 服务提供者处理请求，并返回状态代码和响应正文。当返回响应体时，web 服务消费者从响应体中提取信息，并对提取的数据进行操作。

ServiceNow 可以使用来自第三方提供商或其他 ServiceNow 实例的 web 服务。

在我们的例子中，我们使用由 API 网关通过 Rest web 服务触发的端点 url，并使用在创建票证时运行的 javascript 来访问它。

在创建票证时，javascript 被触发，它将事件描述发送到我们放置在 AWS 中的模型，该模型执行机器学习操作并返回预测的类别和概率。

用于分类的主题建模

即使我们不确定主题是什么，我们也会提前选择主题的数量。

每个文档都表示为主题的分布。

每个主题都表示为单词的分布。

我们使用 NLTK 的 Wordnet 来查找单词、同义词、反义词等的含义。另外，我们使用 WordNetLemmatizer 来获取词根。

然后，我们逐行读取数据集，为 LDA 准备每一行，并存储在一个列表中。

带 Gensim 的 LDA

首先，我们从数据中创建一个字典，然后转换成单词袋语料库，并保存字典和语料库以备将来使用。

然后，我们尝试使用 LDA 找出 5 个主题:-

皮尔戴维斯

pyLDAvis 旨在帮助用户解释符合文本数据语料库的主题模型中的主题。该软件包从拟合的 LDA 主题模型中提取信息，以通知基于 web 的交互式可视化。

可视化 5 个主题:

通过主题建模，我们得出结论，整个数据集可以分为 5 类

网络

用户维护

数据库

应用工作台

安全

然后，我们相应地标记我们的数据集，并准备一个数据集来对其执行监督学习。

RNN 进行分类:-

端到端的文本分类管道由以下组件组成:

1.训练文本:它是输入文本，通过它我们的监督学习模型能够学习和预测所需的类。

2.特征向量:特征向量是包含描述输入数据特征的信息的向量。

3.标签:这些是我们的模型将预测的预定义类别/类

4.ML Algo:它是我们的模型能够处理文本分类的算法(在我们的例子中:CNN，，韩)

5.预测模型:在历史数据集上训练的模型，可以执行标签预测。

使用递归神经网络(RNN)的事件分类:

递归神经网络(RNN) 是一类人工神经网络，其中节点之间的连接沿着序列形成有向图。这允许它展示时间序列的动态时间行为。

使用来自外部嵌入的知识可以提高 RNN 的精确度，因为它集成了关于单词的新信息(词汇和语义)，这些信息是在非常大的数据语料库上训练和提炼的。我们使用的预训练嵌入是手套。

RNN 是一系列神经网络模块，它们像链条一样相互连接。每一个都在向下一个传递信息。

一大块神经网络 AA 查看某个输入 xtxt 并输出一个值 htht。环路允许信息从网络的一个步骤传递到下一个步骤。

这些循环使得循环神经网络看起来有点神秘。然而，如果你想得更多一点，就会发现它们与普通的神经网络并没有什么不同。递归神经网络可以被认为是同一网络的多个副本，每个副本都向后继者传递消息。考虑一下如果我们展开循环会发生什么:

LSTM 网络公司

长短期记忆网络——通常简称为“lstm”——是一种特殊的 RNN，能够学习长期依赖性。由hoch Reiter&schmid Huber(1997)提出，并在随后的工作中被许多人提炼和推广。它们在各种各样的问题上表现得非常好，现在被广泛使用。

LSTMs 的明确设计是为了避免长期依赖问题。长时间记住信息实际上是他们的默认行为，而不是他们努力学习的东西！

所有递归神经网络都具有神经网络重复模块链的形式。在标准 RNNs 中，这种重复模块将具有非常简单的结构，例如单个 tanh 层。

标准 RNN 中的重复模块包含一个层。

LSTMs 也具有这种链状结构，但是重复模块具有不同的结构。不是只有一个神经网络层，而是有四个，以一种非常特殊的方式相互作用。

LSTM 中的重复模块包含四个相互作用的层。

不要担心正在发生的事情的细节。稍后我们将一步一步地浏览 LSTM 图。现在，让我们试着适应我们将要使用的符号。

在上图中，每条线都承载一个完整的向量，从一个节点的输出到其他节点的输入。粉色圆圈代表逐点操作，如向量加法，而黄色方框是学习过的神经网络层。行合并表示连接，而行分叉表示其内容被复制，并且副本被移动到不同的位置。

LSTMs 背后的核心理念

LSTMs 的关键是单元状态，即贯穿图表顶部的水平线。

细胞状态有点像传送带。它沿着整个链条直线向下，只有一些微小的线性相互作用。信息很容易不加改变地沿着它流动。

LSTM 确实有能力删除或添加细胞状态的信息，由称为门的结构仔细调节。

门是选择性地让信息通过的一种方式。它们由一个 sigmoid 神经网络层和一个逐点乘法运算组成。

sigmoid 层输出 0 到 1 之间的数字，描述每种成分应该通过多少。值为 0 表示“不允许任何东西通过”，而值为 1 表示“允许任何东西通过！”

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

LSTM 按部就班地走过

LSTM 的第一步是决定我们要从细胞状态中丢弃什么信息。这个决定是由一个称为“忘记栅极层”的 sigmoid 层做出的。它查看 ht 1 ht 1 和 xtxt，并为单元状态 Ct 1 Ct 1 中的每个数字输出一个介于 00 和 11 之间的数字。11 代表“完全保留这个”，00 代表“完全摆脱这个”

让我们回到我们的例子，一个语言模型试图根据所有前面的单词预测下一个单词。在这样的问题中，单元状态可能包括当前主题的性别，以便可以使用正确的代词。当我们看到一个新的主题时，我们想忘记旧主题的性别。

下一步是决定我们要在单元格状态中存储什么新信息。这有两个部分。首先，一个称为“输入门层”的 sigmoid 层决定我们要更新哪些值。接下来，tanh 层创建一个新的候选值向量，C̃ tC~t，可以添加到状态中。在下一步中，我们将结合这两者来创建状态更新。

在我们的语言模型的例子中，我们希望将新主体的性别添加到细胞状态中，以替换我们遗忘的旧主体。

现在应该将旧的单元状态 ct1ct 1 更新为新的单元状态 CtCt。前面的步骤已经决定了要做什么，我们只需要实际去做。

我们用 ftft 乘以旧状态，忘记了我们早先决定忘记的事情。然后，我们添加 it∗c̃tit∫c ~ t。这是新的候选值，由我们决定更新每个状态值的多少来缩放。

在语言模型的情况下，这是我们实际删除旧主题的性别信息并添加新信息的地方，正如我们在前面的步骤中决定的那样。

最后，我们需要决定我们要输出什么。该输出将基于我们的单元状态，但将是过滤后的版本。首先，我们运行一个 sigmoid 层，它决定我们要输出细胞状态的哪些部分。然后，我们通过 tanhtanh 设置单元状态(将值推至 11 和 11 之间)，并乘以 sigmoid 门的输出，这样我们只输出我们决定的部分。

对于语言模型示例，由于它刚刚看到了一个主题，它可能希望输出与一个动词相关的信息，以防接下来会出现这个信息。例如，它可能输出主语是单数还是复数，这样我们就知道一个动词应该变成什么形式，如果接下来是什么的话。

长短期记忆的变异

到目前为止，我所描述的是一个非常正常的 LSTM。但并不是所有的 LSTMs 都和上面的一样。事实上，似乎几乎所有涉及 LSTMs 的论文都使用了稍微不同的版本。这些差异很小，但其中一些值得一提。

由 Gers & Schmidhuber (2000)提出的一个流行的 LSTM 变体，是增加“窥视孔连接”这意味着我们让栅极层查看单元状态。

上图给所有的门都加了窥视孔，但是很多论文会给一些窥视孔而不给另一些。

另一种变化是使用耦合的遗忘和输入门。我们一起做决定，而不是分别决定忘记什么和应该添加什么新信息。我们只会忘记何时在它的位置输入东西。只有当我们忘记旧的东西时，我们才会向状态输入新的值。

LSTM 的一个稍微戏剧性的变化是门控循环单元，或 GRU，由 Cho 等人(2014) 引入。它将遗忘门和输入门合并成一个“更新门”它还合并了单元格状态和隐藏状态，并进行一些其他更改。由此产生的模型比标准的 LSTM 模型更简单，而且越来越受欢迎。

我们的建筑

通用型号

LSTM 车型

要在文本数据上使用 Keras，我们首先必须对其进行预处理。为此，我们可以使用 Keras 的 Tokenizer 类。该对象将 num_words 作为参数，它是基于词频进行标记化后保留的最大单词数。

一旦在数据上安装了标记器，我们就可以用它将文本字符串转换成数字序列。这些数字代表每个单词在字典中的位置(可以把它想象成映射)。

在这个项目中，我们试图通过使用递归神经网络和基于注意力的 LSTM 编码器来解决这个问题。

通过使用 LSTM 编码器，我们打算在运行前馈网络进行分类之前，在递归神经网络的最后输出中编码文本的所有信息。

这非常类似于神经翻译机器和序列到序列学习。

我们在 Keras 中使用 LSTM 层来解决长期依赖的问题。

模型评分和选择

我们的模型评分和选择基于标准评估指标准确度、精确度和 F1 分数，定义如下:

其中:

TP 代表真正分类的数目。也就是说，具有实际标签 A 的记录已被正确分类或“预测”为标签 A。

TN 是真否定分类的数量。也就是说，实际标签不等于 A 的记录已被正确分类为不属于标签 A。

FP 是假阳性分类的数量，即实际标签不是 A 的记录被错误地分类为属于类别 A。

FN 是假阴性的数量，即标签等于 A 的记录被错误地分类为不属于类别 A。

图 3。预测分类与实际分类的“混淆矩阵”

预测和实际分类的组合被称为“混淆矩阵”，如图 3 所示。在这些定义的背景下，各种评估指标提供了以下见解:

准确性:正确的模型预测总数的比例。

精确度(也称为正面预测值):正确预测相对于该特定类别所有预测的比例。

召回率(也称为真阳性率、TPR、命中率或敏感度):真阳性相对于所有实际阳性的比例。

假阳性率(也称为假警报率):假阳性相对于所有实际阴性的比例(FPR)。

F1:(更稳健的)精确度和召回率的调和平均值。

输出:-

通用 RNN 型号:-

RNN 与 LSTM 层

观察:-

没有 LSTM 的一般 RNN 模型为我们提供了 66%的准确性，而我们能够使用 RNN 的 LSTM 网络层将其提高到 69%

低数据量导致准确性在 70%后几乎停滞不前，我们是否增加图中明显的时期并不重要。

然而，69%是足够公平的分类，因为我们打算在线训练它，并随着数据量增长到更高的程度而不断提高准确性。

模型部署

对于这个项目的范围，我们计划在亚马逊 AWS 上部署模型，并将其与服务集成，以便模型进行在线或实时预测。为此，我们将首先通过将模型转储到 pickle 文件中来导出模型。此外，我们将编写一个连接到 S3 桶的函数，从那里读取 pickle 文件并重新创建模型。

所以工作流程看起来是这样的:

立即创建服务中的事件
事件在 AWS 中接收，并且我们的 AWS EC2 实例或服务正在运行
从 S3 桶中获取 function.py 文件，该文件将从 Pickle 文件中读取模型并重新创建模型
它将从服务请求中提取特征，即事件描述
现在，代码将在 AWS Lambda 中执行，它将为我们提供事件所属的类别
在 AWS 上创建 EC2 实例:-
首先，创建一个 AWS 帐户，它将让你免费使用一年的一些有限的服务，但对这个项目来说已经足够了
创建一个 EC2 实例并选择自由层机器，或者如果您的帐户中有信用并且需要一个更强大的机器，您可以从其他选项中选择
在 AWS 上为 Python 配置一个虚拟运行时环境，完成后，将所有配置文件压缩到一个文件中，并在压缩文件中包含 function.py 文件，因为我们将在 AWS S3 存储桶中上传该文件
创建一个 S3 桶并上传包含模型详细信息(如模型名称、超参数和模型权重)的 pickle 文件，还上传包含 function.py 文件以及 python 虚拟环境配置设置的 zip 文件

现在，最后设置 AWS Lambda，这是我们将运行 python 脚本并进行预测的地方

AWS Lambda 是一种计算服务，让您无需配置或管理服务器就可以运行代码。它会自己处理那部分。AWS Lambda 最棒的一点是，你只需为你消耗的计算时间付费——当你的代码不运行时，是不收费的。有了 AWS Lambda，您几乎可以为任何类型的应用程序或后端服务运行代码——所有这些都无需管理。AWS Lambda 在高可用性计算基础设施上运行您的代码，并执行计算资源的所有管理，包括服务器和操作系统维护、容量供应和自动扩展、代码监控和日志记录。你所需要做的就是用 AWS Lambda 支持的语言之一来提供你的代码。

虽然我们无法配置 AWS lambda，因为我们都不熟悉它，必须浏览文档，时间不够。我们计划将该项目扩展到我们的其他课程并完成它。一旦我们达到目标，我们将更新博客。

ServiceNow 和 AWS 之间的集成:

Web 服务使应用程序能够通过网络连接到其他软件应用程序，从而允许提供者(服务器)和客户(消费者)之间交换信息。

ServiceNow 可以使用来自第三方提供商或其他 ServiceNow 实例的 web 服务。

在我们的例子中，我们使用 API 网关通过 Rest web 服务触发的端点 url，并使用创建票证时运行的 javascript 访问它。

在创建票证时，javascript 被触发，它将事件描述发送到我们放置在 AWS 中的模型，该模型执行机器学习操作并返回预测的类别和概率。

未来范围:

这个项目还没有完成，因为我们时间不够。我们正在进行这个项目，我们计划推进这个项目，以便我们可以在 AWS 上部署我们的代码，并将其与服务集成。一有进展，我们就会更新博客。😃

Github 链接:-

https://github.com/pankajkishore/Cognitive-Project

资源:-

https://medium . com/jatana/report-on-text-class ification-using-CNN-rnn-Han-f0e 887214 d5f

https://medium . com/datadriveninvestor/automation-all-the-way-machine-learning-for-it-service-management-9de 99882 a 33

[## karolzak/support-门票-分类

这个案例研究展示了如何为文本分析和分类创建一个模型，并将其作为 web 服务部署在…

github.com](https://github.com/karolzak/support-tickets-classification)

作者: Pankaj Kishore ， Anuja Srivastava ， Jitender Phogat 和 Karthik Kandakumar

现在是 2019 年，让您的数据可视化与 Plotly 互动

原文：https://towardsdatascience.com/its-2019-make-your-data-visualizations-interactive-with-plotly-b361e7d45dc6?source=collection_archive---------0-----------------------

使用 Express 和袖扣快速找到制作令人惊叹的数字的方法

如果您仍在使用 Matplotlib 在 Python 中进行数据可视化，那么是时候从交互式可视化库中查看视图了。

The view from the top of Mt. Plotly

Plotly 允许你只用几行代码就能制作出漂亮的、交互式的、可导出的图形。

Plotly Express examples from Plotly announcement

然而，没有地图，普洛特利山上的道路🗻会很慢而且令人沮丧。

以下是阻碍冒险者前进的绊脚石:

混乱的初始设置，在没有帐户的情况下脱机工作
一行又一行要写的代码
过时的文档
太多不同的 Plotly 工具，很难保持直线(破折号，快递，图表工作室，和袖扣)

经过几次尝试，我找到了地图、工具和到达山顶的捷径。在这篇文章中，我将带你上山，向你展示如何开始脱机工作，如何在一行代码中制作图形，然后调整它们，去哪里寻求帮助，以及什么时候使用什么工具。

我们开始爬山吧。这景色值得一看。相信我。😃

Plotly

普罗特利背后的公司也叫普罗特利。它已经开源了一系列交互式可视化产品。它通过为许多产品提供增强的功能来赚钱。它还提供收费的私人托管服务。该公司总部设在蒙特利尔，在波士顿设有办事处。

plotly.py 在幕后使用 D3.js 。Plotly 有 R、Julia 和许多其他语言 API 包装器。请注意，并非所有语言都有可用的示例文档。

Instruction options in Plotly docs

在本文中，我们将重点关注使用 Python 的选项。在本指南中，我使用 Python 3.7 和以下库版本。

cufflinks                0.15
jupyterlab               0.35.5
plotly                   3.8.1      
plotly-express           0.1.7

确保你用的是 0.15 的袖扣(0.13 和最近的 Plotly 版本不太搭)。

2020 年 5 月更新:Plotly 4.7.1 是最新版本。下面的大部分，但不是全部，仍然适用于新版本。注意 express 模块是作为 plotly 包的一部分导入的。

plotly.py

您不需要创建一个帐户来使用 Plotly，这与一些文档示例可能看起来的情况相反。使用 Plotly 也不需要在线。

将 vanilla plotly.py 模块安装在 conda 或pip install plotly中。

导入模块并将其配置为脱机工作:

import plotly.offline as pypy.init_notebook_mode(connected=False)

现在你不会得到一个错误，你需要一个帐户。我们已经通过了上山路上的第一个障碍。😄

这是一个交互式的地球仪图形的例子，它允许你用滑块轻松地改变投影类型和位置。由于媒体对文件类型的限制，您无法在此处与该图进行交互，但您可以在文档中与该图进行交互。

下面是一个冗长的要点，由制作这个奇特图形所需的文档改编而来的 plotly.py 代码。

Plotly 对象由一个或多个数据组件和一个布局组件组成。两者都有子组件。大部分(但不是全部)格式是在布局中控制的。

避免使用 vanilla plotly.py 的主要原因是图形定义通常很冗长。指定代码的行数和行数既慢又容易出错。我们无疑遇到了收养道路上的第二个障碍。幸运的是，我们通常可以选择两条备用路线中的一条，稍后我们将对此进行探讨。

如果我们确实需要继续使用老的 plotly.py 路径，我们将需要深入研究文档。官方文档很漂亮，但是经常让我花很长时间去寻找如何调整的方法。

Plotly 确实有一个不错的论坛这里也有一些有用的 SO 问题，但是很多例子没有更新来显示 plotly.py v3 代码。这里有 v3.0 迁移指南可以帮上一点忙。确保您正在寻找的任何示例都使用 v3，或者准备将它们翻译成 v3。

接下来我们要看的两个 Plotly 产品提供了简化 plotly.py API 的高级包装器。如果你和熊猫一起工作，他们可以节省你大量的时间。让我们探索这些替代路线。

Forrest path

表达

Plotly Express 于 2019 年 3 月发布，正在积极开发中，支持更多图表。计划是 2019 年夏天折叠成 Plotly 4.0。

Express 可以将从熊猫数据帧中制作许多图形所需的代码减少 10 倍。Express 希望您的数据帧以整齐的格式到达，其中每行代表一个观察值，每列代表一个变量。

用pip install plotly_express安装 Express。

要在 JupyterLab 中使用它，请在您的终端中运行以下命令:

jupyter labextension install @jupyterlab/plotly-extension

下面是使用传统的快速导入从数据帧制作条形图的代码:

import plotly_express as px px.bar(my_df, x='my_x_column', y='my_y_column')

维奥拉。你已经从你的数据框架中得到了一个条形图(在我上面有“我的 _”的地方替换你的东西)。

您可以调整单线图定义中的许多值。例如，通过更改定义来添加标题，如下所示:

px.bar(my_df, x='my_x_column', y='my_y_column', title='My Chart Title")

如果你想深入到一个特定的设置，你可以返回底层的 Plotly 图。假设您想要将文本值添加到您的条形图中。您需要保存自动返回的图形并引用其数据属性。你可以这样做:

_my_fig = px.bar(my_df, x='my_x_column', y='my_y_column', title='My Chart Title')_my_fig.data[0].update(
    text=my_df['my_y_column'],  
    textposition='inside',
    textfont=dict(size=10)
)_my_fig.iplot()

预警:我发现了快递文档！它在我的谷歌搜索中没有排在前列，所以我有一段时间没有找到它。现在你有了。尽情享受吧！😃

Express 允许您快速制作许多图形类型，但并不是您想要的所有类型都可用。例如，堆积条形图目前不是一个简单的选择。对于那些你想带着袖扣走另一条路到达山顶的人。

The other path

袖扣

袖扣与 Express 非常相似，因为它是 Plotly API 的包装器，以简化与熊猫的工作。袖扣是一个第三方开源项目，已经存在了四年多。

用pip install cufflinks安装。

导入模块并配置文件以供脱机使用。

import cufflinks as cf
cf.set_config_file(offline=True)

许多体型只需要一行袖扣代码。例如，堆积条形图是一件轻而易举的事。

Example cufflinks stacked bar chart

代码如下:

df = pd.DataFrame(np.random.rand(6, 3), columns=['A', 'B', 'C'])df.iplot(kind='bar', barmode='stack', title='Stacked Bar Chart with Random Data')

请注意，您将使用.iplot()制作袖扣造型。

像 Express 一样，Cufflinks 返回基本的 Plotly 数字，以便您可以进行更精细的修改。与袖扣不同，您需要在您的图形定义中指定asFigure=True来返回图形。然后，您可以像在 Express 中一样更新图形。如果你想改变 yaxis 的名称和范围，这里是它的样子。

my_fig = df.iplot(kind='bar', barmode='stack', title='Stacked Bar Chart with Random Data', asFigure=True)_fig.layout.yaxis = dict(title='Members', range=[0, 600])

这是袖扣文档。

不幸的是，有些东西用袖扣是做不到的，比如散点图。

3 个选项的比较

下面是用 plotly.py、Express 和 Cufflinks 创建的图形的类似布局的代码比较。

plotly.py

fig = {
    'data': [
        {
            'x': df2007.gdpPercap, 
            'y': df2007.lifeExp, 
            'text': df2007.country, 
            'mode': 'markers', 
            'name': '2007'},
    ],
    'layout': {
        'title': "Example Scatter Plot with Vanilla plotly.py"
    }
}py.iplot(fig)

表达

px.scatter(
    df2007, 
    x="gdpPercap", 
    y="lifeExp", 
    title='Example Scatter Plot with Plotly Express'
)

那就是又短又甜！默认格式有点不同，您可以自动获得轴标题。让我们看看袖扣中的相同图表。

袖扣

df2007.iplot(
    kind='scatter', 
    mode='markers', 
    x='gdpPercap', 
    y='lifeExp', 
    title='Example Scatter Plot with Cufflinks'
)

这是非常相似的代码，但是图中的默认值略有不同。

快递和袖扣都可以节省你的按键次数。⌨️对于许多更复杂的图表来说尤其如此。😃

让我们看看如何返回和访问底层 plotly 数字。

更新 Cufllinks 和 Express 图

让我们访问由袖扣创建的图形的布局，并添加轴标题。

fig = df2007.iplot(
    kind='scatter', 
    mode='markers', 
    x='gdpPercap', 
    y='lifeExp', 
    asFigure=True,
    title='Example Scatter Plot with Cufflinks - Access Underlying Figure'
)fig.layout.xaxis.title = "GDP per Capita"
fig.layout.yaxis.title = "Life Expectancy"fig.iplot()

以下是如何用 Express 做同样的事情。回想一下，使用 Express，您不需要指定asFigure=True。

fig = px.scatter(
    df2007, 
    x="gdpPercap", 
    y="lifeExp", 
    title='Example Scatter Plot with Plotly Express - Access Underlying Figure'
)fig.layout.xaxis.title = "GDP per Capita"
fig.layout.yaxis.title = "Life Expectancy"fig.iplot()

您可以访问第一个数据跟踪来添加文本标签，如下所示:

fig.data[0].update(
 text=df2007['gdpPercap'],
 textposition=’inside’,
 textfont=dict(size=10)
)

在 plotly.py、Express 和袖扣中选择

空间真的很混乱。不久前的某个时候，我以为我在一个项目的某个部分使用了 Express，当时我正在使用袖扣！🤦‍♂

我是 Python 的中的禅的忠实粉丝:“应该有一种——最好只有一种——显而易见的方法来做这件事。”两种方式导致研究时间、选择疲劳和错误。

不幸的是，现在没有一个单一的高级 API 来制作每种图形类型。不过，我肯定会尽可能使用袖扣或快递。

当你想建立一个数字时，我建议你检查快递和袖扣文档。请记住，快递需要整洁的数据框架，而袖扣更灵活。使用两个库中符合您的需要并且格式最接近您想要的格式的库。袖扣是我首先要找的地方。

这两个库之间的默认格式可能非常引人注目。例如，对于数据帧中 X、Y 和 Z 列的一些随机数据，您可以通过以下袖扣代码获得:

df.iplot(kind=’scatter’, mode=’markers’, x=’X’, y=’Y’, title=’Random Data’, categories=’Z’)

Cool Default Cufflink Scatter Plot

或者这个用这个明示的代码:

px.scatter(df, x=’X’, y=’Y’, color=’Z’, title=’Random Data’)

Different Presets with Express

那是相当不同的！

保存文件

一旦你创建了一个图形，你可以将鼠标悬停在它上面，点击相机图标，将其导出为. png 文件，或者点击导出到 plot.ly 链接，将互动图像保存到 Plotly 的服务器上。

或者，您可以下载交互式 HTML 格式的文件，如下所示:

py.offline.plot(my_fig, filename=’my_example_file.html’)

如果你需要更多的图像格式，你可以使用 Plotly 的 orca 包下载文件格式包括。png，。你需要先安装 orca。该软件包目前在 pypi.org 上不可用，所以你不能用 pip 安装它。你可以通过 conda 安装它，也可以从 orca GitHub 页面安装特定于操作系统的版本。那么就不需要导入 orca 库了。点击阅读更多关于虎鲸的信息。

下面是安装 orca 后创建一个. png 文件的代码。

import plotly as plotly
plotly.io.write_image(fig, file='my_figure_file.png', format='png')

正如你所看到的，有几种方法可以让你的数字脱离 Plotly。😃

让我们简单介绍一下 Plotly 生态系统的另外两个组件，这样你就知道什么是什么了。

破折号

使用 Plotly [Dash](http://Dash is a Python framework for building analytical web applications.) 你可以使用 Python 为你的团队或世界制作 web 应用仪表板。截至 2019 年 5 月 1 日，有近 9000 个 GitHub 明星的免费开源版本。Plotly 提供了一套 Dash 附加组件。我没怎么用过 Dash。也许这将是未来文章的重点。跟着我确保你不会错过。😄

图表工作室

Plotly Chart Studio 让您在浏览器中轻松创建或编辑图表。Plotly 称其为“世界上最复杂的创建 D3.js 和 WebGL 图表的编辑器”。不需要编码。有一个免费版本，但如果你想保存私人图表文件，年费从 99 美元起。

既然我们已经登上了 Plotly 山顶，让我们快速浏览一下 Python 范围内的其他数据可视化山峰。

额外收获:其他 Python 数据 Viz 选项

本文并不打算详尽地介绍数据可视化选项，但是我将提到数据科学家需要了解的其他几个重要选项，这样您就有了一个相当全面的了解。

用 Python 制作可视化的老方法是使用普通的 Matplotlib API。

熊猫 Matplotlib API 很适合快速绘制。它创建常规的 Matplotlib 对象。

Seaborn 是一个优秀的 Matplotlib 高级包装器，可以让你快速制作多种类型的统计可视化。不幸的是，这些选项不是交互式的，并且是建立在一个 15 年历史的 Matplotlib 基础上的，这个基础不是非常容易使用。

散景是 Plotly 的竞争对手。它是开源的、交互式的，并且与 Python 兼容。

Holoviews 是 MatplotLib、Bokeh 和 now Plotly 的高级包装器。我知道有人喜欢全息视图。

r 乡亲们喜欢 RStudio 的闪亮。它让用户创建交互式 web 应用程序可视化。

Tableau 和 Microsoft PowerBI 是另外两个与 Python 集成的流行的拖放数据可视化创建选项。Tableau 真的很好，但是需要你付钱来保持你作品的私密性。

我发现 PowerBI 有点不太直观，但它也非常强大，非常受欢迎。

上面列出的大多数交互式图形软件都使用 D3.js。超级受欢迎。

包装和资源

如果你是一名数据科学家，我鼓励你仔细检查。这是一个制作交互式可视化的现代工具箱。从山顶上看，似乎这个神秘的庞然大物不太可能很快减速。

也许最终会有一种清晰的方法，使用 Ploly 的高级 API 选项来制作你想要的任何东西。现在，我建议你尽可能用熊猫搭配袖扣或 Express，以节省时间并做出令人惊叹的可视化效果。

这里有一些很好的 Plotly 资源:

Will Koehrsen 在这里有一个很好的袖扣入门指南。
下面是 plotly.py 首席开发人员 Jon Mease 的演讲，展示了在 JupyterLab 中使用 plotly.py v3.0 可以做些什么。你可以在你的笔记本上得到帮助，制作一些非常酷的小部件。如果你还没有切换到在 JupyterLab 中运行你的 Juypter 笔记本，这可能是你需要的推动力。😃

PSA:当你使用颜色时，考虑一下色盲人群的可及性。使用色盲友好的调色板很容易。这是我从 ggplot 中采纳的一个。

Color swatch

color_list = ["#E69F00", "#56B4E9", "#009E73", "#F0E442", "#D55E00", "#0072B2",  "#CC79A7"]

我写关于数据科学、Python 和 DevOps 的文章。查看我的文章这里如果你对这些感兴趣的话，注册我的时事通讯。

快乐的阴谋！

这很容易:神经网络导论

原文：https://towardsdatascience.com/its-a-no-brainer-an-introduction-to-neural-networks-10e2738c2d7e?source=collection_archive---------20-----------------------

神经网络的温和介绍，现在与僵尸。

神经网络是 1944 年首次提出的一种人工智能方法。神经网络大致模拟人脑，由大量简单的处理节点(称为神经元)组成，这些节点高度互联，并通过这些网络连接发送数据以估计目标变量。

在这篇文章中，我将讨论简单神经网络的结构和训练(特别是多层感知器，又名“香草神经网络”)，以及演示一个简单的神经网络。

问题:为什么僵尸只和聪明的女人约会？

答案:他们只是喜欢有头脑的女人。

神经网络如何工作

一般来说，神经网络模型由成千上万个密集连接的神经元(节点)组成。在大多数神经网络模型中，神经元被组织成层。这包括输入层和输出层，输入层包括所有提供的预测变量的神经元，隐藏层。神经网络的隐藏层有效地将输入转换成输出层可以解释的东西。输出图层返回类别标注(分类)或估计值(回归)。

在每个神经元处，所有输入值被加在一起，然后用激活函数(例如 sigmoid 函数)进行处理，这将确定神经元是否被“激活”。通常，在激活函数之前，偏差也将包括在该计算中。偏差类似于回归模型中的截距项。

然后使用阈值来确定神经元是否会“触发”，这意味着激活所有到下一层的传出连接。神经网络可以是前馈，意味着所有数据只向前传递，或者是递归，可以包括通过网络层的循环或回路。多层感知器只是前馈。

神经元之间的每个连接都被赋予一个(正的或负的)数字权重。对于每个连接，当一个神经元达到或超过给定阈值时，这个权重乘以神经元的数值，将被传递给下一层中连接的神经元。如果没有达到阈值，神经元将不会被激活，并且来自该神经元的数据将不会传递给下一层中的任何神经元。

在分类模型中，输出层中具有最高值的神经元将确定每个记录的模型估计标签。对于回归模型，神经网络通过单个输出节点返回值。

如果这个快速概述没有意义，或者如果你想知道更多关于数学的知识，3BLUE1BROWN 有一个非常棒的视频叫做，但是我推荐观看什么是神经网络。

如何训练神经网络

多层感知器神经网络通常使用一种称为反向传播的方法进行训练，这涉及通过计算成本(损失)函数的梯度来调整神经网络中神经元的权重。

为了开始训练神经网络，所有的初始权重和阈值都是随机生成的。然后，训练数据通过输入层输入，并通过模型，直到到达输出层。在输出层，计算成本函数以估计模型在估计已知目标变量中的表现。当网络自信地估计正确的值时，成本函数的输出被最小化，并且随着错误分类而增加。训练算法的目标是最小化成本函数值。

然后调整神经网络中的权重和阈值，以最小化成本函数(这是微积分部分)，直到模型收敛于局部最小值。重复该过程，并且基于训练数据和成本函数继续调整权重和阈值，直到具有相同标签的所有数据产生相似的值。

3BLUE1BROWN 关于神经网络系列的第 2 部分和第 3 部分分别涵盖了训练和反向传播，如果您想了解更多，可能会对您有所帮助。还有一本关于神经网络和深度学习的优秀开源教科书，作者是迈克尔·尼尔森(Michael Nielsen)，这里有。

前馈神经网络的剖析

R 包 nnet 可以生成一个简单的单隐层前馈神经网络。前馈指的是数据可以在层间传递的方向。前馈模型只能向“下游”传递数据。单一隐藏层也是这个特定实现的一个重要方面。虽然用户可以调整隐藏层中包含的神经元数量，但隐藏层的数量不能增加。这些神经网络确实属于多层感知器的类别。

具有单个隐藏项的经过训练的前馈神经网络的结构可能如下所示:

浅绿色的线(浅绿色)是负权重，深绿色的线(青苹果)是正权重。线条粗细用于描述分配给每个连接的相对权重。

预测变量(如果你还没有猜到，这个神经网络是用臭名昭著的虹膜数据集训练的)包括在第一层中。

图顶部描绘的偏置层(粉红色)将常数值应用于神经元(类似于回归模型中的截距项)。隐藏层的激活函数将是 sigmoid ，输出层的激活函数将取决于目标场。二元分类将使用逻辑激活函数，多项式分类将使用 softmax 函数，回归(具有连续目标变量的模型)将应用线性激活函数。

用于训练模型的成本函数(使用反向传播方法)也将取决于目标变量。对于分类模型(目标变量是分类的)，成本函数是称为交叉熵的熵度量。对于回归模型(目标变量是连续的)，用于训练神经网络的成本函数是残差平方和。

数据集中的每个记录(观测值)都通过这个网络传递。根据预测变量的值，每层中的不同神经元将被激活，从而对输出层中的记录进行估计。

希望，这已经打破了神经网络周围的坚硬外壳，让你能够消化好的，多肉的部分。

这篇文章最初发表在 Alteryx 数据科学博客上，可以在这里找到。

这完全是关于信任:对向您的组织开放数据的看法

原文：https://towardsdatascience.com/its-all-about-trust-views-on-opening-up-data-to-your-org-ce2fe99174ac?source=collection_archive---------11-----------------------

“民主化”的数据和洞察力，开放访问，数据透明，它有很多名字，很多人想要它，但对你来说正确的决定取决于你的组织。

今天我只讨论信任问题的各个层面，技术/实践方面的考虑留待以后再说。

每个组织都需要决定谁有权访问这些数据，无论是隐式的还是显式的。届时，贵公司的“正确”答案将是独一无二的。作为数据科学家，我们经常被视为良好数据实践的管理者，并经常被要求成为推动数据驱动文化的领导者。但是我们如何决定做什么呢？

为什么“数据民主化”经常出现？

广泛共享数据的基本愿望源于组织中的信息自然倾向于留在组织的本地部分。您让财务团队查看他们的数据，让客户支持团队查看他们的数据，让产品团队查看他们的产品指标。除非有跨组织边界推送或拉取信息的积极努力，否则事情往往会因为惯性而停留在本地。

从表面上看，计算似乎很简单:组织中的所有人都需要做出决策。做出好的决策需要好的证据和数据，这些数据来自整个组织。因此，我们应该确保决策者可以访问他们需要的数据，以最大限度地提高他们的效率。

然而，多年来在许多科技公司工作，我目睹了公司如何。在一个极端，你会发现一些公司根本不愿意让员工接触大量信息和数据。在另一个极端，有些公司几乎无一例外地允许访问任何东西。您在这个范围中的位置似乎取决于您特定的组织现实。

很多不同的观点，感谢 DS-Twitter！

我最近很好奇不同的数据科学家认为他们的公司在数据民主化光谱中处于/应该处于什么位置，所以我在 Twitter 上问了一些人。

有这么多好的回答，我会试着总结和强调一些例子。

不同种类的信任

当综合我自己的经验和我得到的广泛反馈时，我似乎很清楚，公司内部数据共享的范围围绕着几种不同的信任。你在每个轴上所处位置的独特组合决定了你所分享的内容，而改变你所分享的内容就意味着改变你所处的位置。

#1 —访问

我们可以从最明显的轴开始，谁可以访问什么数据开始。首先，这有许多外部限制。例如，遵守法规可能会严格限制哪些人可以访问某些类型的数据，医疗保健数据、个人数据、信用卡数据都属于这一类。这些通常是不可协商的，必须导航。

然后是敏感数据，如公司机密、计划等。你可以在一定程度上分享这些信息，只要你信任有权限的人。一些组织完全不相信某些级别的员工有任何与此类信息相关的东西，其他组织几乎分享所有信息。这是组织愿意进行风险权衡的结果。

但是除了这些敏感的数据之外，还有非常广泛的数据可以帮助人们更好地完成工作，而不会带来重大风险。我认为公司的大部分数据都属于这个范围。我的观察是，倾向于雇用数据科学家和分析师的公司已经有了在公司范围内由数据驱动的某种程度的愿望，所以访问限制往往是在光谱的更开放的一边。

在这种背景下，我并不感到特别惊讶，许多数据科学家似乎倾向于在可行的情况下让人们更多地访问数据。这是下一个信任轴上的“实用”部分。

#2 —个人数据素养

当数据在公司范围内可访问时，管理人员普遍关心的一个问题是“如果有人获取了数据，进行了错误的分析，并据此做出了糟糕的决策，该怎么办？护栏在哪里？”这是公司内部数据素养状态的一个基本问题。这里有两类人，一类是糟糕的演员，一类是根本不具备分析技能的人。

人们真的很担心不良行为者会利用不良数据来证明不良、T2 甚至恐怖的决策是没有保障的。然而，一群好人人附和道，这种不确定决策的风险总是存在的，不管数据是否可用。组织中有不良行为者是一个更大的组织问题，而不仅仅是数据问题。

相反，许多更多的人，包括我自己在内，把拥有不具备分析技能的人作为一个教育和培训的机会。人们，甚至那些没有数据凭证的人，都被鼓励与数据打交道。需要注意的是，当他们想用数据来做决定时，他们应该让更擅长数据的人来检查他们的工作。它为数据科学家/分析师等提供了一个学习更好方法的机会，同时也对数据有了更多的关注，寻找机会和不一致之处。

强大的流程和学习数据素养的文化可以充当护栏。是的，对于一个外行人来说，查看数据并利用它来弄清楚他们在组织中的角色是如何工作的是没问题的，尤其是如果数据已经在某种程度上被清理和策划的话。但前提是他们意识到自己不是使用数据的专家，并且有一个支持网络参与其中。这是一种“信任，但要核实”的心态，在许多实际情况下都行得通。

如果你采用这种模型，实际的数据科学家有多少时间、资源和兴趣(不是每个人都想教)致力于此将在很大程度上决定你能在多大程度上信任这个轴上的人。

组织的决策

最后，您的组织如何在决策中委托信任对数据民主化的努力有很大的影响。

一个自上而下严格组织、拥有集中决策和权力结构的公司使用数据和信息的方式不同于一个自下而上、决策权力分散的公司。

虽然技术领域常见的自下而上型组织一般倾向于更广泛地共享数据，但这不一定是必然的。出于不同的原因，两者可能实际上都希望数据广泛地为每个人所用，但它所采取的确切形式将会非常不同，以适应现有的结构。组织内部的结构可能会使人们不去寻找数据来帮助他们决策。组织内部的激励机制会使人们倾向于反对风险，或者成为风险寻求者。这要视情况而定，你必须花很长时间认真考虑事情，才能决定你想站在哪里。

数据是变革的力量

人们倾向于认为组织已经“准备好”进行数据民主化，就像这是组织的一个模糊属性。我认为，从“每个人都有数据”到“每个人都有洞察力”是一个非常大的飞跃，这是推动组织更加数据化的第一步。

人们越熟悉交互数据、使用数据提问以及利用分析师和数据科学提供的技能，他们就越容易在工作中采用这些技术。

感谢

感谢所有在 twitter 上就这个话题发表了许多有用评论的伟大人们。试图综合众多观点时，我的大脑仍然很痛。

我还想特别提到这份数据景观宣言，Scout24 向我推荐了这份宣言，这是一个极好的例子，说明了一个组织在这些问题上的立场。对他们有用，明显 YMMV。

这是深度学习时代:数据的新前沿

原文：https://towardsdatascience.com/its-deep-learning-times-a-new-frontier-of-data-a1e9ef9fe9a8?source=collection_archive---------22-----------------------

图像、音乐、情感等等

当人们听到“深度学习”这个短语时，许多人对它的真正含义只有一个模糊的概念。深度学习是一种机器学习范式，使用人工神经网络作为学习模型。

但首先，这有什么关系？

它可以帮助我们的生活变得更加容易和方便。

好的，那么，它是如何工作的？

Image: UC Business Analytics R Programming Guide

在人工神经网络中，有三种层:输入层、隐藏层和输出层。

在输入层，输入向量 x=(x 1 ，x 2 ，…，x p )被提供给一个系统，以便测试该系统。在输出层，提供最终输出。隐藏层位于输入层和输出层之间。当隐藏层增加时，它变得深。深度学习是一种机器学习范式，使用这种深度人工神经网络作为学习模型。此外，深度学习非常有用，因为它是一种无监督的机器学习方法，这意味着它不需要标记的数据。

因为这项技术，我们拥有了丰富的数据，可以用于深度学习。我们来看一些常见的数据例子。

#1:图像

Image: Justin Freid/Martechtoday

从视觉信息中获取数据的方式其实并不是什么新鲜事。面部识别技术是过去十年中已经使用的典型例子。苹果公司的 Face ID 让我们对这项技术感到熟悉。

然而，实际上，很少有人意识到它的变化有多大。识别视觉信息是随着深度学习发展起来的。

彭博最近发布了一个新的网站，当人们使用网络摄像头或智能手机摄像头时，它可以扫描任何东西。当我通过我的网络摄像头扫描我的 iPhone 背面时，程序识别了苹果的标志，然后苹果的股票信息就弹出来了，包括当前的股价，公司信息，新闻稿等等。现在，无论何时人们通过相机扫描任何图像，都可以获得完整的数据。

基于深度学习的时尚 app asap 54，也是一个很好的运用深度学习的例子。当用户拍摄或上传他们想用累积的输入视觉值找到的任何衣服的照片时，该应用程序会建议相似的衣服和风格。

#2:音乐

Photo by Natalie Cardona on Unsplash

我们来谈谈音乐。很多与音乐相关的公司都在使用音乐作为他们的数据。

Shazam 应用程序只需点击应用程序上的一个按钮，就可以找到歌曲的信息，包括标题、专辑、发行日期等等。当人们在听他们想要识别的歌曲时点击一个按钮，该应用程序会分析正在播放的音频片段，然后可以找出这首歌是什么。

据 Trey Cooper 称，截至 2018 年，Shazam 上已经存储了 800 万首歌曲/音频文件。此外，随着更多的歌曲(输入值)被添加，准确性也将增加。

#3:情感

Photo by Szabo Viktor on Unsplash

最近出现的最有趣的数据类型是情感。人们已经分析了情感数据，以弄清楚人们如何以及为什么表达他们的情绪，这些情绪往往会被讽刺、评论、评论、消息或标签中的模糊语言所掩盖。

自然语言工具包(NLTK)通常用于分析这类数据。来自 Kaggle 的对电影评论的情感分析是一个很好的例子，因为在分析电影评论的文本后，数据科学家可以从不同方面得出结论，例如某部电影有多受欢迎。目前，已经通过对文本进行分类来分析情感，并且包括人的情感的大量文本足以作为数据输入。

然而，现在，情感也可以用其他不同的方式来分析。人们在社交媒体对话、短信中使用表情符号，甚至制作自己的表情符号来表达情感。随着越来越多的年轻人和成年人使用表情符号而不是长文本进行在线互动和交流，分析表情符号变得令人惊讶地更加必要。

情绪分析公司 Canvs ai 顺应这一趋势推出了一种新方法。今天，他们不仅通过文本，还通过表情符号来分析人们的情绪。据该公司称，他们将表情符号分为 56 种情绪，而不仅仅是将情绪分为积极或消极的类别。看起来，随着人们在在线对话中继续使用表情符号，通过使用表情符号作为输入值来分析他们的情绪的准确性将会增加。

下一个数据集是什么？

Photo by Annie Spratt on Unsplash

换句话说，数据不再局限于视觉图像、声音或文本。如今，一切都可以是数据，可以积累起来进行分析。由此，我们可以想象未来什么样的东西可以是数据。

一种可能性是闻是一种新形式的数据。有时，当人们在餐馆吸入饭菜的香味时，他们想知道他们正在吃什么。如果气味可以用作数据，我们可以使用一个应用程序来获得具有相似气味的食物列表。食谱和最近的食品杂货店的信息，我们可以在那里得到的成分将一起弹出。当积累了足够的关于气味的数据时，我们可以检查臭味是气体泄漏还是仅仅是新地毯的气味。然而，我们应该期待未来数据分析方式的巨大变化。

它在这里！人工智能机器人将如何革新制造业

原文：https://towardsdatascience.com/its-here-how-ai-robot-will-revolutionize-manufacturing-44ce784438d4?source=collection_archive---------24-----------------------

尽管制造业一直被认为是自动化程度最高的行业，但全自动化工厂似乎仍然遥不可及。然而，人工智能定义的机器人有望改变这种情况。拥有更好灵巧性和自主学习能力的机器人将如何改变制造流程和行业格局？企业应该如何应对机器人 2.0 带来的颠覆性创新？

在我之前的 机器人 2.0 系列文章 中，我们讨论了 AI 将如何实现自主学习。以及它将如何让机器人完成过去无法完成的精细动作。

我描述了 AI 如何推出机器人 2.0 时代 。并谈到了AI 机器人在物流行业的应用 。通过观察 AI 机器人的第一个应用场景，我们可以预测这项技术最终将如何影响我们的生产力、就业和日常生活。

在本文中，我们将关注制造业。目前，大多数机械臂和自动化设备用于制造业。然而，令大多数人惊讶的是，许多制造过程仍然保持手工操作。人工智能机器人将改变这一现状。拥有更好灵巧性和自主学习能力的机器人将如何改变流程和行业格局？企业应该如何应对机器人 2.0 带来的颠覆性创新？

“未来已经到来——只是分布不均匀。”—威廉·吉布森

制造自动化的现状

根据国际机器人联合会(IFR)最近发布的报告，2018 年全球工业机器人手臂出货量创下新纪录，达到 38.4 万台。中国仍是全球最大的市场(占 35%)，其次是日本和美国。

汽车和电子制造行业仍然是工业部门最大的应用市场(60%)，远远领先于其他行业，包括金属、塑料和食品。具体原因在我的第一篇文章里也讨论过。

source: IFR Statistical Department

此时，您可能想知道:

几十年前，工业机械臂被引入制造业。自动化应该已经应用到可能的领域。留给创新的空间有多大？

没想到的是，即使是自动化程度最高的汽车行业，离成为“熄灯工厂”，实现全自动化的工厂还有很大距离。

例如，大部分的汽车装配仍然是手工完成的。这是这个过程中最耗费人力的部分。一个汽车厂平均三分之二的员工在装配线上。

就连一向追求创新、崇尚高度自动化的特斯拉 CEO 埃隆·马斯克(Elon Musk)也不得不公开承认，特斯拉的生产线自动化进度没有达到预期。

为什么自动化这么难？自动化至今无法克服的技术局限是什么？

1。灵活性和适应性

今天的自动化生产线是为大规模生产而设计的。自动化有效地降低了成本，但也导致缺乏灵活性。更短的产品生命周期，越来越多的小批量但高度定制的生产要求更高的柔性。而且人类往往比机器人更能适应变化。

2。灵活性和任务复杂性

尽管技术进步很快，人类仍然比机器人拥有更高水平的灵活性。从我与电子合同制造商的交谈中，我了解到尽管组装过程已经高度自动化，但配套程序仍然主要是手工操作。

配套在制造业和仓储业都很常见。这是提高生产效率的重要一步。它指的是收集组装产品所需的各种组件、对其进行包装并将其放入套件中的过程。

然后，机器人从工具箱中取出零件并进行组装。这个装配阶段的自动化相对容易，因为每个零件都处于固定的位置和角度。相反，在装配过程中，零件必须被识别并从箱子中取出，它们在箱子中以无序的方式存放。各部分的各自位置不同，导致可能的重叠或缠绕，对传统的机器视觉和机器人技术提出了挑战。

3。视觉和非视觉反馈

许多复杂的装配操作依赖于操作员的经验或“直觉”。无论是安装汽车座椅，还是将零件装入套件，这些看似简单的动作都需要操作者根据各种视觉和触觉信号来调整其动作的角度和力度。

传统的自动化编程对于这种微调任务没有用，因为检索或放置项目的每个实例并不完全相同。它需要人类从多次尝试中学习和归纳的能力。这样能力的掌握，尤其是深度强化学习，才能给机器人带来最大的改变！

KIT Toolkit — source: kitting-assembly.ca

机器人 2.0:AI 机器人可以执行哪些以前无法完成的任务？

AI 给机械臂带来的最大变化是:过去机械臂只能重复执行工程师的书写过程。尽管它们准确而精密，但它们无法应对环境或过程的变化。

由于人工智能，机器现在可以学习自己处理各种各样的对象和任务。具体来说，与传统机械臂相比，人工智能机器人在三个主要领域取得了重大突破:

视觉系统

即使是最先进的 3D 工业相机也不具备人眼在确定深度和距离以及识别透明包装、反射表面或可变形物体方面的准确性。

这解释了为什么很难找到一个可以提供准确深度并识别大多数包裹和物品的相机。不过由于 AI，这种情况很快就会被改变。

机器视觉在过去几年取得了巨大的进步，从深度学习、语义分割和场景理解都有创新。

这些改进了使用商品相机的深度和图像识别，允许制造商获得准确的图像信息，并成功识别透明或反光物体包装，而无需昂贵的相机。

Deep learning object recognition examples, from left to right: Mask, Object Modeling, Grasp Point Prediction — source: OSARO

2。可扩展性

与传统的机器视觉不同，深度学习不需要预先注册或构建每个项目的 3D CAD 模型。人工神经网络可以在训练后自动识别图像中的目标。

无监督或自我监督学习也可用于减少手动标记数据或特征的需求，使机器更接近人类学习。

ML 减少了对人工干预的需要，并使机器人能够处理新零件，而不需要工程师重写程序。随着机器通过运行收集越来越多的数据，机器学习模型的准确性也将进一步增强。

目前，典型的生产线通常具有周边设备，如摇床、进料器和传送带，以确保机器人能够准确地获取所需的部件。

如果机器学习进一步发展，机械臂变得更加智能，也许有一天这些比机械臂贵四五倍以上的外设就不再需要了。

另一方面，由于深度学习模型一般存储在云端，这也让机器人可以互相学习，分享知识。例如，如果一个机械臂在一夜之间学会了组合两个部分，它就可以将新模型更新到云中，并与其他机器人共享。这样节省了其他机器的学习时间，也保证了质量的一致性。

3。智能放置

一些对我们来说似乎很容易的指令，如小心处理或整齐排列物品，对机器人来说是一个巨大的技术挑战。“小心处理”是如何定义的？是在物体接触桌面时立即停止施力吗？还是把物体移到离桌子 6 厘米的地方，然后让它自然落下？还是在你接近桌面时逐渐减速？这些不同的定义如何影响物品放置的速度和准确性？

将物品摆放整齐更是难上加难。即使我们忽略了“整洁”的定义，我们也必须首先从正确的位置拿起物品，以准确地将物品放置在所需的位置和角度:机械臂仍然没有人类灵巧，目前的大多数机械臂仍然使用吸盘。在实现像人类关节和手指那样的精细运动技能方面，仍有很大的改进空间。

其次，我们需要能够立即确定要抓握的物体的角位置和形状。以上图中的杯子为例。机械臂需要知道:杯子是朝上还是朝下？是应该横着放还是竖着放？以及路上是否有其他物品或障碍物？这样，机器人就可以决定把杯子放在哪里，以最有效地利用空间。

我们从出生开始就在不断地学习拿起和放下物品的各种任务。这些复杂的任务可以本能地完成。但是机器没有这样的经验，必须重新学习任务。

利用人工智能，机械臂现在可以更准确地判断深度。它还可以通过训练进行学习，并确定杯子是朝上还是朝下，或者处于其他状态。

对象建模或体素化可用于预测和重建 3D 对象。它们使机器能够更准确地呈现实际物品的大小和形状，并更准确地将物品放置在所需的位置。

所有这些对制造业格局意味着什么？我们会看到重大的行业洗牌吗？在下一代自动化时代，谁能抓住机会巩固自己的地位？我们将在下一篇文章中详细讨论这一点。

如果你想看更多这样的文章，请点击这里！

Bastiane Huang 是 OSARO 的产品经理，OSARO 是一家总部位于旧金山的初创公司，致力于开发软件定义的机器人技术。她曾在亚马逊的 Alexa 小组和哈佛商业评论以及该大学的未来工作倡议中工作。 她写的是关于 ML、机器人和产品管理的文章。跟随她来到这里T5。

这只是时间问题，华生医生！理解 R 中的日期和时间

原文：https://towardsdatascience.com/its-merely-a-matter-of-time-dr-watson-2fd74a648842?source=collection_archive---------35-----------------------

如何正确处理 R 中的时间——日期、时间、周期、持续时间、通量电容、时间旅行、时间间隔——什么？我在时间丛林里给你一些帮助。

The processing of time often appears weird. Photo by Jon Tyson on Unsplash

每当我需要用 R(和其他编程语言)处理日期和时间时，我通常会遇到困难——解析、打印、时区、夏令时、时差。也许你和我一样是那些可怜的人中的一员。所以这篇文章是写给那些总是忘记这些概念的人和我未来的自己的。这篇文章是提示、包和函数的松散连接，展示了如何处理日期和时间。

概观

r 中时间点的标准表示(即日期和时间)使用所谓的 UNIX 纪元时间或 POSIX 时间，这是自1970–01–01T00:00:00Z以来经过的秒数(这是 ISO8601^1 格式，表示 1970 年 1 月 1 日 00:00:00 AM，协调世界时 UTC)。对于 1970 年之前的时间点，此计数为负。这同样适用于自 1970 年 1 月 1 日以来的天数。

基本日期和时间类

基础包中用于表示日期、时间和时差的最重要的类是

base::Date —没有时间和时区的日期，编码为自 1970-01-01 以来的有符号天数(负数表示该日期之前的年份)。
base::POSIXct — 日历时间 —日期和时间，由 1970 年 1 月 1 日 00:00:00 以来的秒数和时区表示。通常，这是计算(如时差)的最佳表示。POSIXct 使用您平台上的系统实现。亚秒可以用这个类编码。请注意，闰秒通常在大多数平台上被忽略。
base::POSIXlt —当地时间 —日期和时间分为所有日期/时间部分(工作日、年份等)。).如果您需要处理例如工作日，这很有用。
base::difftime —用浮点数和一个单位(“秒”、“天”)表示的两个日期或日期/时间之间的差异。

在 R 中键入?DateTimeClasses来获取这些类的引用。

显示所有数据组件的unclass()函数可以很容易地研究这些类的实例结构。用class(x)你可以得到给定对象x的类名。

注意，所有这些类的实例都是由相应的as.xxxx()函数生成的，例如

base::as.POSIXct(“2019–01–01 00:00:00”, tz=”UTC”)

解析日期时间字符串的示例

> t1 <- as.POSIXct(‘2019–01–01 15:00:00’, tz=’UTC’)> class(t1)[1] “POSIXct” “POSIXt”> unclass(t1)[1] 1546354800attr(,”tzone”)[1] “UTC”

Lubridate 包

lubridate R 包(https://lubridate.tidyverse.org)在日期和时间的处理上引入了一点舒适。尤其是带有日期和时间的计算更加简洁。除了日期(由base::Date表示)和时间(由base::POSIXct表示)之外，lubridate 增加了以下类

lubridate::Duration —两个日期/时间之间经过的确切时间。可以从日期/时间中增加或减少持续时间。使用从dnanoseconds()到dweeks()的lubridate::dxxxx功能可以创建一个持续时间值。注意:持续时间dmonth()和dyear()是一个月/年的平均值。因此，有第二个类代表通常可以理解的月/年值:
lubridate::Period —周期是与公历相关联的时差的度量。因此，如果您将一个月添加到一个日期值中，即使这几个月的持续时间不同，也会出现相同的天数(见图 1 )!使用年()、月()、周()等。此处的功能。
lubridate::Interval —对由两个日期/时间(开始和结束)组成的时间间隔进行编码。集合操作可以用这个类来执行(setdiff、intersect、union)。

Fig. 1: An overview showing all relevant date-time related objects. The duration of a period variates depending on the dates/times to which it is added. Intervals have a clear start and end date/time. Set operations can be performed with intervals such as intersection, difference, or containment using %within%.

lubridate 包有很多解析不同格式的日期和时间的函数，例如

time1 <- lubridate::ymd_hms(“2019–01–01 14:45:00”)date1 <- lubridate::ymd(20190101)

周期

周期是对年和月特别有用的常识性度量，如下所示:

因此，2016 年是闰年:

library(lubridate)(ymd(20160101) + years(1)) — ymd(20160101)Time difference of 366 days

因此，2017 年不是闰年:

(ymd(20170101) + years(1)) — ymd(20170101)Time difference of 365 days

期间

持续时间是基本单位(皮秒、微秒、毫秒、秒、分钟、小时、天、周)内的精确时间量。由于月份和年份不是同质的(有更短和更长的年份)，这些持续时间不适合用作精确的度量。

与上面的例子相反，dyears(1)是平均年正好有 365 天，所以在闰年你会得到以下结果(这通常不是你想要的):

library(lubridate)
(ymd(20170101) + dyears(1) — ymd(20170101)
Time difference of 365 days

间隔

间隔由两个日期组成，如下所示

library(lubridate)
I1 <- interval(
        ymd(20170101),
        ymd(20171231))

或者像这样的日期/时间点

I2 <- interval(
         ymd_hms(“2019–01–01 14:30:00”),
         ymd_hms(“2019–01–01 15:30:00”))

您可以在这里检查日期/时间是否包含在这样的间隔中

ymd(20170317) %within% I1[1] TRUEymd(20180317) %within% I1[1] FALSE

setdiff()、union()、intersect()等操作与lubridate::Interval类协同工作。

亚秒级分辨率的打印和解析

解析微秒级分辨率可以通过base::strptime()函数完成(注意格式字符串中的“%OS”参数允许解析亚秒级):

time1 <- base::strptime(“2019–03–30 17:35:12.456789”,
              format = “%Y-%m-%d %H:%M:%OS”, tz = “UTC”)

或者，使用润滑方法可以更简单地获得相同的结果(这里我使用了日期-时间的 ISO8601 编码——见下一节):

time1 <- lubridate::as_datetime(“2019–03–30T17:35:12.456789Z”)

可以使用下面的 R 表达式执行返回字符串的转换:

print(base::strftime(time1, “%Y-%m-%d %H:%M:%OS6 %Z”))[1] “2019–03–30 17:35:12.456789 UTC”

注意格式字符串中的“%OS6”。这是为了打印小数秒的 6 位数字。

日期和时间的字符表示

“令人高兴的是”,日期和时间的文本 ASCII 表示存在巨大的可变性，这使得日期时间的处理和解析非常具有挑战性。每当你有机会决定使用哪种时间格式时，我都会推荐使用 UTC 的 ISO8601 格式。即使在其他时区处理，UTC 时间代码在全球范围内都是清晰的——您不必摆弄时区或夏令时(从而在时间线中引入一年两次跳跃:一次跳跃到未来，一次跳跃到过去——并且没有通量电容器)。

示例:字符串“2019–01–02T23:50:12.225Z”是采用 UTC 时区的 ISO8601 时间代码(即字符串末尾的Z)。可以像这样用lubridate::as_datetime()函数解析

time1 <- lubridate::as_datetime(‘2019–01–02T23:50:12.225Z’)

从文件加载时间序列

从文件中加载时间序列的一个非常好的包是 readr 包(https://readr.tidyverse.org)，它允许解析带有日期/时间列的表格。通过使用readr::col_date、readr::col_time和readr::col_datetime给出一个列定义，可以给 readr 一个解析readr::read_csv()中日期的格式。寻找 readr::parse_date和 readr::parse_datetime功能。

加载带有日期列的 CSV 文件的示例

library(readr)col_spec <- cols(
   x = col_double(),
   y = col_date(format = “%Y-%m-%d”))df1 <- read_csv(readr_example(“challenge.csv”),
                col_types = col_spec)

绘制时间序列

基础包提供了 ts()函数来创建一个规则的时间序列。一个 ts 时间序列有一个起始点(有时解释为年份)和一个frequency——或者是一个deltat ，它们被设置为与起始点相关。

通过将日期和时间附加到数据帧的每一行(在 xts 中称为index())，该概念被扩展为支持不规则采样时间序列的 xts package⁴。xts 套装基于动物园 package^5.

就个人而言，我更喜欢使用【https://ggplot2.tidyverse.org】库来绘制图形。通过一些简单的步骤，一个 ts 或 xts 时间序列可以转换成一个tible数据帧用于绘图。对于转换时间序列来说，重要的是generics::tidy()函数将时间戳属性提取到一个索引列中。

结果图如下所示:

Time-series in xts.

Time-series in ggplot.

有关处理时间序列的更多资料，请参见[7，8]。

松散的末端

闰秒

由于这个世界在数学上(以及在许多其他方面)并不完美，所以有时会有闰秒(通常是正数)，因此有些日子会有 86401 秒，而不是 86400 秒。否则——迟早——由于平均太阳日并不完美，我们的挂钟会漂移。

全局变量. leap.seconds 包含当前时区的所有闰秒。对于另一个时区，您可以使用format(.leap.seconds, tz=’CET’)打印闰秒。

有趣的是，正如 POSIX 提出的那样，时差应该考虑闰秒。然而，由于这使得所有的时间计算过于复杂，它们通常在大多数系统中被忽略！在 R 的 DateTimeClasses 文档中，编写了以下提示:

在任何平台上，R do 而非使用的[…]“posi xct”时间包括闰秒

表示日期和时间的其他包装/R 类别

在其他常用的包中有一些额外的类代表日期和时间(这个小列表显然不是详尽的):

chron::chron —按时间顺序排列的对象
zoo::yearmon —表示包括年份在内的月度数据
zoo::yearqtr —包括年度在内的季度数据表示
timeDate::timeDate

希望这篇文章有助于找到解决 r 中日期和时间处理困难的方法。

参考

[1]日期和时间格式— ISO 8601。https://www.iso.org/iso/iso8601，https://en.wikipedia.org/wiki/ISO_8601

[2] R 代表数据科学— Ch。16 日期和时间，【https://r4ds.had.co.nz/dates-and-times.html】T4

【3】闰秒。维基百科。https://en.wikipedia.org/wiki/Leap_second

[4] xts:可扩展时间序列，https://cran.r-project.org/package=xts

[5] zoo:规则和不规则时间序列的 S3 基础设施(Z 的有序观测)，https://cran.r-project.org/package=zoo

[6] chron:可以处理日期和时间的时序对象，https://cran.r-project.org/package=chron

[7]使用 dplyr 介绍时间序列分析，https://blog . explorative . io/Introducing-Time-Series-Analysis-with-DP lyr-60683587 cf8a

[8]时间序列分析，http://r-statistics.co/Time-Series-Analysis-With-R.html

有必要将批处理规范化和跳过连接结合起来

原文：https://towardsdatascience.com/its-necessary-to-combine-batch-norm-and-skip-connections-e92210ca04da?source=collection_archive---------11-----------------------

这些技术必须齐头并进

Image by geralt from pixabay

这篇文章基于我在 ICML 2019 年发表的论文。它试图提供新颖的见解来回答以下问题:

为什么深度神经网络(DNNs)的特定架构有效，而其他架构无效？
批量范数[2]和跳过连接[3]起到了什么作用？

回答这些问题是一个热门的研究课题，事关重大。事实上，这样的答案将推进对 DNNs 的理论理解，并有可能进一步改进它们的设计。

如何评估一个架构的质量？

首先，第一个关键的观察是，任何从输入到输出的 DNN 映射都需要指定两个元素:(1)架构；(2)架构内部的模型参数值——权重和偏差。通过固定架构和改变架构内的模型参数获得的所有 DNN 映射的集合被称为假设类。

假设类的目的是对训练施加约束。实际上，训练在于找到同时满足以下条件的 DNN 映射:(1)属于假设类；(2)与训练数据一致。DNN 映射必须属于假设类的约束是表达真实映射本身属于假设类的先验知识的一种方式。本质上，这种先验知识使得仅使用训练数据的测试数据的归纳成为可能。出于这个原因，先前的知识通常被称为感应偏置(要了解更多细节，我建议读者参考 Shalev-Shwartz 和 Ben-David 的这本伟大的书)。

回到我们最初的目标，我们可以通过评估归纳偏差的质量来评估架构的质量。这种评估可以使用以下过程来执行:修复体系结构，并在体系结构内随机抽取模型参数。如果用该过程采样的大多数 DNN 映射具有不好的属性，这意味着对不好的属性存在归纳偏差，即坏的属性在训练期间将被偏爱。反过来，这将导致无法适应——即欠拟合——当坏属性与低训练损失不相容时，或者导致泛化能力差——即过拟合——当坏属性与低训练损失相容但不太可能泛化时。

在能够应用这个过程之前，我们仍然需要使 DNN 映射的“坏性质”的概念更加精确。

DNN 映射有什么不好的性质？

让我们考虑一个固定的 DNN 映射，由固定架构和固定架构内的模型参数指定。这个固定的 DNN 映射接收一个随机输入并通过它的层传播这个输入。我们通过定义以下内容来跟踪传播:

随机信号:y^l =φ^l(x)，通过将固定 DNN 映射φ^l到层 l 应用到随机输入 x 得到
随机噪声随机噪声:dy^l =φ^{*l*(**x**+d**x**)-φ}l(x)、作为随机腐败 d x 产生的层腐败

现在，DNN 映射的“坏特性”可以定义为信号和噪声的不必要行为:或者信号 y ^ l 变得无意义，或者噪声 d y ^ l 失去控制。更准确地说，两种“病理”可以被定义为将这种“不良属性”推向极端(我们关注这两种“病理”，因为它们是在我们的上下文中观察到的，但是其他“病理”可以在其他上下文中被定义和观察到):

Pathological Signal

病理信号:信号 y ^l 失去其变化方向，并在深层沿一条线集中。这种病理例如与多类分类的一次性目标(具有通常等于类的数量减 1 的多个变化方向)不兼容。对这种病理的诱导性偏见可能导致无法治愈。

Pathological SNR

病理 SNR: 噪声 dy^l 相对于信号y ^l ，信噪比 SNR ^l 随 l 呈指数衰减这种病理可能兼容低训练损失，但是测试集上的任何输入讹误 d x 都会导致讹误信号yt20】^{l+d**y**t24】}l =φ^l(x+dx)变成纯噪声——即无意义。对这种病理学的归纳性偏见可能导致不良的概括。

将我们的过程应用于各种架构

现在让我们将我们的过程应用于卷积****DNNs——的各种架构，包括作为空间大小等于 1 的特例的全连接 DNNs—具有 ReLU 激活函数:

没有批次定额的 DNNs 和没有 跳过连接的病理信号——即 y ^l 的#个方差方向在深层接近 1

没有批次标准的 DNNs 和有跳过连接的同样有病理信号——即 y ^l 的#个方差方向在深层接近 1

具有批处理规范的 DNNs 和没有跳过连接的遭受病理 SNR** — 即 SNR^l*/SNR*0随 l 呈指数衰减**

带有批次标准的 DNNs 和带有跳过连接的不会出现任何问题——即在所有深度都保持良好运行****

这是怎么回事？

吸引病理学的主要力量是前馈层组成的乘法性(conv 层和 ReLU 层可以分别看作是与随机矩阵相乘和与 Bernouilli 随机向量相乘):

没有跳跃连接的 DNNs 在深层是病态的，因为它们受到简单前馈乘法的影响
没有批范数的 DNNs 和具有跳过连接的在深层是病态的，因为残差和跳过连接分支中大致相等的方差不有效地对抗前馈乘法
具有批处理规范的 DNNs 和具有跳过连接的在所有深度都保持良好性能，因为剩余连接分支和跳过连接分支之间的信号方差的衰减比率∝1/(l+1)有效地对抗前馈乘法

结论

让我们总结一下我们的结果(为了更深入地挖掘，我建议感兴趣的读者参考论文和代码):

批范数和跳过连接的组合在深网中编码了一个性能良好的感应偏置T21
然而，这些技术的好处很难理清。只有当它们结合时——通过将剩余分支稀释到跳过连接分支——它们才能抵消前馈乘法

我希望这些结果将打开理解深网的新视角。

放弃

为了便于阐述(并且不改变分析)，与本文相比，本文中的一些符号被简化了:

采用了预激活视角，每层 l 在卷积后开始，在卷积后再次结束
#方差方向yt28】^l 在文中对应于yt32】^l 的有效秩
SNR ^l / SNR^0 在本文中对应于归一化灵敏度平方的倒数

参考

[1] A. Labatie，表征行为良好与病理性深度神经网络 (2019)，ICML 2019

[2] S. Ioffe 和 C. Szegedy，批量归一化:通过减少内部协变量移位加速深度网络训练 (2015)，ICML 2015

[3]何国光，张，任，孙，深度剩余网络中的身份映射 (2016)，2016

在数据科学中使用电子表格是可以的

原文：https://towardsdatascience.com/its-ok-to-use-spreadsheets-in-data-science-c1d0eff95b8b?source=collection_archive---------8-----------------------

因为它们在一堆混乱的次优数据科学环境中很棒。

如今有了这么多先进的数据工具，很容易认为电子表格对于严肃的数据科学工作来说太原始了。事实上，有超过 20 年的文献警告人们电子表格的弊端，这听起来像是一个“真正的数据专家”应该知道不要使用这些过时的东西。

但它可能是最伟大的瑞士军队数据电锯，用于那些没人愿意承认他们每天都要做的丑陋工作。在理想情况下，它们是不必要的，但当技术债务、时间压力、糟糕的数据质量以及除了电子表格什么都不懂的利益相关者结合在一起时，它们是无价的。

电子表格有一个坏的说唱，这是很值得的

早在数据科学领域出现之前，由于电子表格是商业中最普遍的程序之一，已经有大量文章吹捧电子表格的各种缺陷。恐怖故事比比皆是。有电子表格错误导致学术工作中的重大错误和论文钻研各种电子表格错误的例子。甚至还有一整个“欧洲电子表格风险利益集团(EuSpRiG)(成立于 1999 年！)致力于电子表格风险管理，即如何避免因电子表格混乱而毁掉你的业务。

许多问题源于人类的弱点。太容易犯公式错误或以不被注意的方式改变公式。各种函数的实际输出偶尔会有问题(内置于 Excel 的统计功能在 15 年前就有了这样的问题，有些可能会持续)。有时候，工作表的复杂性会激增，这简直令人困惑。

已经有大量的功能来防止人类的失败点，但人类通常没有耐心和远见来处理这类事情。当然，我们可以使用单元格保护、锁定、验证等。，但就像备份数据一样，它通常被放在一边“供以后使用”，实际上从未发生过。

其他大部分问题是当人们试图让一个电子表格做太多事情，像成为一个数据库、数据仓库、项目管理工具时，更强大和用户友好的专用解决方案已经存在。说“使用正确的工具来完成工作”很容易，但是通常电子表格怪物都是从小工作开始，然后成长为更多的东西。

所有这些问题都很有道理。我会把这些视为理所当然。这意味着你需要意识到一个好的工具可能会被以可怕的方式滥用。取而代之的是，我将继续讨论电子表格仍然很适合放在你的后口袋里。

“EDA 的电子表格？酷。”—每个人

与我交谈过的大多数从业者都同意，以探索/原型的方式使用电子表格是完全可以做到的(他们自己可能不会这样做，但他们并不认为这有什么错)。你通常是在摆弄一个小的数据样本来找出什么是可能的。在这一点上，几乎没有期望你会产生精炼的代码或分析。根据你对 Excel、Google Sheets 或 Libreoffice vs pandas 和 R 的熟悉程度，你甚至可以工作得更快。

我真的痴迷于在构建分析或编写代码之前熟悉我的数据集。当然，你可以看看描述性统计数据，但它们可能会欺骗你很多:

Such an awesome animation

真正了解数据的唯一方法是查看分布、可视化，并直接以原始形式对其进行采样。电子表格通常非常适合这种情况。我倾向于认为这比用熊猫随意地在大块大块的行上闲逛要不那么笨拙。

关键特性是在电子表格中试验数据转换的速度有多快。快速 VLOOKUP 将让您测试两个混乱的表之间的简单连接，以找到损坏的或重复的键。您可以通过几次击键和点击将数据放入数据透视表，并检查某些聚合。通过这种方式可以发现很多错误，因为您将尝试一个简单的算术，它会因为不可靠的数据而中断，您可以快速检查实际发生了什么，并将其添加到您要清除的数据错误列表中。

类似的操作在熊猫身上也很容易，但需要更多的打字，并保持头脑中的细节，比如什么功能应用于什么等等。因此，这里的理想情况是使用电子表格进行探索，原型化出您想要应用的数据转换，检查一些发行版，然后用 Python 或 R 编写一个合适的模型，现在一切都在您的脑海中变得更加清晰了。知道何时停止的诀窍是，如果你正在认真考虑写一个宏或什么的，就停下来。

处理荒谬的半重复编码

跟踪系统充满了任意字符串和数字的任意组合，您需要对其进行查询以进行计数。也许有一个潜在的模式适合你的用例，让你元编程，也许没有。这对于多年来有许多人添加/改变具有不同命名约定甚至不同后端栈的各种跟踪代码的系统来说尤其是一个问题。

An example of a typical tracking system that’s had a few years to grow production cruft

很多时候，除了编写某种脆弱的硬编码映射函数之外，没有其他方法来处理上述数据集。老实说，在多年的生产过程中保持所有东西的一致性和文档化是一个挑战，camelCase 和下划线的组合就说明了这一点。为了进行有意义的分析而进行简单的汇总是一件极其痛苦的事情。

-- ProductLead: "Where do my registrations come from?"
-- Analyst: "Why do you hate me?"select 
case       
when event_string like 'navRegButton' then page_path       
when event_string like 'homepage_register_button' then 'homepage'      
when event_string like 'newsletterRegistration' then 'newsletter'
when event_string like 'adCampaign_%' then 'ad'
when event_string like 'homepageBiggerRegButton' then 'homepage'
end as source,
count(*) as reg_starts
from ui_events
group by source

想出像上面这样庞大的 case 语句是一件痛苦的事情，保持它的组织性更糟糕。我称之为 semi- repetitive，因为如果它确实是重复的，你就能够编写一个函数，很容易地捕捉它的行为。由于技术债务，这个有一堆愚蠢的自定义边缘案例，所以它有不可取的 Kolmogorov 复杂性。输入使用电子表格来保持事情有点理智。

Sometimes you gotta break some eggs to make a registration source tracker

这是理想的吗？大概不会。但是我甚至不确定在这种情况下理想状态到底是什么样子。另一种选择是将所有这些硬编码到 Python 中进行分析，这在这种混乱的情况下同样脆弱。一个更干净的解决方案是以某种方式重构你的跟踪代码在过去、现在和未来是如何设置的，并创建一个系统来防止这种情况发生，但我还没有聪明到设想这样一个系统不会被未来的使用所滥用。

与不太懂技术的人分享打包的数据

这就是为什么所有级别的 BI 工具都有一种“导出到 CSV/Excel”的特性。许多非常聪明的分析人员不太了解用 Python 或 r 编写代码。他们不会看着一本写有代码的笔记本说“啊哈！让我做一些调整来检验我自己的假设。”但是，如果你给他们一张相当干净的数据表，他们会处理得很好。

那么，为什么不采用通用数据传输格式 CSV 呢？可以，但是这使得留下一个数据源踪迹变得更加困难。您可以将所有需要的相关信息打包到电子表格的一个选项卡中，无论是相关查询、脚本链接还是其他。

Always leave a data trail

这样做的原因是为了确保当不可避免的“这从何而来？”问题来自第三方，实际上有一个答案，而不必做大量疯狂浪费时间的调查工作。

当你是一个地图新手的时候

即使你有精确的经纬度坐标，地图也很难制作。映射邮政编码更加疯狂(像 FIPS 到邮政编码的转换是一个不小的痛苦)。我见过的大多数例子都涉及一个显著的数量的包到工作，这是假设你只是想要一个静态图像。好的一面是，我们不必启动 GIS 软件来做这种事情。

谢天谢地，令人惊讶的是，对于那些无法区分墨卡托和梅赛德斯的人来说，近年来电子表格已经开始填补“我现在需要一张快速地图”的空白，截至 2019 年撰写本文时，Excel 处于这一领域的前沿。Google Sheets 也有一些地图功能，但功能仍然不够强大。

Excel 3d Mapping feature: It’s like MAGIC

Google Sheets Maps: Not as magical, but still pretty magic

制作这些地图是一项高技术壮举，您需要处理疯狂的地图轮廓，通常需要人工智能/人工智能来解释一条数据是邮政编码还是其他位置，地图位置通常有重复的名称，数据点需要根据显示缩放级别进行聚合…因此为您抽象所有这些工作具有巨大的价值。

结论——电子表格是不错的选择

就需要维护的电子表格而言，它们代表了一种技术债务。诀窍是不要让它成为技术债务，避免使用电子表格作为长期的活文档。虽然我们经常被训练不要产生一次性工作，但矛盾的是，电子表格几乎是快速一次性工作的理想选择。通常当我们把它们放在身边时，它们会变成一种令人讨厌的东西。

这很自然:过度深入自然梯度优化

原文：https://towardsdatascience.com/its-only-natural-an-excessively-deep-dive-into-natural-gradient-optimization-75d464b89dbb?source=collection_archive---------1-----------------------

我要讲一个故事:一个你以前几乎肯定听过的故事，但与你习惯的侧重点不同。

对于一阶近似，所有现代深度学习模型都是使用梯度下降来训练的。在梯度下降的每一步，您的参数值从某个起点开始，您将它们向损失减少最大的方向移动。你可以通过对你的损失对你的整个参数向量求导来做到这一点，也就是所谓的雅可比矩阵。然而，这只是你损失的一阶导数，它不能告诉你任何关于曲率的东西，或者说，你的一阶导数变化有多快。由于您可能处于一阶导数的局部近似值可能不会在离估计点很远的地方推广的区域(例如，在一个巨大的山丘之前的一个向下的曲线)，您通常希望小心谨慎，不要迈出太大的一步。因此，为了谨慎起见，我们用一个步长α来控制我们的前进速度，如下式所示。

这个步长做了一些有趣的事情:它限制了你要在梯度方向上更新每个参数的距离，并且是以一个固定的量。在该算法的最简单版本中，我们取一个标量α，假设它是 0.1，然后乘以相对于损耗的梯度。请记住，我们的梯度实际上是一个向量，即模型中每个参数的损失梯度，因此当我们将它乘以一个标量时，我们将沿着每个参数轴的更新乘以，以欧几里德参数距离表示相同的固定量。并且，在梯度下降的最基本版本中，我们在学习过程中的某些点使用相同的步长。

但是…这真的有意义吗？具有小学习率的前提是我们知道梯度的单个局部估计可能仅在该估计周围的小局部区域中有效。但是，参数可以在不同的尺度上存在，并且可以对你学习到的条件分布产生不同程度的影响。而且，这种影响程度会随着训练的进行而波动。从这个角度来看，在欧几里德参数空间中用一个固定的全局半径来定义一个安全气泡似乎不是一件特别明智或有意义的事情。

Image Credit: Science Magazine, because I don’t have the software to make a cool image like this, and damnit the subtleties of gradient calculation techniques are not an easy thing to visualize

自然梯度的支持者含蓄地提出了一个反建议，即我们不应该根据参数空间中的距离来定义我们的安全窗口，而应该根据分布空间中的距离来定义它。因此，不要说“我将遵循我的当前梯度，前提是将参数向量保持在当前向量的ε距离内”，而是说“我将遵循我的当前梯度，前提是将我的模型预测的分布保持在它之前预测的分布的ε距离内”。这里的概念是分布之间的距离对于任何缩放、移位或一般的重新参数化都是不变的。例如，可以使用方差参数或比例参数(1/方差)来参数化相同的高斯；如果查看参数空间，两个分布之间的距离会有所不同，这取决于它们是使用方差参数化还是使用比例参数化。但是如果你在原始概率空间中定义一个距离，它将是一致的。

这篇文章的其余部分将试图对一种称为自然梯度学习的方法建立更强、更直观的理解，这是一种概念上优雅的想法，旨在纠正参数空间中缩放的任意性。我将深入研究它是如何工作的，如何在组成它的不同数学思想之间建立桥梁，并最终讨论它是否以及在哪里真正有用。但是，首先:计算分布之间的距离意味着什么？

许可给 KL

KL 散度，或者更恰当地说，Kullback-Leibler 散度，在技术上不是分布之间的距离度量(数学学家对被称为度量或适当距离的东西很挑剔)，但它非常接近这个概念。

从数学上讲，它是通过计算对数概率(即概率值的原始差值)与从一个分布或另一个分布中采样的 x 值之比的期望值而得到的。事实上，期望是在一个分布或另一个分布上得到的，这使得它成为一个不对称的度量，其中 KL(P||Q)！= KL(Q||P)。但是，在许多其他方面，KL 散度映射到我们对概率距离应该是什么样子的概念:它直接测量如何定义概率密度函数，也就是说，在定义分布的一系列点上的密度值的差异。这有一个非常实际的方面，当分布对一系列 X 的“在这个 X 的概率是多少”的问题有更远的答案时，它们被认为是更不同的。

在自然梯度的背景下，KL 散度被用作测量我们的模型预测的输出分布变化的方法。如果我们正在解决一个多向分类问题，那么我们的模型的输出将是一个 softmax，它可以被视为一个多项式分布，每个类有不同的概率。当我们讨论由我们当前参数值定义的条件概率函数时，这就是我们讨论的概率分布。如果我们使用 KL 散度作为缩放梯度步长的方式，这意味着对于给定的输入特征集，如果两个参数配置会导致预测的类别分布在 KL 散度方面非常不同，则我们会看到这两个参数配置在该空间中“相距较远”。

费希尔的事

到目前为止，我们已经讨论了为什么在参数空间中缩放我们的更新步骤的距离是不令人满意的任意性，并建议了一个不那么任意的替代方案:缩放我们的步骤，使得在 KL 偏离我们的模型先前预测的类分布方面，最大仅前进一定的距离。对我来说，理解自然梯度最困难的部分是下一部分:KL 散度和 Fisher 信息矩阵之间的联系。

从故事的结尾开始，自然渐变是这样实现的:

“Natural Gradient is defined as…”

等号上的 def 意味着右边的是左边符号的定义。右边的术语由两部分组成。首先，是损失函数相对于参数的梯度(这与更普通的梯度下降步骤中使用的梯度相同)。“自然”位来自第二部分:对数概率函数的平方梯度在 z 上的期望值。我们将被称为费希尔信息矩阵的整个对象乘以损失梯度的倒数。

p-theta(z)项是我们模型定义的条件概率分布，也就是说:一个神经网络末端的 softmax。我们在看所有 p-θ项的梯度，因为我们关心，我们预测的类概率，会随着参数的变化而变化。预测概率的变化越大，我们的更新前和更新后预测分布之间的 KL 差异就越大。

自然梯度优化令人困惑的部分原因是，当你阅读或思考它时，有两个不同的梯度对象你必须理解和争论，这意味着不同的事情。作为一个题外话，这不可避免地陷入了困境，尤其是在讨论可能性的时候，而且也没有必要掌握整体直觉；如果你不想看所有血淋淋的细节，请随意跳到下一部分。

相对于损失的梯度

通常，您的分类损失是一个交叉熵函数，但更广泛地说，它是一个将模型的预测概率分布和真实目标值作为输入的函数，并且当您的分布离目标值越远，它的值就越高。这个对象的梯度是梯度下降学习的核心面包和黄油；它表示如果您将每个参数移动一个单位，您的损失将会改变的量。

对数似然的梯度

对我来说，这无疑是学习自然渐变最令人困惑的部分。因为，如果你读过费希尔信息矩阵，你会得到很多链接，解释它与模型的对数似然的梯度有关。我以前对似然函数的理解是，它代表了你的模型认为某组数据的可能性有多大；特别是，您需要目标值来计算它，因为您的目标是当您根据输入要素对其进行调整时，计算您的模型分配给真实目标的概率。在讨论似然性的大多数情况下，例如非常常见的最大似然性技术，您关心对数似然性的梯度，因为您的似然性越高，您的模型分配从真实分布中采样的值的概率就越高，我们都越高兴。实际上，这类似于计算 p(class|x)梯度的期望值，期望值内的概率来自数据中的实际类别分布。

但是，您也可以用另一种方式来评估可能性，而不是计算您相对于真实目标值的可能性(在这种情况下，您会期望有一个非零梯度，因为有可能推动您的参数来增加真实目标的可能性)，您可以使用从您的条件分布本身中提取的概率来计算您的期望**。也就是说，如果您的网络产生了一个 softmax，而不是根据给定观测值的数据中的真实类来获取概率为 0/1 的 logp(z)的期望值，而是使用该类的模型估计概率作为其在期望值中的权重。这将导致总体预期梯度为 0，因为我们将模型的当前信念作为基础事实，但我们仍然可以获得梯度(即梯度平方)的方差的估计，这是我们的费希尔矩阵中需要的，以(隐式)计算预测类空间中的 KL 散度。****

那么…有帮助吗？

这篇文章花了很多时间讨论力学:这个被称为自然梯度估计器的东西到底是什么，以及关于它如何以及为什么工作的更好的直觉。但是我觉得如果我不回答这个问题，我就是失职:这个东西真的提供价值吗？

简单的回答是:实际上来说，它并没有提供足够令人信服的价值来普遍用于大多数深度学习应用。有证据表明，自然梯度导致收敛发生在更少的步骤中，但是，正如我稍后将讨论的，这是一个有点复杂的比较。自然梯度的思想是优雅的，并且满足了那些对参数空间中任意缩放更新步骤感到沮丧的人。但是，除了优雅之外，我不清楚它是否提供了无法通过更多启发式方法提供的价值。

据我所知，自然梯度提供了两个关键的价值来源:

它提供了关于曲率的信息
它提供了一种方法让直接控制你的模型在预测分布空间的移动，与你的模型在损失空间的移动是分开的

弯曲

现代梯度下降的一大奇迹是它是用一阶方法完成的。一阶方法是只计算你想要更新的参数的导数，而不计算二阶导数的方法。有了一阶导数，你所知道的就是曲线在特定点的切线(多维版本)。你不知道切线变化有多快:二阶导数，或者更确切地说，你的函数在任何给定方向上的曲率水平。了解曲率是一件很有用的事情，因为在一个高曲率的区域，从一点到另一点的梯度变化很大，你可能要小心谨慎地迈出一大步，以免你攀登陡峭山峰的本地信号误导你跳下悬崖。我喜欢用一种更具启发性而非严格性的方式来思考这个问题，如果你在一个点与点之间的梯度变化很大(也就是说:方差很大)的区域，那么你对梯度的小批估计在某种意义上更不确定。相比之下，如果梯度在给定点几乎没有变化，那么在采取下一步时就不需要那么小心了。二阶导数信息非常有用，因为它可以让您根据曲率的级别来调整步长。

自然梯度实际上是，机械地，将你的参数更新除以梯度的二阶导数。相对于给定的参数方向，梯度变化越大，费希尔信息矩阵中的值就越高，并且该方向上的更新步长就越低。这里讨论的梯度是你的批次中的点的经验似然的梯度。这和关于损失的梯度不是一回事。但是，直觉上，可能性的巨大变化不对应损失函数的巨大变化是很罕见的。因此，通过捕捉关于对数似然导数空间在给定点的曲率的信息，自然梯度也为我们提供了真实、潜在损失空间中曲率的良好信号。有一个很强的论点，当自然梯度被证明可以加速收敛(至少在所需梯度步骤的数量方面)，这就是好处的来源。

然而。请注意，我说过自然梯度显示出加速收敛的梯度步骤。这种精度来自于这样一个事实，即自然梯度的每一步都需要更长的时间，因为它需要计算费希尔信息矩阵，记住，它是存在于 n_parameters 空间中的一个量。事实上，这种戏剧性的减速类似于通过计算真实损失函数的二阶导数而导致的减速。虽然可能是这样，但我没有看到任何地方说计算自然梯度费希尔矩阵比计算关于潜在损失的二阶导数更快。以此为假设，与对损失本身进行直接二阶优化的方法(也可能同样昂贵)相比，很难看出自然梯度提供了什么边际价值。

在理论预测仅一阶方法会失败的情况下，现代神经网络能够成功的很多原因是，深度学习实践者已经找到了一系列聪明的技巧，从本质上根据经验近似分析二阶导数矩阵中包含的信息。

动量作为一种优化策略，通过保持过去梯度值的运行指数加权平均值，并将任何给定的梯度更新偏向过去的移动平均值来工作。这有助于解决处于梯度值变化很大的空间中的问题:如果你不断地得到矛盾的梯度更新，它们会以这样或那样的方式平均化为没有强烈的意见，类似于减慢你的学习速度。相比之下，如果你反复得到同一个方向的梯度估计，这是一个低曲率区域的指示，并表明一个更大的步骤的方法，动量跟随。
RMSProp ，有趣的是，它是 Geoff hint on mid-Coursera-Coursera course 发明的，是对之前存在的 Adagrad 算法的温和修改。RMSProp 的工作原理是对过去的平方梯度值进行指数加权移动平均，换句话说，就是梯度的过去方差，然后用该值除以更新步长。这可以粗略地认为是对梯度二阶导数的经验估计。
Adam (自适应矩估计)，本质上结合了这两种方法，估计梯度的运行均值和运行方差。这是当今最常见、最默认使用的优化策略之一，主要是因为它可以消除一阶梯度信号的噪声

有趣的是，所有这些方法都值得一提的是，除了根据函数曲率来缩放更新步骤之外，它们还根据特定方向上的曲率量来不同地缩放不同的更新方向。这就涉及到我们之前讨论过的一些问题，关于如何用相同的量缩放所有参数可能不是一件明智的事情。你甚至可以从距离的角度来考虑这个问题:如果一个方向的曲率很高，那么在相同量的欧几里德参数空间中的一个步长将会使我们在梯度值的预期变化方面移动得更远。

因此，虽然在定义参数更新的一致方向方面，这没有自然梯度那么优雅，但它确实检查了大多数相同的框:在曲率不同的方向和时间点，以及理论上给定大小的参数步长具有不同程度的实际影响的地方，调整更新步长的能力。

直接分配控制

好的，那么，最后一节提出:如果我们的目标是使用对数似然的解析曲率估计作为损失的曲率估计的替代，为什么我们不做后者，或者近似后者，因为两种解析 N 计算似乎都非常耗时。但是，如果你真的关心预测的阶级分布的变化，而不仅仅是作为损失变化的代表，那该怎么办呢？那样的情况会是什么样的呢？

这种情况的一个例子大概不是巧合，是自然梯度方法当前使用的主要领域之一:信任区域策略优化在强化学习领域。TRPO 的基本直觉包含在灾难性失败或灾难性崩溃的想法中。在策略梯度设置中，您在模型末尾预测的分布是在操作上的分布，取决于某些输入状态。此外，如果您正在学习 on-policy，您的下一轮训练的数据是从您的模型的当前预测策略中收集的，则有可能将您的策略更新为一种制度，在这种制度下，您无法再收集有趣的数据来了解您的出路(例如，在一个圆圈中旋转的策略，这不太可能让您获得有用的奖励信号来学习)。这就是一项政策经历灾难性崩溃的含义。为了避免这种情况，我们希望谨慎行事，不要进行会显著改变我们政策的梯度更新(根据我们在给定场景中采取不同行动的概率)。如果我们在让我们预测的概率改变多少方面保持谨慎和渐进，这就限制了我们突然跳到一个不可行的制度的能力。

那么，这是自然梯度的一个更强的例子:在这里，我们真正关心控制的是在一个新的参数配置下，不同行为的预测概率会改变多少。我们关心它本身，而不仅仅是作为损失函数的代表。

开放式问题

我喜欢通过让你知道我对一个主题还有哪些困惑来结束这些帖子，因为，尽管解释者帖子的框架暗示了完全理解的崇高立场，但这并不完全是现实。和往常一样，如果你注意到我做错了什么，请评论/DM，我会努力改正的！

我从未最终发现计算对数似然费希尔矩阵是否比仅仅计算损失函数的海森更有效(如果是，这将是自然梯度作为获得损失表面曲率信息的更廉价方式的一个论据)
相对而言，我并不完全相信，当我们对对数概率的 z 取一个期望值时，这个期望值就是我们的模型预测的概率(期望值必须相对于某个概率集来定义)。

参考

“再访深层网络的自然梯度”
《自然神经网络》
[《为什么自然渐变》](http://- "It's in general hard to choose a consistent learning rate...because the the gradient scales vary in size for the different directions" (interesting, this is just discussing gradient magnitude, not curvature))
Sebastian Ruder 的关于自适应梯度方法的惊人帖子

如果你在排行榜上排名第二，就有可能赢得 ML 黑客马拉松

原文：https://towardsdatascience.com/its-possible-to-win-ml-hackathon-if-you-ranked-2nd-on-leaderboard-2b82a23474ea?source=collection_archive---------28-----------------------

在机器学习中，高精度的模型是成功的关键。尽管如此，模型是为最终用户构建的。这个故事将告诉您终端用户视角如何为数据科学的成功增加有价值的分数。

介绍

几周前，我们参加了由 Skoltech 研究机构主办的机器学习黑客马拉松。它发生在我们神奇的家乡俄罗斯喀山，持续了将近 2 天。一定要看看这个关于我们家乡的门户网站。

[## 参观鞑靼斯坦共和国的官方旅游门户——鞑靼斯坦

像当地人一样走路。从内部体验喀山的 5 种方式更多关于指南 100 参观鞑靼斯坦纪念品…

visit-tatarstan.com](https://visit-tatarstan.com/en/)

注意:前方剧透。我们在私人排行榜上排名第二，但我们仍然赢了，我将告诉你如何赢。

黑客马拉松概述

黑客马拉松有三条赛道:

基于网络的医生标签工具
分类癫痫类型的机器学习算法
开放跟踪医学领域人工智能的任何解决方案

作为数据科学家，我们毫不意外地选择了第二条路线。

问题描述

这项任务有两个方面:

建立一个模型，从脑 EEG 信号中正确分类 8 种癫痫。
构建一个 web 应用程序，输入一个文件并为最终用户提供一个预测。

Table 1. Types of Epilepsy Seizures

有 2012 个观察数据是从患有癫痫发作的患者那里收集的。每个观察值都包含基于时间的样本，并使用两种流行的方法进行预处理。关于数据预处理的更多细节请参见这篇文章。

Figure 1. Raw EEG Signals (tribute to WikiMedia Commons)

在预处理之后，我们收到了每个观测的两个文件:

形状的三维阵列[样本数、通道数、频率数]
形状的二维数组[样本数，频率数]

基准

测试方案是在文件水平上 5 倍交叉验证分割的平均加权 F1 分数，即文件被分割成 5 倍，然后它们才必须被解析，因为一个文件内的样本是高度相关的。如果你想知道如何计算交叉验证的 F1 加权分数，这里有 python 代码:

import numpy as np
from sklearn.metrics import f1_score
# assuming you have fold-wise true labels and predicted labels 
# as a list of tuples
val_scores = [f1_score(true_labels, predicted_labels, average=”weighted”) for true_labels,predicted_labels in fold_labels_and_predictions)]
mean_f1 = np.mean(val_scores)

本文作者在样本水平上提取矩阵的特征值，训练各种分类器，其中 K 近邻算法优于其他算法。他们使用方法 1 能够达到 88.4%的分数，使用方法 2 能够达到 90.7%的分数。

排行榜

至于排行榜，我们的本地 5 倍简历充当了公开分数的代理。至于个人得分，我们只有在演示我们的解决方案后才能知道。

但是，开头有一句主持人很重要的话。得分最高的团队不仅会根据个人得分进行排名，还会根据网络应用的质量进行排名。

神经网络

我们决定使用卷积神经网络，因为许多研究人员证明它非常适合癫痫检测任务。此外，我们发现脑电信号的采集过程受到在人体头部放置扫描仪的拓扑结构的影响。幸运的是，第一种预处理为 2D 卷积提供了合适的输入。

结构

我们为我们的通信网尝试了不同的主干网:

预训练的 Imagenet 型号(ResNet18、VGG11)
具有随机权重的 Imagenet 架构(也称为 ResNet18、VGG11)
从零开始的简单 CNN

显然，在 Imagenet 上预训练的模型表现不佳，因为输入没有共同点。具有随机权重的 ResNet 和 VGG 架构也没有优于简单的 convnet。我认为这是因为我们输入的空间维度非常小(20 像素高，24 像素宽)，而这些模型的第一个卷积层的滤波器大小为 7。我们最终会丢失一堆信号，有时输出维数为负(就像 AlexNet 一样)。

也就是说，经过长时间的实验，我们决定采用这个小模型:

3 块卷积、泄漏 ReLU、批量标准化和最大池
1 块卷积、泄漏 ReLU 和批量归一化
1 个全连接层

Figure 2. Our CNN Architecture

输入

因为我们使用了方法 1 预处理的数据集，所以我们的输入是[num_samples，20，24]的形状，而 num_samples 的范围可以从 3 到 100 以上。因此，我们尝试了不同的输入:

连续样本的随机窗口，窗口大小等于 1、3、5 和 10
所有样本的平均值，即输入形状为[1，20，24]
将标准差、最大值、最小值和平均值相加
将第 10、25、50、75 和 90 个百分点与平均值相加

不再说话，随机窗口根本不起作用。因此，我们取了所有样本的平均值，培训变得更加有趣，我们的指标几乎达到了 90% 。添加其他统计指标似乎没有帮助，通常我们的分数会下降。然而，第 25 和第 75 百分位给了我们 1% 的提升，我们让他们继续输入我们的形状[3，20，24]。

培训结果

几次迭代后，我们发现学习率在 0.002 和 0.005 之间的亚当优化器给我们带来了最高的性能，在交叉验证分数中增加了额外的 1% 。每个折叠被训练了 40 个时期。

最终的局部性能作为所有 5 次折叠的平均值来测量。我们以一倍最大值在 93.71% 触及 92.39% 。在所有队伍展示了他们的成绩后，我们排在第二位，比领先者落后 1% 。

在公布私人评分后，我们的业绩跃升至 94.5% 。遗憾的是，我们落后了 1%。

Web 应用程序

现在，你应该记得胜利还有一个标准。是的，一个 web 应用程序，医生可以提交一个文件并得到一个预测。

Table 2. Sample Model Output

我们决定分头努力开发一个漂亮的 web 应用程序表单。不要犹豫，从我们的驱动器下载一些示例文件来测试这个表单。很简单。只需上传一个或几个文件，以获得每个文件的预测。您还可以下载 CSV 格式的预测文件。

模型可解释性

我希望您已经花了一分钟来查看我们的应用程序。如果你有，你应该会注意到一个不寻常的图表，如下图所示。

Figure 3. Grad-CAM Output Interpretation

我们记得，在医学中，不仅要有非常高的精确度，还要有简洁的解释，这一点很重要。这就是为什么我们花时间带来梯度加权类激活映射给我们的用户一个工具来解释为什么我们的模型做出任何决定。简而言之，它使用类别预测、反向传播梯度和类别激活图来指出输入中感兴趣的区域。

这就是我们如何得到上面这两幅图像的。左图是样本平均值的热图，也称为输入矩阵，右图是 Grad-CAM 算法的输出，引起医生对最有影响的输入值的注意。

成功的解决方案

嗯，那是我们所有的秘制酱。我们将高精度模型与简单而完整的网络应用程序相结合，并用可视化模型解释来丰富一切。尽管我们在加权 F1 分数方面获得亚军，但黑客马拉松评审团赞赏我们考虑了医生如何最有效地使用这一解决方案。

此外，我们利用了从以前的黑客马拉松中学到的经验，即有一个团结的团队只致力于一个问题是非常重要的。我们有很好的专业组合，没有浪费我们有限的时间和精力在其他任务上。

关于团队的更多信息

我(Rustem Galiullin)——机器学习研究员——从事模型表演。
机器学习工程师 Almaz Melnikov 让我们的网络应用充满了功能，并整合了我们的神经网络。
前端开发人员 Konstantin Yarushkin 为我们的网络应用开发了一个模板。

Our smiley faces after winning

资源

项目网络应用https://deepl.herokuapp.com/
我们的 gitlab 回购https://gitlab.com/MelnikovAlmaz/epilepticsearch.git
pytorch 的 Grad-CAM 实施https://github.com/jacobgil/pytorch-grad-cam
Grad-CAM 项目【http://gradcam.cloudcv.org/
关于 https://www.skoltech.ru/en 斯科泰克

这是伟大的泵，查理·布朗

原文：https://towardsdatascience.com/its-the-great-pumpgan-charlie-brown-blog-exxact-bfd159d2c1fe?source=collection_archive---------22-----------------------

进入这个南瓜发电机教程甘斯的万圣节精神

(生成性对抗性训练。蓝线表示输入流，绿线表示输出，红线表示错误信号。)

生成对抗网络，简称 GANs，是过去 10 年中出现的最令人兴奋的深度学习领域之一。这是根据 MNIST 的 Yann LeCun 和反向传播的名声得出的。自 2014 年伊恩·古德费勒(Ian Goodfellow)等人引入 GANs 以来，对抗训练取得了快速进展，这标志着对抗训练是一种突破性的想法，完全有可能以有益、邪恶和愚蠢的方式改变社会。甘的训练被用于各种场合，从可预测的猫发电机到在艺术品拍卖会上以六位数卖出的甘“画”出来的虚构肖像画家。所有的 GANs 都基于决斗网络的简单前提:一个生成某种输出数据(在我们的例子中是图像)的创造性网络和一个输出数据是真实的或生成的概率的怀疑性网络。这些被称为“生成器”和“鉴别器”网络，通过简单地试图阻挠对方，它们可以学习生成真实的数据。在本教程中，我们将基于流行的全卷积 DCGAN 架构构建一个 GAN，并训练它为万圣节制作南瓜。

我们将使用 PyTorch ，但是您也可以使用 TensorFlow (如果您对它感到舒服的话)。使用任何一个主要深度学习库的体验都变得惊人地相似，鉴于今年 2.0 版本中对 TensorFlow 的更改，我们已经看到这是流行框架与动态执行的 pythonic 代码更广泛融合的一部分，具有可选的优化图形编译以加速和部署。

要为基本 PyTorch 实验设置和激活虚拟环境:

virtualenv pytorch --python=python3 pytorch/bin/pip install numpy matplotlib torch torchvision source pytorch/bin/activate

如果您安装了 conda，并且喜欢使用它:

conda new -n pytorch numpy matplotlib torch torchvision conda activate pytorch

为了节省您猜测的时间，下面是我们需要的导入:

import random import time import numpy as np import matplotlib.pyplot as plt import torch import torch.nn as nn import torch.nn.parallel import torch.optim as optim import torch.nn.functional as F import torch.utils.data import torchvision.datasets as dset import torchvision.transforms as transforms import torchvision.utils as vutils

我们的 GAN 将基于 DCGAN 架构，并大量借鉴 PyTorch 示例中的官方实现。“DCGAN”中的“DC”代表“深度卷积”，DCGAN 架构扩展了 Ian Goodfellow 的原始 GAN 论文中描述的无监督对抗训练协议。这是一个相对简单易懂的网络架构，可以作为测试更复杂想法的起点。

与所有 GAN 一样，DCGAN 架构实际上由两个网络组成，即鉴别器和发生器。重要的是要保持它们在力量、训练速度等方面的平衡。以避免网络变得不匹配。众所周知，GAN 训练是不稳定的，可能需要相当多的调整才能使其在给定的数据集架构组合上工作。在这个 DCGAN 示例中，很容易陷入生成器输出黄色/橙色棋盘格乱码的困境，但是不要放弃！总的来说，我非常钦佩像这样的小说突破的作者，他们很容易因早期的糟糕结果而气馁，可能需要英雄般的耐心。话又说回来，有时这只是一个充分准备和一个好主意的问题，只需要几个小时的额外工作和计算事情就解决了。

生成器是一堆转置的卷积层，将一个细长的多通道张量潜在空间转换为全尺寸图像。DCGAN 论文中的下图对此进行了举例说明:

来自拉德福德的全卷积生成器等 2016。

我们将实例化为torch.nn.Module类的子类。这是一种实现和开发模型的灵活方式。您可以在forward类函数中植入种子，允许合并像跳过连接这样的东西，这在简单的torch.nn.Sequential模型实例中是不可能的。

class Generator(nn.Module): def __init__(self, ngpu, dim_z, gen_features, num_channels): super(Generator, self).__init__() self.ngpu = ngpu self.block0 = nn.Sequential(\ nn.ConvTranspose2d(dim_z, gen_features*32, 4, 1, 0, bias=False),\ nn.BatchNorm2d(gen_features*32),\ nn.ReLU(True)) self.block1 = nn.Sequential(\ nn.ConvTranspose2d(gen_features*32,gen_features*16, 4, 2, 1, bias=False),\ nn.BatchNorm2d(gen_features*16),\ nn.ReLU(True)) self.block2 = nn.Sequential(\ nn.ConvTranspose2d(gen_features*16,gen_features*8, 4, 2, 1, bias=False),\ nn.BatchNorm2d(gen_features*8),\ nn.ReLU(True)) self.block3 = nn.Sequential(\ nn.ConvTranspose2d(gen_features*8, gen_features*4, 4, 2, 1, bias=False),\ nn.BatchNorm2d(gen_features*4),\ nn.ReLU(True)) self.block5 = nn.Sequential(\ nn.ConvTranspose2d(gen_features*4, num_channels, 4, 2, 1, bias=False))\ def forward(self, z): x = self.block0(z) x = self.block1(x) x = self.block2(x) x = self.block3(x) x = F.tanh(self.block5(x)) return x

是我们“甘多”中有创造力的那一半，而创造看似新奇的图像的习得能力是大多数人倾向于关注的。事实上，如果没有一个匹配良好的鉴别器，发电机是没有希望的。鉴别器架构对于那些过去构建过一些深度卷积图像分类器的人来说应该很熟悉。在这种情况下，它是一个二进制分类器，试图区分真假，所以我们在输出中使用 sigmoid 激活函数，而不是我们在多类问题中使用的 softmax。我们也去掉了所有完全连接的层，因为它们在这里是不必要的。

全卷积二进制分类器适合用作鉴别器【D(x)。

代码是:

class Discriminator(nn.Module): def __init__(self, ngpu, gen_features, num_channels): super(Discriminator, self).__init__() self.ngpu = ngpu self.block0 = nn.Sequential(\ nn.Conv2d(num_channels, gen_features, 4, 2, 1, bias=False),\ nn.LeakyReLU(0.2, True)) self.block1 = nn.Sequential(\ nn.Conv2d(gen_features, gen_features, 4, 2, 1, bias=False),\ nn.BatchNorm2d(gen_features),\ nn.LeakyReLU(0.2, True)) self.block2 = nn.Sequential(\ nn.Conv2d(gen_features, gen_features*2, 4, 2, 1, bias=False),\ nn.BatchNorm2d(gen_features*2),\ nn.LeakyReLU(0.2, True)) self.block3 = nn.Sequential(\ nn.Conv2d(gen_features*2, gen_features*4, 4, 2, 1, bias=False),\ nn.BatchNorm2d(gen_features*4),\ nn.LeakyReLU(0.2, True)) self.block_n = nn.Sequential( nn.Conv2d(gen_features*4, 1, 4, 1, 0, bias=False),\ nn.Sigmoid()) def forward(self, imgs): x = self.block0(imgs) x = self.block1(x) x = self.block2(x) x = self.block3(x) x = self.block_n(x) return x

我们还需要一些帮助函数来创建数据加载器，并根据 DCGAN 论文中的建议初始化模型权重。下面的函数返回一个 PyTorch 数据加载器，带有一些轻微的图像增强，只需将它指向包含您的图像的文件夹。我正在处理来自 Pixabay 的相对较少的一批免费图像，因此图像放大对于从每张图像中获得更好的效果是很重要的。

def get_dataloader(root_path): dataset = dset.ImageFolder(root=root_path,\ transform=transforms.Compose([\ transforms.RandomHorizontalFlip(),\ transforms.RandomAffine(degrees=5, translate=(0.05,0.025), scale=(0.95,1.05), shear=0.025),\ transforms.Resize(image_size),\ transforms.CenterCrop(image_size),\ transforms.ToTensor(),\ transforms.Normalize((0.5,0.5,0.5), (0.5,0.5,0.5)),\ ])) dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,\ shuffle=True, num_workers=num_workers) return dataloader

并初始化权重:

def weights_init(my_model): classname = my_model.__class__.__name__ if classname.find("Conv") != -1: nn.init.normal_(my_model.weight.data, 0.0, 0.02) elif classname.find("BatchNorm") != -1: nn.init.normal_(my_model.weight.data, 1.0, 0.02) nn.init.constant_(my_model.bias.data, 0.0)

这就是函数和类的全部内容。现在剩下的就是用一些脚本将它们联系在一起(以及对超参数的无情迭代)。将超参数分组在脚本顶部附近是一个好主意(或者用 flags 或 argparse 将它们传入)，这样很容易更改值。

# ensure repeatability my_seed = 13 random.seed(my_seed) torch.manual_seed(my_seed) # parameters describing the input latent space and output images dataroot = "images/pumpkins/jacks" num_workers = 2 image_size = 64 num_channels = 3 dim_z = 64 # hyperparameters batch_size = 128 disc_features = 64 gen_features = 64 disc_lr = 1e-3 gen_lr = 2e-3 beta1 = 0.5 beta2 = 0.999 num_epochs = 5000 save_every = 100 disp_every = 100 # set this variable to 0 for cpu-only training. This model is lightweight enough to train on cpu in a few hours. ngpu = 2

接下来，我们实例化模型和数据加载器。我使用双 GPU 设置来快速评估一些不同的超参数迭代。在 PyTorch 中，通过将模型包装在torch.nn.DataParallel类中，在几个 GPU 上进行训练是微不足道的。如果您的所有 GPU 都被束缚在对人工通用智能的追求中，请不要担心，这种模型足够轻量级，可以在合理的时间内(几个小时)训练 CPU。

dataloader = get_dataloader(dataroot) device = torch.device("cuda:0" if ngpu > 0 and torch.cuda.is_available() else "cpu") gen_net = Generator(ngpu, dim_z, gen_features, \ num_channels).to(device) disc_net = Discriminator(ngpu, disc_features, num_channels).to(device) # add data parallel here for >= 2 gpus if (device.type == "cuda") and (ngpu > 1): disc_net = nn.DataParallel(disc_net, list(range(ngpu))) gen_net = nn.DataParallel(gen_net, list(range(ngpu))) gen_net.apply(weights_init) disc_net.apply(weights_init)

发生器和鉴别器网络在一个大循环中一起更新。在此之前，我们需要定义我们的损失标准(二进制交叉熵)，为每个网络定义优化器，并实例化一些我们将用来跟踪训练进度的列表。

criterion = nn.BCELoss() # a set sample from latent space so we can unambiguously monitor training progress fixed_noise = torch.randn(64, dim_z, 1, 1, device=device) real_label = 1 fake_label = 0 disc_optimizer = optim.Adam(disc_net.parameters(), lr=disc_lr, betas=(beta1, beta2)) gen_optimizer = optim.Adam(gen_net.parameters(), lr=gen_lr, betas=(beta1, beta2)) img_list = [] gen_losses = [] disc_losses = [] iters = 0

训练循环

训练循环在概念上是简单明了的，但是用一个片段来概括有点长，所以我们将把它分成几个部分。概括地说，我们首先基于对一组真实的和生成的图像的预测来更新鉴别器。然后，我们将生成的图像馈送到新更新的鉴别器，并使用来自【D(G(z))的分类输出作为生成器的训练信号，使用真实标签作为目标。

首先，我们将进入循环并执行鉴别器更新:

t0 = time.time() for epoch in range(num_epochs): for ii, data in enumerate(dataloader,0): # update the discriminator disc_net.zero_grad() # discriminator pass with real images real_cpu = data[0].to(device) batch_size= real_cpu.size(0) label = torch.full((batch_size,), real_label, device=device) output = disc_net(real_cpu).view(-1) disc_real_loss = criterion(output,label) disc_real_loss.backward() disc_x = output.mean().item() # discriminator pass with fake images noise = torch.randn(batch_size, dim_z, 1, 1, device=device) fake = gen_net(noise) label.fill_(fake_label) output = disc_net(fake.detach()).view(-1) disc_fake_loss = criterion(output, label) disc_fake_loss.backward() disc_gen_z1 = output.mean().item() disc_loss = disc_real_loss + disc_fake_loss disc_optimizer.step()

请注意，我们还记录了假批次和真批次的平均预测值。这将通过告诉我们每次更新后预测如何变化，给我们一个简单的方法来跟踪我们的训练有多平衡。

接下来，我们将使用真实标签和二进制交叉熵损失，基于鉴别器的预测来更新生成器。请注意，我们是基于鉴别器将假图像误分类为真实图像来更新生成器的。与最小化鉴别器直接检测假货的能力相比，该信号为训练产生更好的梯度。令人印象深刻的是，甘斯最终能够学会制作基于这种决斗损失信号的真实感内容。

# update the generator gen_net.zero_grad() label.fill_(real_label) output = disc_net(fake).view(-1) gen_loss = criterion(output, label) gen_loss.backward() disc_gen_z2 = output.mean().item() gen_optimizer.step()

最后，有一点内务管理来跟踪我们的训练。平衡 GAN 训练是一门艺术，仅仅从数字上并不总是显而易见你的网络是否有效地学习，所以偶尔检查图像质量是一个好主意。另一方面，如果 print 语句中的任何值变为 0.0 或 1.0，那么您的训练很可能已经失败，使用新的超参数进行迭代是一个好主意。

if ii % disp_every == 0: # discriminator pass with fake images, after updating G(z) noise = torch.randn(batch_size, dim_z, 1, 1, device=device) fake = gen_net(noise) output = disc_net(fake).view(-1) disc_gen_z3 = output.mean().item() print("{} {:.3f} s |Epoch {}/{}:\tdisc_loss: {:.3e}\tgen_loss: {:.3e}\tdisc(x): {:.3e}\tdisc(gen(z)): {:.3e}/{:.3e}/{:.3e}".format(iters,time.time()-t0, epoch, num_epochs, disc_loss.item(), gen_loss.item(), disc_x, disc_gen_z1, disc_gen_z2, disc_gen_z3)) disc_losses.append(disc_loss.item()) gen_losses.append(gen_loss.item()) if (iters % save_every == 0) or \ ((epoch == num_epochs-1) and (ii == len(dataloader)-1)): with torch.no_grad(): fake = gen_net(fixed_noise).detach().cpu() img_list.append(vutils.make_grid(fake, padding=2, normalize=True).numpy()) np.save("./gen_images.npy", img_list) np.save("./gen_losses.npy", gen_losses) np.save("./disc_losses.npy", disc_losses) torch.save(gen_net.state_dict(), "./generator.h5") torch.save(disc_net.state_dict(), "./discriminator.h5") iters += 1

可能需要一点努力才能得到可接受的结果，但幸运的是，现实中的小故障实际上更适合放大令人毛骨悚然的效果。这里描述的代码还可以改进，但是对于低分辨率下看似合理的南瓜灯应该是不错的。

大约 5000 次更新后的训练进度。

希望上面的教程能激起你对长袍和/或万圣节工艺品的兴趣。掌握了我们在这里构建的基本 DCGAN 之后，尝试更复杂的架构和应用程序。训练 GANs 在很大程度上仍然是一门艺术，平衡训练是棘手的。使用来自 ganhacks 的提示，在获得适用于您的数据集/应用程序/想法的简化概念证明后，一次只添加一小块复杂性。祝你好运，训练愉快。

原载于 2019 年 10 月 28 日【https://blog.exxactcorp.com】。

是时候更多地考虑管道了

原文：https://towardsdatascience.com/its-time-to-think-more-about-the-pipeline-5346c039a803?source=collection_archive---------25-----------------------

tool 工具简介

TPOT (Tree-Based Pipeline Optimization Tool)

看到数据科学始终关注改进算法和技术来分析激增的数据以提取模式，这总是令人兴奋的。这些模式可以创造新的见解或成为新的决策方法，而如果没有数据科学过程的帮助，这些模式很难学习。

然而，该过程通常需要从业者的技能和经验。他们应该能够收集足够的和适当的数据集，清理和预处理它，挑选和比较多个模型，调整模型的参数，并阐明结果。这个处理元素链构成了数据分析的管道。虽然许多数据科学家急切地改进每个元素(更常见的是模型，它类似于管道中的生产元素，因此是有趣的部分)，但促进管道设计也很重要。因此，自动化管道不仅可以帮助数据科学家，也可以让非专家更容易使用。

数据科学中的管道表示数据科学项目的主流，包括从数据清理、特征工程、模型选择、模型优化和模型验证的不同阶段。

最近，我看了一篇的论文，是关于一个叫做 TPOT(基于树的管道优化工具)的自动化管道优化工具。在加州大学欧文分校机器学习库中的一些基准数据集上进行测试，该工具展示了类似于基本机器学习分析的出色数据分析结果。同时，该工具需要用户较少的先验知识。TPOT 可以自动探索预处理和模型操作的组合，并且在某些情况下，胜过基本的机器学习分析。

(Source😃

在完成探索性数据分析和数据清理之后，TPOT 可以自动探索数据科学项目阶段的组合。这些阶段包括特征选择、特征预处理(例如 PCA)、特征构建、模型选择(例如选择随机森林模型或监督向量机模型)和参数优化。然后，TPOT 可以发现输出最佳结果的最佳组合，即分类问题的最高准确度。

在 TPOT 之前，数据科学家已经开发了一些机器学习自动化方法。其中一个著名的库是 grid research，它探索从业者提供的参数组合，以找到最适合的模型。最近，已经发现随机评估参数集执行更好的结果，例如，贝叶斯优化。

机器学习自动化的另一种方式是特征构建，它从原始特征构建新的中间特征以实现更好的性能。

TPOT 机器学习自动化工具是一种替代方式，通过遗传编程建立基于树的流水线进化。TPOT 使用几个基本的管道操作符，然后将它们组合成一个基于树的管道。之后，可以通过遗传编程来进化基于树的流水线，以处理最终输出。

(Source😃

传统上，遗传编程使用叶和节点构建树来表示优化特定标准的数学运算。叶子是操作数，节点是运算符，当它们组合在一起时，可以更新最终结果。

基本的流水线操作包括预处理、分解、特征选择和建模。预处理程序包括“标准标量”、“鲁棒标量”(缩放特征)和“多项式特征”(生成新特征)。分解是“随机化 PCA”，一种使用随机化 SVD 的主成分分析。特征选择包括“RFE”(递归特征消除策略)、“选择最佳”(选择前 k 个最佳特征)、“选择百分位数”(选择前 n 个百分位数特征)和“方差阈值”(过滤掉不满足最小方差阈值的特征)。该模型包括“决策树分类器”、“RandomForestClassifier”、“GradiantBoostClassifier”、“支持向量机”、“LogisticRegression”和“KNeighborsClassifier”。

(Source😃

为了组装基于采油树的管道，TPOT 使用类似于上图所示的结构。在数据集的多个副本中，每个数据集都通过四类操作符中的一类进行传递。之后，可以将它们组合起来形成新的数据集，从而创建组合要素。那么你可能会问如果算子是模型呢，那岂不是和最后的“RandomForestClassifier”相矛盾？答案是，一旦操作符是一个模型，模型输出将覆盖以前的预测。此外，先前的预测将成为新的特征。最后的“RandomForestClassifier”是最终的预测。

然后，TPOT 使用进化计算技术遗传编程(GP)来优化基于树的流水线。遗传编程有助于表示每个算子及其参数的计算，以最大限度地提高精度。每个计算都是一个序列，可以被修改、删除或插入到基于树的流水线中。还有 TPOT 管道的变体，如 TPOT-帕累托管道，它可以最大限度地提高预测的准确性，同时最小化管道的复杂性。

为了评估 TPOT 的性能，测试了来自 UC Irvine 机器学习库的 7 个数据集。结果如下所示。

(Source😃

TPOT(随机研究)用管道的随机生成来表示 TPOT。请注意，TPOT 的缺失箱线图(随机搜索)表明计算时间超过 120 小时。每个箱线图中的凹口代表中位数的 95%置信区间。

如图所示，在大多数数据集中，TPOT 的性能与随机森林相似。然而，对于一些数据集，如 Hill Valley 和 car evaluation，TPOT 和 TPOT (Pareto)优于其他两种算法。通常，TPOT(随机搜索)有一个主要缺点，即运行时间过长。另一方面，TPOT 和 TPOT (Pareto)的所有重复在 48 小时内运行。TPOT(随机搜索)的另一个缺点是复杂。总体而言，TPOT (Pareto)流水线在保持紧凑性的同时实现了最佳精度。

优化整个流水线计算应该同等重要，而不是关注流水线的子集。机器学习流水线的自动设计可以通过节省时间量和为模型创建新的基线而有益于机器学习实践者。此外，由于它的可访问性，它对非专家也是有益的。

非常感谢您的阅读！干杯！

雅可比正则化

原文：https://towardsdatascience.com/jacobian-regularization-7db8836538cc?source=collection_archive---------22-----------------------

L1 和 L2 正则化的推广

Photo by Tom Mussak on Unsplash

L1 和 L2 正则化，也称为拉索和山脊，是众所周知的正则化技术，用于各种算法。这些方法的思想是使预测函数平滑并避免过拟合。考虑这个多项式回归的例子:

Source: https://scikit-learn.org/stable/auto_examples/model_selection/plot_underfitting_overfitting.html#sphx-glr-auto-examples-model-selection-plot-underfitting-overfitting-py

在本例中，我们将不同次数的多项式拟合到数据中，其中高斯噪声被添加到一个函数中，该函数在这里被标识为橙色曲线。我们看到，对于 15 次多项式，预测曲线非常不平滑，并且该模型不能很好地概括，这与预测曲线非常接近原始曲线的 4 次多项式模型相反。

提高平滑度和避免过拟合的一种方法是在成本函数中加入正则项:

Source: http://statweb.stanford.edu/~tibs/sta305files/Rudyregularization.pdf

这里，参数β通常不包括截距。这个正则项将试图降低参数，以提高平滑度。但是会用同样的力把参数拉下来。但是在多项式回归的情况下，惩罚较高次项比惩罚较低次项更有意义。于是，L2 正则化的推广被称为吉洪诺夫正则化，当 β 的平方和被吉洪诺夫矩阵和向量 β 的乘积的平方范数所代替。寻找 Tiknonov 矩阵的最优值通常是困难的过程，尤其是对于神经网络，其中参数的数量是巨大的。

为了解决这个问题，在最近的论文“利用雅可比正则化的鲁棒学习”中提出了一种新的方法来提供可以对简单和复杂模型都起作用的正则化过程

之前已经指出，L2 正则化等同于向输入层添加高斯噪声。事实上，对于前馈网络，输入噪声始终给出比 L2 正则化更好的结果。该论文(和其他几篇论文)的作者使用这一思想来推导适用于简单和复杂模型的广义正则化项。想法是，对于小扰动，我们可以使用 logit 函数的泰勒展开式(在我们应用 sigmod 或 softmax 之前最后一层的输出):

这里我们介绍了一个雅可比 J :

其中 c 是输出类(对于多类分类问题), I 是输入的组成部分。正则项将试图最小化输入-输出雅可比矩阵的 Frobenius 范数:

因此，我们正在最小化的总成本函数如下所示:

这种方法由 Jure Sokoli、Raja Giryes、Guillermo Sapiro 和 Miguel RD Rodrigues 在他们的论文Robust large margin deep neural networks中提出，但由于多类分类问题的计算复杂性，没有得到太多关注。本文通过在单位球面上随机采样来逼近雅可比矩阵，从而克服了这些挑战。为了计算导数，我们可以使用所有现代深度学习框架中可用的自动微分。

我们可以将类似的方法应用于我们在开始时讨论的多项式回归。我们将曲线建模为多项式函数:

这里 d 是多项式的次数。这种情况下的雅可比矩阵是 1×1 矩阵:

那么正则项可以写成:

这里我们对观测值 I 求和。注意，这将是 a 的复二次函数，可能与简单的 L2 正则化函数非常不同。还要注意，这个估计值可能有偏差，必须应用某种贝塞尔校正。本文中没有讨论这一点，但是估计偏差并进一步改进结果是很有趣的。

可以预见，如果我们将函数建模为一次多项式(这将使其成为线性回归)，正则化项将变为:

那正是 L2 正规化！

结论

神经网络的正则化仍然是一个活跃的研究领域，我们回顾的这篇论文以及其他几篇论文继续推进它，提高准确性，同时也为正则化技术奠定了坚实的理论基础。雅可比正则化不仅可以应用于神经网络，还可以应用于其他算法，例如多项式回归。

一月版:图像和语音识别

原文：https://towardsdatascience.com/january-edition-image-and-speech-recognition-43a15669fe75?source=collection_archive---------21-----------------------

10 篇必读文章

多亏了进化，人类取得了长足的进步。贪得无厌的探索和实验欲望使人类超越了其他生物。要想做大，首先你需要一步一步来，一次一步来。复杂的人体解剖学进化了数百万年，这将继续进化到一个我们甚至无法想象的状态。对探索和实验的贪得无厌的渴望源于人类通过其基本的五种感官“视觉”、“听觉”、“嗅觉”、“味觉”和“触觉”来推断其周围环境的能力。

如果我们将进化快进到今天，作为人类，我们可以为自己迄今为止走过的旅程感到无比自豪。今天，我们讨论殖民火星和超越我们的银河系。毫无疑问，人类在知识、科学和技术方面取得了巨大的成功。技术已经成为日常生活中的必需品，并以显著的方式提高了生活质量。即使人们利用技术，我们在技术进步方面处于一个超高的位置，这些工具背后的驱动力仍然是人类的勇气和大脑。20 世纪 50 年代和 60 年代的科学家开始研究和实验“如何教机器像人类一样学习”的想法。正如进化过程需要年复一年，这个想法也需要几十年才能迈出最初的几步。

感谢有远见的思想家的辛勤工作，他们是现代人工智能(深度学习)的先驱，我们看到了通往人类进化下一个时代的充满希望的旅程。“数据是新的石油”。随着海量数据的可用性，高性能计算、分布式系统(云计算)的力量，以及能够访问免费和开源技术，今天我们看到了人工智能的巨大创新。人工智能的最终目标是让人类能够做我们以前从未想象过的巨大工作。今天，我们听到关于机器在某些任务/工作(DOTA、医学成像等)中击败人类智能的新闻。)，但这并不是它的结束，它仅仅是一个漫长的成功旅程的开始。

当今研究界试图解决的挑战之一是，赋予机器从视觉和声音中识别、生成和推断决策的能力。过去几年，我们看到围绕深度学习的许多方面进行了大量的研究工作，特别是在计算机视觉、自然语言处理/生成、几何深度学习和 GANs 等领域，研究人员试图将视觉和语音引入机器。根据我们的读者统计和反馈，我们希望在“图像和语音识别”主题下展示我们平台的几篇精选文章

TDS 编辑助理查敏·纳林达。

图像识别/生成

教程:搭建车道检测器

By Chuan En Lin 林傳恩 — 10 min read

Waymo 的自动驾驶出租车服务本月刚刚上路——但自动驾驶汽车是如何工作的呢？道路上画的线向人类驾驶员指示车道在哪里，并作为相应地驾驶车辆的方向的指导参考，以及车辆代理如何在道路上和谐互动的约定。

2018 年 CVPR 十大最酷论文

到乔治·赛义夫 — 8 分钟读完

2018 年计算机视觉和模式识别大会(CVPR)于上周在美国盐湖城举行。这是计算机视觉领域的世界顶级会议。今年，CVPR 收到了 3300 份主要会议论文，接受了 979 份。超过 6500 人参加了会议，好家伙，这是史诗！6500 人挤进了这个房间:

YOLO v3 有什么新功能？

通过 Ayoosh Kathuria — 9 分钟读取

你只看一次，或 YOLO，是一个更快的对象检测算法。虽然它不再是最准确的对象检测算法，但当您需要实时检测时，它是一个非常好的选择，不会损失太多的准确性。

Only Numpy:使用带有交互代码的 Numpy 实现 GAN 和 Adam 优化器。

由 Jae Duk Seo — 6 分钟阅读

所以今天我被这篇博文“TensorFlow 中的生成性对抗网络”所启发，我想用 Numpy 自己实现 GAN。这里是 @ goodfellow_ian 的 GAN 论文原文。下面是从简单的 GAN 生成的所有图像的 gif。

使用 Tensorflow、OpenCV 和 Docker 进行实时和视频处理对象检测。

由莱奥·博科特 — 7 分钟读完

在本文中，我将介绍如何在 Docker 容器中使用 Tensorflow 对象检测 API 来执行实时(网络摄像头)和视频后处理。我使用 OpenCV 和 python3 多处理和多线程库。

音频/语音识别

递归神经网络:语言建模的发电站

由詹姆斯·勒 — 12 分钟读完

大学三年级春季学期，我有机会去丹麦哥本哈根留学。在此之前，我从未去过欧洲，所以我非常兴奋地沉浸在一种新的文化中，结识新的人，去新的地方旅行，最重要的是，遇到一种新的语言。

使用 Youtube V3 API、Mask-RCNN 和 Google Vision API 自动收集语音识别数据

By 黃功詳 Steeve Huang — 8 min read

随着机器学习特别是深度学习的快速发展，语音识别得到了显著的提高。这种技术依赖于大量高质量的数据。

使用 FastAI 和即时频率变换的音频分类

约翰·哈特奎斯特 — 9 分钟阅读

虽然深度学习模型能够帮助解决许多不同类型的问题，但图像分类是课程和框架最普遍的例子，通常充当“你好，世界”的介绍。

具有人工智能的仿人机器听觉

丹尼尔·罗斯曼(Daniel Rothmann)—9 分钟阅读

人工智能技术的重大突破是通过模拟人类系统实现的。虽然人工神经网络(NNs)是与实际人类神经元的功能方式仅松散耦合的数学模型，但它们在解决复杂和模糊的现实世界问题方面的应用已经非常广泛。

Kaggle Tensorflow 语音识别挑战

由克里斯迪南 — 12 分钟阅读

从 2017 年 11 月到 2018 年 1 月，谷歌大脑团队在 Kaggle 上举办了一场语音识别挑战赛。这项挑战的目标是编写一个程序，能够正确识别一秒钟长的音频文件中 10 个单词中的一个。

我们也感谢最近加入我们的所有伟大的新作家，古伊列梅·利尚德，艾蒙·汗，波尔·费兰多，艾蒙·汗，皮查亚·蒂普卡姆，萨利赫·图顿博士，伊恩·马科姆伯，道格拉斯·科英布拉·德安德拉德，里沙布·加尔格，法兰克福学派、戈塔姆·内坎蒂、马西莫·贝洛尼、托默·克图雷尔、乔纳森·奥海克斯、文森特·万霍克、妮可·关、科林·辛克莱、阿什里斯、迈克尔·亨格、我们邀请你看看他们的简介，看看他们的工作。

理解 Javascript“this”关键字(上下文)

原文：https://towardsdatascience.com/javascript-context-this-keyword-9a78a19d5786?source=collection_archive---------9-----------------------

Photo by sydney Rae on Unsplash

当一个人开始学习 javascript 时，上下文是总会造成很多困惑的话题之一，也是面试官经常问的话题。

让我们开始…

什么是语境？

Context 总是关键字this的值，它是对“拥有”当前正在执行的代码或函数的对象的引用。

我们知道window在浏览器中是一个全局对象，所以如果我们在控制台中键入this，它应该返回窗口对象，它确实返回了。

在 node.js CLI 中，如果你尝试做上面的事情，你会得到一个拥有所有全局使用的函数的对象，比如console、process等等。(试一次)。

注意:*this*关键字的值取决于函数运行/调用/使用的对象。因此this关键字有不同的值，这取决于它的使用场合。

注意:从现在开始，这个和上下文可以互换使用。

上下文—全局和函数内部。

this at the global level called on the global object

foo是在全局级定义的函数，在全局级对象上调用，即window，所以调用foo和window.foo是一样的。因此上下文是一个window对象。

this inside function called on function object at global level

然而，如果我们在全局层次上做new foo()，那么将得到this作为foo对象。

注意:new操作符创建一个对象的实例。函数的上下文将被设置为创建的对象实例。

上下文—在二级功能下

上下文——当函数被全局定义并在对象下使用时(隐式绑定)。

注意:从上面我们可以看出this关键字的值取决于被调用的函数，而不是定义函数的地方。

上下文在“使用严格”中如何表现？

当在一个函数中使用use strict时，上下文即该关键字的行为不同。上下文保持它被调用时的样子。

注意:我们的整个程序可能应该是strict或non-strict。然而，有时你包含一个第三方库，它比你自己的代码有不同的严格性，所以必须注意这些微妙的兼容性细节。

上下文在箭头函数中如何表现？

就上下文而言，箭头函数的工作方式不同于常规函数。this将总是引用词法范围(在这里是关于范围)，即this保留封闭词法上下文的值。

在全局代码中，它将被设置为全局对象，因此我们得到上面的 true。

上下文在对象的原型链上如何表现？

上下文遵循同样的规则，即如果函数在对象的原型链上，this指的是方法被调用的对象。

如果我们调用obj.func()将会得到undefined，如果func被调用于从定义了x的obj创建的newObj，那么它将会返回值 10。

上下文在事件处理程序中如何表现？

案例事件处理程序中的上下文指的是接收事件的元素。

这里我们在 DOM 的 body 标签上添加了一个 jquery click 事件，我们可以看到上下文返回了 body 元素。

上下文在执行上下文中是如何表现的？

如果你不知道什么是执行上下文(这里读)。简而言之，执行上下文是函数执行的“环境”或范围。每次调用一个函数，都会创建一个新的execution context。对一个execution context的每个调用有两个阶段

创建—调用函数时
激活—执行功能时

this的值在创建阶段确定，而不是在执行时确定。然而，this判定规则保持不变。

上下文和范围有什么不同？

范围和上下文是完全不同的概念，但通常被新开发人员互换使用。

范围是运行时代码中某个特定部分的变量、函数或对象的可访问性。点击此处了解更多关于示波器的信息。

每个函数调用都有一个关联的范围和上下文。

如何显式改变上下文？

我们可以通过使用call()、apply()和bind()方法来动态地改变任何方法的上下文。

调用— 第一个参数call是您想要使用的上下文。之后，您可以在中传递任意数量的逗号分隔值。

foo.call(context, param1, param2, param3 );

应用— 这与call相同，但在自变量数量的意义上有所不同。仅应用支持的 2 个参数，上下文和值数组。

foo.apply( context,[param1, param2, param3]);

Bind — 它返回一个新函数，该函数永久绑定到bind的第一个参数，不管该函数是如何使用的。bind不立即调用绑定的函数，而是返回一个我们稍后可以运行的新函数。

为什么我们需要显式地改变上下文？

当我们需要调用定义在一个对象内部的函数时，比如说x，但是在其他对象上，比如说y，我们可以使用显式方法来这样做，以增加 的可重用性。

2.Currying and partial application是另一个使用上下文显式变化的部分。

3.使效用函数像

4.继承是另一个可以使用上下文显式更改的地方。

如果你知道更多原因，请在下面评论:)

我们需要考虑上下文的情况有哪些？

我们可能会丢失上下文，即在中获取this的undefined值

1.嵌套函数

我们需要保留调用回调函数时引用的obj对象的上下文，在上面的例子中，这种情况不会发生，我们会得到错误。

我们可以通过用下面的代码替换exec来消除上面的错误

// use of bind
exec: function () {
    this.f2(function () {
        this.f1();
    }.bind(this));
}// use of arrow function
exec: function () {
    this.f2(() => {
        this.f1();
    });
}// another way not recommended though
exec: function () {
   var that = this;
    this.f2(() => {
        that.f1();
    });
}

2.方法作为回调

let obj = {
  name: "test",
  waveHi() {
    return ('Hi',this.name);
  }
};

setTimeout(obj.waveHi, 1000)

上面会返回Hi undefined，想一秒为什么？这是因为最后一行将会变成

let f = obj.waveHi;
setTimeout(f, 1000);

并且，setTimeout得到了与对象obj分开的函数obj.waveHi

解决方案是

// Wrapping function
setTimeout(function() {
  obj.waveHi(); // Hi Test
}, 1000);// Arrow function
setTimeout(() => obj.waveHi(), 1000); // Hi Test// use of bind
let waveHi = obj.waveHi.bind(obj);
waveHi() // Hi Test

注意:

1.创建“绑定方法引用”需要匿名包装函数和调用成本。在特定情况下，利用闭包可能是更好的选择。

2.任何类型的函数引用(作为值赋值，作为参数传递)都会失去函数的原始绑定。

如果您想被添加到我的电子邮件列表中，请考虑在这里输入您的电子邮件地址和关注我的 medium 阅读更多关于 javascript 的文章，并关注github查看我的疯狂代码。如果有什么不清楚或者你想指出什么，请在下面评论。

你可能也会喜欢我的其他文章

Javascript 执行上下文和提升
Javascript —生成器-产出/下一个&异步-等待🤔
Javascript 数据结构与映射、归约、过滤
Javascript- Currying VS 部分应用
Javascript ES6 —可迭代程序和迭代器
Javascript —代理， Javascript —作用域

如果你喜欢这篇文章，请随时分享，并帮助他人找到它！

谢谢！

Javascript 执行上下文和提升

原文：https://towardsdatascience.com/javascript-execution-context-and-hoisting-c2cc4993e37d?source=collection_archive---------17-----------------------

这篇文章是写给那些不知道 JavaScript 是如何执行的人的。

先决条件:你应该知道

JavaScript 中的作用域
JavaScript 中的这个关键字
电脑中的堆栈

在我们开始之前，你能回答下面的问题吗？

Javascript 是解释语言还是编译语言？

是的，Javascript (JS)是一种解释型语言，仍然有自己的编译器形式，运行在所谓的 Javascript 引擎中。

每个网络浏览器都有自己的 JavaScript 引擎形式，例如 Chrome 有 v8，Mozilla 有 spider monkey 等，尽管它们都有相同的目的。JavaScript 引擎只是将 JavaScript 源代码转换成编译器可以理解的语言，然后执行它。

那我们开始吧，

执行上下文

javascript 代码运行的环境构成了执行上下文。

执行上下文决定了哪段代码可以访问变量、函数、对象等。

如果你读过作用域的文章，那么你应该知道什么是全局作用域和局部作用域(函数作用域)。

类似地，执行上下文也有不同的类型—

1.全局执行上下文

每当代码第一次运行时，或者当代码不在任何函数中时，它就会进入全局执行上下文。在整个代码执行过程中，只有一个全局执行上下文。

在浏览器的情况下，全局执行上下文做两件事

创建一个“窗口”对象。
窗口对象引用了“this”关键字。

2.函数执行上下文

每当代码执行发现一个函数，它就创建一个新的函数执行上下文。可以有任意数量的函数执行上下文。

上面，全局执行上下文包含“name”变量和对“func1”的函数引用。而包含变量和函数引用三个函数执行上下文将被创建。文章中进一步解释了细节。

执行堆栈/调用堆栈

Javascript 在浏览器中一次只能运行一件事，这意味着它是单线程，所以它在所谓的执行堆栈中对其他动作、事件和函数进行排队。

每当浏览器加载脚本时，堆栈中的第一个元素是全局执行上下文。然而，当一个函数执行时，一个执行上下文被创建并虚拟地放置在全局执行上下文之上。一旦函数执行完毕，它就会从执行堆栈中弹出，并将控制权返回给它下面的上下文。

我们举个例子，把上面的形象化。

步骤 1:当上述代码加载到浏览器中时，Javascript 引擎创建一个全局执行上下文，并将其推送到当前执行堆栈中。

步骤 2:假设最后我们调用了 func1()，然后 Javascript 引擎为该函数创建了一个新的执行上下文，并将其推到全局执行上下文的顶部

步骤 3:在 func1()中，我们调用了 func2()，因此 Javascript 引擎为该函数创建了一个新的执行上下文，并将其推到 func1 执行上下文的顶部。

第四步:当 func2()函数结束时，从当前堆栈中弹出它的执行上下文，控件到达它下面的执行上下文，也就是 func1()函数执行上下文。

步骤 5:当 func1()完成时，它的执行堆栈被从堆栈中移除，控制到达全局执行上下文。一旦执行完所有代码，JavaScript 引擎就会从当前堆栈中删除全局执行上下文。

执行上下文阶段

执行上下文主要有两个阶段。

创造
执行

让我们一个一个来看看

创建阶段

在函数执行之前，这里会发生一些事情。

首先，为每个函数或变量创建一个到外部环境的连接，这就形成了作用域链。这告诉执行上下文它应该包含什么，以及它应该在哪里寻找解析函数的引用和变量值。

对于全球环境来说，外部环境是零。然而，全球范围内的所有环境都以全球环境为其外部环境。
如果函数‘a’包含在函数‘b’中，那就意味着‘a’有一个外部环境‘b’。

2.在扫描作用域链之后，创建一个环境记录，其中全局上下文(将是 web 浏览器中的一个窗口)、变量、函数和函数参数的创建和引用是在内存中完成的。

3.最后，在第一步创建的每个执行上下文中确定“this”关键字的值(在全局执行上下文中，“this”指的是窗口)。

注意:如果你发现理解这个关键字行为有困难，那么我强烈推荐这个。

因此，我们可以将创建阶段表示为

creationPhase = {
'outerEnvironmentConnection': {
        /* scope chain resolution*/ 
    },    
'variableObjectMapping': {
        /* function arguments, parameters, inner variable and function declarations are created or referenced in memory */ 
    },
    'valueOfThis': {},

}

执行阶段

在这个阶段，代码开始在创建阶段形成的执行上下文中运行，并逐行分配变量值。

当执行开始时，引擎在其创建阶段对象中寻找引用来执行该函数。如果它没有在自己的环境中找到它，它将继续沿着作用域链向上移动，直到到达全局环境。

如果在全局环境中没有找到引用，它将返回一个错误。但是，如果找到了引用并且正确执行了函数，则该特定函数的执行上下文将从堆栈中弹出，引擎将移动到下一个函数，它们的执行上下文将被添加到堆栈中并执行，依此类推。

让我们通过例子来看看上面的两个阶段，以便对它有一个更好的了解。

因此，在创建阶段，全局执行上下文将如下所示:

globalExecutionObj = {
    outerEnvironmentConnection: null,
    variableObjectMapping: {
        name: uninitialized,
        title: undefined,
        date: uninitialized,
        func1: func,
    },
    this: window //Global Object
}

注意:上面的let(名称)和const(日期)定义的变量在创建阶段没有任何关联的值，但是var(标题)定义的变量被设置为undefined 。

这就是为什么您可以在声明var 定义的变量之前访问它们(虽然是undefined)，但是在声明let和const变量之前访问它们时会得到一个引用错误。

这就是我们所说的提升，即所有使用*var*的变量声明都被提升到它们的函数/局部范围的顶部(如果在函数内声明)或全局范围的顶部(如果在函数外声明)，而不管实际声明是在哪里进行的。

在执行阶段，变量赋值已经完成。因此，在执行阶段，全局执行上下文看起来会像这样。

globalExectutionObj = {
    outerEnvironmentConnection: null,
    variableObjectMapping: {
        name: "overflowjs.com",
        title: "Execution context",
        date: "5 july 2019",
        func1: pointer to function func1,
    },
    this: window //Global Object
}

注意:在执行阶段，如果 JavaScript 引擎在源代码中声明变量let的实际位置找不到它的值，那么它将为它分配undefined的值。

现在，当到达“func1”时，将形成一个新的函数执行上下文，其创建对象如下所示

func1ExecutionObj = {
    outerEnvironmentConnection: Global,
    variableObjectMapping: {
       arguments: {
            0: 10,
            length: 1
        },
        num: 10,

        author: undefined,
        val: uninitialized,
        func2: undefined
        fixed: uninitialized
        addFive: pointer to function addFive()
    },
    this: Global Object or undefined
}

在执行阶段，

func1ExecutionObj = {
    outerEnvironmentConnection: Global,
    variableObjectMapping: {
       arguments: {
            0: 10,
            length: 1
        },
        num: 10,

        author: "Deepak",
        val: 3,
        func2: pointer to function func2() 
        fixed: "Divine"
        addFive: pointer to function addFive()
    },
    this: Global Object or undefined
}

在该函数完成其执行之后，全局环境被更新。然后全局代码完成，程序结束。

你可能也会喜欢我的其他文章

Javascript —生成器-产出/下一个&异步-等待🤔
Javascript 数据结构与映射、归约、过滤
Javascript- Currying VS 部分应用
Javascript ES6 —可迭代程序和迭代器
Javascript —代理

谢谢！

Javascript 生成器 Yield/Next 与 Async-Await 概述和比较

原文：https://towardsdatascience.com/javascript-generator-yield-next-async-await-8442d2c77185?source=collection_archive---------4-----------------------

发电机(ES6)

可以根据用户需求在不同的时间间隔返回多个值并可以管理其内部状态的函数是生成器函数。如果一个函数使用了[*function**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*)语法，它就变成了 GeneratorFunction。

它们不同于普通函数，普通函数在一次执行中运行完成，而生成器函数可以暂停并恢复，因此它们确实运行完成，但触发器仍在开发人员手中。它们允许对异步功能进行更好的执行控制，但这并不意味着它们不能用作同步功能。

注意:当执行生成器函数时，它返回一个新的生成器对象。

暂停和恢复是使用yield & next完成的。所以让我们看看它们是什么，它们是做什么的。

产量/下一个

关键字yield暂停生成器函数的执行，关键字yield后面的表达式的值被返回给生成器的调用者。它可以被认为是基于生成器的return关键字版本。

yield关键字实际上返回一个具有两个属性value和done的IteratorResult对象。(如果你不知道什么是迭代器和可迭代对象，那么请阅读这里的)。

一旦在yield表达式上暂停，生成器的代码执行就会保持暂停，直到调用生成器的next()方法。每次调用生成器的next()方法时，生成器恢复执行并返回迭代器的结果。

咳…理论讲够了，让我们来看一个例子

function* UUIDGenerator() {
    let d, r;
    while(true) {
        yield 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
            r = (new Date().getTime() + Math.random()*16)%16 | 0;
            d = Math.floor(d/16);
            return (c=='x' ? r : (r&0x3|0x8)).toString(16);
        });
    }
};

这里，UUIDGenerator是一个生成器函数，它使用随机数的当前时间计算 UUID，并在每次执行时返回一个新的 UUID。

要运行上面的函数，我们需要创建一个生成器对象，我们可以在其上调用next()

const UUID = UUIDGenerator();
// UUID is our generator objectUUID.next() 
// return {value: 'e35834ae-8694-4e16-8352-6d2368b3ccbf', done: false}

UUID.next()将在value键下的每个UUID.next()上返回新的 UUID，而done将始终为假，因为我们处于一个无限循环中。

注意:我们暂停在无限循环之上，这有点酷，在一个生成器函数中的任何“停止点”，它们不仅可以向一个外部函数产生值，还可以从外部接收值。

上面有很多生成器的实际实现，也有很多大量使用它的库， co 、 koa 和 redux-saga 就是一些例子。

异步/等待(ES7)

传统上，当异步操作返回使用Promise处理的数据时，回调被传递和调用。

Async/Await 是一种特殊的语法，以更舒适的方式处理承诺，非常容易理解和使用。

async 关键字用于定义一个异步函数，返回一个[AsyncFunction](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction)对象。

await关键字用于暂停异步函数的执行，直到Promise完成，即解决或拒绝，并在完成后继续执行async函数。当恢复时，await表达式的值就是已完成的Promise的值。

要点:

1.await只能在async函数中使用。

2.带有async关键字的函数将总是返回一个承诺。

3.在同一个函数下，多个等待将总是按顺序运行。

4.如果承诺正常解决，那么await promise返回结果。但是在拒绝的情况下，它抛出错误，就好像在那一行有一个throw语句一样。

5.一个async函数不能同时等待多个承诺。

6.如果将许多await作为一条语句使用而不依赖于前一条语句，可能会出现性能问题。

到目前为止一切顺利，现在让我们看一个简单的例子:

async function asyncFunction() { const promise = new Promise((resolve, reject) => {
    setTimeout(() => resolve("i am resolved!"), 1000)
  }); const result = await promise; 
  // wait till the promise resolves (*) console.log(result); // "i am resolved!"
}asyncFunction();

asyncFunction执行在第await promise行“暂停”,并在承诺完成时恢复，结果是result。所以上面的代码一秒钟显示了“i am resolved!”。

生成器和异步等待—比较

Generator functions/yield 和 Async functions/await 都可以用来编写“等待”的异步代码，这意味着代码看起来好像是同步的，尽管它实际上是异步的。
一个生成器函数一个产出一个产出地执行，即通过其迭代器(T4 方法)一次执行一个产出表达式，而同步等待，它们被依次执行等待。
Async/await 使得实现生成器的特定用例更加容易。
g 生成器的返回值始终是**{value: X, done: Boolean}**，而对于同步函数来说，将始终是一个承诺，要么解析为值 X，要么抛出一个错误。
一个async函数可以被分解成一个生成器和 promise 实现，这是一个很好的工具。

如果您想被添加到我的电子邮件列表中，请考虑在这里输入您的电子邮件地址和关注我的** 中的 阅读更多关于 javascript 和github的文章，看看我的疯狂代码。如果有什么不清楚或者你想指出什么，请在下面评论。**

你可能也会喜欢我的其他文章

Javascript 执行上下文和提升
理解 Javascript‘this’关键字(上下文)。
Javascript 数据结构与映射、归约、过滤
Javascript- Currying VS 部分应用
Javascript ES6 —可迭代程序和迭代器
Javascript —代理， Javascript —作用域

如果您喜欢这篇文章，请随意分享并帮助他人找到它！

谢谢！

Javascript 新特性

原文：https://towardsdatascience.com/javascript-new-features-part-1-f1a4360466?source=collection_archive---------4-----------------------

Javascript 已经从仅仅是一个 web 浏览器扩展到了编程的所有领域。

Private Class Field, String.matchAll(), Numeric Separators BigInt, Local String BigInt, GlobalThis, Promise.allSettled(), Dynamic Import

Javascript 已经从 web 浏览器扩展到所有编程领域。

Node.js —用于 CLI 和服务器。
电子—用于跨平台桌面应用。
React native —用于跨平台移动应用。
物联网——低成本物联网设备，现在支持 javascript。

最近对 v8 引擎的更新大大提高了性能。从节点版本 8 到节点版本 11，javascript 解析速度提高了 2 倍，promise on an 速度提高了 11 倍。内存消耗降低了 20%。因此在性能和可用性方面有所改进。

在本文中，我们将看到一些可以在 chrome 浏览器(版本≥76)或 Node.js(版本≥11) CLI 中测试的现有和预定功能。

私有类字段👇

直到 ES6，我们才能够直接声明private属性。是的，有像下划线约定(_propertyName)、闭包、符号或 weak map这样的方式。

但是现在私有类字段使用哈希#前缀。让我们通过一个例子来学习它。

class Test { a = 1;          // .a is public
  #b = 2;         // .#b is private
  static #c = 3;  // .#c is private and static incB() {
    this.#b++;
  }}const testInstance = new Test();// runs OK
testInstance.incB();// error - private property cannot be modified outside class
testInstance.#b = 0;

注意:目前还没有办法定义私有函数，尽管一个 TC39 第三阶段:草案提案建议在名字上使用散列前缀*#*。🤞

String.matchAll()👇

如果我有一个字符串，带有一个包含许多捕获组的全局正则表达式，我经常想遍历所有的组。目前，我的选择如下:

string . prototype . match()with/g—如果我们将.match()与一个设置了标志/g的正则表达式一起使用，您将在一个数组中获得它的所有完全匹配。
string . prototype . split()—如果我们使用拆分字符串和正则表达式来指定分隔符，并且如果它包含至少一个捕获组，那么.split()返回子字符串交错的数组。

上述方法的问题在于，只有在正则表达式上设置了/g并且正则表达式的属性.lastIndex在每次匹配发生时都发生了变化的情况下，它们才有效。这使得在多个位置使用相同的正则表达式很危险。

matchAll() 有助于解决上述所有问题。让我们看看它的定义和用法

给定一个字符串和一个正则表达式，.matchAll()返回所有匹配一个字符串和一个正则表达式的结果，包括捕获组。

let regexp = /t(e)(st(\d?))/g;
let str = 'test1test2';let array = [...str.matchAll(regexp)];console.log(array[0]);
// expected output: Array ["test1", "e", "st1", "1"]

注意:*.matchAll()*返回一个迭代器，不是真正的可重启 iterable。也就是说，一旦结果用尽，就需要再次调用方法并创建一个新的迭代器。

数字分隔符👇

如果你很难读懂一长串数字，这就是你搜索的终点。

数字分隔符允许人眼快速解析，尤其是当有大量重复数字时:

1000000000000 -> 1_000_000_000_000
1019436871.42 -> 1_019_436_871.42

现在更容易分辨第一个数字是万亿，第二个数字是 10 亿量级。

它也适用于其他基础，例如:

**const** fileSystemPermission = 0b111_111_000;
**const** bytes = 0b1111_10101011_11110000_00001101;
**const** words = 0xFAB_F00D;

您也可以在分数和指数中使用分隔符:

**const** massOfElectronInKg = 9.109_383_56e-31;
**const** trillionInShortScale = 1e1_2;

注意:解析由*_*分隔的整数可能有些棘手，因为*Number('123_456')*给出 NAN，而*parseInt('123_456')*给出*123*。

BigInt 的👇

BigInts是 JavaScript 中一个新的数字原语，可以表示精度大于 2⁵-1 的整数。有了BigInts，你可以安全地存储和操作大整数，甚至超过Numbers的安全整数限制。

BigInts正确执行整数运算，不溢出。让我们通过一个例子来理解:-

const max = Number.MAX_SAFE_INTEGER;
// 9007199254740991
max+1;
// 9007199254740992
max+2;
// 9007199254740991

我们可以看到max + 1产生的结果与max + 2相同。

对超出安全整数范围(即从Number.MIN_SAFE_INTEGER到Number.MAX_SAFE_INTEGER的整数)的任何计算都可能会失去精度。为此，我们只能依赖安全范围内的数字整数值。

于是，BigInts应运而生，BigInts可以通过在任意整数文字上加上n后缀来创建。例如，123变成123n或者全局BigInt(number)功能可以用来将Number转换成BigInts.

让我们用BigInt s 重新看看上面的例子

BigInt(Number.MAX_SAFE_INTEGER) + 2n;
// 9007199254740993ntypeof 123n
// "bigint2"

注意:数字分隔符对 BigInts 特别有用，例如:

***const*** *massOfEarthInKg = 6_000_000_000_000_000_000_000_000n;*

BigInts支持最常用的运算符。二进制+、-、*、**都按预期工作。/和%工作，根据需要向零方向舍入。

(7 + 6 - 5) * 4 ** 3 / 2 % 3;
// → 1
(7n + 6n - 5n) * 4n ** 3n / 2n % 3n;
// → 1n

注意:一个问题是不允许在*BigInts*和*Numbers*之间混合操作

带 BigInt 的区域设置字符串👇

**toLocaleString()**方法返回一个带有 BigInt 的语言敏感表示的字符串。

let bigint = 123456789123456789n;// German uses period for thousands
console.log(bigint.toLocaleString('de-DE'));
// → 123.456.789.123.456.789// Arabic in most Arabic speaking countries uses Eastern Arabic digits
console.log(bigint.toLocaleString('ar-EG'));
// → ١٢٣٬٤٥٦٬٧٨٩٬١٢٣٬٤٥٦٬٧٨٩// India uses thousands/lakh/crore separators
console.log(bigint.toLocaleString('en-IN'));
// → 1,23,45,67,89,12,34,56,789// the nu extension key requests a numbering system, e.g. Chinese decimal
console.log(bigint.toLocaleString('zh-Hans-CN-u-nu-hanidec'));
// → 一二三,四五六,七八九,一二三,四五六,七八九// when requesting a language that may not be supported, such as
// Balinese, include a fallback language, in this case Indonesian
console.log(bigint.toLocaleString(['ban', 'id']));
// → 123.456.789.123.456.789

globalThis 关键字👇

JavaScript 的变量作用域是嵌套的，形成一棵树，它的根是全局作用域，this关键字的值是对“拥有”当前正在执行的代码或函数的对象的引用。

要了解更多关于这个关键字和全球范围的信息，请阅读我下面的文章

Javascript 中的作用域

理解 Javascript“this”关键字(上下文)

通常我们用一个函数来计算全局，比如

const getGlobalThis = () => {

  // in webworker or service worker
  if (typeof self !== 'undefined') return self;

  // in browser 
  if (typeof window !== 'undefined') return window;

  // in Node.js
  if (typeof global !== 'undefined') return global;

  // Standalone javascript shell
  if (typeof this !== 'undefined') return this;

  throw new Error('Unable to locate global object');
};const theGlobalThis = getGlobalThis();

上面的函数并没有涵盖我们需要全局这个值时的所有情况。

在use strict的情况下，该值为undefined
当我们在 javascript 中形成一个包时，它通常被一些可能与全局不同的代码所包裹。
在独立的 javascript 引擎外壳环境中，上述代码将不起作用

为了解决上述问题，引入了关键字globalThis,它可以在任何时候任何环境下返回全局对象。

注意:由于向后兼容性，全局对象现在被认为是 JavaScript 无法摆脱的错误。它会对性能产生负面影响，并且通常会引起混淆。

Promise.allSettled()👇

如果你想知道 javascript 中的承诺是什么，那么看看这个— JavaScript 承诺:介绍。

有一点要点，承诺是 JavaScript 向您承诺工作将会完成(或者如果工作无法完成可能会失败)的方式。

新方法返回一个承诺，该承诺在所有给定承诺都已解决(即解决或拒绝)后解决，并带有一个对象数组，每个对象描述每个承诺的结果。

const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, 'foo'));
const promises = [promise1, promise2];Promise.allSettled(promises).
  then((results) => results.forEach((result) => console.log(result.status)));// expected output:
// "fulfilled"
// "rejected"

这与Promise.all不同，因为一旦 iterable 对象中的承诺被拒绝，它就会拒绝。

下面是当前支持的承诺方法的比较

动态导入👇

Static vs Dynamic Import

这个很疯狂在我们深入之前，我们先来看看什么是静态导入。

静态导入只接受字符串作为模块说明符，并通过运行前“链接”过程将绑定引入局部范围。

静态的import语法只能在文件的顶层使用。

import * as module from './utils.mjs';

静态import支持重要的用例，比如静态分析、捆绑工具和树抖动。

但是关于什么

按需(或有条件地)导入模块
在运行时计算模块说明符
从常规脚本中导入模块(与模块相对)

这是不可能的，直到动态导入 — import(moduleSpecifier)为所请求模块的模块名称空间对象返回一个承诺，这是在获取、实例化和评估模块的所有依赖项以及模块本身之后创建的。

<script type="module">
  (async () => {
    const moduleSpecifier = './utils.mjs';
    const module = await import(moduleSpecifier)
    module.default();
    // → logs 'Hi from the default export!'
    module.doStuff();
    // → logs 'Doing stuff…'
  })();
</script>

注意:使用静态的*import*作为初始的绘制依赖，特别是对于折叠内容。在其他情况下，考虑用动态*import()*按需加载依赖项。

稳定的分类—(现在获得一致可靠的结果)👇

在算法意义上的稳定是指:它是否保持顺序或者“相等”的项目？

让我们通过一个例子来理解

const people = [
  {name: 'Gary', age: 20},
  {name: 'Ann', age: 20},
  {name: 'Bob', age: 17},
  {name: 'Sue', age: 21},
  {name: 'Sam', age: 17},
];// Sort people by name
people.sort( (p1, p2) => {
  if (p1.name < p2.name) return -1;
  if (p1.name > p2.name) return 1;
  return 0;
});console.log(people.map(p => p.name));
// ['Ann', 'Bob', 'Gary', 'Sam', 'Sue']// Re-sort people by age
people.sort( (p1, p2) => {
  if (p1.age < p2.age) return -1;
  if (p1.age > p2.age) return 1;
  return 0;
});console.log(people.map(p => p.name));
// We're expecting people sorted by age, then by name within age group:
// ['Bob', 'Sam', 'Ann', 'Gary', 'Sue']// But we might get any of these instead, depending on the browser:
// ['Sam', 'Bob', 'Ann', 'Gary', 'Sue']
// ['Bob', 'Sam', 'Gary', 'Ann', 'Sue']
// ['Sam', 'Bob', 'Gary', 'Ann', 'Sue']

如果你得到的是最后三个结果中的一个，那么你可能正在使用 Google Chrome，或者可能是没有实现 Array.sort()作为“稳定”算法的各种浏览器中的一个。

这是因为不同的 JS 引擎(跨不同的浏览器)采用不同的路线来实现排序，另外，一些 javascript 引擎对短数组使用稳定排序，而对长数组使用不稳定排序。

这导致不一致的排序稳定性行为和许多混乱。这就是为什么在开发环境中，与排序相关的一切似乎都可以工作，但在生产环境中，由于测试排序的阵列大小不同，我们开始看到其他情况。

注意:有第三方库，我强烈推荐 Lodash ，它有稳定的排序

但是现在这个问题已经解决了，我们在大多数浏览器上都有一个稳定的排序。语法保持不变。

由于这篇文章有很多需要消化和测试的特性，我们将在下一篇文章中继续介绍更多的新特性。

如果您想加入我的电子邮件列表，请考虑在这里输入您的电子邮件地址****关注我在medium上阅读更多关于 javascript 的文章，在github上查看我的疯狂代码。如果有什么不清楚或者你想指出什么，请在下面评论。

你可能也会喜欢我的其他文章

VS Web 开发生产力的代码扩展
Javascript 执行上下文和提升
Javascript —生成器-产出/下一个&异步-等待🤔
理解 Javascript 'this '关键字(上下文)。
Javascript 数据结构与映射、归约、过滤
Javascript- Currying VS 部分应用
Javascript ES6 —可迭代程序和迭代器
Javascript —代理
Javascript —作用域

如果你喜欢这篇文章，请随意分享，以帮助他人找到它！

谢谢！

爵士&波沙·诺瓦:兄弟姐妹(？)

原文：https://towardsdatascience.com/jazz-bossa-nova-c6c5fae5edb4?source=collection_archive---------19-----------------------

Python 研究

Frank Sinatra & Tom Jobim in a studio recording in 1967. Photo: Warner Bros

在巴西音乐学的背景下，人们普遍认为爵士乐和波萨诺瓦有许多相似之处，但不清楚谁影响了谁，以及如何影响的。尽管有些人凭直觉认为，仅仅断言爵士乐受到了波萨诺瓦的影响是不正确的，尽管爵士乐以前就“诞生”了。相反，这两种风格相互影响。60 年代末，汤姆·乔宾在巴西以外的地方获得巨大成功，这使得他与弗兰克·辛纳特拉合作录制了一张专辑，这一点尤其正确。光是他对爵士乐的影响就很大，更不用说其他音乐家，如塞尔吉奥·门德斯、路易斯·邦法和若昂·吉尔伯托，他们都和美国爵士乐手一起录制过专辑。

这项研究的目的是用 Python 可视化和理解波沙·诺瓦和爵士乐和弦的相似性。我将使用网络抓取——一种数据提取技术，通过网站的 html 代码“抓取”网站内容——收集流行爵士乐和波萨诺瓦歌曲的和弦。为此，我将使用网站 CifraClub ，这是一个巴西和弦网站，其中包含波萨诺瓦和爵士歌曲。

*也就是说，这项研究仅基于一个地点，因此结论可能会有偏差。理想情况下，这项研究应该在多个地点进行。

完整的代码可以在 github gist 的文章末尾找到。

这项研究直接影响了莱昂纳多·塞尔的工作，可以在他的网站上找到https://leosalesblog.wordpress.com/

如果你对如何进行网络搜集有任何疑问，我建议你事先了解网络搜集是如何工作的，因为这项研究的目的不是解释网络搜集，而是将它作为一种工具来使用。

问题

这项研究将试图回答以下问题:

每个流派中最常见的和弦有哪些？
每个流派有多少种不同的和弦？
有哪些和弦在爵士乐中出现的多，在波萨诺瓦中出现的少？反之亦然？
爵士乐和波沙·诺瓦有哪些共同的和弦？

1。导入库

首先 st off，让我们导入所需的库: Matplotlib 和 Seaborn 将被导入用于数据可视化；熊猫，用于数据分析；Bs4 和请求，进行网页抓取。

import matplotlib.pyplot as plt
import seaborn as snsimport pandas as pdimport requests
from bs4 import BeautifulSoup

2。网页抓取

既然库已经被导入，我们将从和弦站点抓取哪些歌曲，以及我们如何创建一个一次抓取许多歌曲的机制？

幸运的是，该网站有一个“点击率最高”的页面，上面有每个流派的 100 首点击率最高的歌曲。在每一个流派中，100 首歌曲中的每一首都有一个链接，链接到一个带有和弦的页面。这太完美了。我们需要做的只是在 bossa nova 和 jazz 页面中抓取 100 个 URL，然后为 200 首歌曲中的每一首抓取和弦。

url_list = []
genres = ['bossa-nova','jazz']
for genre in genres:
    url = 'https://www.cifraclub.com.br/mais-acessadas/'+genre+'/'
    site = requests.get(url)
    soup = BeautifulSoup(site.text) songs = soup.find('ol',{'id':'js-sng_list'})
    for link in songs.find_all('a'):
        links = link.get('href')
        url_list.append('http://www.cifraclub.com.br'+links)

有了这段 Python 代码，我们现在有了一个包含 200 个链接的列表——前半部分包含 100 首最常访问的 bossa nova 歌曲，后半部分包含 100 首最常访问的爵士乐歌曲。

现在，让我们从每首歌里刮出和弦。这类似于我们之前所做的，除了现在我们感兴趣的是和弦的文本，而不是链接。

all_chords = []genres_urls = [url_list[0:99],url_list[100:198]]
for genre_urls in genres_urls:
    chords_list = []
    genre_chords = []
    for url in genre_urls:
        site = requests.get(url)
        soup = BeautifulSoup(site.text) chords_raw = soup.find('pre')
        for chords in chords_raw.find_all('b'):
            chord = str(chords).strip('<>b/')
            chord = chord.replace('-','m').replace('<b>','').replace('</b>','').replace('/','') #Continue next line
            chord = chord.replace('(','').replace(')','').replace('+','M').replace('dim','°').replace('maj','M')
            chords_list.append(chord)
    genre_chords.append(chords_list)
    all_chords.append(genre_chords)

all_chords是一个列表的列表，其中 100 首波萨诺瓦歌曲中的所有和弦作为其第一元素，100 首爵士歌曲中的所有和弦作为其第二元素。

我还标准化了符号，去掉了任何可能来自于 html 的<b>或</b> 。此外，我已经删除了括号和斜线，并将加号和减号改为“M”和“M”，因此该算法将 A7/9 和 A7(9)，以及 D7+和 D7M 视为同一事物。

我在这里遇到了一个小问题，因为，不知道什么原因，200 个 URL 中有 1 个指向了一个没有和弦的页面，而是一个吉他软件文件。因为这只是一个网址，我决定删除它。那是第 200 首歌，所以我就把 *url_list[100:199]* 改成了 *url_list[100:198]* 。

3.制作 Python 词典

现在我们已经收集并标准化了这两种风格中每首歌的每个和弦，让我们看看每个和弦出现了多少次。

def freq_chords(chords_list):
    dic = {}
    count = 0
    for unique_chord in [chords for chords in set(chords_list)]:
        for total_chords in chords_list:
            if unique_chord==total_chords:
                count += 1
        dic[unique_chord]=count
        count=0
    return dicbossa_dic = freq_chords(all_chords[0][0])
jazz_dic = freq_chords(all_chords[1][0])

4.熊猫数据框

现在，让我们把每本字典变成熊猫的数据框架。为了美观起见，我将“出现次数”列重命名为“计数”。

bossa_df = pd.DataFrame.from_dict(bossa_dic,orient='index')
bossa_df.columns = ['Count']
jazz_df = pd.DataFrame.from_dict(jazz_dic,orient='index')
jazz_df.columns = ['Count']

5.数据分析

现在，让我们来回答帖子开头的问题。

每个流派中最常见的和弦有哪些？

bossa_df.sort_values(by='Count',ascending=False,inplace=True)
jazz_df.sort_values(by='Count',ascending=False,inplace=True)f, axes = plt.subplots(1,2,sharey=True,figsize=(10,5))
ax1 = sns.barplot(x=bossa_df[:10].index,y=bossa_df[:10].Count,ax=axes[0])
ax1.set_title('Bossa Nova')
ax2 = sns.barplot(x=jazz_df[:10].index,y=jazz_df[:10].Count,ax=axes[1])
ax2.set_title('Jazz')for ax in f.axes:
    plt.sca(ax)
    plt.xticks(rotation=90)
plt.show()

Most common chords in each genre

洞察 1) 我们可以看到，波沙·诺瓦最常见的和弦是小七和弦。在爵士乐中，它们大多是自然大和弦；

洞察 2) 再者，爵士乐中最常见的和弦出现频率几乎是波沙·诺瓦最常见和弦的两倍；

每个流派有多少种不同的和弦？

print(bossa_df.count())
print()
print(jazz_df.count())

print(bossa_df.std())
print()
print(jazz_df.std())

洞察 3) 波沙·诺瓦的歌曲比爵士歌曲有更多的和弦；

洞察 4) 爵士和弦有大得多的标准差。这是因为有些和弦在爵士乐中出现得如此频繁——爵士乐中最常见的和弦几乎是波沙·诺瓦和弦的两倍——以至于其他和弦的出现偏离平均值更多；

有哪些和弦在爵士乐中出现的多，在波萨诺瓦中出现的少？反之亦然？

让我们创建一个新的数据帧，它将是 bossa nova 和弦出现和 jazz 和弦出现之间的差异。我们将放弃任何 NA 值，因为它们代表了只存在于一个流派中的和弦。

dif_df = bossa_df - jazz_df
dif_df.columns = ['Difference']
dif_df.sort_values(by='Difference',inplace=True)dif_df = dif_df.dropna()

我们现在在数据框中有一列，它告诉我们一个和弦在波沙·诺瓦比在爵士乐中更频繁。越接近 0，它们在两种类型中出现的次数就越多。

f, axes = plt.subplots(1,2,figsize=(10,5),sharey=True)
sns.barplot(dif_df[171:].index,dif_df[171:].Difference,ax=axes[1])
sns.barplot(dif_df[:10].index,dif_df[:10].Difference,ax=axes[0])
for ax in axes:
    plt.sca(ax)
    plt.xticks(rotation=90)

这里我们有顶部和底部的 10 个和弦。左边的图表告诉我们什么和弦在爵士乐中出现得最多，在波沙·诺瓦中出现得最少。在右边，我们有相反的情况。

洞察 5) 爵士乐不仅本身使用了更多的自然和弦，而且比波沙·诺瓦还多了很多。

顿悟 6) 波沙·诺瓦几乎从不使用自然小调和弦，而是更喜欢总是加入一个扩展音(第七、第九等。).

爵士乐和波沙·诺瓦有哪些共同的和弦？

我将规定一个 10 次出现的容限，也就是说，一个和弦在爵士乐或波沙·诺瓦音乐中最多只能出现 10 次。

common = dif_df[dif_df[‘Difference’].isin(range(-10,10))]

所以，符合这个条件的和弦数量相当多。数据帧有 107 行(歌曲)，所以我们需要找到一种方法来过滤或分类这些和弦。

我们试着把它们分成 6，7，9，11，13，减和弦的和弦，通过这个镜头看数据。

contains6 = common[common.index.str.contains('6')]
contains7 = common[common.index.str.contains('7')]
contains9 = common[common.index.str.contains('9')]
contains11 = common[common.index.str.contains('11')]
contains13 = common[common.index.str.contains('13')]
containsdim = common[common.index.str.contains('°')]

我现在将把每个扩展和弦的出现次数加起来(第六，第七，等等。).请记住，一个和弦，比如 G7/9，会同时出现在“第七”和“第九”中。

sns.barplot(x=['6th','7th','9th','11th','13th','Dim'],
            y=[len(contains6),len(contains7),len(contains9),len(contains11),len(contains13),len(containsdim)])

七度是爵士和波沙·诺瓦共有的和弦中最频繁的延伸。

倒置呢？这些和弦中有多少是转位和弦？

inversions = []
for i in range(0,len(common)):
    for letter in ['A','B','C','D','E','F','G']:
        if common.iloc[i].name.find(letter)!=-1:
            for letter2 in ['A','B','C','D','E','F','G']:
                if common.iloc[i].name.find(letter2)!=-1:
                    if letter != letter2:
                        if common.iloc[i].name not in inversions:
                            inversions.append(common.iloc[i].name)

让我们再画一次图，加上反转。

sns.barplot(x=['6th','7th','9th','11th','13th','Dim','Inv.'],
            y=[len(contains6),len(contains7),len(contains9),len(contains11),len(contains13),len(containsdim),len(inversions)])

洞察 8) 爵士和波沙·诺瓦都很喜欢倒装！

结论

尽管这两个流派都以复杂的和声著称，但显然波萨诺瓦似乎不仅有更多的和弦，而且有更多的和弦延伸。我怀疑这是否意味着波萨诺瓦在和声上更复杂，至少不明显。我敢打赌，爵士乐中的和弦名称不像波萨诺瓦那样确定。你可以随意玩 D7 或 D7/9 来代替 D；作曲家不会命令你选择哪一首。如果是真的，这是有意义的，因为爵士乐有很强的即兴成分，而这在波萨诺瓦并不存在。此外，当在 G 和 G9 或 G7/13 之间选择时，波萨诺瓦的作曲家显然倾向于拒绝一个普通的 G。在波萨诺瓦的所有扩展中，小调第七显然是最受欢迎的，而普通的小调和弦非常不受欢迎。如果你玩的是 Am，而不是 Am7，听起来很可能会很奇怪。在博萨诺瓦，小调七度和预期的一样普遍。最后，转位在爵士乐和波萨诺瓦中都非常流行。他们非常适合为一个和弦做不同的展示。D 和 D/F#本质上是相同的，但“听”的方式不同。这对两种流派都很有用，它们都在寻找重新诠释和弦的方法。

整个代码

Jenkins 事件、日志和指标

原文：https://towardsdatascience.com/jenkins-events-logs-and-metrics-7c3e8b28962b?source=collection_archive---------4-----------------------

如何收集关于 Jenkins 的信息以进行分析和数据可视化

如果您支持一个相当大的 Jenkins 实例，或者您支持大量的实例，您可能已经面临一个性能问题。像许多持续集成(CI)应用程序一样，Jenkins 在小范围内工作得很好，但如果没有适当的照顾和喂养，可能会严重退化。本文将展示几个例子，说明如何导出 Jenkins 事件、日志和指标，以帮助发现改进的机会。

Jenkins 应用指标

Jenkins Prometheus 插件在 Jenkins 中公开了一个 Prometheus 端点，允许 Prometheus 收集 Jenkins 应用程序指标。该插件实际上只是对指标插件的包装，通过 REST 端点公开 JVM 指标，该端点以 Prometheus 可以理解的格式返回数据。除了 JVM 信息之外，该插件还公开了关于作业队列、执行器数量的信息，以及其他特定于 Jenkins 的信息。指标插件提供了一个通过端点公开的指标列表。

一旦 Prometheus 插件安装在 Jenkins 中，它所公开的数据可以通过“管理 Jenkins”页面进行配置:

Manage Jenkins -> Configure System -> Prometheus plugin

Prometheus 插件优于大多数其他 metrics 插件，因为它比许多其他插件返回更多的系统信息。如果你需要将数据发送到不同的目的地，你可以使用其中一个普罗米修斯导出器。如果普罗米修斯绝对不是一个选项，但是，有几个替代方案。一个替代方案是Jenkins Metrics Graphite Reporting插件。这个插件导出的数据远比 Prometheus 插件有限，但它允许您获得关于执行程序计数和 HTTP 响应统计的基本信息。

与 Prometheus pull 模型不同，Graphite 插件将数据推送到任何能够接受 Graphite 消息的服务器。例如，您可以配置 InfluxDB Graphite 插件并将指标直接发送到 InfluxDB。或者您可以配置 Logstash Graphite 输入插件并将指标发送到 Logstash 支持的任何输出位置。

如果您管理大量的 Jenkins 实例，通过 UI 配置这些设置可能会很繁琐。在这种情况下，可以使用 Jenkins REST API 向每个实例提交一个 Groovy 脚本:

curl -v -d "script=$(cat /tmp/script.groovy)" --user username:ApiToken [http://jenkins01.yourcompany.com:8080/scriptText](http://jenkins01.yourcompany.com:8080/scriptText)

下面显示的 Groovy 代码提供了一个如何配置 Jenkins Metrics Graphite 插件向外部系统发送数据的例子。

import jenkins.metrics.impl.graphite.GraphiteServer;
import jenkins.metrics.impl.graphite.PluginImpl;
import jenkins.model.*;
import org.codehaus.groovy.runtime.InvokerHelper;// Construct an object to represent the Graphite server
String prefix = "jenkins";
String hostname = "graphite.yourcompany.com";
int port = 2003;
GraphiteServer server = new GraphiteServer(hostname, port, prefix);
List<GraphiteServer> servers = new ArrayList<GraphiteServer>();
servers.add(server);
GraphiteServer.DescriptorImpl descriptor = 
Jenkins.getInstance().getDescriptorByType(GraphiteServer.DescriptorImpl.class);
descriptor.setServers(servers);

詹金斯事件

Jenkins Statistics Gatherer 插件可用于将每个事件的 JSON 消息发送到外部 REST 端点。其中一个应用是将消息发送到 Elasticsearch，以便在 Kibana web 界面中可视化。Jenkins 事件对应于 Jenkins 主服务器上发生的操作，例如:

项目创建(创建、删除或更新作业时)
作业执行(当构建开始和完成时)
作业步骤执行(当作业中的每个步骤开始和结束时)
作业队列(当作业进入或改变作业队列中的状态时)
SCM 签出(当作业从源代码管理中签出文件时)

有很多方法可以将事件发布到 Elasticsearch。一些受欢迎的选项包括:

Logstash HTTP 输入插件->log stash elastic search 输出插件
FluentD HTTP 输入插件-> FluentD Elasticsearch 输出插件
汇合休息代理->卡夫卡-> Logstash 卡夫卡输入插件-> Logstash Elasticsearch 输出插件

为了简单起见，本文将坚持使用 Elasticsearch 产品，并假设使用 Logstash 作为将事件接收到 Elasticsearch 中的方法。无论您选择哪种解决方案，过程本质上都是一样的。

一旦在 Jenkins 中安装了 Statistics Gatherer 插件，就可以将其配置为通过 Jenkins UI 发送消息:

Manage Jenkins -> Configure System -> Statistics Gatherer

上面的屏幕截图显示了如何配置 Statistics Gatherer 插件，以将 HTTP 消息发送到在[http://logstash.yourcompany.com/](http://logstash.yourcompany.com/)监听的 Logstash HTTP 输入插件。

重要提示:

启用 HTTP 发布？为了发送消息，必须选择”选项。此选项仅在点击此配置部分中的“高级… ”按钮时可见。
末尾的/jenkins-<msg>/路径是可选的，但是可以通过允许在request_path信息上定义 Logstash 过滤器来帮助提供关于哪个 Jenkins 事件类型被提交的一些附加信息。
发布工件的构建可以为每个工件生成唯一的 JSON 字段，这可能超过 Elasticsearch 索引所允许的字段数量。要避免这种情况，请使用 Logstash 过滤器去除任何不需要的字段:

filter {
    mutate {
        remove_field => [ "[build][artifacts]" ]
    }
}

如前所述，Jenkins 脚本控制台或 REST 端点可用于自动化插件的配置。Groovy 脚本的内容如下所示:

import org.jenkins.plugins.statistics.gatherer.StatisticsConfiguration;
import jenkins.model.*;String baseUrl = "http://logstash.yourcompany.com";StatisticsConfiguration descriptor = Jenkins.getInstance()
    .getDescriptorByType(StatisticsConfiguration.class);descriptor.setQueueUrl("[${baseUrl}/jenkins-queue/](http://logstash.yourcompany.com/jenkins-queue/)");
descriptor.setBuildUrl("[${baseUrl}](http://logstash.yourcompany.com/jenkins-queue/)[/jenkins-build/](http://logstash.yourcompany.com/jenkins-build/)");
descriptor.setProjectUrl("[${baseUrl}](http://logstash.yourcompany.com/jenkins-queue/)[/jenkins-project/](http://logstash.yourcompany.com/jenkins-project/)");
descriptor.setBuildStepUrl("[${baseUrl}](http://logstash.yourcompany.com/jenkins-queue/)[/jenkins-step/](http://logstash.yourcompany.com/jenkins-step/)");
descriptor.setScmCheckoutUrl("[${baseUrl}](http://logstash.yourcompany.com/jenkins-queue/)[/jenkins-scm/](http://logstash.yourcompany.com/jenkins-scm/)");descriptor.setQueueInfo(Boolean.TRUE);
descriptor.setBuildInfo(Boolean.TRUE);
descriptor.setProjectInfo(Boolean.TRUE);
descriptor.setBuildStepInfo(Boolean.TRUE);
descriptor.setScmCheckoutInfo(Boolean.TRUE);descriptor.setShouldSendApiHttpRequests(Boolean.TRUE);

在这个过程的最后，您应该在 Elasticsearch 中拥有一个 Jenkins 事件消息的集合，然后可以在 Kibana 可视化和仪表板中使用它来做出关于构建性能、失败率或各种其他问题的明智决策。

Kibana Search = type: build AND jobName: rest_open AND result: SUCCESS

Jenkins 应用程序日志

Jenkins 主进程和从进程在文件系统上生成应用程序日志。这些日志包含有关 Jenkins 流程的信息，有助于识别通过用户界面不易识别的问题。通过将这些日志发送到 Elasticsearch，可以使用 Kibana web 界面对信息进行索引和模式搜索。日志的每一行都成为 Elasticsearch 中的一条 JSON 记录。

将应用程序日志内容传送到 Elasticsearch 的最简单方法是使用 Filebeat，这是一个由 Elastic 提供的日志传送程序。Filebeat 可以配置为使用任意数量的日志，并将它们发送到 Elasticsearch、Logstash 或其他几个输出通道。我建议将日志发送到 Logstash，这样就可以应用适当的 Logstash 过滤器将这些行解析成 JSON 字段。这对于 HTTP 访问日志特别有用，因为它使用可预测的日志记录格式。例如，Logstash 中的COMBINEDAPACHELOG grok 过滤器可用于将访问日志条目解析成结构化的 JSON 数据。

下图显示了 Kibana 的“Discover”界面，该界面对于搜索日志条目非常有用。示例演示了如何过滤主机名与cdptestjml01匹配并且日志行包含单词docker的所有 Jenkins 日志:

filebeat.host.name: cdptestjml01 
AND filebeat.source: jenkins 
AND message: docker

Kibana Discover Screen

在最新的 Kibana 6.5.x 版本中，增加了一个“日志”视图，它允许你有一个类似于你在命令提示符下运行tail -f命令得到的视图的日志流视图:

Kibana Logs Screen

Jenkins 构建日志

与应用程序日志类似，每个 Jenkins 作业都会生成一个控制台日志。这些也可以运到 Elasticsearch。这可以在 Jenkins master 上使用 Filebeat 来完成，或者根据你的需要使用 Logstash Jenkins 插件来完成。使用 Filebeat 类似于上面所描述的，所以为了便于说明，我将在这里介绍 Logstash Jenkins 插件。

一旦安装，插件必须配置为指向中央服务器。有几种“索引器类型”可供选择。此示例显示了 SYSLOG 索引器类型的使用。这还需要 Logstash 服务器启用一个 syslog 输入插件，这样它就可以接收 syslog 消息，如此处所示。

Manage Jenkins -> Configure System -> Logstash

如前所述，如果您管理多个 Jenkins 实例，使用 Groovy 脚本来配置插件可能会更容易:

import jenkins.plugins.logstash.LogstashInstallation;
import jenkins.plugins.logstash.LogstashInstallation.Descriptor;
import jenkins.plugins.logstash.persistence.LogstashIndexerDao.IndexerType;
import jenkins.model.*;Descriptor descriptor = (Descriptor) 
    Jenkins.getInstance().getDescriptor(LogstashInstallation.class);
descriptor.type = IndexerType.SYSLOG;
descriptor.host = "logstash.yourcompany.com";
descriptor.port = 5045;
descriptor.key  = "JenkinsTestEnv";
descriptor.save();

以下示例显示了如何在单个作业配置页面上启用 Logstash 插件:

Job Configuration -> Job Notifications

重要提示:

Logstash 插件可以为所有作业全局启用，也可以为每个单独的作业启用。考虑到可能生成的数据量，最好只收集特定作业的日志(尤其是当开发人员碰巧在他们的构建脚本中启用了调试日志记录时)。

摘要

有许多插件可以让你发送或检索 Jenkins 的数据。第一步是确定你需要什么数据以及你将如何存储它。如果您希望定期从 Jenkins 收集时间序列数据，那么可以考虑使用时间序列数据库，并使用 Grafana 可视化结果。流行的数据库选项包括:

InfluxDB
普罗米修斯
时间刻度 B

对于事件或日志等其他数据， Elastic 产品是目前最受欢迎的选择。Elasticsearch 数据库是存储事件消息的绝佳解决方案，而 Kibana 是一个用户友好的界面，用于创建仪表板来呈现数据。尽管 Elastic 试图将时间序列功能集成到他们的产品中，但与 Grafana 结合的专用时间序列数据库可能更易于使用和管理。一旦您从任何或所有这些来源获得了历史数据，您就可以开始对您的 Jenkins 环境的状态做出明智和理性的决策。

如何在编码领域取得成功

原文：https://towardsdatascience.com/job-satisfaction-and-success-in-the-how-how-to-succeed-in-the-coding-world-3a64d4a0e843?source=collection_archive---------27-----------------------

数据驱动的方法:使用 2017 年堆栈溢出调查数据的成功咒语

介绍

成功对不同的人可能有不同的意义。那么，怎样才能成为一名成功的开发者呢？简而言之，这因人而异。在本文的上下文中，成功意味着工作满意度和更高的薪水。

有太多的事情浮现在脑海中，可以通过做来获得成功，比如训练有素的方法、有规律的编码、解决现实世界的问题等等。不同的人基于他们的方法会有不同的建议。但是，我们能从真实世界的数据中收集到什么呢？在本文中，我使用了 2017 年的堆栈溢出调查数据，试图了解以下问题:

被调查者的人口统计是怎样的？
什么因素导致工作满意度？
什么因素会导致更高的薪水，工作满意度会转化为更多的钱吗，反之亦然？

问题 1-人口统计

性别

如下图所示，近 90%的受访者是男性。

就开发人员的男女比例而言，存在很大的不平衡。是因为女性开发人员普遍较少还是因为女性开发人员通常不使用堆栈溢出？更可能的原因似乎是第一个。

人种

超过 70%的受访者是白人或欧洲后裔。

看下面的位置部分，似乎是这样，因为大多数受访者来自美国和欧洲国家。

位置

大多数受访者来自美国，其次是印度，然后是英国。仅美国就有近 40%的受访者。排名第二的国家是印度，约为 14%。与其他国家相比，美国似乎更受欢迎。

问题 2——工作满意度因素

从下面的相关矩阵我们可以看出，工资越高，工作满意度越高。随着每周工作时间的增加，工作满意度也会下降。有趣的是，每周工作时间和薪水之间存在负相关关系。所以更多的工作并不能真正转化为更多的钱。

正如我们在下图中看到的，就工作时间而言，有一个众所周知的 36 小时的最佳时间点。太少和太多一样糟糕，有时甚至更糟。

还有哪些因素影响工作满意度？

从下面的图表中我们可以看到，爱好编码的人通常在编码工作中更快乐。正如马克·吐温所说——“找一份你喜欢做的工作，你这辈子就一天都不用工作了。”

尤其是那些为开源项目和业余爱好编码做贡献的人，看起来工作满意度最高。

另一个流行的观点是，为大型跨国公司工作会带来更多的工作满足感。然而，手头的数据却讲述了一个不同的故事。风险投资的初创公司似乎更受工作满意度的青睐。

位置也是工作满意度的一个因素吗？

为了避免因回复数量少而导致数据失真，我筛选出了少于 30 个回复者的国家进行分析。波斯尼亚和黑塞哥维那位于光谱的顶端，而日本位于底端。

学历如何影响未来的工作满意度？看下面的情节，教育结果喜忧参半。专业学位好像比硕士好，中专好歹比硕士好。但是，这种趋势被博士学位打破了，博士学位轻而易举地胜出。

奇怪的是，计算机科学专业的本科生并不会给开发人员带来最高的工作满意度。健康科学、数学和心理学。

但是在家工作呢？人们喜欢在华丽的办公室工作还是在舒适的家里工作。根据数据，在家工作会带来更高的工作满意度。

因此，为了保证开发人员的工作满意度，最好的机会是编码是你的爱好，并且你也为开源项目做贡献。你应该在波斯尼亚或立陶宛，你的本科专业是健康科学，你要么有博士学位，要么你只学到中学。你为一家风险投资的初创公司工作，每周工作 36 个小时，大部分时间在家。😃

问题 3——高工资因素

正如我们在文章前面看到的，工资与工作满意度正相关，与工作时间负相关。让我们更详细地看看。

每周工作 18 小时似乎是工资最高的。

不出所料，公司类型确实会带来更高的薪水。财力雄厚的上市公司是这里的赢家。风险投资的创业公司紧随其后。

正规教育在事情的发展过程中扮演了多大的角色。这个结果看起来非常有规律，直到硕士学位。博士学位仍然收入最高。

与工作满意度得分相似，对开源的贡献和作为爱好的编码会带来最高的薪水。

远程工作不会降低薪水，反而会带来更高的薪水和更高的工作满意度。双赢的提议。

对于一名开发人员来说，人们会认为计算机科学本科毕业会带来更高的薪水。但是，事实证明，来自不同学科、具有跨职能专业知识的人能拿到高薪。

最重要的是位置如何对人有利。从下面的图表中我们可以看到，这造成了很大的差异，美国和瑞士位于光谱的顶端，尼泊尔和孟加拉国位于底部。

最后但同样重要的是，态度在现实世界中有多重要？

作为调查一部分的 WorkPayCare 属性意味着—

“I don’t really care what I work on, so long as I’m paid well”

从下面的情节中我们可以看出，比起工作类型，那些更在乎钱的人实际上最终会赔钱。

不过，这种趋势可能还有另一个原因。那些收入已经很低的人，出于沮丧，可能会有这种态度去做任何工作，只要报酬更高。相反，收入已经很高的人不想适应这种工作。

C 结论

因此，作为一名成功的开发人员，有几件事情可以做。在你波斯尼亚舒适的家里，为一家美国的风险投资创业公司每周工作 36 小时，100%远程。这可能是梦寐以求的工作！

你怎么看？请在评论中告诉我。

为了检查更多关于这个分析，请看看我的 Github 链接这里。

约翰还是保罗？数据解决了古老的“谁是第一披头士”的问题

原文：https://towardsdatascience.com/john-or-paul-data-resolves-the-age-old-who-was-the-1-beatle-question-fca8d8232df5?source=collection_archive---------1-----------------------

最近我有很多空闲时间；或者更确切地说，很多时候我手里都拿着一个新生儿。那么当你没有手的时候，你有很多时间做什么呢？听听甲壳虫乐队！对于一个婴儿来说，有什么比有史以来最伟大的乐队更好的音乐世界入门呢？

保罗和约翰:从好朋友到敌人

Youtube 的推荐系统很快锁定了我，向我展示了大量关于披头士的事实和八卦。没有什么故事比约翰和保罗之间错综复杂的关系更耐人寻味了。他们从十几岁的闺蜜开始，逃学到保罗爸爸的房子里演奏音乐。忠于他们的 BFF 誓言，他们决定分享他们创作的每一首歌的荣誉，因此大多数甲壳虫乐队的歌曲都由列侬/麦卡特尼正式命名。接下来，他们花数年时间睡在同一个房间里，从汉堡的破旧公寓，在德国夜总会玩摇滚翻唱，到披头士狂热，最后成为，嗯，比耶稣更有名的。从青少年时期的友谊开始，逐渐变成了一场激烈的自我驱动的竞争，最终在痛苦的离婚般的分手中破裂。金融纠纷，暗箭伤人的指控，所有的一切。看到这样的真爱死去令人心碎…

就像任何离婚一样，保罗不是圣人，但我发现自己特别反感约翰在分手后的最终公开评论。他几乎无处不在。一些亮点:说“保罗死于音乐”，把保罗的婚礼描述成葬礼，声称保罗的音乐对电梯有好处，在“等歌曲中嘲讽保罗，你晚上怎么睡得着？”。哎哟！80 年代对保罗的一次采访让他承认这有多伤人，尤其是因为知道约翰的批评会持续下去。如果约翰说他是甲壳虫乐队的真正天才，谁能反驳呢？并且坚持了下来——直到今天，许多粉丝认为约翰是甲壳虫乐队背后的艺术力量，而保罗只是一个庸俗的歌曲作者。需要为自己对有史以来无可争议的最伟大乐队的贡献辩护，尤其是面对你前闺蜜的指控，这一定是多么令人沮丧。

但是如果约翰是对的呢？如果约翰真的是迄今为止最伟大的披头士成员呢？乔治在这场竞争中处于什么位置？

我们来看数据！

甲壳虫乐队痛苦分手的一线希望是，约翰和保罗都觉得可以自由地为每首歌尽可能多地邀功，实质上解开了列侬/麦卡特尼的归属；我使用了这个数据源，它指定了主作曲家作为参考，即使是他们合作的歌曲(基本上是他们所有的歌曲)。我将林戈演唱的曲目分成了自己的类别，因为约翰和保罗通常都为林戈创作简单的歌曲，这些歌曲符合他的演唱能力和无忧无虑的的个性，但却不是他们最好的素材。

让我们先来看看歌曲数量:在甲壳虫乐队录制的 208 首歌曲中，71 首大多是约翰写的，68 首大多是保罗写的，22 首是乔治写的，21 首是他们早期的翻唱歌曲，16 首是约翰+保罗的歌曲(他们平均贡献的歌曲)，10 首是林戈唱的，其中有两首是他自己写的(和 章鱼的花园约翰和保罗在歌曲创作方面几乎同样多产，远远领先于乔治，后者只是在他们后来的专辑中才开始做出重要贡献。

那么谁写的歌更好呢？

艺术的“缺点”之一是它不可客观测量。谁能说一首歌比另一首好呢？为了解决这个棘手的问题，让我们先从分析受欢迎程度的客观指标开始，然后再来分析最主观的量化我自己的偏好！(作为博文作者的额外津贴……)

Spotify 来拯救我们！

Spotify 很牛逼吧？以下分析依靠 Spotify 流计数挖掘人气。让我们深入了解一下:

Top left: most streamed Beatles songs. Bottom left: Log normal distribution of stream counts for all Beatles songs. Right: Median stream count per Beatle

在披头士流传最广的 10 首歌曲中，有 5 首是保罗写的，2 首是约翰写的，1 首是乔治写的。有趣的是，流计数的分布几乎是完美的对数正态分布。这是为什么呢？对数正态分布出现在许多因素相互叠加产生倍增效应的情况下。造成这种情况的一个可能的假设是网络效应；如果你真的喜欢一首歌，你可能会比你只是稍微喜欢的那首歌多放很多次。这将使这首歌更有可能被推荐(无论是你还是 Spotify 的算法)，从而导致一种指数现象。

对歌曲计数中位数的分析显示了一些有趣的事实:

保罗是最受欢迎的甲壳虫乐队成员！他的中流数几乎是约翰的两倍。对我来说，这是一个相当出乎意料的结果。
乔治的歌远不如保罗或约翰的受欢迎。乔治的流数很有趣:他的平均流数实际上高于约翰，但这主要是受他的前三首歌的影响:太阳来了、什么的和而我的吉他轻轻哭泣，这占了他的流的 80%，而《太阳来了》一曲就解释了超过 50%的 3.78 亿的流。那些都是很棒的歌，但是剩下的 19 首歌就没那么受欢迎了。他第四受欢迎的歌曲实际上在 208 首歌曲中只排在第 84 位。George 的案例很好地说明了为什么 中值比平均值更好，尤其是在对数正态分布等非对称分布中。**
林戈的歌曲是最不流畅的。他是个有趣的家伙。也是个很好的鼓手。我们爱你，林戈！作为一个人，但作为一个歌手/歌曲作者就不那么重要了。

为保罗欢呼！但是人气真的是质量最好的指标吗？如果 Spotify 流计数可以作为衡量质量的标准，德雷克和爱莉安娜·格兰德应该是流行音乐史上最优秀的音乐家。如果你听起来没有，那么你肯定是读错了博客文章…

超越流行:主观分析

我听了甲壳虫乐队的 208 首歌中的每一首(那是 14 个小时的播放时间，我已经提到我手上有一个新生儿的时间了吗？)并对每首歌进行了 0 到 10 分的评分。你可以在这里看到数据集。这明显是一个非常** 主观的评级！优美的旋律，有趣的和声和充满激情的歌词在我的书中获得了高分。让我们先来看看我自己的偏好与 Spotify 受欢迎程度的关系:**

歌曲的精彩程度(由我评定)和 Spotify 流计数之间存在 0.59 的强皮尔逊相关性。值得注意的是几首与这种相关性明显不同的歌曲:乔治的可爱的印第安灵感和约翰的 是的，它是 其扣人心弦的和声都表现过度，而约翰的无聊前卫 革命 9 ( 谢谢洋子！)是表现最差的。保罗太可爱Ob-la-di Ob-la-da和顺其自然都获得了相当高的分数，但远低于他们在 Spotify 上的受欢迎程度。****

接下来，该吃主菜了。让我们来看看披头士的《牛逼》:

保罗和约翰很接近，保罗略微领先。
林戈的歌没那么好。 在朋友们的帮助下 是林戈评价最高的歌曲，但这绝对是一次性的:他其余所有的歌曲都在最好听的范围内。约翰和保罗努力做到兼容并蓄，确保林戈的影响超越了他的鼓点，这让我们非常尊重他们，但这些可爱的尝试几乎从未触及真正伟大的披头士歌曲的独创性。
乔治有一些好歌，但他不是保罗或约翰。虽然他有几首歌在纯粹的天才级别中排名很高(什么的、太阳来了)，但他也有不少不那么令人印象深刻的歌曲。他是一个令人敬畏的吉他演奏者，他的吉他演奏在披头士的歌曲中起着至关重要的作用，但他很难跟上保罗和约翰的歌曲创作天才。

深入挖掘一下约翰和保罗的竞争，我们可以看到约翰实际上有更多真正令人敬畏的歌曲，但他也有更多 Meh-ish 歌曲。保罗则比较稳定，他的大部分歌曲都在《爱它！类别，但达到纯粹天才评级的歌曲略少。

结论:保罗是最伟大的甲壳虫乐队成员

根本没有明确的赢家，但如果追问的话，我会说这个分析显示保罗是比 T2 稍微好一点的歌曲作者。有一点可以有把握地说，约翰是而不是甲壳虫乐队背后唯一的艺术驱动力，因为他有时试图将自己描绘成后甲壳虫乐队，保罗可以自信地宣称他是有史以来最优秀的两位歌曲作者之一。要记住的一件重要的事情是，他们从来没有真正自己创作过歌曲，几乎总是参加彼此歌曲的录制，即使是在他们分手前充满苦涩的日子里。约翰的 我要你(她好重) 如果没有保罗惊人的低音线会是什么样？或者保罗的买不到我的爱没有约翰的和声和节奏吉他？或者这么多披头士的歌曲没有乔治美妙的吉他独奏？

John helping Paul with his song in a picture taken by Linda McCartney

另一方面，在听过他们所有的歌曲后，很明显每个人都有自己的天赋:保罗是一个纯粹意义上的音乐家，不断创造出美妙的旋律(仅举几个例子，昨天，米歇尔)，甚至在他的旋律基础演奏中做到了这一点。另一方面，约翰是更完整的艺术家，他在某些方面只是偶然地用音乐来表达自己。他是一个伟大的音乐家，但人们可以说他的歌词和音乐一样伟大，如果不是更好的话(宇宙中的，无名之辈，B 因为)。他的情感谱要黑暗得多，这在某种程度上帮助他创作了更具冲击力的摇滚歌曲。

谢谢约翰和保罗！虽然他们对彼此的爱没有他们的音乐遗产持续得久，但如果没有这些千载难逢的天才之间的特殊关系，这个世界将不再是同一个地方。

奖励曲目:披头士专辑间的比较

让我们根据手动评分的歌曲“牛逼程度”的平均值来给披头士的所有专辑排名:

原来， Abbey Road 是甲壳虫乐队最好的专辑左轮手枪和佩珀中士紧随其后。这是一个特别惊人的壮举，因为在录制《艾比路》的时候，甲壳虫乐队已经很少说话了，他们的交流几乎只限于录音室里的音乐。我觉得这个分析对白色专辑不公平，因为它实际上有最多的歌曲被评为“天才”。这表明了这种双专辑的不一致性——如果甲壳虫乐队将白色专辑缩减为包含两张专辑中最佳歌曲的一张专辑，它的平均评级也会跃升至榜首。我也觉得橡胶灵魂在这里被稍微低估了；虽然它缺少许多天才级别的歌曲，但我觉得这是一个总和大于其部分的情况，这并没有反映在这首歌曲的统计数据中。****

那都是乡亲们！

联接数据源

原文：https://towardsdatascience.com/joining-data-sources-8ca72f19747?source=collection_archive---------21-----------------------

Photo by Christopher Burns on Unsplash

现实世界中的大多数“数据科学”都涉及到创建一个数据集、一个可视化、一个需要从非常不同的来源提取和连接数据来讲述一个连贯故事的应用程序。

跳过玩具数据集，让我们来看一个将不同数据源连接成一个综合地图的完整应用程序。具体来说，我们将回答这个问题:

洛杉机县哪个邮政编码区的人均星巴克门店最多？

举例来说，如果你的工作是在洛杉矶县寻找新星巴克店的最佳地点，你可能会对这个问题的答案非常感兴趣。

定义最终目标

我们的最终目标是创建洛杉矶县的地图。我们的 choropleth 地图基本上满足以下要求:

-所有的 邮政编码边界 都要画出来

-每个邮政编码应根据人均星巴克门店数量以可变强度着色

我们需要什么类型的数据？

好的，所以我们肯定需要某种地理数据来绘制邮政编码的形状。我们还需要洛杉矶县每家星巴克的位置信息。当然，我们需要一些邮政编码为的 LA 县的人口信息。总而言之，我们需要:

1。 洛杉矶县邮政编码边界的地理数据(最好是 GeoJSON 文件，是描述复杂形状的 JSON)

2。 洛杉机郡每家星巴克店的位置(最好是带有每家店邮政编码的电子表格)

3。* 洛杉矶县人口按邮政编码(最好是电子表格)*

我们可以在哪里找到数据？

厉害！我们已经确定了我们理想中需要的数据类型。现在，让我们考虑一下 在哪里 我们会得到这些数据集。

地理数据似乎很容易，在谷歌上搜索“ la county zipcode geojson ”最终让我找到了合适的 geojson，存储在我的 GitHub 这里。

事实证明，星巴克门店的位置数据要复杂得多。我发现的数据集要么是过时了，要么只是特定的州而不是特定的县。为了获得这些数据，我必须对官方的星巴克商店定位器做一些非常仔细的 API 查询。事实上，这个过程非常有趣，足以让我单独写一篇关于它的文章:

* [## 使用 Python 快速收集脏数据

洛杉矶县有多少家星巴克？

towardsdatascience.com](/quick-and-dirty-data-gathering-with-python-9d3d4b8cba13)

对于人口数据集，我在网上找到了一些我想要的预制电子表格，但老实说，我不确定它们的有效性。我认为直接从美国人口普查局获得人口数据要安全得多。获取这些数据需要非常具体地调用人口普查局 API，我有一整篇文章专门介绍这个过程:

[## 通过 5 个简单的步骤获得人口普查数据

为您的项目收集人口数据的简明指南

towardsdatascience.com](/getting-census-data-in-5-easy-steps-a08eeb63995d)

您可以在我的 GitHub 上找到所有三个结果数据集:

洛城县的 GeoJSON 是这里的
洛杉矶县星巴克位置数据集是这里是
洛杉矶县人口(按邮政编码)数据集是这里是

我们将如何连接数据集？

好了，我们已经得到了想要的数据。现在，让我们想出一个策略，如何将所有这些结合在一起，制作出我们想要的地图。为了制作地图，我们需要洛杉矶县每个邮政编码的人均星巴克门店数量。目前，我们有创建该指标所需的两个部分，人口数据和商店数据，但需要将它们结合在一起。

因此，使用两阶段方法是有意义的。第一阶段将把人口数据与商店位置数据结合起来，第二阶段将把产生的人均商店数据集与地理数据结合起来。

大概是这样的:

第一阶段:加入人口和店铺位置数据

让我们看一下这两个电子表格的快照，以确定如何将它们连接起来。

人口数据

存储位置数据

看起来我们应该能够将邮政编码列上的两个数据集连接起来，但是有一个问题。商店位置数据包含洛杉矶县每家星巴克商店的一行，但我们真的希望每个邮政编码占一行，商店总数占另一列。让我们使用 python 来做一些快速和肮脏的数据转换！

一旦我们转换了商店位置数据集，它就包含邮政编码作为索引，邮政编码中的星巴克商店数量作为列。

现在，让我们将两个数据集连接在一起:

随后， joinedDf 看起来是这样的:

怎么有些词条是南？ 好吧，如果某个邮政编码存在于人口数据集中，而不存在于商店数据集中，那么它的numStores**值就会缺失，反之亦然。我们马上会处理这个问题。**

现在，让我们通过将商店数量除以每个邮政编码的总人口来创建人均商店指标。我们还将删除所有人均商店为空或无穷大的邮政编码(如果邮政编码的人口为零)。

由此产生的 joinedDf 看起来像是:

不错！第一阶段已经完成。我们有一个数据框架，其中包含每个邮政编码的人均商店数。

阶段 2:使用地理数据绘制人均商店地图

现在我们有了包含人均商店的数据集，我们可以在洛杉矶县的地图上绘制这些值，其形状细节存储在我们的地理数据中。让我们创建我们的 choropleth 地图吧！

你生成的laChoropleth.html地图将是交互式的，当你打开它时，你将能够点击、拖动和缩放。我们来看看结果如何。

我们确实在地图上看到一些不同深浅的绿色，但是似乎没有太多的变化。这通常发生在 choropleth 图中，当所讨论的变量存在较大的异常值时。对于我们的例子，这意味着对于 商店人均 来说，有一些邮政编码的 值非常大，而大多数邮政编码的值相对较小。

我们将在这里做一个折衷，通过 storesPerCapita 删除邮政编码的前 10% 。 在生成的地图中会有更多缺失的邮政编码，但保留下来的邮政编码会显示出更好的色谱。我们还将缺失的邮政编码涂成灰色，这样我们就可以知道它们确实缺失了。这是我们最后的舞蹈。

正如我们所看到的，由于各种原因，有相当多的邮政编码缺失。这可能是因为缺少人口或商店数量的值，或者可能是因为人口为零，或者可能是因为我们在上一步中选择了将其删除。不管怎样，留下的邮政编码显示出比原来的 choropleth 更好的颜色渐变。你绘制地图的确切方式完全取决于你！

希望本指南演示了如何收集、连接并最终可视化不同的数据源，对您未来的数据工作有所帮助。**感谢阅读！***

社交媒体时代的新闻业:探索新闻、记者、假货、分享行为和兴趣

原文：https://towardsdatascience.com/journalism-in-the-age-of-social-media-exploring-news-journalists-fakes-sharing-behaviour-5f553d79c77c?source=collection_archive---------21-----------------------

在线新闻和社交媒体使用中的数据科学

Photo by Roman Kraft on Unsplash

如今，理解新闻业并非易事。首先，对于今天的记者，还没有一个共同的、可靠的定义。从某种意义上说，现在任何人都可以当记者。

一种可能的解释是，记者是新闻行业的专业人士，属于一个实践团体。

可以检测记者的分类器的现有实现可以达到 95%的精确度。

下一步是了解文章是否可靠和不可靠。存在能够自动检测和解释分类的方法。

最后，重要的一点是在线新闻媒体如何与社交媒体和新闻的社交分享联系起来。贝尔实验室( @BellLabs )对人们在新闻中看到的内容和他们分享的内容进行的一项研究显示，两者之间存在很大差异。

..但是获取新闻在很大程度上不是基于社交媒体。58%的新闻媒体推荐是自我推荐。只有 0.3%是通过推特。

跨社交媒体平台转载新闻是用户的典型行为，但每个平台都有自己的规范。我们可以定义一个递增的参与度:

不同的操作适用于不同的平台。此外，主题的受欢迎程度在不同的平台上是不同的:

所有这些都与我们最近关于社交媒体上新闻分享行为的工作(和开放资源)密切相关。具体来说，我们已经发布了关于该主题的开放资源，如:

一个数据收集和丰富管道，允许从一组新闻源开始，生成包括新闻内容和社会互动的自定义数据集。
该数据集包括来自美国主要新闻媒体的新闻文章和 Twitter 上的相关分享活动，涵盖了推文内容和作者简介。

您可以出于任何目的访问这些资源，因为它们分别在 GitHub 和 Harvard Dataverse 上公开提供。你可以在的幻灯片分享上找到简短的描述。

可在 AAAI 图书馆上直接获得描述性论文。

这篇报道是关于 2019 年 6 月 13 日新闻发布会期间在 ICWSM 2019 (国际网络和社交媒体 AAAI 会议)上展示的作品。论文全文可在 AAAI 图书馆在线查阅，第 13 卷，第 01 期。

Photo by Elijah O'Donnell on Unsplash

什么是云之旅？

原文：https://towardsdatascience.com/journey-cloud-transformation-48a05b20aef?source=collection_archive---------28-----------------------

您不能错过这趟列车，请加入云转型

时机成熟了，伙计们。过去几年我们看到的情况令人不安。云作为一个概念出现，十年后将改变我们的生活。想想你的照片，它们没有存储在云中，可以在任何地方访问。如今，从开发人员到首席执行官，每个人都知道有一个叫做云的机会。本文在简要介绍了云的优势之后，展示了如何移动您的本地应用程序。

云优势是什么？

在云时代之初，说服人们去云的关键词是“它很便宜”。嗯，经过十年的云计算，我们明白这不是成本的问题。在某些情况下，我们体验到云的成本高于本地解决方案。云的关键词是灵活性、效率和战略。

灵活性

IT 项目中最常见的需求是标记时间。如今，每个人都需要比竞争对手更快的解决方案。这种持续的匆忙与实施内部解决方案的常规时间安排相冲突。此外，你需要尝试很多解决方案才能有竞争力。这意味着，并不是所有你将要完成的项目都会结束，或者会有漫长而丰富的生命。但是硬件最终不能简单地转售，sysadmin 的时代一去不复返了。在这种情况下，云帮助了我们。它非常灵活，因此您可以根据自己的需求进行扩展和收缩。此外，你肯定，如果你有足够的钱买它，将有足够的资源给你。

效率

本地解决方案很难维护，需要付出大量努力来保持高效。你需要监控物理数据中心，监控基础设施，与 ISP 签订最好的合同，并为冗余硬件等无用资源付费。你还必须支付入侵测试、保险等安全方面的费用。基本上，云提供商比单个公司更有效率，因为这是他们的工作。他们充分利用成本，能够承担更好的安全检查。而且认为对 AI API 等最有价值的服务。有多少公司可以雇佣一个机器学习工程师请他解决一个图像分类问题？也许更快和更便宜的最终支付昂贵的即用服务。

战略价值

对于所有非 IT 公司来说，花时间在 IT 上是一个混乱的时代。技术是使公司获得(更多)业务的要素，但是……谁真正看到了它的战略性报酬？云提供了许多降低运营成本的机会，并允许公司管理层专注于主要的业务流程或流程。像更新你的 WordPress 网站或者你的 CRM 这样的傻事不再是问题。这种事情必须自动发生。

Foto di 200 Degrees da Pixabay

我如何迁移到云？

云对于那些从零开始的人来说很容易，比如创业公司。当你从白皮书开始，你没有限制，你的第一个约束是要快。你不需要让已经存在的东西活着。基本上，问题是:

如何将现有的应用程序迁移到云中？

有许多选项和方法，但我们可以将问题简化为三种不同的解决方案:

换档并抬起。
重构
重建
替换

将应用转移和提升到云

转移和提升的基础是尽可能少地将应用程序放到云上。这意味着完成迁移的时间更短，软件层的工作量更少。对此的支持通常是 PaaS(平台即服务),并解决与物理基础设施相关的问题。顺便说一句，软件上没有任何改变，所以应用程序可能会在伸缩性和性能上保持一些限制。

重构

为了获得比简单地将应用程序转移到云更多的优势，我们可以重构一些 pat 并获得一些最佳收益。这一选择的驱动力是找到最具影响力的变化，并有选择地应用。

例如，您可以将数据库移动到云数据库，但保持相同的接口。这可以使用云数据库服务来完成，它可以被看作是常规的 SQL 数据库，但基于云。这对于大多数应用程序来说是相当透明的，并且很容易带来性能的提高。解决这个问题的好方法是 Aurora DB 或者 Azure MySQL

重建

重构和再工程之间没有任何概念上的区别，两者都是对现有代码的工作，从云机会中获得更多的好处。实际的区别在于这种变化的范围。重构包括许多软件部分和细节的改变。这种实践有助于通过小的变化获得好处。但是在野生世界里，并不总是小变化就足够了。在某些情况下，您还需要对基础架构进行更改，这称为重新设计。

例如，按照前面的示例，您会发现简单地从本地 mysql 切换到云版本对您来说是不够的，还需要扩展和可用性，以及您需要移动到 NoSQL 解决方案的内容。你可以在 Azure 上使用 Cosmos DB，在 Google Cloud 上使用 Firebase，或者在 IBM Cloud 上使用 DashDB。

替换

实际上，这是最常用的解决方案。似乎很奇怪的是，简单地把你的价值几千美元的应用程序扔掉是最常见的解决方案。顺便说一下，福布斯给了我们一个有趣的统计。企业 SaaS 市场现在为软件供应商创造了 200 亿美元的季度收入。这一数字每年增长 32%。即使我们不知道新软件和移动软件之间的百分比，我们也可以假设这些数字中有很多是由本地软件完成的，而这些本地软件被 SaaS 的替代软件所取代。

得到标准溶液。这也有助于标准化公司内部流程
降低维护成本:无需维护基础设施或支付维护或更新费用。你得到了该产品的最新版本
重新设计一个旧的应用程序意味着重写它。公司实际使用的软件已经丢失了几十年，重新设计比重做更昂贵。即使在没有任何垂直替换的情况下，从头开始可能是更便宜的选择。

带什么回家

十年前，云是一个赌注，但现在是一个切实的机会。每家公司都应该已经引入并开始着手实施。这一举动不必是瞬间的。你可能需要时间来完全转向云，对于许多公司来说，这可能根本不可能。

第一步是承认搬迁不可能一蹴而就，而是一个漫长的旅程。

这一旅程进入了一种称为“混合云”的状态，在这种状态下，本地结构与云结构协同工作。使用 shift & lift 技术可以快速移动大多数应用程序，但是如果您保持数据中心在线以满足其他需求，这可能不会带来太多价值。在很多情况下，你可以通过对软件的小改动获得很多好处(重构和再造)，但是大多数公司只是在他们的软件寿终正寝时才采用 SaaS 解决方案。

数据科学之旅

原文：https://towardsdatascience.com/journey-into-data-mining-3b5ccfa5343?source=collection_archive---------22-----------------------

数据挖掘和机器学习导论

G 鉴于每秒钟数据量的增加，人们越来越倾向于数据科学和机器学习。要想擅长它们，就需要在Data Mining领域有强大的基础。

U 对数据科学的理解来自于从概念上理解什么是数据，如何处理我们得到的数据(数据对于每个问题总是不同的)，以及如何在将数据交给机器学习算法之前有效地预处理数据。我目前正在编写代码示例，完成后我会尽快添加它们。

请容忍我的概念性部分，我知道这可能有点无聊，但如果你有强大的基础，那么没有什么可以阻止你成为一名伟大的数据科学家或机器学习工程师。

Photo by Mika Baumeister on Unsplash

L 我们先问自己一个问题，什么是数据？

→简单来说，数据是一组对象及其属性的集合。数据对象的其他名称有记录、点、向量、模式、事件、事例、样本、观察或实体。

现在，我们必须知道什么是属性？

→它是一个物体的属性或特征。例如:一个人眼睛的颜色。这也称为其他名称，如变量、字段、特性、尺寸、特征等。

然而，为了讨论和更精确地分析物体的特征，我们给它们分配数字或符号。为了明确地做到这一点，我们需要一个测量标尺。那么，测量尺到底是什么？

→嗯，是把一个数值或符号值(属性值)和一个对象的属性关联起来的规则(函数)。例如，我们将某人分为男性或女性。

从上面的讨论中，很明显，用于表示属性的值可能具有不是属性本身的属性，反之亦然。这可以借助一个例子来理解:雇员年龄和 ID 号，这两个属性是用整数值定义的，但它们有不同的意义。谈论员工的平均年龄是有意义的，但不要谈论员工的平均 ID。

他要求根据属性的特征将属性分成不同的类型。数字的下列性质(运算)通常用于描述属性。

清晰度:=和≦
顺序:，且≥
加法:+和-
乘法:*和/

给定这些属性，我们可以定义四种类型的属性:标称、序数、区间、和比率。我在下面提供了两个表格来解释这些属性类型和它们的转换。

Table 1: Attribute Type Explanation, Table 2: Transformation that defines attribute levels

名义和序数属性统称为范畴或定性属性。顾名思义，定性属性，比如员工 ID，缺少数字的大部分属性。即使用数字表示，即整数，也应该更像符号一样对待。

剩下的两类属性，区间和比率，统称为数量或数值属性。数量属性用数字表示，具有数字的大部分性质。请注意，数量属性可以是整数值，也可以是连续的。

不同类型的属性符合上述不同的属性。标称符合区别。序号遵循区别和顺序。间隔遵循区别、顺序和有意义差异。比率符合所有四个属性(区别、顺序、加法和乘法)。

L 最后，在结束这篇帖子之前，我想说一下连续、离散和非对称属性。它们是理解真实数据的关键部分，因为大多数数据集都是由它们的组合组成的，所以区分变得相当重要。

什么是离散属性？

→它只有有限或可数无限的值集。示例:邮政编码

→这些通常表示为整数值。

什么是连续属性？

→它有实数作为属性值。例如:温度、高度等。

→这些值实际上只能用有限的数字来测量和表示。这意味着它们被表示为浮点变量。

什么是不对称属性？

→在这种情况下，只有非零值是重要的。

例如，考虑一个数据集，其中每个对象都是一名学生，每个属性都记录了一名学生是否在大学上过某门特定的课程。对于特定的学生，如果学生选择了与该属性相关联的课程，则该属性的值为 1，否则为 0。因为学生只选修了所有可用课程的一小部分，所以这种数据集中的大部分值都是 0。因此，关注非零值更有意义，效率也更高。这篇关于数据及其属性的文章到此结束。

这篇帖子的后续是这里。

[## 数据科学、数据挖掘和机器学习中的数据集类型

以及它们的一般特征…

towardsdatascience.com](/types-of-data-sets-in-data-science-data-mining-machine-learning-eb47c80af7a)

我正在免费赠送一本关于一致性的电子书。在这里获得你的免费电子书。

如果你喜欢阅读这样的故事，那么你应该 在你的收件箱 中获取我的帖子，如果你想支持我成为一名作家，考虑注册成为一名媒体成员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你注册使用我的链接，我会赚一小笔佣金，不需要你额外付费。

[## 加入我的推荐链接-塔伦古普塔

作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…

tarun-gupta.medium.com](https://tarun-gupta.medium.com/membership)

感谢阅读。如果你喜欢这篇文章，请访问我在这里的其他文章:

[## 标记故事列表的快速链接—感谢您的访问

我也有一份以快节奏出版为目标的出版物。读书成为作家。

tarun-gupta.medium.com](https://tarun-gupta.medium.com/thank-you-for-visiting-my-profile-9f708062c75e)

世界冠军之旅-2019 年微软创新杯

原文：https://towardsdatascience.com/journey-to-the-world-championship-microsoft-imagine-cup-2019-9e7f15e37442?source=collection_archive---------18-----------------------

被微软视为“技术奥林匹克”的世界最大挑战之旅

这是一个基于真实事件的故事，讲述了来自印度韦洛尔理工学院的三名工程系学生参加由微软主办的由微软创意杯命名的世界最大工程挑战赛的旅程。

Microsoft Imagine Cup 2019

I magine Cup 是由微软公司赞助和主办的一年一度的比赛，它将全世界的学生开发者聚集在一起，帮助解决一些世界上最棘手的挑战。它被计算机科学和工程视为“技术奥林匹克”，被认为是与技术和软件设计相关的顶级竞赛和奖项之一。所有创新杯参赛者都创建了创新杯主题的项目:

microsoftimaginecup — 12 teams…each with a story to tell, each with an idea to share, an idea that could impact the world. Every single second felt like…a chance to grow,” shares Ansh on his team, Alpha-India’s #ImagineCup journey.

"想象一个科技帮助解决最棘手问题的世界"

每个人都来自不同的背景和文化。一个是充满激情的设计师(Ansh Mehra)，第二个是用心的铁杆研究员(Hemant H Kumar)，最后是我(Saransh Mittal)，脑子里充满了意想不到的精彩想法，有着创新解决方案的愿景，这些解决方案具有巨大的社会影响，并有可能解决现实世界的问题。旅途中的每一天都让我们学到了新的有价值的东西。

我们是 28000 名学生中的一员，他们申请了来自亚洲地区 20 多个国家的 2019 年微软创新杯。结果已经公布，前 12 名团队有机会在世界面前展示他们的产品。我们一生只有一次机会代表印度参加亚洲锦标赛。

那么我们是怎么知道想象杯的呢？

微软学生技术社区

HackHarvard 2018 at Harvard University, Boston

我是大学技术社区的一员，这个社区是由各种非常勤奋的学生作为微软的学生伙伴为微软创立的。在社区招募我的那天，我的一个学长向我介绍了想象杯。即使我在参观哈佛大学之前就很清楚这个比赛，我总是低估我的批判性思维和能力，总是认为我没有足够的能力参加世界锦标赛。我会在未来的想象杯印度总决赛的审判日之后证明自己是错的。

在哈佛大学举办的 HackHarvard 2018

Saransh Mittal at Harvard University, Boston

这一切都要追溯到 2018 年 10 月，当时我们去哈佛大学参加 HackHarvard 2018。我们在黑客马拉松上开发了一个应用程序的原型，并向很多人推销。幸运的是，负责微软学生合作伙伴项目的创新杯团队成员 Susan Ibach 喜欢我们的想法，并看到了将其转化为大项目的潜力。她激励我们进一步研究这个想法，进一步改进原型，并为 2019 年微软创新杯提交一份新的提案。

我们尽了最大努力在评委面前推销这个想法，但很快意识到我们的应用程序太基础了，无法产生真正的影响。尽管我们没有赢得波士顿黑客大会，但我们相信我们必须在理念和产品上有很大的改进。我们刚刚开发了一个应用程序，可以检查一种食品是否含有某种成分。我们回来后开始开发我们的移动应用程序。我们集思广益，试图为我们现有的技术体系找到一个合适的想法，来解决我们产品中的某些缺陷，从而解决问题。

Prototype of the SPOT created at HackHarvard 2018 by team Alpha-India

“永远不要对自己或自己的想法失去信心”

关于我们的想法和概念

SPOT——将增强现实引入零售店

The project we presented at the Microsoft Imagine Cup 2019

考虑一个场景，杰克和他 7 岁的女儿艾伦去中国旅行。劳累了一天后，他们进入一家超市买东西，却发现所有的商品都有中文信息。由于对坚果过敏，艾伦已经住院两次。Spot 接受了 Ellen 的健康档案，并允许她的父亲选择适合他女儿健康的产品。Spot 允许您在增强现实中比较多个产品。只需使用您的手机，点击产品，选择基于您的健康档案推荐的过滤器，并在增强现实中查看过滤的选择。每年有 100 多万人受到过敏反应(如过敏症)的影响，他们食用的食物会导致有害反应和危及生命的医疗紧急情况。如果一个人选择了对他的消费有害的过滤器，Spot 会立即警告他的选择。这是因为产品和消费者之间的信息差距。我们的目标是消除这种信息鸿沟。我们大部分的日常采购都是在线下完成的。网上杂货店允许我们平行比较产品，这是线下杂货店购物所不具备的功能。我们期待与企业和食品市场合作，让他们的产品做好准备。通过使他们的产品准备就绪，食品制造商可以给顾客更大的激励去选择他们的产品，增加他们的销售。

这很简单，但非常有效，因为它促进了适合你健康的选择，并且离线工作。我们使用了 Azure 的 CustomVision AI 来构建图像识别模型。使用 Python App Service，产品的数据库托管在 Azure Cosmos DB 上。现实世界和虚拟世界之间的界限正在慢慢消失，我们的目标是为离线购物世界引入一个新的维度。这对消费者和制造商都有利。做好 AR 准备可以促进产品的销售，弥合信息差距可以促进用户做出更健康的选择。

结果日-2019 年微软印度创意杯

经过几个不眠之夜的提案和提交视频的工作，结果出来了。视频是我们申请成功的关键因素。午夜时分，我在班加罗尔的一家初创公司工作，正在发布产品，这时我的队友赫曼特打电话给我，告诉了我一生中最好的消息。

"兄弟，我们被选中参加创意杯"

哇！我站在那里，高兴地尖叫，闭上眼睛，享受这一刻。我们做到了。在 HackHarvard 2018 之后，这是一段艰难的旅程，但我们做到了。我们克服了从祖国远道而来美国却没有赢得哈佛的失望。我们从未对我的想法失去信心，继续前进。我立即在深夜打电话给我的父母，向他们表达我最大的幸福，并分享这一美好的时刻。这是我第一次为自己感到超级自豪，告诉他们 2019 年的想象杯。

第二天，我们立即收到了来自微软的电子邮件，祝贺我们在比赛中的出色表现。在确认我们参加在澳大利亚悉尼举行的亚洲区决赛之前，他们给了我们必须遵守的指导方针。我们开始为澳大利亚之旅做准备，因为离冠军赛只有一个月了。他们开始处理我们的申请，让我们的签证获准进入澳大利亚边境。

接下来的几周，我们不断与微软保持联系。我们接受了媒体和外展团队的采访，以分享我们对我们旅程的看法，与微软的开发人员召开了会议，与微软印度团队的工程师进行了会谈，以帮助我们了解我们的业务模式，并与微软的其他专家进行了交流，他们在那里指导我们并简要介绍了我们未来的旅程。

我们赢得了微软创新杯印度全国赛，现在我们必须代表印度参加亚洲区决赛。我们热切地等待这一天已经很久了。所有的资助，包括我们国际旅行的机票以及我们在达令港附近的诺富特酒店的住宿，都是由微软赞助的。我们没有从口袋里掏出一分钱。

为冠军做准备，向世界展示我们最好的能力

入选是我们能想到的最大成就之一。来自 17 个国家的数百个团队提交了参加亚洲区决赛的项目，我们的团队是入选的 12 个团队之一。微软将于 2 月 10 日至 14 日让我们的团队飞往澳大利亚悉尼，争夺超过 20，000 美元的奖金，以及 5 月份参加 2019 年创新杯世界锦标赛的机会。

对于我们来说，这是一个千载难逢的机会，我们可以加入一个学生开发人员的全球社区，用技术产生影响，我们很高兴看到其他团队将为地区决赛带来什么。

我们无法抑制我们的兴奋。这是地球上最大的科技赛事之一，我们即将成为其中的一部分，但我们还没有准备好作为一个强大的竞争对手与其他团队竞争。所有的团队要么是为他们的想法寻找投资的初创公司，要么是像我们这样的团队，他们有一个想法，有一个在世界上产生巨大影响的愿景。现在是时候确保我们尽最大努力制作一个完整的可出版的产品，以及我们在想象杯上推销所需的所有东西。

More about our product for the Microsoft Imagine Cup 2019

很明显，我们需要一个强大的产品来实现我们的想法，并需要一个令人兴奋的推介计划来与其他团队进行激烈的竞争，以产生强大的影响。我们意识到参加决赛的人都是初创公司，所以为了打造我们产品的品牌，我们付出了一点努力，尝试了一些从未有过的新东西，包括一些附加产品，以产生更大的影响。

我们更加努力地改造应用程序的用户界面，通过大量的动画和调整使它更加用户直观。广告词和海报是与人们交流的静态方式，但视频预告片向人们传达了强有力的信息，帮助他们更好地理解你的想法。我们为我们的品牌设计了标志、海报、贴纸甚至 t 恤，让我们在微软 Ignite 上被介绍的人面前看起来很专业。

“无论你走到哪里，你都会带着你的品牌和理念。”

在去班加罗尔之前

我们对冠军无比兴奋，并准备前往澳大利亚悉尼参加亚洲区决赛。就在我们应该从班加罗尔机场起飞的一周前，我早上从软技能课上回来，不小心把 iPhone 掉在了人行道上，屏幕摔碎了。我很难过，因为屏幕坏了，整个应用程序即将完成，将在决赛中展示。无论如何，我不可能开发这个应用程序，因为 AR 开发需要我的智能手机上的摄像头工作。韦洛尔是印度的一个半城市化城市，在那里我们没有足够的设施让任何授权或熟练的人来修理智能手机。

事情对我来说并不顺利。我非常关注我的免疫力和健康。在过去的一个月里，健康状况不是很好。我的皮肤免疫系统接受了一段时间的药物治疗，突然我的健康状况开始恶化，我被诊断为因食用腐烂的食物而腹泻，并患有食物中毒。锦标赛就要到了，我不确定我是否能在我们启程之前康复。我被立即送进了医院，因为这种疾病正在大范围传播，无法控制。医生给我开了一些有助于快速恢复的药物，但几乎花了一周时间才完全治愈。

“健康应该是一个人在任何工作之前的第一要务。没有健康的生活，你就无法高效地工作和享受生活。”

Team Alpha-India on the flight to Sydney, Australia via Malaysia

抵达澳大利亚悉尼达令港的第一天

这一天到来了，我们结束了每天的工程课，从韦洛尔乘出租车离开。当我们离开大学时，我们的朋友来送我们，并祝我们旅途好运。一个月很快过去了，我们从来没有意识到。很快，等待结束了，我们离遇见来自世界各地的优秀的人们更近了一步。我们到达了班加罗尔——印度的网络城市，坐了很长一段时间的车后，我们累极了，我们到达了赫曼特的家。夜深了，但赫曼特的家人还是迎接了我们，并为我和安什准备了晚餐。晚饭后我们打了个盹睡着了，因为第二天还有很多工作要做。太阳升起，晨光渐长。我们计划在 Hemant 的家里呆一整天，研究产品和业务模型，购买新的杂货，并在我们从当地超市购买的新食品上测试我们的应用程序。Ansh 爸爸从德里来接他，把他的护照交给他，所以他和他一起走了，留下来过夜。我和 Hemant 不知疲倦地工作了一整夜，完成了应用程序的前端和后端。漫漫长夜很快就结束了，我们一大早就去了机场。我们在机场遇到了 Ansh，但当我们一进入机场，马来西亚航空公司的工作人员就从我们的旅行预订中认出了我们，并帮助我们办理了登机手续。我们非常震惊，航空公司的工作人员是如何知道我们进入了创新杯决赛的。突然，我们意识到微软应该已经通知他们我们的到来了。工作人员告诉我们，来自班加罗尔地区的另一个团队也到达了机场，并完成了登机手续，因为他们与我们乘坐同一架飞机。甚至在见到他们之前，我们之间的竞争意识就已经增长，我们决定观察他们的每一个动作，并尽可能少地互动，以了解他们的产品。

我们的第一段旅程是乘坐马来西亚航空公司的飞机从班加罗尔出发的，我们的航班本应在马来西亚的吉隆坡着陆。在马来西亚机场停留 6 个小时后，我们登上了飞往澳大利亚的联运航班。根据马来西亚时区，当时是晚上。我们的航班从跑道上起飞。飞机上的那个晚上充满了兴奋，因为我将会见到来自世界各地的优秀的人。离参加国际比赛的梦想又近了一步。

我们的飞机飞越澳大利亚，在该国中部上空的大部分旅程中，我除了不毛之地什么也没看到。澳大利亚是一个岛国，人口约为 2300 万，其中大多数人居住在该国的主要城市。很快，我们在悉尼机场着陆，看到这个岛国令人惊叹的美景，我们兴奋不已。机场建在海边，跑道与之平行。悉尼是一座郁郁葱葱的绿色城市，美丽的建筑横跨全城。这是印度的冬季，但经历了炎热的太阳，能量开始流经我们的身体，让我们兴奋不已。澳大利亚位于地球的南半球，与北半球的气候季节相反。这个国家拥有丰富多样的遗产，有来自世界各地的人。这是我第一次在这个国家看到很多来自亚洲国家的人，比如中国、韩国、泰国等等。

我们离开机场，一名来自微软的向导正在外面等待所有团队和 MSP，他们由处理旅程后勤的旅行社安排在同一时间到达——橘子旅行。一辆巴士正等在到达门口，把我们带到目的地——诺富特酒店。我们由其他决赛队伍和来自其他县的 MSP 陪同。很快我们就到了旅馆，帕布罗和琼迎接了我们。他们在大楼的入口处等着我们，带我们去各自的房间。我们完成了注册过程，Pablo 给了我们各自的想象杯参赛标签和一张礼品卡，可以在酒店旁边的购物中心的美食广场消费。酒店套房还没有准备好，所以我们把行李留在酒店，离开这个地方去探索周围的城市。

The first day at Sydney, Australia

我们的酒店紧挨着太平洋，澳大利亚所有著名的银行都把总部设在港口旁边的大楼里。几乎所有的旅游景点都在达令港附近。我和 Ansh 共用一个房间，但是 Hemant 和一个来自斯里兰卡队的参与者共用一个不同的房间。我们决定白天一起呆在房间里，然后晚上各自回房间睡觉。

傍晚时分，我们离开了房间的四面墙，去欣赏海边的美景。我们预订了一艘游轮，它将带我们游览这座城市海边的各个地方，然后乘船去看日落。在接下来的两个小时里，我们乘风破浪，在城市的岸边巡游。我们体验了悉尼歌剧院和许多地方的美丽。这是我一生中第一次登上轮船。所以很明显我对此非常兴奋！我们点击了大量的照片，从不同的角度，姿势和邮轮周围的地方。夕阳西下，骑行结束。晚饭后，我们回到各自的房间，工作了一会儿，然后打瞌睡，一直睡到第二天早上。

Team Alpha India at Sydney, Australia

创业日——微软反应器

那是早上 8 点，大巴在酒店门口等着我们，带我们去市里的微软反应器办公室。微软反应器是微软的一项举措，旨在孵化初创公司，并与他们密切合作，开发一种创新产品。第二天从模拟投球开始。微软为我们计划了一个特别的训练营，教我们如何从一个简单的商业模式为你的产品建立一个创业公司，并将最简单的想法转化为最具创新性的产品。

The Imagine Cup family

在创业日，他们邀请了所有创新杯的参与者以及微软的学生合作伙伴。有很多专家从美国飞来分享他们在生活中的知识和经验，关于用一个想法创建一个公司。整整一天，我们被介绍了创建公司的新方法及其商业模式，以及如何在评委面前做一个好的推介。会议结束后，所有的团队都被召集到舞台上，一个接一个地测试我们的产品。许多来自不同非英语国家的人发现很难向评委表达他们的想法。所有球队都要做大量艰苦的工作和最后的润色来改进他们的投球策略。由于来自印度，我们没有遇到语言障碍，但其他团队开发的产品非常出色。我们决定，即使他们的产品会比我们的产品有更大的受众群，我们也会用我们最好的产品来推销我们的产品。在推销会议结束后，我们被分成三组，每组四个团队，与当天召集的专家进行私人咨询。

The one with our mentors Cecily Kovatch and Tom Katona

我们与汤姆·考托瑙先生签了名，他是这次旅行的导师之一，他耐心地听我们对商业模式的想法，并集思广益，为我们第二天的工作提出改进建议。晚上晚些时候，我们都聚集在一起，在悉尼的最高峰合影留念，一天就此结束。

microsoftimaginecup - Wonderful end to day 1 of the Imagine Cup Asia Regional Final and Microsoft Student Partner Summit! Tomorrow, the Imagine Cup Asia Regional Finalists will compete for the chance to win USD15,000 and a spot in the World Championship. 🏆 Stay tuned and follow the action right here.

我们回到房间准备最后一次投球。忙碌了一天后，我们非常累，并计划晚饭后见面，为第二天的最后陈述练习。

夜晚过得如此之快，以至于我们甚至没有意识到我们花了多少时间来练习推销和改进展示我们想法的方式。我们多次改变了 Hemant 和 Ansh 晚上要展示的方式，我会制作产品，这样当人们来看我们的产品时，它就不会出现任何问题。我们确保我们完全按照导师建议的改进措施去做，然后睡觉，希望明天会更好。我们用来训练食品的模型并没有给我们带来好的结果。我们尝试了几种技术来创建一个好的 CNN 模型，试图以各种可能的方式捕捉产品的图像，以便我们的应用程序可以识别食品包装。我们花了很大的力气整晚一遍又一遍地点击数百张图片，以使我们的模型足够好，足以向评委推销。

2019 年微软创新杯亚洲总决赛

Team Alpha-India on the stage presenting their ideas to the judges at the Microsoft Imagine Cup 2019

第三天开始充满了兴奋，因为这是审判日，我们必须在来自不同领域和行业的法官面前投球。他们是来自世界各地的专家，是各自领域的佼佼者。我们很早就起来练习投球，然后去了酒店旁边的 ICC。我们进入会场，意识到整个建筑正在被第二天在微软工作的志愿者为 Ignite 大会进行装饰。

锦标赛开始前，所有的参赛者都在为最后一次投球练习。我们是少数几个提前到达会场的队伍之一。尽管我们很紧张，但还是为最后的表演做好了准备。在最后一刻之前，我们开始打开系统包装测试产品。赫曼特和安什本应带着我们最大的热情，在微软邀请的经验丰富的评委面前推销我们的产品。在最后一轮之前，我们通过努力工作至少练习了 100 次，改进了推介产品的方式，为人们每一次可能的 QnAs 做准备，改变了推介脚本，训练深度学习模型识别产品的包装，以及在我们等待已久的最后时刻之前展示产品演示的方式，远离我们的祖国印度。

这是一个时刻，也是一个梦想，对于一个工程系学生来说，他一生都在等待创新，向世界展示对人们发展的深厚热情，这种热情可以对他们的生活产生巨大影响，解决复杂而具有挑战性的问题，帮助人类这一代过上更好、更舒适的生活。

It’s show time

“表演时间到了！一个想法开始了旅程。来自创新杯亚洲区半决赛的 12 名决赛选手带来了他们最具原创性的技术解决方案，我们现在离赢得 10 万美元的大奖又近了一步。”

推介会议以尴尬的沉默开始，大门紧闭。所有的队伍都准备好了他们的产品，评委们在各自的位置上就座。整个礼堂都为最后时刻做好了准备，灯光暗了下来，比赛开始了。摄像机转向各队，我们分成四组，在观众面前投球。所有的团队开始一个接一个地在世界面前展示他们最伟大的创新想法。

轮到硬件项目了，来自中国的 RailinNova 队、来自印度的 Caeli 队、来自斯里兰卡的草帽队和来自马来西亚的suvecs队被叫上台。

在最后的投球之前，所有的导师和观众都祝我们好运，当 Ansh 和 Hemant 开始投球的时候到了。虽然我们很紧张，但我们的投球在我们生命中最长的 3 分钟后结束了。那是我一生中最快乐、最自豪的时刻。投球会议结束，结果宣布。一些媒体在比赛前告诉我们，来自印度的一支球队应该赢得全球冠军，把想象杯带回家。在最后的颁奖仪式之前。会议暂停了一会儿，让评委们决定获胜者。仪式开始前，我们来到观众席外面，与其他队伍见面，祝贺他们取得的成绩，并祝他们好运。我们很幸运能与来自世界各地的创新思维分享世界舞台。休息时间结束了，有影响力的人作为特邀嘉宾被邀请上台宣布获胜者。

来自印度的卡利队在亚洲锦标赛中获得了第一名。他们为哮喘和慢性呼吸道疾病患者创造了一种智能自动抗污染和药物输送口罩。Caeli 实施了一项突破性技术，以改善生活在世界上污染最严重的印度和中国城市的呼吸系统患者的生活质量。

来自中国的 RailinNova 团队被宣布为亚军，因为他们创造了一种技术，通过多传感器融合自动定位和识别各种缺陷来取代工人，从而实现铁路检查过程的自动化，并创造了一种更安全的方法。

来自菲律宾的 AidUSC 队获得了第三极。他们开发了一款名为 Aqua Check 的产品，该产品利用微软 Azure 的定制视觉，通过显微镜拍照来绘制污染物位置，从而分析水样的污染程度。

比赛结束时，我获得了人生中一些最美好的经历，留下了无数珍贵的回忆，并为成为如此伟大的创新思想社区的一员而感到高兴。

The Microsoft Imagine Cup Asia Regional Final 2019 family

比赛评委

蕾切尔·邦迪— 营销&微软澳洲运营总监
凯特·卡鲁泽斯—UNSW 首席数据官，物联网 MAus 创始人
贾斯汀·加勒特— 微软学术生态系统总监
马克·佩斯— 作者，发明家&未来学家
Emily Rich — 微软澳大利亚/新西兰创业公司董事总经理

”最后输赢无所谓。是你旅途中无数宝贵的经历让你成长，成为一个更好的人”

我们离开了礼堂，微软给我们颁发了决赛入围者和赢得印度决赛的证书。他们向当时在场的每个成员分发了一个特别设计的微软礼包，里面装有 t 恤、笔和其他东西。在每个人都要离开之前，一些从新加坡飞来报道这次活动的媒体记者最后一次来到我们这里，向我的团队询问我们进一步推广这个想法的计划。虽然我们之前已经决定，一旦我们到达印度，我们将开始的第一件事是产品创意的专利申请，但最近这一过程仍处于文档阶段。很快，我们离开了国际会议中心大楼，到达酒店，享受这一令人骄傲的时刻。

晚上晚些时候，外面变暗了。我们太累了，从来没有意识到我们睡了这么久。已经是晚上 9 点了，我们已经错过了晚餐。在澳大利亚，大多数食品商店和餐馆 9 点以后就关门了。我打电话给赫曼特，我们离开酒店寻找食物，但在一次不成功的尝试后，我们最终从客房服务订购食物。

微软 Ignite-2019 年澳大利亚悉尼之旅

Saransh Mittal at the Microsoft Ignite Tour at Sydney, Australia

会议日开始了。虽然我对前一天我们被淘汰出在西雅图举行的世界锦标赛感到有点难过。我的父亲是我生命中最有影响力的人，他告诉我这本身就是我生命中最大的成就，是我的胜利，从而激励我重拾信心。他说服我买一部新的 iPhone，因为它以前坏过。我从未想过我会得到这么贵重的礼物作为对我努力工作的回报。由于想买一部新的 iPhone，我搜索了附近最好的商店，找到了 JB Hifi。我穿过分隔达令港和城市的大桥，到达了目的地。在柜台急切地等待机会，买了新手机。我感谢上帝赐予我如此美好的生活。

第四天，微软邀请我们向来自世界各地参加年度 Ignite 大会的 6000 多名企业家、天使投资人和大型 IT 专业人士展示我们的想法。在展览中心，每个创意杯团队都有一个单独的桌子来展示他们的产品，并在会议上展示他们的想法。中心的每个团队都在争夺人民选择奖。幸运的队伍将赢得 1000 美元的现金奖励。每位代表都获得了一张投票票，他们来到由创新杯团队装饰的桌子前，为他们最喜欢的最佳创意投票。

我们在旅途中遇到了很多人，并与他们建立了联系，每当我们的想法在会议上受到人们的赞赏时，我们都为自己的辛勤工作感到自豪。在整个旅程中，我度过的每一刻都让我为自己感到无比自豪，也很幸运有机会成为其中的一员。

The dinner at the Hard Rock Cafe in Sydney, Australia

ignite tour 以 2019 年想象杯的所有学生合作伙伴和决赛选手在晚宴上结束，这是一个特殊的场合，在晚上晚些时候，在达令港美丽的海边景色旁边的硬石咖啡馆庆祝最后一夜的精彩时刻。

所有的车队都聚集在一起庆祝这一时刻，Pablo 向每个人致意，感谢他们作为决赛选手取得的巨大成就，因为在这个星球上很少有人能够幸运地有机会成为顶级梦想家。幸运抽奖比赛的结果已经公布，大约 10 人获得了现金奖。赫曼特是少数赢得 250 美元作为礼物的幸运儿之一。Pablo 召集了我们所有人，并宣布了在 ignite tour 上举行的人民选择奖的获奖者，Suffex 团队赢得了冠军。

食物端上来了，每个人都高兴起来。我们开始讨论我们的经历、想法和其他话题。我们讨论了想象杯项目的团队负责人 Pablo Veramundi，并询问了他对自己所追随的激情的看法。Ansh 和我被他的工作打动了，他周游世界，结识新朋友，体验学生们对单一事业的想法，为团队保存最有价值的记忆，每天面对动态的挑战，并对作为一个人所做的事情保持热情。我希望追求像巴勃罗一样的职业生涯，因为他的激情每天都在激励着他。他是一个非常外向的人，微软的每个人都非常尊重他。

会场上的每个人都有自己独特的鼓舞人心的故事告诉我们，这些故事反映了他们在生活中为成为一个人而奋斗和努力的结果。

Joan Hoshino 是微软的第一批员工之一，当时这家科技巨头还只是一家车库创业公司，她与我们分享了她的故事。她已经为微软工作了 30 年，负责这个科技巨头的销售和市场部门。她曾与比尔·盖茨密切合作，并讲述了萨提亚给公司带来的巨大变化。她来自日本，定居在美国。她未婚，热爱自己的工作。她分享了自己的经历，讲述了“人们在知道她为微软工作后，如何问她关于如何修复某些 windows bug 的技术问题的愚蠢问题”，她来自销售项目。我们进行了一次长谈，她告诉我们她在生活中面临的困难。她给出的最有价值的建议是，永远追求让你对他们充满热情并感到快乐的职业。我们见到了想象杯家庭的整个组织团队，听到他们在生活中的经历，我们感到震惊。

Team Alpha-India and Team RailNova at the Hard Rock Cafe

那天晚上，每个人都互相告别，希望每个人都更加努力，成为更好的自己。在很短的时间内，这已经成为我们的一个小家庭。人们分享电话号码，并承诺彼此保持联系。这是我第一次结交来自世界其他地方的好朋友。

目睹了夜晚的美妙，我们冲出酒店，为无私的努力和真正的友谊庆祝这个夜晚(在房间的四面墙外)。整个晚上过去了，我们漫步在城市的街道上，享受着美丽大都市的夜生活，讨论着关于人、生活和事业的无尽话题，为印度的家人和朋友买了特别的礼物，还有只在这个岛国零售的特别巧克力。我们高兴地回来了，然后就去睡觉了。

宝贵的旅程已经结束，我们被 20 多个媒体网站报道，提到我们团队的成功，赞赏我们创造的产品，称其为一个时代定义的概念。这是我人生中第一次出现在新闻报道中。

Editorial News Publications featuring Team Alpha-India

“再见澳大利亚”——我们在悉尼的最后一天

旅程的最后一天，我们早早起床，计划游览美丽的悉尼和达令港周边地区。这一天从我们退房并把行李交给酒店工作人员开始。我们在酒店的自助餐厅吃了早餐。尽管天气多云，我们还是决定在达令港附近的主要景点逛逛。我们的短途旅行从参观动物园、海底水族馆和杜莎夫人蜡像馆开始。这是一个全国性的节日，每个人都出去和家人一起享受美好的一天。

夜深了，云消失了。我们回到酒店，Ansh 在长途旅行后非常累，决定在累人的飞行前呆在家里放松一下。为了见证这个岛国的真正美丽，我和赫曼特决定去参观我们一生中最美丽的地方——邦迪海滩！如果你去悉尼的话，这是网上最受欢迎的推荐之一。我们预订了一个优步，长途旅行的唯一原因是不要有一种旅行不完整的感觉，而没有经历人们游览澳大利亚的主要原因是因为它的美丽。在那里呆了一个小时左右，然后赶回酒店，因为我们要赶飞机，不得不登上去机场的巴士。

这是一次值得铭记一生的旅行。我们分享的记忆和舞台对我们来说意义重大。我们有过完全失去信心的时刻，但不是我们的想法。我们战斗，努力工作，整晚都被笑话逗笑，分享回忆，旅程最终以梦想成真而结束。

“这些是我生命中最美好的回忆，我们有着如此惊人的友谊！作为朋友和团队，我们已经走过了漫长的道路。”

Saransh Mittal and Hemant H Kumar at the Bondi beach in Sydney, Australia

“这是梦还是真实的现实。我很高兴我是其中的一部分”

朱莉娅盒子:朱莉娅谷歌实验室

原文：https://towardsdatascience.com/julia-box-google-colab-for-julia-5ed8b5bd9a93?source=collection_archive---------19-----------------------

Julia 是一门伟大的语言，正在统计计算领域崭露头角。朱莉娅实际上是非常常用的生物学家，医学家和化学家；然而，Julia for data-science 虽然还没有大规模使用，却是一个越来越可行的想法。与我们现在使用的主要统计和数据处理语言相比，Julia 当然有优势:

Python、R 和 Scala。

ulia 是一种函数式语言，具有近乎 Python 式的语法，运行速度几乎与 c 语言等通用低级语言一样快。虽然我不想说 Julia 很像 Python，但它确实相似。 Julia 在浮点和大数值计算方面也非常精确，这是 Scala 所欠缺的。R 可能有点复杂:一般来说，R 是伟大的，但在一些方面它落后了。基于 S，R 一直面临着一些有趣的问题，并不是不能解决。另外，R 不像 Python 那样通用。Python 也和 Scala、R 一样优秀，但是它有一个巨大的速度问题，这个问题甚至会导致远程服务器上的管理员终止工作。虽然这通常不是问题，但是 Python 性能是一个完全不同的难题，优化可能会非常繁琐。

这并不是说 Python、R 和 Scala 都不好，它们当然不是。但是很难忽视朱莉娅带来的所有好处。

所有这些将我们带入一个新的讨论:

远程计算

远程计算非常棒，它可以让那些在你的电脑上无法运行的计算完美运行。对于 Pythonic 数据科学家来说，Google Colab 绝对不是一个新概念或新产品。Google Colab 是一款全新的 IPython 笔记本，它有一个虚拟内核作为在 Google 服务器上进行计算的前端。Colab 也是免费的，这使它领先于同类服务。最重要的是，Colab 集成了谷歌，完全没有设置。只要去网站注册，就大功告成了！

Colab 对于 Python 来说太棒了，我发现自己经常使用它，而不是启动笔记本服务器。随着 Julia 用户数量的增长，以及每天发布的越来越多的数据科学包，如果 Julia 采用类似的东西会怎么样？

介绍:朱丽亚博克斯

uliabox 类似于 Colab，但它运行的不是 Python，而是 Julia。就像 Colab 一样，JuliaBox 是免费的。我认为谷歌可以做得更好的是可扩展性。如果只是为了方便起见，购买一个更高级别的 Colab 版本就好了。Juliabox 恰恰具备这一点，而且定价绝对超出公平。

资深数据科学家经常忽略远程笔记本的概念。我们可能会去我们古老的服务器，它配备了 RTX 图形处理器和 32 个核心中央处理器。或者甚至在我们的个人服务器上进行计算。

在我看来，像 Juliabox 或 Google Colab 这样的平台让数据科学变得更容易获得。我经常向我的朋友提问，不管他们是数据科学家还是渴望成为一名数据科学家。令我惊讶的是，几乎没有问题是关于编程的，而是更多的概念。其中一个我有很多疑问的概念是 Jupyter 。

朱庇特？！这相当于询问您的 IDE，而不是您的写作语言。当然，这没有什么错，但这表明这些设置概念对新用户来说相当困难。对于 R、Julia 和 Scala 来说，设置也可能相当漫长。从我的经验来看，Julia 最容易，R 居中，Scala 肯定最难。

因此，提前做好一切准备的远程选择肯定是可取的，而 Juliabox 肯定会为 Julia 带来更多的人。在我最初注意到它之后，我想告诉我所有的朋友，然后意识到我一个朋友也没有；所以我决定与你分享这个了不起的软件！

朱莉娅速度战:合成、递归和迭代循环

原文：https://towardsdatascience.com/julia-speed-battle-syntactual-recursive-and-iterative-loops-ff5f719867c1?source=collection_archive---------20-----------------------

随着我为机器学习模块车床所做的所有写作，以及我在 0.0.4 中实现的新算法，我的思想一直集中在优化上，以真正为快速的机器学习设置标杆。几周前，在做一个时间敏感的项目时，我试图用 Python 从一个巨大的数据集构建一个算法，Jupyter 内核会因为试图读取它而崩溃。另一方面，我想到了我的 Julia 经验，甚至不需要使用 Scala，我就可以很好地读取超过 3500 万次观察的数据集，并且使用 Lathe 最多只需要几秒钟就可以做出预测。这是一个很难理解的概念，与其说我遇到了运行的硬件的限制，不如说我遇到了语言的限制。

这让我想到了低级算法以及它们在循环形式的计算速度中的位置。经过深思熟虑，我决定测试众所周知的关于处理和语言的计算机科学思想的有效性和严重性，特别是在 Julia 中。我们都知道朱莉娅不遵循任何人的规则，在这方面她确实是一种独特的语言。我有一篇文章在这里关于你在使用它之前应该知道的关于朱莉娅的事情，你可以查看更多信息。

假设

在早期的计算领域，迭代通常被认为是处理和个性化数组中的索引的最快的循环类型。考虑到这一点，由于明显的原因(mb 内存对 gb 内存),许多较老的系统使用递归传输的堆栈比现代计算机少，然而许多 80 年代的遗留语言仍然更适合于在语法循环和递归循环上进行迭代。还应该注意的是，递归经常不被接受，被认为是完成快速任务最慢的方式。至于语法表达式，通常结果完全取决于你的语言及其编译器。

在那个特别的音符上；我将向您介绍 Julia 的(股票)编译器:

提前(AOT)

考虑到 AOT，我们可以假设许多其他编译器和语言作为一个整体可能不会产生相同的结果，甚至可能产生完全不同的结果。我想指出这一点，因为我个人被这个测试的结果带了回来，它真的让我对他们如何能够操纵语言和编译器到如此程度以使 Julia 成为如此甜美的语言感兴趣。我想那是麻省理工学院给你的。

设置我们的测试

我们的数据集将是我在这个项目中使用的数据集，因为它非常大。数据清理后的形状是 864，863 行× 3 列，这对于一个像样的速度测试来说应该足够了。

我将使用线性回归函数作为控制来进行速度测试，唯一要做的更改是循环(最多一行)和循环本身所必需的部分。线性回归的公式为:

y^ = a+(b*x^)哪里

a =(∑y)(∑x)-(∑x)(∑xy))/(n(∑x)-(∑x))

和
b =(x(∑xy)—(∑x)(∑y))/n(∑x)—(∑x)

因此，让我们编写一个简单线性回归函数的迭代版本:

function pred_LinearRegression(x,y,xt)
    # a = ((∑y)(∑x^2)-(∑x)(∑xy)) / (n(∑x^2) - (∑x)^2)
    # b = (x(∑xy) - (∑x)(∑y)) / n(∑x^2) - (∑x)^2
    # Get our Summatations:
    Σx = sum(x)
    Σy = sum(y)
    # dot x and y
    xy = x .* y
    # ∑dot x and y
    Σxy = sum(xy)
    # dotsquare x
    x2 = x .^ 2
    # ∑ dotsquare x
    Σx2 = sum(x2)
    # n = sample size
    n = length(x)
    # Calculate a
    a = (((Σy) * (Σx2)) - ((Σx * (Σxy)))) / ((n * (Σx2))-(Σx^2))
    # Calculate b
    b = ((n*(Σxy)) - (Σx * Σy)) / ((n * (Σx2)) - (Σx ^ 2))
    # Empty array:
    ypred = []
    for i in xt
        yp = a+(b*i)
        append!(ypred,yp)
    end
    return(ypred)
end

我们将使用 Julia 的计时器来为我们的预测计时。我认为这将是理想的方式，因为我们可以消除任何中间件，因为我们可以在没有任何额外开销计时器的情况下计算值。

[@time](http://twitter.com/time) pred_LinearRegression(trainX,trainy,testX)

现在我们将对一个递归循环做同样的事情:

function pred_LinearRegression(m,xt)
    # a = ((∑y)(∑x^2)-(∑x)(∑xy)) / (n(∑x^2) - (∑x)^2)
    # b = (x(∑xy) - (∑x)(∑y)) / n(∑x^2) - (∑x)^2
    # Get our Summatations:
    x = m.x
    y = m.y
    Σx = sum(x)
    Σy = sum(y)
    # dot x and y
    xy = x .* y
    # ∑dot x and y
    Σxy = sum(xy)
    # dotsquare x
    x2 = x .^ 2
    # ∑ dotsquare x
    Σx2 = sum(x2)
    # n = sample size
    n = length(x)
    # Calculate a
    a = (((Σy) * (Σx2)) - ((Σx * (Σxy)))) / ((n * (Σx2))-(Σx^2))
    # Calculate b
    b = ((n*(Σxy)) - (Σx * Σy)) / ((n * (Σx2)) - (Σx ^ 2))
    [i = a+(b*i) for i in xt]
    return(xt)
end

实际上:

function pred_LinearRegression(m,xt)
    # a = ((∑y)(∑x^2)-(∑x)(∑xy)) / (n(∑x^2) - (∑x)^2)
    # b = (x(∑xy) - (∑x)(∑y)) / n(∑x^2) - (∑x)^2
    # Get our Summatations:
    x = m.x
    y = m.y
    Σx = sum(x)
    Σy = sum(y)
    # dot x and y
    xy = x .* y
    # ∑dot x and y
    Σxy = sum(xy)
    # dotsquare x
    x2 = x .^ 2
    # ∑ dotsquare x
    Σx2 = sum(x2)
    # n = sample size
    n = length(x)
    # Calculate a
    a = (((Σy) * (Σx2)) - ((Σx * (Σxy)))) / ((n * (Σx2))-(Σx^2))
    # Calculate b
    b = ((n*(Σxy)) - (Σx * Σy)) / ((n * (Σx2)) - (Σx ^ 2))
    f(X) = a.+b.*X
    ypred = f(xt)
    return(ypred)
end

结果

这些结果可能会让你震惊:

平均值为 0.114379399999999999 秒的递归
平均为 0.1685546 秒
平均值为 0.4208722 秒的迭代(用于循环)

迭代是最后一次！？

最重要的是，我认为这确实说明了 Julia 非常适合作为函数式语言。递归是函数式编程的一个奇妙的构建块，并且是开创这一概念的基本算法之一。

有了这些结果，我想最小化任何不受控制的变量，所以我的第一个目标是内存，因为递归非常依赖内存。

如左边的系统监视器所示，我们当然没有处理器速度或内存不足的问题，资源远远没有被过度使用。

因此，我决定做的下一件事是拓宽频谱，看看较慢的运行时间是否对结果有显著影响，为此，我将处理单元的时钟频率降低到 1824 MHz，并将调节器设置为仅允许使用两个内核。这说起来容易做起来难，因为完成所有的数据计算需要相当长的时间(太慢了。)我最初选择单核，但那对我来说太远了，感觉像是在 90 年代等待二十分钟来切换窗口。

这产生了明显更高的速度，但趋势完全继续，这没有对结果产生影响…

速度为. 33 的递归
速度为 0.39 的合成事实
速度为 1.37 的迭代

概观

没错，差异实际上非常显著，考虑到这一点，从现在开始，我一定会尽可能地在 Julia 中使用递归！我不知道这种对速度的渴望来自哪里，但我对朱莉娅轻松处理如此大量数据的能力印象深刻。我真的很喜欢做这些测试，因为结果使我成为一个更好的程序员，可以更有效地操作语言和编译器。希望这对于在 Julia 工作的任何其他数据科学家来说也是非常有益的，我知道从现在开始我肯定会将这些结果应用到我的所有功能中。

七月版:自然语言处理

原文：https://towardsdatascience.com/july-edition-natural-language-processing-272f28835af7?source=collection_archive---------23-----------------------

当我问你当我说“性感、未来的机器学习”时，你会想到什么，你可能会想到人工智能生成的人脸、机器制作的视频游戏，以及在《星际争霸 2》中击败人类的计算机。这些算法当然华而不实，令人印象深刻，但分析单词的机器呢？

来自社交媒体帖子、评论、电子邮件、文本、HTML 页面等的非结构化文本构成了世界数据的巨大块。与此同时，对其他人或对谷歌助手或 Alexa 或 Siri 说的话是我们传达思想、感情和意图的最自然的方式之一。因此，如果我们想建造真正多功能和智能的机器，我们必须让它们理解文本。

在这篇文章中，我们收集了一些我们最喜欢的关于自然语言处理的文章。它们涵盖了机器学习中一些最常见的基于语言的任务，如分类、实体提取和文本生成，以及最流行的 NLP 技术和最新的 ML 开发。尽情享受吧！

戴尔·马科维茨——谷歌的编辑助理/软件开发员

自然语言处理:从基础到使用 RNN 和 LSTM

通过 vibhor nigam — 11 分钟读取

对自然语言处理领域中流行的所有概念的详细介绍。

OpenAI GPT-2:通过可视化理解语言生成

由杰西·维格 — 9 分钟读完

超大的语言模型是如何完成你的想法的。

BERT 解释道:自然语言处理的最先进的语言模型

通过拉尼·霍雷夫 — 7 分钟读取

BERT(来自变压器的双向编码器表示)是谷歌 AI 语言的研究人员最近发表的一篇论文。

超越单词嵌入(第一部分、第二部分、第三部分、第四部分)

由亚伦(阿里)博恩施泰因 — 5 分钟阅读

本系列将回顾使用预训练单词嵌入的优点和缺点，并演示如何将更复杂的语义表示方案(如语义角色标记、抽象意义表示和语义依赖解析)整合到您的应用程序中。

使用自定义实体提取解析结构化文档

戴尔·马科维茨 — 6 分钟阅读

网上有很多很棒的教程，解释如何用机器学习对文本块进行分类。但是，如果你想对单个单词进行分类，而不仅仅是对文本进行分类，该怎么办呢？

评估 NLP: BLEU 中的文本输出，风险自负

雷切尔·塔曼 — 17 分钟阅读

刚进入 NLP 的人经常问我一个问题，当系统的输出是文本，而不是输入文本的某种分类时，如何评估系统。

经办人:图文并茂的注意事项

由莱米·卡里姆 — 12 分钟读完

gif 中的注意力，以及在谷歌翻译这样的机器翻译中是如何使用的。

在没有大数据的情况下应用深度学习进行自然语言处理的经验教训

由 yonatan hadar — 10 分钟阅读

作为一名数据科学家，你最重要的技能之一应该是为你的问题选择正确的建模技术和算法。几个月前，我试图解决一个文本分类问题，即对哪些新闻文章与我的客户相关进行分类。

我们也感谢最近加入我们的所有伟大的新作家，罗伯特·桑德尔，安蒂·普乌拉，威，斯文·巴尔诺扬，托马斯·尚邦，希拉里·西特，丹尼·詹兹，山姆·巴罗斯，凯瑟琳·伊莎贝尔·劳伦斯，索米亚·沙阿迪奥戈·萨，卢卡·德·安杰利斯，伊桑·戴伊，彼得·巴贝尔，乔纳森·刘，阿扬·曲等等很多人。我们邀请你看看他们的简介，看看他们的工作。

使用 nbconvert 跳出 Jupyter 笔记本

原文：https://towardsdatascience.com/jump-out-of-the-jupyter-notebook-with-nbconvert-7d4748960702?source=collection_archive---------4-----------------------

轻松将笔记本转换为 Python 脚本和可共享文件

如果你是一名数据科学家，nbconvert 是一个很好的工具，可以添加到你的工具箱中。使用 nbconvert，您可以从命令行轻松地将 Jupyter 笔记本转换为 Python 脚本。它还可以让你把你的 Jupyter 笔记本变成像。html and.pdf 文件。多酷啊。

Jumping Out of a Jupyter Notebook

nbconvert 是一个开源软件项目，与 Anaconda 捆绑在一起。引用 nbconvert docs 的话，它支持:

以熟悉的格式呈现信息，如 PDF。
发表使用 LaTeX 的研究，为在论文中嵌入笔记本打开了大门。
与工作中不使用笔记本的其他人合作。
使用 HTML 通过网络与许多人分享内容。

本指南自 nbconvert 版本 5.4 起生效。让我们深入研究如何使用它！

安装 nbconvert 和朋友

虽然 nbconvert 是随 Anaconda 一起安装的，但是它也可以与 pip 一起安装。您可以将 Jupyter 笔记本转换为一些文件格式，如 HTML，开箱即用。

然而，如果你想将笔记本转换成 LaTex、PDF、Ascii、reStructuredTExt 或 Markdown，你需要安装 Pandoc 和 LaTeX 。这些软件包的安装信息因您的机器而异，您可以在这里找到。

让我们看看如何从 shell 中运行 nbconvert。

从命令行运行 nbconvert

从您的终端 shell 中，运行jupyter nbconvert --to my_format my_notebook.ipynb。

my_format是转换选项之一。

my_notebook.ipynb是要转换的笔记本文件路径的名称。

信息输出公式

超文本标记语言

用jupyter nbconvert --to html my_notebook.ipynb把你的 Jupyter 笔记本变成漂亮的 HTML。

默认的输出格式是一个格式良好的 HTML 页面。如果你想要一个基本的 HTML 版本，可能对嵌入另一个 HTML 文档有用，那么把--template basic作为参数传递。

让我们看看您可以将笔记本转换成的其他格式。

PDF、降价、重组文本、LaTeX 和 AsciiDoc

尝试这些格式之前，请先安装 LaTeX 和 Pandoc。这里的安装信息是。

分别是pdf、markdown、rst、latex、asciidoc。

LaTeX 文件可以在此处描述的几种不同的报告和文章模板中导出。

选择 Markdown，reStructuredText，LaTeX，ASCII 输出创建一个文件夹。png 图像从您的笔记本电脑的图形。

我刚刚做了一个 PR 将 ASCII 转换添加到文档中，很快这个功能也将被记录下来。

运行一个或多个笔记本

当然，在 Jupyter 笔记本中，你可以通过菜单或者快捷键来运行它。我提到这个特性是因为它作为 Python 脚本的一部分可能很有用。就用--to notebook作为你的论据吧。如果你想尝试这个功能，有几个选项，所以我建议你参考文档。

Reveal.js HTML 幻灯片

用--to slides将笔记本转变成幻灯片听起来很有希望，但这还不是一个平稳的过程。您需要首先手动调整 Jupyter 笔记本电池。您还需要安装 Reveal.js 软件包，或者在放映幻灯片时访问互联网。此外，您需要设置一个服务器来使用幻灯片计时。

我个人现在不会使用幻灯片功能，但它值得在未来重新使用。如果你愿意，这方面还有开发工作要做。😄

接下来让我们看看在程序中运行 nbconvert。

可执行 Python 脚本

从 Jupyter 笔记本轻松转换到 Python 脚本的能力让我对尝试 nbconvert 感到兴奋。你猜怎么着？有用！

jupyter nbconvert --to script my_notebook.ipynb在同一个文件夹中创建 my_notebook.py 。然后你就可以跑python my_notebook.py笑了。😄

要使用这个脚本，您当然需要确保导入的包在您的环境中可用。另外，注意以%、%%或!开头的 Jupyter 魔法命令会让你的脚本停下来，所以你需要删除它们。

将 nbconvert 作为库运行

你可以写一个 Python 程序把 nbconvert 当库用。文档中有一个例子。警告您不完全清楚您需要什么样的文件，如何使用导出器，或者如何编写文件。

我在一个开源项目中使用了 nbconvert，以便轻松地将 Jupyter 笔记本转换为 Python 可执行文件和 HTML 文件。下面是如何使用 NotebookToAll 包用两行代码创建这些文件。

pip install notebooktoall

from notebooktoall.transform import transform_notebooktransform_notebook(ipynb_file=”my_jupyter_notebook.ipynb”, export_list=[“html”, “py”])

我正在完成一个使用 nbconvert 制作 OSS 软件包的经验指南。在这篇文章中，我将向您展示如何用自动化测试和部署特性创建您自己的 Python 包。跟着我，保证你不会错过！

Jupyter 实验室/Jupyter 笔记本内部

如果你不想使用命令行或库或我的小软件包，并且你在 Jupyter 笔记本中，你可以通过查看菜单下载转换后的文件。见下图。

Time to hop

与命令行相比，您失去了一点控制，但它很快。😏

更新 2019 年 2 月 27 日笔记本也可以从 Jupyter 实验室导出。进入文件- >将笔记本导出为… 并选择您的导出格式。

Jump out of your Jupyter Notebook

包装

现在您已经看到了 nbconvert 的基础知识。我希望这篇文章能给你一些在工作中使用它的想法。

如果你觉得这篇文章很有趣，请在你最喜欢的社交媒体渠道上分享，这样其他人也可以找到它！👏

我撰写关于数据科学、Python、Docker 和其他技术主题的文章。如果你对此感兴趣，请点击查看。

感谢阅读！

在 R 中启动数据科学

原文：https://towardsdatascience.com/jump-start-data-science-in-r-e80cd8273165?source=collection_archive---------29-----------------------

The worn-out Sticker on the lid of my MacBook

像许多人一样，我在 4 年前开始了我的数据科学生涯，当时我的数据科学知识和编程经验都很有限。为了让自己跟上进度，我在网上搜索了一个自学专家在线课程。Coursera 上出现的一门课程是约翰霍普金斯大学的数据科学专业。我最终选择这个专业的几个原因是:

它有体面的在线评论和评级。
这是一门基于 R 的课程/专业。
它几乎涵盖了数据科学的所有方面。

老实说，完成这 10 门专业课的整个旅程并不那么简单。我在 2016 年初报名了整个专业，花了差不多两年时间才最终确定下来。主要原因是 Coursera 过去不需要每月订阅，课程可以在两年内慢慢完成，只需一次性预付费用。回想起来，我想如果我在目前的每月订阅计划下，我会更早完成它。反正我是 2018 年初定的全专。这是我的证件:

JHU Data Science Specialization Certificate

这个专业包括 10 门课程。在完成这个专精的旅途中，我尽力使用 Github。我所有的作业和项目代码都存储在这个库中。在这篇文章中，我将简要回顾每门课程，我希望你能从中获得一些见解。

课程 1:数据科学家工具箱

选择正确的工具集是至关重要的，这通常会使您的工作效率提高一倍甚至两倍。当我刚开始使用 R 时，我没有做太多的研究，在找到 Rstudio 之前，在 Linux 环境中使用了相当长一段时间的命令行 R。课程 1 涵盖了基于 R 的数据科学工作所需的大部分工具。他们是

RStudio:R 最流行的 IDE。我应该说如果没有 R studio，R 不可能如此流行。Rstudio 不断集成函数，让 R 编程变得更加简单快捷。自动完成、热键、RStudio 项目等等。喜欢 Rstudio 的理由太多了。
Git :最流行的版本控制程序。RStudio 为基本用途提供了非常好的 git 集成。不过最好了解更高级的 git 函数，比如 merge，rebase 等。
Rmarkdown:r 中的一体化报表工具，可以使用 Rmarkdown 创建幻灯片、笔记本、学术论文、互动网站等。

课程 2: R 编程

了解 R 的工作原理非常重要。课程 2 涵盖了 R 编程的基础知识。除了数据结构、流程控制、函数等常规编程主题之外。，本课程中还有一些其他有趣的主题:

作用域规则 : R 使用词法作用域。用简单的语言来说，在定义函数的同一层或更高层创建的变量可以被该函数使用。当我第一次开始开发 R 包时，我想减少函数参数的数量，犯了一个错误，天真地假设在函数 A 中计算的一个变量对在 A 体内调用的函数 B 是可用的。
Xapply 函数族 : R 如果尽可能多地使用向量运算，效率最高。其他语言使用循环可能仍然是最有效的。我不是 Xapply 函数家族的粉丝，也很少使用它们。在我个人看来，这看起来像是元素思维和矢量思维的折衷。它既不像循环那样灵活，也不像向量运算那样快速。

正如我说过的，这门课是 R 编程的一个很好的起点。如果你想学习更多关于 R 编程的知识，我强烈推荐 Hadley Wickham 的《高级 R 编程》一书。

课程 3:获取和清理数据

本课程基本分为两个部分:

获取数据:关于如何从文件、API 和数据库中本地和远程获取数据。很标准，没什么刺激的。
清理数据:是关于数据操作，也是一个重要的概念，叫做“整洁”的数据。

数据操作:本课程主要介绍操作数据的基本方法和dplyr方法，但是，我强烈推荐使用data.table方法操作数据。操作数据要比前两种方式快得多。我也着迷于data.table的语法是多么的简单和简洁。绝对值得一探究竟。
整齐的数据:整齐数据的思想被用在很多 R 包中，比如ggplot2，并且被用在数据库表设计中以获得可伸缩性。如果数据已经是一种整齐的格式，你会发现处理起来容易得多。一定要看看哈德利·韦翰的论文《整洁的数据》。我向你保证，花 30 分钟通读这篇文章将使你成为一名更好的数据科学家。

课程 4:探索性数据分析

这门课程是关于探索性数据分析，又名 EDA。对我来说，EDA 90%是关于数据可视化的。数据可视化对于发现异常值、偏斜度、相关性等非常有用。一般来说，做 EDA 之后，即使没有任何建模工作，你也应该能形成一些基本的假设。然而，在整个数据科学工作流程中，应该在 EDA 上投入多少精力是有争议的。根据我的个人经验，我并没有在 EDA 上投入太多精力，原因如下:

EDA 不是模型构建的先决条件。即使你有一个完整的 EDA，有漂亮的图表，对每个特性的分布有一个基本的概念，以及多个特性是如何相互关联的，最终，你仍然需要建立一个基于数据的预测模型。如果预测模型工作正常，它应该证实 EDA 已经显示了什么。
EDA 没有标准的程序。与模型构建不同，几乎没有人人都应该遵循的理论和标准程序，这是我最害怕的。
数据可视化有其自身的局限性。在单个图表上只能显示有限数量的要素。使用可视化不太可能同时发现多个特征之间的复杂关系，因此我们依赖复杂的建模技术来找出。

虽然我不是 EDA 的粉丝，但它仍然是商业智能、报告和仪表板等方面非常重要的工具。

课程 5:可重复的研究

个人认为这门课除了介绍 R markdown 之外，没有太大的价值。如题所示，这门课程可能是由学术研究活动激发的。对于行业中的大多数数据科学家来说，从本课程中学到的是，您应该将您的数据分析写在某种类型的报告中，然后其他人可以共享和复制这些报告。为此，R 中最好的方法之一是将您的数据分析、模型构建和思考过程简化为 Rmarkdown，而使用 Python 的对应方法是 Jupyter notebook。

目前，我使用 R notebook(仍然基于 R markdown)的次数比原来的 R markdown 多得多，因为 R notebook 总是被缓存起来以便快速预览。

课程 6:统计推断

这对我来说是最难的课程，在整个专业中，我的分数最低。我想大多数学生都会同意我的观点。老实说，到今天为止，我在统计推断方面仍然不太流利和舒服。在本课程中，您将会遇到一些重要而实用的概念

P 值。当人们谈论统计显著性时，这是最重要的概念之一。我问几乎所有候选人 P 值的定义，如果他们申请的是数据科学或分析相关的职位。
假设检验。我应该说测试是任何数据驱动型公司中最重要的概念之一。流行的 AB 测试就属于这一类。严格地说，在公司正式推出任何新产品之前，我们应该选择一个客户子集，进行假设检验，收集数据，并确认感兴趣的指标的改善，如转化率、流失、终身价值等。

课程 7:回归模型

线性回归很可能是每个机器学习或数据科学入门课程或书籍谈论的第一个回归模型。尽管线性回归看起来非常简单明了，但其中有相当多的技术细节。本课程致力于广义线性模型，并很好地涵盖了这些技术细节。以下几个概念值得多加关注。

回归系数的解释。当涉及到多元线性回归时，这一点尤为重要。自变量的系数是在其他因变量保持不变的情况下，因变量对自变量的敏感度。当一些独立变量以某种方式相关时，即相互依赖时，独立性假设被违反，它们的回归系数可能显示与直觉相反的值，这是所谓多重共线性的结果。
型号选择。本课程介绍了传统的模型选择方法，即基于 AIC 或 BIC 的向后、向前和两者。在实践中，我几乎总是使用带有 LASSO 的广义线性模型来执行带有 n 重交叉验证的模型选择。对我来说，它更直观，更容易理解。
逻辑回归。在实践中，我发现逻辑回归是我最常用的分类模型之一，尤其是在模型开发的早期阶段。逻辑回归作为一种广义线性模型，训练速度快，解释性强。

课程 8:实用机器学习

如果你对从事机器学习职业很认真的话，这门课是最重要的课程之一。这门课程涵盖了许多实用的技术和细节。我不知道在这门课程中哪个部分更重要，因为我认为每个主题都同等重要，你可能会在以后的机器学习生涯中遇到它们。

本课程介绍 caret 包，这是一个多合一的机器学习包。该软件包适用于数据量较小的问题。然而，caret 的执行速度相当慢，文档也很糟糕。我认为 caret 包有点过时，而且很少维护。实际上，我大部分时间都在使用 H2O R 软件包。我强烈推荐 H2O 套餐。你会惊讶于它的速度和出色的文档。

课程 9:开发数据产品

我认为成功的数据科学职业生涯的一个重要因素是对业务产生影响。你希望商业利益相关者同意你和他们的认同。要做到这一点，最好的方法之一就是做一个数据产品。它可以是一个 API、一个仪表板、一个自动报告或一个网站等。它们都是影响业务的可扩展产品。本课程介绍了一些你可以用 r。

在我的职业生涯中，最大的数据产品是一个闪亮的交互式仪表盘。与任何商业智能工具不同，Shiny dashboard 的优势在于它是完全交互式的，这意味着您可以通过它执行输入和输出任务。因此，我构建的仪表板可以作为用户的门户。我喜欢构建产品，我相信端到端数据科学家应该能够执行从 ETL 到数据产品的数据任务。

课程 10:数据科学顶点

好的，一旦你完成了这一步，这就是本专业的最后一门课程。老实说，顶点课程中的项目本身并不是那么直接，你需要学习和获取本课程之外的信息。由于学生可能有不同的方法来解决这个问题，所以没有唯一的答案，评分标准也相当宽松。

用线性规划解决难题

原文：https://towardsdatascience.com/jumping-into-puzzle-solving-with-linear-programming-57852609d516?source=collection_archive---------30-----------------------

学习如何在类似数独的数字游戏中使用 Julia 语言制定和解决线性程序

Photo by Austin Neill on Unsplash

线性规划(LP)是一种解决优化问题的强大技术，您将经常看到它被应用于从航班调度、车辆路线到收入管理的问题。在这篇文章中，我想探索一个更异想天开的应用——如何使用线性编程来解决一个难题？

这个谜题类似于数独，所以我将为这个新的脑筋急转弯扩展众所周知的数独 LP 公式。我建议你在继续之前先理解数独解决方案，因为它会有一些类似的逻辑(这里有一个关于它的中型帖子)。

介绍谜题

这个谜题是一个朋友介绍给我的，他推测可以用 LP 解决。这个问题出现在简街拼图上，你可以在这里阅读描述。仅从约束条件来看，它似乎与数独非常相似——对出现次数有约束，但对首次/最后一次出现、值的总和等也有一些其他约束条件。能用 LP 解决吗？答案是肯定的，且看如何。

The first puzzle that I will use for my example

公式化问题

定义变量

在阅读了你的问题并对目标有了深刻的理解后，你应该从定义变量开始。决策会是什么样的？是连续的，整数的，二进制的？它有边界吗？从技术上来说，这是一个约束，但在开始时考虑这一点可能会有所帮助，这样你就不会忘记在以后添加它。

对于这个谜题，决定很简单:给定的单元格中应该放入什么数字？

我的变量名将是 x ，它将是二进制的，它将由三个值索引:

v 是我们正在考虑的从 1 到 7 的数值
r 是从 1 到 7 的行索引
c 是从 1 到 7 的列索引

在数学符号中，这是

由此产生的解将告诉我们哪个数字应该进入哪个单元格。例如，如果解指定 x_{1，1，1}=1，那么这意味着数字 1 进入位置(1，1)的单元格。如果 x_{3，4，7}=0，那么这意味着数字 3 不会进入位置(4，7)的单元格。当我们知道每个数字和单元格组合的所有这些 1 和 0 时，我们就有了解决方案。

这将创建 777 = 343 个二进制变量。对于 LP 问题，二元变量总是比连续值变量更难解决。幸运的是，如今这只是很少的变量，而拥有成千上万个变量的更大的问题可以由如今的解算器来解决。在本地解决这个问题应该没有问题。

定义目标

这个问题很不寻常——没有客观性！将其设置为常数，如 0。我们的目标只是找到一个满足所有约束的解决方案；没有衡量一个解决方案比另一个更好的标准。只要结果可行，我们就已经达到了目标。因此我们不需要目标函数。

定义约束

这就是举重的切入点。让我们一次解决一个。

每个单元格只能包含一个数字，也可以为空。

对于一个给定的单元格，如果 v=1，2，…7 的二进制变量之和等于零，那么我会把它解释为单元格是空白的。我们应该在约束中使用一个不等式来允许这些空单元格，并将阈值上限设置为 1，因为我们不希望每个单元格有多个数字。

每个值 v(不包括空值)出现的次数必须等于值 v。这确保了整个网格中 5 的数量是 5，6 的数量是 6，等等。我们知道这个数的值，因为它等于索引 v ，所以这将是约束的右边。

每行有 4 个数字。同样，每列有 4 个数字。所以只需对所有列(行)和所有可能的值求和。这必须小于 4，因为必须有 4 个数字。

每行数字之和应为 20。此外，每列的总和应为 20。这类似于上面的约束，除了我们需要乘以数字的值， v.

每个 2x2 子正方形必须包含至少一个空单元格。因此，不是每个单元格都可以被填充，所以子正方形中应该有 3 个或更少的数字。

Need to check that each subsquare (yellow region) cannot have at most 3 numbers.

结果应该有一个连通区域。这也意味着一个数字不应该被空值包围。

The question mark should not contain a value if the surrounding cells are empty.

如果我们观察与给定位置相邻的单元格(想象在一个数字周围画一个方框)，就可以实现这一点。如果该区域完全充满了空值，那么该边界的二进制变量之和将为零。在这种情况下，为了满足规则，我们要强制中心数也为空。如果边框中非空值的计数大于零，则允许中间有一个数字。

约束需要根据它们在网格中出现的位置来编写。对于我们可以在单元格周围绘制一个 3x3 框(见下图)的点，将应用以下等式

The equation above applies to these cells.

这个等式被修改以适应网格的剩余区域。例如，对于顶行中的单元格，将针对从 1 到 2 的行修改等式(因为没有 0 行)。

对于第一列和最后一列以及角落中的单元，可以类似地修改等式的其余部分。

行/列的开始应以特定的数字开始/结束。对于第 2 行需要从 3 开始的情况，这意味着第 2 行的第一列可以为空或 3。应用后，如果我们在第 2 行一个接一个地移动，那么一个单元格只能有一个数字，如果它左边的单元格有一个 3。

其余的开始/结束约束遵循类似的公式。

就是这样！这些都是定义问题所需的步骤。干得好，很高兴你还和我在一起。现在，下一步是编写代码。

使用跳转进行线性编程

我在研究生院学习了最优化，在那里 Julia 语言被热情地使用。你需要的软件包是 GLPK 和茱莉亚数学编程(跳转)——这就是本文的标题。这是一个了不起的包裹；编写 LP 问题非常快速、直观，在各种求解器之间切换也很简单。如果你不熟悉 Julia 和 JuMP，那么我强烈建议你去看看。即使不理解语言，代码也应该是可以理解的。我用的是茱莉亚 1.1.1，JuMP 0.19.2，GLPK 0.10.0

using GLPK
using JuMP# Set variable for number of rows/cols/numbers
N = 7function solve_puzzle(start_grid::Array{Int64,2}, edge_constraints::Array{Int64,2})
    model = Model(with_optimizer(GLPK.Optimizer, Presolve=0, OutputFlag=0));
    # Since we don't care about the objective just set it to something arbitrary
    [@objective](http://twitter.com/objective)(model, Min, 0);# Define variables which will be 7x7x7 matrix
    # Use integer instead of binary because I was having trouble fixing Binary values in step below
    [@variable](http://twitter.com/variable)(model, 0 <= x[1:N, 1:N, 1:N] <= 1, integer=true);# Initialize values
    for idx in 1:size(start_grid)[1]
        v = start_grid[idx, 1]
        r = start_grid[idx, 2]
        c = start_grid[idx, 3]
        # Fix value to 1
        fix(x[v, r, c], 1, force=true)
    end# Create the constraints
    # At most one value per cell
    for c in 1:N
        for r in 1:N
            [@constraint](http://twitter.com/constraint)(model, sum(x[v, r, c] for v in 1:N) <= 1)
        end
    end# The number of occurrences of a number should equal the value of that number
    for v in 1:N
      [@constraint](http://twitter.com/constraint)(model, sum(x[v, r, c] for r in 1:N for c in 1:N) == v)
    end# Each row has 4 non-null numbers
    for r in 1:N
      [@constraint](http://twitter.com/constraint)(model, sum(x[v, r, c] for c in 1:N for v in 1:N) == 4)
    end# Each column has 4 non-null numbers
    for c in 1:N
      [@constraint](http://twitter.com/constraint)(model, sum(x[v, r, c] for r in 1:N for v in 1:N) == 4)
    end# Each row numbers sums to 20
    for r in 1:N
      [@constraint](http://twitter.com/constraint)(model, sum(v*x[v, r, c] for c in 1:N for v in 1:N) == 20)
    end     
    # Each column numbers sums to 20
    for c in 1:N
      [@constraint](http://twitter.com/constraint)(model, sum(v*x[v, r, c] for r in 1:N for v in 1:N) == 20)
    end# Every 2x2 subsquare must contain one or more empty square
    for p in 1:(N-1)
        for q in 1:(N-1)
            [@constraint](http://twitter.com/constraint)(model, sum(x[v, r, c] for r in p:(p+1) for c in q:(q+1) for v in 1:N) <= 3)
        end
    end# Connected region = no islands
    for c in 1:N
        for r in 1:N
            [@constraint](http://twitter.com/constraint)(model, 2*sum(x[v, r, c] for v in 1:N) <= sum(x[v, i, j] for v in 1:N for i in (r-1):(r+1) if i in 1:7 for j in (c-1):(c+1) if j in 1:7  ))
        end
    end# Edge constraints                                                                                                     
    val_set = Set(1:N)  # define all possible values
    for idx in 1:size(edge_constraints)[1]
        v = edge_constraints[idx, 1]  # value
        k = edge_constraints[idx, 2]  # affected row/col
        is_col = Bool(edge_constraints[idx, 3])  # row/col
        is_last = Bool(edge_constraints[idx, 4])v_prime = setdiff(Set(1:7), v)for j in 1:(N-1)
            for not_v in v_prime
                if is_col
                    if is_last
                        # last in column k must be v or null
                        fix(x[not_v, 7, k], 0; force=true)
                        # cell is non-null if the values after cell in column have number
                        [@constraint](http://twitter.com/constraint)(model, x[not_v, j, k] <= sum(x[v, r, k] for r in (j+1):N ))
                    else
                        # first in column k must be v or null
                        fix(x[not_v, 1, k], 0; force=true)
                        # cell is non-null if values before cell in column have number
                        [@constraint](http://twitter.com/constraint)(model, x[not_v, j+1, k] <= sum(x[v, r, k] for r in 1:j) )
                    end
                else
                    if is_last
                        # last in row k must be v or null
                        fix(x[not_v, k, 7], 0; force=true)
                        # cell is non-null if values after cell in row have number
                        [@constraint](http://twitter.com/constraint)(model, x[not_v, k, j] <= sum(x[v, k, c] for c in (j+1):N ))
                    else
                        # first col in row k must be v or null
                        fix(x[not_v, k, 1], 0; force=true)
                        # cell is non-null if values before cell in row have number
                        [@constraint](http://twitter.com/constraint)(model, x[not_v, k, j+1] <= sum(x[v, k, c] for c in 1:j) )
                    end
                end
            end
        end
    endoptimize!(model)
    # want to see the code 1                                                                                                                                
    println(termination_status(model)) 
    primal_status(model)# Create results
    results = zeros(N,N)
    for i in 1:N
        vals = reshape(value.(x[i,:,:]), N, N)
        multiplier = ones(N,N)*i
        results += multiplier.*vals
    end
    return results                                                                                                                            
end

要运行它，只需指定边约束和起始网格值，并调用函数。

# Initialize starting values
# column 1 specifies number, column 2 is the row number, column 3 is the column number
values = [7 1 2;
          6 1 3;
          6 2 4;
          6 2 5;
          5 3 1;
          6 4 2;
          4 4 6;
          6 5 7;
          4 6 3;
          7 6 4;
          7 7 5;
          7 7 6]
# Encode the first/end row/col constraints (counter-clockwise)
# column 1 specifies the number
# column 2 specifies the affected row/col
# column 3 has values 0 for row and 1 for col
# column 4 has values 0 for start and 1 for end
start_end_constraints = [3 2 0 0;
                         5 5 0 0;
                         1 7 0 0;
                         7 1 1 1;
                         2 2 1 1;
                         2 6 0 1;
                         4 3 0 1;
                         4 1 0 1;
                         7 7 1 0;
                         5 6 1 0];
results = solve_puzzle(values, start_end_constraints)

对于那些想要解决方案的人:

感谢阅读！我会试着关注评论中的问题。

六月版:概率、统计和机器学习

原文：https://towardsdatascience.com/june-edition-probability-statistics-machine-learning-66a6d3aebc97?source=collection_archive---------17-----------------------

每个人都想进入数据科学和分析领域，因为它既有挑战性、迷人又有回报。你必须熟悉数据科学的核心领域，这取决于概率、统计、机器学习算法、可视化等概念。作为一名数据科学家，这些是您的数据科学之旅中必不可少的一部分，这就是为什么您必须学习它们…

有如此多的博客，如此多的视频，如此多的速成课程；很难知道从哪里开始。为了帮助我们的读者，我们为数据科学有志者以及已经在该学科并希望接触基础知识的人收集了七篇惊人的文章，涉及机器学习的各个角度。我们希望这些文章能进一步引导你朝着正确的方向前进。

swap nil Vijay—Scintel Technologies 的编辑助理/数据科学家

对匆忙人群的统计

由凯西·科济尔科夫 — 8 分钟阅读

曾经希望有人能告诉你统计学的意义是什么，术语用简单的英语表达是什么意思吗？让我试着帮你实现这个愿望吧！我将在 8 分钟内快速浏览统计学中所有最重要的观点！或者只有 1 分钟，如果你坚持使用大字体的话。

数据科学家需要了解的 5 个基本统计概念

由乔治·赛义夫 — 9 分钟读完

当执行数据科学(DS)的艺术时，统计学可以是一个强有力的工具。从高层次的角度来看，统计是使用数学对数据进行技术分析。

概率概念解释:最大似然估计

乔尼·布鲁克斯-巴特利特(Jonny Brooks-Bartlett)—8 分钟阅读

在这篇文章中，我将解释什么是参数估计的最大似然法，并通过一个简单的例子来演示这种方法。有些内容需要基本概率概念的知识，如联合概率的定义和事件的独立性。

用 Python 中的贝叶斯模型估计概率

由威尔·科尔森 — 12 分钟阅读

在本文中，我们将探讨在贝叶斯框架中从数据中估计概率的问题，同时学习概率分布、贝叶斯推理和使用 PyMC3 的基本概率编程。

统计学和机器学习的实际区别

马修·斯图尔特博士研究员——15 分钟阅读

不，它们不一样。如果机器学习只是美化了的统计学，那么建筑学只是美化了的沙堡建造。

机器学习算法通俗地说就是 ( 第一部分，第二部分)

由奥黛丽·洛伯菲尔德 — 14 分钟读完

作为熨斗学院数据科学训练营的一名应届毕业生，我收到了大量关于如何在技术面试中胜出的建议。一项不断涌现的软技能是向非技术人员解释复杂的机器学习算法的能力。

统计学是数据科学的语法 ( 第一部分、第二部分、第三部分)

通过 Semi Koen — 4 分钟读取。

统计复习，开启您的数据科学之旅

我们也感谢最近加入我们的所有伟大的新作家，姚洋，马特·赫戈特，本·曼，克莱尔·吉诺，佩里·约翰逊，尼古拉·奥斯卡尔科夫，维克拉姆·德瓦塔，豪尔赫·卡斯特尼翁博士，亚当·迪克，乔治布兰登林、拉什米马尔加尼、扬恩弗恩滕、舒巴姆提瓦里、约翰·默里、萨利姆切拉尔、马丁米尔莫尔、贾科莫维亚内洛等众多。我们邀请你看看他们的简介，看看他们的工作。

初级数据科学—选择您的第一份工作

原文：https://towardsdatascience.com/junior-data-science-choosing-your-first-job-4f74750982dc?source=collection_archive---------26-----------------------

当您选择第一份数据科学工作时，有几个陷阱可以很容易避免

虽然有许多人想成为数据科学家并在寻找他们的第一个职位，但初级数据科学职位很少。数据科学职位的范围从非常面向研究的公司职位(也在科学会议上发表论文，这种情况非常罕见)到更需要动手并涉及大量编码的职位。(初级)数据科学家也来自不同的背景:刚毕业的人(不同领域的 bsc、msc 和 PhD)，有经验的开发人员，他们想学习新的技能，接受再培训等等。

虽然初级数据科学职位很少，但做出准确选择并避免常见陷阱很重要。该帖子是由 Ori Cohen 针对招聘方的帖子“T2 数据科学招聘-为什么你可能做错了”引发的。这篇文章是给正在寻找第一份工作的数据科学家的。这里有一些见解。

不要做公司里的第一个数据科学家

这听起来像是一个非常性感的职位——你刚从大学毕业，你的技能能够给一家小公司留下深刻印象。他们让你成为公司里的第一个数据科学家，嘣！您将能够以正确的方式塑造方法、流程和工具，就像您一直想象的那样！

״In 的理论、理论和实践都是一样的。实际上，他们是 not״ ( 本杰明·布鲁斯特)。

许多实际任务不像教科书或吴恩达的课程那样。您很可能需要一位经验丰富的数据科学家的指导和建议，她已经犯了错误，熟悉数据和产品的限制条件，而且经验丰富。你想学习的技能会随着时间的推移而变化，但总有人在你身边，你可以从中学习，这总是一个好主意。

另一个问题是，小公司通常只有很少的数据，通常不足以训练模型，数据质量也可能是一个问题。这将需要对产品进行变更，并对其进行定义和实施。作为一名初级数据科学家，要完成这种变化所需的技术和政治工作可能很复杂。

您如何知道您正在面试第一个数据科学职位:

您将被如此明确地告知——“您将成为我们的第一位数据科学家”
你的面试官都不是数据科学家，他们问的问题没有反映出对这个话题的深刻理解。

人们不会辞职——他们会辞掉老板

在辞职之前——人们为老板工作。

面试是双方面的。公司面试你，你也面试公司。产品让你兴奋吗？你认为这家公司有适合你的价值观和文化吗？你愿意为这位经理工作吗？

你很可能会与你的经理和队友密切合作。他们打动你了吗？你会重视他们的反馈吗？

为了学习和提高，需要大量的反馈和沟通，尤其是在初级职位的时候。有规律的 1:1 吗？有登机计划吗？他们是否参加会议\是否有教育预算？这家公司有你想要的工作生活平衡吗？

在面试中，面试官可能想取悦你，所以如果你直接问这些问题，他们可能会回答你希望听到的问题。与队友和公司的其他同事交谈可以让你对团队和公司有更多的了解。

工具和技术

如果你主要关注研究，你可能会发现这一点是次要的。然而，对于你的下一个职位，可能需要实践经验。一定要选择一个使用合理技术的地方，而不是一个利基，深奥的技术。例如使用汇编进行机器学习，在大型机环境下工作等。

数据科学家目前合理的技术栈包括:python(也许是 scala，也许是 R 取决于你的风险厌恶程度)和科学 python 包(pandas、numpy、scipy 等)，云环境，某种数据库(postgres \ MySQL \ elastic search \ MongoDB)。

最后但同样重要的是——选择一些你热爱的事情，这样你会很高兴早上去上班，晚上梦见你的代码:)

特别感谢利亚德·波拉克和艾迪·科恩让这段文字变得可读

Jupyter 是新的 Excel

原文：https://towardsdatascience.com/jupyter-is-the-new-excel-a7a22f2fc13a?source=collection_archive---------1-----------------------

为什么交易者和金融专业人士需要学习 Python

如果你是一名交易员或者在金融服务行业工作，Excel 就是你的面包和黄油。你可以分析价格和其他分笔成交点数据，评估你的交易组合，计算风险值，进行回溯测试，等等。你是数据透视表、公式、图表甚至 VBA 和 PowerQuery 的专家。你可以快速处理一个解决方案，但是在你意识到之前，你的电子表格会扩展成几十个标签、几千行和意大利面条 VBA——所以它的可读性和可维护性已经荡然无存。当你敢按 F9 键刷新结果时，你可以拿一杯茶，然后再等一会儿(如果你的电脑在这期间没有崩溃的话)！

👉🏻 听起来熟悉吗？ 你大概正在狂热地点头。

尽管电子表格很有用，但它不能提供你所寻求的所有答案。让我们看看是什么让 Excel 如此受欢迎，它在哪些地方出了问题，但最重要的是，为什么𝕐𝕆𝕌应该开始使用 Jupyter 笔记本作为一种替代的强大的分析工具。

超越天堂

一些因素使得 Excel 如此有价值，最值得注意的是它简单而强大的反应式计算模型和内置函数。电子表格就像一块空白画布，“业余程序员”可以在上面使用 Excel 的专有语言(如公式和 VBA)编写代码。

银行部署了广泛的 IT 系统来运行业务关键流程，但是电子表格形式的影子 IT 出现了爆炸式增长，它们补充了这些核心系统，并作为新业务计划的默认工具。由于企业系统不像动态财务环境中所要求的那样灵活以适应快速上市，Excel 的出现填补了这一空白！虽然这种方法很方便，但它是正确的吗？

Excel 在企业中的角色需要重新定义！

Excel 地狱

试图使用电子表格对大量数据进行高级、快速的分析，是使用了错误的工具。

以下是 Excel 高级用户面临的一些问题:

级联错误 : Excel 臭名昭著的错误是沿着一列向下传播，然后穿过整个电子表格，形成一个雪球，变成雪崩式的麻烦。可怕的是，有些人看不见，直到为时已晚。已经有几个案例被公之于众，在这些案例中，事情出了差错，产生了巨大的成本影响。
可伸缩性 : Excel 对它可以容纳的行数和列数有一个限制，但是随着数据集以指数速度增长，电子表格很快就会耗尽内存或占用大部分 CPU。当这种情况发生时，数据损坏的风险就会大大增加。
性能:在复杂的工作簿中，改变一个数字会影响数百次重复计算，Excel 需要时间来解决每个问题。当达到一定大小时，它不仅会降低电子表格本身的速度，还会影响任何其他需要内存空间的应用程序的性能。
测试:测试一个电子表格的正确性，然后证明后续的修改没有破坏其他任何东西，这几乎是不可能的。
可追溯性/调试:通常一个很小的变化都会严重破坏您复杂的公式，使其极难识别和修复。
全包:数据和计算都包含在 Excel 文件中，从本地计算机运行。这意味着协作受到约束，使版本控制成为一场噩梦。此外，数据是基于最新刷新的静态数据，而不是随着条件的变化而实时更新。

所有这些问题在几十年前就已经被传统软件解决了。

最后但同样重要的是:

运营风险:所有电子表格都是从小型/快速修复计算开始，但有些会转变为永久性的企业级解决方案。它们为许多业务流程提供支持，但由于缺乏对整个环境谱系的了解，许多财务、运营和监管流程的完整性受到了威胁。这是我目前工作的热门话题。如果你想了解更多关于终端用户计算(EUC)风险的信息，这是一篇非常好的文章。

Courtesy: Pixabay

各位编码员好；再见交易者

传统上，银行将量化交易团队分为量化交易员和量化开发人员。前者想出交易的点子，后者把这些点子转化成可执行的代码。当作为一名交易员，你也是一名熟练的编码员，这种分离就不再需要了，这给了你一个竞争优势:不仅银行希望优化他们的成本，因此你可以在冗余中生存，而且你可以将你自己的交易模型付诸行动，利用这个时间优势为你谋利。能够自动化平凡的任务是如此的解放，事实上编码是如此的有创造性！

这也很大程度上是一代人的事情，因为越来越多的初级交易员已经具备了 uni 的编程技能，所以如果你想保持你的就业能力，你需要参与进来。

如何使用 Python 和 Jupyter 笔记本

——看我做了什么？😄

那么，对于那些发现 Excel 有局限性(如果不是过时的话)的交易员和金融专业人士，解决方案是什么呢？

学习 Python，使用 Jupyter 笔记本作为容器！

计算机编程语言

Python 相当容易学习，并且非常通用，因此在金融界越来越受欢迎。现在，除了 Excel，它还是许多定量角色的先决条件。它没有 C++(或 Java)那么复杂，这意味着:❶的学习曲线没有那么陡峭，❷完成一项任务所需的代码量也少了 1/5 或 1/10。

Python 越来越受欢迎，这从大量的库中可见一斑，这些库支持交易者需要的几乎所有东西:

◽读取、写入、清理、按摩、切片/切块数据
◽数学、统计和时间序列
◽金融分析:交易和量化金融、市场数据分析、股票/衍生品市场分析、彭博社数据访问、执行引擎、回溯测试、风险分析等
◽机器学习管道(例如预测市场价格)
◽绘图和漂亮/交互式可视化
◽ SQL 支持
◽发送电子邮件
◽网络抓取(例如在线获取市场价格)【T19

❗️ 在这里 (非附属)找到一个简明扼要的库 。

朱皮特

同样，Jupyter Notebook 是一个基于网络的计算环境，使您能够创作文档，包括:实时代码、图表、小部件、丰富的叙述性文本(包括链接、等式等)、图片等。更具体地说，您可以:

在浏览器中编辑代码，自动语法高亮、缩进和制表符补全/自检。
从浏览器运行代码，计算结果附在生成它们的代码上。

它们提供了一个全包、自包含的计算记录，因此它们可以代替 Excel 用作实时数据分析平台。

Courtesy: Python for Finance Tutorial

最佳地点

所以你可能会想:

👉🏻我还会使用 Excel 吗？ 当然……

在以下用例中，电子表格仍然是您的最佳选择:
◽️的正确性和准确性并不重要
◽的数据不太大(即不需要可伸缩性)
◽不需要实时更新
◽使用 Excel 作为暂存板来快速组装原型
◽不需要长期维护。

你需要的是一些允许快速开发，验证正确性和可扩展性，同时保持与 Excel 相同的反应模型。而这正是 Jupyter 笔记本所提供的！

不，Excel 没有过时，但是 Jupyter 笔记本是更好的数据分析工具！

尽管我已经明确提到了使用 Python/Jupyter 组合优于 Excel 的一些实质性优势，或者在“Excel 地狱”一节中暗示了它们作为反例，但我还是在这里收集了它们的前 10 个(你看，我确实喜欢列表！):

✔️ 强大的数据操作——它毕竟是数据科学家的工具箱！ ✔️ 高级可视化功能 — 不再有无聊的图表！ ✔️ 更好的用户体验
✔️ 大数据集处理 — 不再死机！ ✔️ 性能管理 — 利用多处理 ✔️ 测试驱动开发 — 思考质量！ ✔️ 开源可访问性——“有它的 lib！” ✔️ 误差溯源
✔️ 更容易自动化
✔️ 自记录——不要低估这个的价值！

从哪里开始

我意识到进入这个领域可能会令人生畏，但是编程不是学习语言的语法，而是使用正确的语言和工具来解决问题:在我们的例子中，是 Python 和 Jupyter。

这里有两个很好的资源可以帮助你开始(非附属):

想 Python : 免费电子书下载
Jupyter 初学者笔记本 : 在线教程。

关键的一点是:

保持相关性！

最后的想法

很难想象没有电子表格的公司世界！

银行开始发现 Python 可以替代 Excel 来处理关键工作负载。巴克莱银行最近因努力教他们的交易员编码而成为头条新闻。我认为你也应该遵循这个范例，你不会失望的！

让 Excel 做 Excel 擅长的事情，把分析和自动化搬到 Python 和 Jupyter 笔记本里。

有一个动态和交互式分析的快乐世界在等着你！

感谢阅读！

我经常在媒体上写关于技术的&数据——如果你想阅读我未来的帖子，请‘关注’我 ！

Jupyter 是新的 Excel(但不是为你的老板)

原文：https://towardsdatascience.com/jupyter-is-the-new-excel-but-not-for-your-boss-d24340ebf314?source=collection_archive---------4-----------------------

最近你可能已经看过 Semi Koen 写的一篇非常有见地的文章，名为 Jupyter 是新的 Excel 。她描述了许多专业人士在面临大量数据分析任务时会立即使用 Excel，但她认为，对于许多“大数据”挑战，使用 Jupyter 笔记本电脑更有意义。

如果你是一名精通 Jupyter 兼容语言的数据科学家，那么你会明白她的意思——你不会想到从 Excel 开始处理大型数据集。

但是你的老板呢？他仍然喜欢 Excel，如果你让他看你的 Jupyter 笔记本，而不是给他看 Excel 电子表格中的简单表格或图表，他会不高兴的。(好吧，你的顶头上司可能也是数据科学家，但产品经理或公司董事长呢？)西装革履的人喜欢把鼠标拖到一列数字上，看看它们在 Excel 的状态栏上加起来是多少。

这篇文章是关于与那些对代码不太熟悉的人分享你的 Jupyter 笔记本的结果。我们将探索可用的解决方案(包括我自己解决问题的尝试)并讨论仍然存在的挑战。

Photo by Campaign Creators on Unsplash

从哪里开始？

让我们说你的辛勤工作分析数据结果在表格中，如熊猫数据帧和图表选择。你和别人分享这些的选择是什么？

根据您的目标受众，有两条明显的主要途径可供您选择:

导出(例如，您可以通过电子邮件发送的单独的 PDF 或 Excel 电子表格)
托管(一些易于阅读的笔记本版本，可能已经消毒，但仍具有交互性)

许多选择立即归结于一个简单但令人沮丧的问题:隐藏代码单元的困难。您的管理团队肯定不想看到您用来生成与他们共享的表格和图表的 Python 代码。

隐藏您的代码

这被证明是非常困难的，而且似乎没有任何适用于所有场景的标准方法。

Jupyter 有一个扩展隐藏所有输入，它允许你在 Jupyter 中在可见和隐藏之间切换代码单元，但这不会影响到大多数导出/静态共享解决方案。

一个 StackOverflow 帖子包含了一个建议粘贴在你的笔记本顶部的代码片段，它可以进入 nbviewer(稍后讨论的“静态托管”共享解决方案之一)并导出 HTML，但没有很多导出选项…

当我们讨论共享笔记本的每种可能方式时，我们将回头讨论这个问题。

导出解决方案

首先，让我们看看从任何看起来像托管的 Jupyter 笔记本的东西中取出的最佳方法，并以一个我们可以附加到电子邮件的简单文件结束。

下载为

在你的 Jupyter 笔记本中，查看文件菜单，打开“下载为”查看一些可能的文件格式。

“HTML”选项是在独立文件中准确表示原始笔记本的最佳方式。这也可以通过上面提到的“StackOverflow”代码片段保持代码单元格的隐藏，但不会尊重大多数小部件。在任何情况下，HTML 都不是您的管理层习惯于通过电子邮件接收的格式，甚至可能被安全软件阻止。

PDF 听起来更像。但是这很难直接获得(你需要先安装某种形式的 LaTeX 软件，这可能很麻烦)，而且它不会隐藏你的代码单元。事实上，生成 PDF 的最佳方式可能就是使用浏览器自带的打印功能，要求它输出一个 PDF，显示当前在浏览器中显示的笔记本。这将打包你当时在浏览器中看到的所有内容(所以如果代码单元格通过隐藏所有输入被隐藏，那么这也将反映在 PDF 中)。

心爱的 Excel 电子表格

大多数其他可用的格式是相当技术性的，并不真正适合我们在这里试图实现的。这让我开始了 nb2xls 项目——一个易于安装的额外导出选项，允许你根据笔记本的输出单元格(标准情况下不包括输入代码单元格)获得 Excel 电子表格文件。

最棒的是，表格仍然是电子表格中的表格——您的经理可以将鼠标拖到数字上，查看总数和平均值！图表等图形输出也会出现。我们不需要担心页面大小，因为如果笔记本是长或宽，我们有足够的行和列来填充。

nb2xls screenshot

要安装，只需运行pip install nb2xls，这将在文件菜单中添加一个额外的“下载为”选项:“Excel 电子表格(。xlsx)'。

在编写的时候，这是一个实验性的包——代码仍然需要一些工作来为复杂的表或 markdown 产生最好的结果。请用您自己的笔记本尝试一下，如果有任何需要改进的地方，请联系(请尽可能发送 ipynb 文件示例)。

更多细节和例子在 GitHub 这里。

在命令行上转换

所有这些“下载为”选项实际上只是命令行实用程序nbconvert的包装器，用默认选项调用转换过程。如果您确实需要指定任何转换选项，了解等效命令行可能会有所帮助。

例如， Hide Input All 扩展文档建议使用以下命令来获取一个移除了输入代码单元格的导出 HTML 文件:

jupyter nbconvert --template=nbextensions --to=html my_notebook.ipynb

自己存文件！

“下载为”选项为将笔记本的框架导出到单独的文件提供了一些有用的基础结构。但是值得记住的是，您已经处于自己熟悉的编码环境中，所以直接从代码单元生成一些文件可能是有意义的。

例如，如果你有一个大型熊猫数据帧，最好的办法是将其保存为 CSV 格式，这样你的收件人就可以完整地加载它。类似这样的:df.to_csv('./data.csv')。在实践中，您可能想先将它导入 Excel，这样您就可以设置列的格式并给标题加下划线等。

当你无法逃离朱庇特时

虽然上面的导出选项几乎可以让你以独立的文件格式获得笔记本的关键内容，但有时(尤其是当小部件在你的笔记本中占很大比重时)你需要找到一种方法来坚持使用你现有的 Jupyter 格式。

但是您需要找到一种方法来与您的非开发人员共享它，以便它:

对他们有意义
很容易接近
是安全的，因此敏感数据不会在您的组织之外被看到
是安全的，因此非开发人员不能破坏任何东西或破坏任何数据

本文的其余部分揭示了一些可能的方法。

Jupyter 自己的项目

Jupyter 项目组织有一些辅助项目，如果您需要经常共享笔记本电脑，值得投资一些基础设施，可以考虑这些项目。

两个枢纽

JupyterHub 是一种在共享资源上集中创建 Jupyter 工作空间的方式，因此至少其他用户不需要运行他们自己的 Jupyter 服务器。除非您有一个可以在内部网络上运行 JupyterHub 的小型组织，否则您将需要考虑如何为适当的用户添加身份验证。这里有一些关于如何在不同用户的工作区内共享笔记本的建议。

Logo on the JupyterHub homepage

BinderHub 通过允许用户启动基于特定计算环境(Python 包等)的 Jupyter 工作空间，真正扩展了 JupyterHub，该工作空间是在 git 存储库中定义的，并带有与项目相关的数据文件和笔记本。用户可以通过直接访问单个 URL 来启动工作区。这为你的作品提供了一个更加正式和易于访问的展示平台。要查看名为mybinder.org的 BinderHub 公共实例的示例，请查看 GitHub 上 my nb2xls repo 的自述文件页面上的“启动活页夹”链接。

实际上，这两个项目都不适合我们开箱即用的任务——管理团队不希望必须通过笔记本输入他们的方式！将工作存储在 git repo 或 workspace 中，以便对非开发人员有意义，这是很大的管理开销。

nbviewer

nbviewer 是一个更合适的轻量级服务，可以通过一个 URL 轻松托管笔记本电脑。可以把它想象成上面讨论的 HTML 导出选项的托管网页版本:Javascript 可以工作，但它背后没有活动的内核，所以用户只能在最后一次运行笔记本时看到您的工作结果。

和 Binder 一样，nbviewer 也有一个免费托管版本供您试用。通常，你在 GitHub 上提供一个笔记本的 URL，但是它也可以使用 Dropbox 链接。例如，在 Dropbox 中的 ipynb 文件上“复制 Dropbox 链接”,然后将 URL 粘贴到https://nbviewer.jupyter.org/上的框中。您可以与同事共享生成的查看器页面的 URL，但当然要注意这是不安全的。

nbviewer.jupyter.org homepage

分享一个 URL 比通过电子邮件向你的管理团队发送一个 HTML 文件更自然，但实际上你不会从 nbviewer 中获得太多 HTML 导出无法获得的东西。

因此，到目前为止，Jupyter 项目的主要倡议似乎都没有对我们有多大帮助…

在那里！

Project Jupyter 最近的一项发展可能正是我们正在寻找的东西:瞧，允许你托管一个带有活动内核的笔记本，而不需要任何 shift-enter。默认情况下，代码单元格是隐藏的。默认情况下，来自前端的执行请求是不允许的，所以用户不能破坏任何东西，即使他们尝试！

Jupyter 的博客帖子宣布 voilà 在描述他们试图解决的问题方面做得很好(这正是我们正在讨论的问题！)并解释了一些特性。

voilà logo

在我们讨论的情况下，这可能成为分享您笔记本的一种奇妙方式，但它仍需要大量工作。在撰写本文时，您只能共享一个指向笔记本应用程序的单用户链接，如果多个用户的独立操作扰乱了您的笔记本中的数据流，他们可能会发生冲突。

已经有计划将 voilà与 JupyterHub(如上所述)集成，这将允许多用户访问您的 voilà托管的笔记本电脑。当然，您仍然需要确保每当您的同事选择查看您的笔记本电脑时，voilà服务器都在运行，因此这不是您通常会在本地计算机上运行的内容。

看得更远

Kyso 是一项第三方服务，允许你“记录你的数据科学”。他们的主页上列出了公共笔记本(以及文章、链接、数据集和图表)，这应该会让你对如何在付费计划上共享笔记本有所了解，你可以将协作限制在你的团队内。默认情况下，代码输入单元格是隐藏的！

应该有可能包含实时的 Jupyter 窗口小部件，尽管现在我遇到了一些问题，因为 JupyterLab 还不完全稳定，而且许多 Jupyter 窗口小部件还不适合 JupyterLab。Kyso 目前似乎固定在 JupyterLab 0.35。

如果您认为像这样的第三方服务可能适合您，请联系他们的销售团队了解更多关于功能的详细信息。

Kyso homepage showing some public notebooks

另一项服务， Saturn Cloud 是一个完整的数据科学云托管环境，作为 Google Cloud 或 AWS 等的替代方案，内置了“发布”功能。虽然你的同事可以很容易地发布你的笔记本，但完全保密的发布似乎是不可能的。

我肯定还有其他人。如果您使用了第三方服务来解决这个问题，请在评论中告诉我们。

结论

事实证明，与非开发人员分享我们的 Jupyter 笔记本实验结果比我们希望的要困难得多！我们想要的功能是确保代码是隐藏的，结果是易于访问的，显示是交互式的，我们的数据是安全可靠的。

虽然现在有一些导出功能可用(HTML、pdf、Excel 电子表格)，但在共享复杂数据的情况下，这些都存在挑战或限制。看看更实际的托管选项，我们要么需要实施我们自己的基础架构(例如运行我们自己的 nbviewer 或 voilà实例)，要么将我们的数据科学工作流改造成新的第三方云托管服务。

因此，最佳解决方案将在很大程度上取决于您共享的数据，以及您需要提交类似报告的频率。值得注意的是，在你的整个组织中，各种演示都有一定的模式。对于大数据分析的临时共享，您可能仍然需要从仔细导出的 CSV 组装您自己的电子表格；但是如果这种情况经常发生，可能是时候投资一些可重用的基础设施来解决这个问题了。

朱庇特实验室:朱庇特笔记本的进化

原文：https://towardsdatascience.com/jupyter-lab-evolution-of-the-jupyter-notebook-5297cacde6b?source=collection_archive---------0-----------------------

JupyterLab 概述，Jupyter 笔记本的下一代。

为了给更好的东西让路，所有美好的事情都会结束。

数据显示，Github 上有超过 300 万台 Jupyter 笔记本可供公众使用。私立学校的数量也大致相同。即使没有这些数据，我们也很清楚笔记本电脑在数据科学领域的受欢迎程度。编写代码、检查结果、获得丰富输出的可能性是 Jupyter 笔记本非常受欢迎的一些特性。但是俗话说，天下没有不散的宴席，我们最喜欢的笔记本也是如此。 JupyterLab 最终将取代经典的 Jupyter 笔记本 但为好。

朱庇特实验室

Source

不久前，我发表了一篇关于有效使用经典 Jupyter 笔记本的指南。但是正如我们将看到的， JupyterLab 是 Jupyter 项目的下一代用户界面，提供经典 Jupyter 笔记本的所有熟悉的构建模块(笔记本、终端、文本编辑器、文件浏览器、丰富输出等)。)中一个灵活而更强大的用户界面 。Jupyter 实验室的基本想法是将经典笔记本中的所有构建模块，加上一些新的东西，放在一个屋檐下。

1.装置

JupyterLab 可以使用conda, pip 或 pipenv.安装

**#conda**
conda install -c conda-forge jupyterlab**#pip** pip install jupyterlab**#pipenv**pipenv install jupyterlab
pipenv shell

查看官方安装文档了解更多详情。

启动 JupyterLab

您只需在控制台键入以下命令即可启动 Jupyter:

jupyter lab

JupyterLab 将在浏览器中自动打开，其界面类似于下图。这意味着一切就绪，你可以开始了。

因为我在 Jupyter 实验室同时使用了Python和R，所以我的工作表中有它们的图标。

🔝

2.连接

在使用它的各种功能之前，让我们先了解一下这个接口。

菜单栏

菜单栏有顶级菜单，显示 Jupyter Lab 中可用的各种操作。

左侧栏

这包括常用的选项卡。通过在查看菜单中选择Show Left Sidebar或点击当前侧边栏标签，可以折叠或展开左侧侧边栏。

您可以从 Running面板查看正在运行的会话，而Commands面板允许您搜索所有可用的命令。

主要工作区域

这是实际活动发生的地方。它包括笔记本、文档、控制台、终端等。只需双击或拖动文件到此区域即可开始工作。工作区可以使用命名的工作区 URL 保存在服务器上。

此外，您可以通过将 JupyterLab 的 url 中的lab更改为tree来在经典的笔记本视图和 JupyterLab 视图之间切换。

🔝

3.创建和保存文件

在本节中，我们将快速了解如何在 Jupyter Lab 中处理文件。

创建文件

只需点击主菜单中的+ 图标。这将在主工作区打开一个新的启动器选项卡，使我们能够创建笔记本、控制台、终端或文本编辑器。使用File选项卡也可以实现相同的操作。一旦打开，文件可以被重命名，甚至下载。

打开现有文件

打开文件是一个非常简单的过程。双击它们或通过上方的 File选项卡访问它们。

🔝

这些只是 Jupyter 实验室的基础，基本上是开始。现在让我们继续讨论它的真正功能，以及它优于传统笔记本的原因。

4.灵活的布局

经典的 Jupyter 笔记本也支持内置的文本编辑器和终端，但这些选项很少使用，因为它们大多隐藏在视线之外。另一个原因是，所有这些组件都是作为独立功能工作的，而不是集成的。

Different blocks in a classic Network which worked independently

Jupyter 实验室倾向于通过将所有功能集成到一个单一的交互和协作环境中来填补这一难题。

笔记本

JupyterLab 中使用的笔记本文档格式与经典 Jupyter 笔记本中的相同。现有的笔记本应该可以在 JupyterLab 中正确打开，我们可以在那里进行常规分析。

控制台

有些控制台是为习惯 QT 控制台类型环境的人准备的。这些控制台使我们能够在内核中交互式地运行代码。

文本编辑器

文本编辑器使编辑文件成为可能。文本编辑器包括语法高亮、可配置缩进(制表符或空格)、键映射和基本主题化。这些设置可以在设置菜单中找到。

端子

JupyterLab 终端提供对系统 shell(bash、tsch 等)的全面支持。)和 Windows 上的 PowerShell。我们可以用终端在我们的系统外壳中运行任何东西，包括像 vim 或 emacs 这样的程序。

现在，有人会说，所有这些功能在经典笔记本中都存在，那么是什么让 Jupyter Lab 与众不同呢？事实上，它给了我们一个非常灵活的布局系统，让我们可以选择这些标签，并排拖动它们，并以几乎无限的灵活性调整它们的大小，这是以前所没有的。

🔝

5.增强的笔记本功能

Jupyter lab 不是笔记本格式的重新实现，而是存在于所有现有架构之上的新前端。然而，这种新的前端实现使我们有可能纳入传统笔记本电脑中遗漏的功能。一些功能包括:

展开和折叠单元格

在笔记本中拖放单元格

编辑器中的制表符自动完成

文本编辑器现在具有代码自动完成特性。然而，到目前为止，只有当文本编辑器有一个附加的控制台时，它才被启用。

主题

整个 JupyterLab 和文本编辑器都有可用的主题。

🔝

6.支持的文件格式

Jupyter Lab 还支持其他格式，如:

图片:jpeg，png 等和 gif
杰奥森
Vegalite 文件，geojson 文件，
PDF 文档
高性能 CSV 查看器

Jupyter 实验室基本上可以渲染任意大的 CSV，而这些 CSV 在 Excel 中通常被渲染为无响应。它的交互性还不是很强，但预计很快会有一些改进。

🔝

7.交互式计算

Jupyter 的真正能力在于它支持交互式计算，这在数据科学中尤其有用。

为输出创建新视图

我将使用 Jupyter Github 官方页面上的洛伦兹微分方程笔记本。在运行了几个细胞后，我们得到了交互式洛伦兹吸引子作为输出。有时当我们有一个交互式输出时，不得不上下滚动到生成它的代码，这有点令人沮丧。作为这个问题的解决方案，Jupyter 实验室给了我们一个选项，将输出分成一个新的选项卡，我们有一种伪仪表板，在那里我们可以使用滑块并更改参数。

同一文件上的新视图

有时我们的笔记本太长，所以我们可以在一个实例中有相同(或不同)笔记本的两个视图。当我们想同时查看笔记本的顶部和底部时，这可能会很有用。

在笔记本之间拖放和编辑单元格

我们知道细胞可以在笔记本中拖动。然而，单元格也可以在不同的笔记本上拖动。此外，一个笔记本中的更改也会反映到另一个笔记本中。

简化代码文档过程

正确的说法是代码被读的次数比它被写的次数多。文档是编程的一个非常重要的方面，Jupyter Lab 会让它变得更容易。在 markdown 文件中编写文档时，我真正面临的一个问题是，我必须在不同的控制台中运行代码，以检查它是否运行正常，然后将它包含在文件中。一次又一次地切换标签是很烦人的。

Jupyter Labs 允许您将编辑器和控制台合并到一个视图中。因此，您可以检查代码和文档，同时预览整个文件。

🔝

8.扩展ˌ扩张

JupyterLab 被设计成一个本质上可扩展的环境。扩展是真正强大的工具，可以真正提高一个人的生产力。JupyterLab 扩展是 npm 包(Javascript 开发中的标准包格式)。GitHub 上有许多社区开发的扩展。你可以搜索 GitHub 主题 jupyterlab-extension 来查找扩展。

为了安装 JupyterLab 扩展，您需要安装 Node.js ，可以从他们的网站安装，或者如下所示。

conda install -c conda-forge nodejs
or
brew install node

安装扩展

可以使用以下命令安装新的扩展:

jupyter labextension install <my-extension>

其中，my-extension是 npm 上有效的 JupyterLab 扩展 npm 包的名称。使用my-extension@version语法安装特定版本的扩展，例如:

jupyter labextension install my-extension**@1**.2.3

更多详情，请参考关于扩展的官方文件。让我们来讨论几个我经常使用并且非常强大的扩展:

谷歌驱动扩展

这个扩展在 JupyterLab 的左侧面板添加了一个 Google Drive 文件浏览器。当你登录到你的谷歌账户时，JupyterLab 就可以使用其中存储的文件。

安装

jupyter labextension install @jupyterlab/google-drive

除了安装扩展之外，您还必须向 Google 认证您的 JupyterLab 部署。通过设置文件或此处链接了解流程。您将获得一个客户端 ID，您必须手动输入。

source

用法

现在，如果有人分享一个笔记本或一个 markdown 文件，它会反映在 Jupyter 实验室的shared with me文件夹中。我们可以在那里打开并编辑它。

Github 扩展

这是一个用于访问 GitHub 库的 JupyterLab 扩展。这个扩展允许我们选择 GitHub 组织和用户，浏览他们的存储库，并打开这些存储库中的文件。如果这些文件是笔记本，我们可以像运行任何其他笔记本一样运行它们。

安装

jupyter labextension install @jupyterlab/github

安装后，我们需要从 GitHub 获取凭证。更多详情请阅读此处的说明。

用法

Git 扩展

jupyterlab-git 是一个 jupyterlab 扩展，使用 git 进行版本控制。

安装

要安装，请执行以下步骤:

jupyter labextension install @jupyterlab/git
pip install jupyterlab-git
jupyter serverextension enable --py jupyterlab_git

用途

Drawio 插件

Drawio 插件是一个 Jupyterlab 扩展，用于将 drawio 独立集成到 JupyterLab 中。画。 io 是一款免费的在线图表软件，用于制作流程图、过程图、组织图、UML、ER 和网络图。

安装

jupyter labextension install jupyterlab-drawio

用法

这些扩展确实让 JupyterLab 脱颖而出。在一个工作场所拥有所有的工具非常有用，因为人们不必在不同的环境之间切换来完成工作。除了上面的扩展之外，还有很多其他的扩展，你也可以随意尝试。

🔝

结论

JupyterLab 是真正的下一代基于网络的用户界面。它装载了交互式计算工具和设计良好的界面，允许用户以新颖的方式组合它们。它非常强大，提供了各种强大的工具，使数据分析过程更加顺畅，效率也更高。

Jupyter 笔记本自动完成

原文：https://towardsdatascience.com/jupyter-notebook-autocompletion-f291008c66c?source=collection_archive---------5-----------------------

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

大多数程序员都非常熟悉不同的自动完成工具。然而，我注意到许多数据科学家不使用它，至少在他们的职业生涯或教育中不够早。如果你是他们中的一员，是时候开始使用这个生产力工具了

什么是自动完成？

它是由您的编程环境提供的功能，用于完成您正在编写的代码。对于大多数程序员来说，这是一件幸事，如果你现在开始使用它，你也一样。这些只是使用自动完成的几个优点:

节省时间 g .你再也不用输入这么长的变量了！
更少的虫子。那么你的代码因为变量输入错误而没有运行了多少次。然后当你改正它的时候，你发现同样的错别字在另一行。在调试代码时，只需要 30 分钟就能发现所有的小错别字。不再是了，欢迎自动完成。
快速查找对象方法和属性。您可以使用 autocomplete 来查看对象的方法和属性，而无需查看文档。

Jupyter 笔记本自动补全

如何使用 Jupyter 笔记本自动完成功能？好消息是:你不需要安装任何东西，因为它带有标准的 jupyter 笔记本设置。

要开始使用自动完成功能，你必须开始输入你的变量名，然后按下键盘上的 tab 键。当您这样做时，带有完整的建议变量名的框将会出现，就像下面的截图一样:

在上面的例子中，我输入了‘my _ va’并点击了 tab 键。自动完成功能建议有两个变量名以‘my _ va’开头，我可以使用 my_variable_1 和 my variable_2。如果我输入的前缀只有一个变量，而不是显示下拉选项，自动完成功能会为我输入完整的变量名。

类的自动完成

如果您想创建一个新对象，也可以使用自动完成功能。以下示例显示了“pd”的自动完成功能。Dat ':

[## Jupyter 笔记本键盘快捷键，适合初学者

使用 Jupyter 笔记本编辑器时，了解提高工作效率的最重要的快捷方式。

medium.com](https://medium.com/towards-artificial-intelligence/jupyter-notebook-keyboard-shortcuts-for-beginners-5eef2cb14ce8)

方法和对象属性的自动完成

如果您已经创建了一个对象并将其赋给了某个变量，那么您可以使用自动完成来访问带有类型化前缀的可用方法和参数的列表。正如您在这里看到的，数据帧有几个以字母 d 开头的方法和参数。

模块的自动完成

最后但同样重要的是，您可以使用自动完成功能来导入模块的名称。所以你几乎记得这个有很多很酷的算法的库是如何被调用的，但是不完全记得。您可以使用自动完成功能来帮助您。下面是导入以' ma '开头的模块的建议列表。

结论

我已经在 jupyter notebook 中展示了自动完成的几种用法，我希望我已经说服您开始使用它(如果您还没有这样做的话)。所以从现在开始，没有借口了，你应该在你的代码编写程序中引入自动完成功能。

对于我在这里没有指出的任何事情，你使用自动完成吗？我敢肯定，数据科学家还有其他方式使用它。如果你有建议，请在下面分享。

原载于 about data blog . com:Jupyter 笔记本自动补全，2019 年 10 月 30 日。

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

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

* [## 9 大 Jupyter 笔记本扩展

改进笔记本电脑功能，提高您的工作效率

towardsdatascience.com](/top-9-jupyter-notebook-extensions-7a5d30269bc8) [## Jupyter 笔记本中的 8 大魔法命令

通过学习最有用的命令来提高您的生产力

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

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

towardsdatascience.com](/7-practical-pandas-tips-when-you-start-working-with-the-library-e4a9205eb443)*

Jupyter 笔记本最佳实践

原文：https://towardsdatascience.com/jupyter-notebook-best-practices-f430a6ba8c69?source=collection_archive---------5-----------------------

更有效地使用 Jupyter 笔记本的简明建议。

Photo by SpaceX on Unsplash

警告:本文中的建议指的是 Jupyter 的原始笔记本。虽然许多建议可以适用于 JupyterLab，但流行的笔记本扩展不能。

1.构建您的笔记本

给你的笔记本一个标题 (H1 标题)和一个有意义的序言来描述它的目的和内容。
在 Markdown 单元格中使用标题和文档来构建您的笔记本并解释您的工作流程步骤。记住:你这样做不仅是为了你的同事或你的继任者，也是为了你未来的自己。
toc2 扩展可以在侧边栏(可选的浮动窗口)和 markdown 单元格中自动创建标题编号和目录。突出显示表示您在文档中的当前位置，这将有助于您在长笔记本中保持方向。
可折叠标题 扩展允许您隐藏整个代码段，从而让您专注于当前的工作流程阶段。
这个默认模板扩展导致笔记本不是空的，而是具有默认结构和公共导入。还有，它会反复要求你把名字从Untitled.ipynb改成有意义的。
Jupyter snippets 扩展允许您方便地插入经常需要的代码块，例如您的典型导入语句。

Using a Jupyter notebook template (which sets up default imports and structure) and the Table of Contents (toc2) extension, which automatically numbers headings. The Collapsible Headings extension enables hiding of section contents by clicking the grey triangles next to the headings.

2.将代码重构和外包到模块中

在你已经在单元格中编写了简单的代码以快速前进之后，养成这样的习惯:将稳定的代码转化为 T2 函数，并将它们转移到一个专门的模块中。这使得你的笔记本更具可读性，并且在生产你的工作流程时非常有帮助。这个:

df = pd.read_csv(filename)
df.drop( ...
df.query( ...
df.groupby( ...

变成了这样:

def load_and_preprocess_data(filename):
   """DOCSTRING"""
   # do stuff
   # ...
   return df

最后是这个:

import dataprep
df = dataprep.load_and_preprocess_data(filename)

如果编辑一个模块文件，Jupyter 的自动重新加载扩展重新加载导入的模块:

%load_ext autoreload
%autoreload

使用 ipytest 在笔记本内部进行测试。
使用合适的 IDE ，例如 PyCharm 。了解其高效调试、重构和测试的特性。
坚持好编码的标准 —思考 干净代码原则和 PEP8 。使用有意义的变量名和函数名，合理地注释，模块化你的代码，不要懒得重构。

3.对生产力黑客保持好奇

学习 Jupyter 键盘快捷键 。将清单打印出来，挂在你屏幕旁边的墙上。
了解 Jupyter 扩展: Codefolding ， Hide input all ， Variable Inspector ， Split Cells Notebook， zenmode 和more more。
Jupyter Widgets (滑块、按钮、下拉菜单……)允许你构建交互式 GUI。
tqdm 库提供了一个方便的进度条。

4.拥抱再现性

版本控制:学习使用 git——有很多很棒的教程。
根据您的项目和目的，使用移除笔记本输出的 git 预提交钩子可能是合理的。这将使提交和差异更具可读性，但可能会丢弃输出(绘图等)。)你其实是想储存。
在专用(conda)环境中运行您的笔记本电脑。将requirements.txt文件存储在您的笔记本和模块旁边的 git 存储库中。这将有助于您重现工作流程，并有助于过渡到生产环境。

5.进一步阅读

使用 JupyterLab 笔记本电脑高效工作
为数据科学带来 Jupyter 笔记本电脑的最佳性能
提高您的 Jupyter 笔记本电脑的工作效率
…当然还有乔尔·格鲁著名的我不喜欢笔记本

结论

良好的软件工程实践、构建和记录您的工作流程以及根据您的个人喜好定制 Jupyter 将提高您的笔记本电脑生产力和可持续性。

我很高兴在评论中听到你自己的建议和反馈。

Jupyter 笔记本——忘记 CSV，用 Python 从 DB 获取数据

原文：https://towardsdatascience.com/jupyter-notebook-forget-csv-fetch-data-from-db-with-python-5ef1a56402f2?source=collection_archive---------14-----------------------

从数据库加载训练数据的简单方法

Source: Pixabay

如果你阅读关于机器学习的书籍、文章或博客，它很可能会使用 CSV 文件中的训练数据。CSV 没什么不好，但是大家想想是不是真的实用。直接从数据库中读取数据不是更好吗？通常你不能直接将业务数据输入到 ML 训练中，它需要预处理——改变分类数据，计算新的数据特征，等等。在获取原始业务数据时，使用 SQL 可以非常容易地完成数据准备/转换步骤。直接从数据库中读取数据的另一个优点是，当数据发生变化时，更容易自动化 ML 模型重训练过程。

在这篇文章中，我描述了如何从 Jupyter 笔记本 Python 代码调用 Oracle DB。

第一步

安装 cx_Oracle Python 模块:

python -m pip 安装 cx_Oracle

该模块有助于从 Python 连接到 Oracle DB。

第二步

cx_Oracle 支持从 Python 代码执行 SQL 调用。但是为了能够从 Python 脚本调用远程数据库，我们需要在运行 Python 的机器上安装和配置 Oracle Instant Client 。

如果你用的是 Ubuntu，安装外星人:

sudo apt-get 更新
sudo apt-get 安装外星人

下载 Oracle 即时客户端的 RPM 文件并使用 alien 安装:

alien-I Oracle-instant client 18.3-basiclite-18 . 3 . 0 . 0 . 0–1 . x86 _ 64 . rpm
alien-I Oracle-instant client 18.3-sqlplus-18 . 3 . 0 . 0 . 0–1 . x86 _ 64 . rpm
alien-I Oracle-instant client 18.3-0 . 0 . 0 . 0–1 . x86 _ 64 . rpm

添加环境变量:

导出 ORACLE _ HOME =/usr/lib/ORACLE/18.3/client 64
导出路径=$PATH:$ORACLE_HOME/bin

在这里阅读更多。

第三步

安装神奇的 SQL Python 模块:

pip 安装 jupyter-sql
pip 安装 ipython-sql

安装和配置完成。

对于今天的样本，我使用的是皮马印第安人糖尿病数据库。CSV 数据可以从这里下载。我将 CSV 数据上传到数据库表中，并将通过 SQL 直接在 Jupyter notebook 中获取它。

首先，建立到数据库的连接，然后执行 SQL 查询。查询结果集存储在一个名为 result 的变量中。您看到%%sql 了吗——这个神奇的 sql:

Connecting to Oracle DB and fetching data through SQL query

建立连接时必须指定用户名和密码。为了避免共享密码，请确保从外部源读取密码值(可以是本例中的简单 JSON 文件，也可以是来自 keyring 的更高级的编码令牌)。

这种方法的美妙之处在于，通过 SQL 查询获取的数据是数据框中现成可用的。机器学习工程师可以像通过 CSV 加载数据一样处理数据:

在 GitHub 上可以找到 Jupyter 笔记本的样本。样本凭证 JSON 文件。

Visual Studio 代码中的 Jupyter 笔记本

原文：https://towardsdatascience.com/jupyter-notebook-in-visual-studio-code-3fc21a36fe43?source=collection_archive---------2-----------------------

如何使用 Microsoft Visual Studio 代码作为您的数据科学工具

从事 Python 工作的人，他们喜欢在 Jupyter Notebook 上做研究和实验。我是 Visual Studio Code (VS Code)和 Sublime 之类的桌面 IDE 的粉丝。Visual Studio 代码是用任何语言编程的世界级工具。不仅仅是程序，它还支持很多 DevOps 工具，比如 Ansible、Kubernetes、Yaml 等等。

全球大多数数据科学家使用 Jupyter Notebook 作为机器学习开发、研究和实验的编辑器。Jupyter Notebook 支持 Python，Java，R，Julia，Matlab，Octave，Scheme，Processing，Scala 等等。它是一个编辑器，准确地说是一个为 python 和其他编程语言设计的基于网络的编辑器。以前 Jupyter notebook 被称为 iPython。它是开源的，全球每个人都在使用它。

微软通过安装官方 Python 扩展，正式宣布 Visual Studio 代码原生支持 Jupyter Notebook。

如何在 Visual Studio 代码中使用 Jupyter 笔记本

下载并安装最新版本的 Visual Studio Code IDE【https://code.visualstudio.com/download

在 Visual Studio 中安装 Python 和 IntelliCode 扩展并重启。转到分机部分(左侧菜单)并搜索分机。

注意——以防安装了 Visual Studio 代码编辑器 Python 扩展。您可以通过点击 update 来更新您的旧 Python 扩展。

如何在 Visual Studio 代码中使用 Jupyter 笔记本

在 VS 代码中创建新笔记本:快捷键 CTRL + SHIFT + P (Windows)或 Command + SHIFT + P (macOS)，运行“Python:创建空白新 Jupyter 笔记本”命令。

在 VS 代码中打开已有的笔记本:重启 VS 代码 IDE 后，打开 Jypyter 笔记本文件(。ipynb 文件)。

单击每个单元格左侧的播放按钮，执行单元格中的代码。

当创建或打开 Jupyter 笔记本文件时，默认情况下，VS Code 会自动在本地为您创建一个 Jupyter 服务器。

如果你想使用一个远程 Jupyter 服务器——很简单，通过 VS 代码命令面板使用“指定 Jupyter 服务器 URI”命令，并输入服务器 URI。快捷键 CTRL + SHIFT + P (Windows)或 Command + SHIFT + P (macOS)。

你在 Jupyter Notebook 中使用 python 包的方式，你可以使用你所有的 Python 包，你会得到就地结果(cell result)。例如，我使用了 matplotlib，并像 Jupyter 一样就地获得了图形输出。

在 Visual Studio 代码中调试 Jupyter 笔记本代码:目前，要调试 Jupyter 笔记本，您需要首先将其导出为 Python 文件。一旦导出为 Python 文件，Visual Studio 代码调试器就允许您逐句通过代码、设置断点、检查状态和分析问题。使用调试器是查找和纠正笔记本代码中问题的一种有用方式。

对于整个笔记本，打开命令调板(⇧⌘P)并运行 Python:在 Python 交互式窗口中调试当前文件命令。
对于单个单元格，使用出现在单元格上方的调试单元格装饰。调试器专门从该单元格中的代码开始。默认情况下，调试单元只是进入用户代码。如果你想进入非用户代码，你需要在 Python 扩展设置(⌘,).)中取消选中数据科学:调试我的代码

Visual Studio 代码中最好的特性——超越 Jupyter 笔记本

智能代码自动完成:当你编写代码时，智能感知会在你的代码单元中给出智能代码完成建议。您可以通过安装我们的 IntelliCode 扩展来进一步增强您的编辑器体验，以获得基于您当前代码上下文的智能自动完成建议。

Microsoft

变量浏览器:使用 VS 代码的另一个好处是，您可以通过点击笔记本工具栏中的“变量”按钮来利用变量浏览器和绘图查看器。变量浏览器将帮助您实时跟踪笔记本变量的当前状态，一目了然。

Microsoft

编码快乐！！！

Jupyter 笔记本提示和技巧

原文：https://towardsdatascience.com/jupyter-notebooks-tips-and-tricks-4e995e7b1fd0?source=collection_archive---------25-----------------------

快捷指令

Shift + Enter 运行单元格(代码或降价)。
用于在当前单元格上方插入新单元格的。
b 在当前单元格下插入一个新单元格。
m 将当前单元格改为 Markdown
y 将当前单元格更改为代码。
D + D(两次)删除选中的单元格。

魔法命令

记录单行代码或整个单元的执行时间

# Run the code multiple times and find mean runtime
%timeit CODE_LINE
%%timeit CODE_CELL# Run once and report
%time CODE_LINE
%%time CODE_CELL

使用!前缀运行一个 bash 命令行
%%bash将当前代码单元改为 bash 模式运行，基本上就是在其中编写 bash 命令

%%bashecho "hello from $BASH"

%%js，%% html，%%latex，%%python2，%%python3，...以指定语言或格式运行和呈现代码单元格。
当您不想在执行新代码之前担心重新加载模块时，IPython 扩展非常有用。换句话说，当你改变当前笔记本使用的某个模块中的某些东西时，改变将在你运行新的代码单元时发生，而不必担心任何事情。

%load_ext autoreload
%autoreload 2

jupyter 笔记本中的嵌入式 tensorboard

%load_ext tensorboard%tensorboard --logdir logs/model_training_logs

最后，您可以通过运行%lsmagic列出所有可用的魔术，这将显示当前定义的线条和单元格魔术。

其他的

有时你会有这个内存饥渴的变量，你可以通过设置它为NONE然后强制 gc 运行来回收内存

some_var = None
gc.collect()

使用sudo service jupyter restart来重启 jupyter，因为每隔一段时间 jupyter 就会抛出一个 fit，重启内核不足以让它回到响应状态。
在几乎任何函数、变量、...并运行代码单元来访问它的文档。
[tqdm](https://tqdm.github.io/)在阿拉伯语(塔卡杜姆，تقدّم)中的意思是“进步”,它与 jupyter 笔记本并不相关，但可以用来显示智能进度表。只要用tqdm(iterable)包住任何一个iterable

from tqdm import tqdmfor i in tqdm(range(10000)):
    pass

当您想要计算目录中文件的数量时，可以运行以下命令

!ls DIR_NAME | wc -l

经典笔记本扩展

在jupyter _ contrib _ nb extensions中有很多很棒的扩展。不过你应该用 Jupyter lab 代替。

首先你需要改为jupyter_contrib_nbextensions，然后你可以安装各种有用的扩展。

pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user

这些是我喜欢的:

code _ pretify由 autopep8 支持，非常适合根据 PEP 8 风格指南重新格式化笔记本代码单元格中的代码

pip install autopep8
jupyter nbextension enable code_prettify/autopep8

拼写检查器突出显示减价单元格中拼写错误的单词，这让我避免了一些令人尴尬的错别字。

jupyter nbextension enable spellchecker/main

toggle_all_line_numbers 顾名思义，它增加了一个工具栏按钮来切换是否显示行号

jupyter nbextension enable toggle_all_line_numbers/main

varInspector 非常适合调试 python 和 R 内核。它在一个浮动窗口中显示所有已定义变量的值

jupyter nbextension enable varInspector/main

主题

dunovank/jupyter-themes 有一个我遇到的最好的主题。我试过，然后我停止使用它，因为我一直在转换环境，所以对我来说习惯股票主题是最好的。

pip install jupyterthemes# dark
jt -t onedork -fs 95 -altp -tfs 11 -nfs 115 -cellw 88% -T# light
jt -t grade3 -fs 95 -altp -tfs 11 -nfs 115 -cellw 88% -T# Restore default theme
jt -r

Jupyter 实验室扩展

目前我只使用两个扩展

krassowski/jupyterlab-go-to-definition它允许我使用 Alt + click 通过鼠标跳转到定义，或者使用 Ctrl + Alt + B 键盘。

jupyter labextension install @krassowski/jupyterlab_go_to_definition

krassowski/jupyterlab-LSP增加代码导航+悬停建议+ linters +自动补全的支持。查看他们的支持的语言服务器的完整列表

pip install --pre jupyter-lsp
jupyter labextension install @krassowski/jupyterlab-lspconda install -c conda-forge python-language-server

最后，您需要重新构建 jupyter 实验室应用程序

jupyter lab build

主题

有很多主题，但是我列表中的第一个定制插件不是主题。这是一个顶栏扩展，可以在亮暗主题之间快速切换

jupyter labextension install jupyterlab-topbar-extension jupyterlab-theme-toggle

以下是我最近使用的一些主题

jupyter labextension install @telamonian/theme-darcula
jupyter labextension install @rahlir/theme-gruvbox
jupyter labextension install @kenshohara/theme-nord-extension

分享一下，联系一下，我的 Twitter DMs 开了！

Jupyter Standalone 可能比 Anaconda 更好

原文：https://towardsdatascience.com/jupyter-standalone-might-just-be-better-than-anaconda-53104da05eee?source=collection_archive---------5-----------------------

如果您已经在数据科学领域呆了很长时间，那么您可能非常了解 Anaconda navigator 和 Jupyter notebook。当数据科学家需要在虚拟内核上逐个单元地执行时，它们都是很好的工具。但是有没有可能在不掉落 Jupyter 的情况下掉落 Anaconda Navigator？

康达的优势

Anaconda 的根源是环境虚拟化。当然，与独立的 Jupyter 相比，这可以看作是使用 Anaconda 的一个巨大优势。此外，Anaconda 附带了“conda”包管理器，它不像常规的 Python 包索引那样具有扩展性。

由于这些特性，对于一个没有经验的人来说，Anaconda Navigator 的启动学习曲线不像设置 docker 映像和虚拟环境来运行 Jupyter 那样激烈。然而，Conda 的一个显著缺点是缺乏常规包装索引。因此，只有通过一个相当具有挑战性的漏洞，才可能安装尚未发布到 Conda 的传统 Python 包。对于使用大量 API 和各种包的人来说，这当然是个问题。

考虑到这一点，Anaconda 对于数据科学家来说无疑是一个很好的工具，因为像 VSCode、Spark managers 等扩展应用程序都可以很容易地实现到 navigator 中，以便在 conda 终端中工作，所以很容易理解为什么这是 Windows 开发人员的普遍选择。有趣的是，我的很多 Windows 朋友都把他们的康达 REPL 当成终端来使用，所以它的价值对他们来说是显而易见的。

Jupyter 通过 SH 的优势

但是随着 Anaconda 在 Windows 上的易用性，在我们已经有了一个包管理器和一个终端来推送命令的操作系统上将会出现什么情况呢？嗯，对我个人来说，我更喜欢 Jupyter SH，希望我可以证明我自己对这种方法的支持和反对。

尽管我们失去了 Conda 环境，但我们保留了从终端启动时使用的任何虚拟环境，所以如果我

$ -  source env/bin/activate

然后运行 Jupyter 笔记本，

$ (env) - jupyter notebook

我将保留我的虚拟 env pip 环境。显而易见，这是在 Jupyter 中管理依赖关系生态系统的好方法。

我喜欢使用 Jupyter 而不是 Anaconda 的另一个原因是文件夹选择，任何时候一个笔记本被深埋在你电脑的文件夹迷宫中，在 Jupyter 中打开它都是非常困难的。Jupyter 的文件界面从任何意义上来说都不是完美无缺的，尽管它确实完成了任务。使用带有 SH 的独立 Jupyter，我可以在我电脑的任何位置打开一个终端，输入“Jupyter Notebook”，就可以直接导航到我想要篡改的文件。

我也是一个 Docker 的忠实用户，在 Docker 上使用 Conda 可能是一件很麻烦的事情……然而，用 Docker 在普通 Jupyter SH 上建立一个完全虚拟的操作系统是非常容易的。

最后的想法

尽管这些观点肯定没有得到普遍认同，但我还是独立使用 Jupyter，因为我喜欢它的多功能性。我喜欢 Anaconda，除了不需要它之外，我并不特别愿意安装它。只要你不通过软件包管理器来安装 Jupyter(它会破坏一切),那么你如何安装 Jupyter 并不重要。)

考虑到这一点，我很好奇有多少人在独立版中使用 Jupyter，而不是在 Anaconda 中使用它，他们对这种体验有什么想法。它们都是非常棒的工具，并且说明了有时候有两种完全不同的方法来做完全相同的事情。

jupyter Superpower——与 Python 的交互式可视化组合

原文：https://towardsdatascience.com/jupyter-superpower-interactive-visualization-combo-with-python-ffc0adb37b7b?source=collection_archive---------3-----------------------

简介

牛郎星 是一个交互式可视化库。它提供了更一致的 API。这是作者对图书馆的描述。

Python 的声明性统计可视化库

它的意思是，它专注于要绘制什么而不是如何绘制，你可以像 ggplot 一样轻松组合不同的组件。在进入本库之前，我想快速介绍两个对数据探索有用的工具。你可以很容易地给像 seaborn 或 matplotlib 这样的库添加更多的交互性。在 Github 上查看一些简单的例子，我已经将大部分例子包含在资源库中

ipywidgets
qgrid
牛郎星

Ipywidgets

ipywidgets 允许你用鼠标与 Jupyter Notebook/Lab 交互，它让 Jupyter Notebook 看起来几乎就像一个小应用程序本身。您可以在笔记本中添加切片器、按钮和复选框。这里有一些使用 ipywidgets 的好项目。

https://www.hongkongfp.com/2019/01/21/hong-kong-nurses-protest-overcrowding-lack-resources-public-hospitals-health-chief-booed/

针对香港过度拥挤的医院，我用事故&急诊【A & E】服务等待时间做了一个例子。这里的图显示了医院的平均等待时间，而 ipywidgets 在这里简单地添加了一个下拉菜单，您可以交互地更改图的颜色。

Simple dropdown menu to interact with static plotting library

[## jupyter-widgets/ipyleaflet

Jupyter-fleet . js 桥。在 GitHub 上创建一个帐户，为 jupyter-widgets/ipyleaflet 开发做出贡献。

github.com](https://github.com/jupyter-widgets/ipyleaflet) [## jupyter-widgets/pytreejs

Jupyter - Three.js 桥。在 GitHub 上创建一个帐户，为 jupyter-widgets/pytreejs 的开发做出贡献。

github.com](https://github.com/jupyter-widgets/pythreejs)

qgrid

qgrid 让你在 Jupyter 笔记本/实验室里有一个类似 Excel 的表格，在引擎盖下，它使用 ipywidgets。这是非常有用的，当你试图理解你的数据，而不是输入大量的代码，你可以通过点击排序你的数据，通过点击临时过滤一些数据。简直太棒了！

牛郎星

altair 有一个示例库，演示了您可以制作的各种可视化。

Rich Example Gallery of altair

1.交互式绘图

Upper left: Multiple Selection, Upper right: box style multiple selections, bottom left: single selection, bottom right: mouse hover single selection

牛郎星为交互式绘图提供了很多选择。上面的 gif 给你一种感觉，这有多简单。只需一行代码，您就可以改变图表的行为。交互性对于数据探索是至关重要的，因为您经常想要深入数据的某个子集。交叉过滤等功能在 Excel 或 Tableau 中非常常见。

2.简洁的语法和易于组合的图表

语法有点像ggplot，创建一个图表对象并在其上添加编码/颜色/比例。

如果你使用过 matplotlib ，你可能会多次尝试查找文档。牛郎星充分利用了像+ & |这样的符号，当你想要组合不同的图表时，这些符号非常直观。例如，a|b表示水平叠加图表a和图表b。a+b在图表 a 上平均叠加图表 b。

叠加两个图表的能力非常强大，它允许我们在同一个图表上绘制两个图表，而不需要实际连接它。

这里有一个例子。我从两个不同的数据集创建了两个图表，它们都连接到一个带有医院名称的选择过滤器。你可以在这里找到我的例子。图表 A 按小时显示历史平均等待时间，而图表 B 按小时显示过去 30 天的平均等待时间。

The bottom left chart is created simply using a+b, both chars are controlled by a filter in the upper left bar chart.

3.出口很容易

很多时候你只是想分享一个图表。你只需要做Chart.save()，直接和你的同事分享 HTML。事实上，它只是 JSON 和 HTML，这也意味着您可以轻松地将其与您的 web 前端集成。

如果你想要一个拥有大量数据的复杂仪表板， Tableau 或 Dash (Plotly)之类的工具，Bokeh 在这一点上还是比较好的。我还没有找到用牛郎星处理大数据的好办法。我发现当你试图做不超过 4 个图表的交互式绘图时，它是最有用的，在那里你有一些交叉过滤，下拉菜单或高亮显示。

结论

这些是我最近试图包含在我的工作流程中的库。让我知道你的感受，并分享你使用的工具。我觉得 altair 的交互控件是最有趣的部分，但在功能上还是要赶上其他库，支持更多的图表类型。

我会尝试实验 plotly + Dash 看看是否更好。到目前为止，我一直很喜欢牵牛星的 API，但它可能不太适合生产。运行 altair 数据服务器可能是一个解决方案，但我还没有尝试过。

请给我一个大拇指，如果你认为这些工具是有用的，不要忘记给这些项目的创造者一颗星。

参考

https://www.youtube.com/watch?v=aRxahWy-ul8(这是《牛郎星》作者之一 Brian Granger 的精彩演讲。我认为 altair 不仅仅是一个可视化库，你也可以从它的 API 设计中学到很多东西)

JupyterLab——新一代 Python 数据科学集成开发环境

原文：https://towardsdatascience.com/jupyterlab-a-next-gen-python-data-science-ide-562d216b023d?source=collection_archive---------9-----------------------

一篇将 Python 数据科学家推向 JupyterLab 的文章。

在使用 Python 进行数据科学项目时，您可能会问自己，哪种 IDE 最能满足您在数据探索、清理、准备、建模、评估和部署方面的需求。您可能还在 Google 上做了一些研究，浏览了标题为“顶级 Python 数据科学 IDE”的各种页面，并开始绝望地意识到，没有一个提到的产品为所有必要的实现步骤结合了无缝的外观和感觉。最终，你回到了你所熟知的，但是独立的工具集。好消息是，有一个非常有前途的项目正等待发布 1.0 版本，以解决我们日常的数据科学需求。我指的是 JupyterLab。

A processed image of Jupiter from Juno’s ninth close flyby provided at [13]. NASA / SWRI / MSSS / GERALD EICHSTÄDT / SEÁN DORAN © CC NC SA

为什么是 JupyterLab？

近年来，Python 笔记本作为一种以交互和布局良好的方式显示代码和结果的工具受到了很多关注。这无疑有助于降低开始编程的门槛，并有助于教育，因为输入及其处理后的输出立即显示在浏览器中，这是许多用户非常熟悉的。尽管 Python 笔记本很受欢迎，但需要做的编码越多，经典的 Python IDE 或文本编辑器就越方便。如果有一种工具能取二者之长，从而将两个世界结合起来，那该多好？ JupyterLab 正在通过使用户能够以灵活、集成和可扩展的方式处理文档和活动，如 Jupyter 笔记本、文本编辑器、终端和自定义组件，从而实现这一目标[1]。

Jupyter notebooks 的“Jupyter web 界面的演变”到 JupyterLab 是基于 2015 年进行的用户体验调查，强调了以下三个成功因素[2]:

用户喜欢笔记本体验。
用户想要组合和混合不同的 Jupyter 构建模块。
用户需要轻松协作的能力。

根据我使用 Jupyter 笔记本的经验，这些因素并不奇怪。

优点:

Jupyter 笔记本电脑在可视化功能方面尤为强大。例如，像 Google Facets 这样的工具已经被开发用于 Jupyter 笔记本[3]。

+ 与图形的交互非常方便，例如只需使用%matplotlib notebook或 ipywidgets [4]。

+ 通过将一个单元格从 code 改为 Markdown，可以为一段代码添加一个漂亮简洁的文档。

Jupyter 笔记本是一个非常好的数据讲述和演示工具，因为它可以显示文档和代码输出。

缺点:

- 缺乏内置的变量检查器是有经验的标准 IDE 用户在 Jupyter 笔记本中首先缺少的东西之一。我想强调的是，有一个非常有用的社区贡献的非官方扩展使用了笔记本的元数据[8]。

- Jupyter 笔记本在开发代码时没有提供方便的文件浏览器视图[5]。因此，读写文件变得很笨拙。

- 为了与操作系统的终端交互或使用作为插件添加的终端视图，用户需要在终端命令前加上一个感叹号!。

- 打开和浏览文件很麻烦，因为你需要先加载文件，然后选择合适的方式以编程方式显示它。这比在 IDE 中双击打开例如 jpg 文件需要更多的努力。

- 测试和模块化在 Jupyter 笔记本中很难处理。

- 缺少与版本控制系统的无缝集成，尽管 nbdime 之类的插件使笔记本的区分和合并变得更加容易，这是一个有趣的进步[7]。

- 缺乏方便的可视化调试和剖析功能，尽管有像 pixedebugger[10]这样非常有前途的开发。

我想强调的是，这并不是一份详尽的利弊清单。“缺点”一节中列出的陈述表明所提及的功能根本无法实现。它也被列在缺点下面，以防它在 Jupyter 笔记本中不直观。

让我们看看当前可用的 JupyterLab 版本(0.35.6)的详细信息，看看从 Jupyter 笔记本迁移到 JupyterLab 时会涉及哪些内容。

Python 和 Jupyter 笔记本文件共享一个内核

JupyterLab 让您可以开发复杂的 python 代码以及 Jupyter 笔记本，并轻松地将它们连接到同一个内核。我认为这是解决弊端的一个关键特征。

在下面的动画中，您将看到如何在 JupyterLab 中连接多个 Python 文件和笔记本。

Creation of two Python files and one Jupyter notebook in JupyterLab. Consecutively, you see the selection of one common kernel for each of the files. At the end you can observe that all three files have access to the same kernel as they are using the the variables a and b interactively.

现在来看看下面的动画，它展示了将数据加载到数据框架、单独开发模型，同时利用 Jupyter 笔记本的强大功能以无缝方式测试和可视化模型的简单性。除了拥有一个通用的变量检查器和文件浏览器之外，所有这些都是可能的。这里可以看到一个简单的手动函数逼近任务。

Exploration of the csv file and loading it into a dataframe in a kernel which is shared among the open files. The dataframe is visible in the variable inspector. First the given x and y vectors are plotted in blue. Afterwards, the function approximator plotted in orange is iteratively improved by manually adjusting the function fun in the file model.py. The approximator covers fully the given data input at the end. Therefore, only an orange line is visible anymore.

这有效地分离了提取、建模和可视化，而不必为了共享数据帧而读写文件。这为您的日常工作节省了大量时间，因为它降低了文件加载中的错误风险，并且因为在项目的早期阶段设置 EDA 和试验要快得多。此外，它有助于减少代码行的数量，以防您像我一样向数据管道中添加同样多的asserts。

如果您在项目的相同上下文中需要一个真正快速的终端，那么您只需打开 launchpad 并创建一个新的终端视图。如果要检查模型或算法所需的资源，这尤其有用，如下图所示。

JupyterLab- Ian Rose (UC Berkeley), Chris Colbert (Project Jupyter) at 14:30 shows how to open a terminal within JupyterLab [9].

用 JupyterLab 打开数据文件也很简单。它以一种很好的方式呈现，例如以 csv 文件的表格形式呈现，并且利用了延迟加载，因此使它很快，并且它支持巨大的文件大小。下一个动画展示了如何从 csv 文件中打开虹膜数据集。

JupyterLab- Ian Rose (UC Berkeley), Chris Colbert (Project Jupyter) at 19:15 shows the IRIS data set in a csv file being opened with a simple click [9].

你也可以通过点击打开图像文件，这在处理计算机视觉任务时非常方便。在下面的动画中，你可以看到 Jupyterlab 如何在一个单独的最后使用的面板中渲染哈勃望远镜的图像。

JupyterLab- Ian Rose (UC Berkeley), Chris Colbert (Project Jupyter) at 17:58, shows an image being rendered in by clicking on it in the built in file explorer [9].

此外，您可以通过 JupyterLab 的 Git 扩展导航和使用 Git，如下所示。

Parul Pandey’s gif showing the navigation in the Git extension provided in [6].

在撰写本文时，JupyterLab 中还没有可视化调试和分析功能。目前计划在未来发布[11]。因此，开发将在 1.0 版本发布后最早开始。尽管有这样的计划，在 Jupyterlab [12]中仍有工作要做，以使 PixieDebugger 适用于笔记本电脑。

结论

JupyterLab 为 Jupyter 笔记本电脑添加了一个完整的 IDE，这无疑是 Jupyter 笔记本电脑的一个强大发展。它可以很好地集成到数据科学家的日常工作中，因此也可以被视为下一代工具。数据提取、转换、建模可视化和测试的分离已经非常容易。

考虑到这一点，我希望看到 1.0 版本很快推出。如果你对 JupyterLab 项目感到兴奋，并想自己尝试一下，只需按照 Parul Pandey 的文章中的说明:

[## 朱庇特实验室:朱庇特笔记本的进化

为了给更好的东西让路，所有美好的事情都会结束。

towardsdatascience.com](/jupyter-lab-evolution-of-the-jupyter-notebook-5297cacde6b)

Jupyter 项目，JupyterLab 概述(2018)，https://JupyterLab . readthedocs . io/en/stable/getting _ started/Overview . html

[2] N. Tache，JupyterLab:Jupyter web 界面的演变(2017)，https://www . oreilly . com/ideas/JupyterLab-The-evolution-of-The-Jupyter-web-interface

[3] J. Wexler，Facets:机器学习训练数据的开源可视化工具(2017)，https://ai . Google blog . com/2017/07/Facets-Open-Source-Visualization-Tool . html

[4] 5agado，朱庇特笔记本中的交互可视化(2017)，朱庇特笔记本中的交互可视化

[5] I. Rose 和 G. Nestor，Jupyter lab:Jupyter 笔记本的进化(2018)，https://www.youtube.com/watch?v=NSiPeoDpwuI&feature = youtu . be&t = 254

[6] P. Pandey，Jupyter Lab:Jupyter 笔记本的进化(2019)，https://towardsdatascience . com/Jupyter-Lab-Evolution-of-the-Jupyter-Notebook-5297 cacde 6b

[7] Project Jupyter，Jupyter Notebook Diff and Merge tools(2019)，https://github.com/jupyter/nbdime

[8] Jupyter Contrib Team，Variable Inspector (2019)，https://Jupyter-Contrib-nb extensions . readthe docs . io/en/latest/nb extensions/varInspector/readme . html

[9] I. Rose 和 C. Colbert，Jupyter 项目的 JupyterLab 下一代用户界面(2018 年)，https://www.youtube.com/watch?v=t5q19rz_FNw&feature = youtu . be

[10] D. Taieb，你一直想要的 Jupyter 笔记本的可视化 Python 调试器(2018)，https://medium . com/codait/The-Visual-Python-Debugger-for-Jupyter-Notebooks-youve-Always-Wanted-761713 babc 62

[11]Jupyter 项目，JupyterLab (2019)，https://github . com/Jupyter/roadmap/blob/master/JupyterLab . MD

[12]Jupyter 项目，JupyterLab (2017 年)，https://github.com/jupyterlab/jupyterlab/issues/3049

[13] M. Bartels，美国宇航局发布了来自朱诺任务(2017 年)的令人难以置信的木星新图像宝藏，https://www . Newsweek . com/NASA-Releases-Treasure-Trove-Incredible-New-Images-Jupiter-Its-Juno-Mission-705210

本文旨在通过结合作者的实践经验和深入的文献研究，提供 JupyterLab 可能是 Python 数据科学家的首选 ide 的理由。它不应作为安装指南，也不应作为功能的列表和比较。

复杂 Python 和 Scala Spark 项目的 JupyterLab

原文：https://towardsdatascience.com/jupyterlab-for-complex-python-and-scala-spark-projects-da1aa64fcc12?source=collection_archive---------15-----------------------

JupyterLab 是一项用于原型和自我记录研究的了不起的技术。但是你能把它用于有一个大代码库的项目吗？

外部库的情况

笔记本工作流对全球所有数据科学家来说都是一大进步。能够直接看到每个步骤的结果，而不是一遍又一遍地运行同一个程序，这是一个巨大的生产力提升。此外，自我记录的能力使它很容易与同事分享。

也就是说，你在笔记本上所能实现的是有限的。它最适合交互式计算，但是当每个单元超过 100 行代码时，它就不再是交互式的了。在这一点上，你需要的是一个真正的 IDE，比如 T2 VS 代码，或者 T4 py charm，也许还有一些单元测试。

一个好的库是在你当前项目之外开发的，它应该足够通用，能够在广泛的项目中帮助你和你的同事。把它看作是一项未来会有很多倍回报的投资。

现在，你如何把这个图书馆推回朱庇特？

Python 内核

假设您想要向 Spark 对象添加新的功能，例如 Spark 上的 doSomething()方法和 DataFrame 上的 predict()方法。使用以下代码创建一个模块(Python 中的一个文件，例如 mylib.py ):

mylib_init()使用 setattr()函数来扩展 SparkSession 和 DataFrame 的类定义，并添加新方法。你要做的就是用下面的两行代码创建一个代码块(代码块 4)。首先导入函数“mylib_init()”定义，然后调用它。

小问题是，如果您更改 mylib.py 文件，即使您再次调用 mylib_init()，它也不会更改工作簿中的任何内容。我在这篇文章中发现了关于自动卸载插件的内容。这将允许 Jupyter 每 2 秒检查一次. py 的新版本，您只需要调用 mylib_init()来使用新的模块。

因此，当您使用 pyspark 库在 Jupyter 实例中创建 Spark 驱动程序时，这是一个简单的例子(例如通过使用下面的代码)。

这是最简单的方法，因为它们都在同一台电脑上。当事情变得遥远时，这就有点复杂了(但没那么难)，例如当使用 Sparkmagic 时。

Sparkmagic 内核(Python 和 Scala)

Sparkmagic 内核允许你的 Jupyter 实例通过 Livy 与 Spark 实例通信，Livy 是 Spark 的 REST 服务器。Sparkmagic 会将你的代码块作为 web 请求发送到 Livy 服务器。然后，Livy 会把它翻译成 Spark 驱动程序并返回结果。

正如您在下图中看到的，Spark 驱动程序在集群上是远程的，根本不能访问 Jupyter 实例下的文件。

你如何解决这个问题并使用你的图书馆？

如果您使用 Python，您可以将代码存储在底层 HDFS 上并使用 sc。 addPath (sc 是 Sparkmagic 自动创建的 SparkContext)。由于驱动程序和执行程序都可以访问 HDFS，所以它会起作用。

对于 Scala，我们希望能够在类路径中添加一个或多个 JAR 文件。JAR 是 Java 生态系统中的库。遗憾的是，虽然 SparkContext 上有 addJar，但这种方式行不通。随着 Scala 的编译和类型化，你不能只是在一大块代码中添加 JAR，然后立刻使用这个 JAR 中的类型。addJar 将使这对于执行者成为可能，但是对于驱动程序来说，当调用 addJar 时，不再可能添加类定义。

幸运的是，有一种方法可以在 Livy 创建 SparkContext 时通知它将哪个 JAR 添加到类路径中(在发送任何代码进行编译之前)。

注意，如果已经有一个上下文，这个块将重新启动一个上下文，所以它应该是您笔记本的第一个块。

两全其美

正如我们所看到的，无论您的情况如何，都有一种方法可以利用现有的代码库，只在 Jupyter 笔记本中保留高级的有意义的代码。

我强烈感觉到，高性能数据科学团队的关键是始终在提高生产力的工具上投入时间。共享的高级原语库对生产力至关重要。Jupyter 对此很满意，这是个好消息。

原载于 2019 年 10 月 6 日https://dataintoresults.com。

Jupytext 1.0 亮点

原文：https://towardsdatascience.com/jupytext-1-0-highlights-a49dca9baa7b?source=collection_archive---------14-----------------------

Jupytext 是 Jupyter Notebook 和 JupyterLab 的扩展，可以保存各种文本格式的 Jupyter Notebook:Markdown、R Markdown、Python、Julia 和 R scripts 等等！

A Jupyter Notebook represented as a Python script (light or percent format), Markdown, and R Markdown

Jupytext 将允许您:

在您最喜欢的代码编辑器中编写或编辑 Jupyter 笔记本
在具有清晰差异历史记录的笔记本上启用版本控制
在 Jupyter 笔记本上协作，轻松合并稿件
重构笔记本并将它们的代码提取到库中

使用 Jupytext 的一种便捷方式是通过配对笔记本。配对笔记本是一个传统的.ipynb笔记本，它与一个文本表示同步——比如一个 Python 脚本。保存笔记本后，Jupytext 会更新这两个文件。该脚本有一个清晰的差异历史，只关注输入单元格。

用户可以在代码编辑器中编辑或重构脚本:当在 Jupyter 中读取或刷新笔记本时，将从脚本中读取输入单元格。此外，匹配未更改输入单元格的输出单元格从.ipynb文件重新加载。

Jupytext 于 2018 年 9 月日推出，并受益于社区的大量反馈。我们已经建立了反馈，我们很高兴地宣布 Jupytext 达到了 1.0 版本。

现在让我们回顾一下这个主要版本的主要新特性！

Jupyter 笔记本中的 Jupytext 菜单

Jupytext 获得了一个 Jupyter 笔记本扩展:使用新的 Jupytext 菜单来选择笔记本的配对格式，并在另一个编辑器中编辑文本表示时禁用自动保存功能。

JupyterLab 中的 Jupytext 命令

Jupytext 1.0 还为 JupyterLab 提供了一个扩展:使用新的 Jupytext 命令将您的笔记本与文本文件配对。

一个强大的`jupytext`司令部

jupytext命令可能已经:

转换笔记本--from和--to各种笔记本格式、
--update一个.ipynb笔记本中的输入单元格，给定一个笔记本的文本表示，
使用 Git 预提交钩子维护笔记本的最新文本表示。

在 1.0 版本中，jupytext命令扩展了新的模式:

--sync同步笔记本的多个表示
--set-formats(以及可选的--sync)，设置或更改笔记本或文本文件的配对
--pipe将笔记本的文本表示输入另一个程序。

也许你想用[black](https://github.com/ambv/black)、不妥协的 Python 代码格式化程序重新格式化你的 Jupyter 笔记本？就这么简单jupytext --pipe black *.ipynb！

子文件夹中的配对笔记本

在 Jupytext 的早期版本中，配对的笔记本必须共享同一个目录。在 1.0 版本中，Jupytext 可以将笔记本与不同文件夹中的文本文件配对。

将当前文件夹中的笔记本与带有以下内容的python子文件夹中的 Python 脚本配对:

jupytext --set-formats ipynb,python//py --sync *.ipynb

(使用--sync实际创建 Python 文件；如果您想使用percent格式，请将py替换为py:percent。

将文件夹notebooks中的笔记本与文件夹markdown中的 markdown 文件和文件夹python中的 Python 脚本配对，使用

jupytext --set-formats notebooks//ipynb,markdown//md,python//py --sync notebooks/*.ipynb

关于笔记本前缀和后缀的更多信息可在文档中找到。也可以激活所有笔记本的默认配对。

氢格式

Jupytext 已经可以将 Jupyter 笔记本表示为 light 或 percent scripts。Jupytext 1.0 引入了一种新的hydrogen格式，这将最适合 Hydrogen 编辑器的用户。hydrogen格式与percent格式相同，除了 Jupyter magic 命令，这些命令没有注释。

下面是 Python Hydrogen 笔记本的截图，其中包含许多其他语言——看看 Hydroden 如何呈现多种输出类型！

久经考验的程序

我们已经尽了最大努力确保 Jupytext 能够完美运行。我们的用户和测试人员已经做了很好的工作。对于他们发现的每个 bug，我们增加了测试数据库。

但是你可能想对你自己的笔记本电脑系列进行压力测试？给jupytext --test或jupytext --test-strict一个尝试。

Vim 的插件

感谢迈克尔·戈尔兹，Jupytext 有了一个用于 Vim 的插件。安装插件并编辑以 Markdown 文档或脚本表示的 Jupyter 笔记本。jupytext.vim是另一种非常方便的使用 Jupytext 的方法！

在未来，我们希望为更多的编辑器提供 Jupytext 插件，包括 PyCharm 和 Visual Studio 代码。请让我们知道你是否能在这里提供帮助——一个好的插件只需从jupytext --sync开始！

谢谢你

Jupytext 非常感谢社区的反馈！

对于这个版本，我特别感谢:
-Florian Wetschoreck，Fran ois Wouts和 Amjad Haouriqui，感谢他们在设计 Jupyter 扩展

Philip Austin 时给予的支持，他们提出了将笔记本与其他工具连接的想法，以及将笔记本与不同文件夹中的脚本配对的想法
Michael Goerz ，Andre Thrill

你想帮忙吗？你可以在很多方面做出贡献。我们很乐意了解 bug。欢迎想法！文档的改进也很有帮助。明星让我们保持动力。来加入我们的 GitHub 吧！

诺瓦克·德约科维奇到底有多好？

原文：https://towardsdatascience.com/just-how-good-is-novak-djokovic-401ce07c7ef3?source=collection_archive---------15-----------------------

数据分析师-网球运动员对 2019 年澳大利亚网球公开赛决赛中密谋的事件的分析

今年的澳网决赛是 2012 年诺瓦克·德约科维奇和纳达尔之间的决赛的复赛。2012 年的比赛具备了被认为是游戏史上最伟大的比赛之一的所有要素。这场比赛有各种各样的东西，从长时间的艰苦拉力赛，最高的防守打法，来自另一个星球的制胜一击，以及最高级别的精神勇气的展示。这场比赛为网球场上的痛苦提供了一个新的定义，在颁奖仪式上，球员们几乎无法站立。

Picture Courtesy

2012 年的 AO 决赛是一场相当公平的比赛，直到第五盘，纳达尔在第一盘就击败了德约科维奇，并有望获得例行的五盘胜利。德约科维奇是一个不屈不挠的斗士，他继续对纳达尔的发球局施加压力，并以决定性的方式保持自己的发球局，以保持自己在比赛中的相关性。在第五盘的第六局，纳达尔错过了一次常规的反手击球，这被证明是至关重要的，并使诺瓦克回到了比赛中。(下面的视频链接)

剩下的就是历史了，德约科维奇找到了打破纳达尔发球局的方法，赢得了他的第三个澳网冠军。2019 年澳大利亚网球公开赛决赛预计将是两位传奇人物之间的又一场大战，但没有人会记得这场比赛是一场势均力敌的比赛。德约科维奇在三盘比赛中决定性地击败了纳达尔，这场比赛持续了 2 个多小时，赢得了他的第七个澳大利亚网球公开赛冠军。

纳达尔

要了解德约科维奇在比赛中有多好，重要的是要了解纳达尔在过去两周的表现有多好。纳达尔没有丢掉任何一盘，并在通往决赛的道路上击败了一些著名的选手。事实上，纳达尔看起来像是进入决赛前的状态。

发球

在 11 月接受脚踝手术和职业生涯中多次膝盖受伤后，纳达尔决定调整他的发球动作。修改后的发球动作旨在增加击球的冲击力，帮助纳达尔更具侵略性，缩短得分，以保护他的身体。

Rafael Nadal’s Serve Stats

在三个重要的方面(第一发球百分比，第一发球得分和第二发球得分)，纳达尔似乎在赢得发球得分方面超越了他的职业生涯最佳数据。这使得纳达尔占据了所有发球比赛的 92.6%，这也是职业生涯的新高。除此之外，第一次发球比去年快了 5 英里。发球的有效性帮助他缩短了比赛时间，并自始至终保持领先。

地滚球和截击球

就在几年前，纳达尔以其令人难以置信的回球技巧、从底线后 10 英尺处回球以及多次重新开始得分的能力而闻名。特别是在过去的 3 年里，纳达尔改变了他的战术，在比赛中融入了进攻型打法。这在 2017 年澳大利亚网球公开赛决赛中得到了充分展示，纳达尔与费德勒展开了激烈的进攻。在最近的脚踝手术后，纳达尔缩短了他的后摆，并开始在击球时变得更平。众所周知，纳达尔有一个惊人的截击(看看这个)并且在他的单打比赛中融入这一点后，在过去的几年里，它变得更加强大。这有助于他在进攻中开始得分，并快速完成得分。

统治地位

纳达尔在 2019 年澳大利亚网球公开赛上直落两盘击败澳大利亚选手詹姆斯·杜克沃斯。比分无疑表明纳达尔由于缺乏比赛而生疏，但他的发球在比赛中被破了两次。从第二轮开始，他的发球局真的开始变得有节奏了，他在决赛中一次也没有丢掉发球局。他在半决赛中令人信服地击败了 Stefano Tsitsipas(罗杰·费德勒的攻击者)。

匹克-德约科维奇

德约科维奇的肘部受伤让他的统治地位受到了影响，这让他在 2017 年和 2018 年的大部分时间里都没有参加大满贯比赛，后来他在 2018 年赢得了温布尔登网球公开赛，打破了他的大满贯冠军头衔。虽然球迷们觉得他从伤病中复苏已经完成，但很少有人希望他能像在 2019 年澳大利亚网球公开赛决赛中那样统治比赛。

调整服务动作

在退出 2017 年下半年的比赛后，德约科维奇团队提出了一个肘部更轻的发球动作。肘部受伤使得德约科维奇的发球不稳定，不可靠，缺乏欺负对手的力量。调整后的发球动作似乎没有改变德约科维奇的命运，他不得不在比赛前接受手术，没有任何痛苦。德约科维奇在 2018 赛季前半段展示的发球动作受到了阿加西发球动作的启发。德约科维奇在美国硬地球场夏天解雇了阿加西和斯捷潘内克，并抨击了他的新发球动作。重新雇用 Marian Vajda 看到他的发球大幅提高，回到了 2016 年的水平。我会让数字自己说话。

费德勒和德约科维奇并不以最强有力的发球而闻名，但却以在正确的时间击中正确的位置而闻名。德约科维奇的发球比以往任何时候都更经常地击中正确的位置。他所有的发球中有 8.3%被证明是 ace 球，他在 ace 球方面从来没有做得更好。下一个要检查的统计数据是第一发球的百分比。

德约科维奇的第一次发球命中率是他能够击败纳达尔的原因，这让他在发球比赛中完全没有表现出来。第一次发球火力全开，对他的所有对手来说都是令人恼火的一致。尽管本赛季开局糟糕，输给了排名前 100 名之外的球员，诺瓦克还是在本赛季的后半段将自己的第一次发球得分率提高到了一个可观的数字。

如果你认为发球的准确度和精确度有所提高，那你就错了。当你看看这些数据时，发球的有效性是不可否认的。我们已经确定，首次发球的次数比以往任何时候都多，而且每次发球都比以往任何时候都有更多的回报。他今年赢得了职业生涯最高的第一发球得分，这包括在多哈锦标赛中的惨淡表现。有一句谚语说“你只像你最薄弱的环节一样强大”，这让我们看到了第二次发球，德约科维奇大大提高了第二次发球，比他的职业生涯平均水平高出近 10 个百分点。在过去，特别是 2011 年，德约科维奇的身体习惯于在他的第二次发球被中和后接管，但这在 2019 年应该是不正确的，因为他变得更老了，因此比以前的自己更弱。不可思议的是，他比以往任何时候都更擅长长基线拉力赛，他的触地击球也比以前更有穿透力。

回归游戏

我可以坐一整天，大声谈论诺瓦克过去的回报有多好，但还能更好吗？

诺瓦克赢得的回球点数当然不像 2011 年那样高，当时他连续得分，差点断送了罗杰和拉法的职业生涯。2011 年，他不得不面对纳达尔和费德勒，他们的状态非常好，因此，回报实际上需要那么好。令人惊讶的是，诺瓦克仍然能够与他在 2011 年创下的纪录相抗衡，并在 2016 年平了自己的纪录，他在本赛季结束时获得了 2 个大满贯。罗杰的接发球率是职业生涯平均 40%，对于一个完全处于巅峰状态的球员来说，这并不算太差，但诺瓦克和罗杰的区别在于赢得的破发点的百分比。在澳网期间，罗杰赢得了 14.7%的破发点，诺瓦克赢得了 39.4%的破发点。下面看看今年的断点统计与他在其他年份打网球的情况如何。

地面“体击”比划

不幸的是，ATP 没有提供足够的数据来评估某人的正手和反手比赛，但在定性的层面上，正手和反手正在全力以赴。在令人失望地输给罗伯托·布蒂斯塔·阿古特之后，诺瓦克打得如此被动，看起来他无法穿透他的任何对手(Marton Fucsovics，Nikoloz Basilashvilli)。他从澳网第一轮开始就很好地掌握了自己的比赛，并且在每一轮比赛后都有很大的进步。在半决赛对阵 Pouille 的比赛中，他犯了 5 次非受迫性失误，而在决赛对阵 Nadal 的比赛中，他犯了 9 次非受迫性失误，这实在是太可笑了。

他的场地位置非常具有攻击性，并多次压平他的反手，以中和纳达尔多圈的斜线正手。看看下面链接中的照片。

显然，马里昂融入的变化将诺瓦克的比赛带到了一个新的水平，没有任何真正的竞争(除非纳达尔和费德勒能够回到 2017 年的状态)，他可能会在今年赢得 2 个或 3 个大满贯。

基于树的分类器在处理缺失数据时有多健壮？

原文：https://towardsdatascience.com/just-how-robust-are-tree-based-classifiers-in-handling-missing-data-as-is-67d62adaf40c?source=collection_archive---------25-----------------------

这是一个有趣的小型实验，通过使用中位数和众数插补，对照逻辑回归的预测，测试没有缺失值替换的树集合的预测。

Train set with 36% of the values missing on average for every row entry.

首先，这不是一个科学实验来确定一个人应该如何预处理缺失值的数据，或者当适合缺失值的数据时，哪个树集成擅长给出最准确的预测。我的主要动机是研究随着数据集中缺失值数量的增加，不同模型的预测如何变化。该实验的结果可能不表示使用不同数据集来拟合相同模型的结果。然而，我希望它可以提供一些关于预测准确性开始加速恶化的临界点的见解。

数据来源及描述

信用批准数据集是从 UCI 机器学习库下载的。它由 690 个条目组成，具有 9 个分类属性和 6 个连续特征属性。为了保护敏感信息的机密性，这些功能的名称和值已被更改为不可识别的类型。有 37 个行条目缺少一个或多个值，但它只占总数据的不到 1%。批准和拒绝这两个目标类别几乎是平衡的，这使得评估不同的模型变得更加简单。

模型训练和测试

数据集分为 80%用于训练，20%用于测试。在训练集的 552 个条目和测试集中的 138 个条目中，分别只有 29 个和 8 个缺失值。每个模型都适合一个流水线，其中诸如输入缺失值、定标器转换和模型训练等过程被简化。作为这个实验的设置，我决定估算数据集的均值和模式，以在逻辑回归上进行训练，并估算一个空字段和'-999，999，999 '(看起来很傻，但像我说过的，这只是一个有趣的实验)以使数据集在额外的树、随机森林、Adaboost 和梯度增强上进行训练。

Pipeline for Logistic Regression

Pipeline for Tree Based Classifiers

每个模型的结果和缺失数据的数量都记录在 Pandas 数据框架中。

缺少价值生成和阈值

我通过向训练集和测试集随机添加缺失值来引入更多的噪声。我将缺失值的行数设置为函数的阈值。这些阈值大约为 15%、30%、50%、75%和 100%的行。在每个阈值对每个模型进行模型训练和附加结果的过程。

初步结果

总的结果肯定不是我所期望的。即使有 75%的行包含至少一个缺失值(即 9.4%的定型集和测试集不包含任何数据)，我的大多数模型的预测得分也只有微不足道的下降。与逻辑相反，任何模型的最佳预测可能不是来自缺失值最少的数据集。如下表所示，在缺失值为 2.6%的数据上构建随机森林比缺失值为 0.6%的初始数据集获得更好的预测。

AUC vs percentage of missing data in training set

重新校准的实验

对初始实验的一个疏忽是，应该定期对数据集中发现的缺失数据进行评估。我修改了缺失数据生成器，以 5%的间隔随机删除数据点，直到一半的数据集(训练和测试)不包含任何数据，同时只保留 25%的行没有任何缺失值。

AUC vs percentage of missing data for recalibrated experiment

决赛成绩

随着缺失值的百分比变高，所有模型的结果最终都会恶化，但这种关系并不像我最初假设的那样接近线性或二次关系。仍然有可能从任何模型，逻辑回归或基于树的分类器中获得很好的预测，建立在具有 20%缺失数据的数据集上。鉴于我没有为基于树的模型估算有意义的值，我对这些模型的结果印象深刻。我的迷你实验的主要收获是，有相对大量的缺失值并不一定会导致糟糕的模型预测。可能还有其他未知因素影响预测的质量。

继续猜测:蒙特卡罗方法的力量

原文：https://towardsdatascience.com/just-keep-guessing-the-power-of-the-monte-carlo-method-f06bc6f33d19?source=collection_archive---------25-----------------------

Photo by Martinp1

蒙特卡罗方法是一个非常强大的工具，广泛应用于各种领域。从数学到科学到金融，蒙特卡罗方法可以用来解决各种独特而有趣的问题。

蒙特卡罗方法的思想相当简单。它依靠大量的重复随机抽样来获得数值结果，并取所有这些结果的平均值来找到问题的最终答案。

让我们尝试用蒙特卡罗方法找到积分的数值解。在我们开始之前，应该注意到蒙特卡罗模拟对于单变量函数来说并不是最优的。他们在解决多变量函数时做得最好，但是为了清楚和简单起见，我们现在将坚持一个。

先说函数平均值的定义。平均值可以表示为

其中 a 和 b 是我们的开始和结束积分点， x 是我们正在积分的值。因此，从这里我们可以通过将方程的两边乘以范围 (b-a)来计算积分。

现在积分等于一个函数的平均值乘以我们想要积分的范围。

从这里我们要求 F 的平均值。我们可以这样做:取一个大的随机数样本，找到每个随机数的对应值，将这些值相加，然后用随机数的总数除总和。数学上，这个关系看起来像

值得注意的是，这只在随机数均匀分布的情况下有效。记住这一点，感兴趣的积分的最终方程是

现在剩下要做的就是插入我们想要积分的函数，我们积分的极限，以及在计算积分时我们想要猜多少次。

让我们举一个简单的例子。让我们将函数 sin(x) 从 0 到 pi 进行积分。分析上，这个积分并不太难，计算只是

但是我们的兴趣是看看蒙特卡罗方法能多好地完成这个计算，所以我们要解的方程是

这是你运行自己的蒙特卡洛计算所需的所有代码。

import numpy as np
from scipy import randoma, b = 0, np.pi # limits of integration
N = 100_000     # Number of random points
integral = 0.0  # initialize the value of the integralx_random = random.uniform(a,b,N) # array of random numbersdef func(x):
    '''This is the function that we want to integrate'''
    return np.sin(x)# Makes a guess at the integral, adds that guess to the other guesses, and prints intermediate answers
for x in range(N):
    integral += func(x_random[x])
    if (x % 10_000 == 0) & (x != 0):
        intermediate_answer = (b-a)/float(x)*integral
        print(f'Value after {x} iterations is {intermediate_answer}')

answer = (b-a)/float(N)*integral
print(f'The value of the integral from {a} to {b} is: ', answer)

结果是

我们可以看到，我们的蒙特卡洛计算正在慢慢地向正确答案靠拢！

67%对 45%的 TD 通过率对运行率。随着 NFL 常规赛的结束，这种奇怪的趋势会持续下去吗？

原文：https://towardsdatascience.com/just-run-the-damn-football-at-the-goalline-a7771b190050?source=collection_archive---------43-----------------------

你应该跑还是应该越过球门线？

(这篇文章最初发表于 2019 年 10 月 22 日，涵盖了截至第 6 周的统计数据。本次更新涵盖统计数据，直到第 16 周。)

所以你一直走到了对手的 1。传统观点认为你应该直接运行它。然而，许多主教练认为这太容易预测了，所以他们选择传球。基于数据的决策应该是什么？

我收集了从 2014 年到 2019 年在对手 1 码线开始的所有比赛的日志。像往常一样，我在这里排除了投篮尝试，唯一合理的解释是，在那个特定的时刻，你更加重视眼前的收益——时间不多了，和/或投篮实际上帮助你的球队赢得了很多的概率，比如从 6 到 9 分的领先优势，或者追平或在晚些时候领先。剧透一下，1 号位的投篮命中率是 49/49。所以让我们把注意力集中在传球和抢攻上。当然，我也排除了下跪戏。

总的来说，触地得分率徘徊在 55%左右，有些年份比其他年份好。2019 年实际上是非常好的一年，整体触地得分率超过 60%。(这不是一个小样本的人工制品，或者只是在赛季初还没有解决的问题，因为当只考虑 9 月和 10 月的比赛时，可以得出相同的结论)。几年过去后，你会有稍微好一点的机会，比如 2014 年和 2017 年，类似的几年，2015 年对两者都不好。但到目前为止，我们从未有过像 2019 年这样的一年，即通过与运行的 TD 比率分别为 67%和 45%。大多数教练知道他们应该少传球，因为他们已经选择传球的时间低于 30%，今年是所有教练中最低的。但不是我的绿湾包装工队。在周四晚上的足球比赛中对阵老鹰队，他们在费城 1 号连续四次传球，导致四次失误和失误。

P(TD，4 次运行)=1-(1–0.68)⁴= 0.985

P(TD，4 遍)=1-(1–0.448)⁴= 0.907

相差 8%！

接下来，一个理念是你应该在第一次传球时多传球，让对手措手不及。从历史上看，这是有数据支持的。TD 通过率在第一次下降时高得多，在第四次下降时低得多。但这在 2019 年不再成立。事实上，在第一、第三和第四次下降时冲得更好，在第二次下降时稍微差一点。

另一个支持足球的理由是风险更小。失误率实际上非常相似——所有传球和跑位的拦截率为 1.8%，失球率为 2.1%。奇怪的是，你甚至可以在前面只有 1 码的绿草地的情况下摸索出一个信号。到目前为止，这项荣誉属于我的数据集中唯一的充电器。

Philip Rivers pass complete short middle to Austin Ekeler for no gain (tackle by Kareem Jackson). Austin Ekeler fumbles ball out of bounds at DEN-1 (forced by Kareem Jackson)

我们应该考虑事情变得非常糟糕的极端情况。就像今年底特律的失球，堪萨斯城的达阵得分。

Kerryon Johnson up the middle for no gain (tackle by Xavier Williams). Kerryon Johnson fumbles (forced by Xavier Williams) recovered by Bashaud Breeland at KC-0 and returned for 100 yards touchdown

在我们的数据集中，最糟糕的传球失误是 Blake Bortles 拦截，他在 84 码处回球。

Blake Bortles pass incomplete short left intended for Marcedes Lewis is intercepted by Kemal Ishmael at ATL-0 and returned for 84 yards

这是过去几年中唯一一次比触球收益更高的失误。但当然，100 码的拦截回报是可能发生的，最令人难忘的是匹兹堡钢人队对红雀队的超级碗第四十三届选秀权(库尔特·华纳传球不完整的短中路，打算给安泉·波尔丁，在 0 号坑被詹姆斯·哈里森拦截，并返回 100 码触地得分)。综合来看，冲向或越过球门线的风险似乎不相上下，但冲向现在给团队带来了更大的好处。所以只管跑那该死的足球！

那么这种趋势会在赛季末保持吗？

下图来自 2019 年常规赛第 16 周的更新。

嗯……没那么引人注目，但仍然是一个巨大的差异。在 60%的情况下，冲球仍然能让你触地得分；而现在通过至少让你有 52%的机会获得 50%以上的机会。但是，在必须得分的情况下，6 分在起跑线上， 8%的触地得分率增长仍然有很大的不同。

更有趣的见解来自唐斯的分解。虽然的传球率在第四轮比赛中飙升，但 rushing 仍然更加成功，达阵率高出 10%。如果你真的想传球，第二次触地得分应该是在你传球的时候，因为传球和冲刺给你的触地得分率是 58%。

你可以在我的 Github 上找到我的代码，并在 LinkedIn 上与我联系。数据来自 Profootballreference.com。它在 2019 年 NFL 赛季的第 6 周更新，首次发布；并且在第二次发行的第 16 周。

证明图像分类的合理性:用什么像素来决定？

原文：https://towardsdatascience.com/justifying-image-classification-what-pixels-were-used-to-decide-2962e7e7391f?source=collection_archive---------19-----------------------

在本文中，我将向您展示一种简单的方法来推理图像分类神经网络模型所做的预测。我已经为您提供了代码来重新创建我的发现，但是您不需要阅读代码来理解这篇文章(希望如此)。

你应该从这篇文章中得到的想法是，你想对神经模型“看到”什么或“它在看哪里”有一些了解，这样你就可以更有信心地相信它做出的预测。

基础知识

让我们回顾一下，在一个超高的水平上回顾一下基础知识。可以训练一个卷积神经网络模型，根据图像中的内容对图像进行分类，我们用准确度、精确度、召回率等指标来衡量这个图像分类器的性能。这些模型非常标准，你基本上可以下载一个预先训练好的神经网络模型(例如 inception-V4 、 VGG19 、 mobilenet 等等)。如果您想要识别的类(事物)不在预训练模型识别的内容列表中，那么您通常可以通过使用预训练模型的大部分权重和连接来重新训练预训练神经网络模型以识别新内容。这叫做迁移学习。

所以，基本上，我们有一堆模型，它们接受图像，吐出标签。但是我为什么要相信这些模型呢？让我们来看看这些模型中的一个使用什么信息来进行预测。这种方法也可以用来测试许多其他模型，包括定制模型。

信任但核实

我们在的真实世界 AI 问题中很好地提到了 The Verge 谈论这些图像分类系统如何可能出错，如果你不考虑它们正在做的事情的细节(全文在此)。

神经网络可以学习从训练数据的错误部分进行预测。这是我们试图通过验证模型预测的基础来消除的问题。如果您想要建立一个分类器模型来区分狼和狗，您想要通过查看背景中的雪(狼)和玩具(狗)来确保该模型没有作弊。我们想知道哪些像素参与了预测。我们不希望雪中的狗被视为狼。把这种方法想象成人工智能(AI) 的测试 - 驱动开发 ( TDD ) 。我们首先定义一个测试(来自某个显而易见的类的一些图片)，然后对照这个图片检查模型，看看模型是否使用我们认为相关的信息做了我们想要它做的事情。然而，我们并没有写测试用例，而是用我们的眼睛来观察这个测试用例，看看发生了什么。

我的文章的最初版本使用了一张黛米·罗斯的图片，因为为什么不呢...但新版本使用了库存照片比基尼模型，因为版权和合理使用法正在粉碎创意世界。好的。发泄完了，又回到文章:我们就用deep shap来看看-16(其中使用了 imagenet 类标签 )如何解读一张图片。

Shap builds an explanation for the model prediction using information about the dataset, and the activations in the model itself (source: the shap github repo)

真实的例子

以下是本文代码的链接，您可以直接将其放入 Google Collab:

[## dcshapiro/funWithShap

检查 deepSHAP 如何在 VGG-16 上工作(探索预言的原因)- dcshapiro/funWithShap

github.com](https://github.com/dcshapiro/funWithShap/)

代码的第一部分安装 deepSHAP 并运行其中一个示例的一部分，以显示该库工作正常。接下来，我们查看输入图像的形状(224，224，3 ),并看到 VGG-16 模型接受高度和宽度为 224 的正方形图像，具有 3 个颜色通道(红色、绿色和蓝色)。

我们现在抓取比基尼模特的图像，并将其裁剪为 224×224×3 的正确尺寸。

The image on the left was cropped to the right shape/size, using the image on the right as a starting point.

既然 cv2 决定为恶，对颜色通道使用 BGR 编码，那么就有一个将 RGB 颜色数据切换为 BGR 颜色数据的编码步骤。

既然预处理已经完成，让我们开始工作吧。模型在这张图片中看到了哪些类(类别)？哪些像素有助于或有损于这些分类意见？

From left to right: The input image, the strongest prediction (cowboy_hat), followed by the second strongest prediction (sombrero), and so on. The scale on the bottom of the image shows relative positive or negative strength (the SHAP value). In each prediction image, the contribution of each pixel to the prediction is shown.

显然，在预测“cowboy_hat”时查看上面的图像，牛仔帽使用帽子中的像素来做出决定。那很好。它还使用了泳衣的几个像素，但让我们更深入地挖掘一下。为什么不用白色、黑色或随机噪声遮挡图像的一部分，看看这如何改变预测。

Prediction explanation when the top half of the image is whited out.

Prediction explanation the when top half of the image is blacked out.

Prediction explanation when the top half of the image is filled with random noise pixel values.

我们来思考一下上面的结果。首先，很高兴看到顶级预测(模型看到的)对我们使用的屏蔽类型(白色、黑色或噪声)不敏感。这表明模型关心真实的数据。此外，无关掩蔽区域对决策的贡献非常小，只有少数例外(创可贴和凉鞋)。此外，根据我们对人类的期望，预测的类 maillot 是正确的。“maillot”是个有趣的词。我得去查一下。它的发音更像“my-yo”而不是“mail-lot”，根据谷歌的说法，它是“一件女式泳衣”很高兴知道。比基尼在这里也很有意义。其余的类都与图像相关，这也是一个好现象。注意凉鞋也在里面。我猜沙滩装会让模特想起穿凉鞋的照片。或者胸罩上的斑点图案看起来像凉鞋？也许纱笼和超短裙经常伴随着皮肤，我们看到触发那些标签的像素是女孩脸上的皮肤和胸罩肩带附近的肩部区域。

好吧！所以我们到了图像的上半部分。让我们做同样的掩蔽工作，看看会发生什么:

Prediction explanation when the bottom half of the image is whited out.

Prediction explanation when the bottom half of the image is blacked out.

Prediction explanation when the bottom half of the image is filled with random noise pixel values.

我们看到顶级预测类 cowboy_hat 是有道理的。图像中有一顶帽子，脸部(尤其是眼睛)的像素大概有助于网络知道帽子在一个头上。

结论

在本文中，您了解了一种简单的方法来推理图像分类神经网络模型所做的预测。这只是神奇的形状库的一个应用。我们研究了输入图像中的哪些像素有助于神经网络模型进行预测。我们看到，图像的掩蔽(分块)部分会改变预测，但模型的顶部预测不会根据掩蔽的类型而改变。重要的是，我们观察到各种预测中涉及的像素位置是有意义的。欢迎您使用这种方法来验证和询问您自己的神经网络模型。

如果你喜欢这篇文章，那么看看我过去最常读的一些文章，比如“如何给一个人工智能项目定价”和“如何聘请人工智能顾问”嘿，加入我们的时事通讯！

下次见！

——丹尼尔
Lemay.ai
丹尼尔@lemay.ai

JVM 与 DVM

原文：https://towardsdatascience.com/jvm-vs-dvm-b257229d18a2?source=collection_archive---------16-----------------------

在本文中，我们将看到 Java 虚拟机和 Dalvik 虚拟机之间的区别

Photo by patricia serna on Unsplash

七年前，当我学习 Java 编程时，我曾经向我自己和朋友询问过许多关于这种奇妙语言的问题，但是有一个问题在我没有找到满意答案之前，大部分时间都是突然出现的。问题是为什么 java 字节码可以在任何机器或平台上运行，它与其他代码有什么不同？。这个问题的答案在当时对我来说并不容易，因为我刚刚起步。

因此，在本指南中，我将回答以下问题

JVM 与 DVM
Android OS 为什么用 DVM 而不是 JVM？

Java 虚拟机

一个 Java 虚拟机 ( JVM )是 Java 程序和运行 Java 代码的平台之间的抽象层。JVM 是平台相关的，不同的实现可用于特定的平台。

例如，如果您有一个Hello.java类，当您运行这个类文件时，javac 编译器会将您的源代码转换为bytecode并创建Hello.class文件，这意味着javac编译器不会像其他编译器那样将 Java 代码直接转换为机器码。字节码是中间代码，这意味着人类不能理解这种代码，并且这种代码不依赖于机器/平台。因为字节码是一种中间代码，所以你可以把它交给任何人在任何平台上运行，这就是为什么我们称 Java 应用程序为 WORA(编写一次，在任何地方运行)。

Image credit to netjs

从上图可以看出，一旦你有了。类文件准备好了，你就可以把这个文件给任何平台，它会把它转换成本机代码。

达尔维克虚拟机

Dalvik 虚拟机(DVM) 是执行 android 应用程序的虚拟机。因为手机的一切都非常有限，无论是电池寿命、处理能力还是内存等等。它已经过优化，可以适应低功率设备。

Image Credit to Tam H. Doan

从上图中可以看出，除了最后两步，一切都和 JVM 一样。Dex 编译器将类文件转换成。在 Dalvik 虚拟机上运行的 dex 文件。多个类文件被转换成一个 dex 文件。

JVM 与 DVM

在 android 中使用 DVM 的主要原因之一是因为它遵循基于寄存器的模型，并且比基于堆栈的模型快得多，而 JVM 遵循基于堆栈的模型，后者占用大量内存并且比 DVM 慢。

有一些主要的区别，让我们来看看

Credit to aatul.me

Android OS 为什么用 DVM 而不是 JVM？

Google 不选择 JVM 而选择 DVM 有几个原因，所以让我们一个一个地理解它们。

尽管 JVM 是免费的，但它是在 GPL 许可下的，这对 Android 是不利的，因为大多数 Android 是在 Apache 许可下的。
JVM 是为桌面设计的，对于嵌入式设备来说太重了。
与 JVM 相比，DVM 占用的内存更少，运行和加载速度更快。

——俄亥俄州立大学

结论

JVM 将基于字节码工作，DVM 将基于优化的字节码工作，它针对移动平台进行了优化，因为移动设备具有更少的内存、低进程和低功耗，这就是它使用 linux 内核的原因。

我希望你喜欢读这篇文章，你也可以访问我的网站，在那里我会定期发布文章。

订阅我的邮件列表，以便在您的收件箱中直接获得我的文章，并且不要忘记关注我自己在 Medium 上发表的文章The Code Monster来完善您的技术知识。

了解你的作者

希曼舒·维尔马毕业于印度勒克瑙的 APJ 阿卜杜勒·卡拉姆大学博士。他是 Android & IOS 开发人员、机器学习和数据科学学习者、金融顾问和博客作者。

K-means:完全介绍

原文：https://towardsdatascience.com/k-means-a-complete-introduction-1702af9cd8c?source=collection_archive---------10-----------------------

K-means 是一种无监督聚类算法，旨在将未标记的数据划分为特定数量(即“K”)的不同分组。换句话说，k-means 找到共享重要特征的观察值，并将它们一起分类到聚类中。一个好的聚类解决方案是找到这样的聚类，使得每个聚类内的观察值比聚类本身更相似。

这种自动数据分组非常有用的例子数不胜数。例如，考虑为投放市场的一系列全新产品创建在线广告活动的情况。虽然我们可以向所有人展示单一的通用广告，但更好的方法是将所有人分成具有共同特征和兴趣的人群，向每个人群展示定制的广告。K-means 是一种算法，它在大数据集中找到这些分组，而手动完成这些分组是不可行的。

算法背后的直觉实际上非常简单。首先，我们为 k (集群的数量)选择一个值，并为每个集群随机选择一个初始的质心(中心坐标)。然后，我们采用两步流程:

分配步骤-将每个观察值分配到其最近的中心。
更新步骤-将质心更新为其各自观察的中心。

我们一遍又一遍地重复这两个步骤，直到集群中没有进一步的变化。此时，算法已经收敛，我们可以检索我们的最终聚类。

The K-means algorithm in action

进一步的细节

在继续下一步之前，值得后退一步来明确我们所说的好的集群解决方案的含义。我们到底将什么定义为可能的最佳集群解决方案？考虑以下对同一个质心的两种可能的观测分配的可视化。

Which data points should be assigned to this centroid?

很明显，第一个赋值优于第二个，但是对于 k-means 算法，我们如何量化这一点呢？解决方法是考虑连接每个观察到的潜在中心的红色虚线。如果我们比较好的赋值和坏的赋值的这些行的平均长度，很明显前者会产生一个小得多的值。这是我们的目标！在我们可能选择的无限多个可能的聚类中心中，我们正在寻找使这些线的总和最小化的一个，或者更正式地说是误差平方和(SSE) 。用数学术语来说，对于 xᵢ ∈ {x₁，x₂，…，xm 的一组观察值，我们希望找到质心 C 以最小化:

其中，由于我们已将质心定义为其各自观测值的中心，我们可以计算:

这个等式给出了单个质心 C 的误差平方和，但实际上我们希望最小化所有质心cⱼ∈{c₁，c₂，…，ck}对所有观测值 xᵢ ∈ {x₁，x₂，…，xn}的误差平方和。因此，k 均值的目标是最小化误差平方和(SST) 目标函数:**

虽然随着数据的增长，检查每个可能的聚类解决方案变得不可行(NP-hard)，但 k-means 在许多实际应用中倾向于找到足够好的解决方案。

到目前为止我们忽略的一个问题是选择集群的数量。偶尔我们会从一开始就知道 k，也许我们的在线广告活动已经预算了正好五个独特的广告，需要正好五个聚类，但是更多的时候我们不知道数据集中聚类的最佳数量。选择 k 没有完美的解决方案，但是一种流行的启发式方法被称为肘法。这包括对一系列的 k 值应用 k 均值，并在所谓的样板图中绘制出相对于 SST 的 k 的选择。然而，请注意，随着我们增加聚类的数量，SST 将总是下降(考虑当我们设置聚类的数量等于观测的数量时 SST 会发生什么)，因此我们正在寻找添加更多聚类不再提供 SST 的显著下降的点。换句话说，我们希望在碎石图中找到一个拐点，在此拐点之后，增加 k 不再能改善我们的整体解决方案。

Finding “the elbow” where adding more clusters no longer improves our solution

k-means 的最后一个关键方面回到了这个概念收敛。我们之前提到过，k-means 算法不一定会收敛到全局最小值，而是可能会收敛到局部最小值(即 k-means 不能保证找到最佳解)。事实上，根据我们为初始质心选择的值，我们可能会得到不同的结果。

由于我们只对给定选择的 k，的最佳聚类解决方案感兴趣，因此该问题的常见解决方案是多次运行 k-means，每次使用不同的随机初始质心，并且只使用最佳解决方案。换句话说，总是运行 k-means 多次，以确保我们找到接近全局最小值的解决方案。

进一步的考虑

到目前为止，我们已经讨论了 k-means 聚类方法的具体细节，本节将介绍对原始算法的一些扩展。

K-均值算法的一个问题是它对异常值的敏感性。由于质心是作为聚类中观察值的平均值来计算的，因此数据集中的极值会严重破坏聚类解决方案。K-medoids 是克服这个问题的流行方法。顾名思义，这种替代算法使用球心而不是质心作为聚类的中心点，这仅仅意味着聚类的中心必须是该聚类中的一个观测值。

In this case, the medoid is a more representative centre than the centroid

这可以比作取一组数字的中间值而不是平均值，同样的，中间值对极值不太敏感。使用 medoid 需要调整常规 k-means 算法的更新步骤。更新阶段现在变成了一个交换阶段，在这个阶段，我们贪婪地考虑将当前的 medoid 与集群中的其他观测值进行交换，并检查这种交换是否会改进整个集群解决方案。

分类数据 —我们应该承认的 k-means 算法的一个局限性是它要求数据是数值型的。性别等分类变量对 k-means 没有意义。一群男女的意思是什么？我们还能对部分甚至完全分类的数据进行聚类吗？

完全分类数据的解决方案被称为 k-modes。这种方法非常类似于 k-means，但是以一个聚类的模式为中心，然后使用一种新的度量来计算每个观察值与其聚类中心之间的距离。该距离度量比较观察值 X 和聚类模式 Z 之间每个属性的相异度，并对这些值求和。与几乎与 Z 相同的观测值相比，与 Z 具有许多不同属性的观测值将采用更高的相异度值。具体来说，对于观察值 X 和质心 Z 的属性，相异度计算如下:

相异度通过频率进行加权，该频率试图说明属性内值分布的不平衡，因此 n 是聚类中的观察总数，而 n ⁽ʳ⁾是聚类中采用相关值 n 的观察总数。K-modes 然后以与 k-means 相同的方式使用这种相异度作为距离的度量来分配和更新聚类。

最后，对于分类数据和数值数据的混合数据，我们可以应用 k 原型算法，它本质上是 k 均值和 k 模式的混合。我们的聚类中心现在被称为原型，正如我们在这一点上可能猜到的，简单地对数字属性应用 k-means 距离度量，对分类属性应用 k-modes 相异度度量，将两者结合起来作为相异度的总体度量。有了这个设置，我们可以再次应用相同的旧的分配-更新方法。

聚类验证—k-means 等无监督方法的一个缺点是，没有明显的方法来评估我们得到的解决方案。我们得到的解是否充分地抓住了集群结构？数据中是否存在任何聚类？当然，有时我们可以绘制数据并观察结果，但这仅在二维中有效，而且聚类通常只会在更高维中变得有趣(如果我们已经可以看到数据中的聚类，为什么还要麻烦 k-means)。

一种流行的方法是检查集群解决方案的稳定性。这种方法背后的基本原理是，如果数据中真的存在聚类，那么当我们比较来自该数据的多个样本时，它们应该表现出相似的聚类解决方案。在下面的例子中，我们采用了两个数据集，一个显然包含三个聚类，另一个只是均匀随机放置的观察值。我们从每个样本中抽取若干 bootstrap 样本(替换样本)，并对每个样本应用 k-means。在结构化数据中，k-means 反复找到相似的解决方案，然而在非结构化数据中，聚类更加不一致。这种稳定性差异可以通过比较聚类平均值的位置或使用更多的技术统计数据(如连续样本的平均轮廓宽度)来更严格地量化。

模糊 C-means—K-means 的另一个我们尚未解决的限制可以归因于硬聚类和软聚类之间的差异。 K-means 是一种硬聚类方法，这意味着每个观察值都被划分到一个单独的聚类中，而没有关于我们在该任务中有多自信的信息。实际上，如果观测值大约在两个质心的中间，将这种不确定性编码到输出中会很有用。软聚类通过给我们一个观察值属于每个质心而不是一个分类的概率估计，解决了这个问题。当然，我们仍然可以将每个观察值分配给提供最高值的质心，但现在我们有了一个对该决策的置信度估计，允许我们区分正好在某个簇质心旁边的观察值和那些更模糊的观察值。模糊 C 均值采用这种软聚类方法。

那么模糊 C-means 和原来的 K-means 算法有什么不同呢？幸运的是，这种调整根本没有改变我们的方法，相反，它只是包括了所谓的模糊化器项wt16】ᵢⱼᵐ(用 m 简单地说就是一个超参数)来包含我们在集群 j 中的成员确定性 X ᵢ的权重。这意味着我们希望最小化的模糊 C 均值目标函数由下式给出:

在哪里

并且应用这些新的等式，我们重复在原始 K-means 中采用的完全相同的分配和更新方法。

R 实施

做得好，一路走到了最后，在 twitter 上关注我以了解未来的帖子。所有的观想都是我自己的。

k 均值聚类

原文：https://towardsdatascience.com/k-means-clustering-13430ff3461d?source=collection_archive---------11-----------------------

更简单直观的解释。

K-means 是最简单的无监督学习算法之一。该算法遵循一种简单易行的方法，将给定的数据集分组为一定数量的相关子集，称为簇。这个想法是找到 K 个中心，称为簇质心 ，一个对应一个簇，因此得名 K-均值聚类。当看到一个新示例时，该算法根据距离度量(如欧几里德距离)报告该示例所属的最接近的聚类。

The dataset used for illustration. The dataset consists of 8 points — those 8 points are plotted as blue circles in the graph below.

The diagram is a typical illustration of clustering, with K=2 clusters and their cluster centroids shown evidently with a green and a yellow cross respectively. The circles correspond to the dataset and the crosses correspond to the cluster centroids.

为了更好地理解，让我们考虑一个例子——假设一个社交网站想要找到具有相似兴趣的人群，并向他们投放相关广告。解决这个问题的一种方法是通过聚类，该公司可以使用喜欢的页面、分享的帖子和登记的位置等特征来建立数据集，并通过聚类算法来运行它，以识别相关的群体。不过需要注意的一点是，数据集是未标记的。

A note on the notation. x_{i} means x subscript i, x_{^th} means x superscript th and x_{^th}{i} means x superscript th and subscript i.

算法

K 均值聚类算法从初始化步骤开始，称为随机初始化步骤。该步骤的目标是为每个 K-聚类随机选择一个质心， u_{i} i ∈ {1，2，3…K}。

For the sake of simplicity only 8 data points have been considered. Out of these 8 points two points, drawn as a cross have been randomly chosen as cluster centroids illustrating random initialisation step.

然后使用迭代算法将这 K 个质心收敛到最优值。迭代的每一步都执行以下两步—

集群分配
移动质心

聚类分配步骤遍历数据集中的每个示例 x_{^i} ，并基于距离度量(比如欧几里德距离)将其分配给其最近的聚类质心。对于下面讨论的例子，可以说——给定一个例子，聚类分配步骤根据该例子离聚类质心的距离将其分配给一种颜色，绿色或黄色。

Cluster Assignment Step

移动质心步骤通过取分配给相同聚类质心的样本的平均值来计算新的聚类质心。或者，用黄色和绿色着色的所有点的平均值给出聚类质心的新值。为了清楚起见，这是负责随机初始化的群集质心收敛到最佳值的步骤。

Move Centroid Step.

该算法一直持续到收敛，也就是说，直到两次后续迭代没有给出几乎相同的聚类质心值。

改进随机初始化

如前所述，该算法从随机初始化步骤开始，但随机初始化可能会导致算法陷入局部最优。

一种提高我们以更好的聚类质心值结束的几率的方法是多次执行随机初始化步骤，并选择一组值，该组值导致由下式给出的失真成本函数的最小值—

||a-b|| implies the Euclidean distance between vectors a and b. Interpret u_{^i}{c} as — cluster centroid of the cluster, to which example x_{^i} has been assigned. Concretely, u_{^ 3}{2} means, the third example is closest to the 2nd cluster centroid.

上面的成本函数正在计算每个训练示例 x_{^i} 和它被分配到的集群 u_{^i}{c}.之间的平方距离的平均值平方是为了完全避免欧几里德距离引起的平方根。显然，较小的成本函数值对应于较好的初始化。

这种技术对于 K≤10 的值有效，但是已经观察到，对于较大的 K 值，它不会产生显著的差异。对于较大的 K 值，K-means 算法将几乎收敛到可接受的聚类质心值。此外，这种优化随机初始化步骤的方法计算量很大。

选择 K 的值

到目前为止，您一定已经对 K-means 聚类算法有了直观的了解，但还有一个方面需要处理，即参数 K。让我们看看如何知道数据集需要划分的聚类数。

肘形法可用于寻找 K 的最佳值。该方法根据失真成本函数值绘制聚类数，并在图形向外弯曲或急转弯处选择 K 值。

Elbow method : The optimal value of K is 3 from the above graph as graph elbows out at 3.

但实际上这种方法用得不多，因为当绘制真实世界的数据时，图形通常没有一个显著的拐点来选择 k 值。

Elbow method : Real world plot where it is hard to point out any elbow.

不幸的是，没有自动选取 K 值的方法。大多数情况下，参数 K 的值是通过查看可视化来手动选取的。

k 均值聚类

原文：https://towardsdatascience.com/k-means-clustering-8e1e64c1561c?source=collection_archive---------2-----------------------

Source: Pixabay

使用无监督学习理解文本数据

、客户细分、文档分类、房价估算、欺诈检测 。这些只是集群的一些实际应用。这种算法还有许多其他的使用案例，但是今天我们将把 K-means 应用于文本数据。特别是，我们将从头开始实现该算法，并将其应用于安然电子邮件数据集，并展示这种技术如何成为总结大量文本并揭示有用见解的非常有用的方法，否则这些见解可能是不可行的。

那么 K-means 到底是什么？嗯，它是一种无监督的学习算法(意味着没有目标标签)，允许您在数据中识别相似的数据点组或聚类。为了了解它为什么有用，想象一下上面提到的一个用例，客户细分。使用这种算法的公司可以根据客户的特点将他们分成不同的组。这可能是一种非常有用的方式，可以进行有针对性的广告或提供个性化折扣或促销等可能推动收入增长的东西。对于我们的用例，它可以帮助我们快速洞察和解释文本数据。当我们有大量的数据时，这是非常有用的，并且对于某些人来说手动浏览它是不实际的。

作为一名经济学家，我能够用这种方法来分析一次公众咨询，其中很多回答都是定性的。利用我的机器学习知识，我能够创建有用的见解并对数据有所了解，同时为我的同事避免了相当多的手动工作，这很好。

更正式地说

同样，K 均值的问题可以被认为是将数据分组为 K 个聚类，其中对聚类的分配是基于到质心的某种相似性或距离度量(稍后将详细介绍)。那么我们如何做到这一点呢？好吧，让我们首先概述一下所涉及的步骤。

我们随机初始化 K 个起始质心。每个数据点被分配到其最近的质心。
质心被重新计算为分配给相应聚类的数据点的平均值。
重复步骤 1 和 2，直到我们触发停止标准。

现在你可能想知道我们在优化什么，答案通常是欧几里得距离或者欧几里得距离的平方更精确。数据点被分配给最接近它们的聚类，或者换句话说，最小化该平方距离的聚类。我们可以更正式地把它写成:

K means Cost Function

J 就是每个数据点到它所分配的聚类的平方距离之和。其中 r 是指示函数，如果数据点(x_n)被分配给聚类(k ),则等于 1，否则等于 0。这是一个非常简单的算法，对吗？如果还不完全清楚，不要担心。一旦我们将它可视化并编码，它应该更容易理解。

k 表示可视化

我一直热衷于使用视觉辅助工具来解释主题，这通常有助于我对各种算法实际发生的事情有更深的直觉。所以让我们看看每次迭代后 K 的意思是什么。

K mean Algorithm, Source: Bishop

正如你所看到的，上图显示了 K 值的作用。我们已经定义了 k = 2，所以我们在每次迭代时将数据分配给两个集群中的一个。图(a)对应于随机初始化质心。在(b)中，我们将数据点分配给它们最近的聚类，在图 c 中，我们分配新的质心作为每个聚类中数据的平均值。这一直持续到我们达到停止标准(最小化我们的成本函数 J 或预定义的迭代次数)。希望上面的解释和可视化能让你很好的理解 K 的意思。接下来，我们将在 Python 中实现这个算法。

数据集和代码

正如我之前提到的，我们将使用文本数据，特别是，我们将查看在 Kaggle 上提供的安然电子邮件数据集。对于那些不知道围绕安然的故事/丑闻的人，我建议看看房间里最聪明的人。这是一部关于这个主题的特别好的纪录片。

只有一个问题

我们能不能只给我们的算法一堆文本数据，然后期待任何事情发生？很遗憾，不行。算法很难理解文本数据，所以我们需要将数据转换成模型可以理解的东西。计算机非常擅长理解数字，所以我们试试看怎么样。如果我们将每封电子邮件中的文本表示为一个数字向量，那么我们的算法将能够理解这一点并据此进行处理。我们要做的是使用术语频率-逆文档频率或 TF-IDF 将每封电子邮件正文中的文本转换为数字向量。我不会太详细地解释这是什么，因为我在之前的帖子中已经解释过，但本质上它使我们能够计算每封电子邮件中的单词相对于该电子邮件中的内容以及相对于数据集中所有电子邮件的重要性。更多关于 TF-IDF 的信息请点击这里。

好了，我们需要做的第一件事是导入所需的库和数据集。我应该提到，我试图在 Kaggle 内核中使用完整的数据集，这是一个挑战。我遇到了一些内核故障，所以我最终使用了大约 70%的完整数据集，运行时没有任何问题。请注意，我没有把代码的数据清理部分放在帖子里，因为我们关注的是 K 均值算法。对于那些感兴趣的人来说，完整的代码可以在我的 Kaggle 内核上找到，链接在文章的最后。像往常一样，我们导入将要使用的库，并读入数据集。

在我们做了一点文本清理之后，例如转换成小写，删除无用的单词和 HTML，我们可以继续使用 TF-IDF，这在 sklearn 中非常简单。

运行这段代码后，我们可以使用下面的 get_feature_names()方法先睹为快。

pd.DataFrame(tf_idf_array, columns=tf_idf_vectorizor.get_feature_names()).head()

现在我们需要考虑我们的 K 意味着类将会是什么样子。嗯，我们需要实现一些方法，这些方法对应于我上面概述的步骤。我们将实现以下 5 个方法，这将有助于我们把算法分成可管理的部分。

初始化 _ 质心
assign _ clusters
更新 _ 质心
fit_kmeans
预测

上面的代码定义了我们的 Kmeans 类，init 和 initialise _ centroids 方法。我们希望我们的类接受一些参数，比如聚类的数量、迭代的次数以及我们需要的可重复性的种子。设置种子是一个重要的步骤，因为我们在算法开始时随机初始化我们的质心。如果我们没有设置种子，那么每次运行算法时，我们可能会收敛到不同的聚类集。初始化 _ 质心方法简单地选择 k 个随机数据点，并将它们设置为初始聚类中心，以开始算法。

我们现在需要编写将数据点分配给特定聚类的方法，并更新聚类中心。请记住，我们根据到中心聚类的欧几里德距离将数据分配给聚类。我们使用 sklearn 的成对距离方法，该方法简化了我们的计算，并返回到每个聚类中心的距离。argmin 函数确定到每个聚类的距离最小的索引，从而允许我们为该索引分配正确的聚类标签。现在，为了完成算法的一次迭代，我们只需要将质心更新为分配给特定聚类的所有数据点的平均值。

接下来的两个方法也很重要。预测方法基本上基于我们的算法为每个数据点返回相应的预测聚类标签。下面代码片段中的最后一个方法通过调用我们之前定义的函数来适应我们的模型。好了，这就是我们的 k-means 类。现在，我们只需在运行我们的算法时，计算出要选择的最佳聚类数。

最佳聚类数

当使用 K-means 时，我们需要做的事情之一是确保我们选择了最佳的聚类数。太少，我们可能会把有显著差异的数据分组在一起。太多的聚类，我们将只是过度拟合数据，我们的结果将不会概括得很好。为了回答这个问题，我们将使用肘法，这是这项任务中常用的技术。它包括使用不同数量的聚类来估计模型，并使用 sklearn 的评分方法来计算每个所选数量的聚类的 组内平方和 的负值。请注意，这只是我们上面的目标函数的负值。我们选择这样一个数字，在这个数字上增加更多的聚类只会略微增加分数。绘制的结果看起来明显像一个肘部(或者在这种情况下是颠倒的肘部)。群集数量的最佳选择是肘部形成的位置，在我们的示例中为 3，我们可以从下图中看到这一点。(我们也可能用 4 个集群进行实验，但对于此实施，我们将使用 3 个集群)

Optimal Number of Clusters

我的实现

在这篇文章的这一部分，我们将实现刚刚用 Python 编写的算法。为了以图形方式查看我们的聚类，我们将使用 PCA 来降低我们的特征矩阵的维度，以便我们可以以二维方式绘制它。也就是说，我们选择两个组件，并使用 PCA 类的 fit_transform()方法转换我们的 tf_idf_array。然后我们创建一个 Kmeans 类的实例，根据上面的分析选择 3 个集群。现在只需要调用 fit_kmeans()和 predict()方法将我们的数据点放入集群中。因为我们已经将阵列投影到一个 2-d 空间中，所以我们可以很容易地使用散点图来显示它和聚类中心。

我们可以在这里看到三个非常不同的集群，紫色集群的分离度特别大，这表明电子邮件的内容有很大的不同。但是，大部分数据都包含在绿色集群中。

Figure 2: My Implementation Clustering Results

SK-Learn 实现

作为一种感觉检查，我们将使用 sklearn 重新进行这个估计。在现实世界中，我非常怀疑你会从零开始实现它，因为它并不是真正需要的。然而，这是一个非常有用的方法，可以具体地理解 k-means 是如何工作的，因此绝对值得亲自去做。我们可以看到，sklearn 使估计变得简单得多，如果我们绘制结果，两个图形看起来非常相似。这是令人放心的，并使我们自己的代码不太可能有错误。尽管星团的颜色因为某种原因发生了变化？？

Figure 3: sklearn Clustering Results

检查每个聚类中的顶部单词

在这一部分，我们将快速浏览一下我们得到的结果。我们主要感兴趣的是看每个词群中的词之间是否有任何共性或者任何突出的特定词。换句话说，我们能在每个集群中识别主题吗？如果我们可以，那么这是一种非常强大的方式来获得对电子邮件内容的总体感觉，并可以指导我们希望做的任何进一步分析，最好的部分是我们不必阅读 35，000 封电子邮件。我们可以使用下面的方法来查看每个聚类中的顶部单词，该方法仅识别每个聚类中具有最高平均 tf_idf 分数的特征。

下面是对应于每个聚类中前 15 个单词的三个图，按照 TF-IDF 测量的相对重要性排序。

Figure 3: Cluster 0

Figure 4: Cluster 1

Figure 5: Cluster 2

好吧，那么这些数字想告诉我们什么呢？这里有什么有趣的特色吗？总的来说， 集群 0 似乎有不少可能相当重要的人的名字。我们可以立即开始查看来自莎莉、约翰和埃里克的电子邮件，看看是否有什么有趣的内容。 集群 1 似乎一般是关于具有主席、日历和时间等特征的会议。同样，这对于缩小我们想要进一步检查的电子邮件的范围非常有用。 Cluster 2 似乎有很多词语暗示这些电子邮件来自请求东西的人。虽然从表面上看，这并不立即有趣，但也值得进一步研究。下面是 Kmeans 类的完整 Python 代码。

Kmeans 类的完整代码

一些需要记住的事情

现在应该很清楚，k-means 是一个简单而强大的算法，它对于分析中可能出现的许多不同类型的问题非常有用。也就是说，对于你的特定问题来说，它可能并不总是最好的选择，如果你要使用它，你需要知道算法的一些假设。大概 k-means 最大的假设和限制就是它假设 簇是球形的。如果事实并非如此，那么 k-means 可能不是最佳解决方案。k-means 算法的另一个限制是数据点被 【硬分配】 到一个聚类。换句话说，数据点要么在集群中，要么不在集群中。当然，我们对某些数据点在一个集群中比其他数据点更有信心？如果我们能以某种方式将这种信心融入到我们的结果中，不是更好吗？

幸运的是，我们可以使用另一种技术来解决这些问题。我们可以使用一种叫做 高斯混合建模或者GMM 的算法。这样做的好处是，我们以软分配结束，即每个数据点以一定的概率属于每个聚类。除此之外，GMM 还对聚类的方差做出了限制性稍小的假设。缺点是这是一个更复杂的算法，但这是我想在另一篇文章中进一步讨论的。

好了，就这样了，伙计们，感谢阅读。希望这已经让你很好地理解了 K 均值以及如何在 Python 中完全实现它。我们可以在代码中实现一些额外的功能，如 智能初始化(k-means++) 或算法的更好的收敛计算，但我在这里没有做这些。你们试一下怎么样？如果你想了解良好的编码实践，我认为一个很好的起点是 sklearn 的 GitHub。已经实现了大量的算法，并且它们都经过了数据科学社区的尝试和测试，所以我鼓励人们看一看，并尝试自己实现其中的一些算法。这是一种很好的学习方式。

链接到 Kaggle 内核:https://www . ka ggle . com/d foly 1/k-means-clustering-from-scratch

来源:Christopher m . Bishop 2006，模式识别与机器学习

来源: 机器学习的贝叶斯方法

注意:这篇文章中的一些链接是附属链接

K-Means 使用 Scikit-Learn & NLTK 对 Chardonnay 评论进行聚类

原文：https://towardsdatascience.com/k-means-clustering-chardonnay-reviews-using-scikit-learn-nltk-9df3c59527f3?source=collection_archive---------17-----------------------

霞多丽是世界上最受欢迎的白葡萄酒。这种葡萄很容易种植，它以复杂和适应不同的技术和口味而闻名。例如，昨晚我尝了一种甜味的未发酵的夏敦埃酒。霞多丽到底有多受欢迎？正如 2018 年加州葡萄种植面积报告所述，在 176，092 英亩专用于白葡萄酒的总面积中，霞多丽消耗了一半以上，为 93，148 英亩！下一个最高的品种是法国科隆巴德，消耗 18246 英亩；相比之下微不足道。那是许多葡萄！

S 因为我熟悉 kaggle 上的葡萄酒评论数据集，所以我决定加载一个笔记本来分析夏敦埃酒。

聚类能帮助我们确定描述和评级之间的关系吗？

在本文中，我将展示如何使用 Scikit-Learn 和自然语言工具包来处理、分析和聚类 Chardonnay 数据。通过使用这些技术，我希望能看到评分高于平均水平的葡萄酒评论和评分低于平均水平的葡萄酒评论在主题或话题上是否有所不同。

导入依赖项和数据

因为这篇文章结合了几种技术来分析 Chardonnay 评论，所以我们有相当多的东西要导入。此外，我对数据集做了一些初步清理，删除了重复和空值，并将其存储在 SQLite 数据库中:

#import dependencies
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import refrom sklearn import preprocessing, decomposition, model_selection, metrics, pipeline
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
from sklearn.cluster import KMeansimport nltk
from nltk.stem.wordnet import WordNetLemmatizer
from nltk.corpus import stopwordsimport sqlite3
from sqlite3 import Error#force output to display the full description
pd.set_option('display.max_colwidth', -1)#connect to database file
conn = sqlite3.connect('db\wine_data.sqlite')
c = conn.cursor()#create dataframe from sql query
df = pd.read_sql("Select country, description, rating, price, title, variety from wine_data where variety = 'Chardonnay'", conn)#display the top 3 rows
df.head(3)

特征工程和分析

从一开始，我就知道我想添加几个特性:首先，我将添加字数统计列来存储每个描述中的字数。其次，我将添加一个二进制字段来表示葡萄酒的评级是否高于平均水平。在我添加这些功能之前，我需要做一些分析来找到平均评级。

分析字数

分析字数可以帮助您决定是否要缩减数据集。例如，查看数据，我们看到一篇葡萄酒评论的最小字数是 3 个词。查看少于 15 个单词的评论，平均评分是 82 分，范围是 80-100 分。这告诉我，简短的评论可能与较低的评级有关。同样，当我观察分布的另一端时，我注意到较长的评论可能与较高的评级相关。

简短的评论可能与较低的评级相关联。更长的评论可能与更高的评级相关联。

#add a column for the word count
df['word_count'] = df['description'].apply(lambda x: len(str(x).split(" ")))print("Word Count Median: " + str(df['word_count'].median()))
print(df['word_count'].describe())x = df['word_count']
n_bins = 95plt.hist(x, bins=n_bins)
plt.xlabel('Number of Words in Description')
plt.ylabel('Frequency')
plt.show()

#word counts less than 15
wc15 = df.loc[df['word_count'] < 15]
print(wc15.rating.median())
print(wc15.rating.describe())#word counts greater than 70
wc70 = df.loc[df['word_count'] > 70]
print(wc70.rating.median())
print(wc70.rating.describe())#plot the counts
plt.figure(figsize=(14,4))
sns.countplot(x ='rating', data = wc70).set_title("Rating Counts")

数据可以可视化，帮助我们看到字数和评分之间的关系。

Rating Counts where Word_Count < 15

Rating Counts where Word_Count > 70

分析评级

因为我想看看描述是否可以用来区分葡萄酒是否高于平均评级，所以我必须找到平均评级。熊猫描述功能使统计数据的查找变得简单。看数据，我们得到的平均评分是 88。使用 list comprehension 很容易将二进制值列添加到数据框中。如果评分大于 88，我们的新列将为 1。如果等级为 88 或更低，值将为 0，因为葡萄酒并不比平均水平好。

如果评分大于 88，我们的新列将为 1。如果等级为 88 或更低，值将为 0，因为葡萄酒并不比平均水平好。

print("Number of Unique Ratings: " + str(len(df['rating'].unique())))print("Rating Median: " + str(df['rating'].median()))
print(df['rating'].describe())plt.figure(figsize=(14,4))
sns.countplot(x='rating', data=df).set_title("Rating Counts")
plt.show()#add column to flag records with rating greater than 88
df['above_avg'] = [1 if rating > 88 else 0 for rating in df['rating']]

Distribution of Chardonnay Ratings

自然语言处理

在对数据进行聚类之前，我使用了几种 NLP 技术，比如删除停用词、标点符号和特殊字符，以及对文本进行规范化。处理完文本后，我将使用 Scikit-Learn tf-idf 矢量器对文本进行矢量化。

清理文本

在聚类之前，我想删除停用词。停用词是常见的词，如“the”和“of”将它们从描述中移除可以突出更相关的常用词。我通过词频来判断是否应该将额外的词添加到停用词表中。此外，我使用正则表达式清理描述，删除标点符号、标签和特殊字符，然后对单词进行词汇化，将单词简化为词根形式，同时保持它是一个真实的单词。词条满足是一种规范化文本的技术:

#create a list of stop words
stop_words = set(stopwords.words("english"))#show how many words are in the list of stop words
print(len(stop_words))
#179#construct a new list to store the cleaned text
clean_desc = []
for w in range(len(df.description)):
    desc = df['description'][w].lower()

    #remove punctuation
    desc = re.sub('[^a-zA-Z]', ' ', desc)

    #remove tags
    desc = re.sub("&lt;/?.*?&gt;"," &lt;&gt; ",desc)

    #remove special characters and digits
    desc = re.sub("(\\d|\\W)+"," ",desc)

    split_text = desc.split()

    #Lemmatisation
    lem = WordNetLemmatizer()
    split_text = [lem.lemmatize(word) for word in split_text if not word in stop_words and len(word) >2] 
    split_text = " ".join(split_text)
    clean_desc.append(split_text)

使用 TF-IDF 对文本进行矢量化

tfidf vector 将文本转换成一个向量空间。为了简化概念，假设你有两个句子:

狗是白色的，猫是黑色的

将句子转换为向量空间模型会以这样的方式转换它们，即查看所有句子中的单词，然后用数字表示句子中的单词。例如，如果单词在句子中，它就是 1。如果该单词不在句子中，则用 0 表示:

狗是白色的猫是黑色的狗是白色的猫是黑色的

TF-IDF 代表词频-逆文档频率。这是一种对单词值进行加权而不是简单计数的方法。它用于确定一个单词对集合文档中的文本有多重要。该功能对于搜索引擎和文本挖掘等信息检索非常有用。Scikit-Learn 中的tfidf 矢量器将一组原始文档转换成 TF-IDF 特征矩阵。它使用 fit_transform 方法返回矩阵。

#TF-IDF vectorizer
tfv = TfidfVectorizer(stop_words = stop_words, ngram_range = (1,1))#transform
vec_text = tfv.fit_transform(clean_desc)#returns a list of words.
words = tfv.get_feature_names()

基于 K-均值聚类的主题抽取

K-means 聚类是一种流行的无监督学习算法，可用于通过将相似的评论分组在一起并产生常用词列表来提取主题。我将试着把数据分成 21 组(n_clusters = 21 ),看看我是否能发现在高评分中常见的主题和在低评分中常见的主题。 Scikit-Learn 使 k-means 的应用变得简单。

#setup kmeans clustering
kmeans = KMeans(n_clusters = 21, n_init = 17, n_jobs = -1, tol = 0.01, max_iter = 200)#fit the data 
kmeans.fit(vec_text)#this loop transforms the numbers back into words
common_words = kmeans.cluster_centers_.argsort()[:,-1:-11:-1]
for num, centroid in enumerate(common_words):
    print(str(num) + ' : ' + ', '.join(words[word] for word in centroid))

将结果可视化

使用热图，我可以看到评级是如何聚集的。我还可以看到高于平均水平的评级与低于平均水平或低于平均水平的评级相比是否聚集在一起。

#add the cluster label to the data frame
df['cluster'] = kmeans.labels_clusters = df.groupby(['cluster', 'rating']).size()fig, ax1 = plt.subplots(figsize = (26, 15))
sns.heatmap(clusters.unstack(level = 'rating'), ax = ax1, cmap = 'Reds')ax1.set_xlabel('rating').set_size(18)
ax1.set_ylabel('cluster').set_size(18)clusters = df.groupby(['cluster', 'above_avg']).size()
fig2, ax2 = plt.subplots(figsize = (30, 15))
sns.heatmap(clusters.unstack(level = 'above_avg'), ax = ax2, cmap="Reds")ax2.set_xlabel('Above Average Rating').set_size(18)
ax2.set_ylabel('Cluster').set_size(18)

我可以通过分割数据框和绘制聚类数来查看分布情况！

#create dataframe of reviews not above average
not_above = df.loc[df['above_avg'] == 0]
not_above.describe()#create data frame of reviews above average
above_avg = df.loc[df['above_avg'] == 1]
above_avg.describe()#plot the counts
plt.figure(figsize=(14,4))
sns.countplot(x='cluster', data=not_above).set_title("Rating Counts")
plt.show()plt.figure(figsize=(14,4))
sns.countplot(x='cluster', data=above_avg).set_title("Rating Counts")
plt.show()

Not Above stats v.s. Above Average stats

最后的想法和笔记本

观察可视化结果，他们显示高于平均水平的评分更多地集中在 5、6 和 12。这意味着这些聚类中的单词在高于平均评级的葡萄酒评论中被普遍使用。需要更深入地查看聚类中的单词，因为仅查看前 10 个单词时很难区分显著差异。例如,“苹果”、“香气”和“味道”等词出现在几个分组中，这使得人们很难理解不同的主题。此外，有不同的算法可能在主题建模方面表现更好。

潜在狄利克雷分配(LDA) 是另一种流行的无监督学习算法，用于主题建模，其性能优于 K-means。希望我能有机会探索 LDA 并比较我的结果。

你可以从我的 github repo 下载我的笔记本:

[## bendgame/kmeansChardonnay

此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…

github.com](https://github.com/bendgame/kmeansChardonnay)

谢谢大家！

如果你喜欢这个， 跟我上 Medium 了解更多
通过订阅 获得完全访问权限并帮助支持我的内容
我们来连线一下LinkedIn
用 Python 分析数据？查看我的 网站

—埃里克·克莱本

k-均值聚类与数学

原文：https://towardsdatascience.com/k-means-clustering-for-beginners-2dc7b2994a4?source=collection_archive---------1-----------------------

用于数据分析的常见无监督学习技术

Photo by Perry Grone on Unsplash

当我们处理大量数据时，将数据分成逻辑组并进行分析是有意义的。我们可以在 K-Means 等算法的帮助下，使用聚类将数据分组。

在这篇文章中，我将尝试解决

a.使聚集

b.k-均值和算法的工作原理。

c.选择正确的 K 值

使聚集

将对象组织成组的过程，使得同一组中的数据点与同一组中的数据点相似。聚类是对象的集合，其中这些对象与另一个聚类相似和不相似。

k 均值

K-Means 聚类是一种无监督学习。该算法的主要目标是在数据中寻找组，组的数量由 K 表示。这是一个迭代过程，其中每个数据点基于特征相似性被分配到 K 个组中的一个。

算法

K-Means 算法从 K 个质心的初始估计开始，这些质心是从数据集中随机选择的。该算法在两个步骤分配数据点和更新质心之间迭代。

数据分配

在该步骤中，基于平方欧几里德距离，将数据点分配给其最近的质心。让我们假设一个以 c 为质心的聚类，并根据 c，x 之间的距离将数据点 x 分配给该聚类。还有一些其他的距离度量，如曼哈顿、雅克卡和余弦，它们是根据适当的数据类型使用的。

质心更新

通过取分配给特定聚类的所有数据点的平均值来重新计算质心。

image by George Seif

让我们用下面的例子来完成上面的步骤。

考虑如下 4 个数据点 A、B、C、D

Observations

2.选择两个质心 AB 和 CD，计算如下

AB =，B 的平均值

CD =、D 的平均值

Two centroids AB, CD

3.计算所有数据点到质心 AB，CD 的平方欧几里得距离。例如，A(2，3)和 AB (4，2)之间的距离可以由 s =(2–4)+(3–2)给出。

A is very near to CD than AB

4.如果我们在图中观察，突出显示的(A，CD)之间的距离是 4，小于(AB，A)的距离 5。由于点 A 靠近 CD，我们可以将 A 移动到 CD 簇。

5.到目前为止已经形成了两个集群，让我们像步骤 2 一样重新计算质心，即 B，ACD。

ACD =、C、D 的平均值

B = B

New centroids B, ACD

6.我们知道 K-Means 是迭代过程，现在我们必须计算所有点(A，B，C，D)到新质心(B，ACD)的距离，类似于步骤 3。

Clusters B, ACD

7.在上图中，我们可以看到各自的聚类值最小，即 A 离聚类 B 太远而离聚类 ACD 近。所有数据点根据它们的最小距离被分配到聚类(B，ACD)。迭代过程到此结束。

8.总之，我们从两个质心开始，以两个集群结束，K=2。

选择 K

选择 K 值的一种方法是肘法。在此方法中，我们将对 K 值范围(K= 1 到 10)运行 K 均值聚类，并计算误差平方和(SSE)。SSE 计算为数据点与其聚类质心之间的平均距离。

然后为每个 K 的 SSE 值绘制一个折线图，如果折线图看起来像一只手臂，那么手臂上的肘部就是最佳的 K 值。

Choose the Best K

希望你喜欢！！请对任何疑问或建议发表评论。

用于无监督机器学习的 k-均值聚类

原文：https://towardsdatascience.com/k-means-clustering-for-unsupervised-machine-learning-afd96fbd37ac?source=collection_archive---------10-----------------------

无监督学习的 Pythonic 指南

Photo by Ramón Salinero on Unsplash

与人类历史上的任何其他技术不同，人工智能(AI)和机器学习(ML)彻底改变了我们生活的方方面面，并扰乱了我们做生意的方式。这种破坏给专业人士和企业带来了许多挑战。在本文中，我将介绍一种最常用的机器学习方法， K-Means。

首先:到底什么是机器学习(ML)？！这是一种新的模式吗？

机器学习是一种科学方法，它利用统计方法和机器的计算能力将数据转换为人类或机器本身可以用来采取特定行动的智慧。“它是 人工智能 的一个分支，基于系统可以从数据中学习、识别模式并在最少人工干预的情况下做出决策的想法。” (SaS)

如果你认为人工智能是一种新的范式，你应该知道机器学习这个名字是亚瑟·塞缪尔在 1959 年创造的。然而，这发生在 20 世纪 50 年代艾伦·图灵的一个提议之后，他用“机器能思考吗？”机器能做我们(作为思维实体)能做的事情吗？，或者换句话说，“机器能学习吗？”

所以，ML 已经存在半个世纪了。然而，随着最近机器计算能力的进步，以及我们正在生成、收集和存储的大量数据，ML 已经成为许多行业的下一个大事件。

机器学习的主要领域有哪些？

ML 中有许多字段，但我们可以将三个主要字段命名为:

监督学习(SL): SL 是使用一组输入(预测器)和期望输出(目标)来建立和训练 ML 模型。许多回归(简单或多元)或分类模型都属于这一类。

无监督学习(UL): 当目标未知时，使用 UL，目标是推断数据中的模式或趋势，从而做出决策，或者有时将问题转化为 SL 问题(也称为迁移学习，TL )。这篇文章的重点是 UL 聚类，特别是 K-Means 方法。

强化学习(RL) : 这种范式比 SL 和 UL 更复杂，然而这篇文章提供了 RL 的一个简单而技术性的定义。一般来说，RL 关注的是“主体”(例如模型)如何在环境中采取行动，并且在每个步骤中试图最大化回报(例如优化函数)。RL 的一个很好的例子是使用遗传算法和蛮力的路由优化(在后面的文章中会有更多的介绍)。

阿卜杜勒·瓦希德的下图很好地展示了曼梯·里的这些主要领域。

From https://www.slideshare.net/awahid/big-data-and-machine-learning-for-businesses, Credit: Abdul Wahid

k-均值聚类，已定义

k-均值聚类是一种来自信号处理的方法，目的是将观测值放入 k 个聚类中，其中每个观测值属于一个具有最近均值的聚类。这些簇在数学上也被称为 Voronoi 细胞。

在进入 Python 代码的细节之前，让我们看一下 K-Means 聚类的基础。

K-Means 如何对观察值进行聚类？

聚类算法的主要输入是聚类的数量(这里称为 k )。 k 决定集群机制，以及集群如何形成。在你知道哪一个应该属于一个聚类之前，想出聚类的数量可能是具有挑战性的，尤其是因为你正在处理一个无监督的学习问题。

还有其他无监督学习方法来确定 K-Means 聚类方法的正确聚类数，包括 分层聚类 ，，但我们在本文中不涉及该主题。我们的假设是您知道集群的数量，或者对集群的正确数量有一个大致的概念。最好的方法是进行几次试错，以找到最佳的聚类数。

一旦知道了聚类的数量，就有三种不同的方法来指定聚类中心:

手动，
随机地，而且
“k-在 SKLearn 中的意思是++

后者以一种智能的方式为 k-mean 聚类选择初始聚类中心以加速收敛。你可以在这里找到更多。

应当注意，初始聚类中心对最终聚类结果没有任何影响，原因将在下面解释。给定初始聚类中心，该算法重复以下步骤，直到它收敛:

Illustration of K-Means Algorithm, Wikipedia Creative Commons, credit: Chire

分配步骤:将每个观察值分配给其平均值具有最小平方欧几里德距离的组，这是直观的“最近”平均值。
更新步骤:计算新聚类中观测值的新均值(质心)。
检查收敛:当分配不再改变时，算法假定收敛。

需要记住的一点是，K-Means 几乎总是收敛的，但不能保证找到最优解，因为它在局部最小值处终止循环，可能不会达到全局最小状态。

好吧！算法说够了。让我们进入令人兴奋的部分，也就是 Python 代码。

关于 K-均值数据缩放的注记

由于 K-Means 基于数据点到聚类中心的距离工作，因此将数据缩放到相同的比例对于结果的准确性至关重要。

Python 中的 K-Means

为此，我们将使用 SciKit Learn 库。你可以在这里阅读 K-Means 聚类包的文档。

让我们先导入包。

import numpy as np
import matplotlib.pyplot as pltfrom sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

为了说明这个算法是如何工作的，我们将使用sklearn.datasets.中的make_blob包。下面的代码片段将生成 5 个集群。在我们的聚类中，我们将不使用聚类名称(y)。

# Create 5 blobs of 2,000 random data
n_samples = 2000
random_state = 42
X, y = make_blobs(n_samples=n_samples, 
                  random_state=random_state, 
                  centers=5)

让我们可视化集群，看看他们在哪里。

# Plot the random blub dataplt.figure(figsize=(6, 6))plt.scatter(X[:, 0], X[:, 1], s=5)
plt.title(f"No Clusters Assigned")

观察这些斑点，我们可以看到我们有三个不同的“区域”，由 5 个斑点组成:

左下角有一个斑点，
在左上区域中有两个彼此大致邻近的斑点，并且
在中间右区有两个几乎重叠的斑点。

让我们看看 K-Means 聚类如何处理这个问题。我们将查看不同的集群编号，从 1 到 10。下面提供了代码，生成的图形放在下面的动画中。

# Plot the data and color code based on clusters# changing the number of clusters 
for i in range(1,11):
    plt.figure(figsize=(6, 6))

    # Predicting the clusters
    y_pred = KMeans(n_clusters=i, random_state=random_state).fit_predict(X)# plotting the clusters
    plt.scatter(X[:, 0], X[:, 1], c=y_pred, s=5)
    plt.title(f"Number of Clusters: {i}")plt.show();

动画情节是用Image.Io包制作的。有关这方面的更多信息，请参考 Johannes Huessy 博客(点击此处)。

评估 K-Means 聚类算法

所以你已经完成了聚类，但是这个聚类有多好，你如何衡量算法的性能？

惯性:我们在上一节中讨论了一个度量，即到聚类中心的距离的类内平方和。这就是所谓的惯性。该算法旨在选择使、惯性最小化的质心，其中、可以被识别为内部一致性聚类如何的度量。

您可以使用下面的代码来获得集群的inertia分数:

km = KMeans(n_clusters=i, random_state=random_state)
km.fit(X)
km.inertia_

下面的代码计算了我们之前所做的 10 个不同聚类数的inertia分数，并将它们保存在一个列表中，我们将使用该列表进行绘制(稍后将详细介绍)。惯性分数对聚类数的作图称为“ 肘形曲线 ”。

剪影评分:剪影评分是基于聚类(聚类中的点相对于彼此有多近)和分离 (聚类相对于彼此有多远)的组合。

剪影得分在-1(聚类差)和+1(聚类优)之间。

惯性

*# Calculating the inertia and silhouette_score¶inertia = []
sil = []# changing the number of clusters 
for k in range(2,11):

    km = KMeans(n_clusters=k, random_state=random_state)
    km.fit(X)
    y_pred = km.predict(X)

    inertia.append((k, km.inertia_))
    sil.append((k, silhouette_score(X, y_pred)))*

现在我们有了惯性和轮廓分数，让我们绘制它们并评估聚类算法的性能。

*fig, ax = plt.subplots(1,2, figsize=(12,4))# Plotting Elbow Curve
x_iner = [x[0] for x in inertia]
y_iner  = [x[1] for x in inertia]
ax[0].plot(x_iner, y_iner)
ax[0].set_xlabel('Number of Clusters')
ax[0].set_ylabel('Intertia')
ax[0].set_title('Elbow Curve')# Plotting Silhouetter Score
x_sil = [x[0] for x in sil]
y_sil  = [x[1] for x in sil]
ax[1].plot(x_sil, y_sil)
ax[1].set_xlabel('Number of Clusters')
ax[1].set_ylabel('Silhouetter Score')
ax[1].set_title('Silhouetter Score Curve')*

你可以看到，当你增加集群的数量时，惯性得分总是下降。然而，肘曲线可以告诉你以上 4 个集群，惯性的变化并不显著。现在，让我们看看轮廓曲线。您可以看到，最大得分发生在 4 个聚类处(轮廓得分越高，聚类越好)。

将肘部曲线与轮廓得分曲线结合起来，可以提供对 K-Means 性能的宝贵见解。

K 均值的其他用例

K-Means 方法有很多用例，从图像矢量化到文本文档聚类。你可以在这里找到一些例子。

我希望您发现本指南有助于理解使用 Python 的 SkLearn 包的 K-Means 聚类方法。请继续关注更多类似的话题！

尼克·米奈博士 ( 领英简介 )是一位资深顾问和富有远见的数据科学家，代表了领导技能、世界级数据科学专业知识、商业敏锐度和领导组织变革能力的独特组合。他的使命是推进人工智能(AI)和机器学习在行业中的实践。

如何在 BigQuery ML 中做好 k-Means 聚类初始化

原文：https://towardsdatascience.com/k-means-clustering-in-bigquery-now-does-better-initialization-3d7e7567bad3?source=collection_archive---------24-----------------------

使用并行 k-Means++初始化选项

BigQuery ML 支持无监督学习—您可以应用 k-Means 算法将您的数据分组到聚类中。正如我在之前的博客文章中所描述的，你可以使用聚类来理解你的数据，以便做出数据驱动的决策。在 BigQuery 中，现在有一个更好的初始化算法可用于 k-Means，在这篇博客中，我将解释这个新的初始化算法做什么，以及为什么它是有益的。

BigQuery 中的 k-均值聚类

但首先，让我们从如何在 BigQuery ML 中使用 k-Means 开始。举个例子，让我们使用爱荷华州的公共酒类销售数据集，并根据 2018 年的销售特征对商店进行聚类。首先，我们使用以下方法提取每个商店的数据:

SELECT 
 store_number
 , AVG(SAFE_DIVIDE(state_bottle_retail - state_bottle_cost, state_bottle_cost)) AS profitability
 , SUM(bottles_sold) AS bottles_sold
 , SUM(sale_dollars) AS sale_dollars
 , SUM(volume_sold_liters) AS volume_sold
FROM `bigquery-public-data`.iowa_liquor_sales.sales
WHERE EXTRACT(YEAR from date) = 2018
GROUP BY store_number

这给了我们这样的数据:

Sales characteristics of liquor stores in Iowa

要基于商店对这些数据进行聚类，我们只需创建一个模型，注意从功能列表中排除 store_number:

CREATE OR REPLACE MODEL demos.iowa_store_clusters
OPTIONS(model_type='kmeans', num_clusters=4, standardize_features = true) ASWITH data AS (
SELECT 
 store_number
 , AVG(SAFE_DIVIDE(state_bottle_retail - state_bottle_cost, state_bottle_cost)) AS profitability
 , SUM(bottles_sold) AS bottles_sold
 , SUM(sale_dollars) AS sale_dollars
 , SUM(volume_sold_liters) AS volume_sold
FROM `bigquery-public-data.iowa_liquor_sales.sales`
WHERE EXTRACT(YEAR from date) = 2018
GROUP BY store_number
)SELECT * EXCEPT(store_number) FROM data

在选项中，我指定了所需的聚类数，并告诉算法标准化这些特征。这一点很重要，因为我们的功能范围变化很大(从盈利能力的 0–1 到销售额的 10E6)。默认情况下，BigQuery ML 对 k-Means 输入特性进行了标准化，但是加倍确保没有坏处！！

BigQuery 控制台中的 evaluation 选项卡向我们显示了生成的集群(您的结果可能会有所不同，原因我将在本文后面解释):

The four types of liquor stores in Iowa

集群之间的盈利能力没有变化(也许州法律规定了价格？).很明显，就销售额而言，集群#1 是高销量集群，集群#4 是下一层商店。分类#2 和分类#3 似乎具有相似的销售量，但是分类#3 中的销售包括较小的瓶子(因此，销售了更多的瓶子),这导致了更大的销售额。

该培训耗时约 30 秒，分七次迭代完成:

重复…

只是笑一笑，让我试着再做一次查询。这一次，大约花了一分钟:

结果有所不同，不如以前好:

原因是 K-Means 默认的初始化方法是在随机的起始点播种聚类。你得到的聚类质量取决于起点，在这种情况下，起点不如以前好。

为什么我们需要更好的初始化

具体来说，随机初始化会导致两个问题。如果初始种子恰好很好(见下面的绿框)，收敛会很快。但是如果起点碰巧是坏的(见下面的红框)，收敛可能需要更长的时间。

Convergence time depends on the starting point

其次，K-Means 很可能会陷入局部最小值，永远找不到好的解决方案(见下文，其中左上的聚类分成两个，右下的两个聚类合并成一个):

Bad initialization can also lead to k-Means being trapped in a local minimum

已经有很多关于如何分配初始起始种子的研究，使得它们以一种导致快速收敛并且不导致陷入局部最小值的方式覆盖输入空间。

k-表示++的意思

BigQuery 现在实现了并行 k-Means++算法。简单来说，算法首先选择一个种子点。然后，为了选择下一个种子点，它对这些点进行随机采样，距离现有种子点越远的点被选择的概率越高。其中 k-Means++简单地选择第一个这样的随机采样点(因此需要 k 遍数据)，并行 k-Means++将这种选择并行化，基于加权函数对所选的点进行聚类，并在单次拍摄中完成这一操作。由 k-Means++选择的种子点(以及并行的 k-Means++)可以证明是接近最优的。

The parallel k-Means++ algorithm that you can tell BigQuery ML to use. The algorithm (and screenshot) is from a paper by Bahmani et. al: https://theory.stanford.edu/~sergei/papers/vldb12-kmpar.pdf

虽然初始化需要更长的时间，但收敛通常更快，结果也更好。在爱荷华商店数据上尝试:

CREATE OR REPLACE MODEL demos.iowa_store_clusters
OPTIONS(model_type='kmeans', 
        num_clusters = 4,
        **kmeans_init_method = 'KMEANS++',**
        standardize_features = true) ASWITH data AS (
SELECT 
 store_number
 , AVG(SAFE_DIVIDE(state_bottle_retail - state_bottle_cost, state_bottle_cost)) AS profitability
 , SUM(bottles_sold) AS bottles_sold
 , SUM(sale_dollars) AS sale_dollars
 , SUM(volume_sold_liters) AS volume_sold
FROM `bigquery-public-data.iowa_liquor_sales.sales`
WHERE EXTRACT(YEAR from date) = 2018
GROUP BY store_number
)SELECT * EXCEPT(store_number) FROM data

真的更好

我只用了三次迭代就实现了融合:

With k-Means++, convergence is twice as fast.

产生的集群甚至比我们之前的集群更好:

The four clusters now

请注意，在所有考虑的要素上，聚类之间的差异有多大，以及两个异常值存储是如何被划分到一个单独的聚类中的，无论它们是否影响其他聚类的聚类均值。这也体现在戴维斯-波尔丁指数中(现在是 0.6，而以前是 1.1)。

这也是相当可重复的——当我再次尝试时，我得到了类似的(不确切，因为随机种子)结果:

SAS 中的 k-均值聚类

原文：https://towardsdatascience.com/k-means-clustering-in-sas-9d19efd4fb1b?source=collection_archive---------2-----------------------

什么是聚类？

“聚类是将数据集分成由相似数据点组成的组的过程”。聚类是一种无监督的机器学习，当您有未标记的数据时使用。

让我们理解在真实的场景中，

坐在餐馆里的一群食客。让我们假设餐馆里的两张桌子叫做 T1 和 T2。表 T1 中的人可能彼此相关，或者可能是一组家庭成员或同事或任何其他人。

Group of diners

同样，T2 餐桌上的人们可能是彼此相关的，或者可能是一组同事或任何东西。但是，当比较坐在 T1 桌的人和坐在 T2 桌的人时，他们是完全不同的，彼此没有任何联系。

集群也以同样的方式工作。一个群集中的数据点与另一个群集中的数据点完全不同。同一聚类中的所有点要么相同，要么彼此相关。

另一个很好的例子是网飞电影推荐。

Netflix movie recommendation

网飞根据用户的观看历史推荐电影。无论人们看什么；与之相关的类似电影也会上映。聚类算法生成所有这些推荐列表。

聚类可用于分割和许多其他应用。它有不同的技术。K -Means 聚类是最流行、最简单和最有趣的算法之一。

什么是 K 均值聚类？

K-Means 是一种聚类算法，其主要目标是将相似的元素或数据点分组到一个聚类中。K-means 中的“K”代表簇的个数。

K-means 聚类步骤:

距离度量将确定两个元素之间的相似性，并且它将影响聚类的形状。通常，欧几里德距离将用于 K-均值聚类

欧几里得距离是“普通的”直线。它是欧几里得空间中两点之间的距离。

K-Means 算法是如何工作的？

我们来看两个数据点。假设 K =2。然后，它将在数据中的任意位置取两个随机质心，并以此为基础在中间画一条线。一个质心用红色表示，另一个用黄色表示。那么所有数据都指向分类为黄色的黄色质心。所有数据都指向分类为红色的红色质心。这是第一个迭代步骤。

下一步，使用欧几里德方法计算从质心到数据点的距离。并且通过计算所有点的平均值，红色和黄色质心点都移动到新点中。

同样，它在新的质心点之间绘制一条新的线。自动地，所有落向红色质心的点将被识别为红色组，而黄色质心将被识别为黄色组。

同样的步骤将重复新的点，它将计算新的质心。我们可以清楚地看到数据点已经被移动到不同的组中。

它继续下去，直到质心运动变得几乎可以忽略不计。然后，它变成集群 1 和集群 2。这里，输出 Y 标签将给出 0 和 1。0 表示聚类 1，1 表示聚类 2。如果是三个集群，那么它给出 0，1，2。

SAS 中的 K-均值聚类

让我们看一个著名的虹膜数据集。使用 proc 方法检查数据集

/* Checking the contents of the datasets */**proc** **means** data=work.iris N Nmiss mean median max min;**run**;

它有 150 个观察值和 5 个变量。未检测到缺失值或异常值。我们将只使用四个变量，即萼片长度、萼片宽度、花瓣长度和花瓣宽度。“cm”中的数据集。“Target”变量可以删除，因为它是一个类别变量。

关于鸢尾花数据集的小介绍。这是一个多元数据集，由英国统计学家和生物学家罗纳德·费雪在 1936 年为他的研究论文引入。下图是关于萼片和花瓣的。

在分析数据集之前先了解它会很有意思。

/* Dropping the variable target and stored the dataset in the name of IRIS1 */**data** iris1; set work.iris; drop target;**run**;

在运行聚类分析之前，我们需要将所有的分析变量(实数变量)标准化到平均值为零，标准差为一(转换为 z 分数)。在这里，我们的数据集已经标准化了。

/* Perfoming Cluster Analysis */ods graphics on;**proc** **cluster** data = iris1 method = centroid ccc print=**15** outtree=Tree;var sepal_length--petal_width;**run**;ods graphics off;

METHOD = > 规范决定了过程使用的聚类方法。这里，我们使用的是质心方法。

CCC——立方聚类准则——有助于找出最佳聚类点。

需要找出最佳的集群。

前三个特征值约占总方差的 99.48%，因此，建议采用三个聚类。但是，可以在 ccc 图中交叉检查。

如果我们从集群历史中看到，有 15 个观察值(如我们在代码中给出的= 15)

从上面的 CCC 图可以看出，肘在三点下降了。因此，最佳聚类将是 3。“在 Python 中的 Elbow 方法中可以找到最佳聚类”

为了将 150 个观察值中的每个观察值分成三组，我们可以使用 proc tree。ncl = 3(我们的最佳聚类是 3)。

/* Retaining 3 clusters */**proc** **tree** noprint ncl=**3** out=out;copy sepal_length--petal_width;**run**;

150 次观察分为三组。

使用 proc candisc 和 proc sgplot 创建散点图

/* To create a Scatterplot */**proc** **candisc** out = can;class cluster;var petal_width: sepal_length:;**run**;**proc** **sgplot** data = can;title "Cluster Analysis for IRIS datasets";scatter y = can2 x = can1 / group = cluster;**run**;

我们可以看到，我们的分析清楚地分为三类。聚类 1 是蓝色的，聚类 2 是红色的，聚类 3 是绿色的。

K-means 聚类的优缺点

优势:

1)实际上工作良好，即使一些假设被打破。

2)简单，易于实现。

3)易于解释聚类结果。

4)在计算成本方面快速有效。

劣势:

1)均匀效应通常产生具有相对均匀大小的聚类，即使输入数据具有不同的聚类大小。

2)不同的密度对于集群可能效果不佳。

3)对异常值敏感。

K 值需要在 K-means 聚类之前知道。

我的 GIT 里有完整的 SAS 代码【https://github.com/sdhilip200/IRIS-datasets

如果您发现任何错误或需要改进的地方，请不吝赐教。

k-均值聚类:推荐系统的无监督学习

原文：https://towardsdatascience.com/k-means-clustering-unsupervised-learning-for-recommender-systems-397d3790f90f?source=collection_archive---------7-----------------------

Your brain on Unsupervised Learning. Source: Pixabay.

在一般人工智能的意义上，无监督学习被称为最接近“实际”人工智能的东西，K-Means 聚类是其最简单但最强大的应用之一。

我在这里不是要讨论这些说法是真是假，因为我既不是专家也不是哲学家。然而，我会说，我经常惊讶于无监督学习技术，即使是最基本的，在数据中捕捉模式的能力有多强，而我本以为只有人才能发现这些模式。

今天我们将在我自己收集的数据集上应用无监督学习。这是一个专业魔术的数据库:我从mtgtop8.com 爬上来的聚会平台，如果你喜欢魔术，这是一个很棒的网站:聚会。

我从几年的比赛中收集了MTG top 8 数据，它们都可以在这个 GitHub 库中使用。

如果你不喜欢这个游戏，或者甚至你从来没有玩过它，不要担心:它不会太碍事，因为我将解释 K-means 聚类的理论方面，并向你展示如何使用 Dask 来应用它。如果你喜欢这个游戏，那么你会喜欢这些例子的。

k 均值聚类

我们今天要研究的算法叫做“K 均值聚类”。如果我们事先不知道如何分离数据，它提供了一种表征和分类数据的方法。

为什么我们需要无监督学习？

我说的无监督学习是什么意思？假设你有一组猫和狗的照片。你可以训练一个监督机器学习模型来将图片分类。

然而，想象一下，你有一个庞大而复杂的数据集，里面有你不太了解的东西。例如，你可能有关于不同行星产生的光谱的数据，并且正在寻找一种方法将它们分类。

再举一个例子，您可能有来自许多不同生物的大量遗传数据，并希望以直观的方式定义哪些属于同一属或科。

或者，在我们的情况下，我们可能有 777 种不同的魔法:收集牌，使用 600 多种不同的卡片(是的，专业元不是那么多样化)，并希望训练一个机器学习模型，以便它了解哪些卡片可以很好地配合，哪些不能。

现在想象你必须做这个任务，你不知道如何玩这个游戏。如果有人发明了一种算法，将看起来相似的数据聚集在一起，而无需您提供“相似”的定义，这不是很好吗？这就是聚类，尤其是 k-means 聚类的意义所在。

现在完成了，我希望你有动力，因为是时候用一些理论弄脏我们的手了。

K-Means 聚类是如何工作的？

K-Means 聚类接收一个单一的超参数: k，，它指定了我们想要将我们的数据分成多少个聚类。

集群不一定有相同数量的实例。然而，它们应该各自表征我们数据的一个特定子集。我们将如何实现这一目标？让我们来了解一下！

首先，这个算法的输入需要是一组向量。也就是说，你的所有特征都应该是数字的，并且顺序相同。如果您有任何分类特征，我的建议是使用 one-hot encode:将每个分类变量转换成一个 n 元素的向量:每个可能的类别一个，除了给定类别的一个，所有的都设置为 0。

该算法将启动 k 个随机“质心”，即由数据集元素的维度定义的空间中的点，然后它将:

将每个元素指定给最靠近它的质心。
将质心重新映射到位于分配给它的所有元素的平均值上的点。
重复步骤 1 和 2，直到满足收敛(或停止条件，如对给定的 N 进行 N 次迭代)。

最后，每个元素将被分配给 k 个簇中的一个，使得同一簇中的所有元素都离它最近。

K-均值聚类的应用

像许多其他非监督学习算法一样，K-means 聚类如果用作一种为监督机器学习算法(例如，分类器)生成输入的方式，可以创造奇迹。

输入可以是给定实例属于哪个聚类的一次性编码，或者到每个聚类质心的 k 个距离。

然而，对于这个项目，我们将开发的是一个(有点初级的)推荐系统，给定一个实例，它将返回出现在同一个集群中的元素。

在 Python 中使用 Dask 的 K-means 聚类

定义了这个项目的概念后，现在让我们开始实践部分。代码可以在 Jupyter 笔记本的这个库上找到。

处理数据

我按照以下格式存储 MtgTop8 资料:

N card name
M another card name

777 年不同。txt 文件，其中每行指一张牌，第一个空格前的数字是该副牌中该牌的幻影数。

为了将它们转换成更易于管理的格式——我将为每副牌使用一个元组列表(Int，String)，每个元组一张牌——我们将这样做:

这是现在一副牌的样子。

[(4, 'Ancient Ziggurat'),   (4, 'Cavern of Souls'),   (4, 'Horizon Canopy'),   (1, 'Plains'),   (2, 'Seachrome Coast'),   (4, 'Unclaimed Territory'),   (4, 'Champion of the Parish'),   (1, 'Dark Confidant') ...]

其中每个元组代表一张牌(没错，那些都是真实的牌名)，以及出现的次数。

因为我们希望将每一副牌映射到一个向量，所以直观地说

将它们转换成一个列表，整个数据集中每个不同的卡片都有一个元素。
将每个组件设置为相应牌的幻影数(所有组件对应于未出现在该副牌中的牌设置为 0)。

要做到这一点，让我们得到所有卡片组中出现的所有不同的卡片。

现在，让我们利用新发现的关于卡片名称的知识，把所有的卡片都变成美丽的、可消费的载体。

现在我们所有的牌都可以很容易地输入 Dask 的 K-Means 聚类算法，我们可以玩输出。

我们可以只使用“二进制”向量，如果卡片出现在卡片组中，则将分量设置为 1，如果没有出现，则设置为 0。我们以后也可以尝试一下，看看我们是否也能得到好的结果。

应用 K-均值聚类

既然我们的数据都被整齐地映射到向量空间，实际上使用 Dask 的 K-means 聚类是非常简单的。

其中最重要的部分是 n_clusters 参数，我把它任意设置为 8。

在现实生活中，你可能想尝试不同的价值观。对于这个特殊的情况，我知道 MtG 有 5 种不同的“颜色”的卡片。为了防止算法只根据颜色对卡片进行聚类(反正它根本没有这样做)，我选择了一个大于 5 的数字。

该算法将标签作为 Dask 数组返回。我以后可能会写一篇关于如何使用它们的文章，但是现在我不想处理所有这些。此外，MtgTop8 数据集足够小，这并不重要，所以我决定将其转换回整数列表。告我吧。

探索性分析:让我们看看我们得到了什么

起初我想检查结果是否有意义。这是我第一次在这个数据集上使用 K-means 聚类，我想确保它学到了一些有价值的东西。所以我只是检查了每组牌中哪些牌最常用。至少对我来说，结果是令人震惊的。以下是我所做的检查。

如果您对结果感兴趣，我强烈建议您从 GitHub 项目下载笔记本并使用它，它真的很有趣！我只是不想将我的 M:tG 发现与本教程混在一起，这样那些对数据科学感兴趣但对游戏不感兴趣的读者就不会感到无聊。

使用 K-均值聚类的卡片推荐

现在我们已经完成了健全性检查，我们可以继续对我们生成的所有标签进行实际应用了。

我们可以有许多方法来解决推荐问题:给定一张牌，推荐与之相配的其他牌，除了这些牌出现在哪副牌中之外，不使用任何关于这些牌的数据(也就是说，不要作弊，不要询问更多关于这些牌的数据，如颜色、价格或专家的意见)。

请思考一下，您将如何使用聚类数据来生成建议？我相信你能想出一些主意。

如果你想出的不是我要做的，请在评论里告诉我！如果是团队合作，创意会更有趣，我真的很想看看我亲爱的读者们能想出什么。

最后，我是这样做的:

如你所见，对于这部分，我省略了一张牌在给定的牌组中出现的次数，只看了一张牌在给定的牌组中出现的相对次数。

然后，我返回具有最相似的相对幻影(由欧几里德距离定义)的牌。

如果你是一个魔术:收集玩家，尝试一下这段代码，看看结果，它会给出很好的(虽然有点保守)建议！

结论

K-Means 聚类允许我们在不真正了解一个领域的情况下接近它，并得出结论，甚至围绕它设计有用的应用程序。

它让我们通过学习数据中的潜在模式来做到这一点，只要求我们以正确的格式给它数据。

我鼓励您使用这里的代码，尝试使用不同的数据集创建自己的推荐系统，或者解决一些其他问题。如果有，请给我看看你的结果！我想看看你能想出什么。

将来，我想用非专业的套牌做同样的分析。这样，我可以为休闲玩家(比如我)制作一个推荐引擎。我认为如果它能与几乎任何卡一起工作，而不仅仅是 642，那将会很酷。

你可以在我的 个人网站 中看到我正在做的事情以及我最近的文章和笔记。

快乐编码。

原载于 2019 年 4 月 3 日www . data stuff . tech。

k 表示用 Dask(猫图片的图像过滤器)聚类

原文：https://towardsdatascience.com/k-means-clustering-with-dask-image-filters-for-cat-pictures-78284a3e83f6?source=collection_archive---------18-----------------------

300+ colors to 24 colors.

对图像应用滤镜对任何人来说都不是新概念。我们拍了一张照片，对它做了一些修改，现在它看起来更酷了。但是人工智能从何而来？让我们用 K 表示 Python 中的聚类来尝试一下无监督机器学习的有趣用法。

我以前写过关于 K 表示聚类的文章，所以这次我假设你对算法很熟悉。如果你不是，这是我写的的深度介绍。

我还用自动编码器尝试过图像压缩(嗯，重建)，获得了不同程度的成功。

然而这一次，我的目标是不重建最佳可能的图像，而只是看看用最少可能的颜色重建一张图片的效果。

我不想让图片看起来尽可能地与原始图片相似，我只想让我们看着它说“真漂亮！”。

那么我们如何做到这一点呢？很高兴你问了。

如何用 K 均值聚类做图像滤波

首先，记住一个图像只是一个像素的向量总是好的。每个像素是一个由 0 到 255(无符号字节)之间的三个整数值组成的元组，表示该像素颜色的 RGB 值。

我们希望使用 K 均值聚类来找到最能表征图像的 k 颜色。这只是意味着我们可以将每个像素视为一个单个数据点(在三维空间中)，并对它们进行聚类。

所以首先，我们想用 Python 把一个图像转换成一个像素矢量。我们是这样做的。

作为题外话，我不认为 vector_of_pixels 函数需要使用 Python 列表。我确信一定有什么方法可以让变平一个 numpy 数组，我就是找不到任何方法(至少没有一个方法能按照我想要的顺序做到)。如果你能想到任何方法，请在评论中告诉我！

下一步是将模型拟合到图像，这样将像素聚集成 k 颜色。然后，只需要给图像中的每个位置分配相应的聚类颜色。

例如，也许我们的图片只有三种颜色:两种红色和一种绿色。如果我们把它分成两类，所有的红色像素会变成不同的红色(聚集在一起)，其他的会变成绿色。

但是解释得够多了，让我们来看看程序的运行吧！像往常一样，你可以用任何你想要的图片自由地运行它，这里是带有代码的 GitHub 库。

结果呢

我们将把滤镜应用到小猫的照片上，这些照片取自令人惊叹的“猫狗大战” kaggle 数据集。

我们从一张猫的图片开始，对 k 应用不同值的滤镜。下面是原图:

首先，我们来看看这张图原本有多少种颜色。

仅用一行 numpy ，我们就能计算出一个像素在这张图片上的唯一值。特别是这幅图像有 243 种不同的颜色，尽管它总共有 166167 个像素。

现在，让我们来看看仅将其聚类为 2、5 和 10 种不同颜色的结果。

只有两种颜色，它所做的只是标记最暗和最亮的区域。然而，如果你是一个艺术家，正在画一些黑白的东西(比如用墨水),并且想看看你的参考资料的轮廓是什么样的，这可能是有用的。

With only 5 different colors, the cat is already recognizable!

The 10 colors picture may look a bit trippy, but it represents the original’s content pretty clearly.

你注意到一个趋势了吗？我们添加的每种颜色都有递减的回报。拥有 2 种颜色和拥有 5 种颜色之间的差别，远远大于 5 和 10 之间的差别。然而，对于 10 色，平面区域更小，我们有更多的粒度。转向 15 色和 24 色！

虽然很明显这是一张经过过滤的图片，用 24 种颜色(原始数量的 10%)我们已经足够好地表现了猫的细节。

继续看另一张图:这是原图(256 种不同的颜色)，这是压缩图(还是 24 种颜色)。

有趣的是，“压缩”图像重 18KB，未压缩图像重 16KB。我真的不知道这是为什么，因为压缩机是非常复杂的动物，但很乐意在评论中阅读你的理论。

结论

我们能够只用原始图像的 10%的颜色来制作新图像，这些图像看起来与原始图像非常相似。由于 K 均值聚类，我们还得到了一些看起来很酷的过滤器。您还能想到其他有趣的集群应用吗？你认为其他聚类技术会产生更有趣的结果吗？

如果你想回答这些问题中的任何一个，请随时通过 Twitter 、 Medium 或 Dev.to 联系我。

你有兴趣在数据科学领域开始职业生涯吗？你想成为一名出色的机器学习专家吗？来看看我的推荐阅读清单:《帮助你提升数据科学家水平的 3 本机器学习书籍》。其中一个实际上教会了我我所知道的 K 的意思是聚类。

原载于 2019 年 6 月 2 日http://www . data stuff . tech。

使用 scikit-learn 的 K-Means 聚类

原文：https://towardsdatascience.com/k-means-clustering-with-scikit-learn-6b47a369a83c?source=collection_archive---------0-----------------------

了解流行的 k-means 聚类算法背后的基础知识和数学知识，以及如何在scikit-learn中实现它！

聚类(或聚类分析)是一种技术，它允许我们找到相似对象的组，这些对象彼此之间的相关性比其他组中的对象更大。面向业务的集群应用程序的示例包括按不同主题对文档、音乐和电影进行分组，或者基于共同的购买行为来寻找具有相似兴趣的客户，以此作为推荐引擎的基础。

在本教程中，我们将了解最流行的聚类算法之一， k-means ，它在学术界和工业界都有广泛的应用。我们将涵盖:

k-均值聚类的基本概念
k-means 算法背后的数学
k-means 的优缺点
如何使用scikit-learn在样本数据集上实现算法
如何可视化集群
如何用肘法选择最佳的 k

我们开始吧！

本教程改编自 Next Tech 的 Python 机器学习 系列的 Part 3 ，带你从 0 到 100 用 Python 进行机器学习和深度学习算法。它包括一个浏览器内沙盒环境，预装了所有必要的软件和库，以及使用公共数据集的项目。你可以在这里免费上手！

K-均值聚类的基础

正如我们将看到的，与其他聚类算法相比，k-means 算法非常容易实现，并且计算效率非常高，这可能是它受欢迎的原因。k-means 算法属于基于原型聚类的范畴。

基于原型的聚类是指每个聚类由一个原型表示，该原型可以是具有连续特征的相似点的形心 ( 平均值)，也可以是分类特征的形心(最具代表性的或最频繁出现的点)。

虽然 k-means 非常善于识别具有球形形状的聚类，但是这种聚类算法的一个缺点是我们必须先验地指定聚类的数量 k 。对 k 的不适当选择会导致较差的聚类性能——我们将在本教程的后面讨论如何选择 k 。

尽管 k-means 聚类可以应用于更高维度的数据，但是为了可视化的目的，我们将使用一个简单的二维数据集来完成下面的示例。

你可以通过使用 Next Tech 沙箱跟随本教程中的代码，沙箱已经预装了所有必要的库，或者如果你愿意，你可以在你自己的本地环境中运行代码片段。

一旦你的沙盒加载完毕，让我们从scikit-learn导入玩具数据集并可视化数据点:

我们刚刚创建的数据集由 150 个随机生成的点组成，这些点大致分为三个密度较高的区域，通过二维散点图进行可视化。

在聚类的实际应用中，我们没有关于这些样本的任何基本事实类别信息(作为经验证据而不是推断提供的信息)；否则，它将属于监督学习的范畴。因此，我们的目标是根据样本的特征相似性对样本进行分组，这可以通过使用 k-means 算法来实现，k-means 算法可以概括为以下四个步骤:

从样本点中随机选取 k 个形心作为初始聚类中心。
将每个样本分配到最近的质心 μ^(j)，j ∈ {1，…，k}。
将质心移动到指定给它的样本的中心。
重复第 2 步和第 3 步，直到聚类分配不变或达到用户定义的容差或最大迭代次数。

现在，下一个问题是我们如何测量对象之间的相似性？我们可以将相似度定义为距离的反义词，一种常用的对具有连续特征的样本进行聚类的距离是 m 维空间中两点 x 和 y 之间的平方欧氏距离:

注意，在前面的等式中，索引 j 是指样本点 x 和 y 的第 j 维(特征列)。我们将使用上标 i 和 j 分别指代样本索引和集群索引。

基于这种欧几里德距离度量，我们可以将 k-means 算法描述为一个简单的优化问题，一种用于最小化组内误差平方和 ( SSE )的迭代方法，有时也称为组惯性:

这里，

和

请注意，当我们使用欧几里德距离度量将 k-means 应用于真实世界的数据时，我们希望确保在相同的尺度上测量特征，并在必要时应用 z 分数标准化或最小-最大缩放。

使用`scikit-learn`的 k-均值聚类

现在我们已经了解了 k-means 算法是如何工作的，让我们使用来自scikit-learn的cluster模块的KMeans类将它应用于我们的样本数据集:

使用前面的代码，我们将期望的集群数量设置为3。我们设置n_init=10使用不同的随机质心独立运行 k-means 聚类算法 10 次，以选择最终模型作为 SSE 最低的模型。通过max_iter参数，我们指定每次运行的最大迭代次数(这里是300)。

注意，如果在达到最大迭代次数之前收敛，那么scikit-learn中的 k-means 实现会提前停止。然而，对于特定的运行，k-means 可能不会达到收敛，如果我们为max_iter选择相对较大的值，这可能会有问题(计算开销)。

处理收敛问题的一种方法是为tol选择更大的值，T10 是一个参数，它控制关于组内平方和误差变化的容限，以表明收敛。在前面的代码中，我们选择了公差1e-04 (= 0.0001)。

k-means 的一个问题是一个或多个聚类可能是空的。然而，在scikit-learn中的当前 k-means 实现中考虑到了这个问题。如果一个聚类是空的，该算法将搜索离空聚类的质心最远的样本。然后，它会将质心重新分配到这个最远的点。

既然我们已经预测了聚类标签y_km，让我们将 k-means 在数据集中识别的聚类与聚类质心一起可视化。这些存储在适合的KMeans对象的cluster_centers_属性下:

在生成的散点图中，我们可以看到 k-means 将三个质心放置在每个球体的中心，对于给定的数据集，这看起来是一个合理的分组。

肘法

虽然 k-means 在这个玩具数据集上工作得很好，但重要的是要重申，k-means 的一个缺点是，在我们知道最优的 k 是什么之前，我们必须指定聚类的数量 k 。在现实世界的应用程序中，要选择的聚类数量可能并不总是那么明显，尤其是当我们处理无法可视化的高维数据集时。

肘方法是一个有用的图形工具，可以估计给定任务的最佳集群数量 k 。直观地，我们可以说，如果 k 增加，组内 SSE(失真*)将减少。这是因为样本将更接近它们被分配到的质心。*

肘方法背后的思想是确定失真开始下降最快的 k 的值，如果我们绘制不同的 k 值的失真，这将变得更加清楚:

正如我们在结果图中看到的，肘部位于 k = 3 处，这证明 k = 3 确实是这个数据集的一个好选择。

我希望你喜欢这个关于 k-means 算法的教程！我们探讨了 k-means 算法背后的基本概念和数学，如何实现 k-means，以及如何选择最佳数量的聚类， k 。

如果您想了解更多，Next Tech 的 Python 机器学习(第三部分)课程将进一步探索聚类算法和技术，例如:

剪影图，另一种用于选择最优 k 的方法
k-means++ ，k-means 的一个变种，通过对初始聚类中心更巧妙的播种来改善聚类结果。
其他类别的聚类算法，如分层和基于密度的聚类，不需要我们预先指定聚类的数量或假设我们的数据集中的球形结构。

本课程还探讨了回归分析、情感分析以及如何将动态机器学习模型部署到 web 应用程序中。这里可以开始！

基于 K-均值的实用聚类

原文：https://towardsdatascience.com/k-means-practical-1ab126e52f58?source=collection_archive---------10-----------------------

在数据科学领域，无监督学习通常被视为有点“非传统”，尤其是当需要经验证明的结果时。然而，K-Means 聚类具有持久的流行性，因为它使用起来相对简单，还因为它是一种强大的(尽管有时)探索性数据分析工具。

正如我在上一篇文章中承诺的，我将在下面介绍一些简单的 K 均值聚类的基础知识！

无监督学习与聚类的比较综述；

与本博客中的其他实际例子相反，明眼人会注意到我们没有“真实的”、可测试的数据可以比较！当不存在测试案例时，K-means (KM)和其他无监督学习算法最有帮助——我们将继续假设数据集的可测试数据不存在或已被排除在考虑范围之外。
我们开始吧！

K-均值聚类理论；

K-Means 聚类只是聚类算法家族中的一个分支，我们将在这里暂时忽略它。KM 是这个家族中最受欢迎的成员之一，因为它相当简单，易于可视化，并且使用概念上简单的度量标准。具体来说，KM 算法寻求围绕“质心”点对数据观察进行聚类。在我们进入质心之前，先看一下聚类前的样本数据图:

Pre-Clustered Data

正如您所看到的，有三组明显不同的数据，几乎可以肯定地代表了基本数据的趋势，我们在这一点上可能知道，也可能不知道。本例中使用的数据非常简洁，因为我们将在 Python 3 环境中用下面的单元格生成它。如果你愿意，继续复制这段代码；

### Building k-means example, step by step!#### Made sure to import and/or download the following libraries:from sklearn.datasets import make_blobs   # tool to create our sample data
import matplotlib.pylab as plt            # standard plotting
import pandas as pd, numpy as np %matplotlib inline                        # very handy 'magic' commandfigsize=(8, 6)colors = ["r", "b", "g"]
columns = ["x1", "x2", "color"] # We'll work with a managable sample of 50 observations in 3 distinct clusters.  You can follow these specifications in the arguments below: 
X, color = make_blobs(n_samples=50, random_state=42, centers=3, cluster_std=1.75)# setting the colors we'll use in a little while
X = map(lambda x: (x[0][0], x[0][1], colors[x[1]]), zip(X, color))# Starting centroid points.  These can be arbitrary, but it helps to give intelligently-designated starting points:
centroids = pd.DataFrame([(-8, 0, "g"), (-7.5, 8, "r"), (2.5, -2, "b")], columns=columns)# Training points
gaus_df = pd.DataFrame(list(X), columns=columns)

现在，通过下面的代码，我们可以将颜色应用到我们的数据中，并使其更加清晰地可视化！

ax = gaus_df.plot(kind="scatter", x="x1", y="x2", figsize=figsize)
ax.set_title("Begin: Load Data Points", fontsize=15)

继续运行该单元格，您应该会生成右边的简单图形！

请注意，数据本身仍然是单色的，我们创建的彩色质心都有点，嗯，没有从它们似乎相关的集群中分离出来。

正如我前面提到的，K-Means 聚类就是要最小化数据观察值和它们的质心之间的均方距离(MSD)。在某些情况下(就像在这个例子中)，我们甚至会在这里使用纯欧氏距离作为度量，因此 K-Means 有时会与 K 最近邻分类模型混淆，但这两种算法的操作有点不同。

非常重要的是，KM 将迭代地从它们的起始位置“行走”所选择的质心，朝向使从数据到最近的或最相似的质心的 MSD 最小化的质心。作为参考，我将在这里包含一个代码来生成欧几里得距离的可视检查:

import numpy as np
import pandas as pd
from sklearn.metrics import euclidean_distances
from sklearn.datasets.samples_generator import make_blobs
import matplotlib.pyplot as plt%matplotlib inlineX = np.array([[2, -1], [-2, 2]])plt.figure(figsize=(12, 7))
for i, (x, y) in enumerate(X):
    plt.scatter(y, x)
    plt.text(y + .05, x -.05, "$X_%d$" % (i+1), size=22)

plt.plot(X[0], X[1], "g--")
plt.text(.5, .5, "$\sqrt{\sum_{i=1}^N (x_{1i} - x_{2i})^2}$", size=25)
plt.title("Euclidean Distance Between $x_1$ and $x_2$", size=15)

当 KM 在数据中循环移动质心时，它学会识别你我在初始数据图中可以直观看到的不同簇！这是一个非常简单的例子，所以 KM 收敛到一个很好的、不同的集群只需要很少的工作。查看下面的示例图，一步一步地展示这一过程:

Step 1: Initializing Centroids

我们已经检查了上面的单元格，但是我将再次包括它，以浏览 K-Means 的逻辑流程

这里，我们的质心是“任意”选择的，因此它们可以应用于观察数据的聚类

Step 2: Calculating Centroid Point-Distances (Euclidean)

在右边，注意每个质心是如何考虑每个数据点的。当在非常大的数据集上运行时，这个算法在计算上可能有点昂贵！

Step 3: Assigning Data Points to Nearest Centroid

就编码而言，这是我们的新领域。我们将在下面回顾如何产生这种结果，但是现在只需观察数据是如何被整齐地分成不同的组的！

此外，请注意，质心没有移动，这适用于简单数据，但对于更复杂的数据，需要更多的步骤。

Step 3 — Onwards: Repeat Step 2 and 3 until Convergence

在这里，我们通过步骤 2 和 3(上面)循环，直到数据收敛！这只是意味着质心将逐渐在图上移动，直到它们从自身到最近的数据点的总 MSD 最小！

Output

一旦实现了融合，我们就有了清晰的数据集群！这些聚类将共享原始数据中的特征，其中一些特征从数据帧本身来看可能并不明显。

现在，让我们从头到尾看一个实际的例子:

应用的 K 均值:

首先，我们将生成一些样本数据:

%matplotlib inlinefrom sklearn.cluster import KMeans, k_means
from sklearn.metrics import silhouette_score
from sklearn.datasets.samples_generator import make_blobsimport numpy as np
import pandas as pdimport seaborn as sns
import matplotlib.pyplot as plt
import matplotlibmatplotlib.style.use('ggplot')# # Let's make some more blobs to test K-Means on
X, color = make_blobs(n_samples=100, random_state=29, centers=3, cluster_std=1.5)
df = pd.DataFrame(X, columns=["x1", "x2"])
df['color'] = color
df.head()

Sample of Generated Data

使用 Matplotlib 绘制数据:

# Plot the scatter -- we need to code the previous cell to get "df"
ax = df.plot(kind="scatter", x="x1", y="x2", figsize=(12,6), s=50)
plt.xlabel("$X_1$", fontsize=18)
plt.ylabel("$X_2$", fontsize=18)
ax.tick_params(axis='both', which='major', labelsize=18)

Neat Clusters from make_blobs

现在我们可以进入有趣的部分了；用 Sklearn 的软件包拟合数据:

## Take note that the latest version of Kmeans my behave slightly different.  
kmeans = KMeans(n_clusters=3)
model = kmeans.fit(df[['x1', 'x2']])# Now, we can get the predicted model labels, or Centroids, in the form of an array:
model.cluster_centers_

现在，我们将这些标签附加到数据框上，用于将来的绘图，并将质心分配给它们自己的数据框:

# attach predicted cluster to original points
df['predicted'] = model.labels_# Create a dataframe for cluster_centers (centroids)
centroids = pd.DataFrame(model.cluster_centers_, columns=["x1", "x2"])

这应该生成一个基本的，但示范性的，K-均值聚类图！

from matplotlib import pyplot as pltplt.figure(figsize=(7,7))## Plot scatter by cluster / color, and centroids
colors = ["red", "green", "blue"]
df['color'] = df['predicted'].map(lambda p: colors[p])ax = df.plot(    
    kind="scatter", 
    x="x1", y="x2",
    figsize=(10,8),
    c = df['color']
)centroids.plot(
    kind="scatter", 
    x="x1", y="x2", 
    marker="*", c=["r", "g", "b"], s=550,
    ax=ax
)

Final Plot of Distinct Clusters

这是对 K-Means 聚类的简单概述！请注意，许多异常和错误标记的数据点很可能出现在不太完美的真实数据中，但这应该可以帮助您入门。特别要注意“whispy”数据，或者沿 X、Y 或两个轴聚集成细长簇的数据，这个简单的模型无法区分这些种类的簇，只能找到最近的点进行簇分配，从而导致一些交叉污染！我将在以后继续举例说明如何避免这种情况。感谢阅读！

Iris 数据集上的 K-Medoids 聚类

原文：https://towardsdatascience.com/k-medoids-clustering-on-iris-data-set-1931bf781e05?source=collection_archive---------1-----------------------

几乎在任何机器学习课程中， K-Means Clustering 将是第一批引入无监督学习的算法之一。由于这一点，它比它的表亲 K-Medoids 集群更受欢迎。如果你谷歌一下“k-means”，会弹出 14.9 亿个结果。对“k-medoids”这样做，只有 23.1 万个结果返回。

当我在一次期末考试中被要求实现 k-medoids 聚类算法时，这就是我的挣扎。这花了一段时间，但我设法做到了。因此，为了帮助 k-medoid 的概念看到更多的行动，我决定将我构建和实现的算法放在这里，这一次，基于“臭名昭著”的虹膜数据集。

简介

k-means 和 k-medoids 算法都是分区的，这涉及到将数据集分成组。K-means 旨在最小化每个聚类中心位置的总平方误差。这些中心位置被称为质心。另一方面，k-medoids 试图最小化被标记为在聚类中的对象和被指定为该聚类的代表的对象之一之间的不相似性的总和。这些代表被称为水母。

与 k-means 算法相反，k-medoids 从集合中的数据点选择 medoids，k-means 算法认为质心是中心的平均位置，可能不是集合中的数据点。

数据准备

我们将使用来自 sklearn 库中的虹膜数据集的副本。为了演示算法，我将跳过将数据集分为训练集和测试集的步骤，而是使用一个数据集来训练和拟合模型。

下面是萼片长度、宽度的测量数据；3 种不同类型的鸢尾的花瓣长度和宽度:['setosa '，' versicolor '，' virginica']，标记为[0，1，2]:

我有一个习惯，当数据在不同的列上时，我会针对这些类型的问题缩放数据。因为没有丢失数据，所以让我们继续缩放。我使用了同一个库 sklearn 的 MinMaxScaler 类。以下是换算后的数据:

有 4 个特征对于聚类模型的可视化和拟合可能不理想，因为它们中的一些可能高度相关。因此，我们将采用主成分分析(PCA)将 4 维数据转换为 3 维数据，同时保持那些预测值的显著性，这些预测值具有来自 sklearn 的 PCA 类。降维后的数据如下:

我们最终可以在三维平面上看到这些:

实施

我们首先开始看相异度函数。有很多选择但是在这里，我们将使用常见的 闵可夫斯基距离 函数的给定顺序。我们将要实现的算法叫做Medoids(PAM)算法(Kaufman 和 Rousseeuw 1990)。可以总结如下:

初始化:随机选择𝑚数据点的𝑘作为 medoids
赋值:根据闵可夫斯基距离将每个数据点关联到最近的 medoid
更新:对于每个 medoid 𝑗和每个与𝑗关联的数据点𝑖，交换𝑗和𝑖，并计算配置的总成本(即𝑖与所有与𝑗).关联的数据点的平均相异度选择配置成本最低的 medoid 𝑗。在第 2 步和第 3 步之间重复，直到分配没有变化。

在下面的代码中，使用我们通常的“数据矩阵”约定会很方便，也就是说，在数据矩阵𝑋中，每一行𝑥̂是𝑚的一个观测值，每一列𝑥是𝑓的一个特征。

1。Medoid 初始化

为了开始算法，我们需要一个初始猜测。让我们从数据中随机选择𝑘观测值。在这种情况下，𝑘 = 3，代表 3 种不同类型的虹膜。

接下来，我们将创建一个函数 init_medoids(X，k ),以便它随机选择给定观测值的𝑘作为 medoids。它应该返回一个大小为𝑘×𝑑的 NumPy 数组，其中𝑑是 x 的列数

从数据点初始化 3 个随机 medoids 后，我们有:

2。计算距离

实现计算距离矩阵的函数，𝑆 = (s_𝑖𝑗)使得 s_𝑖𝑗 = 𝑑^ 𝑝_𝑖𝑗是从𝑥_𝑖点到𝜇_𝑖.的𝑝阶的闵可夫斯基距离它应该返回一个 NumPy 矩阵𝑆与形状(𝑚,𝑘).

𝑝^𝑡ℎ命令𝑥和𝜇两点之间的闵可夫斯基距离由下式给出:

因此，对于矩阵𝑆的元素，

闵可夫斯基距离通常与𝑝1 或 2 一起使用，分别对应于 曼哈顿距离 和 欧几里德距离 。我们将在计算中使用欧几里得距离。

基于此，矩阵 S 的前 5 个元素是:

3。集群分配

现在，我们构建一个作用于距离矩阵 S 的函数，使用最小距离为每个点分配 0，1，2 的“聚类标签”,以找到“最相似”的 medoid。

也就是说，对于由行索引𝑖指示的每个点，如果𝑠_𝑖𝑗是点𝑖的最小距离，则索引𝑗是𝑖的聚类标签。换句话说，该函数应该返回长度为𝑚的一维数组𝑦，如下所示:

然后，我们获得第一次迭代的数据点的标签:

4。交换测试

在此步骤中，对于每个 medoid 𝑗和与𝑗关联的每个数据点𝑖，交换𝑗和𝑖，并计算配置的总成本(即𝑖与∑𝑠_𝑖𝑗所有数据点的平均差异)，如步骤 3 所示。选择配置成本最低的 medoid 𝑗。

也就是说，对于每个聚类，搜索该聚类中的任何点是否降低了平均相异系数。选择降低该系数最大的点作为该聚类的新 medoid。

最后，我们还需要一个函数来检查 medoid 是否已经“移动”，给定 med oid 值的两个实例。这是检查 medoids 是否不再移动以及迭代是否应该停止的函数。

4。将所有这些放在一起

当我们组合上述所有函数时，我们本质上组合了 K-Medoids 算法的步骤。

通过对我们拥有的数据点运行该函数，最终的 medoids 被发现为:

每个数据点的聚类标签是:

通过考虑“不精确”匹配，上面的 K-Medoids 算法正确标记了 94.7%的数据点。这只是为了演示算法如何工作，这个数字没有太大意义，因为我们没有将数据分成训练集和测试集。

使用 ATS 的 K-Medoids 聚类:释放模板的力量

原文：https://towardsdatascience.com/k-medoids-clustering-using-ats-unleashing-the-power-of-templates-56cd7ab944bf?source=collection_archive---------14-----------------------

[## natanielruiz/ats-kmedoids

使用模板在 ATS 中实现 k-medoids。为 natanielruiz/ats-kmedoids 的发展作出贡献。

github.com](https://github.com/natanielruiz/ats-kmedoids)

(您可以在上面找到所有相关的代码)

k-medoids 聚类是一种经典的聚类机器学习算法。它是 k-means 算法的一种推广。唯一的区别是聚类中心只能是数据集的元素之一，这产生了一种可以使用任何类型的距离函数的算法，而 k-means 只能使用 L2 范数证明收敛。

当我在波斯顿大学学习 CS520 编程语言课程，并与 ATS 编程语言的创始人 Xi 教授一起工作时，我意识到 ATS 是处理这种算法的天然选择。事实上，模板允许 k-medoids 的一个非常通用的实现。在实现了模板函数之后，要在数据集上运行它，剩下的唯一需要实现的就是距离函数。这意味着以这种方式编写的算法可以在用户希望的任何数据集上工作，假设用户可以在数据集中的点之间实现良好定义的距离函数。

让我们一步一步地展示这是如何工作的。

Import all necessary libraries — the mylib function which defines the mylist type is included in the GitHub repo

The outline of the k-medoids algorithm

在解析和理解了 k-medoids 算法之后，我们可以看到我们必须实现几个模板函数。但是首先让我们定义一些方便的数据类型。注意，这些数据类型有一个内部数据类型“a”，它将在实现距离函数时定义。这意味着我们的代码是完全通用的——允许任何有限长度和任何类型(例如整数、双精度、浮点、字符)的数据集点。

point(a) is a list of type a and pointlst(a) is a dataset of points of type

接下来我们定义大家伙。我们 k-medoid 算法的模板。KMedoidsTrain 接收数据集 p 和聚类数，施展魔法，输出最终配置的 medoids、聚类和 cost 。

We define templates for the k-medoids training function and the k-medoids loop function

我们定义了一些模板来

初始化 medoids
将数据集中的点与最近的 medoid 相关联
查找特定点的 medoid
给定 medoid 索引列表，查找 med oid 的坐标
用 medoid i 替换数据集中的点 j

也有一些模板来计算成本和距离。

在这一点上，我们可以问:这些函数中的哪一个可以被完整地定义并应用于我们想要解决的任何聚类问题？

实际上，请停止滚动，我们来玩个游戏。请回答这个问题:每当我们想改变距离度量的定义时，我们必须定义哪些函数？(答案在下面)

答案只有距离功能。也许您认为成本函数也需要针对每个问题单独实现，但事实并非如此。成本函数应该基本上计算所有点和它们的中面之间的距离，并将这些距离相加-它取决于距离函数，并且可以独立编码。

所有这些都是好消息。一套函数实现可以解决你想解决的任何问题。您只需要为数据集定义一个距离函数。

实际上，让我们看看这是如何工作的。让我们实现 costf 函数，该函数在给定点 p、中面和聚类的数据集的情况下，给出了这些点和它们的中面之间的所有距离的总和。

通常在 ATS 中，我们使用递归来计算这个结果，并使用一个辅助函数 costf_aux 来计算这个结果。请记住，在这种情况下，我们有 medoids，它是包含 medoids 的 ndis 的列表(数据集中的哪些点是 medoids ),我们使用 lookup_medoids 函数获得的 medoid _ pts 是包含 medoids 的坐标的列表。

在辅助成本函数中，我们使用模式匹配(case+ p of)遍历数据集 p 。当数据集已经被迭代通过时，我们输出累加器 res。当我们仍然迭代通过数据集时，我们获得点 p1 所属的聚类，我们获得对应于该聚类的 medoid 坐标 m，然后使用仍然未指定的距离函数简单地计算距离。

下面我们来快速看一下 lookup_medoids。它只是一个辅助函数，接受数据集和 medoid 索引，并为我们提供 medoid 坐标。你不希望在不必要的时候到处传递 medoid 坐标！

让我们回到算法上。

KMedoidsTrain 接受数据集 p 和数量的簇，使用辅助函数 KMedoidsTrainIter 给我们结果。

代码非常简单明了。但是如果您需要一些帮助来解析它，步骤如下:

如果聚类没有完成:

将 medoid j 换成点 I
获取所有点的新聚类
获取下一次迭代的索引(I，j，step )(我使用下面的帮助函数使代码更整洁)

如果新成本低于旧成本，则使用新的 medoids！如果不是，继续用旧的。

相当简单！

如何初始化 medoids？只需使用辅助函数获取数据集的“n_cluster”个第一元素。抓取随机元素会更好，但这仍然是初始化算法的有效方式。

for loops are for beginners

好的，最后，我们如何将数据集中的每个点与其对应的 medoid 关联起来？首先，我们定义一个函数来为一个特定的点 p1 找到相应的 medoid。然后我们用它在 associate_points 函数中寻找所有对应的 medoids。

Simple recursion with pattern matching where, at each step, we compare the distance to the old medoid to the distance to the new medoid. If the distance is lesser then the new medoid is carried on!

Here we are basically finding the medoids for all points in the dataset. A simple recurrence.

还有一件事。我们如何把 medoid i 换成 j 点？使用 mylib 中的一个可以在 GitHub 上查找的函数:)

我们开始有趣的部分了！

让我们定义一个新文件 l2_medoids.dats，并将最后一个文件命名为 clustering.dats

导入包含模板函数定义的前一个文件。还要导入 C 库调用平方根函数。

ATS can call external C functions to do math

我们有一个像这样的数据集。我们希望使用 k-medoids 算法和 L2 距离函数进行聚类(使用 2 个聚类)。你能看到结果会是什么吗？

好吧，有趣的部分。定义两点之间的距离函数。请记住，到目前为止，点是未指定长度和未指定类型 a 的列表。非常一般！现在我们实际上告诉编译器，我们正在处理类型为 double 的点。我们还告诉编译器如何计算数据集的距离。

Recurrence through the point coordinates. d = sqrt((p1 — p2) ** 2)

是时候在同一个文件中定义 L2 距离的 k-medoids 函数了。

还有一个与上面画的 2D 例子相对应的小例子！让我们看看我们是否做对了。

使用 ATS 编译器“patscc”编译所有这些内容。咻没有错误！ATS 是一种强类型语言，许多潜在的错误会在编译时被清除。调试时，编译器捕获了我的大部分实现错误，因为有些函数没有被输入正确的类型。大多数情况下，运行时错误将是越界错误，尽管使用高级 ATS 编程(如定理证明)甚至可以在编译时捕获这些错误。

所有这些特点使 ATS 成为一种有趣的编程语言。

无论如何，让我们运行代码

我们有相关的几何图列表、最终几何图以及最终配置的成本函数。让我们画出最终状态，看看是否正确。

Two clusters in red and blue. The highlighted points are the cluster medoids.

完美！如果您想在数据集上使用这些代码，请随意。请记住，您只需实现距离函数，就万事俱备了。

就这么简单。作为告别，让我们定义一下 L1 距离，它可以用在同样的问题上。

L1 distance function

Different results. Makes sense!

Same clusters, different medoids!

Python 中从头开始的 k 近邻分类器

原文：https://towardsdatascience.com/k-nearest-neighbor-classifier-from-scratch-in-python-698e3de97063?source=collection_archive---------10-----------------------

“让我看看谁是你的朋友，我就能知道你是谁？”

k-最近邻分类器的概念几乎不能被更简单地描述。这是一句老话，在许多语言和许多文化中都可以找到。圣经中的其他话也提到:“与智慧人同行的，必得智慧；与愚昧人作伴的，必受伤害”(箴言 13:20)

这意味着 k-最近邻分类器的概念是我们日常生活和判断的一部分:想象你遇到一群人，他们都非常年轻，时尚和爱运动。他们谈论他们的朋友本，谁没有和他们在一起。那么，你对本的想象是怎样的？没错，你认为他年轻、时尚、富有运动精神。

如果你知道本住在一个人们投保守党票的社区，而且平均年收入超过 20 万美元？他的两个邻居年收入甚至超过 30 万美元？你觉得本怎么样？最有可能的是，你不认为他是一个失败者，你可能会怀疑他也是一个保守派？

最近邻分类背后的原理在于找到距离新样本最近的训练样本的预定数量，即“k”，该新样本必须被分类。新样本的标签将根据这些邻居来定义。k-最近邻分类器对于必须确定的邻居数量具有固定的用户定义常数。还有基于半径的邻居学习算法，该算法基于点的局部密度具有不同数量的邻居，所有样本都在固定半径内。一般来说，距离可以是任何度量单位:标准欧几里得距离是最常见的选择。基于邻居的方法被称为非一般化机器学习方法，因为它们只是“记住”所有的训练数据。可以通过未知样本的最近邻的多数投票来计算分类。

现在让我们从数学角度来看:

与其他分类方法相比，k-最近邻分类器(k-NN)直接在学习的样本上工作，而不是创建规则。

最近邻算法:

给定一组类别{c1，c2，…cn}也称为类，例如{“男性”，“女性”}。还有一个由带标签的实例组成的学习集 LSLS。

分类的任务在于给一个任意的实例指定一个类别。如果实例 oo 是 LSLS 的一个元素，将使用实例的标签。

现在，我们来看看 oo 不在 LSLS 的情况:

oo 与 LSLS 的所有实例相比较。距离度量用于比较。我们确定 oo 的 kk 个最近邻居，即具有最小距离的项目。kk 是用户定义的常数，是一个正整数，通常很小。

最常见的 LSLS 类将被分配给实例 oo。如果 k = 1，那么该对象被简单地分配给该单个最近邻的类。

k-最近邻分类器的算法是所有机器学习算法中最简单的。k-NN 是一种基于实例的学习，或称惰性学习，在这种学习中，当我们进行实际的分类时，只对函数进行局部近似，并执行所有的计算。

在我们真正开始编写最近邻分类器之前，我们需要考虑数据，即学习集。我们将使用 sklearn 模块的数据集提供的“iris”数据集。

数据集由来自三种鸢尾的每一种的 50 个样本组成

鸢尾，
北美鸢尾和
杂色鸢尾。

测量每个样本的四个特征:萼片和花瓣的长度和宽度，以厘米为单位。

import numpy as np
from sklearn import datasets

iris = datasets.load_iris()
iris_data = iris.data
iris_labels = iris.target
print(iris_data[0], iris_data[79], iris_data[100])
print(iris_labels[0], iris_labels[79], iris_labels[100])

这是预期的输出:

[5.1 3.5 1.4 0.2] [5.7 2.6 3.5 1\. ] [6.3 3.3 6\.  2.5]
0 1 2

我们从上面的集合中创建一个学习集。我们使用 np.random 中的排列来随机拆分数据。

np.random.seed(42)
indices = np.random.permutation(len(iris_data))
n_training_samples = 12
learnset_data = iris_data[indices[:-n_training_samples]]
learnset_labels = iris_labels[indices[:-n_training_samples]]
testset_data = iris_data[indices[-n_training_samples:]]
testset_labels = iris_labels[indices[-n_training_samples:]]
print(learnset_data[:4], learnset_labels[:4])
print(testset_data[:4], testset_labels[:4])

输出:

[[6.1 2.8 4.7 1.2]
 [5.7 3.8 1.7 0.3]
 [7.7 2.6 6.9 2.3]
 [6\.  2.9 4.5 1.5]] [1 0 2 1]
[[5.7 2.8 4.1 1.3]
 [6.5 3\.  5.5 1.8]
 [6.3 2.3 4.4 1.3]
 [6.4 2.9 4.3 1.3]] [1 2 1 1]

下面的代码只是可视化我们的 learnset 的数据所必需的。我们的数据由每个 iris 项目的四个值组成，因此我们将通过对第三和第四个值求和来将数据减少到三个值。这样，我们能够在三维空间中描述数据:

# following line is only necessary, if you use ipython notebook!!!
%matplotlib inline 

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

X = []
for iclass in range(3):
    X.append([[], [], []])
    for i in range(len(learnset_data)):
        if learnset_labels[i] == iclass:
            X[iclass][0].append(learnset_data[i][0])
            X[iclass][1].append(learnset_data[i][1])
            X[iclass][2].append(sum(learnset_data[i][2:]))

colours = ("r", "g", "y")

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

for iclass in range(3):
       ax.scatter(X[iclass][0], X[iclass][1], X[iclass][2], c=colours[iclass])
plt.show()

确定邻居

为了确定两个实例之间的相似性，我们需要一个距离函数。在我们的例子中，欧几里德距离是理想的:

def distance(instance1, instance2):
    # just in case, if the instances are lists or tuples:
    instance1 = np.array(instance1) 
    instance2 = np.array(instance2)

    return np.linalg.norm(instance1 - instance2)

print(distance([3, 5], [1, 1]))
print(distance(learnset_data[3], learnset_data[44]))4.47213595499958
3.4190641994557516

函数“get_neighbors”返回一个包含“k”个邻居的列表，这些邻居离实例“test_instance”最近:

def get_neighbors(training_set, 
                  labels, 
                  test_instance, 
                  k, 
                  distance=distance):
    """
    get_neighors calculates a list of the k nearest neighbors
    of an instance 'test_instance'.
    The list neighbors contains 3-tuples with  
    (index, dist, label)
    where 
    index    is the index from the training_set, 
    dist     is the distance between the test_instance and the 
             instance training_set[index]
    distance is a reference to a function used to calculate the 
             distances
    """
    distances = []
    for index in range(len(training_set)):
        dist = distance(test_instance, training_set[index])
        distances.append((training_set[index], dist, labels[index]))
    distances.sort(key=lambda x: x[1])
    neighbors = distances[:k]
    return(neighbors)

我们将使用虹膜样本测试该功能:

for i in range(5):
    neighbors = get_neighbors(learnset_data, 
                              learnset_labels, 
                              testset_data[i], 
                              3, 
                              distance=distance)
    print(i, 
          testset_data[i], 
          testset_labels[i], 
          neighbors)

输出:

0 [5.7 2.8 4.1 1.3] 1 [(array([5.7, 2.9, 4.2, 1.3]), 0.14142135623730995, 1), (array([5.6, 2.7, 4.2, 1.3]), 0.17320508075688815, 1), (array([5.6, 3\. , 4.1, 1.3]), 0.22360679774997935, 1)]
1 [6.5 3\.  5.5 1.8] 2 [(array([6.4, 3.1, 5.5, 1.8]), 0.1414213562373093, 2), (array([6.3, 2.9, 5.6, 1.8]), 0.24494897427831783, 2), (array([6.5, 3\. , 5.2, 2\. ]), 0.3605551275463988, 2)]
2 [6.3 2.3 4.4 1.3] 1 [(array([6.2, 2.2, 4.5, 1.5]), 0.2645751311064586, 1), (array([6.3, 2.5, 4.9, 1.5]), 0.574456264653803, 1), (array([6\. , 2.2, 4\. , 1\. ]), 0.5916079783099617, 1)]
3 [6.4 2.9 4.3 1.3] 1 [(array([6.2, 2.9, 4.3, 1.3]), 0.20000000000000018, 1), (array([6.6, 3\. , 4.4, 1.4]), 0.2645751311064587, 1), (array([6.6, 2.9, 4.6, 1.3]), 0.3605551275463984, 1)]
4 [5.6 2.8 4.9 2\. ] 2 [(array([5.8, 2.7, 5.1, 1.9]), 0.3162277660168375, 2), (array([5.8, 2.7, 5.1, 1.9]), 0.3162277660168375, 2), (array([5.7, 2.5, 5\. , 2\. ]), 0.33166247903553986, 2)]

投票以获得单一结果

我们现在要写一个投票函数。这个函数使用集合中的类“Counter”来计算实例列表中类的数量。这个实例列表当然是邻居。函数“vote”返回最常见的类:

from collections import Counter

def vote(neighbors):
    class_counter = Counter()
    for neighbor in neighbors:
        class_counter[neighbor[2]] += 1
    return class_counter.most_common(1)[0][0]

我们将在训练样本上测试“投票”:

for i in range(n_training_samples):
    neighbors = get_neighbors(learnset_data, 
                              learnset_labels, 
                              testset_data[i], 
                              3, 
                              distance=distance)
    print("index: ", i, 
          ", result of vote: ", vote(neighbors), 
          ", label: ", testset_labels[i], 
          ", data: ", testset_data[i])

…

index:  0 , result of vote:  1 , label:  1 , data:  [5.7 2.8 4.1 1.3]
index:  1 , result of vote:  2 , label:  2 , data:  [6.5 3\.  5.5 1.8]
index:  2 , result of vote:  1 , label:  1 , data:  [6.3 2.3 4.4 1.3]
index:  3 , result of vote:  1 , label:  1 , data:  [6.4 2.9 4.3 1.3]
index:  4 , result of vote:  2 , label:  2 , data:  [5.6 2.8 4.9 2\. ]
index:  5 , result of vote:  2 , label:  2 , data:  [5.9 3\.  5.1 1.8]
index:  6 , result of vote:  0 , label:  0 , data:  [5.4 3.4 1.7 0.2]
index:  7 , result of vote:  1 , label:  1 , data:  [6.1 2.8 4\.  1.3]
index:  8 , result of vote:  1 , label:  2 , data:  [4.9 2.5 4.5 1.7]
index:  9 , result of vote:  0 , label:  0 , data:  [5.8 4\.  1.2 0.2]
index:  10 , result of vote:  1 , label:  1 , data:  [5.8 2.6 4\.  1.2]
index:  11 , result of vote:  2 , label:  2 , data:  [7.1 3\.  5.9 2.1]

我们可以看到，除了索引为 8 的项目之外，预测与标注的结果一致。

“vote_prob”是一个类似于“vote”的函数，但它返回类名和该类的概率:

def vote_prob(neighbors):
    class_counter = Counter()
    for neighbor in neighbors:
        class_counter[neighbor[2]] += 1
    labels, votes = zip(*class_counter.most_common())
    winner = class_counter.most_common(1)[0][0]
    votes4winner = class_counter.most_common(1)[0][1]
    return(winner, votes4winner/sum(votes))

…

for i in range(n_training_samples):
    neighbors = get_neighbors(learnset_data, 
                              learnset_labels, 
                              testset_data[i], 
                              5, 
                              distance=distance)
    print("index: ", i, 
          ", vote_prob: ", vote_prob(neighbors), 
          ", label: ", testset_labels[i], 
          ", data: ", testset_data[i])

…

index:  0 , vote_prob:  (1, 1.0) , label:  1 , data:  [5.7 2.8 4.1 1.3]
index:  1 , vote_prob:  (2, 1.0) , label:  2 , data:  [6.5 3\.  5.5 1.8]
index:  2 , vote_prob:  (1, 1.0) , label:  1 , data:  [6.3 2.3 4.4 1.3]
index:  3 , vote_prob:  (1, 1.0) , label:  1 , data:  [6.4 2.9 4.3 1.3]
index:  4 , vote_prob:  (2, 1.0) , label:  2 , data:  [5.6 2.8 4.9 2\. ]
index:  5 , vote_prob:  (2, 0.8) , label:  2 , data:  [5.9 3\.  5.1 1.8]
index:  6 , vote_prob:  (0, 1.0) , label:  0 , data:  [5.4 3.4 1.7 0.2]
index:  7 , vote_prob:  (1, 1.0) , label:  1 , data:  [6.1 2.8 4\.  1.3]
index:  8 , vote_prob:  (1, 1.0) , label:  2 , data:  [4.9 2.5 4.5 1.7]
index:  9 , vote_prob:  (0, 1.0) , label:  0 , data:  [5.8 4\.  1.2 0.2]
index:  10 , vote_prob:  (1, 1.0) , label:  1 , data:  [5.8 2.6 4\.  1.2]
index:  11 , vote_prob:  (2, 1.0) , label:  2 , data:  [7.1 3\.  5.9 2.1]

摘要

在本教程中，您了解了如何使用 Python 从头开始实现 k 近邻算法。

具体来说，您学到了:

如何逐步编写 k-最近邻算法的代码？
如何在真实数据集上计算 k 近邻？
如何使用 k 近邻对新数据进行预测？

记住你可以在我的 github 库这里找到完整的工作代码。

感谢的阅读，我很乐意讨论你可能有的任何问题或纠正:)如果你想讨论机器学习或其他任何问题，请在 LinkedIn 上找到我。

Python 中的 k 近邻算法

原文：https://towardsdatascience.com/k-nearest-neighbor-python-2fccc47d2a55?source=collection_archive---------1-----------------------

https://www.pexels.com/photo/photo-of-woman-standing-in-front-of-blackboard-5212320/

k 近邻，简称 KNN，是最简单的机器学习算法之一，被广泛应用于各种机构。KNN 是一个非参数的，懒惰的学习算法。当我们说一种技术是非参数化的，这意味着它不对底层数据做任何假设。换句话说，它根据与其他数据点的接近程度进行选择，而不管数值代表什么特征。成为一个懒惰的学习算法暗示着几乎没有训练阶段。因此，当新数据点出现时，我们可以立即对其进行分类。

KNN 的一些利弊

优点:

没有关于数据的假设
简单的算法—易于理解
可用于分类和回归

缺点:

高内存要求-所有训练数据都必须存在于内存中，以便计算最近的 K 个邻居
对不相关的特征敏感
对数据规模敏感，因为我们正在计算到最近的 K 个点的距离

算法

为 K 选择一个值(即 5)。

2.根据新数据点的欧氏距离，取其最近的 K 个邻居。

3.在这些相邻点中，计算每个类别中的数据点数量，并将新数据点分配到您计算的相邻点最多的类别。

密码

让我们看看如何使用 Python 中的 K 近邻算法对数据进行分类。在本教程中，我们将使用来自sklearn.datasets模块的乳腺癌数据集。我们需要从导入过程库开始。

import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import confusion_matrix
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
import seaborn as sns
sns.set()

该数据集将肿瘤分为两类(恶性和良性)，包含大约 30 个特征。在现实世界中，你可以查看相关性，并选择在确定肿瘤是否为恶性时起最大作用的特征子集。然而，为了简单起见，我们将随机选择几个。我们必须对分类数据进行编码，以便模型对其进行解释(即恶性= 0和良性= 1)。

breast_cancer = load_breast_cancer()
X = pd.DataFrame(breast_cancer.data, columns=breast_cancer.feature_names)
X = X[['mean area', 'mean compactness']]
y = pd.Categorical.from_codes(breast_cancer.target, breast_cancer.target_names)
y = pd.get_dummies(y, drop_first=True)

正如在另一个教程中提到的，构建模型的目的是用未定义的标签对新数据进行分类。因此，我们需要将数据放在一边，以验证我们的模型在分类数据方面是否做得很好。默认情况下，train_test_split在原始数据集中留出 25%的样本进行测试。

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)

sklearn库在 Python 之上提供了一个抽象层。因此，为了利用 KNN 算法，创建一个KNeighborsClassifier的实例就足够了。默认情况下，KNeighborsClassifier会寻找 5 最近的邻居。我们必须明确地告诉分类器使用欧几里德距离来确定相邻点之间的接近度。

knn = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
knn.fit(X_train, y_train)

使用我们新训练的模型，我们根据肿瘤的平均密度和面积来预测肿瘤是否是良性的。

y_pred = knn.predict(X_test)

我们直观地将我们的模型做出的预测与测试集中的样本进行比较。

sns.scatterplot(
    x='mean area',
    y='mean compactness',
    hue='benign',
    data=X_test.join(y_test, how='outer')
)

plt.scatter(
    X_test['mean area'],
    X_test['mean compactness'],
    c=y_pred,
    cmap='coolwarm',
    alpha=0.7
)

评估我们模型的另一种方法是计算混淆矩阵。混淆矩阵对角线上的数字对应于正确的预测，而其他数字意味着假阳性和假阴性。

confusion_matrix(y_test, y_pred)

给定我们的混淆矩阵，我们的模型具有 121/143 = 84.6%的准确度。

结论

当新数据可用时，K 最近邻算法不需要任何额外的训练。相反，它根据某种距离度量来确定 K 个最近的点(样本必须驻留在存储器中)。然后，它查看每个邻居的目标标签，并将新发现的数据点放入与大多数数据点相同的类别中。鉴于 KNN 计算距离，我们必须扩展我们的数据。此外，由于 KNN 忽略了潜在的特征，我们有责任过滤掉任何被认为不相关的特征。

k 近邻和维数灾难

原文：https://towardsdatascience.com/k-nearest-neighbors-and-the-curse-of-dimensionality-e39d10a6105d?source=collection_archive---------10-----------------------

为什么 k-最近邻算法对额外的维度特别敏感

在我的上一篇文章中，我们学习了 k 近邻建模算法。该算法基于附近数据点与测试点相似的假设，对所需数据点进行分类预测。为了发挥作用，它需要两样东西:

首先，它需要你相信它附近的邻居与它相似的假设。在某些情况下，这是正确的。例如，杂货店中的产品通常被分类到相似的组中。嘎拉苹果和嘎拉苹果存放在一起，嘎拉苹果存放在富士苹果旁边。假设一个节日苹果旁边的物品是另一个节日苹果是非常安全的，假设相邻的物品是一个苹果也是非常安全的。然而，在其他情况下，相邻项目相似的假设是没有用的。我醉抽屉里的一个物品是电池，不代表旁边的物品也是电池。它很可能是一支记号笔、一个回形针或一根橡皮筋。
第二，你需要有一种测量距离的方法。注意，这是空间距离，不一定是物理距离。它指的是你试图比较的两个数据点之间的差异。在上面的例子中，我使用物理距离作为距离，但它也可以是两个房子的平方英尺的差异，两个设备之间的效率差异，等等。

这意味着使用 k-最近邻算法的成功很大程度上取决于拥有密集的数据集。这使得它特别容易受到“维数灾难”的影响。

什么是“维数灾难”？

“维数灾难”是一种半开玩笑的说法，即在高维数据集中有大量的空间。数据空间的大小随着维度的数量呈指数增长。这意味着，为了保持相同的密度，数据集的大小也必须呈指数增长。如果你不这样做，那么数据点开始变得越来越远。

为什么这对于 k 近邻来说特别成问题？

从表面上看，k 近邻似乎对这个问题并不特别敏感。每个机器学习算法都需要密集的数据集，以便在整个数据空间中进行准确预测。如果数据之间有间隙，所有算法都会出错。那么是什么让 k 近邻变得特别呢？

k-最近邻的特殊挑战是它要求一个点在每一维上都是接近的。一些算法可以基于单个维度创建回归，并且只需要点沿着该轴靠近。k 近邻不是这样工作的。它需要所有的点在数据空间的每个轴上都是靠近的。而每增加一个新的轴，通过增加一个新的维度，使得每一个轴上的两个特定点越来越难相互靠近。

Joel Grus 在《从零开始的数据科学》中很好地描述了这个问题。在那本书里，他计算了随着维度数量的增加，一个维度空间中两点之间的平均和最小距离。他计算了 10，000 个点之间的距离，维数从 0 到 100 不等。然后，他继续绘制两点之间的平均和最小距离，以及最近距离与平均距离的比率(Distance _ Closest/Distance _ Average)。

在这些图中，Joel 显示了最近距离与平均距离的比率从 0 维的 0 增加到 100 维的 0.8。这显示了当使用 k-最近邻算法时对维度的基本挑战；随着维数的增加，最近距离与平均距离的比率接近 1，算法的预测能力降低。如果最近点几乎与平均点一样远，那么它的预测能力仅比平均点略高。

思考这个问题如何应用到我们上面的苹果例子中。这有点违背直觉，因为苹果的例子本来就是三维的，但是想象一下，到农产品区中下一个最近的商品的距离大约与平均距离相同。突然，你不能确定最近的东西是另一个苹果，还是一个富士苹果，或者一个橘子，或者一束欧芹。就 k-最近邻算法而言，整个生产部分将会混杂在一起。

当使用 k-最近邻算法时，我如何克服维数灾难？

从根本上来说，问题在于没有足够的数据来衡量维度的数量。随着维度数量的增加，数据空间的大小也会增加，保持密度所需的数据量也会增加。如果数据集的大小没有显著增加，k 近邻将失去所有的预测能力。这使得这个问题的一个可能的解决方案很简单:添加更多的数据。添加越来越多的数据以确保即使在添加更多维度时也有足够的数据密度是完全可能的。如果你有硬件来处理这么大的数据量，这是一个完全合理的解决方案。

当然，您不可能总是拥有添加那么多数据所必需的硬件。不是每个数据科学家都买得起超级计算机。即使这样，也有可能有足够大的数据集，即使是超级计算机也无法在合理的时间内处理它。这就是降维概念发挥作用的地方。降维超出了本文的范围，但是我将在下一篇文章中讨论它。本质上，它指的是识别数据集中的趋势，这些趋势沿着数据集中没有明确指出的维度运行。然后，您可以创建与这些轴匹配的新维度，并删除原始轴，从而减少数据集中的轴总数。

举个例子，假设你在一个城市里绘制了花园侏儒的位置。你得到每个花园侏儒的 GPS 坐标，并把它们标在地图上。你有南北和东西两个维度。现在想象一下，出于某种原因，所有的花园侏儒都被放置在一条穿过城镇的近乎对角线的线上。一个在东南角，一个在西北角，两者之间几乎是一条直线。现在，您可以创建一个名为东南-东北轴的新轴(或者，如果您想变傻，也可以称为“花园侏儒分界线”)，并删除南北和东西轴。这样你就把你的数据集从二维减少到了一维，并且使得 k-最近邻算法更容易成功。

包装它

k-最近邻算法依赖于数据点相互靠近。随着维数的增加，这变得具有挑战性，被称为“维数灾难”对于 k-nearest neighbors 算法来说尤其困难，它要求两个点在每个轴的上非常接近，并且增加一个新的维度为点的远离创造了另一个机会。随着维数的增加，两点之间的最近距离接近两点之间的平均距离，从而消除了 k-最近邻算法提供有价值的预测的能力。

为了克服这一挑战，您可以向数据集中添加更多的数据。通过这样做，您可以增加数据空间的密度，使最近的点更加接近，并恢复 k-最近邻算法提供有价值的预测的能力。只要您有在数据集上执行计算所需的硬件，这就是一个有价值的解决方案。随着数据集变得越来越大，您需要越来越多的计算能力来处理它。最终，数据集的规模将超过你的计算能力。此时，您需要使用维度缩减来用更少的维度呈现所有有价值的信息。该主题将在未来的文章中进行更详细的描述。

k 近邻法:预测乳腺 x 线肿块病变的严重程度

原文：https://towardsdatascience.com/k-nearest-neighbour-predicting-the-severity-of-a-mammographic-mass-lesion-9d897a8f5893?source=collection_archive---------30-----------------------

“通过立即更换临床医生，[该算法]将允许我们实际上加快对潜在威胁生命的情况的及时诊断。”雷切尔·卡尔卡特博士。

Feature Image Source: iStock.com/Aleutie

本文阐述了理解 k-最近邻和调整超参数所需的基本背景。

基于实例的学习(也称为基于记忆的学习)是一个学习算法家族，它不是执行数据点的泛化，而是试图将新的问题实例(测试数据)与提供的数据点(训练数据)进行比较。

基于实例的学习算法的最简单形式之一是最近邻(NN)算法。简而言之，最近邻算法倾向于基于问题空间中数据点的最近邻来对测试数据点进行分类。最近邻算法的主要缺点之一是对噪声非常敏感。现在，最近邻算法的一个广泛使用的扩展是k-最近邻(k-NN)算法。与 k-最近邻中的最近邻不同，我们倾向于寻找测试数据点的 k-最近邻，并且在这些 k-最近邻中的多数投票预测测试数据点的类别。深入挖掘 k-NN 的最佳帖子之一是 Onel Harrison 的关于 K-最近邻算法的机器学习基础。

问题陈述

乳房 x 线照相术是目前乳腺癌筛查最有效的方法。然而，从乳房 x 光片判读得到的乳房活检的低阳性预测值导致大约 70%的不必要活检具有良性结果。为了减少大量不必要的乳腺活检，近年来已经提出了几种计算机辅助诊断(CAD)系统。这些系统帮助医生决定对乳房 x 线照片中看到的可疑病变进行乳房活检，或者改为进行实用的机器学习短期随访检查。

我们能否找到 k-NN 系统的最佳变体，用于根据 BI-RADS 属性和患者年龄预测乳腺 x 线肿块病变的严重程度(良性或恶性)?

特征信息

有 5 个数字特征和一个二元目标类，如下所述:

Features in Mammographic Dataset

数据分为—测试和训练集:

创建了四个数据集，每个测试和训练有两个，因此一个数据集中有要素，另一个数据集中有目标变量。

Train and Test Distribution of dataset

用于评估的 k-NN 变量和超参数:

通过改变距离矩阵来创建 k-NN 变体。改变距离矩阵也引入了许多与该距离相关的超参数。

使用的 k-NN 变体在下面描述

欧氏距离:这是最常见的距离度量，它度量的是两点之间的直线距离。下面提供了计算到数据点 p 和 q 的欧几里德距离的数学公式:

Formula to compute Euclidean distance

欧几里德距离的代码:

def calculateDistances(compArray, queryArray):
 “””
 Computes Euclidean distance-
 :param compArray: takes in 2d array i.e. training dataset 
 :param queryArray: takes in 1d array i.e. instance of test dataset
 :return: sqrtArray :distance between the querry point and each point in training dataset
 sortedIndex : sorted index based on the distance between the querry point and each point in training dataset
 “””
 subArray =np.subtract(compArray,queryArray)
 powArray = subArray**2
 sumArray = np.sum(powArray,axis =1)
 sqrtArray = np.sqrt(sumArray)
 #sorts index of array based on respective location value
 sortedIndex = np.argsort(sqrtArray)
 return sqrtArray,sortedIndex

2.曼哈顿距离:第二种最常见的距离度量是曼哈顿距离，它测量平行于每个轴的距离，而不是像欧几里德距离中观察到的那样对角距离。下面提供了计算到数据点 p 和 q 的曼哈顿距离的数学公式:

Formula to compute Manhattan distance

曼哈顿距离代码:

def calculateManhattanDistances(compArray, queryArray):
 “””
 Computes Manhattan distance-
 :param compArray: takes in 2d array i.e. training dataset 
 :param queryArray: takes in 1d array i.e. instance of test dataset
 :return: sumArray :distance between the querry point and each point in training dataset
 sortedIndex : sorted index based on the distance between the querry point and each point in training dataset
 “””
 subArray =np.subtract(compArray,queryArray)
 subArray= np.absolute(subArray)
 sumArray = np.sum(subArray,axis =1)
 #sorts index of array based on respective location value
 sortedIndex = np.argsort(sumArray)
 return sumArray,sortedIndex

3.闵可夫斯基距离:闵可夫斯基距离提供了一个一般化的公式，以找到适用于不同问题域的复杂距离度量。下面提供了计算到数据点 p 和 q 的闵可夫斯基距离的数学公式:

Formula to compute Minkowski distance

对于上面的等式，如果' a' 被认为是 1，我们将得到曼哈顿距离，如果' a' 被认为是 2，我们将得到欧几里德距离。

闵可夫斯基距离代码:

def calculateMinkowskiDistances(compArray, queryArray, alpha):
 “””
 Computes Euclidean distance-
 :param compArray: takes in 2d array i.e. training dataset 
 :param queryArray: takes in 1d array i.e. instance of test dataset
 :param alpha: this value allow us to play with multiple values in which 1 =manhattan distance and 2= euclidean distance
 :return: sqrtArray :distance between the querry point and each point in training dataset
 sortedIndex : sorted index based on the distance between the querry point and each point in training dataset
 “””
 subArray =np.subtract(compArray,queryArray)
 np.absolute(subArray)
 powArray = subArray**alpha
 sumArray = np.sum(powArray,axis =1)
 sqrtArray = np.power(sumArray, (1./float(alpha)))
 #sorts index of array based on respective location value
 sortedIndex = np.argsort(sqrtArray)
 return sqrtArray,sortedIndex

4.加权欧氏距离:上述距离度量的最大缺点是没有考虑 k 近邻之间的距离有多远或多近，导致 k-NN 模型的误分类。在距离加权 k-NN 中，来自每个邻居的投票被累积，并且基于最近邻居到测试数据点的距离来计算它们对投票的贡献，因此更近的邻居点对类的预测影响更大。计算到数据点 x 和 y 的加权欧几里德距离的数学公式如下:

Formula to compute Weighted Euclidean distance

加权欧几里德距离的代码:

def getWtPrediction(computedListValue, k, n): 
 “””
 This functions helps in generating prediction for each test data point-
 :param computedListValue: takes in list in which distance of that respective test point to all training datapoint are available
 :param k: It is hyper parameter which decides how many nearest neighbour should be kept in consideration while doing prediction.
 :param n: It is another hyper-parameter which decides the power to the inverse distance.
 :return: ndComputedList : which contains prediction based on the given input
 “””
 ndComputedList= np.array(computedListValue)
 ndComputedList.sort(axis=1)
 ndComputedList= ndComputedList[:, :k]
 ndComputedList = 1/pow(ndComputedList,n)
 ndComputedList = np.sum(ndComputedList, axis =1) 
 return ndComputedList

下面提供了基于距离度量的与每个 k-NN 变量相关联的超参数:

欧氏距离: ' k '表示数据集中聚类的个数。

Hyper-parameter for k-NN with Euclidean distance

2.曼哈顿距离: ' k '表示数据集中的聚类数。

Hyper-parameter for k-NN with Manhattan distance

3.闵可夫斯基距离: ' k '表示数据集中聚类的数量。 alpha 表示调节距离测量的整数。

Hyper-parameter for k-NN with Minkowski distance

4.加权欧氏距离: ' k 表示数据集中聚类的个数。 n 表示基于它们之间的距离的最近邻居的贡献。

Hyper-parameter for k-NN with Weighted Euclidean distance

k-NN 变体和超参数观察:

如上所述，针对超参数评估 k-NN 变体。对于一个以上的超参数，该测试发展为结合来自 sklearn 库的 ParameterGrid，以进行网格搜索优化。下面，我们将展示不同距离测量和精度所涉及的超参数。

基于欧氏距离的 k-NN；

因为在使用欧几里德距离时只有一个超参数。因此‘k’相对于精度的散点图如下所示:

k-Value V/S Accuracy for Euclidean distance based k-NN

2.基于曼哈顿距离的 k-NN；

因为在使用曼哈顿距离时只有一个超参数。因此‘k’相对于精度的散点图如下所示:

k-Value V/S Accuracy for Manhattan distance based k-NN

3.基于闵可夫斯基距离的 k-NN；

因为在使用闵可夫斯基距离时有两个超参数。因此‘k’和‘alpha’关于精度的散点图如下所示:

k-Value V/S Accuracy for Minkowski distance based k-NN

alpha-Value V/S Accuracy for Minkowski distance based k-NN

4.基于加权欧氏距离的 k-NN；

因为在使用闵可夫斯基距离时有两个超参数。因此‘k’和‘n’关于精度的散点图如下所示:

k-Value V/S Accuracy for Minkowski distance based k-NN

n-Value V/S Accuracy for Minkowski distance based k-NN

k-NN 变体总体观察:

k-NN 变体的最佳性能在本节中进行评估。

Distance Matrix and Accuracy

在条形图上显示相同的内容:

Distance Matrix and Accuracy

结论:

通过上述观察，可以推断出基于加权欧几里德距离的矩阵在根据 BI-RADS 属性和患者年龄预测乳房 x 线摄影肿块病变的严重程度(良性或恶性)方面非常有效

参考文献:

实用机器学习 课程来自 CIT:

链接到数据集:https://archive.ics.uci.edu/ml/datasets/Mammographic+Mass

代码链接:https://github . com/praveenjoshi 01/cork-institute-of-technology-Practical-Machine-Learning/blob/master/Predicting % 20 the % 20 severity % 20 of % 20a % 20 mamo graphic % 20 mass % 20

卡夫多普

原文：https://towardsdatascience.com/kafdrop-e869e5490d62?source=collection_archive---------8-----------------------

一个开源的 Kafka UI

作为一个信息平台，Kafka 无需介绍。自成立以来，它几乎重写了关于事件流的书籍，并促进了现在家喻户晓的设计模式的采用——微服务、事件源和 CQRS。

作为天赐之物，它几乎逃脱了臭名昭著的缺乏工具的惩罚。你很难找到一个开发人员没有看过内置的 CLI 工具，捧着他们的脸说:“就是这个吗？开什么玩笑？”

外面有什么

随着 Kafka 的流行，一些商业供应商抓住机会通过提供他们自己的工具来赚钱也就不足为奇了。卡夫卡工具、兰多普、和卡德克就是一些例子，但它们都是仅供个人使用的，除非你愿意付费。(这并不是说你不应该这样做，恰恰相反，但这不是重点。)在商业环境中的任何非平凡使用都将违反其许可条款。在家里用它们做教程或个人项目是一回事；当你在没有适当许可的情况下使用商业工具时，你是在让你的雇主面临诉讼的风险，是在拿你的职业生涯玩俄罗斯轮盘赌。

但是开源呢？

说到 Kafka 主题查看器和 web UIs，首选的开源工具是 Kafdrop 。在撰写本文时，Docker pulls 已经达到 80 万，享受到这种采用水平的 Kafka 工具并不多。这背后有一个原因:Kafdrop 做了一项惊人的工作，填补了 Kafka 的可观察性工具中的明显空白，解决了社区已经指出太久的问题。

Kafdrop 是一个 Apache 2.0 许可项目，就像 Apache Kafka 本身一样。所以不会花你一分钱。如果你还没有使用过它，你可能应该使用它。所以让我们深入了解一下。

它能做什么？

查看 Kafka brokers —主题和分区分配，以及控制器状态
查看主题 —分区计数、复制状态和自定义配置
浏览消息 — JSON、纯文本和 Avro 编码
查看消费者群体 —每个分区的停放偏移量、组合偏移量和每个分区的延迟偏移量
创建新主题
查看 ACL

入门指南

Kafdrop web UI 项目托管在 GitHub 上:

[## obsidiandynamics/kafdrop

Kafdrop 是一个用于查看 Kafka 主题和浏览消费群体的 web UI。该工具显示如下信息…](https://github.com/obsidiandynamics/kafdrop)

你有几个选择。你可以通过克隆库并从源代码开始构建来显示一点勇气。这是一个 Java (JDK 11) Spring Boot 项目，只要安装了 JDK，就可以用一个 Maven 命令来构建它。如果你想走这条路，回购的README.md文件将引导你通过这些步骤。现在，让我们采取简单的方法——Docker。(我当然会。)

启动 Kafdrop

Docker 图片托管在 DockerHub 上。图像标有 Kafdrop 发布号。标签指向最新的稳定版本。

要在前台启动容器，请运行以下命令:

docker run -it --rm -p 9000:9000 \
    -e KAFKA_BROKERCONNECT=<host:port,host:port> \
    obsidiandynamics/kafdrop

必须将KAFKA_BROKERCONNECT环境变量设置为代理的引导列表。

就是这样。我们应该开始运作了。一旦启动，您可以通过导航到 localhost:9000 来启动 Kafka web UI。

注意: 上面的例子假设一个通过明文 TCP 套接字的认证连接。如果您的集群配置为使用身份验证和/或传输层加密，请咨询 *README.md* 了解连接选项。为 SASL/SSL 锁定集群配置 Kafdrop 实际上非常容易。

在卡夫卡的沙盒中奔跑

没有卡夫卡经纪人吗？别担心。只需使用下面的docker-compose.yaml文件来调出一个 Kafka + Kafdrop 栈:

version: "2"
services:
  kafdrop:
    image: obsidiandynamics/kafdrop
    restart: "no"
    ports:
      - "9000:9000"
    environment:
      KAFKA_BROKERCONNECT: "kafka:29092"
    depends_on:
      - "kafka"
  kafka:
    image: obsidiandynamics/kafka
    restart: "no"
    ports:
      - "2181:2181"
      - "9092:9092"
    environment:
      KAFKA_LISTENERS: "INTERNAL://:29092,EXTERNAL://:9092"
      KAFKA_ADVERTISED_LISTENERS: "INTERNAL://kafka:29092,EXTERNAL://localhost:9092"
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: "INTERNAL:PLAINTEXT,EXTERNAL:PLAINTEXT"
      KAFKA_INTER_BROKER_LISTENER_NAME: "INTERNAL"

现在用docker-compose up启动堆栈。一旦启动，浏览到 localhost:9000 。

浏览 Kafka Web 用户界面

浏览集群

集群概述屏幕是网络用户界面的登录页面。

您可以看到集群的整体布局——组成集群的各个代理、它们的地址和一些关键的代理统计信息——它们是否是控制器以及每个代理拥有的分区数量。后者非常重要——随着集群规模和主题数量(以及分区数量)的增长，您通常希望看到分区在集群中的大致水平分布。

接下来是主题列表，在大多数情况下，这就是你在这里的真正目的。任何合理规模的基于微服务的生态系统可能有数百个，如果不是数千个主题的话。如你所料，这个列表是可搜索的。每个主题旁边显示的统计数据相当单调。值得注意的是复制不足的列。本质上，它告诉我们落后于主分区的分区副本的数量。零是个好数字。任何其他情况都表示需要立即关注的代理或网络问题。

注: Kafdrop 是发现探索工具；它不是实时监控工具。当出现问题时，你应该通知你的经纪人并发出警报。

列出主题

点击列表上的主题，进入主题概述屏幕。

屏幕分为四个部分。

在左上角，有一个主题 stats 的摘要—这是一个方便的视图，与您在集群概述中看到的没有什么不同。

在右上角，您可以查看自定义配置。在上面的例子中，主题运行一个股票标准配置，所以没有什么可看的。如果配置被覆盖，您会看到一组自定义值，如下例所示。

左下部分列举了分区。分区索引是链接—点击将显示主题中的前 100 条消息。

该部分显示了几个有趣的参数:

分区 ID :分区在其包含主题内的从零开始的索引。
第一个偏移量:分区中最早消息的偏移量。如果分区为空，则第一个偏移量与高水位线相同。
Last offset :分区的高水位线，是将分配给下一个发布的消息的偏移量。
大小:分区中消息的数量。
Leader Node :当前充当 Leader 的代理节点的 ID。
副本节点:持有分区副本的所有代理节点的 id。这包括领导者 ID。
同步复制节点:同步复制节点的 id，包括首节点。
离线副本节点:当前离线的副本节点的 id。在正常情况下，这应该是一个空集。
首选首领:当前首领节点是否恰好是首选首领节点。
复制不足:分区是否复制不足，即至少有一个副本与主分区不同步。

右下方的消费者部分列出了消费者组名称以及它们的总延迟(所有单个分区延迟的总和)。

查看消费者群体

点击主题 Overview 上的消费者组，进入消费者视图。该屏幕提供了单个消费者群体的全面细分。

视图按主题划分。对于每个主题，单独的表列出了基础分区。针对每个分区，我们可以看到提交的偏移量，我们可以将它与第一个和最后一个偏移量进行比较，以了解我们的使用者是如何跟踪的。方便的是，Kafdrop 显示每个分区的计算滞后，它聚集在每个主题表的页脚。

注: 有些量的滞后在所难免。对于发布的每条消息，在发布点和消费点之间总会有一段时间。在 Kafka 中，这个时间通常是几十或几百毫秒，取决于生产者和消费者客户端选项、网络配置、代理 I/O 能力、页面缓存的大小和无数其他因素。你需要注意的是增长滞后——表明消费者要么跟不上，要么已经完全停滞。在后一种情况下，您还会注意到，即使在生成器空闲时，滞后也没有被耗尽。这是你需要从 Kafdrop 切换到你最喜欢的调试器的时候。

查看邮件

消息视图屏幕是梦寐以求的主题查看器，很可能就是它把你带到了这里。您可以通过以下两种方式之一进入邮件视图:

点击主题概览屏幕上的查看消息按钮。
单击主题概述中的单个分区链接。

这正是您所期望的——一个按时间顺序排列的消息列表(或者用 Kafka 的说法是记录)。

每个条目都方便地显示了偏移量、记录键(如果设置了的话)、发布的时间戳以及生产者可能添加的任何头。

凯卓的袖子里还有一个小把戏。如果消息碰巧是有效的 JSON 文档，主题查看器可以很好地格式化它。单击消息左侧的绿色箭头将其展开。

最后

使用 Kafka 的次数越多，您就越会发现并欣赏它的真正潜力——不仅仅是作为一个多功能的事件流平台，而是作为一个通用的消息中间件，允许您从异步、松散耦合的服务组装复杂的业务系统。

与过去更成熟的 MQ 经纪人相比，您总是会经历一项最近才进入主流的技术所带来的挫折。令人欣慰的是，开源社区并没有停滞不前，而是产生了一个不断发展的生态系统，为我们继续工作提供了必要的文档和工具。作为回报，我们至少可以偶尔提出一个 pull 请求，或者回答一个或三个 StackOverflow 问题。

这篇文章对你有用吗？我很想听到你的反馈，所以不要退缩！如果你对卡夫卡或者事件流感兴趣，或者只是有什么疑问， 在 Twitter 上关注我 。

巴黎 2019 年 Kaggle Days

原文：https://towardsdatascience.com/kaggle-days-2019-in-paris-8e2844c86198?source=collection_archive---------11-----------------------

Kaggle Days 是数据科学家和 ka ggler 的第一个全球线下活动系列。这样的盛会为创建和构建数据科学社区提供了机会。2018 年，首次在华沙举办的名为 Kaggle Days 的活动取得了成功。100 多名参与者在生动的演示和研讨会中向 Kaggle 大师学习。对许多人来说，亮点是有史以来第一次 Kaggle 线下比赛，一整天的现场挑战。

第二个 Kaggle Days 发生在巴黎。参与者数量增加了一倍:从 400 多个应用程序中选择了大约 200 名数据科学家、Kagglers 和对机器学习感兴趣的人。标准的讲座、研讨会和竞赛项目被一些新的形式所丰富，如头脑风暴会议和有经验的导师的咨询。

参与者的动机

可以将当前的数据科学和机器学习分为 3 大类:商业、学术和竞赛(见下图)。每个领域都有自己的目标和目的:企业努力实现利润最大化，研究人员努力增加高质量出版物的数量，竞争对手努力实现最高职位竞争数量的最大化。每个领域对数据科学和机器学习的“适当”方法都有自己的理解:例如，为分数增加 1%而进行几层下注是机器学习竞赛的常见做法，但通常是生产中部署的禁忌；科学上没有新颖性的方法可能不会在期刊上发表，但可以很容易地应用于学术或工业。

3 major Data Science and Machine Learning fields (picture from Vladimir Iglovikov’s blog post)

然而，电流场是紧密相连的，尽管它们在空间中不是独立存在的。思想、方法和技巧可以通过一些改变从一个领域转移到另一个领域，以达到最佳效果。大概 Kaggle，这个举办各种机器学习比赛的地方，就是在这个意义上检验思想和方法的最佳场所之一。

每个参与者都希望在比赛中在排行榜上获得尽可能高的分数。这需要想出各种各样的想法，然后测试它们。当然，绝大多数的想法不会是好的，但是剩下的那些可以提高你的分数的想法是非常有价值的。竞赛结束后，您可以在工作、做研究或参加各种竞赛时使用这些想法。因此，Kaggle 是一个在 DS 和 ML 领域选择可行的想法和方法的平台。最近发表了一篇很棒的关于如何正确“养殖”Kaggle 的文章。

Kaggle Days 是一个顶级 kag gler 通常分享他们对某些任务的愿景的地方，这些任务已经在比赛、生产和研究中得到验证。对我来说，这是一个很好的机会来看看同样的问题，但从他们的角度来看。所以，我利用这个机会学习了一些新的东西。

第一天

第一天是讲座和研讨会。很难讲清楚每场演讲的每一个细节，因此，我决定提到其中最有趣的三个，并对它们补充一些想法。

“超越特征工程和超参数优化”，作者江泽龙·普吉特

江泽龙讲述了他在 Kaggle 和工作期间解决数据科学问题的方法。他从一个简单的想法开始:许多数据科学家不太重视探索性数据分析(EDA)，这是结果不佳和得分低的一个原因。EDA 的目标是在数据中发现一些隐藏的模式，这可能会导致对特征工程的见解，但不是绘制花哨的图形和可视化。伟大的 EDA 提出问题，然后提供问题的答案。如果你不熟悉 EDA，一定要读一读 Cole Nussbaumer Knaflic 写的关于当前主题的最伟大的书《用数据讲故事》。我强烈推荐看一看一个简短的摘要:用两种语言写的:英语、俄语和 T2 语。

关于特性工程和选择的另一个展示点是:创建一个小的特性数量，而不是大的，但是要让它有意义。总的想法很简单:问问你自己，在当前任务中什么是真正重要的特性，你如何利用现有的数据来创建它。就我而言，我认为当前的方法在应用于商业问题时要好得多，因为它允许有意识地选择要收集的数据。有时，新数据收集并不需要太多的努力，但它在很大程度上影响模型的质量。

但是创造好的特性的最好方法是什么呢？我们可以通过检查以前类似任务的比赛来找到特征工程的灵感，以便找到最重要的特征并将相同的逻辑应用于给定的问题。另一种方法是使用问题领域知识。在这种情况下，我们可能会受到我们对问题的理解方式的限制，因此，没有能力找到新的模式。此外，数据科学家并不总是任务领域的专家。在这种情况下，关于当前主题的论文和文章可能会有所帮助。

结论:开始创建有意义的 EDA，它提出问题，然后试图利用可用数据回答这些问题。从“使用数据时我们可以创建什么功能？”的角度来思考思维模式的转变到“当前任务中有哪些好的特性，在使用给定数据时如何创建它们？如果我们不能，我们如何获得相关数据？”。

Alberto Danese 的“ML 可解释性”和 Konstantin Lopukhin 的“图像和文本的可解释神经网络”

这两个讲座有许多共同之处，因此，我决定把它们结合在一起。两场讲座都在谈论一个常见的现代数据科学主题——模型的可解释性——模型以人类可以理解的方式呈现预测的能力。根据 2018 年 6 月 O'Reilly 的调查，11400 名数据专家中约有一半(49%)表示他们处于机器学习的探索阶段，尚未将任何机器学习模型部署到生产中。65%的受访者表示，可解释性和透明度是他们的模型构建清单的一部分，相比之下，48%的受访者表示遵从，45%的受访者表示确保用户对数据和模型的控制。

因此，我们可以得出结论，在选择是否部署模型时，模型的决策方式实现是重要的。在这样的分析过程中，我们想要回答几个简单的问题:这个模型是否偏向于某些特性？它能对新数据进行很好的归纳吗？我们能相信它的预测吗？通常，我们将所有可用的数据分成训练、验证和测试部分，以便回答这些问题。然后，我们在训练部分训练我们的模型，在验证数据集上调整超参数，并通过测试数据获得我们的管道分数。我们假设测试部分与我们在模型使用过程中得到的数据相似，因此测试部分的分数是可靠的。

然而，《T2》中描述的“哈士奇大战狼”实验，我为什么要相信你解释任何分类器的预测，向我们展示了这种方法的一些局限性。在当前的实验中，卷积神经网络被训练成在有偏差的数据集上对哈士奇/狼进行分类——狼的图片总是包含雪。作者没有提供这样的分类准确性，但我假设它在训练和测试部分都很高，因此上述模型评估方法会给我们体面的分数，因此我们可以部署该模型。

向参与者展示了分类解释-免费图片，并询问了三个问题:

你相信这种算法在现实世界中能很好地工作吗？
你为什么这么想？
你认为算法如何区分这些狼和哈士奇的照片？

在他们回答之后，会展示预测解释图片(见下图),参与者会被问同样的三个问题。正如您所料，对模型的整体信任度显著下降。

“Husky vs Wolf” experiment results (“Why Should I Trust You?” Explaining the Predictions of Any Classifier)

这个实验过于简单，但我们仍然可以得出几个结论，我认为最重要的结论如下:我们可以从模型的预测实现中找到机器学习管道的“弱点”。在与这些点合作后，我们的管道质量将会提高。例如，我们可能会发现数据中的偏差，用没有雪的狼的图片丰富我们的数据集，或者删除图片背景。

结论:理解模型的预测可以通过消除“弱点”来增加机器学习管道的良好性。

斯坦尼斯拉夫·谢苗诺夫的《机器学习的技巧和诀窍》

Stanislav 的演示结合了他多年参加机器学习竞赛的经验，形成了独特的技巧列表。在我看来，最有趣的是最后一条，它显示了任务重组的重要性，我们可以利用我们的优势。

任务来自希腊媒体监督多标签分类。在当前的竞争中，我们必须为印刷媒体文章选择合适的标签。每篇文章可以有几个标签(例如体育、英格兰、足球)。主题数量事先是未知的，可能是一个、两个甚至五十个主题，度量标准会惩罚我们选择太少或太多的主题。那么我们应该如何选择呢？

解决这一挑战的可能方法是选择具有较高概率的恒定主题数，或者选择概率大于某个阈值的主题。第一种情况下的主题数量和第二种情况下的阈值是超参数，可以使用验证数据集进行优化。然而，让我们从另一个角度来看这个问题。我们将在术语中表述相同的问题，这将允许我们在使用数据驱动的方法时解决它。

对于每篇文章，我们可以预测训练部分的某些主题可能性(进行折叠预测)。此外，我们知道基本事实——实际的主题数量。我们可以为每个示例计算一个最佳阈值，并将其用作附加后处理模型的目标。

我们用术语来表述这个问题，这允许我们在使用数据驱动的方法时解决它。在这种情况下，我们的目标是精心制作一些基本事实标签(给定文章的实际主题数量或最佳概率阈值)和描述每篇文章的特征(文章特征、输出主题概率的统计数据等)。

结论:如果你在任务上停滞不前，尝试以某种方式重新制定它，允许生成特征和地面实况目标，然后使用机器学习工具解决它。

第二天

第二天组织了 11 小时的 ka ggle-like 比赛。路易威登提供了这项任务——根据前 7 天销售的各种信息(销售数量、价格、社交网络的情绪分析、经济因素、照片、网站数据)预测未来三个月的产品销售数量(各种商品:包、鞋、皮带等)。为我们提供了产品的培训数据和目标，这些数据和目标在 2017 年发布，测试期包含 2018 年发布的产品。

Similar to Data Scientists free time 😃

由于导师会议，整个比赛流程非常有趣和愉快。每个参与者都可以和有经验的棋手(大师、特级大师)一对一交谈，并问任何问题。我没有错过这个机会，并询问他们关于在比赛和实际工作中突出工程的想法；此外，我从经验丰富的大师那里收到了关于我的比赛进程的非常有建设性的反馈。

最终，我在 77 支队伍中获得了第 22 名，这是一个不错的成绩。其中一名获胜者公布了他们的方法——对过度拟合说是。

希望在接下来的几天里我会改进它。

From left to right: Yana Pleskova, Stanislav Semenov (former top 1 in Kaggle rankings), Denis Vorotyntsev (author of this blog post), Anthony Goldbloom (CEO of Kaggle), Pavel Pleskov (currently top 5 in Kaggle rankings), Pavel Ostyakov (currently top 4 in Kaggle rankings)

Kaggle For 初学者:入门

原文：https://towardsdatascience.com/kaggle-for-beginners-getting-started-75decb43c0c0?source=collection_archive---------22-----------------------

本文的目的是帮助你开始使用 Kaggle 并加入世界上最大的机器学习和数据科学社区。

那么 Kaggle 是什么？

正如他们所说，Kaggle 是“数据科学的家园”。这是通过动手的数据科学和机器学习项目学习和拓展技能的最佳场所。

你还在等什么？前往 Kaggle ，点击一下就可以注册🏃。

Kaggle 上的编程语言

Python 和 R 都在 Kaggle 上很受欢迎，你可以使用其中任何一个进行 kaggle 比赛。

卡格尔服务公司

1.机器学习竞赛

这就是 kaggle 出名的原因。找到你觉得有趣的问题，比赛构建最好的算法。

卡格尔比赛的常见类型

你可以在 kaggle 上按类别搜索比赛，我会告诉你如何获得新手“入门”比赛的列表，这些比赛总是可用的，没有截止日期😃。

特色比赛大概是 Kaggle 最为人熟知的比赛类型。它们通常由公司、组织甚至政府赞助。他们提供高达 100 万美元的奖金。
研究竞赛的特色问题比特色竞赛问题更具实验性。由于他们的实验性质，他们通常不提供奖励或积分。
入门竞赛的结构类似于特色竞赛，但它们没有奖金池。它们具有更简单的数据集、大量的教程，并且没有截止日期——这正是新手需要开始的！😃。入门竞赛的一个例子是:

泰坦尼克号:机器从灾难中学习——预测泰坦尼克号上的幸存者

游乐场竞赛是一种“为了好玩”的 Kaggle 竞赛，比入门难度高一步。奖品从荣誉到小额现金不等。操场竞赛的一个例子是:

狗对猫——创造一种算法来区分狗和猫

how to find getting started competitions

Kaggle 竞争环境

kaggle competition environment

下面是选项卡的快速浏览

概述:问题的简要描述、评估标准、奖品和时间表。
数据:是你可以下载和了解比赛中使用的数据的地方。您将使用一个训练集来训练模型，并使用一个测试集来进行预测。在大多数情况下，数据或其子集也可以在内核中访问。
内核:你和其他竞争对手以前做过的工作。回顾流行的内核可以激发更多的想法。您可以通读其他脚本和笔记本，然后复制代码(称为“Fork”)进行编辑和运行。
讨论:另一个有用的资源，你可以在这里找到来自比赛主持人和其他参赛者的对话。这是一个提问和学习他人答案的好地方。
排行榜:每场比赛都有公开排行榜和私人排行榜。注意，排行榜是非常不同的。公共排行榜根据提交数据的代表性样本提供公开可见的提交分数。该排行榜在整个比赛过程中都可以看到。虽然它给你一个好主意，但它并不总是反映谁会赢谁会输。私人排行榜才是真正重要的。它根据参与者看不到的数据跟踪模型性能。因此，私人排行榜对谁的模型最好，以及谁将成为比赛的赢家和输家有最终决定权。比赛结束才算。
规则:包含管理您参与赞助商竞赛的规则。开始前阅读规则是非常重要的。
团队:您可以在此选项卡上执行许多不同的团队相关操作。
我的参赛作品:查看您之前的参赛作品，选择最终参赛作品。
提交预测:要提交新预测，请使用“提交预测”按钮。这将打开一个允许您上传提交文件的模式。

2.数据集

Kaggle 数据集是发现、探索和分析开放数据的最佳场所。您可以找到许多不同类型和大小的有趣数据集，您可以免费下载并提高您的技能。

how to choose a dataset

3. Kaggle 学习课程

Jupyter 笔记本中教授的免费微课，帮助您提高当前技能。

4.讨论:

一个向 Kaggle 社区的数千名数据科学家提问和寻求建议的地方。

共有六个通用站点论坛:

Kaggle 论坛 :针对 Kaggle 社区的事件和话题
入门 :新手提问讨论的第一站
产品反馈 :告诉 kaggle 你喜欢什么，讨厌什么，或者希望什么
问题&答案 :其他数据科学家的技术建议
数据集 :开放数据的请求和讨论
学习 :与 相关的问题、答案、请求 Kaggle 学习课程

Types of Kaggle discussions

5.内核

Kaggle 内核本质上是浏览器中的 Jupyter 笔记本。这些内核完全免费运行(你甚至可以添加一个 GPU)。这意味着您可以省去设置本地环境的麻烦。它们还允许您共享 Python 或 r 中的代码和分析。它们还可以用于参加 Kaggle 比赛和完成 kaggle 学习课程。探索和阅读其他 Kagglers 的代码是学习新技术和参与社区的好方法。

选择一个数据集，然后点击几下就可以旋转出一个新的内核

Click the Kernel tab of the competition then click new kernel

Kaggle 内核环境

以下是如何打开 GPU、更改内核语言、公开内核、添加合作者以及安装未预装的包，因为 kaggle 内核预装了最流行的 python 和 R 包😃。

Remember kaggle’s run time limitly is currently 9 hours

向内核添加数据集

您可以从您的计算机、kaggle 竞赛或其他 ka ggler 的公共内核向您的内核加载额外的数据集。

内核版本

当您提交并运行内核时，它会运行您的所有代码，并将其保存为一个稳定的版本，供您以后参考。然而，你的代码总是保存你去😃。

Committing a kernel

分叉 Kaggle 内核

您可以从其他用户那里复制并构建现有的内核😃。

Don’t forget to vote for kernels you liked

Click the three dots to learn about what else Kaggle has to offer you 😃

你一路赶到这里？！感谢阅读。😆

恭喜你！你现在是卡格勒了👏🎉。

如果您有任何问题或意见，请在下面留下您的反馈，或者您可以随时通过 Twitter 联系我。在那之前，下一篇文章再见！✋.

参考

[## 如何使用 Kaggle

编辑描述

www.kaggle.com](https://www.kaggle.com/docs)

Kaggle 内核初学者指南—循序渐进教程

原文：https://towardsdatascience.com/kaggle-kernels-for-beginners-a-step-by-step-guide-3db6b1cd7606?source=collection_archive---------4-----------------------

不久前，我写了一篇名为“用 Kaggle 内核展示你的数据科学技能”的文章，后来我意识到，尽管这篇文章很好地说明了 Kaggle 内核对于数据科学家来说是一个强大的投资组合，但它并没有说明一个完全的初学者如何开始使用 Kaggle 内核。

这是一次尝试，握住一个完全初学者的手，带他们走过 Kaggle 内核的世界——让他们开始。

享受 78%的 DataCamp 折扣

在 Kaggle 上注册—【https://www.kaggle.com/

如果你没有 Kaggle 账号，第一步是在 Kaggle 上注册。你可以使用你的谷歌账户或脸书账户创建新的 Kaggle 账户并登录。如果以上都不是，您可以输入您的电子邮件 id 和您的首选密码，并创建您的新帐户。

Kaggle Registration Page

登录 Kaggle

如果您已经有了一个帐户或者刚刚创建了一个帐户，请单击页面右上角的登录按钮启动登录过程。同样，你可以选择用你创建账户时输入的用户名和密码登录谷歌/脸书/雅虎或者最后一个。

Kaggle Login/Signin Screen

Kaggle 仪表盘

登录后，您将被带到 Kaggle 仪表盘。(只是欢迎页面，不知道还能叫什么，所以叫它仪表板)。

这是您登录后立即出现的登录页面(如果您从https://www.kaggle.com/登录)。它有许多组成部分，其中有几个:

Kaggle 最近更新或推荐给您的 Kaggle 内核提要
个人资料摘要(右侧边栏的第一个)
招聘广告(右侧栏)
您的竞争对手(右侧栏—向下滚动后)
您的内核(右侧栏—向下滚动后)

我们接下来要去的地方是导航栏中顶部的内核按钮。

Kaggle 内核列表(最热门):

一旦我们在 Kaggle 旅程的任何地方点击顶部内核按钮，我们就会进入这个屏幕。

这是每个人都试图看到他们的内核的屏幕，因为这就像是内核的首页，这意味着如果它出现在这里，你的内核更有可能获得更多的可见性。内核页面的默认排序顺序是热度，这是基于 Kaggle 的秘密酱算法，以保持显示相关的内核，但它也有其他选项(排序)，如新，大多数投票等。Kaggle 也使用这个页面来宣传是否有任何内核竞争正在发生/将要发生。

当我们在这里时，内核竞赛是 Kaggle 竞赛，它不属于竞赛层，因为竞赛的性质是输出是 Kaggle 内核，并且更经常地专注于讲故事。《为好的数据科学》就是这样一系列核心竞赛之一，数据科学家/卡格勒希望利用数据科学帮助解决一个社会问题。为了更好地理解它，你应该看看内核大师 希瓦姆·班萨尔 的内核，他已经养成了多次赢得它们的习惯。

Kaggle 内核—新的/创建的:

现在，我们已经理解了 Kaggle 内核的元，我们可以直接进入新内核的创建。创建 Kaggle 内核有两种主要方法:

从 Kaggle 内核(首页)使用新的内核按钮
使用新内核按钮从数据集页面

方法#1:从 Kaggle 内核(首页)使用新内核按钮

正如你在上面的截图中所看到的，点击内核页面中的新内核按钮可以创建一个新的内核。如果您正在尝试练习自己的东西或计划输入自己的数据集，这种方法很好。如果你想为 Kaggle 上已经存在的数据集创建一个内核，这种方法是不可取的(在我看来)。

方法#2:使用新内核按钮从数据集页面

这是创建新内核最常用的方法之一(至少对我来说)。您可以打开您感兴趣的数据集的数据集页面(就像下面截图中的那个)，然后在那里单击新建内核按钮。这种方法的优点是，与方法#1 不同，在方法#2 中，创建内核的 Kaggle 数据集附带在内核中(默认情况下),从而使向内核输入数据集这一枯燥的过程变得更加容易、快速和简单。

https://www.kaggle.com/google/google-landmarks-dataset

Kaggle 内核—内核类型:

不管方法#1 还是#2，一旦你点击了新的内核，你将会看到这个模态屏幕来选择你想要创建的 Kaggle 内核的类型。

大体上分为两类——1 .剧本 vs . 2。笔记本。

众所周知，笔记本(基于单元格的布局)就是 Jupyter 笔记本，脚本就是你可能要编写的代码——py charm 或 Sublime Text 或 RStudio。此外，对于 R 用户来说，该脚本是 RMarkdown 的内核类型——这是从 R 以编程方式生成报告的一种很好的方式。

总结一下内核的类型:

脚本
- Python
- R
- RMarkdown
**笔记本
*** Python ***** R

Kaggle 内核—内核语言:

第二级内核语言选择只发生在第一级内核类型选择之后。

如上面脚本类型的 Kaggle 内核的 GIF 图所示，内核的语言可以通过进入设置，然后选择所需的语言——R/Py/RMarkdown 来更改。相同的设置还提供了使内核共享公开的选项(除非公开，否则默认情况下是私有的)。如果你正在做你的大学作业或者自学，而你不想公开代码，那么通常使用私有内核。私有内核也被 Kaggler 使用，他们参与竞争以利用 ka ggle 的计算能力，但不透露他们的代码/方法。

笔记本内核:

类似于上面的 GIF，在选择了内核类型脚本的地方，也可以选择笔记本来创建笔记本内核。

RMarkdown 内核—(内核类型:脚本> RMarkdown)

RMarkdown 结合使用 R 和 Markdown 来生成嵌入了交互式可视化的分析报告。虽然这是解释 RMarkdown 的最简单的方式，但它的用途和潜力远远超出了定义。

幸运的是，Kaggle 内核脚本支持 Rmarkdown，这意味着它可以帮助创建交互式文档和更多在基于笔记本的场景中不可能实现的内容。这是一个由 Saba Tavoosi 在 Kaggle 内核上构建的成熟的交互式仪表盘，它不仅展示了 Kaggle 内核在构建机器学习模型方面的潜力，也展示了以最佳形式进行交互式讲故事的潜力。如果你有兴趣学习如何使用 flexdashboard 构建仪表盘，请查看本课程。

Kernel Courtesy: Saba Tavoosi

复制和编辑(以前称为分叉)

类似于 Github 中的 Fork 选项，如果你想获取一个现有的 Kaggle 内核并在你自己的空间中使用它——修改或赋予你自己的风格——你需要使用右上角的蓝色按钮Copy and Edit。事实上，在 Kaggle 竞赛赛道上的许多机器学习竞赛中，许多高分公共内核通常是forks of forks forks，其中一个 Kaggler 会改进其他 Kaggler 已经建立的模型，并将其作为公共内核提供。

Marked Symbol denotes a Forked / Copied and Edited Kernel

公共/私有内核

正如我们在前面另一节中看到的，Kaggle 内核的访问设置可以是公共的，也可以是私有的。公共内核(顾名思义)对每个人(包括 ka ggler 和非 ka ggler)都是可用的和可见的。私有内核只对拥有者(创建者)和与拥有者共享内核的人开放。公共内核也可以建立在私有数据集上。比方说，这是一场机器学习比赛，你已经用一些第三方数据做了一些特征工程，你不想在比赛期间透露这些数据。这是一个典型的场景，Kagglers 通常将他们的数据集保持私有，但将内核设为公共，这样其他人就可以看到他们的方法并从中学习。

上面的屏幕截图展示了如何将现有内核的访问设置更改为私有或公共。默认情况下，所有新创建的内核都是私有的(在撰写本文时)，如果需要，所有者可以将其更改为公共的。

TL；DR——如何创建新的 Kaggle 内核

如果上面的一切乍看起来有点太沉重而难以理解，这一节将帮助你创建你的第一个 Kaggle 内核。

步骤:

使用您的凭证登录 Kaggle
转到任何公共 Kaggle 数据集
点击右上角的新内核(蓝色按钮)
选择您感兴趣的笔记本/脚本
如果 Python 是您选择的语言，请保持原样，如果是 R，则转到右侧的设置并单击展开项目，您可以看到语言旁边的 Python ，您可以单击该语言以更改为 R
转到屏幕的编辑器部分/窗格(左侧),开始编写漂亮的代码(上面的 GIF 也说明了如何使用创建内核的数据集)
一旦您的代码完成，点击右上角的提交(蓝色按钮)
如果您的内核执行成功(没有任何错误)，公开您的内核(通过编辑内核设置>共享(公共)或者通过再次打开内核并点击顶部的访问按钮)
在这个阶段，你的第一个 Kaggle 内核必须准备好通过你的网络与你的朋友分享！

查看此 Kaggle 视频寻求帮助。

结局

对于许多 ka ggler 来说，竞赛赛道是他们的乐趣所在，但对我来说，Kaggle Kernels 赛道是我的事情，它为我们提供了完成全栈数据科学之旅的巨大潜力，从数据准备到数据可视化——从机器学习建模到讲故事。希望你也会喜欢。祝你的 Kaggle 内核之旅好运。

在我的 Kaggle 个人资料 查看我的 Kaggle 内核，并在 我的 Linkedin 个人资料 与我分享您的反馈。本教程使用的视频/gif/截图可在my github上获得。

ka ggle vs . Colab face off——哪个免费 GPU 提供商是 Tops？

原文：https://towardsdatascience.com/kaggle-vs-colab-faceoff-which-free-gpu-provider-is-tops-d4f0cd625029?source=collection_archive---------4-----------------------

规格，UX，以及 fastai 和混合精度训练的深度学习实验

谷歌有两款产品可以让你在云中免费使用 GPU:Colab 和 Kaggle。如果你对深度学习和人工智能感兴趣，它们会非常棒。本文的目标是帮助您更好地选择何时使用哪个平台。

Kaggle 刚刚获得了 Nvida 特斯拉 P100 图形处理器的速度提升。🚀然而，正如我们将在计算机视觉实验中看到的，Colab 的混合精度训练有助于缩小速度差距。* * 2019 年 4 月 25 日更新— Colab 现在有了 Nvidia T4s。对于混合精度来说，它们真的很快。另外，随着硬件的改进，我不打算继续更新这篇文章。😄**

在本文中，我们将向您展示如何比较硬件规格和探索 UX 的差异。我们还将把计算机视觉任务的训练时间与迁移学习、混合精度训练、学习速率退火和测试时间增加进行比较。

我们开始吧！👍

Twin peaks Colab and Kaggle, side by side in the Google range

Kaggle 和 Colab 是相当相似的产品。卡格尔和科拉布

提供免费的 GPU
在浏览器中提供 Jupyter 笔记本——尽管有他们自己独特的风格
旨在促进机器学习的合作。
是谷歌的产品
并不完美，但在许多情况下非常有用——尤其是当你开始深度学习的时候。😄
不要提供关于他们硬件规格的大量信息

最后一点我们一会儿会深入探讨。不幸的是，当你使用他们的环境时，Kaggle 和 Colab 都不会告诉你确切的规格。确实存在的文件往往已经过时(见此处截至 2019 年 3 月 11 日)。此外，屏幕上的小部件讲述了一些故事，但与我发掘的不同。我将向您展示常见的 profiler 命令，您可以使用这些命令来查看您的环境规格。

首先，简单介绍一下 GPU 的背景——如果这是老一套的话👒对你来说，请随意跳过前面。

什么是 GPU？

GPU 是图形处理单元的简称。GPU 是专门的芯片，最初是为了加速视频游戏的图形而开发的。他们快速地做许多矩阵计算。对于深度学习应用来说，这是一个非常方便的特性。有趣的事实:出于同样的原因，GPU 也是加密货币挖掘的首选工具。

Nvidia P100 GPU

为什么要用 GPU？

使用具有足够内存的 GPU 使训练深度学习网络的速度比单独使用 CPU 快很多倍。因为在几分钟或几小时内而不是几天或几周内获得反馈要好得多，所以如果你对深度学习感兴趣，你会想要使用 GPU。毫无疑问。😃

规范

截至 2019 年 3 月初，Kaggle 已经将其 GPU 芯片从 Nvidia Tesla K80 升级为 Nvidia Telsa P100 。Colab 还是给你一个 K80。关于 Nvida 芯片类型的简要讨论，请参见我的文章比较云 GPU 提供商这里。

有很多不同的方法可以找到你的硬件信息。两个有用的命令是用于 GPU 信息的!nvidia-smi和用于 CPU 信息的!cat /proc/cpuinfo。即使你想用 GPU 训练你的模型，你也仍然需要一个 CPU 来进行深度学习。

每当您在 Jupyter 笔记本代码行的开头使用感叹号时，您都在运行一个 bash 命令。这是我写的关于 bash 命令的文章，包括cat，如果你想知道更多关于它们的信息。

请看这张谷歌表中我在下面的快照中编辑的规格。

内存和磁盘空间很难衡量。一旦 Colab 和 Kaggle 安装了他们的软件并启动了他们的程序，总数就无法得到了。下面是对!cat /proc/meminfo profiler 命令与 Colab 和 Kaggle 小部件之间内存差异的分析。

Total 是总内存。可用是在没有额外运行进程的情况下启动后观察到的可用内存量。您可以看到，分析的数量很接近，但是与 Colab 和 Kaggle 小部件中显示的数量不完全一致。

Mouseover in Colab

Kaggle Sidebar

这里有一个 Kaggle 内核，这里有一个 Colab 笔记本，上面有命令，所以你可以在你自己的环境中查看规格。确保首先启用 GPU 运行时，如本文末尾所示。

请注意，来自命令分析器的 GPU 规格将以兆字节为单位返回，这与兆字节几乎相同，但不完全相同。兆字节可以通过谷歌搜索转换成兆字节——只需输入标记的数量进行转换。谷歌无处不在——不是吗？😄

Kaggle 小部件显示的磁盘空间也比我们看到的报告少得多。Kaggle 可以限制您在当前工作环境中可以使用的磁盘空间，而不管理论上有多少可用空间。

Kaggle 在他们的文档中声明你有 9 个小时的执行时间。然而，内核环境在屏幕右侧的小部件中显示每个会话最多 6 小时。注意，重启内核会重启时钟。Kaggle 还会在 60 分钟不活动后重新启动您的会话。

Colab 给你 12 小时的执行时间，但是如果你空闲超过 90 分钟，它也会把你踢出去。

让我们来看看最重要的问题:在这些平台上进行一些深度学习需要多长时间！

计算机视觉速度比较

我在一个深度学习图像分类任务上对比了 Kaggle 和 Colab。目标是预测一张图片是猫还是狗。该数据集由 25，000 张图片组成，猫和狗的数量相等。该数据集被分成 23，000 个用于训练的图像和 2，000 个用于验证的图像。数据集可以在 Kaggle 这里获得。

Cat and dog images from the dataset

我使用 FastAI 库构建了一个卷积神经网络，并使用 ResNet30 的迁移学习对其进行了训练。该模型使用了几个技巧进行训练，包括数据扩充和学习速率退火。对测试集的预测是通过增加测试时间来实现的。代码改编自这个 FastAI 的例子。

Kaggle 内核可以在这里访问，Colab 笔记本可以在这里访问。批量大小设置为 16，FastAI 版本为 1.0.48。对 FastAI 的内置分析器报告的几个训练阶段和一个预测阶段的时间进行求和。

Note that the y-axis does not start at 0.

在所有情况下，验证集的准确性都超过 99%。三次迭代的平均时间在 Kaggle 上是 11:17，在 Colab 上是 19:54。Kaggle 运行时环境比 Colab 环境快 40%。

批量

为了在 Kaggle 中成功运行图像分类，我不得不将批量大小从 64 个图像减少到 16 个。较大批量的错误似乎是由 Docker 容器中的共享内存设置得太低引起的。有趣的是，我在 2018 年末向谷歌 Colab 提出了这个确切的问题——他们在一周内就解决了这个问题。截至 2019 年 3 月中旬，Kaggle 的同一问题仍未解决。

接下来，我用上面在 Colab 上使用的相同代码运行了两次迭代，但是将批处理大小改为 256。这一变化导致平均运行时间为 18:38。Colab 中批处理大小为 64 的两个额外迭代导致平均时间为 18:14。因此，Colab 降低了批量大于 16 的时间。

尽管如此，较小的批量在这个任务中并不是一个大问题。各种各样的批量参数通常都很有效——关于讨论，请参见这篇论文、这篇文章和这篇 SO 回答。

当我在批量大小为 256 的 Colab 上训练模型时，出现了一个警告，说我正在使用我的 11.17 GB GPU RAM 的大部分。见下文。

这个警告很好，但是由于上面讨论的分析练习，我了解了 Gibibytes 和 Gigabytes 之间的区别。我们之前看到 Colab GPUs 拥有 11.17 千兆字节(12 千兆字节)的 RAM。因此，与警告所说的相反，我们实际上有 12gb 的 RAM 可以使用。尽管如此，如果内存不足，那就是内存不足。😃因此，对于这些图像大小、默认的工作线程数和 32 位精度数，看起来批处理大小 256 是最大值。

混合精确训练

然后，我尝试了混合精度训练，以减少训练时间。混合精度训练意味着在计算中尽可能使用 16 位精度数，而不是 32 位精度数。Nvidia 声称使用 16 位精度可以产生两倍于 P100 的吞吐量。

点击了解混合精度 FastAI 模块。请注意，在使用测试时间增强进行预测之前，您需要将 FastAI 学习者对象切换到 32 位模式，因为 torch.stack 还不支持半精度。

通过在 Colab 上使用混合精度训练，我能够在批量为 16 的情况下实现 16:37 的平均完成时间。我测试了两次。所以我们在减少时间。

然而，混合精度训练将 Kaggle 上的总时间增加了一分半钟，达到 12:47！其他规格没有变化。所有地方的验证集准确率都保持在 99%以上。

Note that the y-axis does not start at 0.

我发现 Kaggle 的默认包包括稍微老一点的 torch 和 torchvision 版本。将软件包更新到 Colab 使用的最新版本对培训时间没有影响。总的来说，我注意到 Colab 上的默认包比 Kaggle 上的更新更快。

上面提到的硬件差异似乎不太可能导致 Kaggle 上观察到的性能下降。观察到的唯一软件差异是 Kaggle 运行 CUDA 9.2.148 和 cuDNN 7.4.1，而 Colab 运行 CUDA 10.0.130 和 cuDNN 7.5.0。

CUDA 是 Nvidia 的 API，可以直接访问 GPU 的虚拟指令集。cuDNN 是 Nvidia 基于 CUDA 构建的深度学习原语库。据英伟达的这篇文章称，Kaggle 的软件应该能提升 P100 的速度。然而，正如在 cuDNN 更改注释中看到的，阻止加速的 bug 会定期被发现并修复。

还得等 Kaggle 升级 CUDA 和 cuDNN，看看混合精度训练是不是变快了。目前，如果使用 Kaggle，我仍然鼓励你尝试混合精确训练，但它可能不会给你带来速度提升。如果使用 Colab，混合精度训练应该与批量相对较小的 CNN 一起工作。

让我们看看使用 Colab 和 Kaggle 的其他方面。

UX

谷歌是一家希望你为你的 GPU 付费的企业，所以不应该指望它免费赠送农场。🐖

Colab 和 Kaggle 有令人沮丧和缓慢的方面。例如，两个运行时断开连接的频率比我们希望的要高。然后，您需要在重启时重新运行您的笔记本。😦

在过去，甚至不能保证你会得到一个 GPU 运行时。看起来他们现在总是有空。如果您发现没有，请在 Twitter @discdiver 上告诉我。

让我们来看看科 lab 和 Kaggle 的优缺点。

科拉布

赞成的意见

可以将笔记本保存到 Google Drive。
您可以向笔记本单元格添加注释。
与 GitHub 的良好集成——你可以直接将笔记本保存到 GitHub repos。
Colab 有免费的 TPU。TPU 类似于 GPU，只是速度更快。TPU 是谷歌自己定制的芯片。不幸的是，TPUs 与 py torch,还不能顺利工作，尽管计划集成两者。如果实验是用 TensorFlow 而不是 FastAI/PyTorch 编写的，那么使用 TPU 的 Colab 可能会比使用 GPU 的 Kaggle 更快。

骗局

在 Colab 中，一些用户的共享内存限制很低。似乎至少有一个用户的问题已经解决(此处讨论为)。
使用 Google Drive 有点痛苦。您必须验证每个会话。此外，你不能很容易地解压驱动器中的文件。
键盘快捷键和普通的 Jupyter 笔记本有不同的绑定。如果你想知道这种情况是否会改变，下面是 GitHub 的第期。

现在我们来看看 Kaggle 的利弊。

卡格尔

赞成的意见

Kaggle 社区非常适合学习和展示你的技能。
把你的工作交给 Kaggle 会创造一段美好的历史。
许多 Jupyter 笔记本的键盘快捷键完全可以转移到 Kaggle 环境中。
Kaggle 有许多数据集可以导入。

骗局

Kaggle 通常会自动保存你的工作，但如果你不提交，然后重新加载你的页面，你可能会发现你失去了一切。这不好玩。😦
如上所述，Docker 容器中的 PyTorch 共享内存在 Kaggle 中较低。当批量大于 16 张图像时，这导致图像分类任务的RuntimeError: DataLoader worker (pid 41) is killed by signal: Bus error.。
Kaggle 内核通常看起来有点滞后。

我不知道有其他云提供商提供免费的 GPU 时间(除了入门学分)，所以这次讨论并不是对谷歌的批评。感谢免费的 GPU，谷歌！👍如果你知道其他人有免费的(不仅仅是介绍性的)GPU 资源，请告诉我。

结论

Colab 和 Kaggle 都是在云中开始深度学习的绝佳资源。我发现自己在使用这两个平台。你甚至可以在两者之间下载和上传笔记本。😄

看到 Colab 和 Kaggle 增加更多的资源令人兴奋。在我们研究的图像分类任务中，使用 P100 GPU，Kaggle 在训练和预测方面肯定比 Colab GPU 更快。如果你正在运行一个密集的 PyTorch 项目，并希望提高速度，那么在 Kaggle 上开发它是值得的。

如果你想更灵活地调整批量大小，你可以使用 Colab。使用 Colab，您还可以将您的模型和数据保存到 Google Drive，尽管这个过程可能会有点令人沮丧。如果您使用 TensorFlow，您可能希望在 Colab 上使用 TPUs。

如果你需要更多的能力或更多的时间来运行更长时间的进程，我之前的实验表明谷歌云平台是最具成本效益的云解决方案。

我希望您发现 Colab 和 Kaggle 的这一比较很有用。如果你有，请分享到你最喜欢的社交媒体频道，这样其他人也可以找到它。👏

我撰写关于 Python、开发运营、数据科学和其他技术主题的文章。如果你对这些感兴趣，请查看并跟随我到这里。

快乐深度学习！

Head down either path you like 😄

卡尔曼滤波器(1)——基础知识

原文：https://towardsdatascience.com/kalman-filter-1-the-basics-68f89deb2613?source=collection_archive---------27-----------------------

自动驾驶汽车本地化的基础知识

我试图学习卡尔曼滤波器，一种结合你的猜测和一些不确定的测量值并做出更好的估计的方法，并发现没有这样容易理解的话题。但是后来，我遇到了这个课程，它从最基本的方面介绍了这个想法。所以在这篇文章中，我将按照课程中的结构，简单介绍一下自动驾驶汽车定位的基础知识，这也是卡尔曼滤波器的起点。

问题设置

在自动驾驶汽车定位中，通常有两个组成部分— 第一个是运动，当汽车踩下油门时，我们肯定可以估计(猜测)它可以走多远，第二个是测量，安装在汽车上的传感器能够检测环境并测量它的位置。现在问题来了，我们的估计(猜测)和传感器测量都可能不准确，结合这两个不确定的因素，我们是否仍然能够对汽车的位置做出猜测，甚至做出更好的猜测？

答案是肯定的，让我们来看一个具体的例子，看看如何用基本的统计学来解决这个问题:

感觉

假设我们的汽车行驶在一维世界中，那里只有 5 个网格和 2 种不同的颜色——绿色和红色。一开始，我们的汽车有相等的概率停留在 5 个网格中的任何一个，它也有一个传感器Z，它检测世界的颜色，然而，传感器并不总是正确的，当传感器说网格是red时，我们给red一个较高的权重pHit = 0.6，给green一个较低的权重pMiss = 0.2(这里我们使用权重，事实上当加起来是 1 时，它可以归一化为概率)。现在的问题是，当我们的传感器Z = red，我们的车的位置的概率是多少？

解决方案很简单，我们的传感器看到的网格是red，所以它更有可能在第二个和第三个单元格中。对于红细胞，我们给出较高的权重，绿色细胞给出较低的权重:

最终概率需要归一化，以便加起来等于 1。运行这个程序，我们得到的结果是:

array([0.11111111, 0.33333333, 0.33333333, 0.11111111, 0.11111111])

显然，第二个和第三个单元比其余单元具有更高的概率。

事实上，其背后的统计数据是贝叶斯法则:

以cell 2(X_2)中的概率为例，结合公式(2)和(3)，可以很容易地计算出概率为:

0.2*0.6 / (0.2*(0.2+0.6+0.6+0.2+0.2))

分母是一个规格化器，对于上面代码中对应于sum(combine_prob)的每个单元格都是一样的。

现在我们能够在感知环境后计算后验概率，让我们移动汽车，看看它如何影响定位。

移动

在这个水平的 5 格世界中，我们的汽车能够以定义为U的步数左右移动。然而，它可能不准确地移动到不期望的单元，并且移动概率具有如下分布:

它有 0.8 的几率正确移动，0.1 的几率比原计划多移动一步，0.1 的几率短移动一步。现在的问题是给一个先验分布p(每个单元格内的概率)，走一步U后验概率q是多少？

让我们看一个例子:

假设我们的车被指示移动 1 步，那么在 3 号单元格落地的概率是多少？

我们反过来考虑问题:移动 1 步后，汽车会在什么场景下降落在 3 号单元格？它可以从小区 2 以概率 0.3 正确移动，从小区 3 以概率 0.1 下冲，从小区 1 以概率 0.1 上冲。

这里的统计称为总概率:

到达X_j的概率等于从每个可能的小区X_i开始的概率之和乘以从X_i移动到X_j的概率。

注意这里的U大于单元总数n，汽车将循环回到步骤U % n。

结合在一起

现在我们有了两个最重要的部分——感知和移动，我们的车已经准备好移动了。过程如下:汽车感知环境→移动→感知环境→移动，…

在本例中，我们的汽车从均匀分布开始，有 2 次连续测量red和green，每次移动 1 步。我们得到最终概率:

[0.21157, 0.15157, 0.08105, 0.1684, 0.3873]

所以经过一系列步骤后，它最有可能以 0.3873 的概率落在最后一个单元格。

参考:

https://classroom.udacity.com/courses/cs373

卡尔曼滤波器(2) —网格世界定位

原文：https://towardsdatascience.com/kalman-filter-2-grid-world-localisation-93674dc750c6?source=collection_archive---------19-----------------------

将基础知识应用于二维空间

在上一篇文章中，我们应用了基本的贝叶斯规则和全概率来定位一维世界中的一辆移动的汽车。让我们加强我们的理解，并将它们应用到二维世界中。

问题设置

考虑一个二维世界，机器人只能向左、向右、向上或向下移动。它不能斜向移动。此外，对于这个任务，机器人永远不会越过它的目的地广场；它要么运动，要么保持静止。

对于每个运动，它遵循:

并且测量和运动被设置为:

该设置表示，在这个 3x3 的世界中，有两种不同的颜色——绿色和红色。机器人在每个单元中以相等的概率开始，测量值为R，传感器有概率0.8是正确的。然后机器人做一个动作[0, 0]，保持静止，这个动作有一个概率1.0被正确执行。问题是机器人在每个细胞中的当前概率是多少？

履行

初始化

最初，每个单元具有相等的概率:

感觉

基于传感器的测量值(测量概率)和初始概率(先验概率)，应用贝叶斯规则，我们可以得到后验概率。

移动

在运动中，我们应用全概率，

也就是说，每个单元的概率等于它来自的单元的概率和转移概率的乘积。

这里的情况更简单，因为机器人只能移动或保持静止((i, j)是当前小区，(i-U[0], j-U[1])是它移动的小区)。

本土化

现在让我们组装零件:

相应地，我们得到的结果是:

[[0.06666667 0.06666667 0.06666667]
 [0.06666667 0.26666667 0.26666667]
 [0.06666667 0.06666667 0.06666667]]

所以在测量和动作之后，机器人最有可能待在牢房(1, 1) or (1, 2)。

更多完整的测试，请点击查看的完整实现。

参考:

https://classroom.udacity.com/courses/cs373

卡尔曼滤波器(3)——连续状态空间中的定位

原文：https://towardsdatascience.com/kalman-filter-3-localisation-in-continuous-state-space-1c979f6bde5b?source=collection_archive---------33-----------------------

将高斯分布应用于连续状态空间

在过去的会议中，我们尝试在网格世界中进行定位，在网格世界中，我们的机器人有不同的概率位于不同的单元中。总之，状态空间是离散的。为了将问题设置推广到连续状态空间，我们将到达卡尔曼滤波器的核心。

在我们讨论卡尔曼滤波器的任何细节之前，请记住我们在这里学到的东西，卡尔曼滤波器总是有两个步骤:

传感(测量):基于机器人所看到的，更新后验分布
移动(预测):估计机器人移动后的新位置

以下是的结构:

扩展到连续状态空间的想法
用高斯分布实现 sense(测量)
用高斯分布实现移动(预测)
结合在一起
多维卡尔曼滤波器

原则

在离散世界中，每个状态都有一个单独的概率，其总和为 1，将其扩展到连续状态空间的关键是找到一个连续的分布，而在卡尔曼滤波器中，该分布是高斯分布。

这就是说，无论是步进测量还是预测，我们对机器人位置的估计总是符合高斯分布。高斯的两个参数分别代表:

μ:机器人位置最可能的估计
σ:检测器和预测的不精确等造成的我们估计的不确定性。

任务是在一系列测量和预测之后，找到最终的高斯分布参数μ和σ。让我们把它分成两部分。

测量(感觉)

在测量阶段，我们根据机器人的传感器更新我们的信念。假设X是位置Z是测量(机器人观察到的)，我们正在解决的问题是:

我们之前的信念是p(X)，但是我们的传感器看到的分布p(Z|X)不同，现在我们正在尝试计算我们的后验分布p(X|Z)，这是给定的我们所看到的(Z)，我们现在的最佳估计是什么？

请记住，这里所有的分布都是高斯分布，为了得到后验分布，我们只需要应用贝叶斯规则，即将这两个分布相乘:

以上是更新分布的参数。注意σ_new比σ和γ都小！这告诉我们，倍增后不确定性降低了，这符合我们的知识，即传感实际上是获取信息和降低不确定性。实施将是:

预测(移动)

移动是直接向前的加法。初始分布N(μ, σ)，移动不确定度U``γ^2，移动后的分布为N(μ+U, σ^2+γ^2)，即均值加U，不确定度加γ^2。

注意，通过进行不确定的运动，方差(不确定性)增加，这与减少方差(不确定性)的测量相反。

1D 卡尔曼滤波器

现在结合测量和预测，我们得到:

在这个例子中，我们设置了初始位置mu = 0和不确定度sig = 10000，这意味着我们对机器人的初始位置非常不确定。经过几轮迭代，我们得到了结果:

我们看到，通过进行第一次测量，不确定性立即下降到3.998，它小于初始方差和测量方差。最后，我们用方差4.0058预测我们的机器人在位置10.9999着陆。

多维卡尔曼滤波器

在上面的例子中，我们只有一个变量，即位置p。现在让我们考虑第二个变速v，然后我们的任务将是得到x = (p, v)和不确定矩阵P = cov(x)的最终估计。

预言；预测；预告

在预测阶段，假设我们有以下关系:

from reference

给定速度和时间t，我们可以得到下一个位置，我们假设的速度保持不变。然后我们得到了它的矩阵形式:

这里F称为状态转移矩阵，P为协方差矩阵，μ为外部运动矢量(比如有加速度或踏板油门)。

尺寸

测量也是一样，有一个测量转移矩阵H。以最简单的形式，让我们假设H = (1, 0)和，

 μ_0 = Hx = (1, 0)(p, v)^T = p

这就是说，我们的测量只能测量机器人的位置，而看不到速度。现在问题变成我们有两个高斯分布，一个是(先验分布):

第二个是(测量分布):

看起来很熟悉我们之前的例子，对吧？现在我们需要将这两个分布组合成后验分布。这里涉及到一系列的推导(一个精彩的解释这里，我把结果放在这里:

现在让我们将它们结合在一起，得到最终的卡尔曼滤波函数:

完整的实现，请点击查看。

参考:

https://classroom.udacity.com/courses/cs373
https://www . bzarg . com/p/how-a-Kalman-filter-works-in-pictures/

分类策略的美丽视觉模型解读——卡纳达语 MNIST 数字识别

原文：https://towardsdatascience.com/kannada-visual-model-952cc6ec3a72?source=collection_archive---------28-----------------------

此处为副标题

Kannada handwritten digits

卡纳达语 MNIST 数据集是一个很棒的近期作品(细节在此)，我很高兴它也对公众开放。我相信很快这里的社区就会在这个数据集上发布最先进的准确性数据。所以，我在做一些不同的事情。

相反，我们将尝试可视化，尝试看到模型所看到的，逐个像素地评估事物。我们的目标是可解释性。在本文中，我将从“最简单的”、最容易解释的算法开始。希望我会在后面的文章中公布其他建模技术的结果。

重申并澄清:我不会专注于获得最佳表现。相反，我将着重于可视化输出，理解模型的意义，并理解它失败的地方和原因。当模型运行得不太好时，评估哪个更有趣。😃

可视化数字数据

函数绘制一个随机数字及其标签

def plot_random_digit():
    random_index = np.random.randint(0,X_train.shape[0])
    plt.imshow(X_train[random_index], cmap='BuPu_r')
    plt.title(y_train[random_index])
    plt.axis("Off")plt.figure(figsize=[2,2])
plot_random_digit()

A random Kannada digit plotted as image

一口气看 50 个样本

plt.figure(figsize=[10,6])
for i **in** range(50):
    plt.subplot(5, 10, i+1)
    plt.axis('Off')
    if i < 10:
        plt.title(y_train[i])
    plt.imshow(X_train[i], cmap='BuPu_r')

作为一个不擅长阅读卡纳达文字的人，对我来说这些符号看起来有些相似

第三和第七条
第 6 和第 9 条

在开始时，我期望这些预测者在这两对之间会有些混淆。尽管这不一定是真的——也许我们的模型能比我更好地识别数字。

重塑数据集以构建预测模型

个别例子是 28 X 28。对于 scikit learn 中的大多数预测建模方法，我们需要将示例展平为 1D 数组。
我们将使用 numpy 数组的整形方法。

X_train_reshape = X_train.reshape(X_train.shape[0], 784)
X_test_reshape = X_test.reshape(X_test.shape[0], 784)

建立和理解逻辑回归模型

让我们为我们的多类分类问题建立一个逻辑回归模型。

请再次注意，我们不会关注获得最佳性能，而是关注如何理解模型所学的内容。

逻辑回归模型将很容易和有趣地分析系数，以了解模型学到了什么。
在 SciKit-learn 中，可以通过多种方式制定多类分类。他们是-

一对休息
多项式

1。一人 vs 其余:

也称为一对一，这种策略包括为每个类安装一个分类器。对于每个分类器，该类与所有其他类相匹配。这种方法的一个优点是它的可解释性。

因为每个类仅由一个分类器表示，所以可以通过检查相应的分类器来获得关于该类的知识。这是多类分类最常用的策略，也是一个公平的默认选择。

对于我们的例子，这意味着构建 10 个不同的分类器。

在这里了解更多:
https://sci kit-learn . org/stable/modules/generated/sk learn . multi class . onevsrestclassifier . html

2。多项式:

在此策略中，我们使用线性预测器对看到给定输出的概率的对数进行建模。
对于multinomial，最小化的损失是整个概率分布的多项式损失拟合。softmax 函数用于查找每个类别的预测概率。

在这里阅读更多相关内容:
https://en . Wikipedia . org/wiki/Multinomial _ logistic _ regression # As _ a _ log-linear _ model

注意:这种区别很重要，需要你为模型解释不同的系数。

首先，让我们使用 One vs. Rest 方案来构建我们的模型

from sklearn.linear_model import LogisticRegression
lr1 = LogisticRegression(solver="liblinear", multi_class="ovr")

*# Fitting on first 10000 records for faster training* 
lr1.fit(X_train_reshape[:10000], y_train[:10000])

评估列车组的性能

模型对训练数据的预测

from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
y_train_pred = lr1.predict(X_train_reshape[:10000])cm = confusion_matrix(y_train[:10000], y_train_pred[:10000])

plt.figure(figsize=[7,6])
sns.heatmap(cm, cmap="Reds", annot=True, fmt='.0f')
plt.show()

那可是非常高的训练准确率！过度拟合？

还有，看起来模型是不是在 3 和 7，6 和 9 之间非常混淆，至少在火车布景上不是。

错误分析:检查错误分类的案例

为了便于索引，我们将转换到熊猫系列，隔离错误分类的案例，绘制一些示例。

11 例分类错误

研究一些案例
选择 9 个随机案例——我们将绘制数字，以及真实和预测的标签

The mis-classified cases

你能看出为什么这个模型是混乱的吗？让我们看看模型在测试集上表现如何。

测试集上的混淆矩阵

对测试数据进行预测，并绘制混淆矩阵。

Confusion Matrix on test set — smells like over-fitting

看着混乱矩阵和分类报告-

3、7 的回忆最少—模型明显混淆了它们。同样，4 和 5 之间也有混淆。还有，很多 0 被误认为 1 和 3。

好吧！所以看起来在测试集上性能急剧下降。很有可能我们在列车上过度适应了。

我们承认这一模式可以改进。

但是，我们现在先不要担心这个。让我们关注理解模型所学内容的方式。

模型解释

了解每个像素的贡献

我们现在学习的每个像素的系数都是基于一对静止方案的。

让我们继续分析我们的 OVR 模型的系数。

系数 lr1.coef_ 的形状。“形状”是(10。784)，即每个标签有 784 个系数——每个数字的每个像素有 784 个系数！

正系数意味着该像素上的高值增加了该标签的机会，与所有其他类相比。因此，系数告诉我们这个像素如何将这个标签与所有其他标签区分开来。

提取像素系数并绘制在标签 0 的热图上

plt.figure(figsize=[3,3])
coefs = lr1.coef_[0].reshape(28,28)
plt.imshow(coefs,cmap="RdYlGn",vmin=-np.max(coefs),vmax=np.max(coefs)) *#setting mid point to 0*
plt.show()

Heatmap for 0 — OVR

我用了一种不同的颜色来区分正负符号。

在上图中，绿色像素是正值像素。图像告诉我们，某些像素中的值有助于将数字归类为 0。不出所料，中间的红色表示该范围内的值意味着该数字为零的可能性较低。黄色接近于 0，这意味着像素对区分没有任何帮助。

制作所有数字的像素热图

Heatmap — all digits — OVR scheme

好好看看这些热图。这将揭示模型已经学习了什么。请注意，我们有“一与其余”的公式，特别是在与其他数字的热图进行比较时。

现在，让我们使用多项式方案建立一个模型。

我们需要将multi_class参数指定为“多项式”
“liblinear”解算器不支持这一点，所以我们选择“sag”解算器。

lr2 = LogisticRegression(random_state=42, multi_class="multinomial", solver="sag")
lr2.fit(X_train_reshape[:10000], y_train[:10000])

在测试集上评估性能

绘制混淆矩阵

了解每个像素的贡献

每个标签有 784 个系数——每个像素的系数。

现在，一个正的系数意味着是什么使得这个标签成为现在这个样子！但是，如果 3 个标签在特定像素中具有相似的存在，则所有 3 个标签的系数可能具有相似的值。

提取像素系数并绘制在标签 0 的热图上

这与 OVR 模型的热图有多不同/相似？
让我们制作所有像素的热图。

为所有数字制作这样的像素热图

这些热图与每个标签的平均图像相比如何？

绘制每个数字的平均图像。

plt.figure(figsize=(10, 4))
for i **in** range(10):
    plt.subplot(2,5,i+1), plt.title(i)
    plt.imshow(np.mean(X_train[y_train==i],axis=0),cmap='gray')
plt.suptitle('Mean images for each digit')

把它们都画在一起——好好看看。

Mean images vs. OVR vs. Mutinomial

锻炼-

你已经看到了 OVR 方法和多项式方法的热图。你也有每个标签的平均图像。

将热图与平均图像进行比较和对比。
你认为这是怎么回事？你能试着理解每个数字的模型都学到了什么吗？
为什么模型在某些数字上表现不佳？热图有助于理解吗？

对于那些有兴趣尝试更多东西的人来说

我建议你试试下面的-

使用带有正则化(ridge、lasso、elasticnet)的逻辑回归和使用交叉验证的超参数优化来减少过度拟合。
利用奇异值分解/主成分分析对原始数据进行去噪和重构；接下来是一个优化的逻辑回归模型。

好了，这就是我们这里的小演示！我将很快分享更多不同建模技术的演示，解释它们的方法，以及更多使用监督和非监督技术的相同数据集的实验。

觉得这个有意思？请继续关注更多这样的演示。

请分享您的评论/意见/建议！

卡普兰·迈耶曲线:介绍

原文：https://towardsdatascience.com/kaplan-meier-curves-c5768e349479?source=collection_archive---------0-----------------------

这个帖子的代码可以在 Github 上找到 。一个完全交互式的应用程序，可以调整样本大小、审查、生存收益等参数，并查看对风险比的影响……可以在shinyapps找到。

K aplan-Meier 曲线广泛用于临床和基础研究，但在制作或解释它们时，需要注意一些重要的陷阱。在这篇短文中，我将给出一个关于卡普兰迈耶图上数据表示的基本概述。

Kaplan-Meier 估计量用于估计生存函数。这个函数的可视化表示通常被称为卡普兰-迈耶曲线，它显示了某个时间间隔内某个事件(例如，生存)的概率是多少。如果样本量足够大，曲线应该接近被调查人群的真实生存函数。

它通常在一项研究中比较两组(比如接受治疗 A 的一组和接受治疗 B 的一组)。

治疗 B 似乎比治疗 A 做得更好(中位生存时间为+/- 47 个月对 30 个月，具有显著的 p 值)。在这篇文章中，我只探讨治疗组 A，不会比较两组。

基本卡普兰迈耶图

让我们从创建一些基本数据开始。我们有 10 名患者参与了一项研究(所谓的“风险”)，随访时间为 10 个月。每个参与者都得到相同的待遇。

Cohort without censored data

如果我们仔细看看“跟进”和“事件类型”列:

后续时间可以是任何时间间隔:分钟、天、月、年。
事件类型 1 等于一个事件。癌症试验中的典型事件可能是死亡，但卡普兰-迈耶曲线也可以用于其他类型的研究。例如，安参加了一项虚构的抗癌新药研究，但在 4 个月后去世。
事件类型 0 等于右删截事件。

为了简单起见，在第一个例子中没有审查事件。

研究开始。每个月都有一名参与者体验一次活动。每发生一次事件，存活概率下降剩余曲线的 10%(=事件数除以处于危险中的人数)，直到研究结束时达到零。

带有删失数据的卡普兰迈耶图

让我们给前面的图表添加一些删失数据。

当关于存活时间的信息不完整时，观察值被称为删失的；最常见的形式是右删截(与左删截和区间删截相反，这里不讨论)。在研究期间没有经历感兴趣事件的患者被称为“右删截”。此人的存活时间被认为至少与研究持续时间一样长。右删截的另一个例子是当一个人在研究观察时间结束之前退出研究，并且没有经历该事件。换句话说，删失数据是一种缺失数据。

安、玛丽和伊丽莎白在研究完成前就离开了。在研究结束时，Kate 没有出现事件。与之前的“楼梯”模式相比，曲线看起来已经非常不同了。

Cohort with censored data (Ann, Mary, Elizabeth and Kate). Note that Andy experienced an event at 6.2 months instead of 7 months in the example above (and was not censored).

现在，事件、审查和卡普兰迈耶曲线上的下降之间的关系是什么？

如果我们看一下第一个有活动的参与者(约翰)，我们会发现 1 个月后我们下降了 0.1，或者说剩余高度的 10%:

如果我们再等一会儿，我们可以看到在第 5 个月，还有 6 名患者处于危险之中。两个已经有了一个事件，还有两个已经被审查。在下一个事件中，曲线下降剩余高度的 16%(而不是研究开始时的 10%)，因为处于危险中的人更少:

这种情况一直持续到研究期结束，或者直到处于危险中的患者数量达到 0。最后一滴是最大的。在最后一次下降时，曲线下降剩余高度的 50%(或总高度的 20%)。然而，仍然只有一个人经历了一次事件，与研究开始时相同(当时跌落仅为剩余(=总)高度的 10%)。这是因为在研究中只有 2 人处于危险中。

置信区间的重要性

特别是当只有极少数患者处于危险中时，一个删失事件的影响会对 KM 曲线的外观产生很大的影响。

在前面的情节中，似乎生存曲线在 20%的生存概率处达到平稳状态。如果我们在 Joe 和 Kate(参与者 9 和 10)之间交换审查状态，KM 曲线会发生剧烈变化，并在研究期结束时降至 0。在这种情况下(曲线 B)，所有参与者要么有一个事件，要么被审查。

The event type for Joe and Kate are reversed in scenario B

换句话说，只有一个事件标志着存活曲线达到 0 或达到稳定在 20%的平台之间的差异。

如果我们在 KM 曲线上绘制 95%的置信区间，我们也可以看到这一点。置信区间非常宽，这表明该研究的参与者非常少。此外，随着时间的推移，95%置信区间会增加，因为受审查个体的数量会增加。

排除审查数据:是还是不是？

小型数据集

我们可以模拟最好的情况(删截等于无事件)和最坏的情况(删截等于事件)，并将其与实际曲线进行比较。

The first 3 observations for every scenario (best, worst and actual)

在最好的情况下，曲线在研究结束时停止在 40%的生存概率，而在最坏的情况下，曲线下降到 0。中位存活时间也大不相同:

实际曲线:6.2 个月
最好的情况:8.1 个月
最坏情况:5.5 个月

大型数据集

如果我们增加样本量，这就更加惊人了。在模拟中，样本量从 10 个增加到 100 个，随访时间为 48 个月。在这个模拟中，40%的个体在第 0 个月和第 48 个月之间被(随机)审查。这再次表明，中位存活时间可以有很大的不同。

结论

删失数据会显著影响 KM 曲线，但在拟合模型时必须包括在内。
如果出现大的落差，在解释 KM 的终点时要小心，尤其是在研究接近尾声时。这通常意味着没有很多人处于危险中(并且 95% CI 区间更宽)。
即使没有报告或者没有显示置信区间，跌落的高度也可以告诉你有多少病人处于危险中。

关于作者:

我是 Ruben Van Paemel 博士，2017 年从医学院毕业后，我开始在根特大学(医学遗传学中心)担任博士研究员，由研究基金会 Flanders 资助。我也是根特大学医院的儿科住院医师。可以在推特上关注我:@ RubenVanPaemel

我从事神经母细胞瘤的研究，这是一种罕见但极具破坏性的肿瘤，最常见于非常年幼的儿童。我们的团队试图了解潜在的基因改变，以提高神经母细胞瘤儿童的诊断、治疗和最终存活率。

参考

这篇文章的灵感来自 Pancanology 给出的解释:https://www.youtube.com/watch?v=KE1tkZmWhqU。
关于审查的定义:https://www.cscu.cornell.edu/news/statnews/stnews78.pdf
封面照片: Unsplash

卡普兰·迈耶的错误

原文：https://towardsdatascience.com/kaplan-meier-mistakes-48cd9e168b09?source=collection_archive---------7-----------------------

了解如何避免常见的生存分析错误并改善预后因素研究

Photo Credit: Louis Reed

患者的预后是指未来医疗结果的风险，如手术并发症、肿瘤复发或死亡。预后因素研究是对可以预测患者预后的信息的研究。经验证的预后因素是转化研究的重要组成部分，转化研究用于为临床决策提供信息，对疾病机制进行假设，并对患者进行分层以获得个性化药物。

生存数据被用来研究预后因素，而卡普兰迈耶分析因其假定的易用性而经常被使用。不幸的是，一些研究人员误解了 Kaplan Meier 的分析，并错误地使用了它，这给他们的分析带来了统计问题，并可能导致医疗错误。

这篇文章的目标是以一种不具备深厚统计学背景的研究人员可以理解的方式强调常见的 Kaplan Meier 错误。虽然我更喜欢写如何正确分析生存数据，但这种希望几乎是不可能的。生存分析是一个复杂的领域，整个教科书都致力于这个主题。相反，我希望读完这篇文章后，你能够发现常见的错误，在你自己的研究中避免这些错误，并提高你评论预后因素研究的能力。

卡普兰·迈耶评论

在我们讨论卡普兰迈耶分析的问题之前，卡普兰迈耶到底是什么？Kaplan Meier 估计值是一种统计方法，用于估计一段时间内的生存概率。这一估计很重要，因为它描述了疾病的总体预后——这是帮助患者和医生讨论医疗保健计划的有用信息。卡普兰迈耶图形象化了患者存活一定时间的概率。图 1 描绘了 NCCTG 群组肺癌存活概率。中位生存期，即 50%的患者仍然存活的时间，约为 300 天。曲线两侧的浅红色带是 95%的置信区间，表明真实的生存概率可能在红色区域内。图 1 是我们在没有关于患者的任何额外信息的情况下所能做出的最全面的风险评估。它是 NCCTG 队列中所有个体的生存概率。

Figure 1. Overall survival of NCCTG lung cancer patients. Data from the lung dataset in the R survival package. Note the median survival time is indicated by the dotted line intercepting the x-axis.

尽管图 1 很好地总结了肺癌患者的总体预后，但我们知道有许多因素导致不同的生存时间。有了额外的信息，我们可以给个体患者更准确的生存估计。NCCTG 数据集包括每个患者的性别，让我们分别估计男性和女性的生存概率，如图 2 所示。

Figure 2. Overall survival for lung cancer patients stratified by sex.

图 2 显示女性患者比男性患者存活时间更长。您可能会注意到，图 1 中的曲线出现在图 2 中曲线的中间。这不是巧合；在没有任何患者信息的情况下，图 1 中的总体估计值平均了男性和女性的生存概率。

注意卡普兰·迈耶的解释没有提到生存差异测试。这是因为卡普兰·迈耶估计量只估计生存概率。它不会比较它们。为了对这些生存概率做出推断，我们需要对数秩检验。

对数秩检验是一种假设检验，用于比较两组之间的生存概率。它计算一个 p 值，表明数据和零假设之间的相容性，前提是所有的测试假设都是正确的。当我们有一个来自较大总体的数据样本，并且我们想对总体进行陈述时，假设检验是有用的。因为我们没有每个肺癌患者的测量数据，所以我们的患者样本存在不确定性。统计检验通过为关于总体的陈述提供一种证据尺度来帮助我们应对这种不确定性。尽管统计测试可以帮助我们对总体做出推断(决定)，但测试也有其局限性。众所周知，p 值很难解释，许多统计学家呼吁结束统计显著性，即如果 p 值小于 0.05，则将发现标记为显著的做法。查看《自然》杂志上的这篇评论，了解更多关于 p 值的局限性。

现在让我们来看一个对数秩检验的简单例子。我们已经从 NCCTG 研究中收集了肺癌患者的数据，我们想对性别特异性存活率做出推断。首先，我们假设男性和女性肺癌患者之间存在生存差异。无效假设是男性和女性之间不存在生存差异。另一个假设是生存差异确实存在。然后，我们使用统计软件来计算对数秩检验的 p 值。该测试产生 0.001 的 p 值，表明在普通肺癌人群中男性和女性之间存在生存差异。

从现在开始，我将使用 Kaplan Meier 分析来表示使用 Kaplan Meier 图和对数秩检验来分析生存差异。本文的其余部分将检查研究人员在使用 Kaplan Meier 分析生存数据时所犯的错误。

分析连续变量

二元、分类和连续变量在医学研究中很普遍。二元变量仅由两个值组成，如治疗对不治疗。分类变量类似于二元变量，但有两个以上的选择，如安慰剂对药物 A 对药物 b。连续变量是数字变量，如年龄、基因表达、血压和肿瘤大小。这些变量可以取无限多的值，这取决于变量测量的精确程度。因为连续变量可以取无穷大的值，所以没有像二元或分类变量那样的组。

试图用 Kaplan Meier 分析来分析连续变量的研究人员会立即遇到问题:log-rank 检验只比较组间存活率。我们如何在没有任何分组的情况下分析一个变量？要使用对数秩检验，连续变量必须以某种方式分成几组。最常见的方法是将变量二分化,从而将值分类为低或高。中值分界点通常用于区分高低分组(图 3)。

Figure 3. Adapted from Liu et al. 2018. Patients were separated into groups of low and high mRNA expression. The initial equal number of patients in each group indicates the median was used as the cutpoint.

一些研究使用“最优”分界点将连续变量二分法。最佳分界点被定义为在组间产生最大生存间隔，产生最小 p 值的值。要确定最佳切割点，通常要检查所有可能的值，并选择产生最小 p 值的切割点。这种方法是有问题的，因为测试每个切割点会产生多重测试问题。测试这么多不同的切割点会夸大 p 值，并大大增加假阳性的机会。更糟糕的是，最佳分界点通常依赖于数据集，这意味着在一项研究中发现的分界点在其他 studies⁴⁻中不太可能相同。研究人员应该避免使用最佳分界点来二分法连续变量。

即使研究人员避免“最佳”分界点并使用中位数，二分法也会导致统计能力的损失，并对风险的分布做出错误的假设。统计功效是假设我们寻找的效应存在，我们的统计测试检测到它的概率。功效取决于样本数量、数据的可变性和所用的统计方法(一些方法比其他方法更有效)。高能量对于科学发现是至关重要的，因为低能量的研究常常会错过重要的结果。研究人员应该使用最大化统计能力的方法。

将连续变量二分法通过强制所有测量值采用简单的是或否值来降低功耗。使用二元变量而不是连续变量可以将检测效果所需的样本数量增加三倍。使用低统计功效的方法不仅成本高昂，而且不道德，因为需要的患者比必要的要多(图 4)。应该使用不二分法的方法，如 Cox 回归。

Figure 4. Simulations comparing statistical power of median cutpoint Kaplan Meier (Median KM) and linear Cox regression (Linear Cox) to detect a continuous linear effect on survival. The dashed red line represents 80% power. HR=Hazard Ratio. Simulation details can be found here.

两分法还对 patients⁴.的风险分布做出了错误的假设例如，考虑将年龄作为心肌梗塞(MI)的预后因素。老年通常与更大的心肌梗死风险相关。使用 65 岁的中位年龄，所有小于 65 岁的患者将被分类为年轻，而超过 65 岁的患者被分类为老年。这种二分法假定所有年轻患者都有相同的心肌梗死风险。它还假设所有老年患者都比年轻患者有相同的、更高的心肌梗死风险(图 5)。这种假设显然是错误的，因为 64 岁的人比 40 岁的人更容易患心脏病。没有理由一个 64 岁的人应该和一个 40 岁的人在同一个危险群；没有哪种生物开关在我们 65 岁时突然开启，会大幅增加我们 64 岁时患心脏病的风险。

Figure 5. Stepwise risk function assumed by dichotomizing a continuous variable into low and high groups

虽然一些生物变量确实显示出逐步的作用机制，在达到某个值之前什么都不会发生——想想神经元中打开离子门控通道的 55mV 动作电位——但研究表明大多数生理变量并不遵循这样的 mechanisms⁹.相反，风险随着变量的变化而逐渐变化。一些变量甚至遵循非线性趋势(图 6)。像 Cox 回归这样的连续建模方法可以考虑到这些趋势，考虑到 40 岁的人与 41 岁的人而不是 64 岁的人有相似的风险。

Figure 6. Adapted from Regression Modeling Strategies by Frank Harrell. Probability of survival gradually increases as the treadmill score increases. Cox regression can use nonlinear functions to model this type of relationship.

协变量调整

预后研究通常分析多个变量，也称为协变量。常见的情况是，研究单独分析每个变量，也分析多个变量(图 7)。单独分析每个变量是单变量分析，而一起分析多个变量被称为多变量分析。

FIgure 7. Adapted from Bill-Axelson et al. Hazard ratios for prostate cancer prognostic factors. The 4th column shows hazard ratios only adjusted for age (practically univariable), while the 5th column shows hazard ratios adjusted for multiple variables (multivariable).

这两种分析方法都很受欢迎，尽管单变量模型很少提供关于预后因素重要性⁻的信息。当多个因素影响生存率时，单变量分析会高估或低估预后效应，因为分析假设多个变量的效应归因于被分析的单个变量。这被称为遗漏变量偏差，解释了为什么图 7 中的单变量风险比远大于多变量风险比。需要多变量模型来调整多个预后因素，减少遗漏变量的偏倚，并理清每个变量对生存率的影响。

卡普兰迈耶是一个单变量的方法。这意味着 Kaplan Meier 的结果很容易有偏差，夸大了预后的重要性或完全错过了信号。在单变量 Cox 回归中分析单个连续标志物是单变量分析的另一个例子，会产生无信息的结果。应该使用可以调整多个变量的多变量方法，如 Cox 回归。

许多研究将声称一种新的生物标志物仅从单变量 Kaplan Meier 分析中预测。虽然生物标志物可能是预后性的，但这很难仅从单变量分析中得到证明。至少应该用 Cox 模型和其他基本预后因素来分析这个变量。像年龄和性别这样的信息通常是可以获得的，并且是许多疾病的预后信息，可以作为很好的基线变量进行调整。虽然不可能对每个潜在变量进行调整，但进行文献回顾和与临床医生交谈是识别对分析有重大影响的强预后因素的好方法。如果信号在多变量分析中仍然成立，新的生物标志物就有希望了。

增值价值

虽然在多变量模型中显示一个小的 p 值是提示一个标志物具有预后价值的最低限度，但是有更严格的方法来评估预后因子重要性⁴.因为许多预后因素已经存在，研究人员应该调查新的预后因素的附加值，量化新的标记改善预测的程度。

有许多方法可以量化新的预后标记物增加了多少信息。ROC 曲线下面积(AUC-ROC)、似然比检验和 r 是衡量预测性能⁻ ⁵.的常用指标虽然讨论每个指标的利弊超出了本文的范围，但是研究人员必须证明他们的新标记的附加值。

量化附加值后，评估与附加值相关的成本至关重要。并非所有的生物标志物都是相同的，一些标志物可以提供比其他标志物更多的信息。根据疾病的不同，传统的临床实验室可以提供比遗传标记或医疗记录更多的信息。重要的是要明白这些标记中的每一个都有不同的成本。像基因标记这样更昂贵的测试可能需要比更便宜的替代方法提供更多的信息来证明它们的成本。只有医生和患者才能决定增加的信息是否值得增加的成本，因此预后研究严格量化附加值是至关重要的。

结论

错误分析生存数据的方法有很多。研究人员应该避免将连续变量二分法，使用多变量模型，并量化新的预后标记物的附加值。遵循这些指南可以降低我们对低质量研究的容忍度，并改善未来的研究，从而改善患者护理。

如果你想了解更多关于生存分析方法的知识，比如 Cox 回归，可以看看我关于生存分析最佳实践的演讲。

参考

[1] R. Riley 等，预后研究策略(进展)2:预后因素研究(2013)， PLOS 医学

[2] A. Hingorani 等，预后研究策略(进展)4:分层医学研究(2013)， BMJ

[3] S. Greenland 等人，统计检验、P 值、置信区间和功效:误解指南(2016 年)，欧洲流行病学杂志

[4] C. Bennette 等人，反对分位数:流行病学研究中连续变量的分类及其不满意之处(2012 年)， BMC 医学研究方法学

[5] D. Altman，在预后因素评估中使用“最佳”切割点的危险(1994 年)， JNCI:国家癌症研究所杂志

[6] K. Metze，连续数据的二分法—预后因素研究中的一个陷阱(2008 年)，病理学—研究和实践

[7] P. Royston 等人，多元回归中的二分法连续预测值:一个坏主意(2006 年)，医学统计学

[8] N. Dawson 等人，统计分析中的二分法连续变量:避免实践(2012)，医疗决策

[9] A. Giannoni 等，连续生理变量中的最佳预后阈值真的存在吗？分析表观阈值的来源，对峰值耗氧量、射血分数和脑钠肽进行系统综述(2014)， PLOS 一

[10] D. Altman，将连续变量二分法中的问题(1994)，美国流行病学杂志

[11] D. Altman，P. Royston，将连续变量二分法的成本(2006 年)， BMJ:英国医学杂志

[12] K. Moons，新标记物的科学评价标准:展望(2010)，临床化学

[13] E. Steyerberg 等人，评估诊断和预后标志物的增量价值:综述和说明(2012 年)，欧洲临床研究杂志

[14] M. Pencina 等人，评估新标记物的额外预测能力:从 ROC 曲线下面积到重新分类和重新分类之后(2008 年)，医学统计学

[15] E. Steyerberg 等，预后研究策略(进展)3:预后模型研究(2013)， PLOS 医学

Kedro:数据科学的新工具

原文：https://towardsdatascience.com/kedro-prepare-to-pimp-your-pipeline-f8f68c263466?source=collection_archive---------6-----------------------

用于生产就绪数据管道的新 Python 库

在本帖中，我将介绍 Kedro ，这是一款面向数据科学家和数据工程师的全新开源工具。在简要描述了它是什么以及为什么它可能成为每个专业人员工具链的标准部分之后，我将在一个教程中描述如何使用它，您应该能够在十五分钟内完成。为未来的太空飞行系好安全带！

Image by stan (licensed under CC BY-SA 2.0)

假设你是一名数据科学家，为一名为公司做出关键财务决策的高管工作。她请你提供一个特别的分析，当你这样做时，她感谢你为她的计划提供了有用的见解。太好了！

三个月后，新晋升的主管，现在是你的 CEO，要求你在下一次计划会议上重新进行分析…而你不能。代码被破坏是因为您覆盖了文件的一些关键部分，并且您不记得当时使用的确切环境。或者，代码可能是好的，但它在一个大的 Jupyter 笔记本中，所有文件路径都是硬编码的，这意味着您必须费力地检查和更改每一个新数据输入。不太好！

数据科学家对软件工程的一些日常原则并不熟悉，他们并不都有广泛的编程背景。事实上，许多数据科学家都是自学的，作为研究项目的一部分或在工作中必要时学习编程。也许，一些数据科学家会争辩说他们的代码不需要高标准，因为他们不是在生产系统上工作。

任何支持业务决策流程的代码都应被视为生产代码

数据科学家可能不认为他们工作的主要产出是代码，但这并不意味着他们编写的代码不应该遵循软件工程团队期望的标准。事实上，它至少应该具有以下特征:

版本化 —使用 git 或类似的工具定期保存您的更改，无论您是独自工作还是在团队中工作。
再现性 —您应该能够将一个项目转移到另一台计算机上并运行它，而不需要大量的工作或重新配置。
遵循标准——通用的项目结构、标准的编码约定和工具。
文档 —自动化文档，使您的文档与您的代码保持同步。
模块化——代码可以很容易地执行和测试。

关于这些原则的更多细节，请看来自 QuantumBlack 的 Thomas Huijskens 的有用的博客文章。

凯卓是什么？

Kedro 是一个开发工作流工具，允许你创建可移植的数据管道。它将软件工程最佳实践应用到您的数据科学代码中，因此它是可复制的、模块化的和有据可查的。如果你使用 Kedro，你可以更少地担心如何编写生产就绪的代码(Kedro 为你做了繁重的工作),你将标准化你的团队合作的方式，让你们所有人更有效地工作。

许多数据科学家需要执行例行的数据清理、处理和编译任务，这些任务可能不是他们最喜欢的活动，但却占了他们日常任务的很大一部分。Kedro 使得构建数据管道来自动化“繁重的工作”变得更加容易，并且减少了在这种任务上花费的时间。

Kedro 由高级分析公司 QuantumBlack 创建，该公司于 2015 年被咨询巨头麦肯锡&公司收购。QuantumBlack 已经在麦肯锡的 60 多个项目中使用了 Kedro，现在决定将其开源。他们的目标是让员工、客户和第三方开发人员能够使用 Kedro 并在其上进行构建。通过根据自己的需求扩展这一开放工具，数据专业人员能够有效地完成他们的常规任务，并有可能将他们的改进分享给社区。

The team from Quantum Black explain Kedro

Kedro 是工作流调度器吗？

Kedro 不像 Airflow 和 Luigi 那样是工作流调度器。Kedro 使您的数据管道原型化变得容易，而 Airflow 和 Luigi 是互补的框架，在管理部署、调度、监控和警报方面非常出色。Kedro 管道就像是制造汽车零件的机器。气流或路易吉告诉不同的机器打开或关闭，以便一起工作，生产出一辆汽车。QuantumBlack 构建了一个 Kedro-Airflow 插件，提供了更快的原型开发时间，并降低了将管道转移到两个工作流调度器的门槛。

我需要知道什么？

Kedro 的文档是为初学者设计的，帮助他们开始创建自己的 Kedro 项目(Python 3.5+)。如果你只有非常基础的 Python 知识，那么你可能会发现学习曲线更具挑战性，但是忍耐一下，并遵循文档的指导。

与凯卓进行十五分钟的太空飞行

我简单易懂的 15 分钟教程将基于以下场景:

现在是 2160 年，太空旅游业正在蓬勃发展。在全球范围内，有数千家航天飞机公司将游客送上月球并返回。你已经能够找到三个(虚构的)数据集，包括每架航天飞机提供的便利设施、顾客评论和公司信息。您希望训练一个线性回归模型，该模型使用数据集来预测班车租赁价格。但是，在开始训练模型之前，您需要通过进行一些数据工程来准备数据，这是通过创建主表来为模型构建准备数据的过程。

正在设置

第一步，将 kedro pip 安装到一个新的 Python 3.5+虚拟环境中(我们推荐 conda )，并通过键入以下命令确认安装正确

kedro info

您应该会看到如下所示的 Kedro 图形:

这将另外给你你正在使用的 Kedro 版本。我在 2019 年 5 月基于版本 0.14.0 编写了本教程，由于这是一个活跃的开源项目，随着时间的推移，可能会对代码库进行更改，从而导致示例项目发生微小变化。我们将努力保持示例代码最新，虽然不是这篇博客，所以如果你发现任何不一致的地方，你应该参考 Kedro 文档和发布说明。

Kedro 工作流程

构建 Kedro 项目时，通常会遵循标准的开发工作流程，如下图所示。在本教程中，我将走过每一个步骤。

设置项目模板

为了简单起见，QuantumBlack 团队已经提供了您需要的所有代码，因此您只需从其 Github Repo 中克隆示例项目。在本教程中，您不需要设置项目样板。

一旦有了 Spaceflights 项目的代码，为了确保有必要的依赖项，请在 Python 3.5+虚拟环境中运行以下代码:

kedro install

设置数据

当可能需要引用不同位置的数据集时，Kedro 使用配置文件使项目的代码可以跨不同环境进行复制。

要为 Kedro 项目设置数据，通常需要将数据集添加到 data 文件夹中，并配置管理数据加载和保存的数据源注册表

本教程使用了航天公司往返月球的三个数据集，并使用了两种数据格式:。csv 和. xlsx .文件存储在项目目录的data/01_raw/文件夹中。

为了使用所提供的数据集，所有 Kedro 项目都有一个conf/base/catalog.yml文件，作为所使用数据集的注册表。注册数据集就像在。yml 文件，包括文件位置(路径)、给定数据集的参数、数据类型和版本。Kedro 支持一些类型的数据，如 csv，如果您查看 Spaceflights 教程的 catalog.yml 文件，您会看到所用数据集的以下条目:

companies:
  type: CSVLocalDataSet
  filepath: data/01_raw/companies.csvreviews:
  type: CSVLocalDataSet
  filepath: data/01_raw/reviews.csv

要检查 Kedro 是否正确加载了数据，并检查前五行数据，请打开一个终端窗口，并在 Kedro 项目目录中启动一个 IPython 会话(当您想要结束会话并继续学习本教程时，只需键入(exit()):

kedro ipython
io.load(‘companies’).head()

创建并运行管道

工作流的下一部分是从一组节点创建管道，这些节点是执行不同的单独任务的 Python 函数。在典型的项目中，项目的这一阶段包括三个步骤:

编写并记录您的节点函数
通过为每个节点指定输入和输出来构建管道
运行 Kedro，选择是顺序运行还是并行运行节点

数据工程管道

我们已经审查了 Spaceflights 项目的原始数据集，现在是时候考虑数据工程管道了，该管道在数据科学管道内处理数据并为模型做准备。这个管道预处理两个数据集，并将它们与第三个数据集合并到一个主表中。

在 nodes 文件夹内的文件 data_engineering.py 中，您将找到preprocess_companies和preprocess_shuttles函数(在 pipeline.py 中指定为管道内的节点)。每个函数接收一个数据帧并输出一个预处理数据，分别为预处理公司和预处理班车..

当 Kedro 运行数据工程管道时，它确定数据集是否在数据目录中注册(conf/base/catalog.yml)。如果注册了数据集，它会自动保存到指定的路径，而无需在函数本身中指定任何代码。如果数据集没有注册，Kedro 会在管道运行时将它存储在内存中，然后删除它。

在本教程中，预处理后的数据登记在conf/base/catalog.yml中:

preprocessed_companies:
  type: CSVLocalDataSet
  filepath: data/02_intermediate/preprocessed_companies.csvpreprocessed_shuttles:
  type: CSVLocalDataSet
  filepath: data/02_intermediate/preprocessed_shuttles.csv

选择CSVLocalDataSet是因为它的简单，但是你可以选择任何其他可用的数据集实现类来保存数据，例如，保存到数据库表、云存储(像 S3、Azure Blob Store 等)。)等。

data_engineering.py 文件还包括一个函数create_master_table,数据工程管道使用该函数将公司连接在一起，将数据帧传送并审核到一个主表中。

数据科学管道

数据科学管道构建了一个使用数据集的模型，由价格预测模型组成，该模型使用了来自 scikit-learn 库的简单 LinearRegression 实现。代码在src/kedro_tutorial/nodes/price_prediction.py文件中。

预测模型的测试大小和随机状态参数在conf/base/parameters.yml中指定，Kedro 在执行流水线时将它们输入到目录中。

合并管道

本工程的管线在 pipeline.py 中注明:

def create_pipeline(**kwargs): de_pipeline = Pipeline(
    [
      node(preprocess_companies, “companies”, “preprocessed_companies”),
      node(preprocess_shuttles, “shuttles”, “preprocessed_shuttles”),
      node(create_master_table,[“preprocessed_shuttles”, “preprocessed_companies”, “reviews”],“master_table”,),
    ],
    name=”de”,
  )ds_pipeline = Pipeline(
    [
      node(split_data,[“master_table”, “parameters”],[“X_train”, “X_test”, “y_train”, “y_test”],),
      node(train_model, [“X_train”, “y_train”], “regressor”),
      node(evaluate_model, [“regressor”, “X_test”, “y_test”], None),
    ],
    name=”ds”,
  )return de_pipeline + ds_pipeline

de_pipeline将对数据进行预处理，然后使用create_master_table将preprocessed_shuttles、preprocessed_companies和reviews组合成master_table数据集。然后ds_pipeline将创建特征，训练和评估模型。ds_pipeline 的第一个节点输出 4 个对象:X_train、X_test、y_train、y_test，这些对象随后用于训练模型，并且在最终节点中用于评估模型。

两条管线在de_pipeline + ds_pipeline合并在一起。添加管道的顺序并不重要，因为 Kedro 会自动检测所有节点的正确执行顺序。如果您指定了ds_pipeline + de_pipeline，将会产生相同的整体管道。

当您调用 kedro run 时，这两个管道都将被执行，您应该会看到类似如下的输出:

如果您在启动和运行教程代码时遇到任何问题，您应该检查您是否在 Python 3.5 环境中工作，并且已经安装了项目的所有依赖项。如果仍有问题，您应该前往 Stack Overflow 寻求社区的指导，如果您观察到的行为似乎是 Kedro 的问题，请在 Kedro 的 Github 库上提出问题。

凯卓跑步者

有两种不同的方式来运行 Kedro 管道。您可以指定:

SequentialRunner —按顺序运行您的节点:一旦一个节点完成了它的任务，下一个节点就会开始
ParallelRunner —并行运行您的节点:独立节点能够同时运行，允许您利用多个 CPU 内核，并且当您的管道中有独立分支时，效率会更高。注意ParallelRunner执行任务并行化(即可以一次运行多个任务)，但不并行化任务内的计算。

默认情况下，当您调用 kedro run 时，Kedro 使用一个SequentialRunner。切换到使用ParallelRunner非常简单，只需提供一个额外的标志，如下所示:

kedro run — parallel

贯穿 Kedro 基础的教程到此结束。还有更多关于各种配置选项和优化的文档，您可以在自己的项目中使用，例如:

安装指南
本教程的加长版
用户指南
API 参考
quantum black 的博客文章

欢迎投稿！

如果您开始与 Kedro 合作，并希望为 Kedro 项目提供一个示例或更改，我们将欢迎与您合作的机会。请查阅投稿指南。

承认

Spaceflights 的例子是基于 QuantumBlack Labs 的 Kedro 团队编写的教程(Yetunde Dada、Ivan Danov、Dmitrii Deriabin、Lorena Balan、Gordon Wrigley、Kiyohito Kunii、Nasef Khan、Richard Westenra 和 Nikolaos Tsaousis)，他们好心地让我提前获得他们的代码和文档，以便为 TowardsDataScience 制作这个教程。谢谢大家！

把机器人关在笼子里——合作机器人有多有效(和安全)？

原文：https://towardsdatascience.com/keep-the-robot-in-the-cage-how-effective-and-safe-are-co-bots-623784f5e27f?source=collection_archive---------27-----------------------

Co-bots are filling a niche in industrial manufacturing between humans and caged industrial robots, but do they offer enough value when balanced against the risk of injury? IPOPBA — FREEPIK

制造机器人正在挣脱牢笼。传感器技术和人工智能现在已经发展到这样一个阶段，即协作机器人(co-bots) 可以在各种各样的应用中与人类一起安全地工作，包括超市、农场和医院。但是制造业是联合机器人真正帮助提高生产力的地方，远远超过人类和机器人单独工作的生产力。

然而，随着市场的扩大，企业必须做好适当的准备，以充分利用合作机器人，避免代价高昂(如果不是危险的话)的错误。

让机器人与人类近距离接触是我们技术进步的巨大进步，将使我们能够实现新的复杂程度，并最大限度地降低受伤风险，特别是在制造业。但是就像任何新的强大的技术一样，在将合作机器人融入企业之前，有一些重要的考虑事项。

生产率悖论

与机器人一起工作是一个新概念:我们已经习惯了机器人在装配厂工作或在笼子里勤奋工作的想法，但与人类一起工作的机器人似乎仍然好得难以置信。这是因为工业机器人被专门设计成不与人类互动，这是有充分理由的:例如，2015 年，一名在大众汽车工厂安装机器人的承包商被误认为是汽车零件后，被 抓住并压在金属板 上。虽然这样的事件并不常见，但这些机器人的预期目的(举重物、使用腐蚀性化学品、高强度焊接)要求它们在执行太危险、太精确、对旁观者有潜在危险或人类自己根本不可能完成的任务时保持隔离。然而，由于这种符合目的的设计，使机器人在人类周围安全可能实际上降低了它们有效完成工作的能力——如果我们限制合作机器人，使它们在人类周围安全，它们能像笼子里的同类一样表现吗？

SAP Industries的联合总裁彼得·梅尔解释说:“合作机器人比传统的工业机器人更小更轻……[并且]配备了传感器，如果它感觉到有人在它的道路上，它就会指示合作机器人后退。”迈尔说，合作机器人在人类周围工作时会小心翼翼，这对我们来说是好事，但也提出了一个问题，即它们是否比工业机器人有更多好处，因为工业机器人“比合作机器人的操作精度、准确度和速度更高”。

最初，联合机器人可能会更多地被无力承担传统工业机器人空间和资金的公司使用，但随着它们的智能增长和传感器技术的进一步改善，联合机器人将找到自己的优势。

迄今为止，将人类和机器人分开一直是我们成功的唯一衡量标准，但迈尔和其他许多人认为，“合作机器人协助人类驱动的任务的能力提高了整个过程的生产率”，因为它确保了人类不必在危险或重复的任务上浪费时间。麻省理工学院的一项研究发现， 联合机器人将人类的闲置时间减少了 85% ，他们与斯帕坦堡宝马工厂的合作发现，某些任务(如在车门内侧卷起一层保护箔)消除了人类重复性劳损的风险，而不会对装配线造成任何额外的风险。

安全第一

合作机器人应该被视为不同于工业机器人。合作机器人不会取代需要关在笼子里的机器人，而是最有可能致力于增加人类的劳动:正如迈尔所说，“合作机器人正在接受从烤汉堡到执行高度专业化的手术任务的一切测试。”然而，协同机器人并不完全是即插即用的:就像任何学习和适应其环境的应用程序一样，它们需要接受适当的训练，目标要适合它们的特定任务(这并不总是像听起来那么容易)。Robotiq 的首席技术官 Jean-Phillipe Jobin 建议企业仔细考虑他们如何使用合作机器人，并为他们的员工和工作环境做好适当的准备，以避免在不适当的实施上浪费时间、精力和金钱。乔宾表示，制造企业在实施合作机器人时，尤其必须问自己三个至关重要的问题:“机器人在执行什么任务，机器人系统本身在做什么，它是否安全，以及机器人在哪个空间内移动？”

“一旦这些问题得到回答，”乔宾说，“制造商应该对涉及的每一步进行风险评估，包括如果机器人用于多项任务，将机器人从一项活动转移到另一项活动。”这种远见不仅对从合作机器人的特殊技能中受益至关重要，而且对确保它们在人类中安全运行也至关重要。Jobin 还指出，“每个人都有独特的视角，只有当每个使用机器人的人都参与进来时，安全才是可能的”——尽管对于首席管理人员来说，准确理解联合机器人在做什么很重要，但那些直接与联合机器人一起工作的人将不可避免地受到公司联合机器人战略的最大影响。

这种协作的元素(名字“合作机器人”的内在特征)也是一个不总是被考虑的要点:即合作机器人被设计成与人类一起完成某些任务，并完成既不适合人类也不适合传统笼中机器人的 肮脏、危险和枯燥的 工作。在实施联合机器人时，乔宾强调公司需要记住联合机器人的预期目的，即“将操作员从这些任务中解放出来，让他们专注于更有价值的任务”，并认为联合机器人安全完成任务的能力“与安全措施同步增长”。

合作机器人来了(说‘嗨’)

联合机器人的有效性将在未来几年得到检验，并且必须被证明超越了任何合理的怀疑，联合机器人才能真正起飞。我们已经看到直接或间接与人类合作的机器人数量大幅增加( 亚马逊 和 沃尔玛 最近公开涉足)，尽管过去几年头条新闻充斥着关于 联合机器人对就业 影响的猜测，但对联合机器人的真正考验是证明它们可以在大规模制造环境中安全工作。

正如乔宾所说，“曾经导致工人受伤的繁重任务现在可以由合作机器人安全高效地完成，”那些考虑将机器人带到工厂车间的人应该记住，这种增强是合作机器人的设计目的，并据此准备他们的业务。

这意味着培训和咨询员工，考虑技术的每一种可能的用途，并设置合作机器人来完成任务，让员工专注于更重要的事情。

合作机器人可能对一些人来说仍然是一个新奇的事物，但是一旦他们的利基建立起来，制造业就可以期待液压辅助的生产力激增。

原载于【https://www.forbes.com】。****

关注混杂因素:计算偏相关矩阵的演练

原文：https://towardsdatascience.com/keeping-an-eye-on-confounds-a-walk-through-for-calculating-a-partial-correlation-matrix-2ac6b831c5b6?source=collection_archive---------15-----------------------

一个 R 演示程序，演示了计算部分相关矩阵的两种方法

Don’t forget about potential confounding variables! Photo from Wikimedia Commons

分析师在数据管理/预处理后执行的最常见步骤之一是运行相关性分析，以标准化的方式检查变量之间的成对关联。这是一种快速且相当轻松的方式来感受您的数据。然而，如果在您的数据集中潜伏着与两个感兴趣的变量相关的其他混淆变量，那么孤立地查看两个变量之间的关系可能会产生误导。

因此，在某些情况下，计算偏相关矩阵可能是更好的选择。这种矩阵将允许人们快速测量和观察 2 个变量之间的关联，同时控制数据集中的所有其他变量。下面，我们将从头开始讨论计算部分相关矩阵的两种方法，并说明如何使用“ppcor”软件包。

对于这个示例，我们将使用空气质量数据集的一部分，该数据集包含 1973 年部分时间内纽约每日空气质量水平的信息。

Manhattan in 1970. Photo from Wikimedia Commons

Overview of the “airquality” data set

首先，我们将运行相关性分析来检查这些质量度量之间的关系。谈到一些结果，我们可以看到较高水平的臭氧与气温上升有关，而较高的风速与较低水平的臭氧有关。风和太阳辐射几乎相互垂直。

我们可以使用“corrplot”包改进可视化。

现在我们已经看了相关结构，让我们继续计算一个部分相关矩阵。这里的想法与运行多元线性回归并试图“控制”其他混杂变量(如 X2 和 X3)的想法相同，同时查看感兴趣的预测变量 X1 对结果变量 y 的影响。偏相关矩阵的好处是可以在标准化矩阵中获得所有这些关联，以便于查看。

我们将介绍的计算偏相关矩阵的第一种方法是求解一系列(等于数据集中变量的数量)两个相关的线性回归模型。我们从这些结果模型中提取残差，并计算它们之间的相关性。为了澄清，让我们说，我们要计算臭氧和太阳之间的部分相关性。

我们有两个模型:
1)模型 1:臭氧~风+温度
2)模型 2:太阳能。风+温度

并对残差进行相关以计算偏相关，结果为 0.242。

我们将概括这一点，在下面的空气质量数据集中以成对的方式找到偏相关。

我们可以并排查看相关矩阵和部分相关矩阵，以了解系数是如何变化的。考虑到我们在“控制”数据集中的其他变量，所有系数的大小都有所降低，这并不奇怪。这种减少在某些情况下更加明显。例如，温度和风之间的相关性是-.5。温度和风之间的偏相关，考虑到了太阳。r 和臭氧，只有 0.13。

我们要研究的第二种计算偏相关的方法使用矩阵代数，而且更简洁。

从相关矩阵 R 开始，我们首先需要找到反镜像协方差矩阵 AICOV 。为了找到 AICOV ，我们需要 D ，即 R 的逆的对角元素的逆。有了 D ，我们可以计算出 AICOV 如下: AICOV = DR⁻ D 。

利用 AICOV 矩阵，我们可以计算反图像相关矩阵 AICOR。这里， D 等于 AICOV 的对角线，平方根，求逆。 AICOR = D / AICOV D /。

在 AICOR 的对角线上是负的部分相关值。我们可以将一个负数乘以 AICOR 的非对角元素，得到偏相关矩阵。下面是一个函数，它可以接受数据集或相关矩阵，并返回部分相关矩阵。

最后，为了确保所有之前的计算都是正确的，我们
可以使用“ppcor”包和“pcor”函数来轻松计算
偏相关系数，并获得用于显著性
测试的指标。

在本演示中，我们查看了从头开始计算偏相关的两种不同方法，并观察了在考虑数据集中的其他变量时，系数(之前在相关中观察到的)会发生怎样的剧烈变化。

希望这是有用的，如果合适的话，你可以在查看数据时检查偏相关！

保持数据科学的科学性

原文：https://towardsdatascience.com/keeping-data-science-scientific-c317838ab317?source=collection_archive---------31-----------------------

Oil painting by Francesco Masci.

卡尔·波普尔会如何看待这门最新的科学学科？

下面，我解释了丹尼尔·卡尼曼的畅销书《思考，快与慢》中最初提出的研究问题:

肝癌发病率最高和最低的地区都在农村。为什么？

我会在帖子的最后回到这个问题。但是现在，让我们讨论一下，从我们收集的关于我们自己的空前数量的信息中，知识会得到什么，会失去什么。

数据科学的标准定义是:“使用科学方法、流程、算法和系统从结构化和非结构化数据中提取知识和见解的多学科领域。”随着信息时代的不断发展，互联网连接和个人计算几乎无处不在。发达国家每一个 50 岁以下的人都在不停地敲击手机屏幕，在笔记本电脑上打字，享受各种数字内容，世界科技公司正在积累前所未有的海量数据。数据科学领域已经开始组织和优化这些数据，通常是为了提高数字服务的性能，如亚马逊商店产品推荐和 Spotify“每周发现”播放列表背后的算法。然而，数据科学也让我们能够在以前无法想象的水平上研究错综复杂的社会行为。随着智能扬声器进入我们的家庭，智能汽车上路，我们只会继续收集更多关于自己的信息。

Data data data (Source: Ourworldindata.org)

然而，拥有更多的数据和信息并不会自动转化为更高的知识和理解。我们将数据转化为真正洞察力的能力仍然依赖于正确运用科学方法。这绝不是保证；根据一些知识分子的说法，几十年来，社会严重依赖未经提炼的科学。

出生于奥地利的英国哲学家卡尔·波普尔(Karl Popper)以其对可证伪性、科学方法以及对归纳法的批评而闻名，他概括了这一令人警醒的思路。波普尔认为，真正的科学依赖于可被证伪的假设。科学严谨的理论在透彻的研究和逻辑检验的基础上做出假设，然后用一切可用的手段证明假设是错误的。这种类型的科学推动人类前进；正如波普尔的信徒纳西姆·尼古拉斯·塔勒布指出的，牛顿的运动理论为人类理解物理创造了奇迹，尽管几百年后被爱因斯坦证明是错误的。进步来自于发现不能被证明是错误的断言，并坚持不懈地进行实验来反驳理论。

Karl Popper

演绎和归纳之间的二分法完美地概括了波普尔等人所认为的科学的不恰当实施。在前一种情况下，我们通过从理论到假设，再到经验观察，最后拒绝假设来进行推理。另一方面，归纳法使用经验事实来发现模式，产生假设并形成理论。归纳法更难反驳，也更危险，因为正如塔勒布所说，它让我们“被随机性所愚弄”。诱导可能表面上看起来无害，但实际上有有害的副作用；当你利用历史数据建立模型，并在房价永远不会下跌的假设下运行时，你就遇到了麻烦。

波普尔追求的是社会科学家，他们创立了表面上看似革命性，但实际证明摇摇欲坠的宏大理论。这是因为这些类型的理论是不可能反驳的。例如，考虑西格蒙德·弗洛伊德关于恋母情结的理论。人们怎么可能否认孩子潜意识里对父母有性吸引力呢？你不能。因此，这是一个不科学的分析，并不比暗示上帝的存在更严格。然而，在许多情况下，不科学的理论被广泛认为是真理。主流经济学是这一现象的完美例子。这一学科的模型变得越来越复杂、数学化，并且脱离现实，在预测成功方面没有任何改进。正如统计学家内特·西尔弗(Nate Silver)所言:“经济预测正在好转的任何幻想，都应该被经济学家在金融危机爆发前犯下的可怕错误击碎。”[1]

当我们专门使用历史数据(也称为经验知识)来制定理论时，我们创建的模型平均来说非常准确，但仍然容易受到边缘情况的影响。正如在一个问题上投入更多的钱并不一定等于解决了这个问题，向我们的模型中添加更多的数据并不一定会使它们更好地反映现实世界。根据定义，模型是一种模拟，有了更多的数据，很容易过度拟合并将信号误认为噪声。但是数据的价值不在于它的整体质量，而在于我们磨练、塑造和解释数据的能力。是关于的过程。

一个好的数据科学家应该对科学方法有很强的理解，提出正确的问题，并对经验知识保持怀疑，特别是在建立具有严重后果的模型时。我们应该记住，“我们学的越多，知道的越少”这句话是有一定道理的；爱因斯坦的相对论可以说创造了更多关于宇宙的问题，而不是答案。

因此，如果你深入研究农村社区的社会行为，并使用数据科学来分析化学品暴露、生活方式差异、文化规范、营养模式等。我相信你可以找到一些令人信服的结果来解释为什么美国农村社区肝癌发病率最高和最低。当我第一次遇到这个研究问题时，我当然绞尽脑汁寻找这样的答案。但是 Popper 对使用你的实证分析建立一个模型来预测农村社区未来的肝癌发病率持怀疑态度。为什么？

此后不久，Kahnman 提醒读者，农村社区的人口比城市地区少，因此考虑到它们的统计分布，它们具有更高的方差和更多样的结果，导致更高和更低的癌症发病率。较小的样本量增加了随机性的影响。当没有因果关系时，人类倾向于创造故事和假设因果关系，所以我们的直觉是对事件做出“科学”的解释，即使统计规律是对小农村社区癌症发病率进一步波动的完美合理的解释。当我们开始研究点击量和点赞数提供给我们的信息宝库时，牢记机遇的作用并对经验主义保持怀疑是很重要的。

引用的作品

[1] N .西尔弗，信号与噪声 (2012)。

保持数据科学简单

原文：https://towardsdatascience.com/keeping-data-science-simple-7c6f4dc51a85?source=collection_archive---------13-----------------------

数据科学是一个充满新奇事物的领域。简单和复杂的概念都有很酷的名字，让你声称自己是“人工智能驱动的”。虽然这不一定是一个问题，但它可能会误导有抱负的数据科学家。像任何领域一样，花哨的名字和复杂的概念吸引了很多关注。这有助于给人留下这样的印象:尖端建模是聚会所在。然而，数据科学不仅仅是关于谁拥有最多的卷积神经网络或最深入的学习。疯狂的人工智能技能在某些情况下可能会被证明是有价值的，但数据科学是关于为工作选择正确的工具，并有效地使用它来解决现实世界的问题。最后一部分，解决现实世界的问题，应该永远是最终目标。持续实现这一目标是数据科学职业生涯的基础。

为了帮助建立这个基础，需要遵循三个简单的步骤，

专注于解决现实世界的问题，同时衡量你的解决方案。
为工作选择合适的工具，这可能是最简单的。
不断重复。

Keep it simple

适合这项工作的工具通常是最简单的，至少在开始时是这样。复杂的模型会崩溃，它们的行为可能很难培养出一种直觉，实现它们也很耗时。专注于简单，你会开始更多的项目，这些项目本身可能会有更高的成功率。当开始数据科学职业生涯时，拥有提供真实世界价值的记录将会给你巨大的推动。机器学习、统计或编程方面的教育将为你提供基本的技能，但证明你能够将这些技能应用于现实世界的问题，并有效地传达你的解决方案，则更有价值。

从简单的项目开始，直到完成，这将有助于你建立记录。一个项目可以从一个简单的 SQL 查询开始，所以试着列出你公司内外可能的项目，然后逐一尝试。创造和衡量价值应该优先于几乎所有事情。重要的是要记住，你如何衡量你的解决方案取决于你试图解决什么问题。如果我试图创建一个抵押贷款审批模型，我可能更关心正确地筛选出欺诈者，而不是错误地拒绝那些善意的人。我如何衡量我的解决方案应该反映这些优先事项。这种方法不仅是建立投资组合的最佳方式；这是任何数据科学工作的重要组成部分。与利益相关者交谈，找到问题的根源，并找到衡量您的解决方案所提供价值的最佳方式。

摘要

如果你想进入数据科学领域，找到现实世界中的问题，并尽可能快地解决它们。最简单的方法将帮助你完成更多你开始的事情，并让你更快得到结果。建立一个坚实的技能基础是很重要的，但是能够展示你的技能所带来的影响比它们听起来有多令人兴奋更有价值。

保持优雅:Quizlet 如何使用层次分类来标记学术主题的内容

原文：https://towardsdatascience.com/keeping-it-classy-how-quizlet-uses-hierarchical-classification-to-label-content-with-academic-4e89a175ebe3?source=collection_archive---------15-----------------------

Quizlet 的社区管理的学习集目录非常庞大(3 亿个，并且还在增长),涵盖了广泛的学术主题。拥有如此大而多样的内容目录使 Quizlet 用户能够掌握世界上的任何主题，但这也产生了有趣的信息检索问题。Quizlet 的搜索、导航和个性化系统都依赖于能够将我们的内容组织成直观的学术主题。在这篇文章中，我们将讨论如何开发我们的学术主题分类，以及如何使用机器学习(ML)来自动为 Quizlet 平台上发布的每个研究集分配主题标签。

定义和组织学术主题

这个项目的第一步是定义构成 Quizlet 学习集目录的学术主题的组织结构。学术主题可以用多种方式定义，而且在主题应该如何组织的问题上没有共识。经过一些研究，我们决定将我们的学术主题组织成一个层次分类树(图 1 )。这种结构类似于著名的系统发生树，用于组织不同生物物种之间的等级关系。我们选择这种组织结构不仅是因为它的直观性和与以前的文献的重叠，也是因为它与可用于高效搜索和信息检索的图形数据结构的一致性。

Figure 1, A subset of Quizlet’s Academic Subject Taxonomy. Subjects are defined in a hierarchical tree, with each node representing increasingly specific subjects as one moves away from the root node All (subjects). Subjects were identified from a combination of pedagogical research and analysis of the content of Quizlet study sets.

为了定义构成我们的分类图的特定主题，我们从各种在线资源中汇编了定义(例如维基百科定义了从公共学术课程中派生的广泛的主题层次)。除了标准主题定义之外，我们还挖掘 Quizlet 内容，以确定平台上经常出现但标准定义中可能没有的主题(例如，体育或阅读词汇是大多数主题分类法定义中没有的常见 Quizlet 研究主题)。

图 1 描述了 Quizlet 使用的主题分类法的子集。该分类法包含数百个独立的主题，跨越八个层次的特性。例如，主题冷战将与层级中的叶节点相关联，该叶节点遵循来自层级根节点的路径:

所有→人文→历史→世界历史→世界大战→冷战

分配带有主题标签的器械包

有了主题分类法，我们接下来的任务就是给所有 Quizlet 研究集贴上最相关的主题标签。由于器械包和可用主题的数量，手工标记所有器械包是不合理的。解决像我们这样的大规模标签问题的一种常见方法是使用 ML 来构建自动标签系统。这种方法需要训练计算机算法来学习像“包含单词线粒体的研究集通常被分配主题标签科学”这样的模式。然后，我们使用经过训练的算法来预测新研究集的标签。ML 方法提供了比人工标记更好的规模、速度和一致性，但代价是实施所需的时间和技术专长。

构建学习数据集

为了让 ML 模型学习，我们必须为模型提供一个输入-目标对的数据集，这些数据集一致地表现出我们希望模型识别的期望模式。在我们的应用程序中，输入属性可以是研究集的标题和文本内容，目标是分配给研究集的主题标签。学习数据集需要包含每个目标值的足够观察值，以允许模式识别算法捕捉输入和目标之间的关系。根据输入-目标关系的复杂性，学习可能需要大量的观察。

我们发现，由于类别的数量以及内容和主题标签之间关系的复杂性，手动管理一个足够大的学习数据集是不可行的。然而，在训练期间，学习数据集通常分为两个子集:用于优化模型参数的训练集，以及用于评估最终模型在野外表现如何的测试集。测试集的这种支持有助于减轻被称为 过拟合 的现象，提高泛化性能。然而，也证明了，只要训练集足够大(例如，在高方差模型体系中的，在训练集中具有噪声比在测试集中问题更少。

在这一概念的指导下，我们生成了我们的学习数据集，以使我们的应用程序具有足够的大小，如下所示:我们使用正则表达式基于研究集标题中关键模式的存在，将主题标签从我们的分类法分配给研究集，生成了一个由(~1M)“不完美”训练观察值组成的大型训练集。然后，我们手工生成一个小得多的测试集(大约 10k 个观察值),以确保得到的观察值具有准确的输入-目标对应关系，并且充分覆盖了分类法主题标签。

制定和培训模型

除了生成学习数据集，我们还需要为我们的自动标注应用程序制定和训练一个 ML 模型。主题标注自然是作为一个离散的分类问题提出的，其目标是估计一个函数F(φ(s))，该函数将集合φ(s)的输入特征值映射到一个或多个分类标签 l ∈ L 。在这种情况下，我们的候选分类标签 L 是我们派生的主题分类法中的主题标签。

计算模型特征

特征化函数φ(s)将输入观察值的属性转换成可以被 ML 模型的算法解释的数值。对于这项工作，φ(s)将集合标题和内容文本中最具信息性的单词的平均嵌入向量与集合中出现的语言的二进制编码连接起来。嵌入向量模型在从数百万 Quizlet 集合中采样的文本上进行训练，并捕捉这些集合中出现的单词之间的语义关系。特征变换φ(s)可以被解释为集合 s 在高维语义空间中的位置的数字表示。这个“语义位置”是 ML 学习算法用来将集合的内容与最相关的主题相关联的关键信号。

我们将φ(s)应用于我们学习数据集中的所有集合，产生用于训练多个候选 ML 模型的数字特征(即各种 F 函数)。下一节描述了我们在模型开发过程中尝试的各种建模方法。

非结构化预测

我们的应用程序的一种建模方法是简单地忽略分类法的层次结构，将分类法树中的每个节点视为一个独立的类标签。使用这个非结构化预测策略，我们估计一个单一的、全局的分类器，该分类器跨整个分类法预测最佳主题标签。我们也将非结构化预测称为扁平化方法，因为它本质上是将树形层次结构扁平化为一个节点层(图 2A )。

扁平策略直观、简单，并且受益于这样一个事实，即由于分类法本身是分层的，所以可以免费获得关于任何父节点的信息。此外，与我们接下来将讨论的结构化预测策略相比，扁平策略具有更简单的推理过程，并且需要更少的外来数据结构。但是，因为扁平策略提出了一个全局分类问题，它可能无法利用本地分类结构来提高决策功能的特异性。结果是，与树中较深节点相关联的高度专门化的主题可能被忽略，而优先选择不太专门化的标签，因为它们更容易与干扰物分开。

结构化预测&分层推理

在结构化预测方法下，我们使用主题分类的分层结构将一般分类任务分解为多个子问题，每个子问题专用于分类树的本地子部分。例如，如果我们想要一个区分主题二战和冷战的模型，对主题人体解剖学或生物学甚至科学的信息进行编码会增加不相关的信息。原则上，通过允许每个局部分类问题仅关注输入中的细微差别，将任务分解成子问题应该提高所得模型的整体特异性，这有助于它最好地区分局部类目标。

与非结构化预测的情况不同，我们不是训练单个全局分类器，而是训练多个局部分类器，一个用于树中的每个父节点。当训练每个局部分类器时，训练目标是当前节点的子节点的索引。注意，只有训练数据集中的观察值的子集将被分配与这些子节点相关联的标签。因此，我们必须划分训练数据集，以仅包括那些与本地分类器相关的观察值。当训练局部分类器时，我们使用两种策略来划分训练集:

排他划分 ( 图 2B ):这种划分策略仅使用训练集中那些被分配了与子节点直接关联的标签的观察值。这种策略受益于对目标节点的高度特异性，代价是如果我们还包括与子节点的后代相关联的观察，则可能使用比可用数据更少的数据。
包含划分 ( 图 2C ):使用这种策略，当前分类器节点下的每个子树都与目标子节点索引相关联。这种策略增加了与每个目标节点相关联的观察值的数量，代价是可能给局部分类问题引入噪声。

Figure 2, Various Modeling Approaches and Training Data Partitioning Strategies. When training a hierarchical classification system, classifiers are trained for one or more parent nodes in the associated tree hierarchy. Node color indicates the taxonomy labels used to identify target observations for the current classifier. Three possible strategies for training the hierarchical classification system are displayed. A) unstructured prediction uses Flat partitioning and fits a single, global classifier with each node in the taxonomy being considered an independent class. B) Exclusive partitioning is used for structured prediction; only those observations that are associated with the children of the current node are used to train the current parent classifier. C) Inclusive partitioning is also used for structured prediction, but also includes observations associated with each subtree under the current classifier node as being labeled as a single target class.

训练一个结构化的预测模型需要训练N=(V-Z)个局部分类器，其中 V 是分类中的顶点总数， Z 是叶节点数。然而，一旦每个分类器的训练数据已经被划分，所有的局部分类器就彼此独立，并且可以被并行训练。所以训练一个结构化的预测模型，实际上在实践中是相当快的。

层次推理

在所有局部分类器被训练之后，我们使用分层推理来对新的观察结果进行预测(图 3 )。等级推理从等级的根节点开始，选择相关分类器在给定当前输入特征的情况下为其分配最大概率的子节点。在下一步中，所选子节点的分类器成为当前父分类器，并且在给定当前输入特征的情况下，选择具有最大概率的子节点，等等(图 3B )。重复这种逐级推理过程，直到到达树中的叶节点，或者当前目标/子集合的最大概率小于推理过程中来自前一级的子集合的最大概率(图 3C )。

Figure 3, Hierarchical Inference Procedure. Inference for a new observation is performed in a greedy, stage-wise fashion. A) The first stage starts with the root node, calculating the probability for the current observation over all candidate children nodes (Relative probability is depicted here as the thickness of the border for each candidate node). B) The candidate node with the maximum probability is then taken to be the next parent node. C) The process is repeated until either the maximum probability at the current inference stage is less than the maximum probability in the previous stage, or a leaf node is reached.

模型评估

现在我们有了一个框架来训练模型，这些模型可以预测我们的分层主题分类法中研究集的标签，我们需要一些方法来量化给定模型在现实世界中满足我们的应用需求的程度。一般来说，我们希望评估模型的以下属性:

预测质量:预测与现实同步的程度如何？它们准确吗？对于用户体验来说，不正确的预测至少是合理可接受的吗？重要的是每个局部分类器尽可能准确，以避免由于在树的根节点附近做出不正确的决定而可能发生的错误传播。
性能:训练模型需要多长时间？一个新的观察需要多长时间进行推理，会对用户体验产生负面影响吗？运行模型需要多少内存？

一旦我们有了评估给定模型的质量和性能的方法，我们就可以比较多个候选模型，从而为我们的应用程序确定最佳框架。下面，我们将讨论如何评估层次分类模型的质量和性能的一些细节。

评估预测质量

与假设二元正确/不正确结果的标准多类分类不同，等级分类可以具有不同程度的正确性。比如，把一个被贴上冷战标签的物品归类为微蜂窝生物就比贴上二战标签差多了。标准分类指标如精确度、召回率和 F1 分数，这些都是基于二元结果的假设得出的，并不处理不同程度的正确性。

因此，在这项工作中，我们使用了这些标准指标的层次版本。本质上，精确度和召回率的层次类似物考虑了分类层次中被正确或错误预测的边的数量，而不是基于单个原子标签进行评估(图 4 )。

Figure 4: Hierarchical Classification Quality Metrics: Due to the structured nature of the hierarchical classification problem, standard classification metrics like precision and recall must be extended into hierarchical analogs. Left: Precision is defined as the ratio of the number of correct taxonomy edges predicted by the classifier to the total number of taxonomy edges predicted by the classifier. Right: Recall is defined as the ratio of the number of correct taxonomy edges predicted to the actual number of edges. A Hierarchical F1 score can be calculated as the harmonic mean of hierarchical precision and recall.

不是所有的人都会同意某一特定物品的确切标签。有人称之为艺术史，另一个人可能称之为艺术欣赏。这些主观偏见反映在我们的测试数据集中分配的标签中，并可能会对侧重于标签预测的评估指标产生偏见。因此，除了测量不同标签正确性的分级分类度量标准(图 4 )之外，我们还试图评估预测的语义准确性。为了捕捉语义准确性，我们计算给定项目的实际和预测主题的嵌入向量之间的余弦相似性。

评估绩效

除了质量，我们还关心我们的应用程序所采用的任何 ML 模型的性能。因此，我们还测量给定模型的训练和评估时间。当在具有相似质量范围的竞争模型之间进行选择时，这些性能指标通常可以用作“决胜局”。

把所有的放在一起

既然我们有多种方法来评估给定的 ML 模型，我们可以比较各种候选模型的质量和性能，以便为我们的自动标记应用程序确定最佳框架。我们训练了 14 种不同的结构化和非结构化模型架构，使用了之前讨论的各种数据集分区策略(参见图 2 )。体系结构的简要概述如下:

结构化预测模型

decisiontreeclassifiereexclusive:使用独占分区和决策树模型作为每个节点的基本分类器
decisiontreeclassifierrinclusive:与decisiontreeclassifierrexclusive相同，但是使用包含数据分区
GaussianNBExclusive :使用排他分区和朴素贝叶斯模型作为每个节点的基本分类器
高斯非独占:与高斯非独占相同，但使用非独占数据分区
kneighborsclassifier Exclusive:使用独占数据分区和 K-最近邻模型作为每个节点的基本分类器。
kneighborsclassifier Inclusive:与kneighborsclassifier exclusive相同，但是使用包含数据分区
LogisticRegressionExclusive:使用独占数据分区和逻辑回归作为每个节点的基本分类器。
LogisticRegressionExclusive:与LogisticRegressionExclusive相同，但使用包含数据分区

非结构化预测模型

DecisionTreeFlat :使用单个全局决策树分类器
GaussianNBFlat :使用单个全局朴素贝叶斯分类器
kneighborsclassifier flat:使用单个全局 K 近邻分类器
LogisticRegressionFlat :使用单一的全局逻辑回归分类器
RocchioTaxonomyClassifierFlat:使用单个全局 Rocchio 分类器算法
anntaxomyclassifierflat:使用单个全局三层人工神经网络分类器

每个算法都使用相同的学习数据集进行训练和评估。我们使用五重交叉验证和网格搜索来确定每个模型架构的最佳参数。

结果

为了评估每个候选模型架构的标签预测质量，我们计算了测试集中所有观察值的分层 F1 分数。为了说明与分类法中更深层次相关联的分类任务通常更具体且潜在地更困难的概念，我们还对在主题分类法的前六个层次中的每一个层次上标记有类别的观察结果单独分组 F1 分数(图 5 )。

Figure 5, Hierarchical F1 scores for candidate model architectures. In order to account for the notion that classification tasks associated with deeper levels in the taxonomy are more specific, we group the Hierarchical F1 for those testing set observations that are labeled at the specificity of each of the first six levels of the subject taxonomy. Error bars are the standard error estimated across all testing set observations in a group. In general structured prediction with Inclusive data partitioning performs the best, for all local classifier families.

通常，使用包含数据分区的结构化预测的体系结构性能最佳。此外，对本地分类器采用逻辑回归和 K-最近邻算法的模型提供了跨所有分类级别的最高质量的预测。有趣的是，非结构化预测模型提供了令人惊讶的好结果，尤其是对于分类中的较高级别。对于全局朴素贝叶斯模型来说尤其如此。采用独占数据分区的模型通常表现出较差的性能。这大概是由于这样的事实:当与排他和平坦划分策略相比时，排他规则减少了有效的训练集样本大小。

图 6 描绘了为候选模型计算的语义相似性质量度量。类似于在图 5 中绘制的 F1 分数，余弦相似性根据测试集观察结果进行分组，这些观察结果在分类体系的前六个级别中的每一个级别上都标有主题。

Figure 6, Semantic similarity scores for candidate model architectures. The cosine similarity between the actual and predicted subjects classes within a word embedding space is plotted for each model. In order to account for the notion that classification tasks associated with deeper levels in the taxonomy are more specific, we group similarities for observations that are labeled at the specificity of each of the first 6 levels of the subject taxonomy. Error bars are the standard error estimated across all testing set observations in a group.

类似于基于 F1 分数的结果，我们发现具有包容性数据划分的结构化预测模型工作得相当好。然而，非结构化模型，尤其是人工神经网络也提供具有高度语义相似性的预测。

有趣的是，平均语义相似性得分似乎随着分类法的深度而增加。这表明分类模型确实捕捉到了分类法中更深层的细微差别:因为嵌入向量的变化在分类法的更深层次上减少了，所以在更深层次上正确地分类标签平均来说给出了更高的相似性。这些结果还表明，即使主题标签可能没有被完美地预测，预测和实际标签之间的语义相似度通常相当高，表明定性的良好预测。

除了质量，我们还绘制了候选模型的评估时间(图 7 )和试衣时间(图 8 )。由逻辑回归分类器组成的结构化预测模型表现相当好，提供了亚毫秒级的推理时间，同时还提供了高质量的预测(图 4 & 5 )。

Figure 7, Evaluation time for candidate models. Evaluation times range from sub-millisecond to tens of milliseconds. Though the K-nearest neighbor and Naive Bayes algorithms provide good quality predictions (See Figures 5 & 6), they are time-consuming to evaluate. B) Same information as A), but zoomed to evaluation times less than one millisecond.

图 8 显示了所有候选模型的拟合时间。试衣时间从不到一秒到几分钟不等。对于我们的应用程序来说，这些培训持续时间没有一个被认为是特别禁止的。如前所述，因为组成结构化预测模型的局部分类器可以被并行训练，并且因为每个局部分类器正被拟合到训练数据的子集，所以这些结构预测的模型拟合时间通常相当快。

Figure 8, Training times in seconds for candidate models.

一般来说，逻辑回归模型比其他模型族需要更长的训练时间。这是由于用于优化逻辑回归模型参数的迭代定点算法。当使用整个训练集时，计算复杂性尤其明显，就像使用 LogisticRegressionFlat 模型的情况一样，这是迄今为止训练时间最长的模型。

考虑到总体质量和性能指标，我们决定继续部署结构化预测模型，该模型使用包容性数据划分来训练本地逻辑回归分类器。我们发现结果模型提供了预测质量和评估时间的最佳折衷。

部署

一旦我们训练了一个适用于我们的应用程序的 ML 模型，我们需要部署一个生产框架，该框架可以用于对历史集合进行分类或重新分类(在分类法更新的情况下)，以及对新发布或更新的集合进行分类。图 9 显示了我们生产框架的概要。

Figure 9, Overview of data flowing through Quizlet’s production subject classification deployment. All arrows in green indicate steps that are coordinated by Apache Airflow ETL jobs. Blue arrows indicate processes not directly related to the classification computations. Application data for newly published or updated sets are written to the application database (AppDB), which is regularly copied to BigQuery. ETL jobs regularly analyze the application data using BigQuery to identify the newly published or updated sets, extract the content of these sets, and send classification requests to one or more classifier services running on Docker instances. The set subject predictions provided by classifier services are then written to Google Cloud Spanner, which used as a read-only database by the application.

在这个框架中，使用由 Apache Airflow 协调的 ETL 在预定的批次中执行分类(关于 Quizlet 如何使用 Airflow 的更多信息，请查看这个帖子)。在每个 ETL 作业中，已经从应用程序数据库(AppDB)导出到 Google BigQuery 的应用程序数据将被分析，以寻找新发布和更新的数据集。然后使用 BigQuery 提取这些集合的属性，并通过 Google Kubernetes 发送到一个或多个 Docker 容器中运行的分类器服务。每个分类器服务都使用一个先前训练过的产品分类器模型工件的副本，该工件存储在 Google Cloud storage(GCS)中。分类器服务的结果随后被写入一个 Google Cloud Spanner 数据库表的行中，该表被应用程序用作只读数据库。

未来的工作

我们的主题分类系统已经生产了将近一年，我们对目前的结果很满意。也就是说总有改进空间。未来，我们计划从多方面改进我们的系统:

改善学习数据集分层。当前的训练数据集偏向于 Quizlet 平台上内容的底层分布。因此，一些常见主题在训练集中出现过多。我们通过使用数据分区在一定程度上减轻了这种偏差，但只针对结构化预测模型。我们可能会看到，增加更多的观察来解释我们目录中的稀有主题，可能会带来最大的好处。
扩展输入特征空间。当前的输入特征空间相当简单，仅表示关于集合内容的特定类型的信息，即集合的“语义位置”。在我们模型的未来迭代中，我们希望将特征空间扩展到 NLP 中更多的常见特征，以及包括使用无监督学习方法(如潜在狄利克雷分配或分层狄利克雷过程)导出的主题模型特征。
局部分类器的特征修剪。很可能并非输入要素的所有维度都对解决所有局部分类问题有用。如果我们发现一些特性与预测层次结构中的下一条路径无关，那么它们很可能在层次结构中也不再有用。因此，删除这些不相关的功能可以提高性能和质量。
改进分层推理算法。当子节点的预测概率小于逻辑的前一阶段中父节点的预测概率时(或者当到达叶节点时)，我们的推理的当前逻辑停止。比较从两个不同分类器返回的概率是有问题的，并且可能负面影响推理过程的质量。推理过程的未来迭代将试图减轻这些缺点。一种方法是将当前父节点索引作为每个本地分类器的候选目标之一。

感谢

许多击掌称赞 Quizlet 团队的所有成员，他们帮助研究和评估了这里讨论的多种 ML 方法，部署了我们的生产模型，并对这篇文章提供了深思熟虑的评论。我看着你沙恩·穆尼、孙凯伦、温斯顿·黄、乔希·拉伊、丹·克劳利、劳拉·奥本海默、提姆·米勒！

肯德尔等级相关解释。

原文：https://towardsdatascience.com/kendall-rank-correlation-explained-dee01d99c535?source=collection_archive---------3-----------------------

肯德尔秩相关(也称为肯德尔的 tau-b)怎么样？这是什么？我如何开始？我什么时候用肯德尔的 tau-b？嘿，教我你所知道的关于肯德尔等级相关的一切。”——一颗好奇的心。

什么是相关性？

相关性是一种双变量分析，衡量两个变量之间的关联强度和关系方向。就关系的强度而言，相关系数的值在+1 和-1 之间变化。值为 1 表示两个变量之间的完美关联程度。随着相关系数值趋向于 0，两个变量之间的关系将变弱。关系的方向由系数的符号表示；加号表示正相关，减号表示负相关。

通常，在统计学中，我们衡量四种类型的相关性:

皮尔森相关性(参数)
肯德尔等级相关(非参数)
Spearman 相关(非参数)
点双列相关。

肯德尔等级相关

也就是俗称的“肯德尔的τ系数”。Kendall 的 Tau 系数和 Spearman 的等级相关系数基于数据的等级评估统计关联。当您正在处理的数据未能通过一个或多个假设测试时，肯德尔等级相关(非参数)是皮尔森相关(参数)的替代方法。当您的样本量很小并且有许多并列的等级时，这也是 Spearman 相关(非参数)的最佳替代方法。

肯德尔等级相关用于测试按数量排列时数据排序的相似性。其他类型的相关系数使用观察值作为相关的基础，Kendall 的相关系数使用成对的观察值，并基于成对观察值之间的一致和不一致的模式来确定关联的强度。

一致:以相同的方式排序(一致性)，即它们相对于每个变量的顺序相同。例如，如果(x1 < x2)和(y1 < x2)或(x1 > x2)和(y1 > x2)，则一对观察值 X 和 Y 被认为是一致的
不一致:排序不同(不一致)，即数值排列方向相反。例如，如果(x1 < x2)和(y1 > x2)或(x1 > x2)和(y1 < x2)，一对观察值 X 和 Y 被认为是不一致的

肯德尔的τ相关系数通常比斯皮尔曼的ρ相关系数的值小。计算是基于和谐和不和谐的配对。对错误不敏感。样本量越小，p 值越准确。

肯德尔排名相关性答案的问题。

学生的考试成绩(A，B，C…)和花在学习上的时间之间的相关性分类(<2 hours, 2–4 hours, 5–7 hours…)
Customer satisfaction (e.g. Very Satisfied, Somewhat Satisfied, Neutral…) and delivery time (< 30 Minutes, 30 minutes — 1 Hour, 1–2 Hours etc)
我把第三个问题留给了你和宇宙…玩得开心！

假设

在开始使用肯德尔等级相关之前，您需要检查您的数据是否满足假设。这将确保您可以实际使用有效的结果，而不仅仅是显示器上的数字。

这些变量是在顺序或连续标度上测量的。顺序量表通常是衡量非数字概念的标准，如满意度、幸福度和不适度。例如非常满意、有些满意、中性、有些不满意、非常不满意。连续秤本质上是区间(即温度如 30 度)或者比例变量(如体重、身高)。
理想的如果您的数据似乎遵循单调关系。简单来说，随着一个变量的值增加，另一个变量也增加，并且随着一个变量的值增加，另一个变量减少。原因如下:肯德尔的等级相关性衡量两个变量之间存在的关联的强度和方向(确定是否存在单调关系)。知道了这一点，测试单调关系的存在是有意义的。但是，就像我说的，这是可取的。

Monotonic vs Non-Monotonic Relationship

就这样！又短又甜！你可以走了！

您还可以查看:

肯德尔等级相关性— Python
皮尔逊相关系数解释
皮尔逊相关系数- python
我的个人资料了解更多关于数据的信息

开普勒。GL & Jupyter 笔记本:优步开源开普勒的地理空间数据可视化。标距长度

原文：https://towardsdatascience.com/kepler-gl-jupyter-notebooks-geospatial-data-visualization-with-ubers-opensource-kepler-gl-b1c2423d066f?source=collection_archive---------0-----------------------

在 Jupyter 笔记本中绘制地理空间数据&轻松地与开普勒的用户界面交互以调整可视化。

kepler.gl for Jupyter 是一款优秀的大地理空间数据可视化工具。将世界一流的可视化工具、易于使用的用户界面(UI)以及 python 和 Jupyter 笔记本的灵活性结合起来(下面是 3D 可视化 GIF，文章中有更多内容)。

3D building footprints

kepler.gl 是基于网络的大型地理空间数据集可视化工具，构建在 deck.gl 之上。优步去年将其开源，其功能令人印象深刻。您可以轻松地拖放您的数据集，并在 web 上立即调整它，以便轻松地可视化大规模地理空间数据集。看看下面这张展示开普勒网络应用的 GIF。

Kepler.gl Source

我喜欢在 Jupyter 笔记本中工作，Kepler.gl 的相同功能在 Jupyter 笔记本环境中也是可用的。在本教程中，我将重点介绍如何在笔记本中集成 kepler.gl for Jupyter 可视化工具。

使用开普勒 Jupyter 笔记本的优点是，你既可以获得作为开普勒伟大的可视化工具的 Jupyter 笔记本的灵活性。

在 Kelpler Jupyter 笔记本中显示数据

我们在本教程中使用的数据集来自纽约开放数据门户。都是 2018 年纽约报道的事件。

import pandas as pd
from keplergl import KeplerGl
import geopandas as gpddf = gpd.read_file("NYPD_complaints_2018.csv")
df.head()

数据集的前几行如下。事件数据、类别和事件发生地的坐标是该数据集中可用的列。

要使用开普勒绘制数据，首先需要创建一张地图。让我们只用一行代码就能做到。

#Create a basemap 
map = KeplerGl(height=600, width=800)#show the map
map

笔记本中会出现带有深色底图的默认地图。如果你愿意，你可以很容易地改变它。

Empty base map

现在，让我们将数据添加到地图中。将数据直接添加到 Kepler.gl 的最简单方法是将其转换为地理数据框架，我们可以使用 Geopandas 快速完成此操作。

# Create a gepdataframe
gdf = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(df.Longitude, df.Latitude))# Add data to Kepler
map.add_data(data=gdf, name=”crimes”)

我们将数据添加到我们创建的第一个地图中(您可以再次调用 map 来显示在下面的单元格中，但这不是必需的)。这些点出现在上面创建的底图的顶部。

Points plotted in Kepler Jupyter

地图点多，乱。让我们做一些调整。

UI:在 Jupyter 笔记本中调整和交互地图

下面是有趣的部分，你可以用开普勒的用户界面轻松地调整可视化的类型、颜色和大小。让我们改变地图的颜色和大小(见下面的 GIF 图)。

Kepler.gl Jupyter notebook User Interface

上面我们只展示了一种可视化的方式，这通常取决于手边的数据集。不过，以下是 Kepler.gl 现在提供的功能(见下图)。您可以将您的数据可视化为点、六边形、热图、弧形或带有线数据的线，以及具有 3D 可用性的建筑物可视化。

Kepler visualisation types. Source

让我们来看看更多的数据可视化(见 GIF 下面的六边形可视化)。开普勒自动计算每个六边形并将其可视化。请从下面的地图中查看周边地区如何减少事故。

Kepler.gl Jupyter notebook 中的另一个很棒的工具是内置的时间序列动画。

Time-series animation

处理您的数据，可视化，永远不要离开 Jupyter 笔记本

它的美妙之处在于，你不用离开 Jupyter 笔记本就能获得开普勒的功能。假设我们对将数据聚合到社区中感兴趣。我下载了邻域文件并执行了一个简单的空间连接来计算每个邻域内有多少个事件。

我创建了一个函数来实现这一功能:空间连接、分组，然后返回地理数据框架。

def count_incidents_neighborhood(data, neighb):
 # spatial join and group by to get count of incidents in each poneighbourhood 
 joined = gpd.sjoin(gdf, neighb, op=”within”)
 grouped = joined.groupby(‘ntaname’).size()
 df = grouped.to_frame().reset_index()
 df.columns = [‘ntaname’, ‘count’]
 merged = Neighborhood.merge(df, on=’ntaname’, how=’outer’)
 merged[‘count’].fillna(0,inplace=True)
 merged[‘count’] = merged[‘count’].astype(int)
 return mergedmerged_gdf = count_incidents_neighborhood(gdf, Neighborhood)

一旦我们有了想要绘制的数据，我们就可以创建开普勒地图。让我们在一个单独的地图中这样做；我们称之为地图 2。我们添加刚刚创建的数据来可视化它。

map2 = KeplerGl(height=600, width=800)
# Add data to Kepler
map2.add_data(data=merged_gdf, name=”NeighborhoodCrimes”)
map2

这是最初的地图，你可以如何调整它。

Polygon visualisation

三维可视化

开普勒也有方便的三维可视化。这是一个使用旧金山开放数据构建足迹的示例。

装置

要安装 Keplergl Jupyter notebook，只需在终端上运行这三行代码。

pip install ipywidgets
pip install keplergl
jupyter nbextension install --py --sys-prefix keplergl

结论

我们已经介绍了 Kepler.gl Jupyter notebook 可视化地理空间数据的一些用例。我发现这个工具非常有用，因为它在 Jupyter notebook 中提供了令人印象深刻的功能。尝试一下，让我知道你是否尝试过。

开普勒& QGIS:开源地理空间工具浅析

原文：https://towardsdatascience.com/kepler-qgis-a-brief-analysis-of-the-open-source-geospatial-tools-5b6308bb5c95?source=collection_archive---------17-----------------------

了解它们是如何工作的，它们的特点是什么，以及我们为什么需要一个新工具

Earthquakes in California, 2000 to 2018, kepler.gl

先说为什么。

为什么我们需要地理空间分析？为什么现在比以往任何时候都重要？

人类大脑主要基于时间、日期和地点来识别信息。例如，“记得我们昨天在剧院见过吗？”或者“你现在在哪里？”其次是“我在大学”。

借助今天的技术——手机、全球定位系统、社交媒体等等——人们可以收集他们周围甚至全球发生的几乎任何事件的地理参考(时间和地点)数据。

地理空间分析正在利用这些数据构建地图、统计图、统计数据和图表，以显示变化是如何发生的以及具体发生在哪里。大规模呈现数据可以揭示我们周围正在发生的重大转变，例如气候变化。地理空间分析的应用包括但不限于供需匹配、气候变化建模、地理营销、更好的 ETA 估计和人口预测。

如今，公司大多使用像 Kepler.gl 和 QGIS 这样的开源工具。虽然这些工具确实适用于地理空间分析的某些方面，但它们需要在其他方面发挥作用。让我们更详细地探讨一下。

开普勒

开普勒是一个基于网络的平台，用于可视化大规模位置数据。它是由优步大学的可视化团队创建的，其使命是创建行业级开源框架来增强大数据。有四种主要套装可供使用——Deck、Luma、React map 和 React vis——来制作漂亮的数据驱动地图。开普勒用 deck.gl 打造，利用 WebGL (一种 JavaScript API)更快更高效地渲染大数据。

开普勒仅仅是一个可视化工具。但就像机器人一样，它非常擅长高效地完成特定的工作。它采用 CSV、JSON 和 geoJSON 文件。开普勒的基本流程是，在本地机器上对数据库执行一些操作，如果不在本地机器上，就下载并在开普勒上绘制。

New York taxi rides via Kepler.gl

Layers available

为了使这些可视化更丰富，它提供了几个层，你可以从中选择，这是非常容易的。例如，要使用点图层，您必须从数据中选择纬度和经度列，瞧！不仅如此，你还可以在一层之上添加多层。是不是很酷？

除此之外，您还可以添加过滤器(时间、日期或大小)、选择颜色、设置不透明度、为地图上的点设置轮廓，以及选择查看内置的地图图层，如土地、道路、水和 3D 建筑物。它也有一个比较视图，您可以启用和可视化两个地图并排。

然而…

地理空间分析不仅仅是美丽的可视化。正如我之前所说，开普勒目前只提供可视化。一个完整的地理空间分析工具中应该有的许多重要功能都缺失了。其中一些是:

您总是不得不手动添加数据文件(电子表格或 geoJSON ),并且无法做出任何实时决策。
空间操作是地理空间分析工具的一个重要方面，如合并、连接和聚类在 Kepler 中不可用。不仅合并和连接，而且更简单的计算都必须在外部完成，然后放入 CS 系统。
在开普勒，添加不同种类的地图是不可能得到更多的背景。
目前，他们提供了自己的一套颜色供你选择，对我来说，这是一个挫折。不可否认，他们有很多选择，但是我喜欢在我的想象中选择我想要的颜色

但是等一下…

2019 年开普勒发展路线图承诺了许多新功能，包括高级图层，空间操作和自定义色标。获取完整列表并在此更新。

QGIS

QGIS 是一个完全开源的桌面软件，由社区维护。安装和使用 QGIS 的成本为零，但这是一个挑战，除非你以前做过，尤其是如果你有其他软件的冲突包。如果你熟悉编程，你甚至可以自己添加功能。它消耗几乎所有类型的数据(超过 70 种矢量格式)。它是跨平台的，可以在所有三种主要的操作系统 Windows、Mac 和 Linux 上使用。

QGIS 就像地理空间世界的excel。从创建地图、执行空间操作到使用 QGIS 数据库，您几乎可以做任何事情。它可以用于非常大的项目，从开始到结束的一切，如果你有一个 GIS 项目，没有其他类型的数据。它提供了一些插件，可以为你的项目增加一颗额外的星星，其中一些是，

QuickOSM 允许下载 OpenStreetMap 数据
QuickOSM 查询引擎—帮助您从 QuickOSM 插件下载特定数据
数据绘图—允许创建矢量数据的 D3 图

然而…

QGIS 是迄今为止最丰富和最有用的地理空间分析工具。然而，就像其他工具一样，它也有自己的局限性。而且我们在现场相信，不仅仅是工具，地理空间数据本身也充满了挑战。

安装和管理 QGIS 是非常不同的，除非你已经这样做了，特别是如果你从其他软件的冲突包。QGIS 难以处理大数据，并且没有真正提供对流数据的支持。在流数据上执行地理空间查询变得非常计算密集型，而我们没有支持它的工具。虽然有时，开发人员会创建他们自己的内部工具集，但这些工具并不适合全球使用，因为它们专注于他们正在执行的特定任务。

此外，当连接到数据库时，它工作得很好，但它是一个桌面应用程序，而不是在云上。此外，如果一个商业人士想使用 QGIS，它不是很直观，因为它需要空间数据知识。该分析不能与任何人共享，不能使用企业规模和更现代的聚合方法，如地理哈希或六边形网格。要知道这些是什么意思，请参考这篇文章。

Locale.ai

那么什么是 Locale，我们为什么要建立它呢？

一切都始于一个个人问题。作为处理地理空间数据的数据科学家，现有的分析产品在我们的日常工作流程中毫无用处。因此，我们必须为我们的日常工作流程构建自己的工具和库。

在这样做的时候，我们意识到不仅仅是我们。谈到位置数据，全球各地的数据科学家都面临着类似的问题。因此，企业正在努力提高运营效率。在现场，我们计划一劳永逸地解决这个问题。

我们正在努力使位置分析成为整个分析生态系统的一部分。因为当然，位置智能不仅仅是在地图上跟踪和标绘点。您可以混合搭配空间和非空间数据库，并回答您的所有问题。我们的目标是让商业用户在不依赖开发者的情况下获得空间洞察力。

位置情报不仅仅是在地图上追踪和标绘点。

借助我们的平台，您可以大规模传输空间数据，这意味着所有这些都是在大规模、实时和非常精细的级别上进行的。我们还添加了一个拖放界面，为业务用户(不知道如何编写复杂的空间查询)编写复杂的查询，以获得他们问题的答案。您可以使用 Locale 的平台轻松定制您的空间模型。

Locale 在一个地方提供团队专用的控制台。它有警报和触发器，以防有任何异常值，如果您想将数据导出到您的系统中，它还提供 API。

如果你对这个问题有共鸣，想投稿，我们 招聘 不同角色。如果你想深入研究，请查看我们的 网站 或通过hello @ locale . ai联系我们！

原载于 2019 年 9 月 18 日 现场。

电话培训通知的 Keras 回拨

原文：https://towardsdatascience.com/keras-callback-for-training-notifications-on-phone-870c3c399a32?source=collection_archive---------32-----------------------

创建一个简单的 Keras 回调，将培训进度作为通知发送到您的手机。

Photo by Jonah Pettrich on Unsplash

训练神经网络通常需要几个小时甚至几天才能完成，当您无法监控训练进度时，这可能会令人沮丧。这个想法很简单，很容易实现一个回调来发送通知到你想要的应用程序。

为了发送通知，我使用了一个名为 Notifiers 的 python 库。它支持大多数流行的应用程序，如:

容易做的事情
推杆
简单推送
松弛的
谷歌邮箱
电报
特维利奥

还有很多。看文档这里。

在这个介绍中，我将使用 PushBullet。所有的服务都差不多。从所需的服务获取一个 API 令牌，并在身份验证中使用它。

你完了！！

谢谢你。

学习如何执行 Twitter 情绪分析

原文：https://towardsdatascience.com/keras-challenges-the-avengers-541346acb804?source=collection_archive---------6-----------------------

Keras 挑战复仇者联盟

情感分析，也称为意见挖掘，是自然语言处理中的一个有用工具，它允许我们识别、量化和研究主观信息。由于每天都会产生数十亿字节的数据，这种技术使我们有可能提取这些数据的属性，例如关于某个主题的负面或正面意见，以及关于正在谈论的主题和表达该意见的个人或实体的特征的信息。

Twitter 越来越受欢迎，如今，人们每天都在使用它来表达对不同话题的看法，如产品、电影、音乐、政治家、事件、社会事件等。每年都有很多电影上映，但如果你像我一样是漫威的粉丝，你可能会迫不及待地想最终观看新的《复仇者联盟》电影。就我个人而言，我想知道人们对此的感受。

在之前的中，我们已经讨论了如何使用 Twitter API 来传输推文，并将其存储在关系数据库中。现在，我们将使用这些信息来执行情感分析。但在此之前，我们应该考虑一些事情。首先，我们使用“复仇者”这个词来发布推文，但没有任何额外的考虑。很有可能我们有成千上万条重复的推文。就情感分析而言，处理它们不会增加任何额外的价值，相反，它将是计算上昂贵的。因此，我们需要访问数据库，删除重复的推文，保留第一个事件。第二，我们有一个未标记的数据库。为了让模型在训练期间学习，我们应该声明推文是正面的还是负面的。理想的解决方案是手动标注数据集，这非常准确，但需要大量时间。然而，有几个选择比如使用开源数据集标记工具，比如 斯坦福 CoreNLP 。

有许多框架可以用于机器学习任务，但是，我们将使用Keras，因为它提供了一致而简单的 API，最大限度地减少了所需的用户操作数量，更重要的是，它易于学习和使用。我们还将利用 自然语言工具包 (NLTK)，它提供了许多语料库和词汇资源，这些资源将方便地用于标记、解析和语义推理，以及Scikit-learn，它为数据挖掘和数据分析提供了有用的工具。

准备好开始了吗？让我们看看 Keras 能从《复仇者联盟》中学到什么。

首先，我们需要检索之前存储在 PostgreSQL 数据库中的 tweets。为此，我们将利用[sqlalchemy](https://www.sqlalchemy.org/)，这是一个 Python SQL 工具包和对象关系映射器，允许我们以一种简单的方式连接和查询数据库。sqlalchemy 的一个特点是包含了最常见数据库的方言(它用来与数据库通信的系统)实现，比如 MySQL、SQLite 和 PostgreSQL 等等。我们将使用create_engine()函数，该函数基于给定的数据库 URL 生成一个引擎对象，其典型形式如下:dialect+driver://username:password**@host**:port/database。在我们的例子中，方言是 PostgreSQL，而驱动程序是 psycopg2。创建引擎对象后，我们将使用来自pandas模块的函数read_sql_query来查询数据库，以获取存储在我们的tweet 表中的所有数据(‘select * from tweet _ table’)并收集在DataFrame中检索的信息:

在我们深入分析“复仇者联盟”的公众意见之前，我们需要采取一个重要步骤:预处理推文文本。但这意味着什么呢？文本预处理包括遵循一组常用的简单规则的基本文本清理，但也包括考虑语法和词汇信息的高级技术。在我们的项目中，我们将执行以下步骤:

使用 **.lower()** 函数将推文转换成小写，以使所有推文保持一致的形式。通过这样做，我们可以确保进一步的转换和分类任务不会受到数据中不一致或大小写敏感问题的影响。
删除 **‘RT’**、用户提及和链接:*在 tweet 文本中，我们通常可以看到每一句都包含一个引用，它是一个转发(' RT ')、一个用户提及或一个 URL。因为它通过许多推文被重复，并且它没有给我们任何关于情绪的有用信息，我们可以删除它们。*
删除数字:同样，数字不包含任何情绪，因此从 tweet 文本中删除它们也是常见的做法。
删除标点符号和特殊字符:因为这会生成高频率的标记，从而影响我们的分析，所以删除它们很重要。
替换拉长的单词:拉长的单词定义为包含两次以上重复字符的单词，例如‘awesooome’。替换这些单词非常重要，因为分类器会将它们视为与源单词不同的单词，从而降低它们的频率。但是，有一些英语单词包含重复的字符，主要是辅音，所以我们将使用 NLTK 中的 wordnet 来与英语词典进行比较。
移除停用词:停用词是在所有推文中出现频率很高的功能词。没有必要分析它们，因为它们没有提供有用的信息。我们可以从 NLTK stopwords 函数中获得这些单词的列表。
用反义词处理否定 : 分析情绪时出现的一个问题就是处理否定及其对后续词语的影响。让我们举一个例子:假设我们找到了推文“我不喜欢这部电影”,我们丢弃了停用词，我们将去掉“我”和“没有”的词。所以最后，我们将得到“喜欢”和“电影”的标记，这与原始推文的意思相反。有几种处理否定的方法，并且有很多关于这个的研究正在进行；然而，对于这个项目，特别是，我们将扫描我们的推文，并用我们的否定词后面的名词、动词或形容词的反义词(我们将从 wordnet 的词条中获得)来替换。

在我们清理了数据之后，但在我们开始构建情绪分析模型之前，我们可以进行探索性的数据分析，看看在我们的“复仇者联盟”推文中出现最频繁的词是什么。对于这一部分，我们将展示关于被标记为正面的推文和被标记为负面的推文的图表。

首先，我们将使用 WordCloud 来表示所有推文中的单词使用情况，根据每个单词的频率按比例调整其大小。尽管出于不同的原因，这个图表似乎不是最合适的，但它提供了一个文本分析和一个关于哪种类型的词在我们的推文中出现得更频繁的总体想法。Python 有一个[WordCloud](http://amueller.github.io/word_cloud/)库，允许我们使用从硬盘上传的图像应用遮罩，选择背景、单词颜色图、最大字数、字体大小以及图形的其他特征。

正面推文的 WordCloud:

负面推文的 WordCloud:

当我们观察正面推文的词云时，一些以较大尺寸出现的词没有特定的内涵，可以被解释为中性的，如“惊奇队长”、“无限战争”。另一方面，其他单词，即使有些较小，也可以被解释为在推文中具有积极的意义，如“好”、“很好”、“最好”和“喜欢”。相反，负面推文的 WordCloud 显示的大多是中性词，如“电影”、“残局”和带有负面内涵的非常小的词，如“从不”和“操”。

之后，我们可以在一张图表中列出正面和负面推文中与“复仇者联盟”词语共现的 50 个最频繁的词。我们将从使用来自sklearn的函数CountVectorizer开始，该函数将把 tweets 的集合转换成令牌计数的矩阵，产生计数的稀疏表示。然后，我们对每个令牌的所有计数求和，获得频率，并将它们存储为数据帧。

我们现在可以通过使用matplotlib函数bar在柱状图中绘制这些值。

我们可以看到，正面和负面推文中的第一个常用词是:“漫威”、“残局”，此外，除了正面推文中的“好”、“太棒了”、“爱”、“最喜欢”和“最好”等词之外，大多数词都有中性的含义。

我们最终可以检查在正面和负面推文中出现的单词的频率之间是否有任何相关性。我们将连接两个词频数据帧，之后，我们将使用 seaborn regplot图:

除了一两点看起来相关之外，从上面的图表中无法得出正面和负面推文中出现的单词之间有任何有意义的联系。

在可视化我们的数据之后，下一步是将数据集分成训练集和测试集。为此，我们将利用sklearn包的train_test_split功能。我们将按照 20–80%规则抽取 20%的数据集进行测试。剩下的 80%用于训练集，我们将保留一部分用于验证我们的模型。

我们还需要将我们的情感列转换成我们的模型可以理解的类别。我们将使用 0 代表负面，1 代表中性，2 代表正面。

最后，我们需要使用TfidfVectorizer 处理我们的输入 tweet 列，这将把 tweet 的集合转换成一个术语频率/反转文档频率(TF-IDF)特征矩阵。这个函数非常关键的一点是，它将返回归一化的频率；特征归一化是构建机器学习算法的关键步骤。经过几次尝试，3500 是返回的最大特征数，它最适合我们的模型。

现在，是时候建立我们的模型了:一个神经网络。如果不熟悉神经网络的工作原理，可以查看我之前的帖子。幸运的是，Keras 使构建神经网络变得非常简单和容易，只需几行代码。

让我们来剖析一下我们的模型:Sequential()是一种由层组成的网络，这些层按照给出的顺序堆叠和执行。那么，我们有哪种类型的层？我们注意到，我们已经为我们的三个层(输入、隐藏和输出层)添加了Dense层，这意味着一个层中的每个节点都接收来自前一层中所有节点的输入，实现了以下操作:[output = activation(dot(input, weights) + bias)](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense)。在它们之间，我们使用了Dropout方法，该方法采用一个介于 0 和 1 之间的浮点数(我们将把它作为drop传递，稍后再进行调整),表示在训练期间将被随机丢弃的神经元部分，以防止过度拟合。关键层是输入层和输出层，因为它们将决定我们网络的形状，正确了解我们的期望是很重要的。因为我们将使用3500作为矢量化过程中返回的maximum features，所以我们需要使用这个确切的数字作为输入形状的大小。我们还将包括第一层将产生多少输出(作为layer1传递)，稍后我们将修改该参数，以便使该层更简单或更复杂。在这种情况下，我们将选择relu作为我们的激活函数，它比其他函数有几个好处，比如减少消失梯度的可能性。对于最后一层，我们将选择对应于三个不同输出的三个节点，因为我们想要获得分类分布，我们将使用softmax作为激活函数。对于隐藏层，我们也将大小作为layer2 传递，它通常是layer1的一半，因为这是一个分类问题，我们将使用sigmoid激活(如果你想知道更多关于使用哪个激活函数，检查这个视频)。

之后，应该说明要使用的优化器及其参数。我们将使用具有固定衰减和β的 AdamOptimizer，但稍后我们将调整学习速率和ε值。 Adam 是一种随机优化，它具有几个优点，例如实现简单、计算效率高、内存需求小、对梯度的对角线重定标不变，以及非常适合于数据和/或参数较大的问题。

训练前的最后步骤之一是编译网络，澄清我们想要的损失。在这种情况下，我们将使用sparse_categorical_crossentropy,因为我们将类别表示为数字。我们还需要澄清优化器，以及要评估的指标(对我们来说，就是准确性)。此外，我们需要拟合模型，说明 X 和 Y 值的集合、batch size(通过网络传播的样本数量)、epochs(我们将扫描所有数据的次数，我们还将调整的参数)、validation split(将保存哪个百分比以验证我们的结果)，以及我们是否每次都以相同的方式呈现数据，或者，我们将对其进行洗牌(shuffle)。

在尝试了dropout、features、shuffle、learning rate、 layer size、epsilon、validation_split、epochs几个参数后，我们最终得出了以下模型:

我们可以看到，我们的最终验证准确度从时段 1 的 71.91 提高到时段 5 的 76.54%。此外，增加，甚至更多，纪元提高了训练精度，但降低了验证精度。

尽管我们总是希望有更高的准确性，但我们现在可以继续尝试在我们创建的新数据集中识别观点，就像我们用于训练和验证的数据集一样。

为此，我们将查询我们的新数据库，执行相同的文本预处理步骤，对我们的推文进行标记，并使用我们训练的模型使用model.predict()预测对“复仇者联盟”的情绪。如果我们想让人类更容易阅读，我们可以将数字预测转换为我们的分类标签‘正、中和、负’。

现在是真相大白的时候了！我们可以使用饼图来绘制每个情感类别中包含了多少条推文:

正如你所看到的，53.1%的推文对“复仇者联盟”有正面的含义，而剩下的 46.9%是中性的或有负面的含义。如果我在推特上谈论这个话题，我应该被列入积极的一面，或者至少我可以有 76%的信心我会。你呢？

接下来，我们将通过 NetworkX 使用 Tweets 信息来可视化 Twitter 上的用户交互。

如果你想了解这个项目的全部代码，请查看我的 GitHub 库 。

MNIST 数据集的 Keras 自定义数据生成器示例

原文：https://towardsdatascience.com/keras-custom-data-generators-example-with-mnist-dataset-2a7a2d2b0360?source=collection_archive---------14-----------------------

Photo by Carlos Muza on Unsplash

通常，在现实世界的问题中，用于训练我们模型的数据集占用的内存比我们在 RAM 中的要多得多。问题是我们不能将整个数据集加载到内存中，并使用标准的 keras fit 方法来训练我们的模型。

解决这个问题的一种方法是只把一批数据装入内存，然后把它输入网络。重复这个过程，直到我们用所有数据集训练了网络。然后我们打乱所有的数据集，重新开始。

为了制作自定义生成器，keras 为我们提供了一个序列类。这个类是抽象的，我们可以创建继承它的类。

我们将编码一个自定义数据生成器，该生成器将用于生成 MNIST 数据集的批量样本。

首先，我们将导入 python 库:

**import** tensorflow **as** tf
**import** os
**import** tensorflow.keras **as** keras
**from** tensorflow.keras.models **import** Sequential
**from** tensorflow.keras.layers **import** Dense, Dropout, Flatten
**from** tensorflow.keras.layers **import** Conv2D, MaxPooling2D
**import** numpy **as** np
**import** math

然后，我们将 MNIST 数据集加载到 RAM 内存中:

mnist = tf.keras.datasets.mnist(x_train, y_train), (x_test, y_test) = mnist.load_data()

MNIST 数据集由 60000 幅手写数字训练图像和 10000 幅测试图像组成。

每个图像尺寸为 28×28 像素。你应该考虑到，为了训练模型，我们必须将 uint8 数据转换为 float32。float 32 中的每个像素需要 4 字节的内存。

因此，整个数据集需要:

每像素 4 字节* (28 * 28)每图像像素* 70000 个图像+ (70000*10)个标签。

总共 220 Mb 的内存完全可以放在 RAM 内存中，但在现实世界的问题中，我们可能需要更多的内存。

我们的生成器模拟生成器将从 RAM 中加载图像，但在实际问题中，它们将从硬盘中加载。

class **DataGenerator**(tf.compat.v2.keras.utils.Sequence):

    def **__init__**(self, X_data , y_data, batch_size, dim, n_classes,
                 to_fit, shuffle = True): self.batch_size = batch_size
        self.X_data = X_data
        self.labels = y_data
        self.y_data = y_data
        self.to_fit = to_fit
        self.n_classes = n_classes
        self.dim = dim
        self.shuffle = shuffle
        self.n = 0
        self.list_IDs = np.arange(len(self.X_data))
        self.on_epoch_end() def **__next__**(self):
        # Get one batch of data
        data = self.__getitem__(self.n)
        # Batch index
        self.n += 1

        # If we have processed the entire dataset then
        if self.n >= self.__len__():
            self.on_epoch_end
            self.n = 0

        **return** data def **__len__**(self):
        # Return the number of batches of the dataset
        **return** math.ceil(len(self.indexes)/self.batch_size) def **__getitem__**(self, index):
        # Generate indexes of the batch
        indexes = self.indexes[index*self.batch_size:
            (index+1)*self.batch_size] # Find list of IDs
        list_IDs_temp = [self.list_IDs[k] for k in indexes]

        X = self._generate_x(list_IDs_temp)

        if self.to_fit:
            y = self._generate_y(list_IDs_temp)
            **return** X, y
        else:
            **return** X def **on_epoch_end**(self):

        self.indexes = np.arange(len(self.X_data))

        if self.shuffle: 
            np.random.shuffle(self.indexes) def **_generate_x**(self, list_IDs_temp):

        X = np.empty((self.batch_size, *self.dim))

        for i, ID in enumerate(list_IDs_temp):

            X[i,] = self.X_data[ID]

            # Normalize data
            X = (X/255).astype('float32')

        **return** X[:,:,:, np.newaxis] def **_generate_y**(self, list_IDs_temp):

        y = np.empty(self.batch_size)

        for i, ID in enumerate(list_IDs_temp):

            y[i] = self.y_data[ID]

        **return** keras.utils.to_categorical(
                y,num_classes=self.n_classes)

然后我们要建立分类网络:

n_classes = 10
input_shape = (28, 28)model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation='relu',
                 input_shape=(28, 28 , 1)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(n_classes, activation='softmax'))model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adadelta(),
              metrics=['accuracy'])

下一步是制作我们的生成器的一个实例:

train_generator = DataGenerator(x_train, y_train, batch_size = 64,
                                dim = input_shape,
                                n_classes=10, 
                                to_fit=True, shuffle=True)val_generator =  DataGenerator(x_test, y_test, batch_size=64, 
                               dim = input_shape, 
                               n_classes= n_classes, 
                               to_fit=True, shuffle=True)

如果我们想检查生成器是否正常工作，我们可以调用产生一批样本和标签的 next() 方法。然后检查图像和标签的数据类型是否正确，检查批次的尺寸等…

images, labels = next(train_generator)
print(images.shape)
print(labels.shape)

如果我们希望在一个时期内将整个数据集输入网络:

steps_per_epoch = len(train_generator)
validation_steps = len(val_generator)

最后，我们将使用 keras 函数 fit_generator()来训练网络。

model.fit_generator(
        train_generator,
        steps_per_epoch=steps_per_epoch,
        epochs=10,
        validation_data=val_generator,
        validation_steps=validation_steps)

感谢阅读这篇文章。希望你觉得有用。

Keras 定制训练循环

原文：https://towardsdatascience.com/keras-custom-training-loop-59ce779d60fb?source=collection_archive---------11-----------------------

Amazing photo by Dan Meyers on Unsplash

如何在 Keras 引擎的底层构建一个定制的训练循环，K.function，opt.get_updates 用法和其他东西

在所有其他深度学习库中，Keras 是一个高水平的库，我们都很喜欢它。它抽象了我们同样钟爱的 Tensorflow 在 GPU 上非常高效地处理数据带来的大部分痛苦。

我在工作和个人项目中使用 Keras，我非常喜欢它的 API 和建模方法。但是，当您想要做一些开箱即用的事情时，会发生什么呢？我告诉你，你偶然发现了这个框架。哪个框架？Keras 范式的框架。在 Keras 中，事情是简单而实用的，你按照步骤去做，事情就会惊人地好。但是，如果出于某种原因，你需要跳过或绕过主要路线，事情就会变得混乱。

你可能会说:“但是 Keras 非常灵活，它有这个惊人的功能 API 来构建 daydream 迷宫模型，支持编写自定义层，强大的生成器来处理序列、图像、多处理、多输入输出、GPU 并行和……”，我知道，事实上，我知道你知道，或者至少我期待它，否则，你不会阅读这篇文章。

但是，尽管有这种灵活性，我仍然可以指出 Keras 中一些相当令人讨厌的体验，例如具有多个输入/参数的损失函数，使用自定义层加载保存的模型…但不知何故，您可以通过一些变通方法或深入代码来解决这些问题。

然而，我最纠结的一件事是创建一个定制的训练循环。但是，你为什么要首先建立一个定制的训练循环呢？Keras 的全部意义不就是抽象出这样的细微差别，以便您可以专注于模型吗？嗯，这是非常正确的，但也有一些你想亲自动手的情况:当你的模型有不同形状的多个输入和输出(不可连接)以及一个独特的损失函数时，当你需要在训练时访问优化的梯度时…或者如果你想要特定的应用:就我而言主要是 GANs 和强化学习(如果你发现其他的，请在评论中告诉我，这样我也可以学习)。写这篇文章的主要原因是澄清(或者如果你喜欢的话，用文档记录)Keras 引擎中某些工具的用法，以构建一个定制的训练循环，而不严格受限于框架。

所以，无聊的够了，给我看看代码！

代码

在这里，所以你可以看看:

你可以把它分成几部分:

数据集创建:我们示例中的虚拟数据集。
Keras 默认工作流程:包括模型、损失函数和优化器定义。
图形创建:创建计算图形并链接其所有部分。此部分不同于默认的 Keras 工作流，因为它是由 Keras 引擎在幕后完成的。
K.function用法:这是棘手的部分，K.function它没有被很好地记录，所以我会试着说明这个问题。
训练循环:这里没有什么特别的，只有 for 循环和一些监控训练(当然还有测试)进展的打印。

资料组

我们案例中的虚拟数据集。给定[0，9]范围内的两个数，网络必须预测这两个数的和。所以:

样本= [ 100 x 2 ]，因此 100 个样本包含两个特征(这两个数字相加)
Targets = [ 100 ]，这 100 个样本相加的结果，理想情况下，我希望它是[ 100 x 1 ]，但我们都熟悉 Numpy 在降维时的工作方式。

还创建了一个包含 10 个样本的小型测试数据集。

# Training samples
samples = np.random.randint(0, 9, size=(100,2))                       targets = np.sum(samples, axis=-1)# Samples for testing                       
samples_test = np.random.randint(0, 9, size=(10,2))                       targets_test = np.sum(samples_test, axis=-1)

Keras 工作流程

你已经知道了这一点，所以:

# Model
x = Input(shape=[2])
y = Dense(units=1)(x)
model = Model(x, y)

# Loss                       
def loss_fn(y_true, y_pred):                           
    # You can get all the crazy and twisted you
    # want here no Keras restrictions this time :)
    loss_value = K.sum(K.pow((y_true - y_pred), 2))
    return loss_value # Optimizer to run the gradients                       
optimizer = Adam(lr=1e-4)

这里唯一的事情是，你可以让损失函数变得疯狂和扭曲，因为 Keras 引擎不会用它的_standarize_user_data ( 链接)阻止你，也不会抱怨。你可以有多个输入，可配置的参数损失函数…我为这个演示实现了一个简单的误差平方和(SSE)。

图形创建和链接

这是棘手的部分。在 Keras 中，您定义的唯一图形是您的模型的计算流程(如果您愿意，也可以是损失函数，但有一些限制)。但是您没有定义损失函数、模型和梯度计算或参数更新之间的链接。

这时，我们需要将我们的观点从代码工作流转变为图形工作流，或张量流(喜欢这个笑话吗？).因此，除了定义模型的输入、模型本身和损失函数(我们已经完成了)之外，我们还需要:

为我们的地面实况创建输入，这样我们可以计算损失，即所谓的y_true
得到模型的输出，或者说预测，俗称y_pred
将模型预测和地面实况与损失函数(也已创建)联系起来

y_true = Input(shape=[0])
y_pred = model(x)
loss = loss_fn(y_true, y_pred)

如果你密切注意这一点，你会发现这个图的唯一输入是x和y_true(我知道你猜到了，因为只有分配了Input调用的变量，但是以防万一……)。

因此，我们已经有了输入、模型和要最小化的损失，所有这些都在一个计算图或一个张量流的图中(抱歉，我不能停止它)。

剩下唯一要做的事情是定义用于计算相对于模型权重的损失梯度的图形，并根据学习速率更新那些权重。简单对吗？嗯，这正是optimizer.get_updates所做的。给定一些参数和依赖于这些参数的损失，它返回计算图用于计算梯度(使用臭名昭著的 K.gradients)和更新权重。

optimizer.get_updates返回用于计算梯度和更新权重的计算图，给定一些要优化的参数(权重)和依赖于这些参数的损失

这是通过用我们定义的loss和参数或者模型的可训练权重来调用optimizer.get_updates来优化的。

# Operation fort getting
# gradients and updating weights
updates_op = optimizer.get_updates(
    params=model.trainable_weights,
    loss=loss)

k .函数用法

现在我们已经完成了图表。我们实际上有两张图表:

图表 1:输入= [ x，y_true ]，输出= [ loss]
图表 2:输入= [损失，权重]，输出=[更新的权重]

第一个图对应于网络的正向传递，图 2 对应于反向传递或优化循环。

现在我们有两张图，它们应该可以在 GPU 上非常高效地运行，那么，我们该如何运行它们呢？这就是K.function帮助我们的地方。

K.function(或keras.backend.function为了完整起见)的用法类似于 Tensorflow (这个是合法的)tf.Session用于实例化图形，session.run用于运行它。因此K.function的描述应该是:

K.function返回一个函数，该函数调用计算图的单次迭代或正向传递，如前所述，并通过其作为参数给出的inputs和outputs引用。如果设置了updates关键字，它也运行向后传递，图中描述的操作作为updates关键字的参数传递。

考虑到这一点，我们创建了两个函数来执行前面定义的图形:

train 函数，它的特点是对它的每次调用都有一个向前和一个向后的传递。它被配置为:

train = K.function(
    inputs=[x, y_true],
    outputs=[loss],
    updates=updates_op)

以及测试函数，该函数仅计算前向传递，假定它旨在用于测试而不是用于更新权重。注意没有设置updates关键字。

test = K.function(
    inputs=[x, y_true],
    outputs=[loss])

注意，这两个函数都有一个参数作为输入，它是一个列表。该列表必须包含inputs中指定的输入张量。另一方面，输出将是一个带有在outputs关键字中指定的输出张量的列表。

在我们的例子中，一个呼叫将像这样完成:loss = train([sample, target])，然后损失将是一个列表，所以:loss = loss[0]。但是你可以在代码中查看它的上下文。

训练循环

最后，我们可以设置我们的自定义训练循环。这里没有什么特别的，只是一个默认的训练循环，不过，我会备注一些细节。虽然在代码中你可以看到训练循环和测试循环，但我将只关注前者，你可以把它扩展到后者。

细节决定成败，所以:

这只是一个实现进度条的库，进度条将告知一个时期内训练的进度。
由于我们一次抽取一个样本，batch_size = 1，Numpy 挤压批次维度，但是模型期望一个具有 2 个维度、批次和特征的输入，因此我们需要使用np.expand_dims手动添加批次维度。
该图使用张量，因此我们需要用K.constant将图的输入转换成张量。
已经实施了一个训练损失累加器来计算loss_train_mean中每一步的平均值，该指标在每一时间步打印在进度条上，以监控训练的进展。

train功能的使用值得特别注意。每次调用时，train函数将使用给定的输入在 GPU 上运行图形的单次执行，向前和向后传递。该图将样本和目标作为输入来执行训练步骤，并将张量列表作为输出返回，在我们的示例中，只有一个张量，这是该训练步骤的损失。

检查每个输入张量的维数必须匹配，这是由 Keras 引擎默认完成的，但在这里我们的目标是控制。所以，当我们调用train([sample, target])时，sample必须和x = Input(shape=[2])有相同的维数，so ^ 2，批量和特征维数，target必须和y_true = Input(shape=[0])有相同的维数，后者是一个零维张量，或者是一个单一的数(标量)。

如果您运行该代码，您会看到类似这样的内容:

Evolution of the training with a slow laptop GPU

其中Training Loss是该时期的训练损失的平均值，而Test Loss是测试数据集的样本的测试损失的平均值。

在一些迭代之后，您可以体会到训练损失和测试损失将如何减少。

其他方法

尽管本指南的目的是展示如何在低抽象层次上使用 Keras，但这并不是一个好的实践或首选方法。为什么？因为 Keras 的高度抽象是精心设计的项目所期望的结果。所以这些工具的使用应该是一个例外，而不是常规，除非你真的想在一个低抽象层次上工作。

但是，如果我想在较低的抽象层次上工作呢？(也许你是一名优化研究人员，正在编写一个新的优化器，或者你正在从事科学计算的代数工作……谁知道呢？)在这种情况下，你可以问自己:如果我真的想控制一切，有没有其他方法来建立训练循环？

嗯，我很高兴你问了这个问题，因为作为一名工程师，我无法在不提出任何其他备选方案的情况下给出一个解决方案。还有另外两个很好的方法来轻松训练你的模型，并且仍然让事情在你的控制之下:

张量层:谷歌的一个被广泛忽视的项目，旨在提供深度学习模型的主要构建模块，而不放弃底层细节。
TensorFlow 2.0 定制训练循环:通过将 Keras 集成到 TensorFlow 2.0 版本中，您可以同时拥有两个世界的优点，即 Keras 的高级构建模块和 TensorFlow 的低级流控制。

因此，如果你真的需要 Tensorflow 的低级 go，如果你只是需要一个适度的抽象级别，请使用 TensorLayer，但如果你像我一样，主要在 Keras 的高级 go 中工作，并使用这些技巧来克服你真的需要它的不寻常的角落情况。

Keras 数据生成器及其使用方法

原文：https://towardsdatascience.com/keras-data-generators-and-how-to-use-them-b69129ed779c?source=collection_archive---------0-----------------------

您可能遇到过这样的情况:您试图加载一个数据集，但是您的计算机没有足够的内存。随着机器学习领域的进步，这个问题变得越来越普遍。今天，这已经是视觉领域中的挑战之一，在视觉领域中，要处理大数据集的图像和视频文件。

在这里，我们将重点讨论如何构建数据生成器，以便在 Keras 中加载和处理图像。

数据生成器的功能是什么

在 Keras 模型类中，有三个方法让我们感兴趣:fit_generator、evaluate_generator 和 predict_generator。这三者都需要数据生成器，但并非所有生成器都是同等创建的。

让我们看看每种方法需要哪种生成器:

拟合 _ 生成器

需要两个生成器，一个用于训练数据，另一个用于验证。幸运的是，它们都应该返回一个元组(输入，目标),并且它们都可以是 Sequence 类的实例。

评估 _ 生成器

这里的数据生成器与 fit_generator 中的要求相同，并且可以与训练生成器相同。

预测生成器

这里的发电机有点不同。它应该只返回输入。

记住这一点，让我们构建一些数据生成器。由于 fit_generator 和 evaluate_generator 中的生成器相似，我们将重点构建 fit_generator 和 predict_generator 的数据生成器。

ImageDataGenerator 类

ImageDataGenerator 类在图像分类中非常有用。有几种方法可以使用这个生成器，取决于我们使用的方法，这里我们将重点介绍 flow_from_directory 取一个路径到包含在子目录中排序的图像和图像增强参数的目录。

让我们看一个例子:

我们将使用可从https://www.kaggle.com/c/dogs-vs-cats/data下载的数据集，其结构如下:

data/
    train/
        dogs/
            dog001.jpg
            dog002.jpg
            ...
        cats/
            cat001.jpg
            cat002.jpg
            ...
    validation/
        dogs/
            dog001.jpg
            dog002.jpg
            ...
        cats/
            cat001.jpg
            cat002.jpg
            ...

首先，让我们导入所有必要的库，并创建一个带有一些图像增强的数据生成器。

最后，创建一个模型并运行 fit_generator 方法。

ImageDataGenerator 是一种为图像分类任务批量加载和扩充图像的简单方法。但是！如果你有一个分段任务呢？为此，我们需要构建一个定制的数据生成器。

灵活的数据生成器

要构建自定义数据生成器，我们需要从 Sequence 类继承。让我们这样做，并添加我们需要的参数。

Sequence 类迫使我们实现两个方法；len 和 getitem。如果我们想让生成器在每个纪元后做一些事情，我们也可以在 _epoch_end 上实现这个方法。

len 方法应该返回每个时期的批数。一种可能的实现如下所示。

如果 shuffle=True，此示例中的 on_epoch_end 可以对训练的索引进行混洗。但是这里可以有任何我们想要在每个纪元后运行的逻辑。

我们必须实现的第二个方法是 getitem 它完全符合您的预期。如果我们进行预测，它应该会返回一批图像和遮罩。这可以通过将 to_fit 设置为 True 或 False 来控制。

整个数据生成器应该如下所示:

假设我们有两个目录，一个保存图像，另一个保存蒙版图像，并且每个图像都有一个同名的相应蒙版，下面的代码将使用自定义数据生成器为模型定型。

最后，如果我们想使用数据生成器进行预测，应该将 to_fit 设置为 False，并调用 predict_generator。

结论

虽然 Keras 提供了数据生成器，但是它们的能力有限。原因之一是每个任务都需要不同的数据加载器。有时每个图像有一个遮罩，有时有几个，有时遮罩被保存为图像，有时被编码，等等…

对于每个任务，我们可能需要调整我们的数据生成器，但结构将保持不变。

参考链接

斯坦福大学的 Keras 如何使用数据生成器的详细示例

[## 使用 Keras 的数据生成器的详细示例

python keras 2 fit _ generator Afshine Amidi 和 Shervine Amidi 的大型数据集多重处理您是否曾经不得不…

stanford.edu](https://stanford.edu/~shervine/blog/keras-how-to-generate-data-on-the-fly)

Keras 模型类

[## 模型(功能 API) - Keras 文档

在函数式 API 中，给定一些输入张量和输出张量，您可以通过以下方式实例化一个模型:from…

keras.io](https://keras.io/models/model/)

Keras ImageDataGenerator 类

[## 图像预处理

keras . preprocessing . image . image data generator(feature wise _ center = False，samplewise_center=False…

keras.io](https://keras.io/preprocessing/image/)

初学者的 Keras:建立你的第一个神经网络

原文：https://towardsdatascience.com/keras-for-beginners-building-your-first-neural-network-f21cdf90789e?source=collection_archive---------14-----------------------

关于使用 Keras 在 Python 中实现简单神经网络的初学者友好指南。

Keras 是一个简单易用但功能强大的 Python 深度学习库。在这篇文章中，我们将看到建立一个前馈神经网络并训练它解决 Keras 的一个实际问题是多么容易。

这篇文章是为完全初学 Keras 的人写的，但是假设他有神经网络的基础背景知识。我的关于神经网络的介绍涵盖了这篇文章中你需要知道的一切(以及更多)——如果有必要的话，请先阅读。

我们开始吧！

只想要代码？下面是 完整源代码 。

问题:MNIST 数字分类

我们要解决一个经典的机器学习问题: MNIST 手写数字分类。很简单:给定一个图像，将其归类为一个数字。

Sample images from the MNIST dataset

MNIST 数据集中的每幅图像都是 28x28，包含一个居中的灰度数字。我们将把每个 28x28 展平成一个 784 维向量，我们将把它作为神经网络的输入。我们的输出将是 10 个可能的类之一:每个数字一个。

1.设置

我假设您已经准备好了基本的 Python 安装(您可能已经准备好了)。让我们首先安装一些我们需要的软件包:

$ pip install keras tensorflow numpy mnist

注意:我们需要安装 *tensorflow* ，因为我们要在一个TensorFlow后端上运行 Keras(即 tensor flow 将为 Keras 供电)。

现在，您应该能够导入这些包并浏览 MNIST 数据集:

2.准备数据

如前所述，我们需要将每个图像展平，然后才能将其传递到我们的神经网络中。我们还将从[0，255]到[-0.5，0.5]归一化像素值，以使我们的网络更容易训练(使用较小的居中值通常更好)。

我们准备好开始构建我们的神经网络了！

3.构建模型

每个 Keras 模型要么使用代表线性层堆栈的顺序类构建，要么使用可定制性更强的功能性模型类构建。我们将使用更简单的Sequential模型，因为我们的网络实际上是层的线性堆叠。

我们从实例化一个Sequential模型开始:

Sequential构造器接受一个 Keras 层的数组。因为我们只是在构建一个标准的前馈网络，所以我们只需要密集层，也就是常规的全连接(密集)网络层。

让我们扔进 3 层Dense:

前两层各有 64 个节点，使用 ReLU 激活功能。最后一层是一个有 10 个节点的 Softmax 输出层，每个类一个节点。

如果需要复习，读我的 简单 Softmax 解释 。

我们总是需要做的最后一件事是告诉 Keras 我们的网络的输入将会是什么样子。我们可以通过给Sequential模型中的第一层指定一个input_shape来实现:

指定输入形状后，Keras 将自动推断后续图层的输入形状。我们已经完成了模型的定义！我们的情况是这样的:

4.编译模型

在开始培训之前，我们需要配置培训流程。在编译步骤中，我们决定 3 个关键因素:

优化器。我们将坚持一个非常好的默认设置:基于梯度的优化器。Keras 还有许多其他的优化器，你也可以看看。
损失函数。由于我们使用的是 Softmax 输出层，我们将使用交叉熵损失。Keras 区分了binary_crossentropy (2 类)和categorical_crossentropy ( > 2 类)，所以我们将使用后者。查看所有 Keras 损失。
一系列指标。由于这是一个分类问题，我们将让 Keras 报告准确性指标。

这是编译后的样子:

向前！

5.训练模型

在 Keras 中训练一个模型实际上只包括调用fit()和指定一些参数。有许多可能的参数，但我们将只手动提供几个:

训练数据(图像和标签)，分别俗称 X 和 Y。
要训练的历元数(整个数据集的迭代次数)。
训练时使用的批次大小(每次梯度更新的样本数)。

看起来是这样的:

然而，这实际上还没起作用——我们忽略了一件事。Keras 希望训练目标是 10 维向量，因为在我们的 Softmax 输出层中有 10 个节点，但是我们提供了一个单个整数来表示每个图像的类。

方便的是，Keras 有一个实用方法可以解决这个问题:to _ categorial。相反，它将我们的类整数数组变成了一个由单热点向量组成的数组。例如，2会变成[0, 0, 1, 0, 0, 0, 0, 0, 0, 0](它是零索引的)。

我们现在可以将所有东西放在一起训练我们的网络:

运行这段代码会得到如下结果:

Epoch 1/5
60000/60000 [==============================] - 2s 35us/step - loss: 0.3772 - acc: 0.8859
Epoch 2/5
60000/60000 [==============================] - 2s 31us/step - loss: 0.1928 - acc: 0.9421
Epoch 3/5
60000/60000 [==============================] - 2s 31us/step - loss: 0.1469 - acc: 0.9536
Epoch 4/5
60000/60000 [==============================] - 2s 31us/step - loss: 0.1251 - acc: 0.9605
Epoch 5/5
60000/60000 [==============================] - 2s 31us/step - loss: 0.1079 - acc: 0.9663

经过 5 个周期，我们达到了 96.6%的训练准确率。然而，这并没有告诉我们太多——我们可能过度适应了。真正的挑战将是看看我们的模型在我们的测试数据上表现如何。

6.测试模型

评估模型非常简单:

跑步带给我们:

10000/10000 [==============================] - 0s 15us/step
[0.10821614159140736, 0.965]

evaluate() 返回一个数组，该数组包含测试损失，后跟我们指定的任何指标。因此，我们的模型实现了 0.108 的测试损失和 96.5%的测试精度！对你的第一个神经网络来说还不错。

7.使用模型

现在我们有了一个工作的、经过训练的模型，让我们将它投入使用。我们要做的第一件事是将它保存到磁盘，这样我们就可以随时将它加载回来:

model.save_weights('model.h5')

现在，我们可以随时通过重建模型并加载保存的权重来重新加载训练好的模型:

使用训练好的模型进行预测很容易:我们将一个输入数组传递给predict()，它返回一个输出数组。请记住，我们网络的输出是 10 个概率(因为 softmax)，所以我们将使用 np.argmax() 将这些转换成实际的数字。

8.扩展ˌ扩张

到目前为止，我们所涉及的只是一个简单的介绍——我们还可以做更多的事情来试验和改进这个网络。我在下面列举了几个例子:

调谐超参数

一个好的超参数是亚当优化器的学习率。当你增加或减少它的时候会发生什么？

批量大小和历元数呢？

网络深度

如果我们删除或添加更多全连接层，会发生什么？这对培训和/或模型的最终表现有什么影响？

激活

如果我们使用 ReLU 以外的激活，例如 sigmoid ，会怎么样？

拒绝传统社会的人

如果我们尝试添加下降层，这是众所周知的防止过度拟合？

确认

我们还可以在训练期间使用测试数据集进行验证。Keras 将在每个时期结束时评估验证集上的模型，并报告损失和我们要求的任何指标。这使我们能够在训练期间监控模型的进度，这对于识别过度拟合甚至支持早期停止是有用的。

结论

你已经用 Keras 实现了你的第一个神经网络！我们在 5 个历元后在 MNIST 数据集上取得了 96.5% 的测试准确率，对于这样一个简单的网络来说已经不错了。我将在下面再次包含完整的源代码，供您参考。

如果你想了解接近 MNIST 的更先进的技术，我推荐查看我的卷积神经网络介绍(CNN)。在这篇文章中，我们看到了如何使用更复杂的网络在 MNIST 上实现更高的准确率。我也推荐我的指南用 Keras 实现一个 CNN，它类似于这篇文章。

你可能感兴趣的进一步阅读材料包括:

Keras 官方入门指南。
这个用 Keras 介绍 CNN。
一系列的例子。

感谢阅读这篇文章！完整的源代码如下。

完整的代码

原载于https://victorzhou.com。

云中的 Keras 超参数优化

原文：https://towardsdatascience.com/keras-hyperparameter-optimization-on-aws-cbd494a7ea15?source=collection_archive---------20-----------------------

使用 Talos 和 Docker 在云中高效搜索大型参数空间

Photo by Roberta Sorge on Unsplash

当训练机器学习模型时，将计算卸载到远程服务器通常更方便(也更有必要)。虽然免费服务如 Google Colab 和 Azure Notebooks 对于 Jupyter 笔记本中的初始手动工作来说很棒，但它们不太适合长时间运行的实验，如超参数训练，因为它们在几个小时后会自动关闭。

以 AWS 为例云提供商，最直接的翻译就是在 Sagemaker 上运行笔记本。然而，通过在 Docker 容器中设置培训并自己进行部署，可以获得更高的成本效率。在这种类型的环境中开发一个模型还具有可移植性和可再现性的优势(后面会详细介绍)。

在 AWS 中，对于这种类型的作业，有三种主要的 Docker 部署选项:

ECS Fargate:抽象出服务器级配置，只需要基本的网络、权限和 CPU/内存要求。
ECS EC2:提供精细控制，同时仍允许 ECS 管理群集和整体资源使用情况。
EC2:提供完整的端到端配置来运行容器。

为了比较各选项的成本，我们将该地区固定为 US-East-1，并使用 Fargate 的 CPU/内存定价来提供一个实例等效成本($ 0.04048/vCPU/HR+$ 0.004445/GB/HR)。

实例类型:m5.xlarge (4 个 vCPU / 16 GB)

AWS sage maker = 0.269 美元/小时>>每 3 天 19.37 美元
AWS Fargate(等值)= 0.23304 美元/小时>>每 3 天 16.78 美元
按需 AWS EC2 = 0.192 美元/小时>>每 3 天 13.82 美元
AWS EC2 现货= 0.0827 美元/小时>>每 3 天 5.95 美元

很明显，如果我们能够利用 spot 实例，将会有显著的成本优势，同样的优势也适用于 c5.large 等其他实例类型。 spot 实例的主要限制是容量可以随时回收，但是超参数培训工作非常适合这种情况。

此外，由于 ECS 实际上旨在管理集群，我们将通过采取以下步骤来部署我们自己的 EC2 实例以避免这种开销:

设置样板 Docker 容器
在容器内部本地开发模型和优化方法
为 EC2 准备一个自定义 Docker 容器
将容器部署到 EC2 spot 实例，该实例将结果保存到 S3
本地下载结果并可视化
选择最佳部署模式

值得注意的是，Sagemaker 还提供了一套 a 服务，用于培训和超参数优化，此处未考虑。

模型概述

对于这个例子，我们将使用来自 Kaggle 的一个简单的数据集，它展示了各种葡萄酒属性和相关的质量分数。

具有 Tensorflow 后端的 Keras 将是机器学习库的选择，对于超参数优化，我们将选择一个名为 Talos 的新库，它具有非常易于使用的工作流。有关介绍，请访问他们关于走向数据科学的文章:

[## 基于 Keras 的超参数优化

towardsdatascience.com](/hyperparameter-optimization-with-keras-b82e6364ca53)

环境设置

将本地实验迁移到远程服务器的最简单方法是始终在 Docker 容器内工作，因为这允许您通过 Python 包从操作系统移植环境的精确副本。

作为基础，我们可以在 Python 3 中使用 Tensorflow 的 Docker 图像。首先导航到您的项目目录，然后运行下面的命令来启动一个 shell 会话。

$ docker run -it -p 8888:8888 --rm -v $PWD:/root \
  -w /root tensorflow/tensorflow:1.13.1-py3

然后在 Docker shell 中安装所需的最小 Python 库:

$ pip install jupyter keras talos

注意:在撰写本文时，PyPi 上可用的 Talos 版本是 v0.4.9。然而，v0.6 很快就会有重大变化，因此使用了这个分支。为此，需要安装 *apt-get update && apt-get install -y git* ，然后将分支传递给 pip，而不是 *talos* ，例如 pip install git+https://github.com/autonomio/talos.git@daily-dev。我还创建了一个快照，这样这个例子就可以重现了: https://github.com/mikepm35/talos.git@v0.6-prerelease。

然后可以通过下面的命令启动 Jupyter 会话，并在您的本地机器上的http://localhost:8888/访问。

$ jupyter notebook --ip=0.0.0.0 --no-browser --allow-root

通过将容器内的工作目录映射到项目目录，所有文件都将被创建并保存在您的本地机器上。

模型设置

笔记本配置

这个例子的模式是模型开发在 Jupyter 笔记本中进行，它也可以在“笔记本即服务”平台上运行，比如 Google Colab。然后，它被转换成一个常规的 Python 文件，用于在云中执行长期运行的优化实验。

为了帮助解决这一问题，我们提供了以下元素来正确配置笔记本电脑:

定义数据流和实验参数的控制字典。
如果在笔记本服务(如 Google Colab)上运行，可选择安装 Python 包的标志。
运行无头优化实验时，使用当前系统用户名来避免图形 UI 显示的导入逻辑语句。(注意，还有其他模式可以用来处理 matplotlib 安装，比如将逻辑移入控制字典)。

数据准备

假设属性跨越多个数量级，我们将归一化所有的特征列(X)。

标签列(Y)将基于阈值被编码为两个类别(差质量、好质量)的一个热点。这也遵循来自 Kaggle 的数据的附带描述的指导。

一个值得关注的问题是，这些类别非常不平衡，只有 13.6%的观察结果被标记为“高质量”。在本节中，我们计算了可选合并到训练中的类权重，但是手动实验没有显示性能的改善，因此它被排除在最终模型之外。

模型配置

为 Talos 建立一个实验遵循正常的 Keras 序列模型的模式，除了为用于优化的参数添加替换(params)。为了允许不同数量的隐藏层，使用了 Talos 函数，而不是直接在我们的函数中构建它们。

优化实验的输入被定义为离散值[a, b, c]或范围(min, max, steps)的字典。有关可用参数的更多信息，请参见 Talos 文档。

调用Scan()时，实际实验开始。这里fraction_limit定义了将运行的全网格参数空间的百分比，即所有可能参数组合的 25%将实际运行。这个例子中没有显示 Talos 中定义优化策略的众多选项。

扫描开始后，Talos 将提供要运行的实验总数以及预计完成时间。在我们的例子中，有 5，760 次运行，大约需要 10 个小时。(请注意，随着新运行的执行，时间估计将会更新，这个实验的实际总执行时间是 22 小时)。

实验完成后，我们可以创建一个部署包，其中包含由val_acc定义的最佳 Keras 模型。这个 zip 文件和每次运行后生成的 csv 结果将被上传到 S3。

部署和培训

模型设置完成后，在 Docker 容器中运行以下命令来保存 Python 依赖项:

$ pip freeze > requirements.txt

如果您使用 Talos 的单独分支，一定要用 git url 替换talos==0.6.0。

为部署设置 Docker 容器

为了部署实验，必须开发一个定制的 Docker 映像来重新创建本地环境。这个 docker 文件从同一个基本 Tensorflow 映像开始，复制 Jupyter 笔记本文件、数据和需求，然后安装所有 Python 包。还创建了一个新用户kerasdeploy，这是安装适当的 matplotlib 后端的触发器。

由于这是一个无头实验，我们将使用 nbconvert 将笔记本转换成一个常规的 Python 文件，然后在容器启动时立即执行。

FROM tensorflow/tensorflow:1.13.1-py3RUN useradd -ms /bin/bash kerasdeployWORKDIR /home/kerasdeployRUN apt-get update && apt-get install -y gitCOPY keras_remote_training.ipynb winequality-red.csv requirements.txt ./RUN pip install -r requirements.txtRUN chown -R kerasdeploy:kerasdeploy ./
USER kerasdeployRUN jupyter nbconvert --to script keras_remote_training.ipynbCMD ["python","-u","keras_remote_training.py"]

完成后，构建容器…

$ docker build -t keras-remote-training .

…然后在本地运行几次，以验证一切正常。

$ docker run --name keras-remote-training \
  --rm keras-remote-training:latest

AWS 配置和部署

现在 Docker 映像已经完成，需要设置云环境。在本例中，我们将使用 ECR 作为 Docker 储存库，但是类似的 push/pull 命令也可以用于 Docker hub(或其他)储存库。

导航到 ECR，创建一个新的存储库keras-remote-training，并注意 URI。使用这个 URI 标记构建，检索基本的 auth 凭证，然后推送到 ECR。

$ docker tag keras-remote-training:latest \
<ecr_id>.dkr.ecr.<region>.amazonaws.com/keras-remote-training:latest$ (aws ecr get-login --no-include-email --region <region>)$ docker push \
<ecr_id>.dkr.ecr.<region>.amazonaws.com/keras-remote-training:latest

在 AWS 中，启动“启动实例”向导，并使用以下选项:

图片ami-0f812849f5bc97db5来自为 ECR/Docker 预建的社区 AMIs
实例类型 m5.xlarge(或其他变体)
选择“请求 spot 实例”
选择允许访问 S3 和 ECR 的 IAM 角色(例如，附加了 AmazonS3FullAccess 和 amazone 2 containerregistyrepoweruser 策略)
在“高级选项”下添加一个启动脚本，该脚本将自动提取并运行 Docker 映像。如果需要，这也允许在终止时自动重启。

当实例启动时，优化实验将自动开始执行，并将结果保存到 S3！

当训练停止时(例如，当平均 CPU 利用率下降到< 10%至少五分钟时)，设置 CPU 警报作为代理非常有用。该警报可以发送电子邮件通知，或自动终止实例以减少费用。

Photo by Andrew Wulf on Unsplash

结果

Talos 包含内置的报告功能，但是，为了提供进一步的定制，我们将把结果文件直接加载到 Pandas 数据框架中。因为这些结果在 S3，所以我们将运行本地实例，而不执行 Scan()。

Kaggle 文档提到 AUC 目标值为 0.88，我们将从最佳模型中计算出该值作为第一参考值。结果是 0.89，这是一个好的开始。

为了探索拟合的质量，我们将绘制验证准确性与损失的关系图，以及培训损失与验证损失的关系图。

从上述图表中可以得出两个主要结论:

大多数优化实验都是高价值的，如验证准确性上限周围的紧密聚类所示。
在有过度拟合趋势的地方产生二次分布。

为了处理实验中的过度拟合，我们将向结果添加一个新参数，该参数表示验证损失和训练损失之间的差异(正值表示过度拟合)。正值表示过度拟合，为后续滤波设置阈值。

使用这个新参数，我们现在可以查看没有过度拟合的最佳结果。尽管我们是按准确度排序的，但我们也将包括作为混淆矩阵代理的马修斯相关系数。

正如所料，根据loss_diff的测量，压差的增加与过度拟合的减少相关。对准确度和马修斯相关系数影响最大的因素是学习速率和隐藏层，与批量大小和时期的关系较弱。

后续步骤

根据所需的微调，这些结果可以直接用于部署模型，或构建更窄的后续实验。

这个例子使用了一个非常小的数据集，所以内存优化的实例不是最好的选择。在价格是 m5.xlarge 一半的 c5.large 中重新运行，对于 0.81 美元的实验，我们可以观察到更好的资源利用率和合理的总成本。

$ docker statsCPU %      MEM USAGE / LIMIT     MEM %157.47%    394.4MiB / 3.618GiB   10.64%

要查看与本文相关的代码，请访问https://github.com/mikepm35/KerasRemoteTraining。

深度学习的 Keras vs PyTorch

原文：https://towardsdatascience.com/keras-vs-pytorch-for-deep-learning-a013cb63870d?source=collection_archive---------1-----------------------

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

对于许多科学家、工程师和开发人员来说，TensorFlow 是他们的第一个深度学习框架。TensorFlow 1.0 发布于 2017 年 2 月；至少可以说，它对用户不太友好。

在过去的几年里，两个主要的深度学习库获得了巨大的人气，主要是因为它们比 TensorFlow 更容易使用: Keras 和 PyTorch 。

本文将涵盖 Keras vs. PyTorch 的 4 个不同方面，以及为什么您会选择一个库而不是另一个库。

克拉斯

Keras 本身并不是一个框架，实际上是一个位于其他深度学习框架之上的高级 API。目前它支持 TensorFlow、Theano 和 CNTK。

Keras 的妙处在于好用。这是迄今为止最容易快速启动和运行的框架。定义神经网络是直观的，使用函数式 API 可以将层定义为函数。

PyTorch

Pyorch 是由脸书人工智能研究小组开发的深度学习框架(类似 TensorFlow)。像 Keras 一样，它也抽象掉了编程深度网络的许多混乱部分。

就高级和低级编码风格而言，Pytorch 介于 Keras 和 TensorFlow 之间。与 Keras 相比，您有更多的灵活性和控制力，但同时您不必进行任何疯狂的声明式编程。

深度学习的实践者整天都在考虑应该使用哪个框架。一般看个人喜好。但是当你做出选择时，你应该记住 Keras 和 Pytorch 的一些方面。

It’s Pytorch!

(1)用于定义模型的类与函数

为了定义深度学习模型，Keras 提供了函数式 API。使用函数式 API，神经网络被定义为一组连续的函数，一个接一个地应用。例如，功能定义层 1 的输出是功能定义层 2 的输入。

img_input = layers.Input(shape=input_shape)
x = layers.Conv2D(64, (3, 3), activation='relu')(img_input)    
x = layers.Conv2D(64, (3, 3), activation='relu')(x)    
x = layers.MaxPooling2D((2, 2), strides=(2, 2))(x)

在 Pytorch 中，您将网络设置为一个类，该类扩展了 torch 库中的 torch.nn .模块。与 Keras 类似，Pytorch 为您提供了作为构建块的层，但由于它们位于 Python 类中，因此它们在该类的 init()方法中被引用，并由该类的 forward()方法执行。

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, 3)
        self.conv2 = nn.Conv2d(64, 64, 3)
        self.pool = nn.MaxPool2d(2, 2)
    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool(F.relu(self.conv2(x)))
        return x
model = Net()

因为 Pytorch 让您可以访问 Python 的所有类特性，而不是简单的函数调用，所以定义网络可以更清晰、更优雅。这真的没有太大的坏处，除非你真的觉得尽快编写网络代码对你来说是最重要的，那么 Keras 会更容易使用。

(2)张量和计算图形与标准数组

Keras API 隐藏了许多不经意间被编码者发现的混乱细节。定义网络层很直观，默认设置通常足以让您入门。

只有在实现一个相当前沿或“奇特”的模型时，才真正需要深入到底层的、本质的张量流。

棘手的部分是，当你真的深入到底层 TensorFlow 代码时，你会得到随之而来的所有具有挑战性的部分！你需要确保所有的矩阵乘法都排成一行。哦，甚至不要想打印出你的层的输出之一，因为你只会得到一个很好的张量定义打印在你的终端上。

Pytorch 在这些方面更宽容一些。您需要知道每一层的输入和输出大小，但是这是比较容易的方面之一，您可以很快掌握。你不必处理构建一个抽象的计算图，你看不到里面的调试。

Pytorch 的另一个优点是可以在 torch 张量和 Numpy 数组之间来回切换。如果您需要实现一些自定义的东西，那么在 TF tensors 和 Numpy 数组之间来回切换可能会很痛苦，需要开发人员对 TensorFlow 会话有很好的理解。

Pytorch 互操作实际上要简单得多。您只需要知道两个操作:一个是将 Torch 张量(一个可变对象)切换到 Numpy，另一个是相反的方向。

当然，如果您从来不需要实现任何花哨的东西，那么 Keras 会做得很好，因为您不会遇到任何 TensorFlow 路障。但如果你这样做了，Pytorch 可能会顺利得多。

(3)培训模式

Time to train!

在 Keras 训练一个模特超级容易！只需一个简单的.fit()动作，你就可以尽情享受旅程了！

history = model.fit_generator(
    generator=train_generator,
    epochs=10,
    validation_data=validation_generator)

在 Pytorch 中训练模型包括几个步骤:

在每批训练开始时初始化梯度
通过模式运行正向传递；
向后传球
计算损失并更新权重

for epoch in range(2):  # loop over the dataset multiple times running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # Get the inputs; data is a list of [inputs, labels]
        inputs, labels = data # (1) Initialise gradients
        optimizer.zero_grad() # (2) Forward pass
        outputs = net(inputs)
        loss = criterion(outputs, labels) # (3) Backward
        loss.backward() # (4) Compute the loss and update the weights
        optimizer.step()

光是运行培训就有很多步骤！

我想这样你总是能意识到发生了什么。同时，这是完全不必要的，因为这些模型训练步骤对于训练不同的模型基本上保持不变。

(4)控制 CPU 与 GPU 模式

We need MORE POWER

如果您已经安装了tensorflow-gpu，那么在 Keras 中，默认情况下会启用并使用 GPU。然后，如果您希望将某些操作转移到 CPU，您可以使用一行程序来完成。

with tf.device('/cpu:0'):
    y = apply_non_max_suppression(x)

对于 Pytorch，您必须为每个 torch 张量和 numpy 变量显式启用 GPU。这使代码变得混乱，如果您为了不同的操作在 CPU 和 GPU 之间来回移动，可能会有点容易出错。

例如，要将我们以前的模型转移到 GPU 上运行，我们必须执行以下操作:

# Get the GPU device
device **=** torch**.**device("cuda:0" **if** torch**.**cuda**.**is_available() **else** "cpu")# Transfer the network to GPU
net**.**to(device)# Transfer the inputs and labels to GPU
inputs, labels **=** data[0]**.**to(device), data[1]**.**to(device)

Keras 的优势在于它的简单性和良好的默认设置

选择框架的一般建议

我通常给的建议是从 Keras 开始。

Keras 绝对是最容易使用、理解和快速启动并运行的框架。你不必担心 GPU 的设置，摆弄抽象代码，或一般做任何复杂的事情。你甚至可以做一些事情，比如实现自定义层和损失函数，而无需接触 TensorFlow 的任何一行。

如果您开始深入到深层网络的更细粒度的方面，或者正在实现一些非标准的东西，那么 Pytorch 就是您的首选库。在 Keras 上会有一点额外的工作，但不会太多以至于减慢你的速度。您仍然能够快速实现、训练和测试您的网络，同时还能轻松调试！

喜欢学习？

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

非线性分类中的核函数

原文：https://towardsdatascience.com/kernel-functions-in-non-linear-classification-91a6c9ab14d6?source=collection_archive---------12-----------------------

了解内核函数如何将特性映射到更高维度。

由于数据点在其原始特征空间中是非线性可分的，线性分类器可能无法确定决策边界在哪里。然而，将原始特征空间( x ∈ ℝᵈ)映射到更高维的特征空间( ϕ ( x ) ∈ ℝᵉ，e > d)可以帮助复活线性分类器来正确地完成工作。

图一。阐释了通过特征映射对数据点进行分类的概念。本来，二维空间中具有特征向量 x = [ x ₁， x ₂]的数据点具有同心圆分布(这里不是严格的数学描述)。不可能使用线性分类器来区分决策边界。

尽管如此，通过结合某种映射函数 ϕ ( x )，特征向量可以被变换到三维特征空间。具有三维特征向量ϕ(x)=[x₁，x₂,(x₁+x₂]的新数据点现在可以使用线性分类器来确定决策边界超平面。这就是特性映射的力量，它可以让我们用更强的表达能力来处理更复杂的数据分布模式。

Figure 1. Mapping data points with 2-D feature vectors into 3-D feature vectors

但是，直接使用 ϕ ( x )的缺点是

有时很难直接显式构造一个 ϕ ( x )。
随着特征尺寸的增加，计算能力迅速提高。

但是内核函数可以提供一种有效的方法来解决这个问题。

核函数

核函数的思想是在两个特征向量之间取内积，并且计算内积不需要很大的计算量。然后，我们可以在算法中只利用内积的结果。例如，如果我们想让 ϕ ( x )如下:

核函数取两个特征向量之间的内积如下，

因此，核函数的形式对于我们来说将比在更高的特征维度中直接使用映射函数更容易构造。

内核合成规则

有几个内核组合规则可以用来构造更复杂的内核函数。

径向基核

核函数甚至可以赋予特征向量无限维的能力。一种常见的核函数是径向基核。定义如下。

因为指数可以扩展到无穷幂级数，所以径向基核赋予特征映射更多的表现力。下面是径向基核是核函数的证明。

核感知器算法

这里回忆一下感知器算法，感知器算法一旦一个数据点被误分类，就更新θ=θ+y⁽ʲ⁾x⁽ʲ⁾。换句话说， θ 可以替换地表达如下。**

其中，α ⱼ 是感知器在第 j 个数据点上犯的错误数。如果在映射特征空间中，则 θ 可以表示如下。

利用 θ的核心形式，核心感知器算法的伪代码可以描述如下。

***# Kernel Perceptron Algorithm**# initialize* α**ⱼ**
*# totally m data points* for i = 1 .. m do
    αᵢ = 0*# totally T epoches to iterate*
for t = 1 .. T do                     
   * # totally m data points*    
    for i = 1 .. m do
        *# misclassify data points*                 
        if y⁽ⁱ⁾***∑*ⱼ(**α**ⱼ**y⁽ʲ⁾*K*(x⁽ʲ⁾,x⁽ⁱ⁾)**)** ≦ 0     
        then
            αᵢ = αᵢ + 1θ*ϕ*(x⁽ⁱ⁾)= ***∑*ⱼ(**α**ⱼ**y⁽ʲ⁾*K*(x⁽ʲ⁾,x⁽ⁱ⁾)**)****

内核在运行

图二。通过径向基核感知器算法可视化决策边界的更新。注意，由径向基核感知器算法绘制的决策边界可以在 2 个 epoches 内收敛于这种数据分布。径向基核的γ在这里使用 0.3。

Figure 2. Updating the decision boundaries by the RBK perceptron algorithm. May take time to load.

示例代码

在 Jupyter 笔记本上写的感知器算法的样本代码可以在这里找到。您可以自己处理数据和超参数，看看内核感知器算法的表现如何。

内核回归—示例和代码

原文：https://towardsdatascience.com/kernel-regression-made-easy-to-understand-86caf2d2b844?source=collection_archive---------2-----------------------

Photo by Markus Spiske on Unsplash

本文讨论了如何利用核函数作为权函数来建立非参数回归模型。在文章的开始，简要讨论了核函数的性质和围绕数据点构建核的步骤。

核函数

在非参数统计中，核是满足以下性质的加权函数。

一个核函数必须对称。从数学上讲，这种性质可以表示为 K (-u) = K (+u)。核函数的对称性质使其最大值( max(K(u) )位于曲线的中间。

An illustration of Gaussian kernel function

2.函数曲线下的面积必须是等于 1。从数学上来说，该属性表示为:

3.核函数的值不能为负，即K(u)≥0 for all-<u<∞。

核估计

在本文中，高斯核函数用于计算数据点的核。高斯核的等式是:

其中 xi 为观察数据点。 x 是计算核函数的值， h 称为带宽。核回归中的带宽被称为平滑参数，因为它控制输出中的方差和偏差。本文稍后将讨论带宽值对模型预测的影响。

例子

假设有六个数据点，每个数据点显示单个学生在某一科目中获得的分数。使用高斯核函数在每个数据点构建核的步骤如下所述。

【Xi】= { 65，75，67，79，81，91}其中 x1 = 65，x2= 75…X6= 91。

需要三个输入来构建围绕数据点的核心曲线。

一.观察数据点，

二。的值 h 的值****

三。线性间隔的数据点系列，包括需要估计 K 值的观察数据点。如: Xj = {50，51，52 …99}

对于给定的h 值，计算K 值【Xj】值的步骤如下表所示，其中【Xi】= 65、h= 5.5。表格中的最后一列显示了内核的纵坐标为= 65。********

下面绘制 Xj 和 K 来可视化内核。注意图中的 x 轴是 Xj ，在其上构建内核曲线，在高斯分布的情况下，以【Xi】为均值，【h】为标准差。******

类似地，在所有六个观察到的数据点，内核值被估计并绘制如下。据观察，【Xj】与【Xi】相差甚远的 K 的值接近 0。例如，Xj= 99 的内核值对于= 65 是零。******

Kernels plotted for all xi

核回归

在本节中，内核值用于从给定的输入导出权重以预测输出。计算权重并最终将其用于预测输出变量所涉及的步骤，预测变量中的 y ， x 将在以下章节中详细说明。让我们从一个例子开始，清楚地理解内核回归是如何工作的。

例子

在本例中，开发了一个核心回归模型来预测集水区的河流流量。如下图所示，集水面积(平方英里)和河流流量(立方英尺/秒)之间存在非线性关系。在本例中， y 为河流流量，x 为流域面积。

Example data set to build kernel regression

作为加权函数的核

最初，如前几节所述，使用所有输入的带宽值来估计核。然后用它们来计算重量。在本例中，带宽值 10 用于解释内核回归。然而，带宽值需要优化以适当地适应数据。在不同的 x 值下绘制的内核如下图所示。

重要的是要理解，内核是在所有的 xi 值下开发的。内核回归背后的基本计算是针对给定的预测值 xi，估计所有观察到的 y 值的加权和。权重只不过是内核值，范围在 0 和 1 之间，在给定的 xi 与垂直于 x 轴的线相交(如下图所示)。

Scattered plot showing input-output data (above) and kernels at all inputs using a bandwidth of 10 (below)

Intersection of predictor variable, area = 50 with surrounding kernels

上面的星形标记显示了交叉点及其相应的内核值。内核值在 0 和 1 之间缩放，以将其用作权重。以下等式用于在 0 和 1 之间缩放内核值。

其中 wi 为输入的权重In为数据点总数。 x = 50 的输出 y 计算为所有观察到的 y 值的加权和，如下式所示。****

其中 y11 是面积= 11 的河流流量， w11 是相应的重量，等式中的其他项也是如此。

下表显示了从输入 x = 50 的内核值计算权重所涉及的步骤。表中的最后一列提供了最终输出，即 50 平方英里区域的计算河流流量。

同样，对于 x、的所有值，权重如上表所述进行估算，并用于计算相应的 y 值。下表和下图显示了不同区域输入的预测河流流量值。

Computed river flow from kernel regression

带宽灵敏度

以上计算基于带宽值 10。内核带宽对预测的影响很大，如下图所示。

Kernel regression output for bandwidth value = 5

Kernel regression output for bandwidth value = 10

Kernel regression output for bandwidth value = 15

在为预测时，由于较窄的内核对训练数据集中的“【Xi】”的【易】 赋予较高的权重，因此较小的带宽值过拟合数据。低带宽会在输出中产生大量看起来不真实的变化，而高带宽值会使输出过于平滑，无法揭示输入和输出之间的真实关系。因此，为了达到偏差-方差的平衡，应该在核回归中优化带宽。******

核回归的 r 代码

*****#Kernel regression
data <- data.frame(Area = c(11,22,33,44,50,56,67,70,78,89,90,100),        RiverFlow = c(2337,2750,2301,2500,1700,2100,1100,1750,1000,1642, 2000,1932))                                 

x <- data$Area
y <- data$RiverFlow#function to calculate Gaussian kernel
gausinKernel <- function(x,b){
  K <- (1/((sqrt(2*pi))))*exp(-0.5 *(x/b)^2)
  return(K)
}b <- 10 #bandwidth
kdeEstimateyX <- seq(5,110,1)
ykernel <- NULL
for(xesti in kdeEstimateyX){
  xx <-  xesti - x
  K <-gausinKernel(xx,b)
  Ksum <- sum(K)
  weight <- K/Ksum
  yk <- sum(weight*y)
  xkyk <- c(xesti,yk)
  ykernel <- rbind(ykernel,xkyk)
}
plot(x,y,xlab = "Area", ylab = "Flow", col = 'blue', cex = 2)
lines(ykernel[,1],ykernel[,2], col = 'red', lwd = 2)*****