TowardsDataScience-博客中文翻译-2020-一百一十三-

TowardsDataScience 博客中文翻译 2020（一百一十三）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

理解新冠肺炎·疫情需要的图表

原文：https://towardsdatascience.com/the-graphs-you-need-to-understand-the-covid-19-pandemic-3353a5cc8adf?source=collection_archive---------24-----------------------

如果你知道要寻找什么，正确的图表会非常有启发性

作为疾病预防控制中心新冠肺炎“集合”预测模型的贡献者之一，我在我的新冠肺炎免费数据中心每周更新几次一组州和国家图表。我附上了我个人认为有助于理解疫情现状和趋势的图表。

国家图表

最基本的图表显示了每日阳性检测和死亡的原始数据，如下所示。蓝线代表阳性测试，红线代表死亡。轴被缩放，使得阳性测试标度是死亡标度的 10 倍。

在这个图表中，我主要寻找的是数据中的意外噪声。我们通常会看到一种每周报告模式，即周日和周一少报，周二和周三多报。你可以在这个图表的“山丘和山谷”中看到。有时也有例外，比如节假日周末严重漏报。如果你看看劳动节附近的蓝线，你可以看到一个明显的下降，然后是一个峰值。

我查看的下一个图表是平滑测试和死亡数据图表。这将在 7 天的平滑期内平滑数据，从而消除少报和多报。通常我认为原始数据比平滑数据过滤更少，更有意义。但在这种情况下，通过减少报告不规则性的影响，平滑的数据实际上呈现了疫情过程的更真实的画面。

更容易看到平滑数据的趋势。在下面 9 月 28 日的例子中，很容易看到蓝线(阳性测试)在大约两周的增加后趋于平稳。

这张图表也很容易看出阳性检测和死亡之间的关系不再像以前那样了。如果你看图表的左三分之一，你可以看到红色曲线跟随蓝色曲线，略微滞后。但是大约在五月中旬之后，蓝色曲线迅速上升。红色曲线仍然跟随它，但是比率完全不同。这是因为在五月中旬之后进行了更多的检测，并且发现了更高比例的感染。因此，死亡与阳性检测的比率下降了。

我查看的全国趋势的最后一个图表是 7 天 delta 图。该图显示了与平滑测试图相同的信息，但其形式更易于查看阳性测试上升或下降的比率。红色表示阳性测试呈上升趋势。绿色表示阳性测试呈下降趋势。高红色意味着阳性测试正在快速上升。低红色意味着阳性测试呈缓慢上升趋势。对于数学爱好者来说，你可以认为这个图显示的是二阶导数。

在下面的例子中，你可以在最右边看到，阳性测试的趋势没有一周前那么快。但它们仍呈上升趋势，而非下降。

右边的一系列绿色曲线展示了试图控制疫情的历史。我们几乎控制住了它(大绿条)，然后我们回落(短绿条，或短红条)。然后我们几乎再次遏制它，然后我们再次回落。你可以看到我们经历了三次这样的循环。

每周看看下面的测试和死亡的对数图是很有趣的。这些图表的不同寻常之处在于，它们没有在 x 轴(水平轴)上绘制时间。x 轴是死亡或阳性检测的累计数，y 轴是递增的周数。

这些图表也以不同的方式讲述了疫情的故事。你可以看到疫情指数达到峰值，开始下跌，然后再次达到稍低的峰值，然后再次开始下跌。至少这是下面死亡图表上的故事。

阳性测试图表上的故事看起来像是阳性测试开始有轻微的第三次上升。如果这是真的，我们预计死亡人数将在阳性测试上升约两周后出现第三次上升。

状态图

有了基本的全国情况，我转向州一级的图表。第一张图显示了阳性测试中的人均趋势。标记的位置显示了前 7 天每 1000 人中阳性测试的数量。实线显示之前 7 天的趋势，空心线显示接下来 7 天的趋势。

关于这个图表有趣的是，这些州是从西到东，从左到右排序的。这使得观察病毒活动的地理聚集变得容易。

现在，你可以看到这个国家的东部相当平静。南方不太像东部那么安静，但还是比较安静的，除了 SC 和 NC。遥远的西部在东部和南部之间。

就病毒活动而言，这个国家的中部是最活跃的。中西部各州都很高，其中大多数在过去几周都在上升。事实上，整幅图中唯一向下移动的状态是 GA(用绿线显示)。

上图显示了人均基础上的病毒活动。下图显示了各州病毒活动的绝对值。水平线显示了一周前每个州的情况。如果一个州的横条在这条线上，趋势是向上的。如果棒线低于线，趋势是向下的。(图中各州是按字母顺序排列的，而不是从西向东。)

从人均来看，ND 可能是最活跃的，但 TX 的人数是它的 35 倍，所以从绝对数字来看，它很容易成为最活跃的，从这个图中很容易看出这一点。同样，从人均水平来看，加州相当安静，但拥有 4000 万人口，从绝对水平来看，它仍然是第二大城市。

线和棒线之间的关系使得很容易看到每个状态的趋势。FL 和 GA 呈下降趋势。CA 基本稳定。NC 趋势强劲上升。TX 仍呈明显上升趋势。大多数其他州保持稳定或略有上升趋势。

我还会查看我在自己的网站上提供的州仪表盘中的开放就绪分数汇总。开放准备分数是阳性测试的绝对数量、最近的测试趋势、每个州的疫情历史以及其他因素的组合。有时，开放就绪分数提供了其他图表没有提供的提示。它还提供了地理聚类的不同视图。

在这种情况下，该图非常清楚地显示，大部分病毒活动或多或少以落基山脉以西和密西西比河以东为界。

五月中旬，疫情集中在东北部。整个夏天，它都集中在最南端的州。现在疫情大部分已经转移到中西部。

大多数国家媒体对疫情的报道都集中在政治上，但我对数据的解读表明，疫情有一个有趣而重要的地理方面，但没有得到应有的关注。

真正严肃的高级图形阅读

最复杂的图表，但也可能是最能说明问题的，是长期比率图。这是一种奇怪的格式，将几个因素与它们的长期平均值进行对比。这意味着每条线都以 1.0 为中心，你可以研究这些线是如何相对于彼此上升和下降的。

如果你研究图表的左边，你可以看到蓝色的估计病例数直线上升和下降，红色的死亡人数直线在蓝色直线之后延迟上升和下降。这种模式在图的右侧重复出现，但级别较低。死亡滞后案例，这是你所期望的。

您可以看到阳性测试(蓝色虚线)和病例(蓝色实线)之间的关系。这些线相互跟踪(应该如此)，但是您可以看到测试与案例的比率在疫情的过程中是如何翻转的，图形右侧的阳性测试捕获的案例百分比比左侧高。

您还可以看到，到 7 月底，总测试行从左到右稳步增加。灰线的上升部分解释了为什么蓝色实线和蓝色虚线位置相反。

你也可以看到灰线在夏末的几个星期里保持平稳。与此同时，积极测试线在几周内呈下降趋势，之后总测试线呈下降趋势。对我来说，这表明测试并没有捕获很多实际案例，所以最终它减少了。如果总测试线下降，而阳性测试线落后于它，那么我会认为阳性测试数字被人为地缩小了。但图表显示的并非如此。

橙色的住院线很有趣，因为在图的左边，它落后于死亡人数。这没有任何意义，我认为这是一个数据质量问题。在疫情早期，各州报告的住院数据并不一致，但随着时间的推移，情况有所改善。

在图表的右侧，您可以看到橙色线紧紧跟随蓝色实线，这很有意义。红线跟踪但滞后于橙线，这也有道理。

这一切把我们带到了今天。我们现在的情况是，总测试数量急剧增加。阳性测试也在迅速增加，但没有总测试增加得快。这表明总的病毒活性持平甚至下降。住院线也在下降的事实也说明了同样的问题。

摘要

我喜欢视觉效果，我一直喜欢研究图表，试图从中提取尽可能多的信息。如果你在回答“它是上升还是下降”后停下来，你经常会错过图表试图传达的最重要的信息。这组图表总体上传达了一个关于美国疫情的过去、现在和潜在未来的相当全面的故事。

我的背景

在过去的 20 年里，我专注于理解软件开发的数据分析，包括质量、生产率和评估。我从处理噪音数据、坏数据、不确定性和预测中学到的技术都适用于新冠肺炎。

伟大的 CSV 对决:Julia vs Python vs R

原文：https://towardsdatascience.com/the-great-csv-showdown-julia-vs-python-vs-r-aa77376fb96?source=collection_archive---------5-----------------------

任何数据分析工作流程中的第一项任务就是简单地读取数据，这绝对必须快速有效地完成，这样才能开始更有趣的工作。在许多行业和领域中，CSV 文件格式是存储和共享表格数据的首选。快速而健壮地加载 CSV 是至关重要的，它必须能够很好地适应各种文件大小、数据类型和形状。这篇文章比较了三个不同 csv 解析器读取 8 个不同真实数据集的性能:R 的 fread、Pandas 的 read_csv 和 Julia 的 CSV.jl。这些解析器分别被选为每个 R 、 Python 和 Julia 的“同类最佳”CSV 解析器。多线程是当今计算机达到最高性能的关键，但只有一种语言(Julia)能够持续有效地使用多核。

这三个工具都支持加载各种可能丢失值的数据类型，但只有 fread (R)和 CSV.jl (Julia)支持多线程— Pandas 只支持单线程 CSV 加载。Julia 的 CSV.jl 的另一个独特之处在于，它是唯一一个完全用其高级语言实现的工具，而不是用 C 实现并从 R / Python 包装而来的。(Pandas 确实有一个稍微强一点的 Python 原生解析器，它明显慢一些，并且几乎所有 read_csv 的使用都默认为 C 引擎。)因此，这里的 CSV.jl 基准不仅代表了在 Julia 中加载数据的速度，而且还表明了在分析中使用的后续 Julia 代码可能的性能。

以下基准测试表明，即使在限制单核的情况下，Julia 的 CSV.jl 也比 Pandas 快 1.5 到 5 倍；启用多线程后，速度可以提高 20 倍以上。r 的 fread 更有竞争力，因为它支持多线程，但在许多数据集上它仍落后 Julia 10 倍或更多。用于基准测试的工具有:Julia 的 BenchmarkTools.jl ，R 的微基准测试，Python 的 timeit 。

同质数据

让我们从一些同质数据集开始，即所有列中具有相同类型数据的数据集。本节中的数据集，除了股票价格数据集之外，都是从基准站点的中获得的。性能指标是线程数量从 1 增加到 20 时加载数据集所用的时间。由于 Pandas 不支持多线程，单线程速度是针对所有内核计数的。

同质数据集上的性能:

统一浮点数据集:第一个数据集包含排列在 100 万行 20 列的浮点值。Pandas 加载这个文件需要 232 毫秒。单线程 data.table 比 CSV.jl 快 1.6 倍，有了多线程，CSV.jl 处于最佳状态，比 data.table 快一倍多，CSV.jl 比没有多线程的熊猫快 1.5 倍，有了大约快 11 倍。

统一字符串数据集(I) :该数据集包含所有列中的字符串值，有一百万行 20 列。Pandas 加载文件需要 546 毫秒。对于 R，添加线程似乎不会带来任何性能提升。单线程 CSV.jl 比 data.table 快 2.5 倍，10 线程时比 data.table 快 14 倍左右。

统一字符串数据集(二):该数据集的维度与上一个数据集的维度相同。但是，每一列也有缺失值。熊猫需要 300 毫秒。没有线程，CSV.jl 比 R 快 1.2 倍，有了，大概快 5 倍。

苹果股票价格:

该数据集包含 5000 万行和 5 列，大小为 2.5GB。这些行是 AAPL 股票的开盘价、最高价、最低价和收盘价。包含价格的四列是浮点值，还有一个日期列。

单线程的 CSV.jl 比 R 的 fread from data.table 快 1.5 倍左右，多线程的 CSV.jl 快 22 倍左右！熊猫的 read_csv 需要 34s 才能读完，这个比 R 和 Julia 都慢。

异构数据集上的性能

混合数据集:这个数据集有 10k 行，200 列。这些列包含字符串、浮点、日期时间和缺失值。Pandas 加载这个数据集大约需要 400 毫秒。没有线程的情况下，CSV.jl 比 R 快 2 倍，有 10 个线程的情况下快 10 倍左右。

抵押贷款风险数据集

现在，让我们来看一个更广泛的数据集。来自 Kaggle 的这个抵押贷款风险数据集是一个混合型数据集，有 356k 行和 2190 列。这些列是异构的，并且具有 String、Int、Float、Missing 类型的值。熊猫在这个数据集中需要 119 秒来读取。单线程的 fread 比 CSV.jl 快大约两倍，然而，如果有更多的线程，Julia 要么和 r 一样快，要么比 r 稍快。

宽数据集:这是一个相当宽的数据集，有 1000 行和 20，000 列。数据集包含字符串和整型值。熊猫读取数据集需要 7.3 秒。在这种情况下，单线程 data.table 比 CSV.jl 快大约 5 倍。由于线程较多，CSV.jl 与 data.table 相比具有竞争力。在 data.table 中，增加线程数量似乎不会带来任何性能提升

房利美收购数据集:该数据集可从房利美网站下载。数据集有 400 万行和 25 列，值的类型为 Int、String、Float、Missing。

单线程 data.table 比 CSV.jl 快 1.25 倍，但是，CSV.jl 的性能随着线程的增加而不断提高。CSV.jl 通过多线程获得了大约 4 倍的速度。

汇总图表:

在所有八个数据集上，Julia 的 CSV.jl 总是比 Pandas 快，即使人为限制为单核。借助多线程技术，Julia 几乎在每一个案例中都独占鳌头，而且常常以 10 倍或更大的优势胜出。r 的 fread 只在少数情况下能够跟上。

系统信息:执行基准测试的系统规格如下

$ lsb_release -a
没有 lsb 模块可用。
发行商 ID: Ubuntu
描述:Ubuntu 18.04.4 LTS
发布时间:18.04
代号:仿生

$ uname -a
Linux 南极 5 . 6 . 0-custom+# 1 SMP Mon Apr 6 00:47:33 EDT 2020 x86 _ 64 x86 _ 64 GNU/Linux

$ lscpu
架构:x86_64
CPU op-mode(s): 32 位， 64 位
字节顺序:小端
CPU:40
在线 CPU 列表:每核心 0–39
线程:每插槽 2
核心:10
插槽:2
NUMA 节点:2
厂商 ID: GenuineIntel
CPU 家族:6
型号:85
型号名称:英特尔(R)至强(R) 银 4114 CPU @ 2.20GHz
步进:4
CPU MHz: 800.225
CPU 最大 MHz: 3000.0000
CPU 最小 MHz:800.0000
BogoMIPS:4400.00
虚拟化:VT-x
L1d 缓存:32K
L1i 缓存:32K
L2 缓存:1024K
L3

free -h
总已用空闲共享缓冲区/可用缓存
Mem:62G 3.3G 6.3G 352k 52G 58G
Swap:59G 3.2G 56G

JuliaCon 今年上线，免费注册。JuliaCon 是一年中最大的 Julia 会议，汇集了来自世界各地的演讲者、开发者和爱好者，为期 3 天，充满了主题演讲、讲座和研讨会！在此注册！

数据市场长城

原文：https://towardsdatascience.com/the-great-data-market-wall-7824c89419c1?source=collection_archive---------70-----------------------

缺乏关于模型和脚本生产的内容。

首先，你完成一些在线课程。然后研究 Iris 数据集，解决泰坦尼克号的挑战。最后，在 Windows 任务计划程序上安排一些脚本。任何与数据打交道的人都会经历这些情况。如果你得到了一份数据方面的工作，很快你就会意识到你不能在你的笔记本电脑上运行一个关键的业务脚本。一天 24 小时都呆在办公室的那个。因此，我们去找基准测试，看一些谈话或读一些帖子，听到类似这样的话:

在我们公司，我们使用气流来编排 ETL 和机器学习。

因此，我们开始研究气流，以了解有关 Dag 和运算符的一切。然后我们意识到气流仍然在我们的笔记本电脑上运行。并且它与我们以前使用的旧任务调度器没有太大的不同。这个关键脚本一直在我们的机器上运行。所以一些开发者找到我们说:

您应该在 AWS EC2 上运行它。

所以我们找到文档，阅读一切，只理解任何东西。我们追求更多的在线课程，我们得到漂亮的证书在 LinkedIn 上展示。然而，我们学得越多，就越容易迷失。警告:要学习的技术数量随着岗位数量和完成的课程数量呈指数增长。

现在我们需要学习 Docker、Kubernetes、SageMaker、ECS、Git、Spark、Scala、VPC、Terraform、CircleCI、Lambda、APIs、MLFlow、NiFi、CloudWatch、Jenkins、DBT。看起来我们需要在 AWS 上运行该死的地狱气流之前了解所有这些。或者在将一些 ML 模型投入生产之前。同时，我们也找不到任何具体的、相关的内容来帮助我们前进。

祝贺你！你已经撞上了数据市场的长城。

数据市场长城。在 Unsplash 上由马克斯·勃姆拍摄的照片

这面墙是什么？

数据科学家的工作不是 80%的清理和 20%的建模。数据工程师的工作不仅仅是 ETL。责任要大得多。它们通常包括生产你的脚本和模型。

数据工作者的挑战和责任。作者配图。

然后你分析互联网上关于数据的内容。你注意到它不再适合你的学习需求，也不能帮助你解决一些特定的问题(比如生产代码)。对于已经达到这个阶段的人来说，没有太多可用的内容。这就是那堵墙。

有很多 clickbait 链接。也有一些针对初学者的课程、帖子和教程，它们经常兜售这样一种观点，即从事数据科学所需要的只是一个 Jupyter 笔记本。但是对于过了初级水平的人来说，内容就很少了。没有太多的帖子教人们如何FQ生产他们的模型。

很少有帖子和教程讨论数据的生产。没有任何科学依据的图表，仅仅基于我自己对现有内容的观察。图表由作者绘制，灵感来自 MLinProduction

可悲的现实是，如果你想把某样东西投入生产，那就只有你、上帝和文档了。这只有在文档写得很好的情况下才有效。

好消息是，一旦你越过了那堵墙，一切都开始变得容易、明显、快速和可重复。您将花费相当多的时间来创建您的第一个自动化部署脚本。从第二次往前，会快很多。

现在讨论墙为什么存在，稍微深入一点。我确实看到了两种解释:

有生产经验的人不会创造关于这个主题的内容。将代码投入生产需要大量的工作。通常，没有人会为了好玩而在周末创建生产化基础设施。人们每天都在工作中这样做，结果却没有写出来。当他们写的时候，通常是一些肤浅的东西，为公司的博客做宣传。
对于初学者来说，写关于生产化的文章要比写关于熊猫的文章困难得多，需要更多的工作。

怎么做才能FQ？

如果你感到不知所措，因为你认为你应该学习数万亿的新东西，那么冷静下来。深呼吸，试着遵循这些建议。

只研究需要的东西

如果你需要学习一些新技术，那么不要试图学习它提供的一切。只学习基础知识来熟悉它。假设您想在生产中部署一些 ML 模型:您可以研究一些框架，如 Serverless 或 Zappa。但只够你大致了解它们是如何工作的。

蛮力速度不快，但它能解决所有问题

学习完基础知识后，是时候尝试使用您所学的知识进行部署了。当然，你会失败。然后探索错误，好好利用谷歌，改变周围的东西，再试一次。重复直到你成功为止。你将会学到比任何课程或博客文章在一两周内所能教给你的更多的技术知识。您将学习到仅够部署您的模型的内容。但是你独自完成了，使用了蛮力，在每次迭代中，你都学到了新的东西。每犯一次愚蠢的错误，你就会获得更多的经验。

可能会出现这样的情况，您无法立即将该技术用于其他目的。但是如果你需要的话，你会准备得更好，学得更快。

请开发人员检查您的工作

当您认为某个产品已经可以投入生产时，请开发人员对其进行评审。他们习惯于对代码进行同行评审，并且知道许多您可以使用的良好实践。不要深入你正在执行的算法或脚本的细节。目标是了解您的代码是否已准备好投入生产。很有可能你会得到一张需要改进的地方的清单。

从我自己的经验来看，我可以说，让一个开发人员教你一些新东西并没有多大帮助。他们通常不会有时间握着你的手教你新技术。例外的是他们日常使用的工具，比如 Git 和 CircleCI。但是即使他们帮助了你，你也可能只擅长一些介绍性的课程。之后又是蛮力法。

试着想想边缘案例

如果我的 API 有 1000 个并发请求，会发生什么？如果 ETL 作业中途失败了，我会丢失或有重复的数据吗？如何快速识别作业是否停止工作？我如何知道我的 ML 模型正在运行，但返回不正确的结果？如果我的 API 收到一个无效的有效负载怎么办？

思考边缘案例将有助于您预测这些问题的解决方案。它们发生的频率超乎你的想象。

学习并应用软件开发最佳实践

当您创建将在生产中运行的数据项目时，请尝试应用一些最佳实践:

基础设施作为代码
YAML 配置
持续集成(CI/CD)
单元测试
警报和监控
证明文件

如果每次需要重新部署时都需要停止所有作业并手动启动一个新实例，那么您的代码就不是生产就绪的。如果您需要修改代码来更改一些配置，因为它是硬编码的，那么您的项目也不是生产就绪的。

YAML 文件是存储配置的好方法。小心不要成为全职 YAML 工程师。图片来源:imgflip.com

如何学习最佳实践？

为一家已经这样做的公司工作，从例子中学习。看看其他人如何生产他们的代码。
或者错误地学习，做一些可以通过最佳实践轻松避免的事情。
或者创建周末项目。不要只训练模型来预测房价，而是将其部署到类似生产的环境中。自动化部署，创建测试和警报，写下适当的文档。在那之后，发表一篇你是如何做到的博文！

我们应该怎么做才能推倒这堵墙？

如果你已经越过了那堵墙，你可以为那些已经学会了基本知识，但不知道如何生产的公众创造内容。撰写教程、博客文章或创建公共存储库来帮助其他人穿越这堵墙。

前段时间，我花了将近一个月的时间尝试在 AWS 上部署生产中的气流。我只能在我的机器上找到教如何使用 Docker 的基本内容。经过大量研究，我发现了一个 repo，它帮助我在 ECS 上使用 Terraform 部署它。但它仍然没有我们对生产环境的所有特定需求，例如自动伸缩。最近，我发表了一份回购协议，解决了其中一些问题。如果我花了将近一个月的时间，我想其他人也会这样做。那么为什么不帮助他们呢？

建立桥梁来帮助人们渡过职业生涯中这个充满挑战的阶段对每个人都有好处。

发布内容:的人会加深知识，完善作品集。

那些正在忍受穿越高墙之苦的人将更快地学会生产和应用最佳实践。

你更喜欢有生产观念的人加入你的团队吗？或者您更愿意开始教导他们任务计划程序不是一个可行的选择？

羟氯喹大辩论

原文：https://towardsdatascience.com/the-great-hydroxychloroquine-debate-29f2a2a47587?source=collection_archive---------14-----------------------

羟氯喹和阿奇霉素有 91.7%的成功率——好得难以置信？对最新数据的评论。

羟氯喹是新冠肺炎讨论中的最新流行词。正如我之前所写的，找到一种有效的治疗方法可以极大地改变我们全球应对疫情的轨迹。在 4 月 5 日周日的每日简报会上，川普总统问全国，你们会失去什么？并一直通过尝试权立法推动患者获得该药物。**

羟氯喹已在实验室中被证明通过阻止病毒进入细胞而有效对抗冠状病毒，包括 SARS 和新冠肺炎。然而，在试管中起作用的东西并不总是在人类身上起作用。在 SARS 病例中，羟氯喹未能降低小鼠体内的病毒载量。此外，经常服用羟氯喹治疗狼疮或关节炎的患者已经感染了新冠肺炎病毒——这表明它不是预防性的。然而，羟氯喹可能是一种有前途的治疗方法，是许多值得研究的疗法之一。

我个人希望羟氯喹，可能与阿奇霉素或锌结合，将在目前正在进行的临床试验中被证明有效。我们都想有所作为。然而，需要注意的是，羟氯喹，尤其是与阿奇霉素合用时，可能会导致视觉和心脏并发症，包括心律失常。所有的医生都在医学院宣誓——“不伤害”——并且在缺乏严格研究的情况下，对开出已知副作用的药物犹豫不决。事实上，法国和瑞典的医院最近已经停止了羟氯喹的临床试验，理由是缺乏益处会增加心脏风险。

关于最新羟氯喹数据的每日更新，我推荐药理学家德瑞克·洛夫博士的博客。总之，现有的数据是不确定的。大多数文章仍处于“预印阶段”——初步提交给期刊，可能尚未完成正式发表所需的同行审查过程。迪迪尔·拉乌尔博士最近发表的一份预发布的摘要和数据表引起了我的注意，并被纽约时报和福克斯新闻频道转载。

简而言之，拉乌尔博士已经成为一个有争议的人物，他倡导使用羟氯喹和阿奇霉素(HCQ AZ)来治疗新冠肺炎。他最初于 3 月 20 日发表了一组 42 名患者的阳性结果，其中 26 名患者服用了 HCQ AZ。这篇论文立即因其方法而受到批评，包括拉乌尔博士选择谁接受 HCQ-阿兹而不是安慰剂，以及排除任何在该方案中表现不佳的患者的分析。对数据的重新分析显示，考虑到方法的不一致性，没有任何益处。该杂志——国际抗菌化疗学会——的一份官方声明如下:“ISAC 认为这篇文章不符合该学会的预期标准，特别是缺乏对入选标准和患者分类的更好解释，以确保患者安全。”拉乌尔博士的第二篇论文是未经同行评审的预印本，根本不包括对照组。

然而，最初的研究引发了特朗普总统对羟氯喹的兴趣——他在 3 月 21 日发了关于羟氯喹的推特，并在他的每日简报中多次提到它。

书房

4 月 10 日，拉乌尔医生在他的推特上发布了一份预发布的摘要和数据表，总结了他在 1000 多名患者中的发现。下面，我将报告相关的发现(粗体)，然后是需要回答的方法问题和遗漏。

****在 3，165 名通过 PCR 诊断为新冠肺炎的患者中，有 1，061 名符合本研究的入选标准。入选标准是什么？为什么其他 2000 名患者被排除在外？值得注意的是，在这项研究中也没有对照组。黄金标准临床试验是随机双盲的——意味着患者和研究者都不知道谁在哪个组——以便可以评估匹配组中治疗的真实效果。在任何没有对照的研究中，我们不能确定观察到的结果是否仅仅是被选入研究的患者组的结果。
平均年龄 43.6 岁，标准差 15.6 。拉乌尔博士后来在他的结论中写道，HCQ AZ 对老年患者是一种安全有效的治疗方法。除了——标准差的数学计算告诉我，超过 84%的患者年龄在 59.2 岁以下。在世界范围内，目前的数据表明，60 岁以下患者的预期死亡率从年轻患者的 0.2%到 50-59 岁患者的 1.3%不等。换句话说，他的研究小组主要是年轻的患者，无论治疗与否，他们都有望获得良好的结果。很难找到法国住院新冠肺炎患者平均年龄的比较统计数据。在美国，住院病人的平均年龄估计在 50 多岁。这再次表明，他的研究小组被选来比平均水平更年轻、更健康。
973 名患者(91.7%)在 10 天内获得了良好的临床结果和病毒学治愈。良好的临床结果定义为第 10 天清除病毒脱落，避免住院> 10 天、ICU 转移或死亡。此外，注意到 4.4%的患者具有超过第 10 天的延长的病毒携带(在 PCR 上可检测到)，但是病毒培养阴性；在第 15 天，除了一个以外，所有都被 PCR 清除。
****46 例患者(4.3%)预后不良。这被定义为住院> 10 天(31 名患者)、ICU 转移(10 名患者)或死亡(5 名患者)。值得注意的是，死亡的 5 名患者年龄在 74-95 岁之间。在 31 名住院治疗> 10 天的患者中，有 16 名在本文发表时仍在住院治疗。总死亡率为 0.5%，另有 16 名(1.6%)患者住院。
****年龄越大，初始严重程度越差，HCQ 血清浓度越低，预后越差。还发现服用β-受体阻滞剂和血管紧张素ⅱ受体阻滞剂的患者预后更差。这些发现已在其他地方报道，并与全球临床经验一致。
****接受> 3 天 HCQ-阿兹治疗的患者死亡率低于在同一家医院(IHU)和马赛公立医院接受其他方案治疗的患者。该声明未经其他治疗方案和马赛公立医院的结果数据验证。
****在数据表中，作者补充说明只有 928 名患者的数据。最初报告的 1，061 名患者的 n 具有误导性，因为 56 名患者因无症状而被排除，77 名患者的数据缺失。

https://www . worldometers . info/coronavirus/coronavirus-age-sex-demographics/

结论

拉乌尔博士的最新出版物乍一看似乎非常有希望——10 天内治愈率为 91.7%，死亡率为 0.5%！然而，我担心的是缺乏一个控制组和病人选择过程缺乏透明度。有意或无意地选择更年轻、更健康的患者队列可能会导致极好的结果，而不管羟氯喹是否有效。我们需要完整的手稿来评估这个摘要是真的有希望还是误导。

黄金标准仍然是一项双盲、随机对照试验。我真诚地希望在不久的将来我们能从这样的试验中获得数据。

编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击这里。

T5 变压器多任务处理指南

原文：https://towardsdatascience.com/the-guide-to-multi-tasking-with-the-t5-transformer-90c70a08837b?source=collection_archive---------10-----------------------

T5 变压器可以执行任何 NLP 任务。它可以在同一时间使用同一型号执行多项任务。祝您身体健康

照片由马特·贝罗在 Unsplash 上拍摄

T5(文本到文本迁移转换器)模型是一项大规模研究的产物(论文)，旨在探索迁移学习的局限性。它建立在流行的架构之上，如 GPT、伯特和罗伯塔(仅举几个例子)模型，这些模型利用迁移学习取得了令人难以置信的成功。虽然可以对类似 BERT 的模型进行微调以执行各种任务，但体系结构的约束意味着每个模型只能执行一项任务。

通常，这是通过在 Transformer 模型之上添加一个特定于任务的层来实现的。例如，通过添加具有两个输出神经元(对应于每个类别)的全连接层，可以使 BERT 变换器适用于二进制分类。T5 模型通过将所有的自然语言处理任务重新组织为文本到文本的任务而背离了这一传统。这导致任何 NLP 任务的共享框架作为模型的输入，而模型的输出总是字符串。在二进制分类的例子中，T5 模型将简单地输出该类的字符串表示(即"0"或"1")。

由于任何 NLP 任务的输入和输出格式都是相同的，相同的 T5 模型可以被训练来执行多个任务！为了指定应该执行哪个任务，我们可以简单地在模型的输入前加上一个前缀(字符串)。谷歌人工智能博客文章中的动画(如下所示)展示了这一概念。

来自文章探索 T5 的迁移学习:文本到文本的迁移转换器

在本文中，我们将使用这种技术来训练一个能够执行 3 个 NLP 任务、二进制分类、多标签分类和回归的 T5 模型。

所有代码也可以在Github上找到。

任务说明

二元分类

自然语言处理中二元分类的目标是将给定的文本序列分成两类。在我们的任务中，我们将使用 Yelp 评论数据集将文本的情感分为正面("1")或负面("0")。

多标签分类

在多标签分类中，给定的文本序列应该用一组预定义标签的正确子集来标记(注意，该子集可以包括空集和标签本身的完整集)。为此，我们将使用有毒评论数据集，其中每个文本都可以用标签的任何子集来标记toxic, severe_toxic, obscene, threat, insult, identity_hate。

回归

在回归任务中，目标变量是一个连续值。在我们的任务中，我们将使用 STS-B(语义文本相似性基准)数据集，其目标是预测两个句子的相似性。相似性由0和5之间的连续值表示。

数据准备

因为我们将使用 3 个数据集，所以我们将它们放在data目录中的 3 个单独的子目录中。

data/binary_classification
data/multilabel_classification
data/regression

下载

下载 Yelp 评论数据集。
抽出train.csv和test.csv至data/binary_classification。
下载有毒评论数据集。
将csv文件解压到data/multilabel_classification。
下载 STS-B 数据集。
将csv文件解压到data/regression。

组合数据集

如前所述，T5 模型的输入和输出总是文本。通过使用前缀为的文本来指定一个特定的任务，让模型知道它应该对输入做什么。

简单变压器中 T5 模型的输入数据格式反映了这一事实。输入是一个熊猫数据帧，有 3 列— prefix、input_text和target_text。这使得在多个任务上训练模型变得非常容易，因为你只需要改变prefix。

上面的笔记本加载每个数据集，为 T5 对它们进行预处理，最后将它们组合成一个统一的数据帧。

这给了我们一个具有 3 个唯一前缀的数据帧，即binary classification、multilabel classification和similarity。注意前缀本身是相当随意的，重要的是确保每个任务都有自己唯一的前缀。模型的输入将采用以下格式:

<prefix>: <input_text>

*": "*是训练时自动添加的。**

其他一些需要注意的事项:

多标签分类任务的输出是预测标签的逗号分隔列表(toxic, severe_toxic, obscene, threat, insult, identity_hate)。如果没有预测到标签，输出应该是clean。
相似性任务的input_text包括两个句子，如下例所示；
sentence1: A man plays the guitar. sentence2: The man sang and played his guitar.
相似性任务的输出是一个介于 0.0 和 5.0 之间的数字(字符串)，增量为 0.2。(如0.0、0.4、3.0、5.0)。这与 T5 论文作者使用的格式相同。

从不同输入和输出的表示方式可以看出，T5 模型的文本到文本方法在表示各种任务和我们可以执行的实际任务方面为我们提供了很大的灵活性。

例如；

* [## 问正确的问题:在新任务中训练 T5 变压器模型

T5 转换器将任何 NLP 任务构造为文本到文本的任务，使其能够轻松学习新任务。让我们来教…

towardsdatascience.com](/asking-the-right-questions-training-a-t5-transformer-model-on-a-new-task-691ebba2d72c)

唯一的限制就是想象力！(嗯，想象力和计算资源，但那是另一回事了)😅

回到数据，运行笔记本应该会给您一个train.tsv和一个eval.tsv文件，我们将在下一节中使用它们来训练我们的模型！

设置

我们将使用简单变形金刚库(基于拥抱脸变形金刚)来训练 T5 模型。

下面给出的说明将安装所有的要求。

从这里安装 Anaconda 或 Miniconda 包管理器。
创建新的虚拟环境并安装软件包。
conda create -n simpletransformers python
conda activate simpletransformers
安装简单变压器。

参见安装 文档

培训 T5 模型

和往常一样，用简单的变形金刚训练模型非常简单。

这里使用的大多数参数都相当标准。

max_seq_length:选择时不截断大多数样本。增加序列长度会极大地影响模型的内存消耗，因此通常最好尽可能地缩短序列长度(最好不要截断输入序列)。
train_batch_size:越大越好(只要适合你的 GPU)
eval_batch_size:同train_batch_size
num_train_epochs:超过 1 个历元的训练可能会提高模型的性能，但它显然也会增加训练时间(在 RTX 泰坦上每个历元大约 7 个小时)。
我们将根据测试数据定期测试模型，看看它是如何学习的。
evaluate_during_training_steps:前述测试模型的时期。
evaluate_during_training_verbose:测试完成后显示结果。
use_multiprocessing:使用多处理大大减少了标记化所花费的时间(在训练开始前完成)，但是，这目前会导致 T5 实现的问题。所以，暂时没有多重处理。😢
fp16 : FP16 或混合精度训练减少了训练模型的内存消耗(意味着更大的批量是可能的)。不幸的是，fp16训练目前与 T5 不稳定，所以也被关闭了。
save_steps:设置为-1表示不保存检查点。
save_eval_checkpoints:默认情况下，在训练过程中进行评估时，会保存一个模型检查点。因为这个实验只是为了演示，所以我们也不要浪费空间来保存这些检查点。
我们只有一个纪元，所以没有。也不需要这个。
reprocess_input_data:控制是否从缓存加载特征(保存到磁盘)或是否对输入序列再次进行标记化。只有在多次运行时才真正重要。
overwrite_output_dir:这将覆盖任何先前保存的模型，如果它们在相同的输出目录中。
wandb_project:用于培训进度的可视化。

说到可视化，你可以在这里查看我的训练进度。为他们令人敬畏的图书馆大声喊出来！

测试 T5 型号

考虑到我们正在处理多个任务的事实，使用合适的度量来评估每个任务是一个好主意。考虑到这一点，我们将使用以下指标:

二元分类: F1 得分和准确度得分
多标签分类:F1 分数(拥抱脸队指标实现)和精确匹配(拥抱脸队指标实现)
相似度:皮尔逊相关系数和斯皮尔曼相关

请注意，在准备数据时，在prefix和input_text之间插入了一个": “。这是在训练时自动完成的，但需要手动处理以进行预测。

如果你想了解更多关于解码论点的内容( *num_beams* ， *do_sample* ， *max_length* ， *top_k* ， *top_p* )，请参考本文。

是时候看看我们的模型做得如何了！

*-----------------------------------
Results: 
Scores for binary classification:
F1 score: 0.96044512420231
Accuracy Score: 0.9605263157894737Scores for multilabel classification:
F1 score: 0.923048001002632
Exact matches: 0.923048001002632Scores for similarity:
Pearson Correlation: 0.8673017763553101
Spearman Correlation: 0.8644328787107548*

尽管在 3 个独立的任务上进行训练，该模型在每个任务上表现得相当好！在下一节中，我们将快速了解一下如何进一步提高模型的性能。

结束语

可能的改进

混合任务时出现的一个潜在问题是用于每个任务的数据集大小之间的差异。通过查看训练样本计数，我们可以在我们的数据集中看到这个问题。

*binary classification        560000
multilabel classification    143613
similarity                     5702*

数据集在本质上是不平衡的，任务similarity的困境看起来尤其可怕！这可以在评估分数中清楚地看到，其中similarity任务落后于其他任务(尽管重要的是要注意，我们而不是在任务之间查看相同的指标)。

对这个问题的一个可能的补救方法是对similarity任务进行过采样，以便模型。

除此之外，增加训练历元的数量(以及调整其他超参数)也有可能改进模型。

最后，调整解码参数也可以得到更好的结果。

包扎

T5 模型的文本到文本格式为将 Transformers 和 NLP 应用于各种各样的任务铺平了道路，几乎不需要定制。T5 型号性能强劲，即使在使用同一型号执行多项任务时也是如此！

希望在不久的将来，这将导致许多创新的应用。

参考

用统一的文本到文本转换器探索迁移学习的极限—https://arxiv.org/abs/1910.10683
谷歌人工智能博客—https://AI . Google Blog . com/2020/02/exploring-transfer-learning-with-t5 . html*

我们为什么需要数据产品经理的事实

原文：https://towardsdatascience.com/the-hard-truth-of-why-we-need-data-product-managers-a53e8a7250b4?source=collection_archive---------46-----------------------

这不仅仅是天马行空的想法——这是一个探索无限可能性的过程

我自己画的大虚空——死亡谷

对于大多数产品经理来说，数据是最重要的。模型将主宰世界，最大的赢家是那些由模型驱动的组织，它们制造收集数据的产品，并不断学习优化增长，从而加速这一循环。但这一现象的背后是，任何成功模型的核心都是代表性数据。虽然这个想法和最终产品对季度 OKRs 来说可能是令人敬畏和伟大的，但它需要很多不性感的努力。就像软件一样，数据需要自己的框架来管理这一过程，以取得成功的结果——数据产品经理如是说。

数据产品经理案例

我喜欢把技术解决方案想象成玛雅——印度哲学对事实和事件的综合世界的术语，通过测量、分类、划分等抽象概念强加给世界。这些解决方案的生命周期是它自己的一种技术因果关系(有点像技术债务)——任何时候我们构建一个解决方案，它都需要质量控制、维护、扩展的进一步行动。将技术玛雅强加于世界的行为本质上是反平衡的，给团队和客户造成了因果报应。

根据这种观点，任何好的产品经理的角色都是挑选正确的问题，将它们与正确的解决方案相匹配，并为团队修整斜坡。了解运行在代表性数据上的模型的“优点”也没什么不同:虽然一个成功的模型的优势是巨大的，但存在更大的复杂性黑洞的可能性。

数据不再只是制作报告，数据正在成为自己的产品领域，拥有自己的交付成果、客户、开发生命周期和基础架构需求。为了满足期望并避免单干希望最好的分析的混乱，我们需要产品经理来指导这些数据产品从构思到完成。

什么是数据产品管理？

“产品管理”，尤其是“数据”，是模糊不清的。让我们定义一下那是什么。

一些组织区分更具战略性和以客户为中心的“产品经理”和更注重实现的“产品所有者”值得庆幸的是，有一个小型的博客家庭产业贬低这种“横向”模式，因为我们遇到了这样一种情况，产品负责人不理解客户，产品经理也不知道技术上什么是可能的。最终结果是:

无视客户的产品所有者努力向工程师交付好的需求，或者更糟，放弃对工程路线图的完全控制，这通常会导致内讧、价值损失，甚至可能失去工作。
技术盲的产品经理向客户交付低质量的产品(他们甚至可能没有足够的深度去认识到这一点)。

我们试图建立明确的责任，这很好，但我们最终以一场高风险的电话故障游戏而告终。

我们需要能够将商业案例和技术细节联系起来的产品经理，作为客户和工程师的合作伙伴。这意味着产品经理承担更大的端到端角色，专注于产品战略、优先顺序、解决方案和交付。当然，产品经理不能做所有的事情，这就是产品运营/分析师的作用，他们充当与客户的日常接口，评估问题的优先级，并确保通过 UAT 和推广顺利交付解决方案。

这对任何产品团队都有意义，但对数据产品团队更是如此。因为数据产品基本上是现实的模型，所以产品经理应该接触客户的现实，而且能够使技术解决方案适应现实。数据产品经理应该能够从头到尾看到技术概念，与前端产品团队合作收集有用的数据，在 ETL 过程中使用数据工程，在模型开发中使用 ML 工程，一直到部署。在这一点上，数据产品经理负责数据产品生命周期中的以下阶段:

产品经理识别可以和应该建模的机会——这是数据产品战略。
确定优先顺序应该是一项共同的工作，一部分是倾听客户的意见，一部分是与分析师一起确定问题的大小，由产品经理来设定预期，即投入多少精力就能建立什么样的模型。
解决问题是一个友好的制衡游戏。产品经理创建概念规格(数据流、实体关系图、用户故事)，工程师戳洞(“你错过了这个边缘案例”)，产品经理卷入任何过度工程(“为什么我们需要 Spark 来做这个”)，两人最终就技术设计和时间表达成一致。对于 ML 工程师来说，这更侧重于问题框架和数据探索，但也可以看作是一个类似的过程。
在交付阶段，团队将设计分解成任务，管理冲刺，运行测试，并根据设计和时间表全面执行。然而，随着复杂性的增加，事情从来没有这么简单——这需要它自己的策略来优先考虑和减轻这些问题。最后，产品经理与产品运营/分析师合作，对解决方案进行用户验收测试，并确保向客户成功展示。

数据产品基本上是现实的模型，对现实建模是困难的。随着这些模型变得越来越普遍，我们需要优秀的数据产品经理在一线领导这个过程，我们需要清楚这个过程是什么。我希望这篇文章有助于澄清这需要什么。

英雄崛起:打造自己的 SSD

原文：https://towardsdatascience.com/the-hero-rises-build-your-own-ssd-febfbdd3bd03?source=collection_archive---------52-----------------------

现实世界中的数据科学

深度学习代码库系列的英雄之旅——IIB 部分

由丹·马洛万尼和加尔·海姆斯
创作的快板艾团队

随着最先进的模型不断变化，人们需要有效地编写模块化的机器学习代码库，以支持和维持 R&D 机器和深度学习多年的努力。在本系列的第一篇博客中，我们展示了如何编写一个可读和可维护的代码来训练 Torchvision MaskRCNN 模型，利用 Ignite 的框架。在我们的第二篇文章(IIA 部分)中，我们详细介绍了单触发和双触发探测器之间的根本区别，以及为什么单触发方法是速度/精度权衡的最佳选择。因此，在这篇文章中，我们很自然地收集了如何利用 MaskRCNN 代码库的模块化特性，并使其能够训练 MaskRCNN 和 SSD 模型。由于代码库的模块化性质，只需要对代码进行最小的修改。

Torchvision 是一个由流行的数据集、模型架构和计算机视觉的通用图像转换组成的包。除其他外，它还包含一个预先训练好的模型动物园，用于图像分类、对象检测、人物关键点检测、语义分割和实例分割模型，随时可供开箱即用。这使得 PyTorch 用户的生活变得更加容易，因为它缩短了想法和产品之间的时间。或者一篇研究论文。或者一篇博文。

Torchvision 不包含单镜头对象检测模型的实现，例如这个流行的 SSD 。因此，我们添加了一个:基于 Torchvision 模型的 SSD 实现，作为特征提取的主干。自发布以来，在最初的 SSD 上进行了许多改进。然而，为了清晰和简单起见，我们将重点放在了最初的 SSD 元架构上。让我们深入研究一下实现的逻辑和方法。完整的代码可以在 Github 上获得。

常量:从默认值开始

首先，我们把手电筒放在代码常量上，它们是 SSD 类构造函数的默认输入参数。这些是为 PASCAL-VOC 数据集定制的 512×512 输入图像的常见值。(在本系列的第三部分中，我们将演示如何根据您自己的数据集调整这些值)

图 1: SSD 元架构和多特征图计算— SSD 论文

这些列表中的每一个包含 7 个条目——每个特征图一个条目，从该特征图中进行对象检测(见上面的图 1 )。注意，列表之一 BOX_SIZES 有 8 个条目，实际的框尺寸计算是基于这些值执行的。

如图 2 (上图)所示，矩形和方形锚点平铺特征图。 aspect_ratio 列表包含每个特征图的矩形纵横比列表。这个列表中的每个数字为每个先前的中心定义了两个矩形:一个具有提到的纵横比，另一个具有相反的纵横比。也就是说，对于每个 2:1 的“躺着的”矩形锚，我们也有一个 1:2 的“站着的”矩形锚。除了矩形锚之外，两种尺寸的方形锚被设置在每个先前的中心上。

*# The size ratio between the current layer and the original image.
# I.e, how many pixel steps on the original image are equivalent to a single pixel step on the feature map.*

STEPS = (8, 16, 32, 64, 128, 256, 512)

*# Length of the smaller anchor rectangle, for each feature map.*

BOX_SIZES = (35.84, 76.8, 153.6, 230.4, 307.2, 384.0, 460.8, 537.6)

*# Aspect ratio of the rectangular SSD anchors, besides 1:1*

ASPECT_RATIOS = ((2,), (2, 3), (2, 3), (2, 3), (2, 3), (2,), (2,))

*# feature maps sizes.*

FM_SIZES = (64, 32, 16, 8, 4, 2, 1)

*# Amount of anchors for each feature map*

NUM_ANCHORS = (4, 6, 6, 6, 6, 4, 4)

*# Amount of each feature map channels, i.e third dimension.*

IN_CHANNELS = (512, 1024, 512, 256, 256, 256, 256)

SSD 类构造函数

这个 SSD 类产生一个基于 Torchvision 特征提取器的 SSD 对象检测模型，参数如上所述。

**class SSD**(nn.Module):
   **def __init__**(**self**, backbone, num_classes, loss_function,
                num_anchors=NUM_ANCHORS,
                in_channels=IN_CHANNELS,
                steps=STEPS,
                box_sizes=BOX_SIZES,
                aspect_ratios=ASPECT_RATIOS,
                fm_sizes=FM_SIZES,
                heads_extractor_class=HeadsExtractor):

**super**(SSD, **self**).__init__()
...
**self**.extractor = heads_extractor_class(backbone)
**self**.criterion = loss_function
**self**.box_coder = SSDBoxCoder(self.steps, self.box_sizes, self.aspect_ratios, **self**.fm_sizes)

**self**._create_heads()

创建分类和本地化负责人

下面，我们首先将特征映射的分解从 SSD 模型中分离出来，使 SSD 能够轻松适应调整后的特征映射提取器。如果您确实要修改 SSD，那么在调用 SSD 构造函数时，不要忘记修改相关的参数。

class HeadsExtractor(nn.Module):
   def __init__(self, backbone):
       super(HeadsExtractor, self).__init__()

       def split_backbone(net):
           features_extraction = [x for x in net.children()][:-2]

           if type(net) == torchvision.models.vgg.VGG:
               features_extraction = [*features_extraction[0]]
               net_till_conv4_3 = features_extraction[:-8]
               rest_of_net = features_extraction[-7:-1]
           elif type(net) == torchvision.models.resnet.ResNet:
               net_till_conv4_3 = features_extraction[:-2]
               rest_of_net = features_extraction[-2]
           else:
               raise ValueError('We only support VGG and ResNet')
           return nn.Sequential(*net_till_conv4_3), nn.Sequential(*rest_of_net)

       self.till_conv4_3, self.till_conv5_3 = split_backbone(backbone)
       self.norm4 = L2Norm(512, 20)

       self.conv5_1 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)
       self.conv5_2 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)
       self.conv5_3 = nn.Conv2d(512, 512, kernel_size=3, padding=1, dilation=1)

       self.conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)
       self.conv7 = nn.Conv2d(1024, 1024, kernel_size=1)

       self.conv8_1 = nn.Conv2d(1024, 256, kernel_size=1)
       self.conv8_2 = nn.Conv2d(256, 512, kernel_size=3, padding=1, stride=2)

       self.conv9_1 = nn.Conv2d(512, 128, kernel_size=1)
       self.conv9_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2)

       self.conv10_1 = nn.Conv2d(256, 128, kernel_size=1)
       self.conv10_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2)

       self.conv11_1 = nn.Conv2d(256, 128, kernel_size=1)
       self.conv11_2 = nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2)

       self.conv12_1 = nn.Conv2d(256, 128, kernel_size=1)
       self.conv12_2 = nn.Conv2d(128, 256, kernel_size=4, padding=1

SSD 模型共享所有的分类和定位计算，直到最终的内容分类器和空间回归器。 create_heads 方法在每个特征图的顶部创建 SSD 分类和定位头，产生每锚预测。对于每个锚，定位头预测向量移位和拉伸(cx，xy，w，h)，而分类头预测每类概率的向量。

**def _create_heads**(**self**):
       **self**.loc_layers = nn.ModuleList()
       **self**.cls_layers = nn.ModuleList()
       **for** i **in** **range**(**len**(**self**.in_channels)):
 **self**.loc_layers += [nn.Conv2d(**self**.in_channels[i], **self**.num_anchors[i] * 4, kernel_size=3, padding=1)]
 **self**.cls_layers += [nn.Conv2d(**self**.in_channels[i], **self**.num_anchors[i] * **self**.num_classes, kernel_size=3**,** padding=1)]

SSD 模型从最高分辨率到最低分辨率建立了一个特征图的层次结构，并检测每个特征图上的对象。头部提取器类放置特征地图，并使其可用于检测器。其命名基于 VGG-16 特征提取器(其中 conv4_3 是用作 SSD 模型特征图的最高分辨率层的名称)。

不同的数据集和影像大小最适合调整后的要素地图等级；小图像不需要像大图像那样多不同的特征地图。类似地，没有小对象的数据集可以避免高分辨率的特征地图(加速模型计算时间)。

定义 SSD 正向传递

在下面的方法中，计算 SSD 模型上的图像批次的正向传递，并返回其结果。

如果模型处于评估模式，则正向传递返回输入图像上的模型预测。但是，如果在训练模式下进行正向传递，则只返回损失。这是一种常见的设计，它只返回损失，比返回所有检测的计算效率更高。

使用这种方法， extracted_batch 参数保存图像批次的布局特征图，然后分别计算跨每个特征图的预测。

**def forward**(**self**, images, targets=None):
       **if** **self**.training **and** targets **is** None:
           **raise** ValueError("In training mode, targets should be passed")
       loc_preds = []
       cls_preds = []
       input_images = torch.stack(images) **if** **isinstance**(images, **list**) **else** images
       extracted_batch = **self**.extractor(input_images)
       **for** i, x **in** **enumerate**(extracted_batch):
           loc_pred = **self**.loc_layers[i](x)
           loc_pred = loc_pred.permute(0, 2, 3, 1).contiguous()
           loc_preds.append(loc_pred.view(loc_pred.size(0), -1, 4))

           cls_pred = **self**.cls_layers[i](x)
           cls_pred = cls_pred.permute(0, 2, 3, 1).contiguous()
           cls_preds.append(cls_pred.view(cls_pred.size(0), -1, **self**.num_classes))

       loc_preds = torch.cat(loc_preds, 1)
       cls_preds = torch.cat(cls_preds, 1)

      **if** **self**.training:
           encoded_targets = [**self**.box_coder.encode(target['boxes'], target['labels']) **for** target **in** targets]
           loc_targets = torch.stack([encoded_target[0] **for** encoded_target **in** encoded_targets])
           cls_targets = torch.stack([encoded_target[1] **for** encoded_target **in** encoded_targets])
           losses = **self**.criterion(loc_preds, loc_targets, cls_preds, cls_targets)
           **return** losses

       detections = []

       **for** batch, (loc, cls) **in** **enumerate**(**zip**(loc_preds.split(split_size=1, dim=0),

                                              cls_preds.split(split_size=1, dim=0))):

           boxes, labels, scores = **self**.box_coder.decode(loc.squeeze(), F.softmax(cls.squeeze(), dim=1))

           detections.append({'boxes': boxes, 'labels': labels, 'scores': scores})

       **return** detections

将 SSD 模型连接到代码库

为了调整 MaskRCNN 代码库的训练和评估脚本，并使其能够训练 MaskRCNN 和 SSD 模型，我们将以下条目添加到配置数据中(手动或通过 Trains Server web app)。

'model_type': 'ssd', 'ssd_backbone': 'resnet50'

如果您查看一下 train 脚本，您会发现除了上述配置数据更改之外，原始 MaskRCNN 脚本和新脚本(也支持 SSD)之间的唯一区别是模型对象定义部分:

*# Get the relevant model based in task arguments*

   **if** configuration_data.get('model_type') == 'maskrcnn':
       model = get_model_instance_segmentation(num_classes, configuration_data.get('mask_predictor_hidden_layer'))
   **elif** configuration_data.get('model_type') == 'ssd':
       backbone = get_backbone(configuration_data.get('backbone'))
       model = SSD(backbone=backbone, num_classes=num_classes, loss_function=SSDLoss(num_classes))
       model.dry_run(torch.rand(size=(1, 3, configuration_data.get('image_size'), configuration_data.get('image_size')))*255)
   **else**:
       **raise** ValueError('Only "maskrcnn" and "ssd" are supported as model type')

这意味着这个代码库中所有剩余的资产都保持不变。从 R&D 资源的角度来看，这是一个巨大的优势。

本系列第一部分中的训练脚本和本文中的训练脚本的比较，展示了这个代码库的模块化本质。

快板火车——坐下来，放松和监控你的实验

培训期间 Trains web app 的快照，显示标量(损失、学习率等。)前进

与原代码库一样，使用 Allegro Trains ，一个开源实验& autoML manager，让我们实时监控训练过程，包括:学习率、损耗、val 数据集上的 mAP 等。此外，Allegro Trains 会在训练过程中自动监控 CPU、GPU 和计算机信息。这一重要工具有助于识别内存泄漏、硬盘空间不足、GPU 利用率低等问题。

由于包括脚本参数在内的所有这些信息都记录在 Trains 服务器中，因此可以比较不同的训练课程，并识别出产生优异结果的超参数。

结论

在上一篇文章(IIA) 中，我们深入探讨了单触发探测器相对于双触发探测器的优势。在这里，我们将这些知识编写成代码，并在 Torchvision 预训练的 backbone 之上创建一个 SSD 模型，您可以根据自己的目的使用它。此外，我们展示了遵循本系列指南编写可维护的模块化代码库的优势。

完整代码可在 Github 上获得。这里介绍的 SSD 类的部分是基于这个写得很好的 SSD 实现。谢谢匡柳😉

在下一篇文章中，我们将向您展示如何优化 SSD 模型，并根据您的数据进行调整。敬请期待！

原载于 2020 年 4 月 19 日https://allegro . ai。

Python 的隐藏类

原文：https://towardsdatascience.com/the-hidden-class-of-python-9bbafcf05abc?source=collection_archive---------36-----------------------

由 Nam Hoang 在 Unsplash 上拍摄的照片

在本文中，我们将探索 python 的两个强大特性，它们存在于标准库中，但由于缺乏宣传而几乎总是被忽略。

数据类

最近，我有幸获得了代码审查。在其他程序员检查我的代码的错误、瑕疵和其他编程小精灵的过程中，不止一个人(实际上是两个)问过这是怎么回事:

@dataclass
class Car:
 doors: int
 …

在 Python 3.7+的上下文中，“this”是一个数据类，一个很少有人遇到的强大而有趣的特性。不管外表如何，它也是有效的代码，这总是一个优势。在 Python 中引入数据类是为了尽可能快地编写代码，同时减少重复，使代码看起来更专业。它只需要定义要存储的数据就可以实现这一点。定义数据变得很容易，我们只需在数据类缩进中列出变量。当然，其他所有事情都是以内部优化的方式为我们完成的，最显著的是包括 init 构造函数方法的创建、所有变量的赋值以及其他一些东西。一个完整的例子就这么简单:

from dataclasses import dataclass@dataclass 
class Car:
 doors: int
 windows: int
 paint_work: str

只需几行代码，我们就可以创建和初始化实例、赋值并免费创建访问器方法。我们可以用命名参数或位置参数创建每个新的实例对象，Python 会理解我们传递的内容，并给正确的变量赋值。

mustang = Car(doors=4, windows=8, paint_work=”black”)
mustang = Car(4, 8, “black”)

上面的两个初始化调用都创建了一个有效的新“Car”data class 对象，可以用点(.)语法:

print(“My mustang is {}”.format(mustang.paint_work))

我们受益于将这一点推进到我们的编码工具箱中，因为我们的脚本变得更可读和更快，正如我们所讨论的那样，但这还不是全部。我们还获得了许多其他“特殊”的 python 方法。dataclass 附带了一个 repr 方法，用于将类表示为字符串，一个相等测试方法 eq 和其他允许 dataclass 对象比较的方法。这意味着我们可以编写清晰的语句，如 mustang > dodge，并让它返回一个 bool。回到 repr 方法，我们能够打印一个实例(字面意思是 print(mustang))并实际看到一些有用的东西！

print(mustang)[Out]: Car(doors=4, windows=2, paint_work=’black’)

这是一个大问题，因为当我们试图打印一个“普通”类时，默认的输出是令人惊讶的无用:

[Out]: <__main__.BadCar object at 0x7f0be5c96190>

浏览文档(https://docs.python.org/3/library/dataclasses.html)是很有价值的，因为有大量更具体的功能和用例，可以很好地探索和应用到项目的需求中。

装修工

简而言之，让我们探索一下在编写数据类时会发生什么。首先，我们用@dataclass 装饰器‘装饰’这个类(这难道不是一个很好的清晰的循环解释吗)。真正的装饰者本身就值得写一整篇文章，因为他们提供了一种方法来截取和修改对象/方法的输入和输出，同时保留所有原始方法的代码。它们通常被描述为方法包装器。将一种或多种方法与另一种方法包装在一起有助于使代码看起来更专业，并减少重复。

类型化变量

类属性(我们通常必须通过 self.our_attribute = "cow "来定义)是用 int 和 strings 类型化的。我不得不承认，在 python 中，类型化看起来很奇怪，但它是区分数据类字段和静态属性(也称为静态变量)的一种简单方法，并且在访问数据源和在 ide 中完成代码时都可以从类型化中受益。如果我们不为数据类提供变量类型(例如，只有 doors = 4)，我们就不会创建数据类字段，而是创建一个静态属性。静态属性错过了 init 函数中自动赋值的好处和所有其他优点。另一方面，静态属性的默认值特性可以应用于数据类(wheels: int = 4)。我们只是在类型后面提供了一个默认值，这意味着如果 init 构造函数没有为一个具有默认值的字段传递一个参数，那么该字段将毫无疑问地采用默认值。

命名的元组

另一个具有特殊 python 功能的隐藏对象是命名元组。数据类提供了许多简洁的特性，但是默认情况下，它们不能像列表或数组那样被索引(可下标的，像 mustang[2])。通过用 getitem(self，I)的签名实现 getitem 方法，我们可以很容易地为任何类添加索引功能，其中“I”是我们要返回的列表/数组中的项目的索引。然而，NamedTuples 提供了一种更简单的无类方法，只需一行代码就可以实现双重访问:

from collections import namedtuple
Coordinate = namedtuple(“Coordinate”, (“x”, “y”))
point = Coordinate(3, 7)print(point.x)
print(point[0])

两个打印语句给出了相同的结果。如果您处理的是类似坐标类型的东西，通过索引和名称方便地访问对象是有益的，那么这就很有用。导入 namedtuple 后，我们创建了 namedtuple 的类型,方法是将其名称指定为字符串，将其变量的名称指定为元组内的字符串。通过索引和点语法联合访问的好处是清晰。通过点语法访问和分配的变量很清楚(索引可读性差，更容易出错)，另一方面，我们仍然受益于循环和数学运算中的索引，在这些运算中，使用名称访问会导致重复代码，因为只有变量的名称会被更改。

可供选择的事物

虽然在任何编程语言中发现新的有用的工具都是非常令人兴奋的。)，一旦我们冷静下来，我们可能会问自己为什么不使用字典？

car = {"doors": 0，" windows": 4，" paint_work": "red"}

虽然字典确实工作得很好，但字典也会带来问题。首先，像任何动态定义的类型一样，特别是当使用字符串访问器时，字典的查找和赋值很慢，因为每个操作都需要解析关键字符串。它们也很难翻译成 C 之类的语言，并且无法从将 Python 代码编译成 Cython 所带来的速度提升(减少执行时间)中获益。更重要的是，通过使用字符串访问键，字典很容易出现运行时错误。因为不正确的密钥串只会产生运行时错误，所以程序只有在使用特定的错误密钥时才会崩溃。很容易写:

print(car[“colour”])
[Out]: KeyError: ‘colour’…

忘记了我们还没有在字典中添加颜色项，或者忘记了我们使用了“colour”的英式拼法，而真正的关键字是没有 u 的美式拼法。我们都容易犯拼写错误。

摘要

数据类允许简洁快速地定义对象和它们的字段变量，帮助我们编写干净的、分区化的代码。数据类是只有 Python 3.7+才有的新特性。

命名元组允许我们通过索引和点语法来访问数据，并且通常在所有 Python 3 版本中都可用。

字典通过关键字串提供访问，因此速度慢并且容易出现运行时错误。用数据类和命名元组替换我们的字典是有意义的。

脚注

1:如果你使用的是 Python <= 3.6，那么它就不是有效的代码，你将不得不对这篇文章感到愤怒，或者使用命名元组来代替。或者直接升级。

2:令人惊讶的是,“特殊方法”是这些默认方法的官方术语，而不仅仅是我自己的一个半生不熟的新词。

3:毕竟重要的是我们的代码看起来很好，尤其重要的是我们的代码在崩溃时看起来很好。

产品错误的隐性成本

原文：https://towardsdatascience.com/the-hidden-cost-of-errors-in-products-8cb75f34eb45?source=collection_archive---------71-----------------------

使用分析来跟踪您的客户没有报告的错过的机会

埃里克·麦克林在 Unsplash 上的照片

软件、服务或物理设备中的错误会阻止客户体验预期的功能。上图中的 404 错误代表了许多非技术用户已经习惯的一种情况，一个断开的链接将他们带到了一个并不存在的页面。

以下部分展示了错误如何导致错失机会的五个真实例子，以及防止未来发生的解决方案(人名和企业名省略)。

1.一个受欢迎的美容网站几乎因为广告拦截器而失去了一名顾客

在网站上购物时，一位客户喊道:“啊，[公司]的网站糟透了！”这个感叹的声音大得足以引起另一个人的注意和询问。

点击结帐按钮会把购物者带到一个部分空白的白色屏幕上，没有任何操作。旁观者的高级故障诊断步骤揭示了问题，而非技术人员无法做到这一点。广告屏蔽软件屏蔽了部分页面，保留了标题和主菜单。幸运的是，旁观者恢复了销售，但有多少购物者没有这种支持？

要点:一些顾客会发起反对公司的运动

百万美元的广告活动无法与朋友的口碑推荐相抗衡。一个体验不好的客户可能不只是告诉朋友，还会推荐以后的其他产品。这场竞赛免费获得了最好的广告。

在这个例子中，客户大声抱怨公司的失败。每个听的人都有一个微妙的和无意识的关于品牌缺陷的强化，即使情况得到了补救——想象一下如果没有的话。

解决方案:交互跟踪软件

跟踪软件可以洞察客户与网站的每一次互动。它可以准确地通知顾客何时离开结账流程。当有人遇到错误时，这些工具也会自动报告错误(在本例中，是内容被阻止的错误)。一旦发现问题，美容网站可以让自己遵守广告拦截软件，或者友好地要求客户在继续之前禁用它。

2.互联网服务提供商(ISP)因为第三方承包商而失去了一名客户

在更换 ISP 时，第三方承包商安装了一条新电缆，为即将到来的安装做准备，意外地切断了竞争对手的现有电缆。这使得客户在 COVID19 隔离期间无法连接互联网，无法工作(咖啡店不是一个选项)。承包商没有报告事故，客户取消了新服务。

总结:一次负面经历可能会失去一个客户

当竞争唾手可得时，像因电缆断裂而失去假期这样的负面经历，可能会导致客户永远不会回来。对于初次经历的人来说尤其如此，因为他们还没有赢得忠诚度。

竞争对手的产品或服务看起来会更好，即使它没那么强——因为它有效。

要点:错误可能不会被报告

对于 ISP 示例，工厂或软件更新中无法应用任何修补程序。行为错误来自第三方承包商，ISP 对此知之甚少。没有度量来跟踪未报告的错误。

要点:错误可能不止一个

ISP 的支持者没有阻止取消，也没有提供任何同情——这可能不是该公司的本意。培训支持人员的这一错误导致了一次机会的错失。

解决方案:客户服务培训

意外是会发生的，但不代表无法补救。通过要求客户服务代表询问取消原因，可以训练他们处理这些问题。

在上面的例子中，这种情况可以通过同情和折扣来解决。一个月的收入损失会比一生的收入损失更大。注明原因也能使他们对承包商进行罚款。

解决方案:业务分析

商业分析软件可以帮助弥补未报告的错误。分析师可以比较服务中最近的事件来查找取消…

承包商安装后
服务中断后
促销定价结束后

3。一家面包店因未能更新在线菜单而失去了一名顾客

这家面包店在 Instagram 上为一道特别的菜肴做了广告，这促使一位顾客从他们的网站上订购。不幸的是，过时的在线菜单没有列出新项目。订购的唯一方式是通过电话(由于 COVID19，无法亲自订购)。这笔买卖没有收回。面包店不仅损失了新菜的利润，而且顾客还计划购买菜单上的其他项目。这些项目本身不值得运费。

外卖:不是每个人都会求助

面包店忘记了内向的人，他们会不惜一切代价避免打电话。打电话询问丢失的菜肴是不值得的努力和焦虑。毕竟，他们选择网上订购是有原因的。

解决方案:单一的真相来源

通过在 Instagram 上发布之前更新网站，可以避免销售失败。

单一的真实来源意味着菜单是在一个地方定义的:销售点(POS)系统。通过转换到实体店的数字显示，面包店老板可以保证在线、电话和亲自菜单之间的匹配。店主更有可能记得在 POS 系统中设置菜肴，否则他们将无法向顾客收费。

解决方案:业务分析

分析可以防止这种错误再次发生。通过比较网上、电话和店内订单，可以发现错误。从那里，面包店可以在 Instagram 上重新推出特价商品，为这一不幸事件道歉。

4.一款手机游戏在未能实现购买后失去了一名客户

一款流行的手机游戏有一个捆绑包，允许客户召唤强大的怪物，保证至少有一个 5 星怪物(满分 5 星)。实际召唤时，保证的怪物竟然是进化(升级)的 4 星怪物。如果这令人困惑，重点是客户没有得到他们支付的东西。挫败感导致他们退出另一场比赛。

要点:客户可能会产生情绪影响

一些错误会给客户留下糟糕的体验。在这种情况下，顾客并没有得到他们所承诺的东西，而是承受着被抢劫的压力。处理无响应的支持流程只会加剧负面情绪，导致客户减少损失。

想象一下，在杂货店的收银台排队时信用卡被拒。对一些人来说，这是一个噩梦般的场景，尤其是在信贷充足的情况下，这是系统中的一个缺陷。在下一家商店成功地使用同一张卡将会坚定你不再回来的决心。

解决方案:更好的支持流程支持反馈

其他带有怪物召唤的游戏通过游戏内反馈选项为错误提供了更好的支持。有些甚至有内置的消息，所以没有必要在应用程序之外的随机论坛上创建一个单独的帐户来获得帮助。

这个过程对客户来说越简单，他们就越有可能给出反馈。

解决方案:业务分析

这类错误可以通过分析来发现。一份报告比较了五星级怪物的数量和所花的钱，结果显示人们花了钱却一无所有。

解决方案:交互跟踪软件

突然不动之前的一次购买可以提供离开原因的线索。该客户可能会收到一封电子邮件，承诺如果他们返回，将获得一个免费的召唤包。

5.一家零售巨头因无法在线结账而失去了客户

一家零售巨头的在线结账流程在最糟糕的时候失败了:黑色星期五(一个购物假日)。虽然一些顾客可能耐心等待，希望经济复苏能给他们一个达成交易的机会，但其他人却感到困惑，转而选择了其他零售商。这种错误造成的经济损失可能高达数百万。

要点:只有一小部分客户提供反馈

反馈可能会产生误导。销售额的急剧下降可能无法与出色的评论相匹配，反之亦然。有些人永远不会填写调查，即使有贿赂(礼品卡/折扣)。

以零售巨头为例，在受影响的时刻，似乎没有其他人经历过中断；网上没有任何评论，直到几个小时后，一些人在 Reddit 上发帖。任何不熟悉该平台的人都会感到困惑，并被排除在外。

如果有错误的变通办法，一些客户可能会选择忍受它们，接受它们是最终会被修复的。然而，缺乏报告可能会使公司无知或认为错误很小。

其他客户会认为其他人已经报告了一个错误，并且正在进行修复。这被称为旁观者效应。

解决方案:错误管理软件

这些工具旨在跟踪停机。当某些错误超过阈值时，甚至会有警报，所以如果在不到一个小时内发生 10，000 个错误，有人会在半夜接到自动电话。

如果修复需要时间，在网站顶部简单的道歉，说明每个页面的进展，可以节省大量的钱。

建议

手动响应错误报告(或者至少让它看起来像是手动的)

自动回复会让人觉得无足轻重，除非他们承诺稍后会有真正的回复。

向顾客表示感谢。请记住，他们不怕麻烦地联系支持人员，而其他人却对此一无所知。

你有没有在程序崩溃时通过弹出的对话框发送错误信息，却从来没有听到回应？这不会让我想再做一次。

使用分析软件

这些工具应该保护用户的隐私，同时为企业主提供见解，使他们能够在没有客户反馈的情况下做出决策。

道歉和打折

当错误发生时，坦白并公开道歉。通过使用分析软件，你甚至可以将道歉仅限于那些受影响的人。

不要让顾客要求折扣，因为有些人永远不会。主动提供一个可以防止沉默的怨恨，提升企业的形象。

顾客永远是对的

让对方挽回面子。——戴尔·卡内基

永远不要让它看起来像是顾客的错。这样做可能会让他们处于守势，造成不愉快的经历。客户支持代表应接受培训，以感同身受的方式做出回应。

支持电话并不是唯一的指责来源。如果用户体验不佳，客户可能会收到一条错误消息，指出他们做错了什么(而实际上他们并没有做错)。这些信息可能会产生带有过多脏话的刺耳回应。

在上面的例子中，客户对他们遇到的错误没有影响。即使他们这样做了，过程中的某些东西也允许他们犯这样的错误。

如果期望客户…

看小字，那应该不是小字。
按时支付账单，那么设置过程应该已经启用了自动支付。
知道风险，但风险传达得不够清楚。
耐心点，工具和基础设施投资不够。
不使用广告拦截器之类的外部软件，那么该产品的限制性太强，需要在更多的环境中进行测试。

结论

每个例子都有一个共性:企业因为未报告的错误而失去了客户。有时这是不可避免的，但不是不可挽回的。使用分析软件等工具有助于洞察真实情况。

错误可能会产生副作用，这些副作用永远不会自己显现出来。依赖客户反馈并不完美，但分析工具也不完美。提供反馈的客户应该像圣人一样对待。

低质量单词嵌入的隐性成本

原文：https://towardsdatascience.com/the-hidden-costs-of-low-quality-word-embeddings-b05f38c7e095?source=collection_archive---------59-----------------------

通过升级到高质量的单词嵌入，英语 NLP，尤其是非英语 NLP 应用程序，通常可以获得高达 10%的分类器准确性提升。

今天，内存和磁盘空间很便宜，但许多应用程序仍在为使用低质量的字向量表示付出代价。为什么非英语语言模型特别容易受到低质量单词嵌入的影响？

在单词嵌入之前，词典引用和索引提供了上下文提示。(图片由作者提供)

空间 NLP 图书馆提供英语和许多其他语言的模型，即:德语、法语、西班牙语、葡萄牙语、意大利语、荷兰语、希腊语、挪威语博克马尔语、立陶宛语。然而，这些产品之间有很大的差异。英语模式有小、中、大三种尺寸，每种尺寸的文件大小和内存需求都在增长。每个模型都有一个固定的词汇表，模型文件大小的主要组成部分是单词嵌入向量维度。减少文件大小的一种方法是使用散列技巧。

哈希技巧:

在机器学习中，特征哈希，也称为哈希技巧(类似于内核技巧)，是一种快速且节省空间的特征矢量化方法，即将任意特征转化为向量或矩阵中的索引。它的工作原理是对要素应用散列函数，并直接使用它们的散列值作为索引，而不是在关联数组中查找索引。[ 1 ]

在某些情况下，特性散列并没有错，但是当产生的空间太受限制时，冲突会增加，性能会降低。使用哈希技巧可以创建更小的单词向量模型(想想 200，000 个关键字映射到 20，000 个浮点向量)。看起来 SpaCy 中型模型使用具有大量冲突的散列技巧来构建它们的词向量表示，或者可能它们只是随机地重用槽——中型模型词汇是固定的，所以很难分辨，但效果是相同的。目前，只有一个 SpaCy 大型模型使用全尺寸嵌入——English。同时，所有非英语语言和中型模型通过重用嵌入槽来节省磁盘和内存空间。每个中型车型规格中都有提示，这里是德国的提示:

向量 276k 个键，20k 个唯一向量(300 维)

对，就是 86.2%复用！实际上，这是大量的哈希冲突。

与全尺寸嵌入相比，散列字嵌入的性能如何？

可悲的是，单词表达一直表现不佳一点也不好笑。(图片由作者提供)

即使只有 7108 项标记数据，使用哈希字向量也能获得 73%的准确率，而不是使用全尺寸嵌入时的 84%的准确率(三个类别用于分离，多数类别基线为 43%)[ 2 ]。上面的学习曲线图显示了机器学习模型在对渐进式数据量进行训练时的不同表现。

幸运的是，非英语语言也可以使用其他嵌入，特别是 FastText ，它使用维基百科和通用抓取数据为 157 种语言提供了单词向量。当然，不同语言之间的大小和质量差异很大:

排名前九的维基百科(不包括机器人创作的内容)是印欧语
普通爬行中的语言分布遵循帕累托分布[ 4

语言不平衡是一个真正的问题。可悲的是，这个图表一点也不好笑。(图片由作者提供)

缺少数据没有简单的解决办法，然而，FastText 以一种独特的方式改进了生成单词向量的问题:允许使用字符级信息。

传统的单词向量构建工具，如 Gensim 、 GloVe ，或者神经网络的嵌入层等，需要许多例子来生成单个单词的精确表示。因此，大多数传统的词向量模型的词汇量有限，因此无法预测他们以前没有见过的词的值。相比之下，通过考虑字符序列(有时称为子词信息)，FastText 可以生成模型，这些模型使用许多相似词和子词的集体信息来为它从未见过的词生成嵌入。但是，有一个问题，要执行这个功能，您必须使用 FastText 模型的二进制形式，而不是 Word Vector 文本格式。

生成自定义词向量模型

FastText 二进制模型文件格式在磁盘和内存中非常大，例如英语压缩为 4.2 GB。更常见的单词向量文件格式是一个简单的文本文件，其中每一行都以一个单词开始，然后是表示该单词在全局单词向量空间中的尺寸的浮点数。以下是 GloVe 文件的简短摘录，展示了 word vector 文件的常见文本格式:

市 0.43945 0.43268-0.36654 0.27781…
造 0.14205 0.0046063 -0.40052 …
像 0.36808 0.20834 …

实际上，NLP/ML 应用程序使用 WordVector 文本文件作为字典，并将单词转换为数字表示，然后输入到管道和模型中。使用 FastText 可执行文件，您可以加载二进制模型文件(。bin)，请求您指定的每个单词的向量，并以通用单词向量格式在文本文件中写出信息。这个过程真的很简单，下面是他们的例子:

获取单词向量
打印包含单词的文本文件 queries.txt 的单词向量。
$。/fast text print-word-vectors model . bin<queries . txt 中

不幸的是，它需要大量的磁盘空间和内存，所以根据你的型号和词汇量，你可能需要使用内存更大的机器。
使用 FastText 二进制格式生成定制的单词嵌入可能是比从零开始周期性地重新生成单词嵌入更好的解决方案，并且这对于实际研究来说可能是一个好问题。

更好的单词嵌入不一定需要更多的维度

几个快速实验表明，主成分分析( PCA )可以将 SpaCy 全尺寸单词嵌入从 300 维减少到 50 维，并且只损失一两个点的准确度。当常规/完整大小的嵌入与散列嵌入进行比较时，我们发现在准确性上有 10%以上的差异。没错:使用少 83%的空间，一个 50 维的字向量比一个 300 维的散列字向量的性能高 10%以上。这使用了三个分类和 7，108 个标记项目；如果您有更多的数据或更多的类，您的里程可能会有所不同，但性能可能会更差。

如何提升你的自然语言处理应用的性能

我们已经展示了散列嵌入是如何执行的，并且展示了如何获得完整大小的单词嵌入。现在，您应该能够升级应用程序使用的 word 嵌入，并获得良好的性能提升。有许多遗留代码仍在使用，通过简单地避免使用散列嵌入并总是使用可用的最高质量的字嵌入，可以获得可靠的性能增益。

快速补充说明 : ELMO 和伯特也可以产生基于字符的嵌入，但是他们被设计用来产生上下文嵌入，这是一个句子中许多字符和单词的乘积。因此，虽然伯特和 ELMO 可以用来生成传统的单词嵌入，但这些应用超出了本文的范围。它们是强有力的工具；但是有很多代码已经成功地使用了单词嵌入，或者用伯特或 ELMO 语言替换来生成嵌入，成本太高。

SpaCy 仍然是一个很好的 NLP 库

尽管我对 SpaCy 在中型模型上使用散列词向量的选择持批评态度，但它仍然是一个很棒的 NLP 库，我向所有有志于 NLP 的实践者(从初学者到中级及以上)推荐它。

你不必扔掉你所有的多余代码；您应该能够将空间模型用于其他功能，如标记化、词性标注、命名实体识别和文本分类。此外，SpaCy 架构的某些部分是模块化和可扩展的，这允许许多新颖的用法。但是，用户也应该考虑替代方案。斯坦福大学的 NLP 图书馆现在正在给一些强有力的竞争，它应该被视为从零开始的努力。与 SpaCy 不同，Stanza 不提供单词嵌入作为离散词汇表的一部分。

最重要的是，要知道你的系统正在使用哪种单词嵌入。坚持高标准实现高绩效。

【参考资料
【1】https://en.wikipedia.org/wiki/Feature_hashing
【2】https://www . ka ggle . com/Todd cook/spacy-embedding-comparated-quality-implications
【3】https://en.wikipedia.org/wiki/List_of_Wikipedias
【4】https://common crawl . github . io/cc-crawl-statistics/plots/crawl size
【5】https://spacy.io/usage/processing-pipelines

(感谢 Kyle P. Johnson 和 Josh Frazier 对本文草稿的审阅和评论。)

强化学习的隐藏线性代数

原文：https://towardsdatascience.com/the-hidden-linear-algebra-of-reinforcement-learning-406efdf066a?source=collection_archive---------17-----------------------

线性代数的基础如何支持深度强化学习的顶点？答案就在求解马尔可夫决策过程时的迭代更新中。

强化学习(RL)是一组智能方法，用于迭代学习一组任务。由于计算机科学是一个计算领域，这种学习发生在状态、动作等向量上。以及动力学或跃迁矩阵。状态和向量可以采取不同的形式，但是我们怎么能看到算法的收敛成为技术社区的头条新闻呢？当我们想到将一个变量向量传递给某个线性系统，并得到类似的输出时，应该会想到特征值。

特征值，特征向量方程。

MDP 中赝本征空间的示意图。MDP 是由特征值决定的，但是它们在一个子空间里，可能有点复杂。

本文将引导您理解在 RL 环境中解决任务的迭代方法(收敛到最优策略)。这个基础将反映环境的特征向量和特征值。

沉思的小狗——来源:作者的好朋友。

回顾马尔可夫决策过程

马尔可夫决策过程是支持强化学习的随机模型。如果你很熟悉，你可以跳过这一部分。

定义

状态集合 s ∈ S 。这些状态代表了世界上所有可能的构型。
一组动作 a ∈ A 。动作是代理可以采取的所有可能动作的集合。
一个转移函数 T(s，a，s’)。T(s，a，s’)持有 MDP 的不确定性。给定当前位置和提供的动作， T 决定下一个状态跟随的频率。

MDP 就是一个例子。来源——我在 CS188 做的讲座。

一个奖励函数 R(s，a，s’)。任何代理人的目标都是回报总和最大化。这个函数说的是每一步获得多少奖励。一般来说，在每一步都会有一个小的负奖励(成本)来鼓励快速解决问题，在最终状态会有大的正(目标)或负(失败的任务)奖励。
[0，1]中的折扣因子 γ (gamma) ，将当前(下一步)的价值调整为未来奖励。这抓住了现在奖励相对于以后奖励的重要性。非常重要的是，在我们讨论如何解决 MDP 时，可以期待更多的信息。
起始状态 s0 ，也可能是终止状态。

来源——我在 CS188 做的讲座 11。

重要的价值观

MDP 有两个重要的特征效用-状态值和机会节点的 q 值。

一个状态的价值:一个状态的价值是从一个状态出发的回报的最优递归和。如果机器人在火坑里、宝石附近或沙发上，左边的状态值会有很大不同。
状态动作对的 Q 值:Q 值是与状态动作对相关的折扣奖励的最优和。一个状态的 q 值由一个动作决定——因此，如果指向火焰内部或外部，壁架上的 q 值会有很大变化！

这两个值通过相互递归关联，贝尔曼更新。

行李员更新

理查德·e·贝尔曼是一位数学家，为现代控制和优化理论奠定了基础。通过一个递归一步方程，一个贝尔曼更新方程，大型优化问题可以高效求解。通过递归贝尔曼更新，可以用动态规划建立优化或控制问题，这是一个创建更小、更易于计算的问题的过程。这个过程从末端递归地进行到——一种滚动时域方法。

理查德·e·贝尔曼(1920-1984)——维基百科。

贝尔曼方程 : 公式化为动态规划 的优化问题最优性的必要条件。
动态编程 : 通过将优化问题分解成最佳子结构来简化优化问题的过程。

在强化学习中，我们使用贝尔曼更新过程来求解状态-动作空间的最优值和 q 值。这最终形成了来自给定位置的预期未来回报总额。

在这里，我们可以看到来自审查交错的所有值。符号 (*) 表示最优，所以正确或收敛。我们有由最佳行为决定的状态值，一个 q 状态，然后是两个递归定义。递归值平衡了【T(s，a，s’)中访问任意状态的概率和任意跃迁【R(s，a，s’)的报酬，为状态-动作空间的值创建一个全局映射。****

最佳值与最佳动作条件 q 值相关。然后值和 q 值更新规则非常相似(加权转换、奖励和折扣)。顶部)值与 q 值的耦合；mid) Q 值递归，bot)值迭代。来源加州大学伯克利分校的 cs 188。

他们在这里的关键点是，我们是乘矩阵( R，T )，乘向量( V，U )，来迭代求解收敛。由于一个状态的值如何由它们的邻居’确定，这些值将从任何初始状态收敛。有关 MDP 的更多信息，请参见我写的这篇简介。

强化学习？

“有人告诉我会有 RL，”—你，读者，4 分钟后。这都是强化学习，我断言理解算法所基于的假设和模型会让你比仅仅从 OpenAI 复制 python 教程准备得更好。之后再做。我已经指导了很多学生在 RL 中工作，那些做得更多的人总是那些了解正在发生什么，然后如何应用它的人。

也就是说，这是离在线 q 学习的一小步，在在线 q 学习中，我们用 T 和 R 的样本来估计相同的贝尔曼更新，而不是在方程中显式地使用它们。所有相同的断言都适用于，但它是基于概率分布和期望。 Q-learning 是~2015 年解决雅达利游戏等著名算法。

隐藏数学

特征值？哼。

回想一下系统的特征值-特征向量对( λ，u)A是一个向量和标量，使得系统作用的向量返回原向量的标量倍数。

特征值，特征向量方程。

特征值和特征向量的美妙之处在于，当它们跨越状态空间时(对于大多数物理系统来说，广义特征向量保证了这一点)，每个向量都可以写成其他特征向量的组合。然后，在离散系统中，特征向量控制从任何初始状态的演化——任何初始向量将组合成特征向量的线性组合。

随机矩阵和马尔可夫链

MDP 与马尔可夫链非常接近，但在结构上并不相同。马尔可夫链由转移矩阵 P 决定。概率矩阵的作用类似于对动作求和的转移矩阵 T(s，a，s’)。在马尔可夫链中，下一个状态由下式决定:**

一个随机矩阵的演化。

这个矩阵 P 有一些特殊的值——你可以看到这是一个特征值方程，所有特征值等于一个(图 a λ =1 预乘方程左侧)。为了使矩阵保证的特征值等于 1，所有列的总和必须等于 1。

我们现在在 RL 中寻找的是，我们的解的演化如何与概率分布的收敛相关联？我们通过将用于 V 和 Q* 的迭代算子公式化为线性算子(a 矩阵) B 来做到这一点。收敛可能很棘手——我们使用的值和 q 值向量不是本征向量——它们收敛到本征向量，但这对于了解本征向量如何控制系统并不重要。*

贝尔曼算子，B，像一个带特征向量的线性变换，特征值对 λ=1。

任何初始值分布将收敛到特征空间的形状。该图没有显示贝尔曼更新的确切特征值，而是显示了空间的形状如何随着值的递归更新而演变。最初，这些值将是完全未知的，但是随着学习的出现，已知的值将收敛到与环境完全匹配。

贝尔曼矩阵更新

到目前为止，我们知道，如果我们能够以一种更简单的形式制定我们的贝尔曼更新(线性更新)，一个方便的本征结构将出现。如何将我们的 Q 更新公式化为一个简单的更新方程式？我们从一个 Q 迭代方程开始(最佳值代替右边的等价 Q 值方程)。

MDP 的 q 迭代。

实现这种转变需要几个小步骤(当然还有几个大的假设)。

将我们的系统移向线性算子(矩阵)

I)让我们将几个术语重新表述为通用表格

前半段更新，求和超过 R，T， 是显式奖励数；我们称之为 R(s) 。接下来，我们将转换的求和改为一个概率矩阵(方便地匹配一个马尔可夫矩阵)。同样，这导致了下一步——从 Q 到实用程序的变化。(回想一下，你可以从一个总和中取出一个最大值(把它想象成一个更一般的上限)。

接近我们想要的贝尔曼矩阵，其中 P(s'|s，a)将决定我们矩阵的演化。

ii) 我们把这个做成向量方程。

我们最感兴趣的是效用，【如何演化为 MDP。效用意味着价值或 q 值。我们可以简单地将我们的 Q 改写成而没有太大的变化，但这意味着我们假设一个固定的策略。**

将 q 状态转换为特征值的通用效用向量。

重要的是要记住，即使对于一个多维的物理系统来说，如果我们将所有测量的状态堆叠成一个长数组，那么状态的效用也是一个向量。一个固定的政策不会改变收敛——它只是意味着我们必须重新审视这一点，以学习如何迭代地获得一个政策。

三。采取固定政策

如果你假设一个固定的政策，最大化超过一就消失了。最大化算子明显是非线性的，但是线性代数中存在特征向量加上一个附加向量的形式(提示— 广义特征向量)。

上面这个方程是贝尔曼效用更新的一般形式。我们想要一个线性算子， B ，然后我们可以看到这是一个特征值演化方程。它看起来有点不同，但这最终是我们想要的形式，减去几个线性代数断言，所以我们有我们的贝尔曼更新。

贝尔曼算子，B，像一个带特征向量的线性变换，特征值对 λ=1。

从计算上来说，我们可以得到我们想要的特征向量，但是从分析上来说这样做是有挑战性的，因为在这个过程中要做很多假设。

来源-作者，詹姆斯敦里。

外卖食品

线性运算符向您展示了某些离散的线性系统将如何演变，以及我们在强化学习中使用的环境遵循的结构。

我们收集的数据的特征值和特征向量可以表示 RL 问题的潜在值空间。

变量变化、线性变换、在线 q-learning(而不是这里的 q-iteration)以及更多的细节将在以后的文章中介绍。

该系列的下一篇文章:

** [## 强化学习的基本迭代方法

学习价值和策略迭代能掌握多少强化学习？很多。

towardsdatascience.com](/fundamental-iterative-methods-of-reinforcement-learning-df8ff078652a) [## 强化学习算法的收敛性

有什么简单的收敛界限吗？

towardsdatascience.com](/convergence-of-reinforcement-learning-algorithms-3d917f66b3b7)

更多？订阅我关于机器人、人工智能和社会的时事通讯！

[## 自动化大众化

一个关于机器人和人工智能的博客，让它们对每个人都有益，以及即将到来的自动化浪潮…

robotic.substack.com](https://robotic.substack.com/)**

Jupyter 笔记本的隐藏功能

原文：https://towardsdatascience.com/the-hidden-power-of-jupyter-notebooks-1ba04fae2784?source=collection_archive---------63-----------------------

如何专注于增加价值的事情

图片由来自 Pixabay 的 Christopher Willey 拍摄

当我的一位同事开始使用 Jupyter notebook 完成任务时，我已经作为一名软件开发人员和架构师工作了 15 年。当我看到它时，我不得不同意这是一个伟大的工具——不仅用于探索性的数据分析，还用于违反软件工艺的所有最佳实践。

现代软件行业非常了解如何保持代码基础的整洁。对于结构化，它将首先被分成域，然后分成服务或库，然后分成包，最后分成类或函数。对于每个级别，都有多种模式用于拆分、API 设计和通信。有集成新代码和支持它们的工具的过程。有多种多样的测试方法(同样，使用工具)。有代码审查实践和工具来发现糟糕的设计。一个有经验的软件工匠在将代码投入生产之前应用所有这些最佳实践，因为忽略它们的风险是真实的。为了给系统添加哪怕是很小的功能，你可能会花费数周的时间，修复 bug 变成了一场噩梦。

唯一的问题是，并不是每个代码都值得在产品中运行。一个不能以直接或间接的方式给你的企业增加价值的产品，最好不要投入生产。产品中无用的特性在两方面都是不好的。首先，遵循上面提到的所有最佳实践的代价很高，因此您不能实现一些不同的东西。其次，它增加了系统的复杂性，需要维护，增加了运营成本，同时使进一步的更改更加难以实施。

有时候，检查这个想法是否符合客户需求的唯一方法是至少为它实现一个 MVP。但通常有更简单的方法。这正是 Jupyter 笔记本提供了一个很好的机会——通过研究假设。

当数据科学家的首要目标是改进某个特定的产品时，假设就成了主要的工作单元。这是满足特定需求(通常是客户的需求)的一种可能方式。假设可能被分割成更小的工作，如研究、数据传递、分析和模型构建。最重要的是，假设可能有效，但也可能失败:如果根本没有需求，或者它没有真正覆盖需求，或者没有足够的数据来建立模型，或者客户不会支付所需的价格，或者许多其他原因中的一个。这就是为什么你需要一种方法，让你可以廉价地测试一个假设，很快获得反馈，并迭代多个假设，除非你找到一个可行的解决方案，或者宣布问题无法用现有的方法解决。

假设你正在销售保险单，并想向你的客户销售更多的旅行保险。你想怎么找到合适的受众去接近？基于人口统计(年龄/性别/家庭情况/就业状况)？或者客户拥有的其他产品？或者他们的金融交易？还是基于 GPS 数据(假设客户拥有你的应用并分享这些数据)？你提供折扣还是按正常价格出售？这些都是有待检验的假设。使用 Jupyter 笔记本，你应该能够对每一个假设做以下事情:

对您的客户数据进行探索性分析
建立一个简单的模型，基于规则或使用机器学习，将客户基础限制在你的目标受众
导出目标受众的随机部分，以便将其传递给营销团队进行营销活动
活动运行后，提取活动跟踪数据并创建报告

不要围绕您的模型构建服务，不要将其集成到 CI/CD 管道中，不要在您的 CRM 中实施新流程，不要在这个时间点向您的移动应用程序添加旅游保险的小部件！围绕实现单个假设的所有工作应该限制在 1 周左右，反馈周期应该很短。做好准备，反馈可能不会很大。记录下来，进入下一个假设——扔掉一台笔记本电脑要容易得多，而不是一个完全构建和集成的解决方案。

当你发现一个能真正为你的产品增加价值的假设时，你就可以打开一个好的 IDE(我更喜欢 PyCharm ),最后开始编写生产就绪的代码。现在，遵循行业最佳实践的时间将会得到很好的利用。

开始职业生涯前需要的高级数据科学简介

原文：https://towardsdatascience.com/the-high-level-datascience-brief-you-need-before-you-start-your-career-a2f860337650?source=collection_archive---------77-----------------------

不仅通过定义，还通过数据科学项目的实际日常流程来了解数据科学

我记得我在文章和视频中磕磕绊绊地理解数据科学的日子。直到我把它作为项目的一部分，我才明白数据科学到底是什么。我写这篇文章是为了帮助那些想知道什么是真正的数据科学以及为什么它最近如此流行的人，并在深入这个领域之前先体验一下。

照片由布伦丹·丘奇在 Unsplash 上拍摄

人类善于分析，在做出决定之前，比如学习新事物或开始新的职业生涯，我们有很多问题，接下来的 5 分钟将帮助你做出决定。

什么是数据科学？

数据科学是对大量数据的分析，通过一些指标提供预测和可操作的见解。你可以把它当成天气预报，如果下雨，你必须穿雨衣，或者带把伞。它通常与过去无关，而是从过去的数据中学习，因此业务可以有一个可操作的洞察力。

为什么数据科学现在变得如此流行？

不过，数据科学并不新鲜，这个术语正在兴起。这并不新鲜，因为科学家们多年来一直在使用数据来获得更好的发现。为什么这个术语越来越流行，这个领域的趋势也越来越明显？因为我们存储数据的能力已经大大增加了。
据推测，全球存储的数据总量已经从 2008-09 年的 0.8 ZB 增加到 2020 年的 30ZB，到 2025 年将超过 120ZB。因此，企业渴望了解他们的数据，以做出数据驱动的决策。

根据一份报告，2022 年，数据科学和分析的工作需求预计将从 364，000 个增加到 2，720，000 个

成为一名数据科学家需要具备哪些技能？

一个非常优秀的数据科学家需要的技能包括领域专长、数学家、开发人员、良好的软技能、科学方法、数据工程、统计学、可视化、高级计算等等。但是在一个人身上找到所有的品质是非常罕见的，因此大公司正在雇佣这样的人来分享资源。

但我们作为数据科学家实际需要的是:
1。最重要的是对数据的热情
2。将问题与分析联系起来
3。关心工程解决方案
4。展示好奇心
5。与团队沟通良好

国家癌症研究所在 Unsplash 上拍摄的照片

数据科学涉及哪些流程？

任何高级数据科学项目的步骤看起来都有点像这样，并遵循类似的模式。

1.获得

可以通过 API、数据库(SQL 或 NoSQL)、RSS 提要、来自传感器的实时数据、电子表格来获取数据。我们有不同的媒介来存储和检索数据，这是其中的几种。在开始这个过程之前，我们从一个可用的介质中获取数据。原始数据集被导入分析平台。

2.准备

探索数据

1.了解数据的性质、初步分析(顾客/客户的需求、可行性、经济分析)、发现相关性(数据内)、总体趋势和异常值(数据中的任何罕见事件或异常情况都将被排除，以便进行更好的分析)。

2.描述数据——这包括测量数据，而不仅限于列的平均值和中值。
b . Mode——出现次数最多的值。
c .范围-数据如何分布。

3.可视化数据—数据通过一系列视觉效果进行可视化，例如热图、直方图—数据分布、箱线图、折线图、散点图。这让我们在真正开始处理数据之前就对数据有了深入的了解。它为我们提供了通过非视觉过程可能会错过的信息。

数据预处理

这个过程涉及到数据的清理，真实世界的数据通常是不一致的、重复的、无效的。我们通常通过，

删除缺少值的数据
合并重复记录
为无效值生成最佳估计
移除异常值、罕见事件

数据科学家 80%的时间花在寻找、清理和组织数据上

3.分析数据

包括建立一个模型。将数据输入到模型中，并决定分析技术。模型生成的是输出。根据要求，我们有不同的技术和模型。

分类—目标是预测类别。数据的分类已经完成。假设天气被识别为晴天、雨天等。或者通过成像找到癌症的类型。给模型一个输入，模型为该数据提供类别。
回归-预测数值。通过数据评估价值。我们可以想到一个预测股票价值的模型。
聚类—目标是将相似的项目组织成组。想想 Youtube 的用户，这样类似的视频就可以显示给和你兴趣相投的用户。
关联分析——目标是找到捕捉项目或事件之间关联的规则。当项目和事件是俱乐部的时候使用规则。例如，PUBG 玩家会对购买 PS5 更感兴趣，因此会向该用户显示广告。
图形分析——目标是使用图形结构找到实体之间的联系。

建模为了从数据集中预测一些有用的东西，我们需要使用机器学习算法。这就是机器学习作为数据科学的一个分支出现的地方。

机器学习模型由提供的训练数据训练，这些数据是我们获取的数据，然后用于预测数据。这种训练数据并从模型中获得预测值的过程称为实践机器学习。

步骤如下:
1。选择技术—在给定的技术中，我们可以从数据中选择符合我们要求的技术。
2。构建模型—我们可以使用现有的预定义模型，也可以自定义它们。
3。验证模型-验证模型，确定模型是否给出正确的输出。

可以对
1 进行验证。分类和回归—通过比较预测值和正确值。
2。聚类—验证分配的组对我们的业务是否有用。
3。关联分析—需要更长时间，因为必须通过实际查看数据来调查，并验证不同实体之间的关系。

如果我们对结果不满意，我们还可以重复分析，重新建立模型。这是在查看结果后决定的，并且一直做到我们有一个最低水平的准确性。

4.报告

这通常是决定呈现什么、显示分析的哪一部分，以及决定对业务的最佳价值。发现并报告整个过程的主要价值和主要结果。我们的发现和分析回答了什么问题？想想通过这种分析得到答案的商业问题。

必须报告所有发现，以便决定下一步措施。如果从项目中看不到有用的范围，这也会导致项目的废弃。

注意——为了让客户满意，最好不做任何修改和变更就展示分析结果。如果根据看似正确但实际上错误的数据采取错误的行动，可信度就会丧失。

卢克·切瑟在 Unsplash 上拍摄的照片

5.行动

Artem Beliaikin 在 Unsplash 上拍摄的照片

数据科学的整个过程都是为了获得对业务或产品的一些可操作的见解。因此，这一步是最后一步，在分析后决定采取什么行动。

通常，业务部门会根据数据团队的建议，根据洞察力来决定行动。

现在，您已经了解了在数据科学领域的期望，行业对数据科学家的期望，以及所涉及的流程，您可以更好地判断选择数据科学作为您的职业。

如果你喜欢这篇文章并学到了一些东西，请在推特和媒体上关注我，阅读更多这样的东西。我写关于 Python，数据科学，ML，AI 等等。

人工智能的历史:图灵测试

原文：https://towardsdatascience.com/the-history-of-artificial-intelligence-the-turing-test-c1d6777d2970?source=collection_archive---------30-----------------------

机器会思考吗？

被许多人认为是人工智能之父的艾伦·图灵(1912-1954)在他 1950 年的著作《计算机器与智能》中提出了以下问题:

机器会思考吗？

尽管这个问题篇幅不长，由来已久，但它仍然是一个经常讨论的话题，贯穿于技术、哲学、神经科学和神学之间。

然而，半个多世纪前图灵提出了一个间接的方法来回答这个问题:通过 t 他著名的图灵测试。

艾伦·图灵的漫画。来源。

图灵认为，为了让我们毫不含糊地回答这个问题，问题本身必须重新措辞，具体说明或替换‘思考’和机器’的含义。

让我们首先看看如何平滑等式中的“思考”。图灵建议这样做，首先将问题从“机器能思考吗？”至:

"机器能做我们作为思维实体能做的事情吗？"

换句话说，机器能模仿或模仿人吗？这个问题的答案就在 模仿游戏 里。

《模仿游戏》

这个问题的新形式——回答前面的问题——用下面的术语来表述。

想象我们有一个男人(A)，一个女人(B)，和一个中立的审讯者(C)。这些受试者中的每一个都在一个单独的上锁的房间里，没有窗户或任何形式的视觉连接，只有一个屏幕和一个键盘，C 可以通过它们与 A 和 b 进行交流和互动。

前面描述的场景的插图:模仿游戏。一个男性 A-，一个女性 B-，和一个审讯者 C-，被安置在三个独立的房间里。只有 C 可以通过键盘和终端与 A 或 B 通信。来自平面图标的图标。

游戏的目标是让审讯者 C 发现谁是男性(A)谁是女性(B)。他通过向他们每个人提问来做到这一点，比如给 A 发信息(不知道他就是那个人)说‘你的头发有多长？’。

在这种情况下，A 的目标是让审讯者失败，即欺骗他认为他是女性。正因为如此，前一个问题的答案可能是类似于‘我的头发是单挑的，最长的几缕大约有九英寸长’，或者更模糊的东西。

你可能想知道所有这些与计算机和机器智能有什么关系。现在来问真正相关的问题: 当一台机器在这个游戏中担任 A 的角色会发生什么？

这是图灵测试的精髓:一个询问者通过前述方法(屏幕和键盘)与某个实体进行对话，这个实体可以是人，也可以是机器。这种对话在时间上是有限的，并且是完全开放的。

如果在这次对话之后，询问者不能说出它与之交互的实体是机器还是人，或者更好地说，它肯定是一个人，而事实证明这样的实体实际上是一台机器，那么这台机器就被认为通过了图灵测试。

在论文的其余部分，图灵阐明了对他来说什么是机器，描述了数字计算机的特征，并试图驳斥某些对他关于机器能否思考的答案的批评。

这突出了他为自己的观点辩护的论据数量很少，使他花了更大的努力指出批评者对他的建议的弱点，而不是为它辩护。

在退出本文内容以进一步讨论图灵测试之前，我们将看到图灵如何采用一些初步方法来概念化人工智能的主要驱动因素之一:机器学习。

学习机器

学习子机:来自 Flaticon 的图标。

在计算机器和智能的最后部分，图灵讨论了如何建造一台有机会在模仿游戏中获胜的机器。

他认为，为了能够编写一个程序，即使只占大脑存储容量的中等比例，一群经验丰富的程序员也需要几十年的时间。

如果我们想要模仿一个成年人的大脑，我们应该以某种方式复制在这样一个大脑中发生的过程，他说，这个过程由三个部分组成:

出生时最初的心理状态。
这种思想所受的教育。
不同于教育的经验，如来自心灵所接触的环境的经验。

这里的目标是创建一个复制儿童思维的程序，然后教育它——让它学习— 以便让它达到成人大脑的特征。

他继续讨论了惩罚和奖励作为学习过程一部分的重要性——类似于我们今天所知的 强化学习——但澄清了这本身是不够的，强调了通过某种推理系统进行学习的必要性，从中可以提取推理和逻辑见解——类似于 监督学习 —。

通过尝试回答机器是否能思考的问题，我们一眼就能看到什么将成为人工智能最具颠覆性的核心领域，这难道不令人愉快吗？

图灵测试的讨论和发展

总结成一句话，图灵测试基本上认可了机器的能力，即在超过三分之一的测试次数(或其他一些既定阈值)内，机器是否能够在打字对话中与人类区分开来。

对图灵测试中获胜的机器的这种智力属性的一些最强烈的批评来自它挑战的狭窄的智力领域。

该测试只评估文本交流能力——理解和表达。我们把智慧授予这两个的主人就够了吗？大多数批评家倾向于持不同意见。

许多使用机器学习构建的现代人工智能应用程序成功并在非常狭窄的特定领域任务中表现出色，甚至在这些任务中击败了一些最优秀的人类，如深蓝和国际象棋或 AlphaGo 和围棋。

深蓝击败卡斯帕罗夫

这是否意味着机器理解游戏？如果他们不理解，我们能说他们是聪明的吗？

图灵测试最著名的批评者之一是所谓的中国房间 T21。让我们来看看吧。

中国室

中文房间是一个智力实验，由约翰·塞尔在 1980 年提出，并由著名物理学家罗杰·彭罗斯推广，认为 试图挑战图灵测试的有效性，认为计算不能衍生为“思维”，或者至少不能以提议的方式衍生。

《中国人的房间》试图打破大脑和计算机之间的类比，认为虽然前者完全局限于对符号的操纵，但大脑拥有理解或意识到这些符号意义的语义能力。

实验是这样进行的:想象我们有某种黑盒机器或计算机，我们可以向它输入不同的文本，它会用同一种语言做出非常恰当的文本回复。

我们不知道它内部正在进行什么样的过程，但是，这台机器可以进行完美的对话，所以它轻松通过了图灵测试。

中国房间的黑盒直觉。来自平板图标的图标。

塞尔提出的问题是:

这台机器懂中文吗？

现在，代替这个黑匣子，想象一下我们在计算机里有一个人，他不会说中文，但是，他或她有一大串指令和手册，可以用来对输入的文本给出完美的回答。这些指令有类似于'如果这些符号包含在输入文本中，则回复这个和这个'的规则。

中文房间实验的进一步发展:现在我们有一个人在房间里，尽管不懂中文，但可以进行完美的对话。来自平面图标的图标。

这又引出了三个问题:

房间里的人懂中文吗？

说明书和书籍的说明书懂中文吗？

整个系统都懂中文吗？

中文室能通过图灵测试，我们已经说过了。这是否意味着它那时会思考？这就是实验试图通过捍卫思考和理解应该齐头并进来拆除的东西，因此一个能够通过图灵测试的系统，如果它不理解，就没有做任何类似于思考的事情。

图灵测试的遗产

图灵测试的遗产:来自平板图标的图标。

最后，让我们探索一下图灵测试的一些最新版本，以及它是何时和如何通过的，以及从这些实验中得出的结论。

伊莱扎

伊莱扎是一个对话机器人，由约瑟夫·韦森鲍姆于 1966 年在麻省理工学院开发，是首批能够处理自然语言的程序之一。这个程序，我们可以通过信使服务与之聊天，模仿心理学家，鼓励另一端的人越来越多地谈论他们的问题。

它使用了类似‘我明白了’或‘告诉我更多关于这个的事情’(见下面对话的最后一行)，的句子，并反复用问题轰炸另一端的人类，如下面的交互所示。

你认为我明天可以用这台电脑吗？
伊莉莎:为什么这么问？我应该做更多的网上销售。
伊莉莎:你为什么不确定？我的潜在客户从未见过这个系统的演示。T21:那对你来说很重要吗？
人:
伊莱扎:你似乎对此很热心
人::这很可笑
伊莱扎:这很可笑是什么意思？
人:我现在不能用电脑有什么原因吗？伊莱扎:多告诉我一些你潜在客户的情况。

在这种情况下，与伊莱扎说话的人在互动之前被告知他正在与另一个人说话，而在对话之后，他根本没有怀疑自己一直在与一台机器说话。

ELIZA 使用字典或关键字方法，在输入句子中寻找特定的单词，如果找到这些单词，就会触发预先做出的响应，这可能是一个问题。如果没有找到任何关键字，则给出一个通用的响应。如今，存在更复杂的系统。

罗布纳奖

罗布纳奖是自 1990 年以来每年在 T42 举办的比赛。它有许多不同的主办地点，如麻省理工学院、剑桥大学或伦敦科学博物馆。

它的目标是评估渴望通过图灵测试的对话机器的艺术状态，并促进人工智能和自然语言处理研究。

这场比赛的程序与普通图灵测试的程序相同:30 名不同的裁判坐在两个屏幕前，进行两次单独的对话:一次与计算机程序对话，一次与真人对话。

目标是能够正确评估哪个屏幕属于机器，哪个属于人。裁判与机器/人类同行进行各种互动，最终，能够以最高百分比成功愚弄裁判的人工系统获得胜利。

伊莱扎的改进版本，被称为 电脑治疗师 ，在前三个版本中赢得了这场比赛。

尽管能够以某种方式评估最先进的人工智能系统的图灵测试性能，但这场比赛已经引起了一些关于法官角色的争议，这些法官可能被伊莱扎或其他类型的模仿者欺骗的方式，以及法官和机器之间发生的短暂且有时异想天开的对话。

对这项试验最大的批评之一是海斯和福特在 1995 年提出的:

模仿游戏的条件对裁判没有任何影响，但游戏的成功关键取决于裁判的聪明、知识和洞察力

此外，竞争系统很少接近超过 1/3 的愚弄法官阈值，这是公认的通过图灵测试的极限。我们将通过探索已经触及这个门槛的系统之一来结束这篇文章:尤金。

尤金

尤金·古斯曼是于 2001 年设计的对话聊天机器人，在 2005 年和 2008 年的罗布纳奖中获得亚军。2012 年，在一场不同的比赛中，它获得了有史以来最高的 29%的评委被愚弄的分数，非常接近超过图灵测试阈值。

尤金模仿一个 13 岁的乌克兰男孩，他有语法错误，缺乏只有孩子才会有的知识，还有一种非常特殊的说话方式。

再次，我们可以看到这类系统中的诡计。他们避免面对自然的对话，而是试图通过模仿一个非常具体的人物来利用测试的弱点，从而将对话引向他们可以轻松聊天的狭窄领域。

2014 年，凭借这一策略，尤金通过了图灵测试，在一次纪念图灵逝世 60 周年的活动中，愚弄了 33%与之对话的法官。让我们看看尤金的谈话记录。

评委:你喜欢什么音乐？

尤金:我喜欢阿姆——因为他和“礼貌-正确”一点关系都没有。

评委: OMG 我爱阿姆，他是我最喜欢的艺人！

尤金:我想知道阿姆罗·尼克是什么意思。我只把它和一个词“灌肠”联系在一起。但他是一个很酷的家伙，我喜欢他的“真正的苗条黑幕”。

法官:我知道他的昵称是什么意思，他的真名是马歇尔·马瑟斯。从首字母 M & M 听起来像阿姆。

尤金:阿姆是个著名的拉屎人。不，强奸者…开膛手…是的，我是说——说唱歌手。我喜欢他的《斯坦》和《真正的苗条黑幕》。

评委:我喜欢《海莉的歌》

尤金:有趣的口味。顺便说一下，我喜欢科幻小说。顺便问一下，你从哪里来？你能告诉我你住的地方吗？

裁判:埃普瑟姆，德比的主场。你自己？

尤金:我的豚鼠说德比这个名字听起来很好听。

法官:我应该找个时间和他谈谈

尤金:我认为你应该上一些打字课。或者只是打字更准确。

评委:那很没礼貌？

Eugene: 嗯……坦白地说，我没明白你的问题:-(

评委:“Ummm”不是词。我认为你需要上打字课

尤金:我的想法是一样的。顺便说一句，我还是不知道你的专长——或者，可能，我已经错过了？

结论

这篇文章探索了图灵测试的起源、性质和发展，这是评估人工智能目标的第一支箭。

我希望它不仅对你理解人工智能的起源有所帮助，而且也提出了几个问题，引发了某种内部讨论。

如果没有，我会给你最后一次提示，鼓励你回答以下问题

这个测试真的能代替回答机器是否能思考的问题吗？

除了前面提供的因素之外，在试图回答这个问题时，还有各种其他因素需要考虑。

首先，知道我们正在交互的两个实体之一是否是机器很重要吗？

正如我们在与伊莱扎的谈话记录中看到的，这个人以前并不知道这是一个机会，所以对他来说，这无疑是与一个人的互动。

如果他知道自己既可以对机器说话，也可以对人说话，这种情况会改变吗？

其次，是否应该以某种方式解决对话的时间限制或不受限制的特点？此外，我们应该如何处理之前与法官讨论的问题？

所有这些考虑只能进一步强调 a .图灵在计算机器和智能:中写的最后一句话

我们只能看到前面不远的地方，但我们可以看到需要做的事情很多。

就这些！

如果你喜欢这篇文章，请随时关注我的Twitter @ jaimezorno。还有，你可以看看我其他关于数据科学和机器学习的帖子 这里 。好好读！

如果你想了解更多关于机器学习和人工智能的知识 关注我上媒 ，敬请关注我的下期帖子！

在那之前，保重，享受人工智能！

感谢阅读！

资源

图灵，A. M. (1950)。计算机器和智能。头脑，59，433–460。论文可以在这里找到。
标题图像的来源:像素。
来自平面图标的图标。
艾伦图灵漫画来自: favpng 。

拓扑机器学习的神圣三位一体:Gudhi、Scikit-Learn 和 Tensorflow

原文：https://towardsdatascience.com/the-holy-trinity-of-topological-machine-learning-gudhi-scikit-learn-and-tensorflow-pytorch-3cda2aa249b5?source=collection_archive---------21-----------------------

库斯科学校，“加冕的三位一体”(约 1730)，利马艺术博物馆(公共领域)

大家好！今天，我想强调拓扑数据分析在机器学习中的作用，并演示如何结合使用三个 Python 库来实际使用它:Gudhi、Scikit-Learn 和 Tensorflow。

拓扑数据分析？

先说第一件事，先说拓扑数据分析 (TDA)。这是一个相对较小的数据科学领域(特别是与机器学习和深度学习相比)，但它正在积极发展，并引起了数据科学家的关注。许多初创企业和公司实际上正在将这些技术集成到他们的工具箱中(我们正在谈论的是 IBM 、富士通、 Ayasdi …),由于它最近在各种应用中取得的成功，例如生物学、时间序列、金融、科学可视化、计算机图形学……我可能会写一篇关于这方面的帖子-)

TDA 的目标是计算和编码数据的拓扑，这意味着记录数据集中各种连接的组件、环路、空腔和高维结构。这可能非常有用，主要是因为这种类型的信息不能由其他描述符计算，所以 TDA 真正存储了一组独特的数据特征，这些特征在其他任何地方都找不到。事实证明，这些功能经常被证明对增强机器学习预测是有用的，所以如果你以前没有见过或听说过这些功能，我会让你跟上速度；-)

我已经写了几篇关于这个主题的文章中的两篇，你可以在 Medium 上找到许多其他关于 TDA 的帖子，所以我不会花时间在数学定义上，而是通过分解 TDA 文献的一个经典例子来说明如何在你的数据集上应用 TDA。

TDA 的参考范例:点云分类

这个数据集是在 TDA 的一篇开创性文章中介绍的。它由通过生成以下动力系统的轨道而获得的一组点云组成:

动力系统方程。

这意味着我们将在单位正方形中随机选取一个初始点，并用上面的等式生成一系列点。这将给出一个单点云。现在我们可以随心所欲地重复操作，最终得到一堆点云。这些云的一个有趣的特性是，根据您用来生成点序列的 r 参数的值，点云最终会有非常不同和有趣的结构。例如，如果 r = 3.5 ，产生的点云似乎覆盖了整个单位正方形，而如果 r = 4.1 ，单位正方形中的一些区域是空的:换句话说，你的点云中有洞。这对我们来说是个好消息:TDA 可以直接计算出这些结构的存在。

用 r = 3.5(左)和 r = 4.1(右)计算的点云。很明显，后者有一个洞，而前者没有。

TDA 追踪这些黑洞的方法其实很简单。想象给定半径的球以你的点云的每个点为中心。如果 R = 0 ，这些球的并集就是点云本身。如果 R =无穷大，球的并集就是全单位正方形。但是如果仔细选择，球的结合可能包含许多拓扑结构，比如洞。

球联合的例子。对于中间的 union，这个 union 显然形成了一个洞。这张图片是无耻地从我以前的一篇文章中重复使用的。

因此，为了避免不得不为 R 手动选择这个“好”值，TDA 将为 0 到无穷大之间的 R 的所有可能值计算这个球的联合，并记录每个球洞出现和消失的半径，并将这些值用作一些点的 2D 坐标。TDA 的输出是另一个点云，其中每个点代表一个洞:它被称为 Rips 持久性图。假设点云存储在一个形状为(n x 2)的 numpy 数组 X 中，可以用下面这段代码用 Gudhi 计算两行图表:

import gudhirips = gudhi.RipsComplex(points=X).create_simplex_tree()
dgm = rips.persistence()

根据对应于 r = 4.1 的点云计算出的漂亮的持久性图。红色的点代表连接的组件，蓝色的点代表孔。

给定点云，我们要解决的任务是预测 r 的值。

用 Gudhi + Scikit-Learn 进行拓扑机器学习

持久性图很简洁，对吗？但是它们的问题是，从不同的点云中计算的持久性图可能有不同的点数(因为点云可能有不同数量的洞)。因此，如果您想用 Scikit-Learn 从持久性图中预测 r ，不幸的是，没有直接的方法，因为这些库期望将结构化向量作为输入。这就是为什么有大量的工作将持久性图转换成固定长度的欧几里得向量，甚至开发持久性图的内核。那太好了，但是你应该使用哪一个呢？

不用再担心了！古迪又来找你了。使用其表示模块，您不仅可以计算所有这些矢量化和内核，还可以完全使用 Scikit-Learn 来交叉验证和/或选择最佳的。就像这样简单:

import gudhi.representations as tda
**from** **sklearn.pipeline** **import** Pipeline
**from** **sklearn.svm** **import** SVC
**from** **sklearn.ensemble** **import** RandomForestClassifier as RF
**from** **sklearn.neighbors** **import** KNeighborsClassifier as kNN
**from** **sklearn.model_selection** **import** GridSearchCVpipe = Pipeline([("TDA",       tda.PersistenceImage()),
                 ("Estimator", SVC())])

param =    [{"TDA": [tda.SlicedWassersteinKernel()], 
             "TDA__bandwidth": [0.1, 1.0],
             "TDA__num_directions": [20],
             "Estimator": [SVC(kernel="precomputed")]},

            {"TDA": [tda.PersistenceWeightedGaussianKernel()], 
             "TDA__bandwidth": [0.1, 0.01],
             "TDA__weight": [**lambda** x: np.arctan(x[1]-x[0])], 
             "Estimator": [SVC(kernel="precomputed")]},

            {"TDA": [tda.PersistenceImage()], 
             "TDA__resolution": [ [5,5], [6,6] ],
             "TDA__bandwidth": [0.01, 0.1, 1.0, 10.0],
             "Estimator": [SVC()]},

            {"TDA": [tda.Landscape()], 
             "TDA__resolution": [100],
             "Estimator": [RF()]},

            {"TDA": [tda.BottleneckDistance()], 
             "TDA__epsilon": [0.1], 
             "Estimator: [kNN(metric="precomputed")]}
           ]model = GridSearchCV(pipe, param, cv=3)
model = model.fit(diagrams, labels)

在前面的代码中，我基本上是用切片 Wasserstein 内核和持久性加权高斯内核来尝试内核 SVM，用持久性图像来尝试 C-SVM，用持久性景观来尝试随机森林，以及用所谓的持久性图之间的瓶颈距离来尝试简单的 k-NN。在 Gudhi 里还有很多其他的可能性，你一定要去看看！如果你想了解更多的细节，你也可以看看这个古迪教程。

Gudhi + Tensorflow 拓扑优化

我很确定你现在已经对 TDA 上瘾了。如果你还是不相信，我有别的东西给你，是从这篇论文得到的启发。假设你现在想解决一个更难的问题:我想让你给我一个点云，它的持久性图有尽可能多的点。换句话说，你要生成一个有很多洞的点云。

我能看到你额头上的汗水。但我是慈悲为怀的那种人，让你知道 Gudhi 眨眼之间就能做到这一点。想一想:当你生成一个持久性图时，这个图中不同点的坐标并不依赖于完整的原始点云，对吗？对于该图中的给定点p,p的坐标仅以简单的方式取决于原始点云中形成洞的点的位置(对应于 p ):这些坐标仅仅是球的联合使这个洞出现或消失的半径——或者等价地，这些点内的最大成对距离。原来 Gudhi 可以用它的 persistence_pairs() 函数吐出这些依赖关系。然后，梯度被简单地定义为欧几里德距离函数的导数(正式定义见本文)。

因此，让我们编写几个函数，一个从点云中计算 Rips 持久性图，另一个计算持久性图点的导数。为了可读性，我稍微简化了代码，实际的代码可以在这里找到。

**def** Rips(DX, mel, dim):
    rc = gd.RipsComplex(distance_matrix=DX, max_edge_length=mel)
    st = rc.create_simplex_tree(max_dimension=dim+1)
    dgm = st.persistence()
    indices = st.persistence_pairs()
    **return** indices**class** RipsModel(tf.keras.Model):
    **def** __init__(self, X, mel=12, dim=1, card=50):
        super(RipsModel, self).__init__()
        self.X = X
        self.mel = mel
        self.dim = dim
        self.card = card

    **def** call(self):
        m, d, c = self.mel, self.dim, self.card

        # Compute distance matrix
        DX = tfa.losses.metric_learning.pairwise_distance(self.X)
        DXX = tf.reshape(DX, [1, DX.shape[0], DX.shape[1]])

        # Turn numpy function into tensorflow function
        RipsTF = lambda DX: tf.numpy_function(Rips, [DX, m, d, c], [tf.int32 for _ in range(4*c)])

        # Compute vertices associated to positive and negative simplices 
        # Don't compute gradient for this operation
        ids = tf.nest.map_structure(tf.stop_gradient, tf.map_fn(RipsTF,DXX,dtype=[tf.int32 for _ in range(4*c)]))

        # Get persistence diagram by simply picking the corresponding entries in the distance matrix
        dgm = tf.reshape(tf.gather_nd(DX, tf.reshape(ids, [2*c,2])), [c,2])
        **return** dgm

现在，让我们定义一个损耗，它与余辉图中指向对角线的距离相反。这将迫使图表有许多点，纵坐标比横坐标大得多，相当于一个有许多大孔的点云。

model = RipsModel()
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-2)**for** epoch **in** range(100):

    **with** tf.GradientTape() **as** tape:

        dgm = model.call()        
        loss = -tf.math.reduce_sum(tf.square(.5*(dgm[:,1]-dgm[:,0])))
        gradients = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(gradients, model.trainable_variables))

现在我们来优化一下！以下是第 0、20 和 90 个时期的结果:

如此多的洞，如此美丽…我们活在梦里。如果你想继续玩其他损失，检查这个 Gudhi 教程，它也包含了另一个关于图像优化的例子。

最后一句话…

这篇文章只是结合 Gudhi、Scikit-Learn 和 Tensorflow 所提供的许多可能性的一瞥。我希望我说服了你，将 TDA 整合到你的管道中已经变得非常简单了。尽管 TDA 的许多应用已经出现在文献中，但肯定还有更多需要发现！

家庭云革命:如何在家托管您的个人云？

原文：https://towardsdatascience.com/the-home-cloud-revolution-how-to-host-your-personal-cloud-from-home-584abf16be4?source=collection_archive---------7-----------------------

抛弃谷歌和微软，选择 Nextcloud

安娜斯塔西娅·杜尔吉尔在 Unsplash 上的照片

前提

谷歌跟踪你。是的，我知道这不是一个令人震惊的阅读，但这是真的。是的，几乎每个大公司都在追踪你，但是你可能不知道谷歌在网络上有多活跃。引用这篇来自《鸭鸭走》的文章:

普林斯顿的 WebTAP 隐私项目最近发现谷歌的追踪器安装在 75%的上百万个互联网网站上。

我一直在逐渐脱离谷歌的生态系统，虽然不使用谷歌的许多应用程序几乎是不可能的，但在本文中，我将向你展示如何摆脱谷歌最受欢迎的服务之一:谷歌驱动。

请注意，本文将向您展示如何在家中托管云应用程序，而且这并不便宜。从 OEM 购买时，这种设置的近似成本是€130 或 159 美元，但显然，您可以通过从第三方购买来降低价格。

这里有一个小小的警告:自己托管云不如让别人托管云安全。它的风险更大，因为任何事故，如停电或过载都可能烧毁你的设备，你基本上失去了所有的文件。如果你害怕这一点，使用 UPS 和 raid 备份多个驱动器。

此外，您的网络需要一个公共静态 IP，因此如果您打算跟进并安装 Nextcloud，请联系您的 ISP 来申请。

什么是 Nextcloud？

Nextcloud 是一个你可以自己托管的云平台。自托管可以让你重新获得对数据的控制，你上传的文档、图片和其他任何东西都不会上传到谷歌或微软的服务器，而是上传到你的个人服务器。

此外，它是一个开源项目，这意味着它所依赖的每一行代码都可以被社区检查。当源代码可用时，您可以阅读文件中发生的任何事情。不再不知道您的数据会发生什么。

你可以在官网找到更多信息。

要求

我们将在这些指南中找到的最重要的工具是 Raspberry Pi ，在我们的情况下，在迭代 4B 2GB 中，你可以从 raspberrypi.org购买。该网站不允许您从 OEM 购买主板，而是将您重定向到您所在国家的合作商店。

你必须为这个项目使用专用的 RaspberryPi 4B，以避免过热。我的树莓 Pi 3 仅仅通过运行 Nextcloud 和其他几个网络项目就轻松达到了 158 华氏度或 70 摄氏度。

我们需要的第二个硬件是树莓派的盒子。我推荐的案例是 PiCase 40 ，一旦它离开 Kickstarter，它将从 2020 年 9 月中旬开始在共同市场上市。你可以使用任何兼容的外壳，甚至根本不使用任何外壳，但 Cooler Master 的这款特殊产品应该可以确保你的设备不会经常过热。

我们必须把系统刷新到 microSD 存储器，所以我们需要买一个。我会推荐一款可靠的 SD，比如你可以在三星网站上找到的三星 EVO 32GB，但实际上任何 16GB 以上的内存都可以，我们只会将其用于操作系统和 Nextcloud 的数据库。

如果你有一台可以读取 SD 卡的笔记本电脑，你是幸运的，但如果你没有，你就需要购买一个 MicroSD 转 USB 适配器。你可以在网上和大多数电子商店找到它。

为了存储数据，我建议使用 USB 驱动器、硬盘或 SSD。我认为最适合的是你可以从沃尔玛或大多数在线电子商店买到的高达 5tb 的希捷 Basic。

最后，你需要一个带 USB Type-C 连接器的 5V 3A 电源。如果你不确定买什么或去哪里买，这是树莓基金会的官方电源。

你还需要一根以太网电缆，但是既然我们在讨论网络，我就不应该提这个了。

Raspberry Pi 操作系统设置

如果你是一个超级用户，或者你已经使用过 Raspberry Pi，你可以跳过这一部分。

如果你是一个普通用户，并且你从来没有接触过树莓派，那么你将开始一段伟大的旅程！

首先，你需要把树莓皮放进你的盒子里。如果你已经购买了 PiCase 40，你可以观看这个视频将电路板安装到机箱中，尽管这应该非常简单。

要将操作系统刷新到 MicroSD，您必须将其直接或通过适配器连接到 PC，然后下载 Raspberry Pi Imager 。如果您在 Linux 上，您可以通过以下命令安装它:

sudo apt install rpi-imager

打开成像仪，选择 SD 并通过 Raspberry Pi OS(其他)——安装 Raspberry Pi OS Lite 而非 Ubuntu，我们也可以安装 Ubuntu 并使用 snap 安装 Nextcloud 或直接安装 NextCloudPi 的系统映像，但在本指南中，我们将使用 Raspberry Pi OS。

要使用 Raspberry Pi，您可以通过 ssh 连接，也可以直接将其连接到 USB 键盘和 HDMI 显示器。我将使用 SSH，因此，如果您将直接连接它，可以跳过下一步。

闪存完成后，使用您的文件管理器导航至 SD 卡，并在根目录下创建一个名为 ssh 的文件——不是 ssh.txt，只是 ssh，如果您在 Windows 上，您可以使用顶部栏通过菜单查看>文件扩展名来启用扩展名。

弹出卡，然后将其插入板上的卡槽。很好，我们的树莓派现在可以启动了。将其插入壁挂支架，并连接到您的路由器。

现在，这有点棘手，你需要进入你的路由器页面来检查树莓派的 IP 地址。不幸的是，我不能提供更好的细节，因为每个制造商有不同的登录页面。我能做的就是告诉你，通常，路由器的 IP 是 192.168.x.1，192.168.x.254，其中 x 可以是 0，也可以是 1。通过运行命令，您可以很容易地找到是否必须通过计算机终端设置 0 或 1

ipconfig

如果你在 Windows 或

ifconfig

如果你在 Linux 上查看你电脑的 IP 地址。

如果你运行的是 Mac OS，也可以采取类似的步骤，因为 Mac OS 和 Linux 一样都是基于 Unix 的。

安装 Nextcloud

现在 Raspberry Pi 已经设置好了，我们需要使用 SSH 通过命令行连接到它。通常，Windows 和 Mac 都带有 SSH 客户端，所以只需启动您的终端并运行:

ssh pi@ip_address

其中 pi 是 Raspberry Pi 的默认用户，ip_address 必须替换为您的 Raspberry 的 ip。pi 帐户的默认密码是 raspberry ，尽管我建议您在使用命令登录后更改它

sudo passwd

现在，要安装 Nextcloud，您只需运行以下命令:

curl -sSL https://raw.githubusercontent.com/nextcloud/nextcloudpi/master/install.sh | sudo bash

如果由于某种原因，你没有自动安装 curl，只需运行

sudo apt install curl

设置 Nextcloud

下一步，导航到 HTTP://rpi-ip-address，其中 rpi-ip-address 是您的 Raspberry Pi 的 ip 地址，并保存将给您的密码。默认用户是 ncp，所以您不需要保存它，因为它不是随机的。点击“激活”，一个新的页面将在你的浏览器中打开，提示你输入用户名和密码。将 ncp 设置为用户名，将您保存的密码设置为密码。

现在有趣的事情开始了，你进入 Nextcloud 的门户网站，你将被要求启动设置向导:

Nextcloud 的设置向导。

按照简化的向导进行操作，当被问及是否希望能够从屋外访问 Nextcloud 时，点击 yes 。

如果你不确定如何移植应用程序，让 Nextcloud 来帮你做吧。它将使用 UPnP 标准来尝试并自动设置端口转发。然而，我们还将在后面介绍如何移植应用程序。

下一步有点棘手。现在，为了让你的服务器在你的房子外面也能使用，你可能需要建立一个域，这意味着不用 2.210.123.43 进入你的服务器，你只需使用 thisismynextcloudserver.com 就可以了。现在你真的不需要一个. com，任何域名都可以。你可以用 name price 买到非常便宜的东西。我的域名(我得到我的大约 2 美元)。

如果你不想购买域名，你可以使用 Nextcloud 向你推荐的服务，基本上是为每个账户创建一个子域，所以你可能会有类似于 yourname.freedns.com 的东西。

我建议你自己购买一个域名，这就是我将在本指南中向你展示的。选择跳过并完成您的设置。

域名和 HTTPS。

现在，我们的 web 服务器运行在 HTTP 上，这意味着设备和服务器之间交换的数据没有加密。你不希望你的数据在线不加密，所以让我们安装一个证书。为此，你需要购买一个域名。

去whatsymip.org保存你的 IP 地址，我们以后会用到。

在namecheap.com或任何你信任的域名提供商上创建一个账户，并购买你的域名。

然后，如果你使用过 namecheap，进入你的域名，点击你的域名右边的管理，显示高级信息标签。现在点击高级 dns — 或者直接导航到 AP . www . name cheap . com/Domains/domain control panel/your domain/advanced ns—添加一个带有 Host @的 A 记录，并为您的 IP 赋值。然后添加一个主机为 www 的 CNAME 记录，并为您的域赋值。

最后，您的配置应该包括这两条记录:

我们所做的是告诉域名，当它被访问时，应该从你的域名和 www.yourdomain. 指向你的 IP 地址

然后回到您的终端并安装 certbot:

sudo apt install certbot python-certbot-apache

在这一步中，我们将检索用于加密连接的证书，因此运行:

sudo certbot --apache

您应该这样配置它:

最后，回到HTTP://rpi-IP-address:1443 进入控制面板，将 yourdomain 和 www.yourdomain 添加到 nc-trusted-domains 部分。

更改驱动器目录

首先，我们需要将 USB 格式化为 btrfs，但是不要担心，这并不难。将驱动器连接到 raspberry pi，并拔下所有其他驱动器。然后运行:

sudo ncp-config

然后导航到工具>NC-格式-USB:

按照屏幕上的步骤格式化 USB 驱动器，然后按 exit 返回主页。在这一步之后，记住驱动器的名称或保留默认名称是很重要的。

现在导航到系统>NC-自动安装，遵循设置程序，当在此屏幕上时，用是替换否:

最后，导航到 config > nc-datadir 并将数据目录更改为/media/yourdevicename，或者，如果您使用了默认名称/media/MyCloudDrive。

设置您的路由器

现在我们差不多完成了。我们只需要设置端口转发。为此，你需要像第一步那样回到调制解调器的页面，找到一个叫做端口转发或端口映射的部分。端口映射基本上是映射您的调制解调器，使某些端口在您的网络之外可用，这样当您访问您的 ip:port 时，该服务将在整个互联网上可用。在新的端口映射中，您必须为您的 raspberry pi 的 IP 添加一个 TCP 异常，以及作为内部和外部端口的端口 443。对端口 80 进行同样的操作。

很好，我们基本上完成了。前往您的领域，测试一切是否正常。您应该会看到一个类似的页面:

Nextcloud 的登录页面。

这意味着您现在可以使用 nextcloud 了。您可以使用之前保存的密码以用户名 ncp 登录。

Nextcloud 的文件页面。

如你所见，你现在可以通过互联网安全地访问你所有的文件。你也可以下载适用于安卓系统和 T2 系统的应用程序，并像在谷歌照片中一样设置照片备份。

文本预处理和主题建模入门

原文：https://towardsdatascience.com/the-hottest-topics-in-machine-learning-866ae21ba22d?source=collection_archive---------39-----------------------

了解自然语言处理(NLP)——Python 中的文本预处理、主题建模和潜在狄利克雷分配(LDA)

Feel free to follow me on Medium!

最近在 DataCamp 上完成了“机器学习最热门话题”项目。该项目在 NIPS 论文上使用自然语言处理(NLP ),并实现主题建模和潜在狄利克雷分配(LDA ),以开发机器学习研究中最热门的主题。

" 主题建模 是一种统计模型，用于发现文档集合中出现的抽象主题。"" 潜在狄利克雷分配 ( LDA ) 是主题建模的一个示例，是一个生成统计模型，它允许观察集由未观察到的组来解释，这解释了为什么数据的某些部分是相似的。"

"文档被认为是主题的概率分布，而主题被认为是单词的概率分布."

数据

NIPS 会议(神经信息处理系统)是机器学习社区最负盛名的年度活动之一。在每次 NIPS 会议上，都会发表大量的研究论文。该数据文件包含从 1987 年到 2017 年(30 年)发表的不同 NIPS 论文的信息。这些论文讨论了机器学习中的各种主题，从神经网络到优化方法等等。

import pandas as pd
papers = pd.read_csv("datasets/papers.csv")
papers.head()

EDA 来理解数据

对于论文的分析，我们只考虑与论文相关的文本数据和论文发表的年份，因此有必要删除所有不包含有用文本信息的列。

papers.drop(columns=['id', 'event_type', 'pdf_name'], inplace=True)

为了理解机器学习领域是如何随着时间的推移而发展的，我们将从可视化 1987 年以来每年的出版物数量开始。

groups = papers.groupby('year')counts = groups.size()import matplotlib.pyplot as plt
%matplotlib inline
counts.plot(kind='bar')
plt.xlabel('Year')
plt.ylabel('Number of Papers per Group')
plt.title('Machine Learning Publications since 1987')

自 1987 年以来的机器学习出版物

数据预处理

在我们开始之前，这里是文本预处理步骤的列表:

正则表达式/规范化 —小写单词，删除标点符号和数字
记号化 —将文本分割成称为记号的小块的过程
停用词移除——任何语言中的一组常用词
词汇化 —将一个单词的词形变化组合在一起的过程，这样它们就可以作为一个单独的项目进行分析
词干分析 —将一个单词的词尾变化形式组合在一起的过程，这样它们就可以作为一个单独的项目进行分析

首先，我们将对标题进行一些简单的预处理，以便于分析。我们将使用正则表达式删除标题中的任何标点符号。然后我们将小写的单词。

import re# Remove punctuation
papers['title_processed'] = papers['title'].map(lambda x: re.sub('[,\.!?]', '', x))# Lowercase the words
papers['title_processed'] = papers['title_processed'].map(lambda x: x.lower())

为了检查预处理是否正确，我们可以制作研究论文标题的单词云。Python 有大量的开放库，但现在我们将使用 Andreas Mueller 的“ wordcloud 库”。这将为我们提供最常见单词的可视化表示。

import wordcloudlong_string = " ".join(papers.title_processed)wordcloud = wordcloud.WordCloud()
wordcloud.generate(long_string)
wordcloud.to_image()

词云

LDA 分析

我们将使用的主要文本分析方法是潜在狄利克雷分配(LDA)。LDA 能够对大型文档集执行主题检测，确定大型未标记文本集中的主要主题。

首先，需要将文档转换成简单的向量表示。文档向量的每个条目将对应于一个单词在文档中出现的次数。综上所述，我们将把一个标题列表转换成一个长度等于词汇量的向量列表。我们将根据文档向量列表绘制 10 个最常见的单词。

from sklearn.feature_extraction.text import CountVectorizer
import numpy as npdef plot_10_most_common_words(count_data, count_vectorizer):
    import matplotlib.pyplot as plt
    words = count_vectorizer.get_feature_names()
    total_counts = np.zeros(len(words))
    for t in count_data:
        total_counts+=t.toarray()[0]

    count_dict = (zip(words, total_counts))
    count_dict = sorted(count_dict, key=lambda x:x[1], reverse=True)[0:10]
    words = [w[0] for w in count_dict]
    counts = [w[1] for w in count_dict]
    x_pos = np.arange(len(words))plt.bar(x_pos, counts,align='center')
    plt.xticks(x_pos, words, rotation=90) 
    plt.xlabel('words')
    plt.ylabel('counts')
    plt.title('10 most common words')
    plt.show()count_vectorizer = CountVectorizer(stop_words='english')
count_data = count_vectorizer.fit_transform(papers['title_processed'])
plot_10_most_common_words(count_data, count_vectorizer)

10 个最常见的单词

最后，将使用 LDA 分析研究标题。我们将改变的唯一参数是 LDA 算法中的主题数量，以便我们决定获得前 10 个主题。根据我们得到的结果，我们可以区分每个主题是关于什么的(“神经网络”、“学习”、“核方法”、“高斯过程”)。

import warnings
warnings.simplefilter("ignore", DeprecationWarning)from sklearn.decomposition import LatentDirichletAllocation as LDA

def print_topics(model, count_vectorizer, n_top_words):
    words = count_vectorizer.get_feature_names()
    for topic_idx, topic in enumerate(model.components_):
        print("\nTopic #%d:" % topic_idx)
        print(" ".join([words[i]
             for i in topic.argsort()[:-n_top_words - 1:-1]]))

number_topics = 10
number_words = 6lda = LDA(n_components=number_topics)
lda.fit(count_data)print("Topics found via LDA:")
print_topics(lda, count_vectorizer, number_words)

通过 LDA 找到的 10 大主题

结论

最后，根据我们之前创建的图表，从 1987 年到 2017 年，NIPS 会议论文的数量呈指数级增长。我们还可以得出结论，机器学习在过去几年变得越来越流行。所以历史数据预测 2018 年会有更多的论文发表！

# The historical data indicates that:
more_papers_published_in_2018 = **True**

创建这篇文章的源代码可以在我的 Github 中找到。

关于我

非常感谢您阅读我的文章！大家好，我是雪莉，目前在亚利桑那州立大学攻读商业分析硕士学位。如果您有任何问题，请随时联系我！

Email me at ***kchen122@asu.edu***and feel free to connect me on [**LinkedIn**](https://www.linkedin.com/in/kuanyinchen-shirley/)!

如何使用贝叶斯网络调整建模的超参数？

原文：https://towardsdatascience.com/the-hyperparameter-tuning-problem-in-bayesian-networks-1371590f470?source=collection_archive---------27-----------------------

Alexis Baydoun 在 Unsplash 上拍摄的照片

在这段历史中，我们讨论了基于贝叶斯网络(BN)建立模型时要考虑的结构标准。

如果你是 BN 的新人，我建议你先看看下一个帖子:

[## 贝叶斯思维导论:从贝叶斯定理到贝叶斯网络

假设世界上存在一种非常罕见的疾病。你患这种疾病的几率只有千分之一。你想要…

towardsdatascience.com](/will-you-become-a-zombie-if-a-99-accuracy-test-result-positive-3da371f5134)

在这篇文章中，我将首先关注模型的结构。为此，我们将使用深度学习模型中使用的术语“超参数”，即“在运行学习算法之前应该设置的参数” (Mnih 等人，2013)。这些超参数将条件固定在被训练的学习参数上；他们依赖专家。例如，在人工神经网络中，超参数是学习率(a)、梯度下降中的迭代次数、隐层数、隐单元数、激活函数等。然后我们需要为 BN 定义特定的超参数。

如果你想了解更多关于超参数和机器学习的知识，我建议你访问这个博客:

[## Optuna vs Hyperopt:应该选择哪个超参数优化库？- neptune.ai

思考应该选择哪个库进行超参数优化？使用远视有一段时间了，感觉像…

海王星. ai](https://neptune.ai/blog/optuna-vs-hyperopt)

通常，在任何机器学习问题中，目标都是找到最小化给定成本函数的正确参数。相反，在构建 BNs 时，这些参数取决于数据可用性和专家的知识。因此，这个问题比参数优化更广泛；这是一个超参数设置问题。在构建 BNs 时，选择超参数的正确配置是一个挑战，因为这些参数是基于模型的语义的。它们对于将用于训练模型的数据应该是有用的。我们在这段历史中探索的超参数是:

输入节点数，

每个输入节点的状态数，

目标节点的状态数，

合成节点数(i 中间节点) ，我有一篇较长的帖子讨论这个主题，因为它非常重要:

* [## 贝叶斯网络和合成节点

在这篇文章中，我给出了一个更正式的观点，并讨论了建模的一个重要元素:合成节点。

towardsdatascience.com](/bayesian-networks-and-synthetic-nodes-721de16c47e2)

学习前的数据结构，

学习算法。*

资格标准选择

选择好的超参数是具有挑战性的，因为没有''先验的'正确答案。这是一种试错妥协。通常，在 BN 构建过程中，建模者尝试一些参数，然后测试获得的 BN，尝试超参数的其他值，然后再次测试网络，等等。例如，创建一个所有输入节点都有两种状态的网络，然后创建另一个所有节点都有五种状态的网络，等等。因此，对于超参数的一个候选配置，我们怎么能说一个网络足够有效呢？在本研究中，我们提出了一些评估 BNs 有效性的标准。这些标准将帮助我们判断 BN 是否有效和有用。

1 —保证语义一致性:专家应该很容易解读 BN 语义。该模型应给出可解释的、对专家群体有用的背景和结果。确保语义一致性将增加可解释性，增加易理解性，增加时间一致性。

2 —调整网络的完整性: BNs 应该使用适当数量的节点(以及节点的状态)来表示概念。第二个标准取决于可用的数据量及其完整性。它取决于数据的可访问性，它的不确定性和不完全性。**

3 —保证结果的相关性:目标节点(及其状态)应对决策者有用，但其值应具有足够的准确度和精度，如下图所示:

结果的相关性确保了几个内在标准，如有效性、唯一性和客观性。**

4 —限制组合爆炸。父节点与子节点的关系数要令人满意。如果模型在每个节点中使用大量的节点或状态，网络将会太复杂而不能被算法学习。当 CPT(条件概率表)对于给定数量的可用数据来说太大时，网络的预测能力将会很低。当 CPT 的大小得到控制时，网络的相关性高，结果的准确性增加。如果 CPT 是由基于数据库的算法构建的，它可以执行敏感性分析，因此对决策者来说有更多的附加值。

5 —保证良好的学习质量。 BNs 要有一个完整的学习，就是 CPTs 必须计算完整。当配置爆炸时(太多的状态或节点)，或没有足够的信息时，CPT 计算将是不完整的，因此学习的质量将是低的(Nam et al .，2008)。有几种衡量标准来估计学习的质量，例如，BIC (Burnham & Anderson，2004)或 AIC (Akaike，1974)。良好的学习质量意味着算法将在新的数据集中表现良好，并且网络将有效地帮助决策过程。

超参数对合格标准的影响

在构建 BNs 时，超参数的选择和资格标准之间有很强的相关性。不同的网络结构会改变标准中的结果:

输入节点数是网络中父节点数。下图显示了具有不同输入节点配置的三个网络。专家应该定义哪些变量与输入相对应，其中有多少是必需的。从语义的角度来看，模型可能用更多的输入变量更好地表示问题，但是从数学的角度来看，更多的输入节点可能影响结果中的准确度和精度，并且模型将需要更大的数量的训练数据。

BN 配置示例-输入节点数量的变化(作者创作)

输入节点的状态数:每个输入节点可以有几种状态。从两种状态出发，通常表示(是/否)。随着状态数量的增加，子节点的 CPT 大小也会增加。文献中的 BNs 在每个节点使用两个输入。从语义的角度来看，更多的状态可能是重要的(增加模型的可解释性)；然而，它们会增加模型训练和灵敏度分析的难度。**

BN 的例子——输入节点数和输入状态的变化(作者创造)

输出或目标节点的状态数:假设输入节点将要连接到一个目标节点。该模型应该在答案的粒度(即目标节点的状态数)和每个答案的值的精度之间进行权衡。

目标节点中四种状态的精度(黑线)。(作者创作)

在这种情况下，我们有四种可能性。第一个显示了事件延迟小于预期时间 1%的概率。第二个显示预期时间的 1%到 10%之间的延迟概率，其他状态以此类推(以对数标度)。目标节点中的这种状态分布向决策者呈现了分组信息，即状态 P 中的范围(10%

Precision (black line) for the six states in a target node (Author’s Creation)

The second case (the figure above) displays a target node with six states. Here the state segmentation is divided into every 20% interval of the expected possible delay. The presence of several states may appear better for the decision-maker because s/he would have more detailed output for each of the different input configurations; nevertheless, as the number of states increases, the precision and accuracy of the value for each state decrease, as presented by the black line in that figure.

合成节点数:如前所示，当目标节点具有多个状态和多个父节点时，问题变得更加难以解决。提出引入合成节点来限制配置的爆炸(康斯坦蒂努等人，2016；芬顿&尼尔，2013；孙&谢诺伊，2007)。然而，要使用的合成节点的数量将取决于问题的结构及其语义。

数据结构化:在训练算法之前，数据必须是干净的和结构化的。数据库中不应有任何错误。一旦数据准备就绪，数据库中的列表示父节点，最后一列表示目标节点。每一行代表一个实例(测量)，即每一行都是训练算法的一个新案例。给定一个数据库，构建网络的专家应该确保列数和行数之间的对应关系，以及其中包含的信息的质量，以确保学习的质量。

机器学习算法:最后，要选择一个学习算法。BN 可以使用几种分类算法，它们可以分为两类:(1)用于确定图结构和条件分布参数的算法(学习算法)。还有(2)那些一旦网络完成就计算信息传播的算法(推理算法)(Acid，De Campos，& Castellano，2005；德鲁日泽尔，1999 年；弗里德曼&戈尔兹米特，1996；戈什，2008；纳姆等人，2008 年；珀尔，1988 年)。下表显示了贝叶斯学习中使用的一些算法。**

贝叶斯网络中使用的算法，改编自(Bouaziz，2014)

如果你想知道超参数优化在哪里应用，我推荐这篇文章:

* [## 石油和天然气工程项目中的数据科学。

探索性数据分析

towardsdatascience.com](/datascience-in-oil-and-gas-engineering-projects-daace6e6c7f)*

贝叶斯网络的超参数调整示例

在这篇文章中，我创建了一个贝叶斯网络来计算石油和天然气项目成本超支的概率，但是，我忽略了大部分超参数优化。下面，我举例说明为什么我选择一个参数(目标节点)有四种状态:

因此，我们选择了目标节点的状态数:目标节点可以具有: (1) 两种状态，表示过成本出现的概率为真或为假。或者， (2) 四种状态，对本文讨论的标准给出了更好的折衷:

目标节点的状态数与精度。

我们定义了目标节点的状态数。为了解决这个问题，我们使用高斯混合模型(GMM)算法来确定目标节点中每个状态的中值和变化值。结果显示在下表中。该表显示，当目标节点具有 2 个或 4 个状态时，产生最佳精度(最低变化)。

三个目标节点配置的均值和方差。(作者创作)

然后，我们评估了在几个类别下对数据库进行聚类时的准确性。我们使用了两个分析标准:阿凯克的信息标准(AIC)(阿凯克，1974)和贝叶斯信息标准(BIC)(施瓦茨，1978)。这两个标准非常接近，并且有很强的统计基础(Vrieze，2012)。下图显示了多个州(2 到 9 个)的评估标准的结果。这些参数下的最佳选择是最小化 BIC 和 AIC 值。这些标准指出，给定手头的数据，目标节点中的四个状态使计算精度最大化。

不同类别的目标节点及其相关的 BIC 和 AIC 值。(作者创作)

根据 AIC 和 BIC 标准，目标节点应该有四个状态来代表四个成本超支范围，以便在准确性和精确度之间达到良好的折衷。

P_1_ 或 P(过度成本)< 1%。相当于总费用不到 1%的成本超支发生的概率。

P_1_10 或 1% ≤ P(超额成本)< 10% : 是总费用的 1%到 10%之间发生成本超支的概率。

P1 _ 100 或 10% ≤ P(超额成本)< 100% : 是总费用的 10%到 100%之间发生成本超支的概率。

P_100_ 或 P(超额成本)≥ 100% : 发生相当于总费用 100%以上的成本超支的概率。

鉴于我们的数据库，我们选择 10 为基数的对数标度有两个原因。首先，这个选择产生了对专家有用的范围。目标节点呈现四种状态，前两种 P(过度成本)< 1% 和 1% ≤ P(过度成本)< 10% 被专家认为具有可忽略和可接受的风险。第三个层次 10% ≤ P(过度成本)< 100% 是“未知区域”(不期望的)，项目的复杂性会产生一系列难以准确预测的漂移。四个级别 P(过度成本)≥ 100% 定义了当项目有如此多的弱点，以至于可以预见重大漂移影响(不可接受)时发生的风险级别。第二个原因，它创建了四个类，每个类中有足够的例子来高效地训练算法 (本帖规则 5)如下图所示。

目标节点中四个类的分布。(作者创作)

该算法显示测试的最佳值是四个状态。它表明较少的状态可能有更精确的值(较少的变化),但准确性较差。最后，四州选择提供了较低的 AIC/BIC 值。

链接到这篇文章的完整研究可以在下一个链接中找到

* [## 一种基于贝叶斯网络的提高项目管理成熟度的方法

提出了一种建立项目管理成熟度和项目超额成本之间因果关系的方法

www.sciencedirect.com](https://www.sciencedirect.com/science/article/pii/S0166361519309480?dgcid=author)*

如果你有兴趣了解创建贝叶斯网络的启发、规则和最佳实践，我推荐这篇文章:

* [## 构建贝叶斯网络的主要启发式方法——项目管理评估实例

这篇文章解释了用贝叶斯网络建模的困难，以及 5 个基本规则如何可以极大地促进你的学习。

towardsdatascience.com](/using-bayesian-networks-for-project-management-evaluation-13a6eda50605)

感谢阅读！！！

如果你想继续阅读这样的故事，你可以在这里订阅！*

假设检验者的附录

原文：https://towardsdatascience.com/the-hypothesis-testers-appendix-ba46d1bcdc00?source=collection_archive---------19-----------------------

“精明的新冠肺炎决策”一文的附录

如果你刚刚读过我的文章 《聪明的新冠肺炎决策》 ，并且你习惯了经典的统计推断，你可能会注意到我跳过了几个步骤。让我们跟随一起仔细看看这个框架。

默认行动:新冠肺炎不在的时候你会做什么(比如用你的戏票)
替代行动:做出你正在考虑的改变(比如不要用你的戏票)。
无效假设:您想要执行默认操作的所有状态。
替代假设:世界的所有其他状态。

等等，触发器和信息源是怎么回事？为什么没有提到零假设？

图片:来源。

简单地说，这篇文章假设你自己没有能力检验关于新冠肺炎的统计假设。

如果你是一个流行病学研究小组的成员，有特权访问数据，这篇文章不适合你(你可能没有时间读它——谢谢你正在做的工作)。如果你是另外一个人，嗯…即使你能接触到数据，你可能没有，用它来推断世界的状态会有一些严重的问题。

例如，如果不对无症状的个体进行随机测试，您将如何开始对人群患病率进行猜测？你做的任何模型都需要大量基于假设。这些假设从何而来？流行病学专业知识，比如其他冠状病毒的传播以及天知道还有什么(我说过我不是流行病学家吗？).

如果你没有这方面的专业知识，让我们假设你的假设是垃圾。你可能仍然会犯这些错误，但是值得记住的是你没有资格犯这些错误。当你的结论更多地基于站不住脚的无知的假设而不是数据时，你真的想依赖它们吗？(我顺便提到，在我的业余时间，我一直在运行一些模拟，就像许多其他数据人一样——我不会与您共享我的任何模型，因为我非常确定我没有资格做出我的代码所基于的许多假设，所以我将保留我的个人便笺本。)

那么，当统计测试假设不可行时，我们如何在模糊和不确定的情况下做出决策呢？

一个解决方案是从我们可能相信的世界状态的框架转换到这种形式的基于事实的标准:“一个我信任的来源说 x”.

即使 x 是一个概率陈述(通常对科学家说的事情来说是真的)，它是一个被说过的事实。如果你能够证实你信任的来源说了那些话，那么你就是在用没有不确定性的决策标准工作。(这并不意味着你的决策质量很棒，但至少你很清楚自己是如何处理事情的。)

如果你拿不到数据来分析，一个合理的决策方法是相信那些比你拥有更多的信息的人。

简而言之:当你无法获得可以用来对你的世界做出合理推断的可靠数据，没有做出合理假设的专业知识，也没有自己收集数据的能力时，你被迫使用代理。一个合理的方法(这是我的建议，也是我个人在这种情况下使用的方法)是基于信任那些比你拥有更多的信息的人。

这种方法不是自己评估零假设，而是挑选你愿意信任的实体(加上新信号的最低可信度标准)、你愿意做出反应的信号以及你的反应方式。这不是你现在想做决定的理想方式——我知道，我也不想——但在获得更多信息(和更好的信息)之前，这可能是你最好的选择。

喜欢作者？与凯西·科兹尔科夫联系

让我们做朋友吧！你可以在 Twitter 、 YouTube 、 Substack 和 LinkedIn 上找到我。有兴趣让我在你的活动上发言吗？使用表格取得联系。

IBM 数据科学家访谈

原文：https://towardsdatascience.com/the-ibm-data-scientist-interview-a8982361755c?source=collection_archive---------41-----------------------

IBM 数据科学面试问题

图片来自 Unsplash

介绍

IBM 是一家跨国技术公司，成立于 1911 年，在全球 170 多个国家开展业务。今天，IBM 提供广泛的产品和服务，包括软件解决方案、硬件架构(服务器和存储架构)、业务和技术服务以及全球融资解决方案。

作为一家数据驱动的公司，IBM 了解数据和数据分析在组织的每一层推动更好的业务决策的重要性。此外，作为分析和基于云的解决方案的领先提供商，IBM 提供了一整套基于云的产品和服务，涵盖数据分析、存储、人工智能、物联网和区块链。

对另一家大型科技公司的数据科学感兴趣？ 看看这篇关于微软数据科学家采访的文章吧！

IBM 的数据科学家角色

图片来自 Pixabay

在任何企业分析团队中，数据科学家的角色包括识别提供最大洞察力的机会、分析数据以识别趋势和模式、构建管道和个性化机器学习模型以了解客户需求，以及做出更好的商业决策。

在 IBM，术语数据科学涵盖了数据科学相关工作的广泛范围(数据分析师、数据工程师、数据科学家和研究分析师)，角色可以包括从数据收集、组织和分析中揭示洞察力，为信息基础设施奠定基础，以及构建和培训具有重大成果的模型。角色有时是特定于团队和分配的产品的，有时它们可以更加专门化，如面向内部和外部客户的 IBM 分析咨询服务。

IBM 的数据科学家被安排在从事 IBM 产品和服务的团队中，如 IBM Watson Studio、IBM Cloud Pak、IBM Db2、IBM SPSS、IBM Infosphere 等。

所需技能

IBM 是一个数据驱动的组织，数据科学是一件大事。IBM 的数据科学家角色需要领域专业化，因此 IBM 只雇佣在数据分析、定量研究和机器学习应用方面具有至少 3 年(高级职位为 5 年以上)行业经验的高素质人员。

其他基本资格包括:

统计学、数学、计算机科学以及其他 STEM 相关领域的理学学士/硕士/博士学位。
对统计计算机语言(R，Python，SQL 等)有丰富的经验。)来操作数据，并从大型数据集中获得洞察力。
具备创建和使用高级机器学习算法和统计的高级知识，如回归、模拟、情景分析、建模、聚类、决策树、神经网络等。
具有机器学习和线性代数的经典方法的经验，包括用于线性分类的支持向量机(SVM)和用于降低数据维度的奇异值分解(SVD)。
有 3 年以上使用数据可视化和报告工具的经验，如 Excel、PowerBI、Tableau 等。
在使用分布式数据或计算工具(如 Hive、Spark、MySQL 等)方面拥有丰富的行业经验
具有自然语言处理、文本分析、数据挖掘、文本处理或其他人工智能子领域和技术的经验
充分理解数据分析基础设施和数据工程流程，包括数据存储和检索、ETL 管道、Docker、Kubernetes 等。
软件工程实践的背景知识，如版本控制、连续交付、单元测试、文档、发布管理

IBM 的数据科学家团队

图片来自 Unsplash

像大多数大型科技公司一样，IBM 有过多的产品和服务，有许多部门和高素质的专业团队在开发新产品和改进现有产品。

IBM 数据科学家在团队中工作，有时可能与内部团队跨职能合作。具体职能可能因团队而异，但一般的数据科学家角色从轻量级数据分析到机器学习/深度学习都有。

下面列出了 IBM 的一些数据科学团队以及团队中具体的数据科学家角色:

用户体验研究&分析:角色包括分析来自多个存储库的大型数据集，包括主要研究、行为数据和数据库，如 AWS S3、Azure、MongoDB、SQL 或 NoSQL，以创建预测性和规范性模型，并提取可操作的见解。角色还包括开发自动化报告和仪表板，并与利益相关者(如高管、项目经理和设计团队)交流发现。

IBM 全球技术服务(GTS)分析团队:该团队通过使用高级分析和机器学习模型来开发和构建创新的 AIOPS 解决方案，分析从各种 IT 运营工具和设备收集的大数据，以实时自动发现和纠正问题。该团队中的数据科学家利用深度学习和 LSTM 模型来实时自动检测任何异常，并防止停机。

IBM Q Start 团队:这里的数据科学家与研究和算法专家一起工作，实现数据处理、运行数值和数据可视化的量子方法。

软件开发&支持:该团队的数据科学家负责扩展和优化数据模型、预测算法、关联算法以及文本分析模型。作为该团队的数据科学家，您还将负责实体的自然语言处理(NLP ),以及使用自然语言分类和 RNN 算法对人工生成的票据进行文本分析。

IBM SME :这个团队的角色包括利用分析和深度学习模型来预测新兴趋势，并提供优化业务结果的建议。

IBM 全球业务服务部(GBS): 这个团队通过利用商业敏锐度和预测性机器学习模型，帮助 IBM 的企业客户做出更好、更明智的商业决策。

IBM 客户创新中心(CIC): 该团队中的数据科学家利用各种机器学习技术，包括聚类、决策树学习、人工神经网络等，以及高级统计技术和概念(回归、分布特性、统计测试和正确使用等)。)来创建解决方案并为业务提供可行的见解。

如果你想在 IBM 这样的公司工作，那里的数据科学家什么都做， 我们推荐阅读《Twitch 数据科学家访谈》！

面试过程

图片来自 Unsplash

面试过程从接受在线编码挑战“HireVue”开始。之后是与招聘人员或人力资源人员就简历和过去的相关项目进行的初步电话面试。随后是一个技术屏幕，可能由各种编码问题组成，从基本的 python、SQL 到中级 Algo 问题。最后一个阶段是现场面试，包括 3 轮面试。

在线挑战

这是在 HireVue 平台上进行的 5 小时在线数据挑战测试。这项挑战中的问题是围绕行为、机器学习和统计的中级难度问题。候选人总共需要回答 13 个问题，有些问题需要视频回答、短文写作、口头解释和编码解决方案。

初始屏幕

这是对人力资源或招聘经理的试探性面试。面试中的问题基本上围绕着你的简历和背景经历，因为这与你申请的工作职位相吻合。

技术屏幕

与最初的面试不同，技术面试要深入得多。你还会被问到过去的项目，比如“你面临过什么挑战？”，“你是如何克服那些挑战的？”“你用了什么技巧或方法？”，“你的项目中使用了哪些机器学习算法？”，以及“您是如何选择参数的？”。还有很多编码问题和一些关于机器学习理论和概念的讨论。

在面试查询上尝试一道来自真实面试的机器学习题。

现场面试

IBM 数据科学家现场面试由 2 到 3 轮面试组成，面试小组由高级数据科学家、经理和来自设计、统计和机器学习、管理的 IBM 员工组成。

问题跨越统计概念、机器学习概念和方法、大数据和框架，以及情境行为问题。大多数统计问题都是基于案例研究的。你也可能会遇到类似“你将如何尝试解决一个数据科学问题？”，“描述您以前工作过的项目/数据集。”，以及“告诉我一次…”。

整个现场面试过程看起来很像这样:

统计面试
机器学习/编码面试
行为面试

注意:行为面试中的问题大多围绕你简历中提到的与角色相关的过去项目和经历。

注意事项和提示

像每个标准的数据科学家面试一样，IBM 数据科学家面试包括数据科学概念的长度和宽度。问题涵盖多变量统计和机器学习算法等领域，包括主成分分析、判别分析、线性和逻辑回归、k-最近邻、分类和回归树、神经网络等、预测和规定模型、多变量回归和聚类分析。

它有助于学习基本的统计和机器学习模型，并在白板上练习编码，以熟悉现场面试。 访问面试查询和练习 IBM 数据科学面试问题 可以帮助你 ace 现场面试的技术部分。

请记住，IBM 非常依赖情景问题，因此您可能会遇到这样的问题:“告诉我一个时间……”、“您如何……”、“您将如何解决……”以及“描述一个您的项目……”。它有助于将每个概念与您过去从事的项目联系起来，以及如何使用这些概念或技术来帮助您克服挑战。

IBM 数据科学家面试问题

使用蒙特卡罗算法估计圆周率的值。
什么是深度学习？
什么是标准差？
精度/特异性有什么区别？
你对成为数据分析师的愿景是什么？
定义一个置信区间？
解释 p 值的重要性？
你熟悉什么语言？(python、java 等)
有监督的和无监督的机器学习有什么区别？
什么是精准？什么是特异性？什么是敏感/回忆？
你有几年的 Python 编程经验？
描述精确度和召回率。
为什么你想为 IBM 工作，
p 值是多少？
你对 Tensorflow 了解多少？
与分类预测模型相比，您如何评估回归预测模型的性能？
监督学习和非监督学习的区别。
为什么你认为你的背景非常适合 IBM
你如何处理一个丢失的值
用于评估预测模型的矩阵是什么？
逻辑回归中的系数和优势比之间有什么关系？
如何验证一个机器学习模型？
如何用 python 实现斐波那契？为什么循环比递归好？

感谢阅读

如果你有兴趣磨练你的数据科学，请查看 面试查询 ！
查看我的 Youtube 频道 获取更多数据科学面试指南、商业视频和解决问题的技巧&。
想要更多数据科学面试问题？复习这些文章关于Google 数据科学面试问题及解答数据科学实习面试问题SAP 数据科学面试问题。************

原载于 2020 年 8 月 24 日 https://www.interviewquery.com。

做出数据驱动决策的错觉

原文：https://towardsdatascience.com/the-illusion-of-making-data-driven-decisions-bf54a2e594c4?source=collection_archive---------34-----------------------

朱利叶斯·德罗斯特在 Unsplash 上的照片

如何让数据真正驱动您的决策

我们都经历过。决策者围坐在一张制作精良的大桌子旁，桌子上摆放着我们所期待的典型投影和协作技术。随着他们的仪表盘、图表和交互式报告被张贴在会议室的墙上，这些国家元首之间展开了热烈的讨论。一旦他们就他们的结论达成了一个集体的温暖和模糊的时刻，他们就头脑风暴出一个要在整个公司分发的行动项目的待办事项列表——最终，一个公司做出数据驱动的决策。

等等！每个人都被骗了。你只是见证了数据驱动决策的幻觉。

场景

大家都在说用数据做决策。许多公司声称正在做出数据驱动的决策。但是他们的结果喜忧参半。因此，他们聘请像我这样的顾问为他们提供建议，希望提高他们的洞察力。不幸的是，这些企业领导人错误地将他们的糟糕表现归咎于数据科学部门的失败。具有讽刺意味的是，由于他们对数据的使用而导致的任何糟糕的决定通常都是他们自己的。

这些公司拥有大量数据。他们创建了一个由具备必要的数据科学技能的个人组成的小团队，将数据整理成有意义的信息。数据辩论者、数据科学家、程序员、数据工程师、图形艺术家、UI/UX 专业人员和主题专家都参与了这项工作。那么问题出在哪里？

[## 让您的分析团队走上正轨！

成功分析团队的五个必要角色

towardsdatascience.com](/getting-your-analytics-team-right-b539206dac3d)

问题是

数据就像灵感女神，激励着商业领袖，而不是推动他们的决策。他们使用数据的方法假设，在受到会议中分享的大量信息的影响后，他们可以做出公正的决定。真正的数据驱动决策来自一种完全不同的方法。为了确保数据推动您的业务，您必须在引入数据洞察之前建立决策标准。

决策科学本身就是一门学科。如果你真的想充分利用决策科学技术，你需要投入大量的时间和金钱。由于预算规模或大或小的公司都需要做出更好的决策，让我们列出一些所有公司都能负担得起并实施的基本决策科学实践。

实现真正的数据驱动决策的 5 个步骤

#1 —定义业务问题

从建立你试图回答的一个或多个问题开始。如果你的公司在每次领导聚会时都是仓促行事，那它的目的地就不明确了。你的数据要么会把你带下悬崖，要么就像喝醉的树懒走的路。两种结果都不理想。

避免这个问题在智力上是简单的，即使采取适当的行动来解决它可能具有挑战性。在评估任何数据之前，首先要确定业务问题。

商业问题:我们是否应该将我们的销售努力扩展到西部地区？

#2 —在看到所有数据之前，定义您的决策标准

接下来，定义做出这个决定的标准。《T2 内幕》电影中有一个很棒的场景。拉塞尔·克罗扮演一名烟草公司的告密者。就在他走向取证处，众所周知的不归路时，他停了下来。他的律师质疑他是否准备好了。克罗的角色回答:“我找不到决定的标准。”

在我们的例子中，董事会成员也面临同样的问题。缺乏预先确定的评估标准为认知偏差奠定了基础。仪表板和报告中的见解会在潜意识中影响它们的使用。随后，决定不再客观。它不是数据驱动的。

如果你是做销售的，你可能已经知道决定这个的要求。

一些示例标准可以是:

新地区的销售会对现有地区的销售产生重大影响吗？
我们产品在新地区的市场是否满足新市场在三年内独立生存所需的最低潜在销售额？
我们是否拥有或能够获得新市场所需的销售资源？
我们是否拥有或能够获得支持新市场所需的营销资源？
我们是否拥有或能够获得支持新市场所需的供应链资源？
我们是否拥有或能够获得必要的支持业务服务来支持新市场？
我们是否有现实的目标来决定一年、两年和三年内在这个新市场的成功？
我们对这个市场有现实的退出策略吗？
开始扩张需要多少资金？
在新的营销自我维持之前，我们有足够的资金来支持扩张吗？

这一步最简单的部分是你不需要数据科学家来做。现在你有问题了，看看你能不能回答。你可能需要一个数据分析师来帮助你，或者你可能已经有了所有这些答案。如果你已经有了答案，跳到第四步。否则，你需要在第三步停下来。

#3 —将您的数据一分为二

如果你将整个数据集用于探索目的，你将会产生和我们在董事会会议室看到的一样的认知偏差。相反，使用大约 20/80 的比例将您的数据分成两组。两个数据集中较小的一个用于探索性数据分析。欢迎贵组织的任何部门使用。分享给所有向你要数据的人。为报告保留较大的数据集。这最后一个数据集驱动您的业务决策。

分割数据集后，您可以请数据分析师帮助您建立与您的预定义标准相对应的决策指标。

#4 —通过回答您的标准问题来建立您的指标

你对这些问题的回答将成为你做出最终决定的门槛。在你坐在会议室看最新报告之前，回答这些问题是很重要的。无论你建立什么样的衡量标准，都将保护你不把数据当作灵感，并把它推到驾驶座上。在这一步上花点时间，确保使用合理有效的度量标准。

虽然我们梦想完美的数据，但它并不存在。您会在数据中发现一些无法提供精确测量值的地方。不要惊慌。不要认输。

[## 数据科学的未来

数据科学和业务环境正在融合

towardsdatascience.com](/the-future-of-data-science-5825bde65637)

当你遇到数据不足时，利用你的人类直觉和你在数据科学领域的伙伴来帮助你建立一个可以接受的阈值。现在，您已经有了决策标准。不完善的数据没什么可怕的；它仍然是有价值的，甚至可以成为决策过程的一部分。

#5 —做出数据驱动的决策

如果你已经使用了前四个步骤，第五步就很容易了。让您的数据科学团队根据您的报告数据创建控制面板。根据您的决策标准和指标来衡量结果。据此行动。当指标达到特定动作的阈值时，采取动作。如果没有，就等着。不要行动。做决定不是很简单吗？

结论

随着公司的发展，您的决策过程应该通过充分利用决策科学实践变得更加复杂。但是这五个步骤是一个强有力的开始。它们会驱散你一直在实践的错觉，帮助你真正做出由数据驱动的决策。

罗德蓖麻 帮助公司获得正确的分析！他帮助国际组织和小型企业改善他们在数据分析、数据科学、技术战略和技术领导力方面的工作。除了咨询，Rod 还喜欢公开演讲、教学和写作。你可以在rodcastor.com和通过他的 邮件列表 了解更多关于 Rod 和他的工作。

什么是分类标准？

原文：https://towardsdatascience.com/the-illustrated-guide-to-classification-metrics-the-basics-cf3c2e9b89b2?source=collection_archive---------34-----------------------

人工智能图解指南

衡量和比较机器学习解决方案背后的基础概述

在我从事数据科学工作的这些年里，我总是发现指标是一个有点神秘的话题:你知道你必须使用哪些指标，但你并不总是明白为什么。例如，一些作品使用特殊性，而另一些作品使用精确性。这是为什么呢？在这篇文章中，我回顾了一些基本的度量标准和它们背后的直觉，希望能稍微揭开这个主题的神秘面纱。为此，我尽了最大努力为您提供插图:

这是一个多部分系列计划。在这一篇中，我将重点放在该领域的每个人都必须知道的三个主要指标:准确性、敏感性/特异性和准确性/召回率，以及全能的混淆矩阵。

事不宜迟，我们先从一个简单的二元问题开始。

明天会下雨吗？

我们的二元问题:预测明天是否会下雨。

有两种可能的答案:是的，会下雨和不，不会。然后，我们可以等待第二天，看看会发生什么:雨或孙。这是一个经典的二元分类问题:我们必须在两种结果之间进行预测。

自然有两种方式是对的:你说下雨了，就下雨了，或者你说晴了，就晴了。同样，有两种方式是错的:你说下雨，结果是晴天，或你说晴天，结果雨下了你一脑袋。

有两种方法是对的，也有两种方法是错的。

如果我们的任务是预测降雨，我们将把降雨称为“积极的”，把太阳称为“消极的”。说雨和得到雨是一个“真正的积极”，而说太阳和得到太阳是一个“真正的消极”。相反，说下雨并晒太阳是“假阳性”——假警报，说晒太阳但下雨是“假阴性”，或者说误预测。

这四种可能的结果以矩阵的形式排列，如下所示:

全能的混乱矩阵。

这种表示被称为混淆矩阵并总结了四种可能性:关于雨是正确的，发出错误警报，错过雨，以及关于太阳是正确的。它被称为混淆矩阵，因为它显示了太阳与雨(假阳性)混淆的程度，以及太阳与雨(假阴性)混淆的程度。

你可能会想，“我不喜欢下雨！为什么下雨应该是一件积极的事情？”我同意一开始这不是很直观。我发现更容易记住“消极”是“自然/预期状态”。例如，在检测疾病时，健康是阴性，生病是阳性。

所有这些名字都有许多其他的昵称。例如，您可以分别使用名称“命中”、“错误警报”、“错过”和“拒绝”，这更直观一些。然而，标准的做法是使用积极/消极。

这是同一个矩阵，但使用了更直观的术语:

混淆矩阵元素的更直观的术语。

以生病/健康为例,“击中”是指你发现了疾病，而“拒绝”是指你拒绝承认这个人生病了。同样，如果你说这个人生病了，但他/她没有，你就发出了假警报，如果你错误地说他/她很健康，你就错过了疾病。

我们来加一些数字。

在荷兰，每年大约有 217 天的降雨。如果你问一个荷兰人明天会不会下雨，他/她会告诉你每天都下雨，他们再也受不了了😢。从字面上理解这个答案，普通荷兰人对雨的困惑矩阵是:

对荷兰人没有仇恨！这只是❤的一个例子

我们这位悲观的荷兰朋友在 217 个雨天里都猜对了，代价是发出了 148 次错误的下雨警报。因为他从来没有说过会是晴天，所以他从来没有错过任何一场雨，也从来没有对过一个晴天。

如果我们问一个完全乐观的人，一个总是希望太阳的人，我们会得到相反的结果:148 天的太阳被正确预测，217 天的阵雨被错误预测。

我们现在面临的问题是:悲观的荷兰人的预测比过度乐观的荷兰人的预测好或差多少？换句话说，我们如何量化 这些预测 有多好？

优度度量

衡量这些预测有多好的一个简单方法是考虑有多少预测是正确的。这叫做精度。

悲观的荷兰人在 365 天内做出了 217 次正确的预测，准确率为 59%，而过度乐观的荷兰人在 365 天中只有 148 天是正确的，准确率仅为 41%。这使得悲观的荷兰人成为比过度乐观的荷兰人更好的榜样。

形式上正确的预测是 TP + TN，而 TP + TN + FP + FN 是预测总数。因此，精度可计算如下:

准确度:绿色超过绿色和红色。

或者简单来说:绿过绿，红过红。

准确性的问题

在我们的雨的例子中，荷兰的雨天明显比晴天多。因此，正确预测下雨比预测晴天更能提高准确率。

在极端情况下，您想要检测的可能只发生在 1%或更少的情况下。例如，撒哈拉沙漠每年只下几天雨，所以如果你总是说“太阳”，你 99%的时间都是对的。

不要相信这些云。明天也会是晴天。乔治·帕拉维西尼在 Unsplash 上的照片

在医疗环境中，疾病通常是罕见的，尽管罕见，你需要来检测它们。对每个人说“健康”并说你 94%准确是不切实际的。你需要一个更好的衡量标准。考虑这个例子:

医学领域典型的不平衡问题。

在这些情况下，分别计算积极因素和消极因素的准确性是值得的，因此您可以衡量模型对其中一个因素和另一个因素的执行情况。简单来说，我们需要一个“正精度”和一个“负精度”。这些在商业中被称为敏感性和特异性:

我们将准确性分为“积极”和“消极”两个方面。

请注意我们是如何将准确度公式分成两部分的:一部分检测我们检测阳性(命中超过未命中)的程度，另一部分检测阴性(拒绝超过误报)的程度。所以，如果你天真的说“大家都很健康！”你将是 0%的敏感和 100%的具体，而不是 94%的准确。

精度是一个的总结。它 试图将所有内容捕获到一个单一的值中。这就是它有用的原因:一个值比两个值更容易处理，但这也是一个缺点:它不能捕捉到问题的每个细微差别。另一方面，特异性和敏感性是指标。它们告诉你你的模型在特定环境下表现如何。

您可能会问，是否有可能将两个指标合并成一个值，以便我们可以进行汇总。一个很酷的公式是几何平均值，它被定义为乘积的平方根:

敏感性和特异性得分的几何平均值

这个公式有一个好处，就是在惩罚不平衡对的同时，平均两个分数。例如，90%对 90%的评分比 80%对 100%的评分稍高。

回到荷兰雨，悲观的荷兰人 100%敏感，0%专一，乐观的荷兰人 0%敏感，100%专一。使用我们的 G 分数，两个模型都有 G = 0。因此，在灵敏度/特异性分析下，它们同样不好。干净利落。

使用敏感性和特异性的限制

在某些情况下，有太多真正的负面因素需要考虑。所以，所有使用真否定的公式都不行。

例如，对象检测任务被定义为寻找对象并用边界框包围它们。真正的肯定是正确发现的对象，错误的肯定是错误的检测，错误的否定是遗漏对象，真正的否定是在没有要检测的东西的地方检测不到任何东西。

物体检测的例子。有多少真阴性？。维基百科:MTheiler CC BY-SA 4.0

请密切注意最后一点:真正的否定是在不期待什么的时候什么也不说。在上面的图片中，我们正确地没有给多少东西一个边界框？

再比如谷歌搜索。当你寻找狗时，返回的所有狗站点都是真阳性，非狗站点是假阳性，错过的狗站点是假阴性，剩下的整个互联网都是真阴性。

在这两个例子中，如果我们真的试图计算有多少真阴性，我们将总是有+99%的特异性，因为真阴性的数量将远远超过其他一切。在这种情况下，我们必须用另一个指标来代替特异性: precision。

当真阴性不可用时，我们使用精度和召回指标。

请注意,“敏感度”更名为“回忆”。它们是相同的度量，有相同的公式。这只是一个命名约定:使用 precision 的时候，你把 sensitivity 叫做“recall”。

使用对象检测示例，recall 测量您在所有对象中检测到多少个对象，precision 测量您在此过程中检测到多少个错误对象。以 Google 为例，recall 是指你返回了多少狗的网站，precision 是指狗的网站和非狗的网站在你的搜索结果中的比例。

注意:精确度/召回率不能代替灵敏度/特异性；它们处理不同的问题。只有当你不能有效地计算出真正的负数，或者它们太多的时候，前者才有意义。只要有可能，灵敏度/特异性更合适。

同样，这些是指示器。为了对它们进行总结，我们使用调和平均值，其计算方法是将乘积乘以总和:

F 分数，从精度和召回指标获得的摘要

调和平均值被称为 F 值。至于 G 分数，它也惩罚不平衡的配对。然而，它做得更有力。因此，为了获得高 F 值，模型必须同时具有高精度和高召回率。

多阶层问题

到目前为止，您可能会问:如果我们有几个类要预测呢？我们来挑一个问题:

我们二元问题的扩展，包括多云和下雪的预测

首先，如果我们有 n 个类，就有 n 个⋅ N 种可能:说太阳得到太阳，说太阳得到多云，说太阳得到雨等等在这些方法中，有 N 种方法是正确的(每个类一种)和 N(N-1)种方法是错误的(所有其他的可能性)。如果我们把它全部绘制成一个混淆矩阵，我们得到如下结果:

一个四类问题的混淆矩阵和准确性

和以前一样，精确度可以定义为我们得到的正确预测数(绿色)除以所有预测数(绿色加红色)。

为了计算每一类的敏感性和特异性，我们必须将我们的问题重定为类对非类。例如，多云与非多云。这样，我们可以为每个类提取一个二进制问题，并像以前一样计算我们的二进制度量。这里是一个敏感性和特异性的例子:

对多类问题的敏感性和特异性。真正的底片是灰色的。

你可能会想到的一件事是，如果我们添加更多的类，我们真正的缺点(用灰色表示)会变得非常大。灰色立方体比绿色和红色多得多。由于这个原因，敏感性和特异性在处理多类问题时意义不大。

出于上述相同的原因，精确度和召回分数更适合于这种情况，因为它们不依赖于真正否定(灰色框)的数量。下面是它的公式:

多类问题的查准率和查全率。在这种情况下不需要真正的否定。

有了这个，我们就有了一套完整的工具来评估我们的二元和多类问题模型，无论是平衡类(准确性)还是不平衡类(特异性/敏感性或精确度/回忆)。

到目前为止，我们已经了解了什么是真/假阳性和真/假阴性，以及它们对于二元和多类情况的意义。然后，我们看到了精确度是如何计算的，精确度是一个总结:一个量化模型有多好的单一值。

后来，我们看到当类不平衡时，精度不是一个可靠的度量，因为一个类倾向于支配精度值。为了解决这个问题，我们把这个公式分成一个“正准确度”，称为灵敏度，和一个“负准确度”，称为特异性。使用这两个值，我们对这两个类的模型性能有了更清晰的了解。

然而，在某些情况下，真正否定的数量可能太高，甚至是无限的。在这种情况下，使用精度和召回分数来代替，这不依赖于真正的否定。

最后，我们看到，我们可以计算 G 分数和 F 分数，分别作为灵敏度/特异性和精确度/回忆分数的汇总。对于不平衡的问题，这些总结比比较解决方案的准确度分数更能提供信息。

在本系列的下一期中，我们将看看如何处理提供分数而不是答案的模型。例如，“我有 60%的把握明天会下雨”。在这种情况下，我们需要为我们的模型设定阈值，以定义哪些是积极的，哪些是消极的。这带来了一些基本概念，如 ROC 曲线和平均精确度分数。

如果你对这篇文章有任何问题，欢迎评论或联系我。如果你是新手，我强烈推荐订阅。对于数据和 IT 专业人员来说，中型文章是 StackOverflow 的完美组合，对于新手来说更是如此。注册时请考虑使用我的会员链接。

感谢阅读:)

新冠肺炎的影响——plottly 数据可视化及与 SARS 的对比分析

原文：https://towardsdatascience.com/the-impact-of-covid-19-data-analysis-and-visualization-560e54262dc?source=collection_archive---------7-----------------------

获得关于新冠肺炎的有趣数据见解，并与 SARS 相比，直观显示冠状病毒的爆发

图片由皮克斯拜的 Gerd Altmann 提供

简介:

随着新型冠状病毒在各国的快速传播，世界卫生组织(世卫组织)和几个国家公布了过去几个月新冠肺炎影响的最新结果。

我查阅了许多资料和文章，以了解死亡趋势，我很高兴看到这个数据源，并决定在其上看到一些可视化。这里的目的是理解 可视化如何帮助从数据源 中获得信息性的见解。

对于可视化部分，我使用 Plotly。 Plotly 是 python 和 R 中可用的可视化工具，它支持大量交互式的高质量图形，是数据科学初学者的绝佳工具。

数据集:

数据集来源由“约翰·霍普金斯大学系统科学与工程中心(JHU·CSSE)”在其github 页面 进行累积、处理和最新更新

使用条款:如链接中 JHU CSSE 所述。【数据仅用于研究目的】。

数据集的详细信息如下:

每日报告数据

该 csv 文件包含关于受影响国家的信息[蓝色],这有助于识别病毒传播、受感染病例信息、死亡人数以及各国的恢复情况。还提供了国家坐标以供分析。

数据来源: 2019-nCoV 数据由约翰霍普金斯 CSSE 提供

2。时序数据

还提供了一个时间序列数据，其中包含各国的感染病例数、死亡数和恢复数。每个案例的时间序列数据都有单独的文件，需要在可视化之前进行处理。国家坐标也可用于地理图上的时间序列可视化，如地理图。

数据来源: 2019-nCoV 数据由约翰霍普金斯 CSSE 提供

代码:生成以下图表的所有代码和所用的数据集可在下面提供的链接中找到。

重要提示:

截至 3 月 3 日的数据已用于以下分析。请避免将分析得出的数据或见解用于医疗指导或商业用途。仅供学习之用。

相同的代码模板可以用于各种其他数据源。我鼓励读者也在 Plotly 中尝试其他图表，并根据应用程序需求定制代码。

展示你的关键发现的另一个重要方面是只使用一组从数据中推断关键见解的图表，而不是展示太多带有冗余信息的图表。

分析:

新冠肺炎的全球影响

2.感染率、死亡率和恢复率的描述性分析

3.新冠肺炎传播的时间线分析

4.新冠肺炎对 SARS 影响的比较分析

新冠肺炎的全球影响

为了了解病毒对地理景观的影响，我使用了 Plotly 的地理散点图。这个互动情节的代码可以在共享链接中找到，这将提供一个更清晰的互动可视化。

新冠肺炎的全球影响

观察:

从图表中，我们可以看到在首次发现这种病毒的中国，这种疾病已经感染了大量的人
尽管感染区域很大【蓝色】,但我们可以观察到死亡人数相当低，我们还可以看到迄今为止有许多康复患者

感染率、死亡率和恢复率的描述性分析

这里我使用了各种图表来展示如何从数据源中挖掘信息。

注意:由于与其他国家相比，中国的感染率高于 85%,因此最好将中国排除在外，查看其他国家的数字。这将应用于以下所有图表。

确诊病例: 分析使用 饼状图

跨国感染病例

感染病例(不包括 Mainland China)

与其他地区相比，中国大陆的受感染病例数量最多。仅次于中国，韩国、意大利和伊朗显示出较高的感染人数。

2。报告死亡人数: 利用条形图 进行分析

各国报告的死亡人数

报告的死亡人数[不包括 Mainland China]

从图表中我们可以看出，尽管与意大利和伊朗相比，韩国的确诊病例数最高，但它们的死亡率相比之下却低得多。现在，各省/州的回收率分析如下所示，

3。回收率: 分析使用树形图

各国的恢复率提供了各国如何缓解疫情的更广泛范围。在这里，不同级别的层次结构来自按顺序排列的数据集，“世界”、“国家”，接着是“省/地区”，如可以看到的 Mainland China(“世界”、“Mainland China”、“鄂”、“豫”、“皖”等)。

树形图:回收率

树形图:回收率[不包括中国]

有趣的一点是，与韩国相比，伊朗和意大利的追回率更高。从这里开始，深入研究其他属性(年龄、种族和地区)对恢复/死亡的影响可以使这些数字更加清晰。

新冠肺炎传播的时间线分析

显示病毒在短时间内在不同国家传播的速度是至关重要的。时间线分析需要对原始数据进行一些预处理，以在笔记本中提供的 Plotly 中可视化。

这里我只显示了感染病例的趋势。在各国的死亡和康复方面也可以观察到类似的趋势。使用下面的折线图给出了一个综合视图。

跨国家时间轴分析: 散点图

各国时间表分析

各国时间表分析[不包括中国]

观察:

虽然在中国可以观察到病毒传播的稳定增长，但在过去几天里，在其他一些国家可以看到病例数量的迅速增加。

时间线分析: 多重折线图

全球总体受影响病例、死亡和康复情况。

新冠肺炎与非典影响的比较分析

最有趣的部分是比较新冠肺炎和性质相似的严重急性呼吸系统综合症(SARS)的影响。SARS 的数据集取自kaggle 数据源 。该数据仅包含总体感染和死亡病例，因此在此将其可视化。我在一个窗口框架内分析了这两种病毒的影响，从它被发现到它在接下来的三个月内的影响。

感染病例时间表分析:

世界各地报告的感染病例:新冠肺炎 vs SARS

报告死亡的时间线分析:

世界各地报道的死亡人数:新冠肺炎 vs 非典

观察:

显然，与 SARS 相比，新冠肺炎的传播速度更快，死亡率也更高。在这种情况下，交通的进步可能是一个关键因素。

结论:

本文详细分析了新冠肺炎是如何影响世界的，以及由此得出的见解如何用于下游分析。这些图表还可以应用于其他场景，以推断关键的数据洞察力。

代码: 链接到代码和数据集

未来工作:

了解更多关于其他属性的信息，如患者性别、种族和年龄，以及它是如何导致死亡率的
交互式图表仪表板，提供总体摘要

参考文献:

[## 主页

世卫组织的主要作用是在联合国系统内指导国际卫生工作，并领导全球卫生合作伙伴

www.who.int](https://www.who.int/) [## ncov - CSSE

数据科学分析对金融机构的影响

原文：https://towardsdatascience.com/the-impact-of-data-science-analytics-on-financial-institutions-ee2d272427d1?source=collection_archive---------27-----------------------

数据科学的力量越来越大，彻底改变了不同的商业领域。其中之一就是金融。如果我们仔细想想，它实际上并不是什么新东西。

多年来，金融机构一直使用收集的数据来决定最佳的商业策略。让我们以银行为例。他们的成功主要取决于他们是否进行了准确的风险分析。这就是为什么公司希望改进他们用来在市场上建立更强地位的技术。

数据科学和机器学习创新使金融行业能够将大量收集的数据转化为有价值的商业见解。在金融领域运营的公司是数据分析领域的先驱，并且已经学会了如何在众多流程中发挥自己的潜力。

金融公司中的数据科学

管理客户数据

数据是从事金融业务的公司的重要资源。如今，金融公司必须处理大量数据，无论是结构还是数量都各不相同。该数据库包括市场数据、交易、移动和社交媒体活动等等。

数据量是一个问题，另一个是它的形式。我们可以将数据分为结构化、半结构化和非结构化。一个普遍的规律是，数据越不结构化，就越难以处理和提取业务洞察力。

处理非结构化数据最有效的方法是使用人工智能驱动的工具。其中一些使用自然语言处理、数据挖掘和文本分析等技术。机器学习算法分析数据，将其转化为可靠的信息，并建议最佳的商业解决方案。最终，目标是提高公司的利润，使用基于人工智能的工具是实现这一目标的最佳方式。

风险分析

管理者做出战略决策时会考虑许多方面，但最重要的是风险。数据科学和商业智能开发专门针对风险分析的创新。它是如何工作的？

风险管理集中于测量损失的频率，并根据现有数据乘以损失的严重程度。有许多风险来源，如客户行为、竞争对手、投资者或监管者。

领导者需要能够首先识别风险，监控风险，然后确定特定风险的优先级。机器学习-软件可以支持金融机构，并为它们执行这些操作。因此，从事金融业务的公司能够比以往任何时候都更快地验证客户的信誉。交易受到持续监控，以便公司可以立即采取措施降低不良后果的风险。

欺诈检测技术

欺诈是金融公司的主要担忧之一。每笔交易中，欺诈的危险都在增加。毫无疑问，每个人都听说过信用卡欺诈——这是金融机构中最常见的欺诈之一。

从事金融业务的公司需要向客户保证无懈可击的安全性。要做到这一点，他们必须应用一个系统来检测欺诈行为，并提醒员工注意危险。机器学习技术提供了各种工具，这些工具具有识别异常活动并自动向金融公司发送消息的功能。

合格的数据科学家能够创造出能够确定交易数据模式的算法，这种模式在大多数情况下会导致操纵。显然，日常犯罪分子会想出新的方法来欺骗系统。这就是基于人工智能的系统如此珍贵的原因——算法具有自学能力。这意味着该系统将每天自我改进，并随着时间的推移而增加有效性。

引入定制客户的方法

为了留在市场上，每个公司都需要保持竞争力。这意味着不仅要保持高质量的服务，还要在其他领域不断发展。

维护与客户的个性化关系是任何企业面临的最重要的挑战之一。数据科学使公司能够分析客户的数字体验，然后在考虑客户个人偏好的同时引入改进。

通过语音识别和自然语言处理等技术，人工智能现在能够比以往任何时候都更好地理解人类的语言和情感。由于收集了信息，金融机构可以向他们的每个客户提供个性化的方法和服务。

如何将数据科学解决方案引入金融机构？

为了充分利用数据科学机遇，与经验丰富的数据科学家合作至关重要。最大的公司建立了整个部门，只专注于数据分析。他们建立了一个数据分析师和商业智能专家团队。通过这种方式，他们能够充分利用数据的潜力，超越竞争对手。

对于中小型公司来说，创建一个新的部门甚至雇佣全职数据科学家可能成本太高。有一个解决办法。虽然数据科学行业相对较新，但市场上有专门从事数据科学咨询的公司。通过这种方式，中小型企业可以从收集的数据中获得有价值的商业见解，而无需进行巨额投资。

结论

金融机构获得了一个难以置信的机会。数据科学分析有足够的力量来加速任何金融公司的发展并增加其利润。

大数据时代已经开启，没有回头路。只有通过实施人工智能驱动的解决方案和机器学习工具，金融机构才能面对海量数据，并将其转化为见解。

地理空间特征对机器学习的影响

原文：https://towardsdatascience.com/the-impact-of-geospatial-features-on-machine-learning-3a71c99f080a?source=collection_archive---------42-----------------------

关于位置数据对机器学习模型的增值

预测冰淇淋销售没有季节模式？不会吧！(照片由蓝菊·福托格拉菲在 Unsplash 上拍摄)

I magine 预测冰淇淋的销售，却忽略了对时间维度的适当处理:虽然在总体水平上(例如每年)进行预测可能仍然会产生良好的结果，但当你进入季节细节时，你会很快进入状态。

位置数据也是如此。在处理地理参考数据时，忽略位置维度将导致预测模型无法解释已经进行的观察，最终将导致不精确和不太稳健的模型。与时间维度一样，您的模型在聚合级别上看起来可能还不错。然而，这对你的客户没有帮助，他住在山里，不断收到潜水设备的报价。

使用地理空间数据创建稳健而精确的模型(照片由 Morning Brew 在 Unsplash 上拍摄)

嗯，听起来很明显，对吧？是的，你会这么想。然而，我观察到，当涉及到高级分析或机器学习时，地理空间维度经常被忽略。在我看来，这主要是因为两个原因。

我的数据没有地理参考。它不包含纬度和经度

首先，您必须确定您实际处理的是地理空间参考数据。它不包含任何坐标的论点是不适用的！无论何时，只要您能够回答在“何处”进行了特定观察的问题，您就有了现成的空间数据。想想销售点数据、客户数据或来自物联网设备的数据。我们的绝大多数数据都以某种方式与地球上的某个位置相关联。通过对您的数据进行地理编码，并在您可能已经拥有的地址或城市名称之外添加纬度和经度信息，您可以提升这些信息的全部潜力。

SRS、几何形状、尺寸…呃，处理地理空间数据很复杂。

其次，初看起来，处理地理空间数据可能比处理依赖于时间的数据稍微复杂一些。当你试图自己解决空间复杂性时，你很快会遇到像空间参考系统和球面几何中的复杂计算这样的术语。

好消息是:你不必自己解决这些复杂的问题！有很好的工具，可以帮你卸下计算几何的重担。如果您在企业环境中工作，您应该考虑利用多模型数据管理平台透明地连接您的业务和位置数据的可能性。我选择的平台是 SAP HANA Cloud 及其空间功能 ( 嗯，我可能会有偏见 ！)。然而，这里描述的大多数方面是独立于底层技术而适用的。

GIS 和非 GIS 应用程序正在消耗底层模型

在多模型数据管理平台上运行地理空间工作负载的主要优势是生产力、敏捷性、加速和集成。通过在数据管理层实施高级分析和机器学习模型(无论有无空间数据),您可以确保构建在该平台上的所有上游应用程序都能使用结果，并以一致的方式提供给不同的用户组。

现在有了平台，它们结合了地理空间数据处理和嵌入式机器学习的能力。但是，我们真的能量化将地理空间特征纳入我们的机器学习模型的好处吗？

我试图挑选一个具体的例子，比较同一个回归模型包含和不包含数据的位置维度。底层数据集包含墨尔本市房屋的属性和销售价格。我根据房子的大小、房间数量、停车位数量等，训练了一个房子价格的回归模型。然后，第二个模型已经使用相同的特征进行了训练，但是这一次还生成了诸如该地方周围的餐馆数量和到海湾的距离之类的特征。

比较具有和不具有地理空间特征的相同回归模型

在本例中，我们可以测量到，中值绝对误差从 300，000 澳元降至 130，000 澳元，而当增加位置维度时，模型的稳健性显著提高。

为了隔离地理空间特征的影响，我使用了第二个模型来预测参考房屋的价格(600 平方米的土地面积，160 平方米的建筑面积等)。)横跨城市的不同位置。根据型号，价格从 33 万澳元到 250 万澳元不等，仅取决于位置！

对同一栋房子的预测在 33 万澳元和 250 万澳元之间变化，取决于位置(红色=昂贵；用叶制作而成

有趣的是，在没有地理空间特征的情况下，对回归模型贡献最大的特征是房屋的建造年份。房子越旧，往往越贵。撇开历史建筑不谈，我解释对价格影响的方法是:地点。旧房子往往位于靠近市中心的居民区，而新房子往往位于郊区的开发区。

这反过来意味着，在我们的例子中，位置维度是如此重要，以至于它甚至通过使用相关的特征潜入到我们的非空间模型中。

在我的 SAP 博客上查找技术细节

你可以在 SAP 社区页面 上的我的 博客中阅读上述例子的所有技术细节。博客还包括完整的 Jupyter 笔记本，可以让你重现分析。最快的入门方式是使用免费的 SAP HANA 云试用版，其中也包括空间处理引擎。

房价预测的例子清楚地量化了将地理空间特征纳入机器学习模型的价值。如果你看一下上面链接的更具技术性的博客，你也会注意到包括位置和其他数据源(如 OpenStreetMap)的努力是可以监督的，并且在任何情况下都是值得的。

空间数据科学和数据库内机器学习的力量

如果你对更多高级地理空间分析的例子感兴趣，请查看我基于波尔图市出租车轨迹数据的其他博客。用于复制该示例的完整 Jupyter 笔记本包含在各自的博客中。

请查看 SAP 社区页面 查看# saphanaspacial上的内容。

地理空间超级力量

用纸质过滤器改进浓缩咖啡

原文：https://towardsdatascience.com/the-impact-of-paper-filters-on-espresso-cfaf6e047456?source=collection_archive---------6-----------------------

空气过滤器与浓缩咖啡机的对比

2019 年 5 月，斯科特·拉奥(Scott Rao)推广了一种高萃取率的浓缩咖啡技术 ( > 25%对 18%至 22%范围的 3:1 镜头)，涉及 Aeropress 过滤器(过滤浓缩咖啡)。当时，我正在深入探索的断奏浓缩咖啡技术，我不想在我的过程中增加另一个变量和另一个步骤。我把这个想法放在了尝试的清单上，在 2019 年的 12 月，我终于有了一些时间。我不想只在常规拍摄中使用这种技术；我想知道它是否有提高断奏击球的潜力。

斯科特发现，由于采用 Aeropress 滤纸进行更精细的研磨，他可以获得更高提取率的美味照片。这项技术包括使用更精细的研磨，然后在咖啡球的上下放置一个湿纸过滤器。顶部过滤器应该通过减少沟道效应来缓解淋浴问题。底部过滤器将阻止较细的研磨物堵塞过滤器。由于使用了更细的研磨，可以获得更高的提取率。然后他用一个 DE1+ 做了一个 3:1(输出:输入)的镜头。

Aeropress 和 Espresso 的简史

浓缩咖啡篮由金属制成，可以承受生产浓缩咖啡所需的高压。滴滤咖啡使用纸质过滤器，因为没有压力要求。法国新闻有一个过滤器，但地面都完全淹没在同一时间。当 Aeropress 问世时，这种技术似乎介于法式压榨和意式咖啡机之间。

切割 Aeropress 纸质过滤器并将其放入浓缩咖啡篮的想法在咖啡界并不新鲜；斯科特推广了这项技术。通常在实验中，许多人独立地得出相同的结论。我不确定是不是这样，但作为一个研究者，我觉得有义务深入挖掘一下，看看题目里还有哪些作品是这样做的。回顾 2011 年，使用气压过滤器的想法被引入，以帮助减少咖啡醇，但进一步观察浓缩咖啡是否好，另一位作者发现了积极的结果。

2015 年，人们对这个话题又有了新的兴趣，但它并没有流行起来。同样，这是篮子底部的单个气压过滤器。他们发现了更快的流速和更好的味道。

在斯科特发表他的结果之前一年，这个家伙实际上做了斯科特用两个过滤器做的事情。因此，尽管宣称原创很容易，但这个想法已经存在，但还没有完全普及。Scott 测量了提取，发现该技术能够以更高的速度提取。在斯科特的视频在咖啡社区疯传后，咖啡师 Hustle 写了一篇很好的文章。

虽然这些讨论不是同行评议的研究，但它们表明这种想法已经存在一段时间了。我原本打算把这项技术称为拉奥滤纸(RPF)技术，但我决定 RPF 应该只提及司各特使用的具体技术，而不是所有的滤纸技术。然而，在找到 2018 年的视频后，RPF 应该被称为双层纸过滤器(DPF)，因为它只是由斯科特推广，但却是由别人首先发现的。对于命名，我想把所有这些技术和变体称为过滤器(PFF)中的纸过滤器，作为一种速记，因为我用断奏镜头做了一些变体。

断续镜头中滤镜(PFF)中的纸质滤镜

我没有立即尝试用纸过滤器的方法来拍摄断续的照片，因为我已经得到了一张相当惊人的照片。然而，我把它加入了我的清单，回到 2020 年 1 月，我开始尝试。我认为它有一些潜力，但我惊讶的是最佳位置在镜头内。

首先，我必须找到最佳位置。我想做实验，所以我从底部的纸开始。我想我会试着在底部，然后顶部，然后两者，然后通过在层间添加它来获得乐趣。快速回顾一下:我的断奏在中间很好(<400um) on the bottom, Coarse (> 500um)，在中间(400um < Mid < 500um) on Top.

On the bottom showed some taste improvement and some extraction improvement, but I was already getting a big benefit from the staccato layering. The major finding was that putting the paper filter between the Fine layer and the Coarse layer made a big difference in taste. The filter on the top didn’t seem to affect the outcome in terms of taste. If anything, it had a negative affect on taste, so I focused on the filter on the bottom or above the fine layer.

The key is a damp filter: too wet causes the shot to be a little less rich. Too dry causes channeling because the process of the filter getting wet initially has some issues with surface tension.

I collected some paired data, but again, similar to 压力脉动，我混合了其他实验，远远不能测试统计显著性。这是一项定性研究，表明纸质过滤器可以改善断奏的味道，同时保持或稍微减少提取。定期拍摄的数据表明提取率更高，口味更好。

这两个指标是:最终得分和咖啡萃取。

最终得分是 7 个指标(强烈、浓郁、糖浆、甜味、酸味、苦味和余味)记分卡的平均值。当然，这些分数是主观的，但它们符合我的口味，帮助我提高了我的拍摄水平。分数有一些变化。我的目标是保持每个指标的一致性，但有时粒度很难确定。

使用折射仪测量总溶解固体量(TDS ),该数值与咖啡的输出重量和输入重量相结合，用于确定提取到杯中的咖啡的百分比。

1)最终得分。2) 1:1 咖啡萃取。3) TDS 为 1:1

原始数据！

数据摘要:

纸过滤器导致更短的镜头，味道更好，但提取的咖啡更少。这似乎导致了更早的金发。这可能会干扰测量，因为它会导致镜头比正常比例更早结束。我的目标是口感，而不是特定的重量(通常 1:1 是正确的比例)。

我非常喜欢这种味道，所以我把它加入到我通常的断奏套路和非断奏套路中(对比视频)。我怀疑这种放置是由于过滤器对来自粗糙层和中间层的提取物有影响。我认为过滤器可能会带走油，但很难确认只有 TDS。我试过在底部和上面都装一个过滤器，但是它带走了味道。

为了看得更清楚，我比较了两张有纸过滤层和没有纸过滤层的照片。这两个镜头都是在一个 20 克的 VST 篮子里的普通的 18 克镜头。烤的有点暗，所以篮子在 18 克的时候是满的。

完整视频:https://youtu.be/9NOCwp1W-dU

PFF 拍摄出来更快，这使得一个人得到更好的研磨。我的理论是，它也有助于减少一些由过滤器上的孔径分布引起的通道问题。

然后事情变得很奇怪。

我在我的金快车上换掉了旧的金属淋浴屏。我把它打扫得很干净，我想我会把它留在身边。我试着把它放在粗糙层之后，它似乎改善了味道。我在包装为 15g 的 7g VST 过滤器上做了这个测试，因为过滤器的形状，金属过滤器完全覆盖了它下面的圆盘。我也不知道怎么解释。与 Aeropresso 过滤器相比，我很难摆弄金属过滤器，因为淋浴屏幕没有整个过滤器宽，导致一些侧沟。

更多数据:深入了解 PFF 咖啡萃取

我收集了每一杯浓缩咖啡的数据，所以我拿出了过去 6 个月的数据来帮助理解其中的差异。我拍摄了 281 张照片，这些照片是从白利折光仪或 Atago 数字折光仪采集的(根据之前的数据，它们之间的差异在统计上并不显著)。这些数据不是成对的，但人们可以看到 PFF 提取在更大样本量上的总体表现。

我还使用两个杯子为每个镜头收集了两个折光仪数据点:1:1 镜头的总溶解固体(TDS)和 3:1 镜头的 TDS。我没有在我的机器下使用秤，因为没有足够的空间，所以我的 1:1 比例和 3:1 比例有轻微的差异。我喝下 1:1 的，然后扔掉剩下的。结果我有 562 个数据点看:woohoo！

让我们关注 1:1 的镜头，因为大部分提取发生在那里:

数据显示了我如何增加了我的镜头长度，部分是由于 PFF。对于断续的镜头，PFF 似乎从提取中抽离，但过滤掉提取中不太理想的成分。

另一个困惑是预输注，因为 PFF 已经迫使我使用更长的预输注。我最初进行了 10 秒钟的预输注，但在过去的两周内，我将预输注时间延长到了 30 秒。

趋势很难猜测，单独的实验将是有益的。添加到列表中！

好奇的问题:如果一个长时间的预灌注(2 巴)获得了如此高的提取率，为什么除了让注射更快出来之外，还要拉 9 巴？

再来看一下 1:1 镜头中连接最终得分和咖啡萃取的预注入。

我从与 PFF 相关的数据中发现的一个主要结论是，3:1 的比例是不必要的，因为大多数咖啡萃取是在 1:1 甚至接近 1.5:1 的比例下进行的。我不相信拉得更长会改善味道，所以在这一点上，只要把 1:1 的镜头冲淡到 3:1。

此外，这些 PFF 实验在我的镜头上有三个:

我在我的大部分常规和断奏照片中加入了一个纸过滤器。
我把我仪式中的预输注时间从 10 秒增加到 20 到 30 秒。
我用纸过滤器的方式来提取照片(为未来的文章)。

如果你愿意，可以在 Twitter 和 YouTube 上关注我，我会在那里发布不同机器上的浓缩咖啡视频和浓缩咖啡相关的东西。你也可以在 LinkedIn 上找到我。

我的进一步阅读:

规则对查询的影响

原文：https://towardsdatascience.com/the-impact-of-rules-on-queries-e69468dadf98?source=collection_archive---------74-----------------------

实现数据中的知识

应用程序处理和操作数据的逻辑通常由位于数据库和表示层之间的应用程序或逻辑层控制。这就形成了必须符合数据库结构的请求。下图代表了经典的三层体系结构，世界上大多数 IT 系统都是在此基础上构建的。

https://en . Wikipedia . org/wiki/Multitier _ architecture #三层架构

然而，知识图提出了这种设计的范式转变，模糊了逻辑和数据之间的界限。通过将领域的一些知识通过规则带入图中，知识图捕获的不仅仅是系统中的数据。因此，规则可以使查询和请求更容易编写和管理，这反过来又使应用程序更灵活、更不容易出错、更快。

本文将介绍一个简单的例子来展示规则对查询设计的影响。这个例子将在由 Oxford Semantic Technologies 开发的高性能知识图和语义推理引擎 RDFox 上演示。

介绍规则

规则是一个逻辑语句，它扫描图形以寻找与规则匹配的数据模式。

考虑 RDFox 控制台中呈现的下图:

为此示例导入的原始数据片段。

从图中很容易判断出道格拉斯·亚当斯和查理·卓别林出生在英国，因此他们是英国漫画家。在经典的分层方法中，可以在中间层编写逻辑，以原始形式直接查询基图。根据定义，这个查询将比我们直接查询所有英国漫画的知识图更复杂。

第一个规则作用于关系的子类，对于我们的数据，这使得道格拉斯·亚当斯和查理·卓别林之间的直接类型关系成为喜剧。

[?x, a, ?z] :- [?x, a, ?y], [?y, :subClassOf, ?z] .

接下来，我们将英国漫画的概念引入图表。为了添加这个概念，我们可以在 Datalog 中使用一个简单的规则来实现英国漫画关系:

[?x, a, :UKComic] :- [?x, a, :Comic] , [?x, :born_in, :uk] .

也就是说:

如果?x是一个:Comic，而?x是born_in :uk，那么?x就是一个:UKComic。

具体化规则

RDFox 将扫描数据存储中满足规则主体的三元组。每当“:-”符号后的模式得到满足时，RDFox 就会向图中添加一个:UKComic三元组，并在找到所有英国漫画后停止。

结果如下图所示:

与前面显示的相同的片段显示了规则添加的内容。特别是与新的英国漫画概念的直接联系。

使用 RDFox，一旦规则被导入到数据存储中，或者每当新的数据点被添加到数据存储中时，这些三元组就被规则具体化。例如，一部在英国诞生的新漫画在被添加到图表中时会被自动标记为:UKComic。

规则如何帮助查询？

在第一个图中，要获取英国漫画，查询必须首先识别在英国出生的实体，然后识别漫画实体，然后返回两个答案中存在的实体。在 SPARQL 中，查询可以用以下方式表示:

原始查询针对源数据运行。

使用英国漫画规则，回答相同问题的查询要简单得多，因为它只搜索:UKComic实体:

使用 new :UKComic 概念的简化查询。

我们还可以注意到，简化的查询执行起来更快。这在更大的数据集和更复杂的查询中变得更加明显。

规则通过以一致和可管理的方式扩展原始数据来提供帮助:随着新数据的添加，相同的规则也会触发。重要的是，如果数据被删除，反之亦然，并且先前触发的规则的后果被撤销。

因此，用规则对经常搜索的概念进行建模有助于更快地回答问题，但由于查询更简单，它们也使中间层更容易维护。更简单的查询使应用程序更加灵活。

大多数查询可以通过规则的 IF 部分来建模，这意味着许多现有的应用程序可以通过知识图变得更快、更灵活。如果您当前的架构无法提供用户所需的查询性能，为什么不使用规则将数据的逻辑推送到知识图中呢？尝试使用 RDFox 结合规则编写查询，您可以在这里注册试用。

要了解更多关于知识图表的信息，请点击阅读我们在 TDS 上的介绍。

关于牛津语义技术

牛津语义技术公司(Oxford Semantic Technologies)背后的团队于 2011 年在牛津大学计算机科学系开始研究 RDFox，他们坚信灵活和高性能的推理是数据广泛应用的一种可能性，而不会危及结果的正确性。RDFox 是第一个面向市场的知识图，它是基于推理从头开始设计的。牛津语义技术公司是牛津大学的一个分支，由主要投资者支持，包括三星风险投资公司()、牛津科学创新公司( OSI )和牛津大学的投资部门( OUI )。作者很自豪能成为这个团队的一员，也是已故伟大的道格拉斯·亚当斯的粉丝。

由paweczerwi324ski在 Unsplash 上拍摄的照片

安全配置错误的影响及其缓解措施

原文：https://towardsdatascience.com/the-impact-of-security-misconfiguration-and-its-mitigation-4c54fda4d025?source=collection_archive---------52-----------------------

克里斯托夫·高尔在 Unsplash 上拍摄的照片

当今的网络安全威胁形势极具挑战性。攻击者一直在寻找利用应用程序和系统中的安全漏洞来访问或控制敏感信息，并发起勒索软件等网络攻击。

随着公司在不同的平台上传播敏感数据，软件即服务 (SaaS)平台，容器，服务提供商，甚至各种云平台，他们开始采取更加主动的安全方法是至关重要的。

这意味着将安全性集成为开发过程的核心部分，将安全性转移到左边，并尽可能地自动化您的基础设施，以摆脱低效、耗时且昂贵的策略。构建强安全性的一个最基本的方面是维护安全配置。

在研究中，发现近 73%的组织至少有一个关键的安全错误配置，这可能暴露关键数据和系统，或使攻击者能够访问敏感信息或私人服务或主 AWS (Amazon Web Services)控制台。

这些“关键的”安全错误配置可能会使远程 SSH 对整个互联网开放，这可能会允许攻击者从任何地方访问远程服务器，从而使防火墙和 VPN 等网络控制变得毫无意义。此外，使用 root 帐户来自互联网的 SSH 流量也有严重的安全影响。

安全错误配置漏洞通常是由于不安全的默认配置、配置更改的副作用或仅仅是不安全的配置造成的。这表明需要基本的配置审计和安全卫生以及自动化流程。服务器应该按角色分组，而不是使用传统的网络控制，使用自动化来创建小而安全的网络路径，以建立对等体之间的信任。

在我们深入研究安全错误配置的影响之前，让我们看一下安全错误配置的真正含义。

什么是安全错误配置？

安全错误配置是对服务器或应用程序配置、网络设备等实施不正确的安全控制。这可能会导致安全漏洞。

例如，web 应用程序的不安全配置可能会导致许多安全缺陷，包括:

文件夹权限不正确
默认密码或用户名
启用设置/配置页面
调试已启用

安全错误配置的范围很广，从忘记禁用默认平台功能(该功能可能授予未经授权的用户(如攻击者)访问权限)到未能在 web 服务器上建立安全标头。安全错误配置可能发生在应用程序的任何级别，包括 web 服务器、数据库、应用服务器、平台、定制代码和框架。

web 应用程序中的安全错误配置的影响可能是深远的和毁灭性的。据微软称，网络安全漏洞现在每年在全球范围内造成高达 5000 亿美元的损失，平均每个漏洞给企业造成 380 万美元的损失。

更糟糕的是，关于网络安全攻击的最大误区之一是，它们不会影响小企业，因为它们太小，不会被瞄准或注意到。

打破这个神话，小企业趋势预测至少 43%的网络攻击是专门针对小企业的。从根本上说，云错误配置等安全错误配置是组织面临的最大安全威胁之一。

事实上，正是云的错误配置导致近 4 亿时代华纳有线电视客户的个人信息泄露。一家外部服务提供商意外错误配置了云存储，并将其公之于众，将该公司的 SQL 数据库暴露给了所有人。

安全错误配置示例

为了让您更好地理解 web 应用程序中潜在的安全错误配置，下面是一些最佳示例:

示例#1:默认配置未被修改/更新

如果您没有更改 web 应用程序的配置，攻击者可能会发现服务器上的标准管理页面，并使用默认凭据登录并执行恶意操作。

示例 2:您的服务器上没有禁用目录列表

在这种情况下，如果攻击者发现了您的目录列表，他们可以找到任何文件。黑客可以找到并下载你所有编译好的 Java 类，他们可以通过逆向工程得到你的定制代码。然后，他们可以利用应用程序中的这一安全控制缺陷进行恶意攻击。

示例 3:不安全的服务器配置可能会暴露用户的个人信息

存在安全错误配置的应用程序通常会在错误消息中显示敏感信息，这些信息可能会返回给用户。这可能会让攻击者危害您用户的敏感数据，并获得他们的帐户或个人信息的访问权限。

示例 4:示例应用程序没有从应用程序的生产服务器上删除

很多时候，这些示例应用程序都有安全漏洞，攻击者可能会利用这些漏洞来访问您的服务器。

示例 5:操作系统的默认配置

大多数操作系统的默认配置侧重于功能、通信和可用性。如果您没有更新或修改操作系统的默认配置，可能会导致服务器不安全。

为了保护您的服务器，您应该为您组织中的所有服务器构建复杂而可靠的服务器强化策略。使用 CIS 基准来帮助强化您的服务器。

如何检测安全错误配置:识别和缓解

安全错误配置是一个普遍存在的问题，在许多系统、网络和应用程序中都存在，您也有可能遇到这种问题。这些错误配置可能发生在 IT 基础架构的任何级别，并使攻击者能够利用应用程序中的安全漏洞发起网络攻击。

最常见的安全错误配置有哪些？

一些最常见的安全错误配置包括不完整的临时配置、从未修改过的不安全默认配置，以及对应用程序的连接要求和网络行为的错误假设。

随着操作系统、网络、应用程序、工作负载和框架以及云环境和混合数据中心的日益复杂，安全错误配置正迅速成为企业面临的重大安全挑战。这些环境多种多样且瞬息万变，因此很难理解和实施针对安全配置的适当安全控制。

例如，在管理跨云和混合环境以及内部的防火墙时缺乏可见性，这继续增加了安全性挑战，并使企业难以遵守隐私法规和安全性。

您的云平台、软件、应用程序、网络和服务器缺乏可见性是导致安全配置错误和风险增加的主要因素。

一份报告发现，几乎三分之一的网络环境中有 100 个或更多的防火墙，每个防火墙都有一套不同的规则需要管理。此外，34%的网络对其网络安全风险和合规性的实时可见性不到 50%,这导致整个基础架构缺乏可见性，并导致安全配置错误。

以下是更多安全错误配置的例子:

不安全的管理控制台为应用程序打开。这些端口暴露了应用程序，攻击者可以利用这一安全缺陷修改管理控件。
云中的闲置虚拟机:由于云缺乏可见性，公司通常不会意识到云中的闲置虚拟机，并连续几天或几个月继续为这些虚拟机付费。这些空闲虚拟机可能没有得到主动管理，在应用安全补丁时可能会被遗漏。
各种互联网服务的出站连接。这些可能会暴露软件在敏感环境中的意外行为。
试图与不再存在的应用建立通信的遗留应用。黑客可以复制这些应用程序，并与传统应用程序建立通信。

除此之外，web 服务器通常带有一组默认特性，包括 QA 特性、调试、示例应用程序和许多其他特性，这些特性在默认情况下是启用的。这些功能可能会为攻击者提供一种手段，通过提升权限来规避安全协议并获得对您的客户或组织的敏感信息的访问权限。

攻击者还可能试图检测低并发限制或长超时的错误配置函数，以便发起拒绝服务(DoS)攻击。具有低并发限制配置的函数可能导致 DoS 攻击，因为攻击者只需调用错误配置的函数几次，直到它不可用。

包含不安全敏感信息(如代码或环境变量中的令牌和密钥)的函数也可能被攻击者破坏，并可能导致数据泄漏。

如何诊断和确定安全错误配置？

有几种方法可以快速检测系统中的安全错误配置:

扫描混合环境和云基础架构以识别资源。使用内置服务，如提供安全检查的 AWS Trusted Advisor。
验证您是否有适当的访问控制
针对可疑用户活动或“正常”行为异常设置警报。异常行为可能表明您在配置设置中没有足够的安全控制。
检查管理控制台或服务器、网络、设备和应用程序的其他部分的默认配置。

安全配置错误的影响是什么？

根据 IBM 的一份报告，在过去的几年中，安全错误配置的数量激增。该报告发现，与安全错误配置相关的违规行为激增了 424%，占该年度受损记录的近 70%。

虽然公司正在整合更好的安全实践并投资于网络安全，但攻击者正在进行更复杂的攻击，难以快速跟踪和缓解。

在各种企业中，人为错误也正在成为一个更加突出的安全问题。这些人为错误会导致一系列安全缺陷，包括安全错误配置、网络钓鱼攻击、恶意软件、勒索软件、内部威胁等。

安全错误配置可能源于简单的疏忽，但是很容易将您的业务暴露给攻击者。在某些情况下，错误配置的网络和系统可能会使数据完全开放，而不需要任何安全漏洞或恶意行为者的攻击。

一个常见的安全错误配置是将不安全的敏感数据留在数据库中，而没有适当的身份验证控制和对开放互联网的访问。

由于安全错误配置导致的最显著的违规事件之一是1 . 54 亿美国选民记录在一次塞尔维亚黑客的安全违规中暴露。

该数据库包含 1.54 亿选民的记录，包括他们的姓名、年龄、性别、电话号码、地址、婚姻状况、国会政党、州参议院选区和估计收入。数据库是一个 CouchDB，不需要认证，任何人都可以访问，这导致了巨大的安全漏洞。

在这个安全错误配置的例子中，存储设备或数据库缺乏基本的安全控制导致互联网上每个人的大量敏感和个人数据被利用。

向用户公开的代码和敏感数据越多，安全风险就越大。如果未能正确配置对应用程序数据库的锁定访问，攻击者就有机会窃取数据，甚至修改数据的一部分来进行恶意活动。

如何防止安全错误配置？

防止安全错误配置的第一步也是最重要的一步是了解系统的行为，并理解每个关键组件及其行为。

要做到这一点，您需要拥有整个基础架构的精确、实时的地图，该地图显示您的数据中心环境中的流量和通信，无论是在混合云上还是在内部。

一旦您彻底了解了您的系统，减轻由于安全配置不当而导致的风险的最佳方式就是锁定最关键的基础设施，只允许特定的授权用户访问生态系统。

以下是一些防止安全错误配置的有效方法:

部署可重复的强化流程，使部署另一个正确配置的环境变得简单快捷。开发、生产和 QA 环境应该完全相同地配置，但是在每个环境中使用不同的密码。自动化此过程，以减少设置新的安全环境所需的工作量。
定期为每个环境及时安装软件更新和补丁。或者更好的是，修补一个黄金映像，然后将该映像部署到您的环境中。
构建强大的应用程序架构，提供安全有效的组件分离。
经常定期运行审核和扫描，以帮助识别潜在的安全错误配置或缺失的补丁程序。
保持一个结构良好的开发周期。这将有助于确保在开发阶段对应用程序进行安全测试。
就安全配置的重要性以及它们如何影响组织的整体安全性对您的员工进行教育和培训。
加密静态数据，帮助保护信息不被泄露。
对目录和文件应用适当的访问控制。这有助于弥补未受保护的目录和文件的漏洞。
如果实现自定义代码，请在将代码集成到生产环境之前使用静态代码安全扫描器。还应该由安全专业人员执行动态测试和手动审查。
使用没有任何不必要的特性、示例、文档和组件的最小平台。移除或不安装不安全的框架和未使用的功能。
审查云存储权限，如 S3 存储桶权限。作为修补程序管理流程的一部分，检查并更新所有安全修补程序、更新和说明的所有安全配置。
实施自动化流程，确保所有环境中的所有安全配置都到位。

最后的想法

随着我们增加更多外部供应商、第三方供应商和混合云环境，动态和复杂的数据中心只会增加安全违规的可能性和人为错误的风险。

安全错误配置的影响具有深远的后果，会影响组织的整体安全性。尽管您可能已经实施了安全控制，但是您需要定期跟踪和分析您的整个基础设施，以发现由于配置不当而可能出现的潜在安全漏洞。

请记住，在混合云环境中拥有可见性可以为您带来优势，并帮助您应对安全错误配置。

作为第一步，Cypress Data Defense 提供了您的云基础架构的详细地图，帮助您自动检测异常行为，并减少安全中的错误配置。一旦您确定了您的关键资产和漏洞，您就可以使用缓解技术来限制攻击面并确保您的数据得到保护。

关于作者:

Steve Kosten 是 Cypress Data Defense 的首席安全顾问，也是“Java/JEE 中的 SANS DEV541 安全编码:开发可防御应用程序”课程的讲师。

来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

适当的数据文化的重要性

原文：https://towardsdatascience.com/the-importance-of-a-proper-data-culture-48c1b19ccd82?source=collection_archive---------47-----------------------

人工智能、机器学习或任何类型的分析的基础都始于数据驱动的组织

从人工智能开始意味着你需要一个合适的数据文化。人工智能不是魔法，尽管许多人可能仍然这么认为。在想到人工智能之前，数据需要有序。您需要文档、策略，最重要的是适当的数据文化。如何实现这一点？继续阅读…

阿夫克·斯豪滕与阿萨德·穆阿瓦德交谈

这是对该领域从业者的一系列采访中的第一篇，内容是关于用 AI 创造商业价值。阿萨德在卢森堡共同创立了公司 DataThings ，该公司致力于将数据转化为可操作的见解。他认为，数据可以帮助你更好地了解你的业务。

DataThings 的核心技术是时态多世界图数据库。简而言之，它定义了所有动态数据的图形存储和处理框架，包括通信流、社交网络、智能电网等。这实际上是一个用于组织网络分析的很好的数据库。

在我们的对话中，我们谈到了 Assaad 与客户一起工作的经历，以及他对该领域需要什么的看法。

Afke:“我们经常谈到这一点，但再一次，你能告诉我们刚刚开始人工智能主题的客户与更高级的客户之间的区别吗？”

阿萨德:“当我们带来新客户时，通常对人工智能的期望是，人工智能是一个神奇的天才。高级客户已经意识到这是他们自己的乌托邦。他们现在明白了在开始使用人工智能之前，创建适当的数据基础设施所需的投资。

新客户希望人工智能表现得像一顶神奇的帽子，他们希望你可以放入一组未清理的数据，然后你可以得到一只兔子。"

威廉·戴尼奥在 Unsplash 上拍摄的照片

Afke:“对我来说，这听起来并不少见，要把这只兔子从帽子里弄出来，需要做很多工作。你会给处于这种情况的人什么建议，成功的关键因素是什么？”

Assaad:“首先，也是最重要的，需要一个合适的数据文化。部分原因是大公司的统一数据政策。许多大公司都有子团队，每个团队都使用不同的技术或格式来存储数据。聚合数据的成本会很大。数据文档也非常重要，因为随着时间的推移，收集数据的人离开了公司，没有人能再了解这些数据是关于什么的。对于一个测量单位来说是一样的，如果它们没有被记录下来，或者在工业环境中不一样(统一)，就很难使用这些数据。”

Assaad:“我推荐一种适当的数据文化，一种统一的数据政策，数据文档，以及一致的术语

“举个例子，在像卢森堡这样的多元文化环境中工作的挑战是，这可以反映在数据中，你可能知道瑞士也是如此。我们在同一个数据集中发现了几种语言、缩写、数据格式、数据模式、术语。每个人都来自不同的文化(法语/德语/英语……)。这就是为什么一致的术语，语言、模式、格式、单位，是如此重要”。

Afke :“我可以说，没有适当的数据基础，很难从你的数据中获得价值，你有什么建议，如何开始？”

Assad:投资数据基础设施非常重要，尤其是在需要数据处理管道的速度/吞吐量时。我们的时态图形数据库每秒可以处理大约 400 000 个值。旧技术只能达到 10，000 v/s，例如，在银行部门，如果你有 10 亿笔交易，那就是 41 分钟和 28 小时的差别。

还有，投资硬件很重要；AI 对处理能力、GPU 非常消耗，对内存也很饥渴。当你有一个快速数据库的时候，你可以迭代几次，测试几个模型，少浪费数据科学家的时间(只是等待模型训练)，少用服务器，降低基础设施成本。大量的好处。GPU对于图像处理或非常大的数据集非常重要。他们可以将机器学习时间加快 10-20 倍。

投资合适的软件对于最大限度地利用硬件同样重要。这就是为什么我们正在大规模开发一种专门用于人工智能的技术。"

Assad:"投资在你的数据基础设施、硬件和软件"

Afke:“你和我过去都谈到过不快乐的数据科学家，你认为该领域的从业者感到沮丧的主要原因是什么？”

Assad:"很少有人喜欢数据清理，这是一个繁琐而耗时的过程。不同来源的数据聚合也是如此。我们最终花了一半的项目时间编写进口商和出口商来连接一个公司内所有不同的格式。

此外，数据分析本身对于最终产品来说是不够的，它需要集成到完整的软件环境中。许多利益相关者认为数据科学家的工作就是做好每一件事:从数据清理到建模、存储、分析、可视化、软件编排(docker 容器)到生产运行。但这实际上是整个 IT 团队的工作。为团队配备不同的个人资料和技能非常重要，这也是我们在项目中所期望的。"

Assaad:“许多利益相关者认为做所有事情都是数据科学家的工作，但这实际上是整个 it 团队的工作。”

Afke:“你会建议公司对此做些什么？

Assad:"了解关于 AI 的话题，实施数据文化政策，并准备投资适当的基础设施。

我喜欢用建筑的比喻:你首先投资于基础设施，然后建造一堵漂亮的墙——人工智能只是一堵漂亮的墙，后面有许多数据基础设施需要到位。"

“没有魔法，没有免费的午餐，没有捷径。”

Afke:“你会建议从业者做些什么呢？

阿萨德:“要有耐心，要有好奇心，要了解不同的主题、软件管道，并致力于在源头、在收集、数据库层面解决数据清理问题。”

总之，你需要适当的数据文化。对于刚起步的公司，建议是投资你的数据结构，投资硬件，投资软件。教育自己并对团队设定正确的期望也很重要。对数据科学家来说，是的，数据清理是工作的一部分，让我们把 数据工程变得性感！

谢谢你，Assaad，谢谢你的有趣的谈话和你给那些想开始学习人工智能的人的建议。我祝你在数据方面一切顺利。你想从阿萨德那里了解更多吗？查看他的 中型帖子 或博客 数据事物 。

关于我:我是一名人工智能管理顾问，也是当地一所商学院的“人工智能管理”研究主任。我的使命是帮助组织利用人工智能创造商业价值，并创造一个数据科学家可以茁壮成长的环境。 报名参加我的 简讯 获取关于 AI 管理的新文章、见解和祭品 这里。

问正确问题的重要性

原文：https://towardsdatascience.com/the-importance-of-asking-the-right-questions-93aa3128500a?source=collection_archive---------22-----------------------

尤其是如果你是一名数据科学家

我们生活在一个重视答案的世界。我们在学校学习如何在考试中回答问题，我们习惯于去工作，知道我们需要有答案，而我们的社会，总的来说，专注于找到解决方案，而不是弄清楚我们是否问了正确的问题。就像大多数经历过传统教育体系并开始在公司工作的人一样，我被训练得知道答案，我被教导我的贡献和价值在于我通过知道正确的答案来解决问题的能力。虽然我确实认为解决问题和找到正确答案的能力是一种很有价值的技能，但我想阐明在此之前的技能，即提出正确问题的技能的重要性。

玛丽·莱扎瓦在 Unsplash 上拍摄的照片

根据定义，问题和答案是联系在一起的，但它们是非常不同的技能组合。寻求答案是一个通过研究和实验进行排除的过程，试图将不同的信息拼凑起来，将事情缩小到一个解决方案。但是提问是一个通过批判性思维和想象力展开的过程。可以理解为什么作为一个社会，我们不重视问正确问题的成本，因为在某种程度上，我们问的问题越多，我们需要做的工作就越多，我们离完成我们需要做的事情就越远。这造成了一个系统性问题，即短期的修补优于长期的解决方案。

这对数据科学家来说意味着什么？

这个问题无处不在，但在像数据科学和工程这样以解决方案为导向的领域尤为突出，因为这些专业都是建立在解决难题之上的。数据科学家倾向于在我们完全理解问题之前就直接进入解决模式，因为我们认为我们已经有了答案。如果存在转换问题，我们可以进行个性化定位。如果存在留存问题，我们可以建立一个流失预测模型。虽然这些可能都是有效的解决方案，但它们可能只是治标不治本。

问错问题的代价

认为解决方案就是解决方案，即使它只是解决了症状，这可能是很自然的。尤其是在一个喜欢立即行动和快速修复的世界里，我们似乎永远没有时间去深入挖掘。我不会说，对于出现的每一个问题，你都需要深入探究你是否问了正确的问题，但我会告诉你一个事实，如果我们问了正确的问题，通常情况下，我们就不会解决一开始就不应该出现的问题。

在数据科学的背景下，成本通常来自两个主要方面，浪费的资源和意想不到的后果。第一个是相对直接的，如果我们没有问正确的问题，我们最终会浪费时间和精力来构建一个不适合目的的解决方案。第二个更邪恶，因为如果我们基于错误的标准来优化一个系统，我们可能会系统性地恶化情况。例如，如果我们将客户流失问题视为一个孤立的事件，并专注于提高保留率，而不问人们为什么会流失，我们可能会错过追溯到客户获取、用户体验和参与的问题，直到它成为客户流失问题。

每个系统都经过完美设计，以获得它所获得的结果

对出现的每个问题都有正确的答案是有价值的，但不提出正确问题的代价更加微妙和长期。如果我们总是优先考虑和重视快速解决方案，我们就在潜意识里鼓励问题发生。我们经常认识到进来解决问题的人，但大多数时候，当涉及到设计系统时，我们没有认识到提出正确问题的人。因此，不提出正确问题的真正隐藏成本是，一个社会或组织培养的人只关注短期而非长期。我们永远无法逃避问题和寻找答案的需要，但我们想要努力的是通过预先提出正确的问题来尽可能防止这种情况发生的能力。

如何提出正确的问题？

在业务中，人们经常在遇到技术问题时求助于技术资源。有道理对吧？然而，当我们生病时会发生什么呢？假设你感到疼痛，你去看医生，你得到的只是止痛药，因为那是你的症状。你会觉得有点吃亏，因为医生没有对你进行正确的诊断，也没有试图理解为什么疼痛会存在。这里的区别是我们的假定知识，当我们认为我们知道问题是什么时，我们有一个封闭的头脑在寻找具体的答案，但当我们不知道问题是什么时，我们有一个开放的头脑，希望别人能帮助解决问题。这里有几件事可以帮助我们克服在理解问题之前就急于解决问题的倾向。

当心你的假设

在我们开始提问之前，我们带着一系列假设来到桌前。假设帮助我们更快地前进，并为手头的问题提供关键的背景，它们是强大的。然而，它们也是危险的，因为人们经常假设一些不一定正确的事情，而且大多数人会得出非常不同的结论，因为他们的思维是基于一套不同的假设。从事实和数据出发是防止假设被歪曲的好方法，但是在这个过程中，我们必须学会尽可能不偏不倚。将假设与现实联系起来让我们到达真正的起点，在那里可以进行逻辑讨论，可以提出正确的问题。

问问我们为什么要这么做？

为一个直接的问题提供答案是很诱人的，因为我们知道它，但是一旦我们切换到解决模式，我们很容易变得狭隘，忘记我们在做什么。因此，虽然这看起来微不足道，但我们应该问问自己，为什么我们经常做我们正在做的事情。保持开放的心态和对自己诚实是很重要的。有时候，我们在某件事情上投入了几周甚至几个月的时间，却发现这件事情一开始就不应该做。对我们为什么这样做进行及时的批判性评估可以帮助我们回到正轨，并专注于正确的问题。

激励诊断而非解决方案

为了长期解决这个问题，我们需要建立一个环境来激励诊断，如果不是解决方案的话。如果我们不从根本上改变我们对好问题和好答案的重视程度，我们将永远习惯于专注于给出答案。虽然这听起来有些牵强，但是我们都可以为此做出贡献。虽然向你的同事或朋友寻求解决方案很诱人，但问问他们认为问题出在哪里，也许我们会获得一个新的视角，以不同的方式重新审视我们的处境。

现在怎么办？

我们每天都面临问题，这是我们练习问正确问题的绝佳机会。这是不直观的，有时甚至会感到沮丧，退一步想想我们是否问了正确的问题。然而，我们必须考虑不提出正确问题的后果，因为我们充其量只能得到错误问题的正确答案，这不应该是我们任何人可以接受的结果。

如果你喜欢我的内容并分享我对这个话题的看法，请在 https://jchoi.solutions/subscribe注册

品牌在数据科学中的重要性

原文：https://towardsdatascience.com/the-importance-of-branding-in-data-science-467b2d2b1e7f?source=collection_archive---------48-----------------------

什么是品牌，作为数据科学家，我们为什么需要品牌

克里斯蒂安·埃格兰在 Unsplash 上拍摄的照片

最近，一个特别的话题在我和朋友的讨论中反复出现。品牌的重要性！我本来不打算写任何关于它的东西，但当我在 TDS 团队播客上听到肯·吉的采访时，我被触动了——这是出于积极的原因。

产品、品牌和品牌

重要的是，我们要区分什么是产品、品牌和品牌，这样我们才能更好地理解我想表达的观点。

产品定义

“广义而言，产品是可以提供给市场以满足需求或需要的任何东西，包括实物商品、服务、体验、事件、人员、地点、财产、组织、信息和想法”(Kotler & Keller，2015 年)

根据这个定义，我们可以说产品是供出售的东西，可以是一项服务或一件物品(或者两者都是)。制造产品是有成本的，因此购买产品也是有价格的，但产品的价格取决于许多因素，如市场、质量、营销和产品的目标市场。

为了使这个概念更加清晰，把水想象成一种产品。我们都知道水是一种免费的资源，是人类生存的必需品，然而，我们可以称之为产品，因为它已经商业化，因为它可以出售。

虽然所有的水看起来都一样，但并不是所有的水价格都一样。同样的产品可能以不同的价格出售，人们仍然会因为一种叫做品牌的东西而购买一瓶更贵的水。

品牌定义

“品牌是公司用来区分其产品与其他产品的识别符号、标志、徽标、名称、单词和/或句子。”(来源 : Investopedia )

如果我对你说“就这么做”，你会想到什么——希望你说的答案是耐克。当你想到某些产品或服务时，你脑海中的想法或形象可能被认为是品牌。但是，请务必注意，品牌不仅仅是一种情感属性，相反，它是物理属性(如“上衣穿着舒适”)和情感属性(如“就这么做”)的结合，因为当我们接触到名称、标志等时，这些因素就会被触发。

这种区别很重要，因为一个产品被其他人仿制的情况更为常见，但一个品牌仍然是独一无二的。例如，你可能拥有和我一样的数据科学技能，但你不是我，反之亦然。

总结一下什么是品牌，我们可以称之为对某种事物的直觉。

品牌定义

“品牌是传达独特销售主张或差异的过程，使产品或服务在竞争中脱颖而出。”(来源:小企业)

换句话说，品牌就是我们如何通过在消费者心中塑造品牌来赋予事物以意义。它作为一种方法，帮助人们识别和体验一个品牌，并通过明确定义某个特定品牌是什么和不是什么，为他们提供一个选择自己产品的理由。

在商业中，品牌的目标是通过确保产品以符合品牌在封面上所说的方式交付来吸引和留住忠诚的客户和其他利益相关者。

目标是通过提供始终与品牌承诺一致的产品(换句话说，是一种营销工具)来吸引和留住忠诚的客户和其他利益相关者。

要将这一点与我们作为数据科学家联系起来，我们可以将产品视为我们的技能。许多人可能拥有与我们完全相同的技能，但他们不是你，因此你为产品(技能组合)提供了不同的意义，即 Kurtis 让你想成为不可或缺的数据科学家，而(填写姓名)让你想掌握深度学习。品牌方面可能被认为是人们如何识别和体验你的品牌，例如，你可能听说过机器学习大师，但你可能不太熟悉 Jason Brownlee，他是机器学习大师的创始人。

为什么这么大惊小怪？

现在我们已经有了定义，下一步是解释为什么品牌在数据科学中很重要，对于这一部分，我有两个关键原因，为什么在我看来作为数据科学家建立个人品牌很重要；

协助审查过程

自从我踏上求职之旅，有一件事是我最关注的…

“数据科学”这个术语非常宽泛。

一家公司认为是数据科学的东西，另一家可能会认为是数据分析师，下一家可能会认为是机器学习工程师，或者是 Quant，或者是万事通；无论你走到哪里,“数据科学家”的角色定义都可能发生变化……有时，变化非常大！

图:一条关于数据科学误解的病毒式推文

在某种程度上，我现在开始对招聘经理、人力资源部门等产生共鸣，因为他们可能每天都会收到大量漂亮的申请，而这些申请与他们具体想要的完全无关。此外，我们不要谈论写工作描述的人的负担。

撰写分析师的工作描述可能很容易，但当您开始定义您希望数据科学家具备的素质时，这些界限变得非常模糊。在某种程度上，这种混乱甚至使得编写其他角色的描述变得更加困难，例如分析师——我见过需要建模技能的分析师角色，如果数据科学之神(只是一个虚构的角色，请不要谷歌它)掌握了它，这可能会引发一场虚拟的骚乱。

我强烈推荐你阅读托马斯·尼尔德的《 数据科学已经变得过于模糊》——它讨论了数据科学的演变，以及为什么托马斯认为我们应该解散“数据科学”这个术语，变得更加专业化。我认为他提出了一些很好的观点。

哈佛创造了一个名为“数据科学”的空白，每个人都竞相填补。SQL 开发人员、分析师、研究人员、定量分析师、统计学家、物理学家、生物学家以及无数其他专业人士都将自己重新标榜为“数据科学”专业人士。——数据科学的一个摘录变得太模糊了，托马斯·尼尔德

鉴于我们在数据科学领域面临的身份危机，个人品牌可以帮助我们从人群中进入“我们正在寻找的”类别。

例如，如果你是 LinkedIn 上数据科学社区的一员，你可能听说过Kate strach Nyi。你永远不会看到 Kate 的个人资料，然后想“嗯……她正是我们一直在寻找的人，来解决我们的信用卡欺诈检测问题”，因为她一直谈论的都是数据可视化。

现在，这并不是说凯特不能做模特(我真的不知道)，但我肯定她可以建立一个邪恶的仪表板！一家正在找人制作复杂仪表板的公司会立即看到凯特的个人品牌，并确切知道她是什么样的人。

同样，我不相信微软会叫吴恩达来为他们建立一个交互式仪表板，因为离开他的 Coursera 课程，其中一些关于机器学习和深度学习的课程是最好的，他可能非常擅长问题公式化和建模(以及其他事情)。

从本质上来说，你的个人品牌将驱散围绕数据科学家定义的迷雾，因为你已经定义了你的优势所在。

上升空间无限，下降空间很小

我必须说，当一个博士生直接给你发信息，告诉你你的工作给了他们多少启发，这是一种自我满足。然而，除了可爱的信息(和偶尔的仇恨邮件)，机会是无穷的。

"只要有无限的上升空间和很小的下降空间，就去冒险！"

毫无疑问，在开始的时候，事情会很缓慢。获得关注可能需要 7、8、9 或 10 个月，但在某个时候(对于一些真正杰出的人来说，甚至更快)，你的收件箱将会被机会和联系请求淹没——我是根据经验说的。

客观地看，我最近是一个播客的嘉宾(希望它会在 1 月初发布)，如果你告诉我这将在今年年初发生，我会嘲笑你，而我没有解释决策树的结果。

给自己打上烙印会让你处于不舒服的境地，这将迫使你比逃避更快地成长。

除了机会之外，回想一下上面我们提到的“品牌保持独特性，那是因为你定义了愿景和价值观。

如果你想到当今世界上一些最成功的公司，如苹果和耐克，它们都从拥有强大品牌中获益。他们很少深究产品的物流和它的作用。见鬼，我说不出前 6 部 iPhones 的区别，但我还是买了一部，还有很多人在买他们的产品。

你的品牌，描述了你要去的地方(你的愿景)和你所重视的东西，是将人们吸引到你身边的东西！

Admond Lee 写了一篇很棒的文章，详细介绍了创建个人品牌的好处，并更深入地讨论了公司因其品牌而获得的成功——作为数据科学家，你为什么应该创建个人品牌 。

如果我把你卖了…

Yoel Zeldes 写了一篇很好的博客，作为建立个人品牌的一个很好的起点——作为数据科学家如何建立你的个人品牌

包裹

个人品牌很重要，越来越多的人，包括公司，开始意识到当前的环境。人们期望你有某种在线足迹，可以追溯到你作为“数据科学家”的工作，如果你没有，那么我建议你开始努力。

关于这一点，我建议你阅读“ 最重要的数据科学项目 ”

* [## 最重要的数据科学项目

每个数据科学家都必须做的项目

towardsdatascience.com](/the-most-important-data-science-project-458d016ef8a6)

谢谢你看完。对话还没结束，我们继续上 LinkedIn 吧…

[## Kurtis Pykes -人工智能作家-走向数据科学| LinkedIn

在世界上最大的职业社区 LinkedIn 上查看 Kurtis Pykes 的个人资料。Kurtis 有一个工作列在他们的…

www.linkedin.com](https://www.linkedin.com/in/kurtispykes/)*

领域经验在数据科学中的重要性

原文：https://towardsdatascience.com/the-importance-of-domain-experience-in-data-science-b46bcc6fba64?source=collection_archive---------46-----------------------

盖蒂图片社的 iStock

领导者应该雇佣数据科学专业的毕业生吗？还是提升现有员工的技能？

绝望的数据科学谷是真实的。一次又一次，精通案例研究和行业研究的领导者赞美数据驱动的洞察力的回报，寻求创新他们的业务——并陷入沮丧和冲销的困境。鉴于 Gartner 预测 85%的数据科学项目会失败(2018)，称之为绝望的火山口可能更准确。这 15%成功的数据科学项目有什么共同点？很多，包括仔细考虑从事给定项目的数据科学家是在从分析项目毕业后立即被雇用，还是现有员工在内部获得技能提升。

从表面上看，这似乎很空洞。既然领导者可以雇佣一个拥有数据科学学士或硕士学位、精通最新最棒的工具和技术的候选人，他们为什么要承担成本和时间来培养一个呢？假设你有时间和能力复制一个世界级的数据科学程序，那岂不是往好里说是低效，往坏里说是无效？

这取决于您的领域，或者更具体地说，取决于您的数据的复杂性和血统。

由大学、MOOCs 和其他方式提供的正式数据科学教育只能有效涵盖成功担任该角色所需的 3 种跨学科技能中的 2 种:统计学和计算机科学。第三个跨学科的技能，领域知识，不能一起教授，因为它在不同的行业，甚至不同的公司之间并不一致。没有任何机构可以教授你数据的复杂性。会有知识差距。问题是，有多宽？火山口？山谷？还是通航关？

数据是一种语言，每个公司，如果不是每个业务部门，都有自己的方言。与口语一样，这些差异是有机产生的，并根据群体的需求而变化或发展。还记得《珠光宝气》之前的生活吗？“渠道伙伴”也是如此。这些方言对于不符合通用分类定义的通用术语来说变得尤其令人困惑。例如，IT 部门的“客户”可能是员工，而销售部门的“客户”通常是具有购买力的个人，他们可能不同于“最终用户”，后者被贵公司的外部联络中心称为“客户”。

重申一下——领域知识是学会的用一个群体的数据方言流利交流的技能。它的组成部分是:一般商业敏锐度+垂直知识+数据谱系理解。例如，人力资源分析部门的数据科学家需要具备业务基础知识+人力资源+公司人力资源工具的内部运作以及创建数据的流程。这些流程和数据集的其他输入至关重要。数据科学家在理解今天的数据是什么之前，无法创造有意义的见解。它在讲故事吗？它，或者它的子集，被污染的太严重以至于今天不能使用吗？一些数据点是其他数据点的代理或输入吗？您的业务流程和相关的数据血统越复杂，您学习数据方言的时间就越长。

对于使用直观方言(即“点击”就是“点击”)自动收集数据的数字原生公司来说，领域知识的发展速度要比经历了转型、收购和/或剥离的大型老牌公司快得多。

如果你雇佣了一个数据科学家，他们需要多久才能学会你的数据方言？在施加压力产生“洞察力”之前，你能为他们提供空中掩护吗？在统计和计算机科学领域提升某人(如业务分析师或开发人员)的技能会更快或更有效吗？

真正的问题是——什么对你的项目最有意义？雇佣数据科学家？培养成功的数据科学家？或者，由这两种类型的人组成的团队会帮助你避开数据科学的绝望深渊吗？

拥有功能库的重要性

原文：https://towardsdatascience.com/the-importance-of-having-a-feature-store-e2a9cfa5619f?source=collection_archive---------43-----------------------

我已经看到了构建和维护一个集中的特性库所带来的巨大价值。特征库是一个包含许多功能的集中式软件库，其中每个功能根据标准化输入(数据)创建一个特征。这些特征可以在以后输入到旨在解决不同问题的机器学习算法中。

约书亚·阿拉贡在 Unsplash 上拍摄的照片

尽管特征存储在数据策略中起着至关重要的作用，但仍然很难在网上找到关于它们的信息。但是，了解什么是功能存储以及它们为什么重要是至关重要的，特别是在当今世界，数据治理越来越多，商业问题越来越多地由机器学习模型解决。事实上，功能商店应该是你公司整个机器学习运营的基础部分。

在它们提供的其他好处中，特性存储的三个具体优势使它们变得非常有价值:它们支持在整个公司范围内简单地重用特性；它们使得标准化特性定义和命名约定变得简单；它们使企业能够在数据科学家离线开发的模型和在线部署的模型之间实现一致性。

什么是特色店？

因为“存储”可能有多种含义，所以有必要澄清在术语“功能存储”中，这个词与“存储”相关商店实际上是一个包含许多功能的集中式软件库，其中每个功能根据标准化输入(数据)创建一个单一特征。这些特征可以在以后输入到旨在解决不同问题的机器学习算法中。

当大规模操作机器学习系统时，数据专业人员通常需要设计大量功能，以便训练他们的模型。如果模型成功地解决了创建它所针对的问题，并部署到生产环境中，那么以后应该在生产环境中创建完全相同的特性，以提供给在生产环境中运行的模型。在此过程中，要素存储成为数据科学家的宝贵资源。

要素存储还允许数据科学家简化维护要素的方式，为更高效的流程铺平道路，同时确保要素得到正确存储、记录和测试。整个公司的许多项目和研究任务都使用相同的功能。通过要素存储，数据科学家可以快速访问他们需要的要素，并避免重复工作。功能商店还提供了一种经过测试和质量保证的方法来创建功能，并知道它是可靠的。

为什么我们需要特色商店？

使用要素存储有助于缓解数据科学家面临的一些特定于要素的挑战。其中包括:

不会重复使用特征。数据科学家面临的一个常见障碍是花费时间重新开发功能，而使用以前开发的功能或其他团队开发的功能就足够了。要素存储允许数据科学家避免重复工作。
功能定义各不相同。任何一家公司的不同团队可能会以不同的方式定义和命名特性。此外，访问某个特定特性的文档(如果存在的话)通常是一个挑战。特征存储通过保持特征及其定义的组织性和一致性来解决这个问题。功能库的文档可以帮助您围绕公司的所有功能创建一种标准化的语言。您确切地知道每个特征是如何计算的，以及它代表什么信息。
培训和生产功能不一致。生产和研究环境通常使用不同的技术和编程语言。流入生产系统的数据流需要实时处理为特征，并输入到机器学习模型中。为了使建模工作有效，在研究中离线开发的模型需要提供与在线部署的模型完全相同的预测，给定相同的数据作为输入。拥有一个与环境无关的特征库(在线和离线)意味着给定相同的数据，模型将被提供完全相同的特征。‍

特色店福利

当一家公司采用功能存储时，它允许团队中的数据专业人员针对任何机器学习用例遵循相同的通用工作流，而不管他们当前正在解决的挑战(例如分类和回归、时间序列预测等)。).这种工作流通常是与实现无关的，这意味着它可以很容易地用于新的算法类型和框架，例如经典的 ML 算法以及较新的深度学习框架。

使用功能库的另一个主要好处是节省时间。在任何建模工作中，创建特征的阶段往往是最耗时的；这一敏感过程要求正确计算要素，一次要创建数千个要素，并在生产环境中以与研究期间离线计算完全相同的方式进行计算。使用特征库使得创建特征的过程更加简化和高效。

我的建议:集中式功能商店

我的团队从构建和维护集中式特征存储中获得了很大的价值，在该存储中，公司内不同的数据专业人员都可以创建和管理供团队其他成员使用的规范特征。这使得数据科学家可以轻松地将他们构建的要素添加到共享要素存储中。一旦有了特性，就很容易在线(在生产中)和离线(在研究中)使用它们，只需引用一个特性的简单规范名称。

今天，我们的功能库中有数千个功能，用于公司和所有领域的各种机器学习项目。我们的数据科学家一直在添加新功能，新功能会自动计算并每天更新。这使得我们的团队成员能够避免重复工作，并轻松访问建模和研究所需的大量数据。

更多信息和有用的信息请访问 Bigabid 技术博客！

k-fold 交叉验证对机器学习中模型预测的重要性

原文：https://towardsdatascience.com/the-importance-of-k-fold-cross-validation-for-model-prediction-in-machine-learning-4709d3fed2ef?source=collection_archive---------11-----------------------

作者图片—加拿大桑德湾

本文将讨论和分析使用经验风险最小化(ERM)的最小二乘算法的机器学习中模型预测的 k-fold 交叉验证的重要性。

我们将使用多项式曲线拟合问题来预测样本数据集的最佳多项式。此外，我们将在 MATLAB 上一步一步地检查 10 重交叉验证的实现。

在这篇文章结束时，你将知道如何实现 k-fold 交叉验证方法，并理解它的优点和缺点。

概观

为了更好地可视化在机器学习上应用 k-fold 交叉验证的好处，我们将分析我们在根本不进行任何类型的交叉验证的情况下估计模型时可能面临的一些问题。

我们首先将数据集导入 MATLAB，并绘制数据点，以便更好地可视化它们。然后，我们将实施 10 重交叉验证算法，并计算经验风险最小化(ERM)的平方损失误差，以找到我们数据的最佳模型。最后，我们将重复这个过程，但这次没有任何类型的交叉验证，并比较结果。

资料组

我们将使用只有 100 个数据点的数据集。稍后将解释使用如此小的数据集的原因。这个数据集最初是由 Ruth Urner 博士在她的一次机器学习课程作业中提出的。在下面的存储库中，你会发现两个 TXT 文件: dataset1_inputs.txt 和 dataset1_outputs.txt 。

[## jaimedantas/最小二乘回归

正则化最小二乘算法用于回归以寻找机器学习模型。这个实现…

github.com](https://github.com/jaimedantas/least-squares-regresion)

这些文件包含输入和输出向量。在 MATLAB 上的 Home > Import Data 中导入它们之后，我们可以绘制如下所示的数据点。

资料组

k 倍交叉验证

当我们没有足够的数据来应用其他更有效的方法，如三分法(训练、验证和测试)或使用维持数据集时，交叉验证通常用于机器学习中，以改善模型预测。这就是我们的数据集只有 100 个数据点的原因。如果你想更多地了解这种方法背后的数学原理，我推荐你阅读这篇文章。

在 k-fold 交叉验证中，我们首先打乱数据集，使输入和输出的顺序完全随机。我们这样做是为了确保我们的输入没有任何偏差。然后，我们将数据集分成大小相等的 k 个部分。在这个分析中，我们将使用 10 重交叉验证。所以，第一步是把我们的数据集分成 10 份。

将数据分成 10 份

然后，我们将使用一个折叠来测试和计算经验平方损失，其余 9 个折叠用于在每个 k 交互中训练我们的模型。通过这样做，每次我们开始一个新的交互时，我们都使用不同的文件夹进行测试。这样，我们保证每一个 k 零件都被用于一次测试。

10 重交叉验证的算法

最后，我们将有 10 个经验平方损失值，每个相互作用一个。最终的经验平方损失将是这些值的平均值。说够了，还是去实现本身吧。

履行

首先，我们需要将数据集随机分成 10 等份。为了做到这一点，我创建了两个循环来迭代向量 t 和 x ，将它们分成 10 个相等的部分。这些部分存储在单元阵列 split_t 和 split_x 中。我还创建了一个辅助单元格数组来存储为每个部分选择的索引。最后，我创建了一个向量来存储所有已经拆分的索引。

在内部循环中，我生成一个从 1 到 100 的均匀分布的随机整数[1]。然后，我检查这个索引是否在被访问的索引列表中。如果它不在那里，我将这个值添加到分割单元数组中，并递增内部循环；否则，我会生成一个新的随机索引。外环重复 10 次这个过程。

这个过程可能不是混洗和分割数据集的最有效的方法，但是它确实有效，并且保证了随机分割。为了形象化我们创建的 10 个折叠，我将它们绘制在下图中。

数据集随机分成 10 份

现在，我们需要对 ERM 的经验平方损失实施 10 重交叉验证。在继续之前，我建议阅读一下关于 ERM 的解释，这样你就能理解它背后的一些主要概念。ERM 的解决方案在下面的等式中定义。

向量 w 是我们的多项式系数， X 是设计矩阵， t 是输出向量。

为了简化我们的计算，我们将在 MATLAB 中手动求解 w 的线性方程(通过矩阵的相乘和求逆)。请注意，这不是求解线性方程的最有效方法。此外，我们将分析 W = 1，2，…，30 阶多项式。

因此，对于 10 重交叉验证，我们在一个循环中执行 ERM 过程 10 次，并将每次执行的所有测试分数存储在单元数组 E 中。经验平方损耗通过以下公式计算。

在此过程中，我们使用一个折叠进行测试，其余 9 个折叠用于训练。在这个循环中，我还计算了训练和测试设计矩阵。

我们算法的输出如下图所示。

Cross_Validation.m 脚本的输出

因此，W = 6 阶多项式最适合该数据。现在，让我们分析下图中所有多项式的 ERM 图。

缩减规模下交叉验证的经验平方损失

请注意，为了更好地理解趋势，我缩小了上图中图表的比例。我们可以得出结论，随着多项式阶数的增加，经验平方损耗降低。然而，当我们将阶数增加到非常大的值时，我们开始看到过度拟合的行为(本例中 W > 21)。此外，请注意，从 W = 12 到 W = 15，平方损耗略有增加。这是因为我们在 k 倍交叉验证过程中置换了我们的数据集。避免这种情况的一种方法是进行多次 k 倍交叉验证，最后对平方损失进行平均。

下图显示了 W = 6 阶多项式相对于数据集的曲线。

6 阶多项式与数据集

请注意，我们没有用我们选择的模型过度拟合我们的数据。

如果我们没有使用 10 重交叉验证会怎么样？

作者图片

为了回答这个问题，让我们看看如果在我们的问题中没有使用 10 重交叉验证，我们会得到什么结果。为此，我们简单地将平方损失法应用于 ERM，如下所示。

上述算法的输出如下所示。

脚本的输出

如我们所见，这一次 21 阶多项式是经验平方损失最小的一个。即使我们分析经验平方损失曲线(如下所示),我们最终也会选择一个非常大的模型。

缩小比例下的经验平方损失

选择更高阶多项式的结果并不便宜。这不仅会使数据过拟合，还会增加复杂性。下面我们来看看 21 阶多项式。

21 阶多项式与数据集

我们可以看到，尽管 W = 21 阶多项式的经验损失最小，但它以极大的方式过度拟合了数据。

结论

我们看到交叉验证允许我们为我们的数据集选择一个更好的模型和一个更小的阶数(W = 6 与 W = 21 相比)。最重要的是，k-fold 交叉验证避免了我们在不执行任何类型的交叉验证时遇到的过拟合问题，尤其是对于小数据集。

然而，这种改进伴随着高成本。当使用 k-fold 交叉验证时，需要更多的计算能力来找到最佳模型。

当我们分析有交叉验证和没有交叉验证的模型的曲线时，我们可以清楚地看到 10 重交叉验证在为该数据选择最佳模型时是最重要的。

我们还研究了 10 重交叉验证的算法，详细说明了在 MATLAB 上实现该算法所需的每个步骤。

关于我

我是约克大学的一名硕士研究生，骨子里是一名软件工程师。在过去的十年里，我一直在软件开发、云计算和系统工程等领域的几个行业工作。目前，我正在研究云计算和分布式系统。

如果你愿意，你可以在我的网站上查看我的作品。

感谢阅读！

参考

[1] Randi 函数 MATLAB。网址:https://www . mathworks . com/help/MATLAB/ref/randi . html # d 122e 1072277

[2] Shai Shalev-Shwartz 和 Ben-David。理解机器学习:从理论到算法。剑桥大学出版社，2014 年。DOI:10.1017/CBO9781107298019。网址:https://www . cs . huji . AC . il/~ shais/understanding machine learning/understanding-machine-learning-theory-algorithms . pdf

机器对机器经济的重要性(M2M) &多智能体系统

原文：https://towardsdatascience.com/the-importance-of-machine-to-machine-economy-m2m-multi-agent-systems-cbb85c2fd3c2?source=collection_archive---------37-----------------------

从商业角度理解去中心化人工智能

克里斯·巴巴利斯在 Unsplash 上的照片

在我最近的一次任务中，我负责在我们所谓的“机器对机器经济”(M2M)的背景下制定一项与去中心化人工智能相关的战略。在本文中，我将解释为什么多代理系统是在即将到来的 M2M 经济中创建新商业模式的关键，以及为什么这个新时代会对您的组织构成重大威胁。

具体来说，我们希望机器变得“更聪明”，并且很快能够在没有任何人类干预的情况下做出决策并在它们之间进行交易。因此，由于去中心化的人工智能，我们将很快看到新的商业模式和客户关系。

多智能体系统

让我们从定义一些关键术语开始:

代理:复杂的计算机程序，在开放和分布式环境中，代表它们的用户自主行动，以解决越来越多的复杂问题。然而，应用程序越来越需要多个可以协同工作的代理。( 1

多智能体系统(MAS): 一个松散耦合的软件智能体网络，通过交互来解决超出每个问题解决者个人能力或知识的问题。( 2 )

更简单地说，用一个来自 Yoav Shoham 和 Kevin Leyton-Brown 的例子，你应该想象一个个人软件代理在几个电子商务网站上代表你。例如，让我们假设这个代理的任务是识别随着时间的推移在各种在线网站上销售的特定产品，并代表您购买其中的一些产品。为了取得成功，您的代理需要记住您对产品的偏好、您的预算以及您对其运营环境的总体了解。

此外，代理将需要利用你对与之互动的其他类似代理的了解(在拍卖中，或代表其他企业的代理)。

这些智能体的集合形成了一个多智能体系统。详细地说，多智能体系统是“一个由各种相互沟通的人工智能组成的松散生态系统”( 3 )。它本质上是基于代理的系统的下一次迭代。一些算法在 MAS (强化学习、深度学习、深度卷积网络、…)的发展中被证明是相当有趣的。

目前，MAS(在分散的人工智能背景下)仍在研究中。因此，多智能体系统的工业应用/可扩展性仍然需要几年的时间。

多代理系统分为两类:

正如我们已经看到的，代理可以相互作用。这些代理之间的通信或协调可以采取多种形式。然而，也有必要理解它们也是自主代理。因此，在一些情况下，代理具有相反的目标，因此，不能执行任何包含它们的合作过程。

知道代理配备了社交能力是很关键的。这种能力可以定义为“交换高级信息(而不仅仅是没有关联意义的数据字节)和与其他代理(和/或人类)进行社会互动过程的能力，类似于人类在日常生活中使用的那些，建立集体行为。”( 4

我们当前的挑战是建立能够与其他代理协商和合作的代理。例如，为了说服代理合作，可能需要付款或提供特定的商品或服务。

此外，我们也在关注联合学习。

联合学习:一种机器学习技术，在多个分散的边缘设备或保存本地数据样本的服务器上训练算法，而不交换它们。( 5 )

事实上，我们认为 AI 和实时数据处理必须发生在边缘网络和边缘设备(物联网设备等)上。对于一些产品来说，从传感器中收集数据以在不依赖云或互联网的情况下实时做出决策是否至关重要。他们还应该能够使用机载算法学习或训练自己，并与其他产品分享他们的学习成果。

机器对机器经济

随着人工智能、智能传感器、去中心化 P2P 交易协议和区块链的兴起，我们正在进入机器经济。机器最终会在经济上独立。一个对象(比如:车)就能花钱，就能挣钱。机器将为我们做出决定，这解释了人工智能方面的问题，但我们需要信任它们——这就是区块链的用武之地。

我们未来的顾客将是带钱包的机器。

我们设想在未来，机器可以发现、自动与其他机器连接(使用公共或私有网络，例如网状网络)，通过 AI(强化学习)做出自己的选择，并独立购买他们需要的东西。我们认为机器迟早也会集成钱包。

一个物联网设备将不再被认为是一个孤立的产品，需要自己从头学习一切；这些设备还将利用全球其他类似物联网设备的大规模学习。这意味着由机器学习训练的物联网智能系统不仅仅是变得更聪明；随着时间的推移，他们以指数趋势变得更聪明。

此外，在 M2M 经济中，大多数消费者将根据他们使用或消费产品的数量付费。这是我们购买产品方式的重大转变。

在汽车行业，我们可以想象车辆可以无缝连接和通信(使用多代理深度强化学习)与其他车辆、道路、交通灯、停车计时器、汽油泵，甚至像优步这样的私营公司。更广泛地说，我们可以设想一个社会，在这个社会中，汽车、无人机或建筑物可以直接相互协商，以实现它们的目标，而不需要人类的参与。

为了在机器对机器经济中创造新的以机器为中心的商业模式，我们必须首先通过更好地利用数据网络效应来改进我们的 AIoT 战略。

机器是未来的客户…

从技术角度来看，建造一台真正自主且可扩展的机器，并使其能够在非常具体的目的背景之外做出决策，仍然是一件极其困难的事情。

我们产品的转型或多或少遵循了澳大利亚联邦银行制定的路线图。在机器对机器经济的发展中，我们有三个必要的步骤

新的机遇和威胁

向大多数顾客都是机器的经济转型将产生重大影响。

你如何说服一个人工智能代理从你的公司购买？
在 M2M 经济中，你是如何管理“顾客”忠诚度的？
你如何确保在这个机器驱动的经济中保持相关性？

这种情况会给你的行业带来新的动力。今天依赖人工智能代理的客户可能会转向更“人工智能友好”的业务，或者一些公司可能会创建特定的专属环境。与此同时，你必须考虑到你的产品可能会独立产生额外的收入。

例如，在 M2M 经济中，自动驾驶汽车的车主可以通过向其他人提供乘车服务，或者通过向人工智能公司出售或出租数据集来受益。我们的项目之一是为这个案例考虑一个激励机制。事实上，作为一种激励，汽车可以接收比特币或一些代币。

我们已经关注了代理之间信任的概念。事实上，信任可以被视为代理之间交互的质量和数量:两个部分之间发生的交互越多，一方就越信任另一方。在一个由去中心化人工智能驱动的竞争市场中，改变这一点容易吗？

代理之间的信任问题可以通过基于动态交互的信誉模型(DIB-RM) 来解决，该模型被引入来捕获信任的动态属性。该模型结合不同的动态因素计算系统中每个代理的信誉值。信誉值在每次交互时被更新。

除了显而易见的技术问题之外，公司还必须从孤立的解决方案过渡到共享的、值得信赖的通信方法。事实上，只有为 MAS 开发特殊的协议，MAS 才能适用于所有行业。MAS 将很难在当前的数据驱动协议下工作。

要了解更多信息，我推荐以下链接:

自然语言处理对非英语语言的重要性

原文：https://towardsdatascience.com/the-importance-of-natural-language-processing-for-non-english-languages-ada463697b9d?source=collection_archive---------21-----------------------

Porapak Apichodilok，Pexels

自然语言处理(NLP)的应用越来越广泛，并在许多系统中发挥着重要作用，从招聘的简历解析到自动电话服务。你也可以在聊天机器人、虚拟助手、现代垃圾邮件检测等常用技术中找到它。然而，NLP 技术的发展和实现并不像它看起来那样公平。

客观地说，尽管世界上有 7000 多种语言，但绝大多数 NLP 过程都扩展了七种关键语言:英语、汉语、乌尔都语、波斯语、阿拉伯语、法语和西班牙语。

即使在这七种语言中，绝大多数技术进步都是在基于英语的 NLP 系统中实现的。例如，光学字符识别 (OCR)对于非英语语言仍然是有限的。任何使用过在线自动翻译服务的人都知道，一旦你尝试超越上面提到的关键语言，就会受到严重的限制。

NLP 管道是如何开发的？

为了理解 NLP 中的语言差异，首先理解这些系统是如何开发的是有帮助的。典型的管道从收集和标记数据开始。大型数据集在这里是必不可少的，因为训练和测试算法都需要数据。

当为几乎没有可用数据的语言开发管道时，在语言中拥有强模式是有帮助的。小数据集可以通过一些技术来扩充，例如同义词替换来简化语言，反向翻译来创建相似短语的句子来扩充数据集，以及用其他相关词类替换单词。

语言数据也需要大量清理。当使用带有特殊字符的非英语语言(如中文)时，通常需要正确的 unicode 规范化。这允许文本被转换成所有计算机系统可识别的二进制形式，降低了处理错误的风险。这个问题在像克罗地亚语这样的语言中被放大了，这些语言严重依赖重音来改变单词的意思。例如，在克罗地亚语中，一个单独的重音可以将一个积极的词变成消极的词。因此，必须对这些术语进行手动编码，以确保数据集的可靠性。

最后，数据集可以分为训练和测试部分，并通过特征工程、建模、评估和细化的机器学习过程发送。

一个常用的自然语言处理工具是谷歌的双向编码变压器(BERT)的代表，据称是开发一个“最先进的”模型在 30 分钟内使用一个单一的张量处理单元。他们的 GitHub 页面报告支持拥有最大维基百科数据库的前 100 种语言，但系统的实际评估和改进只在 15 种语言上进行过。虽然 BERT 在技术上支持更多的语言，但是较低的准确性和缺乏适当的测试限制了这项技术的应用。其他 NLP 系统，如 Word2Vec 和自然语言工具包(NLTK)也有类似的限制。

总之，NLP 管道对于不太流行的语言来说是一个挑战。数据集较小，通常需要扩充工作，清理过程需要时间和精力。对本地语言资源的访问越少，构建 NLP 管道时可用的数据就越少。这使得不太受欢迎的语言的准入门槛非常高，在许多情况下，太高。

NLP 中不同语言支持的重要性

有三个总体观点支持 NLP 的扩展:

社会劣势的加剧
规范性偏见
改进 ML 技术的语言扩展

让我们更详细地看一下每一项:

社会劣势的强化

从社会的角度来看，重要的是要记住，只有当技术工具以你的语言可用时，技术才是可访问的。在基本层面上，拼写检查技术的缺乏损害了那些说和写不太常用语言的人。这种差异沿着技术链上升。

此外，心理学研究表明，你说的语言塑造了你的思维方式。驱动互联网的系统中的内置语言偏好固有地结合了驱动语言的社会规范。

事实是，受支持的系统继续蓬勃发展，而向一个根深蒂固的计划引入新的方面是一个挑战。这意味着，随着 NLP 在没有引入多样化语言范围的情况下继续发展，未来将它们纳入将更具挑战性，危及全球语言的多样性。

规范性偏见

英语和英语邻近语言并不代表其他世界语言，因为它们有许多语言所没有的独特语法结构。然而，由于主要支持英语，互联网和其他技术逐渐将英语视为正常的默认语言设置。

由于一个相对不可知论的系统是在英语上训练的，它学习特定语言的规范和系统以及伴随这种限制而来的所有文化含义。随着 NLP 被应用到拥有国际观众的更智能的过程中，这种单边方法只会继续变得更加明显。

阿迪·佩雷茨

改进 ML 技术的语言扩展

当我们仅将机器学习技术应用于少数几种语言时，我们就在系统中植入了隐含的偏见。随着机器学习和 NLP 在只支持少数几种语言的情况下继续发展，我们不仅使引入新语言变得更具挑战性，而且冒着从根本上不可能做到这一点的风险。

例如，子词标记化实现在以重复为特征的语言上表现很差，重复是许多国际语言的共同特征，如南非荷兰语、爱尔兰语、旁遮普语和亚美尼亚语。

语言也有各种各样的词序规范，这往往会难倒基于英语的 NLP 中使用的常见神经模型。

能做些什么？

在当前围绕 NLP 的话语中，当说出“自然语言”时，一般的假设是研究者正在处理英语数据库。为了打破这种模式，创造更多的国际体系意识，我们首先应该总是参考正在发展的语言体系。这种总是陈述研究人员正在研究的语言的想法被通俗地称为本德法则。

当然，仅仅意识到这个问题是不够的。但是，注意这个问题有助于开发更广泛适用的工具。

当希望在 NLP 管道中引入更多语言时，考虑数据集的大小也很重要。如果您正在创建一个新的数据集，您的预算的很大一部分应该用于创建另一种语言的数据集。当然，在优化其他语言的当前清理和注释程序方面的额外研究对于在全球范围内扩展 NLP 技术也是至关重要的。

这个故事最初发表在 Lionbridge.ai，你可以在这里 阅读故事原文，了解更多关于 Lionbridge 。

监督预测性维护解决方案中问题框架的重要性

原文：https://towardsdatascience.com/the-importance-of-problem-framing-for-supervised-predictive-maintenance-solutions-cc8646826093?source=collection_archive---------10-----------------------

杰西卡·鲁斯切洛在 Unsplash 上的照片

探索美国宇航局的涡轮风扇数据集

重温我们的剩余使用寿命假设&支持向量回归

<免责声明:我的目的是展示模型开发过程中不同方法和选择的效果。这些影响经常使用测试集来显示，这被认为是(非常)不好的做法，但有助于教育目的。 >

在我的上一篇文章中，我们探索了 NASA 的 FD001 涡轮风扇退化数据集。简单概括一下，传感器 1、5、6、10、16、18 和 19 没有与剩余使用寿命相关的信息(RUL)。从数据中去除这些因素后，我们拟合了一个 RMSE 为 31.95 的基线线性回归模型。今天，我们将重新检查我们的 RUL 假设，以提高我们的准确性，并拟合支持向量回归机(SVR)，以进一步改善我们的结果。我们开始吧！

加载数据

首先，我们将加载数据并检查前几行，以确认数据加载正确。

train.head()的结果

加载的数据看起来不错，让我们像以前一样计算线性下降 RUL。

RUL 在击穿时可以认为是 0，我们天真地假设 RUL 是一个线性函数。意味着在击穿前的 10 个周期时 RUL 是 10，在击穿前的 50 个周期时是 50，等等。

在重新检查我们计算 RUL 的方法之前，我们将通过删除不包含有用信息的列来准备数据。这将允许我们直接测试我们所做的任何更改，因为我们的数据已经准备好了。

我们还定义了评估模型性能的函数。

改装我们的基线模型。

# returns
# train set RMSE:44.66819159545453, R2:0.5794486527796716
# test set RMSE:31.952633027741815, R2:0.40877368076574083

重新审视 RUL

之前我假设 RUL 随着时间线性下降。然而，在上一篇文章中，我们看到这可能会影响我们的整体模型性能。有一种方法可以改进我们的假设，我将在下面解释[1]。

观察传感器信号(参见下面的一个示例)，许多传感器在开始时似乎相当稳定。这是因为随着时间的推移，发动机只会出现故障。信号曲线的弯曲是提供给我们的第一个信息，即发动机正在退化，并且第一次有理由假设 RUL 线性下降。在那之前，我们真的不能说任何关于 RUL 的事情，因为我们没有关于最初磨损的信息。

描述 S12、线性和削波 RUL 的图形。

我们可以更新我们的假设来反映这个逻辑。我们没有让 RUL 线性下降，而是将 RUL 定义为一个常数，一段时间后才线性下降(见上面的例子)。通过这样做，我们实现了两件事:

初始恒定的 RUL 与初始恒定的平均传感器信号更好地相关
RUL 的较低峰值导致我们的目标变量的较低分布，从而更容易拟合直线

因此，这种变化允许我们的回归模型更准确地预测低 RUL 值，这通常是更有趣/更关键的正确预测。

使用 pandas，您可以简单地将之前计算的线性下降 RUL 限制在所需的上限值。测试多个上限值表明在 125 处剪切 RUL 对模型产生了最大的改进。当我们更新我们对列车组的 RUL 的假设时，我们应该在评估中包括这一变化。测试集的真实 RUL 保持不变。让我们来看看这一变化的影响。

# returns
# train set RMSE:21.491018701515415, R2:0.7340432868050447
# test set RMSE:21.900213406890515, R2:0.7222608196546241

火车 RMSE 已经减半多了。当然，我们已经自己设定了这些目标，但是它显示了之前的 RUL 假设对整体模型性能的影响有多大。更重要的是测试集的改进。测试 RMSE 从 31.95 降低到 21.90，提高了 31%！这告诉我们更新的假设有利于模拟真实的 RUL。让我们看看使用另一种技术是否能做得更好。

支持向量回归

线性 SVR 与线性回归的主要区别在于，它将边界设置在距离参考数据ε(ɛ)的位置(见下图)。当在模型拟合期间最小化损失函数时，落在边界内的点被忽略。在这些边界之外的点上拟合你的模型减少了计算量，并允许你捕捉更复杂的行为，但是这种技术对异常值也更敏感！

来源:[2]。黑色实线代表目标，虚线是距离ε(ɛ).)处的边界只有边界外的点有助于模型拟合和最小化损失函数。损失函数类似于岭回归和套索回归的损失函数。

实例化一个 SVR 就像建立一个线性回归一样简单，一定要确保将内核设置为“线性”。拟合模型后，我们再次对训练集和测试集进行评估。

# returns
# train set RMSE:29.57783070266026, R2:0.49623314435506494
# test set RMSE:29.675150117440094, R2:0.49005151605390174

请注意，均方根误差比我们的 RUL 线性回归差得多。让我们通过缩放我们的特征来尝试改进我们的模型。

缩放比例

支持向量回归机通过比较特征向量之间的距离来工作。但是当特征在范围上变化时，计算的距离由具有更大范围的一个来支配。假设一个特性的范围在 10-11 之间，另一个在 1000-1100 之间。两者相差 10%，但后者的绝对差异要大得多。SVR 将更重视其范围的变化。
为了解决这个问题，您可以缩放您的要素，使它们都在同一范围内。这使得您的 SVR 可以比较相对距离，并对差异进行大致相同的加权。[3, 4].
Sklearns 的 MinMaxScaler 可用于创建适合我们训练数据的缩放器。默认设置创建一个缩放器，在 0-1 之间缩放我们的训练特征。然后，缩放器被应用于我们的 X_train 和 X_test 集。我们用缩放后的数据拟合和评估一个新的 SVR 模型。

# returns
# train set RMSE:21.578263975067888, R2:0.7318795396979632
# test set RMSE:21.580480163289597, R2:0.730311354095216

请注意，21.58 的测试 RMSE 已经是对我们的线性回归的改进，该线性回归的 RMSE 为 21.90。接下来，我们将应用一些特征工程来尝试进一步改进我们的预测。

特征工程

一种非常有用的要素工程技术是创建要素的多项式组合，这可能会揭示数据中与原始要素不明显的模式。假设我们想要创建二次多项式特征s_2和s_3，结果将是[1, s_2, s_3, s_2², s_3², s_2*s_3]。
将该技术应用于我们当前数据集中的所有传感器，可将特征空间从 14 个增加到 120 个。

# returns
# (20631, 14)
# (20631, 120)

在设计了新的特征之后，我们安装了新的模型。

# returns
# train set RMSE:19.716789731130874, R2:0.7761436785704136
# test set RMSE:20.585402508370592, R2:0.75460868821153

请注意，测试集 RMSE 和方差再次得到改善，表明通过添加多项式特征可以获得更多信息。我也考虑过对数变换，但是传感器值范围不够大，不足以证明这些变换的合理性。然而，多项式特征确实扩大了我们的特征空间，使我们的模型有点“臃肿”,并增加了训练时间。让我们看看我们是否可以在保持分数的同时，通过保留最具信息性的特征来降低音量。

特征选择

使用包含工程特征的模型，我们可以计算哪些特征对模型性能的贡献最大。为此，我们使用 SelectFromModel，在其中传递我们训练好的模型并将 prefit 设置为 True。我们将选择“重要”特征的阈值设置为“平均”，表示所选特征的特征重要性将大于整个集合的平均特征重要性。获取支持将返回一个布尔数组，指示哪些要素的重要性高于平均值。我们将用它来划分特征子集，只保留“特征重要性>平均特征重要性”等于真的特征。

# returns
# Original features:
 Index(['s_2', 's_3', 's_4', 's_7', 's_8', 's_9', 's_11', 's_12', 's_13',
       's_14', 's_15', 's_17', 's_20', 's_21'],
      dtype='object')
# Best features:
 ['x0' 'x1' 'x2' 'x3' 'x5' 'x6' 'x7' 'x9' 'x10' 'x11' 'x12' 'x13' 'x2 x5'
 'x2 x8' 'x2 x9' 'x3 x5' 'x3 x8' 'x3 x9' 'x4^2' 'x4 x6' 'x4 x7' 'x4 x8'
 'x5^2' 'x5 x6' 'x5 x7' 'x5 x9' 'x5 x12' 'x5 x13' 'x6^2' 'x6 x8' 'x6 x9'
 'x7 x8' 'x7 x9' 'x8^2' 'x9^2' 'x9 x12' 'x9 x13']
# shape: (37,)

用所选择的特征来拟合和评估新的 SVR 模型。

# returns
# train set RMSE:19.746789101481127, R2:0.775461959316527
# test set RMSE:20.55613819605483, R2:0.7553058913450649

注意，测试 RMSE 和方差略有改善，而模型使用的特征数量从 120 个减少到 37 个！这种改善可能是由于模型在列车组上过度拟合得稍微少一些。我们现在有了所有的构建模块来训练和选择我们的最终模型。

选择我们的最终型号

对于最终模型，我们将在训练集上使用简单的超参数调整来调整ε的值。正如本文前面所解释的，ε表示最小化损失函数时要考虑的数据点的边界。

# returns
# epsilon: 0.4 RMSE: 19.74772556660336 R2: 0.7754406619776462
# epsilon: 0.3 RMSE: 19.747580761069848 R2: 0.7754439552496148
# epsilon: 0.2 RMSE: 19.74660007817171 R2: 0.7754662580123992
# epsilon: 0.1 RMSE: 19.746789101481127 R2: 0.775461959316527
# epsilon: 0.05 RMSE: 19.746532456984006 R2: 0.7754677958176168

ε为 0.2 似乎在训练集上产生最佳性能。让我们重新训练我们的模型，并检查最终结果。

# returns
# train set RMSE:19.74660007817171, R2:0.7754662580123992
# test set RMSE:20.54412482077374, R2:0.7555918150093489

具有剪切 RUL 的线性模型的 RMSE 为 21.90，比我们的基线回归提高了 31%，基线回归的 RMSE 为 31.95。我们的最终模型利用边界调谐的 SVR、用于训练的限幅 RUL、特征缩放和贡献最大的二阶多项式特征来达到 20.54 的测试 RMSE。这比我们的 RUL 限幅线性模型提高了 6%，比基线模型总体提高了 35.7%。

最后，这篇文章展示了正确构建数据科学问题的重要性。虽然 SVR 肯定是对线性回归的改进，但与我们更新的 RUL 假设相比，它的改进就相形见绌了。完整的笔记本你可以点击这里查看我的 github repo。

我要感谢 Maikel Grobbe 和 Wisse Smit 对我的文章的评论。下一次我们将深入研究时间序列分析，20.54 的 RMSE 将是要打破的分数。如果你有任何建议、问题或评论，请在下面的评论中留下！

参考文献:
【1】f . o . Heimes，“用于剩余有用寿命估计的递归神经网络”， 2008 年国际预测和健康管理会议，科罗拉多州丹佛，2008 年，第 1–6 页，doi:10.1109/PHM . 2008.4711422 .
【2】Kleynhans，Tania & Montanaro，Matthew & Gerace，Aaron & Kanan，Christopher。(2017).使用深度学习的 MERRA-2 大气数据预测大气顶部热辐射。遥感。9.1133.doi: 10.3390/rs9111133。
【3】https://en.wikipedia.org/wiki/Feature_scaling
【4】https://stats . stack exchange . com/questions/154224/when-using-SVMs-why-do-I-need-scale-the-features

r 及其在数据科学中的应用

原文：https://towardsdatascience.com/the-importance-of-r-in-data-science-6b394d48fa50?source=collection_archive---------23-----------------------

弗朗西斯·德拉佩纳在 Unsplash 上拍摄的照片

关于皮尔逊相关系数及其应用的一点提醒

r 是什么？简单来说就是皮尔逊相关系数(r)。或者换句话说:R 是一个相关系数，它衡量两个变量之间的关系强度，以及散点图上的方向。r 的值总是在一个负值和一个正值之间(-1 和 a +1)。

图片作者:https://www . stats tutor . AC . uk/resources/uploaded/pearsons . pdf

对于那些需要复习散点图是什么的人，不要担心。散点图是一个数学图表，显示了两个变量的数据点的笛卡尔坐标。同样，笛卡尔坐标来自笛卡尔系统。笛卡尔系统只是帮助指定和放置每个坐标(一组数字)在一个平面上，这将是散点图。(下面会有散点图的视觉效果)

回到 r .如上所述，连续数据的皮尔逊相关系数(r)范围为-1 到+1。这意味着，如果 r = -1，数据位于一条斜率为负的完美直线上。此外，如果 r = +1，则数据位于具有正斜率的完美直线上。如果 r = 0，这意味着没有线性相关性。注意:如果 r = 0，这并不意味着没有任何关系，只是意味着它不是线性的。可能是二次关系。这可以留给另一篇博客文章。

另一个需要注意的重要事情是，r 并不代表最佳拟合直线的斜率。

很容易直观地知道 r 是什么。r 可分为以下两类:

正相关:因变量随着自变量的增加而增加。这产生了一个正斜率，从视觉上看，散点图向上倾斜。这意味着有一个积极的关系。

图片作者:https://www . stats tutor . AC . uk/resources/uploaded/pearsons . pdf

负相关:自变量增加，因变量减少。这会产生一个负斜率。这通过向下倾斜的点来描述。这意味着有一种负面的关系。

图片作者:https://www . stats tutor . AC . uk/resources/uploaded/pearsons . pdf

无相关性:因变量既不倾向于增加也不倾向于减少，这意味着自变量和因变量之间没有关系。

图片作者:https://www . stats tutor . AC . uk/resources/uploaded/pearsons . pdf

皮尔逊相关系数通常用于线性回归。相关系数不应用于非线性关系。

另一种判断 r 是负还是正的方法是通过皮尔逊公式:

图片作者:https://www . statistics show to . com/probability-and-statistics/correlation-coefficient-formula/

其在数据科学和分析数据方面的用途:

皮尔逊相关系数在数据科学中用于调查两个变量之间的关系强度。

上面我已经列出了完美的消极和积极的关系。大多数时候，情况并非如此，尤其是在应用于数据时。随着 r 越来越接近 0，它变得明显更弱。当 r 接近 0 时，更难确定是否存在正相关、负相关或是否存在相关。

通常，r 将在应用线性回归或最佳拟合线时计算。r 表示每个数据点有多远。

在数据科学中，了解何时使用特定的度量非常重要。在使用皮尔逊相关系数时，大多数测量单位都有一个通用的指导原则，同时也要记住七个假设。皮尔逊相关系数的准则是:

图片来源:来源

如果要用 r 来度量两个数据点之间的关系，那么它必须在一个区间上进行度量，或者它必须在一个比率尺度上。不用担心，两个变量都不需要用同一个比例尺度来衡量。此外，一个变量可以是比率，另一个变量可以是区间。

为了使用皮尔逊相关系数，需要满足七个假设。现实世界的数据经常满足所有七个假设。这个问题的解决方案是找到一个不同的统计测试，更好地适合所提供的数据，或者对现有数据进行调整，使其满足下面列出的要求:

使用的数据必须在连续的范围内测量(比率或间隔)
正在使用的连续数据必须成对出现。每个变量必须有两个值。之前我提到了笛卡尔坐标。
每个案例都应该是独立的。每个变量或情况都有两个观察值。比如智商，年收入。如果一个案例具有高智商和高收入(散点图上的数据点)，这不应该与数据集中的另一个案例或点相关。
两个连续变量之间应该是线性关系。
被测试的两个变量都应遵循一个双变量正态分布(一个三维钟形曲线，代表两个独立变量 X 和 Y，它们相加在一起形成一个概率密度函数 PDF，变量是线性函数，并且是独立的正态随机变量)。使用单变量正态性是可以接受的，但建议使用双变量。
应该有同方差。这意味着，当直线沿某个方向移动时，数据点应该遵循一致的方差，因为它与最佳拟合直线的移动方向相同。如果方差不相似，则意味着存在异方差。(这个真的很难用皮尔森的相关系数来检验)

图片作者:https://statistics . laerd . com/statistical-guides/Pearson-correlation-coefficient-statistical-guide . PHP

7.不应该有任何单变量或多变量异常值。不应该有任何异常值！单变量异常值是出现在一个变量而不是两个变量中的极值。多元变量由至少两个变量中的异常值组成。异常值会影响结果，这取决于所进行的统计测试。在这种情况下，r 会受到影响，这是不理想的情况。

在数据科学领域，当使用线性回归算法时，可以计算 r。线性回归来自统计学，并被借用和应用于机器学习，以创建预测模型。线性回归算法有助于最小化误差量，从而提高精确度。

总的来说，r 有利有弊。

优势:

显示两个变量的强度以及是否确实存在关系
研究随机独立变量的行为
与其他更复杂的统计测试相比，它有助于获得更容易分析的定量数据。

缺点:

它不能显示因果关系
它假设总有某种形式的线性关系
相关性并不意味着因果关系。两个自变量相关性高，不代表就是因果关系。(一个变量导致另一个变量发生)

我发现一个人选择使用的测试很大程度上取决于手头的数据和项目的最终目标。

皮尔逊相关系数是我在学习成为数据科学家时学到的第一件事。

参考文献:

“用于机器学习的线性回归”https://Machine Learning mastery . com/Linear-Regression-for-Machine-Learning/

‘皮尔逊的 PDF’；https://www . stats tutor . AC . uk/resources/uploaded/pearsons . pdf

https://www . ICP Sr . umich . edu/ICP srweb/content/shared/ICP Sr/FAQs/what-is-r . html

为数据可视化设定基调的重要性

原文：https://towardsdatascience.com/the-importance-of-setting-a-tone-for-your-data-visualization-6aae83667062?source=collection_archive---------58-----------------------

创造一种气氛不仅仅是小说家的事

语气和情绪显而易见:照片由 Kat J 在 Unsplash 上拍摄

每一个伟大的故事背后都有一种潜在的基调，讲故事的人试图传达这种基调，以吸引观众产生一种特殊的感受。精心制作的语气可以让听众感受到喜悦、悲伤、愤怒或希望，也可能同时感受到所有这些情绪。我们大多数人能够如此生动地记得某些书籍、电影、电视节目、照片和艺术品，是因为我们第一次观看时的感受。相信创作者以一种非常有影响力的方式精心打造了他们故事的基调。

作为一名数据分析师或数据科学家，我们有大量的数据可以利用，并通过创建可视化来获得洞察力。我们可能精通我们行业的技术，但我们工作的很大一部分是利用这些数据帮助人们根据我们提供的信息采取行动。根据不同的情况，我们必须以一种特殊的方式来构思我们的故事，以影响观众对我们想要讲述的故事的理解和感受。为你的想象创造一个基调有助于构思一个故事。

为寻找一家公司销量最高的产品而创建可视化效果的基调，可能与你试图说服整个国家，在疫情期间呆在家里有助于拯救生命的基调不同。这两种情况处于光谱的相反两端，但是作为可视化者，设定你的可视化的基调将是一个人记住你的分析并采取行动或者把它推到一边并继续前进的区别。

视觉化的基调是什么？

在安迪·基尔克的书《数据可视化:数据驱动设计手册》中，他用一句话很好地总结了可视化的基调:

"声调:“阅读”和“感觉”数据的区别."

就像任何创造性的努力一样，比如写故事、摄影或绘画，创作者想要讲述一个故事，他们可能希望观众以一种特定的方式来感知它。在写作中，作者通过他们的措辞、不同的观点和不同的正式程度来建立一种基调。摄影师可以通过他们对颜色的使用或他们如何框住他们的主题来建立一种基调。在建立你的视觉化图像的基调时有许多相似之处，主要目标是你希望你的观众如何解释和感知你的视觉化图像。你对图表、颜色、字体、大小和形状的选择都在为你的视觉化建立你的基调中扮演了一个角色。

我打赌你会忍不住笑:米的照片

为什么语气很重要？

和其他媒介一样，为你的视觉化建立一个基调尤其重要。在可视化数据的时候有一个你想讲的故事，但是作为创作者，你无法控制你的受众对你的题材的态度。然而，你确实可以控制你的观众如何解释和理解你的主题。建立你的风格有助于影响你的观众以你创造的方式感知和理解你的视觉效果。

如果你已经定义了可视化的目的，你就可以决定你需要为观众设定什么样的基调。正如安迪·基尔克在他的书中所说的，根据你视觉化的目的，你会想要使用两种类型的音调。第一种是用读的语气，第二种是感觉的语气。

如何建立“阅读”的基调

由 Tableau Public 上的 syedjawadhassan 创建:https://Public . Tableau . com/views/supply chain dashboard/1kpid ashboard？:display _ count = y&mobile =&:origin = viz _ share _ link

当试图优化听众理解你的数据并从中获取详细信息的效率时，使用阅读语气。你想用快速的事实和数据打动你的观众，而不必担心提供太多的视觉刺激。目标不是创造视觉效果和故事点来让你的观众感受到某种情绪，而是提供关键的、详细的信息来推动行动。

因为您希望您的受众能够从您的数据中快速获得洞察力，所以线形图、条形图或带有热图的文本表格等图表非常适合设定阅读基调。这些图表很好地展示了价值的大小，观众可以快速识别谁是高绩效者，哪里可以改进。

这种语气的使用在执行仪表板中很明显，如上图所示，它显示了公司内的关键指标。陈述每个指标的数字向观众展示每个指标的大小。使用折线图显示一段时间内每个指标的下降和峰值。如果某个指标超出或未达到目标，颜色会使其易于识别，从而有助于此视觉效果的基调。

如何建立“感觉”语气

由 Kevin Flerlage 在 Tableau Public:https://Public . Tableau . com/views/the African water crisis/water dashboard？:display _ count = y&mobile =&:origin = viz _ share _ link

如果你正在与对你的分析主题一无所知的人交谈，但需要激发行动号召或影响对某一特定主题看法的改变，你会怎么做？抛出指标和硬数字对你的受众没有任何好处，因为他们没有正确解读数据的知识。为你的视觉化选择一种“感觉”的语气将有助于听众如何理解你的主题。

如果听众对某个主题的了解有限，那么要想影响他们，数字是不够的。正如在其他媒体形式中看到的，没有什么比激发情感更有助于改变一个人对某个话题的看法了。无论是试图说服人们呆在家里洗手会在疫情期间拯救生命，还是展示向慈善组织捐款为非洲提供清洁水的重要性，都需要结合精彩的故事和视觉刺激来表达你的观点。

你通常会注意到图形、图片、注释和排版的使用更加明显，以帮助构思故事。与上面的“非洲清洁水”视频一样，请注意使用文字和标签来帮助解释眼前的危机，以及使用颜色和粗体字来吸引观众对令人震惊的统计数据的注意。此外，我提到的条形图和折线图最适合在使用“阅读”语气时使用，但在这种情况下，它可以很好地向观众提供视觉刺激，同时给他们足够的信息，让他们注意到情况的严重性。蓝色和水滴的使用也是一个很好的接触，将可视化的主题结合在一起。

带有感情色彩的视觉效果并不总是试图说服观众采取行动。有时候，分析师的目标是让听众了解某个特定的话题，并让他们得出自己的结论。带着这个目标使用情感基调可能需要使用更少的词语和更多视觉刺激的图形，让观众参与到你的作品中。由于关注更吸引人的视觉效果，数据中的细节可能会有所损失。目标是让观众在高层次上理解主题，使其易于理解。

由杰夫·普拉特纳创作于 Tableau Public:【https://public.tableau.com/profile/jeff.plattner4532#! /viz home/JordanCareerScoring/player viz

迈克尔·乔丹是我最喜欢的运动员，所以上面显示的视觉效果非常吸引我。我不需要太多的视觉效果来吸引我，但是对于一些不太了解迈克尔·乔丹的人来说，美丽的烟火图表可能足以吸引他们。由于 Tableau 的交互特性，如果你将鼠标悬停在每个烟火图的每个条形上，就会显示迈克尔·乔丹职业生涯中每场比赛的得分。然而，如果你要查看 viz 的静态图片，它仍然可以很好地概述迈克尔乔丹的得分能力。通过颜色和条纹的使用，很容易看出他在 30-49 分的比赛中获得了公平的份额。仅仅从视觉上来看，这个评估是相当准确的，因为迈克尔·乔丹是 NBA 历史上每场得分最高的球员。使用情感基调时，确定你的目的和你的听众是知道如何激发听众情绪和参与的最重要因素。

概括起来

像所有形式的消费媒体一样，设定你的视觉化的基调可能是保持你的观众参与和对你的分析采取行动或把你的分析扔到一边的区别。在定义了你的视觉化的目的后，我鼓励你定义一种有助于表达你的观点的语气，并以一种他们可能不会关注你的主题的方式吸引观众。有许多伟大的故事要用数据来讲述，所以从一开始就设定基调是至关重要的！

参考

[1]安迪·基尔克，《数据可视化:数据驱动设计手册》 (2019)

辅助项目在机器学习中的重要性

原文：https://towardsdatascience.com/the-importance-of-side-projects-in-machine-learning-edf9836bc93a?source=collection_archive---------39-----------------------

米卡·鲍梅斯特在 Unsplash 上的照片

提示和建议

你和马克·扎克伯格有什么共同点？在这篇文章中，你会发现为什么副业是通向许多机会的大门。

有几个问题是机器学习从业者经常问的，他们希望提高他们的技能、职业生涯或知识。

一些常见问题大致如下:

“我要怎么做才能学会深度学习？”

“我该怎么做才能得到一份数据科学或机器学习的工作？”

“怎么做才能让机器学习快速进步？”

所有这些问题都有不同的答案，取决于你问谁。也就是说，有一个适用于所有问题的答案。

那就是:

辅助项目。

或者更准确地说，承担和完成附带项目。

这就是你所有问题的解决方案。那么，为什么还剩下文章的实质性内容呢？

嗯，写这篇文章是为了强调机器学习中辅助项目的重要性。

作为读者，我希望你能理解，从事适当的兼职项目会对你的个人生活和职业生涯产生多大的影响。

你会发现我列举的一些个人趣闻来说明本文中提到的建议和技巧的好处。如果我的叙述不能说服你，别担心，我还有更多锦囊妙计。

在我们更进一步之前，你为什么要听我说或者读这篇文章呢？

请允许我简单介绍一下我自己。

介绍

作者简介，作者图片

关于我的职业生涯，与本文相关的一点是，我所担任的大多数角色都比我的经验水平高出至少五年。

毕业不到一年，我已经成为一家初创公司的首席网站开发人员；我接受了为至少有 10 年工作经验的人提供的合同工作。现在，我在一家初创公司领导计算机视觉项目，这是我在理学硕士学习之外的第一个基于机器学习的角色。

我怎么能做到这一切？

很简单。

辅助项目。

现在我已经引起了你的注意，让我们进入这篇文章的主要内容。副业的重要性。

确保工作/技能发展

兼职项目可以帮助你获得下一份工作。

这不是新的建议，你可能已经听过这个建议了。

我实际上想说的是: 副业可以帮助你获得一份比你现在的工作 需要更高技能和经验水平的工作。

但是，这部分的标题会太长。

我获得理学士学位后的第一个角色是一名毕业的前端开发人员。我用PHP(laravel)BackboneJS和 JavaScript 做网页。在与 PHP 战斗了一整天之后，我回到家打开笔记本电脑，开始做一个附带的项目，这个项目使用了 NodeJS、Angular 和 MongoDB。

我的兼职项目没有直接增加我的工作知识，但我知道我想承担的下一个角色需要什么。

有了我下一个角色所需要的技能的信息，我从担任当前角色的第一天起就开始学习这些技能。

在我本科毕业后的第二份工作的面试中，我几乎没有提到我在实际工作中做了什么。主要的对话和提问都与我的副业项目有关。

当时对我的雇主更有吸引力的是，我能够找到学习一套新技能的动力，同时保持理智与 PHP 斗争。

我利用我的兼职项目为我的下一个角色做准备，直到我最近的角色是计算机视觉工程师。在我收到的所有三份工作邀请中，甚至是我被拒绝的职位，我只谈了技能和从我的副业项目中学到的东西。

行动

现在你怎么能把我的个人经验应用到你自己身上呢？

上网到任何一个工作网站，搜索你认为自己在未来 2-5 年内需要的职位。不要被这个角色的资历所影响。记下所需的技能和工具。

接下来，利用你理想角色所需的技能开始一个副业。大小不重要。开始吧。

以下是我目前如何使用这种方法。

我渴望在未来 2-5 年内成为一名首席机器学习工程师。通常，被考虑担任这一职位的人拥有广泛的专业知识，并有 10-15 年的工作经验。

但这一点也不会让我分心。

让我在下面与你分享我确保自己拥有正确技能和专业知识的方法。我用来生成下面页面的工具是idea . so。

为我的下一个角色跟踪我的个人技能和专业知识

上面的图片非常个人化，但这不正是我们都爱 Medium 的地方吗？该图描绘了我的技能跟踪器，其中包含的任务侧重于获取我期望的下一个角色所需的专业知识和技能。

我每周都回顾这个列表，并且每天都处理每个任务的内容。

请随意使用类似的结构。我想展示每个任务包含的内容，但也许在另一篇文章中，我可以详细介绍。

请考虑到我不是专家，我只是像你一样的初学者。

如果你同意或不同意下面的说法，请在这篇文章的评论区留下评论，我想知道你对此事的想法。

我看到很多人在科技行业犯的一个错误是，他们将经验与在一个职位上的年数联系起来。然而在现实中，有些人在几年内只有很少的经验，他们在发展一项技能上花费的时间比一般人在三年内花费的时间还要多。

你需要成为这些个体中的一员。副业是一条经过验证和测试的道路。

照片由你好，我是尼克🎞开启防溅

强化学习

身边的项目可以辅助知识的保留

说机器学习需要吸收前所未有的大量信息是一种保守的说法。

我们的工作包括不断学习，直到退休的那一天。

蒂莫·沃尔茨在 Unsplash 上拍摄的照片

就像我之前说的，我仍处于职业生涯的早期，尽管如此，我仍在努力记住几天前学到的知识。

稍有经验的人会告诉你，机器学习角色的成功并不明确取决于你能记住多少，而是取决于你找到并实施解决方案以满足特定要求的能力。

尽管如此，你需要一种知识保留的方法来保持你的思维敏捷，并拥有能够处理任何任务的心态，不管你是否熟悉。

再说一次，副业可以在这方面有所帮助。

在我的职责范围内，我广泛使用了 TensorFlow 框架。我使用 TensorFlow 建立机器学习管道，每天训练和评估模型。然而，我仍然发现自己在参考 StackOverflow 或者文档来完成我已经做了很多次的任务。

这个问题的解决方案是显而易见的。你可能会告诉我保持理解和练习，直到它成为第二天性。你是对的。

这就是为什么我决定在我的兼职项目中扩展重复和练习我在角色中所学技能的过程。

我的想法很简单。如果我在工作时间和下班后使用 TensorFlow，我会花更多的时间一遍又一遍地重复这些过程，直到它们成为第二天性。

无论你想学哪种方法，对它有一个基本的理解也是至关重要的。

行动

找到流程中你未能理解的方面，并在下班后在你的副业项目中实践它们。

这种简单的技巧通过持续练习的原则来帮助记忆知识。

你自己的公司

身边的项目可以是盛大的开始

马里奥·高在 Unsplash 上的照片

我们听说过有多少副业项目变成了价值数十亿美元的公司？

我们今天使用的大多数应用程序和工具都是副业的产品。

脸书作为副业开始。

在这个包括马克·扎克伯格和陈慧娴在内的简短采访中，普里西拉称脸书只是马克的一个项目。她的原话是:

“没有人会想到会发生这样的事…这是他的下一个项目”

嘿，我不是说你的下一个副业项目会变成一个十亿美元的公司。

我想说的是，人们愿意为解决重大问题的好产品赋予货币价值。你的副业可能是一项有价值的投资。

在我十八九岁和二十出头的时候，我经常参加聚会。我参加了太多的活动，我需要一个系统来推荐值得我花费时间的活动。因此，我开发了一个 web 应用程序，使用多个活动网站 API，并制定了一个比较算法，对活动地点、价格和参与者进行加权，以提供单个活动推荐。

这个副业项目并没有变成一个数十亿美元的公司。尽管如此，它确实变成了一家公司，我和我的兄弟为之工作了几年，并赢得了创业竞赛。

我想做的就是更有效率地开派对。

目前，我的下一个副业项目是围绕限制冠状病毒感染的机会。迫不及待地想分享这个。

行动

用副业解决生活中的痛点。

你有一项技能，使你能够创造工具，以创造性和想象力的方式解决人们生活中的问题。

看看你一天中的方方面面，找出三件可以通过机器学习解决方案变得更简单的事情。

然后实施这些解决方案，享受旅程。

没有人能预测明天，你的下一个副业可能会和《脸书》一样成功。

如果不是，你仍然可以获得大量的技能和经验。

在你走之前

丹尼尔·麦金尼斯在 Unsplash 上的照片

老实说，我只是在生活中尝试了很多事情，如果一些事情产生了积极的结果，我会付出更多的努力。

我鼓励你按照我在这篇文章中提到的一些行动去做。如果它们对你不起作用，那就继续前进，尝试一些有用的东西。

有几个话题我故意没有包括在本文中，这些话题也展示了机器学习中辅助项目的好处，例如:

额外收入
打造个人品牌
建设社区

上面提到的省略的谈话要点，我没有丰富的经验。但是一旦我获得了宝贵的经验，我一定会分享。

别忘了开始一个兼职项目。

基于数据的印度股票市场对新冠肺炎的反应

原文：https://towardsdatascience.com/the-indian-stock-market-reactions-to-covid-19-a-data-based-approach-843fe105a847?source=collection_archive---------46-----------------------

NIFTY-50 价格变动和影响它的各种因素的分析。

作者图片

在本文中，我们将使用 python 对印度股市及其对 2019 年新型冠状病毒疾病(新冠肺炎)的反应进行一些数据分析。我们将试图了解一些因素的影响，如该国确诊病例的增加，搜索新冠肺炎的人的谷歌趋势分析，与 DJIA(道琼斯工业平均指数)的相关性等。理解新冠肺炎出现等事件后果的一个有效方法是考虑资产价格的变化。这些价格变化反映了当前的预期。实际上，资产市场提供了关于未来预期结果的持续的、高风险的调查。

首先，我们将从导入分析所需的库和数据集开始。所有使用的数据可在 NSE 网站上获得

import pandas as pd
import plotly.graph_objects as go
import matplotlib.pyplot as plt
%matplotlib inline
nifty_price = pd.read_csv('nifty.csv',header=0,index_col=0,parse_dates=True)
nifty_price.head()

我们有兴趣分析 NIFTY 指数在过去 6 个月(从 2020 年 1 月 1 日起)的累计回报。我们将使用数据框架的“调整收盘”栏来计算回报。函数 pct_change() 将给出 NIFTY-50 指数收盘价的每日百分比变化。

 nift_price=nifty_price[['Adj Close']]
nift_price['returns'] = nift_price['Adj Close'].pct_change()
nift_price = nift_price.dropna()
nift_price['returns'].plot()

漂亮的每日回报

我们可以清楚地观察到，市场在三月份波动最大，损失也最大。三月份的累计回报率为-0.263，一个月内损失了 26.3%。

returns_sec = nift_price['2020-03-01':'2020-04-01']['returns']
(returns_sec+1).prod()-1

现在，我们将计算一个非常流行的衡量风险的方法，称为最大提取，它给出了如果你不幸在资产的最高点买入，在最低点卖出，你可能经历的最大损失。这基本上是你能经历的最差的回报。提款是衡量最大下行风险的指标。为了计算提款，我们首先计算财富指数和所有时间点的先前峰值(即自开始以来经历的最高值)。

wealth_index = 1000*(1+nift_price['returns']).cumprod()
previous_peaks = wealth_index.cummax()
drawdown = (wealth_index-previous_peaks)/previous_peaks
drawdown.plot()

drawdown.min()将给出考虑期间发生的最大提款，而drawdown.idxmin()给出最大损失发生时的时间戳。我们发现，2020 年 3 月 23 日观察到的最大下降幅度为-38.44%。这是 3 月 22 日 Janata 宵禁后的第二个交易日。

有一点很清楚，在确诊的冠状病毒病例数和漂亮的价格/回报之间没有太多可观察到的相关性。然而，分析谷歌在印度(新冠肺炎)的搜索趋势结果可以得出一个重要的结论:公众情绪对市场价格和波动性的影响最大。应对疫情的市场情绪可以通过社交媒体迅速放大，然后刺激贸易活动并导致极端的价格波动。股票市场基本上为我们提供了投资者对未来的预期。谷歌搜索趋势数据可以从这里下载，也可以从我的 Github 库的 datasets 文件夹下载。

google_trends = pd.read_csv('google_trends.csv',header=0,index_col=0)
google_trends.rename(columns = {'india coronavirus: (India)':'Search_Intensity'}, inplace=True)
google_trends['Search_Intensity']= google_trends['Search_Intensity'].replace('<1', '0') 
google_trends['Search_Intensity'] = google_trends['Search_Intensity'].astype(int)#March 1st to April 1st correlation
column_1 = nift_price['2020-03':'2020-04']['Adj Close']
column_2 = google_trends["01-03-2020":"01-04-2020"]['Search_Intensity']
correlation = column_1.corr(column_2)

在印度，关于冠状病毒的谷歌搜索强度在 3 月份大幅增加，在 3 月份的最后一周(2020 年 3 月 23 日至 24 日)达到峰值。在 4 月初的中期高峰之后，价格有所回落。在此期间(3 月至 4 月)，可以看到谷歌搜索强度因子与 NIFTY 指数高度负相关，相关系数为-0.685。此外，从 2020 年 3 月 1 日到 2020 年 6 月 15 日的总体相关性为-0.52。由此，我们可以看出，搜索查询数据与分析关于疫情的公众情绪及其对金融市场的影响相关。

另一个重要的，虽然预期的相关性，我们可以找到的是道琼斯工业平均指数(DJIA)和 NIFTY 价格之间的关系。道琼斯工业平均指数(DJIA)是一个股票市场指数，跟踪在纽约证券交易所( NYSE )和纳斯达克交易的 30 家大型上市蓝筹股公司。该数据集可以从雅虎财经网站获得。

dow=pd.read_csv('dow.csv')
dow = dow.drop(['Open', 'High','Low','Close','Volume'], axis=1)
dow['Date'] = pd.to_datetime(dow['Date']).dt.strftime('%d-%m-%Y')
dow.rename(columns = {'Adj Close':'Dow_Jones'}, inplace=True)
dow.head()

在 2020 年 1 月 1 日至 6 月 17 日期间，两个市场指数之间的相关性似乎非常高，为 0.93。

按行业划分的股票回报率

我们可以清楚地看到，这一时期唯一累积收益为正的行业是医药行业。Nifty Pharma 指数在 2020 年 4 月的回报率为 22.6%，而 Nifty50 指数仅上涨了 6%。由于该部门相对抗新冠肺炎的破坏，可以观察到一个积极的立场对印度医药股。

从下图(2020 年 1 月 1 日至 2020 年 6 月 17 日各行业指数的累计收益)中，我们可以清楚地看到，银行业、金融服务、房地产、零售和汽车处于受影响最严重的行业的前列。在连锁企业延伸到多个受疫情袭击的国家的公司中，股价跌幅更大，因为这影响到更多的国际供应网络，而不仅仅是当地供应。

结果表明，市场很快开始对新冠肺炎可能的经济后果做出反应。我们在 3 月份观察到一些大的价格波动，当时投资者开始担心新冠肺炎冲击可能通过金融渠道放大。股票价格反映了市场参与者对未来经济后果的预期。此外，我们可以看到，谷歌新冠肺炎趋势指标和市场波动之间存在直接的因果关系。越来越多的人开始寻找与疫情有关的后果，由此引发的焦虑对市场回报产生了负面影响。

就是这样！我们已经到了文章的结尾。完整的代码可以在我的 Github 库这里找到。欢迎留下任何建议、问题或评论！

无法逃脱的人工智能算法:抖音

原文：https://towardsdatascience.com/the-inescapable-ai-algorithm-tiktok-ad4c6fd981b8?source=collection_archive---------6-----------------------

机器学习、创业、数据科学

描述一个抖音用来吸引用户的渐进式推荐系统！

从 Tka4enko 通过运球

如果你没有关注抖音，那你就根本没有关注。

内容表:-

什么是抖音？
是什么让抖音有别于其他社交媒体平台？
几种理论
可能的抖音推荐系统

什么是抖音？

抖音是最受欢迎和最有趣的社交媒体应用之一。除了对口型，它还迎合短舞蹈，喜剧和才艺视频。一个更接近的类比是 Vine ，Twitter 仍然非常怀念的短格式视频应用，其内容作为 YouTube 的汇编而存在。

抖音归字节跳动所有，这是一家成立于 2012 年的科技公司。字节跳动首先为中国市场推出豆饮，然后逐渐向中国以外的市场推出。字节跳动拥有两个社交媒体平台:-中国的抖音(多音)(受到他们协议的审查)，以及世界其他地方的抖音。后来，抖音与 Musical.ly 合并，该公司发展迅速，成为 2018 年第三季度美国下载量最高的应用之一。

字节跳动是世界上最成功的创业公司，在私人市场的估值为 1000 亿美元。关键可以被视为人工智能，该公司使用强大的人工智能工具，这些工具比西方的任何竞争对手都更极端。它还开发了一个人工智能工具，可以阅读 5000 个来源的新闻，并可以在 2 秒内生成一篇 400 字的定制文章。该公司牢牢控制着人工智能，并具有取代其他社交媒体平台的巨大潜力。

是什么让抖音有别于其他社交媒体平台？

从苏珊·沃西基到马克·扎克伯格，所有人都表达了对抖音近年来抢夺市场的担忧，并为它在用户中取得的成功而疯狂，从老人到青少年。

但这只是抖音空前成功的一部分原因。在不到两年的时间里，它从一个小粉丝群中的“唇同步”功能变成了 2020 年的一个病毒式功能，每月活跃用户近 8 亿。在如此短的时间内，它可以与市场上超过 10 年的老牌社交媒体平台相媲美！

抖音每月活跃用户。来源:我们的社会

说到数字，抖音在全球拥有超过 8 亿活跃用户，使抖音在社交网站方面排名第七，领先于 Twitter、Pinterest 和 Snapchat 等知名平台。

与对手相比，Instagram 用了 6 年时间，脸书用了近 4 年时间才达到抖音在不到 3 年的时间里达到的月活跃用户数量。

抖音是 2020 年 5 月美国下载量最多的应用。(来源:感应塔)

《抖音》是 2020 年 5 月全球下载量最大的应用(非游戏)，下载量超过 1.119 亿次，其中包括中国的斗印，同比增长 2 倍。

回到这个问题，是什么让它独一无二？

它使用一个先进的循环推荐系统，不像网飞和 YouTube 这样的老派娱乐平台，它不会向你推荐视频，而是指示你看什么？

正如中国著名投资家康妮·陈所说:

“抖音是第一款以人工智能为产品的主流消费应用。这代表了更广泛的转变。”

与 Instagram 和 YouTube 相反，你不需要一个单一的观点或追随者就可以病毒式传播。它使用人工智能驱动的饲料，其工作原理是“你用得越多，它就越了解你”。

它严重依赖用户的个人信息(位置、特征、特质、互联网搜索)来使提要更加个性化，因此经常成为信息泄露和滥用争议的一部分。

任何社交媒体平台的基本目标都是让用户参与进来，令人惊讶的是，抖音可以让新用户平均参与 10 分钟，这是 Instagram 的三倍。

它降低了进入门槛，甚至不需要你注册，一旦你安装了应用程序，它就开始跟踪你，并根据这些因素向你推荐视频。

举例来说，如果你是一个应用新手，抖音给你看了一个视频，而你没有看完整个视频，你得到的这类视频的推荐会更少，反之亦然。

此外，它允许你展示你的才华，不像其他社交媒体巨头那样提升地位而非才华；任何人都可以成为抖音的创造者，这就是 USP！

几种理论

关于算法没有太多的透明度，但是仍然有一些基于用户经验和专家分析的理论。

批处理理论:

据此，当视频被上传时，它被显示给具有不同意识形态的一批人，或者用简单的话来说，基于诸如他们的观看历史、位置、个人偏好等几个区别因素。你的内容的命运是基于那些不同的批次；重新观看，喜欢，分享和评论，这些都是算法用来提升你的内容分数的小输入。

如果你的内容被批量用户所喜欢，那么它就会被推向更多具有相同思维过程的观众，从而使它成为病毒！

根据这个理论，你可能需要几天时间才能成为名人。

额外的一点是:-你越多地参与趋势挑战，它就越能提升你。

权威排名:

根据这一原则，你能否走红取决于你最初的几个视频。如果这些获得了一些观点和喜欢，那么它为你作为创作者搭建了一个舞台，你唯一的工作将是尽可能多地与观众互动。

一旦你获得了权威排名，你将会成为众人瞩目的焦点，并且会比新手用户高出一些水平，尽管你仍然是个新手。

延迟动量:

遵循这个原则，一些用户建议不要删除任何内容，不管它有多垃圾！

一些用户已经体验到，如果他们的内容没有什么好处，他们在平台上开始变得不那么活跃，平台会在一段时间后试图自己增加他们的内容，从而鼓励他们为观众创造更多内容。

可能的抖音推荐系统

抖音算法没有确定的工作流程，但基于该公司发布的数据和书呆子发现的踪迹。我下定了随之而来的决心。

抖音算法是如何为内容创作者工作的？

一旦视频被上传到抖音，高性能的人工智能算法就会使用自然语言处理和计算机视觉来分析视频。

来源

它将分析你的视频的每一部分，包括音频、字幕和元数据(标签)，以建立对视频内容和背景的理解。

“人工智能为字节跳动的所有内容平台提供动力，”这位发言人说。“我们制造智能机器，能够使用自然语言处理和计算机视觉技术理解和分析文本、图像和视频。这使我们能够为用户提供他们最感兴趣的内容，并使创作者能够向全球观众分享日常生活中的重要时刻。”

在对其规则和法规进行检查后，内容将被推送给一小批观众，并根据样本用户对该内容的反应进行评估。每个被跟踪的指标都有一个可能的关联分数。

【复看率】 = 10 分 完成率 = 8 分 股份 = 6 分 评论 = 4 分 点赞 = 2 分

但一遍又一遍地循环播放你的视频不会让你病毒式传播，因为这种算法可以区分冗余条目。

一旦你的内容的综合得分不错，它会把你的内容推向更多有着相同想法和教条的观众。

如果你的内容没有像病毒一样传播，不要沮丧，因为循环并没有结束，只是暂停了一下，根据延迟动量理论，一旦你开始在应用程序上留下更短的足迹，它可能会回滚。

这是一个连锁反应，将继续下去，吸引更多的内容创作者，从而吸引更多的观众。这是这个平台的精髓，可以长期吸引用户。

作为用户，抖音是如何了解你的？

如前所述，抖音通过不强迫用户注册来降低准入门槛。相反，应用程序开始尽可能多地了解你。你观看的第一系列视频有助于它决定你的口味。

首要任务是让你尽可能长时间地呆在应用程序中。它只会向你展示更广泛的观众喜欢的视频，从而尽量降低你的退出率。

一旦你进入他们的生态系统，他们会跟踪你的每一项指标，并为你的个人资料创建每一个流派的分数。

每次你重新观看一个视频或看完整个视频，算法都会为你的个人资料推荐更多类似类型的视频。以下是详细的可能度量系统:

= 10 分 完成率 = 8 分 份额 = 6 分 评论 = 4 分 点赞

除了您的度量数据，它还会收集您的个人信息，如您的位置、您的互联网历史、您的年龄，以创建更准确的个性化订阅源，从而尽可能长时间地将您留在他们的生态系统中。

这种算法的奇妙之处在于，它可以通过其卓越的内容推荐系统吸引来自世界各地不同年龄组的用户！

简而言之，推荐工作流程

在抖音，每天有数百万的用户上传内容。手动监控每个内容实际上是不可能的，因此审查由机器完成，如果内容被标记为对公司的协议不敏感，它将被传递给人工审查。

通过人工审查后，检查内容是否重复，通过该阶段后，将内容传递给一小批用户进行初步反馈；基于度量系统对内容进行评分，评分决定内容的命运；如果分数高于某个阈值，那么内容将被推向更广泛的受众，但在一周左右的时间内会冷却下来，以保持其用户体验新的内容。

但是，如果反馈很低，循环不会就此停止，而是暂停，应用程序观察用户的行为及其活跃时间，如果它经历了高退出率，那么循环将再次变得活跃，并增加内容，从而鼓励创作者在平台上创作更多和参与更多。

这种循环是主要原因，它让它的用户着迷，因为它不会让用户感到无聊，如果你是用户，它会不断命令你并向你推荐高度个性化的内容，如果你是创作者，它会试图分散你的一些注意力，从而保持你的士气高昂，并鼓励你创造更多！

如果你喜欢这篇文章，请考虑订阅我的简讯: 达克什·特雷汉每周简讯 。

结论

希望这篇文章已经告诉你抖音是如何使用人工智能的，以及它的推荐工作流程如何以低退出率吸引用户更长时间。

一如既往，非常感谢您的阅读，如果您觉得这篇文章有用，请分享！😃

参考资料:

[1] 逆向工程抖音算法如何工作

为什么抖音让它的用户如此痴迷？让你上瘾的人工智能算法。

[3] 我们测试了五种最好的抖音算法理论，看看哪一种有效

【4】是时候认真关注抖音了

[5]2020 年你需要知道的 10 个抖音统计

[6]2020 年 5 月全球热门应用下载量

随意连接:

加入我在www.dakshtrehan.com

LinkedIN ~https://www.linkedin.com/in/dakshtrehan/

insta gram ~【https://www.instagram.com/daksh_trehan/】T21

Github ~https://github.com/dakshtrehan

查看我的其他文章:-

** [## 为什么你要为乔治·弗洛伊德的谋杀和德里社区骚乱负责！！

一个 ML 爱好者改变世界的方法。

medium.com](https://medium.com/@dakshtrehan/why-are-you-responsible-for-george-floyds-murder-delhi-communal-riots-4c1edb7acbc5) [## 使用深度学习检测新冠肺炎

一个实用的方法来帮助医生帮助我们对抗新冠肺炎

towardsdatascience.com](/detecting-covid-19-using-deep-learning-262956b6f981) [## 解释激活功能

阶跃，Sigmoid，双曲正切，Softmax，ReLU，Leaky ReLU 解释

medium.com](https://medium.com/analytics-vidhya/activation-functions-explained-8690ea7bdec9) [## 解释参数优化

梯度下降的简要描述指南，ADAM，ADAGRAD，RMSProp

towardsdatascience.com](/parameters-optimization-explained-876561853de0) [## 梯度下降解释

梯度下降综合指南

towardsdatascience.com](/gradient-descent-explained-9b953fc0d2c) [## 逻辑回归解释

尽可能简单地解释逻辑回归。

towardsdatascience.com](/logistic-regression-explained-ef1d816ea85a) [## 线性回归解释

尽可能简单地解释线性回归。

medium.com](https://medium.com/towards-artificial-intelligence/linear-regression-explained-f5cc85ae2c5c) [## 确定最适合您的 ML 模型。

以最简单的方式教授过度拟合与欠拟合以及完美拟合。

medium.com](https://medium.com/datadriveninvestor/determining-perfect-fit-for-your-ml-model-339459eef670) [## 将机器学习技术与现实生活联系起来。

尽可能简单地解释 ML 模型的类型。

levelup.gitconnected.com](https://levelup.gitconnected.com/relating-machine-learning-techniques-to-real-life-4dafd626fdff) [## 为新手提供数据科学服务

所以，上周我的团队负责人让我面试一些可能加入团队的实习生，了解数据的作用…

medium.com](https://medium.com/towards-artificial-intelligence/serving-data-science-to-a-rookie-b03af9ea99a2)

干杯！**

梯度下降的来龙去脉

原文：https://towardsdatascience.com/the-ins-and-outs-of-gradient-descent-1cf23dc90f83?source=collection_archive---------45-----------------------

优化您对优化器的选择

查德·特兹拉夫在 Unsplash 上的照片

梯度下降是一种优化算法，用于通过在最陡下降的方向上迭代移动来最小化一些成本函数。也就是说，在具有最大负梯度的方向上移动。在机器学习中，我们使用梯度下降来不断调整模型中的参数，以最小化成本函数。我们从模型参数的一些值(神经网络中的权重和偏差)开始，并慢慢地改进它们。在这篇博文中，我们将从探索经典机器学习中常用的一些基本优化器开始，然后转向神经网络和深度学习中使用的一些更流行的算法。

想象一下，你正在山里跑步(或散步，随便什么能让你开心的事)，突然一股浓雾遮住了你的视线。下山的一个好策略是从各个方向感受地面，并向地面下降最快的方向迈一步。重复这个过程，你应该会到达山的底部(尽管你也可能会到达一些看起来不像底部的地方——稍后会详细介绍)。这正是梯度下降所做的:它测量代价函数J(ω)(由模型参数 ω 参数化)的局部梯度，并向梯度下降的方向移动。一旦我们达到零梯度，我们就达到了最小值。

假设现在山的陡度对你来说不是很明显(也许你太冷了，感觉不到你的脚，发挥你的想象力！)，所以你得用手机的加速度计来测量梯度。外面真的很冷，所以要检查你的手机，你必须停止跑步，脱下手套。因此，如果你想尽快把手机关机，你需要尽量少用手机！因此，你需要选择正确的频率来测量山坡的倾斜度，这样才不会偏离轨道，同时在日落前到家。两次检查之间的时间就是所谓的学习率，也就是我们走下坡路的步数。如果我们的学习率太小，那么算法就需要很长时间才能收敛。但是，如果我们的学习率太高，算法可能会发散，并刚刚超过最小值。

作者图片:不同学习率下梯度下降的描述

需要注意的重要一点是，并非所有的成本函数都是凸的(然而，线性回归的 MSE 成本函数是凸的)。如果函数图上任意两点之间的线段位于两点之间的图的上方，则该函数是凸的。凸性是好的，因为它意味着有一个单一的全局最小值。当成本函数不是凸的时，问题就开始出现了:可能有脊、平台、洞等等。这使得收敛到最小值变得困难。幸运的是，有一些技术可以帮助我们解决这些问题。

作者图片:描述梯度下降可能出现的问题

批量梯度下降

梯度下降世界的香草。在批量梯度下降中，我们在每个梯度步骤使用完整的训练集 X 。因此，当使用大型训练集时，速度会非常慢。

我们从寻找成本函数的梯度向量开始，我们将其表示为

这里，j(ω)是由模型参数 ω 参数化的代价函数，∇表示向量微分算子。现在我们有了梯度向量，我们只需要它往相反的方向(下坡)。然后，乘以学习速率η，我们得到一步梯度下降更新方程:

用 python 实现批量梯度下降再简单不过了！

import numpy as np 
eta = 0.01 # our chosen learning rate 
iterations = 10^3
n = 100theta = np.random.randn(d,1) # random initialization, with d being 
# the dimension of thetafor i in range(iterations):
    gradients = 2/n * X.T.dot(X.dot(theta) - y)
    theta = theta - eta * gradients

如果我们愿意，我们可以使用网格搜索来找到一个好的学习率。为了找到正确的迭代次数，通常将迭代次数设置为非常大的数就足够了，但是当梯度向量(gradients)变得小于某个预设容差(通常表示为ϵ).)时，中断算法这是因为当梯度向量变小时，我们非常接近最小值。

另一个重要注意事项是，当使用梯度下降时，您应该确保所有要素都具有相似的比例，否则，算法将需要更长的时间才能收敛-Sckikit-Learn 的标准缩放器通常可以做到这一点。但是，我们可以做些什么来加速我们的优化程序呢？进入随机梯度下降。

随机梯度下降

随机 GD 采用与批处理 GD 相反的极端，而不是在每一步使用整个训练集，它在每一步采用训练集的随机实例，并使用它来计算梯度。这显然要比批量 GD 快得多，尤其是在使用巨大的训练集时。然而，缺点是，由于其随机行为，该算法不太规则:它只是平均减少，而不是在每一步逐渐减少。因此，我们的最终参数值将是好的，但不是最佳的(不同于批量梯度下降)，因为一旦我们接近最小值，算法将继续反弹。

虽然这听起来不太理想，但它确实有帮助！例如，如果成本函数非常不规则(并且不是凸的),则随机性可以帮助跳出局部最小值。所以实际上，随机 GD 比普通的批量 GD 更有机会找到全局最小值。

当我们接近最小值时，我们实际上也可以做一些事情来帮助处理缺乏收敛性:逐渐降低学习率。我们可以从(相对)大的步长开始，这有助于更快地收敛到最小值，也有助于跳出局部最小值。然后，我们可以逐渐降低学习率，这使得算法可以稳定在全局最小值。这个过程被称为学习计划。学习进度计划是一个非常可爱的技术，也许将来我会给它一个自己的博客。

下面的代码实现了随机梯度下降以及一个(简单的)学习计划:

epochs = 50
t0, t1 = 1, 10 # Learning schedule hyperparams
n = 100def learning_schedule(t):
    return t0/(t + t1)theta = np.random.randn(d,1) # random initialization, with d being 
# the dimension of thetafor epoch in range(epochs):
    for i in range(n):
        rand_idx = np.random.randint(n)
        xi = X[rand_idx:rand_idx+d]
        yi = y[rand_idx:rand_idx+d]
        gradients = 2 * xi.T.dot(xi.dot(theta) - yi)
        eta = learning_schedule(epoch * n + i)
        theta = theta - eta * gradients

这里我们迭代了几轮 n 次迭代，每一轮被称为一个时期。

另外值得一提的是另一种方法，小批量梯度下降。简单地说，它只是批处理和随机 GD 方法的结合:在每一步，小批处理 GD 计算训练实例的一个小的随机子集上的梯度(一个小批处理)。这具有比随机 GD 更少不稳定的优点；然而，它更有可能陷入局部最小值。

到目前为止，我们已经讨论了更经典的 GD 算法，这些算法在训练更经典的 ML 模型(例如，支持向量机、随机森林等)时表现出令人满意的水平。但是，使用这些方法来训练大型深度自然网络可能会慢得令人麻木。更快的优化程序可以在训练中为我们提供额外的速度提升。下面将讨论一些最流行的算法。

动量优化

动量优化不是仅使用当前步骤的损失函数的梯度来引导搜索，而是使用动量的概念并累积先前的梯度来帮助确定前进的方向。回想一下我们之前的类比:想象你现在骑着一辆自行车，你正在下山，你开始会很慢，但你会逐渐开始获得越来越多的动量，直到你达到最终速度。这正是动量算法所做的。另一种思考方式是，梯度向量现在用于加速度，而不是速度。因此，我们的模型参数的更新方程由下式给出:

在每次迭代中，我们从动量向量中减去局部梯度(乘以η)，然后通过添加动量向量来更新权重。除了总体上收敛得更快之外，动量还有助于算法更快地脱离平稳状态，并滚过局部最小值。超参数β是系统中的摩擦量，β越高，终端速度越慢。**

内斯特罗夫加速梯度

只要对动量算法稍加调整，我们几乎总能获得更快的收敛。NAG 方法在局部位置 ω 稍前测量成本函数的梯度。单步更新由下式给出

这样做的原因很简单:一般来说，动量向量指向最小值，所以在那个方向上测量稍微远一点的梯度会有帮助。这些微小的速度提升累积起来，最终 NAG 算法的速度明显加快。在 Keras 中实现这一点非常简单，我们只需输入:

**optimizer = keras.optimizers.SGD(lr=0.001, momentum=0.9, nesterov=True)**

RMSProp

RMSProp 算法是由 Geoffrey Hinton 和 Tijmen Tieleman 在 2012 年提出的 AdaGrad 算法的修改版本(从数学角度来说，这是最近的事了！).想象一个场景，其中成本函数看起来像一个细长的碗，GD 算法将开始沿着最陡的斜率下降，但是这个斜率并不直接指向全局最小值。AdaGrad 算法为我们提供了一个修正，因此该算法确实向全局最小值移动。这是通过沿着最陡的维度按比例缩小梯度向量来实现的。另一种思考方式是，我们在更陡峭的维度上衰减学习速率更快，在斜率更平缓的维度上衰减学习速率更慢。理解其工作原理的最简单方法是亲自动手操作单步更新方程:

这里，𝇇表示元素间的乘法。因此，s 的每个元素由下式给出

所以如果代价函数J(ω)在第I-维中是陡峭的，那么 s 将会随着我们的迭代而累积并变得越来越大。这里的第二步实际上与通常的梯度下降更新相同，除了我们相对于 s 缩小梯度向量。⊘代表元素式划分，因此梯度向量的每个元素越大，我们在该方向上采取的步骤就越小。 ε 项是一个非常小的平滑项(例如 ε = 1e-10 )，它只是为了避免被零除(我曾经被零除，流了鼻血，这是魔鬼的工作)。

然而，AdaGrad 的问题是，在训练神经网络时，它通常会过早停止。这是因为学习率下降太多。RMSProp 做了一个简单的调整。相反，我们指数衰减最近迭代中累积的梯度。

尽管我们已经引入了一个新的超参数来进行调整( ρ )，但是值 ρ = 0.9 通常可以达到这个目的。现在您可能已经猜到，在 Keras 中实现 RMSProp 非常容易:

**optimizer = keras.optimizers.RMSprop(lr=0.001, rho=0.9)**

我想现在是时候谈谈优化大师了。

亚当和那达慕优化

自适应矩估计(Adam)结合了我们已经研究过的两种方法:动量和 RMSProp 优化。它从动量优化中窃取了跟踪先前梯度的指数衰减平均值的思想，并且从 RMSProp 中窃取了跟踪过去平方梯度的指数衰减平均值的思想。

这里， t 是迭代次数(从 1 开始)。第一个、第二个和第五个方程几乎与动量和 RMSProp 优化算法相同，不同之处在于超参数。第三个和第四个等式只是为了在算法开始时提升 m 和 s 而存在，因为最初，它们偏向 0。与 Keras 中的所有东西一样，Adam 非常容易实现(下面也给出了超参数的默认值)。

**optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999)**

Nadam 算法与 adam 算法相同，但它也包括内斯特罗夫技巧，这意味着它的收敛速度通常比标准 Adam 稍快。

Adam(以及 Nadam 和 RMSProp)的另一个不太明显的优点是，它需要对η进行更少的调整——因此，在某些方面，它甚至比标准的普通 GD 方法更容易实现！

结论

我们从经典的梯度下降开始，逐渐变得越来越复杂。当使用计算能力不太密集的模型时，我发现通常简单的 SGD/小批量模型工作得非常好。当训练大型神经网络时，像 Adam/Nadam 和 RMSProp 往往工作得很好。就像 ML 世界中的所有事情一样，尝试不同的方法通常会带来最好的结果。

最后一句话:已经发现有时自适应优化方法(Adam、Nadam、RMSProp)有时会导致解决方案泛化能力差，所以如果你发现这个问题，不妨试试 NAG 方法！

如果你觉得这篇文章很有趣，我强烈推荐你拿一本 Aurélien Géron 的《用 Scikit-Learn 和 TensorFlow 进行机器实践学习》。这绝对是一本不可思议的书，也是我第一次读到这篇文章中的很多内容的地方！

感谢阅读！

生成式和判别式机器学习模型有什么区别？

原文：https://towardsdatascience.com/the-insiders-guide-to-generative-and-discriminative-machine-learning-models-34d5791d53d3?source=collection_archive---------29-----------------------

数据科学，机器学习

生成型和鉴别型是机器学习模型的类别

照片由摄影爱好在 Unsplash 上拍摄

在本文中，我们将看看生成模型和判别模型之间的区别，它们是如何对比的，以及它们之间的区别。

生成模型和判别模型之间的区别是什么，它们如何对比，以及它们之间的区别是什么？

判别机器学习是在可能的输出选择中识别钻机输出。给定一些数据，通过学习参数来完成。最大化 P(X，Y)的联合概率。

分类又称为判别建模。这往往是在理由；模型必须跨类分离输入变量的实例。它必须挑选或调用给定实例属于哪个类。

无监督模型总结输入变量的分布。此外，能够习惯于在输入分布中创建或生成新的实例。因此，这些不同的模型被视为生成模型。

一个变量可能具有已知的数据分布，如高斯分布。

生成模型也能够总结数据分布。这用于生成符合输入变量分布的新变量。

创成式设置中的简单模型需要的信息更少。然后是一个复杂的区别性设置，反之亦然。

沿着这些思路，判别模型在条件预测方面胜过生成模型。同样，判别模型应该比生成模型更规范化。

第一个例子

照片由陈茂三潭在 Unsplash 上拍摄

例如，有两个孩子，托尼和马克。两人都去了宠物店，以确定猫和狗的区别。两者都特别注意颜色、大小、眼睛颜色、毛发大小、声音，这些都是宠物的特征。

两张照片一张在猫中间，一张在狗中间，马克问哪一张是哪一张。马克写下了几个条件。如果声音像猫叫，眼睛是蓝色或绿色。

它有棕色或黑色的条纹，那么这种动物可能是猫。

由于他的简单规则，他发现哪一个是猫，哪一个可能是狗。

现在不是给托尼看两张照片，而是两张白纸，让他画一只猫和一只狗的样子。托尼画了这幅画。

现在，给定任何一张照片，托尼也能分辨出哪一张可能是猫。哪一个可能是一只狗支持了他创作的图画。对于检测任务来说，绘图是一项耗时的任务，哪一个可能是猫。

但是，如果只有一些狗和猫似乎托尼和马克意味着低训练数据。在这种情况下，如果一张照片上的棕色狗有蓝眼睛的条纹。

马克有可能会把它标为一只猫。而托尼有她的画，他可以更好地发现这张照片是一只狗。

如果托尼多听一些像特写这样的东西，就会创作出更好的素描。但是，如果更多的例子显示使用猫和狗的数据集，马克会比托尼更好。

马克在观察时一丝不苟。假设你让他听更多的特色。它将创建更复杂的规则，称为过度拟合。因此，找到一只猫和一只狗的机会会增加，但托尼不会这样。

如果在参观宠物店之前，他们没有被告知。只有两种动物意味着没有标记数据。

马克会彻底失败，因为他不知道要找什么，而托尼却能画出草图。这是一个巨大的优势，有时被称为半监督。

这表明，马克是鉴别性的，托尼是生成性的。

再比如

照片由晨酿在破浪

将语音分类到一个语言模型。

确定语言模型差异的判别方法。而不用学习语言和对语言进行分类。

生成方法意味着学习每一种语言。所以用你学到的知识来分类。

生成型和判别型模型的数学方程式是什么？

照片由 Antoine Dautry 在 Unsplash 上拍摄

鉴别式机器学习实际上是在训练一个模型。在可能的输出选择中区分正确的输出。这是通过学习最大化条件概率 P(Y|X)的模型参数来完成的。

生成机器学习是训练一个模型来学习参数，最大化 P(X，Y)的联合概率。

通常在概率模型中以分解形式 P(Y)学习，P(X|Y)在大多数情况下被简化。假设条件独立 P(Y)，P(X|Y)。

有哪些不同种类的判别型和生成型机器学习算法？

由马库斯·斯皮斯克在 Unsplash 上拍摄的照片

不同型号

逻辑回归
随机森林
支持向量机(SVM)
传统神经网络
最近邻

创成式模型

隐马尔可夫模型(HMM)
朴素贝叶斯
贝叶斯网络
高斯混合模型(GMM)

在实施之前，应该问以下哪些问题？

乔恩·泰森在 Unsplash 上的照片

哪个模型训练需要的数据少？
哪个模型可以生成数据？
什么时候应该使用这种模型？
哪个模型对极值更敏感？
哪个模型更容易过拟合？
哪个模型可以用更少的时间训练？
哪个模型学习条件概率？
在不确定的情况下，哪种模型更好？
当特征有关系时，哪个模型更好？
当需要解释性模型时，哪种模型更好？
在优化所需分类精度时，哪种模型更好？
标签数据不可用时，哪种模型更好？
标签数据可用时，哪个模型更好？
哪种模式进行起来简单快捷？

生成式和判别式在深度学习中是如何工作的？

照片由照片爱好在 Unsplash 上拍摄

在生成对抗网络 【甘】中，生成器和鉴别器一起训练。生成器生成一批样本，这些样本与真实数据集一起提供给鉴别器进行分类。

区分性量词的缺点是什么？

由内森·杜姆劳在 Unsplash 上拍摄的照片

它缺乏生成性的优雅，如先验、结构、不确定性。感觉就像黑匣子，变量之间的关系似乎不是显而易见的。

结论

由奥斯汀·迪斯特尔在 Unsplash 上拍摄的照片

生成方法和判别方法是两种广泛的方法。生成包括建模和判别求解分类。生成模型更优雅，更有解释力。

模型的丰富性并不总是好的一面。拟合更多的参数需要更长的时间、更多的空间和更多的计算。鉴别模型比生成模型更需要被正则化。

生成性设置中的简单模型比区别性设置中的高级模型需要更少的数据。

现在，把你的想法放在TwitterLinkedin，以及Github！！**

同意还是 不同意 与绍拉夫·辛拉的观点和例子？想告诉我们你的故事吗？

他对建设性的反馈持开放态度——如果您对此分析有后续想法，请在下面的 评论 或伸出手来！！

推文@ SauravSingla _ 08，评论Saurav _ Singla，还有明星SauravSingla马上！

显著性检验的无意义性

原文：https://towardsdatascience.com/the-insignificance-of-significance-testing-6f6a5a91589?source=collection_archive---------26-----------------------

克服 p 值的案例

卢克·切瑟在 Unsplash 上的照片

什么时候科学发现才是真正的发现？什么时候对可能是真的事情的预感会变成人类集体认为是真的事情？

世界是复杂的，很难找到既有意义又能经得起严格测试和复制的新见解。如果我们进入社会科学和生物医学科学的更复杂的领域，这一点尤其如此:大多数研究人员没有物理学家的奢侈，物理学家可以在严格控制的环境中进行数百万次测量(想想大型强子对撞机)，直到对一项发现的有效性只有一丝怀疑。

近年来，许多怀疑的阴影笼罩在看似确定的结果上。社会科学领域的复制危机让这些问题更加广泛地为公众所知，这场危机持续至今。以心理学为例:多年来被认为坚如磐石的社会启动等现代范式正在失去可信度，这篇 Nature 文章称“许多研究人员表示，他们现在认为社会启动与其说是一种影响人们无意识行为的方式，不如说是一种实物课程，说明不可靠的统计方法如何欺骗科学家发表不可复制的结果。”这一发现不是例外，而是规律:根据 2018 年对 200 项元分析的调查，“心理学研究平均来说受到低统计能力的困扰”。

也许这不应该是一个大惊喜:涉及人类或其他复杂生命系统的实验更难控制，增加样本量并找到所有可能的误差源以保护它们的努力可能相当费力。这使得错误很容易溜进来。

显著性检定

因此，科学家自然关心找到好的标准来判断他们获得的结果是否真的值得报道。显著性检验的想法试图建立客观的衡量标准，帮助区分科学的好坏。

统计显著性最流行的标准可能是(我 95%确定)p 值。但正如我们将看到的，这个看似“最佳”的标准可能会导致一系列全新的问题。它可以使可疑的结果看起来很可靠，不能给任何东西以有意义的气氛，可以把糟糕的研究隐藏在欺骗性的客观性后面。

p 值，而不是帮助我们，在许多情况下，可能会参与到科学面临的复制危机中。显著性检验并不能取代好的科学，但它可以让人们觉得它确实如此。这就是它的危险所在。

p 值

p 值是一个相当简单的概念。

如果你在我获取的一些数据中观察到一种效果，并且如果你在数据中有一种导致这种效果的理论(假设你在一项双盲研究中给予药物治疗，并治愈了一组中一定数量的患者和对照组中一定数量的患者)，即使干预根本没有任何效果，你观察到这种效果的可能性有多大()？用更抽象的话来说，你在看的变量是不是彼此没有关系？

举个例子:假设你把 100 名接受真正药物治疗的病人和 100 名接受安慰剂治疗的病人分成一组。进行试验后，第一组中有 60 人被治愈，而另一组中只有 48 人被治愈。有多大可能这只是一种随机效应，以至于即使药物没有任何作用，你还是会做出这种观察？

这种概率与 p 值有关，通常的做法是将其设置为 p <0.05, meaning that the odds of observing the effect, even if the null hypothesis were correct, 需要小于 5 %,以使结果有效 。

一般程序可概述为如下:

挑选研究假设
陈述零假设
选择错误等级阈值的概率(p 值)
计算统计显著性检验

p 值的问题

在我关于糟糕的统计数据的文章中，我谈到了数字给我们带来的虚假的确定性。计算给定假设的小 p 值将实验的成功及其假设的有效性 归结为一个小的客观数字 。

但是这个数字的客观性和有效性是值得怀疑的，原因有很多。

p 值与零假设密切相关。但是零假设从何而来，它真正陈述了什么？在理想的环境中，零假设是对零效应的尖锐点估计，然而这只有在绝对最优的实验中才有意义，其中所有其他可能的效应都被排除在外。**

但是每一项旨在检验现实生活效果的现实生活研究都是一般地嘈杂，事实上，是系统地如此。每一个真正的零假设都是一个有缺陷的理想化，它假装不再存在系统误差/噪声源，这甚至在大多数高度受控的物理实验中都不成立，更不用说医学或社会科学了。

相应地，在他们 2019 年的论文“放弃统计显著性”中，McShane 等人。写

“……用于计算 p 值的统计模型的充分性……以及任何和所有形式的系统误差或非抽样误差，这些误差因场而异，但包括测量误差；信度和效度的问题；有偏样本；非随机治疗分配；思念；无响应；
双盲的失败；不合规；令人困惑。生物医学和社会科学的这些特征与零效应和零系统误差的尖锐的零假设的结合是非常成问题的。

从纯噪声中可以获得显著的 p 值，如已公布的例子所示(例如在 Carney，2010 )。结合一个理想化的零假设并坚持 p 值会导致荒谬的效果，即 噪音更大的研究比更多受控的、更干净的研究更有可能(或更容易)产生重要的(但错误的)结果 ，因此，基于 p 值标准， 更有可能被发表！

然后 p 值阈值 0.05 完全是任意的。没有真正的科学依据将证据分为统计上显著的和统计上不显著的两类,假设一个看似合理的阈值对于所有学科的所有实验和假设都是完全相同的也是幼稚的。

实例化一个任意的阈值对科学思维是有害的，科学思维应该总是 包含许多不同的、潜在的未被发现的解释 。

顺便提一下，这些未被发现的解释也不包括在零假设中。正如安德鲁·盖尔曼在这里写的，零假设本身不是一个好的假设，而是 扮演了另一个假设 的稻草人。将你的假设与一个坏的假设相比较，并不能否定所有其他的，关于数据中正在发生的事情的潜在的更好的假设。

最后但同样重要的是，p 值经常被误解，这只会加剧问题。一项对 791 篇论文的元研究显示，49 %(!)误用了 p 值，并将统计上不显著的结果归类为表明不存在影响。

放弃显著性检验

统计很难。

麦克沙恩等人。

由于复制危机仍在持续，迫切需要解决方案来提高科学研究的质量。关于 p 值及其滥用的讨论尤其活跃。

那怎么办呢？麦克肖恩等人。建议，科学界应该摆脱 p 值，或者至少引入一个远离任何固定阈值的更连续的观点，并将其与试图判断实验结果的许多其他标准平等对待。

科学应该减少它在发表过程中的权力，只发表 p 值阈值为 0.05 的论文和报告结果。许多科学家最近站出来反对统计学意义(见这篇自然文章)，看起来一个范式转变是应该的。然而，如果在基础统计学课程中更广泛地教授对统计重要性的批判性观点，这种转变就不会发生。

这并没有让我们从对证据采取整体观点的麻烦中解脱出来，这种观点需要根据实验和领域的需要手工定制。根据 p 值高于或低于阈值这一简单事实，用二元陈述得出“有影响”或“无影响”的结论，这是一种危险的倾向。

但这需要时间，而学术界的政治也助长了这一问题。例如，作为第一作者发表出版物的压力不鼓励汇集数据:最好是“发现”并发表两个有噪音的结果，而不是将数据集与竞争对手结合起来，以便更好地处理噪音并分享一无所获的可疑名声。

问题是:统计学思维对做好科学研究至关重要，但统计学很难，做好科学研究也很难，尤其是在嘈杂和难以控制的环境中。p 值是一个诱人的出路。我们的大脑喜欢将不确定性转化为确定性(正如我在关于贝叶斯大脑假说的文章中所探讨的那样)，但这总是冒着将偏见引入我们思维的风险，并且不应该成为 【不确定性洗钱】 的理由，正如格尔曼漂亮地指出的。

紧紧抓住统计意义不放，并在此基础上将证据一分为二，这损害了许多科学的质量，最终损害了社会对科学的信任以及他们从中看到的价值。

所以是时候放手了。

蚁群优化算法简介

原文：https://towardsdatascience.com/the-inspiration-of-an-ant-colony-optimization-f377568ea03f?source=collection_archive---------7-----------------------

寻找最佳路径的概率技术

照片由马克西姆·舒托夫在 Unsplash 上拍摄

优化问题在科学和工业领域都非常重要。这些优化问题的一些实际例子是时间表调度、护理时间分配调度、火车调度、容量规划、旅行推销员问题、车辆路线安排问题、组车间调度问题、投资组合优化等。为此开发了许多优化算法。蚁群优化就是其中之一。蚁群优化是一种寻找最优路径的概率技术。在计算机科学和研究中，蚁群优化算法被用于解决不同的计算问题。

蚁群算法是由 Marco Dorigo 在 90 年代的博士论文中首次提出的。该算法是基于蚂蚁的觅食行为引入的，用于寻找蚁群和源食物之间的路径。最初，它被用来解决众所周知的旅行推销员问题。后来，它被用于解决不同的困难的优化问题。

蚂蚁是群居昆虫。他们生活在殖民地。蚂蚁的行为受寻找食物的目标控制。在寻找的时候，蚂蚁在它们的蚁群中游荡。一只蚂蚁反复从一个地方跳到另一个地方寻找食物。在移动时，它会在地面上沉积一种叫做信息素的有机化合物。蚂蚁通过信息素路径相互交流。当一只蚂蚁找到一定量的食物时，它会尽可能多的携带。当返回时，它根据食物的数量和质量在路径上存放信息素。蚂蚁能闻到信息素。因此，其他蚂蚁可以闻到气味并沿着这条路走。信息素水平越高，选择该路径的概率就越高，沿着该路径行进的蚂蚁越多，该路径上的信息素量也会增加。

让我们来看一个例子。让我们考虑从蚁群有两条路径到达食物。起初，地面上没有信息素。所以，选择这两条路的概率是相等的，也就是 50%。让我们考虑两只蚂蚁选择两条不同的路径到达食物，因为选择这些路径的概率是一半对一半。

这两条路径的距离不同。沿着较短路径行进的蚂蚁会比其他蚂蚁更早到达食物。

找到食物后，它会自己携带一些食物，返回蚁群。当它追踪返回的路径时，它在地面上沉积信息素。走捷径的蚂蚁会更早到达蚁群。

当第三只蚂蚁要出去寻找食物时，它会根据地面上的信息素水平选择距离较短的路径。由于较短的路径比较长的路径具有更多的信息素，第三只蚂蚁将沿着具有更多信息素的路径前进。

当沿着更长路径的蚂蚁返回蚁群时，更多的蚂蚁已经沿着信息素水平更高的路径前进。然后，当另一只蚂蚁试图从蚁群到达目的地(食物)时，它会发现每条路径都具有相同的信息素水平。所以，它随机选择一个。让我们考虑选择上面的一个(在下面的图片中)

反复重复这一过程，一段时间后，较短的路径比其他路径具有更多的信息素水平，并有更高的概率遵循该路径，所有蚂蚁下一次将遵循较短的路径。

为了用蚁群算法解决不同的问题，提出了三种不同版本的蚂蚁系统:

蚂蚁密度 & 蚂蚁数量:信息素在蚂蚁从一个位置到另一个位置的每次移动中更新。

蚂蚁周期:信息素在所有蚂蚁完成旅行后更新。

让我们看看应用蚁群优化算法的伪代码。制造了一种人工蚂蚁来寻找最优解。在解决问题的第一步，每只蚂蚁产生一个解决方案。第二步，比较不同蚂蚁找到的路径。第三步，更新路径值或信息素。

**procedure** ACO_MetaHeuristic **is**
    **while** not_termination **do**
        generateSolutions()
        daemonActions()
        pheromoneUpdate()
    **repeat**
end procedure

有许多优化问题，你可以使用蚁群算法寻找最优解。其中一些是:

有容量限制的车辆路径问题
随机车辆路径问题(SVRP)
带装卸货的车辆路径问题(VRPPD)
群组车间调度问题(GSP)
护理时间分配调度问题
置换流水车间问题(PFSP)
频率分配问题
冗余分配问题
旅行推销员问题

让我们来看看蚁群算法的数学术语(典型的 TSP 问题)。

信息素更新

来源:维基百科

等式的左边表示给定边 x，y 上的信息素的量

ρ——信息素蒸发的速率

右边最后一项表示储存的信息素数量。

来源:维基百科

其中 L 是蚂蚁旅行长度的成本，Q 是常数。

参考

蚁群优化:介绍和最新趋势作者克里斯蒂安·布鲁姆
蚁群优化由 Subvesh Raichand 完成
蚁群优化

感谢您的阅读

Intuit 数据科学家访谈

原文：https://towardsdatascience.com/the-intuit-data-scientist-interview-68b40694380?source=collection_archive---------20-----------------------

Intuit 数据科学问题

businesswire.com

Intuit Inc .是全球最大的小型企业和金融科技公司之一。该公司开发和销售商业和财务管理软件解决方案(QuickBooks)、个人税务解决方案(TurboTax)和个人财务解决方案(Mint 和 Credit Karma now)。Intuit 成立于 1983 年，现已成为领先的金融科技公司，在全球超过 9 个国家拥有超过 5000 万客户。

Intuit 每年都会生成大量的客户数据，将他们所有的产品联系在一起。作为一家数据驱动的公司，数据科学是一切的核心，Intuit 多年来一直在高级分析和机器学习工具中利用数据科学来改善客户的财务生活。

Intuit 的数据科学职位

Intuit 的数据科学家角色因不同团队而异，每个团队中数据科学家的具体角色在很大程度上取决于该团队的需求。从小企业到机器学习未来等团队，Intuit 的数据科学家团队分析数据，并部署 ML 和 AI 模型来解决业务相关问题。一般来说，Intuits 的数据科学范围从商业分析和数据工程，使用的工具可能从基本分析到机器学习和深度学习。

所需技能

Intuit 的首选数据科学招聘要求可能会因特定团队和小组而异，但一般来说，只会聘用在数据科学岗位上至少工作了 3 年(高级职位为 5 年以上)的有才华的合格申请人。

招聘的其他基本要求包括:

统计学、应用数学、运筹学、计算机科学、物理学、工程学或相关领域的学士、硕士或博士学位，或同等经验。
熟悉数据科学工具和框架(即 Python、Scikit、NLTK、Numpy、Pandas、TensorFlow、Keras、R、Spark)。
1 至 3 年以上(高级 5 年以上)通用编程语言(如 Python、C、Java 等)经验。).
实验设计和多元 ab 测试等领域的专业知识。
良好的人际关系和沟通技巧，以便有效地为技术团队做出贡献，并向各种技术和业务人员进行演示。

什么样的数据科学角色？

Intuits 的数据科学职位分布在广泛的团队中。从表面上看，Intuit 的数据科学家是使用高级分析工具、机器学习、NLP 和 AI 算法来提供业务影响建议的人。然而，具体角色可能从嵌入团队的产品特定分析团队到机器学习工程实施。根据分配到的组，Intuit 的数据科学家或机器学习工程师的职能可能包括:

风险研究&智能:在 6000 万消费者和小型企业的集体财务数据基础上，构建算法和应用程序并制作原型，以提高安全性和反欺诈能力
智能货币服务:利用数据挖掘和机器学习技术来管理支付和工资中的信用和欺诈风险。
小型企业数据科学团队:使用行业领先的分析工具和技术来推动小型企业的用户增长和保留。
核心数据科学团队:开发、设计并集成 ML 模型到产品中。为所有内部团队，如工程、人力资源、财务&法律等，合作并建立人工智能解决方案。
客户成功数据团队:从客户成功数据中提取洞察，并将其应用于所有 intuits 产品(TurboTax、QuickBooks、Mint 等)。).

面试流程

Intuit 的面试流程从招聘人员的第一个电话开始，然后是过去相关项目的视频技术面试和带回家的挑战。完成初始阶段后，将安排一次现场访谈，其中包括与各种团队成员、技术经理和产品经理的四次 45 分钟长的访谈。

初始屏幕

最初的面试是与人力资源或招聘人员的电话面试，以简历为基础。这次面试的目的是评估你的技能和过去的项目，看看你是否非常适合你申请的团队。此筛选中的问题是基于简历的标准问题。

技术屏幕

Intuit 的技术屏幕在招聘人员屏幕之后。这要么通过外部面试服务机构 Karat 完成，要么通过 Intuit 招聘经理完成。面试将包括分别测试 SQL 和 Python 的分析和编码技能。期待面试查询本次面试中等水平问题。

试试下面的中等水平面试询问问题这里:

假设您在一家银行工作，该银行希望建立一个模型来检测平台上的欺诈行为。

该银行还希望实施一项短信服务，当模型检测到欺诈性交易时，该服务将向客户发送短信，以便客户通过短信回复来批准或拒绝交易。

我们将如何构建这个模型？

面试长达一个小时，这是恰当的表现出明确的技能倾向。面试官也会检查你过去的项目，以了解你过去的经历。真正确定你的简历，以及如何深入谈论你的项目，以及它们与应用机器学习的关系。

带回家的挑战

Intuit 在现场面试前会给出一个数据挑战，申请人需要在收到带回家的数据后的四个小时内完成。带回家的挑战包括一个关于 TurboTax 的标准 Intuit 案例研究数据集。你必须在 SQL 中运行分析，并在数据集上处理机器学习问题。

数据科学实践，查看 面试查询的 带回家挑战 。

现场面试

Intuit 的现场面试由 4 轮面试组成(两轮技术面试、一轮数据挑战演示和一轮行为面试)。本次面试中的技术问题主要是开放式的，跨越基本统计概念(A/B 测试)、建模、实验设计、SQL 和机器学习算法。

一般来说，Intuit 的现场面试是这样的:

数据挑战演示:在这一轮中，候选人需要创建所给数据的仪表板，并向面试官条理清晰地解释所做的分析类型以及数据的挖掘程度。这将需要在真实环境中编码，并在讨论你正在做的事情时分析数据。
技术面试与一位技术经理谈论过去的经验和机器学习概念。
与一位数据科学家进行技术访谈，内容涉及 SQL 编码、算法以及概率和统计问题。
产品经理和高管的行为面试。与其他大型科技公司的面试不同，Intuit 的行为面试将关注他们的文化和价值观，以及候选人与非技术人员(包括高层)的关系。

最后的提示

Intuit 的数据科学家面试涵盖了广泛的分析概念、统计建模、实验设计和机器学习算法。事先准备好如何将这些数据科学概念应用于与 Intuit 相关的业务问题。
在白板上练习编码，并在现有环境中分析数据。
Intuit 有很好的工作文化，了解他们的文化和核心价值观会在行为面试中帮助你。

Intuit 数据科学面试问题

增压是如何工作的？
比方说，你可以玩一次抛硬币猜谜游戏，也可以玩三选二游戏。获胜的最佳策略是什么？
给定一个无法存储的长数组，如何求中位数？
线性回归有什么局限性？
描述随机森林是如何在引擎盖下工作的。
实现一个迭代器函数，它将三个迭代器作为输入，并对它们进行排序。
你会给一款车型添加哪些尚不存在的功能？
如果有一个 100%的用户都使用的功能，它会是一个好功能吗？
什么是不平衡数据集的充分重新平衡？

更多数据科学面试练习题请上 面试查询 。

自动编码器和变体背后的直觉和应用

原文：https://towardsdatascience.com/the-intuition-and-applications-behind-autoencoders-variants-4afcd45559d4?source=collection_archive---------52-----------------------

来源: Unsplash

无监督深度学习的美妙之处

神经网络从根本上受到监督——它们接受一组输入，执行一系列复杂的矩阵运算，并返回一组输出。随着世界越来越多地被无监督数据填充，简单和标准的无监督算法不再能够满足需求。我们需要以某种方式将神经网络的强大功能应用于无人监管的数据。

幸运的是，自我监督学习的创造性应用——从自然无监督的数据中人工创建标签，如倾斜图像和训练网络来确定旋转的程度——已经成为无监督深度学习应用的一个巨大组成部分。

自动编码器被训练来重新创建输入；换句话说， y 标签就是 x 输入。因为自动编码器被构建为具有瓶颈(网络的中间部分)，其神经元比输入/输出少，所以网络必须找到一种方法来压缩信息(编码)，这需要重建(解码)。

由作者创建

这些类型的模型可以有多个隐藏层，用于携带和转换压缩信息。因为这些节点中的空间有限，所以它们通常被称为“潜在表示”。

“潜伏”一词来自拉丁语，意思是“隐藏起来”。潜在变量和表示就是这样——它们携带间接的编码信息，可以解码并在以后使用。人们可以将迁移学习视为利用潜在变量:尽管像 ImageNet 上的 Inception 这样的预训练模型可能不会直接在数据集上表现良好，但它已经建立了关于图像识别动态的某些规则和知识，这使得进一步的训练更加容易。

创建自动编码器时，有几个组件需要注意:

损失函数非常重要，它量化了“重建损失”。由于这是一个回归问题，损失函数通常是二进制交叉熵(对于二进制输入值)或均方误差。
确定代码大小—这是第一个隐藏层(紧随输入层的层)中神经元的数量。这可以说是最重要的一层，因为它直接决定了有多少信息将通过该层的其余部分传递。
自动编码器的性能高度依赖于架构。平衡表示大小，可以通过隐藏层传递的信息量；和要素重要性，确保隐藏层足够紧凑，以便网络需要确定重要的要素。
对不同类型的数据使用不同的图层。例如，可以使用一维卷积层来处理序列。自动编码器与神经网络相同，只是在架构上有瓶颈。

普通自动编码器的一个应用是异常检测。例如，我可以构建一个使用 1-d conv 的一维卷积自动编码器。层(有架构瓶颈)并训练它重建输入序列。

在经过相当长时间的训练后，自动编码器学习序列的潜在表示——它能够拾取重要的区别性方面(序列中的哪些部分对精确重建更有价值),并能够假设整个序列中通用的某些特征。

当它对一个测试序列进行预测时，重建损失决定了它与先前序列的相似程度。如果自动编码器可以正确地重建序列，那么它的基本结构与以前看到的数据非常相似。另一方面，如果网络不能很好地重建输入，它就不遵守已知的模式。

自动编码器的另一个应用是图像去噪。通过添加噪声，图像被人为破坏，并被送入自动编码器，该编码器试图复制原始的未被破坏的图像。自动编码器最擅长去噪，因为网络只学习让图像的结构元素——而不是无用的噪声——通过瓶颈。

由作者创建

稀疏自动编码器类似于自动编码器，但是隐藏层的节点数至少与输入层和输出层的节点数相同(如果不是更多的话)。但是，L1 正则化用于隐藏层，这导致不必要的节点被停用。为了获得为什么会发生这种情况的直觉，阅读这个。

由作者创建。

因此，在某种意义上，架构是由“模型”选择的。然而，让模型自己选择并不总是好的；一般来说，L1 正则化倾向于消除比可能需要的更多的神经元。

请记住，正则化的目标不是找到性能最佳的架构，而是主要为了减少参数的数量，甚至以牺牲一些性能为代价。然而，在需要稀疏架构的情况下，稀疏自动编码器是一个不错的选择。

可变自动编码器，通常缩写为 VAEs，是自动编码器生成内容的扩展。正如之前在异常检测中所看到的，自动编码器擅长的一件事是拾取模式，本质上是通过将输入映射到一个缩减的潜在空间。这并没有带来多少创意。

任何生成模型的一个组成部分就是随机性。变分自动编码器将输入映射到多维高斯分布，而不是潜在空间中的点。然后，解码器从该分布中随机采样一个矢量以产生输出。

来源: Unite AI 。图片免费分享。

变分自动编码器和自动编码器之间的主要区别在于 vae 基本上是概率性的。他们建立由概率分布形成的一般规则来解释输入并产生输出。

当 VAEs 编码器一个输入时，它被映射到一个分布；因此，这里有随机性和“创造性”的空间。另一方面，必须识别复杂模式的自动编码器必须确定性地接近潜在空间，以获得良好的结果。

最后，自动编码器实际上更多的是一个概念，而不是任何一种算法。这是一个以瓶颈和重建为特征的架构决策，其驱动力是迫使模型将信息压缩到潜在空间并对其进行解释。编码器-解码器的思维模式可以进一步以创造性的方式应用于几个监督问题，这已经取得了相当大的成功。

摘要

自动编码器是深度学习对无监督问题的创造性应用；对快速增长的未标记数据量的一个重要回答。
自动编码器的特点是输入与输出大小相同，并且存在体系结构瓶颈。它们将压缩信息存储在潜在空间中，并被训练以最小化重建损失。
标准自动编码器可用于异常检测或图像去噪(当用卷积层替代时)。
稀疏自动编码器具有与输入和输出神经元数量相同的隐藏层，但是使用 L1 正则化来消除不必要的神经元。在某种意义上，网络“选择”在最终架构中保留哪些和多少神经元。
变分自动编码器用于生成。因此，它们将输入表示为概率分布，而不是潜在空间中确定性的点。解码器从这些分布中采样，以产生随机(因此，创造性)输出。

感谢阅读！

[## 无需任何训练即可获得顶级神经网络性能

我们对神经网络的了解比我们想象的要少

towardsdatascience.com](/obtaining-top-neural-network-performance-without-any-training-5af0af464c59)

梯度增强背后的直觉& XGBoost

原文：https://towardsdatascience.com/the-intuition-behind-gradient-boosting-xgboost-6d5eac844920?source=collection_archive---------24-----------------------

定性理解梯度增强和 XGBoost

在这篇文章中，我们提出了一个非常有影响力和强大的算法，叫做极限梯度提升或XGBoost 【1】。它是梯度推进机器的实现，利用各种优化来非常快速地训练强大的预测模型。

因此，我们将首先解释 渐变增强【2】，以将读者置于上下文中。然后，我们定性地浏览 XGBoost 的工作方式，必要时绘制与梯度增强概念的连接。最后，我们谈谈各种实施的优化及其背后的想法。

在写这篇文章时，我把尽可能定性作为自己的一个目标，只有在有助于解释的情况下才引入方程。目标是让读者直观地了解渐变增强和 XGBoost 是如何工作的。

梯度推进

梯度推进包括建立弱学习者的集合。它基于两个关键的见解。这是洞察力一。

如果我们能解释模型的错误，我们就能改善模型的性能。

让我们用一个简单的例子来支持这个观点。假设我们有一个回归模型，它预测实际结果为 1 的测试用例为 3。如果我们知道误差(在给定示例中为 2)，我们可以通过从原始预测 3 中减去误差 2 来微调预测，并获得更准确的预测 1。这就引出了一个问题，“对于任何给定的输入，我们如何知道模型产生的误差？”，这就引出了我们的第二个洞见。

我们可以训练一个新的预测器来预测原始模型产生的误差。

现在，给定任何预测模型，我们可以首先通过训练新的预测器来预测其当前误差，从而提高其准确性。然后，形成新的改进模型，其输出是原始预测的微调版本。改进的模型需要原始预测器和误差预测器的输出，现在被认为是两个预测器的集合。在梯度推进中，这被重复任意多次，以不断提高模型的准确性。这个重复的过程形成了梯度推进的症结。

一群学习能力差的学生

当训练一个新的误差预测模型来预测模型的当前误差时，我们正则化其复杂性以防止 过拟合 。当预测原始模型的‘误差’时，该正则化模型将具有‘误差’。参考上面的例子，它可能不一定预测 2。由于新的改进模型的预测依赖于新的误差预测模型的预测，它也将有误差，尽管比以前低。

为了减轻这种情况，我们采取了两种措施。首先，我们通过对其输出应用小权重 η (通常在 0 到 0.1 之间)来减少对任何单个误差预测器的依赖或信任。然后，不是在 1 次改进迭代后停止，而是多次重复该过程，为新形成的改进模型学习新的误差预测器，直到精度或误差令人满意。这可以用下面的等式来总结，其中 x 是一个输入。

i*mproved_model(x) = current_model(x) + η × error_prediction_model(x)* *current_model(x) = improved_model(x)* *Repeat above 2 steps till satisfactory*

通常，误差预测模型预测负梯度，因此，我们使用加法而不是减法。在每次迭代之后，将学习一个新的预测器来解释先前模型的误差，并将其添加到集合中。要执行的迭代次数和 η 是超参数。

如果你的渐变增强的想法和这个图相似，你就在正确的轨道上。作者图片

“梯度”推进

在结束之前，我们先探讨一下为什么称之为“渐变”增强。原来，我们上面提到的误差是损失函数相对于模型预测的梯度，这可推广到任何可微分的损失函数。例如，当我们对平方误差损失函数0.5(y _ true y _ pred)求微分时，我们得到y _ pred y _ true，它恰好是我们训练新误差预测器的“误差”。类似地，其他类型的预测问题(例如分类问题)的误差可以通过梯度来表示。因为我们预测的是梯度，我们称之为梯度推进。

从数学上讲，损失函数的导数∂loss/∂pred 给出了调整预测以使损失最大化的方向。在梯度推进中，我们以相反的方向(负梯度)预测和调整我们的预测。这达到了相反的效果(使损失最小化)。因为模型的损失与其性能和准确性成反比，所以这样做可以提高其性能。

凭直觉，我们正在朝着提高模型整体性能的方向逐步改变我们的模型预测。

XGBoost

XGBoost 是一种梯度增强机器，它使用梯度增强树(gbtree)作为误差预测器。它从一个简单的预测器开始，该预测器预测一个任意的数(通常为 0.5)，而不考虑输入。不用说，预测器具有非常高误差率。然后，应用上述想法的，直到误差最小。在 XGBoost 中，误差预测模型的训练不是通过在(特征，误差)对上平凡地优化预测器来完成的。接下来，我们来看看它们是如何构建的。

梯度推进树

在 XGBoost 中，学习一个 gbtree，使得新模型的整体损失最小化，同时记住不要过度拟合该模型。请注意，在本节中，我们将讨论上述想法的 1 次迭代。为了更好地理解它，让我们从最简单的可能的树开始，它不进行分割，并且预测相同的值，而不管输入是什么。这个树非常简单，独立于输入，并且绝对是欠满足的。尽管如此，它仍然可以帮助减少损失。提到的问题可以用下面的等式来表示。

由最后一项表示的所应用的 L2 正则化 已经通过实验证明在防止过拟合方面是有效的。虽然在这个已经不足的模型中没有用，但随着我们增加树的复杂性，它将变得有意义。像这样的问题，可以通过对表达式相对于 o 求导，设置导数为 0，然后找到对应的 o 来解决。不幸的是，我们上面看到的表达式很难区分。为了解决这个问题，我们使用 二次近似 用更简单的术语来近似这个表达式。

这个简化的表达式很容易求导，在导数设置为 0 后，我们可以求解并得到 o 。原来，就是下面的 o。

推导起来并不难。你可以把推导当作练习。

作者图片

给定场景的一个示例:我们找到一个单一的最佳调整 o ,我们可以将其应用于数据集中的任何样本，以最小化总体损失。

请记住，现在，给定一个模型 f 和一组样本，我们可以找到最佳改进我们模型的单个调整 o 。请注意，o 也可以代入等式计算损失值。本节的剩余部分将讨论我们如何通过增加简单模型的复杂性(增长树)来进一步改进(减少损失)。总体思路是这样的。

通过巧妙地将样本分成子组，然后为每个子组找到 oo(使用上面的方法)，可以进一步提高模型的性能(损失可以更低)。

可以使用分割条件来分割样本。例如，如果分割条件是“特征 x 小于 10”，特征 x 的值小于 10 的样本将进入一个子组，其余的样本进入另一个组。如果需要，每个子组可以进一步迭代划分。这些分裂将原始特征空间分成更小的子空间，并且每个子空间中的样本形成一个子组。对于每个子组，其最优的o、和损耗可以使用上述技术求解。总损失， Los s，是每个子组(决策树中的叶子)损失的总和。

作者图片

对所讨论的概念的说明:在这个例子中，特征空间被分成 3 段，具有分裂 B < 2 和 A < 2.5 。然后，使用所讨论的技术计算每个子组的最佳 o 。

在每个组或子组中，是否拆分以及如果拆分，使用哪个拆分的决定取决于拆分是否可以减少该组的损失以及每次拆分可以减少多少损失。我们总是选择使损失最小的分割，如果损失不能减少，我们就不分割。

让我们直观地描述一下正在发生的事情。当前模型在特征空间的不同部分具有不同程度的误差。它对一些样本预测过高，对另一些样本预测过低，预测的幅度各不相同。通过分割特征空间，使得每个子组中的误差相似、更具体，从而可以为每个子组计算更好的调整，增强整体模型性能。

过度拟合

为了防止过度配合，实施了几项措施。我们在这里讨论两个重要的问题。首先，用户可以设定树木生长的最大高度。这有助于限制可以形成的子群(叶子)的数量。第二，分割造成的损失减少必须超过用户为 XGBoost 设置的某个阈值，XGBoost 才会允许。这通过附加的正则化项γT 被建模到损失函数中，其中 T 是叶子的数量。为了防止混淆，前面省略了这一点。

最佳化

下面是 XGBoost 用来提高训练速度和准确性的有趣优化。

用于寻找近似最佳分割的加权分位数草图—在找到最佳分割之前，我们为每个特征形成一个直方图。直方图仓的边界然后被用作寻找最佳分割的候选点。在加权分位数草图中，根据数据点当前预测的“置信度”为其分配权重，构建直方图，使得每个条柱具有大致相同的总权重(与传统分位数草图中相同数量的点相反)。因此，在模型表现不佳的区域将存在更多的候选点，从而进行更详细的搜索。

并行化加快树构建过程——当找到最佳分割时，候选点的尝试可以在特征/列级别并行化。例如，内核 1 可以为特征 A 找到最佳分割点及其相应的损耗，而内核 2 可以为特征 B 做同样的事情。最后，我们比较损失，并使用最好的一个作为分割点。

稀疏感知的分割查找用于处理稀疏数据——XGBoost 通过在树中的每个节点为其指定一个默认方向来处理这种稀疏性，这种稀疏性可能是由单热编码的缺失值或频繁的零条目造成的。默认方向的选择基于哪个更能减少损失。除此之外，XGBoost 确保在查找拆分过程中不会迭代稀疏数据，从而防止不必要的计算。

硬件优化 — XGBoost 将常用的 gs 和 hs 存储在缓存中，最大限度降低数据访问成本。当需要使用磁盘时(由于数据不适合内存)，数据会在存储前进行压缩，以一些压缩计算为代价降低 IO 成本。如果存在多个磁盘，可以对数据进行分片以增加磁盘读取吞吐量。

列和行子采样 —为了减少训练时间，XGBoost 提供了仅使用原始数据行的随机采样子集来训练每棵树的选项，其中该子集的大小由用户确定。这同样适用于数据集的列/特征。除了节省训练时间之外，在训练期间对列进行子采样还具有对树进行去相关的效果，这可以减少过拟合并提高模型性能。这个想法也用在了随机森林算法中。

尾注和参考文献

干杯，我们已经到达终点。希望这对你有所帮助。随时给我发电子邮件(liangweitan300895@gmail.com)寻求反馈(我会喜欢他们)，问题，甚至聊天。

[1] T. Chen 和 C. Guestrin，“XGBoost:一种可扩展的树提升系统” (2016)，编号 arXiv:1603.02754 [cs .LG]
[2] J. H .弗里德曼，“随机梯度推进” (1999)

马尔可夫链背后的直觉

原文：https://towardsdatascience.com/the-intuition-behind-markov-chains-713e6ec6ce92?source=collection_archive---------37-----------------------

用尽可能少的数学或统计数据简单介绍马尔可夫链是如何工作的。

大多数对马尔可夫链的解释都是直接进入数学和统计学领域，而没有提供任何直观的概念。教科书和讲座经常强调精确性和效率，而不是实际的可理解性。在本文中，我将尝试使用一个简单的例子和尽可能少的数学或统计来提供马尔可夫链背后的基本直觉。这篇文章并不意味着全面，而是旨在补充你在教科书和其他地方看到的更正式的解释。

什么是马尔可夫链？

马尔可夫链是一系列事件，其中某件事情发生的概率只取决于它之前发生的事情。对于音乐人来说，这就像你下一张专辑的成功仅仅取决于你最新专辑的成功。在遥远的过去发生了什么都不重要。

让我们考虑 4 个时间段。在马尔可夫链中，时间 4 发生的任何事情都只取决于时间 3 的情况。时间 1 或时间 2 中发生的任何事情对时间 4 来说都无关紧要。

在马尔可夫链中，时间 4 的情况只取决于时间 3 的情况。时间 1 和时间 2 中发生的任何事情对时间 4 中发生的事情没有直接影响。

为什么马尔可夫链很重要？

我们应该关心马氏链的原因有两个。

首先，现实世界中的许多事物的行为有点像马尔可夫链。我们可以想出一些例子，说明近期的未来主要取决于最近的过去，而不是全部的历史。

天气是一个常见的例子。如果今天下雨，那么明天很有可能会下雨。明天的天气可能会像今天一样。一个月前下不下雨，其实并不影响明天的天气预报。这不是马尔可夫链的完美例子，因为我们有季节之类的东西，但它非常适合。

其次，马尔可夫链允许我们将复杂的问题简化为一组简单的步骤，这些步骤可以很容易地在计算机上编程和运行。当我们让一台计算机数千次执行这些相同的步骤时，我们就能得出非常接近问题的答案，否则我们就无法解决这些问题。稍后，我将谈到马尔可夫链如何允许我们使用一套称为马尔可夫链蒙特卡罗方法的机器学习技术。

那么马尔可夫链是如何工作的呢？浏览一个例子很有帮助。

一个例子:iPhone 与 Android

再来想想智能手机用户，我们可以把智能手机用户分为两种:iPhone 用户和 Android 用户。这些是我们可能的状态。成为 iPhone 用户是一种状态。作为安卓用户是另一种状态。所有的可能性就是 T2 状态空间 T3。在这种情况下，状态空间只由两种可能的状态组成:作为 iPhone 用户或作为 Android 用户。

假设每年，每个人都买一部新的智能手机。你可以坚持使用你目前的智能手机或交换机。比方说，用户倾向于坚持使用当前类型的智能手机，但可能会偶尔更换。

因此，如果你目前使用 iPhone，你购买的下一部手机很可能是另一部 iPhone。假设这个概率是 80%。但也有可能你会转向安卓系统。假设这个切换的概率是 20%。

如果你目前使用安卓手机，你可能会再次购买安卓手机——比方说有 70%的可能性——但也有可能换成 iPhone——比方说有 30%的可能性。

明年获得 iPhone 或 Android 手机的可能性取决于你今年是 iPhone 用户还是 Android 用户

每一种继续使用当前类型的智能手机或转换的概率都被称为转换概率。转移概率是“条件概率”，即一年内成为 iPhone 或 Android 用户的概率取决于(“取决于”)你前一年是 iPhone 还是 Android 用户。

所有这些转移概率放在一起形成了一个转移矩阵。一个转移矩阵可以让我们绘制出每一个可能的未来状态的概率——无论你明年是 iPhone 用户还是 Android 用户——对于每一个可能的当前状态——无论你今年是 iPhone 用户还是 Android 用户。

我们不仅可以思考今年和明年会发生什么，还可以思考后年会发生什么。

如果你在第一年开始使用 iPhone，这些是你在第二年和第三年成为 iPhone 用户或 Android 用户的概率

如果我们在第一年开始使用 iPhone，那么在第二年，我们有 80%的机会再次拥有 iPhone，20%的机会拥有 Android 手机。我们可以在第三年做同样的事情，但是这次我们将转移概率应用到第二年的情况中。如果我们在第二年有了 iPhone，那么在第三年，我们有 80%的机会拥有 iPhone，20%的机会拥有 Android 手机。但是，如果我们在第二年有一部安卓手机，那么在第三年，我们有 30%的机会拥有 iPhone，有 70%的机会拥有安卓手机。

我们可以在许多智能手机用户的群体层面上思考这个问题。假设我们的用户一开始是 90%的 iPhone 用户和 10%的 Android 用户的混合体。这被称为初始分配。

如果我们将初始分布应用于 100 名智能手机用户，这意味着在第一年，我们将从 90 名 iPhone 用户和 10 名 Android 用户开始。在第二年，一些人会转换，一些人会继续使用现有的智能手机平台。有多少人会跳槽，有多少人会留下来，这取决于我们之前设定的转移概率。

在 90 名 iPhone 用户中:

其中 80%的人会继续使用 iPhone，这意味着 72 名 iPhone 用户
20%的人会转用安卓系统，也就是说有 18 个安卓用户

10 个原始 Android 用户中:

70%的人会继续使用安卓系统，也就是说有 7 个安卓用户
30%的人会转用 iPhone，这意味着 3 个 iPhone 用户

因此，在第 2 年，如果我们将所有这些相加，我们最终会得到:

75 名 iPhone 用户
25 名安卓用户

对于第 3 年，我们将再次应用相同的转移概率，但改为应用于第 2 年。在第二年，我们的 iPhone 用户中有一部分人会在第三年继续使用 iPhone(80%)，而其余的人会转而使用 Android (20%)。在第二年，我们的 Android 用户中有一部分人会在第三年继续使用 Android(70%)，而其余的人会转而使用 iPhone (30%)。对于第 3 年，你是否是第 1 年的 iPhone 用户并不重要。重要的是你在第二年是否是 iPhone 用户。

对于第 4 年和第 5 年以及之后的每一年，我们都会将转移概率应用于前一年智能手机用户的分布。我们可以想做多少年就做多少年。

平稳分布

如果坚持多年，iPhone 用户和 Android 用户的比例最终会收敛到一个稳态均衡。你可以在下面看到，大约 6 年后，我们的用户群最终稳定在大约 60%的 iPhone 用户和 40%的 Android 用户。100 年或 1000 年或 100 万年后，我们的 iPhone 和 Android 用户比例基本保持不变。

当我们观察一个分布在很长一段时间内会发生什么时，我们会发现极限分布。而当我们的极限分布收敛到某个稳定的东西时，我们称之为平稳分布(它也被称为不变分布或平衡分布)。以我们的例子为例，长期来看，iPhone 用户和 Android 用户的比例是 60/40，这是我们的固定分布。

事实证明，从长远来看，iPhone 和 Android 用户的确切比例只取决于我们的转移概率。如果我们改变任何一个转移概率，就会改变我们的稳态分布。例如，如果我们将今年的 iPhone 用户明年继续使用 iPhone 的概率从 80%提高到 90%，那么从长远来看，iPhone 用户和 Android 用户的比例将达到 75/25。这些长期平稳分布可以用线性代数数学地找到。

事实证明，从长远来看，我们的初次分配并不重要。不管我们一开始是 90%的 iPhone 用户和 10%的 Android 用户，还是 50%的 iPhone 用户和 50%的 Android 用户。所需的时间可能会有所不同，但最终我们会达到相同的稳态 60/40 分裂，只要我们的转移概率保持不变。

遍历马尔可夫链

像我们的例子一样，所有的马尔可夫链在长期内都会收敛到一个单一的平稳分布吗？不。事实证明只有一种特殊类型的马尔可夫链叫做遍历马尔可夫链会像这样收敛到一个单一的分布。遍历马氏链是满足两个特殊条件的马氏链:既不可约又非周期。我会解释这些是什么意思。

条件 1:不可约

首先，我们必须能够最终从一个州到达另一个州。我们永远不会永远停留在一种状态或一组状态中。当这为真时，那么马尔可夫链就被称为是不可约的。

对于我们的智能手机例子来说，这是正确的。如果你是 iPhone 用户，你可以在明年或未来某个时候成为 Android 用户。如果你是安卓用户，你可以在明年或未来某个时候成为 iPhone 用户。如果我们以不同的方式设置我们的例子，这样一旦你成为一个 iPhone 用户，你就永远不能切换到拥有一个 Android 手机，那么我们的马尔可夫链将不再是不可约的。

请记住，对于不可约的马尔可夫链，您不需要能够立即到达每个状态。可能需要几个步骤才能达到某个状态。但重要的是，最终你可以通过足够多的步骤达到任何状态。

条件二:非周期性

第二，我们不能陷入定期在同一组状态之间来回循环。换句话说，我们的马尔可夫链一定是非周期的。

首先解释什么是周期马尔可夫链是有帮助的。当我们每隔 2、3 或更长的时间间隔保持在同一状态时，马尔可夫链就是周期性的。对于我们的智能手机的例子，让我们回到只考虑单个用户。而这一次，让我们假设每年你肯定会切换你使用的智能手机类型(所以你切换的概率是 1)。因此，如果你在第一年开始使用 iPhone，那么你将在第二年使用 Android 手机，然后在第三年再次使用 iPhone。

周期马尔可夫链的一个例子。如果我们每年都有 100%的概率换手机，那么我们最终会在奇数年换一部 iPhone，在偶数年换一部 Android 手机。

你可以很快看到，在奇数年，你肯定会有一部 iPhone，在偶数年，你肯定会有一部 Android 手机。在这种情况下，您的马尔可夫链是周期性的，因为您以固定的时间间隔(在这种情况下，每两年一次)在 iPhone 和 Android 手机之间来回循环。

但在我们最初的智能手机例子中，我们有各种各样的转移概率，我们永远不会以这样的规律性在 iPhone 和 Android 之间循环。虽然我们确实在两种可能的状态——iPhone 和 Android——之间来回切换，但我们不会定期这么做。换句话说，并不是每两年或每三年你就会拥有一部 iPhone。你无法预测每隔奇数年或偶数年，或者每隔 3 年或 5 年，你就会拥有一部 iPhone。因为没有基于时间的模式，所以这个马尔可夫链被称为是非周期性的。

当这两个条件都满足时——也就是说，当我们的马尔可夫链既不可约又非周期时——那么我们可以说我们的马尔可夫链是遍历的。如果我们把所有这些放在一起，我们就有了遍历定理，它说任何遍历的马尔可夫链最终都会收敛到一个单一的平稳分布，不管我们的初始分布是什么。换句话说，如果你在许多时间段内运行这些特殊类型的马尔可夫链，不管你是如何开始的，你都会越来越接近某个分布。

我们可以看到，智能手机用户的群体级示例就是如此。由于我们设置转移概率的方式(例如，今年的 iPhone 用户明年有 80%是 iPhone 用户)，我们创建了一个马尔可夫链，它碰巧是遍历的。因为我们的马尔可夫链是遍历的，我们可以应用遍历定理，并提前知道我们最终会收敛到 iPhone 和 Android 用户的某种混合。遍历定理让我们知道这一点，而不必花费多年时间来完成我们的马尔可夫链。

马尔可夫链蒙特卡罗

为什么要关心遍历定理？因为它是一种叫做马尔可夫链蒙特卡罗方法的强大的机器学习技术的基础。马尔可夫链蒙特卡罗方法(通常缩写为 MCMC )涉及在计算机上运行马尔可夫链的模拟，以获得复杂统计问题的答案，这些问题太难甚至不可能正常解决。

遍历定理是使用马尔可夫链蒙特卡罗方法的基础，因为它确保收敛。只要我们在建立我们的马尔可夫链蒙特卡罗模拟时使用遍历马尔可夫链，那么我们就可以确定我们模拟产生的数据点确实会收敛到一个单一的分布。但在另一篇文章中有更多关于马尔可夫链蒙特卡罗方法的内容。

变形金刚背后的直觉——注意力是你所需要的

原文：https://towardsdatascience.com/the-intuition-behind-transformers-attention-is-all-you-need-393b5cfb4ada?source=collection_archive---------14-----------------------

Mor 妮莎在 Unsplash 上拍照

传统的递归神经网络及其变体已经广泛用于自然语言处理问题。近年来，《变形金刚》的表现超过了大多数 RNN 车型。在看变形金刚之前，让我们重温一下递归神经网络，它们是如何工作的，以及它们落后于何处。

递归神经网络(RNN)处理语言翻译和时序数据等序列数据。有不同类型的递归神经网络。

来源维基百科

向量到序列模型——接受向量并返回任意长度的序列。
序列到向量模型—这些模型将序列作为输入，并将向量作为输出返回。例如，这些模型通常用于情感分析问题。
序列到序列模型，正如你现在已经猜到的，它们将一个序列作为输入，输出另一个序列。它们在语言翻译应用程序中很常见。

自然语言处理和 RNNs

说到自然语言处理 rnn，它们在一个 编码器-解码器 架构中工作。

作者图片

编码器将总结输入句子的所有信息，解码器将使用编码器的输出来创建正确的输出。编码器的最终状态传达开始解码的信息。解码器使用先前的状态和输出来计算新的隐藏状态和字。多个 rnn 用于编码器和解码器层。

然而，递归神经网络有其局限性。

首先，它们很慢，事实上，训练非常慢，我们经常不得不使用类似于 的技术来截断训练，及时截断反向传播 。
其次，也是更常见的，rnn 会遇到 消失和 爆炸梯度的问题。当应用于 NLP 问题时，从句子开始的信息会丢失。

长短期记忆(LSTM)

引入长短期记忆(LSTM)网络来解决递归神经网络的这些问题。

它们的工作原理是有一个被称为记忆单元的隐藏状态，允许信息从前一个单元流向当前单元，同时跳过当前单元的大部分处理。这使得以前哑的神经元现在有了记忆，可以用来在需要时保留信息。这反过来允许模型在更长的序列中保留信息。

来源维基百科

然而，虽然常规的递归神经网络的训练速度很慢，但是 LSTMs 的训练速度甚至更慢。其次，由于序列的每个字都被单独传递到网络，并且处理仍然在网络内顺序发生，所以这种架构没有利用当今 GPU 的并行处理。

注意机制与 RNNs

一个 注意机制 被添加到它们中，以解决传统 rnn 和 LSTMs 的一些限制。注意机制通过使用全局向量来工作，上下文向量包含编码器所有隐藏状态的加权和。

来源巴赫达瑙等人。

上下文向量表示解码器的当前状态如何与全局输入序列相关。虽然注意机制解决了 rnn 的一些固有缺陷，但我们仍然是单独输入单词并顺序处理它们，这意味着这些架构仍然不能让我们利用当今硬件提供的并行处理。

注意力是你所需要的——变形金刚

我们可以完全取消注册护士吗？输入变压器。2017 年，transformer 架构在标题为的文章中进行了介绍。事实证明，注意力是你解决最复杂的自然语言处理任务所需要的全部。让我们来看看。

来源瓦斯瓦尼等人。

变压器架构使用一个编码器和一个解码器，但只使用注意力，没有 RNNs。

与之前架构的主要区别在于，编码器的 输入是整个句子 ，而不是像 RNNs 那样一次输入一个单词。类似地，解码器的 输入也是整个句子(右移) 。我们同时传递句子中的所有单词，并同时确定单词嵌入。

让我们打破这种架构，深入研究各个组件，从 编码器模块 开始。

我们从序列中所有单词嵌入的网络输入开始。单词嵌入是单词的向量表示，使得具有相似意思的单词更接近；具体来说，相关单词在嵌入空间内彼此更接近。

来源瓦斯瓦尼等人。

然而，在语言中，一个词在句子中的位置可以改变它的意思。例如，在句子“之间，猫是一种动物。你像动物一样吃东西。”字动物的位置改变了它的意思。我们在做 CNN 和 RNNs 的时候，保留了这个词的位置。然而，在 transformer 模型中，我们需要一个显式的 位置编码 层来在嵌入完成后保留单词在序列中的位置。

来源瓦斯瓦尼等人。

该论文提到了不同频率的正弦和余弦函数的使用。

一旦我们有了单词嵌入和位置编码，我们就可以将它传递给 多头注意力模块。

来源:瓦斯瓦尼等人。

多头关注块重点关注 自我关注；即序列中的每个单词如何与同一序列中的其他单词相关联。自我关注由关注块中产生的关注向量来表示。这个想法是为了捕捉句子中单词之间的上下文关系。

这是如何工作的？我们通过计算缩放后的点积来找到两个向量之间的关系。

数学上，点积给出了两个向量之间的相似性。总之，如果点积为 1(或负相关时为-1)，则两个向量密切相关，如果点积为 0，则两个向量不相关。

我们的 transformer 模型使用一个 比例点积 函数来计算关注度。

来源瓦斯瓦尼等人。

转换器使用的注意函数接受三个输入:Q(查询)、K(键)、V(值)，下面的等式用于计算权重。

注意力块被称为多头注意力块，因为我们对每个单词使用多个注意力向量，然后进行加权平均。

来源瓦斯瓦尼等人。

每个注意力向量都是相互独立的，这允许我们使用并行化。还记得 GPU 吗？

接下来，我们有一个 前馈网络 (FFN)。这是一个应用于每个注意力向量的常规前馈网络。应用 FFN，使得输出可以被下一个编码器块或解码器块使用。

来源瓦斯瓦尼等人。

每个 FFN 由两个密集的线性层组成，其间有 ReLU 激活。

关于 FFN 层的几个关键点

FFN 分别应用于每个位置，并且完全相同。
每个子层的 FFN 不同。

最后，我们有一个 添加&归一化层 应用在每个关注块和每个 FFN 块之后。FFN 层对输出进行归一化，并在通过剩余连接进行反向传播的过程中帮助学习。

来源瓦斯瓦尼等人。

解码器模块 的工作方式类似。我们传入在嵌入中编码的单词的目标序列以及位置编码。

解码器的自关注模块为目标序列生成关注向量，以找出目标序列中的每个单词与序列中的其他单词的相关程度。解码器的第一个关注块被称为 掩蔽关注块 ，这是因为我们对该块应用了掩蔽层。这确保了在为目标序列生成注意力向量时，我们可以使用输入序列中的所有单词，但只能使用目标序列的前一个单词。

来源:瓦斯瓦尼等人。

解码器具有 额外的关注块 ，其从输入序列和目标序列中获取嵌入，以确定输入序列中的每个单词如何与目标序列中的每个单词相关。

来源瓦斯瓦尼等人。

第二关注层的输出被发送到 FFN 层，该层类似于具有类似功能的编码器块的 FFN 层。

最后，在最后，我们有一个线性层，这只是另一个 FFN 和一个 softmax 函数来获得所有接下来的单词的概率分布，因此，下一个预测的单词具有最高的概率得分。

来源瓦斯瓦尼等人。

这个过程被执行多次，直到为序列生成句子结束标记。

这篇文章给了你 NLP 转换架构背后的基本直觉。也可以在这里阅读原论文。

如果你想亲手实现变形金刚，TensorFlow 有一个很棒的分步教程。

统计学的直觉——集中趋势

原文：https://towardsdatascience.com/the-intuition-of-statistics-central-tendency-70f01949d61e?source=collection_archive---------35-----------------------

这篇故事/文章将直观地介绍使用 Python 的统计和一些概念的可视化。

但在此之前，我想先介绍一下我们的大脑是如何利用统计学和数学来理解我们生活的现实的。

我们几乎在生活的每个方面都使用统计学。我们发现统计数据可以帮助我们做纯粹的决策，分析事件——为什么会这样，以及我们如何预测同样的事情在不久的将来会发生。我们的大脑更注重统计和数学。

奥斯曼·拉纳在 Unsplash 上拍摄的照片

根据 Kenneth Craik 的说法，我们的大脑模拟现实来理解现实本身。这款车型是出了名的被称为 小型车型 。

简而言之，我们用统计学来辨别好的推理(决策)和坏的推理(决策)。我希望你们都能理解这其中的迫切需要。我们来消化一下上面这句话。你可能想知道如何应用统计学来决定什么是好的，什么是坏的？

我们的大脑如此善于收集数据、分析数据，并智能地帮助我们推理出结论性的结果。它是如何收集数据的？大脑通过感觉器官(眼睛、鼻子、耳朵、舌头和皮肤)收集数据，这个房间里有太多的生物。整个过程在不知不觉中发生了。隐藏的过程是将数据转化为可感知的信息。

w3.org 上的照片

这个简单的反省给我们留下了一个重要的结论。我们需要数据来进行统计和绘制结果图。你掌握的数据越多，我们得出的结论就越合理。

作者图片

因此，我正在阐明统计概念的直觉同化，这些概念是我们日常活动中与事件相关的基础。

每当我们有数据时，不管是数字的还是分类的，我们都努力通过寻找共同的模式来理解它。在这个过程中，我们发明或发现了一些统计关系或统计函数，它们被称为集中趋势。集中趋势是定量数据(分布值)围绕中心值聚集的特征。什么样的分布值被认为是中心值？这是一个很好的问题，为了回答这个问题，我们通常会计算分布的平均值、中值或众数。但是为什么只有平均、中值、模式？如果你脑子里有这个问题，那么排队我们会慢慢解开。

让我们创建一些数据并使用它。我们会写一些简单的Python函数，现场看答案。

导入有用的库

计算集中趋势的代码，并用一个汇总表漂亮地绘制出来

我知道代码看起来很大，但是很简单。我们还需要创建一个简单的函数来生成我们的观察结果。

生成随机观察值的代码

现在我们都明白为什么平均值、中值和众数被认为是中心值了。让我们实例化我们刚刚编码的类。

实例化 CentralTendency 类的代码

统计表

平均值、中值、众数和范围-按作者分类的图像

你注意到第一和第二个次要情节了吗？紫色表示平均值，绿色表示中值(Q2 ),两者都大致位于观察值的中心。描述模式的第二个子图不是观察的中心(记住，它有时可能在中心)。 可视化总是有助于解开统计学中的这些基本概念 。如果你不明白一个函数是如何工作的，那么只要把输入标在 X 轴上，输出标在 Y 轴上，现在你就有了一个函数的图示。这将使生活变得更容易。

让我们稍微详细地检查一下平均值和中值。

异常值影响平均值，但不影响中值。

什么是离群值？在夏季，当附近的每个人都穿着轻薄的夏季服装时，如果你穿毛衣，那么你就是一个局外人。从技术上讲，离群值是分布中与同一分布中的其余值有很大不同的值。是的，异常值会影响平均值，但不会影响中值。让我们用可视化和少量代码来看看这个。

让我们分别实例化 mean 和 median 的类，看看结果。

为平均值实例化类的代码

存在异常值时平均值的影响-作者图片

如果有任何异常值，平均值会受到很大影响。在上图中，第一个子图表示数据中没有异常值的平均值。第二个子曲线表示当异常值被添加到相同的数据中时，均值在某种程度上被拉向异常值。异常值是285，它远大于分布中的任何其他值。

为中间值实例化类的代码

存在异常值时中值的影响(无影响)-按作者分类的图片

中位数不受异常值的影响，但当异常值大得多时，它们会有轻微的影响。在上图中，尽管数据中存在异常值，但我们没有看到中值的任何变化。在这种情况下，异常值为209，但对中值没有影响。

这清楚地解释了平均值和中间值的异常行为。

平均值和中值是分布的中心值。上面所有的图表清楚地说明了它们的性质，并回答了我们的根本问题:为什么它们是中心？因为在制定平均值和中值时，我们会考虑所有的观察值并进行一些汇总。由于这种聚合，结果总是落在分布的最高值和最低值之间，但大多位于中心。中间值通常不受影响，但平均值受极值的影响很大。

我希望这篇文章能帮助我们理解均值和中位数的本质。

知识图和推理背后的直觉

原文：https://towardsdatascience.com/the-intuitions-behind-knowledge-graphs-and-reasoning-59df2f1ad054?source=collection_archive---------24-----------------------

概念和示例

尽管名为关系数据库，但它并不擅长表达数据中的关系，因为它们强加了一种不利于连接的存储结构。

图形数据库尽管其名称看起来一点也不像图形，但在表达数据点之间的关系时提供了更大的灵活性。这些关系可以是任何类型，并表示为数据点之间的边。

在图中存储关系很有趣，但对于提取知识和见解来说不是很有用。因此，知识图由存储数据的图形数据库和搜索并具体化数据中的模式的推理层组成。

本文通过在高性能知识图和语义推理引擎RDF fox上演示的例子，介绍了知识图和在 RDF 图上推理背后的基本概念和直觉。

知识图表

RDF 数据模型要求数据点以三个一组的形式表达:主语-谓语-宾语。RDF 图的主要查询语言是 SPARQL 。

RDF 中的推理是根据 RDF 图和一组规则计算逻辑三元组的能力。这样的逻辑结果在 RDFox 中具体化为图中的新三元组。

规则的使用可以大大简化 RDF 数据的管理，并为用户查询提供更完整的答案。例如，考虑包含以下三元组的图:

:oxford       :located_in :oxfordshire .
:oxfordshire  :located_in :england .
:england      :located_in :uk .

关系:located_in 是直观传递的:从牛津位于牛津郡，牛津郡位于英格兰这一事实，我们可以推断出牛津位于英格兰。然而，图中缺少了三个字母:oxford :located_in :england ,查询所有英国城市的 SPARQL 查询不会返回 Oxford 作为答案。

图表的可视化表示。

当然，我们可以手动将缺失的三元组添加到图表中，从而确保牛津包含在英国城市列表中。然而，这样做有许多重要的缺点。

可能有数百万个涉及:located_in 关系的缺失三元组，它们中的每一个都需要手动添加，这既麻烦又容易出错。
更重要的是，通过手动添加缺失的三元组，我们没有捕捉到关系的传递性，这普遍适用于图中由它连接的所有对象。

特别地，如果我们将三元组:england :located_in :uk 添加到图中，我们应该导出以下三元组作为:located_in 关系的传递性的逻辑结果:

:oxford :located_in :uk .
:oxfordshire :located_in :uk .

我们可以使用一个规则来忠实地表示关系的传递性。

这种规则将规定，

如果
【任意】对象？图中的 x 通过:located_in连接到一个物体？y 、
、T20、
？y 又通过:located_in连接到一个物体？z ，
然后
？x 也必须通过:located_in连接到？z 。

这里，？x ，？y ，和？z 是可以绑定到图中任何对象的变量。

具体来说，这样的规则可以用 RDFox 的规则语言编写如下:

[?x, :located_in, ?z] :- 
   [?x, :located_in, ?y], [?y, :located_in, ?z] .

在此图中，绿线显示了从规则中派生的链接。

该规则建立了不同数据三元组之间的因果关系；

的确，

三元组:oxford, :located_in, :england 成立，因为三元组:oxford, :located_in, :oxfordshire 和:oxfordshire, :located_in, :england 也成立。

绿线表示由规则导出的关系。

假设我们后来发现:oxford 不在:oxfordshire 中，而是在美国的密西西比州，结果我们从图中删除了下面的三元组:

:oxford :located_in :oxfordshire .

然后，三联件:oxford, located_in, :england 和:oxford, :located_in, :uk 也必须收回，因为它们不再对齐。

这种情况很难通过简单地添加和/或删除三元组来处理；相比之下，可以通过使用 RDFox 中的规则，以高效而优雅的方式自动处理它们。

规则语言

规则语言决定了哪些语法表达式是有效的规则，并为每个规则提供了定义明确的含义。特别是，给定一组任意的语法上有效的规则和一个任意的 RDF 图，将规则应用到图中产生的新三元组必须明确定义。

数据日志

自 20 世纪 80 年代以来，规则语言一直被用于数据管理和人工智能领域。基本的规则语言叫做 Datalog 。它是一种非常容易理解的语言，构成了大量后续规则形式的核心，并配备了广泛的扩展。

Datalog 规则可以被看作是一个IF ... THEN 语句。特别是我们的示例规则

[?x, :located_in, ?z] :- 
    [?x, :located_in, ?y], [?y, :located_in, ?z] .

是 Datalog 规则。

规则的IF部分也称为主体或前件。
嵌线的THEN部分称为头或后件。
头先写，用符号:-与体分开。

主体和头部都由条件合取组成，其中合取用逗号分隔，每个合取都是一个三元组，其中可能会出现变量。

在我们的例子中，身体是[?x, :located_in, ?y], [?y, :located_in, ?z] ，头部是[?x, :located_in, ?z] 。

每个 Datalog 规则都传达了这样的思想，即从输入 RDF 图中三元组的某些组合中，我们可以从逻辑上推断出一些其他的三元组也一定是图的一部分。

特别地，规则中的变量覆盖 RDF 图中所有可能的节点；每当这些变量被赋予使规则体成为图的子集的值时，我们看到那些变量的值是什么，将这些值传播到规则的头部，并推断出结果三元组也必须是图的一部分。

在我们的示例中，一个特定的规则应用程序将变量?x绑定到:oxford ，将变量?y绑定到:oxfordshire，将变量?z绑定到:england，这意味着在规则的头部用:oxford替换?x和用:england替换?z所获得的三元组:oxford :located_in :england 作为一个逻辑结果成立。

一个不同的规则应用程序将把?x绑定到:oxfordshire，把?y绑定到:england，把?z绑定到:uk；由此，三联:oxfordshire :located_in :uk也可以作为一个逻辑推论推导出来。

理解单个 Datalog 规则应用程序对 RDF 图的意义的另一种方法是将其视为 SPARQL 中一个INSERT语句的执行，该语句向图中添加了一组三元组。特别是，声明

insert {?x :located_in ?z } where {
   ?x :located_in ?y. 
   ?y :located_in ?z }

对应于我们的示例规则导致三元组的插入

:oxford :located_in :england . 
:oxfordshire :located_in :uk .

然而，有一个基本的区别使规则比 SPARQL 中简单的INSERT 语句更强大，即规则是递归应用的。

事实上，在我们推导出牛津位于英国之后，我们可以通过将?x 与:oxford 、?y 与:england 、以及?z 与:uk 匹配来再次应用该规则，以推导出:oxford :located_in :uk ——一个不是由上面的INSERT 语句得到的三元组。

这样，图表上的一组 Datalog 规则的逻辑结果被规则的迭代应用捕获，直到没有新的信息可以添加到图表中。

重要的是要注意，所获得的逻辑结果集完全独立于规则应用的执行顺序以及规则体的不同元素的给出顺序。特别是，以下两条规则完全等效:

[?x, :located_in, ?z] :- 
   [?x, :located_in, ?y], [?y, :located_in, ?z] .[?x, :located_in, ?z] :- 
   [?y, :located_in, ?z], [?x, :located_in, ?y] .

实践中的知识图表

知识图表提供了各种各样的应用，但这些应用并不总是为人所知。

使用 RDFox 构建的知识图在动态发现数据中复杂的基于规则的模式或验证它们没有发生时特别有效。

基于规则的模式提供了一种对领域专业知识进行编码的直观方式。例如，模式可以模拟组件应该如何组装成一个功能产品，或者用户需要满足哪些需求才能完成一个过程。

大多数有响应能力的应用程序需要动态评估这些规则，这对于使用传统的推理引擎在期望的响应时间内大规模执行通常是不切实际的。你可以在这里阅读rd fox 如何帮助 Festo 将复杂产品的配置时间从数小时减少到数秒。

通过提供一种更加灵活和一致的方法来存储知识，知识图还可以用来将聊天机器人变成真正智能的推理代理。规则也有助于改善对表述不当的问题的解释。

知识图的另一个关键用例是检测网络中的循环关系，这些关系代表了欺诈或内幕交易等不良行为。RDFox 可以通过有效地导航传递关系来无缝地建立网络中的连接。RDFox 可以自动标记或阻止不应该存在的连接，不管网络有多复杂。

用 RDFox 操作化知识图

RDFox 是一个高性能的知识图和语义推理引擎，可以大规模和动态地评估复杂的查询和规则。

RDFox 克服了传统数据库和推理引擎的灵活性和性能限制，它是一个针对速度和并行推理而优化的内存 RDF 三重存储。

支撑 RDFox 的新颖设计和概念是牛津大学在过去十年中开发和完善的，并在同行评审研究中得到数学验证。

RDFox 保证其规则具体化和查询结果的正确性，可以在生产级服务器和内存受限的设备上大规模、动态地交付。

更多关于 RDFox 的信息可以在这里找到。

团队和资源

牛津语义技术公司(Oxford Semantic Technologies)背后的团队于 2011 年在牛津大学计算机科学系开始研究 RDFox，他们坚信灵活和高性能的推理是数据密集型应用的一种可能性，而不会危及结果的正确性。RDFox 是第一个面向市场的知识图，它是从底层开始设计的，并考虑到了推理。牛津语义技术公司是牛津大学的一个分支，由主要投资者支持，包括三星风险投资公司(【SVIC】)、牛津科学创新公司( OSI )和牛津大学的投资部门( OUI )。笔者很自豪能成为这个团队的一员。

paweczerwiński在 Unsplash 上拍摄的封面照片。

数据的隐形陷阱

原文：https://towardsdatascience.com/the-invisible-traps-of-data-278aa1f491ac?source=collection_archive---------49-----------------------

这都是关于字里行间的解读

埃里克·马塞利诺在 Unsplash 上的照片

众所周知，数据科学家花在数据准备任务(数据收集、 EDA 和功能工程)上的时间比花在机器学习建模上的时间多得多。虽然我们中的许多人可能会抱怨这个事实，但我认为低估数据准备的重要性——尤其是数据探索——是一个错误，会极大地损害您的 ML 项目，并且在开始模型实现之前，应该花相当多的时间来理解和探索数据。

机器学习中的数据挑战

在 ML 项目中遇到的挑战要么与算法有关，要么与数据有关。与算法相关的挑战在大多数时候要么过拟合，要么欠拟合训练数据。另一方面，与数据相关的挑战非常多样；此外，它们在当今商业领域的 ML 项目中非常常见——由此可见数据准备的重要性。

现实就是这么简单:你的程序的性能很大程度上取决于你的数据准备的质量——永远不要忘记这个领域最著名的一句话“垃圾进，垃圾出”。

但是数据准备并不总是容易的。除了确保你拥有高质量的数据和足够数量的数据，你还必须应对其他一些挑战，如果没有对数据的深刻理解，这些挑战更难揭开——它们是数据的隐形陷阱。他们要为数据科学家犯下的几个错误和错误假设负责，这些数据科学家没有后退一步提出正确的问题。这里是我在商业中见过的两个最常见的隐形陷阱。**

偏见，无处不在的偏见

当 ML & AI 系统在我们的社会中大规模部署时，解决与偏见相关的挑战至关重要。尤其是考虑到算法对我们生活的影响的性质——现在它们可以决定你是否获得抵押贷款或工作。这就是为什么在过去几年里，机器学习中的公平问题已经成为一个非常活跃的研究领域。

因此，数据科学家应该注意这个问题，因为偏见很容易进入 ML 系统，并且很难发现。偏见有很多种，但它们可以分为两类。

****数据中的偏差:这些是训练数据中的偏差，ML 算法将从中学习，并因此复制为输出。社会偏见、种族偏见、样本偏见……都是数据偏见的例子。它们可能是由非代表性数据引起的，也可能是由训练样本中描述的有偏模式引起的，它们肯定会影响您的 ML 系统，使其泛化能力很差，或者学习将在输出中复制的有偏模式。要了解更多关于社会偏见的信息，我建议你看看 Bertrand K. Hassani 的论文通过机器学习强化社会偏见:信用评分视角。
****人类的偏见:这些是存在于我们头脑中的认知偏见。事实上，我们大大高估了自己做出正确决定/判断以及摆脱无意识偏见的能力。我们需要记住，作为个体人类，我们有很多认知偏见，这取决于我们个人的背景、文化等。因此，在某些情况下，人们可以从相同的数据中得出非常不同的——有时甚至相反的——结论。

您的 ML 工作流程需要一个探索审查步骤

有大量的 EDA 技术和工具旨在自动化和加速我们的数据探索方法。但是这种方法的缺点是，它增加了忽略数据复杂性的风险——以及落入其隐形陷阱的风险。

为了解决这个问题，我发现最好的方法是在 ML 工作流程中系统地整合一个探索审查阶段，在此期间，您可以后退一步，提出更多的问题，并重新考虑您对培训数据所做的假设。

在这个新阶段，“探索数据集之外”也至关重要。我说的不仅仅是通过一些谷歌搜索或寻找更多的数据，还包括走出去和人们交谈:

咨询领域专家以获得更多的领域知识，
与客户接触，更好地了解他们的动机，
与你的同事/朋友分享你的发现，以获得其他观点，…

因为，通常情况下，数据只会告诉你发生了什么，而不是为什么会发生。我们都知道，预测未来最好的方法莫过于理解过去和现在的原因。

虹膜数据集——一点历史和生物学知识

原文：https://towardsdatascience.com/the-iris-dataset-a-little-bit-of-history-and-biology-fb4812f5a7b5?source=collection_archive---------24-----------------------

如果我们知道数据背后的故事，数据会更有意义。

卡伦·艾姆斯利在 Unsplash 上的照片

如果你曾经接受过任何正式或非正式的统计或机器学习培训，你不会对虹膜数据集感到陌生，鉴于其受欢迎程度，它甚至有自己的维基百科页面。大多数人对虹膜数据集的了解是，它记录了萼片和花瓣的长度和宽度。该数据集由三种鸢尾中的每一种的 50 条记录组成:鸢尾、海滨鸢尾和杂色鸢尾。

除此之外，你知道数据集来自哪里吗？你知道这些不同的物种长什么样吗？如果你不知道答案，没关系。这正是本文所要讨论的。让我们暂时放下处理数据的工作，了解一些常见数据集背后的有趣故事。

数据集的历史

Iris flower 数据集也称为 Fisher's Iris 数据集。你的猜测是对的——这就是同一个费雪，罗纳德·艾尔默·费希尔爵士，他也发明了费雪精确测试。作为皇家学会的会员，费希尔爵士于 1890 年出生在英国伦敦，是一位著名的统计学家和遗传学家。

罗纳尔·艾尔默·费希尔爵士(来源:维基百科，许可:公共领域)

他对统计学的贡献远远超出了费希尔的精确检验。例如，他开发了最大似然估计和方差分析(通常被称为 ANOVA)测试。由于这些重要的贡献，他在现代统计学史上受到了高度评价，正如他的维基百科页面上所指出的那样。

由于他在统计学方面的工作，他被描述为“一个几乎单枪匹马为现代统计学奠定基础的天才”和“20 世纪统计学中最重要的人物”。—维基百科

1936 年，费希尔在《T2 优生学年鉴》杂志上发表了一篇题为“多重测量在分类学问题中的应用”的报告。如果你有兴趣，可以在这里阅读全文。在这篇文章中，Fisher 开发并评估了一个线性函数来根据花的形态区分鸢尾属物种。这是上述三种鸢尾属植物的萼片和花瓣结构首次公开出现。下面提供了原始数据表的快照。请注意，这些测量是以厘米为单位记录的。

鸢尾花的形态学测量(鸢尾数据集的一部分，来源&许可

如下图所示，总体而言，该判别函数在区分这些物种方面表现良好，除了杂色鸢尾和海滨鸢尾之间有一些重叠。刚毛鸢尾与其他两个物种明显不同。

图来自 Fisher 关于 Iris 数据集的文章(来源&许可

但是，需要注意的是，费希尔本人并没有收集这些数据。在他的文章中，他明确将数据来源归功于埃德加·安德森博士，他在加拿大一个美丽的旅游胜地加斯佩半岛收集了大部分数据。我找不到安德森博士的无版权图片，但如果你感兴趣，你可以在这里找到他的图片。

安德森博士 1897 年出生于纽约州，21 世纪初在美国密歇根州长大。作为一名植物学家，安德森博士是圣路易斯华盛顿大学的教员。1929 年，他接受了一项奖学金，与包括费希尔爵士在内的几位科学家一起在英国工作。通过这次合作机会，Fisher 获得了 Anderson 博士的许可，可以使用上面讨论的文章中的数据。

除了收集这个著名数据集的数据，安德森博士还对植物遗传学做出了重要贡献，并出版了一本关于该领域的原创书籍，书名为“渐渗杂交”他在科学上的贡献使他在 1934 年当选为美国艺术与科学院院士，并在 1954 年当选为美国国家科学院院士。

鸢尾花的生物学

你们中有多少人真的在花园或图片中看到过鸢尾花，尤其是数据集中的那三种？我怀疑这个数字可能很高，因为根据我周围的朋友和同事的回答，只有一小部分人告诉我他们以前见过 Iris 追随者。当然，我必须给他们看一些鸢尾花的照片，否则他们中的许多人可能甚至不知道鸢尾花是什么。

除此之外，我们知道数据集中的三种鸢尾:鸢尾、海滨鸢尾和杂色鸢尾，我们还知道数据集记录了这些花的萼片和花瓣的长度和宽度。让我们一箭双雕吧——见下图。

鸢尾、杂色鸢尾和海滨鸢尾的花瓣和萼片(来源: 1 、 2 、 3 ，许可证:公共领域，CC BY-SA 3.0 & CC BY-SA 2.0)

如上图所示，这几个物种在形态上确实有相似之处。因此，有趣的是，费希尔爵士在 30 年代开发的判别函数可以从统计学的角度巧妙地解决这个问题。然而，植物学家有更好的方法来区分这些物种。其实安德森博士自己也发表了一篇名为《鸢尾属植物中的物种问题》的手稿，讨论鸢尾属植物物种的判别问题，你可以在这里阅读正文。在文章中，安德森博士指出，这些花的种子的形态更能提供信息。除了花瓣和萼片的大小不同之外，这三个种的种子大小也有明显的不同。

最终想法

大数据、人工智能、机器学习、深度学习和许多其他数据科学术语几乎是每个学术和工业领域的热门话题。鉴于市场上对数据科学家的大量工作需求，许多人进入了这些领域。一些数据科学家错误地认为他们唯一的工作就是处理呈现给他们的数据。

他们没有真正意识到的是，我们所有的数据都有其来源和内容背景。数据的处理、分析和解释都需要相关领域的内容知识。因此，如果我们想做更好的数据科学，我们永远不能忽视我们正在处理的数据背后的内容知识。

关于当前文章的最后一个简短说明。我第一次了解 Iris 数据集是在我使用 SAS 学习判别分析的时候。坦白地说，我没有过多地考虑数据集本身。然而，随着我对数据科学研究的了解越来越多，我发现深入理解数据非常重要。因此，事后看来，我想找出虹膜数据集背后的故事，并与你分享。我希望你喜欢当前作品的某些部分，并学到一些东西——至少，你应该知道鸢尾花的萼片和花瓣是什么，对吗？

矩阵的瑰宝:深入探究特征值和特征向量

原文：https://towardsdatascience.com/the-jewel-of-the-matrix-a-deep-dive-into-eigenvalues-eigenvectors-22f1c8da11fd?source=collection_archive---------14-----------------------

信号源

对抽象概念的直观观察

特征值和特征向量可能看起来是抽象和遥远的概念，但它们在你周围的世界中起着不可或缺的作用。当一切都由数据定义时，它们被存储在矩阵中。通过复杂性和复杂性，矩阵的中心是特征向量和特征值，提供了清晰性并揭示了矩阵的本质。理解它们是什么，如何得到它们，以及它们的应用是欣赏矩阵之美，以及更广泛地说，数据和数学在世界上所扮演的角色所不可或缺的。

让我们首先考虑二维向量，它有两个元素，每个元素对应于二维平面上的一个坐标。它们代表从一个坐标到另一个坐标的运动。

当一个向量乘以一个矩阵时，他们应用了一个线性变换。这具有沿着两个向量拉伸(或挤压)坐标系的效果。例如，矩阵[[3, 1], [1, 2]]沿着矢量[3, 1](第一列)对齐 x 轴，沿着矢量[1, 2]对齐 y 轴。从视觉上，可以看出点(0，1)实际上映射到(1，2)，这可以通过将其乘以矩阵来确认。

假设我们有一个矢量[-1, -1]。它乘以线性变换矩阵后，落在点[-4, -3]上。

向量的跨度是永远穿过向量的线。当一个向量经历线性变换(乘以矩阵)时，通常它会被从它的跨度中去掉。

然而，一些类型的向量不会被删除。这些是矩阵的特征向量。相反，当特征向量乘以矩阵时，特征向量简单地按特征值的因子缩放，落在沿其跨度的其他地方。

特征向量和特征值是混乱的——它们很少是整数，很容易处理。

由于特征向量的性质，简单地在相同或直接相反的方向上缩放基本特征向量将产生另一个特征向量。

在三维空间中，矩阵描述了三个轴的变换——x、 y 和z——对应于代表每个坐标经历的变换的三个坐标。这就是为什么只对方阵定义特征向量和特征值；一个通用的 n 乘 n 矩阵描述了 n 轴的变换，每个轴对应一个具有 n 元素的坐标。

为了找到一个矩阵的特征向量，我们首先需要找到它的特征值。从特征值的定义可以构造一个等式 Ax = λ x ，其中 A 表示矩阵，λ表示特征值。这有道理；将特征向量乘以变换矩阵 x 应该具有与将其缩放特征值λ相同的效果。

根据这个关系，我们可以将这两个项移到左边。为了使表达式 A - λ有效( A 是一个矩阵，λ是一个数)，我们将λ乘以一个单位矩阵，它根本不应用任何变换。

如上所述，有无限多的平凡解，或者可以简单地通过将一个特征向量缩放任意数量来实现的解。为了摆脱琐碎的解决方案，我们使用行列式。

行列式只是面积被变换矩阵拉伸的因子的度量。例如，考虑坐标平面上的一个标准正方形，面积为一个正方形单位。

当空间被变换矩阵拉伸时，新的区域是四个平方单位。因为面积增加了四倍，所以矩阵的行列式是四。

当行列式等于 0 时，正方形的面积折叠为零，这意味着描述轴的位置的两个向量在同一条线上。在这种情况下，所有的空间都被扭曲成一条线(一维)。通过设定行列式必须等于零的要求，多余的或平凡的解的空间可以被丢弃，使得方程更容易解。

因此，为了使先前设计的等式(容易)可解，首先矩阵的行列式必须等于零。

寻找特征值是一个求解二次方程的任务。对于 3+维矩阵，必须使用不同形式的行列式公式。

在这种情况下，矩阵[[1, 4], [3, 2]]的特征值是 5 和-2。这意味着当矩阵的特征向量乘以矩阵时，它们的向量长度将被拉伸 5 倍和-2 倍，分别对应于每个特征向量。通过将发现的特征值代入我们最初导出的方程，我们可以找到特征向量。

特征向量和特征值确实是矩阵的瑰宝。它体现了母体的精神和本质——eigen是德语中“先天”的意思。只要给定任何矩阵的特征向量和特征值，就可以很容易地完全重构原始矩阵。有了这个特殊的性质，特征向量几乎完全可以保证出现在任何有矩阵运算的地方。

例如，考虑主成分分析(PCA)，这是一种常见的无监督机器学习技术，旨在减少数据的维度，同时保留方差和均值等关键统计指标。例如，考虑一个 100 维的数据集，PCA 将尝试将其缩减为两维。首先，该算法构造一个协方差矩阵，该矩阵评估(在某种意义上)两个变量的相关程度。矩阵作为一个整体定义了数据的形状。

协方差矩阵的特征向量用于沿着最大方差线在 x 和 y 轴之间重新定向数据。本质上，特征向量被用作矩阵的快照，它告诉算法哪些区域要放大，哪些区域要去噪。特征向量和特征值的无数其他应用，从机器学习到拓扑学，都利用了特征向量提供了如此多关于矩阵的有用信息的关键特征——应用于从寻找四维立方体中的旋转线到压缩高维图像到谷歌的搜索排名算法的任何地方。

也许特征向量和特征值如此特殊的原因是因为它的定义——向量的方向保持不变，而它们周围的空间是扭曲的，永远指向矩阵的真正美丽。

如果您喜欢，您可能还会喜欢微积分入门，这是一个与线性代数一样重要和迷人的数学领域:

点击上方！^

“吉拉思维”正在损害您的数据科学团队

原文：https://towardsdatascience.com/the-jira-mindset-is-damaging-your-data-science-team-66efc46aaa47?source=collection_archive---------0-----------------------

完成一个成功的数据科学项目与完成任务没有多大关系。

数据科学项目和建设项目是不同的猛兽。

对于外行人来说，“吉拉”是一个项目管理工具，在科技公司之外几乎无处不在。它最初是为了管理软件开发项目而构建的，自然会被重新应用到数据科学项目中。我想说，尽管吉拉可能是一个很好的工具， 数据科学项目是不同的 ！

管理数据科学项目会引起大量热烈的讨论(如果你是乐观主义者)或大量的争论(如果你是悲观主义者)【1】。一方面，有一个默认的立场，因为数据科学家通常在技术部门工作，他们应该像专业的软件开发人员一样管理。另一方面，有一种观点认为，因为数据科学家通常有研究背景，他们应该像研究人员一样被对待，并被赋予“创造性”的自由。

两个都不行。然而，后一种方法的风险对管理类型来说更为明显:你让这些数据科学家自由支配，他们就会变得无关紧要，对底线没有任何帮助。所以我想把这周的帖子花在前一个职位有什么问题上。为什么数据科学家如此抗拒软件开发人员和管理人员认为理所当然的过程？

首先，我应该说我是某种项目管理的忠实信徒。就像一个管弦乐队需要一个指挥一样，一个团队需要一个具有协调功能的人。一个问题是对于如何称呼他们还没有广泛的共识。在微软，他们都被称为项目经理。其他地方会称他们为项目经理。我见过有产品经理头衔的人扮演这个角色。甚至是商业分析师。

面对所有这些混乱，一些地方(我在这里不点名)只是雇佣其中一个，并希望他们能找出谁为自己做什么。这可能会导致耶稣会关于角色差异的争论。此外，取决于你是思想家还是探索者【3】，我见过一个团队的产品经理、项目经理、业务分析师和项目经理都管理两个糟糕的数据科学家的滑稽/悲剧场景。现在，我们能责怪那两位数据科学家抵制四位经理创建的流程吗？毕竟，谁在做真正的工作呢？

所以也许数据科学家对流程不满意是流程破碎的标志，而不是数据科学家破碎的标志 。

现在，就我们的目的而言，我将把担任协调角色的所有人放在职务“ PM ”下。如果你是一名数据科学家，不确定我说的你的项目经理是谁，他们是你团队的乐队指挥，也就是说，他们站在最前面，挥舞着手臂，做着奇怪的表情。

无论如何，在任何项目中，一个项目经理必须展示进度。这种数据科学的东西很复杂。因此，也许我们只是给人们分配任务，然后绘制燃尽图，显示有多少任务已经完成。我们甚至可以制作图表显示谁做了什么！高级管理人员相信这些东西。这是一个非常棒的工具，它让所有这类事情变得非常非常简单，所以让我们就这么做吧…

所以，吉拉。

现在，吉拉在这方面做得很好，这没有错。然而，在这个世界上有一种心态，认为“我们正在完成任务，因此我们正在交付”。这是错误的。真的真的错了。吉拉鼓励这种心态，因为，嗯，它把世界组织成可以被勾掉的任务。

让我们来看看完成任务和交付有用的东西之间的区别。乍一看，这似乎有悖直觉。当然，项目管理的一个基本原则是，你把一件大事分成许多可预测的小事情，然后通过这些小事情来解决。换句话说，你把你的大事分成几个任务，然后一个接一个地完成这些任务。甚至有一个非常好理解的、政府批准的系统来做这件事，叫做 Prince2(冷静下来，敏捷的人们，我们一会儿就来找你们)。许多人乐于在这种体制下拥有各种听起来很花哨的资格。见鬼，如果我在建摩天大楼，我会用这个系统。这在伦敦奥运会上奏效了，对吗？

所以问题就变成了:数据科学项目是不是像摩天大楼项目？

不不不不原因如下。

目的不是手段

第一个区别是最终目标。摩天大楼项目的目标是建造一个人工制品。使用这种人工制品的商业目标，即出租办公室/酒店/公寓/任何被令人眼花缭乱的层层金融骗局抽离的东西，这些骗局一直延伸到为你提供养老金的基金。只是不要去想每一层都把你的钱装进了自己的口袋。

我跑题了。

关键是，作为一名谦逊的工程师，你可以继续建造该死的摩天大楼，而不必太担心商业方面的事情。

作为一个卑微的数据科学家，你没有这个闲心。你的工作不是制造一个人工制品，而是将一个正在进行的业务流程变得更好。让我举一个例子，那就是，咳咳，具体的:你的工作不是建立一个预测订阅流失的模型，你的工作是实际减少订阅流失。预测模型可能有帮助，也可能没有。耸耸肩说“我只是因为你告诉我才造了一个模型”是没有用的。

好的，所以你要改进这个业务流程。你从哪里开始——什么会真正改变这个数字？你可能会想到很多事情。提醒邮件？个性化推荐？产品折扣？

此时，作为一名数据科学家，您会注意到两件事。首先，数据科学只占你工作的一小部分，所以你最好和其他人一起工作。其次，你不知道什么可行，什么不可行。

到处都有不确定性

这里我们来看数据科学项目和摩天大楼之间的第二个区别。你的摩天大楼是在一个基本可预测的环境中建造的，使用基本可预测的材料和或多或少固定的设计。在这种情况下，将这些大部分可预测的结果分解成大部分可预测的子任务，并以自己的方式完成它们是完全合理的。

在许多数据科学项目中，这些都不适用。环境总是在变，因为高级经理们似乎一直在改变主意。数据科学家的材料等同于他们使用的技术，基本上不可能预先预测什么可行，什么不可行。你不知道哪个产品相关的功能会有所不同。提醒邮件？推荐文章？打折？所以想出一个固定的设计是不可能的——谁知道客户会有什么反应？

你能做的最好的事就是尽可能快地进行实验。然后用你的实验结果来决定下一步做什么实验，然后收集下一组结果等等。换句话说你需要迭代。

给你。陈词滥调是有原因的。

由于 MVP 运动，现在每个人都口头上支持迭代。然而，我很少看到这种影响完全融入到一个组织的工作中。如果你这样做是对的，一旦你完成了第一个任务，你将不得不根据你的发现改变接下来的任务。

换句话说，你的计划毫无用处。

现在，列出你要做的事情清单可能会让你内心暖洋洋的。然而，你不应该欺骗自己，认为要做的事情清单与你最终实际要做的事情有任何关系。如果清单上的项目与你最终要做的事情无关，那就再提醒我一次？

这就是吉拉心态的问题。如果你按计划使用这个工具，你将会花费一生的时间去删除标签、更改标签、取消标签的优先级——因为你的任务总是会随着你的学习而改变。问题不在于吉拉本身，而在于你是在一个可预测的世界中运作，这个世界可以被组织成一个任务列表。

但是敏捷就是迭代。吉拉很敏捷，所以你错了！

号码

看，敏捷软件开发的 12 个原则是非常棒的。这是我发现自己反复参考的文件之一。而且，它们表达得如此优雅，以至于它们抗拒总结。请看这里的【5】。

回来了？合适的印象？嗯，比敏捷宣言本身更可怕的是敏捷过程，大写的“A”。事实上，宣言的作者之一已经否认了敏捷过程【6】。所以从现在开始，我将使用敏捷(小 A)这个词来指代与敏捷宣言一致的过程，而敏捷(大 A)是指公司向数据科学家推行的各种过程。

这些过程是什么？它们可能非常复杂，包括故事、史诗、仪式和尖峰的术语。然而最终，尽管意图可能不同，我只见过敏捷被做为一堆要被勾掉的任务。对我来说，这就是“吉拉思维”，更接近于 Prince2，而不是敏捷宣言。

那么数据科学项目应该如何管理呢？

这本身就是一个帖子！但是，这里有一个供数据科学项目经理考虑的简短列表:

项目经理工作的很大一部分是将可移动的部分“拿出来”,并确保项目团队有一个明确的交付目标。99%的情况下应该包含一个数字。
一旦确定了这个数字，项目就必须有时间限制。不是说过了一段时间后就会停止，更像是“我们今天有个重要的会议，我们必须在会上展示我们在人数上的进步”。然后你不得不咬指甲，因为开始时似乎什么都没发生，然后看着人们在截止日期到来时工作到很晚。显然，是关于创造性思维的。
计划是无用的，但计划是必不可少的。你将不得不做出一些最好的猜测，事情可能会迭代到哪里。好吧，你不确定会发生什么，但是你认为你需要发电子邮件吗？那么最好提前与 CRM 团队沟通。
没别的了。如果你发现自己鞭笞别人来完成任务，那一定是出了严重的问题。

最后一点，我对项目经理有点刻薄。他们是容易被攻击的目标，而且这种数据科学的东西还是相当新的。我们将回到数据科学家和项目经理在未来应该如何合作的问题上，但是现在可以说项目经理有两种类型。有些人并不真正明白发生了什么，他们试图把一切都强加到他们上过的任何项目管理方法中。这些人基本上是项目的负面因素。组织无法承受净负。

另一种在科技公司中很常见，但在公司之外可能更少见，基本上与黄金同等重要。如果你的组织里碰巧有一个，你应该考虑如何不惜一切代价留住他们！

脚注

【1】参见例如奥赖利的敏捷数据科学 2.0

每条规则都有例外。看 Persimfans 乐团。

【3】“我经常说，也经常想，这个世界对思考的人来说是喜剧，对感受的人来说是悲剧——这就是为什么德谟克里特斯笑了，赫拉克利特哭了。”霍勒斯·沃波尔，致霍瑞斯·曼爵士的信(1769 年 12 月 31 日)

【4】关于稍微压抑的阅读，参见大卫·格雷伯关于 B******t 乔布斯。(语言警告，仅在标题中)

敏捷宣言在它 21 世纪初的辉煌中是可见的。

【6】见迪夫·托马斯这里讲的。

【7】之类的。这里有一段关于那段特殊引文的讨论。

自动化运维之旅

原文：https://towardsdatascience.com/the-journey-to-automated-operation-and-maintenance-7eecf8efd135?source=collection_archive---------33-----------------------

无需人工干预即可操作服务器

您是否想象过您可以从操作和维护服务器的繁重重复的日常工作中解脱出来？你想自动化所有这些无聊的东西，专注于更有创意的吗？自动化操作和维护的价值在于消除了手动和重复性任务，使用工具和平台来自动化曾经是手动的流程，如修补、配置和部署等。

自动化操作和维护的范围

在学习自动化操作之前，我们先回到起点，看看什么是操作。操作和维护应包括以下内容:

环境定义:包括开发环境、测试环境、预生产环境、生产环境等。
部署:有效地将包部署到不同环境的能力。
监控:在部署后监控系统和应用程序的能力。
报警响应:报警发生时的响应和处理机制。
性能优化:包括系统各种服务的优化，如 Nginx、Java、PHP、数据库或网络。
SLA 保证:这通常需要在与业务相关部门讨论后决定。

自动化运维也应该包括以上六类。在实践中，我们将关注三个自动化。第一，自动化环境定义；第二，自动化部署；第三，自动化监控。

照片由 Goh Rhy Yan 在 Unsplash 上拍摄

自动化操作和维护的三个阶段

操作自动化

自动化操作和维护的第一阶段是操作自动化。在这个阶段，我们将日常事务中一系列手动执行的操作与脚本或工具联系起来。最简单的例子是将多个 shell 脚本放在一起执行特定的操作。这种程度的自动化只是解决了手动执行的一部分问题，因为一旦运行条件发生了变化，shell 脚本可能就要改了，运维压力还是很大的，而且容易出错。您管理的服务器和系统越多，出错的可能性就越大。

卢卡·布拉沃在 Unsplash 上的照片

场景自动化

自动化运维的第二个阶段是场景自动化。在这个层面上，自动化工具会根据外部环境判断如何运行，这些判断条件是预先定义好的。这个级别的运维系统需要各种类型的环境数据来做出判断，还需要能够根据变化来操作，比如不同的执行步骤。因此，这个级别的运维系统需要与许多其他系统进行接口，如配置系统、网络管理系统等。，最好也有一个流程引擎。

照片由达里娅·内布里亚希娜在 Unsplash 拍摄

人工智能操作(AIOps)

自动化操作的第三阶段是人工智能操作，即所谓的 AIOps。这个级别的运维体系有一个数据核心，有基于数据的自我分析判断能力，有自我决策和执行的能力。这一级别的运维主要工作是在系统中加入分析策略，对这个智能运维系统进行运维，并介入对系统关键节点进行人工判断。

自动化操作和维护的价值

自动化运维的价值在于将运维从繁琐、常规、人为易出事的工作中分离出来，去做更有价值的业务运维、服务运维。从这个角度来说，自动化运维既不是起点，也不是终点。自动化运维不是万能的。如何构建您的自动化系统取决于您的业务支持哪种服务。自动化运维毕竟只是一个高级工具。运维的价值最终体现在业务上，实现的方式就是运营服务化(或者运营即服务)。因此，运维自动化的目标是摆脱所有的人类干预，达到一种我们可以将运维便捷化为服务的水平。

马库斯·温克勒在 Unsplash 上的照片

自动化操作和维护的体系结构

接下来，我们将介绍自动化运维的架构。本节内容主要包括自动化运维系统的目标、自动化运维系统架构概述、自动化运维系统架构的构建原则。

自动化操作和维护系统的四个目标

首先，我们来看看自动化运维系统的目标。我们可以用四个字来概括构建一套自动化运维系统的目标:

完整性意味着系统必须能够覆盖所有的操作和维护需求。
简单意味着易于使用。如果系统的操作流程、操作界面、设计思路都很复杂，运维人员的学习成本会很高，有效性会大打折扣，系统的能力和效率也会降低。
高效，特别是在批量处理或者执行特定任务的时候，我们希望系统能够及时反馈。
安全。如果一个系统不安全，它可能会很快被黑客接管，所以安全也是一个重要的因素。

自动化操作和维护架构概述

自动化运维系统的核心是自动化运维管理平台。根据业务情况，其他模块可能略有不同。典型的模块包括自动安全检查系统、自动更新系统、自动数据分析和数据备份系统以及自动监控和报警系统。自动更新系统分为服务器端更新系统和客户端更新系统。在各个模块之间，自动化运维平台将为自动化安检系统和自动化更新系统提供底层支持；自动数据分析系统和自动更新系统将互连，并且自动数据分析系统将对自动更新系统的结果给出反馈。

自动化运维体系建设的三个原则

自动化运维系统是系统工程、规划和建设的理念。有几个原则供你参考。

渐进过程

中小型公司不需要复杂但庞大的系统。如果系统从一开始就设计的非常大，功能非常丰富，可能会导致一些无法控制的情况。这个系统可能因为耦合太强，发展无法控制，或者因为资金问题导致项目搁浅，最后都不行。但如果一开始的目标就是解决一些具体问题，有针对性，那么就更容易推进。

斯蒂芬·亨宁在 Unsplash 上的照片

可量测性

第二是考虑可扩展性。在设计系统的时候，可能没有那么多的功能或者设计考虑，但是要考虑当服务器数量相对膨胀的时候，系统是否还能支撑。例如，系统是否可以在 10 到 100 或数千个服务器的数量级上使用。

实用目的

在许多情况下，市场上可能已经有了更成熟的协议和工具。对它们进行评估，看看它们是否可以在您的生产环境中使用。如果能直接用，就没必要自己再做一套了。你自己做的这套工具，很多方面都没有经过验证，可能会造成安全问题。基于成熟的协议和框架来实现它们可以提高效率并确保稳定性和安全性。

自动化操作和维护的技术框架

监控是自动化操作和维护的核心概念

首先让我们了解一个概念:监控是自动化运维的核心。影响运维工作效率的主要因素是响应速度。运维人员需要持续盯着告警页面，然后通知相应人员处理告警。在生产系统中，我们需要将服务器的状态监控作为自动化运维的核心问题。监控用于驱动操作和维护事件的启动、处理和终止。ElkStack Zabbix 和 Zabbix-Agent 获取服务器每天的工作状态和服务信息，并生成时间序列统计图用于结果分析。

斯蒂芬·道森在 Unsplash 上拍摄的照片

通过精准有效的报警策略，专业的人才能做专业的事。生产系统可以通过邮件、微信、短信等方式发送报警，根据故障类型和影响程度及时通知相应人员，并根据 SLA 升级事件。一些运维系统是针对微信平台开发的，可以提供更多的功能，比如通过模板处理问题。例如，当服务器的磁盘利用率达到 90%时，就会向相应的处理人员发出警报。此时，处理人员可以从微信中选择并操作相应的垃圾清除模板、数据修复模板、删除历史日志模板等。，可用于结算操作。这样的模式自然大大提高了运维效率。

模板化部署是自动化运维的必备工具

模板化部署是自动化运维不可或缺的工具。对于运维工程师来说，真正意义上的服务器维护的负荷并不重，真正的负担是环境的部署。有时候环境的部署会占用运维工程师 80%以上的时间。由于操作系统版本的不同，系统环境的手动和随机初始化，以及不同软件包版本的更新，一系列的问题会导致工程师在部署运维工具或公司产品时出现各种奇怪的问题。模板描述了如何部署一组资源和安装所需的软件。模板指定要使用的资源、要设置的属性以及自动部署特定应用程序所需的参数。然后，您可以使用编排引擎自动创建和配置模板中的所有资源，以简化部署和操作维护

自动化运维框架和工具

接下来，我们看几个自动化操作和维护框架和工具。业界有三种主流工具:Ansible、SaltStack 和 Puppet。

可回答的

[## Ansible 是简单的 IT 自动化

Ansible 是自动化应用和 IT 基础设施的最简单方式。应用程序部署+配置管理+…

www.ansible.com](https://www.ansible.com/)

Ansible 是基于 Python 开发的。它不能批量部署。ansible 运行的模块是批量部署的。Ansible 提供了一个框架，主要模块包括连接插件、多任务插件剧本等等。

Ansible 具有以下特征。

它不需要在被控制的主机上安装客户端，也不需要服务器。使用时可以直接运行命令。但是，operation 命令的服务器 Python 版本必须高于 2.6。
它基于模块，可以用任何语言开发。
使用 YAML 语言定制剧本。
其他包括基于 ansible 的 SSH 工作，可以有效地实现多级命令。

盐堆

[## 主页|盐栈

IT、网络和安全运营团队使用 SaltStack 基础架构自动化软件来提高安全性…

www.saltstack.com](https://www.saltstack.com/)

SaltStack 是服务器基础设施的集中管理平台，具有配置管理、远程执行和监控功能。SaltStack 基于 Python，结合了轻量级消息队列和 Python 第三方模块。通过部署 SaltStack 环境可以实现的功能包括在数千台服务器上批量执行命令，以及基于不同业务特征的集中配置管理、文件分发、服务器数据收集、操作系统基础和软件包管理。

傀儡

[## 强大的基础设施自动化和交付|木偶

我们希望在扩大客户群的同时确保高效地扩大规模——有了 Puppet，我们可以做到这一点。我们可以关注…

puppet.com](https://puppet.com/)

Puppet 是一个用于 Linux Unix 平台的集中式配置管理系统；它基于 C/S 架构，用 Ruby 语言开发。它可以管理配置文件、用户、cron 任务、软件包、系统服务等。Puppet 将这些系统实体称为资源，其设计目标是简化这些资源的管理，并妥善处理资源之间的依赖关系。Puppet 是一个基于 C/S 的配置管理工具。Puppet-Server 安装在中央服务器上，客户机软件安装在需要管理的目标主机上。当客户机连接到 puppet-master 时，puppet master 上的配置文件被编译，然后在客户机上运行。

摘要

最后，我们总结一下。首先，我们介绍了自动化运维的范围，包括三个自动化:环境自动化、部署自动化和监控自动化。接下来，我们介绍了自动化运维的三个阶段，即运营自动化、场景自动化、人工智能运营。我们还介绍了自动化操作和维护的价值。它是把运维从繁琐、常规、人为的任务中分离出来，做更有价值的业务运维、服务运维。

然后，我们介绍了自动化操作和维护系统的目标。我们可以用四个词来概括它们:完整、简单、高效和安全。接下来，我们介绍了自动化运维系统的总体架构。自动化运维管理平台是整个系统的核心。其他典型模块有自动安检系统、自动更新系统、自动数据分析和数据备份系统、自动监控和报警系统。接下来，我们介绍了构建自动化运维系统的原则。有三个原则:循序渐进，考虑可扩展性，实用目的。

上一节我们介绍了一个概念:监控是自动化运维的核心概念，响应速度是决定运维效率的一大因素。有效的监控方法可以提高响应速度和运维效率。我们引入了模板化部署，这是自动化运维不可或缺的工具。最后，我们介绍了几个用于自动化操作和维护的工具，即 Ansible、SaltStack 和 Puppet。

是时候不用服务器了

哇，上面好多东西，感觉筋疲力尽吧？我也有同感。经过我五年多的操作和维护经验，我找到了一个解决方案:无服务器！那是什么？那就是运行您的应用程序而不操作和管理您的服务器！这是从 HumanOps 到 AutoOps 再到 NoOps 的过程。你将所有的操作和维护工作外包给世界上最好的工程师，所有这些都由公共云服务提供商管理，他们已经构建了许多自动化工具来运行他们的网络，现在他们将服务出售给其他人。这是无服务器时代。

模拟的乐趣

原文：https://towardsdatascience.com/the-joy-of-simulation-9906f1d5c604?source=collection_archive---------54-----------------------

使用蒙特卡罗模拟来设置测试参数和选择算法

统计学家的天堂(照片由约翰·施诺布里奇在 T2 的 Unsplash 上拍摄)

在拥挤的领域中，数据科学中最棘手的问题之一是为一项任务选择正确的方法和工具，这项任务没有“基础事实”来比较不同的选项。我说的“基本事实”是指你试图预测或评估的真实结果的例子。

例如，如果你想知道 ARIMA 和预言家谁更擅长预测冰淇淋销量，你可以选择过去的某个日期，比如说，你卖了 10 个冰淇淋，如果 ARIMA 预测了 4 个，预言家预测了 11 个，你就知道预言家更好，因为它最接近现实，即“基本事实”。简单！好的，通常情况下没有那么容易，但是原理很简单…

但是，如果你想弄清楚是温度还是一周中的哪一天对冰淇淋的销售影响最大呢？或者你卖了多少多冰冰淇淋，因为所有的“天气热，也许买些冰淇淋？”你上周在镇上张贴的海报(看，广告不是我的强项…)？这里你没有“地面真相”,因为你不知道温度和星期到底有什么影响，也不知道你的海报到底有多有效。你所知道的是，不同的方法和软件包会产生对这些值的不同估计，但是要说出这些估计中哪些是好的，哪些是不太可靠的是很棘手的，因为你没有东西可以对它们进行比较(除了彼此之外)。**

那怎么办呢？在这些情况下，一个很好的工具是简单的蒙特卡罗模拟。这些模拟以 20 世纪 40 年代摩纳哥的蒙特卡洛赌场命名，本质上包括构建您感兴趣的任何系统的虚拟版本，然后大量运行各种场景以生成问题的“暴力”解决方案。

因为建立这些模拟通常很简单，通常只需要几行代码就可以实现，一旦概率数学变得困难，通常更容易依靠蒙特卡罗模拟。对于任何经常处理复杂概率问题的人(即任何数据科学家/分析师)，这使他们成为一个无价的工具。

它们对“没有事实根据”的问题有什么用？使用蒙特卡洛模拟，你可以创建一个你正在处理的情况的粗略副本，然后创建你自己的基本事实来比较不同的方法。

总是关闭

这一点很重要(Gif 来自 GIPHY)

让我们用一个例子来说明:假设你是一个统计员，任务是为销售代理销售房地产时使用的销售脚本开发一个测试策略。你掌握的信息是:

销售代理平均每天销售 10 件商品，正态分布，标准差为 4
你的老板今年想要测试大约 50 个想法。考虑到测试的限制，每个测试将按 50:50 的比例进行，每个桶中有 50 个代理
相对于之前的脚本，任何新脚本的提升平均分布在+10%和-15%之间(即任何给定的新脚本都有 40%的机会产生积极影响)

您有四个测试选项:

置信水平为 95%的单尾 T 检验
置信水平为 99%的单尾 T 检验
置信水平为 60%的单尾 T 检验
推出每一个新剧本！

现在，解决这个问题的一个方法是拿出笔和纸，做一大堆代数运算，算出哪种策略是最优的，如果这能让你高兴的话:请便！但是如果你和我一样，你可能会发现建立一个蒙特卡洛模拟更容易，然后让它为你做所有困难的工作。

让我们这样做，运行上面的场景，比方说，500 次，看看我们用每种测试策略得到什么结果。

这可能不是人们所期望的结果。这是怎么回事？要回答这个问题，让我们看一下模拟的单次运行，看看测试的累积影响如何随着时间的推移而演变。如您所见，最宽松的测试标准(置信度为 60%)胜出，因为尽管它做出了相当多的错误判断，但它选择了如此多的获胜者，以至于最终的净效果总体上比其他更严格的测试设置更积极。

关键的一点是，在这个场景中，我们并不试图优化单个测试的结果，而是希望在一个大型测试组合中，最大化正确识别的赢家数量减去错误识别的输家数量。更一般地说，如果一个人正在做大量的测试，他通常可以对任何一个给定测试的结果不太有信心。这也有一个令人高兴的结果，通常意味着一个人可以在每次测试中得到更少的数据，从而可以在可用的时间内进行更少的测试或更多的测试，但是我离题了。

现在，你可能会反对创建广告脚本的人(或在通常的数据科学设置中:产品经理/领导层)很少坦率或能够说出类似“有趣的是，我们实际上 60%的时间都是错误的”这样的话，所以事情可能不像我的例子中那样明确？

然而，蒙特卡洛模拟的美妙之处在于，人们可以非常灵活地看到不同的场景是如何发生的。也许销售线索很弱，你想知道这会如何影响你的测试？也许三等奖是你被解雇了所以你想采取更安全的策略，最大化获得高于某个阈值的结果的概率，而不考虑期望值？或者如上所述，你暗自怀疑新销售脚本的成功率不会那么高？所有这些场景都可以插入到模拟中，以查看它们可能如何实现，通常只需对代码进行小的更改。

建造你的赌场

在构建这些模拟时，您可以自己生成数据，就像我上面所做的那样，创建与您感兴趣的数据分布相匹配的随机数集*。您通常可以用不到 100 行代码构建一个半体面的模拟，当然，您可以根据自己的喜好将这些代码变得复杂。但是，要小心高度复杂的模拟，因为它们会失去一些简单的解释能力，而这种能力使它成为一种有吸引力的工具。

另一种方法是从您感兴趣的系统中获取实际数据，并根据您感兴趣的内容对其进行修改。因此，在上面的示例中，我们将采用实际的销售历史，并根据模拟的测试影响向上或向下调整销售额。这样做的好处是，你可以更加确信模拟与现实相符，坏处是，如果你想了解数据分布的变化如何影响结果，你的控制力会小得多。

*另一个快速题外话:不要假设你所有的数据都是正态分布的，因为当它不是真的时，它会狠狠地咬你一口！例如，大多数销售分布是不正常的，少数销售人员/产品/广告推动了大部分销售。

数据科学家最好的朋友

如果你还没有被说服，喜欢这种方法的另一个原因是，当与利益相关者交谈时，模拟通常更直观。人们可以更容易地谈论所做的假设，为什么某些结果/运行会以这样的方式结束，以及输入假设的变化如何影响结果。我倾向于发现利益相关者比“我做了一船复杂的概率数学，你最好希望我没有搞砸”更容易接受这一点。

我保证我做对了(照片由罗马法师在 Unsplash 上拍摄)

因此，如果您不确定哪个因果影响/提升产品包适合您的特定问题和数据分布，该怎么办？需要检查您的多元回归是否正确地调整了系数？不确定您的算法对不断变化的环境的响应速度有多快？无法确定统计测试是否适用于您的数据分布？给你的老朋友蒙特打个电话。

武装匪徒:强化学习的入门课

原文：https://towardsdatascience.com/the-k-armed-bandit-an-introductory-lesson-to-reinforcement-learning-4d51f5e71fdd?source=collection_archive---------25-----------------------

一个简单的例子很好的演示了 RL 的基本词汇。

指导性和评估性反馈

在监督学习中，你的算法/模型会得到有益的反馈。这意味着它被指示它应该做出的正确选择是什么，然后它更新自己以减少它的错误并使它的预测更准确。在强化学习中，你给出一个算法评估反馈。这告诉你的算法一个动作有多好，但不是最好的动作是什么。行为的好坏被称为奖励。RL 算法通过模拟来学习如何最大化该奖励。

RL 的最佳应用

RL 的最佳应用是当您可以很好地模拟它运行的环境时。如果我们想教一个 RL 程序开车，我们可以让它开车，这将是一个完美的模拟。如果我们想教它在美式足球比赛中叫牌，我们会让它玩一堆 Madden 的游戏，这不是一个完美的模拟，因为我们使用视频游戏来代表现实世界。理解我们如何在这两种情况下设计 RL 算法中的反馈可能相当复杂，因此我将在一个称为 K 臂土匪的简单情况下介绍 RL 的一些基本概念。

K 臂大盗的模拟

图片由龙翔钱从派克斯

想象一下，你在一个有 1000 台老丨虎丨机的房间里，每台老丨虎丨机都是免费供你玩的(这使你成为一个土匪，因为你不会输掉任何钱)。这种情况下，有 1000 个兵种供你拉，那么这种情况下，你就是一个 1000 兵种的土匪。每台吃角子老丨虎丨机都会给你一笔正态分布的支出，每笔支出都有不同的平均值和方差。如果你有无数次拉杠杆的机会，你可以从每台吃角子老丨虎丨机中获得大量样本，找到最大化你的预期支出值的那个，然后一次又一次地拉杠杆。为了让事情变得有趣，假设你有一个 5000 次拉杆的极限。在这种情况下，你会如何优化你的支出？这很难说，你会慢慢实验并发现，因为拉动每个杠杆并记录信息需要时间，这是强化学习机器人的一个很好的应用。

勘探与开发

机器人首先拉动其中一个杠杆。结果是 500 美元，太好了！机器人目前对机器的看法是，它们都支付 0 美元，除了这台支付 500 美元。机器人决定留在这台机器上，等待机器人 1999 年剩余的拉杆。这被称为一种剥削方法，因为 bot 利用其当前对支出的了解。如果机器人决定切换到一台新机器，这将被称为探索性的，因为机器人正在收集如何最大化奖励的信息。剥削策略也被称为贪婪策略。

量化贪婪

相反，你可以建立一个系统，在这个系统中，机器人将总是利用它当前的知识(例如，选择当前支付最大的机器)，但在一定比例的时间里，你随机决定选择另一台机器来拉。这个时间百分比通常用变量ε来表示。ε为 0.1 的机器人会探索 10%的时间，这个机器人比ε为 0.5 的机器人更贪婪，后者只探索一半的时间。然后，你可以用许多不同 epsilon 的机器人来模拟你的环境，以找到最大化回报的最佳 epsilon。然后你可以模仿现实世界中最好的机器人。当单个吃角子老丨虎丨机的支出差异很大时，探索更有帮助。当每台机器每次支付完全相同的金额时(支付的差异为 0)，更贪婪的 epsilon 是首选。在第一次拉动控制杆之前，由于对所有机器有着完美的了解，epsilon 为 0 的机器人是最好的，因为它已经知道最好的机器，并且探索没有任何好处。

乐观的期望

即使在贪婪的机器人中，鼓励探索的一个好方法是改变机器人对它没有尝试过的机器的期望。早些时候，我将我们的机器人描述为，如果机器上没有任何信息，它的预期支出为 0 美元。我们可以改变这一点，使最初的期望是一台机器有 25 美元的支出。现在，如果我们第一次拉动杠杆，我们有 5 美元的支出，即使是贪婪的机器人也会想切换到另一台机器，因为另一台机器会使回报最大化。

支出漂移

以前，我们的机器人会跟踪每台机器的平均奖励，除非被随机告知要探索，否则就会拉走那台机器。如果每台机器的支出随着时间的推移开始变化，这意味着其正态分布的平均值增加或减少，有两种简单的方法来调整我们的机器人。首先是探索更多，所以只要选择一个更大的ε，我们就可以改进机器人。这不需要你修改任何代码，只需要重复模拟并挑选出新的最佳机器人。一个更好的方法是，我们可以制作一个线性回归模型，显示机器支出如何随着时间的推移而变化，而不是将我们关于机器的信息仅仅保存为平均值和方差。这将阻止贪婪的机器人利用不再有最高支付的机器。

强化学习中的 K-bandit 问题

原文：https://towardsdatascience.com/the-k-bandit-problem-with-reinforcement-learning-440b2f3ddee0?source=collection_archive---------30-----------------------

强化学习的基本概念

图片来自 Pixabay

强化学习中的基本问题

强化学习中一个非常重要的部分是如何评估代理执行的动作。在本帖中，我们将使用 K-bandit 问题来展示评估这些行为的不同方法。重要的是要记住，K-bandit 问题只是许多强化学习情况的一个简单版本。这很简单，因为代理执行的操作是单独评估的，不像其他技术那样，评估是在一系列操作上完成的。

K-bandit 问题

想象一下，你在一个被 4 台不同的老丨虎丨机包围的赌场里。每台机器根据不同的概率法则给你不同的奖励。你的工作将是最大化这些机器给你的奖励，并发现哪一台机器有更好的奖励。你将通过在机器上试验和玩一千次来做到这一点！奖品和获得这些奖品的概率不会随着时间而改变。

你会使用什么策略来最大化奖励和发现最好的机器？也许第一种方法是在机器上玩相同的次数(每台 250 次)。然而，在给我们更好奖品的机器上玩得更多不是更好吗？如果我们选错了机器怎么办？

正是因为这些问题，我们需要协调我们的行动。有时探索会更好(尝试在不同的机器上玩)，有时利用我们的知识会更好(在我们认为最好的机器上玩)。

图片来自 Pixabay

在我们继续解决这个问题之前，我将介绍一些贯穿整个问题的符号:

在时间 t 执行的 Aₜ=The 动作。(在示例中，这将是机器
在第 t 步获得 Rₜ=The 奖
q∫(a)=执行行动 a 时的预期奖励，数学上是:

期望奖金 q∑(a)是这个问题中最重要的值，因为如果我们发现它的真实值，我们就知道应该一直在哪个机器上玩。通常这个值是未知的，这就是为什么我们需要在不同的机器上探索(玩)来估计期望值。随着时间的推移，我们将得到期望值的更好的近似值(如果我们可以无限地玩下去，我们将得到精确的值)。近似值使用的符号是 Qₜ(a).这是对时间 t 时 a 的期望值的估计。

估计代理行动的期望值

有许多方法可以估计行动的期望值(Qₜ(a)).这里我们将使用对我来说最自然的方法。该方法将执行某个动作获得的所有奖励相加，这将出现在分子中，并将除以该动作执行的次数:

借助于这个方程，随着时间的推移，Qₜ(a 的值将更接近于 q∑(a ),但探索和利用不同的可能行动将是很重要的。在本文中，ε-贪婪方法将被用来探索。这是一个非常简单的方法，因为我们唯一要做的事情就是选择一个被计算为更好的选项，但是有一定的概率(ε)随机尝试不同的动作。所以我们假设ε=.1 成立，那就意味着时间上一千步，会选择 900 次最佳选项(exploit)，做 100 次探索。

使用 Python

既然已经定义了问题并描述了解决问题的方法，我们将使用 python 来解决它。所以是时候打开你最喜欢的 IDE 开始编码了！我将一段一段地描述和解释代码，并将它完整地放在最后。你可以完全复制它，如果有疑问，检查具体的作品。对于这个程序，我们将只使用两个库，因此我们将继续导入它们:

###Import necessary libraries
import random as rd
import numpy as np

第二步是创建两个辅助函数。第一个辅助函数将帮助我们模拟概率结果。这个函数将抛出一个介于 0 和 1 之间的随机数。如果随机数的结果低于我们定义的数，函数将返回 true，否则将返回 false。

###Define a random number in the interval [0,1] to simulate results of
###probabilistic experiments.
def decision(probability):
return rd.random() < probability

第二个函数是ε-贪婪算法，它将决定在哪个机器上玩。它可以是期望值最高的机器，也可以是随机的机器。

### Choose which machine to play following the E-greedy method.
def greedy(no_machines,probability):
aux=decision(probability)
if(aux==True):
index=rd.randint(0,len(no_machines)-1)

else:
index=np.argmax(no_machines)
return index

为了测试不同的想法，我们将多次执行该算法。在这种情况下，我们将为每个循环播放 1000 次，重复循环 10000 次，并尝试ε=[0，. 05，. 1，. 15，. 2，. 25，. 3，. 35，. 4，.. 45，.. 5]。这样我们就会知道我们应该对我们的知识有多贪婪。让我们首先定义有助于实验的变量。

### This variable holds the real probability of winning that each machine has.
### This variable is unknown to the player and it is what we'll try to estimate. 
prob_win=[.8,.85,.9,.7]
### We will try different epsilons to see which one is better. 
epsilon=[0,.05,.1,.15,.2,.25,.3,.35,.4,.45,.5] ###Variables that hold the total for each different simulation(E=(0,.1,.2,...).
p_total_reward=[]
p_chosen_machine=[]

鉴于问题 3 的结构，循环是必要的:

第一个循环将用于遍历所有ε=[0，. 05，. 1，. 15，. 2，. 25，. 3，. 35，. 4，. 45，.. 5]。
第二个循环在每个游戏中都有 10，000 个循环。
第三个循环进行了 1000 次。

代码:

for j in range(len(epsilon)):
    ### Here the evolution of the algorithm can be seen. This variable shows
    ### the evolution of the average prize. With the average prize the performance
    ### of the algorithm is shown.
    average_prize=[]
    ###Variable that holds the total prize for each iteration.
    total_reward_acum_g=[]
    ###At the end of each cycle we will choose the machine that has the highest
    ###expected prize and save it in this variable.
    chosen_machine_g=[]
    for x in range(10000):
        ###The algorithm will be tested many times to see it's performance
        ### variable that indicates the prize by playing 1000 times.
        total_reward=0
        ### Number of times played
        i=0
        ### Númber of times played over each machine.
        iteraciones_por_accion=[0,0,0,0]
        ### The expected prize over each machine. The value is started at 10
        ### so that initially all machines are tested.
        expected_prize_action=[10,10,10,10]
        for x in range(100):
          ###Index is the machine that was chosen to play with
          index=greedy(expected_prize_action,epsilon[j])
          ###Esta parte emula si ganaste o perdiste   
          res=decision(prob_win[index])
          if (res==True):
              g=2
          else:
              g=1
          ###Total reward   
          total_reward=total_reward+g
          i=i+1 
          #Total average prize
          average_prize.append(total_reward/i)
          ###Number of times played per machine.
          iteraciones_por_accion[index]=iteraciones_por_accion[index]+1
          ###Update the value of the expected prize
          expected_prize_action[index]=(expected_prize_action[index])+(1/iteraciones_por_accion[index])*(g-expected_prize_action[index])
        ###results after playing 1000 times
        total_reward_acum_g.append(total_reward)
        chosen_machine_g.append(np.argmax(expected_prize_action))
    print(epsilon[j])
    print("On average "+str(sum(total_reward_acum_g)/len(total_reward_acum_g))+" points were obtained.")
    print("The machine was chosen correctly " +str(chosen_machine_g.count(np.argmax(prob_win)))+" times.")
    p_total_reward.append(sum(total_reward_acum_g)/len(total_reward_acum_g))
    p_chosen_machine.append(chosen_machine_g.count(np.argmax(prob_win)))

最后，我们将使用 matplot 库在绘图中可视化结果。

import matplotlib.pyplot as plt
values=p_total_reward
values2=p_chosen_machine
eje_x=epsilon
eje_x[-1]
fig, ax = plt.subplots(figsize=(20, 14)) 
plt.xticks(rotation=90)
plt.plot(eje_x,values , marker ="o",label = "Average Total Prize");

ylabels = ['{:,}'.format(int(x)) + "K" for x in ax.get_yticks()*(1/1000)]
plt.legend(prop={'size': 24})
plt.title("Figure 1", fontdict=None, loc='center', pad=None,fontsize=18)
plt.xlabel("Epsilon", fontdict=None, labelpad=None,fontsize=18)

观察“图 1 ”,我们认识到当我们设置ε=0.15 时，达到最大奖励

这意味着 15%的时间用来探索是方便的，其余 85%的时间是贪婪的。现在，对于问题的第二部分，我们要求算法告诉我们它认为哪台机器最好。让我们也用图表来看看这个:

import matplotlib.pyplot as plt
valores2=p_chosen_machine
eje_x=epsilon
eje_x[-1]
fig, ax = plt.subplots(figsize=(20, 14)) 
plt.xticks(rotation=90)
plt.plot(eje_x,values2 , marker ="o",label = "Númber of times the best machine was chosen correctly");
#plt.plot(x, y, marker ="o", label = "Modelo Atribución");
ylabels = ['{:,}'.format(int(x)) + "K" for x in ax.get_yticks()*(1/1000)]
plt.legend(prop={'size': 16})
plt.title("Figure 2", fontdict=None, loc='center', pad=None,fontsize=18)
plt.xlabel("Epsilon", fontdict=None, labelpad=None,fontsize=18)

图 2 向我们展示了，随着探索的深入，算法倾向于更准确地选择最好的机器。这是一个显而易见的结果，因为有了更多关于不同机器的信息，我们就能更好地选择。然而，这伴随着一个奖励，因为做更多的探索伴随着降低奖励的成本。

更进一步

本文只是对 k-bandit 问题的初步探讨，所以对于感兴趣的读者，我想留下一些问题供您思考:

如果我们玩 100 次而不是 1000 次，ε的结果会不同吗？
如果这些机器给出的奖品大相径庭，ε会有什么变化？
随着时间的推移，改变ε是否方便？
这三个问题有什么联系？

非常感谢您的关注，希望能再次见到您。您可以提前找到并运行代码。

原载于 2020 年 9 月 22 日【https://datasciencestreet.com】。

高效数据科学团队的关键要素

原文：https://towardsdatascience.com/the-key-elements-of-effective-data-science-teams-468676b16440?source=collection_archive---------40-----------------------

组建数据科学团队时要考虑什么

马文·迈耶在 Unsplash 上的照片

T 这里有很多关于数据科学技术的博客、文章和文献，但是关于如何建立一个数据科学团队的却很少。需要什么样的技能？它们应该如何组合在一起？谁应该做什么？在这篇博客中，我将勾勒出数据科学体系的关键要素，介绍一些角色，并概述他们是如何协同工作的。

在这种情况下，我将谈论将算法构建到软件中的数据科学团队，因此必须担心代码性能、稳定性、操作等。这不适用于从事分析或统计的数据科学家，他们的算法可能同样复杂，但结果更多的是一个决策、报告或仪表板。

认真对待这一点，但不是字面意思

诸如“产品经理”、“工程师”和“数据科学家”等术语并没有一致定义的含义，所以如果你正在阅读这篇文章，并且发现自己在想“等等，那不是数据科学家的工作！”那么请容忍我。这与需要(比如说)编写单元测试以确保代码稳定的人的职称关系不大，更多的是指出有人需要这样做，而当有人这样做时，他们不能做其他事情，比如模型开发或特性探索。

此外，我并没有暗示任何类型的组织设计。组织数据科学项目团队的方式有很多种，从 Spotify 倡导的团队模式到更传统的垂直模式，在这种模式下，所有这些角色都将汇报给一个整体领导。“正确的”设置将是组织文化、资源、成熟度和当地限制的函数，虽然我在这里确实有一些意见，但我会留到下次再说。

在我们开始之前…

“产品”

Peter Kasprzyk 在 Unsplash 上拍摄的照片

在这里，我将我们为之构建算法的软件称为“产品”。产品很少由单一算法驱动，而是由许多算法、业务规则、用户界面、API 等构建而成。例如，假设我们正在构建一个工具来优化城市中的出租车路线。这可能由许多要素组成:

匹配算法，用于选择将哪些客户链接到哪些驱动因素
将客户送到目的地，将司机送到客户的路线算法
位置推荐算法向司机指示客户可能在何时何地
定价算法，为客户和司机设定可接受的价格
一个 API，用于向应用程序或桌面设备实时提供上述所有服务

现在，不是所有这些都必须在同一个产品中。我的观点是，大多数数据科学驱动的产品涉及多个算法和组件一起工作，因此人们必须比优化单个算法或函数考虑得更广泛。

利益相关者

在我们进入团队之前，有一个重要的人群我们需要谈论:利益相关者。他们以各种形式出现:客户、执行领导、其他内部团队，甚至其他数据科学家。本质上，利益相关者是任何你想影响或想影响你的群体。

现在你可能在想:真简单！是我们在为谁构建算法！但这将是一个幼稚的错误。任何大规模的数据科学项目都有一系列的利益相关者，正确理解他们是谁，他们想要什么，以及他们有(或应该有)多大的影响力对于任何数据科学或其他产品的成功都是至关重要的。

例如，回到我们的出租车路由产品，谁是你的利益相关者？很明显的两个是:

那些想快速便宜地从一个地方到达另一个地方的顾客，你想让尽可能多的人使用你的产品
出租车司机谁想要尽可能多的顾客，而不需要太多的驾驶，你又想吸引谁使用产品

但就这样吗？嗯，不太可能。假设你在周一发布了你的路由产品的第一个版本后查看了你的电子邮件，你看到更多的利益相关者进入了你的视野:

市场部负责人希望你确保晚上的等待时间低于 2 分钟，因为这是他们刚刚在一场昂贵而高调的广告活动中承诺的
财务团队希望了解如何最大限度地减少燃料支出，以保持成本和碳排放不高于他们需要的水平
首席执行官想知道为什么你的产品让他们昨晚在雨中站了 30 分钟等出租车(是的，这种事情确实会发生！)

欢迎加入您的利益相关者网络！这些人/群体中没有一个可以被完全忽视，但很可能他们也不能得到他们想要的一切。那么，如何权衡所有这些利益相关者之间的利益呢？这让我们很好地认识了我们的第一个团队成员…

见见团队

产品管理

凯利·西克玛在 Unsplash 上的照片

他们是球队的四分卫，或者是队长，如果你喜欢英式足球胜过美式足球的话。他们负责确保团队在正确的时间做正确的事情，并管理涉众需求的复杂网络。

首先，它们作为一个分流点。企业通常是快速移动的环境，有大量直言不讳的利益相关者:将团队直接暴露在这种环境中会极大地分散注意力。产品管理做的重要工作是找出哪些涉众要求立即处理，哪些可以等待，以及谁应该做这项工作。后一部分对机器学习/人工智能尤其重要，因为它们是每个人都想使用的大肆宣传的技术。根据我的经验，至少有一半的人工智能解决方案可以通过更普通的方法得到更好的解决，例如改善用户界面、分析或数据工程。

接下来，他们从涉众那里获取广泛的、非结构化的请求，并将它们划分为离散的任务，供团队消化和处理。利益相关者不知道算法&代码的内部工作原理，所以只能指出他们不喜欢或觉得应该添加的产品方面。将这些宽泛的要求转化为有意义的具体改变，与所有其他活动部分协同工作，并完全满足阐明的需求是范围界定的微妙艺术。这是一个困难但至关重要的角色，做好它对产品的健康至关重要。根据我的经验，大多数项目失败都是范围失败。

最后，伟大的产品经理不仅仅是香肠工厂，他们接受利益相关者的混合要求，生产出优先的、有范围的工作，而且对产品应该如何发展有他们自己的愿景。你可能会对“愿景”这个老生常谈的术语嗤之以鼻，但能够提前思考并说“这是这个产品应该成为的”，以一种实际上让人们想起床并让它发生的方式，是成功的关键因素。没有愿景，产品往往会变成不同利益相关者群体希望产品成为什么样的弗兰肯斯坦怪物，做了一堆可以接受的事情，但没有一个是出色的。一个很好的测试是，如果你清除了来自涉众的所有请求，你还能清楚地看到你想做什么吗？

数据科学

在 Unsplash 上由 Ousa Chea 拍摄的照片

你可能会感到惊讶，我用了近 1000 个单词来介绍数据科学家。虽然我可能应该为此道歉，但我不会，因为它说明了在开始编写代码之前需要做多少仔细的思考。

他们的首要职责是选择正确的算法目标。例如，我们的出租车路线应该旨在最大化出行次数、客户数量、给定出租车的总收入，还是其他？一些顾客或旅程是否比其他顾客或旅程更重要(如夜间的女性顾客)？虽然一开始目标可能看起来很简单，但对于任何问题，都有大量可能的目标，仔细选择正确的目标是数据科学家角色的关键部分。

一旦定义了目标，这自然会导致数据科学家如何根据该目标评估准确性。同样，这可以采取多种形式，我们的出租车数据科学家可以选择行程长度预测的平均误差，可以是绝对值(这将使算法专注于较长的行程)，也可以是实际行程时间的百分比(这将使算法专注于较短的行程)。此外，在开始之前预先声明正确的准确性标准是很重要的，以避免不谨慎的方法，即只生成大量的统计数据并挑选看起来最好的。

对于任何给出好结果的算法来说，训练数据必须被仔细管理。算法经过训练，可以反映我们提供给它们的数据中存在的模式和关系，因此对训练数据考虑不周可能会给数据科学产品带来真正的问题。例如，如果我们的路线训练数据集只从私人车辆中生成，并且我们正在为可以使用公交车道的出租车设计一种算法，我们可能会设置正确的目标，并在拒不接受的样本上获得很高的准确性，但在现场的结果很差。

最后，算法接近，包括模型选择、设计和特征工程。这些是数据科学的支柱，也是花费大部分时间的地方。已经有很多关于这个主题的文献，所以我不会在这里补充，除了指出一个经常被忽略的点:通过思考你需要你的模型输出有多稳定是很重要的。例如，如果我们的路由模型在您每次询问从 A 地到 B 地的路线时给出了稍微不同的路线，这可能不是问题，但是如果我们的定价算法在您每次询问相同的问题时给出了不同的价格，这将会给您带来很多问题！

一旦我们有了一个算法，是时候把它展示给一些用户了，为此我们需要…

工程

照片由穆里洛·席尔瓦在 Unsplash 上拍摄

真正伟大的数据科学产品只能建立在伟大工程的基础上。你的数学可能是完美的，但是如果模型有一半时间是坏的或者充满了错误，那么它就没有多大用处。因此，工程是至关重要的角色，扮演着许多角色。

在理想的情况下，训练和构建模型所需的数据应该已经存在，格式简洁，所有相关属性都存储在一个易于访问的数据集中。遗憾的是，数据天堂总是遥不可及，因为即使在最好的数据环境中，数据需求也会随着业务和环境的发展而不断变化。因此，你将需要在数据创建方面的工程帮助。这可能涉及检测工作、ETL 创建(尤其是对于大型数据集)以及围绕经济高效的存储和检索解决方案的创造性的合理组合。

一旦你有了数据和模型，你就需要把它们串成一个软件，在需要时可以可靠地执行，或者用行话来说，串成一个“数据管道”。这可以是简单的每周“批处理”运行，将一个小文本文件放入共享文件夹，也可以是涉及大量复杂数据的大规模实时“流”管道。此外，如果算法输出被另一个服务(例如，一个应用程序)消费，那么可能需要进一步的工程设计，以确保数据管道符合消费它的服务的标准。

最后，一旦这些都完成了，接下来就是操作。系统是否在需要时启动并运行？所有下游组件和数据集都是正确的和最新的吗？输出有意义吗？让这艘船以人们可以依赖的方式运行可能不是数据科学中最性感的部分，但你离不开它。现在，我的任何工程同事读到这里都会对良好的操作只是他们的工作这一观点表示惊讶，他们是对的:这是每个人的工作。但是工程通常是分析和分类错误，并在系统中建立弹性的第一道防线。

分析学

由斯蒂芬·道森在 Unsplash 上拍摄的照片

最后，任何大规模数据科学驱动的产品都会产生问题:产品是否满足其目标？我们怎么知道新版本的算法比旧版本的好？算法在特定场景下的响应如何？回答这些问题是分析的工作。

首先，任何数据科学驱动的产品都是围绕特定的目标构建的，这些目标通常与算法目标相关联，但通常可以更广泛。例如，我们的出租车路由产品可能有一些目标，比如一定数量的客户或收入。跟踪产品相对于目标的表现，并解释超出或低于表现，是一个关键的分析角色。

接下来，任何产品都会从利益相关者群体那里产生几乎无限数量的问题。我们的出租车路线有多省油？不同城市的等待时间有什么不同？我们是否对不同的客户群服务过度或不足？虽然其中一些需要数据科学家挖掘算法的精髓，但在大多数情况下，并不需要深入的算法知识，您最好利用分析师的快速查询&数据可视化技能。

没有一个产品一开始就很棒，要真正击败竞争对手并保持领先地位，测试是至关重要的。网站和应用程序通常可以享受随机 AB 测试，但即使没有随机 AB 测试，拥有良好统计知识的创造性分析师也可以找到方法来设计测试，以确认一个惊人的想法或新算法功能确实是它所希望的一切。

将这一切结合在一起

乔希·卡拉布雷斯在 Unsplash 上拍摄的照片

我按照利益相关者>产品经理>数据科学家>工程师>分析师的顺序介绍了团队，虽然这有一定的道理，但实际上所有团队成员都需要在某种程度上参与项目生命周期的所有部分。如果不了解数据科学，产品经理就无法设计出正确的解决方案，数据科学家需要构建能够在给定工程现实的情况下实际运行的算法，而工程人员在构建基础设施时需要密切关注产品目标。

最重要的是，共享成功和相互合作的文化对于团队的高效运作至关重要。胜利需要所有团队成员共享，而问题需要整个团队深思熟虑才能解决。如果道路上的坎坷遭遇指责，那么你会很快发现问题被隐藏起来，做出决定是为了保护自我，而不是推动结果。最终，客户和利益相关者不会关心到底是谁搞砸了或部署了这个或那个特性:他们只是看到一个产品要么做了要么没有做他们想要的。

构建一个伟大的算法是困难的，但构建一个伟大的数据科学产品可能是彻头彻尾的恶魔。我提供的大纲应该能让你看到一些关键的部分，这些部分需要到位，这样你才有机会争取。一个好的团队结构不会保证你成功，但是一个坏的团队结构会保证你失败。

创建协同过滤音乐推荐系统的关键

原文：https://towardsdatascience.com/the-keys-building-collaborative-filtering-music-recommender-65ec3900d19f?source=collection_archive---------9-----------------------

西蒙·诺在 Unsplash 上的照片

接下来该放哪首歌？

“ …

哦，我是个幸运的人，

用双手去数我爱的人

[…。】

跟我在一起，

我们深呼吸

…”—我开始喃喃自语我最喜欢的一首歌

我仍然记得在音乐会上唱过这首歌。

尽管这不是我的第一场演唱会，但这是我用第一份工资全额支付的第一场演唱会。

大概是我在写关于基于内容的推荐系统的时候想到了这个问题。

从广义上来说，推荐器(或推荐)系统(或引擎)是一个过滤系统，其目的是预测用户对一个项目的评级或偏好:在我们的例子中是一首歌。

在推荐系统中，最常用的是基于内容的过滤器和协同过滤器。

基于内容的方法基于两首歌曲内容或属性的相似性给出推荐，而协作方法使用不同歌曲的评级矩阵来预测可能的偏好。

我们有兴趣了解 协同过滤器 是如何工作的。该算法的目的是学习一个可以预测用户是否会从某个项目中受益的函数——这意味着用户可能会听一首歌。

为此，这种类型的过滤仅依赖于用户对一组歌曲的历史偏好。

1 答案是我们在日常生活中使用的东西:评级。

收集用户评分有两种方式。

第一种是通过使用明确评级，这意味着我们明确要求用户给出一个评级。这代表了来自用户的最直接的反馈，以显示他们有多喜欢一首歌。

第二种采用隐性评级；例如，我们检查用户是否听了一首歌，听了多长时间或多少次，这可能表明他/她喜欢那首特定的歌。

这些评级可以转化为二进制(用户听或不听一首歌)，离散(1 到 5 颗星)，或某人听一首歌的次数，或连续数字(用户听一位艺术家的总时间)。

收集评级后，我们可以生成互动矩阵。

交互矩阵基于许多条目，包括用户-歌曲对以及代表用户对该歌曲的评级的值。

用户给特定的歌曲评级

一般来说，这些相互作用矩阵是巨大的(百万行百万列)，非常稀疏并且充满了缺失值。为什么？因为大多数项目没有被特定用户看过或评价过。

显示每个用户对特定歌曲的评价的矩阵。

在我们的例子中，我们将使用 百万首歌曲数据集 ，这是一百万首当代流行音乐曲目的音频特征和元数据的免费集合。

有两个文件会让我们感兴趣。

第一个文件给出了关于用户 ID、歌曲 ID 和收听次数的信息。我们可以从static.turi.com/datasets/millionsong/10000.txt开始读。

第二个文件将包含歌曲 ID、歌曲标题和艺术家姓名。我们可以从static.turi.com/datasets/millionsong/song_data.csv开始读

合并这两个文件后，我们最终得到一个数据集，其中包含 200 万个观察值，9567 首不同的歌曲和 76353 个不同的用户。

我们将使用listen_count，用户听一首歌的次数作为一个隐含的评级。

做一些探索性分析，我们可以发现用户平均听 26 首歌曲，平均听 16 首歌曲。

我们可以很快看到，并不是所有的用户都听所有的歌。所以song x users矩阵中的很多值都将为零。因此，我们将处理极其稀疏的数据。

处理这样一个稀疏矩阵，我们会占用大量的内存和资源。为了让我们的生活更容易，让我们只选择那些已经听了至少 16 首歌曲的用户。

我们现在需要使用scipy-[sparse matrix](https://en.wikipedia.org/wiki/Sparse_matrix)来避免溢出和内存浪费。为此，我们将使用scipy.sparse中的[csr_matrix](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csr_matrix.html)函数。

首先，我们将根据来自作为索引的song_id和作为列的user_id的唯一值来重塑数据，以形成作为结果的DataFrame 的轴。

然后，我们将使用函数 pivot 生成一个透视表。然后，我们将把这个表转换成一个稀疏矩阵。

正如我们可以观察到的，许多值等于零。这表明用户没有听过该歌曲。

2那么，协同过滤器是如何向特定用户推荐歌曲的呢？有两种主要方法可以做到这一点。

它找到具有相似兴趣和行为的用户，并考虑这些相似用户所听的内容，然后做出推荐。这种技术被称为 基于用户的方法 (或用户项目)。

或者它可以考虑用户过去考虑过什么歌曲，并推荐用户可以欣赏的新的类似歌曲；一种技术叫做 基于项目的方法 (或项目-项目)。

3协同过滤器用什么算法推荐新歌？有几种机器学习算法可以用于协同过滤的情况。其中，我们可以提到最近邻、聚类和矩阵分解。

让我们来看看它们。

K-最近邻(kNN) 被认为是基于用户和基于项目的协同过滤方法的标准方法。

在我们研究这个算法在推荐系统中的具体应用之前，我们将解释 kNN 是什么。

kNN 算法是一种监督的非参数惰性学习方法，用于分类和回归。

监督因为它需要标记的数据点才能工作。

非参数因为它不对数据分布做任何假设。

懒是因为没有使用训练数据点做泛化；它被延迟到测试阶段。

这种算法是基于特征相似性的——我们可以开始看看它可以用于推荐系统的什么东西。

它基本上假设相似的东西彼此靠近。在这里距离再次测量两点有多相似或“接近”。

想象一下，我们必须将一个数据点分为两类。

我们有两个属性来描述不同的点。如果我们在 x-y 图中表示点及其属性，它看起来会像这样:

现在，kNN 算法如何知道这个新点属于黄色还是绿色类别？

首先，它会查看它的 k 最近邻居。然后，它将通过在这些 k 点中投票选出最受欢迎的类来确定该点应该具有哪个类。

让我们来看看实际情况。如果在我们的例子中 k = 5，我们需要取 5 个最近的邻居如下:

因此，我们有 3 个点属于绿色类，2 个点属于黄色类。所以我们的新数据点被归类为绿色。

注意这里。k 的选择非常重要，因为在我们的情况下，如果我们设置 k=3，新的数据点将被分类为黄色。

当我们使用 kNN 对一首歌曲进行预测时，该算法将计算目标歌曲与数据集中每首其他歌曲之间的距离。

然后，它会根据它们的距离进行排序。最后，它将返回前 k 首最近邻歌曲作为歌曲推荐。

让我们使用Python 3.7建立一个推荐系统，它依赖于 k 个最近邻居来推荐歌曲。

为此，我们将创建一个名为Recommender的类。我们不会在这里描述整个类，相反，我们将关注它内部的主要函数。

我们将使用scikit-learn中的NearestNeighbors方法。这种方法需要几个我们应该仔细选择的参数。

度量:要使用的距离度量。我们将使用cosine
算法:用于计算最近邻的算法。我们将使用一个brute强制算法。
n_neighbors: 用于查询的邻居数量。我们要用20。记得我们之前提到过，这个参数非常重要。

我们还需要使模型符合数据。为此，我们将使用之前获得的稀疏矩阵。

现在，我们可以使用这个拟合的模型来推荐新歌。

我们如何做到这一点？我们只需要输入歌曲并从歌曲中获取kneighbors。该模型的这个属性还告诉我们，我们的歌曲与推荐的歌曲有多接近，从而允许我们对它们进行排序。

因为系统将输出歌曲的 id，而不是标题，所以我们将创建一个函数，将这些索引与歌曲标题进行映射。

如果我要做推荐，我们就不会有id。我们只知道标题。而且有时候这个名字的写法不一样。

我们如何解决这个问题？克服这一点的方法是将新歌曲的字符串与数据集中所有歌曲的字符串进行近似匹配，并确定它们的相似程度。

如果我们找到一首相似的，我们就选这首歌。

我们将使用一种叫做模糊匹配的普通技术来完成这项工作。我们将使用库[fuzzywuzzy](https://pypi.org/project/fuzzywuzzy/)。

这个方法使用 Levenshtein Distance ，它测量将一个单词序列更改为另一个单词序列所需的最少编辑次数。这些编辑可以是插入、删除或替换。

我们现在已经有了我们的推荐系统。所以是时候用了。

我们首先需要创建一个字典，根据歌曲的 id 对歌曲标题进行解码。这将被传递给推荐者。

然后，我们将推荐歌曲I believe in miracles。让我们看看我们有什么！

这种方法有一些限制。它没有很好地处理稀疏性，并且当我们有更多的用户或歌曲时，它的计算效率不高。

为了克服这些限制，我们可以使用其他方法，如矩阵分解。

矩阵分解是一种实现推荐系统的强大方法。其背后的思想是在一个低维的潜在空间中表现用户和物品。

因此，换句话说，矩阵分解方法将原始的稀疏用户项矩阵分解成具有潜在特征的较低维度的稀疏矩形矩阵。

这不仅解决了稀疏性问题，而且使该方法可扩展。不管矩阵有多大，你总能找到更低维度的矩阵，它们是原始矩阵的真实代表。

但是什么是潜在特征呢？为什么它对推荐系统有意义？

想象一下，一个用户给了下面几首歌很好的评价:通往地狱的公路(AC DC)* ，野兽的数量，，【铁娘子】，水上烟(深紫色)。*

我们可以把它们看作三个独立的等级。然而，如果我们的目的是找到一种更简单的方式来表达他们的偏好，我们可以说他们喜欢硬摇滚 T2。

Hard Rock是一个的潜在特征。它们是通过更高层次的属性来表达的，而不是具体的歌曲。

矩阵分解将告诉我们一个用户与一组特征有多少关联，以及一首歌有多少属于这组潜在特征。

这提供了一个优于其他协作过滤的优势:尽管两个用户没有评价过任何相同的歌曲，但如果他们共享相同的潜在特征，我们仍然可以找到他们之间的相似性。

在不同的矩阵分解技术中，我们发现了流行的奇异值分解(SVD)* 。*

当我们深入研究数学基础时，这可能是一个抽象的概念。但是我们会尽量保持简单。

假设我们有一个矩阵 A，包含 n 个用户 x m 首歌曲的数据。这个矩阵可以唯一地分解成 3 个矩阵；姑且称之为 U 、 S 和 V 。

就我们的歌曲推荐者而言:

- U 是一个 n 用户 x r 用户潜在特征矩阵

- V 是一个 m 歌曲 x r 歌曲-潜在特征矩阵

- S 是一个包含原矩阵奇异值的 r x r 非负对角矩阵。

奇异值表示特定特征在预测用户偏好中的重要性。

**对角矩阵是主对角线外的元素全为零的矩阵。

单值分解:任何 n×m 维的矩阵 A 都可以分解成三个矩阵 U，S，v。

这三个矩阵非常容易处理。此外，将它们相乘会给我们返回原始矩阵 A 。

我们以前研究过这些数据。我们知道一个用户平均听 26 首歌。经过进一步的探索，我们发现一首歌平均有 200 个用户在听，最少 48 个，最多 8277 个。

所以我们已经知道它是一个非常稀疏的矩阵。为了让我们的生活更轻松，让我们进一步过滤数据。我们将只选择那些至少被 200 个用户听过的歌曲。

我们将应用宁滨技术，而不是像现在这样使用隐式评级。

我们将定义 10 个类别。落在从 0 到 1 的区间内的原始数据值将被代表等级 1 所取代；如果它们落入 1 到 2 的区间，它们将被 2 所取代；诸如此类。最后一个类别将被赋予范围从 9 到 2213 的原始值。

现在让我们尝试采用矩阵分解的方法，使用 Python 3.7 和一个名为surprise的有趣库来推荐歌曲。

惊喜是一个简单易用的 Python 库，专门为推荐系统设计。要安装惊喜，我们只需运行:pip install surprise。

运行推荐系统所需的软件包。

为了从我们的DataFrame加载数据集，我们将使用load_from_df()方法。

我们需要传递以下参数:

df —包含歌曲评级的数据帧。它必须有三列，分别对应于用户 id、歌曲 id 和收视率。
阅读器([**Reader**](https://surprise.readthedocs.io/en/stable/reader.html#surprise.reader.Reader))——一个阅读文件的阅读器。只需要指定**rating_scale**字段。

我们将为 SVD 使用内置函数。值得注意的是，这种实现(由西蒙·芬克在网飞奖期间推广)将一个矩阵分解为另外两个矩阵，然后使用梯度下降来寻找特征和权重的最佳值。

严格来说，这不是上面解释的数学 SVD。

相反，该算法将原始矩阵分解为两个低维矩阵的乘积。

第一矩阵具有包含与每个用户相关联的潜在特征的行。第二个具有包含与歌曲相关联的潜在特征的列。

首先，我们需要为我们的模型找到最适合我们现有数据的参数。

在交叉验证过程中，[GridSearchCV](https://surprise.readthedocs.io/en/stable/model_selection.html#surprise.model_selection.search.GridSearchCV)类将根据所选的参数组合为SVD算法计算准确性指标。这对于找到预测算法的最佳参数集非常有用。

cross_validate将为我们在网格搜索中找到的最佳估计值运行交叉验证程序，并报告准确性测量和计算时间。

这种方法使用KFold作为交叉验证技术。

找到模型的最佳参数后，我们可以创建我们的最终模型。

我们可以使用方法fit()在训练集中训练算法，然后使用方法test()返回从测试集中获得的预测。

现在，我们可以得到用户对特定歌曲的评价:

这个模型现在可以使用了！

如果您想了解代码的更多细节，可以看看我在 GitHub 中的 repo:

* [## UGIS 22/音乐 _ 推荐者

一个推荐系统(或引擎)是一个过滤系统，其目的是预测一个评级或…

github.com](https://github.com/ugis22/music_recommender)

如果您好奇并渴望阅读更多内容，请阅读以下资源:

Thierry Bertin-Mahieux、Daniel P.W. Ellis、Brian Whitman 和 Paul Lamere。
百万首歌曲集。《第 12 届国际音乐信息检索会议论文集
》(ISMIR 2011)，2011 年。

k 近邻算法。

基于 Python 的推荐系统——第二部分:协同过滤(K 近邻算法)

尺度模糊匹配

在 PyTorch 中构建概率矩阵分解的音乐推荐引擎。

基于 Python 的推荐系统——第三部分:协同过滤(奇异值分解)

人工智能-全合一。第 16.3 讲和第 16.4 讲。*

使用 gif 的动力学数据集浏览器

原文：https://towardsdatascience.com/the-kinetics-dataset-explorer-using-gifs-8ceeebcbdaba?source=collection_archive---------33-----------------------

使人类更容易筛选动力学数据集

动力学数据集浏览器是一个网站，包含转换为 GIF 格式的动力学视频。使人们更容易快速筛选大量时态数据。生成的 gif 来自以比原始视频更低的频率采样的帧，即 4 fps 对 25 fps，并且得到的帧速率被调整为 16 fps。这意味着一个 10 秒的视频可以在大约 2.5 秒内被观看。宽度和高度也按比例缩小，以减小文件大小并加快加载速度。

点击下面的链接(或者去 http://kinetics-explorer.com/)可以找到探险家。博客文章的其余部分讨论了为什么(动机)和如何创建探索者以及所做的假设。

问题是

动力学数据集是用于人体动作识别的最重要的数据集之一。然而，该数据集非常大，包含大约 650，000 个视频，其中每个视频的持续时间为 10 秒。这意味着快速筛选数据集以理解类别背景可能具有挑战性。

这是因为通常视频倾向于顺序观看(而不是并行观看，例如 YouTube vs Giphy )。因此，为了获得视频中动作类别的整体时间结构，人们必须观看整个视频。因此，如果一个视频以 25 fps 的标准帧速率为 10 秒长，人眼需要扫描总共 250 帧才能掌握视频内的时间结构。

解决方案

视频只是一段时间内的图像序列，其中图像序列的顺序能够编码某种形式的时间信息，例如一个人跳舞、一个人走路或任何形式的位移，我们的大脑将其解释为运动。在一秒钟内压缩的图像序列越多，视频看起来越无缝，越接近真实世界的解释，例如，60 fps 的视频看起来比 25 fps 的视频更无缝。这意味着，如果帧速率足够高，视频是一种高密度的时间编码介质。

为了找到解决这个问题的好办法，我们需要考虑动作类别的时间同一性。这里，我指的是以高精度确保特定类别的动作已经发生所需的最小时间和帧速率。因此，可以认为视频在编码时间信息时包含大量冗余。这样，只有少量均匀采样的帧可以编码必要的时间标识。

为了找出正确的帧速率，我们需要考虑在什么时间分辨率下信息变得不连贯，并且不能以有意义的方式捕捉视频中动作的时间结构。

这个问题在图像中的相似之处是像素化，如下所示。

https://miscellaneousdetails.com/tag/mona-chalabi/

从上面的图像中，我们可以看出拍摄对象可能是一只老虎，但是，它是像素化的，即使用少量像素来表示图像。这意味着图像的空间同一性很低，因为我们不能清楚地说出它是什么。

增加像素数(从而降低像素化)将增加所讨论对象的空间同一性，代价是图像可能需要更大的内存。可以说，空间分辨率越大，对象的空间身份的可信度越高。存在一个限制，即增加更多的像素不会增加空间同一性。

将上述逻辑应用于视频，我们从连续的真实世界场景出发，该场景具有最高可能的时间分辨率(由于连续的性质)。分辨率约为 60 fps 的高质量视频编码(在上下文中，人眼的上限约为 1000 fps)。对于高质量的视频，大量的存储器用于存储时间信息，但是具有大量冗余。随着视频中更多的帧被均匀地移除，一些时间信息会丢失，直到视频编码不连贯的程度。这意味着我们不能根据时间信息来判断动作类别，即时间身份不确定。(然而，视频也包含空间结构，因此很容易纯粹根据图像判断视频中发生了什么，例如去游泳还是踢足球。这个因素是相当多的基于视频的深度学习算法所利用的，并且没有真正考虑时域)。

GIF 编码格式是解决这一问题的理想选择，因为:

它们通常具有比视频更低的帧速率，这意味着更低的时间分辨率/密度。
有默认的自动循环功能，允许多个 gif 连续播放。
在网络浏览器中被广泛采用。

因此，将动力学视频转换为 gif 可以为筛选大型视频数据集提供更有效的方法。

实施细节

实现 GIF 到视频的转换非常简单，如下所示。

subprocess.call([
'ffmpeg',
'-i', str(video_file),
'-filter_complex',
"[0:v] fps=4,scale={scale}:-1".format(scale='180'),
'-f', 'image2',
'-loglevel', 'warning',
'-y',
png_file
])subprocess.call([
'ffmpeg',
'-i', png_file,
'-f', 'gif',
'-framerate', '16',
'-loglevel', 'warning',
'-y',
str(gif_file)
])

ffmpeg 库用于进行转换，其中第一个subprocess调用用于以 4 fps 对原始视频进行统一采样，并将数据存储为图像。(从技术上讲，在此过程中直接创建 GIF 表示是可能的，但它将以 4 fps 播放，但仍需要 10 秒才能播放完视频)。filter_complex参数将视频重新缩放到 180 像素的宽度，同时保持宽高比

第二个subprocess调用用于以 16 fps 的帧速率从生成的 png 文件创建 GIF，这使得 GIF 的总长度为 2.5s，长度减少了 75 %。

gif 的缺点

然而，gif 有一些缺点，其中之一是有时它们比视频需要更高的内存(cpu 和存储)。并且已经建议因为这个问题最好把 gif 转换成视频。还有其他文件编码，比如比这两种都更有效的 webp ，但是，它没有像 GIF 格式那样被广泛采用。

然而，主要概念保持不变，即通过从源视频中统一提取帧来降低时间分辨率。将提取的帧与新的帧速率组合，以减少相对于源视频的持续时间。

对深度学习的启示

一些深度学习论文提到了子采样帧的想法，例如让我们跳舞:从在线舞蹈视频中学习论文。然而，据我所知，还没有关于视频数据中最佳子采样频率的研究。由于标准视频数据(例如 YouTube 中的)包含大量时间冗余，一个有趣的研究领域可以是在什么时间分辨率下时间身份丢失以及影响它的因素是什么。

与此同时，GIF 方法可以作为一个权宜之计，以防您有大量的视频训练数据需要进行二次采样，因为使用视频的每一帧进行训练在计算上非常昂贵。只需以统一的间隔提取帧，转换成 gif 并浏览您的数据。如果人类能够以降低的时间分辨率说出正在发生的事情，那么理论上，深度学习算法应该能够识别动作序列。增加提取间隔，直到你一个人分不清帧中发生了什么动作。此时，视频序列的时间同一性变得不一致。

结论

希望 Kinetics explorer 工具对希望使用 Kinetics 数据集执行深度学习的个人有用。

我们还研究了将视频转换为 gif 并降低时间分辨率背后的原因。如果我的推理有任何逻辑上的不一致，请在下面的评论区添加。我也一直在寻求学习和完善我的知识。

如果您有任何问题或需要澄清的事情，您可以在https://mbele.io/mark和我预约时间

参考

您需要的最后一个机器和深度学习概要

原文：https://towardsdatascience.com/the-last-machine-deep-learning-compendium-youll-ever-need-dc973643c4e1?source=collection_archive---------15-----------------------

简编，Blende12，。

针对数据科学研究人员的几乎每个主题的综合资源

编辑 : 简编有自己的网站@mlcompendium.com谷歌文档现在已经完全退役，取而代之的是网站。我没有从纲要中获利，我总是试图确保它是最新的，用新的知识更新工作的主体，用作者信用更新参考文献。

自 2017 年以来，我一直在策展与机器学习(ML)、深度学习(DL)、统计学、概率、NLP、NLU、深度视觉等直接或间接相关的一切。我开始整理一份私人参考书目，因为我想扩大我的知识范围。这份名单后来被命名为 ML 纲要。我认为，每个研究人员和数据科学家(DS)都应该努力在日常基础上学习更多知识，不是通过撞上与任务相关的墙并解决它们，而是作为一种终身学习实践。就我个人而言，我在开始新的一天之前会阅读一些文章，偶尔会写下并分享我在媒体上获得的知识。

部分目录，第一部分，ML 汇编。

我把《纲要》当成了我个人的谷歌，上面有我读过的关于我感兴趣的或我需要了解的每个主题的各种摘要、链接和文章。主题可能包括大多数现代机器学习算法、特征选择和工程技术、深度学习、NLP、音频、视觉、时间序列、异常检测；诸如雇佣、管理和实验管理等主题。这将节省你无数的时间去搜索和筛选那些可能不会给你任何价值的文章。

部分目录，第二部分，ML 汇编。

请记住，这是一个进行中的永久工作，我不断更新它与新的主题，所以请随时访问。最后，请随时使用评论选项给我反馈。

我为初创企业和扩大规模的企业提供无偿建议。你可以在这里 了解更多关于我的信息并联系我 。

Ori Cohen 博士拥有计算机科学博士学位，主要研究机器学习和脑机接口(BCI)。他在一家智能城市初创公司领导了一个数据科学团队，主要利用机器和深度学习进行自然语言处理(NLP)和理解(NLU)研究。目前，他是 TLV 新遗迹公司在 AIOps 领域的首席数据科学家。他定期在 Medium.com 撰写关于管理、流程和所有数据科学的文章。

2019 年最后一次发人深省的采访

原文：https://towardsdatascience.com/the-last-thought-provoking-interview-of-2019-e082ad1c475f?source=collection_archive---------22-----------------------

探索两个聪明人之间的对话，包括对猫、鬼和显然是埃隆·马斯克的讨论。

前十年的最后一个十二月发生了一件事，这件事是一次谈话。

两个伟大的头脑之间的对话，讨论有趣和刺激的话题。这篇文章探索了这段对话中有趣的片段，希望你，读者，能继续听下去(对话链接在本文末尾)。

我从没想过我会在一篇媒体文章中提到猫，但是我们在这里。

为什么我们在这篇文章中提到猫？埃隆·马斯克和一个鬼魂的对话是什么？

好吧，继续读下去找出答案。

但我可以向你保证，读完这篇文章后，你很可能会比开始时更加困惑——提前道歉。

个人资料和对话

让我们先来理解我在本文中提到的对话是关于什么的。首先，介绍一下参与我们对话的两位有趣的头脑。

对话发生在两个人之间，你们可能在网上见过面，如果你们没有见过面，让我给你们介绍一下莱克斯·弗里德曼和迈克尔·史蒂文斯。

莱克斯和迈克尔是非常聪明和有声望的人。两人都在 YouTube、Instagram 和 Twitter 上拥有大量粉丝。

这是他们的简介。

Lex Fridman 的研究工作在于人工智能、深度学习和自动驾驶汽车。

我是通过他在 Spotify 上的播客“Lex Fridman 的人工智能”认识 Lex Fridman 的。

他 33 岁(在写作的时候 g)，受过博士教育。

哦，他也在谷歌工作，研究机器学习。

去迈克尔·史蒂文斯。

在我谈到迈克尔之前，让我补充一下，这篇文章中提到的对话是由莱克斯·弗里德曼的 YouTube 频道主持的(观看他的视频和讨论，你会获得脑细胞)。我会在下面放一个链接。

迈克尔·史蒂文斯也是 33 岁(写作时 g)，身兼数职；他是演说家、演员、编辑等等。

迈克尔因在他的频道 Vsauce 上提供娱乐内容而成为最著名的 YouTubers 用户之一。他提出了最令人兴奋和发人深省的问题，同时提供了一种科学的方法来回答奇怪和有趣的问题，如:“什么是最可怕的东西”或“镜子是什么颜色的。”

对话开始时，Lex 问了 Michael 以下关于心理学的问题:

“你认为我们怎样才能把心理学从 20 世纪的水平提升到更像理论物理学家所做的，更精确和严谨的水平？”

莱克斯以一个探索思维的问题开始，这很公平，因为迈克尔在 YouTube 上有一个名为“思维场”的系列

迈克尔很好地回答了这个问题，尽管没有衡量答案正确性的标准，但他回答的自信方式和逻辑推理实际上可能有一定的根据——当然是假设性的。

迈克尔对第一个问题的回答是，我们需要结合心理学的物理基础。

心理学的物理基础是一个模糊的短语，可以有主观的解释。尽管如此，迈克尔解释说，如果我们能够在我们的情绪、感觉和心情中获得一些可测量和可量化的成分，心理学也许能够与理论物理学相媲美。

通过发现我们的情绪和这个可量化的成分之间的相互关系，我们可以走上一条意识可以以物理和数学形式存在的道路。

我跟随迈克尔的推理和思考过程，直到当他提到“量子态”时我迷失了方向。但在莱克斯提出第二个问题后我发现自己。

意识和猫

“你对意识有什么看法，你认为它是现实的一部分，还是深入人心，由人类构建？”

在迈克尔回答第二个问题之前，他谦虚地声明“我不是上帝，”他的答案是基于猜测。

在继续解释我们的整个存在和宇宙之前，这些都是合理的免责声明。

再一次，迈克尔的回答让我不禁想到，我本以为最后会问我是谁？。但是，恰恰相反，我在问，我是什么时候？(曼哈顿博士在此共鸣)

提示推测假说……

意识是一种可以在物理定律中得到充分解释的东西

暂停，你是在告诉我理论上意识可以用支配我们宇宙的公式来描述。

如‘F = ma’之类的。

脑子=炸了。

来自 https://giphy.com 的 Gif 图片

对他的答案的进一步解释引导迈克尔探索宇宙，以及它如何与我们的记忆和意识的联系相吻合。他推测，在我们宇宙的口袋里，有嵌入的记忆。

这是我从这一段对话中所理解的:如果我们以某种方式抓住宇宙的一部分，那么我就可以探索人们在被抓住的那部分时间内存在的记忆。

迈克尔用一只猫来解释记忆和宇宙之间的联系。我会尽力把他的口头解释写下来。

假设你被你的猫(我是爱狗人士)抓伤了，事实上有两种说法或者说是证据证明你确实被抓伤了。

第一个是你手臂上的物理爪痕，第二个是宇宙内部有一种状态，包含了你被你的猫抓伤的记忆。因此，意识出现在宇宙中包含这些存储记忆状态的空间，并且时间的存在是普遍的。

时间和回忆过去的事件可以被看作是我们以某种方式或形式进入记忆状态。

沉重的东西。

不会破坏剩下的对话，但对话发生了有趣的转变，涉及到了诸如自由意志、模拟、科学挑战、地球是平的等话题。

但我们谈谈吧，鬼魂。

鬼

来自 pinterest.com 的幽灵形象

提到鬼魂是因为 Lex 之前的一个声明，他说 Michael 的思维方法是"像"一样的科学，并且被封装在科学过程中。

“提出问题，勇于提出问题，保持好奇心，不被自己的想法所束缚，这就是作为一名科学家对我的意义”——莱克斯·弗里德曼

我欢迎读者反驳我将要陈述的理论。这个理论是迈克尔为了传达一个观点而提出的。

理论是这样的，当我们用手、脚或头移动物理物体时，实际发生的是一个鬼魂( Casper 就是你)离开我们的身体，占有了我们想要移动的物体，突然物体移动了。

你问的重物呢？迈克尔的理论是分两部分的。

第二部分通过陈述鬼魂只是变得懒惰来适应不能移动重物的情况。

“鬼的懒惰与物体的质量成正比，这就是 F=ma 的原因”。

我们可能无法证明鬼魂的存在，因为我们缺乏对鬼魂的视觉感知，但一旦我们开始询问关于鬼魂的问题，或进行测试，并表达对鬼魂的各种好奇，以及提出的理论，我们就开始了科学进程。

迈克尔用鬼魂做类比的重点是，能够提出问题和基于观察表达好奇心的能力不仅仅归因于拥有科学思维，而是人类的产物。

人工智能和埃隆·马斯克

图片来自gettyimages.co.uk

很高兴你能走到这一步。所以我不会在这里浪费时间，陈述 Lex 向 Michael 提出的问题。

“你认为构建超人或人类级别的人工智能需要什么？”

我不得不称赞迈克尔回答上述问题的方法。他没有直接跳到一个可以炫耀他的智慧、观点或经历的答案，而是选择进一步剖析这个问题。

“我们讨论的基础是什么？”
“聪明是什么意思？”
"我们如何衡量人工机器或程序的智能？"

不幸的是，这些问题在对话中没有得到直接回答，但关于人工智能程序的输出与人类结果如何区分的讨论引出了一条道路，人们可以亲自探索这条道路，以找到涵盖上述问题的研究领域或解决这些问题的讨论。只需在谷歌上输入“图灵测试”。

现在，埃隆·马斯克的名字出现在人工智能和自动驾驶汽车的话题中。

提到人工智能，你就不能不提到埃隆马斯克(Elon Musk)或他的一家公司。

你和我可能都是技术专家，我们非常清楚埃隆·马斯克和其他知名人士对人工智能进步的立场，以及如果发展得不到适当的治理和监控，它对人类生活的影响。

莱克斯·弗里德曼问迈克尔·史蒂文斯这个问题:

“在当前的时间里，人们担心人工智能的一个好的门槛是什么？”

在我看来，我不认为我们可以量化对影响人类生活的紧迫问题的关注程度，对任何主题采取预防措施成功的真正指标是最糟糕的情况不会发生。

迈克尔对这些问题的回答与我对此事的看法一致。他指出，关于技术进步的警告性声明和行动并不新鲜。然后，他进一步将人工智能的创造与夫妇接生婴儿进行了比较。

我们怎么知道现在出生的婴儿不是精神病患者。如果婴儿表现出高比例的邪恶或精神变态，我们应该阻止他们出生吗？

“也许我们不应该生孩子，也许我们不应该创造人工智能”——迈克尔·史蒂文斯

重申一下，这些问题没有直接的答案。Lex Fridman 与这些有创造力和智慧的人交谈的目的是通过提出特定领域和发人深省的问题来揭示和民主化他们的思维方法。

Lex 对 Elon Musk 的努力非常了解，因为他已经与 Elon Musk 进行了几次对话(链接在本文末尾)。

埃隆与人工智能、太空以及几乎所有与技术相关的时髦词汇的讨论都有关联。埃隆也积累了大量忠实粉丝。

在我看来，随着网络卡车的成功发布，埃隆·马斯克笑到了最后。

当谈到埃隆·马斯克时，迈克尔并不关注汽车、人工智能、宇宙飞船等华而不实的东西。相反，他表达了自己对埃隆如何处理这么多追随者和责任的好奇。

我会列出迈克尔问的问题，但我有一个想法。

在这里迁就我，中等；我将代表迈克尔·史蒂文斯向埃隆·马斯克提出一些问题。

我相信埃隆·马斯克阅读这篇文章的概率只有 0.00001%(或者小得可笑的概率)。

如果你正在阅读这篇埃隆·马斯克的文章，迈克尔·史蒂文斯(顺便提一下，还有 Medium)想问你一些下面列出的问题，请在这篇文章的评论部分或你选择的任何回复形式中随意回答。

但这引发了一个问题，如果他真的回应了，我们怎么知道他是真的埃隆·马斯克……好吧，我会让埃隆·马斯克来证明他回应的真实性。但是问题来了。

分享你的想法、愿景和梦想的人的数量让你担心吗？
当很多人分享你的想法和梦想时，你对自己所承担的责任有什么感觉？
做埃隆·马斯克是什么感觉？

不幸的是，没有办法在一篇单一的媒体文章中充分呈现迈克尔·史蒂文斯和莱克斯·弗里德曼之间的对话的价值，所以我鼓励你观看对话的 YouTube 视频或收听 Spotify 播客版本，也包括在下面。

如果你喜欢这篇文章，并且想阅读我的更多文章，请关注我。感谢阅读。

[## 迈克尔·史蒂文斯:Vsauce-Lex frid man 的人工智能(AI 播客)

迈克尔·史蒂文斯是世界上最受欢迎的 YouTube 教育频道之一 Vsauce 的创始人，拥有超过…

open.spotify.com](https://open.spotify.com/episode/5UmcM9Glgni4CVi4ruZ8Kr)

学习率查找器

原文：https://towardsdatascience.com/the-learning-rate-finder-6618dfcb2025?source=collection_archive---------23-----------------------

实践教程

无需昂贵的搜索即可快速到达最佳值的邻域。

图片由 Wokandapix 来自 Pixabay

学习率可以说是神经网络中最重要的超参数。不幸的是，这也是最难调准的。但是不要绝望，因为学习率搜索器会让你很快得到相当不错的值！我们来看看它是如何工作的，如何在 TensorFlow 中实现。

为什么重要？

要回答这个问题，让我们从定义学习率开始。当你训练一个神经网络时，一个优化算法(通常是某种梯度下降)遍历损失函数的表面，寻求沿着损失正在减少的斜坡向下走。学习率基本上就是它所走的一步的大小。这个步长不能太小也不能太大，这非常重要。

如果学习率太小，该算法将需要很长时间才能达到最小值，如上图左侧面板所示。更糟糕的是，如果损失曲面中存在局部极小值，优化器可能会陷入其中，无法仅通过小的步骤摆脱出来。

另一方面，如果学习率太大，优化算法可能会超过最小值，并在最小值附近反弹，永远不会收敛，在最糟糕的情况下，它甚至会完全发散，就像上图右侧的面板一样。因此，让你的学习速度恰到好处是非常重要的！

为什么很难？

学习率是一个很难调整的超参数，原因有很多:

在大多数情况下，领域知识或以前的研究帮助不大，因为对一个问题有效的学习率可能连另一个问题的一半都不到，即使是一个密切相关的问题。
通过网格搜索或随机搜索来调整学习率通常在时间和计算能力方面都很昂贵，尤其是对于大型网络。
最优学习率与其他超参数紧密耦合。因此，每次你改变正则化的数量或网络的结构，你应该重新调整学习率。

进入学习率查找器

寻找最佳收视率在某种程度上一直是一个随机射击的游戏，直到 Smith (2017) 提出了一个聪明而简单的方法。

他注意到，通过在训练早期监测损失，可以获得足够的信息来调整学习速度。其思想是仅针对一个时期训练网络，从非常低的学习速率开始，每次迭代都增加学习速率，直到非常大的值(使得每个新的小批量都使用比前一个小批量更高的学习速率来训练)。然后，我们可以为每次迭代绘制损失与学习率(对数标度)的关系图。通常情况下，我们会得到一个类似于下图的图:

为什么是这样的形状？在训练开始时，在网络的权重被随机初始化后，很容易取得进展(减少损失)。这种进步最初是缓慢的，因为我们是一小步一小步地前进，但是随着我们学习速度的提高，损失开始越来越快地减少。然而，在某一点上，学习率变得太大，损失发散。

基于这个情节，可以挑出一个好的学习率。然后，我们简单地用选择的值重新开始训练。你可能会问，这个最优值是多少？令人惊讶的是，这并不是损失最小的值！最佳学习率略小于或低于损失最小化值。为什么？这有两个原因。

首先，至少，学习率已经太大，因为损失处于爆炸的边缘。少一点不会有太大的区别，但多一点会把一切都炸飞，所以最好还是保险一点。
其次，如果您使用一个具有动量的优化器(比如流行的 Adam)，那么每次迭代的损失实际上是当前小批量损失和过去损失的移动平均值。因此，当学习率开始变得太大时，损失图不会立即爆炸，因为平均值会被过去的小损失拉低。当我们看到损失曲线飙升时，这意味着学习率已经过大一段时间了。

因此，对于上面的示例图，我们将选择 10^-3 的最优学习速率，它比最小值小大约一个数量级。

这种方法可能不会选择学习率的单一最优值，但它选择的值应该非常接近最优值。然而，它最大的吸引力在于它的速度。你只需要训练一个网络一次，只有一个纪元-没有昂贵的随机搜索！

在 TensorFlow 中实现学习率查找器

在 TensorFlow 中实现这种方法非常容易。我们只需要四个组件:

在每次迭代中增加学习速度的东西。
记录学习率和每次迭代损失的东西。
在记录损失和学习率的同时训练一个时期的模型的代码。
密谋策划人。

前两个可以组合在一起，作为自定义回调来实现。

在处理每个批处理的末尾，它会将当前的丢失率和学习率附加到为存储这些值而建立的两个相应的列表中，然后它会将学习率乘以一个因子，作为参数传递。

现在，我们应该传递什么因子？这取决于我们想要开始的学习率的初始小值、我们最终想要在时期结束时达到的大值以及每个时期的迭代次数。

如果我们想以 0.000001 的学习率开始，并在 1000 次迭代中指数增加，最终达到 10，那么适当的乘法因子由np.exp(np.log(10 / 10**-6) / 1000)给出。我们可以很容易地验证这一点:

除了左边的图以对数刻度显示垂直轴(学习率)之外，这两个图是相同的。如你所见，我们确实在 1000 步中从 0.000001 到 10。对数学习率线性增加，因此学习率呈指数增加。这样，我们可以比大值更详细地研究小值。

最后要避免的是我们在一个历元训练中的迭代次数——它不会总是 1000。它只是训练数据中的示例数除以我们想要使用的批量大小。

让我们用一个简洁的函数把它们打包在一起。

我们的函数将编译的 TensorFlow 模型作为输入，同时输入训练数据和批量大小。它首先计算我们刚刚讨论过的学习率乘法因子。为了得到一个整数，我们在计算迭代次数时使用了除法运算符(//)。然后，它将模型的学习速率设置为我们开始时的最小值，并使用我们之前定义的自定义回调对其进行一个时期的训练。最后，它从回调中提取损失和学习率，并绘制它们，产生我们已经看到的图。

让我们在臭名昭著的时尚 MNIST 数据集上尝试一下。

正如所讨论的，根据情节判断，我们宣布 10^-3 为最佳学习率，重新编译模型，并准备好以调整后的学习率进行训练！

结论

在神经网络中，学习速率是一个很难调整的超参数。但是，有一个简单的解决方案:

仅在一个时期内训练网络，提高每次迭代的学习率(从非常小的值开始，到非常大的值结束)。
每次迭代后，绘制损失与对数学习率的关系图。随着学习率的增加，损失曲线可能开始以增加的速度向下倾斜，然后它将达到最小值，然后向上爆发。
最佳学习率比使图中损失最小的学习率小一个数量级。
这种调整学习率的方法可以使用自定义回调在 TensorFlow 中轻松实现。

来源

Smith (2017)，训练神经网络的循环学习率。在计算机视觉应用(WACV)，2017 年 IEEE 冬季会议。IEEE，第 464–472 页。
https://github . com/ageron/hands on-ml2/blob/master/11 _ training _ deep _ neural _ networks . ipynb

感谢阅读！

如果你喜欢这篇文章，为什么不在我的新文章上 订阅电子邮件更新 ？而通过 成为媒介会员 ，就可以支持我的写作，获得其他作者和我自己的所有故事的无限访问权。

需要咨询？你可以问我任何事情，也可以在这里为我预约 1:1 。

也可以试试 我的其他文章 中的一篇。不能选择？从这些中选择一个:

[## 蒙特卡洛辍学

用一个小技巧免费改善你的神经网络，获得模型不确定性估计作为奖励。

towardsdatascience.com](/monte-carlo-dropout-7fd52f8b6571) [## SVM 内核:他们实际上做什么？

直观的视觉解释

towardsdatascience.com](/svm-kernels-what-do-they-actually-do-56ce36f4f7b8) [## 校准分类器

你确定你的模型返回概率吗？🎲

towardsdatascience.com](/calibrating-classifiers-559abc30711a)

伦纳德-琼斯势

原文：https://towardsdatascience.com/the-lennard-jones-potential-35b2bae9446c?source=collection_archive---------6-----------------------

卢卡·扎马塔罗的《逃离伦纳德·琼斯》，版权 2020

分子动力学

为什么分子动力学的艺术如此迷人，为什么我在情感上如此不知所措

那是2004 年，德国海德堡市正在举办第五届国际系统生物学大会(ICSB 2004) ，一个摆在大会内的书摊吸引了我的注意。被曝光的书籍之一是由丹尼斯·c·拉帕波特(Dennis C. Rapaport)撰写的第二版 分子动力学模拟艺术，由剑桥大学出版社出版。

给我印象最深的是分子动力学基本概念的清晰展示。这本 549 页的书代表了计算化学的经典课程。尽管如此，一个完整的 C 代码的出现使这本书具有了创新性，这些代码被分成几个部分，像学生练习一样在每一章中传播。

在与冠状病毒隔离 16 年后，我从书架上掸掉了它的精装书，重新发现了这部不可思议的杰作。现在，我想用 Python 提出一些它的美丽概念。

模型流体

第二章使用软磁盘流体模拟解决了非键合相互作用的基本分子动力学主题，这是一个球形粒子(原子)相互作用的运动方程的实现。计算成对原子之间的相互作用是为了提供原子间作用力的两个主要特征:

斥力:对压缩的阻力。
吸引力:在一定分离范围内粒子对的相互吸引(偶极-偶极，偶极-诱导偶极，范德华力，包括伦敦分散力)。

计算这些特征的温和方程式是伦纳德-琼斯势(LJP)。

图 1:约翰·爱德华·伦纳德·琼斯爵士。剑桥大学计算机实验室/CC BY(https://creativecommons.org/licenses/by/2.0)

LJP 最初是由约翰·爱德华·伦纳德·琼斯爵士于 1924 年提出的，用于液态氩。这个电势决定了位于 ri 和 rj 位置的一对原子 i 和 j 的相互作用和排斥的强度。它根据它们的分离距离 r 计算它们的加速度和力。你还想要什么？！

等式 1:伦纳德-琼斯势

LJP 模型由两部分组成:排斥项(σ/r)和吸引项 (σ/r)⁶ ，分别表示排斥力和吸引力。参数 r 是两个原子之间的距离(单位为ω)；

σ 是代表两个原子间分子间势= 0 时的距离的长度标度(单位为ω)，而 ε 支配着相互作用的强度(单位为 eV)。本质上，它是两个原子相互吸引程度的量度。

最后， u 是两个粒子之间的分子间势。相互作用在近距离排斥，然后吸引，在某个极限分离 rc: 随着参数 r 向 rc 增加，力下降到 0。

图 2:Lennard-Jones 电势曲线，计算为 ε = 0.0103 和 σ = 3.3

生成图 2 的 LJP 曲线的代码如下:

代码 1:计算伦纳德-琼斯势

为了简化计算，Rapaport 修改了第二章报告的例子中的 LJP，通过忽略由范德华力代表的吸引尾来简化相互作用。而且，ε和σ都设为 1。极限间距 rc* 如公式 2 所示:*

等式 2:极限分离

如果我们用这种势来构造模型流体，模拟看起来就像“一堆相互碰撞的软球”，正如 Rapaport 所报道的那样。像这样的模型仅限于一些低密度气体。

正如我们将很快看到的，我将在这里提出一个 Python 代码，它将恢复原来的 LJ 势。如果与我的 Python 代码相比，Rapaport C 代码是很快的，但是如果我们想使用像 Python 这样健壮的、得到很好支持的编程语言，这是我们必须付出的代价！

牛顿…在工作！

我们正在谈论相互作用的原子。所以，我们应该考虑牛顿第二运动定律，其中 F 是每对粒子在位置 r 的力。等式 3 显示了从 LJ 电势得到的力。

等式 3:来自 LJP 的力

牛顿第三定律意味着 Fji 等于-Fij，因此来自成对相互作用 u(rij)的作用在粒子 i 上的力与作用在粒子j上的力方向相反。力的计算将需要进行数值积分，这将允许我们推导出模拟中每个原子的坐标、速度和加速度。有多棒？

2D 软盘流体算法

现在我们已经了解了 LJP 是如何工作的，让我们开始创建一个二维软盘流体模拟的算法！该程序将是第二章的简单分子动力学练习( pr_02_1 )的 Python 实现。在开始详细讨论代码之前，让我们简单介绍一下模拟将如何工作。看一下图 3 中的程序流程图:

图 3:程序的流程图

该计划由三部分组成:

主循环
设置作业功能
单步函数

这些部分中的每一个都代表了另外十个子功能(彩色方块)的一个包装。主协调流量，首先调用 SetParams 和 SetupJob 这两个函数进行程序初始化。 SetParams 用于设置多个全局参数，而 SetupJob 包含 InitCoords 、 InitVels 和 InitAccels、分别是所有原子的坐标、速度和加速度的初始化函数。

主程序要做的每件事都是调用单步执行，它代表处理整个过程的函数。单步将调用跳步，使用简单的数值技术执行运动方程的积分:跳步方法。这种方法具有很好的能量守恒特性，综合了粒子的坐标和速度。您会注意到跳过步骤在单步的列表中出现了两次，参数 1 或 2 决定了两步跳过过程的哪一部分将被执行。最后，单步包含计算力，*实现 LJP 和力并更新原子加速度，以及两个用于属性测量的函数: EvalProps 和 AccumProps。*

既然我们已经阐明了算法将如何工作，让我们准备一个参数文件作为输入，如下所示:

代码 2:输入文件

代码 2 中显示的参数输入文件将引导基本参数的设置。 initUcell 将指一个 20×20 正方形晶格的初始构型(共 400 个原子)。 deltaT 是一个时间步长参数，将由蛙跳方法使用，并涉及能量守恒。温度设置为 1，而流体密度设置为 0.8。最后， stepLimit 设置模拟的循环数。

通过上传输入文件设置好所有全局参数，并运行所有初始化后，主将进入 while 循环运行单步，直到步数变量超过步数限制。

代码

第一步包括安装和导入 Python 所需的所有包，如代码 3 所示:

代码 3:导入所有需要的包

在最初的 Rapaport 版本中，我引入了一个用于分子定义的 Python 类(Mol 类)和一个用于属性的 Python 类(Prop 类)，它们由两个 C 语言结构表示:

代码 4:类定义

我已经用来自 NumPy 的线性代数函数替换了所有用于向量运算的函数。此外，我重新编写了随机性和更新周期边界坐标的所有必要函数。

代码 5:基本功能

坐标、速度和加速度的初始化函数包含在以下代码中:

代码 6:初始化函数

代码 7 中有两个功能设置参数和设置作业**

代码 7: SetParams 和 SetupJob

如前所述，一个重要的修改涉及到 ComputeForces 函数，它实现了 LJP:在这里，我引入了由范德华力代表的吸引尾，在 pr_02_1 中被移除。(代码 8)

代码 ComputeForces 函数

代码 9 包括蛙跳方法，用于整合运动方程。

代码 LeapfrogStep 函数

代码 10 提供了属性测量的所有功能(温度、能量和压力)。

代码 10:属性测量功能

在向您展示单步函数的代码之前，让我为程序输出介绍一些有用的额外函数。在代码 11 中，我提出了第一个用于绘制原子轨迹的函数(【plotMolCoo】)，它一步一步地绘制所有的图形，第二个函数从所有的坐标图形块中创建一个 mp4 视频。这两种功能必须协同工作。此外，代码 11 包括 GraphOutput ，这是一个打印熊猫数据帧形状属性的函数。

代码 11:输出函数

这里的单步功能:整个算法的真实档位。

代码 12:单步函数

最后，在代码 13 中，主循环。

代码 13:主循环。

将所有代码可视化后，将所有部分装入 Jupyter 笔记本并运行它:你应该能够制作一个这样的视频…

视频 1:2D 软盘模拟

对我最喜欢的谜题的思考。

基于 Lennard-Jones 势的软盘流体模拟表示流体或气体的微观模型。它是基于模拟原子相互作用的球形粒子。相互作用发生在利用排斥力和吸引力的粒子对之间。正如视频中所见，在 500 个时间步长后，最初靠近的两个彩色原子(红色和青色)倾向于向不同的方向移动。

表 1:分子动力学特性(前 500 个时间步)

表 1 提供了速度分量的总和、每个原子的平均能量和动能、标准偏差以及前 500 个时间步长的平均压力。对于守恒定律，系统的能量是守恒的。

密度为 0.8 时，轨迹显示稠密的流体相。我邀请读者改变密度和温度的参数，看看轨道如何修改它们的模式。

我提供了 Rapaport 一书第二章练习 pr_02_01 中描述的函数的 python 实现。在这样做的时候，我保留了与这本书相关的物理和化学概念的原创性，同时，用 Python 代替 C 代码帮助我更深入地理解了所有模拟过程背后的数学。毕竟，Rapaport 的书的整体紧凑性已经被我的直接方法粉碎了，这种方法包括用另一种更现代的代码替换旧的 C 代码。

我喜欢称这种方法为“我最喜欢的难题”！

参考资料:

分子动力学模拟的艺术，丹尼斯·c·拉帕波特著，剑桥大学出版社出版。

拉比亚·纳伊姆(加州大学戴维斯分校)——libre texts，伦纳德·琼斯潜力

https://python inchemistry . org/sim _ and _ scat/molecular _ dynamics/intro . html

升力曲线:揭开面纱

原文：https://towardsdatascience.com/the-lift-curve-unveiled-998851147871?source=collection_archive---------5-----------------------

评估分类算法的另一种[棒极了]方式

这篇文章的目的是解释什么是提升曲线，它如何补充 ROC 曲线等其他分类评估技术，以及它如何用于比较不同的模型。

如果你不知道什么是 ROC 曲线，你可以在这里 找到一个解释这一切的好帖子 。没有必要了解它来理解升力曲线(它们是独立的工具)，但看到它们如何一起使用总是很好的。

最后，在我们开始之前，这里有一些额外的资源可以让你的机器学习事业突飞猛进:

*Awesome Machine Learning Resources:**- For* ***learning resources*** *go to* [***How to Learn Machine Learning***](https://howtolearnmachinelearning.com/books/machine-learning-books/)*! 
- For* ***professional******resources*** *(jobs, events, skill tests) go to* [***AIgents.co — A career community for Data Scientists & Machine Learning Engineers***](https://aigents.co/)***.***

[## 订阅我的专属列表！

订阅我的专属列表！并获取所有你喜爱的新鲜文章<3! By signing up, you will create a Medium…

z-ai.medium.com](https://z-ai.medium.com/subscribe)

说了这么多，我们开始吧。

分类算法的概率输出

当面临二元分类问题时(例如使用某个患者的健康记录来识别他是否患有某种疾病)，我们使用的机器学习算法通常会返回一个概率(在这种情况下是患者患有疾病的概率)，然后将其转换为预测(患者是否患有这种疾病)。

之前解释的场景的管道

提升曲线使用这个返回的概率来评估我们的模型的表现，以及它在识别数据集的阳性(1 或患病患者)或阴性(0 或健康患者)实例方面的表现。

数据

本例中使用的数据集是 UCI 心电图数据集 ，您可以在此处 找到。 理解这篇文章并不需要下载数据，但是如果你想研究一下，在这篇文章的末尾有一个 Jupyter 笔记本的链接，上面有我用来解释的代码。

我们模型的目标是对患有某种心脏疾病的患者进行分类。让我们看看升力曲线如何帮助我们评估模型。

升力曲线

下图显示了正常升力曲线的示例:

升力曲线图形

如我们所见，在 X 轴上，我们有对应于某一升力的样品比例，绘制在 Y 轴上。提升很容易计算为某个样本点上 1 的比率除以整个数据集上 1 的比率，这也可以视为随机算法做出的预测。

举升公式

如何构建升力曲线:

建立升力曲线非常容易。首先，我们必须从最高(最接近 1)到最低(最接近 0)对模型的预测进行排序。通过这种方式，我们可以根据患病的可能性对人口进行排序。

首先，我们根据患者患病的可能性对他们进行分类

之后，我们使用真实的已知标签计算数据集上 1 的比例，对于样本的每个比例(X 轴),我们使用上述公式计算提升，这是我们最终绘制的。因此，每个点上的升力是使用到该点为止的数据样本的比例的正实标签和我们的数据的正实标签的总数来计算的。

如何阅读升力曲线

让我们看看提升曲线如何帮助我们评估我们的模型:在我们的例子中，我们想估计一个病人患病的可能性有多大。通过我们对数据的排序，患病概率最高的患者将出现在我们图表的左侧，通常伴随着最高的 Lift 得分。

这些患者将对应于上图的点 A ，有时也称为 最大升力点 。一般规则是，这个点越高，我们的模型表现得越好，因为在我们的人口比例中有许多真正的阳性标签，这些标签具有非常高的阳性概率(我们知道这一点，因为我们已经以这种方式对数据点进行了排序)。

最大升力是一个可以快速用于比较两个模型的指标:具有最高最大升力的模型通常更好。下图显示了这一点。曲线 2 具有更高的最大升力，因此与其对应的模型可能更好。

两条升力曲线的比较

对于点 B ，我们选择了一个包含 10%人口的样本，我们可以看到我们的阳性标记比平均值多 4 倍多。我们如何将这些转化为有用的信息？想象一下，我们的记录显示 10%的患者患有心脏病，而 90%的患者没有。B 点的信息告诉我们，最有可能患病的 10%人口的患病比例是平均值的 4 倍。

因此，在我们的例子中，我们的算法预测的概率最高的 10%的人群将有大约 40%(10%平均值的 4 倍)的患病患者。

最后，点 C 与点 B 非常相似，但样本中包含了患病几率最高的 50%人口。对于该样本，患病患者的比例是平均值的两倍，因此患病患者的比例为 20%。

最后一个要解释的有趣概念是理想升力。这种情况很少发生，当升力曲线的起点平坦时，如下图所示。

具有平坦理想升力区的曲线

这意味着，在升力曲线开始下降之前，随着样本比例的增加，升力保持不变，所以具有最大升力的群体越来越大，直到出现下降，这是一件好事。

在这里，您可以找到使用一组数据点的真实标签和相应的预测概率绘制升力曲线的代码:

结论和其他资源

提升曲线，就像所有其他评估指标一样，不是唯一或完美的解决方案，但是，像 ROC 曲线一样，它提供了一种快速评估我们的算法如何运行的方法，也是比较不同模型的好工具。

提升曲线在营销模型中非常有用，我们希望预测特定受众是否会对特定营销活动做出反应:使用提升曲线，我们可以在最有可能做出积极反应的特定人口规模中进行削减。此外，它们还可以用于类似的模型，这些模型试图预测一个人是否会拖欠贷款或付款，并只针对影响最大的样本。

[## 订阅我的专属列表！

订阅我的专属列表！获取所有你喜欢的新鲜文章<3! By signing up, you will create a Medium…

z-ai.medium.com](https://z-ai.medium.com/subscribe)

Additional Resources:

[## Lift Analysis - A Data Scientist's Secret Weapon - KDnuggets

By Andy Goldschmidt, Akanoo. Whenever I read articles about data science I feel like there is some important aspect…

www.kdnuggets.com](https://www.kdnuggets.com/2016/03/lift-analysis-data-scientist-secret-weapon.html) [## Cumulative Gains and Lift Curves: Measuring the Performance of a Marketing Campaign - Select…

Suppose that you are running a direct marketing campaign, where you are trying to target members of your customer base…

select-statistics.co.uk](https://select-statistics.co.uk/blog/cumulative-gains-and-lift-curves-measuring-the-performance-of-a-marketing-campaign/)

That is all, I hope you liked the post. Feel Free to connect with me on LinkedIn 或在 Twitter 上关注我 @jaimezorno 。还有，你可以看看我在数据科学和机器学习上的帖子这里。好好读！

关于机器学习和数据科学的更多资源，请查看以下资源库: 如何学习机器学习 ！有关职业资源(工作、事件、技能测试)，请访问 AIgents.co——一个面向数据科学家&机器学习工程师的职业社区。

此外，更多像这样的帖子请在 Medium 上关注我，敬请关注！

您可以在我的 Github 上找到用于绘制升力曲线的代码以及一个带有快速示例的 Jupyter 笔记本:

[## jaimezorno/升力曲线

此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…

github.com](https://github.com/jaimezorno/Lift_curve)

非常感谢您的阅读，祝您有美好的一天！

知识的极限

原文：https://towardsdatascience.com/the-limits-of-knowledge-b59be67fd50a?source=collection_archive---------24-----------------------

哥德尔、图灵和关于我们能知道什么和不能知道什么的科学

俄勒冈州的火山口湖(图片来源:塞巴斯蒂安·戈德堡， Unsplash )

17 世纪，德国数学家戈特弗里德·莱布尼茨提出了一种机器，它可以读取任何数学陈述作为输入，并根据数学公理确定其真假。但是每一个陈述都可以这样决定吗？或者是我们所能知道的极限？这个问题被称为 Entscheidungsproblem (决策问题)。

两个世纪后，另一位德国数学家戴维·希尔伯特乐观地宣布，Entscheidungsproblem 的答案必然是，是的，我们能够并且将会知道任何数学问题的答案。1930 年在德国柯尼斯堡的一次演讲中，他说了一句名言:

我们是 müssen wissen —我们是 werden wissen。(“我们必须知道——我们会知道的。”)

但是我们会吗？

数学的局限性

希尔伯特的乐观被证明是短暂的。同年，奥地利数学家库尔特·哥德尔通过证明他著名的不完全性定理，证明了我们的数学知识是有限的。

这里有一个理解哥德尔定理的简化方法。考虑下面的语句。

陈述 S:这个陈述是不可证明的。

现在，假设在数学的范围内，我们可以证明 S 为真。但是，语句 S 本身会是假的，导致不一致。好，那么让我们做相反的假设，我们不能在数学的范围内证明 S。但那将意味着 S 本身是真的，数学包含至少一个为真但不能被证明为真的陈述。因此，数学一定是不一致的或不完整的。如果我们假设它是一致的(陈述不能同时为真和假)，这只会留下数学不完整的结论，即存在真的陈述，只是不能被证明为真。

哥德尔对不完全性定理的数学证明比我在这里概述的要复杂得多，它从根本上改变了希尔伯特宣扬的完整知识是可行的观点。换句话说，如果我们假设数学是一致的，我们一定会发现不可证明的真实陈述。

例如，考虑哥德巴赫猜想，根据该猜想，每个偶数都是两个素数的和:

6 = 3+3
8 = 3+5
10 = 3+7
12 = 7+5，以此类推。

还没有人找到反例，如果这个猜想是真的，也可能没有反例。因为哥德尔，我们知道存在着没有证据的真实陈述，但不幸的是，没有办法去识别这些陈述。哥德巴赫猜想可能是其中之一，如果是这样，那么试图寻找证据将是浪费时间。

库尔特·哥德尔(左)和阿兰图灵(右)(图片来源:康托尔的天堂)

计算的极限

艾伦·图灵第一次了解哥德尔不完全性定理的时候是剑桥大学的研究生。在那段时间里，图灵致力于制定机器的数学设计，这些机器可以处理任何输入并计算结果，这与莱布尼茨几个世纪前的设想类似。这些概念化的机器今天被称为图灵机，并被证明是现代数字计算机的蓝图。简单来说，图灵机可以比作现代计算机程序。

图灵正在研究所谓的停机问题，可以提出如下问题:

有没有一个程序可以决定另一个程序是否会暂停(结束执行)或者不暂停(永远循环)？

图灵证明了停机问题的答案是“不”，这样的程序不可能存在。与哥德尔的工作类似，他的证明是一个“矛盾证明”。假设存在一个程序 halts() ，它确定一个给定的程序是否将暂停。但是我们也可以构造下面的程序:

**def** g():
    **if** halts(g):
        loop_forever()
    **return**

看到这里发生了什么吗？如果 g 成立，g 不成立，如果 g 不成立，g 成立。不管怎样，我们都有矛盾。因此，程序 halts()不能存在。

哥德尔证明了数学是不完整的，而图灵证明了计算机科学在某种意义上也是“不完整的”。某些程序根本无法存在。这不仅仅是理论上的好奇:停机问题在今天的计算机科学中有许多实际的含义。例如，如果我们希望编译器为一个给定的程序找到尽可能最快的机器码，我们实际上是在试图解决停顿问题——而且我们已经知道这个问题是不可解的。

复杂的蛋白质结构——预测蛋白质如何折叠是一个 NP 问题。(图片来源:自然)

知识的实际极限:P 对 NP 问题

哥德尔和图灵通过表明有些问题根本无法解决，证明了我们所能知道的东西在理论上是有限的。但是除此之外，还有其他一些问题，我们可以在理论上解决，但在实践中却无法解决，因为计算解决方案的时间太长了。这就是我们区分 P 问题和 NP 问题的地方。

P-问题是可以在“合理的时间”内解决的问题，这里的“合理”是指“多项式”(因此 P)。寻找这些问题的解决方案的计算复杂度随着问题的输入大小的某种幂而增长。思考乘法或排序问题。

另一方面，NP-问题是不能在合理的时间内解决的问题。NP 代表非确定性多项式，意味着可以用多项式计算复杂性来确认解决方案，但无法找到。寻找 NP-问题的解的复杂性是指数的而不是多项式的，这造成了巨大的实际差异。NP 问题的例子有最优调度、预测蛋白质如何折叠、加密消息、解决数独难题、最优打包(也称为背包问题)或最优路由(也称为旅行推销员问题)。一些问题，比如寻找一个函数的离散傅立叶变换，从 NP 开始，但最终在 P 中结束，因为新的、聪明的算法的发展简化了解决方案。

当今计算机科学中最大的未解问题之一是 P 对 NP 问题:P 是否等于 NP？换句话说，对于所有我们可以在合理的时间内确认解决方案的问题，我们也可以在合理的时间内找到解决方案吗？

P 与 NP 的问题如此重要，以至于它被列入了千年奖问题清单，如果你找到答案，你将赢得一百万美元。很难夸大这个问题的重要性:一个 P=NP 的世界将与一个 P≠NP 的世界有根本的不同。如果 P=NP，那么我们可以肯定地说，有一种更快的方法来解决数独难题，或者预测蛋白质如何折叠，只是我们还没有找到那种方法。不用说，了解蛋白质是如何折叠的可能会对现实世界产生各种各样的影响，比如了解阿尔茨海默氏症或治愈癌症。

今天大多数科学家认为 P 不等于 NP，但是我们真的会知道吗？P vs NP 问题本身可能类似于希尔伯特的 Entscheidungsproblem 或图灵的停机问题:这个问题可能根本没有答案。

资源和进一步阅读

复杂性，导游(梅勒妮·米切尔)
P vs NP 和复杂性动物园(视频)
哥德尔不完全定理(视频)

如果你喜欢这篇文章，也可以看看以下内容:

[## 如何少犯错误

用有限数据预测未来的贝叶斯指南

towardsdatascience.com](/how-to-be-less-wrong-5d6632a08f) [## 偶然形成的轨迹

物理、金融和我们生活中的随机漫步

medium.com](https://medium.com/swlh/trajectories-formed-by-chance-bc96c8e236a5)

简单地说，线性回归方程

原文：https://towardsdatascience.com/the-linear-regression-equation-in-a-nutshell-8df202501255?source=collection_archive---------15-----------------------

“回归图前的家伙”使用未画的剪贴画|作者图片

回归到底是什么？回归分析是根据其他一些变量来预测某个变量的值或属性。而线性回归是当只有一个变量，你想根据另一个单一的变量来预测。

定义

实际上，我在学校学到的简单线性回归的正式定义是，通过一个变量 y 对另一个变量 x 的回归，我们指的是 y 对 x 的依赖，平均而言。这是你可以写在考卷上的更多答案。回归的概念实际上要简单得多。

回归实际上是寻找图表中数据集的趋势。如果画回归线(流行语预警！)通过散点图，只要看着这条线，你就能判断出某个事物的趋势是上升还是下降！！

作者的 matplotlib 散点图|图片

你应该知道回归分析是计算和制定直线方程的方法(不要担心我们会得到它)，而回归线就是直线本身。而简单回归的方程是一条线的方程。

Y = mX + b

直觉

浏览互联网时，你会发现两种直观的线性回归方法。一个是人们会告诉你回归是一种方法，你可以预测一个变量的值，比如说，y，输入 x，你可能已经知道了，这没问题！(这是 ML 的最佳方法)

另一种方法是我在定义中定义的。想想看，你可以在散点图上画出成千上万条线，但是最符合并且不同于所有其他线的线就是回归线。讲出来在下一段！

matplotlib 散点图中的各种线条|图片由作者提供

预测的方法是正确的，但不是 100%有保证，这就是为什么在我的教科书中，在定义的末尾写着:“平均而言”。要知道为什么这是真的，你和我必须深入研究均方差。).现在，把它想象成一个函数，它告诉你这条线工作得有多好。均方差的值越低，线条应该越好。

均方误差

正如我前面说过的，平方误差是一个函数，可以知道相对于绘制的数据，线中存在多少误差，线越好，mse 的值越小。

现在让我们学习如何找到 mse，这样你就可以自己计算了。从下面的图中，让我们假设蓝线是回归线，然后我们将试图找到该线与图中(yᵢxᵢ)标为红色的点的垂直距离。

也就是说，我们从 Yᵢ点的实际高度中减去 xᵢ点，也就是 yᵢ点的线的高度，假设值是 eᵢ

eᵢ = yᵢ - Yᵢ

matplotlib |图像中直线和点的距离(由作者提供)

现在以同样的方式，我们把 eᵢ的所有值加起来，

∑eᵢ = ∑(yᵢ — Yᵢ)

现在你自己想一想，有些点可能在直线上，直线下可能有更多的点，这可能使总和为负，但惯例决定让 mse 为正值，以便更好地理解。

现在，如果我们使用模数使数值为正，那么随着图中更多的数据点，数值将变得太大。所以伟大的头脑决定在相加之前先求平方值。然后在相加之后，他们建议将总和除以数据集的总计数。因此它被称为均方差。

MSE 方程|作者方程

线性回归方程

正如我在直觉部分所说的，均方差(mse)值越低，这条线就越好，被称为最佳拟合。由于 mse 本身不可能为 0(实际上在大多数情况下不可能，但并非所有情况下都是如此)，我们必须通过简化 mse 方程来找到 mse 的最小值。

简化 mse 的方程式后，会是这样的，

作者对均方误差方程的扩展

其中 n 是存在的数据点总数，r 是数据集的相关性值，sₓ和 sᵧ分别是所有 y 值和 x 值的标准偏差，x̅ ̄ & y̅分别是 x 和 y 值的平均值。

现在，由于 r 总是位于-1 到 1 之间，r 可以导致sᵧ(1-r)为 0，而 sᵧ本身不能为 0，这一项的帮助并不能真正方便地制定线性回归方程。

现在，如果 (msₓ-rsᵧ) = 0，那么 m = r(sᵧ/sₓ) ，其中 m 也可以写成 mᵧₓ (听起来像 m 在 x 上的 y)。
现在，如果 (y̅ — b — mx̅̄) = 0 ，那么， y̅ = b + mx̅ ，或者 b = y̅ — mᵧₓx̅̄ ，其中 b 也可以写成 bᵧₓ(听起来像 b 在 x 上的 y)。

现在，如果你把 bᵧₓ和 mᵧₓ的值放入我们在定义中讨论过的主要线性方程中，它看起来会像这样，

作者推导回归方程|方程

是的，我知道这对于一个方程来说看起来很难看，但是你不需要每次都记住它。请记住，斜率只是相关乘以标准差的比率，截距看起来像旧的线性方程，其中 x 和 Y 分别是平均值，x 被视为 xi，因为 Y 将是 x 输入线的未知数。

matplotlib |作者图片中的最佳拟合线

这是回归线最终外观的可视化表示。如果你输入一个在计算中没有用到的值，你会得到 y 的预测值，它会像红点一样出现在这条线上。

重要提示

这是大多数回归新手会犯的错误，仔细看我用了 mᵧₓ 和 bᵧₓ 这是 y 在 x 上而不是 x 在 y 上，因为这意味着我们将用 x 的值作为函数输入来预测 y 的值。

只有在这种情况下，我才把 mse 的等式表述为 yᵢ — Yᵢ 。但是，如果你想在某一天根据输入的 y 来预测 x 的值，你必须用xᵢ——xᵢ来计算 mse，因为如果你仔细想想，某个数据点的水平距离与它到直线的垂直距离有很大的不同。

那么斜率就会变成 mₓᵧ = r(sᵧ/sₓ) (仔细看标准差的比值是 mᵧₓ值的倒数，现在听起来是 x 对 y)。截距将变成b =x̅̄——mₓᵧy̅,最终等式将是这样的， X = mₓᵧyᵢ + bₓᵧ

matplotlib | Image 中 y 对 x 和 x 对 y 的回归方程

这条蓝线是您想要基于 x 预测 y 值的函数的方程，绿线是您想要基于 y 预测 x 的函数。这证明没有一条回归线是另一条回归线的反函数。

结论

线性回归通常用于数据科学家领域，作为一种机器学习模型，主要作为一些分析领域的统计工具。如果你已经仔细阅读，尽管这篇文章有多长，线性回归背后的数学太简单了。在那件事上你必须支持我！

流动性效应:对美国股票和黄金的分析

原文：https://towardsdatascience.com/the-liquidity-effect-an-analysis-of-us-equities-gold-eb12e6d92caf?source=collection_archive---------65-----------------------

货币扩张如何影响黄金和美国股市不同板块的表现？在货币制度相对稳定的时期，趋势是否有所不同？

照片由来自 Pexels 的大卫·麦克比拍摄

注:这不是投资建议。

我以谈论 2020 年上半年发生的历史性事件结束了我的上一篇帖子——多次触发断路开关、美联储宣布“无限量化宽松”以及随后购买美国公司债务。作为一个将沃伦·巴菲特的价值投资原则与宏观经济趋势相结合的人，美联储最近注入的流动性让我质疑我的核心投资理念。我决定使用历史数据来观察不同资产类别在量化宽松(QE) 和量化紧缩(QT) 期间的相对表现，以了解潜在趋势的迹象。

我意识到这个主题包含了很多内容，所以我将这篇文章集中在以下几个要点上:

市场情绪从价值股转向成长股
黄金作为一种天然的市场对冲
美国股票市场的估值

数据准备

我所有的数据都是从雅虎财经获得的，在那里你可以下载几乎所有在主要指数上交易的股票或 ETF/ETN/ETP 的历史价格。唯一的警告是——在分析之前需要考虑股息和股票分割(如果每只股票都像伯克希尔·哈撒韦公司的 A 类股一样运作，对吗？).我下载股息历史、历史股价和股票分割(如果适用)并计算相关股票/ETF 的实际价格:

结果输出如下所示:

衡量任何资产表现的最常见方法是计算从开始日期开始的回报率，并与时间复合。python 中的 Performance Analytics 包不符合我的要求，所以我创建了一个自定义方法来计算给定资产的回报:

因为我想分析 QE 期和 QT 期之间的表现，所以我从他们的网站下载了美联储总资产的历史，以估计 QE 和 QT 的日期范围，供以后分析。美联储的资产负债表(以百万美元计)如下:

用红色突出显示的区域表示美国经济衰退的时期(是的，我们目前正处于衰退中)。人们可以看到在经济衰退期间货币刺激的使用，美联储将其资产负债表从大约。2008 年至 2015 年间的 1 万亿至 4.5 万亿美元。仅在 2020 年 2 月至 2020 年 6 月期间，美联储就实施了 3 万亿美元的资产购买，相比之下，上一轮刺激措施相形见绌。我将把这两个时期用于 QE，2004 年至 2020 年的剩余时间将被视为稳健货币政策的时期。

人气从价值转向增长

优秀的基本面、稳定的自由现金流和强劲的资产负债表是沃伦·巴菲特投资哲学的特质。他发现了被低估的公司，并进行长期投资，在此过程中获得了股息和投资组合的增长。然而，成长型公司并不吹嘘有很大(或任何)的利润，而是实现销售的指数增长，牺牲短期利润。这些公司最终可能发展成为高价值公司，或者破产。

在我的分析中，我使用了$SPYG 和$SPYV 指数，分别跟踪 S&P500 的成长型和价值型公司。我首先绘制了这两个指数从 2001 年到 2020 年的累积回报，以及 SPYV 和 SPYG 价格随时间的比率，以获得两者之间的趋同感。

价值与增长的权衡:价值(蓝色)胜过增长(绿色)，直到 2008 年衰退

从上面的图片中可以看出一些有趣的地方:

在 2008 年大衰退之前，价值跑赢了增长，此后一直呈下降趋势
从 2002 年到 2008 年，增长几乎停滞不前，但经历了衰退后的天文数字般的增长
2020 年标志着成长型股票的复合回报率在过去 20 年中首次超过价值

2000 年的网络泡沫主要集中在 90 年代牛市期间私人投资推动的严重高估的科技股上。美联储没有干预直接向市场注入任何流动性，这可能是 2008 年经济增长如此艰难的原因。在大衰退之后，经济经历了快速的货币扩张，导致利率处于历史低位。私营企业以接近零的利率获得了急需的资本，这为这些股票的上涨再次推波助澜。

为了通过 QE 和 QT 直观显示相对表现，我将这两个指数的复合回报分成不同的时间段

以上图表有助于讲述一个详细的故事:

价值明显优于 2008 年，增长将持续到 2016 年，这可能是由于廉价资本的可用性
2016 年至 2017 年年中似乎是两者之间的一场掷地有声的比赛，但似乎有另一个刺激因素再次推动估值上升——总统可能会胜过 TCJA 比尔？
美联储在 2018 年 12 月抛售后的温和行动解释了随后的反弹

Soo……价值投资死了吗？

也许吧。或者，一段时间的 QT 将迎来经典投资原则的新时代。似乎价值投资在资金充裕的环境下非常有效，但这在目前并不现实。

黄金作为市场避险工具

在市场动荡时期，黄金一直是避风港，在危机期间提供风险调整后的回报和急需的流动性。由于它不易受到货币操纵的影响，在疯狂印钞和通货膨胀期间，它充当了价值储存手段。我绘制了与上面相同的图表，比较黄金和 S&P500:

与 S&P500 相比，2001 年至 2012 年似乎是投资黄金的最佳时机，最近几个月又出现了上涨。我对黄金和 S&P500 的比率进行移动平均交叉分析，以了解长期投资趋势。我选择 200 天和 50 个月的简单移动平均线(SMA)进行分析，因为我在寻找一个大的日期范围，它平滑了短期波动，表明长期买入机会。

黄金 S&P500 比值的均值反演分析。短期和长期移动平均线的交叉可以表示看涨(黄金交叉)或看跌(死亡交叉)信号

短期移动平均线(在这种情况下，200 日移动平均线)高于长期移动平均线表明出现了“黄金交叉”，这通常是该资产的买入机会。相反，较高的长期均线交叉表示死亡交叉。与 S&P500 相比，2003 年至 2012 年是购买黄金的好机会，如果美联储继续印钞，似乎另一轮上涨可能会变成牛市，推动金价上涨。指数移动平均线(EMA)是另一个可以用来衡量趋势的工具。EMA 更重视当前数据。最新的价格数据对移动平均线的影响更大，旧的价格数据影响较小，使其对当前价格波动的反应更大。

基于均线的黄金 S&P500 比率均值反演分析。短期和长期移动平均线的交叉可以表示看涨(黄金交叉)或看跌(死亡交叉)信号

虽然总的趋势保持不变，但是均线和均线相比有更大的差距。这告诉我，黄金可能会出现长期突破，但它需要另一种催化剂才能继续上涨。

美国股票市场的估值

投资界使用多种指标来确定与历史数据相比，股票市场是过高还是过低。S&P500 可能接近历史高点，但这并不意味着它在这些水平上被高估了。我使用一段时间内标准普尔 500 与黄金的比率来获得市场的跨资产视图，并查看标准普尔 500 是否达到了历史最高水平。

尽管标准普尔 500/黄金比率处于 2007/08 年的水平，但远低于互联网泡沫破裂时的峰值。上图启发我观察 SPY 指数的不同板块(特别是科技股),寻找超买的迹象。我首先关注纳斯达克综合指数，它包含了更广泛市场中的所有科技股。技术在过去十年中经历了最大的增长，使其成为理想的首选。我比较了纳斯达克和 S&P 的比率，看前者指数的相对增长。

纳斯达克/S&P500 比率上次处于这些水平是在 2000 年网络泡沫时期，但这次的增长率似乎有所不同。私人投资涌入科技行业，在很短时间内将价值推至过高水平。纳斯达克指数可能与 2000 年代处于同一水平，但大部分上涨可归因于 5 只大型科技股。在过去几十年里，受指数增长和廉价资本的推动，技术作为一个整体一直跑赢大盘。我将科技股从更广泛的指数中分离出来，并与所有其他板块的综合表现进行比较。它有助于描绘出一幅科技行业全面占据绝对主导地位的画面，从而产生了历史上第一次万亿美元的估值。

自 2016 年以来，不包括技术在内的市场仅上涨了约 35%，而技术板块却出现了爆炸式增长，在同一时间段内实现了 170%的回报率！尽管市场尚未从 3 月份的恐慌性抛售中恢复过来，但科技股已经创下了今年的又一个新高。我们会重蹈 2001 年的覆辙吗？

离别的思绪

十多年来，在资本投资和低利率的推动下，增长盖过了传统的价值投资。如果借贷成本再次上升，或者人为的流动性突然被吸出市场，市场就可能发生逆转。鉴于目前的市场状况，这两种可能性都不大。
黄金/S&P500 比率是衡量相对于股票表现的良好指标，有助于衡量更广泛的市场情绪。黄金似乎预示着在合适的催化剂下开始另一轮上涨(也许是更多的货币刺激？).
技术一直是历史上最长牛市的领跑者，只有时间才能证明这些估值是新常态，还是该行业将会突然觉醒。

在这种时期投资可能具有挑战性——申请破产的公司在消息传出后估值飙升，使得市场上的意外波动似乎很正常。有什么好的交易技巧来应对这种市场波动？我的答案是——动量投资(即将推出)。

感谢您的阅读！如果你认为我错过了一些可以帮助你了解这个话题的东西，请告诉我，你的反馈将会非常感谢。下面是 Github 的链接。

[## 然后 namesvik/quantified easing effects _ Equities

GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码、管理项目和构建…

github.com](https://github.com/thenamesvik/QuantitativeEasingEffects_Equities)

建模的逻辑:认识论笔记

原文：https://towardsdatascience.com/the-logic-of-modeling-an-epistemological-note-88e524e14e62?source=collection_archive---------32-----------------------

简介

在的上一篇文章中，我讨论了回归分析的因果建模。此外，我解释了机器学习的逻辑如何偏离定量社会科学的逻辑，因为它的主要目的不是揭示因果联系并生成关于人类行为的全面主张。
然而，这种情况比大多数在学术环境之外使用回归和机器学习的人所认为的要有限得多。顾问通常需要产生关于生产的投入和产出、管理实践和可交付成果之间的关系的知识。通常，他们会对员工表现不佳、员工流失和延误进行根本原因分析。无论是否理解了支配推理的规则，人们通常都会在考虑因果关系的情况下做出决定，并对真理做出一些承诺。因此，统计学习最终与因果推理融合在一起，尽管程度不同，取决于对发现的使用。

在那篇文章中，我解释了科学与非科学话语的区别，即程序合法性和可证伪性。尽管科学家很少逃脱被描绘成真理的吸盘，但他们的角色更容易被理解为陪审员，他们唯一且庄严地向科学进程宣誓。这是因为程序合法性的概念是科学的核心，而实质合法性是由宗教和大多数公共话语支撑的。程序合法性的核心是可证伪性，或认为科学是一个筛选过程，剔除与证据不一致或不连贯的观点。虽然那些在象牙塔外工作的人可能会把这些视为哲学上的诡辩，但研究和理论之间的墙，以及商业和生产之间的墙，是越来越薄的。如今，企业界带来的大部分附加值都来自于那些严重依赖与科研机构之间的桥梁的公司。正因为如此，引入科学精神可能有助于他们吸引和留住人才，否则这些人才将被学术界没收。此外，科学的精神通过奖励合理的逻辑和长期主义而不是成就和短期主义来培养开放、宽容和创造力。

超越因果性:可证伪性

在前面提到的文章中，我列出了在回归分析中证明因果关系的条件。因果关系的条件是: i 非虚假性； ii 协变；以及 iii 存在一个貌似随意的环节(或传动链)。对于非虚假性，必须在一个映射分析的自变量和因变量之间的关系的经验模型中指定所有的前因、所有的调节因素，而没有中介因素。当这种情况发生时，系数代表自变量对因变量的总体影响的估计。如果它们的相关性是显著的，并且某种生成过程似乎控制着这种联系，那么只有这样才能推断出这种影响是因果的。这里重要的是: a 生成过程或传递链是永远无法观测到的，必须来自理论模型；因果关系的主张从来都不是对真理的主张，而只是对经验模型与理论模型的一致性的主张。

暗示 a 对于定量社会科学来说是相当重要的。尽管方法论研究让研究人员拥有了更好的工具来打破变量之间的关系——准实验就是一个例子——但它没有赋予他们找到因果联系的定量方法，而且永远不会。因为只有协变的结构被揭示，而根本的过程从未被揭示，定量社会科学将总是依赖于理论模型，无论是人类行为的数学或定性理论。
暗示 b 对社会科学、自然科学和非学术实践有着广泛的影响。一次打开因果关系的大门，并不意味着此后这门就永远锁上了。与放弃质疑其宗教信条或某些定义其核心信条的权利的宗教信徒不同——如果他们不放弃这种权利，他们就不是信徒——那些参与科学讨论的人不能承诺他们任何主张的真理价值。他们同意用科学方法测试任何假设，同时放弃他们对所有假设真值的承诺。研究人员最终致力于科学的过程，这意味着任何发现，无论多么有力，都可能在一些无法预料的情况下被证伪。
尽管对上述三个领域(社会科学、自然科学和非学术实践)的大多数人来说，因果关系和相关性之间的区别有些容易，但对证伪的更深入理解通常并不容易。这对于公司环境来说尤其是个问题，在公司环境中，决策是基于被认证为验证的规则而定期做出的。或许更重要的是，这是公共话语和我们社会结构的问题。舆论制造者竞相争取大众的支持，政治家竞相争取最多的选票，名人寻求扩大自己的粉丝群。然而，他们大多信奉某种既定的观念或价值观，而不是最初引导他们接受这些观念或价值观的过程。直到公共话语在实质上(“什么”)而不是在程序上(“如何”)被合法化的那一刻，它将更多地由宗教构成，而不是由科学构成。

退一步讲，为什么造假这么重要？尽管科学哲学已经采取了超越它的措施，但它还没有真正摆脱它。这是因为证伪原则依赖于科学中的推理逻辑。要知道为什么，我们应该看看推理的两个基本规则，即推理模式和推理模式。
模因托伦斯规则指出，要证明任何给定的理论是错误的，有且只有一个反驳是必要的。一个一般的理论总是以这样的形式出现:如果 T，那么 p——你可以随意把 T 看作理论，把 p 看作命题——因此观察 p 就足以使 T 出错。该规则提供了一个清晰的决策规则，是科学的瑞士军刀。假言规则——p，然后 A——不具有相同的性质，可能不能作为科学与非科学的分界线。观察 p 并不排除以下观察( q ， f ，…， n )会使 T 为假，也不排除 p 可能在以后的任何时间被观察到。无论有多少证实性的观察，都不足以在以后的阶段排除负面的观察。相反，一个理论真的只需要一次证伪就可以被否定。卡尔·波普尔(Karl Popper)认为证伪和验证是不对称的，他认为大部分经验观察是科学的基石。然而， p 也可以是任何理论命题，它将证伪的范围延伸到了经验主义的边界之外。不仅仅是一个证伪就能击败一个概括的主张，事实上，它需要一个不一致才能被宣布无效。
基于这一点，斯坦利&坎贝尔注意到“理论测试数据收集的任务主要是拒绝不充分的假设”( 1963，第 35 页)。因此，理论是一组经验和理论命题——在蒯因的和两个经验主义的教条 出版后，这两者之间的界限一直困扰着认识论者，并作为进一步反驳尝试的无效假设。科学家通过测试替代解释来挑战现有理论:他们淘汰的越多，理论要求的确定性水平就越高。然而，在这个过程的任意阶段，我们只能说一些理论更符合现有的证据，但绝不能说一些理论是正确的。这些理论被赋予这样的地位是因为经受住了更强有力的驳斥，剔除了更多可供选择的假设。因此，它们在某些点上提供了更大的确定性，这并不是说它们是真的。

认识论在起作用:对技能溢价的另类解释

人们经常讨论教育和收入之间的联系是什么，有多强，所以我最近在写了一篇关于新冠肺炎大学学费的文章。经济学家经常使用工资公式来表示个人收入，作为他们的教育和其他控制因素的函数。计算教育的最天真的方法是用受教育年限来表示:在其他条件不变的情况下，相对于受教育年限较短的人，受教育年限较长的人预期会挣得更多。其他条件不变条件要求在工资模型中规定所有相关控制因素，包括年龄和工作经验年限等变量。因果模型在这里有点棘手，因为箭头指向彼此的方式往往因地点和职业类型而异。通常，年纪大的人更有可能有更多年的工作经验，因此赚更多的钱；此外，他们通常更擅长这项工作，因为他们经历了学习曲线。因此，多年的经验对收入既有间接影响，也有直接影响。对于学习曲线不陡峭的职业和技能要求周转快、贬值快的职业来说，情况就不那么真实了。

说到教育，受教育程度越高的工人通常工资越高。这被称为“技能溢价”,经济学家对其进行了左右南北的估算。技能溢价是对教育投资回报率的一种衡量，被经济合作与发展组织(OECD)等国际组织用来比较各经济体及其社会流动性程度。
技能溢价真正抓住了什么？为什么受教育程度更高的工人要求更高的工资，人类行为的什么基本理论提供了因果函数？几十年来，教育学者提出了两个假说，即人力资本理论和教育信号理论。在我引用的那篇文章中，我用这两者来洞察为什么大学在转向在线教学后保持其价格点。

对我们来说，重要的是这两个理论都与积极的技能溢价相一致，尽管链接功能非常不同。在人力资本框架中，教育提高了工人的生产力，使他们能够以更具成本效益的方式更有效地完成任务。值得注意的是，如果人力资本理论是我们的指导假设，我们应该考虑教育和多年工作经验的相互作用:更多的技术工人预计会以更快的速度学习曲线，并更多地利用他们在工作中获得的经验。
信号假说是也是与积极的技能溢价相一致。我不会在这里详细介绍这个理论，而将讨论限制在介绍它的核心假设。雇主对申请人是否适合职位空缺知之甚少，招聘只能占用他们这么多时间。此外，申请人有动机夸大自己的能力，申请他们并不真正胜任的工作。最重要的是，许多工作在本质上并不是真正的技术性工作，但需要高水平的能力才能有效地完成。人力资源和管理工作就是这样一个例子，还有很多；相比之下，工程和编程工作的准入门槛要高得多，会让那些知识领域不包含一些明确定义的技能的求职者望而却步。就业市场充斥着信息不对称和负面激励，有些工作比其他工作更容易受到这些因素的影响。
问题是，雇主能做些什么来把不合适的求职者挡在门外？信号给出的答案是凭证或学位。学位和证书(例如，分数)可能不会给我们的技能组合增加多少，但它们可以区分适合和不适合。能力水平高的人在课程中进步更快，成绩也更高。因此，他们发出信号表明自己是健康的。能力水平较低的人——我们这里说的是一般能力，并假设存在这样一种能力，这又是一个大问号——会表现得更差，甚至可能在比赛开始前被淘汰，无论是因为考试成绩差还是学业成绩不理想。

附带说明一下，人力资本阵营最近安抚了信号，承认它“开启了对教育市场的非常现实的理解，并与人力资本的观点很好地结合”。在实践中,,当还不清楚是否可以将对立的理论归纳为共同的子成分时，它们可能会在一个更大的范式中达成一致。我们将不讨论为什么人力资本和信号目前在理性选择的更广泛框架内共存，但重要的是要承认科学在实践中是如何工作的。要解释这一点，需要更深入地探究科学的认识论，尤其是伊姆雷·拉卡托斯的“研究计划”。仅出于演示的目的，我们将假设人力资本和信号是不可约的，并且一次只能有一个是真的。

下图显示了与人力资本和教育信号相对应的两个逻辑模型。值得注意的是，前者在从教育到工资的路径中引入了一个中介因素，即人力资本。为了简单起见，我没有考虑人力资本和工作经验的相互作用，尽管一个成熟的逻辑模型可能应该考虑。教育对人力资本有积极的影响，通过提高工人的生产力来提高他们的工资。如果信号不存在，并且我们可以获得一个完美的人力资本衡量标准，并在模型中加以说明，那么教育年限对收入的剩余或部分影响在统计上不会与零不同。如果人力资本理论正确地描述了教育和工资之间的联系，那么这个一定是这样的。
相比之下，信号框架引入能力作为教育的前提。能力水平较高的人获得更多的教育，而教育表明他们有能力找到收入更高的工作。因为能力和教育是协变量，教育和人力资本也是协变量，所以两个模型都认为教育对工资的独立影响为零。这一观察结果相当重要，并质疑标准工资模型作为人力资本与信号假说的合法测试。

因果模型:人力资本

因果模型:信号

那么合法的测试会是什么样的呢？先说一个这样的测试来之不易。一个人一定很挑剔。更重要的是，无论什么样的测试都只能得出这样的结论:其中一个理论与人类行为一致，而另一个则不一致。它永远不会为那个理论提供确凿的证据，也永远不会得出这个理论是正确的结论。教育学者过去使用的少数测试之一是课程作业的变化。当相邻群体的课程要求发生变化时，一个人在获得相同学位的同时，结束了或多或少的受教育年数，那么接受更多教育年数的群体肯定有更高的工资，这样人力资本理论就不会验证错误。反过来说，这两个群体肯定有相同的工资，因为他们发出了不要测试错误的信号。值得注意的是，这两个陈述不能被重新表述为“……为了让理论[X]检验真实的”。
所有这些都可以而且必须形式化:

HK wT6w HK

其中, HK 是教育的人力资本理论, w 是“在其他条件相同的情况下，接受更多年教育的个人挣得更多”的命题。如果 w 不成立，则的规则会使理论无效。另一方面，假言规则假定:

S w
w S∩T1∩…∩Tn**

从 w 可能无法推断出 S 为真，只能推断出 w 与 S 为真一致。然而，任何现阶段尚未考虑的理论( T1 ，…， Tn )都可能是真的。“验证”在这里意味着的迄今为止与人类行为一致，而不是理论是真的。路德维希·维特斯坦根的哲学家们从未完全接受验证的消亡，并得出结论说，一个人必须从科学之外的地方寻找真理和价值。从纯逻辑的角度来看，他们实际上是非常正确的，尽管我们不一定会被他们的反科学观点所迷惑。然而，它们让我们明白，进入科学话语是关于拥抱科学的过程，而不是拥抱世界的任何特定描述。这可能与科学家是热情的真理追求者的观点相冲突；作为个人，他们可能是，然而，科学的精神本质上是程序性的，而不是实质性的。

结论

这篇文章旨在成为研究和商业环境中统计推断和机器学习用户的认识论入门。从我自己的经验来看，我看到太多的人称赞科学是寻求真理的，而很少有人理解作为科学方法特征的程序合法性的形式。这并不意味着是理论哲学的练习。比起“可交付成果”,那些更关心发现过程——或者用波普尔的话说，发现逻辑——的经理们会支持企业文化向长期主义和开放的转变。尽管科学看起来是无情的，但从本质上来说，它并不是性能驱动的。草根文化的改变如果想要持久，就需要有强大的哲学基础。可证伪性和推理的逻辑是这些基础，所以让我们传播这个词，使它们成为公共领域。

遗失登机牌的问题

原文：https://towardsdatascience.com/the-lost-boarding-pass-problem-2a17313b2d8a?source=collection_archive---------22-----------------------

使用蒙特卡罗和一个惊人简单的解析解解决概率难题

马库斯·温克勒在 Unsplash 上的照片

在一个售罄的航班上，100 人排队登机。队伍中的第一位乘客丢失了登机牌，但还是被允许进去。他随便找了个座位坐下。每个随后的乘客坐在他们指定的座位上(如果有的话),否则坐在随机的空座位上。
最后一个登机的乘客发现他们的座位没人坐的概率有多大？

如果你的第一反应是描绘出登机人数较少的可能性，我邀请你花点时间自己尝试一下这个难题。这种方法给我带来了巨大的痛苦，我不想剥夺你的这种体验。

或者，继续阅读蒙特卡罗模拟和解析解的解释。

蒙特卡罗模拟

由于对自己未能手动解决问题感到恼火，我很快用 Python 打出了一个杂乱的蒙特卡洛模拟:

import random
import numpy as npairplane = []#positive indicates that the criteria (last passenger reaches their seat) is fulfilled & vice versapositive = 0
negative = 0#constructing airplane
for i in range (1,101):
    airplane.append(i)def simulate():

    global airplane
    global positive
    global negative#first passenger
    airplane.remove(np.random.choice(airplane))#subsequent passengers
for i in range (2,100):
        if i in airplane:
            airplane.remove(i)
        else:
            airplane.remove(np.random.choice(airplane))if 100 in airplane:
        positive += 1
    else:
        negative += 1airplane = []
    for i in range (1,101):
        airplane.append(i)#running 100k trials
for i in range (0,100000):
    simulate()print(positive/(positive+negative)*100)Output: 50.076

通过蒙特卡洛计算，最后一名乘客找到座位的概率约为 50%。考虑到它代表了一架 100 人飞机中坐在特定座位上的最后一名乘客，我发现概率如此之高令人惊讶。

这是另一个概率难题，我们的直觉让我们失望了。这让我特别想起了生日悖论，在这个悖论中，由于存在严重缺陷的心理计算，大多数人也倾向于大大低估某种结果的概率。

分析解

真正的概率是正好 1/2 。原因如下:

乔纳森·法伯在 Unsplash 上拍摄的照片

从这一点开始，我按照进入的顺序引用乘客和分配给他们的座位，例如第一个登机的乘客是乘客 1，最后一个登机的乘客是乘客 100。类似地，座位 1 是乘客 1 的指定座位，依此类推。

事实:乘客 100 将坐在座位 100(他被分配的座位)或座位 1。

从第一个和最后一个乘客登机的角度来看，我最能理解这种观察。乘客 2–99 有两种可能。

乘客的指定座位是空的。他们坐在那个座位上。
乘客的指定座位被占用了。他们随意坐在其他座位上。

在这些乘客中的每一个在飞机上就座之后，他们被分配的座位被占用是必然真实的。要么是先前未被占用(上面的选项 1)并且他们坐在里面，要么是已经被占用(选项 2)。

在最后一名乘客登机前，2-99 号乘客的指定座位已被占用。此时，99 个人(包括乘客 1)已经就座，这意味着只有一个座位仍然空着。

由于还剩一个座位，且 2-99 号座位肯定有人，因此空座位必须是 1 号座位或 100 号座位。在最后一批乘客登机之前，座位 1 和座位 100 都不可能被占满，因为这意味着飞机上的所有 100 个座位都只有 99 名乘客。

事实:最后一名乘客坐在座位 1 和座位 100 的概率相等。

当最后一名乘客登机时，丢失登机牌问题的结果已经确定，因为只有一个座位可供他们选择。因此，我们必须看看乘客 1-99 所面临的决定。

对于乘客 1，选择 100 个座位中任何一个的概率是相等的。推而广之，他选择自己指定座位的概率和他选择最后一个乘客指定座位的概率是相等的。

乘客 2-99 坐在座位 1 或座位 100 的唯一方式是他们被分配的座位被占用。在这种情况下，坐在任何一个空座位上的概率也是相等的。

虽然座位 1 和座位 100 都是空的，但是同样有可能选择其中一个座位。在这两个座位中的一个被占用后，另一个座位保证保持空闲，直到最后一名乘客登机。座位 100 被先前的乘客占据的概率是 1/2。

因此，最后一名乘客发现自己座位没人坐的概率也是 1/2。

虽然我是一个非常没有经验的程序员，但通过 Python 使用蒙特卡罗解决丢失登机牌问题仍然比用解析方法解决要快得多。我可以在这里说一些关于模拟在解决问题中的力量，但是你可能已经听过了。

相反，我将公开感谢那些提出让航空公司在登机口打印登机牌的人。

来源

遗失登机牌的问题并没有在网上大量出现，尽管我能够找到略有不同的措辞版本:这里的、这里的和这里的。

[## Tanae Rao -中等

阅读 Tanae Rao 在媒体上的文章。牛津大学哲学、政治和经济学(即将出版)。每天，塔娜·饶…

medium.com](https://medium.com/@raotanae)

彩票假说:一个综述

原文：https://towardsdatascience.com/the-lottery-ticket-hypothesis-a-survey-d1f0f62f8884?source=collection_archive---------11-----------------------

隐喻是将思想从一个头脑传递到另一个头脑的强大工具。1970 年，艾伦·凯在 PARC 施乐公司介绍了术语“桌面”的另一种含义。如今，每个人——只需一瞬间——都想知道当提到桌面时，它到底是什么意思。最近，深度学习有幸迎来了一个新的强大隐喻:彩票假说(LTH)。但是这个假设试图传递什么思想呢？在今天的帖子中，我们深入研究了这一假设，并回顾了最初由 Frankle & Carbin (2019) 获得 ICLR 最佳论文奖后的文献。

深度学习✂️中的剪枝

修剪过度参数化的神经网络在深度学习中有着悠久的传统。最常见的是将特定的重量设置为 0，并在随后的训练过程中保持不变。这可以通过将权重 W 与二进制修剪掩码 m 逐元素相乘来容易地完成。进行这种外科手术有几个激励因素:

它通过正则化过度参数化的函数来支持泛化。
它通过识别能够适合内存的性能良好的较小网络来减少推理时间期间的内存约束。
它降低了能源成本、计算、存储和延迟，这些都可以支持在移动设备上的部署。

随着最近越来越深的网络的出现，所有这三个因素都重新受到关注。概括地说，任何竞争剪枝算法都必须解决 4 个基本问题:

要修剪哪些连接结构？ : 非结构化修剪不考虑修剪后的权重之间的任何关系。另一方面，结构化修剪按组修剪权重，例如通过移除整个神经元(权重列)、过滤器或 CNN 的通道。虽然非结构化修剪通常允许更大幅度地减少权重的数量(同时保持高性能)，但这并不一定要在标准硬件上加速计算。这里的关键是密集计算可以很容易地并行化，而“分散”计算则不能。另一个区别是全局修剪和局部修剪。局部修剪强制修剪每层的 s 百分比的权重。另一方面，全局修剪是不受限制的，并且简单地要求整个网络上的权重总数被修剪了 s 百分比。

修剪什么、如何修剪、何时修剪以及多久修剪一次？

如何对权重进行排序修剪？:有许多或多或少的启发式方法来对网络中特定权重的重要性进行评分。一个常见的经验法则是，较大幅度的权重对函数拟合有更大的影响，应该减少修剪。虽然在实践中效果很好，但直觉上这似乎与诸如 L2 权重正则化的想法相矛盾，后者实际上惩罚了大量的权重。这激发了使用基于梯度的方法或者甚至更高阶曲率信息来学习修剪掩模的更复杂的技术。
多久修剪一次？:体重量通常只是体重重要性的一个嘈杂的代理。在训练结束时只修剪一次(一次性)就会成为这种噪音的牺牲品。另一方面，迭代程序在一次训练运行后仅修剪少量权重，但重复训练-得分-修剪-回卷循环。这通常有助于消除整个修剪过程中的噪声。通常，每次迭代的修剪率大约为 20%，总共使用 20 到 30 次修剪迭代(这使得我们只有 1%的未修剪权重)。一个人可以更保守——以更长时间的训练为代价！
何时执行修剪步骤？:可以在网络训练的 3 个不同阶段进行修剪——训练后、训练中和训练前。当训练收敛后进行修剪时，性能通常会下降，这使得有必要重新训练/微调并给网络一个重新调整的机会。另一方面，训练期间的修剪通常与正则化和丢弃/加强分布式表示的想法相关联。直到最近，从头开始训练稀疏网络还是不可能的。

彩票假说&如何衡量它🃏

弗兰克尔和卡宾(2019)——彩票假说:寻找稀疏、可训练的神经网络

论文 | 代码

虽然传统文献已经能够表明，完全训练的密集网络可以被修剪到很小的参数，而不会使性能降级太多，但是很长时间以来，从零开始成功训练稀疏子网络是不可能的。那么为什么会出现这种情况呢？较小的子网可以近似表现良好的功能。但是与密集的网络相比，学习动力显得非常不同。

最初的彩票假设论文 (Frankle & Carbin，2019) 首先提供了为什么会出现这种情况的见解:在修剪之后，产生的子网络被随机初始化。相反，如果将权重重新初始化回其原始(但现在被屏蔽)权重，则有可能恢复同等(甚至更好)的性能！)在潜在更少的训练迭代中。这些高性能的子网可以被认为是权重初始化彩票的赢家。假设如下:

彩票假设 :一个随机初始化的、密集的神经网络包含一个子网，该子网被初始化为使得——当被隔离训练时——它可以在最多相同次数的迭代训练后匹配原始网络的测试精度。— 弗兰克尔&卡宾(2019，第 2 页)

那么，我们怎样才能找到这样一张中奖的彩票呢？Frankle&Carbin(2019)提出迭代幅度修剪 (IMP):从密集初始化开始我们训练我们的网络，直到收敛。然后，我们确定最小幅度权重的百分比，并创建一个二进制掩码来删除这些权重。然后，我们用它的先前的初始权重重新训练稀疏化的网络。收敛后，我们重复修剪过程(掩蔽额外的 s 权重),并用新发现的掩码重置为初始权重。我们重复这个过程，直到我们达到期望的稀疏水平，或者测试精度显著下降。

如果 IMP 成功，它会找到初始化彩票的赢家。这只是在这个迭代修剪过程之后剩下的子网。请注意，也可以简单地以一次性方式进行修剪——但当花费额外的计算时，会获得更好的结果(参见Frankle&Carbin(2019)的图 4)。如果我们回想一下修剪文献中的广泛问题，我们会发现:

小鬼和修剪的柱子

下图总结了第一篇 LTH 论文的一些关键经验观点:

LTH 关键结果。来源:改编自Frankle&Carbin(2019)

面板 B :在没有任何超参数调整的情况下，IMP 能够找到稀疏子网络，其能够在更少的训练迭代中胜过未修剪的密集网络(图例指的是修剪权重的百分比)。彩票中奖初始化和随机重新初始化之间的最终表现差距被称为彩票效应。
面板 C & 面板 D :为了将原始结果扩展到更复杂的任务/架构，如 CIFAR-10、VGG-19 和 Resnet-20， Frankle & Carbin (2019) 必须调整学习速率，并包括预热(在预定义的一组迭代内从 0 退火到最终速率)时间表。注意，要求的 Resnet 学习率比 VGG-19 学习率小得多。

那么这能告诉我们什么呢？首先，IMP 可以找到一个有利于手头任务的子结构，并且该子网络的权重初始化在学习动态方面是特殊的。此外，过度参数化对于成功的训练来说不是必需的，它可能只通过提供可用子网的组合爆炸来有所帮助。许多有趣的后续工作描述了中奖彩票质量差异背后的潜在机制。

Frankle 等人(2019)——稳定彩票假说

论文 | 代码

原始彩票纸的一个限制是它局限于小规模的任务，如 MNIST 和 CIFAR-10。为了将 LTH 扩展到具有竞争力的 CIFAR-10 架构，Frankle&Carbin(2019)必须调整学习率计划。没有这种调整，不可能获得与原始密集网络相当的修剪网络(刘等人，2018；盖尔等人，2019) 。但是如果我们放松一些门票限制呢？

在后续工作中，Frankle 等人(2019) 询问是否有可能通过不将权重重置为初始值，而是重置为少量 k 次训练迭代后找到的权重，来稳健地获得修剪后的子网络。换句话说，不是在修剪后倒回迭代 0，而是倒回迭代 k 。以下是正式定义和图解:

来源:弗兰克尔等人(2019)

因为我们执行了一点点训练，所以产生的票不再被称为彩票，而是匹配票。

下图总结了关键的见解:在执行 IMP 时，回退到迭代 k > 0 非常有效。最多可以修剪大约。85%的重量，同时仍然获得匹配的测试性能。这适用于 CIFAR-10 和 Resnet-20(回退到迭代 500；画面 A)以及 ImageNet 和 Resnet-50(倒带至时期 6；图片 B)。不再需要学习率热身。

缩放 LTH 关键结果。来源:改编自 Frankle 等人(2019)

Renda 等人(2020 年)——比较神经网络修剪中的倒回和微调

论文 | 代码

到目前为止，我们已经讨论了 IMP 是否能够识别匹配的网络初始化。但是抽签程序与其他修剪方法相比如何呢？在他们的论文中， Renda 等人(2020) 比较了三种不同的程序:

微调:修剪后，使用小学习率从最终训练值训练剩余权重。通常这只是原始训练程序的最终学习率。
重绕:对应于 Frankle et al. (2019) 之前介绍的方法。修剪之后，剩余的权重被重置为先前 SGD 迭代 k 的值。从那一点开始，使用从迭代 k 开始的学习率时间表重新训练权重。重量和学习率计划都被重置。
学习速率倒回:学习速率倒回使用最终未倒回的重量，而不是倒回重量值和设置学习速率时间表，只有将学习速率时间表重置为迭代 k 。

Renda et al. (2020) 对比三种方法在精度、搜索成本和参数效率方面的得失。他们回答了以下问题:

假设在搜索成本上的预算是无限的，那么这三种方法的最终精度和参数效率(剪枝前/剪枝后的压缩比)如何？
给定搜索成本的固定预算，这三种方法在准确性和参数效率方面如何比较？

在 Resnet-34/50/56 和自然语言基准 GNMT 上的实验揭示了以下见解:

在无限制和固定预算实验中，重量倒带和再训练都优于简单的微调和再训练。在比较结构化和非结构化修剪时也是如此。
学习率倒带优于重量倒带。此外，虽然重量倒带可能会因 k =0 而失败，但将学习速率倒带至训练程序的开始几乎总是有益的。
权重重绕 LTH 网络是在精确度、压缩和搜索成本效率方面用于初始化修剪的 SOTA 方法。

正如许多由大规模实验产生的对深度学习的经验主义见解一样，仍然存在一个令人生畏的问题:对于我们试图理解的这些高度非线性的系统，这实际上告诉了我们什么？

剖析彩票:鲁棒性和学习动力学🔎

周等(2019)——解构彩票:零、符号和超级面具

论文 | 代码

决定初始化是否成功的主要因素是什么？这似乎是掩蔽标准(权重的大小)、非掩蔽权重的倒带以及将权重设置为零并冻结它们的掩蔽的组合。但是如果我们改变这三种成分中的任何一种呢？大重量有什么特别之处？其他替代倒带策略保留中奖票吗？为什么要将权重设置为零？周等(2019) 从三个方面研究这些问题:

通过比较不同的评分标准来选择要屏蔽的权重。保持最小的训练重量，在初始化时保持最大/最小重量，或者重量空间中的幅度变化/移动。
通过分析当重绕重量不回到其初始状态时是否仍然获得中奖票。他们比较了随机重新初始化、保持权重的重新洗牌和常数初始化。
将屏蔽重量冻结至初始值，而非 0 值。

大量实验的结论如下:

保持重量与其离原点的距离成比例地“活动”的其他评分标准与“最大量”标准表现得一样好。
只要在执行重绕时保持与初始化时权重的原始符号相同的符号，就可以获得与经典 IMP 公式表现相当的彩票(注:该发现后来不能被 Frankle 等人(2020b) )复制)。
将权重值屏蔽为 0 至关重要。

基于这些发现，他们假设“知情”屏蔽可以被视为一种训练形式:它只是加速权重的轨迹，这些权重在其优化轨迹期间已经“朝向”零。有趣的是，从 IMP 获得的掩码已经应用于随机初始化的网络(并且没有任何额外的训练),其产生的性能大大优于随机掩码和/或随机初始化的网络。因此，对强感应偏置进行编码是超屏蔽的一种形式。这开辟了一个令人兴奋的前景，即根本不训练网络权重，而是简单地找到正确的掩码。周等(2019) 表明，甚至可以通过使其可微分并以强化式损失训练来学习掩模。这个想法非常让我想起Gaier&Ha(2019)权重不可知的神经网络。学习到的掩码可以被认为是编码解决方案规则性的连接模式。通过多次采样权重来评估掩模，我们本质上使其对采样的权重是鲁棒的(或不可知的)。

Frankle 等人(2020 a)——线性模式连接&彩票假说

论文 | 代码

当我们训练神经网络时，我们通常对数据批次进行随机排序。每一批用于评估相对于网络参数的损耗梯度。在数据集上的一个完整循环(也称为一个时期)之后，批次通常被混洗，并且我们继续下一个时期。批次的顺序可以被视为我们注入到训练过程中的噪声源。根据它，我们可能获得非常不同的最终权重，但是理想情况下，我们的网络训练过程对于这样的噪声是有些健壮的。更正式地说，我们可以考虑单个砝码初始化，我们对两个不同的批次订单进行训练，以获得两组不同的训练砝码。线性模式连接性分析 (Frankle 等人，2020a) 提出了以下问题:如果我们在这两个由不同数据顺序产生的最终权重配置之间进行平滑插值(凸组合)，验证/测试精度会如何表现？

线性模式连接。来源: 弗兰克尔等人(2020a)

如果当我们在两个最终权重之间进行插值时误差没有显著增加，则网络被认为是稳定的。此外，我们可以在单个共享数据排序上训练用于 k 迭代的初始权重，并且仅在稍后将训练分成两个单独的数据排序。对于哪一个 k，网络会变得稳定？很简单， k=T 就是这种情况，但是更早的呢？事实证明，这与我们为了获得匹配的票证初始化而必须倒带的迭代有关。

线性模式连接关键结果。来源:改编自 弗兰克尔等人(2020a)

面板 A :暂时没有票，看看网络什么时候对不同的数据排序变得插值稳定。对于 LeNet，在初始化时就已经是这种情况了。对于 Resnet-20 来说，这种稳定性只是在以后的训练中才会出现。这不是让人想起倒带迭代吗？
面板 B :迭代幅度修剪可以诱导稳定性。但这仅在倒回至 k =0 时与学习率计划技巧结合使用。
面板 C :通过修剪越来越多的权重，我们似乎进入了 3 种参数化模式(聚焦于蓝线):
- 模式 I :网络被过度参数化，因此即使是随机修剪也能产生良好的性能。
- 制度 II :随着我们增加删减权重的百分比，仅影响与和稳定票/网络匹配的产量。
- 状态 III :虽然 IMP 仍然能够在严重稀疏的情况下产生稳定的网络，但是得到的网络不再匹配。

这是彩票如何被用来揭示学习动力特征的一个例子。下一篇文章给出了对不同学习阶段的另一种更精细的分析:

Frankle 等人(2020 b)——神经网络训练的早期阶段

论文 | 代码

到目前为止，我们已经看到，只有少量的训练迭代(或 Resnet 上的历元)会产生数据顺序健壮性以及倒带时获得匹配票的能力。一个更普遍的后续问题是:这些匹配票证初始化有多健壮？在我们失去魔力之前，我们能在多大程度上扭动和扰乱初始化？而这个随着 k 如何变化？

为了研究鲁棒性的出现 Frankle 等人(2020b) 在 CIFAR-10 上使用 Resnet-20 进行了置换实验。协议如下:使用带有倒带的 IMP 导出匹配票据。然后，对匹配的车票和列车进行扰动，直到收敛。排列包括:

将权重设置为迭代 0 或 k 的符号和/或幅度(见画面 A )。任何排列(符号或大小—‘init’)都会损害高稀疏级别的性能。另一方面，在低水平上，IMP 衍生的网络似乎对符号翻转具有鲁棒性。同样的定性结果适用于倒回至 k =2000(参见 Frankle 等人(2020b) 的图 4)。
在迭代 k 时，用网的结构子组件置换权重(见画面 B )。这包括全局(跨层)、局部(层内)和给定过滤器内交换网络的权重。匹配标签对任何扰动都不鲁棒，并且性能降低到倒回迭代 k =0 的水平。另一方面，画面 C 通过仅交换具有相同符号的权重来限制排列的效果。在这种情况下，网络对于在所有稀疏水平上的滤波器内洗牌是鲁棒的。
将高斯噪声添加到匹配的票证权重(见面板 D ):为了确保添加的噪声的正确比例， Frankle 等人(2020b) 计算由特定层的初始化分布产生的逐层标准化标准偏差。有效标准差的大小非常影响扰动彩票的最终表现。扰动越大=性能越差。
具有不同自监督损耗 ( 面板 E )的密集/稀疏网络的预训练:当从 k =500 到 k =2000 时，先前的结果被很大程度地保留。这表明除了简单的重量分布特性和符号之外，还有其他的力。相反，魔术似乎在于实际的训练。因此， Frankle 等人(2020b) 询问早期阶段适应是否取决于条件标签分布中的信息，或者无监督表示学习是否足够。与回退到迭代 0 相比，在随机标签上训练少量的历元确实缩小了差距。但是较长的预训练最终会损害网络的性能。最后，预训练(非票证)稀疏网络不足以克服“错误的”/有害的修剪掩模(面板 F )。

前期关键成果。来源:改编自 弗兰克尔等人(2020b)

总而言之，这提供了一个证据，即很难克服使用倒带的必要性，因为匹配初始化的出现显得非常重要。自我监督的预培训似乎提供了一种避免倒带的潜在方法。在 CIFAR-10 上培训 Resnet-20 的早期学习动态的进一步见解总结在下面由 Frankle 等人(2020b) 制作的 awesome 可视化中:

NN 训练的早期阶段。来源: 弗兰克尔等人(2020 年 b)

几乎不需要培训就能发现中奖彩票！

虽然乔纳森·弗兰克尔的原始工作提供了一个实证存在的证明，但寻找门票是棘手和昂贵的。IMP 需要反复训练越来越稀疏的网络，这不是每个博士研究员都能做到的(不会被他们的实验室成员讨厌)🤗).下一个自然的问题是如何用更少的计算来识别这样的网络。这里有两种尝试这样做的最新方法:

you et al .(2020)——获取早期入场券:更有效地训练深度网络

论文 | 代码

You et al. (2020) 使用结合了早期停止、低精度和大学习率的低成本训练方案，在训练早期识别获胜门票(因此是“早期鸟”门票)。他们认为这是由于神经网络优化轨迹的两阶段性质:

学习低频/大奇异值分量的稳健的第一阶段。
学习较高频率/低奇异值分量的吸收阶段。

通过仅关注于识别连通性模式，有可能在阶段 1 中识别出早鸟票。与标准 LTH 工作的一个主要区别是，尤等人(2020) 基于它们的批量归一化比例因子修剪整个卷积通道。此外，修剪是在单次训练运行中迭代执行的。

作者根据经验观察到，在训练的第一个时期，修剪掩码发生了显著变化，但似乎很快就收敛了(见下图的左部)。

掩码收敛&早鸟算法。来源:改编自 尤等(2020)

因此，他们推断早期出现的假设是正确的，并制定了合适的检测算法:为了检测早期出现，他们提出了一种掩码距离度量，该度量在两次连续的修剪迭代中计算两个修剪掩码之间的汉明距离。如果距离小于阈值，它们会停止修剪。然后，可以简单地重新训练所产生的早期票证，以恢复性能。

Tanaka 等人(2020)——通过迭代保存突触流，在没有任何数据的情况下修剪神经网络

论文 | 代码

虽然 You et al. (2020) 询问是否有可能减少所需的计算量，但他们仍然需要根据数据训练模型。 Tanaka et al. (2020) 另一方面，回答了一个更宏大的问题:我们能在没有任何训练和任何数据的情况下获得中奖的门票吗？他们认为，初始化时修剪的最大挑战是层崩溃的问题——过度急切地修剪整个层，导致架构无法实现(因为梯度流被切断)。

想象一个堆叠了一组完全连接的层的 MLP。可以通过保持每层的单一重量来避免层塌陷，该重量对应于理论上可实现的最大压缩量。在不崩溃的情况下，修剪算法可以实现的压缩级别称为临界压缩。理想情况下，我们希望这两者相等。受流网络的启发， Tanaka 等人(2020) 定义了一种基于梯度的分数，称为突触显著性。该指标与分层相关性传播有些关系，并测量一种形式的贡献。然后，本文在“微观”神经元和“宏观”网络层次上证明了两个显著性守恒定律。这使得作者能够证明——为了充分压缩——基于梯度的方法将完全修剪大的层(如果评估一次的话)。那么我们为什么不在训练的小鬼设定中遇到层塌陷呢？ Tanaka 等人(2020) 表明这是由于梯度下降鼓励逐层保护以及小速率迭代修剪。因此，任何想要最大临界压缩的全局剪枝算法都必须考虑两件事:积极地对逐层保守性评分，并在剪枝后迭代地重新评估评分。

性能&突触流算法。来源:改编自 田中等人(2020)

基于这些观察，作者定义了一个迭代过程，该过程产生一个屏蔽，该屏蔽通过初始化的网络保持突触强度的流动(见上文)。最重要的是，这个过程完全是数据不可知的，只需要随机初始化。在 CIFAR-10/100 和 Tiny ImageNet 上，它们能够超越其他“初始化时修剪”基准。我真的很喜欢阅读这篇论文，因为它通过将理论结果转化为可操作的算法来利用它。

票在数据集、优化器和域之间通用吗？🃏 👉 🃏

morcos et al .(2019)-一张票赢所有人:跨数据集和优化器推广彩票初始化

论文 | 代码

一个关键问题是匹配票是否过多。在子网初始化的上下文中，过度拟合是什么意思？票证是在特定数据集(如 MNIST、CIFAR-10/0、ImageNet)上生成的，具有特定的优化器(SGD、Adam、RMSprop)，用于特定的域(视觉)和特定的任务(对象分类)。如果我们改变这些成分中的任何一个，一张票是否仍然是赢家还不明显。但是我们真正感兴趣的是在一般意义上找到学习的正确归纳偏差。

因此， Morcos et al. (2019) 询问是否可以在一个视觉数据集(如 ImageNet)上识别匹配的票证，并将其转移到另一个数据集(如 CIFAR-100)。关键问题是，在新数据集上训练匹配的彩票后，彩票效应是否会持续。过程如下:

使用 IMP 在源数据集上查找彩票。
在新的目标数据集上评估源彩票，对其进行训练直至收敛。

因此，此时你可能会问自己，在这种情况下，输入/输出形状是如何工作的？至少我做到了😄。由于我们对图像进行操作，并且所考虑的网络情况中的第一层是卷积，所以我们不必对第一隐藏层变换进行任何改变。呸。在我们从卷积过渡到全连接(FC)层的网络处理阶段， Morcos 等人(2019) 使用全局平均池，以确保不管通道大小(数据集之间会有所不同)如何，FC 层的尺寸都能计算出来。最后但并非最不重要的是，最后一层必须从彩票传输中排除，而是随机初始化。这是因为不同的数据集有不同数量的目标类。这个过程不同于传统的转移学习，因为我们不转移表示(以训练权重的形式)，而是在单独的数据集上找到的初始化和屏蔽。那么 Morcos et al. (2019) 发现了什么？

面板 A 和面板 B :将 VGG-19 票证从小型源数据集传输到 ImageNet 的性能很好，但不如在目标数据集上直接推断的票证。另一方面，从比目标数据集更大的数据集推断的票据比从目标数据集推断的票据性能更好。
面板 C 和面板 D:Resnet-50 的情况大致相同。但是也可以观察到，对于比 Resnet-50 更小的修剪部分，性能已经下降(Resnet-50 的“修剪”悬崖比 VGG-19 更尖锐)。

跨数据集传输票据。来源:改编自Morcos et al .(2019)

最后， Morcos et al. (2019) 还调查了用一个优化器推断的票据是否转移到另一个优化器。是的，这对于 19 岁的 VGG 来说是可能的，如果你仔细调整学习速度的话。这再次表明彩票编码的归纳偏差在数据和优化过程中是不变的。

票跨优化器转移。来源:改编自 Morcos 等人(2019)

那又怎样？这凸显了门票作为一般归纳偏差的巨大潜力。人们可以想象在一个非常大的数据集上找到一个健壮的匹配标签(使用大量计算)。这个通用票可以灵活地充当(可能是所有/大部分)松散域相关任务的初始化器。因此，票证可以——类似于元学习权重初始化的概念——在权重初始化空间中执行某种形式的分摊搜索。

余等(2019)——用奖励和多种语言玩彩票:RL 和 NLP 中的彩票

纸

到目前为止，我们已经在计算机视觉任务的上下文中看到了子网初始化。非交叉熵损失函数的不同域怎么样？于等(2019) 调查对语言模型的扩展(基于和 Transformer 模型)以及强化学习(演员-评论家方法)的设置。在 vision 中与之前的工作有几个不同之处:首先，除了卷积滤波器和 FC 层(循环&嵌入层和注意模块)，我们还修剪了其他类型的层。第二，我们在非常不同的损失面上训练(例如，非平稳的演员-评论家损失)。最后，RL 网络通常比大型视觉网络具有少得多的参数(特别是对于连续控制)，这可能使其在高稀疏水平下更难修剪。

语言模型中的票& RL。来源:改编自 于等(2019)

简而言之，是的，对于语言和 RL 任务，存在明显优于随机子网的稀疏初始化。最有趣的是，作者发现人们可以减少所有变压器重量的 2/3，同时仍然获得强大的性能。后期倒带和迭代修剪也是关键，嵌入层似乎被过度参数化了。所以主要是 IMP 针对他们。另一方面，对于 RL，在所有考虑的游戏中，表现良好的修剪水平变化很大。这表明对于一些任务，标准的基于 CNN 的演员-评论家网络有太多的参数。这很可能是由许多游戏组成的 RL 基准的功能，这些游戏都是由相同的架构设置学习的。

开放研究问题？

彩票假说开辟了许多不同的观点，如优化、初始化、表达性与可训练性以及稀疏性/过参数化的作用。目前，未回答的问题比回答的问题要多得多——这让我兴奋不已！以下是我的一些想法:

引发彩票的有效初始化方案是什么？元学习能产生这样的中奖票初始化方案吗？有可能将利用彩票的优化算法形式化吗？连通性和权重初始化的影响能够被解开吗？中奖票能算归纳偏差吗？
一个已经用只在一半训练数据上预训练的权重初始化的网络，最终网络(在完整数据集上训练)总是产生泛化差距 (Ash & Adams，2019) 。换句话说，对数据子集进行预训练比从随机初始化中进行训练更糟糕。彩票能克服这个暖启动问题吗？根据 Morcos 等人(2019) 的研究，这应该是一个很容易的扩展。
彩票在领域(视觉、语言、RL)和任务(分类、回归等)之间有哪些不同？)?差异是损失面的函数吗？我们能简单地从掩模中提取规律吗？

总的来说，仍有许多东西有待发现，许多彩票有待赢取。

一些最后的提示和致谢

感谢Jonathan Frankle的宝贵反馈，指点&整个 LTH 代码库的开源(参见open _ lth repository)。此外，我要大声疾呼，是谁让这篇博文变得可读🤗

如果你仍然看不够 LTH，这些建议值得一试:

Jonathan Frankle 的 ICLR 最佳论文奖演讲 —精彩的 10 分钟关键观点和结果介绍，非常容易理解的幻灯片！
Ari Morcos 的关于跨数据集归纳票据的再工作演讲。
乔纳森·弗兰克尔对 2019 年 ML 研讨会回顾的贡献&伴随个人故事(从 12:30 分钟开始)
推荐大家看一下原始论文的演变和 ArXiv 预印本的不同版本。特别是对于一个刚刚起步的研究人员来说，看到基于越来越强大的假设检验的轨迹和规模，真的很有启发。
如果你对一些数学感兴趣，并且对浓度不平等有亲近感，请查看malachi 等人(2020) 。他们正式证明了 LTH，并提出了一个更强的猜想:给定一个足够大的密集网络，不需要任何额外的训练就可以获得匹配性能的子网。
检查这个 GitHub 库中的大量最近的(和不太最近的)修剪文件。

你可以在这里找到这篇博文的 pdf 版本。如果您在科学工作中使用本博客，请注明:

@article{lange2020_lottery_ticket_hypothesis,
  title   = "The Lottery Ticket Hypothesis: A Survey",
  author  = "Lange, Robert Tjarko",
  journal = "https://roberttlange.github.io/year-archive/posts/2020/06/lottery-ticket-hypothesis/",
  year    = "2020",
  url     = "https://roberttlange.github.io/posts/2020/06/lottery-ticket-hypothesis/"
}

原载于 2020 年 6 月 27 日https://roberttlange . github . io。

Lyft 数据科学家访谈

原文：https://towardsdatascience.com/the-lyft-data-scientist-interview-a935700c3f8e?source=collection_archive---------25-----------------------

Lyft 数据科学面试问题

图片来自 Unsplash

介绍

Lyft，Inc .是一家快速扩张的拼车公司，总部位于旧金山，在美国 644 个城市和加拿大 12 个城市开展业务。Lyft 成立于 2012 年，是长途拼车业务的一部分，最初名为 Zimride ，于 2013 年在硅谷推出。

该公司迅速扩张，从 2014 年 4 月的 60 个美国城市扩张到 2017 年 1 月的 300 多个城市。现在，Lyft 的用户已经超过 2300 万，截至 2020 年，记录的乘车次数达到 10 亿次。

Lyft 每天生成数百万个数据点，需要扩展其数据科学和研究科学能力。因此，一个专门的数据科学和商业智能部门的任务是利用最先进的分析、机器学习和大数据(使用 AWS S3/AWS EC2)工具来提供商业模式和见解。

Lyft 的数据科学角色

来自 Lyft 工程的数据科学职责

Lyft 的数据科学能力分为三个特定的团队:数据科学家、研究科学家和机器学习工程师。

数据科学家负责构建分析基础架构，创建模型，并为自助分析设置仪表盘。Lyft 的数据科学家角色最初被称为数据分析师，现在更专注于分析，并与产品经理一起推动产品决策。

Lyft 的研究科学家更像传统的数据科学家并运送生产代码来从事核心的机器学习项目，例如估计的乘坐时间和每次乘坐的定价。Lyft 研究科学家在运行 Lyft 应用和产品的自动化引擎上做了大量工作。

最后，Lyft 的机器学习工程师专注于构建基础设施，这是托管研究科学家构建的复杂模型所需要的。

Lyft 的数据科学角色是为不同产品和功能的团队量身定制的。因此，确切的角色和职责将取决于您被分配到的团队和产品/功能。

无论您正在与哪个团队合作，或者您的团队被分配到哪个产品/功能，Lyft 的数据科学家角色都将跨越业务分析、建模、机器学习和深度学习实施。

所需技能

Lyft 的文化是创造一个“开放、包容和多元化的环境，在这个环境中，成员的贡献得到认可”。Lyft 更倾向于聘用在数据分析和可视化方面拥有 3 年以上经验的高素质申请人。

Lyft 招聘的其他基本要求包括:

统计学，经济学，应用数学，运筹学或工程学学士学位。有高等学位者优先。
3 年以上数据科学或分析行业经验。
优秀的数据分析、建模、Python 和 SQL 语言(MySQL、PostgreSQL、SqlServer、Oracle)技能——能够编写大型数据集的结构化高效查询。
精通 Tableau、Power BI 或类似的数据可视化软件。
使用 ETL 逻辑构建新的数据表非常容易:构建、管理和修复整个企业数据模型。
熟练使用气流等工作流程管理工具。
出色的沟通技巧，能够向相关受众展示调查结果和建议。

什么样的数据科学角色？

来自 Lyft 工程的车辆数据映射

Lyft 有一个专门的数据分析和商业智能部门，但根据您被分配到的团队和产品，工作角色和职能可能会略有不同。根据团队的不同，这些职能可能包括:

利用机器学习自动化工具来管理增长杠杆。
通过每周、每月和每季度的业务回顾，跟踪并报告与中心工作流相关的 KPI。
分析价格变化对整个市场的影响。
与产品领导紧密合作，构建最有效的工具、系统和流程来管理大规模定价

Lyft 的数据科学团队包括:

绘图
自主车辆
市场
动态定价
成长团队
骑手体验
驾驶员体验
欺诈团队
机场体验

Lyft 面试流程

Lyft 总部来自影城建筑

Lyft 的招聘流程与其他大型科技公司类似。面试过程从招聘经理或人力资源的初步电话筛选开始，然后是带回家的挑战(通常有 24 小时的交付时间)或技术筛选。在成功通过带回家的挑战和 45 分钟长的技术面试(在某些情况下是两次技术面试)后，接下来是五六次现场一对一面试，现在几乎是因为新冠肺炎。

初始屏幕

最初的筛选是通过人力资源或招聘经理的电话来完成的。这次面试主要是试探性的，以简历为主。这里的主要重点是评估你的背景，特别是过去的经验、角色、团队动态，以确定你是否是一个潜在的合适人选。

技术屏幕

面试流程的下一步是与数据科学家进行技术面试电话筛选。这次面试持续 30 到 45 分钟，面试问题涵盖概率基础、统计学、机器学习、业务案例研究、一些运营 KPI 的定义、假设测试的数学演示以及您的技术/过去的项目经验。

带回家的挑战

完成初步筛选后，您将收到 Lyft 带回家的挑战，您将有 24 小时的时间完成。带回家挑战中的问题是基于案例研究的问题(拼车数据集)，它们包括技术和商业方面的问题。在这项挑战中，问题通常跨越不同的主题，例如流失率测量、优化(使用机器学习)、建议的设计/实验，以及创建关于您的假设、限制和结论的综合报告。

面试查询 查看 Lyft 带回家挑战。

注意:带回家的挑战演示将在现场进行。

现场面试

通过技术筛选后，流程中的下一个预定面试是现场面试。该流程包括五或六轮与数据科学家或团队经理的一对一面试，每轮持续约 45 分钟。这是一个为期半天的面试过程，包括白板编码、与团队经理和数据科学家的项目讨论、业务案例研究和统计概念。

一般来说，累积面试过程看起来会像这样:

带回家的数据挑战演示–在这次面试中，候选人需要对在面试过程的早期提交的带回家的挑战进行演示。

注意:在这个阶段，你需要围绕你的分析建立一个连贯的故事，同时回答关于你使用了什么指标以及为什么选择它们的问题。

商业案例研究面试:这个面试中的问题主要是开放式的，围绕一个真实的商业案例研究。建议在 Lyft 温习一些与拼车相关的单位经济学指标。
数据科学家的统计和概率:这里的问题围绕假设检验，比如经典的“硬币在 y 次翻转中有 x 个正面”。熟悉关键概念的业务应用程序、它们的变体以及使用 SQL 的数据操作是有好处的。
SQL/Python 访谈:这是一次 45 分钟的数据科学家访谈，涉及 SQL 或 R/Python 和算法的白板编码。
核心价值观/文化契合度与产品经理的面谈。

面试流程的目的是评估您在提供业务影响洞察方面的分析概念和设计技能的经验。记得复习你的统计和概率(A/B 测试)、实验设计和关键统计概念的商业应用的知识。

此外，阅读关键经济指标和 KPI、算法和模型也会有所帮助。 在面试查询上练习大量的 SQL 和优化问题，因为这些可以更好地为面试过程的技术方面做好准备。**

Lyft 数据科学面试问题

描述如何设计热图，告诉司机去哪里。你如何定义接下来哪些领域会有高需求，你希望谁去那里？
你如何模拟激增对需求和供给的影响？
解释相关性和方差。
解释实现池匹配的最佳方法。
你如何减少供应方的流失？
一个司机的终身价值是多少？
有哪些不同的因素会影响司机平均等待时间的增长？
你熟悉哪些优化技术，它们是如何在基础层面上工作的？给定一个线性需求函数，你如何找到最优价格？对二次函数求导。
如何在极坐标下从圆中画出均匀的随机样本？
求基本分布的随机变量的期望值。你如何构建一个置信区间？
你如何估计用户订购顺风车的概率？为了估计这个概率，你需要什么样的假设？

感谢阅读

如果你想了解更多独家面试解释，请查看 面试查询 ！
查看我的 Youtube 频道 获取更多面试指南，以及解决问题的技巧&。
在面试查询博客上找到更多数据科学面试指南，如 Pinterest 数据科学家面试和 IBM 数据科学家面试 。

原载于 2020 年 7 月 28 日 https://www.interviewquery.com*。***

集成学习背后的魔力

原文：https://towardsdatascience.com/the-magic-behind-ensemble-learning-569be80fbab4?source=collection_archive---------30-----------------------

如何使用许多 Kaggle 竞赛获胜者使用的简单技术来提高模型的性能

机器学习中最有用和最简单的技术之一是所谓的集成学习。集成学习(EL)是 XGBoost、Bagging Trees、Random Forest 和其他方法背后的方法，但还不止这些。

这里有很多关于数据科学的非常好的文章(这里的和这里的是我最欣赏的两个故事)。那么，为什么又是一篇关于埃尔的文章呢？因为我想用一个非常简单的例子向你展示它是如何工作的，这个例子让我确信它不是魔术！

嗯，我第一次看到 EL 运行时(只有几个非常简单的回归模型)，我简直不敢相信自己的眼睛，我仍然感谢教授我这项技术的教授。

我有两个不同的模型(“弱学习者”)，样本外 R 分别为 0.90 和 0.93。在查看结果之前，我会想到在两个原始 R 之间的某处获得一个 R。换句话说，我认为 EL 可以用于避免一个模型的性能与最差的模型一样差，但不是一个可以胜过最佳模型的模型。

令我非常惊讶的是，预测的简单平均值的 R 为 0.95。

起初，我寻找一个错误，然后我想这背后可能有什么神奇的东西！

什么是集成学习

使用 EL，您可以组合两个或更多模型的预测，以获得一个更健壮和性能更好的模型。集合模型有很多方法，但这里我只讨论两个最有用的，只是给出一个想法。

在回归中，您可以对可用模型的预测进行平均。

在分类中，你可以让任何一个模特投票给一个标签。票数多的标签就是新机型选择的标签。

为什么效果更好

EL 工作得更好的基本原因是每个预测都有误差(至少在概率意义上)，组合两个预测可以帮助减少误差，从而提高性能指标(RMSE，R .等)。).

在下面的图表中，你可以看到两个弱学习者如何处理一个样本数据集。第一个学习者具有比它应该具有的高得多的角度系数，而第二个学习者具有几乎为零的角度系数(可能是过度正则化的结果)。整体看起来好多了。

查看样本外 R，我们得到-0.01，两个弱学习者的 R 为 0.22，整体的 R 为 0.73。

作者图片

即使在像这样的基本例子中，学习者也可能不是一个好模型的原因有很多:也许你选择使用正则化来避免过度拟合，或者你选择不排除一些异常值，或者你使用了错误次数的多项式回归(当你使用二次多项式，但你的测试数据显示明显的不对称更适合三次)。

当它工作得更好的时候

让我们看看另外两个有相同数据的学习者。

作者图片

在这个例子中，我们可以说组合这两个模型并没有提高多少性能，但是 R 对于学习者分别是-0.37，0.22，对于组合是-0.04。因此，EL 模型的得分介于两个原始模型之间。

这两个例子之间有一个很大的区别:在前一个例子中，模型的误差是负相关的，而在后一个例子中，它们是正相关的(三个模型的系数不是估计的，而是作者为了举例而选择的)。

因此，集成学习可以用于在任何情况下改善偏差/方差平衡，但是当模型的误差不是正相关时，EL 模式可以导致性能的提升。

异构与同构模型

EL 通常用于同质模型(如本例或随机森林),但您可以将非常不同的模型(线性回归+神经网络+ XGBoost)与不同的解释变量集相结合。这可能会导致不相关的错误和性能的提高。

与投资组合多样化的比较

EL 的工作原理类似于投资组合理论中的多样化，但它甚至更好。

在分散投资中，你试图减少投资于不相关股票的业绩差异。一篮子多元化的股票比最差的单只股票表现好，但永远不会比最好的单只股票好。

引用沃伦·巴菲特的话:

“多元化是对无知的一种保护，对于那些知道自己在做什么的人来说，这没有什么意义。”

在机器学习中，EL 有助于减少模型的方差，但它可能会导致一个整体性能优于最佳单一模型的模型。

总结

将更多模型组合在一个模型中是一种相对简单的技术，可以解决偏差-方差权衡问题并提高性能。

如果你有两个或两个以上看起来不错的型号，不要选择:全部使用(小心)！

关于我

我是一名前数学家，对许多不同的事情都有热情:数据科学、数据可视化、金融、资产/负债管理，以及(但不要告诉任何人)会计！

如果您想知道，如果根据样本外数据计算，或者如果您的估计量不是 OLS，R 可能是负的

【协同过滤】

这种过滤类型的基础是用户/项目反馈循环。

这种反馈可以是用户评级、竖起大拇指和竖起大拇指，甚至是用户对特定内容的参与程度。协作过滤有两种含义，狭义的和更广义的。

在狭义上，协同过滤是一种通过聚集偏好或从几个用户(协作)收集数据来构建关于用户兴趣的自动预测(过滤)的方法。

协同过滤方法的基本假设是，如果人 A 在一个问题上与人 B 有相同的观点，则 A 更有可能在一个不同的问题上与随机选择的人有不同的观点。网飞可以使用协同过滤来预测一个用户会喜欢哪个电视节目，给定一个用户喜好(喜欢或不喜欢)的部分列表。注意，这些预测是特定于用户的，但是使用从许多用户那里收集的信息。

来源:Shutterstock。评级/评论

协作过滤公式将客户表示为 N 维向量 N，其中 N 是各种不同的目录数据。向量的元素对于被访问或正面评价的内容是正的，对于负面评价的信息是负的。

从计算角度来说，协同过滤在最坏的情况下是 O(MN ),其中 M 是客户的数量，N 是产品目录数据的数量。实际上，由于平均客户端向量非常小，因此性能更接近于 O(M+N)。

来源:InCubeGroup。顾客和品味(MxN 矩阵)

在更一般的意义上，协作过滤是使用涉及多个代理、观点、数据源等之间协作的技术来过滤信息或模式的过程。它通常涉及非常大的数据集。一些公开的可以在这里找到。

我们有不同类型的协同过滤:

用户-用户
项目-项目
用户项目

用户-用户: 最常用的推荐算法遵循“喜欢你的人喜欢那个”的逻辑。它会推荐相似用户以前喜欢的物品。两个用户之间的相似性是根据他们在数据集中共有的项目数量计算的。当用户数量小于项目数量时，该算法是有效的。一个很好的例子是一个中等规模的电商网站，有几百万的产品。主要的缺点是添加新用户是昂贵的，因为它需要更新用户之间的所有相似性。

Item-Item: 它使用相同的方法，但是颠倒了用户和项目之间的视图。它遵循“如果你喜欢这个，你可能也会喜欢那个”的逻辑。换句话说，它会推荐与您之前喜欢的项目相似的项目。和以前一样，两个项目之间的相似性是使用它们在数据集中共有的用户数量来计算的。当项目数量远小于用户数量时，该算法更好。一个例子可能是一个大型的网上商店，当你的物品不经常改变时。主要缺点是项目-项目相似性表必须预先计算。添加新项目时更新该表的成本很高。

用户-项目: 它结合了两种方法来生成建议。最简单的是基于矩阵分解技术。目标是为所有用户和所有项目创建低维向量(“嵌入”)，这样将它们相乘就可以发现用户是否喜欢某个项目。

用户-项目矩阵是传统协同过滤技术的基础，但存在数据稀疏问题。

矩阵分解可以使用 SVD 来完成，但是它的计算量很大，并且扩展性不好。对于中等规模的数据集， ALS 可能是一个不错的选择。对于大型数据集，只有 SGD 算法能够扩展，但总是需要相当大的计算能力。

一旦预先计算了用户的嵌入和项目的嵌入，就可以实时提供推荐。这种方法的另一个好处是，您可以使用它们的嵌入来了解更多关于用户和项目的信息。

用户项目算法都有一个缺点，即在添加新项目或新用户后，没有有效的方法来更新嵌入。

正如在个性化推荐场景中，新用户或新项目的引入可能导致冷启动问题，因为这些新条目上的数据不足以使协同过滤准确工作。为了给新用户做出适当的推荐，系统必须首先通过分析过去的投票或评级活动来学习用户的偏好。协同过滤系统要求大量用户在推荐新项目之前对该项目进行评级。

在下一篇文章中，我们将深入探讨两种主要类型的协同过滤系统:

基于模型的:使用不同的技术，如数据挖掘、机器学习算法来预测用户对未评级项目的评级。通常使用基于聚类的算法(k 近邻或 KNN)、矩阵分解技术(SVD)、概率分解或深度学习(神经网络)。
基于内存的:使用用户评分数据计算相似度。它通常使用余弦或皮尔逊相关性来寻找相似性，并对评级进行加权平均。这种方法更容易解释，但是扩展性不好。

基于内容

所有以前的模型都存在所谓的冷启动问题。

基于内容的过滤方法基于项目的描述和用户偏好的配置文件。这些方法最适合于已知项目数据(名称、位置、描述等)的情况。)，但不在用户身上。基于内容的推荐器将推荐视为特定于用户的分类问题，并根据产品特征学习用户喜欢和不喜欢的分类器。

在该系统中，使用关键字来描述项目，并且建立简档来指示该用户喜欢的项目类型。该算法试图推荐与用户过去喜欢的或者现在正在检查的项目相似的项目。这种方法源于信息检索和信息过滤研究。

机器学习中模式识别的最新进展使得使用从图像或文本描述中提取的信息的基于内容的模型有了很大的改进。

该方法与之前的用户-用户或项目-项目算法相同，除了相似性是使用仅基于内容的特征计算的。

CF 与基于内容的过滤

个案研究

对于以下案例研究，我们将使用 Python 和公共数据集。

具体来说，我们将使用 GroupLens Research 收集的 MovieLens 数据集。包含 MovieLens 100k 数据集的文件是一个稳定的基准数据集，具有 943 个用户对 1682 部电影给出的 100，000 个评级，每个用户至少对 20 部电影进行了评级。

这个数据集由许多文件组成，这些文件包含关于电影、用户以及用户对他们所观看的电影的评级的信息。感兴趣的有以下几个:

**u.item** : 电影列表
**u.data** : 用户给出的评分列表

文件的前五行如下所示:

来源:Kaggle。MovieLens 100k 数据集

该文件包含用户对特定电影的评价。该文件包含 100，000 个评级，将用于预测用户未观看的电影的评级。

基于记忆的协同过滤

在这种变化中，统计技术应用于整个数据集来计算预测。

为了找到用户 U 将给予项目 I 的评级 R ，该方法包括:

正在查找与 U 相似的用户，他们已经对项目 I 进行了评级
根据上一步中找到的用户评分计算评分 R

考虑到每个用户都是一个向量，scikit 有一个函数可以计算每个向量的余弦距离。

>>> from scipy import spatial
>>> a = [1, 2]
>>> b = [2, 4]
>>> c = [2.5, 4]
>>> d = [4.5, 5]

>>> spatial.distance.cosine(c,a)
0.004504527406047898

>>> spatial.distance.cosine(c,b)
0.004504527406047898

>>> spatial.distance.cosine(c,d)
0.015137225946083022

>>> spatial.distance.cosine(a,b)
0.0

矢量 C 和 A 之间的较低角度给出了较低的余弦距离值。

注意，用户 A 和 B 在余弦相似性度量中被认为是绝对相似的，尽管具有不同的评级。这在现实世界中其实是常有的事，像用户 A 这样的用户就是你所谓的强硬评分者。一个例子是一个电影评论家，他给出的评分总是低于平均水平，但他们列表中的项目的排名与平均评分者相似，如 B 。

为了考虑这种个人用户偏好，我们可以标准化评级以消除他们的偏见。我们可以通过从该用户评价的每个项目中减去该用户对所有项目给出的平均评价来做到这一点。

下面是这个正常化的样子:

对于用户 A ，评分向量[1, 2]具有平均值1.5。从每个评分中减去1.5会得到向量[-0.5, 0.5]。
对于用户 B ，评价向量[2, 4]具有平均值3。从每个评分中减去3会得到向量[-1, 1]。

对用户 C 和 D 进行同样的操作，我们可以看到，评级现在被调整为所有用户的平均值为 0，这使他们处于相同的水平，并消除了他们的偏见。

调整后的向量之间的夹角余弦称为中心余弦。这种方法通常用在向量中有很多缺失值的时候，你需要放置一个公共值来填充缺失值。

填充缺失值的一个很好的选择可以是每个用户的平均评级，但是用户 A 和 B 的原始平均值分别是1.5和3，用1.5填充 A 的所有空值以及用3填充 B 的所有空值将使他们成为不同的用户。这个问题通过我们的归一化解决了，因为两个用户的以为中心的平均值是0，这带来了所有缺失值都是0.的想法

在我们确定了一个类似于用户 U 的用户列表后，我们就可以计算出 U 会给某个项目 I 的 R 。我们可以通过多种方式做到这一点。

我们可以预测，用户对项目 I 的评级 R 将接近与 U 最相似的前 5 名或前 10 名用户给予 I 的评级的平均值。由 n 用户给出的平均评分的数学公式如下:

N 个相似用户的平均评分

这个公式表明，n 个相似用户给出的平均评分等于他们给出的评分之和除以相似用户的数量，这是 n。

会有这样的情况，你找到的 n 个相似用户与目标用户 U 不完全相似。他们中的前 3 名可能非常相似，其余的可能不像前 3 名那样与 U 相似。在这种情况下，您可以考虑一种方法，其中最相似用户的评级比第二相似用户更重要，依此类推。加权平均可以帮助我们实现这一目标。

在加权平均方法中，您将每个评级乘以一个相似性因子(它表明用户有多相似)。通过乘以相似性因子，您可以为评级增加权重。权重越大，评级就越重要。

充当权重的相似性因子应该是上面讨论的距离的倒数，因为距离越小意味着相似性越高。例如，您可以从 1 中减去余弦距离来获得余弦相似度。

利用与目标用户 U 相似的每个用户的相似性因子 S ，我们可以使用以下公式计算加权平均值:

在上面的公式中，每个评级都乘以给出该评级的用户的相似性因子。用户 U 的最终预测评级将等于加权评级的总和除以权重的总和。

通过加权平均，我们按照相似性的顺序更多地考虑相似用户的评级。

这种技术是用户-用户 CF 的一个例子。如果我们使用评分矩阵根据用户给他们的评分来寻找相似的项目，那么这种方法就是项目-项目 CF。

但是，对于包含浏览或娱乐相关项目(如电影镜头)的数据集，项目-项目方法的性能很差。这种数据集使用矩阵分解技术会得到更好的结果，我们将在基于模型的 CF 部分看到这一点。

基于模型的 CF

在用户-项目矩阵中，有两个维度:

用户数量
项目的数量

如果矩阵大部分是空的(稀疏的)，降低维数可以在空间和时间两方面提高算法的性能。最常用的方法之一叫做矩阵分解。

矩阵因式分解可以看作是将一个大矩阵分解成多个小矩阵的乘积。这类似于整数的因式分解，其中12可以写成6 x 2或4 x 3。在矩阵的情况下，一个维数为m x n的矩阵 A 可以简化为两个维数分别为m x p和p x n的矩阵 X 和 Y 的乘积。

根据用于维数缩减的算法，缩减矩阵的数量也可以多于两个。

简化的矩阵实际上分别代表用户和项目。第一个矩阵中的 m 行代表 m 用户，而 p 列告诉您用户的特征或特性。具有 n 个项目和 p 个特性的项目矩阵也是如此。下面是矩阵分解的一个例子:

来源:维基百科(GNU)

在上图中，矩阵被简化为两个矩阵。左边的是有 m 个用户的用户矩阵，上面的是有 n 个条目的条目矩阵。额定值4被降低或分解为:

用户向量(2, -1)
一个项目向量(2.5, 1)

用户矩阵中的两列和项目矩阵中的两行被称为潜在因素，并且是关于用户或项目的隐藏特征的指示。因子分解的一种可能解释如下:

假设在一个用户向量(u, v)中，u代表用户有多喜欢恐怖片，而v代表他们有多喜欢言情片。
因此，用户向量(2, -1)表示喜欢恐怖电影并对其进行正面评价，不喜欢浪漫电影并对其进行负面评价的用户。
假设在一个项目向量(i, j)中，i表示一部电影有多少属于恐怖片，而j表示那部电影有多少属于言情片。
电影(2.5, 1)恐怖评分2.5，浪漫评分1。使用矩阵乘法规则乘以用户向量得到(2 * 2.5) + (-1 * 1) = 4。
所以，这部电影属于恐怖片类型，用户本来可以给它评分5，但是稍微加入了言情片就导致最终评分降到了4。

因素矩阵可以提供关于用户和项目的洞察，但实际上，它们通常要复杂得多。这些因素的数量可以是从一个到数百个甚至数千个。这个数字是模型训练过程中需要优化的东西之一。

在这个例子中，你有两个电影类型的潜在因素，但是在真实的场景中，这些潜在因素不需要太多的分析。这些是数据中的模式，无论你是否理解它们的潜在含义，它们都会自动发挥作用。

潜在因素的数量以这样的方式影响推荐，其中因素的数量越多，推荐变得越个性化。但是太多的因素会导致模型中的过度拟合。

# load_data.py

import pandas as pd
from surprise import Dataset
from surprise import Reader

# This is the same data that was plotted for similarity earlier
# with one new user "E" who has rated only movie 1
ratings_dict = {
    "item": [1, 2, 1, 2, 1, 2, 1, 2, 1],
    "user": ['A', 'A', 'B', 'B', 'C', 'C', 'D', 'D', 'E'],
    "rating": [1, 2, 2, 4, 2.5, 4, 4.5, 5, 3],
}

df = pd.DataFrame(ratings_dict)
reader = Reader(rating_scale=(1, 5))

# Loads Pandas dataframe
data = Dataset.load_from_df(df[["user", "item", "rating"]], reader)
# Loads the builtin Movielens-100k data
movielens = Dataset.load_builtin('ml-100k')

k 近邻和矩阵分解。

惊喜库有很多算法我们可以很轻松的使用，k-NN。

# recommender.py

from surprise import KNNWithMeans

# To use item-based cosine similarity
sim_options = {
    "name": "cosine",
    "user_based": False,  # Compute  similarities between items
}
algo = KNNWithMeans(sim_options=sim_options)

我们可以用 k-NN 来训练和预测。

>>> from load_data import data
>>> from recommender import algo

>>> trainingSet = data.build_full_trainset()

>>> algo.fit(trainingSet)
Computing the cosine similarity matrix...
Done computing similarity matrix.
<surprise.prediction_algorithms.knns.KNNWithMeans object at 0x7f04fec56898>

>>> prediction = algo.predict('E', 2)
>>> prediction.est
4.15

最后，我们可以微调超参数和均方根误差。

from surprise import KNNWithMeans
from surprise import Dataset
from surprise.model_selection import GridSearchCV

data = Dataset.load_builtin("ml-100k")
sim_options = {
    "name": ["msd", "cosine"],
    "min_support": [3, 4, 5],
    "user_based": [False, True],
}

param_grid = {"sim_options": sim_options}

gs = GridSearchCV(KNNWithMeans, param_grid, measures=["rmse", "mae"], cv=3)
gs.fit(data)

print(gs.best_score["rmse"])
print(gs.best_params["rmse"])

奇异值分解推荐器

作为一种变化，我们可以使用 SVD 而不是 k-NN 来运行推荐算法。

from surprise import SVD
from surprise import Dataset
from surprise.model_selection import GridSearchCV

data = Dataset.load_builtin("ml-100k")

param_grid = {
    "n_epochs": [5, 10],
    "lr_all": [0.002, 0.005],
    "reg_all": [0.4, 0.6]
}
gs = GridSearchCV(SVD, param_grid, measures=["rmse", "mae"], cv=3)

gs.fit(data)

print(gs.best_score["rmse"])
print(gs.best_params["rmse"])

上述程序的输出如下:

0.9642278631521038
{'n_epochs': 10, 'lr_all': 0.005, 'reg_all': 0.4}

参考

Suresh Chandra Satapathy，Vikrant Bhateja，Amit Joshi。数据工程和通信技术国际会议论文集。2016.

[## 用协同过滤构建推荐引擎——Real Python

在本教程中，您将了解到协同过滤，这是最常见的构建…

realpython.com](https://realpython.com/build-recommendation-engine-collaborative-filtering/)

特维恩，洛伦；希尔，威尔(2001)。《超越推荐系统:帮助人们互相帮助》。艾迪森-韦斯利。第 6 页。

Badrul Sarwar、George Karypis、Joseph Konstan 和 John Riedl (2001 年)。【基于项目的协同过滤推荐算法】。GroupLens 研究小组/陆军 HPC 研究中心。第一篇发表在基于项目的推荐器上的论文。

大卫 a .戈德堡，大卫 a .尼科尔斯，道格拉斯 b .特里。“用协同过滤编织信息织锦”。ACM 的通信。1991.术语协同过滤的首次使用。

库light FM:Python 中的一种混合推荐算法。

库 Python-recsys :用于实现推荐系统的 Python 库。

库惊喜:Python scikit 构建和分析推荐系统，处理显式评级数据。

Aggarwal，Charu C. (2016 年)。推荐系统:教科书。斯普林格。

彼得·布鲁斯洛夫斯基(2007 年)。"自适应网络"第 325 页。

Aditya，p .和 Budi，Indra 和 Munajat，Qorib。(2016).“基于记忆和基于模型的协同过滤在印度尼西亚电子商务推荐系统实施中的比较分析:案例研究第十卷”。第 303-308 页

InCubeGroup。私人银行推荐系统。参考 2020 年 3 月 18 日。

“神奇公式文章分析器”背后的所有 Python 代码

原文：https://towardsdatascience.com/the-magic-formula-article-analyzer-all-the-python-code-behind-it-e821d889fdb?source=collection_archive---------42-----------------------

没有熊猫或 Matplotlibs 的分析。我知道，很疯狂…

Kelly Sikkema 在 Unsplash 上拍摄的照片

你可能有一些最喜欢的作家。如果有一种方法可以分析他们成功的文章并向他们学习呢？嗯，有一种方法可以做到这一点，这就是我用 python 分析器工具所做的事情。

在这篇文章中，我将浏览并分享这个工具背后的所有代码，这样你就可以分析你自己喜欢的作者了。

它是如何工作的

如果你还没有读过，那就去看看我的原始文章，在那里我会把它分解并做实际的分析。

[## 7 个数据点编译成功媒体作家的神奇公式

用数据分析为什么三位顶级作家如此成功

medium.com](https://medium.com/better-marketing/7-ways-you-can-find-the-magic-formula-of-great-successful-writers-d32001d6ac4e)

该工具只需要一个包含特定数据的 CSV 文件，并将立即输出统计数据:

工具管道。CSV 通过程序发送并输出统计数据

这是一个 CSV 示例

Google 工作表示例

下面是一个输出示例:

蒂姆·丹宁的神奇公式表。

在这篇文章中，我将一步一步地检查我的代码，这样你可以更好地理解我一直在想的东西，也许你可以优化、重构并重写它，使它变得更好。

为什么他还没有谈到熊猫？

对于这个工具，我使用了statistics、datetime和tabulate。pandas和matplotlib搭配jupyter可能是一个完美的组合。说实话，刚开始的时候我还不够了解。如果我再做一次，我可能会使用这样的设置。

让我们来看看这个工具是如何设置的！

阶级结构

根据程序的大小，你可以有几个类。Articles、Writers、Publications都有效。

main.py使用Article类和一个 CSV 文件来解析数据。main.py也输出所有数据。

我最后得到的设置是:

如果您愿意，可以跟随这个 testdata.csv 文件:

测试数据 CSV 文件。

文章类

先说Article类。

这个类包含文章本身的数据。我们发送标题，它属于哪个出版物，数据，阅读时间，掌声和回应。

当你请求数据时，一组方法返回数据。

以下是 article 类的完整代码。

文章类别的要点代码

def init (self…)

self._headline = headline 
self._publication = publication 
self._date = date 
self._read_time = int(read_time) 
self._claps = int(claps)
self._responses = int(responses)

这个类的构造函数保存了我们将从 CSV 文件中获得的有价值的数据。这里没什么特别的…

def str(self):

str 方法的代码

我喜欢包含__str__方法，这样如果我需要知道它包含什么数据，我就可以打印对象本身。用这个方法，我们可以创建一个对象并打印它，看看构造函数保存了什么数据(或者您决定的__str__应该打印的任何数据)

article1 = Article('Super Headline' , 'Super Publication' , '03/19/20' , '6' , '55' , '2')print(article1)

打印文章 1 的输出

headline_word_count(自己)

这是一个非常简单的方法函数，可以写成一行:

return len(self._headline.split())

连字符经常出现在标题中，我们不希望它们出现在我们的字数中。我们必须移除它。

split_headline = self._headline.split()#remove hyphen as it is not a word
        if '-' in split_headline:
            split_headline.remove('-')count = len(split_headline)
        return count

另一种选择(实际上我更喜欢)是使用列表理解:

word_list = [word for word in self._headline.split() if word != '-']
return len(word_list)

对于初学者来说有点难读，所以我想把两个选项都包括进来。

def headline_include_you(自己)

这个方法的功能是检查标题中是否有单词“you”。

带有“你”的文章通常向用户提供一些提示和技巧，有趣的是，看看有多少顶级文章以某种方式使用了“你”。

if 'you' in self._headline.lower():
    return True
return False

我们可以在后台循环每个单词，因为标题是一个字符串，我们正在检查字母组合“you”是否在标题中的任何位置。

这段代码也能捕捉像“你自己”这样的词，但是它有一个的重大缺陷。它还可以捕捉像“青年”、“youtube”或其他包含“你”️anywhere 的单词🤷🏼‍♂️

接下来的方法将以不同的方式处理这个问题。这是一个更安全的设置，我们也应该使用你的方法。

def headline_include_i(自己):

这个方法函数与前一个方法函数的逻辑相同，但是它有一个我们想要检查的单词的预定义列表。

它将检查【我】【我已经】【我是】。它不会像上面的例子那样捕捉仅仅以‘I’开头的单词，因为我们预先定义了我们想要使用的单词列表。

i_list = [‘I’,’I\’m’,’I\’ve’] 
for word in i_list: 
    if word in self._headline.split():
        return True
return False

def headline_wh_words(self):

该方法功能与上面的方法功能相同。

def headline_include_num(self):

这个方法函数与前两个几乎相同，但是它有一个额外的步骤(检查单词的字母，而不仅仅是单词),以确保它捕获像“6+”这样的单词

for word in self._headline.split():
    for letter in word:
        #catch words with number concatinated with anything:
        if letter.isdigit():
            return True
    return False

def headline_include_money(自己)

另一种方法是使用一个 if 语句来运行我们循环遍历的列表。我不能决定哪个更漂亮，但它们都是有效的选择。

这更短，但如果语句太长，可能更难阅读。

标题的要点代码包括金钱

注意，我对照self._headline.lower()检查money，这样我就不用担心像‘Money’这样的大写字母了。

我还检查美元符号,$，以及单词“美元”(因此也是美元)

比率方法

代码有一些比率方法，检查每分钟鼓掌和响应的比率。

获取方法

get 方法用于返回我们以后可能需要的任何东西，比如所有的构造函数变量。

分析(main.py)

图片来自 Pixabay 由 janjf93 拍摄

是时候写一个主工具，解决我们可能有的所有分析问题了。

主文件的结构是这样设置的:

将数据作为Article对象添加到文章列表的 CSV 阅读器
柜台。这些方法检查所有文章并返回计数数据。(例如，最长的标题、平均字数、包含“您”的文章数量等。)
read_time具体方法。其中一些也是计数器。
产出。这些方法只是输出我们想要看到的数据。

在我们浏览代码之前，这里是:

main.py 的要点代码

def read_csv(文件):

这里并没有发生太多的事情。我们向过程传递一个文件名，过程使用csv.reader读取它。

我们使用next(datareader)来跳过标题，然后循环遍历这些行，并将它们添加到article_list中。这将是我们剩余程序的数据。

csv 阅读器的要点代码。

计数器:

所有计数器的设置都非常相似。我们定义一个计数器，遍历文章对象，并使用文章方法递增计数器。

来自headlines_wiht_i()的示例

i_count = 0
    for article in article_list:
        if article.headline_include_i():
            i_count +=1return i_count

def headline_median_word_count():

这是设置稍有不同的计数器之一。在使用statistics.median方法寻找中位数之前，我们使用列表理解来填充标题字数列表。

word_count_list = [words.headline_word_count() for words in article_list]word_count_median = statistics.median(word_count_list)
return word_count_median

def 读取时间摘要():

read_time_summary 的要点代码

我想为 read_time 数据创建一个字典。这样我们就可以知道一篇 X 分钟的文章写了多少次。

如果我们有一个这样的列表:
read _ time:5
read _ time:9
read _ time:2
read _ time:5
read _ time:4
read _ time:3
read _ time:3

该字典将如下所示:

read_time_dict ={2:1，3:2，4:1，5:2，9:1}

这意味着 2 分钟的文章被发现 1 次，3 分钟的文章被发现 2 次，以此类推。

我们快速检查 read_time 键是否已经在字典中。如果不是，我们就创建它。如果它确实存在，我们就增加它。

有了这样一个函数，我们可以在任何时候请求 read_time 数据的概览。

def 平均读取时间():

使用 read_time_summary()字典，我们可以很容易地得到平均读取时间值。

read_sum = 0
    read_time_extract = read_time_summary()
    for key,value in read_time_extract.items():
        minutes = key*value
        read_sum += minutes
    return read_sum/len(article_list)

def 中值读取时间():

为了找到中值 read_time，我们再次使用statistics.median函数。该函数需要一个列表，所以我们将使用read_time_summary函数来创建这个列表并返回中值。

read_time_list = []
    read_time_dict = read_time_summary()
    for key,value in read_time_dict.items():
        for iteration in range(0,value):
            read_time_list.append(key)read_time_median = statistics.median(read_time_list)
    return read_time_median

定义 publication_summary():

publication_summary与read_time_summary的逻辑相同

输出:

照片由 AG Z 从 Pexels 拍摄

是时候输出了。产出是我们本质上所追求的。这是我们数据的表示。

我已经把不同的输出写成了程序，所以我们可以随心所欲地打开和关闭它们。

有两种输出结构。

列表输出:

列表输出的公式如下:

header
information : {data}

表格输出:

表格用tabulate方法输出打印数据

header1 - header2 - header3
-data1-----data2-----data3--

以下是输出程序及其终端打印表示

def 输出读取时间数据():

输出 _ 读取 _ 时间 _ 数据代码

输出 _ 读取 _ 时间 _ 数据终端打印

def 输出发布数据():

这是我们第一次使用tabulate方法。当我们遍历 publication_dict 时，我们可以使用键和值来创建我们发送给制表方法的列表。

publication_dict = publication_summary()
    #create list to print.
    table_representation_list = []
    for key,value in publication_dict.items():
        publication_table = [key,value]
        table_representation_list.append(publication_table)

我们还想在展示之前对其进行排序。

sort_table = sorted(table_representation_list , key=lambda x: x[1],reverse= True)

tabulate让我们定义标题和表格样式。有很多好看的桌子款式。这个工具我用的是 fancy_grid。

print (tabulate(sort_table, headers= ['Publication' , 'Articles'],tablefmt="fancy_grid"))

我建议你在这里看看所有的选择:

制表样式格式选择

输出 _ 发布 _ 数据代码

输出 _ 出版 _ 数据终端打印

def 输出标题数据():

输出 _ 标题 _ 数据代码

输出 _ 标题 _ 数据终端打印

def 输出日期数据():

这个过程处理日期。我们想看看作者每月写多少文章。我们创建一个 dict，以月份作为键，以该月写的文章数量作为值。这样我们也可以找到平均值。超级俏皮👍🏼

为了让这个程序更容易使用，我决定每月设定 4 周。如果你设置一个日/月字典{'Jan':31，' Feb':28…}，你可以得到一个完美的计算。

输出日期数据代码

输出日期数据终端打印

def 输出 _ 文章 _ 数据():

我并不经常使用这个过程，但这是一个很好的方法，可以收集每篇文章的信息并打印出来，这样你就可以更仔细地检查它们。

输出 _ 商品 _ 数据代码

输出 _ 文章 _ 数据终端打印

def 输出 _ 牵引力 _ 数据():

与前面的程序一样，牵引力数据用于检查物品。

它根据每分钟的鼓掌次数和每分钟的响应次数为文章分配一个分数。

输出 _ 牵引力 _ 数据代码

输出 _ 牵引 _ 数据终端打印

def top_ten(比率类型):

这个程序大概有几种写法。如果你知道更好的方法，请在评论中告诉我。我相信这是可以优化的。

这个过程根据鼓掌率(每分钟阅读时间你得到多少次鼓掌)或响应率(每分钟阅读时间你得到多少次响应)输出一个包含前 10 篇文章的表格。

首先，我们用文章填充一个列表，其中我们添加了一个包含标题(作为标识符)和比率值的元组。

对电路板进行排序是通过我们之前使用的一行漂亮的小代码来完成的:

sorted_board = sorted(ratio_board , key=lambda x: x[1], reverse=True)

有了排序板，我们只需要前 10 篇文章:

sorted_board = sorted_board[0:10]

然后使用制表来输出表格。

十大代码

十大终端打印—拍手

前十名终端打印-响应

def 魔法公式():

最后的程序！真正的神奇公式。这使用了前 10 个逻辑中的大部分，看起来非常相似。

魔术公式代码

一篇好文章的所有有价值的分析数据都在这个表中。是利用好这些数据，还是只是为了好玩而阅读，这取决于我们。

魔术公式终端打印

def analyse_writer(数据集):

这个过程执行我们想要的所有输出。这种设置方式使得故障排除非常容易。只需注释掉你已经完成的部分，并专注于你正在做的部分。

def analyse_writer(dataset):
    '''
    Procedure that reads the CSV file and
    outputs all data.
    '''
    read_csv(dataset)
    output_article_data()
    output_read_time_data()
    output_date_data()
    output_headline_data()
    output_traction_data()
    output_publication_data()
    top_ten('Claps')
    top_ten('Responses')
    magic_formula()

…最后:

#execute the tool:
if __name__ == "__main__":
    analyse_writer('analysis_tim_denning.csv')

最后

照片由 Pexels 的 Andrea Piacquadio 拍摄

这个项目基于每个人都可以获得的文章数据输出一些有价值的信息。这里的所有数据都在你向下滚动作者页面时看到的文章卡片中。

如果你是一名数据科学家，你现在可能会因为看到我们可以使用熊猫完成的所有手动工作而流泪，但这是一个很好的实验项目，专注于编写一些好的程序和函数以及处理真实数据。

如果我再做一次类似的事情，我肯定会把pandas和matplotlib与类似jupyter的东西一起使用。

我希望你喜欢这个旅程:)拿起代码，和你最喜欢的作者一起亲自尝试一下，然后告诉我效果如何。

Python 上下文管理器的魔力

原文：https://towardsdatascience.com/the-magic-of-python-context-managers-adb92ace1dd0?source=collection_archive---------8-----------------------

入门

使用和创建令人敬畏的 Python 上下文管理器的方法，这将使您的代码更可读、更可靠、更不容易出错…

资源管理是任何编程语言都需要做的事情之一。无论您处理的是锁、文件、会话还是数据库连接，您都必须确保关闭并释放这些资源，以便它们正常运行。通常，人们会使用try/finally来完成这个任务——使用try块中的资源，并在finally块中释放它。然而在 Python 中，有一种更好的方法——使用with语句实现上下文管理协议。

因此，在这篇文章中，我们将探索它是什么，它是如何工作的，最重要的是你可以在哪里找到以及如何实现你自己的令人敬畏的上下文管理器！

大卫·贝克尔在 Unsplash 上拍摄的照片

什么是上下文管理器？

即使你没有听说过 Python 的上下文管理器，你也已经知道——根据介绍——它是try/finally块的替代品。使用打开文件时常用的with语句实现。与try/finally相同，引入这种模式是为了保证某些操作将在程序块的末尾执行，即使出现异常或程序终止。

从表面上看，上下文管理协议只是围绕代码块的with语句。实际上，它包括两个特殊的( dunder )方法- __enter__和__exit__ -分别方便设置和拆卸。

当代码中遇到with语句时，__enter__方法被触发，其返回值被放入as限定符后面的变量中。在with块的主体执行后，__exit__方法被调用来执行 teardown -完成finally块的角色。

上面的代码展示了使用try/finally的版本和使用with语句实现简单定时器的更优雅的版本。我在上面提到过，实现这样的上下文管理器需要__enter__和__exit__，但是我们如何着手创建它们呢？让我们看看这个Timer类的代码:

这段代码片段显示了实现了__enter__和__exit__方法的Timer类。__enter__方法只启动定时器并返回self，它将在with ... as some_var中被赋值。在with语句体完成后，用 3 个参数调用__exit__方法——异常类型、异常值和回溯。如果在with语句体中一切顺利，这些都等于None。如果出现异常，就会用异常数据填充，我们可以在__exit__方法中处理这些数据。在这种情况下，我们忽略异常处理，只停止计时器并计算运行时间，将其存储在上下文管理器的属性中。

我们已经在这里看到了with语句的实现和示例用法，但是为了有更多的关于实际上发生了什么的可视化示例，让我们看看在没有 Python 的语法糖的情况下，这些特殊的方法是如何被调用的:

既然我们已经确定了什么是上下文管理器，它是如何工作的以及如何实现它，让我们看看使用它的好处——只是为了有更多的动力从try/finally语句切换到with语句。

第一个好处是整个安装和拆卸都在上下文管理器对象的控制下进行。这可以防止错误并减少样板代码，从而使 API 更安全、更易于使用。使用它的另一个原因是with块突出了关键部分，并鼓励您减少该部分的代码量，这通常也是一个好的实践。最后，也是最重要的一点，这是一个很好的重构工具，它将常见的设置和拆卸代码分离出来，并转移到一个地方，即__enter__和__exit__方法。

也就是说，如果你以前没有使用过上下文管理器，我希望我说服你开始使用它们而不是try/finally。所以，现在让我们看看一些很酷很有用的上下文管理器，你应该开始把它们包含在你的代码中！

使用`@contextmanager`使其变得简单

在上一节中，我们探讨了如何使用__enter__和__exit__方法实现上下文管理器。这很简单，但是我们可以使用contextlib，更具体地使用@contextmanager，让它变得更简单。

@contextmanager是一个装饰器，可以用来编写独立的上下文管理函数。因此，我们不需要创建整个类并实现__enter__和__exit__方法，我们只需要创建一个生成器:

这个代码片段实现了与上一节中的Timer类非常相似的上下文管理器。然而这一次，我们需要更少的代码。这段代码有两部分——在yield之前的所有内容和在yield之后的所有内容。yield之前的代码接替__enter__方法的工作，yield本身就是__enter__方法的return语句。yield之后的一切都是__exit__方法的一部分。

正如您在上面看到的，像这样使用单个函数创建上下文管理器需要使用try/finally，因为如果在with语句体中出现异常，它将在带有yield的行中被引发，我们将需要在对应于__exit__方法的finally块中处理它。

正如我已经提到的，这可以用于自包含的上下文管理器。然而，它不适合需要成为对象一部分的上下文管理器，例如连接或锁。

尽管使用单一函数构建上下文管理器会迫使您使用try/finally，并且只能用于更简单的用例，但在我看来，这仍然是构建更精简的上下文管理器的优雅而实用的选择。

现实生活中的例子

现在让我们从理论转到实际有用的上下文管理器，您可以自己构建它。

日志记录上下文管理器

当需要尝试找出代码中的一些 bug 时，您可能会首先查看日志来找到问题的根源。然而，这些日志可能被默认设置为错误或警告级别，这可能不足以用于调试目的。更改整个程序的日志级别应该很容易，但是更改特定代码段的日志级别可能会更复杂——不过，这可以通过下面的上下文管理器轻松解决:

超时上下文管理器

在本文的开始，我们是在玩代码的计时块。相反，我们将尝试为由with语句包围的块设置超时:

上面的代码为这个上下文管理器声明了名为timeout的类，因为这个任务不能在单个函数中完成。为了能够实现这种超时，我们还需要使用信号——更具体地说是SIGALRM。我们首先使用signal.signal(...)将 handler 设置为SIGALRM，这意味着当内核引发SIGALRM时，我们的 handler 函数将被调用。至于这个处理函数(_timeout_handler)，它所做的只是抛出TimeoutError，如果没有及时完成，它将停止执行with语句的主体。处理程序就绪后，我们还需要开始指定秒数的倒计时，这由signal.alarm(self.seconds)完成。

至于__exit__方法——如果上下文管理器的主体设法在时间到期前完成，那么SIGALRM将被signal.alarm(0)取消，程序可以继续。另一方面，如果由于超时而产生信号，那么_timeout_handler将产生TimeoutError，而TimeoutError将被__exit__捕获并抑制，那么with语句的主体将被中断，代码的剩余部分可以继续执行。

利用已经存在的东西

除了上面的上下文管理器，在标准库或者其他常用的库中已经有很多有用的了，比如request或者sqlite3。让我们看看能在里面找到什么。

临时更改小数精度

如果您正在进行大量的数学运算并需要特定的精度，那么您可能会遇到需要临时更改十进制数精度的情况:

上面的代码演示了没有上下文管理器和有上下文管理器的两个选项。第二种选择显然更简短，可读性更强。它还排除了临时上下文，使其不容易出错。

从`contextlib`开始的所有事情

当使用@contextmanager时，我们已经偷看了contextlib，但是还有更多我们可以使用的东西——作为第一个例子，让我们看看redirect_stdout和redirect_stderr:

如果你有工具或者函数默认输出所有数据到stdout或者stderr，但是你更喜欢它输出数据到其他地方——比如文件——那么这两个上下文管理器可能会很有帮助。和前面的例子一样，这极大地提高了代码的可读性，并消除了不必要的视觉干扰。

另一个来自contextlib的便利工具是suppress上下文管理器，它将抑制任何不想要的异常和错误:

正确处理异常当然更好，但是有时候你只需要去掉那个讨厌的DeprecationWarning，这个上下文管理器至少会让它可读。

我要提到的contextlib中的最后一个实际上是我最喜欢的，它叫做closing:

这个上下文管理器将关闭作为参数传递给它的任何资源——在上面的例子中——这将是page对象。至于在后台实际发生了什么——上下文管理器实际上只是强制调用page对象的.close()方法，就像使用try/finally选项一样。

用于更好测试的上下文管理器

如果你想让人们使用、阅读或维护你写的测试，你必须让它们易读易懂，而mock.patch上下文管理器可以帮助你做到这一点:

将mock.patch与上下文管理器一起使用可以让您摆脱不必要的.start()和.stop()调用，并帮助您定义这个特定模拟的明确范围。这个工具的好处是它既能与unittest一起工作，也能与pytest一起工作，尽管它是标准库的一部分(因此也是unittest)。

说到pytest，让我们也从这个库中展示至少一个非常有用的上下文管理器:

这个例子展示了pytest.raises的非常简单的用法，它断言代码块引发了所提供的异常。如果没有，那么测试失败。这对于测试预计会引发异常或以其他方式失败的代码路径非常方便。

跨请求保持会话

从pytest前往另一个伟大的图书馆——requests。通常，您可能需要在 HTTP 请求之间保留 cookies，需要保持 TCP 连接活动，或者只想对同一台主机执行多个请求。requests提供了良好的上下文管理器来帮助应对这些挑战，即管理会话:

除了解决上述问题，这个上下文管理器还可以帮助提高性能，因为它将重用底层连接，从而避免为每个请求/响应对打开新的连接。

管理 SQLite 事务

最后但同样重要的是，还有用于管理 SQLite 事务的上下文管理器。除了让你的代码更整洁，这个上下文管理器还提供了在异常情况下回滚更改的能力，以及在with语句体成功完成时自动提交:

在这个例子中，您还可以看到closing上下文管理器的良好使用，它有助于处理不再使用的连接对象，这进一步简化了代码，并确保我们不会让任何连接挂起。

结论

我想强调的一点是，上下文管理器不仅仅是资源管理工具，而是一种特性，它允许您提取和分解任何一对操作的常见设置和拆卸，而不仅仅是像锁或网络连接这样的常见用例。这也是 python 的一大特色，你可能在其他语言中找不到。它简洁而优雅，所以希望本文向您展示了上下文管理器的强大功能，并向您介绍了在代码中使用它们的更多方法。🙂

本文最初发布于martinheinz . dev

[## 下一个 Python 项目的最终设置

从零开始任何项目都可能是一项艰巨的任务…但如果您有这个最终的 Python 项目蓝图就不会了！

towardsdatascience.com](/ultimate-setup-for-your-next-python-project-179bda8a7c2c) [## 编写更加地道和 Pythonic 化的代码

使你的 Python 代码可读、有效、简洁和可靠的习惯用法和惯例。

towardsdatascience.com](/writing-more-idiomatic-and-pythonic-code-c22e900eaf83) [## Python 调试终极指南

让我们探索使用 Python 日志记录、回溯、装饰器等等进行调试的艺术…

towardsdatascience.com](/ultimate-guide-to-python-debugging-854dea731e1b)

被动监督的魔力

原文：https://towardsdatascience.com/the-magic-of-reactive-supervision-3fc83cdb1ca4?source=collection_archive---------44-----------------------

图片由来自 Pixabay 的 Michal Jarmoluk 拍摄

使用社交媒体交互的高质量 NLP 数据标记

这个故事是基于 Shmueli 等人的论文“反应式监督:收集讽刺数据的新方法”，EMNLP 2020。

机器学习模型和它们的训练数据质量一样好。嘈杂、不准确的标签会导致灾难性的预测。但是，获得足够多的高质量标签数据通常是机器学习管道中最具挑战性的部分。特别是对于 NLP 任务来说，获取带标签或带注释的文本可能是一件麻烦而昂贵的事情。

例如，假设你需要标记数据来训练一个用于讽刺检测的分类器。讽刺是一种不真诚的言论，有点类似于说谎。但是谎言和讽刺性话语之间是有区别的:当你撒谎时，你试图而不是被抓住。当你在讽刺的时候，你实际上是希望你的听众“明白”。例如，你可能会告诉你的朋友“哦，是的，统计学非常有趣……”，但你说话的语气很尖刻，因为你想让你的朋友知道你其实讨厌统计学。

这就引出了为什么文本的自动讽刺检测如此重要。如果 NLP 系统没有检测到句子中的讽刺，文本的意思就完全颠倒了。假设您构建了一个情感分类器。如果你的分类器漏掉了，比如说，餐馆评论中的讽刺(“汤是冷的，沙漠是不新鲜的。有史以来最好吃的一顿饭！”)，它可能会将帖子的情绪误归类为“积极”。或者想想人工智能聊天机器人——误解用户的讽刺可能是灾难性的。

照片由达林·麦克卢尔在知识共享下拍摄

好吧，讽刺检测很重要。现在我们需要建立我们的 NLP 深度学习分类器。为了训练我们的模型，我们需要大量带标签的讽刺文本。我们如何着手收集数据？目前有两种方法:手动和自动。

让我们从手动方法开始，在这种方法中，人们被要求——或者更常见的是，被付费——注释或收集讽刺文本。可以想象，这可能会很昂贵，因此数据集通常很小。此外，讽刺是高度上下文和文化敏感的，但注释者往往缺乏必要的上下文——想想亚马逊机械土耳其工人。因此，注释者经常需要猜测一个句子是否是讽刺性的。

另一方面，自动方法使用远程监控。它依靠社交媒体用户将自己的帖子自我标记为讽刺。例如，在 Twitter 上，一些用户可能会在他们的一些推文中添加#讽刺标签。在 Reddit 上，人们偶尔会出于同样的目的使用后缀 /s 。(有趣的事实:这里没什么新鲜的！四百多年前，有人建议用一个反问号(⸮)来表示讽刺；它从未真正流行起来。)远程监督的工作原理是搜索这些标签，并假设相应的文本是讽刺性的。这是一个很酷的想法，但它有一些严重的缺点。首先，只有某些用户会标记他们的帖子，而且可能只针对某些类型的推文。这引入了偏差。此外，人们可能会在非讽刺性的推文中使用#讽刺标签，给这道菜增加一些噪音。

进入被动监督

为了克服所有这些问题，我们提出了一种具有许多优点的全新方法:反应式监督。我们的方法基于社交媒体对话的自然动态。基本的想法非常简单，我们将用下面有趣的测验来演示。准备好！

测验 1:这是三个用户 A、B 和 c 之间的四条推特对话。除了最后一条，所有的推特都被编辑了。我们只展示最后一条推文，也就是用户 A 的“我当时在讽刺 lol”。仔细看图:你能想出讽刺的推文在哪里吗？

(图片由作者提供)

这个不难吧？用户 A 写道“我正在讽刺”，所以讽刺性的推文肯定也是 A 发布的。由于 A 正好发布了另一条推文，我们可以很容易地找到讽刺性的推文。完整的线程显示如下。讽刺性的推文然后是用户 A 的“所以汤姆·汉克斯可以行动了！谁知道呢？？?"。

解决方案 1，和一个温和的提醒(重新)观看阿甘正传

准备好接受另一个测验了吗？这个更有挑战性。开始了。

问题 2:你能在这里找到讽刺的推文吗？

测验 2(作者图片)

这里只有两种选择:要么讽刺性的推文是由 B 发布的，要么是由 c 发布的。我们注意到 A 用"她只是在讽刺！"。“她”是谁？是第三人称，所以不可能是 b，我们断定 C 的推文就是讽刺的那条。太棒了。下面再一次展示完整的线索。

解决方案 2(图片由作者提供)

这些例子展示了反应式监督背后的简单想法——通过利用用户的反应来捕捉和标记讽刺性的推文。为了系统地使用我们的方法，我们首先寻找提示推文，这些推文表示之前推文中的讽刺。线索推文的例子是“我在讽刺 lol”，“我认为你在讽刺”，或者“她只是在讽刺！”。很容易找到线索推文:我们只需在 Twitter 上搜索短语“讽刺”，因为这是社交媒体用户在以前的帖子中想要强调讽刺时常用的。接下来，我们在线索推文中寻找人称代词:我、你或她/他。这告诉我们如何找到讽刺的推文:

第一人称“我”是指线索推文和讽刺推文由同一作者发布。
第二人称“你”意味着提示推文是对讽刺推文的直接回复。
第三人称“他”或“她”表示提示推文是而不是对讽刺推文的直接回复，而是对第三方的回复。

一旦我们找到提示推文及其人物类别(第一、第二或第三)，我们就使用常识规则来找到讽刺推文，如使用两个测验所演示的。

反应式监督可以完全自动化，因此我们可以用它来廉价地收集大量数据。与基于 hashtag 的远程监管方法相比，它还有很多优点。反应式监督最重要的特征之一是它能够捕捉并标记出有意讽刺和感知讽刺。这是下一节的主题。

有意的讽刺，感知的讽刺

假设我们发现了两条使用反应式监督的讽刺性推文。我们发现一条推文使用了第一人称提示“我只是在讽刺”，我们发现另一条推文使用了第三人称“她正在讽刺 lol”。现在我们有两条讽刺的推特。

在第一种情况下，提示推文的作者也是讽刺推文的作者。通过发布线索推文，作者声明他打算这条推文是讽刺性的。这条推文因此被贴上了有意讽刺的标签。

在第二种情况下，发布线索推文的用户是而不是讽刺推文的作者。这条线索推文是由一个阅读了推文并认为它是讽刺的人发布的。人们不会读心术——他们并不真正知道这条推文的原作者是否有意让这条推文具有讽刺意味。我们只能确定一件事:发布提示推文的用户认为这条推文是讽刺性的。因此，我们将这条推文命名为感知讽刺。

有意讽刺(作者图片)

这两种类型的讽刺标签都很重要，并且都有自己的使用案例。我们只举一个例子。想象一个人工智能聊天机器人。当它读取用户的输入时，它需要检测出意图讽刺，这样聊天机器人就可以解释人类的真实意图。另一方面，当聊天机器人生成文本作为对用户的回复时，我们想知道人类是否会认为生成的文本是讽刺性的。这就是感知讽刺分类器变得超级方便的地方。因此，检测有意的和感知的讽刺是两个不同的(尽管高度相关)任务。这就是为什么我们需要这两种类型的数据。

由于反应式监督的工作方式，它捕捉并标记有意的讽刺和感知的讽刺。事实上，反应式监督是在同一数据环境中自动捕捉有意讽刺和感知讽刺的唯一方法。这是非常漂亮的。

高质量标签

使用反应式监督会产生高质量的标签，因为我们利用了用户发布的线索。在某种程度上，用户充当了我们的注释者。美妙之处在于，他们非常熟悉对话的背景——毕竟，他们是讨论的积极参与者——所以标签非常准确。因此，我们的方法克服了与使用外部注释器相关的质量问题。

反应式监督还有许多其他的好特性，在论文中有详细介绍。

SPIRS 数据集

我们使用反应式监督来收集和发布 SPIRS ，这是一个讽刺性推特的大型数据集。

数据集在 GitHub 上公开。

公共服务公告

我们寻找包含“讽刺”的线索推文，因为我们想收集讽刺的文本。根据您的应用和您想要收集的数据集，您可以通过更改您搜索的提示 tweets 来调整反应式监督。这里仅举一个例子:假设您想要获取一个数据集，其中包含表示抑郁或焦虑的文本；在这种情况下，搜索像“听起来很悲伤”或“听起来很焦虑”这样的推文可能会帮助你找到合适的文本。换句话说，反应式监督可以推广到其他领域。

从这里去哪里

如果您想了解更多关于反应式监管的信息，请参阅我们的 EMNLP 2020 论文。它有很多关于方法、算法、数据集和我们做的一些实验的细节。你也可以查看我们创建并公开的 SPIRS 讽刺数据集。

我们希望你喜欢这个故事！如果你有任何关于反应式监督的问题、想法或建议，或者计划在你自己的研究或项目中使用这种方法，请随时给我发电子邮件或发@ shmu EliDM 我。我很乐意收到你的来信——我不是在讽刺你！

注: 本文 是与和 苏米亚雷 的联合工作。

钟形曲线的魔力

原文：https://towardsdatascience.com/the-magic-of-the-bell-curve-60caa40bf182?source=collection_archive---------22-----------------------

理解统计学的一个基本定理

我几乎不知道有什么比“错误频率法则”所表达的宇宙秩序的奇妙形式更容易打动想象力。如果希腊人知道法律的话，他们就会把它人格化，神化。这是非理性的最高法则。每当一个混沌元素的大样本被拿在手里，并按照它们的数量级排列时，一种意想不到的、最美丽的规律性形式被证明一直隐藏着。
-爵士弗朗西斯·高尔顿****

阿莱西奥·达马托、米哈伊尔·梁赞诺夫/CC BY-SA(http://creativecommons.org/licenses/by-sa/3.0/)

这个世界令人难以置信地混乱，所以我们甚至需要一定的勇气去试图在其中找到永恒的结构。统计学家是这群大胆的人中的一员，他们总是在寻找规律性。但是规律性很难找到，关于这个世界的强有力的陈述通常只有在长期盲目徘徊的代价下才会出现。

但有时候，就好像大自然奖励了我们的坚持，给了我们一份礼物，让一切都变得简单了很多。中心极限定理(CLT)就是这样一个例子。它的力量甚至会让久经风雨的统计学家感到惊讶，它的有用性使它成为概率论的核心概念之一。

它是什么——它不是什么

由于其在统计学中的重要性和广泛的适用性，CLT 的概念以某种形式进入了介于常识和民间传说之间的灰色地带。和所有关于这个界限的概念一样，它有被曲解和误解的危险。因此，区分 CLT 说了什么和没说什么很重要。

CLT 没有说明几乎所有的随机变量都是正态分布的。坦白地说，这也没有多大意义，因为事情可以按照他们喜欢的方式进行分配。

另一方面，确实陈述了即使从许多非正态分布中添加足够大的样本也会导致 样本的分布意味着 实际上是正态分布。

让我们仔细看看这是如何工作的。

中心极限定理

假设我们从一个有点混乱和无组织的分布开始。这可能代表许多不同的东西，例如，掷骰子的结果或不同种族人群中的身高分布。我们唯一的要求是分布有一个明确定义的均值和方差(正如你在这个例子中看到的，这并不意味着分布必须遵循一个钟形曲线！):

Mathieu ROUAUD / CC BY-SA

在上面显示的曲线中，这可能表示男女混合人口中的平均身高，其中男性占人口的比例较大，因此分布有两个峰值，第二个峰值位于较大的平均身高处。

独立于分布的细节，让我们假设我们可以从这个分布中重复采样 N 次(比如从人群中随机走到 N 个人面前，测量他们的身高)。对于这个 N 人的样本，然后通过将所有样本相加并除以 N 来直接计算 样本均值

这里重要的一点是，在实践中，我们不需要知道潜在的人口分布，然后我们就可以从中取样。CLT 根本不在乎:它指出，如果你一次又一次地从这个总体中抽取 N 个样本，样本平均值除以标准误差，将收敛于正态分布:

Mathieu ROUAUD / CC BY-SA

在更正式的术语中，中心极限定理指出，如果我们有一组 x_i，其中 I 来自 1…N 个相同分布的随机变量，具有有限的正方差和有限的期望值，那么样本均值的误差，通过样本大小的平方根与总体分布的协方差加权，收敛于标准正态分布:

考虑到我们没有对进入总和的随机变量做任何假设，这是非常显著和令人惊讶的，坦率地说，我们的直觉完全接受它有一些问题。

为什么即使在最混乱和偏斜的分布中也会出现如此整齐的顺序？

简单的例子

照片由安德烈·弗朗索瓦·麦肯齐在 Unsplash 拍摄

这一举动让我质疑自己的理智，我决定通过扔硬币来看看 CLT 的魔力。

我反复投掷硬币 50 次，并记录每次试验后得到的人头数。经过几次这样的冥想练习，数到 1500 次投掷硬币，我得到了这个柱状图:

直方图统计了投掷 50 次硬币后的人头数。

现在我对此并不十分满意(考虑到我浪费的时间)，但得到一点钟形曲线结构出现的提示还是有点特别。

但是，随着我的耐心逐渐消失，我用 Python 脚本自动将剩余的硬币抛入虚拟空间:

******

每次投掷 50 枚硬币 200 次和 10000 次后的最终结果直方图。**

分别经过 200 次和 10000 次试验后，曲线接近一个很好的钟形曲线，如你所料，以平均值 25 为中心。

需要再次强调的是，从分布中抽取的样本数量不能太少。对于大多数分布来说，最合适的值是 30 左右，这取决于基础分布的偏斜程度(如果总体分布已经是正态分布，那么这就没关系，1 个样本就足够了)。例如，如果投掷硬币的次数变得显著低于 30 次，则分布开始看起来不对称，如在 5 次投掷硬币的样本量的情况下:

如果您想自己进一步试验，以下是 Python 脚本:

import matplotlib.pyplot as plt
import randomnumber = 50
trials=10000
head_count =[]
for i in range(trials):
    heads=0   
    for amount in range(number):
        flip = random.randint(0, 1)
        if (flip == 0):
            heads=heads+1
    head_count.append(heads)
plt.hist(head_count, bins = n_bins)
plt.style.use('ggplot')
plt.show()

为什么这如此有用

每个人都相信[正常的]误差定律:数学家，因为他们认为这是一个实验事实；而实验者，因为他们假设这是一个数学定理……
加布里埃尔·李普曼

抛硬币可能看起来只是一个具体的例子，但由于我们在现实世界中遇到的各种数量往往是许多未观察到的随机事件的总和，CLT 有助于解释为什么钟形曲线在如此多的情况下出现。

在实践层面上，它也非常有用，因为正态分布很容易处理，而且假设检验很容易计算并标准化为正态分布。

假设我们想要对未知人口分布的均值进行陈述，这隐含着我们在科学和日常生活中做了很多。我们可以问街上的普通人有多高，或者 60 岁以上的人胆固醇的平均浓度是多少。

假设你是一名药理学家，想要测试一种新药，方法是评估 50 名服药者的胆固醇水平，并与 50 名未服药者的胆固醇水平进行比较。试验后，您获得了两个胆固醇水平样本均值，假设样本大小 N 为 50 足够大，中心极限定理证明了均值的概率分布为高斯分布，因此您可以采用标准假设检验来评估药物产生效果的概率。

非理性的最高法则

正确地看，数学不仅拥有真理，而且拥有至高无上的美。
——伯特兰·罗素

从混乱中产生的秩序令人非常满意，CBT 就是这样做的。尽管它在数学上简单明了并且可以被证明，但看到它的实际应用还是会让人大吃一惊。

它很好地位于有用性和抽象性之间，普遍性和简单性之间。它值得深入了解，不仅仅是因为它在如此多的地方出现并且如此有用，还因为它如此简单和美丽。

模块的制作

原文：https://towardsdatascience.com/the-makings-of-a-module-5990100216d4?source=collection_archive---------37-----------------------

实践 OOP 开发以产生快速线性模型并应用脊和套索正则化

提示和问题

最近在我的数据科学训练营完成了一个关于使用面向对象编程的讲座后，我选择实践这些原则，并将它们应用到一个工具中，我可以在作为数据科学家的工作中继续使用它们。我观察到这个项目旨在解决的三个问题是:

新手身份导致方向不明
常见步骤的重复代码(导入、拆分等)
由于常见的印刷或语法错误而导致失败的倾向

这个模块将允许我“聪明地工作，而不是努力地工作”，并尽可能地简化数据清理和 EDA 阶段。

假设

我的 qdtools，或“快速和肮脏”模块最初将包含线性回归方法以及脊和套索正则化技术。它将在使用过程中为用户提供反馈和指导。正如所料，该模块将严重依赖于现有的模块和来自熊猫，sklearn 和 statsmodels 的软件包，并将主要用于为我自己的需求定制的“香草”建模。最后，该模块将需要不断开发和增强，并将是合作的开源。

初速电流状态

处理线性回归数据集时，数据科学家必须遵循一些定义好的步骤(简而言之):

上传并快速查看数据集
为培训和测试定义目标和分割数据集
探索原始数据
清理数据集
运行模型并分析

或者，像在 CRISP-DM 模型中一样，进行数据准备、建模和评估(根据需要重复)。

特别是在线性模型中，我发现这个过程的一些步骤可以包装在一个函数中，以减少时间编码和限制错误，从导入模块和平面文件开始

分配目标和特征，

分割数据集

接下来是虚拟或一次性编码、缩放和标准化以及建模。我们将看看 qdtools 如何帮助我们加速这一过程。

使用 qdtools

免责声明:本演示进展很快，因为我们已经熟悉了 kc_house_data 数据集

首先，qdtools.py 文件位于 site-packages 文件夹中，所以我不需要在 jupyter 笔记本的工作目录中有一个副本。此时，唯一要实例化的类是 LinearVanilla

非常好。用户甚至会收到一个确认消息，确认对象已经创建，并指示用户尝试 help()方法。我们去看看。

这很有帮助！好了，让我们直接跳过 kc_house_data.csv。

又来了，多么健谈。我们通常会查看数据帧，并使用。info()和。描述()，但是让我们看看 qd_info_df()方法能向我们展示什么

哎呀，这是一个很大的信息扔在那里。但是，注意到什么不同了吗？这不仅是一个函数调用的 info()和 describe()输出，而且它们被稍微修改以包含一些潜在有用的信息。在这种情况下，我们可以在 1 和 99%看到一些额外的分位数数据；这可能会派上用场...

就现在。仔细观察这个数据集，我发现有一栋房子有 33 个卫生间，但 99%的房子只有不到 6 个。让我们使用 cut99()方法删除一些异常值(在其他列中也是如此)

注意:你可能不想(阅读，你可能被告知你不应该)以这种方式或根本不想剔除异常值，但对我来说，这是一个学习的经历，包括能力来快速轻松地做到这一点。

现在，让我们分割数据，并设置一个分类特征，邮政编码。

使用方法的两行简短代码。我看到自己在未来会经常使用这种方法！在这里看不到，但是可以像使用 test_train_split()一样操作 test_size 和 random_state，target_and_split()就是从 test _ train _ split()派生出来的。在我们运行我们的模型之前(已经？！)，让我们删除一些我们现在不想包含在普通模型中的列，同时，让我们处理一些空值

信不信由你，我们已经准备好运行一些模型。对于线性香草，我们运行两种方法来获得统计模型 OLS 和 sklearn 线性回归，岭和套索分数。

我们可以看看我们的训练成绩，

我们可以访问我们的 OLS 摘要作为我们对象的属性

我们刚刚在一个原始数据集上运行了三个“模型”(对此我们很熟悉),得分为 0.83…非常好！我们甚至使用了一个分类特性，但是不必处理 get_dummies()的编码。此外，我的 R 为 0.87 的原始项目包括了我们在这里没有探讨的工程特性。不幸的是，截至这篇博客发表之日，我还没有对这些错误的分析。

我学到了什么

这个模块的开发比预期的更具挑战性(也更耗时)。吸取的第一个教训是预先确定模块的范围；我发现自己正在庆祝我之前设计的新代码块的成功执行，却发现它破坏了模块的一个关键功能。

一些更具技术性的发现包括在模块内放置导入(在声明类之前)，高效的控制流，

以及在哪里存储？py 文件，这样该模块可以在系统范围内使用(参见这篇有用的文章)。我还获得了使用文本编辑器和调试的美妙体验。总而言之，看到我的代码变得栩栩如生，并为自己创建了一个我可能会经常使用的工具，这是令人兴奋的。

局限性和未来工作

我不能夸大的是，我意识到这个模块对于许多数据科学家来说可能并不实用，它主要是 OOP 中的一个实践。qdtools 1.0 是一个激动人心的有用的模块，它有一些很棒的回归工具，但是它也不是没有缺点。

我希望该模块适用于任何数据集，因此需要更健壮的数据清理方法(或控制流)。
特征只能被删除或虚拟编码，因此工程特征不在模块范围内。
可视化；我的目标是包括一些快速和肮脏的 EDA 方法(sns pairplots，相关矩阵)
我期望在模块中实现 OneHotEncoder
“抬头显示”的潜在高价值功能，在建模前突出显示您的功能数据的关键点，如有多少唯一值的计数为 1，以及(可能)基于算法的推荐器，用于确定某一列是否应该分类，甚至是否应该删除；这将使用 OLS 汇总中的 p 值。

在添加更多功能之前，我将花时间创建完整的文档和一个有组织的库，这样任何人都可以使用并为这个项目做出贡献。

SQL 的多种风格

原文：https://towardsdatascience.com/the-many-flavours-of-sql-7b7da5d56c1e?source=collection_archive---------15-----------------------

照片由福蒂斯·福托普洛斯在 Unsplash 拍摄

数据工程

2022 年的 SQL 前景会是怎样的，它的未来会是怎样的？

本文最后一次更新于 2022 年 12 月 9 日。

随着 SQL 成为传统数据库的事实上的查询语言，它可能已经在当前用于部署生产级应用程序的几乎所有技术栈中占有一席之地。即使当传统数据库(读关系数据库)不在使用时，SQL 也不可避免地在系统中显示自己。卡珊德拉有类似 SQL 的 CQL，Spark 有 SparkSQL，甚至 JIRA 有类似于基本 SQL 子句的 JQL，比如WHERE、IN、BETWEEN等。这些子句不仅仅属于 SQL，它们也是几乎所有编程语言的一部分，用于循环和条件结构中。为了不离题太远，我想证明 SQL 不仅会在不远的将来出现，还会在遥远的将来出现。

我正在读保罗·格拉厄姆写的一篇关于未来语言的文章。他谈到了语言是如何在人类时间线上进化的，计算机语言是如何进化的，以及它们之间是如何相似的。这是一个很有趣的问题，不是吗？

他们会用什么样的编程语言来编写控制那些飞行汽车的软件？

—保罗·格拉厄姆

[## 百年语言

2003 年 4 月(本文摘自 PyCon 2003 的主题演讲。很难预测未来的生活会是什么样子

www.paulgraham.com](http://www.paulgraham.com/hundred.html)

我们从不使用“SQL 是编程语言之一”这样的句子，就像我们使用“Python 是编程语言之一”这样的句子一样。 SQL 是查询语言。然后是 SQL 风格。这是标准。但认为它在未来不会改变将是一个疏忽。

在这个领域工作了一段时间后，我知道许多传统和非传统的数据库都使用 SQL。我想探索当前实践中不同风格的 SQL。下面是 SQL 最常用、最流行的风格的汇编。

[## 我们总会有续集

为什么 SQL 是数据工程、数据科学和软件开发的不二之选

towardsdatascience.com](/well-always-have-sequel-55325432174)

关系数据库

大多数关系数据库支持写在ANSI-92 SQL 文档中的基本 SQL 功能。最重要的是，每个数据库都有自己的一组附加特性，这些特性需要额外的 SQL 语句来利用这些特性。让我们来看看其中的一些。

MySQL

很长一段时间，MySQL 不支持分析和窗口功能。它只支持基本的聚合和GROUP BY。然而，MySQL 的替代者，如 Percona Server 和 MariaDB，甚至在 MySQL 之前就已经发布了这些特性。

您可以从 SQL 客户端或 SQL 终端执行的所有操作都应被视为 SQL。例如，在 MySQL 中，您可以运行一个SHOW SLAVE STATUS命令来检查从属服务器的当前状态，以及复制是否正在工作，它已经进行了多远，等等。这不是标准 SQL 的一部分，在其他数据库中也不受类似的支持。要了解 SQL-92 标准，可以通过这篇 500 页的文档。

MySQL 的一些独特特性是

支持本机复杂复制拓扑
模拟分析函数和 PL/SQL 功能的会话和全局变量
存储引擎 —支持这么多存储引擎的数据库并不多

[## MySQL 专家编写的阅读材料——书籍和博客

一个资源列表，由曾在 MySQL、Oracle 工作过的人提供，他们开发了广泛使用的 MySQL 分支，或者…

medium.com](https://medium.com/crowdbotics/mysql-from-the-horses-mouth-582dbfca2abb)

一种数据库系统

PostgreSQL 通常被称为程序员的数据库，它通过对数组等高级抽象数据结构的原生支持，在开源领域成为 MySQL 的真正竞争对手。例如，要检查复制状态，您需要检查这个表— pg_stat_replication。使 PostgreSQL 与众不同的一些特性是

可扩展—您可以向数据库添加扩展以增强其功能。PostGIS 是 PostgreSQL 的流行扩展，PostgreSQL 是一个用于进行地理空间 SQL 查询的库。
对抽象数据类型的广泛支持，尤其有助于匹配应用程序编程语言中的常见数据类型。
与 MySQL 不同，PostgreSQL 确实扩展了自己，加入了一种过程语言 PL/pgSQL，类似于 Oracle 的 PL/SQL。

这里有几个工作中的 PostGIS 扩展的例子

在 Github Gist 上托管

甲骨文

关于 Oracle 数据库，我们能说些什么？它可能是最有弹性和最耐用的数据库，这就是为什么它继续在需要最强酸性和随之而来的保证的时间关键型业务中占据主导地位。

Oracle 数据库的一些独特特性是

极强的耐酸性、高可靠性、高耐久性和弹性。
使用CONNECT BY ... LEVEL极大地支持分层查询。
最长时间完全支持分析和窗口功能。

MySQL 和 PostgreSQL 这些年来变得越来越流行的一个原因是它们可以免费使用——它们是开源的。Oracle 是闭源的定义。许可费用可能会扼杀一家小公司。每个企业都负担不起像 Oracle 和 SQL Server 这样的专有数据库。

SQL Server

微软的终极数据库也拥有相似的特性和 ACID 支持级别等。，就像甲骨文一样。同样，就像甲骨文一样，对大多数公司来说成本太高。SQL Server 的一些独特功能包括

支持 T-SQL，微软自己的过程
使用查询存储优化数据库和查询性能的高级查询统计
完全支持分析和窗口功能

这是四种主要的关系数据库。我不算 DB/2，SQLite 等。，因为这些数据库没有足够的新用户。使用 DB/2 的地方可能是遗留系统。SQLite 功能不丰富，不适合生产级应用程序。

非关系数据库和其他

从关系数据库开始，让我们看看一些被称为 NoSQL 数据库、NewSQL 数据库或非关系数据仓库的数据库。

CQL

CQL 是卡珊德拉对 SQL 的回答。它非常类似于 SQL，但同样，就像您将从现在开始看到的所有其他数据库一样，这个数据库也有关于体系结构实现的附加特性，这反过来又需要 SQL 中的附加特性。例如，CQL 有一种叫做ALLOW FILTERING的东西在这里做了很好的解释:

SELECT * FROM ruling_stewards
WHERE king = 'Brego'
  AND reign_start >= 2450
  AND reign_start < 2500 
ALLOW FILTERING;

请访问本页查看的完整功能列表。

SparkSQL

最初，Spark 不支持 SQL 查询，查询必须用 Scala 或 Python APIs 为数据帧编写。SparkSQL 提供了另一个抽象层，使受过 SQL 教育的员工能够轻松地充分利用他们的知识。下面是 Databricks 对 SparkSQL 的一个很好的介绍

[## 大规模使用 SQL-Spark SQL 教程-数据块

Databricks 上 SparkSQL 的简短指南

databricks-prod-cloudfront.cloud.databricks.com](https://databricks-prod-cloudfront.cloud.databricks.com/public/4027ec902e239c93eaaa8714f173bcfc/3137082781873852/3704545280501166/1264763342038607/latest.html)

下面是一个示例查询的样子。您将看到越来越多的新关键字出现在每个其他数据库中，以获得特定于该数据库的功能。

sqlContext.sql("SELECT hashtag.text, count(*) A inst_count 
                  FROM twitter LATERAL VIEW OUTER 
                       explode(entities.hashtags) hashtagsTable AS hashtag 
                 GROUP BY hashtag.text 
                 ORDER BY inst_count DESC").show(4)

下面是 Rittman Mead 关于如何使用 SparkSQL 的一个示例:

[## 使用 SparkSQL 和 Pandas 将数据导入 Hive 和大数据发现

大数据发现(BDD)是探索、转换和可视化存储在您的…

www.rittmanmead.com](https://www.rittmanmead.com/blog/2016/07/using-sparksql-pandas-import-data-big-data-discovery/)

尽管 Spark 即使不支持 SQL 也能提供很多东西，但自从它开始支持 SparkSQL 以来，Spark 已经获得了更多的关注，因为它为数据分析师和数据科学家开辟了道路，否则他们将没有机会在 Spark 上工作(或者将有一个陡峭的学习曲线)。

HiveQL

随着 Hadoop 生态系统的出现，分析大量数据很快变得非常困难，因为每个人都不熟悉编程语言，并且必须编写许多行代码来分析数据。脸书有很多数据要分析，所以他们开发了这个类似 SQL 的查询引擎，运行在 Hadoop 的存储系统之上。Hive 也意味着只查询结构化的分布式数据。以下是配置单元查询的样子:

CREATE TABLE sample_bucket (code STRING, 
                            description STRING, 
                            total_emp INT, 
                            salary INT) 
CLUSTERED BY (code) 
   SORTED BY (salary) 
     INTO 5 BUCKETS;

如果你感兴趣，这里有一份蜂巢备忘单。

InfluxQL

InfluxDB 是一个时序数据库，用于需要实时查询的应用程序。这是一个传统数据库不完全支持的用例。一些新时代的流式管道解决方案为这一功能提供了一些限制。另一方面，InfluxDB 专门处理如下连续查询:

CREATE CONTINUOUS QUERY "cq_basic_rp" ON "transportation"
BEGIN
  SELECT mean("passengers") 
    INTO "transportation"."three_weeks"."average_passengers" 
    FROM "bus_data" 
   GROUP BY time(1h)
END

该查询为您提供了一个小时内的平均乘客数量，而这一个小时的时间段每秒都在不断变化，因此我们得到的指标是一个小时内乘客的实时移动平均值。是不是很酷？

InfluxDB 适合多种高容量、实时、关键的数据收集应用，如物联网、股票市场运动数据、天文数据等。这是来自 InfluxDB 的 David Simmons 的演讲，他讨论了 InfluxDB 的物联网用例。

在这个演讲中，David 说 InfluxDB 中的插入比使用相同硬件的 MongoDB 快 50 多倍。我认为这不准确。这里有一篇比较这两种技术的更好的文章

[## MongoDB 与 InfluxDB | InfluxData 时序工作负载

阅读 MongoDB 和 InfluxDB 之间比较的基准测试结果的更新版本，这两者不匹配…

www.influxdata.com](https://www.influxdata.com/blog/influxdb-is-27x-faster-vs-mongodb-for-time-series-workloads/)

与 MongoDB 相比，InfluxDB 在相同的硬件上快了 2 倍多。试试看！

弹性搜索 SQL

尽管大多数关系数据库现在都支持全文搜索，但关系数据库并不意味着广泛的全文搜索，因为管理存储、内存和索引的成本会很高。Elasticsearch 作为一个专用的全文搜索引擎来拯救我们。

[## Elasticsearch SQL

Elasticsearch 拥有您的数据所需的速度、规模和灵活性——而且它使用 SQL。使用传统数据库…

www.elastic.co](https://www.elastic.co/what-is/elasticsearch-sql)

下面是一个 POST 调用的例子，带有对 Elasticsearch 的查询负载。

POST _xpack/sql?format=txt {   "query":"SELECT OriginCityName, DestCityName FROM flights WHERE FlightTimeHour > 5 AND OriginCountry='US' ORDER BY FlightTimeHour DESC LIMIT 10" }

其他全文搜索引擎如 Solr 也支持 SQL 语法。

密码

neo4j 是一个重要的图形数据库，它也非常支持类似 SQL 的查询。你自己看吧。以下是常规 ANSI SQL 中的一个示例:

SELECT p.ProductName, 
       sum(od.UnitPrice * od.Quantity) AS Volume
  FROM customers AS c
  LEFT OUTER JOIN orders AS o ON (c.CustomerID = o.CustomerID)
  LEFT OUTER JOIN order_details AS od ON (o.OrderID = od.OrderID)
  LEFT OUTER JOIN products AS p ON (od.ProductID = p.ProductID)
 WHERE c.CompanyName = 'Drachenblut Delikatessen'
 GROUP BY p.ProductName
 ORDER BY Volume DESC;

下面是它在 Cypher 中的样子:

MATCH (c:Customer {companyName:"Drachenblut Delikatessen"})
OPTIONAL MATCH (p:Product)<-[pu:PRODUCT]-(:Order)<-[:PURCHASED]-(c)
RETURN p.productName, toInt(sum(pu.unitPrice * pu.quantity)) AS volume
ORDER BY volume DESC;

您可以使用包含简单到复杂转换示例的指南来学习如何将常规 SQL 转换为 Cypher。

[## 关系数据库开发人员:SQL 到 Cypher 指南

本指南教任何熟悉 SQL 的人如何编写等价的、有效的 Cypher 语句。我们将使用…

neo4j.com](https://neo4j.com/developer/guide-sql-to-cypher/)

图形数据库在过去几年中有所发展，其中一个主要的广泛应用是推荐系统。随着越来越多的基于社交媒体的互动，图形数据库预计会增加。

DynamoDB

亚马逊的键值和文档数据库产品目前主要与 MongoDB 竞争。虽然 DynamoDB 没有原生 SQL 支持，但一个开源项目提供了一个类似 SQL 的外部 DSL，用于在 Amazon DynamoDB 中查询和扫描数据。你可以在这里查看项目。根据我的经验，我在 DynamoDB 上做了一些笔记，你可以在这里查看

[## 关于 DynamoDB 的注释

亚马逊 NoSQL 数据库简介

medium.com](https://medium.com/@KovidRathee/notes-on-dynamodb-cd1eed0cc19a)

StackOverflow 最近发布了其 2020 年开发者调查。了解世界各地的人们在研究什么技术总是很有趣。因为 DynamoDB 是闭源和专有的，所以没有得到那么多关注。开源数据库占据了数据库世界中最大的空间。

最流行的数据库。StackOverflow 开发者调查 2020。

[## 堆栈溢出开发者调查 2020

每个月大约有 5000 万人访问 Stack Overflow 来学习、分享和建立他们的职业生涯。行业估计…

insights.stackoverflow.com](https://insights.stackoverflow.com/survey/2020#technology-most-loved-dreaded-and-wanted-databases-wanted4)

钻

这是一个开源的分布式查询引擎，就像脸书的 Presto(T2)一样，用来分析大规模数据(结构化和半结构化)。Drill 支持大量存储文件格式和外部系统。Drill 的灵感来自于Dremel——谷歌的闭源大规模分布式查询引擎。

在支持常规 SQL 之上，Drill 还支持类似 PostgreSQL 的语言扩展性。您可以使用 jar 文件创建用户定义的函数:

CREATE FUNCTION USING JAR ‘<jar_name>.jar’;
DROP FUNCTION USING JAR ‘<jar_name>.jar’;

在官方文档中可以找到更多关于 SQL 支持的内容

[## 阿帕奇演习

在没有开销(数据加载、模式创建、维护、转换等)的情况下获得更快的洞察力。)分析一下…

drill.apache.org](https://drill.apache.org)

SAP HANA

它是第一个专有的内存列数据库之一，另外还支持基于文档和基于图形的数据模型。HANA 是一个符合 ACID 的数据库。它也是为数不多的对空间、层次和全文搜索查询提供广泛本机支持的数据库之一。下面是一个带有分层函数的查询示例:

SELECT
    hierarchy_rank AS rank,
    hierarchy_level AS level,
    node_id,
    amount AS amount_int,
    avg_amount_int,
    sum_amount_dec,
    num_nodes,
    num_facts
FROM
    HIERARCHY_DESCENDANTS_AGGREGATE(
        SOURCE h_demo
        JOIN h_demo_facts ON node_id = node
        MEASURES (
            AVG(h_demo.amount) AS avg_amount_int,
            SUM(h_demo_facts.amount_dec_fact) AS sum_amount_dec,
            COUNT(DISTINCT h_demo.hierarchy_rank) AS num_nodes,
            COUNT(h_demo_facts.amount_dec_fact) AS num_facts
        ) WHERE hierarchy_level <= 2
        WITH SUBTOTAL '(subtotal)'
        WITH BALANCE '(remainder)'
        WITH NOT MATCHED '(unassigned)'
        WITH TOTAL '(total)'
    )
ORDER BY
    rank NULLS LAST;

该查询将层次结构连接到事实表，并从层次结构本身和事实表中计算各种聚合度量。结果集包含级别小于或等于 2 的所有节点，以及附加的小计、余额和总计结果行。

Teradata

它是数据仓库业务的首批参与者之一，Teradata 已经活跃了 40 多年。Teradata 的运行方式很大程度上类似于传统的关系数据库，但它是用于数据仓库的。和 Redshift 一样，Teradata 也是一个 MPP 系统，号称可以线性扩展。下面是他们的文档中一个典型的 Teradata 查询:

CREATE SET TABLE employeePhoneInfo(
       emp_id INTEGER,
       emp_name VARCHAR(30),
       emp_phone emp_phone_array);
INSERT INTO employeePhoneInfo
SELECT emp_id, emp_name, 
       ARRAY_AGG(emp_phone, NEW emp_phone_array())
  FROM employee 
 GROUP BY emp_id,emp_name           
 WHERE emp_id < 100;

SELECT * FROM employeePhoneInfo;

雪花

雪花是最值得信赖的云数据仓库平台之一。主要与 Amazon Redshift 和 Azure SQL DW 竞争，雪花设法将存储和计算分开，这是它的优势所在。由于数据分析负载千差万别，分离存储和计算似乎是正确的选择。

这里有一个雪花中的 SQL 查询的例子。请注意，除了关键字QUALIFY之外的所有内容都与您在任何其他完全支持 SQL 的关系数据库中找到的内容完全相同:

SELECT c2, 
       SUM(c3) OVER (PARTITION BY c2) as r
  FROM t1
 WHERE c3 < 4
 GROUP BY c2, c3
HAVING SUM(c1) > 3
QUALIFY r IN (SELECT MIN(c1)
                FROM test
               GROUP BY c2
              HAVING MIN(c1) > 3
             );

文档说:

在 *SELECT* 语句中， *QUALIFY* 子句过滤窗口函数的结果。 *QUALIFY* 对窗口函数的作用与 *HAVING* 对集合函数和 *GROUP BY* 子句的作用相同。

当前主要数据仓库参与者之间的一个很好的比较。

结论

衡量你的 SQL 风格有多强大的一个方法是浏览数据库提供的全部特性集——并找出你的 SQL 风格是否已经完全成熟。但是即使一个图灵完整的 SQL 也不能保证处理特定的用例，这些用例是查询 DSL 允许的，但是架构不允许。由于这个原因，存在如此多的数据库/SQL。大多数公司在给定时间使用不止一个这样的系统来存储数据并与之交互。

应用程序混合使用关系数据库和文档存储，但是数据分析师和数据科学家不能像现在这样使用这些系统。数据工程师将数据从源系统传输到数据湖和数据仓库之类的系统，以便数据可以用于报告和分析。我试图涵盖最受欢迎和喜爱的 SQL 风格，因为它们因其独特的特性而创造了自己的市场。

最近，我写了一些数据工程师需要了解的不同技术和概念。讨论的一些技术不属于这一部分。我试着把缺失的整合到这里。你可以在这里找到这篇文章

[## 完整的数据工程师词汇

数据工程师必须知道的 10 个单词以内的概念

towardsdatascience.com](/complete-data-engineers-vocabulary-87967e374fad)

我们从保罗·格拉厄姆关于一百年后语言会是什么样子的观点开始。很难说 100 年后会发生什么，但可以肯定地说，在 5-10 年的时间框架内，SQL 可能会存在，更高效，更先进，更广泛。没有理由不这么认为。因此，虽然这看起来是次要的事情，但它不是。SQL 是软件工程和开发过程的核心，因为，正如我一直说的，SQL 是数据说话的语言。学会说 SQL！

合成数据的许多使用案例

原文：https://towardsdatascience.com/the-many-use-cases-for-synthetic-data-60e0b0193afe?source=collection_archive---------45-----------------------

Hazy 的数据科学

保护隐私的合成数据如何帮助您的企业在竞争中保持领先。

2016 年的一项研究发现，在监控司机刹车模式仅 15 分钟后，研究人员就能够以 87%的准确率识别出该司机。原来，你踩刹车踏板的方式几乎完全是你独有的。

数据的这种敏感性延伸到我们生活的方方面面。你在最喜欢的咖啡馆买的时髦咖啡也会留下行为的数据痕迹。各公司都迫不及待地想获得这些数据，以便制定新的商业策略来吸引你的业务。这就是为什么像欧洲的 GDPR 这样的隐私保护法正在迅速改变数据格局，它们优先考虑消费者保护，赋予你被遗忘的权利，并控制谁有权拥有和访问你的数据。

这就是合成数据的魔力所在。合成数据是使用机器学习算法生成的，这些算法吸收真实数据，训练行为模式，然后完全排除保留原始数据集统计特征的人工数据。这应区别于更传统的匿名数据集，后者实际上很容易受到重新识别技术的攻击。由于合成数据本质上是人工的，因此此漏洞不适用。

由于合成数据的隐私保护性质，它不受相同的数据保护法管辖。机器学习工程师和数据科学家可以放心地使用这些合成数据进行分析和建模，因为他们知道这些数据的行为方式与真实数据相同。这同时保护了客户隐私并降低了利用这些隐私的公司的风险，同时解除了数据的冻结，否则这些数据会被冻结在法规遵从性障碍之后…通常长达数月甚至数年。

从六月底开始，我一直在朦胧合成数据做数据科学实习生。Hazy 团队构建了一个复杂的合成数据生成器和企业平台，帮助客户释放其数据的全部潜力，提高他们的创新速度，同时最大限度地降低风险。

合成数据用例。

现在，您已经了解了合成数据以及它可以帮助解决的高层次问题，让我们进入一些更详细的合成数据用例。

供应商评估。

想象一下。你在一家寻求外包一些工作的公司工作，比如应用程序开发、测试、数据科学、分析和商业智能。像任何大宗购买一样，你想在购买前先试驾一下。这通常意味着将真实且高度敏感的数据交给第三方，这不仅存在安全风险，而且可能需要长达 6 至 18 个月的时间来跨越法律和采购障碍。考虑到这一切只是为了确定你是否想与该供应商合作，这是一个很大的麻烦。

由于数据不再敏感，使用合成数据消除了这一过程中的滞后。人工智能生成的合成数据可能具有足够的代表性，如果你选择与该供应商合作，你可以通过继续只建立在人工数据上来消除任何安全妥协的风险。

与第三方服务共享数据。

与供应商评估类似，使用在线应用程序或云计算资源等第三方服务需要将敏感数据交给该服务。同样的道理也适用于与第三方共享数据，以获得更好的或至少是外部的分析。由于硬件限制，企业可能无法将所有数据保存在内部，因此需要使用在线存储平台或更快的云提供商。但是，法规要求这些数据必须保留在本地。除了通常令人头痛的合规性问题，这可能(也应该)成为公司的一个重大担忧，因为安全漏洞可能会让您的客户和您的声誉都变得脆弱。有了合成数据，一切都是假的。

数据货币化。

如今，许多商业模式完全基于将从用户群中收集的数据货币化。如果你没有为产品付费，那么很有可能就是这种情况。公司可以收集数据，进行分析，并将任何见解出售给有既得利益的外部企业。一些组织出售原始数据，以便外部公司可以进行自己的细致分析，但这带来了更多的监管合规问题，而且这些数据通常被认为过于敏感，无法这样做。

有了合成数据，法规遵从性和风险不再是问题—随后，该数据的价值和从中产生价值的速度都大大提高了。公司甚至可以创造全新的收入来源。毕竟，大多数数据的价值不是个人信息，而是从中获得的洞察力。此外，合成数据比真实数据更灵活，因为它可以无限自动化、放大和丰富，从而开辟更多的货币化机会。

跨组织的数据可移植性。

对数据传输的限制不仅限于与外部公司的交易。在一个组织中，在数据可以在部门之间传递之前，可能需要满足许多法规遵从性标准，这通常需要几周时间。如果涉及到跨越地理边界和法规的共享，时间甚至会更长。

能够创建安全的合成数据集意味着组织可以拥有集中的数据存储库，通常称为数据池，可以通过简单的基于角色的访问控制来管理。例如，银行在其客户的交易历史中拥有特别丰富的数据。通过汇集这些数据的合成双胞胎，可以在来自多个部门和跨国界的数据科学家之间安全地共享。

这种前所未有的合作水平可用于在更大的数据集上进行培训，挖掘出更多模式，以实现更好的洗钱和欺诈检测算法。有了在内部共享信息的自由，企业可以更快地创新和处理新数据——从个性化营销到国际犯罪。这使企业比竞争对手拥有更传统的数据生命周期和人为的创新壁垒更具优势。

数据保留。

法规还限制了公司保留个人数据的时间，这使得很难进行更长期的分析，例如在试图检测几年的季节性时。请记住，合成数据不受同样的隐私保护法的约束——尽管它保留了客户的使用模式，但它完全是人造的。由于没有重新识别的风险，公司可以根据自己的意愿保留其合成数据，并且可以在未来的任何时候重新使用这些数据来进行分析，这些分析是以前没有进行过的，甚至在数据收集时在技术上是不可行的。

模拟意外事件。

准备通常比膝跳反应要好。越来越多的公司希望利用数据为不可预见的情况做准备，在这个前所未有的时代，这种情况比以往任何时候都多。由于有条件的合成数据生成，这种准备现在是可能的。可以采用“正常”或先例数据集，向生成器添加条件，并输出代表以前从未发生过的事件的合成数据集，这允许您分析、建模并随后为这种情况做准备。

有条件的合成数据用例可以从预测客户行为(如果出现第二波疫情)到预测一种癌症转移到全球变暖效应的概率。更一般地说，它可以将一个国家的客户行为与公开的公共数据源结合起来，准确预测一种产品或服务在一个全新的地方会有怎样的表现。

不要被落下。

世界上 90%的数据是在过去两年中创建的，每天有 2.5 万亿字节的新数据被捕获。数据经济已经是一个高度监管的空间，但就数据的当前轨迹而言，随着政府和监管机构急于赶上正在收集的不可估量的数据量，这种情况可能会变得更加严重。

利用合成数据的企业将在竞争中领先一步。它将加快您开发新产品的速度，与第三方建立新的合作关系，甚至创造全新的收入来源，同时大大降低您的风险载体。

输入梯度正则化的许多用途

原文：https://towardsdatascience.com/the-many-uses-of-input-gradient-regularization-e2af244e6950?source=collection_archive---------24-----------------------

将这一通用的概念添加到您的深度学习工具带中，以实现对抗鲁棒性、输入稀疏性、更好的泛化能力等

菲利普·斯温伯恩在 Unsplash 上拍摄的照片

正则化是机器学习的基本技术之一。这个想法是，我们对理想模型的结构做出假设，并修改我们的训练过程，以鼓励产生满足这些期望的模型。通常，正则项是损失函数的一部分。也许机器学习中最常见的正则化是模型权重上的 L1 范数(假设:稀疏权重)和 L2 范数(假设:小权重)，分别导致套索和岭回归。相对较新的是 dropout 的概念，我们喜欢网络中的冗余。

在这篇文章中，我讨论正则化的输入梯度。具体来说，这意味着对输入的梯度如何表征 x wrt 施加一些结构约束。我们的损失函数表现为。自然，这种技术只能应用于训练完全可微分的模型，如神经网络。

对输入梯度施加约束的想法确实很古老，但似乎只是在最近几年才受到重视。为了理解它的有用性，我们需要理解输入梯度的的含义。直观地说，输入梯度告诉我们，在非常小的输入扰动下，模型损耗如何变化。输入梯度是输入空间中导致局部损耗变化最大的方向。

这个特性使它成为许多可解释的 ML 技术的核心，试图用输入来解释输出。(例如，参见综合梯度、显著图、迭代梯度。)这个想法是，知道输入的哪一部分在小扰动下剧烈地改变输出，告诉我们什么输入对当前输出负责。

从广义上来说，输入梯度告诉我们网络关注的是。因此，调整输入梯度给了我们改变模型看世界方式的能力。

引导网络注意力

限制输入梯度的最自然的方法是告诉模型哪些输入区域是重要的，哪些是要忽略的。 Ross 等人实现了一个简单的惩罚，阻止神经网络查看输入的某些部分。

要添加到损失中的惩罚条款。a 是要惩罚的掩码。它适用于损耗 wrt 的梯度。 x 。存在 D 维的 N 个数据点，导致 K 维输出 y 。

在图像处理应用中，通过训练网络仅关注前景对象并在背景元素上具有零梯度，可以潜在地避免噪声或虚假相关。

如果成功应用，这种正则化可能会提高泛化能力(忽略虚假的相关性)并加快学习速度(仅使用输入的重要部分)。

对抗鲁棒性

另一个有趣的应用是使用输入正则化实现对抗鲁棒性。已经证明输入梯度的 L2 正则化可以避免输入上的大梯度——这正是使网络容易受到敌对攻击的原因。

这个正则化项与前一个相似，但没有应用掩膜，交叉熵损失项的表达方式也不同。

人们可以认为这个正则化器改变了网络对输入的感知，使得它必须稍微注意许多特征，而不是大量依赖少数特征。从这个意义上说，这种正规化与辍学有着相似的动机。

有趣的是，为输入梯度正则化网络创建的对抗性攻击可以成功地转移到在相同数据集上训练的其他网络。这使得这个简单的正则化器不仅是一个防御工具，还可能在不知道目标网络的情况下制造攻击。

输入稀疏度

在查看了 L2 正则化在输入梯度上的用途之后，探索 L1 正则化的效用是很自然的。幸运的是，这已经为我们完成了。事实上，使用 L1 规范改变了网络对数据的感知，使得它在任何时候都只认为很少的输入是相关的。

当获取特征的成本很高，并且人们更喜欢仅使用少量特征的模型时，这可能是有用的。或许，它也可以用作分析特征相关性的分析工具，类似于传统的神经注意机制。

正则化方法的优点是简单。您可以轻松地将输入梯度正则化应用于任何网络(但需要一些计算成本)。

希望你学到了有用的东西！

Matplotlib 中调用轴的多种方法

原文：https://towardsdatascience.com/the-many-ways-to-call-axes-in-matplotlib-2667a7b06e06?source=collection_archive---------6-----------------------

Jun 的总结图

学习 matplotlib 的初学者笔记

答虽然matplotlib非常强大，唯一的限制可能是我们的想象力，但对于新用户来说，找到正确的路径有点挑战性，因为在matplotlib中总是有不止一种方法来实现相同的目标。打电话给axes就是其中之一。

假设你只是决定使用matplotlib中的面向对象接口 ( 又名 美工图层绘制 )进行绘制。然而，我敢打赌，当你试图实例化axes来开始你的绘图时，你很快就会遇到问题。你可能会发现plt.subplots()和plt.subplot()都可以还你axes。是的，它们只有一个字母“s”不同。稍后，您会注意到plt.axes()也可以调用axes。这还没有结束，你很可能会遇到下面的函数fig.add_subplot()、fig.add_axes()、fig.subplots()，它们都可以为你创建axes。我完全理解你有多惊慌，因为我在学习matplotlib时也有同样的困惑。

在这篇文章中，我将总结这些函数(即 *plt.subplot()* ， *plt.subplots()* ， *plt.axes()* ， *fig.add_subplot(),* *fig.subplots()* ， *fig.add_axes()*)的区别，并演示如何相应地使用它们。

在matplotlib术语中，一个基本情节从一个figure和至少一个axes开始(如果你对这些术语感到困惑，你可能会发现 这个帖子 是有用的)。与绘画非常相似，figure是画布，axes是艺术构图。一幅画布(*figure*)上可以只有一种类型，也可以有多种不同类型的艺术构图(*axes*)。有鉴于此，让我们首先从只有一个axes的figure的简单案例开始，然后深入到有多个axes的figure。

`Figure`只有一个`axes`

在大多数情况下，我们通过调用fig = plt.figure(…)实例化一个fig对象，然后通过调用ax = fig.add_subplot()将一个axes对象添加到fig中。默认情况下，如果将括号留空，该函数通过fig.add_subplot(1, 1, 1)传递，这意味着在 1 行 1 列axes网格中添加# 1 axes。我们也可以使用一种没有逗号的三位数整数格式(即 *fig.add_subplot(111)*)。但是，对于 3 位整数格式，每个整数都不能大于 9。使用此功能，我们一次只添加一个axes。

# *Create a figure*
fig = plt.figure()# *Add a subplot*
ax = fig.add_subplot()

*# Equivalent method*
ax = fig.add_subplot(111)# *Another equivalent but more general method*
ax = fig.add_subplot(1, 1, 1)

有时，我们能够使用ax = fig.subplots()添加一个axes对象。这个功能最初是为了方便通过单次调用在普通布局中创建一组支线剧情。它将nrows和ncols作为位置参数(，即该函数应该一次添加多个*axes*)。然而，如果我们将括号留空，默认情况下该函数通过fig.subplots(1, 1)传递，这意味着创建一个 1 行 1 列的axes网格(即一个* *axes* 在 *fig*上)。因此axes中只包含一项(即 *len(ax)* 为 1 )。*

*# *Create a figure*
fig = plt.figure()

*# Create a subplot*
ax = fig.subplots()*# Equivalent method*
ax = fig.subplots(1, 1)*

很少，对于有一个情节的figure，我们也可以使用ax = fig.add_axes([left, bottom, width, height])在fig上添加一个axes。该功能通过获取新axes的尺寸(你可以在这里* 找到一个的例子)来启用fig上axes的任意布局。所有四个数字都应该是figure宽度和高度的分数。换句话说，我们控制axes的位置和大小。fig.add_axes([0, 0, 0.78, 0.78])创建与fig.add_subplot(111)和fig.subplots(1, 1)相同大小的地块。正如你在这里看到的，axes和figure大小不一样。默认情况下axes和figure之间有空格。*

*# *Create a figure*
fig = plt.figure()*# Add a subplot* ax = fig.add_axes([0, 0, 0.78, 0.78])*

在演示了以上三个函数的区别之后，理解plt.subplot()、plt.subplots()、plt.axes()就相当容易了。它们来自matplotlib的基于状态的接口 ( 又名脚本层标绘)，只是将fig = plt.figure()对应的包装了fig.add_subplot()、fig.subplots()、fig.add_axes()。

plt.subplot()只返回一个axes并自动创建一个figure对象。您可以通过调用ax.figure.xxx()来更改figure级属性或保存figure。例如，ax.figure.savefig('example.png')会将figure保存为example.png。

**# Creates just a figure and only one subplot*
ax = plt.subplot()# *Equivalent method* fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)*

plt.subplots()返回包含图形和轴对象的元组。我们需要解包这个元组，并将它的项分别分配给变量fig和ax。

**# Creates just a figure and only one subplot*
fig, ax = plt.subplots()# *Equivalent method* fig = plt.figure()
ax = fig.subplots(1, 1)*

当没有提供参数时，plt.axes()使用fig.add_subplot(1, 1, 1)返回一个axes，就像plt.subplot()一样，它自动创建一个figure对象。plt.axes()也在其后端使用fig.add_axes([left, bottom, width, height])接受尺寸(*[left, bottom, width, height]*)。以下两组代码创建了相同的绘图。

*# ***Set one***
*# Creates just a figure and only one subplot*
ax = plt.axes()# *Equivalent method* fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)-------------------------------------------# ***Set two***
*# Creates just a figure and only one subplot*
ax = plt.axes([0, 0, 0.78, 0.78])# *Equivalent method* fig = plt.figure()ax = fig.add_axes([0, 0, 0.78, 0.78])*

`Figure`带多个`axes`

当在figure上绘制多个axes时，这些函数(即* *plt.subplot()* ， *plt.subplots()* ， *plt.axes()* ， *fig.add_subplot()* ， *fig.subplots()* ， *fig.add_axes()*)之间的区别就显而易见了。同样，让我们用例子来证明这一点。由于plt.subplot()、plt.subplots()和plt.axes()与fig.add_subplot()、fig.subplots()和fig.add_axes()本质上是相同的，因此我将只展示后三种功能的示例。*

如上所述，我们在使用fig.add_subplot()时，一次增加一个axes。axes的内置顺序是在axes网格内从左到右、从上到下开始(图 1)。

图一。 fig.add_subplot()创建一个 2×2 轴网格

用一行代码使用fig.subplots()可以获得相同的布局(图 2)。它返回一个ndarray对象axs ( 我在 *ax* 后面加了一个‘s’表示它包含多个对象)。就像 2D 数组对象一样，axs中的每个ax也可以使用axs[x, y]来访问(即 ax1 可以使用 axs[0，0]* 来访问)。而且，如果你喜欢在axs内给每个ax赋值，可以这样使用 tuple 解包，((ax1, ax2), (ax3, ax4)) = fig.subplots(nrows=2, ncols=2)。2D 数组的展平是从axs访问ax的另一种方法，如图 2 所示。*

图 2 创建一个 2×2 轴的网格

通常，fig.add_axes()用于任意布局，例如入口支线剧情或支线剧情相互重叠的剧情。这是因为我们可以通过尺寸来微调每个子情节的位置和大小(*[left, bottom, width, height]*)。话虽如此，我们仍然可以使用fig.add_axes()(图 3)做出如图 1 和图 2 所示的普通布局。

图 3 。创建一个 2×2 轴的网格

综上所述，这六个函数(简而言之应该是三个函数，即*fig.add_subplot(),**fig.subplots()**fig.add_axes()*)在你用一个axes做一个figure的时候可以互换使用。然而，它们有各自的优势，在制作不同布局的多个axes的figure时，可以单独使用或组合使用。**

看完这篇帖子，希望你对matplotlib中如何调用axes有更清晰的认识。这篇文章中的所有代码都可以从这个 jupyter 笔记本中访问。如果您知道此处未列出的其他可调用axes的功能/案例，请随时留下您的评论。让我们一起来学习matplotlib。

和往常一样，我欢迎反馈、建设性的批评以及倾听您的数据科学项目。你可以在 Linkedin 和我的网站上找到我。

《大师算法》——比尔·盖茨建议你阅读的书，以更好地理解人工智能

原文：https://towardsdatascience.com/the-master-algorithm-a-book-review-and-opinion-piece-f3a3f2cf5606?source=collection_archive---------29-----------------------

书评和评论文章。

列宁·艾斯特拉达在 Unsplash 上的照片

你认识伊芙吗？不，不是圣经中的人物。不，不是瓦力的伊芙。

伊芙是一名研究员。她在英国曼彻斯特理工学院工作。2015 年，她发现一种具有抗癌特性的化合物也可以用于抗击疟疾。亚当呢，你认识他吗？他也是一名研究人员，在 2009 年贡献了关于面包酵母酿酒酵母基因组学的新科学知识。

为什么你要关心这些科研人员？

亚当和夏娃都是机器人。使用人工智能建造，标志着自动化和降低科学研究费用的里程碑。自 2009 年以来，我们已经走过了漫长的道路，如今人工智能技术随处可见。这是一个迷人的领域，理解它不仅对科学家很重要，对任何活着的人也很重要，因为它可能会影响我们的职业和个人生活。

人工智能被认为是治愈癌症、加快疫苗研发、降低医疗成本的解决方案。据说人工智能会增加失业率，并对我们所知的人类社会构成威胁。但是什么是真实的呢？这些技术在现实世界中有哪些应用？它们是如何工作的？

这个领域如此广阔，以至于没有人会对这些问题有更多的答案。尽管如此，我们总是可以尝试学习更多。

大师算法:对终极学习机器的探索将如何重塑我们的世界是 2015 年出版的一本书，作者是佩德罗·多明戈斯。这本书减少了我们在这一领域知识的缺乏。

我拿起它是因为:

1。我在寻找机器学习领域的概述，并了解这些点是如何连接的；

2。我想要一个对我自己实现的算法以及我从未合作过的其他算法的技术性更少的解释；

[## 主算法

www.goodreads.com](https://www.goodreads.com/book/show/24612233-the-master-algorithm?ac=1&from_search=true&qid=jrtEkWtSSv&rank=1)

作者背景

但是佩德罗·多明戈斯是谁？在他的简历中，你可以看到:

“我在里斯本的 IST 大学获得了电气工程和计算机科学的本科学位(1988 年)和硕士学位(1992 年)。我在加州大学欧文分校获得了信息和计算机科学硕士学位(1994 年)和博士学位(1997 年)。在 1999 年加入华盛顿大学之前，我在 IST 大学做了两年助理教授

此外，1999 年他开始教授人工智能，并在该领域取得了学术成功，获得了几项最佳论文奖。他最有影响力的项目之一是炼金术、‘一个为统计关系学习和概率逻辑推理提供一系列算法的软件包’。

要了解更多关于佩德罗多明戈斯你可以检查…

…他的简历:https://www.cs.washington.edu/people/faculty/pedrod或者 https://homes.cs.washington.edu/~pedrod/

…他的推特账户:https://twitter.com/pmddomingos

…他的中等账户(不太活跃):https://medium.com/@pedromdd

总结

这本书有 10 章，每一章的目的是揭示一个想法或探索一个特定的主题。我决定总结每一章，这样你就可以了解这本书的结构以及它所涵盖的主题。

1。机器学习革命:通过一些应用的例子介绍机器学习，它可以实现的承诺，以及目前的障碍。在这一章的结尾，作者列出了本书试图回答的问题。

2。大师算法:在这里，本书提出了中心假设:

“所有的知识——过去、现在和未来——都可以通过一个单一的通用学习算法从数据中推导出来。”

这个通用学习算法就是佩德罗多明戈斯所说的主算法。佩德罗·多明戈斯(Pedro Domingos)提到了 5 个不同的思想流派所做的工作，或者他称之为“机器学习的 5 个部落”:象征主义者、连接主义者、进化论者、贝叶斯主义者和类推者。

这为接下来的 5 章奠定了基础，每一章都深入其中一个部落。

3。休谟的归纳问题:潜入在学习过程中融入先存知识的象征主义者。他们掌握的算法是感应。

4。你的大脑是如何工作的:深入研究联结主义者，对他们来说，学习需要理解大脑是如何工作的。更具体地说，基于新的证据，神经元的连接是如何适应的。他们的主要算法是反向传播。

5。进化:自然学习算法:深入探究受自然母亲和自然选择启发的进化者。他们的主要算法是遗传编程。

6。在 Bayes 牧师的教堂里:潜入 Bayesians 人。这个部落最关心的是不确定性，因为所有的知识都有一定程度的不确定性。他们的主要算法是贝叶斯定理。

7。你是你推理出来的人:深入探究类比推理者，他们认为学习的关键是识别事件之间的相似性，并利用这些来推断进一步的相似性。他们的主要算法是支持向量机。

8。无师自通:无监督学习简介，作者认为对 Master 算法很重要的一种技术。这一部分包括算法的简要说明，如 k-means，主成分分析和分块。此外，它还忽略了强化学习。

9。拼图的碎片就位:作者提出了组合不同算法和方法的方式，以便创建主算法。本文介绍了一些以此为目标的当前项目。

10。这是机器学习的世界:作者分享了他对所讨论内容的意义和现实世界影响的看法。他通过设计我们日常生活中的事件以及它们将如何被影响来做到这一点。

意见

总的来说，我真的很喜欢读这本书。这是我第一次接触到 5 个机器学习部落的想法，它改变了我对这个领域以及它如何演变的看法。

此外，Pedro Domingos 通过工作人员描述了该领域的发展。我发现，这种技术的人性化极其重要，因为技术相关领域有时会忘记那些在进步背后的人，或者那些受到这些进步影响的人。此外，这是了解不同研究人员和他们从事的项目的好方法。

关于提出的算法和方法，很少使用公式，概念主要通过类比、例子和图表来解释。这对每个人来说都很容易，但那些有机器学习经验的人可以从一个新的角度看待他们可能经常使用的方法。大多数图表都设计得很好，并支持解释。

不好的一面是，看不到任何参考文献或脚注。如果你到书的结尾，没有资源列表。即使对于一本为门外汉写的书，我也认为这是一个巨大的缺陷。佩德罗·多明戈斯是一位成就卓著的学者，有着令人印象深刻的记录，但我们不应该简单地购买他所说的一切，更重要的是，我们不能满足我们好奇的心。例如，在某个时候，他提到了一项估计，NSA 截获了超过 10 亿个电话。我很想多读一些这方面的内容，但是我不能。

类似地，在反驳人工智能无法学习所有东西、甚至黑天鹅(Nassim Taleb 书中的一个概念)也可以被机器学习模型预测的论点时，作者指出，2008 年的房地产危机在很大程度上是被预测到的。这又是一个非常有趣的话题，我想从他使用的相同信息开始(而不仅仅是谷歌搜索)，但这些信息无处可寻。

在最后一章中，佩德罗·多明戈斯以极其积极和鼓舞人心的口吻呼吁采取行动。在试图将人们的注意力吸引到该领域的过程中，我相信他成功地为更好地理解什么是机器学习、如何使用机器学习以及在与这些技术交互时应该考虑什么奠定了基础。

还有什么？

如果你不相信，并想了解更多关于这本书的信息，你可以查看以下内容:

一篇关于 5 个部落的简短博文:【https://www.bmc.com/blogs/machine-learning-tribes/
佩德罗·多明戈斯在“谷歌会谈”中说:【https://www.youtube.com/watch?v=B8J4uefCQMc
Pedro Domingos 在 TEDxUofW 上发表的《探索大师算法:https://www.youtube.com/watch?v=qIZ5PXLVZfo

感谢阅读！

希望这篇评论对你有用，尤其是当你正在决定是否要读这本书的时候。

如果你错过了一些信息，或者你有问题，欢迎在评论中写下。我会很感激的。

“大 O”和其他渐近符号背后的数学

原文：https://towardsdatascience.com/the-math-behind-big-o-and-other-asymptotic-notations-64487889f33f?source=collection_archive---------17-----------------------

像“大 O”、“大ω”和“大θ”这样的符号的正式定义。

舒巴姆·莎兰在 Unsplash 上拍摄的照片。

大 O (读作“大 oh”)是计算机科学中广泛使用的一种数学符号，用于描述算法的效率，无论是计算时间还是内存空间。这个和其他所谓的渐近符号的主要目的是通过比较它们的“增长顺序”来描述数学函数的行为。

在这篇文章中，我首先简要介绍了大 O 符号在实践中是如何用来描述算法效率的。后来，我提出了它的数学定义，以及其他类似的符号，如“大ω”(ω)和“大θ”(θ)。此外，我还提供了一些正式的方法，您可以使用这些方法根据这些定义对数学函数进行分类。

简而言之就是“大 O”

注意:如果你习惯于和算法打交道，你可能以前用过或见过大 O 符号。如果您认为您已经对大 O 的含义以及如何用它来描述算法的效率有了大致的了解，那么您可以跳到下一节，在那里您将找到大 O 和其他类似符号的数学定义。

大 O 符号通常用于将算法分成几个基本效率类，比如O(log(n)】、 O(n) 、 O(nlog(n))* 、 O(n ) 等等。我们说一个标准的线性搜索算法在 O(n) 中运行，因为它的运行时间预计会随着它的输入大小线性增加。同样，我们知道二进制搜索是 O(log(n)) ，最高效的排序算法可以运行在 O(nlog(n))* 。

然而，说一个算法是 O(n ) 并不意味着它对给定大小为 n 的输入执行精确的 n 运算。假设算法 A 总是执行 f(n)=2n +n+1 运算。人们通常对这个函数做的是去掉它的非支配项(像+ n 和+ 1 )和它的常数(像 2n 中的 2 )得到它的渐近符号 O(n ) 。如果有一个算法 B 总是执行 f(n)=4n +3n+3 运算，也可以描述为 O(n ) ，虽然它对 n 的任意值执行的运算都是算法 A 的两倍以上。

但这并没有错。当我们使用像大 O 这样的渐近符号时，我们感兴趣的是比较增长的顺序，而不是关心精确的数字。此分析的主要目的是描述算法所需的运行时间或内存空间如何根据输入大小 n 增加，尤其是当 n 相当大时。

如果一个算法是 O(n)，这意味着如果我们将输入大小加倍，那么执行的操作数将是大约的四倍。通过将 n=100 增加到 n=200 ，算法 A 执行的运算次数将从 20，101 次增加到 80，201 次，而算法 B 的运算次数将从 40，303 次增加到 160，603 次。每个算法执行的操作数大约乘以4(尽管不精确)。

另一方面，算法是 O(2ⁿ) 或 O(n！)具有高得多的增长阶数，甚至对于 n 的小值也可以注意到这一点。例如，简单地从 n=10 到 n=20 将导致 O(2ⁿ) 算法多执行大约 1024 次运算。而且，对于一个 O(n！)算法，这将意味着比以前多 6700 亿次运算。

渐近符号的形式定义

如果您不太熟悉大 O 符号，我希望上面的快速介绍足以让您大致了解像大 O 这样的渐近符号是如何工作的，以及为什么在评估算法效率时应用这种形式主义如此有意义。如果你觉得你仍然没有完全理解这个概念，也许你应该在进入这篇文章将要讨论的更复杂的数学定义之前，查看其他有额外例子的文章(像这个)。

在下文中，我将更深入地探讨 O 在数学上是如何定义的。我还将介绍一些其他类似的渐近符号，它们也在计算机科学中用于评估算法的效率。

大 O:上限

到目前为止，我一直以最常用的方式使用大 O 符号:作为对算法效率的精确描述。然而，这在技术上是不正确的——正如我将在下面展示的，大 O 只提供了一种表示上限的方法。所以请记住，从现在开始，我将根据对的数学定义来称呼大 O，而不是通常在实践中使用的。(如果你有兴趣对这个非常普遍的误解进行更深入的讨论，可以查看我之前的这篇文章。)

非正式地说， O(g(n)) 可以理解为包含所有不**比 g(n) 增长更快的数学函数集合。例如， O(n ) 是包含 n +3n 、 3n 、 n 、 log(n) 以及其他无限个当 n → ∞ 时增长速度不超过 f(n)=n 的函数的集合。**

现在，这里是大 O 的正式定义:

f(n)∈ O(g(n)) 当且仅当存在某个正常数 c 和某个非负整数 nₒ 使得 f(n) ≤ cg(n) 对于所有 n ≥ nₒ.

例如，让我们检查一下 3n∈ O(n ) 。取 c=1 并绘制函数 f(n)=3n 和 cg(n)=1n ，我们可以看到两者相交于 nₒ =3:

绘图 f(n)=3n 和 cg(n)=1n 。请注意 n∈ℕ，但为了清晰起见，我将功能域标为ℝ。用 Matplotlib 创建。

看图我们不难看出，对于所有的 n≥3 来说 3n ≤ 1n 。但这还不够，因为我们需要实际上证明这一点。我们可以用数学归纳法来做。事情是这样的:

我们需要一个基础案例 nₒ ，我们知道 f(nₒ) ≤ cg(nₒ) 。但是我们已经有一个了，因为我们知道我们可以使用 nₒ=3。
然后我们假设对于给定的 n≥nₒ ，f(n)≤cg(n) 。在我们的例子中，我们假设对于给定的 n≥3 ，3n ≤ 1n 。
现在我们需要证明，如果 f(n)≤cg(n) ，那么 f(n+1) ≤ cg(n+1) 。在我们的例子中，我们需要证明如果我们上面的假设(2)成立，那么 3(n+1) ≤ (n+1) 也成立。这也可以写成 3n+3 ≤ n + 2n + 1 。但是，由于我们从(2)中已经知道 3n ≤ n ，我们可以从不等式的左边减去 3n ，从右边减去 n ，而不影响它的关系。这就给了我们 3 ≤ 2n+1 。我们知道 n≥3 ，只要(2)成立，这个不等式就永远成立。这就完成了对于所有的 n≥3，以及3n∈O(n)3n≤1n的证明。

注意:对于两个给定的函数 f(n) 和 g(n) ，有一个更方便的方法来检查 f(n)∈ O(g(n)) 。这将在本文中进一步讨论，在我们完成介绍一些其他渐近函数的正式定义之后。

大ω(ω):下界

大ω的定义方式与大 O 类似，只不过它代表的是下界而不是上界。因此，它的形式定义只是颠倒了 f(n) 和 cg(n)之间的关系。换句话说，“≤”变成了“≥”:

f(n)∈ω(g(n))当且仅当存在某个正常数* c 和某个非负整数 nₒ 使得 f(n)≥cg(n) 对于所有 n ≥ nₒ.*

举个例子，考虑n∈ω(2n+n)。为了证明这种说法，你可以试试 c=1/3 和 n=1 ，使用如上所述的归纳法。这是一个图形表示:

绘图 f(n)=n 和 cg(n)=(1/3)(2n +n) 。用 Matplotlib 创建。

大θ(θ):紧界

位θ用于表示函数的紧界。说f(n)∈θ(g(n))是指 f(n) 与 g(n)有恰好 相同的增长顺序。**

基本上，大θ是大 O 和大ω的交集。基于这一事实，这里有两个关于大θ的简单定义:

1)f(n)∈θ(g(n))当且仅当* f(n) ∈ O(g(n)) 和f(n)∈ω(g(n))。*

**2)θ(g(n))= o(g(n))⋂ω(g(n))。

但是，大θ也可以定义为类似于我们如何定义大 O 和大ω，通过将两个定义合并在一起:

f(n)∈θ(g(n))当且仅当存在一些正常数* c ₁ 和 c₂ 和一些非负整数 nₒ 使得 c₁g(n)≤f(n)≤c₂g(n)对于所有 n ≥ nₒ.*

就像我们对大ω做的一样，我们也可以证明n∈θ(2n+n)。为此，考虑 c₁=1/3 、 c₂=1/2 和 nₒ=1 :

绘图c₂g(n)=(1/2)(2n+n)，f(n)=n* ，以及c₁g(n)=(1/3)(2n+n)。用 Matplotlib 创建。*

小ω(ω)和小 O (o):松边界

没错，渐近符号并不总是很大。还有这两个小记法: 小ω(ω)和 小 O (o)。它们没有大的用得多，但是为了完整起见，我喜欢提到它们。

这两种符号用于表示不“紧”的下限或上限。更具体地说， ω(g(n)) 包括所有在ω(g(n))中但不在θ(g(n))中的函数。形式上，ω(g(n))=ω(g(n))–θ(g(n))。同样，O(g(n))= O(g(n))–θ(g(n))。**

比如 n ∈ o(n ) ，但是 n ∉ o(n ) 。

以下是这两个小符号的正式定义:

f(n)∈ o(g(n)) 当且仅当存在一个非负整数 nₒ 使得 f(n)≤cg(n) 对于所有 n ≥ nₒ 和对于任何一个正常数 c**

f(n)∈ ω(g(n)) 当且仅当存在一个非负整数 nₒ 使得 f(n)≥cg(n) 对于所有 n ≥ nₒ 和对于 任何 正常数c****

你看出区别了吗？虽然对于大ω和大 O 来说， c 的单个值就足够了，但是小ω和小 O 要求属性对于c的任何值都有效。**

使用极限比较两个函数

在上面的例子中，我已经展示了如何使用数学归纳法来证明对于任意两个函数 f(n) 和 g(n)】，是否f(n)∈O(g(n)】。但是有一个更方便的方法来系统地建立两个函数之间的比较，当涉及到它们的增长顺序时。****

为此，你需要计算当 n → ∞时的极限 L = lim(f(n)/g(n)) 。如果存在这样一个极限，当比较 f(n) 和 g(n) 时，它的值马上告诉你哪个渐近符号是有效的:

如果 L=0 ，那么 f(n)∈ O(g(n)) 和 f(n)∈ o(g(n)) 。
如果 L → ∞ ，那么f(n)∈ω(g(n))和 f(n)∈ ω (g(n)) 。**
对于 L 的其他常数值，则f(n)∈θ(g(n))。**

作为例子，再考虑一下 f(n)=n 和 g(n)=2n +n. 对于这些函数，你会发现 L=1/2，也就是说n∈θ(2n+n)。(但是注意，根据定义，它也意味着n∈ω(2n+n)和 n ∈ O(2n +n)。)****

最后的想法

为了使用像大 O 这样的渐近符号，你并不需要对它们背后的数学有深入的理解。然而，知道它们的含义和定义可能是有用的，特别是当两个函数之间的关系不是很明显的时候。θ(log(n))比θ(√n)快吗？ O(2ⁿ) 和 O(3ⁿ) 一样吗？ω(log₂(n))**ω(ln(n))呢？现在你知道了这些符号是如何被数学定义的，你可以试着自己去寻找这类问题的答案。****

参考

Anany Levitin 的设计介绍&算法分析。

披露:这篇文章包含一个或多个亚马逊服务有限责任公司协会项目的链接。作为代销商，我从通过这些链接购买的商品中获得佣金，客户无需支付额外费用。

**** [## “大 O”的真正含义是什么

大多数时候，大 O 符号的用法都有点不正确。

levelup.gitconnected.com](https://levelup.gitconnected.com/what-big-o-really-means-e5f15044c9d2) [## C/C++中测量执行时间的 8 种方法

不幸的是，没有放之四海而皆准的解决方案。在这里你会找到一些可用的选项。

levelup.gitconnected.com](https://levelup.gitconnected.com/8-ways-to-measure-execution-time-in-c-c-48634458d0f9) [## 通过 Python 示例理解时间复杂性

如今，面对我们每天消耗和生成的所有这些数据，算法必须足够好才能处理…

towardsdatascience.com](/understanding-time-complexity-with-python-examples-2bda6e8158a7)****

Deepfakes 背后的数学

原文：https://towardsdatascience.com/the-math-behind-deepfakes-b9ef8621541f?source=collection_archive---------22-----------------------

由 Unsplash 上的 Pietro Jeng 拍摄

入门指南

GANs 概述

虽然许多人都熟悉 deepfakes 产生的令人难以置信的结果，但大多数人都很难理解 deepfakes 实际上是如何工作的。希望这篇文章能揭开创造一个 deepfake 的一些数学秘密。

Deepfake 通常指的是一个人(通常是公众人物)的面部和/或声音被人工智能软件处理过的视频，这种处理方式使修改后的视频看起来真实可信。
—Dictionary.com

事实证明，deepfake 是一个笼统的术语，没有明确的创建方式。然而，大多数 deepfakes 都是用一个深度学习框架创建的，该框架被称为生成式对抗网络，或 GANs，因此这将是本文的主要焦点。

什么是甘？

生成对抗网络——简称 GANs 是一种深度学习模型，由 Ian Goodfellow 和他的同事在 2014 年的一篇论文中首次提出。该模型通过在对抗游戏中同时训练两个神经网络来运行。

抽象地说，我们会有生成模型 G ，即试图学习复制数据集分布 p_data 的分布 p_g ，而判别模型 D 试图确定一段数据是来自数据集还是来自生成器。虽然第一次看到这一点可能会感到害怕，但当看到一个例子时，这个数学变得相对简单。

传统上，GANs 是用制造假币的类比来解释的。为了建立这种情况，有一个伪造者组织试图制造假币，而警方则试图检测货币是否是伪造的。在这里，我们的伪造者可以被视为生产假币的生成模型 G 与分布 p_g 。分布本质上是描述货币特征的特征“地图”。基本上，伪造者生产的货币具有分布 p_g 所描述的一些特征。此外，警察的角色是鉴别真假货币，所以他们扮演鉴别模型的角色。在实际中，这些模型往往是多层感知器，但在只讨论理论时不需要指定神经网络的类型。

这是我们示例场景的设置

最初，伪造者生产的货币可能有许多缺陷，因此警察可以很容易地检测到货币是由伪造者生产的；换句话说，警察知道钱什么时候来自分配 p_g 。随着时间的推移，警察和伪造者都变得更加精通他们的工作。对于伪造者来说，这意味着他们生产的货币将更像真钱；从数学上讲，当假币的分布 p_g 接近真币的分布 p_data 时，就会出现这种情况。另一方面，警方在检测金钱是否来自 p_data 或 p_g 方面变得更加准确。然而，伪造者最终会达到一个地步，即假币可以冒充真币，骗过警察。当分布 p_g 和 p_data 相同时会出现这种情况；简单地说，假币的特征与真币的特征相匹配。事实证明，这种“距离”的度量可以用多种方法计算，每种方法的工作方式略有不同。有了这些知识，我们可以为造假者设定一个目标:学习分布 p_g ，使其等于数据 p_data 的分布。同样，我们给警察定了一个目标:最大限度地提高检测假币的准确率。

对于这个例子来说，这是一个稍微正式的设置

到目前为止，我们在很大程度上忽略了这些模型如何实际操作的细节，所以我们将从描述发电机 G 开始。回到上一个伪造货币的例子，我们的生成器需要接收一些输入，指定正在创建的货币类型。这意味着对应于创建一美元钞票的输入将不同于对应于创建十美元钞票的输入。为了一致性，我们将使用来自分布 p_z 的变量 z 来定义这个输入。分布图 p_z 给出了哪种货币可以被伪造的大致概念。此外，发电机的输出表示为 G ( z )，可以用分布 p_g 来描述。把我们的焦点转移到鉴别器上，我们从检查它所扮演的角色开始。也就是说，我们的鉴别器应该告诉我们一些数据是来自我们的数据集还是来自生成器。原来概率完全适合这个！具体来说，当我们的鉴别器接受一些输入 x ， D ( x )应该返回一个介于 0 和 1 之间的数字，表示 x 来自数据集的概率。为了了解为什么我们的鉴别器允许返回 0 到 1 之间的值，我们将检查我们的输入与数据集中的内容有些相似的情况。回到我们之前的例子，假设我们有一张一角有小划痕的美元和另一张印有普京头像的美元。毫无疑问，第二张钞票比第一张可疑得多，所以很容易被归类为假钞(discriminator 返回 0)。然而，我们的第一张钞票仍然有可能是真的，将它归类为 0 意味着它看起来和第二张钞票一样糟糕。显然，我们丢失了一些关于第一张钞票的信息，最好用 0.5 这样的数字对它进行分类，因为我们的鉴别者对它是真的有些怀疑，但不能确定它是假的。简而言之，我们的鉴别器返回一个数字，表示输入来自数据集的置信度。

推导误差函数

现在我们已经大致了解了我们的模型 G 和 D 应该做什么，我们仍然需要一种方法来评估它们的性能；这就是误差函数发挥作用的地方。基本上，误差函数 E 告诉我们，给定当前的一组参数，我们的模型表现有多差。例如，假设我们有一个被训练来识别各种物体的模型。如果我们向模型展示一辆自行车，而模型看到一辆三轮车，那么误差函数将返回一个相对较小的误差，因为这两者非常相似。然而，如果模型将自行车视为卡车或学校建筑，误差函数将返回更大的数字，因为它们之间几乎没有相似性。换句话说，如果我们的模型的预测与实际数据非常匹配，误差就很小，而当预测与实际数据完全不匹配时，误差就很大。

有了这些知识，我们开始设计误差函数应该具有的一些特性。首先，当我们的鉴别器对数据进行错误分类时，错误函数应该返回一个大的数字，而当数据被正确分类时，返回一个小的数字。为了理解这意味着什么，我们从定义分类开始。本质上，一个分类是一个数据的标签。例如，红知更鸟将被归入鸟类，而金枪鱼将被归入鱼类。在我们的例子中，鉴别器的输入可以来自两个地方，数据集或生成器。为了方便起见，我们将在后面看到，我们对来自生成器的数据进行分类，给它一个标签 0，而来自数据集的数据将被赋予标签 1。利用这一点，我们可以进一步阐述我们的误差函数。例如，假设我们有一些数据， x ，标签为 1。如果我们的鉴别器预测 x 来自数据集( D ( x )返回一个接近 1 的数字)，那么我们的鉴别器将会正确预测 x 的分类，并且误差将会很低。然而，如果我们的鉴别器预测 x 来自生成器( D ( x )返回一个接近于 0 的数字)，那么我们的鉴别器将会错误地对我们的数据进行分类，并且错误将会很高。

这代表了我们的误差函数应该如何表现

当我们寻找一个理想的函数时，我们注意到区间[0，1]上的图 y = log( x )经过一些处理后与我们的规范相匹配。

y = log(x)

特别是，围绕 x 轴翻转图形会产生误差函数，其中我们的标签为 1。通过线 y =0.5 反映这个新图形，然后揭示当我们的标签是 0 时的误差函数。这些的方程式分别是 y = -log( x )和 y = -log(1- x )，如下图所示。

左侧标签= 0 右侧标签= 1 时的误差函数

将这两个函数放在一起，我们可以创建下面的“分段”函数。

我们可以在 label = 0 时代入 x = D(G(z)) ，在 label = 1 时代入 x = D(x) 。当 label = 0 时，我们正在评估我们的鉴别器在从生成器获取图像作为输入时的误差。当 label = 1 时，当我们的鉴别器从我们的数据集中取一些东西作为输入时，我们就找到了它的误差。

遗憾的是，这个公式写出来有点繁琐，所以想找个办法精简到一行。我们首先给我们的误差函数一个合适的名字，比如 E 。此外，我们还想创建一个变量来表示我们的标签，因为写出标签是低效的；我们将这个新变量称为 y 。这就是一点点天才发挥作用的地方。当我们不仅将 y 视为一个标签，还将其视为一个数字时，我们实际上可以将此公式简化为:

注意，当 y = 0(标号为 0)时，(1 - y )系数变为 1，而项y(log(D(x))变为 0。当 y = 1(标签为 1)时，类似的事情发生。第一项减少到 0，剩下-log( D ( x ))。事实证明，这些结果正好等于我们的“分段式”函数。另外，这个误差函数也被称为二元交叉熵。

需要注意的一点是，介绍 GANs 的论文使用了误差函数- E 。因此，为了与原论文保持一致，我们将误差函数重新定义为- E 。

这是经过细微调整后的误差函数，以更好地代表伊恩·古德费勒论文中最初提出的内容

公式中的这一变化意味着不正确的预测(即— y = 0，但 D 输出 1)将导致误差为-∞，而不是∞。

应用误差函数

为 GAN 推导出合适的误差函数后，下一个合理的步骤是将其应用于当前设置。

这个过程的第一步是为我们的模型设定一些目标。本质上，我们的鉴别器， D，应该旨在正确地对其所有输入进行分类，而生成器， G 应该试图欺骗鉴别器，使其对尽可能多的数据进行错误分类。记住这两个目标，我们现在开始分析我们的误差函数的行为。很容易看出，误差函数达到最大值 0，这仅发生在鉴别器以 100%的置信度对所有事物进行完美分类时(使用我们的误差函数的定义，这一点尤其容易看出)。此外，我们的误差函数在-∞处达到最小值，这仅发生在鉴别器对其预测 100%有把握时，但总是错误的(如果 D ( x )为 0 但 y = 1，这可能发生)。

结合这两种见解，我们能够用数学公式表示两个模型 G 和 D 之间的竞争。也就是说， G 试图最小化我们的误差函数( G 希望误差为-∞)，而 D 试图最大化它( D 希望误差为 0)。这种对抗性竞争也被称为迷你最大 游戏，其中模特 G 和 D 像玩家一样相互竞争。因此，我们发现调用 E a 值函数， V ( G ， D )，其中 G 的目标是最小化 V ( G ， D )的值，而 D 的目标是最大化这可以用下面的表达式来描述:

不幸的是，这个表达式还不完整；你看怎么改进？

然而，上面的公式有一个致命的缺陷:它一次只接受一个输入。为了提高这个函数的效用，最好让它计算所有数据的误差(包括数据集和生成器生成的所有数据)。在这种情况下，找到模型在整个数据集上的总误差变得更加有用。事实上，我们只需将每个输入的误差相加，就可以得到总误差。为了了解这将把我们引向何处，我们现在必须检查鉴别器的输入来自数据集的情况，以及输入来自生成器的情况。

当鉴别器的输入来自数据集时， y 将等于 1。这意味着数据的单个实例的值函数变成了 log( D ( x ))。因此，如果我们要找出数据集中每条数据的误差，这些数据条目的总误差将是数据中条目的数量乘以数据集中单个条目的误差。当然，这是假设数据集中每个条目的误差大致相同。此外，我们可以使用𝔼_(x∑p _ data)从数学上描述数据集中的数据条目数，其中𝔼代表期望值。本质上，该表达式返回分布 p_data 中条目的预期数量，该分布描述了我们的数据集。

类似地，当鉴别器的输入来自发生器时， y 将等于 0，因此值函数简化为 log(1-D(G(z))。因此，查找生成器生成的所有项目的总误差等于生成器生成的项目数乘以生成器生成的单个项目的误差(假设每个项目的误差大致相同)。我们再一次用𝔼_( z ∈ p_z 来表示生成器生产的物品数量。我们使用 z 代替的原因是，当鉴别器的输入来自发生器时，我们试图发现错误，发生器产生的项目由输入 z 定义。本质上，𝔼_( z ∈ p_z )让我们很好地了解了生成器生成的项目数量。

将我们最后的两个观点放在一起，我们可以得到一个合适的价值函数:

这也是 Goodfellow 原始论文中出现的价值函数

训练 GAN

回想一下我们培训的最终目标:生成器必须能够欺骗鉴别器。这意味着发生器的输出分布 p_g 必须等于数据集的分布 p_data 。然而，我们可能不希望 p_g 恰好等于 p_data 。要了解这是为什么，请考虑数据集中存在异常值的情况。如果我们训练我们的生成器产生具有精确分布 p_data 的输出，由于这些异常值，我们的生成器将不可避免地产生一些错误的输出。这就是为什么我们希望我们的分布大致相等。

这是我们训练的最终目标

分布之间的距离

现在我们知道我们在训练过程中的目标是什么，我们仍然缺乏一种方法来严格定义两个分布相互近似意味着什么。这是数学提出了分布之间距离的概念。本质上，分布之间的距离给了我们两个分布之间相似程度的度量。下图很容易看出这一点。

事实证明，根据我们的距离函数是如何定义的，训练的结果会有所不同。这将在后续阅读中涉及。

勾画算法

有了对距离的粗略了解，我们现在有足够的知识来构建训练这些模型的算法框架(事实证明，不同的定义距离的方式会导致不同的结果，这在后续阅读中可以看到)。在其核心，我们的训练算法将依赖于随机梯度下降来更新模型参数(梯度下降将不在本文中讨论，因为有许多其他资源涉及该主题)。然而，训练 GAN 是独特的，因为算法必须在模型 G 和 D 之间交替。这是因为如果所有的焦点都放在训练鉴别器上， D 就会变得太善于阻止我们的生成器学习。此外，如果我们只专注于训练生成器， D 将无法正确学习，并且还会向生成器提供无用的反馈。因此，我们的算法将继续重复以下循环，直到达到我们的最终目标:

更新鉴别器的参数 k 次( k 为任意常数)
更新一次发电机的参数

不幸的是，在我们训练的初期，我们的价值函数的梯度可能无法提供足够大的梯度；这使得 G 无法有效学习。请注意，对 G 的更改仅影响术语 log(1-D(G(z))，因此这成为 G 想要最小化的内容。把这个画出来，我们看到最小化这个表达式等于最大化表达式 log(D(G(z))。以这种方式训练我们的模型更有效，因为它在学习的早期阶段提供的梯度更大。

最终，这种训练方法保证收敛于最佳鉴别器，表示为 D *。这个最佳鉴别器存在的证据将在进一步的阅读中显示。

进一步阅读

距离

虽然距离很容易观察到，但如果我们要将距离纳入我们的训练过程，我们需要一个具体的公式。因此，我们必须找到一个合适的距离函数。

我们从 Kullback-Leibler 散度和 T2 Jensen-Shannon 散度开始我们的研究，这也是 Goodfellow 和他的同事们开始研究的地方。

库尔贝克-莱布勒散度(KL 散度)

这篇文章的目的仅仅是对 KL 散度的作用有一个大概的了解。首先，需要注意的是 KL 散度不是一个距离度量，因为它是不对称的，并且不满足三角形不等式。这意味着，给定两个概率分布 P 和 Q ，从 P 到 Q 的 KL 散度不同于从 Q 到 P 的 KL 散度。下面，我们看到的数学公式给出了从分布 P 到 Q 的 KL 散度。

这些是计算分布之间 KL 散度的数学公式

注意计算 KL 散度有两种方法。当 P 和 Q 为离散分布时，使用第一种方式。当 P 和 Q 为连续分布，而 p ( x )和 q ( x )分别为 P 和 Q 的概率密度时，使用第二个公式。有了这些基本定义，我们可以进一步将 KL 发散“分类”为两类:正向 KL 发散和反向 KL 发散。对于两种分布 P 和 Q ，前进 KL 定义为 KL(P|Q)，而后退 KL 定义为 KL(Q|P)。

因此，当我们在训练 GAN 时试图最小化 p_g 和 p_data 之间的距离时，我们实质上是最小化分布之间的 KL 散度；数学上，这表示为 min(KL( p_g||p_data ))。

现在，我们可以开始分析当我们使用正向和反向 KL 来训练我们的 GAN 时会发生什么。当使用前向 KL 时，我们的目标是最小化 KL( p_data||p_g )，因此分布 p_g 将基本上在 p_data 上展开，以便最小化 KL 发散。如下图所示，其中 p_g 标为红色，而 p_data 标为蓝色。

使用前向 KL 训练 GAN

当 p_g 如左图所示被初始化时，我们知道沿着曲线有某些地方 p_g 接近 0 而 p_data 不接近 0。将这些代入我们的前向 KL 散度公式，我们看到 log(p _ data(x)/p _ g(x))将趋近于无穷大。为了防止这种情况发生， p_g 基本上被拉伸，使得前向 KL 发散不再爆发。这被称为寻求均值或零规避行为。

应用反向 KL，我们的目标变成最小化 KL( p_g||p_data )。这里，如果分布 p_data ，则 p_g 将最终覆盖单个模式。这可以从下面看出来:

使用反向 KL 训练 GAN

为了最小化反向 KL 发散，我们想要最大化求和中趋向于 0 的项数。这意味着我们希望 p_g 有很多点，其中 p_g 接近于 0，而 p_data 不是(像这样的地方 KL 散度为 0——这可以通过将数字代入我们的公式来验证)。此外， p_g 所在的模式也将具有接近 0 的 KL 散度。这是因为表达式 log( p_g / p_data )将在 log(1)附近求值，从而减少到 0。这种“收缩”行为被称为模式搜索行为。

不幸的是，当我们看到有两个不重叠的离散分布的情况时，KL 散度将扩大到无穷大。这是不希望的，并且会导致训练中的问题。这就是詹森-香农分歧发挥作用的地方。

詹森-香农分歧(JSD)

詹森-香农发散或 JSD 是测量距离的另一种方法。它使用 KL 散度的元素，但可以处理分布不重叠的情况。计算 JSD 的公式如下所示:

从分布 P 到 Q 计算 JSD 的公式

事实证明，当我们的分布不重叠时，JSD 实际上收敛于 log(2)。这意味着我们现在有一种方法可以有效地测量分布之间的距离，而不必担心散度趋于无穷大；因此，JSD 优于 KL 散度。

这个视频对吉隆坡大分流和 JSD 进行了更深入的研究

这结束了对距离函数以及它们如何被用于训练 GANs 的介绍性一瞥。然而，即使是 JSD 也不是没有缺点。因此，研究人员可能会选择使用 GAN 的变体，如 Wasserstein GAN (这使用 Wasserstein 距离)或 Info GAN 。

最佳鉴别器存在的证明

一旦我们的算法被勾勒出来，我们仍然需要证明它完成了它设定的目标。也就是说，我们想要证明我们的算法产生了最佳鉴别器，表示为 D *。

我先提出一个命题:当 G 固定时，最佳鉴别器 D 由下式给出。

这是给定发生器 G 的最佳鉴别器

证明:生成器的目标是最大化价值函数 V ( G ， D )。请注意，数据集的期望值可以写成数据分布的积分；类似的规则也适用于发电机。这给我们留下了:

用积分写出的值函数

从这里，我们可以进行“变量的改变”也就是说，我们将 G ( z )替换为 x ，并将我们的分布从 p_z 更改为 p_g 。这实质上是根据 G 产生的输出重写了第二项。

简化价值函数

现在，最大化 V 变成了最大化被积函数的问题。从基本微积分中，我们知道表达式a⋅log(x)+b⋅log(1-x的最大值将在( a )/( a+b )的区间[0，1]上达到最大值。将这个代入我们的值函数，我们得到最大化被积函数的鉴别器将是我们上面提出的。我们的证明到此结束。

结论

总之，这篇文章旨在涵盖创建 deepfakes 的数学方法，尤其是 GANs。这篇对 GANs 的介绍性研究将为你提供足够的信息，让你对如何使用人工智能创建 deepfake 有一个大致的了解。除了标题中的图片，所有的图片都是作者创作的，方程式都是在 TexStudio 中用 LaTex 渲染的。如果你有任何问题或者只是想谈谈，请随时通过felix.liu.2005@gmail.com联系我。

参考

[1]https://arxiv.org/pdf/1406.2661.pdf

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

[3]https://github . com/siddrrsh/StartOnAI/blob/master/auto encoders _ _ Meta _ Learning _ _ GANs _ _ wasser stein _ GANs _。pdf

梯度下降和反向传播背后的数学原理

原文：https://towardsdatascience.com/the-math-behind-gradient-descent-and-backpropagation-code-example-in-java-using-deeplearning4j-f7340f137ca5?source=collection_archive---------16-----------------------

入门

使用 Deeplearning4J 的 Java 代码示例

本文介绍了两种算法:梯度下降法和反向传播法。我给出了它们如何工作的直觉，也给出了它们背后的数学原理的详细介绍。在本文的最后，我用 Deeplearning4J 给出了这个算法的 Java 实现。然而，它的目的不是介绍 Deeplearning4J 框架，而是实现文章中提出的所有概念。读完这篇文章后，你应该对这两种算法的工作原理和工作方式有一个清晰的理解，并且能够自己实现它们。

作者图片

梯度下降

通常情况下，我们希望最小化一个函数，比如说 C。一种方法是计算导数，并尝试找到 C 的极值点。如果 C 的变量数量很少，这是一种可行的解决方案，但如果 C 的变量数量很多，就像机器学习算法经常遇到的情况一样，这就不再是一种实用的解决方案，我们需要另一种方法。

让我们假设我们的函数如图 1 所示，一个随机点被选为红点。我们的目标是达到该函数的最小值或底部。那么，从我们最初的位置，我们应该去哪个方向才能到达谷底？直觉上，方向是指向最陡下方的方向。如果我们往那个方向走一点点，然后环顾四周，再次找到最陡的方向，再往那个方向走一点点，重复这个过程很多次，我们最终会到达谷底。但是怎么才能找到最陡下降的方向呢？

图 1: f(x，y)=x +y(图片由作者提供)

方向导数

为了找到我们想要的方向，方向导数的概念将是有帮助的。让我们假设我们的函数 C 有两个变量 x 和 y ，我们想知道 C 在方向上移动时的瞬时变化率

C 沿 x 轴的瞬时变化率为

C 关于 x 的偏导数

对于 y 也是一样，向量 v 可以认为是 x 方向的 v₁单位和 y 方向的 v₂单位。因此，C 沿矢量 v 方向的方向导数为

或者更简洁地说:

C 在 v 方向上的方向导数

在哪里

然而，这不是 C 在 v 方向上的斜率。为了得到斜率，向量 v 的范数必须为 1，因为 v 可以按比例放大，这将反映在等式(1)的值中。

让我们回到我们最初的问题:如果我们在点 w=(a，b)，向量 v 是什么使它指向最陡下降方向？当向 v 方向移动时，C 的瞬时变化率必须是负的，绝对值最大，这是最陡的下降。所以，问题归结为找到:

我们有两个向量∇ C(a，b)和 v 之间的点积，这是通过将向量 v 在∇ C(a，b)上的投影长度乘以∇ C(a，b)的长度来计算的(如果投影指向∇c(a b 的相反方向，则它的长度为负值)。那么，向量 v 应该是多少才能使乘积最小呢？如果你向各个方向摆动 v，很容易看出，当 v 指向与∇C(a 相同的方向时，v 的投影最大，而当 v 指向与∇C(a, b).相反的方向时，乘积最小所以，最陡下降的方向与∇C(a 的方向相反。这就是我们要找的矢量 v！

图 2 最陡下降方向(图片由作者提供)

为了接近最小值，剩下要做的就是更新我们的位置直到收敛，如下所示:

其中 η 称为学习率。这就是梯度下降算法。这不仅适用于两个变量的函数，也适用于任意数量的变量。为了使梯度下降正确工作，必须仔细选择η。如果η太大，更新 w 时我们采取的步骤将会很大，我们可能会“错过”最小值。另一方面，如果η太小，梯度下降算法将运行缓慢。梯度下降算法的一个局限性是它容易陷入局部极小值，但许多机器学习成本函数是凸的，不存在局部极小值。

批量梯度下降

在机器学习中，使用成本函数来测量模型的准确性。其中一个函数是均方误差或 MSE :

在此等式中，w 和 b 表示模型中所有权重和偏差的集合，m 是训练观测值的数量，ŷ(x 是模型输出的值，y(x)是 x 的真实预测值。c 是平方项的和，我们希望最小化其值，即 C(w，b) ≈ 0。

为了最小化 C(w，b)的值，我们可以应用梯度下降算法。为此，我们可以从 w 和 b 的一些初始值开始，然后重复更新它们，直到它有希望收敛到最小化 C(w，b)的值，如上面等式(3)中所述。然而，这种方法有一个缺点。在每次迭代中，我们必须计算梯度∇C.，但是为了计算∇C，我们必须计算每个训练样本的梯度∇Cₓ，然后对它们进行平均。当有大量训练观测值时，算法可能会很慢。为了加快速度，可以使用另一种叫做随机梯度下降的方法。

随机梯度下降

随机梯度下降的思想是一次仅使用一个训练观察来更新参数值。它的工作原理如下:

随机“洗牌”数据集
对于 i =1…m
(w，b) ← (w，b)——η∇c x(I)(w，b)其中(w，b)是包含所有权重和偏差值的向量

此算法不会扫描所有的训练观察值来更新模型参数，但它会尝试一次适合一个训练示例。随机梯度下降可能不会收敛到全局最小值，但它可以足够接近，是一个很好的近似。

另一种方法是不使用一个训练示例(如在随机梯度下降中)或所有训练示例(如在批量梯度下降中)，而是使用一些中间数量的观察值。这叫做 小批量梯度下降 。

假设我们随机选择了 k 个训练样本，x，x … xᵏ.这是小批量的。有了足够大的小批量，小批量中梯度的平均值将接近整组训练样本的平均值，即:

该算法的工作原理是随机选取一个小批量，并使用它们更新参数:

重复这一过程，直到使用了所有的训练样本，从而完成了一个时期的训练。之后，我们可以按照相同的程序开始新的训练周期。

神经网络

分类问题的一种常见方法是使用 sigmoid 函数。

它具有每个输入的权重和总体偏差 b。此函数的一个非常好的特性是σ(wᵗ x + b)取值于区间(0，1)内，因此当其输出大于 0.5 时，我们可以将输入分类为属于类 1 或类 0。

图 3 Sigmoid 函数(图片由作者提供)

然而，如果我们想要使用包括所有二次项的三个特征，我们必须计算

它有六个特点。在这里，我们采用所有两个元素的特征组合。更一般地，为了计算多项式项数，我们可以使用重复的组合函数:

所以，如果我们的输入是一张 100x100 像素的黑白图片，那么特征大小最终将是(100+2–1)！/2!(100–1)=5050.显然，这是不切实际的，我们需要另一种方法。

当创建具有许多特征的复杂模型时，神经网络是另一种选择。神经网络的体系结构如下所示:

图 4 神经网络(图片作者提供)

神经网络有许多层，每层有一群神经元。第一层称为 输入层 ，该层内的神经元称为输入神经元。最后一层称为 输出层 和神经元输出神经元。中间的图层称为 隐藏图层 。一层的输出被用作下一层的输入。这些网络被称为 前馈神经网络 。

乙状结肠神经元的工作方式如下。神经元的每个输入 x1、x2 …xn 具有相应的权重 w1、w2 …wn。神经元也有一个总偏差 b。神经元的输出是σ(w T x + b ),这是神经元的激活。该输出值将作为下一层的输入。

权重被表示为 wˡⱼₖ ，意味着从层 (l-1) 中的 kᵗʰ 神经元到层 l 中的 jᵗʰ 神经元的权重。b ˡⱼ 是 jᵗʰ 神经元在 lᵗʰ 层的偏置。激活 lᵗʰ 层中的 jᵗʰ 神经元是一个 ˡⱼ 。对于对应于最后一层的值，使用上标 L。

例如，在对图片进行分类的问题中，输入层可以由灰度值在 0.0 和 1.0 之间的所有像素组成。如图 4 所示，为了计算第 2 层中最后一个神经元的激活值，我们计算:

我们如何训练一个神经网络？我们可以使用梯度下降来最小化成本函数。但是为了执行梯度下降，我们必须计算∂C/∂w 和∂C/∂b.。接下来，给出了计算这些偏导数的算法。

反向传播

反向传播是用于计算成本函数梯度的算法，即偏导数∂C/∂ wˡⱼₖ和 ∂C/∂b ˡⱼ.为了定义成本函数，我们可以使用等式(4):

其中第二项是输入 x 的激活值向量，我们知道

其中总和超过了(1)ᵗʰ层中的 k 个神经元。

我们可以定义一个权重矩阵 Wˡ，它们是连接到 lᵗʰ 层的权重，而权重 Wˡⱼₖ 对应于 wˡ中具有行 j 和列 k 的条目。类似地，我们可以定义一个包含层 l 中所有偏差的偏差向量 bˡ，以及激活向量:

计算中间值也很有用

或者以矢量化的形式

很明显，

我们还将 l 层神经元 j 的误差定义为δ ˡⱼ 。我们从梯度下降算法中知道，当偏导数为 0 或接近 0 时，我们接近最小值，否则斜率越陡，我们就越不正确。考虑到这一点，我们可以定义

有了所有这些工具，我们可以将输出层中的误差定义如下:

在哪里

如果我们使用等式(9)中定义的二次函数作为一个例子，那么

我们可以将∇ₐC 定义为包含 c 相对于最后一层中的每个激活的偏导数的向量，然后我们可以写出(16)的矢量化形式:

现在让我们尝试计算任何神经元的误差。特别

但是

因此，我们有

代入等式(18 ),我们得到:

或者矢量化的形式:

因此，使用这个公式，如果我们知道层 l 的δ，我们可以计算 l-1，l-2 等的δ。那就是我们反向传播的错误，因此算法的名字。我们已经在等式(17)中看到了如何计算δ L。

现在让我们试着计算∂C/∂b ˡⱼ

第二个等式由等式(15)和等式(12)得出。等式(23)表明:

这是个好消息，因为我们已经看到了如何计算任意 l 的δ ˡⱼ

等式(23)和(24)示出了如何计算成本函数的梯度。

交叉熵

在上一节中，我描述了使用二次成本函数(9)的反向传播算法。用于分类问题的另一个成本函数是 交叉熵 函数。

让我们把这个函数分解成几个部分，看看它为什么有意义。如果 y=1，则第二项抵消，ln 和 a 剩余。如果我们看这个函数的图形，我们看到当 a 接近 1 时，函数的值接近 0，当 a 越接近 0 时，函数趋于无穷大。也就是说，a 越接近 y 的真实值，成本就越小。类似地，对于 y=0。剩下的一项是 ln(1 a)。当 a 接近 1 时，函数值接近无穷大，a 越接近 0，函数值越接近 0。交叉熵函数中 j 上的和意味着输出层中所有神经元上的和。

作者图片

在实践中，交叉熵成本似乎是最常用的，而不是二次成本函数。我们一会儿就会明白为什么会这样。我们前面介绍过反向传播算法。对于这个新功能，它有什么变化？等式(16)为我们提供了一种计算输出层误差的方法，我们还看到了二次成本函数的情况。现在让我们计算交叉熵函数。

似乎与二次函数的唯一区别是，我们去掉了等式(16)中的第二项，即 sigma 质数。这有多重要？如果我们观察图 3，我们可以注意到，当 sigmoid 函数接近 0 或 1 时，图形变平，因此σ'(x)非常接近 0。例如，如果输出层神经元将输出非常接近 0 的值，则σ’将接近 0。但是如果真值是 1，δ的值接近 0 将使得相应权重的偏导数非常小，因此学习将非常慢，并且将需要多次迭代。但是当使用交叉熵函数时，σ'项消失了，学习可以更快。计算相对于权重和偏差的偏导数的方式与上一节中描述的方式相同，唯一的区别是计算等式(26)的方式。

正规化

正则化是克服过度拟合的一种方法。实现正则化的技巧有很多，但这里我只描述【L2】。L2 正则化的思想是通过增加正则化项来惩罚大的权值。然后，正则化的交叉熵变成:

正则化参数是α。正则化项中不包括偏差，因此偏差的偏导数不变，梯度下降更新规则也不变:

权重的更新规则变为:

你可以注意到，第一项缩小了权重。这也叫做重量衰减。

代码示例

使用上述概念，我们将尝试使用 MNIST 手写数字数据库来识别手写数字。

完整的代码可以在这里找到。

首先，指定层大小来构建网络

*/**
 * The constructor takes as input and array of integers
 * representing the number of nodes in each layer
 * */* public Network(int[] layerSizes) {
    this.layerSizes = Arrays.*copyOf*(layerSizes, layerSizes.length);
    this.layers = layerSizes.length;

    //initialise biases
    for (int i = 1; i<layerSizes.length; i++) {
        biases.add(Nd4j.*randn*(layerSizes[i], 1));
    }

    //initialise weights
    for (int i = 1; i<layerSizes.length; i++) {
        weights.add(Nd4j.*randn*(layerSizes[i], layerSizes[i-1]));
    }
}

为了训练网络，我实现了随机梯度下降算法。

*/**
 * Performs mini-batch gradient descent to train the network. If test data is provided
 * it will print the performance of the network at each epoch
 ** ***@param*** *trainingData data to train the network
 ** ***@param*** *epochs number of epochs used to train the network
 ** ***@param*** *batchSize the size of batch
 ** ***@param*** *eta the learning rate
 ** ***@param*** *testData data to test the network
 * */* public void SGD(DataSet trainingData, int epochs, int batchSize, double eta, DataSet testData) {
    int testSize=0;
    if (testData != null) {
        testSize = testData.numExamples();
    }
    int trainingSize = trainingData.numExamples();
    for (int i=0; i<epochs; i++) {
        trainingData.shuffle();
        for(int j=0; j<trainingSize; j+=batchSize) {
            DataSet miniBatch = trainingData
           .getRange(j,j+batchSize<trainingSize ? j+batchSize :    trainingSize-1);
            this.updateMiniBatch(miniBatch, eta);
        }
        if (testData != null) {
            System.*out*.printf("Epoch %s: %d / %d ", i, this.evaluate(testData), testSize);
            System.*out*.println();
        }
    }
}

*/**
 * Updates the weights un biases of the network using backpropagation for a single mini-batch
 ** ***@param*** *miniBatch the mini batch used to train the network
 ** ***@param*** *eta the learning rate
 * */* public void updateMiniBatch(DataSet miniBatch, double eta) {
    INDArray [] gradientBatchB = new INDArray[layers];
    INDArray [] gradientBatchW = new INDArray[layers];
    for (int i=0; i < this.biases.size(); i++) {
        gradientBatchB[i+1] = Nd4j.*zeros*(this.biases.get(i).shape());
    }
    for (int i=0; i < this.weights.size(); i++) {
        gradientBatchW[i+1] = Nd4j.*zeros*(this.weights.get(i).shape());
    }
    List<INDArray[]> result;
    for(DataSet batch : miniBatch) {
        result = this.backpropagation(batch.getFeatures(), batch.getLabels());
        for(int i=1; i<layers; i++) {
            gradientBatchB[i] = gradientBatchB[i]
.add(result.get(0)[i]);
            gradientBatchW[i] = gradientBatchW[i]
.add(result.get(1)[i]);
        }
    }
    for (int i=0; i<this.biases.size(); i++) {
        INDArray b = this.biases.get(i).sub(gradientBatchB[i+1]
.mul(eta/miniBatch.numExamples()));
        this.biases.set(i, b);
        INDArray w = this.weights.get(i).sub(gradientBatchW[i+1]
.mul(eta/miniBatch.numExamples()));
        this.weights.set(i, w);
    }
}

SGD 方法基本上是从训练集中取批，调用 updateMiniBatch 方法。在这种方法中，调用反向传播方法，它返回为该小批量计算的梯度，偏差和权重数组根据随机梯度下降部分给出的规则进行更新。

反向传播方法如下计算上述方程:

//feedforward
INDArray activation = x;
INDArray [] activations = new INDArray[layers];
INDArray [] zs = new INDArray[layers];
activations[0] = x;
INDArray z;
for (int i=1; i<layers; i++) {
    z = this.weights
.get(i-1).mmul(activation).add(this.biases.get(i-1));
    zs[i] = z;
    activation = sigmoid(z);
    activations[i] = activation;
}

这里计算等式(13)和(14)，然后使用(22)计算δ项。有了 deltas，我们可以用(23)和(24)计算偏导数。代码如下:

//back pass
INDArray sp;
INDArray delta = costDerivative(activations[layers-1], y).mul(sigmoidPrime(zs[layers-1]));
gradientB[layers - 1] = delta;
gradientW[layers - 1] = delta.mul(activations[layers2].transpose());
for (int i=2; i<layers; i++) {
    z = zs[layers-i];
    sp = sigmoidPrime(z);
    delta = (this.weights
.get(layers - i).transpose().mmul(delta)).mul(sp);
    gradientB[layers - i] = delta;
    gradientW[layers - i] = delta
.mmul(activations[layers - i - 1].transpose());
}

在本文中，我们看到了梯度下降和反向传播是如何工作的。我介绍了描述它们的数学概念和这些算法的实现。您可以使用代码并尝试调整参数，看看您的分类有多准确。

机器学习算法背后的数学

原文：https://towardsdatascience.com/the-math-behind-machine-learning-algorithms-9c5e4c87fff?source=collection_archive---------8-----------------------

不同的机器学习算法是如何从数据中学习，并在看不见的数据上进行预测的？

罗马法师在 Unsplash 上拍摄的照片

机器学习算法是以这样一种方式设计的，即它们从经验中学习，并且随着它们获取越来越多的数据，它们的性能会提高。每种算法都有自己学习和预测数据的方式。在本文中，我们将介绍一些机器学习算法的功能以及这些算法中实现的一些数学方程，这些算法有助于学习过程。

机器学习算法的类型

机器学习算法可以大致分为以下四类:

监督学习: 预测的目标或输出变量已知。这些算法生成一个将输入映射到输出变量的函数。回归和分类算法属于这一类。在回归中，输出变量是连续的，而在分类中，输出变量包含两个或多个离散值。一些监督学习算法包括线性回归、逻辑回归、随机森林、支持向量机(SVM)、决策树、朴素贝叶斯、神经网络。
无监督学习: 目标或输出变量未知。这些算法通常分析数据并创建数据聚类。关联、聚类和维数约简算法都属于这一类。K-means 聚类、PCA(主成分分析)、Apriori 算法是一些无监督学习算法。
半监督学习:它是监督和非监督学习方法论的结合。它使用已知数据来训练自己，然后标记未知数据。
强化学习: 机器或代理被训练从‘试错’过程中学习。机器从过去的决策经验中学习，并使用其学习来预测未来决策的结果。强化学习算法的几个例子是 Q 学习、时间差分等。

线性回归

线性回归用于通过拟合数据点上的最佳直线来预测连续变量的结果。最佳拟合线定义了因变量和自变量之间的关系。该算法试图找到预测目标变量值的最佳拟合线。通过最小化数据点和回归线之间的平方差之和，获得最佳拟合线。

线性回归(来源: onlinestatbook

方程式: Y = c + m₁X₁ + m₂X₂ + …..+mnXn

Y →因变量或目标变量

m →斜率

c →截取

X →独立变量

逻辑回归

逻辑回归是一种分类算法，用于根据自变量估计分类变量的结果。它通过将数据拟合到逻辑函数来预测事件发生的概率。通过最大化 似然函数 来优化逻辑函数中独立变量的系数。决策边界被优化，使得成本函数最小。可以通过使用梯度下降来最小化成本函数。

逻辑回归的 sigmoid 曲线

逻辑回归的成本函数

逻辑回归方程

朴素贝叶斯

朴素贝叶斯是一种基于贝叶斯定理的分类算法。该算法假设自变量之间不存在相关性。即一个类别中特定特征的存在与同一类别中另一个特征的存在无关。我们根据类别(目标变量的不同值)为所有预测值创建一个频率表，并计算所有预测值的可能性。使用朴素贝叶斯方程，计算所有类别的后验概率。朴素贝叶斯分类器的结果将是所有类概率中概率最高的类。

c →类，X→预测器

决策树

决策树主要用于分类问题，但也可以用于回归分析。在该算法中，我们根据最有效地划分数据集的属性，将数据集划分为两个或多个同类集合。选择将分割数据集的属性的方法之一是计算熵和信息增益。熵捕捉变量中杂质的数量。信息增益是父节点的熵减去子节点的熵之和。 选择提供最大信息增益的属性进行拆分。我们还可以使用基尼指数作为杂质标准来分割数据集。为了防止过度捕捞，我们优化了决策树的超参数，如 max_features、min_samples_split、max_depth 等。

熵，c →类别数

基尼

随机森林

随机森林由几个决策树组成，这些决策树作为一个整体运行。集合由一组用于预测结果的模型组成，而不是单个模型。在随机森林中，每个决策树预测一个类结果，投票数最多的类结果成为随机森林的预测。 为了准确预测，决策树之间的相关性应该最小。确保这一点的几种方法是通过打包和特征选择。Bagging 是一种从数据集中选择随机观察样本的技术。特征选择允许决策树仅在随机特征子集上建模。这可以防止单个树使用相同的特征进行预测。

随机森林(来源: victorzhou )

k 近邻

该算法也可用于回归和分类。该算法通过计算其与所有数据点的距离来寻找数据点的 k 个最近邻。数据点被分配给 k 个邻居中点数最高的类(投票过程)。在回归的情况下，它计算 k 个最近邻的平均值。可以使用的不同距离度量是欧几里德距离、曼哈顿距离、闵可夫斯基距离等。为了消除平局的可能性，k 的值必须是奇数。这种算法计算量很大，因为每个数据点的距离是用每隔一个数据点来计算的。

距离度量

k-NN(来源:辅导点)

k 均值

K-Means 是一种无监督学习算法，用于形成数据的聚类。形成的聚类应该使得一个聚类内的数据点尽可能相似，并且这些聚类彼此之间尽可能不同。它随机选择 K 个位置，每个位置作为一个聚类的质心。数据点被分配给最近的聚类。在分配数据点之后，计算每个聚类的质心，并且再次将数据点分配给最近的聚类。重复该过程，直到数据点保持在相同的聚类中，或者聚类的质心在每次连续迭代中不变。我们还可以指示算法在执行一定次数的迭代后停止计算。

k-均值聚类(来源:斯坦福

Apriori 算法

Apriori 算法是一种基于关联规则的算法，用于从数据库中识别频繁项集。频繁项集是支持度值大于阈值(支持度)的项集。关联规则可以被认为是一种 IF-THEN 关系。它通常用于购物篮分析，发现不同项目之间的关联。支持、信心和提升是有助于确定关联的三个衡量标准。

支持(A 和 B 是不同的项目)

信心

电梯

支持度指示某些项集一起出现的频率。

置信度计算其中一个项目出现时，该项目集出现的概率。

提升表示关联规则的强度。支持是用户定义的阈值。

XGBoost

XGBoost 是一种基于决策树的梯度推进算法(另一种类型的集成)。XGBoost 涉及一组弱学习器，它们组合起来做出显著的准确预测。 Boosting 是一种顺序集成，其中每个模型都是基于对先前模型错误分类的校正来构建的。换句话说，它接收前一个模型的错误，并试图通过学习这些错误来改进模型。

支持向量机(SVM)

SVM 也是一种监督学习算法，可用于分类和回归问题。SVM 试图在 N 维空间中找到一个最佳超平面(N 指的是特征的数量)，这有助于对不同的类别进行分类。使用 铰链损失 函数，通过最大化类的观测值之间的边缘距离，找到最优超平面。超平面的维度取决于输入特征的数量。如果特征的数量是 N，那么超平面的维数是 N-1。

SVM(来源: alteryx

铰链损失函数:t →目标变量，w→模型参数，x →输入变量(来源:维基百科)

感谢您阅读本文。

薛定谔方程背后的数学:波粒二象性和热方程。

原文：https://towardsdatascience.com/the-math-behind-schrödinger-equation-the-wave-particle-duality-and-the-heat-equation-d5837bf4b13f?source=collection_archive---------7-----------------------

薛定谔方程的历史和半形式推导。

在量子力学中，一个事件的结果没有确定性，就像在经典物理学中一样。这是因为每个事件都有关联的概率，这就是薛定谔方程告诉我们的关于粒子的信息。但是，埃尔温·薛定谔如何解决这个问题呢？理查德·费曼曾经说过:

它不可能从你知道的东西中推导出来，它只是简单地从薛定谔的头脑中出来。

然而，我们会看到它与约瑟夫·傅立叶在 1822 年提出的热方程(扩散方程±傅立叶)有关系，阿尔伯特·爱因斯坦和路易·德布罗意的粒子波假设给了我们一个半形式推导的提示。

图 1:热量方程。来源:作者

1.波粒二象性

1897 年有人提出，当原子吸收光的能量时，会发射出电子，这种现象被称为光电效应。后来，在 1905 年，爱因斯坦通过假设量子或离散能量单位的存在，对此事件做出了解释。

图二。爱因斯坦的提议。来源:作者

图 2 中的关系告诉我们，一个粒子的能量 E 可以取普朗克常数h的倍数，只与波的频率 v 有关。换句话说，爱因斯坦提出波在某些过程中表现得像粒子一样，因为只需要知道它的频率。

在 20 年代初，衍射电子束的可能性仍然是迫切需要的。事实上，可以预期的是，电子在孔径附近(大小与波长相当)的波结构中的扭曲会使其扩散。直到 1924 年路易·德布罗意在让·佩兰和保罗·朗之万的博士论文指导下，给出了一个表达式，明确计算出一个波的波长

图 3。德布罗意的提议。来源:作者

其中 λ 和 p 分别代表质点的长度和动量。现在，我们如何从先前的后置定语中得到图 7 中的等式呢？三个词:能量，空间和时间，具体来说:

图 4。粒子的总能量。来源:作者

能量需求。一个粒子的总能量(动能和势能让我们找到了与波粒二象性的关系。换句话说，我们需要满足一个能量要求，才能模拟粒子的行为。

图 5。关于空间的变化。来源:作者

太空中的行为。k，描述了以空间为单位的波数。此外，相对于空间的变化(如果位置改变，震级如何变化)向我们展示了波的初始状态在空间频率方面如何演变。

图 6。相对于时间的变化。来源:作者

行为及时。ω，描述了以时间为单位的波数。此外，波的初始状态相对于时间的变化(幅度如何随时间变化)导致我们用角频率来表示它。

因此，我们得到了与时间相关的薛定谔方程(图 7)。如果您对技术细节感兴趣，请参阅[4]的第 1 章。

图 7。含时薛定谔方程。来源:作者

2.热量方程

当傅立叶开始研究这个方程时(大约 1802 年)，热学和微分方程理论处于发展的早期阶段。具体地说，已经确立了通过温差和蓄热的热传导。比如 1804 年让·巴普蒂斯特·比奥关于不连续体之间热传导的工作或者 1783 年拉瓦锡和拉普拉斯对热容的测量。

图 8。金属茶壶中的热扩散。史蒂夫·库克通过 pixabay ( 来源)拍摄的照片

离开了 Biot 的观点，Fourier 用连续体(如金属薄片)中的偏微分方程来描述热传导。因此，他可以从三个方面考虑这个问题:

太空中的热传输。
身体各部分的热量储存。
边界条件。

边界条件是允许元素或主体的外部与内部相互作用的条件，在数学上，它们被表示为第二个方程，【x，0】，如下图所示(图 9)。

图 9。具有初值条件的热传导方程。来源:作者

让我们分解上面的问题来理解它:

第一个方程是约瑟夫·傅立叶公式化的，即热量相对于时间的变化(∂ u / ∂ t)等于通过物体的加速度热量(∂ u / ∂ x)乘以某个常数 m 。
第二个方程是热量最初的行为，我指的是最初，因为它建立了数学术语中所谓的 初值条件 ，时间 t = 0 时的行为。

现在，我们可以问自己如何解决这个问题，即热量如何在连续体中通过空间【x】和时间 t 演化？让我们回到图 8，想象茶壶底部是我们的初值条件。然后，要问的几个自然问题是

锅盖还是锅底会更暖和？
热量的减少是如何发生的，是快还是慢？

数学是我们的答案，特别是所谓的热核(图 10)，它是图 9 中问题解决方案背后的核心。

图 10。热核。来源:作者

如果你熟悉正态分布，这个函数可能看起来很容易辨认，因为它们背后的根是高斯函数。现在，如果你上过一次概率课，你会记得大多数值都集中在平均值 μ 附近，衰减可以用方差 σ来解释。 同理，对于热核来说，热的扩散取决于时间 t 和常数 m 。因此，这个函数的衰减向我们解释了热量是如何通过时间和空间扩散的。对于茶壶(图 8)，来自燃烧器的热量在到达壶盖和时间流逝时是如何扩散的。

但是，这个方程能保证边界条件吗？是的，这里有个窍门整合。正如人们在概率课程中所记得的，概率分布必须满足它整合为一。用茶壶的术语来说，人们可以测量茶壶不同的温度。所以，假设热核满足这个性质，我们可以从数学上证明它整合到 f(x)中。 试试看，整合图 11 中的函数，作为提示，你可以检验一下狄拉克δ函数的概念。

图 11。热方程初值问题的求解。来源:作者

最后，我们之前说过热量方程和含时薛定谔方程之间的关系，为了提醒我们，让我们再看一下图 1 和图 7。乍一看，似乎没有任何关系，但如果我们考虑两个方程中的共同项，并通过设置 V(x) = 0 (没有力作用在粒子上)，我们可以将图 7 中的方程重新表述如下。

图 12。自由薛定谔方程。来源:作者

因此， 薛定谔方程是热方程但带有虚数 ，参见虚数的概念。

3.薛定谔方程是什么？

路易·德布罗意的开创性著作出版后，没有人能理解它。事实上，埃尔温·薛定谔一开始就拒绝了他的观点，直到维克多·亨利回复他“你应该再读一遍德布罗意的论文；朗之万认为这是一部非常好的作品”，因此欧文开始发展他的想法。此外，大约在那个时候，彼得·约瑟夫·威廉·德拜和欧文·马德隆试图设计一种原子层次的波动理论。

薛定谔需要两次尝试来为现在所知的非相对论波动力学奠定基础。在第一篇文章中，他试图将德布罗意波推广到氢原子上的电子(束缚粒子)。然而，结果与实际观察不一致，因为他没有考虑电子的自旋。几个月后，在他的第二次尝试中，他注意到通过以非相对论的方式处理电子，他的方法与观察一致。因此，在 1926 年发表他的卓越文章《作为正当值问题的量子化》。

最后， 什么是薛定谔方程？ 它是基于原子或亚原子粒子的当前状态或初始状态(初值条件)，描述原子或亚原子粒子将如何随时间变化的一种表述。

4.更多主题

在薛定谔方程系列文章的第二部分，我们将发展波包的概念作为初值条件和时间无关的情况来研究量子隧穿效应。关于本文中数学发展的技术细节，参见[4]的第 1 章和第 2 章。

参考

[1]罗伯特·艾斯伯格。量子物理学。约翰·威利父子公司，1985 年。

[2]干扰机，最大。量子力学概念的发展。美国物理研究所，1989 年。

[3] Naramsinhan，T.N .傅立叶热传导方程:历史、影响和联系。

[4]米格尔·特雷霍。schredinger 教育数学解释(Tesis)。网址:https://github.com/TremaMiguel/Thesis-Schrodinger-Equation

5 布鲁斯·惠顿。老虎和鲨鱼。剑桥大学出版社，1983 年。

预测模型的统计决策理论

原文：https://towardsdatascience.com/the-math-you-need-to-develop-your-own-predictive-models-fdb771cc1ddf?source=collection_archive---------29-----------------------

沉默的统计学家改变了我们的世界；不是通过发现新的事实或技术发展，而是通过改变我们推理、实验和形成观点的方式。伊恩·哈金

你能从观察值中写出一个预测函数来最小化误差偏差吗？还是平均误差？你能找到能最小化任何给定损失函数的最佳理论预测值吗？

这篇文章将通过快速介绍统计决策理论来回答这些问题。这不是另一个机器学习的线性代数基础教程。我假设读者有一点数学背景。一年级的 Stems 本科生所知道的就足够了。

照片由克里斯·利维拉尼在 Unsplash 拍摄

统计决策理论

我们的模型是根据几个假设定义的:

我们有一个输入向量 X 的 p 随机参数。
我们有一个期望的输出变量 Y 。
目标是找到一个预测函数 f 来预测给定 X 的 Y 。
为了搜索给定标准的最优 f ，我们将根据该标准选择损失函数 Lf 。
根据我们的标准，如果预测与现实相差甚远，我们的损失函数将返回最大值。

由于预测器的质量是由 Lf 的损失函数来测量的，所以最佳预测器 f 仅在 Lf 规定的意义上是最佳的。损失函数的不同选择导致不同的最优解。

一般来说，不可能想出一个在所有可以想到的方面都是最佳的预测器。因此，为了在一组预测因子中进行选择，我们将比较它们损失函数的平均值 E。

最佳预测器的搜索

我们将任何概率分布表示为 ℙ ，期望值表示为 E 。

从贝叶斯定理，

然后通过分解二元积分，

现在可以通过逐点最小化期望误差来求出 f。
设 c ∈ ℝᵖ，

用 L_Id 将损失函数应用于身份函数。通过最小化上述期望，无论是解析地还是数值地，我们可以找到最佳匹配预测器 f 。

案例研究将有助于阐明如何在给定的损失函数上找到 f。

案例研究:均方误差

ML/DL 中最常用的损失函数通常是均方误差:

从上一节来看，

因此，

解是 f(x) = E(Y|X=x)，因为:

我们刚刚证明，当损失函数是均方误差时，Y 在任一点 X=x 的最佳预测值是条件均值:

这个预测值通常被称为线性回归。通过将 f(x)注入多元积分并使关于β的矢量导数等于零，可以求解β。

损失函数的另一种可能选择是偏差的绝对值:

可以证明最佳预测值是条件中位数:

这是一种不同的位置度量，它的估计比条件均值的估计更稳健。不幸是，偏差的绝对值在其导数中具有不连续性，这阻碍了它们在损失函数中的广泛应用。

分类变量的预测值

当我们预测一个变量 Y 取离散值 c₁，c₂，…，cₖ 可视为某种群体标签时，我们经常会谈到分类。

我们的损失函数可以用一个 K×K 矩阵 Lf 来表示，其中 K 为类的数量。 Lf(ci，cj) 是对类别 j 而不是类别 i 的错误分类的损失。

然后，我们计算损失函数的平均值:

现在可以最小化逐点损失的期望值，得到 f 的表达式:

案例研究:贝叶斯分类器

损失函数的一个非常常见的例子是零一损失。如果类谓词是正确的，那么 loss 是 0。如果是错的，损失是 1:

然后，用 δ 作为克罗内克δ，期望损失为:

因此，对于每个 x ，最小化 1−ℙ(f(X)|X) 的 f 的最佳选择为:

这个预测器被称为贝叶斯分类器。由于这些“真实”的概率本质上是永远不知道的，因为在实践中很难计算出 ℙ (c|X=x)，这更多的是一个理论概念，而不是你可以实际使用的东西。通过对该量应用贝叶斯定理，然后假设所有参数相互独立:

这就是 朴素贝叶斯分类器 ，然后可以在实践中实现。

一个问题，两种解决方案

我们在前面几节中研究的所有预测器都有明显的缺点。如果在输入数据 X 中存在特殊结构，回归不能减少估计的偏差和方差。此外，如果 X 的尺寸较高，回归会导致较大的误差。

我们的目标是找到对函数 f(x) 的有用近似f(x)，该函数是具有大的和高维状态空间的输入和输出之间的预测和潜在结构化关系的基础。

这个问题可以通过两种不同的方法来解决。

统计估计量

应用数学和统计学采用的方法是从函数逼近和估计的角度。

输入和输出被视为欧几里得空间中的点，并且预测估计器将这些点对映射到该空间的超平面中。估计量现在表示为:

通过对拟合的模型类别施加一些严格的限制来选择估值器:粗糙度惩罚、核方法和基函数就是其中的一些。

通过实例学习

这种方法试图通过旨在最小化损失函数的教师来学习 f。教师的目标是根据输入产生输出f(Xi)。在学习过程完成后，我们希望预测输出和实际输出足够接近，以便对实践中可能遇到的所有输入集都有用。

这种方法通常被称为监督学习。据我们所知，机器学习旨在从技术上解决这个问题。

安托万冠军 2020 年 4 月 6 日

参考

哈斯蒂，特雷弗，蒂布拉尼，罗伯特和弗里德曼，杰罗姆。统计学习的要素。美国纽约州纽约市:斯普林格纽约公司，2001 年。

尼尔斯·理查德，预测和分类，哥本哈根大学，2006 年

John L. Weatherwax，David Epstein，解决方案手册和注释:统计学习的要素，第 2 章，2020 年

概率的数学基础

原文：https://towardsdatascience.com/the-mathematical-foundations-of-probability-beb8d8426651?source=collection_archive---------7-----------------------

测度论导论

抽象是为了隐藏不相关的东西，只关注重要的细节。虽然有时看起来很可怕，但它是管理复杂性的最佳工具。

如果你问 n 位数学家定义数学是什么，你可能会得到 2n 个不同的答案。我的定义是，它是一门将事物抽象到只剩下核心的科学，为任何事物的推理提供最终框架。

你有没有想过概率到底是什么？你肯定用它来对数据进行推理，进行统计分析，甚至通过统计学习来构建算法为你进行推理。在本帖中，我们将深入兔子洞，用放大镜探索概率论。

先决条件

要坚持到底，你不需要任何高等数学，我正专注于从基础开始解释一切。但是，如果您了解以下内容，这对您是有益的:

集合和集合运算，如并、交和差。
极限和一些基本的微积分。

集合和度量

概率可以被启发式地认为是一个函数，衡量一个事件发生的可能性。尽管从数学上来说，目前还不清楚什么是事件和度量。在我们能够恰当地讨论概率之前，我们需要先建立一个坚实的基础。所以，先说事件。

事件

“我用这个骰子掷出奇数的概率是多少？”

当谈到概率时，这个简单的问题会作为一个例子出现在我们的脑海中。在这个简单的问题中，事件是掷出一个奇数。为了对此进行数学建模，我们使用集合。“宇宙”，即包含该实验结果的基本集合，简单来说就是ω= { 1，2，3，4，5，6} ，而事件是ω的子集。这里滚动一个奇数对应的是子集 A = {1，3，5} 。

所以，为了定义概率，你需要一个底层集合ω和它的子集集合σ，我们称之为事件。然而，σ不能仅仅是任何子集的集合。有三个条件必须满足。

ω是事件。
如果 X 是事件，那么它的补码ω\ X也是事件。也就是说，没有发生的事件也是另一个事件。
事件的联合就是事件。也就是说，(事件或另一个事件)也是一个事件。换句话说，σ接近于并集。

如果满足这些条件，σ被称为σ代数。用恰当的数学术语来说:

在我们的情况下，我们有

当ω是实数集时，会出现一个更有趣的情况。稍后我们会看到，如果实数的所有子集都被认为是事件，那么会发生非常奇怪的事情。

描述σ-代数

我们用σ-代数定义的这些事件空间很难描述。人们可以立即看到，为了在非平凡基集ω上有一个有意义的事件空间，我们应该有无限数量的事件。例如，我们在木板上射击子弹，想要计算击中某个区域的概率。在这些情况下，指定一些子集并取包含这些子集的最小σ代数就足够了。

让我们假设我们正在射击一块长方形的板。如果我们说我们的事件空间是包含棋盘上所有矩形子集的最小σ代数，我们

对σ代数有一个非常简单的描述，
会有各种形状，因为σ-代数在并下是闭的。

很多集合可以描述为矩形的无限联合，如下图所示。

不规则形状如并集或无限矩形。

我们称棋盘内的矩形集合为生成集，而我们称最小的σ代数为生成σ代数。

你可以把这个生成过程想象成获取你的生成集的所有元素，并以所有可能的方式获取并和补集。

现在我们有了一个处理事件的数学框架，我们将把注意力转向度量。

措施

尽管直观地衡量某些东西是清楚的，但这是一件非常难以恰当形式化的事情。度量基本上是一个函数，将一个集合映射到一个数字。考虑一个简单的例子，测量一个三维物体的体积似乎足够简单，但即使在这里，我们也有严重的问题。你能想到空间中一个你不能测量其面积的物体吗？

大概你不能马上，但绝对不是这样。可以证明，如果空间的每个子集都有明确定义的体积，那么你可以拿一个单位体积的球体，把它切成几块，然后把两个单位体积的球体放在一起。

巴拿赫-塔尔斯基悖论。来源:维基百科

这被称为巴拿赫-塔尔斯基悖论。因为你不能真正做到这一点，所以你不能测量空间中每个子集的体积。

但是在这种情况下，措施到底是什么？真的，我们只有三个要求:一个度量应该永远是正的；空集的度量应该为零；如果你把不相交集合的测度相加，你就得到了它们并的测度。

为了正确定义它们，我们需要一个基集ω和一个σσ-子集代数。该功能

是一个测量值如果

房产 3。叫做σ——可加性。如果我们只有有限数量的集合，我们将简单地称之为测度的可加性。

这个定义只是对体积测量的抽象。这可能看起来很奇怪，但这三个属性才是最重要的。其他一切都是从他们那里来的。例如，我们有

这是由于 A \ B 和 B 不相交，它们的并是 A 。

设置差异。

另一个重要的特性是度量的连续性。这上面说

这个性质类似于实值函数的连续性定义，所以这个名字不是偶然的。

描述度量

正如我们已经看到的 σ 代数，你只需要给出一个生成集，而不是一个完整的 σ 代数。这在我们使用度量时非常有用。尽管测度是在 σ 代数上定义的，但是在生成子集上定义它们就足够了，因为由于 σ 可加性，它决定了 σ 代数的每个元素上的测度。这是从

概率的定义

现在一切都被设定为数学定义概率。

一个概率空间由元组定义

其中ω是基集，σ是其子集的σ-代数，并且 P 是这样的度量

因此，概率与面积和体积等量密切相关。面积，体积，概率都是各自空间的度量。但是，这是一个相当抽象的概念，我们来举几个例子。

扔硬币

最简单的概率空间，用抛硬币事件来描述。假设我们用 0 编码头部，用 1 编码尾部，我们有

由于σ代数和测度的性质，你只需要定义事件 {0 }(正面)和事件 {1} (反面)的概率，这就完全决定了概率测度。

随机数

一个更有趣的例子与随机数生成有关。如果你熟悉 Python，你可能用过random.random()函数，它给你一个 0 到 1 之间的随机数。虽然这看起来很神秘，但是用概率空间来描述它是非常简单的。

再次注意，给出生成集元素的概率就足够了。例如，我们有

再看一个更复杂的例子，什么是 P({0.5}) ？怎么才能算出挑到 0.5 的概率？(或 0 到 1 之间的任何其他数字。)为此，我们需要依赖测度的性质。我们有

其中这适用于所有ε > 0 的情况。这里，我们使用了概率测度的可加性。因此，可以得出结论

同样，因为它适用于所有ε > 0 的情况。这意味着概率小于任何一个正实数，所以一定为零。

对于任何 0 ≤ x ≤ 1 ，类似的论点成立。令人惊讶的是，选择一个特定的数字的概率为零。所以，在你生成了随机数并观察了结果之后，要知道它发生的概率是 0。然而，结果仍然摆在你面前。

零概率的事件都有可能发生。

分布和密度

我们已经走了很长的路。尽管如此，从实用的角度来看，使用测度和σ-代数并不十分方便。幸运的是，这不是处理概率的唯一方法。

为了简单起见，让我们假设我们的基集是实数集。具体来说，我们有概率空间(ω，σ，P) ，其中

而 P 是这个空间上的任意概率测度。我们之前已经看到，事件 (a，b】的概率决定了事件空间中其余事件的概率。然而，我们可以进一步压缩这些信息。实际上，这个函数

包含了我们必须知道的关于概率测度的所有信息。想想看:我们有

对于所有的 a 和 b 。这被称为 P 的分配函数。对于所有的概率测度，分布函数满足以下性质:

(第四个叫左连续性。如果你不熟悉连续性的定义，不要强调，它现在不是必不可少的。)

同样，如果这太抽象，让我们考虑一个例子。对于前面的随机数生成示例，我们有

这被称为[0，1]上的均匀分布。

总而言之，如果你给我一个概率测度，我会给你一个描述概率测度的分布函数。然而，这并不是分布函数的最佳之处。从数学的角度来看，同样正确的是如果你给出一个满足上述性质 1)-4)的函数，我可以从它构造一个概率测度。而且，如果两个分布函数处处相等，那么它们对应的概率测度也是相等的。因此，从数学的角度来看，在某些情况下，分布函数和概率度量是相同的。这对我们极其有用。

密度函数

正如我们所见，分布函数从概率度量中提取所有信息，并对其进行压缩。这是一个很好的工具，但有时并不方便。例如，当我们只有一个分布函数时，计算期望值是很困难的。(如果您不知道什么是期望值，请不要担心，我们现在不会使用它。)

出于许多实际目的，我们用密度函数来描述概率度量。一项功能

是概率测度 P 的密度函数

适用于所有的*Eσ-代数σ*。也就是说，启发式地，给定集合的概率由 f(x) 曲线下的面积决定。这个定义可能看起来很简单，但是这里隐藏了很多细节，我就不赘述了。例如，如何在任意集合 E 上积分一个函数一点也不简单。**

你可能熟悉微积分中著名的牛顿-莱布尼茨法则。这里写着

这基本上意味着，如果分布函数是可微的，它的导数就是密度函数。

有些概率分布只有密度函数是已知的封闭形式。(具有封闭形式意味着可以用有限个标准运算和初等函数来表示。)最著名的分布之一是这样的:高斯分布。它的定义是

其中，μ和σ是参数。

高斯分布的概率密度函数。来源:维基百科

高斯分布的概率分布函数。来源:维基百科

不管看起来多么令人惊讶，我们不能以封闭的形式表达高斯分布函数。并不是数学家只是还没想通，是证明了不可能。(相信我，在数学中证明某件事是不可能做到的有时是极其困难的。)

从这里去哪里？

到目前为止，我们所看到的只是冰山一角。(想起来，这可以在每次关于数学的讨论结束时说。)这里，我们只是以数学上(半)精确的方式定义了什么是概率。

真正有趣的东西，比如机器学习，还在我们面前。

如果你想开始深入，我写了一篇关于机器学习如何用概率论来表述的文章。看看吧！

** [## 机器学习的统计基础

超越函数拟合的视角

towardsdatascience.com](/the-statistical-foundations-of-machine-learning-973c356a95f)**

如果你喜欢把机器学习概念拆开，理解是什么让它们运转，我们有很多共同点。看看我的博客，我经常在那里发表这样的技术文章！

深度学习背后的数学

原文：https://towardsdatascience.com/the-mathematics-behind-deep-learning-f6c35a0fe077?source=collection_archive---------11-----------------------

深度神经网络如何学习和适应的解释

图片作者:特里斯特·约瑟夫

深度神经网络(DNNs)本质上是通过具有多个连接的感知器形成的，其中感知器是单个神经元。将人工神经网络(ANN)想象成一个包含一组输入的系统，这些输入沿着加权路径馈送。然后对这些输入进行处理，并产生一个输出来执行某项任务。随着时间的推移，人工神经网络“学习”，并开发不同的路径。各种路径可以具有不同的权重，并且在模型中，被发现更重要(或产生更期望的结果)的路径比产生更少期望结果的路径被分配更高的权重。

在一个 DNN 中，如果所有的输入都密集地连接到所有的输出，那么这些层被称为密集层。此外，DNNs 可以包含多个隐藏层。隐藏层基本上是神经网络的输入和输出之间的点，在这里激活函数对输入的信息进行转换。它被称为隐藏层，因为它不能从系统的输入和输出直接观察到。神经网络越深入，网络就越能从数据中识别。

然而，尽管目标是尽可能多地从数据中学习，但深度学习模型可能会遭受过度拟合。当模型从训练数据中学习了太多内容(包括随机噪声)时，就会出现这种情况。然后，模型能够确定数据中非常复杂的模式，但这会对新数据的性能产生负面影响。训练数据中拾取的噪声不适用于新的或看不见的数据，并且该模型不能概括所发现的模式。非线性在深度学习模型中也非常重要。虽然模型将从多个隐藏层中学到很多，但是将线性形式应用于非线性问题将导致较差的性能。

图片作者:特里斯特·约瑟夫

现在问题来了，“这些层是怎么学习东西的？”好吧，让我们将人工神经网络应用于一个真实的场景来解决一个问题，并了解如何训练该模型来实现其目标。由于当前的疫情，许多学校已经过渡到虚拟学习，这导致一些学生担心他们通过课程的机会。“我会通过这门课吗”这个问题是任何人工智能系统都应该能够解决的。

为了简单起见，让我们考虑这个模型只有 3 个输入:学生参加的讲座的数量，在作业上花费的时间，以及在整个讲座期间互联网连接丢失的次数。该模型的输出将是二元分类；这个学生要么通过这门课，要么不及格。现在是学期末，学生 A 已经参加了 21 次讲座，花了 90 个小时做作业，并且在整个学期中失去了 7 次互联网连接。这些输入被输入到模型中，输出预测学生有 5%的机会通过课程。一周后，最终成绩公布，学生 A 通过了课程。那么，模型的预测出了什么问题呢？

技术上来说，没什么问题。这种模式本可以像目前开发的那样发挥作用。问题是模型不知道发生了什么。我们可能已经初始化了路径上的一些权重，但是模型目前不知道什么是对的，什么是错的；因此重量是不正确的。这就是学习的来源。这个想法是，模型需要理解什么时候它是错误的，我们通过计算某种形式的“损失”来做到这一点。正在计算的损失取决于手头的问题，但它通常涉及最小化预测输出和实际输出之间的差异。

图片作者:特里斯特·约瑟夫

在上面的场景中，只有一个学生和一个错误点需要最小化。然而，通常情况并非如此。现在，考虑有多个学生和多个差异要最小化。因此，总损失通常计算为所有预测值和实际观测值之差的平均值。

回想一下，正在计算的损失取决于手头的问题。因此，由于我们当前的问题是二元分类，适当的损失计算将是交叉熵损失。该函数背后的思想是，它将学生能否通过课程的预测分布与实际分布进行比较，并试图最小化这些分布之间的差异。

假设我们不再想预测学生是否会通过这门课，但是我们现在想预测他们在这门课上会得到的分数。交叉熵损失不再是合适的方法。相反，均方误差损失会更合适。这种方法适用于回归问题，其思想是试图最小化实际值和预测值之间的平方差。

图片作者:特里斯特·约瑟夫

现在我们已经了解了一些损失函数，我们可以进入损失优化和模型训练。拥有良好 dnn 的一个关键因素是拥有合适的权重。损耗优化应该试图找到一组权重， W ，其将最小化计算的损耗。如果只有一个重量分量，那么可以在二维图上画出重量和损失，然后选择使损失最小的重量。然而，大多数 dnn 具有多个权重分量，并且可视化一个 n 维图是相当困难的。

相反，计算损失函数相对于所有权重的导数，以确定最大上升的方向。既然模型知道哪条路是向上和向下的，它就向下行进，直到到达局部最小值的收敛点。一旦这个体面的完成，一组最佳的权重将被返回，这就是应该用于 DNN(假设该模型是发达国家)。

计算这个导数的过程被称为反向传播，它本质上是来自微积分的链式法则。考虑上面显示的神经网络，第一组权重的微小变化如何影响最终损失？这就是导数或梯度试图解释的。但是，第一组权重被输入到一个隐藏层，该隐藏层具有另一组权重，从而导致预测的输出和损失。因此，权重的改变对隐藏层的影响也应该被考虑。现在，这是网络中仅有的两部分。但是，如果有更多的权重需要考虑，这个过程将通过从输出到输入应用链式法则来继续。

图片作者:特里斯特·约瑟夫

训练 DNN 时需要考虑的另一个重要因素是学习速度。当模型寻找一组最优的权重时，它需要用某个因子来更新它的权重。虽然这看起来微不足道，但是决定模型应该移动的因素是相当困难的。如果这个因子太小，那么这个模型要么会以指数级的速度运行很长一段时间，要么会陷入某个非全局最小值的地方。如果因子太大，那么模型可能完全错过目标点，然后发散。

虽然固定速率可能是理想的，但是自适应学习速率减少了前面提到的问题的可能性。也就是说，该因子将根据当前的梯度、当前权重的大小或其他一些可能影响模型下一步找到最佳权重的因素而变化。

图片作者:特里斯特·约瑟夫

可以看出，dnn 是建立在微积分和一些统计的基础上的。评估这些过程背后的数学是有用的，因为它可以帮助人们理解模型中真正发生的事情，这可以导致开发更好的整体模型。但是，即使这些概念不容易理解，大多数程序都带有自动微分等工具，所以不用担心。编码快乐！

参考文献:

digital trends . com/cool-tech/what-a-artificial-neural-network/

deepai . org/machine-learning-glossary-and-terms/hidden-layer-machine-learning #:~:text = In % 20 neural % 20 networks % 2C % 20a % 20 hidden，inputs % 20 enter % 20 into % 20 the % 20 network。

ncbi.nlm.nih.gov/pmc/articles/PMC4960264/

towards data science . com/introduction-to-artificial-neural-networks-ann-1 EAE 15775 ef9

explainthatstuff.com/introduction-to-neural-networks.html

neuralnetworksanddeeplearning.com/

mathsisfun.com/calculus/derivatives-rules.html

d2l . ai/chapter _ appendix-深度学习数学/多变量微积分. html

其他有用的材料:

deeplearning.mit.edu/

math . UC Davis . edu/~ kouba/CalcOneDIRECTORY/chainruledirectory/chain rule . html

youtube.com/watch?v=tGVnBAHLApA

https://www.inertia7.com/tristn

youtube.com/watch?v=aircAruvnKk

youtube.com/watch?v=bfmFfD2RIcg

https://towards data science . com/what-is-deep-learning-ADF 5d 4 de 9 AFC

封锁一个国家背后的数学

原文：https://towardsdatascience.com/the-mathematics-behind-the-lock-down-of-a-country-af5e31a8fdf?source=collection_archive---------21-----------------------

照片由来自 Pexels 的 Prasanta Kr Dutta 拍摄

理解 2020 年的印度大封锁

免责声明:以下文字无意引起恐慌或伤害感情。这篇文章没有提出任何政治判断。这纯粹是一篇观点文章。我既不擅长数学建模，也不擅长流行病学。这项研究的结果有逻辑和推理的支持，并通过了适当的审查程序。

4 月 14 日，新德里:当 10 点的钟声敲响时，印度总理纳伦德拉·莫迪在经历了 21 天的疯狂封锁后向全国发表讲话，成为头条新闻。

另一边是 13 亿人民，屏息静气地听他讲话。

这是至关重要的公告。这将决定未来几个月这个国家运作的条件。该国爆发的 n-CoV-SARS-2(也称为新冠肺炎)病例数刚刚超过 10，000 例。

到上午 10:30，消息传出去了。

该国在 5 月 3 日之前一直处于封锁状态。虽然我内心的客观现实主义者在这场险些酿成的灾难中松了一口气，但我内心的人性却只能感受到越来越多的沮丧和绝望。

到上午 10 点 45 分，电话开始打进来。

我妈妈先打电话来的。她被困在喀拉拉邦南部城市高知。自从我上次见到她已经快 4 个月了，我们现在都意识到我们再次见面还需要一段时间。

然后我的小弟弟打电话来了。他和我们的祖父母住在一起，在学校宣布停课前，他及时搬出了他的大学。他们都在首都新德里，也是此次疫情中受影响最严重的地区之一。他说他没事，但我能感觉到他的担心。还是我自己的？

我的家人接受他们眼中的生活。他们是现实主义者。既不悲观，也不乐观。我们都意识到这次关闭是必要的。重要。

在这个国家里，我们并不是唯一分散的、分离的群体。

印度最近面临封锁后最大的移民危机，该国大城市近百万移民决定寻找回家的路。

我们都渴望回家。不是物理空间，而是与之相关的一切:稳定、爱、和平。

但是，有谁知道这种封锁是否有效吗？我们不知道。我不知道。

然而，我们希望，我们祈祷。

在我之前的帖子请保持距离中，我试图通过一些复杂的数学，以及一些相当直观的概念来解释为什么以及如何产生社交距离。

这篇文章得到的热烈反响让我大吃一惊，也让我受宠若惊。谢谢你的支持，尤其是我的那些不愿透露姓名的评论者。

在这篇文章中，我试图提出我对诸如封锁这样的极端措施是否有效的想法。发表意见很容易，但用经验证据来支持一个观点要困难得多。在这篇文章中，我们试图寻找这种支持的证据。

但在继续之前，我必须提醒读者，我们将试图用一个数学模型来证明这一点。预计会有误差。

我们尝试将这个模型应用到印度的数据中。有人担心在这个国家进行的测试数量，这是我们必须认识到的警告。

任何概率模型的先验往往是一个有争议的问题，我乐于听取对我的选择的不同观点。

流行病学 101 —是的，先生

我们使用的是上一篇文章中提到的模型，请保持距离。一个 SIR 模型。

作为一个复习，SIR 模型——首先在 1927 年开发——是一组微分方程，试图将一个群体分割成可接受群体、不可接受群体和可移动群体。

通过将模型与数据拟合，可以获得参数β和γ的估计值。

β、γ是该模型中最重要的两个元素。

β控制着接触率，即每个感染者每天被感染的平均接触次数
γ控制每天的清除率或恢复/死亡/隔离人员的比例

他们一起给予

R₀ = β/γ ∝ 每个原发病例的继发病例数

与更复杂的模型相比，我选择 SIR 方法的原因是为了限制系统最终做出的假设数量。

我们如何求解这些参数？
嗯，有两种突出的方式。

确定性解还是概率性解？

在我之前的文章中，我们尝试的是一个确定性的模型——一个产生单一解决方案的模型。

另一方面，概率模型可以被证明是一种范式转变。它们通常使用模拟来解决。

这两种方法有什么区别？

一个确定性的模型不包括随机性的元素。每次你用相同的初始条件运行模型，你都会得到相同的结果。

大多数日常情况的简单数学模型是确定性的。你灯里的电压？决定性的。
通过银行账户赚取的利息？决定性的。

一个概率模型包含了随机性元素。每次运行模型时，即使初始条件相同，结果也可能略有不同。这些模型包含了随机变化的某些方面。

这些模型是如何工作的？

概率方法最直观的解释类似于用地图导航。

假设，你在一个你从未去过的城市，你必须确定你在哪里。你只有一张地图。就在你失去所有希望的时候，你的朋友打电话告诉你你在城市的南部。这个信息叫做。**

你打算如何定位自己？嗯，你四处看看。

你猜测到你周围地标的距离。这些就是我们所说的 观察值 。

从逻辑上讲，你所需要做的就是在给你的地图上识别这些观察结果，瞧，你已经找到了你自己。

但对于一台机器来说，这并不是那么简单。那么，机器是如何做到的呢？

为此，我们使用 MCMC 采样或马尔可夫链蒙特卡罗采样。我们从先前的中随机选取点，即城市南部的随机点。

使用 Bayes 定理，每个人在他们的高中都必须学习的结果，MCMC 方法为每个采样点计算以下形式的机会…

“假设我在 200 米处看到这个地标，我在这个位置的可能性有多大？”

这就是 MCMC 的闪光点。它智能地搜索。它旨在通过探索附近的位置并从那些区域连续取样，向更高概率的区域收敛(希望是)。所以随着时间的推移，你能够识别你的位置。这是一个分布——因此，你可以理解估计值的变化，否则估计值会减少到一个点。****

不过，理论已经说够了。

罗马法师在 Unsplash 上拍摄的照片

让我们换个话题——变点分析

前面的部分看了用贝叶斯术语陈述问题。
为了模拟新冠肺炎，概率方法针对每天的观测提出以下形式的问题:

“假设我们在第 19 天观察到了 8000 个案例，那么在 R₀为 2 的情况下发生这种情况的可能性有多大？”

事实上，流行病建模的概率方法已被广泛用于预测新冠肺炎的传播——最显著的应用是伦敦卫生和热带医学院和 London⁴.帝国理工学院所做的工作这两个机构都在指导英国应对全球危机的策略。

我们使用两个 python 库requests和pandas，从这里访问印度的 CoViD 案例。它们提供 API，一个简单的 python 脚本就可以提取数据。这是一个众包数据库，数据与其他新闻报道一致。

让我们将数据可视化:

为了研究封锁的影响，我们设置了变化点。那是什么意思？一个简单的草图解释了这个想法。

绘制变化点——它们是如何工作的？

我们实质上是说，R₀变化有两个时间点。

在这里，点τ₁，τ₂在本质上是离散的，未知的。该过程将尝试估计这些。在这些时间段的每一个中，R₀也是未知的。

我们首先修改微分方程来解决这个问题

****def _simulate_with_changepoints(parameters, times, N):
 beta_1, beta_2, beta_3, gamma, tau1, tau2 = [float(x) for x in parameters] def SIR(y, t, p):
    beta_1, beta_2, beta_3, gamma = p[0], p[1], p[2], p[3]
    tau1, tau2 = p[4], p[5]
    if t < tau1:
       beta = beta_1
    elif t >= tau1 and t < tau2:
       beta = beta_2
    elif t >= tau2:
       beta = beta_3
    S, I = y[0], y[1]
    dSdt = -beta * S * I / N
    dIdt = beta * S * I / N - gamma * I
    return dSdt, dIdt values = odeint(SIR, y0, times, (parameters,))
 return values.T[1]****

我们在pymc3中陈述这个模型——一个用于概率编程的 python 包。

****num_days = len(Infected)
with pm.Model() as SIR_forward_model:    
    R0_1 = pm.Uniform('R0_1', lower=1, upper=6, testval=2)
    R0_2 = pm.Uniform('R0_2', lower=1, upper=6, testval=2)
    R0_3 = pm.Uniform('R0_3', lower=1, upper=6, testval=2) tau_1 = pm.DiscreteUniform('tau_1', lower=1, upper=num_days)
    tau_2 = pm.DiscreteUniform('tau_2', lower=tau_1, upper=num_days) Dinf = pm.Uniform('Dinf', lower=0, upper=15, testval=7) gamma = pm.Deterministic('gamma', 1 / Dinf)
    beta_1 = pm.Deterministic('beta_1', R0_1 / Dinf)
    beta_2 = pm.Deterministic('beta_2', R0_2 / Dinf)
    beta_3 = pm.Deterministic('beta_3', R0_3 / Dinf) forward = th_forward_model(beta_1, beta_2, beta_3, gamma, tau_1, tau_2)
    Y = pm.Poisson('Y', mu=forward, observed=Infected)****

在上面的模型定义中，我们假设所有的 R₀'s 都来自从 1 到 6 的均匀分布。

这意味着 1 到 6 之间的每个数字都有相等的出现概率

感染期，1/γ，或者定义为 D∞，来自 0 天到 15 天的均匀分布。

这意味着 0 到 15 之间的每个数字都有相等的出现概率

由此我们构造出γ和β₁、β₂、β₃.的方程

γ = 1 / D∞
βᵢ = R₀ᵢ / D∞

我们假设这种病毒的感染期不会随着时间的推移而改变。只有接触率发生变化。

切换点被设置为离散的统一先验，这意味着它们只能取从 1 日到数据最后一天的离散值，每天的概率相等。

有了这些先验，我们可以使用泊松分布来拟合模型，因为我们处理的数据是原始计数数据。

考虑到我们正在处理近 50 天的数据，我已经分离出最近 10%的数据进行验证。我们运行 6000 次模拟来估计参数。

模特合体看起来怎么样？

这导致了 17%的 MAPE(平均绝对百分比误差)。
这意味着预测值在∓实际值的 17%以内。

为了建立信心，我们对照尚未输入模型的数据检查结果，即被隔离且未用于导出参数的 5 天( 基于时间序列分割的样本外验证 )。

在这个数据集上，我们得到了 14%的 MAPE。

这为基于该模型构建推论提供了一些信心。

那么，这些推论是什么呢？

来自 Pexels 的丹尼尔·雷彻的照片

结论

一旦模型拟合完成，并且模型的预测能力得到评估，我们就可以看到参数推断是什么。

如果你画出平均 R₀随时间的变化，结果是你永远无法理解的。我第一次看到这个的时候，有点震惊。

锁定似乎起作用了！

其他参数呢？

鉴于我们提取了 3 月 2 日的数据，这就使我们对以下情况有了正确的认识:

τ₁位于 3 月 23 日至 3 月 24 日之间(从 3 月 2 日起 21-22 天)。这与封锁的开始(3 月 25 日)相一致。
在此之前，R₀在 2.1 到 2.6 之间。这是一个很高的数字。如果早一点实施封锁，这种情况本可以得到遏制。
τ₂在 4 月 5 日(离 3 月 2 日还有 35 天)。
从上图可以看出，在 3 月 24 日到 4 月 5 日之间，R₀的估计值在 1.9 到 2.3 之间变化。这可能意味着，虽然一些国家正在实施社会距离做法，从而看到 R₀下降，但其他国家的反应较慢。
4 月 5 日以后，R₀从 1.5 到 1.7 不等。这比印度危机的初始阶段减少了 31%。
感染期 D∞，估计在 5.1 天和 7.4 天之间。这与最近的研究提供的估计相符。

从下图中，我们可以看到大多数结果都是双峰的。这意味着有两个收敛点——直方图中的条在特定点达到峰值，具体来说是两个点。这可能是因为在广阔的印度次大陆上有大量的移民。对于即将到来的危机，每个州都有自己的立场。**

抽样后的后验分布估计

这一见解让我兴奋地去理解和进一步分析这个国家各州的数据。这种性质的分析有多种应用，我计划大约每周使用一种。所以，请继续关注这些更新！

结论

分析结束时，我百感交集。我想起了阿兰达蒂·洛伊最近一篇文章中的一句话。

我们当中谁不是庸医流行病学家、病毒学家、统计学家和预言家？

我确实想提倡这种分析。有足够的理由这样做。印度数学科学研究所最近的一项研究得出结论，扁平化的影响在 4 月 6 日开始显现。这些都符合上面的估计。感染期和 R₀在印度媒体报道的范围之内。
一位著名的经济学家也认同这些发现，尽管采用了不同的方法，这份报告已于 4 月 24 日提交给印度政府。

然而，这个模型也有警告。这个系统没有考虑到无症状的个体。这个系统没有计算潜伏期。我们假设人口是同质的。

此外，印度因没有进行足够的试验而受到批评。如果这是正确的，没有进行足够的测试可能意味着所有的预测和见解都是不真实的。毕竟，这个模型符合现有的数据。

至于根据这个模型的输出来做决定，我反对。如果有什么推论的话，那就是:

参数的双模态性质表明传染病仍然逍遥法外。请呆在家里。冒险出去不安全。

保持物理距离。隔离。

封锁只有在人们不出门的情况下才能起作用。

当我写这篇文章时，时钟已经敲响了凌晨 4 点。看着这些数字，我的希望很高，我不禁觉得我们会渡过难关。

我提醒自己:我们是现实主义者。既不悲观，也不乐观。

然而，我们希望，我们祈祷。

参考文献:

https://www . livemint . com/news/India/coronavirus-update-新冠肺炎-印度病例数-超过 10，000-国家数量-11586831204582.html
W. O .科马克和 A. G .麦肯德里克。1927."对流行病数学理论的贡献."英国皇家学会学报，A 辑 115:700–721。
J.库恰尔斯基等人。all，2020，新冠肺炎传播和控制的早期动力学:一项数学建模研究，The Lancet(传染病)，https://www . The Lancet . com/journals/LAN INF/article/piis 1473-3099(20)30144-4/full text
弗拉克斯曼等人。all，2020，估计 11 个欧洲国家的感染人数和非药物干预对新冠肺炎的影响，伦敦帝国理工学院，https://www . Imperial . AC . uk/MRC-global-infectious-disease-analysis/新冠肺炎/report-13-Europe-NPI-impact/

锁定和社交距离的数学

原文：https://towardsdatascience.com/the-mathematics-of-lockdown-social-distancing-1257bc685022?source=collection_archive---------27-----------------------

使用经典 SEIR 模型量化社会距离在遏制新冠肺炎病毒传播中的影响

( )免责声明: 这项工作中出现的见解是方向性的，因为这里使用的 SEIR 模型是一个经典模型。尽管如此，该模型仍然能够很好地量化社交距离锁定的影响以及它们在“拉平曲线”中所起的作用。但由于我不是流行病学家，这篇文章的观点不应被解释为专业建议。)

为了遏制新冠肺炎的蔓延，印度采取了一项激烈的措施，从 2020 年 3 月 25 日开始，印度进入了为期 21 天的封锁期。即使是病毒的发源地中国，也没有采取如此极端的措施，只是封锁了几个处于冠状病毒传播高峰期的省份。

别误会，鉴于目前的情况，我完全赞成全面封锁。但是全国范围的封锁让我好奇，情况(或者可能是预测的情况)可能有多糟糕，政府决定将 13 亿人关在家里 3 周。这个想法让我兴奋不已，我开始浏览网页寻找更多信息，最终找到了世卫组织网站上发布的研究论文和 ICMR 最近完成的研究。这些研究构成了我这篇博文的基础。

为了这个项目，我基本上建立了一个经典的 SEIR 流行病学模型来模拟在不同程度的社会距离措施下新冠肺炎在印度的传播。

博客分为两部分。在第一部分中，我试图在模型产生的投影背后发展一种高层次的直觉。在第 2 部分中，我更深入地研究了分析的数学方法，并谈到了我是如何实现这个模型的。

第 1 部分:为什么印度现在需要全面封锁？

ρ=0 表示完全封闭，而ρ=1 表示完全没有社交距离。观察随着社交距离的增加，即ρ的降低，曲线变平，峰值延迟

这篇文章的重点是变量ρ，它的范围是从 0 到 1，是这个模型衡量社会中正在实行的社会距离的程度。ρ=0 表示社区中的完全封锁，而ρ=1 表示根本没有社交距离或隔离。

还要注意的是，如果一个人已经感染了疾病，但仍处于潜伏期(即，该人或多或少没有症状，但携带病毒)，则该人被称为。潜伏期结束后，患者进入感染阶段。

从上面的可视化中可以看出，ρ的降低，以及由此导致的社会距离严重性的增加—
a)导致受感染个体的峰值变平
b)延迟了曲线达到峰值所需的时间

因此，如果严格的隔离和隔离得到遵守，那么当高峰到来时，感染病例的数量将会低得多。在乐观的情况下，这个数字会足够低，以至于印度的医疗保健系统不会在高峰期间感染人数的重压下崩溃。

来源: Vox

这个模拟确实显示了完全封锁在降低峰值方面的重要作用。但我们真正谈论的是多少奉承。为了理解这一点，让我们来看看预计在不久的将来可能需要住院治疗的受感染人数。

感染和严重感染病例的预计数量与ρ的函数关系

从上图中可以看出，即使相当乐观的ρ为 0.6(如果实行自愿的社会距离，可能会是这种情况)，从现在起大约 5 个月后，印度将有大约 35 亿人感染。各种科学文章以及世卫组织的这篇报道称，20%的感染者需要住院治疗，甚至可能需要重症监护室级别的护理。如果我们将同样的数字外推到我们的模拟中，我们将会有大约 700 万人在高峰期需要住院治疗。客观来看，印度总共只有大约 70 万张医院病床和 7 万张重症监护室病床。

来源: The Print

这就是为什么印度需要一个激烈的措施，如全国范围的封锁，以尽可能降低这个ρ。

不用说，现在ρ=1 意味着我们在劫难逃。

第二部分:了解 SEIR 流行病学模型！

SEIR 是用于模拟疾病如何在人群中传播的房室模型。是易感、暴露、感染、康复的首字母缩写。

来源:世卫组织

易感人群包括尚未感染或未患病的所有人。如果一个人已经感染了这种疾病，但仍处于潜伏期(即，尽管他携带病毒，但或多或少没有症状)，那么他就被称为 暴露者 。潜伏期结束后，患者进入感染阶段。接下来，他移动到最后的移除* 阶段，在那里他不再被感染。现在，取决于你的思想构成有多黑暗(也取决于你正在阅读的教科书)，这个阶段可能意味着个体康复并且现在对疾病免疫，或者他死于疾病，因此不在人口中，或者可能是两种情况的结合。*

接下来，如果 N 是考虑中的总人口，并且如果我们可以假设在病毒传播期间人口中没有增加任何个体，下面的等式应该成立-

其中 S 是易患该疾病的人数，E 是暴露的人数，R 是康复或死亡的人数。

在这个项目中，我使用了 N = 1.3 亿(印度人口)，并借用了以下印度新冠肺炎的统计数据，这些数据是 3 月 25 日从卫生部&家庭福利的网站上获得的，并将它们输入到模型中

当前 I =确诊(感染)病例数:563
当前 R=痊愈数:43 +死亡数:10 = 53

为了计算初始 E，我采用了
中引用的方法当前 E = 2.399 天前的感染病例数(249)~ 600*

最后，我们有下面一组非线性常微分方程，它们一起形成了基本的 SEIR 模型(排除了社会距离的影响):

其中 β，σ，γ 是一个人从一个阶段进入另一个阶段的概率或速率。

β: 控制传播速度；它表示在易感者和感染者之间传播疾病的可能性。(我用【2】中引用的生殖数字计算出这个值为 1.19)。*
σ: 是潜伏(暴露)个体变得有传染性的速率。它相当于 1/Y，其中 Y 是平均孵化持续时间。(模拟使用 Y=5.2，如引用的【1】)
γ =1/D，其中 D 为感染的平均恢复期 D。(模拟使用了【1】中引用的 D=2.3)

( ***** a .再生数，Ro =β/γ
b . ICMR 的研究表明，在最乐观的情况下 Ro 等于 1.5，在悲观的情况下 Ro 等于 4。我取了这两个数字的平均值来得出这个项目的β值)

下一步，我们需要考虑一个变量来捕捉社会距离的影响。这就是我们引入已经详细讨论过的 ρ 的时候。我们需要做的就是在上述方程组中用 ρβ 替换 β ，并针对不同的ρ值进行仿真。

最后，为了用 python 解决这个修改过的非线性 ODE 系统，我使用了 scipy 库的 odeint 函数。你可以在这里找到代码。

SEIR 模拟代码

希望现在你能更好地理解为什么印度在接下来的几周需要封锁。也许现在你可以理解总理莫迪警告严格遵守 21 天的封锁或看着这个国家被推回 21 年背后的重量。

希望现在你理解了锁定和社交距离的数学原理！

对这个国家来说，这真是一个艰难的时刻。你至少可以呆在你的沙发上，洗洗手，保持安全！

找我这里 了解更多。

深度学习的数学优化

原文：https://towardsdatascience.com/the-mathematics-of-optimization-for-deep-learning-11af2b1fda30?source=collection_archive---------3-----------------------

关于如何最小化具有数百万个变量的函数的简要指南

通常，神经网络的整体性能取决于几个因素。通常最引人注目的是网络架构，然而，这只是众多重要组件中的一个。一个经常被忽略的对高性能算法的贡献者是优化器，它被用来拟合模型。

为了说明优化的复杂性，ResNet18 架构有 11689512 个参数。寻找最优参数配置就是在 11689512 维空间中定位一个点。如果我们强行这样做，我们可能会决定将这个空间划分为一个网格，假设我们沿着每个维度选择 10 个点。然后，我们必须检查 10 个⁶⁸⁹⁵可能的配置，计算每个配置的损失函数，并找到损失最小的配置。客观地看，这个可观测的宇宙大约有 10⁸原子，估计年龄为 4.32 x 10 ⁷秒(约 137 亿年)。如果我们每秒钟检查的参数组态和从大爆炸开始的原子数一样多，那么到目前为止，我们已经能够检查 4.32×10 个⁴点。

说这甚至不接近是一种轻描淡写。如果我们让宇宙中的每一个原子都检查一个自大爆炸以来的构型，网格的大小仍然比我们所能检查的大大约 10⁸ ⁸⁴倍。

因此，优化是非常重要的。他们正在管理这种不可理解的复杂性，允许你在几天内而不是几十亿年内训练神经网络。接下来，我们将深入研究优化者的数学，看看他们是如何处理这个看似不可能的任务的。

优化的基础

让我们从简单的开始，假设我们有一个我们想要最大化的一元函数。(在机器学习上下文中，我们一般以最小化损失函数为目标，但最小化与最大化函数的负值是相同的。)定义

如果我们画出它的图表，它看起来像下面这样。

一个显而易见的优化方法是将线分成网格，检查每个点的值，并选择函数最大化的点。正如我们在简介中看到的，这是不可扩展的，因此我们将寻找另一种解决方案。让我们想象这是一个山区景观，我们是登山者，试图到达顶峰。假设我们在标有红点的地方。

如果我们想找到顶峰，我们应该朝哪个方向走？当然要去坡度越来越大的地方。这个概念通过函数的导数来形式化。数学上，导数定义为

虽然这个量乍一看似乎很神秘，但它有一个非常简单的几何意义。让我们更仔细地看看函数在求导点的位置。

对于任一 x 和 y ，通过 f(x) 和 f(y) 的直线由下式定义

一般来说，如果我们有一条由 at + b 定义的线，对于某些 a 和 b ，量 a 称为该线的斜率。这可以是负的，也可以是正的，正斜率的线向上，负斜率的线向下。绝对值越大，线条越陡。如果我们让 y 越来越接近 x 就像它在导数的定义中一样，我们看到这条线变成了函数图在 x 处的切线。

f(x)在 x = -2.0 处的切线和逼近线

正切值由函数给出

而它的方向可以用向量 (1，f’(x))来描述。

如果我们再次把自己想象成一个登山者的位置，从 x0 = -2.0 开始，我们应该往切线上升的方向走。如果切线的斜率很大，我们也愿意迈一大步，而如果斜率接近于零，我们就应该迈一小步，以确保不越过峰值。为了从数学上形式化这一点，我们应该转到下一点

其中λ是一个参数，设置步长应该是正确的方向。这叫做学习率。一般来说，后续步骤由以下内容定义

正导数意味着切线是增加的，所以我们想前进，而负导数是减少的，所以我们想返回。我们可以想象这个过程。

我们可以看到，这个简单的算法成功地找到了一个峰值。但是，这并不是函数的全局最大值，看图像就能看出来。稍微超前一点，这是一个广泛的优化算法家族的潜在问题，但是有解决方案。

在这个简单的例子中，我们只最大化了一个单一变量的函数。这有助于说明这个概念，但是，在现实生活中，可能存在数百万个变量。对于神经网络来说，肯定是这样的。在下一部分中，我们将会看到这个简单的算法是如何被推广到多维函数的优化中的！

多维度优化

对于一个单变量的函数，我们可以认为导数是切线的斜率。然而，对于多个变量，情况并非如此。我们先通过看一个具体的例子来试着建立直觉吧！定义函数

这将是本节中的玩具示例。

f(x，y)的图

对于二元函数，图形是一个曲面。我们立即看到切线的概念没有很好的定义，因为我们有许多线与曲面上的一个给定点相切。事实上，我们有一整架飞机。这被称为切面。

f(x，y)在(0，0)处的切平面

然而，这个切面包含两个非常特殊的方向。假设我们在看 (0，0) 处的切面。对于每一个多变量函数来说，除了一个变量之外，固定所有的变量基本上是一个单变量的函数。在我们的情况下，我们会

和

这些功能可以通过用一个垂直于其中一个轴的垂直平面来切割表面来可视化。平面和曲面相交的地方就是 f(x，0) 或者 f(0，y) 的图，这取决于你用的是哪个平面。

用垂直平面切割曲面以可视化 f(0，y)

对于这些函数，我们可以像上一节那样定义导数。这些被称为偏导数，它们在推广我们之前的峰值发现算法中起着重要作用。从数学上来说，它们被定义为

每一个偏导数代表我们切面上的一个方向。

可视化切面上偏导数的方向。

偏导数的值是特殊切线的斜率。最陡上升方向由坡度给出，其定义如下

注意，梯度是参数空间中的一个方向。梯度可以很容易地在二维平面中可视化，在我们的例子中如下所示。

f(x，y)的渐变

总而言之，峰值发现算法现在是

这被称为梯度上升。如果我们想找到一个函数的最小值，我们将向负梯度方向迈出一步，这是最陡下降的方向:

这个版本被称为梯度下降，你可能更频繁地看到这个版本，因为在机器学习中，我们实际上希望最小化损失。

为什么坡度指向最陡的上坡？

在这种情况下，为什么坡度会给我们最陡上升的方向，这并不是无关紧要的。为了给出精确的解释，我们需要做一些数学计算。除了用垂直于 x 或 y 轴的垂直面切割表面外，还可以用任意方向 (a，b) 给定的垂直面切割。有了偏导数，我们就有了

我们可以把这些看作是 f(x，y) 沿 (1，0)**(0，1) 方向的导数。虽然这些方向有特殊的意义，但是对于任何方向我们都可以这样做。假设我们有方向

那么相对于该方向的方向导数定义如下

请注意，最后一个恒等式就是方向向量和梯度的点积(也称为标量或内积),这个点积你们可能在高中几何课上遇到过。所以，

问题如下:哪个方向的方向导数最大？这将是最陡上升的方向，所以如果我们想优化，我们想知道这个特定的方向。要看到这不是别的，而是我们提到的梯度本身，回想一下，点积可以写成

其中|。|表示向量的长度，α是两个向量之间的角度。(这在任意维数都成立，不仅仅是二维。)很容易看出这个表达式在 cos α = 1 时最大化，即α为零。这意味着两个向量是平行的，因此 e 的方向必须与梯度相同。

训练神经网络

现在我们准备从理论走向实践，看看如何训练神经网络。假设我们的任务是将图像的 n 维特征向量分成 c 类。为了在数学上形式化我们的情况，我们的神经网络由函数 f 表示，将 n 维特征空间映射到 c 维空间:

神经网络本身是一个参数化的函数。为了表示方便，我们可以用一个单一的 m 维向量来表示它的参数

为了明确表达对参数的依赖，习惯上要写

训练神经网络相当于寻找损失函数的最小值

将神经网络参数空间映射到实数。损失函数采取以下形式

在哪里

第个数据点是否有观测值

并且 L 是逐项损失函数。例如，如果 J 是交叉熵损失，那么

在哪里

这可能看起来很简单，但是计算起来确实很困难。在现实生活中，数据点的数量 N 可以以百万计，更不用说参数的数量 m 了。因此，我们有一个包含数百万项的和，为此我们需要计算数百万个导数来最小化。如何在实践中解决这个问题？

随机梯度下降

为了使用梯度下降，我们必须计算

如果 N 很大，并且 N 很有希望非常大(因为我们需要大量数据)，那么这在计算上是非常密集的。我们能简化这个吗？一种方法是省略 sum 中的一些成员。虽然这听起来像一个临时的解决方案，但它有坚实的理论基础。要看到这一点，请注意 J 实际上可以写成期望值:

在哪里

是由我们的训练数据给出的(经验)概率分布。我们可以处理这个序列

独立的，同分布的随机变量。根据大数定律，

保持，在哪里

才是真正的底层分布。(具体哪个不得而知。)更详细地说，这意味着随着我们增加训练数据，我们的损失函数收敛于真实损失。因此，如果我们对数据进行二次抽样，并且只计算梯度

对于某些人而不是所有人，如果我们计算得足够多，我们仍然可以得到一个合理的估计。这被称为随机梯度下降或简称 SGD。

在我看来，有三个基本的发展使研究人员和数据科学家能够有效地训练深度神经网络:利用 GPU-s 作为通用计算工具，反向传播，以及最后的随机梯度下降。可以肯定地说，没有 SGD，深度学习的广泛采用是不可能的。

与几乎所有新方法一样，SGD 也引入了一个全新的问题。显而易见的问题是，我们的子样本量应该有多大？太小的尺寸可能导致有噪声的梯度估计，而太大的尺寸具有递减的收益。选择子样本也需要小心谨慎。例如，如果所有子样本都属于一个类别，估计值可能会相差一英里。然而，这些问题在实践中可以通过实验和数据的适当随机化来解决。

改进梯度下降

梯度下降(SGD 变体也是如此)有几个问题，在某些情况下会使它们无效。例如，正如我们已经看到的，学习率控制着我们在梯度方向上的步长。通常，关于这个参数，我们会犯两个错误。首先，我们可以把步长做得太大，这样损失就不会收敛，甚至可能发散。第二，如果步长太小，我们可能永远达不到局部最小值，因为我们走得太慢。为了演示这个问题，我们来看一个简单的例子，研究一下 f(x) = x + sin x 函数。

假设我们从 x0 = 2.5 开始梯度下降，学习率α = 1，α = 0.1，α = 0.01。

这里发生了什么可能并不明显，所以让我们为每个学习率画出 x -s。

对于α = 1，序列实际上在两点之间振荡，不能收敛到局部最小值，而对于α = 0.01，收敛似乎非常慢。在我们的具体例子中，α = 0.1 似乎刚刚好。在一般情况下，如何确定这一点？这里的主要思想是学习率不一定是恒定的。启发式地，如果梯度本身的大小很大，我们应该降低学习速率，以避免跳得太远。另一方面，如果幅度很小，这可能意味着我们正在接近局部最优，因此为了避免超调，学习率肯定不应该增加。动态改变学习率的算法称为自适应。

AdaGrad 是这种自适应算法最流行的例子之一。它累积存储梯度幅度，并根据梯度幅度调整学习速率。AdaGrad 定义了一个累积变量 r0 = 0 并用规则更新它

在哪里

表示两个向量的分量乘积。然后用它来衡量学习速度:

其中，δ是数值稳定性的一个小数值，平方根按分量计算。首先，当梯度较大时，累积变量增长相当快，从而降低了学习速率。当参数接近局部最小值时，梯度变小，因此学习率几乎停止下降。

当然，阿达格拉德是这个问题的一个可能的解决方案。每年都有越来越多的高级优化算法问世，解决了与梯度下降相关的广泛问题。然而，即使是最先进的方法，尝试学习率和调整它是非常有益的。

关于梯度下降的问题，另一个例子是确保我们找到一个全局最优值或一个接近它的局部最优值。正如你在前面的例子中看到的，梯度下降经常陷入一个糟糕的局部最优。为了更好地了解这个问题和其他问题的解决方案，我建议通读深度学习教材的第八章，作者是伊恩·古德菲勒、约舒阿·本吉奥和亚伦·库维尔。

深度神经网络的损失函数是什么样的？

在前面几节的示例中，我们只可视化了非常简单的玩具示例，如 f(x) = 25 sin x — x 。这是有原因的:对于两个以上的变量，绘制一个函数并不简单。由于我们固有的局限性，我们最多只能在三维空间中观察和思考。然而，为了理解神经网络损失函数的困难，我们可以使用一些技巧。关于这一点的一篇优秀论文是郝力等人的可视化神经网络的损失图，他们能够通过选择两个随机方向并绘制两个变量的函数来可视化损失函数

(为了避免尺度不变性造成的失真，他们还为随机方向引入了一些归一化因子。)他们的研究揭示了 ResNet 架构中的跳跃连接如何塑造损耗格局，从而使其更易于优化。

来源:郝力等可视化神经网络损失景观。

不管 skip 连接带来了多大的改进，我的观点是证明高度多维的优化是困难的。通过观察图的第一部分，我们看到有许多局部极小值、尖锐的峰值、平稳段等等。好的架构设计可以让优化者的工作变得更容易，但是通过深思熟虑的优化实践，我们可以处理更复杂的损失场景。这些是相辅相成的。

结论

在前面的章节中，我们已经了解了梯度背后的直觉，并以数学上精确的方式定义了它们。我们看到，对于任何一个可微函数，不管变量的数量是多少，梯度总是指向最陡的上升，这是梯度下降算法的基础。虽然它在概念上非常简单，但当应用于具有数百万个变量的函数时，它有很大的计算困难。这个问题通过随机梯度下降得到了缓解，但是还有更多的问题:陷入局部最优，选择学习速率等等。由于这些原因，优化是困难的，需要研究者和实践者的关注。事实上，有一个非常活跃的社区在不断改进它，并取得了惊人的成果！在理解了深度学习优化的数学基础之后，现在你已经走上了提高艺术水平的正确道路！一些让你开始的好文章:

由郝莉、徐征、加文·泰勒、克里斯托夫·斯图德和汤姆·戈尔茨坦共同完成
由 Diederik P. Kingma 和 Jimmy Ba 编写的《Adam:一种随机优化方法》
校准自适应学习速率以提高 ADAM 的收敛性作者:千千·童、关南亮和毕金波
【关于自适应学习率的方差及其超越】蒋、、何鹏程、、、高剑锋、韩佳伟

如果你喜欢把机器学习概念拆开，理解是什么让它们运转，我们有很多共同点。看看我的博客，我经常在那里发表这样的技术文章！

反向传播背后的数学

原文：https://towardsdatascience.com/the-maths-behind-back-propagation-cf6714736abf?source=collection_archive---------2-----------------------

全民数据科学

BP 算法幕后的一瞥

是的，一样。

介绍

对于大多数人来说，反向传播(BP)如何工作的高级解释在概念上是相当容易理解的。

计算成本函数 C(w)
计算 C(w)相对于你的神经网络(NN)中所有权重、 w 和偏差、 b、的梯度
调节 w 和 b 与它们的梯度大小成比例。

更可怕的是我们到底是如何计算这些梯度的。

你为什么要关心 BP 是如何工作的？

看看上面的图片就足以让我们当中除了最注重数量的人之外的所有人远离这个深度学习的领域。尤其是有了这么多的高级库(例如 Keras ),人们很容易忽略 BP 实际上是如何工作的。然而，理解 BP 如何工作将有助于你理解许多用于提高普通神经网络性能的技术。此外，了解 BP 将为您提供一个很好的基础，来攻击那里更奇特的深度学习架构，因为它们几乎都在引擎盖下使用它。

我真的相信大多数人能够理解上面介绍的内容，因为它只不过是高中数学，用一些花哨的符号来记录神经网络中数百万个参数。我们只需要把它分解成它的组成部分，然后把它们翻译成英语，这样我们就能理解这些方程想要表达的意思。

在本文中，我将阐明驱动 BP 的方程——驱动深度学习的奇迹算法。在继续之前，我假设读者已经知道神经网络是如何训练的。具体来说，假设在高水平上理解神经网络的正向和反向传播阶段。如果这些听起来很奇怪，那么我会把你引向我的 上一篇文章 ，我在其中解释了这一点。

在接下来的文章中，我将继续我上一篇文章中识别手写数字的例子。所以让我们继续吧。

简单的一对一网络

与大多数问题一样，我们可以通过简化场景来取得很大进展。因此，让我们先考虑一个简单的 1-1-1 网络，而不是通常的神经元和层以各种方式连接到一切。

图 1:标有激活、权重和偏差的 1–1–1 网络。

图 1 显示了这样一个网络，其中绿色、蓝色和红色神经元分别代表输入、隐藏和输出神经元。我们将最后一层神经元的激活称为 a^(L，将前一层神经元的激活称为 a^(l-1)，其中 l 是我们网络的层数(在这种情况下 L = 3)。类似地，将层(L-1)和 l 之间的权重和偏差定义为 w^(L-1)和 b^(L-1).

想象一下，我们把一个 9 的 1 像素图像(只是逗逗我，显然这是不可能的)通过我们的神经网络的前向传播阶段，这个输出神经元对应于数字 9。期望的输出是 1。但是我们的神经网络给我们一个随机值，比如 0.68。我们将使用均方误差作为我们的成本函数。一个训练示例的成本 C 就是(0.68–1)。

第一层

所以现在我们想计算我们的成本 C . w . r . t .的梯度，即连接 L 层到 L-1 层的神经元的权重。为了了解如何做到这一点，我们可以展开网络的最后一层。

图 2:图 1 的最后一层展开以显示术语如何影响成本函数 c。

图 2 示出了对最终层的激活(a^(L)有贡献的每一项如何对成本 c 有贡献。为了得到最终层的加权和(z^(L ),我们将来自层(L-1)的激活乘以连接两层的权重 w^{(L-1).然后我们加上一个偏差项，b}(L-1).最后，我们将加权和通过非线性函数σ(z^(L)，来计算 a^(L).

图 3:最终层的加权和与激活的等式。

现在我们想知道如果我们改变 w^(L-1).，c 会改变多少换句话说，我们想计算 dC/dw^(L-1).要做到这一点，我们可以使用我们所有人在中学时都学过的东西: 链式法则 。

图 4:用于计算成本函数相对于最终层权重的梯度的链式法则。还显示了展开的网络，以显示权重 w^(L-1 如何间接影响 c

从图 4 可以看出重量 w^(L-1)影响 c 的路径。w^(L-1)对加权和 z^(L)有贡献，加权和)用于计算活化度 a^(L)，活化度本身直接用于计算 c。因此，通过对适当的项取导数，我们可以构建 c 对重量 w^(L-1).的梯度方程

在链式法则中使用来自图 3 的 z^(L 和 a^(L 的方程给出

图 5:图 4 的链式法则中每一项的解析表达式，得到 w^(L-1).梯度的表达式

图 5 左侧三项中的第一项是 a^(L).的梯度因为我们使用 MSE(a^(l)-y)，作为我们的成本函数，梯度是 2(a^(L)-y).

第二项是最终层的激活梯度与最终层的加权和。这就是我们正在使用的非线性函数的导数，所以我们称之为σ’。例如，如果我们使用 sigmoid 作为我们的非线性函数(1/(1+e^-z)，那么导数将计算为 (e^-z/(1+e-z) ) 。

【注意:这就是为什么选择一个处处可微的非线性函数很重要，否则你不能传播(计算)你的梯度，尽管有类似 ReLU 激活函数】的警告

最后一项是连接层(L-1)和 L 的加权和的导数。根据图 3，这简单地等于层(L-1)的激活。

我们还想知道，如果我们改变偏置项，b^(L-1).，我们的成本函数会如何变化因此除了偏置项之外，可以构建与图 4 类似的展开图。

图 6:用于计算成本函数相对于最终层偏差的梯度的链式法则。还显示了展开的网络，以显示权重 b^(L-1 如何间接影响 c

链式法则中唯一改变的项是第一项，现在最后一层的加权和的导数相对于偏差。

像以前一样，我们仔细检查并计算链式法则所需的每一项的值。

图 7:图 6 的链式法则中每一项的解析表达式，得到 b^(L-1).梯度的表达式

很好，现在神经网络可以使用权重更新方程中的这些方程来计算出下一轮训练中 w^(L-1 和 b(L-1)的值。

图 8:最终层权重和偏差项的权重更新方程。

尽管神经网络对 a^(L-1 没有直接控制，但当我们考虑进一步进入神经网络时，很快就会发现我们需要它，所以让我们重复上述过程，但对 a^(L-1).来说

再次，我们沿着回到 a^(L-1 的路径，并构建链接 a^(L-1 的变化如何影响 c 的链式规则

图 9:用于计算成本函数相对于(L-1)层激活的梯度的链式法则。还显示了展开的网络，以显示激活 a^(L-1 如何间接影响 c

和以前一样，我们只是替换了链式法则中的第一项。然后我们计算这三项以获得

图 10:图 9 的链式法则中每一项的解析表达式，得到 a^(L-1).梯度的表达式

如果你一直坚持到这一点，你已经完成了大部分工作！再多一点点，你就能得到几乎所有的方程了。

L-2 层

现在让我们考虑一下，如果我们改变层(L-2)中的一个权重，C 会发生什么变化。和前面一样，我们可以画一个展开图来说明 w^(L-2)是如何间接影响 c 的

图 11:展开图 1 的三层以显示术语如何影响成本函数 c

构建适当的链式规则表达式，其将 w^(L-2 的变化如何影响成本函数 c 联系起来

图 12:用于计算成本函数相对于(L-2)层权重的梯度的链式法则。还显示了展开的网络，以显示权重 w^(L-2 如何间接影响 c

从图 12 中，你可以看到连接 w^(L-2 和 c 的路径。因此，我们在链规则中使用路径中所有项的偏导数。但是我们刚刚算出了 a^(L-1 的变化如何影响 c 的表达式(见图 10)。所以我们用一个偏导数代替最后三个偏导数，因为我们已经有了它的表达式。

前两项与之前非常相似，但现在我们只是替换了图 5 中上标的负 1。这样，我们就可以得到重量 w^(L-2).的梯度的下式

图 13:图 12 的链式法则中每一项的分析表达式，得到 w^(L-2).梯度的表达式

你可以看到，如果我们有一个更深的网络，甚至更远的一层，这个表达式将调用梯度 dC/da^(L-2)，前一个将调用 dC/da^(L-3)，等等。因此，通过计算每层激活的 C . w . r . t .的导数，我们可以递归地计算 C . w . r . t .的梯度，而不考虑网络中的任何权重或偏差。这个过程被称为反向传播，因为你是字面上传播梯度从最后一层回来。

如果你已经做到了这一步，那么你会很高兴听到以上是 90%的反向传播。我们刚刚针对 1–1–1 网络的简单情况执行了上述所有操作。将其推广到任意大小的网络，只意味着我们必须添加一些求和以及更多的指数，以跟踪每一项对应于层中的哪个神经元。但是我们刚刚推导出的方程具有完全相同的形式。

通用网络

现在让我们考虑如何修改上面的方程，以应用于每层有许多神经元而不是只有一个神经元的一般网络。

图 14:标记了激活和权重的一般网络。与图 1 相反，现在每一项都有一个下标来表示它所指的是层中的哪一个神经元。

图 14 示出了这样的网络，其中有 L 层，并且层 L 具有 N _ 1 个神经元。例如，如果 N _ 1 = 5，则最后一层中有 5 个神经元，如果 N_3 = 7，则意味着第 3 层有 7 个神经元。还显示了连接不同层中的神经元的权重之一。和以前一样，它有一个上标来表示它对应于哪一层，还有一个下标来表示它连接每一层中的哪一个神经元。例如，图中的权重 w_21 连接 L-1 层的神经元 1 和 L 层的神经元 2。

【注意:我将只考虑权重方程如何变化，因为这与偏差方程的过程相同。]

调整正向传播方程

让我们首先来看看前向传播的术语在 1–1–1 情况和最终层的成本、加权和以及激活的一般情况之间是如何变化的。

图 15:简单 1-1-1 情况(左)和一般情况(右)的成本、加权和以及激活的等式。

在 1–1–1 的情况下，成本函数只取决于输出层中单个神经元的值。但是现在在更一般的情况下，我们在最后一层有 N_L 个神经元。在我们的数字识别例子中，N _ L = 10——每个数字对应一个神经元。所以我们需要对最后一层中每个神经元的平方误差求和。最后，因为我们使用均方误差作为我们的成本函数，所以我们除以该层中神经元的数量。

对于一般情况下的加权和，现在有来自前一层(L-1)中所有神经元的贡献，这是 k 上的和，此外，由于一层中有多个神经元，我们必须确保指定我们指的是哪一个，因此我们为此添加下标 j。与往常一样，这是最容易理解的图表和简化的例子，其中最后和倒数第二层都有 3 个神经元，如图 16 所示。

图 16:每层有 3 个神经元的网络。示出了对最终层中的第二神经元的加权和有贡献的激活和权重。

因此，如果我们考虑哪些项对最后一层中第二个神经元的加权和有贡献，我们会看到前一层中的每个激活都有贡献。它们被乘以一个权重，该权重将它们连接到最后一层中的第二个神经元，因此我们给权重一个下标，其中两个数字对应于这两个神经元。您还可以将单个偏差项添加到加权和中(未显示)。

最后，图 15 中的第三项没有改变，所以你将这个加权和通过一个非线性函数来获得神经元的激活。我们唯一要做的是添加一个下标，来显示我们所指的是哪一层中的神经元。例如，a₁^(L)是最后一层中第一个神经元(图 16 中右上神经元)的激活，同样，a₃^(L)是最后一层中第三个神经元(图 16 中右下)的激活。

很好，我们已经调整了条款，以解决所有激活，并最终在正向传播中使用的成本。现在，我们需要对用于反向传播的梯度进行同样的操作。

调整反向传播方程

L-1 层

和以前一样，我会先陈述结果，然后我们会看到调整的原因。

图 17:简单 1-1-1 情况(左)和一般情况(右)下成本函数梯度与(L-1)层活化和重量的关系式。

C w.r.t .的梯度与(L-1)层的权重相比没有太大变化，除了我们增加了一个下标，正如我们在调整前向传播方程时所做的那样。

真正改变的术语是 C w.r.t 上一层活化的梯度。当我们调整加权和方程时，推理与以前基本相同，通过图表和简化的 3-3-3 网络更清晰。

图 18:每层 3 个神经元的网络该图显示了(L-1)层中特定神经元的激活现在如何影响 L 层中的所有激活，从而通过这些 N_L 通道影响 C。在这种情况下，它有 3 个不同的渠道来影响成本。

图 18 显示来自(L-1)层中单个神经元的激活现在如何影响最终层的所有激活。然后将所有这些激活相加以计算成本 c。因此，在该示例中，改变 a₁^(L-1)将影响下一层中的所有 N_L 神经元，这将影响成本。这就是为什么梯度现在是下一层神经元上的总和，以说明将受该激活值变化影响的所有通道。

关键是它和以前的形式完全一样，我们只是引入了求和和下标来说明每层有多个神经元。

L-2 层

最后，我们进一步回到这个网络中，问，如果我改变层(L-2)中的权重会发生什么？

让我们首先考虑一下，通过改变将层(L-2)中的第一个神经元连接到层(L-1)中的第一个神经元的权重，我们预计会影响哪些项。另一幅救援图！

图 19:每层 3 个神经元的网络该图显示了改变(L-2)和(L-1)层中第一个神经元之间的重量现在如何影响 L 层中的所有激活，从而通过这些 N_L 通道影响 C。在这种情况下，它有 3 个不同的渠道来影响成本。

改变(L-2)和(L-1)层第 1 个神经元之间的重量会改变(L-1)层第 1 个神经元的激活。但是，正如我们刚才看到的，这现在影响了通过 N_L 通道的成本，因为它连接到最后一层的所有神经元。因此，我们预计这个权重的梯度将包含这些 N_L 通道上的和。

图 20 示出了成本函数相对于层(L-2)中的权重的导数的调整方程。如果我们像以前一样，只调整 1–1–1 情况下的表达式，加上下标 If，可能看起来我们没有包括这些 N_L 通道。

图 20:简单 1-1-1 情况(左)和一般情况(右)下成本函数梯度与层(L-2)中权重的等式。

但是，如果我们现在输入上面图 17 的表达式，对于图 20 右侧的最后一个导数，我们确实看到 N_L 个通道已经包括在这个表达式中。

我们现在遵循与之前完全相同的过程，由此计算网络中任何权重的梯度，我们只是递归地找到成本函数 w.r.t .的梯度，所有的激活都在成本和感兴趣的权重之间。换句话说，我们 反向传播 梯度计算一直回到感兴趣的权重。

遵循相同的程序来获得网络中任何偏差的梯度。

就是这样！

【鸣谢:https://gi phy . com/gifs/reaction-扰流板-外域人-LSNqpYqGRqwrS 】

摘要

祝贺你，如果你能在一次阅读中理解所有的内容。如果这是你第一次看这些方程，它们肯定会因为所有的下标和上标而显得非常混乱。但是通过观察网络和跟踪一个项影响 C 的渠道，你可以推理出求和应该发生在哪里。这使得方程看起来不那么可怕了。

最好的事情是，因为网络中更后面的每个梯度都依赖于网络中它之后的梯度项，所以您不需要构建长得离谱的链式规则表达式，因为您已经从前面的层中获得了您需要的表达式。

在本文中，我们首先使用简单的 1–1–1 网络来推导反向传播方程的一般形式。这是一个展开网络的问题，以明确地看到从网络中的术语到成本函数的路径，然后构建适当的链式规则表达式。一旦我们有了这个，我们就可以简单地计算出这些表达式是什么。然后，我们看到层(L-1)中的项如何依赖于层 L 中的项。因此，我们可以通过不断地将后面层中的项链接在一起，将我们的计算结果传播回网络。

最后，我们转向网络的一般情况，每层有多个数量可变的神经元。这个简单案例和这个案例的区别在于:

包含下标来跟踪我们所指的神经元
确保一个项的变化可能影响 C 的所有渠道都考虑在内的总和。

不要误解我，支持反向传播的方程乍一看并不容易理解(或者第二、第三、第四等)。但它们所代表的实际数学工具只是导数和加法。其余的只是奇特的簿记。

我希望你喜欢研究黑盒的方程式。下一篇文章再见。

【鸣谢:https://tenor.com/vemb.gif

音乐的数学:玛丽亚·凯莉的数字

原文：https://towardsdatascience.com/the-maths-of-music-mariah-carey-in-numbers-75f0b56eeac9?source=collection_archive---------35-----------------------

数据科学能揭开她成功的秘密吗？

无论是一些最具标志性的歌曲，如《永远是我的宝贝》(T0)或《比天还高》(T1)，还是《T2》的必然性，我想要的圣诞节就是你(T3)在冬天的第一个迹象，甚至是催生了一整类迷因，我们都知道并热爱玛丽亚·凯莉。

歌鸟至尊、流行女王、R&B 女王、梅利斯玛女王、圣诞女王，最重要的是羔羊女王，这只是她所拥有的一些头衔，也是理所当然的，因为她在 20 多年的职业生涯中不断创造和打破记录。至少可以说，她以 19 首歌曲荣登 Billboard Hot 100 排行榜榜首，比任何一位独唱歌手都多，也是第一位在 4 个不同的十年中获得冠军的歌手。除了作为一名歌手的成就，她还创作和制作了专辑中几乎所有的歌曲(上述 19 首冠军歌曲中有 18 首是由她创作的)，这使她成为音乐行业有史以来最多产的音乐家之一。

她的歌曲在荒凉的时代闪耀着普遍的光芒，她的声音风格和歌曲创作激发了新一代的创作歌手，她对混音的热情塑造了 R&B 和嘻哈如何与当今主流流行音乐无缝融合——我们让数字为她讲述这个故事。

高于天之上

玛丽亚·凯莉的首张单曲Love于 1990 年发行，立即将她推上了音乐世界的上层。她是当时最年轻的获得格莱美金像奖四大奖项(唱片、歌曲、专辑和最佳新人奖)提名的人，凭借《爱的愿景》获得最佳新人奖和最佳流行歌手奖。随着业界的认可巩固了她作为音乐家的地位，她第一张专辑中的 3 首单曲也取得了商业上的成功，登上了公告牌百强排行榜。

她的专辑描绘了玛丽亚·凯莉的排行榜历史，不断推出一首又一首热门歌曲，除了 2018 年广受好评的 Caution 在她的声音、歌曲创作和合作者的选择方面看到了她最冒险和创新的一面。这张图表最引人注目的事情显然是我想要的圣诞礼物是你的成功，这首歌最初于 1994 年发行，但最终在 2019 年高居榜首，并在 2020 年迎来了它的位置。

作者图片

鉴于她在排行榜上的主导地位，人们不禁要问，玛丽亚·凯莉是一个开拓者，还是仅仅掌握了当时流行音乐生态系统的脉搏。作为代理，我们使用 Spotify 的音频功能来区分她的歌曲与其他歌曲的特征，这些歌曲在她获得第一名前后 6 个月也在 Billboard 热门 100 首歌曲中排名前 10。

在下面的图表中，我们绘制了相关时期其他 10 首顶级歌曲相对于 Mariah 排名第 1 的平均声音、舞蹈性、能量、乐器性、活力、语速和效价。

作者图片

有趣的是，当时仅有的两首处于其他歌曲平均水平之内的玛利亚·凯莉的歌曲是《爱的愿景》和《我们属于彼此》。这两首歌都处于她职业生涯的关键时刻，其中Love Vision是她的首张单曲We believe Together巩固了她的复出和继续统治。

与同龄人相比，她早期的大多数歌曲都有较高的声学分数，略低的舞蹈性，能量和效价分数。这与制作早期对她声音的技术掌握的关注不谋而合。此外，由于 Mariah 的许多歌曲都涉及爱情和心碎，较低的配价分数告诉我们，人们在需要的时候会向她寻求安慰，她的音乐的这一方面是她在职业生涯初期受欢迎的原因之一。虽然 Mariah 显然与《解放咪咪》发布后的声音合拍，但这一时期也见证了她更加自信和创造性地利用不同的音色来实现更低调但同样有效的张力和释放。

她来开派对了

尽管玛丽亚·凯莉是有史以来最多产的歌曲作者之一，但她并没有得到她应得的一半的荣誉，她只是在 2020 年入选了歌曲作者名人堂。众所周知，她是一个了不起的顶级作家，为了实现自己的创作愿景，她召集了越来越多的作家和制片人。

作者图片

从上面的情节中，我们可以看到她是如何从少数亲密的合作者开始她的职业生涯的，随着她与越来越多样化的人才合作，最终发展到拥有 40 名其他作家。为了《T2》，玛丽亚·凯莉(Mariah Carey)利用了她和本·马古利斯(Ben Margulies)在高中时创作的歌曲，并通过她的唱片公司，寻求沃尔特·阿法纳西夫(Walter Afanasieff)的帮助。由于这张专辑的成功，她的标签给了她更多的创作自由，在她后来的专辑中寻找新的方向。白日梦标志着她开始控制将嘻哈和 R & B 融入她的音乐，以《肮脏的混蛋》为特色的幻想混音巩固了她作为融合嘻哈、R & B 和流行音乐的革新者的地位。除了在她的音乐中大量融入说唱元素之外，这张专辑还见证了她对另一位长期合作者杰梅因·杜普利的首次介绍。

2005 年，杰梅因·杜普利创作的歌曲《就像这样》和《我们属于一起》的组合拳《解放咪咪》见证了她重回排行榜首位，并开创了一个实验的新时代。与梦想一起，玛丽亚凭借专辑 E=MC 中的 Touch My Body 获得了她的第 18 个冠军，这导致了更富有成效的会议，当时他共同创作并制作了不完美天使回忆录中的大部分歌曲。她的最新专辑《小心 T21》让她和她以前从未合作过的制作人一起出现在录音棚里，比如《史奇雷克斯》、《便便熊》和《血橙》,该专辑受到了评论界的好评，并且这张专辑出现在许多年终最佳专辑中。

作者图片

从她的目录后退一步，我们回到公告牌 100 大热门数据集来衡量她对同龄人的影响。1995 年发行的《幻想》混音版对流行音乐产生了重大的文化影响，因为它为后来产生强烈嘻哈影响的唱片设定了蓝图，并为碧昂斯、克里斯蒂娜·阿奎莱拉、蕾哈娜和今天的许多其他艺术家铺平了道路。作为一个简单的衡量标准，我们统计了具有以下特征的歌曲的数量，很明显在 1996 年有一个巨大的爆炸，并且这几年来一直在持续上升。

作者图片

词曲作者的艺术

如果我们要从玛丽亚·凯莉的歌曲中吸取一点东西，那就是她理解爱情的多面性，无论是它采取的情感形式如此强烈，以至于你相信它不仅仅是一个幻想，而是一个甜蜜的命运，还是分手的细微差别可能导致前情人无限期地成为你的一部分，或者被告知干脆滚蛋。

作者图片

上面的单词 clouds 确实显示了爱是她每张专辑的中心主题，但是她到底指的是什么样的爱呢？我们转向自然语言处理来深入挖掘她的歌词，在一种叫做非负矩阵分解的技术的帮助下，出现了四个有趣的话题。每个话题的前 10 个单词如下:

相信，发现，内在，结束，需要，知道，心，爱，理解，伤害
男孩，玩，女孩，好，想，离开，亚，告诉，玛丽亚，意思是
触摸，天堂，梦想，需要，感觉，想要，爱，漫长，等待，今夜
远离，光，开放，远，走，褪色，跑，夜，雨，晴

第一个话题的歌词提醒我们，为什么我们转向玛丽亚:飙升的权力歌谣，以解除我们最黑暗的时刻。第二个话题清楚地展示了她与嘻哈和 R&B 艺术家合作制作俱乐部准备好的果酱的亲和力(玛丽亚可能是一个天后，但她肯定不会唱自己的名字)。第三个主题是想象爱情的典范会是什么样子，而最后一个主题则带有更多反思和渴望的语气。为简明起见，我将它们重命名为:

力量歌谣
R&B/嘻哈音乐爱好者
爱情和浪漫
自省逃避主义

每项中得分最高的热门曲目是:

正如我们之前提到的, Daydream 是 Mariah 职业生涯的一个转折点，她开始尝试 R & B/hip-hop，并开始创作更多亲密的歌曲，如【星星下的。我们也看到这些年来，随着她摆脱了传统“流行”艺人的标签束缚，权力民谣的影响力持续下降。

作者图片

最后，除了上面的主题，我们还使用 Spotify 的音频功能对玛丽亚凯莉的歌曲进行聚类，以查看是否有任何模式出现。我们使用简单的 k-means 聚类算法和 4 个聚类，因为我们希望音频特征与上述主题大致相符。一些音频功能被删除，如乐器，因为这没有太多的变化；活跃度和响度，让每首歌曲都被视为标准的工作室作品；模式已被删除，因为主/次键的任何预期效果都将被化合价封装。

与简单地应用总括规则来对来自上述歌词分析的歌曲进行分类相反，我们保留原始分数并应用 k-means 聚类，以便考虑其他音频特征，这些音频特征也可能对歌曲的整体欣赏产生影响。下面的图是聚类算法的输出，其中每个聚类都被标记在具有最高平均值的抒情类别之后。

作者图片

不出所料，她的 R&B 学习曲目在可舞性、能量和效价方面得分最高，但爱情和浪漫歌曲也紧随其后。她的力量民谣在声学上得分最高，因为这些歌曲展示了她通过声音的技术运用来传达情感的能力，而不需要任何可能转移注意力的伴奏。

看看她的排名第一的歌曲是如何被分类的，她在权力歌谣、爱情和放纵中拥有同等数量的歌曲，在自省逃避主义中最少。然而，这一类别中有许多小羊最喜欢的，如《七月四日》、《星空下》、《T2》和《闭上我的眼睛》。玛丽亚·凯莉对情感的盛大展示吸引了大众，而她的忏悔引起了粉丝的共鸣。

作者图片

结论

玛丽亚·凯莉是一个活着的传奇——我们已经知道她是一个破纪录的，不落俗套的开创性创作歌手，但是量化这些成就只会让她的成功看起来更加不可思议。然后，我们试图用数学来分解她的音乐，以了解是否有潜在的模式，并确定了她的歌曲创作和生产中的一些共同主题。这些都不会让她虔诚的粉丝感到惊讶，因为他们已经下意识地将她的音乐的不同方面内化了，但数学给了我们一种从数字上评估这一点的方法。这是一个总结！

第 1 部分:矩阵简介

原文：https://towardsdatascience.com/the-matrix-profile-e4a679269692?source=collection_archive---------10-----------------------

STUMPY:用于现代时间序列分析的强大且可伸缩的 Python 库

(图片由约书亚·索蒂诺提供)

整体大于部分之和

(图片由作者提供)

STUMPY 是一个强大且可扩展的 Python 库，用于现代时间序列分析，在其核心，有效地计算出一种叫做矩阵轮廓的东西。这个多部分系列的目标是解释什么是 matrix profile，以及如何开始利用 STUMPY 完成所有现代时间序列数据挖掘任务！

(作者视频)

注:这些教程最初出现在 STUMPY 文档 中。

第一部分:矩阵轮廓图
第二部分: STUMPY 基础知识
第三部分:时间序列链
第四部分:语义分割
第五部分:快速近似矩阵轮廓图与 STUMPY
第六部分:用于流式时间序列数据的矩阵轮廓图
第七部分:快速模式搜索与 STUMPY
第八部分:【T2 10: 发现多维时间序列模体
第十一部分:用户引导的模体搜索
第十二部分:机器学习的矩阵轮廓

奠定基础

在一个简单的句子中，矩阵配置文件本质上是一个向量，它存储了时间序列中任何子序列与其最近邻居之间的 z 归一化欧几里德距离。

为了充分理解这意味着什么，让我们后退一步，从一个简单的示例以及一些基本定义开始:

长度 n = 13 的时间序列

time_series = [0, 1, 3, 2, 9, 1, 14, 15, 1, 2, 2, 10, 7]
n = len(time_series)

为了分析这个长度为n = 13的时间序列，我们可以可视化数据或计算全局汇总统计数据(即平均值、中值、众数、最小值、最大值)。如果你有一个长得多的时间序列，那么你甚至会觉得有必要建立一个 ARIMA 模型，执行异常检测，或尝试一个预测模型，但这些方法可能会很复杂，可能经常有假阳性或没有可解释的见解。

(图片由作者提供)

然而，如果我们应用奥卡姆剃刀，那么我们可以对这个时间序列进行分析的最简单和直观的方法是什么？

要回答这个问题，让我们从我们的第一个定义开始:

子序列/ˈsəbsəkwəns/名词

完整时间序列的一部分或一段

因此，以下都被认为是我们的time_series的子序列，因为它们都可以在上面的时间序列中找到。

(图片由作者提供)

print(time_series[0:2])
print(time_series[4:7])
print(time_series[2:10])[0, 1]
[9, 1, 14]
[3, 2, 9, 1, 14, 15, 1, 2]

我们可以看到每个子序列可以有不同的序列长度，我们称之为m。例如，如果我们选择m = 4，那么我们可以考虑如何比较任意两个相同长度的子序列。

m = 4
i = 0  # starting index for the first subsequence
j = 8  # starting index for the second subsequence

subseq_1 = time_series[i:i+m]
subseq_2 = time_series[j:j+m]

print(subseq_1, subseq_2)[0, 1, 3, 2] [1, 2, 2, 10]

(图片由作者提供)

比较任何两个子序列的一种方法是计算所谓的欧几里德距离。

欧几里德距离/yo͞oˈklidēən/ /ˈdistəns/名词

两点之间的直线距离

(图片由作者提供)

import math

D = 0
for k in range(m):
    D += (time_series[i+k] - time_series[j+k])**2
print(f"The square root of {D} = {math.sqrt(D)}")The square root of 67 = 8.18535277187245

距离轮廓-成对欧几里得距离

现在，我们可以更进一步，保持一个子序列不变(参考子序列)，以滑动窗口的方式改变第二个子序列，并计算每个窗口的欧几里德距离。成对欧几里得距离的结果向量也称为距离轮廓。

(图片由作者提供)

当然，并不是所有这些距离都有用。具体来说，自匹配(或平凡匹配)的距离并不提供信息，因为当您将子序列与其自身进行比较时，距离将始终为零。因此，我们将忽略它，取而代之的是，从距离配置文件中记录下一个最小的距离，并选择它作为我们的最佳匹配:

(图片由作者提供)

接下来，我们可以一次在一个元素上移动我们的参考子序列，并重复相同的滑动窗口过程来计算每个新的参考子序列的距离分布。

(图片由作者提供)

距离矩阵

如果我们把为每个参考子序列计算的所有距离分布图一个接一个地堆叠起来，那么我们就得到一个叫做距离矩阵的东西

(图片由作者提供)

现在，我们可以通过只查看每个子序列的最近邻居来简化这个距离矩阵，这将带我们进入下一个概念:

矩阵轮廓/mātriks//ˈprōˌfīl/名词

存储时间序列中任何子序列与其最近邻居之间的 (z 归一化)欧几里得距离的向量

实际上，这意味着矩阵简档只对存储来自每个距离简档的最小非平凡距离感兴趣，这显著地将空间复杂度降低到 O(n):

(图片由作者提供)

我们现在可以在原始时间序列下绘制这个矩阵图。并且，事实证明，具有小矩阵分布值的参考子序列(即，它具有显著“靠近”的最近邻居)可以指示可能的模式，而具有大矩阵分布值的参考子序列(即，它的最近邻居显著“远离”)可以暗示异常的存在。

(图片由作者提供)

因此，通过简单地计算和检查矩阵轮廓，人们可以很容易地挑出顶部模式(全局最小值)和最罕见的异常(全局最大值)。一旦你计算出矩阵的轮廓，这仅仅是可能的一小部分！

真正的问题是——暴力方法

现在，在这一点上看起来很简单，但我们需要做的是考虑如何有效地计算完整的距离矩阵。让我们从强力方法开始:

for i in range(n-m+1):
    for j in range(n-m+1):
        D = 0
        for k in range(m):
            D += (time_series[i+k] - time_series[j+k])**2
        D = math.sqrt(D)

乍一看，这可能看起来不太糟糕，但如果我们开始考虑计算复杂性以及空间复杂性，那么我们就开始理解真正的问题了。事实证明，对于较长的时间序列(即 n >> 10，000)，计算复杂度为 O(mn^2(如上面代码中的三个 for 循环所示)，存储完整距离矩阵的空间复杂度为 O(n^2).

为了客观地看待这一点，想象一下，如果您有一个单一的传感器，在 5 年的时间里每分钟收集 20 次数据。这将导致:

n = 20 * 60 * 24 * 364 * 5  # 20 times/min x 60 mins/hour x 24 hours/day x 365 days/year x 5 years
print(f"There would be n = {n} data points")There would be n = 52416000 data points

假设内循环中的每个计算需要 0.0000001 秒，那么这将需要:

time = 0.0000001 * (n * n - n)/2
print(f"It would take {time} seconds to compute")It would take 137371850.1792 seconds to compute

相当于 1，598.7 天(或 4.4 年)和 11.1 PB 内存来计算！因此，使用我们简单的暴力方法来计算距离矩阵显然是不可行的。相反，我们需要找出如何通过有效地生成矩阵轮廓来降低计算复杂度，这就是 STUMPY 发挥作用的地方。

多残株的

2016 年秋天，来自加州大学河滨分校和新墨西哥大学的研究人员发表了一组漂亮的背靠背论文，描述了一种叫做 STOMP 的精确方法，用于计算任何时间序列的矩阵轮廓，计算复杂度为 O(n2)！他们还使用 GPU 进一步证明了这一点，他们将这种更快的方法称为 GPU-STOMP。

考虑到学者、数据科学家和开发人员，我们采用了这些概念，并开源了 STUMPY ，这是一个强大的可扩展库，可以根据这一已发布的研究有效地计算矩阵轮廓。此外，由于其他开源软件，如 Numba 和 Dask ，我们的实现是高度并行化的(对于具有多个 CPU 或多个 GPU 的单个服务器)，高度分布式的(多个 CPU 跨多个服务器)。我们已经在多达 256 个 CPU 内核(分布在 32 台服务器上)或 16 个 NVIDIA GPU 设备(在同一台 DGX-2 服务器上)上测试了 STUMPY ，并获得了与公布的 GPU-STOMP 工作类似的性能。

(图片由作者提供)

结论

根据原始作者的说法，“这些是过去二十年中时间序列数据挖掘的最佳想法”，并且“鉴于矩阵配置文件，大多数时间序列数据挖掘问题都可以在几行代码中解决”。

根据我们的经验，这绝对是真的，我们很高兴与您分享 STUMPY ！请联系我们，让我们知道 STUMPY 是如何帮助您完成时间序列分析工作的，我们非常希望听到您的反馈！

附加注释

为了完整起见，我们将为那些想将自己的 matrix profile 实现与 STUMPY 进行比较的人提供更多的评论。然而，由于原始论文中省略了许多细节，我们强烈建议您使用 STUMPY 。

在我们上面的解释中，我们只考虑了无关紧要的匹配。然而，这是不够的，因为附近的子序列(即i ± 1)很可能是高度相似的，并且我们需要将其扩展到相对于对角线平凡匹配更大的“排除区”。在这里，我们可以看到不同的隔离区是什么样子:

然而，在实践中，已经发现i ± int(np.ceil(m / 4))的排除区域工作良好(其中m是子序列窗口大小),并且在为ith子序列提取矩阵轮廓值之前，在该区域中计算的距离被设置为np.inf。因此，窗口尺寸越大，禁区就越大。此外，请注意，由于 NumPy 索引具有包含性起始索引和排他性终止索引，确保对称排除区的正确方法是:

excl_zone = int(np.ceil(m / 4))
zone_start = i - excl_zone
zone_end = i + excl_zone + 1  *# Notice that we add one since this is exclusive*
distance_profile[zone_start : zone_end] = np.inf

资源

STUMPY Matrix Profile 文档
 STUMPY Matrix Profile Github 代码库

第二部分:短粗基础知识 →

AI 接管之事:人工智能会取代人类吗？

原文：https://towardsdatascience.com/the-matter-of-ai-takeover-will-artificial-intelligence-replace-human-beings-79d2c788f358?source=collection_archive---------4-----------------------

人工智能会接管人类吗，不管是崇拜者还是批评家？

Jason Yuen 在 Unsplash 上的照片

所谓的机器人/人工智能起义一直是许多反乌托邦小说的流行情节点。无论是在大银幕上还是在小银幕上，我们都见证了由人工智能驱动的机器人霸主缓慢、肯定和无情地接管人类的情节。然而，在电影中，人类总是赢家。我们还不确定人工智能接管的结果，如果它发生在现实生活中！

人工智能革命的话题很有争议。虽然有些人对人工智能革命没有什么可说的，但许多人工智能专家公开表示人工智能可能对社会产生的负面影响，并要求研究人员调查人工智能的社会影响。

人工智能无所不知、无所不在、几乎无所不能的能力一再受到质疑。这项技术的未来可能性很容易与潘多拉魔盒的神话相提并论。然而，我们知道潘多拉盒子里装的是什么，另一方面，人工智能的未来仍然很模糊，这证明了我们一次又一次面临的问题，那就是-人工智能会取代我们人类吗？

人工智能接管:终结的开始

今天，人工智能技术正被用来执行从琐碎到重大的任务。无论是用人工智能相机增强移动摄影还是金融资产管理，人工智能在人类生活的各个领域都有一些真正令人惊叹的应用。

但是随着人工智能应用的增加，越来越多的人开始怀疑它是否会消除人类技能和经验在不同任务中的重要性。当手持增强型人工智能相机的人只需对准相机并点击时，一位资深摄影师的技能和经验会发生什么变化？当人工智能被训练来预测股票并帮助人们基于此做出决策时，一名经验丰富的股票经纪人的技能和直觉会发生什么变化？

来源:照片由 Franck V. 在 Unsplash 上拍摄

有些人会争辩说，人工智能只是帮助用户获得多年经验的好处，而不必努力多年来获得这种经验。但是，当获得经验的过程被完全移除，没有任何东西阻挡用户获得最佳结果时，人类的基本价值观会发生什么呢？

如果你把所有这些问题都记在心里，那么整个“AI 将取代人类”的前提似乎就没有那么荒谬了。然而，为了证实或拒绝这种想法，我们真的必须弄清人工智能对社会的明显积极和消极影响。

人工智能自动化:同一枚硬币的不同面

任何事物都有其积极和消极的影响，这是显而易见的。人工智能也不例外。人工智能自动化的效果从非常好到非常糟糕不等。在对人工智能在社会中的长期影响做出任何假设之前，需要密切观察和分析这些影响。

硬币的正面

人工智能有许多积极的方面——从加速平凡的任务到增强更大行业的内部工作。人工智能的分析和预测能力已被证明是许多行业的宝贵资产。无论是预测天气还是股市，人工智能技术预测能力的准确性正在以积极的方式影响许多行业。不仅是数据分析和在此基础上做出预测，人工智能还被用于更危险的任务，如太空探索，海洋探索等等。

下一个积极因素无疑是加强医疗行业的诊断和监测程序。通过可穿戴集成，今天的医生能够更好地诊断患者并监控他们的情况，从而提供更好、更准确的治疗。人工智能效应不仅改善了医疗程序，而且还大大降低了全世界的医疗成本。

来源:https://www.pexels.com/photo/gray-and-white-robot-73910/

由于智能家居自动化发展的增加，人工智能也进入了我们的家庭，并将其变成了一个更智能的家庭。基于人工智能的智能家居系统，通常被称为“幻影负载”或“吸血鬼能量”，在降低功耗和控制家庭碳足迹方面创造了奇迹。基于人工智能的面部识别系统也有助于当局以先进的方式对付罪犯。

人工智能还有很多很多其他的积极用途。但简而言之，我们可以肯定地说，人工智能的积极方面不仅跨越不同的行业，还影响着那些行业中每个人的个人生活。

硬币的反面

既然有积极的一面，AI 也必然有消极的一面。从人工智能偏见到社交媒体操纵，人工智能正在以以前不可想象的方式影响社会。

人工智能自动化的引入给现代人类的生活方式带来了重大转变。那些曾经需要手工劳动的任务，今天可以不费一根手指就完成。这意味着今天的用户有更多的空闲时间，他们正在寻找新的体验来填补这一空白。然而，这种对新体验的寻求对一些人来说比其他人更容易，这对社会产生了一些严重的社会和心理影响。

来源:https://www . Harvard . co . uk/6-things-you-need-know-on-artificial-intelligence/

人工智能负面影响的一个最明显的例子是涉及种族主义医疗人工智能系统的事件，该事件将数百万人的生命置于危险之中。人类社会的种族偏见通过用于训练人工智能系统的数据集进入了人工智能。这导致数百万黑人由于没有得到足够好的治疗而患病。

除此之外，还有更邪恶的影响，比如社交媒体操纵，这正在改变我们的观点，缺乏隐私和安全，这从中国的社会信用体系中显而易见，等等。人工智能的所有这些负面影响的主要问题是，直到它们就在我们面前，我们才想到这些影响。人工智能的负面影响看起来很肤浅，但实际上它正在更深层次上发挥作用，改变我们所知的社会结构。

AI 能否渗透到所有行业和领域？

直到现在，我们都认为人工智能可以应用于广泛的行业。但是它能在所有的地方使用吗？

尽管人工智能正在扰乱多个研究和工作领域，但在许多其他领域，人工智能并不那么有效。无论是一个组织的人力资源经理、公共关系经理还是一名艺术家，有些领域需要更多的人类同情、经验和技能。

来源:照片由 Unsplash 上的 Franck V. 拍摄

尽管有各种可能性，人工智能仍被认为处于发展的第一阶段。我们今天所看到的一切只是一个更聪明、更智能的版本的先驱。这就是为什么我们可以放心，因为今天的人工智能仍然没有达到完成大量工作所需的技能。

写作和编辑、平面设计、教学等工作尚未实现自动化，因为这些工作需要人的参与。当然，有了基于人工智能的系统，这些工作可以变得简单。但是 AI 还不能完全接管这些任务，现在还不行。学术领域也不受人工智能自动化趋势的影响。给论文评分等任务可以分配给人工智能系统，但当涉及到教学或研究时，该领域仍然需要人类的影响。

它们的区别在哪里——人工智能与人类

如果我们要最终回答人类是否会被人工智能系统取代的问题，我们需要理解人类的心理和人工智能系统之间存在根本的差异。

来源:安迪·凯利在 Unsplash 上拍摄的照片

虽然两者都具有认知功能，如解决问题、记忆、计划、推理和感知收集，但人类的大脑更有能力完成这些简单的任务。人类大脑能够将他们的情商、自我意识和人类经验整合到这些任务中，并给它一个每个人都独一无二的闪光。另一方面，人工智能系统还没有发展到能够自主学习的程度。它仍然需要由人类使用数据集进行训练，以便他们可以执行不同的任务。

归根结底，人工智能是人类思维的发明。由于人类的想象力，今天各种任务的完全自动化成为可能。尽管我们是否会被人工智能取代的问题仍然存在，但我们可以放心，就目前而言，人工智能系统还远远没有达到接管人类的技术成熟程度。

结论

对于人工智能在各个行业取代人类的问题，可能没有任何结论性的答案。我们只有预测和观察。这里是我们在思考人工智能收购时可以考虑的三大观察结果

人类已经创造了人工智能，即使正在进行更大的尝试来通过人工智能系统复制人类智能，我们仍然有很长的路要走，才能创造出一个可以超越我们的智能系统。
人工智能将在一些工作和行业中取代人类，这是不可避免的。许多需要手工劳动的工作将来会自动化。然而，这并不是人工智能统治的第一步。当计算机成为主流时，类似的事情也发生了，但我们还不是它的奴隶。(尽管我们痴迷于电脑和智能手机)
有了足够的监管和限制，我们可以为人工智能的接管做好准备。即使现在，人工智能行业也需要适当的监管法律，包括关于人工智能如何训练、使用以及它如何影响用户的法律。

在人工智能技术的负面影响变得太大之前，它的快速扩张需要不断的监管和观察。有了适当的法律保护用户，人工智能的接管将只限于反乌托邦电影和虚构世界的娱乐情节。

数据工程师的成熟

原文：https://towardsdatascience.com/the-maturity-of-data-engineers-2c9e2bfcee09?source=collection_archive---------52-----------------------

活动发起人在 Unsplash 上的照片

数据科学和机器学习

数据科学和机器学习的兴起是否影响了数据工程师的作用？

数据工程师是做什么的？

让我们从理解一个数据工程师是做什么的之前需要了解的三大战争开始。

数据挖掘、大数据和数据管道。

数据挖掘就是对数据进行预处理，从数据中提取一些知识，所以我们用一些数据来提取知识。大数据包含大量数据和变量。这些数据是巨大的，你需要让它在云计算或多台计算机上运行，如 AWS、Azure 和 Google Cloud，因为他们有很多机器和存储来存储这些数据。

通常情况下，大数据不会存储在一台机器中。这通常是因为数据集变得非常大。将数据存储在 MySQL、Postgres 或任何数据库中，当数据存储在一台机器上时，会变得很复杂。新技术被发明出来解决这个问题，像 Hadoop⁴和 NoSQL⁵.

数据管道本质上是数据工程师构建的管道。事实上，您需要使用数据挖掘从这些数据中提取信息。数据工程师需要做一个管道，让数据从未知的大量数据流向更有用的形式。

数据工程师本质上创建了一个数据管道，其中所有信息都来自不同的设备，如物联网设备、移动应用程序、网络应用程序、相机、汽车以及任何收集数据和存储信息或将数据记录到服务器或云的设备。

数据工程师将所有这些信息累积到包装精美的数据库中，并存储引擎，以便公司的不同部门可以创建可视化。他们可以监控其产品的性能，获得业务洞察力，根据这些数据做出业务决策，甚至在他们的应用程序中使用这些数据，例如，用于用户档案。

在一家公司寻找数据科学家、机器学习专家、商业智能或数据分析师之前，他们需要雇用一名数据工程师来建立管道。数据工程师带来所有组织好的信息来进行数据建模。他们帮助收集数据。通常，机器学习工程师或数据科学家不必关心数据管道。

在实践中，数据工程师从称为数据摄取的过程开始，该过程从各种来源收集数据，并将它们摄取到我们称之为数据湖的地方。数据湖是数据的集合。然而，我们不希望湖水溢出干涸。我们需要执行称为数据转换的操作，将数据从一种格式转换成另一种格式，通常转换成我们称之为数据仓库的东西。

数据仓库是保存对业务有用的可访问数据的地方。在将数据放入数据仓库之前，数据工程师会查看原始数据，并使用数据中有用的部分，然后将其放入数据仓库，以便业务的其他部分可以使用它。我们可以假设数据湖是一个原始数据池。这意味着数据湖通常比数据仓库之类的东西组织得更少，过滤得更少。

问题是，企业为什么要这么做？

当数据经过组织后，分析起来就容易多了。我们可能在数据湖中有我们不需要的数据。然而，我们节省了数据仓库中的存储空间，因为我们不必存储所有的数据，只存储数据结构。构建数据仓库基础设施是昂贵的；因此，我们可以通过这种数据管理来节省资金。

回顾一下，数据工程师使用数据工程实践构建了这条数据生产和数据捕获管道。这样数据科学家和数据分析师就可以分析数据了。

数据工程师使用什么样的工具？

你可能听说过阿帕奇 Kafka⁶、Hadoop⁴、亚马逊 S3 或 Azure Data Lake。这些程序是由工程师构建的，用来像数据湖一样携带大量数据。还有像 Google Big Query，Amazon Redshift，Amazon Athena 这样的工具。这些是数据仓库，允许工程师进行查询或分析结构数据。

在整个系统中，我们研究了数据工程师为业务创建的整个系统。他们使用不同的工具和程序来接收数据，然后将其放入数据湖或数据仓库。作为数据科学家和机器学习专家，你使用哪些数据？大多数时候，你会处理数据湖，因为如果你在进行机器学习，你拥有的信息越多越好。

通过机器学习，您可以使用结构化或非结构化数据进入数据湖，获取大量数据用于您的模型，无论是 CSV 形式还是任何其他形式。通常，数据仓库由商业智能人员或商业分析师或数据分析师使用，以进行可视化或分析数据，因为数据仓库通常具有更多已被清除的结构化数据。

作为数据科学家，您可以使用来自数据仓库的数据。这不仅仅是一条规则；通常是你用任何对你有用的数据。他们使用尽可能多的数据，尽可能多的有价值的数据。相比之下，像商业智能人员或数据分析师这样的人已经让数据工程师对数据进行了清理和处理，并使用类似数据仓库的东西来分析数据。

类似谷歌的大查询正是这样做的。它允许没有多少工程经验或编程经验的人在数据仓库中分析它。通常，软件工程师、软件开发者、应用开发者、移动开发者构建用户和客户使用的程序和应用。然后，数据工程师将通过管道和流水线来接收数据，并将其存储在不同的服务中，如 Hadoop⁴或谷歌大查询。然后业务的其余部分可以访问数据。

我们还有数据科学家，他们使用数据湖和数据科学家来提取信息并提供一些商业价值。最后，我们有数据分析师或商业智能来使用数据仓库或结构化数据来获得商业价值。

如今，这个行业正在快速发展，并且有一些重叠。有时工作描述可能会有所不同，但它们是通用的简化规则，你可以用来理解每个角色在公司中扮演的角色。

结论

作为数据工程师有三项主要任务。首先，数据工程师构建一个提取转换加载管道，也称为 ETL 。与数据摄取不同，数据摄取意味着将数据从一个地方移动到另一个地方，而 ETL 管道是数据工程师提取所有这些系统生成的数据的想法。他们提取数据，然后将数据转换成可以加载到数据仓库中的有用形式。因此，公司的其他人可以使用数据，他们使用 Python、Go、Scala 和 Java 等编程语言来完成这些 ETL 工作。

接下来，数据工程师还构建分析工具，以了解公司系统如何工作。数据工程师需要确保当系统的任何部分出现故障时，它会得到通知。数据工程师允许数据科学家、数据分析师和商业智能人员使用工具来分析数据，并确保他们部署的系统正确运行。

最后，他们的第三个主要任务显然是维护数据仓库和数据湖，即确保公司的其他部门可以访问其中的所有内容。

现在，您对数据工程师的工作有了一个高层次的概述。然而，这种情况正在快速变化，因为新工具总是层出不穷。所以我的建议是，不要把所有数据工程师都视为绝对必须知道的，而是要看到它们的存在。此外，数据工程师的角色似乎将被数据科学家取代。去阅读他们的一些文档，只在需要时学习或使用它们，因为它们是定期更新的，而数据工程的世界现在节奏很快。

关于作者

Wie Kiang 是一名研究员，负责收集、组织和分析意见和数据，以解决问题、探索问题和预测趋势。

他几乎在机器学习和深度学习的每个领域工作。他正在一系列领域进行实验和研究，包括卷积神经网络、自然语言处理和递归神经网络。

**References**#1 [Amazon Web Services](https://aws.amazon.com/)
#2 [Microsoft Azure](https://azure.microsoft.com)
#3 [Google Cloud](https://cloud.google.com/)
#4 [Apache Hadoop](https://hadoop.apache.org/)
#5 [NoSQL](https://en.wikipedia.org/wiki/NoSQL)
#6 [Apache Kafka](https://kafka.apache.org/)

混乱的深渊

原文：https://towardsdatascience.com/the-maw-of-chaos-a7b42cbc30cf?source=collection_archive---------52-----------------------

为什么时间预测如此具有挑战性？

你知道，如果开始下大雨，事情会变得很糟糕。古巴，2015。图片由作者提供。

介绍

我对自己发誓不写新冠肺炎。

然而，由于我最近倾向于回归基本面，重新审视数学中一些更有趣的话题，我认为解释为什么预测时间序列(例如疾病进展)如此具有挑战性将是有趣和有用的。更准确地说，我想通过展示事物在基本层面上是如何工作的，来解释为什么做这样的模拟有时真的很难。

我们将从一些基本方程开始，讨论与数据和构建模型相关的主要挑战。然后，我们将转向一个更复杂的数学现象，称为混沌。就像在小偷:黑暗计划(我以前最喜欢的一个)中一样，我们会逐渐进入其中，但这一次，我们将配备 python。；)

最简单的模型

指数生长

不失一般性，让我们联系在一个给定的时间步骤感染疾病的人数。确定进展的最简单模型是以下更新规则:

这是一个简单的递归公式，它在每次应用时都将值加倍。这里 2 只是一个比例常数，它告诉扩散发生的速率。

由于时间是连续的，因此将 x 视为时间相关值 x(t) 是有意义的。此外，将它解释为人口的一部分而不是一个绝对数量也是有意义的。这样，我们可以将问题重新表述为一个简单的一阶微分方程(ODE):

用一个> 0 个。

这个方程的解用经典的指数函数表示

其中 x0 = x(t = 0) 就是所谓的初始条件。

它的形式正是戏剧性增长背后的原因。然而，当 x 开始变得过大时，这个函数就是一个糟糕的模型。毕竟，正如我们同意用来描述人口的分数一样，它不能超过 1。在某种程度上，它必须放慢速度，因为如果一个被感染的人只与被感染的人接触，就不会再有新的感染发生。

逻辑增长

在定义我们的模型时，考虑这种“停顿”机制似乎是一个自然的步骤。下面这款怎么样？

这个公式定义了逻辑增长。我们来考虑一下它的性质。最初，当 x 较小时， a(1 - x) ≈ a 和，增长是指数型的。然而，一旦 x 接近 0.5， (1 - x) 开始抑制增长，使其在 x = 1 时完全停止。

图一。指数增长和逻辑增长的比较。观察它们对于作者的小 x. Image 是多么的相似。

事情变得复杂…

逻辑增长看起来可以接受。我们喜欢它，因为它很容易理解，抓住了一些现实，给了我们希望，只要我们接近“临界点”(在这个例子中是 x = 0.5 )，我们就可以阻止指数增长，并逐渐减缓整个事情。也许我们只需要参数化这里和那里的逻辑更新规则，它肯定会帮我们一个忙。我们知道这至少可以为我们赢得宝贵的时间。

不幸的是，这就是事情变得困难的地方。

与数据相关的问题

此类模拟(如此处或此处)的共同出发点是首先修改逻辑增长方程以捕捉更多现实情况，找到数据(如某个国家每天发生的病例数)，最后将数据拟合到分析解中(如果存在)或使用数据对其进行数字整合以进行微调。如果一个解决方案 x(t) 很好地捕捉到了数据，我们就可以做出预测或者进行进一步的“假设”分析。

这听起来很简单，但坏消息是大多数参数很难估计。例如，让我们稍微修改一下等式，通过添加 x(∞) = x(t → ∞) 系数(就像这里的中的一样)来说明也许不是每个人都会感染这种疾病。该等式将变成如下:

该系数本身表示最终会被感染的人口比例。虽然这是一个未知数，但人们可以通过比较参数化逻辑曲线与指数曲线的偏差来估计它。图二。显示了该参数的影响。

图二。系数对逻辑增长级数的影响。图片由作者提供。

由于大多数数据都有噪声，噪声很容易转化为对某些系数的错误估计。在微分方程的情况下，这些微小的变化可能会进一步放大，从而导致大胆的“错误估计”(稍后将详细介绍)。

尽管如此，数据上的噪声只是更大图景的一部分…

模型相关问题

添加 x(∞) 该参数表明朝着正确的方向迈出了一步，以捕捉更多的现实。然而，它并没有抓住全部。人们搬家，生病，有些人康复，有些人再次生病，有些人死亡，有些人出生。有的也是因为完全不相关的原因而死。

整个人口是一个动态的实体，这应该转化为一个新的方程。当然，并不是所有的过程都需要考虑在内，决定哪些过程重要，哪些不重要，以及如何考虑它们，这本身就是一个更大的挑战。

让我们看看下面的例子:波兰的数据。考虑到第一个 100 天，似乎很明显，疾病进展确实可以用修正的逻辑生长方程的解来表示:

import pandas as pd
import numpy as np
from scipy.optimize import curve_fit

df = pd.read_csv('./poldata.csv').set_index('day')
ddf = df.head(100)

t = np.linspace(0.0, 10.0, num=101)

def logistic(t, a, x0, xi):
    return x0 * xi * np.exp(a * t) / (xi + x0 * (np.exp(a * t) - 1))

(*params,) = curve_fit(logistic, t[1:], ddf['cases'].to_numpy())[0]
solution = logistic(t, *params)

图 3。显示结果。

图 3。将逻辑增长函数拟合到前 100 天收集的数据中(上图)。226 天后的进展显示出不同的趋势(下图)。图片由作者提供。

事实是，在第一个 100 天之后，人们似乎彻底改变了他们的态度。说到数学，不仅我们的等式没有捕捉到几个可能重要的影响因素(例如，人们康复或再次感染)，而且常数(例如， a )也不是真正的常数。

因此，由于数据似乎反映了某种趋势(不同于逻辑，但仍然是一种趋势)，指责模型过于简单是有道理的。

没错。像这样的情况可能，的确，给我们希望，用正确的成分，应该有可能建立必要的方程，一旦解决，可以用于预测。

不幸的是，还有最后一个问题似乎是数学本身。

混乱

一片混乱。如果没有随机性、嘈杂的数据或“错误校准”的方程，混沌可能会让所有的预测完全变成废话。这是一个纯粹的数学现象，它起源于数字。

为简单起见，让我们回到纯逻辑增长更新规则 ax(1 - x)。让我们也编写递归应用这条规则的代码。以后会更容易形象化。

from functools import lru_cache

def logistic_growth(x, a=2.0):
    return a * x * (1 - x)

@lru_cache(100)
def update(x_init, i, rule=logistic_growth):
    x = rule(x_init)
    i -= 1
    if i == 0:
        return x
    else:
        return update(x, i, rule=rule)

蛛网图

有了这段代码，我们可以使用所谓的蛛网图来调查初始化解决方案的结果。通过绘制更新规则和一条对角线 x = t 来构建该图。然后，通过用某个数字初始化 x(0) ，我们通过随后应用规则并把输出反馈给输入来跟踪它。从视觉上看，这相当于将点从曲线上弹开(图 4。).

from functools import partial

def cobweb_plot(ax, x0_init, a, rule=logistic_growth, max_iter=10, 
    xlim=(0, 1), ylim=(0, 1)):

    x = np.linspace(xlim[0], xlim[1], num=101)
    update_rule = partial(rule, a=a)

    ax.plot(x, update_rule(x), 'b')
    ax.plot(x, x, color='k')

    x0, x1 = x0_init, update(x0_init, 1, rule=update_rule)
    y0, y1 = 0.0, update(x0_init, 1, rule=update_rule)

    ax.plot((x0, x0), (0, y1), 'r', lw=0.5)

    x0, x1 = x0_init, update(x0_init, 1, rule=update_rule)
    y0, y1 = 0.0, update(x0_init, 1, rule=update_rule)

    for i in range(1, max_iter):
        y1 = update(x0_init, i, rule=update_rule)
        ax.plot((x0, x1), (x1, x1), 'g', lw=0.5)
        ax.plot((x1, x1), (x1, y1), 'g', lw=0.5)
        x0, x1 = x1, y1

    ax.set_xlabel('x')
    ax.set_ylabel(f'{a} x(1 - x)')
    ax.set_title(f'Logistic growth progression, x0={x0_init}')
    ax.set_xlim(xlim)
    ax.set_ylim(ylim)

fig, axs = plt.subplots(2, 2, figsize=(10, 10), dpi=100)
for ax, x_init in zip(axs.flatten(), (0.11, 0.25, 0.66, 0.88)):
    cobweb_plot(ax, x_init, 2.0)

图 4。使用四种不同的初始条件为“a = 2”准备的蛛网图。不管“x0”如何，观察解如何收敛到 0.5。图片由作者提供。

x(t) = t 的点称为不动点。它们很重要，因为它们包含了整个系统的信息。这里(图 4。)，显然 x = 0.5 是一个特定的不动点，它倾向于吸引解。更正式的说法是叫一个稳定不动点，因为无论我们如何初始化解， x 最终都会稳定在 0.5。

不是每个 x 都是“有吸引力的”

逻辑规则是如此简单，以至于没有人会认为它会出错。我们知道 a 系数决定了扩散率(在文献中通常称为 R )。现在，让我们把它改成一些不同的值。

fig, axs = plt.subplots(2, 2, figsize=(10, 10), dpi=100)

axs = axs.flatten()
cobweb_plot(axs[0], 0.12, 3.31, maxiter=150)
cobweb_plot(axs[1], 0.62, 3.31, maxiter=150)
cobweb_plot(axs[2], 0.12, 3.51, maxiter=150)
cobweb_plot(axs[3], 0.12, 3.99, maxiter=150)

图 5。系统的不同演化情况。顶部:` a = 0.31 '和不同的初始值。下图:相同的初始值“0.12”，但不同的比率“a = 3.51”和“a = 3.99”。图片由作者提供。

正如我们在图 5 中看到的。选择稍高的复制率值 a = 3.31 ，我们获得两个固定点。系统变得双稳态，并且当 t → ∞ 时，解在 0.825664338273154 和 0.4465353535 之间交替翻转。1982 . 00000000005

进一步增加速率 a = 3.51，我们得到 4 倍的周期。最后，对于更高，似乎没有一点吸引解决方案了。它变得不稳定，其中初始值 x0 的微小变化导致完全不同的路径。字面意思就是蝴蝶效应。

请注意，这是而不是随机性，因为我们的计算是完全确定的。然而，正是由于刚才提到的不稳定性，在实践中，即使对于完美的数据集和设计良好的方程，我们也可能面临无法做出任何长期预测的情况。

这只是…数学。

分叉

在我们结束这一部分之前，想象一个更有趣的图形可能会很有趣。

N_SAMPLES = 200

def get_fixed_point(x_init, a):
    return update(x_init, 100, rule=partial(logistic_growth, a=a))

a_values = np.tile(np.linspace(0.0, 4.0, num=200000) \
    .reshape(-1, 1), N_SAMPLES)
df = pd.DataFrame(a_values) \
    .applymap(lambda a: (np.random.random(), a)) \
    .applymap(lambda c: get_fixed_point(*c))

df = df.unstack().xs(1)

图。分支图是通过扫描“a”和每个“a”随机初始化“200 次并让系统每次进化 100 次迭代而获得的。图片由作者提供。

图 6。显示了所谓的分叉图，它显示了不同的 x(∞) 值作为 (a，x0) 的函数。我们可以看到，只要 a < 1 ，最终的被感染比例就会降到零。对于 1 < a ≈ < 3，它会非零，但至少有一个解。然而，随着进一步增加，系统的最终行为变得越来越不可预测，即使 a 被精确估计。这个系统对微小的变化过于敏感，因此不能被信任。

结论

创建数学模型并非易事。我们已经看到了人们可能面临的三种主要挑战，最后一种挑战似乎是数学本身在捉弄我们。尽管如此，许多人发现，即使是简单的方程也能表现出如此丰富的行为，这令人着迷。

从实践的角度来看，预测模型通常由数学“驱动”,包括某种更新规则。即使它们不是直接基于微分方程，这些模型产生的解是否稳定也常常值得考虑。正如我们所看到的，即使是简单的规则，连续应用它们的长期效果可能会直接导致混乱。

还会有更多…

我计划把文章带到下一个层次，并提供简短的视频教程。

如果您想了解关于视频和未来文章的更新，订阅我的 简讯 。你也可以通过填写表格让我知道你的期望。回头见！

原载于https://zerowithdot.com。

流程图中的注意机制

原文：https://towardsdatascience.com/the-mechanics-of-attention-mechanism-f6e9805cca66?source=collection_archive---------22-----------------------

TLDR :这基本上是关于将yo shua beng io 小组的原始注意文件【1】转换成流程图。查看附录前的最后一张图，了解完整的流程图。

认知状态:我试图正确理解注意力机制，在这个层面上，我知道如何对任何类型的数据/问题或任何形式实施它，以及如何调整它以改善它。这篇文章就像是我自己教自己的笔记。最后，由于我自己没有实现注意力机制，所以我写这篇文章时不够资格，也过于固执己见。

注意。Justin Chrn 在 Unsplash 上拍摄的照片

动机:网上大部分解释做好在解释什么注意力机制是关于的，但不是它如何工作的确切的机械细节，比如哪个向量跟哪个矩阵走。虽然原始论文做得很好，但它就像一个非常浓缩的版本，典型的学术写作，这意味着我需要很大的努力来解开它。这是那个。

简要背景

原始论文正在处理一个特定的自然语言处理(NLP) 问题，这是一个机器语言翻译任务，将一个句子从源语言翻译成目标语言。它被制定为一种编码器-解码器序列到序列(seq2seq) 架构，通常使用 RNN 的变体来完成，如 LSTM 和 GRU ，它们是一类深度学习算法，是人工神经网络(ANN) 的一部分，是人工智能(AI)的数据驱动/机器学习范式，而不是模型驱动范式。本文的其余部分假设您熟悉这些概念。

香草 RNN

香草 RNN 编码器单元。

巴赫达瑙等人。艾尔。通过以下等式描述了典型的 RNN 编码器单元。我用下图解开了这个等式。x_t 是一个用向量表示的字。函数 f(。)通常是某种类型的 RNN，像 LSTM 和格鲁。在论文中，他们使用的是双向 RNN (BiRNN)。最后，h_t 是 RNN 隐藏态。

完整的编码器架构如下，其中 c 是对整个句子进行编码的向量。通常，c = h_T，这基本上只是最后一个 RNN 隐藏态。

普通 RNN 编码器(T_x=4)

下面是一个典型的编码器-解码器 seq2seq RNN 的完整结构，翻译中有夸大的错误。想象一种语言，其中关于距离(这里对那里)、可数性(多对多)和性别/年龄/ 数量(男人对女孩)的信息包含在一个单词中，被翻译成另一种语言，其中这些信息必须被分割成多个单词，这些单词甚至可能彼此不相邻，反之亦然。此外，还有动词“to be”的问题，这是一个在所有语言中都不通用的特征。然后，我们可能会看到这类错误。

典型编码器-解码器的结构 seq2seq RNN 用机器发现翻译困难的夸张例子。不同的字体(字样)显示不同的语言(包括编码)。

(我在假装函数 g(。)产生下一个单词(技术上来说是单词向量，因为是嵌入的，但我打算从现在开始就称它为“单词”)。在本文中，它实际上是所有单词的概率向量。但这不是注意力机制的重要区别。)

香草 RNN 的局限

由于注意力机制只应用于解码器部分，所以我们可以忽略编码器部分，而专注于 H 也就是所有 h_j 的集合(原论文中有一个符号变化，所以我在这里反映出来。“j”是编码器部分的索引，“I”是解码器部分的索引，以前是“t”。)

左图:典型的 RNN 解码器。右图(绿框):典型 RNN 解码器的一个单元。

首先，在注意机制中，我们将使用 H，所有 h_j(所有隐藏状态的集合)的集合，而不仅仅是最后一个，所以让我们保持在那里。其次，为了简化起见，我们将重点关注一个 RNN 解码器单元，如上图右侧所示。

函数 g(.)(一个 RNN 单元)主要负责产生下一个单词(向量，嵌入的)y_i，这个决定是通过结合来自 c(代表原语言中的整句)、y_i(前一个单词)、s_i(前一个隐藏状态)的信息做出的。

作者意识到的是，使用“c”是一种非常糟糕的做事方式。首先，当一个人试图翻译下一个单词时(假设他们已经弄清楚了的语序，，他们只会关注(阅读:注意)一个(最多几个)单词，而不是整个句子。然而，通过使用“c”作为输入，网络/模型的体系结构在某种程度上暗示我们应该试图从对整个句子的某种整体理解中找出下一个单词，但事实绝对不是这样。

(为什么是几个字而不是一个？根据语言的不同(特别是当从一种分析语言翻译成综合语言的时候)，我们必须根据上下文来决定使用哪种形式。许多语言根据许多不同的语法方面改变形式，如单数/复数、男性/女性/中性、过去/现在/未来等。例如，想象从一种第三人称代词不区分性别的语言翻译过来，(像印度尼西亚语“dia”翻译成英语 he/she)。网络必须注意单词“dia”和任何可能给出问题人物性别线索的单词，以便正确翻译。)

注意力的要点

注意机制使用通过计算解码器 RNN 隐藏状态(红色箭头)和 h 中的每个注释向量之间的对齐而创建的唯一上下文向量 c_i(而不仅仅是一般的“c”)

注意的要点基本上是用一个上下文向量 c_i 来代替一般的“c ”,而不是每一步都给解码器一个相同的“c ”,我们会在每一步给解码器一个不同的 c_i。希望这个 c_i 给予注意源句子中的相关单词。

为了做到这一点，函数 c(.)需要关于原始句子的详细信息(因此我们使用注释向量 H，而不仅仅是最后的 h_j)和当前解码器 RNN 隐藏状态 s_i(因此红色箭头)。理想情况下，上下文向量 c_i 将包含关于相关单词的大量信息，以及关于其他不太相关的单词的少量信息。

解码器实际上是如何实现的

三个模块，每个输出一个:c(.)，f(。)，g(。).

每个解码步骤有 3 个重要输出:

y_i，目标语言中的一个单词。
s_i，当前解码器当前时间步的 RNN 隐藏状态。
c_i，源句子的加权表示(权重基于注意力)。

[我不确定这是否是真正的动机，但是…]有 3 个不同的模块是有意义的，其中每个模块负责每个输出:c(。)，f(。)，还有 g(。):

c(H，si-1)= c _ I
f(c_i，s_i-1，y_i-1) = s_i
g(c_i，s_i，y_i-1) = y_i

最后，注意！

最后一个问题是，如何计算上下文向量 c_i？这可以通过下面的完整模型得到最好的解释(根据注释，我希望这是不言自明的)。

注意机制的完整模型。方程式转录成流程图。

最重要的部分是比对分数 e_i，j(出于某种我不明白的原因，也被称为能量)。它基于当前解码器 RNN 隐藏状态计算源语言中每个单词的相关性(由注释 h_j 表示)。然后，我们给更相关的单词更大的权重，给不太相关的单词更小的权重。这相当于把的注意力给了更相关的词。下一步只是使用 softmax“标准化”权重。(出于某种我不明白的原因，等同于概率)。最后，我们计算源语言句子中所有单词的加权平均值，得到上下文向量 c_i。

附录

将我们的流程图与原始文件中的简化图进行比较。

对齐矩阵。(来自原论文)

要获得著名的比对矩阵图，只需绘制所有的 a_i，j，其中 I 是列，j 是行。

软注意和硬注意

这里描述的注意机制可以被认为是软注意，因为它使用的是 softmax。如果使用最大值(。)函数，那么 c_i 将只是最相关的单词向量。这可能不太有利，因为一些单词与另一种语言中的多个单词对齐。更重要的是，我们不能通过 max(使用反向传播。)，而我们可以用 softmax 做同样的事情。

参考文献和致谢

[1] D. Bahdanau，K. Cho 和 Y. Bengio，联合学习对齐和翻译的神经机器翻译 (2015)，学习表征国际会议(ICLR)

感谢陈思教会我注意力是如何工作的。

所有图像属于我，除非在标题中另有说明。

媒体的新冠肺炎情绪

原文：https://towardsdatascience.com/the-medias-covid-19-emotions-72b76963357d?source=collection_archive---------33-----------------------

资料来源:Pexels

报纸文章标题的自然语言处理分析

作为一个数据科学的待业学生，我至今还没搞清楚这是不是“21 世纪最性感的工作”。如果你们中的一个有，我很想知道你的观点！关键是，失业意味着我有很多空闲时间，这与你和我都(希望)遵循的社交距离措施相结合，所以我最近阅读了很多关于 COVID 相关问题的新闻。

经过几个月的持续接触，以真正的数据科学家的方式，一个想法浮现在我的脑海中:如果我分析一些最近的新闻文章，看看报纸是在利用积极还是消极的情绪——也许是作为一种让(一些)人产生负罪感的手段，让他们遵循社交距离措施，或者让其他人对他们感到愤怒，会怎么样？

这就是我产生这个想法的“社交媒体”版本。事实上，我很无聊，想做一些“数据科学”的事情，所以我下载了一些数据，并扔了一些我在学校学到的东西，看看会出现什么。

数据集

与典型的大数据标准相比，我使用的数据集非常小。我从 2020 年 3 月 22 日开始使用新闻 API(【https://newsapi.org/】T2)为 5 家不同的报纸收集了 100 篇报纸文章。我试图通过为英国(BBC)、西班牙(El Mundo)、法国(Les Echos)、美国(Washington Post)各准备一份受人尊敬的报纸来分散消息来源，并使用通配符作为布莱巴特，因为，嗯，它是布莱巴特。我无法分析文章文本本身(NewsAPI 似乎没有给我完整的文章)，所以我只对标题进行分析。

假说

我有两个目标:

获取所有报纸标题的总字数，看看它们是否都集中在某些话题上(假面舞会、死亡、医院等)。)
某些报纸标题是否平均具有积极或消极的倾向，作为它们是否诱导积极或消极情绪以吸引读者参与的(牵强)代理。

家政

在我给你看分析之前，有几点需要在这里说清楚:

a)有些标题只包含几个词(在有限的时间范围内)。对于任何一种 ML 技术(包括 NLP ),仅仅用几个数据点来提供结论性的证据要困难得多。

b)这些只是标题，其作用是吸引注意力，而不是表达观点。真正的感悟可以在文章本身找到。尽管如此，标题本身可以是负面的，以引起对文章的注意，所以对它的分析还是有一些价值的。

c)我的其他文章的读者会知道，我倾向于不从数据中得出太多的结论，而是让读者自己解决问题，所以我将在下面向您展示我的发现，我们可以在评论中讨论这些结论。

字数

我做的第一件事是计算 5 份报纸标题中使用的单词。它们都有一些有趣的地方:

数据来源:新闻宣传，英国广播公司

BBC:奇怪的是，印度是一个非常常见的词(也许印度有很大的读者群)，但忽略这一点，BBC 的主要观点似乎是对世界的封锁及其[影响]。

数据来源:新闻 API，华盛顿邮报

《华盛顿邮报》:测试似乎是这家报纸最常使用的词，也许是因为它的来源国(美国)的缘故，在美国，测试最近成了一个热门话题。

资料来源:新闻宣传，回声报

《回声报》:封锁是法国的大新闻，监禁是最热门的词。医院也占据首位，单词 cure 或 cured(复活)在词云(也适用于西班牙)中占据显著位置。

数据来源:新闻 API，世界报

《世界报》:如果我可以这么说的话,《世界报》有一点爱国倾向，因为它最常用的词是西班牙语中的西班牙。与其他报纸相比，masques 也成为一个热门话题，尽管这并不奇怪，因为它们已经成为世界范围内的一个重大瓶颈，特别是在西班牙(为了重新开放该国，西班牙决定向所有人发行它们)。

最好的留到最后…

数据来源:新闻 API:布莱巴特

e)布莱巴特:如果你知道布莱巴特代表什么，我想你不会对中文和墨西哥成为热门词汇感到惊讶。

这一切意味着什么？对于任何一份报纸来说，关键话题都是读者最有兴趣了解的。从愤世嫉俗的角度来看(更确切地说，是匆忙下结论)，这些话题反映了这些报纸的读者的偏见。对布莱巴特来说，这种偏见更加明显，但对像《世界报》这样的报纸来说可能不是(至少对我来说不是)。知道你我所阅读的报纸的偏见在哪里很好，这样我们就可以避免把自己进一步推入过滤泡沫。

情绪

现在让我们来看看，平均来说，是否有些报纸使用的标题包含了更消极的情绪，而另一些则更积极。

数据来源:新闻 API

上图显示了每份报纸所有标题的平均极性。范围从-1(负)到 1(正)，数字越大表示每个方向的极性越大。

我们真的不能在这里说太多，因为所有报纸的极性数字都很低。然而令我惊讶的是，两家欧洲(后英国退出欧盟时代)报纸似乎在标题上有负面倾向。也许这与他们的政治偏见有关，所以对此更了解的人可能会提供一些澄清。BBC 似乎是最中立的。更令人惊讶的是，布莱巴特对其标题的正面情绪相对较高，而《华盛顿邮报》是分析对象中最正面的。

这是什么意思？如果你是西班牙人，也许只阅读世界报的文章会让你对周围的一切都感到消极，所以多样化地阅读 BBC 上的西班牙文文章。再说一次，在这一点上我们不能下任何结论，上面的工作是为了满足我的无聊感，也是为了提供一些有用的信息。

客观性

最后，因为我用来做情感分析的 Python 库(TextBlob)也给出了标题的平均客观性，所以我想为什么现在也给你看这个。

数据来源:新闻 API

客观性的衡量标准与情感的衡量标准一样，1 代表客观工作，1 代表主观工作。换句话说，主观性越高、越积极，标题就越不客观。

没有一家报纸在客观性方面得分很高。《世界报》似乎是主观性最强的，而《回声报》是主观性最低的。

我不会走得太远，以至于说你应该忽略这些报纸中的任何一份，因为它们不符合事实，仅仅因为这些是正在被分析的标题，它们必须能够抓住你的注意力——它们天生就能引发情绪。

我想说的是，正如他们所说的，永远不要通过封面来判断一本书，永远不要通过标题来判断一篇文章，但要知道鉴于标题的性质，这篇文章是否可能引发负面情绪。如果这还不够复杂的话，也许，仅仅是也许，这能帮助你避免比我们现在经历的更多的悲伤。

任何意见，一如既往，非常感谢。

中型数据集

原文：https://towardsdatascience.com/the-medium-sized-dataset-632cf0f15bb6?source=collection_archive---------37-----------------------

对 RAM 来说太大，对集群来说太小。

马丁·桑切斯在 Unsplash 上的照片

小数据集很酷。你可以将它们加载到内存中并随意操作它们，不费吹灰之力。海量数据集也很酷。他们有大量的数据和令人兴奋的模型和分析的承诺。您很乐意支付所需集群的价格，只是为了处理所有这些优点。中等规模的数据集是一种痛苦。它们要么足够小，适合您的 RAM，但处理起来太麻烦，要么只是比您的内存大一点，但不值得集群成本。你如何处理这种情况？

有几种解决方案可以处理中型数据集，我最喜欢的是使用本地数据库。您可以将数据放在本地存储中，只将需要处理的内容放入内存中。一个古老但行之有效的解决方案。

我的常规设置是 Python 机器学习和数据分析生态系统支持的 Jupyter 笔记本。对于这样的环境，一个自然的本地数据库选择是 SQLite 。Python 发行版附带了该数据库的一个实现，该实现具有简单直观的 API。

在本文中，我用一个中等大小的车辆燃料和电能消耗数据集来说明这种用法，如上所述。

在我们继续之前，我建议您安装一个 SQLite 数据库编辑器，比如 SQLiteStudio 。在创建和检查数据集时，像这样的工具会让您的生活变得更加轻松，我发现它们的用处非常宝贵。

车辆能源数据集

2019 年，G. S. Oh、David J. Leblanc 和 Huei Peng 发表了一篇关于车辆能源数据集 (VED)的论文，其中包含一年的车辆轨迹和能源消耗数据。这些数据是从 2017 年 11 月至 2018 年 11 月在安阿伯收集的，参考了 383 辆不同类型和动力源的车辆样本。有关数据集及其内容的官方描述，请参见本文。

数据集从作者的 GitHub 存储库分发，由两个名为动态和静态数据的子集组成。前者包含所有收集的信号数据，而后者由两个 Microsoft Excel 文件组成，其中包含有关所研究车辆的信息。两个压缩文件包含整个动态数据集。

下面展示的所有代码都可以在本文的 GitHub 库中找到。

获取数据

要下载数据，我们可以简单地将存储库克隆到本地存储。这个过程很容易做到:

git clone [https://github.com/gsoh/VED.git](https://github.com/gsoh/VED.git) ./ved

克隆后，新创建的本地目录包含许可证文件、文档文件和包含两个数据集的数据目录。在继续之前，我们必须首先使用特定工具解压缩动态数据文件:

7z x ./ved/Data/VED_DynamicData_Part1.7z -o./data
7z x ./ved/Data/VED_DynamicData_Part2.7z -o./data

请注意，您可能必须安装适当的文件压缩工具，以上命令行才能工作。一旦完成，本地数据目录将有 55 个 CSV 文件和每周动态数据。我们现在可以读取它们并将其插入到 SQLite 数据库中。

你可以在附带的 GitHub 库中找到作为第一个 Jupyter 笔记本实现的下载和解压过程。

数据库

在使用它之前，我们必须首先通过提供的 Python API 创建 SQLite 数据库。为了使整个过程更简单、更易于管理，我创建了一个更高级别的类来与数据库交互。要访问它，您只需要实例化一个对象:

from sqlapi import VedDbdb = VedDb()

对象实例化在后台执行几个任务，比如打开数据库文件，如果它还不存在，就创建一个基线结构。该代码使用外部存储的 SQL 脚本创建数据库表和索引，如下所示，该脚本创建包含所有车辆的表。

CREATE TABLE vehicle (
    vehicle_id      INTEGER PRIMARY KEY ASC,
    vehicle_type    TEXT,
    vehicle_class   TEXT,
    engine          TEXT,
    transmission    TEXT,
    drive_wheels    TEXT,
    weight          FLOAT
);

外部 JSON 文件对这些文件的执行顺序进行编码。这种设置允许直接扩展 SQL 文件及其执行顺序。下面是撰写本文时 JSON 文件内容的一个示例:

{
  "sequence": ["tables", "indexes"],
  "tables": [
    "tables/vehicle.sql",
    "tables/signal.sql",
    "tables/move.sql"
  ],
  "indexes": [
    "indexes/idx_signal_vehicle_day_ts.sql",
    "indexes/idx_move_vehicle_day.sql"
  ]
}

“sequence”标记包含一个列表，其中列出了要按顺序执行的 JSON 标记的名称，因此在本例中，我们首先创建表，然后创建索引。“表”列表中的每个条目都是要执行的 SQL 脚本的相对路径。基路径是默认的构造函数参数。

数据库准备就绪后，我们可以开始从下载的 VED 数据文件导入数据。

导入数据

VED 动态数据保存在几个可管理的 CSV 文件中，因此我们可以一次一个地将它们读入 Pandas 数据帧，并将数据批量插入数据库。Pandas 库使得读取 CSV 文件变得非常容易，因此我们可以使用它来轻松地将数据读入内存。下面是这样做的代码(请参考 GitHub 库中的第二笔记本):

for file in tqdm(files):
    df = read_data_frame(file)

    signals = []
    for row in df.itertuples(index=False):
        signals.append(row)

    db.insert_signals(signals)

插入信号的函数也使用外部存储的 SQL 脚本。为了管理这些外部引用，我创建了一个类，它按需从存储中加载 SQL 脚本，并使用字典将它们存储在内存中。这种解决方案的优点是允许您在不更改 Python 代码的情况下更改 SQL 脚本，并且内存缓存意味着您在第一次加载文本文件时只会受到很小的性能影响。下一次对性能的影响几乎为零。该函数如下所示:

def insert_vehicles(self, vehicles):
    conn = self.connect()
    cur = conn.cursor()
    sql = self.sql_cache.get("vehicle/insert")
    cur.executemany(sql, vehicles)
    conn.commit()
    cur.close()
    conn.close()

正如您可能已经猜到的那样，脚本的键名是文件的相对路径名，不带扩展名。

同样的过程也适用于静态数据集，但是这次使用 Panda 的函数将 Excel 文件读入数据帧。

探索数据

为了说明如何使用 SQLite 接口探索数据集，让我们从分析生成数据的车辆类型开始。我们首先发出一个查询，并将结果存储在 Pandas 数据帧中:

vehicles = db.query_df("select * from vehicle")

将所有车辆数据加载到 DataFrame 后，我们可以使用标准查询方法来揭示数据结构:

vehicles.groupby(by='vehicle_type').count()

该命令产生以下输出:

车辆特征计数

我们还可以通过head和tail函数进行快速检查，如下所示:

db.head("select * from signal where vehicle_id = 10", rows=20)

跳闸检测

我们现在可以使用上面描述的简单工具进行一些更复杂和更深入的分析。数据集中高频位置数据的存在允许我们执行轨迹分析，以帮助表征车辆行为。检测已知停靠点之间的单个车辆行程通常是一个复杂的过程。幸运的是，我们很幸运拥有这个数据集，因为数据匿名化过程为我们提供了这个数据集。

VED 的数据收集流程通过一个相对简单的三步法确保了驱动程序的匿名化。这个过程被证明与这项研究非常相关，因为它产生了一个副产品，一条重要的信息:个性化的车辆轨迹。为了匿名化驾驶员信息，研究作者应用了随机模糊、地理围栏和主要交叉路口边界的技术。随机雾化方法移除行程开始和结束附近的观察位置。地理围栏技术在围绕城市边界定义的边界框之外裁剪观测值。作者还在第一个和最后一个重要的十字路口附近修剪了行程。除了驾驶员匿名化，这些程序还具有生成易于使用的个人轨迹的好处。

粗略检查之后，很容易意识到我们可以仅使用两个特征来识别行程，即“天数”和车辆标识符。让我们先计算一下不同车辆的行驶次数。

使用 SQL 查询计算车辆行驶次数。

数据集中有超过 32000 次旅行。知道了如何唯一地标识车辆行程，我们就可以创建一个包含每个行程的汇总信息的表。该表将证明其在迭代行程时作为信号表索引的有用性，并有助于汇总每辆车的行程。

数据库启动代码创建了一个名为“move”的额外表来存储每个旅行标识符。我们可以使用更复杂的查询来填充该表:

insert into move (vehicle_id, day_num, ts_ini, ts_end)
select    tt.vehicle_id
,         tt.day_num
,         ( select min(s1.time_stamp)
            from signal s1
            where s1.day_num = tt.day_num and
                  s1.vehicle_id = tt.vehicle_id
            ) as ts_ini
,         ( select max(s2.time_stamp)
            from signal s2
            where s2.day_num = tt.day_num and
                  s2.vehicle_id = tt.vehicle_id
            ) as ts_end
from (select distinct vehicle_id, day_num from signal) tt;

您可以尝试使用“查询”功能从笔记本中运行此操作，或者使用数据库接口对象中的现成快捷方式:

db.generate_moves()

这个函数说明了从 Python 代码中分离 SQL 脚本的原理。它首先通过 SQL 脚本缓存对象加载文本，然后执行它。结果是一个包含每辆车所有独特行程的表。如果我们需要检查一辆车的行程，我们可以使用简单的连接到信号表的查询来获取必要的详细信息。让我们用一张地图来说明这一点。

规划旅行

为了提取任意行程的地理信息，我们可以使用“移动”表作为“信号”表的选择器。

sql = """
select      s.latitude
,           s.longitude
from        signal s 
inner join  move m on m.vehicle_id = s.vehicle_id and 
                      m.day_num = s.day_num
where       m.move_id = 1
"""
locations = db.query(sql)

关于上面的代码，有两点需要注意。首先，我通过惟一的标识符选择了一个任意的旅程。更现实的情况是选择车辆和行程检查周期。其次，这个版本的查询函数返回一个元组列表，其顺序与 SQL 文本中声明的顺序相同。这种安排非常方便，因为我们可以立即将查询结果返回给所选择的地图对象，一个叶子折线。

tiles = "cartodbpositron"
map = folium.Map(prefer_canvas=True)
folium.TileLayer(tiles).add_to(map)color='#3388ff'
opacity=0.7lats = [l[0] for l in locations]
lons = [l[1] for l in locations]
min_lat, max_lat = min(lats), max(lats)
min_lon, max_lon = min(lons), max(lons)
map.fit_bounds([[min_lat, min_lon], [max_lat, max_lon]])polyline = PolyLine(locations, color=color, opacity=opacity)
polyline.add_to(map)

结果如下:

在交互式地图上绘制的车辆行程的地理位置。

摘要

在本文中，我展示了在管理中型数据集时，如何使用 SQLite 作为 Pandas 的部分替代方案。当 RAM 不足时，这种方法尤其实用。通过将熟悉的 Pandas API 与一点 SQL 混合，您可以对不适合您的主存的数据集执行令人信服的分析。

我将在本文之后对 VED 进行更深入的分析，因为它是一个如此有趣的数据集，将地理信息与车辆能源性能数据相结合。敬请关注即将发布的文章。

参考

[1] G. S. Oh，David J. Leblanc，Huei Peng。汽车能源数据集(VED)，用于汽车能耗研究的大规模数据集。

[2] GitHub 库

[3] SQLiteStudio

[## 使用 HDBSCAN 进行地理聚类

如何使用 HDBSCAN、H3、图论和 OSM 探索地理数据。

towardsdatascience.com](/geographic-clustering-with-hdbscan-ef8cb0ed6051) [## joo Paulo Figueira-数据科学家- tb.lx by 戴姆勒卡车和公共汽车| LinkedIn

查看 joo Paulo Figueira 在全球最大的职业社区 LinkedIn 上的个人资料。圣保罗列出了 1 份工作…

www.linkedin.com](https://www.linkedin.com/in/joao-paulo-figueira/)

真实世界数据的混乱:用逻辑函数追踪 COVID19 的生长因子。

原文：https://towardsdatascience.com/the-messiness-of-real-world-data-tracking-r0-of-covid19-with-logistic-function-31cb4d6edd98?source=collection_archive---------33-----------------------

TLDR:这是一个关于现实世界的数据如何不能很好地符合一个过于简单的模型的故事。又名:假设完美球形奶牛如何导致阴性结果。

认知状态:我对深度学习有足够的研究，知道它是一个数据饥渴的模型，我们没有足够的数据让 COVID19 把它当作一个时间序列。所以不妨拟合一条古老的逻辑曲线。鉴于我在流行病学方面完全缺乏能力，我写这篇文章时资格不足且过于固执己见。而我对此有证明: 勘误表: 我把 R0 误认为是生长因子，懒得去固定数字。如果这还不够免责声明的话，下面是来自编辑的样本版本:

编者注: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击这里。

球形奶牛。来源:http://www.cs.cmu.edu/~kmcrane/Projects/ModelRepository/

这个计划

计划很简单:

观看上面 3blue1brown 的指数增长和流行病。
了解 logistic 模型了解生长因子(来自视频)。
获取 COVID19 数据。
用一个逻辑模型来拟合它(查看附录中的数学公式)并追踪 r。
确认这适用于中国的数据(中国的数据已经接近逻辑曲线的平顶)
然后再外推到全世界的数据。
找出世界现在在逻辑曲线上的位置。
???
利润！

理论

第 1 部分到第 3 部分很简单。第 4 部分在理论上可行:

确诊病例(黑色)形成了一个很好的 s 形(或者 sigmoid，如果你想花哨一点的话)逻辑曲线。一阶导数(红色的每日新案例)形成了一条漂亮的钟形曲线(据我所知不是正态/高斯曲线)。生长因子(蓝色，使用右轴)平稳下降。当生长因子达到生长因子=1 标志(水平蓝色虚线)时，新病例数开始下降。我们可以将逻辑斯谛曲线分成 4 个部分，由 3 条垂直的绿线来划分，分别标记最大值、拐点和最小值。

是的，这里和那里有些不连续，因为我用的是离散方法(因为实际数据无论如何都是离散的)。但一般来说，这在理论上是行得通的。(曲线是垂直归一化的，因为我们并不真正关心实际值，而是更关心曲线的形状。)

中国

即使使用中国数据拟合逻辑模型，直到一阶导数，一切仍然相当好:

这个看起来很有前景！(除了第 50 天以后，好像每天的新增病例都在慢慢增加！这是令人恐惧的第二波浪潮的开始吗？).

(还有另外一个顾虑。数据太吻合了。有一些主要的干预措施，但一切看起来都像噪音(除了由于诊断定义的变化而在第 22 天左右突然出现的峰值)。中国做了很多干预，但为什么这些干预消失在噪音中，没有出现突然下降或类似的情况？干预没用吗？这是个奇怪的结论。无论如何，这是一个思考的食粮，不仅仅是这些数据，我之前有一个关于这个的博客，它来自许多不同的领域。我猜想这里只是另一个例子:是现实驱动了图上的直线，还是图上的直线驱动了现实？)

不幸的是，当得到完整的模型时，它是非常令人失望的。

生长因子没有明显的平稳下降。什么时候生长因子=1？好像一直都是！在二阶导数里找地标就更没希望了。也许我们需要一些平滑？因此，让我们不要从原始数据中获取这些值，而是从我们的逻辑模型中获取。

如果你仔细看，你会发现逻辑模型有某种适合度。例如，在第一季度末(第一条绿色垂直虚线)，与最后确诊病例的第 25 个百分位数(纯黑色)非常吻合。第二季度(第二条绿色垂直虚线)也与最终确诊病例的第 50 百分位非常吻合，也与逻辑增长因子降至 1 以下的时间相吻合。由于第 22 天的异常(新的诊断定义)，第 3 季度出现偏差，低估了约 12.5 个百分点。

世界

一不做，二不休。第五步失败了，不如完成它。由于简单的逻辑模型有点可疑，让我们看看世界的曲线。

不出所料，数据是嘈杂的。无论如何，事情看起来并不乐观。一阶导数仍在上升，尤其是从第 30 天开始。这意味着，我们仍处于疫情的前半部分。粗略计算，我们预计目前确诊病例至少会增加一倍，死亡人数也会增加。尽管进一步的干预可能会改变一些事情。我真的很高兴全世界的人们都在为此努力。让我们关注那条红色曲线。

我认为我们可以怀疑增长因素正在放缓和变平。如果这是真的，至少我们已经走了四分之一的路，如果不是刚刚通过的话。请注意，当谈到确诊病例/死亡的天数或数量时，这不是季度。就曲线形状而言，只有四分之一。(这是一种奇怪的平滑曲线和可视化的方式，但我认为它有点整洁，所以它在这里。)

似乎二阶导数也在讲述同样的故事。它变平了。(日志看起来几乎相同。)

最后是成长因素。总的来说，它在下降。现在肯定比第 35 天到第 45 天的时候低。它还没有触及增长因子=1 的关口，这表明我们还没有超过第二季度。

定论

通常，我会把它放在 TLDR。但是，由于这些数据非常嘈杂，我的方法也非常简单，我认为，如果不大声疾呼:“这只是为了好玩！”就得出任何有意义的结论都是轻率的。所以我就把它放在这里，只是为了阅读到底俱乐部。免责声明:“无论如何，不要以此为基础做出任何社会/医疗/财务/任何决定”。外面有更多合格的人，听他们的。

如果我们真的在第一季度左右，或者就在第一季度之前，那么我们可以预计事情很快就会变得非常糟糕。看起来病例数量会有一个爆炸，每天都会有一个新的记录。这很糟糕，因为，对于不了解情况的人来说，事情看起来和感觉上都失去了控制，看不到尽头。只是一个指数增长等待感染地球上的 100%。作为一个社会，我们能挺过这个阶段是很重要的。

我喜欢人们传播“平坦曲线”的方式，这也是设定预期的双重作用。以任何标准衡量，COVID19 都是一场灾难。如果我们，作为一个社会，盲目地走进它，感觉会更糟。而感觉是重要的，因为感觉决定了骚乱和社会结构的崩溃，以及法律和秩序是否会发生。但是如果我们知道将要发生什么，即使是一场灾难，我们至少可以振作起来。

过一段时间，也许几周，也许几个月，我们会看到第二季度，新病例开始下降。很难确定这是真的，还是只是数据的暂时下降。只有再过几个星期，噪音才会平息，我们才能确认情况正在好转，记录不再被打破。死亡人数滞后几周，但很快就会跟上。

从情感上来说，即使我们还在半路上，也会感觉一切都快结束了，因为事情正在变好，隧道的尽头有一线光明。重要的是，如果我们保持警惕，情况只会继续好转。如果我们在那个时候放松自己，事情会再次变得更糟。

尽管说了这么多。这可能只是第一波。第二波可能会到来，就像西班牙流感一样。最重要的是，我听说专家们有目的地设计了多种波，因为另一种选择是永远锁定，永远不要用回归常态的计划来建立群体免疫。

这将是一次长途旅行，系好安全带。

附录

查看我的代码:https://colab . research . Google . com/drive/1 wfv 0 pqdwalfn 5n 9 bewnuvwptdjxbq 6 KF

对于中国，我假设 L =最新的数字+1，所以我们不会有 log(0)的问题。我不知道对这个世界来说什么是假设 L 的好方法。

参考文献和致谢

数据来自:【https://github.com/CSSEGISandData/COVID-19

所有图像属于我，除非在标题中另有说明。

微软数据和应用科学家访谈

原文：https://towardsdatascience.com/the-microsoft-data-and-applied-scientist-interview-c0e2b77593dd?source=collection_archive---------16-----------------------

微软数据科学访谈和一般访谈的流程、问题和关键概念指南

在Unsplash【1】上由 Franck V. 拍摄的照片。

介绍

这篇文章的目的是给你更多的自信和洞察力，为你在微软的下一次面试做准备。这个指南也适用于类似的大型科技公司，如脸书和苹果。

我将讨论微软高级数据和应用数据科学家的角色和面试流程。

我采访了许多公司，过了一段时间，正如我所料，我开始看到一种趋势，即它们是如何被安排和执行的。招聘人员、面试官和公司不仅仅想要一个会编程的人，还想要一个能向非技术人员解释结果的人。我还想强调，有不同的角色，如数据科学家、应用科学家，以及我将要写的内容:数据和应用科学家。除了特定的科学家角色之外，还有级别，包括通常的头衔、高级和校长。在其他公司，你可能会看到像助理和职员这样的角色。我在微软面试中的经历很棒，我会向任何感兴趣的人推荐这个职位。

我特别喜欢听特定团队的意见。在这个职位上，对文化和多样性的关注是一个非常吸引人的因素。

在这篇文章中，我将详细介绍整个过程，以及你在面试中可能会遇到的一些问题(或类似的问题)。最后，我想强调的是，这篇文章的目的是最终帮助你在微软或其他类似的大型科技公司面试。我真的相信，作为一个数据科学社区，我们应该相互学习，帮助每个人尽可能做到最好。就像面试官最终会让你知道一样(或者我希望如此)，开放和善于学习比被提问更有价值。下面，了解从申请到最终面试的整个过程、问题和概念，以及对您的高级数据和应用科学家面试之旅的建议。

过程

照片由视觉效果在Unsplash【2】上拍摄。

整个面试过程出奇的简单。申请之后(希望如此)，你会收到招聘人员的电子邮件或电话，在那里你必须提交一份更新的简历和为什么你适合微软的信息。如果你在这一点上有所进展，你将有 30-45 分钟的电话时间与经理讨论为什么你认为你是这个职位的合适人选，以及你对此感兴趣的地方。你会希望专注于做你自己，了解你的过去，以及这个角色，甚至是微软公司。

这通电话将包括一些技术对话，但下一次面试是你在一轮四位面试官中展示你的技能的时候(通常是面对面，但这次可能是通过视频会议)。这一步实际上是最后的面试，但需要大约四个小时，由协调员安排。这一天面试最重要的部分是了解机器学习算法的关键概念和例子。

While coding is greatly used in these types of data science roles, it is arguably more important that you know the theory and point of an algorithm in data science over Python, R, or SQL code.

即使是在同一家公司，每次面试的流程很可能都不一样，但流程是一样的。这将需要您之前通过电话交谈的同一位经理，主要是行为方面的，一个人提出的更深入的数据科学算法问题，一个案例研究，然后是对您的数据科学知识的总体最终总结。

以下是典型面试流程的概要:

申请这个职位

通过电话或电子邮件听取反馈

通过电子邮件或电话提交筛选答案

初次电话经理面试

与团队进行四轮面谈(或最有可能是视频会议)

问题

由劳拉·法尔在Unsplash【3】上拍摄的照片。

以下问题不是确切的问题，但很可能是你将会遇到的确切问题(因为它们被改变了——但遵循类似的格式)。这里的主题是什么是关键。如果你现在就能自信地回答这些问题，那么你可以期待总体表现良好。回答问题时，请记住，暂停并思考整个过程是可以的，因为这将显示问题的解决方法和听起来不像记忆的答案。以下是你需要知道的六个问题:

1。向非技术用户解释机器学习算法

2。回顾你在工作中发生冲突的时候

3。给出机器学习流水线的例子

4。解释梯度下降

5。描述降维

6。提供一个时间序列的例子

最好从商业角度考虑你的答案。虽然机器学习模型获得 95%的准确率令人印象深刻，但如果你能向业务用户或利益相关者解释这将为公司节省多少资金，以及你能在多大程度上自动化否则手动的过程，那就更令人印象深刻了。了解常见的数据科学算法，如无监督与有监督，以及时间序列和计算机视觉将是有用的。最后，掌握 sklearn 和 TensowFlow 等常见 Python 库的工作知识也将有助于让您脱颖而出。除了问题和技能之外，还有一些关键的概念将会在你的面试中讨论，如下所述。

概念

在Unsplash【4】上由 Hitesh Choudhary 拍摄的照片。

虽然具体问题或关键问题有助于回顾，但将这些概念应用到你的面试中也是有益的。总之，你会想通过在你的回答或讨论中加入职位的部门或微软产品来很好地了解这个角色。你也想让他们知道你不知道的事情；不要漫无边际地谈论你不清楚的事情，或者作为一种解决方案，可以建议一个类似的例子及其各自的解释。此外，当你用例子来解释一个答案时，不要一遍又一遍地用同一个例子，因为这表明你没有太多的经验(即使你有)。最后，尽管角色的描述主要描述了数据科学和以机器学习为中心的技能，但请记住要知道深度学习的关键部分，以及它与传统算法的不同之处。关注以下四个概念:

整合微软产品
让面试官知道你不知道的事情
尽量不要反复使用同一个例子
深度学习

了解数据科学的基本概念以及它们如何应用于微软及其用户，将是你面试过程中令人印象深刻的一条路线。回顾企业的总体运作方式将是有益的——如果你能提供如何将你的模型整合到一个已经存在的系统中会更好——团队将如何工作，以及最终会出现什么缺点。

测试你的模型是数据科学家可能忘记练习的事情。

不是指在数据集上测试您的模型，而是在生产中测试您的模型，以了解它的工作原理、速度、使用的存储空间，以及总体而言，它可能存在的限制。从头到尾了解整个过程，会让你作为候选人脱颖而出。

检索数据、清理和转换数据、构建基础模型、二级和三级模型(等等)，以及最终用户的最终产品是一个您应该熟悉并且能够自信地解释的完整过程。谈论你的 Jupyter 笔记本是件好事，但是阐述面向对象编程将是向面试官炫耀的另一个加分项。向团队展示你是如何创造的。py 文件不仅可以轻松编译并与其他数据科学家共享，还可以与其他与您的模型交互的专业人员共享，如软件工程师、机器学习工程师和数据工程师，这将是一个很好的概念。

摘要

虽然在面试前你可能有数百个问题和文章要看，但最终，你还是想向面试官展示你解释答案的信心。

如果你提供清晰、正确、自信的解释，让面试官对你的回答感到满意，你就更有可能被录用。

请记住，这个概述是针对高级职位的，更具体地说，是针对数据和应用科学家角色的。除了一般职位和非数据科学职位的面试之外，非高级职位以及数据科学家和应用科学家职位很可能会有类似的情况。

The common roles are: data scientist, applied scientist, and data and applied scientist.

就像具体的角色和部门会有所不同一样，面试你的团队也会有所不同。类似于数据科学模型，您将希望赢得团队的大多数投票来赢得面试。面试过程的另一个重要方面不仅是编码和技术评估，还有行为评估。将你的讨论集中在文化和多样性上是很重要的；找到微软或类似公司的支柱，了解他们的声明，它如何适用于你，以及它对你意味着什么。最后，保持你的简历简单:你做了什么，它如何帮助业务，结果是什么。例如，在一个项目中，你可以说:我开发了一个决策树模型，它帮助手工过程自动化了 50%。

我不能保证如果你遵循所有这些步骤，你会得到这份工作，但我相信如果你已经在微软学习数据科学，你会很快得到这份工作。我希望你对这篇文章感兴趣，尤其是对你未来的面试有用。感谢您的阅读！

参考

[1]Franck v .在 Unsplash 上拍摄的照片，(2020)

[2]图片由视觉效果在Unsplash(2020)上拍摄

[3]照片由 Lara Far 在 Unsplash 上拍摄，(2019)

[4]照片由 Hitesh Choudhary 在 Unsplash 上拍摄，(2018)

强大的 GPT 3 号

原文：https://towardsdatascience.com/the-mighty-gpt-3-1cb6ee477932?source=collection_archive---------26-----------------------

探索当今最强大的人工智能之一的能力——这太神奇了

来源

欢迎我可爱的读者！这篇文章的目标是简要解释什么是 GPT-3，然后展示一系列例子来突出它作为通用自然语言处理人工智能的潜力。

其中一些例子真的很神奇，有几个接近可怕，所以我鼓励你继续阅读，如果你真的想享受自己，看看人工智能可能达到的范围。

然而，在探索 GPT 3 是关于什么的之前，我想让你看看下面这个来自钢铁侠电影之一的视频，其中托尼·斯塔克公开而广泛地与他创造的虚拟助手贾维斯交谈。

在这个短视频中，你可以看到贾维斯能够与斯塔克就任何话题进行互动，与他进行完全像人类一样的对话，回答问题，甚至帮助他进行研究。

据目前所知，人工智能在非常有限的特定领域任务中表现出色:在图灵测试、中愚弄人类，进行情感分析、击败国际象棋世界冠军，或者总结文本。

尽管这些成就可能令人印象深刻，但执行每项任务的软件都是专门为该任务构建的，心中只有该目标，并经过微调，以在某些特定条件下提供良好的结果。

他们与我们所说的 人工通用智能 (AGI) 相去甚远，后者是一种能够在广泛的任务上表现相当好的人工智能:有点像《钢铁侠》中的贾维斯。

GPT 3 可能是我们见过的最接近这一点的东西，尽管不是 AGI，但它在各种各样的自然语言处理(NLP)相关任务上的表现令人惊讶。

《100 页机器学习书》的作者安德烈·布尔科夫的推文。

在这个简短的介绍之后，让我们真正看看 GPT-3 是怎么回事。

什么是 GPT-3？

2020 年 7 月 OpenAI ，最初由埃隆·马斯克等人资助的人工智能公司发表了一篇论文 【语言模型是很少被使用的学习者】 ，这意味着对上一年的 GPT-2 模型家族进行升级，引入了新的、大肆宣传的、更强大的模型:GPT-3。

这些模型家族是神经 语言模型 ，这意味着它们被训练试图预测句子中缺失的或下一个单词，就像来自你手机或谷歌搜索栏的自动补全。

可以从文本语料库中以无人监督的方式训练语言模型(不需要向模型提供一组带有句子标签的数据，以及实际丢失的单词)，方法是从文本的其余部分中删除句子中的一个单词，并尝试使用剩余的部分来预测它。

你可以在下面的链接中找到一些关于 GPT 3 号具体情况下这是如何工作的令人敬畏的可视化效果:

[## GPT3 如何工作——可视化和动画

(Live thread，将在未来几天内更新新的视觉效果并进行润色。加入邮件列表以获得更新…

jalammar.github.io](https://jalammar.github.io/how-gpt3-works-visualizations-animations/)

在这种预训练之后，产生的 NLP 模型通常会针对手边的特定任务(例如文本翻译)进行微调，这意味着必须收集特定任务的标记数据，并且总是需要进行后续的第二次训练。

有了 GPT-3，这种为特定任务进行事后训练的需要被消除了，这在很多时候变得不必要，而仅仅通过这种预训练而没有进一步微调，仍然在各种各样的任务上取得惊人的性能。

好了，现在我们对 GPT-3 有了一点了解，让我们来看看 GPT-3 的一些不同用法的例子，它们会让你惊讶不已。

例子:GPT-3 在行动

GPT-3 编码

我们将首先看到一些从 Twitter 社区收集的关于 GPT-3 生成代码的例子。Sharif Shameen 的以下推文在展示了如何通过给 GPT-3 API 一些简单的指令，它可以根据这些指令生成代码后，已经迅速传播开来。

此外，看看 GPT-3 如何通过几条指令和数据集的描述来生成代码，以建立一个机器学习模型。

看到这里后，你可能会问自己:

“GPT-3 会取代程序员吗？”

现在下结论还为时过早，因为这些新模型刚刚问世，还没有人尝试过用它们来构建更复杂的应用程序，但是，对于相对简单的任务，比如上面的那些，它们似乎工作得相当好。

GPT-3 用几个要点写电子邮件

在下面的例子中，GPT-3 收到了一封输入邮件和一些回复邮件的要点，并写了一个完整、优雅的回复文本。

有了这样的例子，我们可以看到 GPT-3 是多么多才多艺:从编码到根据要点生成电子邮件。它会很快成为我们日常生活的一部分，被用来简化和自动化流程吗？

使用推理问题与 GPT 3 对话

让我们看另一个例子。以下是一位用户与 GPT 3 号的对话，此前它只给出了准确回答所有问题的指令。看看对话是如何流畅的，与人类的对话完全没有区别。

与 GPT 的推理对话-3。来源。

看起来我们的朋友 GPT-3 可以毫无问题地欺骗人类，让他们以为它是人类，从而通过机器智能的图灵测试。

GPT-3 写创造性的小说

继续，让我们根据一些指导方针来探索 GPT 3 写作小说:非真实文本的一些努力。首先，让我们看看当被告知以过去著名作家欧内斯特·海明威的风格写一篇对著名的《哈利·波特》系列的滑稽模仿时，它会做什么。

“女贞路那天很冷。一个孩子哭了。哈利什么也没感觉到。他比灰尘还干。他已经沉默太久了。他没有感受到爱。他几乎不觉得讨厌。然而摄魂怪的吻没有杀死任何东西。死亡并没有让他少死一秒钟。这真的不是生或死的问题。这与死亡无关。这是关于黑魔王，他的创造者，他的诞生。他没有复活。他又被创造了。他在马尔福庄园的院子里又完整了”

你可以在这里找到这篇文章的出处，以及许多其他的例子。

[## GPT-3 创意小说

我用 OpenAI 的 2020 GPT-3 继续我的人工智能诗歌生成实验，它是 116 倍大，也更强大…

www.gwern.net](https://www.gwern.net/GPT-3)

让我们多看一些。GPT-3 可以比这更进一步，可以解释为什么一个笑话是一个笑话。当被告知:’解释以下笑话中的双关语:成年游泳者称他们的实体零售店为什么？《布里克和莫蒂》，参考了著名的成人游泳节目《瑞克和莫蒂》，《GPT 3》给出了以下近乎完美的解释:

… 双关语“Brick and Morty”暗指有线电视网络“成人游泳”，该网络播放一部名为“rick and Morty”的漫画系列，是对“回到未来”和其他科幻电影的幽默恶搞。“砖头和毛蒂”不是指漫画中的人物，而是指出售基于漫画的 DVD 和商品的实体店。这个双关语融合了“砖和砂浆”的两个意思，一个是实体商店，一个是建筑的一部分。

最后，让我们看一篇由 GPT-3 创建的新闻文章，给出标题和副标题:

GPT-3 生成的新闻文章。来源。

印象深刻吧？

看到和贾维斯的相似之处了？尽管还没有完全实现(在我们能够实现足够、容错和安全的 AGI 之前，还有很多工作要做)，但我认为这是我们最接近的东西，实现人工通用智能的工作应该遵循 GPT 3 号规划的道路。

最后，我会给你们留下一个视频，其中有一些其他很酷的例子的汇编，关于 GPT-3 能做什么，以防你们想更深入地了解这个奇妙的新模型家族。

结论和更多资源

就是这样！一如既往，我希望你喜欢这篇文章，并且我设法帮助你更多地了解了 GPT 3 号，希望你和我一样对它的威力印象深刻。

这篇文章的目的是简要描述这个模型，然后展示许多例子来突出它的潜力，但是，我将很快发表另一篇文章来解释所有的技术细节、功能和弱点，所以敬请关注！

在这里你可以找到一些额外的资源，如果你想了解更多关于这个话题。

如果你想了解更多关于机器学习和人工智能的知识 关注我上媒 ，敬请关注我的下期帖子！另外，你可以查看 这个资源库 来获得更多关于机器学习和人工智能的资源！

JupyterLab 键盘快捷键的缺失列表

原文：https://towardsdatascience.com/the-missing-list-of-jupyterlab-keyboard-shortcuts-c613ff711a20?source=collection_archive---------33-----------------------

笔记本电脑的常用键盘快捷键

JupyterLab 太棒了。它几乎拥有数据科学家想要的一切。

选项卡式窗口✅
拆分窗口✅
jupyter 笔记本
文件浏览器✅
降价文件预览✅
有益的扩展✅
小部件功能✅
编辑。csv 文件✅
✅终端窗口
Python 脚本✅
以多种格式出口笔记本电脑✅
有益的教程✅

我发现它只缺少一样东西——键盘快捷键列表。☹️

资料来源:pixabay.com

有了键盘快捷键，你就可以在 JupyterLab 里快速浏览 Jupyter 笔记本了。您可以节省时间，减少使用鼠标造成的手腕疲劳，并给朋友留下深刻印象。🙂

下面是我制作的 GitHub Gist 中缺少的常见 JupyterLab 键盘快捷键列表。尽情享受吧！🎉

来源:https://gist . github . com/disc diver/9e 00618756d 120 A8 C9 fa 344 ac1c 375 AC

如果你想创建自己的 JupyterLab 快捷方式，我在这里写了一个指南。🚀

我写关于 Python 、 SQL 、 Docker 和其他技术主题的文章。如果你对这些感兴趣，请注册我的邮件列表，那里有很棒的数据科学资源，点击这里阅读更多内容，帮助你提高技能。👍

祝快乐！🎉

“任意尺度”时空分析的缺失部分

原文：https://towardsdatascience.com/the-missing-piece-towards-any-scale-spatial-temporal-analytics-2677063d95e3?source=collection_archive---------76-----------------------

现实世界中的数据科学

我们为什么创建 Arctern 项目

由希德·维尔马在 Unsplash 上拍摄的照片

物联网(IoT)和 5G 技术将涉及数量惊人的数据，记录人、设备、事件、位置和时间之间的联系。根据 IDC 的预测，2025 年将有 416 亿个物联网设备产生 79.4 zettabytes 的数据。随着物联网数据和物联网应用的快速增长，对高效时空数据科学工作流的需求不断增加，以从海量数据中获得洞察力。

可扩展性是构建高效数据科学管道的关键。为了应对这一可扩展性挑战，我们推出了 Arctern，这是一个开源时空分析框架，用于提高端到端数据科学性能。Arctern 旨在从两个方面提高可扩展性:

跨不同平台(从笔记本电脑到集群和云)的统一数据分析和处理界面；
丰富且一致的算法和模型，包括轨迹处理、空间聚类和回归等。，跨越不同的数据科学管道阶段。

本文的其余部分探讨了当前的地理空间数据科学管道，并回顾了每个阶段使用的工具、库和系统。通过讨论现有工作流的不足，我们强调了可伸缩性的重要性。我们将展示良好的界面、算法和模型不仅可以减少解决数学或技术问题的时间，还可以提高数据科学家和工程师之间的协作和沟通效率。

时空数据科学工作流概述

作者图片

为了更好地理解当前工作流中存在的可扩展性问题，我们需要看一下时空数据科学的管道，如上图所示。原始数据首先由物联网设备生成，然后由数据存储收集。数据科学家对这些数据进行探索性分析。基于技术假设和数据特征，他们选择合适的模型来开发回答业务问题的原型。经过几次反复的评估和调整，该模型最终将部署在一个数据处理系统上，该系统进而通过物联网设备向最终用户提供更好的服务。

整个过程可以分为三个阶段:

原型开发。在这一阶段，数据科学家倾向于使用小型数据集，以实现快速数据探索、高效模型选择和迭代原型润色。轻量级工具在这个阶段受到青睐，因为它们可以提供快速的洞察力，并支持快速迭代。典型的工具包括 NumPy、GeoPandas、scikit-learn、PySAL 和 kepler.gl。
车型评测。为了使原型适合生产环境，更大(甚至接近生产水平)的数据集被用于模型评估。因此，这个阶段的模型评估-修改迭代比原型阶段要敏捷得多。此外，工具链要重得多。大多数常用的工具，比如 PostGIS 和 PySpark，都是基于磁盘的，或者说是分布式的。
车型部署。部署是将模型集成到现有生产环境中提供实际服务的阶段。这一阶段涉及大规模系统，如用于存储的 HDFS、Hbase、TSDB，以及用于数据处理的 Spark、Flink、GeoMesa。

可扩展性问题

在时空数据科学的不同阶段，对工具链的需求差异很大。虽然上面提到的库和系统可以共同支持整个数据科学工作流，但单个工具很难跨多个数据科学阶段或跨不同的分析平台(笔记本电脑、集群或云)扩展。结果，工具链变得越来越复杂，以至于很难简化工作流程。具体来说，挑战有三个方面:

库(系统)接口的差距。不同阶段使用的库或系统不共享统一接口。因此，数据科学家可能会在数据分析、原型开发、模型评估和模型部署的整个过程中使用多种语言，如 Python、R、Scala、SQL 和不一致的函数名称。这种接口不一致性极大地加剧了学习曲线，迫使数据科学家花费宝贵的时间和脑力来重写他们的代码，而不是专注于业务问题。
算法/模型库的差距。不同阶段使用的库对算法和模型的支持不同。目前，标准化协议仍处于原语级别，如开放地理空间联盟(OGC)提出的协议。这大大降低了生产率。当在原型开发期间使用高级算法作为解决方案的一部分，但没有为生产环境找到合适的实现时，必须付出巨大的努力来重新发明轮子。
数据科学家和工程师的差距。时空数据科学是一个复杂的领域，需要正确处理数学问题、技术问题和商业问题。它需要数据科学家和工程师之间的无缝协作。然而，整个工作流程中使用的工具的不一致性使得协作变得困难。鉴于在不同的数据科学阶段使用不同的编程语言和算法实现，工程师可能不知道数据科学家使用什么模型，而数据科学家正在努力理解为什么工程师不能让他们的模型工作。

在接下来的几节中，我们将比较时空数据科学中广泛使用的几个库和系统，并对“任意比例”时空分析中缺失的部分进行更多讨论。

流行工具及其局限性

随着 Python 成为地理空间数据处理和分析的主要解决方案，数据科学家开发了基于工具集的词汇表，包括 NumPy、Pandas、Shapely、GeoPandas、PySAL 等。有了这些工具，他们可以充分表达自己的想法，并根据想法得出结论。

Shapely 是一个 Python 包，提供了几何数据构造、常见几何操作、关系分析和坐标系投影等原语。GeoPandas 结合了 Pandas 和 Shapely 的功能，简化了 python 中的地理空间数据处理。它将地理空间数据组织为地理系列或地理数据框，并提供构建、分析和操作多种几何的操作。

PySAL 是一个 Python 空间分析库，为地理空间数据的高级分析提供模块。其功能包括空间数据探索性分析，如对点、多边形格的统计测试，以及高级空间分析，如空间聚类和空间回归。

尽管这些工具很受欢迎，但它们无法处理大数据。它们本来就是为独立机器上的小数据集设计的。考虑到现代笔记本电脑和工作站的容量，这些工具可以处理的数据量将高达几个千兆字节。下图显示了 GeoPandas 中 19 种常用原语的性能。正如我们所观察到的，当数据大小达到 10M 时，GeoPandas 中的大多数原语需要几分钟才能完成。在处理大型数据集时，PySAL 与 GeoPandas 面临同样的问题。与 GeoPandas 中的原语相比，PySAL 中的高级算法通常具有更高的计算复杂度，从而可能导致更严重的数据分析和原型开发效率问题。由于数据科学家需要迭代地调整和验证他们的模型，直到他们得到满意的结果，这些原语和算法被频繁和重复地使用。可扩展性问题会严重降低空间数据科学工作流的效率。

由于可扩展性问题，上述工具一般用于小数据集的原型设计。为了处理大型生产级数据集，数据科学家和工程师最终需要将他们的算法迁移到分布式解决方案，如 GeoSpark 和 GeoMesa。

GeoSpark 是一个集群计算系统，它通过一组空间弹性分布式数据集和 SpatialSQL 函数扩展了 Apache Spark 和 SparkSQL，这些数据集和函数可以跨机器有效地加载、处理和分析大规模空间数据。GeoMesa 支持分布式计算系统上的大规模地理空间查询和分析，包括时空索引、流处理和自定义分布式分析。

与 GeoPandas 和 PySAL 相比，GeoSpark 和 GeoMesa 采用了非常不同的 API 抽象。上表显示了界面对比。不同工具之间的数据接口差别很大，没有一对工具共享相同的数据接口。编程语言方面，主要有三大类:python、SQL、Java/Scala。

上表比较了地理空间分析工具中提供的原语和算法。所支持的 OGC 标准原语的数量差异很大，从大约 30 个到 300 个不等。高级算法也显示出很大的分歧。每种工具都提供了一组有限的算法，几乎没有重叠。

由于数据接口、编程语言、算法和模型的显著不一致性，每当将模型原型应用于大型生产数据集时，工程师可能必须重写整个数据处理逻辑。对于空间聚类和回归等高级分析，数据科学家可能需要从头开始重新实施模型和算法。

Arctern 的方法和目前的进展

在 Arctern 中，为了帮助数据科学家和工程师提高生产力和创造力，我们试图通过在笔记本电脑、集群和云环境中提供具有一致接口的丰富原语、算法和模型来解决空间数据科学工具的不一致性问题。

在我们研究的工具中，我们发现 GeoPandas 的接口最符合 data scientist 的使用习惯，并且易于使用。因此，我们采纳了它的想法，并计划构建可纵向扩展和横向扩展的地理数据框架/地理系列。在此基础上，我们将开发跨执行环境的一致的时空算法集。

我们现在已经开发了一个高效的多线程 GeoSeries 实现，分布式版本正在开发中。在最新版本 0.2.0 中，与 GeoPandas 相比，Arctern 的速度提高了 24 倍。即使在单线程执行的情况下，Arctern 的平均性能也是 GeoPandas 的 7 倍。详细的评估结果如下图所示。

在大型数据集的交互/探索方面，Arctern 提供了可以渲染数据的渲染方法(如热图、choropleth 等。)以秒为单位 10M 的成交量。

我们还在进行时空数据分析和渲染的实验性 GPU 加速。到目前为止，Arctern 提供了六种 GPU 加速的渲染方法和八种空间关系操作，比基于 CPU 的方法提高了 36 倍。

在接下来的几个版本中，我们的团队将专注于:

开发 GeoSeries 的分布式版本。我们第一个地理数据框架/地理系列的分布式实现将基于 Spark。自从 Spark 3.0 预览版发布以来，它就与 Spark 3.0 同步开发。Spark 对 GPU 调度和基于列的处理的支持，与我们高性能时空数据处理的理念高度契合。此外，引入的考拉接口为实现一致的地理数据框架/地理系列接口提供了一个有前途的选择。
丰富了我们的时空算法集。在项目的早期阶段，我们将专注于 KNN 搜索和轨迹分析。

了解更多关于 Arctern:https://github.com/arctern-io

关于作者

郭仁同是 Arctern 项目的研发主管。他获得了中国华中科技大学(HUST)的计算机软件和理论博士学位。他参与并领导数据库、缓存系统、分布式系统和异构计算领域的项目。

易(音译)是 Arctern 项目的高级研究员。易先生毕业于华中科技大学，获得计算机体系结构博士学位。他的研究重点是云和分布式系统中的调度和资源分配。他的作品发表在著名的会议和期刊上，如 IEEE Network Magazine、IEEE TON、IEEE ICDCS 和 ACM TOMPECS。

攀登熊猫的摩登观点

原文：https://towardsdatascience.com/the-modin-view-of-scaling-pandas-825215533122?source=collection_archive---------27-----------------------

将摩丁与达斯克、雷、瓦克斯和拉皮兹进行比较

最近，写了一篇博文，比较了一组工具中的各种工具。我想借此机会与摩丁谈论我们的愿景，以及我们希望将数据科学领域带向何方。

https://github.com/modin-project/modin·莫丁()对系统应该如何构建持不同观点。 Modin 旨在提高数据科学家的工作效率。当我在加州大学伯克利分校 RISELab 做博士生时，我注意到一个危险的趋势:数据科学工具在构建时考虑到了硬件性能，但变得越来越复杂。这种复杂性和性能负担被推给了数据科学家。这些工具以数据科学家的时间为代价来优化处理器时间。

这种趋势对数据科学的整体领域是有害的:我们不想强迫每个数据科学家成为分布式系统专家，或者要求他们理解底层实现细节，以避免受到性能的惩罚。通过将数据科学家的时间优先于硬件时间，Modin 正在颠覆数据科学工具领域。为此，摩丁已经:

学习新的 API 没有前期成本
与 Python 生态系统的集成
与 Ray/Dask 集群集成(在您现有的设备上运行！)

摩丁开始是作为熊猫的替代者，因为那是我们看到最大需求的地方。使用 Modin 就像使用pip install modin[ray]或pip install modin[dask]一样简单，然后更改导入语句:

# import pandas as pd
import modin.pandas as pd

摩丁正在演变成不仅仅是熊猫的替代品(试试最新版本 0.7.4 )，我将在本文稍后讨论这一点。首先，我想对 Modin 和其他库做一个更详细的比较，因为许多比较经常遗漏了关键信息。

这些系统旨在解决不同的问题，因此公平的比较具有挑战性。我会尽量坚持定性属性，以避免偏见。

Dask Dataframe vs. Modin

由于底层系统的架构，dask data frame(【https://github.com/dask/dask】T2)覆盖了大约 40%的 Pandas API。Dask Dataframe 是一个行存储，就像它之前的许多 SQL 系统一样。然而，数据帧不是 SQL 表。这种架构允许 Dask Dataframe 非常好地扩展，但是阻止它支持所有的 Pandas APIs。Dask Dataframe 还要求用户在数据科学工作负载中添加.compute()或.persist()调用，以便在触发计算时进行管理。用户还需要指定分区的数量。 Dask 更加成熟，自首次提交以来已有> 5 年。

摩丁目前覆盖了熊猫 API 的 80%以上。Modin 被设计为一个灵活的列存储，因此 Modin 中的分区可以根据需要计算的操作进行更改。这使得 Modin 可以扩展严格的列或行存储所不能扩展的算法。Modin 也不会给用户带来任何计算或分区负担。对用户查询的优化是在幕后运行的，不需要用户的输入。自第一次提交以来，两年的时间里，摩丁仍处于婴儿期。

Modin 与 Dask 的调度 API 集成，因此 Modin 也可以在 Dask 集群上运行。这里有更多关于这种比较的信息。

Vaex vs. Modin

vaex(https://github.com/vaexio/vaex)是一个基于 HDF5 和 Arrow 内存映射文件的查询引擎，所以如果你的数据已经是 HDF5 格式，它是一个可靠的选择。从其他文件格式(CSV、JSON、Parquet)转换为 Vaex 兼容格式需要大量的计算时间和磁盘空间。Vaex 可以支持大约 35%的 Pandas API，但不支持关键的 Pandas 特性，如 Pandas 行索引。从第一次提交到现在，Vaex 已经有将近 6 年的时间了。

在撰写本文时，Modin 依赖 Pandas 作为其 HDF5 文件阅读器，并且不支持 Vaex 支持的内存映射查询风格。Modin 扩展到集群，而 Vaex 试图帮助用户避免对具有内存映射文件的集群的需求。

急流城 cuDF 对摩丁

cuDF(https://github.com/rapidsai/cudf)是一个数据帧库，有一个类似熊猫的 API，运行在 NVIDIA GPUs 上。cuDF 受到内存量(高达 48GB)的限制，溢出到主机内存会带来很高的开销。只要数据合理地适合 GPU 内存，您在 GPU 上获得的性能就非常好。您可以将多个 GPU 与 cuDF 和 Dask 一起使用，生成的分布式 GPU 数据帧将具有与上面 Dask 部分概述的相同的一般属性。 cuDF 从第一次提交到现在已经 3 年了。

截至发稿时，Modin 还没有 GPU 支持，但 Modin 的架构是分层的，因此 Modin 可以将 GPU 内核与 CPU 一起集成。由于底层架构的灵活性，Modin 甚至可以集成混合 CPU/GPU/*PU 内核。有了这种 GPU 支持，我们将需要确保它以一种允许用户避免考虑 GPU 内存限制的方式实现。这里有更多关于这个比较的信息。

雷对摩丁

Modin 是 Ray 的数据处理引擎。 Ray 是一个底层的分布式计算框架，用于缩放 Python 代码，而 Modin 有更高级别的 API，用于数据操作和查询。

摩丁的未来

摩丁扰乱了交互式数据科学空间，围绕数据科学生产力的讨论超过了基准性能。随着 Modin 的不断成熟，它正在发展成为一个支持各种规模的数据科学的平台。一些重要的特性将在 7 月底推出，今年晚些时候还会推出更多。我将讨论其中的几个功能，如果您想了解更多，请随时在 GitHub 问题跟踪器或 ZenHub 板上探索我们的未来计划。

用一行代码向外扩展

数据科学家面临的主要困难之一是，他们经常必须在 Jupyter 笔记本电脑之间切换，以在不同的集群或环境上运行代码。当试图在本地调试代码时，这变得很麻烦，所以我们开发了一个 API，只需一行代码就可以在本地运行代码或在多个不同的云或集群环境上运行代码之间进行切换。注意:该 API 可能会发生变化，在最新版本( 0.7.4 )上尚不可用。欢迎反馈！

import modin
import modin.pandas as pdtest_cluster = modin.cloud.create(provider="AWS", 
                                  instance="m4.xlarge", 
                                  numnodes=2)with modin.local():  # run this code locally
    df_local = pd.read_csv("a_file.csv")
    df_local.head()with modin.cloud.deploy(test_cluster):  # run on my test cluster
    df_test = pd.read_csv("s3://bucket/a_file.csv")
    df_test.head()with modin.local():
    df_local.count()with modin.cloud.deploy(test_cluster):
    df_test.count()with modin.cloud.deploy(production):  # run this on production
    df_prod = ...

这可以在标准的 Jupyter 笔记本或任何 python 解释器中工作，并使数据科学家在单个笔记本的环境中比以往任何时候都更加高效。

Numpy 和 Sci-kit 学习 API

这些 API 已经被请求很久了，并且正在被构建。这将与现有的 Pandas 引擎集成，并避免往返于 Modin 的 dataframe 和 numpy 或 sklearn 的常见瓶颈。就像 Pandas API 的情况一样，它们也将是替代产品。

import modin.pandas as pd
import modin.numpy as np
from modin.sklearn.model_selection import train_test_split

与 dataframes 的情况一样，Modin 将被分层，以集成其他技术和计算内核。我们可以集成其他计算引擎或内核，例如 nums (另一个 RISELab 项目)。

摘要

数据科学家热爱他们的工具，我们也热爱数据科学家。Modin 旨在让数据科学家能够使用他们喜欢的工具提高工作效率。我们正在努力将数据科学工具的重点转移到重视数据科学家的时间，而不是他们使用的硬件的时间。

蒙蒂·霍尔问题

原文：https://towardsdatascience.com/the-monty-hall-problem-9c4053ef0640?source=collection_archive---------28-----------------------

彼得·诺伊曼在 Unsplash 上的照片

你对概率的直觉有你想象的那么好吗？

让我们做个交易是一个流行的电视游戏节目，始于 60 年代的美国，其最初的主持人叫蒙蒂·霍尔。基于它的一个著名的概率谜题后来出名了，格式如下:

你在游戏节目的舞台上，这里有三扇门。其中一个后面有一辆汽车，另外两个后面有一只山羊。你必须选择其中一扇门，你的奖品将是门后的任何东西(显然你想要这辆车)。

一旦你选择了一扇门，主人会从剩下的两扇门中选择一扇后面有山羊的门，然后打开门，让山羊出现在你面前。然后，他让你选择是坚持你先前选择的门，还是改变。你是做什么的？

这就是这个问题引起了很多愤怒的地方:我们的直觉告诉我们，换车门或坚持我们的选择之间没有区别，两者都有 50%的可能性把车藏起来。然而，仔细观察就会发现，换门确实是有益的——它实际上会让你的胜算翻倍。

我们的直觉要说什么？

我们倾向于认为，我们是否切换并不重要，因为我们将游戏分为两部分:第一部分，每扇门有 1/3 的机会获得奖品，第二部分，我们只有 2 扇门可供选择，因此每扇门只有 1/2 的机会获得奖品。主人打开一扇没有奖品的门的决定如何改变其他门的概率？

为什么我们的直觉是错的？

我们的直觉是错误的，因为它忽略了这样一个事实:主持人不仅仅是随机打开一扇门:他选择打开哪扇门，是基于他对奖品在哪里的了解。如果你首先选择隐藏汽车的门(有三分之一的可能性)，那么是的，他可以随机选择两扇门中的任何一扇门。如果你选择了一扇藏着山羊的门(三分之二的机会)，那么他必须故意打开藏着山羊的门，不碰汽车的门。

那我们怎么解决这个问题呢？

一个非常简单直观的方法是建立一个这样的表格:

来源:维基百科

在那张表中，我们有 doors x 奖品的所有可能组合，结果取决于我们的决定。正如你所看到的，换车门给你三分之二的机会赢得汽车，而不换车门给你三分之一的机会——这意味着你实际上可以通过换车门使你得到汽车的机会翻一番！

我们现在如何说服我们的直觉？

如果解决方案仍然困扰你，尝试同样的问题，但用 1，000，000 扇门代替。有 999，999 只山羊和 1 辆汽车(忽略这一假设背后的逻辑挑战)。你选择一扇门，然后主人打开 999，998 个装有山羊的门，让你决定选择你选择的门还是主人关闭的门。当你选门的时候，你只有百万分之一的机会是对的。然而，除了一扇门，主人打开了所有的门，这一事实说明了他没有打开的那扇门，对吗？

如果你仍然不相信，我用 R 语言运行了一个问题的模拟，运行游戏 10000 次并显示考虑两种策略(开关门与不开关门)的胜率。正如所料，观察到的速率与上表中的速率一致。

它教会了我们什么？

这个谜题出名的时候，一个叫玛丽莲·沃斯·莎凡特的女人在杂志专栏上给出了正确答案。该杂志随后收到了包括数学家在内的数千人的来信，声称她错了。经过大量的解释、演示甚至计算机模拟，他们才相信自己错了。

这可以帮助我们理解我们对概率的直觉可能是错误的，即使是非常简单的练习。更重要的是，它告诉我们，即使我们错了，我们的自信也会如此之高，以至于我们对现实视而不见(尤其是如果我们是一位著名的数学家)。因此，有时我们应该试着检查我们假设背后的数学——即使它们看起来完美无瑕。

蒙蒂霍尔问题:朴素贝叶斯解释！

原文：https://towardsdatascience.com/the-monty-hall-problem-naive-bayes-explained-fadd991edeb2?source=collection_archive---------34-----------------------

检查蒙蒂霍尔问题的解决方案，研究朴素贝叶斯分类器，理解贝叶斯定理的应用。

图片作者:特里斯特·约瑟夫

我们做个交易吧！“如果你对机器学习感兴趣，那么很有可能你听说过贝叶斯定理和朴素贝叶斯分类器。你听说过蒙蒂·霍尔问题也是有道理的。如果你没有听说过蒙蒂霍尔问题，那么这是一个著名的数学问题，它来自游戏节目，让我们做一个交易，当它由蒙蒂霍尔主持时。这个节目的参赛者将被告知从三扇门中选择，其中两扇门会有不利的结果。做出选择后，Monty 将揭示两个不利门之一后面是什么，然后询问参赛者是否愿意坚持最初的选择或切换到剩下的关闭的门。因为其中一扇门现在是开着的，参赛者知道奖品一定在两扇关着的门的后面。因此，他们有 50%的机会坚持最初的选择而获得奖励，他们是否改变选择并不重要，对吗？不对。数学表明，如果参赛者改变他们的选择，获胜的概率将增加到 2/3；因此，如果有选择的话，你应该经常换工作。好吧，但是为什么这是真的呢？它和朴素贝叶斯有什么关系？嗯，蒙蒂霍尔问题和朴素贝叶斯分类器都植根于贝叶斯定理，它们高度依赖于事件发生的可能性。因此，我们将在本文中探讨这两个主题！

图片作者:特里斯特·约瑟夫

假设我们不是开门，而是盲目地从包里挑选弹珠。假设袋子有 1 个红色、1 个绿色和 1 个蓝色，其中蓝色的弹球是有利的结果。每个弹珠被选中的几率是一样的，参赛者随机挑选一个，但不知道他们选择的颜色。然后，主持人检查袋子，并显示一个不利的结果。现在有三种可能的情况:

参赛者挑选了蓝色的弹珠。主持人现在可以显示红色或绿色，因为它们都是不利的结果，显示任何一种颜色的概率是 50%。不管主持人展示了什么，如果参赛者选择不转换，他们就赢了。
参赛者挑选了绿色的大理石。主持人现在只能展示红色弹珠，因为这是唯一不利的结果。这是必然发生的，只有当参赛者选择转换时，他们才能赢。
参赛者挑选了红色的弹珠。东道主现在只能展示绿色大理石，因为这是唯一不利的结果。这是必然发生的，只有当参赛者选择转换时，他们才能赢。

当参赛者选择转换时，结果如下:

蓝色= 1/3 + 1/3 = 2/3

绿色= 1/6

红色= 1/6

这说明转行时赢的概率是 2/3，输的概率是 1/3。

当参赛者选择不转换时的结果如下:

蓝色= 1/6 + 1/6 = 1/3

绿色= 1/6

红色= 1/6

这说明不切换时赢的概率是 1/3，输的概率是 2/3。

图片作者:特里斯特·约瑟夫

蒙蒂霍尔问题的解决方案之所以有效，是因为最初，选择不利结果的方式比选择有利结果的方式多。这就是贝叶斯定理的本质；新信息不应该孤立地决定信念。相反，新信息应该用于更新先前的信息。每当存在一个假设、与该假设相关的证据，并且被问及的问题是“假设证据为真，该假设的概率是多少”时，贝叶斯定理都是适用的。让我们看看这个公式。目标是找到这个更新的信息，或者说后验，写为【Pr(假设|证据) 。

在考虑任何证据之前，我们需要确定假设的概率。这是写为 Pr(假设) 的先验信息。在 Monty Hall 问题的情况下，先验的事实是每个弹球最初有 1/3 的机会被选中。

在此之后，我们需要考虑证据能够被看到的概率，假设假设为真； 【证据|假设】 。这通常被称为可能性，它直观地表示了一个事件可能发生的方式的数量，假设先前的事件为真。在 Monty Hall 的例子中，给定参赛者最初的选择，主持人可以用多少种方式显示不利的结果。

这些数字被相乘，因为它们代表了假设的先验信念和信念符合证据的概率。它们共同提供了确定问题答案所必需的信息。

现在，必须注意的是，即使假设不成立，证据也会出现； Pr(证据| ~假设) 。当加上 Pr(证据|假设) 时，我们得出证据为真的总概率； 公关(证据) 。

最后，假设证据是真实的，我们必须将我们所拥有的信息除以证据的总概率来确定假设的概率。

图片来自 developers.google.com

朴素贝叶斯分类器背后的机制就是基于这一原理。朴素贝叶斯是一种概率分类算法，它根据概率为实例分配标签。术语“天真”来自于这样一个事实，即该算法假设特征之间具有很强的独立性。朴素贝叶斯的一个常见应用是电子邮件分类，垃圾邮件与非垃圾邮件。让我们看一个例子:

为简单起见，我们假设有 4 个单词；“你”“需要”“钱”“现在”。

假设对于非垃圾邮件， Pr(word = you | email =非垃圾邮件)= 0.40； Pr(需要|非垃圾)= 0.25；Pr(钱|非垃圾)= 0.20；和 Pr(现|非垃圾)=0.15

假设对于垃圾邮件，Pr(word = you | email = spam)= 0.30；Pr(need | spam)= 0.10；Pr(金钱|垃圾邮件)= 0.45；和 Pr(now | spam) =0.15

假设 Pr(邮件=垃圾邮件)= 0.80 ，而 Pr(非垃圾邮件)= 0.20

假设有一封电子邮件“你现在需要钱钱钱”，它会被归类为垃圾邮件还是不是垃圾邮件？

使用贝叶斯公式， Pr(垃圾邮件|电子邮件)= ~93% 和 Pr(非垃圾邮件|电子邮件)= ~7% 。

必须注意，朴素贝叶斯并不计算实际概率。相反，该公式通过确定总信息(而不是除以总证据)来给电子邮件打分，然后将电子邮件分类到分数较高的类别中。实际概率是为了举例而计算的，但同样的原则也适用。

因此，由于该电子邮件是垃圾邮件的后验概率高于它是非垃圾邮件的后验概率，所以该电子邮件将被分类为垃圾邮件。但是，请注意，如果垃圾邮件中至少有一个单词的概率为 0，则该邮件将被归类为非垃圾邮件。这一事实很容易在构建模型时产生不正确的分类。因此，通常会在集合中的每个单词上添加一个伪计数(或 1 计数),以确保不会输出 0。伪计数不会改变先验，它主要确保后验非零。

所以，现在你熟悉了贝叶斯定理，你理解了简单的邮件分类，你知道如何在“让我们做笔交易”中平均获胜！但是这篇文章的主要收获是理解信息可以用来更新先前的信念，然后做出数据驱动的决策。贝叶斯定理适用于机器学习，可用于各种过程，开发这种类型的适当模型的关键是理解它的理论来源。

参考文献:

seas.upenn.edu/~cis391/Lectures/naive-bayes-spam-2015.pdf

courses . cs . Washington . edu/courses/CSE 312/18sp/lectures/naive-Bayes/naive Bayes notes . pdf

brilliant.org/wiki/monty-hall-problem/

Norwegian creations . com/2018/10/Bayes-rule-and-the-monty-hall-problem/

machine learning mastery . com/Bayes-theory-for-machine-learning/

其他有用的素材:

github . com/Surya-Murali/Email-Spam-Classifier-Using-Naive-Bayes

statisticsbyjim.com/fun/monty-hall-problem/

plato.stanford.edu/entries/bayes-theorem/

我对数据科学了解得越多，就越觉得自己懂得不多

原文：https://towardsdatascience.com/the-more-i-learn-about-data-science-the-less-i-feel-i-know-5e25439556cb?source=collection_archive---------70-----------------------

我做了什么来克服这种感觉

K8 在 Unsplash 上拍照

数据科学是一个奇特的领域。数据科学的众多应用和产品吸引了许多公司和个人的注意。越来越多的企业投资这一领域，从数据中创造价值。这个领域的“性感”加上高需求驱使许多人开始从事数据科学职业。

我是许多被吸引的人之一。经过短暂的介绍，我不可避免地要从事这个领域的职业。所以，我开始越来越多地学习。

在最初的几个月里，我觉得我学到了很多东西，这进一步激励了我。我收集证书，完成在线教程，阅读论文，学习算法的基本原理，等等。

过了一段时间，我意识到我学的越多，要学的就越多。虽然我学到了很多，但我觉得我做得不好。我甚至认为我的技能和学习技巧是不够的。

如果您感觉我在您的数据科学之旅中的表现，请不要担心。我会试着解释为什么你不应该。

那种不充分的感觉，有些人可能称之为“冒名顶替综合症”，让我停下来想了一会儿。为了继续学习，我不得不把这种感觉抛在脑后。

在这篇文章中，我解释了，在我看来，产生这种感觉的原因，以及帮助我专注于学习旅程的解决方案。

接受要学的东西太多

数据科学是一个跨学科领域，由数学、统计学、软件和算法思维组成。除此之外，根据我们工作的内容，领域知识可能是一个重要的需求。因此，我承认要学的东西太多了，即使尝试也是不必要的负担。

学习你需要的东西。

我的座右铭是学习你需要的东西。我试图避免过度学习。我的软件技能比不上一个软件开发人员的技能，这是绝对正常的。我需要数学，但不喜欢主修数学的人。

照片由 Xavier von Erlach 在 Unsplash 上拍摄

数据科学仍在兴起

数据科学是一个新兴领域。有不同的领域需要关注，但它们还没有清晰的结构和区分。考虑一个人在读物理学博士。你能指望她专注于整个物理学领域吗？绝对不行！要成为专家，重点要缩小。

我告诉自己，我会在一定程度上了解数据科学的不同领域。对事物的工作原理和用途有一个大致的了解是很有好处的。然而，我不会因为试图掌握每一个概念而自暴自弃。

我可能在一家金融机构担任机器学习工程师，从事算法培训。然后我的重点变成了对时间序列数据的预测分析。这并不意味着我只需要学习时间序列分析的动力学。关键是我们通常只需要专注于一个特定的领域。

招聘信息谬误

另一个表明数据科学仍在兴起的迹象是招聘信息。我阅读了许多招聘信息，我逐渐意识到，即使是公司也没有完全意识到数据科学中存在不同的领域。

我知道有些公司无力雇佣整个数据科学团队。但这并不意味着他们需要一个能够在数据科学领域执行任何任务的人。

招聘启事中的大量要求让我觉得我需要学习更多。这些要求通常比你在那个职位上要做的要多。

一段时间后，我能够克服需求谬误。你在一个职位上要做的任务实际上告诉我们你需要关注什么。根据您想要工作的领域，您可以创建自己的需求列表。

工具谬误

NumPy，Pandas，TensorFlow，Keras，PyTorch，Scikit-learn，SpaCy，NLTK，BERT，statsmodels，Matplotlib，Seaborn，Pyplot，ggplot，tidyverse，dplyr，FastAPI，Streamlit，不胜枚举。

这些只是数据科学中使用的软件包和工具的一小部分。他们都擅长执行一些任务。

当我开始学习时，我觉得我需要练习所有这些。随着我不断地学习，我遇到的工具的数量增加了。没有办法赶上。

然后我意识到我只需要其中的几个。他们中的一些人以不同的方式做着同样的事情。所以，我开始坚持独立于工具的学习过程。

如果我绝对需要使用一种新工具来完成一项任务，那么我会花时间去学习它。否则，我倾向于使用我的武器库中的那些。与同一个工具保持一致的另一个好处是，我能够掌握它。

结论

我认为数据科学中的大多数学习途径都会因为要学习的材料太多而失去动力。克服这种消极时期并保持它的短暂是我们的责任。

我也建议做项目。当你专注于完成一项特定的任务时，学习过程将会被提炼出来，帮助你克服我们讨论过的困难。

感谢您的阅读。如果您有任何反馈，请告诉我。

Python 中字符串的 5 种基本但最容易出错的情况

原文：https://towardsdatascience.com/the-most-5-error-prone-cases-for-strings-in-python-278741668057?source=collection_archive---------47-----------------------

保罗·埃施-洛朗在 Unsplash 上拍摄的照片

字符串是一系列字符。它是 Python 中的一种基本数据类型，但你真的知道如何使用它吗？下面我们来讨论最容易出错的 5 种情况。

1.单引号、双引号或三引号

例如，如果你想输出字符串:汤姆说:“你好吗？我也很好。”，让我们检查不同的方法:

方法 1:使用单引号

代码和结果将是:

方法 2:使用双引号

代码和结果将是:

方法 3:使用三重引号

方法 4:用转义法连单引号

方法 5:将打印功能与三重引号一起使用

方法 6:对多行使用三重引号

你发现结论了吗？因此，要正确显示包含引号的句子，可以使用以下提示:

如果字符串只有单引号，那么可以使用双引号
如果只有双引号，可以使用单引号
如果字符串既有单引号又有双引号或者字符串有多行，最好使用三引号
与直接输出字符串相比，使用打印功能可以避免转义字符

2.len(string)或 len(string)-1:索引或切片

如果有 string = '8euro/piece '，你要

获取字符串的最后一个字符
获取字符串的最后五个字符

让我们尝试不同的方法，看看结果如何:

string2 = '8euro/piece'

输出 1:

输出 2:

输出 3:

输出 4:

从结果中，我们知道输出 2 针对问题 1，输出 4 针对问题 2。这是因为:

要求 1:使用索引。虽然 len()给出了字符串的总字符数，但由于它是从 0 开始的，所以最后一个字符的索引是 len()-1。

要求 2:使用切片的方法。切片语法是 S[firstIndex: tailIndex]获取 firstIndex 到 tailIndex -1 的字符

3.int、float 或 int(float)

有两个字符串:

string3 = '8.8euro/piece'

如何从 string3('8.8 ')的数字中得到整数部分？
如何四舍五入出 string3 的个数(' 8.8 ')？

让我们试一试:

测试 1:

测试 2:

测试 3:

提示是:

int():仅从:转换为整数类型

浮动
字符串中的整数部分

如果想得到字符串 8.8 的整数部分，先把它转换成 float 类型，然后用 int()。

4.bool():真或假

我们将案例总结如下:

print("''is",bool(''))
print("space' ' is",bool(' '))
print('None is',bool(None))
print('True is', bool(True))
print('Number 0 is', bool(0))
print('string 0 is',bool('0'))

输出是:

一起使用 bool()和 len():

此方法可用作 if 的逻辑条件。

所以基本规则是:

For bool():如果传递的值为 None、empty 或 0(数字，不是字符串 0)，则返回 False，否则返回 True。

5。。join()方法

当使用 BeautilfulSoup 从一个网站提取数据时，通常数据会被保存为一个列表，然后使用 for 循环读取每个元素。举一个例子:

list1=['The Shawshank Redemption','(1994)','9.6']

要将其保存为 CSV 文件，需要将其保存为字符串。join()方法在这里有效。

该字符串是不可变的，因此您不能直接在字符串之间删除或插入特定的字符。为此，需要将字符串转换成列表，然后使用。插入()，结合使用。join()方法，示例如下:

今天，我们尝试用 Python 编写最容易出错的字符串代码。你对字符串操作有更清楚的了解吗？玩得开心！

最牛逼的损失函数

原文：https://towardsdatascience.com/the-most-awesome-loss-function-172ffc106c99?source=collection_archive---------22-----------------------

论文综述:通用和自适应稳健损失函数

玩具火车:(图片由作者提供)

最近，我偶然看到了 Jon Barron 在 2019 年 CVPR 会议上发表的惊人论文，关于为机器学习问题开发一个鲁棒和自适应的损失函数。这篇文章是对那篇论文以及一些必要概念的回顾，它还将包含一个简单回归问题的损失函数的实现。

异常值和稳健损失问题:

考虑机器学习问题中最常用的误差之一——均方误差(MSE)。如你所知，它的形式是(y-x)。MSE 的一个关键特征是，与小误差相比，它对大误差具有高灵敏度。用 MSE 训练的模型将偏向于减少最大误差。例如，3 个单位的单个错误将被赋予与 1 个单位的 9 个错误相同的重要性。

我使用 Scikit-Learn 创建了一个示例，演示在一个简单的数据集中，在考虑和不考虑离群值的情况下，拟合度是如何变化的。

图 1: MSE 和异常值的影响。(图片由作者提供)

正如你所看到的，包含离群值的拟合线受到离群值的严重影响，但是，优化问题应该要求模型受到内嵌值的更多影响。在这一点上，你已经可以认为平均绝对误差(MAE)是比 MSE 更好的选择，因为它对大误差不太敏感。有各种类型的稳健损失(如 MAE ),对于一个特定的问题，我们可能需要测试各种损失。在训练一个网络的时候测试各种各样的损失函数不是很神奇吗？该论文的主要思想是引入广义损失函数，其中损失函数的鲁棒性可以变化，并且该超参数可以在训练网络的同时被训练，以提高性能。这比通过执行网格搜索交叉验证来寻找最佳损失要少得多。让我们从下面的定义开始——

鲁棒和自适应损失:一般形式:

鲁棒和自适应损失的一般形式如下—

Exp。1:鲁棒性损失:α是控制鲁棒性的超参数。

α 控制损失函数的鲁棒性。 c 可以认为是一个比例参数，在 x =0 附近控制碗的大小。由于 α 作为超参数，我们可以看到，对于 α 的不同值，损失函数具有相似的形式。让我们看看下面—

Exp。2:自适应损失的各种损失(表达式。1)对于不同的α值。

损失函数在 α = 0 和 2 时是未定义的，但是取极限我们可以进行近似。从 α =2 到 α =1，损耗平滑地从 L2 损耗过渡到 L1 损耗。对于不同的 α 值，我们可以绘制损失函数，看看它是如何表现的(图 2)。

我们还可以花一些时间研究这个损失函数的一阶导数，因为基于梯度的优化需要导数。对于 α 的不同值，w.r.t x 的导数如下所示。在图 2 中，我还绘制了不同 α 的导数和损失函数。

Exp。3:稳健损失的导数(经验。1)各种α值的 w . r . t . x。

适应性损失及其导数的行为；

下图对于理解这个损失函数及其导数的行为非常重要。对于下面的图，我已经将比例参数 c 固定为 1.1。当 x = 6.6 时，我们可以认为这就像 x = 6× c 。我们可以得出以下关于损失及其导数的推论—

损失函数对于 x，α 和c0 是平滑的，因此适合于基于梯度的优化。
在原点，损耗始终为零，并且对于|x| > 0 ，损耗单调增加。损失的单调性质也可以与记录损失进行比较。
损耗也随着 α 的增加而单调增加。这一特性对于损失函数的稳健性很重要，因为我们可以从较高的值 α 开始，然后在优化过程中逐渐(平滑地)降低，以实现稳健估计，避免局部最小值。
我们看到当|x|<|c时，对于 α 的不同取值，导数几乎是线性的。这意味着导数在很小时与残差的大小成比例。
对于 α = 2，导数始终与残差的大小成比例。这一般是 MSE (L2)损失的财产。
对于 α = 1(给我们 L1 损失)，我们看到导数的幅度饱和到超过|x|>|c的恒定值(正好 1/ c )。这意味着残差的影响永远不会超过一个固定的量。
对于 α < 1，导数的幅值减小为|x|>|c。这意味着当残差增加时，它对梯度的影响较小，因此异常值在梯度下降期间的影响较小。

图 2:作为α函数的损失函数和损失函数导数。(图片由作者提供)

我还绘制了不同的 α 值的稳健损失及其导数的表面图。

图 3:自适应损失函数(左)及其导数(右)的曲面图。(图片由作者提供)

实施稳健损失:Pytorch 和 Google Colab:

既然我们已经了解了鲁棒和自适应损失函数的基本知识和属性，让我们将它付诸实践。下面使用的代码只是从乔恩·巴伦的 GitHub 库中找到的代码稍微修改了一下。我还制作了一个动画来描述随着迭代次数的增加，自适应损失如何找到最佳拟合线。

我们可以使用 Colab 中的pip 在本地安装存储库，而不是克隆并使用它。

!pip install git+https://github.com/jonbarron/robust_loss_pytorchimport robust_loss_pytorch

我们创建一个简单的线性数据集，包括正态分布的噪声和异常值。由于库使用了 pytorch ，我们使用 torch 将 x，y 的 numpy 数组转换为张量。

import numpy as np
import torch scale_true = 0.7
shift_true = 0.15x = np.random.uniform(size=n)y = scale_true * x + shift_truey = y + np.random.normal(scale=0.025, size=n) # add noise flip_mask = np.random.uniform(size=n) > 0.9 y = np.where(flip_mask, 0.05 + 0.4 * (1\. — np.sign(y — 0.5)), y) 
# include outliersx = torch.Tensor(x)
y = torch.Tensor(y)

接下来，我们使用 pytorch 模块定义一个线性回归类，如下所示

class RegressionModel(torch.nn.Module): def __init__(self): super(RegressionModel, self).__init__() self.linear = torch.nn.Linear(1, 1) 
      ## applies the linear transformation. def forward(self, x): return self.linear(x[:,None])[:,0] # returns the forward pass

接下来，我们将线性回归模型拟合到我们的数据中，但是，首先使用损失函数的一般形式。这里我们使用α ( α = 2.0)的固定值，它在整个优化过程中保持不变。正如我们已经看到的，对于 α = 2.0，损失函数复制了 L2 损失，并且我们知道这对于包括异常值的问题不是最佳的。对于优化，我们使用学习率为 0.01 的 Adam 优化器。

regression = RegressionModel()
params = regression.parameters()
optimizer = torch.optim.Adam(params, lr = 0.01)for epoch in range(2000):
   y_i = regression(x)
   # Use general loss to compute MSE, fixed alpha, fixed scale. loss = torch.mean(robust_loss_pytorch.**general.lossfun**(
     y_i — y, alpha=torch.Tensor([2.]), scale=torch.Tensor([0.1]))) optimizer.zero_grad() loss.backward() optimizer.step()

使用鲁棒损失函数的一般形式和固定值 α ，我们可以获得拟合线。原始数据、真实线(用于生成数据点的具有相同斜率和偏差的线，不包括异常值)和拟合线绘制在图 4 中。

图 4:一般损失函数(图片由作者提供)

损失函数的一般形式不允许 α 改变，因此我们必须手动或通过执行网格搜索来微调 α 参数。此外，如上图所示，拟合受到异常值的影响，因为我们使用了 L2 损失。这是一般情况，但是，如果我们使用损失函数的自适应版本，会发生什么呢？我们调用自适应损失模块，只需初始化 α ，让它在每个迭代步骤中自适应。

regression = RegressionModel()adaptive = robust_loss_pytorch.adaptive.AdaptiveLossFunction( num_dims = 1, float_dtype=np.float32)params = list(regression.parameters()) + list(adaptive.parameters())optimizer = torch.optim.Adam(params, lr = 0.01)for epoch in range(2000): y_i = regression(x) loss = torch.mean(adaptive.lossfun((y_i — y)[:,None]))
   # (y_i - y)[:, None] # numpy array or tensor optimizer.zero_grad() loss.backward() optimizer.step()

使用这个，还有一些额外的代码使用赛璐珞模块，我创建了下面的动画(图 5)。这里，您可以清楚地看到，随着迭代次数的增加，自适应损失如何找到最佳拟合线。这接近于真实线，并且受异常值的影响可以忽略。

图 5:自适应损失函数如何达到最佳拟合的动画。(图片由作者提供)

讨论:

我们已经看到包括超参数 α 在内的稳健损失如何被用来快速找到最佳损失函数。本文还展示了如何将以 α 为连续超参数的损失函数的鲁棒性引入到经典的计算机视觉算法中。论文中显示了实现可变自动编码器和单目深度估计的自适应损失的示例，这些代码也可在 Jon 的 GitHub 中获得。然而，我最感兴趣的部分是动机和论文中描述的损失函数的逐步推导。很容易读懂所以，我建议看一看论文！

保持坚强，干杯！！

参考资料:

[1] “一种通用的、自适应的鲁棒损失函数”；j .巴伦，谷歌研究。

[2]稳健损失:线性回归示例；乔恩·巴伦的 GitHub 。

[3]鲁棒丢失和动画的曲面图: GitHub 链接。

pySpark 数据帧最完整的指南

原文：https://towardsdatascience.com/the-most-complete-guide-to-pyspark-dataframes-2702c343b2e8?source=collection_archive---------0-----------------------

来源: Pixabay

包含您可能需要的所有数据框架功能的书签备忘单

大数据已经成为数据工程的代名词。但是数据工程和数据科学家之间的界限日益模糊。此时此刻，我认为大数据必须是所有数据科学家的必备技能。

原因: 每天生成太多数据

这让我们想到了 Spark ，这是处理大数据时最常用的工具之一。

虽然 Spark 曾经严重依赖 RDD 操作，但 Spark 现在已经为美国数据科学家提供了一个 DataFrame API。这是为喜欢冒险的人准备的文档。但是，尽管文档很好，但它没有从数据科学家的角度进行解释。它也没有恰当地记录数据科学最常见的用例。

在这篇文章中，我将讨论 Spark 的安装、使用 DataFrames 时需要的标准 Spark 功能，以及一些处理不可避免的错误的技巧。

这个帖子会很长。事实上，这是我在 medium 上最长的帖子之一，所以去买杯咖啡吧。

如果您想跳到某个特定部分，这里还有一个目录:

安装
数据 T51。基本功能
∘ 读取
∘ 查看文件中的几行内容
∘ 更改列名
∘ 选择列
∘ 排序
∘ 投
∘ 筛选
∘ 分组方式
∑播/图方加入
3。使用 SQL 与 DataFrames
4。创建新列
∘ 使用 Spark 原生函数
∘ 使用 spark UDF
∘使用 RDDs
∘ 使用熊猫 UDF
5。火花窗功能
∘ 排名
∘ 滞后变量
∘ 滚动聚合
 6。枢纽数据框
 7。Unpivot/Stack 数据帧
 8。腌制
 更多一些技巧和窍门
∘ 缓存
∘ 从中间步骤保存并加载
∘ 重新分区
∘ 读取本地的拼花文件
 结论

装置

我正在努力在 Ubuntu 18.04 上安装 Spark，但是步骤应该和 MAC 上的一样。我假设您已经安装了 Anaconda 和 Python3。之后，您只需完成以下步骤:

从 Apache Spark 网站下载 Spark 二进制文件。并点击下载 Spark 链接下载 Spark。

2.一旦你下载了上面的文件，你可以从解压文件到你的主目录开始。打开终端，输入这些命令。

cd ~
cp Downloads/spark-2.4.5-bin-hadoop2.7.tgz ~
tar -zxvf spark-2.4.5-bin-hadoop2.7.tgz

3.检查您的 Java 版本。从 2.4 版本开始，Spark 可以与 Java 8 协同工作。您可以使用终端窗口上的命令java -version来检查您的 Java 版本。

我的机器上有 Java 11，所以我必须在我的终端上运行以下命令来安装并将默认 Java 更改为 Java 8:

sudo apt install openjdk-8-jdk
sudo update-alternatives --config java

您需要通过键入选择号来手动选择 Java 版本 8。

重新检查 Java 版本应该会得到类似这样的结果:

4.编辑您的~/.bashrc文件，并在文件末尾添加以下几行:

function pysparknb () 
{
#Spark path
SPARK_PATH=~/spark-2.4.5-bin-hadoop2.7export PYSPARK_DRIVER_PYTHON="jupyter"
export PYSPARK_DRIVER_PYTHON_OPTS="notebook"# For pyarrow 0.15 users, you have to add the line below or you will get an error while using pandas_udf 
export ARROW_PRE_0_15_IPC_FORMAT=1**# Change the local[10] to local[numCores in your machine]**
$SPARK_PATH/bin/pyspark --master **local[10]**
}

5.来源~/.bashrc

source ~/.bashrc

6.运行终端中的pysparknb功能，您将能够访问笔记本。你可以打开一个新的笔记本，同时sparkcontext也会自动加载。

pysparknb

数据

安装完成后，我们可以转到这篇文章更有趣的部分。我将与南韩新冠肺炎数据科学合作，这是 COVID 在互联网上最详细的数据集之一。

请注意，我将使用这个数据集来展示 Spark 的一些最有用的功能，但这不应该以任何方式被视为对这个惊人数据集的数据探索练习。

来源:卡格尔

在本文中，我将主要使用以下三个表格:

案例
地区
时间省

你可以在GitHub库中找到所有的代码。

1.基本功能

阅读

我们可以从使用 spark.read.load 命令加载数据集中的文件开始。这个命令读取 parquet 文件，这是 spark 的默认文件格式，但是您可以添加参数format来读取。csv 文件使用它。

cases = spark.read.load("/home/rahul/projects/sparkdf/coronavirusdataset/Case.csv",format="csv", sep=",", inferSchema="true", header="true")

查看文件中的几行

cases.show()

这份档案包含按感染传播方式分类的病例。这可能有助于韩国对电晕放电病例的严格追踪。

这个文件现在看起来很好，但是有时当我们增加列数时，格式会变得不太好。我注意到下面的技巧有助于在我的笔记本上以熊猫的形式显示。.toPandas()函数将 spark 数据帧转换成更易于显示的 pandas 数据帧。

cases.limit(10).toPandas()

更改列名

有时我们想改变 Spark 数据框架中的列名。我们可以简单地使用下面的命令来更改单个列:

cases = cases.withColumnRenamed("infection_case","infection_source")

或者对于所有列:

cases = cases.toDF(*['case_id', 'province', 'city', 'group', 'infection_case', 'confirmed',
       'latitude', 'longitude'])

选择列

我们可以使用select关键字选择列的子集。

cases = cases.select('province','city','infection_case','confirmed')
cases.show()

分类

我们可以按确诊病例数排序。这里要注意的是，cases数据帧在执行这个命令后不会改变，因为我们没有把它赋给任何变量。

cases.sort("confirmed").show()

但这是颠倒的。我们希望在顶部看到最多的案例。我们可以使用F.desc功能来实现:

# descending Sort
from pyspark.sql import functions as F
cases.sort(F.desc("confirmed")).show()

我们可以看到，在韩国的一个逻辑区域中，大多数案件都起源于"信川寺教会"。

铸造

虽然我们在这个数据集中没有遇到，但是可能会出现 Pyspark 将 double 作为 integer 或 string 读取的情况，在这种情况下，您可以使用 cast 函数来转换类型。

from pyspark.sql.types import DoubleType, IntegerType, StringTypecases = cases.withColumn('confirmed', F.col('confirmed').cast(IntegerType()))cases = cases.withColumn('city', F.col('city').cast(StringType()))

过滤器

我们可以使用 AND(&)、OR(|)和 NOT(~)条件过滤数据框。例如，我们可能希望找出大邱省所有不同的感染病例，其中有 10 个以上的确诊病例。

cases.filter((cases.confirmed>10) & (cases.province=='Daegu')).show()

分组依据

我们也可以使用火花数据框的groupBy功能。与熊猫groupBy非常相似，除了你需要导入pyspark.sql.functions。这里的是该功能模块可以使用的功能列表。

from pyspark.sql import functions as Fcases.groupBy(["province","city"]).agg(F.sum("confirmed") ,F.max("confirmed")).show()

如果您不喜欢新的列名，您可以在agg命令中使用alias关键字来重命名列。

cases.groupBy(["province","city"]).agg(
    F.sum("confirmed").alias("TotalConfirmed"),\
    F.max("confirmed").alias("MaxFromOneConfirmedCase")\
    ).show()

连接

从连接开始，我们需要引入一个 CSV 文件。我们将使用包含地区信息的地区文件，如小学数量、老年人人口比例等。

regions = spark.read.load("/home/rahul/projects/sparkdf/coronavirusdataset/Region.csv",format="csv", sep=",", inferSchema="true", header="true")
regions.limit(10).toPandas()

我们希望通过连接两个数据帧在案例文件中获得这些信息。我们可以通过以下方式实现这一点:

cases = cases.join(regions, ['province','city'],how='left')
cases.limit(10).toPandas()

2.广播/地图端连接

有时，您可能会遇到这样的情况，需要将一个非常大的表(~1B 行)与一个非常小的表(~ 100–200 行)连接起来。该场景还可能包括增加数据库的大小，如下例所示。

Spark 中有很多这样的操作，您可能希望对一个特定的键应用多个操作。但是假设大表中每个键的数据都很大，就会涉及到大量的数据移动。有时甚至会导致应用程序本身崩溃。在连接如此大的表(假设另一个表很小)时，可以做的一个小优化是在执行连接时将小表广播到每个机器/节点。您可以使用 broadcast 关键字轻松做到这一点。当其他一切都失败的时候，这已经是 Spark 的救命稻草很多次了。

from pyspark.sql.functions import broadcast
cases = cases.join(**broadcast**(regions), ['province','city'],how='left')

3.对数据帧使用 SQL

如果您愿意，也可以对数据框使用 SQL。让我们试着在 cases 表上运行一些 SQL。

我们首先将 cases 数据帧注册到一个临时表 cases_table 中，在这个表中我们可以运行 SQL 操作。如您所见，SQL select 语句的结果又是一个 Spark 数据帧。

cases.registerTempTable('cases_table')
newDF = sqlContext.sql('select * from cases_table where confirmed>100')
newDF.show()

我在上面展示了一个最小的例子，但是您可以在上面的查询中使用非常复杂的 SQL 查询，包括 GROUP BY、HAVING 和 ORDER BY 子句以及别名。

4.创建新列

在 PySpark 数据帧中创建列有多种方法。我会尽量展示其中最有用的。

使用 Spark 本地函数

在 PySpark 数据帧中创建新列的最简单的方法是使用内置函数。这是创建新列的最有效的编程方式，所以每当我想做一些列操作时，这是我第一个去的地方。

我们可以使用.withcolumn和 PySpark SQL 函数来创建一个新列。本质上，您可以找到已经使用 Spark 函数实现的字符串函数、日期函数和数学函数。我们的第一个函数是F.col函数，它让我们可以访问列。所以如果我们想给一列加 100，我们可以用F.col作为:

import pyspark.sql.functions as F
casesWithNewConfirmed = cases.withColumn("NewConfirmed", 100 + F.col("confirmed"))casesWithNewConfirmed.show()

我们也可以使用数学函数，如F.exp函数:

casesWithExpConfirmed = cases.withColumn("ExpConfirmed", F.exp("confirmed"))casesWithExpConfirmed.show()

这个模块还提供了很多其他的功能，对于大多数简单的用例来说已经足够了。你可以点击查看功能列表。

使用 Spark UDFs

有时我们想对一列或多列做复杂的事情。这可以被认为是将 PySpark 数据帧映射到一列或多列的操作。虽然 Spark SQL 函数确实解决了许多列创建的用例，但每当我需要更成熟的 Python 功能时，我都会使用 Spark UDF。

要使用 Spark UDF，我们需要使用F.udf函数将常规 python 函数转换为 Spark UDF。我们还需要指定函数的返回类型。在这个例子中，返回类型是StringType()

import pyspark.sql.functions as F
from pyspark.sql.types import *
def casesHighLow(confirmed):
    if confirmed < 50: 
        return 'low'
    else:
        return 'high'

#convert to a UDF Function by passing in the function and return type of function
casesHighLowUDF = F.udf(casesHighLow, StringType())CasesWithHighLow = cases.withColumn("HighLow", casesHighLowUDF("confirmed"))
CasesWithHighLow.show()

使用 rdd

这可能看起来有点奇怪，但有时 spark UDFs 和 SQL 函数对于特定用例来说是不够的。我观察到 rdd 在现实生活中的一些用例中表现得更好。您可能希望利用 spark RDDs 带来的更好的分区。或者您可能想在 Spark RDDs 中使用组函数。

不管是哪种情况，我发现这种使用 RDD 创建新列的方式对于有使用 rdd 经验的人来说非常有用，rdd 是 Spark 生态系统中的基本构建块。不懂也不用太担心。它只是在这里完成。

下面的过程利用了 ***Row*** 和 ***pythondict*** 对象之间的转换功能。 我们把一个行对象转换成一个字典。像我们习惯的那样使用字典，并将字典转换回 row。这在很多情况下可能会派上用场。

import math
from pyspark.sql import Rowdef rowwise_function(row):
    # convert row to python dictionary:
    row_dict = row.asDict()
    # Add a new key in the dictionary with the new column name and value.
    # This might be a big complex function.
    row_dict['expConfirmed'] = float(np.exp(row_dict['confirmed']))
    # convert dict to row back again:
    newrow = Row(**row_dict)
    # return new row
    return newrow# convert cases dataframe to RDD
cases_rdd = cases.rdd# apply our function to RDD
cases_rdd_new = cases_rdd.map(lambda row: rowwise_function(row))# Convert RDD Back to DataFrame
casesNewDf = sqlContext.createDataFrame(cases_rdd_new)casesNewDf.show()

使用熊猫 UDF

Spark 版本 2.3.1 中引入了这一功能。这就允许你在 Spark 上使用 pandas 的功能。当我必须在 Spark 数据帧上运行 groupBy 操作时，或者当我需要创建滚动特征并希望使用 Pandas 滚动函数/窗口函数而不是 Spark 窗口函数(我们将在本文稍后介绍)时，我通常会使用它。

我们使用它的方式是通过使用F.pandas_udf装饰器。 我们这里假设函数的输入将是一个熊猫数据帧。 我们需要从这个函数中依次返回一个熊猫数据帧。

这里唯一的复杂性是我们必须为输出数据帧提供一个模式。我们可以使用数据帧的原始模式来创建外部模式。

cases.printSchema()

在这里，我使用 UDF 熊猫来获得按感染病例分组的标准化确诊病例。这里的主要优势是我可以在 Spark 中处理熊猫数据帧。

5.火花窗功能

窗口函数本身可以构成一篇完整的博客文章。这里我将谈谈 spark 中一些最重要的窗口功能。

为此，我还将使用另一个数据 CSV，它显示日期，这将有助于更好地理解窗口功能。我将使用包含每个省每日病例信息的时间省数据框架。

等级

使用这个函数，您可以在一个组上获得 rank 和 dense_rank。例如，您可能希望在您的病例表中有一列，该列根据某个省中的 infection_case 数量提供 infection_case 的等级。我们可以通过以下方式做到这一点:

from pyspark.sql.window import WindowwindowSpec = Window().partitionBy(['province']).orderBy(F.desc('confirmed'))cases.withColumn("rank",F.rank().over(windowSpec)).show()

滞后变量

有时，我们的数据科学模型可能需要基于滞后的功能。例如，一个模型可能包含像上周的价格或前一天的销售量这样的变量。我们可以使用窗口函数的滞后函数来创建这样的特征。在这里，我试图得到 7 天前确诊的病例。我正在过滤以显示结果，因为头几天的电晕案例为零。您可以在这里看到 lag_7 day 特性移动了 7 天。

from pyspark.sql.window import Window
windowSpec = Window().partitionBy(['province']).orderBy('date')
timeprovinceWithLag = timeprovince.withColumn("lag_7",F.lag("confirmed", 7).over(windowSpec))timeprovinceWithLag.filter(timeprovinceWithLag.date>'2020-03-10').show()

滚动聚合

有时，为我们的模型提供滚动平均值会有所帮助。例如，我们可能希望将连续 7 天的销售额总和/平均值作为销售回归模型的一个特性。让我们计算一下过去 7 天确诊病例的移动平均数。这是很多人已经在用这个数据集做的事情，来看真实的趋势。

from pyspark.sql.window import WindowwindowSpec = Window().partitionBy(['province']).orderBy('date')**.rowsBetween(-6,0)**timeprovinceWithRoll = timeprovince.withColumn("roll_7_confirmed",F.mean("confirmed").over(windowSpec))timeprovinceWithRoll.filter(timeprovinceWithLag.date>'2020-03-10').show()

这里有几件事需要了解。首先是我们在这里使用的 **rowsBetween(-6,0)** 函数。这个函数有一个包含开始和结束的rowsBetween(start,end)形式。使用它，我们只查看特定窗口中的过去 7 天，包括当前日期。这里，0 指定当前行，而-6 指定当前行之前的第七行。记住我们从 0 开始计数。

因此，为了获取roll_7_confirmed的2020–03–22日期，我们查看2020–03–22 to 2020–03–16日期的确诊病例，并取其平均值。

如果我们使用了**rowsBetween(-7,-1)** ，我们将只查看过去 7 天的数据，而不是当前日期。

我们还可以使用rowsBetween(Window.unboundedPreceding, Window.currentRow),在这里，我们获取窗口中第一行和 current_row 之间的行，以获得运行总数。我在这里计算累计 _ 确认。

from pyspark.sql.window import WindowwindowSpec = Window().partitionBy(['province']).orderBy('date').rowsBetween(Window.unboundedPreceding,Window.currentRow)
timeprovinceWithRoll = timeprovince.withColumn("cumulative_confirmed",F.sum("confirmed").over(windowSpec))
timeprovinceWithRoll.filter(timeprovinceWithLag.date>'2020-03-10').show()

6.透视数据框架

有时我们可能需要平面格式的数据帧。这在电影数据中经常发生，我们可能希望将类型显示为列而不是行。我们可以使用 pivot 来实现这一点。在这里，我试图为每个日期获取一行，并将省份名称作为列。

pivotedTimeprovince = timeprovince.groupBy('date').pivot('province').agg(F.sum('confirmed').alias('confirmed') , F.sum('released').alias('released'))pivotedTimeprovince.limit(10).toPandas()

这里需要注意的一点是，我们需要始终用 pivot 函数提供一个聚合，即使数据只有一个日期行。

7.取消透视/堆叠数据帧

这与支点正好相反。给定一个如上的旋转数据框架，我们能回到最初吗？

是的，我们可以。但是方法并不简单。首先，我们需要在列名中用_替换-，因为这会干扰我们将要做的事情。我们可以简单地重命名这些列:

newColnames = [x.replace("-","_") for x in pivotedTimeprovince.columns]pivotedTimeprovince = pivotedTimeprovince.toDF(*newColnames)

现在我们需要创建一个如下所示的表达式:

"stack(34, 'Busan_confirmed' , Busan_confirmed,'Busan_released' , Busan_released,'Chungcheongbuk_do_confirmed' ,.
.
.'Seoul_released' , Seoul_released,'Ulsan_confirmed' , Ulsan_confirmed,'Ulsan_released' , Ulsan_released) as (Type,Value)"

一般格式如下:

"stack(<cnt of columns you want to put in one column>, 'firstcolname', firstcolname , 'secondcolname' ,secondcolname ......) as (Type, Value)"

这可能看起来令人生畏，但是我们可以使用我们的编程技能创建这样一个表达式。

expression = ""
cnt=0
for column in pivotedTimeprovince.columns:
    if column!='date':
        cnt +=1
        expression += f"'{column}' , {column},"expression = f"stack({cnt}, {expression[:-1]}) as (Type,Value)"

我们可以使用以下方法取消透视:

unpivotedTimeprovince = pivotedTimeprovince.select('date',F.expr(exprs))

瞧啊。我们得到了垂直格式的数据帧。要获得与以前完全相同的格式，需要进行相当多的列创建、过滤和连接操作，但我不会深入讨论这些。

8.盐碱滩

有时可能会发生这样的情况，大量数据被分配给一个执行器，因为我们的数据中有很多行被分配了相同的键。Salting 是帮助您管理数据偏斜的另一种方式。

假设我们想要做加法运算，当我们有倾斜的键时。我们可以从创建 Salted 键开始，然后对该键进行双重聚合，因为 sum 的和仍然等于 sum。为了理解这一点，假设我们需要 cases 表中已确认的 infection_cases 的总和，并假设关键 infection_cases 是偏斜的。我们可以分两步完成所需的操作。

1。创建一个加盐键

我们首先使用 infection_case 列和 0 到 9 之间的 random_number 的连接创建一个 salting 键。如果你的钥匙更加倾斜，你可以把它分成 10 个以上的部分。

cases = cases.withColumn("salt_key", F.concat(F.col("infection_case"), F.lit("_"), F.monotonically_increasing_id() % 10))

这是操作后表格的外观:

2。salt 键上的第一个 group by

cases_temp = cases.groupBy(["infection_case","salt_key"]).agg(F.sum("confirmed")).show()

3。第二组原始密钥

这里我们看到了 sum 的和是如何被用来得到最终的和的。您还可以利用以下事实:

min 的 min 就是 min
最大的最大就是最大
总数就是总数

您也可以考虑将加盐作为一种思想应用到连接的方法。

结论

来源: Pixabay

这是一个很大的帖子，祝贺你到达终点。这些是我在日常工作中最常用的功能。

希望我已经很好地介绍了 Dataframe 的基础知识，足以激起您的兴趣，并帮助您开始使用 Spark。如果你想了解更多关于 Spark 是如何开始的或者 RDD 的基础知识，看看这个帖子

你可以在这里找到所有的代码GitHub我保存了我所有帖子的代码。

继续学习

此外，如果你想了解更多关于 Spark 和 Spark DataFrames 的信息，我想在 Coursera 上调出大数据专业。

我以后也会写更多这样的帖子。让我知道你对这个系列的看法。关注我在媒体或者订阅我的博客了解他们。一如既往，我欢迎反馈和建设性的批评，可以通过 Twitter @mlwhiz 联系。

此外，一个小小的免责声明——这篇文章中可能会有一些相关资源的附属链接，因为分享知识从来都不是一个坏主意。

阅读他人编写的代码的最有效方式

原文：https://towardsdatascience.com/the-most-efficient-way-to-read-code-written-by-someone-else-cb1a05102b76?source=collection_archive---------4-----------------------

如何加快 4 步读懂别人代码的奋斗？

萨法尔·萨法罗夫在 Unsplash 上拍摄的照片

作为开发人员，不管我们的专业是什么，不管是数据科学、前端还是后端，我们 75%以上的时间都花在阅读他人编写的代码上。这项任务可能是一项非常艰巨的任务。

也就是说，高效阅读他人代码的能力是让一个人的软件工程工作变得更加愉快的技能之一。不幸的是，这也是一项被学校、训练营和公司普遍忽视的技能。这是那些每个人都认为你知道或者擅长的技能之一，仅仅因为你知道如何写代码。

关于写代码，每个人都有自己的编码风格。阅读代码不像阅读小说或故事；不仅仅是阅读屏幕上的说明。相反，当你阅读别人写的代码时，你不仅仅是在阅读他们的代码。你试图了解他们的思维过程，以及他们写代码时在想什么。

不用说，这是一项极具挑战性的任务。但是，这是一项任务，你可以使之大大简化。在这篇文章中，我将带你经历阅读和理解他人代码的 4 个步骤。

为了解释不同的步骤，我将仔细阅读我为 web 抓取教程编写的代码。

步骤 1:运行代码，看看它做了什么

每当你得到一个需要阅读和理解的代码时，第一件事——也是最明显的，我认为——就是运行代码，看看它能做什么。它以什么作为输入？输出是什么？

所以，让我们继续运行上面的代码并研究结果。

图片由作者提供(代码的结果截图)

并非所有代码都会生成图表；一些代码的输出将是文本输出。不管输出类型是什么，我们都可以探索它来猜测——如果您还不知道——编写代码的目的是什么。

然而，这可能不会给你很多关于代码的细节，或者如果这个代码是一个更大的项目的一部分，你可能不知道它是如何连接的，但是你将学习如何构建和运行它。此外，您将了解它所使用的库和它所依赖的框架。

然而，运行代码会给你更好地理解它所需要的信息，并且为了确保你得到了每一个依赖项，你需要开始工作并扩展它。

第二步:找到主函数或起始点

既然我们知道了代码做什么和输出是什么，我们可以开始更深入地研究它的细节。为此，我们需要精确定位代码的开始。如果你正在使用一种带有 must main函数的编程语言，比如 C、C++或 Java，那么就从这里开始，一路走到其他函数。

然而，如果你使用 Python，不是所有的代码都有一个main函数，但是你可以使用缩进来知道代码从哪里开始。比如上面的代码，我们有多个函数，然后代码的起点在 第 80 行 。

因此，我们可以先浏览注释——如果有注释的话——然后浏览代码的整个主要部分，而不去探究子功能的细节。

浏览main函数给你代码的一般流程，每个子函数做什么，不是它们如何工作，而是它们做什么。

步骤 3:在调试模式下运行代码

一旦您仔细阅读了代码的主要部分，您可能会发现在调试模式下运行代码很有用。原因是，当您在调试器中运行代码时，它允许您观察代码如何与内存交互。

它将向您展示每个变量如何随着代码中的每一步而变化。这样做将使您更深入地理解代码的内部功能及其不同的功能。

一旦您看到代码中的每个变量是如何随着每一行而变化的，您就可以开始在代码中添加自己的注释，向自己解释代码的每一行是做什么的。

步骤 4:构建代码不同部分之间的连接思维导图

我发现非常有帮助的一件事是，当我在调试器模式下运行时，构建一个代码连接的思维导图。调试器模式向您展示了不同代码项之间的清晰联系。

从思维导图中间的代码文件名开始，然后分支出不同的功能以及它们是如何连接的。试着鼓励代码中的变量进入思维导图，也许不是所有的变量，但是对整体结果有最大影响的变量。

此外，尽量包含代码的输入和输出以及它们的类型或预期类型。下面是上面代码的思维导图。

图片由作者制作(使用 Mindmeister )上面代码的思维导图

构建思维导图将会在你与代码库交互时节省你很多时间。如果您想添加或删除代码的任何部分，它将帮助您了解连接。

外卖食品

阅读其他开发人员编写的代码可能是一项具有挑战性的任务；你需要理解他们的逻辑，他们的风格，以及他们的具体选择。我看过那么多不同水平不同年龄的程序员写的代码。有了这样的经历，我用我自己的 4 步法来简化阅读、探索和理解基本上不是我写的代码。

这 4 个步骤很简单，会节省你很多时间和精力；你需要做的就是:

运行代码并探索结果。
找到主函数或代码的起点。
在调试器下运行代码，并完全理解代码的机制。
构建不同代码元素之间的连接的思维导图，并在与代码交互的任何时候使用它。

我希望这些步骤对您在下一次代码探索中节省大量时间和精力非常有用。

“的确，花在阅读和写作上的时间比远远超过 10 比 1。作为编写新代码工作的一部分，我们不断地阅读旧代码。…[因此，]让它易于阅读会让它更易于书写。”

―罗伯特·c·马丁，

用三行代码解决任何线性方程的最有效方法

原文：https://towardsdatascience.com/the-most-efficient-way-to-solve-any-linear-equation-in-three-lines-of-code-bb8f66f1b463?source=collection_archive---------13-----------------------

背景图:Pixabay。免费分享图片

使用复数和字符串求值的 Python 技巧

除非另有说明，所有图片均由作者创作。

这个函数可以用三行代码求解任何线性方程，甚至可以用两行代码重写。据我所知，这是在 Python 中求解线性方程最有效的方法。

def solve_linear(equation,var='x'):
    expression = equation.replace("=","-(")+")"
    grouped = eval(expression.replace(var,'1j'))
    return -grouped.real/grouped.imag

例子和标准的代数过程来得到答案。

它是如何工作的？

首先，让我们定义什么是线性方程——它必须是纯可解的。这意味着它只能有一个变量，通常写成 x 。双变量方程需要求解多个线性方程(方程组)。

线性方程由三个主要部分组成——常数、变量和乘数。

任何数量或组合的运算(加、减、乘、除)都是有效的，包括任何括号范围。只要它遵守一个线性方程的这些定义，它就是我们的函数可解的。

让我们一步一步地分解这个函数。作为一个例子，我们将使用下面的线性方程作为示范。

第一行通过将等式右侧的整个表达式移动到左侧，将等式转换为要计算的表达式。

expression = equation.replace("="," - (")+")"

IDE 中的演示:

等式中的所有“信息”都被移到了一边，虽然等号已经被丢弃，但请记住，这个表达式等于 0。

第二行代码对新表达式求值，转换成形式 ax + b = 0 。这使用了 Python 内置的复数处理，其中 j 用于表示数学常数 i = √-1。

grouped = eval(expression.replace(var,'1j')

注意在函数初始化时var被指定为等于‘x’。

eval函数接受一个表达式。通过用自然理解的 j ( i )替换未知变量 x ，Python 将两类表达式元素——变量和常量——视为独立的。当表达式求值时，答案出来是*a***j* + *b*，Python 认为它是一个复数。因为 j 被用来代替 x，结果是一个简化的并且容易解的线性方程。

首先，作为对eval()如何工作的演示，它可以评估字符串中给出的任何 Python 命令:

因此，数学表达式就像任何 Python 表达式一样被处理。使用eval()的天才之处在于，我们利用 Python 的字符串处理方法，而不是手动完成繁重的工作。

通过欺骗 Python 使其相信*x*实际上是*i* ，字符串被自动求值。

请注意，这与…相同

最后，我们实现了一个简化形式*ax* + *b* = 0。通过标准和简单的代数操作，我们发现 x 等于-b/a，或者，相对于我们创建的复数，实部(上例中为 9)的负数除以虚部乘数(上例中为 1)。

return -grouped.real/grouped.imag

最后一行代码通过返回复数的实部除以虚部的负数，简单地返回这个代数步骤。

通过操作和利用 Python 内置的数学计算能力，这个三行函数可以处理任何线性方程，无论其长度或复杂度如何。

如果你喜欢，请随意投票！

最优雅的 Python 面向对象编程

原文：https://towardsdatascience.com/the-most-elegant-python-object-oriented-programming-b38d75f4ae7b?source=collection_archive---------6-----------------------

数码师在像素点拍摄的照片

具有全面验证功能的字典和对象之间的无缝转换

众所周知，Python 的优势在于它的灵活性。例如，Python 是面向对象编程中最简单的编程语言之一。然而，它有时也会受到批评，因为它“过于灵活”。

在本文中，我将介绍我认为使用 Python 进行面向对象编程的最优雅的方式。

方法的关键是一个名为marshmallow的库。

你可以通过pip install marshmallow轻松安装这个库。

由 Zorro4 在 Pixabay 上拍摄的照片

类别的定义

让我们从声明一个用户类开始，出于演示目的，保持简单。

class User(object):
    def __init__(self, name, age):
        self.name = name
        self.age = agedef __repr__(self):
        return f'I am {self.name} and my age is {self.age}'

好的。我们的User职业只有两个属性:name和age。请注意，我还实现了__repr__方法，这样我们可以很容易地输出实例来验证它。

然后，我们需要从库marshmallow中导入一些模块和方法。

from marshmallow import Schema, fields, post_load
from pprint import pprint

这里我导入了pprint，因为我们要打印许多字典和列表。只是想让它更好看。

现在，我们应该如何使用marshmallow？简单地为我们的User类定义一个“模式”。

class UserSchema(Schema):
    name = fields.String()
    age = fields.Integer()@post_load
    def make(self, data, **kwargs):
        return User(**data)

这很简单。对于每个属性，我们需要声明它是fields，然后后跟类型。

注释@post_load是可选的，如果我们希望将模式作为任何类的实例来加载，就需要这个注释。因此，在我们的例子中我们需要它，因为我们想要生成User实例。make方法将简单地使用所有的参数来实例化实例。

JSON 到实例

如果我们有一个字典(JSON 对象)并且想要一个实例，下面是代码。

data = {
    'name': 'Chris',
    'age': 32
}schema = UserSchema()
user = schema.load(data)

多简单啊！只需调用模式的load()方法，我们就将 JSON 对象反序列化为类实例。

多个实例的 JSON 数组

如果我们有一个包含多个要去序列化的对象的 JSON 数组呢？我们不需要写 for-loop，简单指定many=True如下。

data = [{
    'name': 'Alice',
    'age': 20
}, {
    'name': 'Bob',
    'age': 25
}, {
    'name': 'Chris',
    'age': 32
}]schema = UserSchema()
users = schema.load(data, many=True)

将实例序列化为 JSON 对象(字典)

好的。我们知道可以使用load()方法将字典转换成实例。反过来怎么样？我们可以使用如下的dump()方法。

dict = schema.dump(users, many=True)

在这个例子中，我简单地使用了users，它是从前面的例子中生成的用户实例列表。可以看到，一行代码就把用户实例列表转换成了 JSON 数组！

现场验证

你认为marshmallow只能序列化/反序列化实例吗？如果是这样，我大概不会把这个作为故事分享在这里。这个库最强大的特性是验证。

这里先说一个简单的例子。首先，我们需要从库中导入一个异常ValidationError。

from marshmallow import ValidationError

还记得我们用字段age声明了上面的UserSchema为Integer吗？如果我们传入一个无效的值呢？

data = [{
    'name': 'Alice',
    'age': 20
}, {
    'name': 'Bob',
    'age': 25
}, {
    'name': 'Chris',
    'age': 'thirty two'
}]

请注意，在上面的 JSON 数组中，第三个对象“Chris”的年龄格式无效，不能转换为整数。现在让我们使用load()方法去序列化数组。

try:
    schema = UserSchema()
    users = schema.load(data, many=True)
except ValidationError as e:
    print(f'Error Msg: {e.messages}')
    print(f'Valid Data: {e.valid_data}')

异常被捕获，它告诉我们“不是一个有效的整数”。想象一下，我们正在开发一个 web 应用程序，甚至没有必要为编写错误消息而烦恼！

此外，在本例中，只有第三个对象存在验证问题。错误消息实际上告诉我们它发生在索引2处。此外，仍然可以输出有效的对象。

高级验证

当然，仅仅针对数据类型进行验证是不够的。该库支持更多的验证方法。

让我们给User类再添加一个属性gender。

class User(object):
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = genderdef __repr__(self):
        return f'I am {self.name}, my age is {self.age} and my gender is {self.gender}'

然后，让我们定义带有验证的模式。我们还需要从库中导入validate特征。

from marshmallow import validateclass UserSchema(Schema):
    name = fields.String(validate=validate.Length(min=1))
    age = fields.Integer(validate=validate.Range(min=18, max=None))
    gender = fields.String(validate=validate.OneOf(['F', 'M', 'Other']))

这里，我们向所有这三个字段添加了验证。

对于字段name，长度必须至少为 1。换句话说，不能是空的。
对于字段age，它必须大于或等于 18。
对于字段gender，它必须是三个值之一。

让我们定义一个包含所有无效值的 JSON 对象，如下所示。

data = {
    'name': '',
    'age': 16,
    'gender': 'X'
}

然后，让我们试着加载它。

try:
    UserSchema().load(data)
except ValidationError as e:
    pprint(e.messages)

捕捉异常并不奇怪，但是当我第一次尝试时，我真的很惊讶错误消息是现成的。这为我们编写验证错误消息节省了大量时间。

定制验证功能

您可能会问，使用上例中的内置验证方法(如范围、长度和“其中之一”)仍然有一定的局限性。如果我们想要定制验证方法呢？当然可以。

def validate_age(age):
    if age < 18:
        raise ValidationError('You must be an adult to buy our products!')class UserSchema(Schema):
    name = fields.String(validate=validate.Length(min=1))
    age = fields.Integer(validate=validate_age)
    gender = fields.String(validate=validate.OneOf(['F', 'M', 'Other']))

在这里，我们用定制的逻辑和消息定义了我们的验证方法validate_age。让我们定义一个 JSON 对象来测试它。在以下对象中，年龄小于 18 岁。

data = {
    'name': 'Chris',
    'age': 17,
    'gender': 'M'
}try:
    user = UserSchema().load(data)
except ValidationError as e:
    pprint(e.messages)

现在，它使用你定制的逻辑和错误信息。

还有另外一种实现方式，我觉得更优雅。

class UserSchema(Schema):
    name = fields.String()
    age = fields.Integer()
    gender = fields.String()@validates('age')
    def validate_age(self, age):
        if age < 18:
            raise ValidationError('You must be an adult to buy our products!')

因此，在这个例子中，我们使用注释来定义类内部的验证方法。

必填字段

您还可以定义一些必填字段。

class UserSchema(Schema):
    name = fields.String(required=True, error_messages={'required': 'Please enter your name.'})
    age = fields.Integer(required=True, error_messages={'required': 'Age is required.'})
    email = fields.Email()

在这个例子中，我们定义name和age为必填字段。现在，让我们使用一个没有电子邮件的对象来测试它。

data_no_email = {
    'name': 'Chris',
    'age': 32
}try: 
    user = UserSchema().load(data_no_email)
except ValidationError as e:
    pprint(e.messages)

好的。完全没问题。如果我们有一个没有名字和年龄的物体呢？

data_no_name_age = {
    'email': '[abc@email.com](mailto:abc@email.com)'
}try: 
    user = UserSchema().load(data_no_name_age)
except ValidationError as e:
    print(f'Error Msg: {e.messages}')
    print(f'Valid Data: {e.valid_data}')

它会报错并提供我们为必填字段定义的错误消息。

默认值

有时，我们可能希望用默认值定义一些字段。因此，用户可能不需要输入它，默认值将被利用。

class UserSchema(Schema):
    name = fields.String(missing='Unknown', default='Unknown')print(UserSchema().load({}))  # Take the "missing" value
print(UserSchema().dump({})) # Take the "default" value

在marshmallow中，有两种方式定义“默认”值:

missing关键字定义了使用load()反序列化实例时将使用的默认值
default关键字定义使用dump()序列化实例时将使用的默认值

在上面的例子中，我们使用了两个关键字，并用一个空对象试验了load()和dump()两种方法。可以看出，两者都添加了带有默认值的name字段。

属性别名

继续，还没完:)

有时候，在键/属性名方面，我们的类和实际的 JSON 数据之间可能会有一些差异。

例如，在我们的类中，我们定义了name属性。然而，在 JSON 对象中，我们有username,它表示相同的字段，但是命名不同。在这种情况下，我们不必重新实现我们的类，也不必转换 JSON 对象中的键。

class User(object):
    def __init__(self, name, age):
        self.name = name
        self.age = agedef __repr__(self):
        return f'I am {self.name} and my age is {self.age}'class UserSchema(Schema):
    username = fields.String(attribute='name')
    age = fields.Integer()@post_load
    def make(self, data, **kwargs):
        return User(**data)

请注意，我们在User类中有name，而在UserSchema中我们有username，但是对于字段username，我们定义它的attribute应该叫做name.

让我们尝试转储一个用户实例。

user = User('Chris', 32)
UserSchema().dump(user)

它正确地序列化了字段名为username的实例。

反之亦然:

data = {
    'username': 'Chris',
    'age': 32
}
UserSchema().load(data)

即使我们传递了带有键username的 JSON 对象，它仍然可以毫无问题地将其反序列化到User实例。

嵌套属性

最后但同样重要的是，marshmallow支持嵌套属性，没有任何问题。

class Address(object):
    def __init__(self, street, suburb, postcode):
        self.street = street
        self.suburb = suburb
        self.postcode = postcodedef __repr__(self):
        return f'{self.street}, {self.suburb} {self.postcode}'class User(object):
    def __init__(self, name, address):
        self.name = name
        self.address = address

    def __repr__(self):
        return f'My name is {self.name} and I live at {self.address}'

我们定义了两个类Address和User。类别User有一个属性address，其类型为Address。让我们通过实例化一个用户对象来测试这些类。

address = Address('1, This St', 'That Suburb', '1234')
user = User('Chris', address)
print(user)

现在，我们将如下定义模式。

class AddressSchema(Schema):
    street = fields.String()
    suburb = fields.String()
    postcode = fields.String()@post_load
    def make(self, data, **kwargs):
        return Address(**data)class UserSchema(Schema):
    name = fields.String()
    address = fields.Nested(AddressSchema())@post_load
    def make(self, data, **kwargs):
        return User(**data)

这里的技巧是使用fields.Nested()来定义一个使用另一个模式的字段。上面我们已经有了一个用户实例。让我们把它转储到一个 JSON 对象中。

pprint(UserSchema().dump(user))

如图所示，用户实例已经被序列化为一个嵌套的 JSON 对象！

当然，反过来也可以。

data = {
    'name': 'Chris',
    'address': {
        'postcode': '1234',
        'street': '1, This St',
        'suburb': 'That Suburb'
    }
}
pprint(UserSchema().load(data))

摘要

图片由 geralt 在 Pixabay 拍摄

在本文中，我介绍了如何使用库marshmallow在实践中极大地简化 Python 中的面向对象编程。我认为在 Python 中使用 OO < - > JSON 是最优雅的方式。

所有的代码都在我的谷歌实验室里:

[## 棉花糖 _ 面向对象 _Python.ipynb

实验记录手册

colab.research.google.com](https://colab.research.google.com/drive/1mZVBiVgk3OTyJqFFTw6NYRThtjyZne9X?usp=sharing) [## 通过我的推荐链接加入 Medium 克里斯托弗·陶

作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…

medium.com](https://medium.com/@qiuyujx/membership)

如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和数以千计的其他作者！(点击上面的链接)

统计学和数据科学中最基本也是最有争议的争论

原文：https://towardsdatascience.com/the-most-fundamental-and-controversial-debate-in-statistics-and-data-science-e8dd1bad737a?source=collection_archive---------36-----------------------

频繁主义者-贝叶斯之争

Pixabay

统计是一个不断发展的领域，不断赶上指数增长的应用和数据来源。随着统计学和数据科学——涵盖从机器学习和人工智能到政客们实事求是地证明自己观点的数字的一切——的迅速发展，关于统计学基本性质的 250 年分歧也在迅速扩大。

Bayesians 和 Frequentists 反映了对科学过程的不同观点。因为争论是如此根本，并且在统计学和数据科学的根源上分裂，这两个思想流派之间的争论在许多地方爆发，从 A/B 测试的世界到社会研究到一般数字(美国的平均身高是多少？你不能衡量所有人)。事实上，以任何一个众所周知的统计问题为例，比如德国坦克问题，可能会有两种方法/解决方案:频率主义方法和贝叶斯方法。

从广义上讲，19 世纪是贝叶斯统计占主导地位，而 20 世纪是频率主义。当 21 世纪进入贝叶斯频率主义的时代，对大量数据进行筛选和处理的需求呈指数级增长，统计学和数据科学的观点将会以前所未有的规模扩大。

贝叶斯统计更适合利用其掌握的所有信息来取得快速进步——在追求科学进步的过程中，贝叶斯主义者往往在建模假设方面更加激进和乐观，为了给模型更多的视角(从其他来源获取数据)，他们牺牲了确认模型潜在前提的严谨性。另一方面，频繁主义的数据科学家更加谨慎和保守，旨在获得普遍接受的结论，经得起严厉的对抗性审查。如果冒着学术和统计完整性的风险，科学的频繁主义模型将牺牲一些可能能够改进模型的收益。

通常，用来区分这两个群体的最明显的区别是他们接受新的和外部数据的开放性，这可能使模型更加清楚，但也可能炫耀或甚至违反模型的基本假设。常客们觉得只使用当前实验的数据和参数最舒服，因为它可以进行比较，即使它没有给模型太多的视角。贝叶斯主义者将试图纳入来自不同外部实验的数据，他们认为这将改善模型，这样，如果数据不能严格对应，也没有关系。贝叶斯思维方法会不断用新的信息和数据更新模型或计算，而常客会满足于常数参数。

这幅有争议的漫画通过在当前实验中引入外部数据来嘲笑常客的保守主义:

一个有争议的常客——贝叶斯漫画。来源。免费分享。

实验的当前参数表明:

每个骰子有六分之一的几率落地。
有两个骰子，所以总共有 36 种可能的组合。
如果两个骰子落入 36 种可能组合中的一种，那么检测器就在说谎。换句话说，它有 1/36 的机会说谎。

给定实验的参数，频率学家发现p-值小于 0.05，该值衡量实验产生错误结果的可能性(假设临床试验中 100 个患者中有 5 个不支持该假设，则p-值为 0.05)。这种 p < 0.05 的标准在学术界如此根深蒂固，以至于 p 的整个领域——黑客行为——扭曲你的结果，以达到 p 的价值标准，并在学术期刊上发表研究——都变得非常流行。因为这项研究的发现是侥幸的几率小于 0.05，并且中微子探测器宣布太阳已经爆炸，所以频率主义者宣布太阳确实已经爆炸了！对此，贝叶斯讽刺道，“我赌 50 美元，它没有。”(参考贝叶斯学者布鲁诺·德·福内梯，他在他的思想实验中大量使用了打赌。)

当然，这很傻。频率主义者没有考虑到这样一个事实，即太阳爆炸的概率非常小——远远小于 1/36——这意味着，即使考虑到 1/36 的撒谎概率，太阳爆炸的可能性仍然非常小。事实上，用于计算一个事件发生的概率(假设另一个事件为真)的贝叶斯方程可以用在以下场景中:

在贝叶斯方程和贝叶斯统计中，外部信息以先验的形式提供。在这种情况下，先验以太阳已经爆炸的机会(4.38× ⁰中的一个)的形式出现，结合当前实验的参数和条件。

尽管这部有争议的漫画幽默地揭示了贝叶斯主义者和常客之间的差异，但还有很多被忽略了。就连漫画的作者兰道尔·门罗也承认:

不过，我似乎踩到了马蜂窝，在面板上添加了“频繁主义者”和“贝叶斯”标题。这对我来说是一个惊喜，部分是因为我实际上是在最后的笑点加上去的。……事实是，我真的没有意识到常客和 Bayesians 实际上是一群人——他们现在都在给我发电子邮件。我认为它们是松散应用的标签——也许只是我最近碰巧阅读的书籍所贴的标签——用于我们在科学课上学到的标准教科书方法与更仔细地融入先验概率思想的方法。

太阳爆炸的“实验”是不可重复的，这是比较两种方法时要考虑的一个重要因素。然而，这种对比的潜在问题是，将先验整合到计算中很简单，也很有意义(我想都是为了笑点)。不幸的是，现实世界中的统计和数据科学问题从来都不是一目了然的。

例如，考虑贝叶斯-频率主义者冲突的主要战场:A/B 测试，它通常被公司用来比较两组(A 和 B ),在这两组中，除了一个变量之外，一切都保持相同。两组之间的差异可以(通常)归因于该变量的变化；例如，将调色板从浅变深可能会显著增加与网站的交互。每次你访问一个相当大的公司的网站，比如谷歌和微软，你可能会进行几十次 A/B 测试。成功的 A/B 测试让他们的运营商赚了几十亿美元(字面意思)。

比方说，我们销售巨型计算机的公司 Macrosoft 想进行一次 A/B 测试，以确定我们能否通过改变字体来增加从网站上购买产品的人数。每当用户登录 Macrosoft 时，他们会被分为 A 类或 B 类，并以相应的字体显示内容。

由作者创建。

1000 人参与了(当然是不知情的)A/B 实验。500 人在 A 组，500 人在 B 组，随机决定是否进入 A 组。A/B 测试产生以下结果:

A 组有 20%的用户购买了产品。因此，如果用户在 A 组，他们有 20%的机会购买产品。
B 组有 25%的用户购买了产品。因此，如果用户在 B 组，他们有 25%的机会购买产品。

在这一点上，常客会得出结论，将字体更改为 B 组中的字体，Macrosoft 会看到通过该网站购买的产品增加了 5%。为了对这种变化越来越有信心，频率主义者会增加实验中的人数，期望随着受试者人数的增加，结果越来越接近真实值。这种被称为大数定律的思想是频率主义统计学的基础。

贝叶斯理论并不确定这个结论。贝叶斯从一项研究中检索数据，该研究发现不同组的常用字体之间没有明显的情绪或心理差异，并将其纳入他或她的计算中。当这项研究考虑在内时，贝叶斯发现 A 组和 B 组之间没有差异——5%的差异只是一个随机的侥幸。如果公司花了几个小时改变网站字体，什么都不会改变。这反映了贝叶斯数据科学的主要目标:试图在结果的表面价值背后放置更多的上下文。

频繁主义者不愿意接受贝叶斯的结论。“这项研究的前提与我们的不同，”他/她说。“它来自不同的人口规模，有不同的背景和不同的目标。这不是苹果与苹果之间的比较，因此甚至不应该被计算在内。”贝氏反击道，“这有什么关系？这总比信以为真要好，因为这些结果不可避免地会有偏差。”

虽然大学、公司和其他机构的统计或数据科学团队经常选择并坚持一种观点以保持一致，但对于应该相信哪种观点没有明确的答案。是的，贝叶斯理论可能会给模型更多的视角，但从频率主义者的角度来看，增加外部数据会导致更多的问题——引入偏见和潜在假设的新维度——而不是解决问题。随着从泛滥的数据河流中做出明智决策的需求关系到数十亿美元的利益，这一长达数百年的争论将具有更大的重要性。

让我们看看 21 世纪的数据科学在哪里落地。

主成分分析最温和的介绍

原文：https://towardsdatascience.com/the-most-gentle-introduction-to-principal-component-analysis-9ffae371e93b?source=collection_archive---------9-----------------------

来源: Skitterphoto @ pixabay —免费股票图片

包括特征向量和特征值

在过去的几个月里，我花了相当多的时间重温一些我已经遗忘的数学知识。这让我最终理解了机器学习中的一些关键概念，这些概念我以前有点理解，但从来没有深入到以一种清晰的方式向其他人解释它们。所以今天，我们要测试一下我自己，看我能多清楚地解释一个概念，比如主成分分析。

这个故事的目的是给出一个关于它是如何工作的强烈直觉，而不是过多地进入本质的数学细节。然而，解释一些基本概念是不可避免的。我很乐意阅读您在评论部分的反馈，因为我们的想法是继续写这类故事，为没有坚实数学背景的数据爱好者涵盖机器学习的关键概念。

让我们从理解什么是主成分分析开始，从现在开始我们称之为 PCA。来自维基百科， PCA 是一种统计过程，将一组可能相关变量的观察值转换为一组线性不相关变量的值，称为主成分。简单来说，PCA 常用于简化数据、降低噪声、寻找不可测的“潜在变量”。这意味着主成分分析将帮助我们找到数量减少的特征，这些特征将以压缩的方式表示我们的原始数据集，根据我们最终选择的新特征的数量，捕捉其方差的特定部分。这种转换的定义方式是，第一个主成分具有最大的可能方差(即，尽可能多地解释数据中的可变性)，而每个后续成分依次具有最大的可能方差。

前一段提到了一些重要的事情，但在深入之前，让我们快速回顾一下一些基本概念。

在整个故事中，我们将使用 Kaggle 上的数据集的一个子集，该数据集由哥伦比亚商学院的教授汇编，试图找到一个问题的答案，即什么影响一见钟情？数据是从 2002 年至 2004 年的实验性速配活动参与者那里收集的。在活动期间，参与者将与其他异性参与者进行四分钟的“第一次约会”。在四分钟结束时，参与者被问及是否愿意再次见到他们的约会对象。他们还被要求从六个方面评价他们的约会对象:吸引力、真诚、智力、乐趣、雄心和共同兴趣。

我们的数据集名为' sd '(快速约会的首字母缩写)，总共包含 551 行和以下 29 个特征:

sd.columnsIndex([‘subject_id’, ‘wave’, ‘like_sports’, ‘like_tvsports’, ‘like_exercise’, ‘like_food’, ‘like_museums’, ‘like_art’, ‘like_hiking’, ‘like_gaming’, ‘like_clubbing’, ‘like_reading’, ‘like_tv’, ‘like_theater’, ‘like_movies’, ‘like_concerts’, ‘like_music’, ‘like_shopping’, ‘like_yoga’, ‘subjective_attractiveness’, ‘subjective_sincerity’, ‘subjective_intelligence’, ‘subjective_fun’, ‘subjective_ambition’, ‘objective_attractiveness’, ‘objective_sincerity’, ‘objective_intelligence’, ‘objective_fun’, ‘objective_ambition’], dtype=’object’)

如您所见，这些列代表了兴趣和看法。其中一些可能是相互关联的。比如欣赏音乐和电影，或者喜欢体育和电视体育。这就是为什么，尽管 29 列并不多，我们的目标是，在这个故事的结尾，将列的总数减少到几个不相关的特征，解释兴趣和认知之间的大部分关系。也就是我们希望以一个更小的特征集来解释数据集的初始列之间的原始关系。我们将使用线性代数和主成分分析来实现。

让我们开始记住，每次我们处理任何给定的数据集时，我们只有一个巨大的矩阵，每个特征包含一个向量。

作者图片

如前所述，我们数据集的这些特征或多或少是相关的，也就是说，如果我们在我们的特征矩阵中绘制两个向量，其中一些将呈现相似的趋势，一些可能走向相反的方向，一些可能几乎相同，然后，当然，我们可以找到中间的任何东西。对两个向量之间关系的强度和方向的测量就是相关性。

如果我们在散点图上绘制相关性很强的两个特征，图表上的数据点将会非常接近。最终值越接近 1 或 1，这些特性之间的关系就越密切:

1 强反比关系
+1 强直接关系

当相关性较弱时，数据点分散得更开。相关性越接近 0，关系越弱:

作者图片

两个变量之间的相关方程看起来很混乱，但实际上很简单:

作者图片

其中:

和 Yi 分别是向量 X 和 Y 的元素，
x-条和 y-条是每个矢量的平均值

如果我们测量数据集中所有要素之间的相关性，我们最终会得到一个 nxn 矩阵，其中 n 是数据集中要素的总数，对角线表示每个要素与其自身的相关性。您可以使用 pandas 在 Python 中轻松找到这个矩阵:

sd.corr()

作者图片

我们可以很容易地看到一些功能实际上是相当相关的。例如，可能出乎意料的是， like_exercise 和 like_tvsports 显示出 0.489 的相关性……相当强！而其他一些如喜欢阅读和喜欢徒步相关性很弱。

以非常相似的方式，我们可以对两个变量之间的协方差感兴趣，而不是相关性。虽然相关性告诉我们关于两个特征如何彼此变化的方向和幅度的信息，但协方差只给我们两个量彼此变化的方向，即某个变量相对于另一个变量具有正协方差，它们一起增加或减少。在我们上面的例子中， like_tvsports 和 like_sports 之间的协方差是 3.91，而 like_shopping 和 like_hikinig 之间的协方差是-0.37。

酷，为了更好地理解 PCA 中的两个关键概念:特征值和特征向量，让我们暂时搁置这个概念。

让我们从基础开始，矩阵和向量当然不仅仅是解释数据集的另一种方式。在这个故事中，不可能介绍矩阵和向量的所有情况和用途，但是为了理解特征值和特征向量，其中有一个特别重要:变换。

长话短说，向量指出了一个特征或变量在某个空间的跨度(是的，在任何愤怒的数学家加入之前，我知道这不是完美的技术定义…只是想保持简单😄).例如，假设我正在买橘子和苹果，出于某种原因，我决定去超市两次。第一次，我买了 2 个橘子和 3 个苹果，而第二次我买了 10 个橘子和 1 个苹果。如果我们把苹果和橘子的价格加到分析中，这可以用几种方式来表示:

作为单独的功能
作为单独的向量
作为一个矩阵

作者图片

如果我们知道这些苹果和橘子的价格分别是 3 和 2，我们现在就可以得到一个新的价格向量，我们可以用它来做一个矩阵乘法，并找到我们的总支出:

作者图片

因此，我们的方程组，即我们的矩阵，是问我需要什么价格向量才能在位置[12，32]得到一个变换的乘积？换句话说，我们的矩阵只是将我们的原始价格向量[3，2]转换成我们的总支出向量[12，32]

作者图片

当我们在机器学习中拟合任何类型的线性回归时，这也是后面发生的一部分；我们只是试图找到一个系数向量，当它与我们的特征矩阵相乘时，会给我们一个目标变量向量的最佳近似值。然而，在不深入了解这种复杂情况下会发生什么的情况下，矩阵可以对向量执行某些类型的变换，了解这些变换非常重要:

对角线上有任意数而其余部分都是零的矩阵称为拉伸矩阵。并且它执行拉伸变换。其中沿着对角线的正数将有效地拉伸空间中的每个向量，而负数将翻转轴，沿着对角线的任何位置的分数都将挤压一切。让我们来看一个例子，使用所谓的基向量，即跨越点[1，0]和[0，1]的向量:

作者图片

我们可以找到的另一种变换是剪切，其中沿着给定直线的所有点保持固定，而其他点被移动:

作者图片

我们还可以进行轮换:

作者图片

然后有一个矩阵什么都不做。只有前面提到的基向量的矩阵:单位矩阵:

作者图片

然后，我们可以组合所有这些变换，甚至是更复杂的多维情况。但是，这些基础知识应该足够让你坚持下去了。我们已经建立了我们的代数理解，现在我们准备最终讨论特征向量和特征值。然而，对于这一点，重要的是要理解，尽管我们一直说变换只应用于一个向量，但它们通常适用于空间中的每个向量。理解主成分分析的关键是，即使一些向量会完全改变它们的位置，一些其他的会落在它们开始的同一条线上。举以下例子:

作者图片

正如你在上面的图像中看到的，水平向量保持相同的长度，指向相同的方向。垂直向量指向相同的方向，但是它的长度改变了。对角向量完全改变了它的角度和长度。水平和垂直向量将成为该变换的特征向量。此外，假设水平向量完全没有变化，我们可以说它的特征值为 1，而垂直向量增加了它的长度，因此它可能具有例如 2 的相关特征值。

你能在下面的剪切变换中找出特征向量吗？🤔

作者图片

只是水平向量没有变化。在这种情况下，我们只有一个特征向量。

在继续之前，让我们快速总结一下:

特征向量:变换前后位于同一跨度的向量
特征值:每个向量拉伸或压缩的量

嗯，这太好了！特征向量和特征值的概念现在应该很清楚了。至少通过观察，我们可以很容易地在图表中找到它们。当然，只要我们处理简单的情况，就像我们刚刚看到的。想象一下，现在我们不是在做 2D 操作，而是有一个多维空间😬🤔。缩放、剪切和我们提到的所有变换都将以类似的方式运行，但它们将更难或不可能被发现。此外，我们可以有一个转换的组合。就像剪切加上垂直旋转。

我们需要一种新的方法来确定我们的特征向量和值。让我们试着用方程的形式将我们的发现推广到所有类型的向量和矩阵:

作者图片

在上面的等式中，A 是一个 n 维矩阵，这意味着它是一个 nxn 矩阵，因此 X 必须是一个 n 维向量。还记得我们之前看到的一个例子吗:

作者图片

我们现在可以重新排列这个等式。但是为此，我们必须使用我们之前提到的一个概念:单位矩阵。这个矩阵根本不执行任何转换:

作者图片

现在，我们对向量 X 为零的情况不感兴趣，因为它没有长度和方向。所以我们将寻找括号中的部分为零。

为了向前推进，我们必须引入一个新概念:矩阵的行列式。我们可以广泛地讨论这个概念，因为它是机器学习和数据科学中几个工具的一部分。然而，主要思想是，行列式是可以从方阵(即具有相同行数和列数的矩阵)的元素中计算出的数，并且对矩阵所描述的线性变换的某些属性进行编码。具体来说，它向我们展示了线性变换如何改变面积或体积。举以下例子:

作者图片

你看到发生了什么吗？🤔一切都变大了一倍，d 。例如，一个 2 的行列式会告诉我们，一个矩阵运算会使我们的向量空间的面积或体积加倍。酷，现在我们已经准备好理解行列式在前面等式中的位置了:

作者图片

还记得我们说过，我们会寻找这个等式括号内的部分为零。你注意到那里发生了什么吗？无非就是一个矩阵运算。由于我们将标量λ乘以对角线上充满 0 和 1 的单位矩阵，最终，我们只是从矩阵中减去另一个对角线上有λ项的矩阵。然后，我们可以用矩阵形式重写上面的等式，使用行列式来解决我们的问题:

作者图片

将这两个矩阵相减会得到另一个矩阵，因为我们知道当一个矩阵的行列式为零时，它等于零，所以我们知道它的面积或体积也为零。评估上面的矩阵运算，我们得到下面的等式:

作者图片

这个方程被称为特征多项式。然而，不要担心，你现在只需要知道我们的特征值就是这个方程的解。然后我们可以把这些特征值代入我们的原始方程，找到特征向量。让我们来看一个具体的例子:

作者图片

我们可以知道原始方程中的塞λ = 1 和λ = 2，并找到我们的特征向量:

作者图片

这一切告诉我们什么？在λ = 1 的情况下，根据我们最终的表达式，我们需要 X2 为零。但是我们对 X1 一无所知。这是因为任何沿着水平轴指向的向量都可以是该系统的特征向量，即任何 X2 等于零并且 X1 为任何其他数的向量都将是特征向量。在λ = 2 时，结果也非常相似，但反过来:我们可以取 X2 的任何值，同时保持 X1 等于零。请参见以下示例:

作者图片

哇，这真是一段不平凡的旅程！从主要概念开始，一直到实际找到变换的特征值和特征向量。然而，我们还有几件事情要处理。你还记得在开始的时候，我们谈到相关性和协方差吗？通过使用以下命令，我们可以轻松地从一见钟情数据集获得协方差矩阵:

sd.cov()

在下面的例子中，我首先删除了 subject_id 和 wave 列:

sd.drop(labels=[‘wave’,’subject_id’], axis=1).cov()

作者图片

作为参考，在 PCA 中，当变量尺度相似时，我们使用协方差矩阵，当变量在不同尺度时，我们使用相关矩阵。然而，我们将看到的 Sklearn 算法默认使用协方差矩阵，因此如果您的要素具有不同的比例，您必须在继续之前应用一些标准化。例如，在数据中包含体重和身高。不幸的是，我无法在这个故事中涵盖标准化，但是如果您有兴趣了解更多信息，我将留给您来自 Clar Liu 的另一个故事关于数据科学。

现在，酷的事情，因为我们的协方差矩阵是一个方阵，它可以用来做我们的“本征魔术”，找到本征向量和本征值。以只有两个变量/特征的场景为例:

作者图片

很好，我们已经拥有了理解主成分分析下发生的一切。然而，在我们找到我们的特征向量和特征值之后，整个 PCA 过程不会结束。最后一步是用我们找到的所有或部分特征向量创建一个矩阵，然后做一些称为投影的事情，将我们的原始数据集转换到我们刚刚找到的新向量空间。换句话说，我们将使用特征向量将样本转换成一个更小的特征集，尽可能多地表达原始数据的方差。其中我们找到的最大特征值将对应于最大的解释方差，第二大到第二大方差，依此类推。最终，我们将拥有和我们最终选择的特征值和特征向量一样多的新特征。如果前两个特征值似乎解释了我们数据集中的大部分方差，那么我们可能不需要选择比它们更多的。

对我们来说幸运的是，在 Sklearn 中实现这一切非常简单，我们实际上不需要在这个故事中涉及投影。然而，如果你有兴趣了解更多，我推荐你去看看汗学院的这组视频。

让我们通过快速查看如何使用 Sklearn 的 PCA 模块来结束这个超级长的故事吧！第一，进口:

from sklearn.decomposition import PCAfrom sklearn.preprocessing import StandardScaler

在我的例子中，我的所有要素都在相同的比例上，所以我不需要转换我的数据。但是，如果情况不是这样，您可以通过简单地运行以下命令来实现:

scaler = StandardScaler()transformed_data = scaler.fit_transform(data)data_transformed = pd.DataFrame(transformed, columns=data.columns)

酷，现在我们只需要两行代码来进行主成分分析:

sd_pca = PCA(n_components=5)sd_pca.fit(sd)

正如你所看到的，尽管我们可以找到和我们拥有的特性一样多的组件，Sklearn 允许我们指定想要保留的组件的数量，以加快计算速度。

我们现在可以检查组件，并且explained _ variance _ratio 属性将告诉我们原始数据中有多少差异被封装在新的组件变量中。

sd_exp_var_eigenvals = sd_pca.explained_variance_sd_exp_var_pct = subjective_pcasd.explained_variance_ratio_print(sd_exp_var_eigenvals)print(sd_exp_var_pct)[2.16041482 0.88925024 0.73820887 0.72229813 0.49907009][0.43128576 0.17752191 0.14736937 0.14419309 0.09962986]

最后，PCA 中的变换函数将创建新的分量变量矩阵:

components_matrix = sd_pca.transform(sd)

我们最终将只有 5 个向量，减少了数据的维数，同时最大限度地减少了损失，并占原始数据集内方差的 75.6%(0.431+0.178+0.147 = 75.6% 0.431+0.178+0.147 = 75.6%)。

嗯，我想这已经足够了😅。一如既往，我渴望阅读您的评论和反馈。

别忘了看看我的其他一些故事:

或者访问我在 Medium 上的个人资料，查看我的其他故事🙂。如果你想直接在你的邮箱里收到我的最新文章，只需 订阅我的简讯 😃

再见，感谢您的阅读！

最重要的数据科学项目

原文：https://towardsdatascience.com/the-most-important-data-science-project-458d016ef8a6?source=collection_archive---------24-----------------------

弗兰克·维西亚在 Unsplash 上拍摄的照片

每个数据科学家都必须做的项目

最近，我被各种各样的人提出的一个特殊问题所困扰——“完成数据科学的 MOOC 课程后，我应该做些什么？”。当然，最显而易见的答案是使用你刚刚学到的技能，最好的方法是做一个项目，但即使这样也可能很复杂，因为下一个问题可能是“我应该做什么类型的项目？”

因此，我在回答之前花了一些时间来思考这个问题，并想对那些等待我考虑这个问题的人表示深深的感谢。在我孤独的地方，我顿悟了。最重要的数据科学项目是让世界知道你能做什么——你如何能增加更多价值。因此，在完成任何数据科学 MOOC 后，开始你的旅程，向世界展示你的能力，你可以从你新创造的技能开始。

“我们的生活是一场持续的推销，我们应该有意识地让其他人知道我们可以做些什么来为他们增加价值。”

这听起来可能很宽泛，事实上的确如此。就像在任何数据科学项目中一样，你需要不断重复你的沟通方式，因为有太多的方式可以向市场传达你的价值，而简单地说“做项目”并不能捕捉到这一点。

此外，我们永远无法从数据科学项目的一开始就知道最佳解决方案，也不应该期望知道交流技能的最佳方式，除非我们尝试。然而，通过每一个解决方案，我们发现了更多关于我们自己的东西，我们可以建立专注于纠正我们正在犯的错误的解决方案。此外，无论它是到达我们想象的地方，还是对市场具有巨大价值，它都很可能需要以前的解决方案的输出来整合您在此过程中学到的所有经验，就像大多数数据科学竞赛的获奖解决方案一样。

它完全不符合你喜欢的交流方式——让它变得有趣。

在我看来，我相信这种看待事物的方式减轻了有抱负的数据科学家的压力，因为他们关注的是自己的发展。激励是变得更好，这样你就可以为市场提供更多，而不是追逐工作机会，顺便说一下，当你向市场展示你所能提供的东西时，工作机会最终会来到你身边。

注意:记住最健康的关系适合双方。双方都赢！你想要高薪，这个世界需要有能力的问题解决者。如果你想有重大突破，就要有重大用途。

展示您的数据科学技能

如上所述，有很多方法可以展示你的数据科学技能，可能比我能想到的更多。你的工作是选择 2-3 个，并从每一个开始工作。事不宜迟…

期刊

照片由亚伦·伯顿在 Unsplash 上拍摄

写日记是记录你的经历和想法的好方法。从长远来看，写日记可以用来确定未来的目标和目的。在数据科学环境中，我们可以使用日志记录来跟踪我们的:

密码
主意
思维过程
研究
学问
失败

是的，所有这些都是有价值的信息，如果它能让你跟踪自己的进步并展望未来，它也能作为展示你能力的工具。你前面的人可以看到你要去哪里，并提供帮助，以帮助你更快地到达职业生涯的下一个点，并在他们专注于将推动他们前进的任务时，将他们的一些责任交给你。此外，你身后的人可以从你留下的东西中学习和受到启发。不管你怎么看，在这两种情况下你都是有用的！

项目

Jo Szczepanska 在 Unsplash 上拍摄的照片

项目不仅能让你学习新技术，走出你的舒适区，还能让你体验到在真实的项目环境中，如果处理得当，工作流会是什么样子。此外，你是在直接展示你能做什么，如果它适合某些人的需要，他们就会来找你。

关于这个方法，我有两点要说。首先，请不要管泰坦尼克号的挑战。其次，维护项目。不要只是做，直到“它起作用了”就停下来。继续构建和开发您的项目，添加功能，让它变得生动。如果你已经创建了一个狗的分类器，建立一些东西(例如一个应用程序，网站等)让这个项目从你的终端出来。

总结

在某种意义上，这可以与你的项目携手并进，你可以分享你的解决方案背后的思路。另一个很好的例子是总结其他人的工作，这有利于参与，你可能(很可能)学到一两件事。比如，总结别人的工作想法；每周都有许多研究论文发布，你可以决定在它们发布时总结 2 或 3 篇。

案例分析

对于那些不熟悉案例研究的人来说，它可以被描述为“对单个个人、群体、社区或一些其他单位的深入、系统的调查，其中研究人员检查与几个变量相关的深入数据。”(来源:大数据让简单变得简单)。

简单地说，从一个问题开始，概述各种可用的解决方案，然后提供证明您的解决方案是最佳的经过验证的结果。所有企业不都需要最佳解决方案吗？案例研究在商业中是有效的，对你也是有效的——下面是一些例子。

示例案例研究

[## 我们如何在 5 年的超高速增长中把数据科学扩展到 Airbnb 的各个方面

五年前，我加入了 Airbnb，成为它的第一位数据科学家。在那个时候，很少有人听说过…

venturebeat.com](https://venturebeat.com/2015/06/30/how-we-scaled-data-science-to-all-sides-of-airbnb-over-5-years-of-hypergrowth/)

演讲

照片由优 X 创投在 Unsplash

演示是向观众展示一个主题的过程。它通常是一种示范、介绍、讲座或演讲，旨在告知、说服、启发、激励或建立良好的意愿或展示一种新的想法或产品(来源:维基百科)。

这为什么有用？

您可以向他人展示您对某个主题的理解，这也是一种软技能的展示，对于数据科学家来说，这与技术能力一样有用。

博客/视频博客

如果你正在读这个故事，你可能会猜到我选择的一个选项。写博客对我来说绝对是一件神奇的事情(尤其是在禁闭期间)。思考该写些什么会驱使你想学得更多，当你必须充实一个技术主题时，你会更加关注让你学得更快的细节——我可以证明这一点。此外，你可以建立你作为主题专家的声誉——哦，我有没有说你可以获得额外收入？

“如果你不能简单地解释，那就是你理解得不够好”。—理查德·费曼

你绝对没有理由不从今天开始。像 Youtube 和 Medium 这样的平台让这个市场变得非常容易进入，如果你学到了一些新东西，很可能其他人也想知道。不要因为别人已经做了你做不到的事情而有这种感觉——借鉴他人的工作也是一个好主意。

比赛

照片由奎诺·阿尔在 Unsplash 上拍摄

我听过很多次了，每当提到数据科学竞赛时，Kaggle 是第一个想到的名字。关于是否对现实世界的数据科学有用，已经有太多的争论，我真的不想深入讨论。重要的因素是，要做得好，你必须运用技巧(其中一些是在现实世界中运用的)，这是一种实践学习的形式，如果你做得好，它充分说明了你的性格。

是的，比赛和真实世界的数据科学工作流之间确实存在一些差异，但当我们谈论解决问题时，这是你最接近真实世界的事情(当然，除非你决定做自己的项目)。

包裹

展示你的价值是每个人都必须参与的人生项目，而不是在完成 MOOC 后做一个项目来获得下一份工作，决定做一些长期来说能让你不断为自己增加价值的事情。不要盲目地度过一生，希望你做的下一件事会为你打开所有的大门，而是要深思熟虑，持续展示你的能力，以增加你获得重大突破的机会。

有很多方法可以展示你学到的技能。如果你觉得我遗漏了什么，留下一个回复，告诉我它是什么，并解释它是如何有用的。

[## Kurtis Pykes -人工智能作家-走向数据科学| LinkedIn

在世界上最大的职业社区 LinkedIn 上查看 Kurtis Pykes 的个人资料。Kurtis 有一个工作列在他们的…

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

如果你喜欢这个故事，你可能也会喜欢:

[## 如何获得你真正想要的数据科学职位

当承担与人工智能相关的角色时，必须做的事情没有被充分提及

towardsdatascience.com](/how-to-secure-a-data-science-role-you-actually-want-169afc52019b) [## 为您的数据科学事业保持动力

我们可以长期保持动力。

towardsdatascience.com](/staying-motivated-for-your-data-science-career-e845f18421e1) [## 数据科学家如何更快地学习

学会学习的有效策略

towardsdatascience.com](/how-to-learn-faster-for-data-scientist-cfd96d317ce6) [## 当你试图成为一名数据科学家时感到沮丧的原因

将最优秀的人与众不同的隐藏技能

towardsdatascience.com](/the-reason-youre-frustrated-when-trying-to-become-a-data-scientist-2d2b8b402811)

数据科学有志者最重要的思维方式

原文：https://towardsdatascience.com/the-most-important-mindhack-for-the-data-science-aspirant-6ab25d9010b1?source=collection_archive---------72-----------------------

作为数据世界的学生，为了提高自己，要认识到你周围的每个人都是有能力的导师

您已经完成了第一个数据科学项目。这很简单，但很有效。你会惊讶于自己在工作中所学到的东西。现在，你希望将你的作品分享给世界上的其他人。所以，你开始写博客。很快，你会意识到你的项目还没有装饰到“值得写博客”的程度。

你可以写一篇“如何做 X”或者“用 Y 构建 X”的文章。但是，你不喜欢增加互联网上某些内容的冗余。你考虑在 LinkedIn 上发布你的项目。毕竟，这是一个可以帮助你增加职业联系的网络。

然后你想起过去几天你在 LinkedIn feed 上看到的项目。每一次都比前一次更可怕。你再次意识到，你的项目还没有准备好进入一个平台，尤其是一个有这么多复杂项目控制着喜欢和分享的平台。

此时，你们中的一些人可能会将代码文件保存到 Github 中，不管有没有文档。如果您喜欢将代码文件保存在本地系统中，我希望您不要在例行的桌面清理过程中误删了它们。我蠢到做了这件事。

几个星期后，你会忘记这个项目。生活在继续。你开始学习新的东西。你建立了更多的项目，但不与任何人讨论你的工作。你简直就是初级数据科学项目的布鲁斯·韦恩。这无疑是一条充满便利的道路。但是便利对于改善来说是一个很差的催化剂。

不太方便的途径是与他人讨论你的工作，与他们交流你的努力，帮助他们理解你的工作，理解他们的反馈，并在你已经知道的基础上进行改进。

如果你只从这篇文章中拿走一句话，我希望是这句话——“作为一名数据世界的学生，为了提高自己，要意识到你周围的每个人都是一位能干的导师”。

从关心你的项目开始

当你是初学者时，每个项目都让你有能力学习新的东西。因此，这些项目值得你的关心和全力以赴。你越了解自己做了什么，为什么这么做，就越容易向别人解释。

数据科学主要是为利益相关者创造价值。它不是你制造的。它是你提供给人们的价值。

如果你已经花了至少几个小时在你的项目上，不言而喻，你将需要花更多的时间来完善它。如果这是你为大学作业所做的事情，它不应该仅仅是为了评估。如果你不喜欢从中学习，你可以。

有几种方法可以让你的工作物有所值

在一个仅靠在线课程无法提供帮助的世界里，项目是初学者工具包中最重要的组成部分。然而，如果没有很好地利用，即使最好的工具也可能失败。

数据科学主要是为利益相关者创造价值。它不是你制造的。它是你提供给人们的价值。

共享您的项目

我们大多数人都是伴随着这句格言“分享就是关爱”长大的。我仍然记得我是如何用这句话来吃我同学的午餐盒的！然而，作为一名数据科学初学者，分享您的工作很重要，因为它提供了一个讨论的机会。讨论可以让你从以前从未有过的角度来看待这个项目。

然而，分享的想法躲避初学者。作为初学者，我们都觉得我们太新了，无法分享我们的项目。我们脑海中出现的一些非常常见的问题是

我的项目“好”吗？
不好的话人们会“把我撕成碎片”吗？
有人会“窃取”我的想法吗？

首先，在有人给你反馈之前，你怎么知道你的项目是否好？自力更生，自我评价肯定是很重要的。但是，在数据世界里，你创造东西来帮助人们。所以，为了了解你是否击中了要害，你需要与人交谈。

为什么人们会“把你撕成碎片”？即使他们这样做了，为什么要打扰一个没有什么可失去的初学者呢？我们走的每一步都是一次新的学习机会。如果恐惧开始控制我们进步的速度，那么掌握就很遥远了。

最后，如果你喜欢的项目很敏感，你还不想公开，那也没关系。但是，如果有一点点可能与你信任的人讨论这件事，你必须去做。全新的视角总是有帮助的。

好吧，那我们怎么分享？我们是否把我们的工作和文件夹联系起来？或者发关于项目的推特？还是把链接发给朋友，要求评论？在我看来，没有放之四海而皆准的答案。不过，我可以给你提供一个框架，我发现这个框架在让你的宠物项目“公开”时极其有用。我称之为“拥抱风暴”金字塔。

这个术语源于这样一种理解，即要求对某件事的反馈总是会在我们的头脑中产生恐惧、怀疑和希望的风暴。

演员表:作者

对于你喜欢的项目，基本上有三个要求反馈的层次。随着你越往上爬，你受到的批评越多。往下走，诚实的正面评价会增加。所有级别都同等重要。至于有价值的反馈需要达到什么水平，这完全取决于你的项目。

第一级——你最近的圈子

三者中最小的一组。这包括你的朋友或教授，他们每天都和你交谈，或者一周至少交谈几次。这些人了解你，知道你在项目中所做的工作。

优势:他们给你最诚实的正面评价。例如，如果他们喜欢他们所看到的，他们会全心全意地欣赏它。他们为你的工作感到骄傲，并且不会隐瞒该表扬的地方。

劣势:他们最少批评。他们中的大多数人不会指出消极的一面，因为他们认为这不适合你。然而，如果你告诉他们批评对你有多重要，他们中的一些人可能会帮助你。

第二级——你刚刚认识的人

这包括你在大学或工作场所会遇到几次的人。你和他们并不亲近，但是你们都意识到了你们对工作的重视。这可以包括你不太了解的共同朋友，也可以包括系里没教过你但认识你的教授。

优势:他们位于金字塔的中间，因此对你的努力给予相当多的批评性反馈和赞扬。

劣势:你不太了解这些人。所以，相信他们的意见确实变得有点困难。曾经有人告诉我他们“喜欢”我的项目。然而，他甚至还没有运行我的代码。哎呀。

第三级——你不认识的人

这些人可能甚至不知道你的存在。它包括世界上所有你不认识的人。如果你对我的要求是具体，我会说你从未见过但在你的领域工作的教授。世界各地的数据科学家。社交媒体上的数据科学社区。这样的例子不胜枚举。

优势:他们给你最关键的反馈。其中许多都是高质量的，可以帮助你显著地改进你的工作。他们会毫不犹豫地向你展示需要改进的地方。

缺点:他们真的没有时间来称赞你的努力，因为时间就是金钱。如果他们有时间回应，他们会确保这是值得的。话虽如此，他们中的许多人可能不会回应，因为他们通常都很忙，没有义务回应你。

现在，如果你住在第一层，你就不需要在 LinkedIn 上写博客或帖子了。这可能发生在午餐时间。你的同事不需要理解数据，他们需要理解的只是你的想法及其重要性。他们甚至不需要成为编码员。你得到的讨论和想法会让你大吃一惊。不要相信我的话。尝试一下，自己感受一下。

一封电子邮件或一次例行的聊天/边喝咖啡边见面会对二级反馈有所帮助。如果对你来说太正式，10-15 分钟的谈话也可以提供一些非常重要的反馈。

电子邮件仍然适用于第三级。如果你足够幸运能见到你的偶像，那听起来很棒！然而，第三层的大部分互动将通过社交媒体进行。所以，这就是你可能需要一篇博文或一篇文章的地方。明智而谨慎地使用它。你一定会被你的内容所评判。

这里的底线是“你不需要认为一篇博文或一篇文章是让你的项目为人所知并获得反馈的唯一途径”。如果你想提高，即使你日常见到的人也可以成为重要的老师，即使他们对数据知之甚少。毕竟，数据科学的一个关键部分是沟通。

作为一名数据世界的学生，要意识到你周围的每个人都是有能力的导师。

人工智能系统开发最重要的部分

原文：https://towardsdatascience.com/the-most-important-part-in-artifical-intesystems-development-243f04f73fcd?source=collection_archive---------59-----------------------

如今，像数据科学和机器学习这样的人工智能相关领域已经成为主流。几乎每个人现在都可以成为数据科学家。这当然是一件好事，但不幸的是，人们忘记了什么是人工智能系统。我更喜欢麻省理工学院的帕特里克·温斯顿的观点:

人工智能(或智能代理)是一个基于数学模型的系统，它在具有某些约束的环境中以最佳方式运行。

在这篇文章中，我想多谈谈模型。

那么是什么让一个模特成为好模特呢？

简而言之，一个好的模型(在我看来是每一个好的模型)应该是问题的一个好的代表。换句话说，它必须:

使显著的特征清晰。
暴露约束。

不幸的是，由于像 Kaggle 这样的平台以漂亮的封面和简单的表格提供数据，大多数人认为人工智能是一项找到一些特征来预测一个类别或连续值的任务，有时是在图像中找到一个对象。但现在我想展示一个人工智能领域的另一个问题的例子，不幸的是它没有被当作人工智能的例子。

八皇后问题

8 皇后问题被公式化为:一个代理人应该把 8 个皇后放在一个国际象棋桌上，以这样的方式没有皇后攻击其他皇后。

一个理想和目标状态，没有一个女王攻击另一个女王。

为了解决这个问题，我们首先需要对这个问题进行数学描述。所以让我们把它公式化为一个优化问题:

性能函数——相互攻击的女王对的数量。
问题的状态——棋盘上皇后的排列——我们将使用它们来找到它的成本值。
求解的方法——我选择了遗传算法。

《人工智能——现代方法》一书的插图显示了交叉过程中桌子本身的分裂。但不幸的是，有时它会违反问题的主要规则——女王的数字必须是 8。

书中所示的拆分方法。由此产生的国际象棋桌上有 7 和 9 皇后——违反了主要规则。

那么，在交换过程中，在不改变皇后数量的情况下，有什么更好的模型来描述棋盘的排列呢？什么描述了皇后在餐桌上的位置？
当然坐标！所以，通过把染色体描述成一列皇后坐标。但是变异就像随机改变女王的坐标一样。

结论

所以作为我的结束语，我想给你一个建议。如果你想成为一名人工智能研究员或人工智能工程师，我真的建议你不要坚持机器学习和神经网络等技术，尤其是 sklearn 或 Keras 这样的框架。更好地学习建立你自己的，就像我们在 Sigmoid 做的那样。最重要的是学会用公式表达问题和解决问题的模型。

额外收获:python 实现。

更多资源:

麻省理工学院人工智能课程:第 14 讲

数据科学家应该具备的最重要的技能

原文：https://towardsdatascience.com/the-most-important-skill-a-data-scientist-should-possess-d0700de3e5fa?source=collection_archive---------37-----------------------

不要从数据开始，从人开始

乔希·卡拉布雷斯在 Unsplash 上的照片

我们数据科学家需要有很多准备。提取、争论、清理、转换、查询、分析、建模、可视化、部署——所有这些都在一天之内完成。一个“全栈”数据科学家需要能够胜任无数的包、框架和技术，或者至少有能力在必要时快速提升技能。多样化的技术挑战是我们如此热爱这一领域的部分原因。

但是，尽管我们有先天缺陷，有一项技能我们都应该努力完善。

神入

《T4 牛津英语词典》将移情描述为…

将一个人的个性投射到(并完全理解)沉思对象中的力量。

作为一名数据科学家，你的思考对象可以指你的利益相关者、受众、最终用户，或者你正在使用数据了解或影响其行为的人。

数据科学是一种翻译练习。随之而来的是一个混乱的、定义不清的现实世界中的人类问题。这个问题的一个清晰明确的数字近似解决方案出来了。你的工作是确保这种近似很好地映射到人类问题，捕捉它的细微差别，满足涉众和用户的需求。为此，你需要设身处地为许多人着想，提出许多问题，并真诚地寻求理解是什么让人们产生活力。

同理心让你的工作保持相关性。

在零售分析行业工作，我最不喜欢的问题是“你能给我一些见解吗？”。完全开放和模糊，它邀请你跳下一个又一个兔子洞，寻找一些“有趣”的东西。随着截止日期的临近，你匆忙地将几个松散连接的图表和“知识”拼凑成一个 Powerpoint，然后向一屋子呆滞的目光和没有被仔细检查过的手机展示。致命一击是一个可怕的问题，“这很好，但那又怎样？”。

照片由埃德温·安德拉德在 Unsplash 上拍摄

为了让你的作品受到重视并引起观众的共鸣，你必须了解他们的动机和议程。这意味着要问很多愚蠢的问题，以建立对他们关心什么以及什么能给他们带来最大价值的真正理解。

经过多次的学习，我现在意识到数据科学项目最重要的部分远在你开始敲键盘之前。不要从数据开始，从人开始。如果你从关注数据开始，你可能只会考虑你能利用它做什么，而不会考虑什么能提供最大的价值。如果您首先关注向您寻求帮助的人，您可以更容易地确定最有益的问题和功能，并可以担心以后如何找到您需要的数据。

有时这迫使你出卖一点灵魂。在公司的黑暗政治中，偶尔你会不得不与那些不一定致力于追求知识的人一起工作。与其说是寻找的真理，不如说是寻找的真理，我们可以一起工作。在这种情况下，您的客户有一个特定的议程，需要数据来帮助证明这一点。你的工作是理解客户和他们的观众的动机，并找到一个角度，在不损害你的诚信的情况下，对数据进行积极的解释。**

同理心给你“为什么”

分析有关人们行为的数据也需要同理心。原始数据可以告诉你一个人是谁，什么，何时，何地，怎么样，但不能告诉你“为什么”。为了弄清楚他们为什么这样做，你需要运用你的想象力把桌子上的一排变成一个活生生的人。

在你的数据集中挑选一个人，然后问“这个人是谁，为什么他们会有这样的行为？”。仔细想想他们的生活方式可能是什么，他们在想什么，以及他们正在做出什么决定来在数据中留下他们的“足迹”。

照片由大卫·维克斯列尔在 Unsplash 上拍摄

以超市为例，您可能会问:

他们喜欢从头开始烹饪吗？
他们花钱谨慎吗？
他们进店时是习惯性的，还是冲动性的？
他们是计划开一家大商店，还是需要什么就来？
他们有孩子或者和伴侣住在一起吗？
他们是为了普通的工作日夜晚，还是为了款待或娱乐而购买？

将此与定性研究(调查、焦点小组、使用和态度研究)相结合，有助于充实您的数据所代表的真实人群。

在较浅的层面上，这种思维给你的集群起了名字，并提供了一些轶事来帮助活跃演示。在更深的层次上，这些问题导致更深思熟虑的分析、更准确的模型以及对数据如何反映现实的更直观的看法。

移情是永恒的

在您作为数据科学家的职业生涯中，您将投入大量的时间和精力来学习技术，而这些技术几年后就会过时。但是在 PyTorch 灭绝和熊猫灭绝很久以后，理解其他人的需求和需要的需要将会继续。当然，直到机器人启示录。

匡威“查克·泰勒”全明星赛，今天和 1917 年一样受欢迎。照片由卡蜜拉·达马西奥在 Unsplash 上拍摄

我们使用的技术只是工具，真正的挑战是如何应用这些工具去实现其他人关心的事情。那些今天开始在工作场所工作的人可能会一直工作到半个世纪以后。他们将不得不应对我们工作方式的无数变化，这些变化在今天是不可思议的。想想自 1970 年以来的 50 年间发生了多大的变化。但是同情你的人类同胞的需要一如既往地强烈，并将继续下去。

当然，同理心也可以高度转移到其他职业和你的个人生活中。如果你努力解读新同事/未来同事的内心想法，换工作会更顺利，成功的几率也会更高。花时间考虑他人的感受会让你成为更好的伴侣、朋友、父母或同事。

照片由凡妮莎·布姆比尔斯在 Unsplash 上拍摄

一项我们都可以努力的技能

我们的行业是建立在硅片、数学和计算机代码之上的。我们陶醉于进步的步伐以及数据科学带来的考验和机遇。但是我们工作的真正价值是其他人从中发现的价值。我们克服的技术挑战毫无价值，除非我们帮助别人解决问题，让他们的日子更轻松。通过花时间去了解其他人，无论他们是利益相关者、观众还是数据库中的名字，你的工作将会有你努力应得的质量和影响。

数据科学家最重要的技能

原文：https://towardsdatascience.com/the-most-important-skill-of-a-data-scientist-2b7f7f03635a?source=collection_archive---------39-----------------------

意见

由 Unsplash 上的克里斯托佛罗拉拍摄的照片

近年来，数据科学获得了极大的普及。对数据科学领域技术人员的需求很高，而且还在不断增加。因此，越来越多的人试图进入这个领域。

但是，这绝对不容易。

你需要有一定的技能才能在这个领域找到工作。虽然要求可能会根据职位的不同而变化，但基线是围绕线性代数、统计学、软件技能和领域知识建立的。

抛开这些不谈，我认为数据科学家应该具备的最重要的技能是其他东西。在我解释那个技巧之前，我最好提一下我认为数据科学是什么。

数据科学正在从数据中创造价值。

数据是以任何格式收集的任何信息。人们花在社交媒体上的时间，雨天的数量，媒体上的博客帖子，手机上的视频，等等。

数据科学领域使用了许多工具。在收集、存储、检索、处理和建模方面，你几乎可以对数据做任何事情。而且，由于计算机技术的进步，你可以以惊人的速度做到这一点。

一天下来，归结起来就是回答“你创造了什么价值吗？”。该值可以有多种形式。例如:

改进流程
预测更好的东西(例如对商品的需求)
帮助人们更有效地完成工作(例如检测 x 射线图像中的特定情况)

我可以成为数据清理和处理的专家。我可以创造最先进的模型。然而，我并没有以某种方式为使事情变得更好做出贡献，可以肯定地说，我的工作已经被证明是无用的。

数据科学有潜力创造巨大的利益。例如，科学家已经使用深度学习检测木薯的病毒疾病，木薯是非洲最重要的食物来源之一。虽然人们可能已经获得了理解植物是否有疾病的经验感，但深度学习使它更容易、更快、更准确。

另一个例子是原油蒸馏过程，这是一个高耗能的过程。机器学习技术用于分析原油成分，从而改进蒸馏过程。这就是更有效地利用自然资源的价值。

我们可以很容易地扩展例子的列表。但关键是，如果你想从事数据科学，你的重点应该是价值。这是创造数据科学产品的唯一途径。

当我们开始在数据科学领域的旅程时，我们需要有这种创造价值的心态。否则，我们将更多地成为数据科学实践者，而不是使用数据创造价值的数据科学家。

当然，我们在旅途中需要一套工具。我们绝对需要这些工具来实现我们的目标。例如，如果没有统计，我们可能无法理解或理解数据之间的某些属性或关系。线性代数是全面理解数学运算的关键。

为了创建性能良好的模型，我们需要大量的数据，这些数据需要我们使用软件来处理或建模。因此，软件技能也很重要。

这些硬技能是可以学习的。你应该只是学习和练习。网上有很多学习资料，这使得学习它们变得很方便。但是，从数据中创造价值的技能是学不来的。没有一个证书叫“如何从数据中创造价值？”据我所知。

更像是一种心态。你总是需要关注价值。这是一切开始的地方。它甚至在收集数据之前就开始了。

马修·施瓦茨在 Unsplash 上的照片

虽然这种技能不能像数学或统计学那样学习，但随着经验的积累会变得更好。你最终会使你的思维方式始终集中在价值上。而且，你不需要像上图中的人那样等那么久。创造价值的心态将会成长并成为根本。

感谢您的阅读。如果您有任何反馈，请告诉我。

最重要的统计测试

原文：https://towardsdatascience.com/the-most-important-statistical-test-dee01f4d50cf?source=collection_archive---------28-----------------------

剧透警告:可能性比率测试

似然比检验(LRT)“统一”频数统计检验。诸如 t 检验、f 检验、卡方检验等品牌检验是 LRT 的特定案例(甚至是近似值)。

因此，令人惊讶的是许多人从未听说过 LRT。当我帮助人们解决他们的统计问题时，大多数时候他们只需要表演 LRT 就可以了。但是之后他们会问这是什么，问怎么做。如果你必须记住一个统计测试，那应该是 LRT。

本文将带您了解 LRT 的理论和应用。假设对数理统计有基本的了解。

尽管我学习贝叶斯理论，但任何应用统计学家也必须理解基本的频率主义方法。人们通常没有时间学习理论上的开销，上级要求报告中的 p 值。

什么是 LRT？

顾名思义，我们采用两种可能性的比率，并对其进行转换:

我为这个迟钝的符号道歉，但是它和维基百科中的一致，所以请参考它来澄清。分子是零假设下的似然，分母是零和备选假设并集下的最大似然。我用这个量δD 来表示零模型和松弛模型之间的偏差，-2 对数似然+某个常数(从减法中抵消)。如果现在还不清楚，不要担心；通过下面的一些例子，LRT 应该会变得更加清晰。

那些曾经看过 AIC 或 BIC 的人可能会对看似任意的-2 感到困惑，但偏差是很重要的，因为δD 是渐近χ分布的，其自由度(df)等于两个模型之间 df 的差异(估计参数数量的差异)。这个惊人的事实使得大多数假设检验成为可能。

尼曼-皮尔逊引理证明了 LRT 的使用是合理的，该引理指出 LRT 是比较两个简单假设的最强大的测试，例如 H0: θ = 0 和 Ha: θ = 2。

因为备选假设通常不简单，比如θ ≠ 0，我们用极大似然估计(MLE)将其简化为简单的比如θ = 2。通常最大似然估计是通过(广义)线性回归完成的。直觉上，如果我们不能在最大似然估计处拒绝零假设，那么我们不可能在任何其他点拒绝，所以最大似然估计是唯一重要的点。

将点连接起来:f 检验

用人类的语言来说，我们在比较两个模型:一个有约束，另一个有约束的放松。你经常把它看作

在零模型中，我们将平均值限制为 0。在另一个模型中，我们允许平均值不为零。然后我们需要指定一个似然函数。这里，为了保持熟悉，我们假设观察值来自方差σ = 1 的正态分布。最大似然是样本平均值。因此:

这看起来很粗糙，但是δD术语看起来很熟悉:回归平方和(SS)！(应该是缩放的，但是这里的 scale 参数是 1。)它可以重新表示为总 SS 减去剩余 SS，如第二行所示。而 χ分布被定义为来自标准正态分布的 SS，所以这一切都有意义。因为在替代模型中我们估计了一个额外的参数，所以δD 遵循具有 1 df 的χ分布。

如果方差未知呢？那么零模型估计一个参数，而替代模型估计两个参数，因此 df 的差异仍然是 1。在这种情况下，我们更熟悉地称之为 ANOVA 或 f 检验，在本例中相当于截距的 t 检验。

还记得我的观点吗，所有这些名字不同的统计测试实际上都是一样的(LRT)？是啊。这里有一些 R 代码来演示等价性:

set.seed(123)
x <- rnorm(50, 0.5, 1)
model0 <- lm(x~0)
model1 <- lm(x~1)anova(model0, model1)
summary(model1)
t.test(x)

你可以把偏差看作是应用于非正态分布的 SS 的推广。虽然不完全准确，但直觉是存在的。作为练习，将二项式偏差与对数损失函数进行比较，后者有时会在分类模型中进行优化。

连接这些点:G 测试

除了测试样本均值之外，我们通常还想测试列联表的独立性。统计学充斥着许多过时的传统，这是其中之一。

大多数人会立即跳到皮尔逊卡方检验，但这仅仅是 T2 G 检验的近似值，是 LRT 的一个特例。在计算器出现之前，取对数很困难，所以统计学家使用卡方检验来简化计算。令人惊讶的是，我们现在有了计算器，但仍然没有默认切换到 G 测试。(另一个常见的替代方法， Fisher 精确检验，提供精确的 p 值，而不是依赖于渐近值，但是阶乘使得它对于大样本量的计算不切实际。)

相依表

可能性有多大？在独立情况下，我们可以认为数据是从多项式分布中生成的，其中落在每个像元中的概率是

有了依赖，每个单元格中的下降概率为

我们可以将δD 计算为:

这相当于 G-test 的 Wikipedia 页面中的测试统计。这个看起来很可疑 KL 发散，嗯？有趣的是，许多概念是如此的相互关联。

我们可以使用泊松回归很容易地执行这个测试:y~x1+x2 对 y~x1+x2+x1*x2。(相当于作为练习留下的多项式模型。哦不。我变成了我讨厌的东西。)

当所有πN 都很大时，卡方检验和 G 检验得出相似的 p 值。G 检验应该是更可取的，因为 LRT 是最有效的检验，并且检验统计量的分布更接近χ分布。

library(data.table)N <- 100 # play around with this
factor1 <- sample(
  c('A', 'B'), 
  N, 
  replace = TRUE, 
  prob = c(0.4, 0.6)
)
factor2 <- ifelse(
  factor1 == 'A',
  sample(c('C', 'D'), N, replace = TRUE, prob = c(0.3, 0.7)),
  sample(c('C', 'D'), N, replace = TRUE, prob = c(0.7, 0.3))
)
dat <- data.table(factor1, factor2)
xtab <- table(dat)
dat_count <- dat[,.N, by = .(factor1, factor2)]model_indep <- glm(
  N~factor1+factor2, 
  data = dat_count, 
  family = 'poisson'
)
model_dep <- glm(
  N~factor1*factor2, 
  data = dat_count, 
  family = 'poisson'
)
summary(model_indep)
summary(model_dep) # the fitted match the observed so deviance = 0pchisq(model_indep$deviance, df = 1, lower.tail = FALSE) # G-test
chisq.test(xtab) # Chi-Squared test

以上是 LRT 的一般程序。我们拟合了一个简单的回归模型，并将偏差与一个更复杂的模型进行比较。

如何表演 LRT？

从前面两个例子来看，很明显:

计算约束零模型下的最大对数似然
当约束放松时，计算最大对数似然
将δD 与具有适当 df 的χ分布进行比较，以获得 p 值

1)中的模型必须在 2)下嵌套。毕竟放松约束就是这个意思。否则，δD 没有理论上的保证。

例如，y~x1 对 y~x1+x2 的δD 是公平的，因为在第一个模型中，我们约束 b2 = 0，而在第二个模型中，我们放松了这个约束。

但是 y~x1 对 y~x2 的δD 是没有意义的。在第一个模型中，我们没有约束 b1 = 0，而在第二个模型中，我们有约束 b1 = 0。对于 b2 来说，反之亦然。

有时我们有一些假设，比如 H0: θ ≤ 0，哈:θ > 0。为了确保模型是简单的和嵌套的，当θ ≤ 0 时，零模型应该是最大似然，而当θ是任意实数时，替代模型应该是最大似然。

手工计算最大似然估计很麻烦，而且大多数时候最大似然估计没有封闭解。幸运的是，我们可以利用计算机的力量。

对于线性模型，统计软件包有内置函数来计算 GLMs 的 MLE，它涵盖了您想要测试的大多数假设。(小心！在 Python 中，sklearn 的逻辑回归函数不也不计算最大似然估计，并且会产生不正确的偏差。请改用 statsmodels。)我认为 GLM 是应用统计学家最重要的技能，因为如此多的推理任务都可以归结为 GLM 问题。

对于更复杂的似然函数(如截尾和截断)，你需要写下函数并进行数值优化。

最后

你可以放弃几十种不同的统计测试，用 LRT(主要通过 GLM)取而代之，这应该是最强大的测试。学习如何将问题框定为正确的回归公式，选择最合理的分布，并诊断模型。

编写正确的回归公式是最棘手的部分。加入太多变量会导致非常不正确的推论。逐步回归是而不是要做的事情的典型代表，而正则化方法是而不是 MLE，因此我们无法计算δd。参见以前的文章以了解如何选择变量。

机器学习工程师最需要的技术技能

原文：https://towardsdatascience.com/the-most-in-demand-tech-skills-for-machine-learning-engineers-7498754887d4?source=collection_archive---------18-----------------------

机器学习工程师和数据科学家、数据工程师有什么不同？

在这篇文章中，你会看到新的研究显示了机器学习工程师工作清单中最受欢迎的技术术语。📊

我们将探索机器学习工程师如何适应组织中的数据流。最后，我将分享一个机器学习工程师技能的建议学习路径。

资料来源:pixabay.com

机器学习工程师是一个听起来很时髦的职位，这个职位的人报酬很高。根据一份分析，这是 2012 年至 2017 年领英上最热门的新兴工作。的确报道称，截至 2020 年 6 月 26 日，美国机器学习工程师的平均工资为 140536 美元。不算太寒酸。😀

让我们看看机器学习工程师如何适应组织内的数据流。

组织中的数据流

这是数据如何在组织中流动的示意图。

由杰夫·黑尔创作

数据被生成、接收并存储在数据库中。可以通过 ETL 修改数据，使其更加可用，ETL 代表提取、转换、和加载。

然后，这些数据可以用来制作机器学习模型，进行推理，并创建分析。

如果数据用于机器学习模型，那么这些模型可能会通过网站或 API 提供给世界。那是左边的小路。📱

或者，如果数据是为了建立因果关系而获得的(通常是通过实验),那么可以进行统计分析并共享。🔬

最后，如果数据用于事后分析以收集见解，它可能会被输入到报告或演示文稿中。🖥

让我们将经常伴随数据流的角色添加到图表中。

数据角色

由杰夫·黑尔创作

橙色框代表做数据工作的人。😀

数据工程师负责制作数据管道。他们创建系统来接收、存储数据，并将其转换为可供数据科学家和数据分析师使用的形式。💻
数据科学家创建机器学习模型来帮助驱动决策和创建预测工具。他们也可能做实验和统计推断来得出因果结论。这第二个角色更多的是传统的统计学家的角色。🧪
数据分析师在现有数据中发现见解，并与利益相关方分享这些信息。📊
机器学习工程师采用数据科学家创建的概念验证机器学习模型，并将它们转化为可扩展、优化、可服务的模型，供 API 和应用程序使用。👩‍💻

角色之间经常有很多重叠。🙂

请注意，数据科学家可能更专注于机器学习或统计推断。这种区分类似于迈克尔·霍克斯特的对 A 型和 B 型数据科学家的区分。A 型数据科学家做更多的静态、统计推断和分析，B 型数据科学家做更多的机器学习系统构建和软件工程。参见 Robert Chang 的优秀文章进行讨论。

在小型组织中，数据科学家可能是多面手，扮演上图中所示的所有角色。如果组织是年轻的，首先需要的是让数据管道成形。然后是核心指标的分析、报告和仪表板，以推动业务决策。因此，数据工程师和数据分析师通常是早期雇员。

随着组织的数据和数据能力的增长，机器学习工程师通常会在稍后添加。如果机器学习是一个组织的核心竞争力，你会很快看到更多的机器学习工程师。👍

我们在这篇文章中的重点是机器学习工程师，所以让我们深入了解他们做什么。

资料来源:pixabay.com

机器学习工程师技能

机器学习工程师的工作与数据科学家或数据工程师的工作有什么不同？

⭐️机器学习工程师采用科学家创建的显示预测前景的模型数据，将它们转化为在生产中表现良好的代码。⭐️

机器学习工程师需要编写代码来:

预测准确
生产准备好了吗，容易理解吗
运行速度快，内存效率高
对道德因素敏感

第一点需要了解如何评估机器学习模型的性能。机器学习工程师需要调整模型并测试不同的架构来提高性能。正如你马上会看到的，许多雇主正在寻找具有深度学习框架的技能。

机器学习工程师为生产编写代码，因此他们需要实践良好的软件开发实践。他们需要熟悉版本控制，遵循通用的代码风格规则，并且很好地记录代码。他们可能会处理持续集成、测试和容器化。他们甚至可能处理用于部署的容器编排——正如您稍后将看到的，Kubernetes 和 Docker 出现在相当多的工作描述中。

生产代码需要快速高效，所以机器学习工程师应该有计算机科学和大数据原理的基础。有很多方法可以提高代码效率和性能。我已经起草了一个关于这个主题的粗略大纲，所以跟我来以确保你不会错过完成的指南。😀

最后，机器学习工程师需要了解他们的模型可能会如何对人产生负面影响。查看凯茜·奥尼尔的数学毁灭武器的介绍。机器学习工程师的权力很大，俗话说:权力大责任大。🕷

现在让我们看看在机器学习工程师工作清单中找到的具体技术。

方法

我从搜集信息，简单雇佣了和怪物，看看在美国的工作列表中哪些关键词出现了“机器学习工程师”。我在分析中使用了请求、美汤、熊猫和 Plotly Python 库。

我使用了从我对数据科学家、数据工程师和数据分析师工作列表的分析中收集的技术关键词。实际上没有包括在内，因为它偶尔不返回常见术语的信息，并且对于没有关键字的基线情况，它有时返回非常不同的计数。LinkedIn 没有被搜索到，因为它之前在抓取了它的网站后将我锁定在我的账户之外。☹️

对于 Monster 和 SimplyHired，我计算了每个关键词出现在总机器学习工程师列表中的百分比。然后我平均每个关键词的百分比。

结果

这是 2020 年 7 月 1 日出现在至少 15%的工作列表中的技术术语。

让我们开始吧！😀

大多数雇主都在寻找拥有 Python 技能的机器学习工程师。Python 在四分之三的工作列表中都能找到！🐍

TensorFlow 是第二常见的技术，出现在超过 40%的所有机器学习工程师列表中。TensorFlow 是一个开源的深度学习框架。

让我们看看其他频繁出现的深度学习框架。

Keras 在 20%的列表中。Keras 是 TensorFlow 的高级 API，现在与 TensorFlow 2.0 紧密集成。两者都主要是由谷歌开发的。

另一个主要的深度学习框架 PyTorch 出现在超过四分之一的列表中。它比 TensorFlow 年轻，但使用量一直在增长。看我这篇探索 PyTorch 和 TensorFlow 流行度的文章这里。

Java 出现在近三分之一的列表中。Java 是最常用的软件开发语言之一。然而，它不像 Python 或 r 那样被教授给数据科学。

Apache Spark 常用于大数据应用。它支持许多编程语言，包括 Java、Python、R 和 Scala。

AWS 是机器学习工程师最常见的云提供商，在近 30%的列表中出现。这并不奇怪，因为它是占主导地位的云提供商。

与其他术语的比较

下面的图表比较了十个最常见的机器学习工程师术语，以及这些术语在数据科学家和数据工程列表中的常见程度。

2020 年 7 月 1 日

可以看到 Python 对于这三个职位都是相当受欢迎的。让我们来看看几项存在巨大差异的技术。

数据工程师列表中包含 SQL 可能性是机器学习工程师列表的两倍多。数据科学家列表中也更有可能包含 SQL。这是有意义的，因为机器学习工程师更加关注组织数据管道中更下游的数据。

C++ 出现在近四分之一的机器学习工程师列表中。这是数据科学家和数据工程师列表中的三倍多！机器学习工程师经常需要为快速训练和推理进行优化，像 C++这样的低级语言可以加快速度。🚀

Scikit-learn 在机器学习工程师列表中比在数据科学家或数据工程师列表中被提及的频率高得多。我很惊讶它没有更多地出现在数据科学家列表中。🤔

R 在机器学习工程师列表中比在数据科学家工作列表中更不常见。然而，它比数据工程师列表中更常见。r 通常用于 A 类数据科学/统计领域，尤其是在学术界。在机器学习产品中就少多了。

值得一提的是，在 2020 年栈溢出开发者调查中，Java、C++和 R 都被更多的人列为害怕的，而不是喜欢的。

这里有一个扩展的技术列表，平均至少出现在 5%的列表中。

建议

如果你想成为一名机器学习工程师，你将需要强大的软件开发和机器学习技能，以及多项技术的能力。你当然不需要学习使用上面列出的所有技术，但是如果你的最终目标是成为一名机器学习工程师，我建议你学习一些。

首先，现实一点:如果你正在从一个完全不相关的领域过渡，不要指望你会直接跳到一个机器学习工程师的角色。它发生了，但是我的感觉是它是罕见的。

在进入机器学习工程师的工作之前，你通常需要有相邻职位的经验。这些职位通常需要在计算机科学、数学或所谓的硬科学方面有很强的学术背景。相当多的机器学习工程师拥有硕士学位或博士学位。🎓

如果你想成为一名机器学习工程师，确保你了解 Python。这是机器学习的通用语言。如果你是 Python 的新手，我可以推荐我的难忘的 Python 书吗？😉

然后学习机器学习库 NumPy 、熊猫和 scikit-learn 。这些术语都出现在相当多的工作列表中，并在很大程度上被认为是机器学习工程师的工作。如果你也想学，我有一本关于熊猫的书给你。🐼

你应该知道 Git。凯蒂·塞勒-米勒和朱莉娅·埃文斯有一本关于这个话题的有趣的书在这里。

正如你在上面看到的，雇主通常希望有深度学习框架的经验。要入门，推荐阅读 Keras 的原作者Fran ois Chollet的《深度学习与 Keras》。在 2020 年晚些时候发行之前，你可以使用曼宁的早期访问程序来查看该书的更新版本。那本书会让你很好地适应 TensorFlow。

如果你想学习 PyTorch，fast.ai MOOC 是一个很好的介绍。它有很棒的视频和支持深度学习的社区。

学 SQL 是个好主意。我有一本关于 PostgreSQL 的 SQL 入门书,目的是做一个温和的介绍。

那么我建议你学习 AWS 基础知识，这样你就熟悉了最流行的云平台。 Linux Academy 有很棒的互动在线课程。

我建议你学习你需要的数学，因为你需要它做一个项目。脱离上下文学习数学很难。在某些时候，你可能想学习线性代数。 3Blue1Brown 在 YouTube 上有关于这个和许多数学和机器学习主题的精彩讲解视频。

一路走来，做好自己的项目，投入生产。定期参与 GitHub 活动，并在活动过程中回馈社区。参加 Kaggle 比赛。一边走一边与世界分享你的技能。🚀

这应该够你忙的了。😀

要知道的事情太多了，可能会让人不知所措，但是不要感到不知所措或气馁。一次只处理一件事，坚持，坚持，坚持。👍

记住，每个人都有自己的学习之旅——总有更多的东西要学。这使得机器学习令人兴奋。🎉

包装

我希望你发现这个机器学习工程师技术技能的分析和讨论是有帮助的。如果你有，请在你最喜欢的社交媒体上分享，这样其他人也可以找到它。😀

我写关于 Python 、 SQL 和其他技术主题。如果你对这些感兴趣，请注册我的邮件列表，那里有很棒的数据科学资源，点击这里阅读更多帮助你提高技能的内容。👍

资料来源:pixabay.com

机器学习快乐！🚀

Twitter 上最受欢迎的数据科学文章主题

原文：https://towardsdatascience.com/the-most-popular-towards-data-science-article-topics-on-twitter-2ecc512dd041?source=collection_archive---------49-----------------------

介绍文本分析，可以增加你的文章受欢迎程度

如果您已经撰写了数据科学文章或正试图开始，找到最受欢迎的主题对让您的文章被阅读有很大帮助。下面是使用 R 和分析结果轻松确定这些主题的步骤。本文也可以作为使用 API 的介绍，并在 r 中进行一些基本的文本处理。如果您只对结果感兴趣，可以随意修改这段代码来进行其他的 Twitter 分析并跳到最后。

图片由皮克斯拜的 Gerd Altmann 提供

Twitter API

如果你没有 twitter 账户，你需要创建一个。之后前往推特开发者。使用新帐户登录后，您可以选择“应用程序”菜单，然后创建应用程序。在那里填写应用程序的详细信息，在大多数情况下，除了应用程序的名称和详细信息，这可以留空。

安装 R 包

我们需要 3 R 软件包来完成这个项目——rtweet、tidyverse 和 tidytext。安装这些与

install.packages("package-name")

确保在脚本中使用 library()函数加载了这些包。

收集推文

要获取推文，我们首先需要生成一个令牌。我们可以用 rtweet 包中的 create_token()函数来实现。可以通过查看 Twitter 开发者网站上新应用页面上的信息来填充参数。所有这些变量对于安全性都很重要，所以无论何时使用 API，都要确保采取预防措施，将这些令牌和密钥保持为私有。

token <- create_token(app = "<app-name>",
  consumer_key = "<consumer-key>",
  consumer_secret = "<consumer-secret>",
  access_token = "<access-token>",
  access_secret = "<access-secret>")

现在来抓取推文！使用 get_timeline()函数来访问任何公共用户的 3200 条最近的推文，以便在一次查询中获得比这更多的内容。

tweets <- get_timeline("TDataScience", n=3200, token=token)

现在有 50 列数据和 3200 行存储在变量“tweets”中。我们主要关心的是 text、favorite_count 和 retweet_count 列，但是您也可以研究一下还需要查看什么。

删除不需要的短语

我们还想删除一些在这个域中常见的东西，主要是链接和 twitter 句柄。我们可以使用 gsub()函数将出现的链接和句柄替换为其他内容，在我们的例子中，我们通过用空字符串替换它们来删除它们。下面，我们使用管道操作符将文本列从一个 gsub()函数传递到下一个函数，删除 URL 和句柄，最终将它们保存在一个名为 clean_text 的新列中。

tweets$text %>% 
gsub("?(f|ht)(tp)(s?)(://)(.*)[.|/](.*)", "", .) %>% 
gsub("@([A-Za-z0-9_]+)", "", .) -> tweets$clean_text

删除停用词

现在我们想从 clean_text 列中删除停用词。停用词是对理解文章意思不重要的词。这些通常是一种语言中最常见的单词，但是对于某个特定的领域，您可能想要删除一些额外的单词。在我们的任务中，我们可能认为“数据”这个词无关紧要，因为几乎每篇文章都会提到数据。

标记化是将文本分割成多个部分的过程。这可以是句子、段落、单词或其他。在我们的例子中，我们将使用按单词拆分，这将获取我们的数据表，并使每个 tweet 中的每个单词在一个表中占一行。下面我选择感兴趣的列，然后对单词进行标记。

tweets %>% 
select(clean_text, favorite_count, retweet_count) %>%
unnest_tokens(word, clean_text)

这留给我们下面的表格，其中单词“include”、“training”和“operations”最初都是 clean_text 列中同一行的一部分。

现在我们继续对 tidytext 包中的 stop_words 数据集进行反连接。这将删除属于 tweets 数据集和 stop_words 数据集的所有单词(本质上，这将从您的数据中删除停用词)。这方面的代码如下。

tweets %>% 
select(clean_text, favorite_count, retweet_count) %>%
unnest_tokens(word, clean_text) %>%
anti_join(stop_words)

获得平均收藏和转发

使用 tidyverse 中的 groub_by()和 summarise()函数，我们可以获得数据集中每个单词的收藏和转发次数的中位数。我在这里选择使用中位数来消除一些异常值可能对我们的数据产生的影响。

tweets %>% 
select(clean_text, favorite_count, retweet_count) %>%
unnest_tokens(word, clean_text) %>%
anti_join(stop_words) %>%
group_by(word) %>% 
summarise("Median Favorites" = median(favorite_count), 
  "Median Retweets" = median(retweet_count),
  "Count" =  n())

过滤结果

我们希望看到有最多人喜欢/转发的单词来通知我们应该写些什么。但是让我们考虑一个单词只使用一次的情况。例如，如果有一篇关于数据科学应用于密歇根地理的非常受欢迎的文章，我们不希望这使我们偏向于写关于密歇根的文章。为了解决这个问题，我用 filter()函数过滤掉至少 4 条 tweets 中没有使用的所有单词，然后用 arrange()函数对结果进行排序。留给我们最后一点代码。

tweets %>% 
select(clean_text, favorite_count, retweet_count) %>%
unnest_tokens(word, clean_text) %>%
anti_join(stop_words) %>%
group_by(word) %>% 
summarise("Median Favorites" = median(favorite_count),
  "Median Retweets" = median(retweet_count), 
  "Count" =  n()) %>%
arrange(desc(`Median Favorites`)) %>%
filter(`Count` > 4)

决赛成绩

因此，如果您想跳到最后看看结果如何，或者不想自己运行这段代码，下面是结果。这些是《走向数据科学》中的常用词，根据包含该词的推文通常获得的喜爱程度进行排名。

网站— 84.5 收藏夹
金融——72 个最爱
动作— 66 个收藏夹
matplotlib — 59.5 收藏夹
绘图— 57 个收藏夹
漂亮— 55.5 个最爱
作品集— 51 个最爱
探索— 47 个最爱
github — 46.5 收藏夹
综合— 46 个收藏夹

注意:我不得不删除“詹姆斯”这个词，因为显然有一个作者非常喜欢这个名字。恭喜你，詹姆斯！

我现在的建议是写一篇题为“用 Matplotlib 创建漂亮的财务图的综合指南”之类的文章。现在，你可以对任何其他拥有公共账户的 twitter 用户重复这个过程。

SKlearn 中最强大的组合拳:Pipeline & GridSearchCV

原文：https://towardsdatascience.com/the-most-powerful-one-two-punch-in-sklearn-pipeline-gridsearchcv-9fd5b66f1819?source=collection_archive---------46-----------------------

澳门图片社在 Unsplash 上拍摄的照片

额外的好处:没有更多的意大利面条代码

有没有被自己的意大利面卡住过？

听起来很美味。

但是对于编码人员来说，这是非常令人沮丧的。

我将尝试为您提供两种工具，它们将缩短您的代码，并让您重新控制您必须经历的许多迭代，以优化您的机器学习工作流，而不是逆来顺受。

你的模型构建代码是什么样的？

我的过去是这样的:

管道

上面的代码可以通过 Sklearn 中的管道模块以一种更加简洁和容易的方式编写。

GridSearchCV

假设我们希望优化我们的分类器，并通过不同的参数进行迭代，以找到最佳模型。最好的方法之一是通过 SKlearn 的 GridSearchCV 。它可以从您输入的参数集中为您提供最佳参数。

强力组合

继续拳击的比喻，把这个钩子和刺拳放在一起会形成一个强大的组合。

它肯定会让你大吃一惊。

我们将有一个非常干净灵活的机器学习工作流程，只需要几行代码:

最后，我们可能希望使它更加通用，这样我们就可以迭代几个不同的模型、参数和特性操作。

使用这个函数，我们现在可以有一个非常短的主函数:

请享受使用这一个二打孔机学习组合！

以前发表的文章包括:

改善电子表格预测的最强大的东西

原文：https://towardsdatascience.com/the-most-powerful-thing-that-improves-spreadsheet-forecasting-447d6168e5d6?source=collection_archive---------84-----------------------

用一个简单的清单来避免忽略它

艾萨克·史密斯在 Unsplash 上拍摄的照片

我在我参加过最无聊的项目管理研讨会上睡着了。话题已经转到预测预算和进度上，这时老师突然问道:“你们中有多少人上过校对课？”不要举起手来。下一个问题更具修辞性，类似于“你们中的大多数人大部分时间都在做检查和校对，但你们从未接受过这方面的培训？”这达到了预期的效果——在接下来的几年里，我参加了几门校对文本文档、计划和规范以及电子表格的课程。

要改进你的电子表格，你能做的最重要的一件事就是制定一份校对清单。我知道那既无聊又老套。这话有些道理。另一方面，我并不是建议一个令人痛苦的标准格式，或者一个繁重的质量保证计划，甚至是高度技术性的调试协议。每次开发电子表格时，只要遵循一个简单的校对清单，就能提供可靠、易懂和有见地的结果。

校对清单

清单被定义为一系列需要的项目、要做的事情或要考虑的要点，用作提醒。在实践中，核对表用于更好地组织任务，并轻松验证最重要的任务。在业务流程中，清单有助于减少错误，确保一致性和完整性。检查表不能代替政策或程序。

你的购物清单是最简单的例子。它提醒你什么是重要的，帮助你不要忘记一些事情；然而，它不能帮助制定你应该(或不应该)吃什么的政策，也不能指导你如何去商店或购物的顺序。

校对清单应该包括三个主要方面和几个子方面。

影响图

影响图是一个问题的可视化显示，它描述了目标、关键元素和依赖关系。不同方面之间的影响用连接箭头表示。影响图是最先进的计算机编程的一个正常部分，但是在电子表格的世界里却被可悲地忽略或跳过。影响图很重要，因为它使校对电子表格的人能够直观地(容易地)理解问题及其界限。

将“影响图”作为校对清单中的一行。最重要的是在你的电子表格中建立可视化图表。是的，还有其他准备工作，如问题陈述、边界条件、数据验证、选择正确的工具(例如，你真的想使用电子表格吗？)，以及结果的验证。让影响图保持简单、简洁和可视化。

质量的三个层次

校对清单的顶层由三个主要类别组成:模型在不崩溃的情况下计算结果；模型计算做了预期的事情(逻辑错误)；而且，这个模型构造得很好，很容易转移给其他人。有许多方法可以解决这些类别中的每一个。最重要的问题是评审活动至少包括每个类别中的一个活动。伟大的思想会在细节活动上有所不同，一如既往，在某些情况下这是一个偏好的问题。

与确保模型计算达到预期目的相关的最巧妙的方法是用全范围的输入对模型进行压力测试。换句话说，仅仅检查基本情况通常很难理解全部功能。否则，Excel 会很好地提供错误消息和线索来修复基本的计算问题。

识别和处理逻辑错误是最困难的方面。此活动下的一些活动可以包括:创建单独的摘要图表，尤其是在执行时序分析时；检查模型中计算的绩效比率之外的绩效比率；以不同的方式重新计算和汇总产出，并将敏感度与模型进行比较；和执行灵敏度分析。发现逻辑错误需要一种结构化的方法，在模型之外做一些额外的工作，以及直觉上什么是有意义的。

另一种独特但未被充分利用的方法与灵敏度图有关，包括那些使用概率方法的方法。敏感性图的一种常见形式是龙卷风图，它在顶部用宽条表示较重要的不确定性来源，在底部用窄条表示不太重要的不确定性来源。校对检查是所有的条应该接触代表总成本或收入的某种形式的中心垂直线。如果横条没有碰到垂直线。那么该输入对模型的结果没有影响。这个模型很有可能没有像预期的那样工作。创建龙卷风图，并寻找“飞行棒”。

审查一个模型以确定它是否被很好地构建、理解和转移给其他人是一个好的实践、文档和版本控制的功能。其中一些将在下一节讨论。然而，最重要的是要认识到电子表格将被传递给其他人使用和审查。

良好实践

校对清单的第三层也是最后一层包括组织或分析团队认为最重要的 5 到 10 个项目。同样，有许多非常详细的电子表格标准，关于这些标准也有很多争论。这里的要点是要有一些基本的标准，而不是包括所有可能的标准。请记住，清单在实践中用于更好地组织任务，并轻松验证最重要的任务。清单不是完整的政策文件或标准操作程序。

八个潜在的最佳实践包括:

1.包括输入选项卡和结果选项卡

2.对输入、输出和计算的单元格进行不同的颜色编码

3.在等式中，使用输入名称而不是单元格引用(战舰语言)

4.输入名称应该是一个或两个单词

5.所有等式中都应该使用小写字母

6.使用工作模型，并将工作模型标记为不同于主版本

7.指定用于质量保证的代码评审工具和方法

8.确定遗留代码是否(以及在哪里)被导入和利用

总结一下

要改进你的电子表格，你能做的最重要的一件事就是制定一份校对清单。电子表格开发有许多标准，调试代码有更多标准。但是，俗话说，不要只见树木不见森林。在实践中，我们通常会放弃质量分析中最重要的方面。与模型一样，从简单开始，逐步增加复杂性。开发和维护一个基本的校对清单。

我们应该留在数据科学领域吗？

原文：https://towardsdatascience.com/the-most-realistic-data-science-career-guide-d12c4af87cc8?source=collection_archive---------10-----------------------

办公时间

数据科学家的 4 个现实职业选择

由凯勒·琼斯在 Unsplash 上拍摄的照片

TL；“数据科学”成为主流已经快 10 年了。我们很少问如何进入数据科学，而是想知道“我应该留下吗？”以及“下一步是什么？”在这篇文章中，我分享了一些关于一些重要但实用的选项的见解——数据科学家的 4 个原型——以及它们的陷阱(对有抱负的数据科学家也很有用)。最后，你可以在最后找到一个现场调查，看看社区的发展方向。

2020 年 5 月 4 日更新: 我收录了一篇讨论调查结果的文章的链接。请在调查部分找到链接。

如果你的职位受到新冠肺炎的影响，并且你在加拿大工作或准备移居加拿大，加入这个开放的 人才帮助列表 寻找技术领域的潜在机会。注意安全，我们会很快度过难关的。

免责声明:本帖未经认可或赞助。我交替使用术语数据科学和 ML。

喜欢读什么？ 跟我上 中LinkedInTwitter。查看我的“ ”影响与机器学习 ”指南。它有助于数据科学家更好地交流。**

2020 年 2 月 27 日

大约在多伦多因为新冠肺炎而被封锁的三周前，我和一个朋友坐在多伦多市中心我们最喜欢的泰国餐馆里。

****“我应该留在数据科学吗？如果没有，接下来该怎么办？”朋友问。

就像聚会的声音和新鲜餐馆食物的味道一样，如何进入数据科学的问题现在似乎有点遥远。事实上，你可以在谷歌上找到约 30 亿条搜索结果，其中有一条极其具体的分步指南(只有约 20 亿条关于“如何赚钱”)。

截至 2020 年 3 月 25 日的谷歌搜索

然而，我朋友的问题挥之不去。在内心深处，这种紧张是由两个因素驱动的:1)数据科学的期望与现实— 它可能比我们预期的更无聊，以及 2)角色与我们的期望。

那么，有什么选择呢？

保持同样的角色，将挫败感内化(你可以跳过这篇文章，但请** 在点击关闭前分享🙂)**
离开目前的职位，但继续在其他地方做数据科学相关的工作(这篇文章是为你写的)
够了。我完全做完了(你确定吗？在此之前，请考虑选项 2)

但是，去哪里呢？

要知道我们想去哪里，你必须知道我们在哪里。为了更好地了解替代方案，我们许多人可能会问“什么是数据科学？”如果你在谷歌上搜索这个短语，我们可能会看到这样的内容:

什么是数据科学，图片来源

这种分类是有道理的，但它并没有真正抓住 日常工作 和 公司性质的现实和细微差别。 这两个因素可以说是我们做职业决策时最重要的。

有一种更好的方式来思考这个问题。所以，让我向你展示数据科学家的原型。

请稍等…

在我们开始之前，重要的是考虑我的背景和旅程，这样你可以根据你自己的现实和限制来翻译我的见解。

简而言之，我见证了数据科学的演变，为大型企业提供咨询，与许多类型的数据科学家成为朋友，并在一家最终被收购的人工智能初创公司构建 ML 产品。

我的观点只是一个数据点(希望这是一个有用且独特的数据点)，所以请留意其他人的观点。希望最后的调查能有所帮助。

选项:数据科学家的原型

那么，什么是数据科学？这取决于公司的规模(企业或初创企业)和角色的主要职责(面向客户或专注内部)。

当你面试一个数据科学职位时，尽管有头衔和工作描述，但很有可能归入以下四个过于简单且带有主观标签的类别之一。

数据科学家的四种原型。作者的分析

****你怎么能使用这个？原型向你展示了可能性。它让你看到你现在在哪里，以及眼前的选择是什么。对于有抱负的数据科学家来说，你可以用这个来计算你的最佳起点。

接下来，你可能会问:我怎么知道新角色是否更适合我？****

为了帮助你决定，这里有一些每个角色的优点和缺点。此外，我将讨论最适合的人才概况。当然，这些有点主观:对我好的可能对你不好。总有例外。所以你自己做判断吧。

注:

您还可以根据公司的其他方面进行分类，例如行业和产品类型(例如，与数据科学相关的服务或工具、非数据科学产品)。我认为公司的规模对日常工作的影响更大。
公司规模不是二元的，有许多中型公司；为了简单起见，我将其二进制化。
在初创企业，面向客户和内部员工之间的墙并不真正存在；人们倾向于两者兼顾。只是时间分配的问题。

1 —昂贵的顾问

全球咨询公司的数据科学服务或大型技术公司的专业服务部门(如德勤、麦肯锡、埃森哲、谷歌、IBM 等)。)

吉菲

:非常好的解决问题和高效工作的培训。做非常“重要”的事情，因为客户为结果支付高额费用。每个项目都可以不同，以防你感到无聊或沮丧。非常明确的晋升途径和要求(例如，从分析师、经理到合作伙伴)。接触高级管理人员，早期职业生涯中的广泛话题，以及许多雄心勃勃的人。

:商业价值压倒一切(例如科学创新和酷算法)。要求所有资历的工作时间。一些公司可能不会考虑传统合作伙伴轨道的数据科学家(你可能会觉得被边缘化，但不要担心，大多数人都非常尊重)。很多阿尔法人格。

:受过一些技术培训、渴望在大公司里经营自己的“小生意”的商务型人士。刚刚起步、正在寻找导师、想要学习最好的行话并且不介意非常努力的学生。

2 —精通技术的销售人员

在专注于人工智能的初创公司或中型公司担任技术销售或项目领导角色(例如， Dessa 、 Element AI 、 H2O 、 Cloudera 、 Palantir )。

GIPHY

:你可以从事一些前沿的用例，因为客户通常期待你的创新，而不是交付(乏味的)长期、大规模的转型项目。在重要的战略和产品决策上有更大的发言权。保持敏捷和创新。

不好的一面:一些客户可能不信任你的大项目(例如获得更多预算)，这是“灵活创新”的另一面可能需要做大量的“免费”工作来赢得客户的信任。与大公司相比，后台支持较少。产品愿景可能会受到投资者(如果你有错误的风投)或沉没成本心态的影响，而不是真正的市场需求。

:希望在早期阶段与公司一起成长，实现创业梦想，并且已经拥有坚实的商业网络、领域专长和/或声誉的人。不适合新手，因为你需要立即行动。

3 —产品嬉皮士

具有软件和/或 ML 背景的人，他们与工程人员一起在人工智能产品公司建立 IP、演示和支持销售电话。

吉菲

:致力于有趣和实际的问题，而不必处理太多的客户政治。短期项目。作为“内部用户”来影响或定义产品应该如何设计为客户或内部人员制作酷的东西。

:可能会被拉进一个面向客户或用户的角色，这会在竞争优先权和时间管理上造成紧张。很难在“前沿”和“立即实用”之间找到正确的平衡可能会陷入无休止的客户支持工作中。

:以产品为导向、以工程为中心，但有时又很粗鲁的人。经验丰富的专业人士，拥有特定技术堆栈或工作流领域的专业知识。具有开放和好奇心的学生，喜欢技术挑战，并能完成任务。

4——大家庭

好吧，家庭可能很复杂，所以这个群体需要分成两部分:无名英雄* 和超级极客。***

家庭结构。作者的分析

4.1 — 无名英雄

来自企业内传统 BI、分析和建模团队的人员。他们大多与业务线或职能部门合作(例如营销、风险、财务等)。)在数据科学家这个术语被创造出来之前，他们就是数据科学家。

吉菲

好的 :工作非常专注。接近真实的商业运作。可以访问独特的数据集。能够使用可运行的大规模基础设施。很好的工作生活平衡。对投资决策有影响力或权力。

坏消息 :事情在(大多数)时候会变得缓慢而乏味。通常不被认为拥有 21 世纪最性感的工作。内部政治。缓慢的职业轨迹。被某些角色或项目所束缚。

:在生活中找到激情或喜欢在特定领域投入时间的人。不在乎炒作的人。有很多耐心和韧性的人。

4.2 —超级极客

数据科学中“金童”的刻板印象。在 R&D 大公司工作的人，比如谷歌大脑/ DeepMind，脸书博览会，优步，沃尔玛研究等等。

吉菲

:从事非常理智的话题。能够接触到独特的数据集和问题。能够利用大公司的资源挑战极限。获得很多认可和赞扬。

:因不得不展示“商业价值”而产生的强烈紧张感。业务优先级可以限制或影响研究主题。如果研究证明了价值，可能会陷入“无聊”的实现中。

最适合 :学院派。对学术研究和教育背景非常感兴趣的工程师。希望发表文章并接触一些行业的研究生。

下一步是什么

现在你已经很好地掌握了什么是可能的，问自己这些问题:

我现在在哪里？我为什么会沮丧？
在我的数据科学职业生涯(或总体生活)中，我真正想要的是什么？
目的地是否提供了可感知的缓解和好处？(希望本文能提供一些见解)
我有哪些可行的选择？
我如何以最少的努力和最好的结果到达那里？

在下一篇文章中，我将分享一些常见的和非常规的路径及其挑战。敬请关注我的中、LinkedIn，或Twitter。

现场调查

这里有两个调查，希望了解我们的现状和我们想要达到的目标。所有数据都是匿名收集的。这不是用于任何商业目的，而是为了满足社区的好奇心。

这里有一篇文章讨论了这次调查的结果。

** [## 越线

数据科学家最受欢迎的过渡路线

towardsdatascience.com](/the-best-data-science-transition-routes-e809254934d0)**

喜欢读什么？ 跟我上 中LinkedIn，或者Twitter。还有，作为一名数据科学家，要不要学习商业思维和沟通技巧？查看我的“ ”影响与机器学习 ”指南。**

以下是我的一些文章，你可能会喜欢:

** [## 最有用的 ML 工具 2020

每个懒惰的全栈数据科学家都应该使用的 5 套工具

towardsdatascience.com](/the-most-useful-ml-tools-2020-e41b54061c58) [## 被遗忘的算法

用 Streamlit 探索蒙特卡罗模拟

towardsdatascience.com](/how-to-design-monte-carlo-simulation-138e9214910a) [## 数据科学很无聊

我如何应对部署机器学习的无聊日子

towardsdatascience.com](/data-science-is-boring-1d43473e353e) [## 12 小时 ML 挑战

如何使用 Streamlit 和 DevOps 工具构建和部署 ML 应用程序

towardsdatascience.com](/build-full-stack-ml-12-hours-50c310fedd51) [## ML 和敏捷注定的联姻

如何不对 ML 项目应用敏捷

towardsdatascience.com](/a-doomed-marriage-of-ml-and-agile-b91b95b37e35) [## 无用的机器学习

通过解决信任时刻来设计有用的 ML

towardsdatascience.com](/useless-machine-learning-momemts-of-trust-54c5a6c5f701)**

自工业革命以来最重大的变化

原文：https://towardsdatascience.com/the-most-significant-change-since-the-industrial-revolution-9b2b3dad199e?source=collection_archive---------59-----------------------

人工智能在当今工业中的应用概述

奥马尔·弗洛雷斯在 Unsplash 上拍摄的照片

人工智能(AI)在工业 4.0 中的应用已经烘烤了相当长一段时间，但技术现在已经足够成熟，可以将其变为现实。它涉及制造过程中的数据融合和智能自动化以及人工输入。为此，它利用了各种技术，如物联网、云计算、区块链等。让我们花一点时间来理解为什么使用人工智能是重要的。

如果你是一家制造厂的老板，那么你可能熟悉各种机器协同工作，每天生产数千台设备。监控同时进行的不同过程已经是一件非常头痛的事情。最有可能的是，为了确保至少维持生产水平，你要受各种经营者的支配。然而，即使你采取了尽可能好的措施来降低风险并确保一切顺利进行，事情还是会出错。当他们这样做时，混乱就会爆发，直到主要问题得到解决。当问题在周末或公共假期出现时，事情会变得更加复杂，因为熟练专业人员的可用性非常有限且成本高昂。当生产停止时，显然会导致财务损失，这也可能影响生产期限。大型生产过程通常依赖于原材料、零件或其他物品的仓库。所有这些都需要大量资金，如果管理不当，还会带来巨大的风险。光是处理这些资产就已经让管理层非常头疼了。我们甚至还没有开始考虑如何改进工厂；也许通过优化或改变基本配置。但有时，在处理遗留系统时，任何变化都可能是灾难性的，因此，管理层可能会对市场不断变化的需求反应迟钝。有时，一切都太晚了，缺乏果断的行动会导致工厂走向毁灭。

这些场景听起来是不是太熟悉了？好的一面是，利用今天的技术，大部分问题都可以很容易地解决。为了理解我们的意思，让我们举几个例子。

远距离微监控

XR Expo 在 Unsplash 上拍摄的照片

考虑管理一个有数百台机器的工厂，像时钟一样工作。让事情变得复杂的是，让我们想象有一个以上的工厂分布在世界各地，位于不同的时区。你如何管理所有这些？

答案是一个人无法微观管理！你需要有人去做，尤其是当人数开始增加的时候。但是我们都知道人不是不会犯错的。解决方案是安装一个智能数字双(IDT)系统，该系统能够全天候不间断地监控您的所有机器，而不管它们实际位于何处。你可以忘记它，让系统处理出现的问题，同时只在真正需要你注意的时候提醒你。此外，它还能让你安心，因为你可以在需要时实时放大任何机器的内部工作情况。随着虚拟现实(VR)耳机或增强现实(AR)眼镜等工具的出现，你可以使用 VR 虚拟地被运送到制造工厂，或者使用 AR 虚拟地将工厂运送到你的办公室。混合现实体验可以在世界上的任何地方享受，并允许您实时查看您的设施的每个部分。

优化您的工厂

照片由digity Marketing在 Unsplash 上拍摄

工厂优化和改进是一个巨大的游戏改变者。然而，它经常被忽视，因为俗话说:

"如果它没坏，就不要修理它"

但这有多真实呢？有人尝试过计算用不同方式做事的机会损失吗？最有可能的是，这种情况永远不会发生，因为通常情况下，您必须依靠专家来深入了解这些信息。除非专家有时间(他们通常没有)，或者如果他们没有得到管理层的鼓励，他们永远不会这么做。但管理层很少关注这些事情，因为他们忙于工厂的日常运营，所以事情会不断恶化，直到系统突然失灵或竞争优势因系统效率低下而开始消失的那一天。

有了人工智能，这种情况就改变了，因为系统实际上执行这些计算，不需要任何人的提示。它将不断分析供应链，并快速模拟任何特定工作的理想和最有效的场景。它通过查看当前的生产，预测潜在的停工时间，在管道中插入新任务，并根据最后期限(如交付目标、可用材料等)提出建议。只需点击一个按钮。人工智能的最终目标是确保生产工厂始终处于优化状态，并根据工厂车间发生的变化不断地实时重新调整这些优化参数。

预测未来

由杰里米·帕金斯在 Unsplash 上拍摄的照片

预测未来并不容易，但它是一个非常可取的功能，尤其是当人们考虑到机器停机时间等问题是造成生产损失的最大因素之一时。事实上，80%的公司无法计算他们的真实停机成本。平均而言，公司每天记录 4 小时的停机时间！

许多人试图完成这一壮举，但很少有预测能真正经受住时间的考验。然而，在处理一个封闭的系统时，过去的事件可以很好地预示未来会发生什么。制造工厂中的机器可以被认为是一个封闭的系统，已经运行了几个月，在某些情况下甚至几年。由于本质上是机械的，它们不断地记录大量宝贵的诊断数据，这些数据可能存在于某个数据库中，以备工程师需要。事实上，筛选所有这些数据是相当痛苦的，正是因为它的数量，所以人们很少参考它。

然而，人工智能系统擅长处理大量数据并进行分析。具体来说，他们发现定位模式相当容易，这些模式可以很好地预示将要发生什么。因此，人工智能系统可以很容易地预测机器什么时候会出故障，原因是什么。这将允许电厂组织规定的维护，从而将管理层对计划维护的严格依赖转变为能够根据实际事件采取实时行动。

此外，该系统不仅可以预测潜在的故障，还可以帮助管理层确定问题的根本原因。因此，一些故障可能会从生产周期中一劳永逸地消除，而其他故障将会及时得到处理。这样，计划外停机时间可以大大减少，甚至在某些情况下消除，从而最大限度地提高盈利能力和设备可靠性。

乐高工厂

在 Unsplash 上由amlie Mourichon拍摄的照片

在一个理想的世界里，人们会把机器集合起来，移动它们，直到找到正确的配置。这将最大限度地降低成本，优化可用空间。此外，当工厂开始发展和增加新的机器时，不同的配置可能是有益的。实际上，这种情况不会发生，因为这样做需要花费大量的时间和精力，甚至可能得不偿失。

然而，使用 IDT 系统，这可以很容易地实现。IDT 系统已经有了所有机器的虚拟副本，并且它们的状态是实时更新的。由于移动虚拟机和改变配置就像玩乐高一样，因此改变系统的配置就成了小孩子的游戏。可以添加或删除机器，并且可以使用系统已经拥有的历史信息很容易地模拟它们的输出。因此，为了找出可能的最佳配置，管理人员或控制工厂的人工智能系统可以设置不同的试验。一旦完成，就要评估这种配置的价值，如果它超过了成本，就可以在工厂的物理系统中进行部署。

简化资产管理

Nana Smirnova 在 Unsplash 上的照片

管理一个组织中的所有资产是一件令人头痛的事情，尤其是在拥有数百台甚至数千台机器同时工作的工厂中。因此，预测变得更有价值，尤其是在管理备件采购以更换有缺陷的部件时，或者在规划即将到来的机器重新配置时。在这样做的时候，人工智能系统可以用来浏览在线商店，估计零件的成本(考虑交货日期等)。)并预测总拥有成本。

所有组件；购买的和通过制造过程生产的都可以通过它们的唯一标识符来跟踪。其中一些将使用射频识别(RFIDs)等技术进行标记，这些技术可以无缝地向中央系统提供有关组件物理移动的信息。因此，通过点击一个按钮，管理该系统的人将在任何一个时间点对工厂中所有可用的实际库存有一个最新的概览。永无止境盘点的日子已经一去不复返了。该系统将提供额外信息，如已订购产品或运输中的产品。此外，如果跟踪模块建立在区块链系统上，可以确保任何产品的完全可追溯性；从构成产品的原材料开始，直到产品生命周期结束的回收阶段。

更好的决策

斯科特·格雷厄姆在 Unsplash 上拍照

IDT 系统公司将协助管理层提供及时的信息，在数据海洋中进行筛选，并对各工厂的运营情况进行总结。毫无疑问，他们将成为管理人员的私人助理，不仅能够提供准确的快照，还能实时突出关注领域。

此外，将会有一天，组织的管理将被委托给人工智能系统，从而自动化整个决策过程。决策将以光速做出，一旦有事情发生，就会立即采取纠正措施。经理们将从日常的微观管理中解脱出来，他们可以从宏观的角度来看待工厂，并根据董事会的指示花更多的时间来规划未来的改进。

结论

由 Unsplash 上的twist拍摄的照片

未来的工业看起来光明而令人兴奋。但是未来从今天开始，因为上面提到的大部分技术都已经存在。那么，你还在等什么呢，跟上变革的潮流，让你的组织为未来的挑战做好准备吧！

如果你喜欢这篇文章，并想与我联系，请这样做🐦推特，🔗领英，📷 Instagram 或者😊脸书。

[## 坐在一堆数字黄金上

如何利用你已有的资源改变你的组织！

towardsdatascience.com](/sitting-on-a-pile-of-digital-gold-f20b74e0ae47) [## 如何使用人工智能提升你的业务

一本给没有人工智能背景的人的简明指南

towardsdatascience.com](/how-to-pump-up-your-business-using-ai-ff9d7edb1d77) [## 一个全新的人工智能世界

疫情之后人工智能的兴起

towardsdatascience.com](/a-whole-new-ai-world-6a5e9e49aa12)

Alexei DingliProf 是马耳他大学的 AI 教授。二十多年来，他一直在人工智能领域进行研究和工作，协助不同的公司实施人工智能解决方案。他的工作被国际专家评为世界级，并赢得了几个当地和国际奖项(如欧洲航天局、世界知识产权组织和联合国等)。他出版了几本同行评审的出版物，并成为马耳他的一员。由马耳他政府成立的人工智能工作组，旨在使马耳他成为世界上人工智能水平最高的国家之一。

数据科学中最被低估的工具:NumPy

原文：https://towardsdatascience.com/the-most-underrated-tool-in-data-science-numpy-68d8fcbde524?source=collection_archive---------19-----------------------

NumPy 的强大功能以及如何有效地使用它

数据科学的一切都始于数据，数据有多种格式。数字、图像、文本、x 光、声音和视频记录只是数据源的一些例子。无论数据以何种格式传入，都需要转换成数字数组进行分析。复杂的计算机视觉模型无法像人类一样看到或处理图像。在分析之前，图像被转换成一组数字。因此，在数据科学中有效地存储和修改数字数组是至关重要的。NumPy(数字 Python)是一个科学计算包，它提供了非常实用的方法来创建和操作数字数组。所以我们对 numpy 的了解绝对要多于“把 NumPy 当 np 导入”。

图来源

Python 列表处理混合数据类型。例如，我们可以创建一个包含整数、浮点数、字符串和布尔值的列表。但是，NumPy 数组的所有元素必须属于同一类型。这听起来好像列表比 NumPy 数组更受欢迎，NumPy 数组对于小型列表可能是正确的。然而，我们几乎总是在现实生活的数据集中处理非常大的数字数组。就存储和处理而言，NumPy 数组比列表有效得多。

值得注意的是，最常用的数据分析工具熊猫是建立在 NumPy 之上的。

在这篇文章中，我将通过例子介绍 NumPy 数组的基础知识。

创建 NumPy 数组

我们可以从 python 列表创建一个数组:

可以使用 dtype 明确选择数据类型:

我们还可以使用嵌套列表创建更高维的数组:

NumPy 有内置函数来从头开始创建数组，这样我们就不需要传入值了。0和1函数分别创建充满 0 和 1 的数组。 full 功能允许选择要填充到数组中的值。我们只需要传入维度:

我们也可以使用arrange函数在特定范围内创建一个具有特定增量的数组:

前两个参数指定范围，第三个参数是增量的大小。请注意，上限值不包含在内。

在一个范围内创建数组的另一种方法是 linspace 函数。在 linspace 函数中，我们需要在指定的范围内选择我们想要多少个值(不是增量的大小):

这些值是等距的，下限和上限都包括在内。记住上限不包括范围功能。

我们有时需要随机数据集进行实践或实验分析。NumPy 的 random 函数用随机数创建数组:

random.random 创建 0 到 1 之间均匀分布的随机值。
random.normal 的自变量依次为均值、标准差和极差。
random.randint 创建指定范围内具有指定维数的整数数组。

我们在上面的例子中创建了数组，所以我们知道它们的属性。我们不会总是事先知道这些特性。NumPy 提供了 ndim 、 size 和 shape 方法来了解数组:

访问数组元素

访问单个元素或数组片段类似于 Python 列表的相同操作:

第一个元素的索引是 0。如果从末尾开始，第一个元素的索引是-1，第二个元素是-2，以此类推。要访问数组的一部分，我们需要指定上限和下限，中间用冒号隔开。如果不指定下限(即[:3])，就从头开始。同样，如果没有指定上限，上限就是数组的结尾。请注意，指定的范围上限是唯一的。

选择一个范围内的单个元素或所有元素不是唯一的选项。在某些情况下，我们可能需要访问每第二个或第三个元素。此任务的语法是[开始:结束:步骤]。通过示例，这一点变得更加清楚:

如果未指定下限值和上限值，数组的开始和结束将作为下限值和上限值。

要访问多维数组的元素，可以使用逗号分隔索引或嵌套索引:

对数组的操作

数组是可变的，所以我们可以改变数组中元素的值:

我们可以使用整形功能改变数组的尺寸:

算术运算可以作为矢量化运算在数组上进行。

NumPy 还提供了数学函数，用作矢量化运算。这些功能也被称为 ufuncs (通用功能)。

NumPy 中还有许多其他的 ufuncs。你可以随时查看 NumPy 官网上的文档了解更多详情。

注: 向量化运算的优势在于执行速度。我在这里展示的例子包括小数组。然而，在实际项目中，我们需要对非常大的数字数组(即 100 万个元素)进行操作，这对速度至关重要。

我已经介绍了一些基础知识，但是 NumPy 提供了更多的东西，我计划在第二篇关于 NumPy 的文章中介绍。您可以随时访问官方网站获取更详细的信息。

感谢您的阅读。如果您有任何反馈，请告诉我。

我的其他帖子

数据分析

机器学习算法

参考文献

数据科学中最常用的概率分布

原文：https://towardsdatascience.com/the-most-used-probability-distributions-in-data-science-5b3c11d34bfe?source=collection_archive---------30-----------------------

统计学和概率是数据科学家箭袋中最好的箭。让我们看看一些常用的概率分布

统计学是数据科学家简历中的必备技能，因此如果有人想使用数据和机器学习模型，就必须提前了解一些概念和主题。

概率分布是必备工具。让我们来看看数据科学家应该知道的最重要的几条。

均匀分布

最简单的概率分布是均匀分布，它赋予一个集合中的任意点相同的概率。

在其连续形式中， a 和 b 之间的均匀分布具有这样的密度函数:

这是它是如何出现的。

如你所见，范围越大，分布越低。这对于保持面积等于 1 是必要的。

均匀分布无处不在。任何蒙特卡罗模拟都是从生成均匀分布的伪随机数开始的。例如，在计算置信区间的自举技术中使用均匀分布。这是一个非常简单的分布，你会经常发现它。

正态分布

所有发行版中的女王，也可能是最著名的。如果你有一些有限方差的随机和独立变量，它们和的概率分布收敛于高斯分布。

这是概率密度函数:

μ和σ是分布的平均值和标准差。平均值是峰值位置，而标准差与宽度有关。标准差越高，分布越大(峰越低，以保持面积等于 1)。

高斯分布的一个特殊情况是正态分布，其均值等于 0，标准差等于 1。

每个使用最小二乘法的回归模型都假设残差是正态分布的，因此了解我们的数据是否是正态分布的非常重要。用于比较两个数据集中模型残差方差的 F 测试假设残差呈正态分布。如果你从事数据科学工作，你和高斯分布将很快成为最好的朋友。

学生 t 分布

一个非常特殊的分布是学生的 t 分布，其概率密度函数为:

自由参数 n 称为“自由度”(通常缩写为 d.o.f .)。很容易看出，对于较高的 n 值，t 分布更接近正态分布。

如果您必须比较不同样本的平均值或样本的平均值与总体的平均值，并且如果样本取自高斯分布，您通常会使用学生 t 检验，这是一种使用学生 t 分布进行的假设检验。也可以使用学生的 t 检验来检查两个变量之间的线性相关性。因此，在未来的数据科学家职业生涯中，您很可能会需要这种分布。

卡方分布

如果你取一些正态分布且独立的随机变量，取它们的平方值并求和，你得到一个卡方变量，它的概率密度函数是:

k 是自由度的个数。它通常等于您求和的正态变量的平方数，但有时如果这些变量之间存在某种关系，它会减少(例如，曲线拟合问题中的模型参数数)。

以下是这种分布的一些例子。

您将在皮尔逊卡方检验中使用卡方分布，该检验在某些假设下将实验直方图与理论分布进行比较。卡方分布与方差相等的 F 测试相关，因为 F 分布是作为两个卡方变量之间比率的概率分布计算的。

对数正态分布

如果取一个高斯变量并对其取指数，则得到对数正态分布，其概率密度函数为:

μ和σ与原始高斯分布相同。

以下是一些例子:

对数正态分布在自然界中被广泛测量。血压遵循对数正态分布、城市规模等等。一个非常有趣的应用是在几何布朗运动中，这是一个随机行走的模型，通常用于描述金融市场，特别是在期权定价的布莱克-斯科尔斯方程中。

正如高斯分布在自然界中广泛存在于实域中的可观测量一样，对数正态分布对于具有正值的可观测量几乎同样常见。你可以注意到强烈的不对称性和长尾效应，这两种现象在处理正变量的许多情况下都很常见。

二项分布

二项分布通常被描述为抛硬币概率分布。它测量两个事件的概率，其中一个以概率 p 发生，另一个以概率 1-p. 发生

如果我们的事件是 0 和 1 的数字，并且 1 事件以 p 的概率发生，我们可以很容易地用狄拉克δ分布写出密度:

一种可能的表示如下:

二项分布是任何概率课程的基本工具，在数据科学家的职业生涯中，可能会出现多次。想想二元分类模型，它处理 0-1 变量及其统计数据。

泊松分布

泊松分布通常被描述为罕见事件的分布。一般来说，如果一个事件以固定的速率在时间内发生(即每分钟 3 个事件，每小时 5 个事件)，那么在时间单位内观察到若干 n 个事件的概率可以用泊松分布来描述，泊松分布的公式如下:

μ是单位时间内的事件率。

以下是一些例子:

如您所见，其形状类似于高斯分布，峰值等于μ。

泊松分布在粒子物理学中非常常用，在数据科学中，它可以用于描述具有固定速率的事件(例如，早上进入超市的顾客)。

指数分布

如果泊松事件以固定的时间速率发生，则该事件两次连续发生之间的时间间隔呈指数分布。

指数分布有这样的密度函数:

τ是两个连续事件之间的平均时间间隔。

指数分布用于粒子物理学，一般来说，如果您想从泊松过程(在此过程中，您研究事件的数量)转移到与时间更相关的东西(例如，两个连续的顾客进入商店之间的时间间隔)。

结论

数据科学和统计学是两个非常相关的主题，如果不了解后者，就不可能很好地处理前者。在本文中，我向您展示了在您的数据科学家职业生涯中会发现的一些最重要的概率分布。可以找到其他分布(例如伽马分布)，但在数据科学家的日常工作中，他可能会使用这里描述的分布之一。

最有用的 ML 工具 2020

原文：https://towardsdatascience.com/the-most-useful-ml-tools-2020-e41b54061c58?source=collection_archive---------2-----------------------

每个懒惰的全栈数据科学家都应该使用的 5 套工具

在 Unsplash 上创作八的照片

TL；构建好的机器学习应用程序就像做米其林风味的菜肴。拥有一个井井有条、管理有序的厨房至关重要，但有太多选项可供选择。在本文中，我强调了我发现的在交付专业项目中有用的工具，分享了一些想法和替代方案，并做了一个快速的实时调查(您可以在参与后看到社区的想法)。

像任何工具讨论一样，这个列表并不详尽。我试图专注于最有用和最简单的工具。欢迎评论区的任何反馈，或者告诉我是否有更好的选择。

免责声明 :本帖没有背书或赞助。我交替使用术语数据科学和 ML。

喜欢读什么？ 跟我上 中LinkedIn，以及Twitter。查看我的《* 用机器学习影响 》指南。它帮助数据科学家更好地解决问题、设计和交流。*

“我如何构建好的机器学习应用？”

在与学校中有抱负的数据科学家、希望转行的专业人士和团队经理的聊天中，这个问题以各种形式出现了多次。

交付专业数据科学项目有许多方面。像许多其他人一样，我喜欢用在厨房做饭来做类比:有配料(数据)，食谱(设计)，烹饪过程(嗯，你独特的方法)，最后是实际的厨房(工具)。

所以，这篇文章走过我的厨房。它强调了设计、开发和部署全栈机器学习应用的最有用的工具——与系统集成或在生产环境中为人类用户服务的解决方案。

如果你想了解更多关于交付 ML 的其他方面，请点击这里查看我的文章。

压倒一切的可能性

我们生活在一个黄金时代。如果你在谷歌上搜索“ML 工具”或者咨询顾问，你很可能会得到这样的结果:

数据& AI 景观 2019，图片来源

吉菲

外面有(太多)工具；可能的组合是无限的。这可能会令人困惑和不知所措。所以，我来帮你缩小范围。也就是说，没有完美的设置。这完全取决于你的需求和约束。因此，挑选，选择，并相应地修改。

我的列表优先考虑以下几点(不按顺序):

自由的💸
易于学习和设置🧸
未来证明(采用和工具成熟度)♻️
工程超过研究🤖
为初创企业或大型企业的大项目或小项目工作🚀
完成任务就行了💪

警告:我使用 Python 🐍 99%的时候。因此，这些工具可以很好地与原生 Python 一起工作，或者用原生 Python 构建。我没有用其他编程语言测试过它们，比如 R 或 Java。

1.冰箱:数据库

PostgreSQL

一个免费的开源关系数据库管理系统(RDBMS ),强调可扩展性和技术标准遵从性。它旨在处理一系列工作负载，从单台机器到数据仓库或有许多并发用户的 Web 服务。

图像来源

替代品: MySQL ， SAS ，IBM DB2，Oracle，MongoDB，cloud era

2.台面:部署管道工具

管道工具对于开发的速度和质量至关重要。我们应该能够用最少的手工处理快速迭代。这里有一个很好的设置，更多细节请看我的 12 小时 ML 挑战文章。每个懒惰的数据科学家都应该在项目的早期尝试这种方法。

作者作品， 12 小时 ML 挑战

Github

它提供了 Git 的分布式版本控制和源代码管理(SCM)功能，以及它自己的特性。它为每个项目提供了访问控制和几个协作特性，比如 bug 跟踪、特性请求、任务管理和 wikis。

备选:DVC，bit bucket， GitLab**

皮查姆社区版

一种用于计算机编程的集成开发环境(IDE ),专门用于 Python 语言。它是由捷克公司 JetBrains 开发的。它提供了代码分析、图形调试器、集成单元测试器、与版本控制系统(VCSes)的集成，并支持使用 Django 进行 web 开发以及使用 Anaconda 进行数据科学。

替代品: 原子，崇高

Pytest

一个框架使得编写小测试变得容易，并且可以扩展以支持应用程序和库的复杂功能测试。它节省了手动测试的大量时间。如果每次修改代码时都需要测试一些东西，那么可以用 Pytest 自动测试。

备选:Unittest

CircleCi

CircleCI 是一个持续集成和部署工具。当您提交 Github 时，它使用远程 dockers 创建了一个自动化的测试工作流。Circle CI 拒绝任何没有通过 PyTest 设置的测试用例的提交。这确保了代码质量，尤其是当您与一个较大的团队一起工作时。

备选: 詹金斯 ， 特拉维斯 CI ，Github Action

Heroku (仅当你需要虚拟主机时)

平台即服务(PaaS)使开发人员能够完全在云中构建、运行和操作应用程序。可以与 CircleCI 和 Github 集成，实现自动部署。

备选: Google App 引擎， AWS 弹性计算云 ，其他

Streamlit (仅当您需要交互式 UI 时)

Streamlit 是一个面向机器学习和数据科学团队的开源应用框架。近年来，它已经成为我最喜欢的工具之一。看看我如何使用它和本节中的其他工具来创建一个电影和模拟应用。

备选: 烧瓶，姜戈，画面

3.iPad:探索工具

流线型(再次)

忘掉朱庇特笔记本吧。是的，没错。

Jupyter 是我探索数据、进行分析、试验不同数据和建模过程的首选工具。但是我不记得有多少次:

我花了很多时间调试(并拔头发)，但最终意识到我忘了从头开始运行代码；Streamlit 解决了这个问题。
我不得不等待一段时间，让我的数据管道重新运行，即使是一个小的代码更改；Streamlit 缓存解决了这个问题。
我不得不重写代码或将代码从 Jupyter 转换成可执行文件——以及花费在重新测试上的时间；Streamlit 提供了一条捷径。

令人沮丧🤯😭。于是，我用 Streamlit 做前期探索，服务最终前端——一举两得。以下是我典型的屏幕设置。左边是 PyCharm IDE，右边是结果可视化。试试看。

IDE(左)Streamlit 的实时更新(右)，作者的作品来自被遗忘的算法

备选: Jupyter 笔记本 ，Spyder from Anaconda，Microsoft Excel【严重】

4.刀子:ML 框架

就像使用真正的刀一样，你应该根据食物和你想怎么切来选择合适的刀。有通用刀和专用刀。

谨慎。使用寿司专用刀切骨头需要很长时间，尽管寿司刀更亮。选择正确的工具来完成工作。

Scikit-Learn(常见的 ML 用例)

用 Python 进行一般机器学习的首选框架。说够了。

Scikit-Learn 的使用案例，来源

备选方案:无，句号。

PyTorch (深度学习用例)

基于 Torch 库的开源机器学习库。鉴于深度学习的重点，它主要用于计算机视觉和自然语言处理等应用。它主要由脸书人工智能研究实验室(FAIR)开发。最近很多知名的 AI 研究机构，比如 Open AI ，都在用 PyTorch 作为他们的标准工具。

替代品:tensor flow，Keras， Fast.ai**

开放 AI 健身房(强化学习用例)

开发和比较强化学习算法的工具包。它提供了 API 和可视化环境。这是一个社区正在开发工具的活跃领域。目前还没有很多打包好的工具可用。

替代品:很多小项目，但没有多少像健身房一样维护的那么好。

5.火炉:实验管理

图集

这是一个免费的工具，允许数据科学家用一些片段设置实验，并将结果显示在基于网络的仪表板上。

图册流程，来源

****免责声明:我在 Dessa 工作，这家公司创造了亚多拉斯。

替代品: ML 流量 ，SageMaker，彗星， 权重&偏见 ， 数据机器人 ，**

一项调查

出于好奇，在寻找合适的工具时，什么最困扰你？我很想听听你下面的想法。这是一个现场调查，所以你在参与后会看到社区的想法。

另一种观点

正如我提到的，没有完美的设置。这完全取决于你的需求和约束。这是可用工具以及它们如何协同工作的另一个视图。

2019 年 Sergey Karayev 在全栈深度学习的演讲

一个小小的挑战

如果你想更多地了解如何使用这些工具，最好的方法是找一个项目来做。你可以将这些工具整合到当前的项目中，或者做一个 12 小时的 ML 挑战。不确定怎么做？查看我如何创建一个用户授权的推荐应用并讨论工具和流程。

我期待看到你能创造出什么。请分享给社区，并在推特上给我加标签🙌。

喜欢读什么？ 跟我上 中，LinkedIn，或者Twitter。还有，作为一名数据科学家，要不要学习商业思维和沟通技巧？查看我的《 用机器学习影响 》指南。

以下是我的一些文章，你可能会喜欢:

** [## 对生活的追求

一个发现为什么许多 ML 项目失败的工具

towardsdatascience.com](/the-pursuit-of-lift-why-ml-projects-fail-f032dc31a303) [## 被遗忘的算法

用 Streamlit 探索蒙特卡罗模拟

towardsdatascience.com](/how-to-design-monte-carlo-simulation-138e9214910a) [## 数据科学很无聊

我如何应对部署机器学习的无聊日子

towardsdatascience.com](/data-science-is-boring-1d43473e353e) [## 12 小时 ML 挑战

如何使用 Streamlit 和 DevOps 工具构建和部署 ML 应用程序

towardsdatascience.com](/build-full-stack-ml-12-hours-50c310fedd51) [## ML 和敏捷注定的联姻

如何不对 ML 项目应用敏捷

towardsdatascience.com](/a-doomed-marriage-of-ml-and-agile-b91b95b37e35) [## 人工智能的最后一英里问题

如何培养人类和人工智能之间的信任

towardsdatascience.com](/fixing-the-last-mile-problems-of-deploying-ai-systems-in-the-real-world-4f1aab0ea10) [## 又一个 AI 冬天？

如何部署更多的 ML 解决方案——五种策略

towardsdatascience.com](/the-last-defense-against-another-ai-winter-c589b48c561)**

posted @ 2024-10-16 09:03 绝不原创的飞龙阅读(626) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

TowardsDataScience-博客中文翻译-2020-一百一十三-

TowardsDataScience 博客中文翻译 2020（一百一十三）

理解新冠肺炎·疫情需要的图表

如果你知道要寻找什么，正确的图表会非常有启发性

国家图表

状态图

真正严肃的高级图形阅读

摘要

更多详情请访问新冠肺炎信息网站

我的背景

伟大的 CSV 对决:Julia vs Python vs R

同质数据

异构数据集上的性能

数据市场长城

缺乏关于模型和脚本生产的内容。

这面墙是什么？

怎么做才能FQ？

只研究需要的东西

蛮力速度不快，但它能解决所有问题

请开发人员检查您的工作

试着想想边缘案例

学习并应用软件开发最佳实践

我们应该怎么做才能推倒这堵墙？

羟氯喹大辩论

羟氯喹和阿奇霉素有 91.7%的成功率——好得难以置信？对最新数据的评论。

书房

结论

T5 变压器多任务处理指南

T5 变压器可以执行任何 NLP 任务。它可以在同一时间使用同一型号执行多项任务。祝您身体健康

任务说明

二元分类

多标签分类

回归

数据准备

下载

组合数据集

T5 转换器将任何 NLP 任务构造为文本到文本的任务，使其能够轻松学习新任务。让我们来教…

设置

培训 T5 模型

测试 T5 型号

结束语

可能的改进

包扎

参考

我们为什么需要数据产品经理的事实

这不仅仅是天马行空的想法——这是一个探索无限可能性的过程

英雄崛起:打造自己的 SSD

现实世界中的数据科学

深度学习代码库系列的英雄之旅——IIB 部分

常量:从默认值开始

SSD 类构造函数

创建分类和本地化负责人

定义 SSD 正向传递

将 SSD 模型连接到代码库

快板火车——坐下来，放松和监控你的实验

结论

Python 的隐藏类

数据类

装修工

类型化变量

命名的元组

可供选择的事物

摘要

脚注

产品错误的隐性成本

使用分析来跟踪您的客户没有报告的错过的机会

1.一个受欢迎的美容网站几乎因为广告拦截器而失去了一名顾客

要点:一些顾客会发起反对公司的运动

解决方案:交互跟踪软件

2.互联网服务提供商(ISP)因为第三方承包商而失去了一名客户

总结:一次负面经历可能会失去一个客户

要点:错误可能不会被报告

要点:错误可能不止一个

解决方案:客户服务培训

解决方案:业务分析

3。一家面包店因未能更新在线菜单而失去了一名顾客

外卖:不是每个人都会求助

解决方案:单一的真相来源