数据科学转移
2017 年 4 月 21 日
如果您喜欢像这样的内容每周出现在您的收件箱中，请注意这是数据科学社区时事通讯的一部分。报名 这里 。
Street art by unknown artist. Gowanus Brooklyn 2017. Photo by Laura Norén
在每周撰写数据科学时事通讯的过程中，我会遇到一些与大学、公司或政府无关的故事，但仍然值得一读。有时，它们是关于数据科学的伦理影响的很好的长篇读物。有时候，我也会收录播客片段。但本周的故事大多很有趣，而且都是书面的(这次没有播客，但一定要发给我你喜欢的数据科学剧集)。
和你的伴侣吵架？有一个应用程序可以做到这一点！南加州大学**的夫妇移动传感项目(多好的名字)的研究人员让 34 对夫妇捕捉他们的语音和 GPS 坐标，同时可穿戴设备测量他们的皮肤电导率、身体活动和体温。34 对夫妇中有 19 对在一天的收集期内发生了冲突。(我感觉到，这些夫妇中的一方可能比另一方更热衷于这个研究项目，制造了否则可能不会发生的冲突。啊，我们以科学的名义做的事情。)机器学习过程在 79.3%的时候准确地预测了冲突。希望这些预测可以让手机上的应用程序提供“有用的建议”来缓解冲突。给一对争吵不休的夫妇增加两部智能手机，我并不觉得这是个好主意。**
J 范德比克把水厂的奖金从骰子显示的 4 倍提高到 7 倍。如果玩家还拥有电力公司呢？费用从 10 倍到 17 倍不等。
摄影师摩根·特林布尔和阿什利·罗布森** 预测 非洲 75%的大象因偷猎而“失踪”。深感悲哀，一点也不好玩。**
在密歇根大学的地球 222/环境 232 课程中，一位教授记录了学生使用电脑的情况。然后她制作了一张 幻灯片 列出了他们在课堂上在线做的所有事情。有些活动是可以预测的——脸书、纽约时报、购物、他们的编程作业。有些远没那么容易预测:把特朗普总统的头像 PS 到布偶上，聊天时和男朋友分手(不推荐)。
Lego characters at a flea market in New Orleans. 2016. Photo by Laura Norén. Reminding us of youth.
T 何美国人口普查发布了一份关于年轻人生活的引人入胜的描述:《1975 年至 2016 年年轻成年期的经济和人口统计变化》 。【网飞还有一个 有争议的 新原创节目，可以说是关于改变年轻人生活的: 13 个理由 。]
人口普查报告中的一些要点。“超过一半的美国人认为结婚生子对于一个成年人来说并不重要。“在 20 世纪 70 年代，80%的人在 30 岁前结婚。今天，不到 45 岁就结婚的人 10 人中有 8 人
3。“如今，住在父母家中的年轻人比其他任何安排都多:2015 年，三分之一的年轻人，即大约 2400 万 18 岁至 34 岁的年轻人，住在父母家中。”我承认在我写论文的时候，我逃离了纽约几次，去我父母的地下室写论文。他们的地下室是一个非常适合居住的地方。
4。“1975 年，25%的 25-34 岁的年轻男性年收入低于 3 万美元。到 2016 年，这一比例上升至 41%(收入以 2015 年美元计算)。”我们必须开始讨论男人身上发生了什么，尤其是单身男人。我不是在暗示什么因果箭头，只是指出数据显示单身男性在健康结果或工作晋升方面不如已婚男性公平。
Kevin HoofIDEO**创建了 一个交互式 字体图 使用卷积神经网络进行聚类。Ho 写道，“选择字体是设计师最常见的视觉决策之一”，但如果没有一个易于导航的目录，他们通常会“依赖于他们以前使用的字体，或者在 serif、san-serif 或 grotesque 等类别中搜索”。在这种情况下，如果我们将创造力定义为在一个人现状之外的领域建立想法，计算的应用可能会导致更多的创造力，而不是更少。**
永远的数据科学！
Dubai Data Science community
这个周末，我很荣幸地在 In5 Tech 共同主持了九月份的迪拜数据科学会议。meetup 由迪拜的开放数据科学社区组织，汇集了数据科学家、领域专家和行业领袖的最大聚会。作为 9 月 meetup 的支持者，我有机会与来自金融、安全、运营、航空业甚至天体物理学等各种背景的现场专家交流，了解他们的经验以及他们如何使用数据科学解决复杂的工业挑战！
Kicking off the meetup with Developers coming in from all across UAE!
由于 IBM 是 meetup 的赞助商，我有机会邀请来自迪拜数据科学界的开发人员参加代码征集挑战，这是一项全球性的多年计划，旨在激励开发人员用可持续的软件解决方案解决紧迫的全球问题。2018 年的比赛要求参赛者建立能够显著改善其社区和世界各地备灾现状的解决方案。这一点尤其重要，因为 2017 被列为有记录以来灾难性事件最严重的年份之一，包括火灾、洪水、地震和风暴，我们只会看到这种情况在 2018 年继续。
从事机器学习和数据科学工作的开发人员肯定可以通过解决挑战来提供帮助，例如如何使用机器学习、深度学习和视觉识别来改善关键流程或者能够理解、分析和预测健康&营养需求来改善数据科学服务。
除了其他好处(高达 20 万美元的现金奖励！)，最具影响力的项目将在 IBM、Linux 基金会、联合国人权委员会和美国红十字会的帮助下，实施到最需要的社区。
Inviting developers to participate in the Call for Code!
然后，我们以 Sethu Raman 关于数据科学成熟度模型的演讲开始了第一场会议，在此期间，他谈到了数据科学家如何根据多个重要标准评估他们的模型，而不仅仅是评估其性能。这可以通过针对愿景&一致性、风险(治理、风险&合规性)、责任&技术/平台对其成熟度进行评分来实现。Sethu 浏览了几篇论文和令人难忘的防止对抗性 攻击的例子，模型可解释性与时间，以及减轻&避免在 ML 系统中传播偏见的最佳实践与 Kate Crawford 对解决偏见的建议:使用公平辩论，创建跨学科系统，以及“更加努力地思考分类的伦理”。他的演讲让房间里的数据科学家大开眼界，并让他们意识到，在发布之前，考虑他们的模型的社会影响并根据这样一个成熟度模型进行评估也同样重要。
Sethu sharing A Maturity Model for Data Science
接下来是由 Evgenii Makarov 针对面部标志检测和 MSQRD 如何工作等不同用例的演讲，而其他人如 Vivek Kalyanarangan 演示了像这样的数据科学家使用 Docker 容器部署机器学习模型的基本技能。
Facial Alignment by Evgenii & Deploying ML Models using Docker by Vivek
下一个有趣的演讲是由 Pavel Golubev 做的，关于使用马尔可夫决策过程(MDP)来优化航空公司的机上餐食。Pavel 带我们了解了 S7 航空公司项目的商业和技术方面(如果你喜欢乐队 OK Go ，你可能会认出他们)。了解正在解决的核心业务问题(每月大量未消费的机上餐食)是非常有趣的，它与公司的年度 KPI 以及项目的实际实施相关联——从了解为什么 MDP 与线性模型相比是一个很好的 ML 选择，以及通过识别主要代理、状态、行动、成本函数&转移概率来应用 MDP 来构建解决方案的模型。然后，他向我们展示了这是如何与正确的项目团队一起推出的，并通过他们的调度投入生产，使用针对 Python 的 MDP 工具箱的大规模修改版本来安排&预订系统。这个相当简单的 ML 实现将膳食过剩从 80%减少到只有 12%！
Pavel speaking about optimising S7’s onboard meal ordering system
最后，最后一场会议是关于帕维尔·内斯特罗夫使用开源 RASA 工具创建聊天机器人的简短讨论，他向我们展示了一个 Jupyter 笔记本，展示了数据科学家如何使用 RASA 核心创建聊天机器人。
Pavel speaking about open source vs proprietary tools for chatbots
meetup 最精彩的部分是与来自不同行业的开发人员会面，了解他们如何使用多种数据科学工具应用描述性、预测性和规范性分析来解决复杂的业务问题。这真的让你大开眼界，看到了使用数据科学解决挑战性问题的全部能力&我迫不及待地想看到迪拜数据科学界如何通过构建成熟的模型和开发备灾和救灾的可持续解决方案来充分利用这些技能。
想学以致用吗？在【http://callforcode.org】独自或组队参加一场有意义的全球在线比赛。了解开发人员如何通过更好的灾难准备来尽自己的一份力量，让世界变得更美好。当然，现金奖对获奖者的奖励只是奖金！
您也可以参加我们在meetup.com/IBMCloud-Dubai/举办的下一次开发者聚会
真实的数据科学
借助高级分析和机器学习实现物业管理转型
“它是有形的，它是坚实的，它是美丽的。从我的角度来看，这是艺术，我就是喜欢房地产。”- 唐纳德·特朗普
我通常不同意特朗普总统的观点。事实上，恰恰相反。尽管——关于房地产——我们似乎有共同的爱好。
几千年来，房地产一直是财富的代名词，帮助人们积累了大量财富，未来几代人可能还会继续如此。通过房地产投资创造价值的一个关键因素是健全的物业管理。
虽然已经开发了久经考验的财产管理技术，但其中许多方法是在模拟世界中开发的。我们现在生活在一个设备变得越来越智能、万物互联、算法正在抢走我们工作的时代。我们已经从模拟转向数字。在这个新的数字时代，物业经理仍然扮演着重要的角色，但我们现在越来越有能力让他更有效率，让他把时间花在对业务有更大影响的任务上。
房地产公司可以通过多种方式利用数据科学来改善物业管理——从集成智能建筑技术到为租户管理实施机器学习模型。本文将讨论为使用这些技术做准备的一些方法，并展示高级分析和机器学习模型在物业管理中的具体用例。
跑之前先走
使用机器学习算法来推动利润听起来很酷——它可能是价值的巨大驱动力，但在这些技术能够得到充分利用之前，需要对业务流程、结构和治理有所了解。
过程
首先，应该清楚地理解和定义业务流程。业务流程管理，或者被从业者称为 BPM，可能已经过时了，但是仍然可以从绘制流程图和分析流程中获得有价值的见解。BPM 可以清楚地了解当前的流程，并且更容易看到流程的哪些部分可以用新技术改进，哪些应该保持原样。对您的流程采用模块化方法，并分析每个步骤中所需的输入和输出。始终考虑简化和标准化的方法，因为这将使数字化和自动化更加容易。
从电子表格到数据库
像微软的 Excel 这样的电子表格程序取得了巨大的成功。它们被世界上数百万的企业所使用，对于许多特殊的任务，它们表现得非常好。但当涉及到报告和更高级的任务时，电子表格可能会很麻烦，容易出错，并且无法提供模型所需的正确数据。当然，您可以通过集成 Visual Basic 代码使您的工作表变得智能，并创建伟大的宏，但这可能很难开发出一个潜在的噩梦来维护。
就其本质而言，易于操作和更改，电子表格并不是报告和其他日常任务的理想解决方案。这几乎肯定会导致错误和模糊性的增加。从电子表格转向更像数据库的世界，使得机器学习算法更有效地应用于问题成为可能。在一个更加结构化的系统中，任务可以被更大程度地分析和自动化。这对于想要涉足数据科学的公司来说至关重要。
数据治理
如何处理数据，如何保护和存储数据，谁可以插入、更新或删除记录，这些都是数据治理中的关键问题。企业从数据治理中受益，因为它有助于确保数据的一致性和可信性，并符合法规约束。
从数据科学的角度来看，数据的质量和一致性至关重要。老话“垃圾进，垃圾出”在训练和使用机器学习模型时尤其适用。没有好的数据，模型会变得更弱，它们的输出和预测会变得不可信。因此，强烈建议在实施高级机器学习项目之前，建立一个良好的数据治理流程。
使用数据科学
有了正确的流程、数据治理和架构支持，现在是时候在数字化之旅中勇往直前了。数据科学——将高级分析和机器学习模型应用于行业问题——是下一个自然的步骤。下面是几个例子，说明如何利用这项技术来加强物业管理。
租户流失
客户流失建模是数据科学的经典应用之一。几十年来，银行、保险和电信等行业一直使用客户流失模型来预测客户行为，它在物业管理方面也有明显的用例。
在其最简单的形式中，流失模型是一个二元分类模型，给定一组预测值或输入变量，输出一个分类。例如，如果租户租用一个单元，流失模型可以用来预测租户在给定的时间范围内(例如 1 年)离开的概率。
有了这些知识，物业经理可以更好地了解租户组合将如何随着时间的推移而变化，以及哪些单元可能会很快可用。这将使经理能够主动锁定高流失率的候选人，并为他们延长合同提供激励。此外，该模型可以突出哪些单元可能需要在未来被填充，从而可以减少单元的空缺期。
流失模型也可以有效地用作大型预测模型的组件，其中流失的概率被纳入未来现金流，并在广泛的租户群体中进行汇总。通过这样做，一家房地产公司可以对其现金流做出更准确的预测，从而在不增加风险的情况下增加其总杠杆。最终，导致更有效地利用资本。
房地产公司认真对待租户管理的一个例子是 Spire 物业管理。他们使用 MRI(一种专用的房地产软件解决方案)来帮助防止客户流失。据 Spire 的执行董事肖恩·保罗称，他们使用 MRI 来“简化客户关系管理……组织、自动化和评估其保留工作——跟踪租赁和租赁周年纪念、租户记录、维护活动和工作订单”。有效地为物业管理公司和租户创造双赢的解决方案。
为新租户带来商机
你知道谁是你最好的房客吗？他们是有最高支付意愿和能力的人，还是那些总是延迟支付以便你可以收取滞纳金的人？或者，最好的租户可能是一至两年周转期短的租户，这让你有机会签订新合同并提高租金。这个问题的答案无法通过机器学习模型来回答，而是应该从商业角度进行评估，与公司的整体战略保持一致。
一旦明确定义了最佳租户，并且公司知道它想要谁作为租户——请记住，这可能因建筑而异——就有可能使用机器学习算法来绘制出这些理想租户的特征。然后，可以在各种潜在客户列表中运行该功能集，以确定哪些客户有可能成为最佳租户。当特征集丰富而复杂时，机器学习模型通常在超人的水平上执行这种类型的分类，并且比人类好得多。
对于商业房地产，也有一些供应商帮助公司产生线索，增加销售。Vainu 就是这种公司的一个例子。他们成立于 2013 年，正在使用机器学习模型和大型数据库来辅助销售过程。房地产公司 Technopolis 的一项案例研究显示，与以前相比，他们在销售机会挖掘方面所用的时间减少了三分之一。这种类型的解决方案可能特别适用于希望增加其商业单位销售线索的物业经理。
员工的位置优化
考虑下面的场景。一家公司拥有两栋带有几个单元的办公楼，并且有员工使用这两栋楼。由于意想不到的情况，办公空间的使用出现了不平衡，导致一栋建筑超负荷使用，而另一栋却未得到充分利用。这种次优情况如何用技术改善？
使用分析和传感器系统，可以监控员工的位置，并且可以配置自动消息系统来通知员工不平衡，并引导该组的子集到较少占用的空间。这种类型的优化工作实施起来并不困难，但如果经常出现不平衡，可以节省大量资金，并可以减少办公空间的总体使用量。
智能建筑技术
智能建筑技术有望让物业经理受益匪浅。有些创新相当新，它们的潜力还没有完全发掘出来，但有几个用例非常突出。
预测性维护
预测性维护可以帮助您在建筑物出现问题之前发现问题，从而采取措施防止故障或限制维修造成的停机时间。这可以使维护人员更加有效，从而降低成本，并可能增加设备的总寿命。对于租户来说，缩短关键基础架构维修的停机时间也是有利的。
使用预测性维护技术的第一步是为需要监控的设备添加传感器。来自这些传感器的数据然后被收集在数据库中，并且在操作一段时间后，关于系统操作的时间序列数据被累积。假设我们有足够的观察结果，那么时间序列就包含了建立预测系统下一次故障的机器学习模型所需的数据。
这些机器学习模型通常是分类模型或回归模型。在分类模型的情况下，我们将尝试预测在接下来的 n 个时间步骤内失败的概率。通过回归模型，我们可以预测下一次故障之前还剩多少时间，这通常被称为“剩余使用寿命”。无论选择哪种模型，都将取决于系统的类型和建模可用的数据。
建筑信息建模
建筑信息建模，简称 BIM，是智能建筑领域的另一项激动人心的技术发展。基本的想法是，该建筑有一个完全相同的数字孪生与示意图和三维模型。虽然许多建筑公司使用 BIM 来帮助他们的建筑过程，但他们也可以在物业的生命周期内提供显著的优势，从而帮助物业经理。
BIM 对物业管理有用的一个典型例子是当建筑中的系统出现故障时。由于建筑本身具有完整的 3D 模型，维护工程师可以在穿越建筑时使用增强现实，并在进行维修时获得关键的建筑信息。可以提供给工程师的数据包括服务历史记录、系统规格和合同信息，使维修过程更容易、更快，并且与预测性维护一样，还可以缩短关键基础设施的停机时间。
超越物业管理
值得注意的是，我们主要讨论了如何利用数字化和数据科学来改善物业管理。这当然只是房地产行业的一个子集，对于整个行业来说，数据科学还有很多其他可能的应用领域。机器学习模型现在被用来预测从价格和租金收入到人口趋势的任何事情。随着我们继续使用更多的物联网设备和算法变得更好，我们肯定会看到更多的用例发展。
通过使用新兴的数字技术，有许多方法可以加强物业管理。但是，为了充分利用分析和机器学习方面的最新进展，一个组织需要一定程度的数字成熟度。然而，一旦达到这个阈值，数据科学就可以以多种方式使用。通过更好地了解租户及其流失情况，或者通过使用预测性维护技术和 BIM 模型，可以节省成本，通过销售线索挖掘模型可以增加销售额。
如果您喜欢这篇文章，并希望看到我的更多内容，或者希望使用我的服务，请随时在 https://www.linkedin.com/in/hans-christian-ekne-1760a259/的 LinkedIn 上与我联系，或者访问我在 https://ekneconsulting.com/的网页，查看我提供的一些服务。如有任何其他问题或意见，请发邮件至hce@ekneconsulting.com给我。
感谢阅读！
参考资料:
[## 磁共振成像软件-解放你的房地产业务
MRI 软件提供创新的房地产解决方案，解放您的公司。了解我们的开放和互联…
www.mrisoftware.com](https://www.mrisoftware.com/) [## 租户流失会如何影响盈利能力
租户，作为商业建筑的主要收入来源，是关键，因此租户保留应该是首要的…
www.bizcommunity.com](http://www.bizcommunity.com/Article/196/567/158822.html) [## 预测性维护的机器学习技术
在这篇文章中，作者探讨了如何建立一个机器学习模型来进行系统的预测性维护…
www.infoq.com](https://www.infoq.com/articles/machine-learning-techniques-predictive-maintenance) [## 什么是数据治理(DG)？-WhatIs.com 的定义
数据治理(DG)是对数据的可用性、可用性、完整性和安全性的全面管理…
searchdatamanagement.techtarget.com](https://searchdatamanagement.techtarget.com/definition/data-governance) [## 什么是 BIM |建筑信息建模| Autodesk
BIM(建筑信息建模)是一个智能的三维模型为基础的过程，给建筑，工程和…
www.autodesk.com](https://www.autodesk.com/solutions/bim)
创业数据科学:博客->书籍
Publishing a blog series as a book.
数据科学家写书有很多令人信服的理由。我想更好地理解新工具，并记录我过去在行业中的一些经验。基里尔·叶列缅科也声称写作让你更快乐、更善解人意、更有效率。
我实现这个目标的最初方法是使用 Medium 发布一系列关于走向数据科学的博客文章。我的第一篇文章反响很好，我分享的后续文章也得到了很好的反馈。一旦我在这个系列上取得了一些好的进展，我就受到启发，使用“基于博客的同行评审”来写一本书。这种方法是由加州大学圣克鲁斯分校的教授诺亚·沃德里普-弗鲁恩在创作他的书《表达处理》时首创的。我没有采用这种正式的方法来进行同行评审，但是在将博客文章转化为书籍章节时，我采纳了反馈意见。
这个过程的结果就是《创业公司的数据科学》这本书。它以多种格式在线免费提供，印刷版也免版税。书中所有例子的代码都可以在 Github 上找到，我也发布了这本书的源代码。以下是一些格式:
在这篇文章中，我将讨论用来创作这本书、构建这本书和自助出版的工具，以及我使用的写作过程。
工具作业
对于创作内容，我使用 Medium 来编写作为博客帖子的章节初稿。与其他编辑器相比，我喜欢使用 Medium 进行写作，因为我不必担心格式问题，有一个内置的拼写检查器，并且很容易包含代码片段。在使用该平台一段时间后，我发现它为创作提供了一个很好的流程。在创作一本书时，缺少一些有用的功能，例如能够引用图表、代码块或参考书目条目，但它确实提供了一个很好的起点。
为了构建这本书，我使用了 bookdown 包，这是一个 R 库，它将 R markdown 文件转换为 PDF、epub 和 web 格式，以便出版一本书。因为它基于 R markdown，所以您可以使用 R 代码来生成可视化，作为图书编译过程的一部分。将 Medium posts 转换成 R markdown (Rmd)文件需要做一些工作，我将在下一节详细讨论。过去，我用 LaTeX 写论文。对于这本书，我发现 bookdown 更容易使用，不会失去对内容布局的控制。当使用 bookdown 构建 PDF 时，库首先将 R markdown 转换为 TeX 文件，然后使用 Pandoc 生成输出文件。
出版方面，我用的是 Kindle Direct Publishing，现在有了平装本选项。KDP 提供了很好的工具来审查书籍内部的内容，提供了一个有用的封面设计师，并提供了各种各样的书籍尺寸。你的书出现在亚马逊市场上只需要几天时间。我也探索了使用 CreateSpace 和 Lulu，但发现 KDP 有最好的打印质量价格。
写作
我很清楚我想在这本书里涵盖什么内容，我在我的介绍帖子里做了概述。然而，我并没有一个完全实现的计划，来计划我将构建什么样的系统，然后在本书中介绍这些系统。理想情况下，我想做一个完整的游戏分析平台，然后在不同的章节中讨论这个系统的不同部分。实际上，我构建了数据平台各部分的 MVP，并使用公开可用的数据集来减少我在撰写章节之前需要做的系统构建工作。在撰写技术书籍时，了解您采用以下哪种方法来创作内容是很有用的:
- 建立一个系统，然后记录它是如何工作的
- 编写介绍不同主题的教科书
我从第一种方法开始，然后在写作过程中转向第二种方法。我应该从一开始就决定采取哪种方法，并坚持下去。
因为我已经有了一个很好的大纲，我想涵盖的内容，我把重点放在按顺序写每一章。以下是我使用的过程:
- 创建章节大纲
- 为章节中的教程编写代码
- 创建可视化效果和代码片段
- 写下这一章的正文部分
我发现第二步通常花费最多的时间，尤其是在探索新工具时，比如使用 Google Datastore。
一旦我在 Medium 上发布了帖子，我就需要将帖子转换成 Rmd 格式。为此，我将文章中的文本复制到一个新文件中，添加了部分和子部分的标题，添加了代码块标识符，用脚注替换了超链接，并使用 knitr 中的 include_graphics 函数添加了图像。我还抽查了产生的章节输出，并修改了间距以消除孤儿和其他文本工件。我还修复了媒体上突出显示的或回复中提到的任何错别字。
我的建议是，在写一本技术书籍时，如果可能的话，尽早锁定工具，并留出比你认为写一本书所必需的时间更多的时间，尤其是如果你打算在写作过程中学习一些新东西的话。总的来说，我发现这种体验很有价值，并会推荐更多的数据科学家来尝试一下！
创业数据科学:商业智能
roleSource: rawpixel at pixabay.com
我正在进行的关于在初创公司建立数据科学学科的系列文章的第四部分。你可以在 简介 中找到所有帖子的链接，还有一本基于这个系列的关于 亚马逊 的书。
在初创公司建立数据科学涉及的大量繁重工作是说服产品团队使用仪器并关心数据。如果你能够实现这个目标，下一步就是能够回答你的组织内所有关于产品健康的问题。数据科学家新手可能会认为这类工作超出了数据科学家的职责范围，但确定产品健康的关键指标是该角色的核心方面之一。
我将这篇文章命名为商业智能，因为一旦你建立了数据管道，初创公司的数据科学家就应该回答所有关于数据的问题。考虑到新的数据洪流，这并不奇怪，但也是数据科学家为组织的其他人设定期望的时候了。作为一名初创公司的数据科学家，你的职责不是回答数据问题，而是告知领导层哪些指标应该是重要的。
这篇文章讲述了如何将原始数据转化为可以总结产品健康状况的成熟数据的基础知识。我将讨论在处理原始数据时采用的几种不同的方法，包括 SQL 查询、R markdown 和供应商工具。总的来说，就是展示处理数据集有几种选择，您应该选择一种适合您团队目标的解决方案。我将讨论过去使用 Tableau 等工具的经验，并提供在团队中扩展自动化报告的建议。
在这篇文章中，我们将使用两个数据源。第一个是公共数据集，我们将使用关键指标对其进行汇总和总结。第二个是本系列第二章中跟踪 API 生成的数据。我们将关注用于将原始数据转换为已处理数据的第二个数据集，以及用于将已处理数据转换为熟数据的第一个数据集。
KPI
关键绩效指标(KPI)用于跟踪初创公司的健康状况。为了确定对产品所做的改变是否有益，跟踪捕捉参与度、保留率和增长的指标是很重要的。作为一家初创公司的数据科学家，你的职责是确定哪些指标是重要的。该职能与领域知识的数据科学能力相一致，是数据科学家极具影响力的领域之一。
由早期数据科学家建立的 KPI 可能会产生巨大的影响。例如，我过去工作过的许多公司的公司目标都是基于数据科学家过去的分析。在电子艺界，我们专注于提高会话指标，在 Twitch，我们希望最大限度地提高观看内容的数量，在索尼在线娱乐，我们希望提高免费游戏的保留指标。这些是游戏行业的衡量标准，但还有更通用的衡量标准，如参与度、增长和货币化，这些在创建公司时非常重要。
在初创公司建立数据科学学科时，确保您的团队从事高影响力的工作非常重要。我在过去的公司看到的一个问题是，数据科学家被拉入数据工程和分析类型的工作。当公司只有一名数据人员时，这是意料之中的，但是您不希望支持太多无法扩展的手动数据流程。这就是为什么为报告和分析建立可重复的方法是重要的。几个月后重新运行一个分析应该是微不足道的，并且其他团队成员在最少的指导下也可以这样做。
我对新数据科学家的主要建议是，为防止被产品经理和其他团队的请求淹没，为数据科学团队建立一个接口，缓冲直接请求。与其让公司的任何人都能够询问数据科学团队事情的执行情况，不如设置一组基线仪表板来跟踪产品性能。鉴于数据科学家可能是初创公司的首批数据角色之一，这一职责最初将由数据科学家承担，为了在初创公司支持这一职能，熟悉许多不同的工具非常重要。
用 R 报告
作为一名数据科学家，您在创业时可以实现的一个关键转变是从手动报告流程迁移到可重现的报告。对于这种类型的工作来说，r 是一种强大的编程语言，它可以以多种不同的方式提供自动化的报告功能。本节讨论如何使用 R 来创建绘图、生成报告和构建交互式 web 应用程序。虽然 Python 和 Jupyter suite 也提供了许多这样的功能，但是对自动化的关注比用于实现这一目标的语言更重要。
用 Excel 或 Google Sheets 可以实现这类功能，但我建议初创公司不要用这种方法。这些工具非常适合创建演示图表，但不适合自动报告。对于数据科学家来说，基于这些类型的报告来支持一家初创公司是不可持续的，因为可能需要如此多的手动步骤。像 Excel 中的 ODBC 这样的连接器对于自动化来说似乎很有用，但是当试图在另一台机器上运行报告时可能就不起作用了。
本节涵盖了用 R 构建报告的三种方法:直接使用 R 创建图，使用 R Markdown 生成报告，以及使用 Shiny 创建交互式可视化。本节列出的所有代码都可以在 Github 上获得。
Base R
幸运的是，有一个公共数据集可以帮助回答这类问题:BigQuery 的纽约出租车和豪华轿车出行公共数据集。此旅行数据集合包括付款信息，您可以使用这些信息来确定付款类型随时间变化的趋势。
我们将用来回答这个问题的第一种方法是使用 R 中的绘图库来创建一个绘图。采用这种方法时，我推荐使用 RStudio IDE 。此外，这种方法实际上不是“Base R ”,因为我使用了两个额外的库来完成汇总数据集和绘制结果的目标。我将这个部分称为 Base R ，因为我使用了 R 的内置可视化功能。
R 的一大优点是有各种不同的库可用于处理不同类型的数据库。BigQuery库为 big query 提供了一个有用的连接器，可以用来从 R 脚本中的公共数据集中提取数据。下面显示了用于汇总一段时间内的支付历史并将结果绘制成图表的代码。
library(bigrquery)
library(plotly)
project <- "your_project_id"sql <- "SELECT
substr(cast(pickup_datetime as String), 1, 7) as date
,payment_type as type
,sum(total_amount) as amount
FROM `nyc-tlc.yellow.trips`
group by 1, 2"df <- query_exec(sql, project = project, use_legacy_sql = FALSE)
plot_ly(df, x = ~date, y = ~amount, color = ~type) %>% add_lines()
该脚本的第一部分包括除最后一行之外的所有内容，负责从 BigQuery 中提取数据。它加载必要的库，声明要运行的查询，并使用 bigrquery 获取结果集。将数据放入数据框后，脚本的第二部分使用 plotly 库将结果显示为折线图。脚本中排除了一些额外的格式化步骤，完整的代码清单可以在 Github 上找到。在 RStudio 中，图表将在 IDE 中显示为交互式绘图，Jupyter 也提供了类似的功能。下面的图表显示了这段代码的结果。
Monthly Spending by Payment Type
该查询使用 2009 年至 2015 年的数据，按支付类型计算纽约市出租车旅行的每月总支出。结果显示，信用卡(CRD)现在是比现金(CSH)更受欢迎的支付方式。要回答最初关于实现哪种类型的支付系统的问题，我建议从接受信用卡的系统开始。
此时值得一提的一个话题是数据质量，因为图表中有许多不同的标签似乎代表相同的值。例如, CAS 和 CSH 都可能指现金支付，应该组合在一起以获得准确的现金支付总额。处理这类问题超出了这种方法的范围，但是有一些方法可以用于这类场景。最简单但可伸缩性最差的方法是编写考虑这些不同类型的查询:
,sum(case when payment_type in ('CSH', 'CAS') then amount else 0 end) as cash_payments
可以使用的另一种方法是创建一个维度表，将所有原始的 payment_type 值映射到净化的类型值。这个过程通常被称为属性丰富，在从原始数据或经过处理的数据构建成熟的数据集时非常有用。
我们已经回答了关于确定最流行的支付方式的第一个问题，但如果我们有第二个问题，关于纽约市的交通市场是否在增长呢？我们可以使用现有数据集轻松绘制数据来回答这个问题:
total <- aggregate(df$Amount, by=list(Category=df$Date), FUN=sum)
plot_ly(total, x = ~Category, y = ~x) %>% add_lines()
此代码计算所有不同支付类型的每月总支付额，并将合计值绘制成单线图。结果如下图所示。基于对该数据的初步观察，第二个问题的答案尚不清楚。从 2009 年到 2013 年，纽约市的出租车支出稳步增长，但有季节性波动，但支出在 2014 年夏天达到顶峰。优步和 Lyft 可能解释了这一趋势，但需要进一步分析才能得出明确的结论。
Total Monthly Spending
本节展示了如何使用 R 从 BigQuery 中的汇总数据生成图表。虽然这个示例使用了一个固定的数据集，但是同样的方法也可以用于一个随时间增长的动态数据集，重新运行脚本将会包含更多的最新数据。这还不是自动报告，因为它涉及到在 IDE 或笔记本中手动运行代码。可以使用的一种方法是将绘图输出到图像文件，并作为 cron 作业的一部分运行脚本。这种方法的结果是定期更新的绘图图像。这是一个很好的起点，但是在 r 中还有更好的自动化报告解决方案。
R Markdown
R Markdown 提供了这种能力，可以使用 R 代码生成 pdf、word 文档(DOCX)、网页(HTML)。甚至可以用 R Markdown 写本书！R Markdown 扩展了标准 Markdown，支持可用于生成可视化效果的内联 R 代码片段。嵌入式 R 代码几乎可以执行任何标准的 R 功能，包括使用 R 库和连接数据库。这意味着我们可以将上面的代码转换成 R markdown 文件，并定期运行脚本来构建自动化报告。
下面的 markdown 代码片段是以前的 R 代码，现在嵌入到一个报告中，该报告将生成一个 HTML 文件作为输出。文件的第一部分是关于报告的元数据，包括所需的输出。接下来，markdown 用于向报告添加注释。最后，使用 R 代码块从 BigQuery 中提取数据并绘制结果。运行此报告时，生成的 plotly 对象嵌入到文档中。
---
title: "Business Intelligence"
author: "Ben Weber"
date: "May 21, 2018"
output: html_document
---
## Taxi Payments
R Markdown can outputs reports as PDF or HTML.```{r echo=FALSE, message=FALSE, warning=FALSE}
library(bigrquery)
library(plotly)
project <- "your_project_id"sql <- "SELECT
substr(cast(pickup_datetime as String), 1, 7) as date
,payment_type as type
,sum(total_amount) as amount
FROM `nyc-tlc.yellow.trips`
group by 1, 2"df <- query_exec(sql, project = project, use_legacy_sql = FALSE)
plot_ly(df, x = ~date, y = ~amount, color = ~type) %>% add_lines()
生成的 HTML 文档如下图所示。它包括与之前相同的情节，以及在代码块之前列出的降价文本。此输出可能比图像更有用，因为文件中嵌入的 plotly 图表是交互式的，而不是渲染的图像。它对于创建具有各种不同图表和指标的报告也很有用。
The interactive web page generated from the R Markdown file.
要自动创建该报告，您可以再次设置一个 cron 作业。将 Rmd 文件转换为报告的命令是:
Rscript -e “rmarkdown::render(‘BI.Rmd’)”
我们现在有了一种生成报告的方法，并且可以使用 cron 开始构建一个自动化的报告解决方案。然而，我们还没有提供过滤和深入功能的图表。
**R Shiny** [Shiny](https://shiny.rstudio.com/)是一个直接在 R 中构建仪表板的解决方案，它提供了构建具有过滤和下钻功能的报表的功能，可以作为 Tableau 等工具的替代。使用 Shiny 时，您可以指定要包含在报告中的 UI 组件，以及报告中不同组件的行为，例如基于对 slider 组件的更改应用过滤器。结果是一个交互式的 web 应用程序可以运行您的嵌入式 R 代码。
我已经基于与上述报告相同的代码创建了一个示例 Shiny 应用程序。代码的第一部分是相同的，我们将数据从 BigQuery 拉至 dataframe，但是我们还包含了闪亮的库。代码的第二部分定义了不同组件(服务器)的行为，以及不同组件(ui)的布局。这些函数被传递给 shinyApp 调用以启动仪表板。
library(shiny)
library(bigrquery)
library(plotly)
project <- "your_project_id"sql <- “SELECT
substr(cast(pickup_datetime as String), 1, 7) as date
,payment_type as type
,sum(total_amount) as amount
FROM nyc-tlc.yellow.trips
group by 1, 2”
df <- query_exec(sql, project = project, use_legacy_sql = FALSE)server <- function(input, output) {
outputKaTeX parse error: Expected '}', got 'EOF' at end of input: … plot_ly(df[dfdate >= input$year, ], x = ~date,
y = ~amount, color = ~type) %>% add_lines()
})
}ui <- shinyUI(fluidPage(
sidebarLayout(
sidebarPanel(
sliderInput(“year”, “Start Year:”,
min = 2009, max = 2015, value = 2012)
),
mainPanel(plotlyOutput(“plot”))
)
))shinyApp(ui = ui, server = server)
UI 函数指定如何在仪表板中布置组件。我从包含滑块和直方图的 [Hello Shiny](http://rstudio.github.io/shiny/tutorial/#hello-shiny) 示例开始，并修改了布局以使用 plotOutput 对象代替 plot output。滑块指定允许选择的年份，并设置默认值。behavior 函数指定如何响应 UI 组件中的变化。该图与 behavior 相同，但有一处修改，当使用数据帧`df$date >= input$year`时，它现在过滤起始数据。结果是如下所示的交互式仪表板。移动滑块将会过滤图表中包含的年份。
An interactive Chart in R Shiny.
我已经展示了使用 R 生成报告的三种不同方式。如果您需要交互式仪表板，那么 Shiny 是一个很好的工具，而如果您希望构建静态报告，那么 R Markdown 是一个很好的解决方案。这两种方法的一个关键好处是，你可以在你的图表中嵌入复杂的 R 逻辑，比如使用脸书的 [prophet library](https://research.fb.com/prophet-forecasting-at-scale/) 向你的图表添加预测值。
## ETLs
在关于数据管道的文章中，我讨论了使用原始数据、经过处理的数据和熟数据。大多数用于商业智能的报告应该基于熟数据，在熟数据中数据被聚合、丰富和净化。如果您在构建报告时使用经过处理的数据或原始数据，而不是熟数据，您将很快遇到报告管道中的性能问题。例如，不是在上面的 R 部分中直接使用 *nyc-tlc.yellow.trips* 表，我可以创建一个预先计算了聚合值的表。
ETL 是提取-转换-加载的缩写。这些类型的流程的主要用途之一是将原始数据转换为处理过的数据，或者将处理过的数据转换为熟数据，例如聚合表。设置聚合表的一个主要挑战是保持表的更新和准确。例如，如果您开始使用新的缩写(例如 CAH)来跟踪现金支付，您将需要更新计算每月现金支付的汇总流程，以包括这种新的支付类型。
数据管道的输出之一是一个原始事件表，其中包含所有编码为 JSON 的跟踪事件的数据。我们可以设置的一种 ETL 过程是原始数据到已处理数据的转换。在 BigQuery 中，这可以为登录事件实现，如下所示:
create table tracking.logins as (
select eventVersion,server_time
,JSON_EXTRACT_SCALAR(message, ‘
.
u
s
e
r
I
D
′
)
a
s
u
s
e
r
I
D
,
J
S
O
N
E
X
T
R
A
C
T
S
C
A
L
A
R
(
m
e
s
s
a
g
e
,
′
.userID') as userID ,JSON_EXTRACT_SCALAR(message, '
.userID′)asuserID,JSONEXTRACTSCALAR(message,′.deviceType’) as deviceType
from tracking.raw_events
where eventType = ‘Login’
)
该查询过滤原始事件表中的登录事件，并使用 JSON 提取标量函数解析 JSON 消息中的元素。运行此 DDL 语句的结果将是跟踪模式中的一个新表，其中包含所有登录数据。我们现在已经处理了带有可以直接查询的 *userID* 和 *deviceType* 属性的登录数据。
在实践中，我们希望逐步构建一个这样的表，只转换自 ETL 过程最后一次运行以来到达的新数据。我们可以使用下面的 SQL 代码中所示的方法来实现这一功能。我们不是创建一个新表，而是插入到一个现有的表中。使用 BigQuery，您需要为插入操作指定列。接下来，我们找到最后一次更新登录表的时间，表示为 *updateTime* 值。最后，我们使用这个结果来连接自上次更新以来发生的登录事件。这些原始事件被解析成已处理的事件，并添加到登录表中。
insert into tracking.logins
(eventVersion,server_time, userID, deviceType)
with lastUpdate as (
select max(server_time) as updateTime
from tracking.logins
)
select eventVersion,server_time
,JSON_EXTRACT_SCALAR(message, ‘
.
u
s
e
r
I
D
′
)
a
s
u
s
e
r
I
D
,
J
S
O
N
E
X
T
R
A
C
T
S
C
A
L
A
R
(
m
e
s
s
a
g
e
,
′
.userID') as userID ,JSON_EXTRACT_SCALAR(message, '
.userID′)asuserID,JSONEXTRACTSCALAR(message,′.deviceType’) as deviceType
from tracking.raw_events e
join lastUpdate l
on e.server_time > updateTime
where eventType = ‘Login’
可以使用类似的方法从处理过的数据中创建熟数据。上面登录 ETL 的结果是，我们现在可以直接查询 *userID* 和 *deviceType* 字段。这些经过处理的数据使得按平台计算有用的指标(如每日活跃用户(DAU))变得很简单。下面是在 BigQuery 中计算这个指标的一个例子。
create table metrics.dau as (
select substr(server_time, 1, 10) as Date
,deviceType, count(distinct userID) as DAU
from tracking.logins
group by 1, 2
order by 1, 2
)
运行该查询的结果是一个预先计算了 DAU 度量的新表。烹饪数据表中显示了该数据的一个示例。与前面的 ETL 类似，实际上我们希望使用增量方法来构建这个度量表，而不是使用完整的数据集来重建。这里需要采用稍微不同的方法，因为如果 ETL 在一天中运行多次，那么当天的 DAU 值需要更新多次。
Cooked Data: DAU by Platform
一旦有了一组要为数据管道运行的 ETL，您就需要安排它们定期运行。您可以采用的一种方法是使用 cron 来设置任务，例如:
bq query --flagfile=/etls/login_etl.sql
为这样的流程设置监控非常重要，因为数据管道早期的故障会对下游产生重大影响。诸如 [Airflow](https://airflow.apache.org/) 等工具可用于构建复杂的数据管道，并提供监控和警报。
## 报告工具
虽然 R 确实为执行商业智能任务提供了有用的工具，但它并不总是构建自动化报告的最佳工具。当技术和非技术用户需要使用报告工具时，这是很常见的，并且用于构建仪表板的供应商解决方案通常对这些类型的场景很有用。以下是我过去用过的几种不同的工具。
谷歌数据工作室
如果你已经在使用 GCP，那么谷歌数据工作室值得探索，为你的组织内部共享建立仪表板。然而，它比其他工具稍显笨拙，所以最好推迟构建仪表板，直到您有了要构建的报告的基本完整的规范。
Setting up a Custom Data Source in Google Data Studio
上图显示了如何在 Google Data Studio 中设置一个自定义查询，以提取 R 报告中使用的相同数据集。与之前相同的报告，现在用 Data Studio 实现，如下所示。
The Taxi Report recreated in Google Data Studio
这个工具的主要好处是它提供了许多内置于其他工具的协作特性，比如 Google Docs 和 Google Sheets。它还会根据需要刷新报告以防止数据过时，但可用的计划选项有限。
**Tableau** 我用过的最好的可视化工具之一就是 Tableau。当您有一个完整的规格时，它非常适合构建仪表板的用例，以及在执行探索性分析时构建交互式可视化。DC Universe Online 的热图是用 Tableau 构建的，是可以构建的许多不同类型的可视化之一。
A heatmap in Tableau for the game DC Universe Online
Tableau 的主要优点是易于构建可视化和探索新数据集。主要的缺点是许可证的定价，以及缺乏 ETL 工具，因为它关注的是表示而不是数据管道。
在 Twitch，我们使用了一个名为 Mode Analytics 的供应商工具。Mode 使得与其他分析人员共享查询变得简单，但是它的可视化功能非常有限，并且只关注于表示，而不是 ETL 类型的任务。
Line Charts in Mode Analytics
**定制工具** 另一种可用的方法是使用 D3.js 和 Protovis 等工具创建定制可视化。在电子艺界，D3 被用于为游戏团队创建客户仪表盘，例如由 Ben Medler 创建的用于可视化死亡空间 2 中游戏测试数据的[数据破解](https://dl.acm.org/citation.cfm?id=1979288)工具。
The Data Cracker Tool for Dead Space 2\. Source: GDC Vault 2011
使用定制工具提供了最大的灵活性，但是也需要维护一个系统，并且通常需要做更多的工作。
## 结论
数据科学家在初创公司的一个关键角色是确保其他团队可以有效地使用你的产品数据。通常这采取提供仪表板或其他自动化报告的形式，以便为不同的团队提供 KPI 或其他指标。它还包括确定哪些指标对公司的测量是重要的。
这篇文章介绍了在 R 中设置自动化报告的三种不同方法，从直接在 R 中创建图表，使用 R Markdown 生成报告，到使用 Shiny 构建仪表板。我们还讨论了如何编写 ETL 来将原始数据转换为经过处理的数据，并将经过处理的数据转换为熟数据，以便可以用于报告目的。最后一节讨论了一些不同的报告供应商解决方案，以及它们的优缺点。
在为商业智能设置好工具之后，大部分工作都已经就绪，可以更深入地研究数据科学类型的工作了。我们可以超越回顾性的问题，前进到预测、预测性建模和实验。
# 创业公司的数据科学:数据管道
> 原文：<https://towardsdatascience.com/data-science-for-startups-data-pipelines-786f6746a59a?source=collection_archive---------0----------------------->
Source: TheDigitalArtist at pixabay.com
我正在进行的关于在初创公司建立数据科学学科的系列文章的第三部分。你可以在 [*简介*](/data-science-for-startups-introduction-80d022a18aec) *中找到所有帖子的链接，还有一本基于这个系列的关于* [*亚马逊*](https://www.amazon.com/dp/1983057975) *的书。*
建立数据管道是初创企业数据科学的核心组成部分。为了构建数据产品，您需要能够从数百万用户那里收集数据点，并近乎实时地处理结果。虽然我的[上一篇博文](/data-science-for-startups-tracking-data-4087b66952a1)讨论了收集什么类型的数据以及如何将数据发送到端点，但这篇博文将讨论如何处理已经收集的数据，使数据科学家能够处理这些数据。即将发布的关于模型生产的博文将讨论如何在这个数据平台上部署模型。
通常，数据管道的目的地是数据湖，如 S3 上的 Hadoop 或 parquet 文件，或者是关系数据库，如 Redshift。理想的数据管道应该具有以下特性:
* **低事件延迟:**数据科学家应该能够在事件被发送到数据收集端点的几分钟或几秒钟内，在管道中查询最近的事件数据。这对于测试和构建需要近实时更新的数据产品非常有用。
* **可扩展性:**一个数据管道应该能够扩展到数十亿个数据点，随着产品的扩展，可能会扩展到数万亿。一个高性能的系统不仅应该能够存储这些数据，还应该能够查询完整的数据集。
* **交互式查询:**一个高功能的数据管道应该支持长时间运行的批处理查询和较小的交互式查询，使数据科学家能够探索表和理解模式，而不必在采样数据时等待几分钟或几小时。
* **版本控制:**您应该能够对您的数据管道和事件定义进行更改，而不会导致管道中断和数据丢失。本文将讨论在改变事件模式的情况下，如何构建一个支持不同事件定义的管道。
* **监控:**如果某个事件不再被接收，或者某个特定区域的跟踪数据不再被接收，那么数据管道应该通过 PagerDuty 等工具生成警报。
* **测试:**您应该能够使用测试事件来测试您的数据管道，这些测试事件不会出现在您的数据湖或数据库中，但是会测试管道中的组件。
数据管道应该具有许多其他有用的属性，但这是一个创业的良好起点。当您开始构建依赖于您的数据管道的附加组件时，您会想要设置用于容错和自动化任务的工具。
本文将展示如何建立一个可伸缩的数据管道，将跟踪数据发送到数据湖、数据库和订阅服务，以便在数据产品中使用。我将讨论管道中不同类型的数据，数据管道的发展，并通过 PubSub、DataFlow 和 BigQuery 在 GCP 上实现一个示例管道。
在部署数据管道之前，您需要回答以下问题，这些问题类似于我们关于跟踪规格的问题:
1. 谁拥有数据管道？
2. 哪些团队将使用数据？
3. 谁将对管道进行质量保证？
在小型组织中，数据科学家可能负责管道，而大型组织通常有一个基础架构团队负责保持管道的运行。了解哪些团队将使用数据也很有用，这样您就可以将数据传输到适当的团队。例如，营销可能需要登录页面访问的实时数据来为营销活动进行归因。最后，应该定期彻底检查传递到管道的事件的数据质量。有时，产品更新会导致跟踪事件丢失相关数据，应该建立一个流程来捕获这些类型的数据变化。
## 数据类型
根据已执行的修改量，管道中的数据通常有不同的名称。数据通常用以下标签分类:
* **原始数据:**是未经处理的跟踪数据。这是以用于发送跟踪事件的消息编码格式存储的数据，如 JSON。原始数据尚未应用模式。将所有跟踪事件作为原始事件发送是很常见的，因为所有事件都可以发送到单个端点，并且模式可以稍后在管道中应用。
* **处理过的数据:**处理过的数据是已经被解码成事件特定格式的原始数据，并应用了一个模式。例如，JSON 跟踪事件被转换成具有固定模式的会话启动事件，这些事件被视为已处理数据。已处理的事件通常存储在数据管道中不同的事件表/目的地中。
* **熟数据:**经过汇总或汇总处理的数据称为熟数据。例如，处理后的数据可以包括会话开始和会话结束事件，并被用作汇总用户日常活动的熟数据的输入，例如会话的数量和网页在网站上的总时间。
数据科学家通常会处理经过处理的数据，并使用工具为其他团队创建成熟的数据。这篇文章将讨论如何构建一个输出处理过的数据的数据管道，而商业智能文章将讨论如何将熟数据添加到您的管道中。
## 数据管道的演变
在过去的二十年里，收集和分析数据的环境发生了巨大的变化。现代系统可以跟踪活动并近乎实时地应用机器学习，而不是通过日志文件在本地存储数据。初创公司可能希望使用早期的方法进行初始测试，但应该真正寻找更新的方法来构建数据管道。根据我的经验，我注意到了四种不同的管道方法:
1. **平面文件时代:**数据保存在游戏服务器本地
2. **数据库时代:**数据存放在平面文件中，然后加载到数据库中
3. **数据湖时代:**数据存储在 Hadoop/S3 中，然后加载到 DB 中
4. **无服务器时代:**托管服务用于存储和查询
这一演变中的每一步都支持更大数据集的收集，但可能会引入额外的操作复杂性。对于一家初创公司，目标是能够在不扩展运营资源的情况下扩展数据收集，而向托管服务的发展为增长提供了一个很好的解决方案。
我们将在本文的下一节中介绍的数据管道是基于最新的数据管道时代，但介绍不同的方法是有用的，因为不同公司的需求可能更适合不同的架构。
**平面文件时代**
Components in a pre-database Analytics Architecture
2010 年，我在电子艺界开始研究数据科学，那时 EA 还没有围绕数据建立组织。虽然许多游戏公司已经收集了大量关于游戏的数据，但大多数遥测数据都以日志文件或其他平面文件格式的形式存储在游戏服务器上。没有什么是可以直接查询的，计算月活跃用户(MAU)等基本指标需要大量的工作。
在电子艺界，重播功能被内置到 Madden NFL 11 中，这提供了一个意想不到的游戏遥测源。每场比赛后，一份 XML 格式的比赛摘要被发送到一个游戏服务器，其中列出了每场比赛的叫牌、比赛过程中的走法以及比赛结果。这导致了数百万个文件可以被分析，以了解更多关于球员如何在野外与马登足球互动的信息。
在本地存储数据是目前为止收集游戏数据时最简单的方法。例如，上一篇文章中介绍的 PHP 方法对于设置轻量级分析端点非常有用。但是这种方法有明显的缺点。
这种方法很简单，使团队能够以任何需要的格式保存数据，但是没有容错能力，不将数据存储在一个中心位置，在数据可用性方面有很大的延迟，并且具有用于构建分析生态系统的标准工具。如果您只有几台服务器，平面文件可以很好地工作，但它不是真正的分析管道，除非您将文件移动到一个中心位置。您可以编写脚本将数据从日志服务器拉到一个中心位置，但这通常不是一种可伸缩的方法。
**数据库时代**
Components in an ETL-based Analytics Architecture
当我在索尼在线娱乐公司时，我们让游戏服务器每隔几分钟就将事件文件保存到一个中央文件服务器。然后，文件服务器大约每小时运行一次 ETL 过程，将这些事件文件快速加载到我们的分析数据库中，该数据库当时是 Vertica。这个过程有一个合理的延迟，从游戏客户端发送事件到数据在我们的分析数据库中可查询大约一个小时。它还可以扩展到大量数据，但需要使用固定的事件数据模式。
当我还是一个 Twitch 时，我们对我们的一个分析数据库使用了类似的过程。与 SOE 的方法的主要区别是，我们没有将游戏服务器 scp 文件放在一个中心位置，而是使用[亚马逊 Kinesis](https://aws.amazon.com/kinesis/) 将事件从服务器传输到 S3 的集结地。然后，我们使用 ETL 过程将数据快速加载到 Redshift 中进行分析。从那时起，Twitch 转向了数据湖方法，以便扩展到更大的数据量，并为查询数据集提供更多选项。
SOE 和 Twitch 使用的数据库对两家公司都非常有价值，但我们在扩展存储的数据量时确实遇到了挑战。随着我们收集更多关于游戏的详细信息，我们不能再在表格中保存完整的事件历史，需要截断超过几个月的数据。如果您可以设置维护这些事件的最重要细节的汇总表，这很好，但是这不是理想的情况。
这种方法的一个问题是，临时服务器会成为故障的中心点。当一个游戏发送了太多的事件时，也有可能出现瓶颈，导致事件在所有游戏中被丢弃。另一个问题是当处理数据库的分析师数量增加时的查询性能。几个分析师组成的团队处理几个月的游戏数据可能会很好，但在收集了多年的数据并增加了分析师的数量后，查询性能可能会成为一个重大问题，导致一些查询需要几个小时才能完成。
这种方法的主要好处是，所有事件数据都可以在一个位置使用 SQL 查询，并且有很好的工具可以使用，如 Tableau 和 DataGrip，用于处理关系数据库。缺点是将所有数据加载到像 Vertica 或 Redshift 这样的数据库中的成本很高，事件需要有固定的模式，并且可能需要截断表来保持服务器的性能。
使用数据库作为数据的主要接口的另一个问题是，Spark 的 MLlib 等机器学习工具无法有效使用，因为相关数据需要从数据库中卸载才能进行操作。克服这种限制的方法之一是以一种格式和存储层存储游戏数据，这种格式和存储层可以很好地与大数据工具配合使用，例如在 S3 上将事件保存为拼花文件。这种类型的配置在下一个时代变得越来越普遍，它避开了需要截断表的限制，并降低了保存所有数据的成本。
**数据湖时代**
Components in a Data Lake Analytics Architecture
当我在游戏行业担任数据科学家时，最常见的数据存储模式是数据湖。一般模式是将半结构化数据存储在分布式数据库中，并运行 ETL 过程来提取与分析数据库最相关的数据。许多不同的工具可以用于分布式数据库:在电子艺界我们使用 Hadoop，在微软工作室我们使用 Cosmos，在 Twitch 我们使用 S3。
这种方法使团队能够扩展到海量数据，并提供额外的容错能力。它的主要缺点是引入了额外的复杂性，并且由于缺少工具或访问策略，可能导致分析师访问的数据比使用传统数据库方法时少。在这个模型中，大多数分析师会以同样的方式与数据交互，使用从数据湖 ETL 中填充的分析数据库。
这种方法的好处之一是它支持各种不同的事件模式，并且您可以在不影响分析数据库的情况下更改事件的属性。另一个优势是，分析团队可以使用 Spark SQL 等工具直接处理数据湖。然而，我工作过的大多数地方都限制了对数据湖的访问，消除了这种模式的许多好处。
这种方法可以扩展到大量数据，支持灵活的事件模式，并为长时间运行的批处理查询提供了一个很好的解决方案。不利的一面是，它可能涉及大量的操作开销，可能引入大量的事件延迟，并且可能缺乏针对数据湖的最终用户的成熟工具。这种方法的另一个缺点是，通常需要整个团队来保持系统的运行。这对大型组织来说是有意义的，但对较小的公司来说可能有些矫枉过正。利用数据湖而不产生运营开销的方法之一是使用托管服务。
**无服务器时代**
Components in a managed Analytics Architecture (GCP)
在当前时代，分析平台整合了许多托管服务，使团队能够接近实时地处理数据，根据需要扩展系统，并减少维护服务器的开销。我在游戏行业工作时从未经历过这个时代，但看到了这种转变正在发生的迹象。Riot Games 正在使用 [Spark](https://www.slideshare.net/SparkSummit/video-games-at-scale-improving-the-gaming-experience-with-apache-spark) 进行 ETL 过程和机器学习，并需要按需旋转基础设施。一些游戏团队正在为游戏服务使用弹性计算方法，利用这种方法进行分析也是有意义的。
这种方法有许多与使用数据湖相同的好处，可以根据查询和存储需求自动伸缩，并且操作开销最小。主要缺点是托管服务可能很昂贵，采用这种方法可能会导致使用无法移植到其他云提供商的平台特定工具。
在我的职业生涯中，我在使用数据库时代方法方面取得了最大的成功，因为它为分析团队提供了对所有相关数据的访问。然而，这不是一个可以继续扩展的设置，我工作过的大多数团队后来都转移到了数据湖环境。为了让数据湖环境取得成功，分析团队需要访问底层数据，以及成熟的工具来支持他们的流程。对于初创公司来说，无服务器方法通常是开始构建数据管道的最佳方式，因为它可以根据需求进行扩展，并且只需要最少的员工来维护数据管道。下一节将通过托管服务构建一个示例管道。
## **一个可扩展的管道**
我们将构建一个数据管道，使用 Google 的 PuSub 作为端点来接收事件，并将事件保存到数据湖和数据库中。这里介绍的方法将事件保存为原始数据，但是我还将讨论将事件转换为处理过的数据的方法。
执行所有这些功能的数据管道相对简单。管道从 PubSub 读取消息，然后转换事件以实现持久性:管道的 BigQuery 部分将消息转换为 TableRow 对象并直接传输到 BigQuery，而管道的 AVRO 部分将事件批处理到离散的窗口中，然后将事件保存到 Google 存储中。操作图如下图所示。
The streaming pipeline deployed to Google Cloud
**设置环境** 构建数据管道的第一步是设置编译和部署项目所需的依赖关系。我使用了以下 maven 依赖项来为向管道发送事件的跟踪 API 和处理事件的数据管道设置环境。
Source: 4047259 at pixabay.com
我正在进行的关于在创业公司建立数据科学学科系列的第十部分，第一篇文章从 R 移植到 Python 。你可以在 简介 中找到所有帖子的链接，以及一本基于 R 系列关于 亚马逊 的书。
这篇博文是对使用 Keras 深度学习框架解决经典(浅层)机器学习问题的简要介绍。它展示了一个案例研究，来自我在意外之财数据公司的经历，我在那里研究一个模型，预测美国数亿套房产的房价。
我最近开始与 R 一起阅读“深度学习”，我对 R 对深度学习的支持印象深刻。然而，现在我将我的博客系列移植到 Python，我将直接使用 Keras 库，而不是 R 包装器。幸运的是，这本书还有一个 Python 版本。
使用 Python 的深度学习介绍了使用 Python 语言和强大的
www.amazon.com](https://www.amazon.com/Deep-Learning-Python-Francois-Chollet/dp/1617294438)
书中介绍的一个用例是预测波士顿的房价，这是一个有趣的问题，因为房价可能会有很大的变化。这是一个机器学习问题，可能最适合经典方法，如 XGBoost，因为数据集是结构化的，而不是感知数据。然而，它也是一个数据集，深度学习提供了一个真正有用的能力，即编写新的损失函数的容易程度，这可能会提高预测模型的性能。这篇文章的目标是展示深度学习如何通过使用自定义损失函数来改善浅层学习问题。
我在处理金融数据时遇到过几次的一个问题是，您经常需要构建预测模型，其中的输出值可能有很大的范围，跨越不同的数量级。例如，在预测房价时会发生这种情况，一些房屋的价值为 10 万美元，而其他房屋的价值为 1000 万美元。如果你在这些问题上使用标准的机器学习方法，如线性回归或随机森林，通常模型会过度拟合具有最高值的样本，以减少平均绝对误差等指标。但是，您实际需要的可能是用相似的权重处理样本，并使用相对误差等误差度量来降低用最大值拟合样本的重要性。
**# Standard approach to linear regression** fit <- lm(y ~ x1 + x2 + x3 + ... + x9, data=df)**# Linear regression with a log-log transformation** fit <- nls( log10(y) ~ log(x1*b1 + x2*b2 + ... + x9*b9),
data = df, start = list(b1=1, b2=1, ... , b9 = 1))
我实际上是在 R 中使用诸如非线性最小二乘法( nls )之类的包显式地做到了这一点。Python 也有一个 NLS 库，但是我在解决住房问题时没有探索这个选项。上面的代码示例显示了如何使用内置优化器构建线性回归模型，该优化器将对具有较大标签值的样本进行加权，以及使用 nls 方法，该方法显示了如何对预测值和标签执行对数转换，这将给予样本相对相等的权重。第二种方法的问题是，您必须明确地说明如何使用模型中的特性，这就产生了一个特性工程问题。这种方法的另一个问题是，如果不编写自己的似然函数和优化器，它不能直接应用于其他算法，如随机森林。这是一个针对特定场景的，在该场景中，您希望将误差项排除在对数转换之外，而不是简单地将对数转换应用于标签和所有输入变量。
深度学习为处理这些类型的问题提供了一个优雅的解决方案，其中，您可以探索不同的内置和自定义损失函数，这些函数可以与提供的不同优化器一起使用，而不是编写自定义的可能性函数和优化器。本文将展示如何在使用 Keras 时用 Python 编写自定义损失函数，并展示如何使用不同的方法对不同类型的数据集有益。我将首先展示一个使用 Keras 的分类示例，然后展示如何使用自定义损失函数进行回归。
下图是我将在这篇文章中涉及的内容的预览。它显示了在波士顿房价数据集上训练的四个不同的 Keras 模型的训练历史。每种模型使用不同的损失函数，但是根据相同的性能指标，平均绝对误差进行评估。对于原始数据集，自定义损失函数不会提高模型的性能，但在修改后的数据集上，结果更有希望。
Performance of the 4 loss functions on the original housing prices data set. All models used MAE for the performance metric.
装置
开始深度学习的第一步是建立一个环境。在我过去的帖子中，我提到了在 AWS EC2 实例上设置 Jupyter。我们将为 Python 安装两个额外的库:tensorflow 和 keras。此外，当处理深度学习问题时，加速更大的机器是有用的，例如 t2.xlarge。下面是我用来在 EC2 上建立深度学习环境的步骤。但是，这种配置不支持 GPU 加速。
**# Jupyter setup** sudo yum install -y python36
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
sudo python36 get-pip.py
pip3 install --user jupyter**# Deep Learning set up** pip3 install --user tensorflow
pip3 install --user keras
pip3 install --user matplotlib
pip3 install --user pandas**# Launch Jupyter** jupyter notebook --ip *Your_AWS_Prive_IP*
一旦连接到 Jupyter，就可以通过运行以下命令来测试您的安装:
import keras
keras.__version__
输出应该显示正在使用 TensorFlow 后端。
用 Keras 分类
为了开始深度学习，我们将建立一个二元分类器，根据过去的购买情况，预测哪些用户最有可能购买特定的游戏。我们将使用我在关于推荐系统的帖子中展示的数据集。数据集中的行包含指示玩家是否购买了游戏的标签，以及具有值 0 或 1 的其他游戏的列表，其指示购买了其他标题。目标是预测哪些用户会购买游戏。本节介绍的代码的完整笔记本可在这里获得。
使用 Keras 构建模型的一般过程是:
- 建立模型的结构
- 编译模型
- 符合模型
- 评估模型
我将在下面更详细地讨论这些步骤。首先，我们需要包含 keras 和绘图所需的库:
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
import keras
from keras import models, layers
keras.__version__
接下来，我们下载数据集并创建训练和测试数据集。我拿出了 5000 个样本，我们将把它们作为一个维持数据集。对于训练数据集，我将数据帧分成输入变量( x )和标签( y )。
df = pd.read_csv(
"[https://github.com/bgweber/Twitch/raw/master/Recommendations/games-expand.csv](https://github.com/bgweber/Twitch/raw/master/Recommendations/games-expand.csv)")train = df[5000:]
test = df[:5000]x = train.drop(['label'], axis=1)
y = train['label']
现在我们可以创建一个模型来拟合数据。下面的模型使用了三层具有 relu 激活功能的全连接神经元。输入结构在第一层中指定，它需要匹配输入数据的宽度。输出被指定为具有 sigmoid 激活的信号神经元，因为我们正在执行二进制分类。
model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(10,)))
model.add(layers.Dropout(0.1))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dropout(0.1))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
接下来，我们指定如何优化模型。我们将使用 rmsprop 用于优化器，使用 binary_crossentropy 用于损失函数。我们将使用 ROC AUC，而不是使用准确性作为指标，因为数据集有很大的类别不平衡。为了使用这个度量，我们可以使用 tensorflow 提供的 auc 函数。
def auc(y_true, y_pred):
auc = tf.metrics.auc(y_true, y_pred)[1]
keras.backend.get_session().run(
tf.local_variables_initializer())
return auc
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',metrics=[auc]
最后一步是训练模型。下面的代码显示了如何使用训练数据集、100 个训练时期(批量大小为 100)和 20%的交叉验证拆分来拟合模型。
history = model.fit(x,
y,
epochs=100,
batch_size=100,
validation_split = .2,
verbose=0)
如果 verbose 设置为 1 或 2，模型的进度将在训练期间显示。为了绘制结果，我们可以使用 matplotlib 来显示训练和测试数据集的损失值:
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(loss) + 1)plt.figure(figsize=(10,6))
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.legend()
plt.show()
结果图如下所示。虽然训练数据集的损失值随着更多的时期继续降低，但是测试数据集的损失在大约 10 个时期后变平。
Plotting the loss values for the binary classifier.
我们还可以在每个时期后绘制 AUC 指标的值，如下所示。与损失值不同，测试数据集上的模型的 AUC 度量随着额外的训练而继续改善。
Plotting the AUC metric for the binary classifier.
最后一步是评估模型在维持数据集上的性能。可以使用下面所示的代码计算维持数据的损失值和 AUC 指标，从而得到约 0.82 的 AUC。
x_test = test.drop(['label'], axis=1)
y_test = test['label']results = model.evaluate(x_test, y_test, verbose = 0)
results
本节讨论了使用深度学习模型和 Keras 框架构建一个简单的分类器。一般来说，深度学习在像这样的浅层学习问题上的表现不如 XGBoost，但它仍然是一种有用的探索方法。在下一节中，我将讨论如何使用自定义损失函数来改进模型训练。
自定义损失函数
深度学习的一个很大的特点是，它既可以应用于感性数据的深度问题，如音频和视频，也可以应用于结构化数据的浅层问题。对于浅层学习(cclassic ML)问题，通过使用提供有用信号的自定义损失函数，您经常可以看到对浅层方法(如 XGBoost)的改进。
然而，并不是所有的浅层问题都能受益于深度学习。我发现，在构建需要为不同数量级的数据创建预测的回归模型时，自定义损失函数非常有用。例如，预测某个地区的房价，该地区的房价可能会大幅波动。为了展示这在实践中是如何工作的，我们将使用 Keras 提供的波士顿住房数据集:
来自 IMDB 的 25，000 个电影评论的数据集，由情绪(正面/负面)标记。评论已经过预处理…
keras.io](https://keras.io/datasets/#boston-housing-price-regression-dataset)
这个数据集包括 20 世纪 70 年代波士顿郊区的房价。每条记录有 13 个描述房屋属性的属性，在训练数据集中有 404 条记录，在测试数据集中有 102 条记录。在 R 中，数据集可以如下加载:boston_housing.load_data()。数据集中的标签代表房屋的价格，以千美元计。价格从 5k 美元到 50k 美元不等，价格分布如左图所示。原始数据集具有相似数量级的值，因此自定义损失函数可能不适用于拟合该数据。右侧的直方图显示了标签的变换，这可能得益于使用自定义损失。
The Boston data set with original prices and the transformed prices.
为了转换数据，我将标签转换回绝对价格，对结果求平方，然后除以一个大因子。这导致最高和最低价格之间的差别是 100 倍，而不是 10 倍。我们现在有一个预测问题，可以受益于自定义损失函数的使用。生成这些图的 Python 代码如下所示。
**# Original Prices** plt.hist(y_train)
plt.title("Original Prices")
plt.show()**# Transformed Prices** plt.hist((y_train*1000)**2/2500000)
plt.title("Transformed Prices")
plt.show()
Keras 中的损失函数
Keras 包括许多有用的损失函数，用于训练深度学习模型。像mean_absolute_error()这样的方法对于数值数量级大致相等的数据集很有效。还有一些函数，比如mean_squared_logarithmic_error()，可能更适合转换后的房屋数据。以下是 Keras 提供的一些损失函数:
mean_absolute_error()
mean_absolute_percentage_error()
mean_squared_error()
mean_squared_logarithmic_error()
为了真正理解这些是如何工作的，我们需要跳入 Python 损失代码。我们将探讨的第一个损失函数是均方误差，定义如下。该函数计算预测值和实际值之间的差值，对结果求平方(使所有值为正)，然后计算平均值。注意，该函数使用的是对张量对象而不是 Python 原语进行操作的后端操作。
def mean_squared_error(y_true, y_pred):
return K.mean(K.square(y_pred - y_true), axis=-1)
我们将探讨的下一个内置损失函数基于预测值和目标值的自然对数之间的差异来计算误差。这里定义为，如下图所示。该函数使用 clip 操作来确保负值不会被传递给对数函数，并且将 1 加到 clip 结果确保所有对数变换的输入将具有非负的结果。这个函数类似于我们将要定义的函数。
def mean_squared_logarithmic_error(y_true, y_pred):
first_log = K.log(K.clip(y_pred, K.epsilon(), None) + 1.)
second_log = K.log(K.clip(y_true, K.epsilon(), None) + 1.)
return K.mean(K.square(first_log - second_log), axis=-1)
我们将探讨的两个自定义损失函数在下面的 Python 代码段中进行了定义。第一个函数 mean log absolute error(MLAE)计算预测值和实际值的对数变换之间的差值，然后对结果取平均值。与上面的内置函数不同，这种方法不会平方误差。与上面的对数函数的另一个不同之处是，该函数对数据应用了一个显式的比例因子，将房价转换回其原始值(5，000 到 50，0000)而不是(5，50)。这很有用，因为它减少了将+1 加到预测值和实际值上的影响。
from keras import backend as K**# Mean Log Absolute Error** def MLAE(y_true, y_pred):
first_log = K.log(K.clip(y_pred*1000, K.epsilon(), None) + 1.)
second_log = K.log(K.clip(y_true*1000, K.epsilon(), None) + 1.)
return K.mean(K.abs(first_log - second_log), axis=-1)**# Mean Squared Log Absolute Error**
def MSLAE(y_true, y_pred):
first_log = K.log(K.clip(y_pred*1000, K.epsilon(), None) + 1.)
second_log = K.log(K.clip(y_true*1000, K.epsilon(), None) + 1.)
return K.mean(K.square(first_log - second_log), axis=-1)
像 Keras 函数一样，自定义损失函数需要对张量对象而不是 Python 原语进行操作。为了执行这些操作，您需要使用 from 语句获得对后端的引用。在我的系统配置中，这将返回对 tensorflow 的引用。
第二个函数计算对数误差的平方，类似于内置函数。主要的区别是，我对值进行了缩放，这是针对住房数据集的。
评估损失函数
我们现在有四个不同的损失函数，我们希望评估原始和转换后的住房数据集的性能。本节将介绍加载数据、编译模型、拟合模型和评估性能。本节的完整代码清单可以在 github 上找到。
在完成上一节中的安装步骤后，我们将加载数据集，并将我们的转换应用于倾斜房价。最后两个操作可以注释掉使用原房价。
**# load the data set** from keras.datasets import boston_housing
(x_train, y_train), (x_test, y_test) = boston_housing.load_data()**# transform the training and test labels** y_train = (y_train*1000)**2/2500000
y_test = (y_test*1000)**2/2500000
接下来，我们将创建一个用于预测房价的 Keras 模型。我已经使用了“用 R 进行深度学习”中的样本问题中的网络结构。该网络包括两层全连接的 relu 激活神经元和一个无变换的输出层。
**# The model as specified in "Deep Learning with R"** model = models.Sequential()
model.add(layers.Dense(64, activation='relu',
input_shape=(x_train.shape[1],)))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(1))
为了编译这个模型，我们需要指定一个优化器、损失函数和一个度量标准。我们将对所有不同的损失函数使用相同的指标和优化器。下面的代码定义了一个损失函数列表，对于第一次迭代，模型使用均方误差。
**# Compile the model, and select one of the loss functions** losses = ['mean_squared_error', 'mean_squared_logarithmic_error',
MLAE, MSLAE]model.compile(optimizer='rmsprop',
loss=losses[0],
metrics=['mae'])
最后一步是拟合模型，然后评估性能。我使用了 100 个 epochs，批量大小为 5，20%的验证分割。在训练数据集上训练模型之后，使用测试数据集上的平均绝对误差来评估模型的性能。
**# Train the model with validation** history = model.fit(x_train,
y_train,
epochs=100,
batch_size=5,
validation_split = .2,
verbose=0)**# Calculate the mean absolute error** results = model.evaluate(x_test, y_test, verbose = 0)
results
训练完模型后，我们可以使用 matplotlib 绘制结果。下图显示了训练和测试数据集的损失值。
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(loss) + 1)plt.figure(figsize=(10,6))
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.legend()
plt.show()
Loss values for the training and validation data sets.
我用不同的损失函数训练了四个不同的模型，并将这种方法应用于原始房价和转换后的房价。所有这些不同组合的结果如下所示。
Performance of the Loss Function of the Housing Price Data Sets
在原始数据集上，在损失函数中应用对数变换实际上增加了模型的误差。这并不奇怪，因为数据是正态分布的，并且在一个数量级内。对于转换的数据集，平方对数误差方法优于均方误差损失函数。这表明，如果您的数据集与内置损失函数不兼容，自定义损失函数可能值得探索。
转换数据集上四个不同损失函数的模型训练历史如下所示。每个模型使用相同的误差度量(MAE ),但不同的损失函数。一个令人惊讶的结果是，所有应用对数变换的损失函数的验证误差都要高得多。
Performance of the 4 loss functions on the transformed housing prices data set. All models used MAE for the performance metric.
深度学习对于浅层学习问题来说是一个有用的工具，因为你可以定义定制的损失函数，这可能会大大提高你的模型的性能。这并不适用于所有问题，但如果您有一个不能很好地映射到标准损失函数的预测问题，这可能是有用的。
本·韦伯是 Zynga 的首席数据科学家。我们正在招聘！
创业数据科学:探索性数据分析
Source: wynpnt at pixabay.com
我正在进行的关于在初创公司建立数据科学学科的系列文章的第五部分。你可以在 简介 中找到所有帖子的链接，还有一本基于这个系列的关于 亚马逊 的书。
一旦你建立了数据管道，收集了用户行为的数据，你就可以开始探索这些数据，以决定如何改进你的产品。探索性数据分析(EDA)是调查数据集以了解数据形状、特征之间的相关性以及数据中可能对构建预测模型有用的信号的过程。
能够用查询语言和脚本语言来执行这项任务是很有用的。r 为快速理解数据集的形状提供了有用的工具，但只能分析能放入内存的数据集。为了处理大规模数据集，SQL 对于计算整个数据集的汇总统计和分布非常有用。
本文介绍了四种探索性分析，包括计算汇总统计数据、绘制要素、相关性分析和简单线性模型的要素重要性加权。执行这类工作的目标是能够更好地理解用户行为，确定如何改进产品，并调查数据是否为构建数据产品提供了有用的信号。
对于 EDA 示例，我们将使用 Natality BigQuery 数据集。这个数据集提供了美国过去 50 年的出生信息。该分析的目的是确定哪些因素与出生体重相关，并建立一个线性回归模型来预测结果。
汇总统计数据
当探索一个新的数据集时，我们要做的第一件事是计算帮助我们理解数据集的汇总统计数据。这可能包括平均值和中值等统计数据，以及最小值和最大值等极端值。r 提供了一个名为 summary 的函数，用于计算数据框中每一列的统计数据。下面的代码片段显示了使用该函数的示例。
library(bigrquery)
project <- "your_project_id"sql <- "
SELECT year, plurality, mother_age, father_age,
gestation_weeks, ever_born, mother_married, weight_pounds
FROM `bigquery-public-data.samples.natality`
order by rand()
LIMIT 100000"df <- query_exec(sql, project = project, use_legacy_sql = FALSE)
summary(df[, 2:5])
该脚本在 BigQuery 中查询出生率数据集，并在本地提取一个样本数据集。接下来，将结果集的第二到第五列传递给 summary 函数。调用该函数的结果如下图所示。对于每一列，该函数计算每个属性的最小值、平均值、最大值以及第 25、50 和 75 个百分点。它还计算缺失(NA)值的实例数。
Summary Stats for the Natality Data Set
摘要提供了一种快速理解数据集的方法，但通常需要进一步挖掘才能真正理解数据的形状。下一节将展示如何使用直方图来更全面地理解数据集。数据集中一个有趣的特征是 multiple 列，它描述了怀孕过程中携带的子女数量(产仔数)。中位数略高于 1，因为很少出现双胞胎、三胞胎甚至更多的孩子。由于这种分布的偏态性，汇总的统计数据不能很好地概括人类怀孕中双胞胎或三胞胎的常见程度。
为了弄清楚双胞胎和三胞胎有多常见，我们可以使用 sqldf 库，它允许在 R 数据帧上执行查询。下面的代码显示了如何计算导致多胎分娩的怀孕次数。结果显示，双胞胎出现的频率约为 2.4%，三胞胎出现的频率约为 0.1%，四胞胎出现的频率约为 0.009%。
library(sqldf)
df <- df[!is.na(df$plurality), ]
sqldf("select plurality, sum(1) as Babies
from df group by 1
order by 1")
这些结果是基于 1，000，000 例妊娠的样本。理想情况下，我们希望跨计算数据集计算这些统计数据。min、max 和 mean 等聚合值很容易计算，因为 SQL 内置了这些运算的聚合。然而，计算中间值以及第 25 和第 75 个百分位数通常并不简单。如果您试图将 percentile_cont 操作应用于 1.38 亿次怀孕的完整数据集，BigQuery 将会抛出一个异常，因为这是一个分析函数，会将所有记录混排到一个节点中。
有几种不同的方法可以解决这个限制。BigQuery 确实提供了一个近似的分位数函数来支持这种大小的数据。您还可以使用随机生成的值(如 rand()*10)对数据集进行分区，并取平均值，以获得近似结果。这些方法适用于第 25、50 和 75 百分位值，但对于极端结果(如第 99.9 百分位)则不太准确。第三种方法是提供一个分区键来分割数据，防止太多的数据被转移到一台机器上。我们可以使用 year 字段，如下面的查询所示。
select year, sum(1) births, min(father_age) Min
,avg(Q1) Q1, avg(Q2) Median, round(avg(father_age), 1) Mean
,avg(Q3) Q3, max(father_age) Max
from (
select year, father_age
,percentile_cont(father_age, 0.25) over (partition by year) as Q1
,percentile_cont(father_age, 0.50) over (partition by year) as Q2
,percentile_cont(father_age, 0.75) over (partition by year) as Q3
FROM `bigquery-public-data.samples.natality`
where mod(year, 5) = 0 and year >= 1980
)
group by 1 order by 1
这种方法为父亲年龄列计算第 25、50 和 75 个百分点。 percentile_cont 函数是一个分析函数，这意味着它为每条记录返回一个结果，并且需要进行聚合以创建汇总统计数据。上面的查询显示了如何使用 BigQuery 计算由 R summary 函数提供的相同统计数据，同时按出生年份对数据进行分区。该查询生成下表，其中显示了关于父亲年龄的统计信息。
Birth Summary Statistics by Year (Father Age)
这些数据中有一些有趣的趋势值得注意。第一个是 99 年的一致值，作为最大父亲年龄。这可能是数据质量问题，当父亲的年龄未知时，99 可能被设置为年龄。另一个趋势是，父亲的平均年龄逐年增加，从 1980 年的 28 岁增加到 2005 年的 32 岁。对于第一个孩子来说，这并不正常，但汇总统计数据确实表明了一种趋势，即家庭开始晚育。
测绘
汇总统计数据提供了一种快速获取数据集快照的方法，但通常不能很好地概述数据是如何分布的。为了更完整地理解数据集的形状，用各种方法绘制数据是很有用的，比如使用直方图。
hist(df$weight_pounds, main = "Distribution of Birth Weights",
xlab = "Weight")
上面的 R 代码显示了如何在我们的采样数据集中绘制出生体重的直方图。结果是下面的直方图，它似乎表明值是正态分布的。大多数新生儿的体重在 6 到 9 磅之间。
Distribution of Birth Weights in the Sampled Natality Data Set
直方图对于可视化分布是有用的，但是它们确实有许多问题，例如桶的数量影响分布是单峰还是双峰。直接从直方图中确定百分位数通常也很困难。累积分布函数(CDF)是一种能够更好地传达这类信息的可视化方法。下面的代码展示了如何可视化相同的数据，但是使用了 CDF 而不是直方图。
plot(ecdf(df$weight_pounds), main = "CDF of Birth Weights",
xlab = "Weight", ylab = "CDF")
该代码应用经验累积分布函数，类似于计算运行总和并除以数据集中的实例总数。CDF 图的一个主要好处是，您可以直接从可视化中读取百分位值。这两种类型的可视化都可以使用 SQL 生成，然后在 Excel 等工具中绘制结果，但直方图通常计算成本较低，因为它们不需要分析函数。
The same data, plotted as a Cumulative Distribution Function (CDF)
在研究数据集时，另一个有用的技巧是变换要素，例如应用对数变换。当数据集不是正态分布时，这很有用。例如，会话数据通常是具有长尾的单侧分布，应用对数变换通常可以在绘制时提供更好的数据汇总。
hist(df$gestation_weeks, main = "Gestation Weeks", xlab = "Weeks")
hist(log(df$gestation_weeks),
main = "Gestation Weeks (Log Transform)", xlab = "log(Weeks)")
上面的代码显示了如何使用对数转换来转换妊娠周数特征。这对于具有长尾且只有正值的分布很有用。代码生成了下面两个图，它们显示了相似的结果。对于这个例子来说，转换是没有用的，但是当您需要将数据从偏态分布拟合到更接近正态分布时，这是一个值得探索的技巧。您也可以应用平方根变换来生成有用的图。
Log Transforming Gestation Weeks and Plotting Histograms
直接传达百分位数信息的 CDFs 的替代方法是箱线图。箱形图显示了第 25、50 和 75 个百分位数，以及四分位数范围和异常值。在比较不同数据分区的中值时，这种类型的图通常很有用。
sample <- df[df$ever_born <= 6, ]
sample$ever_born <- sample$ever_born - 1
boxplot(weight_pounds~ever_born,data=sample, main="Birth Weight vs Prior Births",
xlab="Prior Children Delivered", ylab="Birth Weight")
上面的代码片段显示了一个在 R 中创建盒状图的例子。该代码根据母亲分娩的前几个孩子的数量，创建了一个不同四分位数范围的图。该图没有显示出明显的模式，但看起来第一个分娩的孩子比母亲分娩的其他孩子的体重略轻。
Birth weight based on number of previous children.
另一种有用的可视化是散点图，它比较数据集中两个不同特征的值。散点图可用于显示两个要素是强相关还是弱相关。下面的 R 代码显示了如何绘制妊娠期和出生体重的比较图。我过滤掉了孕育期超过 90 周的值，因为这些是可疑记录。
sample <- df[1:10000, ]
sample <- sample[sample$gestation_weeks < 90, ]
plot(sample$gestation_weeks, sample$weight_pounds, main = "Birth Weight vs Gestation Weeks",
xlab= " Gestation Weeks", ylab = "Birth Weight")
结果如下图所示。从图中可以清楚地看出，明显较短的妊娠期会导致较低的出生体重，但对于超过 35 周的妊娠期，这种相关性有多强还不清楚。总体而言，对于样本数据集，这些要素的 R 平方值为 0.25。为了确定哪些特征与出生体重相关，我们需要使用下一节讨论的不同方法。
A comparison of the gestation period and birth weight features.
相关分析
了解某些特征是否可以预测数据集中的其他值非常有用。例如，如果我们知道使用某个产品特性的用户比其他用户保留的时间更长，这就为产品开发提供了有用的洞察力。相关性分析有助于了解数据集中哪些要素是相关的。每个要素都与数据集中的所有其他要素进行比较。然而，通常目标只是理解单个特征之间的相关性，而不是完整的比较矩阵。
避免仅基于相关性分析得出强有力的结论也很重要，因为不可能建立因果关系。通常，更专注的用户会探索应用程序提供的更多选项，所以试图驱使用户执行特定的操作并不一定会增加用户的保留率。例如，在应用程序中添加社交关系可以提高用户的留存率，但促使用户在应用程序中添加朋友可能不会带来长期用户留存的预期结果。最好使用受控方法进行实验，我将在以后的帖子中讨论这一点。
r 有一个用于执行相关性分析的内置函数。 cor 函数使用指定的方法计算数据帧中所有不同列之间的相关性。pearson 方法在处理连续值时很有用，而 spearman 方法在处理离散值(如调查数据)时很有用。下面的 R 代码片段展示了一个计算相关矩阵的例子。
res <- cor(df, method = "pearson", use = "complete.obs")
res <- ifelse(res > 0, res^.5, -abs(res)^.5)
library(corrplot)
corrplot(res, type = "upper", order = "hclust", tl.col = "black")
为了可视化结果，我包含了 corrplot 库，它创建了一个矩阵图。我注意到数据集中不同特征之间的相关性很弱，所以我应用了平方根变换使结果更具可读性。结果图如下图所示。如前所述，妊娠期不是决定出生体重的最重要因素。多胎实际上是出生体重最强的预测因素。
Correlation Matrix for the Natality Data Set (R-values have been square-rooted for visibility).
与绘制直方图类似，在计算相关性时尝试不同的要素变换很有用。例如，在预测房价时，房屋平方英尺的对数变换通常比原始平方英尺值更能反映房屋价值。
特征重要性
通常，探索数据集的目标是确定哪些特征对预测结果有用。这类似于相关性分析，但不是孤立地评估每个特征的影响，而是在包括所有其他特征时确定单个特征的重要性。相关性分析是理解特征的边际效应的一种方式，而特征重要性是理解特征的独特效应的一种方式。这对于处理高度相关的特性很有用，比如会话数量与总会话长度之比。两者都可能与用户保持度相关，但其中一个特征比另一个特征更能说明问题。石灰是这种值得探索的分析类型的概括。
虽然下一篇文章将更详细地介绍预测建模，但我们将在这里使用一个简单的线性模型来展示如何执行特征分析。本例的目标是预测出生体重，这是一个连续的特征。考虑到这个问题规范，回归非常适合预测结果。我们可以建立一个线性回归模型，然后评估模型中不同特征的重要性，以确定哪些因素是结果的强预测因素。下面的代码示例显示了如何在 R 中构建一个线性回归模型，并使用不同的方法来度量功能的重要性。
library(relaimpo)
fit <- lm(weight_pounds ~ . , data = df)
boot <- boot.relimp(fit, b = 10,
type = c("lmg", "first", "last", "pratt"),
rank = TRUE, diff = TRUE, rela = TRUE)booteval.relimp(boot)
plot(booteval.relimp(boot,sort=TRUE))
这个脚本的结果显示在下面的图中。使用不同的方法对特征进行加权，所有这些方法都表明，多元性是决定出生体重的最强特征。该脚本首先通过将 weight_points 指定为目标值来拟合线性回归模型，然后使用相对重要性库来确定哪些特征在决定结果方面是重要的。
Feature Weighting for the Natality data set.
结论
探索性数据分析是初创公司数据科学家的关键能力之一。您应该能够挖掘新的数据集，并根据结果确定如何改进您的产品。EDA 是一种理解数据集形状、探索数据中的相关性以及确定是否存在基于不同特征的结果建模信号的方法。
探索性分析通常涉及一些轻量级建模，以确定数据集内不同特征的重要性。在下一篇文章中，我们将深入探讨预测建模，它侧重于基于许多不同的特征来估计结果。
创业数据科学:简介
Source: rawpixel at pixabay.com
我最近换了行业，加入了一家初创公司，负责建立数据科学学科。当我加入时，我们已经有了一个可靠的数据管道，但我们还没有可重复分析、放大模型和执行实验的流程。这一系列博客文章的目标是概述如何为初创公司从头构建数据科学平台，提供使用谷歌云平台(GCP)的真实示例，读者可以自己尝试。
本系列面向希望超越模型培训阶段，构建对组织有影响的数据管道和数据产品的数据科学家和分析师。然而，对于那些希望更好地了解如何与数据科学家合作进行实验和构建数据产品的其他学科来说，它也可能是有用的。它面向有编程经验的读者，将包括主要用 R 和 Java 编写的代码示例。
为什么是数据科学？
为你的初创公司雇佣数据科学家时，首先要问的问题之一是
数据科学将如何改进我们的产品？在意外之财数据，我们的产品是数据，因此数据科学的目标与公司的目标非常一致，即建立最准确的模型来估计净资产。在其他组织，如移动游戏公司，答案可能不那么直接，数据科学可能更有助于理解如何运营业务，而不是改进产品。然而，在这些早期阶段，开始收集关于客户行为的数据通常是有益的，这样你就可以在未来改进产品。
在初创企业中使用数据科学的一些好处包括:
- 确定要跟踪和预测的关键业务指标
- 构建客户行为的预测模型
- 运行实验来测试产品变化
- 构建支持新产品功能的数据产品
许多组织在前两三个步骤上停滞不前，没有充分利用数据科学的潜力。这一系列博客文章的目标是展示托管服务如何用于小型团队，以超越仅用于计算业务运营指标的数据管道，并过渡到数据科学为产品开发提供关键输入的组织。
系列概述
以下是我计划在这个博客系列中涉及的主题。当我写新的章节时，我可能会添加或移动章节。如果你觉得还有其他的话题需要讨论，请在文章的最后提供评论。
- **简介(这篇文章)😗*提供了在创业公司使用数据科学的动机，并概述了这一系列文章所涵盖的内容。类似的帖子还有数据科学的功能、缩放数据科学和我的 FinTech 之旅。
- 跟踪数据: 讨论了从应用程序和网页中捕获数据的动机，提出了收集跟踪数据的不同方法，介绍了隐私和欺诈等问题，并用 Google PubSub 给出了一个例子。
- 数据管道: 介绍了分析和数据科学团队收集数据的不同方法，讨论了平面文件、数据库和数据湖的方法，并介绍了使用 PubSub、DataFlow 和 BigQuery 的实现。类似的帖子包括一个可扩展的分析管道和游戏分析平台的演变。
- 商业智能: 确定 ETL、自动化报告/仪表板以及计算业务运营指标和 KPI 的常见实践。用 R Shiny 和 Data Studio 给出了一个例子。
- 探索性分析 : 涵盖用于挖掘数据的常见分析，如构建直方图和累积分布函数、相关性分析以及线性模型的特征重要性。使用出生率公共数据集进行示例分析。类似的帖子还有聚类前 1% 和 10 年数据科学可视化。
- 预测建模 : 讨论有监督和无监督学习的方法，并介绍流失和交叉提升预测模型，以及评估离线模型性能的方法。
- 模型制作 : 展示了如何扩大离线模型的规模，对数百万条记录进行评分，并讨论了模型部署的批处理和在线方法。类似的帖子还有在 Twitch 制作数据科学和用数据流制作模型。
- **实验:**介绍产品的 A/B 测试，讨论如何建立一个实验框架来运行实验，并给出一个使用 R 和 bootstrapping 的实例分析。类似岗位包括分阶段推出的 A/B 测试。
- **推荐系统:**介绍了推荐系统的基础知识，并提供了一个为生产系统扩展推荐器的示例。类似的帖子还有原型推荐。
- **深度学习:**简单介绍了最适合通过深度学习解决的数据科学问题，例如将聊天消息标记为攻击性的。提供了使用 R 接口到 Keras 的原型模型和使用 R 接口到 CloudML 的产品化的例子。
工具作业
在整个系列中，我将展示构建在 Google 云平台上的代码示例。我选择这个云选项，因为 GCP 提供了许多托管服务，使小团队可以建立数据管道，将预测模型产品化，并利用深度学习。还可以注册 GCP 的免费试用，并获得 300 美元的积分。这应该涵盖了本系列中介绍的大多数主题，但如果您的目标是深入研究云上的深度学习，它将很快过期。
对于编程语言，我将使用 R 编写脚本，Java 用于生产，SQL 用于处理 BigQuery 中的数据。我还将介绍其他工具，如 Shiny。推荐一些 R 和 Java 的经验，因为我不会涉及这些语言的基础。
本·韦伯是游戏行业的数据科学家，曾在电子艺界、微软工作室、黎明游戏和 Twitch 任职。他还在一家金融科技初创公司担任第一位数据科学家。
创业公司的数据科学:模型生产
Source: cwizner at pixabay.com
我正在进行的关于在创业公司建立数据科学学科系列的第七部分。你可以在 简介 中找到所有帖子的链接，还有一本基于这个系列的关于 亚马逊 的书。
数据科学家可以为初创公司提供价值的一个重要方式是构建可用于改进产品的数据产品。从模型训练到模型部署的转变意味着学习一套全新的工具来构建生产系统。模型的产品化意味着数据科学团队需要支持运营问题，以维护一个活跃的系统，而不仅仅是输出一个报告或模型的规范。
我用来缓解这种过渡的一种方法是托管工具，如 Google Dataflow，它为将模型投入生产提供了一种托管和可扩展的解决方案。本文中讨论的大多数方法都使用无服务器方法，因为它通常比手动配置服务器更适合初创公司。使用像 Dataflow 这样的工具还可以使数据科学家与工程团队更紧密地合作，因为它可以建立一个暂存环境，其中数据管道的一部分可以在部署之前进行测试。初创公司的大多数早期数据科学家也可能通过构建数据产品来扮演 ML 工程师的角色。
数据科学家应该拥有缩放模型所需的工具，而不是依赖工程团队将模型规范转化为生产系统。我过去完成这项工作的方法之一是使用预测模型标记语言( PMML )和谷歌的云数据流。以下是我推荐的构建和部署模型的工作流程:
- 用 R 或 Python 训练离线模型
- 将模型翻译到 PMML
- 使用数据流作业获取 PMML 模型用于生产
这种方法使数据科学家能够在本地处理用于训练模型的采样数据集，然后在完整的数据集上使用生成的模型规范。第三步可能需要工程团队的一些初始支持，但只需要设置一次。使用这种方法意味着数据科学家可以使用 PMML 支持的任何预测模型，利用托管数据流服务意味着团队无需担心维护基础架构。
在这篇文章中，我将讨论几种不同的模型产品化方法。首先，我讨论了如何在 R 中训练一个模型并将规格说明输出到 PMML。接下来，我提供了两种模型部署的例子:批处理和实时。最后，我将讨论一些我见过的团队用于产品化模型的定制方法。
构建模型规范
为了建立一个预测模型，我们将再次使用出生率公共数据集。在这篇文章中，我们将建立一个线性回归模型来预测出生体重。用于执行模型构建和导出过程的完整笔记本可在线获得。脚本的第一部分从 BigQuery 下载数据，并将结果存储在数据框中。
**library**(bigrquery)
project <- "gcp_project_id"sql <- "
SELECT year, plurality, apgar_5min, mother_age, father_age,
gestation_weeks, ever_born, mother_married, weight_pounds
FROM `bigquery-public-data.samples.natality`
order by rand()
LIMIT 10000
"df <- query_exec(sql, project = project, use_legacy_sql = FALSE)
接下来，我们训练一个线性回归模型来预测出生体重，并计算误差指标:
lm <- lm(weight_pounds ~ ., data = df)
summary(lm)cor(df$weight_pounds, predict(lm, df))
mean(abs(df$weight_pounds - predict(lm, df))) sqrt(mean(abs(df$weight_pounds - predict(lm, df)^2)))
这会产生以下结果:
- 相关系数:0.335
- 平均误差:0.928
- RMSE: 6.825
模型性能相当弱，可以探索其他算法和功能来改进它。由于这篇文章的目标是专注于将模型产品化，因此经过训练的模型就足够了。
下一步是将训练好的模型翻译成 PMML。 r2pmml R 包和 jpmml-r 工具使这一过程变得简单，并支持多种不同的算法。第一个库将 R 模型对象直接转换成 PMML 文件，而第二个库需要将模型对象保存到 RDS 文件，然后运行命令行工具。我们使用第一个库直接进行翻译:
**library**(r2pmml)
r2pmml(lm, "natality.pmml")
这段代码生成了下面的 pmml 文件。PMML 文件格式指定用于模型的数据字段、要执行的计算类型(回归)以及模型的结构。在这种情况下，模型的结构是一组系数，定义如下:
<RegressionTable intercept="7.5619">
<NumericPredictor name="year" coefficient="3.6683E-4"/>
<NumericPreda ictor name="plurality" coefficient="-2.0459"/>
<NumericPredictor name="apgar_5min" coefficient="9.4773E-5"/>
...
<NumericPredictor name="mother_married" coefficient="0.2784"/>
</RegressionTable>
我们现在有了一个模型规范，可以将其产品化并应用于我们的整个数据集。
批量部署
在批处理部署中，模型被应用于大量记录，结果被保存以备后用。这与实时方法不同，后者几乎实时地将模型应用于单个记录。可以将批处理方法设置为定期运行，例如每天运行，或者根据需要临时运行。
SQL 查询 我将用来执行批处理模型部署的第一种方法是最容易采用的方法之一，因为它直接使用 BigQuery，并且不需要增加额外的服务器。这种方法通过在查询中直接编码模型逻辑来应用模型。例如，我们可以如下应用 PMML 文件中指定的线性回归模型:
select weight_pounds as actual,
+ 11.82825946749738
+ year * -0.0015478882184680862
+ plurality * -2.1703912756511254
+ apgar_5min * -7.204416271249425E-4
+ mother_age * 0.011490472355621577
+ father_age * -0.0024906543152388157
+ gestation_weeks * 0.010845982465606988
+ ever_born * 0.010980856659668442
+ case when mother_married then 1 else 0 end * 0.26494217739205
as predicted
from records
结果是，数据集中的每条记录现在都有一个预测值，该值是根据模型规范计算的。对于这个例子，我手动将 PMML 文件转换为 SQL 查询，但是您可以构建一个工具来执行这个功能。因为所有的数据都已经在 BigQuery 中，所以这个操作运行起来相对较快，执行起来也不昂贵。还可以根据 SQL 中带有现有标签的记录来验证模型:
select sum(1) as records
,corr(actual, predicted) as Correlation
,avg(abs(actual - predicted)) as MAE
,avg(abs( (predicted - actual)/actual )) as Relative
from predictions
该查询的结果表明，我们的模型的平均绝对误差为 0.92 lbs，相关系数为 0.33，相对误差为 15.8%。使用 SQL 并不局限于线性回归模型，可以广泛应用于不同类型的模型，甚至深网。下面是如何修改前面的查询来计算逻辑回归而不是线性回归:
1/(1 + exp(-1*(
--regression calculation
)))as predicted
我过去也使用这种方法来部署增强模型，比如 AdaBoost。当模型的结构相对简单，并且您需要数据库中的模型结果时，这很有用。
数据流—大查询
Components in the BigQuery Batch Model Deployment
如果您的模型更复杂，Dataflow 为部署模型提供了一个很好的解决方案。当使用 Dataflow Java SDK 时，您可以定义一个要在一组对象上执行的操作图，该服务将根据需要自动提供硬件进行扩展。在这种情况下，我们的图是一组三个操作:从 BigQuery 读取数据，计算每条记录的模型预测，并将结果写回 BigQuery。该流水线生成以下数据流 DAG:
The Dataflow graph of operations used in this tutorial.
我使用 IntelliJ IDEA 来创作和部署数据流作业。虽然设置 Java 环境超出了本教程的范围，但是用于构建项目的 pom 文件可以在这里获得。它包括对数据流 sdk 和 JPMML 库的以下依赖关系:
<dependency>
<groupId>com.google.cloud.dataflow</groupId>
<artifactId>google-cloud-dataflow-java-sdk-all</artifactId>
<version>2.2.0</version>
</dependency><dependency>
<groupId>org.jpmml</groupId>
<artifactId>pmml-evaluator</artifactId>
<version>1.3.9</version>
</dependency>
如上图所示，我们的数据流工作由三个步骤组成，我们将详细介绍这三个步骤。在讨论这些步骤之前，我们需要创建管道对象:
PmmlPipeline.Options options = PipelineOptionsFactory
.fromArgs(args).withValidation().as(PmmlPipeline.Options.class);
Pipeline pipeline = Pipeline.create(options);
我们创建一个管道对象，它定义了应用于对象集合的一组操作。在我们的例子中，管道正在对一组 TableRow 对象进行操作。我们将一个选项类作为输入传递给 pipeline 类，该类为数据流作业定义了一组运行时参数，例如用于运行作业的 GCP 临时位置。
管道中的第一步是从公共 BigQuery 数据集中读取数据。从这一步返回的对象是 TableRow 对象的一个p 集合。特征查询字符串定义要运行的查询，并且我们指定在运行查询时要使用标准 SQL。
private static final String featureQuery =
"SELECT year, plurality, apgar_5min ... weight_pounds\n" +
"FROM `bigquery-public-data.samples.natality`";pipeline.apply(BigQueryIO.read().fromQuery(featureQuery)
.usingStandardSql().withoutResultFlattening())
下一步是将模型预测应用于数据集中的每条记录。我们定义了一个 PTransform 来加载模型规范，然后应用一个 DoFn 在每个 TableRow 上执行模型计算。
.apply("PMML Application", new PTransform<PCollection<TableRow>,
PCollection<TableRow>>() {model = new RegressionModelEvaluator(PMMLUtil.unmarshal(
Resources.getResource("natality.pmml").openStream()));return input.apply("To Predictions", ParDo.of(
new DoFn<TableRow, TableRow>() {
@ProcessElement
public void processElement(ProcessContext c) throws Exception {
/* Apply Model */
}})))
应用模型代码段如下所示。它检索 TableRow 以创建估计值，为 pmml 对象创建输入字段的映射，使用模型来估计出生体重，创建新的 TableRow 以存储出生的实际和预测体重，然后将该对象添加到 DoFn 的输出中。总而言之，这个应用步骤加载模型，定义一个函数来转换输入集合中的每个记录，并创建预测对象的输出集合。
TableRow row = c.element();HashMap<FieldName, Double> inputs = new HashMap<>();
for (String key : row.keySet()) {
if (!key.equals("weight_pounds")) {
inputs.put(FieldName.create(key), Double
.parseDouble(row.get(key).toString()));
}
}Double estimate =(Double)model.evaluate(inputs)
.get(FieldName.create("weight_pounds"));TableRow prediction = new TableRow(); prediction.set("actual_weight", Double.parseDouble(
row.get("weight_pounds").toString())); prediction.set("predicted_weight", estimate);c.output(prediction);
最后一步是将结果写回 BigQuery。在本课的前面，我们定义了将记录写回 BigQuery 时要使用的模式。
List<TableFieldSchema> fields = new ArrayList<>();
fields.add(new TableFieldSchema()
.setName("actual_weight").setType("FLOAT64"));
fields.add(new TableFieldSchema()
.setName("predicted_weight").setType("FLOAT64"));
TableSchema schema = new TableSchema().setFields(fields);.apply(BigQueryIO.writeTableRows()
.to(String.format("%s:%s.%s", PROJECT_ID, dataset, table))
.withCreateDisposition(BigQueryIO.Write.CreateDisposition
.CREATE_IF_NEEDED).withSchema(schema));pipeline.run();
我们现在已经定义了一个管道，可以运行它来为整个数据集创建预测。这个类的完整代码清单可以在这里找到。运行这个类将启动一个数据流作业，该作业将生成上面显示的 DAG，并将提供许多 GCE 实例来完成该作业。下面是一个用于运行此管道的自动缩放示例:
Autoscaling the Model Predicting Task
当作业完成时，输出是 BigQuery 项目中的一个新表，它存储了出生率数据集中所有记录的预测和实际权重。如果我们想要运行一个新的模型，我们只需要在数据流作业中指向一个新的 PMML 文件。运行离线分析和数据流项目所需的所有文件都可以在 Github 上获得。
数据流—数据存储
Components in the Datastore Batch Model Deployment
通常，部署模型的目标是使结果对端点可用，以便应用程序可以使用它们。过去的两种方法将结果写入 BigQuery，这不是存储需要在事务中使用的数据的最佳位置。本节讨论的数据管道不是将结果写入 BigQuery，而是将结果写入 Datastore，web 服务或应用程序可以直接使用 Datastore。
执行此任务的管道重用前面管道的前两部分，从 BigQuery 读取记录并创建具有模型预测的 TableRow 对象。我在管道中添加了两个步骤，将 TableRow 对象转换为数据存储实体，并将结果写入数据存储:
.apply("To Entities", ParDo.of(new DoFn<TableRow, Entity>() { @ProcessElement
public void processElement(ProcessContext c) throws Exception {
TableRow row = c.element(); // Create a lookup key for the record
String keyName = "Record" + row.get("recordID").toString();
Key.Builder keyBuilder = Key.newBuilder();
Key.PathElement.Builder path = Key.PathElement.
newBuilder().setKind("Profile").setName(keyName);
keyBuilder.addPath(path);
Key key = keyBuilder.build(); // set the experiment group
String expGroup = Double.parseDouble(row.get("predicted_weight")
.toString()) >= 8 ? "Control" : "Treatment";
Value value = Value.newBuilder().
setStringValue(expGroup).build(); // create an entity to save to Datastore
Entity.Builder builder = Entity.newBuilder().setKey(key);
builder.putProperties("Experiment", value);
c.output(builder.build());
}
}))
.apply(DatastoreIO.v1().write().withProjectId(PROJECT_ID));
数据存储是一个 NoSQL 数据库，可由应用程序直接使用。要创建数据存储条目的实体，您需要创建一个键。在这个例子中，我使用了一个 recordID，它是使用 BigQuery 中的 row_number() 函数为出生记录生成的惟一标识符。该键用于存储关于配置文件的数据，可以使用该键作为查找来检索该数据。该操作的第二步是根据预测的出生体重，将记录分配给对照组或治疗组。这种方法对于手机游戏可能很有用，在手机游戏中，有很高购买可能性的用户可以被放入一个实验组，该实验组提供购买的提示。该代码片段的最后一部分构建实体对象，然后将结果传递给 Datastore。
存储在数据存储中的结果实体可以在客户端应用程序或 web 服务中使用。下面的 Java 代码片段展示了如何从数据存储中检索值。例如，基于预测模型的输出，可以使用 web 服务来检查登录时提供给用户的报价。
public static void main(String[] args) {
Datastore datastore =
DatastoreOptions.getDefaultInstance().getService();
KeyFactory keyFactory =
datastore.newKeyFactory().setKind("Profile"); // get a user profile
Entity profile = datastore.get(keyFactory.newKey("User101"));
System.out.println(profile.getString("Experiment"));
}
实时部署
到目前为止，我们介绍的方法都有很大的延迟，并且对于创建实时预测没有用，比如根据用户当前的会话活动为他们推荐新内容。为了近乎实时地构建预测，我们需要使用不同类型的模型部署。
Web 服务 为模型提供实时预测的方法之一是建立一个计算输出的 Web 服务。因为我们已经在关于跟踪数据的帖子中讨论了 Jetty，所以我们将在这里重用它来完成这项任务。为了使这种方法有效，您需要将所有的模型输入指定为 web 请求的一部分。或者，您可以从像 Datastore 这样的系统中检索值。下面是一个使用 Jetty 和 JPMML 实现实时模型服务的示例:
public void handle(...) throws IOException, ServletException {
// load the PMML model
final ModelEvaluator<RegressionModel> evaluator;
try {
evaluator = new RegressionModelEvaluator(PMMLUtil.unmarshal(
Resources.getResource("natality.pmml").openStream()));
}
catch (Exception e) {
throw new RuntimeException(e);
} // create a map of inputs for the pmml model
HashMap<FieldName, Double> inputs = new HashMap<>();
for (String attribute : modelFeatures) {
String value = baseRequest.getParameter(attribute);
inputs.put(FieldName.create(attribute),
Double.parseDouble(value));
} // output the estimate
Double estimate =(Double)evaluator.evaluate(inputs).
get(FieldName.create("weight_pounds"));
response.setStatus(HttpServletResponse.SC_OK);
response.getWriter().println("Prediction: " + estimate);
baseRequest.setHandled(true);
}
该代码处理一个消息请求，其中包含使用模型输入值的参数。该代码片段首先加载 PMML 规范，使用 web 请求参数创建要素的输入地图，应用赋值器获取预测值，并将结果作为输出写入。模型特征数组包含 PMML 文件中指定的特征列表。可以通过以下方式向服务提出请求:
[http://localhost:8080/&year=2000&plurality=1&apgar_5min=0&mother_age=30&father_age=28&gestation_weeks=40&ever_born=1&mother_married=1](http://localhost:8080/?year=2000&plurality=1&apgar_5min=0&mother_age=30&father_age=28&gestation_weeks=40&ever_born=1&mother_married=1)
在浏览器中输入这个 URL 的结果是一个网页，其中列出了 7.547 磅的预测体重。实际上，您可能希望使用消息编码，比如 JSON，而不是传递原始参数。这种方法很简单，延迟相对较低，但是需要管理服务。向上扩展很容易，因为每个模型应用都可以独立执行，并且在提供预测后不会更新任何状态。
数据流—发布订阅
Components in the PubSub Live Model Deployment
也可以在流模式下使用数据流来提供实时预测。我们在数据管道上的 post 中使用了流式数据流，以便将事件流式传输到 BigQuery 和下游的 PubSub 主题。我们可以使用类似的方法进行模型预测，使用 PubSub 作为数据流作业的源和目的地。下面的 Java 代码展示了如何设置一个数据管道，该管道使用来自 PubSub 主题的消息，应用模型预测，并将结果作为消息传递给输出 PubSub 主题。该代码片段不包括加载 PMML 文件的过程，我们在本文前面已经介绍过了。
// Read messages from PubSub
PCollection<PubsubMessage> events = pipeline
.apply(PubsubIO.readMessages().fromTopic(inboundTopic));// create a DoFn for applying the PMML model to instances
events.apply("To Predictions", ParDo.of(
new DoFn<PubsubMessage, PubsubMessage>() {@ProcessElement
public void processElement(ProcessContext c) throws Exception {
PubsubMessage row = c.element(); // create a map of inputs for the pmml model
HashMap<FieldName, Double> inputs = new HashMap<>();
for (String key : row.getAttributeMap().keySet()) {
if (!key.equals("weight_pounds")) {
inputs.put(FieldName.create(key),
Double.parseDouble(row.getAttribute(key)));
}
} // get the estimate
Double estimate = (Double)evaluator.evaluate(inputs).
get(FieldName.create("weight_pounds")); // create a message with the prediction
String message = "Prediction:" + estimate;
PubsubMessage msg = new PubsubMessage(
message.getBytes(), new HashMap());
c.output(msg);
}}
.apply(PubsubIO.writeMessages().to(outboundTopic));
该代码从传入的主题中读取一条消息，然后从该消息中解析不同的属性，以用作模型的特征输入。结果保存在传递给出站主题的新消息中。由于数据流作业设置为在流模式下运行，管道将在收到消息时近乎实时地处理消息。这条管道的完整代码清单可以在 Github 上找到。
在实践中，PubSub 可能有太多的延迟，这种方法对于在应用程序中直接处理 web 请求来说是无用的。当需要将预测传递给系统中的其他组件时，这种类型的方法非常有用。例如，它可以用来实现一个用户保留系统，向有高流失可能性的移动游戏用户发送有针对性的电子邮件。
定制工程 提供实时模型部署的其他可行方法有 Spark streaming、AWS Lambda 和 Kinesis analytics(针对简单模型)。
有时，数据科学团队不可能直接构建数据产品，因为需要应用模型的系统属于不同的工程团队。例如，电子艺界使用预测模型来改善匹配平衡，而构建该模型的团队可能无法直接访问执行该模型的游戏服务器。在这样的场景中，有必要有一个可以在两个团队之间传递的模型规范。虽然 PMML 是这里的一个选项，但定制模型规范和编码在行业中很常见。
过去，当数据科学团队需要与远程工程团队合作时，我也见过这种流程崩溃。如果一个模型需要被翻译，比如说从一个 Python 笔记本到 Go 代码，在翻译过程中可能会出现错误，这个过程可能会很慢，而且一旦部署了模型，就不可能对其进行修改。
结论
为了给初创公司提供价值，数据科学家应该能够构建支持新功能的数据产品。这可以通过与工程团队合作来完成，也可以由数据科学单独负责。我对初创公司的建议是，在构建数据产品时使用无服务器技术，以降低运营成本，并实现更快的产品迭代。
这篇文章介绍了将模型产品化的不同方法，从直接在 SQL 查询中编码逻辑到构建 web 服务，再到在数据流任务中使用不同的输出组件。将模型产品化的结果是，现在可以在产品中使用预测来构建新功能。
我还介绍了根据预测结果将用户分成不同实验组的想法。在下一篇文章中，我将讨论可以使用的不同实验方法，包括 A/B 测试和分阶段推出。
创业数据科学:模型服务
Source: maxpixel.net
为了让数据科学家在初创公司高效工作，他们需要能够构建其他团队可以使用的服务，或者产品可以直接使用的服务。例如，数据科学家不应该仅仅定义一个预测用户流失的模型，而应该能够建立一个端点，为玩家流失的可能性提供实时预测。本质上，目标是提供一个模型作为服务，或者产品可以直接使用的功能调用。
鉴于初创公司的规模较小，数据科学家能够在不需要工程支持的情况下站起来支持一个端点是很有用的。团队实现这一功能的方法之一是使用 AWS Lambda 或 GCP 的云服务。这些通常被称为无服务器计算，但另一种看待它们的方式是功能即服务。AWS lambda 等工具使数据科学团队能够建立面向客户的服务，同时最大限度地减少支持实时服务的开销。
在我的模型生产帖子中，我介绍了这些服务的一些替代方法，其中讨论了如何使用 Jetty 将模型预测设置为 web 端点。这种方法的主要问题是，数据科学团队现在需要维护一个 web 服务器，这可能不是团队专业知识的一部分。我还讨论了使用 PubSub 进行接近实时的预测，但是这种方法不适合提供需要毫秒级延迟来生成预测的端点。
这种类型的功能提供亚毫秒级延迟的模型预测，可以归类为提供模型即服务。AWS lambda 提供了一种实现这些功能的好方法，但是确实需要一些设置来使用通用 ML 库。这篇文章的目的是展示如何使用 AWS lambda 来设置一个可以提供模型预测的端点。它可用于大多数可使用 pickle 序列化的 scikit-learn 型号。我首先讨论设置一个公开在开放 web 上的函数，然后展示如何将 sklearn 预测打包成函数。
这篇文章建立在我之前的文章中讨论的 AWS 设置之上。它假设您已经设置了一个 AWS 帐户，并分配了一个具有 S3 访问权限的角色。这篇教程的完整源代码可以在 GitHub 上找到。
创建测试函数
AWS lambda 使团队能够编写服务或 web 客户端可以调用的功能，而无需设置任何基础设施。它被称为无服务器，因为团队专注于编写功能而不是构建系统。首先，我们将设置一个 Hello World 函数，该函数解析输入参数并将参数作为响应的一部分返回。对于本教程，我主要关注 web 请求，其中参数作为查询字符串的一部分输入，响应是一个 web 请求，请求体包含 html 内容。我们将首先设置一个测试功能，然后使用 API 网关将该功能暴露给开放的 web。
第一步是登录 AWS 控制台，然后深入 lambda 屏幕。首先，我们将使用 Python 3.6 和内联编辑器创建一个新函数，如下所示。
Creating our first lambda function
对于没有外部依赖的简单函数，您可以使用“内联编辑代码”功能直接在 AWS web 界面中创作 lambda 函数。对于更复杂的函数，我们需要在本地或 EC2 实例上编写代码，然后上传打包的函数。
创建并保存一个函数后，您应该能够使用“test”按钮来测试它。这将提示一个对话框，您可以在其中配置发送给该函数的参数，我们现在将其留空，但在下一步中进行修改。继续保存默认配置，然后单击“测试”。结果应该看起来像下面的对话框。
A successful run of the Hello World function.
该函数向控制台输出“Hello from Lambda ”,表明该函数调用成功。下一步，我们将希望在函数中使用参数，以便稍后我们可以将这些参数作为输入提供给模型。对于本教程，我们将使用附加到 web POST 命令的查询字符串参数，但是 lambda 可能有许多不同的配置。将服务放入 lambda 函数中是很常见的，这需要一种不同的方法来使用本文没有涉及的参数。
我们将对 AWS 定义的默认 Hello World 函数做一些修改。我添加了一个事件对象的打印语句，将消息参数附加到 Hello 语句的末尾，并修改了 return 语句以返回 web 响应而不是字符串。下面是我们新函数的代码:
def lambda_handler(event, context):
print(event)
esult = 'Hello from ' + event['queryStringParameters']['msg']
return { "body": result }
如果您尝试运行这个代码块，您将会得到一个错误。该函数试图从查询字符串参数中检索 msg 参数，这将引发一个异常，因为它未被定义。为了调用这个函数，我们需要更新我们的测试事件来提供这个参数，如下所示:
{
"queryStringParameters": { "msg": "Data Science for Startups!"}
}
如果您再次测试该函数，您现在将得到一个成功的响应:
{
"body": "Hello from Data Science for Startups!"
}
我将响应包装为 web 响应，因为我们希望将函数开放给开放的 web，如果 return 语句只提供一个字符串，lambda 函数将不能用作 web 调用。
设置 API 网关 我们现在有了一个 lambda 函数，可以在我们的虚拟私有云(VPC)中使用，但不对 web 开放。为了将该函数设置为 web 调用，我们需要配置一个 API 网关，将该函数公开给开放的 web。有了 lambda，你可以在多个函数中使用同一个网关，在本文中，我们将在测试和预测模型函数中使用同一个网关。
Setting up an API Gateway
上图显示了为 lambda 函数添加 API 网关的 GUI。您需要为网关设置一些参数，以下是我用来配置我的设置的内容:
- "创建新的 API "
- API 名称:“暂存”
- 部署阶段:“准备阶段”
- 安全性:开放
一旦你设置了这些参数，你需要再次点击保存按钮。然后，您可以单击网关来配置您的设置，如下所示。
Configuring an API Gateway
AWS lambda 提供了几种在将功能部署到野外之前测试它们的方法。上图显示了您的函数在进行调用时将使用的组件的子集，单击“TEST”提供了一种通过网关测试该函数的方法。
Testing the API Gateway
我们现在可以模拟在 web 上调用该函数。选择“POST”作为方法，并设置 msg 参数来测试功能。当您点击 test 时，您应该会得到一个类似上面显示的对话框的结果。
既然我们已经测试了 API 网关，我们终于可以向全世界部署我们的功能了。点击“Actions”->“Deploy API”之后，您应该会看到一个对话框，其中列出了您的网关的 URL。如果您点击网关 URL，您将得到一个错误，因为您需要添加函数名和 msg 参数。下面是我的端点的 URL，以及如何从 web 上调用它:
**# API Url** [https://vkdefzqrb8.execute-api.us-east-1.amazonaws.com/staging](https://vkdefzqrb8.execute-api.us-east-1.amazonaws.com/staging)**# Useable endpoint** [https://vkdefzqrb8.execute-api.us-east-1.amazonaws.com/staging/lambdaTest?msg=TheWeb](https://vkdefzqrb8.execute-api.us-east-1.amazonaws.com/staging/lambdaTest?msg=TheWeb)
在所有这些设置之后，我们现在有了一个 lambda 函数，我们可以从开放的 web 上调用它。继续尝试一下！下一步是创建一个响应传入参数提供模型预测的函数。
使用 SKLearn
如果你想使用外部库，比如在定义 lambda 函数时使用 sklearn，那么这个过程比我们刚刚讨论的要复杂一点。关键区别在于，您不能使用内联代码编辑器，而是需要设置一个目录，其中包含部署该函数所需的所有依赖项。下面是创建依赖外部库的 Python lambda 函数的一般过程:
- 在本地机器(或 EC2 实例)上创建一个工作目录
- 使用 pip -t 将库安装到这个目录
- 将所有代码和资产添加到您的工作目录中
- 将该目录的内容压缩到一个. Zip 文件中
- 上传。压缩文件到 S3
- 使用从 S3 上传的. zip 文件定义一个 lambda 函数
您可以在本地机器上完成这项工作，或者使用 EC2 实例来完成这项任务。由于我使用的是 Windows 笔记本电脑，我更喜欢 EC2 路线。我在之前关于 Python 的帖子中讨论过 EC2 的设置。以下是我用来设置环境的步骤:
**# set up Python 3.6** sudo yum install -y python36
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
sudo python36 get-pip.py
pip3 --version
下一步是在本地目录中建立外部库。通过以这种方式安装模块，您可以在定义 lambda 函数以创建模型预测时包含所有依赖项。我喜欢使用的一些库相当大(50MB+)，但是 lambda 现在毫无问题地支持这些库，最大可达 128MB。过去，你必须用一个特殊设置来构建 scikit-learn，以满足 lambda 的有效载荷需求。
**# install dependencies to a target directory** mkdir classifier
pip3 install scipy -t classifier
pip3 install pandas -t classifier
pip3 install sklearn -t classifier
cd classifier
我们现在已经为 python 模型脚本设置了库。下一步是训练一个模型，我们将把它保存为 pickle 文件。我运行了下面的脚本来输出一个模型文件(logit.pkl ),我们将在 lambda 函数中使用它。
import pandas as pd
from sklearn.externals import joblib
from sklearn.linear_model import LogisticRegressiondf = pd.read_csv(
"[https://github.com/bgweber/Twitch/raw/master/Recommendations/games-expand.csv](https://github.com/bgweber/Twitch/raw/master/Recommendations/games-expand.csv)")y_train = df['label']
x_train = df.drop(['label'], axis=1)model = LogisticRegression()
model.fit(x_train, y_train)joblib.dump(model, 'logit.pkl')
下一步是定义我们希望通过 lambda 公开的模型预测函数。我创建了一个新文件， logit.py ，其中包含了我们希望作为端点启用的预测函数:
from sklearn.externals import joblib
import pandas as pdmodel = joblib.load('logit.pkl')def lambda_handler(event, context):
p = event['queryStringParameters']
print("Event params: " + str(p))
x = pd.DataFrame.from_dict(p, orient='index').transpose()
pred = model.predict_proba(x)[0][1] result = 'Prediction ' + str(pred)
return { "body": result }
在创建 zip 文件并通过 S3 上传之前，在本地测试代码也很有用。我使用这个片段来测试预测函数:
event = { 'queryStringParameters': {'G1':1, 'G2':0, 'G3':1, 'G4':1,
'G5':0, 'G6':0, 'G7':1, 'G8':0, 'G9':1, 'G10':0 }}
lambda_handler(event, "")
我们现在有一个函数和环境设置，我们想上传到 lambda。我使用 zip 命令和 AWS CLI 将文件上传到 S3。要使用这个命令，首先需要运行aws configure。
zip -r logitFunction.zip .
aws s3 cp logit.zip s3://bucket/logitFunction.zip
我们现在有一个函数，我们已经测试并打包成 zip 文件发送到 S3。
部署功能 我们将遵循与之前相同的步骤来设置和部署该功能，其中有一个主要变化。我们现在将使用“从亚马逊 S3 上传文件”并选择我们的 zip 文件，而不是使用“内嵌代码编辑器”。我们还需要为函数指定一个入口点，它是文件名和函数名的组合。我用了: logit.lambda_handler 。
您可以使用与之前相同的步骤来测试该函数，但是我们需要包括更多的参数。该模型以 10 个参数作为输入:
G1 — G10。我更新了测试事件，以输入以下参数:
{ "queryStringParameters": {"G1":1, "G2":0, "G3":1, "G4":1,
"G5":0, "G6":0, "G7":1, "G8":0, "G9":1, "G10":0 }
}
现在，调用该函数将返回模型预测结果:
{
"body": "Prediction 0.10652960571858641"
}
最后一步是重用之前的 API 网关并部署 API。一旦一切都设置好了，您应该能够通过 API 调用模型，如下所示:
[https://vkdefzqrb8.execute-api.us-east-1.amazonaws.com/staging/logitModel?G1=1&G2=1&G3=1&G4=1&G5=1&G6=1&G7=1&G8=1&G9=1&G10=1](https://vkdefzqrb8.execute-api.us-east-1.amazonaws.com/staging/logitModel?G1=1&G2=1&G3=1&G4=1&G5=1&G6=1&G7=1&G8=1&G9=1&G10=1)
您还需要启用限制选项，以确保端点不会被滥用。我们现在已经设置了一个端点，可以在构建产品时使用。本教程将 lambda 函数设置为 web 端点，但是许多其他配置选项也是可能的。
结论
能够将模型设置为不同服务或产品可以调用的端点是很有用的。预测模型可以直接在产品中使用，例如确定是否应该在移动游戏中向用户追加销售某个项目，或者通过其他服务使用，例如确定向用户分配哪个细分市场的实验平台。
本教程展示了如何使用 AWS lambda 部署用 scikit-learn 库构建的预测模型。由于该库提供了各种各样的预测模型，因此相同的配置可以用于许多不同的用例。lambda 和 GCP 上的云功能等服务的关键优势在于，它们以服务的形式提供功能。这意味着维护服务所需的运营开销最小。它们使数据科学团队能够部署可在产品中使用的端点。
这篇文章展示了如何使用一个火车模型，它被打包成上传的 zip 文件的一部分。常用的扩展之一是从 S3 读取模型文件，这样就可以部署新的模型，而不需要重新部署 API 网关。
本·韦伯是 Zynga 的首席数据科学家。我们正在招聘！
创业公司的数据科学:预测建模
Source: Aichi8Seiran at pixabay.com
我正在进行的关于在创业公司建立数据科学学科系列的第六部分。你可以在 简介 中找到所有帖子的链接，还有一本基于这个系列的关于 亚马逊 的书。
机器学习可以用来预测未来。您提供一个包含定型实例集合的模型，使该模型适合此数据集，然后将该模型应用于新实例以进行预测。预测建模对初创公司很有用，因为你可以制造基于预期用户行为的产品。例如，如果观众一直在观看流媒体服务上的同一家广播公司，应用程序可以在启动时加载该频道。预测模型也可以用于构建数据产品，例如可以向观众推荐新广播公司的推荐系统。
这篇文章简单介绍了机器学习的预测建模。我将讨论不同类型的预测问题，介绍一些常用的方法，介绍使用开放工具和脚本语言构建模型的方法，并提供一个聚类的应用示例。这篇文章的目标不是提供对具体方法的深入理解，而是展示如何使用各种工具快速构建不同类型的模型。
预测模型的类型
机器学习模型通常分为两类:监督学习和非监督学习。对于监督问题，用于拟合模型的数据具有指定的标签或目标变量。比如，如果目标是识别一款手游中哪些用户有可能成为购买者，我们可以用过往用户的交易数据作为标签，其中 1 表示付费用户，0 表示免费用户。标签用作监督算法的输入，以在将模型拟合到训练数据集时提供反馈。分类和回归算法是监督学习的两种类型。在分类任务中，目标是预测结果的可能性，例如移动游戏用户是否会购买。对于回归来说，目标是预测一个连续变量，例如给定不同特征描述的房屋价格。
对于无监督的问题，没有为训练模型提供显式标签。最常见的无监督学习方法是聚类，它通过在数据集中形成不同实例的组来推断标签。聚类有助于回答细分问题，例如产品应该支持哪些不同的用户原型。
还有另外两类机器学习模型我就不在这里讨论了:半监督学习和强化学习。半监督学习是一种识别目标标签的过程，作为训练过程的一部分，通常用深度学习中的自动编码器来实现。强化学习是基于奖励策略更新的模型，其中模型采取的行动提供正面和负面的反馈信号，并用于更新模型。
对于一家初创公司，你可能会从分类和回归模型开始，这通常被称为经典或浅层机器学习问题。有很多种不同的方法可以使用。一些常见的分类方法是逻辑回归、朴素贝叶斯、决策树和集成方法，如随机森林和 XGBoost。常见的回归方法包括许多与分类相同的方法，但线性回归用于代替逻辑回归。十年前我读研究生时，支持向量机很流行，但现在 XGBoost 似乎是浅层学习问题之王。
了解不同的算法是如何实现的很重要，因为如果你想将预测模型作为产品的一部分，它需要是可靠的和可伸缩的。通常，在运送产品时，渴望型模型比懒惰型模型更受青睐。急切模型是在训练过程中生成规则集的方法，如线性回归模型中的系数，而懒惰模型在运行时生成规则集。例如，最近邻(k-NN)模型是一种懒惰的方法。惰性方法通常对构建在线学习系统有用，在这种系统中，模型在部署时会频繁地用新数据更新，但可能存在可伸缩性问题。
如何评估预测模型的性能取决于所执行问题的类型。例如，平均绝对误差(MAE)、均方根误差(RMSE)和相关系数等指标可用于评估回归模型，而 ROC 曲线下面积(AUC)、精度、召回率和提升率可用于分类问题。
训练分类模型
本节介绍了几种不同的方法，可用于构建分类模型。我们将使用与 EDA 上的过去帖子相同的数据集，但不是在出生率数据集中预测出生体重，而是试图预测哪些怀孕将导致双胞胎而不是单胎。
首先，我们需要在本地提取一个数据集，作为不同工具的输入。下面的 R 代码展示了如何对 100k 次怀孕进行采样并将数据帧保存到 CSV 文件中。这个查询类似于上一篇文章中的查询，但是我在 where 子句中加入了额外的约束，以避免提取缺少(NA)值的记录。
library(bigrquery)
project <- "your_project_id"
options(stringsAsFactors = FALSE)sql <- "SELECT year, mother_age, father_age, gestation_weeks
,case when ever_born > 0 then ever_born else 0 end as ever_born
,case when mother_married then 1 else 0 end as mother_married
,weight_pounds
,case when plurality = 2 then 1 else 0 end as label
FROM `bigquery-public-data.samples.natality`
where plurality in (1, 2) and gestation_weeks between 1 and 90
and weight_pounds between 1 and 20
order by rand()
LIMIT 100000"df <- query_exec(sql, project = project, use_legacy_sql = FALSE)
write.csv(df, "natality.csv", row.names = FALSE)
这个数据集的一个挑战是，这个数据集中的反面例子比正面例子多得多。在抽样数据集中，只有 2.4%的怀孕有“1”的标签，表明是双胞胎。这意味着我们需要使用除准确性之外的指标来衡量不同方法的性能。对于像这样的大类不平衡问题，准确性不是一个好的度量，因为预测每个记录的标签为 0 会导致 97.6%的准确性。相反，我们将使用 AUC 曲线度量来评估不同的模型，因为它对于处理不平衡类的问题很有用。
评估不同模型时的另一个考虑是使用不同的定型、测试和维持数据集。维持数据集保留到模型定型过程结束，并且仅用于一次评估。在构建和调整模型时，可以根据需要频繁使用训练和测试数据集。10 重交叉验证等方法对于构建模型性能的稳健估计非常有用。这是我在构建模型时通常采用的方法，但是为了简洁起见，并没有在下面所有不同的例子中涉及到。
Weka 我喜欢用来探索性分析和评估不同建模算法的工具之一是 Weka ，它是用 Java 实现的，提供了一个探索不同模型的 GUI。现在它有点过时了，但我仍然发现它对于快速挖掘数据集并确定是否有很多信号可用于预测结果非常有用。
Visualizing different features in the data set with Weka.
上图显示了数据集中不同特征的可视化效果。红色数据点代表正例(双胞胎)，蓝色数据点代表负例(单胎)。对于具有强信号的特征，通常可以画一条垂直线来分隔大部分红色和蓝色数据点。这个数据集就不是这样了，我们需要结合不同的特征来构建一个好的分类器。
我使用 Weka 研究了以下算法，并在使用 10 重交叉验证时计算了 AUC 指标:
- 逻辑: 0.892
- 朴素贝叶斯: 0.893
- LogitBoost: 0.908
在我研究的算法中，性能最好的算法是 LogitBoost。该算法具有多个超参数，例如迭代次数，可以对其进行调整以进一步提高模型的性能。Weka 中可能有其他算法在这个数据集上工作得更好，但我们最初的探索已经产生了有希望的结果。
Visualizing the ROC Curve with Weka
上图显示了逻辑回归模型的 ROC 曲线。使用 Weka 还可以探索逻辑回归模型中不同特征的重要性。您可以直接检查模型的系数。比如体重 _ 磅的系数值最高，为 0.93。还可以使用 InfoGain 属性排名器来确定哪些特征对分类任务最重要。Weka 发现体重 _ 磅(0.0415)是最有影响力的特征，其次是妊娠 _ 周(0.0243)。
Weka 通常不是产品化模型的最佳选择，但它确实为探索各种不同的算法提供了一个有用的工具。
BigML 我在创业经历中用过的另一个工具是 BigML 。这个工具类似于 Weka，因为它提供了一个 GUI(基于 web 的),用于探索不同类型的模型，而不需要任何编码。该工具的选项比 Weka 少，但有更新的模型，如 DeepNets。
Evaluating Feature Importance in a Logistic Model with BigML
上图展示了 BigML 提供的一个特性重要性工具。这些工具有助于了解哪些特征有助于预测结果。我用 BigML 研究了两种不同的模型，得出了以下 AUC 指标:
- 逻辑: 0.890
- DeepNet: 0.902
我没有使用 10 倍交叉验证，而是使用一个 80/20 的数据分割来评估不同的模型。BigML 中模型的性能与 Weka 相似，但与 LogitBoost 的性能不太匹配。
Evaluation Metrics provided by BigML
除了绘制 ROC 曲线，如上所示，BigML 还可以绘制其他有用的可视化图形，如提升图。BigML 还提供了有用的分类指标，比如精度、召回率和 F1 分数。
R — Glmnet 我们可以使用 R 中的 glm 库实现我们已经评估过的逻辑回归模型。通过指定二项式族作为输入，可以将广义线性模型函数应用于逻辑回归。加载 CSV 并训练逻辑回归模型的 r 代码如下所示。
df <- read.csv("Natality.csv")
fit <- glm(label ~ .,family=binomial(),data=df)
fitlibrary(Deducer)
rocplot(fit)
拟合模型后， fit 语句输出模型的系数。为了评估模型的性能，我使用了包含 rocplot 函数的演绎库。对于这个基本的模型拟合方法，我没有进行任何交叉验证。结果是训练数据集的 AUC 为 0.890。
ROC Curve for the logistic regression model in R.
为了在拟合 R 中的逻辑回归模型时使用正则化，我们可以使用 glmnet 库，它提供了 lasso 和 ridge 回归。下面的代码显示了一个使用这个包来评估特性重要性的例子:
library(glmnet)
x <- sparse.model.matrix(label ~ ., data = df)
y <- as.factor(df$label)fit = glmnet(x, y, family = "binomial")
plot(fit, xvar = "dev", label = TRUE)
默认情况下，使用“最小二乘法”模型来拟合训练数据。下图显示了模型的系数如何随着其他因素用作模型的输入而变化。最初，只有 weight_pounds 要素被用作输入。一旦这一项开始变得不利，大约值为-0.6，就要考虑模型的附加特征。
Feature weights based on different lambda values for glmnet.
cvfit = cv.glmnet(x, y, family = "binomial", type.measure = "auc")
cat(paste("ROC:", max(cvfit$cvlo)))
plot(cvfit)
glmnet 包提供了内置的交叉验证功能，可用于优化不同的指标，如 AUC。上面的 R 代码显示了如何使用这个特性训练一个逻辑回归模型，并在下图中绘制了结果。正则化逻辑回归模型的 AUC 度量是 0.893。
Performance (AUC) of the glmnet model based on different lambda values.
Python-scikit-learn 我想在本节介绍的另一个工具是 sci kit-learn，因为它提供了一种探索不同类型模型准确性的标准化方法。到目前为止，我一直专注于模型拟合和 EDA 的 R，但是通过 scikit-learn 获得的 Python 工具非常有用。
**# load the data set** import pandas as pd
df = pd.read_csv('./Natality.csv')**# build a random forest classifier** from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier()
x = df.drop('label', axis=1)
y = df['label']
rf.fit(x, y)**# evaluate the results** from sklearn.metrics import roc_curve, auc
false_positive_rate, true_positive_rate, _ = roc_curve(y, rf.predict(x))
roc_auc = auc(false_positive_rate, true_positive_rate)**# plot the curve** import matplotlib.pyplot as plt
plt.plot(false_positive_rate, true_positive_rate,
'b', label='AUC = %0.2f'% roc_auc)
plt.legend(loc='lower right')
plt.show()
上面的 Python 代码显示了如何使用 pandas 读取数据框，使用 sklearn 拟合随机森林模型，评估模型的性能，并绘制结果，如下图所示。对于这个模型，我在评估模型时没有应用任何交叉验证。使用 scikit-learn 的好处之一是 fit 和 score 函数在不同的算法中是一致的，这使得探索不同的选项变得很简单。
ROC Curve for the Random Forest model in scikit-learn
集群
对初创公司有用的分析类型之一是了解是否有不同的细分市场或用户群。这类工作的一般方法是首先识别数据中的聚类，为这些聚类分配标签，然后根据带标签的聚类为新记录分配标签。本节展示了如何使用 2016 年美联储消费者金融调查的数据来执行这种类型的过程。
该调查数据集提供了美国成千上万个家庭的资产明细。这种聚类分析的目的是确定是否存在不同类型的净资产超过 100 万美元的富裕家庭。加载数据和执行分析的完整代码在本 Jupyter 笔记本中提供。在这篇博客文章中介绍了之前对该数据集的分析。
对于每一个被调查的家庭，我们都有许多列来说明如何为该家庭分配资产，包括住宅和商业房地产、企业股权、退休金和许多其他资产。我们要做的第一件事是确定哪些资产具有对用户进行聚类的强信号。我们可以使用 PCA 和因子图来实现这个目标:
**# filter on affluent households, and print the total number**
affluent <- households[households$netWorth >= 1000000, ]
cat(paste("Affluent Households: ", floor(sum(affluent$weight))))**# plot a Factor Map of assets**
fviz_pca_var(PCA(affluent, graph = FALSE), col.var="contrib",
gradient.cols = c("#00AFBB", "#E7B800", "#FC4E07"), repel = TRUE)+
labs(title ="Affluent Households - Assets Factor Map")
下图显示了富裕家庭中不同的资产类别。最重要的因素是企业权益。其他一些因素包括投资资产(股票、债券)和房地产资产/退休基金。
A factor map showing differences in asset allocations.
要使用多少个集群？
我们现在已经有迹象表明，百万富翁有不同的类型，资产也因净资产的不同而不同。为了理解资产配置如何因净值部分而不同，我们可以使用聚类分析。我们首先识别富裕调查受访者中的聚类，然后将这些标签应用于调查受访者的总体人口。
k <- 7
res.hc <- eclust(households[sample(nrow(households), 1000), ],
"hclust", k = k, graph = FALSE)
fviz_dend(res.hc, rect = TRUE, show_labels = FALSE)
为了确定使用多少个集群，我使用上面的代码片段创建了一个集群树图。结果如下图所示。我还改变了集群的数量， k ，直到我们有了最大数量的可清楚识别的集群。
A hierarchical visualization of the cluster assignments.
如果您更喜欢采用定量方法，您可以使用 fviz_nbclust 函数，该函数使用轮廓度量计算最佳聚类数。对于我们的分析，我们决定使用 7 个集群。
clarax <- clara(affluent, k)
fviz_cluster(clarax, stand = FALSE, geom = "point", ellipse = F)
为了将富裕家庭分成独特的群体，我使用了克拉拉算法。不同集群的可视化如下所示。结果类似于上面讨论的 PCA 和因子图方法。
A visualization of the two-principal components identified by PCA.
聚类描述 既然我们已经确定了要使用多少个聚类，那么检查这些聚类并根据特征集分配定性标签是很有用的。下面的代码片段显示了如何计算 7 个不同分类的平均特征值。
groups <- clarax$clustering
results <- as.data.frame(t(aggregate(affluent,list(groups),mean)))
results[2:18,]
该代码块的结果如下所示。基于这些结果，我们提出了以下集群描述:
- V1:股票/债券——占资产的 31%,其次是家庭基金和共同基金
- V2:多元化——53%的商业股权，10%的房产和 9%的其他房地产
- V3:住宅房地产——占资产的 48%
- V4:共同基金——资产的 50%
- V5:退休— 48%的资产
- V6:企业权益— 85%的资产
- V7:商业房地产——59%的资产
除了仅包含 3%人口的星团 V7 之外，大多数星团的大小相对均匀。第二小的聚类代表人口的 12%,而最大的聚类代表 20%。您可以使用 table(groups) 来显示未加权的集群人口规模。
Asset allocation amounts for the 7-identified clusters.
按净值段对人群进行聚类 该分析的最后一步是对总体人群应用不同的聚类分配，并按净值段对人群进行分组。因为我们只对富裕家庭进行聚类训练，所以我们需要使用分类算法来标记人口中的非富裕家庭。下面的代码片段使用 knn 来完成这项任务。剩余的代码块计算每个净值段被分类为每个聚类的家庭数量。
**# assign all of the households to a cluster** groups <- knn(train = affluent, test = households,
cl = clarax$clustering, k = k, prob = T, use.all = T)**# figure out how many households are in each cluster** clusters <- data.frame(
c1 = ifelse(groups == 1, weights, 0),
...
c7 = ifelse(groups == 7, weights, 0)
)**# assign each household to a net worth cluster** nw <- floor(2*log10(nwHouseholds))/2
results <- as.data.frame(t(aggregate(clusters,list(nw),sum)))**# compute the number of households that belong to each segment**
results$V1 <- results$V1/sum(ifelse(nw == 4, weights, 0))
...
results$V11 <- results$V11/sum(ifelse(nw == 9, weights, 0))**# plot the results** plot <- plot_ly(results, x = ~10^Group.1, y = ~100*c1, type = 'scatter', mode = 'lines', name = "Stocks") %>%
add_trace(y = ~100*c2, name = "Diversified") %>%
...
add_trace(y = ~100*c7, name = "Commercial R.E.") %>%
layout(yaxis = list(title = '% of Households', ticksuffix = "%"),
xaxis = list(title = "Net Worth ($)", type = "log"),
title = "Cluster Populations by Net Worth")
这一过程的结果如下图所示。图表显示了一些明显和新颖的结果:房屋所有权和退休基金构成了非富裕家庭的大部分资产，2M 美元(不包括商业房地产和商业股权)附近的资产组合相对均匀，商业股权主导了超富裕家庭的净资产，其次是其他投资资产。
How the distribution of clusters varies based on Household Net Worth.
对于这个聚类示例，我研究了调查数据并确定了七种不同类型的富裕家庭。然后，我使用这些聚类为剩余的家庭分配标签。类似的方法可以在创业时使用，以将细分标签分配给用户群。
结论
预测建模是机器学习的一种应用，具有各种各样的工具，可用于入门。建立预测模型时，首先要考虑的事情之一是确定您试图预测的结果，并建立用于衡量成功的指标。
在这篇文章中，我展示了四种不同的方法来建立预测怀孕期间双胞胎的分类模型。我展示了如何使用基于 GUI 的工具 Weka 和 BigML 来评估逻辑回归模型、集成模型和深度网络。我还编写了用 R 执行正则化逻辑回归和用 Python 执行随机森林的脚本示例。我用一个集群的例子结束了这篇文章，这对于执行创业公司的细分任务可能是有用的。
独立于用于构建预测模型的方法，能够输出模型规格作为训练过程的结果是很重要的。这可以是线性回归模型的系数权重列表，随机森林模型的节点和权重列表，或者深度学习网络的神经元权重和激活列表。在下一篇帖子中，我将讨论如何将预测模型扩展到数百万用户，并且能够将训练好的模型表示为规范是生产的先决条件。
创业数据科学:PySpark
Source:Wikimedia Commons
我的创业数据科学第三部 系列 s 现在重点介绍Python。
Spark 是一个很好的工具，可以让数据科学家将研究代码转化为生产代码，PySpark 使这种环境更容易访问。虽然我一直是谷歌用于产品化模型的云数据流的粉丝，但它缺乏一个易于原型化和部署数据科学模型的交互环境。Spark 对于初创公司来说是一个很好的工具，因为它既提供了执行分析的交互式环境，又提供了将模型投入生产的可伸缩性。这篇文章讨论了如何在 GCP 上启动集群并连接到 Jupyter，以便在笔记本环境中使用 Spark。
有各种不同的生态系统可用于与 Spark 合作，从自托管到供应商选项。以下是我过去探索过的一些 Spark 选项:
- 阿帕奇安巴里+阿帕奇齐柏林
- GCP DataProc + Jupyter
- AWS EMR + SageMaker
- 供应商:DataBricks、Cloudera
除了 SageMaker 之外，所有这些设置我都亲自操作过。在与大型企业合作时，我更喜欢供应商解决方案，但初创公司可能希望避免这种选择。最佳方法取决于您需要处理多少数据，您预计您的公司将增长多少，以及您需要用该基础架构支持多少数据科学家。
这篇文章的目标是展示如何尽快使用 PySpark 的云解决方案。我决定使用 GCP，因为该平台提供免费积分，并且进入笔记本环境是微不足道的。下面的帖子是 GCP 星火计划的一个很好的起点:
[## 数据科学家的谷歌云平台:在谷歌上使用带有 Apache Spark 的 Jupyter 笔记本…
结合使用 Jupyter 笔记本电脑和 GCP，您将获得熟悉的数据科学体验，而不会有乏味的…
cloud.google.com](https://cloud.google.com/blog/products/gcp/google-cloud-platform-for-data-scientists-using-jupyter-notebooks-with-apache-spark-on-google-cloud)
这个例子的完整源代码可以在 GitHub 上找到。
设置
首先，我们需要设置一个集群，我们将用 Jupyter 连接到这个集群。我们将使用大多数默认设置，即创建一个包含一个主节点和两个工作节点的集群。我们将指定的一个初始化步骤是运行位于 Google Storage 上的一个脚本，它为集群设置 Jupyter。
- 从 GCP 控制台，选择汉堡菜单，然后选择“DataProc”
- 从 DataProc 中，选择“创建集群”
- 分配一个集群名:“pyspark”
- 单击“高级选项”，然后单击“添加初始化选项”
- 添加如下命令(如下所示):
GS://data proc-initial ization-actions/jupyter/jupyter . sh - 点击“开始”
Adding the Jupyter initialization step.
群集将需要几分钟的时间来启动。准备就绪后，状态将从“正在调配”变为“正在运行”。在开始使用 Jupyter 之前，我们需要为集群设置连接规则。推荐的方法是设置 SSH 隧道，如这里的所述。为了快速启动并运行，我们将修改防火墙以接受来自特定 IP 的连接。
The initialized Spark cluster.
要修改防火墙以接受来自您的计算机的连接:
- 点击集群“pyspark”
- 单击“虚拟机实例”
- 对于“pyspark-m ”,单击 3 个垂直点，然后单击“查看网络详细信息”
- 从左侧，选择“防火墙规则”
- 选择“创建防火墙规则”
- 对规则使用以下设置
-名称:jupyter
-目标标签:http-服务器
-源 IP 范围:您的 v4 IP- tcp: 8123(脚本在此端口上设置 jupyter)
- 点击“创建”
现在您应该能够测试到您的 DataProc 集群的连接了。浏览回“VM Instances”并单击“pyspark-m”以获取集群的外部 IP。然后点击“编辑”，启用“允许 HTTP 流量”，然后“保存”。将“:8123”附加到集群外部 IP 的末尾，并将结果粘贴到您的浏览器中。您应该会看到 Jupyter，如下所示。
Jupyter set up for GCP DataProc.
我们现在已经为 PySpark 的云部署设置了 Jupyter 笔记本！
PySpark
设置好 Jupyter 环境后，您可以通过选择“新建”然后选择“PySpark”来创建新笔记本。虽然已经安装了一些常用库，如 matplotlib 和 numpy ，但是您可能希望通过 pip 添加额外的库。我们可以直接在笔记本上完成:
!pip install --upgrade pandas
!pip install --upgrade pandas_gbq
!pip install --upgrade pyspark
上面的代码片段在集群上安装 Pandas，以及 Pandas 的 BigQuery 连接器和 PySpark，我们将使用 py Spark 来获取对 Spark 上下文的引用。我们将遵循 GCP 的例子，从将数据从 BigQuery 拉入 Pandas 数据帧开始。此时，我们实际上并没有利用 Spark 的功能，因为使用 Pandas 需要将所有数据加载到驱动程序节点的内存中。但这是在担心 Spark 的一些复杂性之前快速启动和运行的一种方式。
下面的代码片段显示了如何在 BigQuery 上运行查询，并将结果拉入驱动程序节点上的 Pandas 数据帧。当处理较大的数据集时，应该使用 BigQuery 连接器以 Spark 数据帧而不是 Pandas 数据帧的形式返回结果。
from pandas.io import gbqproject_id = "your-project_id"
query = """
SELECT *
FROM `bigquery-public-data.samples.natality`
limit 10000
"""births = gbq.read_gbq(query=query, dialect ='standard', project_id=project_id)
births.head()
因为我们将结果作为熊猫数据帧返回，所以我们可以使用 hist 函数来绘制不同属性的分布。下图显示了出生体重和母亲年龄的分布。
Histograms of different attributes in the data set.
为了充分利用 Spark 的分布式计算能力，在使用 PySpark 时最好避免使用 Pandas。这意味着避免 toPandas() ，直接将数据加载到 Spark 而不是 Pandas 数据帧中。然而，Pandas UDF是在 Spark 环境中使用 Pandas 的一种很好的方式，但是调试起来很有挑战性。
首先，我们将展示如何从 Pandas 数据帧转换到 Spark 数据帧。关键的区别在于 Spark 数据帧是延迟评估的，并且分布在集群中，这意味着在需要计算结果之前不执行任何操作。当使用 Pandas 数据帧时，所有的操作都以一种急切的模式执行，并被立即拉入内存，即使结果在后面的步骤中不被使用。在使用 Spark 数据帧之前，我们首先需要获得对 Spark 上下文的引用，如下面的代码片段所示。一旦获得，我们可以用它来转换从熊猫到火花数据帧。
from pyspark.context import SparkContext
from pyspark.sql.session import SparkSession# Get a reference to the Spark Session
sc = SparkContext()
spark = SparkSession(sc)# convert from Pandas to Spark
sparkDF = spark.createDataFrame(births)# perform an operation on the DataFrame
print(sparkDF.count())# DataFrame head
sparkDF.show(n=5)
许多 Spark 操作类似于 Pandas 操作，但是执行流程有很大的不同。上例显示了如何使用显示功能执行与头操作类似的结果。Spark 的主要好处是执行是分布式的和懒惰的，从而产生可伸缩的管道。
结论
Spark 是构建数据管道的强大工具，PySpark 使这个生态系统更容易访问。虽然使用 spark 有多种选择，但本文主要关注如何使用 GCP 的 DataProc 和一个 Jupyter 初始化脚本来快速交互式访问 Spark 集群。有效地使用 PySpark 需要重新学习许多在 Python 中执行数据科学的标准方法，但结果是大规模可扩展的数据管道和分析。
本·韦伯是 Zynga 的首席数据科学家。我们正在招聘！
创业公司的数据科学:R -> Python
Source: Yuri_B at pixabay.com
在我的博客系列初创公司的数据科学中，我收到的一条反馈是，对于加入初创公司的数据科学家来说，Python 将是一个更好的选择。如果 Python 已经是执行数据科学任务的首选语言，这就很有意义了。就我而言，我在 R 方面有更多的经验，我想用一种我以前用来解决问题的语言来介绍如何与初创公司合作。
现在我已经完成了这个系列，并把它变成了一本书，我想开始深入研究 Python 作为数据科学的脚本语言。目前，我仍然更喜欢使用 Java 来生产模型，使用数据流，但是随着我对这种语言越来越熟悉，这种偏好可能会改变。我想把我以前的一些文章从 R 移植到 Python，为更广泛的读者提供一个介绍。以下是我探索 Python 的主要动机:
- **创业工具:**许多创业公司已经在使用 Python 进行生产，或者他们的部分数据管道。使用 Python 来执行分析任务是有意义的。
- R 和 Java 不能很好地过渡到交互式创作 Spark 任务。可以用 Java 做 Spark，但是不太适合做探索性的工作，从 Python 过渡到 PySpark 似乎是学习 Spark 最平易近人的方法。
- **深度学习:**我对深度学习很感兴趣，虽然有 Keras 等库的 R 绑定，但最好还是用这些库的母语编码。我之前用 R 创作过自定义损失函数，调试错误有问题。
- **Python 库:**除了为 Python 提供的深度学习库，还有许多其他有用的工具，包括 Flask 和 Bokeh 。有可以扩展的笔记本环境，包括谷歌的联合实验室和 AWS SageMaker 。
我还想介绍两个主题，这是我在最初的系列文章中没有提供的内容:
- **虚拟化:**一旦您开始运行大型作业，您需要一个更好的环境来进行扩展以处理大型数据集。在最初的系列文章中，我使用了 Google 的数据流，但是我想展示一些工具，这些工具在交互工作时对扩大分析规模很有用。
- Spark: 我想探索更多的 Spark 生态系统，包括像最近宣布的 MLflow 这样的工具。Spark 为处理大规模数据提供了一个很好的环境，可以更容易地从勘探转移到生产任务。
首先，我计划重温我以前的帖子，这些帖子都是 R heavy，并向 Python 提供这些帖子的一个端口。以下是我的原始系列中需要翻译成 Python 的主题:
- 商业智能: 用 base R、R markdown、Shiny 进行报告。
- 探索性数据分析: 汇总统计、可视化、关联分析。
- 预测建模: 带正则化的逻辑回归。
- 模型制作: 将线性回归模型导出到 PMML。
- 实验: 执行引导和因果影响分析。
- 推荐系统: 原型化一个样本推荐器。
- 深度学习: 编写自定义损失函数。
其中许多部分可以直接翻译，但商业智能等帖子需要使用不同的库，如 Bokeh 而不是 Shiny。我不会更新数据流中的部分，因为它们是用 Java 编写的。然而，使用 Python 编写数据流任务是可能的。我不会将 Java 移植到 Python，而是探索用于产品化工作的新工具，比如 Spark 和 SageMaker。
这篇文章的目标是激励我向 Python 的过渡，并介绍如何使用 Jupyter 笔记本。鉴于我对虚拟化的新关注，我还想展示如何在 AWS 上使用远程机器。本文的剩余部分将讨论如何在 AWS 上启动 EC2 实例，为远程连接设置 Jupyter 笔记本，以及用 Python 从 BigQuery 查询数据。
设置 Jupyter
Python 有很多很好的 ide，比如 PyCharm。然而，我将重点关注 Jupyter，因为它是一个笔记本环境，许多用于可扩展数据科学的工具都基于笔记本，如 Spark、Colaboratory 和 SageMaker 的 DataBricks。在学习这门语言的基础知识时，从 IDE 开始可能是有用的，但是熟悉笔记本环境也是有益的，因为这种类型的环境对于大型工具来说非常流行。
开始使用 Python 时讨论的一个常见任务是设置一个虚拟环境，以便使用诸如 virtualenv 之类的工具安装 Python 和任何必要的库。使用 Python 时设置一个虚拟环境是一个很好的实践，因为库之间可能会有冲突，您可能需要运行多个版本的 Python，或者您可能想要创建一个全新的安装来重新开始。Docker 是另一个选择，但比 virtualenv 更重要。在这篇文章中，我将讨论在 AWS 上启动 EC2 实例来设置 Python 3 环境。这也比使用 virtualenv 要重要得多，但是在处理较大的数据集时，如果有必要，它提供了扩大机器大小的能力。这也是更熟悉 AWS 并开始虚拟化数据科学任务的好机会。
设置笔记本电脑环境时，安全性是另一个重要的考虑因素，因为您不希望您的工作空间对外界开放。在使用 AWS 时，连接到 Jupyter 笔记本最安全的方法是设置一个带端口转发的 SSH 隧道，这可以确保客户端只有在拥有所需的私钥时才能连接到笔记本。另一种选择是将笔记本电脑开放给开放的 web，但是限制哪些机器可以连接到 EC2 实例。我将在本文中介绍后一种方法，因为它需要的步骤更少，但是强烈推荐前一种方法用于任何实际任务。
启动 EC2 实例 这篇文章假设你已经创建了一个 AWS 账户。AWS 提供了许多自由层选项，您可以使用它们来熟悉该平台。EC2 是一项服务，可用于启动和连接虚拟机。我们将启动一个 EC2 实例，并使用它来托管 Jupyter 笔记本。关于使用 EC2 的文档可以在这里找到。
Launching an EC2 instance on AWS
从 EC2 仪表板执行以下步骤启动机器:
1.点击
的【启动实例】2。选择“亚马逊 Linux AMI 2018 . 03 . 0”
3。选择“t2.micro”，这是符合条件的自由层
4。点击
5【审核并启动】。点击“Launch ”,然后选择通过 SSH 连接的密钥
6。单击“启动实例”，然后单击“查看实例”
我们还需要编辑机器的配置，以便允许端口 8888 上的入站 Jupyter 连接。默认情况下，EC2 实例只允许使用私钥进行身份验证的端口 22 上的入站连接。关于配置安全组的文档可在这里获得。
Setting up an exception for port 8888 for Jupyter.
我们将只允许主机在端口 8888 上连接到 EC2 实例。从 EC2 仪表板执行以下步骤:
1.选择您的 EC2 实例
2。在“描述”下，选择安全性(如启动向导-1)
3。点击【操作】->-【编辑入站规则】
4。添加新规则:将端口改为 8888，在 source 下选择“我的 IP”
5。点击“保存”
执行完这些步骤后，您现在就有了一个正在运行的 EC2 实例，并有一个开放的端口可用于连接 Jupyter。为了连接到您的实例，您需要一个工具，比如 Putty。此处提供了针对 Windows 用户的说明。另一个选择是使用 Java 直接连接到您的实例。不过我之前没用过这个，在 Chrome 里已经弃用了。
安装 Jupyter
一旦您能够连接到您的实例，您将需要设置 Python 3 和 Jupyter。该实例应该已经安装了 Python 2.7，但是我们希望使用一个更新的版本。运行以下命令安装 Python 3、pip 和 Jupyter:
sudo yum install -y python36
python36 --version
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
sudo python36 get-pip.py
pip3 --version
pip3 install --user jupyter
亚马逊 linux 发行版是基于 RedHat 的，所以 yum 是用来安装软件的。Pip 是 Python 的包管理器，我们将在后面的步骤中使用它来安装库。我还包含了检查安装版本的语句。
Private IP and Public IP details for my test instance.
默认情况下，Jupyter 只接受来自本地机器的连接。这可以通过使用--ip命令来改变。为了在 EC2 实例上工作，您需要使用机器的私有 IP。这就是上图中的172.31.60.173。您可以使用以下命令启用远程连接并启动 Jupyter:
jupyter notebook --ip *Your_AWS_Prive_IP*
当 Jupyter 启动时，它会提到一个特定的 URL，需要复制到您的浏览器中才能运行笔记本。因为我们将 Jupyter 配置为使用私有 IP，所以这是在启动 Jupyter 时打印出来的内容。要连接到机器，你需要复制链接，还要将 IP 从私有 IP 修改为公有 IP，也就是上图中的18.206.244.128。
# output from running the command
The Jupyter Notebook is running at:
[http://*Your_AWS_Private_IP*:8888/?token=dd921a6c4ebc3a3bb90fcd8ac44394692a80685705da30e3](http://172.31.60.173:8888/?token=dd921a6c4ebc3a3bb90fcd8ac44394692a80685705da30e3)# switch the internal IP to external to run in a browser
[http://Your_AWS_Public_IP:8888/?token=dd921a6c4ebc3a3bb90fcd8ac44394692a80685705da30e3](http://172.31.60.173:8888/?token=dd921a6c4ebc3a3bb90fcd8ac44394692a80685705da30e3)
如果一切顺利，您现在应该会在浏览器中看到 Jupyter。
The Jupyter landing page on my EC2 instance.
现在，您已经有了一个用于创作交互式 python 3 脚本的笔记本！
连接到 BigQuery
现在我们已经有了一个 Jupyter 笔记本，在深入研究商业智能和 EDA 之前，我想探索的第一步是弄清楚如何将数据从 BigQuery 提取到 Pandas 数据框架中进行分析。虽然谷歌确实提供了一个在 Python(谷歌云存储)中使用 GCP 的库，但我们不需要在这个特定的用例中使用它。 pandas-gbq 库使得在本地提取结果集进行分析的任务变得容易。要设置该库以及用于绘图的 matplotlib ，在终端中运行以下命令:
pip3 install --user pandas-gbq
pip3 install --user matplotlib
我们可以切换回 Jupyter 环境，开始使用 BigQuery 公共数据集。下面代码片段中的第一行加载 pandas 库，它是在安装 pandas-gbq 时作为一个依赖项安装的。第二行标识运行查询时使用的产品 id。第三个命令运行一个查询，从出生率数据集中提取一个数据样本，并将结果集分配给 pandas 数据帧。最后一步显示关于 df 对象中数据类型的信息。当您第一次运行这个脚本时，笔记本会提示您输入一个密钥，作为向 Google 进行身份验证的一部分。单击提供的链接并复制密钥以继续。
import pandas as pdprojectid = "your_project_id"df = pd.read_gbq("""SELECT *
FROM `bigquery-public-data.samples.natality` limit 100""",
projectid, dialect = "standard")df.info()
对于 R 用户来说，Python 中的 info() 类似于 str() ， describe() 类似于 summary() 。如果您想了解数据集的形状，可以使用 DataFrame 对象的一些内置绘图函数，这些函数使用 matplotlib 生成绘图。下面的代码片段显示了如何从 DataFrame 中选择两列，并为这些属性绘制直方图:
df[['weight_pounds', 'mother_age']].hist()
这将生成以下 matplotlib 可视化效果:
Histograms of attributes in the Natality data set.
我们现在已经建立了一个环境，可以将 BigQuery 中的数据提取到 pandas 数据帧中进行分析。该工作簿可在 Github 这里获得，渲染版本可在这里获得。我已经用 Jupyter 笔记本进行了一些分析，所以在这个环境中用 BigQuery 建立 Python 连接是将我的 R 分析移植到 Python 的良好开端。下一步是学习如何使用 Python 库执行探索性数据分析、可视化和建模。
结论
作为我的创业数据科学系列的下一步，我将探索使用 Python 代替 R 来完成脚本任务。Python 提供了许多激发这个端口的伟大库，包括深度学习、对 Spark 更温和的介绍，以及可扩展的笔记本环境。这篇文章展示了如何设置 EC2 实例并远程使用 Jupyter 笔记本。它还展示了如何从 BigQuery 中提取数据。现在我已经为开始使用 Python 打下了一些基础，我可以开始将我的一些帖子从 r 移植到 Python。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
