TowardsDataScience-博客中文翻译-2019-三十四-
TowardsDataScience 博客中文翻译 2019（三十四）
如何找到一份数据科学家的工作——7 个可行的建议
想知道如何获得数据科学工作？如果你想搬家，这里有 7 个可行的建议需要考虑。
对许多人来说，找工作可能是一项具有挑战性的任务，但我们都需要经历这一过程，才能找到工作，建立自己的事业。目前就业市场上最理想的工作有很大一部分是与分析相关的工作，比如数据科学家、数据工程师，甚至是数据分析师。
随着像数据科学家这样的工作变得越来越受欢迎，它们的竞争也会越来越激烈。竞争激烈的就业市场意味着最有技能的人往往是最容易被雇佣的。雇主们正在寻找能够解决他们面临的任何问题的数据科学家。那么，一个人如何才能找到一份数据科学家的工作呢？
当谈到获得数据科学家的工作时，许多人不知道从哪里开始以及如何获得数据科学的工作。作为一名数据科学家，成就伟大事业的道路并不复杂。
如何获得数据科学工作的 7 个可行建议
当然，在你申请任何数据科学工作之前，你需要雇主在数据科学家候选人身上寻找的正确技能。这些可行的建议不仅能巩固你的基础，还能帮助你获得正确的技能。这些技巧可以帮助你获得第一份数据科学工作。这 7 个可行步骤包括基本技能以及软技能、教育资源和其他决定如何获得数据科学家工作的因素。在这里，我们试图提供非常具体的步骤，让你在数据科学领域找到理想的工作。
1.知道最重要的技能
数据科学家是程序员、统计学家、软件工程师以及其他更多人的混合体。数据科学家需要能够从头到尾运行一个项目。因此，想要获得数据科学家工作的人需要具备多种技能才能胜任工作。
拥有一套强大的技能是雇主可以好好利用的。了解数据科学和分析中最重要的技能是任何未来的数据科学家应该做的第一件事。成为数据科学家的一些最重要的技能是:
- 精通 Python
- 精通 SQL 的经验
- R 的有效使用
- 从事统计学
- 了解机器学习
了解这些技能并能够有效地使用它们是获得数据科学家工作的核心要素。如果你觉得自己还不能胜任使用上述任何一种技能，那么试着专注于提高技能，这也是我们的下一个技巧。
2.不断学习
在数据科学领域，为了在你的领域保持领先，你必须掌握技能发展。数据科学和分析领域总是在不断适应，问题每次都在变化。因此，提升和磨练你的技能对于打造数据科学家的职业生涯至关重要。
通过在教育资源中的实践来建立真正的行业知识可以有很长的路要走。拥有强大的分析技术基础是可以在自己家里舒适地建立起来的。
利用教育资源
如果你想得到一份数据科学家的工作，了解基础知识是不够的。要在分析领域取得成功，需要深入的知识和解决问题的技能。利用在线练习、训练营和模块等教育资源对掌握分析技能大有帮助。
尝试练习，阅读案例研究，做类似于那些来自 Strata Scratch 的教程，可以让你在游戏中保持领先。持续学习对于跟上分析领域的步伐是必要的，所以如果你想得到一份数据科学家的工作，就要花时间继续学习。
3.增强你的沟通技巧
获得一份数据科学家的工作不仅需要强大的分析工具，沟通等软技能也很重要。能够描述你将如何解决一个问题，以及你为什么选择那条路线来解决问题，是成为一名数据科学家的关键部分。
数据科学家需要能够交流项目的每一步及其背后的推理。当你解决一个问题或处理一个项目时，试着记下你的想法，这样你就可以在将来学会向别人解释每一步。
4.熟能生巧
作为一名数据科学家，找到一份完美的工作需要时间。每个成功的数据科学家背后，都有大量的求职申请和数次面试。事实是，获得一份数据科学家的工作需要时间和努力。
保持乐观，从你没有得到的数据科学职位中学习，从不如你希望的顺利的面试中学习。尽可能多地练习模拟面试。最终，熟能生巧，你会得到一份数据科学家的工作。
5.网络
获得一份数据科学家的工作不仅是拥有最强的技能，也是为了结识业内人士，他们可能会帮助你找到一份出色的数据科学工作。通过与其他数据科学家甚至招聘人员建立关系，你可以获得更好的结果。利用 LinkedIn 这样的社交网站，参加行业会议，对获得你梦想中的数据科学家职位大有帮助。所以，开始利用你网络中的关系吧。
6.建立投资组合
雇主会看到成百上千的简历，声称该候选人有能力做他们需要的事情，但并不是每个求职者都有很多表现。说你能做某事是很好的，但是表现出你能做并且做得更多会更好。
好的作品集对找数据科学工作非常重要。你应该在你的 数据科学投资组合 中包含什么，实际上取决于你在寻找什么类型的数据科学角色。
建立一个过去工作和项目想法的文件夹向雇主展示你有能力、有能力并且有所作为。以多样化和有趣的投资组合脱颖而出可能是你申请的决定性部分，这将使你获得一份数据科学家的工作。
额外收获:你在业余时间所做的所有学习对建立投资组合大有帮助。保存你在 Strata Scratch 上完成的问题和练习的最佳解决方案，以充实你的文件夹。
7.找一个导师
除了常规的人际交往，你可以遵循的获得数据科学家工作的最佳建议之一是找到一位导师。导师可以指导你完成项目和教育资源，甚至可以帮助你弄清楚雇主到底在数据科学家候选人身上寻找什么。
结论
在你找到一份工作之前，你可能会申请数百份数据科学工作。所以我们建议你耐心点，多做准备。你不仅要学习重要的概念，还要记住你将与不同的人和情况打交道。所以你必须准备好回答在不同的工作环境中你会如何表现的问题。
如何在数据科学领域找到工作
赢得数据科学面试的技巧
Image credit: fusionanalyticsworld.com
数据科学领域有许多流行词汇，但总体而言，关于面试过程的重要资源很少。鉴于此，我想分享这篇文章，因为我真的对数据科学面试准备的需求产生了共鸣，尤其是对大学生而言。这绝对是一个领域，我希望在进入这个行业之前，我在学校期间有更多的信息。我用粗体突出了我认为每个部分中的一些关键部分，因为它们与我在许多公司的大部分真实面试非常相关。
介绍
从事分析工作的数据科学家应该与产品团队紧密合作，以推动产品向前发展。扮演这样一个角色通常需要几项基本技能，这些技能通常会在各种公司的面试中得到广泛测试。本帖将是面试流程的介绍，重点是各知名公司的资源和样题。
一般提示
很重要的一点是，要很好地理解手头具体职位的角色和职责，以及你可能从事的产品。这是因为面试官可能会问你一些基于他们已经完成或正在进行的工作和项目的问题。因此，你可以问自己以下类型的问题:
- 公司是什么样的企业，处于什么阶段？根据对这些问题的回答，不同类型的指标，以及分析数据的方式将会很重要。Alistair Croll 和 Benjamin Yoskovitz 的书《精益分析》是这方面的一个很好的资源。
- 该产品如何融入公司产品套件的更广泛的生态系统？我喜欢和不喜欢该产品的哪些方面？产品应该有哪些新功能？这些问题通常也会在产品管理面试中出现，因为那里的工作职能主要是考虑产品问题。这里有一些有用的资源，比如 PM 面试和产品经理面试。
- 如果我正在开发这个产品，我应该衡量哪些关键绩效指标(KPI)，即基本的业务指标？哪些因素和变量会影响这些指标，它们是如何影响这些指标的？每个公司都有自己的衡量标准，但基于商业模式和公司创收方式，这些标准有很多重叠之处。基于商业模式，YC 有一个很棒的视频覆盖指标:【https://www.startupschool.org/videos/66
- 产品如何赚钱？这里的关键是考虑推动核心业务的产品和流程中的各种杠杆。Keith Rabois 使用了术语“商业方程式”，这是一个有用的概念。他的用法的一个例子是:http://growth . eladgil . com/book/chapter-8-financing-and-evaluation/going-public-why-do-an-IPO-an-interview-with-Keith-rabois-part-2/
在面试前做调查会表明你对手头的工作和产品感兴趣。此外，你或许可以开始想象你可能会被问到什么类型的问题——在脸书这样的公司，对话可能会集中在用户、社交图和内容上，而在优步这样的公司，对话可能会围绕乘客、拼车算法和定价。最后，重要的是不要忽视一般的提示，包括:润色你的简历，拥有一个项目组合，等等。
产品感
这类面试问题的主要功能是更好地理解如何衡量和改进产品。目标是评估你对产品决策和相关数据的看法。它们可以是开放式的(更常见，询问要跟踪什么指标以及如何优化它们)，也可以是更详细和技术性的(关于您可能跟踪什么类型的数据以及这些数据可能如何影响指标)。
示例问题:
- 假设你是第一个使用 Facebook Messenger 的人。你会跟踪什么 KPI？您将如何衡量和改进这些 KPI？
- 假设你在 Youtube，有两个新想法要实现来增加收入。您将如何决定实施哪一个，为什么？
概率与统计
这些是经过测试以确保数字素养的核心主题，对于数据科学角色的成功至关重要。通常，概率主题将限于你可能在统计学 101 课程中找到的东西:基本分布，条件概率，以及像中心定理和大数定律这样的概念。对于统计主题，像假设检验、统计显著性和其他与统计推断相关的主题是常见的，因为 A/B 检验是许多公司实验的核心部分。有许多这类主题的教科书(例如，谢尔登·罗斯的《概率入门教程》)以及涵盖这一内容的在线课程。
这些问题的技术细节水平可能因角色类型而异。例如，如果这个角色专门在一个实验团队中处理 A/B 测试和大规模推理问题，那么你在这个类别中收到的问题可能会比在纯产品方面工作的人涉及更多的数学。这种数学将涉及分布、统计测试、优化等背后的技术细节。另一方面，许多公司也会问用通俗的语言解释这些技术概念的问题。这是为了测试你对更复杂主题的理解和沟通能力，这对他们评估很有用，因为作为一名数据科学家，你将经常与其他部门的非技术人员互动。
示例问题:
- 掷两个骰子。假设两者的最大值是 4，那么总和超过 6 的概率是多少？
- 向外行解释什么是 p 值和置信区间。
编码和 SQL
尽管数据科学家的主要角色不同于软件工程，但数据科学家应该对编码和计算机科学有相当的熟练程度。最常用的语言是 Python 和 r。此外，SQL 问题在面试中也很常见，因为它们更简单，而且大多数数据科学职位都会涉及查询大型数据集。
涵盖的常见算法和数据结构将涉及 and 数组、流、图和矩阵，因为它们经常用于产品的实际应用中。适用于软件工程的相同原则也适用于此:总是从强力解决方案开始，然后慢慢优化，重点关注最差的运行时和内存使用情况。LeetCode 和破解编码面试都是练习编码问题的绝佳资源。
与编码问题类似，SQL 问题通常具有真实公司中常见的结构，因为它们对收集用户、交易等特定类型的数据感兴趣。例如，优步和 Lyft 可能会问关于用户最后一次乘车的时间、最繁忙的时间或其他关于拼车体验的问题，而脸书可能会问关于用户和友谊图的问题。
示例问题:
- 给定一个包含一段时间内销售的产品的表:date，product_id，sales_amount，按时间顺序计算每种产品在一段时间内的累计总和。
- 给定一个整数数组，找出第一个缺失的正整数。例如，如果给定[0，2，1]返回 3，如果给定[-1，4，1，3]返回 2。
最后的想法
虽然这篇文章并没有完全涉及整个过程的所有部分(例如，没有简历和人际关系网方面)，但我认为它从实际面试中需要注意的方面对整个过程进行了很好的概述。如果你对更多的面试准备资料感兴趣，一定要去看看:https://datascienceprep.com/
如何从预测分析投资中获得回报:公司应该知道什么
由于预测分析，公司可以挖掘当前和历史数据，并预测未来事件，比仅凭经验和有根据的猜测更有把握。但是，预测分析工具并不是企业的神奇解决方案。
将预测分析应用于业务需求对于获得最佳结果至关重要。在使用预测分析时，你可以做以下五件事来最大化投资回报(ROI)。
1.使用预测分析减少生产停工时间
停机时间是制造工厂的一个主要问题，主要是因为停机时间的长短和生产的产品类型决定了停机时间的成本。
例如，统计数据显示，汽车工厂的一次停电每分钟可能会花费 22，000 美元。预测分析有助于减少计划外停机，从而提高公司的投资回报率。
在一个案例研究中，一家开发和制造营养成分的生物技术公司发现设备上的管道堵塞降低了生产线的速度，导致需要更频繁地延迟清洗设备。但是，企业无法确定问题的根本原因
在该公司查看其季度审查并发现停机时间减少了 3.6%后，它使用了预测分析来洞察未来的停机时间，并允许业务主动出击。该解决方案将停机时间减少了 83%,并将生产能力提高了 5.1%。
2.应用预测分析减少员工流动
工作研究所(Work Institute)2018 年的一项研究发现，员工流动成本通常占员工基本工资的 33% 。这意味着找出员工离职的原因，并努力解决这个问题，可以为每一个决定留在公司的员工节省数千美元。
越来越多的公司投资预测分析工具，以评估员工对工作的真实感受，以及是否存在警告信号，表明他们可能会沮丧到辞职。
其中一些工具还可以帮助人力资源代表将事件联系起来。
例如，如果一个人的平均生产率下降，并且在过去的三个月里他们开始迟到，这些事情都可能表明对工作不满意。但是，如果一家公司投资于人力资源预测分析软件，它可以通过增加员工留下来努力工作的可能性来提高投资回报率。
3.使用电话营销来参与分析软件提出的销售线索建议
许多预测分析软件选项可以帮助销售专业人员缩小销售线索列表，找到最合格的销售线索，而不是在不太可能采取积极行动的人身上花费太多时间。
也就是说，即使预测分析依赖于令人印象深刻的计算能力，人的因素仍然需要成为销售组合的一部分。
因此，提高投资回报的一个好方法是，公司使用预测分析来寻找最佳线索，然后让电话销售专业人员培育线索来帮助推动销售。内部或外部电话营销团队对业务有益，因为他们可以展示对客户需求的个性化理解，然后以吸引这些特征的方式讨论产品或服务。
这个例子表明，尽管预测分析解决方案变得越来越先进，但它们不会——也不应该——取代擅长工作和了解客户的人。
4.利用预测分析发现交叉销售和追加销售机会
当客户收到与他们已经购买或将要购买的产品相关的推荐时，就会发生交叉销售。许多公司通过在网站上展示各种“你可能也会喜欢……”的产品来做到这一点，只要有人将一件商品添加到虚拟购物篮中。
然后，当人们被说服花更多的钱购买类似但更贵的产品时，促销就发生了，比如同意更好的互联网套餐或更大的饮料配快餐套餐。
预测分析允许品牌通过使用更好的定位和确保最高价值的客户收到最有吸引力的报价来提高他们的投资回报率。第一田纳西银行尝试了这一策略，并实现了总体投资回报率 600%的增长，因为预测分析允许品牌更有效地分配其营销资源。
此外，由于向特定受众群体发送了最相关的报价，营销回复率提高了 3.1%。这种方法也帮助银行削减了印刷和邮寄成本。
如果人们被不感兴趣的优惠轰炸，交叉销售或追加销售都不会有效。预测分析有助于品牌在吸引客户时更加精准。
5.依靠预测分析进行更好的内容营销
正如没有通用的营销方法一样，公司在选择何时发布何种内容时，必须足够具体。合适的内容可以将品牌定位为思想领袖，让客户渴望听到他们要说的话。
预测分析可以帮助公司发现最适合不同受众群体的内容。然后，这些企业可以做出更明智的决策，决定如何使用内容预算来获得最佳投资回报。
预测分析还提供关于内容时机的指导。例如，历史统计数据显示，一个品牌的社交媒体页面在下午三点左右最活跃，这是内容发布的理想时间。或者，数据可能表明，人们通常在下载一本电子书之前至少会访问一个网站三次。
这些细节有助于内容创作提高投资回报率，并限制品牌在不想要或不必要的材料上浪费金钱的可能性。
预测分析可以帮助解决业务问题
你不应该将预测分析软件视为可以立即解决公司面临的所有问题的东西。
但是，正如这个列表所示，战略性地应用预测分析的力量可以提高投资回报率，帮助企业克服挑战。
图像由 Rawpixel
如何从一个不平衡的 RNG 得到一个无偏的
Python 中的一个随机抽取器，适用于从倾斜的硬币到莎士比亚
Stars, quasars, and other celestial objects generate photons in a random way that can be used to generate random numbers
"当然，任何考虑用算术方法产生随机数的人都是有罪的."
—约翰·冯·诺依曼
有可能从一枚不公平的硬币中获得公平的投掷吗？或者，一般来说，是否有可能从具有非均匀分布输出的源中提取随机性？还是从任何一种文字中？也就是说，我们怎样才能平衡不平衡呢？
假设我们有一枚硬币正面朝上的概率是 30%。你能使用这样一枚硬币(以任何你想要的方式，但只有这枚硬币)并期望总是有 50%的机会得到正面或反面吗？
这里是一个简单的 Python lambda 函数，它定义了不偏不倚的硬币的投掷:
头部编码为“0”，尾部编码为“1”，所以 flip_a_biased_coin() 实际上是一个非平衡二进制随机生成器。
现在让我们定义函数 flip_the_coin() ，该函数必须使用 flip_a_biased_coin() 才能创建一个均匀分布的二进制生成器。
在求职面试中，我见过很多关于这个问题的答案，包括基于二叉树或哈希表的怪异策略，以及过度设计的决策算法。
但是解决方案更简单。你要做的就是玩…
可能性
用 flip_a_biased_coin() 得到连续两个“0”的概率是多少？我们把这个概率命名为 p
连续得到两个“1”的概率是多少？
好吧…这些概率好像没啥用。但是得到一个“01”或者“10”序列的概率有多大呢？
最后一丝平衡！
flip_a_biased_coin() 输出一个“01”序列或“10”序列，概率相同:21%。
为了利用这一特性，每个“01”序列都被编码为“0 ”,或者换句话说，每次抛两次硬币，先投正面，然后投反面，结果是正面。反之亦然,“10”序列被编码为“1 ”,也就是说，每次抛两次硬币，一次是正面，一次是反面。
可以简化说，每两次投掷，如果结果不同，返回第一次；否则继续抛硬币两次。
这是一个完美平衡的随机发生器！
您可以粗略地检查这种发电机的输出:
Number of 0s: 495 Number of 1s: 505
另一个有趣的属性
你可以用这种方法作为随机抽取器来抽取任意序列的比特！
例如，让我们用二进制编码莎士比亚戏剧《罗密欧与朱丽叶》第二幕第二场最著名的部分:
噢，罗密欧，罗密欧！你为什么是罗密欧？否认你的父亲，拒绝你的名字。
或者，如果你不愿意，只要你发誓做我的爱人，我就不再是凯普莱特家族的人了。100111111000001010010111111110111101111011001000010011011111111110111101110111001111001110111001111111001111111111111000111111101111111111111111111111111111111100……共 1040 位
我们可以通过使用为 flip_the_coin() 函数所采用的相同策略，以诗意的方式提取具有均匀分布的比特序列。
对于每一对比特，如果比特不同，则打印第一个比特；否则不会打印任何内容。这就是结果:
100010101111110010110000000010010010001100100111100000111001010111111010000101110110101000100100010001011001000001010011101101110100001000100110000001110001110011001100100100001100111001110110101011010011111110010100101100110101001011100100101111011
这个序列是从原始的 1040 位中提取出来的，包含 130 个“0”和 119 个“1”，这意味着有 52%的概率得到“0”(或头部)，有 48%的概率得到“1”(或尾部)。
🎲你能找到一个装骰子的策略吗？🎲
对于这种简单的算法来说，这确实很好，但是您可以注意到，该算法丢弃了 1040 位中的 791 位，导致了大约 76%的拒绝率…非常糟糕！
还能改进吗？
熵的浪费
flip_the_coin() 和debias _ Romeo _ and _ Juliet()使用的原始策略在产生一个比特之前丢弃了许多比特。
如前所述，丢弃一个“00”序列(或两个头)的概率是，丢弃一个“11”序列(或两个尾)的概率是【1-p】。这意味着期望拒绝率 rej(p) 为
这意味着
换句话说，考虑到硬币已经平衡的最佳情况，一半的硬币投掷将被丢弃。
graph as a function of p (x axis) and rej (y axis)
实际上，我们浪费了大量可以从序列中提取的“随机性”,使我们的输出变得更短，或者需要一个必须生成很长比特序列的源！
因此，这个简单的策略似乎能完成任务，但远非最佳。该算法没有以任何方式使用其浪费的“00”和“11”序列。
让我们想办法使用它们吧！
简单有效的方法
主要概念是重新使用“00”和“11”序列，并在进一步的提取循环中将它们转换成新的“0”和“1”序列。
新策略将通过使用两个不同的来源递归地回收“浪费的随机性”:序列“丢弃/非丢弃”(即 discard_seq )和丢弃对的值(“00”编码为“0”，“11”编码为“1”，即 new_seq )。直觉上，它依赖于这样一个事实，即给定已经生成的序列，这两个源仍然是可交换的比特序列，因此有资格进行另一轮提取。
让我们看一个输入“10011011”的例子:
Step 1 with initial input
根据初始输入，我们计算 3 个序列:
- discard_seq :如果初始输入没有被 flip_coin() 丢弃，则每一位为“1”，否则为“0”。这个序列将被相同的策略递归地重复使用。
- new_seq :将“00”映射成“0”，将“11”映射成“1”。这个序列将被相同的策略递归地重复使用。
- 简单的抛硬币:这是我们在文章中使用的第一个策略。这将不会被重复使用，是最终输出的一部分。
图像中使用的颜色将被重新用作后续步骤的参考(相同的颜色，相同的来源)。
现在我们继续第 2 步，使用 discard_seq 作为输入:
Step 2 with discard_seq from Step 1 as input
这里我们还有 3 个新的序列，它们具有与上一步完全相同的属性。请注意，当没有产生输出时，会出现一个红色的 X 。
现在我们以同样的方式将此步骤的 discard_seq 用于下一步(步骤 2.1):
Step 2.1 with discard_seq from Step 2 as input
如上所述，该算法创建了 3 个新序列，其中 2 个被递归地重复使用，然后以固定顺序相互连接。当每个计算步骤都没有输出时，该过程结束。
In one image, Step 2.1.1 with discard_seq from Step 2.1, Step 2.2 with new_seq from Step 2 and Step 3 with new_seq from Step 1
从步骤 2.1 我们可以只使用一个“1”，我们不能从中提取随机性，因为没有熵了，对于步骤 2.2 和 3 也是一样。
这里是每一步算法的递归可视化，以便让您更好地了解该过程:
A visual diagram with the step executed with input “10011011”
最终的结果是“10110”，而简单的 flip_coin() 在相同的输入下只会产生“101”！现在让我们来看一个快速的 Python 实现，名为 better_flip_coin() 函数:
您会注意到，如果一个序列的位数为奇数，最后一位将被丢弃。该函数返回一个列表并直接对列表进行操作:一个用于经典的 flip_coin() ，一个用于 new_seq ，一个用于 discard_seq 。
好了，现在我们已经完成了作业，我们可以使用所学的知识并将其应用于…
第二幕，第二场…算法反击了
这里是相同的函数，但是应用于一个字符串位序列(注意 better_flip_coin()生成的是字符串位列表，而不是位列表):
结果非常有希望:
Number of extracts bits: 893 Number of 0s: 450 Number of 1s: 443
这意味着我们刚刚丢弃了 147 位，这意味着丢弃率仅为 15%！甚至分布似乎更好，得到“0”(头)的概率为 50.39% ，得到“1”(尾)的概率为 49.61% ！！！
现在让我们检查每对比特(或每对掷硬币)由两种算法产生的比特的平均值(p)。
我们已经发现 flip_coin() 的拒绝率是
rej(p)= 1–2p(1-p)，因此平均ā(p)只是它的“互补”:
为了计算 better_flip_coin() 的平均值ā’【p】，需要进行非平凡的分析，但是可以证明
我不打算在这里写演示，因为它很长。
注意，描述由 better_flip_coin() 产生的平均比特的函数等于熵函数的定义！
two graphs as function of p (x axis) and the average of bits produced by each algorithm (y axis)
这意味着 better_flip_coin() 函数本质上是你能得到的最好的！如果源已经具有均匀分布，则该算法将为来自源的每个被处理的比特产生 1 个比特。
感谢你阅读这篇文章(或者至少感谢你来到这里)。
让我知道你对这篇文章的看法，以及是否有人可以将 flip_coin() 策略应用到一个已装载的骰子上！
如何擅长行为面试
行为面试技巧远比大多数人意识到的重要。
部分原因是它们随处可见:实际上每个面试都是行为性的，至少在某种程度上是这样。
但这也是因为行为面试通常是公司招聘过程的第一步。不擅长行为面试有一种方法可以让你当场毙命——甚至在你有机会展示你花了很长时间培养的那些闪亮的技术技能之前。
因此，擅长行为面试是必须的，然而我已经数不清有多少次听到人们说“我就是不擅长行为面试”，好像不擅长技术面试是一种无法治愈的医学状况。
幸运的是，如果说我从与数百名目前和未来的数据科学家在sharpes minds的合作中学到了什么，那就是行为面试绝对可以被征服。
在这篇文章中，我想解释你如何做到这一点。
你最大的优点和缺点是什么？
我明白了，准备面试最有效的方法是真正擅长回答一个具体的、老生常谈的问题:你最大的优点和缺点是什么？
这个问题总是出现，而且并不总是被直接问到。最重要的是，善于回答这个问题意味着善于自省，因此，行为面试。
那么如何才能有效回答这个问题呢？以下是我在 SharpestMinds 使用的流程:
- 从参加一个(免费的)“大五”人格测试开始，就像这个。你将在性格的 5 个维度上得分:内向/外向、责任心、开放性、神经质、宜人性。
- 接下来，做一些自我反省，问问自己是否同意你的结果。
- 如果有，选择你获得最高分的个性维度。比方说，让我们想象你在内向方面得分很高。
- 问问你自己:在工作环境中，我的高分如何转化为优势或劣势？在我们的例子中，内向的人有哪些优点和缺点？
- 例子:内向的人从独处中获得能量，而与他人互动也耗费了他们的能量。如果你是一个内向的人，你可能对持续的单独工作有着异乎寻常的高容忍度(当事情需要完成时，这是一种优势)。然而，你也不太可能与你的同事核实你的行动方针(当你有可能最终花数小时在错误的事情上时，这是一个弱点)。
这是关键:你的长处和短处是由每个人都有的性格特征(如内向或开放)明确衍生出来的。有了这个框架，你可以看到你不应该因为你的优点而受到赞扬，也不应该因为你的缺点而受到指责:每个人都因为他们是谁而拥有这两者。
行为面试寻求的是你识别这两者的能力，更重要的是，开发策略来解决你的弱点。这是任何完美的行为面试答案的最后一步。
顶端的樱桃
"你最大的优点和缺点是什么？"
“嗯，我是一个内向的人，因此我很乐意长时间埋头专注于一项任务。这有点像一把双刃剑:因为除非必要，否则我倾向于避免社交，所以我倾向于不经常向他人汇报我的工作。因此，我学会了定期检查自己，反思自己是否达到了外部反馈可以帮助我不偏离轨道和避免兔子洞的程度。
最后一句话是你对行为问题所能给出的任何答案中最重要的部分:你制定了什么策略来解决你的弱点？即使你没有被直接问到，这也绝对应该包括在你谈论自己缺点的任何时候，因为这表明你已经花了很多心思在你是谁和你需要改进的地方，以至于你正在积极采取纠正措施变得更好。
剖析一个完美的答案
一个强有力的行为面试答案通常有 3 个组成部分:
- 提及性格来设置场景(“我是一个内向的人…”)
- 提及因你指出的个性特征而产生的相关优势或劣势(“…所以我发现我擅长 X，但在 Y 方面很挣扎…”)
- 你针对这些优点和缺点制定的策略(“…但是我发现我可以通过…”)
这适用于任何行为面试问题，而不仅仅是优点和缺点。例如，想象一下被问到一个看起来完全不同的问题:“你什么时候在工作场所经历过冲突？”
一个好的方法是这样的:
第 0 步:你可能还没有想到一个故事。所以停下来说，“这是一个有趣的问题，让我考虑一下。”→很多人没有意识到他们可以这样做，这实际上让你显得更加成熟和有思想。
第一步:设置场景。“我不得不和我的一位同事一起改进我们的推荐系统。她负责客户关系，她非常注重细节，非常认真。
第二步:介绍优势和劣势。“这太棒了，因为这意味着她可以真正进入顾客的生活，理解他们的问题，并与他们感同身受。但这也让她很难看到全局，并理解她面向客户的工作如何更广泛地适应我们的运营。因此，她一开始坚持要一些我们的预算无法提供的功能，或者在技术上不可能实现的功能，因为她觉得这些功能会给她如此关注的用户增加价值。”
第三步:描述你的策略。“当这一切终于发生时，我意识到，如果我能让她与技术团队产生共鸣，并理解他们所面临的限制，她的共鸣实际上可以成为我们项目的优势。所以我带她去见了开发团队，让他们解释了我们的系统是如何构建的，以及每个新功能对他们时间的要求。听到他们谈论需要在周末或晚上加班来完成我们当时的淡化版本，这足以改变现状，我最终得到了她的认可。”
就像技术技能一样，你使用这个框架的表现会随着练习而提高，所以做到这一点很重要。好消息是，你不需要与精通技术的人交谈来练习给出良好的行为面试答案:重要的是他们在看到时知道内省。
如果你有关于行为面试的问题，请随时在 Twitter 上联系我。我是@jeremie charris！
原载于 2019 年 12 月 18 日https://blog.sharpestminds.com。
当你还没有 3 年工作经验和博士学位时，如何被聘为初级数据科学家
作为一个新的复杂领域，招聘人员很难判断谁是合格的数据科学家，这是可以理解的。因此，你可能会看到工作申请有着难以置信的要求，例如数据科学博士学位和 3 年工作经验。如果被招聘为数据科学家的最佳方式是已经成为一名数据科学家，那么你如何才能找到一份数据科学的工作呢？以下是我对获得数据科学工作的具体建议。有些很容易实现，有些很难，但我保证它们都是值得的。
有网站
数据科学职位是一个技术职位。作为一名技术人员，拥有一个网站增加了你作为技术人员的合法性。我建议“自己”做，不要使用 Wix 或 Squarespace 这样的基本编辑器。就我个人而言，我用 R+blogdown+T1 相当快速地制作了我的网站。这是我的第一条建议，因为几乎在每次面试中，面试官都会提到我的网站有多好。我也有过几次招聘人员联系我，因为我网站的。
我已经在我的网站上添加了谷歌分析。这让我知道来自特定地理区域的人何时查看我的站点。如果我在亚特兰大申请一份且只有一份工作，拥有一个来自亚特兰大的网站视图给了我一个暗示，有人正在从那个公司看我的网站。如今，大多数公司甚至不会给你发拒绝邮件，所以浏览你的网站可能比你通常得到的信号更多。
你也应该得到一个自定义域名。除了让你的简历看起来更好之外，这还能让你的电子邮件看起来像 yourname@yourname.com 的邮件，这很不错。
网站也是一个展示你正在做的一些个人项目的地方，这就引出了我的下一个技巧。
有一个投资组合
招聘人员不一定很懂数据科学。投资组合是向他们证明你做了的最好方式。在简历上列出项目清单是很好的。更好的是有招聘人员可以点击在线查看的网址。理想情况下，你的项目有一个互动元素(例如，对招聘人员上传的图像进行物体检测，或者在他们的社交媒体上进行一些 NLP)。让你的项目变得有趣是一件大事，我在最近的文章“你的个人数据科学项目很无聊。让我们改变这一点。”我建议至少有 3 个项目，我的投资组合只有几个，但我仍然偶尔会得到积极的评价。
下面是一些你应该快速制作一个在线项目的东西:
擅长核心数据科学技能
核心的数据科学技能是 python(包括 numpy、pandas、sklearn)和 SQL。我建议看这么多教程，直到你完全厌倦为止，制作自己的教程也是一个好主意。
我参加过的很多技术面试都是一些基本的 python 或 numpy 问题(例如，寻找数组中的第二大值，寻找数组中数字的出现频率，从有序序列中寻找缺失的元素)。做 leetcode 并对 Big O Notation 和数据结构有一个很好的理解应该会让你为大多数数据科学面试做好充分的准备。
在数据科学中占有一席之地
在我看来，你应该在数据科学中有一个技术和非技术的利基。以下是数据科学中的一些技术领域(不要选择 python 或 SQL，那是你的核心技能):
- 稀有
- MongoDB
- 商务智能工具
- 计算机视觉
- 自然语言处理
- 时间序列
- 火花
- 张量流
但是，开发非技术领域也很重要，例如:
- 金融
- 运动
- 形象化
- 制造业
基本上，我认为精通一个不是 Python/SQL 的工具或过程，并且有一个专业领域是很重要的。成为数据科学子领域的专家会让你更有可能在那个领域找到工作。我相信，在未来几年内，数据科学“通才”岗位会越来越少，而对特定工具和知识的需求会越来越多。
与此相关的一些其他想法是:
- 为你的领域建立一个俱乐部/聚会
- 为 it 开源项目做贡献
- 做关于覆盖利基的 Kaggle 竞赛
- 创建专门针对你的领域的教程
要么重写你的简历，要么复印两份
如今，你的简历很可能会被电脑阅读。虽然有很多人在谈论人工智能如何彻底改变招聘，但大多数用来解析简历的程序并没有那么好。你可能认为“我应该做一份漂亮的简历来脱颖而出”，但实际上你应该想的是“我应该做一份简单的简历，这样计算机就能读懂。”有情节，表格，或者有趣布局的简历，其实是阻碍你的。
你的简历会通过一个叫做申请人跟踪系统的东西。我在这里找到了一个免费的网站来测试你的简历在 ATS 上的表现。编辑它，直到它很容易通过，并检查多个 ATS 测试人员。
你可能只想要两份简历，一份通过 ATS，另一份看起来很棒，可以亲自交给别人。
使用 Indeed 的高级搜索
据 J.T .安东内尔称，招聘人员接待第一个求职者的平均时间为 200 秒。大多数工作会有 200 名申请人。从我在 LinkedIn 上看到的情况来看，对于数据科学来说，它甚至不止于此。
如果你想让你的简历真正被浏览，如果你申请的工作发布日期是旧的，你就没有机会了。我的建议是使用 Indeed 的高级搜索，并将工作限制在“3 天内”如果这移除了很多工作，不要惊慌，新的工作一直在发布。
接下来，我建议删除那些需要大量经验的招聘信息，你也可以这样做。这些工作要么需要大量的经验，而你不适合这个职位，要么他们不需要大量的经验，但招聘人员要求很多，因为他们不太了解数据科学，认为要求类似“7 年的 TensorFlow 经验”是可以的，尽管它只有 4 年左右。不管怎样，这都不是你应该申请的工作。以下是我对取消这些工作的建议:
博士学位是消除不适合你的工作的最好方法。如果你是在申请你的第一份工作，你也可以试着加上“初级”、“小”或“入门级”这样的词。你也可以在“至少其中一个词”部分添加你的专业领域，来寻找你特别适合的工作。老实说，这是我求职的最佳建议之一，幸运的是这很容易实现。不要气馁，如果只有几个工作，在你做了这些筛选后，新的工作会一直发布。
您的 LinkedIn 个人资料
填写你的 LinkedIn 个人资料是个好主意。以下是我对此的最佳建议
- 你过去的工作描述应该至少有两段。确保使用你可能想要的工作的关键词，例如，如果你想从事计算机视觉方面的工作，在你的描述中提及计算机视觉技能。当我重写我的工作描述时，LinkedIn 开始向我展示不同的工作。
- 添加到 LinkedIn 个人资料的技能部分。很多人忘记了它的存在，但它在向你展示你可能想要申请的工作时发挥了作用。
- 利用 LinkedIn 学习，如果你是一名在校大学生，你很有可能免费获得这个或 Lynda.com。参加这些课程极大地增加了我对主题和技能的理解，但一个很好的优势是你可以直接将课程证书添加到你的个人资料中。
- 我建议在你的个人资料中放一张封面照片，而不是默认的，这表明你在乎你的 LinkedIn。最后，确保你确实有一张个人资料照片，而且是在中性背景下拍摄的。
联系 LinkedIn 上的人
一般来说，我不认为 LinkedIn 是一个申请工作的好地方，但是直接接触人们可以帮你很多。试着输入“数据科学家招聘”,搜索人而不是工作。许多人会在他们的简历中提到这一点。这些人通常不介意别人向他们寻求机会。当你提出要求时，要简短，有一个令人信服的理由你对他们公司感兴趣，有一个你申请的具体工作，包括你的简历，我建议包括一个链接到你的网站。如果你没有包括所有这些，你很可能会被忽视。我不建议在简历中没有注明要招聘的人身上试用。我在下面进行了测试，屏蔽了人们的照片、公司和姓名，但你可以看到他们的简历正是你要找的。
打动开发者的技能
你将不得不与开发人员一起工作，在许多公司的面试过程中，你甚至可能会被一些人面试。要让这些人认为你很好共事，就要投资那些让你很好共事的技能。这些包括 git、flask、docker、使用 API 以及将模型部署到云。杰瑞米·哈里斯在这篇博客文章中对此做了比我更好的报道。
打造“你的品牌”
为自己扬名是有用的，因为它可能会让人们试图雇佣你，甚至不用你去申请工作。这里有一些你可以做的事情来建立你的品牌，其中一些我已经提到过了。即使你有工作，做这些事情也是有用的，因为你永远不知道你什么时候会去找另一份工作。
- 制作一个网站(它应该包括博客部分)
- 拥有一个专业的 twitter 账户，与你尊敬的人互动，实际上我从 twitter 上学到的比 LinkedIn 多得多
- 在 YouTube 上建立教程(尤其是关于新兴技能的)
- 在介质上写东西
- 参加会议
- 参加黑客马拉松比赛(或者指导，如果你太老的话)
- 志愿者数据科学为非营利组织工作吗
- 开始聚会或俱乐部
如何入门 Python 编码？
让我们从零开始了解如何成为一名优秀的 python 程序员。
Credits: Udemy
因此，朋友们让我们学习在真正用 python 编码之前你需要入门的所有东西，以及成为一名优秀的 python 程序员你需要知道的所有东西，你需要掌握编程语言的资源。这不是一个编码教程，我不会教你们如何用 Python 编码，相反，我会分享一些想法，资源，通过一些步骤，你需要遵循成为一个好的程序员。我会尽量不让你觉得无聊，我会给你提供所有教程、书籍、GitHub 资源库等等的链接。因为你如何学习内容并不重要，重要的是你是否知道概念。对于那些在本教程主要面向您之前从未使用 python 编写过代码的初学者来说，不要担心，因为这是入门的好地方。我将告诉你我的经验，让你掌握 python 编程。我再次重申这不是一个编码教程，因为我不能一口气教你 python，但是，我会提供足够的内容让你开始。
我在下面列出了一些重要的步骤，帮助你开始成为一名 python 程序员:
1.安装 Python
在开始学习 python 之前，你必须做的第一件事就是在你的 Windows 或 Mac OS X 或其他平台上安装 python，点击下面的链接下载:
对于 Windows:
Python 编程语言的官方主页
www.python.org](https://www.python.org/downloads/windows/)
为 Mac OS X
Python 编程语言的官方主页
www.python.org](https://www.python.org/downloads/mac-osx/)
针对其他平台
Python 已经被移植到许多专门的和/或旧的平台上，下面按字母顺序列出。请注意…
www.python.org](https://www.python.org/download/other/)
一定要下载最新的稳定版本，因为每次下载安装最新版本是一个好习惯，python 几乎每个月都会发布一个新的稳定版本。另外，我推荐你下载 python 3，因为 python 3 是 python 2 的增量版本，python 3 比 python 2 有很多更方便的特性。
2.安装 IDE
到目前为止，您已经知道 IDE 是一个集成开发环境，它允许您编译和执行不同的编程语言。首先，我建议大家下载名为 PyCharm 的 IDE。PyCharm 是 Jet Brains 开发的 IDE。可能是这个星球上最好的 IDE 之一，非常容易使用和练习你的代码。我建议你从下面的链接下载它，你也可以在你的命令提示符下运行 python 程序或者使用 anaconda ，但是 PyCharm 是最好的，也是最容易编程的:
对于 Windows:
[## 下载 py charm:JetBrains 为专业开发人员提供的 Python IDE
PyCharm 现在也可以作为快照包使用。如果你使用的是 Ubuntu 16.04 或更高版本，你可以从…
www.jetbrains.com](https://www.jetbrains.com/pycharm/download/#section=windows)
对于 Mac:
[## 下载 py charm:JetBrains 为专业开发人员提供的 Python IDE
PyCharm 现在也可以作为快照包使用。如果你使用的是 Ubuntu 16.04 或更高版本，你可以从…
www.jetbrains.com](https://www.jetbrains.com/pycharm/download/#section=mac)
对于 Linux:
[## 下载 py charm:JetBrains 为专业开发人员提供的 Python IDE
PyCharm 现在也可以作为快照包使用。如果你使用的是 Ubuntu 16.04 或更高版本，你可以从…
www.jetbrains.com](https://www.jetbrains.com/pycharm/download/#section=linux)
现在，我还将提供使用由 JetBrains 官方提供的 PyCharm IDE 的提示和技巧的链接，如下所示:
发展是关注和流动。学习你的工具有助于你进入流程并停留在那里。此播放列表显示…
www.jetbrains.com](https://www.jetbrains.com/pycharm/guide/playlists/42/)
3.从在线教程和书籍中学习
显然，你不能仅仅通过自学来掌握一门编程语言，你必须并且应该在网上阅读一些教科书或文章。网上有一些最好的教科书。我建议你们仔细阅读并学习这些材料。试着一点一点地学，你不可能在一天内读完整本书。这需要时间来完成，现在下面我给了一些我认为最好的教科书的链接，现在你不需要购买它们，但是你可以通过下载来离线阅读它们，下面提供了它们的链接。
1)Python 的搭便车指南！
《Python 的搭便车指南》将熟练工 Pythonista 带到了真正的专业领域。比其他任何语言都多…
shop.oreilly.com](http://shop.oreilly.com/product/0636920042921.do)
2) Headfirst Python 第二版
想要学习 Python 语言而不苦读入门手册吗？使用 Head First Python，您将…
shop.oreilly.com](http://shop.oreilly.com/product/0636920036777.do)
下载: 头头蟒
3)想 Python
这是 Think Python 的第一版，用的是 Python 2。如果您正在使用 Python 3，您可能希望使用…
greenteapress.com](https://greenteapress.com/wp/think-python/)
下载: 想 Python
4)艰难地学习 Python
[## 艰难地学习 Python 3:一个非常简单的介绍可怕的美丽世界…
索引符号:(冒号)，创建函数，61-62(点)运算符，146-148，193 "(双引号)避免与…一起使用
www.oreilly.com](https://www.oreilly.com/library/view/learn-python-3/9780134693866/index.html)
下载: 敬酒不吃吃罚酒
5)流畅的 Python
Python 的简单性让您很快变得高效，但这通常意味着您没有使用它必须的一切…
shop.oreilly.com](http://shop.oreilly.com/product/0636920032519.do)
下载: 流畅的 Python
现在让我们看看一些掌握 python 编程技能的最佳文章。据报道，现在互联网上有大量不同的文章和出版商。最好的文章是:
1。走向数据科学
[## 搜索和查找-中等
在 Medium 上搜索，找到关于重要话题的最受欢迎的声音。
medium.com](https://medium.com/search?q=Python)
这是我几乎每天阅读有趣文章的最好的网站之一。养成每天阅读本网站文章的习惯。
2。真正的 Python
我们正在更新此页面，以使其更加有用，如果您有时间分享您对我们如何改进此页面的想法…
realpython.com](https://realpython.com/start-here/)
只要输入你的需求，这个网站会尽一切可能帮助你。可能是我推荐你们去的第二好的网站。
3。Python.org
[## Python 教程- Python 3.7.5rc1 文档
Python 是一种简单易学、功能强大的编程语言。它有高效的高级数据结构和简单但…
docs.python.org](https://docs.python.org/3/tutorial/index.html)
如果你像我一样是个喜欢每次都阅读官方文档的极客(因为我是个书呆子)，那么 python.org 就是你需要经历的一切。因为很明显，官方网站是保持内容更新的一方。他们会试图解释所有的概念，并确保每个人都理解这些概念。
4。GitHub
我不认为自己是程序员。我创建这些小程序作为试验来玩语言，或者…
github.com](https://github.com/geekcomputers/Python)
除此之外，还有一个 GitHub 库，这也是一个在线阅读的好方法。通常在将来，即使你知道更多的东西，你也应该在 GitHub 上工作，并与世界分享你的想法。
4.在您的 IDE 上练习并运行程序
现在，这一步是显而易见的，因为现在你知道你应该做什么，你正在学习所有的材料，现在唯一悬而未决的事情是键入和运行你的程序。这是必须的，因为许多学生特别是学习了概念，但他们从来没有键入和运行程序，因为通常当你键入程序时，有可能当你运行程序时，你在屏幕上得到错误，通过这个你可以看到和了解你得到什么类型的错误。当你遇到错误或有疑问时，不要担心，有一个地方会永远帮助你。
堆栈溢出:
Python 是一种多范式、动态类型、多用途的编程语言，旨在快速(学习、应用……
stackoverflow.com](https://stackoverflow.com/questions/tagged/python)
所以请输入程序，并感受它成功执行时的喜悦。
5。在 GitHub 上记录您的旅程
这是每个程序员必须开始做的最重要的事情之一， GitHub 就像是程序员的简历，因为它讲述并展示了你的工作。因此，在学习编程的时候，一定要创建一个 GitHub 库。尝试提供一个好的 read.me (Read.me 文件是一个描述文件，它告诉你的存储库是关于什么的——不要担心你在使用它的时候会习惯它)文件，并保持它的更新。谁知道谁会读你的 GitHub 库，也许有时候他们会雇佣你为他们工作。如果你不知道如何创建和使用 GitHub，请观看下面的视频:
Credits: MicrowaveSam
正如你现在已经注意到的，你已经有意或无意地到达了我的教程的末尾(查看开头的流程图)。现在我已经尽我最大的努力给你们所有的资源、工具和指导，球在你们的球场上，决定你们想用它做什么。现在，如果你们想看看我的 GitHub 库，并从中学习一些新的东西，请见下文:
对于那些不知道 Pycharm 的人来说:PyCharm 是一个用于计算机的集成开发环境…
github.com](https://github.com/Tanu-N-Prabhu/Python)
感谢你们阅读我的文章，如果你们对 Python 有任何疑问，请通过评论区告诉我，我会在几分钟内回复，或者几年内回复(开玩笑)。好了，踩油门，开始编程。再见，祝你愉快。
Credits: Giphy
如何开始使用 AWS 人工智能服务
Photo by Ivan Bandura on Unsplash
逐步进入云计算的指南
在过去的六个月里，我帮助在 AWS 上实现了一个复杂的数据管道。这条管道中与机器学习/数据科学相关的两个构建模块由我负责。
在这个过程中，我意识到有多少数据科学家希望开始在云端工作。然而，过多的服务和概念让他们望而生畏。
这篇博文是让你开始使用 AWS 的一步一步的指南。如果您继续下去，您将有一个利用云服务的基本框架。然后，您可以根据您的项目和想法轻松调整它们。唯一的先决条件是你有一个 AWS 帐户。如果没有，在这里创建一个。
我们开始吧！
第一步:明确需求。
当我写这篇文章时， AWS 提供 165 种不同的服务。有必要首先定义一个用例，以避免迷失在其中。这适用于简单的例子和现实世界的实现。
对于这篇文章，让我们假设我们想要实现一个简单的照片排序管道。每次度假后，我们都想把我们的照片分类放在两个文件夹里:里面有和没有人脸的照片。让我们在云中构建一些东西来自动化这个过程。
更具体地说，我们希望我们的照片排序过程做以下事情:
- 每当我们上传照片时，它应该会自动启动。
- 它应该可以识别照片中是否有人。
- 它应该将文件移动到“面孔”或“风景”文件夹中。
作为附加要求，我们不想一张张上传照片。相反，我们想一口气上传上一次旅行的文件夹，喝一杯咖啡或鸡尾酒，然后回来看结果。
第二步:设计整体流程。
在进入实现的细节之前，我们需要决定整体架构。也就是说，我们需要回答两个问题:
- 我们需要什么样的服务才能让它发挥作用？
- 它们是如何相互作用的？
先说第一个问题。
第 1 部分:选择合适的构建块
为了简单起见，我们希望尽可能少地限制我们的服务。我们还希望它们是按需服务，以最大限度地降低成本。最后，我们希望减少设置照片所需的时间，因为我们的主要重点是对照片进行分类。
首先，我们需要一个上传图片的地方，以及存储排序结果以备后用的地方。AWS 上的中央服务称为 S3 ( 详情 )。使用它很便宜。直到第一个 50TB，每个 GB 每月花费 2 美分多一点。
虽然 AWS 控制台上的 S3 界面看起来像您的本地文件系统，但它的工作方式不同。这对该使用情形的最大影响是我们无法移动文件。相反，我们需要将它们复制到一个新位置，然后在旧位置删除它们。
第二个，我们需要一种方法来判定图片中是否有人脸。虽然这会很有趣，但我们不需要为此建立机器学习模型。相反，我们可以使用 AWS 提供的 AI 服务之一:Amazon Rekognition(详情 )。我们可以通过 API 调用来访问这个服务。对于前 100 万张图片，每月 1000 次 API 调用总计约为 1 美元。
更具体地说，我们将使用 API 的 detect_faces 方法。应用它将为图片中找到的每张脸返回一个元素。如果没有人脸，返回的列表将为空( 详情 )。
最后，我们希望有一个服务来执行我们的排序逻辑，我们只在需要的时候付费。这是无服务器服务的主要优势。在 AWS 生态系统中， Lambda 函数就是解决方案( 细节 )。就我们的目的而言，这项服务的成本可以忽略不计。
Lambda 函数是一个庞大的主题，因为它们是 AWS 上无服务器应用程序的主干。对于本演练来说，知道它们是并行运行的就足够了，这将大大加快我们的照片排序过程。
总之，我们只需要 AWS 的三个服务:S3、亚马逊 Rekognition 和 Lambda 函数。如果我们估计一个月拍摄的照片不超过 1000 张，即每天大约 33 张，那么成本可以忽略不计。这三种服务都很容易设置和连接，我们可以在本教程中完成。
第二部分:思考它们之间的相互作用。
既然我们知道我们需要哪些构件，我们必须考虑他们的合作。在我们的例子中，我们可以认为λ功能是整个过程的大脑。它负责两件事。
首先，我们的函数需要能够读写 S3 。这些权利包括新文件的触发器和执行上述数据伪移动的可能性。第二个，我们的函数需要能够调用 Rekognition API 并接收其答案。
The Lambda function in the middle is the brain of our process. On the left, you can see S3 as its tool. Amazon Rekognition on the right will answer our API calls.
如果这对你来说太简单了:不要担心，在以后的现实生活中，你会遇到很多复杂的(可能是令人费解的)架构。
步骤 3:创建构建块和角色
第 1 部分:S3 水桶
设置新的 S3 存储桶非常简单。首先，登录 AWS 控制台，在“服务”菜单中找到 S3:
你会看到一个闪亮的蓝色“创建桶”按钮。点击它。键入您喜欢的存储桶名称，然后单击左下角的“创建”。出于我们的目的，我们不需要关心进一步的配置问题。Bucket 名称必须是唯一的，所以在 AWS 允许您创建它之前，您可能需要注入一些创造力。它现在将出现在您的 S3 桶列表中。
出于我们的目的，我们需要四个文件夹:
- 一个“上传”文件夹，我们可以把上次度假的照片放在那里。
- “处理”文件夹，防止并行处理。
- “面孔”文件夹，用于存放上面有面孔的照片。
- 一个“风景”文件夹，用于存放没有人脸的照片。
通过“创建文件夹”按钮创建它们。出于我们的目的，我们不需要担心加密选项。
太好了，我们的储物件已经就位，随时可以使用！
第 2 部分:Lambda 函数
与 S3 类似，通过 AWS 控制台找到 lambda 服务。这一次，按钮在右边，亮橙色，上面印着“创建功能”。定义一个名称，选择“Python 3.7”作为运行时。点击“创建函数”,等待 AWS 完成创建。为了完成基本设置，我们必须定义两件事:
- 上传新照片时触发的触发器。
- 一个允许我们的功能做我们要求它做的任何事情的角色。
要添加触发器，请查找“Designer”选项卡，它应该是从顶部开始的第一个选项卡。如您所见，左侧有一个“添加触发器”按钮:
当您单击它时，AWS 会建议您可以定义为触发器的服务列表。选择 S3。在下一步中，为这个项目选择您的 bucket 并添加您的文件夹作为前缀。因此，您的配置应该如下所示:
现在，每次你上传一个文件到 S3，你的 Lambda 函数的一个新实例将开始执行它的代码。很简单，对吧？
设置具有必要权限的角色更加棘手。向下滚动，直到在左侧找到“执行角色”选项卡。如您所见，AWS 已经为您的 Lambda 函数创建了一个角色。单击允许您在 IAM 控制台中查看该角色的链接。
目前，唯一的权限策略是标准执行角色:
为了让我们的应用程序工作，我们需要添加允许完全访问 S3 和 Rekognition API 的策略。为此，点击“附加策略”，查找“AmazonS3FullAccess”并点击右下角的“附加策略”。对“AmazonRekognitionFullAccess”策略进行同样的操作。现在,“权限”选项卡应该如下所示:
现在我们的 Lambda 函数有了所有必要的权利去做我们想让它做的事情。它可以从 S3 读取和写入，并使用 Rekognition API。
注意:这种添加策略的方式很方便，因此适合本演练。然而，使用策略的一般最佳实践是所谓的“授予最小特权”方法。点击查看的更多信息。
步骤 3:重新识别 API
AWS AI 服务是 API 调用，所以这里不做什么。
步骤 4:编码并测试实现
现在一切都准备好了，我们可以实现并测试代码使其工作。由于我们简单的架构，我们只需要在 Lambda 函数中编写代码。
第 1 部分:收集有效照片的路径
在 S3 逻辑中，有效照片的路径由一个桶和一个键组成。为了实现这一点——以及 AWS 和 Python 的所有其他事情——我们可以使用 boto3 库。实现同一个目标有不同的方法，但我发现这个方法对初学者来说很容易理解:
注意，如果至少有一个带有的文件，这个函数只返回一个键。上传文件夹中的 jpg 后缀。它也只处理它找到的第一个。
第 2 部分:“移动”照片从上传到处理
请记住，没有办法移动 S3 上的文件。相反，你必须将它们复制到其他地方，并删除原始文件。这个函数的确切作用是:
如果您想调整文件名，您可以进一步修改 destination_key 。
第 3 部分:调用 Amazon Rekognition API
为了优化 API 的使用，阅读关于响应结构的文档是至关重要的。在我们的例子中，我们只关心 Amazon Rekognition 识别的人脸细节(如果有的话)。
结果，我们得到一个布尔值，它告诉我们照片中是否至少有一张脸。
第 4 部分:“移动”照片到正确的文件夹
最后，我们执行与上面相同的复制/删除过程，但这次是从处理文件夹到正确的输出文件夹:
第 5 部分:在我们的 Lambda 函数中组合它
Lambda 函数的核心是所谓的 lambda_handler 。每次触发器启动 Lambda 函数时，它都会运行里面的任何东西。对于我们的示例，它看起来像这样:
第五步:享受工作成果
上传 S3 的图片，观看奇迹发生。
Photo by kyryll ushakov on Unsplash
那么，下一步是什么？
如果你跟着做，你就有了一个开始进一步实验的好地方。只是一些启发你的想法:
- 实施更精细的照片分类流程。例如，只保留笑脸照片。或者反过来，我不做判断。
- 通过将“风景”照片分成更好的子类别来扩展 API 的使用。
- 集成一个额外的 AWS 服务，一旦“上传”文件夹再次为空，它会向您发送一封电子邮件。
- …
无论您做出什么决定，云计算之旅都是一次不容错过的冒险。
如果这篇文章对你有所帮助，或者你想补充什么，请在评论或 Twitter 上告诉我。我也很乐意在 LinkedIn 上联系。感谢阅读！
数据科学入门:使用 Anaconda、Python、Jupyter 笔记本& Kaggle 竞赛的简要教程。
在本文中，我想写下我克服最初障碍并开始学习数据科学的经历。学习数据科学是一个旅程，一旦开始，你将不断学习。在本文中，我们将通过以下 5 个开始步骤进入学习数据科学领域:
- 报名参加卡格尔比赛 ( 房价比赛)。本文的最终目标是成功地向 Kaggle 上的房价竞赛提交一个输出。同时学习如何使用 Python 和机器学习。
- 下载并安装 Anaconda 发行版
- 开始使用 Jupyter 笔记本和编写 Python 代码
- 使用我们的 Jupyter 笔记本为房价竞争生成输出，即测试数据的价格预测。
- 成功提交预测输出到 Kaggle 竞赛，在排行榜上看到你的名字。
第一步:注册卡格尔比赛
学习数据科学的最佳方式是实际研究数据科学。处理数据，使用 python 分析数据，创建有用的输出，不断学习和改进结果。如果你把一个你想要解决的问题摆在你面前，所有这些都会自然发生。一旦你开始解决问题，你就会不断发现和学习解决问题所需的新事物。为此，需要一个明确定义的问题和原始数据。这正是 Kaggle 比赛给你提供的。一个起点，即一个确定的问题和一个数据集。这也是我们将开始的地方。
让我们先在 Kaggle 上注册。 Kaggle 归谷歌所有，是数据科学家和机器学习工程师的在线平台。它提供了大量的数据科学竞赛——有些有丰厚的金钱奖励。现在，让我们把奖励集中在学习上，开始一个 Kaggle 入门竞赛- 房价竞赛。
在这场竞赛中，挑战是根据训练数据集中提供的数据预测测试数据集中每个房屋的价格。您可以点击数据选项卡，并看到为您提供了 train.csv 和 test.csv 文件。你可以下载这些文件并保存在你的电脑上。因此，现在的问题是，我们如何使用训练数据集，并预测测试数据集的房价。答案是分析数据和使用机器学习。分析数据和使用机器学习的一个简单方法是使用 Python，这就是我们现在要学习的。
第二步: 下载安装 Anaconda 发行版
开源的 Anaconda 发行版是使用 Python 进行数据科学和机器学习的最简单的方法。一旦您为您的操作系统下载了 Anaconda 发行版，它将自动下载并安装 python 以及 1500 多个 Python 数据科学包。以后随着你不断学习，你会用到很多重要的包，比如 NumPy、matplotlib、pandas、scikit-learn、TensorFlow 等等。所有这些包和 python 将在您安装 Anaconda 发行版时安装。选择您的操作系统(macOS、Windows 或 Linux)并下载 Python。最新版本是 Python 3.7。
安装了 Anaconda 发行版搜索并启动 Anaconda-Navigator。你会看到类似这样的东西
在这里，我们将使用 Jupyter 笔记本。你可以在这里了解更多关于 Jupyter 笔记本的信息。
步骤 3:开始使用 Jupyter 笔记本和编写 Python 代码
让我们现在开始吧。按照下面的图像顺序。这是在苹果电脑上。这个想法是在终端中找到你想要的笔记本所在的文件夹。您可以右键单击您想要的文件夹→服务→在文件夹中新建终端。或者从搜索栏打开终端，将工作目录切换到所需的文件夹(Windows 用户可以使用 Anaconda 终端，搜索 Anaconda 终端)。一旦你在终端的目标目录中，输入 jupyter notebook 并按回车键。这将带您到默认浏览器。下一步是单击新建→ Python 2 或 Python 3(如您已安装的)。这将为您打开一个新的无标题 jupyter 笔记本，您可以在那里开始编写 python 代码。这是你的游乐场:)
第四步:使用我们的 Jupyter 笔记本为房价竞争制作输出，即测试数据的价格预测。
现在的想法是用机器学习来预测房价。我不会在这里详细解释机器学习的技术方面。我们将简要回顾总体想法的摘要，并生成最终输出，作为 submission.csv 文件，该文件可提交到房价卡格尔竞赛。你可以在我的 github 上使用这个笔记本来详细了解代码。简单解释一下相关步骤:
- 我们导入必要的包:熊猫，scikit-learn
- 读取训练数据(train.csv 文件)，将目标(即销售价格)存储在变量 y 中，选择所需的功能(功能选择)
- 将培训数据分为培训数据和验证数据
- 定义 RandomForestRegressor 模型，使用定型数据拟合模型，预测验证数据，计算误差
- 为整个训练数据拟合模型，使用此模型为测试数据集预测房价
- 将最终预测输出以所需格式存储为“submission.csv”
这里使用的代码是一个简化版本。最终的预测还有很大的改进空间。你可以在不断学习的过程中不断修改代码，改进预测。我在这里的目的是让你感受一下机器学习和 python 可以做什么。下一步是向 Kaggle 提交预测，即 submission.csv 文件。
第五步:成功将预测输出提交给 Kaggle 竞赛，并在排行榜上看到自己的名字。
进入比赛页面。点击提交预测并上传 submission.csv 文件。
提交完成后，您可以在排行榜上查看自己的名字。随着你不断学习，你将不断提高最终预测。可以重新提交输出，不断提高分数。一切顺利，学习愉快:)
如何获取所有 Spark 集群节点的 Python 环境
我们在 Invenium 对匿名手机位置数据进行分析时，使用了 Apache Spark 等工具。在我们的应用程序中，我们直接使用 Java API 和 Python API pyspark进行接口。最近，我们注意到在运行我们的算法时出现了不寻常的性能下降。
在确保我们没有对代码进行任何可能导致性能变化的更改后，我们给集群维护人员发了电子邮件，检查他们那边是否有任何更改。据他们说，除了增加几个新节点外，没有任何变化。然后，我们开始检查调度程序，发现一些节点以正常速度处理任务，而其他节点则慢得令人痛苦。这使我们对新增加的工人产生了怀疑。可能它们的某些配置与现有基础架构不同。
但是如何调试不可访问的节点呢？
由于只能直接访问边缘节点，而不能访问工作节点，因此我们想出了一个能够在工作节点上自省 Python 环境的简短脚本:
Code to query print the environment on worker nodes
据我们所知，没有安全的方法来确保脚本在所有节点上运行，因为这依赖于调度程序。作为一种变通方法，下面的代码在NUMBER_OF_PARTITIONS = 10_000分区中启动NUMBER_OF_OPERATIONS = 100_000操作，这些操作通常应该(假设集群上没有太多其他负载)平均分布在工作节点中。根据集群大小和当前负载，您可以尝试增加这些值和/或多次运行脚本，以确保它在每个工作线程上至少执行一次。
我们发现的窃丨听丨器
我们发现所有节点上都安装了相同的软件包，但是，在较新的节点上，一些软件包的版本有所不同。即使情况不应该是这样——您会希望在相同的集群节点上有不同的版本吗？—只要主要版本保持不变，这通常不是问题。但是你永远不应该抛开墨菲定律。不幸的是，包含一个性能错误的pyproj的最新版本恰好在补丁发布前几天安装，导致转换慢得多，从而导致观察到的性能下降。
我们希望这可以帮助其他人调试不可访问的集群基础设施。
如何获得关于货币汇率的 Twitter 通知:网络抓取和自动化
Image by Photo Mix from Pixabay
随着世界变得更加一体化，我们比以往任何时候都更加紧密地联系在一起。更多的学生出国留学，更多的人环游世界。无论是为了教育还是为了旅游，当我们出国或向外国汇款时，我们不得不考虑汇率。出于这个原因，我创建了一个自动通知系统，当指定货币的汇率下降或上升时，我们可以收到 Twitter 警报。
在本文中，我将解释我是如何从雅虎财经搜集汇率数据，并通过 Twitter 建立自动通知系统的。我们开始吧！
1。安装网页抓取所需的软件包
我首先安装了几个必需的包。BeautifulSoup 用于解析 HTML 页面，与时间相关的包用于记录货币兑换的日期和时间。
2.使用 BeautifulSoup 从 Yahoo Finance 中删除汇率数据
Structure of Yahoo Finance
如上图所示，雅虎财经由“符号”、“名称”、“最后价格”和“变化”组成。对于这篇文章，我只使用了“名称”和“最后价格”。
使用 BeautifulSoup，我解析了汇率页面。
解析之后，我使用 for 循环语句提取一些信息。因为我不需要完整的数据，所以我在第 40 次观察时开始解析，在第 404 次观察时停止，间隔为 14，并创建了一个只有“名称”和“最后价格”信息的货币数据帧。
由于我对美元/日元汇率感兴趣(1 美元等于多少日元？)，我选择了第 16 次观察，赋给 now_usd_jpy(当前美元/JPY 汇率)。
dataframe “Currency”
我从雅虎财经提取的汇率记录在我创建的文本文件“usdyen”中。如果当前汇率与旧汇率不同，则当前汇率会替换旧汇率。
Text file where I recorded the current USD/JPY exchange rate
3.通过 Twitter 建立一个自动通知系统
现在是时候通过 Twitter 建立一个自动通知系统了。让我们根据文本文件中记录的汇率向我们的 Twitter 关注者发送汇率通知。
为了做到这一点，我安装了 TwitterAPI 并请求 Twitter 提供访问令牌(更多详细信息，请参考【https://developer.twitter.com/】en/docs/basics/authentic ation/guides/access-tokens . html)。有了访问令牌，我的程序现在可以用“1 美元兑日元= 111.6(日本时间 05:06:37 04–05–19)”的格式发布美元兑日元的汇率。
USD/JPY exchange rate tweet
如果我们只是在 Twitter 上更新汇率，那就没什么意思了。每当我们想知道汇率时，手动运行程序实际上没有意义。说到这里，我让程序全天候运行。每隔 5 小时(60 秒 x 60 秒 x 5 小时)，我的算法会自动检查当前的货币汇率并更新旧的货币汇率，然后发布到 Twitter 上。由于 Twitter 不允许发布相同的消息，所以我使用 try 和 except block 使其可以接受。
上面提到的 web 抓取和自动化算法非常易于使用，并且可以灵活地应用于加密货币和股票价格等其他主题。在下一篇文章中，我想讨论 Rasberry pi——我们如何使用 Raspberry pi 让程序 24/7 运行，因为在我们的计算机或笔记本电脑上整天运行这个 python 脚本不是很实际。
感谢您的阅读！我希望我的文章是有帮助的，并且容易理解。如果您有任何意见或反馈，请随时在下面留下您的评论。
如果你喜欢我做的事情，请不要犹豫，在 GitHub 上关注我，在 Linkedin 上与我联系。
如何在黑客新闻上获得投票
来自一个在 HN 最多只能投一票的人
Photo by Ben White on Unsplash
动机
黑客新闻定期向 Kaggle 发布一个数据集。当我看着我的帖子在“新”部分迅速消失时，我想知道分数和故事在“新”部分的可见部分保留多长时间之间的关系，这提高了向上投票的概率。
在这篇文章中，我研究了分数和故事的不同属性之间的相关性:
- 发布日期/时间，显示发布的故事比率和分数之间的关系
- 故事类型(展示 HN……)
- 转贴效率
- 主题类别(仅使用 NLP 从标题中聚类故事)
附带的笔记本可以在 Kaggle 上找到。
HN 数据集的初步观察
我们来看看分数的分布。分数从 1 开始(当你发布你的故事时，你会自动投自己一票，这就是我目前的分数:)。
Distribution of score (capped to 20) on Hacker News
在黑客新闻上发布一个故事就像抛硬币一样。你的故事得不到支持的可能性大约是 50%
让我们通过对标题进行单词云来快速阅读 HN 上发布的主题。
Ask HN and Show HN not surprisingly stand out in word frequency
有 3.4%的展示 HN 故事和 3.3%的询问 HN 故事。让我们把这些从标题中去掉。
Hacker News summarized
更多关于趋势话题的信息，请见文章末尾。让我们深入了解是什么影响了分数。
周末出版
看看分数和几个计算属性之间的相关矩阵，最大的影响因素是一周中的某一天。
Correlation matrix of the score and other attributes of the posting
放大每周日的平均分数，我们看到周末日非常突出。
Scores are on average higher during the week-end, and so is the time between stories posted.
同样在周末，发布的故事也比平时少。周六故事之间的平均时间约为 300 万，约为周一等工作日的两倍。
不足为奇的是，当绘制平均分与故事之间的平均时间时，你会得到一个非常好的趋势。应该有同等影响的是观众的数量，我们不知道，但根据简单的假设，平均得分= k 读者故事之间的时间，那么周末 HN 的读者应该会减少 25%左右。
Choose your luck
这导致周末期间的平均故事分数比一周内高出约 30%。
做一个创造者(或者保持好奇心)
“展示 HN”的故事比“询问 HN”的故事更受欢迎，后者又比普通帖子更受欢迎。运行演示的价值是一个显著的优势。
一个普通的故事被否决的可能性是 50%,而一个 HN 秀的故事被否决的可能性是 30%
故事转贴的效率
虽然黑客新闻政策允许在合理范围内转发，但一些用户或机器人显然在滥用它，没有得到回报。
大约 4%的故事被发布了不止一次(基于标题是相同的，所以这是一个下限)。在转帖的高端，这些是我们发现的故事…
Of utmost quality
看看平均分数和转发次数，我们看到它上升到 3 次转发，然后下降，暗示垃圾邮件，如上表所示。
Higher reposts appear to be correlated with low quality of stories
由于其中一些转发来自不同的人，可能是代理一个值得注意的故事，而不是为了能见度，现在让我们来看看由同一作者转发的同一故事。下图显示了转帖的显著差异。
Big variation on story score with reposts, for apparently higher quality stories
我们可以看到你的分数有很大的变化，转贴的分数低，转贴的分数高(分数低的假设从没有足够的眼球到没有足够的兴趣)。这是一个平均值，你可以从最近的例子中看到一些边缘情况，分数徘徊在 2 左右，然后在 8 次转发后爆炸到 192。
Know your prior
让我们仔细看看你能获得的最高分和你的初始分。
Note the number of reposts are going down dramatically after 3, the bump on 5 is likely not significant
在转贴你的故事时，平均来说，你的得分会是最初的三倍多。最有影响力的转发日是周末
Looking at the days where repost is most effective
自我参考黑客新闻获得 50%的分数提升
黑客新闻喜欢黑客新闻。虽然这些故事(在标题中寻找“黑客新闻”)很少(0.2%)，但它们的平均得分为 8.4，而非黑客新闻故事的平均得分为 5.6。
关于 HN 的故事比平均得分高 50%
话题发现和流行度
我想做一些有趣的话题发现，看看是否有特定的话题得分通常较高。
为此，我使用 BERT 计算了标题的嵌入(在这种情况下，我对每个单词的嵌入进行了平均，以获得句子的固定向量长度)，还尝试了 Google 的句子编码器，结果工作得更快更好。虽然在如此高的维度上(句子编码为 512 长)通常使用余弦距离(由于点在边缘上，成对距离是相似的)，但在实践中，我发现对于 Google 的句子嵌入器(Transfomer 的编码器)的输出，欧几里德距离给出了更好的结果。此外，这种类型的分析是内存饥饿，所以我只能在我的标准问题 kaggle 内核上采样 30000 个标题。
这是发现的主题，以及它们的平均分数。请注意，这是日期，可用数据集涵盖 2013 年 12 月至 2015 年 10 月期间
Popular topics: web technology, net neutrality, the next frontier and privacy
And some unpopular topics: Hacker News readers write software and like users to be fair with it, and rise on their own merits
热门话题:网络技术、隐私、网络中立和太空探索。当然还有人工智能。
The learning machine king (ok, not many samples…)
TL；速度三角形定位法(dead reckoning)
- 在太平洋时间 12 点左右的周末出版
- 转贴你的故事是有效的，但仅仅超过一次。
- 黑客新闻奖励工作代码(展示 HN 的故事)
如何从偏见走向购买者
Photo by Arvid Malde on Unsplash
这里有很多关于估算房价的文章，也有很多关于网络搜集的文章。虽然这两者在本文中都有所涉及，但我还想重点关注那些在使用数据进行决策支持时非常容易上当的典型偏见。
最近，我离开了美丽的阿姆斯特丹，离开了一个很棒的社区里一个可爱的、明亮的小城市公寓，只是为了在奥斯陆我岳父母冰冷的地下室里过一种类似肉体的生活。不完全有资格被称为伟大的成功故事。
但因为我知道这一天会到来，我提前几个月就开始网上搜索当地的房地产市场，以尽可能缩短我寄生生活的时间，重新找到自己的家，并利用(幻觉中的)高级信息这样做。
我过去使用网络抓取收集谷歌新闻标题，这相当容易，因为我访问的网站结构非常简单。这一次，结构有点复杂，所以让我先解释一下这个网站:
网站 finn.no 是挪威几乎所有内容的首选网站。这是一个二手市场，就像房地产或就业市场一样。在房地产板块，网站提供了大约 50 个公寓的缩略图，你可以点击浏览几十个页面。
Typical structure of the real estate website
缩略图包含的信息比住房单元的大小和价格多不了多少。只有当你通过缩略图链接到一个新的网站时，你才能得到所有相关的信息，所以我不得不分两轮设置网页抓取器。
第一部分将从每个页面的每个缩略图收集“href”或链接，并将它们写入一个简单的列表。在第二部分中，一个循环遍历收集到的链接，逐个访问特定的 web 地址，并从每个存储了更多有趣信息的网站收集所有细节。
Detailed information after accessing an individual ad
高层结构到此为止。我使用 BeautifulSoup 包进行网络搜集，并收集了许多 try- except: Exception pass 语句的属性。这些代码的工作原理听起来很像:它们试图处理某个命令，但是如果它不起作用，代码就会继续运行。这在处理稍微不同的内容时是完美的，例如网页具有非常相似的结构，但不完全相同的元素。没有指定建造年份？没问题，代码继续运行，没有错误。
我在嵌套字典中收集了详细信息。在最高级别上，href 充当键，值是属性的集合。这个集合同样由多个键(属性名)和值(属性值)组成。
On the top in the back is the high level key (the web-address) and the value. In the front is this value expanded, showing the lower level key and value pairs.
字典在格式上很灵活，使用高级关键字作为索引，低级关键字作为列，可以非常快地转换成整洁的数据帧。在收集非数字属性并将它们转换成虚拟变量时，它们也很方便。像{balcony:1}这样的属性可以很容易地作为键值对收集。稍后，当将字典转换成数据帧时，键变成一个单独的列，不包含阳台键-值对的数据点得到一个None条目。通过一个 liner 和 Python 的df.fillna(0)命令，我们可以用 0 替换 None 条目，并立即得到一个二进制虚拟变量列，指示是否存在阳台。
我对奥斯陆的所有公寓运行了一次 webscraper，然后添加了一个“今天新”过滤器，并设置了一个任务调度程序来每天运行它，每天用大约 50 到 100 个新数据点扩展数据集。奥斯陆不是一个大城市，冬季是房地产市场的淡季，但几个月后，数据集约为 5500 次观察。足以获得一些洞察力和更好的市场信息。
一旦你在 Finn 上发现了一个有趣的广告，你就可以看到同一地区一段时间内出售的住房单元的平均价格，并检查你选择的单元与这个平均价格相比如何。
Finn shows average prices per m² over time in an area. The green dot displays the housing unit you inspect.
如果一所房子相对便宜或昂贵，人们很容易将此作为一个指标，我曾有房地产经纪人告诉我，某套公寓的价格“低于该地区的平均价格”。但是，如果你看到平均价格是每平方米 75 000 挪威克朗，而有问题的单元以每平方米 65 000 欧元的价格售出，这并不一定意味着它是“偷窃”。通常小公寓的每平方米价格较高，大公寓的价格较低。因此，一个地区显示的平均价格可能包含许多每平方米价格非常高的小公寓。如果你正在查看的“低于平均价格”的房子比的平均价格大得多，那么它的每平方米价格仍然可能比同一地区同样大的公寓贵。让我们看看在我的数据集中，m 的价格是否真的随着大小而下降:
Price per m² by size
这种趋势在 45 平方米以下的小公寓中尤为明显，几乎不可能找到每平方米价格低于 10 万挪威克朗(在撰写本文时约为 1 万欧元)的 25 平方米的工作室。但是小公寓也经常聚集在最吸引人的地段，因此 m 价自然已经因此而更高了。调查同一地区内的同一张图片降低了位置差异的影响，并表明这种影响持续存在:较小的公寓具有较高的 m 价格。每个人都知道比较平均值是棘手的，但值得思考的变量在发挥作用，以避免做出粗糙的误判。
我发现了我的数据库的另一个非常方便的特性；在浏览数据时，我注意到有些公寓已经被上传了不止一次，而且价格也有所调整。我很快得出结论，这将告诉我总体市场趋势的方向。正如我们所看到的，几乎所有这些都向下调整了一个大约-5%的大峰值！
Density plot of the price adjustments done on re-uploaded ads.
公寓以更低的价格重新上传对整个市场意味着什么？有那么一会儿，我推断价格正在下降，我说得对吗？不，我没有。想象一下从低价到高价的公寓分布。定价过低的公寓卖得很快，甚至可能高于最初的要价。在中间区间，具有公平要价的单位也在没有更大发行的情况下被出售，并离开市场，因此价格过低和价格公平的区间都消失了。我们只观察定价过高的设备，需要用更有竞争力的价格标签再试一次。我们从来没有看到定价过低的作品以高于其售价的价格上传。生存偏见的一种形式在这里发挥作用，而不一定是挪威房地产市场的崩溃。我仍然认为，如果你对某个特定的公寓感兴趣，并且观察到它没有卖出某个价格，回来时更便宜，这是有用的信息。想象一下，你会去看这样一套公寓。你已经知道市场拒绝了某个价格，你可能不会在第一个不成功的价格区域出价。知道卖方可能会变得不耐烦，这也可能会给谈判一点点权力。
几周后，我发现了一个我非常喜欢的公寓的广告。它看起来相对便宜，但是只有平均价格。不，我怎么能确定。我认为，根据我的数据集训练的预测模型，并预测我感兴趣的公寓价格可能会有所帮助。清理完数据后，最好稍微研究一下数据，寻找可以转换或删除以获得更好的拟合和性能的要素。让我们先看看奥斯陆的 m 和房价之间的一般关系，并在此基础上进行线性拟合。
我们观察到预期的积极关系和住房市场散点图的一个共同属性:价格的方差随着单元的大小而增加。虽然具有这种扩展形状的回归模型中的估计量保持无偏，并且预测模型仍然是可行的，但是通常有一种简单的方法来解释这种现象(称为异方差)。我们可以取两个变量的对数，而不是大小和价格之间的线性关系。
查看对数散点图，我们可以看到散点图的分布有所减少。
接下来，我必须从收集的大量属性中选择有意义的特征。我见过有人用散点图进行特征选择。他们探索解释变量和目标变量之间所谓的因果关系。有时结论是特征对目标变量没有影响，因为图形显示的是水平线拟合。但是散点图只是多维关系的二维表示，因此，它并不能说明全部情况。想象一下这个例子:假设我们有不同大小和不同位置的房子。最小的一个直接在热门的市中心。其他的位于离市中心越来越远的地方，并且随着距离的增加也越来越大。到中心的距离增加的负面影响抵消了额外的占地面积将带来的价格上涨。如果你把这些观察结果绘制成散点图，y 轴是价格，x 轴是尺寸，你可能会观察到一条水平线，并错误地得出尺寸对价格绝对没有影响的结论。我们宣扬相关性不一定意味着因果关系，但是没有相关性也不意味着没有潜在的因果关系。图中只显示了孤立的两个维度，但没有给出一些特征如何相互作用的信息。
为了研究这种相互作用，通常使用相关矩阵。对我来说，重要的是要记住，数据是如何产生的。并不是每个观察都有价值。房地产经纪人只是列出他们认为值得列出的东西。由于许多变量经常以完全相同的措辞出现，可能会有预先选择的属性可供选择，但许多“奇异”的特征对于特定的广告只出现一次，这表明它们是手动输入的。因此，一些看似可靠的变量被视为不可靠，并显示出与其他特征的错误相关程度。一些广告声称房子或公寓在“中心”。价格的一个主要驱动力当然是它所处的区域，或者像每个房地产经纪人所宣扬的那样:“位置，位置，位置！”
但并不是每个位于中心的住房单元都在数据集中获得了这一属性。只有那些房产经纪人想特别强调这种品质的房子。
比依赖这样一个弱功能更好的方法是根据住房单元的地址创建邮政编码虚拟变量。我们无法列出某个地点吸引人的每一个单独因素，我们当然也无法从芬恩那里收集这些因素，但我们知道或接受一些邮政编码通常是好的地点。邮政编码模型捕捉了一个地方无法解释的全部吸引力，包括位于市中心、有很棒的学校或低犯罪率。由于邮政编码通常在地理上是群集的(0251 紧挨着 0252，以此类推)，我们使用一个更高的级别，比如 3 位数，来对邮政编码进行分组，并确保我们对每个邮政编码哑元有足够的观察。为了得到邮政编码假人，你可以使用非常方便的“get_dummies”函数:
df = pd.concat([df, pd.get_dummies(df.post_code3)], axis=1)
同样重要的是要记住，广告就是广告(废话),因此只列出积极的属性，有时会方便地省略掉那些可能被认为是消极的属性(一楼的公寓经常“忘记”说明他们所在的楼层)。对此我无能为力。但是，即使没有这种复杂性，数据中属性相同的两个公寓也不一定是相同的。在我的数据中，如果一套公寓的窗外被邻近建筑的外墙挡住，或者浴室看起来像 70 年代的半腐烂真菌换妻派对，那么没有属性捕捉到这一特征。数据捕捉到了很多东西，但审美不在其中。所以预测也不会考虑公寓的条件。
另一方面，连续变量相当可靠，因为它们包含最基本的信息。
From left to right: floorspace, price (in NOK), running costs, floor, energylabel (converted from letters), construction year.
在分类变量中，我发现最有用的是:房屋类型和所有权的模型、邮政编码、有无阳台、花园、壁炉(在挪威非常普遍和流行)→所有观察的 25%!)、电梯、车库或停车点。我还保留了一些更“奇特”的假人，如果它们被足够频繁地提到(超过 10%的观察)，但不会像“基本的下水道入口”那样过时。这些变量包括“看门人服务”。
我运行了两个不同的模型。对数规范中的线性回归和梯度推进模型。在训练模型之前，我分离了我想要预测的一个观察值，以便该观察值是真正“新”的。对于线性模型，没有必要进行训练-测试-分割，因为如果限制估计量的函数形式，过拟合就不是问题。
from sklearn.metrics import mean_squared_errorfrom sklearn.linear_model import LinearRegression
Y = df.price_log
X = df.drop(columns = 'price_log')
regressor = LinearRegression()
regressor.fit(X, Y)
print('Liner Regression R squared: %.4f' % regressor.score(X, Y))
mse_linear = mean_squared_error(Y, regressor.predict(X))
print("MSE: %.4f" % mse_linear)
regressor.predict(ad_for_pred)
对于梯度推进模型，我尝试了一些参数设置，但没有花太多时间优化它们，因为预测不会随着每次变化而显著变化。在线性模型中，测试集的 R 比整个集的 R 稍高(0.89 比 0.85)，并且均方误差降低(0.012 比 0.014)。该模型很容易建立:
from sklearn.model_selection import train_test_split
from sklearn import ensemble
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.3, random_state=0)
params = {'n_estimators': 500, 'max_depth': 4, 'min_samples_split': 30, 'min_samples_leaf':10,'learning_rate': 0.1, 'loss': 'ls'}
regressor_gr_boost = ensemble.GradientBoostingRegressor(**params)regressor_gr_boost.fit(X_train, y_train)
mse_gb = mean_squared_error(y_test, regressor_gr_boost.predict(X_test))
print("MSE: %.4f" % mse_gb)
print('Gradient Boosting training set R squared: %.4f' %regressor_gr_boost.score(X_train, y_train)
print('Gradient Boosting test set R squared: %.4f' %regressor_gr_boost.score(X_test, y_test)
regressor_gr_boost.predict(ad_for_pred)
根据线性预测，我感兴趣的物品的价格比 Finn 上列出的要价高 5%。梯度增强显示甚至有 8%的差异。在这种情况下，准确的预测是次要的，鉴于之前讨论的数据质量缺陷，对欧元肯定是不正确的。但我们得到了一个明确的指示，鉴于其特点，该公寓的价格处于低端。
我决定去看房，看看这套公寓是否物有所值。它位于一条热闹的街道上，有许多商店和咖啡馆，但也有一些交通，甚至有一条电车线，这可能是价格较低的原因。我仍然认为它相对便宜，因为我的预测给了我一种感觉，如果我要在一个更安静的小街上寻找一个类似的公寓，我必须期待的价格。其实最后还是买了(真人真事，不只是为了本文的叙述)。数据分析并没有让我决定买什么样的公寓，但它提供了决策支持。当我获得几十万欧元的贷款时，我会很乐意接受任何我能得到的支持。
条形图竞赛？
我的好奇心始于这种在 reddit/datasibeautiful、youtube/wawamustats 上非常流行的“条形图竞赛”。
有一种更简单的方法，你可以输入你的参数，制作你自己的条形图比赛。https://app.flourish.studio/@flourish/bar-chart-race。看起来是这样的:
数据科学家喜欢应用如此多的模型和方法，但当涉及到向具有各种技术技能水平的人解释时。图表抓住了注意力，更好地进行叙述。
为了练习和展示一个例子，我从 FiveThirtyEight github repo:【https://github.com/fivethirtyeight/data/】T2 获得数据集，或者如果你是一个 R 用户，有一个直接的包，你可以安装并从中获得乐趣。我的练习数据集是关于:https://github . com/fivethirtyeight/data/tree/master/approvals-June-30的数据集。数据集是关于初选前的背书数据。其中包括 2000 年至 2012 年 6 月 30 日前候选人的背书点数据。
如果你对我如何绘制赛车条形图感兴趣，你可以阅读我在本教程中关于如何使用 matplotlib.animation 模块从简单的 matplotlib 动画开始的笔记。
让我们一步一步来看看发生了什么。导入所需的模块后。获得 FiveThirtyEight 样式的一个简单方法是使用 style.use()。Matplotlib 还有一个动画模块，可以帮你做大部分工作。
- 步骤 1:导入库
让我们尝试绘制将在动画结尾显示的第一个条形图，这是观众应该看到的最后一帧。
- 步骤 2:布局基本条形图
步骤 3:添加颜色和分组数据
我使用 python 颜色常量模块来格式化颜色:
[## Python 颜色常量模块- Webucator 博客
对于 Pygame 和其他图形作品，拥有保存颜色 RGB 值的颜色常量是很有帮助的。我不能…
www.webucator.com](https://www.webucator.com/blog/2015/03/python-color-constants-module/)
- 第四步:将它们放入一个函数中
第五步:使用动画。FucAnimation 函数来完成画面
您也可以导出为 gif 或 mov 文件。在中，只需改变速度参数 fps(每秒频率)和 dpi 来调整分辨率。保存功能。
我完全可以带着后见之明的偏见阅读图表，竞选资金并不能预测候选人的表现。但除此之外，一个很酷的动画条形图并不能告诉你未来会发生什么。毕竟，如果我们想阅读一篇真正科学和分析性的文章，仅仅进行一些可视化是远远不够的。我研究了内特.西尔弗和他的团队。以下是一些关键要点。
先问正确的问题
当 x 轴上有大范围的值和 y 轴上有分类变量时，条形图竞赛的类型是这种情况的典型代表。看到这些年来的巨大变化或谁在某些行业“领先”是很有趣的。然而，对于像这样的特定数据集，没有足够的年度数据来绘制条形图竞赛。在这次尝试之后，我再也不会为了仅仅是为了审美上的绘图或者为了它的流行而开始绘图了。
根据对 FiveThirtyEight 的编辑和评论员的采访，在他们的主要“项目”中，该团队提出了一个问题——“谁将在 2016 年赢得总统大选？”，“唐纳德·特朗普有多受欢迎/不受欢迎？”—然后确定要包括哪些类型的数据集，并相应地构建模型。该方法大致基于棒球衍生的策略“ sabermetrics ”，即统计学家收集广泛和深入的可能相关的定量信息，并使用它来模拟潜在的未来结果。科学家这个词提醒我们所有人，工程思维和科学思维都是前进道路上的精华。
图表的准确性
上面条形图的主要视觉指示器是频率计数，而不是突出显示百分比。这种可视化强调了数据分析的科学本质，而不是提供一个理想的，但更容易解读的对现在演员比例的未来的一瞥。这种方法也有助于数据可视化中正在进行的问题，其中“美丽”数据的美学与如何准确传达信息的问题相交叉——这是艺术辩论中常见的形式挑战。( 1)
除了创建精确的图表，并不总是有一致的数字解释。Nate Silver 在一次采访中提到，73%的读者误读了他们发布的图表和结果，称其中一些人没有以正确的方式解释几率和百分比。数据新闻似乎在我们身上有如此大的力量，有可能改变我们的认知和行为。
参考资料:
- t .布莱克(2018)。数字不会说谎:FiveThirtyEight 概率预测中的事实和未来。剧院杂志 70 (4)，519–538
- 斯蒂格勒(2016)。统计智慧的七大支柱
如何用 Pandas 和 Dask 在 Python 中处理大型数据集
如何使用 Pandas 和 Dask 进行并行计算来处理大型数据集，以及何时将更大的问题转移到 SQL。
TL；速度三角形定位法(dead reckoning)
Python 数据科学家经常使用熊猫来处理表格。虽然 Pandas 非常适合中小型数据集，但较大的数据集存在问题。在本文中，我将展示如何使用 Pandas 和 Dask 并行计算来处理大型数据集——以及在其他方法都失败的情况下何时将更大的问题转移到 SQL。
Photo by Debbie Molle on Unsplash
在大型数据集上使用熊猫
Pandas 是一个处理数据表的极好的库。它的 dataframe 构造为数据分析提供了一个非常强大的工作流，类似于 R 生态系统。它相当快，功能丰富，并且有据可查。事实上，它已经成为遵循 Python 方式的数据科学家使用的基本工具。
然而，在使用 Python 而不是 R 的数据科学家的生活中，总会有笔记本电脑发脾气、拒绝再做任何工作、死机的时候。
尽管如此，Pandas 在执行计算时通过将数据集保存在 RAM 中来实现其速度。这就是为什么它有一定的限制(当然，这也取决于机器的规格)。
为什么会这样？
该问题通常源于过度复杂的转换过程中数据帧的意外扩展，或者从文件盲目导入表。这可能非常令人沮丧。
那么如何才能修复呢？
一种解决方案是将数据限制在一个较小的子集内——例如，每隔 n 个值探测一次数据源。但通常这还不够。
但是如果限制数据不是一个选项呢？
是不是意味着我们就是不能用熊猫做大数据集？
幸运的是，有一种方法可以解决这个问题。
最常见的解决方案是将 Pandas 与另一个解决方案结合使用，如关系型 SQL 数据库、MongoDB、ElasticSearch 或类似的解决方案。在 Sunscrapers，我们完全同意这种方法。
但是你有时可以使用 Pandas 和另一个方便的 开源 Python 库 、Dask 来处理 Python 中大于内存的数据集。
Dask 是一个健壮的 Python 库，用于执行分布式和并行计算。它还为 Python 定义的任务(类似于 Apache Airflow)的动态调度提供了工具。它与 NumPy 紧密集成，并为 Pandas 提供了数据帧等效结构——dask . data frames——该结构基于延迟加载，可用于以块和并行方式执行数据帧操作。它还通过在幕后执行数据洗牌来自动支持分组。
本文概述了一些方便的提示和技巧，帮助开发人员在使用 Python 处理大型数据集时减少一些障碍。
这是数据集
为了展示 Pandas/Dask 的威力，我从维基百科选择了一个关于网站访问者来源的开源数据集。您可以在这里获得【点击流】表格(在.tsv ) 。
点击流数据包含 4 个主要列:
- Prev’—访问者来自的站点(我将其重命名为‘coming _ from’)
- curr’—目标文章页面(重命名为“文章”)
- 类型’—该列描述了推荐的类型，例如，外部链接(我将其重命名为‘referral _ type’)
- n’—访问次数
接下来，我想出了几个问题来摆弄我的数据集，并检查 Pandas 和 Dask 的组合是否有效:
- 在给定的文章中，人们最常点击哪些链接？
- 用户从所有外部搜索引擎获取的最受欢迎的文章是什么？
- 在一个给定的文章页面上，有百分之多少的访问者点击了链接到达那里？
- 每篇文章最常见的访问来源是什么？(显示在单个表格中)
数据集大小为 1.4 Gb，因此存在内存过载的巨大风险。这就是为什么我把研究分成两部分。
首先，我只使用 Pandas 库对有限的数据子集进行了分析。然后，我尝试使用 Dask 在完整集上做完全相同的操作。
好了，接下来进行分析。
准备数据集
让我们获取数据进行分析:
if [ ! -d “./data” ]
then
mkdir ./data
echo ‘created folder ./data’
fi*# get the data if not present:*
if [ ! -f “./data/clickstream_data.tsv” ]; then
if [ ! -f “./data/clickstream_data.tsv.gz” ]
then
wget [https://dumps.wikimedia.org/other/clickstream/2018-12/clickstream-enwiki-2018-12.tsv.gz](https://dumps.wikimedia.org/other/clickstream/2018-12/clickstream-enwiki-2018-12.tsv.gz) -O ./data/clickstream_data.tsv.gz
fi
gunzip ./data/clickstream_data.tsv.gz
fi
现在，让我们看看这里有什么样的数据，并将其导入数据框。
此时，我们可以执行的第一个内存优化步骤(假设我们现在已经知道了我们的表结构)是在导入期间指定列数据类型(通过dtype=输入参数)。
这样，我们可以强制熊猫将一些值转换成内存占用明显较低的类型。
如果您正在处理几千行，这可能没有多大意义，但是在几百万行中会有显著的不同！
例如，如果您知道一个列应该只有正整数，那么使用无符号整数类型(uint32)而不是常规的 int 类型(或者更糟— float，这有时可能会自动发生)。
df = pd.read_csv(‘data/clickstream_data.tsv’,
delimiter=’\t’,
names=[‘coming_from’, ‘article’, ‘referrer_type’, ‘n’],
dtype={
‘referrer_type’: ‘category’,
’n’: ‘uint32’}
)
最后，为了提高速度，我们将数据帧的大小限制在前 100k 行。
注意，这通常是个坏主意；当对子集进行采样时，每隔 n 行进行一次采样更为合适，这样可以获得尽可能均匀的采样。但是因为我们只是用它来演示分析过程，所以我们就不打扰了:
df = df.iloc[:100000]
Q1:在一篇给定的文章中，人们最常点击哪些链接？
为了回答这个问题，我们需要创建一个表，在这个表中我们可以看到每篇文章和每个来源的访问者总数(coming_from列)。
因此，让我们对文章中的表进行聚合，coming_from列，对'n'值求和，然后根据'n'和对行进行排序。以下是我们对熊猫的研究方法:
top_links = df.loc[
df['referrer_type'].isin(['link']),
['coming_from','article', 'n']
]\
.groupby([‘coming_from’, ‘article’])\
.sum()\
.sort_values(by=’n’, ascending=False)
和结果表:
熊猫+达斯克
现在让我们使用 Dask 库重新创建这些数据。
from dask import dataframe as dddfd = dd.read_csv(
‘data/clickstream_data.tsv’,
delimiter=’\t’,
names=[‘coming_from’, ‘article’, ‘referrer_type’, ‘n’],
dtype={
‘referrer_type’: ‘category’,
’n’: ‘uint32’},
blocksize=64000000 # = 64 Mb chunks
)
注意，read_csv函数与 Pandas 函数非常相似，除了这里我们指定了每个块的字节大小。我们执行的聚合逻辑也几乎与 Pandas 相同:
top_links_grouped_dask = dfd.loc[
dfd[‘referrer_type’].isin([‘link’]),
[‘coming_from’,’article’, ‘n’]]\
.groupby([‘coming_from’, ‘article’])
这还不会做任何计算，top_links_grouped_dask将是一个 Dask 延迟数据帧对象。然后我们可以通过.compute()方法计算它。
但是我们又不想堵塞内存，就直接存到硬盘吧。我们将使用 hdf5 文件格式来实现这一点。让我们宣布 hdf5 商店:
store = pd.HDFStore(‘./data/clickstream_store.h5’)
并将数据帧计算到其中。
注意，用 Dask 对列值进行排序并不容易(毕竟，数据是一次读取一个块)，所以我们不能像在 Pandas 示例中那样使用sort_values()方法。
相反，我们需要使用nlargest() Dask 方法并指定我们想要确定的顶部值的数量:
top_links_dask = top_links_grouped_dask.sum().**nlargest**(20, ‘n’)
它也返回一个延迟的 Dask 对象，所以为了最终计算它(并将其保存到存储中),我们运行以下命令:
store.put(‘top_links_dask’,
top_links_dask.compute(),
format=’table’,
data_columns=True)
在这种情况下，结果与 Pandas 示例中的值不同，因为这里我们处理整个数据集，而不仅仅是前 100k 行:
Q2:用户从所有外部搜索引擎获得的最受欢迎的文章是什么？
那一个很容易。我们需要做的就是过滤掉包含“外部”referrer_type和“其他-搜索”coming_from值的行:
external_searches = df.loc[
(df[‘referrer_type’].isin([‘external’])) &
(df[‘coming_from’].isin([‘other-search’])),
[‘article’, ‘n’]
]
然后，我们只需根据访问者的数量对值进行排序:
most_popular_articles = external_searches.sort_values(
by=’n’, ascending=False).head(40)
瞧啊。
熊猫+达斯克
这次用 Dask 在完整数据集上做同样的事情怎么样？
external_searches_dask = dfd.loc[
(dfd[‘referrer_type’].isin([‘external’])) &
(dfd[‘coming_from’].isin([‘other-search’])),
[‘article’, ‘n’]
]
因为我们只需要存储前 40 个结果，所以我们可以简单地将它们直接存储在 Pandas 数据帧中:
external_searches_dask = external_searches_dask.nlargest(
40, ‘n’).compute()
它返回以下内容(此处仅显示前 5 行):
这是一个很好的问题，需要用图形来回答，所以让我们画出前 40 个最高值:
sns.barplot(data=external_searches_dask, y=’article’, x=’n’)
plt.gca().set_ylabel(‘’)
问题 3:给定文章页面的访问者中有多少人点击了链接到达那里？
这个问题的框架表明，我们需要能够计算特定文章标题的分数。因此，让我们创建一个函数，它接受一个数据帧和所需的文章标题，然后返回百分比值。
该函数必须过滤给定文章的行，对所有访问者计数求和，然后在referrer_type列中找到带有“链接”值的访问子集的累积和 n:
def visitors_clicked_link_pandas(dataframe, article):
df_article = dataframe.loc[dataframe[‘article’].isin([article])]
a = df_article[‘n’].sum()
l = df_article.loc[
df_article[‘referrer_type’].isin([‘link’]),
‘n’].sum()
return round((l*100)/a, 2)
让我们测试其中一篇文章，比如标题为“Jehangir_Wadia”的文章:
>>> visitors_clicked_link_pandas(df, ‘Jehangir_Wadia’)
81.1
这表明约 81%的“Jehangir_Wadia”文章访问者是通过点击外部链接到达的。
熊猫+达斯克
我们如何使用 Dask 将它扩展到整个数据集？很容易。我们所要做的就是使用 dask-dataframe 而不是 Pandas 的，并将.compute()方法添加到函数的两个内部语句中，就像这样:
def visitors_clicked_link_dask(dataframe, article):
df_article = dataframe.loc[dataframe[‘article’].isin([article])]
a = df_article[‘n’].sum()**.compute()** l = df_article.loc[
df_article[‘referrer_type’].isin([‘link’]),
‘n’].sum()**.compute()**
return round((l*100)/a, 2)
运行该函数将返回相同的结果:
>>> visitors_clicked_link_dask(dfd, ‘Jehangir_Wadia’)
81.1
Q4:每篇文章最常见的访问来源是什么？
要回答这个问题，我们需要两列:一列用于目标文章和源标题，以及访问次数的总和。此外，我们必须过滤掉每篇文章中访问者数量最多的行。
首先，让我们通过对每个coming_from / article组合的referrer_type计数进行聚合和求和，去掉所有不必要的额外列:
summed_articles = df.groupby([‘article’, ‘coming_from’]).sum()
接下来，让我们找到为每个文章页面产生最高访客数的推荐者(coming_from)。
一种方法是通过df.iloc[]方法使用带有所需行索引的过滤表。因此，让我们为summed_articles表找到那些对应于每篇文章最高的n。
我们将使用一个叫做idxmax的漂亮的 Pandas 方法，它返回具有最大值的分组列的索引。再次聚合summed_articles，这次是在coming_from列上，我们可以这样运行它:
max_n_filter = summed_articles.reset_index()\
.groupby(‘article’)\
.idxmax()
让我们先预览一下过滤器:
现在我们可以用这个表过滤掉summed_articles行:
summed_articles.iloc[max_n_filter[‘n’]].head(4)
最后，我们需要按访问者的最高数量对值进行排序:
summed_articles.iloc[max_n_filter[‘n’]]\
.sort_values(by=’n’, ascending=False)\
.head(10)
搞定了。
熊猫+达斯克
现在，让我们尝试在完整数据集上用 Dask 重新创建这个中等复杂的任务。第一步很容易。我们可以像这样用summed_articles创建一个表，没有任何问题:
summed_articles = dfd.groupby([‘article’, ‘coming_from’])\
.sum()\
.reset_index()\
.compute()
但是最好不要将它存储在内存中——我们将不得不在稍后执行聚合，这将需要大量内存。因此，让我们将它(在计算时)直接写在硬盘上，例如 hdf5 或一个拼花文件:
dfd.groupby([‘article’, ‘coming_from’])\
.sum()\
.reset_index()\
.to_parquet(‘./summed_articles.parquet’, engine=’pyarrow’)
到目前为止一切顺利。
第二步是创建过滤表。这就是问题的开始:在撰写本文时，Dask dataframes 还没有可用的idxmax()实现。我们必须随机应变。
第一种方法
例如，我们可以将summed_articles索引复制到一个新列中，并通过一个定制的 apply 函数输出它。然而，还有另一个问题——数据的 Dask 分区意味着我们不能使用iloc来过滤特定的行(它要求所有行都使用":"值)。
我们可以尝试使用一个loc方法，通过检查它们的索引是否出现在先前确定的过滤表的列表中来选择行，但是这将是一个巨大的计算开销。真扫兴。
第二种方法
这里有另一种方法:我们可以编写一个自定义函数来处理聚合数据，并与groupby-apply组合使用。这样，我们可以很容易地克服上述所有问题。
但是……apply方法的工作原理是将来自单独处理的行子集的所有数据输出连接到一个最终的表中，这意味着它必须临时存储在内存的一个部分中，不幸的是……
取决于我们对数据的运气，它可能足够小，也可能不够小。我试了几次，发现它堵塞了我的(16BG RAM 笔记本电脑)内存，最终迫使笔记本内核重新启动。
第三种方法
我没有放弃，而是求助于解决方案的黑暗面，尝试迭代各个组，找到正确的行，并将其添加到磁盘上的 hdf5/parquet 存储中。
第一个问题: **DaskGroupBy** 对象没有实现 **iteritem** 方法(在写的时候)，所以我们不能使用 **for-in** 逻辑。
最后，我们可以找到所有的article / coming_from唯一组合，并迭代这些值，用get_group()方法对summed_articles行进行分组:
dfd[[‘article’, ‘coming_from’]]\
.drop_duplicates()\
.to_parquet(‘./uniques.parquet’)for item in pd.read_parquet(‘./uniques.parquet’,
engine=’pyarrow’).itertuples():
t = dfd.groupby([‘article’,‘coming_from’])\
.get_group(item)\
.compute()
...
这应该可行，但这个过程会慢得令人难以置信。这也是我放弃用 Dask 解决这个问题的原因。
我在这里想说的是，不是所有面向数据的问题都可以用熊猫(轻松)解决。当然，一个人可以投资大量的 RAM，但大多数时候，这不是一个好办法——对于一个拥有笔记本电脑的普通数据人员来说当然不是。
这类问题最好还是用传统的 SQL 和关系数据库来解决，即使是简单的 SQLite 也能在非常合理的时间内执行得更好。
我们可以用几种方法解决这个问题。这是其中之一。
我的解决方案基于将数据存储在 PostgreSQL 数据库中，并在PARTITION BY和ROW_NUMBER函数的帮助下执行复合查询。我在这里使用 PostgreSQL 数据库，但它也可以是最新的 SQLite3(版本 3.25 或更高版本)，因为它现在支持按功能分区——这就是我们的解决方案所需要的。
为了能够保存结果，我创建了一个新的 PostgreSQL 数据库“点击流”,在 Docker 容器中本地运行，并通过 SQLAlchemy 接口引擎从 Jupyter 笔记本连接到它:
import psycopg2
from sqlalchemy import create engineengine = create_engine(‘postgres://<db hostname>/clickstream’)conn = psycopg2.connect(
dbname=”clickstream”,
user=”postgres”,
password=”<secure-password>”,
host=”0.0.0.0")cur = conn.cursor()
然后，我们对 group by article 和coming_from列上的 Dask 数据帧进行求和，并清除制表符和返回字符中的字符串数据，这会干扰 PostgreSQL 上传:
summed_articles = dfd.groupby([‘article’, ‘coming_from’])\
.sum()\
.reset_index()\
.compute()for c in ['\t', '\n', '\\']:
summed_articles[‘article’] = \
summed_articles[‘article’].str.replace(c, ‘ ‘)summed_articles[‘coming_from’] = \
summed_articles[‘coming_from’].str.replace(‘\t’, ‘ ‘)
同样，在这一点上我们仍然没有执行任何编辑，并且summed_articles仍然是一个延迟的 Dask 对象。
在将数据帧上传到数据库之前，要做的最后一件事是在现有的数据库中创建一个空表，因此发送一个具有正确列名的空表将会非常有效:
pd.DataFrame(columns=summed_articles.columns).to_sql(
‘summed_articles’,
con=engine,
if_exists=’replace’,
index=False)
最后，让我们上传数据到里面。注意，在编写 Dask dataframe 时没有提供to_sql方法，所以我们可以使用另一个技巧来快速逐块完成:
for n in range(summed_articles.npartitions): table_chunk = summed_articles.get_partition(n).compute()
output = io.StringIO()
table_chunk.to_csv(output, sep=’\t’, header=False, index=False)
output.seek(0)
try:
cur.copy_from(output, ‘summed_articles’, null=””)
except Exception:
err_tables.append(table_chunk)
conn.rollback()
continue
conn.commit()
接下来，我们创建一个SELECT语句，该语句通过article对行进行分区，通过访问次数列n对行进行局部排序，并用整数对排序后的组进行增量索引(每个分区子集从 1 开始):
SELECT
row_number() OVER (
PARTITION BY article
ORDER BY n DESC
) ArticleNR,
article,
coming_from,
n
FROM article_sum
然后，我们通过文章列再次聚合这些行，只返回那些索引等于 1 的行，本质上是过滤掉给定文章中具有最大'n'值的行。以下是完整的 SQL 查询:
SELECT t.article, t.coming_from, t.n
FROM (
SELECT row_number() OVER (
PARTITION BY article
ORDER BY n DESC
) ArticleNR,
article,
coming_from,
n
FROM article_sum
) t
WHERE t.ArticleNR = 1
ORDER BY n DESC;
然后，通过以下方式对数据库执行上述 SQL 查询:
q = engine.execute(‘’’<SELECT statement here>’’’).fetchall()
pd.DataFrame(q, columns=[‘article’, ‘coming_from’, ‘n’]).head(20)
瞧，我们的桌子准备好了。
此外，显然连字符和减号之间的差异让许多人在 2018 年夜不能寐:
我希望这篇指南能够帮助你使用 Pandas + Dask 组合来处理 Python 中的大型数据集。很明显，一些复杂的分析任务最好还是用其他技术来处理，比如传统的关系数据库和 SQL。
注 1:在使用 Dask 时，每个 dask-dataframe 块以及最终输出(转换为 Pandas dataframe)必须足够小，以适合内存。
注 2:这里有一些有用的工具，有助于关注与数据大小相关的问题:
[**%timei**](https://ipython.readthedocs.io/en/stable/interactive/magics.html)**t**Jupyter 笔记本中的魔法功能[**df.memory_usage()**](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.memory_usage.html)[**ResourceProfiler**](http://docs.dask.org/en/latest/diagnostics-local.html)从到**dask.diagnostics**[**ProgressBar**](http://docs.dask.org/en/latest/diagnostics-local.html)[**sys.getsizeof**](https://docs.python.org/3/library/sys.html#sys.getsizeof)[**gc.collect()**](https://docs.python.org/2/library/gc.html)
如何在 PostgreSQL 中处理特权
我曾经低估了内部工具处理特权的重要性，或者至少误解了它的意图。我将在这里讨论的用例是一个数据库集群，其中的用户是一个研究小组中的研究人员。因为这是一个小团体，本质上每个人都有权利阅读和修改数据。当我被要求将集群迁移到新的服务器并在此之前做一些数据清理时，问题就暴露出来了。事实证明
- 大多数数据库都没有很好的文档记录，人们很难弄清楚一些旧数据库的语义。这个问题可以通过 schemaspy 和 PostgreSQL 自己的注释这样的工具部分解决。
- 有些字段使用类似于
varchar(n)的类型，但是只存储数值——我通过模式匹配查询发现了这一点。 - 一个数据库有多个名为
xyz-[year]的模式，模式间有重复的数据。从第一点，你可以看到我不知道这样的设计是故意的还是简单的错误。
因此，即使没有人想以任何方式破坏数据，由于缺乏权限管理和使用数据库的明确准则，人们也可以很容易地将数据库集群弄得一团糟，维护数据变得极其困难。这些问题很大程度上是由于学术界的研究人员非常独立地工作，他们主要关心的是做自己的研究项目。确保每个人在数据库集群中做出正确的行动实际上是不可能的。我们决定在新的服务器中限制用户的权限，当创建、删除和更新发生时，必须通知数据库管理员。
为了更好地用代码演示我们的解决方案，假设现在我们组中只有五个人。postgres将是管理员用户。user1和user2负责数据库demo12。user3和user4为demo34。我们希望只允许人们在数据库管理员的许可下在他们负责的数据库上写。每个人仍然可以读取所有数据。总而言之，我们希望在数据库级别获得写访问的粒度，在集群级别获得读访问的粒度。
旁注:小心混淆 PostgreSQL 和 MySQL 中的“数据库”概念。粗略地说，PostgreSQL 中有表<模式<数据库<集群。“<”应读作“包含于”。
PostgreSQL 中没有简单的内置解决方案。如果你阅读了GRANT的文档，听起来下面的代码应该已经解决了我们一半的问题
GRANT CREATE, CONNECT, TEMPORARY ON DATABASE demo12 TO user1, user2;
GRANT CREATE, CONNECT, TEMPORARY ON DATABASE demo34 TO user3, user4;
不幸的是，事实并非如此。这个 StackOverflow 帖子说明了我们必须处理的繁重工作。
然而，向用户 1/2/3/4 授予相应的权限并不是一个可伸缩的解决方案。首先，这个组中实际上有超过五个人，并且在我们的集群中有超过两个数据库。此外，新的人可能会加入小组，而现有的研究人员将在某个时候离开。为每个用户的特权记账不是一个非常干净的解决方案。
我们将结合使用 PostgreSQL 的ROLE和USER来构建一个简单的层次结构，如下所示:
Dotted circles represent roles and solid circles represent our users. Rounded squares are our databases. Meanings of the arrows are explained by the demo below.
PostgreSQL 中的ROLE和USER会造成很大的混乱。但是从我正在使用的版本 10 开始，文档清楚地说
CREATE USER现在是*CREATE ROLE*的别名。唯一的区别是当命令拼写为CREATE USER时，默认情况下假定为LOGIN，而当命令拼写为CREATE ROLE时假定为NOLOGIN。SQL 标准将用户的定义留给实现。
许多人将ROLE用作包含多个USER的“组”角色。我们在这里也将以这种方式思考。
顺便说一下，如果您想知道为什么处理 PostgreSQL 的特权值得写一篇文章，这里给出了其中一个原因
请注意，角色是在数据库集群级别定义的，因此在集群中的所有数据库中都有效。
因此，我们需要数据库级别的写权限，但是角色是在集群级别定义的。更糟糕的是，应该调用GRANT(和REVOKE)……我想在我们的例子中的每一层都应该调用。虽然这些概念应该很好地协同工作来帮助管理系统中的用户，但它们似乎是由许多人以不同的设计思想设计的。
听够了我的抱怨。让我们静观其变。
设置
我们首先创建一些应该存在于系统中的角色和用户。
$ psql -U postgrespostgres=# CREATE ROLE readonly;postgres=# CREATE ROLE rw_demo12;postgres=# CREATE ROLE rw_demo34;postgres=# CREATE USER user1 ENCRYPTED PASSWORD 'user1';postgres=# CREATE USER user2 ENCRYPTED PASSWORD 'user2';postgres=# CREATE USER user3 ENCRYPTED PASSWORD 'user3';postgres=# CREATE USER user4 ENCRYPTED PASSWORD 'user4';postgres=# GRANT readonly TO user1, user2, user3, user4;postgres=# GRANT rw_demo12 TO user1, user2;postgres=# GRANT rw_demo34 TO user3, user4;
我事先在两个数据库中都注入了一些虚拟数据。这里显示了我们的数据库中有什么。
demo12(demo34)=# \dnList of schemasName | Owner----------+----------public | postgres(3 rows)demo12(demo34)=# \dList of relationsSchema | Name | Type | Owner--------+--------------+-------+----------public | departments | table | postgrespublic | dept_emp | table | postgrespublic | dept_manager | table | postgrespublic | employees | table | postgrespublic | salaries | table | postgrespublic | titles | table | postgres(6 rows)
配置"readonly"
我们现在将授予readonly读取集群中所有数据库的权限。在外层的FOR循环中，我们遍历每个想要设置特权的数据库。在内部的FOR循环中，我们遍历每个数据库中的所有模式。
如果我们有不止一个数据库demo12和demo34，并且我们想要为所有数据库配置readonly角色，我们可以使用
DATABASE_NAMES=$(psql -U postgres -t -c “SELECT datname FROM pg_database WHERE datistemplate = false AND datname <> ‘postgres’;”)
获取集群中所有数据库的列表。然后简单的把for DBNAME in "demo12" "demo34"换成for DBNAME in $DATBASE_NAMES。
您可能想知道GRANT和ALTER DEFAULT PRIVILEGES之间的区别，以及为什么前者需要放在一个循环中，而后者不需要。简而言之，GRANT改变数据库中特定模式中当前对象的权限，而ALTER DEFAULT PRIVILEGES改变数据库中未来对象的权限。是的，当我们在ALTER DEFAULT PRIVILEGES中没有指定任何特定的模式时，这些更改会应用到整个数据库。所以又多了一个不同步的命令:ALTER DEFAULT PRIVILEGES可以在数据库级别调用，但是GRANT不能。
你注意到ALTER DEFAULT PRIVILEGES命令中的FOR ROLE postgres部分了吗？密切注意，看看它一会儿能怎样欺骗我们。
配置"rw_demo12" and "rw_demo12"
让我们看看下面的代码会发生什么。
$ psql -d demo12 -U user1 -Wdemo12=> create schema foo;CREATE SCHEMAdemo12=> create table foo.bar(col1 int);CREATE TABLEdemo12=> insert into foo.bar values(1);INSERT 0 1demo12=> \c demo12 user3You are now connected to database "demo12" as user "user3".demo12=> select * from foo.bar;ERROR: permission denied for schema fooLINE 1: select * from foo.bar;demo12=> \dnList of schemasName | Owner--------+----------foo | user1public | postgres(2 rows)
我们以user1的身份登录，在demo12中创建一个名为foo的模式，并在其中创建一个表。现在当user3连接到demo12并试图读取数据时，显示user3没有权限。这怎么可能呢？user3不是可以读取所有数据库的readonly成员吗？
原因显示在Owner栏中。foo的主人是user1。当我们做ALTER DEFAULT PRIVILEGES FOR ROLE postgres GRANT SELECT ON TABLES TO readonly时，我们只授予postgres拥有的未来对象的特权。因此，readonly及其成员不能在user1拥有的表上进行选择。
我知道我刚才说了我们希望负责人能够写入数据库，但是上面的例子表明这会导致阻止其他用户读取数据。因此，一个简单(但非常严格)的解决方法是强制postgres拥有所有对象。这对我们的情况来说并不坏，因为创建和删除远不如更新数据那么频繁。
rw_demo12和rw_demo34的配置如下
不幸的是，这并不能阻止拥有连接权限的用户在模式public中创建新表(并因此拥有它们)。为了避免这种情况，我们需要对所有数据库额外执行REVOKE ALL ON SCHEMA public FROM public。只要把它放在外部循环中，我们就有了完整的配置脚本。
试验
如果我们想从rw_demo12组中删除user1，我们只需要做
REVOKE rw_demo FROM user1;
类似地，如果我们想为数据库rw_demo12添加一个newuser，只需将它授予组
GRANT rw_demo TO newuser;
如果我们要拒绝所有对demo12的更新，而角色rw_demo12中的成员远不止user1和user2呢？我没有找到任何可以检索此类信息的现有查询。我认为这是因为 PostgreSQL 将每个用户映射到他们所属的所有组角色，而不是相反。所以我们需要撤销我们之前授予rw_demo12的特权，脚本会像以前一样麻烦。但是，嘿，这次我们有一些一致性😃
替代设置
如果你想要一个更灵活的解决方案，即允许除管理员之外的用户拥有对象，我们可以用NOINHERIT来破解它。我们采用这种严格实现的原因是，我们不想在像ALTER DEFAULT PRIVILEGES FOR ROLE postgres, user1,user2,user3,... GRANT SELECT ON TABLES TO readonly这样的命令中列出所有用户。但是如果我们能确保demo1对象的所有者只有postgres和rw_demo12，那就更容易管理了。我们对使用NOINHERIT的用户使用不同的设置。
$ psql -U postgrespostgres=# DROP USER user1, user2, user3, user4;postgres=# CREATE USER user1 NOINHERIT ENCRYPTED PASSWORD 'user1';postgres=# CREATE USER user2 NOINHERIT ENCRYPTED PASSWORD 'user2';postgres=# CREATE USER user3 NOINHERIT ENCRYPTED PASSWORD 'user3';postgres=# CREATE USER user4 NOINHERIT ENCRYPTED PASSWORD 'user4';postgres=# GRANT readonly TO user1, user2, user3, user4;postgres=# GRANT rw_demo12 TO user1, user2;postgres=# GRANT rw_demo34 TO user3, user4;
现在user1只能连接到集群，因为它不会自动继承rw_demo12的权限。为了查看数据，user1必须显式地做SET ROLE TO readonly。同样，如果user1想要在某些表中插入值，或者创建新表(这在我们提出的解决方案中是禁止的)，那么user1需要SET ROLE TO rw_demo12。这样，user1或user2创建的所有新的未来对象将归rw_demo12所有。所以你看，这种替代方案更灵活，但牺牲了用户体验。
参考
[## PostgreSQL:文档:12:第 20 章。客户端身份验证
当客户机应用程序连接到数据库服务器时，它会指定它想要哪个 PostgreSQL 数据库用户名…
www.postgresql.org](https://www.postgresql.org/docs/12/client-authentication.html) [## PostgreSQL:文档:12:第 21 章。数据库角色
PostgreSQL 使用角色的概念来管理数据库访问权限。角色可以被认为是一个…
www.postgresql.org](https://www.postgresql.org/docs/12/user-manag.html) [## 无法更改默认权限
感谢给数据库管理员栈交换贡献一个答案！请务必回答问题…
dba.stackexchange.com](https://dba.stackexchange.com/questions/114834/cant-alter-default-privileges/114839#114839) [## 如何管理用户对数据库和模式的默认权限？
我在哪里可以找到这方面的像样的指南、教程或视频系列？你会在手册中找到一切。下面的链接…
dba.stackexchange.com](https://dba.stackexchange.com/questions/117109/how-to-manage-default-privileges-for-users-on-a-database-vs-schema/117661#117661) [## 为什么允许新用户创建表？
我想知道为什么一个新创建的用户可以在连接到数据库后创建一个表。
dba.stackexchange.com](https://dba.stackexchange.com/questions/35316/why-is-a-new-user-allowed-to-create-a-table) [## 更改角色的默认权限
我有一个名为 Blackacre 的数据库和两个可以访问它的角色:johnrole 和。janerole 被授予所有…
dba.stackexchange.com](https://dba.stackexchange.com/questions/135168/alter-default-privileges-for-role) [## 将数据库中特定模式的 all 权限授予 PostgreSQL 中的组角色
您找到了为给定模式中的所有现有表设置特权的捷径。手册阐明:(但请注意…
stackoverflow.com](https://stackoverflow.com/questions/10352695/grant-all-on-a-specific-schema-in-the-db-to-a-group-role-in-postgresql/10353730#10353730) [## 在 PostgreSQL 中授予特定数据库的权限
我正从 MySQL 迁移到 PostgreSQL，但在用户权限方面遇到了瓶颈。我习惯于给用户分配所有…
stackoverflow.com](https://stackoverflow.com/questions/24918367/grant-privileges-for-a-particular-database-in-postgresql/24923877#24923877) [## PostgreSQL:文档:11:更改默认权限
更改默认权限-定义默认访问权限更改默认权限[针对{角色|用户}…
www.postgresql.org](https://www.postgresql.org/docs/11/sql-alterdefaultprivileges.html)
如何利用人工智能驾驭语言的力量
你听说过图灵测试吗？图灵测试是艾伦·图灵在 1950 年设计的一项测试，旨在观察机器是否能够表现出与人类无法区分的对话行为。
当艾伦·图灵(Alan Turing)第一次开发 T2·图灵测试(Turing Test)时，他严格地将实验限定为纯文本对话，而不是完整的语音对话。为什么？他不想让 20 世纪 50 年代蹩脚的机器人声音泄露“机器人是谁”背后的线索测试。但是自从这个测试被首次构思以来，纯文本规则就一直存在了很多年甚至几十年。许多计算机科学家认为，我们实际上更接近于建立一个完全像人类一样的对话代理，而不是建立一个现实的文本到语音系统。
文本到语音转换
首先，什么是文字转语音？TTS 是一个语音合成系统，可以将自然语言转换成可听语音。很有可能，你已经多次和使用 TTS 系统的聊天机器人交谈过。Siri 背后的声音？亚马逊 Alexa？Google Home？是的，那些声音实际上是合成的声音(大部分是)。TTS 系统有多种工作方式。
在这篇博客中，我们将特别关注神经 TTS 是如何工作的。让我们深入了解语音合成是如何完成的！
串联方法
拼接方法，主要是单元选择方法，是最常用和最广泛使用的语音合成技术。拼接模型从非常大的预先录制的音频数据库中检索短的语音片段，并拼接多个片段以生成可听语音。然而，这种方法是不可扩展的，因为每当需要不同风格的语音生成时，它们都需要新的数据集。此外，由于这种方法的性质，合成的音频不具有一致性，听起来很像机器人。
Source: https://www.explainthatstuff.com/how-speech-synthesis-works.html
参数方法
可伸缩性的问题导致了参数模型的使用，其中语音的生成可以通过如何定义输入来控制。大多数参数模型都专注于从给定的文本输入中生成声学特征，并通过使用一组称为声码器的算法，将它们转换为音频信号。
神经文本语音转换(TTS)
在这篇博客中，我们将具体看看 Tacotron ，这是一个流行的神经网络，经常被 TTS 追随者在许多机器学习框架中重新实现(经常是多次)！Tacotron 团队已经发表了不少关于神经 TTS 的论文，所以我们将着眼于那些已发表论文的核心部分，Tacotron！
文本到声音特征
大多数参数 TTS 模型具有文本到声学特征的近似阶段。在这里，文本输入被转换成密集的声学特征，声码器可以使用这些声学特征来产生音频信号。在神经 TTS 中，我们不太关心文本的语义，而更关心形成单词的空间和形态结构(音素和字形)。字符级(或甚至音素级)的一维卷积通常用于提取这种信息。因为我们不太关心语义，所以减少了对单词嵌入的需求，并且不经常使用单词级标记。(如下图)
Source: https://arxiv.org/pdf/1703.10135.pdf
注 : 有趣的是，最近研究了通过用相应的单词嵌入来调节字符以注入语义知识，可以实现这些网络的半监督训练的效果。这表明语义上下文可以与形态学信息结合使用，以帮助更好地提取声学特征。这也可能表明，单词嵌入也包含空间和结构信息。(如下图)
Source: https://arxiv.org/pdf/1808.10128.pdf
Tacotron 遵循标准方法，其中网络具有编码器-解码器结构。在编码器中，采用 3 层逐字符卷积神经网络来从文本的字符序列中提取长期上下文，例如形态学结构。最初由 max pooling 和 highway layer 跟随，但后来被删除。使用批处理规范化和 ReLU 激活。然后，使用单层双向 RNN 以顺序方式组合局部特征。
在解码器端，提取的表示然后被转换成密集的声学特征(声谱图),随后可以使用称为声码器的不同算法将其转换回音频。关注由位置敏感注意机制在每个时间步长生成的上下文向量，堆叠的 RNN 层被用于预测基于先前隐藏状态和从编码器提取的文本表示的每个帧(或多个帧)。以这种方式训练 Tacotron，可以在推理时从文本特征中近似出完整的声学特征，而无需在基于 HMM 的参数模型中使用特定的对齐算法。
注: 要考虑的一个有趣点是所学的语言和声学表征。由于 Tacotron 提取语言特征，如字符和音素排列，并使用它们来生成频谱图，中间表示可能包含丰富的声学和语言特征。这些信息可以用于其他相关任务吗？还有说话者代表呢？本文讲的是用说话人和韵律嵌入来训练 Tacotron。我们是否可以通过从这个连续的空间采样，生成一个地球上不存在的任意人声？
Source: https://arxiv.org/pdf/1803.09047.pdf
声码器
那么我们如何将获得的声学特征(即。光谱图)回到音频信号？事实证明，人工生成的频谱图通常过于平滑，缺乏为传统声码器创建高保真音频信号所需的特定信息。这部分是由于相位声码器的质量、声学特征建模的准确性以及频谱图的过度平滑(因为传统的声码器是基于 mel 倒谱的并且具有简单的相位重构算法)。这导致提取的频谱图缺少从频谱图重建语音所必需的相位信息。这意味着合成语音通常听起来很低沉，并且有伪像。
Wavenet
为了解决上述问题，谷歌 DeepMind 在 2016 年发表了一篇论文，名为“ Wavenet ”，它可以生成音频信号，不是从频谱方面，而是使用堆叠层的扩张卷积神经网络进行完全自回归采样。Wavenet 生成的音频不会显示伪像和消音，因为它们不是从声谱图以并行方式重建的，而是以先前的音频样本为条件。有很多令人惊讶的博客文章深入讨论了 Wavenet(包括作者的，所以我不会深入讨论 Wavenet 如何工作的细节。由于这种新的智能架构，Wavenet 实现了最先进的合成音频质量，这仍然是任何其他架构无法比拟的。
关于 Wavenet，我想说的一点是它的灵活性及其根据本地特征调节网络并从中生成语音的能力。原始论文考虑了其他声学特征，如对数基频和语言特征，如音素排列等。然而，后来的研究表明，Wavenet 可以直接调节简单的声学特征，如 mel-scale 频谱图，以生成更好的语音质量(链接到论文)。这表明，受 Wavenet 等强大架构影响的 mel 频谱图是一种用于音频相关任务的特殊音频-声学特征。
Source: https://arxiv.org/pdf/1712.05884.pdf
结论
我们已经研究了从文本中提取声学特征的新标准方法，然后使用它们来生成高保真语音。我们在高层次上研究了用于神经文本到语音转换的两个主要模型。以下是关键要点:
- 文本中的语义上下文对于音频生成任务来说不是必需的，但是如果数据的大小很小，则有点有用
- 语言和声学特征可以与诸如说话者嵌入和韵律嵌入的连续分布连接，以向 Tacotron 模型提供更多的归纳偏差
- 梅尔标度频谱图是非常有用和紧凑的音频声学特征，当以 Wavenet 变体为条件时，能够生成高保真语音。
Tacotron 和 Wavenet 的作者都没有为论文发布代码，但在 Github 上有 Tacotron 和 Wavenet 的惊人实现，你可以分别在这里和这里找到。我们已经讨论了神经 TTS 的高级管道，但是如果你想更深入地研究这个问题，请看看这篇博客中提到的论文。此外，如果你认为我忘记了添加一个关于神经 TTS 的有价值的信息，或者想讨论更多关于它，请不要犹豫与我在 minsang.kim.142@gmail.com 联系
感谢阅读，并请在评论中留下问题或反馈！
如何雇佣和建立一个软件开发团队！
让软件开发得更快的最好方法是尽早开始。但是这里的问题并不是每个人，特别是小企业有一个 软件开发团队 听候他们的召唤。所以，问题来了，如何雇佣一个专门的软件开发团队？
在本文中，我们将讨论参与软件开发的不同人员，以及是什么让他们成为一个团队。此外，我们还提到了在团队组成中应该注意哪些属性，以雇佣合适的软件开发团队。
招聘从来都不是一件容易的事情，但是当你需要招聘一个软件开发团队来满足你的定制软件需求时，事情就变得更加复杂了。但是，组建一支优秀的团队对任何企业的成功都至关重要。
说到软件开发，通常不止两个人要跳探戈。你需要一个技术可靠、灵活且一致的团队，作为一个整体来开发你梦想中的软件。
现在，有多种方法可以让你开始雇佣你梦想中的软件团队:
[1]口碑，即你认识的人的推荐[2]在独立的第三方门户网站上搜索，如 Upwork
[3]滚动浏览目录网站，如 Clutch 或goodforks
[4]谷歌上的有机搜索
不管你的来源是什么，我们已经列出了一个问题清单，在雇佣你的软件开发团队之前，你绝对需要问你潜在的软件开发人员这些问题。
让我们来谈谈更复杂的下一步——谷歌帮不了你。让我们来谈谈为一个好的软件开发团队创建一个坚实的基础，以及使你预想的软件获得成功所涉及的不同的人或角色。
业务分析师或项目经理
项目经理在软件开发中的角色——在雇佣软件团队时，你接触的第一个人是项目经理或业务分析师。他们首先了解您的业务需求，记下功能并进行映射。
然后，他们充实所有细节，并将需求转化为适当的技术需求文档或 SOW。
项目经理的角色是战略性的，包括计划和组织时间和资源以成功完成工作。技术架构师、开发人员、设计人员、测试人员都是重要的资源，但是他们之间的相互作用和项目流程需要有人来协调。因此，项目经理需要在最短的时间内以最大的效率协调资源、任务和人员。
主要职责:
[1]引出项目需求和进一步的分析[2]编写必要的文档[3]活动和资源规划[4]协作并激励团队[5]与客户保持沟通
[6]管理项目的范围
不管这个项目有多难或者有多小，一定要在软件团队中包括一个项目经理。
你应该在项目经理身上寻找的一些明显的品质是对细节的关注，非常非常清晰的沟通，资源管理能力，多任务能力，领导素质和对技术平台的一些熟悉。检查这些技能，把好的和优秀的分开，确保项目不偏离轨道。
设计师
任何优秀设计的目标都应该是改善整体用户交互体验，并提供最大的客户满意度。设计师最初从理解业务流程和用户交互序列开始，然后根据用户流程创建基本的线框和解决方案。
他的主要职责是设想最佳方法，并提供屏幕的模型和设计，以便它们可以用于创建最佳体验。他们需要不断改进用户交互——屏幕、按钮和其他视觉元素。
主要职责:
[1]了解完整的用户旅程[2]开发线框
[3]设计原型
好的设计不仅仅是美学，更多的是用户交互。查看一些他们设计的现场网站，确保他们对设计有眼光，并且总体上很好奇。当然还有很棒的沟通！
网络开发者
这分为两种资源—前端开发人员和后端开发人员。
(一)前端开发人员:一旦业务需求明确，设计完成，接下来是什么？将设计带入生活。完全是前端开发者做的事情！他们采用静态设计，并将其转化为一个全功能的交互式网络应用程序，可在所有设备上运行。HTML/CSS、JavaScript/jQuery、Angular、Aurelia、Bootstrap、Backbone.js 等。是前端开发人员使用的一些技术。
主要职责:
[1]确保 UI/UX 设计的技术可行性[2]优化用户交互元素以获得最大速度和可扩展性[3]针对 SEO 优化的有意义的语义
(b) 后端开发人员:设计完成，用户流程完善后，有人要确保所有的业务逻辑和数据存储都正确实现。这就是后端开发者的工作。后端是任何软件的主干。它由服务器、数据库和服务器端应用程序组成。Linux、Apache、MySQL、PHP、MongoDB、Express.js、AngularJS、Node.js 等是后端开发人员使用的一些技术。
主要职责:
[1]数据库创建、集成和管理[2]云计算[3] API 集成[4]安全检查[5]备份和恢复
[6]发布新的应用程序版本
寻找那些不仅能写好代码，而且对逻辑和系统也很在行的人。他们必须愿意付出额外的努力来确保您的系统是健壮的，并且完美地代表了您的业务逻辑。此外，确保开发人员有良好的沟通和任务管理技能。最后，他们不应该反对调试和修复错误。
质量保证和测试专家
因此，分析了业务需求，设计和开发了 web 应用程序，现在您想要让您的 web 应用程序运行起来！诱人！保持冷静，因为现在是质量保证的时候了。
实际上，QA 测试应该从软件供应商提供给你的第一个可交付产品开始。一旦实现了新的特性，QA 测试人员就会勤奋地、刻苦地审查这些特性，寻找业务逻辑或设计方面的问题。这也将帮助你降低软件开发成本。
主要职责:
[1]编写测试[2]进行测试
[3]测试应用程序与各种浏览器和设备的兼容性
QA 测试人员应该始终牢记用户交互和接受，并相应地准备测试场景。一个以客户为导向，关注细节，能够区分轻重缓急的人应该是一个好的测试人员。
-…总结::-
为了确保你的网络应用的成功，请一个有能力端到端管理项目的软件开发团队。在项目经理的领导下，您的定制软件开发团队必须由设计师、前端和后端开发人员以及软件验证人员组成。
你的项目是否成功最终取决于你雇佣的软件开发团队采取的方法。花一些时间与软件开发团队交流，并保持最新的功能。永远记住，如果你想开发一个优秀的产品，你需要一个优秀的团队。
最初发表于: 双星
如何使用机器学习识别酒店交易
A beautiful shot of Las Vegas to catch your attention — photo credit to Prexels
拉斯维加斯是世界上最好的度假目的地之一。它是世界娱乐业的中心。在这篇摘录中，我想探索使用机器学习预测拉斯维加斯酒店价格的理论，以最终确定是否有人向你提供交易。我们开始吧！
借助当今的动态定价技术，酒店价格每分钟都可能波动。这是由多种原因造成的，如供求、竞争、季节性、位置和一周中的某一天。为了这个项目的简单，我想知道我们是否可以使用两个主要因素来预测拉斯维加斯的酒店价格:位置和星期几。当然，除了这些主要因素之外，我们还将使用其他属性，但我们将在稍后讨论。我希望用这个博客来解释我在这个项目中的工作流程，并详细阐述一些决定。尽情享受吧！
这是我的方法:
- 从 Hotels.com 收集酒店列表信息
- 预处理数据
- 训练一个机器学习模型
- 评估模型性能
- 要点和建议
网页抓取
我同时使用 BeautifulSoup 和 Selenium 从 hotel 收集了 3 个月的酒店列表信息。我搜集的一些信息包括入住和退房日期、成人和儿童的数量、到城市和会议中心的距离、酒店地址、酒店评论和评级、猫途鹰的评论和评级、酒店设施以及标价。我希望这篇节选更侧重于机器学习，这样我就不会用抓取的细节来烦你。如果你对我如何使用 BeautifulSoup 和 Selenium 感兴趣，你可以在我的 GitHub 上找到更多信息。
数据预处理和 EDA
刮出来的原始数据极其杂乱。从 2019 年 11 月到 2020 年 1 月，我总共收集了 2 万个酒店列表。如果你对数据感兴趣，你可以在我的 GitHub 上找到一个腌制的数据集。在预处理和提取所有有用的信息后，我们得到了以下特征:
- 入住和退房日期
- 成人和儿童人数
- 距离市中心和会议中心的距离
- 邮政区码
- 酒店评级和评论
- 访客评论的数量
- 猫途鹰评分和评论
- 挂牌价格
- 酒店便利设施
尽管酒店的价格在很大程度上受到我上面提到的供需、季节性、竞争、位置和星期几的影响，但我想看看我们是否可以仅使用我收集的特征来产生一个强大的机器学习模型。以下是 2019 年 11 月至 2020 年 1 月拉斯维加斯的酒店平均价格…
一个直接的观察结果是，在 2006 年 11 月、2008 年 12 月 30 日和 2008 年 1 月出现了价格高峰。我还看了价格分布，它严重倾斜，所以通常的处理步骤是转换它。在这种情况下，我使用了对数变换来使价格分布看起来更为正常。
接下来，我使用一键编码方法将所有分类特征转换为 1 或 0。我还过滤掉了一些标价在每晚 450 美元以上的房源。最后，在预处理之后，我们总共有大约 16，000 个观察值和 104 个特征。
建模
不用说，这是一个线性回归问题。为了提醒我们，以下是线性回归分析的五个假设:
- 我们的输入特征和输出变量之间的关系是线性的
- 特征呈正态分布
- 要素之间几乎没有多重共线性
- 这些特征之间几乎没有自相关
- 余数均匀分布在零附近
我们的数据不需要遵循上面的每一个假设来产生一个好的模型。我们稍后将会看到如何处理其中的一些问题…
按照标准程序，我们将数据分为训练集、验证集和测试集。我们将拿出测试集进行最终评估。我使用 Statsmodel 软件包生成了一个初步的普通最小二乘(OSL)模型。Statsmodel 可以方便地生成一个汇总表，显示 R 和调整后的 R 值。更重要的是，它还输出我们所有特征的 p 值列表。p 值是对特征显著性的度量。我移除了 p 值为 0.05 或更大的所有特征。p 值为 0.05 意味着观察到的数据可能有 5%的几率是随机的。R 值是模型解释了多少可变性。在我们的例子中，R 值是 0.602，这意味着我们的模型解释了大约 60%的方差。
根据初步的模型，我使用了 Scikit-learn 软件包中的 Lasso 和 Ridge regression。套索和山脊算法允许我们应用正则化来帮助过度拟合。
- Lasso 回归将通过向系数(β)分配零来惩罚对模型不太重要的要素，从而有助于要素选择。发现正则化系数为 0.0001。这告诉我们，Lasso 回归模型本质上与我们的简单线性回归模型相同，没有特征被消除。
- 另一方面，岭回归将有助于处理要素多重共线性。它通过分配一个非常低的值系数β来抑制具有高度多重共线性的要素的影响。发现正则化系数为 13.970。这意味着我们的数据中存在多重共线性，但岭回归可以减少这种影响。
- 找到最佳超参数(例如正则化系数)的有效方法是使用 GridSearchCV。这是一种交叉验证技术，用于搜索一系列参数，同时优化用户指定的分数。
估价
对于我们的问题，我们可以使用许多评估指标。我马上想到的两个是平均绝对误差(MAE) 和均方根误差(RMSE)。如果我们想惩罚那些预测异常值很差的模型，RMSE 是一个很好的指标。由于我们将数据集过滤到每晚 450 美元或更低的标价，使用 MAE 就足够了。最后，结果如下:
Cross-validation score for hotel price prediction in Las Vegas
所有三个模型进行了类似的比较。我选择了简单的线性回归模型。更简单、更快速的模型的好处超过了性能的小幅提升。我还生成了一条学习曲线来验证模型是否存在偏差或方差。
Learning Curve: a bias/variance tradeoff analysis
从学习曲线中，我们看到训练和验证分数都接近 32 美元的渐近值。该模型不存在高偏差或高方差。为了提高分数，我们将需要额外的功能或更复杂的算法。
最后但同样重要的是，下面是预测价格与实际价格的对比。我们可以看到，该模型更好地预测了低于 150 美元的较低等级酒店。这是有道理的，因为随着酒店变得越来越贵，还有其他特征，如房间大小、服务质量或其他便利设施，我们的模型没有考虑在内。
要点和建议
解决机器学习问题最重要的部分是从我们的结果中找到潜在的信息。我们经常会问——为什么我们要关心这些结果？这些结果有意义吗？或者这些结果揭示了关于我们问题的深刻信息？
让我们来看看我们的特征系数(beta)。
Lowest Feature coefficients (Beta)
如果酒店在这些日期内预订和/或位于这些邮政编码区内，那么它们是最便宜的。
最后一次提醒我们，酒店价格受供求、季节性、竞争、位置和一周中的日子的影响很大。我们只使用了五个变量中的两个(位置和星期几)来建立一个模型。最后，该模型在预测较便宜酒店的标价时平均表现更好。
如果你做到了这一步，让我们回到我们最初的问题(如标题所示)——如何识别酒店交易
- 你想在拉斯维加斯预订，有一个价格为每晚 150 美元的交易。
- 该模型预测价格为 182 美元。
- 平均来说，由于 MAE 是 32 美元，酒店应该贵到 214 美元或便宜到 150 美元。
- 如果预测价格比挂牌价格高出至少 32 美元，那么你就找到了一笔交易！
这个方法一点也不完美。我们假设酒店价格是固定的，但我们知道不是。我们还假设您提前几个月进行预订，因为所刮取的数据是相对于刮取时间的未来数据。
总之，如果没有季节性、供求和竞争方面的数据，预测酒店价格是很困难的。让一台机器使用静态数据集来确定你是否得到了一笔交易就更难了。
感谢您的阅读！
项目存储库可以在这里找到。
你也可以在我的 LinkedIn 上找到这个帖子。
如何实现机器学习进行预测性维护
随着工业 4.0 继续引起媒体的关注，许多公司都在努力应对人工智能实施的现实。事实上，预测性维护的好处，如帮助确定设备状况和预测何时应该进行维护，是非常具有战略意义的。不用说，基于 ML 的解决方案的实现可以导致大量的成本节约、更高的可预测性和系统可用性的增加。
在不同的 ML 项目之后，我想写这篇文章来分享我的经验，也许可以帮助你们中的一些人将机器学习与预测性维护相结合。
什么是预测性维护:在预测性维护场景中，随着时间的推移收集数据以监控设备的状态。目标是找到有助于预测并最终防止失败的模式。
您可以解决的一些问题:
我已经解决了这些问题，但其他问题也确实存在…
为什么在预测性维护中使用 ML
坦率地说，预测性维护只需要对机器状况何时处于需要维修甚至更换的状态进行非正式的数学计算，以便能够准确地在最有效的时间和方式进行维护。
然而，ML 消除了大部分猜测，帮助工厂经理专注于其他任务……ML 使您能够:
虽然某些设施管理者确实执行预测性维护，但这通常是使用 SCADA 系统来完成的，该 SCADA 系统设置有人工编码的阈值、警报规则和配置。
SCADA: 一个用于采集和分析实时数据的计算机系统。SCADA 系统用于监测和控制电信、水和废物控制、能源、石油和天然气提炼和运输等行业中的工厂或设备
这种半手工的方法没有考虑到机器的更复杂的动态行为模式，或者与制造过程相关的上下文数据。
相比之下，ML 算法需要数据(来自生产车间:传感器、PLC、历史记录、SCADA)、IT 数据(上下文数据:ERP、质量、MES 等)。)，以及描述机器之间同步性的制造过程信息，以及生产流程的速率。
在工业人工智能中，被称为“训练”的过程使 ML 算法能够检测异常并测试相关性，同时在各种数据馈送中搜索模式。
战略决策
要理解维护的重要性，我们来考虑一家公交公司。如果公共汽车的引擎坏了，公司需要处理不满意的顾客，并送去替换品。失败的成本远远高于其表面成本。
目前，大多数公司处理这一问题的方式是悲观，并通过精确的维护程序在故障发生前更换易出错的组件。虽然定期维护比故障好，但我们经常在需要维护之前就结束了维护。因此，从成本角度来看，这不是最佳解决方案。
预测性维护避免最大限度地利用其资源。预测性维护将检测异常和故障模式，并提供早期警告。
根据我的经验，预测性维护模式的成功取决于三个主要因素:
收集数据
像大多数 ML 项目一样，我们需要足够的历史数据来帮助我们理解以前的失败。此外，系统的一般“静态”特征也可以提供有价值的信息，例如机械特性、平均使用和操作条件。然而，更多的数据并不总是更好。
不幸的是，对于没有数据文化的公司来说，机器的寿命通常是几年，这意味着数据必须收集很长一段时间，以观察系统的整个退化过程。
理想情况下，我们希望数据科学家和领域专家都参与数据收集过程，以确保收集的数据适合要构建的模型。
根据系统/机器的特性和可用数据，有可能回答这些关键问题:
例如，对于预测性维护，我们关注的是故障事件。因此，有必要从收集机器性能和维护记录的历史数据开始，以形成对未来故障的预测。使用历史数据是设备状况的重要指标。我们还需要关于维护和服务历史的信息。
由于生产机器的使用寿命通常是几年，历史数据应该追溯到足够远的时间，以正确反映机器的退化过程。
此外，关于机器/系统的其他静态信息也是有用的，例如关于机器特征、其机械特性、典型使用行为和环境操作条件的数据。
以上问题应该由领域专家和数据科学家共同回答。
一旦我们有了所有这些信息，就有可能决定哪种建模策略最适合可用的数据和期望的输出。预测性维护有多种建模策略，我们将描述其中两种(我研究最多的),涉及它们旨在回答的问题以及它们需要哪种数据:
- 预测剩余使用寿命的回归模型( RUL )
- 预测给定时间窗口内故障的分类模型
你的数据干净吗？
拥有足够的数据固然很好，但这只是预测性维护算法开发一系列步骤中的第一步。您必须存储数据，清理数据，将数据与其他数据集成，然后分析数据以获得有意义的见解。
如果你没有高质量的数据输入到你的机器学习模型中，那么产生的预测将是无用的。数据预处理是清理数据并将其转换为可以从中提取条件指标的形式所必需的。这通常是一个具有挑战性且耗时的过程。
预测剩余使用寿命的回归模型(RUL)
对于这个场景，我们需要静态和历史数据，并且每个事件都有标签。此外，每种故障类型的几个事件必须是数据集的一部分。理想情况下，当退化过程是线性的时，我们更喜欢建立这样的模型。
此外，我们通常只对一种类型的“故障路径”建模:如果可能出现多种类型的故障，并且每种故障之前的系统行为不同，那么应该为每种故障建立一个专门的模型。
在制造业中，回归可用于计算资产剩余使用寿命(RUL)的估计值。
对于回归，最常用的机器学习算法是线性回归，实现起来相当快速和简单，输出也容易解释。线性回归的一个例子是预测温度的系统，因为温度是一个连续值，其估计值易于训练。
当数据存在于一个范围内(如温度、重量)时，使用回归，这通常是处理从传感器收集的数据时的情况。
预测给定时间窗口内的故障
这种情况非常具有挑战性。然而，在实践中，人们通常不需要非常准确地预测很远的将来的寿命。通常，维护团队只需要知道机器是否会“很快”出现故障。因此，我们的挑战基本上是确定机器是否会在接下来的 X 天/周期内出现故障？
同样，我们需要静态和历史数据，并且每个事件/案例都被标记以训练和评估我们的模型。
在这种情况下，我们通常使用分类模型:
- 分类模型可以处理多种类型的故障，只要它们被框定为多类问题。
- 由于我们是在一个时间窗口内而不是在一个确切的时间内定义故障，与退化过程相关的要求是不同的。
一般来说，回归和分类模型所做的是模拟特征和系统退化路径之间的关系。
这两种方法有着相同的目标:映射输入数据(来自制造过程)和输出数据(已知可能的结果，如部件故障、过热等)之间的关系。).
由于机器或部件的故障有多种可能的原因，因此预测性维护利用多级分类。这些是被归类为潜在设备问题的可能结果，使用几个变量进行计算，包括机器健康状况、风险水平和故障的可能原因。
多类分类技术可用于两种情况:
- 预测两个未来结果:第一个结果是一个资产的故障时间范围。资产被分配到多个可能的期间之一。第二个结果是未来一段时间内由于多种根本原因之一而导致失败的可能性。这种预测使维护人员能够观察症状并计划维护时间表。
- 预测给定故障最可能的根本原因。这个结果推荐了一组正确的维护措施来修复故障。根本原因和建议维修的排序列表可以帮助技术人员在出现故障后优先考虑他们的维修行动。
添加传感器
我建议公司使用状态监控传感器。它非常有助于为您的预测模型收集额外的数据，并提供关于是否达到故障阈值的不断更新的信息。集成的 CMMS 非常有用，它有助于自动通知您的维护团队需要完成的工作。
CMMS: 旨在简化维护管理的计算机软件。CMMS 代表计算机化维护管理系统(或软件)，有时也被称为企业资产管理(EAM)软件。
一些现代工厂/机器已经布满了传感器。人工智能可以通过两种方式增强预测性维护数据:
通过向模型添加多种类型的数据:图像、音频或视频，基于现有的传感器数据，用于增强数据集，为全面的预测模型提供动力。
例如，音频数据尤其是预测性维护模型的强大数据源。传感器可以拾取声音和振动，并用于深度学习机器学习模型。
数据包括时间戳、与时间戳同时收集的一组传感器读数以及设备标识符。通过传感器，我们的目标通常是预测在时间“t”时，使用直到该时间的数据，设备是否会很快发生故障。
如果你想/可以使用深度学习，使用长短期记忆(LSTM)网络在预测性维护中特别有吸引力。LSTM 网络擅长从序列中学习。时间序列数据可用于回顾更长时期，以检测故障模式。
要开始预测性维护之旅，首先要定义用例。然后，确保您已经拥有或者能够生成与您的用例相匹配的数据集。要验证数据集是否具有构建模型的匹配模式，您应该使用简单的数据探索技术来确定您的数据是否包含降级或失效模式。一旦你获得了一个模式的证据，你就准备好建立机器学习模型了。
如何在 Keras 中实现 Seq2Seq LSTM 模型
如果你被尺寸问题困扰，这是给你的
Keras: Deep Learning for Python
为什么需要看这个？
当我第一次尝试为聊天机器人任务实现 seq2seq 时，我卡了很多次，特别是关于输入数据的维度和神经网络架构的输入层。
现在我明白了，除非你对矩阵、张量等线性代数概念，或者 Keras API 是如何工作的有很深的理解，否则你会不断地得到错误(而且那太惨了！).
因此在本文中，我将通过仔细检查每个过程中的输入和输出，来解释 seq2seq for Keras 的完整分步指南。
此外，我将提供一些可移植的原始函数，您可以在任何其他 NLP 项目中使用这些函数进行预处理。
我们开始吧！
菜单
- Seq2Seq 文本生成模型是什么？
- 任务定义和 Seq2Seq 建模
- Seq2Seq 中各层的尺寸
- Seq2Seq 的预处理(在聊天机器人的情况下)
- 最简单的代码预处理:您现在就可以使用！
1.Seq2Seq 文本生成模型是什么？
Fig A — Encoder-Decoder training architecture for NMT — image copyright@Ravindra Kompella
Seq2Seq 是一种使用 RNN 的编码器-解码器模型。它可以作为机器交互和机器翻译的模型。
通过学习大量的序列对，该模型从另一个生成一个。更友好地解释一下，Seq2Seq 的 I/O 如下:
- 输入:文本数据的句子，例如“你好吗？”
- 输出:文本数据的句子，例如“还不错”
这里是 Seq2Seq 的业务应用示例:
- 一个聊天机器人(你可以从我的 GitHub 中找到它)
- 机器翻译(可以从我的 GitHub 中找到)
- 问题回答
- 摘要文本摘要(可以从我的 GitHub 中找到)
- 文本生成(可以从我的 GitHub 中找到)
如果你想了解更多关于 Seq2Seq 的信息，这里我有一个来自 Youtube 上微软的机器学习的推荐。
现在我们可以理解这项技术的多功能性，所以让我们来看看整个过程！
— — — — —
2.任务定义和 Seq2Seq 建模
为了训练我们的 seq2seq 模型，我们将使用康奈尔电影对话语料库数据集，该数据集包含 10，292 对电影角色之间超过 220，579 次对话交流。它涉及 617 部电影中的 9035 个角色。
这是数据集中的一段对话:
Mike:
"Drink up, Charley. We're ahead of you."Charley:
"I'm not thirsty."
然后我们将这些对话对输入编码器和解码器。这意味着我们的神经网络模型有两个输入层，如下图所示。
这是我们这次的 Seq2Seq 神经网络架构:
copyright Akira Takezawa
让我们用 LSTM 来形象化我们的 Seq2Seq:
copyright Akira Takezawa
3.Seq2Seq 中各层的尺寸
https://bracketsmackdown.com/word-vector.html
“NLP 新手”的黑盒是这样的:
每一层如何编译数据并改变它们的数据维度？
为了说明这一点，我将详细解释它是如何工作的。这些层可以分为 5 个不同的部分:
- 输入层(编码器和解码器)
- 嵌入层(编码器和解码器)
- LSTM 层(编码器和解码器)
- 解码器输出层
我们开始吧！
1.编码器和解码器的输入层(2D->2D)
- 输入层维度:2D (sequence_length，无)
# 2D
encoder_input_layer = Input(shape=(sequence_length, ))
decoder_input_layer = Input(shape=(sequence_length, ))
注意:sequence_length 是 MAX_LEN 在预处理中通过填充统一的
- 输入数据:2D(样本数量，最大序列长度)
# Input_Data.shape = (150000, 15)array([[ 1, 32, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 123, 56, 3, 34, 43, 345, 0, 0, 0, 0, 0, 0, 0],
[ 3, 22, 1, 6543, 58, 6, 435, 0, 0, 0, 0, 0, 0],
[ 198, 27, 2, 94, 67, 98, 0, 0, 0, 0, 0, 0, 0],
[ 45, 78, 2, 23, 43, 6, 45, 0, 0, 0, 0, 0, 0]
], dtype=int32)
注意:样本数量可以是训练数据的长度(150000)
- 输出数据:2D
注意: Input() 仅用于 Keras 张量实例化
— — — — —
2.编码器和解码器的嵌入层(2D->3D)
- 嵌入层维度:2D (sequence_length，vocab_size)
embedding_layer = Embedding(input_dim = **vocab_size**,
output_dim = **embedding_dimension**,
input_length = **sequence_length**)
注:vocab _ size是数字的唯一字
- 输入数据:2D (sequence_length，vocab_size)
# Input_Data.shape = (15, 10000)array([[ 1, 1, 0, 0, 1, 0, ...... 0, 0, 1, 0, 0, 0, 0],
[ 0, 0, 1, 0, 0, 1, ...... 0, 0, 0, 0, 0, 0, 1],
[ 0, 1, 0, 0, 0, 0, ...... 0, 0, 1, 0, 0, 0, 0],
[ 0, 1, 0, 0, 0, 1, ...... 0, 0, 0, 1, 0, 1, 0],
[ 0, 0, 1, 0, 1, 0, ...... 0, 0, 1, 0, 1, 0, 0]
], dtype=int32)
注意:数据应该是一组单热向量
- 输出数据:3D(样本数，序列长度，嵌入尺寸)
# Output_Data.shape = (150000, 15, 50)array([[[ 1, 1, 0, 0, ...... 0, 1, 0, 0],
[ 0, 0, 1, 0, ...... 0, 0, 0, 1],
...,
...,
[ 0, 1, 0, 0, ...... 1, 0, 1, 0],
[ 0, 0, 1, 0, ...... 0, 1, 0, 0]],
[[ 1, 1, 0, 0, ...... 0, 1, 0, 0],
[ 0, 0, 1, 0, ...... 0, 0, 0, 1],
...,
...,
[ 0, 1, 0, 0, ...... 1, 0, 1, 0],
[ 0, 0, 1, 0, ...... 0, 1, 0, 0]], ....,] * 150000 , dtype=int32)
注:数据是嵌入 50 维的字
— — — — —
3.编码器和解码器的 LSTM 层(3D->3D)
LSTM 层的棘手论点是这两个:
1.返回状态:
是否随输出一起返回上一个状态
2。返回序列:
是否返回输出序列的最后一个输出或完整序列
你可以从 中找到很好的解释理解 Keras 作者Jason Brownlee中 LSTMs 的返回序列和返回状态的区别。
- 图层维度:3D (hidden_units，sequence_length，embedding_dims)
# HIDDEN_DIM = 20encoder_LSTM = LSTM(HIDDEN_DIM, return_state=True) encoder_outputs, state_h, state_c = encoder_LSTM(encoder_embedding)decoder_LSTM = LSTM(HIDDEN_DIM, return_state=True, return_sequences=True)
decoder_outputs, _, _ = decoder_LSTM(decoder_embedding, initial_state=[state_h, state_c])
- 输入数据:3D(样本数，序列长度，嵌入尺寸)
# Input_Data.shape = (150000, 15, 50)array([[[ 1, 1, 0, 0, ...... 0, 1, 0, 0],
[ 0, 0, 1, 0, ...... 0, 0, 0, 1],
...,
...,
[ 0, 1, 0, 0, ...... 1, 0, 1, 0],
[ 0, 0, 1, 0, ...... 0, 1, 0, 0]], [[ 1, 1, 0, 0, ...... 0, 1, 0, 0],
[ 0, 0, 1, 0, ...... 0, 0, 0, 1],
...,
...,
[ 0, 1, 0, 0, ...... 1, 0, 1, 0],
[ 0, 0, 1, 0, ...... 0, 1, 0, 0]], ....,] * 150000 , dtype=int32)
注:数据是嵌入 50 维的字
- 输出数据:3D(样本数，序列长度，隐藏单位)
# HIDDEN_DIM = 20
# Output_Data.shape = (150000, 15, 20)array([[[ 0.0032, 0.0041, 0.0021, .... 0.0020, 0.0231, 0.0010],
[ 0.0099, 0.0007, 0.0098, .... 0.0038, 0.0035, 0.0026],
...,
...,
[ 0.0099, 0.0007, 0.0098, .... 0.0038, 0.0035, 0.0026],
[ 0.0021, 0.0065, 0.0008, .... 0.0089, 0.0043, 0.0024]], [ 0.0032, 0.0041, 0.0021, .... 0.0020, 0.0231, 0.0010],
[ 0.0099, 0.0007, 0.0098, .... 0.0038, 0.0035, 0.0026],
...,
...,
[ 0.0099, 0.0007, 0.0098, .... 0.0038, 0.0035, 0.0026],
[ 0.0021, 0.0065, 0.0008, .... 0.0089, 0.0043, 0.0024]], ....,] * 150000 , dtype=int32)
注:数据被 LSTM 整形为 20 维隐藏层
附加信息:
如果return_state = False和return_sequences = False:
- 输出数据:2D(数量 _ 样本，隐藏 _ 单位)
# HIDDEN_DIM = 20
# Output_Data.shape = (150000, 20)array([[ 0.0032, 0.0041, 0.0021, .... 0.0020, 0.0231, 0.0010],
[ 0.0076, 0.0767, 0.0761, .... 0.0098, 0.0065, 0.0076],
...,
...,
[ 0.0099, 0.0007, 0.0098, .... 0.0038, 0.0035, 0.0026],
[ 0.0021, 0.0065, 0.0008, .... 0.0089, 0.0043, 0.0024]]
, dtype=float32)
— — — — —
4.解码器输出层(3D->2D)
- 输出层维度:2D (sequence_length，vocab_size)
outputs = TimeDistributed(Dense(VOCAB_SIZE, activation='softmax'))(decoder_outputs)
注意:时间分布密度层允许我们将一个层应用到输入的每个时间片
- 输入数据:3D(样本数，序列长度，隐藏单元数)
# HIDDEN_DIM = 20
# Input_Data.shape = (150000, 15, 20)array([[[ 0.0032, 0.0041, 0.0021, .... 0.0020, 0.0231, 0.0010],
[ 0.0099, 0.0007, 0.0098, .... 0.0038, 0.0035, 0.0026],
...,
...,
[ 0.0099, 0.0007, 0.0098, .... 0.0038, 0.0035, 0.0026],
[ 0.0021, 0.0065, 0.0008, .... 0.0089, 0.0043, 0.0024]],[ 0.0032, 0.0041, 0.0021, .... 0.0020, 0.0231, 0.0010],
[ 0.0099, 0.0007, 0.0098, .... 0.0038, 0.0035, 0.0026],
...,
...,
[ 0.0099, 0.0007, 0.0098, .... 0.0038, 0.0035, 0.0026],
[ 0.0021, 0.0065, 0.0008, .... 0.0089, 0.0043, 0.0024]],....,] * 150000 , dtype=int32)
注:数据被 LSTM 整形为 20 维隐藏层
- 输出数据:2D (sequence_length，vocab_size)
# Output_Data.shape = (15, 10000)array([[ 1, 1, 0, 0, 1, 0, ...... 0, 0, 1, 0, 0, 0, 0],
[ 0, 0, 1, 0, 0, 1, ...... 0, 0, 0, 0, 0, 0, 1],
[ 0, 1, 0, 0, 0, 0, ...... 0, 0, 1, 0, 0, 0, 0],
[ 0, 1, 0, 0, 0, 1, ...... 0, 0, 0, 1, 0, 1, 0],
[ 0, 0, 1, 0, 1, 0, ...... 0, 0, 1, 0, 1, 0, 0]
], dtype=int32)
在数据通过这个完全连接的层之后，我们使用反向词汇，我将在后面解释它来从一个热点向量转换成单词序列。
— — — — —
4.Seq2Seq 的整个预处理(在聊天机器人的情况下)
Creating A Language Translation Model Using Sequence To Sequence Learning Approach
在开始 Seq2Seq 的预处理之前，我想提一下:
在数据预处理过程中，我们需要一些变量来定义我们的 Seq2Seq 神经网络的形状
- MAX_LEN:统一输入句子的长度
- VOCAB_SIZE:决定句子的一个热点向量的维数
- EMBEDDING_DIM:决定 Word2Vec 的尺寸
— — — — —
seq 2 seq 的预处理
好了，请把这些信息记在心里，我们开始讲预处理。整个过程可以分为 8 个步骤:
- 文本清理
- 为解码器输入放置
标签和 标签 - 制作词汇表(VOCAB_SIZE)
- 将单词包标记为 id 包
- 填充(MAX_LEN)
- 单词嵌入(EMBEDDING_DIM)
- 重塑数据取决于神经网络的形状
- 为培训和验证、测试拆分数据
— — — — —
1。文本清理
- 功能
我总是使用我自己的函数来清理 Seq2Seq 的文本:
- 输入
# encoder input text data["Drink up, Charley. We're ahead of you.",
'Did you change your hair?',
'I believe I have found a faster way.']
- 输出
# encoder input text data['drink up charley we are ahead of you',
'did you change your hair',
'i believe i have found a faster way']
— — — — —
2.为解码器输入放置标签和标签
- 功能
- 输入
# decoder input text data[['with the teeth of your zipper',
'so they tell me',
'so which dakota you from'],,,,]
- 输出
# decoder input text data[['<BOS> with the teeth of your zipper <EOS>',
'<BOS> so they tell me <EOS>',
'<BOS> so which dakota you from <EOS>'],,,,]
— — — — —
3.制作词汇表(VOCAB_SIZE)
-
功能
-
输入
# Cleaned texts[['with the teeth of your zipper',
'so they tell me',
'so which dakota you from'],,,,]
- 输出
>>> word2idx{'genetically': 14816,
'ecentus': 64088,
'houston': 4172,
'cufflinks': 30399,
"annabelle's": 23767,
.....} # 14999 words>>> idx2word{1: 'bos',
2: 'eos',
3: 'you',
4: 'i',
5: 'the',
.....} # 14999 indexs
— — — — —
4.将单词包标记为 id 包
-
功能
-
输入
# Cleaned texts[['with the teeth of your zipper',
'so they tell me',
'so which dakota you from'],,,,]
- 输出
# decoder input text data[[10, 27, 8, 4, 27, 1107, 802],
[3, 5, 186, 168],
[662, 4, 22, 346, 6, 130, 3, 5, 2407],,,,,]
— — — — —
5.填充(MAX_LEN)
-
功能
-
输入
# decoder input text data[[10, 27, 8, 4, 27, 1107, 802],
[3, 5, 186, 168],
[662, 4, 22, 346, 6, 130, 3, 5, 2407],,,,,]
- 输出
# MAX_LEN = 10
# decoder input text data array([[10, 27, 8, 4, 27, 1107, 802, 0, 0, 0],
[3, 5, 186, 168, 0, 0, 0, 0, 0, 0],
[662, 4, 22, 346, 6, 130, 3, 5, 2407, 0],,,,,]
— — — — —
6.单词嵌入(EMBEDDING_DIM)
- 功能
我们使用手套的预训练和 Word2Vec 模型。我们可以通过 3 个步骤用手套创建嵌入层:
- 从 XX 调用手套文件
- 从我们的词汇表中创建嵌入矩阵
- 创建嵌入层
我们来看看吧！
-
从 XX 调用手套文件
-
从我们的词汇中创建嵌入矩阵
-
创建嵌入层
— — — — —
7.将数据重塑为神经网络形状
-
功能
-
输入
# MAX_LEN = 10
# decoder input text dataarray([[10, 27, 8, 4, 27, 1107, 802, 0, 0, 0],
[3, 5, 186, 168, 0, 0, 0, 0, 0, 0],
[662, 4, 22, 346, 6, 130, 3, 5, 2407, 0],,,,,]
- 输出
# output.shape (num_samples, MAX_LEN, VOCAB_SIZE)
# decoder_output_data.shape (15000, 10, 15000)array([[[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 1., ..., 0., 0., 0.],
...,
[1., 0., 0., ..., 0., 0., 0.],
[1., 0., 0., ..., 0., 0., 0.],
[1., 0., 0., ..., 0., 0., 0.]], ..., ], , dtype=float32)
— — — — —
8.为培训和验证、测试拆分数据
-
功能
-
输入
array([[[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 1., ..., 0., 0., 0.],
...,
[1., 0., 0., ..., 0., 0., 0.],
[1., 0., 0., ..., 0., 0., 0.],
[1., 0., 0., ..., 0., 0., 0.]],..., ], , dtype=float32)
- 输出
array([[[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 1., ..., 0., 0., 0.]],..., ], , dtype=float32)
现在，在将学习数据输入到我们的 LSTM 模型之前，我们已经完成了整个预处理过程。
在这之后，你只需要喂他们，等待完成学习。
感谢阅读，下一篇文章再见。
— — — — —
参考
大家好。距离我上一篇博客已经有很长时间了。这听起来像是借口，但我一直在挣扎…
chunml.github.io](https://chunml.github.io/ChunML.github.io/project/Sequence-To-Sequence/) [## 基于 Keras 的问答深度学习模型
上周，我参加了一个由我们搜索协会组织的关于问答的(公司内部)研讨会，其中…
sujitpal.blogspot.com](http://sujitpal.blogspot.com/2016/10/deep-learning-models-for-question.html) [## 使用序列对序列学习的机器翻译
在本文中，我们正在训练一个基于两个长短期记忆(LSTM)层的递归神经网络(RNN)模型…
nextjournal.com](https://nextjournal.com/gkoehler/machine-translation-seq2seq-cpu)
何时实施正确的机器学习技术？
Photo by Caleb Jones on Unsplash
深度学习 VS 强化学习 VS 贝叶斯网络
1 导言
最初，人工智能技术旨在“计算机化”表征人类认知、知识、推理等的过程。人工智能的主要挑战是:确定一种可以计算机化的过程，然后将其计算机化并验证其相关性或效率。ML 研究专注于一个特定的过程，也就是学习。主要的挑战是给计算机最少的知识和数据来训练它们。此外，ML 需要人与计算机之间的互动，选择数据并验证机器的结果，并赋予它们更大的决策自主权。自 20 世纪 90 年代以来，大型数据集(尤其是带标签的数据)之间的协同作用，以及使用图形处理器单元的计算机能力的增强，更强大的技术应用出现了。技术和推理逻辑能够实现几个目标，例如降低语音识别中的单词错误率，处理图像识别(Krizhevsky，Sutskever 和 Hinton，2012 年)，在围棋上击败人类冠军(Silver 等人，2016 年)，以及将图像翻译成自然语言(Karpathy 和飞飞，2017 年)。
在项目管理的特定领域，作者仍然建立了项目管理因素(过程实施、团队管理等)之间的统计相关性。)和以往项目的业绩(Ko & Cheng，2007；黄，赖，&林，2000)。更一般地，我们假设 AI 和 ML 技术是 PM 的有价值的解决方案；它们有助于系统地利用项目数据，以便更清楚地了解因果关系的相关性或强度。其中一个主要问题是选择一个好的人工智能和最大似然技术，因为这个非常活跃的领域包括各种各样的统计方法，可以实现自动决策、预测建模、数据分类和数据聚类。这解释了为什么这篇文章关注于选择适合项目管理特性的人工智能和 ML 技术
2 人工智能技术综述
在项目管理中，一些最常用的人工智能技术是:双变量相关和多元回归测试(Mir & Pinnington，2014 年)，数据挖掘(Ahiaga-Dagbui & Smith，2014 年)，人工神经网络(Al-Tabtabai 等人，1997 年；高和程，2007；王&吉布森，2010；王等，2012)，强化学习(毛，阿里扎德，梅纳切，&坎杜拉，2016；Tesauro，Jong，Das 和 Bennani，2006 年；叶&李，2018)，遗传算法与多准则决策(Baron，Rochet，& Esteve，2006)和贝叶斯网络(Qazi et al .，2016)甚至贝叶斯网络与进化算法的杂交方法(Pitiot，Coudert，Geneste，& Baron，2010)。
这就是为什么为了解决我们的研究问题，我们探索了 PM 研究人员可能熟悉的三种建模技术:
人工神经网络(深度学习)，因为我们现在已经在几个领域证明了其结果的准确性(王和吉布森，2010)，
一种称为强化学习(RL)的 ML，因为它与我们对成熟度的概念有相似之处，
贝叶斯网络(BNs)，因为这些动态工具结合了专家的知识和数据、因果推理和相关性。
2.1.监督学习技术:深度学习/人工神经网络(ANN)
最初，我们探索使用监督学习，更具体地说是人工神经网络(ANN)来预测基于项目管理成熟度的绩效。
如果你想了解更多关于监督学习算法的知识，我建议你看下一个帖子:
监督学习算法采用一组已知的输入数据(学习集)和已知的数据响应(学习集)
towardsdatascience.com](/supervised-learning-algorithms-explanaition-and-simple-code-4fbd1276f8aa)
神经网络用于提取人类无法感知的复杂模式，因为它们具有从复杂数据中获取趋势的非凡能力(Castillo & Melin，1999)。它们在商业应用中有广泛的用途(Wong 等人，2000 年)，特别是评估风险管理实践(Kampianakis & Oehmen，2017 年)。在本节中，我们将介绍它们，然后解释如何在我们的研究工作中使用这项技术。
受人类大脑的启发，神经生理学家沃伦·麦卡洛克和逻辑学家沃尔特·皮茨提出了第一个由相连的功能节点组成的神经网络。通过反复修改连接的权重来训练网络(麦卡洛克和皮茨，1943)。后来，同样受到神经科学的启发，罗森布拉特(Rosenblatt，1958)开发了感知器，这是一种简单的学习功能。它将每个神经元的输出映射为 1 或 0。它将标准向量 x 、权重向量 w 作为输入，并评估它们的标量积是否超过阈值 u、，即f(x)= { 1 ifwx>u；否则 0} 。在一个简单的层神经网络中，这个函数不是很有用，因为二进制分类是有限的。然而，它在多层网络中更有用，称为多层感知器(MLP) (Rumelhart，Hinton，& Williams，1986)。MLP 于 20 世纪 80 年代开发，包括反向传播，即算法，分配好的权重，使神经网络在学习中具有较低的误差。最常用的反向传播方法之一是随机梯度下降(SGD)，它通过使用偏导数的链规则来最小化错误率。SGD 传播所有导数或梯度，从顶部输出开始到底部，然后直接计算每个链接各自的权重。
自从 MLP 和 SGD 的实现，在解决神经网络方面没有相关的进展，直到 1997 年，另一种反向传播方法，称为长短期记忆 LSTM，被提出(Hochreiter & Schmidhuber，1997)。LSTM 缩短新币；它还引入了循环网络的概念来学习长程相关性。LSTM 的学习速度比 SGD 快，它解决了复杂的人工长时间滞后的任务。
神经网络应用于许多科学和工业部门。然后，我们需要界定对项目管理有用的神经网络的类型。此外，在我们的特殊情况下，神经网络必须具有:(1)作为输入，表征项目管理成熟度的标准，以及(2)作为输出，项目的运营绩效。根据惯例，创建因果模型可能需要使用几个层(见图 1)。然而，即使神经网络已经表现出很高的准确性，在 PM 中，我们也不能访问构建足够有效的网络所需的数据量。在这些标准下，我们没有足够的项目来训练网络。ANN 对数据的需求随着输入标准的数量呈指数增长(图 2)。尽管存在固有的局限性，人工神经网络仍被用于一些商业应用(Wong 等人，2000 年)，例如评估风险管理实践(Kampianakis & Oehmen，2017 年)。
人工神经网络非常有趣，甚至令人着迷。在表 1 中，我们总结了他们与项目经理观点相关的优势和劣势。
我们要介绍的第二种技术是强化学习(RL)。
2.2.强化学习
强化学习算法是从马尔可夫决策过程(MDP)发展而来的。它们是在随机情况下进行决策的数学模型，其中每个事件仅取决于前一个事件中达到的状态(马尔可夫特性)。1957 年，贝尔曼(Bellman，1957)提出了一个沿 MDP 优化所有报酬总和的递归公式。解这个方程意味着找到最优策略。然而，贝尔曼方程是不可能解析求解的，因为它涉及到一个函数的最大化，而这个函数是不能求导的。这个问题让 RL 没有任何相关的进展，直到 1995 年 Watkins 提出了 Q-learning 算法(Watkins，1995)。该算法有助于解决探索-开发困境的挑战:计算机代理花费最优时间探索解决方案并获得奖励，不至于陷入局部最优，而是最大化总体奖励。
例如，在图 3 中，黄色方块代理尝试了几种途径来最大化长期累积奖励并达到其目标:带+1 奖励的绿色位置。在 RL 下，该代理人没有直接的指令来指示做出哪个决定或者哪个决定是其决定的直接结果。尽管如此，每个决定都要花费 -0.04 分。代理完成所有步骤(从起点，到绿色方块)；然后，在决策过程的最后，它会获得累积的回报。然后，它会模拟几个路径，直到积累的回报最大化(萨顿，1988)。
非常令人惊讶的是，RL 是基于一种接近过程成熟度的学习概念。PMMMs 被设计成根据实施(或不实施)的最佳实践的数量和类型对组织进行分类和排名。类似地，在 RL 下，改进是基于某件事的成功重复，这类似于实施的最佳实践。RL 使用计算机代理，这些代理通过与模拟环境的交互来学习如何直接做出决策。RL 旨在最大化来自经验的回报信号；也就是说，通过创建最优策略(类似于项目管理建议)来最大化奖励效用函数(类似于项目绩效)。在 RL 下，计算机代理从不知道如何处理外部环境开始；随着它变得越来越成熟，它以更有效的方式完成它的任务，就像在成熟过程完美性量表中一样(表 2)。
此外，PM 数据库可以被定义为标准轴。图 4 显示了具有两个标准简化。这个想法是这样的:当代理人——旨在改进的系统——向每个方向移动时。它会从环境中得到回报。一个项目管理评估代理将探索状态(也就是说，它满足在每个轴上移动到下一个级别的标准)，并且它将获得奖励点(项目操作性能的增加)。RL 模型在产生较好性能的同时，会根据通过不同级别的步骤产生相应的策略。使用 RL 需要创建一个模拟，包括几个项目管理标准和代理满足这些标准时“奖励”点的定义。
尽管 RL 很有价值，但在 PM 中也不容易实现。许多参数必须在之前定义。不幸的是，在我们的研究调查中，我们没有足够的数据来创建健壮的 RL 场景。表 3 显示了 RL 的优势和劣势。
ann 和 RL 的结合是深度强化学习 (DRL)的基础。在这种情况下，处于状态的计算机代理使用深度神经网络来学习策略。有了这个策略，代理在环境中采取行动，并从它达到的特定状态中获得奖励。奖励为神经网络提供信息，并产生更好的政策。这是在一篇名为“用深度强化学习玩雅达利”的论文中开发和应用的，在论文中，他们学习一台机器直接从像素开始玩雅达利游戏，经过训练，这台机器产生了优秀的结果(Mnih，Silver，& Riedmiller，2013)。作者学习一台计算机直接从像素玩雅达利游戏，经过训练后，机器产生了优秀的结果。RL 还被用来，在 2016 年下围棋，这是一个非常复杂的游戏，打败了世界冠军(Silver et al .，2016)。在这部作品之后，RL 受到了投资者更多的关注。自那以后，投资增加了，应用程序也在增长(Huddleston & Brown，2018)。
2.3 贝叶斯网络
bn 是基于图形的工具，对专家的知识和推理进行建模；BN 结合了数据和知识、知识状态和知识更新、相关性和因果性。如果你不熟悉 BN，我建议你看下一个帖子:
假设世界上存在一种非常罕见的疾病。你患这种疾病的几率只有千分之一。你想要…
towardsdatascience.com](/will-you-become-a-zombie-if-a-99-accuracy-test-result-positive-3da371f5134)
BNs 明确管理不确定性的能力使其适用于各种现实世界问题的大量应用，包括风险评估(Fenton & Neil，2013 年)、破产预测(Sun & Shenoy，2007 年)、产品可接受性(Arbelaez，Rakotondranaivo，& Bonjour，2016 年)、医疗诊断(康斯坦蒂努，Fenton，Marsh，& Radlinski，2016 年)、建筑设计过程诊断(Matthews & Philip，2012 年)等。
然而，我们可以注意到 BNs 适用于以下问题:(1)原因必须与结果相关联，例如，作为输入变量的项目管理成熟度标准，以及作为输出变量的特定项目的运营绩效，(2)数据量不大，并且随时间变化(其不确定性水平很高)，(3)必须结合数据和专家知识。我们可以在表中总结 BNs 的优势和劣势
一旦 ANN、RL 和 BNs 被提出，我们就可以定义一个令人满意的 AI 和 ML 技术的以数据为中心的需求，以阐述项目管理过程成熟度和项目运营绩效之间的因果关系。
3 选择适当的技术
我们提出了三种人工智能和最大似然技术——ann、RL、BNs——可以用来解决我们的研究问题。在本节中，我们对它们进行定性比较，以选择最有价值的。我们将使用的标准是指数据，而不是知识。
3.1.数据质量评估框架
我们提出了三种技术，可以用来解决我们的研究问题。在本节中，我们将对它们进行定性比较，以选择最合适的一个。为此，我们选择了几个标准来评估如何根据上述技术处理数据。表 5 介绍了从《经合组织统计术语汇编》(经合组织统计术语汇编，2008 年)和(Nam，Wuillemin，Leray，Becker 和 Pourret，2008 年)中提取的概念。
3.2.与我们的调查相关的数据评估
表 6 通过上述标准列表显示了 ANN、RL 和 BNs 之间的比较。如果满足特性，每个 AI 和 LM 技术都有一个 + 符号，如果技术在特性中更好，则有一个 ++ 符号。同样— —如果没有达到该特征，请签名，如果该技术在该特征中有重要的弱点，请—签名。
访问标准:数据可访问性受限于我们的查询。最大的挑战之一是获得项目管理成熟度审计和项目运营绩效评估的结构化数据库。因此，需要大量数据输入(ANN，RL)的方法是不合适的。就可及性而言，BNs 似乎是最合适的。他们以处理混合数据(来自数据库和专家)的能力脱颖而出，处理数据的不确定性并易于阅读。
上下文标准:给定项目管理成熟度评估的上下文，数据的类型和数量是有限的。BNs 比其他技术更好地确保了结果的完整性。创建相关 BN 所需的数据量与研究问题的现实相一致。
表示标准: BNs 的图形表示是明确的、直观的，并且是项目管理专家可以理解的。这有助于模型的验证和使用。决策者对其工作可以理解的模型比像人工神经网络这样的黑箱模型更有信心。
内在标准:人工神经网络已经在准确性、客观性、独特性和一致性方面显示了它们的能力。只有当他们收到足够数量的数据时，才能达到这种熟练程度。BNs 在“客观性”上失败了:他们可能会有偏见。然而，BNs 可以从输入到输出传播数据演化，并在另一个方向反向传播信息，这一特性使它们对这一研究问题非常有用。
项目管理数据通常是稀缺和不完整的，从以前的数据做出好的决策是这项研究的总体挑战。虽然神经网络等经典机器学习基于可用数据给出答案，但贝叶斯网络包括相关的非样本或先验人类专业知识。通常，采访专家询问几个参数的影响是回忆所有信息的最好方式，这使得贝叶斯网络比其他技术更丰富。将这种专业知识与样本数据结合起来，可以产生一种强大的技术，能够生成一个可实现的、足够高性能的模型。
模型的图形表示结构总是比黑盒模型更好，如神经网络。更容易解释和交流这在与人合作时提供了优势，这些人不是模型技术方面的专家，而是业务领域的专家，即医疗保健，或者在这种情况下是项目管理。贝叶斯网络的另一个积极优势是它能够通过专家知识和原始数据来构建，即使其中一组知识是不完整的。可以从专家开始，然后用数据进行提炼，或者先用数据创建一个模型，然后用专家进行改进。
感谢阅读！！
如果你想继续阅读这样的故事，你可以在这里订阅！
如何在 RStudio 中导入 Excel 文件
在安装了 R 和 RStudio 之后，学习几种导入 Excel、CSV 或 SPSS(.sav)文件导入到 RStudio 中
Photo by Avi Waxman
介绍
正如我们在这篇关于如何安装 R 和 RStudio 的文章中所看到的，R 对于许多种计算任务和统计分析都很有用。然而，如果没有将数据集导入 R 的可能性，它就不会如此强大和有用。由于您最有可能将 R 与您自己的数据一起使用，因此能够将其导入 R 对于任何用户来说都是至关重要的。
在本文中，我介绍了两种导入 Excel 文件的不同方法；(I)通过文本编辑器,( ii)以更“用户友好”的方式。我还讨论了这两种方法的主要优缺点。请注意:
- 如何导入数据集往往取决于文件的格式(Excel、CSV、text、SPSS、Stata 等。).我在这里只关注 Excel 文件，因为它是数据集最常见的文件类型
- 还有其他几种导入 Excel 文件的方法(甚至可能是一些我不知道的方法)，但是我给出了两种最简单而又健壮的方法来导入这样的文件
- 无论是什么类型的文件以及如何导入，关于数据集的结构都有一个黄金标准:列对应于变量，行对应于观察值(广义而言)，每个值都必须有自己的单元格:
Structure of a dataset. Source: R for Data Science by Hadley Wickham & Garrett Grolemund
将 Excel 文件转换为 CSV 文件
在处理导入之前，首先要做的是将 Excel 文件的格式转换为 CSV 格式。 1 CSV 格式是处理数据集和编程语言的标准格式，因为与 Excel 相比，它是一种更强大的格式。
如果您的文件已经是 CSV 格式(扩展名为。csv)，可以跳过这一节。如果文件不是 CSV 格式(例如扩展名是。xlsx)您可以通过以下步骤轻松地将其转换为 CSV:
- 打开您的 Excel 文件
- 点击文件>另存为
- 选择格式。战斗支援车
- 点击保存
检查您的文件是否以扩展名. csv 结束。如果是这样，您的文件现在就可以导入了。但是首先，让我介绍一个将数据集导入工作目录 RStudio 时的重要概念。
r 工作目录
尽管编程语言可能非常强大，但它经常需要我们的帮助，导入数据集也不例外。事实上，在导入数据之前，您必须告诉 RStudio 您的文件位于何处(因此让 RStudio 知道在哪个文件夹中查找您的数据集)。不过在这之前，我先介绍一下工作目录。工作目录是 RStudio 当前工作的位置(在您的计算机中)(事实上，RStudio 并不在您的整个计算机上工作；它在你电脑的一个文件夹里工作)。关于这个工作目录，我们需要两个函数:
getwd()(wd代表工作目录)setwd()
获取工作目录
在大多数情况下，当您打开 RStudio 时，工作目录(即它当前工作的位置)与数据集所在的位置不同。要知道 RStudio 当前使用的工作目录是什么，运行getwd()。在 MacOS 上，这个函数很可能会渲染一个位置，比如"/Users/yourname/"，而在 Windows 上，它很可能会渲染"c:/Documents/"。如果您的工作目录不同，不要担心，最重要的是正确设置工作目录(因此您的文件所在的位置)而不是它现在的位置。
设置工作目录
如前所述，数据集很可能位于与工作目录不同的位置。如果您不采取任何措施，RStudio 将永远无法导入您的文件，因为它没有在正确的文件夹中查找(您将在控制台中遇到以下错误:无法打开文件“data.csv”:没有这样的文件或目录)。现在，为了指定文件的正确位置(也就是告诉 RStudio 应该在哪个文件夹中查找数据集)，您有三种选择:
- 用户友好的方法
- 通过控制台
- 通过文本编辑器(见下文，为什么这是我的首选)
用户友好的方法
要设置正确的文件夹，以便将工作目录设置为文件所在的文件夹，请按照下列步骤操作:
- 在 RStudio 的右下方窗格中，单击“文件”选项卡
- 点击房屋图标旁边的“主页”
- 转到数据集所在的文件夹
- 点击“更多”
- 点击“设为工作目录”
Set working directory in RStudio (user-friendly method)
或者，您也可以通过点击会话>设置工作目录>选择目录…来设置工作目录
Set working directory in RStudio (user-friendly method)
正如您在控制台中所看到的，这两种方法中的任何一种都将实际执行代码setwd(),其路径指向您指定的文件夹。所以通过点击按钮，你实际上要求 RStudio 为你写一行代码。这种方法的优点是您不需要记住代码，并且不会在文件夹的路径名中出错。缺点是，如果您离开 RStudio 并在稍后再次打开它，您将不得不再次指定工作目录，因为 RStudio 不会通过按钮保存您的操作。
通过控制台
您可以通过在控制台中直接运行setwd(path/to/folder)来指定工作目录，其中path/to/folder是包含数据集的文件夹的路径。但是，重新打开 RStudio 时，您需要再次运行该命令。
通过文本编辑器
这种方法实际上是上述两种方法的结合:
- 按照与用户友好方法(通过按钮)完全相同的步骤设置工作目录
- 复制在控制台中执行的代码，并将其粘贴到文本编辑器(即您的脚本)中
我推荐这种方法有几个原因。首先，你不需要记住setwd()功能。第二，你不会在你的文件夹路径中输入错误(如果文件夹中有文件夹，路径有时会很长)。第三，当保存你的脚本时(我假设你这样做了，否则你会丢失你所有的工作)，你也保存了你刚才通过按钮所做的动作。因此，当您将来重新打开您的脚本时，无论当前目录是什么，通过执行您的脚本(现在包括用于设置工作目录的代码行)，您将同时指定您为此项目选择的工作目录。
导入数据集
现在，您已经将 Excel 文件转换为 CSV 文件，并且通过设置工作目录指定了包含数据的文件夹，现在就可以实际导入数据集了。提醒有两种方法可以导入文件:
- 以用户友好的方式
- 通过文本编辑器(也见下面为什么它是我的首选)
无论您选择哪种方法，最好先在“文本编辑”( Mac)或“记事本”( Windows)中打开文件，以便查看原始数据。如果您在 Excel 中打开文件，您会看到数据已经格式化，因此会错过导入所需的一些重要信息。下面是一个原始数据的例子:
Example of raw data
为了正确导入数据集，我们需要注意以下几点:
- 变量名是否存在？
- 值是怎么分开的？逗号，分号，空格，制表符？
- 十进制是点还是逗号？
- 如何指定缺失值？空单元格，NA，null，O，other？
用户友好的方式
如下所示，只需点击文件>导入数据集…
Import dataset in RStudio
将会打开一个如下所示的窗口:
Import window in RStudio
从这个窗口，您可以预览您的数据，更重要的是，检查您的数据是否正确导入。如果您的数据已经正确导入，您可以点击“导入”。如果不是这样，您可以根据查看原始数据时收集的信息，更改窗口底部(数据预览下方)的导入选项。下面是您最可能使用的导入选项:
- 名称:设置数据集的名称(默认为文件的名称)。避免使用特殊字符和长名称(因为您将不得不多次键入数据集的名称)。我个人用一个通用的名字给我的数据集重新命名，比如“dat”，其他人用“df”(data frame)、“data”，甚至“my_data”。例如，如果您使用网球比赛的数据，您可以使用更明确的名称，如“tennis_data”。但是，为数据集使用特定名称的主要缺点是，例如，如果您想要在分析其他数据集上的网球数据时重复使用您创建的代码，您将需要通过用新数据集的名称替换所有出现的“tennis_data”来编辑您的代码
- 跳过:指定要跳过的顶部行数(默认值为 0)。大多数时候，0 就可以了。但是，如果文件顶部包含一些空白行(或您想要忽略的信息)，请设置要跳过的行数
- 第一行作为名称:指定变量名称是否存在(默认情况下是变量名称存在)
- 分隔符:分隔值的字符。从上面的原始数据中，您可以看到分隔符是逗号(“，”)。如果您的值由“；”分隔，请将其更改为分号
- NA:如何指定缺失值(默认为空单元格)。从上面的原始数据中，您可以看到缺少的值只是空的单元格，因此将 NA 保留为默认值或将其更改为“empty”。如果原始数据中的缺失值编码为“NA”或“0”，请更改此选项(提示:不要将自己的缺失值编码为“0”，否则您将无法区分真正的零值和缺失值)
更改与您的数据对应的导入选项后，单击“导入”。现在，您应该可以在一个新窗口中看到您的数据集，并从那里开始分析您的数据。
这种用户友好的方法的优点是您不需要记住代码(完整的代码见下一节)。但是，主要缺点是您的导入选项不会被保存以备将来使用，因此您需要在每次打开 RStudio 时手动导入数据集。
通过文本编辑器
与设置工作目录类似，我也建议使用文本编辑器而不是用户友好的方法，原因很简单，使用文本编辑器时可以保存导入选项(而使用用户友好的方法时不行)。将导入选项保存在脚本中(多亏了一行代码)允许您以完全相同的方式快速导入数据集，而不必在每次导入数据集时重复所有必要的步骤。导入 CSV 文件的命令是read.csv()(或read.csv2()，它是等效的，但具有其他默认导入选项)。下面是一个与用户友好方法中的文件相同的示例:
dat <- read.csv(
file = "data.csv",
header = TRUE,
sep = ",",
dec = ".",
stringsAsFactors = TRUE
)
dat <-:r studio 中数据集的名称。这意味着在导入之后，我将需要通过调用dat来引用数据集file =:工作目录中文件的名称。不要忘记在名称、扩展名周围加上" "。csv 结尾，并且 RStudio 区分大小写("Data.csv"将给出错误)，在“”内部区分空格("data .csv"也将抛出错误)。在我们的例子中，文件被命名为“data.csv ”,所以file = "data.csv"header =:变量名存在吗？默认为TRUE，如果您的数据集中不是这种情况，请将其更改为FALSE(TRUE和FALSE始终是大写字母，true将不起作用！)sep =:分离器。相当于用户友好方法中的分隔符。不要忘记" "。在我们的数据集中，值的分隔符是逗号，所以sep = ","dec =:十进制。不要忘记" "。在我们的数据集中，数值的小数是一个点，所以dec = "."stringsAsFactors =:字符向量要不要转换成因子？默认选项曾经是TRUE，但是从 R 版本 4.0.0 开始默认为FALSE。如果你所有的角色向量实际上都是定性变量(所以因子在 R 中)，设置为TRUE- 我没有写缺失值在我的数据集中被编码为空单元，因为这是默认的
- 最后但同样重要的是，不要忘记参数是用逗号分隔的
存在其他参数，运行?read.csv查看所有参数。
导入后，您可以通过运行View(dat)来检查您的数据是否被正确导入，其中dat是您为数据选择的名称。一个类似于用户友好方法的窗口将显示您的数据。或者，您也可以运行head(dat)来查看前 6 行，并检查它是否对应于您的 Excel 文件。如果有些地方不正确，请编辑导入选项并再次检查。如果数据集已正确导入，现在就可以开始分析数据了。如果您想了解如何操作，请参阅 R 上的其他文章。
通过文本编辑器中的代码直接导入数据集的优点是，您的导入选项将被保存以供将来使用，从而避免您在每次打开脚本时手动导入它。然而，你需要记住函数read.csv()(不是参数，因为你可以在帮助文档中找到它们)。
导入 SPSS(。sav)文件
这里只详细介绍 Excel 文件。但是，SPSS 文件(。sav)也可以通过使用以下命令在 R 中读取:
library(foreign)
dat <- read.spss(
file = "filename.sav",
use.value.labels = TRUE,
to.data.frame = TRUE
)
read.spss()函数输出一个检索所有特性的数据表。sav 文件，包括不同级别分类变量的名称和变量的特征。如果您需要关于该命令的更多信息，请参阅帮助文档(library(foreign)然后是?read.spss)。
感谢阅读。我希望本文能帮助您在 RStudio 中导入 Excel 文件。如果数据集被正确导入，学习如何操作它。
和往常一样，如果您有与本文主题相关的问题或建议，请将其添加为评论，以便其他读者可以从讨论中受益。
- 我知道可以直接将一个 Excel 导入到 R 中，而不用将其转换成 CSV 文件，例如用
{readxl}包中的read_excel()函数。然而，CSV 格式是标准格式，更重要的是，导入 CSV 不需要安装和加载软件包(这对初学者来说有时会很困惑)。 ↩︎
相关文章:
- 安装和加载 R 包的有效方法
- 我的数据符合正态分布吗？关于最广泛使用的分布以及如何检验 R 中的正态性的注释
- R 中的 Fisher 精确检验:小样本的独立性检验
- R 中独立性的卡方检验
- 如何在简历中创建时间线
原载于 2019 年 12 月 18 日 https://statsandr.com**T21。
如何用正则化方法改进神经网络
了解如何应用 L2 正则化和辍学的神经网络
Photo by Jessica Ruscello on Unsplash
您刚刚构建了您的神经网络，并注意到它在训练集上表现得非常好，但在测试集上却没有那么好。
这是过度拟合的标志。你的神经网络有很高的方差，它不能很好地概括未经训练的数据。
解决过度拟合有两种常见方法:
- 获取更多数据
- 使用正则化
获取更多的数据有时是不可能的，有时又非常昂贵。因此，正则化是减少过拟合从而提高模型性能的常用方法。
在这篇文章中， L2 正则化和退出将被介绍为神经网络的正则化方法。然后，我们将对每种方法进行编码，看看它是如何影响网络性能的！
我们走吧！
对于机器学习、深度学习和人工智能的实践视频教程，请查看我的 YouTube 频道。
L2 正则化
回想一下，在深度学习中，我们希望最小化以下成本函数:
Cost function
其中 L 可以是任意损失函数(如交叉熵损失函数)。现在，对于 L2 正则化我们增加了一个惩罚大权重的组件。
因此，等式变为:
L2 regularization
其中λ是正则化参数。注意增加了 Frobenius 范数，用下标 F 表示。这实际上相当于矩阵的平方范数。
现在，λ是一个可以调整的参数。如果λ的值较大，则较大的权重值将受到更多的惩罚。类似地，对于较小的λ值，正则化效果较小。
这是有意义的，因为成本函数必须最小化。通过添加权重矩阵的平方范数并将其乘以正则化参数，大的权重将被降低，以便最小化成本函数。
为什么正规化有效？
如前所述，添加正则化分量将使权重矩阵的值下降。这将有效地去相关神经网络。
回想一下，我们为激活函数提供了以下加权和:
Weighted sum
通过减少权重矩阵中的值， z 也将减少，这反过来减少了激活函数的效果。因此，一个不太复杂的函数将适合数据，有效地减少过度拟合。
辍学正规化
退出包括检查神经网络中的所有层，并设置保留或不保留某个节点的概率。
当然，输入层和输出层保持不变。
保持每个节点的概率设置为随机。您只需决定阈值:一个决定节点是否被保留的值。
例如，如果您将阈值设置为 0.7，则有 30%的概率会从网络中删除一个节点。
因此，这将产生一个更小、更简单的神经网络，如下所示。
Left: neural network before dropout. Right: neural network after dropout.
为什么退学有效？
从一个神经网络中随机移除节点来调整它可能看起来很疯狂。然而，这是一种广泛使用的方法，并且被证明可以极大地提高神经网络的性能。那么，为什么它的效果这么好呢？
丢失意味着神经网络不能依赖任何输入节点，因为每个节点都有被删除的随机概率。因此，神经网络不愿意给予某些特征高的权重，因为它们可能会消失。
因此，权重分布在所有要素上，使它们变得更小。这有效地缩小了模型并使其正规化。
正规化的实施
现在，让我们对一些样本数据实施丢失和 L2 正则化，以查看它如何影响神经网络的性能。
参考完整笔记本这里。
创建样本数据集
我们首先创建一个样本数据集。在导入必要的库之后，我们运行下面这段代码:
我们应该得到:
太好了！这是一个简单的随机数据集，有两个类，我们现在将尝试编写一个神经网络，它将对每个数据进行分类，并生成一个决策边界。
非正则化模型
现在，我们定义一个模型模板来适应正则化:
花时间阅读代码并理解它的作用。请注意对 L2 正则化有用的 lambd 变量。此外， keep_prob 变量将用于 dropout。
现在，让我们运行一个没有正则化的神经网络，作为基准性能。
我们得到了:
Baseline performance of a non-regularized model
还不错！让我们画出决策边界:
您应该会看到:
Decision boundary without regularization
在上面的图中，您会注意到模型过度拟合了数据的某些部分。我们将以此为基准，看看正则化如何提高模型的性能。
L2 正则化
在使用 L2 正则化之前，我们需要定义一个函数来计算适应正则化的成本:
最后，我们用正则化定义反向传播:
太好了！现在，我们可以使用我们的模型模板与 L2 正则化！将λ的值设置为 0.7，我们得到:
Decision boundary with L2 regularization
厉害！我们提高了测试精度，您会注意到模型不再过度拟合数据了！
现在，让我们看看辍学者是否能做得更好。
拒绝传统社会的人
首先，我们需要重新定义正向传播，因为我们需要随机消除某些节点的影响:
当然，我们现在必须定义辍学的反向传播:
太好了！让我们看看阈值为 0.8 时，模型在辍学情况下的表现如何:
Decision boundary with dropout
太神奇了！我们实现了更高的精度和下降率！
干得好！您了解了正则化如何改进神经网络，并且实现了 L2 正则化和剔除来改进分类模型！
在以后的文章中，我将展示如何通过选择正确的优化算法来进一步改进神经网络。
敬请关注，继续学习！
使用 Scikit Optimize 调整 XGBoost 超参数
XGBoost 不再是少数人能够理解和使用的外来模型。它已经成为许多场景中的比较基准。自从首次提出该算法的论文发表以来的三年半时间里，人们对 XGBoost 的兴趣也急剧增加。谷歌趋势表明，人们对 XGBoost 的兴趣目前正处于历史最高水平。
Relative popularity of XGBoost in the since April 2016
挑战是什么？
现在，虽然 XGBoost 在过去的几年里越来越受欢迎，但是一些挑战使得它有点难以使用。最坚定的一个是使用什么超参数值——估计器的数量应该是多少，应该允许的最大深度是多少，等等。XGBoost 之所以比线性/逻辑回归模型或决策树更难管理，是因为它比许多其他模型有更多的超参数。简单地手动调整它们需要大量的时间和耐心。你仍然不能确定你是否在朝着正确的方向前进。
有解决办法吗？
你可能会想，如果我们能够以某种方式自动化这种无聊又累人的调整超参数的仪式，我们的生活将会容易得多。如果你对此感到疑惑，那么请放心，因为，是的，我们有办法提高 XGBoost 模型的性能，而不需要做所有的手工劳动，只需让计算机为我们解决问题。
选择超参数的正确值的过程称为超参数调整，有预建的库可以为我们完成这项工作。所以我们需要做的就是写一些代码，给出一些输入值，让计算机算出最佳值。
我们是如何做到的？
在我们进入代码和弄脏我们的手之前，让我们在这里停留一分钟并且问我们自己——如果我们是一台计算机并且被给予同样的问题，我们将如何做它？
让我们好好想想。我假设在这种情况下我们只有两个超参数值，因为这样更容易可视化。我要做的第一件事是用两个超参数的任意随机值建立一个模型，看看我的模型表现如何。
我要做的下一件事是增加一个参数，保持一个参数不变，看看我的模型性能如何响应其中一个参数的增加。如果我的模型性能提高，这意味着我正在向正确的方向移动我的超参数。如果没有，我现在知道我需要降低这个超参数的值。在下一次迭代中，我将更改我的另一个超参数的值，并查看我的模型如何对该更改做出反应。我将这样做几次，一旦我看到我的模型对这些变化做出足够多的反应，我将开始同时改变两者。
因此，我们现在所做的是利用之前模型的输出，并相应地改变超参数的值。在下面的部分中，我们将使用一个专门开发的包来帮助我们做到这一点。
想法
在本教程中，我们将使用 scikit-optimize 包来帮助我们为模型选择合适的值。现在，为了能够使用这些算法，我们需要为它们定义一个搜索区域，比如搜索空间。想象一下，你需要寻找一个地区的最高点，一个朋友愿意为你做这项工作。为了让你的朋友能够有效地做到这一点，你必须告诉他你想让他搜索的区域。你必须定义一个你希望他花时间搜索的区域/空间。
skopt 和其他此类算法也是如此。在这种情况下，算法是您的朋友，您需要它来搜索最佳的超参数值集。为了使算法成功，你需要定义一个搜索区域。
这些是我们将要遵循的步骤
- 使用 sklearn 的
make_classification功能创建虚拟数据集。我们将使用执行二元分类，因此我们的标签将包含 0 和 1 - 定义一个搜索空间/区域，您要在该空间/区域上建模以搜索最佳超参数值
- 定义一个用不同超参数值拟合模型的函数，并测量模型性能
- 定义您想要训练模型的次数
- 使用 skopt 的
gp_minimize算法搜索我们的空间并给出结果
仅此而已。这就是你需要做的。现在让我们看一下代码。
代码
您将需要 skopt 包，您可以通过在命令行输入pip install scikit-optimize来安装它
注意:代码框下面提供了所有代码片段的链接。如果有任何代码看起来不完整，点击 GitHub 链接找到完整的代码
- 进口
https://gist . github . com/vecto saurus/6a E1 b 455 c 7527 BF 25954 e 834 b 8b 49 a 89
- 创建数据集
https://gist . github . com/vecto saurus/a 53683 c 4d 6 FDE 396 ce 43 b 92 c 045 a5a 00
- 定义搜索空间。这里，我们通过提供每个超参数可以取的最小值和最大值来定义搜索空间。
https://gist . github . com/vecto saurus/DC 922 b 0 b 8d 9 db 080 BD 75b 736 c 2e 09 b 0 b
- 函数来拟合模型并返回模型的性能
https://gist . github . com/vecto saurus/73d 257 CB 0 be 61d 88 ab 788 bb 70 f 22 b 857
这里，在 return 语句中，我返回1 - test_score而不是test_score。这是因为 skopt 的gp_minimize致力于寻找最小值。我们的目标是找到我们能得到的最大值f1_score。所以通过让gp_minimize最小化1 - test_score，我们就最大化了test_score
- 运行算法
https://gist . github . com/vecto saurus/f 686 bfc 43 fdec 8 f 378d 0 eeae 074 E5 Fe 1
结果
https://gist.github.com/vectosaurus/2f6ff57ac4cb4e728d32c65a155ceb78
XGBoost 模型在第一次迭代中以test_score开始，现在是0.762，但是最终 F1 分数是0.837，增加了超过 7%。
结论
虽然自动超调在许多情况下有助于提高模型性能，但仍有必要密切关注数据。在许多情况下，探索数据和工程信息变量会更加有效。
此外，重要的是要注意，我们为模型选择的搜索空间是有意义的。简单地声明一个非常大的空间会影响这些算法所能执行的搜索的质量。
超参数调整非常有效，但我们需要确保我们为它提供了足够公平的搜索空间和足够合理的迭代次数。自动化的超参数调整减少了人力，但并没有降低程序的复杂性。
如何在 Tensorflow 2.0 中改进训练您的深度神经网络
Taken from http://www.merzpraxis.de/index.php/2016/06/13/der-suchende/
当涉及到建立和训练深度神经网络时，你需要设置大量的超参数。正确设置这些参数对你的网的成功有巨大的影响，也对你花在加热空气上的时间，也就是训练你的模型有巨大的影响。其中一个你必须选择的参数是所谓的学习率(也称为更新率或步长)。在很长一段时间里，选择这种权利更像是试错法或黑色艺术。然而，有一种聪明而简单的技术可以找到一个合适的学习率，我猜这种技术通过在 fastai 中的使用变得非常流行。在本文中，我将向您简要介绍这种方法，并向您展示 Tensorflow 2 中的一个实现，它也可以通过我的回购获得。所以让我们开始吧。
问题是
学习率 l 是一个单一的浮点数，它决定了你向负梯度方向移动多远，以更新和优化你的网络。正如在介绍中已经说过的，正确地选择它极大地影响了你花在训练你的模型上的时间，直到你得到好的结果并停止咒骂。为什么会这样呢？如果你选择的太小，你的模型将需要很长时间才能达到最佳状态，因为你只需要一小步一小步的更新。如果你选择的太大，你的模型将会反弹，跳过最优值，最终无法达到最优值。
解决方案
莱斯利·n·史密斯提出了一个非常聪明和简单的方法，在短时间内系统地找到一个让你非常快乐的学习率。前提是你有一个模型，并且你有一个被分成 n 批的训练集。
- 你将你的学习初始化为一个小值 l = l_min ，例如 l_min =0.00001
- 你用一批训练集来更新你的模型
- 计算损失并记录损失和使用的学习率
- 你成倍地提高了当前的学习速度
- 如果学习率已经达到预定义的最大值 l_max 或者如果损失增加太多，则返回步骤 2 或者停止搜索
- 最佳学习速率是导致两次连续试验之间损失最大程度减少的速率。选择最佳学习率的另一种方法是找到导致最小损失的学习率，并将其降低一到两个数量级。
为了让这一切更加直观，我给你看了在对数标度上绘制的学习率的平滑损失。红线标记计算出的最佳学习率。
实施
由于我目前正在学习 Tensorflow 2 (TF2)，我认为通过使用新的 TF2 概念实现学习率查找器来练习它是一个好主意。除此之外，我(希望你也是)现在有了所有我(或你)想要追求的即将到来的 TF2 项目的 LR Finder。在这里发布的代码中，我用步骤 1–6标记了相应的行，以引用上面的清单。这里显示的代码经过了一点简化和重构，以增加在介质上的可读性。你可以在我的 Github repo 上找到完整的代码以及一个小例子和绘图功能。
**from** dataclasses **import** dataclass, field
**from** typing **import** List**import** numpy as np
**import** tensorflow **as** tf
**from** tqdm **import** tqdm**def** lr_finder(
mdl: tf.keras.Model,
opt: tf.keras.optimizers.Optimizer,
lossf: tf.keras.losses.Loss,
dataset,
learn_rates: LrGenerator,
losses: SmoothedLoss,
) -> Lr:
# Step 1 & 4 init and decrease, Step 2 take batch
**for** lr, (source, target) **in** zip(learn_rates(), dataset):
tf.keras.backend.set_value(optimizer.lr, lr)
# Step 2 model update, Step 3 Calculate loss
loss = step(mdl, opt, lossf, source, target).numpy()
# Step 3 record losses
losses.update(loss)
# Step 5 check if done
**if** losses.no_progress:
**break****return** Lr(learn_rates, losses)**@tf.function**
**def** step(mld, opt, lossf, src: Tensor, trg: Tensor) -> Tensor:
**with** tf.GradientTape() **as** tape:
# Step 3 Compute loss
loss = lossf(trg, mld(src))
grads = tape.gradient(loss, mld.trainable_weights)
# Step 2 Update the model
opt.apply_gradients(zip(grads, mld.trainable_weights))
**return** loss**@dataclass**
**class** SmoothedLoss:
sm: float = 1
_losses:List[float]=field(init=False, default_factory=list)
_sm: List[float] = field(init=False, default_factory=list)
_avg: float = field(init=False, default=0)
_best_loss: float = field(init=False, default=None)**def** update(self, loss):
# Step 3 record losses
self._avg = self.sm * self._avg_loss + (1 - self.sm) * loss
smooth_loss = self._avg / (
1 - self.sm ** (len(self._sm) + 1)
)
self._best_loss = (
loss
**if** len(self._losses) == 0 or loss < self._best_loss
**else** self._best_loss
)self._losses.append(loss)
self._sm.append(smooth_loss)**@property**
**def** no_progress(self):
**return** self._sm[-1] > 4 * self._best_loss**@dataclass**
**class** LrGenerator:
min_lr: float
max_lr: float
n_steps: int
_lrs: List[float] = field(init=False)**def** __call__(self):
self._lrs = []
frac = self.max_lr / self.min_lr
**for** step **in** tqdm(range(self.n_steps)):
# Step 1 and 4 update lr and init
lr = self.min_lr*frac**(step/(self.n_steps - 1))
# Step 3 record learning rates
self._lrs.append(lr)
**yield** lr**@dataclass
class** Lr:
lr: LrGenerator
loss: SmoothedLoss
_opt_idx: int = field(init=False, default=None)**@property
def** opt_idx(self):
# Step 6 get best learning rate
cut = 3
**if** self._opt_idx **is** None:
sls = np.array(self.loss._smoothed_losses)
self._opt_idx = np.argmin(sls[1 + cut :] - sls[cut:-1])
**return** self._opt_idx + 1 + cut**@property
def** lr_opt(self):
# Step 6 get best learning rate
**return** self.lr._lrs[self.opt_idx]
结束了
感谢您关注我的小文章和我的第一个 TensorFlow 2 实现。如有任何问题、意见或建议，请随时联系我。
如何改进您的数据科学战略
这不仅仅是雇佣一名数据科学家和支付 Tableau 许可证的费用
Photo by Tabea Damm on Unsplash
创建有效的数据策略并不像雇佣一些数据科学家和数据工程师以及购买 tableau 许可那么简单。也不仅仅是用数据做决策。
创建有效的数据战略就是要创建一个生态系统，在这个生态系统中，获取正确的数据、指标和资源非常容易。这是关于发展一种文化，学会质疑数据，在做出最终结论之前，从多个角度看待一个商业问题。
我们的数据咨询团队与从价值数十亿美元的科技公司到医疗保健公司以及介于两者之间的几乎所有类型的公司都有过合作。我们已经看到好的、坏的和丑陋的数据被用于战略。我们想分享一些简单的变化，这些变化有助于改善贵公司的数据处理方法。
在集中和分散实践之间找到平衡
标准和过度集权不可避免地会拖团队的后腿。对表、数据库和模式进行小的更改可能会被迫经历一些过于复杂的过程，从而影响团队的工作效率。
另一方面，集中化可以更容易地实施新的战略变化，而不必去每个团队，然后强迫他们采取新的流程。
在我们看来，公司可以获得的最大优势之一是开发工具和策略，帮助在集中和分散之间找到一个合适的中间点。这通常包括创建标准来简化开发决策，同时提高管理每个数据团队需要执行的常见任务(如文档和数据可视化)的能力。同时分散通常特定于部门和领域的决策。
这里有一些例子，可以为非标准化的主题提供标准化的工具和过程。
为相似的度量创建 UDF 和库
在包括医疗保健、银行和市场营销在内的几个行业工作后，你会意识到许多团队都在使用相同的指标。
这可能是跨行业的，或者至少是跨内部团队的。问题是每个团队将不可避免地创建不同的方法来计算完全相同的数字。
这可能会导致重复的工作、代码和高管做出相互冲突的决策，因为顶线指标会发生变化。
您可以创建使用相同字段来计算正确指标的集中式库，而不是依赖每个团队来负责创建计算各种指标的过程。这使流程标准化，同时仍为最终用户提供足够的灵活性，使他们能够根据自己的特定需求开发报告。
这只有在指标使用一致的情况下才有效。例如，在医疗保健行业，每个患者每月的成本(PMPM)、再入院率或床位周转率等指标都是一致使用的。这些有时由 EMR(如 EPIC)计算，但仍可能由分析师针对更具体的情况再次计算。它也可能由外部顾问计算。
创建能够轻松完成这项工作的函数或库有助于提高一致性并节省时间。相反，让每个团队开发他们自己的方法，你可以简单地提供一个框架，使实现相同的度量变得容易。
自动化平凡但必要的任务
创建有效的数据策略就是让数据的使用和管理变得简单。
这个过程的一部分需要将所有数据团队需要做的普通任务自动化。
这方面的一个例子是创建文档。文档是帮助分析师理解他们正在使用的表格和流程的一个重要因素。拥有好的文档可以让分析师进行更好的分析。然而，文档经常被推迟到最后一分钟，或者根本不做。
与其强迫工程师记录每个新表，不如创建一个系统，定期自动抓取可用的数据库，并跟踪存在哪些表、谁创建了它们、它们有哪些列，以及它们是否与其他表有关系。
这将是一个由 devops 团队承担的项目，或者您也可以研究第三方系统，例如用于 SQL Server 的 dbForge 文档。这并没有涵盖所有内容，这个工具只适用于 SQL Server。但是一个类似的工具可以帮助简化很多人的生活。
团队仍然需要描述表和列是什么。但是，实际检查和设置基本信息的初始工作都可以自动跟踪。
这有助于减少必要但重复的工作，使每个人的生活变得更轻松。
提供更简单的方法来分享和跟踪分析
这是专门面向数据科学家的。
数据科学家通常会在 Jupyter 笔记本和 Excel 上工作，只有他们才能访问这些文件。此外，许多公司没有强制要求使用某种形式的存储库，如 git，以便数据科学家可以对他们的工作进行版本控制。
这限制了共享文件以及跟踪分析过程中可能发生的变化的能力。
在这种情况下，协作变得很困难，因为同事们经常被来回传递文件和自我版本控制所困扰。通常情况下，这些文件的后缀类似于 _20190101_final、_20190101_finalfile…
对于那些不明白的人，希望你永远也不会明白。
最重要的是，由于许多 python 脚本利用了多个库，所以当您在环境中安装所有正确的版本时，要确保这一点是很困难的。
老实说，所有这些小困难都可能因为故障排除而导致一两天的损失，这取决于您试图运行的分析的复杂程度。
但是，解决方法多的是！
实际上，有很多很棒的工具可以帮助您的数据科学团队进行协作。这包括像多米诺数据实验室这样的公司。
现在，您也可以随时使用 git 和虚拟环境，但这也要求您的数据科学家非常精通这些技术。情况并非总是如此。
同样，这允许您的团队独立工作，但也很容易分享他们的工作。
数据文化转变
当你试图创建一家更加数据驱动的公司时，增加新的库和工具并不是唯一需要发生的变化。一个更重要也更困难的转变是文化上的。
改变人们看待和处理数据的方式是一个非常具有挑战性的关键方面。这里有几个原因。
数据谎言
对于没有读过这本书的人来说，如何用统计数据撒谎，剧透一下，用数字来讲述你想要的故事真的很容易。
有很多方法可以做到这一点。
一个团队可以挑选他们想要的统计数据来帮助他们的议程取得成功。或者，如果你不考虑所有其他变量，一个研究团队可能会忽略混杂因素，并报告一些看起来令人震惊的统计数据。
作为一家数据驱动的公司，这意味着你需要发展一种文化，试图查看统计数据和指标，并确保没有任何东西干扰数字。这一点也不容易。说到数据科学和分析。
大多数度量和统计通常有一些规定，可能会否定它们试图表达的任何信息。这就是为什么创造一种关注指标并问为什么的文化是过程的一部分。如果只是简单地获得输出和 p 值。那么数据科学家就会失业，因为有很多第三方公司的产品可以找到最佳算法，为你进行特征选择。
但这并不是数据科学家的唯一工作。他们在那里质疑每一个 p 值，并真正挖掘他们所看到的数字的原因。
数据仍然杂乱无章
说实话，数据还是很乱。即使有了今天的现代 ERP 和应用程序，数据也是混乱的，有时坏数据会误导经理和分析师。
这可能是由很多原因造成的。应用程序如何管理数据，这些应用程序的系统管理员如何修改所述系统，等等。从业务流程的角度来看，即使是看似微不足道的变化也会对数据的存储方式产生重大影响。
反过来，当数据工程师提取数据时，由于错误的假设和有限的知识，他们可能无法准确地表示数据。
这就是为什么只有数字是不够的。团队还需要对创建所述数据的业务和过程有很好的理解，以确保他们不允许混乱的数据进入分析师直接使用的表中。
我们的观点是，数据分析师需要确信他们正在查看的数据正确地代表了他们相应的业务流程。如果分析师必须删除任何数据，或者一致地执行连接和 where 子句来准确地表示业务，那么数据就不是“自助”的。这就是为什么每当数据工程师创建新的数据模型时，他们都需要与业务部门密切合作，以确保收集正确的业务逻辑并在表的基础层中表示出来。
这样，分析师可以对他们的数据有近乎 100%的信任。
结论
归根结底，创建有效的数据文化需要自上而下和自下而上的思维转变。从执行层面来看，需要决定在哪些关键领域可以帮助简化数据访问。然后，团队可以开始工作，在实际使用数据做决策方面变得更加熟练。我们经常发现大多数团队花太多时间在需要完成但可以自动化的数据任务上。改进您公司的数据方法可以提供巨大的竞争优势，并让您的分析师和数据科学家能够从事他们都喜欢的项目，并帮助您提高利润！
如果你喜欢这篇关于数据科学的文章，那么也考虑一下这些文章吧！
大数据已经从仅仅是一个时髦词变成了一种必需品，高管们需要想出如何与之争论。今天…
www.acheronanalytics.com](http://www.acheronanalytics.com/acheron-blog/hadoop-vs-relational-databases) [## 使用 Python 抓取相遇 API
我们最近发布了一些你可以参与的项目的想法，添加到你的简历中，并帮助你更多地了解…
www.acheronanalytics.com](http://www.acheronanalytics.com/acheron-blog/using-python-to-scrape-the-meet-up-api) [## 自动化工作流程的 4 个简单 Python 想法-西雅图数据人
自动化。它应该可以消除工作。那么，为什么不帮助它呢？说实话，自动化甚至简单的任务…
www.theseattledataguy.com](https://www.theseattledataguy.com/4-simple-python-ideas-to-automate-your-workflow/) [## 软件工程师面试学习指南
这是一个软件工程学习指南，你可以用它来帮助自己准备面试。这是…
www.coriers.com](https://www.coriers.com/the-interview-study-guide-for-software-engineers/) [## Python 后端:Flask 对 Django
你的下一个项目适合做什么？
medium.com](https://medium.com/better-programming/python-backends-flask-versus-django-5de314fa70ff) [## 使用 Python 抓取相遇 API
我们最近发布了一些你可以参与的项目的想法，添加到你的简历中，并帮助你更多地了解…
开发到](https://dev.to/seattledataguy/using-python-to-scrape-the-meet-up-api-316p)
如何提高你的 kaggle 竞赛排行榜排名
美国有线电视新闻网失明检测新大楼的提示
在最近参加了 2019 年 APTOS 失明检测 Kaggle 比赛并获得前 32%的成绩后，我想分享一下我训练卷积神经网络的过程。我之前唯一的深度学习经验是完成 Deeplearning.ai 专业化，因此这是你阅读本文所需的全部内容。
本条的章节
- 竞争环境
- 写日志
- 获取更多数据
- 利用现有内核
- 预处理图像
- 训练是一个非常非常缓慢的过程(但是不要担心)
- 迁移学习
- 型号选择
竞争环境
我在过去的 2-3 个月里断断续续地参加了 Kaggle 上的 APTOS 2019 失明检测比赛，比赛要求你将人们眼睛的图像分为 5 类糖尿病视网膜病变严重程度。在本文的剩余部分，我将谈论一些你可以在任何 kaggle vision 竞赛中使用的技巧和诀窍，，因为我觉得我从这个竞赛中学到的东西基本上是普遍适用的。
记日志
像任何好的科学实验一样，我们一次改变一件事，并将我们的结果与我们的对照进行比较。因此，当训练 CNN(卷积神经网络)时，我们也应该这样做，并在日志中记录变化和结果。这是我在失明检测挑战赛中用过的。
My logbook for Kaggle APTOS Blindness Detection Challenge
我并不声称我在这里使用的精确的表格是理想的(远非如此)，但是我发现至少能够识别每次我进行更改时，模型是否在以前的更改基础上有所改进是非常有用的。无论如何，我强烈建议你保持某种形式的日志，因为很难确定你所做的事情是否有效。
我对下一份比赛日志的一些想法是:
- 建立一个单一的基线模型来比较所有未来的变化
- 想出一堆您想要尝试的调整，并为每个调整独立地运行基线的修改版本，而不是以累积的方式。
- 尽可能长时间保持相同的(最小的)CNN 架构，因为这将使迭代更快，并且通过一些观察，许多超参数应该体面地转移到更大更复杂的模型。
获取更多数据
在你开始编码之前做一些研究，看看以前是否有类似的比赛，或者是否有类似标签的训练集的数据库可以使用。更多的数据永远不会对你的模型造成真正的伤害(假设标签的质量还不错)，所以尽可能地获取更多的数据，但是不要忘记从提供给你的原始数据集中保留你的验证和测试集，否则你可能会以训练测试不匹配而告终。
利用现有内核
如果你是深度学习竞赛的新手(像我一样)，你可能不想从头开始编写整个笔记本——特别是当别人可能已经为你的竞赛发布了一个入门内核时(为什么要重新发明轮子呢？).这可能会为您节省大量调试时间，并通过调整其他人的模型让您更快地学习新东西。
这是一个很好的启动内核,我在几乎所有的进一步试验中使用并改进了它。
下载数千个项目的开放数据集+在一个平台上共享项目。探索热门话题，如政府…
www.kaggle.com](https://www.kaggle.com/mathormad/aptos-resnet50-baseline)
一个警告:如果一个内核建议你的模型使用一些技术，你应该检查它们是否陈述了最终的性能提升，否则，在盲目地将它们合并到你自己的模型之前，要持怀疑态度并自己进行测试:)
预处理图像
裁剪&其他增强:这一步是必须的。训练图像可能处于非常原始的状态。例如，在失明检测挑战中，所有图像都以不同的比例裁剪，这意味着一个愚蠢的算法可能会过度适应眼睛周围的黑色空间，这在一个类别中比另一个类别中更普遍。
Source: https://www.kaggle.com/taindow/be-careful-what-you-train-on
因此，以稳健的方式裁剪图像和调整图像大小是这场竞赛的关键部分。也有许多图像增强技术，如随机裁剪，旋转，对比度和亮度等，我有不同程度的成功。
不均衡的职业:总有一些职业比其他职业有更多的训练例子，所以你需要在开始训练前解决这个问题。在小批量梯度下降过程中，过采样/欠采样以及混合 (Zhang 等人，2019)是一组行之有效的技术组合。
预处理计算:数据集通常会非常大，应用基本程序(如标准化尺寸和图像裁剪)应在单独的内核 t(或离线 dep)中完成。数据集的大小)并作为原始数据的修改版本重新上传——否则，您将不得不在模型的每个时期/运行时进行这种计算(这是对时间的极大浪费)。
训练是一个非常非常缓慢的过程
现在你已经写了你的第一个内核，你需要测试它！Kaggle 内核可以运行长达 9 个小时(内核时间限制可能因竞争而异)，该网站也运行许多模型，因此在一天中的某些时间可能会比其他时间慢。我最好的建议是，首先在浏览器中快速运行 1 到 2 次，以确保你没有犯任何错误，然后获得几个你想同时测试的想法，然后点击提交所有想法，几个小时后再回来检查。注意，如果你点击提交而不是运行内核，你就不必让你的笔记本电脑一直运行:)。
迁移学习
你不会从头开始训练一个足够大的模型。通常情况下，我们只需要在 imagenet 或其他大型数据集上预先训练一个大型模型，并根据我们的目的对其进行微调。几乎在所有情况下，您都应该在微调期间解冻模型的所有层，因为结果可能是最稳定的。
这张图表很好地说明了这一点(Yosinski 等人，2014 年),其中两个网络在数据集 A 和 B 上进行训练，然后网络在第 n 层被切断，之前的层被冻结或微调(用+表示)。在第二幅图中可以看到结论，其中 to 线 AnB+的所有 7 层都经过了调整，产生了最佳的 top-1 精度。
(Yosinski et al. 2014)
型号选择
您可能最好从一个较小的模型(如 ResNet 50)开始，然后尝试一些较大的架构，如(Resnet-101、InceptionNets、EfficientNets)。所有这些网络都有可用的论文，在你继续使用它们之前绝对值得一读，尽管通常你应该期望用新的模型比旧的模型获得更好的准确性。
结束语
有了我上面提供的信息，你应该能在公共和私人排行榜上获得一个真正体面的分数。
我参加这项挑战的直觉告诉我，进入公开排行榜的前 30 名，就有很大机会进入私人排行榜的前 10 名，因为剩下的数据集存在不确定性。
在 APTOS 挑战赛中，排名前 32%和赢得第一名之间的差距比我的分数提高了不到 3%，所以继续调整你的模型吧！
参考
Yosinski，j .，Clune，j .，Bengio，y .和 Lipson，H. (2019)。深度神经网络中的特征有多大的可转移性？。[在线]arXiv.org。地点:【https://arxiv.org/abs/1411.1792】T2。
张，h .，西塞，m .，多芬，y .和洛佩斯-帕兹，D. (2019)。混乱:超越经验风险最小化。[在线]arXiv.org。可在:https://arxiv.org/abs/1710.09412【2019 年 9 月 8 日获取】。
如何通过课程学习提高您的网络性能
Elman 在 1993 年已经提出了课程学习的思想，Bengio 在 2009 年的几个任务中证明了课程学习可以提高网络性能。然而，这些天你很少听到关于它的消息，这就是为什么我决定写一篇关于它的文章。
课程学习描述了一种学习类型，在这种学习中，你首先从一项任务的简单例子开始，然后逐渐增加任务的难度。几十年来，我们人类一直在根据这一原则进行学习，但我们没有将它转移到神经网络，而是让它们从一开始就对整个数据集进行训练，尽管它有各种困难。
为了演示课程学习的效果，我将使用一个相当小的卷积神经网络，尝试将图像分为 10 类。数据集被称为 CIFAR-10，可以在这里找到:https://www.cs.toronto.edu/~kriz/cifar.html网络由两个卷积层组成，后面是一个具有 512 个神经元的全连接层和一个具有 10 个神经元的读出层。网络太小，无法实现 60%以上的性能，但这将更容易看到课程学习如何提高性能，以及如何通过使用这种技术从小型网络中挤出更多的准确性。
Network performance over time on the CIFAR-10 data set. Training with all classes at once for 5 epochs. Red lines mark the beginning of a new epoch. In the bottom right corner you can see some examples out of the data set.
当我们现在查看网络在各个类上的表现时，我们可以看到一些类似乎比其他类更难学。虽然网络在飞机、汽车、轮船或卡车等物体上取得了相当好的性能，但它与猫、狗、鹿和鸟进行了斗争。
接下来，我们想看看如果不从一开始就对所有的类进行训练，而是一步一步地介绍它们，网络性能会有什么变化。在这个实验中，我从十个类中的六个开始，然后在每个新的时期引入一个新的类。这意味着在五个时期之后，所有十个类都在数据集中。之后，网络继续训练另外 20 个时期，以达到稳定的性能。更多关于渐进学习过程和网络成长的信息可以在我的上一篇文章中找到。
当重复这个实验很多次时，每次以随机的班级顺序，人们可以观察到一些表现特别好的运行。如果你现在观察这些表现最好的网络训练，并绘制在运行中使用的课堂顺序与各自的课堂难度的关系，你可以观察到两者之间的显著负相关为-0.27，F(1，16.43)，p<0.001。作为班级难度，我定义了一次正常训练结束时网络在班级上的表现(见上图)。
One dot represents the difficulty of a class shown at the respective point in time during the best performing runs. Class difficulty = the accuracy on this class at the end of a normal network training -> The higher the accuracy the lower the difficulty. Position 0–5 are equal since the network starts out training on six classes.
上图显示了具有最佳执行类顺序的运行如何倾向于首先显示简单类，而从不最后显示简单类。在上一个纪元中引入的所有职业都是普通网络努力学习的职业，因此看起来更难学习。
现在将这些结果再进一步，我们可以将难度递增的训练和难度递减的训练的网络性能进行比较。
Test accuracy distribution over a hundred runs for training with increasing and decreasing class difficulty.
结果显示了两种情况之间的非常显著的差异，其中，随着难度的增加而训练的网络在准确性方面具有大约 4%的领先。
可能最有趣的部分是将这些性能与从一开始就在所有类上训练的正常网络的性能进行比较。
Test accuracy distribution of 100 network trainings for continuous learning (increasing and decreasing difficulty) compared to a normal network training for an equal amount of epochs.
即使正常训练相对于连续学习有一点优势，因为后者在一些类上训练的次数较少，因为它们只是后来才引入的，但是以逐渐增加的难度训练的网络达到显著更高的性能，F(1，953.43)，p <0.001.
It seems as if learning the broad concept on a few easy examples and only later on refining the concept with more complex examples gives the continuously learning network a distinct advantage over a network which needs to grasp the whole concept at once.
When thinking about real life this appears quite intuitive, one would not mix advanced calculus into a first grader’s math homework, but with neural networks this seems to be common practice. Of course it is an additional effort to determine individual class difficulties, but for reaching or exceeding benchmarks and deploying an optimal model this additional effort can
很容易值得。
代号:https://github . com/vkakerbeck/progressive-Growing-Networks
参考文献:
Bengio，Yoshua 等人(2009 年)。“课程学习”。载于:《第 26 届机器学习国际年会论文集》,第 41-48 页。刊号:0022–5193。多伊:10。1145 / 1553374 .1553380.arXiv: arXiv : 1011。1669v3。
埃尔曼，L (1993 年)。“神经网络中的学习和发展:从小处着手的重要性”。载于:第 48 页，第 71-99 页。
增加你的机器学习模型的影响
关于平衡努力
随着媒体的大肆宣传和学术机器学习社区的最新发展，有时感觉这就是最重要的事情:
或者，在例如用于自然语言处理的单词嵌入的情况下:
那有什么问题？
通常，行业机器学习项目并不基于像 MINST 这样固定的、预先存在的参考数据集。很多努力都花在了获取训练数据上和清理训练数据上和。由于这些任务是高度具体的项目，不能一概而论，他们很少被谈论，也没有得到媒体的关注。
后期建模步骤也是如此:如何将你的模型带入制作？模型输出将如何创造实际的商业价值？还有对了，这些问题不是应该事先就想好了吗？虽然服务工作流的模型在某种程度上是可转移的，但货币化策略通常是特定的，不会公开。
有了这些考虑，我们可以描绘一幅更准确的画面。这是真正影响你的机器学习项目的因素:
现在，我如何最好地增加模型的影响？
关键是平衡你的努力。更准确地说:注意在花费的时间和总体影响方面，哪个步骤产生的投资回报最高。这将随着你的进步而改变:一旦你充分改进了一个组件，在另一个组件上的工作将变得更加有效。请记住，您不需要在最终的执行顺序中这样做:货币化阶段，也就是上图中的最后一步，可能是您应该首先考虑的。
获得更多的训练数据或提高其质量可能比吹嘘使用最先进的深度学习架构更乏味，也没有那么迷人，但从整体模型性能来看，往往更有价值。如果你还不知道如何建立一个高效的机器学习系统，以及它将如何实际影响公司决策，就不要专注于花哨的技术。
那么，当开始一个新项目时，这意味着什么呢？你可以
- 把数据转储到 Keras。如果模型性能不令人满意，请使用更多的层。调整所有参数。
- 几周过去了。
或者你可以
- 想想这个项目将如何真正帮助你的公司。尽早让需要的人加入进来，让他们感受到努力的一部分。为所有步骤设计一个计划。确保一个关键决策者支持你。钻研数据，做一些可视化和清理，获得关于平均值、异常值、相关性、缺失字段和底层业务流程的良好感觉。尝试决策树或逻辑回归作为简单、可解释的基线模型。例如，使用云平台进行原型部署和测试您的工作流程。
- 从那里迭代。在每一步中，改进你认为目前在商业价值和时间方面能给你带来最高投资回报的组件。得到反馈。
- 你将有一个早期的原型展示。这将建立信任并解锁资源。进一步的渐进、平衡的改进确保你不会浪费时间拧紧错误的螺丝。
就是这样！感觉少了点什么？完全不同意？请在评论中分享你的观点！
如何初始化神经网络
权重初始化技术的实际应用
Image source: https://pixabay.com/photos/sport-tracks-running-run-sprint-1201014/
训练神经网络远不是一项简单的任务，因为最轻微的错误都会在没有任何警告的情况下导致非最佳结果。训练取决于许多因素和参数，因此需要深思熟虑的方法。
众所周知，训练的开始(即最初的几次迭代)非常重要。如果操作不当，结果会很糟糕——有时，网络甚至什么也学不到！因此，初始化神经网络权重的方式是良好训练的关键因素之一。
本文的目标是解释为什么初始化会产生影响，并给出有效实现它的不同方法。我们将通过实际例子来检验我们的方法。
代码使用了 fastai 库(基于 pytorch)。所有的实验笔记本都可以在这个 github 库中找到。
为什么初始化很重要？
神经网络训练基本上包括重复以下两个步骤:
- 前进的一步在于权重和输入/激活之间的大量矩阵乘法(我们称激活为将成为下一层输入的层的输出，即隐藏激活)
- 向后的步骤，包括更新网络的权重，以便最小化损失函数(使用参数的梯度)
在向前的步骤中，激活(然后是梯度)可以很快变得很大或很小——这是因为我们重复了许多矩阵乘法。更具体地说，我们可能会得到:
- 非常大的激活，因此大梯度射向无限
- 非常小的激活，因此梯度极小，由于数值精度，梯度可能被抵消为零
这两种影响对训练都是致命的。下面是在第一次向前传递时，使用随机初始化的权重进行爆炸的示例。
在这个特殊的例子中，平均值和标准偏差在第 10 层已经很大了！
让事情变得更加棘手的是，在实践中，即使在避免爆炸或消失效果的同时，经过长时间的训练，你仍然可以获得非最佳的结果。这在下面一个简单的 convnet 上有所说明(实验将在文章的第二部分详述):
请注意，默认的 pytorch 方法并不是最好的方法，随机初始化并不能学到很多东西(另外:这只是一个 5 层网络，这意味着更深层次的网络不会学到任何东西)。
如何初始化您的网络
回想一下，良好初始化的目标是:
- 获取随机权重
- 在第一个正向过程中，将激活保持在良好范围内(反向过程中的梯度也是如此)
什么是练好的靶场？定量地说，这意味着使矩阵与输入向量相乘的输出产生平均值接近 0 且标准偏差接近 1 的输出向量(即激活)。那么每一层将在所有层中传播这些统计数据。
即使在一个深度网络中，你也会在第一次迭代中获得稳定的统计数据。
我们现在讨论两种实现方法。
数学方法:明凯初始化
让我们想象一下这个问题。如果初始化的权重在训练开始时太大，那么每个矩阵乘法将指数地增加激活，导致我们所说的梯度爆炸。
相反，如果权重太小，那么每次矩阵乘法将减少激活，直到它们完全消失。
因此，这里的关键是缩放权重矩阵，以获得均值约为 0、标准差为 1 的矩阵乘法输出。
但是如何定义权重的范围呢？因为每个权重(以及输入)都是独立的，并且按照正态分布分布，所以我们可以通过计算得到帮助。
两篇著名论文基于这一思想提出了一个很好的初始化方案:
- “Xavier 初始化”，在 2010 年的论文中提出理解训练深度前馈神经网络的难度
- “明凯初始化”，2015 年在论文中提出，深入研究整流器:在 ImageNet 分类上超越人类水平的性能
实际上，这两种方案非常相似:“主要”区别在于明凯初始化考虑了每次矩阵乘法之后的 ReLU 激活函数。
现在，大多数神经网络使用 ReLU(或类似 leaky ReLU 的类似函数)。这里，我们只关注明凯初始化。
简化公式(对于标准 ReLU)是通过以下方式对随机权重(取自标准分布)进行缩放:
例如，如果我们有一个大小为 512 的输入:
此外，所有偏置参数应初始化为零。
注意，对于 Leaky ReLU，公式有一个额外的部分，我们在这里没有考虑(我们让读者参考原始论文)。
让我们看看这个方法在前面的例子中是如何工作的:
请注意，现在我们在初始化后获得了平均值为 0.64、标准偏差为 0.87 的激活。显然，这并不完美(怎么可能是随机数呢？)，但比正态分布的随机权重好得多。
50 层之后，我们得到的平均值为 0.27，标准差为 0.464，因此不再有爆炸或消失的效果。
可选:明凯公式的快速解释
明凯的论文中提供了导致 math.sqrt 的神奇缩放数(2 /输入向量的大小)的数学推导。此外，我们在下面提供了一些有用的代码，读者可以完全跳过这些代码进入下一节。注意，代码要求理解如何做矩阵乘法以及什么是方差/标准差。
为了理解公式，我们可以考虑矩阵乘法结果的方差是什么。在本例中，我们将一个 512 矢量乘以一个 512x512 矩阵，得到一个 512 矢量的输出。
在我们的例子中，矩阵乘法输出的方差大约等于输入向量的大小。根据定义，标准差是它的平方根。
这就是为什么将权重矩阵除以输入向量大小的平方根(本例中为 512)会得到标准差为 1 的结果。
但是“2”的分子从何而来？这只是考虑到了 ReLU 层。
如你所知，ReLU 将负数设置为 0(只有 max(0，input))。所以，因为我们有以平均值 0 为中心的数字，它基本上消除了一半的方差。这就是为什么我们加一个分子 2。
明凯 init 的缺点是
明凯 init 在实践中非常有效，那么为什么要考虑另一种方法呢？事实证明，Kaming init 有一些缺点:
- 一层之后的平均值不是 0，而是大约 0.5。这是因为 ReLU 激活函数，它删除了所有的负数，有效地改变了它的平均值
- 明凯初始化只适用于 ReLU 激活函数。因此，如果你有一个更复杂的架构(不仅仅是 matmult → ReLU 层)，那么这将不能在所有层上保持大约 1 的标准偏差
- 一层之后的标准偏差不是 1，而是接近 1。在深度网络中，这不足以使标准差始终接近 1。
算法途径:LSUV
那么，在不为更复杂的架构手动定制明凯初始化的情况下，我们能做些什么来获得一个好的初始化方案呢？
2015 年的论文展示了一种有趣的方法。它被称为 LSUV(层序单位方差)。
解决方案在于使用简单的算法:首先，用正交初始化来初始化所有层。然后，取一个小批量输入，并为每一层计算其输出的标准偏差。将每层除以产生的偏差，然后将其重置为 1。下面是论文中解释的算法:
经过一些测试，我发现正交初始化比在 ReLU 之前进行明凯初始化给出了相似(有时更差)的结果。
杰瑞米·霍华德在 fastai MOOC 中展示了另一种实现方式，它对权重进行了更新，以保持均值在 0 左右。在我的实验中，我还发现将平均值保持在 0 左右会得到更好的结果。
现在让我们比较这两种方法的结果。
初始化方案的性能
我们将在两个架构上检查不同初始化方案的性能:一个具有 5 层的“简单”convnet 和一个更复杂的类似 resnet 的架构。
任务是在Imagenet 数据集(Imagenet 数据集的 10 个类的子集)上进行图像分类。
简单的建筑
这个实验可以在这个笔记本里找到。请注意，由于随机性，每次的结果可能会略有不同(但不会改变顺序和整体情况)。
它使用一个简单的模型，定义为:
ConvLayer 是一个 Conv2D 层，后跟一个 ReLU
nn。Sequential(ConvLayer(3，32，ks=5)，ConvLayer(32，64)，ConvLayer(64，128)，ConvLayer(128，128)，nn。AdaptiveAvgPool2d(1)，Flatten()，nn。线性(128，data.c))
下面是 3 个初始化方案的比较:Pytorch 默认的初始化(它是一个明凯初始化，但有一些特定的参数)，明凯初始化和 LSUV 初始化。
请注意，随机初始化的性能太差了，我们从下面的结果中删除了它。
【init 后的激活统计
第一个问题是在第一次迭代向前传递后的激活统计是什么？我们越接近平均值 0 和标准差 1，就越好。
该图显示了初始化后(训练前)每一层的激活状态。
对于标准差(右图)，LSUV 和明凯初始值都接近 1(LSUV 更接近)。但是对于 pytorch 默认值，标准差要低得多。
但是对于平均值，明凯初始结果更差。这是可以理解的，因为明凯 init 没有考虑平均的 ReLU 效应。所以平均值在 0.5 左右而不是 0。
复杂架构(resnet50)
现在让我们检查一下在一个更复杂的架构上是否得到了类似的结果。
架构是 xresnet-50，在 fastai 库中实现。它比我们之前的简单模型多了 10 倍的层数。
我们将分两步进行检查:
- 没有规范化层:batchnorm 将被禁用。因为这一层将逐批修改 stats mini，所以它应该会降低初始化的影响
- 使用规范化图层:batchnorm 将被启用
第一步:没有 batchnorm 这个实验可以在这个笔记本里找到。
如果没有 batchnorm，10 个时期的结果是:
该图显示 LSUV 的精度(y 轴)为 67%,明凯初始化为 57 %, py torch 默认为 48%。差别是巨大的！
让我们在训练前检查激活统计:
让我们缩放以获得更好的比例:
我们看到一些层的 stats 为 0:这是 xresnet50 的设计，与 init 方案无关。这是论文中的一个技巧，用于使用卷积神经网络进行图像分类(在 fastai 库中实现)。
我们认为:
- Pytorch 默认初始化:标准差和均值接近于 0。这是不好的，显示了一个正在消失的问题
- 明凯·尼特:我们得到了一个很大的均值和标准差
- LSUV init:我们得到了很好的统计数据，虽然不完美，但比其他方案要好
我们看到，即使在 10 个完整的时期之后，这个例子的最佳初始化方案对于完整的训练给出了好得多的结果。这显示了在第一次迭代中保持各层良好统计的重要性。
步骤 2:使用 batchnorm 图层
这个实验可以在这个笔记本里找到。
因为 batchnorm 正在规范化一个层的输出，我们应该期望 init 方案的影响较小。
结果显示，所有 init 方案的准确率接近 88%。请注意，在每次运行时，最佳初始化方案可能会根据随机生成器而变化。
它表明 batchnom 层使网络对初始化方案不太敏感。
培训前的激活统计如下:
像以前一样，最好的似乎是 LSUV init(只有它能保持平均值在 0 左右，标准差接近 1)。
但是结果显示这对准确性没有影响，至少对于这个体系结构和这个数据集是这样。不过它证实了一件事:batchnorm 使网络对初始化的质量不太敏感。
结论
从这篇文章中要记住什么？
- 第一次迭代非常重要,会对整个培训产生持久的影响。
- 一个好的初始化方案应该在网络的所有层(对于第一次迭代)保持关于激活的输入统计(平均值为 0，标准偏差为 1)。
- 批处理层降低了神经网络对初始化方案的敏感性。
- 使用明凯 init + LSUV 似乎是一个不错的方法，尤其是当网络缺少标准化层的时候。
- 其他类型的架构在初始化方面可能有不同的行为。
如何在你的 Mac 上安装一个完全免费的 Windows 10 操作系统来获得乐趣和利润
创建免费虚拟机的完整初学者指南:轻松运行任意数量的操作系统进行黑客攻击、游戏、渗透测试、软件测试、调试等等。
Image by Ian Lindsay from Pixabay
你可以在你的 Mac 电脑上免费运行完全不同的操作系统。大概五分钟后就可以启动运行了。
想要一台运行 Windows 10 的机器？
搞定。
即使是最忠实的 Mac 粉丝在某些时候也可能想要或需要使用 Windows(或另一个操作系统)。你可能想测试一些在 Windows 下运行的很酷的工具或游戏。你可能迫切需要一个不同于你面前的操作系统。你可能需要检查一些有问题的软件，或者处理一个错误或病毒。
有可能是你真正开始玩游戏的时候了…
GIF via GIPHY
幸运的是，在你的 Mac 上安装一个免费的虚拟机并像运行其他应用程序一样运行它非常简单。一旦你知道你在做什么，只需要不到五分钟的时间！
关于虚拟机
无论您是对渗透测试、黑客攻击、软件调试感兴趣，还是只想(或需要)运行一些基于 Windows 的程序和游戏，虚拟机(VM)都是一个方便的东西。它们允许你在桌面上的一个窗口中安装和运行操作系统，如 Windows 或 Kali Linux 。
这个新的客户操作系统认为它运行在一台真正的电脑上，但它实际上是运行在你的 Mac 上的一个软件内部。该虚拟机与您计算机的其余部分“隔离”。这意味着它完全独立于你的电脑。您可以免受 bug、病毒和许多其他安全问题的侵害。
虚拟机允许你同时运行多个操作系统。您可以在一个操作系统上运行为另一个操作系统编写的软件，而无需重启。因为您可以配置您的虚拟硬件，您甚至可以安装一个旧的操作系统，如 d OS 或 OS/2。
您可以随时用“快照”保存计算机的状态，并在需要时恢复到该状态。这让你可以自由地试验你的环境。如果出现问题，无论是软件安装还是系统感染病毒，您都可以轻松切换回之前的快照。不需要持续的备份和恢复。
VirtualBox
尽管有很多流行的虚拟机程序，但是 VirtualBox 是完全免费的，开源的，非常棒。当然，有些细节，比如 3D 图形，在 VirtualBox 上可能不如在你付费的东西上那么好。如果你追求的是速度和图形，你可能会想看看付费版本。
我听说 Parallels Desktop 很棒，比 VirtualBox 快得多，但我自己并没有真正试过。如果你有喜欢的，在下面的评论里让人们知道吧！
那么什么是虚拟机呢？它是一种计算机文件(通常称为图像)，其行为类似于实际的计算机。这就像你在自己的电脑里创造了一台电脑。它运行起来很像任何其他程序，但虚拟机与系统的其余部分是分开的。这意味着虚拟机内部的软件无法逃脱并篡改你的计算机。这使得它成为测试新版本、检查受感染数据、创建操作系统备份以及在最初不支持的操作系统上运行应用程序和软件的理想场所。
您甚至可以在同一台计算机上同时运行多个虚拟机。
Image by (Joenomias) Menno de Jong from Pixabay
我想要那个
我们将对安装带有扩展包的 VirtualBox 并运行 Windows 10 所需的绝对基础知识做一个简单的演练。这只是设置的一种方式。如果你感兴趣的话，你可以从这里得到更多的乐趣！
我们将要使用的程序是完全免费的，我们有使用它们的许可。(我把它放在这里是因为当你接近黑客世界时，事情会变得相当棘手。)我们将前往 Oracle 获取 VirtualBox 和 VirtualBox 扩展包。然后我们将前往微软获取我们想要使用的 Windows 版本。
步骤 1:下载 VirtualBox
如果你进入 VirtualBox ，你会看到一个巨大的绿色“下载 VirtualBox”按钮。继续点击或者前往 VirtualBox 下载页面为您的系统选择正确的 VirtualBox 版本。如果你在 Mac 上，你会点击 MacOsX 链接。
或者:
在下载页面上，您还会看到一个标题为“VirtualBox 6 . 0 . 8 Oracle VM Virtual Box 扩展包”的部分单击“所有支持的平台”下载扩展包。
第二步:抢到 Windows 10
你有几种方法可以在你的虚拟机上安装 Windows 10，但这是我发现的最简单的一种。它是由微软专门为测试目的而设计和发布的。如果您想要运行 Windows 10 和“选择平台”下的“VirtualBox”，请确保您选择了“MSEdge on Win10 (x64) Stable 1809”然后点击“下载。拉链"按钮！
**更新 * *这是一个完全免费的 Windows 10 版本，但是你并没有无限制、不受限制地使用这个软件。这不是你可以永远无限制使用的无限制版 Windows。我不知道你在哪里可以找到这样的东西，但是如果你有，请告诉我们！
该软件由微软提供，仅供有限使用。该许可证的有效期为 90 天。你可以复制一份，用它来重新安装软件，90 天后就没问题了(这在官方文件中有明确说明)。如果你想在 90 天后继续使用该软件，请为此制作一份副本)，但这不是完全版的 Windows 10，它可以永远免费使用，没有任何限制。这是微软提供的 Windows 10 的合法免费版本，您可以在有限的时间内用于有限的目的，并随时从网站或备份副本快速轻松地重新安装。
当然，这并不是在 VirtualBox 上安装 Windows 10 的唯一方式。对于初学者和开发人员来说，这是一种非常快速和方便的方式来访问和测试 Windows 10 所提供的大部分功能。
有些可选:取消归档
下载解压器也是有意义的。这是打开这些文件的快速、免费和强大的方法。在微软官方文档中也有推荐。你不需要使用它来打开 VirtualBox 或扩展包，但使用像这样的应用程序来提取 Windows 10 下载是一个好主意。
一旦你的下载准备好了，去你的下载文件夹。右键单击 VirtualBox 图标，转到“打开方式”，然后单击“取消归档”这将解压缩并打开您的文件。
步骤 3:安装 VirtualBox 和扩展包
您可以像安装任何程序或应用程序一样，直接将 VirtualBox 安装到应用程序文件夹中。当然，如果你想的话，你可以改变位置。然后按照安装程序的提示进行操作。
接下来，转到您的应用程序文件夹(或您为 VirtualBox 指定的位置),双击图标将其打开。
您可以像安装 VirtualBox 一样打开并安装您的扩展包。当您开始安装时，您会看到一个弹出窗口，让您知道您正在安装什么。点击“安装”
步骤 4:启动并运行您的操作系统
现在您已经安装了 VirtualBox，是时候创建虚拟机了。要做到这一点，你需要一个操作系统。我们将使用我们的 Windows 10 微软下载，但如果你进入这个，你有很多选择！
继续使用解压缩程序打开您的 Microsoft 下载。如果您想按原样使用，Windows 已经安装完毕，可以随时运行。为此，请单击“导入”您可以按原样导入它，然后随时修改您的设置。如果你没有不同的计划，就按现在的方式导入吧。
现在转到 VirtualBox 并单击“新建”这将打开一个向导，引导您完成安装。
首先，你需要给你的虚拟机一个名字。因为这很有趣，所以我强烈建议给你的虚拟机取一个描述性强、简单明了的名字。过一段时间后，他们开始看起来非常相似，这将为你节省一些严重的挫折。类似“Windows 10”或“MSEdge-Win10”的东西很有意义。
如果你选择了有创意的名字，并真正进入其中，你可能很难记住“松饼”运行的是 Windows 10，而“Tchotchke”运行的是 Kali Linux 等等。
Image by MrsBrown from Pixabay
指定您将运行的操作系统的类型(Microsoft Windows)和版本(Windows 10 64 位)，然后单击“下一步”
现在你需要设置内存的大小。您正在指定有多少计算机内存将分配给虚拟机。VirtualBox 会自动让您知道所选操作系统的建议最小容量，但您可以根据需要增加或减少。
请记住，您只能使用系统实际拥有的内存量，将其设置为最大值并不是一个好主意。当您运行虚拟机时，将不会有任何空间留给您的常规操作系统使用！不要指定超出您能力范围的内容，尤其是当您认为可能会同时运行多个虚拟机时。不管怎样，你最好待在绿色区域。否则，您可能会面临一些严重的性能问题。
点击“继续”
现在你需要创建一个虚拟硬盘。选择一个选项并单击“创建”，然后浏览提示并再次单击“创建”。你需要一个虚拟硬盘来安装你的操作系统和其他程序。
虚拟硬盘最常见的格式是 VirtualBox 磁盘映像(VDI)。确保它至少有足够的空间来安装操作系统。请记住，您要安装的任何程序也会占用您的虚拟硬盘空间！
我选择了“动态分配”作为存储细节，但这可能不适合您。一个动态分配的文件会随着你存储数据而增长。它开始很小，但它会成长。另一方面，固定大小的文件将立即占据您指定的大小。尽管这种类型的文件最初会占用更多的空间，但它会产生较少的开销。这意味着它实际上稍微快一点。
单击“创建”创建您的新虚拟机！现在你会看到你的新机器列在你的 VirtualBox 窗口的左侧。
是时候开始操作系统安装了！配置好虚拟机后，安装向导将关闭，您将返回 VirtualBox 主窗口。双击左边的新机器(或者确保它已被选中，然后单击“开始”)。
要从映像文件(这就是我们有的)安装，请单击文件夹图标浏览您的文件。你正在寻找我们的微软下载。选择该文件并单击“开始”
现在您的安装将开始！一旦完成，你就可以开始了。
恭喜你！
你现在是一台运行在你的 Mac 上的 Windows 机器的骄傲的主人了！
在你设置的时候，确保你把你的虚拟机当成一台完全独立的计算机。这会帮助你避免沮丧。当你运行你的虚拟机时，它完全独立于你的真实计算机。您无权访问相同的文件和文件夹。即使你点击鼠标也不会在你的电脑和虚拟机之间来回移动，除非你这样设置。
最终细节
双击 VirtualBox 屏幕左侧的机器，或者在任何想要运行机器的时候单击机器并点击“开始”。
将会打开一个窗口，您将会看到全新的 Windows 机器。真正启动并运行可能需要几秒钟(或几分钟)。如果一开始感觉有点慢或者有故障，深呼吸几次。
一旦你的新 Windows 机器开始运行，继续点击窗口中的任何地方来唤醒它。它会要求您输入用户名和密码。你可以在官方安装文档中随时找到这些。(你的用户名是“IEUser”，密码是“Passw0rd！”但是你可以在控制面板的“用户帐户”下随时更改)
当你第一次启动你的机器时，窗口非常小。您可以按正常方式扩展窗口，但它不太可能会调整大小以适应最初的大小。你可以通过从视图菜单中选择“缩放模式”来实现。如果您想忽略纵横比，请在调整窗口大小时按住 shift 键。
首先，当你在虚拟机上工作时，它会“拥有”你的键盘和鼠标。您可以在窗口的右下角看到从虚拟机切换到常规操作系统所需的命令。在虚拟机运行时，您还可以选择在两者之间来回移动鼠标，方法是转到屏幕顶部的输入并选择“鼠标集成”
移动文件
在设置好我的虚拟机后，我需要快速抓取一些我下载到 Mac 上的文件和程序。这是一个小紧急情况，没有时间进行研究。这可能不是将您的信息从 Mac 转移到 Windows 机器的最佳方式(反之亦然)，但我发现将我的文件上传到 OneDrive 是从 Mac 上获取我需要的内容的最简单、最快的方法。它已经安装好了，可以在 Windows 机器上运行了。注册 OneDrive 既快又免费。
这肯定不是唯一的解决方案，但如果你很着急，它就在这里。(如果你目前没有存储问题，Dropbox 也可以工作得很好……)
快照
VirtualBox 允许您复制虚拟机的确切状态。允许你在任何时候回到那个状态。这对于测试软件或其他配置非常有用。您可以通过点按“机器”菜单并选择“拍摄快照”来拍摄快照该快照将被添加到 VirtualBox 菜单左侧的虚拟机列表中。您可以通过右键单击快照并选择“恢复”来恢复快照恢复快照时，自创建快照以来对虚拟硬盘所做的任何更改都将丢失。
停工
关闭虚拟机时，您有几个不同的选项。每一种对机器的影响都有所不同。当您关闭虚拟机窗口时，您会看到几个选项。您可以选择:
- 保存机器状态。这将虚拟机保存为您关闭时的状态。您正在运行的任何程序都将保存为其当前状态，当您再次启动机器时，一切都将恢复。
- 发出关机信号。这将向虚拟机发送一个关机信号，它将像你按下物理计算机上的电源按钮一样关机。
- 关闭机器电源。这将关闭机器的电源，就像切断了计算机的电源一样。什么都不会被保存。
你做到了！
恭喜你！！！你现在是一台免费 Windows 机器的骄傲拥有者，你可以在你的 Mac 上随时运行它！在这里你几乎可以做任何事情。开始玩吧！
和往常一样，如果你用这些信息做了什么惊人的事情，请在下面的评论中让每个人都知道，或者随时在 LinkedIn @annebonnerdata 上联系。
感谢阅读！如果你想接触或找到更多酷的文章，请来和我一起在内容简单！
如何在 Windows 环境下安装 OpenAI Gym
一步一步的指导如何建立和运行 OpenAI 健身房
这是关于强化学习和 OpenAI 健身房系列文章的第二篇。第一部分可以在这里找到。
介绍
OpenAI Gym 是一个非常棒的工具，它使业余和专业的计算机科学家有可能实验一系列不同的强化学习(RL)算法，甚至有可能开发他们自己的算法。
OpenAI Gym 旨在成为 RL 研究的标准化环境和基准，是一个 Python 包，包含一系列 RL 环境，从简单的“玩具”环境到更具挑战性的环境，包括模拟机器人环境和 Atari 视频游戏环境。
该软件包唯一的缺点是，尽管世界上超过 80%的台式机和笔记本电脑都运行 Windows 操作系统，但 OpenAI Gym 只支持 Linux 和 MacOS。
然而，仅仅因为 OpenAI Gym 不支持 Windows，并不意味着你不能让 OpenAI Gym 在 Windows 机器上工作。在这篇文章中，我将提供如何在我的 Windows 10 PC 上安装和运行 OpenAI Gym 的说明。
注意:这些指令足以让 OpenAI Gym 的算法、玩具文本、经典控制、Box2D 和 Atari 环境工作。OpenAI Gym 还包括 MuJoCo 和机器人环境，允许用户使用 MuJoCo 物理模拟器进行实验。然而，要运行这些环境，你还需要安装 MuJoCo 这将花费你至少 500 美元购买一年的许可证(除非你是学生)。
说明
这些说明假设您的计算机上已经安装了 Python 3.5+。
步骤 1:安装用于 Visual Studio 2017 的 Microsoft Visual C++构建工具
如果你的电脑上还没有，安装Microsoft Visual c++ Build Tools for Visual Studio 2017。这可以在这里免费下载。
您需要将页面向下滚动到“Visual Studio 2017 工具”部分。
步骤 2:安装所有必要的 Python 包
鉴于 OpenAI Gym 在 Windows 环境中不受支持，我认为最好将其设置在单独的 Python 环境中。这是为了避免潜在地破坏我的主要 Python 安装。
在 Conda 中，可以使用下面的命令(在终端或 Anaconda 提示符下)来实现这一点:
conda create -n gym python=3 pip
这个命令创建一个名为“gym”的 Conda 环境，它运行 Python 3 并包含 pip 。
如果您在创建 Conda 环境时没有安装 pip ，那么您试图在该环境中安装的任何包都将被全局安装到您的基本 Python 环境中，而不仅仅是本地安装到该环境中。这是因为在您的本地环境中不存在一个版本的 pip 。
要激活新的环境类型:
activate gym
接下来运行以下命令:
pip install gym
这是 OpenAI 健身房的最小安装。
conda install pystan
这是运行 ToyText 环境所必需的。
conda install git
pip install git+https://github.com/Kojoley/atari-py.git
这是运行 Atari 环境所必需的。
conda install swig
pip install Box2D
这是运行 Box2D 环境所必需的。
pip install gym[all]
这将安装剩余的 OpenAI Gym 环境。可能会出现一些错误，但请忽略它们。
pip install pyglet==1.2.4
pip install gym[box2d]
最后两行是必要的，以避免 Pyglet 和 Box2D 环境中可能出现的一些错误。
一旦你完成了这些，安装你希望在 Conda 环境中安装的任何其他 Python 包。
步骤 3:安装 Xming
在你的电脑上安装 Xming，可以从这里免费下载。
第四步:开始跑步
每次您想要使用 OpenAI Gym 时，在启动 Python IDE 之前，通过在 Windows 命令提示符下输入以下命令来启动 Xming running:
set DISPLAY=:0
第五步:测试
要测试新的 OpenAI Gym 环境，请运行以下 Python 代码:
如果一切都设置正确，应该会弹出一个窗口，显示在 Cart Pole 环境中进行的 1000 次随机操作的结果。
为了测试其他环境，将代码第 3 行中的“CartPole-v0”替换为环境名。比如《Taxi-v2》《太空入侵者-v 0》《lunar lander-v2》。
你可以在 OpenAI 健身房网站这里找到所有可用环境的名称和描述。
结论
如果你遵循了这些说明，你现在应该已经成功地在你的电脑上运行 OpenAI Gym 了。然而，现在它已经开始运行了，你用它做什么呢？
在我的下一篇文章中，我将介绍如何将这个令人兴奋的工具应用于强化学习问题。
想了解更多关于价值驱动的数据科学？ 加入我的邮件列表，让我的最新文章和建议直接发送到你的收件箱。
如何在远程机器上安装 PySpark
简单的方法。
Spark, Wikipedia.
假设您想在使用 python 的机器上运行 Spark。要做到这一点，您需要在机器上运行 PySpark，并在 Jupyter 或 python 中使用它，这需要在您的 shell 中进行一些安装和调试。我使用下面的过程解决了这个问题，成功地安装了 PySpark 并在 Jupyter 实验室中运行了演示代码。此程序旨在使用股票张量流 1.14 引导映像在基于 Gloud 的机器上执行，但是，这些指令也应该在本地机器上工作。
安装 Java 1.8
- 网上说很多版本都有兼容性问题，所以请安装 java 1.8:
sudo apt 更新
2.检查您的 java 版本
java 版本
3.如果没有安装 Java，请执行以下操作
apt 安装 openjdk-9-jre-headless
4.验证 java 的版本
java 版本
5.您应该会得到与此类似的结果:
openjdk 版本" 1.8.0_222"
OpenJDK 运行时环境(build 1 . 8 . 0 _ 222–8u 222-b10–1 ~ deb9u 1-b10)
open JDK 64 位服务器 VM (build 25.222-b10，混合模式)
6.(可选)如果显示另一个版本的 java，请执行以下操作并选择指向 java-8 的版本。
sudo 更新-备选方案-配置 java
输出:
There are 2 choices for the alternative java (providing /usr/lib/java).Selection Path Priority Status
------------------------------------------------------------
* 0 /usr/lib/java/java-11-openjdk-amd64/bin/java
1 /usr/lib/java/java-11-openjdk-amd64/bin/java
2 /usr/lib/java/java-8-openjdk-amd64/jre/bin/java Press <enter> to keep the current choice[*], or type selection number:
7.找到 java.home 在哪里
Java-XshowSettings:properties-version 2 > & 1 >/dev/null | grep ' Java . home '
8.(或者)您可以设置 JAVA_HOME
导出 JAVA _ HOME = " $(/myJavaHome/JAVA _ HOME-v 1.8)"
或者创建并添加到~/。bash _ profile
然后
来源。bashrc
此时，您应该已经有了 java_home 目录，您可以开始安装 PySpark，过程是类似的，因此，我们还需要找到 Spark 的安装位置。
安装 PySpark
- pip 安装以下项目:
pip3 安装 findspark
pip3 安装 pyspark
2.找到 pyspark 在哪里
pip3 显示 pyspark
输出:
名称:pyspark
版本:2.3.1
摘要:Apache spark Python API
主页:https://github.com/apache/spark/tree/master/python
作者:Spark 开发者
作者-邮箱:dev@spark.apache.org
许可:http://www.apache.org/licenses/LICENSE-2.0
位置:/usr/local/lib/Python 3.5/site-packages 需求:py4j
至此，我们已经拥有了所需的一切，只需在下面的代码中替换主目录指针并运行演示程序。
初始化:
下面是在您的代码中配置一切，使用之前为 PySpark & Java 找到的主目录信息。
导入 findspark
导入 OS
spark _ HOME = ' mySparkLocation '
JAVA _ HOME = ' myJavaHome '
OS . environ[' JAVA _ HOME ']= JAVA _ HOME find spark . init(spark _ HOME = spark _ dir)
演示:
如果一切配置正确，这个演示将工作，祝你好运:)
从 pyspark.sql 导入 pyspark
导入 spark session
spark = spark session . builder . getor create()
df = spark . SQL(" select ' spark ' as hello ")
df . show()
spark . stop()
参考
Ori Cohen 博士拥有计算机科学博士学位，主要研究机器学习。他是 TLV 新遗迹公司的首席数据科学家，从事 AIOps 领域的机器和深度学习研究。
如何为 AWS Lambda 层安装 Python 包
关于如何使用 Docker 容器为 AWS Lambda 层构建 Python 包的指南。
Image Source: bvoyles4 from Pixabay (Modified by Author)
Lambda 及其层
当我第一次听说 AWS Lambda 时，我对它是什么感到非常困惑，并试图用它来训练一个简单的 ML 模型，但遇到了 5 分钟的执行限制。快进几年，我相信 Lambda 已经发展了很多，人们对事件驱动系统和无服务器计算的理解也是如此。它已经成为许多现代应用程序和数据架构师的一部分。
在 re:Invent 2018 上，Lambda 进行了大量的定制运行时改进，并将执行运行时限制增加到 15 分钟。 Lambda Layers 也发布了，它允许你共享公共依赖项，以简化 Lambda 部署规模和更新。然而，AWS 仍然没有解决友好步骤的需求，以引入非原生 python 包，例如熊猫。
引入外部包的麻烦方法…
目前，你要么压缩你的 Lambda 函数和 Linux 兼容的依赖项，要么上传你的依赖项作为 Lambda 层。如果你以前玩过 Google Cloud Functions 和 Azure Function，你会知道这就像在requirements.txt中写一个愿望清单一样简单。
为了增加额外的复杂性，一些 Python 包需要编译 C 或 C++ 扩展(包如 Numpy 和 Pandas)。如果你想用你的 macOS 或 Windows 机器来pip install -t . pandas然后为 Lambda 层压缩它们，这是一个亚马逊 Linux 环境，这可能有点麻烦。
有几种方法可以引入 Linux 兼容的依赖项，无论是通过无服务器还是使用 EC2 实例。现在，如果你以前读过我的一些博客，我真的很喜欢在黑客马拉松中使用 Lambdas，因为时间是关键，我想向你展示如何使用 Docker 将 Python 依赖作为 Lambda 层的最简单和最快的方式。
5 个简单的步骤:
1.建设
希望你已经设置了 Docker，但是如果你没有，那么一定要先设置。你要做的第一件事是使用一个 Amazon Linux 作为基本映像，并用几个实用程序、 python3.7 和 Virtualenv 创建一个 Dockerfile。
**FROM** **amazonlinux:2.0.20191016.0****RUN** yum install -y **python37** && \
yum install -y **python3-pip** && \
yum install -y **zip** && \
yum clean all**RUN** python3.7 -m pip install --upgrade pip && \
python3.7 -m pip install **virtualenv**
运行下面的命令来创建带有标签的 docker 文件。
usr> **docker build** -f **"<filename>.Dockerfile"** -t **lambdalayer:latest .**
2.奔跑
你应该可以通过做docker images看到图像。在那之后，你想要撞击你的容器。
usr> **docker run** -it --name lambdalayer **lambdalayer:latest** **bash**
3.安装
在您的容器中创建一个新的虚拟环境来隔离您的 python 环境，并重用同一个容器，而不用担心全局安装破坏东西。您可以为每个依赖项创建一个容器，但是时间是关键…
bash> **python3.7** -m venv **pandas**
我把它命名为熊猫，你可以叫它任何你想要的名字，但是一定要激活它，把你的包安装到一个特定的文件夹中，然后再去激活它。
bash> **source pandas/bin/activate** (pandas) bash> pip install **pandas** -t **./python** (pandas) bash> deactivate
4.包裹
这些包及其依赖项应该已经安装在 python 文件夹(或您的特定文件夹)中。现在您可以将该文件夹压缩为python.zip并退出容器。您需要将压缩文件夹复制到本地环境中，以便将其上传到 Lambda 图层或 S3。
bash> **zip** -r **python.zip** ./python/usr> **docker cp** lambdalayer:python.zip ./Desktop/
5.上传
如果你的压缩文件大于 50mb，那么你需要把它上传到 S3，而不是直接上传到 Lambda 层。一定要记录下 S3 对象的网址。
就这样，现在你有 Pandas(和 Numpy)作为你的 Python Lambda 的一部分作为一个层使用，如果你想创建一个部署包，那么一定要把你的 Lambda 函数代码作为一个.py文件添加到压缩文件夹中。
λ层的限制
您需要了解一些限制，包括:
- 每个 Lambda 最多只能使用 5 层。
- 解压缩后的所有图层的大小不能超过 250mb。
- 层安装在函数执行环境中的/opt 目录中，因此如果您要有多个函数，请确保正确地对函数进行分层。
部署 Lambda
请随意查看我的文章关于如何使用无服务器或 AWS SAM 将 Lambda(和 Pandas)部署到 AWS。
关于我
我喜欢写媒体文章，并为知识共享社区做贡献。除了尝试新的食物配方，我还帮助企业构建云和数据解决方案。请随时与我联系并向我问好！
——李帝努·雅玛
如何安装 R 和 RStudio？
Photo by Cris DiNoto
R 和 RStudio 是什么？
稀有
统计程序 R 只不过是一种编程语言，主要用于数据操作和执行统计分析。在撰写本文时，这种语言是统计学中的主要程序之一，尽管不是统计学家使用的唯一编程语言。
为了使用 R，我们需要两样东西:
- 用于编写代码的文本编辑器
- 运行这段代码的地方
RStudio
这就是 RStudio 派上用场的地方。
RStudio 是 R. R 和 RStudio 协同工作的集成开发环境(IDE)。R 是一个运行你所有代码的程序，RStudio 是另一个可以让你以更舒适友好的方式控制 R 的程序。RStudio 的优势在于，它既提供了一个用于编写代码的强大文本编辑器，又提供了一个运行在该编辑器中编写的代码的地方。
出于这些原因，我强烈推荐使用 RStudio 而不是 R。我每天都使用 RStudio(而不是 R ),你会看到这个博客上所有的文章都是用 RStudio 写的。
请注意，RStudio 需要预先安装 CRAN 提供的 R 软件才能正常工作。仅仅在个人电脑上安装 RStudio 是不够的。请参阅下一节，了解如何安装两者。
如何安装 R 和 RStudio？
你可以在 https://cran.r-project.org/mirrors.html下载 R。选择离你的国家最近的 CRAN mirror 网站。如果您所在的国家有多个链接，只需选择一个:
Select the CRAN mirror site closest to your country
然后在标有“下载并安装 R”的框中(位于顶部)，单击与您的操作系统(Windows、Mac 或 Linux)对应的链接:
Click on the link corresponding to your operating system
现在 R 已经安装在您的计算机上，您可以下载 RStudio 了。可以下载免费版的 RStudio(对绝大多数用户来说完全够用，包括我！)在他们的网站上。
RStudio 的主要组件
现在，这两个程序都已经安装在您的计算机上，让我们深入了解 RStudio 的主要组件。
默认情况下，RStudio 窗口有三个窗格:
- 控制台(红色窗格)
- 环境(绿色窗格)
- 文件、图、帮助等。(蓝色窗格)
RStudio window
控制台(红色窗格)是您可以执行代码的地方(稍后会有关于红色和蓝色窗格的更多信息)。默认情况下，文本编辑器不会自动打开。要打开它，点击文件>新建文件> R Script，或者点击左上角标有绿色小叉的按钮，然后点击 R Script:
New R script in RStudio
一个新的窗格(下面的橙色部分)，也称为文本编辑器，将会打开，您可以在其中编写代码。代码将被执行，结果显示在控制台(红色窗格)中。
Write and execute your code in RStudio
请注意，您也可以在控制台(红色窗格)中编写代码。但是，我强烈建议在文本编辑器(橙色窗格)中编写代码，因为您可以保存在文本编辑器中编写的代码(并在以后再次执行)，而不能保存在控制台中编写的代码。
要执行在文本编辑器(橙色窗格)中编写的代码，您有两种选择:
- 键入您的代码，然后按“运行”按钮(见下文)或使用键盘快捷键 CTRL+Enter(Mac 上为 cmd + Enter)。只有光标所在的代码块会被执行。
- 键入代码，在文本编辑器中选择要执行的部分，然后按“运行”按钮或使用键盘快捷键 CTRL+Enter(Mac 上为 cmd + Enter)。所有选择的代码将被执行
Run code in RStudio
例如，尝试在文本编辑器中键入1+1，点击“运行”(或 CTRL/cmd + Enter)来执行。您应该会在控制台中看到结果2，如下图所示:
Example of code executed in RStudio
文本编辑器和控制台是您最常用的窗格。然而，在使用 RStudio 时，其他两个窗格(前面介绍的蓝色和绿色窗格)仍然非常有用。
环境(绿色窗格)显示 RStudio 存储的所有值。例如，如果您键入并执行代码a = 1，RStudio 将为a存储值1，如下图所示:
Environment pane in RStudio
这意味着您现在可以使用a执行任何计算，因此如果您执行a + 1，RStudio 将在控制台中呈现2。在该窗格中，您还可以看到一个标签，其中包含所执行代码的历史记录和一个用于导入数据集的按钮(更多信息请参见在 RStudio 中导入数据集)。
最后一个窗格(蓝色)是你可以找到所有其他东西的地方，比如你的文件、图表、软件包、帮助文档等等。我在这里更详细地讨论了文件选项卡，所以让我们讨论一下其他选项卡:
- 绘图:您将看到渲染的绘图。例如，运行
plot(1:10)，您应该会在这个选项卡中看到它。如果您绘制了多个图，您可以通过单击箭头在它们之间导航。您可以通过单击缩放在新窗口中打开绘图，并通过单击导出导出您的绘图。这些按钮位于绘图选项卡的正下方(见下图) - 软件包:在这里你可以看到所有已安装的软件包。r 只提供基本的功能，其他的都必须从包中安装。提醒一下 R 是开源的；每个人都可以编写代码并作为一个包发布。然后，您就可以免费使用这个包(以及这个包中内置的所有功能)。一些包是默认安装的，所有其他的包必须通过运行
install.packages("name of the package")来安装(不要忘记在包的名字后面加上""！).软件包安装后，您必须加载软件包，只有在它被加载后，您才能使用它包含的所有功能。要加载一个包，运行library(name of the package)(这一次包名两边的""是可选的，但是如果你愿意，仍然可以使用)。您还可以通过 packages 选项卡下的按钮来安装和加载软件包。为此，单击“软件包”下的“安装”按钮，键入要安装的软件包的名称，然后单击“安装”。您将看到代码出现在控制台中。要加载软件包，请在“软件包”窗口中找到您要加载的软件包(您可以使用搜索框)，然后单击软件包名称旁边的复选框。同样，代码在控制台中运行。如果需要，请参见下图。请注意，您只需安装一次软件包、 1 ，但每次打开 RStudio 时都会加载软件包。此外，请注意，安装软件包需要互联网连接，而加载软件包则不需要 - 帮助:为 r 编写的所有函数的文档。要访问函数的帮助，运行
help("name of the function")或简单的?name of the function。例如，要查看关于均值函数的帮助，运行?mean。将光标放在某个函数上时，也可以按 F1
Plot buttons in RStudio
Step 1: click on the Install button
Step 2: type the name of the package and click on Install
Step 3: load your package by clicking on the box next to the package’s name
代码示例
现在您已经安装了 R 和 RStudio，并且知道了它的主要组件，下面是一些基本代码的例子。更多高级代码和分析在其他关于 R 的文章中介绍。
计算器
计算 5÷5
5 * 5## [1] 25
计算
1 / sqrt(50 * pi) * exp(-(10 - 11)^2 / 50)## [1] 0.07820854
如您所见，有些值(如π)是默认存储的，因此您不需要指定它的值。请注意，RStudio 区分大小写，但不区分空间。这意味着pi与Pi不同，但5*5给出的结果与5 * 5相同。
评论
要在代码中添加注释，请在代码前使用#:
# A comment
# Another comment
1 + 1## [1] 2
存储和打印数值
注意，为了在对象内部存储一个值，使用=或<-是等效的。然而，我建议使用<-来遵循 R 编程的准则。您可以随意命名您的对象(在我们的例子中是 A 和 B)。但是，建议使用简短的名称(因为您很可能会多次键入这些名称),并避免使用特殊字符。
A <- 5
B <- 6
存储值时，RStudio 不会将其显示在控制台上。要在控制台中存储并打印一个值，请使用:
(A <- 5)## [1] 5
或者:
A <- 5
A## [1] 5
向量
也可以通过函数c() (c 代表合并)在一个对象中存储多个值。
A <- c(1 / 2, -1, 0)
A## [1] 0.5 -1.0 0.0
矩阵
或者通过matrix()创建一个矩阵:
my_mat <- matrix(c(-1, 2, 0, 3), ncol = 2, nrow = 2)
my_mat## [,1] [,2]
## [1,] -1 0
## [2,] 2 3
您可以通过?matrix或help("matrix")访问该功能的帮助。请注意，在一个函数中，可以有多个由逗号分隔的参数。在matrix()内部，第一个参数是向量c(-1, 2, 0, 3)，第二个是ncol = 2，第三个是nrow = 2。对于 RStudio 中的所有函数，您可以通过函数内的顺序或参数名称来指定参数。如果您指定参数的名称，顺序不再重要，因此matrix(c(-1, 2, 0, 3), ncol = 2, nrow = 2)相当于matrix(c(-1, 2, 0, 3), nrow = 2, ncol = 2):
my_mat2 <- matrix(c(-1, 2, 0, 3), nrow = 2, ncol = 2)
my_mat2## [,1] [,2]
## [1,] -1 0
## [2,] 2 3my_mat == my_mat2 # is my_mat equal to my_mat2?## [,1] [,2]
## [1,] TRUE TRUE
## [2,] TRUE TRUE
生成随机值
基于均值μ=400、标准差σ=10 的正态分布生成 10 个值:
my_vec <- rnorm(10, mean = 400, sd = 10)
# Display only the first 5 values:
head(my_vec, 5)## [1] 397.5906 394.1163 395.8203 395.1248 397.3691# Display only the last 5 values:
tail(my_vec, 5)## [1] 411.7824 402.6334 399.0726 399.9974 398.0901
你会有不同于地雷的价值，因为它们是随机产生的。如果你想确保总是有相同的随机值，使用set.seed()(括号内有任何数字)。例如，对于下面的代码，无论何时何地运行，都应该有完全相同的值:
set.seed(42)
rnorm(3, mean = 10, sd = 2)## [1] 12.741917 8.870604 10.726257
情节
plot(my_vec,
type = "l", # "l" stands for line
main = "Plot title",
ylab = "Y-axis label",
xlab = "X-axis label"
)
这只是对 RStudio 可能性的非常有限的介绍。如果你想了解更多，我建议你阅读与 R 相关的其他文章，从如何导入 Excel 文件或如何操作数据集开始。
感谢阅读。我希望这篇文章能帮助你安装 R 和 RStudio。
和往常一样，如果您有与本文主题相关的问题或建议，请将其添加为评论，以便其他读者可以从讨论中受益。
相关文章:
- 安装和加载 R 包的有效方法
- 我的数据服从正态分布吗？关于最广泛使用的分布以及如何检验 R 中的正态性的注释
- R 中的 Fisher 精确检验:小样本的独立性检验
- R 中独立性的卡方检验
- 如何在简历中创建时间线
原载于 2019 年 12 月 17 日https://statsandr.com。
如何在 UBUNTU 18.04 上安装 TensorFlow GPU
在教授计算机和机器人如何看待世界、理解世界，并最终在物理和虚拟领域执行复杂任务的热潮中，人工智能领域的进展速度是最激烈的争论之一。这个行业发展的速度和目的通常不仅仅是通过实际的产品进步和研究里程碑来衡量，还通过人工智能领导者、未来学家、学者、经济学家和政策制定者的预测和表达的担忧来衡量。人工智能将改变世界——但如何以及何时改变仍然是个悬而未决的问题。
大多数已经在装有 Nvidia GPU 的台式机/笔记本电脑上训练机器学习模型的用户由于安装 TENSORFLOW 的 GPU 版本的困难而与 CPU 妥协。在对安装过程进行了一些研究后，我正在编写我在装有 nvidia 930MX 的笔记本电脑上尝试过的程序。
为什么是 TensorFlow？ TensorFlow 是机器学习的端到端开源平台。它有一个全面、灵活的工具、库和社区资源的生态系统，让研究人员推动 ML 的最新发展，让开发人员轻松构建和部署 ML 驱动的应用程序。
让我们从安装过程开始
步骤 1: Nvidia 驱动程序
第一步是检查你是否安装了 nvidia 驱动程序。
您可以通过在终端中键入以下命令来检查。
英伟达-smi
如果你的系统已经检测到 nvidia 驱动，那么你会看到一些类似的输出。
nvidia output for my gpu drivers.
如果你还没有安装显卡驱动，我建议你从官方网站安装驱动，然后输入上面的命令重新检查。
可选的，如果你不能找到你的 gpu 的图形驱动程序，那么你可以尝试下面的过程。
转到软件和更新->附加驱动程序->在那里您可以找到您的驱动程序。选择驱动程序—使用 NVIDIA 驱动程序元包，然后单击应用更改。
Ubuntu 18.04 Additional Drivers settings
正如你可以检查有一个驱动程序安装的系统默认选项，但你可以看到我已经手动安装了我的图形驱动程序。我强烈建议手动安装 gpu 驱动程序。
如果你正试图安装来自。运行文件，然后你可能会面临与“新内核驱动程序”的冲突，不要强迫安装在这种情况下。先把司机加入黑名单。这是强制性的，因为它会阻止内核使用你的 gpu 资源。
将下面的命令加入黑名单。
回显选项 nouveau modeset = 0 | sudo tee-a/etc/modprobe . d/nouveau-kms . conf
之后，运行
sudo update-initramfs-u
要更新 initframs
，请再次尝试安装驱动程序。
步骤 2:安装 NVIDIA CUDA
CUDA 是 NVIDIA 开发的并行计算平台和编程模型，用于图形处理单元(GPU)上的一般计算。有了 CUDA，开发人员就可以利用 GPU 的强大功能，大幅提高计算应用的速度。
在 GPU 加速的应用中，工作负载的顺序部分在 CPU 上运行(针对单线程性能进行了优化)，而应用的计算密集型部分在数千个 GPU 内核上并行运行。当使用 CUDA 时，开发人员使用 C、C++、Fortran、Python 和 MATLAB 等流行语言编程，并通过几个基本关键字形式的扩展来表达并行性。
访问 nvidia 官方网站为您的操作系统下载 cuda。
选择适当的操作系统版本、发行版、版本，并选择安装程序类型为 deb(本地)
你需要下载 cuda deb 文件(1.6GB)并按照上面提到的步骤安装。
第三步:安装深度神经网络库(cuDNN)
NVIDIA CUDA 深度神经网络库(cuDNN)是一个针对深度神经网络的 GPU 加速原语库。cuDNN 为标准例程提供了高度优化的实现，例如前向和后向卷积、池化、规范化和激活层。
全球深度学习研究人员和框架开发人员依赖 cuDNN 进行高性能 GPU 加速。这使得他们可以专注于训练神经网络和开发软件应用程序，而不是花时间在低级别的 GPU 性能调优上。cuDNN 加速了广泛使用的深度学习框架，包括 Caffe 、 Caffe2 、 Chainer 、 Keras 、 MATLAB 、 MxNet 、 TensorFlow 、 PyTorch 。要访问 NVIDIA 优化的深度学习框架容器，该框架已将 cuDNN 集成到框架中，请访问 NVIDIA GPU CLOUD 了解更多信息并开始使用。
转到https://developer.nvidia.com/cudnn并下载(需要登录和协议)。
登录并接受协议后。
根据上一步安装的 CUDA 版本选择合适的 cuDNN 开发者库(deb 文件)。
I have used cuDNN Developer Library for Ubuntu18.04 (Deb)
运行以下步骤来安装 cuDNN 库。
sudo dpkg-I</PATH/to/cud nn _ file . deb> 如果安装时出现 cupti 依赖项错误，则使用下面的命令安装 cupti 依赖项:
sudo apt-get install libcupti-dev
echo ' export LD _ LIBRARY _ PATH =/usr/local/cuda/extras/CUPTI/lib64:＄LD _ LIBRARY _ PATH '>>~/。bashrc
第四步:最后安装有 GPU 支持的 TENSORFLOW
pip install --upgrade tensorflow-gpu
步骤 5:检查安装
验证 TensorFlow 安装:请执行以下 Python 代码来验证您的 TensorFlow 安装:
python -c "from tensorflow.python.client import device_lib; print(device_lib.list_local_devices())
执行上述命令后，您将收到类似于我的输出的输出，如下所述。
2019-04-17 23:10:19.343549: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
2019-04-17 23:10:19.377027: I tensorflow/core/platform/profile_utils/cpu_utils.cc:94] CPU Frequency: 2400000000 Hz
2019-04-17 23:10:19.377323: I tensorflow/compiler/xla/service/service.cc:150] XLA service 0x56231cab6c90 executing computations on platform Host. Devices:
2019-04-17 23:10:19.377360: I tensorflow/compiler/xla/service/service.cc:158] StreamExecutor device (0): <undefined>, <undefined>
2019-04-17 23:10:19.427725: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2019-04-17 23:10:19.428532: I tensorflow/compiler/xla/service/service.cc:150] XLA service 0x56231cbb9310 executing computations on platform CUDA. Devices:
2019-04-17 23:10:19.428551: I tensorflow/compiler/xla/service/service.cc:158] StreamExecutor device (0): GeForce 930MX, Compute Capability 5.0
2019-04-17 23:10:19.428797: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1433] Found device 0 with properties:
name: GeForce 930MX major: 5 minor: 0 memoryClockRate(GHz): 1.0195
pciBusID: 0000:01:00.0
totalMemory: 1.96GiB freeMemory: 1.50GiB
2019-04-17 23:10:19.428833: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1512] Adding visible gpu devices: 0
2019-04-17 23:10:19.429703: I tensorflow/core/common_runtime/gpu/gpu_device.cc:984] Device interconnect StreamExecutor with strength 1 edge matrix:
2019-04-17 23:10:19.429717: I tensorflow/core/common_runtime/gpu/gpu_device.cc:990] 0
2019-04-17 23:10:19.429744: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1003] 0: N
2019-04-17 23:10:19.429924: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1115] Created TensorFlow device (/device:GPU:0 with 1307 MB memory) -> physical GPU (device: 0, name: GeForce 930MX, pci bus id: 0000:01:00.0, compute capability: 5.0)
[name: "/device:CPU:0"
device_type: "CPU"
memory_limit: 268435456
locality {
}
incarnation: 7335559256733264271
, name: "/device:XLA_CPU:0"
device_type: "XLA_CPU"
memory_limit: 17179869184
locality {
}
incarnation: 5312720144392370303
physical_device_desc: "device: XLA_CPU device"
, name: "/device:XLA_GPU:0"
device_type: "XLA_GPU"
memory_limit: 17179869184
locality {
}
incarnation: 4529346810094966789
physical_device_desc: "device: XLA_GPU device"
, name: "/device:GPU:0"
device_type: "GPU"
memory_limit: 1370750976
locality {
bus_id: 1
links {
}
}
incarnation: 2845160405845590596
physical_device_desc: "device: 0, name: GeForce 930MX, pci bus id: 0000:01:00.0, compute capability: 5.0"
]
结论
我真的希望这篇指南能帮助你在装有 nvidia 显卡的机器上安装 TensorFlow GPU。如果您在安装过程中发现任何困难，请告诉我。
谢谢；)
如何在 Python Pandas 中内插时间序列数据
Time Series Interpolation for Pandas: Eating Bamboo Now — Eating Bamboo Later (Photo by Jonathan Meyer on Unsplash)
注:熊猫 0.20.1 版(2017 年 5 月)更改了分组 API。这篇文章反映了更新版本的功能。
任何处理数据的人都知道现实世界中的数据通常是不完整的，清理数据会占用你大量的时间(有人知道 80/20 法则吗？).最近从 Pandas 搬到 Pyspark，我已经习惯了 Pandas 提供的便利，而 Pyspark 由于它的分布式特性有时会缺乏这些便利。我特别欣赏的一个特性是 Pandas 提供的内插(或填充)时间序列数据的直接方式。这篇文章旨在使用在一组房屋中收集的传感器读取数据的示例，以简单易懂的方式展示这种能力。这篇文章的完整笔记本可以在我的 GitHub 中找到。
准备数据和初步可视化
首先，我们用一些测试数据生成一个熊猫数据帧 df0。我们创建了一个包含两个房屋的模拟数据集，并使用 sin 和 cos 函数为一组日期生成一些传感器读取数据。为了生成缺失值，我们随机丢弃一半的条目。
data = {'datetime' : pd.date_range(start='1/15/2018',
end='02/14/2018',
freq='D')\
.append(pd.date_range(start='1/15/2018',
end='02/14/2018',
freq='D')),
'house' : ['house1' for i in range(31)]
+ ['house2' for i in range(31)],
'readvalue' : [0.5 + 0.5*np.sin(2*np.pi/30*i)
for i in range(31)]\
+ [0.5 + 0.5*np.cos(2*np.pi/30*i)
for i in range(31)]}df0 = pd.DataFrame(data, columns = ['readdatetime',
'house',
'readvalue'])# Randomly drop half the reads
random.seed(42)
df0 = df0.drop(random.sample(range(df0.shape[0]),
k=int(df0.shape[0]/2)))
生成的表格如下所示:
Raw read data with missing values
下图显示了生成的数据:一个 sin 和一个 cos 函数，两者都有大量缺失的数据点。
我们现在来看三种不同的内插缺失读取值的方法:前向填充、后向填充和内插。请记住，为每项任务选择合适的插值方法至关重要。特别是对于预测任务，我们需要考虑在进行预测时是否有插值数据。例如，如果你需要插值数据来预测天气，那么你不能用明天的天气来插值今天的天气，因为明天的天气还是未知的(合乎逻辑，不是吗？).
插入文字
为了对数据进行插值，我们可以使用 groupby()- 函数，然后是 resample() 。但是，首先我们需要将读取的日期转换为 datetime 格式，并将它们设置为数据帧的索引:
df = df0.copy()
df['datetime'] = pd.to_datetime(df['datetime'])
df.index = df['datetime']
del df['datetime']
因为我们想分别对每栋房子进行插值，所以在使用带有选项“D”的 resample() 函数将数据重新采样到每日频率之前，我们需要按“房子”对数据进行分组。
下一步是使用均值填充、前向填充或后向填充来确定新生成的网格应该如何填充。
平均值()
因为我们使用 mean() 方法进行严格的上采样，所以所有缺失的读取值都用 nan 填充:
df.groupby('house').resample('D').mean().head(4)
Filling using mean()
pad() —向前填充
使用 pad() 代替 mean() 向前填充 NaNs。
df_pad = df.groupby('house')\
.resample('D')\
.pad()\
.drop('house', axis=1)
df_pad.head(4)
Filling using pad()
bfill() —反向填充
使用 bfill() 代替 mean() 后向填充 NaNs:
df_bfill = df.groupby('house')\
.resample('D')\
.bfill()\
.drop('house', axis=1)df_bfill.head(4)
Filling using bfill()
插值()-插值
如果我们想要对缺失值进行插值，我们需要分两步来完成。首先，我们通过使用 mean()生成底层数据网格。这会生成以 NaNs 为值的网格。然后，我们通过调用 read value 列上的 interpolate() 方法，用插值填充 nan:
df_interpol = df.groupby('house')\
.resample('D')\
.mean()
df_interpol['readvalue'] = df_interpol['readvalue'].interpolate()
df_interpol.head(4)
Filling using interpolate()
可视化结果
最后，我们可以可视化三种不同的填充方法，以更好地了解它们的结果。不透明点显示原始数据，透明点显示插值。
我们可以看到，在上面的图中，间隙是如何用先前已知的值填充的，在中间的图中，间隙是如何用即将到来的现有值填充的，在下面的图中，差异是线性插值的。由于插值过程的线性，请注意插值线中的边缘。根据任务的不同，我们可以使用高阶方法来避免这些问题，但是对于这篇文章来说这样做太过分了。
Original data (dark) and interpolated data (light), interpolated using (top) forward filling, (middle) backward filling and (bottom) interpolation.
摘要
在这篇文章中，我们看到了如何使用 Python 的 Pandas 模块，通过回填、前向填充或插值方法来插值时间序列数据。
原载于 2019 年 1 月 14 日https://walken ho . github . io。
如何使用 scikit-learn 评估二元逻辑回归
为这个 python 函数添加书签，它使评估您的二进制分类器变得容易。
功能概述
逻辑回归因其可解释性而成为一个有价值的分类器。这个代码片段提供了一个剪切和粘贴功能，当逻辑回归用于二元分类问题时，该功能显示了重要的指标。这里的一切都是由 scikit-learn 提供的，但是如果没有这个助手函数，手动调用和可视化会非常耗时和重复。
【evalBinaryClassifier()将拟合的模型、测试特征和测试标签作为输入。它返回 F1 分数，并打印密集输出，包括:
- 标有数量和文本标签的完整混淆矩阵(例如“真阳性”)
- 两类预测概率的分布
- ROC 曲线，AUC，以及沿着混淆矩阵和分布所代表的曲线的决策点
- 精确度、召回率和 F1 分数
有关如何解释这些输出的说明，请跳到代码块后面的。
必需的进口:
例句用法:
输出:
代码
解释:
左图:混淆矩阵
混淆矩阵将模型做出的预测描述为正确或错误。它将这些与真实的真相进行比较。一个完美的模型只有真正的正面和真正的负面。一个完全随机的模型将有相似数量的所有 4 个类别。
如果你有一个阶级不平衡的问题，通常你会看到很多负面的(真的和假的)和很少正面的，反之亦然。(关于这方面的一个很好的例子，请看我关于预测颠覆的项目。)
中心图:预测的分布
中间的图表是正面结果的预测概率分布。例如，如果您的模型 100%确定样本为阳性，则它将位于最右侧的箱中。两种不同的颜色表示真实的类，而不是预测的类。一个完美的模型将显示绿色和红色分布之间没有任何重叠。一个完全随机的模型将会看到它们彼此完全重叠。
决策边界决定模型的最终预测。在 scikit-learn 中，默认的决策边界是. 5；也就是说，高于 0.5 的预测为 1(正)，低于 0.5 的预测为 0(负)。这是理解你的模型和 ROC 曲线的一个重要细节。
右图:ROC 曲线
接收机工作特性曲线描述了所有可能的 决策界限。绿色曲线表示可能性，以及不同决策点的真阳性率和假阳性率之间的权衡。这两个极端很容易理解:您的模型可以对所有样本延迟预测 1，并获得完美的真阳性率，但它也会有 1 的假阳性率。类似地，你可以通过懒惰地预测所有事情都是负面的来将你的假阳性率降低到零，但是你的真阳性率也将是零。你的模型的价值在于它增加真阳性率比增加假阳性率更快的能力。
一个完美的模型应该是 y 轴上的一条垂直线(100%真阳性，0%假阳性)。一个完全随机的模型将位于蓝色虚线上(找到更多的真阳性意味着找到相同数量的假阳性)。
Left: a perfect model; Right: a purely random model
蓝点代表当前确定混淆矩阵的 0.5 决策边界。
当一种错误类型比另一种更糟糕时，更改这一点是调整模型敏感度的有效方法。举个例子，医疗保健充满了这样的决定:错误地诊断癌症要比错误地诊断健康好得多。在这种情况下，我们需要一个非常低的决策边界，也就是说，只有在我们非常确定的情况下，才预测一个阴性结果(没有癌症)。
如果使用相同的模型选择不同的边界(例如:0.3 而不是 0.5)，蓝点将沿着绿色曲线向右上方移动。新的边界意味着我们将捕获更多的真阳性，也将捕获更多的假阳性。这也很容易想象为中间图表中的蓝线向左移动，直到它位于 0.3:边界右侧会有更多的“绿色”箱，但也会有更多的“红色”箱。
scikit-learn 没有调整决策边界的内置方法，但这可以通过对您的数据调用 predict_proba() 方法来轻松完成，然后根据您选择的边界手动编码一个决策。
这对你理解你的模型有帮助吗？还能改进吗？请告诉我，我很乐意收到你的来信！
如何在咨询公司面试
咨询公司寻找一种特殊的数据科学家。以下是你如何为他们的面试做准备。
经过一番催促，我们最终决定公开专业数据科学家和他们的学员之间关于 SharpestMinds 内部松弛的一些对话。我们希望这将让更多的人从 SharpestMinds 的专业知识中受益，即使他们不能直接进入社区。
一个公司需要解决的问题决定了他们问应聘者的面试问题。所以，如果你准备去一家公司面试，你会想确保你留出一些时间对这些问题进行研究，这样你就可以对这些问题做出有根据的猜测。
幸运的是，有很多公司都会遇到类似的问题，能够识别这些公司可以大大提高你为面试做好充分准备的机会。其中一类是咨询公司，这是上个月在sharpes mindsSlack 上通过一位匿名学员提出的话题，我们称她为狄奥多里克:
第一个答案是对预期结果的高度概括:
另一件要记住的重要事情是:应用研究和项目的重要性，正如夏普明德的校友(现在是 IQVIA 的数据科学家🚀) Karthik Viswanathan 指出:
狄奥多里克补充了更多的背景知识(注意，他是通过询问面试他的公司获得这些信息的——这总是一个好的步骤！):
SharpestMinds 的导师 Ryan Kingery 也顺道来访，对咨询公司提出了警告。虽然我个人没有他那么强烈的感觉，但我肯定从很多其他人那里听到过这种情绪，所以如果你正在考虑咨询角色，这是值得考虑的事情:
Alum(现在是数据科学家) Khain Win 也有一些关于咨询作为以用户为中心的活动的好建议…
…以及一些如何说面试官语言的好建议:
就这样结束了！
想要更多吗？
我们每隔几周发布一份时事通讯，其中包含关于如何在数据科学领域找到工作的对话和提示。你可以在 https://sharpestminds.substack.com/查看一个例子
可以在推特上关注 Jeremie()@ Jeremie charris)或者 sharpes minds(@ sharpes mindsai)。
原载于 2019 年 12 月 11 日https://blog.sharpestminds.com。
如何投资 Airbnb 房产
利用数据做出明智的决策
A irbnb 与 2019 年 8 月相比增长了 21%，总收入4，308，726，681 美元。更令人印象深刻的是，它已经发展到1.5 亿用户，目前在 191 个国家有 6，370，563 个房源。到目前为止，这对 Airbnb 来说非常成功。
在东南亚，马来西亚连续第二年成为 Airbnb 增长最快的国家。仅在 2018 年一年，马来西亚共有 53，000 家上市公司带来了约亿RM3 的直接经济影响。得知 Airbnb 在马来西亚的业务增长迅速，我一直有一个疑问。
在马来西亚首都吉隆坡，开办 Airbnb 业务的最佳地区是哪里？
在思考上述问题之前，我的脑海里马上会蹦出另一个问题。我在想什么？我还没有房子，为什么我会考虑这个问题？然而，我仍然决定谷歌是否有其他方法，这里是我发现的。
有两种方法可以让你开始经营 Airbnb。一种是出租自己的一处房产，另一种方式是出租别人的房产来开展 Airbnb 业务。换句话说，我不需要拥有一个物业开始！
如果你要我选择开始的方式，我会先选择第二个选项。因为它更灵活，与购买房产相比，我可以在相对较短的时间内租赁房产。另一个原因是，我可以体验一下在 Airbnb 做主持人的感觉，然后再为了开办 Airbnb 业务而购买房产。
在本文中，我将讨论如何设法获取数据以供以后分析。事不宜迟，我们开始吧！
数据收集之旅
在我开始爬 Airbnb 网站之前，我偶然发现了这个网站，它似乎改变了我做其他话题的想法。总之，Airbnb 网站实际上并不热衷于分享他们拥有的数据。阿姆斯特丹政府试图刮网站周刊似乎已经放弃刮这个网站。
尽管知道我将面临很多问题，我仍然决定尝试抓取网站。现在，我将分享一些我在浏览网站时遇到的问题。
我面临的第一个问题是动态改变 Xpath 或 CSS 路径。这意味着你不能只使用 Xpath 的一个例子，并且假设在所有列表的网页上使用这个 Xpath 会给你你想要的相同的信息。
此外，爬行器的稳定性也是另一个问题。如果你在清理 Airbnb，以下是我建议的一些方法。我发现的最有效的方法是将旋转 IP 和减慢爬虫速度结合起来。
在花了几个小时检查网络选项卡之后，我发现了一条路径，在这条路径上，您将能够访问包含更整洁数据的 JSON 。所以，我的第一个问题已经解决了！为了增加我的爬虫的稳定性，我旋转 IPs 并且减慢我的爬虫。最后，我能够以稳定得多的速度抓取数据。
数据清理之旅
收集完数据之后，我们来做一些数据清理。
首先，我获得了至少有一个评论的列表的最高价格。让我们称这个价格为价格 A。此外，我删除了所有高于价格 A 的列表——异常列表。换句话说，异常列表是价格高得离谱，但没有人发表评论的列表。
基于局部邻域，删除了重复的列表，只留下大约 5590 个列表。此外，前 10 大房源区域的房产估计价格来自 edgeprop 、 brickz 和 propsocial 。
数据探索
显示吉隆坡价格分布的一个好方法是绘制一个 choropleth 图。这张地图由吉隆坡的 11 个联邦选区分割而成。根据图，你可以看到马来西亚东北部的平均价格最高，而吉隆坡中部的价格相当有竞争力。
如果你是来吉隆坡度假的经济型旅行者，我猜你现在知道该住在哪个地方了！
现在，让我们来鸟瞰一下整个吉隆坡的房源分布。可以看到，Airbnb 的房源大部分都是积累在吉隆坡的市中心区域。这就是为什么城市地区的房源价格较低，因为供应量要高得多。
请随意浏览交互式图表，深入了解吉隆坡的特定区域。
数据分析
上图显示了前 20 个最贵的社区。三角形代表物品的数量，而横条代表物品的平均价格。
从这张图中你能得到什么启示？
Taman Bukit Maluri、Taman Golden 和 Segambut 的价格相对较高，上市量较低。原因之一可能是该地区没有足够的供应，因此价格较高。如果你正在考虑开办 Airbnb 业务，你可以在这个领域做一些研究，看看这个地方是否有需求，租房或买房的成本是否可以承受。
现在，是时候知道答案了。
吉隆坡最适合投资的地区是哪里？
让我们只考虑拥有最多房源的前 10 个街区。在我开始解释计算之前，让我解释一下我将要使用的一些术语。
如何计算住房市场的投资回报率(ROI)？
ROI (%) = (monthly rental * 12) / property value
因此，在我们的 Airbnb 案例中，我使用occupancy rate * fee per night * 30来计算月租金。此外，根据 AirDNA 的报告，2018-2019 年吉隆坡的平均入住率为 66%。假设每月平均有 30 天。
因此，最终的公式看起来像这样。
ROI (%) = (fee per night * 0.66 * 30 * 12)/ property value
我寻找的另一个变量是需求。然而，如果我需要获得实际的预订数量，我需要构建一个更大规模的网络爬虫。因此，对于我的例子，我使用评论数量作为需求的代理。
最佳投资区域是甘榜巴鲁和周杰，它们位于右上方的象限。换句话说，这些街区有很高的投资回报率(%)和需求。这张图是给一个想投资房地产来开办 Airbnb 业务的投资者看的。
另一方面，对于一个买不起房子，但打算开办 Airbnb 业务的人来说，他或她需要考虑一个略有不同的衡量标准。他/她应该关注airbnb expected monthly income/ monthly rental fee，而不是关注 ROI (%)，T3 相当于(fee per night * 0.66 * 30)/monthly rental fee。在这里，我将其定义为收入成本比。
如果你不想拥有自己的房子来开始 Airbnb 业务，周杰和甘榜巴鲁将是你可以考虑的地方。
我收集的所有估计的租房费用和房价都是来自一些免费网站。因此，如果你想要一个更准确的数字，你需要订阅一个付费服务，例如， brickz 。此外，上述所有数据都忽略了季节性影响，因为我只收集了 2019 年 11 月 29 日至 2019 年 12 月 2 日的数据。
最后的想法
非常感谢你一直读到最后。真的很感谢！
我想说的是，这个迷你项目真的消耗了我相当多的时间，所以如果你喜欢或喜欢这种内容，请在下面的评论中告诉我。
此外，收集 Airbnb 数据也非常耗时。不过，为了感谢大家今年的支持，我想免费送出去！
我收集的数据集包含了吉隆坡总共 71 个街区。如果您有兴趣获得数据集，以便您能够使用它，请随时查看此链接！
这篇文章被刊登在《亚洲科技》上，欢迎点击这里查看！
下期帖子再见！
参考
- https://www . alltherooms . com/analytics/Airbnb-IPO-going-public-incomes-business-model-statistics/
- https://www . the star . com . my/business/business-news/2019/07/02/Airbnb-generates-rm3bil-in-direct-economic-impact-in-Malaysia-last-year
关于作者
Low 魏宏是 Shopee 的数据科学家。他的经验更多地涉及抓取网站，创建数据管道，以及实施机器学习模型来解决业务问题。
他提供爬行服务，可以为你提供你需要的准确和干净的数据。你可以访问这个网站查看他的作品集，也可以联系他获取抓取服务。
在媒体上阅读低纬鸿的作品。数据科学家|网络抓取服务:https://www.thedataknight.com/.每…
medium.com](https://medium.com/@lowweihong)
如何在找数据科学工作时保持你的技能
这是我写的系列文章的第二篇，内容是关于我公司内部的对话。你可以在这里看第一部。
如果你现在加入我们，我们运行一个私有的 Slack 组，一半是有经验的数据科学家，一半是有抱负的数据科学家。有抱负的那一半往往会提出很棒的问题，有经验的那一半往往会给出很棒的答案。
我们今天要讨论的问题是:当你积极找工作时，你应该如何分配你在找工作本身——申请、面试、建立关系网——和保持你的专业技能之间的时间？
这个问题经常出现。两者兼顾非常难！幸运的是，在今天的对话中，你会发现有很好的策略可以让这变得更容易。
Jiri Stodulka 问道:
我已经花了大约两个月的时间在找工作上——结果，在这段时间里我没有做很多编码工作。
昨天我在做一些 EDA，我震惊地发现我不得不谷歌一切来完成它——我已经忘记了很多语法。
你如何处理这个问题？假设你在积极地找工作，你现在编码多少？
杰瑞米·哈里斯的回答:
我通常建议把你的一周分成两天的技能维护和五天的应用和项目，当他们积极寻找的时候。但因人而异。
一种常见的划分方式是周末做项目工作，工作日做工作申请和面试。
是的，解决方案是明确地安排编码时间。每个人的正确时间表会有所不同。
如果工作日/周末分开对你不起作用，一个很好的方法是每天做最小量的编码——比如 15 分钟——并安排在特定的时间。这是一种个人习惯触发器，叫做 实现意图 。
Karthik Subramanian 的回答:
事实上，在我被雇佣之前，我在这个州呆了很长时间。我忙于应付全职课程、个人项目和找工作。
除了半定期的练习，很有帮助的是文档。你练习的任何东西，你都需要记录。**
光练习编码是不够的。你应该很好地记录你的工作，这样当你回头看的时候，你可以马上说，“是的，我有一个关于如何做这件事的想法。”例如，我记得在 LeetCode 上做了大量的问题——当我想为即将到来的面试修改它时，很多工作都浪费了，因为我没有费心记录我的解决方案。
记录资料也给你一个简单的方法来查找资料，而不需要依赖谷歌搜索，因为你已经做了艰苦的跑腿工作。我喜欢添加一两个帮助我快速找到解决方案的最佳链接，这样下次会更快。**
引来了乐和 :
我以为只有我一个人受这种苦！我总是牢记“遗忘曲线”——所以我花在编码上的时间比申请工作的时间还多:
除了这些很棒的回答，下面是我自己的策略:为自己建立一个奖励系统。**
在你必须完成的所有任务中——工作申请、编码项目等等。—其中一些任务给你能量，一些消耗你的能量。你可以把给予能量的任务作为完成消耗能量任务的奖励。这就像在吃甜点之前先吃蔬菜一样:小而持续的奖励可以创造并保持良好的习惯。**
例如，比起发送求职申请，你可能更喜欢编写软件和分析数据。
然后，你可以给自己设定一个求职申请的最低目标(例如每天一个)和一天中处理求职申请的具体时间段(例如下午 6-6:30)。在你发送了当天的工作申请后，你就可以继续你的编码项目了。**
我可能会在未来发布更多这样的对话——如果有你特别感兴趣的话题，在 Twitter 上 ping 我！
如何免费在手机上标记数据
厌倦了电子表格？在您的手机上更轻松地添加标签
Label data on your phone!
我们将通过使用 Airtable 在您的手机上随时随地标记数据的步骤。自从我开始在手机上做标记，我的标记速度至少提高了 3 倍，而且更加愉快了。注:以上为个人观点，与 Airtable 无关。
在博客的最后，这是它如何标记图像的:
Labeling images with Airtable
第一步:创建账户
在这里创建您的账户。
第二步:下载他们的手机应用程序
点击下载 Airtable 的手机应用。
步骤 3:上传数据集
- 收集您未标记的示例，并将其保存为带标题的 CSV 格式。
- 打开电脑应用程序，点击“添加底座”。
- 选择“导入电子表格”并上传您的 CSV 文件。
Adding a base
- 如果你想给图片加标签，这里有一个批量上传图片的步骤。
步骤 4:选择列类型
既然您已经上传了 CSV，我们需要自定义字段类型。对于文本栏，我们将使用“长文本”，对于图像，我们使用“附件”。
Customizing column types.
步骤 5:添加标签复选框
现在我们已经上传了数据集，我们将设置用于标注的列。根据我的经验，最简单的标记方法是为每个类创建一个复选框字段列。下面是我们如何设置复选框字段:
Adding a checkbox for “Positive” class.
第六步:开始贴标签！
第 7 步:将标签数据导出为 CSV 格式
Download CSV
希望你试试 Airtable out！如果你有任何问题，请让我知道。
额外的糖果
与团队合作:
- 邀请其他贴标机到你的飞行台基地。
- 创建一个名为“Labeler”的列，类型为“Collaborator ”,并分配谁来标记哪些例子。
- 为每个标签创建一个视图，并在每个视图中创建一个过滤器，以便每个标签只能看到它们被分配到的示例。这里就不多赘述了。
标记时记笔记:
有时在标记示例时做笔记很有用，为此我们添加了一个名为“笔记”的“长文本”栏。
Taking notes as you label
使用 Zapier 进一步自动化流程:
你想在贴标机工作时得到通知吗？或者，当你不确定一个例子的标签时，你想自动松弛你的一个队友吗？那么扎皮尔就是你的答案。我也不会详细介绍，但是如果你感兴趣，请在下面评论，我会写另一篇关于如何将 Zapier 与 Airtable 集成的博客。
如何标记文本以进行情感分析——良好实践
你是否曾经开始一个情感分析或其他文本分类任务，却发现你没有得到好的结果？要研究的可能问题的列表很长，但是有两个方面你可能会按这个顺序忽略。
第一个方面是训练数据集标签的质量，第二个方面是模型本身。我们倾向于花很多时间调整模型，因为——嗯，我们学会了这样做。当你开始你的第一个项目时，你通常会得到一个已经整理好的数据集。在预处理方面没有什么或很少要做。
当我说预处理时，忘记删除重音符号——标记化——删除停用词 bla，bla，关注所有事情的第一步:数据的质量。
使用来自互联网知识库的数据来研究机器学习(ML)是很棒的，但这也是有代价的:大量的…
medium.com](https://medium.com/@wilamelima/dealing-with-data-preprocessing-problems-b9c971b6fb40) [## 为什么删除停用词并不总是一个好主意
删除停用词是一个困难的选择。您不应该每次都删除它们。但是这一步什么时候才是真正的…
medium.com](https://medium.com/@wilamelima/why-is-removing-stop-words-not-always-a-good-idea-c8d35bd77214)
即使对人类来说，贴标签也很难
你有没有试过给东西贴标签，却发现自己做得很差？如果你还没有，这是一个发现这项任务有多难的好机会。我敢肯定，如果你从一个情感分析问题开始你的机器学习之旅，你多半会下载一个数据集，其中有许多关于酒店/电影/歌曲的预先标记的评论。我的问题是:你有没有停下来读一些呢？
如果你这样做了，你会发现有些标签并不完全是你一开始给的。你可能不同意一些评论是积极的还是消极的。这是因为负/正标签是非常主观的。
如果你不能分辨什么是积极的，什么是消极的，你的电脑肯定会和你一样糟糕。这就是为什么我会坚持认为:给数据贴标签是一门艺术，应该由对你试图从人类的角度解决的问题有着深刻了解的人来完成。但是你可以训练自己变得更好。
定义清晰的规则
给文本加标签的一个好方法是定义什么应该接受什么标签的明确规则。一旦你列出了规则，就要保持一致。如果你将亵渎归类为负面，不要将数据集的另一半标记为正面，如果它们包含亵渎。
但是这并不总是有效的。根据问题的不同，即使是讽刺也可能是一个问题和消极的标志。因此，标注文本的第二条经验法则是首先标注最简单的例子。显而易见的正面/反面例子应该尽快标记出来，最难的应该留到最后，当你对问题有更好的理解时。
另一种可能性是预先标记最简单的例子，并用它们建立第一个模型。然后，您可以将剩余的示例提交给该模型，并检查该模型对最难的示例的“意见”。
测试随机性
如果你做了以上所有的事情，你仍然不确定你的分类或者你的模型的质量，你可以试着测试随机性。执行以下操作:获取用于创建模型的示例，并为其分配随机标签。你可以用阿鲁纳来做。
当您随机标记您的示例时，您可以检查这些标签对预测的重要性。换句话说，你检查文本是否有好的标签。如果您不确定标签的正确性(假设您认为示例首先收到了错误的标签)，您可以分配随机标签并观察模型的表现。
还有一种可能是模型本身坏了。为了测试模型是否总是给出相同的预测，不管它接收的是什么样的例子，我们可以给模型输入随机的文本。在这种情况下，除了只更改标签，您还可以创建没有任何意义的文本块，并查看模型的执行情况。
做实验
我用上面的两个理论来测试我正在工作的一个模型。我不确定是我的模型坏了，还是我正在处理的例子没有贴好标签。
下面是我如何进行体验的:使用相同的例子，我用相同的配置训练了一个模型三次(但是总会存在一点随机性)。第一次运行时，我用随机标签测试了模型。第二次运行时，我使用了文本 blobs，第三次运行时，我使用了正确的示例。很重要的一点是，我研究的是一个平衡的数据集。
我把数据加载到一个熊猫数据集中，有两列:“文本”和“情绪”。情感栏保存文本分类。
首轮放映
from aruana import Aruana aruana = Aruana('pt-br') sentiment = [aruana.random_classification](https://aruana.nheeng.com/docs/aruana-class#random_classification)(data['text'], classes=[0,1], balanced=True) data['sentiment'] = sentiment
结果是:
正如你所看到的，一般的准确率是 50%，这意味着这个模型并不比随机猜测好多少。
二轮放映
from aruana import Aruana aruana = Aruana('pt-br') texts = [aruana.replace_with_blob](https://aruana.nheeng.com/docs/aruana-class#replace_with_blob)(data['text']) data['text'] = texts
结果是:
将文本更改为随机斑点也会降低模型的性能。
第三轮
第三次运行时，我用好的文本/标签填充模型，结果如下:
看看它是如何改进的！因此，文本和标签在这里并不重要。
结论
如果你正在处理情感分析问题，小心文本标签。如果你一生中从未给文本加过标签，这是一个很好的练习。如果你仅仅依靠干净/处理过的文本来学习，你可能会面临一个问题，这个问题不是你的模型，而是你用来训练它的信息。
如何获得机器学习领域的实习机会
作为一名本科生，获得机器学习的实习机会是很艰难的。真的很难……大部分知名公司都在找在知名期刊发表论文的博士生。如果不能满足以上几点，如何增加获得 ML 实习的机会？
Photo by Hunters Race on Unsplash
去年，我已经花了几个小时发送申请，申请机器学习/人工智能实习。作为一名电子工程专业的学生，我发现甚至连面试都特别困难，尽管我在机器学习方面有一些相关经验。在我寻找实习机会的过程中，我注意到了一些公司都在寻找的共同点。基于这些事实，我决定改变发送简历的策略，这最终导致我获得了一份机器学习研究实习生的工作。如果你正计划申请机器学习实习，或者你正在努力获得一份实习，我希望这篇文章能帮助你找到你梦想的工作！
我还写了另一篇帮助你准备面试的文章。 链接就在这里。
大公司=激烈的竞争
Photo by Paweł Czerwiński on Unsplash
我犯的第一个错误是申请知名的大公司。谷歌(Google)、亚马逊(Amazon)或苹果(Apple)等公司每天都会收到数百份申请，甚至很难通过实习的第一个招聘阶段。如果你觉得你在机器学习方面有很好的技能，在这个领域有丰富的经验，那就去做吧。否则，最好把目标放在规模较小、知名度较低的公司，以最大化你被聘用的机会。例如，看看亚马逊机器学习实习生所需的基本资格:
Internship requirements for Machine Learning Internship at Amazon, found on Linkedin
哇哦。你看，这就是我所说的严格要求的意思。最好，你应该是一个在机器学习方面有几个出版物的哲学博士。如果你是本科，和我一样，在这里明显处于劣势。
看看你周围有没有涉及机器学习的公司。给他们发邮件，或者在 LinkedIn 上联系他们，询问他们是否提供 ML 的实习机会。他们有可能会这样做，这让你处于一个非常有利的位置，因为不会有那么多申请人，工作要求也不会那么高。
你可以做的另一件事是询问你大学里专注于 ML 研究的教授。他们可能会在研究项目中寻求帮助，或者认识业内的相关人士。这也是我去年在网络物理系统研究小组实习的原因。
证明你是好的
Photo by Lee Campbell on Unsplash
在 ML 中投入大量时间在你的自我教育上。您可能知道，这是一个非常广泛的主题，需要对统计学、算法和编程有很好的理解。你需要证明你对 ML 的各个方面都有很好的理解，并且你也是一名优秀的程序员。
个人项目是一条路要走！为 Kaggle 写一个内核，在 Github 上发布你的代码或者贡献给开源项目。招聘人员希望有证据证明你作为实习生会给公司带来积极的贡献。
通过参加 Kaggle 比赛，在其他机器学习爱好者中测试自己。起初它们可能很难，但这是一个加深你对算法理解的绝佳机会，它也推动你学习新的 ML 概念。
在你的大学创建一个人工智能社团或学习小组。这就是我去年所做的，它对我的自我发展的贡献令人惊讶。出于对社会的责任感，我必须为每周的研讨会制作大量各种各样的材料，并提高我的领导技能。它也能让你在你的大学里处于一个 ML 专家的位置！如果你玩得好，你还可以通过邀请当地公司做演讲或为学生准备研讨会来参与其中。
提高你在行业中的地位
Photo by Miguel Henriques on Unsplash
在线状态确实有助于与其他人建立联系，并获得认可。你可以成为机器学习的专家，但谁会在乎没人听说过你呢？定期在 ML 媒体上发表文章以吸引眼球，或者创建自己的博客。
也可以加入 AI 会议或活动。走出你的舒适区，和尽可能多的人交谈。这是结识来自不同公司的专业人士的最佳场所，也是与能帮你获得 ML 实习机会的人建立良好联系的潜在场所。
希望这篇文章对你获得 ML 实习有所帮助。你有什么其他的想法吗？你能做些什么来增加你得到那份工作的机会？请在评论中告诉我！
如何在 Kaggle 上安装 LB 探针
在 Kaggle 的 LANL 地震预测竞赛中，我们的团队使用 LB 探测策略，与 4500 个参赛团队一起获得了公共排行榜第一名。这是描述该策略的概述。
我们从简短介绍比赛环境开始。然后，我们继续我们对测试数据的发现，最后描述我们采用的主要方法——混合整数规划，通过分数逐渐提高来迭代可行的解决方案。
Top of the public leader-board
比赛训练数据由 6.29 亿次连续测量组成，这些测量跨越了 163 秒的实验室实验，包括 16 个地震周期。列车数据中的地震间隔时间从 7 秒到 16 秒不等。基于该训练信号，要求竞争者在 2624 个测试段上预测下一次故障的剩余时间，每个测试段包含 150k 连续测量值或大约 0.038 秒的测试数据。目标是最小化预测的平均绝对误差。
大约在比赛结束前一个月，论坛上有报道称数据可能来自一个特定的实验室实验，而一篇描述该实验的学术文章中有一张与比赛列车组完全匹配的列车组图片。
train vs test data from the article
该图片还包含可疑的测试集，并且可以安全地假设，测试数据段是从列车集之后的 108 秒长的连续间隔中截取的。
组织者进一步将测试数据细分为公共和私有数据集，已知公共数据包含 13%的数据。然而，没有公开在公共部分中确切有多少段，也没有公开哪一个是私有的，哪一个是公共的。
每个团队每天有两次提交，参与者被要求对所有 2624 个测试段做出预测。系统使用公共集 MAE 分数进行回答，该分数仅在公共部分子集上进行内部计算，每个团队的最佳分数显示在公共排行榜上。
一份全部 10 分的提交给我的分数是 5.982，全部 20 分是 15.982，这意味着在公共领导板上没有高于 10 的值。
然后，我们通过将所有值设置为 10，但另外将 60 个随机段值更改为 10000，进行了另一次提交。分数是 293.051，由此很容易得出结论，公共集合中唯一可能的整数段数是 348，并且我们碰巧在所选的 60 个段中找到了 10 个公共段。
接下来，我们为以下值列表的所有预测提交了相同的值:[0，2，3，3.25，3.5，3.75，4，4.25，4.5，5，9，9.72，10]。基于得到的分数，并假设片段的密度对于每个区间是恒定的，可以计算每个区间上片段的密度。事实上，这个问题甚至是过度约束的，需要一些优化技术或启发式方法来解决它。
注意，上次地震设定的列车被截断，停在 9.76。因此，测试集最早从 9.72 开始(减去一个片段持续时间 0.038)。这就是上面列表中值 9.72 的来源，只是猜测这个值可能是相关的。
fig. 1: density of public segments targets
不赘述，我们将问题公式化为二次规划凸优化问题，用 cvxopt 包求解。这导致图像上描绘的片段密度(见图 1)。
fig. 2: density of public segments targets only with scores 0, 4.5, 9.72 and 10
所获得的结果是有噪声的，因为对于每个区间段的密度恒定的假设并不精确，毕竟我们只有大约 348 个离散值，它既不是均匀的也不是连续的。但人们仍然可以清楚地看到，我们有两种制度。通过在模型中只保留 4.5 和 9.72 的值，我们得到了更清晰的结果，见图 2。计算出的密度为 0.141、0.070 和 0.001。如果您有兴趣自己进行计算并验证该结果，分数如下:
4.017 for all 0
2.379 for all 4.5
5.702 for all 9.72
5.982 for all 10
上面的计算决定性地向我们证明，公共集由两个连续的区间组成:9.72 到零，这显然是上次火车地震的延续，另一个区间从 4.5 到零。我敢打赌，这最后的 4.5 秒是取自最后一次测试数据地震，使私人测试数据连续。
通过了解文章中的总测试持续时间，我们还估计在连续的测试段之间平均有 7500 个样本的差距。考虑到这一差距，可以计算出 0 到 9.72 和 0 到 4.5 这两个区间正好符合 348 个区间，进一步证实了结论。
接下来，我们提交了 88 份材料，以发现哪些部分是公开的，哪些是私人的(是的，花了 44 天！).
the expected reaction
在每个这样的提交中，我们将所有值设置为 10，除了 30 个段，我们为其选择值
val[i] = 10 + 0.348*2^i
以二进制表示的结果提交分数减去 5.982(全部 10 个的分数)给出了这 30 个分段的公共/私有掩码。
现在，当我们知道公共段索引时，发现公共段值的一种方法是提交所有值 10，并且一次将一个公共段更改为零。这个过程需要 348 个提交来覆盖整个集合，这是不可行的。
我们采用的方法是基于混合整数规划(MIP)的，这种神奇的方法让我们能够以更快的速度提高我们的公共 LB 分数。问题公式是我们需要将 348 个段匹配到 348 个值，其中这些值从 0 到 9.72 和从 0 到 4.5 等间距分布，如上所述。我们所做的每一次提交都是对这个公式的约束。下面给出了完整的 MIP 问题公式，我们使用了 pulp python 包和 cplex 作为求解器(学术许可)。代码中的语法是纸浆的语法。
# decision variables
# matrix of indicators if a segment selects a value
pp=LpVariable.dicts("mix",(range(D),range(D)),0,1,LpInteger)
# absolute value of errors for submission-segment pairs
tt=LpVariable.dicts("err",(range(S),range(D)),0,20,cat='Continuous')
# margins for submission scores
dd=LpVariable.dicts("div",(range(S)),0,100,cat='Continuous')# D is number of segments = 348
# S is number of submissions available
# den is a probability density of a segment to have a value
# sub is predictions for public segments in each submission
# times is a list of all 348 public segments values
# sc is the submissions scores# objective
prob += lpSum(lpSum(pp[d][i] * den[d,i] for i in range(D)) for d in range(D)) + 1000*lpSum(dd[s] for s in range(S))
# constraints
for d in range(D):
# one selected for each segment
prob += lpSum(pp[d][i] for i in range(D)) == 1
for i in range(D):
# one selected for each value
prob += lpSum(pp[d][i] for d in range(D)) == 1
for s in range(S):
for d in range(D):
# error of each submission-segment
prob += tt[s][d] == lpSum(pp[d][i] * abs(sub[s,d] - times[i]) for i in range(D))
for s in range(S):
# sum of errors is +-0.0005 rounding error plus margin
prob += lpSum(tt[s][d] for d in range(D))<=D*(sc[s]+0.0005+dd[s])
prob += lpSum(tt[s][d] for d in range(D))>=D*(sc[s]-0.0005-dd[s])
我们最小化的目标函数由两部分组成。首先，我们希望找到可行的解决方案，因此我们希望将利润率设为零(决策变量 dd)。其次，在所有可行的解决方案中，我们希望选择可能性最大的一个。为此，我们使用了一个单独的 LGBM 分类模型的输出，该模型定期在训练集上进行训练。
MIP 迭代的过程如下。对于给定的一组可用提交，我们运行模型，获得可行的最大似然解，这是我们提交给 Kaggle 的结果。可行解决方案的集合仍然很大，我们通常每次都将分数提高 0.000–0.080。然后，我们将新的提交添加到集合中，并使用新的约束重复这个过程。
注意这个 MIP 问题还是挺大的，最后达到 245k 变量和 124k 约束。我们每次迭代都要运行几个小时的模型，即使这样也达不到精确可行的解决方案。所有提交的平均利润率在最后是 0.003(实际上非常好)。
最后，我们有 353 份以分数为约束条件的提交，其中包括所有我们自己的相关提交+ 261 份我们从公共内核下载的提交。
作为总结，我们开发了一个 MIP 模型公式，它在 348 个公共段和我们知道的构成公共测试集的值之间寻找可行的匹配。在每一次迭代中，模型都会生成一个满足所有约束条件的可行解决方案，即带有我们已有分数的提交。从某种意义上说，这是一个可行的解决方案，如果提交了这个解决方案，模型认为 0 分是可能的。在实际提交生成的值后，我们得到了一个真实的分数，而不是 0，并再次运行模型，这样它就可以根据新的信息进行自我修正。
该模型的特性是它生成满足所有提交的匹配。也就是说，如果您计算生成的解决方案和任何提交公共条目之间的 MAE 度量，您将获得实际的提交分数(如上所述，平均误差为 0.003)。
令人着迷的是，我们添加了如此多的公共内核提交，以至于我们完全覆盖了那个特定的子空间。当我们观察到我们的模型解决方案预测了 95%的分数，最大误差为 0.02，而没有专门学习它们时，我们停止了获取更多的公共内核提交！另一方面，该模型生成的提交物的预测值为零，与所有其他提交物正交，并提供了大量新信息。
在最后一个比赛日期间，MIP 解决方案生成的在“常规”提交的子空间上预测分数非常好，以至于我们使用它来估计所有最终提交候选人的公共 LB 分数(参与者被要求选择两个提交作为最终提交)。
不幸的是，我们在比赛中很晚才准备好运行 MIP 模型，只有时间提交 17 份这样的提交材料。他们的分数如下所示。
1.641 MIP 1th
1.511 MIP 2th
1.681 MIP 3th - Me giving only 20% to make any significant progress
1.304 MIP 4th - Better score than our best model
1.409 MIP 5th
1.326 MIP 6th
1.357 MIP 7th
1.306 MIP 8th
1.412 MIP 9th
1.231 MIP 10th - First place reached
1.226 MIP 11th
1.225 MIP 12th
1.145 MIP 13th
1.110 MIP 14th
1.101 MIP 15th
1.080 MIP 16th
1.104 MIP 17th
衷心感谢我的 Kaggle 队友 Ido Greenberg 在这个过程中给予的帮助和支持，即使我估计它只有 20%的机会产生任何有价值的东西。这是一个冒险的策略，但实际上奏效了。
thanks for reading!
如何免费学习数据科学
Photo by Josh Appel on Unsplash
一个完整的学习路径，包括不花你一分钱的资源
在传统的实体院校获得硕士学位的平均费用会让你花费在 3 万到 12 万美元之间。即使是在线数据科学学位课程也不便宜，最低费用为9000 美元。那么如果你想学数据科学但是又付不起这个费用怎么办？
我接受了数据科学家的职业培训，但没有接受过这方面的任何正规教育。在本文中，如果你不能或不想支付数千美元进行更正式的学习，我将与你分享我自己学习数据科学的个人课程。
该课程将包括 3 个主要部分，技术技能，理论和实践经验。我将包括学习路径的每个元素的免费资源的链接，也将包括一些额外的“低成本”选项的链接。因此，如果你想花一点钱来加快你的学习，你可以将这些资源添加到课程中。我将包括每个项目的估计成本。
技术
课程的第一部分将侧重于技能。我建议先学习这些，这样你就可以先采取实用的方法，而不是说先学习数学理论。到目前为止，Python 是用于数据科学的最广泛使用的编程语言。在 2018 年进行的 Kaggle 机器学习和数据科学调查中，83%的受访者表示他们每天都在使用 Python。因此，我建议把重点放在这种语言上，但也花一点时间在其他语言上，比如 r。
Python 基础
在开始将 Python 用于数据科学之前，您需要基本掌握这门语言背后的基础知识。所以你会想参加 Python 入门课程。有很多免费的，但我最喜欢 Codeacademy 的，因为它们包含了在浏览器中动手编码。
我建议参加入门课程学习 Python 。这包括基本语法、功能、控制流、循环、模块和类。
使用 python 进行数据分析
接下来，您将希望很好地理解使用 Python 进行数据分析。这方面有许多好的参考资料。
首先，我建议至少参加 dataquest.io 上的免费数据分析师学习课程。Dataquest 为数据分析师、数据科学家和数据工程师提供完整的学习路径。相当多的内容，尤其是关于数据分析师路径的内容是免费的。如果你确实有一些钱用于学习，那么我强烈建议你把它用于支付几个月的高级订阅费。我参加了这门课程，它为数据科学的基础知识打下了良好的基础。我花了 6 个月的时间完成了数据科学家之路。价格从每月 24.50 美元到 49 美元不等，取决于你是否按年付费。如果你负担得起的话，购买年度订阅更划算。
用于机器学习的 Python
如果你选择在 Dataquest 上付费学习完整的数据科学课程，那么你将会很好地掌握 Python 机器学习的基础知识。如果没有，那么有大量的其他免费资源。我将重点从 scikit-learn 开始，这是迄今为止最常用的用于机器学习的 Python 库。
在我学习的时候，我有幸参加了由 scikit-learn 的核心开发者之一 Andreas Mueller 举办的为期两天的研讨会。然而，他已经在这个 Github repo 上发表了本课程的所有材料和其他材料。这些包括幻灯片、课程笔记和笔记本，您可以浏览。我肯定会推荐你阅读这些材料。
然后我会建议参加 scikit-learn 文档中的一些教程。在那之后，我会建议构建一些实用的机器学习应用程序，并学习模型如何工作背后的理论——我稍后会谈到这一点。
SQL
如果你想成为一名数据科学家，SQL 是一项至关重要的技能，因为数据建模的基本过程之一是首先提取数据。这通常会涉及到对数据库运行 SQL 查询。同样，如果你没有选择参加完整的 Dataquest 课程，那么这里有一些免费的资源来学习这项技能。
Codeacamdemy 有免费介绍 SQL 课程。同样，这对于浏览器内编码非常实用。如果你也想了解基于云的数据库查询，那么 Google Cloud BigQuery 是非常方便的。有一个免费层，所以你可以免费尝试查询，大量的公共数据集可以尝试，非常好的文档。
稀有
要想成为一名全面的数据科学家，从 Python 开始尝试多样化是一个好主意。因此，我建议在 R. Codeacademy 上一门入门课，介绍他们的免费计划。这里可能值得注意的是，与 Dataquest Codeacademy 类似，它也提供完整的数据科学学习计划作为其 pro 帐户的一部分(每月费用从 31.99 美元到 15.99 美元不等，取决于您预先支付的月数)。我个人认为 Dataquest 课程更全面，但如果你想在单一平台上学习，这可能会便宜一点。
软件工程
掌握软件工程技能和最佳实践是一个好主意。这将有助于您的代码对自己和他人来说更具可读性和可扩展性。此外，当您开始将模型投入生产时，您将需要能够编写高质量且经过充分测试的代码，并使用版本控制等工具。
这里有两个很棒的免费资源。 Python 如你所愿涵盖了 PEP8 风格指南、文档等内容，也很好地涵盖了面向对象编程。
scikit-learn 贡献指南，虽然是为了方便对库的贡献而写的，但实际上很好地涵盖了最佳实践。这涵盖了 Github、单元测试和调试等主题，并且都是在数据科学应用程序的上下文中编写的。
深度学习
对于深度学习的全面介绍，我不认为你能得到比完全免费和完全无广告的 fast.ai 更好的了。本课程包括机器学习介绍、实用深度学习、计算线性代数和自然语言处理的代码优先介绍。他们所有的课程都有实用的第一方法，我强烈推荐他们。
理论
当你在学习课程的技术元素时，你会遇到你正在实现的代码背后的一些理论。我建议你在学习实践的同时学习理论知识。我这样做的方式是，我学习代码，以便能够实现一种技术，让我们以 KMeans 为例，一旦我有了工作，我就会更深入地研究惯性等概念。同样，scikit-learn 文档包含算法背后的所有数学概念。
在这一部分，我将介绍你应该学习的理论的关键基础元素以及更实用的元素。
可汗学院几乎涵盖了我下面免费列出的所有概念。当你注册时，你可以定制你想学习的科目，然后你就有了一个很好的定制课程来学习这一部分。勾选下面所有的框会让你对我下面列出的大部分元素有一个大致的了解。
数学
演算
微积分被维基百科定义为“对连续变化的数学研究。”换句话说，微积分可以找到函数之间的模式，例如，在导数的情况下，它可以帮助你理解函数如何随时间变化。
许多机器学习算法利用微积分来优化模型的性能。如果你学过一点机器学习，你可能会听说过梯度下降。这通过迭代调整模型的参数值来找到最佳值，以最小化成本函数来实现。梯度下降是微积分如何用于机器学习的一个很好的例子。
您需要了解的内容:
衍生
- 几何定义
- 计算函数的导数
- 非线性函数
链式法则
- 复合函数
- 复合函数导数
- 多重功能
渐变
- 偏导数
- 方向导数
- 积分
线性代数
许多流行的机器学习方法，包括 XGBOOST，都使用矩阵来存储输入和处理数据。矩阵与向量空间和线性方程一起形成了被称为线性代数的数学分支。为了理解有多少机器学习方法起作用，很好地理解这个领域是至关重要的。
您需要学习的内容:
向量和空格
- 向量
- 线性组合
- 线性依赖和独立
- 向量点积和叉积
矩阵变换
- 函数和线性变换
- 矩阵乘法
- 反函数
- 矩阵的转置
统计数字
以下是您需要了解的一些关键概念:
- 如何总结数据样本
- 不同类型的分布
- 偏斜度、峰度、集中趋势(如均值、中值、众数)
- 相关性的度量，以及变量之间的关系，如相关性和协方差
实验设计
- 假设检验
- 抽样
- 显著性测试
- 随机性
- 可能性
- 置信区间和双样本推断
机器学习
- 关于斜率的推断
- 线性和非线性回归
- 分类
实践经验
课程的第三部分是实践。为了真正掌握上面的概念，你需要在一些项目中使用技巧，这些项目非常类似于真实世界的应用程序。通过这样做，你将会遇到一些需要解决的问题，比如缺失的和错误的数据，并且在这个主题上有更深层次的专业知识。在最后一部分，我将列出一些你可以免费获得这种实践经验的好地方。
“然而，经过深思熟虑的练习，你的目标不仅仅是发挥你的潜力，而是开发它，让以前不可能的事情成为可能。这需要挑战体内平衡——走出你的舒适区——并迫使你的大脑或身体适应。”，安德斯爱立信， 巅峰:来自新科学的秘密
Kaggle 等人
机器学习竞赛是练习构建机器学习模型的好地方。他们可以访问广泛的数据集，每个数据集都有一个特定的问题要解决，并且有一个排行榜。排行榜是一个很好的方式来衡量你在开发一个好模型方面的知识水平，以及你可能需要进一步提高的地方。
除了 Kaggle 之外，还有包括 Analytics Vidhya 和 DrivenData 在内的其他机器学习竞赛平台。
UCI 机器学习知识库
UCI 机器学习库是一个公共可用数据集的大型来源。您可以使用这些数据集来整合您自己的数据项目，这可能包括数据分析和机器学习模型，您甚至可以尝试构建一个具有 web 前端的部署模型。将你的项目存放在公开的地方是一个好主意，比如 Github，因为这可以创建一个展示你的技能的作品集，用于未来的工作申请。
对开源的贡献
另一个可以考虑的选择是为开源项目做贡献。有许多 Python 库依靠社区来维护，并且经常在聚会和会议上举行黑客马拉松，甚至初学者也可以参加。参加这些活动之一肯定会给你一些实践经验和一个环境，在那里你可以向别人学习，同时回报一些东西。 Numfocus 是这类项目的一个很好的例子。
在这篇文章中，我描述了一个学习路径和免费的在线课程和教程，可以让你免费学习数据科学。以作品集的形式展示你所能做的是未来工作申请的一个很好的工具，代替了正式的资格和证书。我真的相信教育应该对每个人开放，当然，至少对数据科学来说，互联网提供了这样的机会。除了这里列出的资源之外，我之前还在这里发布了一份学习数据科学的推荐书目。这些都可以在网上免费获得，是补充上面提到的更实用的资源的好方法。
感谢阅读！
我每月都会发一份简讯，如果你想加入，请点击此链接注册。期待成为您学习旅程的一部分！
如何学习数据科学-我的道路
我使用的工具和资源
上周，我在 TDS 上发表了我的第三篇文章。在下一个帖子之前，我想发布这个快速的帖子。希望这篇帖子对想进入数据科学或者刚开始学习数据科学的人有所帮助。在这篇文章中，我将分享我使用的资源和工具。这基本上是我日常活动中使用的所有应用程序和链接。以下所有我用过或将来会用到的。如果你想让我添加任何其他信息，请张贴在评论区，我会包括它。
我的数据科学课程
我制作的这张图表。这应该给出了在 DS 和 ML 中需要什么工具和技能的基本概念。
[## Roadmapedia -让我们分享知识
编辑描述
www.roadmapedia.com](https://www.roadmapedia.com/roadmap/5d595ab0b3e31200174ad787)
感谢陈楚翔提出了路线图。请检查上面的链接。
另一个我在网上找到的
编程语言:
我从 R 编程开始。然后我转向 python，几乎一直使用 python 和 Jupyter Notebook。所以对我来说，python 和 SQL 是必须的。
1。Python 或者 R
[## 从“R 与 Python”到“R 与 Python”
根据你的需要而不是受欢迎程度来选择编程语言。
towardsdatascience.com](/from-r-vs-python-to-r-and-python-aa25db33ce17)
2。SQL
Python:
使用的重要库:
- NumPy
- 熊猫
- Matplotlib
- SciPy
- Scikit-Learn
- 张量流
- Keras
- Seaborn
- NLTK
- Gensim
一些有用的资源开始
1.基本 python 技巧
如果页面笔记本无法在 GitHub 上加载，请在这里查看:注意，这些是用 Python 3 (3.6)编写的，这些文件…
github.com](https://github.com/gpetepg/python_tips)
2.一些例子
[## donne Martin/数据科学 ipython 笔记本
演示深度学习功能的 IPython 笔记本电脑。其他 TensorFlow 教程:IPython 笔记本电脑…
github.com](https://github.com/donnemartin/data-science-ipython-notebooks)
3.Youtube 频道
[## Python YouTube 频道的终极列表-真正的 Python
我们在网上找不到一个好的、最新的 Python 开发者或 Python 编程 YouTube 频道列表。学习…
realpython.com](https://realpython.com/python-youtube-channels/)
SQL
传统 SQL /trəˈdɪʃəˌnəl ˈɛs kjuː ˈɛl/众所周知的 SQL-92 子集。仅限于关系模型。经常…
modern-sql.com](https://modern-sql.com/) [## SQLBolt -学习 SQL-SQL 介绍
欢迎使用 SQLBolt，这是一系列交互式课程和练习，旨在帮助您在工作中快速学习 SQL
sqlbolt.com](https://sqlbolt.com/) [## SQLZOO
使用 SQL Server、Oracle、MySQL、DB2 和 PostgreSQL 学习 SQL。如何从数据库中读取数据？2 创建和…
sqlzoo.net](https://sqlzoo.net/) [## 数据分析的 SQL 教程
本教程是为想用数据回答问题的人设计的。对许多人来说，SQL 是“肉和土豆”…
mode.com](https://mode.com/sql-tutorial/introduction-to-sql/) 
2。数据可视化:
- 马特里布
- Seaborn
- 牛郎星
- 阴谋地
- 画面
- D3.js
- 散景
让别人理解你的观点的最好但也是更具挑战性的方法之一是将它们可视化:这样，你可以更多地…
www.datacamp.com](https://www.datacamp.com/community/tutorials/seaborn-python-tutorial) [## clair 513/Seaborn-教程
数据可视化是追求职业生涯所需要的一项关键但被削弱的技能。这个知识库是一个尝试…
github.com](https://github.com/clair513/Seaborn-Tutorial) [## 牛郎星-viz/牛郎星-教程
在 PyCon 2018 上发布的 Altair 教程的笔记本，请查看笔记本/Index.ipynb 上的内容介绍幻灯片…
github.com](https://github.com/altair-viz/altair-tutorial) [## rougier/matplotlib-教程
来源可从 github 获得，所有代码和材料都是在知识共享署名-共享的情况下获得许可的…
github.com](https://github.com/rougier/matplotlib-tutorial) [## d3/d3
用 SVG、Canvas 和 HTML 赋予数据生命。:bar _ chart::chart _ with _ upward _ trend:🎉-D3/D3
github.com](https://github.com/d3/d3/wiki/tutorials) [## 什么是 Tableau？-分析师指南和教程
在我的职业生涯中，我有机会使用许多工具。很少有产品像 Tableau 一样给我留下如此深刻的印象。在…
www.projectbi.net](https://www.projectbi.net/what-tableau-guide-tutorial-analysts/)
3。网页抓取:
- 美汤
- 刺儿头
- Urllib
- 硒
- 类似 Twitter API 的 API
4。流程
数据分析有 5 个核心活动:
1。陈述和提炼问题
2。探索数据
3。建立正式的统计模型
4。解读结果
5。传达结果
这本书描述了分析数据的过程。作者有丰富的经验，既管理数据分析师…
leanpub.com](https://leanpub.com/artofdatascience)
5。DS/ML 中的数学
资源:
[## 19 门面向数据科学和机器学习的数学和统计学 MOOCs
在创造之前，上帝只做纯数学。然后他认为这将是一个愉快的变化，做一些应用-约翰…
www.analyticsvidhya.com](https://www.analyticsvidhya.com/blog/2017/01/19-mooc-mathematics-statistics-datascience-machine-learning/) [## 15 门面向数据科学的数学 MOOCs
作者马修·梅奥。数据科学所需的大部分数学属于统计学和代数领域…
www.kdnuggets.com](https://www.kdnuggets.com/2015/09/15-math-mooc-data-science.html) [## 可汗学院
免费学习数学、艺术、计算机编程、经济学、物理学、化学、生物学、医学、金融…
www.khanacademy.org](https://www.khanacademy.org/math/linear-algebra) [## 数据科学基础数学和统计教程| Edureka
正如乔希·威尔斯曾经说过的，数据科学的数学和统计学是必不可少的，因为这些学科构成了基础…
www.edureka.co](https://www.edureka.co/blog/math-and-statistics-for-data-science/)
http://www.cis.upenn.edu/~jean/gbooks/linalg.html
6。机器学习:
资源:
7。大数据
来自 365 数据科学的不错的一个
4v 的
资源:
1.数据工程指南。
我经常被问到如何成为一名数据工程师。这就是为什么我决定以所有的话题开始这本食谱…
github.com](https://github.com/andkret/Cookbook)
2.学习数据工程
[## 教程和练习|数据工程|学习数据工程
编辑描述
www.learndata.engineering](https://www.learndata.engineering/tutorials-exercises)
8。我的 IDE
Jupyter 笔记本
皮查姆
r 工作室
智能理念
Jupyter 笔记本是什么？
towardsdatascience.com](/jypyter-notebook-shortcuts-bf0101a98330) 
以下应用程序非常有用，我也在使用
**** Quora***
*中等
*盲
**** Reddit***
*领英
**** Udemy***
**** Coursera***
**** Youtube***
**** Meetup***
*数据营
1.Reddit:
我已经订阅了以下的 Reddit，它非常有帮助
- 数据工程
- 数据美丽
- 数据集
- 学习数据科学
- 学习编程
- Learnpython
- 机器学习
- 学习机器学习
- Python
- Rstats
- 计算机视觉
- 学习编程
- 商业智能
- 编程
- 语言
- Scala
- AWS
- bigdata
- SQL
通过订阅上述子编辑创建个性化订阅源。在应用程序中，你可以按日、周、月、年、全天等热门程度对帖子进行排序。
2.盲人:
这是一个有用的社区。你可以了解到其他公司的 DS、ML 和软件工程正在发生什么。
3.商务 Udemy:
我认为大多数公司都与 Udemy 有业务往来，我通过我的雇主与 Udemy 有业务往来。这个非常好，超级有帮助。大约有 3000 道菜。比如我在尝试安装 spark，Hadoop，scala。网上没有太多的信息，很难把它安装到我的电脑上。我刚刚去了 Udemy，参加了一个教授 apache spark 的课程，几乎在不到一个小时的时间里就安装好了。这对我真的很有帮助。此外，价格非常合理，如 9.99 美元。有好的课程可供选择。
4.Linkedin 学习:
同样，我可以访问所有 LinkedIn 学习课程。它是由我的雇主提供的，也是当地县图书馆会员免费提供的。我在 Linkedin Learning 上发现了一些很棒的 python 和 R 课程。
此外，查看 Linkedin 群组
- 数据挖掘、统计、大数据、数据可视化和数据科学
- 人工智能、深度学习、机器学习
- 大数据、分析、商业智能&可视化专家社区
- kdnugges 机器学习、数据科学、数据挖掘、大数据、AI
- 云计算，SaaS &虚拟化
- 数据仓库—大数据— Hadoop —云—数据科学— ETL
- 人工智能、深度学习和物联网
- SQL Server 商业智能(BI)
- 物联网
- 银行和金融科技——金融科技银行系统金融高管
- 云计算
- Python 社区
- Python 数据科学与机器学习
5.中等:
这是学习和发表文章的最佳平台。
我关注的一些出版物有
- 走向数据科学
- 启动
- HackerNoon.com
- freeCodeCamp.org
我发表于
走向数据科学
TDS 是 DS 中增长最快的出版物。
- 218，052 名用户
- 每天增长 436.8 个关注者
6.Youtube:
显然，DS、ML 和 AI 都有很多可用的渠道。我跟着几个
- 数据学校
- 谷歌云平台
- 学 R
- 数据营
- Simplilearn
- 爱德华卡
- 海洋统计讲座
- send ex
- Siraj Rawal 频道
7.Udacity:
我没有在 Udacity 上任何付费课程。有一些免费的课程，你可以去看看。
8.其他有用的网站
- Kdnuggets.com
- Datacamp.com
- **【Khanacademy.org **
- geeksforgeeks.org
9.卡格尔:
我想每个人都知道 Kaggle，不需要介绍
此外，看看他们有帮助的迷你课程****
**[## 学习| Kaggle
编辑描述
www.kaggle.com](https://www.kaggle.com/learn/overview)**
10.Github:
显然，你可以建立你的投资组合。我有几个项目，如网络抓取，twitter 分析，使用 python 的数据可视化等。我计划今后增加更多。它也是一个搜索类似项目的好地方，你可以从 Github 发布的其他项目中获得很多帮助和想法。
11.会议:
我参加了一些圣何塞和旧金山当地的聚会。可惜我没有时间经常做。这对学习和人脉很有帮助。我在 Linkedin 大楼里见过一个 python 聚会，有几百名开发者参加。所以很明显，这是一个认识人和向人学习的黄金机会。甚至有一些聚会在工作日期间一次或隔天进行实践工作。整个周末都有一些研讨会。几乎所有的工作坊都是免费的，或者有些收取很少的费用。
12.Quora:
我订阅了以下订阅源
- 算法
- 竞争性编程
- 数据科学
- 机器学习
- 深度学习
- 大数据
- 数据分析
- 数据可视化
- Python
- Hakon Hapnes 链
- 麦克西
- 威廉·陈
- 姜黎黎
13.播客
- 数据怀疑论者(Spotify)
- 机器学习和人工智能周(Spotify )
- Superdatascience.com
- 【https://talkpython.fm/T42****
另外，请检查以下内容
Paysa.com&关卡.参考消息
**[## 你拿到市场工资了吗？
Paysa 是为企业员工提供薪酬补偿和职位匹配的个性化职业服务。
www.paysa.com](https://www.paysa.com/)** ** [## Levels.fyi -比较不同公司的职业水平
Levels.fyi 便于比较和对比不同公司的不同职业水平。找出您的新…
www.levels.fyi](https://www.levels.fyi/) 
14.Stackoverflow
我认为没有 StackOverflow 你就不能编码:-)
15。解题地点:
- 哈克兰克(http://hackerrank.com/)
- 厨师长(http://codechef.com/)
- 黑客地球(【http://hackerearth.com/】T2
- leet code(【http://leetcode.com/】T4)
- top coder(http://topcoder.com/)
- 卡格尔(http://kaggle.com/)
- 挑战者邮报(http://challengepost.com/
- code forces(http://codeforces.com/)
- 辉煌(http://brilliant.org/)
- SPOJ(http://www.spoj.com/)
- 欧拉项目(https://projecteuler.net/)
- 编码蝙蝠(http://codingbat.com/
- codewars(http://www.codewars.com/)
- codi ity(https://codility.com/)
- 柯丁加姆(https://www.codingame.com/)
- 科德比特(https://coderbyte.com/)
- 代码评估(https://www.codeeval.com/)
- UVA 在线评委(https://uva.onlinejudge.org/)
- 格斗大赛(https://codefights.com/)
- http://www.checkio.org/
- 塔兰特巴迪(http://talentbuddy.co/)
- python 挑战(http://pythonchallenge.com/)
- lint code(【http://www.lintcode.com/en/】T42)
- 罗莎琳德(http://rosalind.info/problems/locations/)
- CrowdANALYTIX(【https://www.crowdanalytix.com/】T2
- SQL-EX。茹(【http://sql-ex.ru/】)
- 卡特斯(http://www.kattis.com/)
- 代码卡塔(http://codekata.com/)
- CodeAbbey(http://codeabbey.com/)
- 战斗代码(http://fightcodegame.com/)
- 节拍码(http://www.beatmycode.com/)
- http://tunedit.org/
- http://mlcomp.org/
- HPC 大学(http://hpcuniversity.org/students/weeklyChallenge/
- https://practiceit.cs.washington.edu/
16。免费课程:
芬兰赫尔辛基大学推出了一门关于人工智能的课程，完全免费向全世界所有人开放。与卡耐基梅隆大学新的人工智能本科学位不同，赫尔辛基大学提供的课程对那些想了解更多的人来说更像是初学者课程。
2018 年春天，Reaktor 和赫尔辛基大学携手合作，旨在帮助人们获得力量…
www.elementsofai.com](https://www.elementsofai.com/)
机器学习
[## 免费在线课程:来自 edX | Class Central 的机器学习
第一周:最大似然估计，线性回归，最小二乘法第二周:岭回归，偏差-方差，贝叶斯…
www.classcentral.com](https://www.classcentral.com/course/edx-machine-learning-7231?utm_source=qz&utm_medium=web&utm_campaign=ivy_league_courses_2019)
人工智能
[## 免费在线课程:edX | Class Central 的人工智能(AI)
上过这门课吗？与其他学生分享你的经验。写评论什么做自动驾驶汽车，人脸识别…
www.classcentral.com](https://www.classcentral.com/course/edx-artificial-intelligence-ai-7230?utm_source=qz&utm_medium=web&utm_campaign=ivy_league_courses_2019)
面向数据科学和分析的机器学习
[## 免费在线课程:edX | Class Central 的数据科学和分析机器学习
从不错过一门课程。没有垃圾邮件。随时退订。班级中心是一个免费的搜索引擎和评论网站…
www.classcentral.com](https://www.classcentral.com/course/edx-machine-learning-for-data-science-and-analytics-4912?utm_source=qz&utm_medium=web&utm_campaign=ivy_league_courses_2019)
机器学习
[## 免费在线课程:来自 Udacity | Class Central 的机器学习
这门课在佐治亚理工学院作为 CS7641 提供，是在线硕士学位(OMS)的一部分。拿着这个…
www.classcentral.com](https://www.classcentral.com/course/udacity-machine-learning-1020?utm_source=qz&utm_medium=web&utm_campaign=ivy_league_courses_2019)
机器学习无监督学习
[## 免费在线课程:机器学习:来自 Udacity 的无监督学习
有没有想过网飞如何预测你会喜欢什么电影？或者亚马逊如何在你买之前知道你想买什么…
www.classcentral.com](https://www.classcentral.com/course/udacity-machine-learning-unsupervised-learning-1848?utm_source=qz&utm_medium=web&utm_campaign=ivy_league_courses_2019)
数据科学 21 门课程
[## 2019 年，你可以在线学习 400 门免费的常春藤大学课程
八所常春藤盟校是世界上最负盛名的大学之一。他们包括布朗大学，哈佛大学…
qz.com](https://qz.com/1514408/400-free-ivy-league-university-courses-you-can-take-online-in-2019/)
大数据、Ai、ML 方面的证书
关于学位，请参见在线学位页面|美国/加拿大|欧洲。此页面用于获取证书的选项和…
www.kdnuggets.com](https://www.kdnuggets.com/education/analytics-data-mining-certificates.html)
免费的谷歌机器学习课程
用谷歌 AI 学习。无论你是刚刚学习编码，还是经验丰富的机器学习实践者，你都会…
ai.google](https://ai.google/education/)
17。书籍
[## 免费的编程书籍；HTML5，CSS3，JavaScript，PHP，Python...
最新消息，书籍每周更新:2019 年 8 月:部分书籍小幅更新 2019 年 7 月:部分书籍小幅更正…
goalkicker.com](https://goalkicker.com/) [## mravendi/数据科学机器学习人工智能资源
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/mravendi/data-science-machine-learning-ai-resources/tree/master/books) [## sayantanmitra 87/数据-科学-书籍-1
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/SayantanMitra87/Data-Science-Books-1)
一些我经常参考的重要书签
1.所有 DS 备忘单放在一处
[## FavioVazquez/ds-cheatsheets
统治世界的数据科学清单— FavioVazquez/ds-cheatsheets
github.com](https://github.com/FavioVazquez/ds-cheatsheets)
2.DS 资源在一个地方
[## 数据-科学-资源
一个精心策划的资源链接宝库(软件、平台、语言、技术等)。)对于数据科学，all in…
数据-科学-资源. readthedocs.io](https://data-science-resources.readthedocs.io/en/latest/#data-science-curated-resources)
3.DS 笔记
[## 克里斯·阿尔邦
我是一名数据科学家，有十年应用统计学习、人工智能和软件的经验…
chrisalbon.com](https://chrisalbon.com/)
4.DS 教程
使用口袋妖怪-韦德尔洞穴的数据
www.kaggle.com](https://www.kaggle.com/kanncaa1/data-sciencetutorial-for-beginners)
5.ML 教程
使用来自骨科患者的生物力学特征的数据
www.kaggle.com](https://www.kaggle.com/kanncaa1/machine-learning-tutorial-for-beginners)
6.DS 词汇表
使用来自[数据集不再可用]的数据
www.kaggle.com](https://www.kaggle.com/shivamb/data-science-glossary-on-kaggle)
7.DS 工具箱
[## 数据科学家工具箱教程— 1
使用房价数据:高级回归技术
www.kaggle.com](https://www.kaggle.com/mjbahmani/the-data-scientist-s-toolbox-tutorial-1)
8.Plotly 教程
使用来自世界大学排名的数据
www.kaggle.com](https://www.kaggle.com/kanncaa1/plotly-tutorial-for-beginners)
9.DS Github 存储库
[## donne Martin/数据科学 ipython 笔记本
演示深度学习功能的 IPython 笔记本电脑。其他 TensorFlow 教程:IPython 笔记本电脑…
github.com](https://github.com/donnemartin/data-science-ipython-notebooks)
10.开源代码库
[## Andrey Lukyanenko 的数据科学作品集
这个文件夹是我为数据分析或探索机器学习而创建的笔记本的汇编…
erlemar.github.io](https://erlemar.github.io/)
11.工业机器学习
此外，你可以加入链接信，而不是“观看”,它已经发送给了大约 90 人，你是…
github.com](https://github.com/firmai/industry-machine-learning)
12.数据工程指南。
我经常被问到如何成为一名数据工程师。这就是为什么我决定以所有的话题开始这本食谱…
github.com](https://github.com/andkret/Cookbook)
13.学习数据工程
[## 教程和练习|数据工程|学习数据工程
编辑描述
www.learndata.engineering](https://www.learndata.engineering/tutorials-exercises)
14.谷歌数据集搜索
谷歌推出了一种新型搜索引擎，专门帮助人们查找数据。简单的叫…
www.searchenginejournal.com](https://www.searchenginejournal.com/google-introduces-new-search-engine-for-finding-datasets/268337/)
15.数据工程研究指南；
[## 数据工程学习指南—大纲(复制一份:)，然后从那里开始
数据工程学习指南联系我们的问题，完成日期，笔记，个人困难 1-5 介绍这是一个…
docs.google.com](https://docs.google.com/spreadsheets/d/1GOO4s1NcxCR8a44F0XnsErz5rYDxNbHAHznu4pJMRkw/edit#gid=0)
16。正则表达式
https://regex101.com/
17。Google OpenRefine
OpenRefine(前身为 Google Refine)是处理杂乱数据的强大工具:清理它；将它从一种格式转换成另一种格式；并用 web 服务和外部数据来扩展它。
OpenRefine(前身为 Google Refine)是处理杂乱数据的强大工具:清理它；将 it 从…
openrefine.org](http://openrefine.org/)
18。更多 ML Youtube 频道:
[## 深度学习和计算机视觉的 Youtube 频道终极列表——编码女人
我想收集 Youtube 频道上关于深度学习和计算机视觉相关主题的视频…
www.codingwoman.com](http://www.codingwoman.com/youtube-channels-for-deep-learning-and-computer-vision/)
19。自制机器学习
对于这个库的 Octave/MatLab 版本，请检查机器学习 Octave 项目。此存储库包含…
github.com](https://github.com/trekhleb/homemade-machine-learning)
20。机器学习术语:
准确性是衡量分类模型好坏的标准。它由正确分类的数量给出…
塞曼迪](https://semanti.ca/blog/?glossary-of-machine-learning-terms)
21。令人敬畏的数据科学
这部分是为数据科学新手准备的。这是开始学习数据科学的捷径。只是…
github.com](https://github.com/academic/awesome-datascience)
22。数据科学博客
[## rushter/数据科学博客
数据科学博客的精选列表一个人类工程师——http://www.erogol.com/(RSS)的博客
github.com](https://github.com/rushter/data-science-blogs)
23。数据科学专业课程
这些是约翰霍普金斯大学数据科学专业的课程材料
github.com](https://github.com/DataScienceSpecialization/courses)
24.100 页机器学习书籍:
关于机器学习，你只需要知道一百页。监督和非监督学习，支持向量…
themlbook.com](http://themlbook.com/)
25。数据营信息表
希望这篇帖子对大家有帮助。如果你想添加任何东西，请在评论区发表。感谢您阅读我的帖子:-)
通过张量流考试:
我刚刚通过了 TensorFlow 开发者证书考试，并想分享对我有帮助的源代码。
自我图如何帮助你了解人工智能、下棋、吃得更健康、买狗和寻找爱情。
medium.com](https://medium.com/applied-data-science/the-google-vs-trick-618c8fd5359f)
绝对有意思，值得准备。我认为对于有经验的 TensorFlow 开发者来说，这可能是简单和容易的。
我使用的来源:
主要的是 Coursera 的 TensorFlow in Practice 或者 Udacity 的 tensor flow Intro。其他来源帮助我在更广泛的理解。从认证的角度来说，在 Coursera 的实践中，无论是 Udacity 还是 TensorFlow 都足够了。
仅用于认证:Coursera 或 Udacity
- Coursera 的 tensor flow in Practice
- tensor flow—uda city 简介
[## 获得 TensorFlow 开发者证书- TensorFlow
通过 TensorFlow 开发者证书脱颖而出展示您使用 TensorFlow 的熟练程度…
www.tensorflow.org](https://www.tensorflow.org/certificate)
每月 49 美元。Coursera。
探索软件开发人员用来构建可扩展的人工智能算法的工具…
Udacity 免费课程——类似 Coursera one。
免费课程由本课程是一个实用的方法，以深度学习的软件开发人员开始免费课程约…
www.udacity.com](https://www.udacity.com/course/intro-to-tensorflow-for-deep-learning--ud187)
Udacity — Github
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/tensorflow/examples/tree/master/courses/udacity_intro_to_tensorflow_for_deep_learning)
本书:
[## 使用 Scikit-Learn、Keras 和 TensorFlow 进行机器实践学习，第二版
通过最近的一系列突破，深度学习推动了整个机器学习领域。现在，甚至…
www.oreilly.com](https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/)
其他来源:
Youtube 频道
欢迎来到官方 TensorFlow YouTube 频道。了解最新的 TensorFlow 新闻、教程和最佳…
www.youtube.com](https://www.youtube.com/channel/UC0rqucBdTuFTjJiefW5t-IQ)
皮查姆
谷歌可乐布
张量流基础
TensorFlow 2.0 备忘单
梯度下降一步一步解释:我最喜欢的一个
用谷歌 AI 学习。无论你是刚刚学习编码，还是经验丰富的机器学习实践者，你都会…
ai.google](https://ai.google/education/) [## 机器学习速成班|谷歌开发者
学习和应用基本的机器学习概念的速成课程，获得现实世界的经验与…
developers.google.com](https://developers.google.com/machine-learning/crash-course) [## 我如何通过 TensorFlow 开发人员认证考试
你也可以
towardsdatascience.com](/how-i-passed-the-tensorflow-developer-certification-exam-f5672a1eb641) [## Tensorflow 开发者证书考试的一些小技巧
如你所知，Tensorflow 团队开放了 Tensorflow 开发者证书，从我们的口袋里掏出 100 美元…
medium.com](https://medium.com/@yrc602/some-tips-for-tensorflow-developer-certificate-exam-9d7a7b4495ae) [## 查看 Google 的“Tensorflow 开发者认证”
关于认证你需要知道的一切
medium.com](https://medium.com/analytics-vidhya/reviewing-the-tensorflow-developer-certification-by-google-45e913152def) 
AWS 机器学习专业
欢迎来到机器学习大学频道！我们的使命是让任何人都可以使用机器学习…
www.youtube.com](https://www.youtube.com/channel/UC12LqyqTQYbXatYS9AA7Nuw) [## AWS 认证机器学习专业 2020 -动手！
夏羽是一名解决方案架构师、顾问和软件开发人员，他对所有事物都有特殊的兴趣…
www.udemy.com](https://www.udemy.com/course/aws-machine-learning/) [## AWS 机器学习认证考试|2020 完整指南
机器和深度学习是目前最热门的技术领域！机器/深度学习技术被广泛…
www.udemy.com](https://www.udemy.com/course/amazon-web-services-machine-learning/) [## 云计算介绍免费课程| Udacity 免费课程
机器学习有望改变我们今天所知的几乎所有行业和客户体验。然而…
www.udacity.com](https://www.udacity.com/course/aws-machine-learning-foundations--ud090) [## AWS-样本/AWS-机器学习-大学-加速-标签
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/aws-samples/aws-machine-learning-university-accelerated-tab/tree/master/notebooks)
如有任何问题，请发电子邮件至 esenthil@hotmail.com 给我
一切顺利，同样，目标是学习 TensorFlow，而不是认证。
如果你喜欢这个帖子，就按一下鼓掌按钮，不要按一次😝
希望这篇帖子对你们有帮助。如果你想添加任何东西，请在评论区发表。感谢您阅读我的帖子:-)**
如何自学数据科学:实用指南
credit: https://1technation.com/lone-wolf-tactics-md-expo-success/
如果你曾经在家工作过，你就会知道这并不是大多数人想象的那种神奇、自由的体验。保持你的注意力和士气，让同事参与进来，并不像大多数人想象的那么容易。但幸运的是，在家工作的问题已经得到了很多关注:你可以找到大量专门针对这个问题的博客帖子和播客，其中有各种各样伟大的、可行的建议。
但是有一个密切相关的问题却没有得到那么多的关注，那就是在家学习的挑战。在家学习与在家工作非常不同，因为它是自我指导(你没有老板告诉你你必须学习什么)，而且——特别是在数据科学领域——它是开放式的(你可以学习多少没有限制，所以很难知道什么时候停止)。
随着越来越多的 MOOCs、在线训练营和免费学习资源出现，这正成为一个越来越重要的问题，我将在这篇文章中讨论这个问题。
一些背景:我的公司开展了一个数据科学导师项目，该项目本着远程优先的理念设计，我们的大部分努力都是为了确保我们的学员不会感受到远程学习带来的痛苦。我希望我们学到的教训可能对其他人有所帮助，所以我在这里整理了它们。
常见问题及解决方法
问题:我正在失去注意力，我发现很难不分心。
解决方案:这是一个常见的问题，但实际上你可以做很多事情来避免分心，专注于任务。
→每次使用后注销社交媒体。这不会让你的使用量降到零，但是强迫自己每次使用 Twitter 或 Instagram 时都登录，会让你更加意识到自己是如何使用时间的。
→不要在家工作。相反，你可以尝试去咖啡店、公共图书馆或共同工作空间。明确区分你的“工作”空间和“家庭”空间可以帮助你追踪你实际花在项目和 MOOCs 上的时间，并在你这样做时进入一个更专注的心态。
→找个人一起工作。如果是另一个有抱负的数据科学家或开发人员，会有加分，但几乎任何人都可以。同意追踪彼此的目标以保持彼此诚实。注意:你的学习伙伴甚至不必亲自到场——开放式视频聊天也可以。
→阅读一些生产力黑客文献。像《原子习惯》这样的书和像《T2》这样的帖子都是很好的起点。
问题:我没有取得足够的进步，而且我也没有动力。
解决方案:你追求的时间表总是有可能不切实际，这是你应该考虑的第一种可能性(完成向数据科学的职业转型可能需要几个月甚至几年)。除此之外，保持正轨的关键是问责制。
→设定明确的学习目标。瞄准短期目标(“这是我今天想做的”)，这可以更现实地确定范围。
→公开承诺你的目标。让你的 Twitter 关注者或 LinkedIn 联系人了解你的最新进展(如果你没有 Twitter 或 LinkedIn，请注册)。如果可以的话，联系一位行业专家，问问他们你是否可以通过每周简讯让他们了解你的最新工作。这是一个非常简单的方法，可以给自己一些额外的动力，确保你在每周的工作中有所表现，同时也是扩大你职业关系网的一个好方法。
→尝试设置您的项目，使其产生对您来说意义重大的成果。旨在将它部署为一个 Flask 应用程序，供您的朋友玩。计划把它写成一篇博文。为当地的聚会准备一个关于它的演讲。专注于产生具体的、有形的产出会是一个很大的动力。
问题:不知道什么时候继续前进。
解决方案:这在数据科学中是一个特别大的问题，因为项目通常是开放式的。对你的模型来说有多好才算足够好？您如何知道何时完成了数据探索步骤？你应该尝试另一种编码策略吗？
→最好的项目被设计成产品，有特定的目标受众和特定的使用案例。提前决定你在为谁构建你的项目，并把你的注意力放在构建对他们有用的东西上。带着这个目的去做你的数据探索:从探索你的数据中你能得到什么样的洞察力，这将导致一个更好的产品？
→提前确定你的成功标准(你想学什么，你的模型应该有多好，等等)。大多数行业项目都有明确的范围，您的项目也应该有。
→为您的项目设定时间框。在你开始工作之前，给自己设定一个明确的完成期限。这有一个额外的好处，那就是模拟您作为专业数据科学家将面临的时间限制和分类决策。
问题:不知道从何说起。
如果你刚刚起步，你需要做的第一件事就是找出你的兴趣所在。
→拿一个免费的 MOOC(这里可以找到一堆)。如果你刚刚开始，关注那些能让你建立 Python 技能的东西，那些能向你介绍 Jupyter 笔记本、scikit-learn 和 pandas 的东西。
→一旦你做到了这一点，问问自己:我想成为什么样的数据科学家？当然，你会想知道你有哪些选择，这就是为什么我写了这篇文章。
→对前方的道路有所了解。与经历过类似职业转变的人交谈，询问他们为实现这一转变做了些什么。我还建议查看这篇关于我见过的最常见的数据科学职业转变的帖子，因为你的情况很有可能在其中。
我已经看到这些事情中的每一件都为 SharpestMinds 学员带来了进步和生产力的显著提高。也就是说，要记住的一件重要事情是对自己要有耐心。
第一次尝试实施这个或那个策略时，您可能会失败，您可能仍然会落后于计划，并且您可能无法及时完成项目。没关系:关键是把你的旅程当成一次实验，并记录下哪些有效，哪些无效。就像任何好的机器学习模型一样，只要你不断迭代，你迟早会找到你的最优解。
如果你想联系，你可以在 Twitter 上找到我，地址是 @ jeremiecharris！
如何使用 Python 从 S3 的 pickle 文件加载数据
我不知道你怎么想，但我喜欢尽可能高效地钻研我的数据。从 S3 提取不同的文件格式是我每次都要查找的事情，所以这里我展示了如何将数据从存储在 S3 的 pickle 文件加载到我本地的 Jupyter 笔记本上。
This has got to be the ugliest picture I’ve ever used for one of my blogs. Thx Google Search and Print Screen!
一些注意事项:
- 永远不要硬编码您的凭证！如果你这样做了，一定不要把代码上传到仓库，尤其是 Github。有网络爬虫寻找意外上传的密钥，你的 AWS 帐户将被危及。相反，使用
boto3.Session().get_credentials() - 在 python 的老版本中(Python 3 之前)，你将使用一个名为
cPickle的包而不是pickle，正如这个 StackOverflow 所验证的。
维奥拉。而从那里看，data应该是一个熊猫的数据帧。
我发现消除数据帧中字段和列名的空白很有帮助。我不确定这是一个 pickle 文件，还是针对我的数据。如果这个问题影响到你，下面是我使用的:
要消除列名中的空白:
col_list = []
for col in list(data.columns):
col_list.append(col.strip())data.columns = col_list
要消除数据中的空白:
data = data.applymap(lambda x: x.strip() if type(x)==str else x)
资源:
[## 凭证- Boto 3 文档 1.9.123 文档
boto3 中有两种类型的配置数据:凭证和非凭证。凭据包括以下项目……
boto3.amazonaws.com](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html)
如何加载 Matlab？Python 中的 mat 文件
Matlab 是学术界非常流行的科学计算平台。我在攻读工程学位的过程中一直在使用它，有可能你会遇到。大学发布的数据集的 mat 文件。
这是一个简短的帖子，解释了如何使用 python 加载这些文件，python 是当今最流行的机器学习语言。
数据
我想建立一个分类器来检测不同型号和品牌的汽车，所以斯坦福汽车数据集似乎是一个很好的起点。来自学术界，数据集的注释在。mat 格式。你可以在这里获得这篇文章中使用的文件。
正在加载。mat 文件
Scipy 是一个非常流行的用于科学计算的 python 库，很自然地，他们有一个方法可以让你读入。mat 文件。阅读它们绝对是最简单的部分。您可以用一行代码完成它:
from scipy.io import loadmat
annots = loadmat('cars_train_annos.mat')
嗯，真的就这么简单。但是让我们继续，实际上试着从这本字典中得到我们需要的数据。
格式化数据
loadmat 方法返回一个更熟悉的数据结构，一个 python 字典。如果我们看一下这些键，我们会发现与处理. mat 文件相比，我们现在感觉就像在家里一样:
annots.keys()
> dict_keys(['__header__', '__version__', '__globals__', 'annotations'])
查看这个数据集的文档，我们将了解它的真正构成。README.txt 为我们提供了以下信息:
This file gives documentation for the cars 196 dataset.
([http://ai.stanford.edu/~jkrause/cars/car_dataset.html](http://ai.stanford.edu/~jkrause/cars/car_dataset.html)) — — — — — — — — — — — — — — — — — — — —
Metadata/Annotations
— — — — — — — — — — — — — — — — — — — —
Descriptions of the files are as follows:-cars_meta.mat:
Contains a cell array of class names, one for each class.-cars_train_annos.mat:
Contains the variable ‘annotations’, which is a struct array of length
num_images and where each element has the fields:
bbox_x1: Min x-value of the bounding box, in pixels
bbox_x2: Max x-value of the bounding box, in pixels
bbox_y1: Min y-value of the bounding box, in pixels
bbox_y2: Max y-value of the bounding box, in pixels
class: Integral id of the class the image belongs to.
fname: Filename of the image within the folder of images.-cars_test_annos.mat:
Same format as ‘cars_train_annos.mat’, except the class is not provided. — — — — — — — — — — — — — — — — — — — —
Submission file format
— — — — — — — — — — — — — — — — — — — —
Files for submission should be .txt files with the class prediction for
image M on line M. Note that image M corresponds to the Mth annotation in
the provided annotation file. An example of a file in this format is
train_perfect_preds.txtIncluded in the devkit are a script for evaluating training accuracy,
eval_train.m. Usage is:(in MATLAB)
>> [accuracy, confusion_matrix] = eval_train(‘train_perfect_preds.txt’)If your training predictions work with this function then your testing
predictions should be good to go for the evaluation server, assuming
that they’re in the same format as your training predictions.
我们感兴趣的是'注解'变量，因为它包含了我们的类标签和边界框。它是一种结构，一种人们非常熟悉的数据类型，来自 C 或 java 风格的强类型语言。
稍微挖掘一下这个对象，我们就会发现一些有趣的东西:
type(annots[‘annotations’]),annots[‘annotations’].shape
>(numpy.ndarray, (1, 8144))type(annots['annotations'][0][0]),annots['annotations'][0][0].shape
>(numpy.void, ())
注释以 numpy.ndarray 格式存储，但是这个数组中项目的数据类型是 numpy.void ，numpy 似乎并不知道它们的形状。
loadmat 方法的文档页面告诉我们它如何将 matlab 结构加载到 numpy 结构化数组中。您可以使用键来访问结构的成员:
annots[‘annotations’][0][0][‘bbox_x1’], annots[‘annotations’][0][0][‘fname’]> (array([[39]], dtype=uint8), array(['00001.jpg'], dtype='<U9'))
现在我们知道了如何访问结构的成员，我们可以遍历所有的成员并将它们存储在一个列表中:
[item.flat[0] for item in annots[‘annotations’][0][0]]> [39, 116, 569, 375, 14, '00001.jpg']
这里，我们可以使用 flat 方法从数组中挤出值。
你好熊猫
现在我们知道了如何用 python 处理 matlab 文件，让我们把它转换成 pandas 数据框。我们可以使用列表列表轻松做到这一点:
data = [[row.flat[0] for row in line] for line in annots[‘annotations’][0]]columns = [‘bbox_x1’, ‘bbox_y1’, ‘bbox_x2’, ‘bbox_y2’, ‘class’, ‘fname’]
df_train = pd.DataFrame(data, columns=columns)
终于，熟悉的领地！
这个帖子的代码可以在这里找到。
如何用深度学习做披萨
当只给一张美味饭菜的图片时，深度神经网络能学会如何烹饪吗？麻省理工学院新的深度学习研究表明了这一点！
他们最近发布的题为 如何制作披萨:
学习基于成分层的 GAN 模型 的研究探索了 GAN 模型如何被训练以识别制作披萨所涉及的步骤。他们的 PizzaGAN 分为两部分:
(1)给定比萨饼的输入图像，PizzaGAN 被训练来预测比萨饼上有什么浇头
(2)给定比萨饼的输入图像，PizzaGAN 可以将一组有序的模型应用于该图像，其中每个模型从比萨饼中添加或移除浇头
比萨饼是由什么组成的？
在尝试训练深度神经网络制作披萨之前，我们首先需要弄清楚如何自己制作披萨。
像任何伟大的食谱一样，制作比萨饼的过程是由一系列有序的步骤组成的。你总是从面团、酱和奶酪开始，然后继续添加其他更冒险的配料。这种连续的过程反映在比萨饼在每一步的外观上——它的视觉外观随着每一种添加的浇头而变化。
How PizzaGAN defines a pizza — as a set of ordered steps.
一旦我们的目标过程被很好地定义，我们就可以开始训练一个实际的模型来近似这些步骤。
例如，我们从一个美味的意大利辣香肠披萨开始。然后我们的朋友走过来对我们说:“嘿，我们来加橄榄吧！”我们可以将从原始披萨到新披萨的过程建模为一系列步骤:
(1)认清我们的现状——意大利香肠比萨饼
(2)应用一个让我们达到目标状态的改变——加入橄榄
加入橄榄后，另一个朋友可能会说:“我不喜欢意大利香肠，我们用火腿吧！”这次我们有 3 个步骤:
(1)认清我们目前的状态——意大利香肠和橄榄披萨
(2)应用让我们更接近目标状态的第一个改变——去掉意大利香肠
(3)应用使我们达到目标状态的第二个变化——添加火腿
为了了解如何制作比萨饼，PizzaGAN 神经网络试图对所有这些步骤进行建模。
甘人是如何做披萨的
资料组
用于训练 PizzaGAN 的披萨数据集由 9213 幅图像组成，每幅图像显示一个披萨。每张图片都有一组相应的标签，描述比萨饼上的配料，不包括面团、调味汁和基础奶酪。例如，如果比萨饼图像上有火腿和蘑菇，则该图像的标签为:
["ham", "mushrooms"]
当执行训练时，输出分类是一次性编码的。因此，对于火腿和蘑菇比萨饼，输出向量的火腿和蘑菇元素被设置为 1.0，而其余元素被设置为 0.0。
生成器网络-添加和删除浇头
回想一下，我们希望能够将比萨饼的制作建模为一组连续的步骤。因此，无论训练什么样的网络，都必须能够一次执行一个步骤——添加一个浇头、移除一个浇头、烹饪比萨饼等等。
为此，训练一个生成器网络来模拟每个浇头的添加或去除。给定比萨饼的输入图像，生成器预测比萨饼的输出图像，就好像我们添加或删除了一种浇头。
由于一次为一个浇头训练发生器，并且仅用于添加或移除，所以训练多个发生器网络，每对不同的浇头组训练两个(每对中一个用于添加，一个用于移除)。下面显示了一对 PizzaGAN 发生器的示例，一个用于添加意大利香肠，一个用于移除意大利香肠。
An example of a pair of PizzaGAN generators — one to add pepperoni and one to remove it
奶酪披萨的整个分类向量为 0，而意大利辣香肠披萨的分类向量除了意大利辣香肠指数为 1.0 之外都是 0。由于 PizzaGAN 生成器的输入和输出图像之间的差总是只有一个顶点，因此输入和输出标签向量的分类向量元素之和的差也是 1。
鉴别器—识别比萨饼
PizzaGAN 生成器涵盖了所有添加和删除比萨浇头的操作。鉴别器将负责识别当前比萨饼上实际上的浇头。
给定比萨饼的输入图像，鉴别器网络预测一组多标签分类。输出向量的每个元素对应于一个特定的浇头。
例如，在下图中，PizzaGAN 鉴别器预测比萨饼的图像有意大利辣香肠、蘑菇和橄榄。对应于那些浇头的输出向量的元素被推断为 1.0(或者高于用户设置阈值的某个值)。
An example of how the discriminator of PizzaGAN works, predicting both the classification and the topping ordering of the pizza
GAN 模型通常通过一起执行生成器和鉴别器的训练来训练。鉴别器模型用发生器模型的一些输出来训练，鉴别器模型从其预测中的损失用于发生器模型的训练。
PizzaGAN 也遵循这一培训计划。除了预测比萨饼图像的标签，鉴别器还预测图像是真实的还是来自生成器。这有助于生成器创建看起来仍然像真正的比萨饼图像的图像，并具有所有正确的浇头。
最终比萨饼
通过鉴别器预测比萨饼上的浇头，并且生成器能够添加和删除浇头，PizzaGAN 能够以相当高的精度构建和分解比萨饼的图像。
PizzaGAN adding and removing toppings
PizzaGAN cooking and uncooking toppings
如果你想阅读更多关于 PizzaGAN 如何工作的细节，我建议查看发表在 CVPR 2019 的原始论文！
除此之外，我给你们留下这篇论文中的精彩引文:
披萨是 Instagram 上被拍照次数最多的食物，有超过 3800 万个帖子使用#披萨这个标签。
喜欢学习？
在推特上关注我，我会在那里发布所有最新最棒的人工智能、技术和科学！也在 LinkedIn 上与我联系！
推荐阅读
想了解更多关于深度学习的知识？用 Python 进行 深度学习本书将教你如何用有史以来最简单的 Python 库进行真正的深度学习: Keras ！
提醒一句，我支持这个博客，因为分享好书对每个人都有帮助。作为一名亚马逊员工，我从合格购买中获得收入。
如何让您的数据科学团队取得成功？
数据科学响彻每一个行业，已经到达主流媒体。只要我称之为人工智能，我就不再需要解释我以什么为生——我们是数据科学炒作的巅峰！
因此，越来越多的公司对数据科学寄予厚望，准备投资组建自己的团队。不幸的是，企业中数据科学的现实远非一个成功的故事。NewVantage 在 2019 年 1 月发布了一项调查，发现 77%的企业报告了业务适应方面的挑战。这就意味着所有的数据项目都积灰了，而不是提供投资回报。Gartner 一直对数据科学的成功持批评态度，最近他们并没有变得更加乐观:根据 Gartner 2019 年 1 月的报告，即使是分析见解也不会在 2022 年前带来业务成果，那么数据科学还有什么希望呢？很明显，由于某些原因让数据科学取得成功真的很难！
Me scaring Execs about their data science investments at the Data Leadership Summit, London 2019.
无论你是管理现有的数据科学团队，还是即将在大数据或人工智能领域开始一个新的绿地项目，承认不可避免的事情很重要:T2 炒作周期 T3。
Luc Galoppin, https://www.flickr.com/photos/lucgaloppin/
数据科学和人工智能的能见度越来越高，随之而来的是过高的期望。结合这些项目和团队目前的成功率，我们正朝着悬崖边缘和幻灭的低谷前进。
Christopher Conroy 在最近接受《信息时代》采访时完美地总结了这一点:围绕人工智能的新一轮炒作只是给人一种虚假的印象，即企业在大数据和数据科学方面取得了多年前的进步。我们是不是发现了一个更高的悬崖边缘？
谢天谢地，这不全是坏消息。一些团队、项目和企业确实是成功的(根据调查，大约 30%)。我们只需要对成功的要求有一个新的关注点。
The five pillars of data science success
第一个重要事实是，在数据科学领域，成功的公司并不只有一个优先事项或一件事情。
成功没有灵丹妙药或捷径！
数据科学的成功通常有五个更广泛的主题。一些主题得到了很好的理解和广泛的讨论，如文化的重要性。其他主题突出了一些误解，例如，这些误解导致低估了技术在留住数据科学团队中的重要性。技术的重要性是数据科学领域大多数成功公司都是科技公司的关键因素。这不仅仅是因为只有科技公司有办法解决技术需求，而是因为他们更好地理解了挑战及其合适的解决方案。但是不要绝望！幸运的是，随着云解决方案和 PaaS 的日益成熟，这可以在任何行业实现。
动机
数据科学在商业上取得成功的第一个优势是企业在第一时间组建团队的动机。动机决定了努力是成为一个虚荣的项目，还是与商业战略保持一致。
从我的经验来看，数据科学需要一个由愿景而不是短期目标驱动的企业。这是基于数据科学和数据创新的复杂性和时间表。数据科学仍然是创新的同义词，很难在短期目标优先级快速变化的情况下实现创新。关注数据科学以实现其愿景的公司也表现出对数据科学实际上是什么以及它如何增加价值的更好理解。
动机也将是任何文化或业务变革努力的好坏，这些努力伴随着业务向数据驱动的转变。
检验动机的一个很好的试金石是高层领导的认同。
准备工作和要求
然而，许多大数据和数据科学项目无论有多么好的意图都无法通过初步阶段，因为需求和基础根本不存在。
基础设施
围绕数据基础设施有明显的需求:任何数据团队都需要访问高质量的数据和合适的基础设施来处理这些数据。但是一个好的基础设施是什么样的呢？这取决于您的数据量和波动性，数据解决方案市场发展如此之快，以至于在我发表本文时，任何建议都已经过时了。但是有一个不变的事实
数据基础设施的试金石应该是多租户和生产试验能力。
A data lake without good multi-tenancy is a failed investment. (Pixabay)
随着数据量和易失性的增加，为数据维护单独的环境(如生产和开发环境)变得不可行或成本过高。你将不得不接受在生产中进行实验的数据科学要求。如果仅仅为了保证数据科学家的性能，就必须让他们尽可能远离生产数据存储和管道，那么你就没有好的多租户。多租户不同于可伸缩性，可伸缩性本身不是解决方案。无论您的数据基础架构有多大的容量或弹性，您的数据科学家最终都会全部使用它，并与您的任务关键型数据流程发生直接冲突。良好的多租户原生技术是经济高效且安全地共享数据和资源的唯一解决方案，具有 1)数据放置控制、2)工作放置控制、3)访问控制和 4)管理、审计和报告。
此外，您的基础架构需要一定程度的敏捷性。正如您将看到的，大多数数据科学项目(希望不是团队)都非常短暂，并且失败率很高。你根本不知道数据会把你带到哪里，也不知道在每个想法的结尾是否有一个可行的模型。为了保持生产力，您的基础设施需要敏捷性来支持失败率高的短期项目。
Fail early, fail fast, fail often to succeed.
团队和组织结构
The nature of the tree determines the nature of its fruit. (Manu Cornet)
团队和组织结构是重要的考虑因素。组织和组建团队有很多方法，但简单地改变人们的位置并不能解决很多问题。这种趋势指向由共同的目标或任务声明激励的跨职能项目团队。数据科学没有区别。特别是在拥有许多产品团队或业务部门的大公司中，集中的团队将难以与业务优先级保持一致，最终会被孤立。
但是将数据科学家放在跨职能团队中很容易将他们与同行隔离开来。这是一个问题，当它对文化产生影响，从而留住数据科学家。此外，将数据科学家与他们的同行隔离开来将会限制他们以创新方式解决问题以及克服挑战或障碍的能力。能够解决任何业务问题，同时又是多面手和完美专家的数据科学家仍然拥有独角兽地位。不太可能为每个班或业务单位找到一个。集中化的数据科学团队受益于更广泛的技能交叉，也更容易留住人才。
有一些有趣的新方法，例如运行公民数据科学计划，该计划依靠技术来克服分析和数据科学自助服务/授权战略中的技能差距。埃森哲发表了一篇关于分析和数据科学组织结构的广泛评论。
无论哪种结构适合您的业务，数据科学家都需要来自工程、数据架构、开发运维及产品等其他职能部门的支持。最后，这种支持是存在于跨职能团队内部，还是可以通过团队和部门之间的良好协作和强大的优先级划分来获得，对于数据科学的成功并不重要。
数据科学是一项团队运动！
雇用
不要被市场上越来越多的数据科学家误导了。数据科学仍然是一个创新主题，有经验的数据科学“独角兽”和以前一样少。为了吸引有经验的数据科学家，企业需要考虑的不仅仅是有竞争力的薪酬水平。组成成功的数据科学团队的人是由好奇心驱动的，他们喜欢玩新技术，并且受到企业可以为他们提供的机会和挑战的激励。
建立一个新团队伴随着一些明显的挑战:你从哪里寻找好的候选人，什么是合适的面试过程？还有一个“先有鸡还是先有蛋”的难题，即谁应该组建团队？理想情况下，一名经验丰富的高级数据科学经理，拥有一些实际操作经验，能够驾驭流行词汇并发现人才。
做好第一份工作很重要，合适的候选人会比其他人更愿意面试你。
你的试金石是在高层领导认同、激励、基础设施、业务变革流程、交付渠道和文化方面受到候选人的挑战。
在当前人才短缺的市场中，公司拥有良好的招聘流程至关重要。当人才短缺时，企业需要每时每刻都以闪电般的速度向中介和候选人提供反馈。候选人为王。如果候选人有不好的经历，这将对企业的声誉产生不利影响，最好的候选人会去别处。
如果你想在招聘过程中加入某种形式的测试或演示，那么就要准备好用同等的时间投资来回报应聘者的努力，仔细检查他们的申请并提供详细的反馈。最重要的是，让它与业务相关！远离在白板上用伪代码设置的考试。没有一个数据科学家必须在日常工作中像这样工作，也没有人期望他这样工作。
Technical interviews like this are still way too popular with hiring managers.
交付
One does not simply deploy data science models! More details in my article about Machine Learning Logistics.
交付是误解最多的话题:商业数据科学需要克服的科学问题比技术挑战要少得多。不幸的是，尽管模型的生产部署是商业数据科学中最艰难的挑战，但人们对数据准备挑战的关注是不必要的。数据科学团队要想在商业上取得成功，需要满足以下要求的交付渠道:
- 平行评估大量现有车型和挑战者车型
- 管理模型生命周期
- 处理日益增长的数据科学工具包的异构性
- 允许在不影响用户体验的情况下进行生产实验，并将业务目标与数据科学目标分离
- 将 SLA 和 GDPR 等企业需求从数据科学模型中分离出来
- 将其扩展到每分钟 50+k 页面负载的峰值，而无需雇佣大批 DevOps 工程师
如何构建一个前沿的数据科学平台来解决数据科学中的真正挑战:生产化。
towardsdatascience.com](/rendezvous-architecture-for-data-science-in-production-79c4d48f12b)
所有这些都是技术挑战，而不是科学问题。在我关于机器学习物流的文章中阅读一个叫做 Rendezvous Architecture 的解决方案。一个关键的优先事项是生产中模型生命周期管理的自动化或数据操作。依靠数据科学家来进行数据操作是错误的:这不是一个强大或可扩展的解决方案，它会让数据科学家感到沮丧，并很快导致他们离开。
成功的数据科学交付受益于强大的业务变革流程。业务的数据转换成为数据驱动将会引起重大变化。数据科学、创新和总体业务变革不应成为利益之争，而应成为定义明确、客观的变革管理流程。
John Kotter’s 8-Step Process for Leading Change, https://strategyumwelt.com/frameworks/kotters-8-step-process-for-leading-change
用户界面、UX 和设计
数据科学等同于生产中的实验即使是最好的模型，其好坏也取决于用户对其集成和执行的体验。模型永远不会是 100%正确的，UI 和 UX 必须考虑到这一点。举例来说，你的推荐引擎的不完美不应该导致用户不得不浏览它们的同样沮丧。当你对倾向评分采取行动时，例如针对追加销售，考虑到不确定性，干预的介入程度应该如何？根据我的经验，许多数据科学项目失败不是因为数学错误，而是因为 UX 不好。
保留
文化是最重要的保持工具，同时也具有超越保持的重要性。不仅仅是为了数据科学！
https://www.flickr.com/photos/doesliverpool/ (CC BY-SA 2.0)
数据科学文化不仅仅是公司津贴和福利待遇。任何人才都会被他们产生影响的工作所激励，但数据科学的业务适应可能会很慢，并导致挫折。与此同时，数据科学有一个强大的组织聚会、会议和黑客马拉松的社区。企业应该将此作为其文化投资的一部分。为什么不举办一次见面会或午餐学习会，为您的数据科学家提供一个展示他们工作的平台，并提高他们在企业中的知名度呢？为什么不组织一次黑客马拉松呢？重要的是要记住，文化不是一夜之间创造出来的，也不是一次性的考虑。如果你没有策略来跟进你的黑客马拉松，然后把有希望的想法放到待办事项中，那将会适得其反。你不希望你的黑客马拉松进一步凸显业务适应的无能。
Living breathing data science: me and my team at meet-ups, conferences and hackathons
如果我们有时间研究一些自己的想法并展示……的创新潜力，那不是很好吗
towardsdatascience.com](/organising-the-zoopla-hack-days-6d7f25e4e763)
对于数据科学来说，更独特的是，技术在留住人才方面发挥着重要作用。
可扩展的交付渠道和快乐的数据科学家之间有着重要的联系。
数据科学家的动机是开发新模型来解决相关的业务问题，而不是模型在生产中的日常运营责任。这意味着，数据基础设施、数据科学平台、自动化和数据运营不仅对于业务成果的交付，而且对于团队的长期保留都是至关重要的问题。在一个超过 75%的团队未能做到这一点的市场中，任何将模型端到端交付到生产中的数据科学家都变得非常有价值。对生产中的模型进行日常维护和监控并不是留住人才的好方法。很快，您会发现自己的产品中有一个无人维护的模型，这个模型正在漂移，没有人知道这个模型最初是如何工作的。
交付、技术和保留都与数据科学的长期成功紧密相关。
最后但同样重要的是:你需要为你的数据科学家制定一个职业发展战略！目前，太多的数据科学家为了获得职业发展或寻找新的令人兴奋的挑战而跳槽。一方面，这包括支持和认可作为职业框架一部分的不断变化的领域中的学习和发展需求。另一方面，数据科学仍然是一个新兴的业务领域，目前还不太符合业务。你的职业框架需要灵活性来适应这一点。
你能否留住人才的试金石是数据科学家的工作时间是否超过通常的 12-18 个月。
Jan 是公司数据转型方面的成功思想领袖和顾问，拥有将数据科学大规模应用于商业生产的记录。他最近被 dataIQ 评为英国 100 位最具影响力的数据和分析从业者之一。
在 LinkedIn 上连接:https://www.linkedin.com/in/janteichmann/
阅读其他文章:https://medium.com/@jan.teichmann
如何让车辆自动驾驶
自动驾驶汽车的关键方面
Source: Machine Design
当想到自动驾驶汽车时，我们会想到一种无需人工干预就能把我们从起点带到终点的汽车。
SAE 国际(汽车工程师学会)已经定义了各种级别的自治。从 0 级(日常使用的多功能车)到 5 级(不需要人工干预的车辆)。目前，我们距离第 5 级自动化还很远，因为有许多情况下自动驾驶汽车不擅长处理。但是，如果工业界和学术界保持良好的工作，我们可能会早于晚。一旦我们到达那里，我们的车辆将没有方向盘。
本文将阐述使车辆实现自主驾驶的使能技术，以及如何将这些技术集成在一起，使汽车/卡车/SUV 能够自主地在街道上行驶。
首先，让我们想象我们有一辆汽车，我们希望让我们的汽车自动驾驶。这辆车成为自动驾驶需要三个主要元素，即高清地图(HDMap)；状态和地理位置估计器；和一个动作经理。在我们开始解决自动驾驶汽车的这些关键问题之前，我们需要解决一些背景概念，例如自动驾驶汽车中使用的传感器。
自动驾驶汽车使用的传感器:
以下是自动驾驶汽车中使用的一些传感器:
LIDAR :代表光探测和测距，是一种遥感方法，使用脉冲激光形式的光来测量到地球的距离(可变距离)。这项技术用于扫描道路和建筑物。通过激光雷达扫描，我们可以生成一个云点(字面意思是一个点的数据集)，它可以被加载并用于表示现实世界。
Lidar Sensor Velodyne HDL-64E — Source: news.voyage.auto
LIDAR EXAMPLE — Source: news.voyagae.auto
雷达:是一种利用无线电波来确定物体的距离、角度或速度的探测系统(详见此处)。雷达是我们在自动驾驶汽车中可以拥有的最简单的传感器之一，它们到达的距离很短，但与激光雷达相比，它们相对便宜。目前，许多车辆已经使用雷达技术来防止停车时的碰撞。
GPS: 简单来说我们都知道 GPS 是什么意思。当你使用智能手机时，你可能需要在地球上定位自己；你激活你的全球定位系统，突然你可以谷歌地图或任何其他地理定位相关的功能。如果你需要一个官方定义，这里是这样的:全球定位系统 ( GPS )，是一个基于卫星的无线电导航系统，由美国政府所有，由美国空军运营。它是一个全球导航卫星系统(GNSS ),向地球上或附近任何地方的 GPS 接收器提供地理位置和时间信息，在那里可以畅通无阻地看到四个或更多 GPS 卫星(点击了解更多信息)。
摄像头:摄像头是自动驾驶汽车中的重要传感器。这使他们能够识别现实世界中的物体和人。这都要归功于近年来计算机视觉的进步。得益于机器学习技术的最新发展，特别是卷积神经网络，自动驾驶汽车可以使用摄像头进行物体检测和物体识别。
Driverless Car computer stock footage — Source: electrek.co
第一个关键点:高清地图
汽车需要的第一件事是能够检测它在世界上的位置。为了做到这一点，自动车辆需要有一个高清地图(高清地图)，其中包括大量关于道路和周围环境的数据。构建高清地图需要大量的工作。有些公司的唯一目的是创建和更新高清地图。
激光雷达扫描路面，计算机视觉分析提取道路信号和创建车道对象。创建高密度贴图时需要这些和更多的步骤。自动车辆必须始终知道它们位于哪个车道，并且路线必须包括所有必要的车道变换。一个重要的库被广泛用于此:LANENET。定义 lanenets 的研究论文可以在这里找到。
Sample of HDMap. Source: TechCrunch
第二个关键点:状态估计器
其次，汽车需要一个状态估计器。状态估计器将协调来自自主车辆中所有传感器的输入，并在 HDMap 内创建保持车辆最新的地理位置。它将接收来自车辆各种不同部分的输入。
不同的情况可能需要不同的传感器。例如，如果车辆在建筑物内，GPS 信号可能不可靠，并且状态估计器可能不得不依赖于其他传感器，例如激光雷达、雷达和轮胎的运动来更新车辆的地理位置。与此同时，在高速公路(英国的高速公路)上，一辆卡车可能位于车辆前方，阻碍了激光雷达传感器感知车辆前方的整个世界。在这种情况下，我们的自动驾驶汽车将会失明。但有了可靠的高清地图和 GPS 信号，我们的车辆可以很好地了解前方的情况(下一个路口或出口是什么时候)。
最终，状态估计器将接收并组合来自自主车辆内多个传感器的数据。并非所有传感器都以相同的速率发送数据。激光雷达系统可以每毫秒提供许多脉动，而 GPS 需要更长时间来更新。状态估计器应该协调这些信息。
第三关键环节:运动规划
运动规划器是自主车中负责运动的部分。如果我们打算将自动驾驶汽车从 A 点移动到 B 点，第一个选项可能是前进(或倒车，或转弯)。运动规划者负责确定车辆到达目的地所需的动作。从状态估计器中，车辆可以知道何时有障碍物阻挡了车辆的路线，然后运动规划器应该要求紧急停止。当车辆需要换道时，运动规划器将调用换道操作。运动规划器是一个大型算法数据集，它基于车辆的路线进行操作。
结论
在自主车辆的开发中，有更多的类和算法需要考虑，希望这篇文章为您指明了正确的方向。
如果你希望开始从事这一领域的工作，你需要掌握一些工具或特定的知识，例如编程技能(Matlab/Python/C++)、深度学习(计算机视觉)、地理信息系统(GIS，这将有助于构建高清地图)、建模和模拟的概念等等。无论你的背景是什么，我希望这篇文章对你有所帮助。
制作自动编码器
使用 Keras 和 MNIST 培训
了解自动编码器:
Image of Autoencoder Architecture created by Arvin Singh Kushwaha
自动编码器是一类无监督网络，由两个主要网络组成:编码器和解码器。
无监督网络是在没有任何训练标签的情况下从数据中学习模式的网络。网络在没有被告知模式应该是什么的情况下在数据中找到它的模式。
相反，有监督网络，其中当给定特定输入时，网络被训练以返回特定输出。
编码器通常使用一系列密集和/或卷积层将图像编码成以紧凑形式表示图像的固定长度向量，而解码器使用密集和/或卷积层将潜在表示向量转换回相同的图像或另一个修改的图像。
上图显示了一个简单的自动编码器的例子。在这个自动编码器中，您可以看到大小为 X 的输入被压缩成大小为 Z 的潜在向量，然后被解压缩成大小为 X 的相同图像。
为了生成图像，给解码器网络一个随机输入向量。解码器网络将把输入向量转换成完整的图像。
创建自动编码器:
我推荐使用 Google Colab 来运行和训练 Autoencoder 模型。
安装 Tensorflow 2.0
#If you have a GPU that supports CUDA
$ pip3 install tensorflow-gpu==2.0.0b1#Otherwise
$ pip3 install tensorflow==2.0.0b1
Tensorflow 2.0 内置了 Keras 作为其高级 API。Keras 可通过此导入进行访问:
import tensorflow.keras as keras
导入必要的模块/包
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Dense, Input, Flatten,\
Reshape, LeakyReLU as LR,\
Activation, Dropout
from tensorflow.keras.models import Model, Sequential
from matplotlib import pyplot as plt
from IPython import display # If using IPython, Colab or Jupyter
import numpy as np
正在加载 MNIST 数据
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train/255.0
x_test = x_test/255.0
MNIST 数据集由 70000 个 28 像素乘 28 像素的手写数字图像和 70000 个包含每个数字是哪个数字的信息的向量组成。
图像训练数据从[0，255]缩放到[0，1]，以允许使用 sigmoid 激活函数。
Data from x_train[0]
为了检查我们的数据，我们将绘制训练数据集中的第一幅图像。
# Plot image data from x_train
plt.imshow(x_train[0], cmap = "gray")
plt.show()
决定潜在规模
潜在大小是潜在空间的大小:压缩后保存信息的向量。该值是一个至关重要的超参数。如果该值太小，将没有足够的数据用于重建，如果该值太大，可能会发生过度拟合。
我发现一个好的、成功的潜在大小是 32 个值长。
LATENT_SIZE = 32
创建编码器
encoder = Sequential([
Flatten(input_shape = (28, 28)),
Dense(512),
LR(),
Dropout(0.5),
Dense(256),
LR(),
Dropout(0.5),
Dense(128),
LR(),
Dropout(0.5),
Dense(64),
LR(),
Dropout(0.5),
Dense(LATENT_SIZE),
LR()
])
编码器由一系列致密层和间隙漏失层和泄漏层组成。密集层允许将 28×28 的输入张量压缩到大小为 32 的潜在向量。下降层有助于防止过拟合和泄漏。作为激活层，下降层会在混合中引入非线性。Dense(LATENT_SIZE)创建大小为 32 的最终矢量。
创建解码器
decoder = Sequential([
Dense(64, input_shape = (LATENT_SIZE,)),
LR(),
Dropout(0.5),
Dense(128),
LR(),
Dropout(0.5),
Dense(256),
LR(),
Dropout(0.5),
Dense(512),
LR(),
Dropout(0.5),
Dense(784),
Activation("sigmoid"),
Reshape((28, 28))
])
解码器本质上与编码器相同，但方向相反。然而，最终的激活层是 s 形的。sigmoid 激活函数输出范围为[0，1]的值，这与我们的缩放图像数据完全吻合。
Sigmoid Function
创建完整的模型
要创建完整的模型，必须使用 Keras 功能 API。函数式 API 允许我们将多个模型串在一起。
img = Input(shape = (28, 28))
这将创建一个占位张量，我们可以将它输入到每个网络中，以获得整个模型的输出。
latent_vector = encoder(img)
output = decoder(latent_vector)
Keras Functional API 最好的部分是它的可读性。Keras Functional API 允许您将模型直接调用到张量上，并从该张量获得输出。通过将encoder模型调用到img张量上，我得到了latent_vector。同样的事情也可以在latent_vector上用decoder模型来完成，这给了我们输出。
model = Model(inputs = img, outputs = output)
model.compile("nadam", loss = "binary_crossentropy")
要创建模型本身，可以使用 model 类并定义模型的输入和输出。
要训练一个模型，你必须编译它。为了编译一个模型，你必须选择一个优化器和一个损失函数。对于优化器，我选择了 Nadam，这是应用于自适应矩估计的内斯特罗夫加速梯度。这是一个改进的 Adam 优化器。对于损失，我选择了二元交叉熵。二进制交叉熵通常用于自动编码器。然而，通常二元交叉熵与二元分类器一起使用。此外，二进制交叉熵只能在[0，1]范围内的输出值之间使用。
训练模型
EPOCHS = 60
值EPOCHS是一个设置为 60 的超参数。一般来说，时期越多越好，至少在模型稳定下来之前是这样。
#Only do plotting if you have IPython, Jupyter, or using Colab
只有在使用 IPython、Jupyter 或 Colab 时，才建议重复绘图，以便 matplotlib 绘图是内联的，而不是重复创建单个绘图。
for epoch in range(EPOCHS):
fig, axs = plt.subplots(4, 4)
rand = x_test[np.random.randint(0, 10000, 16)].reshape((4, 4, 1, 28, 28))
display.clear_output() # If you imported display from IPython
for i in range(4):
for j in range(4):
axs[i, j].imshow(model.predict(rand[i, j])[0], cmap = "gray")
axs[i, j].axis("off")
plt.subplots_adjust(wspace = 0, hspace = 0)
plt.show()
print("-----------", "EPOCH", epoch, "-----------")
model.fit(x_train, x_train)
首先，我们创建具有 4 行 4 列子曲线的曲线，并选择 16 个随机测试数据图像来检查网络的性能。
接下来，我们清空屏幕(仅适用于 IPython、Jupyter 和 Colab ),并在随机测试图像上绘制模型预测。
最后，我们训练模型。为了训练模型，我们简单地在训练图像数据上调用model.fit。还记得 autoencoder 的目标是如何获取输入数据，压缩它，解压缩它，然后输出输入数据的副本吗？这意味着输入和目标输出都是训练图像数据。
如你所见，这些生成的图像非常好。然而，这些图像最大的问题是模糊不清。这些问题中的许多可以用其他类型的生成网络或者甚至其他类型的自动编码器来修复。
完整代码
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Dense, Input, Flatten,\
Reshape, LeakyReLU as LR,\
Activation, Dropout
from tensorflow.keras.models import Model, Sequential
from matplotlib import pyplot as plt
from IPython import display # If using IPython, Colab or Jupyter
import numpy as np(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train/255.0
x_test = x_test/255.0# Plot image data from x_train
plt.imshow(x_train[0], cmap = "gray")
plt.show()LATENT_SIZE = 32encoder = Sequential([
Flatten(input_shape = (28, 28)),
Dense(512),
LR(),
Dropout(0.5),
Dense(256),
LR(),
Dropout(0.5),
Dense(128),
LR(),
Dropout(0.5),
Dense(64),
LR(),
Dropout(0.5),
Dense(LATENT_SIZE),
LR()
])decoder = Sequential([
Dense(64, input_shape = (LATENT_SIZE,)),
LR(),
Dropout(0.5),
Dense(128),
LR(),
Dropout(0.5),
Dense(256),
LR(),
Dropout(0.5),
Dense(512),
LR(),
Dropout(0.5),
Dense(784),
Activation("sigmoid"),
Reshape((28, 28))
])img = Input(shape = (28, 28))
latent_vector = encoder(img)
output = decoder(latent_vector)model = Model(inputs = img, outputs = output)
model.compile("nadam", loss = "binary_crossentropy")EPOCHS = 60#Only do plotting if you have IPython, Jupyter, or using Colabfor epoch in range(EPOCHS):
fig, axs = plt.subplots(4, 4)
rand = x_test[np.random.randint(0, 10000, 16)].reshape((4, 4, 1, 28, 28))
display.clear_output() # If you imported display from IPython
for i in range(4):
for j in range(4):
axs[i, j].imshow(model.predict(rand[i, j])[0], cmap = "gray")
axs[i, j].axis("off")
plt.subplots_adjust(wspace = 0, hspace = 0)
plt.show()
print("-----------", "EPOCH", epoch, "-----------")
model.fit(x_train, x_train)
这段代码的 Google Colab 可以在这里找到。
经过 60 个纪元的训练，我得到了这个图像:
Generated Image after 60 epochs
如你所见，结果相当不错。自动编码器成功地编码和解码了潜在的空间矢量，质量相当好。这种自动编码器是“普通的”类型，但是其他类型的自动编码器，如变型自动编码器，有更好的图像质量。此外，通过增加历元的数量，可以进一步改善结果。
自动编码器的用途
简单地说，自动编码器学习如何在没有监督的情况下有效地压缩和解压缩数据。这意味着自动编码器可以用于降维。自动编码器的解码器部分也可以用于从噪声矢量生成图像。
自动编码器网络的实际应用包括:
- 去噪
- 图像重建
- 图象生成
- 数据压缩和解压缩
如何让数据科学家开心
为了与您的数据科学家建立牢固的长期关系，并让他们在您的公司中保持愉快，需要关注 5 个方面
Photo by Luca Upper on Unsplash
虽然我们知道对数据科学家的需求很大，但似乎许多在该领域工作的人并不完全满意，并且每周花几个小时寻找不同的机会。虽然它没有关注数据科学市场，但最近的一项研究表明，千禧一代对公司的参与度较低，跳槽的倾向较高。总而言之，企业努力争取数据科学家，但往往难以让他们满意。
数据科学家想要什么，需要什么才能留在某个地方？
这是不是一种现象，没有一个地方会好得太久？我不认为数据科学家要求特别高，但这个角色涉及雇主和领导者在招聘和建立工作方式时需要考虑的必要性和挑战。
作为一名数据科学家，我确定了工作中对我的满意度和幸福感至关重要的 5 个部分。我把它们收集成 5c，这样更容易记忆。我相信它们适用于所有参与数据项目的数据专家，即数据科学家，但在某种程度上也适用于数据工程师、机器学习工程师&其他开发人员。
5 C
- 清楚
- 沟通
- 挑战
- 创造力
- 庆祝
免责声明:显然，所有数据科学家或个人总体上都是不同的，他们会更重视某一方面。这些方面只是从我自己的经历和我可能从其他数据科学家那里听到的经历中总结出来的。尽管如此，我真的相信这些 5c 对于为数据科学家创造一个良好的成长环境至关重要。
清楚
Photo by Markus Spiske on Unsplash
不要把不是数据科学的东西称为数据科学
我看到了太多的机会把数据科学/机器学习的旗帜竖起来引起关注，希望能让无数热情极高的申请者申请一个机器学习部分完全是海市蜃楼的职位。尽管这种方法在短期内会吸引很多人，但从长远来看，它会让公司付出巨大的代价，因为他们开始失去他们投入时间、培训和资源的受骗员工。尽管机器学习在工作机会中可能是一个非常性感的术语，但它只是数据世界的一个微小方面，大多数有经验的数据科学家都知道这一点。虽然这些术语可能看起来不那么光彩，但只要定义明确，数据分析、BI、数据质量或 Python 开发职位都没有错。
保持你的任务清晰或者寻求帮助来使它们清晰
在为一个项目建立一个问题陈述时，我总是喜欢有太多的细节和要求，而不是不够。在一开始不知道别人需要什么的情况下，你怎么能满足他们呢？我显然认为我知道利益相关者可以使用什么，以及什么对业务有意义，但是我对利益相关者面临的需求或要求感到惊讶。有一个清晰的画面帮助我交付正确的产品，并最小化要做的返工量，从而最小化要经历的挫折量。此外，如果对需要什么样的需求有疑问，利益相关者应该尽早与数据科学团队开始讨论，以便他们一起建立准确的问题陈述或任务。
沟通
Photo by Icons8 Team on Unsplash
在团队中，简单的沟通应该是最重要的
当我们想到它的时候，编程、数据科学、人工智能、人工智能、沟通技巧并不经常作为基本技能出现在脑海中。如前所述，项目从目标定义、期望和需求开始。缺乏透明度或糟糕的沟通可能是团队问题的核心，并且会以超乎你想象的速度发展问题。别误会，说多了不代表沟通清楚。我知道，我是极度活跃的法国南方人。我可以说 15 分钟，但什么也没说。尽管如此，我还是重视那些我可以自由表达对帮助或建议的需求的团队，而不是花 3 个小时失去理智，同时诅咒我的 Python 代码。
诚实和透明是稳固关系的关键
我想了很多关于将清晰和交流结合在一起的问题，因为它们有很多共同点。诚实和透明是良好沟通和清晰表达所需要的一些有价值的方面。然而，我非常关心我工作的沟通方面，因此它需要有自己的 c。无论如何，诚实和透明的领导可以对团队及其绩效产生奇妙的影响。根据《福布斯》一篇关于透明领导者的文章,透明能让关系更快成熟，因为开放能潜在地避免会加剧不必要紧张的误解
在您的团队中寻找数据翻译人员
我注意到，在大多数情况下，团队中的一些人比其他人更欣赏这份工作的沟通方面。我不知道我是否比其他人更适合，但我绝对喜欢演讲、讨论、聊天或建立关系网。认识到数据科学家的这种技能可以让团队或其领导者选择合适的人，当他们需要帮助时，他们会乐意与其他部门的利益相关者或团队领导讨论组织会议的任务。
挑战
Photo by Juan Jose on Unsplash
为成长和学习机会提供挑战
我非常重视挑战和复杂的项目。尽管它们会给我的生活带来一些压力，但它们让我快速成长，无论是作为开发人员还是数据科学家。此外，这样的挑战也让我走出自己的舒适区，拓展它的边界。复杂的项目可能是公司的一个弱点，因为它们需要大量的工作时间和奉献精神，经常会遇到意想不到的挑战，并且可能在数据和系统方面有多种依赖关系。然而，复杂性也可能允许公司进入一个新的、不同的和创新的领域，带着他们的团队一起前进。
只有那些敢于冒险走得太远的人，才有可能发现自己能走多远。—t·s·艾略特
庆祝
赞美团队中的差异和多样性
除了庆祝性别、年龄和种族差异，我真的认为不是每个数据科学家都应该在同一个地方有优势。除了最好的程序员，我还喜欢和最好的统计学家、最好的老师、最好的演示者和最好的“网络员”一起工作。认识到不同数据科学家、专家和工程师的不同品质，可以让你培养和利用团队中已经存在的品质，而不是只关注最薄弱的地方进行改进。
鼓励团队工作、团队聚会和团队活动。
根据我自己的经验，当人们真正欣赏彼此的陪伴(或者至少感觉到一点点联系)时，一个团队会运作得更好。他们可能会毫不犹豫地向对方寻求帮助，并且更容易在交流中保持诚实和透明。如果我领导一个数据科学团队，我肯定会鼓励午休，或者更好的是，我会强制整个团队都午休。我过去常常不吃午饭。我现在知道，只有当我在不适合我的环境中工作时，我才会这样做。如今，我的午休时间已经成了某种神圣的休息时间，如果有人试图在我的午休时间安排会议，我会很生气(除非他们提供免费午餐和一个非常好的理由)。).我只是很高兴能休息一下，享受我的食物，和车队聊聊天，即使是在繁忙的时候。
创造力
Photo by Iker Urteaga on Unsplash
“创造力”听起来就像这个我在编程和技术领域很少听到的罕见的古怪的词。我们经常听到创新、技术技能、分析技能，但创造力仍然是一种艺术形象，色彩、抽象的想法和音符，只属于音乐厅和美术馆。然而，我相信创造力在机器学习中无处不在，并且是所发现的最佳模型的核心。
为创造力留出空间
研究表明，工作自主对员工的满意度和幸福感有积极的影响。在我看来，自主也是创造力的先决条件，我非常感激被给予解决问题或回答问题的自主权。通过人工智能、数据可视化、数据处理、特征工程甚至数据清理，一个问题陈述往往有不止一个可能的解决方案，而最佳答案可能并不总是最明显的。构建一个在创新、可靠、高效、轻便和可解释之间取得平衡的机器学习解决方案通常需要大量的创造力。
"创造力包括打破既定模式，以不同的方式看待事物。"-爱德华·德·波诺，横向思维技术的发明者
实施 5c
围绕数据科学的世界仍然复杂多变，不可能简单地涵盖其所有方面，尽管我希望触及我在这 5 个方面经历的基本要求。此外，在一个企业或组织中应用所有的 5c 显然比简单地决定这样做要复杂得多。尽管如此，通过在任何数据科学项目、团队或管理的每个决策中牢记这 5 个要素，可以朝着正确的方向迈出一小步。
感谢您的阅读！
如果您想阅读更多关于改善数据科学家工作环境或如何面对数据翻译、数据科学、人工智能和领导力挑战的文章，请关注我的 中型 或 推特 获取通知。
如果你想阅读更多我的故事:
编程时 3 个简单的练习
towardsdatascience.com](/mindfulness-for-programmers-da6f92147b8f) [## 你能成为榜样吗？
STEM 领域的女性需要更多的榜样。但是如果他们已经在外面了呢？
medium.com](https://medium.com/swlh/can-you-be-a-role-model-68e52c9f759a)
如何让电脑做梦
生成模型的软介绍
“当一个人理解了原因，所有消失的图像可以很容易地通过原因的印象在大脑中重新找到。
这才是真正的记忆艺术……”
勒内·笛卡尔，私人思考。
闭上眼睛(当你试图说服人们阅读你的文章时，这是一个糟糕的开场白)，想象一张脸。
现在想象一只猫。一只狗，房子，汽车，水槽，一瓶啤酒，桌子，树。
这一切都在你的头脑中，很容易在你的内眼、内耳和内心世界中想象出来。但是你有没有想过，当你想象一个前所未见、前所未闻的东西时，会发生什么？
我们都有能力想出不存在的新奇事物。在电车上看到一则广告后，我们塑造了对未来的愿景，并突然体验到自己在遥远的土地上。
当我们晚上睡觉时，闭上眼睛，远离世界上所有的模糊事物和所有的感官输入，我们会梦见一个新的世界，里面住着和我们在现实生活中熟悉的人极其相似的人。
Salvador Dali: Dream Caused by the Flight of a Bumblebee around a Pomegranate a Second Before Awakening (fair use).
我们能从中学到什么
神经科学家和人工智能研究人员都意识到，我们如此强大的想象能力是我们智力的一个重要方面。因此，在构建类人智能时，对它进行建模可能是对我们工具箱的重要扩展。
但是我们能教机器如何做梦吗？这难道不是人类独有的东西，与计算机的精确和机械决定论如此不同吗？
答案是肯定的。看看这些快乐的人们:
George, Barbara, Aditya and Mikey, as imagined by a computer (via StyleGAN).
你可以看着他们，感受他们的生活。他们在哪里长大？他们上的是哪所高中？他们的性格是怎样的？他们是相当严肃的人，还是厚颜无耻的微笑的痕迹？
他们是你想象中的那种人。也许他们会出现在你的梦里。
问题是他们四个都不存在。它们完全是我五分钟前让我的电脑生成的虚构。 那是一台电脑想象出来的，就像你想象出来的一样。
这怎么可能？
不同程度的随机性
让我们后退几步。
图片由成千上万的像素组成，其中每个像素包含单独的颜色信息(例如，用 RGB 编码)。如果您随机生成一张图片(每个像素都是独立于所有其他像素生成的)，它看起来像这样:
A truly random picture. If you see a face in this, you should consider seeing a doctor.
如果你每秒钟都以这种方式生成一张图片，直到一张脸出现，你不会在几十亿年后更接近你的目标，当太阳在你脸上爆炸时，你仍然会生成图片。
大部分随机图片都不是人脸的图片，人脸的随机图片非常不随机。
潜在结构
每张脸后面都有一个潜在的结构。在这种潜在结构的范围内，有一定程度的灵活性，但它受到的约束要比不受约束多得多。
人类非常擅长理解潜在结构。我们不会根据像素来考虑人脸:我们会考虑嘴巴、鼻子和耳朵等特征，以及眉毛之间的距离(或没有距离)，我们会在脑海中建立一个抽象的面孔表示(更多信息请见我的文章思维的几何学)，这使我们可以很容易地想象一张脸，无论是在脑海中还是通过绘制。
总的来说，在世界中寻找潜在结构不仅对在世界中导航和交流非常重要，因此对我们的生存也非常重要，而且从某种意义上说，寻找潜在结构是所有科学实践的基石，可以说，也是智力的基石(正如我在关于为什么智力可能比我们想象的更简单的文章中所详述的)。
当我们从外部世界收集数据时，数据是由我们通常看不到的过程产生的。建立一个世界模型意味着寻找这些产生我们观察到的数据的隐藏过程。
物理定律，无论是牛顿定律还是薛定谔方程，都是这些潜在原理的浓缩、抽象的表现。就像牛顿的例子一样，意识到一个 落下的苹果遵循与行星 轨道相同的规律意味着理解这个世界比它看起来有序得多，随机得少。
生成模型
"我不能创造的东西，我不明白。"
理查德·费曼
生成模型的目标是学习一些输入数据 x 背后的潜在结构的有效表示(例如在我们的声音文件的大量人脸图片上进行训练)，理解控制其分布的规律，并使用它来生成共享输入数据 x 的关键特征的新输出x’
您的输入数据不是真正随机的这一事实意味着 x 后面有一个结构，这意味着有某些 非平凡(平凡只是随机点)概率分布负责生成数据 。但是这些概率分布对于高维输入通常是极其复杂的，并且通常很难解析出来。
这就是深度学习的救援之处，它已经一次又一次地被证明在捕捉数据中各种复杂的非线性相关性方面非常成功，并允许我们很好地利用它们。
生成模型可以采取许多形状和形式，但我认为 变型自动编码器 是一个非常有启发性的例子，所以我们现在将仔细看看它们是如何工作的。
潜在变量
一个变分自动编码器通常使用 两个深度神经网络构建。
第一深度神经网络 学习 输入数据 x 的潜在(通常是低维)表示。
它 将 这种潜在结构编码在 关于一些潜在变量的概率分布 中，我们用 z 来表示那么的主要任务就是在给定我们的数据的情况下，找到所谓的潜在变量的后验，在 概率论 的语言中写成 p(z|x) 。相应地，这个步骤被称为 编码器 。
请注意，这有点类似于 辨别神经网络 在监督分类任务中所做的事情:它被训练成在与标签相关的数据中找到结构，例如，允许它区分猫和狗的图片。
只是在生成模型的情况下，我们在寻找数据本身的概率分布，对于自动编码器，我们将其编码在潜在变量中。
对于技术上更感兴趣的人来说:实现这一点的一种方法是通过在潜在变量上引入一类近似先验分布(例如高斯分布的组合)并训练网络找到这些分布的参数(例如 表示 和 协方差 )，它们尽可能接近真实先验(由测量)
一旦模型已经学习了潜在变量 z 上的 概率分布 ，它可以通过从 p(z|x) 采样并执行第一个网络的反向任务来使用这一知识生成新数据x’，这意味着寻找由 p(x'|z) 给出的以潜在变量为条件的数据的后验概率。
换句话说:给定我们之前通过使用第一个网络了解到的潜在变量 p(z|x) 的分布，新数据会是什么样子？
这个步骤然后被称为 解码器 或 生成模型 。
我们可以通过同样训练一个 神经网络 将随机变量 z 映射到新数据x’上来构建它。****
总结一下 变型自动编码器 正在做的事情:
- 从输入数据中学习后验 x→z:p(z | x)****
- 从模型生成新数据 z→x ':p(x ' | z)****
The variational autoencoder. Credit to Chervinskii [CC BY-SA 4.0]
亥姆霍兹机器会梦到电羊吗？
“电器也有它们的寿命。这些生命是微不足道的。”菲利普·K·蒂克，机器人会梦见电动绵羊吗
这里缺少一个关键因素:我们如何训练生成模型？
这可能相当棘手。训练它们通常比训练有鉴别能力的模型要困难得多。因为在你自己创作之前，你真的真的需要理解一些东西:认识一首贝多芬的交响曲比你自己创作一首容易得多。
为了训练模型，我们需要一些损失函数来进行训练，并需要一个算法来实现它，同时需要训练多个网络。
最早的生成模型之一叫做 亥姆霍兹机器， 由达扬、辛顿、尼尔 于 1995 年开发。
亥姆霍兹机器可以使用所谓的唤醒-睡眠算法进行训练。
在唤醒阶段 ，网络从世界中查看数据 x，并试图推断潜在状态的后验 p(z|x) 。
在睡眠阶段 ，网络基于其内部的世界模型，从 p(x'|z) 中生成(“梦境”)新数据，并试图使其梦境与现实趋同。
在这两个步骤中，机器被训练以最小化模型的自由能(也称为“惊奇”)。通过逐步减少惊奇(然后可以通过梯度下降等方法合并)，生成的数据和真实数据变得越来越相似。
不同的生成模型
现代深度学习中使用了几种类型的生成模型，它们建立在亥姆霍兹机器上，但克服了它们的一些问题(例如唤醒-睡眠算法效率低下/不收敛)。
在上面介绍的 变分自动编码器 中，目的是尽可能好地重构输入数据。这对于实际应用非常有用，例如数据去噪或重建数据的丢失部分。它是通过最小化所谓的 ELBO(证据下限)来训练的。
另一个强大的方法是由通用对抗网络 (GAN)给出的，它被用来生成你之前看到的人脸。
在 GANs 中，在 生成模型 之上引入了一个 鉴别器网络 ，然后对其进行训练以区分其输入是真实数据 x 还是生成数据 x’。不使用编码器网络，但随机采样 z，并训练生成模型，以使鉴别器网络尽可能难以辨别输出数据是真是假。
请注意，生成模型背后的思想非常抽象，因此非常灵活。你可以在各种数据(不仅仅是图片)上训练它们，比如在时间序列数据上的递归神经网络(RNNs)，例如 fMRI 数据或来自大脑的尖峰脉冲串。在推断出数据背后的潜在结构之后，可以对训练的模型进行分析，以提高对大脑中潜在过程的理解(例如与精神疾病有关的动力系统属性等)。).
生成模型与认知
生成模型所能实现的已经令人印象深刻，但它们也能让我们更进一步了解我们的大脑是如何工作的。他们不仅被动地对世界进行分类，还主动捕捉其中的基本结构，并将其整合到模型本身中。就像我们都生活在我们大脑创造的自己的内心世界一样，生成模型创造了他们自己微小的内心世界。
正如贝叶斯大脑假说的支持者所说，这是我们认知器官的一个关键特征。我们的大脑不断建立潜在的内部表征，以某种方式反映现实世界的概率分布，但也简化它们并专注于最重要的事情(因为这个世界太复杂了，你的大脑无法完全模拟)。
在精神生成模型中，一旦你能创造出你知道它是如何运作的东西。因此，制造能够做梦和想象的机器可能会让我们在理解我们如何做梦和想象自己方面走得更远。
如何让 GDPR 和 ONA 合作？
unsplash.com
GDPR 和 ONA 相辅相成——如何运用 ONA 的见解，取决于组织的文化。
在网上搜索 ONA(组织网络分析)，你会得到各种各样的定义，包括那些带有卷曲的数学符号和图论。然而，简而言之，ONA 是关于组织中谁与谁沟通。
虽然 ONA 被认为是最近的流行语之一，但它至少可以追溯到 80 年代。1985 年，乔治·巴尼特和他的同事写了一篇文章，论述了 ONA 在组织层级中的不同层次。下面的摘要提供了更多的线索。
显然，在这个时候和以后，ONA 的隐私方面很少或没有关注。然而，随着《欧盟一般数据保护条例》(GDPR)的颁布，情况发生了缓慢的变化，然后变得更快了。由于已经有很多关于 GDPR 本身的文章和讨论，我们将不再深入探讨更多的细节。
ONA 在你的组织里！
ONA 是一个帮助组织在人员分析方面向更好的世界转型的工具。对当今 VUCA 世界的发展和采用感兴趣的组织都在。尽管如此，终端用户往往不愿意，表达了隐私问题。有一点是清楚的，每一种技术都可以用于好的或坏的方面，ONA 也不例外。
有些员工认为 ONA 的见解会对个人或职业造成伤害。这些员工直言不讳，讨论他们的隐私如何处于危险之中。然后，这些声音被工人委员会放大——都是以隐私的名义。然而，ONA 洞察使员工能够在他们自己的组织中产生影响，并实现个人发展。如何运用 ONA 的见解取决于公司文化或人力资源实践。这并不比耳语咖啡更糟糕——谈论对同事的专业和个人评价。事实上，对自己公司文化的恐惧是一些员工不愿意去 ONA 的核心原因。
这并不是说 ONA 不应该解决隐私问题，恰恰相反，企业和产品经理有责任在考虑隐私的情况下开发产品，用 GDPR 的话说，这叫做“设计和默认的数据保护”。
GDPR 要求用户明确同意开发 ONA 洞察。虽然 ONA 洞察可以通过未加入的员工比例来计算，但为了实现可接受和可靠的 ONA 洞察，需要足够数量的员工给予用户同意。因此，在开始实施和征求同意之前，提高贵组织对 ONA 的认识至关重要。
从根本上解决数据隐私问题绝非易事！
GDPR 的主要变化是，设计和默认的数据保护现在是一项法律要求。 ICO 指出:
“GDPR 要求您采取适当的技术和组织措施，以实施数据保护原则和保障个人权利。”
这种方法从基础设施一直到 UI。拥有如此广泛的实施焦点，这使得组织很难实施，尤其是在现有产品和服务的基础上构建。
幸运的是，GDPR 以匿名化的形式提供了高水平的解决方案，更重要的是假名化。 IAPP 将假名化定义为:
“从直接标识符中分离数据，以便在没有单独保存的附加信息的情况下，不可能链接到身份”
对于有隐私意识的产品实现，这意味着个人身份信息(PII)数据必须通过设计分离。显然，下一个问题是:PII 意味着什么？这个问题正在被定义——其中一个概念在这里被描述为 PII 2.0。然而，组织应该尽最大努力解决 PII 和隐私的话题 topic 教不明确的借口在法庭上对你的组织没有帮助。有各种各样的方法来解决 PII 和假名化问题，然而最好的方法是(尽可能地)结合安全性、加密和混淆。根据定义，PII 混杂因素是最难解决的，这篇研究论文显示了推断 PII 是多么容易。
关于假名化(假设您的组织已经尽可能好地解决了 PII 问题)，假名化数据的最安全方法是使用散列值、数据加密和应用所谓的深度防御方法。
如何对用于 ONA 产品的数据使用假名？
首先，需要实现深度安全或防御概念。纵深防御是:
美国国家安全局(NSA)构想的一种分层策略，作为信息和电子安全的综合方法。
在我们的案例中，这意味着 PII 的数据必须通过多层安全控制进行隔离，这使得 PII 的信息很难获取。这是通过实施不同的 VLANs、加密、散列、硬件分离、认证等来实现的。
一旦确定了 PII 油田并制定了深度安全措施，就可以采用以下技术步骤:
这些步骤可确保您的组织在设计和默认情况下尽最大努力解决数据保护问题，这是 GDPR 的法律要求。
作为概述，下图显示了上述内容的一个更广泛、更简化的版本:
与汇总统计数据和团队相关指标相关的 ONA 特性工作方式类似。隐私和 PII 问题更宽松，可以使用匿名。
结论
提供 ONA 相关的服务是可能的，也是可行的，这些服务是 GDPR 意识到的，并遵循最佳隐私惯例。最终用户的期望不匹配主要与对 ONA 的误解、内部文化、假设以及与数据隐私相关的负面情绪有关。组织中的文化成就或抑制了 ONA 的洞察力，而不是相反。后 ONA 阶段以及组织如何利用 ONA 洞察(和其他决策信息)必须是员工关心的问题。ONA 给员工提供了推动他们自己的兴趣和文化的方法，而不是抱着最好的希望，在喝咖啡休息或异地决策会议期间等待发生什么。
关于 ONA 在国际电影节的更多信息，请参见我们的系列文章。
圆周率怎么做
在今年的圆周率日，艾玛·相户爱·Iwao计算出圆周率为 31 万亿位，使之前 22 万亿位的记录相形见绌。从六年级开始，我就知道圆周率是 3.14 和一些变化。但是我开始想我们是怎么知道的？我们如何制作圆周率？
计算 pi 的位数有很多种方法——可以用随机抽样、几何、微积分等。但是我们为什么要在乎呢？如果你给我 pi 的前 39 位，我可以告诉你一个氢原子内已知宇宙的宽度(具体方法见 Numberphile 的视频)。我们真的需要 31 万亿吗？
嗯，不，可能不会。但这并不意味着这没有价值！为了生成这些近似值，我们使用了数学、计算机科学和计算机工程中的许多重要工具。我们需要处理关于浮点运算的准确性的问题，估计和误差界限的问题，以及关于优化的问题。所有这些都是有价值的，即使其他 30，999，999，999，961 个数字没有价值。
蒙特卡洛方法
我们将从蒙特卡罗方法开始。这些方法依靠随机抽样来生成数字结果。出于我们的目的，我们将对 X-Y 平面中的点进行采样。我们来看看下图。有一个半径为 1 的圆内接在正方形上。这个正方形的边长正好是圆的直径，也就是 2。
A circle with radius 1 and center (1, 1) inscribed in a square with side length 2
现在，假设你和我在玩一个游戏。我们随机选取一个 0 ≤ x ≤ 2 和 0 ≤ y ≤ 2 的点 (x，y) 。如果点在圆圈里，你就赢一美元。否则，我赢一美元。橙色是你赢的地方，蓝色是我赢的地方。你赢得一美元的几率有多大？它是橙色圆圈的面积与总面积的比率。圆的面积是A = pir = pi1 = pi总面积是正方形的面积 A = s = 2 = 4。所以，赔率是( pi / 4) ≈ 78.5%。胜算大！
所以，如果我们取一堆点，看看落在圆内的点的百分比，我们可以估计出 pi (这里是为什么)。这种随机抽样正是我们的蒙特卡罗方法。下面的代码采样一千万、一亿和十亿个点来计算圆周率。
An implementation of the Monte Carlo method using Python. Source code here.
结果如下。
Monte Carlo method results
那还不算太糟！在我的电脑上，十亿次迭代大约需要半个小时。它给出了对π的估计，只差 0 . 00007。但是我们远没有产生 31 万亿位的圆周率。幸运的是，我们有很多其他方法可以尝试。
微积分方法
我们知道半径为 1 的圆的面积是A = pi**(1)= pi。太好了！让我们计算半径为 1 的圆的面积。但是我们到底如何计算面积呢？我们可以用积分来解决这个问题。看一下下图。它是以 (0，0) 为圆心，半径为 1 的圆的右上部分。这个圆的方程式是 x + y = 1。然而，我们只关心 x 轴上方的部分，因此我们可以将公式重新排列为下方的公式。
The top right of a circle with radius 1 and center at (0, 0)
由于整个圆的面积是 pi ，那么上面的面积就是 pi / 4 。我们可以从 0 到 1 积分，结果将是 pi / 4 。但是，再一次，整合一个函数到底意味着什么？积分源于波恩哈德·黎曼(1826 年)提出的黎曼和。黎曼求和允许我们通过对曲线下的矩形求和来近似积分，如下所示。我们使用的矩形越多，近似值就越好。
Riemann Sums (Images from Khan Academy)
下面的代码使用黎曼和的方法来近似我们的圆下面的面积。这个近似值等于 (pi / 4)。更多关于黎曼和的内容，请看这里。
Implementation of the Riemann Sum Method with Python. Source code here.
结果如下。
这无疑是对我们以前方法的改进！在相同的迭代次数下，我们为自己多买了几个正确的数字。但是我们可以做得更好。
无穷级数方法
这个无穷和的想法似乎是可行的，所以我们将继续沿着这条路走下去。从三角学我们知道tan(π/4)= 1。我们现在可以使用反正切函数 arctan(x) 来计算 arctan(1) = pi / 4 。幸运的是，我们有一个简单易行的公式来计算 arctan(x) 。这种方法也被称为格雷戈里-莱布尼茨系列或马达瓦-格雷戈里系列，以戈特弗里德·莱布尼茨(1646)、詹姆斯·格雷戈里(1638)和桑加玛格拉玛的马达瓦(1340)命名。
Summation Formula for arctan(x)
我们可以设置 x = 1 ，让下面的代码运行。
Implementation of the arctan(x) method with Python. Source code here.
结果是朝着正确的方向迈出了一步！对于十亿次迭代，我们得到的数字比积分法多一位。
Results of arctan(x) method
我们可以继续这种方法，做一些改进，并得到明显更好的结果。一个改进来自约翰·麦金(1706)，他发展了下面的公式。Machin 对这个公式的推导超出了本文的范围，但是可以在这里找到。
Machin’s formula for estimating pi
Implementation of Machin’s Formula with Python. Source code here.
结果如下。确保记下迭代的次数。经过 10 次迭代，我们的估计和上面一样好。我们在第 1 部分中的蒙特卡罗方法花了 10 亿次迭代去做 Machin 公式在第 3 部分所做的事情。
Results of estimation using Machin’s Formula
但是，正如你可能猜到的，我们仍然可以做得更好。
一种改进的无穷级数方法
我们看到的最后一个无穷级数来自杰出的数学家斯里尼瓦瑟·拉马努金(1887)。Ramanujan 写了两个计算 pi 的公式。Chudnovsky 兄弟，Gregory (1952)和 David (1947)也改进了 Ramanujan 的初始公式。
Ramanujan’s and Chudnovsky Brothers’ formulae for estimating pi
下面的代码是 Chudonovksy 公式的一个实现。
Implementation of Chudnovsky formula with Python. Source code here.
在一次迭代后，该公式将 pi 精确到第 14 位数字。随着每一次连续的迭代，该公式会生成 14 个以上的正确数字 pi 。经过三次迭代后，我们就可以计算出一个氢原子内宇宙的宽度了。
这个公式是每一个现代圆周率计算记录的基础。常见的实现使用的是 y-cruncher ，这是一个设计用来高效计算 pi 的软件。
结束语
我们已经研究了 4 种不同的策略来生成pi——随机模拟、积分、三角函数和无穷级数。估计问题现在看起来可能微不足道，但那只是因为我们可以在现代笔记本电脑上运行十亿次迭代。在历史上的大部分时间里，找到准确的估计值需要巧妙的公式，而这些公式在计算上并不昂贵。现在只需要 Python 一个半小时。
这些只是制作圆周率的几种方法。如果你想做派，皮尔斯伯里有一篇很棒的文章在这里。
如何理解混乱的表格数据
Python 的滤镜和。拆分函数是您对抗格式不良的数据集的盟友
您是否曾经不得不打开一个格式错误的数据集？那种有人拼凑并打印出来的数据集，没有想到也许， 也许， ，有人可能想以后自己打开这些数据并进行处理？
浪费时间，多长出几根白头发，这是一种奇妙的方式，不是吗？
幸运的是，Python 提供了大量的工具，可以让您的生活变得更加轻松。您可以使用这些可用的工具，以一种易于使用的方式重新格式化数据集，无论它一开始是否格式化良好。
这个问题有什么例子？
在这个例子中，我们来谈谈保存在。txt 格式。不在。csv 或其他对保存数据集有意义的格式。作为一个文本文件，中间留有足够的空间，使值排成一行，并显示为表格。
以图 1 中的数据为例。这是我专门为了演示这个概念而编造的样本数据。如果物理环境对你很重要，假装它是显示水-水热交换器性能的数据。器件的热端和冷端都有流量，器件两侧都有入口和出口温度测量值。
Figure 1: Scientific Data Presented as a Text File
你知道是什么让这个数据集令人讨厌吗？这是一个文本文件。数据集之间没有逗号分隔，因此不能将其视为 CSV。不，它也不是制表符分隔的(尽管从图中看不出来)。将值输入到表中，然后添加足够的空格以确保所有内容都对齐。
作为数据科学家，我们希望加载这些数据，并尽快处理它们，但是数据集的格式存在延迟。我们如何快速简便地将它转换成可用的格式？借助 Python 的滤镜和的力量。拆分功能！
我如何使用过滤器和？拆分以使其成为可管理的数据集？
T 读入 Python 的 ext 文件对象有T3。()功能可用。这是一个非常有用的函数，正如它所说的那样。每当指定的分隔符到达时，它就拆分一个文本块。如果希望文件在有逗号的时候被分割，可以调用。split('，')(不过我还是建议把它们打开。csv 文件代替)。如果您想在看到代码字时拆分文件，您可以输入该代码字作为分隔符。如果您有一个使用未指定数量的空格进行格式化的文本文件，您也可以对其进行格式化。这就是我们需要对图 1 所示的示例数据做的事情。
为了解决这个难题，我们首先需要在有空间的时候分割数据。这将产生一个包含所有数据点的列表，保持数据点的完整性。这个。split 函数需要按顺序应用于表中的每一行，以便将数据保持在所需的格式。假设数据文件是打开的，并且存储在一个名为 Contents 的变量中，我们可以使用下面的代码:
for i in range(1, len(Contents)):
Row = Contents[i].split(' ')
每当上面的代码找到一个空格时，它将拆分每一行的数据。这是一个很好的步骤，提供了一个包含所有最终数据的列表。不幸的是，由于每个分隔符中有任意数量的空格，脚本有时会在列表中返回空值。
要解决这个问题，我们可以使用 Python 的 滤镜 函数。要使用过滤器，我们只需向它提供我们想要使用的过滤器，以及我们想要应用它的数据集。当调用 filter 函数时，您可以创建任何您想要的过滤器，这使得它非常灵活和有用。如果我们想从列表中删除所有空值，我们可以利用可用的 filter 命令 None 选项。这消除了所有的空白空间，不需要我们额外的努力。最后，我们需要将过滤后的结果输入到一个列表中(否则 Python 的过滤器不会返回实际数据。然后，代码显示为:
for i in range(1, len(Contents)):
Row = list(filter(None, Contents[i].split(' '))
这个过程的结果是什么？
这个过程的结果是，每个数据点之间的所有空白空间现在都被移除，并且有意义的数据点现在作为列表可用。你可以随意使用这份数据清单。如果您准备好直接对这一行数据进行数据分析，您可以这样做。
然而，我通常不喜欢走那条路。我喜欢尽可能频繁地保存中间结果，以防以后我想返回到该文件并将其用于其他目的。为此，您需要在处理数据框时按顺序将每一行数据添加到数据框中，并使用有意义的名称保存数据框。在自动存储来自分析数据集的结果中描述了这样做的技术。
为了更好地讲故事，如何制作令人惊叹的 3D 情节？
在我们开始之前，这不是 2D 与 3D 图之间的战斗，也不是声称 3D 图优于 2D，因为它有一个额外的维度。事实上，我是那些试图避免给一个情节添加太多以至于情节失去其本身情节的人之一。但是有些情况下，你知道你可以通过使用 3D 情节更好地讲故事。这篇文章是为了帮助你在这些情况下！
查看 78%的 DataCamp 折扣
以正确的方式为正确的目的构建的 3D 图总是令人惊叹。在本文中，我们将看到如何使用ggplot2和rayshader用 R 制作令人惊叹的 3D 图。虽然ggplot2可能为数据科学领域的任何人所熟悉，但rayshader可能并不熟悉。那么，让我们先来简单介绍一下rayshader。
来自[rayshader](https://github.com/tylermorganwall/rayshader):的包装说明
rayshader 是一个开源包，用于在 R 中生成 2D 和 3D 数据可视化。 rayshader 使用基本 R 矩阵中的高程数据以及光线跟踪、球形纹理映射、叠加和环境遮挡的组合来生成美丽的地形 2D 和 3D 地图。除了地图， rayshader 还允许用户将 ggplot2 对象转换成漂亮的 3D 数据可视化。
所需的库/包:
最新版本的[rayshader](https://github.com/tylermorganwall/rayshader)可从 github 上获得，可以使用devtools或remotes安装。
devtools::install_github("tylermorganwall/rayshader")
并且，确保你已经获得了最新版本的ggplot2。如果你是一个爱潮流的人，那就买最新的吧。
install.packages('tidyverse')
数据
为了保持这篇文章的最低要求，我们将使用ggplot2库中的一个内置数据集faithfuld。
> glimpse(faithfuld)
Observations: 5,625
Variables: 3
$ eruptions <dbl> 1.600000, 1.647297, 1.694595, 1.741…
$ waiting <dbl> 43, 43, 43, 43, 43, 43, 43, 43, 43,…
$ density <dbl> 0.003216159, 0.003835375, 0.0044355…
如你所见，faithfuld有 3 个连续变量，我们将用它们来绘图。
2D 图
我们的 3D 绘图之旅从普通的 2D ggplot2 绘图开始。我们将使用 geom_raster 在waiting、eruptions之间构建一个密度图，以查看数据情况。
faithful_dd <- ggplot(faithfuld, aes(waiting, eruptions)) +
geom_raster(aes(fill = density)) +
ggtitle("3D Plotting in R from 2D_ggplot_graphics") +
labs(caption = "Package: rayshader") +
theme(axis.text = element_text(size = 12),
title = element_text(size = 12,face="bold"),
panel.border= element_rect(size=2,color="black",fill=NA)) faithful_dd
正如你在上面的代码中看到的，随着情节的展开，我们对情节的外观做了一些美学上的改进
嗯，这很好，但这是我喜欢以 3D 形式显示一座小山的地块之一，事实上，是两座小山。因此，让我们推进到一个三维绘图。
从 2D 情节到 3D 情节的旅程——一条线！
从 2D 情节到 3D 情节的旅程，只是来自包rayshader的一行额外的代码。函数plot_gg() 采用一组参数来定义 3D 绘图的外观。
plot_gg(faithful_dd, multicore = TRUE, width = 8, height = 8, scale = 300,
zoom = 0.6, phi = 60,
background = "#afceff",shadowcolor = "#3a4f70")
faithful_dd是我们在上一步中生成的 ggplot2 对象。因为大多数参数都是不言自明的，比如在渲染时激活计算机的所有内核。像zoom和phi这样的参数用于设置 3D 摄像机视图应该在哪里。
让我们来看看生成的图:
看起来是不是很美？这些不仅仅是惊人的，而且是有目的的。想象一下，你要解释梯度下降或一些优化算法，像这样更直观和自我解释，以获得一个心理模型。
还有一件事！
这个故事不仅仅以一个 3D 情节结束，但开发人员(泰勒·摩根-沃尔)非常友好地给了我们另一个功能render_movie()，它放置了一个相机，并围绕我们刚刚建立的 3D 情节旋转，给了我们一个令人惊叹的 3D 情节视频。render_movie()内部使用av包制作视频。
render_movie("faithful_3d.mp4", frames = 480)
摘要
感谢泰勒，现在我们可以从 2D ggplots 制作出令人惊叹的 3D 绘图——只需使用一个额外的函数plot_gg()最终甚至可以制作 360 度的 3D 绘图视频。在 R here 和 rayshader 文档中了解更多关于数据可视化的信息。这里使用的代码和 sessionInfo 可在这里获得。
如何确保你的“好主意”奏效
我们如何保持“数据科学”中的“科学”？
Photo by Gregory Jacquet on Unsplash
这是很常见的事情。我们的高层领导参加完一个会议——上帝保佑，一个“异地战略会议”——回来后，满脑子都是改善组织的好主意和方向。等等…不要翻白眼，这些绝对可以增加价值，设定重要的视觉！
然而，以我的经验来看，这些新想法与公司以前的做法相比，有时是激进的。“不用担心。”我们想，“我们就做个试点研究吧！”
在你的一生中，你见过多少“飞行员”除了看他们是否真的可以建造，以及人们对他们有“积极的感觉”之外，从来没有被真正评估过？我们对此有一个术语，它是概念验证…而不是试验。
当我谈到评估时，我真正想让你想到的是测量新过程、项目或计划的输入、输出和结果的严格组合，以便与预先建立的基线和期望进行比较。度量可以是定量的，也可以是定性的(通常最好的评估是两者都是)。
将评估与 KPI 和绩效衡量区分开来的是规划评估的基础工作。理想情况下甚至在试点实施之前。
数据科学评估
我不是在谈论评估你的模型的准确性或潜在偏差，尽管这些都很重要。我想讨论一些我现在在行业中没有看到的东西:我们如何评估我们的数据科学项目的结果。
我们在数据科学中可能不会经常看到这种情况，因为它在组织的许多其他领域并不常见。
通常我们更关注“好主意”和“好主意”的实现，而不是关注我们如何测试这个主意的实际结果。我说的也不是产出，而是结果。如果你不知道这两者的区别，那么请继续阅读。
好吧，那我们怎么做？
第一步是非常清楚计划的预期目标和结果。你希望实现什么？这不仅仅是点击量、页面访问量或正确的面部识别匹配。结果就是为什么这些事情很重要…增加销售额，更高的回复率，更多的用户注册。
对结果有一个好的感觉，以及你如何相信你会实现它们，让你理解你的程序理论。程序理论是你的输入、输出和结果之间的因果联系。
它还确定了在评估过程中应该考虑的潜在子群和偶发事件，例如预期对计划有不同行为或反应的特定子群，这些子群需要以不同的方式进行评估和比较。当你决定如何度量它们时，它还会让你反思并测试你对程序理论步骤和因果关系的理解。
例如，让我们来看一个试点项目，它自动将你的新媒体故事的链接发送到带有多个标签的 twitter。在这个例子中，你寻求的结果是你的媒介故事的额外阅读和阅读时间。然而，该计划的目标(我希望)是创造一个更有见识的读者群。
试点项目的产出实际上可能是文章浏览量的增加，你的故事链接的推荐量的增加，以及关于你的故事的 twitter 流量的增加。输入内容显然是你的故事，以及自动发布和散列标签。
理解了你的程序变化理论，你就可以开始识别可能有不同反应的子群。你有没有那些只关注 Twitter 的读者，他们的反应与那些关注你或以不同方式看到你的文章的读者不同？
如何设计一个好的评估:
- 收集主题的背景信息——包括对因果理论和其他实验的研究。
- 评估可用数据源的相关性和质量。你能获得有效和准确的数据，并允许你回答程序理论所确定的问题吗？
- 如果对上述问题的回答是否定的，那么必须有一个用于评估的原始数据获取计划。这个应该作为你项目设计的一部分来完成，但也可以在事后完成。
- 必须根据评估的目标和试图回答的问题来选择评估标准。
- 如果由于种种限制，不能对整个群体进行研究，那么选择一个观察样本是很重要的。注意此阶段外部有效性的风险。
- 这有点“元”，但是对数据收集和分析进行试点测试，以确保在纸上看起来可行的东西可以在野外进行。当新的数据收集很昂贵时，这一点很重要。
两种主要类型的评价:形成性和终结性
现在著名的比喻是厨师做汤。形成性评价是她一边准备汤一边品尝，终结性评价来自客人吃完汤之后。
这里的主要观点是，形成性评估关注于实施，因此评估的目标是评估项目对需求和政策的遵守情况，并测试它们实施的有效性。形成性评价侧重于评价输入和输出。
总结性评估关注的是结果以及你在哪里实现了项目的目标。这通常需要更长的时间，并且更加难以识别和收集必要的数据。内部有效性及其面临的风险在此阶段应予以密切关注。
评估的目的——形成性
"该计划正在按计划实施吗？"这里用作评估结果的基线是计划的预期或所需的特性。这些通常可以在法律、法规、政策和程序指南、合同或其他说明中找到。
这些还包括可行性或管理问题，这些问题在早期阶段(通常)识别挑战、问题或顾虑，可以解决这些问题以更好地使计划按预期实现。
明确地说，你可以进行形成性评价而不进行终结性评价，但是如果不首先进行形成性评价，你就不能进行有效的终结性评价。
这是因为你需要知道该计划是按计划实施的，以便测试它是否产生了预期的结果。在我们的例子中，如果程序没有准确地添加想要的散列标签，那么你真的不知道你的项目是否能够增加读者群，或者最终它是否能够增加你的读者的知识。
如果是这种情况，评估可以侧重于未能按照要求实施的原因，如是否缺乏资源、知识/能力、参与者目标错误或未能设定适当的基准。
可以解决目标人群与实际人群的早期迹象，包括调查为什么这些可能不同。可以根据项目需求对挑战和障碍进行识别、分类和变更。
评估的目的—总结性的
"项目是否产生了预期的结果和目标？"，或者更常见的是，“为什么计划没有达到预期的结果？”问题是通过总结性评价来看的吗？
重复我们之前讨论的内容，在这个阶段要认识到你的数据来源和收集方法。通常，你现有的数据不足以衡量这些目标。太多的组织在这一阶段失败了，相反，他们决定只度量什么是可用的，因此从来没有真正了解他们的项目是否成功。
在我们的例子中，媒介为我们提供了一些关于结果的信息，但不是全部。当我们想出如何衡量我们的目标时，我们必须有创造性。也许我们会要求我们的读者做一个跟踪调查或小测验来衡量通过我们的文章获得的知识。
评估设计的最后一个关注点——你的受众
还有一个要记住的重要因素，当你的团队需要设计和实施科学合理的评估时，你也需要考虑你的观众的需求和期望的目标。
在大多数情况下，这主要是您的组织的领导。确保你的评估设计符合他们对项目目标和成功的理解。获得他们的共同理解和认同对于进行有效的评估至关重要，对于根据形成性评估和总结性评估的结果做出任何必要的修正也是如此。
如何做到这一点的一些提示:
(1) 平衡及时性&相关性 —确保评估彻底并能够评估结果/目标，但又足够及时以保持利益相关方参与并允许他们做出必要的更改来纠正实施中的问题。
弥合这一差距有助于关键员工理解变化或行动如何影响计划的实施，而不会因为反馈滞后而过度纠正。
(2) 关于事物如何运作的假设 —这是一个困难的认知问题，需要所有利益相关者解决，包括评估者。如果人们认为他们已经完全理解了一些东西，他们就很难接受甚至理解与他们的信念不符的信息。
意识到这一点并找出对策是很重要的。例如，让项目人员和领导参与确定项目理论可以帮助突出这些假设，但让他们基于反事实创造替代理论可以使他们在数据需要时以不同的方式解释事情。
(3) 防御惯例和情绪反应——是帮助我们保护我们坚定信念的行动，例如设计允许单方面控制的情境或反驳不一致的信息。这些防御行为之所以会发生，是因为我们做出了跳跃性的推理，让我们能够过滤掉与我们的信念相冲突的不一致的信息。
我们从事基于假设的行为，在这种行为中，我们与他人的交流是基于将我们的信念投射到他们身上，这阻碍了我们真正理解他们在说什么的能力。意识到这些潜在的陷阱在评估中是有用的，理解信息和对立观点的不适是一面旗帜，应该提醒我们质疑自己的假设和信念。
最后，这听起来很难。但是，让你的数据科学团队成员了解所涉及的方法问题，可以确保你的团队真正实现他们设定的目标。不进行这些评估的代价总是大于不进行评估的代价。
如何充分利用您的第一次数据科学训练营
一切都归结于准备、时间管理和对唯一重要目标的不懈关注——为工作做好准备。
数据科学训练营继续吸引着稳定的职业生涯中期的专业人士和学生，尽管正在就此类课程的质量和实用性进行辩论。
自从 5 月底在 General Assembly 完成为期 12 周的数据科学课程后，许多朋友和前同事问我这样的训练营是否值得参加。
坦率地说，直接回答这个问题是不可能的，因为有太多的个人因素在起作用。
你的年龄、经济状况、家庭状况和职业道路都在这个决定中起着关键作用。试图建立一个支持或反对参加训练营的普遍案例是徒劳的。
例如，如果你像我一样 45 岁左右，训练营是唯一可行的选择。大学或理工学院的冗长课程是不现实的，因为当你毕业时，你已经接近或超过 50 岁了。
如果你还在考虑是否报名，我唯一的建议是研究训练营的导师，而不是担心选择哪所学校。一个好的教练会让变得与众不同。如果组织者软弱或不感兴趣，一所外表华丽的学校就没有多大意义。
对于那些已经报名或决定加入数据科学营地的人，这里是我关于如何充分利用它的实地笔记。
#1:提前准备
在训练营中，你可能犯的第一个也是最致命的错误就是认为你可以把严肃的学习留到课程开始的时候。你不能，因为训练营的重点是课程，而不是学生。
坦白地说，大多数训练营的主题数量之多令人疯狂，只有几天时间专注于核心领域，如统计学、熊猫和可视化图书馆。如果你落后了，教练不能也不会放慢速度。如果你已经在前几周落后了功课，你很可能永远也赶不上了。
那么应该提前做多少准备呢？这取决于你的教育和工作背景，以及你对自己的诚实程度。
首先，我建议你在留出课前准备的时间时，考虑几个月，而不是几周。
我花了大约 5 个月的时间准备我的课程，期间我参加了 Codecademy 和 Data Quest 的在线课程，并在导师的指导下学习。五个月的时间听起来可能有点多余，但是如果你像我一样没有编码背景，那么坦白地说，五个月的时间并不足以从头开始讨论关键主题。
当我在 2019 年 3 月开始上课时，我已经完成了一个简单的、自我分配的关于新加坡天气模式的分类项目。但即使在那时，每天都要努力跟上课堂的紧张节奏。如果我没有花几个月的时间自己复习基础知识，这将是一场彻底的灾难。
部分问题源于这样一个事实，即大多数学生期待传统的课堂体验，并且不熟悉训练营的运作方式。所以当课程以每小时 100 英里的速度向前推进时，每个人都震惊了。
根据我所看到的，训练营根本不适合教你基础知识。相反，它们被设计来加速你在自己的时间里已经在做的事情。
从这个角度来看，做好充分准备并不是像我们在新加坡所说的“怕输”。相反，它是关于确保你在你的学习旅程中得到最大可能的推动。
#2:抑制你的(过度)热情
信不信由你，你会遇到一些同学，他们认为在已经塞得满满的课程之外钻研深度学习是个好主意。如果你是个天才，那就想尽一切办法去做吧。但是如果你像我一样是一个经常学习的人，不要屈服于“害怕错过”，或者他们所说的 FOMO 。
原因虽然显而易见，但对于过于热情的学生来说并不总是显而易见的——学好基础知识已经够难了。
数据科学本质上是多学科的。你可能擅长编码或统计，但你不太可能同样擅长解决业务问题、为普通读者可视化数据或向不安的观众清楚地展示你的工作。
专注于拓展训练营试图传授的技能范围，而不是渴望那些没有传授的技能。这就是课程结束后你剩下的时间要做的事情。
对抗 FOMO 浪潮的最有效的现实检验之一是定期阅读入门级数据科学职位的招聘信息。一两周之后，你会注意到，与深度学习相关的所有东西在网上的热度，与雇主(至少是新加坡的雇主)在入门级员工中寻找的东西——SQL、数据清理、可视化技能和基本的机器学习知识——之间存在明显的脱节。
当然，拥有一些关于深度学习发展的对话级知识是很好的。但是不要贪多嚼不烂，除非你打算 12 周不睡觉。
#3:时间管理
Time, like traffic in some parts of the world, is relative.
上面这幅半开玩笑的插图是为了取笑行人如何处理越南混乱的交通。但这也是对训练营开始后一些学生扭曲的时间观念的准确描述。
训练营的时间会比你想象的要快，12 周左右的时间并不能转化为学习自然语言处理等沉重话题的大量时间。你还必须完成几项主要作业，包括课程结束时的一个展示项目。
然而，有些人会陷入自以为还有时间的陷阱，而事实上他们没有。
对于展示项目来说，时间的缺乏成为一个特别大的问题，它需要比通常留出的两周时间更多的时间来研究、计划和执行。如果你最初的想法失败了，留给 B 计划的时间也很少。
在训练营开始时，你的导师会尽职尽责地告诉全班同学，他们应该为他们的最终项目提出一两个想法，并开始研究如何获得项目所需的数据。
除了认真对待这些建议并付诸行动，我想不出更好的方法让你在训练营期间生活得更轻松。
我从一开始就知道我想为我的展示项目做什么。许多繁重的工作，如 T2 的清理、清理和格式化成千上万的推文，被分散到训练营的前几周。当项目主题——关于 Twitter 上国家支持的虚假信息运动——被批准时，我已经准备好了数据和项目大纲。
在训练营期间将你的项目管理技能付诸实践。这都是关于管理潜在失败的风险，给自己足够的缓冲来应对意外事件——如果你在第 10 周开始你的最终项目，你就不会有这些了。
#4 工作就绪
在我参加的训练营，没有考试，也没有毕业时要公布的最终成绩。相反，学校的重点是帮助学生在毕业三个月后找到一份工作——这很适合我们大多数人。
但是你会惊讶地发现，一旦每天枯燥的讲座/实践/项目开始了，就很容易忘记这个至关重要的最终目标。
当你的求职进入高潮，你正在回顾你的项目(在整个课程中你可能会被分配到其中的 3 到 4 个)，看看你可以向潜在的雇主展示什么作为你的技能和知识的例子时，这一点变得非常突出。
您可能会对第二轮在 Github repo 中发现的内容感到震惊。在绞尽脑汁、辛辛苦苦地完成一个家庭或工资价格预测项目后，很自然地会想把笔记本扔到 Github 上，然后继续前进。
这的确是一种宣泄，但也是有代价的。
作为一个在数据科学行业没有正式工作经验的人，这些不同的项目工作是你在求职面试中可以展示你的就业能力的少数几件事情之一(除了你的其他书面资格)。
虽然期末(或顶点)项目被宣传为你能力的主要展示品，但对于那些希望看到你更多作品的要求更高的雇主来说，这可能还不够。
我的建议是:认真对待较小的项目，把它们当作你可以在未来的工作面试中使用或重新包装成“工作样本”的东西。这可能涉及到构建一个简单的 web 应用程序，该应用程序利用了您已经构建的机器学习模型。或者你可以通过 Tableau 这样的平台巩固和提高你的数据可视化成果。
毫无疑问，当你在与大量的课程材料作斗争的时候，很难去想那么远。但长期回报是值得的。我当然希望我从一开始就这样对待我的项目工作。
至少，确保你的 repos 和 Github 账户组织有序，每件作品都有清晰的描述。
如果你告诉自己，在训练营结束后，你会清理混乱的回购或重构代码，你可以相当肯定这永远不会发生。从一开始就做好这件事，你就可以省去一大堆的悲伤。
我对训练营的经历有疑虑吗？毫无疑问。但那是以后的事了。
就像他们说的，与其生气地回头看，不如向前看。如果您有具体的疑问，请随时通过以下渠道联系:
领英:https://www.linkedin.com/in/chuachinhon/
推特: @chinhon
如何让您的数据科学演示精彩难忘
Photo by Taylor Grote on Unsplash
还记得上一次启发你的数据科学演讲吗？你认为给人留下深刻印象的那个。吸引你注意的仅仅是数学术语还是最先进的精确度？
肯定不是。有效的演示技巧在将想法传达给更广泛的受众方面发挥着重要作用。对于任何研究人员来说，掌握令人难忘的演讲技巧都是至关重要的。
出色的演讲有助于你为你的研究和你自己建立一个品牌，这将极大地指导你的学术或职业前景。
T 他的文章会引导你了解一些关键点，这些关键点会让数据科学研究演示更加有效。我首先讨论五个一般性的想法，然后深入一个要点，那就是你演讲的故事情节。
- 结构好。一个好的演示文稿会一步一步地带领观众踏上旅程。在你前进的每一步，你的想法都应该向听众展示一个清晰的最终目标。一个常见的结构总是从介绍你自己和你的研究问题开始。重要的是一开始就设定一个清晰的场景，这样你就可以从那里开始你的故事。故事情节，事实上是一个好的演示文稿最重要的特征，将在后面的文章中详细讨论。
- 专业幻灯片。幻灯片强化了你的故事。你不能低估高质量幻灯片对观众的影响。在这里，重要的是要记住，你的听众在听你演讲的时候会倾向于阅读你幻灯片上的所有内容。所以明智地选择你想要的幻灯片。否则，它会分散你的听众的注意力，最终使他们迷惑。幻灯片上的大量文本通常不是一个好主意。事实证明，有效的图形能够抓住注意力，帮助清晰理解。尽可能保持你的幻灯片整洁。
- 技术贡献。任何研究的最终目标都是你对一个行业或知识的贡献。所以你要强调你在工作中所能做出的技术贡献。同样，这是你故事情节的重要部分，在这篇文章中会进一步讨论。
- 清晰有趣的传递。不管你的材料有多好，你的表达方式将决定你的演讲是否会让人难忘。清楚和正确地使用语言与良好的发音和相位一样重要。确保每个人都能听到你，不要忘记微笑。
- 自信的演讲者。有些人可能会认为自信取决于每个人的性格，但有些因素可以帮助你在演讲时提高自信水平。在这里，演讲前的充分准备是最重要的。确保你在上台前至少练习几次演讲。相信我，这不会浪费时间，而且会比你想象的更能增强你的自信！
基调的故事情节
现在，让我们来关注准备和提交研究报告时最重要的一点，故事情节。这决定了在整个演讲过程中你会有多少只耳朵。
以下是您希望按顺序构建的关键领域。当然，根据你的喜好，有些主题是可以互换的，但是如果你正在寻找一个指导你准备演讲的大纲，这是一个有效的大纲。
- 设定场景。这应该是首要目标。你在研究中要解决的问题是什么？为什么它是及时的、相关的和有趣的？为什么重要？让这个场景非常清晰，你就抓住了观众的注意力。它应该成为你想要传达的东西的基础。以及你努力的目的。当听众能理解你的背景时，就很难忽视你。
- 专注于你的假设/解决方案。设定完成后，你可以让听众专注于你针对问题的假设/解决方案。这是至关重要的，因为现在他们马上就能看到你的提议，他们渴望知道更多。这样，你就可以引导他们进入揭示你的方法和程序的下一步。
- 方法/方法/完成的工作。现在，你解释一下你为实现上一步中的目标所做的工作。一定要简洁。没有人喜欢数学公式或深奥的技术细节。在这一步，也不要急于炫耀你的数学或编码技能。简单地呈现你在更高层次上采取的步骤。如果有人有兴趣深入挖掘技术细节，他们将在稍后跟进。流程图和图表在这一步非常有效。文字段落是一个错误。
- 上下文/相关工作。现在有些人可能会争辩说，这一点应该放在方法论之前。在某些情况下，这可能是真的。但我的论点是，在演讲开始时，听众的注意力持续时间会很长。这就是你必须让你的工作成为焦点的地方。如果你在这方面做得很好，无论如何，当你进入这一步时，你会拥有观众。因为他们急切地想知道你做了什么，所以一开始介绍相关的工作可能会让他们厌烦而不切入正题。然而，背景很重要，你必须让你的方法从现有的技术和想法中脱颖而出。
- 做出的贡献和取得的成果。突出你的影响力。展示你的应用成果和结果。指出你对该领域的知识和理解所做的贡献。这就是你在你提出的解决方案中加强自己立场的地方。
- 展望/未决问题/未来工作。最后，记下你努力展示的更广阔的舞台。现在要思考的一点是，你提到过你的研究的局限性吗？我的意见是肯定的。这是传达你弱点的地方，这会给你的工作留下积极的印象。此外，用你的特殊方法提出未来工作的问题，并强调潜在的影响。
我希望这篇文章能为那些希望提高自己表达技巧的人提供指导，尤其是在数据科学这个高度技术性的领域。就我个人而言，这是我花了大量时间来提高自己的东西，因为我坚信有效的演示对你的研究的影响。如果运用得当，这些技能将有助于你提升自己作为研究员或数据科学家的职业生涯。
我也想听听你对此的看法。在 Twitter 上联系我或者在下面评论。
感谢阅读。
如何让你的数字战略获得回报？(提示:数据科学)
Source: Pixabay
数字广告支出正在超过传统广告支出(电视、印刷、户外)。大多数品牌已经将重点转移到通过各种数字平台直接瞄准客户，以获得更大的销售份额。
数字活动有助于在更个性化的层面上锁定客户。有效的数字战略包括关注高质量的内容和锁定正确的受众。但是，确定正确战略的关键因素是了解哪些媒体和活动最有效，并为未来制定正确的渠道组合。营销人员应该遵循一种综合的方法来深入挖掘最有效的媒体和活动。
打开集合方法的包装
让我们打开系综方法。
- 首先了解营销组合(自上而下的方法)。传统与数字营销推动了多少销售？。找出在各种营销投入上花费的每一美元的投资回报。
每个营销人员都希望所花的钱有很高的投资回报率，他们的想法是不要把钱留在桌面上。
- 然后了解每项营销活动中哪些活动最有效。例如，如果正在显示 3 个 YouTube 广告，分析哪一个广告的转化最有效。这将有助于理解哪个广告以最有效的方式传达信息。对创意、文案持续时间和类型的深入分析有助于确定最有效的广告，并有助于制定成功的传播策略。
- 在了解营销效果的同时，营销人员通常只了解营销投入对其业务指标(销售额、市场份额等)的直接影响。这导致了对营销投入的不当归因。纠正措施应该是了解营销投入对销售的间接和直接影响。例如，观看电视广告后购买产品的人可能会先观看 YouTube 广告。因此，销售必须归功于电视和数字(YouTube)接触点。直接和间接分析有助于将正确的销售额归因于这些营销投入。
- 接下来，通过使用归因建模方法了解客户转化路径。这将提供客户层面的具体见解(自下而上的方法)，并揭示客户转化过程中的细微差别。
- 从营销组合和归因模型中收集见解，获得有效活动的整体情况以及每项活动的预算。
整体方法将通过对线下和线上接触点的深入分析提供 360 度的洞察力，并有助于制定有效的数字战略。
与阿里马实验室 取得联系，了解如何通过集成技术获得正确的数字战略。
如何用 Optuna 让你的模型牛逼
Odysseus and the Sirens source
轻松高效地优化模型的超参数
超参数优化是训练机器学习模型的关键步骤之一。由于要优化的参数很多，训练时间长，并且要多次折叠以限制信息泄漏，这可能是一项繁琐的工作。处理这个问题有几种方法:网格搜索、随机搜索和贝叶斯方法。 Optuna 是后一种的实现。
Will Koehrsen 写了一篇关于使用贝叶斯代理模型进行超参数优化的优秀文章。我也解释不清楚了:)你可以在这里找到。在第二篇文章中，Will 将介绍如何用 Python 中的hyperpt包实现该方法。
关于 Optuna
这个软件包过去是，现在仍然是，由日本人工智能公司 Preferred Networks 开发的。在很多方面，Optuna 与 Hyperopt 相似。所以你为什么要烦恼呢？有几个原因:
- 可以指定优化过程应该持续多长时间
- 与 Pandas 数据框架集成
- 该算法使用剪枝来尽早丢弃低质量的试验
- 这是一个相对较新的项目，开发人员还在继续工作
- 它比远视更容易使用(至少对我来说)
示例演练
Jason and the Argonauts source
数据
我使用了来自 Scikit-Learn 的 20 个新闻组数据集来准备实验。您可以在下面找到数据导入:
模型
这是一个自然语言处理问题，模型的管道包含一个特征提取步骤和一个分类器。管道的代码如下所示:
优化研究
The School of Athens by Raphael source
创建的研究优化了矢量化步骤和模型超参数。可以从 5 个发行版中选择:
- 统一-浮点值
- 对数均匀-浮点值
- 离散统一-有间隔的浮点值
- 整数-整数值
- 分类-列表中的分类值
语法如下所示:
然后，这些值被传递到参数字典，并在以后设置为优化模型。这些值可以在字典中给出，但是这会使代码行变得很长，很难阅读。
定义函数的最后一步实际上是定义目标。它应该只返回一个值。强烈建议根据交叉验证(如有可能，分层)对模型进行评分，并给出较高的折叠数(绝对最小值为 8)。
请记住，截至 2019 年 2 月 24 日，只可能最小化函数值。最大化目标还没有实现，所以如果你想找到最高值，只需在它前面加一个减号。
我还添加了一行代码，将研究结果转储到 pickle 文件中。它允许你保持进度，即使这个过程由于某种原因被中断(因为你的决定或者你的机器的决定)。您可以在下面找到目标代码:
要创建研究的实例，您可以创建一个新实例，也可以从 pickle 文件中加载它以继续之前的实验。第二步是进行研究。您可以在以秒为单位的试验次数 (n_trials)或(T5)(超时)中指定研究持续的时间。后者的最后一次试验在暂停前开始，整个研究持续的时间比指定的时间长一点。您可以在下面找到代码和默认输出。
请注意，目前显示的是最佳超参数。
您可以分别使用 best_value 和 best_params 属性访问最佳指标的值和最佳参数字典。您可以使用 trials 属性访问试用版，但是 Optuna creators 准备了更好的东西。使用 trials_dataframe()方法创建一个包含试验详情的熊猫数据框架。
研究结束后，您可以为模型设置最佳参数，并在完整数据集上对其进行训练。
为了可视化正在进行的过程，您可以从另一个 Python 线程(即 Jupyter Notebook)访问 pickle 文件。
Ongoing study’s progress. Image by author
您可以在这个 GitHub 资源库中找到示例笔记本和可视化笔记本。
修剪技术
A man pruning olives source
Optuna 的创造者表示，该软件包在速度和质量方面优于 Hyperopt。以下是他们在项目网页上写的内容:
修剪功能会在训练的早期阶段自动停止没有希望的试验(也称为自动提前停止)。Optuna 提供了在迭代训练算法中简洁地实现剪枝机制的接口。
[…]
例如，与现有的优化框架相比，我们的基准实验展示了修剪特性的优势。
https://optuna.org/assets/img/Pruning_of_unpromising_trials.png
我不得不说，就修剪机制而言，我有一些复杂的感觉。我坚信，在超参数优化方面，多重交叉验证技术是必不可少的。在 Optuna 的开发人员在每次试验中提供的剪枝示例中，对验证集进行了采样。在我看来，它增加了度量的方差，因此使得优化不那么可靠。如果验证集是常量，它将导致代理的模型过度拟合到验证集。当然，如果数据集很大，以防止方差/过拟合问题发生，这可能不是一个问题。
在我看来，最好的选择是以某种方式将交叉验证和修剪结合起来。也许在 k 次折叠(k 小于折叠总数)后验证试验是个好主意？
摘要
对于我来说， Optuna 成为首选优化框架。它易于使用，可以设置研究的超时，休息后继续研究，并轻松访问数据。该项目仍在开发中，我期待着新的功能。我认为首选网络团队过去和现在都做得很好！谢谢大家！
资源:
Odyssey source
- 项目网址:https://optuna.org/
- 项目的 GitHub 库:https://github.com/pfnet/optuna
- 示例笔记本:https://github.com/PiotrekGa/optuna_article
- 机器学习的贝叶斯超参数优化概念解释:https://towardsdatascience . com/A-Conceptual-explain-of-Bayesian-model-based-super parameter-Optimization-for-Machine-Learning-b 8172278050 f
- Python 中的自动机器学习超参数调优:https://towardsdatascience . com/Automated-Machine-Learning-Hyperparameter-Tuning-in-Python-dfda 59 b 72 f 8 a
非常欢迎您对这篇文章的反馈！请让我知道你的想法！
如何自制深度学习加速器芯片！
目前，全球有超过 100 家公司正在构建面向深度学习应用的 ASICs(专用集成电路)或 SOC(片上系统)。这里有一长串的公司。除了谷歌(TPU)、脸书、亚马逊(推理)、特斯拉等这些创业大公司都在开发定制的 ASIC，用于深度学习训练和推理。这些可以分为两种类型—
- 训练和推理——这些 ASIC 设计用于处理深度神经网络的训练和执行推理。训练像 Resnet-50 这样的大型神经网络是一项涉及梯度下降和反向传播的更加计算密集型的任务。与训练相比，推理非常简单，需要较少的计算。今天最流行的深度学习的 NVidia GPU 既可以做训练，也可以做推理。其他一些例子还有 Graphcore IPU 、谷歌 TPU V3 、脑波强化器等。OpenAI 有很棒的分析显示最近训练大型网络所需的计算增加。
- 推论——这些 ASIC 被设计为运行 DNN(深度神经网络),这些网络已经在 GPU 或其他 ASIC 上进行过训练，然后经过训练的网络被修改(量化、修剪等)以在不同的 ASIC 上运行(如谷歌珊瑚边缘 TPU、英伟达杰特森纳米)。大多数人都说深度学习推理的市场比训练大得多。如 TensorFlow Lite 团队所示，即使是基于 ARM Cortex 的非常小的微控制器(MCU)——M0、M3、M4 等也可以进行推理。
AI Landscape by Shan Tang : Source
制造任何芯片(ASIC、SOC 等)都是一个昂贵、困难和漫长的过程，通常由 10 到 1000 人的团队完成，具体取决于芯片的大小和复杂程度。这里我只提供一个针对深度学习 推理 加速器的简要概述。如果你已经设计了芯片，你会发现这太简单了。如果你仍然感兴趣，请继续阅读！如果你喜欢它，分享和👏。
现有 ASIC 的架构
让我们首先来看看目前正在开发的一些加速器的高层架构。
Habana Goya—Habana labs是一家初创公司，正在开发用于训练的独立芯片——高迪和推理——Goya。
Habana Goya High-Level Architecture: Source
GEMM 引擎——通用矩阵和乘法引擎。矩阵乘法是所有 DNN 中的核心运算——卷积可以表示为矩阵乘法，全连接层是直接的矩阵乘法。
TPC——张量处理核心——这是一个实际执行乘法或乘加(MAC)运算的模块。
本地内存和共享内存—这些都是某种形式的高速缓存，通常使用 SRAM (静态随机存取存储器)和寄存器文件(也是一种静态易失性存储器，只是密度比 SRAM 小)。
Eyeriss——来自麻省理工学院的 eye riss 团队一直在研究深度学习推理加速器，并发表了几篇关于他们的两个芯片的论文，即 Eyeriss V1 和 V2 。你可以在这里找到好的教程。
Eyeriss V2 top-level architecture: Source
NVDLA : Source
数据流架构 —数据流架构至少从 20 世纪 70 年代就开始研究了。 Wave Computing 想出了数据流处理单元 (DPU)来加速 DNN 的训练。 Hailo 也使用了某种形式的数据流架构。
Hailo — Embedded Vision Summit — Source
Gyrfalcon —他们已经发布了一些针对低功耗边缘人工智能应用的芯片，如 Lightspeeur 2801S 。
Matrix Processing Engine (MPE) — Source
谷歌 TPU 也有脉动数据流引擎。
Matrix Multiplier on TPU — Source
TPU Floor plan — Source
统一缓冲区—这基本上是本地内存/缓存，可能使用 SRAM 实现。
DRAM —这些是访问外部 DRAM 的接口，使用其中两个接口，您可以访问两倍的数据。
关键模块
基于上面的一些例子，我们可以说下面是制造深度学习推理加速器所需的关键组件。此外，我们将只关注 8 位推理引擎，该引擎已被证明对许多应用足够好。
矩阵乘法单元——它有不同的名称，如 TPC(张量处理核心)、PE 等。GEMM 参与了 DNN 的核心计算，要了解更多关于 GEMM 阅读这篇伟大的帖子。
SRAM —这是用于存储权重或中间输出/激活的本地存储器。
Data movement Energy Vs Compute — Source — Efficient Processing of Deep Neural Networks: A Tutorial and Survey
为了减少能量消耗，存储器应该尽可能靠近处理单元，并且应该尽可能少地被访问。
互连/结构—这是连接所有不同处理单元和内存的逻辑，以便一个层或模块的输出可以传输到下一个模块。也称为片上网络(NoC)。
接口(DDR、PCIE) —需要这些模块来连接外部内存(DRAM)和外部处理器。
控制器——这可以是 RISC-V 或 ARM 处理器或定制逻辑，用于控制所有其他模块和外部处理器并与之通信。
架构和指令集
如果我们观察所有架构，我们会发现内存总是尽可能靠近计算。原因是移动数据比计算消耗更多的能量。让我们来看看 AlexNet 架构所涉及的计算和内存，它在 2012 年打破了 ImageNet 记录——
AlexNet Layers and Parameter — Source
AlexNet 由 5 个构成层和 3 个全连接层组成。AlexNet 的参数/权重总数约为 6200 万。假设在权重量化之后，每个权重被存储为 8 位值，因此如果我们想要将所有权重保存在片内存储器中，则至少需要 62 MB 的 SRAM 或 62*8 兆位= 4.96 亿 SRAM 单元。如果我们使用 6T(六晶体管)SRAM 单元，仅存储器就需要 496M * 6 ~ 2.9 亿个晶体管。因此，在决定架构时，我们必须记住在不增加片外重量(这会增加功耗)的情况下，我们可以支持哪些 DNN 架构。由于这个原因，许多创业公司展示了使用更新的架构，如 MobileNetV2 ，它使用更少的参数和更少的计算，例如，ImageNet 上前 5 名准确率为 92.5%的 MobileNetV2 的一个检查点只有 6.06M 个参数，在单个图像推断期间执行 582M 次 MAC(乘和累加)操作。
Accuracy Vs Model Size — Source
权重修剪是另一种可以用来减少模型大小(从而减少内存占用)的技术。参见模型压缩的结果。
MobileNetV2 使用不同于传统卷积的深度方向可分离卷积，因此加速器架构必须足够灵活，以便如果研究人员提出不同的操作，它们仍然可以根据加速器上可用的指令集来表示。
我们可以为我们简单的加速器想出一套非常简单的指令，就像—
- 加载数据—获取源地址和目标地址
- MAC(乘加)—假设数据已经在本地寄存器中。
- 存储结果—存储中间结果
- 填充—添加零
硬件加速器编译器
编译器将使用 PyTorch 或 Tensorflow 用 python 编写的高级代码转换为特定芯片的指令集。下面是开发/使用这些定制 ASIC 的一些框架。这个过程可能非常困难和复杂，因为不同的 ASIC 支持不同的指令集，如果编译器没有生成优化的代码，那么您可能没有充分利用 ASIC 的功能。
脸书 Glow —哈瓦那实验室利用 Glow 框架为他们的 ASIC 开发了后端。
TVM —这是一个开源的深度学习编译器堆栈，由华盛顿大学的研究人员发起。TVM 框架还包括多功能张量加速器 (VTA)，这是一个可编程的独立加速器。亚马逊 Sagemaker Neo 使用 TVM 编译深度学习模型，部署在不同的硬件上。
TensorFlow MLIR—MLIR是 Google 为 tensor flow 提供的编译器基础设施，最近已经成为 LLVM 项目的部分。
英特尔 ngraph —这是由 Nervana 开发的，用于 nerv ana/英特尔深度学习加速器。
EDA 工具和高级综合
Chisel 是一种硬件构造/描述语言，最初由伯克利的研究人员开发。它实际上是用 Scala 编写的，用于许多基于 RISC-V 的处理器的设计。
综合、时序和布局——RTL 综合是将 Verilog/VHDL 等语言编写的高级代码转换成逻辑门的过程。时序工具使用逻辑门和布线的布局前和布局后延迟信息来确保设计正确。在时序设计中，一切都与时钟沿有关，因此时序非常重要。布局工具从合成的网表生成布局。 Synopsys (设计编译器，黄金时间)和 Cadence 工具最常用于这些步骤。
高级综合(HLS)——HLS 是指用 C/C++等高级语言描述硬件，然后转换成 VHDL/Verilog 等 RTL(寄存器传输级)语言的过程。甚至还有一个 python 包http://www.myhdl.org/——将 python 代码转换成 Verilog 或 VHDL。 Cadence 拥有支持 C/C++等的商业工具，这些工具对定制设计非常有帮助。Google 使用 Mentor Graphics Catapult HLS 工具开发了 WebM 解压 IP 。
可用 IP
现在，我们已经确定了所需的关键模块，让我们看看我们使用什么现有的 IP(免费或付费)。
Nvidia 深度学习加速器(NVDLA) — NVDLA 是 Nvidia 发布的免费开放架构，用于深度学习推理加速器的设计。源代码、驱动程序、文档等可在 GitHub 上获得。
SRAM——不同类型的 SRAM IP——单端口、双端口、低功耗、高速等，可从 Synopsys 和其他公司获得。通常，它们提供 SRAM 编译器，用于根据芯片要求生成特定的 SRAM 模块。
寄存器文件—该 IP 也可从 Synopsys 和各种类型的逻辑标准单元获得。
互连/结构/NoC——这个 IP 的一个选项是 Arteris ，他们有针对深度学习加速器的 FlexNoC AI 包。
处理器——各种 RISC-V 处理器内核可以免费获得。甚至 ARM 也免费或以非常低的前期成本向初创公司提供许可。ARM Ethosnpu 是专门为神经网络设计的——Ethos N37、N57、N77。
AMR Ethos NPU — Source
Cadence Tensilica DNA 100—根据我们的目标应用/行业，Cadence 提供的 IP 可配置为 0.5 至 100 的 TMAC 操作。
有很多其他可用的知识产权，所以我的建议是在设计自己的知识产权之前，从像 ARM 、 Ceva 、恩智浦等公司寻找已经测试过的知识产权。
设计流程
有很多关于 ASIC 设计流程、数字设计过程等的资源(书籍、讲座等)，所以我就不多讲了。
ASIC Flow from Wikipedia — Source
代工厂和工艺技术
芯片的制造是在大型晶圆厂(制造厂或代工厂)完成的，目前，很少有公司像英特尔、三星、德州仪器、恩智浦等拥有自己的晶圆厂。甚至像高通、AMD 等大公司也使用外部代工厂，所有这样的公司都被称为无晶圆厂。以下是一些最大的半导体代工厂
TSMC(台积电) — TSMC 是世界上最大的代工厂，为高通、苹果等公司制造芯片。对于小型创业公司来说，在 TSMC 进行生产可能具有挑战性，因为他们的大部分生产能力都被大公司利用了。
UMC(联合微电子公司)——UMC 也与包括小型创业公司在内的大量客户合作。目前，UMC 可用的最小工艺是 14 纳米。
流程选择
Cross-section of two transistors in a CMOS gate, in an N-well CMOS process
IC 制造工艺是通过晶体管的尺寸和金属连接的宽度来衡量的。长期以来，工艺尺寸一直在下降(摩尔定律)，这就是现代 IC 每年包含越来越多的晶体管(这曾经是由摩尔定律决定的)。目前，最先进的工艺节点是 7 纳米，使用 7 纳米工艺的产品仅在 2019 年推出。所以目前大部分产品都是使用 14 纳米/16 纳米工艺制作的芯片。工艺越先进，成本就越高，因此大多数小型创业公司最初会使用稍微老一点的工艺来保持低成本。许多开发深度学习加速器的创业公司都在使用28 纳米处理器，在某些情况下，甚至是 40 纳米工艺。泄漏是现代工艺中的一个大问题，如果芯片设计不当，可能会导致巨大的功耗。
简单成本估算
晶圆成本取决于工艺节点和各种其他因素，如加工步骤的数量(使用的层数)。成本从相对较老的工艺的几千美元到最新的工艺节点的几千美元不等，这很大程度上取决于一个人要购买多少晶片等等。
CMOS Wafer — Source
大多数代工厂生产 300 毫米(约 12 英寸)直径的晶圆用于数字工艺。让我们简单计算一下 12 英寸晶片的芯片成本
总面积~ π * r (r =晶圆半径)~ 70，650 mm
晶圆总成本约 1000 美元(仅用作示例)
芯片面积约 10mm×10mm ~ 100mm(TPU V1 芯片尺寸约 331 mm ， SRAM 单元面积约 32nm ~ 0.18um
每个晶片的芯片数约为 70，650 / 100 ~ 706(由于边缘缺陷等原因，实际上更少)
实际上好的模具有 95%的成品率 ~ 0.95 * 706 ~ 670
单个模具成本约 1000 元/670 元~ 1.5 元
包装和测试也会增加最终成本。
这是一个巨大的领域，这篇文章只是触及了其中一些话题的表面。还有很多其他的东西要涵盖，比如用于深度学习的FPGA，布局，测试，成品率，低功耗设计等等。如果人们喜欢这篇文章，我可能会再写一篇。
我热衷于构建生产机器学习系统来解决具有挑战性的现实世界问题。我正在积极寻找 ML/AI 工程师职位，你可以在这里联系我。
链接
麻省理工学院的教程
发布者:TensorFlow MLIR 团队
medium.com](https://medium.com/tensorflow/mlir-a-new-intermediate-representation-and-compiler-framework-beba999ed18d) [## Google Coral Edge TPU 主板与 NVIDIA Jetson Nano 开发主板—硬件比较
NVidia 和 Google 最近都发布了针对 EdgeAI 的开发板，并且以低廉的价格吸引了…
towardsdatascience.com](/google-coral-edge-tpu-board-vs-nvidia-jetson-nano-dev-board-hardware-comparison-31660a8bda88)**
如何让你的熊猫循环快 71803 倍
循环通过熊猫数据帧可能会非常慢——我将向您展示一些非常快速的选项
如果用 Python 和 Pandas 做数据分析，用不了多久，第一次就想用循环了。然而，即使对于小的数据帧，使用标准循环也是非常耗时的，您很快就会意识到对于较大的数据帧，这可能需要很长时间。当我第一次等了半个多小时来执行代码时，我寻找了一些替代方法，我想与大家分享一下。
标准循环
数据帧是熊猫——有行和列的对象。如果你使用循环，你将遍历整个对象。Python 不能利用任何内置函数，而且速度非常慢。在我们的例子中，我们得到了一个 65 列 1140 行的数据帧。它包含 2016 - 2019 赛季的足球结果。我们希望创建一个新列来指示某个特定的球队是否打了平局。我们可以这样开始:
由于我们的数据框架中有英超联赛的每一场比赛，我们必须检查感兴趣的球队(阿森纳)是否参加了比赛，如果适用，他们是主队还是客场队。如您所见，这个循环非常慢，执行时间为 20.7 秒。让我们看看如何才能更有效率。
熊猫的内置函数:iterrows() —快 321 倍
在第一个例子中，我们循环了整个数据帧。iterrows()为每一行返回一个序列，因此它将一个数据帧作为一对索引进行迭代，将感兴趣的列作为序列进行迭代。这使得它比标准循环更快:
代码运行需要 68 毫秒，比标准循环快 321 倍。然而，许多人建议不要使用它，因为仍然有更快的选择，而且iterrows()不能跨行保存 dtypes。这意味着如果你在你的数据帧上使用iterrows()，数据类型会被改变，这会导致很多问题。要保留数据类型，您也可以使用itertuples()。这里就不赘述了，因为要注重效率。您可以在这里找到官方文档:
[## 熊猫。data frame . ITER tuples-pandas 0 . 25 . 1 文档
如果列名是无效的 Python 标识符、重复或以…开头，它们将被重命名为位置名
pandas.pydata.org](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.itertuples.html)
apply()方法—速度快 811 倍
apply本身并不快，但与数据帧结合使用时有优势。这取决于apply表达式的内容。如果能在 Cython 空间执行，apply要快很多(这里就是这种情况)。
我们可以将apply与Lambda函数一起使用。我们要做的就是指定轴。在这种情况下，我们必须使用axis=1,因为我们想要执行列操作:
这段代码甚至比以前的方法更快，用了 27 毫秒才完成。
熊猫矢量化—速度提高 9280 倍
现在我们可以谈一个新的话题了。我们利用矢量化的优势来创建真正快速的代码。重点是避免 Python 级的循环，就像[1]前面的例子一样，并使用优化的 C 代码，这样可以更有效地使用内存。我们只需要稍微修改一下函数:
现在我们可以创建以熊猫系列作为输入的新列:
在这种情况下，我们甚至不需要循环。我们要做的就是调整函数的内容。现在，我们可以直接将 Pandas 系列传递给我们的函数，这将大大提高速度。
Numpy 矢量化—速度提高 71.803 倍
在前面的例子中，我们将熊猫系列传递给了我们的函数。通过添加。值我们接收一个 Numpy 数组:
Numpy 数组如此之快是因为我们得到了引用局部性的好处[2]。我们的代码运行耗时 0，305 毫秒，比开始时使用的标准循环快 71803 倍。
结论
如果你使用 Python，Pandas 和 Numpy 进行数据分析，你的代码总会有一些改进的空间。我们比较了五种不同的方法，根据一些计算在我们的数据框架中添加一个新的列。我们注意到了速度上的巨大差异:
如果你能从这篇文章中得到两条规则，我会很高兴:
- 如果您确定需要使用循环，您应该始终选择 apply 方法。
- 否则，矢量化总是更好，因为它更快。
来源:
[1]https://stack overflow . com/questions/52673285/performance-of-pandas-apply-vs-NP-vectorize-to-create-new-column-from-existing-c
【2】https://en.wikipedia.org/wiki/Locality_of_reference
如果您喜欢中级数据科学，并且尚未注册，请随时使用我的推荐链接加入该社区。
如何用 Python 管理 Google Drive 中的文件
Photo on unsplash
作为一名数据分析师，大多数时候我需要与我的产品经理/利益相关者分享我提取的数据，Google Drive 始终是我的首选。这里的一个主要问题是我必须每周甚至每天都做，这很无聊。我们所有人都讨厌重复的任务，包括我。
幸运的是，谷歌为其大部分服务提供了 API。我们将使用 Google Drive API 和 PyDrive 来管理我们在 Google Drive 中的文件。
使用 Google Drive API
在开始编码之前，您应该准备好 Google Drive API 访问。我写了一篇关于如何通过客户端 ID 获得你的 Google 服务访问的文章。你应该可以得到包含密钥的 JSON 文件来访问你的 Google Drive。
PyDrive 入门
安装 PyDrive
我们将使用 python 包管理器来安装 PyDrive
pip install pydrive
正在连接到 Google Drive
PyDrive 只用 2 行代码就使认证变得非常容易。
你必须将JSON 文件重命名为“client _ secrets . JSON”，并将它与你的脚本放在同一个目录下。
将启动浏览器并要求您进行身份验证。选择您想要访问的 google 帐户并授权应用程序。
drive = GoogleDrive(gauth)创建一个 Google Drive 对象来处理文件。您将使用该对象来列出和创建文件。
在 Google Drive 中列出和上传文件
第 1 行到第 4 行将显示 Google Drive 中的文件/文件夹列表。它还会给你这些文件/文件夹的详细信息。我们获取您想要上传文件的文件夹的文件 ID 。在这种情况下，To Share是我上传文件的文件夹。
文件 ID 很重要，因为 Google Drive 使用文件 ID 来指定位置，而不是使用文件路径。
drive.CreateFile()接受元数据 ( dict )。)作为输入来初始化一个 GoogleDriveFile。我用"mimeType" : "text/csv"和"id" : fileID初始化了一个文件。这个id将指定文件上传到哪里。在这种情况下，文件将被上传到文件夹To Share。
file1.SetContentFile("small_file.csv")将打开指定的文件名并将文件的内容设置为 GoogleDriveFile 对象。此时，文件仍未上传。您将需要file1.Upload()来完成上传过程。
访问文件夹中的文件
如果你想上传文件到一个文件夹里的文件夹里呢？是的，你还需要文件 ID ！你可以使用ListFile来获取文件，但是这次把root改为file ID。
file_list = drive.ListFile({'q': "'<folder ID>' in parents and trashed=false"}).GetList()
现在我们可以进入文件夹To Share中的文件夹picture。
除了上传文件到 Google Drive，我们还可以删除它们。首先，用指定的文件 ID 创建一个 GoogleDriveFile。使用Trash()将文件移至垃圾箱。您也可以使用Delete()永久删除文件。
现在你已经学会了如何用 Python 管理你的 Google Drive 文件。希望这篇文章对你有用。如果我犯了任何错误或打字错误，请给我留言。
可以在我的 Github 中查看完整的脚本。干杯！
如果你喜欢读这篇文章，你可能也会喜欢这些:
在 Python 中再现相同的 SQL 查询结果
towardsdatascience.com](/how-to-rewrite-your-sql-queries-in-python-with-pandas-8d5b01ab8e31) [## 如何掌握 Python 命令行参数
使用命令行参数创建自己的 Python 脚本的简单指南
towardsdatascience.com](/how-to-master-python-command-line-arguments-5d5ad4bcf985)
你可以在 Medium 上找到我其他作品的链接，关注我 这里 。感谢阅读！
如何管理数据科学中的冒名顶替综合症
如果他们发现你一无所知怎么办？
冒名顶替综合症是数据科学实验室里的大象。每个人都有，没人觉得别人有，也没人说。
我很惊讶更多的人不公开讨论。我在一家数据科学导师创业公司工作，在那里我可能会花 20%的时间帮助数据科学家克服冒名顶替综合症以及随之而来的自我怀疑。我看到它阻碍了更多有抱负的数据科学家和机器学习工程师，多得数不清。
我从数百次关于冒名顶替综合征的谈话中学到了很多，从我所见，克服它的最好方法就是理解它。这就是这篇文章的内容。
症状和原因
关于冒名顶替综合症最奇怪的事情是，它与技术技能呈正相关:我与之交谈过的最有能力的数据科学家和 ML 工程师往往是最自我批评的。
起初，我发现这令人困惑:为什么最博学的数据科学家最自我怀疑？
然后，我想起了一个叫做邓宁-克鲁格效应的东西。DKE 是一个被充分研究过的现象，在这个现象中，在一项任务中表现糟糕的人过度高估了他们在这项任务中的能力水平。
例如，如果你给人们一个物理测试，你让他们预测他们做得如何(他们的“原始分数”)，以及他们对自己的预测有多少信心(“项目信心”)，你会发现表现最差的人往往认为他们做得很好，非常感谢:
Adapted from Williams, Dunning and Kruger’s paper: “The Hobgoblin of Consistency: Algorithmic Judgment Strategies Underlie Inflated Self-Assessments of Performance”
冒名顶替综合征与邓宁-克鲁格效应相反。就像不称职的人往往会高估自己的表现一样，称职的人往往会低估自己的表现。
在某种程度上，这是有道理的。如果你对一项任务一无所知，你可能不知道它有多难。想想那些花了 30%的 NBA 总决赛时间对着电视屏幕大喊他们如何能比职业篮球队的专业人员做得更好的扶手椅教练吧。
另一方面，一旦你对一个问题有了坚实的理解，你就更熟悉解决这个问题需要克服的挑战。也能看出自己理解上的漏洞在哪里。
这让我想到了数据科学。
是的，在数据科学领域更糟
每天都有新算法、新库和新工作流被发明出来。所以你理解中的漏洞数量永远不会是零。事实上，由于我们每天创造的知识比任何人可能学到的都要多，你理解中的漏洞将会永远增长。你对数据科学的了解越多，你就越有可能意识到这一点。
因为在数据科学中没有办法避免无知，你必须管理它。这里有一个好消息:没有一家公司因为他们不知道或不会做什么而雇佣数据科学家或 ML 工程师。公司雇佣员工是因为他们能做什么。
这是克服冒名顶替综合症的关键。
如何看待冒名顶替综合症
如果你觉得自己像个骗子，因为你不了解数据科学的一切，那么从改变你对数据科学家的看法开始:这与知识无关，而是与有用性有关。
如果你能从数据中获得准确的见解，或者做出足够好的模型用于实际目的，那么你就是有用的。你不是骗子。你是个增值者。大多数数据科学家从未接触过神经网络，大多数不做任何聚类，大多数不日常使用 KNNs。不知道如何做这些事情并不妨碍它们有用。
底线是，如果你能真正做好一件事，不知道所有事情也没关系。如果可以的话，那么你应该定义你的身份是一个关于那个东西的数据科学家。例如，“我是一名专门使用基于树的模型进行回归的数据科学家”，而不是“我是一名数据科学家”。你总是可以通过现实地看待你期望自己扮演的角色来定义自己走出冒名顶替综合症的方法。
如果你是一个骗子呢？
这不会是一个流行的说法，但是…
也许你是冒名顶替。这并不是说你不属于数据科学，只是说你可能还没有准备好工作。擅长数据科学很难，而且门槛每年都在提高。
自我诊断“冒名顶替综合症”的危险在于，这是一个非常诱人的诊断:告诉自己患有“冒名顶替综合症”,会让你想象自己已经具备了成功所需的所有技能，而你的不足感是没有道理的。有时候确实如此。但是有时候，我们头脑中的“我感到非常无知”警报响起是有原因的。
因此，如果你认为自己患有冒名顶替综合症——而不是正确诊断自己的无知——一个好的第一步是问知道自己在做什么的人。这就是导师和信息面试的价值所在:通过 LinkedIn 联系安排一次咖啡聊天，或者去参加一个当地聚会。
当你这样做的时候，永远记住那个关键的指导原则——你知道什么并不重要；重要的是你能做什么。
如果你想聊天，请随时在 Twitter 上与我联系。我是@jeremie charris！
如何管理机器学习和数据科学项目
机器学习(ML)和数据科学(DS)项目很难管理。因为项目本质上类似于研究，所以很难预测它们需要多长时间才能完成。他们通常从一个想法开始，然后当提出的技术不起作用或对数据的假设被证明是错误的时，转向一个新的方向。
建模本身也是一个漫长的过程(与大多数软件工程和分析工作相比)，对于数据科学家来说，进入一个兔子洞，在一个项目上花上几个月的时间，却没有一个明确的进展概念，这种情况并不罕见。与标准软件工程实践的另一个区别是，模型开发通常由一个人完成。这种串行性质并不适合传统的协作 SE 工作流，比如看板和 Scrum。
我花了相当多的时间研究现有的工作流程(主要是在吉拉)来管理 DS 和 ML 项目，但是没有运气。那里的大部分信息都是针对软件工程的，并且集中在敏捷方法上。我也和该领域的同事和朋友交谈过，但我找不到任何为机器学习和数据科学量身定制的东西。我注意到有些人试图使他们的工作流程适应标准的工程实践，或者，在其他情况下，根本不尝试管理那些项目。后者尤其成问题，因为它可能导致项目耗时太长，范围太大，并且更有可能失败。
由于我找不到好的解决方案，我决定建立自己的定制工作流来管理机器学习和数据科学项目。这个系统可以在吉拉实施，让我很容易地监测和报告项目的状态。这也有助于我限制它们的范围，避免构建时间过长的过于复杂的模型。我们的科学家被提供了一个结构，帮助他们思考应该如何建立模型，这增加了他们在项目中取得成功的变化。我使用这个系统已经有几年了，我和我的团队对它非常满意。
机器学习项目有明确定义的阶段
无论您是使用深度学习构建复杂的计算机视觉算法，还是使用 LightGBM 构建学习到排序模型，甚至是简单的线性回归，构建 ML 模型的过程都有明确定义的阶段。下面是我们如何将模型构建过程分成连续的阶段，从最初的研究一直到 A/B 测试结果的分析。请注意，每个阶段都有一个可交付成果(或里程碑)，它也是与团队或涉众同步的接触点。
1)研究
这是项目的初始阶段。它包括与利益相关者交谈以了解项目的目标和期望，与业务分析师交谈以了解哪些数据可用以及从哪里获取数据，创建一些初始查询并调查数据，以便对问题有更好的直观理解。
也是在这个阶段，科学家将阅读文献并决定解决问题的方法。这包括阅读科学论文和与同龄人集思广益。有时候，决定方法还需要了解现有的包，并使用 Jupyter 笔记本构建一些简单的原型。
交付成果:此阶段的输出是项目执行的详细计划，包括后续阶段的分解(即，数据探索、建模、产品化和结果分析)以及相关的估计工作量水平(以周数表示)。还必须具体说明要使用的方法和数据。
该计划将与利益相关方分享以获得反馈。
2)数据探索
这是使用熊猫和木星笔记本(有时是 Tableau)探索数据的传统阶段，以便获得对数据的洞察。典型的分析包括计算数据中的行数、创建不同要素聚合的直方图、一段时间内的趋势图以及多个分布图。科学家们还将构建查询，这将是他们模型 ETL 的核心。
交付成果:一份详细的数据探索报告，作为一个木星笔记本，带有图表和评论，提供对数据的见解。该报告将与小组的其他成员和项目干系人共享。
3)建模
这是这个项目的核心。在这里，科学家将开始使用我们的内部框架构建他们的模型。这包括构建 ETL、执行特性工程和训练模型。它还包括构建基线模型和提供最终解决方案的广泛评估。
可交付成果:本阶段的产出是:
- 模型原型
- Jupyter 笔记本中的一份报告，对模型进行了广泛的评估
最终报告将与小组和项目利益相关者共享。
4)产品化
这个阶段是关于实现最终版本的代码。一些常见的任务包括向所有函数添加注释，并确保代码的格式符合 Python 标准和该组织的标准。代码中包含报告指标，如提取的行数、输出中的行数、根据几个指标的预测误差，以及适用时的功能重要性。最后，代码由一名数据科学家和一名工程师审查。
有时候产品化的过程会导致与平台工程师的来回互动。对于运行时性能至关重要的实时模型来说，这一点尤为重要。也有可能是代码的内存需求太大，导致生产流水线出现问题。工程师可能会推后，要求减少内存占用来训练模型。
可交付成果:这个阶段的输出是提交给主分支的代码，准备由平台工程团队进行部署。
5) A/B 测试
大多数型号将经历 A/B 测试阶段。在这里，科学家和利益相关者决定测试的细节:它将运行多长时间，流量的百分比是多少，控制是什么，如何解释结果等。当测试运行时，团队成员将主要关注其他项目，但是他们需要监控测试。
6)结果分析
每个科学家都要对自己的模型结果进行详细的分析。在这里，他们将以多种不同的方式分析结果指标，以了解实际情况。特别是，当测试不成功时，我们需要深入研究结果，找出问题所在。
可交付成果:
- 在 Jupyter 笔记本上的结果的详细报告。
- 关于为什么事情没有按预期进行的假设(如果适用)
最终报告将与小组和项目的利益相关者共享。
与吉拉合作
虽然这个框架在理论上看起来很棒，但现实是上述阶段很少是纯连续的。例如，从数据探索到建模，然后再回到数据探索，这是非常常见的。此外，这个过程不适合现有的吉拉框架，所以你如何在实践中实现它呢？
这其实很简单。我们使用吉拉看板和泳道(每个团队成员一个)以及一些自定义字段和更改。以下准则定义了我们流程的本质:
- 为每个项目创建一个新的 Epic 票证，并将工作分解为多个任务。
- 每个任务都标记有一个阶段，这是吉拉的一个自定义字段，用于从上面列出的 6 个阶段中选择一个。(注意，一个阶段可以有多个任务。)
- 任务不能超过 1 周(5 天)。这迫使团队成员将他们的工作分解成更小的(但仍然相当大的)块，允许以较小的开销进行进度监控。
- 任何时候都只能有一张票在进行中。这确保了我们总是知道项目处于什么状态。
- 阶段并不总是连续的，随着新任务的创建，可以在阶段之间来回移动。
结论
管理 ML 和 DS 项目不一定要复杂。起初，我花了大约 30 个阿敏日来监控这个过程，但是一旦团队习惯了，我的时间就减少到每周 15 分钟！我知道每个项目在任何时间点处于什么状态，一个项目花了多长时间，并且我可以快速识别问题，以便在需要时可以投入进来并帮助我的团队。我的数据科学家有一个清晰的框架来思考如何建立模型，他们在这方面变得更加高效。
我希望你能发现这对我很有用。
如何管理机器学习产品
第一部分:为什么管理机器学习产品这么难？你为什么要在乎？
总结:以下是我希望您记住的关于这一系列文章的内容:
- 管理 ML 产品比管理普通软件产品更具挑战性，因为它涉及更多的不确定性，不仅需要技术上的改变，还需要组织上的改变。
- ML 最适合做决策或预测。
- 清楚地定义问题，确定需求范围，设置度量标准，在决定前进的道路之前，给工程师和科学家足够的空间和灵活性去探索。
- 从第一天开始就考虑你的数据策略。
- 构建 ML 产品是跨学科的。超越 ML 思考。
在我的上一篇文章中，我谈到了机器学习(ML)带来的最大不同: ML 使人们能够从必须给机器编程转向真正的自主(自学)。机器根据它们在数据中识别的模式做出预测并提高洞察力，而无需人类明确告诉它们该做什么。这就是为什么 ML 对于挑战人难以向机器解释的问题特别有用。这也意味着 ML 可以使你的产品更加个性化，更加自动化，更加精确。先进的算法、海量的数据和廉价的硬件正在使 ML 成为 GDP 的主要驱动力。
ML 的采用已经在各个商业领域中快速推进。根据麦肯锡最近的调查，近一半的公司已经在其流程中纳入了一项或多项人工智能能力，另有 30%的公司正在试点人工智能项目。不难看出为什么 ML 比移动技术更有变革性。然而，向移动支付的过渡也可能比向移动支付的过渡困难 10 倍以上。在我们讨论为什么会出现这种情况之前，让我们先回顾一下基础知识。
机器学习基础
AI 和 ML 是什么？
人工智能没有普遍认同的定义，而且定义一直在变。一旦某项任务由机器执行，该任务就不再属于 AI 的范围。ML 是 AI 的子集。CMU 大学教授 Tom M. Mitchell 将机器学习定义为对计算机算法的研究，它允许计算机程序通过经验自动改进。
ML 的类型
机器学习主要有三种类型:
- 监督学习:最常见、应用最广泛的一种学习方式。这些算法从带标签的数据中学习，即，用模型试图预测的结果标记的训练数据集。简而言之，就是预测结果。
- 无监督学习:另一方面，无监督学习算法在没有标记数据的情况下学习识别数据中的模式。它可以用于聚类、关联和异常检测问题。还有半监督学习，它本质上是监督学习和非监督学习的混合体。
- 强化学习:随着时间的推移，算法在获得相应预测的反馈时进行学习。RL 用于机器人或自动驾驶汽车等控制领域。
机器学习产品的类型
根据产品的类型和核心价值的来源，你的团队需要不同的技能，并需要专注于产品的不同部分。
- 企业对消费者
智能音箱等消费级 ML 产品比企业级产品具有更强的社交成分。因此，用户体验(UX)在设计消费者 ML 产品中起着更重要的作用，ML 往往成为更好的 UX 的促成因素。例如，NLP(自然语言处理)用于改善 Alexa 与其用户之间的交互。另一方面，企业的核心价值，尤其是工业 ML 产品，如预测性维护软件，往往来自其预测的功能性能(如准确性)。这并不是说 UX 对企业 ML 产品不重要。然而，当你只有有限的资源，需要专注于优化产品的某些部分时，这是需要考虑的事情。
- 您是在打造 ML 产品还是在产品中应用 ML？
如果你的产品的核心价值来自于 ML 模型，那么你很可能正在构建一个 ML 产品。另一方面，如果 ML 只是用来增强你的产品的体验或性能，那么你最有可能把 ML 应用到你的产品中。在这种情况下，重要的是理解模型的输入和输出，而不是技术细节，如架构或 ML 模型是基于 CNN(卷积神经网络)还是 R-CNN。例如，该模型采用用户的人口统计数据来预测他们在平台上的每月支出。许多公司或团队也将利用现有的解决方案，这样他们就不会重新发明轮子。另一方面，构建 ML 产品通常需要项目经理更具技术性，以帮助团队导航关键决策和权衡。
组织结构也各不相同。对于制造人工智能产品的公司或在人工智能上有大量投资的大公司，如脸书和谷歌，雇佣人工智能研究人员/科学家并让他们与人工智能工程师配对是很常见的。另一方面，对于将 ML 应用于其产品的公司或资源受限的较小公司，雇用多学科的 ML 工程师或培训你的软件工程师学习 ML 可能比雇用 ML 研究人员/科学家更好。
- 构建 ML 产品通常是跨学科的。
即使你正在构建一个 ML 产品，也很少会只涉及 ML。它通常是跨学科的，不仅涉及 ML 模型，还涉及软件工程、后端基础设施、数据分析、UX/UI 设计，有时还涉及硬件。项目经理需要能够管理跨职能团队，并处理团队之间的相互依赖和潜在冲突。ML 从根本上不同于其他学科，我们将在下面的段落中解释更多。如果您正在为物理世界(如机器人或自动驾驶汽车)构建 ML 产品，这将变得更加复杂。项目经理需要知道 ML 可以做什么，不可以做什么，以及我们什么时候应该使用 ML，什么时候不应该使用 ML。
需要理解的其他关键 ML 概念
- 过度拟合:是一种错误，当模型过于接近一组特定的数据点时就会发生。鲁棒的 ML 模型不仅在“训练数据集”上表现良好，而且在“验证数据集”上也表现良好。但是，在过度拟合的情况下，训练数据的性能会提高，但看不见的(验证)数据的性能会变差。
- 深度学习(DL) :主要用于图像分类。DL 使用深度神经网络，并将标记的图像作为输入。神经网络的每一层都将把输入转换成稍微抽象和复合的表示。最终，模型学会识别图像中的物体。
- 自然语言处理(NLP) :机器理解人类语言的计算机科学领域。不一定涉及 ML。NLP 用于聊天机器人、语音助手或预处理数据。
管理 ML 产品的挑战
1.实验是 ML 的关键部分。
仅仅因为 ML 涉及代码和数据并不能使它类似于软件工程。事实上，这两个学科有天壤之别。与软件工程不同，开发机器学习产品需要更多的实验，因此涉及更多的不确定性和可变性。软件工程是编写规则供机器遵循的确定性过程，而机器学习则更具概率性，因为它自动化了编写规则的任务。
例如，如果你想教一台机器识别一只猫。在软件工程中，你可能会想出像“一只猫有四条腿和两只尖耳朵”这样的规则但这和狗有什么不同呢？如果你用深度学习，而不是显式的规则，你会给机器喂一堆猫的照片(贴标签的图像)，让机器自己学习。通过这样做，你让机器自己写规则。您和您的团队所做的是定义问题、准备数据、构建一组模型、测试和迭代，直到您有一个交付期望结果的模型。
这就是为什么团队在开发 ML 产品时，一般需要冒更大的风险。对于项目经理来说，帮助设定正确的期望以避免团队之间的潜在冲突是很重要的。例如，软件工程师可能觉得 ML 团队没有给他们足够清晰的需求，没有理解 ML 产品的本质。让工程师与研究人员/科学家密切合作也很重要，这样他们可以相互平衡。更重要的是，最好让端到端系统更快地工作，以确保 ML 团队一直在研究的算法实际上与业务目标一致。
2.开发 ML 是一个高度迭代的过程。
如前所述，ML 非常适合于解决人类无法显式编程的复杂问题。模型需要被训练、测试和调整。在选择一个令人满意的方法之前，科学家经常要测试几种方法。这就是为什么定义里程碑和估计 ML 产品的时间表通常更加困难。由于 ML 产品的性质，对于产品经理来说，清楚地定义需求和度量标准并确保团队根据期望的度量标准频繁地测试模型是至关重要的。
3.除了技术挑战，还有更多结构性挑战。
因为 ML 与软件工程如此不同，它需要一些根本性的组织变革:实验文化，数据分析驱动的思维模式，以及对不确定性更加开放，等等。如果在位者将 ML 视为一个纯粹的技术问题而忽视了相关的组织变革，他们可能会面临“创新者的困境”。对于过去追求高精度的机器人制造商等公司来说，在内部开发 ML 产品尤其具有挑战性。此外，ML 产品需要大数据集进行训练。公司需要建立自己的数据管道和基础设施来支持 ML 产品的扩展。
4.ML 仍然是一个新的领域，它将继续发展。
术语“软件工程”第一次出现在 1965 年，在编程语言开始出现 15 年之后。将近 20 年后，软件工程研究所成立，以管理软件工程过程。今天，我们已经普遍接受了软件工程的最佳实践。另一方面，机器学习在 20 世纪 90 年代才开始作为一个独立的领域蓬勃发展。深度学习是 ML 的一个子集，它在包括图像识别和 NLP 在内的许多问题上创造了新的准确性记录，但直到 2012 年 AlexNet 的崛起才被广泛讨论。与软件工程相比，ML 仍然处于起步阶段，因此缺乏行业标准、度量标准、基础设施和工具。企业仍在探索最佳实践，扼杀应用。
5.ML 产品的可解释性和可解释性问题。
许多 ML 算法缺乏透明度，就像一个黑盒，接受输入(例如图像)并输出预测(例如图像中的对象/人是什么/谁)。这使得产品经理很难解释 ML 模型是如何工作的，也很难得到用户和利益相关者的认可。尤其是在医疗保健等关键领域，问责制和透明度极其重要。在不清楚算法实际如何工作的情况下，确保 ML 工作和客户问题之间的一致性是一项挑战。
面对所有这些挑战，我们应该如何着手管理 ML 产品？对于 ML 产品来说，好的 PM 本能在哪里变坏了？在第二部分，我将更多地谈论我的学习和最佳实践。
连接更深:如果你喜欢读这篇文章，请 在这里订阅我的个人博客！
最佳实践和我一路走来学到的东西。
towardsdatascience.com](/how-to-manage-machine-learning-products-part-ii-3bdabf91eae4)
Bastiane Huang 是 OSARO 的产品经理，OSARO 是一家总部位于旧金山的初创公司，致力于开发软件定义的机器人。她曾在亚马逊的 Alexa 小组和哈佛商业评论以及该大学的未来工作倡议中工作。她写关于 ML、机器人和产品管理的文章。跟着她到这里 。
本帖已在【www.productschool.com】社区发布。
如何管理机器学习产品——第二部分
最佳实践和我一路走来学到的东西。
在第一部分，我谈到了管理 ML 产品的基础和挑战。开发 ML 产品需要更多的实验和迭代。因此，作为一名项目经理，你需要给工程师和科学家足够的空间和灵活性去探索，然后再决定前进的道路。但是你如何帮助你的团队应对这些不确定性呢？在允许您的团队探索的同时，您如何着手定义业务问题和度量？
为什么管理机器学习产品这么难？为什么你应该关心？
towardsdatascience.com](/how-to-manage-machine-learning-products-part-1-386e7011258a)
1.规划:从明确问题开始。
ML 是一种工具，一种达到目的的手段。如果你正在解决的问题不需要 ML，就不要构建 ML 产品。从识别问题开始，即需求大(业务潜力)且可解决(技术可行性)的客户痛点。你可以做一个市场评估练习来评估业务潜力。那么下一个问题是:我们如何知道 ML 是否可以帮助解决我们的用户问题。有许多 ML 的应用，但核心是，ML 最适合做决策或预测。我们可以将 ML 应用程序分为几种类型。
- 检测/检查:帮助用户识别缺陷或异常在哪里，例如银行或保险中的欺诈检测或生产线中的缺陷检测。
- 模式识别:帮助用户筛选海量数据。示例包括推荐、排名、个性化、分类、预测性维护、聚类以及与人类的交互(例如用于智能扬声器(如 Alexa 或 Google Home)的自然语言处理(NLP))。
- 高维认知:帮助用户筛选海量高维感官数据。例子包括人工智能机器人和自动驾驶汽车。
您应该避免在产品中使用机器学习，如果:
- 你可以用简单的规则解决问题。
- 您正在构建的解决方案不需要适应新数据。
- 你无法获得训练 ML 模型所需的数据。
- 您的产品需要高精度。
- 你需要完全透明地了解你的产品是如何工作的。
一旦您找到了要解决的正确问题，下一个关键任务就是清楚地定义需求。开发 ML 产品是一个高度迭代的过程。跳过适当的计划，直接研究模型能做什么，这可能很有诱惑力。然而，如果你这样做，你可能会浪费很多时间而没有具体的结果。
2.定义目标函数(结果)和指标。允许更多的空间和灵活性。
对于 ML 产品，人类不编程规则；机器会。它更具实验性，必须与传统的分而治之的软件工程方法区别对待。很多时候，很难预测什么行得通，什么行不通。这就是为什么在决定前进的道路之前，给工程师和科学家更多的空间和时间去探索是很重要的。
作为产品经理，您可以通过以下方式帮助您的团队在如此广泛的探索过程中保持专注:
(1) 定义一个目标函数:你的模型试图预测的预期结果是什么？或者你在尝试识别数据中的模式？有什么“基本事实”可以让你比较你的模型的结果吗？例如，如果您设计一个模型来预测天气，您可以通过将预测与实际天气数据进行比较来验证模型的性能。
(2) 定义绩效指标:你如何衡量你产品的成功或失败？设定验收标准并不总是那么简单。例如，如何衡量翻译模型相对于人类翻译的性能？有时，您需要看到模型的初始结果，然后决定标准。但是重要的是尽早考虑测试标准，并不断地测试模型，直到找到能够交付满意结果的正确模型。
(3) 从头到尾早期频繁的测试模型:你可以把 ML 模型想象成黑盒。您定义了您希望您的模型生成的输入和输出，而不必了解黑盒中正在发生什么。这就是为什么构建端到端原型并尽可能早地和频繁地测试模型是重要的。从可以帮助您测试关键功能的简单原型开始，然后对其进行迭代。避免不惜一切代价从全面的端到端解决方案开始。
需要注意的一件重要事情是，模型准确性本身通常不是一个好的度量标准。相反，考虑测量精度(真阳性/所有正预测)并召回(正预测/所有真阳性)。正如维基百科解释的那样:精确度是关于有多少被选择的条目是相关的，召回是关于有多少相关的条目被选择。没有适用于所有情况的经验法则。您需要根据您的业务案例来决定取舍。
3 从第一天开始就考虑你的数据策略。
训练 ML 模型通常需要大量高质量的数据。当用大量数据训练时，深度学习的表现优于旧的算法。因此，从第一天开始就概述你的数据获取策略是极其重要的。您可以购买数据，与其他公司合作，从您的客户那里收集数据，内部生成数据，或者雇佣第三方为您生成或标记数据。你需要考虑你的竞争对手是怎么做的，你的客户和监管者是怎么想的，以及每种策略相应的可行性和成本。搞清楚你的数据策略不是数据科学家的责任。这是一个战略性的商业决策，需要产品经理、高管和关键利益相关者来定义。
如果你是一家初创公司，请三思而后行。是否有行业巨头主导大部分数据？例如，你可能不想在购买历史上与亚马逊竞争，或者在位置数据上与谷歌地图竞争。尝试找到一些利基市场，还没有一家公司主导市场。
你能建立一个可防御的和可持续的数据管道吗？遵守用户隐私政策的情况如何？如果您的公司在欧盟范围内运营，请熟悉 GDPR(一般数据保护法规)和其他数据保护法规。例如，根据 GDPR 法案，公司需要确保不仅合法地收集个人数据，而且保护个人数据不被误用或利用。因此，作为项目经理，您需要从产品开发的早期阶段就考虑数据保护措施。
请确保您与您的 ML 团队讨论，以确定您需要哪些数据以及需要多少数据。让法律和运营等其他利益相关方也参与进来。为机器人和自动驾驶汽车等物理世界开发 ML 产品带来了更多挑战。确保您利用模拟并关注研究领域，包括模拟到真实、数据增强、迁移学习和元学习，以寻找降低您对海量数据的需求并加速您的培训过程的方法。
4 超越 ML 思考。
在大多数情况下，你实际上不仅仅是在构建一个 ML 产品。为了使它成为一个完整的产品，您需要一个用户界面、执行模型预测的软件和/或硬件组件。例如，如果你太专注于构建 ML 模型而忽略了用户体验，你就不会有一个成功的产品。你需要一个多功能的团队，不仅包括 ML 工程师和科学家，还包括数据工程师、软件工程师、UX UI 专家和/或硬件工程师。您还需要与后端工程师合作，以确保基础设施能够支持 ML 团队。
尽量减少不同职能或团队之间的相互依赖和冲突。如前所述，ML 的本质使得它与传统的软件编程完全不同。例如，虽然每日站立会议可能有助于保持软件工程团队的生产力，但它可能不是 ML 团队的最佳实践。这就是为什么 ML 可能不仅需要技术上的改变，还需要组织上的改变。作为一个项目经理，你可以帮助其他团队理解为什么和如何构建 ML 产品是不同的，并帮助解决潜在的冲突。你也应该试着将 ML 固有的不确定性传达给你组织中的其他利益相关者。
沟通不仅对内部团队至关重要，对客户也是如此。ML 产品的性能随着时间的推移而提高。很可能一开始顾客不会得到完美的结果。你的用户能接受吗？如何减轻用户的风险并保证可接受的基线性能？如何设计你的产品来优化用户体验？
5.提出投资 ML 的理由。
如果您想投资 ML 特性，请考虑以下几点:
- 增强用户体验或产品功能:例如，ML 能否用于个性化或定制您的产品，以便您的用户更容易找到最相关的结果？或者可以应用 ML 来增加你的预测或者预言的准确性吗？考虑内部用户和外部用户(客户)的潜在应用。
- 自动化流程或重复性任务:贵公司员工或客户需要反复经历的流程有没有可以自动化的？通过自动化重复任务，您可以节省时间、成本和资源，还可能创造更好的用户体验。如果流程太复杂，有没有可能实现部分流程自动化，或者帮助人类更高效地做事？Gmail 的智能撰写就是一个很好的例子:Gmail 现在可以自动完成你的句子，而不是让用户每次都键入相同的单词或句子，如“best communication s”。
- 开启新的商业机会:有没有什么新的机会或商业问题是无法解决的，但现在似乎可以用 ML 解决？例如，仓库中的拣货过程是高度人工的，因为对机械臂进行编程来识别和处理数百万件产品是不可行的。但是现在有了 ML，机器人可以在人类最少的监督下学习识别各种各样的物体。这为仓库中的人工智能机器人带来了巨大的机会。
6.好的项目管理本能对 ML 产品来说变坏了。
有时候管理软件产品的最佳实践不一定适用于 ML 产品。以下是我经常提醒自己的几件事:
- 认识开发 ML 和软件产品之间的区别。没有放之四海而皆准的方法。需要的时候调整你的冲刺过程、计划或组织。
- 不要在你的 PRD 上详细列出所有的需求，而要专注于定义目标函数和关键绩效标准，让团队去探索和实验。
- 不要在开发过程的开始就要求你的 ML 团队给出确定性的结果，而是和团队一起尽早地、经常地开发和测试端到端的原型。
- ML 只是工具之一。不到万不得已不要用 ML。
摘要—我希望您记住这一系列文章的以下内容:
- ML 最适合做决策或预测。
- 管理 ML 产品比管理普通软件产品更具挑战性，因为它涉及更多的不确定性，不仅需要技术上的改变，还需要组织上的改变。
- 清楚地定义问题，确定需求范围，设置度量标准，在决定前进的道路之前，给工程师和科学家足够的空间和灵活性去探索。
- 从第一天开始就考虑你的数据策略。
- 构建 ML 产品是跨学科的。超越 ML 思考。
深入联系:如果你喜欢阅读这篇文章，请在这里订阅我的个人博客！
Bastiane Huang 是 OSARO 的产品经理，OSARO 是一家总部位于旧金山的初创公司，致力于开发软件定义的机器人。她曾在亚马逊的 Alexa 小组和哈佛商业评论以及该大学的未来工作倡议中工作。 她写的是关于 ML、机器人和产品管理的文章。跟着她到这里 。
本帖已在www.productschool.com社区发布。
如何使用 DVC、权重和偏见以及 Docker 管理您的机器学习工作流程
管理机器学习工作流是很难的。除了软件工程中常见的挑战，机器学习工程师还需要考虑实验跟踪、可重复性、模型部署和治理。在本文中，我想展示 3 个强大的工具，通过使跟踪、复制、管理和部署模型变得容易，来简化和扩大组织内的机器学习开发。
对 DVC 使用版本控制
在传统的软件工程中， Git 是版本控制的行业标准。团队成员在他们自己的本地代码上工作，但是总是与中央存储库同步他们的进展和新的开发。这确保了每个人都是最新的和同步的。这是一个很好的方式，让团队的工作互相配合，而不是互相冲突，从而导致更高的产出。
机器学习有点棘手，因为它是研究和软件工程的结合。例如，数据本身很大，因此共享存储可能会很有挑战性。或者在 Jupyter 笔记本中显示更改是很困难的，因为 Git 不允许在图表中显示从提交到提交的更改。
是一个方便的工具，旨在使机器学习模型可以共享和复制。它旨在处理大型文件、数据集、机器学习模型、指标和代码。
在任何时候，您可能都需要获取您已经运行/正在运行的实验的完整上下文。DVC 保证所有的文件和度量标准都是一致的，并且在正确的位置重现实验或者作为新迭代的基线。此外，DVC 在 Git 中保存元文件来描述和版本控制你的数据和模型。如果你在一个团队中工作，DVC 可以通过定义有效工作的规则和过程来作为协作的协议。
使用权重和偏差跟踪实验
在传统的软件工程中，当程序失败时，您可以手动检查错误，以了解它失败的原因。对于机器学习模型，通常没有关于模型失败的原因或时间的信号，这使得调试更加困难。因此，跟踪您的模型实验的需求变得至关重要。
权重&偏好是一个非常棒的实验管理平台，因为它有非常好的用户体验。记录您想要记录的任何指标都非常容易。因此，它提供了一种透明的方式来找出你的机器学习模型中的瓶颈，从而实现简单的修复和更好的优化。
机器学习的一个难点是，通常有太多的超参数或太多的方法可以修改系统。因此，能够通过一次改变一件事来对比实验是至关重要的。Weights & Biases 的仪表板具有灵活性和可伸缩性，可以为您的模型预测提供大量可视化内容。作为数据科学家，您可以轻松地比较和对比不同的实验，并将它们汇总到物理报告和/或实时监控中。在数据科学团队中，权重和偏差可以成为共享日志，以跟踪哪些模型正在接受培训以及每个团队成员取得的进展。
使用 Docker 部署模型
机器学习开发中的一个巨大挑战是将训练好的模型部署到生产中并具有可扩展性。这是因为生产中的机器学习管道将出于多种目的使用多个模型。
Docker 是一个强大的容器化平台，它将应用程序及其所有依赖项打包到一个容器中。如果你来自软件工程世界，这个技术一定非常熟悉。当您有许多在竖井中工作的服务时，您可以使用 Docker 作为数据提供者将这些服务连接到一个 web 应用程序中。根据负载情况，可以根据设置的规则按需剥离实例。
你开发的机器学习模型很有可能具有非统一的环境(Windows vs Unix)，不同的库包(TensorFlow vs PyTorch)，或者各种资源需求(GPU vs TPU)，GPU 容器可以通过将不同的模型放入不同的容器并根据需求分配灵活的资源来处理所有这些挑战。
事实上，您可以使用命令“wandb Docker”轻松地将权重&偏差与 Docker 集成起来——该命令设置一个安装了标准包的 Docker 映像，安装您的代码，并将您放入其中。该命令自动启动 Docker 映像，默认安装了 TensorFlow、PyTorch、Keras 和 Jupyter 这是典型的深度学习工具包。在模型训练过程中，Weights&bias 将保存 Docker 映像状态的永久记录，这样您将始终能够恢复代码运行的确切环境。
在未来的任何时候，您都可以运行" wandb restore
结论
正如本文所证明的，您的整个机器学习工作流可以通过第三方应用程序来管理。使用这些新兴平台中的任何一个都可以让你的项目保持有序，让你作为一名机器学习工程师更有效率。
如何在 20 分钟内掌握 Python 的主要数据分析库
熊猫终极指南——第一部分
熊猫基本功能的代码指南。
Photo by Sid Balachandran on Unsplash
本文阐述了有抱负的数据科学家和数据分析师经常面临的典型问题和挑战。我们将通过利用 Python 最强大的数据操作和分析库 Pandas 来解决这些问题和应对这些挑战。
在本文中，我们将讨论以下主题:
你可以在这里找到完整的 Jupyter 笔记本。但是我强烈建议您亲自完成这些步骤。毕竟，熟能生巧。
先决条件:
一个工作的 Python 环境(我建议 Jupyter 笔记本)。如果你还没有设置这个，不要担心。在上周的文章中，我们讨论了如何设置 Anaconda，并解释了如何打开您的第一个 Jupyter 笔记本。如果你还没有这样做，看看链接的文章。做好一切准备只需不到 10 分钟。
到底是什么阻止了你？下面是如何开始！
towardsdatascience.com](/get-started-with-python-e50dc8c96589)
1.设置
Photo by Ivan Zhukevich on Unsplash
在进行任何数据操作之前，我们先获取一些数据。我们将使用 2019 年世界幸福报告中的数据。我将提供一个稍微调整过的原始数据版本，其中也包括各大洲。
这个 GitHub Repo 保存数据和代码。如果不熟悉 GitHub，还可以从这个 链接 下载一个打包的 zip 文件！解压文件并将内容(尤其是happiness_with_continent.csv)移动到 Jupyter 笔记本所在的文件夹中(如果还没有，创建一个)。
在新笔记本中运行import pandas as pd(即，将 Pandas 库导入到工作簿中，以访问这些功能。
我喜欢这样调整我的笔记本设置:
from IPython.core.display import display, HTML
display(HTML("<style>.container {width:90% !important;}</style>"))
这些命令使笔记本变得更宽，从而利用屏幕上的更多空间(通常笔记本有固定的宽度，这与宽屏很不一样)。
2.加载数据
Photo by Markus Spiske on Unsplash
Pandas 将数据存储为序列(一列)或数据帧(一列或多列)，后者只是一个或多个序列的组合。
注意:每当我们用以下加载函数之一加载数据时，结果将存储在 DataFrame 中。
pd.read_csv
对我来说，加载数据的主要方式是熊猫。它完全符合我对数据的思考方式，那就是大量的表格。
您可以像这样从本地文件加载数据:
data = pd.read_csv('happiness_with_continent.csv')
或者您可以从 web 直接读取数据到数据帧中，如下所示:
data = pd.read_csv('[https://raw.githubusercontent.com/FBosler/you-datascientist/master/happiness_with_continent.csv'](https://raw.githubusercontent.com/FBosler/you-datascientist/master/happiness_with_continent.csv'))
从 Excel 或 Google 工作表
从 Excel 中读取数据非常简单。Google Sheets 有点棘手，因为它要求你首先通过一个认证程序。你可以在这里阅读所有关于从 Excel 和 Google 工作表中提取数据的内容:
或者如何学习统一 Google 工作表、Excel 和 CSV 文件——代码指南
towardsdatascience.com](/replacing-sheets-with-python-f1608e58d2ca)
pd.read_clipboard
这个我很少用，但是对于较小的表肯定有效。例如，只需标记并复制(ctrl+c)Google sheets 中的一个表格，然后运行pd.read_clipboard()。
示例:导航此处(我找到的第一个公共表单)并标记一个区域，如截图所示。
After hitting ctrl+c the data will be in your clipboard, you can now use pd.read_clipboard
Running pd.read_clipboard on previously copied data with parameter index_col=’name’
基于 read_csv 的函数(和 read_clipboard)的一些值得注意的参数:
sep:分栏符(默认为,，也可以是 tab)header:默认为'infer'(即熊猫猜测你的头是什么)，可选为整数或整数列表(多级名称)。例如，您可以做header=3，数据帧将从第 4 行开始(因为 Python 是 0 索引的)作为标题。如果您的数据没有标题，请使用header=Nonenames:栏目名称。如果您想使用这个参数来覆盖 Pandas 推断出的任何列名，那么您应该指定header=0(或者您的列名所在的行)，如果您不这样做，那么您的名称将作为列名，然后在第一行中显示原始的列名。names参数需要一个列表，例如['your col 1', 'your col 2', ... 'your last col name']index_col:设置加载时的索引(即我们将索引设置为name)。稍后我们将了解更多关于索引的内容)skiprows:跳过前 x 行，当文件开头包含一些元数据，如作者和其他信息时，这很有用skipfooter:跳过最后 x 行，当文件末尾有元数据(例如脚注)时很有用parse_date:这个参数告诉熊猫，它应该把哪些列解释为日期(例如pd.read_csv(happiness_with_continent.csv,parse_dates=['Year']))。默认的解析器开箱即可正常工作。在遇到奇怪的数据格式时，Pandas 可以使用定制的日期解析器(为此，您必须指定解析逻辑)。
还有一堆额外的(很少使用的)参数。您可以通过在单元格中运行pd.read_csv?来阅读这些内容(在命令后添加一个问号将打印帮助文本)。
无论我们如何读取数据，我们都希望将它存储在一个变量中。我们通过将读取结果赋给一个变量来实现，比如data = pd.read_clipboard()或data = pd.read_csv('NAME_OF_YOUR_FILE.csv')
其他读取方法:
下面的阅读方法很少出现在我身上，但是在熊猫身上也实现了:
- 阅读 _ 羽毛
- read_fwf
- read_gbq
- read_hdf
- read_html
- read_json
- read_msgpack
- 阅读 _ 拼花地板
- 阅读 _ 泡菜
- 读取 _sas
- 读取 _sql
- 读取 sql 查询
- 读取 sql 表
- read_stata
- 读取 _ 表格
3.检查/分类/过滤数据
Photo by Max Böttinger on Unsplash
①检查—第一行、最后一行、随机行
在笔记本中显示数据有三种标准方式，head、tail和sample。head显示第一行，tail显示最后一行，sample显示随机选择的行。
data.head(x) previews the first x rows of the data
data.tail(x) previews the last x rows of the data
data.sample(x) previews x randomly selected rows of the data
注意gini of household income reported in Gallop, by wp5-year栏前有圆点。圆点表示存在未显示的列。要更改笔记本设置以显示更多列/行，请运行以下命令:
pd.set_option('display.max_columns', <number of columns you want>)
pd.set_option('display.max_rows', <number of rows you want>)# I typically usepd.set_option('display.max_columns', 50)
pd.set_option('display.max_rows', 8)
但是，请注意，您正在加载的文件通常非常大(1GB 以上),因此出于性能原因，不可能显示所有数据。因此，您应该尝试在更高的层次上熟悉数据，而不要依赖于直观地浏览行。
②检查—形状、列、索引、信息、描述
data.shape返回数据帧的尺寸。在我们的例子中，1704 行，27 列。
**IN:** data.shape**OUT:** (1704, 27)
data.columns返回数据帧中所有列名的列表。
**IN:**
data.columns**OUT:**
Index(['Country name', 'Year', 'Life Ladder', 'Log GDP per capita',
'Social support', 'Healthy life expectancy at birth',
'Freedom to make life choices', 'Generosity',
'Perceptions of corruption', 'Positive affect', 'Negative affect',
'Confidence in national government', 'Democratic Quality',
'Delivery Quality', 'Standard deviation of ladder by country-year',
'Standard deviation/Mean of ladder by country-year',
'GINI index (World Bank estimate)',
'GINI index (World Bank estimate), average 2000-16',
'gini of household income reported in Gallup, by wp5-year',
'Most people can be trusted, Gallup',
'Most people can be trusted, WVS round 1981-1984',
'Most people can be trusted, WVS round 1989-1993',
'Most people can be trusted, WVS round 1994-1998',
'Most people can be trusted, WVS round 1999-2004',
'Most people can be trusted, WVS round 2005-2009',
'Most people can be trusted, WVS round 2010-2014',
'Continent'],
dtype='object')
data.index返回关于索引的信息。我们将在排序和过滤部分更详细地讨论索引。把索引想象成行名/编号。
**IN:** data.index**OUT:** RangeIndex(start=0, stop=1704, step=1)
data.info()返回有关数据帧中非空值观察的类型和数量的信息
**IN:** data.info()**OUT:** <class 'pandas.core.frame.DataFrame'>
RangeIndex: 1704 entries, 0 to 1703
Data columns (total 27 columns):
Country name 1704 non-null object
Year 1704 non-null datetime64[ns]
Life Ladder 1704 non-null float64
Log GDP per capita 1676 non-null float64
Social support 1691 non-null float64
Healthy life expectancy at birth 1676 non-null float64
Freedom to make life choices 1675 non-null float64
Generosity 1622 non-null float64
Perceptions of corruption 1608 non-null float64
Positive affect 1685 non-null float64
Negative affect 1691 non-null float64
Confidence in national government 1530 non-null float64
Democratic Quality 1558 non-null float64
Delivery Quality 1559 non-null float64
Standard deviation of ladder by country-year 1704 non-null float64
Standard deviation/Mean of ladder by country-year 1704 non-null float64
GINI index (World Bank estimate) 643 non-null float64
GINI index (World Bank estimate), average 2000-16 1502 non-null float64
gini of household income reported in Gallup, by wp5-year 1335 non-null float64
Most people can be trusted, Gallup 180 non-null float64
Most people can be trusted, WVS round 1981-1984 125 non-null float64
Most people can be trusted, WVS round 1989-1993 220 non-null float64
Most people can be trusted, WVS round 1994-1998 618 non-null float64
Most people can be trusted, WVS round 1999-2004 491 non-null float64
Most people can be trusted, WVS round 2005-2009 630 non-null float64
Most people can be trusted, WVS round 2010-2014 671 non-null float64
Continent 1704 non-null object
dtypes: datetime64[ns](1), float64(24), object(3)
memory usage: 372.8+ KB
data.describe()返回关于数据帧的数字列的一些描述性统计信息(计数、平均值、标准差、最小值、25%、50%、75%、最大值):
①排序— data.sort_values()
在没有参数的数据上调用sort_values对我们没有任何好处。事实上，它将引发一个错误，告诉我们它缺少一个名为by的参数。这个错误是有道理的。我们必须告诉熊猫我们想要按哪个(哪些)列排序。
例如，我们可以按年份或年份和国家名称对数据进行排序，如下所示:
data.sort_values(by='Year')
data.sort_values(by=['Year','Country name'])
data.sort_values(by=['Country name','Year'])
注意:如果传递多个值，它会按照值的顺序按值排序。
默认情况下，排序将从“最低值”开始。然而，改变这种行为很容易。
data.sort_values(by='Year', ascending=True)data.sort_values(
by=['Country name','Year'],
ascending=[False,True]
)
注意: Ascending 默认为真，即最小值优先，如果你想要最大值优先，你必须指定 ascending=False
②排序— data.sort_index()
除了基于列的排序，还有基于索引的排序。按索引调用排序:data.sort_index()或data.sort_index(ascending=False)。第一个是升序，第二个是降序。
①过滤—列
排序固然很好，但我们通常关心的是数据的特定子集。有时您可能只想查看一列或多列。
选择一列: 选择一个特定的列有两种方法。假设我们想要选择Year列。我们可以选择:
data['Year']，或者data.Year(不使用这种方法)
两者做同样的事情。
The two ways of selecting columns in Pandas
注意:你可能会问，为什么完全相同的事情有两种方法？原因是方便。第二种方法稍微快一点，因为只需要两个点和列名。而在第一种方法中，您需要列名、两个上勾号和两个括号。
然而，我强烈建议使用第一种方法，因为它避免了一些小问题，并且与选择多个列相一致。
选择多个列: 假设您想要选择Country name和Life Ladder，那么您应该这样做(小心:双括号):
Selecting “Country name” and “Life Ladder” columns and sampling five random rows
注意:要特别注意您要选择的第一列和最后一列前后的双括号！无论何时使用双括号，结果都将是一个 DataFrame(即使只选择一个带有双括号的列)。我怎么强调这一点都不为过，因为我有时仍然会遇到这些错误！如果要选择多列，但只打开一组括号，括号之间的内容将被视为一列。不用说，您的数据不包含意外组合的列。
KeyError: If you only open and close one set of brackets.
②过滤—行
能够选择特定的列只是完成了一半。然而，选择行也同样简单。
熊猫中的行通过索引选择。您可以将索引视为行的名称。每当您从一个数据帧中选择行时，都会用一个具有相同索引的序列覆盖该数据帧，该序列只包含True和False值(True表示应该选择该行，False表示不应该选择该行)。然而，大多数时候，这种显式的索引选择是从用户那里抽象出来的。我仍然认为理解行选择过程是如何工作的非常重要。
您可以通过索引选择一行或多行。有两种方法可以做到这一点:
[data.iloc](#7d8b)或者[data.loc](#86f2)
iloc: data.iloc允许通过位置(即通过行数)选择行(以及可选的列)。
iloc —选择一行:
语法如下data.iloc[row_number (,col_number)]，括号中的部分是可选的。
data.iloc[10] selects the 10th row
注意:格式看起来有点不常规，这是因为当选择一行且仅选择一行时，将返回一个系列。
data.iloc[10,5] selects the 5th column out of the 10th row
iloc —选择多行: 语法如下data.iloc[start_row:end_row (,start_col:end_col)]所示，括号中的部分是可选的。
data.iloc[903:907] selects the 903rd to 907th row
或者，您还可以指定要选择的列。
data.iloc[903:907,0:3] selects for the 903rd to 907th row the 0th to 3rd column
loc: data.loc与iloc相反，允许通过以下方式选择行(和列):
- 标签/索引或
- 使用布尔/条件查找
为了更好地解释第一点，也为了更好地将其与iloc区分开来，我们将把国家名称转换成数据帧的索引。为此，运行以下命令:
data.set_index('Country name',inplace=True)
set_index命令在数据帧上设置一个新的索引。通过指定inplace=True，我们确保数据帧将被改变。如果我们没有指定 inplace=True，我们将只能看到数据帧在应用操作后的样子，但底层数据不会发生任何变化。
数据帧现在应该如下所示:
DataFrame after setting ‘Country name’ as the index
我们可以看到，DataFrame 丢失了它的行号(以前的)索引，并获得了一个新的索引:
New Index of the DataFrame
loc —通过一个索引标签选择行: 语法如下data.loc[index_label (,col_label)]，括号中的部分是可选的。
data.loc[‘United States’] selects all rows with ‘United States’ as the index
loc —通过索引标签和列标签选择行和列:
data.loc[‘United States’,’Life Ladder’] selects the column ‘Life Ladder’ for all rows with ‘United States’ as the index
位置——通过多个索引标签选择行:
data.loc[[‘United States’,’Germany’]] selects all rows with ‘United States’ or ‘Germany’ as the index
备注:
- 像前面一样，当选择多个列时，我们必须确保将它们放在双括号中。如果我们忘记这样做，列将被认为是一个长的(不存在的)名称。
- 我们使用样本(5)来表明在混合中有一些德国。假设我们使用 head(5)来代替，我们将只能在 12 行美国之后看到德国。
- Loc 按照提供的顺序返回行，而不考虑它们的实际顺序。例如，如果我们首先指定德国，然后指定美国，我们将得到 13 行德国，然后 12 行美国
loc-通过多个索引标签选择行和列: 您还可以为要返回的选定行指定列名。
Selecting rows and columns by label name
注意:我们将行选择['Germany','United States]和列选择['Year','Life Ladder']分布在两行上。我发现将语句拆分有助于提高可读性。
loc —通过一系列索引标签选择行: 这种选择行的方式可能有点奇怪，因为标签范围('Denmark':'Germany')不像 iloc 使用数字范围(903:907)那样直观。
指定标签范围是基于索引的当前排序，对于未排序的索引将会失败。
但是，假设您的索引已经排序，或者您在选择范围之前已经排序，您可以执行下列操作:
Using loc with a range of rows is going to return all rows between (including) Denmark and Germany
loc —布尔/条件查找 布尔或条件查找才是真正的关键所在。正如前面提到的和，无论何时选择行，这都是通过用真值和假值的掩码覆盖数据帧来实现的。
在下面的例子中，我们用索引['A','B','A','D']和 0 到 10 之间的一些随机值创建了一个小的数据帧。
然后我们创建一个具有相同索引值[True,False,True,False]的overlay。
然后，我们使用df.loc[overlay]只选择索引值为真的行。
**IN:**
from numpy.random import randint
index = ['A','B','A','D']## create dummy DataFrame ##
df = pd.DataFrame(
index = index,
data = {
'values':randint(10,size=len(index))
})
print('DataFrame:')
print(df)**OUT:** DataFrame:
values
A 8
B 2
A 3
D 2**IN:**
## create dummy overlay ##
overlay = pd.Series(
index=index,
data=[True,False,True,False]
)
print('\nOverlay:')
print(overlay)**OUT:** Overlay:
A True
B False
A True
D False
dtype: bool**IN:**
## select only True rows ##
print('\nMasked DataFrame:')
print(df.loc[overlay])**OUT:**
Masked DataFrame:
values
A 8
A 3
基于一个(或多个)条件，可以使用相同的逻辑来选择行。
我们首先创建一个布尔掩码，如下所示:
Filtering based on the value of ‘Life Ladder’ returns Series with True/False values
然后使用该掩码只选择符合指定条件的行，如下所示:
Selecting rows based on a condition
选项 1 作为替代方案也产生完全相同的结果。然而，另一种选择更清晰一些。当应用多种条件时，易读性的提高变得更加明显:
Chaining various conditions together
注意:我们使用了&(按位 and)来过滤行，其中多个条件同时适用。我们可以使用|(按位 or)来过滤符合其中一个条件的列。
loc —带有自定义公式的高级条件查找
也可以使用定制的函数作为条件，并将它们应用于选择列，这非常容易。
在下面的例子中，我们只选择能被三整除的年份和包含单词 America 的大洲。这个案例是人为的，但却说明了一个问题。
Row selection based on custom formulas conditions
除了 lambda(匿名)函数，您还可以定义和使用更复杂的函数。您甚至可以(我并不推荐)在自定义函数中进行 API 调用，并使用调用的结果来过滤您的数据帧。
4.分析功能
既然我们已经习惯了从前到后对数据进行过滤和排序，反之亦然，那么让我们转向一些更高级的分析功能。
标准功能:
像 read 函数一样，Pandas 也实现了很多分析函数。
我将强调并解释我最常用的方法。然而，这也是它美丽的一部分，甚至我会不时地发现新的有用的功能。所以千万不要开始阅读和探索！
- ①最大/最小
- ②总和
- ③平均值/中位数/分位数
- ④ idxmin/idxmax
注意:所有函数都可以按列应用，也可以按行应用。在我们的例子中，行方式的应用没有什么意义。然而，通常情况下，您有数据，您想比较不同的列，在这种情况下，行方式的应用程序确实有意义。
每当我们调用上述函数时，都会传递一个默认参数axis=0(对于按列的应用程序)。然而，我们可以覆盖这个参数并传递axis=1(对于行方式的应用)。
① max/min 对数据调用max()，将(尽可能)返回每列的最大值。min()恰恰相反。
**IN:**
data.max() **# COLUMNWISE MAXIMUM****OUT:** Year 2018
Life Ladder 8.01893
Log GDP per capita 11.7703
Social support 0.987343
...
Most people can be trusted, WVS round 1999-2004 0.637185
Most people can be trusted, WVS round 2005-2009 0.737305
Most people can be trusted, WVS round 2010-2014 0.661757
Continent South America
Length: 26, dtype: object**IN:** data.max(axis=1) **# ROW-WISE MAXIMUM****OUT:**
Country name
Afghanistan 2008.0
Afghanistan 2009.0
Afghanistan 2010.0
Afghanistan 2011.0
...
Zimbabwe 2015.0
Zimbabwe 2016.0
Zimbabwe 2017.0
Zimbabwe 2018.0
Length: 1704, dtype: float64
② sum 对数据调用sum()，将(尽可能)返回每一列的总和。
**IN:** data.sum()**OUT:** Year 3429014
Life Ladder 9264.91
Log GDP per capita 15456.8
Social support 1370.67
...
Most people can be trusted, WVS round 1999-2004 131.623
Most people can be trusted, WVS round 2005-2009 166.532
Most people can be trusted, WVS round 2010-2014 159.358
Continent AsiaAsiaAsiaAsiaAsiaAsiaAsiaAsiaAsiaAsiaAsiaEu...
Length: 26, dtype: object
注意: Sum 会将字符串连接成一个长字符串，这将为 Continent 列生成 asiasiasiasiasiasiasiasiasiasiasiasiasiasiasiaaiaeu…。
③均值/中值/分位数 对数据调用mean、median或quantile将分别返回均值或中值。
**IN:** data.mean()**OUT:** Year 2012.332160
Life Ladder 5.437155
Log GDP per capita 9.222456
Social support 0.810570
...
Most people can be trusted, WVS round 1994-1998 0.249574
Most people can be trusted, WVS round 1999-2004 0.268070
Most people can be trusted, WVS round 2005-2009 0.264336
Most people can be trusted, WVS round 2010-2014 0.237493
Length: 25, dtype: float64**IN:** data.median()**OUT:**
Year 2012.000000
Life Ladder 5.339557
Log GDP per capita 9.406206
Social support 0.833098
...
Most people can be trusted, WVS round 1994-1998 0.229924
Most people can be trusted, WVS round 1999-2004 0.232000
Most people can be trusted, WVS round 2005-2009 0.198380
Most people can be trusted, WVS round 2010-2014 0.193531
Length: 25, dtype: float64**IN:** data.quantile(q=.8)**OUT:** Year 2016.000000
Life Ladder 6.497157
Log GDP per capita 10.375623
Social support 0.913667
...
Most people can be trusted, WVS round 1994-1998 0.304498
Most people can be trusted, WVS round 1999-2004 0.388611
Most people can be trusted, WVS round 2005-2009 0.415082
Most people can be trusted, WVS round 2010-2014 0.373906
Name: 0.8, Length: 25, dtype: float64
④idx min/idx max
对数据调用idxmax或idxmin将返回找到第一个最小值/最大值的行的索引。然而，只可能在一些普通的列上调用这个函数。
**IN:** data.iloc[:,:-1].idxmax() # We exclude the Continent Column**OUT:** Year Afghanistan
Life Ladder Denmark
Log GDP per capita Qatar
Social support New Zealand
...
Most people can be trusted, WVS round 1994-1998 Norway
Most people can be trusted, WVS round 1999-2004 Sweden
Most people can be trusted, WVS round 2005-2009 Norway
Most people can be trusted, WVS round 2010-2014 Netherlands
Length: 25, dtype: object
这意味着，例如，丹麦的社会支持值最高Life Ladder，卡塔尔最高Log GDP per capita和New Zealand。
idxmin的工作原理与idxmax相同。
总结:不要忘记，您可以按列(轴=0)或行(轴=1)应用所有这些函数
应用/自定义功能:
您还可以编写自定义函数，并在行或列上使用它们。有两种自定义函数:
- 命名函数
- λ函数
命名函数是用户定义的函数。它们是通过使用保留关键字def来定义的，如下所示:
命名函数:
**FUNCTION:**
def above_1000_below_10(x):
try:
pd.to_numeric(x)
except:
return 'no number column'
if x > 1000:
return 'above_1000'
elif x < 10:
return 'below_10'
else:
return 'mid'**IN:** data['Year'].apply(above_1000_below_10)**OUT:** Country name
Afghanistan above_1000
Afghanistan above_1000
Afghanistan above_1000
Afghanistan above_1000
...
Zimbabwe above_1000
Zimbabwe above_1000
Zimbabwe above_1000
Zimbabwe above_1000
Name: Year, Length: 1704, dtype: object
这里我们定义了一个名为above_1000_below_10的函数，并将其应用于我们的数据。
该函数首先检查该值是否可转换为数字，如果不可转换，将返回“无数字列”否则，如果值大于 1000，函数返回 above_1000，如果值小于 10，函数返回 below_10，否则返回 mid。
Lambda 函数: 对我来说，Lambda 函数出现的频率比命名函数高得多。本质上，这些都是简短的一次性函数。这个名字听起来很笨拙，但是一旦你掌握了窍门，它们就很方便了。例如，我们可以首先在空间上拆分大陆列，然后获取结果的最后一个词。
**IN:** data['Continent'].apply(lambda x: x.split(' ')[-1])**OUT:** Country name
Afghanistan Asia
Afghanistan Asia
Afghanistan Asia
Afghanistan Asia
...
Zimbabwe Africa
Zimbabwe Africa
Zimbabwe Africa
Zimbabwe Africa
Name: Continent, Length: 1704, dtype: object
注意:命名函数和 lambda 函数都应用于单独的列，而不是整个数据帧。将函数应用于特定列时，函数逐行执行。当将函数应用于整个数据帧时，函数逐列执行，然后应用于整个列，并且必须以稍微不同的方式编写，如下所示:
**IN:**
def country_before_2015(df):
if df['Year'] < 2015:
return df.name
else:
return df['Continent']**# Note the axis=1** data.apply(country_before_2015, axis=1)**OUT:** Country name
Afghanistan Afghanistan
Afghanistan Afghanistan
Afghanistan Afghanistan
Afghanistan Afghanistan
...
Zimbabwe Africa
Zimbabwe Africa
Zimbabwe Africa
Zimbabwe Africa
Length: 1704, dtype: object
在这个例子中，我们也是逐行进行的(由axis=1指定)。当该行的年份小于 2015 年或该行的洲时，我们返回该行的名称(恰好是索引)。当您必须进行条件数据清理时，这样的任务确实会出现。
合并列:
有时你想增加、减少或合并两列或多列，这真的再简单不过了。
假设我们想要添加Year和Life Ladder(我知道这是人为的，但我们这样做是为了便于讨论)。
**IN:**
data['Year'] + data['Life Ladder']**OUT:** Country name
Afghanistan 2011.723590
Afghanistan 2013.401778
Afghanistan 2014.758381
Afghanistan 2014.831719
...
Zimbabwe 2018.703191
Zimbabwe 2019.735400
Zimbabwe 2020.638300
Zimbabwe 2021.616480
Length: 1704, dtype: float64
和-, *, /一样，你还可以做更多的字符串操作，就像这样:
**IN:** data['Continent'] + '_' + data['Year'].astype(str)**OUT:** Country name
Afghanistan Asia_2008
Afghanistan Asia_2009
Afghanistan Asia_2010
Afghanistan Asia_2011
...
Zimbabwe Africa_2015
Zimbabwe Africa_2016
Zimbabwe Africa_2017
Zimbabwe Africa_2018
Length: 1704, dtype: object
注意:在上面的例子中，我们想把两列组合成字符串。为此，我们必须将data['Year']解释为一个字符串。我们通过在列上使用.astype(str)来实现。为了简洁起见，我们不会在本文中深入探讨类型和类型转换，而是在另一篇文章中讨论这些主题。
分组依据
到目前为止，我们应用的所有计算都是针对整个集合、一行或一列的。然而——这正是令人兴奋的地方——我们还可以对数据进行分组，并计算各个组的指标。
假设我们想知道每个国家的最高Life Ladder值。
**IN:** data.groupby(['Country name'])['Life Ladder'].max()**OUT:** Country name
Afghanistan 4.758381
Albania 5.867422
Algeria 6.354898
Angola 5.589001
...
Vietnam 5.767344
Yemen 4.809259
Zambia 5.260361
Zimbabwe 4.955101
Name: Life Ladder, Length: 165, dtype: float64
假设我们希望每年有最高的Life Ladder的国家。
**IN:** data.groupby(['Year'])['Life Ladder'].idxmax()**OUT:** Year
2005 Denmark
2006 Finland
2007 Denmark
2008 Denmark
...
2015 Norway
2016 Finland
2017 Finland
2018 Finland
Name: Life Ladder, Length: 14, dtype: object
或者多级组，假设我们想要每个洲/年组合中Life Ladder最高的国家。
**IN:**
data.groupby(['Year','Continent'])['Life Ladder'].idxmax()**OUT:** Year Continent
2005 Africa Egypt
Asia Saudi Arabia
Europe Denmark
North America Canada
...
2018 Europe Finland
North America Canada
Oceania New Zealand
South America Chile
Name: Life Ladder, Length: 83, dtype: object
像之前的一样，我们可以使用许多标准函数或自定义函数(命名或未命名)，例如，为每组返回一个随机国家:
**IN:**
def get_random_country(group):
return np.random.choice(group.index.values)# Named function
data.groupby(['Year','Continent']).apply(get_random_country)# Unnamed function
data.groupby(['Year','Continent']).apply(
lambda group: np.random.choice(group.index.values)
)**OUT:** Year Continent
2005 Africa Egypt
Asia Jordan
Europe France
North America Mexico
...
2018 Europe North Cyprus
North America Nicaragua
Oceania Australia
South America Chile
Length: 83, dtype: object
注意: groupby 总是为每组返回一个值。因此，除非您按只包含唯一值的列进行分组，否则结果将是一个较小的(聚合的)数据集。
改变
有时，您不希望每个组只有一个值，而是希望属于该组的每一行都有您为该组计算的值。您可以通过以下方式完成此操作:
**IN:** data.groupby(['Country name'])['Life Ladder'].transform(sum)**OUT:** Country name
Afghanistan 40.760446
Afghanistan 40.760446
Afghanistan 40.760446
Afghanistan 40.760446
...
Zimbabwe 52.387015
Zimbabwe 52.387015
Zimbabwe 52.387015
Zimbabwe 52.387015
Name: Life Ladder, Length: 1704, dtype: float64
我们得到一个国家所有得分的总和。我们还可以做:
**IN:** data.groupby(['Country name'])['Life Ladder'].transform(np.median)**OUT:** Country name
Afghanistan 3.782938
Afghanistan 3.782938
Afghanistan 3.782938
Afghanistan 3.782938
...
Zimbabwe 3.826268
Zimbabwe 3.826268
Zimbabwe 3.826268
Zimbabwe 3.826268
Name: Life Ladder, Length: 1704, dtype: float64
得到每个国家的中位数。然后，我们可以像这样计算每一年的值的差异(因为转换保留了索引):
**IN:**
data.groupby(['Country name'])['Life Ladder'].transform(np.median) \
- data['Life Ladder']**OUT:** Country name
Afghanistan 0.059348
Afghanistan -0.618841
Afghanistan -0.975443
Afghanistan -0.048782
...
Zimbabwe 0.123077
Zimbabwe 0.090868
Zimbabwe 0.187968
Zimbabwe 0.209789
Name: Life Ladder, Length: 1704, dtype: float64
这篇文章应该给你一些思考。最初，我还想包括访问器、类型操作和连接、合并和连接数据帧，但是考虑到文章的长度，我将这些主题移到了本系列的第二部分:
[## 在 20 分钟内了解 Python 主数据分析库的高级功能
熊猫高级功能代码指南。
towardsdatascience.com](/learn-advanced-features-for-pythons-main-data-analysis-library-in-20-minutes-d0eedd90d086)
到时见，继续探索！
哦，如果你喜欢阅读这样的故事，并想支持我成为一名作家，考虑注册成为一名灵媒成员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你用我的链接注册，我甚至会得到一些🍩。
[## 通过我的推荐链接加入 Medium-Fabian Bosler
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@fabianbosler/membership)
如何在 Airbnb 上实现利润最大化？基于数据的主机方法。
Foto credit unsplash.com/@filios_sazeides
可能每个人都听说过或使用过 Airbnb——在世界各地安排寄宿家庭的在线社区市场。Airbnb 将主人与游客联系起来，并负责包括支付在内的整个交易过程。也许你想在度假时在 Airbnb 上列出你的公寓，以赚取额外的钱。也许你已经在 Airbnb 上列出了你的房产，但你的利润有限，没有人联系你。你的价格太高了吗？Airbnb 不会告诉你这个。如何用你的财产赚更多的钱？如何确定你的 Airbnb 列表的最佳价格？数据可以帮助你深入了解 Airbnb 市场，以及在为你的 Airbnb 房产制定价格策略之前应该考虑什么。
我们使用了西雅图 Airbnb 的公开数据，这给我们的分析带来了限制。这个内幕可能只在西雅图或美国西海岸类似人口的任何城市有效(西雅图市 70 万；西雅图市区 3 . 000 . 000；).我们的方法通过每人每晚的价格来比较不同的 Airbnb 属性。
哪些属性增加了我的 Airbnb 挂牌价格？
像酒店行业一样，五星级设施的成本更高，但也提供更高的舒适度、质量和服务，Airbnb 上的价格也存在类似的现象。大楼里的电梯(20%)、前门的门卫(12%)、健身房(12%)或游泳池(8%)会对价格产生积极影响。不足为奇的是，在市中心(16%)、安妮女王(9%)或国会山(8%)等热门地区，价格更高。此外，客人对酒店位置的良好评价(12%)会影响价格，甚至比良好的清洁度评分(4%)更重要。
Price per person along Seattle districts.
像船一样过夜的不寻常的航空旅馆对价格有正面影响(8 %)。这可能是对主人的一个建议，让他们的位置看起来特别或独特。
但是，如果主人不能搬到游客最喜欢的地方，也不能改变她居住的建筑的属性，那该怎么办呢？数据还显示，安装空调(8%)、真正的床(6%)、有线电视(11%)或普通电视(7%)和热管(6%)可能会有所回报。这些小小的改进产生了积极的影响，提高了标准和价格。
每人的整体价格还取决于清洁费(35 %)和保证金(20%)。向客人收取额外的清洁和保安费用可能是增加利润的好主意，但可能会阻止客人预订。我们的数据方法没有回答这个问题。
拥有一个以上列表(8 %)的主机似乎要价更高，这导致了一个假设，即更有经验的主机更了解市场。
严格的取消政策(13%)，要求客人的电话验证(8%)或客人的个人资料图片(7 %)对价格有正面影响，可以从两个方面解读。首先，受欢迎的主人可能会收取更高的价格，但也希望确保他们的租金收入，而不会让善变的客人在最后一刻取消订单。更有可能的是，受欢迎的主持人收紧了他们的预订政策。第二，拥有更昂贵、更豪华、标准更高的房子的人，可能会更愿意让经过核实、值得信任的陌生人进入他们的房子。
cleaning_fee 0.350421
security_deposit 0.203517
Elevator in Building 0.198643
neighbourhood_group_cleansed_Downtown 0.162595
cancellation_policy_strict 0.130720
Doorman 0.121563
review_scores_location 0.121196
Gym 0.120789
Cable TV 0.113371
neighbourhood_group_cleansed_Queen Anne 0.090053
calculated_host_listings_count 0.083392
Pool 0.083153
property_type_Boat 0.079727
neighbourhood_group_cleansed_Capitol Hill 0.078682
require_guest_profile_picture 0.077501
Air Conditioning 0.076503
TV 0.075863
Kitchen 0.071869
require_guest_phone_verification 0.069068
bathrooms 0.067893
bed_type_Real Bed 0.063524
Hot Tub 0.060124
review_scores_rating 0.057456
property_type_Condominium 0.051757
review_scores_cleanliness 0.047834
extra_people 0.043730
neighbourhood_group_cleansed_Cascade 0.042380
property_type_Bed & Breakfast 0.039962
哪些属性会降低我的 Airbnb 标价？
西雅图的一些地区不是很受欢迎:雷尼尔谷(-9%)、德尔里奇(-8%)、北门(-8%)、比肯山(-6%)、苏厄德公园(-6%)或其他一些不太出名的街区(-7 %)。
酒店类型私人房间(-17 %)或房子(-13 %)允许的客人数量少(-16 %)，床位数量少(-9%)似乎比宽敞的酒店更便宜。
住在酒店的宠物(-8%)也可能会吓退一些客人。有些客人可能对狗或猫过敏，遗憾的是，并不是每个人都喜欢动物。
令人惊讶的是，价格越高，主机收到的评论越少(-12 %)和每月评论越少(-22 %)。原因可能是越贵的房产每月的预订率越低。一个主持人的预约越少，她收到的评论就越少。由于该分析不包括时间因素，我们必须进一步调查，哪种情况更有希望:一个月内以更低的价格接待更多的客人，还是以更高的价格接待更少的客人。
Distribution for number of reviews, price per person and reviews per month.
neighbourhood_group_cleansed_Seward Park -0.057727
Shampoo -0.058516
neighbourhood_group_cleansed_Beacon Hill -0.059966
instant_bookable -0.063909
neighbourhood_group_cleansed_Other neighborhoods -0.070834
neighbourhood_group_cleansed_Northgate -0.075342
Pets live on this property -0.078505
neighbourhood_group_cleansed_Delridge -0.083484
beds -0.087425
neighbourhood_group_cleansed_Rainier Valley -0.088460
Free Parking on Premises -0.098190
number_of_reviews -0.121019
property_type_House -0.126896
accommodates -0.159946
room_type_Private room -0.168101
reviews_per_month -0.219961
如何让我的 Airbnb 利润最大化？
在调查了数据之间的相关性之后，我们创建了一个模型，该模型生成了对人均价格最有影响的属性。以下是前 10 名。
- 点评评分“位置”:楼盘广告语“位置，位置，位置！”在 Airbnb 环境中似乎也是如此。一个位置好的 Airbnb 为主机获得更多利润。
- 查看评分“评级”:毫不奇怪，良好的总体评级会产生新的预订并使利润最大化。
- 大楼内的电梯:客人不喜欢楼梯，似乎会为使用电梯支付更多费用。
- 主持人是超级主持人:为了利益最大化，成为超级主持人是好的。如果主人满足四个标准，Airbnb 会自动分配 superhost 徽章:A)主人一年至少入住 10 次，B)快速回复客人，C)至少有 80%的五星评论，D)主人应该很少取消预订。以超主机奖为目标是值得的。
- 位置“市中心”:为了利润最大化，最好将位于市中心的物业上市。
- 计算主机挂牌数:越有经验的主机越了解市场。偶尔在 Airbnb 上列出位置可能不是实现利润最大化的好主意。
- 点评评分“清洁度”:客人期望有一定程度的清洁度，并愿意为高标准的完美入住支付更多费用。
- 点评评分“准确性”:对客人坦诚是有回报的。如果住宿无法描述，图片或问题没有反映在列表中，客人不会喜欢。
- 浴室:毫不奇怪，更高的标准，比如更多的浴室，会给主人带来更多的利润。
- 取消政策严格:更有可能的是，受欢迎的主持人收紧了他们的预订政策。有了稳定的预订，主人就可以选择希望谁住在她的房子里。
我们的方法仅限于时间部分。我们只分析了特定时间点的数据，而不是长期数据。
这篇文章是作为完成 Udacity 数据科学纳米学位的一部分提交的。请在以下链接中找到 Github 库:https://github.com/astraetluna/airbnb-blogpost
如何最大化你的下一次会议的价值并停止浪费你的时间
Photo by Product School on Unsplash
我目前在伦敦担任奥莱利人工智能大会的 Ignite AI 活动的发言人。在参加会议之前，我想了很多关于如何不在这里浪费时间的问题。我相信许多从事技术工作的人也想知道如何确保参加会议是值得的。以下是我的一些想法。
说话
从会议中获取价值的最佳方式是在会议上发言。这有很多好处。首先，你通常可以免费参加，甚至可以报销旅费和时间。其次，它允许你谈论你、你的团队和你的公司所做的工作。这通常会吸引对你正在解决的问题感兴趣的人，这有助于招聘和建立关系网。现在，这些人不再在会议上四处游荡，希望遇到有相似兴趣的人，而是来找你。最后，演讲者通常能更好地接触到其他演讲者和活动组织者。可能会有一个演讲者休息室或仅演讲者参加的活动。这些活动是了解其他致力于解决挑战性问题的人的好方法，与他们交谈可以帮助你思考用不同的方式解决你的问题。
然而，能够在会议上发言需要额外的预先计划和时间。你需要准备好要展示的作品，你需要足够早地确定会议，以便能够提交演讲提案。因此，提前 6-12 个月确定关键会议非常重要。
网络
这可能会让一些人感到惊讶，但通常情况下，你会从你遇到的人那里获得比你参加的会谈更多的价值。然而，一个会议可能会有成千上万的人参加，那么你如何找到“最好的”交谈对象呢？我非常相信你可以从每个人身上学到一些东西，所以我认为和任何人说话都是有价值的，但我认为你可以使用一些策略。
- 根据谁在讲话，而不仅仅是主题是什么，来区分讲话的优先顺序。然后，去把你自己介绍给演讲者。几乎没有理由不花几分钟时间与演讲者交谈——以我的经验，这些交谈将是会议中最精彩的部分。
- 不要一个人坐。大多数人都是一个人参加会议，所以你通常会看到一堆人自己坐着。在谈话或午餐开始时，去坐在某人旁边并介绍你自己。你永远不知道你会遇到谁，你会学到什么。
- 花些时间在展览摊位上。几乎总是有公司在会议上成立。去和他们谈谈。你可能会了解一个新兴的 ML 工具，或者了解一些新的尖端硬件。
- 在走廊里遇见人。这被称为走廊通道，经常会导致长时间的谈话，你会发现自己在走廊上花的时间比在谈话上花的时间还多。
- 参加会议后的活动。通常，除了实际的会谈之外，你还可以参加某种类型的晚宴或活动。去见见人吧！
总的来说，要确保你花时间与人交谈，而不仅仅是听别人讲话。这一开始可能会有点不舒服，但是非常值得。如果你和你遇到的人一起参加类似的会议，你会发现自己期待着活动，以此作为重新联系的手段。
写
记下你学到的东西并与他人分享！如果你代表你的团队参加会议，确保你写下你学到的东西，回来后花时间展示你的发现。这使得团队中的每个人都能从会议中受益。如果这太正式，建立一个宽松的渠道，发送你正在学习的快速笔记。或者，如果你想要更正式的东西(或者没有团队可以分享)，创建一个中型帖子，与世界分享你的会议总结。我发现这类帖子非常有价值。花时间写下并分享你学到的东西，这不仅能帮助别人，还能帮助你巩固关键的要点。
Photo by Riccardo Annandale on Unsplash
优化
当你做完以上所有的事情，回到家中后，花些时间思考一下会议的价值。一些简单的事情，如快速的利弊清单，可以很有启发性。是什么让大会变得有价值？你不喜欢什么？也许你和某个启发了你如何解决当前问题的人建立了很好的联系。但是也许这个会议也让你损失了几天的工作时间。一旦你有了清单，检查一下，决定你认为会议的净值是多少。对自己诚实，用你学到的东西让你的下一次会议更有价值。如果你发现多日会议对你来说太长了，下次一定要参加一日会议。如果你把会议出席当成一个需要优化的学习问题，你就开始真正实现他们的价值最大化。
这篇文章也可以在这里找到。
如何有意义地处理数据
[image of a ballpit with some slides and other play-ground like things; bright colors and whimsy] Ballpits are probably a public health crisis, but I think they get across the magical feeling of “playtime” quite well.
再说玩吧！自从大学毕业后，我做过一些有趣的工作。作为一名认知科学研究员，我每天会花一部分时间思考贝叶斯推理，然后去隔壁的 T2 婴儿实验室数“婴儿吃角子老丨虎丨机”项目的贴纸。有些日子我不和任何人说话，埋头于我非常复杂和精密的编程(我开玩笑)。其他时候，我会在一台录音机上学习演奏“Let it Go”，这台录音机是一位研究员给我买的，他给我们的小机器人make block编了程序，让它唱“你想堆雪人吗？”来自迪士尼的冰雪奇缘。我经历了学习 Linux 命令的痛苦，成为我们非官方的 IT 人员，我还当过幼儿园老师。我想说的是，我做过“严肃的编程”,也玩过。玩了这么多。我为此无比开心。
我不想让玩耍成为我学术生涯中一种罪恶的快乐。我不希望玩耍成为一种“休息”或“副业”。我希望玩耍成为我每天工作中不可或缺的一部分，成为学习中不可或缺的一部分。我明白最重要的项目并不总是像玩耍一样。我们生活在一个危机四伏的世界里；人们受苦受难，不平等持续存在，这让人精疲力尽。但是我们都需要快乐、社区和玩耍的某些方面来让我们继续前进。
我想说的是，我做过“严肃的编程”,也玩过。玩了这么多。我为此无比开心。
因此，我提出了一些有意义地玩数据的方法，可以帮助我们学习，帮助我们笑，帮助我们作为非常严肃的学术程序员深呼吸。我之所以开这个玩笑，是因为我见过很多压力过大、疲惫不堪的人。我看过介绍性编程课把学生吓得屁滚尿流；我曾目睹学生们不顾一切地寻找工作，希望尽可能地获得技能以获得成功。我经历过自己成为我自己的“生产力”和“价值”观念的受害者。所以，如果你正在读这篇文章，也许是时候你试着玩了。就一小会儿。让我们学会有意义地玩数据来学习。
今天我正在为计算机科学专业的学生写一堂入门课，让他们学习 R 编程语言并使用 GitHub 数据。是的，现在很多人想学习“数据科学”、“科学计算”和“统计分析”。这将有助于学术界，就业前景，等等。我看到很多学生试图获得这些技能，但失败了，尽管他们尽职尽责地遵循 Coursera 的课程或完成了教程中的所有课程。可能是因为通常没那么好玩吧。这当然是我喜欢谈论的主题:个人相关、个人有意义、个人生成的数据项目。但是，让我们用数据来探究一系列非常小的个性化游戏日期:
生日当天流行的编程语言
我给学员上了一堂课，教他们如何查看 GitHub 统计数据，了解自己的生日。这里我用艾伦·图灵的生日(6 月 23 日)来演示一些情节。你知道吗，2016 年，JavaScript 是 GitHub 上艾伦·图灵生日那天使用最多的语言？不，你不知道，你到底为什么要在乎？你可能不会。但这是的乐趣。与你朋友的生日相比，嘲笑那些愚蠢的答案。你在学习 R，争论数据和 API，做数据可视化，都是为了玩。
[a graph demonstrating that JavaScript had the most commits on Alan Turing’s birthday; Java was second and Python third]
这一课最终通过艾伦·图灵的生日和假期的统计比较，特定生日在特定年份的一周中的重要性，给定语言相对于一年数据的相对提交量等来指导学习者。训练学习者像数据科学家一样思考的统计警告；但同时也显示了游戏的价值。
表明没人在乎你朋友最喜欢的语言
这个很有趣。你有朋友真的喜欢茱莉亚、戈朗、斯卡拉或者更糟的音乐吗，比如《T4》？是时候把你选择的语言如何在 GitHub 上更受欢迎的情节推到他们面前了，然后等待他们爽快的反驳。(朋友就是这样表现的吗？我不确定)。这一个比生日的那个更相关一点，但是是意图让这个变得有趣。幸灾乐祸。意图是幸灾乐祸。
[plot demonstrating language growth over time by number of commits to GitHub. Python has the most, then Ruby, then Scala, then Julia]
GitHub 上的加拿大日 vs 月 4 日
我的 RStudio 导师碰巧是加拿大人，带着我最后一点美国尊严，我决定做一个加拿大对美国的数据可视化。请继续关注这一课，因为它实际上有点复杂。我开始比较 7 月 1 日(加拿大国庆日)和 7 月 4 日(独立日)提交的数据，但是太多的事情会影响这些数据:一周中的哪一天，我们查看哪一年中的哪一天，等等。如果加拿大国庆日是星期二，但独立日是星期五呢？这变得很复杂，但重点是允许学习者插入他们喜欢的假期。
GitHub 也有周末吗？
这个剧情其实是我自己自己玩出来的。我甚至没有想过周末会对提交数量产生影响；我都没想到。当我画出它的时候，看到正弦波形的线，我笑了，因为我“发现”了周末。我也笑了，因为加拿大似乎有点难以决定周末是什么时候。本课展示了如何绘制线条，以及如何使用 r 中的weekdays()命令检查提交量较低的日子是否真的是周末。
[plot demonstrating a sinusoidal pattern in number of commits by day, with the dips in the pattern occurring on weekends! Even GitHub takes a break. Canada line is significantly less in volume of commits, and more sporadic in the pattern but still seems to show some evidence of fewer commits on weekends]
该课程还包括如何调整相对于提交的数据的说明，说明美国提交的数据总体上比加拿大多。当它们按照自己国家的频率标准化后，这些国家的周末可以更好地进行比较。
GitHub 上的哑项目描述
[bar plot for popular languages for project descriptions containing the word “pizza”. JavaScript has the most commits and Python has the least]
[bar plot for popular languages for project descriptions containing the word “cats”. JavaScript has the most commits and PHP has the least]
我们可以访问的东西之一是 GitHub 上的“项目描述”。我们可以开始玩文本数据，我有一个 13 岁孩子的幽默，所以显然我试图看看是否有任何项目描述包含粗俗。这一课展示了如何找到包含“哑巴”、“比萨饼”、“猫”等词语的 GitHub 项目描述。我们用dplyr做一些汇总和总结，以了解我们“收集”的数据。你当然也可以通过这种方式来教授关于ngrams的知识。这些都不重要，而且结果也很糟糕。但同样，这很有趣。你总是会惊讶于你的学生决定玩什么、发现什么和报道什么。此外，重要的是要记住我们在 GitHub 上的项目描述是公开的。看着你，给他们的项目贴标签的人:
“电脑很擅长做傻事。以 derp" 的速度为你的站点服务——一个有 24 个提交的 CSS 项目
数据播放日期
“也许这种自我驱动的数据游戏日可以给我们所有人多一点快乐，多一点信心，一路上多一点乐趣。”
这些特定的数据播放日期是 GitHub 关注的，但这些类型的课程几乎可以在任何领域进行。这个想法是抓住好奇心，让学习者用适当的支架去探索它。你能发现什么？我的目标是减轻一点计算机教室的压力。我们所有都想成功；解决大问题，成为专家。而且真的很难。我试图在充斥着垃圾和无用游戏的计算机科学课程和单纯为了好奇和发现而玩游戏的快乐之间游走。我的希望是我们都试着两者都找到一点。展示玩耍如何能让我们学到帮助我们解决大问题的技能，以及快乐如何能让我们从事对我们有意义的职业。也许这种自我驱动的数据游戏日可以给我们所有人多一点快乐，多一点信心，一路上多一点乐趣。
机器学习中如何测量距离
Photo by Bruno Wolff on Unsplash
这完全取决于你的观点
“如果你在德国挖一个洞，你会在中国结束” —当我的欧洲朋友告诉我这个的时候，我笑得很厉害。
不是因为我觉得这很荒谬什么的。而是因为这句话在阿根廷也很常见。我不认为这是一个世界性的说法。
“真的吗？那里也常见吗？”——他们和我一样惊讶。
“等等！有一个网站可以让你发现，如果你在你站的地方挖一个洞，你会在哪里结束”——我的朋友说。他总是有一个包罗万象的网站。
“为什么你认为这里和那里是一样的？”— 另一位朋友询问— “也许因为它表示一个远离我们出生的地方”
“对我来说，西班牙很遥远” —另一个人说
我的祖国离我很远。所以对我来说，13000 公里很远。对我的一些朋友来说，2000 公里非常遥远。
我开始思考，如果你从主观的角度来看，距离这个概念有多复杂。
有时你坐在某人对面，但那个人似乎很遥远。其他时候，一个人在几公里之外。一条信息就能让你感觉到一个非常亲近的人。
在某些情况下，我猜近和远取决于观点。
在机器学习中，许多监督和非监督算法使用距离度量来理解输入数据中的模式。此外，它还用于识别数据之间的相似性。
选择好的距离度量将提高分类或聚类算法的性能。
距离度量使用距离函数来告诉我们数据集中元素之间的距离。
幸运的是，这些距离可以用数学公式来测量。如果距离很小，元素很可能是相似的。如果距离大，相似度就低。
有几种距离度量可以使用。了解他们考虑了什么是很重要的。这将有助于我们选择哪一个更适合一个模型，以避免引入错误或误解。
1
如果我们想到两个城市之间的距离，我们会想到我们必须在高速公路上行驶多少公里。
我们能想到的这些距离的例子是欧几里德距离的例子。本质上，它测量连接两点的线段的长度。让我们用图表来看看这个:
Euclidean distance
想起什么了吗？你还记得数学课上的勾股定理吗？
该定理指出，斜边(直角的对边)的平方等于其他两条边的平方之和。
欧几里德距离可以用它来计算。
在我们的示例中，我们有二维点之间的距离，因此公式为:
对于 n 点，一般公式如下:
其中 x 和 y 是两个向量。
欧几里德距离是机器学习算法最常用的距离。当我们的数据是连续的时，这是非常有用的。它也被称为 L2-诺姆。
那么，欧氏距离还不够吗？为什么我们需要另一种距离？
在某些情况下，欧几里得距离不能给我们正确的度量。在这些情况下，我们将需要利用不同的距离函数。
2 曼哈顿距离:假设我们又要计算两点之间的距离。但这一次，我们想在一个网格状的路径中完成，就像图中的紫色线一样。
在这种情况下，相关度量是曼哈顿距离。它被定义为它们的笛卡尔坐标的绝对差之和。
让我们澄清这一点。一个数据点有一组数字笛卡尔坐标来唯一地指定该点。
这些坐标是从该点到两条固定垂直定向线的带符号距离，如下图所示。这可能也会给数学课带来一些回忆吧？
Cartesian coordinate system
因此，在我们的示例中，曼哈顿距离将按如下方式计算:获得(δx = x2-x1)和 y 轴的差值(δy = y2-y1)。然后，得到它们的绝对值，|δx |,最后，将两个值相加。
一般来说，公式是:
曼哈顿距离度量也称为 L1 距离或 L1 范数。如果你熟悉机器学习正则化，你可能以前听说过这个。
建议在处理高维数据时使用它。此外，如果您正在计算误差，由于其线性性质，当您想要强调异常值时，这是有用的。
3 闵可夫斯基距离:首先我们会定义一些数学术语，以便后面定义闵可夫斯基距离。
- 一个向量空间是一个称为向量的对象的集合，这些对象可以被加在一起并乘以数字(也称为标量)。
- 范数是为向量空间中的每个向量分配严格正长度的函数(唯一的例外是长度为零的零向量)。通常用∨x∨表示。
- 赋范向量空间是实数或复数上定义了范数的向量空间。
这和闵可夫斯基距离有什么关系？
闵可夫斯基距离被定义为赋范向量空间(N 维实空间)中两点之间的相似性度量。
它也代表一种广义的度量，包括欧几里德距离和曼哈顿距离。
公式看起来怎么样？
如果我们注意当λ = 1 时，我们有曼哈顿距离。如果λ = 2，我们在欧几里德距离的存在。还有一个距离叫做切比雪夫距离，发生在λ = ∞。
总的来说，我们可以用很多方法改变λ的值来计算两点之间的距离。
我们什么时候使用它？当感兴趣的变量在绝对零值的比例尺度上测量时，经常使用闵可夫斯基距离。
4 马氏距离:当我们需要计算多元空间中两点的距离时，就需要用到马氏距离。
我们之前讨论过笛卡尔坐标系。我们画了垂直线。然后我们根据这个轴系计算距离。
如果变量不相关，这很容易做到。因为距离可以用直线来测量。
假设存在两个或多个相关变量。我们还将补充说，我们正在与超过 3 个维度。现在，问题变得复杂了。
在这种情况下，Mahalanobis 距离来拯救我们。它测量多元数据相对于质心的距离。在这一点上，意味着来自所有变量的交集。
它的公式如下:
其中 Xa 和 Xb 是一对对象，C 是样本协方差矩阵。
5 余弦相似度:假设你需要确定两个文档或者文本的语料库有多相似。您将使用哪些距离指标？
答案是余弦相似度。
为了计算它，我们需要测量两个向量之间角度的余弦。然后，余弦相似度返回它们的归一化点积。
归一化向量是方向相同但范数为 1 的向量。
点积是两个等长向量相乘产生一个标量的运算。
Cosine similarity
因此，余弦相似性的公式是:
其中 A 和 B 是向量，∑A∨和∨B∨是 A 和 B 的范数，cosθ是 A 和 B 之间的夹角的余弦，这也可以写成其他的形式:
当我们对向量的方向而不是大小感兴趣时，余弦相似性非常有用。
方向相同的两个向量的余弦相似度为 1。90°的两个向量相似度为 0。两个完全相反的向量相似度为-1。都与它们的大小无关。
最后，我们将改变我们的注意力焦点。我们将处理集合，而不是计算向量之间的距离。
集合是对象的无序集合。所以比如{1，2，3，4}等于{2，4，3，1}。我们可以计算它的基数(表示为|set|)，它就是集合中包含的元素数量。
假设我们有两组对象，A 和 b，我们想知道它们有多少相同的元素。这叫做路口。它在数学上表示为 A ∩ B。
也许，我们想要得到所有的项目，而不管它们属于哪个集合。这就是所谓的联合。数学上表示为 A ∪ B。
我们可以用文氏图更好地描述这一点。
Intersection and Union represented in light blue in the Venn diagrams.
这与 Jaccard 相似性有什么关系？Jaccard 相似性被定义为已定义集合的交集的基数除以它们的并集的基数。它只能应用于有限的样本集。
Jaccard 相似度= |A ∩ B| / |A ∪ B|
假设我们有集合 A = { "花"，"狗"，"猫"，1，3}和 B = { "花"，"猫"，"船" }。那么，A ∩ B = 2，A ∪ B = 6。因此，Jaccard 相似度为 2/6 = 3。
正如我们之前所述，所有这些指标都用于几个机器学习算法中。
一个明显的例子是聚类算法，如 k-means，我们需要确定两个数据点是否相似。你可以阅读我关于集群的帖子来了解更多。
要传达的信息是，存在几种距离度量。它们中的每一个都有它们更适合的特定环境。学会选择正确的答案将会改善你的机器学习算法的结果。
如何衡量一个回归模型的好坏
浅谈如何检验回归模型的统计优度？
Photo by Antoine Dautry on Unsplash
回归模型非常有用，广泛应用于机器学习。然而，当测量一个训练好的模型的优度时，它们可能会显示出一些问题。而分类模型有一些标准工具可用于评估其性能(即 ROC 曲线下面积、混淆矩阵、F-1 评分等)。)，回归模型的性能可以用许多不同的方法来衡量。在本文中，我将向您展示我在作为数据科学家的经历中使用的一些技术。
R 中的示例
在这个例子中，我将向你展示如何使用著名的虹膜数据集来衡量一个训练好的模型的好坏。我将使用线性回归模型来预测作为其他变量函数的萼片长度值。
首先，我们将加载 iris 数据集，并将其分为定型和维持。
data(iris)
set.seed(1)training_idx = sample(1:nrow(iris),nrow(iris)*0.8,replace=FALSE)
holdout_idx = setdiff(1:nrow(iris),training_idx)training = iris[training_idx,]
holdout = iris[holdout_idx,]
然后我们可以执行一个简单的线性回归来描述变量 Sepal。长度为其他长度的线性函数。这就是我们想要检验其优良性的模型。
m = lm(Sepal.Length ~ .,training)
我们现在需要做的就是将训练集中的残差与维持中的残差进行比较。记住残差是真实值和预测值之间的差。
training_res = training$Sepal.Length - predict(m,training)
holdout_res = holdout$Sepal.Length - predict(m,holdout)
如果我们的训练程序已经产生了过拟合，那么与保持中的残差相比，训练集中的残差将非常小。这是一个消极的信号，应该促使我们简化模型或者去除一些变量。
现在让我们执行一些统计检查。
t 检验
我们首先要检查的是残差是否有偏差。我们从基本统计中知道，残差的平均值是零，所以我们可以开始用学生的 t 检验来检验这个样本是否正确。
t.test(holdout_res,mu=0)
正如我们所见，p 值大于 5%，因此我们无法拒绝零假设，可以说维持残差的平均值在统计上与 0 相似。
然后，我们可以测试保持残差是否具有与训练残差相同的平均值。这叫做韦尔奇的 t 检验。
t.test(training_res,holdout_res)
同样，高于 5%的 p 值可以让我们知道没有足够的理由假设平均值是不同的。
f 检验
在我们检查了平均值之后，就有了方差。我们显然希望维持残差显示一个与训练残差没有太大不同的行为，因此我们可以比较两个集合的方差，并检查维持方差是否高于训练方差。
检验方差是否大于另一个方差的一个好测试是 F 检验，但是它只对正态分布残差有效。如果分布不正常，测试可能会给出错误的结果。
所以，如果我们真的想使用这个测试，我们必须使用(例如)夏皮罗-维尔克测试来检查残差的正态性。
两个 p 值都高于 5%，因此我们可以说两个集合都显示正态分布残差。我们可以放心地继续进行 f 检验。
var.test(training_res,holdout_res)
p 值为 72%,大于 5%,可以说这两个集合具有相同的方差。
科尔莫戈罗夫-斯米尔诺夫试验
KS 测试非常通用，在许多情况下都很有用。一般来说，我们期望，如果我们的模型工作良好，保持残差的概率分布与训练残差的概率分布相似。创建 KS 检验是为了比较概率分布，因此它可用于此目的。然而，它带有一些近似值，对我们的分析可能是危险的。概率分布之间的显著差异可能隐藏在测试的一般考虑中。最后，KS 分布只有在某种近似下才是已知的，因此 p 值也是已知的；所以我建议谨慎使用这个测试。****
ks.test(training_res,holdout_res)
同样，大的 p 值可以让我们知道这两个分布是相同的。
情节
我在大学的一位教授通常说:“你必须用你的眼睛来看数据”。在机器学习中，肯定是这样的。
查看回归数据的最佳方式是通过绘制预测值与维持集中的真实值。在理想状态下，我们期望这些点位于穿过原点的 45 度线上(公式为 y = x )。这些点离这条线越近，回归越好。如果我们的数据在笛卡儿平面上形成了一个不成形的斑点，那肯定有问题。
plot(holdout$Sepal.Length,predict(m,holdout))
abline(0,1)
嗯，本来可以更好的，但也不是完全错了。点近似位于直线上。
图的 t 检验
最后，我们可以根据前面的图计算一条线性回归线，并检查其截距在统计上是否不等于零，其斜率在统计上是否不等于 1。为了进行这些检查，我们可以使用一个简单的线性模型和学生 t 检验背后的统计理论。
记住具有 n-1 个自由度的 t 变量的定义:
当我们在线性模型上使用 R 的总结函数时，它给出了参数的估计及其标准误差(即 t 定义的完整分母)。
对于截距，我们有 mu = 0 ，而斜率有 mu = 1 。
test_model = lm(real ~ predicted, data.frame(real=holdout$Sepal.Length,predicted=predict(m,holdout)))
s = summary(test_model)intercept = s$coefficients["(Intercept)","Estimate"]
intercept_error = s$coefficients["(Intercept)","Std. Error"]
slope = s$coefficients["predicted","Estimate"]
slope_error = s$coefficients["predicted","Std. Error"]t_intercept = intercept/intercept_errort_slope = (slope-1)/slope_error
现在我们有了 t 值，因此我们可以执行双边 t 检验来计算 p 值。
它们大于 5%，但绝对值不太高。
哪种方法是最好的？
照例要看问题。如果残差是正态分布，t 检验和 f 检验就足够了。如果不是，也许在使用 Kolmogorov-Smirnov 测试之前，第一个图可以帮助我们发现宏观偏差。
然而，非正态分布的残差应该总是在我们的头脑中拉响警报，让我们寻找一些我们还没有考虑到的隐藏现象。
结论
在这篇短文中，我向您展示了一些计算回归模型的良好程度的方法。虽然有许多可能的方法来衡量它，但这些简单的技术在许多情况下非常有用，并且很容易向非技术观众解释。
如何对交叉数据建模
这是多伦多的骄傲周末，519(T1)是一个致力于倡导包容 LGBTQ 社区的城市组织，今天的主题是交叉性。
我们谈到了使用交叉方法增加数据产品公平性的重要性。感谢您对这个故事的所有积极反馈。你已经问了一些如何开始的实用建议，所以我们将开始寻找一些实际可行的方法。
让我们从一个例子开始，发表在《新英格兰医学杂志》上的一项研究探讨了性别和种族如何影响病人的心导管插入术的转诊。他们收集了关于种族和性别的数据，并进行了统计分析。他们所做的被称为“主要影响”分析，他们先观察性别的影响，然后观察种族的影响。然后，他们将这些主要影响相加，创建了一个看起来像这样的图表。
然而，著名学者 Lisa Bowleg 和 Greta Bauer 利用这个例子指出，将主要影响加在一起并不能产生交叉分析。(附注:像大多数数据公平分析一样，这种做法不仅不是交叉分析，而且是错误和糟糕的数学。看到这里。)当使用基于定量交叉的模型重新进行分析时，这些是我们发现的结果。很快就清楚了，这里真正的偏见是针对黑人女性的，最初的错误结果显示白人女性和黑人男性的优势比较低，这是因为在加性主效应模型中，这两个类别都包括了一些显示给黑人女性的偏见。
虽然专家、从业者或用户对如何进行定量交叉分析没有一致的意见，但根据我的经验，有两个基本要素需要考虑。一旦你掌握了这两个技巧，我们就可以讨论其他的技巧、要考虑的事情和下一步。这两个是基础。
使用乘法而不是加法
使用个体和结构数据点的组合
乘法，不要加法
为了建立一个交叉模型，我们需要从加法走向乘法。构建为的模型或算法
结果=种族+性别+性取向
不是一个交叉的模型。这个模型也可以用来理解其中一个预测因素(如性取向)对结果的影响，同时保持其他预测因素不变(换句话说，假设其他变量处于公平竞争环境)。然而，在观察种族和性取向的影响时保持性别不变，并不能告诉我们当允许这些个体特征波动时，它们的影响是否不同；换句话说，当性别被允许为男性或女性时，性取向的影响是什么？这是交叉分析中核心问题的性质。为了得到这个问题的有用答案，我们需要添加一个交互项。相互作用项本质上是乘法。也叫中庸，或者说是条款的产物。新模型现在看起来像这样:
结果=种族性别性取向
这个模型可以回答不同变量组合的结果如何变化的问题。当种族、性别和性取向一起改变时，结果会如何改变？例如,(同时)是一名拉丁裔男性同性恋者与同时是一名男性同性恋者和一名白人女性异性恋者的不同体验。它通过将所有三个预测因子放在一起看，而不是一次看一个，同时保持另外两个稳定。模型中的乘法精确地估计了不同变量的同时和分层效应。
使用单个数据点和结构数据点的组合
一般来说，数据公平的一个关键原则，特别是交叉分析，是只看个人水平的数据经常产生有偏见和不正确的结果。这有点像把一只虫子从地里拿出来，放到一个玻璃罐里，并试图研究它。没有任何背景，你会犯很多错误。为了建立一个交叉模型，最好包括变量和数据来衡量个人所处的环境和社区。例如，在一个关于年龄、性别和难民身份对教育结果的影响的模型中，重要的是要包括衡量每个社区对难民的接受程度的指标。此外，最好包括衡量各种语言教育可用性的变量、关于性别和教育的系统法规等等。幸运的是，有几种统计方法可以做到这一点。最常见的一种是多层次模型，旨在包括在个人层次和几个更广泛的聚合层次(如社区和国家)测量的变量。就像传统的回归一样，这些模型可以包括乘法，而不仅仅是加法，如上所述。
Setareh Rouhani 的关于定量交叉分析的初级读本包含了一个很好的例子。这项研究探讨了种族、教育和城市地区的交叉影响。不同的城市地区有不同的政策，因此这一变量在模型中作为结构水平影响的衡量标准。
“研究人员可以进行跨背景的比较，评估这一政策在城市环境中的影响(通过比较该政策出台前后的累计年数)(颁布该法律的州的城市与未颁布该法律的州的城市),以实证研究该政策如何构建相对的权力和特权……”多层次分析更好地说明了政策是如何构建个人在地位、健康和福祉方面的相对权力和特权的(Bauer，2014；Hankivsky 等人，2012 年)。
您可以使用乘法模型和多水平模型的包和示例将交叉分析添加到您的工作中，这些包和示例可用于最常见的统计包。这里有一个关于 R 对乘法或交互和一个关于多级建模的好例子。对于 SPSS 用户，这里有一个关于交互的和一个关于多级建模的不错的。老实说，外面有几百个。找一个能证明你学习方法最好的人，并努力去做。我真的很想听听您对您的模型和数据产品如何变化的更新。保持反馈、建议、评论和问题不断出现。
原载于 2019 年 6 月 21 日https://weallcount.com。
“我们都算数” 项目分享例子，构建工具，并提供旨在帮助更好地理解数据的培训和教育——因此我们可以使数据对每个人来说更加透明和公平。因为当你计算的时候，我们都在计算。
报名参加我们的简讯 【真相】 。发表关于当前数据科学公平问题的平实语言、无行话、深入的文章；如何找到并纠正这些错误的视频教程；交互式网络工具可以帮助您将数据游戏提升到一个新的水平；深入探讨“数据生命周期”，这是我们思考数据未来的基本概念。
如何通过手机监控深度学习实验
介绍 TeleGrad 一个免费开源的电报机器人，可以与深度学习实验无缝交互。
深度学习培训过程通常会运行数小时/数天，并且您不会总是在您的工作站附近查看进展情况或进行调整。使用这个电报机器人，你可以通过手机无缝地获得持续更新，甚至控制你的训练过程。
特征
- 获得每个时期的损失、准确性等的更新。
- 改变学习速度
- 获取损耗收敛图
- 扼杀训练过程
- 查询最新的 LR 或指标
- 限制对特定电报用户 id 的访问
完整的安装和使用说明可以在 GitHub 资源库 中找到。
要开始使用 TeleGrad，您需要遵循 3 个简单的步骤:
- 创建一个电报机器人
- 安装库依赖项
- 使用 TeleGrad 的 API 将机器人包含在您的代码中
1.创建一个电报机器人
使用电报应用程序创建一个电报机器人非常简单，有一个机器人可以做到这一点！只需遵循以下步骤:
Search for the botfather user
1.打开电报应用程序
2.搜索僵尸父亲用户
3.开始与机器人父亲对话，然后点击start
4.发送/newbot并按照屏幕上的指示操作
5.复制 bot 令牌。使用 TeleGrad API 时，您将需要它
就是这样！你现在自豪地拥有了一个电报机器人。
2.安装依赖项
要使用 TeleGrad，您需要以下依赖项:
- python-丨t丨e丨l丨e丨g丨r丨a丨m丨s丨-bot
- matplotlib(可选，发送收敛图)
- 一个深度学习 API。例子包括 Keras & TensorFlow
只需遵循以下步骤:
-
克隆 TeleGrad 仓库:
-
将
dl_bot.py添加到您的项目中 -
将
丨t丨e丨l丨e丨g丨r丨a丨m丨s丨_bot_callback.py添加到您的项目中(可选，仅当您使用 Keras 时)
3.使用 TeleGrad API
如果您使用的是 Keras，只需将包含的回调传递给 fit 方法，就可以自动与机器人进行交互。否则，自己定制交互(包括 TensorFlow 示例)。
使用 Keras:
要使用 Keras 丨t丨e丨l丨e丨g丨r丨a丨m丨s丨 bot 回调，您只需使用以下块:
现在只需将丨t丨e丨l丨e丨g丨r丨a丨m丨s丨_callback添加到传递给 model.fit 的回调列表中:
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test),
callbacks=[丨t丨e丨l丨e丨g丨r丨a丨m丨s丨_callback])
就这样，你可以走了！
[keras_mnist_example.py](https://github.com/eyalzk/telegrad/blob/master/keras_mnist_example.py)中包含了一个用法示例
自定义消息:
如果您正在使用 TensorFlow(或任何其他框架，并且您想要自定义与机器人的交互)，首先在脚本中包含以下代码:
在这种情况下，您需要实现对/setlr、/getlr、/status、/stoptraining和/quiet消息的响应。
此外，为了使用/plot命令，你需要向机器人发送每个时期的损失值。
包含这些响应相当容易，TensorFlow 示例包含在[tf_mnist_example.py](https://github.com/eyalzk/telegrad/blob/master/tf_mnist_example.py)中
使用机器人
TeleGrad 机器人会向你发送自动更新，或者回复来自应用程序的消息。注意，只有在你从应用程序向它发送 **/start** 消息后，机器人才会开始发送消息。
要开始与机器人交互，请发送/start。
自动历元更新:
- 一旦你从电报应用程序发送
/start,机器人将开始向你发送每个时期的更新 - 您可以通过发送
/quiet停止获取这些自动更新 - 要重新打开更新，请再次发送
/start。 - 在任何时候(即使在安静模式下)，发送
/status获取最新的纪元更新:
修改学习率:
如果您的模型收敛停滞，并且您想要改变优化器的学习速率，只需发送/setlr。
您也可以通过发送\getlr随时查询当前的学习率
Setting and getting the learning rate
绘制收敛图
要获得损失的收敛图，从应用程序发送/plot:
停止训练过程
您可以使用应用程序停止训练过程。只需发送/stoptraining并点击“是”按钮。通过 Keras 回调，训练可以安全地停止，因为计划在训练后进行的其他操作仍然会发生。
就是这样！你现在可以使用手机轻松监控和控制你的深度学习实验。
TeleGrad 目前是它的第一个工作版本，所以欢迎改进和新功能的想法！
更多项目，请访问我的网站:【https://eyalzk.github.io/
如何使单个细胞正常化
生命科学的数理统计和机器学习
单细胞基因组学标准化策略的比较
From C. Hafemeister et al. 2019, image source
这是专栏 生命科学的数理统计和机器学习 的第九篇文章，我试图在这里涵盖生物信息学、生物医学、遗传学、进化科学等领域常用的分析技术。今天，我们将通过比较最流行的归一化算法，来讨论在激动人心的单细胞基因组学领域中消除 技术变异的挑战。
从批量标准化到单细胞标准化
人们普遍认为，单细胞 RNA 测序( scRNAseq ) 实验中的大规模细胞间基因表达变异可能在很大程度上是技术性的，从而混淆了与细胞类型相关的生物学 变异。技术变异的来源各不相同，从 PCR 扩增偏差到逆转录(RT) 效率以及制备和测序步骤中分子取样的随机性。因此，必须应用跨细胞的标准化，以消除技术变异并保持生物学变异。然而，常见的批量 RNAseq 方法，如 TMM 和 DESeq 都是基于构建每个单元的大小因子，这些因子代表比率，其中每个单元都由一个参考单元进行归一化，该参考单元是通过对所有其他单元进行某种平均而构建的。
Bulk normalization (TMM, DESeq) builds a reference sample, from Mar Gonzalez-Porta teaching material
scRNAseq 数据的一个特点是，与大量 RNAseq 相比，它们包含大量的随机零，这是由于每个细胞的 RNA 量低和 RNA 捕获效率不理想(丢失)。因此，TMM 和 DESeq 尺寸因子可能变得不可靠膨胀或等于零。因此，开发了新的单细胞特异性标准化方法，解决了 scRNAseq 数据中大量零的问题。
Genes expressed in one cell are missing in another cell due to dropout (left), zero inflated scRNAseq data (right)
在 Marioni 的实验室中，用 反卷积归一化 方法对归一化过程中的随机零点进行了一次非常优雅的尝试。该算法背后的思想是通过多个池单元来表示所有单元，对于每个池，来自多个单元的表达式值被求和，这导致更少的零，并且通过所有单元的平均表达式来缩放。以这种方式构建的每池尺寸因子可以在线性方程组中解卷积 ，产生每单元尺寸因子的。
Pooling across cell, from A. Lun et al., Genome Biology 2017
这种“整体大小因子方法”的缺点是，不同组的基因不应该用每个细胞大小因子的相同常数来标准化，而是应该针对每组基因例如高、中、低表达的基因进行单独调整。这在 SCnorm 和更近的 皮尔逊残差 归一化算法中被考虑在内。两者都是基于回归出不同基因组的测序深度偏差。
SCnorm builds per cell per group of genes size factors, from Bacher et al., Nature Methods 2017
下面我们将使用来自的先天淋巴细胞(ILC) scRNAseq 数据来比较不同的流行标准化策略。bjrklund 等人，自然免疫学 17 ，第 451–460 页(2016)
比较 scRNAseq 归一化方法
scRNAseq 分析工作流程相当复杂，在这里我将专注于结果，但鼓励您查看我的 github 中的完整笔记本。首先，ILC scRNAseq 数据集是用 SmartSeq2 全长转录物测序技术产生的，并且包括非常方便的尖峰信号(跨细胞恒定浓度的对照转录物)用于评估技术背景噪音。通过将变异系数 (CV=sd/mean)绘制为每种标准化方法的平均基因表达的函数，这些峰值可用于检测变异高于噪声水平的一组基因:
Detecting genes with variation above technological noise using spike-ins
在这些图上:一个点是一个基因，红色曲线代表峰值的变异，峰值曲线上方的基因展示了技术变异上方的变异(高度变异基因)。可以观察到，可变基因的数量根据标准化方法而变化。 RPKM 归一化显示了 最低数量的可变基因，这可能是由于在 RPKM 中用于归一化的短长度的刺突。接下来，我们将检查主成分分析(PCA)图如何根据 scRNAseq 归一化策略而变化:
PCA plots for different scRNAseq normalization strategies
很难看出标准化方法之间的任何差异，PCA 图看起来几乎相同，表明来自 4 个 ILC 簇的细胞严重重叠。此外，如预期的那样，我们可以使用 tSNE 图获得 ILC 细胞的更明显的聚类:
tSNE plots for different scRNAseq normalization strategies
然而，归一化的方法似乎并没有改变 4 个 ILC 簇，不管采用什么归一化方法，它们都非常清晰可见。最后，我们可以计算不同归一化策略的大小因子，并检查它们的相关性:
Comparing size factors across different normalization strategies
这里为了简单起见，我对不同基因组的 SCnorm 大小因子进行了平均。令人惊讶的是，大小因子在不同的归一化方法中几乎是不可区分的，甚至包括批量 RNAseq 算法 TMM 和 DEseq。然而，对于其他 scRNAseq 数据集，这可能不如 ILC 看起来好。
看着上面的图，感觉上对 scRNAseq 的标准化的重要性被稍微高估了，因为至少对于 SmartSeq2 数据集，性能上的差异是可以忽略的。如果细胞群体足够不同，即如果数据中有信号，选择哪种 scRNAseq 归一化方法并不重要。此外，随着基于 UMI 的测序方案的广泛使用，对复杂标准化算法的需求甚至变得不那么明显，因为这些方案原则上能够消除扩增和测序深度偏差，因为多个读数被压缩到单个 UMI 计数中。
Major sources of technical variation in scRNAseq that can be improved by UMI-based protocols, images source
摘要
在这篇文章中，我们了解到由于 scRNAseq 数据集中大量的随机零，基于比率的** 传统批量 RNAseq 归一化算法不适用。去卷积和 SCnorm 代表了优雅的特定于 scRNAseq 的归一化方法。然而，scRNAseq 标准化方法学**的比较并未显示其性能的显著差异，随着基于 UMI 的 scRNAseq 方案的进展，这可能变得更加不显著。
在下面的评论中让我知道生命科学中的哪些分析对你来说似乎特别神秘，我会在这个专栏中尝试回答它们。在我的 github 上查看帖子中的代码。在媒体关注我，在 Twitter @NikolayOskolkov 关注我，在 Linkedin 关注我。下期我们将覆盖如何批量修正单细胞数据，敬请关注。
如何不仅生存，而且领导人工智能革命
AI 有信任问题
Photo by Miguel Bruna on Unsplash
人工智能革命是强大的，不可阻挡的，影响着我们生活的方方面面。它由数据推动，由今天的人工智能从业者推动。伴随着强大的力量而来的是巨大的责任——不仅对我们的后代，而且对今天我们周围的世界。为了推动一场为所有人带来更美好世界的革命，我们需要确保我们为人工智能注入信任。
AI 有“信任问题”
我们都看过关于人工智能机器人看起来像流氓一样的新闻报道。以被设计成对话机器人的索菲亚为例，当被问及是否愿意毁灭人类时，她愉快地回答说愿意。或者泰伊，被设计成一个 13 岁的女孩，从推特互动中学习，但很快她的学习导致她发布仇恨的种族主义信息。还有我个人最喜欢的——诺曼，第一个心理变态的 AI 机器人。诺曼由麻省理工学院媒体实验室设计，旨在展示训练数据对 AI 行为的影响。他们用网络黑暗面的图片训练他——暴力、令人不安的图片。然后，他们用罗夏墨迹测验来测试他的个性——他们给诺曼展示了这样一幅图像，然后他们问 Normal 他看到了什么:
当我看着这个，我看到了春天的巴黎——被鲜花环绕的埃菲尔铁塔。当“标准”AI 看这个的时候，它看到的是“桌子上一个结婚蛋糕的特写”。但当诺曼看到这个时，他看到了“被超速司机撞死的人”。
虽然这三个角色——索菲亚、泰和诺曼——受到了媒体的大量关注，但他们并不真正危险。索菲亚的问题是由她的创造者提出的，他可以很容易地修改她的培训和编程，以获得不同的回应。Tay 在公开展示其异常行为后可能会很快被关闭。诺曼，嗯，他实际上是一个好人——向世界教授准确和无偏见的数据对人工智能应用的重要性。
AI 真正的危险往往是隐藏的。
它们存在于影响我们日常生活的应用程序中，从我们的医疗保健到我们的财务。我们使用这些应用程序来查看我们应该在社交网络上与谁交朋友，并接收关于我们应该阅读的新闻报道的建议。决定在社交媒体上向孩子们展示内容的应用程序。
人工智能的真正危险往往始于良好的意图。
例如，亚马逊的简历审查工具，旨在帮助审查人员筛选简历，结果显示对女性有偏见。这一切都是因为它被训练成根据过去 10 年提交的简历(主要是男性提交的简历)进行推荐。另一个例子是抵押贷款算法，被发现对非裔美国人和拉美裔申请人有偏见。这不是故意的——这些算法在提供抵押贷款时没有明确考虑族裔或种族。相反，他们关注的是申请人是否在寻找更好的价格，并给那些寻找更好价格的人更好的报价。事实证明，非裔美国人和拉丁美洲人不太可能货比三家，这导致了隐藏在基于竞争的定价之下的种族偏见。今天，互联网上充斥着这样的故事，从决定监狱中的人是否可能再次犯罪的应用程序(并被证明有种族偏见)，到用于决定儿童是否有受伤害风险的。
鉴于这些导致对人工智能不信任的故事，人工智能从业者可以做些什么来确保人工智能系统受到信任，从而加速人工智能对现实世界的真正好处？
可信 AI 是公平可解释的
首先，我们需要构建能够向非专家解释自身的人工智能。有了可解释的人工智能，人类可以更快地发现异常或有偏见的人工智能结果。我们还需要建立和使用能够自动检测数据和模型中的偏差，并自动修复偏差的人工智能。对于人工智能来说，要激发信任，它需要公平和可解释，但也要防止恶意攻击，并且是可追溯的——我们需要知道数据来自哪里，以及它是如何被使用的。丹尼尔·卡内曼展示了我们人类在做决定时是多么的偏颇。他表示
让人们相信谎言的一个可靠方法是频繁的重复，因为熟悉和真实是不容易区分的
对人工智能来说也是如此——我们可以通过向人工智能提供有偏见或虚假的数据，轻易地欺骗它相信某些东西。
可信人工智能在多样性中茁壮成长
公平和偏见的 AI 主题诞生于人类世界。为什么今天这么多 AI 应用被发现有偏差？通常，这是因为几十年来我们一直在将我们有偏见的人类决策插入到我们的数据库中，而这些数据现在正被用来训练人工智能模型。回到亚马逊有偏见的简历审查应用程序的例子:这个应用程序只是有偏见，因为提交的简历主要是男性，由主要的男性审查员审查和选择。这个应用程序没有机会了解一份好的女性简历是什么样的。想想看，如果 50%的“好”简历来自女性，而选择“好”简历的人类评审员中有 50%是女性，结果会有多么不同。因此，修复数据偏差的一部分是建立多样化的人类团队，减少人类决策的偏差，从而减少用于训练人工智能的数据集的偏差。
引领人工智能革命需要可信的人工智能。这意味着人工智能是公平的，无偏见的，可解释的，对恶意攻击安全的，可追踪的。为了在您的 AI 应用程序中注入信任，利用工具来检测和修复偏差，并在您的应用程序中构建治理、安全性和血统。还要建立数据科学和人工智能团队，不仅在性别和种族方面，而且在思想方面都是多样化的。
你会做些什么来为你的人工智能应用注入信任？
如何组织您的数据科学项目
数据科学项目组织教程
Always good to maintain two versions of your project, one locally, and the other on Github.
本文将讨论一些有用的技巧，帮助您更好地组织数据科学项目。在深入研究数据科学项目管理的一些技巧之前，让我们首先讨论一下组织项目的重要性。
组织项目非常重要的 4 个理由
- 组织提高生产力。如果一个项目组织得很好，所有的东西都放在一个目录中，那么就更容易避免浪费时间去搜索项目文件，比如数据集、代码、输出文件等等。
- 一个组织良好的项目有助于您保持和维护正在进行的和已完成的数据科学项目的记录。
- 已完成的数据科学项目可用于构建未来模型。如果将来您必须解决类似的问题，您可以使用稍加修改的相同代码。
- 一个组织良好的项目在 Github 等平台上分享时，很容易被其他数据科学专业人士理解。
F 为了说明的目的，我们将使用游轮数据集。我们假设我们希望建立一个机器学习模型，用于根据预测变量(如年龄、吨位、乘客、长度、船舱等)推荐游轮船员人数。在第一节中，我们描述了如何在本地组织项目。然后在第一节，我们描述了如何为项目创建一个 Github 存储库。我们总是建议您维护项目的两个版本，一个在本地，另一个在 Github 上。这样做的好处是，只要你有互联网连接，你可以在世界任何地方、任何时间访问你的项目的 Github 版本。另一个好处是，如果您的本地计算机发生了可能对您的计算机产生不利影响的事情，例如计算机中的病毒，那么您可以始终确信您在 Github 上仍有项目文件可以作为备份。
一、地方项目目录
对于你正在做的每个项目，有一个项目目录是很好的。
a)目录名
在为您的项目创建项目目录时，最好选择一个反映您的项目的目录名称，例如，对于推荐船员人数的机器学习模型，可以选择一个目录名称，如ML _ Model _ for _ Predicting _ Ships _ Crew _ Size。
b)目录内容
您的项目目录应该包含以下内容:
(1) 项目计划:这可能是一个世界文档，您可以在其中描述您的项目的全部内容。你可以先提供一个简要的大纲，然后一步一步地计划你想完成的事情。例如，在构建模型之前，您可能会问自己:
㈠什么是预测变量？
㈡目标变量是什么？我的目标变量是离散的还是连续的？
(三)我应该使用分类还是回归分析？
(iv)如何处理数据集中缺失的值？
㈤在将变量纳入同一尺度时，我应该使用规范化还是标准化？
(vi)我是否应该使用主成分分析？
(vii)如何调整模型中的超参数？
(viii)如何评估我的模型以检测数据集中的偏差？
(ix)我是否应该使用集成方法，即使用不同的模型进行训练，然后进行集成平均，例如使用 SVM、KNN、逻辑回归等分类器，然后在 3 个模型上进行平均？
(x)我如何选择最终型号？
2.项目数据集:您应该包括项目要使用的所有数据集的逗号分隔值(csv)文件。在这个例子中，只有一个 csv 文件:cruise _ ship _ info . CSV。
3.一旦你弄清楚了你的项目计划和目标，就该开始编码了。根据您正在解决的问题的类型，您可以决定使用 jupyter 笔记本或 R script 来编写代码。让我们假设我们将使用 jupyter 笔记本。
在 jupyter 笔记本上，从添加项目标题开始，例如:
**Machine Learning Model for Predicting a Ship’s Crew Size**
然后你可以提供你的项目的简要概述，接着是作者的名字和日期，例如:
*We build a simple model using the cruise_ship_info.csv data set for predicting a ship’s crew size. This project is organized as follows: (a) data proprocessing and variable selection; (b) basic regression model; (c) hyper-parameters tuning; and (d) techniques for dimensionality reduction.**Author: Benjamin O. Tayo**Date: 4/8/2019*
当您开发代码时，您希望确保 jupyter 笔记本被组织成突出机器学习模型构建工作流的各个部分，例如:
Importation of necessary python librariesImportation of datasetExploratory data analysisFeature selection and dimensionality reductionFeature scaling and data partitioning into train and test setsModel building, testing, and evaluation
有关示例项目 jupyter 笔记本和 R 脚本文件，请参见以下链接:
[## bot 13956/ML _ Model _ for _ Predicting _ Ships _ Crew _ Size
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/bot13956/ML_Model_for_Predicting_Ships_Crew_Size/blob/master/Ship_Crew_Size_ML_Model.ipynb) [## bot 13956/天气模式
创建于 2018 年 7 月 9 日星期一@作者:Benjamin O. Tayo 此代码执行以下操作:它返回一个折线图…
github.com](https://github.com/bot13956/weather_pattern)
4.项目输出:您也可以将关键的项目输出存储在您的本地目录中。一些关键项目输出可以是数据可视化、将模型误差作为不同参数的函数的图表，或者包含关键输出(如 R2 值、均方差或回归系数)的表格。项目输出非常方便，因为它们可用于准备项目报告或 powerpoint 演示幻灯片，以展示给数据科学团队或公司的业务管理员。
5.项目报告:在某些情况下，你可能需要写一份项目报告来描述项目的成就，并根据你的模型的发现和见解提供要采取的行动。在这种情况下，您需要使用 MS word 编写一份项目报告。在编写项目报告时，您可以充分利用从主代码中产生的一些可视化效果。你想把这些加到报告里。你的主要代码可以作为附录添加到项目报告中。
可以从以下位置找到项目报告文件的示例:
作者:Benjamin O. Tayo 日期:2018 年 11 月 22 日简介:预测贷款状态是风险中的一个重要问题…
github.com](https://github.com/bot13956/Monte_Carlo_Simulation_Loan_Status)
二。Github 项目目录
一旦您解决了感兴趣的问题，您就必须在 GitHub 上创建一个项目资源库，并上传项目文件，如数据集、jupyter 笔记本、R 程序脚本和样本输出。为任何数据科学项目创建 GitHub 存储库都是极其重要的。它使您能够随时访问您的代码。你可以与程序员和其他数据科学家分享你的代码。此外，这也是您展示数据科学技能的一种方式。
创建 Github 资源库的技巧:确保你为自己的资源库选择了一个合适的标题。例如:
**Repository Name**: bot13956/ML_Model_for_Predicting_Ships_Crew_Size
然后附上一个自述文件，提供项目的概要。
Author: Benjamin O. TayoDate: 4/8/2019We build a simple model using the cruise_ship_info.csv data set for predicting a ship's crew size. This project is organized as follows: (a) data proprocessing and variable selection; (b) basic regression model; (c) hyper-parameters tuning; and (d) techniques for dimensionality reduction.**cruise_ship_info.csv**: dataset used for model building.**Ship_Crew_Size_ML_Model.ipynb**: the jupyter notebook containing code.
然后，您可以上传您的项目文件，包括数据集、jupyter 笔记本和样本输出。
下面是一个机器学习项目的 Github 知识库的例子:
资源库网址:https://github . com/bot 13956/ML _ Model _ for _ Predicting _ Ships _ Crew _ Size。
总之，我们已经讨论了如何组织数据科学项目。良好的组织导致更好的生产力和效率。当你下一次要做一个新项目时，请花时间组织你的项目。这不仅有助于提高效率和生产率，还有助于减少错误。此外，保留所有当前和已完成项目的良好记录使您能够创建一个存储库，您可以在其中保存所有项目以供将来使用。
由数据推动:如何为伦敦马拉松比赛配速🏃 🇬🇧
Chris 目前是英国华威大学计算机科学硕士学生。他也是 抗大投资 的联合创始人。在此之前，Chris 曾在花旗风险投资 和花旗市场 工作。
它始于一个借口
嗨，我是克里斯。在与我的共同创始人安德烈、尼克·福登和西尔维娅·齐巴一起建造 T21 的时候，我一直在攻读计算机科学硕士学位。在我参加的一个数据分析模块中，我们的任务是找到世界上的任何数据集，并应用我们在课堂上学到的技术。
作为一个自称的跑步爱好者，这是一个深入研究一些有趣的跑步数据的机会。分析哪个种族？只有世界上最好的比赛才能做到:伦敦马拉松。💪
Before the race: full of hope and joy.
去年 4 月，我参加了伦敦马拉松比赛，目标是 2 分 59 秒 59。我失败了。我的比赛训练经历了漫长寒冷的冬天，但在比赛当天，气温达到了温和的 23 摄氏度。我的速度一直在目标上，直到刚过 25 公里大关，然后就直线下降。我用了 3 分 16 秒 38 完成。
这给我留下了大问题:天气会影响每个人吗？对他们有多大影响？最终我想知道…这是我表现的正当理由吗？😂
去哪里找数据？🕵️
虽然没有伦敦马拉松比赛结果的公开数据集，但官方网站有过去 5 年所有跑步者的可搜索结果。为了检索这些结果，我用编程语言 python 构建了一个抓取工具。我使用流行的模块请求和漂亮的汤来调用过去 5 年中每个参与者的结果页面。我将这些结果保存到一个 csv 文件中。
In retrospect, the heat was getting to me from the start.
总的来说，有 193，439 名独特的跑步者，略低于比赛的参与者人数，因为我没有精英跑步者的数据。
我所掌握的关于每位跑步者的信息有些有限:姓名、跑步者编号、比赛年份、俱乐部、年龄类别、地点、性别和国籍。如果有确切的年龄、居住城市、捐助的慈善机构、奇装异服和跑步经历(例如完成的马拉松次数)就太棒了。哦，好吧，我会尽我所能。
对于每个跑步者，我也有一堆关于跑步者在每个 5 公里标记上的时间的信息。例如，在 10 公里处，我是这样看的:
到目前为止，一切顺利。没错。让我们从跑步者的一些基本数据开始。你可以看到，在 2014 年至 2018 年期间，跑步者平均在 4 个半小时左右完成。最快的 25%的跑步者在 3 分 50 秒内完成，最慢的 25%超过 5 分钟。有意思。
Finish (total time) and at the 5km mark (in min/km)
好的，让我们来看看节奏策略。我认为公平地说，一个跑步者在 5 公里或 10 公里处的配速几乎是他们想在整个比赛中保持的配速。正如你在下面看到的，普通跑步者每年都会放慢速度。我想这并不奇怪，但是看看这条紫色的线。在 2018 年的比赛中，普通跑步者的速度明显比其他任何一年都要慢。看来我不是一个人…
Pace in mins/km at each 5km mark
现在是数学课
好吧，警告。接下来会有一点数学。我向你保证很快就会结束。
所以上面的图表给了我一个想法。如果我能计算出每个跑步者的“减速系数”会怎么样？基本上，我想知道一个特定的跑步者在 5 公里和 40 公里之间慢了多少。下面的公式给出了这个数字的百分比。
‘Slowdown factor’ for a runner
无论如何，即使你忽略这个公式，你也要知道减速因子是一个数字，它代表了跑步者的速度在比赛开始和结束之间减慢了多少。
Pretty chart: how much did different runners slow down?
上图显示了多年来跑步者放慢速度的程度。我将结果分成不同的完成时间(跑完 3 小时以下，4 小时以下等等)，然后根据他们跑完比赛的年份。你可以看到跑得快的人没有慢下来那么多(可能 10%左右)，这很有道理。这些跑步者通常经验丰富，知道如何调整自己的速度。然而，跑得较慢的人会经历更大幅度的速度下降。
同样有趣的是，2018 年是减速最糟糕的一年，无论跑步者的速度如何。
让我们来看看天气
因此，当跑步者抱怨天气时，他们通常是指天气冷(低于 5 摄氏度)、热(高于 18 摄氏度)或潮湿。在雨中跑步也很糟糕，但这更多的是一种心理上的事情。在这里，我只是看了每个比赛日的气温。
Looks complicated, but it’s just the range of temperatures each year
上图被称为盒须图。它标明了每年比赛日的温度范围。方框显示了 50%时间内的温度。胡须显示了剩下比赛的温度。
你会发现，2018 年不仅更热，而且气温在比赛过程中变化很大。比任何一年都多！
2015: finish times got longer as the temp went up
这是 2015 年比赛期间不同温度与每位参赛者完成时间的图表。很明显，天气越热，跑步者越慢。图表甚至给出了关系的回归方程。
更多的数学:每年似乎都有类似的关系。上表的最后一栏显示了相关系数。肯定有关联。2018 年除外。
A mere 600 metres to finish but I was in a dark dark place
嗯，这很奇怪。我们刚才不是说明 2018 年是最热的一年吗？我们不是显示了这也是跑步者放慢速度最多的一年吗？一个潜在的解释是，2018 年从一开始就如此炎热，以至于白天气温如何变化都无关紧要。
回归之后，我为数据建立了许多分类器。如果你对那里的结果感兴趣，那我们就聊聊吧，但我会把它放在这一页之外，以免其他人看到。
****总是预先准备好你的借口😏
所以看起来我的辩护是合理的。2018 年比其他任何一年都要热。这也是跑步者放慢速度最多的一年。即使在其他年份，气温越高，跑步者越慢。
结案了，对吧？
Felt like that guy behind me, but there’s always energy for a photo
嗯，也许不是。我不怀疑 2018 年是最热的一年(连每日快报都同意，他们从来不会错)。从数据中也可以明显看出，2018 年跑步者的速度比此前任何一年都慢。但我对在一场特定比赛中，气温较高的运动员跑得更慢的证据持怀疑态度。如果他们花了 5 个小时完成比赛，然后在当天晚些时候结束，温度总是更高，对吗？
总之。让我知道你的想法。我有一个好的借口吗？或者我应该承认我不够合适？2019 年 4 月，我又有机会打破布莱顿马拉松 3 小时的障碍。祈求凉爽的空气！🙏🏼
零代码如何参加 Kaggle 比赛
如果没有以前的经验和对至少一个标准深度学习框架(如 TensorFlow 或 PyTorch)的深入了解，Kaggle 竞赛的入门可能会非常复杂。在本教程中，我们将探索零代码参与 Kaggle 竞赛的机会。
Freesound 音频标记 2019
我们将参加 Freesound 音频标记 2019 Kaggle 比赛。本次比赛是 DCASE2019 挑战赛 中的 任务 2 。如果你想使用与比赛相关的数据集，我们鼓励你在 Kaggle 上注册，通读比赛规则并接受它们。
Freesound Audio Tagging 2019 是前几年由free sound(MTG-庞贝大学)和谷歌的机器感知举办的音频标签比赛的更新。2019 版本是多标签音频标签，音频类别数量是原来的两倍。 FSDKaggle2019 数据集中的注释是通过 Freesound 注释器收集的。
竞赛基于 Eduardo Fonseca 等人的论文:
注册 Peltarion 平台
Peltarion 平台是一个用于深度学习的可视化开发环境。该平台从构建到培训再到部署你的深度学习模型，一行代码都不需要。
- 到平台报名。
- 确认你的电子邮件。
- 等待激活邮件。可能需要几分钟。
- 设置您的密码。
- 该平台已准备就绪，可免费使用 50 个 GPU 小时。
Peltarion Platform
下载 FSDKaggle2019 数据集
FSDKaggle2019 数据集已经针对 Peltarion 平台进行了预处理。这意味着音频文件已被转换为频谱图并与包含每个文件对应类别的 index.csv 文件一起保存为 NumPy 文件。
可下载数据集已经过预处理，可以上传到平台。点击 dataset.zip 下载。
Click on the dataset.zip
创建新项目
在左侧的 Peltarion 主视图中，点击新建项目按钮。现在，您可以在弹出模式中添加项目名称和可选描述。我们将该项目称为项目 v1 。
Home view.
项目 v1 出现在新建项目按钮下方的左侧。点击展开项目，然后点击打开。
上传数据集
点击转到项目后，您将进入项目的数据集视图。在数据集视图上，点击新建数据集。在上传文件选项卡上，点击选择文件上传 dataset.zip ，等待其上传，点击下一步。命名数据集。我们准备把它命名为音频。默认情况下，数据集分为 80%的数据用于定型，剩下的 20%用于验证。我们将使用这种拆分。
我们需要通过点击顶部的新特性集来捆绑类别特性。选择除 fname 之外的所有特征(共 80 个)，并将 F 特征集名称设置为标签，然后点击创建。
在右上角，点击保存版本，你就可以进入建模阶段了。
Datasets view.
创建一个深度学习实验
从顶部的选项卡转到建模视图。点击左边的新实验。我们将把我们的实验命名为实验 v1 。
建模
在建模视图的右侧，可以看到构建和设置选项卡。这些是我们将在构建深度学习模型时使用的工具。在本教程中，我们将把音频文件视为称为光谱图的图片，并执行图像分类。
Audio as a picture.
由于我们正在对被视为图片的声音数据进行分类，因此我们可以使用性能良好的卷积神经网络。在这种情况下，我们将使用 ResNetv2 large 50 。
Ready model in modeling view.
我们现在将在建模视图中创建模型:
- 从块中添加输入块，并将 fname 指定为右上角的特征。
- 添加批量标准化块并保持可训练状态。批次正常化是为了加快训练速度。
- 从块添加整形块，并将目标形状设置为(256，256，1)。 ResNetv2 large 50 需要一个额外的通道轴。
- 从片段中添加 ResNetv2 large 50 。
- 点击 ResNetv2 large 50 上方的输入块，按 backspace 删除。
- 将批量正常化模块的点连接到 ResNetv2 大 50 模块。
- 将 ResNetv2 大 50 后的密集块中的激活改为 ReLU 。 ReLU 在大多数情况下是优秀的激活功能。
- 在目标块之前添加另一个密集块，将其节点设置为 80，激活为s 形。
- 将目标块的特征更改为标签并将损失更改为二元交叉熵。
- 转到右侧的设置选项卡，将批量设置为 28 ，周期到 30 和优化 r 到 Adam 。批量 28 将适合 GPU 内存，30 个历元应该足够模型收敛， Adam 是一个很好的标准优化器。
- 点击视图右上角的 Run 。
评价
从顶部的选项卡进入评估视图。
在评估视图中，您可以跟踪您的模型的训练，并获得实验的实时训练指标。
Evaluation view.
你应该感兴趣的指标是精度和召回。如果你想了解更多，有一篇很棒的媒体文章。
我们的模型现在已经训练好了，可以下载了。您可以点击实验 1 概述中左侧的三点下拉菜单下载模型。在下拉菜单中，点击下载，它打开一个模态，点击确定。将模型下载为 H5 文件会有一点延迟。如果您训练了多个模型，请下载具有最佳验证精度的模型。
模型现在可以发货了！
Kaggle 帐户入门
如果您还没有 Kaggle 帐户，您可以在这里创建一个。请按照说明操作。
一旦您的帐户准备就绪，请加入音频标记 2019 。迟交按钮在右上角。如果这是你第一次参加 Kaggle 比赛，你需要在参加比赛前用你的手机验证你的帐户。
提交预测
点击新内核，选择笔记本。
您需要将下载的模型 H5 文件添加为数据集。为了找到 H5 文件的正确路径，将下面的代码添加到 Kaggle notebook 并运行它(记住保存路径以备将来使用)。
有一些代码。你必须将下面的代码复制粘贴到 Kaggle 笔记本中。
将模型变量路径更改为之前保存的路径，并点击右上角的提交。
点击提交后，ka ggle 内核检查错误并开始用你的模型进行预测，并将 submission.csv 发送给竞赛。
进一步工作—迁移学习
即使比赛不允许迁移学习，在平台上测试迁移学习的能力也是有用的。迁移学习利用从 ImageNet 或 CIFAR-100 等大规模数据集学习的图像属性，然后针对特定的图像识别问题微调神经网络。在我们的例子中，我们会用音频文件的图像对它进行微调。
该平台支持 VGG16、VGG19 和 ResNetv2，权重在 ImageNet 上训练。
使用迁移学习时，您可以尝试使用较小的数据集获得更好的结果。迁移学习通常收敛得更快，即使预训练数据集与您正在使用的数据集非常不同。
特别感谢
特别感谢free sound Audio Tagging 2019的组织者在整个过程中给予的帮助。
参考
Eduardo Fonseca、Manoj Plakal、Frederic Font、Daniel P. W. Ellis 和 Xavier Serra。“带有嘈杂标签和最小监督的音频标签”。已提交至 DCASE2019 Workshop，2019。网址:【https://arxiv.org/abs/1906.02975
爱德华多·丰塞卡、若尔迪·庞斯、哈维尔·法沃里、弗雷德里克·方特、德米特里·波格丹诺夫、安德烈斯·费拉罗、塞尔吉奥·奥拉马斯、阿拉斯泰尔·波特和哈维尔·塞拉。 Freesound datasets:一个创建开放音频数据集的平台。《第 18 届国际音乐信息检索学会会议论文集》(ISMIR 2017)，第 486–493 页。中国苏州，2017。
如何通过谷歌云专业数据工程师考试
没有推荐的 3 年行业经验
所以你可能已经谷歌了上面的标题，现在你在这里。别担心，你不是唯一一个。我也做了同样的事情。
在本指南中，我将让你了解考试是什么样的，以及我是如何准备的(并且通过了！)
我的背景
我最近毕业，获得了物理学学位，2019 年夏天，我在一家名为 Zenu 的早期创业公司实习。这是我第一次接触到数据工程师的角色和谷歌云平台。
你可以在这里阅读更多关于我的实习经历。
我加入 Zenu 时是一名有抱负的数据科学家，也是该公司愿景的坚定信徒，后来发现他们没有任何数据或存储数据的基础设施。因为我想与数据密切合作，所以我承担了 Zenu 的分析数据库的设计和交付的责任。
业务需求的一个技术解决方案是使用 BigQuery 作为我们的数据仓库，它支持使用熟悉的标准 SQL 语法快速查询嵌套行。此外，它允许与其他谷歌云产品进行简单的集成，如用于分析报告的 Data Studio 和用于机器学习的 AI 平台。
来自一个非技术背景，我从零开始学习工作所需的数据工程技能。在此期间，我偶然发现了谷歌云专业数据工程师认证，并参加了几个在线课程，以更好地了解这项技术及其在数据分析未来的更广泛作用。
我花了大约两个月的时间，每天漫不经心地看几个视频，然后花了一个月的时间密集练习论文，并确定关键点。11 月初考的。
资源
课程: 有 GCP 专业证书的数据工程
费用:38/月(1 周免费试用) 有用性: 7/10
Coursera 是我上的第一门在线课程，由谷歌员工授课。他们提供演示、动手实验和演示的组合。
我发现这门课程对于一个没有任何商业经验的人来说是相当高级的。我不知道当前的技术，如 Hadoop 生态系统中的技术，并且被许多不熟悉的术语淹没了。
我看完了所有的视频，但是说实话我马上就忘了大部分。不过我强烈推荐考T3备考 Google Cloud 专业数据工程师考试课程 考试前一两周左右。这就像大学里的复习课，他们会快速介绍考试中可能会看到的关键产品。
像任何一个破产的学生一样，我使用了一周的免费试用，下载了所有的视频供离线观看。
课程: Google Cloud 认证专业数据工程师
费用:【49 美元/月(1 周免费试用)【80 美元/3 个月(学生订阅) 有用性: 9/10
注意:Linux 学院现在是云计算大师的一部分
这是我参加的第二个在线课程，涵盖了考试中出现的大约 70%的内容。本课程还结合了演示、动手实验和演示。
本课程对每项谷歌云服务进行了高度概述，涵盖了关键概念以及谷歌使用每项服务的最佳实践。
该课程结构良好，从基础概念开始，到不同类型的数据库、架构管道、机器学习和数据可视化。
我发现这个很容易理解，对新手也很友好。马修·乌拉森(课程讲师)在谷歌云平台方面的专业知识意味着他的解释非常清晰简洁。在他的视频中，他经常强调考试中会出现的关键事实和概念。
有各种动手实验、演练和测验可以帮助巩固您的理解，并提供机会直接在 Google 云平台上测试您在视频中学到的材料。
Screenshot of The Data Dossier provided by Linux Academy for the Google Cloud Certified Professional Data Engineer course
本课程提供的最有帮助的资源之一是数据档案，它就像一套数字化的课程笔记。它突出了每项服务的要点，显示了清晰的对照表、图表和工作流程，以及考试时需要记住的提示。
如果你是数据工程的新手，我建议你先学习这门课程，因为它比 Coursera 课程更容易掌握。
如果我只推荐一个付费订阅，这将是一个。我支付了 3 个月的学生订阅费，这是值得的。你不仅可以接触到 GCP 课程的惊人资源，还可以完全接触到 Linux Academy 提供的所有其他课程(我曾经使用过)。
课程: Google 数据工程师考试—专业认证备考
费用:49/月(1 周免费试用) 有用性: 8/10
云学院是我用来备考的第三个也是最后一个在线课程。我在考试前一周开始上这门课，更多的是把它作为复习而不是学习指南。
这门课程最有用的一点是，它涵盖了其他课程中没有涉及的安全和网络、数据加密和计算引擎等主题，但可以根据官方考试大纲进行测试。
除了上面提到的主题，我以 1.5 的速度观看了所有其他视频，以检查是否有任何我以前不知道的新信息。我发现动手实验有点难，而且更多的是复制粘贴一长串预先写好的命令。
我使用了 1 周的免费试用。
其他资源
以下是我发现的一些非常有用的资源，但根据你的经验是可选的。
Linux Academy—大数据要领 (免费带社区账号)
本课程全面介绍了大数据世界。它涵盖了大数据基础架构的原理及其与云计算的集成。
对我来说，本课程最有用的一点是，它提供了最流行的大数据技术的高级概述，包括核心 Hadoop、Hadoop 生态系统(Hive、Pig、Kafka 等)和 Apache Spark。对于考试，你需要知道这些是做什么的，以及它们在 GCP 的对等物。例如 Kafka -> PubSub，Hive -> BigQuery。
Linux Academy—SQL 入门
本课程是在谷歌云认证专业数据工程师课程开始时为不熟悉 SQL 的人推荐的。它涵盖了基本的 SQL 语句和函数，包括聚合、连接和排序。如果您以前没有使用过 SQL 或者不经常使用，我推荐您学习本课程，因为您将需要它来在 BigQuery 中编写查询语句。
本课程是谷歌对机器学习的快速、实用介绍。我用这门课快速复习了一下，因为我已经在大学课程中讲述了一些流行的算法和概念。然而，我认为它的结构很好，会给你在机器学习方面打下良好的基础。
Qwiklabs 是一个平台，以教程和演示的形式提供在各种云平台上使用的临时信用。您可以使用 Qwiklabs 获得额外的 Google 云平台实践经验。我考了 Baseline: Data，ML，AI/数据工程/big query for Data Warehousing课程。我发现最后一个非常有用，因为它允许您练习在 BigQuery 中编写查询语句。
我的建议
有许多人通过了专业数据工程考试，并在网上分享了他们的准备和考试经验。我觉得他们中的大多数人都来自技术背景，所以他们浏览了一些显而易见的知识(因为参加考试的建议经验是 3 年以上的行业经验，包括 1 年以上使用 GCP 设计和管理解决方案的经验)。
在阅读在线论坛、评论和听说参加考试但失败的人时，一个似乎很常见的模式是，他们低估了考试的难度，因为他们在日常工作中做类似的事情。
我可以理解这种对考试中机器学习部分的过度自信，因为我已经熟悉了在大学模块中涉及到的算法。我在教学大纲的这一部分上花的时间较少，因此对我的一些答案不太自信。
作为学生，我们的一个优势是我们习惯于学习。就我而言，我刚刚结束最后一年的考试，仍处于“学习模式”，所以准备这次考试并不太陌生。在你繁忙的日程安排之外，我知道你可能已经有好几年没有为考试而学习了，所以我将概述一些你应该关注的关键领域以及我是如何准备的。
先看考试大纲
我犯的第一个错误是没有正确阅读谷歌官方考试指南，天真地认为在线课程会涵盖这一点。在线课程做得好的地方在于，它们详细涵盖了每项 GCP 服务，概述了其常见用例、谷歌使用该服务的最佳实践，以及它们如何适应整体数据工程角色。
From the official exam guide
考试测试的是你对业务需求提出可行技术解决方案的能力。虽然永远不会有一个完美的解决方案，但一个伟大的解决方案应该考虑到上述四点。
在考试中，你可以看到几个可能满足业务或技术需求的选项，但其中一个比其余的更好。
提升和换挡与提升和杠杆
如果你看过一些在线课程，你可能认识这些术语。
提升和转移就是简单地将现有流程或基础设施迁移到云中，而不需要重新设计任何东西。一些公司可能会采取这种方法，因为他们不想花费时间和金钱来修改他们当前的基础架构，但仍然希望利用云的优势。例如，在计算引擎上托管 MySQL 数据库，而不是将所有数据迁移到云 SQL。
提升和利用意味着将您现有的流程迁移到云上，并使用云提供的一些服务使它们变得更好。例如，您可以使用 Dataproc 运行 Hadoop 和 Spark 工作负载，但是将数据存储在云存储中，而不是存储在 HDFS。这更具成本效益，因为您只需为作业运行的时间付费，然后您可以在不使用群集时关闭它，而不会丢失所有数据，因为它现在存储在云存储中。
在完成所有在线课程和练习题后，你可能会认为大多数答案都涉及到为特定的业务或技术需求选择最合适的 Google 云服务。毕竟，谷歌出售的是他们卓越的、低成本的、完全管理的、无运营的云服务能力。
然而，情况并非总是如此，仔细阅读问题很重要，因为考试中的一些问题有技术要求，他们不想对现有流程进行任何修改。
成本与性能
对我来说，考试最难的部分是成本和性能之间的权衡。(这可能是你 3 年以上的行业经验派上用场的地方！).业务人员考虑的是最小化成本，而技术人员考虑的是提高性能。
一个常见的问题是“一家中型公司希望在保持低成本的同时[做点什么]”。虽然有些情况是显而易见的，如使用云 SQL 与云扳手，但涉及运行作业的场景更难，因为您可以使用更强大的 CPU(成本更高)来运行作业，从而缩短运行时间(成本更低)。
您应该关注的其他一些领域
最近，有一种趋势是让每个人都可以接触到人工智能。BigQuery ML 允许用户使用标准 SQL 查询在 BigQuery 中创建和执行机器学习模型，而不是编写代码。其中一个很大的优势就是数据不会离开 BigQuery。请看这个视频的简单解释。
卡夫卡— 我从其他渠道了解到卡夫卡在考试中出现了很多次，对我来说也是如此。Google Cloud 的对等物是 Cloud Pub/Sub。你应该知道两者之间的区别，例如 Pub/Sub 只能保存长达七天的数据，而 Kafka 可以存储你想要的数据，并且可以随时访问。
故障转移副本— 正如考试指南的教学大纲 4.3 所述，为您的数据基础架构考虑备份解决方案非常重要。一些谷歌云服务会自动创建数据副本，而另一些则需要手动设置。考虑您想要提供服务的地区和区域。如果一个区域中的数据中心出现故障，会发生什么情况？你如何为此做准备？
云密钥管理&数据加密— 数据安全是数据工程非常重要的组成部分。默认情况下，GCP 加密所有静态客户数据。您应该知道还有其他加密方法，包括 CMEK、CSEK 和客户端加密。Google Cloud 有一个云密钥管理服务，可以让你管理云服务的加密密钥。
Table comparison of different data encryption types (Coursera)
学习策略
每个人都有不同的学习方法，所以你应该找到适合你生活方式的方法。我并不是建议你采用我的方法，但是如果你还没有找到你的风格，或者发现其他技术不起作用，请随意尝试我的方法。
基础知识
在线课程方面，我推荐以下顺序。
- Linux Academy — 大数据基础知识 (可选)— 对大数据世界的非技术性介绍，对 Hadoop 生态系统进行了高度描述。
- Linux Academy—SQL 入门 (可选)—SQL 入门。对于 BigQuery，您需要一些基本的 SQL 知识。
- Linux Academy—Google Cloud 认证专业数据工程师 — 对你在考试中有望看到的主要 GCP 服务的深入介绍。
- Coursera — 数据工程与 GCP 专业证书 — 稍微高级一些，更侧重于现实世界中数据工程师的角色。
- 云学院— Google 数据工程师考试—专业认证备考 — 好用来作为临近考试日期的复习。花些时间看看其他在线课程中没有涉及的主题。
- 机器学习速成班——涵盖了数据科学中最常用算法背后的数学和动机。对于考试，您应该知道哪种算法适合业务需求，包括监督(回归、分类)、非监督(聚类)和强化学习。
- Coursera—准备 Google Cloud 专业数据工程师考试 — 这其实是上面提到的 Coursera 课程的一部分，但我建议在考试前一两周上这门课。本课程涵盖了官方考试指南中的所有要点。
动手实践
如果你没有很多使用谷歌云平台的经验，我建议你使用动手实验室和 Qwiklabs 练习。你不应该记住如何做每一项任务，而是把它作为一个熟悉服务和整个 GCP 环境的机会。
如果您订阅了 Linux Academy，您就可以访问云沙盒，在那里您可以获得访客用户凭据，以便每次会话使用 GCP 3 小时。
通过使用这个云沙盒，或者创建一个免费的 GCP 账户(300 美元免费信用),并按照 Coursera 或 Qwiklabs 上的动手实验室的任务说明，你仍然可以获得有价值的实践，而不会打破你的钱包。(在 Qwiklabs 上，你实际上是在固定时间内付费使用 GCP 环境)
过去的论文
我在大学的学习策略是尽可能早地做试卷，让自己熟悉考试风格和期末考试中可能出现的题型。通过这种方式，你可以发现自己知识上的差距，并专注于自己的薄弱领域。
如果你已经有行业经验，我推荐这种方法。如果你是第一次学习数据工程，我建议你完成 Linux Academy 课程，至少做一次模拟考试，然后继续 Coursera 课程。
真正考试前一个月，我一周做一次模拟考试。我用的是 Linux Academy 实践考试，Coursera 实践考试和谷歌官方数据工程师实践考试。
你复习的练习纸步骤最重要的部分是记下你做错的所有问题，然后再复习一遍。查看答案后(参加在线课程的测试后)，您会看到一个简短的解释，说明为什么您的答案是对的或错的(有时还会看到一个链接，指向涉及该主题的视频)。对于谷歌的官方实践考试，他们也会给你链接到他们在 GCP 网站上的官方文档。
以下是一些额外的自由练习题:
- https://www . whiz labs . com/Google-cloud-certified-professional-data-engineer/
- https://www . exam topics . com/exams/Google/professional-data-engineer/view/1/
我不能强调坚持做练习题的重要性。虽然它们没有反映出与真正考试相同的难度，但你将接触到各种各样的问题，并增加你参加真正考试的信心。
最后
课程导师极力强调仅完成在线课程不足以通过考试。你的准备应该包括各种在线资源、GCP 的实践和过去的试题。
我强烈推荐我的修订版中包含的另外两个内容。
- 阅读官方谷歌云文档——阅读全部文档不太现实，但我的建议是阅读在线视频所涵盖主题的文档。你应该记住的要点是谷歌的最佳实践(用于做某些事情)和一些服务的配额和限制(例如，为云 SQL 存储高达 3TB 的数据)。经验法则是，如果你可能在工作中查找它(例如，2vCPU 计算引擎每月花费多少)，你不需要记住它。但是，您应该大致知道，不同存储类型的上限。
- 浏览案例分析— 它们曾经是 2019 年 3 月之前考试的一部分，但不在当前的教学大纲中。说到这里，我发现浏览这些案例非常有用。作为一名之前没有任何数据工程经验的学生，看到现实生活中的应用程序和数据工程师为提出业务需求的技术解决方案而经历的思维过程是很有帮助的。你可以在 Coursera 上查看和浏览这些关于 准备谷歌云专业数据工程师考试 课程的案例研究。您可以在此观看一群经验丰富的专业人士讨论某个案例研究的几个潜在解决方案。
考试期间
考试由 50 道题组成，你有 2 个小时的时间完成。有一个书签功能，您可以将问题标记为书签，供以后查看。根据我在网上读到的，大多数人花了大约 1 到 1 小时 15 分钟来完成这个测试。我用了整整 2 个小时。
我会说考试比模拟考试难 20%左右。许多问题会引起很多自我怀疑，比如成本与性能的权衡。我的建议是调整自己的节奏，不要在一个问题上浪费太多时间。如果你不知道答案或者不确定你的答案，把它标上书签，然后继续下一个。
如果你第一次不能回答所有的问题，不要惊慌。我被前 5 个问题难住了，然后把一半以上的问题做了书签，以便以后复习。
最终意见
干得好，走到了这一步！我希望这个指南对那些即将参加考试的人有所帮助，并有望成为他们的信心助推器。没有商业经验，站在理论的立场上准备，肯定是可以通过这个考试的。
我在下面添加了一些帮助我准备考试的链接。这些人还分享了他们的经验，并提供了一些很好的建议和需要注意的地方。
- https://towards data science . com/passing-the-Google-cloud-professional-data-engineer-certification-87da 9908 b 333
- https://deploy . live/博客/Google-cloud-certified-professional-data-engineer/
- https://medium . com/@ sathishvj/notes-from-my-Google-cloud-professional-data-engineer-exam-530d 11966 aa 0
祝你好运！你能行的！
如果你喜欢这篇文章，何不注册 medium，通过此链接阅读更多精彩内容。
https://medium.com/@jonathan.moszuti/membership
我已经使用了上面列出的所有资源，并且只推荐对我备考有帮助的产品**
Photo by Ian Stauffer on Unsplash
如何用 Apache Spark 和 LightGBM 大规模构建机器学习模型？
Image credit iStockPhoto.com
虽然在 Jupyter 笔记本电脑上用相对较小的静态数据集训练机器学习模型很容易，但当它部署在金融机构内部的真实环境中时，会出现挑战，因为海量的交易数据驻留在 Hadoop 或数据湖中。在本文中，我将向您展示如何利用 Apache Spark 来实现使用 LightGBM 在 Spark 环境中构建和训练模型的核心部分，light GBM 被认为是在数据科学社区中广泛使用的梯度推进算法的快速实现。
Apache Spark 是一个内存集群运行时环境，存储和处理数据的速度比从 SSD 或硬盘访问数据快几千倍。假设我们要处理的数据集位于 Hadoop、S3、数据库或本地文件中，那么第一个任务就是在 Spark cluster 中以 Spark dataframe 的形式访问它。
欺诈检测是每个发行信用卡的金融机构目前都在进行的一项活动，该活动使用大规模数据集，这些数据集是每天在其平台上发生的数百万笔交易的结果。在我们的例子中，我将 ULB 机器学习小组提供的 CSV 文件格式的数据集作为 Spark dataframe 导入到由 Databricks community edition 托管的具有 6gb RAM 的 Spark 集群上。这是关于向数据块添加数据的指南。
*# File location and type*
file_location = "/FileStore/tables/creditcard.csv"
file_type = "csv"
*# CSV options*
infer_schema = "true"
first_row_is_header = "true"
delimiter = ","
df = spark.read.format(file_type) \
.option("inferSchema", infer_schema) \
.option("header", first_row_is_header) \
.option("sep", delimiter) \
.load(file_location)
该数据集包含约 300，000 行，由 31 个与欧洲信用卡持卡人交易相关的变量组成，其中 28 个是通过对一些未披露的原始参数进行主成分分析而得出的数值变量。剩下的三个变量是交易量、相对于第一次交易的交易时间(以秒计)以及指示交易是真实还是欺诈的交易标签。当我们谈论大规模时，数据集可能看起来很小，但只要选择使用 Apache Spark 来训练模型，即使是小数据集，也可以放心，相同的代码将无缝扩展到任意大的数据集，这些数据集可能托管在 HDFS、S3、NoSQL 数据库或数据湖中，只要它可以以 Spark 数据帧的形式访问模型。
就标记为欺诈和真实的样本数量而言，数据集严重失衡。与数据集中的总行数相比，它只有少量的 492 个样本与被识别为欺诈的交易相关。你可以在 Kaggle 上访问这个数据集。
下一步是从这个数据帧中选择我们希望在训练模型时用作输入变量和目标变量的列。在构建生产级 ML 模型时，执行数据转换步骤通常是一种很好的做法，例如使用标签编码器或一个热编码器作为管道阶段将分类列转换为数字列，然后可以用于转换训练、验证或测试数据，而不会将测试用例的知识泄露给训练数据(同时执行标准化缩放等转换)和代码的高维护性。
feature_cols = ["V" + str(i) **for** i **in** range(1,29)] + ["Amount"]
assembler = VectorAssembler(inputCols=feature_cols, outputCol="features")
stages = [assembler]
接下来，我们可以向管道添加 LightGBMClassifier 实现的实例。LightGBMClassifier 类在由 Microsoft Azure 团队作为开源项目维护的 MMLSpark 库中可用。按照本页中建议的步骤，可以将它作为库包含到集群中。我通过从 Maven option 中搜索名为 mmlspark 的包添加了这个库，选择了它的 0.17 版本，并将其安装在集群中。之后用 Python 从 mmlspark 导入 LightGBMClassifier 就奏效了。
在使用 LightGBM 时，使用超参数的最佳值对其进行调优是非常重要的，例如叶子的数量、最大深度、迭代次数等。如果用不同的超参数值训练，在相同数据上训练的模型的性能可以有很大不同。
通常，这需要设置交叉验证实验，并使用一些超参数值空间探索策略，如全网格搜索、随机搜索、贝叶斯优化或树形结构 Parzen Estimators 算法，以找出超参数的最佳值，通过最小化一些预定义的误差度量(如二进制误差)或最大化一些分数(如 ROC 或 F1 测量下的面积)来最大化模型在验证数据集上的性能。
这种探索可能会持续很长时间，这取决于我们想要探索的参数值空间的大小以及我们对模型的预期性能水平。在这种情况下，我决定调优 LightGBM 模型的 7 个超参数。这些参数中有许多是实值，这意味着要探索的参数空间是无限深的。
为了获得不间断的计算时间，通过评估超参数值的不同组合来探索这个超参数空间，同时使用一些优化策略在相对较少的评估轮次中找出超参数的接近最优的值，我使用了具有相同数据集的 Python 中 Kaggle 的执行环境内的 Hyperopt 库。在对超参数值的组合进行 200 次评估后，我使用树形结构的 Parzen 估计算法来找出超参数的最优值。这是我在 Spark 内部训练这个模型时确定要使用的超参数值的笔记本。
在 Databricks 的社区版中，我可以不间断地访问集群 2 个小时。如果您可以访问 Spark cluster 更长的不间断时间，您还可以使用 Spark 中的 ParamGridBuilder 和 CrossValidator 类来探索和评估超参数值，如下面的示例代码所示。如果您想在这里以更有效的方式进行整个超参数调整，而不是执行整个网格搜索，您可以参考由 Hyperopt 和 DataBricks 提供的指南，这些指南展示了如何使用 Spark cluster 和 Hyperopt。
在这里，我使用了我从 Kaggle 的 python 环境中进行的模型调整中获得的大多数最佳超参数值，以及 lambda L2 正则化参数的调整值作为 Spark 内部使用 CrossValidator 执行网格搜索的示例。
请注意，我在 LightGBMClassifier 中设置了标志 isUnbalance=True，这样它就可以处理我们前面讨论的数据集中的不平衡。
best_params = {
'bagging_fraction': 0.8,
'bagging_freq': 1,
'eval_metric': 'binary_error',
'feature_fraction': 0.944714847210862,
'lambda_l1': 1.0,
'lambda_l2': 45.0,
'learning_rate': 0.1,
'loss_function': 'binary_error',
'max_bin': 60,
'max_depth': 58,
'metric': 'binary_error',
'num_iterations': 379,
'num_leaves': 850,
'objective': 'binary',
'random_state': 7,
'verbose': **None** }lgb = LightGBMClassifier(
learningRate=0.1,
earlyStoppingRound=100,
featuresCol='features',
labelCol='label',
isUnbalance=**True**,
baggingFraction=best_params["bagging_fraction"],
baggingFreq=1,
featureFraction=best_params["feature_fraction"],
lambdaL1=best_params["lambda_l1"],
# lambdaL2=best_params["lambda_l2"],
maxBin=best_params["max_bin"],
maxDepth=best_params["max_depth"],
numIterations=best_params["num_iterations"],
numLeaves=best_params["num_leaves"],
objective="binary",
baggingSeed=7
)paramGrid = ParamGridBuilder().addGrid(
lgb.lambdaL2, list(np.arange(1.0, 101.0, 10.0))
).build()evaluator = BinaryClassificationEvaluator(labelCol="label",metricName="areaUnderROC")crossValidator = CrossValidator(estimator=lgb,
estimatorParamMaps=paramGrid,
evaluator=evaluator,
numFolds=2)
stages += [crossValidator]
pipelineModel = Pipeline(stages=stages)
下一步是将数据集分成训练数据集和测试数据集。我们将使用训练数据集来拟合我们刚刚创建的管道，该管道由特征组装和模型训练等步骤组成。然后，我们将使用此管道来转换测试数据集，以生成预测。
train, test = df.randomSplit([0.8, 0.2], seed=7)
model = pipelineModel.fit(train)
preds = model.transform(test)
一旦我们有了来自测试数据集的预测，我们就可以用它们来衡量我们的模型的性能。Spark 提供了 BinaryClassificationEvaluator，可以计算 ROC 度量下的面积。
为了计算其他相关指标，如精确度、召回率和 F1 分数，我们可以利用测试数据集的预测标签和实际标签。
binaryEvaluator = BinaryClassificationEvaluator(labelCol="label")print ("Test Area Under ROC: " + str(binaryEvaluator.evaluate(preds, {binaryEvaluator.metricName: "areaUnderROC"})))#True positives
tp = preds[(preds.label == 1) & (preds.prediction == 1)].count() #True negatives
tn = preds[(preds.label == 0) & (preds.prediction == 0)].count()#False positives
fp = preds[(preds.label == 0) & (preds.prediction == 1)].count()#Falsel negatives
fn = preds[(preds.label == 1) & (preds.prediction == 0)].count()print ("True Positives:", tp)
print ("True Negatives:", tn)
print ("False Positives:", fp)
print ("False Negatives:", fn)
print ("Total", preds.count()) r = float(tp)/(tp + fn) print ("recall", r) p = float(tp) / (tp + fp)print ("precision", p)f1 = 2 * p * r /(p + r) print ("f1", f1)
在这种情况下，其 AUC-ROC 得分为 0.93，F1 得分为 0.70。在 Kaggle notebook 中，我在使用它进行训练之前还使用了 SMOTE 来平衡数据集，它获得了 0.98 的 AUC-ROC 分数和接近 0.80 的 F1 分数。我在 Kaggle 环境中对超参数值的组合进行了 200 次评估。如果我们想进一步提高模型的性能，那么接下来要做的显然是在 Spark 中实现 SMOTE 来平衡训练数据集，然后再用它来拟合管道。我们还可以通过对参数值组合进行大量评估来更深入地探索超参数空间。
除了在 Spark 上训练 LightGBM 等高性能模型之外，数据科学团队通常面临的另一个重大挑战是管理准备数据、选择模型、训练、调整、保存最佳参数值、部署训练好的模型以及以 API 形式访问输出预测的生命周期。 MLFlow 是一个试图解决这个问题的开源解决方案。建议有兴趣的读者多了解一下。我也可能会写一篇文章，介绍如何将它集成到建立 ML 模型构建、培训和部署项目的工作流中，就像我在 Databricks 平台上使用 Spark 演示的那个项目一样。
你可以在 GitHub repo 上托管的这个笔记本中参考我在数据块上执行的确切步骤。这里是另一个笔记本，我在 Kaggle 上对这个数据集进行了参数调优实验。
我希望这篇文章对你使用 LightGBMClassifier 在 Apache Spark 上实现机器学习有所启发。如果你在自己尝试的时候有什么问题，欢迎在评论中提问。
如何执行可解释的机器学习分类——没有任何树
Credit: Pixabay
严格而清晰的规则……在我们看来是背景中的东西——隐藏在理解的媒介中。
——路德维希·维特斯坦根
决策树是一种流行的分类技术。它们直观、易于理解，并且开箱即用。
树模型是人类可以理解的规则的路径。在某些情况下，能够为你的预测提供一个解释——原告的贷款申请被拒绝，因为他们正面临破产程序，而不是，某物——某物——某物——点产品——可能是一个优势。
但是还有另一类规则生成算法，您可能不熟悉，可能值得添加到您的工具集中，称为规则集学习器。
在最近一个通过古典音乐作曲家对音频进行分类的项目中，我的规则集实现击败了 sklearn 的 DecisionTreeClassifier，并匹配了网格搜索优化的 SVD 和随机森林。
让我们看看什么时候您可能想要考虑规则集模型，它们如何工作，以及如何在您自己的代码中使用它们——包括我最近开发的一个新的 Python 包，您可以使用它进行分类。
动机
尽管决策树有很多优点，但它们因过度拟合、脆弱和难以处理不平衡数据集而臭名昭著。
树通过从完整的训练集开始学习，并贪婪地添加最大化每个子节点的类纯度的条件。随着我们沿着树向下，每个节点添加一个条件，将我们的训练数据分成越来越小的子组:
Decision tree model generated by sklearn on the mushroom dataset.
在短短的几个决策步骤中，我们已经从具有数千个样本的根发展到样本大小低至 29、11、2 甚至 1 的叶。
怎么会？想想二叉树搜索是如何很好地扩展的，因为树的深度只随着节点数量的对数增长。对于训练决策树来说，另一方面是节点的数量随着深度以指数的速度增长。因此，我们的训练子集收缩得非常快，最终缺乏统计上有效的样本量。
出于类似的原因，树是“脆弱的”,因为训练集中的微小变化会改变顶级规则，从而在整个模型中产生连锁反应。
有几个流行的技术来处理树木过度拟合和脆弱性。我们可以修剪这棵树，要么根据某个阈值提前停止生长，要么在完成后缩小它的大小。或者我们可以建立一个由数千棵树组成的随机森林集合，以训练速度和可解释性为代价。
规则集类似于决策树，但是因为它们没有层次结构，有有序的子分支决策，所以它们有可能避开这些缺点。
规则集学习者也倾向于产生更紧凑的模型。
Some major differences between trees and rulesets
那么什么是规则集呢？
规则集就是合取词(and)的析取(or)。
例如，描述您的孩子能否说服您出去吃冰淇淋蛋糕的模型可能是这样的:
如果:
我很好和我们有足够的时间去买冰淇淋；或
你的韧性被磨薄了和你不想和我打交道；或
你感到大度，
然后:
冰淇淋蛋糕。
我们可以象征性地表达这个规则集:
(我很好 ^ 我们有足够的时间)vt23】(筋疲力尽 ^ 你就是不行) V
(坦荡)
用 python 语言来说:
[[(行为=好)，(时间=真)]，
[(韧性=瘦)，(你=连不上)]，
[(感觉=坦荡)]]
如何训练规则集模型
规则集不是通过递归将训练数据分解为子集的子集，而是通过对所有尚未检查的训练数据进行训练来迭代增长。
为了获得训练如何工作的基本味道，让我们首先来看看一个简单的规则集学习算法，称为 IREP。
在将我们的数据分成训练集和测试集之后，我们通过以下步骤在训练集上训练模型:
1.将你的训练集分成“生长集”和“修剪集”
2.增长规则(信息增益)
3.删减规则(减少错误度量)
4.从您的训练集中删除新规则涵盖的示例，并重复步骤 1、2 和 3，直到您开始让事情变得更糟(精度度量)。
在步骤 1 中，我们将训练数据随机分成 2/3–1/3。我们将使用第一部分增长规则，第二部分修剪规则。这有点像交叉验证要求我们留出评估折叠，这种分割确保我们不会使用刚刚用于增长的相同数据进行修剪！
接下来，我们通过贪婪地添加最大化 FOIL 信息增益的条件来增长规则(下面的公式)。随着我们的规则获得越来越多的条件，它变得越来越严格，排除了越来越多的负类例子。(记住，规则是一组“和”的集合，更多的“和”意味着更严格。)当规则不再涵盖负面例子时，我们就停止了。
FOIL information gain. p0 (n0) is the number of positive (negative) examples covered by an existing rule, p1 (n1) the number covered by the proposed new rule.
现在是时候修改我们刚刚制定的规则了。我们尝试以相反的顺序贪婪地修剪它的每个条件，选择最大化一些修剪度量的规则，比如这个:
Pruning criterion. p (n) is the number of positive (negative) examples covered by the rule, P (N) the total number. Different versions use different prune metrics.
我们刚刚制定并修改了我们的第一条规则！现在我们迭代。从我们的训练集中，删除新规则覆盖的示例。继续增加新规则——使我们的规则集越来越宽松——直到我们增加一个精确度低于 50%的规则。
这是整个过程的可视化:
Growing-pruning a ruleset using iterative coverage.
我的新规则集包，维特根斯坦，实现了 IREP，以及另一个叫做 RIPPER 的规则集算法。除了听起来像重金属乐队，开膛手仍然是这种技术的艺术状态。
该算法比 IREP 要复杂得多，但主要区别如下:
- 一个理论上更严密的停止条件:RIPPER 没有使用修剪指标来告诉我们何时停止生成新规则，而是借用了昆兰的 C4.5 决策树算法中使用的一种信息论启发式方法，称为描述长度。这个想法是，我们可以在建模过程的任何阶段测量总复杂性(以比特为单位),即我们的试验性模型的复杂性加上它未能捕获的所有示例的复杂性。随着我们的规则集在长度和精度上的增长，模型的复杂性会增加，而它无法捕获的示例数量的复杂性会降低。为了防止过度拟合，一旦总复杂度超过某个阈值，我们就停止增加规则。描述长度指导最小化训练错误和最小化模型复杂性之间的平衡行为。
- 计算模型的描述长度既复杂又昂贵。但是要点是模型的复杂性是基于的区别性。条件较多的规则比条件较少的规则更复杂，从更大的可能性池中选择条件的规则也是如此。
k is the number of conditions in the rule, n the number of possible conditions. r is k/n. ||k|| is the number of bits needed to send k (i.e., log2(k)). The 0.5 factor is to account for possible redundancies.
- 异常描述长度公式更简单。我们从正面和负面预测中选择假阳性和假阴性的组合。(公式使用组合而不是排列，因为顺序并不重要)。Log₂将十进制值转换为比特:
p is the number of examples classified as positive, n the number classified as negative. fp is the number of false positives, fn false negatives.
- 模型优化:一旦我们生成了初始规则集，我们实际上可以使用我们的模型以更全面的方式重新评估每个规则的贡献。我们考虑用几个备选方案来替换每个规则:一个全新的生长修剪过的替换和一个生长修剪过的原始修订。我们的优化模型使用三者中最好的一个——原始、替换或修订。(“最佳”这个词有点复杂，实现起来也有点可怕。这意味着任何规则都会导致规则集的最小描述长度，这是基于如果我们删除所有其他增加描述长度的规则，我们可以得到的最小可能描述长度。)我们可以根据需要多次重复优化阶段，但原始论文建议进行两次迭代。
不也是这样吗，我们一边玩，一边制定规则？
——路德维希·维特斯坦根
- 总结:如有必要，增加一些规则，以涵盖我们的优化模型不再涵盖的任何正面训练示例。最后，去掉任何不能提高描述长度的规则。
在代码中使用规则集
想要使用规则集学习者的 Java 用户可以使用 Weka 的 RIPPER 实现 JRip 。还有 Python 和 r 的 Weka 包装器。
Python 用户也可以尝试维特根斯坦。(可能有其他针对这些特定算法的 Python 包，但我找不到任何包。)这里是 github 回购。
从命令行安装:
pip install wittgenstein
这里有一个快速的使用示例，使用令人愉快的毒蘑菇数据集。我们的目标是产生一套规则，可以辨别哪些蘑菇有毒。
让我们从将数据帧加载到 pandas 开始:
>>> import pandas as pd
>>> df = pd.read_csv(mushroom.csv)
训练-测试-分割我们的数据:
>>> from sklearn.model_selection import train_test_split
>>> train, test = train_test_split(df, test_size=.33, ... random_state=42)
维特根斯坦使用与 scikit-learn 相似的 fit-predict-score 语法。我们将训练一个开膛手分类器，将阳性类别定义为有毒。
>>> import wittgenstein as lw
>>> clf = lw.RIPPER()
>>> clf.fit(train, class_feat='Poisonous/Edible', pos_class='p',
... random_state=42)
在初始化/拟合期间，我们可以传递几个可选参数:
**prune_size**:更改增长/修剪比例。如果你想跳过修剪阶段(刺激，但不推荐！)使用 IREP 时，您可以将其设置为无。**k**:优化运行的次数**dl_allowance**:复杂性停止阈值**verbosity (1–5)**:如果你想知道规则是如何产生的，就用这个。(每个详细级别在文档字符串中都有解释。)**n_discretize_bins**:维特根斯坦会为你自动检测和离散化连续特征——如果你想控制容器的数量，使用这个。
您可以使用默认的度量标准(准确性)或者通过传递您自己的评分度量标准来测试模型。让我们从 scikit-learn 导入 precision 和 recall。我们还将通过计算条件的数量来检查模型的复杂性。
>>> # Split target class feature
>>> X_test = test.drop('Poisonous/edible', axis=1)
>>> y_test = test['Poisonous/edible']>>> # Collect performance metrics
>>> from sklearn.metrics import precision_score, recall_score
>>> precision = clf.score(X_test, y_test, precision_score)
>>> recall = clf.score(X_test, y_test, recall_score)
>>> cond_count = clf.ruleset_.count_conds()>>> print(f'precision: {precision} recall: {recall}
... conds: {cond_count}')precision: 0.9938..., recall: 0.9977..., conds: 32
我们可以使用 clf.ruleset_ attribute 访问我们的训练模型。经过训练的规则集模型表示“或”的“与”列表:
>>> clf.ruleset_.out_pretty()
[[Stalk-surface-above-ring=k^Gill-spacing=c] V
[Gill-size=n^Stalk-root=?^Stalk-shape=t] V
[Gill-size=n^Population=s] V
[Sport-print-color=h^Cap-surface=s] V
[Gill-size=n^Cap-surface=s^Stalk-shape=e] V
[Gill-size=n^Habitat=g] V
[Population=v^Stalk-shape=e^Bruises?=t] V
[Gill-size=n^Stalk-root=b^Gill-spacing=c] V
[Gill-size=n^Population=c] V
[Gill-size=n^Cap-color=p] V
[Gill-size=n^Gill-color=u^Cap-surface=f] V
[Gill-size=n^Cap-color=g^Gill-spacing=w] V
[Gill-color=g^Stalk-root=b]]
若要生成新的预测，请使用 predict 方法:
>>> clf.predict(mysterious_unseen_mushrooms)
[True, False, False, True, False...
我们也可以要求我们的模型告诉我们为什么它做出了每一个肯定的预测:
>>> clf.predict(mysterious_unseen_mushrooms, give_reasons=True)([True, False, False, True, False...,
[[<Rule object: [Gill-size=n^Population=s]>,
<Rule object: [Gill-size=n^Cap-surface=s^Stalk-shape=e]>],
[],
[],
[<Rule object: [Gill-size=n^Population=s]>],
[]...)
相当酷！
效果如何？
我使用 scikit-learn 的 DecisionTreeClassifier 和网格搜索优化的 RandomForestClassifier 作为基线，在最初的 11 个分类数据集(大部分来自 UCI )上重复测试了我的 IREP 和 RIPPER 实现。(我抛出了两个数据集的结果，sklearn 和维特根斯坦分别拒绝做出正面预测。)
将规则集与随机森林这样的集成技术进行比较有点不公平——网格搜索-调整森林使它更加不公平——但我想看看维特根斯坦能在多大程度上与最好的可比较替代方案竞争。
尽管它是一个决策树分类器，scikit-learn 的树实现实际上并不接受分类数据。但是没关系——我们只需要做一点预处理，将数据转换成 DecisionTreeClassifier 可以接受的格式。
首先，让我们使用 scikit 的 LabelEncoder 将我们的分类特征转换成数字特征:
>>> from sklearn.preprocessing import LabelEncoder
>>> le = LabelEncoder()
>>> df_le=df.apply(le.fit_transform)
>>> df_le.head()
然后，我们使用一个热编码来创建虚拟变量。否则我们将被序数特征所困，而不是名义特征！
>>> from sklearn.preprocessing import OneHotEncoder
>>> encoder = OneHotEncoder(sparse=False)
>>> encoder.fit(df_le)
>>> df_hot = enc.transform(df_le)
>>> df_hot.head()
预处理完成，我们现在准备分割我们的数据…
>>> train, test = train_test_split(df_hot, test_size=.33, ... random_state=random_state)
>>> train_X = train[:,n_classes:]
>>> train_y = train[:,0]
>>> test_X = test[:,n_classes:]
>>> test_y = test[:,0]
…并训练我们的模型:
>>> tree_clf = DecisionTreeClassifier(random_state=random_state)
>>> tree_clf.fit(train_X, train_y)
为我们可爱的树打分:
>>> predictions = tree_clf.predict(test_X)
>>> precision = precision_score(test_y, predictions)
>>> recall = recall_score(test_y, predictions)
>>> print(f'precision: {precision} recall: {recall} node_count: ... {tree_clf.tree_.node_count}')
...
下面是调整和适应随机森林的代码:
>>> forest = RandomForestClassifier(random_state=random_state)
>>> n_features = train_X.shape[1]
>>> grid_params = {
'n_estimators': [50,100,200],
'max_depth': [1,3,5,8,10,None],
'min_samples_leaf': [3,6,10,13,16,20]
}
>>> clf = GridSearchCV(forest, grid_params, cv=5)
>>> clf.fit(train_X, train_y)
>>> best_params = clf.best_params_
>>> forest = RandomForestClassifier(
... n_estimators=best_params['n_estimators'],
... max_depth=best_params['max_depth'],
... min_samples_leaf=best_params['min_samples_leaf'],
... random_state=random_state)
>>> forest.fit(train_X, train_y)
结果
我的软件包至少在这些数据集上与 sklearn 有竞争力。(详细的 Jupyter 笔记本和测试可以在这里找到。)
以下是每个规则集模型击败每个 sklearn 模型的频率比较，按精度评分:
下面是一个回忆对比:
我还比较了它们的紧凑性，通过条件或节点的总数来衡量。
有些领域维特根斯坦做得很好:
- 不平衡类:两种规则集算法都比基于树的方法更好地处理了不平衡类；IREP 和瑞普在精确度和召回率上击败了特里，而且在严重不平衡的数据集上，他们在召回率上都比特里好得多。
- 过拟合:在训练样本和每个特征样本都较少的数据集上，两种规则集算法在精度上都胜过 Tree，RIPPER 胜过 Forest。(优势没有延伸到召回。)
- 紧凑性/可解释性: IREP 和 RIPPER 模型比(现成的)树和(调整的)森林更紧凑。
要考虑的潜在缺点:
- 速度: IREP 和决策树共享相同的时间复杂度——O(an logn)，其中 a 是属性个数，n 是例子。但是 RIPPER 的优化阶段在较大的数据集上可能变得耗时，在 O(模拟 n)上。更具体地说，在我将维特根斯坦的关键部分优化成 C++之前，RIPPER 通常是四个中训练时间最长的。另一方面，IREP 运行速度相当快，即使是在 Python 中。
- 连续特性: sklearn 的 trees 实现了 CART，它使用了比我目前实现的更复杂的离散化算法。目前，对于具有大量连续要素的数据集，您可能会从 sklearn 获得更好的性能，尽管这种情况可能很快就会改变。
- 性能:我通常认为 C5.0 树、随机森林和部分决策树(一种混合的树-规则集方法)在大多数(但不是所有)数据集上比规则集模型表现得更好；对 C4.5 和车树，赢家应该更悬而未决。
与任何机器学习模型一样，您的特定数据和您面临的特定问题决定了这项工作的最佳工具。
规则集学习器是一种机器学习方法，实现起来很有趣，在某些情况下，在您的工具集中包含它会很有用。
我很想听听你的想法，所以请随时通过 LinkedIn 或 Github 联系我！
参考
[1]j . funkrantz 和 G. Widmer，增量减少错误修剪 (1994)，机器学习 1994 年第十一届年会会议录
[2] J .罗斯·昆兰， MDL 与范畴理论(续) (1995)机器学习 1995 年第十二届国际会议论文集
[3] W. 科恩，快速有效规则归纳 (1995)机器学习 1995 年第十二届国际会议论文集
[4] E. Frank 和 I. H. Witten，在没有全局优化的情况下生成精确的规则集 (1998)机器学习 1998 年第十二届国际会议论文集
[5] T .王等。al，用于可解释分类的学习规则集的贝叶斯框架 (2017)《机器学习研究杂志》
[6]路德维希·维特斯坦根，《哲学研究》 (1958)
如何使用 Seaborn 执行探索性数据分析
探索性数据分析 ( EDA )是一种分析数据集以总结其主要特征的方法。它用于理解数据，获得与数据相关的一些上下文，理解变量及其之间的关系，并制定在构建预测模型时可能有用的假设。
所有的数据分析都必须以一些关键问题或目标为导向。在开始任何数据分析任务之前，您应该心中有一个明确的目标。当你的目标允许你理解你的数据和问题时，你就能从你的分析中得到有意义的结果！
在本教程中，我们将学习如何使用数据可视化执行 EDA。具体来说，我们将关注**seaborn**，这是一个构建在matplotlib之上的 Python 库，支持NumPy和pandas。
seaborn使我们能够制作出有吸引力的、信息丰富的统计图表。虽然matplotlib使得任何东西都有可能被可视化，但是让情节在视觉上吸引人通常是困难和乏味的。seaborn通常用于使默认的matplotlib图看起来更好，也引入了一些额外的图类型。
我们将介绍如何进行可视化分析:
- 带直方图的数值变量，
- 带计数图的分类变量，
- 散点图、联合图和配对图中数值变量之间的关系，以及
- 盒须图和复杂条件图中数值变量和分类变量之间的关系。
通过有效地可视化数据集的变量及其关系，数据分析师或数据科学家能够快速了解趋势、异常值和模式。这种理解可用于讲述故事、推动决策和创建预测模型。
这个简短的教程改编自 Next Tech 的完整Python 数据分析课程，其中包括预装 Python、Jupyter 笔记本和seaborn 的浏览器内沙盒环境。您可以免费开始学习这门课程！
Next Tech’s environment.
数据准备
数据准备是任何数据分析的第一步，以确保数据得到清理，并以可分析的形式进行转换。
我们将在埃姆斯住宅数据集上执行 EDA。这个数据集在那些开始学习数据科学和机器学习的人中很受欢迎，因为它包含了爱荷华州埃姆斯市出售的不同房屋的几乎每个特征的数据。这些数据可以用来预测销售价格。
该数据集已经清理完毕，可以进行分析。我们要做的就是过滤一些变量来简化我们的任务。让我们从将数据作为pandas数据帧读取开始:
This image only shows the info for the first five columns in the dataset.
如果您在 Next Tech 已经导入了数据集的沙箱中运行这段代码，或者在 Jupyter 笔记本中运行这段代码，您会看到有 1，460 个观察值和 81 列。每一列代表数据帧中的一个变量。我们可以从每一列的数据类型看出它是什么类型的变量。
我们将只处理一些变量——让我们将它们的名字过滤并存储在两个名为numerical和categorical的列表中，然后重新定义我们的housing数据帧，只包含这些变量:
Out: (1460, 14)
从housing.shape中，我们可以看到我们的数据框架现在只有 14 列。让我们开始一些分析吧！
分析数字变量
我们的 EDA 目标将是理解这个数据集中的变量如何与房子的销售价格相关联。
在此之前，我们需要先了解我们的变量。让我们从数字变量开始，特别是我们的目标变量SalePrice。
数值变量就是那些值是数字的变量。当我们有数值变量时，我们要做的第一件事是理解变量可以取什么值，以及分布和离差。这可以通过直方图来实现:
Distribution of the SalePrice variable.
注意，由于一个内部笑话，库seaborn被导入为sns。
只需一种方法sns.set()，我们就可以设计图形的样式、改变颜色、增加字体大小以提高可读性，以及改变图形大小。
我们使用distplot在seaborn中绘制直方图。默认情况下，这将绘制一个带有核密度估计(KDE)的直方图。你可以试着改变参数kde=True看看这是什么样子。
看一下柱状图，我们可以看到很少有房子的价格低于100,000，大多数房子在100,000和200,000之间出售，很少有房子的价格高于400,000。
如果我们想为所有的数字变量创建直方图，pandas提供了最简单的解决方案:
Distributions for each of our numerical variables.
从这个可视化中，我们获得了很多信息。我们可以看到1stFlrSF(一楼面积)严重向右倾斜，大多数房子没有二楼，有 3 个BedroomAbvGr(地上卧室)。大多数房屋以 5 的OverallCond和 5 或更高的OverallQual价格出售。视觉效果更加难以解读——但是我们可以看出，在建模之前，可能需要移除一个或多个异常值。
请注意，该图保持了我们之前使用seaborn设置的样式。
分析分类变量
分类变量是那些值被标记为类别的变量。使用条形图可以最好地理解分类变量的值、分布和离散度。我们来分析一下SaleCondition变量。seaborn为我们提供了一个非常简单的方法来显示每个类别中的观察值计数:countplot。
The bars in this plot represent the number of houses for each condition of sale.
从可视化中，我们很容易看到，大多数房屋是在Normal条件下出售的，极少数是在AjdLand(相邻土地购买)、Alloca(分配:两个有单独契约的关联财产)和Family(家庭成员之间的出售)条件下出售的。
为了可视化我们数据集中的所有分类变量，就像我们对数字变量所做的那样，我们可以循环通过pandas系列来创建支线剧情。
使用plt.subplots，我们可以创建一个 2 行 4 列的网格图形。然后我们迭代每个分类变量来创建一个带有seaborn的countplot:
Countplots for each of our categorical variables.
第二个for循环简单地获取每个 x -tick 标签，并将其旋转 90 度，以使文本更好地适合绘图(如果您想知道文本不旋转时的样子，可以删除这两行)。
就像我们的数字变量直方图一样，我们可以从这个视觉中收集很多信息——大多数房子都有RL(住宅低密度)分区分类，有Regular地块形状，还有CentralAir。我们还可以看到，在夏季的几个月里，房屋销售更加频繁，大多数房屋是在NAmes(北艾姆斯)附近售出的，2010 年的销售有所下降。
然而，如果我们进一步考察YrSold变量，我们可以看到这种“下降”实际上是因为只收集了截至 7 月的数据。
正如您所看到的，对变量及其值的彻底探索非常重要——如果我们在 2010 年销售额下降的假设下建立一个模型来预测销售价格，该模型可能会非常不准确。
既然我们已经探索了数字和分类变量，让我们看看这些变量之间的关系——更重要的是，这些变量如何影响我们的目标变量，SalePrice！
分析数值变量之间的关系
绘制变量之间的关系可以让我们很容易地获得对模式和相关性的直观理解。
散点图通常用于可视化两个数值变量之间的关系。创建散点图的seaborn方法非常简单:
Relationship between 1stFlrSF and SalePrice.
从散点图中，我们可以看到房屋的1stFlrSF和房屋的SalePrice之间存在正相关关系。换句话说，房子的一楼越大，可能的售价就越高。
您还可以看到默认情况下为我们添加了轴标签，并且标记会自动勾勒出来以使它们更清晰——这与matplotlib相反，在matplotlib中这些标签不是默认的。
seaborn还为我们提供了一个名为jointplot的好函数，它会给你一个散点图，显示两个变量之间的关系以及每个变量在边缘的直方图——也称为边缘图。
Jointplot showing relationship between 1stFlrSF and SalePrice and their individual distributions.
你不仅可以看到两个变量之间的关系，还可以看到它们各自是如何分布的。
分析数字变量和分类变量之间的关系
盒须图通常用于可视化数值变量和分类变量之间的关系，而复杂条件图用于可视化条件关系。
让我们从用seaborn的boxplot方法创建盒须图开始:
Box-and-whisker plots for each of our categorical variables and their relationships with SalePrice.
在这里，我们已经遍历了每个子图，以产生所有分类变量和SalePrice之间的可视化。
我们可以看到，与其他分区分类相比，具有FV(流动村庄住宅)分区分类的房屋具有更高的平均SalePrice，具有CentralAir的房屋以及具有Partial(上次评估时房屋未完工)SaleCondition的房屋也是如此。我们还可以看到，不同LotShapes的房子之间，或者MoSold和YrSold之间，平均SalePrice差异很小。
让我们仔细看看Neighborhood变量。我们看到，不同的邻域肯定有不同的分布，但可视化有点难以破译。让我们使用额外的参数order按照最便宜的邻域到最贵的邻域(按照中间价格)对箱线图进行排序。
Sorted box-and-whisker plot showing relationship between Neighborhood and SalePrice.
在上面的代码片段中，我们按照中间价格对我们的邻居进行了排序，并将其存储在sorted_nb中。然后，我们将这个邻域名称列表传递给order参数，以创建一个排序的盒子图。
这个数字给了我们很多信息。我们可以看到，在最便宜的社区，房子的售价中值约为 10 万美元，而在最贵的社区，房子的售价约为 30 万美元。我们还可以看到，对于一些邻近地区，价格之间的离散度非常低，这意味着所有价格彼此接近。然而，在最昂贵的街区NridgHt，我们看到一个大盒子——价格分布有很大的差异。
最后，seaborn还允许我们创建显示条件关系的图。例如，如果我们对Neighborhood进行调节，使用FacetGrid函数，我们可以看到OverallQual和SalePrice变量之间的散点图:
This image only shows the first 12 plots. There are actually 25 plots — one for each neighborhood.
对于每个单独的邻域，我们可以看到OverallQual和SalePrice之间的关系。
我们还向(可选)hue参数添加了另一个分类变量CentralAir——橙色点对应于没有CentralAir的房屋。正如你所看到的，这些房子往往以较低的价格出售。
FacetGrid方法使得生成复杂的可视化和获取有价值的信息变得非常容易。制作这些可视化效果来快速了解变量关系是一个很好的实践。
我希望你喜欢这个关于探索性数据分析和数据可视化的简短教程seaborn！我讲述了如何创建直方图、计数图、散点图、边际图、盒须图和条件图。
在我们的探索中，我们发现了个别变量中的异常值和趋势，以及变量之间的关系。这些知识可以用来建立一个模型来预测埃姆斯市房屋的SalePrice。例如，由于我们发现了SalePrice与变量CentralAir、1stFlrSf、SaleCondition和Neighborhood之间的相关性，我们可以从使用这些变量的简单模型开始。
如果您有兴趣了解如何做到这一点以及更多，我们在 Next Tech 提供了完整的Python 数据分析课程。从这里免费开始！
本课程探索使用NumPy的矢量化运算、使用pandas的 EDA、使用matplotlib的数据可视化、使用seaborn的附加 EDA 和可视化技术、使用SciPy的统计计算以及使用scikit-learn的机器学习。
如何在完全无数据集的情况下执行图像恢复
无学习神经网络图像恢复
深度学习需要大量的数据。这个短语在考虑对其数据应用深度学习方法的人群中变得流行起来。当没有足够“大”的数据时，人们通常会担心，这主要是因为人们普遍认为深度学习只能使用大量数据。这不是真的。
尽管在某些情况下，你确实需要大量的数据，但是有一些网络可以在一张图片上进行训练。最重要的是，在实践中，即使没有大型数据集，网络本身的结构也可以防止深度网络过度拟合。
这篇文章是关于“之前的深度图像”，这是 Dmitry Ulyanov 在 2018 年 CVPR 发表的一篇有趣的论文。本文证明了 CNN 的结构足以解决图像恢复问题。简而言之，这篇论文声称 CNN 包含了自然图像的“知识”。此外，作者将这一主张用于图像恢复任务，如图像去噪、超分辨率、绘画等。
在这篇文章中，我将涉及三件事:首先，图像恢复任务和一些用例的概述。其次，概述“深度图像先验”以及它如何用于图像恢复任务。最后，我们将使用深度图像先验来执行去噪任务——使用神经网络进行图像恢复，但不需要学习 PyTorch 中实现的 GitHub 知识库。
图像恢复
当我们提到图像恢复问题时，我们基本上是指我们有一个降级的图像，我们希望恢复干净的非降级图像。图像降质的原因有很多，主要是图像在传输、形成和存储过程中会发生降质。
图像恢复的任务很多，我们来说三个主要任务:
去噪和一般重建
图像去噪是指试图恢复被附加噪声或压缩等来源污染的图像。
Figure 1 — Building! — (Left) Noisy Image, (Right) Denoised Image
超分辨率
超分辨率的目标是获取低分辨率图像，并对其进行上采样以创建高分辨率版本。
Figure 2 — Fruits! — (Left) Low-Resolution Image, (Right) High-Resolution Image
图像内置
图像补绘是对图像和视频中丢失或退化的部分进行重建的过程。这种技术通常用于从图像中移除不想要的对象或恢复旧照片的损坏部分。下图显示了画中画结果示例。
Figure 3 — (Left) Damaged Image, (Right) Reconstructed Image
当然，还有更多的用例，但是现在让我们试着理解这篇论文的新颖技术。
深度图像先验
1.什么是“先验”？
考虑一下，你需要自己执行超分辨率任务。例如，给你一张低分辨率的图像(下图 4 中左边的图像)，一支笔和一张纸，然后要求你解决它。希望这就是你要画的(下图 4 中的右图)。
Figure 4 — drawing a face from memory — low resolution to high resolution
那么，你是怎么做到的呢？你可能会利用你对世界的了解；什么是脸，脸的结构，即眼睛、鼻子、嘴等的位置。您还可以使用低分辨率图像中的特定信息。因此，我们可以更直观地将先验定义为我们在缺乏信息的情况下的基本信念。例如，在图像的情况下，图像上的先验基本上代表我们认为自然图像应该看起来像什么。
2.已知和明确的前科
如果您希望计算机进行图像恢复，例如图像去噪，您可能会收集大量干净和有噪声的图像数据集，并训练一个深度神经网络，将有噪声的图像作为输入，只获得干净的图像作为输出。因此，可以说网络通过数据集学习先验知识。这种方法叫做事先学习。****
问题是，这种方法需要大量的噪声和干净的图像对。
Figure 5 — Left —noisy images as an input to our network, Right — clean images as the networks output
解决这个任务的另一种方法是执行显式先验或手工先验，其中我们不需要使用除了我们的图像之外的任何附加数据。
我们可以把这个问题看作一个优化问题，以产生期望的干净图像 x ，其中我们的目标是创建一个图像 x ，它既接近于噪声图像【x^，又像干净图像 x 一样“自然”或“清晰”。*
Figure 6 — Image restoration task — Given the observed corrupted image x^ we want to to get the restored image x that is close to our corrupted image but as clear as possible*
例如，我们可以使用用于去噪任务的像素值之间的 l2 距离或者其他任务相关的数据项来测量被标注为数据项【e(x,x^】、** 的“接近度”。**
除了数据项，我们假设有一个函数 R(x) 可以测量图像的“不自然”或“不清晰”。在这种情况下，我们的优化目标的公式将是最大后验分布，以估计来自经验数据的未观察值:
E(x;x^)is the data term which is negative log of the likelihood and R(x) is the image prior term which is negative log of the prior.
数据项将项拉向原始图像，确保图像不会偏离太远。另外右边的项，即 R(x)，将 x 拉向自然图像的方向，(有希望地)降低噪声。所以我们可以把 R(x) 看成一个正则项。如果没有它，优化器将“过度适应”噪声图像。因此，我们定义先验/正则项的方式对于获得好的结果至关重要。
不幸的是，我们没有自然图像的精确先验。传统上，我们使用手工制作的特征来表示先验，但是这些总是包含一定程度的任意性。本文的本质是细胞神经网络可以作为图像的先验；换句话说，CNN 以某种方式“知道”自然图像应该是什么样子，不应该是什么样子。
2.定义先验的网络结构
因此，呈现最小化图像 x 上的函数的任务
Optimize at image space
传统的方法是在图像空间最小化该函数，在该空间进行初始估计，基本上用噪声初始化图像，然后计算该函数相对于x 的梯度，更新我们的权重并重复，直到收敛。
Figure 7 — Visualization of the conventional approach optimizing over image space x
但是我们能换一种方式吗？我们可以说，每个图像 x 都是一个函数的输出，该函数将一个值从不同的空间映射到图像空间。
这里，我们有参数空间θ，并且我们有从参数空间θ到图像 x 的映射，并且不是在图像上优化，而是在θs 上完成优化
Figure 8 — Visualization of the proposed parametric approach optimizing over parameter space θ
在图 8 中，我们可以看到，我们从参数空间中的初始值开始，并且我们立即将其映射到图像空间，计算相对于 g(的梯度。)，接着使用梯度下降进行θ更新，并重复直到收敛。
那么，我们为什么要这么做呢？在图像空间上优化和在参数空间上优化有什么区别？函数 g(.)可以被视为一个超参数，它可以被调整以突出显示我们想要得到的图像。即“自然”图像。如果我们仔细想想，函数 g(θ)实际上定义了一个先验。因此不是优化两个分量的和。我们现在将只优化数据项。
我们可以定义一个网络结构，例如 UNet 或 Resnet，并将θ定义为网络参数。因此，我们将最小化函数表示如下:
其中， z 是随机固定输入图像，θ是随机初始化的权重，将使用梯度下降来更新该权重，以获得期望的输出图像。
明白了吗？这里的变量是θ！与其他类型的网络不同，在其他类型的网络中，固定权重并改变输入以获得不同的输出，在这里，他们固定输出并改变权重以获得不同的输出。这就是他们如何得到映射函数 g(。)到图像空间。
3.为什么使用这种参数化？
你可能会认为使用这种参数化会导致相同的噪声图像，因为我们基本上是过度拟合原始噪声图像。作者在论文中指出，虽然自然图像的优化更快更容易。
Figure 9— Learning curves for the reconstruction task using: a natural image, the same plus i.i.d. noise, the same randomly scrambled, and white noise. Naturally-looking images result in much faster convergence, whereas noise is rejected.
每条曲线代表我们优化图像和噪声以及添加噪声的图像时的损失变化。该图显示，与噪声相比，自然图像的损失收敛得更快。这意味着，如果我们在适当的时机中断训练，我们可以获得一个“自然”的图像。这就是为什么这篇论文将 CNN 视为先验:它(不知何故)偏向于产生自然图像。这允许我们使用 CNN 解码器作为在某些限制下生成自然图像的方法。**
结果
让我们看看一些常见任务的结果。
JPEG 压缩图像的盲复原
深度图像先验可以恢复复杂退化的图像(在这种情况下是 JPEG 压缩)。随着优化过程的进行，深度图像先验允许恢复大部分信号，同时在最终过度拟合输入(在 50K 次迭代时)之前消除光晕和块效应(在 2400 次迭代之后)。
Figure 10— Deep Image prior output for different iterations
图像内嵌
在下图中，in-painting 用于移除覆盖在图像上的文本。深度图像先验结果导致几乎完美的结果，几乎没有伪影。
Figure 11 — in-painting result
图像去噪
深度图像先验成功地恢复了人造和自然模式。
Figure 12 — Image denoising results
PyTorch 中深度图像先验的实现
既然我们已经看到了深度图像先验背后的概念和数学。让我们实现它，并在 PyTorch 中执行去噪任务。整个项目在深度图像先验中可用——使用神经网络进行图像恢复，但不需要学习 GitHub 知识库。
笔记本结构如下:
预处理
前几个单元格与导入库有关，所以要确保正确安装了所有的依赖项。如果在 GitHub 库中列出，你需要安装来执行代码的库列表。此外，这是你选择图像去噪的地方。
在这个例子中，我选择了一张使用杂色噪声生成器 GitHub 知识库应用杂色噪声的图片，如下图所示。
Figure 13— U.S Capitol Building — (Left) Clean image, (Right) Noisy image after adding additive noise
最佳化
下面的代码是神奇的地方，随机初始化的图像 z 在 closure()函数中反复更新。计算数据项(本例中为 MSE ),更新参数空间θ get。
该块将在每次迭代中生成一个图像，这样您就可以跟踪优化过程的进度。当你对结果满意时，停止这个过程并运行下面的代码来创建一个很棒的 gif 来可视化整个过程。
请看下面我们实现的去噪任务的结果。右边是嘈杂的图像，左边是整个复原过程。
太神奇了！
Figure 14 — (Left) —Clean image x restoration result using Deep Image Prior starting from random initialization up to convergence , (Right) — The Noisy image x^*
结论
如果你对源代码感兴趣，可以在我的深度图像先验中找到——用神经网络进行图像恢复，但不需要学习 GitHub 库。
一如既往，如果您有任何问题或意见，请随时在下面留下您的反馈，或者您可以随时通过 LinkedIn 联系我。
在那之前，下一篇文章再见！😄
如何挑选一个成功的人工智能项目，第 1 部分:发现问题和收集数据
这篇文章是“如何挑选一个成功的人工智能项目”系列文章的一部分。第二部分，第三部分。即使你独立地阅读每一部分，它们也能很好地工作。
想象一下，你有 200 个小时的时间来改善你在 ML 的职业前景。这段时间的最佳用途是什么？我在赌做一个投资组合项目。
让我们比较不同的选项:
1.你可以去聚会
2.你可以做教程，遵循模板代码，成为做同样练习的 Github 用户# 2245
3.你可以参加课程或 mooc
选项 1 依赖于意外收获。假设你每 5 次聚会就遇到一个潜在的工作机会(这可能有点乐观！)你很可能会花一年时间去参加聚会，却得不到任何工作机会，如果:
- 你在纸上/网上看起来并不惊艳，而且
- 你当面交流不太好
假设通勤和参加会议需要 5 个小时，你能参加多少次会议？40.这是值得进行的 20 次对话。尽管如此，如果没有一些你可以执行的强有力的信号(比如工作经验，或者你从零开始建立的一个有形的 ML 项目)，你不会将这些随机对话转化为工作邀请。
选项 2 和 3(教程和 MOOCs)不足以将你与大众区分开来。他们是达到能引起招聘经理注意的水平的先决条件。因为当你试图进入一个新领域(鸡和蛋的问题)时，工作经验很难获得，这让你有了我的首选选项，我写这一系列帖子的原因是:向世界展示你可以通过拥有一个人工智能组合项目做什么。
一个大型项目大大超过了其他选项
有一次我问特德·邓宁:“作为一名面试官，你最关心的一件事是什么？”。他的回答:“我只关心一件事:没人告诉你该做什么的时候，你做了什么。”
拥有一个项目组合显示了创造力，这在数据问题中是极其重要的。
数据清理，甚至是模型拟合，都是一些繁重的工作。我们很可能在未来实现自动化。
什么是不可自动化的(以及您想在哪些方面出类拔萃):
发现问题
值得解决的问题(产生商业价值；帮助某人)
并且可以用当前的技术解决
好，所以你想做一个好的人工智能项目
这篇文章的其余部分是我在我创立的公司指导了超过 150 个人工智能项目五年后所学到的。
我把我所知道的分成四类:
发现问题
收集数据
处理数据
使用模型
发现问题
您的项目帮助或取代了什么人工任务？如果这项任务的决策对一个人来说需要超过一秒钟的时间，选择另一个
机器擅长帮助人类完成枯燥的任务。(来自吴恩达的)经验法则是，你想解决人类不到一秒钟的任务。例如，驾驶就是一长串的瞬间决策。这里面很少有深度思考。写小说不是那样的。虽然 NLP 的进展可能看起来我们越来越接近了，但用 AI 写小说并不是一个好项目。
误区:你需要大量的数据。你需要成为谷歌，才能从机器学习中获得价值
在寻找问题的时候，你也在寻找数据。通常你会觉得没有数据来解决你发现的问题。或者没有足够的数据。数据是有价值的，拥有数据的人不公开数据。有大量的公共数据，但没有一个符合你的需要。
当然，你会想到黑客。也许你可以结合不同的来源？也许你自己生成并标注数据？
然后你在网上读到你需要巨大的数据集。你完蛋了。你不能只靠自己给数百万张图片贴标签。
诚然，对于非常复杂的深度学习模型，你需要那些庞大的数据集。21 世纪对 ML 的一个巨大推动是，现在我们有更多的数据和计算能力来训练更复杂的模型。
计算机视觉和 NLP 中的许多革命性成果都来自于拥有大量数据。
这是否意味着，如果你没有太大的计算集群或太字节范围的数据集，你就不能进行高效的机器学习？当然不是。
库包含预训练的模型(像 Inception V3，ResNet，AlexNet)。您可以使用 then 来节省计算时间。
以 YOLO 为例(你只看一次)。任何拥有现成 GPU 的人都可以在视频中进行实时对象检测和分割。太神奇了。有了这个功能你能构思出多少项目？让它成为一个练习:列出 10 个基于 YOLO 的项目。当你读到这篇文章的时候，很可能有一种新的算法可以更好地完成这项任务。这是活着的美好时光。你不需要万亿字节大小的数据集来从机器学习中获得价值。
挑一个通过“眉毛测试”的问题
挑选问题的技巧和解决问题的技巧一样有用。有些问题会抓住你的想象力，有些问题会让你无动于衷。选第一个。
然后还有那些项目，让人觉得你说的是不可能的。你想要一个吗？
你怎么知道你选对了问题？使用“眉毛测试”你想看到对方听到的时候眉毛上扬。如果没有，继续找。
有些问题仅仅是好奇，会耗尽你的资源。不要去找那些。现在使用 ML 有巨大的潜在影响。当你可以让人们的生活变得更容易时，为什么要花时间创建一个从克林贡语到多斯拉克语(两种都是发明的语言)的翻译算法？
在 AI Deep Dive 和数据科学务虚会上，我们相信，因为有大量的“好问题”，所以没有借口去挑选一个没有通过眉毛测试的问题。发现一个好的问题是需要时间的。你应该花多长时间？为了通过眉毛测试。
如果你周围的人以前发现了一个好问题，这会有所帮助。有时候，那些在 ML 领域知识很深的人并不像你想象的那样有用。
你在卖 AI 的价值。当你做“眉毛测试”项目时，你不仅帮助了有这个问题的人(永远记住他们),也帮助了你的数据科学家同事。你的项目越令人印象深刻，公众就会越欣赏人工智能对社会的变革性。你为这个领域的其他人创造的机会越多。
你只需要知道一个好主意的大概
一位参与者来找我，说他要迟到了，无法接受一个想法，他已经用尽了所有的可能性。他一无所有。
“好吧，让我们看看你热衷于什么。你身上有什么活力？”
“嗯，……我讨厌浪费。”
所以我们用谷歌搜索了“垃圾机器学习”没有太明显，也没有太令人兴奋的事情发生。经过进一步的搜索，我们发现了一个斯坦福大学的垃圾分类项目。学生们有一个垃圾数据集，被痛苦地贴上标签。不过，这并不完全是一个通过“眉毛测试”的想法。
"如果我们不把垃圾分类，而是建造一些可以收集垃圾的东西，会怎么样？"(重复这个想法)
"你是说自动运转的东西？"
“是的，一辆自动驾驶的玩具车。08 批中有一个项目就是这样做的。这辆车在赛道上跑了几圈。你必须修改它来识别垃圾，靠近它，并把它拣出来。”
“听起来太神奇了！”(眉毛测试通过)
随着时间的推移，这个大概的想法从一般的垃圾演变成捡烟头，这对环境很糟糕。随着时间的推移，关于如何捡烟头的细节得到了改进:用针刺它们，而不是试图用机械臂抓住它们。我们将在本系列的后面更多地讨论这个项目。
挑一个让你感动的问题。如果什么都不做，那就用“水坑”来倾听能打动人的问题
如果你有你想要解决的问题，你就有很大的优势。你明白这种需要。您可以构建解决方案，并通过将它应用到自己身上来了解它的效果。你可以区分“有好处”和“痛点”在这一点上，我们所做的和创业公司创始人、产品经理所做的并没有什么不同。
你手中握着最接近捷径的东西:你自己有问题。你会节省时间，但不会走弯路。你会敏锐地感觉到要建造什么。
2014 年，我创建了一家公司，但最终没能为电子商务商店做顾客终身价值(CLV)预测。不过，作为一名顾问，CLV 预测的产品是我可以提供给自己的。所以我成了一名“CLV 顾问”我的一个客户雇佣了一名数据科学家，他们全职雇佣了我，所以我神奇地过渡到了数据科学领域。
许多其他人有同样的问题:他们有技术技能，也许是博士，他们想成为数据科学家，但他们不知道如何做。请记住，这是 2014 年，在网络开始沸腾之前，关于如何成为数据科学家的建议。我建立了一个帮助他人解决这个问题的企业，在过去的五年里，它一直运转良好。
我很清楚问题是什么；信息太多，指引不清，面试官不知道如何识别人才。每一步，我都觉得我知道自己在做什么；一种无比珍贵的感情。过渡到数据科学是一个极好的问题；5 年后，人们仍然在为之奋斗。
我不打高尔夫球。如果我想为高尔夫球手打造一款产品，我会完全迷失。我会构建没人需要的功能；我会错过痛点。即使我进行采访并倾听市场，我也会比一个高尔夫球手处于劣势。
因此，我对选择投资组合项目的建议是:选择一个你非常了解的问题。如果是让你感动的问题就更好了。如果你因为自杀失去了三个朋友，建立一些东西来防止自杀。在这种情况下，你自己没有问题，但是你有强烈的动力去解决它。
如果你没有任何问题呢？你一直在同一个行业(比如石油和天然气)，所有有价值的问题都会得到解决！
我不相信你。没有哪个行业成熟到可以解决所有问题。但是，好吧，你不能想出一些让你感动的事情，一些你有的问题。
然后观察别人有什么问题。一大群人。他们倾向于聚集在公共场所，抱怨他们的问题；每当你看到人们抱怨某事时，把它变成一个做项目的机会。
哪些公共空间？我称这些为“水坑”。在网上，你可以有默默无闻的论坛，但 Reddit 和 twitter 是最容易的。只是坐在那里‘听’人们讨论问题。了解它的每一个细节。这是一个真正的问题，还是一个“值得拥有”的问题？
例如，你可能会加入一个游戏子编辑，看看游戏玩家是否关心在视频游戏中拥有更强的人工智能。或者他们是否关心虚拟现实。这些想法太抽象了，不可能是好的项目想法，但是你明白我的意思了。
收集数据
集成不同的数据源
通常，公司太专注于从他们拥有的数据中获取价值，他们忘记了他们可以使用不在公司内部但公开可用的数据来增加价值。
有大量的开放存取数据。和用于频繁变化的数据的 API。没有理由不使用多个数据源。通过集成 API，可以解决一个更有趣的问题(之前不太明显的问题)。
如需 API 集合，请查看https://www.programmableweb.com/.
当您添加一个新的数据源时，用单一数据源看似不可能解决的问题变得可以解决。枯燥的项目变得生动起来。如果你设法找到一个显示更多价值的转折，吃力不讨好的任务就会变成一种乐趣。
当使用多个数据源时，您必须使用一个共享键(一个在两个数据集中都存在的列)将它们连接在一起。)不能合并没有共享键的数据源，这往往会阻碍许多想法的实现。
不要收集或重复使用数据，而是生成自己的数据
你不需要找到数据，或者拥有它。多亏了预先训练的模型(见后面关于它们的部分)，你不需要那么多数据，这意味着你可以自己产生它。去掉“我不太/任何数据”这个障碍，打开了你想解决问题的空间。
为了产生原始数据，我发现了一个大窍门:使用硬件。传感器很便宜，它们给你你自己的数据。
京东的上海履行中心使用自动化仓库机器人每天组织、挑选和运送 20 万份订单。4 名工人负责维护设施。JD.com 的仓库数量和面积同比增长 45%。人工智能也影响制造业。批量生产比以往任何时候都更容易，这意味着市场上有更多的硬件“玩具”。像显微镜、分光镜这样你永远也不会认为买得起的东西正在进入大众消费市场，而且非常容易被破解。这些都是很棒的数据来源！
因为深圳，Kickstarter 等。硬件的发展速度比以前快得多。它永远不会像软件一样快速迭代，但我们正在达到这一步。你查过阿里快递上有什么吗？不到 100 美元就能买到多种传感器。将其中一个安装到运行你的代码的手机上，你就有了一台便携式的专用机器。
例如，你可以买一个显微镜，在没有人类医生的情况下用它来检测疟疾。在手机上运行的深度学习已经好到可以计数血液上的寄生虫了。
阿里快递充满了你可以附加到手机上的廉价硬件。你可以混合使用手机(运行 ML 代码)和
例如:我们的疟疾显微镜。
Eduardo, AIscope’s founder, after reaching 1000x the first time
疟疾每年导致大约 40 万人死亡，其中大多数是儿童。它是可以治愈的，但检测它并不简单，它发生在世界上医院和医生不太方便的地方。疟原虫挺大的，简单的显微镜就能看出来；标准的诊断方法包括医生清点它们。
事实证明，你可以将 USB 显微镜连接到手机上，并在手机上运行 DL 代码，以与人类相当的精度计算寄生虫。DSR 校友 Eduardo Peire 从公共疟疾数据集开始。虽然很小，但这足以向人们展示价值，他的众筹活动让他有足够的资金飞往亚马逊收集更多样本。你可以在这里关注他们的进展:http://aiscope.net。
再举一个例子，你可以买一个分光镜，它可以指向任何材料，并告诉你它的成分。它小到可以连接到手机上作为手持扫描仪。你能检测出食物中微量的花生吗？是啊！这就是现实生活中人们遇到的问题的解决方案。如果你对花生过敏，这将给你带来一定的生活质量。
现在传感器很便宜，它们会帮助你获得独特的数据。你可以把手机变成显微镜、分光镜或任何其他工具。内置摄像头和加速度计也是很好的数据来源。
本系列的下一篇:我所学到的关于处理数据的知识，以及这如何帮助你挑选成功的人工智能项目。
如何挑选一个成功的人工智能项目，第 2 部分:处理数据
这篇文章是“如何挑选一个成功的人工智能项目”系列文章的一部分。第一部分，第三部分。即使你独立地阅读每一部分，它们也能很好地工作。
在这里，我将介绍在选择人工智能项目时与数据相关的技巧和诀窍。我在人工智能深度潜水和数据科学静修中指导了超过 150 人。
您的最小可行数据集比您想象的要小
我们如何才能在 2050 年前将粮食产量翻一番，以养活 90 亿人？两个人拿着智能手机走来走去拍照，这个解决方案能启动吗？
举一个自举数据集的例子，以 Blueriver Inc .为例，他们从事精准农业。通过精确地喷洒在正确的位置，可以减少 90%的除草剂用量。
See & Spray 机器使用深度学习来更准确地识别更多种类的植物，然后当场做出作物管理决策。定制喷嘴设计使得<1-inch spray resolution. They focus on cotton and soybeans.
In September 2017, John Deere acquired Blue River for 300 million.
What was the dataset Blue River started with? Collected by a handful of guys with phones taking pictures while walking down an entire crop field:
Often the amount of data you need for proof of concept is ‘not much’ (thanks to pretrained models!).
You can collect and label the data yourself, with tiny, tiny resources. 我指导的投资组合项目中可能有 50%是从不存在的数据开始的，而团队生成了这些数据。fast.ai 的创始人杰瑞米·霍华德也坚定地打破了“你需要谷歌大小的数据集”才能从人工智能中获得价值的神话。
多么好的机会；现在活着是令人兴奋的，有这么多问题可以用现成的技术解决。一个农业机器人可以处理移动摄像机数据开辟了一条新的道路。下次你想出人工智能项目的时候，把蓝河作为你创造的数据的可能性的参考。
知道“你的最小可行数据集比你想象的要小”会极大地拓展你可以处理的项目范围。
因为有了预训练的模型，你不需要那么多数据
模型动物园是预先训练好的网络的集合。那里的每个网络都为解决类似问题的人节省了大量的时间和数据。例如:
模型动物园的管理员让你的生活轻松多了。随着最近在 ML 方面的成功，研究人员获得了更多的资助，发表了来自享有强大机器和数周计算的学术界的模型。行业领导者经常发布他们的模型，希望吸引人才或抵消竞争对手的优势。
一个数据科学家 80%的时间都在清理数据；另外 20%抱怨清理数据
这是个笑话，但离真相不远。如果你把大部分时间花在数据准备上，不要感到惊讶。
数据增强在图像上运行良好
不要‘手动’做，今天有用于最常见的数据扩充任务(水平和垂直移动、水平和垂直翻转、随机旋转等)的库。这是一个非常标准的预处理步骤。
通过询问公司/个人获得独特的数据
有一支队伍曾经需要鸟鸣。原来有一个鸟类观察者协会有一个巨大的歌曲数据集。他们可以把它给我们的团队，不问任何问题。
公司可能有他们不太关心的数据。其他时候，他们确实关心它们，但如果你提供一些有价值的东西作为交换，比如他们可以使用的预测模型，他们还是会把它们给你。如果你要求的话，政府通常会给你数据。
如果你想不出用更传统的方法来获取数据，试着去问。发送几封电子邮件可能是对你时间的一个很好的利用。如果学者们发表了一篇相关的论文，并且你提出了要求，他们应该分享他们的数据。不一定管用，但值得一试。寻找任何优势的小公司，只要得到一些利益，可能都想和你合伙。
边缘计算(联合学习)，避免隐私问题
这是我们在 2019 年的生活:华为新推出的“super zoom”P30 Pro 智能手机摄像头可以识别远处的人，并将神经网络应用于唇读。计算机视觉系统可以在同一个人改变位置(例如，从地铁站出来)时重新识别他们，这一切都表明大规模监控在技术上日益成熟。隐私是“最重要的”
企业可以接触到越来越多的公民私人数据；监管机构试图保护我们的隐私，并限制对这些数据的访问。隐私保护并非没有副作用:它经常导致科学进步受阻的情况。例如，欧洲的 GDPR 法规似乎是研究人员和公司将机器学习应用于许多有趣问题的严重障碍。与此同时，健康数据等数据集受益于隐私；想象一下，如果你得了一场重病，而雇主因此而不雇用你。
一个解决方案:如果不是将训练数据的语料库带到一个地方来训练模型，而是将模型带到数据生成的任何地方，会怎么样？这被称为联合学习，由谷歌在 2017 年首次提出。
这样，即使你不能立刻访问整个数据集，你仍然可以从中学习。
Andrew Trask, harbinger of federated learning
如果你对这个话题感兴趣，请关注安德鲁·特拉斯克。他有一门关于联合学习的 coursera 课程，还有一个方便的 jupyter 笔记本，上面有一个算出的例子。
为什么这在挑选人工智能项目的对话中很重要？因为如果你的项目使用联合学习，你可能更容易让人们给你数据和使用你的产品。它为不同类别的项目打开了大门。
数据重用和伙伴关系
数据具有极佳的二次价值。
也就是说，通常，您可以找到收集数据的实体没有想到的数据用途。通常通过合作关系，数据的新用途可以产生二次收入流。例如，您可以集成:
-关于欺诈的数据
-来自信用评分的数据，
-来自客户流失的数据，
-关于购买的数据(来自不同来源)
发布这些数据(包含个人数据)的组织可能会使用限制您使用的许可证。您需要检查他们是否明确拥有数据重用的许可，否则最好联系他们并就您项目的许可达成一致。
但是要小心问题:
1.如果你的产品依赖于只有一个合伙人才能产生的数据，你就掌握在他们手中。当你决定结束合作的时候，他们就结束了你的生意。
2.如果不同数据集中唯一的共享变量是一个人，那么数据整合将会非常困难。有助于识别个人身份的数据在世界上的某些地方受到监管。
即使你可以合法地整合这些不同的数据源，记住在大公司里有整个团队致力于整合。永远不要认为这会顺利进行。
使用公共数据并不是唯一的选择。有些人会抱怨，对于每个公开的数据集，已经有很多项目了。很难脱颖而出。也许值得给业内人士发邮件，获取一些别人没有的数据(数据合作)。如果你提供你的模型的结果来交换使用权，一些公司可能会被说服。
做 Kaggle 怎么样？对于投资组合项目来说，这不是一个好主意，因为 1/找到问题和数据的困难已经完成，2/很难从一群竞争者中脱颖而出，这些竞争者可能花了比你更多的时间来拟合模型，并且有更好的表现。
发现数据的二次利用是一项了不起的技能。提出项目想法可以训练这种技能。
使用非结构化数据
几十年来，ML 可以使用的所有数据都是表格的形式。那些作为附件到处乱飞的 excel 文件，那些 SQL 数据库…表格数据是唯一能从 ML 中获益的东西。
自 2010 年以来，这种情况发生了变化。
非结构化数据包括:
- 形象
- 由真实的人写的话，不遵循预先定义的模式，使用充满细微差别的语言。
- 录像
- 音频(包括语音)
- 有时，传感器数据(流)
定义为非结构化的数据每年以 55–65%的速度增长。电子邮件、社交媒体帖子、呼叫中心记录……这些都是非结构化数据集的优秀示例，可以为企业提供价值。
你可能认为‘每个人都知道这一点，为什么要提它’……但根据我的经验，到处都有大公司没有收到备忘录。如果您为其中一家公司工作，并且碰巧发现了他们可能拥有的非结构化数据的用例，那么您就发现了可能会改变职业生涯的东西。
以银行为例。对他们来说，数据意味着来自市场和证券价格的数字信息。例如，现在他们使用夜间光线强度、油罐阴影和停车场汽车数量的卫星图像，可以用来估计经济活动。
根据我的经验，在 AI Deep Dive 和数据科学务虚会上，大多数人选择非结构化数据用于投资组合项目。用这些很容易通过“眉毛测试”。另外，它们在野外大量存在。每个人都可以访问图片、文本…与表格数据如货币交易形成对比。
一个缺点是:非结构化数据可能会引发合规性问题。你永远不知道在一大堆文本中隐藏着什么。这些邮件里有机密信息吗？即使我们试图匿名，用户的个人数据会泄露吗？
你可能还记得美国在线的惨败。2006 年 8 月 4 日，AOL Research 在它的一个网站上发布了一个压缩文本文件，其中包含超过 650，000 个用户在 3 个月的时间内使用的 2000 万个搜索关键词，用于研究目的。8 月 7 日，AOL 删除了他们网站上的搜索数据，但在此之前，这些数据已经被镜像并在互联网上发布。AOL 在报告中没有指明用户；然而，个人身份信息出现在许多查询中，给数据集中的用户带来了隐私噩梦。
—
给你。我学到的关于挑选一个好项目的事情与收集和清理数据有关。
在本系列的最后一部分，我将讲述我在模型构建方面所学到的影响你如何选择人工智能项目的知识。
如何挑选一个成功的人工智能项目，第 3 部分:使用模型
这篇文章是“如何挑选一个成功的人工智能项目”系列文章的一部分。第一部分，第二部分。即使你独立地阅读每一部分，它们也能很好地工作。
在这里，我将讲述我在与模型打交道中所学到的东西，以及这对选择一个将会成功的人工智能项目有多么重要。我在人工智能深度潜水和数据科学静修中指导了超过 165 人。
没什么理论
如果你问 meetup 主持人“你是如何选择你的架构的？”最有可能的答案是类似于“我从博客帖子或论文中复制了它，然后进行了调整。”几乎没有指导如何选择架构的理论。该领域似乎处于中世纪学徒阶段，学徒们复制大师的作品。尽管这个领域每年产生 1000 篇论文，但理论方面的文章很少。从业者产生“经验法则”来挑选架构和训练模型。一个很好的例子是吴恩达的书《机器学习的渴望》。'
这本书充满了我们所拥有的最接近“理论”的东西，用来挑选架构和微调模型。
你需要有一个黄金标准
你的模型必须改进一个重要的 KPI。这意味着有一些可观察的、可测量的东西，模型比基线做得更好(这通常意味着根本没有模型)。
监督学习比无监督学习更好，因为你可以证明你的模型做了什么。
如果你使用聚类分析，你的老板总是会说‘你给我看 3 个聚类，为什么不是 5 个呢？’我想有 5 个。这个没有正确答案。受监督的模型有明确的性能指标，而且经常可以“用眼睛”检查(嘿，你的狗分类器漏掉了这只看起来像蔓越莓蛋糕的狗。)
使用预训练模型
使用迁移学习，你不是从零开始学习过程，而是从解决不同问题时学到的模式开始。这样，你可以利用以前的学习，避免从头开始。
当您根据自己的需要重新调整预训练模型的用途时，首先要删除原始分类器，然后添加一个符合您的目的的新分类器。您可以节省时间(在处理具有数百万参数的大型深度网络时，可以节省数周时间)。
公共领域中有一些模型库，例如:
[## cadene/pretrained-models . py torch
pytorch 的预训练 conv net:NASNet、ResNeXt、ResNet、InceptionV4、InceptionResnetV2、Xception、DPN 等。…
github.com](https://github.com/Cadene/pretrained-models.pytorch)
也试试 https://paperswithcode.com。顾名思义，这是一个可搜索的论文集合，具有公共实现，是一个很好的起点。
如果你已经学过 fast.ai 或者其他很多 ML 课程，你知道的已经足够开始重用预训练模型了。即使您无法找到与您的问题匹配的预训练模型，使用一个几乎不相关的模型通常比从头开始要好。如果您的数据很复杂，并且您的体系结构将超过十几层，情况就更是如此。需要很长时间(而且硬件大！)来培养大架构。
对新型号保持一定的了解是有好处的；跟踪艺术的状态是不必要的，但可以肯定的是，现在比以往任何时候都容易。Twitter 会告诉你是否有什么重要的事情突然出现。如果有人做了一个很棒的演示，Twitter 就会火起来。关注几个经常发这些东西的人就好了。
要浏览 arXiV，试试 arxiv sanity (这有助于捕捉趋势，如果你想成为一名 ML 从业者，我不建议你优先考虑纸质阅读。你可能需要快速行动来交付成果，以至于阅读论文成为你负担不起的奢侈品。)关于演讲视频: https://nips.cc 现在大多数演讲都有视频。处理 NeurIPS 是一项巨大的工作，所以很容易在人们参加后不久阅读他们的摘要。
我指导的大多数项目(至少最近一两年)都使用了迁移学习。想想 10 年前的自己。如果你告诉过去的自己，在未来，任何人都可以下载一个花了几周时间训练的最先进的 ML 模型，你会感到惊讶吗？用它来建造任何你想要的东西？
所有科学学科发表的论文都用 ML，但是模型都不是很强；改善它们是一个快速的胜利
例如，这篇关于如何根据放电模式预测电池寿命的论文发表在最好的科学杂志之一《自然》上。他们的机器学习充其量只是初步的；这实际上是意料之中的，因为作者是电气工程，而不是机器学习。该团队更关注他们在电气工程领域的知识，而不是机器学习部分。在第 18 批数据科学务虚会上，一个非常精明的参与者团队(汉尼斯·诺布洛赫、阿德姆·弗伦克和温迪·张)看到了一个机会:如果我们用更复杂的模型让做出更好的预测会怎么样？他们不仅设法在纸上击败了模型的性能；他们从 Bosch 那里得到了继续工作 6 个月的机会(已支付！无股权)。他们拒绝了这个提议，因为他们毕业后都有更好的计划。
汉尼斯、阿德姆和温迪所做的事情，充满了机会；那么多论文提供了数据和(低)基准。忘记做 Kaggle 比赛；在这些高调的文件中有更多的机会！
避免大猩猩问题
以下内容仅适用于产生用户可见结果的模型。如果您的模型的最终用户是另一台机器(例如，您生产了一个其他机器使用的 API)，那么您可以跳过这一节。
你的 ML 模型为你的用户提供价值，但前提是他们信任结果。你会看到，这种信任是脆弱的。
2015 年，Google photos 使用机器学习来标记图片的内容，并改进搜索。虽然这种算法的准确度让谷歌高管批准它投入生产，但它有“灾难性的错误标注”。你可以想象这对谷歌和机器学习领域来说是一场公关灾难。谷歌发布了一个修复程序，但第一个修复程序并不充分，因此谷歌最终决定不给任何照片添加“大猩猩”标签。
我们从中学到了什么？如果你的问题依赖于一个算法，而这个算法有可能错误地分类一些破坏信任的东西:选择另一个问题。
在我监管的 200 个项目中，当一个团队提出一个有“大猩猩问题”的想法时，我会引导他们远离它。你可以花几个月的时间做那些被大猩猩问题弄得无效的一流 ML 工作。另一个例子是标记“假新闻”:如果你的算法将我的一个意见领袖(一个我盲目信任的人)标记为“假新闻”，你就永远失去了我。
多个模特完成一项任务(例如:捡烟头)
让无人驾驶汽车发挥作用是一系列工程问题。许多不同的 ML 模型协同工作，带你去你想去的地方(原谅这个双关语)。
我们实验室的一个例子:Emily 是一辆自动驾驶的玩具车，它能找到并捡起我们之前提到的烟头，它正在做 3 个子任务:
-识别烟头
-将车开得足够近，让烟头触手可及
-捡烟头(捅)
每个子任务都是一个模型。
请注意，烟头的毒性令人难以置信(一个烟头可以污染 40 升水)，而且很难用扫帚捡起来，因为它们太轻了)。结果，它们在公共区域堆积。一大群这样的机器人可能会造成严重的生态影响。当然，现在还为时尚早，许多实际问题依然存在:人们会为了零件而偷车吗？即使他们不这样做，他们会与会犯很多错误并可能在关键时刻阻挡他们道路的自主机器人分享街道吗？
要学习的一个经验是结合 3 种模式让你解决一个问题，否则无法解决。每一个孤立的问题可能并不那么棘手；事实上，这可能是一个已经解决的问题。
理解上下文
这个模型试图解决什么问题？你认识这些“产品人”？他们认为人们“雇佣”产品和服务来完成工作。你的模特正在做的工作是什么？
这有时可能很明显，但有时不那么明显，这就存在机会。
想象你在一家医院工作。经过深思熟虑后，你的老板决定你的下一个任务是建立一个模型，预测重症监护病人何时会崩溃。这个模型的“工作”是什么？
可以这么看:工作是拯救生命。
换个角度来看:这份工作是优化利用医院的资源。当病人崩溃时，需要很多人努力让她恢复稳定。每一个和这个病人有任何关系的护士和医生都会冲进房间，放弃他们正在做的任何工作。重新完成任务代价高昂。任务切换效率非常低；手拿天文钟多次尝试做 A 和 B 两个任务，AAAABBBBB vs ABABABAB。第二种需要更长的时间，对于几乎所有的任务 A 和 b 来说都是如此。这就是为什么被一个通知分心会对生产力造成如此大的损害。
无论如何，无论你认为你的模式是拯救生命(句号)还是优化配置医院资源(拯救更多生命！)让一切变得不同。
因为不“接近金属”的“老板”不能真正估计什么是适合模型的工作，你将不得不做它。它非常适合数据科学家的分析思维。
— -
这就是你要的。一个完整的手册来挑选一个成功的人工智能项目，分三部分。我希望这是有用的，它可以帮助你解决真实的人在机器学习中遇到的问题。活着从来没有比现在更好的时候了。这么多唾手可得的果实，这么多的杠杆作用都要归功于这种技术，如果我们能设法在人工智能方面多教育几千人，就会有这么多的生产力提高。如果本手册有所帮助，我很乐意收到您的来信，并见证您构建的项目。在 twitter 上发送给我，地址是 @quesada ，我的 DMs 是开放的。
如何绘制时间序列
Photo by Chris Lawton on Unsplash
如果处理得当，处理时间序列可能是探索性数据分析中最有洞察力的部分之一。在这篇文章中，我们将使用来自 Yelp 数据集的签到日志，使用 Pandas 和 Matplotlib 来探索不同时间段的趋势。
数据采集
下载完数据后，我们需要知道使用什么。下面的块显示了基于 Yelp 文档的checkin.json文件中的一个示例条目:
{
// string, 22 character business id, maps to business in business.json
**"business_id": "tnhfDv5Il8EaGSXZGiuQGg"**
// string which is a comma-separated list of timestamps for each checkin, each with format YYYY-MM-DD HH:MM:SS
**"date": "2016-04-26 19:49:16, 2016-08-30 18:36:57, 2016-10-15 02:45:18, 2016-11-18 01:54:50, 2017-04-20 18:39:06, 2017-05-03 17:58:02"**
}
我们可以用带参数orient=columns和Lines=True的熊猫 read_json 方法读取输入文件。
在读取数据时，我们的数据帧看起来像这样:
date列条目是字符串，每个日期由逗号分隔。通过查看它们，我们可以知道格式确实是YYYY-MM-DD HH:MM:SS。
数据争论
为了可读性，我们希望我们的数据帧看起来更像这样:
从 EDA 的角度来看，展开的事件日志更有意义，而 JSON 格式对于内存存储更有意义。
我们可以通过创建一个字典来获得这个结果，其中的键对应于日期，值对应于 business_id。在这里，我们假设日期足够细，因此没有两个日期是相同的。记住 python 文档不允许在一个字典中有重复的键。
实现可以如下进行:
季节性
假设我们想知道所有可用年份的入住总数。我们将以此为契机，通过方法引入可以在群内使用的熊猫群。有关频率别名的更多信息，请参考 pandas 文档。
代码返回了这个简洁的图形:
这是一个好的开始，但是如果我们想潜得更深呢？我们将放大到 2014 年，尽管任何其他年份都可以。选择日期范围很简单:
季节性的第一个指标是看周末，因为数据来自美国和加拿大，周末是周六和周日。请记住，周末因国家而异，例如迪拜的周末是周五和周六。
因此，我们希望检测哪些天是周末，并为其编写一个可定制的函数:
上面的函数返回周末的指数。接下来，为了绘图，我们定义了另一个辅助函数，以在 pyplot axvspan 的帮助下突出显示与这些指数相对应的绘图范围:
最后，我们可以在一个接收数据帧的更大的函数中使用这两个函数:
结果是这个简洁的情节:
上面的情节符合人们周末出门比工作日多的直觉。为了更好地了解这种累积，我们可以使用相同的函数更仔细地查看 2014 年 4 月。
如果我们想要显示一个更细粒度的四月视图呢？由于原始数据帧中的每个条目都是一次签入，因此我们可以按 30 分钟的频率分组，并按如下方式计数:
结果就是下图:
绘制置信区间
我们看到了如何放大时间段来获得季节性的感觉。然而，企业也想知道给定一天的预期签到数量，以及它可能如何变化。例如，我们可能正在求解一个回归方程。
因此，我们需要构建图表来显示一周中某一天的平均签入量和某种置信区间。
我们将使用上一节中定义的checkin_halfhour来提取星期几:
我们的数据帧现在看起来如下:
接下来，我们使用 pandas aggregate 方法构建day_avg数据框架。出于我们的目的，我们将汇总:
- 总和
- 平均
- 标准偏差
下面的代码块为我们做到了这一点:
我们现在有了一个可以用来绘制区间的数据框架:
我们如何定义间隔取决于数据的分布以及窄/大间隔的商业价值。在我们的例子中，我们希望为一周中的每一天生成预期的签入，并获取两个标准偏差内的所有信息。
这样做是为了注意如下所示的day_avg索引中的级别:
结果图揭示了很多签入行为，举例来说，我们展示了周一、周三和周六。
结论
时间序列分析的数量和深度取决于我们试图解决的问题。例如，我们可能想要评估餐馆，或者只在早上 8 点到下午 3 点营业的企业，比如咖啡馆。
EDA 的一个目的是为特征提取做准备。通过上面的练习，我们可以开始考虑一些特性，比如最常见的签到时间，或者说是白天的签到。
如何通过 python 微服务的机器学习为您的产品提供动力。一
文章集是我在euro python 2019给的 工作坊 的总结。
主要动机是展示如何开展数据科学和机器学习项目，以及如何使用面向微服务的架构构建机器学习服务并将其集成到软件产品中。
如果您是从事机器学习项目的软件工程师，或者正在考虑如何改进您的工作流程和模型交付的数据科学家/机器学习工程师/数据工程师，或者试图连接各个点并改进数据产品交付流程的项目经理，或者致力于在您的组织中采用数据科学和机器学习的执行经理，您可能会发现这些文章很有用。
这套物品被分成不同的部分。第一部分涉及主题的背景/介绍。
介绍
首先，让我们定义微服务/面向微服务的软件架构和机器学习。
简而言之，微服务是一种当不同的功能应用部分相互独立并通过网络上的通信协议进行通信时构建软件的方法。每个应用组件都是独立的，并根据服务层协议 SLA 与其他组件进行交互。
机器学习或 ML 是一种跨学科的方法，使用迭代计算技术和应用数学算法从数据中提取模式。它是计算机科学/数据科学的一个子域。机器学习软件产品遵循以下流程:
*train: data + result -> rules
serve: rules + data -> result*
为什么选择微服务和 Python？
首先，你可能会问自己两个合理的问题，为什么是微服务和为什么是 python ？我和几乎所有人一样，会用谷歌来回答这个问题:)
计算机编程语言
Google trends for python, microservices, machine learning, development and infrastructure related topics.
Correlation of google trends for python, microservices, machine learning, development and infrastructure related topics.
正如人们所看到的，随着时间的推移，社区对使用 python、微服务软件开发、机器学习和 DevOps 的兴趣正在增长，这些兴趣领域高度相关。换句话说，当人们搜索词涉及微服务，或机器学习，或 DevOps 话题时，很有可能是在 google 上查询了 python 相关搜索词。
上面的搜索趋势，事实上 python 是 继 C 和 java 之后第三个最流行的 通用编程语言根据 TIOBE 索引(截至 2019 年 7 月)和使用 python 引导和执行项目的相对简单性使其成为机器学习和数据科学的领导者。
微服务
Google trends for software architecture related topics.
至于面向微服务的软件架构，很明显，开发者社区的兴趣倾向于微服务，而不是单片软件架构。
微服务的主要优势之一是软件产品特性服务的独立性，使公司能够进行分布式开发，提高软件的可扩展性。这使得这种开发方法成为将机器学习集成到软件产品中的合理架构选择。
数据科学/机器学习项目
我为什么要烦恼呢？
作为一名高管，这是一个合理的问题，目前我应该为数据科学，还是为我的产品的机器学习而烦恼？
它伴随着以下问题:
- 我的组织准备好实施机器学习服务了吗？
- 我们应该如何改进才能达到准备就绪的程度？
Is my organisation ready for data science/machine learning project?
上图可能有助于回答这些问题。让我们跟随它:
- 首先要回答的问题是，是否已经有了根据业务目标交付结果的高效经典解决方案。 经典 这里指的是软件产品作为“数据+预定义的业务规则=结果”。如果答案是 是 ，你可能应该关注其他问题，或者在为你的产品使用机器学习之前重新定义当前问题的范围。如果答案是 否 ，我们就去点 2。
- 更好地了解你的资源，如果你有，或者你可以负担得起 数据科学专家将机器学习集成到你的产品中。如果答案是 否 ，你应该缩小你的问题的范围，重组你的组织，考虑外包，或者为你的产品使用第三方服务提供商。如果答案是 是 ，我们就去点 3。
- 基础设施呢？我们有需要的东西吗？机器学习是一个计算量非常大且耗时的过程，因此为了降低成本，它需要足够的硬件资源和自动化数据管道。如果答案是 否 ，您应该定义策略来供应、构建和维护基础架构，以构建和托管数据科学解决方案和机器学习模型。如果答案是是，我们转到第 4 点。
- 我们需要所有必要的数据吗？ 是否所有数据都可以访问，它们是否在一个公共存储层？这是一个非常棘手的问题，可能需要许多团队的投入，如数据工程师、、产品、开发人员。但是，澄清这个问题很重要，因为没有数据就没有数据科学:)如果答案是否，那么在数据科学项目执行之前，首要任务是构建一个统一的数据层，其中包含干净且易于访问的数据，并自动收集与您的业务问题相关的数据。如果答案是是，我们就转到第 5 点。
- 我所在组织的工作流程有多灵活？我们能适应解决问题的新方法吗？这是列表中最棘手的问题，它可能没有直接的是或否。但是，如果您的组织无法支持流程和工作自动化的思维模式，您的任何数据科学计划都可能会失败。例如，如果访问数据需要几周时间，获得资源(GPU 机器、工作站等)需要几个月时间。)对于模型培训，无限小时的会议以获得业务部门的足够支持来确定问题的范围，即使很小的积极价值也不太可能通过机器学习为您的公司产生。如果答案是否，你的首要任务应该是重组组织的工作流程，以促进新方法的整合，从而有效地解决你的业务问题。
如果在回答了流程图中的所有问题后，我们到达最后的 是 ，我们就准备好进入机器学习服务的工作点，并将其集成到产品中。让我们从项目流程开始。
数据科学/机器学习项目流程
Data science/machine learning project cycle.
数据科学，或者说机器学习项目最重要的 目标是解决商业问题 。它是一个项目的基础，一切都是围绕要解决的问题来定义的。一旦设定好，数据科学/机器学习项目应该按照周期进行:
- 范围 和项目 目标 由业务干系人、项目经理和数据科学家设定。
2。必然 数据 要准备好。在这里，许多团队都参与其中:
- 产品/项目经理和数据科学家以 定义数据 特性 进行建模。产品人员是连接数据团队和业务的桥梁。
- 数据工程师和开发人员实现新的管道，将所需数据从产品发送到 数据平台 。
- 机器学习和数据工程师在数据平台上设置数据管道。
- 基础设施 到培训和部署由 SRE/DevOps 和机器学习工程师提供的模型。一旦基础设施被设置好，它当然可以被其他 ML 项目重用。
4.一个被循环的步骤本身叫做机器学习 实验 ，它涉及数据科学家和分析师。机器学习项目的模型或产品在项目的这个阶段被定义。
5.步骤 构建模型 将数据科学家和机器学习工程师联系在一起。在项目的这个阶段，正在构建机器学习的产品。
6.周期的最后阶段， 模型部署 涉及机器学习工程师、开发人员和 Ops/SRE/DevOps 工程师。只有完成了这一步，项目才能被利益相关者评估。只有在这个阶段，许多团队工作的结果才能集成到产品中，从而影响业务。如果没有这个阶段，数据科学/机器学习项目就不能被认为是一个项目，因为它永远不会以其他方式与用户交互。所有机器学习项目都应该将部署作为首要目标， API 优先设计是可以遵循的有用方法之一。
一旦机器学习模型/产品交付给用户，项目可以缩小范围，或重新定义以改进现有模型，或新项目可以启动以构建新模型。
金科玉律
当你进行数据科学/机器学习项目时，有一些规则，我会称之为黄金 规则:
- 缺乏问题规范→模型的无限发布时间
如果您错过了项目范围的阶段，无法从利益相关者那里收集需求，并为问题设定明确的业务目标，您就无法交付机器学习解决方案。
- 无基础设施≡不充足，或坏数据→无，或坏模型
如果没有足够的数据平台，你就无法实施任何机器学习解决方案，否则你就不太可能拥有足够高质量的数据来提取系统模式、训练模型和实施你的解决方案来为你的用户服务。
- 精益/迭代开发→成功的 ML 项目≡产品交付
机器学习只能使用精益/迭代开发方法有效地交付:
-首先部署概念验证 PoC，以测试数据管道基础设施并设置模型基线。
-要交付给利益相关方进行解决方案评估的最低可行产品、服务的 MVP。
-最终交付的服务的生产版本，作为具有监控和(自动)模型调整的最终结果。
数据平台
现在，当我们定义机器学习项目流程时，让我们看看如何将机器学习服务集成到产品平台中，以及可以采用什么样的数据平台逻辑架构。
Data platform integration architecture.
上图说明了软件应用的两个主要功能部分，或所谓的 平台 :
- 产品平台，服务通过不同的接口，如 web GUI 或 REST API 端点，相互通信并与第三方服务通信，以向用户/企业客户交付价值。
- 数据平台提供支持内部客户/业务利益相关方的服务，并提供足够的工具，通过强调用户活动来促进决策制定。
数据平台可以分解为三个部分，可能有三个团队参与维护；
- 数据仓库、或 DWH — 连接产品平台和第三方数据提供商的部分，将所有有用的数据整合到一个持久数据存储中，并转换加载的原始数据，以提供预定义的KPI和数据集市，供分析人员、数据科学团队和业务利益相关方进一步使用。 数据工程 团队负责这部分。团队至少有三套 SLA:DWH-to-BI+业务 ，DWH-to-Product，DWH-to-DS+业务 。**
- 分析/商业智能平台、或 BI — 从 DWH 获取数据并向业务利益相关方提供内部分析作为报告解决方案的部分，例如仪表板、描述性和说明性特别分析。 毕 和 数据分析 团队负责这部分。团队至少有两套SLA:BI-to-DWHBI-to-Business。
- 数据科学平台、或 DS — 使用来自 DWH 的数据来构建数据科学和机器学习服务，以改进面向内部客户/业务利益相关方的分析解决方案，或实施新产品功能来提高用户/业务客户的业务价值。 数据科学 和 机器学习 团队负责这部分。团队至少有三套 SLA: DWH 对 DWH ，DS 对产品 ，DS 对业务 。**
机器学习项目交付
数据科学平台的成果可以(至少)以三种方式部署:
- 数据批处理— 数据科学/机器学习服务按计划处理数据批处理，以进行预测，并将结果写回数据存储或分析平台，以供进一步使用。
- 报告— 数据科学/机器学习服务生成并交付报告，例如仪表板、web-hook 消息、SMS 或电子邮件报告。
- 模型即服务 、 MaaS —数据科学/机器学习服务实时交付模型预测结果。它可以集成到产品平台中，以便与其他产品功能服务进行通信，例如与项目搜索或内容交付服务进行通信。
尽管是部署你的机器学习解决方案的最有用的方法之一，MaaS 在网络上几乎没有被涉及。比如只有 5(！)2019 年 4 月至 6 月在towardsdatascience.com上发布的 650 篇 帖子中的模型部署相关文章。
这让我们看到了文章集的主要技术目标，即如何构建 MaaS 的演示。实现这一目标的最佳方式是遵循 边做边学的方法 。敬请阅读本文的动手部分，我将带您完成构建机器学习模型的步骤，并将其作为微服务集成到现有的 web 应用程序中。
摘要
总结一下，要点如下:
- Python和微服务 是将机器学习集成到你的产品中的仪器的合理选择。**
- 数据科学项目只能在您的组织准备好 进行这种战略性转移时执行，例如，如果您有易于访问的通用数据层，遵循灵活的工作流程，并且能够聘请数据科学专家。
- 要成功执行数据科学项目，应满足黄金法则 。首先，你要时刻牢记数据科学/机器学习是关于解决商业问题，而不是关于花哨的技术缺乏项目目标规范容易导致项目失败。第二个，缺乏数据，或缺乏足够的基础设施往往不好，或根本没有数据科学解决方案。第三个，迭代精益方法倾向于成功执行数据科学/机器学习项目。
- 模型即服务 是一种高效、可维护和可扩展的方式，用于向您的用户或内部客户交付机器学习解决方案。
参考
- 关于微服务: https://microservices.io
- 关于机器学习:【https://link.medium.com/C9pSewGfSY】T2
- **API 首次进场:【https://apifriends.com/api-creation/api-first **
- API 优先方法:http://engineering . pivotal . io/post/API-first-for-data-science/
- 数据科学 MVP:https://link.medium.com/PbmMswPfSY
- 精益开发:https://lean kit . com/lean/lean/principles-of-lean-development/
我希望这篇文章对你的发展有用。欢迎留下评论，以便进一步讨论。
如何用 Google Colab 练习 Python 编程？
自动设置、有效获得帮助、协作编程和版本控制。Python 初学者练习中的痛点一站式解决方案。
棘手问题
这学期，我开始在北德克萨斯大学(UNT)教授“INFO 5731:信息系统的计算方法”这门课程，内容包括 Python、自然语言处理和机器学习的基础。
这个班的学生是信息科学和数据科学专业的硕士生和博士生。我仍然像在中国一样使用翻转指令。
在过去的几周里，我们已经完成了 Python 部分的基础。
每周，学生们都被要求阅读两本教科书中指定的章节，并在上课前尝试自己修改的代码。
如果遇到错误，他们还会被要求尝试修复代码。如果他们用尽了所有的方法仍然不能解决问题，他们可以将问题张贴在画布上的讨论板上。
由于大多数学生都是 Python 的新手，他们很容易遇到以下实际问题。
- 不知道如何安装和设置 Python 运行环境；
- 面对问题时，不知道如何有效地找到解决方案；
- 当试图完成小组任务时，不知道如何与他人合作；
- 不知道如何处理版本控制，这可能会导致代码混乱。
上面提到的问题是 Python 初学者的主要痛点。
如果这些问题不能被有效地解决，学生们将会在许多琐碎无用的工作上浪费大量的时间。更有可能的情况是，他们的信心会被击碎，他们会失去学习的动力和兴趣(T2)。
为了帮助他们，我找到了一个适合初学者练习 Python 的工具。在这里，我也想和你分享这个工具。
它叫做谷歌实验室。我在文章《如何用 Python 和递归神经网络预测严重堵车？“给你看源代码，也给你提供深度学习的环境。
在这篇博客文章中，我将介绍如何使用 Google Colab 解决以上痛点，为你的 Python 练习提供帮助。
环境
Python 初学者最常见的问题就是积累学习兴趣不容易，很快就会遇到错误。
事实上，Python 初学者犯的错误总是与配置环境有关。
例如，当试图下载 Anaconda 时，您可能不知道选择哪个版本。
有人在安装后卡住了，因为路径设置错误，他们无法启动 Jupyter 笔记本服务器。
当你试图导入一个包时，会有一个错误信息告诉你“我不知道你要的模块！”
Google Colab 可以帮助你完成所有这些事情。
只要打开一个浏览器(我推荐谷歌 Chrome 或者火狐)，输入以下网址:
[https://colab.research.google.com](https://colab.research.google.com)
您将看到以下网页。
只需选择创建一个新的 Python 3 笔记本。
然后你可以看到一个完全配置好的 Python 运行环境。
就是这么简单。
不要小看这个环境。
尽管您没有完成任何安装过程，但它仍然包含了数据科学分析所需的几乎所有模块。
这些工具包括但不限于 Numpy、Scipy、Pandas 等。甚至深度学习框架，比如 Tensorflow，Keras，Pytorch 也包括在内。
Google Colab 的深度学习环境支持不仅限于软件方面。谷歌慷慨地为你提供 GPU，甚至免费提供云 TPU。
默认情况下，这些云计算硬件不启用。你需要在菜单栏中选择“运行时”，然后“更改运行时类型”。
通过这种方式，您可以看到硬件加速器的选项。
一些示例代码，甚至教科书中的 Python 组件都需要 Python 2.x 环境才能运行。别担心。当您选择创建一个新的笔记本时，您可以指定不同版本的 Python。
如果你足够小心，你可能已经发现你可以在任何时候在“更改运行时类型”标签中更改 Python 版本。
帮助
作为初学者，遇到错误信息和问题是很正常的。
好在 Python 有一个强大的社区，可以帮到你很多。
但如果你尝试过，可能会有一种错觉，认为这些“Python 大师”并不友好，因为你很久以前就发布了问题，但没有人给你任何回复。
其实很可能是因为你问那些问题的方式不对。
想象一下，你描述了一个错误信息，可能有几十个，甚至几百个原因可以导致它。谁能有那种耐心帮你一个一个的考察排除？
你可能会争辩说，有时你也包括代码，甚至是问题的错误信息的截图，但是仍然没有人来帮忙。
这可能是因为你的信息仍然不充分。
比如你在本地安装了什么样的 Python 环境？你导入的模块版本是什么
？当你得到错误信息的时候是在什么环境下？会不会和之前的代码块有关？你的操作系统完全支持你正在使用的框架吗？
这些可能性是无穷无尽的。同样，没有人愿意浪费时间一个一个地检查它们。
然而，在谷歌实验室的帮助下，当你试图提问时，效率可以显著提高，因为潜在的回答者可以很容易地重复你的问题。
你可以通过分享你的笔记本来实现。
如上图所示，你可以点击右上角的分享按钮。
在对话框中，选择权限时需要注意。我的建议是选择“任何有链接的人都可以查看”。
然后，选择“复制链接”，链接将被保存在您的剪贴板。把链接和问题描述放在一起，贴在 Python 的官方论坛或者课程讨论板上。
人们只需要点击链接，他们就可以看到你所有的代码和错误信息，更好的是，他们可以轻松地运行你笔记本的副本。
尽管你们两个可能使用不同的操作系统和/或不同的浏览器，但是由于 Google Colab，你们的 Python 计算环境是完全相同的。
当有人解决了问题，他或她可以通过链接共享完整的笔记本，这样就完成了。
请注意，提问只是获得帮助的方法之一。
在论坛上发帖之前，你最好尝试独立解决问题。如果你拒绝自己考虑，只依靠别人，人们就不会愿意帮助你。
Google Colab 为你提供了一个非常有用的功能来寻找可能的答案。每当你遇到一个错误信息，你可以看到一个“搜索堆栈溢出”按钮。
点击按钮，Google Colab 将使用 Google 搜索引擎在Stackoverflow.com 网站上找到类似的问题和潜在答案。
大多数情况下，你会在前几个链接里找到相应的答案。
在我们的例子中，这次您很幸运，因为答案解释说这个问题与 Python 2 和 3 之间的语法差异有关。
现在你只需要按照说明，稍微修改一下代码(加上括号)，一切都会好的。
合作
你试过和别人一起写代码吗？
在我的课程中，有些作业是小组任务。要求学生分组合作，用 Python 解决问题。
一些学生尝试这样合作:
写一段代码，发给另一个成员。当另一方完成他/她的部分时，新的源代码文件被发送回来。它一直在继续。
这显然是相当低效的。
有更好的方法吗？
当然了。您可以继续使用我们介绍的共享功能。
不过这次在选择权限的时候，给对方“任何有链接的人都可以编辑权限。
我们仍然使用print命令带有“无括号”的问题。但是这一次，除了看到你的问题，其他人也可以直接编辑你的代码。
你的搭档可以创建一个新的代码块，并输入正确的语句。
在您这边，更改将被同步，您会看到这一点。
你伴侣的头像会出现在相应的修改旁边，他(她)也可以选择添加评论。
例如，可以做出如下的注释。
评论也会立即同步到你的笔记本上。
这样，团队协作可以更有效率。
请确保将“编辑”权限仅限于您信任的协作者。
如果你打算向公众展示你的作品，你可以使用 Google Colab 提供的 Github 集成功能。
你可以选择将副本保存在 Github 中。
然后，选择要保存的 Github 项目。
之后，相应的 Github 页面会自动打开，准备预览。
预览可以包含所有文本、图片、代码和输出信息。注意笔记本的顶部，有一个“在 Colab 打开”的链接。
点击它就可以打开 Google Colab 环境，直接在这个 Github repo 上运行笔记本的副本。
版本
当你试图修改你的代码很多次，它可能会导致混乱，事情可能会变得更糟。这个时候，你可能需要一个“时光机”回到以前的副本。
谷歌实验室为你提供了这台机器。
点击菜单中的“修订历史”，可以看到当前笔记本中保存的所有历史版本。
修改时间、进行修改的用户以及
文档的大小等都显示在这里。如果你想回到任何版本，只需点击“恢复”按钮。
此外，您还可以将 Google Colab 笔记本直接下载到.ipynb文件中，并在本地保存一份副本。
一定要仔细选择存储路径，不然以后可能就找不到了。
当学生需要提交作业时，我通常会要求他们提交 Google Colab 共享链接和一个.ipynb文件。
为什么？两者不是一模一样吗？
我会把它作为一项任务留给你去思考。希望你能立刻得到正确答案。
您可以通过在命令行中启动 Jupyter 笔记本服务器来打开.ipynb文件。然而，使用一个叫做interact的很酷的应用程序来直接查看.ipynb文件的内容会更方便。
摘要
在本文中，我介绍了 Google Colab，以帮助 Python 初学者更有效地练习 Python 编程。总之，它可以处理您可能遇到的以下棘手问题:
- 运行环境和软件包的安装；
- 处理错误信息和问题；
- 协作效率低；
- 版本混乱。
在这种情况下，你可以把更多的时间花在练习和理解 Python 上，而不是花在配置上。
我多次向我的学生和读者推荐经典而著名的教科书“艰难地学习 Python”。
它为初学者学习 Python 编程语言提供了一种有效的方法。事实上，你也可以尝试使用其他好的教科书。请记住，您不仅需要阅读内容，还需要仔细地逐行尝试代码。这可能看起来很乏味，但是我可以向你保证“边做边学”是 T2 正确的方法。
Python 编程快乐！
相关博客
如果你对这篇博客文章感兴趣，你可能也想看看下面几篇:
- Python 深度学习，第 0 部分:在谷歌云上设置 fast . ai 1.0
- 使用 Python 和 fast.ai 进行深度学习，第 1 部分:使用预训练模型进行图像分类
- 使用 Python 和 fast.ai 的深度学习，第 2 部分:使用迁移学习的 NLP 分类
- 如何用 Python 和递归神经网络预测严重堵车？
- 如何用云 GPU 加速你的 Python 深度学习？
确认
我要感谢我的硕士生杨晓君帮我把我的中文原版文章翻译成英文。此外，我要感谢我的老朋友杰西·里德，他花了很多时间来校对。没有你们的帮助，我不可能这么快就完成这个博客。
如何预测时间序列第 1 部分
真实世界预测
经典时间序列方法与预测包
时间序列预测与其他监督回归问题有很大不同。我的背景是商业分析，所以我对经典预测方法学(arima、指数平滑状态空间模型、移动平均等)有相当多的了解。在与许多数据科学家交谈时，我发现他们中的许多人对预测时间序列知之甚少，并将其视为其他监督学习问题，收效甚微(通常是因为他们没有设计正确的功能)。
R forecast 库是处理和预测时间序列的最完整和最流行的库之一。虽然我承认 python 在数据科学家中变得越来越流行，但这并不意味着它是万能的最佳语言。R 中的时间序列预测要成熟和常规得多。
本文的目标是逐步完成预测工作流和评估。因此，在这篇博文中，我将把数学最小化。有许多博客文章讨论了这些方法背后的数学原理，我将链接其中几个。在这篇博文中，我想分享一些我从使用预测包预测大量时间序列中学到的东西。在后续的博客文章中，我将介绍 facebook prophet 的工作流和使用监督机器学习算法提前一步预测的工作流。
不是所有用来写这篇文章的代码都会出现在博文中。更多例子的完整代码可以在我的 github 上找到。
时间序列预测与其他监督学习问题有何不同:
- 使用 k 倍随机交叉验证是不符合原则的(因为保持时间顺序很重要)
- 我们正在观察数据范围之外扩展一个趋势
- 流行的机器学习算法(xgboost、线性回归、MLP 神经网络等)如果没有大量的特征工程，通常不会很好地工作
- 对于决策来说，理解点估计的不确定性可能比点估计本身更重要，尤其是在商业环境中
数据—西雅图自行车:
我将尝试预测的时间序列是西雅图市每周记录的自行车道流量。脚本 seatleBike.r 创建了这个数据集(从西雅图开放数据门户收集了 13 个公共数据集，按每周频率进行聚合)。
我将从一个快速的线图开始，来可视化时间序列。
df_day %>%
ggplot(aes(ds, y))+
geom_line()+
labs(x = "Date", y = "Traffic", title = "Seattle Bike Traffic")+
theme_minimal()
观察和重要提示:
- 我们可以看到时间序列有季节性。季节性是指一种周期性模式，在几年内，与日历日、月、季度等相关
- 我们可以看到，时间序列似乎没有趋势。一个趋势是一系列长期向上或向下的方向。
- 夏季的自行车流量似乎比冬季要高得多。我们可以预料到这一点，因为西雅图冬天寒冷多雨。
预测时间序列时，我们通常使用序列的先前值来预测未来值。因为我们使用这些先前的值，所以绘制 y 向量(给定一周内自行车道上的交通量)与先前的 y 向量值的相关性很有用。该图被称为自相关图(自相关，因为它与自身相关)。
ggAcf(df_day %>% convert()) + theme_light() + labs(title = "ACF plot of Seattle Bikes Series")
备注:
- 相关性最强的是最近的值。这是典型的时间序列
- 我们可以看到在 26 周左右有很强的负相关性。鉴于时间序列的季节性，我们应该预料到这一点
- 这与一年前(52 周)的观察结果有很强的相关性，这是意料之中的。
- 我们可以看到，相关性下降了大约 3 或 4 个滞后。经典时间序列模型将学习这种结构，我们可以创建滞后变量，将其纳入我们的机器学习模型。
用季节性朴素模型设置基线:
我们的时间序列似乎没有趋势，但它确实有季节性。当时间序列中存在季节性时(这是大多数真实世界时间序列中的典型情况)，一个好的基线模型是季节性朴素模型。
季节性朴素模型在预测时预测同一季节(去年同一周)的最后一个值。我们可以用预测包中的 snaive()函数来拟合这些模型。我之前说过，我会限制数学，以便放大预测工作流程。这是我将在博文中展示的唯一公式。我选择用公式来介绍预测中常用的符号。我将链接到其他模型背后的公式/数学的更多信息。
source = https://otexts.com/fpp2/simple-methods.html
我在训练集上拟合模型，并在一个持续的测试集上进行预测，以查看模型如何预测它没有看到的数据。
naiv = train %>%
snaive(h=length(test), bootstrap = T, level = 0.89)
naiv %>%
forecast_eval(model_name = "Seaonal Naive")
- 最新的预测看起来相当不错。该预测在测试集(MAE)上平均误差约为 56953.55。对于真实世界数据的简单模型来说，这已经很不错了。
- 预测区间覆盖了大部分点
- 如果数据有趋势，模型的表现会差得多
- 该模型忽略了 5 月和 4 月的大峰值，可以看到这两个峰值远远超过了预测的预测区间
- 预测的不确定性随着时间的推移而增加
- 一个模型必须表现得比这更好才是可行的
另一种评估预测的方法是使用 checkresiduals()函数检查训练集的模型残差。该函数返回 Ljung-Box 检验的检验统计量，这是一种零假设检验，用于确定残差是否为白噪声。我不喜欢零假设测试，所以我只做一次。
residual analysis
Nothing worse than null hypothesis tests
残差分析的另一个问题是强调点估计的准确性，而不是预测区间的准确性。这些测试还附带了一系列现实世界时间序列中通常不会遇到的假设。
auto.arima:
auto.arima()是预测包中最受欢迎的函数之一。尽管它很受欢迎，但我并不喜欢它。根据我的经验，arima 模型最适合月度、季度或年度数据，但如果没有傅立叶项(auto.arima 不使用傅立叶项)，就无法捕捉每周或每日数据的季节性。尽管如此， auto.arima()通常是数据科学家使用的唯一预测函数。
aarim = train %>%
auto.arima() %>%
forecast(h = length(test), level = 0.89)
aarim %>%
forecast_eval(model_name = "Arima")
auto.arima
- auto.arima()函数的性能比仅猜测去年的值(snaive()模型)差
- arima 模型往往不能很好地处理周数据(hynd man 博士写了这个包，所以如果你不相信我，就相信他)
auto.arima 函数选择了带漂移的 SARIMA(1，0，0)(1，1，0)[52]。让我们慢下来解释这个符号。
SARIMA 模型遵循形式(P，D，q)x(P，D，Q)m，ARIMA 模型遵循形式(P，D，Q):
p =自回归项的数量
d =差异数
q =移动平均项数
p =季节性自回归项的数量
d =季节差异数
q =季节性移动平均项的数量
m =频率
漂移=漂移系数或常数(arimas 和 sarimas 都可以包含漂移)
这意味着我们的模型是一个 SARIMA 模型，有一个自回归项，一个季节自回归项和一个季节差异项。该模型没有移动平均或季节性移动平均项。它还有一个漂移系数。我们可以用汇总函数来确认这一点:
Arima model summary
有兴趣了解更多 arima 模型的人可以参考包作者的书或者这个链接。
当用额外的外生回归变量和领域知识创建 arima 模型时，它们往往表现得相当好。当分析师选择只使用 auto.arima 函数时，模型往往表现不佳(尤其是对于周数据)。
指数平滑:
指数平滑方法是一系列相关的模型，使用以前值的指数递减权重来预测时间序列的当前值。这些方法在商业分析和供应链领域非常流行。为了简洁起见，我将使用 ETS 函数，它适合各种指数平滑方法，并选择最佳方法。我强烈推荐你在这里阅读更多关于函数的内容。这篇文章越来越长，所以我不会进一步解释。
ETS = train %>%
ets() %>%
forecast(h = length(test), bootstrap = T, level = 0.89, lamda = 'auto')
ETS %>%
forecast_eval()
ETS model fit
- 基于 ETS 模型的预测分布存在大量不确定性
- 该模型完全不符合季节性，因为它不处理大于 24 的频率
指数平滑模型往往适用于每日数据(如果它没有年度季节性，因此频率可以设置为 7)、每月和每年的数据，但不适用于每周数据。在许多商业情况下，我们需要预测每周数据并理解不确定性。
TBATS:
TBATS 是我使用预测包预测时间序列的常用方法。像预测包中的其他方法一样，它是完全自动的。该模型本身足够灵活，可以适应一系列不同的时间序列，而且适应速度相对较快。
TBATS 是指数平滑方法的扩展，增加了 ARMA 误差和三角项。人们可以写一整篇关于这种方法的博文，所以我会选择链接一些关于这种方法的好文章给那些感兴趣的人，因为完整的解释只会让这篇文章太长。
TBATS = train %>%
tbats()TBATS_for = TBATS %>%
forecast(h = length(test))
TBATS_for %>%
forecast_eval("Tbats")
TBATS forecast
- TBATS 是目前所有方法中表现最好的
- TBATS 在表示预测的不确定性方面做得很好
- 正如软件包作者指出的，TBATS 间隔有时会太宽
让我们放大适合测试集的 TBATS:
我知道字幕是不正确的，预测区间是灰色的。
- 夏季和初秋的不确定性比一年中的其他时间要高得多
- 几个连续的点落在预测区间之外
总结:
- TBATS 是一种灵活、精确的算法，通常优于其他经典方法
- 经典的时间序列方法无法预测大的异常
- 所有提出的模型都使用了自动模型选择程序
要了解更多关于预测的信息，我强烈推荐阅读 Rob Hyndman，这是软件包作者的书。Hyndman 博士还在使用新的寓言包开发这本书的新版本，该包为 tidyverse 带来了预测(要查看它，只需将 URL 中的 2 改为 3)。我还没能让寓言在我的机器上运行。它也可能需要一段时间才能像预测包一样成熟，所以现在我会坚持使用预测包。
西雅图开放数据门户的必要说明:
“此处提供的数据已经过修改，以用于其原始来源，即西雅图市。西雅图市和首席技术官(OCTO)办公室均不对本申请中包含的任何数据的完整性、及时性、准确性或内容做出任何声明；作出任何形式的陈述，包括但不限于对特定用途的准确性或适用性的保证；也不暗示或推断此处提供的信息或数据有任何此类保证。随着修改和更新的完成，数据可能会发生变化。据了解，使用网络订阅源中包含的信息需要自担风险。”
从我的代码中可以清楚地看到对数据集所做的修改。
本文授权:https://creativecommons.org/licenses/by-sa/3.0/
如何预测商业成败
为什么一些小企业会失败，以及如何利用机器学习进行优化以取得成功
Photo by Eaters Collective on Unsplash
创业不是一件小事，有许多费用要考虑，如沉没成本、管理费用和贷款。衡量成功的标准包括但不限于增长、销售收入、客户保持率和资产负债表。
一个企业的生存能力首先取决于一个公理:它保持开放。
对于必须保持生存的企业和期望良好可靠服务的客户来说，这个主题是他们的主要兴趣所在。这在金融领域也很重要，在这一领域，贷款人必须证明发放贷款的正当性，并且可能有法律义务解释申请被拒绝的原因。
因此，我们将这一努力的动机和目的表述如下:我们能否预测一家企业是开张还是关门？生存能力的主要指标是什么？
在本文中，我们将使用 Yelp 数据集来解决这个问题，这是一个关于美国和加拿大当地企业的关系数据集合。它包含大量的综合信息:
- 668.59 万条评论
- 192609商家
- 10 都市圈
- 1223094提示
因此，Yelp 数据集是一个很好的案例研究，它研究了恰当设计的功能如何与机器学习模型相结合，可以预测企业在资产负债表等传统方法之外的成功。
在下一部分中，我们将呈现给定数据集的每个部分，并从中提取要素:
- business:(business . JSON)该数据集包含与业务相关的数据，包括位置数据、餐馆属性和美食类别。
- Reviews: (Review.json)这个数据集包含完整的评论文本数据，包括撰写评论的 user_id 和撰写评论的 business_id。
- Checkin: (Checkin.json)这个数据集包含企业的登记信息。
商业
特征工程
business.json文件包含业务数据，包括位置数据、属性和类别。下面的代码片段显示了它的配置:
{
// string, 22 character unique string business id
**"business_id": "tnhfDv5Il8EaGSXZGiuQGg",**
// string, the business's name
**"name": "Garaje",**
// string, the full address of the business
**"address": "475 3rd St",**
// string, the city
**"city": "San Francisco",**
// string, 2 character state code, if applicable
**"state": "CA",**
// string, the postal code
**"postal code": "94107",**
// float, latitude
**"latitude": 37.7817529521,**
// float, longitude
**"longitude": -122.39612197,**
// float, star rating, rounded to half-stars
**"stars": 4.5,**
// integer, number of reviews
**"review_count": 1198,**
// integer, 0 or 1 for closed or open, respectively
**"is_open": 1,**
// object, business attributes to values. note: some attribute values might be objects
**"attributes": {
"RestaurantsTakeOut": true,
"BusinessParking": {
"garage": false,
"street": true,
"validated": false,
"lot": false,
"valet": false
},
},**
// an array of strings of business categories
**"categories": [
"Mexican",
"Burgers",
"Gastropubs"
],**
// an object of key day to value hours, hours are using a 24hr clock
**"hours": {
"Monday": "10:00-21:00",
"Tuesday": "10:00-21:00",
"Friday": "10:00-21:00",
"Wednesday": "10:00-21:00",
"Thursday": "10:00-21:00",
"Sunday": "11:00-18:00",
"Saturday": "10:00-21:00"
}**
}
目标变量是is_open，如 0 表示关闭，1 表示打开。
作为第一种方法，我们需要将嵌套的属性分解成相应的值。例如在attributes特性中，我们有一个RestaurantsTakeOut的二进制编码，我们需要进一步扩展BusinessParking特性。
在attributes特性中，我们可以设计分类变量，例如数值。例如,NoiseLevel是一个带有值的字符串输入:
- 非常大声
- 声音大
- 平均值
- 安静
- 楠
因此，可以用数值对这些字符串特征进行编码，例如表示噪声级别的标度。我们可以对AgesAllowed、Alcohol、RestaurantsAttire等属性重复同样的练习。
此外，categories特性包含一个不互斥的字符串列表。一家企业有可能被归入墨西哥式、汉堡式和腹肌式餐馆。因此，这些被编码为二进制特征。
在一个简单的自然语言处理案例中，我们注意到大约 1000 个业务被命名为Starbucks，大约 800 个被命名为McDonalds。因此，我们定义二进制chain特征，如 1 表示该业务是链的一部分，并且一个名称必须至少出现 5 次才能被认为是链。
我们使用latitude和longitude特征，以便从 datataset 中提取大地测量特征。我们使用最小包围盒方法来查询给定半径内的所有其他企业。在这个项目中，我们将半径设置为 2 公里，作为客户愿意在企业之间步行的合理距离。
从大地测量数据中，我们可以定义诸如density之类的特征，这是所查询的圆中的业务量。此外，我们可以通过应用 Z 分数标准化将每个企业与其周围环境进行比较。例如，企业价格的 Z 值是价格和群体平均值之间的差值，除以标准差。
借助外部资源推动业务发展
对于要素工程，在数据集之外提取信息可能会有所帮助。每个企业都有其相应的美国和加拿大格式的邮政编码。
也就是说，美国国税局发布个人收入统计数据，加拿大统计局发布收入数据。虽然不具体到业务本身，当地的收入可以发挥生存能力的作用。
为了保护公民的隐私，美国国税局不公布确切的收入数字，而是数据是绝对的。例如，3的值表示收入在50，000-75000 美元和5100，000-200，000 美元之间。
因此，我们可以将每个邮政编码与相应的家庭收入中值进行匹配，确保按照 IRS 方法将加拿大元转换为美国货币和宁滨加拿大收入数据。
复习
review.json文件包含完整的评论文本数据，包括撰写评论的用户标识和撰写评论的企业标识。
下面是展示这些属性的一个片段:
{
// string, 22 character unique review id
**"review_id": "zdSx_SD6obEhz9VrW9uAWA",**
// string, 22 character unique user id, maps to the user in user.json
**"user_id": "Ha3iJu77CxlrFm-vQRs_8g",**
// string, 22 character business id, maps to business in business.json
**"business_id": "tnhfDv5Il8EaGSXZGiuQGg",**
// integer, star rating
**"stars": 4,**
// string, date formatted YYYY-MM-DD
**"date": "2016-03-09",**
// string, the review itself
**"text": "Great place to hang out after work: the prices are decent, and the ambience is fun. It's a bit loud, but very lively. The staff is friendly, and the food is good. They have a good selection of drinks.",**
// integer, number of useful votes received
**"useful": 0,**
// integer, number of funny votes received
**"funny": 0,**
// integer, number of cool votes received
**"cool": 0**
}
我们可以通过business_id进行聚合，然后完成特性工程。然而，假设每个印象都有一个与之相关的时间戳，我们可以直接测量与给定位置相关的变化。
用户星级评定的平均值返回平均业务得分。按年份分组可以帮助我们了解业务特性是如何随年份变化的。他们是在进步还是落后了？
了解企业
首先要问的是那些~ 19.2 万的商家都在哪里？根据以下情节:维加斯宝贝！
与上图相反，大多数企业位于亚利桑那州，如下图所示:
此外，我们可以看到大多数企业的评级在 3.0 到 4.5 之间，因此平均值约为 3.5。
最后，我们希望通过按目标变量绘制计数和色调来比较不同业务类型的正/负标签的分布。餐馆占企业的绝大部分，关门企业的比例最高。
签入数据
checkin.json文件列出了所有可用的企业登记信息:
{
// string, 22 character business id, maps to business in business.json
**"business_id": "tnhfDv5Il8EaGSXZGiuQGg"**
// string which is a comma-separated list of timestamps for each checkin, each with format YYYY-MM-DD HH:MM:SS
**"date": "2016-04-26 19:49:16, 2016-08-30 18:36:57, 2016-10-15 02:45:18, 2016-11-18 01:54:50, 2017-04-20 18:39:06, 2017-05-03 17:58:02"**
}
作为第一步，我们可以探索签入的趋势，如下图所示，其中 y 轴对应于所有年份的总签入数，并以 30 分钟为间隔进行分割。例如，这个图告诉我们，从周六到周日晚上的平均签入高峰发生在晚上 8 点左右，同时提供了一个置信区间。
从更宏观的角度来看，我们也可以探索 12 月份的入住情况，其中包含了很多季节性因素。在下面的图中，高光对应的是周末。
从这些数据中，我们可以提取出平均每月的签入量。此外，我们将span定义为第一次和最后一次登记之间的时间(以秒为单位):一家企业开业的时间越长，它保持营业的可能性就越大(参见日出问题)。
模型选择和评分
我们试图解决的问题属于监督学习。鉴于目标变量的严重不平衡性质，我们忽略了基于准确性的评分，并考虑以下指标:
在第一轮中，我们应用了几种监督学习算法。表现最好的人按升序排列:
在接下来的几节中，我们将更详细地阐述结合在一起产生可靠结果的各个技术。
分裂
特征工程的目的是获得可以直接输入算法的数据的数字表示。第一步是在训练集和测试集之间拆分数据。
此外，我们应用最小-最大特征缩放，其仅适用于训练数据，以避免模型泄漏。然后使用该拟合来转换训练和测试数据。
网格搜索交叉验证
这种也被称为 GridSearchCV 的方法很受数据科学家的欢迎，因为它非常全面。通过结合交叉验证和网格搜索，我们获得调整后的超参数。
特征相关性
某些算法，如基于树的模型，在高维空间中表现不佳。拥有太多的功能也可能会产生噪音。
用于检测噪声特征的第一种方法是通过逻辑回归的 L1 特征选择，其给无用特征赋予 0 的权重。第二种方法是使用 featexp 包来识别噪声特征。
最终，最容易理解的方法是特征重要性排列。在这种情况下，我们置换一个给定的特征并计算模型预测误差的变化。如果移动特征会显著改变模型上的误差，则该特征是“重要的”，如果误差保持不变，则该特征是“不重要的”。
应对失衡
最后，该项目的最有影响的方面是处理不平衡的目标变量。回想一下，只有大约 20%的企业被列为关闭。
实际上，这意味着少数类被多数类淹没，使得算法没有足够的少数观察来做出决定，或者少数类被多数淹没。
解决这个问题的一个方法是通过欠采样:保持少数类不变，从多数类中随机抽取等量的观察值。相反，过采样稍微好一点:复制少数类，直到数据集平衡。
在任一采样选择中，仅将它应用于训练数据是至关重要的。对测试数据进行采样是一个常见的陷阱，因为这等同于曲解现实。
模型性能
下表总结了几种型号的性能。总的来说，所有模型都更擅长预测开放的企业(第 1 类)，而不是关闭的企业(第 0 类)。
总的来说，我们可以看到基于树的模型往往在 AUC 徘徊在 0.75 时表现最佳。
也就是说，模型的可解释性与模型性能同等重要，如果不是更重要的话。因此，我们必须更深入地研究每个模型，以了解驱动我们决策的主要特征是什么。
下表显示了这些型号的 5 个最重要的功能。
有趣的是，在逻辑回归等同一模型中，根据抽样方法的不同,Restaurant可能是正权重，也可能是负权重。
我们还注意到一些预期的特性，如与价格相关的RestaurantsPriceRange2，以及一些特殊的特性，如AcceptsInsurance和BikeParking。就保险而言，这一功能对按摩院或医生诊所等企业可能很重要。
在成功模式中，以下特征对企业成功至关重要:
- 做一个
Restaurant - 服务
lunch - 还发球
dinner - 你的
RestaurantsPriceRange2很重要 - 做一个
chain
XGBoost 模型解释
XGBoost 的主要特性是从 feature_importances_ 属性中获得的。然而，我们希望找到一种方法来解释我们的输出，以及如何优化业务成功。
对于这项研究，我们使用 SHAP(沙普利附加解释)包来获得个性化的特征属性。 Shapley 值主要用于每次预测的基础上，以帮助解释，并回答类似“是什么导致我的企业被标记为关闭？”
为了证明 SHAP 的使用是正确的，我们在 XGBoost 中给出了 plot_importance 方法，它基于重要性类型产生了三种不同的解释。
weight特征在树中出现的次数
gain使用该功能的拆分的平均增益
cover使用该特性的分割的平均覆盖率，其中覆盖率定义为受分割影响的样本数
在下图中，我们显示了 SHAP 值的平均绝对值。x 轴显示从模型中隐藏特征时模型输出的平均幅度变化。考虑到隐藏一个特征会根据隐藏的其他特征而变化，Shapley 值用于加强一致性和准确性。
下图是每个要素的 SHAP 值的密度散点图，用于确定每个要素对数据集中每个观测值的模型输出的影响程度。摘要图结合了特征重要性和特征效果。摘要图上的每个点都是一个特征和一个实例的 Shapley 值。y 轴上的位置由特征决定，x 轴上的位置由 Shapley 值决定。颜色代表从低到高的特性值。
“着色”功能告诉我们，随着时间的推移，你的stars_change(星级的平均变化)增加是保持开放的一个很好的预测。对于review_count(评论数量)来说，不多会对你有害，然而reiew_count多也意味着负面评论多。对于第三个最重要的特性useful(有用评论投票总数)，这似乎是一个成功的积极指标。
该图还允许我们识别异常值，因为重叠点在 y 轴方向上抖动，因此我们可以了解每个要素的 Shapley 值的分布情况。对于一个特定的业务子集，拥有一个高计数的useful实际上可能是一个即将关闭的指标。比如，有人评论说“离鸡肉远点，好像没煮熟”也不是没听说过。
SHAP 相关图是显示单个要素对整个数据集的影响的额外可视化工具。与部分相关图相反，SHAP 考虑了特征中存在的交互作用效应，并且仅在由数据支持的输入空间的区域中定义。
下面的图表适用于review_density(相对于 2 公里半径内所有其他业务的标准化审查计数)。
在上面的图中，垂直扩散由交互作用影响驱动，另一个特征，这里是RestaurantsGoodForGroups，被选择用于着色，以突出可能的交互作用。我们可以看到，相对于其他业务，拥有更高的评论数是成功的良好指标。此外，对群体有利往往与review_density正相关。
下面的相关矩阵与上面的图相联系。我们可以注意到review_density和RestaurantsGoodForGroups之间的正相关关系。
结论
企业家在投资前要研究清楚一家企业是关门还是继续营业。通过机器学习，我们能够识别出能够预测本文原始问题的特征。我们还能够在每个用户的基础上提供模型可解释性。
虽然可能无法获得问题的全面答案，但解决方案提供了一条前进的道路。企业可以使用模型解释来优化成功，并知道他们需要改进的指标。
展望未来，我们可以利用review.json文件中的文本信息。一个示例的 NLP 练习将是提取表示商业表现的时间或位置函数的情感或单词组。
多亏了 s和 Aditya Subramanian，这个项目才得以实现。要深入了解该流程及其相应代码，请访问 GitHub 资源库:
https://github.com/NadimKawwa/PredictBusinessSuccess
参考
如果你是学生，你将有机会赢得 10 个奖项中的一个，奖金为 5000 美元。我们将根据他们的…
www.yelp.com](https://www.yelp.com/dataset/challenge) [## 利用 Yelp 数据预测餐馆倒闭
米恰伊尔·阿里菲拉克斯是一名有抱负的数据科学家，也是普林斯顿大学的化学工程博士生…
towardsdatascience.com](/using-yelp-data-to-predict-restaurant-closure-8aafa4f72ad6) [## 第 5 章模型不可知的方法|可解释的机器学习
将解释从机器学习模型中分离出来有一些…
christophm.github.io](https://christophm.github.io/interpretable-ml-book/agnostic.html) [## 使用 XGBoost 的可解释机器学习
这是一个关于错误解释你的机器学习模型的危险，以及解释的价值的故事…
towardsdatascience.com](/interpretable-machine-learning-with-xgboost-9ec80d148d27) [## 树集成的一致个性化特征属性
解释来自树集合方法的预测是很重要的，例如梯度推进机器和随机森林…
arxiv.org](https://arxiv.org/abs/1802.03888) [## 我的秘方是在卡格尔比赛中名列前 2%
使用特征探索技术构建更好的 ML 模型，用于特征理解、噪声/泄漏特征检测…
towardsdatascience.com](/my-secret-sauce-to-be-in-top-2-of-a-kaggle-competition-57cff0677d3c) [## 使用边界坐标查找纬度/经度距离内的点
这篇文章描述了如何有效地查询一个数据库，查找距离某一点一定距离内的地点…
扬马图舍克](http://janmatuschek.de/LatitudeLongitudeBoundingCoordinates)*
如何预测你的营销活动的成功
线性、树、森林和支持向量回归:比较、源代码和即用型应用程序
Photo by Anika Huizinga on Unsplash
在这篇文章中，我将带你经历一个建立、训练和评估数字营销活动中广告投放数量预测模型的过程。所有这些技术都可以类似地应用于其他回归问题，尤其是预测各种活动绩效指标。这些预测可用于在推出之前评估未来的营销活动，以及确定最佳参数，包括此类活动的时间表和预算规模。您可以使用自己的活动数据或提供的样本数据集来编写 Python 代码。在所有源代码旁边，我还提供了一个简单的应用程序来预测基于购买的数字营销活动的印象、点击和转换。
app:【predictor.stagelink.com
代码:github.com/kinosal/predictor
故事大纲
- 要求
- 定义你的目标
- 获取数据集
- 第一眼
- 预处理您的数据
- 训练你的模特
- 评估您的模型
- 预测下一次活动的结果
- 额外收获:现成的训练模型
要求
我们将使用过去营销活动的数据来预测未来营销活动的结果。一般来说，数据越多，即活动越多，预测就越准确。确切的数字取决于你的活动的同质性，但是你可能需要至少几百个活动的数据。此外，由于我们将使用监督学习技术，您需要相同的输入，即尺寸或特征，用于您想要估计结果的未来活动。
如果您现在手头没有合适的数据集，不要担心:您可以从这里下载一个 CSV 文件，其中包含我将在本文中使用的示例:
https://github . com/kinosal/predictor/blob/master/model/impressions . CSV
明确你的目标
当我们提到活动的成功或结果时，我们实际上指的是什么？这个显然要看你的具体情况。在这篇文章中，我们将尝试预测单个活动的印象数。类似地，点击和转化可以被预测来完成经典的营销漏斗:
获取数据集
我们看到了几个过去的活动，每个活动都提供了一个观察值或表中的一行，该表具有多个维度或列，包括我们要预测的因变量以及多个解释自变量或特征:
由于我们希望预测结果的活动存在于未来，因此这种情况下的特征不包括任何先前的性能数据，而是活动的不同可观察质量。由于我们通常事先不知道哪些功能将成为良好的预测工具，我建议也使用那些看起来与您的活动关系不大的变量，并投入一些时间来寻找或构建新功能。虽然也有关于减少特征空间的争论，但这通常仍然可以在稍后阶段处理。
你可以用一个非常简单的功能加载 CSV 并保存到一个熊猫数据框中:
import pandas as pd
data = pd.read_csv('impressions.csv')
第一眼
在建立和训练预测模型之前，我总是先看一眼数据，以了解我在处理什么，并找出潜在的异常。我们将使用样本数据来预测营销活动的印象数，因此“impressions.csv”包含每个活动的一行，每个活动的印象总数以及指标和分类特征，以帮助我们预测未来活动的印象数。我们将通过加载数据并显示其形状、列和前 5 行来确认这一点:
>>> data.shape
(241, 13)>>> data.columns
Index(['impressions', 'budget', 'start_month', 'end_month',
'start_week', 'end_week', 'days', 'region', 'category',
'facebook', 'instagram', 'google_search', 'google_display'],
dtype='object')>>> data.head(5)
impressions budget start_month ... google search google_display
9586 600 7 ... 1 0
...
第一列包含从属(待预测)变量“印象”,而总共有 241 个记录(行)的 12 个特征列。我们还可以使用 data.describe() 来显示每个指标列的计数、平均值、标准差、范围和四分位数。
我们可以进一步观察到，我们正在处理十个数字特征和两个分类特征，而四个数字列是二进制的:
现在让我们绘制数字特征的直方图。我们将使用两个非常方便的数据可视化库， Matplotlib 和 Seaborn (构建于 Matplotlib 之上):
import matplotlib.pyplot as plt
import seaborn as snsquan = list(data.loc[:, data.dtypes != 'object'].columns.values)
grid = sns.FacetGrid(pd.melt(data, value_vars=quan),
col='variable', col_wrap=4, height=3, aspect=1,
sharex=False, sharey=False)
grid.map(plt.hist, 'value', color="steelblue")
plt.show()
作为最后一瞥，我们将看看数字特征之间的基本线性相关性。首先，让我们用 Seaborn 热图来想象一下:
sns.heatmap(data._get_numeric_data().astype(float).corr(),
square=True, cmap='RdBu_r', linewidths=.5,
annot=True, fmt='.2f').figure.tight_layout()
plt.show()
此外，我们还可以输出每个特征与因变量的相关性:
>>> data.corr(method='pearson').iloc[0].sort_values(ascending=False)
impressions 1.000000
budget 0.556317
days 0.449491
google_display 0.269616
google_search 0.164593
instagram 0.073916
start_month 0.039573
start_week 0.029295
end_month 0.014446
end_week 0.012436
facebook -0.382057
这里我们可以看到，印象数与预算金额和活动持续时间(天数)正相关，与使用脸书作为渠道的二元选项负相关。然而，这仅仅向我们展示了一种成对的线性关系，并且只能作为一种粗略的初始观察。
预处理您的数据
在我们开始构建预测模型之前，我们需要确保我们的数据是干净的和可用的，因为这里适用于:“垃圾进，垃圾出。”
在这种情况下，我们很幸运地获得了一个结构相当良好的数据集，但我们仍然应该针对即将面临的挑战进行快速预处理:
- 只保留因变量大于零的行，因为我们只想预测大于零的结果(理论上值等于零是可能的，但它们对我们的预测没有帮助)。
- 检查缺少数据的列，并决定是删除还是填充它们。这里，我们将删除丢失数据超过 50%的列，因为这些特性不会给模型增加太多。
- 检查缺少值的行，并决定是删除还是填充它们(不适用于示例数据)。
- 将罕见的分类值(例如，份额小于 10%)放入一个“其他”桶中，以防止我们的模型过度适应这些特定事件。
- 将分类数据编码到一次性虚拟变量中，因为我们将使用的模型需要数字输入。有各种方法对分类数据进行编码，这篇文章提供了一个很好的概述，以防你有兴趣了解更多。
- 指定因变量向量和自变量矩阵。
- 将数据集分为训练集和测试集，以便在训练后正确评估模型的拟合度。
- 根据我们将要构建的一个模型的需要缩放特征。
下面是完整的预处理代码:
训练你的模特
最后，我们可以继续构建和训练多个回归变量，以最终预测结果(因变量的值)，即所讨论的营销活动的印象数。我们将尝试四种不同的监督学习技术——线性回归、决策树、随机森林(决策树)和支持向量回归——并将使用 Scikit-learn 库提供的相应类来实现这些技术，该库已经用于在预处理期间缩放和拆分数据。
我们可以使用更多的模型来开发回归器，例如人工神经网络，它可能会产生更好的预测器。然而，本文的重点是以直观和可解释的方式解释这种回归的一些核心原则，而不是产生最准确的预测。
线性回归
https://towardsdatascience.com/introduction-to-linear-regression-in-python-c12a072bedf0
使用 Scikit-learn 构建线性回归器非常简单，只需要两行代码，从 Scikit 的线性模型类中导入所需的函数并将其赋给一个变量:
from sklearn.linear_model import LinearRegression
linear_regressor = LinearRegression(fit_intercept=True, normalize=False, copy_X=True)
我们希望保留默认参数，因为我们需要计算截距(当所有特征都为 0 时的结果),并且我们不需要偏好可解释性的标准化。回归器将通过最小化误差平方和(即预测结果与真实结果的偏差)来计算自变量系数和截距，这被称为普通最小二乘法。
我们还可以输出系数及其各自的 p 值，输出的概率独立于(此处也不相关于)特定特征(这将是系数等于 0 的零假设)，因此是统计显著性的度量(越低越显著)。
在我们之前的“第一眼”中已经可视化了数字特征之间的相关性，我们期望特征“预算”、“天数”和“facebook”携带相对较小的 p 值，其中“预算”和“天数”具有正系数，“facebook”具有负系数。 statsmodels 模块提供了一种输出这些数据的简单方法:
model = sm.OLS(self.y_train, sm.add_constant(self.X_train)).fit()
print(model.summary())
这里的 p 值是使用基于 t 分布的 t 统计或得分计算的。该摘要还为我们提供了整个模型的准确性或拟合优度的第一个提示，通过测定输入变量解释的输出中方差份额的决定系数 R 平方进行评分，此处为 54.6%。
然而，为了比较所有模型并适应我们的特殊挑战，我们将使用一种不同的评分方法，我称之为“平均相对准确度”，定义为 1 -平均百分比误差= 1 -平均值(|(预测-真值)/真值|)。如果真值为 0，则该度量明显是未定义的，但是在我们的情况下，这是不相关的，因为我们在预处理步骤中检查该条件(见上文),并且我们将因此获得与准确性的直观定义相匹配的良好可解释性。我们将使用五重交叉验证计算所有模型的得分，随机将数据集拆分五次，并取每个得分的平均值。Scitkit-learn 也为此提供了一种简便的方法:
linear_score = np.mean(cross_val_score(estimator=linear_regressor,
X=X_train, y=y_train, cv=5,
scoring=mean_relative_accuracy))
我们获得的线性回归的训练分数是 0.18；因此，我们能够用这个模型产生的最佳拟合结果只有 18%的预测准确度。让我们希望其他模型能够超越这一点。
决策树
https://becominghuman.ai/understanding-decision-trees-43032111380f
接下来是从一个决策树中得到的回归量。这里，我们将使用一个 Scikit-learn 函数，它比线性模型多了几个参数，即所谓的超参数，包括一些我们尚不知道所需设置的参数。这就是为什么我们要引入一个叫做网格搜索的概念。网格搜索也可从 Scikit-learn 获得，当训练预测模型并返回最佳参数(即产生最高分数的参数)时，它允许我们定义要测试的参数网格或矩阵。通过这种方式，我们可以测试决策树模型的所有可用参数，但我们将关注其中的两个参数，即衡量将一个分支分成两个分支的质量的“标准”和树的一个叶子(最终节点)的最小样本(数据点)数量。这将有助于我们找到具有训练数据的良好模型，同时限制过拟合，即不能从训练数据推广到新样本。从现在开始，我们也将为所有的随机计算设置一个等于 1 的随机状态，这样你将会得到相同的编码值。其余的工作类似于我们之前构建的线性回归:
tree_parameters = [{'min_samples_leaf': list(range(2, 10, 1)),
'criterion': ['mae', 'mse'],
'random_state': [1]}]
tree_grid = GridSearchCV(estimator=DecisionTreeRegressor(),
param_grid=tree_parameters,
scoring=mean_relative_accuracy, cv=5,
n_jobs=-1, iid=False)
tree_grid_result = tree_grid.fit(X_train, y_train)
best_tree_parameters = tree_grid_result.best_params_
tree_score = tree_grid_result.best_score_
从我们定义的网格中选择的最佳参数包括均方误差，作为确定每个节点最佳分割的标准，以及每个叶片的最少九个样本，产生 67%的平均相对(训练)准确度，这已经比线性回归的 18%好得多。
决策树的一个优点是我们可以很容易地形象化和直观地理解模型。使用 Scikit-learn 和两行代码，您可以生成拟合决策树的点表示，然后您可以将其转换为 PNG 图像:
from sklearn.tree import export_graphviz
export_graphviz(regressor, out_file='tree.dot',
feature_names=X_train.columns)
正如您所看到的，所有 16 个特性中只有 4 个用于构建这个模型:budget、days、category_concert 和 start_month。
随机森林
单一决策树的主要挑战在于在每个节点找到最佳分裂，并过度适应训练数据。当将多个树组合成随机森林集合时，这两种情况都可以得到缓解。这里，森林的树将在数据的不同(随机)子集上被训练，并且树的每个节点将考虑可用特征的(再次随机)子集。
随机森林回归器的构建几乎与决策树一模一样。我们只需要添加树的数量，这里称为估计量，作为一个参数。由于我们不知道最佳数字，我们将在网格搜索中添加另一个元素来确定最佳回归量:
forest_parameters = [{'n_estimators': helpers.powerlist(10, 2, 4),
'min_samples_leaf': list(range(2, 10, 1)),
'criterion': ['mae', 'mse'],
'random_state': [1], 'n_jobs': [-1]}]
forest_grid = GridSearchCV(estimator=RandomForestRegressor(),
param_grid=forest_parameters,
scoring=mean_relative_accuracy, cv=5,
n_jobs=-1, iid=False)
forest_grid_result = forest_grid.fit(X_train, y_train)
best_forest_parameters = forest_grid_result.best_params_
forest_score = forest_grid_result.best_score_
根据我们定义的网格搜索，森林模型的最佳参数包括平均绝对误差标准、3 个最小叶子样本大小和 80 个估计量(树)。与单个决策树相比，通过这些设置，我们可以再次将训练准确率提高到 70%。
支持向量回归机
我们要构建的最后一个回归变量基于支持向量机，这是一个由 Vladimir Vapnik 在 20 世纪 60 年代到 90 年代开发的美丽的数学概念。不幸的是，解释它们的内部工作超出了本文的范围。尽管如此，我还是强烈建议去看看；一个很好的入门资源是温斯顿教授在麻省理工学院的演讲。
一个非常基本的总结:支持向量回归机试图将给定样本拟合到由线性边界定义的直径的多维(按照特征数量的顺序)超平面中，同时最小化误差或成本。
尽管这种类型的模型与决策树和森林有着本质的不同，但 Scikit-learn 的实现是相似的:
svr_parameters = [{'kernel': ['linear', 'rbf'],
'C': helpers.powerlist(0.1, 2, 10),
'epsilon': helpers.powerlist(0.01, 2, 10),
'gamma': ['scale']},
{'kernel': ['poly'],
'degree': list(range(2, 5, 1)),
'C': helpers.powerlist(0.1, 2, 10),
'epsilon': helpers.powerlist(0.01, 2, 10),
'gamma': ['scale']}]
svr_grid = GridSearchCV(estimator=SVR(),
param_grid=svr_parameters,
scoring=mean_relative_accuracy, cv=5,
n_jobs=-1, iid=False)
svr_grid_result = svr_grid.fit(X_train_scaled, y_train_scaled)
best_svr_parameters = svr_grid_result.best_params_
svr_score = svr_grid_result.best_score_
我们可以再次使用网格搜索来找到一些模型参数的最佳值。这里最重要的是将样本变换到更高维度的特征空间的核，在该特征空间中，数据可以被线性分离或近似，即通过上述超平面。我们正在测试一个线性核，一个多项式核和一个径向基函数。ε为 0.08，即预测与真实值的最大(缩放)距离，其中没有与其相关联的错误，并且惩罚参数 C 为 12.8，线性核表现最佳，达到 23%的(缩放)训练精度。
评估您的模型
在我们根据手头的训练数据确定了模型的最佳参数后，我们可以使用这些参数来最终预测测试集的结果，并计算它们各自的测试精度。首先，我们需要用训练数据的期望超参数来拟合我们的模型。这一次，我们不再需要交叉验证，并将使模型适合完整的训练集。然后，我们可以使用拟合回归来预测训练和测试集结果，并计算它们的准确性。
training_accuracies = {}
test_accuracies = {}
for regressor in regressors:
if 'SVR' in str(regressor):
regressor.fit(X_train_scaled, y_train_scaled)
training_accuracies[regressor] = hel.mean_relative_accuracy(
y_scaler.inverse_transform(regressor.predict(
X_train_scaled)), y_train)
test_accuracies[regressor] = hel.mean_relative_accuracy(
y_scaler.inverse_transform(regressor.predict(
X_test_scaled)), y_test)
else:
regressor.fit(X_train, y_train)
training_accuracies[regressor] = hel.mean_relative_accuracy(
regressor.predict(X_train), y_train)
test_accuracies[regressor] = hel.mean_relative_accuracy(
regressor.predict(X_test), y_test)
结果如下:
训练精度:线性 0.34，树 0.67，森林 0.75，SVR 0.63
测试精度:线性 0.32，树 0.64，森林 0.66，SVR 0.61
我们最好的回归器是随机森林，最高测试精度为 66%。这似乎有点过了，因为它与训练精度的偏差相对较大。随意试验超参数的其他值，以进一步改进所有模型。
在最终保存我们的模型以对新数据进行预测之前，我们将使它适应所有可用的数据(训练和测试集)，以尽可能多地纳入信息。
预测结果
现在我们有了一个模型，可以预测未来营销活动的结果。我们只需对它调用 predict 方法，传递一个特定的特征向量，并将收到我们训练回归元的度量的相应预测。我们还可以将现有数据集的真实印象与基于新模型的预测进行比较:
预测值与实际值的平均相对偏差为 26%，因此我们达到了 74%的准确率。只有 14%的中值偏差甚至更小。
结论
我们能够构建和训练回归器，使我们能够根据历史营销活动数据预测未来营销活动的印象数(以及其他模拟方式的绩效指标)。
随机森林模型的预测精度最高。
我们现在可以使用这些预测来评估一个新的营销活动，甚至在它开始之前。此外，这使我们能够确定最佳参数，包括我们活动的时间表和预算规模，因为我们可以用这些特性的不同值来计算预测。
奖励:现成的训练模型
你手头还没有数据来为你计划的数字营销活动建立一个准确的预测模型？别担心:我已经训练了多个模型，用 1000 多个活动的数据来预测印象、点击和购买。通过不同模型的组合，这些预测的准确率高达 90%。在 predictor.stagelink.com你会发现一个简单的应用程序，只需几个输入就能预测你未来活动的结果。这些模型主要根据推广活动门票销售的数字营销活动的数据进行训练，因此这可能是它们表现最好的地方。
predictor.stagelink.com
除此之外，你可以在我的 Github 上找到所有用于讨论营销业绩预测的代码:github.com/kinosal/predictor
感谢您的阅读-我期待您的任何反馈！
如何在 Power BI 中预测自定义 R 模型的值
如果您经常在 R 中为您的客户开发预测模型，您可能需要为他们提供一个实用的 GUI 来测试他们的模型。一个真正简单方便的方法是为用户提供与模型输入特性一样多的滑块和/或组合框，以及一个显示预测值的简单标签。对于研发人员来说，第一个显而易见的选择是一个闪亮的应用程序。但是，如果您的客户 IT 基础架构以微软为中心，Power BI 报告可能是最佳选择。
我们的测试预测模型
首先，我们创建一个 R 模型，用 Power BI 报告进行测试。我们将使用mtcars数据集，这是一个从 1974 年汽车趋势美国杂志中提取的数据集，包括 32 款汽车(1973-74 款)的燃油消耗以及汽车设计和性能的 10 个方面。深入分析后，您可以在此处找到，最终适合的型号如下:
finalfit <- lm(mpg ~ wt+qsec+factor(am), data = mtcars)
我们可以将训练数据加载到 Power BI 模型中，以便在报告中进行训练。但是以这种方式，每次输入参数改变时，都需要模型训练，失去了预测的实时效果。最好的方法是将已经训练好的模型用于 Power BI 报告中。所以，让我们在文件系统上序列化它:
让我们设置电源 BI 报告
为了从 Power BI Desktop 执行 R 代码，您需要安装 R 引擎。如果您已经将 RStudio 与 CRAN R 一起使用，那么 R 脚本的 Power BI 桌面选项应该是这样的:
fig. 1 — Power BI Options for R Scripting
如果你想使用微软 R Open 引擎，确保它已经安装在你的机器上，然后正确地修改 R home 目录。
将 R 语言集成到 Power BI Desktop 中非常有效。您可以使用 R 脚本来:
- 输入数据
- 转换数据
- 创建可视化效果
您还可以导入基于 R 的自定义视觉效果。更多信息，你可以阅读这篇博文。
对于我们的目标，我们肯定需要一个 R 脚本可视化来从模型中预测目标值，然后将其显示为文本。数字特征可以通过假设参数输入。分类的可以通过 OK Viz 智能滤镜输入(只需下载 pbiviz 文件导入)。
加载 R 模型
因为我们在 RDS 文件中序列化了我们的模型，所以我们需要首先加载它，然后将它反序列化到我们的报告中。如果我们在 R 脚本可视化中做了这两个步骤，那么每次通过切片器或组合框修改输入值时，我们都会有一个 I/O 操作(加载步骤)。为了最大限度地减少 I/O 操作，从而获得更好的预测性能，最好从磁盘加载我们的预测模型一次(在 Power BI 报告开始时的导入数据阶段)，然后将我们的预测放入 R 脚本可视化中。
Power BI 只有在 data.frame 或 data.table 类型时才能通过 R 脚本加载数据(详见此处)。那么，如何才能将一个序列化的模型加载到 Power BI 中呢？
诀窍是将模型序列化为一个字节串，然后将其存储在 dataframe 中。
所以，点击获取数据→更多…，只需搜索“脚本”，选择“R 脚本”，点击“连接”即可:
fig. 2 — Get data from an R script
现在只需在弹出的 R script 窗口中输入以下代码(感谢 Danny Shah 解决了 Power BI 中由于长字符串截断而导致的错误):
注意到项目文件夹变量需要一个绝对路径。
在上一个窗口中点击“确定”后，需要选择 model_df 数据框，然后点击“加载”:
fig. 3 — Load the R dataframe into Power BI
就是这样！R 模型现已纳入我们的 Power BI 报告。
添加切片器和组合框
现在是时候给我们的报告添加视觉效果了。由于输入特征是数值型( wt 和 qsec 和分类型( am )的，所以我们添加两个假设参数和一个智能过滤器。点击建模选项卡中的新参数后:
fig. 4 — Create a new What If Parameter
弹出一个新的对话框，询问参数细节。在检查了 wt 的最小值、平均值和最大值后，输入值如下:
fig. 5 — Details for the Weight What If Parameter
单击“确定”时，将添加一个新的计算表。重命名其对象，如下图所示:
fig. 6 — Calculated table added with the Weight What If Parameter
关联的切片器如下所示:
fig. 7 — The slicer for the new What If Parameter
对 qsec 参数做同样的操作:
fig. 8 — Details for the qsec What If Parameter
fig. 9 — Calculated table added with the qsec What If Parameter
为了为 am 分类值创建过滤器，首先我们需要创建一个新的表格来输入手动数据:
fig. 10 — Create a manual table
fig. 11 — Entering manual data in a table
然后，我们可以添加一个智能滤波器，选择传输值作为字段:
fig. 12 — Adding the Smart Filter
fig. 13 — The Transmission Smart Filter
现在我们有了输入输入参数所需的所有控件。我们只是错过了从模型中预测值的“核心”R 代码。
添加 R 脚本可视化
我们可以使用 R Script Visual 来取消模型的序列化，然后将预测值显示为标签中的字符串。让我们添加它，在组件中拖动以下值:
- 型号标识
- 型号 _str
- 重量
- qsec
- 上午
自定义视觉效果如下:
fig. 14 — Adding the R Script Visual
添加到相关联的 R 脚本编辑器的代码如下(感谢丹尼·沙阿修复了丢失尾随空格的问题):
带有预测的结果标签如下:
fig. 15 — The predicted value shown in the visual
就是这样！在与它的几次交互中，这里显示了完整的报告:
fig. 16 — Interacting with the report
完整的 pbix 文件和保存为 rds 文件的模型可在此链接获得。
发布报告
如果这个工具必须在涉众之间共享呢？一个解决方案是共享这两个文件( pbix 和 model rds 文件)，这样用户就可以在他们的笔记本电脑上使用它们。这个解决方案的主要问题是指向 rds 文件的路径必须根据用户下载它的新位置手动更改。所以用户必须编辑 pbix 文件(对于普通用户来说不那么明显)。
更简单的解决方案是将报告发布给 Power BI 服务。预测模型已经在 Power BI 模型中序列化，因此不再依赖外部文件。唯一的预见是确保报告中使用的 R 包已经安装在 Power BI 服务上。服务上支持的 R 包是这个链接上的。
由于我们使用了 CRAN 标准软件包，我们的报告可以轻松发布。只需几次点击(按下主页选项卡上的发布按钮并选择报告目的地)即可完成:
fig. 17 — Interacting with the report published on the Power BI service
显然，如果我们尝试刷新底层报表数据集:
fig. 18 — Trying to refresh the dataset
我们将得到一个错误，因为没有连接到模型文件的网关来检索序列化的模型:
fig. 19 — Error after trying to refresh the dataset
您可以在 RDS 文件所在的机器上安装一个个人网关来绕过这个错误。
请记住，今天(2019 年 4 月)R 视觉仍然不支持 发布到网络 功能:
fig. 20 — R Visuals are not allowed by Publish to Web
如果你希望微软在未来的版本中考虑这个特性，你可以投票这个特性请求。
结论
在数据科学家训练出一个预测模型来解决一个业务问题之后，他必须向利益相关者提供工具来测试它。最好的工具是一个动态工具，让他们拖动滑块并通过过滤器选择分类值，以实时查看预测值。Power BI 报告可以管理所有这些需求，也可以通过 Power BI 服务轻松共享。
你可以在我的书“用 Python 和 R 扩展 Power BI”中找到这篇文章中使用的技术的更多细节，包括用 R 和 Python 开发的模型:
它在亚马逊上全球都有售。这里有几个链接:
希望你会觉得有趣！🙂
如何预测你的最佳足球运动员的 FIFA 20 评分？
创建一个机器学习算法来预测 FIFA 20 球员的评分。
我把球从米尔纳传给萨拉赫。萨拉赫快速运球，把球传给菲尔米诺。菲尔米诺时髦地给马内做了一个 360 度的转身。马内用左脚将球踢入门柱的右上角。这是一个目标。备受好评的利物浦足球俱乐部队的又一次强有力的努力。
这种能在虚拟世界里控制自己喜欢的玩家，让他们做不同技能的感觉深不可测。我在国际足联有过一些最好的经历。我可以看到足球运动员做我想让他们做的事情，并有机会控制比赛的节奏和结果，这就是为什么我对玩 FIFA 20 如此兴奋。
EA sports 每年都会发布一款新的 FIFA 游戏。今年，我最喜欢的球员，维吉尔·范·迪克登上了封面。我不能只是等待安装游戏，并使用一个 91 额定范迪克发挥对对手。我也渴望体验新的游戏活动，如沃尔塔足球，家规和国际足联终极团队。
看着球员的评分，我想起了我前一阵子写的一篇文章(可以在这里找到这里)，我在文章中用机器学习算法预测了 FIFA 19 球员的评分。因此，我决定写一篇关于预测 FIFA 20 球员评分的新文章。
这是通过两种方式完成的。首先，通过使用国际足联 20 名球员的属性。然后，通过使用开发的机器学习算法来预测 FIFA 19 球员的收视率。
数据集
找到了具有正确属性的数据集。从这个链接获得了由 2019 年 FIFA 评分和 2020 年 FIFA 评分组成的两个数据集。在他们被获得之后，他们被装载并且清洗进 Jupyter 笔记本。为数据分析保留的主要特征是:姓名、总体情况、年龄、价值、工资和潜力。
Top five rows of the FIFA 20 dataset
Top five rows of the FIFA 19 dataset
将 FIFA 20 名球员的属性与其总体评分进行比较
创建了一个散点图来找出 FIFA 20 球员的总体评分与他们的潜力之间的关系。在散点图中也建立了回归线。
A scatterplot of FIFA 20 players’ overall ratings vs potential
该散点图的相关系数约为 0.647，表明两个变量之间存在适度的正相关关系。
下表显示了所有变量之间的相关系数。
The correlation coefficient table for all the variables
在回顾了其他变量与总体评分的关系后，得出的结论是，年龄、工资和价值也与总体评分有适度的正相关关系。
基于 FIFA 20 属性的预测模型
数据集分为两组:训练数据集和测试数据集。训练数据集保留了整个数据集的 87.5 %，而测试数据集保留了整个数据集的 12.5 %。
将数据集分成两组的目的是使用训练数据集来了解自变量(年龄、潜力、价值和工资)如何与因变量(总体)相互作用。然后，从这种交互开发的算法用于预测测试数据集的总体评级。
下面是拆分、训练和测试数据集的代码。
分割数据集
**import** **numpy** **as** **np**
split = np.random.rand(len(df_fifa1)) < 0.875
train = df_fifa1[split]
test = df_fifa1[~split]
regr = linear_model.LinearRegression()
训练数据集
*## Trainig & fitting the model*
fifa_x_train = train[['age','value_eur','potential','wage_eur']]
fifa_y_train = train[['overall']]
poly = PolynomialFeatures(degree=4)
fifa_x_train_poly = poly.fit_transform(fifa_x_train)
regr.fit(fifa_x_train_poly, fifa_y_train)
测试数据集
*## Testing the model*
fifa_x_test = test[['age','value_eur','potential', 'wage_eur']]
fifa_y_test = test[['overall']]
fifa_x_test_poly = poly.fit_transform(fifa_x_test)
使用 a 为四次的多元多项式回归进行预测，并使用 r2 分数、皮尔逊相关系数和 p 值测试其准确性。
机器学习算法非常准确。其 r2 分数约为 97.6 %，皮尔逊相关系数为 98.8 %，p 值为 0。
预测的玩家评分
进行预测后，创建两个表来显示训练数据集的预测评级和测试数据集的预测评级。
First 20 rows of the training datasets’ predicted ratings
First 20 rows of the testing datasets’ predicted ratings
在这两个数据集中，玩家的预测评分可以在右边第一列看到。这使得莱昂内尔·梅西的预测评分为 93.59，罗纳尔多的预测评分为 93.27，内马尔的预测评分为 91.00。因此，显示了他们的评级与他们分别为 94、93 和 92 的实际评级相比有多准确，并证明了该模型 97.6 %的准确性。
利用 FIFA 19 预测模型预测 FIFA 20 球员的评分
基于属性为 FIFA 20 球员的评级生成预测模型的相同过程被重复用于 FIFA 19 球员的数据集。然后，来自 FIFA 19 数据集的预测模型用于使用 FIFA 20 球员的属性生成 FIFA 20 评级的预测评级。
这个模型也被证明是准确的。它的 r-2 值为 97.4 %，皮尔逊相关系数为 98.8 %，p 值为 0。
预测的玩家评分
First 20 rows of FIFA 20 predicted players’ ratings based on FIFA 19 predictive model in descending order
从表中可以看出，大部分预测收视率与总体收视率相当接近。然而，马克·特尔·斯特根似乎是一个异数。他的评分预计为 104 分，而一个人最多只能得到 100 分。欧洲足联年度最佳球员维吉尔·范迪克的预测得分为 92.9。他的综合评分是 91 分。国际足联年度最佳球员莱昂内尔·梅西的预测评分为 92.14 分。他的综合评分是 94 分。
结论
查看用于预测收视率的两种方法的结果，可以得出结论，国际足联每年都使用相同的指标来确定球员的收视率。
用于构建这些预测模型的代码完整版本可见 此处为 。
如何准备你的数据工程面试
得到了你梦想中的公司的回电，但不确定该期待什么，以及如何准备接下来的步骤？我们是来帮忙的！
在 Insight ，我们已经成功地让数百名同事做好准备，在他们梦想的公司中过渡到数据工程师和机器学习工程师的职位。在任何工程职位的面试中，面试官都希望了解你是否具有良好的分析能力、解决问题的能力、沟通能力、工作文化和构建技术解决方案的能力。具体到数据工程，他们还想了解你是否有处理大数据和构建可扩展的健壮系统的技能。在本文中，我们将讨论如何最好地准备和执行每种类型的数据工程面试，从算法、系统设计、SQL 问题到基本的行为组件。
The typical Data Engineering interview process.
手机屏幕
有两种类型的电话屏幕:人力资源，一般都是行为问题，和技术电话屏幕。
人力资源电话筛选通常为 15-30 分钟，由公司的非技术人员进行，如招聘人员。你会被问到一些软问题，比如你为什么想成为一名数据工程师？你认为自己五年后会怎样？你为什么想在我们公司工作？更重要的是，你期望的薪水是多少？如果你不知道这些问题背后的真正原因，这些问题可能会显得无聊或奇怪:人力资源部门希望找到适合他们团队的合适人选。他们希望应聘者能够与同事和经理很好地沟通，并在公司呆很长时间，因为招聘和入职成本很高！
就像 HR 电话屏幕是基本沟通能力的过滤器一样，技术电话屏幕是基本技术能力的过滤器。现场面试在时间和团队资源方面的成本非常高，所以公司不想在一个不会编程的候选人身上花费几个小时。评估基本的 SWE 知识和将复杂的想法分解成更小的可理解的部分的能力是技术电话屏幕的最重要的原因。
HR 电话屏幕汇总
期待一个 15-30 分钟的电话会议，讨论你的背景、目标和对他们公司的兴趣。
他们正在寻找清晰的沟通，一个愉快的合作伙伴，一个对公司充满热情并做过调查的人，最好是一个愿意留在公司并快乐工作的忠诚员工。
例题包括说说你的背景。你为什么想成为【公司】的数据工程师？你期望的工资范围是多少？
准备:
1.为你的背景写一个剧本并练习。
2。深入了解公司价值观，并相应调整你的答案。
3。通过电话与你的同龄人练习(我们知道这可能会很尴尬)。
4。面试前至少 10 分钟，找一个安静的地方，有良好的网络连接。
技术电话屏幕总结
期待一个 30-60 分钟的电话会议，回答基本的 DE 概念或经典的 SWE 问题，通常由工程团队成员提出。
他们正在寻找具备 SWE 和 DE 基础知识、解决问题的技能以及交流技术信息能力的人。
例题包括什么是链表？你会如何用你选择的语言编写它们呢？在列表中查找所有重复项。你什么时候使用 SQL 和 NoSQL 数据库？
准备: 1。阅读数据工程食谱并回答至少 50 个问题。
2。和你的同伴一起练习书中的随机问题。
3。做 50 道简单的 LeetCode 题。
4。面试前至少 10 分钟，找一个安静的地方，有良好的网络连接。
课后考试
你的简历上说你有多年的经验，领导过多个项目，还是个摇滚明星。公司怎么知道你是否真的那么好？在大多数情况下，无法访问你的旧公司 GitHub 库，阅读和理解个人 GitHub 项目需要时间——更不用说他们不会确定代码是你写的。带回家的编码挑战是评估您的代码的生产就绪程度、您如何考虑边缘情况和异常处理，以及您是否能够以最佳方式解决给定问题的最简单和最快的方法。有两种主要的考试类型:
定时黑客排名
预计1.5-2 小时的考试，包含 3-5 个简单的中级黑客问题
，包括 SQL、正则表达式、算法和数据结构
他们在寻找知道解决标准计算机科学问题的有效算法和数据结构、考虑边缘情况并快速提供解决方案的工程师
准备: 1。解决至少 100 个 LeetCode/HackerRank 问题
2。用虚拟 Leetcode 竞赛练习——所有免费的过去竞赛，你可以在任何时间参加，并尝试在第一次尝试时快速正确地解决问题
3。划出一大块时间，让你处在一个舒适的环境中，你通常在那里做技术工作，确保你不会被打扰，并有足够的水和零食(如果需要的话)。
编码挑战
预计1–7 天编写代码，回答 1–3 个数据集上的 1–10 个问题，将其推送到您的 GitHub 存储库并提交链接。
他们正在寻找清晰的模块化代码、清晰的自述文件、单元测试和异常处理。
例题清理并分析一个员工工资和地点的数据集。不同地点的工资分布情况如何？编写一个 SQL 查询来完成相同的任务。
准备
准备 1。阅读并消化谷歌风格指南。
2。用 Python 或类似语言练习使用 unittest 库。
3。阅读 GitHub 最佳实践。
现场面试
如果你到了现场面试，你应该会觉得很有成就感，但是最难的部分还在后面！在 3-6 个小时内与 4-10 个人进行现场面试是一件非常累人的事情，尤其是在你没有准备好的情况下。知道会发生什么，提前做好现实的准备，对减少恐惧和紧张大有帮助。
白板算法和数据结构
这是最常见的面试类型，因为算法和数据结构的知识对于节省成本和时间的代码至关重要。它通常在白板上完成，以评估您在没有 IDE/堆栈溢出的情况下的编码技能以及您的技术交流技能。
期待30-45 分钟的面试，在白板上回答 1-2 个中等难度的问题，不断与面试官交流需求和解决方案。
他们想要的是你面试前的准备，基础知识和良好的沟通能力。不要在沉默中解决问题——让它成为你和面试官之间的对话。
准备
1。在纸张/白板上解决 80-150 个 LeetCode 问题
2。作为受访者，与同行或专业人士进行至少 20 次练习。
3。练习在白板上书写清晰易读的代码。
白板系统设计
作为一名数据工程师，每天你都要从头开始设计整个系统，或者给巨大的现有管道添加小功能。即使你在简历中提到了这些技能，公司在现实生活中检验你的能力也是至关重要的。
预计30-45 分钟的面试将设计出符合规格的数据工程系统。
例题:设计 Twitter——需要哪些系统块？你会使用什么样的数据库和模式？缓存和负载平衡呢？系统的权衡是什么？
他们在寻找你清晰沟通和缩小需求范围、设计概念级管道的能力，以及分布式系统基础知识。
准备 1。阅读数据工程食谱、数据工程生态系统和进行系统设计面试。
2。与同伴或导师在白板上练习至少 10 个不同的问题。
3。练习在白板上绘制清晰易读的系统图。
结构化查询语言
大多数公司都是语言不可知的。你可以从 Scala 过渡到 Python 再到 Java，但是对 SQL 的深刻理解是数据库工作的基础，是不可替代的，即使是 NoSQL 数据库。这就是为什么超过 50%的公司将这种类型的面试作为现场数据工程的一部分。
预计一次30-45 分钟的采访，包括 1-3 个难题 HackerRank SQL 问题+规范化、索引、分析-解释查询
****例题包括打印一个表格列的第 n 个最大条目。
****他们正在寻找您编写查询和优化他们现有 RDBMS 的能力。
准备**1。练习 57 SQL 问题书。
2。Google 并了解查询优化。
文化契合度
技术过硬，知识渊博很重要，但这还不够！如果你不能传达你的优秀想法，那么没有人能够理解和使用它们。面试的行为类型，比如文化契合度，意在展示你如何讲述自己的故事，并解释你如何处理艰难的工作环境。
The STAR method.
期待一次 30-45 分钟的面试，问 2-4 个关于你过去情况的问题。
****他们使用 STAR(情境、任务、行动、结果)方法寻找一致且完整的答案。
****示例问题包括告诉我们一次你在工作中遇到重大截止日期的经历。告诉我们你与其他团队成员发生冲突的一次经历。你是如何处理这些情况的？
准备
1。单独练习至少 30 个文化契合面试问题，写脚本，如果需要的话自己录音。
2。遵循 STAR 方法，与同伴一起练习至少 10 个问题。
TLDR
如果你喜欢看视频，这是我们就同一主题举办的网络研讨会:
如何为更好的 AI 准备训练数据？
人工智能(AI)可以给你的产品带来竞争优势。但要真正用 AI 产生价值，你需要高质量的 AI 训练数据。
为了获得这些训练数据，首先要决定你想用你的人工智能系统完成什么。带着这个目标，计算出你需要什么样的训练数据以及需要多少。然后，最后，你可以收集和准备数据来训练你的 AI 。
决定你想用你的人工智能系统实现什么
我们应该先说，人工智能不是所有问题的唯一解决方案。通常，您可以使用更有效、更复杂的技术。
例如，让我们想象一下你想让读者在你的网站上停留更长时间。有多种方法可以做到这一点，并不是所有的方法都需要构建一个定制的人工智能引擎。
- 一种方法是专注于降低你博客的跳出率。您可以通过多种方法实现这一点，包括更改页面设计、添加新的共享功能以及创建更好的内容。
- 然而，如果你选择用与他们最相关的内容来吸引读者，建立一个人工智能支持的内容推荐系统实际上是你最好的选择。
通过尽早设定一个明确的目标，你将完成两件事:1)确保人工智能是你真正需要的，2)简化为它选择、收集和准备训练数据的过程。
一个定制的人工智能可以帮助你预测和预测值，检测异常行为，发现模式，分析影响，以及构造或分类数据。
价值预测
有了回归分析，你就可以预测未来在一定条件下会发生什么。回归是一种很好的统计方法，可以帮助你分析几个变量之间的联系，看看它们是如何相互影响的。
例如，回归分析可以通过分析过去影响你销售额的因素来帮助你预测明年的销售额。以类似的方式，您可以使用回归分析来估计需求、收入、客户满意度等方面的波动。
价值预测
使用价值预测来计算在某个时间段内会发生什么。通过分析过去的事件，价值预测人工智能可以帮助你预测在给定的时间内形势将如何发展。
这种方法的一些实际实现包括估计未来的销售数字，计算何时开始产生投资回报，以及计算全年需求增长最快的时间。
异常检测
您可以通过异常检测注意到异常情况和行为。异常检测人工智能分析过去的数据，了解什么被认为是正常的行为，然后寻找任何不符合标准的行为。
借助异常检测，您可以防止客户欺诈、构建智能安全系统、分析医疗传感器的读数、维护工业环境的稳定性等等。
影响分析
影响分析可以帮你决定哪些因素对结果影响最大。推动销售的因素很可能是有限的，影响分析可以帮助你确定这些因素。
这种方法的其他实际实现包括找出什么内容驱动了最大的流量和转化率，以及什么内容可能会损害您所在行业的客户满意度。
联合
使用关联方法，您可以在各种事件序列中找到模式。例如，你可以让人工智能分析客户可能会一起购买哪些商品，然后向其他潜在客户推荐这些商品。
在工业环境中，关联方法可以帮助您在系统崩溃之前追溯跟踪传感器读数的变化，以避免将来发生类似的崩溃。您还可以记录顾客在结账时的行为，找出那些继续付款的顾客和那些放弃购物车的顾客之间的相似之处。
了解 Lemberg 如何构建用于个人卫生控制的数据科学设备。
使聚集
通过聚类，人工智能使得根据相似性将数据组织成类别变得容易。这种方法非常适合您想要理解您所拥有的任何数据的时候。
聚类的一些例子是划分目标受众，分析竞争对手提供的服务的异同，以及建立基于客户的营销策略。
分类
通过实现分类方法，你可以构建一个人工智能来回答简单和复杂的数据问题。
数据分类可以帮助你更好地了解你的受众和客户:根据他们的推文和评论，他们对你的服务有多满意，他们完成结账的可能性有多大，你可以做些什么来为他们提供更好的体验，等等。
请记住，并不是所有的 AI 开发都是从解决某个行业问题的愿望开始的。有时候，你有很多数据，你想从中产生价值，这也很好。不管你从什么开始，尽可能缩小你的最终目标。
用你的目标来决定你需要什么样的 AI 训练数据
为了训练人工智能解决问题或实现你确定的目标，你需要给它足够的与目标或问题相关的数据。这些数据将构成您的训练数据集。
根据任务的不同，你要么需要监督人工智能的学习过程，要么让人工智能自学。
- 有了监督学习，你需要给人工智能输入标签数据，告诉人工智能什么输入应该导致什么输出。当你已经知道你想要人工智能产生什么结果(分类，异常检测等)时，这种方法是很好的。).
- 然而，无监督学习意味着人工智能将分析数据，然后自己决定产生什么输出。如果您不确定从您拥有的数据中能得到什么(聚类、值预测和预测等)，您应该实现这种方法。)
当开发 BarHelper(一个具有计算机视觉功能的人工智能，可以识别瓶装和罐装饮料并计算订单的总成本)时，我们必须训练人工智能:
- 在图像和视频中识别特定的罐子和瓶子，以及
- 弄清楚每种饮料的名称和价格。
Interface of BarHelper, our drink recognition system
BarHelper AI 在监督下学会了提供我们期望的结果。为了实现这一点，我们的工程师选择了几种瓶装饮料，并从不同角度拍摄了多达一千张照片。
Examples of data we collected to train the BarHelper AI
这大概也是你应该做的。确定一个目标，然后考虑哪些数据可以帮助你实现这个目标。然而，重要的是，你只在有意义的数据上训练你的人工智能。你无法通过向任何人工智能提供藏着可乐罐的汽车图像来教它识别可乐罐。
听听 Lemberg 首席数据科学家帕夫洛·特卡琴科的话:“为了训练一个人工智能产生你期望的结果，你应该给它与这些结果有明确、有意义联系的训练数据。你永远不要指望人工智能能建立你自己无法建立的联系。”
你不仅需要相关的训练数据，还需要大量的数据。但是多少训练数据足以开始开发一个 AI 呢？
估计你需要多少训练数据来开始
一个很好的经验法则是你拥有的高质量训练数据越多，你能开发的 AI 就越好。然而，如果你想更精确一点，看看你的解决方案有多复杂，你需要它有多精确。
例如，在开发风力涡轮机异常检测系统时，帕夫洛·特卡琴科必须创建一个解决方案，能够快速且极其准确地检测系统行为中的任何异常。鉴于风力涡轮机的整体复杂性和人工智能的要求，帕夫洛需要至少一年的风力涡轮机传感器读数，以 5 到 10 分钟的间隔持续记录。
这些数据足以教会人工智能在全年不同天气条件下正常的风力涡轮机性能。一旦人工智能了解到正常的性能，它就能够提前两天准确地检测到系统行为的异常。
以此类推，你应该准备足够的训练数据来完全包含你对人工智能的期望。为了帮助您得出正确的结论，我们建议您:
- 与行业专家交流
- 想想人工智能会有多复杂
- 决定你需要人工智能有多精确
- 如果可以的话，总是获取更多的数据
与行业专家交流
你对开发人工智能解决方案的领域了解得越多，你就越有可能创造出有价值的产品。即使你认为自己无所不知，也要考虑尽可能多地从行业专家那里获取意见。每一个新的输入都可以帮助你提出一个稍微好一点的解决方案，即使是最微小的优势也可以让你在竞争中脱颖而出。
行业专家可以帮助你发现你以前可能没有注意到的数据之间的联系。这将帮助你找出什么样的训练数据可能是最有用的，并可能促使你考虑使用你以前没有考虑过的数据。
想想人工智能会有多复杂
请记住，人工智能所做的只是将输入与输出相匹配。它以创造性的方式做到这一点，并且可以同时保存许多输入和输出，但本质上这就是它所做的全部。你的人工智能需要的输入数量决定了它的复杂性。通常，你需要的数据样本至少是输入的十倍。
例如，要构建一个智能内容推荐系统，你需要分析你的读者的行为，这可以通过收集关于读者的数据来完成。假设您将收集五个数据点:年龄、性别、居住国家和查看次数最多和最少的文章标签。这些都将成为你的人工智能的输入。所以要通过这五个数据点来分析用户，你需要从至少 50 个人那里收集数据。要分析的输入越多，需要的训练数据就越多。
决定你需要人工智能有多精确
根据您正在构建的系统，您可能有不同程度的容错能力。尽管人们总是希望系统尽可能精确，但可以说，医疗监护仪对错误的容忍度远不如智能广告宣传。
决定你允许的容错程度，并以此为基础开展工作。你希望人工智能越精确，你就需要越多的训练数据。
总是获取更多数据
如果你有一个明确的目标，并且坚持不懈地收集有意义的数据，那么总是要尝试收集更多的数据。如果存在，是因为数据的质量往往比数量更有意义。然而，随着人工智能的发展，我们总是会回到第一条规则:你拥有的高质量数据越多，你的人工智能就越好。
因此，尽早建立有效的数据收集和准备流程非常重要。
建立一致的数据收集和准备流程
决定了目标，选择了要收集的训练数据，并估计了开始需要多少数据后，您可以开始为您的 AI 实际收集和准备训练数据。
您收集培训数据的过程将根据您设定的目标而有所不同。它可能包括汇总销售数据、调查客户和用户、收集传感器读数等。现阶段唯一真正的建议是保持数据收集的一致性。
每个新的训练数据集必须具有与前一个相同的输入。如果您的第一个数据集包含用户的年龄、性别和母语列，那么您的下一个数据集也应该包含相同的列-不多也不少。不应该有一个包含年龄、性别和母语的训练数据集，另一个包含年龄和性别，第三个只包含年龄。如果不一致，人工智能将无法理解训练数据。
我们说应该和不应该，因为不一致不会在数据收集阶段制造或破坏人工智能。总是有办法在以后完善数据，但是如果您能够从一开始就收集一致的数据，您真的不想浪费时间清理和格式化数据。
为了收集 BarHelper 的训练数据，我们的工程师拍摄了几个瓶子的照片。然而，照片本身不足以训练人工智能。
我们通过建立图像失真算法来补救这种情况。它扭曲、拉伸、调整大小、模糊，并通过其他方式扭曲瓶子图像，以复制不同相机在不同情况下可能查看瓶子的方式。这有助于我们为训练数据集带来必要的数量和多样性。
这就是数据准备的内容:你获取你所拥有的任何数据，并应用各种技术使其对你的人工智能完美。您可以专注于向数据集添加更多数据，就像我们对 BarHelper 所做的那样，或者减少数据量以确保其质量和一致性——或者根据需要执行这两种操作。
清除丢失值的数据
缺失的值会大大降低你的 AI 的准确性。您可以用虚拟值或平均值替换丢失的值来修复它们。如果无法填充缺失的行和列，您也可以考虑将它们一起删除:拥有较少的干净数据比拥有大量的脏数据要好。
格式化数据以保持一致性
如果您的数据集聚集了来自不同来源的数据，或者如果不同的人负责在不同的时间更新它，确保记录的一致性。例如，所有的日期必须遵循相同的格式，所有的地址应该以相同的方式填写，所有的货币价值应该遵循相同的风格，等等。
使单位一致
使用一致的单位很重要，因为这将提高人工智能的速度和准确性。不应该同时有千克和磅的值，也不应该把不同的货币混在一起。将所有相同类型的值放入相同的单位:将所有重量转换为千克，将所有货币转换为美元，以此类推。
分解复数值
有时，你会收集复合值，人工智能将能够理解它们。然而，有些情况下你需要将复杂的值分解成简单的值以便更快更准确地处理:将月分解成天，将大的注释分解成关键字，等等。
聚合简单值
或者，有时小而具体的值会妨碍 AI 效率。为了补救这一点，将较小的数据点合并成较大的数据点:不是按照精确的年龄而是按照年龄范围对用户进行分组；不收集单一的传感器读数，而是计算给定一天或一周的平均值，等等。
这份数据准备技术清单远非详尽无遗。根据任务的不同，数据工程师可以选择以各种方式转换数据，确保他们可能从人工智能中获得的最高准确性和效率。
摘要
你的第一步应该是确定你到底想要实现什么。一个明确的目标将帮助你决定你需要收集哪些数据，并估计你需要多少数据来开始。然后，您仍然需要认真对待收集和准备数据的本质——对于在数据科学和工程方面几乎没有实践经验的人来说，这是一个令人疲惫的过程。
这就是为什么我们强烈建议雇佣有经验的数据科学家和工程师来帮助你开发最好的人工智能。
给我们写一封短信了解 Lemberg 如何帮助你开发一个出色的人工智能系统。
最初发表于【https://lembergsolutions.com】。
数据可视化如何防止误传？
图表、图形、地图和图解不会说谎。设计它的人会。
Science Valentine from xkcd - Randall Munroe
数据可视化方法涉及图形表示的设计，以总结分析过程中的数据。
从这第一个陈述来看，让公司理解假信息和假信息可能代表的风险是很重要的。
虽然假信息被定义为“故意且经常秘密传播的虚假信息，以影响公众舆论或掩盖真相”，但假信息与众不同。所以没错，图表会误导人。而且，我们都会同意，有时，实现没有任何错误信息风险的美学可视化是一门真正的艺术。然而，我们需要记住的是图表、图形、地图和示意图只是分析结果的图标。
误传是如何发生的？
这并不意外。一个图形可以通过集体意义的使用引发错误的见解，这种集体意义往往偏向于自我确认。无论是通过暴露、过度简化还是世界观，通过数据可视化得到的错误信息都是基于个体和各种成分的。
我个人偏爱的特拉维斯综合症，这种人往往会高估当下的意义。但是，他们还有很多其他人:
- 单纯接触效应:人们因熟悉事物而产生偏好的效应。
- 熟悉度逆火效应:熟悉度增加人们接受真实信息的机会的效应。
- 矫枉过正的逆火效应:较少的信息和更容易处理的信息更容易被接受为真实的效应。
- 确认偏见:以确认一个人已有信念的方式搜索、解释、关注和回忆信息的倾向。
- 世界观逆火效应:对一个人坚定信念的事实和反驳只会强化这些信念的效应。
这种偏差样本可用于制作误导性图表，这提高了考虑这些偏差对商业和经济决策以及人类总体行为产生影响的重要性。认知偏差的完整列表可在这里 获得。
Designed by John Manoogian III — Categorized by Buster Benson
在数据可视化中，可以使用哪些技术来防止有偏见的视图？
遵循可视化的 4 个支柱
当你对以下问题回答“是”时，你就认为可视化是成功的:
- 目的明确吗？由于目的规定了可交付成果，因此需要明确定义。
- 内容是否支持目的？考虑到包含的内容和排除的内容同样重要，只需要包含相关的内容。提醒一下，内容，即现实和数据之间的关系，必须始终去政治化和政治化。
- 结构是否揭示了内容？需要用一个合适的结构来清晰地表现现实和图形之间的关系。
- 可视化有助于消费吗？可视化，是图形和数据之间的链接，必须通过突出显示重要的内容并删除其余内容来发挥作用。
通过使用这四个支柱，图形的创建可以最接近现实和数据。越是远离这些条件的图形，越会导致歧义。
学习格式塔原则
格式塔这个术语的意思是“形式”或“形状”。在心理学中，格式塔是指当作为一个整体考虑时具有特殊性质，但当作为单独部分考虑时并不明显的东西。
心理学家马克斯·韦特海默、沃尔夫冈·科勒、库尔特·考夫卡以及后来加入的库尔特·勒温研究了感知，并得出结论:感知者应该被认为是主动的，而不是被动的。事实上，他们认为感知者不只是收集信息。为了理解数据，他们主动处理和重组数据。这是一个感知过程，某些因素会影响这一感知过程。
根据格式塔心理学:
- 我们倾向于用大脑看事情。
- 头脑把外部刺激理解为整体，而不是部分的总和
- 我们倾向于在的基础上有规律的、有序的、对称的和简单的来排列我们的经验。
Key principles of Gestalt
注意所有的技巧
from xkcd — Randall Munroe
- 建立相反的故事:引入不相关的信息，鼓励我们对较大的部分赋予较大的价值。 (Cudmore，2014)
- 坏的/错误的标度:改变 Y 范围讲述了一个不同的故事，(Jones 2006—Peltier 2011)
Shut up about the Y-axis — Vox
- 摘樱桃:将信息隐藏在其他数据中，以缓和影响。
- 错误的因果关系:根据格式塔原理，当两条或更多的线一起出现在图表中，并且它们看起来彼此相似，我们倾向于假设它们是相关的。 (Cudmore，2014)
- 【邪恶的】政客:描绘政客们经常用来夸大斜坡、衰退、增长的伎俩。(安德伍德，2013)
- 花里胡哨的样子:用来在你应该关注信息的时候分散你的注意力。
- 不公正地划分选区:操纵地理边界对数据进行分组，以改变结果。(参见格式塔:邻近法则)
- 通过操纵隐藏差异:要么对一张图片使用不同的尺度 (Brown，2013) 、累积数据、时间间隔 (Huff，1993) 、绝对值，要么使用对数尺度来看起来不那么引人注目。(安德伍德，2013)
- 省略数据:主要用于饼图/圆环图，在作为一个整体呈现之前排除缺失的记录。
- “视错觉”使用 3D: 很难区分什么对象是背景，什么是前景，很难解释图形，以及在给定周围颜色的情况下，对象的颜色在哪里被不同地感知。
- 过度拟合:创建一个过度适应你现有数据的模型，它不能代表总体趋势。
- 面积感知:通过不标注标签来评估一个结果所占比例的难度。(怀特洛-琼斯，2013)
- 均值的问题:当一个方向或另一个方向存在异常值时，均值具有误导性。在这种情况下，中值或众数更好。 (Vembunarayanan，2014)
- 抽样偏差:从不代表总体的样本中得出结论。 (Vembunarayanan，2014)
- 辛普森悖论 (与“摘樱桃”相反) :当一个趋势出现在不同的数据子集中，但在组合各组时消失或反转。
- 尺寸作为错误的指标:容易因不恰当使用气泡尺寸而产生误导。
- 将数据分割成许多图表:来自每个类别的各种观察总是在一个条形图中更好。(考希克，2014)
如果还不够，你还可以****使用“谎言因子”
不太引人注意但同样重要的是，爱德华·塔夫特提出了一个叫做“谎言因子”的公式来计算图形的精确程度。谎言因子越接近 1.0，图形越精确。
The “Lie Factor” — Edward Tufte (1983)
数据就是力量，可视化就是力量的运用。更多的观众将准备好处理数据驱动的视觉效果，他们将能够识别和避免错误和谎言。不幸的是，无论我们如何指出和谴责误导性图表，我们永远不会让它们消失。所以，如果你认为一个可视化不准确、清晰、知识性、教育性、非政治化、包容性、真正的、支持性和非判断性，不要让自己上当。通过提问来消除噪音。毕竟，数据可视化永远不应该被认为是某种真理，而只是用来显示显而易见性、事实和支持论点。
想获得更多操作指南吗？ 上还有很多 😃
如何防止种族主义机器人
什么是算法公平，为什么它很重要？
你遇到过这种情况吗？
你在给你的同事讲故事，你提到了你的种族(不是白人)。突然，你的(白人)同事打断你并宣布:
You sure about that, Chad?
和你的老板谈论与你的女性身份有关的事情？为什么你一定要把性别带进来？如果你想被平等对待，那就不要提醒我你是女人。”
想结婚，摄影师却拒绝你服务？“你是同性恋只是巧合！我听着不像是歧视！”
在美国有许多受 T4 压迫的人群。系统性压迫是复杂的，但我们闭上眼睛，塞住耳朵，并不意味着不公正将不复存在。这只意味着我们站在它的中间，忽略它。
无知不是福。这只会让你变得无知。
尽管如此，许多人不理解或试图理解有色人种、女性、LGBTQ 人群、不同能力人群或其他任何目标人群的经历。他们选择忽略“他者”应该指出的是，这往往是善意的，但其结果却恰恰相反。机器每天做出的某些决定也是如此。
在他们的学术文章“算法公平”中，作者提出，如果我们(和我们的机器)想要利用这些信息做出重要决策，我们应该包括种族和其他代表受压迫群体的因素。如果我们忽视这些重要的因素，我们会弊大于利。为什么？我们来分解一下文章是怎么说的。
算法是一组步骤、规则或计算，计算机通常都有自己遵循的算法。我们越来越普遍地使用算法来做决策。仅举几个常见但重要的例子:医生决定某人是否有患病风险，法官设定保释金，学校分析申请。
一次又一次的事实表明，我们的“机器人”正在接受我们人类的偏见，做出歧视性的决定。来自文章:
因为用于训练这些算法的数据本身带有刻板印象和过去的歧视，所以很自然地会担心偏见正在被“烤熟”
因此，一个常见的反应是排除敏感因素，训练机器人宣布:
为什么这是个坏主意？在说之前，我们必须知道一个关键词的定义:公平。公平意味着公正。相等意味着“相同”因此，请记住，公平并不意味着平等。
The Difference Between Equality and Equity
当我们平等待人时，我们给予每个人同样的支持。当我们公平对待他人时，我们会给予每个人所需的支持，这样结果才会公平。
当然，我们的世界更加复杂…
Another idea: True liberation means no one cares about watching the game?
…但是这些知识足以帮助我们理解这篇文章。文章做了这样一个实验:
想象一下，我们有两个不同的大学招生顾问。一位名叫埃里卡的辅导员很有效率。Erica 的目标始终是录取在大学期间表现最好的学生。所以，她看着学生的申请，她使用机器学习模型来预测那个学生的大学平均绩点会是多少。艾丽卡所要做的就是选择最有潜力的学生。
另一个顾问法拉是公平的和高效的。Farrah 也想要最有潜力的学生，但她对申请者一视同仁。在实验中，他们将学生群体限定为非西班牙裔白人学生和黑人学生。因此，预测模型中唯一需要“不同”处理的变量是种族。Farrah 必须选择大学 GPA 最高的学生，确保有一定比例的黑人学生。
所以埃里卡是有效率的，她只想要在大学里表现最好的申请者。法拉是公平的，她希望申请人在大学里表现最好结合她想最大限度地增加黑人学生的数量。
他们使用的模型能够预测大学的 GPA，因为实验涉及到随着时间的推移跟踪申请人。所以，他们有一堆高中数据以及他们最终的大学平均绩点来显示他们在大学的真实表现。
Erica 以两种方式运行这个模型:排除种族，包括种族。不管是哪种模式，记住她总是有效地选择——预测平均绩点最高的学生。
Farrah 运行了包括种族在内的模型，她设置了不同的阈值，试图消除黑人申请者可能遇到的一些系统性偏见。例如，我们可能会担心一个黑人申请者没有参加 SAT 预备课程，而一个白人学生参加了。然后，如果这两个学生获得相同的 SAT 分数，该模型将预测黑人学生将有更高的大学 GPA。这只是 Farrah 对模型阈值进行的许多复杂调整中的一个例子。
结果非常棒:
- 最能预测申请人在大学表现的模型总是将种族因素考虑在内，即使在 Erica 的案例中，她只关心效率。这可能看起来违反直觉或令人困惑。换句话说，当人们处理申请并猜测申请人将如何上大学时，它带有我们所有的偏见，所以我们经常想从等式中去掉种族，以欺骗自己认为我们是公平的。然而，实际上由一个数学模型为我们做出预测更有效(准确)，因为他们的预测是基于数字，而不是基于有偏见的预感。因此，在模型中包含种族因素会更有效。
- 当 Farrah 对门槛进行公平调整时，无论她试图录取多少比例的黑人学生，使用种族意识预测器都会导致相对更多的黑人申请人被大学录取。因此，为了更加公平，有必要在模型中包含种族因素。
- 总之:永远包括种族。机器人应该能看到颜色。
“在没有法律约束的情况下，出于公平原因，我们应该纳入性别和种族等变量……纳入这些变量可以提高公平和效率。”
他们使用各种机器学习模型进行了这项实验，但他们一致发现，“让算法盲目进行种族划分的策略无意中损害了公平性。”
虽然这篇文章有一个老生常谈的结论，但解决算法偏差并不容易。我们如何定义什么是公平的？正如另一位名叫莎拉·谢弗勒的研究员指出的:
有许多不同的衡量公平的标准，它们之间有所取舍。那么……系统在多大程度上符合我们想要实现的公平理念呢？
即使一些科学家同意什么是公平的，我们也经常必须确保用不同的公平阈值实现我们的算法是合法的。正如我们在平权法案的历史中所看到的，举个例子，对于什么应该被合法实施，经常会有不同的意见。
我对几件不同的事情充满希望:
- 我希望我们能利用与他人相处的受教育机会，向他们解释为什么正确看待一个人的整个环境是非常有价值的，而不是抱着“无知是福”的心态。
- 我也希望那些受分析推理驱动的人能够理解像我们刚刚重复的文章。我们通过在我们的科学中包括像种族这样的受保护的因素，而不是忽视它，来尽可能做出最好的预测。这有利于所有人，不管我们对“公平”的定义是什么。
我们希望这两种情况能够汇聚成一个社会，在机器的帮助下，不断地为更大的利益做出决定。
如何用 12 种最流行的编程语言打印“Hello World”
Img source: yen.io
你好，世界！
当你开始学习编程时，或者当你只是在学习一门新的编程语言时，首先要做的事情之一就是做一些非常简单的事情。你要做的第一步是打印一个简单的文本。当你读这篇文章的时候，你可能知道哪一篇文章是最常见的，也是我所指的那一篇。
我正在谈论的文本是你好世界。
当你刚刚踏上一个重要的旅程时，这篇文章应该是你向世界问候的一种方式。尽可能多的学习之旅。
如果你很好奇，想看看如何在 12 种最流行的编程语言中做到这一点，那么让我们开始吧。不过在我们开始之前有一件事:流行度的排序是基于 GitHub 和 Tiobe 的，正如这里的所示。
1.Java 语言(一种计算机语言，尤用于创建网站)
2.C
3.计算机编程语言
4.C++
5.C#
6.Visual Basic。网
7.Java Script 语言
8.服务器端编程语言（Professional Hypertext Preprocessor 的缩写）
9.目标-C
10.结构化查询语言
11.红宝石
12.矩阵实验室
这些例子来自下面的库，在那里你可以找到更多的例子。
它是开源的，如果你知道其他没有列出的编程语言，你也可以对它做出贡献。
如何从零开始编程 UMAP
生命科学的数理统计和机器学习
以及如何改善 UMAP
这是我的专栏 生命科学的数理统计和机器学习 的第十三篇文章，我试图解释一些在生物信息学、生物医学、遗传学等领域使用的神秘分析技术。以一种简单的方式。在上一篇文章 中，我首先直观地解释了 UMAP 背后的数学原理。学习它的最好方法是从头开始为 UMAP 编程，这就是我们今天要做的。这篇文章的想法是要表明，每个人都可以相对容易地创建自己的邻居图降维技术，这种技术甚至可以提供比 UMAP 更好的可视化效果。这将是大量的编码，扣好安全带！
构建高维概率
作为测试数据集，我们将使用癌症相关成纤维细胞(CAFs) scRNAseq 数据。我们从导入 Python 库(主要使用 numpy 和 scikit-learn)开始，查看数据矩阵并检查数据集的维度。请注意，这里的行是细胞，列是基因，最后一列包含聚类结果的编码，即每个细胞属于 id 为#1、2、3 和 4 的 4 个聚类之一:
从一开始就要定义的一个重要的全局变量是初始高维 scRNAseq 数据集的平方成对欧几里德距离的矩阵，这个矩阵将在未来的代码中大量使用。在这里，我们还定义了局部连通性 参数 rho ，作为到第一个最近邻居的距离，关于该参数含义的更详细解释，参见上一篇文章。
使用平方成对欧几里德距离的矩阵，我们将计算高维空间中的概率矩阵。知道了这个矩阵，我们可以很容易地计算出每个细胞的熵和最近邻的数量，k = 2^Entropy.请注意函数的自变量。这意味着作为的函数的概率矩阵将在以后用于二分搜索法过程，该过程为固定数量的最近邻居计算最优。**
这里的一个技巧是，为了方便起见，我们为每个第 I 个单元计算一个 1D 概率数组，这意味着为平方成对欧几里德距离矩阵的每个第 I 行(或列)(从第 I 个单元到数据集中所有其他单元的距离)。这样做是因为等式中有未知的 σ_i :
我们必须使用二分搜索法来为数据集中的第 I 个单元格找到 σ_i 。对于每个第 I 个单元格，给定高维概率的 1D 数组，我们可以对数组的元素求和，并根据定义计算最近邻的数量， k :
所以现在我们有了一个函数，它为每个第 I 个单元格的每个 σ_ i 生成最近邻的数量、 k 、(标量)值。我们可以固定最近邻值的数量(期望的 k 超参数)并将该函数输入到二分搜索法过程中，以便计算每个第 I 个单元的 σ_i 。
计算 σ_i 对于每个细胞，我们得到 n 个细胞的概率 1D 阵列，它们一起构建了一个高维概率矩阵。根据 UMAP 算法，该矩阵必须满足对称条件:
然而，根据我的经验，下面更简单的对称条件提供了一个更好的可视化，我们将在后面看到。
我鼓励读者尝试不同的方法来获得高维概率的对称矩阵，并检查最终的可视化是如何变化的。
构建低维概率
接下来，我们将计算高维相邻图的布局，即根据 UMAP 定义的低维概率矩阵:
由于 UMAP 算法的目标是找到低维嵌入的最佳坐标， y_i ，其通过梯度下降过程被更新，我期望 a 和 b 参数也应该在每个梯度下降迭代中被更新。然而，在最初的 UMAP 算法中，它们似乎在最开始就被固定为 min_dist 超参数的期望值:
同样，在这里我看到了改进和实验的空间。为了简单起见，下面我将设置 a=1 和 b=1 ，以便得到一种 UMAP 和 tSNE 的混合。那么低维概率矩阵由下式给出:
学习低维嵌入
最后，我们将编码 UMAP 的代价函数，即交叉熵，请参见上一篇文章了解该代价函数如何保持全局距离的详细信息。实际上，我们感兴趣的不是交叉熵本身，而是稍后将在梯度下降过程中使用的梯度。
请注意 CE_gradient 函数中的 Q 矩阵。不应该根据 UMAP 算法对其进行归一化。然而，根据我的经验，这种规范化提高了低维可视化。我再次鼓励每个人在这里尝试。最后，我们用图拉普拉斯算子初始化低维嵌入的坐标 y_i ,并启动梯度下降过程:
交叉熵似乎在减少，并达到一个平台。请注意，这里为了简单起见，我实现了常规梯度下降，而不是 UMAP 最初实现使用的随机梯度下降。这是因为这篇文章的目的是展示 UMAP 的想法，而不是提供一个优化的漂亮的代码。现在，我们可以将低维嵌入可视化:
我们还可以很容易地动画显示不同的聚类是如何从拉普拉斯嵌入开始形成的，这是通过将每次迭代的图合并到 gif 文件中来完成的。
UMAP 的从头实现看起来工作良好，4 个细胞群的集群清晰可辨。如果我们在上面的低维嵌入中运行聚类算法，那么它们在识别细胞群体时不会有问题。
让我们将上图与最初的 UMAP Python + numba 实现进行比较。我们将使用 n_neighbors = 15 和 min_dist = 0.25，即与之前的从零开始 UMAP 实现中相同的 UMAP 超参数值。
我们在这里可以看到，从某种意义上说，与最初的 UMAP 实现相比，从头开始的实现提供了更独特的集群。这是由于在方法上应用了小的改变，例如略微不同的对称条件和交叉熵梯度中 Q 矩阵的归一化。
摘要
在这篇文章中，我们了解到用 Python 从头开始实现 UMAP 相对容易。因此，我的预测是，UMAP 只是一个开始，在不久的将来，单细胞基因组学研究领域将会出现更多、可能更好的降维技术。很简单调整低维和高维分布，制定更好的标准化和对称条件，更好的成本函数，并利用吸引力/排斥力来解决 N 体问题，以获得更好的低维表示。
在下面的评论中让我知道生命科学中的哪些分析技术对你来说似乎特别神秘，我会在以后的帖子中尽量涉及它们。检查我的 github 上的帖子中的代码。在 Medium 关注我，在 Twitter @NikolayOskolkov 关注我，在 Linkedin 关注我。下一次，我将转向进化生物学，并展示如何利用古代 DNA 来估算种群数量，敬请关注。
如何在线发布 Jupyter 笔记本——10 分钟内使用 AWS！
无论您是在构建您的数据科学组合，还是需要与同事或朋友共享资源，了解如何在 AWS 上在线发布 Jupyter 笔记本都非常重要。
期待结果
在本文结束时，您将拥有一个可以通过互联网访问的 Jupyter 笔记本，网址如下:
Example result of this tutorial
步骤 0:创建 AWS 帐户
首先，你需要一个 AWS 账户。在这里设置非常容易。拥有一个账户是免费的，因为你为你使用的服务付费。
对于新帐户，AWS 在第一年给予巨大的折扣，称为免费层，本文中介绍的所有内容都是免费的。如果你是一个有经验的 AWS 用户(没有免费层)，你将为你的笔记本支付少量的流量。详见本文下面的免责声明。
对了，我和 AWS 没有隶属关系:我就是喜欢这种做法，所以想在这篇文章里和大家分享一下。
步骤 1:将 Jupyter 笔记本另存为。html 文件
为了使您的笔记本可以在线访问，您需要将其导出为 HTML 文件。HTML 是静态网站的语言，它将被 AWS 认可。
为了使您的笔记本可以在线访问，您需要将其导出为 HTML 文件。
- 在 Jupyter 笔记本上，当你的笔记本准备发布时，进入‘文件’→‘下载为’→‘HTML(。html)'
Save your Jupyter Notebook as HTML
- 使用网站 URL 可接受的名称(避免空格和某些字符)将 HTML 文件保存在您记得的位置。
步骤 2:创建一个 S3 存储桶
在 AWS 中，我们将使用 S3 服务。S3 是 AWS 服务，允许文件存储和建立静态网站。我们使用它是因为它很便宜并且很容易安装。
S3 是 AWS 服务，允许文件存储和建立静态网站。
S3 的所有东西都用所谓的水桶。存储桶就像一个文件夹，你可以把你的文件放在里面。要与 S3 合作，你必须做一个桶，让我们开始吧:
- 转到 aws.amazon.com 并登录 AWS 管理控制台。
- 在“服务”下拉菜单中，单击 S3
Navigate to S3
- 在 S3 菜单中，点击“创建铲斗”,将出现以下菜单:
Create an S3 bucket
- 作为一个桶名，注意使用一些适当的东西，因为它将是你的 URL 的一部分！作为一个地区，采取一些接近你的网站访问者会在哪里(虽然这并不重要)。然后单击下一步。
- 现在，他们会询问您的访问偏好。我们希望给予每个人访问权限，因为每个人都应该能够通过互联网访问您的笔记本。
Give everyone access to your website
- 在下一个屏幕中，单击 next 并创建 bucket。
步骤 3:将您的 bucket 配置为静态网站
S3 服务可用于制作静态网站，但也经常用作文件存储。
就访问权限而言，文件存储和网站托管并不完全相同:在网站上，你希望每个人都可以访问，而对于文件存储，你可能希望将访问权限限制在选定的一组人。
在本例中，我们希望托管一个静态网站，因此有必要按如下方式指定此 S3 存储桶的属性:
- 你的。html 笔记本实际上是所谓的静态网站，我们需要通过“属性”→静态网站托管来指定
AWS S3 Console
- 在“静态网站托管菜单”中，将“索引文档”设置为您的 HTML-notebook 文件的确切名称。
S3 Static Website Hosting
- 在这个菜单的顶部，你可以看到“端点”，这是你可以访问你的网站的终点。所以你最后会需要它。点击‘保存’继续。
步骤 4:上传您的笔记本
最后一步是将你的 HTML 笔记本上传到你的桶中。这样做很容易:
- 在“概览”菜单中，点击“上传”，然后拖放您的。步骤 1 中的 html 文件。
- 在‘设置权限选项卡’中选择‘授予公共读取权限’
AWS S3 access permissions
- 保留其他设置，单击下一步，然后发布。
仅此而已！您现在可以分享了！
只需在任何浏览器中使用步骤 3 中的 URL 即可查看您的笔记本。
Our Jupyter notebook is online!
祝贺您，现在全世界都可以访问您的文件了！
免责声明:
除非你有很大的流量，否则这种方法是免费的，如果你在 AWS 免费层(你的 AWS 帐户的第一年)，并且在第一年后有一个非常小的月费。我与你分享这种方法，因为我喜欢它。我和 AWS 没有任何关系，有很好的替代品，例如 GitHub pages 或 GitHub Gists，或者任何其他云提供商。无论使用这种方法还是其他方法，我都不接受 AWS 上发生的任何费用的任何责任或义务。
AWS source of billing information
非常感谢您的阅读，敬请关注更多精彩的数据科学文章！
如何将你的机器学习放入 Docker
你是一名数据科学家，你了解业务问题，你收集数据，执行一些功能工程，并提出了一个惊人的机器学习模型，可以在本地 IDE 上很好地预测东西。
但是接下来呢？
换句话说，如何将您的模型部署到生产环境中，或者轻松地与其他人共享，以便他们可以在本地 PC 上运行和评估它，并在看不见的数据上运行，无需安装任何库、依赖项、图形界面(IUPython、Jupyter Notebook..)，或者查看您的代码。
Docker 是这个问题的答案之一，因此，我们将在接下来的段落中看到如何将你的模型包含在一个 Docker 中，并将其分发给其他人。
在这个例子中，我们将使用一个简单的线性回归模型。
让我们从启动我们的库开始:
import warnings
warnings.filterwarnings(**"ignore"**, category=FutureWarning)
import sys
import pandas as pd
from sklearn.linear_model import LinearRegression
之后，我们将需要导入数据:
训练数据:我们的模型将从中学习的数据。
测试数据:将由任何需要根据看不见的数据评估你的模型的人引入。
测试数据和训练数据应该有，很明显，与外形相同的。
TestData = sys.argv[1]
# Read the data that will serve for training and the test data
X_full = pd.read_csv(**"TrainingData.csv"**, index_col=**'x001'**)
# Read the data that will serve for testing
X_test = pd.read_csv(**TestData**, index_col=**'x001'**)
我们将把目标数据从整体数据中分离出来:
#separate target from predictors in both training and test data
y = X_full.y
y_test=X_test.y
X_full.drop([**'y'**], axis=1, inplace=True)
X_test.drop([**'y'**], axis=1, inplace=True)
然后，我们将应用我们的模型:
model=LinearRegression()
model.fit(X_full,y)
preds = model.predict(X_test)
接下来，我们将把预测输出结果保存在文件 outputTest.txt. 中
# Save test predictions to file
output = pd.DataFrame({**'Id'**: X_test.index,**'Y Original'**: y_test, **'Y predicted'**:preds})
output.to_csv(**'/data/outputTest.txt'**, index=False)
现在我们已经有了基本模型，我们将试着把它放到一个 docker 上。
为此，我们首先需要创建 docker 映像创建所需的文件，即 Dockerfile 和 requirement.txt
DockerFile:
FROM python:3
COPY Your_python_code.py./
COPY requirements.txt ./
COPY **TrainingData.csv** ./
RUN pip install -r requirements.txt
CMD ["python", "wallet.py", "/data/**testData.csv**"]
requirements.txt(不需要下载数学库，因为它会自动添加 python3)。
pandas
sklearn
然后，我们将 TrainingData.csv、Your_python_code.py DockerFile 和 requirements.txt 放在同一个文件夹中，打开一个终端，转到该文件夹，启动以下程序:
docker build -t <your_docker_image_name> .
# dont forget the . at the end.
然后，我们将图像推送到我们在 DockerHub 中的帐户(我们假设您在 docker hub 上有一个帐户，如果没有，您可以免费创建一个，然后在您的 PC/MAC 上启动 docker 应用程序) :
docker push <your_docker_image_name>
现在你的模型在 Docker hub 中，你可以与你的朋友分享它。你可以要求他们做以下事情:
1-从 Docker Hub 获取图像:
docker pull <your_docker_image_name>
2-运行容器:
docker run -v <path>:/data/ <your_docker_image_name>
其中
在这个例子中，您的文件应该按照 requirements.txt 命名为testdata . CSV
示例 :
如果您的 testData.csv 在/var/files/中，那么您应该运行:
*docker run -v /var/files/:/data/ <your_docker_image_name>*
输出 :
将创建一个输出文本文件 outputTest.txt ，包含 3 列:
ID、Y 的实际值和 Y 的预测值。
输出将保存在 <路径> 目录中，在上面的示例
中，输出将保存在 /var/files/ 中，并命名为
outputTest.txt
请在这个要点上找到完整的代码。
一如既往，希望你学到了新东西:)
萨拉姆。
如何生产 PyTorch
Photo by Sharon McCutcheon on Unsplash
ML 好玩，ML 流行，ML 无处不在。大多数公司使用 TensorFlow 或 PyTorch。例如，有些老同性恋更喜欢咖啡。大部分都是关于谷歌和脸书之战。
我的大部分经验都去了 PyTorch，即使大部分教程和在线教程都用 TensofFlow(或者希望是 bare numpy)。目前，在 Lalafo(人工智能驱动的分类)，我们正在与 PyTorch 玩得开心。不，真的，我们试过 caffe，它太棒了，除非你还没有花几天时间安装它。更好的是，PyTorch 现在是 1.0，我们从 0.3 开始使用它，它非常简单和健壮。啊啊..也许这里稍微调整一下，那里稍微调整一下。大多数问题都很容易解决，没有给我们带来任何问题。在公园散步，真的。
在这里，我想分享在生产中使用 PyTorch 最常见的 5 个错误。考虑用 CPU？多线程？使用更多的 GPU 内存？我们已经经历过了。现在让我也来引导你。
错误# 1——在推理模式下存储动态图
如果您以前使用过 TensorFlow，您可能会意识到 TF 和 PT 之间的关键区别——静态图和动态图。由于每次模型改变时都要重建图形，所以调试 TFlow 非常困难。这需要时间、努力和你的希望。当然现在 TensorFlow 更好。
总的来说，为了使调试更容易，ML 框架使用了与 PyTorch 中所谓的Variables相关的动态图。您使用的每个变量都链接到前一个变量，为反向传播建立关系。
下面是它在实践中的样子:
在大多数情况下，您希望在模型定型后优化所有计算。如果你看火炬界面，有很多选项，特别是在优化方面。eval模式、detach和no_grad方法造成的很多混乱。让我解释一下它们是如何工作的。在模型被训练和部署后，这里是你关心的事情:速度，速度和 CUDA 内存不足异常。
为了加速 pytorch 模式，你需要将它切换到eval模式。它通知所有层在推理模式下使用 batchnorm 和 dropout 层(简单说就是停用 dropout)。现在，有一种detach方法，它从计算图中删除变量。当你从零开始构建模型时，它是有用的，但是当你想要重用最先进的模型时，它就不那么有用了。一个更全局的解决方案是在torch.no_grad上下文中向前回绕，通过不在结果中存储图形链接来减少内存消耗。它节省了内存，简化了计算，从而提高了速度，减少了内存的使用。答对了。
错误 2——没有启用 cudnn 优化算法
在 nn 中有很多布尔标志可以设置。模块，你必须知道的存储在 cudnn 命名空间。使用cudnn.benchmark = True启用 cudnn 优化。为了确保 cudnn 寻找最优算法，通过设置cudnn.enabled = True启用它。NVIDIA 在优化方面给你带来了很多好处。
请注意，您的数据必须在 GPU 上，模型输入大小不应变化。数据的形式越多样化，可以进行的优化就越少。例如，为了标准化数据，可以对图像进行预处理。总的来说，要有创意，但不要太多。
错误 3——重用 JIT 编译
PyTorch 提供了一种简单的方法来优化和重用来自不同语言的模型(阅读 Python-To-Cpp)。如果你足够勇敢，你可能会更有创造力，用其他语言注入你的模型(我不是，CUDA: Out of memory是我的座右铭)
如果输入的形状不变，JIT 编译允许优化计算图形。这意味着如果你的数据没有太大的变化(见错误 2 ), JIT 是一个不错的选择。老实说，与上面提到的no_grad和cudnn相比，这并没有太大的不同，但是可能会。这只是第一个版本，潜力巨大。
请注意，如果您的模型中有conditions，它将不起作用，这在 RNNs 中是常见的情况。
完整文档可在 pytorch.org/docs/stable/jit网站上找到
错误#4 —试图使用 CPU 实例进行扩展
作为云中的虚拟机，GPU 非常昂贵。即使你查 AWS 一个实例也要 100 \(/天左右(最低价 0.7\)/h)参考:aws.amazon.com/ec2/pricing/on-demand/。我使用的另一个有用的备忘单是 www.ec2instances.info 每个从 3d 年级毕业的人都会想:“好吧，如果我买 5 个 CPU 实例而不是 1 个 GPU 会怎么样”。试过在 CPU 上运行 NN 模型的人都知道这是个死胡同。是的，你可以为 CPU 优化一个模型，但是最终它还是会比 GPU 慢。我强烈建议放松一下，忘掉这个想法，相信我。
错误 5——处理向量而不是矩阵
cudnn-检查no_grad-检查GPU with correct version of CUDA-检查JIT-compilation-检查
万事俱备，还能做什么？
现在是时候运用一点数学知识了。如果你记得大多数神经网络是如何使用所谓的张量来训练的。张量从数学上讲是一个 N 维数组或者多线性几何向量。你可以做的是将输入分组(如果你愿意的话)到张量或矩阵中，并输入到你的模型中。例如，使用图像数组作为发送到 PyTorch 的矩阵。性能增益等于同时传递的对象数量。
这是一个显而易见的解决方案，但很少有人真正使用它，因为大多数时候对象是一个接一个处理的，从架构上建立这样的流程可能有点困难。别担心，你会成功的！
下一步是什么？
关于如何在 PyTorch 中优化模型，肯定有更多的技巧。我会继续张贴我们在野外使用脸书小子的经验。你呢，你有什么技巧可以在推理上取得更好的表现？
原载于 2019 年 2 月 18 日【tarasmatsyk.com】。
如何在生产中 Pytorch:第 2 部分。体系结构
Photo by Isaac Smith on Unsplash
最近我做了一个关于将 PyTorch 模型部署到产品中的演讲。你可以在这里找到幻灯片事件驱动 ML 。简而言之，我们从一个简单的原型开始，到一个生产就绪的可扩展解决方案。在这篇文章中，我想分享我们的发现。
我们是谁，我们做什么
基本上，Lalafo 是一个分类器。如果你想卖旧手机，你可以找我们。这就是现代纸质广告。然而，这里的商业模式非常简单，我们真正想做的是把它带到下一个层次。到目前为止，常规发布时间大约需要 2 分钟。我们的目标是将这个时间减少到几秒钟。我不是在开玩笑。为了实现这一目标，我们需要变得更加技术化。我们的一个助手是 AI，它用于填充价格，描述，照片分类和我们关于用户和类似项目的数据。最终目标是这样的(简而言之:你拍一张照片，剩下的我们来做):
到目前为止，我们正在整合下一个版本的移动应用程序的所有内容，并进行用户测试，以确保它是一个爆炸。
这一切是如何开始的？
或者说，如何在一天内造出一个原型。
说实话，每当一个商业人士来找你说:“我想造一辆自动驾驶汽车，你能做到吗？”。当然，作为软件工程师，我们有解决方案。
我们该怎么办？就我个人而言，我会去谷歌上输入“stack overflow how to a self-driven car”->回车。第一个答案会告诉您使用 JQuery，第二个会提示您从哪里开始。这就是我们应对图像识别挑战的方式，开始非常简单，这里是我们选择的一组技术:
我打赌这对你来说是显而易见的，以下是你得到的结果:
- 用于 PyTorch 模型的带 GPU 的 AWS
- 龙卷风在它上面处理 10K 问题
- 用于缓存预测的 Redis
老实说，这样的设置每分钟可以分类大约 200 张图像，如果我被要求为另一个模型提供 PoC，任何基于 AWS 的 Redis 的 python 异步框架都可以胜任。
200 这个数字是怎么来的？
这完全取决于度量，这里是我们定义的成功的图像处理。我们的分类流程如下:
- 你给我们发送一张带有
POST请求的图片， - 然后您使用
GET来接收结果。 - 如果结果已准备好—图像处理速度足够快。
通常，需要 1 到 2 秒钟。考虑到这一需求，在线程池中运行 PyTorch 的 Tornado 每分钟可以处理 200 张图像。为什么选择 ThreadPool？等一下，我会解释的。
值得一提的是，我们有 8Gb 的 GPU 内存和大约 20Gb 的 RAM，其中 5Gb 由服务器消耗，原因是线程池和缓存队列。如果你想知道我们为什么不使用 ProcessPoolExecutor——那是因为 PyTorch，它不能很好地处理 python 并发，现在也不能。考虑到您必须考虑内存共享，线程池是一个非常简单的选择。我们幸福吗？没有。我们找到更好的方法了吗？我对此不太确定，不过，还有一种选择。
那又怎样？目前的方法有问题吗？
嗯，退一步说，AWS 很贵，线程化不是并行，Tornado 监控很难，伸缩性也不是那么明显(只是在 N 个 workers 服务器上面放上负载平衡器，我们称之为 python 方式)，ML 结果不持久等等。这就是我们开始考虑构建一个可扩展的分布式系统的地方。最初的计划是这样的:
我们有几个目标要实现:
- 监控。(将数据点发送到流入液中，并使用 Grafana 进行监控)
- 节省一些美元。(我们有机会采用 K8s，并选择 Hetzner 作为 it 提供商的 Linux 裸机)
- 能够根据要求进行扩展
- 玩得开心(我们决定采用 Go 进行数据处理和 API)
- 持久性(选择 PSQL 来存储分类结果，以便我们可以构建报告和分析历史)
- 可扩展(如果我们决定要添加更多的 ML，我们应该能够在最短的时间内完成)
- SDK 友好的(API 用户应该也很高兴)
我们最后去了哪里？让我们回顾一下组件
这是我们最后得到的结果:
让我们逐一回顾一下差异和组件
API 与 ML
主要决定是将与客户端和数据处理层的交互分开。最后，我们有了 Go+Swagger+PostreSQL API，它消耗大约 20Mb 或 RAM，工作非常好，可以扩展 10 倍，而无需考虑新服务器(是的，我们的数据中心容量有限，但是，K8s 通过增加额外的容量来解决它)。
问题是在这两者之间放什么呢？我们有不同的选择，从 Redis、RabbitMQ、HTTP/gRPC 开始，到 Kafka 结束。主要的两个优点是:易于扩展分区和消息缓冲。主要缺点是再平衡。如果您以前使用过它—您知道它，否则请在实现您自己的消息总线之前测试 Redis 或 RabbitMQ。
监视
因为我们有一个可用的流入服务器，所以发送一些数据点并使用 Grafana 监控它们是一个非常合理的选择。这是一个活系统看起来像 atm 的样子:
如果我们必须选择的话，我们可能会选择哨兵或者麋鹿栈，在它上面使用 APM 。
节省一些美元
AWS 的成本比其他产品高得多，甚至更贵。我们订购了几台 GeForce GTX-1080，在 Hetzner 上使用 8Gb GPU，节省了 10 倍美元。对欧洲非常有效。此外，我不会说它是超级可靠的，但是，如果你把两个集群和一个负载均衡器放在它们之间——一切都工作得很好。无论如何，即使是 5 个集群也比 AWS 便宜 2 倍，高效 5 倍，对不起 Jeff。
能够根据要求进行扩展
如果你曾经在 K8s 或 infrastructure 中尝试过 helm 作为代码，你应该知道这里的伸缩只是一行代码的变化。一旦你进入 K8s，你就很容易升级一个 pod。另一个问题是去那里有多难，但我们很幸运地在另一方面获得了一些专业知识。
开心
Go 很有趣，它是一种静态类型的编译语言，被宣称为框架本身。goroutine 不仅有名，如果您在生产或生活中有任何问题，只需添加 go routine，它就会得到解决。
虽然我们确实玩得很开心，而且 go 确实是一种设计良好的语言，但它仍然给我们带来了一些痛苦。如果你来自一个有 25 年历史的语言，它有很多很多库，看起来 Go 没有很多，这是真的。需要数据库？编写普通的 SQL。需要一个 API 服务器？编写自己的中间件和请求解析器。需要文档吗？幸运的是它在那里。当然，如果我们谈论大摇大摆，也不完全完整。
一方面，它节省了我们一些时间，减少了打字带来的痛苦，另一方面，它还不太成熟，即使是 10 年前的语言，你也需要回馈社区。没有人们告诉你的那么糟糕，也没有那么甜蜜。对此半信半疑。无论如何，它工作得很好，我们将在小服务中坚持使用它。
坚持
第一个里程碑是 Redis，因为它很简单。你把 json 放到内存里，它活的好好的。直到..你没有内存了。多加点内存就行了。正确。然而，如果你有处理内存结束相当快。对我们来说，15 分钟的工作大约需要 1Gb。让我们把它增加到 1 小时，你得到 4Gb。RAM 绝对是一种便宜的资源，但是，你知道什么更便宜吗？磁盘空间和在 2k19 SSD 便宜得要命，快得像兔子。
所以我们决定使用关系数据库，将数据反规范化并存储在 PostgreSQL 中。工作得很好，我们不会离开它，除非我们厌倦了数据方案的维护，并希望使用 NoSQL。如果我们能以正确的方式去做。我们试图使用 MongoDB 作为 NoSQL 数据库来存储历史数据，因为你知道吗，每个大数据初创公司都应该使用 MongoDB——最终，我们花了更多时间来优化它，并编写代码来处理非结构化数据。下次我会再试一次。
可展开的
让我们再来看这幅画。
看到右边的容器了吗？每个 ML 任务都存在于自己的容器中，并且只做一件事。这要么是欧几里得距离的指数，要么是分类任务或回归——我们把它放在单独的盒子里。这允许我们在任何时候扩展瓶颈位置，而不需要调整系统的其余部分。如果分类很慢——添加更多的分类器，太多的 API 请求——再添加一个 API 服务器。每个盒子只负责一件事，而且做得很好。如果我们决定从 PyTorch 迁移到 Keras 或 tensor flow——我们可以迁移一个容器，然后看看情况如何。如果成功了——在整个系统中推广。听起来像个计划吗？
SDK 友好的
作为一名工程师，我真的很讨厌那些可以工作，但是要么不能工作，要么文档非常糟糕的系统。你所能做的就是玩玩它，猜猜看，谁知道当你上线的时候会有什么在等着你。我可能集成了 2017 年之前推出的所有第三方系统，记录不良的服务数量惊人。我们希望我们的用户有一个愉快的体验，我们为此而努力。
一个很好的起点是 swagger 文档，我们打算用它来自动生成 SDK 客户端。这基本上是亚马逊做的，一切都很好。然而，每个 AWS 客户端看起来都像是你在写 Java，不管你用的是什么语言。因此，在我们交付定义良好的 API 之后，下一个里程碑将是原生 SDK 客户端和..击鼓..如何使用它们的例子。真的，这么多 API 至少缺少例子，我甚至没有说文档可能会误导。
最后，我们在发布新的架构和试验更多可以作为特性添加的东西上已经进行了一半。在我们确保它功能丰富之后，我们将把它公之于众，让开发人员容易使用，并不断尝试扩展和性能调整，因为这很有趣。如果你想知道我们决定在 API 中做什么，让它可以扩展新的特性，请告诉我。
原载于 2019 年 3 月 26 日【tarasmatsyk.com】。
如何在 BigQuery 中查询和计算 Google Universal Analytics 数据
带有示例查询的标准 SQL 指南
W 当我第一次开始在 BigQuery 中查询谷歌分析数据时，我很难解释隐藏在ga_sessions_导出表中的“原始”点击级数据。因为我找不到关于如何在 BigQuery 中计算 Google Analytics 指标的可靠指南，所以我决定自己写一个。我提供了许多示例查询，因此您不必重新发明轮子，希望您可以节省一些宝贵的时间。
更新:你喜欢这篇文章吗？那么你也会喜欢我的新网站【GA4BigQuery.com】:这是一个关于如何在 big query&rock your digital marketing Analytics 中查询谷歌分析数据的技巧、想法、示例查询和教程的数字指南。
我已经将本文中的大多数示例查询迁移到新网站，因为在一个地方维护所有内容更容易。这篇文章将留在网上，让你找到正确的地方。
我也在 BigQuery 中发表了一篇关于 查询 Google Analytics 4(之前为 App + Web)事件数据的文章。此内容将被迁移到【GA4BigQuery.com】中。
Image by Berber Bijlsma
目录
–Google Analytics 数据简介 big query
–多表
–用户–
–会话
–时间
–流量来源
–地理网络
–平台或设备
–页面追踪
–
–增强型电子商务(产品)
–自定义维度&自定义指标
–自定义渠道分组
–日内表格
–实时表格&查看
BigQuery 中的 Google 分析数据简介
The BigQuery User Interface
为什么是 BigQuery？
对于那些想知道为什么应该使用 BigQuery 来分析谷歌分析数据的人，请阅读这篇优秀的文章。一些大优势:
- 不再取样。永远不会。
- 无限数量的维度
- 将不同的范围合并在一份报告中(不适合胆小的人！)
- 计算目标完成情况，建立您自己的渠道分组并纠正数据错误，所有这些都基于过去的数据
- 将谷歌分析数据与第三方数据源相结合
陡峭的学习曲线
但是我们不要太激动。事实是，一旦你发现很多你习惯的谷歌分析指标无处可寻，钻研 BigQuery 可能会相当令人沮丧。
Google Analytics 用户，特别是高级用户对 BigQuery 感兴趣的原因是，Google 可以每天将原始的 Google Analytics 数据转储到 BigQuery 中。虽然这使得许多类型的分析无法在 Google Analytics 界面中执行，但它也没有提供任何基本的指标，例如，跳出率。(来源**
这有两个方面:困难的部分是我必须计算我的查询中每一个“缺失”的谷歌分析指标。积极的影响:我在概念层面上对度量标准的理解有了很大的提高。
另一个障碍
的 BigQuery 食谱在某些情况下帮助了我，但有时也显得不完整和过时。因为标准 SQL 语法是当今首选的 BigQuery 语言，并且许多旧的 Stackoverflow 条目正在使用(很快将被弃用？)遗留的 SQL 语法，我花了很多时间来思考我必须编写的 SQL 查询，以获得我想要的报告。除了我需要注意的计算度量之外，还有另一个障碍需要跨越:嵌套和重复的字段。
Google Analytics BigQuery 转储中的每一行都代表一个会话，并包含许多字段，其中一些字段可以是重复的和嵌套的，例如 hits，它包含一组重复的字段，代表会话期间的页面视图和事件，以及 custom dimensions，它是一个单独的重复字段。这是 BigQuery 和普通数据库的主要区别之一。(来源)
我的目标
有了这篇文章，我希望能为你省去一些麻烦。我将向您展示如何创建会话和用户级别的基本报告，稍后我将展示一些更高级查询的示例，这些查询涉及点击级别的数据(事件、页面浏览量)、结合不同范围的多个自定义维度、处理(增强的)电子商务数据以及将历史数据与实时或当天数据结合起来。
在家试试这个
没有谷歌云计费账户？进入 BigQuery 沙箱，它允许你使用 BigQuery web UI 而无需启用计费账户。要设置 Google Analytics to big query export，您需要 Google Analytics 360(Google 营销平台的一部分)。
Standard SQL in BigQuery
我假设您对作为查询语言的 SQL 和作为数据库工具的 BigQuery 有基本的了解。如果没有，我建议您先学习 SQL 入门课程，因为我不会详细介绍 SQL 语法，而是将重点放在如何从 BigQuery 中获取您的(自定义)Google Analytics 报告以供分析。所有查询示例都使用标准 SQL。
在本文中，我们将为 BigQuery 使用 Google Analytics 样本数据集，它包含来自 Google 商品商店的分析数据。
Google Merchandise Store
然而，如果你想用 Google Analytics 比较你的查询结果，我建议你使用你自己的 Google Analytics 数据集，因为我已经注意到 Google Analytics 中的 Google 商品商店数据和样本 BigQuery 数据集之间的差异。我在其他谷歌分析账户上测试了这些查询，它们匹配得相当好。
导出模式
为了更好地理解 BigQuery 中的ga_sessions_表，让我们看看 BigQuery 导出模式，它让我们了解了 BigQuery 中可用的原始 Google Analytics 数据字段。
尽管您可能会从 Google Analytics UI 中识别出许多维度和指标，但我知道这种模式可能有点令人不知所措。为了更好地理解我们的数据集，我们必须知道(嵌套)字段的结构。下一张图片代表来自ga_sessions_表的两行(= 2 个会话)。
嵌套示例
如你所见，如果你需要自定义维度、自定义指标或任何点击量数据，即事件、页面浏览量或产品数据，我们的麻烦就来了。让我们查询我们的嵌套样本集:
*SELECT
*
FROM
`bigquery-public-data.google_analytics_sample.ga_sessions_20170801`
LIMIT
2*
这给了我们 2 行，表示为平面表，如下所示:
记住，在这个例子中，只有第 2 行和第 14 行是我们表中真正的行。其他“行”实际上是嵌套字段，大多数情况下是NULL值。只有hits.product列填充了值。
为了处理这些字段，并能够查询我们的表以满足我们的需求，我们需要UNNEST函数。
这里的问题是它本质上是一个数组(实际上在 BigQuery 中它是一个“重复的记录”，但是你可以把它看作一个数组)。(…)这就是
UNNEST函数的用武之地。它基本上允许你在一个数组中获取元素，然后展开每一个单独的元素。然后，可以将原始行与每个未嵌套的元素连接起来，将它们添加到表中。(来源)
我强烈推荐阅读这篇文章，它以 Firebase Analytics 样本数据集为例详细解释了UNNEST概念。
您只需UNNEST包含“重复字段”的记录。对于我们的谷歌分析数据集，这些可能涉及:
用户/会话范围
- 自定义维度
命中范围
- 打击
- hits.customDimensions
- hits.customMetrics
产品范围
- hits.product
- hits.product.customDimensions
- hits.product .自定义度量
为了确保您理解 BigQuery 导出模式的结构，我鼓励您看一看这个交互式可视化表示。
好的。理论废话够多了。准备好行动了吗？我们来查询一下！
多个表格
BigQuery 中的 Google Analytics 数据每天存储在一个表中。如果您只需要某一天的数据，查询中的FROM子句将如下所示:
*SELECT
*
FROM
`bigquery-public-data.google_analytics_sample.ga_sessions_20160801`*
在大多数情况下，您需要查询更长的时间段。输入_table_suffix。更多细节在这里，但是要查询谷歌分析数据的多个表格，你只需要这些例子。请注意，您可以将静态日期和动态日期结合使用，或者在最近 90 天左右的滚动期内只使用静态日期或动态日期。也可以在您的查询中包含日内表。
静态日期范围
当您对静态数据范围执行分析时，您应该使用固定的开始和结束日期。在本例中，我们选择 2016 年 8 月 1 日至 2017 年 8 月 1 日。
*SELECT
*
FROM
`bigquery-public-data.google_analytics_sample.ga_sessions_*`
WHERE
_table_suffix BETWEEN '20160801'
AND '20170801'*
动态日期范围
在本例中，我们选择“今天”——到昨天为止的 30 天。
*SELECT
*
FROM
`bigquery-public-data.google_analytics_sample.ga_sessions_*`
WHERE
_table_suffix BETWEEN FORMAT_DATE('%Y%m%d',DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY))
AND FORMAT_DATE('%Y%m%d',DATE_SUB(CURRENT_DATE(), INTERVAL 1 DAY))*
静态和动态日期的组合
我们知道我们的数据集中有 366 个日表，所以我们可以在这里使用固定的结束日期(20170801)，但是通常我更喜欢固定开始日期和动态结束日期的组合(在本例中:今天减一)。如果新数据被添加到我们的数据集中，它会自动包含在我们的查询中。在本例中，我们选择 2016 年 8 月 1 日至昨天。
*SELECT
*
FROM
`bigquery-public-data.google_analytics_sample.ga_sessions_*`
WHERE
_table_suffix BETWEEN '20160801'
AND FORMAT_DATE('%Y%m%d',DATE_SUB(CURRENT_DATE(), INTERVAL 1 DAY))*
用户
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。
用户维度
用户类型
会话计数
用户指标
用户
新用户
%新会话
每个用户的会话数量
点击
示例查询
此示例查询包含以下所有 Google Analytics 用户维度和指标。如果你只需要一个维度…
www.ga4bigquery.com](https://www.ga4bigquery.com/user-dimension-metrics-ua/)
返回目录*
会议
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的# comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。
会话维度
-
会话指标
会话
跳出率
跳出率
平均值。会话持续时间
示例查询
此示例查询包含以下所有 Google Analytics 会话维度和指标。如果你只需要一个…
www.ga4bigquery.com](https://www.ga4bigquery.com/session-dimensions-metrics-ua/)
返回目录*
时间
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。
时间维度
日期
年份
ISO 年份
年份月份
年份月份
年份星期
年份星期
ISO 年份星期
ISO 年份星期
月份日期
星期日期
星期名称
小时
分钟
日期小时和分钟
时间度量
-
示例查询
此示例查询包含以下所有 Google Analytics 日期和时间维度和指标。如果你只需要一个…
www.ga4bigquery.com](https://www.ga4bigquery.com/date-time-dimensions-metrics-ua/)
返回目录*
流量来源
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或指标，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。
交通来源维度
推荐路径
完整推荐人
默认频道分组
活动
来源
媒介
来源/媒介
关键词
广告内容
社交网络
社交来源推荐
活动代码
流量来源指标
-
示例查询
此示例查询包含以下所有 Google Analytics 流量来源维度和指标。如果你只需要一个…
www.ga4bigquery.com](https://www.ga4bigquery.com/traffic-sources-dimensions-metrics-ua/)
返回目录*
地理网络
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。
地理网络维度
洲
亚洲
国家
地区
地铁
城市
纬度
经度
网络域
服务提供商
城市 ID
地理网络度量
-
示例查询
此示例查询包含以下所有 Google Analytics 地理网络维度和指标。如果你只需要一个…
www.ga4bigquery.com](https://www.ga4bigquery.com/geo-network-dimensions-metrics-ua/)
返回目录*
平台或设备
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。
平台或设备尺寸
浏览器
浏览器版本
操作系统
操作系统版本
移动设备品牌
移动设备型号
移动输入选择器
移动设备信息
移动设备营销名称
设备类别
浏览器大小
数据源
平台或设备指标
-
示例查询
此示例查询包含以下所有 Google 分析平台和设备维度和指标。如果你只需要…
www.ga4bigquery.com](https://www.ga4bigquery.com/platform-and-device-dimensions-metrics-ua/)
返回目录*
页面跟踪
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或指标，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。
页面跟踪尺寸
主机名
页面
上一页路径
页面路径一级
页面路径二级
页面路径三级
页面路径四级
页面标题
登陆页面
第二页
退出页面
页面跟踪指标
入口
浏览量
独特浏览量
页面/会话
出口
%出口
平均。页面上的时间
示例查询
此示例查询包含以下所有 Google Analytics 页面跟踪维度和指标。如果你只需要一个…
www.ga4bigquery.com](https://www.ga4bigquery.com/page-tracking-dimensions-metrics-ua/)
返回目录*
事件跟踪
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。
事件跟踪维度
事件类别
事件动作
事件标签
事件跟踪指标
总事件数
唯一事件数
事件值
平均值。值
带事件的会话
事件/带事件的会话
示例查询
此示例查询包含以下所有 Google Analytics 事件跟踪维度和指标。如果你只需要一个…
www.ga4bigquery.com](https://www.ga4bigquery.com/event-tracking-dimensions-metrics-ua/)
返回目录*
目标转换
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或指标，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。
目标转换维度
目标完成位置
目标上一步-1
目标上一步-2
目标上一步-3
目标转化指标
目标 XX 完成情况
示例查询
此示例查询包含以下所有 Google Analytics 目标转换维度和指标。如果你只需要…
www.ga4bigquery.com](https://www.ga4bigquery.com/goal-conversions-dimensions-metrics-ua/)
返回目录*
(增强型)电子商务(交易)
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。
(增强的)电子商务维度
交易 ID
(增强的)电子商务指标
交易
电子商务转换率
收入
平均。订单价值
每会话价值
运费
税
每用户收入
每用户交易
示例查询
此示例查询包含以下所有谷歌分析电子商务交易的维度和指标。如果你只是…
www.ga4bigquery.com](https://www.ga4bigquery.com/enhanced-ecommerce-transactions-dimensions-metrics-ua/)
返回目录*
电子商务(产品)
当输入产品范围时，您必须验证增强型电子商务是否在谷歌分析中启用。如果是这样，您可以安全地使用 hits.product 字段。如果只测量“标准”电子商务:使用 hits.item 字段。
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。
电子商务维度
产品 SKU
产品
产品类别
电子商务指标
数量
唯一采购
平均。价格
产品收入
平均。数量
示例查询
当进入产品范围时，您必须验证谷歌分析中是否启用了增强型电子商务。如果是这样，你就…
www.ga4bigquery.com](https://www.ga4bigquery.com/ecommerce-products-dimensions-metrics-ua/)
返回目录*
增强型电子商务(产品)
当进入产品范围时，您必须验证谷歌分析中是否启用了增强型电子商务。如果是这样，您可以安全地使用 hits.product 字段。如果只测量了“标准”电子商务:使用 hits.item 字段。
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或指标，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。
增强的电子商务维度
产品 SKU
产品
产品类别(增强型电子商务)
产品品牌
产品变型
增强的电子商务指标
数量
唯一购买量
产品收入
平均值。价格
平均值。数量
购买到明细比率
购物车到明细比率
产品添加到购物车
产品结账
产品明细视图
产品退款
产品从购物车中移除
退款金额
示例查询
当进入产品范围时，您必须验证谷歌分析中是否启用了增强型电子商务。如果是这样，你就…
www.ga4bigquery.com](https://www.ga4bigquery.com/enhanced-ecommerce-products-dimensions-metrics-ua/)
返回目录*
自定义维度和自定义指标
该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的# comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。
自定义维度
自定义维度 XX(用户)
自定义维度 XX(会话)
自定义维度 XX(点击)
自定义维度 XX(产品)
自定义指标
【自定义指标 XX 值(命中)】T23【自定义指标 XX 值(产品)
示例查询
此示例查询包含以下所有 Google Analytics 自定义维度和指标。如果你只需要一个…
www.ga4bigquery.com](https://www.ga4bigquery.com/custom-dimensions-metrics-ua/)
返回目录*
自定义频道分组
如果需要默认通道分组，只需使用通道分组尺寸即可。但是，建立自己的频道分组可能有各种原因。例如，当您使用当天数据时，因为通道分组维度不可用。或者当您需要“修复”历史数据的数据质量问题时，因为这对于 Google Analytics UI 中的默认频道分组维度是不可能的。
我将向您展示如何镜像 BigQuery 中默认频道分组的标准 Google Analytics 定义。如果您使用这个查询作为起点，那么创建您自己的定制或默认频道分组就不再那么困难了。
示例查询
如果需要默认的渠道分组，就使用渠道分组维度。然而，可以有各种…
www.ga4bigquery.com](https://www.ga4bigquery.com/tutorial-how-to-create-your-own-custom-channel-grouping/)
返回目录*
当天表格
对于每个导出到 BigQuery 的 Google Analytics 视图，一个ga_sessions_intraday_表也将在一天内被导出多次。让我们看看这是如何工作的:
在每个数据集中，为每天的导出导入一个表。每日表格的格式为“ga_sessions_YYYYMMDD”。
日内数据大约每天导入三次。日内表格的格式为“ga_sessions_intraday_YYYYMMDD”。在同一天，当天数据的每次导入都会覆盖同一表中的前一次导入。
每日导入完成后，前一天的日内表将被删除。对于当天，直到第一次日内导入，没有日内表。如果日内表写入失败，则保留前一天的日内表。
在每日导入完成之前，当天的数据不是最终数据。您可能会注意到日内和每日数据之间的差异，这是基于跨越上次日内导入时间界限的活动用户会话。(来源)
在查询中包含当天数据和历史数据的最简单方法是将通配符与更宽的_table_suffix过滤器结合使用。在这个条件下，它将包括数据集中任何以ga_sessions_开始并包含格式为YYYYMMDD的日期的表。
注意:确保你的数据集不包含任何标题以 ga_sessions_ 开头的表格！
示例查询
对于每个导出到 BigQuery 的 Google Analytics 视图，ga_sessions_intraday_ table 将被导出多个…
www.ga4bigquery.com](https://www.ga4bigquery.com/how-to-query-an-intraday-table-and-combine-it-with-daily-tables-ua/)
返回目录*
实时表格和视图
如果您没有看到当天的表格，而是看到实时表格和视图，则您的 Google Analytics 视图启用了流导出。要查询这些数据并将其与来自ga_sessions_表的历史数据相结合，需要另一种方法。
每天,“流式导出”创建 1 个新表和该表的 1 个(BigQuery)视图:
table:ga _ real time _ sessions _ YYYYMMDD 是一个内部的 staging 表，它包括一天中发生的所有活动的所有会话记录。大约每 15 分钟连续导出一次数据。当会话跨越多个导出操作时，此表中包含会话的多条记录。
ga_realtime_sessions_YYYYMMDD 表不应用于查询(并且不受 Google Analytics 技术支持的支持)。对这些表的查询可能会产生意外的结果，因为它们可能包含某些会话的重复记录。请改为查询 ga _ real time _ sessions _ view _ YYYYMMDD 视图。
view:ga _ real time _ sessions _ view _ YYYYMMDD 位于导出的表的顶部，用于对跨导出边界存在的重复会话的多个记录进行重复数据删除。在此表中查询已消除重复的流数据。(来源)
在撰写本文时，这个每日生成的实时视图只能用遗留 SQL 查询。任何标准的 SQL 查询都会导致以下错误:
为了能够使用标准 SQL，我们必须创建自己的实时视图。
示例查询
如果您没有看到当天的表格，但看到了实时表格和视图，您的 Google Analytics 已启用流导出…
www.ga4bigquery.com](https://www.ga4bigquery.com/how-to-query-realtime-tables-and-views-and-combine-it-with-daily-tables-ua/)
返回目录*
引入流式商业智能
New capabilities in business intelligence help anticipate what lies ahead
一种新形式的自助服务分析有助于业务用户了解运营情况
十多年来，商业智能在观点上一直没有突破。
Tableau、QlikView 和 PowerBI 等自助式商业智能工具有助于人们更轻松地理解他们的数据。但是那些工具只分析已经发生的事情。分析历史数据假设过去观察到的模式、异常和机制将在未来发生。
现在，商业智能正在发生变化。通过结合流分析和自助式可视化探索，业务分析师可以询问和回答有关未来的问题。就像《少数派报告》中的预防犯罪部门一样，这种新型的商业智能可以帮助商业分析师预测未来的情况，实时检测它们，并在为时过晚之前采取行动。
The snapshot images that proved that horses do leave the ground, and sparked the invention of the motion picture camera.
导致电影诞生的赌注
流式 BI 的创建类似于 19 世纪后期电影的发明。
1872 年，利兰·斯坦福雇佣摄影师爱德华·迈布里奇帮助他解决一个赌局，即马匹在奔跑时离开地面。这花了几年时间，但迈布里奇完善了一种方法，从多台相机拍摄一系列快照，这些快照被马折断的细线绊倒。
他的快照揭示了人眼看不到的东西:马奔跑时离开地面。幻灯片二和三展示了这一事实的快照。斯坦福赢了他的赌注。
但更重要的是，迈布里奇的技术捕捉到了运动感。受他的工作影响，第一部电影摄影机于 1892 年问世。
像 19 世纪 80 年代的相机一样，现有的 BI 工具也是为快照而构建的。它们显示已经发生的事情，就像一张静止的照片。就像斯坦福的赌注一样，对华尔街的押注开启了一种思考商业智能的新方式。
流式商业智能的诞生
五年前，“闪电崩盘”在华尔街非常普遍。当交易算法对新闻事件等刺激反应过度时，就会发生闪电崩盘。例如，2012 年，一家公司在 45 分钟内损失了 4 . 4 亿美元。
银行需要一种新的方法来检测和阻止闪电崩盘。正如一位交易主管所说—
“我需要一个实时的数据仓库，在那里我可以询问数百个关于未来的问题，并在这些情况即将发生时得到实时通知，以便我可以在为时已晚之前采取行动。”—电子交易副总裁
这个请求就像斯坦福大学的赌注，但对于商业智能和数据仓库。来自麻省理工学院和剑桥大学的技术专家着手回答华尔街的“询问未来”挑战。
解决方案是连续查询处理(CQP)，这是一种结合了流分析和基于推送的查询模型的技术。CQP 允许商业智能用户向数据流中注入问题。对数据流中的每一个数据更改都评估查询。当查询的结果集发生变化时，BI 可视化会自动更新。或者，如果用户没有盯着屏幕，就会发出警报，提醒他们注意当前的情况。
流式 BI 就像一个可查询的业务数据监控摄像头。它有助于用算法增强人类的智能。
流动商业智能在行动
让我们来看看 BI 流的一天。下面的短片展示了 BI 分析来自一级方程式赛车中嵌入的传感器的物联网数据流。
业务分析师可以通过要求系统连续绘制汽车的位置来实时监控汽车的位置。这里显示了对油门、转速和制动压力的实时分析，但也可以考虑数百个因素。流动 BI 揭示了静态快照永远无法展示的东西:运动、方向、关系、动量。
Streaming BI at work: Query the future.
但是流式 BI 如何查询未来？
在这个例子中，用户为汽车的位置创建了一个地图。BI 工具记录这种连续查询:
从物联网流中选择连续*[位置、转速、油门、刹车]
CQP 记录这个问题并评估数据流上的每一个滴答。车动了，数据就变了，地图也变了。你只要设置好，然后忘记它。计算会改变。关系会变。视觉元素会改变。
这是未来查询的最简单的例子:“当汽车移动时，告诉我它在哪里。”但是可以登记成千上万的这种连续的问题:告诉我司机什么时候走了一条次优的路径进入发夹弯；告诉我轮胎磨损何时降低；告诉我天气预报什么时候变化。
与传统商务智能一样，流式商务智能也是自助服务。因此，查询未来就像查询 Excel 电子表格一样简单:您只需打开一个到流数据的连接，创建一些图表，然后进行探索。
AI can’t apply human judgment and reason. Image from the University of Wyoming.
流式商业智能通过算法意识增强了人类的判断能力
在下注思考中，世界扑克锦标赛冠军安妮·杜克解释了计算机和人类为什么是不同种类的决策。当需要上下文、判断和直觉时，人类表现出色。算法更擅长关联海量数据。
例如，算法通常会将顶部涂有鲜奶油的乌龟图像误认为卡布奇诺，正如加里·马库斯在重启人工智能:建立我们可以信任的人工智能中所描述的那样。自己看看算法是如何猜测上图中的 40 张图片的。
另一方面，人类无法关联海量数据。如果我在一分钟内向你闪现一百万个图像，你就没用了。但是电脑可以做出很好的猜测。
流式 BI 平衡了这些决策优势:来自计算机的算法洞察力和来自上下文的人类判断。
连续查询不仅仅针对原始数据；您可以将算法注入到查询中。例如，“告诉我我的车什么时候可以通过”检测一个算法条件:“可以通过”可以是，例如，用 r 编写的预测模型。
方法的另一个变化是流式 BI 的用户体验是基于推送的，而不是基于请求-响应的。CQP 不断评估流数据；当查询结果改变时，新的信息被推到可视化。或者，分析师可以通过文本消息、电子邮件或警报请求获得特别重要查询的提醒。基于推送的 BI 使分析比以往任何时候都更具沉浸感。
通过这种方式，流式 BI 平衡了人类的理解和算法洞察力。
改变你的想法
对未来的质疑是如此新鲜，以至于我经常被问到，“我该拿它做什么？”以下是如何思考它帮助解决的问题。
首先，想想你拥有的经常变化的数据:销售线索、交易、联网汽车、移动应用、可穿戴设备、社交媒体更新、客户电话、机器人、信息亭、社交媒体活动、网站、客户订单、聊天消息、供应链更新、文件交换。
接下来，想想以“告诉我什么时候”开头的问题这些问题可以包含数学、规则，甚至是用 Python 编写的数据科学模型，每天可以被回答数百万或数十亿次。
流式商业智能问题以“告诉我什么时候”开始
这些问题是在你不看的时候回答的。串流 BI 会通知你问题已回答；你不必坐以待毙。去喝咖啡吧。
流 BI 问题是关于未来的问题:告诉我 当一个高价值客户走进我的店。告诉我什么时候一件设备出现故障迹象。告诉我 当一架载有高优先级乘客的飞机即将着陆时，乘客可能会错过转机。
流式商务智能就像一个算法监控摄像头
流式 BI 就像是数字业务的算法感知监控摄像头。这里有一些公司已经使用它的例子。
罗马和墨尔本的机场从预订、登记、安全摄像头、自动驾驶汽车、飞机和维护设备中获取流数据。他们的分析师可以问:告诉我一架没有登机口的飞机什么时候着陆；告诉我什么时候有一个行李被卡住了，威尔可能会错过航班，或者告诉我们什么时候在任何安检线等待超过 5 分钟。这种算法意识有助于机场运营人员在问题失控之前做出反应并解决问题。
这些算法有助于判断问题的紧迫性，因此人类可以决定该做什么。
流 BI 有助于将信息针从流干草堆中分离出来。
银行风险管理人员可以监控交易、订单、市场数据、客户活动、账户活动和风险指标，以发现可疑交易。算法可以根据风险评估算法，人类可以判断那个风险是否可以接受。
供应链、物流和运输公司可以实时分析数以千计的互联车辆、集装箱和人员。串流商务智能通过识别最具影响力的路线问题，帮助分析师优化交付。
智能城市分析师可以监控紧急车辆的 GPS 数据流、交通数据和警方报告数据，以帮助他们对紧急情况做出快速反应。
像 Anadarko 这样的能源公司监控物联网工业设备以避免石油生产问题发生，并预测何时对设备进行维护。康菲石油公司说这些系统可以导致“数十亿美元”的节约。
华尔街的闪电崩盘呢？它们不再经常发生了。
快照不会死。它们只是旧闻了
快照 BI 没有死。像静态照片一样，它们对于报告、预测和月度报表来说仍然是必不可少的。但是，流式商业智能可以将你的观点转移到未来，并在算法洞察力和人类判断之间取得平衡。
每一份移动数据都成为改变业务方式的机会。与其等待环境来控制你，不如你自己掌握控制权。你预料到了。你表演。
流式商业智能是数字商业 BI 的未来，未来就在眼前。
了解更多
更多，请查看这个 3 分钟 如何查询未来中序列 。有关如何在流式 BI 中应用数据科学模型的更多信息，请阅读 为什么您应该了解流式数据科学 。
关于作者
马克·帕尔默是 TIBCO software 公司分析部的 SVP。作为 StreamBase 的 CEO，他被《时代》杂志评为将改变你生活的 科技先锋之一 。
图片署名为头条文章: 杰西布瑟 上un splash。谢谢大家！
如何快速比较数据集
如何快速总结两个数据集之间的差异
Photo by Joshua Sortino on Unsplash
时不时地，你会需要比较两个数据集；要么证明没有区别，要么强调它们之间的确切区别。根据数据的大小，您可能有许多选择。
在我的上一篇文章中，用 Python 比较数据的 3 种快速方法，我们讨论了许多比较数据的方法。然而，我们讨论的选项都不能给你一个快速、详细的摘要，或者让你适应数据集之间的微小差异。
对于任何从事分析工作的人来说，收到比较数据的请求都太熟悉了。不管那是…
medium.com](https://medium.com/financeexplained/3-quick-ways-to-compare-data-in-python-65201be10b6)
在这篇文章中，我想给你提供另一种选择；我相信这将会非常有帮助。这一次，我想让您注意 DataComPy python 库。
什么是 DataComPy 库？
正如他们的 GitHub 页面上所强调的，DataComPy 库是一个用来比较两个熊猫数据帧并提供描述差异的人类可读输出的包。
示例输出如下所示:
DataComPy Comparison
--------------------DataFrame Summary
-----------------DataFrame Columns Rows
0 Original 18 36634
1 New 18 36634Column Summary
--------------Number of columns in common: 18
Number of columns in Original but not in New: 0
Number of columns in New but not in Original: 0Row Summary
-----------Matched on: policyid
Any duplicates on match values: No
Absolute Tolerance: 0
Relative Tolerance: 0
Number of rows in common: 36,634
Number of rows in Original but not in New: 0
Number of rows in New but not in Original: 0Number of rows with some compared columns unequal: 2
Number of rows with all compared columns equal: 36,632Column Comparison
-----------------Number of columns compared with some values unequal: 2
Number of columns compared with all values equal: 16
Total number of values which compare unequal: 2Columns with Unequal Values or Types
------------------------------------Column Original dtype New dtype # Unequal Max Diff # Null Diff
0 eq_site_limit float64 float64 1 190601.40 0
1 hu_site_limit float64 float64 1 79375.76 0Sample Rows with Unequal Values
-------------------------------policyid eq_site_limit (Original) eq_site_limit (New)
2 206893 190724.4 123.0policyid hu_site_limit (Original) hu_site_limit (New)
3 333743 79520.76 145.0
Photo by Franki Chamaki on Unsplash
它是如何工作的？
DataCompPy 要求您提供一列(可以只有一列)作为连接的键。您还可以设置它，使它基于索引工作。如果库在连接键上检测到重复项，那么它将对剩余的字段进行排序，并根据该行号进行连接。
算出例子
让我们探索一些用例，并确保我们知道如何将其付诸实践。我们需要做的第一件事是安装库。打开命令行窗口，键入以下内容:
pip install datacompy
然后，我们可以继续在 Python 脚本中导入库。在示例中，我将使用一些本地样本数据集:
import datacompy, pandas as pddf1 = pd.read_csv('FL_insurance_sample.csv')df2 = pd.read_csv('FL_insurance_sample - Copy.csv')print(df1.head(10))
返回:
如何使用 DataComPy
要使用该库，您只需要以下脚本框架:
import datacompyimport pandas as pddf1 = pd.read_csv('FL_insurance_sample.csv')df2 = pd.read_csv('FL_insurance_sample - Copy.csv')compare = datacompy.Compare(df1,df2,join_columns='policyID', #You can also specify a list of columns eg ['policyID','statecode']abs_tol=0, #Optional, defaults to 0rel_tol=0, #Optional, defaults to 0df1_name='Original', #Optional, defaults to 'df1'df2_name='New' #Optional, defaults to 'df2')print(compare.report())
要根据您的喜好调整上面的脚本，您需要注意以下几点:
- abs_tol 和 rel_tol 分别代表绝对公差和相对公差。它们允许您指定数值之间的偏差公差。
- 您可以将 join_columns 替换为 on_index=True 来连接索引。
- 如果你想要两个数据集之间的交集，你可以使用compare . intersect _ columns()
查看 他们的文档 以了解特性的全部细节。
我希望你觉得这是有用的。
如果您觉得这篇文章有用，您可能还会对以下内容感兴趣:
了解如何使用 Python 比较大文件
towardsdatascience.com](/how-to-compare-large-files-f58982eccd3a) [## 构建用于比较数据的 Python UI
如何快速让您的非技术团队能够比较数据
towardsdatascience.com](/building-a-python-ui-for-comparing-data-13c10693d9e4) [## 在 Python 中比较数据的 3 种快速方法
对于任何从事分析工作的人来说，收到比较数据的请求都太熟悉了。不管那是…
medium.com](https://medium.com/financeexplained/3-quick-ways-to-compare-data-in-python-65201be10b6)
拆箱为什么和如何阅读一篇研究文章？
Source of Image: https://libparlor.com/2017/09/27/research-101-qualitative-research-approaches/
世界上有这么多有趣的研究领域，我相信我们每个人在一生中的某个时候都曾设想过创造出一些至今无人想到的东西。如此渴望向世界展示我们有勇气做一些不平凡的事情。但是当你开始的时候，你会意识到世界是多么的广阔，世界上有那么多的人为了解决一个问题或者发明一个令人惊奇的东西而想出那么多巧妙的主意。
就在这一刻，我们意识到，为了推进我们的研究思路，我们需要了解人们以前做过什么。我们中的许多人选择这样做是为了从其他想法中获得灵感，而其他人这样做是为了确保他们不会花费几周、几个月甚至几年的时间来做世界上其他地方的其他人已经做过的事情。因此，在围绕我们的问题范式探索研究世界的旅程中，我们会遇到研究论文。
这些研究论文通常充满了技术术语和数学方程式，足以吓到任何人。特别对于一个人来说，刚入门，好像特别恐怖。我当然不是能告诉你阅读技术研究论文或出版物的最佳方法的专家，但我肯定能与你分享我通常是如何在 30 分钟或更短时间内不仅阅读而且理解一篇论文的。
相信我，当我第一次看报纸的时候，我也很害怕。我看着论文，甚至还没看一页，就开始觉得我需要学习这么多东西，才能开始领会论文的内容。相信我！每个人都会这样！觉得自己知道的还不够是正常的。事实上，正是在这一点上，我们开始意识到我们还需要学习多少，这很重要，因为世界上没有人知道一切。所以你至少可以继续努力。
总的来说，在你直接阅读任何研究出版物之前，如果你是初学者，我建议你试着掌握你感兴趣的领域的基础知识。例如，如果您选择的问题陈述是在自然语言处理(NLP)领域，那么您应该考虑了解如何解释自然语言并将其可视化，如何使用不同的模型和框架处理自然语言，以及 NLP 中使用的最流行的算法是什么。当你对基础知识有了足够的了解后，就可以开始阅读你想阅读的研究论文了。
一篇研究论文通常分为以下几个部分。
研究论文部分:
1.摘要
2.介绍
3.相关著作
4.主要部分(通常分为子部分，如详细描述想法、采取的方法等)
5.实验/实验装置
6.结果
7.结论
8.确认
9.参考
请注意，这是一般研究论文的结构，根据研究领域和作者偏好的写作风格可能会略有不同。
在我们详细了解每一节之前，我先跟大家分享一下我的策略。
我使用的一个简单的技术是打印出这张纸。对于那些喜欢在笔记本电脑、iPad 或平板电脑上阅读的科技达人来说，这听起来可能很烦人。请原谅我。我保证有效！随身携带一支铅笔和荧光笔。两者都很重要。我来解释一下原因。用铅笔在空白处或边上对你读到的任何部分做简短的笔记。使用荧光笔，突出你认为重要的区域。这听起来可能很幼稚，但是相信我，它对你的注意力有神奇的效果。诀窍是用你自己的话每隔一两段写下你所理解的内容。这不仅有助于你记住文章的内容，也有助于你让自己保持在正确的轨道上，专注于阅读文章。
招数一:打印出纸张。用铅笔对你正在阅读的任何部分做简短的笔记，并用荧光笔突出重点。
另一点要记住的是，不要被看起来疯狂的数学方程式吓到。请记住，论文的作者也曾和你一样是初学者，他们确实希望别人理解他们的工作。所以请放心，他们确实解释了那些看起来疯狂的方程的意思。耐心点。另一件要记住的事情是，不要把方程看成一个整体，而要先理解方程中的单个元素。这有助于你更快地理解整体思想。毕竟，成功的一个秘诀是坚持不懈，直到你到达你想到达的地方。
诀窍二:不要害怕看起来疯狂的数学方程式。不要把方程看成一个整体，先试着理解方程中的单个元素。这有助于你更快地理解整体思想。
让我试着详细说明每一部分代表什么，以及如何最大化你的理解。
在你开始阅读一篇研究论文之前，第一步是阅读摘要。摘要通常简短扼要，是论文中整个工作的总结。如果你理解了摘要想要表达的意思，那么你就能更好地理解文章。如果你没有完全理解抽象，那么不要灰心。随着论文的展开，你会明白它的意思。
摘要:简短扼要地总结论文中提出的全部工作。
接下来是介绍。引言通常是论文的一部分，它介绍论文背后的总体思想，但不涉及太多的细节。例如，引言可以包括简要解释为什么论文讨论的研究领域是相关的，以及论文展示的工作如何是解决该领域问题的好方法。像阅读一部戏剧或一本书的介绍那样阅读介绍。这是为了引起你的兴趣，让你对论文中讨论的观点感到好奇。
简介:介绍论文背后的总体思路，但不涉及太多实施细节。
我们关注的下一部分是与相关的工作。本节提到了为解决同一问题而做的其他相关工作，这些工作值得一提，并强调了它们的优点和缺点。由于两个原因，这一部分对你来说特别重要。第一个原因是，阅读这一部分有助于你了解人们提出了哪些其他方法来解决你的目标问题或类似的相关问题。这有助于你找到一个起点，开始看你感兴趣的论文。转到参考文献部分，使用引用号识别论文并阅读它！你读得越多，你就会越有见识。需要注意的一点是，不要把论文作者所说的一切都当成真理。请记住，论文中未提及的任何内容都是作者自己的观点，众所周知，每个人都有权以不同的方式看待事物。所以在形成你的观点之前，你必须阅读一篇论文。阅读这一部分的第二个原因是因为这有助于你理解作者的方法如何从其他竞争方法中脱颖而出。明智的做法是知道外面还有什么，以及它们和你正在阅读的报纸之间的区别。简而言之，相关工作提供了一系列研究文章，增加了我们在研究中的呼吸，可以帮助我们更好地制定和概念化我们的问题。
相关工作:谈论全球其他研究相同或相似问题的研究者的想法和方法。
你通常会遇到的下一个部分是这篇论文的关键。主要部分通常被细分为更小的子部分，每个子部分解释作者正在呈现的一个概念、元素或组件。它还包括问题公式。这一节对于理解本文的观点至关重要。不要忘记在你阅读的段落旁边的空白处做笔记。每隔几段，停下来，试着问自己这是关于什么的，你学到了什么。然后把它写在空白处。这有多重好处。一个显而易见的好处是，无论何时你再次打开这份文件，你都不必再通读一遍。你可以在一边读你的解释，然后就完事了。另一个好处是，与只读一遍的内容相比，你更容易记住自己手写的内容。它增加你的记忆能力。
主要部分:通常被细分为更小的子部分，每个子部分解释作者正在展示的一个概念、元素或组成部分。
在这部分之后是实验设置或实验部分。这一部分通常解释关于论文的实现细节，包括关于作者如何划分他们的训练、验证和测试集(在机器学习、视觉、NLP、相关论文的情况下)的细节，以及他们进行了哪些实验来展示他们的想法是惊人的。这些实验包括针对预期研究领域中的基准数据集和基线进行测试。这一节让你深入了解如何计划你自己的实验，以及有哪些基线模型可供你测试。
实验设置或实验:解释关于论文的实现细节，包括数据集、评估指标和针对已知基准模型和数据集进行的实验。
下一节是结果。本节使用与研究领域相关的不同评估指标，强调论文中提到的模型、网络或想法的性能和效率。这一部分可用于确定一个想法对您来说有多好，您可以使用本文的研究结果或从他们的想法中获得灵感来帮助构建您自己的模型。
结果:强调论文中提到的模型、网络或想法的性能和效率。
标题为结论的部分给出了论文中提出的想法的最终更精确的总结，以及它与其他模型相比的表现。它有时也提到未来的研究范围。这有助于你巩固对论文的理解，并对照作者的结论再次检查你得出的结论。
结论:给出最终更精确的总结，以及预期研究领域的未来工作范围。
确认是可选部分。在这一部分，作者通常感谢在他们的工作过程中帮助他们的机构或赞助商，以及使他们的工作得以完成的任何资助细节。如果你的目的只是阅读研究论文中提到的观点，你可以跳过这一部分。
致谢 : 包含了帮助他们的工作取得成功的赞助商的详细信息(包括行业和学术资助)。
最后但同样重要的是参考文献或参考书目部分。本节包含了整篇论文中以某种方式引用的所有研究论文或出版物的列表。这一部分可以作为一个起点来寻找你感兴趣的领域的类似论文。
参考文献或参考书目: C 包含本文引用的所有出版物的列表。
一旦你读完整篇论文，我建议你用自己的话写一个简短的总结，介绍这篇论文的内容和它引入了什么新事物。你也可以写一两行关于你在报纸上发现的有趣的东西，甚至是你在阅读报纸时大脑中闪现的新想法，你可以在以后继续。这不仅有助于我们在以后的时间里更快地将论文作为一个整体保留下来，而且还能确保那些我们一时兴起并随后忘记的短暂的精彩想法不会在日复一日的单调乏味中丢失。
技巧 3: 用自己的话写一篇简短的总结，介绍这篇论文的内容以及它引入了什么新事物。
我希望这篇文章能帮助你有朝一日成为一名伟大的研究者！
如果你喜欢这篇文章，请在 medium 或 LinkedIn 上关注我，或者与你的朋友分享这篇文章！
感谢您的阅读！
永远不要放弃，总有一天世界会认识到你的潜力。这是成功的关键。坚持学习就好！
使用 PyTorch Lighting 简化和扩展您的 PyTorch 代码
如果你没有听说过，现在有一个非常简单的方法可以使用 PyTorch，并免费获得非常先进的功能！
PyTorch Lightning 是 PyTorch 上的一个非常轻量级的包装器，它更像一个编码标准，而不是一个框架。如果您将 PyTorch 代码重构为 Lightning 格式，您将获得顶级研究团队的附加功能，而无需所有工作。这种格式可以让您摆脱大量的样板代码，并使其具有高度的可重复性。
酷吧。让我们从 PyTorch 库中获取快速风格转换教程，并将其转换为 Lightning 格式。
图像加载
首先，让我们定义一些工具来帮助我们操作图像
变压器
接下来，我们将定义变压器网络来处理输入(不是 BERT 使用的类型)。
VGG 网
接下来，我们定义我们想要用于特征提取的 VGG 网
培训代码
前面的文件是独立的文件，我们通常希望它们与我们的主训练脚本分开。这不是闪电的事情，只是一般的软件工程最佳实践。
在本节中，我们定义了大部分培训逻辑。每个项目都有不同的做法。在最乐观的情况下，所有代码都在一个单独的(很长的)文件中，其中包含了您需要训练的所有要素。在正常情况下，该代码分布在多个文件中，这使得无法看到该方法的高级视图。
这是 PyTorch 回购的版本。
根据存储库的说明，您可以运行这个文件，它应该可以工作。
Running instructions
然而，这远非最佳。例如，如果您想使用 16 位精度呢？还是在多个 GPU 上训练？还是多机？还是加梯度积累？还是加早停？还是 tensorboard 测井？或者，或者，或者……—你明白了。这段代码会迅速膨胀，变得非常复杂。
这就是 PyTorch 闪电出现的地方。
步骤 1:设计照明模块
为了开始重构，我们需要浏览冗长的主文件，提取出我们将添加到 LightningModule 中的真正重要的内容。
照明模块
我们创建了一个名为 FastStyleTransfer 的类，它将样式传输的主要成分包含在一个 lightning 模块中:
现在我们寻找闪电模块的主要成分:
- 优化器，学习率调度程序
- 培训、验证和测试数据
- 训练循环中会发生什么
- 验证循环中发生了什么
- 模块执行什么计算(转发)
模型计算
首先，让我们找到这个模型的核心计算。这很难，因为这些总是分散在代码中，这使得核心科学贡献很难精确定位。
首先，看起来我们需要这个变压器:
看起来我们也需要这张 VGG 网:
看起来我们在这里也做了一些预训练循环缓存:
因为我没有读过这篇特别的论文，但是我熟悉风格转换，看起来他们在预先计算 gram_matrix。像这样的任何类型的缓存操作都是 init 函数的很好的候选，这个函数在 Lightning 中只被调用一次。
看起来这是核心的计算部分。在 lightning 中，我们将这些整合到一个功能中
注意一些事情:
- 现在很清楚这篇论文的主要计算单位是什么了。
- 我将一组超参数(hparams)传递给构造函数。这是可选的，但几乎是标准的做法。这通常是一个 Argparse 对象。
- 注意我们去掉了对 GPU 的任何调用(例如:没有。todevice()或。cuda())…闪电会帮你处理的。
现在，如果你想理解这篇论文的代码，你可以看看 init，知道这篇论文需要一个 VGG 网，一个 gram_style 矩阵和一个 convnet(他们称之为 transformer)。记住，这不是 BERT 中使用的变压器网络。
训练循环
接下来我们看看计算是如何应用的。通常这是在内部循环中(所有的东西在批处理之后和之前。向后)
注意这段代码非常混乱。有大量调用将内存转移到 gpu(。到(设备))。有管理计数器(coung+= n_batch)等…
这是深度学习项目 80%的复杂性所在。让我们把这个移到我们的照明模块。
内部训练循环(上面黄色的东西)进入 training_step。training_step 实际上只是在黄色代码所在的位置被调用:
注意关于 training_loop 的一些事情:
- 现在发生的事情非常清楚。对于快速风格转换，使用 convnet(变压器)对输入进行编码，归一化，通过 vgg 运行每个输入，然后计算一些损耗。
- 没有提到 optimizer 或 zero_grad 或任何有关培训的内容。
- 没有对的调用。cuda 或 gpu 内存管理。
- forward 中的东西不需要在 forward 函数中。可以在 training_step。但是如果你想在产品中使用这个模型，或者在一个 API 后面，或者与其他 PyTorch 代码一起使用，你通常想把核心计算的东西放在前面。
这里要传达的信息是，要理解一篇论文在做什么，你所要做的就是看看 lightning 模块的 training_step！
优化器
我们需要做的最后一件事是告诉 Lightning 使用什么优化器。我们在第 47 行找到了优化器:
我们将把这个优化器添加到这个 lightning 模块函数中:
如果我们在训练更复杂的东西(比如 GAN)，我们可以在这里返回多个优化器。对于您返回的每个优化器，您还可以添加一个学习率调度器。
然而，这项工作只使用了一个优化器。
数据加载器
接下来，我们寻找培训、验证和测试数据加载器。如果他们不使用数据加载器，你必须转换他们的代码来使用数据加载器
幸运的是，我们找到了这个数据加载器代码。现在我们把它变成闪电。
Lightning 还允许您为验证和测试定义不同的数据加载器。这是同一个想法:
装饰器 data_loader 确保您的数据只被调用一次。但是，如果您需要重新加载每个纪元或做一些更深奥的事情，可以选择禁用它。
就是这样！现在我们有了完整的照明模块:
在底部，我们做了一个小小的添加。每个项目都有一组通常通过 ArgumentParser 传递的参数。然而，这些论点中有些是针对整个项目的，有些只适用于这个特定的 LightningModule。最好在 LightningModule 中耦合这些参数，这样就可以很容易地看到参数是从哪里传入的。
训练
就是这样！我们只是将所有需要的相关代码提取到一个 LightningModule 模块中。现在我们创建一个培训脚本，它将为我们运行培训。如果我们有其他项目或不同的风格转换方式，我们可以使用同一个教练来运行它们，只要它们是照明模块。
就是这样！教练将自动运行你的照明模块，并处理所有复杂的训练。有了上面这三行，你就获得了训练循环所需的一切:
- 自动后退，步进
- 自动验证检查
- 自动张量板
- 自动提前停止
- 自动检查点
- …大约 100 种其他免费的东西。
如果你想在几个图形处理器上运行？
如果您想要在 32 个节点上运行，每个节点有 8 个 GPU？
您可以使用这样的 SLURM 脚本提交这个任务:
这就是事情的全部。
展开性
但是等等，你会说…这对于你的用例来说太简单了？别担心，闪电是由我设计的(我的研究都是在 NYU 和费尔进行的)，对研究人员来说是尽可能灵活的。以下是一些例子:
需要自己的后传？覆盖此挂钩:
需要自己的放大器初始化吗？覆盖此挂钩:
想深入到添加自己的 DDP 实现吗？覆盖这两个挂钩:
像这样的钩子有 10 个，我们会根据研究人员的要求增加更多。
底线是，对于一个新用户来说，Lightning 使用起来很简单，如果你是一名从事前沿人工智能研究的研究人员或生产团队，它可以无限扩展。
项目健康
还记得那些你不必写的代码吗？闪电测试它和文件它超级适合你。此外，我们有超过 53 的贡献者——许多来自世界顶级人工智能实验室，每天都在添加新功能。
最后，我们有非常清晰的贡献者指南、核心价值观和极高的代码质量标准。我们使用持续集成进行测试，通常使用闪电标志的各种排列来训练完整的模型。
全部功能
Lighting 有超过 42 个功能，通过标志或挂钩实现，让您对研究/生产过程的每个部分进行无限控制。
今天试试闪电！
用人工智能制作烟鬼混音。
这是“建造人工智能音乐发生器”系列的第四部分(也是最后一部分)。我们将使用我们的多任务音乐模型来混音一首 EDM 歌曲。它将专注于音乐制作，仅用于娱乐目的。
在本帖中，我们将重新混音排行榜冠军歌曲——烟鬼乐队的《玫瑰》。首先，我们将使用 Ableton 和 HookTheory 重新创建合唱。然后，我们将使用我们的 MusicTransformer 模型来生成新的旋律。
这是它听起来的一个小秘密:
背景
之前，我们向您展示了如何构建和训练音乐模型。结果很酷，但似乎缺少了些什么…
更多的生产！！！
大家都知道，想要你的歌有更大的冲击力，就需要层层叠叠的声音。
我不知道怎么做到的，但是烟鬼 做到了 。
所以让我们从他们的歌曲《玫瑰》的副歌部分借用一些声音。
如果你不知道，这里是 drop(又名合唱):
第一部分。在阿伯顿重建合唱团
我们的第一步是将歌曲分解成各个部分——乐器、音符、鼓和人声。这样我们就可以在混音时重复使用这些元素。
构建那个引导音
“烟鬼”在“玫瑰”上做了一个非常酷的大师课，他们解释了他们是如何创造出这些听起来很棒的合成器的。
事实证明，这些乐器中的很多都受到了 Sylenth 预设的极大启发。如果你不知道 Sylenth，它是一个虚拟合成器，带有许多开箱即用的优秀乐器(预设)。
以下是他们在合唱中的领唱:
我们所需要做的就是加载相同的预设，并修改与他们相同的参数。现在我们有了领先的合成器！
抄写这首歌
HookTheory 恰好有这首歌的确切音符和和弦。
让我们将 MIDI 导出并导入到 Ableton！
制作其他层
鼓:我用我所有的样本用耳朵重现了节拍。
人声:谢天谢地，人声样本可以在网上找到。烟鬼们举办了一场混音比赛，他们在比赛中发布了录音。
把这一切都投入到艾伯顿
以下是我们的盗版翻拍听起来像:
够好了。现在让我们重新混合一下。
第二部分。REEEE-MIX！！
是时候使用上一篇的多任务音乐模式了。
让我们把之前下载的原始 MIDI 音符作为我们模型混音的基础。
这是音乐机器人:
You can play the original song here.
现在我们都准备好开始生成了。
我将向你展示两种不同的混音方式，但这是从开始到结束的一般流程:
我们的第一次令牌屏蔽混音
为了创作我们的第一首混音，我们要预测歌曲的“音高”。换句话说，我们将删除一些音符(仅音高)，并让模型填充空白。
输入:音符音高被擦除/屏蔽。音符长度保持不变。
预测语境:概念上，模型知道原曲的节奏，但不知道听起来是什么样的(歌曲音高被屏蔽)。
输出:期望得到一首音符完全不同，但节奏相同的歌。
我们开始吧。
- 将预测类型切换到“音高”。
2.按下那个神奇的按钮，我们就会得到:
Link to remix here
**Red/Blue** notes are the predictions.
**Green/white-striped** notes are from the original melody
观察:
- 所有的音符都改变了音高，但保持相同的位置和持续时间。这正是我们所希望的。请记住，只有音符音高被抹掉。
- 序列最末端的蓝色音符完全没有遮盖。它有助于保持几个完整的笔记作为模型的指南。
3.保存预测输出，并将其拖到我们的 Ableton 项目中:
4.这是我们的创作！
大约需要 5 次尝试才能产生听起来合理的东西。你可以通过向下拨动右下角的“创造力”控制键来选择更高的稳定性。
创作新的旋律
重新混合“音高”产生了完全不同的声音和风格。这一次，我们将保留更多的原始特征，并保持和弦进行不变。
输入:歌曲的原和弦进行。旋律被完全抹去。
预测上下文:seq 2 seq 模型将使用和弦并将它们“翻译”成新的旋律。
输出:与原和弦配合良好的新旋律。
同样的步骤，不同的开关。
- 切换“旋律”开关并按下红色按钮:
Link to remix here
**Red notes** are the predictions.
**Blue notes** are the chords (used by the model to predict the melody).
**Green/white-striped notes** are the original melody
2.将预测导入到 Ableton 中，我们可以得到:
嗯，还不错！
自己试试吧！
如果你拥有 Ableton，你可以在这里下载整个项目。
关于音乐一代人工智能的结束语
我想我们都同意这个人工智能远没有达到人类的水平。
我使用了链锯“drop ”,因为一只带键盘的猴子可以产生 MIDI 音符，用那些原始的合成器和人声听起来很棒。制作和编曲一首完整的歌曲更是一项艰巨的任务。
然而，人工智能在音乐中仍然有很多价值。虽然这种模式不会马上创造出惊人的成功……但更多地把它看作是制片人/作曲家激发新想法的另一种工具。
就像烟鬼们把 Sylenth 中的一个预设变成了一个令人敬畏的主音一样，我认为 MusicAutobot 也可以以同样的方式充当灵感启动器。
感谢你大老远跑来。
构建和分享这个个人项目对我来说是一大乐趣，我希望它对你来说也是一点娱乐。
我将很快发布另一个系列，介绍如何在网络上部署深度学习模型——使用 Flask、Vue 和 Github 页面。你可以在媒体上关注我来了解这方面的更新。
我也很乐意听到你的反馈或者关于你已经建立或创造的任何东西！在推特上联系我。
如何从数据表中删除%符号
将包含%符号的列从字符串转换为数字类型
Columns x5, x6, and x7 contain the % sign, and hence are treated as string type so they can’t be used for numerical calculations.
数据争论是将原始的非结构化数据转换为可用于进一步分析(如数据可视化或建模)的形式的过程。有时，在讨论完数据后，您可能会注意到一些列可能包含符号，如美元符号($)、加号(+)、减号(-)或百分号(%)。任何包含这些符号之一的数据列都被视为字符串类型，因此不能用于数值计算。
在本文中，我将展示如何从数据列中删除百分号(%)。然后，一旦%符号被删除，我们将把列从字符串转换为数字类型，使其适合数字操作和计算。可以使用类似的方法来删除不需要的符号，如加号(+)、减号(-)等。
我将用一个从 pdf 文件中提取的数据集来说明这个例子，如下所示:
Data table originally in a pdf file. Source of original file: http://www.ijastnet.com/.
a)将表格复制并粘贴到 Excel 中，并将文件保存为 table_1_raw.csv
数据以一维格式存储，必须进行整形、清理和转换。
b)导入必要的库
import pandas as pdimport numpy as np
c)导入原始数据并重塑数据
df = pd.read_csv("table_1_raw.csv", header=None)df2 = pd.DataFrame(df.values.reshape(25,10))column_names = df2[0:1].values[0]df3 = df2[1:]df3.columns = df2[0:1].values[0]df3.head()
d)使用字符串处理工具执行数据辩论
我们从上表中注意到，列 x5 、 x6 和 x7 是用百分比表示的，因此我们需要去掉百分比(%)符号:
df4['x5'] = list(map(lambda x: x[:-1], df4['x5'].values))df4['x6'] = list(map(lambda x: x[:-1], df4['x6'].values))df4['x7'] = list(map(lambda x: x[:-1], df4['x7'].values))
e)将数据转换成数字形式
我们注意到列 x5 、 x6 和 x7 的列值具有字符串数据类型(即使在删除了%符号之后)，因此我们需要将它们转换为数字数据，如下所示:
df4['x5'] = [float(x) for x in df4['x5'].values]df4['x6'] = [float(x) for x in df4['x6'].values]df4['x7'] = [float(x) for x in df4['x7'].values]
f)查看转换数据的最终形式
df4.head(n = 5)
g)将最终数据导出至 csv 文件
df4.to_csv('table_1_final.csv',index = False)
总之，我们已经展示了如何从数据列中删除百分号(%)，以及如何将该列转换为数字类型以使其适合数字计算。可以使用类似的方法来删除不需要的符号，如加号(+)、减号(-)等。
如何用海滩时间取代电脑时间——贝壳的魔力
Beach in San Sebastian — Photo by Athena Lam on Unsplash
我编程越多，我就越懒。我只是不明白，为什么我应该做一些电脑自己能做得更好、更快、更可靠的事情。在我接近懒惰工作者的过程中，我发现 shell 脚本是一个很好的朋友和助手。虽然在过去，您可以经常使用 Windows(如果您愿意的话)，但在越来越多的计算在云中执行，服务器大多基于 Linux 的时代，在我看来，每个数据科学家和数据工程师都应该至少对 shell 脚本有一个基本的了解。(奖金:*看到我最喜欢的时间，当 shell 脚本实际上使我高兴的时候，在底部的附录。提示:它确实包含了大量的海滩时间。因为我相信，在内心深处，我们都想把时间花在做其他事情上，而不是手动移动文件，所以我想与您分享我对 shell 的个人基本知识的介绍。希望它能让你的生活变得轻松一点(如果你愿意的话，还能让你在海滩上多待些时间:)。
基础:移动和基本的文件操作
四处走动
如果你登录了，你可能想知道的第一件事是你在哪里(提示:你可能在你的主目录中)。您可以通过将当前工作目录打印到屏幕上来找到答案:
# print working directory
pwd
接下来，您应该通过键入以下命令列出它的内容
# list contents of current directory
ls
许多 bash 命令允许修饰符，即所谓的标志。它们主要由一个字母组成，在命令后面加上一个“-”。您可以通过一个接一个地写入多个标志来组合它们。有许多可能的标志。这里有一些例子
# include hidden files
ls -a# include hidden files and print more details
ls -la# list only directory (without content)
ls -1d directoryname
要了解有关命令的更多信息，请使用手册(手册页):
# print manual for mycommand
man mycommand# for example:
man ls
为了四处移动，您使用cd(改变目录)命令:
# change to directory called mydirectory inside current directory
cd mydirectory# change to directory above
cd ..# move to directory which is also inside the directory above (basically a "parallel" directory)
cd ../mydirectory# change into previous work directory
cd -
高级移动
您可以使用pushd / popd在堆栈中添加/删除目录。一旦添加到堆栈中，您就可以在堆栈中的目录之间跳转。请注意，在构建您的堆栈时，您需要添加两次最终目录，因为最终位置总是会被覆盖(听起来比实际复杂，只要尝试一下，您就会明白我的意思)。
# add mydirectory to stack
pushd mydirectory# show directories in stack
dirs -v # delete top repository from stack
popd # change to directory numbered n (eg 2) in the stack
cd ~2
与文件和文件夹的基本交互
您可以通过以下方式创建一个简单的文本文件
# create a text file called mynewtextfile.txt
touch mynewtextfile.txt
文件由以下人员复制、移动或删除:
# copy file
cp oldfilename newfilename# move/rename file
mv oldfilename newfilename# delete file
rm oldfilename
为了创建(制作)新目录:
mkdir mynewdirectory
目录像文件一样被复制、移动和删除。然而，复制和删除需要-r(递归)标志:
# copy directory
cp -r folder_old folder_new# delete directory
rm –r folder_to_remove# rename directory (does not require -r flag)mv old_folder new_folder
与文件交互和将命令链接在一起——稍微不太基本
与文本文件交互
既然我们知道了如何移动文件，我们还想用它们做一些有用的事情。
有四个主要选项可以访问文本文件的内容。我建议尝试一下，看看它们能做什么，它们的行为有何不同。
# prints whole file to screen
cat mytextfile# prints file to screen one screenful at a time
more mytextfile# prints file to screen, allowing for backwards movement and returns to previous screen view after finishing
# note: less does not require the whole text to be read and therefore will start faster on large text files then more or text-editors
less mytextfile# use a text editor (for example nano or here vi)
vi mytextfile
关于编辑的选择:我个人是 Vim 的忠实粉丝。然而，我承认一开始它确实有一个陡峭的学习曲线。如果你想从对初学者更友好的东西开始，你可以看看 nano。然而，为了将来，请记住 VIM，一旦您熟悉自己的工作方式，文本处理的速度将会惊人。
还可以返回文档的前 n 行或后 n 行
# show first 10 rows of a document
head -10 mytextfile# show last 10 rows of a document
tail -10 mytextfile
使用grep在文档中查找文本
# look for the string python in mytextfile
grep python mytextfile# search case-insensitive
grep -i python mytextfile# return line-numbers with the results
grep -n python mytextfile# search for a filename ("mybadfilename" in the example) (case insensitive) in all files with the ending *.py and return the occurences together with the line number
grep -in mybadfilename *.py
在上一个例子中，我们已经看到了一个占位符的例子。*.py 表示所有以. py 结尾的文件。
重定向输出
一些命令打印到屏幕上。为了将输出重定向到一个文件，我们可以使用>和>>。>>将输出附加到现有文件，或者如果文件尚不存在，则创建一个新文件。相反，>总是创建一个新文件。如果同名文件已经存在，它将覆盖该文件。以下是如何将grep -in mybadfilename *.py命令的输出重定向到文件的示例:
# creates new file; if file exists, overwrites it
mycommand > mytextfile
# example:
grep -in mybadfilename *.py > myoutputfile# appends output to file; if myoutputfile does not exist yet, creates it
mycommand >> mytextfile
# exammple:
grep -in mybadfilename *.py >> myoutputfile
如果除了将输出重定向到文件，我们还想要将输出打印到屏幕上，我们可以使用| tee。注意，完整的命令需要出现在|之前。
# print output to screen plus re-direct it to file
mycommand | tee myoutputfile# example:
grep -in mybadfilename *.py | tee myoutputfile
在前面的示例中，我们已经看到了管道(|)命令的用法。它是如何工作的？|将输出重定向到通常“从右边”获取输入的函数，因此输入应该在函数调用之后。一个例子:如前所述，grep需要语法grep sth filename。但是，您可能有一个返回输出的程序，并且想要在这个输出中寻找一些东西。这就是|发挥作用的地方。例如，ps aux显示系统上运行的所有进程。您可能希望搜索包含特定字符串的进程，例如 launch_。你应该这样做:
# grep for the string launch_ in the output of ps aux
ps aux | grep launch_
变量和脚本
变量
Bash 是一种脚本语言，不是类型化的。使用=符号定义和分配变量。变量名、=符号和值之间不能有任何空格。您可以使用$后跟变量名来访问变量的内容。您可以使用echo打印到屏幕上。
# define string variable
my_string_variable="this_is_a_string"# define numeric variable
my_numeric_variable=3# print variable to screen
# (will print this_is_a_string to the screen)
echo $my_string_variable
变量通常用于定义路径和文件名。当变量在文本中被重新求解时，需要在变量名周围加上{}。例如，考虑刚刚创建的变量 my_string_variable。假设你想打印' this_is_a_string_1 '。为了打印变量 my_string_variable 的内容，后跟 _1，请在变量名两边使用{}:
# incorrect (bash will think that the variable is called "my_string_variable_1"):
echo $my_string_variable_1# instead use:
echo ${my_string_variable}_1
在第二个例子中，bash 解析对 this_is_a_string 的引用，然后将 _1 追加到结果字符串中。
环
Bash 使用for ... do ... done语法进行循环。该示例显示了如何使用循环将文件 myfilename1 和 myfilename2 重命名为 myfilename1.bac 和 myfilename2.bac。请注意，列表元素之间没有逗号分隔。
rename files by appending a .bac to every filename
# no comma between list elements!
for myfilename in myfilename1 myfilename2
do
mv $filename ${filename}.bac;
done
为了遍历整数列表，首先使用序列生成器生成一个列表:
for i in $(seq 1 3)
do
echo $i
done
注意:$()打开一个子 shell，在这里解析()的内容。然后将结果返回到外壳。在上面的例子中，seq 1 3产生的序列 1 2 3 被传递回外壳，然后在外壳中循环。例如，这种行为可用于循环包含特定模式的文件:
for myfile in $(ls *somepattern*)
do
cp myfile myfile.bac
done
编写和执行(非常)基本的脚本
要创建脚本，创建一个包含 bash 语法的文本文件，使其可执行并运行它。让我们看一个非常基本的(公认非常无用的)例子。创建包含以下内容的文件:
#!/bin/bash# print myfilename.txt
echo "Hello World!"exit 0
并将其保存为 print_hello_world.sh。注意文件的第一行，它告诉 shell 使用哪个解释器。您可以通过为所有者添加执行权限来使其可执行，并由。/scriptname:
# add execution rights for file myfirstbashscript.sh for the owner of the file
chmod u+x print_hello_world.sh# run
./print_hello_world.sh
如果不是硬编码“Hello World！”，您希望用户将待问候的传递给脚本，您可以将它作为变量传递给脚本。让我们用以下内容创建一个新文件 print_hello_user.sh:
#!/bin/bash# print "Hello " + user-input
echo "Hello " $1exit 0
如果我们给它执行权，像这样执行
./print_hello_user.sh "Universe"
它会将“Hello Universe”打印到屏幕上。为什么？“Universe”作为文件名作为名为 1 的变量传递给脚本后的第一个输入变量，然后通过 print 语句中的$1 命令引用它。
最后的提示和技巧
- 尽可能使用 tab 补全:要自动补全，请按“Tab”键。如果有多个选项，按“Tab”两次以显示所有选项。
ESC + .将从上一行带回最后一个令牌。例子:cp file_a file_b；然后在下一行ESC + .会产生 file_b。- 括号结束:你可以使用
{}来缩短你的代码。例如，如果你想重命名一个文件，你可以输入mv myfilename{,.bac}。这作为mv myfilename myfilename.bac执行。对于交互式工作非常有用(虽然我不会在脚本中使用它)。 tail -f myfilename:tail filename在执行点产生尾部。但是，您可能希望能够在编写输出脚本时跟踪它们。tail -f照常开始tail，但是当新的行出现在输出文件的末尾时，继续追加。watch -n somenumber command每隔几秒执行一次命令。例如，watch -n 2 ls每 2 秒运行一次 ls。观看文件传输非常棒。
结论
在这篇文章中，我们看了使用 shell 的基本介绍。我们已经看到了如何在 shell 环境中定位自己，如何四处移动以及一些与文件的基本交互。最后，我们已经创建并运行了我们的第一个脚本，并查看了一些我最喜欢的技巧。虽然这应该会给您一个好的开始，但这只是对 shell 脚本这个怪异而奇妙的世界的一个小小的介绍。如果你想了解更多，这里的是一个很好的、广泛的脚本备忘单，可能会对你有进一步的帮助。有关该主题的完整内容，请查看 Mendel Cooper 的对 shell 脚本艺术的深入探索。和往常一样， StackOverflow 也提供了大量的建议和帮助:)玩得开心！
*附录:Shell 脚本如何让我花更多时间在沙滩上
我在圣塞巴斯蒂安攻读博士学位，圣塞巴斯蒂安是巴斯克地区的首府，也是著名的“La Concha”海滩的所在地。我的论文非常注重计算，需要协调许多不同的技术。我仍然天真地记得设置我的计算机来自动生成大量用于计算的输入文件，将计算提交给超级计算中心，等待它们完成，从输出中提取相关数据，可视化结果，创建一个完整的网页层次结构，并将所有这些推送到网络服务器，这样来自世界各地的多人就可以协作查看结果。只需按一下按钮，它就能完全自动地完成所有这些工作，而且做得非常可靠，从未出错。而我呢？我正在海滩享受午餐:)
原载于https://walken ho . github . io。
如何用 TensorFlow-2.0 替换张量中的索引值
NumPy 中一个看似简单的操作如何在一些不幸的情况下变成 TensorFlow 的噩梦
你有没有尝试过根据数组的索引只替换数组的某些值？
>>> import numpy as np
>>> a = np.array( [1,2,3,4,5] )
>>> print(a)[1 2 3 4 5]>>> i = [ 0, 1, 3 ]
>>> a[i] = -1
>>> print(a)[-1 -1 3 -1 5]
一个更复杂的用例可能是，例如，将某个阈值以上的所有值削波到最大值:
>>> import numpy as np
>>> a = np.array( [1,2,3,4,5] )
>>> print(a)[1 2 3 4 5]>>> a_max = 3
>>> i = np.where( a > a_max)
>>> a[i] = a_max
>>> print(a)[ 1 2 3 3 3]
事实证明，如果数组由一个张量表示，这种明显简单的操作在 TensorFlow 中是不允许的(但如果数组是一个 tf，这种操作是允许的。变量对象)。如果您尝试，最有可能的结果是这样的错误:
AttributeError: 'tensorflow.python.framework.ops.EagerTensor' object has no attribute 'assign'
事实上，我必须承认，我花了很长时间才想出如何解决这个经常出现的问题。在 StackOverflow 上有很多问题，人们在那里讨论同一个问题(例如，见这个)。我认为从 TensorFlow 操作的角度来看，最简单的方法是过滤希望将保留在一个向量中的元素，创建另一个向量，用希望替换的屏蔽值来“填充空白”(例如零、无穷大、一些其他默认值)，最后给出两者之和的结果。
我在这里给出一个例子来过滤一个向量的前 k 个元素，但是这个过程是非常通用的，包括以下步骤:
- 确定要删除的索引。通常，它们由布尔值向量表示，如【真、假、假、…、真】
- 将这个向量转换成包含实际索引的两个数组( idx_keep ， idx_replace )。这可以用很多方法来实现，但是我相信使用 tf.where 是最简洁的方法。
- 用要替换的值创建一个向量。在这个例子中，新值将是 -inf ，复制 N 次，其中 N =要替换的元素的数量= len(idx_replace)
- 用要保留的值创建一个向量。我通过使用函数 tf.gather( a，idx_keep ) 来完成这个任务，这个函数几乎相当于类似于 a[[0，1，3]] 的东西
- 创建上面两个集合的稀疏向量。恼人的部分是稀疏向量的索引必须是 2D，即使只有一维。我做的方法是创建零向量，然后我把它们和索引向量“堆叠”在一起。
- 将两个稀疏向量转换为密集向量，并将它们相加。
- 返回结果。
下面是一个代码示例:
A graphical representation of the workflow
不可否认，至少对于一些特定的情况，比如上面描述的裁剪，存在一个基于三参数版本的tf.where的更快的解决方案:
result = tf.where(condition, x, y)
返回的张量包含条件为True的x元素和条件为False的y元素。因此，在我们的例子中，上述函数可以简化为:
a = tf.where(tf.less_equal(a, a_max), a, a_max)
或者更明确地说:
def top_k_filtering(logits, top_k=5):
"Set values less than the k'th largest to -Inf."
kth_largest = tf.math.top_k(logits, top_k)[0][-1]
return tf.where(logits < kth_largest, -Inf, logits)
跟 TensorFlow 玩得开心！
如何在 fastai 中恢复中断的训练课程
如果使用 fit_one_cycle 的训练中途中断，该怎么办？
Courtesy of Gratisography@Pexels
如果您有一个庞大的数据集、一个庞大且训练缓慢的网络，并且您的训练会话在几个小时的训练后被中断，您会怎么做？发生这种情况的原因有很多:
- 因为你在谷歌 Colab 笔记本上达到了你的连续 12 小时“免费”操作时间；
- 您暂时失去了与 Colab 或 Kaggle 的联系；
- 因为你的电脑因为某种原因停了。我住在巴西，电力短缺是常事…
fast.ai 采用的 fit_one_cycle() 方法使用变化的、自适应的学习速率和动量，遵循速率先增加后减少的曲线，而动量则相反，如下图所示。
Cyclical learning rate and momentum variation in fit1cycle. Learning rate highlighting by Roger Mao.
如果您在第 10 个时段(比如说 20 个时段)中中断训练，然后再次开始 9 个时段以上的训练，您将不会获得与不间断地训练 20 个时段相同的结果，因为从头开始的新训练，即使您从上一个时段加载权重，也将采用新的学习速率和动量策略，并再次经历该循环。你想要的是从你在循环中被打断的地方开始。
Learning rate and momentum graphs for one fit1cycle training policy, divided into three consecutive training sessions. Image by PPW@GitHub
什么是 fit1cycle？
Fit1cycle 是 Leslie N. Smith 开发的超收敛策略。它被用作 fast.ai 中的标准培训策略。有关详细信息，请参见下文:
- https://docs.fast.ai/callbacks.one_cycle.html
- 神经网络超参数的训练方法:第 1 部分——学习速率、批量大小、动量和权重衰减—https://arxiv.org/abs/1803.09820
- 超级收敛:使用大学习率快速训练残差网络—https://arxiv.org/abs/1708.07120
如果你想看更多的论文，请点击这个链接:莱斯利·n·史密斯论文。我们不会在这个帖子中进入细节。媒体上有几篇帖子以简单易懂的方式介绍和讨论了第一轮训练政策:
- karan Bir Chahal 将训练神经网络的速度提高了 10 倍；
- Yogesh gur jar 内置正则化的超收敛；
- 超收敛:Aditya Gupta 使用大学习率非常快速地训练神经网络；
- Fast.ai Part1 v2/v3 笔记—学习率—从 SGDR 到 1cycle 和超收敛(Roger Mao)；
- [用 fastai 复制 Leslie N. Smith 的论文。](http://Reproducing Leslie N. Smith’s papers using fastai” by Kushajveer Singh)
Kushajveer Singh 的最后一个帖子是一个非常有说明性的 Jupyter 笔记本，值得一看。还有一篇来自 Nachiket Tanksale 的非常有趣的文章，名为寻找好的学习率和单周期政策，其中讨论了周期学习率和动量。
我如何恢复训练？
为此，您必须首先能够记录您停止的位置，然后从该点恢复训练周期，并使用该周期部分的正确超参数。你要做的第一件事就是保存你的网络:
# Do not forget to import the callback function
from fastai.callbacks import SaveModelCallback# Train with the callback function set to save weights every epoch
learn.fit_one_cycle(20, max_lr=slice(1e-5,1e-6),
callbacks=[SaveModelCallback(learn, every='epoch',
monitor='accuracy', name='saved_net')])
这将使您的网络在每个时期都被保存，您提供的名称后跟_ #时期。所以在时段#3，文件 saved_net_3.pth 将被写入。您可以在完成以下操作后加载此文件:
- 重新创建了数据束和
- 用这个特定的数据集群重新实例化了网络。
重装后。pth 文件，你可以重新开始你的训练，只是你要再次告诉 fit_one_cycle 考虑 20 个历元，而是从历元#4 开始训练。
Fast.ai 采用特殊的回调来实现这一点。要了解如何做到这一点的细节，请看这里:
怎么编码？
fast.ai 中的 fit_one_cycle 方法已经开发出来，允许您告诉它从周期的哪个部分恢复中断的训练。恢复培训的代码如下所示:
# Create a new net if training was interrupted and you had to
# restart your Colab sessionlearn = cnn_learner(data, models.<your_model_here>,
metrics=[accuracy, error_rate])# If you're resuming, only indicating the epoch from which to
# resume, indicated by ***start_epoch=<epoch#>*** will load the last
# saved .pth, it is not necessary to explicitly reload the last
# epoch, you only should **NOT** change the name given in
# name=<callback_save_file>: when resuming fast.ai will try
# to reload ***<callback_save_file>_<previous_epoch>.pth***# Unfreeze the network
learn.unfreeze()# Use start_epoch=<some_epoch> to resume training...
learn.fit_one_cycle(20, max_lr=slice(1e-5,1e-6),
***start_epoch=<next_epoch#>***,
callbacks=[SaveModelCallback(learn,
every='epoch', monitor='accuracy',
***name=<callback_save_file>***)])
…fast.ai 会告诉你“已加载<回调 _ 保存 _ 文件> _ <上一个 _ 纪元# > ”，恢复训练。
您可以在此查看 fit_one_cycle 方法支持的所有参数:
如何将这种恢复策略嵌入到我的网络中？
这篇文章的重点是告诉你如何在 fast.ai 中轻松恢复训练，如果被中断的话。如果你是 fast.ai 的新手，为了找到一些背景并学习如何将上面的代码集成到训练网络的整个过程中，请查看我们在下面的 TowardsDataScience 中的帖子:
图像分类:
- 深度学习用 fastai 诊断皮肤图像——学习从皮肤镜图像中识别皮肤癌和其他病症Aldo von Wangenheim；
- Aldo von Wangenheim 利用 fastai 进行疟疾检测的深度学习和医学图像分析；
语义分割:
- 人工智能&古生物学:利用深度学习搜索微化石奥尔多·冯·万根海姆；
我们学到了什么？
在这篇文章中，我们简要介绍了 fast.ai 采用的超级收敛 fit1cycle 训练策略，并展示了一些易于阅读的发布材料，如果你想深入研究，可以使用这些材料，而不必阅读 Leslie N. Smith 的科学论文。
我们还向您展示了如何以一种非常简单实用的方式，使用 fast.ai 的 fit_one_cycle() 方法的一些附加参数来执行完全可中断和可恢复的训练周期。
如何从复杂格式的文件中检索数据
我从 PDF 扫描图像中提取数据的方式
当我提取数据对马来西亚汽车市场进行分析时，我遇到了如何检索干净数据的问题。
我一直在谷歌上寻找可能有其他来源获得数据，但我没有找到答案。起初，我以为 pdfMiner 能够从 PDF 中提取一些文本，但都是 PDF 文件中的扫描图像。这是我唯一能得到的消息来源。
我很震惊，并感到累了，只是得到数据，并开始我的分析。过了一会儿，我尽力让引擎再次启动，谷歌搜索我找到了一个答案——OCR(光学字符识别)。
OCR 是一种识别数字或手写字符的技术。我发现最常用的库是 Python 中的 Tesseract OCR，这是一个由惠普公司发起的开源项目。在 Google 接手开发后，Google 发布了最稳定的基于深度学习框架的版本 4 . 0 . 0——LSTM(long short memory)。
简单来说，OCR 会逐行读取，逐字符识别字符，有两种
- 模式识别
- 基于特征的识别
1.模式识别
20 世纪 60 年代，一种叫做 OCR-A 的特殊字体被开发出来，用于银行支票等。所以，在当时，字体、笔画和字体大小都是标准化的，这样它就可以很容易地被识别为一个字符。然而，这种方式不能够识别不同种类的笔迹。
2.基于特征的识别
例如，一个字母“A ”,您可以将其视为 3 个笔画的组合:
因此，基于特征的识别可以在学习特征(笔画)时识别不同类型的笔迹。
换句话说，与简单的模式识别相比，像 LSTM 这样的基于特征的方法的当前技术能够识别字母“A”的特征。
我如何为马来西亚车辆分析检索数据
例如，在 NLP 中，我们经常有很多关于如何执行建模的想法，或者短语挖掘的多种方法。然而，当涉及到如何获取数据时，却常常被忽视。
首先，我必须通过谷歌搜索一些关键字，例如，马来西亚汽车协会(MAA)，但结果不是我想要的。因此，我试图更加具体，包括像 pdf 这样的关键字，所以最终使用了这个关键字:data 2017 年车辆销售数据。pdf 格式，以搜索所需的年度报告。通过改变年份，你将能够得到所有的年度报告。
然后，更有趣的部分来了:如何从包含快照图像的 pdf 中获取数据。我会把它分成两部分。
1.读入 pdf 文件，提取你需要的页面
我用的工具是 pdf2image 。它会将 pdf 的所有页面转换成图像。下面是我想提取文本的倒数第二页的快照。
所以我用 pdf2image 提取倒数第二页。然后，我只提取前 20 个品牌的汽车，并裁剪掉不相关的文本部分(如下图的紫色边界框所示)。使用这种方法，你将能够减少提取文本的噪音。
2.应用 OCR 将文本提取到 CSV
在裁剪掉所有不需要的部分后，我利用 tesserocr 包提取文本。以下是我在使用这个软件包时遇到的一些经验和问题。
如果你使用 tesserocr 的默认模型，你会发现这个模型犯了一些错误，例如 6 被预测为 8 和质子被预测为大虾，但总体来说还不错。因此，如果您使用默认模型，请对所有文本进行手动检查，以确保解析正确。
根据我的经验，使用宇宙魔方 3 和宇宙魔方 4 的主要区别是:
- 宇宙魔方 4 文本识别比宇宙魔方 3 好。
- 宇宙魔方 3 的数字识别比宇宙魔方 4 好。
Tesseract 支持超过 130 种语言，所以当你发现在解析文本时存在很多错误时，也许你应该考虑改变语言。
资源
作者克里斯·伍德福德。最后更新:2018 年 12 月 11 日。你曾经努力去阅读朋友的笔迹吗？算你自己吧…
www.explainthatstuff.com](https://www.explainthatstuff.com/how-ocr-works.html) [## Tesseract 版发布了基于 LSTM 的新引擎和更新的构建系统| Packt Hub
谷歌昨天发布了其 OCR 引擎 Tesseract 的 4.0 版本。宇宙魔方 4.0 带有一个新的神经网络(LSTM)…
hub.packtpub.com](https://hub.packtpub.com/tesseract-version-4-0-releases-with-new-lstm-based-engine-and-an-updated-build-system/)
最后的想法
其实还有更好的 OCR 服务，比如可以使用 Google OCR 付费服务进一步提高准确率。
我希望你喜欢这个帖子，并在下面评论你感兴趣的话题，我会努力为你创造内容！
关于作者
Low 魏宏是 Shopee 的数据科学家。他的经验更多地涉及抓取网站，创建数据管道，以及实施机器学习模型来解决业务问题。
他提供爬行服务，可以为你提供你需要的准确和干净的数据。你可以访问 这个网站 查看他的作品集，也可以联系他获取抓取服务。
如何在 15 分钟内用一个数据库和一个 GPU 在 Google Cloud 上运行一个数据科学的笔记本？
设置您的云外壳
首先，你需要有一个谷歌账户，并访问你的谷歌云控制台这里。
登录后，如果您是第一次使用 google cloud，您需要创建您的项目，方法是点击弹出窗口右上角的“选择一个项目，然后点击“新建项目，并按照几个简单的步骤创建您的第一个项目:
完成后，你应该会在谷歌云控制台窗口的顶部横幅中看到你的项目名称，而不是新项目。
现在，点击 Google Cloud 控制台窗口右上角的图标，打开您的云外壳(如果是第一次点击，您需要激活它，只需点击“启动云外壳”)。
你的云外壳窗口应该出现在当前谷歌云控制台窗口的底部。彩色文本是你的项目的名称，例如我的项目在这里是名称“first proj”+一个由谷歌提供的 id:
确保您的 ggcloud 组件保持最新并准备就绪:
sudo gcloud components update
安装和设置数据实验室
激活 API
Google Cloud console 要求您激活 API 以允许它们在您的项目上运行，如果您不这样做，您将不得不处理一个HTTPError 403:Access Not Configured错误。去那里，让我们激活所需的 API:https://console.developers.google.com/apis/library
搜索计算引擎 API 并启用它(如果尚未创建计费帐户，您将需要创建计费帐户)，确保 Google 云存储 API 已经启用:
安装 DataLab
gcloud components install datalab
现在，我们将创建一个数据实验室，该命令将创建一个具有数据科学基本要求的实例(我在这里选择了 n1-highmen-8，带有 8 个 vCPUs 和 52 GB 内存，请不要犹豫更改机器类型。要查看机器详情，请点击此处并点击此处):
datalab beta create-gpu your-datalab-instance-name --machine-type n1-highmem-8
您必须接受 NVidia GPU 驱动程序安装，然后选择一个区域，并按照查看步骤使用 SSH 访问您的 datalab 实例。
重要说明:默认情况下，create-gpu 命令使用 Nvidia Tesla K80 创建一个实例，该实例仅在那些选定的区域上可用:
us-west1-b
us-central1-a
us-central1-c
us-east1-c
us-east1-d
europe-west1-b
europe-west1-d
asia-east1-a
asia-east1-b
安装完成后，您可以通过在云 Shell 中键入以下命令，在 windows 浏览器中运行您的 datalab:
datalab connect your-datalab-instance-name
然后通过点击改变端口:将端口设置为 8081 打开一个窗口浏览器
给你！您刚刚安装了您的 Datalab Google 实例，它看起来应该如下图所示。你现在可以像使用普通的 Jupyter 笔记本一样使用它了。
设置你的谷歌云存储
一个实例不应该被用作一个存储环境这就是为什么 Google Cloud 提供了许多不同服务来提供不同种类的存储服务。这里我们就用最简单的一个:谷歌云存储。
点击左侧菜单，进入谷歌云的“存储”服务。
创建存储桶:
一切就绪，谷歌云存储非常简单，只需像通常的操作系统一样点击即可访问:
在你的数据实验室使用你的谷歌云存储
这是一个简单的示例函数，从 bucket 中读取一个文件和一个 csv。
import google.datalab.storage as storage
import pandas as pd from io
import BytesIO def get_bucket(bucket_target):
shared_bucket = storage.Bucket(str(bucket_name))
return shared_bucketdef read_file_from_bucket(file_target):
shared_bucket = get_bucket(bucket_target)
sample_object = shared_bucket.object(str(file_target)
sample_text = sample_object.read_stream()
return sample_textdef read_csv_from_bucket(bucket_name,csv_file_name):
%gcs read --object gs://+bucket_name+/+file_name --variable csv_as_bytes
df = pd.read_csv(BytesIO(csv_as_bytes))
return df
要打印存储桶的内容，请执行以下操作:
shared_bucket = get_bucket(bucket_name)
for obj in shared_bucket.objects():
if obj.key.find('/') < 0:
print(obj.key)
例如，要打印文本文件:
sample_text = read_file_from_bucket(file_name)
print(sample_text)
要获取 csv 表格作为数据帧:
df = read_csv_from_bucket(bucket_target,file_target)
df.head()
现在，您已经有了一台连接到存储云的高性能笔记本电脑，可以用于您的数据科学项目了！
尽情享受吧！😃
如何从 EC2 实例运行 Spark 应用程序
为什么你会这样做，而不是使用电子病历？好吧，问得好。在某些情况下，使用 EC2 可能比使用 EMR 更便宜，但在其他情况下，EMR 可能是可取的。无论如何，下面是如何从 EC2 实例运行 Spark 应用程序:
Photo by Steve Richey on Unsplash
我使用了一个深度学习 AMI (Ubuntu 16.04)版本 25.3，带有一个 p3 实例，用于加速计算。
SSH 到您的 EC2 实例。
ssh -i pem_key.pem ubuntu@public_dns_key
从一开始，你就安装了一些东西。
您在 EC2 终端中键入:
java -version
它返回:
openjdk version “1.8.0_222”OpenJDK Runtime Environment (build 1.8.0_222–8u222-b10–1ubuntu1~16.04.1-b10)OpenJDK 64-Bit Server VM (build 25.222-b10, mixed mode)
Java 8 是我们希望 Spark 运行的，所以这很好。
我的应用程序是使用 python 编写的，所以我想检查它是否已安装。
python --version
它返回:
Python 3.6.6 :: Anaconda, Inc.
太好了！
现在你需要安装 Hadoop。
我使用了以下准则:
https://data wookie . netlify . com/blog/2017/07/installing-Hadoop-on-Ubuntu/
- 去 Spark 下载网站看看它用的是哪个版本的 Hadoop:
It uses Hadoop 2.7, as of November 2019, this may be different for you.
2.它使用 Hadoop 2.7。好了，现在转到 Hadoop 镜像站点并使用 wget
- 右键单击，将链接复制到 Hadoop-2.7.7.tar.gz
- 输入你的 ubuntu 终端(粘贴你刚刚复制的，我加粗是为了让你知道你的可能不一样):
wget [**http://apache.mirrors.ionfish.org/hadoop/common/hadoop-2.7.7/hadoop-2.7.7.tar.gz**](http://apache.mirrors.ionfish.org/hadoop/common/hadoop-2.7.7/hadoop-2.7.7.tar.gz)
3.打开压缩的内容
tar -xvf hadoop-2.7.7.tar.gz
4.找到 java 的位置
type -p javac|xargs readlink -f|xargs dirname|xargs dirname
它返回:
/usr/lib/jvm/java-8-openjdk-amd64
好的，复制你的输出^
5.好了，现在编辑 Hadoop 配置文件，这样它就可以与 java 交互了
vi hadoop-2.7.7/etc/hadoop/hadoop-env.sh
键入i通过粘贴您复制的输出来插入和更新 JAVA_HOME 变量
要退出 vim，使用 ESC + :wq！(wq 代表 write 和 quit，解释点就是强制)
6.设置 HADOOP_HOME 和 JAVA_HOME 环境变量。JAVA _ HOME 环境变量指向计算机上安装 JAVA 运行时环境(JRE)的目录。目的是指向 Java 安装的位置。
您可以通过使用
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64export HADOOP_HOME=/home/ubuntu/hadoop-2.7.7
并更新您的路径:
export PATH=$PATH:$HADOOP_HOME/bin/
但是如果关闭 EC2 实例，这可能无法保存。所以我使用 vim 并把这些导出添加到我的。bashrc 文件。
不及物动词 bashrc，I 表示插入，然后:wq 表示完成。
PS:这是你如何删除路径中的副本，你不需要这样做，它们不会伤害任何东西，但如果你想知道:
if [ -n "$PATH" ]; then
old_PATH=$PATH:; PATH=
while [ -n "$old_PATH" ]; do
x=${old_PATH%%:*} # the first remaining entry
case $PATH: in
*:"$x":*) ;; # already there
*) PATH=$PATH:$x;; # not there yet
esac
old_PATH=${old_PATH#*:}
done
PATH=${PATH#:}
unset old_PATH x
fi
来源:https://UNIX . stack exchange . com/questions/40749/remove-duplicate-path-entries-with-awk-command
7.找到你的。bashrc 文件，在您的主目录中键入source .bashrc
8.现在要检查版本，您可以回到您的主目录并键入
hadoop 版本，它应该会告诉您
9.您可以从您的主目录中删除压缩的 tar 文件:rm hadoop-2.7.7.tar.gz
现在你需要安装 Spark。我遵循这些准则:
https://data wookie . netlify . com/blog/2017/07/installing-spark-on-Ubuntu/
1.转到该站点并复制第一个镜像站点的链接地址
2.在你的 ubuntu 终端中输入 wget 并粘贴复制的链接
wget [http://mirrors.sonic.net/apache/spark/spark-2.4.4/spark-2.4.4-bin-hadoop2.7.tgz](http://mirrors.sonic.net/apache/spark/spark-2.4.4/spark-2.4.4-bin-hadoop2.7.tgz)
3.现在解压压缩的 tar 文件
tar -xvf spark-2.4.4-bin-hadoop2.7.tgz
4.给你的环境变量添加火花export SPARK_HOME=/home/ubuntu/spark-2.4.4-bin-hadoop2.7
5.安装 scala。为什么我们在这里用简单的方法？因为我们不需要查看 jar 文件或任何东西。
sudo apt install scala
现在你必须确保 Spark、Hadoop 和 Java 能够协同工作。在我们的情况下，这也包括能够从 S3 读和写。
a.导航到 EC2 终端中的文件夹~/spark-2.4.4-bin-hadoop2.7/conf
运行代码:
touch spark_defaults.confvi spark_defaults.conf
在这里，您需要添加下面几行:
如果 2FA 适用于您:确保您的访问密钥和秘密密钥是用于服务帐户的(不与用户名/密码相关联)
spark.hadoop.fs.s3a.access.key ***your_access_key***spark.hadoop.fs.s3a.secret.key ***your_secret_key***spark.hadoop.fs.s3a.impl org.apache.hadoop.fs.s3a.S3AFileSystemspark.driver.extraClassPath /home/ubuntu/spark-2.4.4-bin-hadoop2.7/jars/**hadoop-aws-2.7.3**.**jar**:/home/ubuntu/spark-2.4.4-bin-hadoop2.7/jars/**aws-java-sdk-1.7.4.jar**
b.如何确保这些 jar 文件是正确的呢？？我把它们加粗是因为它们对你来说可能不一样。所以要检查，去你的 Hadoop jars。
使用 cd 转到以下文件夹:cd ~/hadoop-2.7.7/share/hadoop/tools/lib并检查哪些罐子用于aws-java-sdk和hadoop-aws，确保这些。jar 文件与您刚刚放入spark_defaults.conf的内容相匹配。
c.将这些文件复制到 spark jars 文件夹:
为了让下面的代码工作，请放在~/hadoop-2.7.7/share/hadoop/tools/lib文件夹中
cp **hadoop-aws-2.7.3.jar** ~/spark-2.4.4-bin-hadoop2.7/jars/cp **aws-java-sdk-1.7.4.jar** ~/spark-2.4.4-bin-hadoop2.7/jars/
配置 Hadoop
a.让你的每个工作节点都可以访问 S3(因为我们的代码从 S3 读写)
https://github.com/CoorpAcademy/docker-pyspark/issues/13
编辑文件hadoop-2.7.7/etc/hadoop/core-site.xml以包含以下行:
<configuration>
<property>
<name>fs.s3.awsAccessKeyId</name>
<value>*****</value>
</property><property>
<name>fs.s3.awsSecretAccessKey</name>
<value>*****</value>
</property>
</configuration>
b.将下面的 jar 文件复制到hadoop-2.7.7/share/hadoop/common/lib目录
sudo cp hadoop-2.7.7/share/hadoop/tools/lib/aws-java-sdk-1.7.4.jar hadoop-2.7.7/share/hadoop/common/lib/sudo cp hadoop-2.7.7/share/hadoop/tools/lib/hadoop-aws-2.7.5.jar Hadoop-2.7.7/share/hadoop/common/lib/
好了，现在您已经准备好克隆您的存储库了
git 克隆路径/到/your/repo.git
确保将下面一行添加到您的。bashrc 文件:
export PYTHONPATH=$PYTHONPATH:/home/ubuntu/repo
PYTHONPATH 是一个环境变量，您可以设置它来添加额外的目录，python 将在这些目录中查找模块和包。对于大多数安装，您不应该设置这些变量，因为 Python 运行不需要它们。Python 知道在哪里可以找到它的标准库。
设置 PYTHONPATH 的唯一原因是维护您不想安装在全局默认位置(即 site-packages 目录)的自定义 Python 库的目录。
来源:https://www . tutorialspoint . com/What-is-Python path-environment-variable-in-Python
现在运行您的代码！
快乐火花！
有关在 EC2 中使用 Spark 的更多信息
查看 Snipe.gg 的博客:
[## 在 AWS 上运行 Apache Spark，而不会让银行破产
在 Snipe，我们处理大量的数据。考虑到有超过 1 亿的活跃联盟…
medium.com](https://medium.com/snipe-gg/running-apache-spark-on-aws-without-busting-the-bank-5566dad18ea3)
在他们的案例中，他们发现
[……]在检查了 EMR 定价后，我们发现 EMR 在其使用的 EC2 实例的价格上增加了高达 25% 的定价开销
这个博客也很好地突出了工具和生产我刚刚概述的努力的考虑。
如何在云中运行 Jupyter 笔记本
专注于数据科学而不是开发运维
介绍
开始从事数据科学时，DevOps 任务是您应该担心的最后一件事。试图掌握数据科学的所有(或大部分)方面需要大量的时间和实践。然而，如果你碰巧参加了新兵训练营或其他类型的学校，很可能你迟早要完成小组项目。然而，在没有任何 DevOps 知识的情况下协调这些可能是一个相当大的挑战。我们如何共享代码？我们如何处理非常昂贵的计算？我们如何确保每个人都在使用相同的环境？诸如此类的问题很容易阻碍任何数据科学项目的进展。
对于熟悉 GitHub 和云计算的人来说，这些问题可能非常直接。尽管如此，根据我参加纽约市数据科学学院为期 12 周的训练营的个人经验，这些问题与试图处理极其昂贵的计算或在小组中工作的数据科学新手非常相关。虽然人们确实可以使用 AWS、Azure、GCP(谷歌云平台)或任何其他云服务提供商来解决这些问题，但同时掌握数据科学和云计算是一项不必要的困难任务。为什么不使用熟悉的带有扩展的工具呢？
云端的 Jupyter 笔记本
Jupyter 笔记本在数据科学领域非常受欢迎，这是理所当然的。它们为用户提供了简洁的界面，并且易于使用。基本上，他们让用户专注于他们想做的事情:写一些代码并立即执行。然而，也有局限性。首先，Jupyter 笔记本运行在你的本地机器上，使你的计算能力完全依赖于你的计算机的 CPU/GPU/RAM/等。规格。虽然大多数笔记本电脑对于一个人在开始从事数据科学时遇到的基本任务来说绰绰有余，但一旦你开始在本地机器上进行机器学习，特别是深度学习，你可能会很快遇到障碍。此外，当进行团队项目时，需要找到一种方法与队友共享 Jupyter 笔记本。虽然使用 GitHub 可以让你分享你的代码，但它需要你知道如何使用 GitHub，而且它不能让你仅仅分享一个链接，让你的队友能够看到和编辑你的工作。顺便提一下，GitHub 还要求你的所有队友记得将他们的最新版本提交给 GitHub，如果你以前从未从事过数据科学小组项目，这很容易被忘记。
因此，一个人要么需要知道如何与云服务提供商和 GitHub 合作，要么就会有延迟的团队项目和非常热门的笔记本电脑。
土星云
土星云允许你在云中快速旋转 Jupyter 笔记本，并根据你的需求进行缩放。基本上，它让你可以在 AWS、Azure 或 GCP 内部的虚拟机上运行你的 Jupyter 笔记本，而不需要你知道如何正确设置和使用这些服务。它还有几个非常好的特性，使它有别于其他产品，例如让您能够指定 conda 环境、requirements.txt 或 docker 映像，以便跨所有团队标准化环境。您还可以使用链接与公众或队友共享您的 Juypter 笔记本。这消除了理解如何使用 GitHub 进行基础数据科学项目的需要。如果您确实知道如何使用 GitHub，它仍然提供了一种快速方便的方法来测试和开发代码。因此，(有抱负的)数据科学家可以专注于数据科学，而不是开发运维，并以比其他方式更快的速度完成他们的项目。
除此之外，Saturn Cloud 使您只需点击一下鼠标就可以部署 Spark 或 Dask 集群。这简化了处理非常昂贵的计算的问题，只需点击一下鼠标就可以使用分布式计算。Saturn Cloud 还为您自动化了版本控制，避免了由于团队成员没有提交他们的最新版本而产生的潜在问题。
由于我个人更喜欢演示而不是描述，我将快速向您展示如何使用土星云旋转 Jupyter 笔记本。
Spinning up a Jupyter Notebook on Saturn Cloud
首先，命名您的笔记本电脑并定义您想要使用的 VM(虚拟机)。你需要做的就是指定磁盘空间和内存。如果你默认 10 分钟不使用它，Saturn Cloud 会自动终止你的虚拟机。但是，您可以将它更改为您喜欢的任何时间段。使用高级选项，您可以定义您希望您的团队使用的环境。点击 create 后，你云端的 Jupyter 笔记本就启动了。
一旦启动并运行，您将看到以下内容:
通过点击“转到 Jupyter 笔记本”，您可以在云端访问您的 Jupyter 笔记本并开始编码。对于大多数简单的任务，这基本上就是你需要做的全部。如果您想要使用更高级的选项，，例如部署 Spark/Dask 集群或使用 GPU 处理您的工作负载，您只需在现有的 Jupyter 笔记本电脑中点击上面的蓝色按钮，并按如下方式定制您的虚拟机即可:
Adding a GPU to your VM
为什么要为虚拟机添加 GPU(图形处理单元)？非常简单地说:把你想要训练的算法(比如一个神经网络)想象成一系列的数学计算。现在，有了 GPU，你基本上可以同时进行所有的计算，而有了 CPU，你可以一个接一个地进行计算。本质上，这就是为什么 GPU 是昂贵计算的更好选择，特别是在机器学习方面。
正如您所看到的，使用土星云可以非常直观地开始在云端使用 Jupyter 笔记本。一旦您的笔记本运行，您还可以轻松地从笔记本内部与公众或您的队友分享。为了证明这一点，我出版了一本笔记本，可视化纽约市的老鼠目击事件，您可以使用以下链接访问:
结论
当试图启动数据科学团队项目时，开发运维可能是一个真正的难题。托管带有土星云的 Jupyter 笔记本，同时还负责版本管理等工作，并能够根据需要扩展或缩小，这可以极大地简化您的生活。就个人而言，快速轻松地共享笔记本的能力确实很有帮助。然而，最重要的是，在开始任何项目之前，你应该仔细评估和确定你的需求。
如何在 3 分钟内免费在 AWS 上运行 RStudio
说到数据分析，我有理由从你的本地电脑转移到云端。最突出的是，您可以运行无限数量的机器，而不需要拥有或维护它们。此外，您可以在几分钟内随意缩放。如果您选择运行 t2.micro 服务器，在最初的 12 个月内，您可以每月免费运行 750 个小时！之后，每个月和服务器就要几美元。
好吧，让我们开始吧！可以理解的是，在点击了一个承诺在 3 分钟内为你提供解决方案的标题后，你将没有时间去阅读一篇十分钟的关于 RStudio Sever 和 T2 亚马逊网络服务的文章。所以我跳过正式的介绍，直接切入正题。
第一步:登录你的 AWS 账户(如果你是 AWS 新手，也可以创建一个)
第二步:转到 Louis Aslett 的网站，选择您希望您的虚拟机驻留的地区，然后单击它旁边的链接(例如， ami-02bf650155c44b475 代表美国西部，N. California)。该链接将直接引导您到 EC2 管理控制台。
步骤 3: 单击启动实例向导。几乎所有的东西都已经预先填写好了，你的屏幕应该看起来像下面的截图。先不要按“查看并启动”。为了确保万无一失，我们需要检查一遍整个过程，所以请按“下一步:……”。
Nothing to change here. Press Next: Configure Instance Details.
Nothing to change here. Press Next: Add Storage.
Nothing to change here. Press Next: Add Tags.
Nothing to change here. Press Next: Configure Security Group
啊哈！这里你需要再次活跃起来。点击“添加规则”，选择 HTTP 并将“源”从自定义改为任意位置。现在它应该看起来像下面的截图。
你快完成了！只需按下下一页的“查看并启动”和“启动”。最后一步是选择 SSH 安全密钥。虽然这不是最安全的设置，但最快的是选择不带钥匙继续。只需复制下一个截图中的设置，然后按“启动实例”
现在，亚马逊将完成剩下的工作。
不幸的是，这可能需要 5 分钟…
但是嘿！那不是我的错，对吗？请不要因为我在题目中的虚假承诺而生气。一个小小的点击诱饵不会伤害任何人……给我写封电子邮件，告诉我我是如何滥用你的信任，以及谷歌和脸书的算法是如何支持这种新闻报道方式的。我向你保证:一旦你写完第一段，你的服务器就启动并运行了！😃
JK，实际上只需要一分钟。
Server still pending…
… and this is how it looks like once everything is done.
如果你的主机长得像上面的截图:恭喜你！您现在是 RStudio 服务器的所有者。
只需复制“IPv4 公共 IP”(这里:54.193.0.253)，并在一个新的标签中打开它。RStudio 服务器要求您登录。您的初始用户名是“rstudio ”,密码是该服务器的“实例 ID ”(这里是:i-09784d4946595e752 ),也可以在 AWS 控制台中找到。
请击鼓…..
搞定了。
现在，您可以复制想要在云中运行的脚本，或者编写一个新的脚本。RStudio 服务器的外观和操作与本地 RStudio 几乎完全相同。
那不是很容易吗？
好吧，该表扬就表扬。路易·阿斯莱特就是这个原因。他为虚拟机准备了模板，即所谓的 Amazon 机器映像(AMI ),它可以开箱即用地运行 RStudio 服务器(以及 my things more)。这些是您在步骤 2 中选择的。
如果你对我的逐步指导有困难，请访问他制作的视频。它不再是最新的了，但是有了这个指南，你将在几分钟内实现它！如果你有困难，可以写评论。现在开始用您的脚本填充您的 RStudio 服务器吧！
请务必关注我的媒体简介，获取有关 RStudio、数据科学和影响者欺诈的新帖子的更新。如果你想谈论我在市场营销方面的研究或数据科学，你可以在 LinkedIn 或 Twitter 联系我。
感谢阅读，
乔纳斯·施罗德
如何在数据科学团队中运行 Scrum
在数据项目中使用 scrum 框架时，关于团队结构、技能、交叉功能、产品待办事项、冲刺长度、困难和好处的实践经验技巧。
后续——不要错过我即将发表的文章，其中包含一个案例研究的产品 backlog 项目，它展示了如何将 pbi 分成更小的部分并创建垂直切片。
我在一个敏捷团队中工作，该团队由 7 个团队和 58 个人组成，旨在为银行的现有产品提供人工智能功能。其中一个团队是架构团队，其他的是交付团队。
商业案例示例
它可以是任何数据科学案例，如客户流失预测、客户风险计算、信用评分、人脸识别、情绪检测、欺诈检测、预防性维护等
团队结构
Scrum 团队需要包括 3 到 9 名成员。我建议团队的最佳人数是 5 人，包括产品负责人。
有 4 个重要问题需要考虑:
问题 1:团队应该具备哪些技能？
这个列表可能会更长，我已经指出了最关键的技能:
- 分析以理解领域和需求
- 从不同来源收集必要数据的数据传输
- 数据预处理以创建模型所需的特征
- 可视化，从数据中获得洞察力，并与业务部门交流
- 建模以创建预测模型
- 建立数据管道，实现完全自动化的现场体验
- API 或 web 服务开发来打开预测服务
- 测试上线后的“平静生活”。
- 仪表板开发，以技术和商业方式监控生产寿命。
问题-2:对于一个由 5 个人组成的团队来说，拥有所有这些技能可能吗？
不容易，但有可能。团队成员是跨职能的(产品负责人除外)。这并不意味着所有的团队成员都必须是所有这些领域的专家，但是他们应该在一两个领域是合格的。这就是 T 型人的确切定义。
我的观察告诉我，这个交叉功能的最佳候选人是具有软件开发背景的人。
问题 3:这些技能有角色吗？
理想情况下，不应该有。事实上，作为一个拥有大量数据的新生部落，我们决定从角色开始。因此，我们分享了 4 个不同的角色:
- 数据翻译:调整团队和业务方面，分析领域
- 数据科学家:建模
- 数据工程师:数据处理
- 数据架构:为其他团队的基础设施需求服务
问题-4:为什么 5 人是最佳团队规模？
不是规则，而是基于最佳实践的理论:
- 团队可以挤在一辆车里，一起参加活动:)
- 当团队规模越来越大时，scrum 仪式变得越来越低效，越来越耗时，这对团队的整体效率产生了负面影响。
- 团队可能倾向于创建更小的团队来一起工作，这导致了知识转移和同步问题。
产品待办事项 &在 Sprint 评审中呈现什么？
对于一个典型的软件开发团队来说，答案非常简单:产品 backlog 项目通常是用户故事，团队总是展示一个工作软件(即使 PBI 是一个错误，而不是用户故事)。
然而，数据科学团队的答案更复杂。以下是产品待办事项类别以及每种类别的展示内容:
- 数据洞察:这类产品 backlog 项目的主要焦点是理解现有的数据和结构。输出通常是图表或表格。在最初的冲刺阶段，有更多的洞察型输出。如果客户流失是一个项目，那么“流失率与时间”线图或“根据客户年龄组的流失率”条形图就是很好的例子。
- 模型结果:这对于团队和涉众来说都是最有吸引力的类别。您处理预测模型，并在 sprint 评审中展示它们的结果，一起讨论它们。一般来说，我们会集体思考模型的准确性和稳健性，模型在哪些领域表现最佳，在哪些领域表现不佳。当然，3 到 6 个月后工作的可能结果也包括在议程中。对于这种类型的 PBI，与业务部门的额外会议可能是必要的，因为讨论可能比预期花费更多的时间。
- 仪表板:它是最接近工作软件原则的产品积压类别。团队创建一个仪表板，并在评审中将其显示为工作仪表板。在模型的成熟度达到一定水平之后，团队可以处理这种类型的待定项。
- API 开发:如果模型将作为服务开放，则需要进行服务开发。当团队完成此 PBI 时，他们会展示几张幻灯片，其中包括与现有软件的集成架构、API 的响应字段、现有软件将如何使用它获得的这些响应、API 对现有结构的非功能性影响(例如响应时间)。
- ETL 开发:如果模型结果将被批量使用，就需要 ETL 开发。当团队完成此 PBI 时，他们会展示几张幻灯片，其中包括与现有软件的集成架构、文件中传输的字段、现有软件如何使用它获得的字段、如何安排此文件传输。
- 法规项目:处理数据的团队应了解 GDPR(一般数据保护法规)，这些法规可能因国家/地区而异。专门处理客户数据的数据科学团队可能需要准备一些文档并获得一些批准。这个 PBI 是为了所有这些作品的努力。
- 监控和推广:应该监控人工智能模型在生产中的表现。A/B 测试是最好的方法之一。结果可能比预期的更糟，可能需要进行一些修改。应制定并遵循推广战略。
产品待定项必须是什么样的？如何创建薄的垂直切片并分解它们？—不要错过我的下一篇文章，我将为您提供关于这些主题的更多细节和示例。
冲刺长度
冲刺长度可以在 1 周到 4 周之间。我相信 1 周对于软件开发团队来说是完美的，但是对于数据科学团队来说太短了。由于数据传输和预处理任务可能需要几天时间，并且准备好的数据本身并不是要呈现的输出，团队必须对其进行更多的工作以产生一些输出。
我们已经开始了为期一周的冲刺，但团队不得不在每个冲刺阶段都加班加点，毫无例外地出现了精疲力竭的信号。然后团队决定将冲刺长度改为 2 周。
以下是经过两周冲刺后观察到的结果。
- 快乐团队
- 产出质量提高
- 利益攸关方对产出更加满意
- 团队速度增加！！！1 周冲刺的平均速度约为 35，2 周冲刺的平均速度变为 85(平均速度在最少 5 次冲刺后计算)。
困难
让我们接受它——scrum 是一种很好的工作方式。尽管如此，在所有团队成员都习惯了它的方法之前，请为一些挑战做好准备，比如:
- 那些习惯于处理详细项目计划的人开始批评 scrum 缺乏远见。他们掌握 scrum“路线图”哲学需要时间。
- 喜欢独自工作的人开始抱怨花费在仪式和交流上的时间。他们相信如果不被打扰，他们的生产力会提高。
- 学习为数据科学项目创建薄的垂直产品 backlog 项目的艺术需要时间。
- 对于软件开发来说，编写和声明 done 的定义很容易。设置最小测试覆盖率或者把完成用户验收测试作为一个必须的例子。此外，您可以将其应用于您的所有 pbi。另一方面，对于数据科学敏捷团队来说，这些任务更具挑战性。由于所涉方案预算多种多样，几乎不可能为所有项目找到一个共同的完成定义。此外，即使对于一些 PBI 类型，比如迭代试错模型，找到 done 的定义也是很痛苦的。
- 编写验收标准也比软件开发案例更复杂。PBI 数据洞察类型的验收标准是什么？团队只是探索数据和领域，然后将可视化带到评审会议上进行讨论。“应该对数据进行可视化”并不是验收标准的一个好例子，对吗？
好处
尽管存在上述所有困难，但还是有很多好处:
- 团队精神建立起来了，工作变成了一项有趣的活动。
- 自我组织能力提高。团队在回顾会议中解决了大部分问题。
- 应用 scrum 让团队保持一致。每个团队成员都知道产品的远景和路线图。
- 在几次冲刺之后，团队速度变得确定，可预测性出现了。
总之
在这篇文章中，我试图分享我自己关于在数据项目中使用 scrum 框架的想法。请注意，条件和规则可能因团队和案例的不同而不同。这使得 scrum 令人兴奋，不是吗？
如果你有任何进一步的问题，请不要犹豫，写信给:haydarozler@gmail.com。
如何对 PDF 文件运行 SQL
pdf 是今天分发和共享固定布局文档的事实标准。对我的笔记本电脑文件夹的快速调查显示，账户报表、收据、技术论文、书籍章节和演示幻灯片都是 pdf 格式的。许多有价值的信息都可以在各种 PDF 文件中找到。这也是 Rockset 支持对 PDF 文件进行 SQL 查询的重要原因，我们的使命是让数据对每个人都更有用。
Rockset 中 pdf 上的快速 SQL
Rockset 使开发人员和数据从业者可以轻松地在各种数据格式的半结构化数据上接收和运行快速 SQL，如 JSON、CSV 和 XLSX，而无需任何前期数据准备。现在将 PDF 添加到混合数据中，用户可以将 PDF 数据与来自不同来源的其他格式的数据组合到他们的 SQL 分析中。或者一起分析多个 pdf 也可能是有价值的，如果你像我一样有一系列的电费账单，我们将在下面的简短例子中看到。
上传 pdf 文件
从现有的集合中，点击控制台右上角的上传文件按钮，并指定 PDF 格式以摄取到 Rockset 中。
查询 pdf 中的数据
我上传了 9 个月的电费。我们可以使用 DESCRIBE 命令来查看从 pdf 中提取的字段。
> describe "elec-bills";
+--------------------------------------------+---------------+---------+-----------+
| field | occurrences | total | type |
|--------------------------------------------+---------------+---------+-----------|
| ['Author'] | 9 | 9 | string |
| ['CreationDate'] | 9 | 9 | string |
| ['Creator'] | 9 | 9 | string |
| ['ModDate'] | 9 | 9 | string |
| ['Producer'] | 9 | 9 | string |
| ['Subject'] | 9 | 9 | string |
| ['Title'] | 9 | 9 | string |
| ['_event_time'] | 9 | 9 | timestamp |
| ['_id'] | 9 | 9 | string |
| ['_meta'] | 9 | 9 | object |
| ['_meta', 'file_upload'] | 9 | 9 | object |
| ['_meta', 'file_upload', 'file'] | 9 | 9 | string |
| ['_meta', 'file_upload', 'file_upload_id'] | 9 | 9 | string |
| ['_meta', 'file_upload', 'upload_time'] | 9 | 9 | string |
| ['author'] | 9 | 9 | string |
| ['creation_date'] | 9 | 9 | int |
| ['creator'] | 9 | 9 | string |
| ['modification_date'] | 9 | 9 | int |
| ['producer'] | 9 | 9 | string |
| ['subject'] | 9 | 9 | string |
| ['text'] | 9 | 9 | string |
| ['title'] | 9 | 9 | string |
+--------------------------------------------+---------------+---------+-----------+
Rockset 解析出所有元数据，如author、creation_date等。从文档中随同text。
text字段通常是 PDF 中大多数信息所在的地方，所以让我们检查一下示例text字段中有什么。
+--------------------------------------------------------------+
| text |
|--------------------------------------------------------------|
| .... |
| .... |
| Statement Date: 10/11/2018 |
| Your Account Summary |
| .... |
| Total Amount Due: |
| $157.57 |
| Amount Enclosed: |
| ... |
+--------------------------------------------------------------+
合并来自多个 pdf 的数据
在 Rockset 中获取并索引了我 9 个月的电费账单后，我可以对这段时间内的使用情况做一些简单的分析。我们可以运行 SQL 查询来选择text中的月/年和账单金额。
> with details as (
select tokenize(REGEXP_EXTRACT(text, 'Statement Date: .*'))[3] as month,
tokenize(REGEXP_EXTRACT(text, 'Statement Date: .*'))[5] as year,
cast(tokenize(REGEXP_EXTRACT(text, 'Total Amount Due:\n.*\nAmount Enclosed'))[4] as float) as amount
from "elec-bills"
)
select concat(month, '/', year) as billing_period, amount
from details
order by year asc, month;
+----------+------------------+
| amount | billing_period |
|----------+------------------|
| 47.55 | 04/2018 |
| 76.5 | 05/2018 |
| 52.28 | 06/2018 |
| 50.58 | 07/2018 |
| 47.62 | 08/2018 |
| 39.7 | 09/2018 |
| <null> | 10/2018 |
| 72.93 | 11/2018 |
| 157.57 | 12/2018 |
+----------+------------------+
并将结果绘制在超集中。
我 10 月份的账单出人意料地为零。账单金额提取不正确吗？我回去查了一下，结果是我在 10 月份收到了一份加州气候信用，这使我的账单归零了，所以摄取和查询 pdf 就像它应该的那样工作了！
最初发表于【rockset.com】。
如何从语言模型中取样
标准抽样技术与新核心抽样的探讨
Humans often choose words that surprise language models (Holtzman et al 2019)
像 GPT-2 这样的因果语言模型被训练来预测给定一些上下文下一个单词的概率。例如，给定“我吃了一个美味的热 __ ”,模型可能以 80%的概率预测“狗”，以 5%的概率预测“煎饼”，等等。这个结构很酷的一点是，它们可以用来生成任意长度的序列。我可以给这个模型一个“我吃了”，从结果分布中抽取一个令牌来得到“我吃了一个”，然后再次通过这个模型来得到另一个分布和结果令牌。我们想重复多久就重复多久。事实证明，这一代人经常要么陷入重复的循环，要么忘记主题，跑题。为什么会发生这种情况，我们如何更好地采样以生成更像人类的文本？
本帖是霍尔茨曼等人 2019 对神经文本德代的好奇案例的总结和探索。我发现这是我近年来读过的最透彻、可读性最强的论文之一，所以如果这篇文章引起了你的兴趣，请看看吧！
如果我们总是对最可能的单词进行采样，标准的语言模型训练目标会导致我们陷入像“我不知道”这样的循环中。我不知道。我不知道。”这是不自然的，但现代语言模型中模型的大部分注意力只在最近的几个标记上。相反，流行的生成抽样方法是基于分布的抽样。但是采样也遇到了一个问题:如果我们有 50K 个可能的选择，即使底部的 25K 个记号每个都极不可能，它们总共可能有例如 30%的概率质量。这意味着每一个样本，我们都有 1/3 的机会完全偏离我们的“思路”由于前面提到的短上下文，这将导致不可恢复的错误级联，因为每个下一个单词都严重依赖于这个最近的错误单词。
为了防止尾部取样，最常用的方法是温度和顶部 k 取样。
温度 采样受统计热力学启发，高温意味着更可能遇到低能态。在概率模型中，对数起着能量的作用，我们可以通过将对数除以温度来实现温度采样，然后将其输入 softmax 并获得采样概率。例如:
>>> import torch>>> import torch.nn.functional as F>>> a = torch.tensor([1,2,3,4.])>>> F.softmax(a, dim=0)tensor([0.0321, 0.0871, 0.2369, 0.6439])>>> F.softmax(a/.5, dim=0)tensor([0.0021, 0.0158, 0.1171, 0.8650])>>> F.softmax(a/1.5, dim=0)tensor([0.0708, 0.1378, 0.2685, 0.5229])>>> F.softmax(a/1e-6, dim=0)tensor([0., 0., 0., 1.])
或者视觉上
较低的温度使模型对其首选越来越有信心，而高于 1 的温度会降低信心。0 温度相当于 argmax/max 似然，而无限温度对应于均匀采样。
Top k 采样是指按概率排序，将第 k 个令牌以下的概率归零。它似乎通过去除尾部来提高质量，使其不太可能偏离主题。但是在某些情况下，真的有很多词我们可以合理地从中取样(下面的广泛分布)，而在某些情况下没有(下面的狭窄分布)。
Holtzman et al 2019
为了解决这个问题，作者提出了 top p 采样，也称为核采样，其中我们计算累积分布，并在 CDF 超过 p 时立即截止。在上面的广义分布示例中，可能需要前 100 个令牌才能超过 top_p = .9。在窄分布中，我们可能已经超过了 top_p = .9，在我们的样本分布中只有“热”和“暖”。通过这种方式，我们仍然避免了对极其错误的记号进行采样，但是当最高得分的记号具有低置信度时，保持了多样性。
为什么最大似然抽样不起作用？在培训过程中，永远没有机会看到复合错误。该模型被训练成基于人类生成的上下文来预测下一个令牌。如果它通过生成一个坏的分布而得到一个错误的标记，下一个标记将使用“正确的”人类生成的上下文，而与上一个预测无关。在生成过程中，它被迫完成自己自动生成的上下文，这是它在训练过程中没有考虑的设置。
定性结果
以下是使用 top_k=40 和上下文“我吃了一个美味”的示例
这里是使用 top_p=0.9 和相同“我吃了美味”上下文的示例:
自己试试这里！您可以在运行时>启用 GPU，更改运行时类型，无需额外运行时即可获得大批量数据。
超越纸张:自动选择 p 和 k
我发现很难确定这些样本中哪一个更像人类。为此，我设计了一个实验来根据经验确定top_k和top_p。
我们的目标是使用 top_k 和 top_p 来最大化选择我们给出的实际下一个单词的概率。当搜索最佳 k 和 p 值时，实际上很容易通过分析确定给定样本。对于 k，我们找到“黄金”令牌出现的排序索引。对于 p，我们找到黄金令牌的 CDF。例如，如果上下文是“我吃了一份美味的热食”,实际单词是“狗”,但模型的预测分布最有可能是“煎饼”,我们将向下搜索概率，直到在索引 3 处找到“狗”。在指数 1 时，CDF 可能是 62%。在指数 3 处，CDF 可能是 86%左右，所以我们把它记为最优 p。
在许多例子中，我们可以计算最佳 p 和 k 值的直方图，并计算它们的汇总统计数据。我在维基百科的一个随机部分进行了测试，其上下文长度为 15。这比模型被训练的时间(1024)要短得多，但是对于像 https://duet.li 或聊天机器人这样的设置是常见的。
===== ks =====max 29094.00mean 233.69median 3.00len 13376.00===== ps =====max 1.00mean 0.59median 0.60len 13376.00
你可以在我的 colab 笔记本里自己尝试一下。
如果对模型的训练集进行评估，则选择 top_k = 1 是最佳选择。但是由于模型稍微超出了范围，最有可能的标记有时会出现在列表的底部。此外，我们还有一个 50K 的令牌词汇表。在许多数据集中，我们永远不会看到所有的令牌，但模型对此并不确定。通过使用 top_p 或 top_k 将大部分概率质量归零，我们合并了我们的先验以从不选择这些从未在训练中见过的令牌。
也就是说，这种对 k 和 p 的寻找仍然是在模型的世界观的背景下，因此这只是一个创可贴。我们真正想要的是修正训练。
固定训练
我也开始考虑改变培训目标，以更好地匹配生成任务。例如，当模型生成看起来不像人类的整个序列时，我们可以训练某种鉴别器来惩罚它吗？如何将 GAN 架构应用于非连续域并不简单。我发现了没有强化学习的对抗性文本生成和一个基于 RL 的想法，但似乎这些还没有成为主流。我认为将这些想法应用到过去几个月席卷艺术领域的大型变形金刚上会很有趣。
感谢 雅罗斯拉夫布拉托夫 的反馈和编辑
如何通过一个文件保存和共享您的机器学习模型(以及更多)
Photo by Jonathan Pielmayer
忘记模块导入。只需一行代码，您就可以在一个 Python 文件中存储和分发经过训练的 ML 模型等。
在处理机器学习模型时，通常建议您将它们存储在某个地方。在私营部门，您经常在生产前培训和存储它们，而在研究和未来的模型调整中，在本地存储它们是一个好主意。我总是使用令人惊讶的 Python 模块 pickle 来做这件事。
我最近发现了一个有用的窍门。您不仅可以存储模型，还可以将整个函数和变量都存储在同一个文件中！当你想和其他人分享你的模型，但是你知道那个人不一定安装了所有需要的模块/功能，或者只是不具备这样做的专业知识时，这就特别方便了。他们只是想在一台具有基本 Python 环境的计算机上运行该算法以查看结果。
我将在这里向你展示如何做这个简单的把戏。
假设在您的本地计算机中，为了进行分类分析，您首先加载这些 sklearn 和 numpy 模块:
from sklearn.metrics import accuracy_score, f1_score
from sklearn import svm
from numpy import average
稍后用交叉验证测试模型的准确性。最后，在验证完模型的准确性之后，用一些数据拟合最终模型:
sv_t = svm.SVC()
sv_t.fit(Features,Classes)
现在到了有趣但相当简单的部分。您可以将经过训练的模型以及任何功能/模块存储到一个 pickle 中，以便以后在其他地方分发！
Free to use and part of the public domain Pickle drawing taken from here. Image generated with Inkscape
这样你就可以将训练好的模型sv_t加上例如 numpy 的average函数和 sklearn 模块的f1_score函数保存在一个文件中。为此，您只需:
import pickle
pickle.dump([sv_t,average,f1_score], open('complete_ml.pkl', 'wb' ))
就是这样！下次您(或其他人)从任何计算机加载 pickle 文件 complete_ml.pkl 时:
sv_t,average,f1_score = pickle.load(open('complete_ml.pkl','rb'))
您将可以访问存储的训练模型以及您想要打包在一起以供将来分发的任何函数和变量。为什么要这样做？嗯，正如我在乞求中所说的，很多时候你想要共享、部署和分发你的 ML 管道到其他计算机，这些计算机可能没有预装所有需要的模块。有了这个技巧，唯一需要的模块就是 Pickle，它是 Python 的标准库的一部分。
希望这个简单的指南对你的 ML 之旅有所帮助，它让我的 ML 之旅与众不同。
感谢您的阅读！
如何在多个 GPU 上扩展训练
如何在多个 GPU 中训练 PyTorch 模型
深度学习模型的最大问题之一是，它们变得太大，无法在单个 GPU 中训练。如果在单个 GPU 中训练当前的模型，它们将花费太长时间。为了及时地训练模型，有必要用多个 GPU 来训练它们。
我们需要来缩放训练方法，以使用 100 个甚至 1000 个 GPU。例如，一位著名研究员能够将 ImageNet 的训练时间从 2 周减少到 18 分钟，或者在 2 周内训练出最大和最先进的 Transformer-XL，而不是 4 年。他使用了 100 个 GPU 来完成这个任务。
我们非常关心我们的训练迭代速度。因此，为了提高我们的迭代速度，我们必须将我们的训练扩展到多个 GPU。在这篇博文中，我将介绍如何用 PyTorch 扩大训练规模。我们已经在 TensorFlow ( <2.0) and scaled our training, using Horovod )中有了一些模型，这是优步工程团队开发的一个工具。如果你走这条路，我们建议使用他们的 Docker 镜像来安装它。
我们发现 PyTorch 在易用性和控制性之间取得了最好的平衡，同时又不牺牲性能。PyTorch 构建了两种方法来在多个 GPU 中实现分布式训练:nn.DataParalllel和nn.DistributedParalllel。它们是包装和更改代码以及在多个 GPU 中增加训练网络的能力的简单方法。
nn.DataParallel更容易使用，但要求只能在一台机器上使用。nn.DataParalllel仅使用一个进程来计算模型权重，并在每批中将其分配给每个 GPU。
在这篇博文中，我将详细介绍nn.DataParallel和nn.DistributedDataParalllel是如何工作的。我将介绍两者之间的主要区别，以及在多个 GPU 中进行训练的工作原理。我将首先解释训练神经网络是如何工作的。
训练循环
首先，让我们回顾一下训练神经网络通常是如何工作的。为此，我们将使用由 HuggingFace 创建的一些图像:
训练神经网络时，每个循环都有四个主要步骤:
- 正向传递，由神经网络处理输入
- 计算损失函数，比较预测标签和地面实况标签
- 进行反向传递，根据损耗计算每个参数的梯度(使用反向传播)
- 使用梯度更新参数
对于大于 1 的批量大小，我们可能希望批量规范化训练。关于批处理规范化的深入解释，我推荐阅读这篇博文:
目前在斯坦福大学有一门很棒的课程，叫做 CS231n -卷积神经…
kratzert.github.io](https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html)
数据并行
DataParallel 有助于将训练分布到单台机器的多个 GPU 中。让我们详细了解一下 DataParallel 是如何工作的。每当使用数据并行训练神经网络时，都会发生几个步骤:
Image created by HuggingFace
- 小批量在 GPU 上拆分:0
- 将小批量分割并移动到所有不同的 GPU
- 将模型复制到 GPU
- 正向传递发生在所有不同的 GPU 中
- 计算与 GPU:0 上的网络输出相关的损耗，并将损耗返回给不同的 GPU。计算每个 GPU 上的梯度
- 对 GPU:0 上的梯度求和，并使用优化器更新 GPU:0 上的模型
简单的例子
让我们把这个编码起来。首先，让我们进口我们需要的一切
我们定义一个非常简单的卷积模型来预测 MNIST
第 4–14 行:我们正在定义这个神经网络的层次。
第 16–21 行:我们定义了向前传球
main()函数将接受一些参数并运行训练函数:
第 2–6 行:我们实例化模型并将其设置为在指定的 GPU 中运行，并通过使用DataParallel在多个 GPU 中并行运行我们的操作。
第 9–23 行:我们定义损失函数(标准)，和优化器(在这种情况下，我们使用 SGD)。我们定义了训练数据集(MNIST)和数据加载器。
第 24–45 行:这就是训练神经网络的循环发生的地方。我们加载输入和预期输出。我们运行向前传递和向后传递以及优化器。
这里肯定有一些额外的东西(例如，GPU 和节点的数量)我们还不需要，但将整个框架放在适当的位置是有帮助的。
分布式数据并行
为了 nn。' DistributedDataParallel '，机器每个 GPU 有一个进程，每个模型由每个进程控制。GPU 可以都在同一个节点上，也可以跨多个节点。只有渐变在进程/GPU 之间传递。
在训练过程中，每个进程从磁盘加载自己的小批量，并将其传递给 GPU。每个 GPU 执行其正向传递，然后梯度在 GPU 之间全部降低。每层的梯度不依赖于先前的层，因此梯度 all-reduce 与向后传递同时计算，以进一步缓解网络瓶颈。在反向过程结束时，每个节点都有平均梯度，确保模型权重保持同步。
辅导的
为了用多重处理来做到这一点，我们需要一个脚本来为每个 GPU 启动一个进程。每个进程都需要知道使用哪个 GPU，以及它在所有正在运行的进程中的排名。我们需要在每个节点上运行脚本。
让我们来看看每个函数的变化。我已经把新代码隔离开来，以便于查找。
让我们回顾一下主函数的参数:
args.nodes是我们正在使用的节点总数(机器数量)。args.gpus是每个节点(每台机器上)的 GPU 数量。args.nr是当前节点(机器)在所有节点(机器)中的排名，从 0 到args.nodes- 1。
让我们一行一行地看看新的变化:
第 12 行:根据节点数和每个节点的 GPU 数，我们可以计算出world_size，或者要运行的进程总数，它等于 GPU 总数乘以节点数。
第 13 行:这告诉多处理模块为进程 0 寻找什么 IP 地址。它需要这样做，以便所有的进程可以同步开始。这需要在所有节点上保持一致。
第 14 行:同样，这是查找进程 0 时使用的端口。
第 15 行:现在，不再运行一次 train 函数，我们将产生args.gpus进程，每个进程运行train(i, args)，其中i从 0 到args.gpus - 1。记住，我们在每个节点上运行main()函数，这样总共会有args.nodes * args.gpus = args.world_size个进程。
我可以在终端中运行export MASTER_ADDR=10.57.23.164和export MASTER_PORT=8888，而不是第 13 和 14 行。
接下来，让我们看看对train的修改。我会再把新线路围起来。
我已经删除了一些代码，并用...代替，以使本教程更容易阅读，但如果你想要完整的脚本，这里是。
第 3 行:这是该流程在所有流程中的全局排名。我们将在第 6 行使用这个。
第 4–6 行:初始化流程并与其他流程连接。这是“阻塞”，意味着在所有进程都加入之前，没有进程会继续。我用的是NCCL，因为它是最快的..init_method告诉进程组在哪里寻找一些设置。在这种情况下，它在查看MASTER_ADDR和MASTER_PORT的环境变量，我们在main中设置了这些变量。这就是为什么我们把它设置为env://。我们可以在那里设置world_size和WORLD_SIZE.
第 23 行:将模型包装成一个[DistributedDataParallel](https://pytorch.org/docs/stable/nn.html#distributeddataparallel)模型。这将模型复制到每个 GPU 上。
第 35–39 行:[nn.utils.data.DistributedSampler](https://pytorch.org/docs/stable/_modules/torch/utils/data/distributed.html)确保每次加载数据时，每个进程都获得不同的训练数据片段。如果您想要调试并验证每个 GPU 都加载了正确的数据，您可以计算加载到每个 GPU 中的张量的 sha。
第 46 行和第 51 行:使用nn.utils.data.DistributedSampler而不是通常的洗牌方式。这就是为什么我们将 shuffle 设置为 false。
比方说，要在 4 个各有 8 个 GPU 的节点上运行，我们需要 4 个终端(每个节点一个)。在节点 0 上(由main中的第 13 行设置):
然后，在其他节点上:
对于 i∈1，2，3。换句话说，我们在每个节点上运行这个脚本，告诉它在训练开始之前启动彼此同步的args.gpus进程。
请注意，有效的 batch_size 现在是每 GPU batch_size(脚本中的值)* GPU 总数(全局大小)。
问题
当在几个 GPU 而不是一个 GPU 中运行同一模型时，可能会出现一些问题。可能出现的最大问题是主 GPU 可能会耗尽内存。这样做的原因是因为第一个 GPU 将为不同的 GPU 保存所有不同的输出以计算损失。
每当您训练网络时，以下信息将显示在控制台上:ran out of memory trying to allocate 2.59GiB
为了解决这个问题，并减少内存使用量，我们使用两种技术:
- 减少批量大小
- 将 Apex 用于混合精度
第一种技术非常简单，通常只需要改变一个超参数。
第二种技术意味着我们将降低神经网络中使用的权重的精度，因此使用更少的内存。混合精度意味着对某些事情使用 16 位，但对权重等事情保持 32 位。要了解更多关于混合精度的信息，我推荐阅读这篇博文:
[## 做深度学习的时候 FP16 和 FP32 有什么区别？
回答(第 1 题，共 3 题):这是一个适时的问题，因为我们上周五刚刚给 Horovod 添加了 FP16 支持。所以很自然，我…
www.quora.com](https://www.quora.com/What-is-the-difference-between-FP16-and-FP32-when-doing-deep-learning)
混合精度的顶点
为了解决内存不足的问题，我们建议使用较低精度的数字。这使我们能够使用更大的批量，并利用 NVIDIA Tensor 内核加快计算速度。
为了让 APEX 工作，我们需要更改代码的 2 个部分。第一个是在代码库中的train循环中:
训练步骤
第 18 行:[amp.initialize](https://nvidia.github.io/apex/amp.html#unified-api)包装混合精度训练的模型和优化器。注意，在调用amp.initialize之前，模型必须已经在正确的 GPU 上。opt_level从使用所有浮点的O0到使用半精度的O3。O1和O2是不同程度的混合精度，其细节可以在 Apex 文档中找到。
第 20 行:[apex.parallel.DistributedDataParallel](https://nvidia.github.io/apex/parallel.html)是nn.DistributedDataParallel的替代产品。我们不再需要指定 GPU，因为 Apex 只允许每个进程使用一个 GPU。它还假设脚本在将模型移动到 GPU 之前调用了torch.cuda.set_device(local_rank)(第 10 行)。
第 37–38 行:混合精度训练要求损失被缩放，以防止梯度下溢。Apex 会自动执行此操作。
确保无论何时初始化 AMP，你都设置了opt_level=O1，因为它的实现有一个错误
检查站
每当使用 Apex 时，我们需要改变我们保存和加载模型的方式，请参见下面的问题。我们需要改变保存检查点并将其加载到模型中的方式:
第 5 行:我们将amp.state_dict添加到检查点
第 19 行:我们在这里加载state_dict到 amp。
结论
有了所有这些，您应该能够开始在多个 GPU 中训练您的模型。我们建议在尝试将训练扩展到多个 GPU 之前，先在一个 GPU 中训练一个小模型。但是，如果有必要进行规模化训练，本教程可能会有所帮助。
链接和参考:
https://lambda labs . com/blog/introduction-multi-GPU-multi-node-distributed-training-nccl-2-0/
https://medium . com/south-park-commons/scaling-transformer-XL-to-128-GPU-85849508 EC 35
https://yang kky . github . io/2019/07/08/distributed-py torch-tutorial . html
正在下载 ImageNet…
结果是:
我写了一个软件工具，它使用 ImageNet API 提供的 URL 从 ImageNet 数据创建新的数据集。
你可以告诉这个工具:“我想要一个有 200 个类的数据集，每个类至少有 800 张图片”，它就会开始收集图片。
此外，在这个过程中，我做了一个小分析，得出了关于 ImageNet 图片 URL 状态的有趣结论。
完整的故事:
我需要在大于 32x32 像素的图像上构建和训练分类 ConvNet，因此我必须找到一个包含用类标记的更大图像的数据集。ImageNet 就是这样一个数据集。
ImageNet 广泛用于图像分类模型的基准测试。它包含超过 20 000 个类别的 1400 万张图片。
获取数据的一种方法是使用 ImageNet LSVRC 2012 数据集，它是整个 ImageNet 的 1000 个类别的选择，包含 128 万张图像。
但是我不一定想要也不需要下载 20 000 个类中每一个类的 150GB 的数据和图像。出于原型和测试的目的，数据集的较小子集就足够了，例如，100 个类的数据集。
ImageNet 项目不拥有任何图像，但是它们通过 API 或在一个文件中为每个图像提供 URL 列表。
我想了解我能够从 ImageNet 创建什么样的数据集。我分析了 URL 列表并绘制了每类图像直方图:
峰值大约是每类 1200 张图片，超过 1000 个这样的类。足以创建 100 个类数据集的许多变体，每个类至少有 1000 个图像。
下载和第一次观察
于是我写了一个程序，开始下载。
在这个过程中，我观察到了 5 件事:
- 许多网站都关闭了。许多图像找不到了。(这些网址来自 2011 年)
- 从自己的 URL 逐个下载图片是一个缓慢的过程，但关闭的不包含图片的 URL 会使这个过程更慢——在大多数情况下，下载图片比意识到网站不会用图片来响应要快。
- 图像来源的多样性很高。
- 大量图片来自 Flickr。
- 在某些网站上，如果图像不存在，则返回另一个图像，并带有一些文本，表明该图像不存在。例如:
这是一个不太容易解决的问题。
我想到了一个可能解决一些问题的选择——只使用 Flickr 网址。
为了继续，我首先检查了 ImageNet 中是否有足够的 Flickr 图片来创建足够大的数据集。快速 URL 解析显示，700 万张图片来自 Flickr，正好是一半。
然后我检查了只有 Flickr URLs 的每个类的图像，得到了下面的图像:
高峰已经过去，形势看起来不再那么好了。
为了更好地理解这种情况，我创建了每类图像的反向累积图，它不是显示每类有多少个图像，而是显示每类有多少个图像:
它显示大约有 2000 个类，每个类至少有 1000 个图像，这仍然非常好，对于我的目的来说绰绰有余。
Flickr 网址与其他网址
现在我需要检查仅使用 Flickr 网址是否会改善下载过程。
我运行了一段时间我的下载器。在这个过程中，我尝试了 25 000 个随机网址。对于我发出的每一个 URL 请求，我都标记了图片下载是否成功，并测量了处理 URL 所花费的时间。
首先，我想知道我尝试的网址中有多少是 Flickr 网址，有多少是其他网址:
至少在我的随机样本中，这些 URL 在 Flick 和 other 之间平均分布，这将使它们更容易比较。
以下是 Flickr URLs 与其他 URL 的请求时间对比:
似乎下载者在其他网址上花了很多时间。让我们看看所花的时间有多有成效。以下是 Flickr 网址与其他网址的成功比较:
在这里，我们可以看到，其他网址需要更多的时间，不太成功。我计算了一下平均值:大约。80%的 Flickr 网址是成功的，而只有 30%的其他网址是成功的
现在让我们检查一下最有趣的指标—Flickr URL 和其他 URL 每次成功花费的时间:
该图显示，下载者在其他 URL 上平均每次成功花费 2 到 10 秒(平均接近 4 秒)，而在 Flickr URLs 上，每次成功的时间始终保持在 0.5 秒以下。一个非常显著的差异。每张图片 0.5 秒仍然很慢，但比使用所有的 URL 要快得多，也更一致。
ImageNet 下载器
在这个过程中，我编写了一个下载器，它将创建一个包含 Y 个类的数据集，每个类包含 X 张图片。我准备好用了放在 GitHub 上。
下载器将随机挑选每班至少有 YY 图像的班级。但是如果你有什么特殊的需求，你可以指定一个下载的类列表。要选择类，您可以查看一下类列表 csv ，其中我列出了出现在 ImageNet 中的每个类及其名称、id 和 URL 计数。
默认情况下，下载器将只使用 Flickr 网址，但如果你足够勇敢，并准备等待更长时间，并准备清理坏图像的数据，你可以关闭该选项。
更新:多处理器工作人员带来 25 倍的性能提升
我已经实现了并行请求处理。有了 24 名员工，我的速度提高了 25 倍——大约。每幅图像约 0.02 秒。2 到 6 MB/s 的总下载速度。我担心 Flickr 会以某种方式限制带宽和下载的数据量，但幸运的是，情况并非如此——我通过在短时间内下载 1000 x 1000 的图像数据集(60GB 的数据)测试了这些限制，没有出现任何问题。
如何搞砸一个计算机视觉项目
统计数据(它们准确吗？)告诉 85%的 AI 项目没有交付。这样只剩下 15%的真正成功，而这些项目成功的原因是很充分的。从规划到沟通，我们来看看是什么让一个基于 AI 的计算机项目脱颖而出。
第一课:承诺过多，兑现不足
AI 就是炒作，毫无疑问。过多的承诺和过少的兑现是很容易的。最好的例子？自动驾驶汽车。他们是 AI 领域过度承诺的完美例子！回顾汽车制造商在 2016 年讲述的自动驾驶汽车愿景很有趣。结果发现他们中的一些人非常乐观。
Tesla Semi prototype (Steve Jurvetson). Is promising big stuff a good idea?
另一方面，熟悉人工智能的人知道，我们在 2020 年初看到完全自动驾驶汽车的可能性很小。挑战是巨大的，许多分析师并不完全理解它会涉及到什么。
为了避免过度承诺，你必须找到现实世界中的用例，这些用例做出微小但重要的步骤。你的项目投资回报率必须是显而易见的。仅仅因为说话或对着相机挥手很酷就替换日常用品，但这些用例通常假设技术会完美无瑕。
你猜怎么着？一开始就不会完美无瑕。
因此，你的 AI 实现——尤其是你的第一个项目——应该总是有备份！在上面有趣的视频中，一把好的旧钥匙可能会很有用…
就部署和目标而言，这意味着您的计算机视觉应用程序应该为您的用户带来更多的东西，但如果它不能按预期工作，就永远不应该妨碍他们。
第二件重要的事情是要有一个狭窄的焦点。我将在未来的帖子中讲述更多这方面的内容，但深度学习需要大量数据。深度学习是巨大的。因此，如果你计划部署一个超级炒作的人工智能项目，例如，能够检测到野外的任何物体，但只有几百个样本可用，你就完蛋了。
我喜欢来自 Charles Ollion 的这篇文章，它讲述了是什么让计算机视觉项目变得容易或困难。
所以，如果你想搞砸，最简单的方法就是选择一个模糊的项目，没有明确的投资回报，有很大的复杂性，只有很少的数据。例如，从头开始实现面部检测算法显然属于这一类。
第二课:不要从计划开始
如果你不知道你要去哪里，你可能不会到达那里。
正如《阿甘正传》提醒我们的，猜测有时被高估了。一个计算机视觉项目有一条清晰而稳定的成功之路，步骤总是相同的。你猜怎么着？我知道很多(我的意思是，很多)才华横溢的数据科学家有时会忘记这一点。
好了，计划是这样的！
The Data Science process — long version
我来告诉你数据科学家的肮脏秘密:我们喜欢做的部分是“实验”，看到了吗，上图中的黄色小方块？
如果这部分花费了你项目工作的 20%以上，那么相信我:你完蛋了。为什么？因为在没有仔细的问题定义的情况下开始，没有可能揭示深度学习不是这个特定问题的解决方案或者一个团队已经用完全不同的方法解决了它的最先进的分析，在没有组织数据收集的情况下开始(在第 4 课中有更多关于这一点的内容)，并且在没有适当沟通的情况下部署一些半生不熟的东西…嗯。
你想毁掉你的项目吗？这里有一个 3 步食谱:
- 甚至在明确定义项目之前就组建数据科学团队
- 打开 Jupyter 笔记本
- 观看您的项目崩溃
如果你在实验阶段之前错过了一个步骤，那么你肯定会在这个项目上花费两倍以上的费用。
第四课:垃圾进，垃圾出
说到准备工作，数据科学中有一个神奇的公式:垃圾进，垃圾出。如果你不给你的团队提供代表你的算法将会起作用的数据，你就完了。
Garbage in. What do you expect to come out? Photo by Elevate on Unsplash
例子不胜枚举。最好的情况下，你的算法会完全不准确。更糟糕的是，它会有偏见，在伤害发生之前没有人会注意到。好的，想要一些例子吗？
还记得我们的自动驾驶汽车吗？算法目前主要在美国接受训练。想象你是一家英国汽车制造商。啊哦:突然，左手驾驶似乎是一个问题…
你是一名放射科医生，正在开发最先进的深度学习放射学软件(我猜每周都有 10 家公司因为这个承诺而成立)。你的实验室只能买得起一台好的 GE 医疗设备，但是你的客户有 Phillips 医疗设备。嗯，理论上是可行的。实际上，你没有证据证明它会。你完蛋了。
Photo by Mathew Schwartz on Unsplash
一个更微妙的例子。几年前，我开发了一个系统，可以自动检测你智能手机上的积分卡。这是一个困难的问题，因为它是一个有 500 个类别的分类器，而每个类别只有一个样本。我们成功了(根据我们的目标衡量标准)，因为我们大量使用了数据增强和其他技巧来使我们的深度学习部分工作。
A thumb on a credit card, from The Verge
我们最引以为傲的技巧之一是在卡片的不同部分模拟拇指，并将其输入神经网络。答对了。除了它有缺陷和偏见:它只适用于白人男性的拇指。哎呀。
但总的来说，我经常看到客户有一个很好的数据集，但完全无法使用，因为它不是在生产环境的条件下捕获的。测试材料不能很好地概括。在 90%的情况下，我们在 NumeriCube 不得不从头开始重做数据集。要做到这一点，我们必须按顺序执行这些步骤——当您还不知道将使用哪种摄像机时，如何为系统收集图像呢？
你想确保你的计算机视觉项目失败吗？给它输入不准确的数据。经验之谈。
第五课:永远不要评估
计算机视觉项目失败的最后一种方式——但还有其他方式——是忽略评估部分。我所说的“评估”，是指从写下你的业务目标开始，到满意地查看你的生产监控系统，确认一切正常为止。
How deep will your project fail? Photo by Gonard Fluit on Unsplash
首先，在开始编写任何代码之前(嘿，在编写代码之前你应该做很多事情)，开始陈述你将用来决定你的项目是否成功的度量标准。
哦，小心点，有诡计。例如，如果你说“我希望我的癌细胞检测器在 99%的情况下都是正确的”，我已经可以给你一个有效的算法:
def is_cell_cancerous(img):
"""A very powerful algorithm that returns True if the given image is of a cancerous cell and False otherwise. Gives more than 99% accuracy provided you feed it with less than 1% cancerous cell images."""
return False
明白了吗？这里的精度指标不令人满意，您必须使用其他方法。什么？这取决于你的项目目标，但考虑 F1 分数，确保你的数据集是平衡的，并使用可以在现实世界中测量的指标。例如，如果您想检测图片上的汽车，使用平均精度(地图)很适合于训练，但可能您的用户希望有一个计数而不是表面的百分比…
事实上，许多项目在开始后就找到了他们的客观标准。在 NumeriCube 公司，我们习惯于在开始项目之前就与客户协商目标指标，但那是因为我们有丰富的经验。当你开始第一个项目时，保持低目标(参见第一课:不要承诺过多)。
结论…
我们还可以说很多其他的事情来帮助构建更好的数据科学项目:清晰的沟通，让利益相关者参与进来，分享最佳实践，在需要时使用外部输入…你对此有什么看法？我们谈谈吧！
浙公网安备 33010602011771号