为什么数据科学不仅仅是？适合()。预测()
在这篇文章中，我将回顾一些我学到的让我从一名技术数据科学家变成一名优秀数据科学家的顶级概念
两个月前，我结束了在 YellowRoad 作为数据科学家的第二年，所以我决定对我的项目进行回顾性分析，我做得好吗？我发现了哪些有趣的方法？我犯了什么错误？最重要的是，我学到了什么？
在这篇文章中，我将回顾我学到的一些顶级概念，在我看来，这些概念使我从一个运行模型并可以很容易被 autoML 取代的技术数据科学家变成了一个优秀的数据科学家，即使不需要最先进的研究，也能在每个项目中提供价值。
1)数据泄露
根据 Kaggle 的说法，数据泄漏是在训练数据中创建意外的附加信息，允许模型做出不切实际的良好预测。或者更简单的定义，任何能让你的模型在研究中比在生产中表现更好的东西。我有一百万种类型的数据泄漏，有时是由于模型中的错误(比如将标签作为一个特性输入)，有时是由于数据集创建中的错误(比如创建一个包含未来信息的特性)，有时是由于业务逻辑中的错误(比如使用不能在生产中使用的特性)。关于数据泄漏最危险的事情是很难发现，有时只有当你发现测试集的准确率为 90%而生产的准确率只有 60%时，你才会发现泄漏。如果你想了解更多关于数据泄露的信息，你可以观看我的闪电谈话，从 11:15 开始(只有 10 分钟:)。
2)选择偏差
选择偏倚是指通过选择个体、群体或数据进行分析而引入的偏倚，这种方法不能实现适当的随机化(来自维基百科)。例如，如果您正在使用贴在脸书墙上的调查问卷构建一个训练集。回答这个问题的人可能和你年龄相仿，来自你的国家甚至城市，拥有你的社会经济属性。如果你只基于这些数据建立一个模型，当它投入生产时，它将暴露给更广泛的人群，你的模型对你的朋友有效的事实并不意味着它对每个人都有效。有时，选择偏差甚至比数据泄露更难，因为如果你可以监控所有群体的标签，你就可以使用这些标签进行训练。选择偏差也更难修复，你可以基于整个群体重新加权你的训练集，或者删除将训练集与整个群体区分开来的特征，但你不能真正评估这些方法是否有效。更多关于卢卡斯·伯纳蒂精彩演讲的选择偏见。
3)生产反馈回路
在许多机器学习应用程序中，生产工作流看起来是这样的:机器学习模型对用户行为进行预测，系统根据模型输出采取行动，用户对系统做出反应，模型根据用户行为进行重新训练。这种反馈循环中，模型对其未来训练集的影响会导致一些偏差。例如，在一个推荐引擎中，我们根据用户点击的项目进行排名，但是如果我们首先对一个项目进行排名，那么它的点击概率高于排名第 10 的项目。这样，我们的模型将永远不会学习新的东西，即使有些项目对用户来说更好。为了解决这个问题，我们通常使用 exploration，即使一个项目从模型中以某种概率得到低分，也将其排名靠前，或者相对于项目的先前排名重新调整模型标签，如果项目是从第二页被点击的，那么它比第一个项目被点击的指示更强。另一个例子是预测客户是否会归还贷款。我们不知道如果我们批准我们拒绝的贷款会发生什么，因此，我们正在为模型的下一个训练集创建一个偏差。
4)特殊交叉验证技术
在某些情况下，使用随机交叉验证是不够的，因为生产数据看起来与研究数据不同，我们需要使用特殊的交叉验证方法。例如，在时间序列数据集中，由于自然或特殊事件，数据分布通常会发生变化。如果我们将使用随机交叉验证，训练和测试数据分布将是相同的，我们不知道我们的模型是否对这种数据分布变化具有鲁棒性。因此，在时间序列中，我们需要使用滑动窗口交叉验证，而不是随机验证。关于时间序列交叉验证的更多信息，你可以在这篇文章中阅读。另一种特殊情况是当您的数据中有组时，例如在医学临床试验中，您在试验期间有同一患者的许多实例。为了确保我们的模型将推广到新的组，我们需要使用组交叉验证，其中每个文件夹包含几个组的所有示例，在测试时间，我们将测试新的组。
5)选择“正确的”评估指标
这是一个有点陈词滥调的句子，有时在真实场景中很难做到，但是你评估你的模型的方式应该与你的用例的业务需求高度相关。我会举一些例子，我有一个项目，在一个广告技术公司建设一个投标人，将决定支付多少印象。我们的方法是建立一个模型，预测公司可以从一个印象中赚多少钱，然后根据预测设定出价。在这个模型中，MSE 是一个糟糕的评估指标，尽管它可能是回归模型中最流行的指标。MSE 对大错误的惩罚比对小错误的多。在这个模型中，当公司设法以非常高的价格出售印象时，大多数大错误都是异常的。预测异常几乎是不可能的，所以即使在这些异常中，其他人也会提供与其他印象大致相同的出价。如果我们的预测会更低，我们有时仍然会购买这些异常，但如果我们对常规印象提供大量出价，我们会损失很多钱。另一个例子是排名模型，准确性和 MSE 显然与业务用例不匹配，但即使不同的排名指标也可以适合不同的用例。如果您只向用户呈现前 K 项，那么 K 处的回忆应该是您的评估指标。但是，如果你向用户展示一个长长的排序列表，并且他看到一个项目的概率随着排序的降低而降低，那么 NDCG 是一个非常好的度量。
6)从一个简单的模型开始
使用新的深度 Cnn Rnn 与 Gans 的残余变压器注意力和一些网络区块链层的流行语很酷，甚至非常酷，但这不是一个开始项目的好方法。从具有少量特征的简单模型开始有几个优点。调试模型和发现错误或数据泄漏更容易，你更好地理解模型的预测，并知道如何使它表现得更好，以及哪些研究方向更有前途，如果你看到数据中没有信号，你会很快失败，并花一点时间转移到你的下一个项目，这可能是最重要的优势，有时简单的模型足以满足你的业务需求，所以你节省了大量的研究和 GPU 时间。
7)不要使用ε型号
在 Kaggle 比赛中，获胜的模特通常是拥有数百种特征的 30 个模特的组合。这些模型通常比一个好模型或 2-3 个简单模型的集合好 0.01 点。这些复杂的模型被称为 epsilon 模型，因为它们只增加了一个 epsilon 的性能，但给生产系统带来了巨大的复杂性。每个模型甚至特征都是另一个潜在的漏洞，它需要更多的训练和推理时间以及更多的内存。在由于复杂性和性能导致的成本权衡中，除了模型的准确性与收入高度相关的特殊情况，较简单的模型胜出。
8)监控生产中的模型
在大多数实际应用中，由于业务决策、用户行为的变化、模型引起的变化等等，数据分布总是在变化。这意味着您的模型性能可能会随着时间的推移而下降。为了阻止这种现象，我们需要监控模型的性能，并在性能显著下降时重新训练模型甚至返回研究阶段。但是，在许多情况下，我们没有新的标签(例如，如果我们用 Mechanical Turk 标记我们的训练集)，或者我们在很长时间后发现了这些标签(例如，如果我们预测某个企业是否会归还其 5 年贷款)。在这些情况下，我们应该监视定型集和生产数据之间的数据变化，甚至监视模型预测概率分布的变化。这里是 Jannes Klaas 关于监控生产中的机器学习模型的精彩演讲。
感谢阅读:)
我希望这篇文章能给你一些启发，也希望你能从我过去的错误中吸取教训，以后不会再犯同样的错误。
希望你喜欢我的帖子，非常欢迎你阅读和关注我的博客。
数据科学的顶级 R 库
courtresy: https://pixabay.com/en/statistic-survey-website-template-1606951/
在这里，让我告诉你一些关于 R 的一些很棒的库。我认为这些库是数据科学的顶级库。这些库具有广泛的功能，对于数据科学操作非常有用。我曾经使用过它们，并且仍然在日常的数据科学操作中使用它们。不浪费任何时间，让我带你开始可怕的 R 的东西。
这里提到的这些库是随机排列的，我不想给它们排名，因为它们都有自己的用处，对它们进行排名是不合理的。
1。Dplyr
Dplyr 主要用于 r 中的数据操作，Dplyr 实际上是围绕这 5 个函数构建的。这些函数构成了大部分的数据操作。您可以使用本地数据框和远程数据库表。您可能需要:
选择 某列数据。
过滤 您的数据以选择特定的行。
将 您的数据行排列成一个顺序。
改变 您的数据框以包含新列。
以某种方式总结 你的大块数据。
它还具有类似于的功能，由 和 管组成。
2。 Ggplot2
Ggplot2 是 r 中最好的数据可视化库之一。ggplot2 库实现了一种“图形语法”(Wilkinson，2005)。这种方法通过表达数据属性和它们的图形表示之间的关系，为我们提供了一种产生可视化效果的一致方法。Ggplot2 具有广泛的功能。
阅读这个 R 文档了解 ggplot2 函数，点击这里:https://bit.ly/2DBo0VK
***3。*Esquisse——我最喜欢的包，对 r 最好的补充
不喜欢 ggplot2？使用 ggplot2 和它的功能有一些问题，那么这个包是给你的。这个包将 Tableau 最重要的特性带到了 r 中。只需拖放，几分钟就可以完成可视化。这实际上是对 ggplot2 的增强。此加载项允许您通过使用 ggplot2 包可视化数据来交互式地浏览数据。它允许您绘制条形图、曲线、散点图、直方图，然后导出图表或检索生成图表的代码。太棒了，不是吗？
4。生物导体
当你进入数据科学领域时，你会处理不同种类的数据。你可能不知道将来要处理什么样的数据。如果你在健康行业，那么相信我，你会发现这非常有用。我认为这个库在你研究基因组数据时非常有用。Bioconductor 是一个开源项目，托管了大量使用 r 分析生物数据的工具。要安装 Bioconductor 软件包，您需要安装bio manager。**
- 图形:geneplotter，hexbin。
- *注释:annotate，ann builder【https://bit.ly/2OUYdd5 *
- 5。闪亮
- 这是 r 中一个非常有名的包。当你想与你周围的人分享你的东西，让他们更容易理解和直观地探索它时，你可以使用 shiny。它是数据科学家最好的朋友。Shiny 让构建交互式网络应用变得更加容易。你可以在网页上托管独立的应用程序，或者将它们嵌入到 R Markdown 文档中，或者构建仪表盘。你也可以用 CSS 主题、 htmlwidgets 和 JavaScript 动作来扩展你闪亮的应用。
- 6。润滑剂
- 这个图书馆非常适合它的用途。主要用于数据角力。它使 r 中的日期-时间处理变得更加容易。使用这个库，您可以做任何您想做的关于日期算法的事情，尽管在这里理解和使用可用的功能可能有些复杂。当你在分析时间序列数据并想按月汇总数据时，你可以使用 lubridate 包中的 floor_date ，它可以很容易地完成你的工作。它具有广泛的功能。你可以在这里阅读文档:https://bit.ly/2AbTEpf
- 7。针织机
这个包用于 R 中的动态报告生成。knitr 的目的是允许通过有文化的编程方式在 R 中进行可再现的研究。这个包还支持将 R 代码集成到 LaTeX、Markdown、LyX、HTML、AsciiDoc 和 reStructuredText 文档中。您可以将 R 添加到 markdown 文档中，并轻松生成 HTML、Word 和其他格式的报告。如果您对可重复的研究感兴趣，并且对从数据分析到报告创建的自动化之旅感兴趣，这是一个必备工具。
8。Mlr
这个包在执行机器学习任务方面绝对不可思议。它几乎拥有执行机器学习任务的所有重要和有用的算法。它也可以被称为分类、回归、聚类、多分类和生存分析的可扩展框架。它还具有用于特性选择的过滤器和包装器方法。另一件事是，这里执行的大多数操作都可以并行化。文档中提到了广泛的功能:【https://bit.ly/2QflLy6】T2
9。昆达。词典
这个包扩展了 quanteda 包的功能。它由用于文本分析的词典组成。它主要用于 quanteda，但也可以用于其他文本分析库，如 tm、tidytext 和 udpipe。通过 quanteda.dictionaries 包中的 liwcalike() 函数，您可以使用现有的或定制的词典轻松地分析文本语料库。你可以从他们的 github 页面安装这个包。
10。DT
它是 javascript 库 数据表的包装器。 用于数据显示，可以将 R 矩阵和数据框显示为交互式 HTML 表格。使用这个库，你可以用最少的代码创建一个可排序的表，实际上你可以只用一行代码创建一个可排序的、可搜索的表。你也可以设计你的桌子。数据表还在表中提供过滤、分页、排序和许多其他功能。
11。罗勒
RCrawler 是一个贡献的 R 包，用于基于域的 web 爬行和内容抓取。它增加了 Rvest 包所缺少的爬行功能。RCrawler 可以抓取、解析、存储页面、提取内容并生成可直接用于 web 内容挖掘应用程序的数据。爬行操作的过程是由几个并发进程或节点并行执行的，因此建议使用 64 位版本的 r。
12。插入符号
Caret 代表分类和回归训练。软件包中的主要工具之一是培训功能，可用于。使用重新采样评估模型调整参数对性能的影响。Caret 有几个功能，试图简化模型构建和评估过程，以及特征选择和其他技术。你只需要知道这个包就可以解决几乎所有有监督的机器学习问题。它为几种机器学习算法提供了统一的接口，并标准化了各种其他任务，如数据分割、预处理、特征选择、变量重要性估计等。
13。RMarkdown
R Markdown 允许您创建文档，作为您的分析的整洁记录。在可重复研究的世界里，我们希望其他研究人员能够容易地理解我们在分析中做了什么，否则没人能确定你正确地分析了你的数据。R Markdown 是 Markdown 的一个变种，它嵌入了 R 代码块，与knitter一起使用，可以轻松创建可复制的基于 web 的报告。使用 R Markdown，您可以将您的分析转化为高质量的文档、报告、演示文稿和仪表盘。
14。传单
这是一个 javascript 库，主要用于绘制和处理交互式地图。而且，你可以从 R 控制台直接使用这些地图。传单为您提供了不同的功能集，可用于样式和自定义您的地图。这个库的开发工作也很广泛。如果你想使用地图，一定要试试这个库。除了基本地图之外，您还可以为地图使用不同的单幅图块。
15。看门人
看门人使基本的数据清理变得容易，例如通过多个列找到重复项，使 R 友好的列名和删除空列。它也有一些很好的制表工具，比如添加一个总计行，以及生成带有百分比和简单的交叉标签的表格。而且，它的 get_dupes()函数是一种在数据框中查找重复行的优雅方式，可以基于一列、几列或整行。
其他值得一提的 R 库:
Ggvis
Plotly
Rcharts
Rbokeh
金雀花
StringR
- 马格里特
- Slidify
- Rvest
- 将来的
- RMySQL
- 红柱石
- 先知
- Glmnet
- Text2Vec
- 雪球 c
- Quantmod
- Rstan
- 漩涡
- 数据科学家
- 如果我错过了任何重要的库，请在下面的评论区告诉我。
- 所以，这就是，这些是你需要知道的一些顶级库，以便完成你的日常数据科学操作。
- 表现出一些爱心，如果有帮助的话！
- 感谢阅读！
- Swirl
- DataScienceR
If I’ve missed out any important library then do let me know down below in the comments section.
So, This is it, these were some of the top libraries that you need to know in order to get your day to day Data Science operations done.
Show some love, if it was helpful!
Thanks for reading!
亚马逊评论的主题挖掘
如何用 NLP 理解客户的声音？
互联网上充斥着对商品、商店和服务的评论。这些评论是产品经理更好地了解他们的客户的关键。在本教程中，我们将使用 RapidMiner 和 Python 对亚马逊评论进行主题建模。
看一看数据
我们正在分析的数据来自 kaggle 。总数据集由 564.033 条评论组成。除了文章的评论正文，我们还获得了一些更多的描述属性，如发布时间、有用性和用户产品 id。在这篇文章中，我们将重点放在文本本身。
Read In and sample process in RapidMiner.
由于运行时间的原因，我们将把评论的数量减少到 10，000。
预处理
像往常一样，在分析中，我们需要对数据进行一些预处理。对于这个分析，我们首先希望用 Transform Cases 操作符将所有内容转换成小写。稍后，我们还想删除像“the”这样的停用词。这些词在检测我们数据中的不同主题时没有用。如果它们有助于我们的建模，这通常是一个消极点——即产生一个“通用的”主题或类似的主题。
Preprocessing in RapidMiner. The left subprocess retrieves a frequency list and filters it for the top50 words.
我们进一步删除在文档中出现少于 50 次的所有单词。这有助于我们在获得良好结果的同时减少运行时间。
LDA 和检测到的主题
为了检测主题，我们运行潜在的狄利克雷分析，或简称 LDA。这是一个任务是在数据集中寻找主题的算法。我们使用 RapidMiner 的操作工具箱扩展中的 Extract Topics from Documents (LDA)操作符来实现这一点。这背后的实现来自于 MALLET ，在 R & Python 中也有。
LDA 算法需要设置一些参数。除了预处理决策，我们还需要定义要搜索的主题数量、狄利克雷分布的先验知识以及优化迭代的次数。在本例中，我们将重点关注主题数量的定性分析。对于先验，我们使用 MALLET 的参数自动调整，对于迭代，我们使用 1000。
Main Setup for the LDA in RapidMiner. The outer Loop Parameter Operator varys the number of topics in each iteration.
如果您想对超参数进行定量优化，您可以使用作为性能向量公开的模型诊断。这里的问题是，你添加的主题越多，大多数性能指标通常会变得越好。这有点像集群中的问题，集群内的距离越短，添加的集群越多。因此，我决定定性地做这件事，用最重要的词的词云来观察聚类。
Most important words per topic for a total of six topics. Topic_5 can be identified as a “general” topic including a lot of texts on general amazon services, while the other are product categories.
Most important words per topic for a total of 12 topics. The generic topic is split into two — Topic_0 and Topic_3.
你可以在单词 clouds 中清楚地看到，你添加的越多，一些主题似乎就分裂成了副主题。当选择 6 个主题时，您可以看到 Topic_5 是通用 amazon 和产品相关主题的混合。如果你有 12 个主题，这个主题可以分成主题 0、主题 3 和主题 5。相似性，你可以看到“咖啡”和“茶”在 6 个主题的设置中是一个很好的主题，但在 12 个主题中有两个。
当然，决定选择什么主题应该与你的商业目标相一致。如果你有兴趣单独跟踪茶评论的数量，你不应该选择 6。话题回顾。
话题挖掘可以做什么？
我们已经看到了如何实现主题建模，但通常问题是:我为什么要在业务中这样做？
将主题挖掘应用于您的客户或内部数据可以轻松快速地使您的分析团队(甚至是领域专家和业务分析师)能够直观地识别数据中的因果关系和相关性，并帮助他们解决具有挑战性的业务问题，如客户流失和员工满意度。
最受欢迎的应用是:
- 社交媒体评论分析
- 案例系统处理
- NPS 访谈分析
让我们来看看一些最常见的前进方式。
向下钻
手头有了主题分配，你可以把它放入普通的 BI 工具中。有没有一个特定的话题聚集的区域？我们在某个特定的周末遇到问题了吗？所有这些问题都可以从数据中找到答案。
分析话题趋势
有时候你对单一话题感兴趣。您想知道“交付时间”话题是否会随着时间的推移而增加。通过对每天与主题相关的文档数量进行时间序列预测，您可以创建一个警报信号。该信号通知用户或负责的业务单位，在作为主题的“交付时间”中存在峰值，并且在交付过程中可能存在瓶颈，从而允许企业解决该问题并保持良好的服务。
为进一步分析进行预处理
当然，您现在可以使用这些主题分布来进一步分析您的文本数据:
- 使用产品的主题分布作为进一步分析的输入，例如监督学习。
- 用于聚类以发现相似产品的主题分布。
- 对主题分布和其他属性进行异常检测，以发现“奇怪”的产品。
结论
在本文中，我们在亚马逊评论上使用了主题挖掘。正如你所看到的，这种技术可以很快使用，并产生可理解的结果。所有的流程、脚本和数据样本都可以在 my github profile 上找到。
Python 中的主题建模和潜在狄利克雷分配
Photo Credit: Pixabay
主题建模 是一种用于发现文档集合中出现的抽象“主题”的统计建模。 潜在狄利克雷分配 (LDA)是主题模型的一个例子，用于将文档中的文本分类到特定主题。它建立了每个文档的主题模型和每个主题的单词模型，建模为 Dirichlet 分布。
这里我们将把 LDA 应用于一组文档，并把它们分成主题。我们开始吧！
数据
我们将使用的数据集是 15 年间出版的超过 100 万条新闻标题的列表，可以从 Kaggle 下载。
import pandas as pddata = pd.read_csv('abcnews-date-text.csv', error_bad_lines=False);
data_text = data[['headline_text']]
data_text['index'] = data_text.index
documents = data_text
看一眼数据。
print(len(documents))
print(documents[:5])
1048575
Figure 1
数据预处理
我们将执行以下步骤:
- 分词:将文本拆分成句子，句子拆分成单词。将单词小写，去掉标点符号。
- 少于 3 个字符的单词将被删除。
- 所有停用字都被移除。
- 单词被词汇化了——第三人称的单词变成了第一人称，过去时态和将来时态的动词变成了现在时态。
- 单词被词干化——单词被还原成它们的词根形式。
加载 gensim 和 nltk 库
import gensim
from gensim.utils import simple_preprocess
from gensim.parsing.preprocessing import STOPWORDS
from nltk.stem import WordNetLemmatizer, SnowballStemmer
from nltk.stem.porter import *
import numpy as np
np.random.seed(2018)import nltk
nltk.download('wordnet')
【nltk _ data】下载包 wordnet 到
【nltk _ data】C:\ Users \ Susan Li \ AppData \ Roaming \ nltk _ data…
【nltk _ data】包 wordnet 已经是最新的了！
真
编写一个函数，对数据集执行词汇化和词干预处理步骤。
def lemmatize_stemming(text):
return stemmer.stem(WordNetLemmatizer().lemmatize(text, pos='v'))def preprocess(text):
result = []
for token in gensim.utils.simple_preprocess(text):
if token not in gensim.parsing.preprocessing.STOPWORDS and len(token) > 3:
result.append(lemmatize_stemming(token))
return result
选择预处理后的文件进行预览。
doc_sample = documents[documents['index'] == 4310].values[0][0]print('original document: ')
words = []
for word in doc_sample.split(' '):
words.append(word)
print(words)
print('\n\n tokenized and lemmatized document: ')
print(preprocess(doc_sample))
原始文档:
[‘雨’，‘帮忙’，‘浇灭’，‘丛林大火’]
标记化和词条化的文档:
[‘雨’，‘救命’，‘浇灭’，‘灌木’]
成功了！
预处理标题文本，将结果保存为‘processed _ docs’
processed_docs = documents['headline_text'].map(preprocess)
processed_docs[:10]
Figure 2
数据集上的单词包
从“processed_docs”创建一个字典，其中包含一个单词在训练集中出现的次数。
dictionary = gensim.corpora.Dictionary(processed_docs)count = 0
for k, v in dictionary.iteritems():
print(k, v)
count += 1
if count > 10:
break
0 播出
1 共产主义
2 分钟
**T5 3 许可 **
4
5 默认
6 机智
⑦谓
8 基础设施
9 保护
10 峰会
Gensim 过滤器 _ 极端情况
过滤掉出现在中的令牌
- 少于 15 份文件(绝对数量)或
- 超过 0.5 个文档(总语料库大小的一部分，而不是绝对数量)。
- 完成上述两个步骤后，只保留前 100000 个最常用的令牌。
dictionary.filter_extremes(no_below=15, no_above=0.5, keep_n=100000)
Gensim doc2bow
对于每个文档，我们创建一个字典，报告有多少
单词以及这些单词出现了多少次。将此保存到“bow_corpus ”,然后检查我们之前选择的文档。
bow_corpus = [dictionary.doc2bow(doc) for doc in processed_docs]
bow_corpus[4310]
[(76，1)，(112，1)，(483，1)，(3998，1)]
我们的样本预处理文档的单词预览包。
bow_doc_4310 = bow_corpus[4310]for i in range(len(bow_doc_4310)):
print("Word {} (\"{}\") appears {} time.".format(bow_doc_4310[i][0],
dictionary[bow_doc_4310[i][0]],
bow_doc_4310[i][1]))
字 76(“bush fir”)出现 1 次。
字 112(“帮助”)出现 1 次。
字 483(“雨”)出现 1 次。
字 3998(“挫伤”)出现 1 次。
TF-IDF
使用模型创建 tf-idf 模型对象。’ bow_corpus ‘上的 TfidfModel 并将其保存到’ tfidf ‘，然后对整个语料库应用转换并将其命名为’ corpus_tfidf '。最后，我们预览了第一份文档的 TF-IDF 分数。
from gensim import corpora, modelstfidf = models.TfidfModel(bow_corpus)
corpus_tfidf = tfidf[bow_corpus]from pprint import pprintfor doc in corpus_tfidf:
pprint(doc)
break
[(0，0.5907943557842693)，
(1，0.3900924708457926)
(2，0.49514546614015836)
(3，0.5036078441840635)】
运行 LDA 使用的包字
使用 gensim.models.LdaMulticore 训练我们的 lda 模型，并将其保存到“lda_model”
lda_model = gensim.models.LdaMulticore(bow_corpus, num_topics=10, id2word=dictionary, passes=2, workers=2)
对于每个主题，我们将探索在该主题中出现的单词及其相对权重。
for idx, topic in lda_model.print_topics(-1):
print('Topic: {} \nWords: {}'.format(idx, topic))
Figure 3
你能用每个题目中的单词和它们对应的权重来区分不同的题目吗？
使用 TF-IDF 运行 LDA
lda_model_tfidf = gensim.models.LdaMulticore(corpus_tfidf, num_topics=10, id2word=dictionary, passes=2, workers=4)for idx, topic in lda_model_tfidf.print_topics(-1):
print('Topic: {} Word: {}'.format(idx, topic))
Figure 4
还是那句话，能不能用每个题目里的词和对应的权重来区分不同的题目？
使用 LDA 词袋模型对样本文档进行分类的性能评估
我们将检查我们的测试文档将被分类到哪里。
processed_docs[4310]
[‘雨’，‘帮助’，‘挫伤’，‘灌木’]
for index, score in sorted(lda_model[bow_corpus[4310]], key=lambda tup: -1*tup[1]):
print("\nScore: {}\t \nTopic: {}".format(score, lda_model.print_topic(index, 10)))
Figure 5
我们的测试文档最有可能成为我们的模型分配的主题的一部分，这就是准确的分类。
使用 LDA TF-IDF 模型对样本文档进行分类的性能评估。
for index, score in sorted(lda_model_tfidf[bow_corpus[4310]], key=lambda tup: -1*tup[1]):
print("\nScore: {}\t \nTopic: {}".format(score, lda_model_tfidf.print_topic(index, 10)))
Figure 6
我们的测试文档最有可能成为我们的模型分配的主题的一部分，这就是准确的分类。
在看不见的文档上测试模型
unseen_document = 'How a Pentagon deal became an identity crisis for Google'
bow_vector = dictionary.doc2bow(preprocess(unseen_document))for index, score in sorted(lda_model[bow_vector], key=lambda tup: -1*tup[1]):
print("Score: {}\t Topic: {}".format(score, lda_model.print_topic(index, 5)))
Figure 7
源代码可以在 Github 上找到。我期待听到任何反馈或问题。
参考:
使用 Google Colab 为每个人进行主题建模
Image from Pixabay
注意:Google Colab 笔记本已经针对 Python 3 进行了更新，包括 pyLDAvis 可视化，并改进了主题中热门单词和热门文档的原始显示。
您现在可以在文本中查找主题，而无需安装任何库或编写一行 python 代码。这一切都是由 Google Colab 实现的，这是一款定制的协作 Jupyter 笔记本，可以托管在 Google Drive 上。包含两个主题建模算法的奇妙的 Scikit-Learn 库默认安装在 Google Colab 上，这使得在文本中查找主题变得非常容易。
这篇博文和附带的 Google Colab 笔记本的目的是让主题建模能够被更广泛的受众所接受。诸如非负矩阵分解(NMF)和潜在狄利克雷分配(LDA)的主题建模算法在文档集合中寻找主要主题或主题。文档集合可以是短文档，如 tweets 或自由文本调查回复，也可以是长文档，如博客帖子或新闻文章。NMF 和 LDA 算法有两个有利于文本聚类的特点，这是其他算法如 k-means 所没有的。这两种算法都将文档集合作为输入，并返回主题中的主要单词和属于主题的文档——这一特性使得输出可解释。NMF 和 LDA 还支持主题之间的重叠(即文档可以属于多个主题)。我特别希望看到研究人员和定性内容分析师开始使用主题建模算法，现在他们可以了，这要归功于一个简单的 Google Colab 笔记本，它可以处理来自 Google Sheet 的数据。只需遵循以下简单步骤:
- 去 https://colab。研究。Google . com/Github/aneesha/Google colab _ topic modeling/blob/master/Colab _ topic modeling . ipynb
以上网址将从 Github repo 中打开 Colab 笔记本。 - Colab 笔记本将会打开。只有将 Colab 笔记本保存到 Google Drive 文件夹后，您才能使用它。点击文件菜单，选择“保存一份拷贝到驱动器…”。
- 接下来，您需要在您的驱动器文件系统上找到 Colab 笔记本。点击文件菜单，选择“在驱动器上定位”。
- 该文件夹通常被称为“Colab 笔记本”。创建一个新的 Google 工作表并导入文本数据。文本数据需要两列，即 id 和 text。
Figure 1: The required columns in the Google Sheet
- 返回到 Colab 笔记本，输入 Google 工作表的名称。您可以更改代码，但会提供一个表单字段。单击位于单元格左侧的播放按钮，运行第一个笔记本单元格。您需要通过点击链接来授权访问您的 Google Drive。在授权过程结束时，您需要输入一个验证码。
Figure 2: Authorizing access to a Google Sheet
- 运行“从 Google Sheet 加载和预览数据”笔记本单元格。将显示数据集的前几行。
- 使用提供的表单字段设置需要生成的主题数、热门单词数和必须显示的热门文档数。
Figure 3: Specifying the NMF and LDA algorithm parameters
- 运行 NMF 或 LDA 细胞。将显示主题模型的输出。
Figure 4: Topics discovered by the NMF topic modeling algorithm
- 笔记本现在是你的了。你可以把它移到一个新的文件夹，并添加新的谷歌工作表进行分析。
- 就这样——没有更多的步骤了。
Google Colab 笔记本的发布能够对来自 Google Sheet 的文本数据进行主题建模，这消除了开始主题建模的所有技术障碍。NMF 和 LDA 主题建模算法可以应用于一系列个人和商业文档集合。让你开始的一些例子包括自由文本调查回复、客户支持电话记录、博客帖子和评论、匹配标签的推文、你的个人推文或脸书帖子、github 提交、招聘广告和技术文章。如果你想出一种新的方法来使用 Google Colab 笔记本应用主题建模，请在评论区发布你的例子。
纽约时报新闻数据集的主题建模
Credits: Mario Tama, News Getty Images
一种用于新闻主题分类的非负矩阵分解方法
为什么要主题建模？
我们生活在一个不断收集数据流的世界。因此，从收集的信息中寻找见解会变得非常乏味和耗时。主题建模是作为组织、搜索和理解大量文本信息的工具而设计的。
什么是主题建模？
在机器学习中，主题模型被具体定义为一种自然语言处理技术，用于发现文档集合中文本的隐藏语义结构，通常称为语料库。一般来说，每个文档指的是一组连续的单词，就像一个段落或一篇文章，其中每篇文章包含一组单词。
让我们以纽约时报数据集为例，其中每篇文章代表一个文档。我们想解决的问题是这些单词在一个文档中出现的频率。这将允许我们将每个文档分类到一个特定的主题。
NMF 是如何工作的？
通常使用两种主要的主题建模技术，潜在狄利克雷分布 (LDA)和非负矩阵分解 (NMF)。让我们把重点放在主题建模的后一个实现上，对纽约时报新闻数据集中的相似词进行聚类。
NMF 技术通过概率分布检查文档并在数学框架中发现主题。作为一个例子，我们首先用矩阵 X 作为我们的数据。这个矩阵由两个更小的矩阵 W 和 H 表示，当它们相乘时，近似重构 X 。
在实施 NMF 之前有一些先决条件。首先，数据 X 必须有非负的条目。没有丢失，但可能有许多零。第二，学习因式分解 W 和 H 必须有非负项。
如何实现 NMF？
这个问题中使用的数据由来自纽约时报的 8447 份文件组成。词汇量 3012 字(此处下载)。我们首先使用该数据构建矩阵 X ，其中 Xij 是单词 I 在文档 j 中出现的次数。因此， X 是 30，128，447，并且 X 中的大多数值将等于零。
这里，我们将一个 N × M 矩阵 X 分解成一个秩- K 近似值 W H ，其中 W 是 N × K ， H 是 K × M ，矩阵中的所有值为 W 和 H 中的每个值都可以随机初始化为一个正数，这里我用的是均匀(0，1)分布。
我们通过最小化以下散度损失对该数据实施并运行 NMF 算法，其中 W 和 H 包含非负值:
对于数据预处理和矩阵计算，您可以在本文底部的编码参考中找到我的原始代码。
现在让我们挑选一些我们想要排序的主题，以及我们预期目标函数会偏离的迭代次数。假设我们将等级设置为 25，并运行 100 次迭代，这也对应于学习 25 个主题。
我们可以看到目标图是下面迭代的函数。通过观察目标函数的散度，我们确保了用于聚类相似单词的模型是稳定的。
运行该算法后，我们希望规范化 W 的列，使它们的总和为 1。这也是为了确保我们得到的概率分布没有大于零的值。
现在，假设我们为每个话题选择 10 个单词。对于 W 的每一列，我们列出了具有最大权重的 10 个单词，并显示权重以显示我们预期的概率分布。 W 的第 i- 行对应于提供数据的“字典”中的第 i- 个单词。
主题建模结果
下表捕获了一组包含 25 个主题的文档，这是我们预期的结果。仔细查看结果，话题 7 指的是财经话题，医疗领域话题 13 ，娱乐领域话题 14 ，以及商业领域话题 24 。这些只是数百个话题中的 25 个，如果不是数百万的话，还有其他的可能性！
挑战: 你能猜出上面每个题目代表什么吗？下面评论下来！
编码参考
**注意:**代码是基于 NMF 背后的原始数学概念和直观计算实现的，但更方便的替代方法是使用 Python 库，如 scikit-learn 。
希望你喜欢！
Source: https://github.com/moorissa/nmf_nyt
Moorissa 是一名研究生，目前在哥伦比亚大学学习机器学习，希望有一天她可以利用这些技能让世界变得更好，一次一天。
用 NLTK 和 Gensim 在 Python 中进行主题建模
在这篇文章中，我们将学习如何识别文档中讨论的主题，称为主题建模。特别是，我们将讨论潜在的狄利克雷分配 (LDA):一种广泛使用的主题建模技术。我们将应用 LDA 将一组研究论文转换成一组主题。
研究论文主题建模是一种无监督的机器学习方法，它帮助我们发现论文中隐藏的语义结构，允许我们学习语料库中论文的主题表示。该模型可以应用于文档上的任何种类的标签，例如网站上帖子上的标签。
该过程
- 即使我们不确定主题是什么，我们也会提前选择主题的数量。
- 每个文档都表示为主题的分布。
- 每个主题都表示为单词的分布。
研究论文文本数据只是一堆未标记的文本，可以在这里找到。
文本清理
我们使用下面的函数来清理我们的文本并返回一个令牌列表:
import spacy
spacy.load('en')
from spacy.lang.en import English
parser = English()def tokenize(text):
lda_tokens = []
tokens = parser(text)
for token in tokens:
if token.orth_.isspace():
continue
elif token.like_url:
lda_tokens.append('URL')
elif token.orth_.startswith('@'):
lda_tokens.append('SCREEN_NAME')
else:
lda_tokens.append(token.lower_)
return lda_tokens
我们使用 NLTK 的 Wordnet 来寻找单词、同义词、反义词等的意思。另外，我们使用 WordNetLemmatizer 来获取词根。
import nltk
nltk.download('wordnet')from nltk.corpus import wordnet as wn
def get_lemma(word):
lemma = wn.morphy(word)
if lemma is None:
return word
else:
return lemma
from nltk.stem.wordnet import WordNetLemmatizer
def get_lemma2(word):
return WordNetLemmatizer().lemmatize(word)
过滤掉停用词:
nltk.download('stopwords')
en_stop = set(nltk.corpus.stopwords.words('english'))
现在我们可以定义一个函数来为主题建模准备文本:
def prepare_text_for_lda(text):
tokens = tokenize(text)
tokens = [token for token in tokens if len(token) > 4]
tokens = [token for token in tokens if token not in en_stop]
tokens = [get_lemma(token) for token in tokens]
return tokens
打开我们的数据，逐行阅读，每行，为 LDA 准备文本，然后添加到列表中。
现在我们可以看到我们的文本数据是如何转换的:
import random
text_data = []
with open('dataset.csv') as f:
for line in f:
tokens = prepare_text_for_lda(line)
if random.random() > .99:
print(tokens)
text_data.append(tokens)
[’ social crowd ‘，’ social ‘，’ network ‘，’ base ‘，’ framework ‘，’ crowd ‘，’ simulation’]
[‘detection ‘，’ technique ‘，’ clock ‘，’ recovery ‘，’ application’]
[‘voltage ‘，’ syllabic ‘，’ companding ‘，’ domain ‘，’ filter’]
[‘perceptual ‘，’ base ‘，’ coding ‘，’ decision’]
['cognitive ‘，’ mobile ‘，’ virtual ‘，’ network ‘，’ operator ‘，’ investment ‘，’ pricing '，'f '，‘神经元’]
[‘平铺’，‘交错’，‘多级’，‘离散’，‘小波’，‘变换’]
[‘安全’，‘交叉’，‘层’，‘协议’，‘无线’，‘传感器’，‘网络’]
[‘客观性’，‘工业’，‘展示’]
[‘平衡’，‘分组’，‘丢弃’，‘提高’，‘性能’，‘网络’]
['身体 qos ‘，‘自适应’，‘无线电’，‘不可知论者’，‘传感器’，‘网络’]
[‘设计’，‘可靠性’，‘方法论’]
[‘上下文’，’
带有 Gensim 的 LDA
首先，我们从数据中创建一个字典，然后转换成单词袋语料库，并保存字典和语料库以备将来使用。
from gensim import corpora
dictionary = corpora.Dictionary(text_data)corpus = [dictionary.doc2bow(text) for text in text_data]import pickle
pickle.dump(corpus, open('corpus.pkl', 'wb'))
dictionary.save('dictionary.gensim')
我们要求 LDA 在数据中找出 5 个主题:
import gensim
NUM_TOPICS = 5
ldamodel = gensim.models.ldamodel.LdaModel(corpus, num_topics = NUM_TOPICS, id2word=dictionary, passes=15)
ldamodel.save('model5.gensim')topics = ldamodel.print_topics(num_words=4)
for topic in topics:
print(topic)
(0，’ 0.034 “处理器”+ 0.019* “数据库”+ 0.019* “发布”+ 0.019* “概述” ‘)
(1，’ 0.051* “计算机”+ 0.028* “设计”+ 0.028* “图形”+ 0.028* “图库” ‘)
(2，’ 0.050* “管理”+ 0.027* “对象”+ 0.027*
主题 0 包括像“处理器”、“数据库”、“问题”和“概述”这样的词，听起来像是与数据库相关的主题。主题 1 包括像“计算机”、“设计”、“图形”和“画廊”这样的词，它肯定是一个平面设计相关的主题。主题 2 包括像“管理”、“对象”、“电路”和“高效”这样的词，听起来像是企业管理相关的主题。诸如此类。
使用 LDA，我们可以看到具有不同主题不同文档，且区别是明显的。
让我们尝试一个新文档:
new_doc = 'Practical Bayesian Optimization of Machine Learning Algorithms'
new_doc = prepare_text_for_lda(new_doc)
new_doc_bow = dictionary.doc2bow(new_doc)
print(new_doc_bow)
print(ldamodel.get_document_topics(new_doc_bow))
[(38，1)，(117，1)]
[(0，0.06669136)，(1，0.40170625)，(2，0.06670282)，(3，0.39819494)，(4，0.066704586)]
我的新文档是关于机器学习算法的，LDA 输出显示主题 1 具有最高的分配概率，主题 3 具有第二高的分配概率。我们同意了！
记住以上 5 个概率加起来是 1。
现在，我们要求 LDA 在数据中找出 3 个主题:
ldamodel = gensim.models.ldamodel.LdaModel(corpus, num_topics = 3, id2word=dictionary, passes=15)
ldamodel.save('model3.gensim')
topics = ldamodel.print_topics(num_words=4)
for topic in topics:
print(topic)
(0，’ 0.029 “处理器”+ 0.016* “管理”+ 0.016* “辅助”+ 0.016* “算法” ‘)
(1，’ 0.026* “无线电”+ 0.026* “网络”+ 0.026* “认知”+ 0.026* “高效” ‘)
(2，’ 0.029* “电路”+ 0.029* “分发”+ 0.016*。*
我们还可以找到 10 个主题:
ldamodel = gensim.models.ldamodel.LdaModel(corpus, num_topics = 10, id2word=dictionary, passes=15)
ldamodel.save('model10.gensim')
topics = ldamodel.print_topics(num_words=4)
for topic in topics:
print(topic)
(0，’ 0.055 “数据库”+ 0.055* “系统”+ 0.029* “技术”+ 0.029* “递归” ‘)
(1，’ 0.038* “分发”+ 0.038* “图形”+ 0.038* “重新生成”+ 0.038* “精确” ‘)
(2，’ 0.055* “管理”+ 0.029* “多版本”+ 0.029*
皮尔戴维斯
pyLDAvis 旨在帮助用户解释符合文本数据语料库的主题模型中的主题。该软件包从拟合的 LDA 主题模型中提取信息，以通知基于 web 的交互式可视化。
可视化 5 个主题:
dictionary = gensim.corpora.Dictionary.load('dictionary.gensim')
corpus = pickle.load(open('corpus.pkl', 'rb'))
lda = gensim.models.ldamodel.LdaModel.load('model5.gensim')import pyLDAvis.gensim
lda_display = pyLDAvis.gensim.prepare(lda, corpus, dictionary, sort_topics=False)
pyLDAvis.display(lda_display)
Figure 1
显著性:衡量术语告诉你多少关于主题的信息。
相关性:给定主题的单词和给定主题的单词的概率的加权平均值，由主题的概率归一化。
气泡的大小衡量了主题相对于数据的重要性。
首先，我们得到了最显著的术语，意思是术语主要告诉我们与主题相关的事情。我们也可以看个别话题。
可视化 3 个主题:
lda3 = gensim.models.ldamodel.LdaModel.load('model3.gensim')
lda_display3 = pyLDAvis.gensim.prepare(lda3, corpus, dictionary, sort_topics=False)
pyLDAvis.display(lda_display3)
Figure 2
可视化 10 个主题:
lda10 = gensim.models.ldamodel.LdaModel.load('model10.gensim')
lda_display10 = pyLDAvis.gensim.prepare(lda10, corpus, dictionary, sort_topics=False)
pyLDAvis.display(lda_display10)
Figure 3
当我们有 5 或 10 个主题时，我们可以看到某些主题聚集在一起，这表明主题之间的相似性。这是一个多么好的方法来形象化我们到目前为止所做的事情！
试试看，找个文本数据集，有标签就去掉标签，自己建个主题模型！
源代码可以在 Github 上找到。我期待听到任何反馈或问题。
PLSA 的主题建模
假设你有数百篇文章/句子。你想知道每篇文章/句子谈论什么话题。一篇描述对一家制药公司的指控的文章可能会谈论像政府、医药或*商业这样的话题。*我们的目标是将这些主题分配给文档。
执行这项任务的方法之一是概率潜在语义分析(PLSA)。
PLSA 或概率潜在语义分析是一种用于在概率框架下对信息建模的技术。潜在因为话题被当作潜在的或隐藏的变量。
型号:
可以用两种不同的方式来理解 PLSA。
- 潜在变量模型
- 矩阵分解
第一个帮助你很好地理解 PLSA 的数学。而第二种方法很容易用 Python 实现。
让我们正式定义出现在 PLSA 的变量。
我们有三组变量
- 文件数: D={d1，d2，d3，…dN} ， N 为文件数。 di 表示 D 中带有文件的*。注意——此处的文档也可以指句子。这两个词可以互换使用。*
- 单词: W={w1，w2，…wM} ，M 是我们词汇量的大小。 wi 表示词汇表中的第 I 个单词 W.
注:集合 W 被视为单词包。意思是索引 I 的赋值没有特定的顺序 - 题目: Z={z1，z2，…zk} — 潜变量或隐变量。数字 k 是我们指定的参数。
指定了命名约定之后，让我们来看看第一种方法。
潜在变量模型:
如前所述，主题是隐藏变量。我们唯一看到的是文字和一套文件。在这个框架中，我们将隐藏变量与观察变量联系起来。
我们将 z 与( d，w) 联系起来的方式是，我们描述一个生成过程，我们选择一个文档，然后是一个主题，然后是一个单词。形式上，
- 我们选择一个概率为 P(d) 的文档
- 对于本文档中的每一个单词 dn，wi——从概率为 P(z|dn)的条件分布中选择一个话题 zi 。
- 选择一个有概率的单词 P(w|zi)
如果不是完全清楚，也不用担心。我在数学上把一切都放在前面了。在进入方程之前，让我们讨论一下模型的两个假设。
**假设 1——单词包:**正如我们之前讨论的，单词在词汇表中的排序并不重要。更准确地说，联合变量(d，w)是独立采样的。
假设—条件独立:我们做的一个关键假设是单词和文档是条件独立的。有条件地聚焦这个词。这意味着—
P(w，d | z)= P(w | z) P(d | z)——*(3)
上述讨论下的模型可指定如下—
现在，
利用条件独立性，
使用贝叶斯规则，
模型中的参数是—
- ***P(w | z)——***有(M-1)*K 个。怎么会？对于每一个 z 我们都有 M 个单词。但是因为这 M 个概率的和应该是 1，我们失去了一个自由度。
- ***P(z | d)——***有(K-1)*N 个参数来确定。
使用期望最大化或似然函数的 EM 算法来确定上述参数。
可能性函数—
Likelihood function
对数可能性—
Log Likelihood
我们不会深入 EM 算法是如何工作的。这次讨论的主要目的是让你熟悉主题如何与观察到的变量、单词和文档相关联。如果你想了解它的数学，你可以在这里找到相关的论文。
矩阵分解模型
另一种表示 PLSA 的方法是矩阵分解模型。
考虑一个维度为 NM* 的文档-单词矩阵，其中 N 是文档的数量， M 是词汇表的大小。矩阵的元素是一个单词在文档中出现的次数。如果单词 wi 在文档 dj 中出现一次，那么元素 (j，i) = 1。
如果你想到这个矩阵，大部分元素都是 0。假设我们有一个 10 个单词的文档和 1000 个单词的词汇表。自然地，该行的 990 个元素将具有值 0。这样的矩阵称为稀疏矩阵。
矩阵分解的作用是将这个矩阵(姑且称之为 A )分解成低维矩阵(奇异值分解)
Pictorial representation of the above equation
L、U 和 R 的尺寸分别为 NK、KK 和 KM* 。
矩阵 U 是对角矩阵，取值为 AA* 的特征值的平方根，其中*表示转置。对于任意给定的 *k，*你选择 L 的第 k 行，的第 k 元素， U 的第 k 列， R. 的第k列，记住， k 是我们设置的题目数。
这个模型与潜变量模型没有太大的不同。这三个矩阵可以解释为—
- L 包含文档概率 P(d|z)
- U 是主题 P(z) 的先验概率的对角矩阵
- R 对应单词概率 P(w|z)
所以如果你把三个矩阵相乘，你实际上做的是下面的等式——
请注意，这三个矩阵的元素不能为负，因为它们代表概率。因此，使用非负矩阵分解来分解 A 矩阵。
如果你想在 Python 中应用这个算法，你可以在这里找到一个例子。
感谢阅读！如果你喜欢这个博客，你可能想看看我的另一篇关于单词嵌入和 Word2Vec 的文章。
欢迎分享你的观点。很乐意在 LinkedIn 上与您联系
Tensorflow 中的地形/正则化特征学习[TF 中的手动反向投影]
Photo by Nick Dunlap on Unsplash
今天我想比较不同的正则化方法得到的不同结果，看看每种方法是如何影响梯度的。
情况 a) 0 范数自动编码器(p = 0)无正则化
情况 b) 0.5 范数自动编码器(p = 0.5 )
情况 c) 1 范数自动编码器(p = 1 )
情况 d)软化 1 范数自动编码器(p = 1.5 )
情况 e) 2 范数自动编码器(p = 2)
情况 f)软化 2 范数自动编码器(p = 2.5 )
情况 g) 3 个范数自动编码器(p = 3 )
情况 h) 4 个范数自动编码器(p = 4 )
情况 I)稀疏拓扑自动编码器(KL 发散方法)
请注意，这篇帖子是为了我未来的自己回顾这些话题以及纯粹的好奇。
审查向量规范
Video from this [website](http://Ritvik Kharkar)
如果任何人需要一个向量范数的基本审查，请观看上面的视频。
P 范数正则化/软化正则化
Image from this website website
L1 和 L2 正则化通常用于防止过拟合，但是从 P 范数正则化的定义中，我们实际上可以选择许多不同的 P 值正则化，今天让我们看看每个正则化项给出什么不同的结果。最后我会链接真正帮助我的视频。
Video from Alexander Ihler
现在当我看到 L2 范数的定义时，我感到困惑，根据 P 范数的方程,“适当的”L2 范数是由…
Image from this website
然而，当我们看到许多不同的机器学习教程时，我们会看到 l2 规范，如下所示。
Image from this website
这两项明显不同，也要注意导数也不同。此外，这种情况也发生在 L1 诺姆身上，我们不时会遇到 L1 诺姆’软化’版本。
Image from this website
上面的图片来自吴恩达的无监督学习课程。我们之所以用那个方程，是因为当|x|为零时，没有导数。然而，我们也可以简单地忽略这个事实，使用原始的绝对正则化，让导数只是权重的符号。(如下图。)
Image from this website and this website
不同 P 范数正则化函数的导数
在实现之前，让我们练习一下数学，手动计算不同 p 值的导数。
KL 散度的导数
image from this website
并且因为我们必须通过最小化 KL 散度来实现稀疏编码，所以让我们也导出关于 KL 散度损失函数的导数。如上所述，我们的数学检查。
地形稀疏编码
Image from this website
最后，我们有拓扑稀疏编码，我们的目标是学习具有一些有序方式的特征。(当输入类似的特征时，我们大脑中相互靠近的神经元就会激活。)
Image from this website
如上所述，当我们将拓扑结构的概念应用到我们的网络中时，我们可以看到，在学习过的过滤器中，彼此接近的过滤器倾向于激活相似的特征。如果有人需要衍生品方面的帮助，请点击此处。
情况 a) 0 范数自动编码器(p = 0)无正则化
左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度
在编码部分没有任何约束的情况下，我们可以清楚地看到，学习到的权重没有任何特定的顺序。好的一面是重建的图像非常清晰，然而，这是由于过度拟合。并且当我们观察梯度如何相对于输入变化时，我们可以看到大部分梯度变成灰色图像，不管图像中的数字是什么。下图显示了最终的结果。
情况 b) 0.5 范数自动编码器(p = 0.5 )
左上 →编码层权重的收敛过程
右上 →重建图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度
当我们添加 0.5 范数正则化时，我们可以立即注意到差异，在左上角的图像中，黑色方块立即出现。这表明学习到的权重为零，并且学习到的权重中存在大量漏洞。这是意料之中的，因为 p 值为 0.5 会促进稀疏性。此外，我们现在注意到，相对于输入的梯度开始显示类似边缘的数字符号。
案例 c) 1 范数自动编码器(p = 1 )
左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度
当 P 值设置为 1(也称为曼哈顿范数)时，当 P 值设置为 0.5 时，网络会生成类似的结果。这也是预料中的，然而如下所示，当与该值被设置为 0.5 的情况相比时，在最终时期学习的权重更亮。(向上滚动自己对比！)
案例 d)软化 1 定额自动编码器(p = 1.5 )
左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度
现在事情变得有趣了，吴恩达使用了这个不包含绝对函数的 L1 范数的软化版本。当我们观察学习到的权重时，我们可以直接看到结果的差异，现在我们可以观察到学习到的权重中间的数字。
情况 e) 2 个标准自动编码器(p = 2)
左上 →编码层权重的收敛过程
右上 →重建图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度
当我们使用标准的 L2 范数(不是软化版本)时，我们可以看到学习到的权重看起来与我们使用 1 范数的软化版本时的情况非常相似。然而，一个区别是梯度，当我们仔细观察输入的梯度时，我们可以观察到边缘变得更加清晰。
情况 f)软化 2 个标准自动编码器(p = 2.5 )
左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度
然而，当我们使用 L2 常模的软化版本时，我们得到(在我看来)更好的结果。其中所学习的重量代表每个手指的不同手笔画。不仅梯度更清晰，我们还可以观察到不同梯度之间更鲜明的对比。(相对于编码层的梯度)(当我们考虑它时，绝对函数在零处的导数是未定义的，并且我们已经软化了它，所以导数不是+就是-。然而，这似乎无助于学习更好的表达。此外，我们将权重初始化为具有零均值的高斯分布，这表明相对于原始权重的大部分导数必须被软化，并且这可以转化为噪声。)
例 g) 3 定额自动编码器(p = 3 )
左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度
当我们接近更高的 p 值时，我们仍然使权重变小，但是我们放弃了稀疏性。并且每个权重之间的关系变得更加相互独立。上面看到的结果与我们使用 p 值 2 时非常相似，在我看来没有太大的不同。
情况 h) 4 个范数自动编码器(p = 4 )
左上 →编码层权重的收敛过程
右上 →重构图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度
当我们将 p 值设置为 4(我们的最高值)时，我们可以立即注意到，与其他情况相比，学习到的权重看起来更加不同。学习的过滤器实际上类似于一个数字，但是具有相反的对比度。
情况 I)稀疏地形自动编码器(KL 发散方法)
左上 →编码层权重的收敛过程
右上 →重建图像
左下 →相对于输入图像的梯度
右下 →相对于编码层的梯度
最后，当我们通过分组矩阵将编码权重分组在一起时，我们可以看到一个结构正在形成。不仅仅是学习到的权重，还有梯度。当我们观察渐变时，现在它不像一个椒盐噪声类型的图像，而是看起来有某种一般的结构。
从学习到的权重(见底部)我们可以看到，每个细胞响应某种类型的数字，如 0 或 1。例如，在左/右角的图像似乎喜欢边缘，而中心更喜欢圆形的图像。
交互代码
对于 Google Colab，你需要一个 Google 帐户来查看代码，而且你不能在 Google Colab 中运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！
要获取这篇文章的代码，请点击这里。
最后的话
如果有人想知道 L1 的一些优点和其他信息，请参见下面的，这很有趣，因为我们可以组合许多不同的正则化项来优化给定的函数，这本身就是一个优化问题。
Image from this website
此外，这篇博客的文章也是一篇很好的阅读材料,可以用来概括正则化术语。
如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你希望看到我所有写作的列表，请在这里查看我的网站。
同时，在我的推特这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。我也实现了广残网，请点击这里查看博文 pos t。
参考
- NumPy . fill _ diagonal—NumPy 1.15 版手册。(2018).Docs.scipy.org。检索于 2018 年 9 月 17 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . fill _ diagonal . html
- 稀疏编码:自动编码器解释。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 17 日，来自http://uf LDL . Stanford . edu/wiki/index . PHP/Sparse _ Coding:_ auto encoder _ Interpretation
- 利用反向传播思想推导梯度。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 17 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/derivating _ gradients _ using _ the _ back propagation _ idea
- Deep Learning 12_ 深度学习 UFLDL 教程：Sparse Coding_exercise（斯坦福大学深度学习教程） — 夜空中最帅的星 — 博客园. (2018). Cnblogs.com. Retrieved 17 September 2018, from http://www.cnblogs.com/dmzhuo/p/4994947.html
- 练习:稀疏编码— Ufldl。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 17 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/Exercise:Sparse _ Coding
- Wolfram|Alpha:让世界知识可计算。(2018).Wolframalpha.com。检索于 2018 年 9 月 19 日，来自http://www.wolframalpha.com/input/?I = y * log(y % 2Fx)+% 2B+(1-y)+*+log(+(1-y)% 2F(1-x))
- 对数的导数—log(x)’。(2018).Rapidtables.com。检索于 2018 年 9 月 19 日，来自https://www . rapid tables . com/math/algebra/logarity/logarity _ derivative . html
- 稀疏编码:自动编码器解释。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 19 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/Sparse _ Coding:_ auto encoder _ Interpretation
- 稀疏编码:自动编码器解释。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 19 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/Sparse _ Coding:_ auto encoder _ Interpretation
- 练习:稀疏编码— Ufldl。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 19 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/Exercise:Sparse _ Coding
- 利用反向传播思想推导梯度。(2018).Ufldl.stanford.edu。检索于 2018 年 9 月 19 日，来自http://ufldl . Stanford . edu/wiki/index . PHP/derivating _ gradients _ using _ the _ back propagation _ idea
- 基于稀疏性的正则化。(2018).YouTube。检索于 2018 年 9 月 19 日，来自https://www.youtube.com/watch?v=jEVh0uheCPk&t = 123s
- 线性回归(6):正则化。(2018).YouTube。检索于 2018 年 9 月 19 日，来自https://www.youtube.com/watch?v=sO4ZirJh9ds&t = 334s
- 科学计算矩阵范数、收敛和矩阵条件数。— ppt 下载。(2018).Slideplayer.com。检索于 2018 年 9 月 19 日，来自https://slideplayer.com/slide/6006587/
- 定义，F. (2018)。用极限定义求|x|的导数。数学栈交换。检索于 2018 年 9 月 19 日，来自https://math . stack exchange . com/questions/83861/finding-the-derivative-of-x-using-the-limit-definition
- Anon，(2018)。[在线]可从以下网址获取:https://www . quora . com/What-is-the-derivative-of-the-absolute-value-of-x【2018 年 9 月 19 日获取】。
- Anon，(2018)。[在线]可从以下网址获得:https://www . quora . com/What-is-the-advantage-of-the-L2-L1-L1-L2-诺姆-诺姆-特征标准化【2018 年 9 月 19 日获取】。
- 模特，W. (2018)。为什么稀疏模型的 L1 范数？交叉验证。检索于 2018 年 9 月 19 日，来自https://stats . stack exchange . com/questions/45643/why-L1-norm-for-sparse-models
- L1 和 L2 作为损失函数和正则化的区别。(2018).chioka . in . 2018 年 9 月 19 日检索，来自http://www . chioka . in/differences-between-L1-and-L2-as-loss-function-and-regulation/
- 向量范数。(2018).YouTube。检索于 2018 年 9 月 19 日，来自https://www.youtube.com/watch?annotation _ id = annotation _ 1494666085&feature = iv&src _ vid = 5 ASL 5 eq 2 x0a&v = 5 fn 2j 8 wyn fw
总体最小二乘法与 OLS 和 ODR 的比较
线性回归分析的整体概述
目录:
- OLS:快速回顾
- TLS:解释
- ODR:触及表面
- 三种方法的比较及结果分析
总体最小二乘法(又名 TLS)是一种回归分析方法，旨在最小化响应变量(或观察值)和预测值(我们常说的拟合值)之间的误差平方和。最流行和标准的方法是普通最小二乘法(又名 OLS)，TLS 是采用不同方法的其他方法之一。为了获得实际的理解，我们将通过这两种方法以及正交距离回归(又名 ODR)来了解一下，这是一种旨在最小化正交距离的回归模型。
OLS:快速回顾
为了复习我们的知识，首先让我们回顾一下回归分析和 OLS。一般来说，我们使用回归分析来预测(或模拟)未来事件。更准确地说，如果我们有一堆过去收集的数据(这是一个自变量)和相应的结果(这是一个因变量)，我们就可以用我们刚刚收集的新数据来制造预测未来结果的机器。
为了制造更好的机器，我们应用回归分析并试图获得更好的参数，这是我们模型的斜率和常数。例如，让我们看看下图。我们求红色回归线的参数(而蓝色点是数据点(响应变量和自变量)，灰色线的长度是这个估计量计算出来的残差的量)。
A visual comparison between OLS and TLS
在 OSL，灰色线不是正交的。这是 OSL 和 TLS(以及 ODR)的主要区别。在 OSL，灰线平行于 y 轴，而在 TLS 中，灰线垂直于回归线。OLS 的目标函数(或损失函数)定义为:
这通过二次最小化来解决。我们可以从中获得参数向量(这就是我们所需要的)。
Numpy 为此提供了 numpy.linalg.lstsq，不过从头开始实现这个 正规方程 很容易。我们在下面的代码中得到 b 中的参数向量，并用它来预测拟合值。numpy.linalg.lstsq 期望常量 c 存在于最后一个索引处，所以我们需要切换列值的位置。
TLS:解释
让我们回到 TLS，考虑一下 TLS 优于 OLS 的原因。OLS 期望所有的样本数据都被精确地测量，或者没有误差地观察。然而，在实际情况下，或多或少会有观测误差。如果假设是合理的，OLS 可能是一个不一致的估计量，而不是理论假设的理想机器。TLS 可以考虑这个问题，它允许自变量和因变量都存在误差。我们希望最小化自变量的误差 E 和因变量的误差 F 。这些误差被认为包含观测误差和残差。
用 SVD 求解 X 和 Y 的协方差矩阵后，我们得到了下面的等式。是 的左奇异向量【xᵀy】**【σ】**是对角线上有奇异值的对角矩阵。
同样参数向量 B 定义为:
在下面的代码中(TLS 正规方程的实现)，我们计算了**【E F】并添加了对 Xtyt 的返回。(Xtyt 只是 x 波浪号和 y 波浪号的意思。一个波浪号往往暗示一个近似值)垂直堆叠的向量【vxy vyy】是【xᵀy】v的右奇异向量的整个最后一列。用于计算参数向量【B】的 Vxy 和 Vyy 与此不同。 Vxy 和 Vyy 都是被截断的数量的×变量*** 。*
第**【n】列为错误n到最后一列为错误 F 。我们还可以通过Y =【X，E】B计算出估算的 Y 值，写在下面第 15 行。关于 Matlab 中更多数学过程和代码的参考，可以查看 这个 详细 pdf。**
(警告:对于非 Matlab、R、Julia 或 Fortran 用户，数组的索引从 1 开始)
ODR:触及表面
有一种回归模型旨在最小化正交距离。谢天谢地，Scipy 提供了 scipy.odr 包。我们可以在数据** 功能中设置误差值**【wd】。这是一个权重矩阵，用于处理残差的不等方差(异方差)。如果我们事先知道误差有多大/多小，这种调整可以提高估计量。然而，在现实世界中，很难确定或估计这一点。这种加权也是提高加权最小二乘和广义最小二乘应用的有效方法之一。****
我们在【wd】中设置1×N的误差值数组，也就是说的误差值被应用到的数据点上。****
ODR 比其他国家更适合这个数据集。
三种方法的比较
让我们比较这三种方法，直观地看看它们的适用性。左图中灰色的上方三角形是自变量和因变量都包含错误的数据。右图显示了每个模型产生的每个数据点的误差。纵轴表示误差有多大。ODR 和 TLS 在二次曲线的中心拟合得非常好，然而，随着它们远离中心，它们的预测失去了精度。为了解释这一点，当拟合值的方差很小时，ODR 和 TLS 工作得很好。特别是当拟合值的方差如此大时，TLS 将不再正确工作，尽管当方差小时，在没有任何加权值的情况下预测拟合值是非常精确的。在这种情况下，我们需要应用迭代方法，例如梯度下降。
以确保每个模型的均方误差(又名 MSE)和拟合优度(或 R2 分数)。总的来说，ODR 更适合这个数据样本，但这取决于数据。我们需要逐一考虑这些模型，直到找到最佳模型。
参考资料:
我们浏览的样本数据:
哪些欧洲国家游客泛滥？(以及其他数据支持的欧洲旅游趋势)
去年，当我第一次计划去意大利、西班牙和匈牙利等几个国家的欧洲度假时，我把研究重点放在寻找所有“必看”的旅游景点上。然而，当我回忆起那些旅行时，这些品牌景点没有一个在我的记忆列表中名列前茅。尽管明信片上的地方令人敬畏，但周围的环境几乎就像一个游乐园，街道两旁是游客陷阱餐厅，多语言菜单，街头企业家向像我这样的人出售各种仿制品。你在附近找不到当地人是有原因的。
事实证明，我度过的一些最美好的时光是在巴塞罗那传统的 Gràcia Barrio、奥斯陆肮脏但富有艺术气息的 grünerl kka 区以及罗马以美食为主的 Trastevere 街区漫步度过的。虽然所有这三个提到的地区都位于主要目的地的一英里范围内(因此仍然拥有游客的存在)，但这些景点提供了当地人如何生活的一瞥(更重要的是，ate)。
经过最近的两次旅行，我意识到下次我去欧洲时，我想去那些我能真正观察到文化的地方，一个没有受到游客太多影响的地方。
欧洲国家旅游(按 2015 年游客总数排序)
利用现有的最新乡村居民人口和旅游业数据，我决定专注于三个主要指标来回答我的问题*:
-2015 年游客总数(千人)
-五年期间游客抵达的百分比变化
-2015 年期间游客人数除以该国居民的比率
*在编写这些报告时，瑞典或斯洛伐克没有完整的数据，因此这两个国家都没有包括在本报告中。
当然，当你按年度游客数量对这些国家进行排名时，排名第一并不令人惊讶。法国在 2015 年以 8450 万游客领先，其次是西班牙(6850 万)和意大利(5070 万)。但是当你观察 2010 年到 2015 年游客的变化时，你会发现这些顶级旅游国家的旅游增长率有很大的不同。
从 2010 年到 2015 年，法国的旅游人数仅增长了 8.8%，是整体旅游人数排名前 10 位的国家中最低的。另一方面，希腊以令人印象深刻的 57.3%的旅游业增长率位列前十。
这里还需要注意的是，不仅像法国这样的主要旅游强国每年都有大量的游客，而且游客人数已经超过了当地居民。在法国，2015 年的 8450 万游客超过当地人口 26.4%。在西班牙，情况更糟，游客数量比当地人多 41.1%(然而西班牙的旅游业增长率是法国的三倍多)。然而，没有一个国家胜过奥地利，它的游客与居民的比率是令人难以置信的 306.8%。
欧洲国家的旅游业(按 2010 年至 2015 年游客到达的变化百分比排序)
说到时尚国家，世界上没有什么比冰岛更受欢迎的了。如果法国是星巴克，那么冰岛就是菲尔茨咖啡(有意冒犯，法国)。五年来，冰岛的游客数量增长了 163.6%。130 万国际游客超过当地冰岛人口 284%。
上面的地图描绘了每个国家，根据国际游客与实际居民的比例进行着色。
暗绿色表示游客比例较低的国家，而暗红色表示游客与居民比例较高的国家。较浅的阴影表示居民和游客的比例几乎相等。
去年我去过五个欧洲国家(意大利、瑞士、匈牙利、西班牙和挪威)，我不可能猜到意大利的游客与当地人的比例最低(81.8%)，我的意思是在 10 月下旬那里挤满了游客。说实话，我会赌匈牙利(145%)，但最近的想法，我意识到，虽然我注意到在布达佩斯完全没有美国游客，但毫无疑问，我记得有很多东欧游客。
在主要国家中，令我惊讶的是，尽管德国南部与卢森堡(187%)、法国(126%)、瑞士(114%)、奥地利(307%)和捷克共和国(109%)接壤，但它的游客/居民比率为 43%。
纵观所有人口超过 500 万的欧洲国家，几乎每个国家的游客数量都在大幅增长。当分析五年间游客数量的变化时(将这些国家按 20%的区间分组)，大多数国家的增长幅度在 20-40%之间，紧随其后的是增长相对较低的国家(旅游业增长< 20%)。
最后，结合这两个因素，这是一个象限图，只显示人口超过 500 万的国家。x 轴是游客与居民的比率，y 轴是 5 年来游客抵达的变化，圆圈的大小表示各个国家居民人口的规模。
游客与居民比率低&旅游业增长低
这些地区处于最佳状态，增长速度并不快。
虽然俄罗斯、乌克兰和芬兰等国家因其地理位置或各种其他旅行限制而在一定程度上有意义，但我对英国出现在这份名单中感到意外。
高游客与居民比率&旅游业高增长
这些地区的游客已经饱和，而且这种趋势也没有减缓。远在右上角的是希腊。追赶希腊的是匈牙利、西班牙、捷克、荷兰。
尽管我对冒险进入匈牙利等(相对而言)较少人去的领域感到自豪，但它确实属于这一类，这意味着我不是我想象中的那么时髦的旅行者。
低游客与居民比率&旅游业高增长
这些国家仍然很少被国际游客光顾，但这些美景的时间正在流逝。网格的最左边是罗马尼亚，游客/居民比率只有 10%，但它也越来越受欢迎。毫无疑问，更实惠的价格和旅游兴趣的扩大促成了东欧国家在短短五年内超过 65%的繁荣。这一部分还包括德国、土耳其和波兰。
高游客/居民比率&旅游业低增长
虽然这些国家可能已经到了无法回头的地步，但令人欣慰的是，它们的增长速度并不快。像法国和意大利这样的旅游大腕在这个名单上占据了重要位置，但是像挪威、瑞士和奥地利这样的小国也榜上有名。
感谢您阅读我最新的数据帖子。作为一名产品营销和数据分析专业人士，我对数据支持的讲故事充满热情。这些数据新闻帖子是我将真实数据与我个人的不同兴趣整合起来的方式，这些兴趣包括从旅行和娱乐到经济和社会问题的任何事情。如果您有任何评论、故事想法或预期的数据项目，请随时发送电子邮件至我的 dwpwriting <邮箱至> gmail < dot > com 或通过LinkedIn联系我。
使用 AWS CodeStar，在 10 分钟内将您的 ML 模型转变为 web 服务
部署您的模型变得更加容易
Photo by Ryan Hutton on Unsplash
作为一名数据科学家，开发一个能够做出正确预测的模型本身就让人觉得非常值得。然而，您机器上的 hdf5 文件通常对您的公司或任何与您刚解决的问题有相同问题的人来说并没有真正的帮助。因此，下一步通常是为您的模型创建一个 web 服务，您可以通过 API 访问它。一种选择是编写一个 Flask 应用程序，您可以将其托管在您的服务器上。不幸的是，这种方法通常很复杂，而且扩展性不好。虽然有很多工具可以帮助设置和管理虚拟服务器，但是每个试图设置 EC2 实例的人都知道随之而来的麻烦。坚持使用 AWS，下一个选择是在 Lambda 上运行您的模型，通过 API Gateway 等公开它。由于至少需要管理四个不同的服务+代码，这种方法可能更简单，但仍然非常复杂。幸运的是，亚马逊认识到了这个问题，并在 2017 年推出了解决方案: AWS CodeStar 。
CodeStar 通过以直观易用的方式连接多个 AWS 服务，简化了应用程序的创建和部署流程。作为一个例子，我们将部署我的实现Rob RenaldsGibberish Detector，这是一个基于马尔可夫链的工具，用于检测一个字符串是包含真正的单词还是只是随机的“乱码”。我在德语文本上训练模型，并将其存储为 Python Pickle 文件。
到本文结束时，我们将拥有一个工作的 web 服务，它通过 GET 请求接收一个变量，通过 Python 代码运行模型，并将结果预测作为 JSON 返回。
步骤 1:创建您的 CodeStar 项目
Over 30 templates make it easy to set up your web service or app
因为我们的目标是建立一个 web 服务，所以我们可以选择第一个 Python 模板。因此，我们的服务将在 Lambda 上“无服务器”运行。以下三个步骤相对来说不言自明:
- 我们决定一个项目名称，AWS 也将把它转换成一个 URL 友好的项目 id。稍后，这个项目 id 将成为 HTTP 端点的一部分。
- 接下来，我们必须选择我们首选的 Git 存储库。如果您决定使用 GitHub，您可以选择更改存储库名称、描述，并将其设置为 public 或 private。CodeStar 将为您创建一个存储库，其中包含所有必需的文件，稍后会有更多相关内容。
- 为了发挥它的魔力，CodeStar 需要获得许可来代表你管理我们管道中所有不同的工具。
Our AWS CodePipeline
步骤 2:连接到您的源存储库
CodeStar 的一个伟大之处在于，代码都是通过 Git 管理的，每次更新都会更新 Lambda 函数并自动部署。因为 AWS 会自动为您创建存储库，所以开始编码所需要做的就是一个git clone your_repository_url。
AWS CodeStar creates all the necessary files for you
步骤 3:在 AWS APIGateway 中创建 GET 参数
要更改 API 参数，我们需要在 AWS APIGateway 中打开我们的项目。最快的方法是在我们的仪表板的边栏上:项目->项目资源-> AWS APIGateway。
AWS APIGateway before our changes
第一步是添加一个方法请求。在本练习中，我们添加一个字符串参数，称为字符串。因为我们需要这个输入来运行我们的模型，所以我们可以将这个参数设为必需的。APIGateway 要求我们检查一个合适的请求验证器。因为我们只使用 URL 参数，所以验证器验证查询字符串参数和头就可以了。以下是结果页面的外观:
AWS APIGateway configuration for one URL parameter
步骤 4:编写 Lambda 函数
CodeStar 从您的 Git 存储库构建。因此，一旦完成，您就可以在您最喜欢的 IDE 和push中编写代码。默认情况下，创建的存储库包含以下项目:
- index.py:这个文件包含 Lambda 函数的代码。
- readme . MD:readme 文件包含有关后续步骤的基本信息以及到官方文档的链接。
- template.yml:你的“无服务器”AWS 架构的结构。
- 这个文件包含在构建过程中执行的附加命令。标准的命令预构建是单元测试的执行。
- tests/:包含带有上述单元测试的文件 test_handler.py 。
首先，我们必须使我们的模型文件可以被函数访问。最简单的方法是将文件添加到我们的 Git 存储库中。AWS Lambda 有相对宽松的存储限制，对于大多数用例来说应该足够了。一旦上传，Lambda 可以使用open以通常的方式访问文件。
最后，我们可以将我们的 Python 代码写入 index.py，它将成为我们的 Lambda 函数。根据我们在步骤 3 和 4 中的设置，我们可以通过event参数轻松访问 URL get-parameter:
req_name = event['queryStringParameters']['string']
你可以在 Github 上找到完整代码。在实现了主函数之后，我们必须更新单元测试。请记住，如果单元测试失败，服务将不会被部署。因此，我们会相应地更新所有内容:
我们现在要做的就是使用常用的命令:git add .、git commit和git push将模型文件和代码推送到项目存储库。一旦更改上线，CodeStar 将自动更新其代码基础，并构建和部署一切。您可以在仪表板的右侧找到状态。
How it should look like
最后的话
如果你跟着做了——恭喜你，你刚刚在不到 10 分钟的时间里公开了你的机器学习模型！您可以在仪表板上找到 API 的端点，添加参数，瞧。由于 AWS CodePipline 的集成，很容易保持您的模型更新，与 Amazon CloudWatch 的连接让您可以深入了解一旦您的功能在野外会发生什么。
通过 Lambda 公开你的机器学习模型只是你可以用 CodeStar 做的许多伟大事情之一。下一次，当你在设置任何涉及 5+服务的 AWS 工作流程时迷失了方向，看一看，也许 CodeStar 也能帮助你减少生产时间。
走向一个更好的无足轻重的小费模式:一个基本的启发式分析
这是我尝试开发一个关于无足轻重的小费的数据模型的系列文章的第一部分。你可以在这里阅读前奏和第二部 在这里 。这篇文章使用的数据和代码在Footy TipperGitHub repo 中(在实验文件夹中)。所有数据来自 2010 年至 2017 年的 AFL 比赛。
Photo by Charles Van den Broek on Flickr
足球小费是澳大利亚人每周挑选澳大利亚规则足球(AFL)球队赢得比赛的流行消遣(就像填写三月疯狂括号，只不过每次都是一轮，当球队得分时，裁判会把手指变成手枪)。每个给小费的人都可以因正确选择赢家而得到一分，如果是平局，也可以得到一分。在赛季结束时，获胜者是得分最多的一方，预测每轮第一场比赛的差距作为决胜局。
有各种各样的试探法可以用来挑选本周的赢家和输家。在我与小费者和足球爱好者的交谈中，我发现普通参与者倾向于接受数据，例如哪个队更受青睐，哪个队是主队，每个队最近的表现如何，以及他们预计其他竞争对手会给谁小费，然后凭直觉处理这些信息，以这种方式得出他们对本轮的预测。
下面，我将介绍一些预测比赛结果的基本试探法，比较它们各自的准确性，然后对 AFL 比赛结果的赔率中包含的偏差进行更深入的分析。
基本启发式算法的准确性比较
下面是一个简单而合理的给 AFL 比赛小费规则的简要调查。这当然不是一个全面的列表，但对于一个并不真正关注球队目前比赛情况的人来说，每个启发都代表了一种在使用单个容易找到的数据点时实现高于 50%的准确率的方法。
启发 1:永远给主队小费
尽管很少有人会选择主队赢得每场比赛，但一个普遍公认的事实是，主场比赛比客场比赛更好，以至于季后赛系列赛都是围绕这一前提的接受而构建的，在线小费比赛通过默认客队来惩罚不付小费的人。
总是给主队小费时的准确率:57.29%
启发 2:总是给排名较高的团队小费
这虽然简单，但可能更接近于一个普通球迷可能给出的提示:参数是快速的两个词谷歌搜索(你甚至不必去另一个网站)，并且人们总是选择从赛季开始到当前一轮的历史上更成功的球队。当然，令人沮丧的事情确实会发生，1 号和 15 号之间的差别比 7 号和 8 号之间的差别要大得多。
总是给排名较高的团队小费时的准确率:68.00%
启发 3:总是提示胜算最大的人
从最终用户的角度来看，这是一种启发式方法，几乎与提示排名更高的团队一样简单，但它的行为几乎像一个复杂的黑盒集合模型:据我们所知，局外人可以获得与 oddsmakers 相同的数据，我们知道他们正在优化收入，但我们不知道什么过程——什么秘方——产生了人们押注的线赔率和点差。也许一群戴着软呢帽、穿着廉价西装、棱角分明的老人抽着雪茄，争论着悉尼究竟会以多少分击败圣基尔达；也许是一个分布式深度学习模型，日夜在 GPU 上运行，每 5 分钟计算一次赔率到 100 个有效数字；也许一个预言家会观察天空，看鸟儿在某一天是如何飞行的。在任何情况下，博彩赔率肯定代表了比前面描述的任何试探法多得多的数据的集合。
总是预测胜算最大的概率时的准确率:72.32%
试探法概述
如上面的平均准确率所示，启发式算法的可靠性随着其来源所考虑的数据输入数量的增加而增加。
- 计算主队只需要一个数据:哪个队在主场。
- 计算排名更高的球队需要更多的东西:两支球队在本赛季的累计胜场、平局、得分和对手的得分。
- 最后，在计算每场比赛的赔率时，可能会考虑上述所有因素，加上每支球队最近的胜率、他们的比赛统计数据、他们球员的个人统计数据、是否有球员受伤、每场比赛的正面交锋历史等等。
由于超过 4%的几率是最准确的启发式方法，我将使用它作为基准，来衡量我稍后将开发的机器学习模型的性能。因此，我将把进一步分析的重点放在检查投注赔率中的偏差上，目标是使用这些信息来帮助我的模型确定何时反驳赔率，希望最终实现更高的准确性。
博彩赔率分析
既然我们知道仅基于投注赔率的小费提供了最高的准确性，让我们探索在什么条件下投注赔率更准确或更不准确。赔率是由博彩公司设置的反馈回路决定的，博彩者基于感知的低效率而冒险(“卡尔顿不可能输给墨尔本超过 50 分！”)，然后这些公司根据总体博彩行为调整赔率，以实现收入最大化。这意味着博彩赔率代表了足球迷对每支球队获胜概率的传统看法，因为赔率制造者和赌博公众之间的任何差异都会很快得到解决。所以，问题是是否有偏见倾向于形成对球队获胜概率的总体看法。在什么情况下更有可能出现心烦意乱？如果我们能够理解博彩赔率何时以及为什么会不太准确，我们就可以在训练模型时强调这些特征，希望它能够更准确地预测比赛结果。
当价差很小时(大约在-25 和 25 点之间)，下注赔率不成比例地错误。这并不奇怪。然而，在每个点差值上，下注赔率正确的次数多于错误的次数，这意味着即使是在势均力敌的比赛中，你最好还是下注最有希望的一方。
主队的赔率
正如我们所展示的，在其他条件相同的情况下，主队的胜率要比客队略高一些(约 57%)。那么，奇怪的制造者是如何考虑到这一点的呢？他们对主队和客队有偏见吗？
赔率制定者在支持主队方面保持合理的平衡，选择他们获胜的概率为 57.68%，这与主队 57.29%的胜率一致。当选择主队时，赔率制造者的总体准确性提高了约 2%(当选择客场时，比平均水平差约 4%)，这表明他们更善于识别主场优势何时会成为决定性因素，何时不会。
主队的赔率:跨州比赛
除了被广泛接受的跨体育和联赛的主场优势的影响，AFL 起源的一个怪癖给我们的分析增加了一条皱纹。澳大利亚规则足球始于该国南部和西部的地区运动，橄榄球联盟是北部和东部的主要接触运动。事实上，澳大利亚足球联盟曾经是维多利亚足球联盟，即使现在联盟的 18 支球队中有 10 支位于维多利亚州，他们的主场距离彼此只有一小时多一点的车程(根据谷歌地图，1 小时 1 分钟)。因此，根据我的各种对话，关于主场优势的传统观点是，对于来自同一地区的球队来说，主场优势很小，甚至可能不存在，而当球队来自不同的州时，主场优势就更加重要了。
考虑到这一点，我将研究跨州比赛，看看在这些情况下主场优势的影响是否更大。
主场球队赢得了 58.16%的跨州比赛，总体上比主场球队多赢了大约一分，这表明额外旅行距离的影响是真实的，尽管很小。然而，奇怪的是，61.51%的时候支持跨州主场球队，大约多三分，这意味着传统智慧认为跨州效应是实际的三倍。这是一个证据，赌赔率往往会放大关于影响球队获胜概率的因素的传统智慧。跨州比赛的投注赔率准确率为 72.65%，比整体准确率高出不到半个点。上面的标准化混淆矩阵也显示了我们在所有匹配中看到的预测误差之间的类似平衡。
为排名较高的队伍下注
如前所述，比一支球队是否在主场比赛更强的获胜概率预测因素是他们是否比他们的对手更高(约 57%比约 68%)。因此，博彩公司通常青睐排名更高的球队是有道理的。问题是这种趋势有多强，在多大程度上得到了排名更高的球队的实际表现的支持。
尽管排名较高的球队只赢得了 68.00%的比赛，但赔率制造者选择他们赢得 82.45%的时间，这比我们在其他细分市场看到的不平衡要大得多。
通过观察混淆矩阵，我们发现，下注赔率错误地偏向于排名较高的球队的情况比偏向于排名较低的球队的情况更多。此外，就像挑选主队一样——更是如此——赔率制造者在识别更好的球队(根据他们的排名)何时会赢比差的球队何时会赢要好得多。
看起来真实的效果越强(主场优势，跨州比赛的主场优势，阶梯排名作为获胜的预测因素)，越不平衡的投注赔率变得有利于应该获胜的球队。即使这些偏差似乎不会显著影响投注赔率的整体准确性，但它们确实显示了一些赔率不太准确的情况，即当它们与传统观点相反时。这意味着，至少在势均力敌的比赛中，当赔率有利于排名较低和/或客场的球队时，偶尔给对手小费可能是值得的。
按团队下注的赔率
在组织形式上，AFL 比欧洲足球联盟更接近于美国体育联盟:赛季之间有一个选秀，在这个选秀中，烂队可以优先得到顶级业余球员，有工资帽，自由球员等等。这些规则中的许多都是为了促进球队之间的平等，防止一组球队进入决赛，而另一组球队年复一年地在阶梯的底部徘徊。尽管如此，在与足球迷的交谈中，我感觉到一些球队获得了常年赢家或输家的名声，而这些看法很难改变。这有可能影响 oddsmakers 如何对待不同的球队，将预测建立在声誉而不是实际表现的基础上。
Team win rate vs predicted win rate, sorted by difference between the two (predicted win rate — win rate)
正如胜率和预测胜率之间的百分比差异所表示的那样，似乎确实有一种倾向，即过分青睐有获胜记录的球队(山楂，悉尼)，而不太看好有失败记录的球队(布里斯班，黄金海岸)。
团队胜率与赔率制定者倾向于过分偏爱好团队而不偏爱坏团队之间的关系是存在的，但并不明显。此外，支持好团队的偏见，像其他被检查的偏见一样，对下注赔率的准确性没有太大影响，因为高准确性和低准确性在具有不同预测误差值的团队中传播。然而，似乎确实有一种模式，好的和坏的团队与高投注准确性相关联，而平庸的团队与低准确性相关联。
它有些嘈杂，但上面的图表明，oddsmakers 在预测坏队和好队的结果方面有些更好，但对那些赢了 40%到 60%比赛的平庸球队来说就有麻烦了。当预测势均力敌的比赛结果时，这种趋势符合下注赔率不太准确的一般模式。虽然我能理解在尝试与那些能够在一周击败顶级球队，而在下一周输给垫底球队的中游球队比赛时的挫败感，但这并不是一个非常有趣的观察结果。在势均力敌的比赛中翻牌是很难的一部分，但你需要做好这些才能有机会赢得底池。
最后
在这里探讨的简单试探法中，基于大量数据输入的试探法往往更好地预测 AFL 比赛结果，其中博彩赔率是最准确的预测因素。从不同的维度来分析比赛，显示出博彩公司在预测赢家和输家的能力上存在一些偏差和弱点。下注赔率往往会放大关于促成胜利的因素的传统智慧，有利于以高于胜率保证的比率从这些因素中受益的团队。然而，这些偏差对博彩赔率的表现几乎没有影响，较低的准确性通常集中在接近的比赛上，无论一个人的方法的质量和复杂程度如何，都很难预测。模型可以利用的一个轻微的弱点是，当下注赔率违背传统智慧，偏向排名较低和/或客场球队时，下注赔率的准确性会受到影响。
我没有提到的一个重要方面是时间。AFL 比赛数据可以按球队或主场对客场或高排名对低排名进行汇总，但它们代表的是按顺序发生的离散事件，过去的比赛不仅影响未来的比赛，而且球队在球场上的表现趋势会影响关于下周谁将获胜的传统观点，这反过来会影响下周比赛的投注赔率。然而，时间是一个很大的主题，所以我将在下一篇文章中深入探讨。
将数据运用到个人理财中
安泰米斯集团利用人力和金融资本，在充满活力的市场中为高潜力的创始人寻找机会，投资于这个交叉领域。
New York City at Night (NASA)
简介
T 交易数据和分析数据的技术为改善个人财务决策提供了一个强大的机会。好处远远超出了财务健康，影响到身体和精神健康。此外，利用这些数据可能是将个人银行业务模式与个人结果相结合的重要催化剂。
本文探讨了两个概念:
1) 基于交易数据的解决方案，使账户持有人能够做出更好的消费决策
2) 一种衡量此类解决方案对银行和最终用户价值的方法
思维实验
考虑一下…现在是 2020 年。当你起床查看手机时，你会收到银行新应用的一些通知。
早上好，莎拉，
没有超越您的目标的荣誉 : 根据您本月设定的 1 个月目标和您的相关“回报率”，我们在 ASOS 冻结了您的卡。您不必退回这些鞋子，节省了 7.99 美元的运费和 45 分钟的免费时间:)
提醒:根据您的健康目标设定，我们在所有快餐店维护您的信用卡。好消息:你离“Chopt”的免费沙拉只差一份了
节省费用:根据您前五年的航班预订情况，您通常会在 12 月 23 日至 12 月 26 日之间从纽约飞往芝加哥。下周预计是为这次旅行购买机票的最佳时间。我们可以在下周发送另一个提醒，但它们本周为 250 美元，预计下周将降至 225 美元。现在买还是等？
现在是 2022 年
$$$储蓄:你每年最大的支出是住房。如您所知，我们密切关注您所在社区的价格，以确保您获得公平的市场价格。根据你的账户注册，在过去的 6 个月里，你所在的巴特西区的一居室公寓价格下跌了 20%。您目前支付的金额似乎过高。如果可能的话，我们建议进行重新谈判。如果你愿意，我们可以促进谈话。只需向我们提供管理代理的详细信息。
你怎么想呢?
太疯狂了。我不希望我的银行做这些事情。
或者‘有道理’。几个这样的会很酷。可能吗？“这怎么可能行得通，”
我们认为，发现不健康的购买模式、不必要的费用、储蓄选项或未能坚持目标本身是有帮助的，但在不影响结果的情况下，它们真的有多大吸引力？银行和其他金融机构拥有几十年来客户的详细交易记录。因此，这些机构完全有能力产生影响，尽管开放银行业加速了这一环境，并带来了更多的挑战。数据科学形式的技术足够复杂，可以识别上述每一种模式，行为科学通过推动取得了显著的成果。
认识和确定消费模式仅仅是开始，在这个阶段我们的问题比答案多。然而，我们的研究发现了趋同趋势和 60 多家在该领域开展业务的早期公司——从聊天机器人到分类引擎，从机器人顾问的数字忠诚度，到短期贷款人和数据使能器的挑战者银行。根据这一分析，很明显，数据优先、自下而上的方法可以改善支出决策。然而，在剥离这些层面时，消费者的价值主张比零售银行更明显。因此，我们将这篇文章集中在四个主题上:
教育和适应消费者:从 TransferWise 中学习
不断变化的市场条件和客户期望
监管的作用
为什么时机合适，衡量什么有用？
教育消费者并与消费者保持一致:从 TRANSFERWISE 中学习
七年前，TransferWise 带着一个新颖的想法进入外汇交易市场:大规模削弱竞争对手，并教育市场。他们的 100 多万客户群获得了极具竞争力的外汇汇率和最低的交易费用，从而获得了很高的客户满意度和保留率。许多银行注意到了 TransferWise 的成功(参考桑坦德银行内部备忘录[1])，但选择了等待和观望的方法，含蓄地打赌客户不会注意到，或者更糟的是，会注意到而不会接受更低成本的替代方案。
transfer wise 的客户平均年龄为 30 岁，它的产品预示着消费者行为的转变和不断变化的银行业预期。【2】
Figure 1: Comparison of TransferWise Fees to Leading UK Banks*[3]**(Eurozone Transfer £1k & £10k)*.
通过提供透明度，以转移方式建立信任；通过帮助提高金融知识，培养客户的信心；而且，通过提供低成本产品，确保了客户增长，增加了企业和用户的价值。TransferWise 的崛起反映了以客户为导向的方法的可行性和实现的潜力。货币化和保留的新方法表明，传统的终身客户价值模型与最终客户一致。这是一个为客户直接创造价值的独特机会，而不是以零和形式产生费用，如透支。高盛(Goldman Sachs)收购 Clarity Money(T1)并投资抵押贷款转换和经纪公司(mortgage switcher and broker)，truss le(T3)以及摩根大通(JPMorgan)最近宣布推出免费应用程序You-Invest(T5)与 robin hood(T7)竞争，突显了这一趋势。
不断变化的市场条件和客户期望
如果你想说服别人，就诉诸兴趣，而不是理性- 本·富兰克林
银行理所当然地强调个人活期账户(PCA)持有者的低转换率。他们还指出，挑战者账户主要由二级账户持有人组成。然而，在当今的动态环境中，这些比率似乎具有误导性。
从一个主要提供非数字化、类似商品的产品的时代转向一个竞争加剧、产品差异化和监管支持的数字化时代，意味着方向性的改变即将到来。
从 NPS 得分来看，客户对金融机构越来越警惕。尽管这一指标本身正在调整，但市场情绪依然存在。在某种程度上，这导致好奇的客户尝试竞争对手的“增值”创新功能，例如:
- 控制/限制
- 自动分类
- 数字收据
- 照片账单支付
- 无期货交易费用
- 不收自动取款机费用
- 增加获得以前机构产品的机会
- 消费忠诚度/奖励
- 高收益利息
- 弹性透支
- 自动帐户/服务切换
- 替代贷款
- 四舍五入储蓄
因此，包含上述组件的解决方案正在成为标准。杰夫·贝索斯通过描述亚马逊的第一天，提供了一种描述这一演变的有用方式。
Figure 2. Day 1 at Amazon
从本质上讲，未能关注客户的公司和产品为亚马逊(和其他公司)打开了尝试的大门。这是一个相当简单的策略:通过测量来持续改进附加值和用户体验。这意味着从客户的角度出发并相应地设定绩效指标。此外，更具体地说，与经常账户相关，EY 发现，对于考虑纯数字、非银行提供商的客户来说，获得不同产品和服务以及客户体验的要素仅次于更具吸引力的费率/费用。[4]
Figure 3: Online Experience, Products and Services Combine to Lead*[5]*
这项研究强调了明确的市场趋势，研究还在继续。要点是，数据可用性、竞争对手的发展势头以及新的法规为测试和创建符合客户需求的解决方案提供了丰富的环境。
调控的作用
我们正在密切关注对未安排透支的提议变更(正在接受 FCA 的审查)。这为构建数据驱动的系统、解决客户需求以及与客户保持一致提供了及时的机会。
银行拥有帮助客户避免透支费用的数据，但使用这些数据需要改变方法，因为他们以前从这些费用中获得的收入超过了 PCA 的收入。
Figure 4: Analysis of UK PCA Value to Bank (£ per main PCA customer per year)[6],[7]
然而，在与数据科学家和银行家交谈时，分析消费行为是困难的。不完整的数据、行为上的关联、数据的不当使用，更不用说集成了，都会造成严重的障碍。除了建立信任，消费者的脆弱性也是一个问题。谁在关注弱势客户？在这一领域，监管变得越来越严格，但更值得注意的是，商业模式应该是限制性的，或者基于对客户的附加值。示例:
在对您的历史数据进行回溯测试后，我们创建了您定制的账户储蓄引擎。如果您选择使用这项服务，每年平均可节省 104 个小时和 138 美元。我们根据结果收费。
为什么时机合适，衡量什么有用？
“对我最大的赞美就是有人问我的想法，并注意听我的回答。”——亨利·大卫·梭罗
Figure. 5. Monzo and Revolut take a customer first approach[8]
简而言之，“把客户放在第一位”，市场指标，新的监管，受过教育，但脆弱的客户期望不同。大型银行对此时刻保持警惕，并积极努力更好地利用客户数据，在某些情况下，建立自己的解决方案。然而，在数据上实现技术，建立一个“酷”的市场验证产品，不受利益竞争的影响，以及吸引合适的人才是重大的内部障碍。
根据上面强调的发展趋势，我们研究了替代银行解决方案，如 Monese、Revolut、N26、Monzo、Chime、“包容性金融服务提供商”支付宝和收益率为 4%的田弘余额宝货币市场基金。
Figure 6: Revolut — 1.5m+ customers inside 3 years*[9][10]*
Figure 7: Yu’e Bao — $260b+ AUM in 5 years*[11]*
客户价值可能不等于企业价值，但价值肯定能抓住用户的注意力。F/X 和高收益利息产品在上述公司中脱颖而出。精明的早期采纳者基于对价值主张的接近和了解而选择加入。这种“病毒式传播”依赖于客户对附加值的欣赏，以及在自己的网络中进行宣传或分享的意愿。在财务方面，TransferWise 认为增值比竞争对手的成本低 80-90%。注册一张卡后，Revolut 的基本服务是免费的。
这些结果纯粹以财务节约来衡量。就对用户的价值而言，还有什么是重要的？节省的时间、与目标的一致性、理解、透明度和信心呢？搜索优惠券和交易节省的时间？追踪品牌忠诚度的价值？对谷歌或客服来说，提高了知识，减少了问题？更好地控制我们在哪里、什么时候和谁一起消费？改善个人消费模式的好处？这些因素能被实质性地衡量吗？
我们正在考虑几个假设:
- 我们可以识别客户数据中的模式，并主动或被动地使用它来改善支出结果(如下图所示)
Figure 8: Aligning Historical Spending Patterns with Desired Outcomes
- 每个人都处在消费健康谱的某个位置:无论是总体还是个人交易。
Figure 9: Spending Health Spectrum
我们感兴趣的东西
就财务健康而言，经常账户价值主张和有形客户价值之间存在脱节。帮助消费者做出更好的财务决策和结果的数据是可用的，但目前消费者并未以最佳方式利用这些数据。在金融机构遭受消费者情绪低落的关键时刻，向客户提供有意义的价值势在必行。市场上有明确的证据表明，这种方法可以提高客户参与度、评级、产品采用率和长期价值。
由于我们正处于发展我们的假设和为这一风险概念招募创始团队的早期阶段，我们已经分享了对市场信号和监管的研究和初步想法。我们寻求创始人和顾问来推动这一主张，以及银行合作伙伴进行合作。请提出意见和问题。
我在 安泰美丝集团 从事早期业务的市场识别、分析和开发工作，这里陈述的观点是我个人的观点。感谢 Kat，Archie，Dario，Leslie，SJ 和 Erica 的许多建议。
来源:[1]卫报 Money，2017 年 4 月[2]CBInsights，2017 年 6 月[3]Monito，2016 年 5 月[4]EY，2016 年[5]WSJ，穆迪，2018 年[6]Baringa，2016 年 1 月[7]FCA，2018 年 5 月[8]LinkedIn，2018 年[9]Revolut，2018 年 5 月[10]CBInsights，Tech.eu，2018 年[11]WSJ，穆迪
走向再现性:平衡隐私和出版
在数据安全和研究披露之间的冲突中，会有一个金发女孩的选择吗？
Photo by Shiva Smith on Pexels.
数据科学是一个高度跨学科的领域，在学术/行业分界线的两侧(以及两者之间的任何地方)都呈爆炸式增长。这导致了从业者背景和哲学方面惊人的多样性，该领域的多样性转化为数据科学和高级分析组织的观点和政策的多样性。一些组织，无论是在学术界还是工业界，都有非常“学术”的天赋，领导者鼓励开发新颖的模型和方法，然后发布这些方法并参加会议。相反，其他小组则专注于根据行业标准按时创建可销售的数据产品，同时受到 NDAs 和其他数据的限制，而不太关注理论上的新颖性。大多数组织在这两者之间寻求某种程度的平衡，但是找到平衡点通常需要仔细考虑技术和组织的需求和目标。
这些理念和环境的差异将数据科学领域分割成了基于数据和模型可用性的万花筒般的子集，这使得在不同环境之间转化发现变得非常困难。多种多样的软件许可、知识产权保护以及隐私和安全保障会使复制，更不用说再现性，成为一个重大挑战。然而，所有持久的职业，无论多么隐秘，都有一个共同点:从业者能够以有意义和富有成效的方式相互分享信息和最佳实践。
建立强大的专业环境的唯一方法是让数据科学家能够相互分享问题和解决方案，因为没有人知道所有的答案。在许多前沿模型和大型数据集有访问限制的领域中，这可能是极其困难的。然而，其他领域已经克服了类似的挑战，数据科学越早从其前辈和相关领域获得灵感，就越早能够在信息共享方面制定严格的标准。
但在此之前，我们必须先看看这个领域的现状。
GNU, from the Free Software Foundation
寄养合作
自由和开放源码软件(FOSS)也许是软件可用性的最自由的方法之一。在这种情况下，开源意味着一个项目的代码库可以公开地被检查、修改和分发，而自由(就像“解放的”，而不是“极其便宜的”)意味着你可以用你可以访问的软件做任何你想做的事情。自由和开放源码软件有各种各样的模式，其中许多模式在什么是自由和什么是开放源码以及一个给定的软件是一个、两个还是两个都不是之间做出了令人困惑的区分。想到这一点最简单的方法是使用理查德·斯托尔曼对 4 种软件自由的定义:以你喜欢的方式运行程序的自由，研究和修改程序的自由，重新发布程序的自由，以及发布程序修改副本的自由。
这种类型的模型，或者非常类似的东西，是学术软件的默认设置。大多数出版的学术著作都与某种公开可用的代码库相关，其中最常见的是 GitHub 。但是这个模型很少提到可及性的负担，而且这些已经成为学术界所有领域的共同问题，不仅仅是计算领域的问题。换句话说，坚持自由/开源软件概念的规则是一回事，但坚持其原则又是另一回事。出版物禁运、员工超负荷工作、服务器停机、IT 规则和政策，甚至补丁和更新等因素都会使在有意义的时间范围内重现或复制过去的实验变得困难。这些可访问性障碍并不总是恶意的，甚至不是有意的，但它们仍然是实践的一个重大障碍。
在云计算的推动下，数据科学中的许多挑战已经减少。用电子邮件发送大量 zip 文件的日子已经一去不复返了。如果你在这个领域工作的时间够长的话，你可能还记得有一段时间你不得不将数据或软件刻录到 CD 上或加载到硬盘上，然后将整个东西邮寄给合作者。但是，尽管越来越多的人采用基于云的服务，仍然有一些负担需要解决。最重要的是，“云”实际上只是“其他人的硬件”的一个新术语，在其他人的系统上存储数据和工作通常是有成本的，无论是名义上的还是财务上的，或者两者兼而有之。理想情况下，研究产生的软件和模型都将成为免费访问的 Github 库(或类似库)的一部分。很多都是。然而，Github 仍然是一家私人公司，不管那里有多少模型或软件包，在它或任何其他平台上发布数据都有自己的问题。
因为数据科学不仅仅是软件和代码。它还与从软件中产生模型所用的数据有关，这就是问题所在。我们不能总是使用公开可用的数据集来回答每个数据科学问题，试图这样做限制了我们探索现实生活现象的能力。我们不能总是公开我们的数据。
Photo by Steve Johnson on Pexels.
受限访问
虽然自由/开源软件看起来是一个适用于大多数研究软件的美好理想，但是自由/开源软件的概念并不总是适用于数据科学的每一个方面，尤其是在数据共享方面。适用于我们领域的一些最大的数据仓库必然有访问限制。这可能是由于各种各样的原因，但最常见的是隐私和安全。无论我们喜欢与否，这两种力量都不可避免地与数据科学的实践联系在一起。
世界上大多数最大的数据集都由公司持有，对于这些公司来说，数据是其主要的(如果不是唯一的)产品或市场竞争优势。类似地，数据科学最成熟的领域之一，医学数据科学/信息学，有一系列广泛的数据隐私和同意法律，并且有充分的理由。其他不断发展的领域，如运营和制造数据科学，使用的数据可能会揭示关键的业务实践，甚至在关键基础设施的情况下会产生国家安全后果。
这些挑战甚至可以进一步延伸到模型共享，尤其是随着“对抗性数据科学”领域的发展。根据系统的不同，如果你可以访问 API 或类似的接口，就有可能攻击机器学习和深度学习工具来提取模型信息，甚至推断数据集成员关系。这些信息可能足以让坏人造成严重伤害。由于这些重大的安全威胁，许多团体在最小化对他们的模型和数据的访问方面有既得利益。由于披露的不可逆转性，这一点尤其重要。数据集一旦公开发布，就几乎不可能再保护它，而且没有人知道该数据集以后会被用来做什么。
在隐私方面，通常有关于数据隐私和可用性的非常严格的法规和法律。 HIPAA ，一套在美国保护健康信息披露的复杂规则和条例，是这种不断增长的法规体系的典型例子。随着健康信息和数据科学中新趋势的发现，HIPAA 规则也在不断更新，许多机构现在都有广泛的办公室和培训计划，致力于维护 HIPAA 合规性。
GDPR 是一个更近的例子，一般隐私法规正变得越来越广泛，越来越具有技术意识。作为这些法规有多么重要的一个例子，想一想由于 GDPR 法案的生效，您收到了多少服务条款更新电子邮件。这只是一个地区的一个监管框架。
这些规则和法规是保护公民和组织个人隐私和安全的强大力量，但它们的要求也增加了数据科学家对监管意识的需求，这在我们年轻的领域中有时会被忽视。对于数据科学家来说，重要的是理解并接受这些规定的原因，并找到在规定范围内工作的方法，以免我们成为害群之马。虽然哀叹隐私和安全在我们领域的负担可能很诱人，但整合这些安全措施的强大道德立场将极大地促进我们作为一个领域的未来成功。
平衡再现性、安全性和隐私性
数据科学的许多子领域正迅速走向严重的社会和监管障碍。在过去几年中，违规和道德上有问题的使用案例对数据科学这一领域以及我们许多人每天处理的数据的性质产生了负面影响。数据科学的“狂野西部”时代即将结束，这意味着我们需要超越“新算法、相同数据”和“相同算法、新数据”的范式。我们一些最强大的算法已经以意想不到的方式被公开利用，关于一些数据集中包含多少个人信息的更广泛披露让许多公众感到不安。
至此，数据科学已经到了它的“青春期”。仍然存在严重不足的主题，迫切需要新方法和新数据来解决根本问题，但我们也需要共同扩大我们的工作，以公平地讨论和研究数据可用性以及如何在数据可用性与安全性之间取得平衡。
大多数数据科学研究的核心是人类主体研究。我们大多数人都努力尽可能地去识别我们发表的研究的主题，但我们必须仔细区分安全性(在这种情况下，身份检索是不可能的)和模糊性(在这种情况下，身份检索简直令人讨厌)。我们还必须认识到，在许多情况下，由于新的研究和技术会随着时间的推移将强有力的安全措施转变为弱模糊，安全措施很容易被削弱。
一个值得深入研究的有前途的数据安全方法是差分隐私。从本质上讲，差异隐私是一种在披露前用某种程度的统计不确定性“掺杂”原始数据的方式。然而，正如我们大多数人所知，有了足够大的数据集或足够的系统访问，许多类型的统计不确定性可以被建模和抽象掉。关于一个人在一天中的位置的一个不可靠的数据点可能相对难以验证。连续 100 天内关于一个人位置的 100 个不可靠的数据点远没有那么安全。这只是数据安全措施可能成为相对较弱的数据混淆措施的一个例子。仅仅将隐私注入数据点是不够的。我们还必须考虑受试者或数据集的终生“隐私预算”，而差异隐私的隐私预算难题尚未得到可靠解决。
尽管如此，在这一点上，差分隐私是我们拥有的最好的可扩展选项之一。因此，差分隐私已经被几个主要的基于数据的组织采用，包括苹果、谷歌和美国人口普查，其中每个组织对不确定性注入和隐私预算都有不同的方法。这些方法没有一个是完美的，但是这些实现导致了对它们的优点和缺点的重要研究。
美国人口普查实际上在技术和监管领域都处于数据隐私和安全的前沿。他们甚至开发了一个经济模型来判断如何管理隐私和准确性之间的平衡。虽然这种方法可能不是最佳解决方案，但它是朝着正确方向迈出的重要一步，评估和管理隐私预算和数据准确性的方法可能会继续发展。
不幸的是，尽管在公开期间对维护数据隐私的方法有很大的努力和兴趣，但在数据科学中很少有可用的方法来建模或算法隐私。这可能会让许多团体，尤其是私人数据公司，不愿分享他们在该领域通常具有开创性的工作。开源和开放获取显然可以有效地进行披露，但对于许多企业研究人员来说，如果允许的话，它们往往只是有选择地实施。迫切需要关于模型和方法披露的新的商业(和研究)伦理，特别是在与数据披露相结合时。我们如何评价一种新的建模方法？我们如何预测我们方法的新用例？我们甚至应该在披露决策中考虑估值吗？这些问题并不容易回答，而且在这一领域工作的数据科学家相对较少，使得这些问题变得更加难以回答。
随着我们领域的发展，这种类型的“元数据科学”工作将变得越来越重要。数据和模型的可用性对该领域的发展至关重要，但随着我们的工作变得更加可见和公开，我们需要不断评估和实施我们的道德披露政策。在数据科学中，我们有一个个人隐私、企业安全和公共利益的多种道德模式相互碰撞的领域，将这些道德整合成一个单一、统一的整体，平衡最大允许披露水平和最高安全水平将需要大量工作。
走向再现性
迈向再现性是一个正在进行的系列文章，讨论数据科学和机器学习中再现性的当前挑战和潜在解决方案。每篇文章都聚焦于推动数据科学中 再现性危机的主要因素之一 。
走向防御性数据科学宣言
数据科学家的世界你一无所获，却收获了更多的客户
我是一个非常糟糕的壁球运动员，但在一个短暂的时期内，当一个对手告诉我如何防守时，我成为了一个稍微更好的壁球运动员——而不是每次击球时都试图击出致胜球或吊球，稳定而深入地回击，以便我的对手最终更接近他们的后角，最终犯下错误。事实证明，遵循这一策略，我可以比全力以赴打好每一杆时赢得更多的分数。更好的是，在前两个点打完之后，我并没有因为跑来跑去而筋疲力尽——直到第四个点打了一半才停下来。
数据科学有一点相同，因为人们经常试图用最精彩的镜头赢得每一分，而不是通过应用正确的工具，更不用说通过应用允许他们花费最少努力的正确工具。
合适的工具会更容易实现，更容易理解，更容易交流。它将使用较少的计算能力来计算其结果。防御数据的本质在于算法的经济性。
为了最新的事物而避开它的理由很容易被发现。最显而易见的是，在一种方法是尖端的和它难以实现之间有一种直观的关联。有些时候，这是因为方法本身就很复杂。在其他时候，这将是由于该方法缺乏成熟的现成解决方案(否则它不会是“前沿”)，所以需要做更多的工作来形成什么是可用的，以满足您的应用程序的特定需求。
这里有比投入不必要的努力更多的风险——尽管新乡重夫会告诉你那已经够糟了。算法最简单的模型是最容易被顾客和客户接受的，可信的模型是最能赢得人心的。一个算法存在的时间越长，你的客户就越有可能见过它。越简单，他们就越有可能理解它，从而信任它。因此，你的发现可以传播给他人的观念是数据科学防御方法的主要目标之一。
比过于复杂的算法更不必要的是错误问题的解决方案。正如约翰·图基(John Tukey)所说，“对正确的问题给出一个大致的答案，这通常是模糊的，远比对错误问题给出一个精确的答案好得多，后者总是可以变得精确。”
发现正确问题的途径需要时间与客户一起了解他们的需求 —但是在这里花的时间越多，你越认真地试图理解问题背后的问题，解决方案就越有价值。
找到了解决客户问题的可行方案后，下一个重要步骤是找到向客户解释的最佳方式，除非他们不可能不理解，否则不能指望或相信他们会理解。正如谚语所说，数据科学家 80%的精力花在清理数据上，80%的精力也花在向需要理解数据的人解释最终结果上。
交流的可视化策略不同于发现的可视化策略。一个完整的解决方案必须包括允许客户自己发现的独特组件，以及确保客户正确理解您的发现的组件。因此，确保你的沟通不留任何侥幸心理是防御数据科学的另一个核心要点。
当然，不管你认为你知道多少，也不管你认为你的算法有多好，你出错的可能性仍然存在。一个防御性的数据科学家欢迎被证伪——不仅仅是因为道德含义。通过提出明确的案例，并用数据支持，防御性数据科学家确保主题专家可以提出有用的批评，并通过在发布前将模型暴露给这些人，最大限度地提高了在任何人受到影响之前发现错误的可能性。
李小龙信奉的哲学是“运动经济”——用最少的努力获得结果。当然，为了达到这种效果，李和他的学生刻苦训练，以完善他们的技术。实际上，他们在道场投入了最大的努力，特别是在打斗中尽量减少努力。防御性数据科学要求数据科学家付出努力来防止用户不必要的努力。
Raja Chatila 的抽象机器人理解
TWiML Talk 118
在这一集里，我们邀请到了 Raja Chatila，他是巴黎皮埃尔和玛丽·居里大学智能系统和机器人学主任，也是 IEEE 智能和自治系统伦理全球倡议的执行委员会主席。
订阅:iTunes/SoundCloud/Google Play/Stitcher/RSS
Raja 和我就他的研究聊得很开心，他的研究涉及机器人的感知和发现。我们讨论了学习和发现之间的关系，特别是当它应用于机器人及其环境时，以及机器人感知和行动之间的联系。我们还深入探讨了应用于智能系统的启示、抽象教导、元推理和自我意识的概念。最后，我们触及这些系统的价值和伦理问题。
和我一起参加人工智能峰会
你是一名需要在企业中广泛的机器学习和人工智能机会上变得聪明的 IT、技术或业务领导者吗？或者，也许你组织中的某个人可以从这方面的提升中受益？(或者，也许你会从他们的升级中受益！)如果这听起来像你或你认识的人，你可能会对我即将举行的人工智能峰会感兴趣。
把这个活动想象成一个为期两天的机器学习和人工智能的技术 MBA。你会清楚地了解:
机器学习和深度学习如何工作(不需要数学知识)
如何在您的组织中识别机器学习和深度学习的机会
如何理解和利用计算机视觉和自然语言处理等技术
如何管理和标记数据以利用 ML 和 AI
以及如何建立 AI 优先的文化，并在您的业务中实施 AI。
你将对整个人工智能和人工智能领域正在发生的事情有一个知情的观点，并将能够自信地与你的同事、客户和合作伙伴讨论机器学习和人工智能。我对这次活动和演讲者感到非常兴奋，你们将有机会向他们学习。欲了解更多信息，请访问twimlai.com/aisummit，如有疑问，请随时联系我。
关于 Raja
采访中提到
由李·罗斯韦尔创作的《以后再谈》，由 CC 4.0 授权
原载于 2018 年 3 月 12 日twimlai.com。
以深度认知迈向更轻松的深度学习生活
Deep Cognition 的深度学习工作室的新版本中出现了令人惊叹的新功能。你有深度学习模型但是你希望它在 TensorFlow 或者 MXNet？现在可以转换了！JupyterLab 已为您预先配置，H2O 现已作为预先配置的环境和新的集成功能提供给 Talend！
深度学习有趣又神奇。现在做深度学习非常容易，你有很多很好的框架和库、平台等等。但我认为改变游戏规则的是深度认知。
在他们的新版本中，他们为他们的深度学习工作室(DLS)添加了惊人的功能。顺便说一句，如果你想知道更多，就看看这个:
在过去的一个月里，我有幸见到了 DeepCognition.ai 的创始人
becominghuman.ai](https://becominghuman.ai/deep-learning-made-easy-with-deep-cognition-403fbe445351) [## 深度认知的视频漫游
大家好！在本文中，我将与您分享几个视频，带您浏览深度认知的平台…
towardsdatascience.com](/a-video-walkthrough-of-deep-cognition-fd0ca59d2f76)
要尝试我将向您展示的新功能，您需要下载最新版本的 DLS:
Deep Learning Studio - Desktop 是在您的硬件上本地运行的单用户解决方案。桌面版允许您…
deepcognition.ai](https://deepcognition.ai/products/desktop/)
提高不同深度学习框架之间的互操作性
深度学习工作室增加了一个功能，可以让用户将模型转换为 Tensorflow、Caffe、Keras2、MXNet、CNTK、Pytorch 或 ONNX。
你现在可以复制转换后的代码，并在喜欢的深度学习框架中使用它。
这太酷了，因为如果出于某种原因你需要创建 Pytorch 代码，但你只知道 Keras，现在你可以很容易地转换你的代码。
JupyterLab 现已在深度学习工作室内可用
如果你没有听说过，JupyterLab 是 Jupyter 项目的下一代用户界面。它提供了经典 Jupyter 笔记本的所有熟悉的构建模块(笔记本、终端、文本编辑器、文件浏览器、丰富输出等)。)在一个灵活而强大的用户界面中，可以通过第三方扩展进行扩展。
JupyterLab 是一个交互式开发环境，用于处理笔记本、代码和数据。最重要的是，JupyterLab 完全支持 Jupyter 笔记本。
JupyterLab 提供了笔记本、文档和活动之间的高度集成:
- 拖放以重新排列笔记本单元格，并在笔记本之间复制它们。
- 从文本文件(以交互方式运行代码块。py，。r，。md，。tex 等。).
- 将代码控制台链接到笔记本内核，以交互方式探索代码，而不会因为临时的临时工作而弄乱笔记本。
- 使用实时预览编辑流行的文件格式，如 Markdown、JSON、CSV、Vega、VegaLite 等。
JupyterLab 建立在一个扩展系统之上，该系统使您能够通过安装额外的扩展来自定义和增强 JupyterLab。
现在在 DLS 你可以看到:
H2O.ai 现已在 DLS 作为预配置环境提供
是的。朱庇特拉布的最后一张照片是对 H2O 的一个试探！现在也是 DLS 的一部分。
H2O 是用于大数据分析的开源软件。由 H2O.ai 公司生产。
如果你想了解如何利用 H2O 改变你作为一名数据科学家的生活，我建议你看看马修·丹乔与 R 合作的商业数据科学课程(你可以使用此优惠券代码享受八五折优惠！):
了解如何使用 H2O 自动机器学习和石灰黑盒模型解决现实世界中的员工流动问题…
大学.商业-科学. io](https://university.business-science.io/p/hr201-using-machine-learning-h2o-lime-to-predict-employee-turnover/?coupon_code=SAVE_15)
最后！
Talend Open Studio 现已在深度学习工作室内可用
Talend Open Studio 为跨公共云、私有云和混合云以及内部环境的数据集成提供了单一平台。
使用 Talend，您可以:
- 功能强大，易于使用。Talend Open Studio for Data Integration，您可以免费下载和使用，它提供了设计和执行各种数据集成流程所需的所有功能，例如数据迁移(包括 ETL 和 ELT)和数据同步。凭借基于 Eclipse 的图形开发环境、900 多个组件和内置数据连接器、统一的元数据存储库、Java 代码的自动生成和强大的 ETL 测试功能，基于订阅的 Talend Data Integration 通过专门为企业级项目设计的功能(如团队协作工具、工业级部署和实时负载平衡)补充了 Talend Open Studio 的数据集成功能。
- **成熟的性能。**Talend Open Studio for Data Integration 于 2006 年推出，迅速赢得了市场份额，拥有数百万次下载和数十万用户。Talend 数据集成平台企业版的用户数以千计，包括一些世界上最大的公司。
- **节省大量成本。**与劳动密集型定制开发或专有软件相比，Talend 的开源解决方案可大幅节省成本。与用于数据集成的免费 Talend Open Studio 相关的节省是显而易见的，但是即使是基于订阅的 Talend 数据集成，成本也明显低于专有技术。
- **活跃的社区。**围绕 Talend 数据集成和应用集成解决方案的社区非常活跃。一些社区应用程序可用于共享问题、建议和代码。
- 由塔伦德撑腰。Talend 应用一个主要的和正在进行的 R&D；努力维护和改进其开源产品。该供应商提供专业质量的用户文档和培训材料，并为那些需要它的人提供一流的技术支持和专业服务。
现在集成到 DLS，像一个开放的工作室 ETL。如果你想改善你的数据集成工作流程，这是必须的。
我真的认为 GUI 和 AutoML 是用深度学习完成事情的不远的将来。不要误解我，我喜欢编码，但是我认为我们明年要写的代码数量会减少。
我们不能花这么多时间在世界范围内一遍又一遍地编写相同的东西，所以我认为这两个特性(GUI 和 AutoML)将帮助数据科学家提高生产率和解决更多的问题。
下载新的 DLS，检查这个新功能，并与他人分享！
感谢你阅读这篇文章。我希望你在这里找到了一些有趣的东西:)如果你有问题，请在 Twitter 上关注我:
Favio Vázquez 的最新推文(@FavioVaz)。数据科学家。物理学家和计算工程师。我有一个…
twitter.com](https://twitter.com/faviovaz)
和 LinkedIn:
[## Favio Vázquez -首席数据科学家- OXXO | LinkedIn
查看 Favio Vázquez 在世界上最大的职业社区 LinkedIn 上的个人资料。Favio 有 17 个工作列在他们的…
www.linkedin.com](https://www.linkedin.com/in/faviovazquez/)
那里见:)
走向伦理机器学习
数据采集员道德责任探析
我辞掉了工作，加入了一个密集的数据科学训练营。我理解大量可用数据背后的价值，这些数据使我们能够创建预测性的机器学习算法。除了在专业层面上认识到它的价值，作为消费者，我也从这些技术中受益。每当我发现自己陷入音乐的窠臼时，我都会依赖 Spotify 的 Discover Weekly。我经常惊讶于 Spotify 的算法和其他机器学习模型如何如此准确地预测我的行为。事实上，当我第一次坐下来写这篇文章时，我停下来看了一段 Youtube 视频。20 分钟后，我意识到 Youtube 的推荐算法有多好。虽然我非常清楚地看到了机器学习的好处，但认识到并减轻其潜在的危险也是必不可少的。
虽然 Spotify 或 Youtube 推荐我不喜欢的歌曲或视频不会产生任何毁灭性的后果，但并非所有的机器学习算法都是如此。我第一次意识到机器学习的潜在后果是在我看到 Marshal Project 和 FiveThirtyEight 之间的合作时，他们讨论了机器学习在刑事司法系统中的使用。我认为机器学习只会给支离破碎的刑事司法系统带来好处。毕竟，美国占世界总人口的 5 %,却有世界 25%的被监禁人口。除了不成比例的监禁人口，美国的司法系统是建立在种族主义的警察和起诉，飙升的累犯率，以及对非暴力毒品罪犯过于严厉的惩罚。机器学习的引入难道不会对一个深陷危机的系统有所帮助吗？
虽然乍一看，机器学习似乎除了帮助美国破碎的刑事司法系统之外什么也做不了，但在阅读了更多关于正在实施的一些努力之后，我意识到谨慎行事至关重要。确定一个人被捕后的命运是机器学习被引入刑事司法系统的一种方式，它体现了依赖机器学习做出可能改变生活的决定的风险。
传统上，在一个人被逮捕后不久，法官就会面临一个困难的决定，即他们是否必须在监狱中等待出庭日期，这可能是几个月或几年，或者他们是否可以在家里等待出庭日期，有或没有限制。为了做出这一决定，法官必须分析被告，并且必须预测他们是否认为此人有逃跑的风险——如果被释放回家，此人将不会出庭受审，或者有犯下其他罪行的风险。
事实上，一个人被赋予做出可能改变生活的决定的权力是不公平的，并且为有偏见的决定留下了空间。随着机器学习的进步，已经引入了各种技术，试图消除法官的偏见，并基于数据而不是个人的唯一判断做出决定。这些技术通常被称为风险评估工具，由非营利组织和营利公司开发。劳拉和约翰·阿诺德基金会(LJAF)开发的公共安全评估(PSA)就是这些风险评估工具之一。PSA 使用历史数据，根据与未能出庭的风险和再次犯罪的风险相关的分数，标记那些被视为高风险的人。似乎利用基于历史数据的算法可以减少决定个人命运的偏差，而不是将全部决定权交给一个法官，但许多人发现这些风险评估加剧了他们试图消除的歧视性做法。
这些算法为模型特征分配分数，例如年龄、性别、收入、药物使用和以前的定罪。尽管 PSA 在 29 个城市和州使用，以及许多其他风险评估工具在全国范围内使用，但这些模型中使用的变量和权重的综合列表仍然是专有的，通常被称为“黑盒”。范德比尔特法学院刑事司法项目主任克里斯托弗·斯洛博金(Christopher Slobogin)表示，“风险评估应该是不被允许的，除非双方都能看到进入其中的所有数据。这应当是一个公开的、全面的对抗式诉讼程序。”如果我们想确保这些算法努力减少偏差，理解它们所基于的数据是很重要的。
这些风险评估的透明度是无价的，因此公众以及依靠他们做出决定的法官可以充分理解导致他们提出建议的途径，包括这些建议所依据的原始数据。毕竟，正如 IBM Research 指出的，“人工智能系统的好坏取决于我们输入的数据。不良数据可能包含隐含的种族、性别或意识形态偏见。许多人工智能系统将继续使用坏数据进行训练，使这成为一个持续存在的问题。但我们相信偏见可以被驯服，能够解决偏见的人工智能系统将是最成功的。”
作为数据科学家，我们必须认识到我们的道德责任，用无偏见的数据训练机器学习模型。出发点之一是允许透明度和制衡制度，以确保模型所基于的数据是公平和公正的。关于风险评估工具，理解所使用的数据是至关重要的，特别是考虑到困扰美国刑事司法系统的历史问题，如种族主义和对非暴力毒品犯罪的过于严厉的处理。我们必须理解这些数据，以便脱离这些偏见，而不是让它们永久化。
减少机器学习算法偏差的一个步骤是通过纽约大学 AI Now 研究所提出的算法影响评估(AIAs)。AIA 从“黑盒”方法导致恶性循环的想法延伸而来，不断远离对这些算法的理解，并削弱解决可能由此产生的任何问题的能力。AI 现在建议使用 AIAs 来处理公共领域中机器学习的使用，创建一套标准要求。通过 AIAs，AI 现在旨在通过公开列出和解释所使用的算法系统向公众提供清晰度，同时允许公众对这些系统提出争议，开发审计和评估流程，并提高公共机构理解他们所使用的系统的内部能力。
类似于使用 AIAs 来促进机器学习的透明度，国防高级研究计划局(DARPA)建议将可解释的人工智能(XAI)作为解决方案的一部分。如下图所示，XAI 致力于创造更多用户可以理解和信任的可解释模型。
虽然在 DARPA 的网站上似乎还没有对 XAI 的任何清晰、简明的描述，但他们表示，XAI 原型一直在进行测试，目标是在去年 11 月完成第一阶段的系统评估。在网站上，他们还表示，“在项目结束时，最终交付的将是一个工具包库，由机器学习和人机界面软件模块组成，可用于开发未来可解释的人工智能系统”
AIAs 和 XAI 只是组织朝着更道德、更透明的机器学习模型努力的两个例子。随着机器学习继续以爆炸式的速度增长，肯定会有更多的想法被引入，以确保这种监管。不管这些想法背后的具体细节如何，重要的是保持一个围绕机器学习模型的透明和理解的系统，在此期间，在机器学习过程的所有阶段都要仔细检查数据，以确保公平的做法，不会使偏见永久化。
来源:
马修·康伦、鲁本·菲舍尔-鲍姆和安迪·罗斯贝克的互动图形
www.themarshallproject.org](https://www.themarshallproject.org/2015/08/04/the-new-science-of-sentencing) [## 是否应该根据尚未犯下的罪行来判刑？
这个故事是与马歇尔计划合作制作的。长期以来，刑事判决都是基于…
fivethirtyeight.com](https://fivethirtyeight.com/features/prison-reform-risk-assessment/) [## 是的，美国的入狱率比其他任何国家都高
2015 年 7 月 7 日“一个严峻的事实是，美国的人口不到世界人口的 5 %,然而我们有…
www.washingtonpost.com](https://www.washingtonpost.com/news/fact-checker/wp/2015/07/07/yes-u-s-locks-people-up-at-a-higher-rate-than-any-other-country/?utm_term=.9de388bf6ac6) [## 用机器学习解决社会问题的指南
这是周日晚上。你是一个大城市的副市长。你坐下来看电影，向网飞寻求帮助…
hbr.org](https://hbr.org/2016/12/a-guide-to-solving-social-problems-with-machine-learning) [## 保释改革和风险评估:联邦判决的警示故事
从新泽西州到德克萨斯州，再到加利福尼亚州，全国各地都在讨论、实施和诉讼保释改革…
harvardlawreview.org](https://harvardlawreview.org/2018/02/bail-reform-and-risk-assessment-the-cautionary-tale-of-federal-sentencing/) [## 审前风险评估现已向所有感兴趣的司法管辖区开放；研究顾问委员会…
纽约-劳拉和约翰·阿诺德基金会(LJAF)正在扩大访问一套资源，将有助于…
www.arnoldfoundation.org](http://www.arnoldfoundation.org/laura-and-john-arnold-foundation-makes-pretrial-risk-assessment-available-to-all-jurisdictions-announces-expert-panel-to-serve-as-pretrial-research-advisory-board/) [## 算法风险评估和青年的双刃剑。
在判刑时，年轻可以被认为是一个减轻情节，因为它与减少…
papers.ssrn.com](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3225350) [## 人工智能和偏见- IBM 研究-美国
五年内，有偏见的人工智能系统和算法的数量将会增加。但是我们会相应地处理它们…
www.research.ibm.com](https://www.research.ibm.com/5-in-5/ai-and-bias/) [## 算法影响评估:走向公共机构的可问责自动化
2018 年 4 月 9 日更新:我们发布了一份新报告，完整描述了我们对算法影响评估的提议…
medium.com](https://medium.com/@AINowInstitute/algorithmic-impact-assessments-toward-accountable-automation-in-public-agencies-bd9856e6fdde) [## 爱现在研究所
纽约大学的人工智能研究所是一个跨学科的研究中心，致力于理解…
ainowinstitute.org](https://ainowinstitute.org/) [## 可解释的人工智能
图一。对可解释的人工智能在机器学习方面的巨大成功的需求导致了人工智能的洪流…
www.darpa.mil](https://www.darpa.mil/program/explainable-artificial-intelligence)
毒理学家，把这当成你的干预:打破我们对 P 值的依赖
同事们，我们有个问题。请坐下。这听起来不太容易。
我们被谎言所诱惑。我们的女妖:p 值。一场危机已经酝酿了好几年。这个谎言充斥着我们整个社会。我们已经说服自己，p 值是总结我们研究价值的最重要的值。我们培养了一代又一代的同事，让他们明白小于 0.05 的 p 值是对我们工作的认可。它根植于我们的价值观中——它根植于我们在药品、化学品和公共卫生方面做出决策的同事中。
问题:我们被一个关于 p 值的弥天大谎骗了。
我们中的一些人认为 p 值告诉我们研究的假阳性率(这根本不是真的)。我们社区中的其他人认为，p 值告诉我们，如果我们重复研究一百次，我们会看到与我们的研究一样大或更大的差异的概率。问题是，这两种观点都不正确。事实上，一个 p 值实际上是相当不同的。
假设零模型为真，p 值实际上是特定研究中数据与零模型拟合程度的度量。是的，我说的是模特。换句话说，如果您的数据不太符合零模型(同样，假设零模型是真的，它可能是也可能不是)，那么您将有一个小的 p 值(更接近于 0)。如果您的数据非常符合零模型，那么您将有一个非常大的 p 值(接近 1)。这就是问题所在。
我们被告知，如果我们有一个小的 p 值，特别是小于α值(通常α= 0.05)，那么我们可以拒绝零假设。不过，这实际上并不正确。“但是为什么呢？”你可能会问。
嗯，原来原因有点复杂。我会尽最大努力保持简单，但我不能做出任何承诺——这变得非常棘手。
失乐园
当罗纳德·费雪设计 p 值时，他只是为了一个目的:告诉我们一项研究是否应该重复。就是这样。这就是 p 值的数学基础。
然而，随着时间的推移，费舍尔的信息变得混乱。p 值成了一种统计学上的灵丹妙药——一种从那些没有信息的研究中识别“有价值”的研究的方法。这个想法变成了具有较大 p 值的研究价值较低——更可能是假阳性。人们开始接受费希尔的观点，并把它变得如此愚蠢，以至于 p 值失去了所有最初的意义。
p 值不是意味着我们需要重复一项研究，而是成为了一个看门人。它是期刊的看门人。这些期刊反过来成为了工作的守门人。在资源有限的环境中，期刊之间的竞争加剧，科学家之间对期刊有限页数的竞争加剧，研究复制的想法开始逐渐消失。
p-values 和 frequentist 方法的巨大吸引力在于，大多数毒理学家使用简单的软件就能轻松完成。GraphPad Prism 和其他易于使用的软件使得毒理学家能够轻松分析他们自己的数据。毒理学家现在可以生成他们自己的 p 值。这使得统计学家可以将他们的时间和精力集中在更复杂的问题上，并推进他们的研究领域。
当然，有时毒理学家没有把他们的研究设计和他们的分析方法很好地匹配起来。当然，有时毒理学家实际上并没有很好地设计他们的研究。这些都是期刊的同行审稿人会注意到的，对吗？对吗？
重返天堂
2016 年，美国统计协会发表了一份关于 p 值的声明。这一陈述的关键是重申 p 值确实告诉我们特定研究的数据与特定模型的吻合程度。通常，该模型是零假设。为了让 p 值起作用，我们假设零假设为真。它继续揭穿了围绕 p 值的几个神话。
ASA 还声明，科学界应该使用和探索 p 值的替代方法。包括我自己在内，有些人支持贝叶斯方法。
我喜欢贝叶斯方法的地方在于它们非常透明。在贝叶斯世界中，你通常关心的数字是后验概率——这只是某个事件的概率，考虑到你的研究证据以及该事件的先验证据。这不同于大多数毒理学家经常使用的方式。在频率主义者的方法中，你真的只关心零假设，然后是你的研究数据。
我从开始使用贝叶斯方法的人那里听到的一个担心是，他们不知道先验应该是什么。事实上，他们确信没有人做过他们正在做的事情。事实上，这可能是真的——也许你是唯一一个以前做过这项研究的人，它是 100%独一无二的。这很好——贝叶斯方法仍然有帮助。
先验概率是我们对事件发生的知识或信念的概括。我是一个现实主义者——我知道大多数毒理学家不会进行试点研究。我不会相信很多毒理学家会这么做。但是假设你做了一个初步研究。太好了，我们可以在先验中使用这些信息！也许你做了剂量发现或范围发现研究——最棒的是，我们也可以在我们的先验中使用它！
这是事情变得有趣的地方。如果您正在处理一个二元情况—活着/死了，头/尾，生病/好了，肿瘤/没有肿瘤—那么您可能会假设您的数据遵循伯努利分布。
等等——你可能会问，我为什么要说分销？这是因为在贝叶斯统计中，我们使用分布来封装我们的不确定性。如果我什么都不知道，除了我们正在处理一个二元情况，而你只有一个试点研究，那么我会说，“让我们做伯努利，因为这是一个合理的假设。”另一方面，如果你看伯努利，并决定它使用太多或太少的不确定性，我们总是可以看不同的分布，并适当地参数化它。
现在，如果我们没有进一步的信息会发生什么。我们有两条路可走——我们可以利用你作为毒理学家的培训、教育和经验，对先验知识做出有根据的猜测(我们通常会有某种偏见),或者我们可以直接说，“你知道吗，我完全不知道，所以让我们使用无信息先验知识。”一个非信息性的先验将最终整合为 1——所以在现实中，你的后验分布将完全由你的研究数据决定。大多数 Bayesians 人不喜欢使用无信息的先验知识——我不得不说，我在极少数情况下使用它们，我通常必须有一个非常好的理由，并且在我尝试之前对一个领域完全无知。说实话，你的前科可能会也可能不会对你的后验有很大影响——这真的取决于你带来的数据。
我们可以在贝叶斯世界中拟合各种模型。关心剂量反应？是的，我们可以分析一下。在乎一剂吗？是的，我们也能做到。但是这是最好的部分——我们可以开始问决策者需要答案的真正有意义的问题。比如，“如果一个人暴露在毫克/千克/天的乙基甲基有害物质中 70 年，他患癌症的概率是多少？”然后，“如果我们把 Q 毫克/千克-天改为 Q/10 毫克/千克-天，现在概率是多少。”这些是决策者关心的有意义的问题。
那是什么？你想在一个荟萃分析中整合多个研究——做贝叶斯分析时易如反掌。您将数据集链接在一起，使用先验知识作为您的先验，您的数据作为可能性，并计算后验。再简单不过了。
我们对后验是 100%透明的。我们说，“假设我们的模型是正确的，事件 E 的概率是 x%。”任何人都可以就你的模型的适当性与你争论——他们应该这么做。但是为了使辩论有意义，他们需要把他们自己的反模型带到辩论中来，让他们的模型与你的模型相对抗。你知道吗，谁赢了，谁就拥有最符合数据的模型。
最终，真正的赢家是科学。我不在乎我是否输掉了一场关于我的模型的有意义的辩论，因为我知道别人已经做出了一个更好的模型。最终，我们都赢了。我将了解更多关于更好的模型，使我成为一个更好的贝叶斯，科学界将有更好的数据和知识可用，最终，我们将停止谈论 p 值，并开始讨论在给定的一些情况下事件发生的概率。
真的，我们最关心的不是预测在给定的环境下，某个事件发生的概率吗？
Python 中的 TPOT 自动机器学习
TPOT graphic from the docs
在这篇文章中，我分享了我和 Python 中的自动机器学习(autoML)工具 TPOT 的一些探索。目标是看看 TPOT 能做什么，以及它是否值得成为你机器学习工作流程的一部分。
自动化机器学习不会取代数据科学家，(至少现在不会)，但它可能会帮助你更快地找到好的模型。TPOT 自称是你的数据科学助手。
TPOT 旨在成为一个助手，通过探索你可能从未考虑过的管道配置，给你提供如何解决特定机器学习问题的想法，然后将微调留给更受约束的参数调整技术，如网格搜索。
所以 TPOT 帮助你找到好的算法。请注意，它不是为自动化深度学习而设计的——类似 AutoKeras 的东西可能会有所帮助。
An example machine learning pipeline (source: TPOT docs)
TPOT 建立在 scikit learn 库的基础上，并严格遵循 scikit learn API。它可以用于回归和分类任务，并为医学研究提供特殊的实现。
TPOT 是开源的，有很好的文档记录，正在积极开发中。它的开发是由宾夕法尼亚大学的研究人员带头进行的。TPOT 似乎是最受欢迎的 autoML 库之一，截至 2018 年 8 月，有近4500 个 GitHub star。
TPOT 是如何工作的？
An example TPOT Pipeline (source: TPOT docs)
TPOT 拥有其开发者所称的遗传搜索算法来寻找最佳参数和模型集合。它也可以被认为是一种自然选择或进化算法。TPOT 尝试了一条流水线，评估了它的性能，并随机改变了流水线的某些部分，以寻找性能更好的算法。
AutoML 算法不像在数据集上拟合一个模型那么简单；他们正在考虑多种机器学习算法(随机森林、线性模型、支持向量机等。)在具有多个预处理步骤(缺失值插补、缩放、PCA、特征选择等)的流水线中。)，所有模型和预处理步骤的超参数，以及在流水线内集成或堆叠算法的多种方式。(来源:【TPOT 文档】 )
TPOT 的这种能力来自于自动高效地评估各种可能的管道。手动完成这项工作既麻烦又慢。
运行 TPOT
TPOT 分类器的实例化、拟合和评分类似于任何其他 sklearn 分类器。格式如下:
tpot = TPOTClassifier()
tpot.fit(X_train, y_train)
tpot.score(X_test, y_test)
TPOT 有自己的一键编码变体。注意，它可以自动将其添加到管道中，因为它将具有少于 10 个唯一值的特性视为分类特性。如果你想使用自己的编码策略，你可以对你的数据进行编码，然后再把它输入 TPOT。
您可以为 tpot.score 选择评分标准(尽管 Jupyter 和多处理器内核的一个 bug 使您无法在 Jupyter 笔记本中拥有一个多处理器内核的自定义评分标准)。
看来你不能改变 TPOT 在内部搜索最佳管道时使用的评分标准，只能改变 TPOT 选择最佳算法后在测试集上使用的评分标准。这是一些用户可能想要更多控制的领域。也许在未来的版本中会增加这个选项。
TPOT 使用 tpot.export()将有关最佳性能算法及其准确度分数的信息写入文件。您可以选择 TPOT 运行时希望看到的冗长程度，并让它在运行时将管道写入输出文件，以防由于某种原因提前终止(例如，您的 Kaggle 内核崩溃)。
TPOT 要跑多长时间？
简而言之，这要视情况而定。
TPOT 被设计为运行一段时间——几个小时甚至一天。尽管使用较小数据集的不太复杂的问题可以在几分钟内看到很好的结果。您可以调整 TPOT 的几个参数，以便更快地完成搜索，但代价是对最佳管道的搜索不够彻底。它并不是为了对预处理步骤、特性选择、算法和参数进行全面的搜索而设计的，但是如果您将它的参数设置得更详尽一些，它可能会更接近。
正如医生解释的那样:
…TPOT 将需要一段时间才能在较大的数据集上运行，但了解原因很重要。使用默认的 TPOT 设置(100 代，100 人口规模)，TPOT 将在完成前评估 10，000 个管道配置。为了将这个数字放入上下文中，考虑机器学习算法的 10，000 个超参数组合的网格搜索，以及该网格搜索需要多长时间。也就是说，有 10，000 个模型配置要用 10 重交叉验证来评估，这意味着在一次网格搜索中，大约有 100，000 个模型适合并评估了训练数据。
我们将在下面看到的一些数据集只需要几分钟就可以找到得分较高的算法；其他人可能需要几天。
以下是默认的 TPOTClassifier 参数:
generations=100,
population_size=100,
offspring_size=None # Jeff notes this gets set to population_size
mutation_rate=0.9,
crossover_rate=0.1,
scoring="Accuracy", # for Classification
cv=5,
subsample=1.0,
n_jobs=1,
max_time_mins=None,
max_eval_time_mins=5,
random_state=None,
config_dict=None,
warm_start=False,
memory=None,
periodic_checkpoint_folder=None,
early_stop=None
verbosity=0
disable_update_check=False
每个参数的描述可以在文档中找到。以下是几个决定 TPOT 将搜索的管道数量的关键因素:
**generations:** int, optional (default: 100)
Number of iterations to the run pipeline optimization process. Generally, TPOT will work better when you give it more generations(and therefore time) to optimize the pipeline. **TPOT will evaluate POPULATION_SIZE + GENERATIONS x OFFSPRING_SIZE pipelines in total** (emphasis mine).**population_size:** int, optional (default: 100)
Number of individuals to retain in the GP population every generation.
Generally, TPOT will work better when you give it more individuals (and therefore time) to optimize the pipeline. **offspring_size:** int, optional (default: None)
Number of offspring to produce in each GP generation.
By default, offspring_size = population_size.
从 TPOT 开始，设置 verbosity=3 和*periodic _ check point _ folder = " any _ string _ you _ like "*是值得的，这样你就可以看到模型的发展和训练分数的提高。当管道元素的一些组合不兼容时，您会看到一些错误，但是不要担心。
如果您正在多核上运行，并且没有使用自定义计分功能，请设置 n_jobs=-1 以使用所有可用的内核并加速 TPOT。
搜索空间
以下是 TPOT 从版本 0.9 开始选择的分类算法和参数:
‘sklearn.naive_bayes.**BernoulliNB**’: { ‘alpha’: [1e-3, 1e-2, 1e-1, 1., 10., 100.], ‘fit_prior’: [True, False] }, ‘sklearn.naive_bayes.**MultinomialNB**’: { ‘alpha’: [1e-3, 1e-2, 1e-1, 1., 10., 100.], ‘fit_prior’: [True, False] }, ‘sklearn.tree.**DecisionTreeClassifier**’: { ‘criterion’: [“gini”, “entropy”], ‘max_depth’: range(1, 11), ‘min_samples_split’: range(2, 21), ‘min_samples_leaf’: range(1, 21) }, ‘sklearn.ensemble.**ExtraTreesClassifier**’: { ‘n_estimators’: [100], ‘criterion’: [“gini”, “entropy”], ‘max_features’: np.arange(0.05, 1.01, 0.05), ‘min_samples_split’: range(2, 21), ‘min_samples_leaf’: range(1, 21), ‘bootstrap’: [True, False] },‘sklearn.ensemble.**RandomForestClassifier**’: { ‘n_estimators’: [100], ‘criterion’: [“gini”, “entropy”], ‘max_features’: np.arange(0.05, 1.01, 0.05), ‘min_samples_split’: range(2, 21), ‘min_samples_leaf’: range(1, 21), ‘bootstrap’: [True, False] }, ‘sklearn.ensemble.**GradientBoostingClassifier**’: { ‘n_estimators’: [100], ‘learning_rate’: [1e-3, 1e-2, 1e-1, 0.5, 1.], ‘max_depth’: range(1, 11), ‘min_samples_split’: range(2, 21), ‘min_samples_leaf’: range(1, 21), ‘subsample’: np.arange(0.05, 1.01, 0.05), ‘max_features’: np.arange(0.05, 1.01, 0.05) },‘sklearn.neighbors.**KNeighborsClassifier**’: { ‘n_neighbors’: range(1, 101), ‘weights’: [“uniform”, “distance”], ‘p’: [1, 2] }, ‘sklearn.svm.**LinearSVC**’: { ‘penalty’: [“l1”, “l2”], ‘loss’: [“hinge”, “squared_hinge”], ‘dual’: [True, False], ‘tol’: [1e-5, 1e-4, 1e-3, 1e-2, 1e-1], ‘C’: [1e-4, 1e-3, 1e-2, 1e-1, 0.5, 1., 5., 10., 15., 20., 25.] }, ‘sklearn.linear_model.**LogisticRegression**’: { ‘penalty’: [“l1”, “l2”], ‘C’: [1e-4, 1e-3, 1e-2, 1e-1, 0.5, 1., 5., 10., 15., 20., 25.], ‘dual’: [True, False] }, ‘xgboost.**XGBClassifier**’: { ‘n_estimators’: [100], ‘max_depth’: range(1, 11), ‘learning_rate’: [1e-3, 1e-2, 1e-1, 0.5, 1.], ‘subsample’: np.arange(0.05, 1.01, 0.05), ‘min_child_weight’: range(1, 21), ‘nthread’: [1] }
并且 TPOT 可以堆叠分类器，包括多次相同的分类器。TPOT 的核心开发者之一在本期中解释了它是如何工作的:
流水线
*ExtraTreesClassifier(ExtraTreesClassifier(input_matrix, True, 'entropy', 0.10000000000000001, 13, 6), True, 'gini', 0.75, 17, 4)*执行以下操作:使用提取树分类器拟合所有原始特征
从提取树分类器中获取预测，并使用这些预测创建新要素
将原始特征加上新的“预测特征”传递给第二个提取树分类器，并将其预测用作管道的最终预测
这个过程被称为堆叠分类器，这是机器学习中一种相当常见的策略。
这里是 TPOT 从 0.9 版本开始可以应用的 11 个预处理程序。
‘sklearn.preprocessing.**Binarizer**’: { ‘threshold’: np.arange(0.0, 1.01, 0.05) }, ‘sklearn.decomposition.**FastICA**’: { ‘tol’: np.arange(0.0, 1.01, 0.05) }, ‘sklearn.cluster.**FeatureAgglomeration**’: { ‘linkage’: [‘ward’, ‘complete’, ‘average’], ‘affinity’: [‘euclidean’, ‘l1’, ‘l2’, ‘manhattan’, ‘cosine’] }, ‘sklearn.preprocessing.**MaxAbsScaler**’: { }, ‘sklearn.preprocessing.**MinMaxScaler**’: { }, ‘sklearn.preprocessing.**Normalizer**’: { ‘norm’: [‘l1’, ‘l2’, ‘max’] }, ‘sklearn.kernel_approximation.**Nystroem**’: { ‘kernel’: [‘rbf’, ‘cosine’, ‘chi2’, ‘laplacian’, ‘polynomial’, ‘poly’, ‘linear’, ‘additive_chi2’, ‘sigmoid’], ‘gamma’: np.arange(0.0, 1.01, 0.05), ‘n_components’: range(1, 11) }, ‘sklearn.decomposition.**PCA**’: { ‘svd_solver’: [‘randomized’], ‘iterated_power’: range(1, 11) }, ‘sklearn.preprocessing.PolynomialFeatures’: { ‘degree’: [2], ‘include_bias’: [False], ‘interaction_only’: [False] }, ‘sklearn.kernel_approximation.**RBFSampler**’: { ‘gamma’: np.arange(0.0, 1.01, 0.05) }, ‘sklearn.preprocessing.RobustScaler’: { }, ‘sklearn.preprocessing.**StandardScaler**’: { }, ‘tpot.builtins.ZeroCount’: { }, ‘**tpot.builtins.OneHotEncoder**’: { ‘minimum_fraction’: [0.05, 0.1, 0.15, 0.2, 0.25], ‘sparse’: [False] } (emphasis mine)
这是一个非常全面的 sklearn ml 算法列表，甚至包括一些您可能没有用于预处理的算法，包括 Nystroem 和 RBFSampler。最后列出的预处理算法就是之前提到的自定义 OneHotEncoder。请注意，该列表不包含神经网络算法。
组合的数量几乎是无限的——您可以堆叠算法，包括相同算法的实例。管道中的步骤数量可能有一个内部上限，但可以说可能有太多的管道。
如果您运行 TPOT 两次，它可能不会导致相同的算法选择(我发现，即使设置了 random_state，也可能不会，如下所述)。正如文档所解释的:
如果您正在处理相当复杂的数据集或短时间运行 TPOT，不同的 TPOT 运行可能会产生不同的管道建议。TPOT 的优化算法在本质上是随机的，这意味着它使用随机性(部分)来搜索可能的管道空间。当两个 TPOT 运行推荐不同的管道时，这意味着 TPOT 运行由于缺少时间而没有收敛或多个管道在数据集上执行或多或少相同的操作。
少说多做。让我们用一些数据来检验一下 TPOT！
数据集 1: MNIST 数字分类
首先我们来看一个分类任务 sklearn 数据集中包含的来自 MNIST 的流行手写数字分类任务。MNIST 数据库包含 70，000 张 28x28 像素的手写阿拉伯数字图像，从 0 到 9。
TPOT 是 Kaggle Docker 镜像的标准配置，所以你只需要在使用 Kaggle 的时候导入它——你不需要安装它。
这是我的代码——可以在这个 Kaggle 内核上获得，形式略有不同，可能有一些修改。
# import the usual stuff
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import os# import TPOT and sklearn stuff
from tpot import TPOTClassifier
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
import sklearn.metrics# create train and test sets
digits = load_digits()
X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target, train_size=0.75, test_size=0.25, random_state=34)tpot = TPOTClassifier(verbosity=3,
scoring="balanced_accuracy",
random_state=23,
periodic_checkpoint_folder="tpot_mnst1.txt",
n_jobs=-1,
generations=10,
population_size=100)# run three iterations and time themfor x in range(3):
start_time = timeit.default_timer()
tpot.fit(X_train, y_train)
elapsed = timeit.default_timer() - start_time
times.append(elapsed)
winning_pipes.append(tpot.fitted_pipeline_)
scores.append(tpot.score(X_test, y_test))
tpot.export('tpot_mnist_pipeline.py')times = [time/60 for time in times]
print('Times:', times)
print('Scores:', scores)
print('Winning pipelines:', winning_pipes)
如上所述，管道总数等于人口 _ 大小+世代 x 后代 _ 大小。
例如，如果设置 population_size=20，generations=5，那么 subject _ size = 20(因为默认情况下 subject _ size 等于 population_size。因为 20 + (5 * 20 ) = 120，所以总共有 120 条管道。
您可以看到，运行这个数据集根本不需要太多代码——这包括一个计时和重复测试的循环。
有 10 个可能的类别，没有理由选择一个结果而不是另一个，准确性——TPOT 分类的默认——是这项任务的一个很好的衡量标准。
下面是相关的代码部分。
digits = load_digits()
X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target, train_size=0.75, test_size=0.25, random_state=34)tpot = TPOTClassifier(verbosity=3,
scoring=”accuracy”,
random_state=32,
periodic_checkpoint_folder=”tpot_results.txt”,
n_jobs=-1,
generations=5,
population_size=10,
early_stop=5)
结果如下:
Times: [4.740584810283326, 3.497970838083226, 3.4362493358499098]
Scores: [0.9733333333333334, 0.9644444444444444, 0.9666666666666667]Winning pipelines: [Pipeline(memory=None,
steps=[('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,
learning_rate=0.1, loss='deviance', max_depth=7,
max_features=0.15000000000000002, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
...auto', random_state=None,
subsample=0.9500000000000001, verbose=0, warm_start=False))]), Pipeline(memory=None,
steps=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True)), ('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,
learning_rate=0.5, loss='deviance', max_depth=2,
max_features=0.15000000000000002, max_leaf_...auto', random_state=None,
subsample=0.9500000000000001, verbose=0, warm_start=False))]), Pipeline(memory=None,
steps=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True)), ('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,
learning_rate=0.5, loss='deviance', max_depth=2,
max_features=0.15000000000000002, max_leaf_...auto', random_state=None,
subsample=0.9500000000000001, verbose=0, warm_start=False))])]
请注意，只有 60 个管道——远远少于 TPOT 建议的——我们能够看到相当好的分数——在一个案例中，测试集的准确率超过 97%。
再现性
TPOT 每次都用相同的 random_state 集合找到相同的获胜管道吗？不一定。像 RandomForrestClassifier()这样的算法都有自己的 random_state 参数，这些参数没有被设置。
如果你实例化一个分类器，然后像我们在上面代码中的 for 循环中所做的那样反复拟合，TPOT 并不总是找到相同的结果。我在 random_state 设置和 Kaggle 的 GPU 设置打开的情况下运行了三组非常小的 60 条管道。请注意，我们得到的管道略有不同，因此三个测试集的测试集得分也略有不同。
下面是另一个例子，有少量的管道设置了随机状态，并使用了 Kaggle 的 CPU 设置。
Times: [2.8874817832668973, 0.043678393283335025, 0.04388708711679404]
Scores: [0.9622222222222222, 0.9622222222222222, 0.9622222222222222]
Winning pipelines: [Pipeline(memory=None,
steps=[('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,
learning_rate=0.5, loss='deviance', max_depth=2,
max_features=0.15000000000000002, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
....9500000000000001, tol=0.0001,
validation_fraction=0.1, verbose=0, warm_start=False))]), Pipeline(memory=None,
steps=[('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,
learning_rate=0.5, loss='deviance', max_depth=2,
max_features=0.15000000000000002, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
....9500000000000001, tol=0.0001,
validation_fraction=0.1, verbose=0, warm_start=False))]), Pipeline(memory=None,
steps=[('gradientboostingclassifier', GradientBoostingClassifier(criterion='friedman_mse', init=None,
learning_rate=0.5, loss='deviance', max_depth=2,
max_features=0.15000000000000002, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
....9500000000000001, tol=0.0001,
validation_fraction=0.1, verbose=0, warm_start=False))])]
三次都发现了相同的管道。
注意，在第一次迭代之后，运行时间要快得多。TPOT 似乎确实记得它什么时候见过一个算法，并且不会重新运行它，即使它是第二次拟合，并且你已经设置了 memory=False。如果设置 verbosity=3，当它找到这样一个以前评估过的管道时，您将看到以下内容:
Pipeline encountered that has previously been evaluated during the optimization process. Using the score from the previous evaluation.
运行时间更长，精确度更高
如果制造大量管道，TPOT 怎么办？要真正看到 TPOT 在 MNIST 数字任务中的威力，你需要运行 500 多条管道。如果在 Kaggle 上运行，这至少需要一个小时。然后，您将看到更高的准确度分数，并可能看到更复杂的模型。
如果你有大量的管道和一项重要的任务，你可能会看到一个机器学习算法的输出进入另一个算法的链式或堆叠式集合。
0.9950861171999883knn = KNeighborsClassifier(
DecisionTreeClassifier(
OneHotEncoder(input_matrix, OneHotEncoder__minimum_fraction=0.15, OneHotEncoder__sparse=False),
DecisionTreeClassifier__criterion=gini,
DecisionTreeClassifier__max_depth=5,
DecisionTreeClassifier__min_samples_leaf=20,
DecisionTreeClassifier__min_samples_split=17),
KNeighborsClassifier__n_neighbors=1,
KNeighborsClassifier__p=2,
KNeighborsClassifier__weights=distance)
在运行了一个多小时并生成了 600 多条管道后，这是 0.995 的平均内部 CV 准确度分数。内核在完成之前崩溃了，所以我没有看到测试集的分数，也没有得到输出的模型，但是这对 TPOT 来说看起来很有希望。
该算法使用决策树分类器，将 TPOT 定制的 OneHotEncoder 分类编码输入 KNeighborsClassifier。
这是一个类似的内部分数，不同的管道来自于近 800 个管道后的一个不同的 random_state。
0.9903723557310828 KNeighborsClassifier(Normalizer(OneHotEncoder(RandomForestClassifier(MinMaxScaler(input_matrix), RandomForestClassifier__bootstrap=True, RandomForestClassifier__criterion=entropy, RandomForestClassifier__max_features=0.55, RandomForestClassifier__min_samples_leaf=6, RandomForestClassifier__min_samples_split=15, RandomForestClassifier__n_estimators=100), OneHotEncoder__minimum_fraction=0.2, OneHotEncoder__sparse=False), Normalizer__norm=max), KNeighborsClassifier__n_neighbors=4, KNeighborsClassifier__p=2, KNeighborsClassifier__weights=distance)
TPOT 发现了一个 KNN 管道，一个热编码，规范化和随机森林。花了两个半小时。前一个更快，得分更高，但有时这就是 TPOT 遗传搜索算法的随机性质。😉
MNIST 数字分类任务的要点
- 如果你给它足够的时间，TPOT 可以很好地完成这个图像识别任务。
- TPOT 管道越多越好。
- 如果你需要任务的再现性，TPOT 不是你想要的工具。
数据集 2:蘑菇分类
对于第二个数据集，我选择了流行的蘑菇分类任务。目标是根据标签正确确定蘑菇是否有毒。这不是图像分类任务。它被设置为一个二元任务，这样所有潜在危险的蘑菇被归为一类，而安全食用蘑菇则归为另一类。
Yummy or deadly? Ask TPOT.
我的代码可以在这个 Kaggle 内核上获得。
TPOT 通常可以在这个数据集上快速拟合出一个完美的模型。它在两分钟之内就完成了。这比我在没有 TPOT 的情况下使用许多 scikit-learn 分类算法、各种名义数据编码和无参数调整测试该数据集时的性能和速度好得多。
在使用相同的 TPOTClassifier 实例和相同的随机状态集的三次运行中，TPOT 发现了以下情况:
Times: [1.854785452616731, 1.5694829618000463, 1.3383520993001488]
Scores: [1.0, 1.0, 1.0]
有趣的是，它每次都找到不同的最佳算法。它找到了 DecisionTreeClassifier，然后是 KNeighorsClassifier，然后是带有 BernoulliNB 的堆叠 RandomForestClassifier。
让我们更深入地探讨一下可再现性。让我们用完全相同的设置再运行一次。
Times: [1.8664863013502326, 1.5520636909670429, 1.3386059726501116]
Scores: [1.0, 1.0, 1.0]
我们看到同一组三个管道，非常相似的时间，测试集上相同的分数。
现在让我们试着将这个单元分成多个不同的单元，并在每个单元中实例化一个 TPOT 实例。代码如下:
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.75, test_size=0.25, random_state=25)tpot = TPOTClassifier(
verbosity=3,
scoring=”accuracy”,
random_state=25,
periodic_checkpoint_folder=”tpot_mushroom_results.txt”,
n_jobs=-1,
generations=5,
population_size=10,
early_stop = 5
)
第二次运行的结果现在与第一次运行的结果相匹配，并且花费了几乎相同的时间(分数= 1.0，时间= 1.9 分钟，管道=决策树分类器)。更高再现性的关键是我们在每个单元中实例化 TPOT 分类器的一个新实例。
下面是 10 组 30 个流水线的时间结果，其中随机状态在训练测试分割上，TPOT 设置为 10。所有管道正确地对测试集上的所有蘑菇进行了分类。TPOT 在这项简单易学的任务上速度很快。
蘑菇任务的收获
对于这个基本的分类任务，TPOT 表现得又好又快。
作为比较，R 中蘑菇集上的这个 Kaggle 内核非常好，探索了各种算法，非常接近完美的精度。但是，它并没有完全达到 100%,与我们实施 TPOT 相比，它确实花费了更多的准备和培训时间。
我强烈认为 TPOT 可以为将来这样的任务节省时间，至少作为第一步。
数据集 3:埃姆斯住宅预测
接下来，我们转向回归任务，看看 TPOT 的表现。我们将使用流行的爱荷华州艾姆斯房价预测数据集来预测房产销售价值。我的代码可以在这个 Kaggle 内核上获得。
This house could be in Ames, Iowa, right?
对于这个任务，我首先做了一些基本的缺失值插补。我用该列中最常见的值来填充缺失的数字列值，因为其中一些列包含序号数据。随着时间的推移，我会对列进行分类，并根据区间、序数或名义数据类型使用不同的插补策略。
在顺序编码之前，字符串列缺失值用“缺失”标签填充，因为并非所有列都有最常见的值。TPOT 的 one hot 编码算法将为每个特征增加一个维度，这将表明该数据缺少该特征的值。
TPOTRegressor 默认使用均方误差评分。
这里有一个只有 60 条管道的运行。
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = .25, random_state = 33)# instantiate tpot
tpot = TPOTRegressor(verbosity=3,
random_state=25,
n_jobs=-1,
generations=5,
population_size=10,
early_stop = 5,
memory = None)
times = []
scores = []
winning_pipes = []# run 3 iterations
for x in range(3):
start_time = timeit.default_timer()
tpot.fit(X_train, y_train)
elapsed = timeit.default_timer() - start_time
times.append(elapsed)
winning_pipes.append(tpot.fitted_pipeline_)
scores.append(tpot.score(X_test, y_test))
tpot.export('tpot_ames.py')# output results
times = [time/60 for time in times]
print('Times:', times)
print('Scores:', scores)
print('Winning pipelines:', winning_pipes)
这三次小试的结果。
Times: [3.8920086714831994, 1.4063017464330188, 1.2469199204002508]
Scores: [-905092886.3009057, -922269561.2683483, -949881926.6436856]
Winning pipelines: [Pipeline(memory=None,
steps=[('zerocount', ZeroCount()), ('xgbregressor', XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,
max_depth=9, min_child_weight=18, missing=None, n_estimators=100,
n_jobs=1, nthread=1, objective='reg:linear', random_state=0,
reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=True, subsample=0.5))]), Pipeline(memory=None,
steps=[('xgbregressor', XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,
max_depth=9, min_child_weight=11, missing=None, n_estimators=100,
n_jobs=1, nthread=1, objective='reg:linear', random_state=0,
reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=True, subsample=0.5))]), Pipeline(memory=None,
steps=[('stackingestimator', StackingEstimator(estimator=RidgeCV(alphas=array([ 0.1, 1\. , 10\. ]), cv=None, fit_intercept=True,
gcv_mode=None, normalize=False, scoring=None, store_cv_values=False))), ('maxabsscaler-1', MaxAbsScaler(copy=True)), ('maxabsscaler-2', MaxAbsScaler(copy=True)), ('xgbr... reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=True, subsample=0.5))])]
运行很快完成，每次都找到不同的获胜管道。取分数的平方根得到均方根误差(RMSE)。RMSE 的平均价格在 3 万美元左右。
对于 train_test_split 和 TPOTRegressor，尝试使用 60 个管道和 random_state = 20。
Times: [9.691357856966594, 1.8972856383004304, 2.5272325469001466]
Scores: [-1061075530.3715296, -695536167.1288683, -783733389.9523941]Winning pipelines: [Pipeline(memory=None,
steps=[('stackingestimator-1', StackingEstimator(estimator=RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,
max_features=0.7000000000000001, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=12, min_sample...0.6000000000000001, tol=0.0001,
validation_fraction=0.1, verbose=0, warm_start=False))]), Pipeline(memory=None,
steps=[('xgbregressor', XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,
max_depth=7, min_child_weight=3, missing=None, n_estimators=100,
n_jobs=1, nthread=1, objective='reg:linear', random_state=0,
reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=True, subsample=1.0))]), Pipeline(memory=None,
steps=[('stackingestimator', StackingEstimator(estimator=RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,
max_features=0.7000000000000001, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=12, min_samples_...ators=100, n_jobs=None,
oob_score=False, random_state=None, verbose=0, warm_start=False))])]
导致了截然不同的管道和分数。
让我们用 720 条管道试一次更长的运行
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = .25, random_state = 20)tpot = TPOTRegressor(verbosity=3,
random_state=10,
#scoring=rmsle,
periodic_checkpoint_folder=”any_string”,
n_jobs=-1,
generations=8,
population_size=80,
early_stop=5)
结果:
Times: [43.206709423016584]
Scores: [-644910660.5815958]
Winning pipelines: [Pipeline(memory=None,
steps=[('xgbregressor', XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,
max_depth=8, min_child_weight=3, missing=None, n_estimators=100,
n_jobs=1, nthread=1, objective='reg:linear', random_state=0,
reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=True, subsample=0.8500000000000001))])]
RMSE 是迄今为止最好的。收敛花了大半个小时，我们仍然在运行比推荐的小得多的管道。🤔
接下来，让我们尝试使用均方根对数误差，这是 Kaggle 在本次比赛中使用的自定义评分参数。这是在另一个非常小的迭代中运行的，30 个管道分三次运行，random_state=20。我们不能使用一个以上的 CPU 核心，因为在 Jupyter 的一些 TPOT 算法中有一个自定义评分参数的错误。
Times: [1.6125734224997965, 1.2910610851162345, 0.9708147236000514]
Scores: [-0.15007242511943228, -0.14164770517342357, -0.15506057088945932]
Winning pipelines: [Pipeline(memory=None,
steps=[('maxabsscaler', MaxAbsScaler(copy=True)), ('stackingestimator', StackingEstimator(estimator=RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,
max_features=0.7000000000000001, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
...0.6000000000000001, tol=0.0001,
validation_fraction=0.1, verbose=0, warm_start=False))]), Pipeline(memory=None,
steps=[('extratreesregressor', ExtraTreesRegressor(bootstrap=False, criterion='mse', max_depth=None,
max_features=0.6500000000000001, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=7, min_samples_split=10,
min_weight_fraction_leaf=0.0, n_estimators=100, n_jobs=None,
oob_score=False, random_state=None, verbose=0, warm_start=False))]), Pipeline(memory=None,
steps=[('ridgecv', RidgeCV(alphas=array([ 0.1, 1\. , 10\. ]), cv=None, fit_intercept=True,
gcv_mode=None, normalize=False, scoring=None, store_cv_values=False))])]
那些分数并不可怕。这个小运行的 tpot.export 的输出文件如下。
import numpy as np
import pandas as pd
from sklearn.linear_model import ElasticNetCV, LassoLarsCV
from sklearn.model_selection import train_test_split from sklearn.pipeline import make_pipeline, make_union
from tpot.builtins import StackingEstimator # NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64) features = tpot_data.drop('target', axis=1).values training_features, testing_features, training_target, testing_target = train_test_split(features, tpot_data['target'].values, random_state=42) # Score on the training set was:-0.169929041242275 exported_pipeline = make_pipeline( StackingEstimator(estimator=LassoLarsCV(normalize=False)), ElasticNetCV(l1_ratio=0.75, tol=0.01) exported_pipeline.fit(training_features, training_target) results = exported_pipeline.predict(testing_features)
将来，我想在这个数据集上对 TPOT 做一些更长时间的运行，看看它的表现如何。我还想看看一些手动特征工程和各种编码策略如何提高我们的模型性能。
抓到 TPOT 和卡格尔了
我喜欢 Kaggle 的内核，但如果你想运行几个小时的算法，如 TPOT，这可能会超级令人沮丧。内核在运行时经常崩溃，你有时无法判断你尝试的提交是否被挂起，并且你不能像你希望的那样控制你的环境。
Wall for banging head
没有什么比 720 次管道迭代中的 700 次更好的了。我的 Kaggle CPU 利用率经常显示为 400%+并且在这个练习中需要多次重启。
其他一些需要注意的事项:
- 我发现我需要将我的 Pandas 数据帧转换成 Numpy 数组，以避免回归任务中的 XGBoost 问题。这是熊猫和 XGBoost 的一个已知问题。
- 一个 Kaggle 内核正在运行一个 Jupyter 笔记本。当 Jupyter 笔记本中的 n _ jobs > 1 时，TPOT 的自定义评分分类器不起作用。这是一个已知的问题。
- 当你提交代码时，Kaggle 只会让你的内核代码写到一个输出文件。你看不到 TPOT 提交时的临时输出。确保文件名用引号括起来，不要用斜线。该文件将显示在 O 输出选项卡上。
- 在 Kaggle 上打开 GPU 设置并不能加快大多数分析的速度，但可能会加快深度学习的速度。
- ka ggle 6 小时的可能运行时间和 GPU 设置使得在非大型数据集上无需配置即可免费实验 TPOT 成为可能。很难拒绝免费的。
为了更多的时间和速度，你可以使用类似于 Paperspace 的东西。我在 Paperspace 上建立了 TPOT，虽然不是免费的，但也很轻松。如果你需要一个云解决方案来运行 TPOT，我建议你先在 Kaggle 上使用它，如果你需要几个小时以上的运行时间或更高的功率，就离开 Kaggle。
未来方向
TPOT 和 autoML 有很多有趣的方向可以探索。我想将 TPOT 与 autoSKlearn、MLBox、Auto-Keras 和其他公司进行比较。我还想看看它在处理更多种类的数据、其他插补策略和其他编码策略时的表现。与 LightGBM、CatBoost 和深度学习算法的比较也将是有趣的。机器学习的这个时刻令人兴奋的是，有这么多领域可以探索。关注 me 确保不会错过未来的分析。
对于大多数数据集来说，仍然有大量的数据清理、特征工程和最终模型选择要做——更不用说预先提出正确问题这一最重要的步骤。那么你可能需要生产你的模型。TPOT 还没有进行彻底的搜索。所以 TPOT 不会取代数据科学家的角色——但这个工具可能会让你最终的机器学习算法更好更快。
如果你使用过 TPOT 或其他 autoML 工具，请在评论中分享你的经验。
我希望这篇介绍 TPOT 的文章对你有所帮助。如果你有，请在你最喜欢的社交媒体上分享，这样其他人也可以找到它。😀
我写关于 Python 、 SQL 和其他技术主题的文章。如果你对这些感兴趣，请注册我的邮件列表，那里有很棒的数据科学资源，点击阅读更多内容，帮助你提高技能。👍
投票快乐！🚀
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
