TowardsDataScience-博客中文翻译-2021-二-

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

TowardsDataScience 博客中文翻译 2021（二）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

除测试之外的 14 种提高软件质量的方法

原文：https://towardsdatascience.com/14-ways-to-improve-software-quality-other-than-testing-a62d14936575?source=collection_archive---------9-----------------------

程序员的世界

软件质量不仅仅是测试、测试和测试

照片由 JC Gellidon 在 Unsplash

当我们谈论软件质量时，首先想到的是测试。许多组织甚至有专门的 QA 团队来执行测试或编写自动化测试。

毫无疑问，测试对于保证质量是至关重要的，但这只是保证质量可以做的许多事情中的一件。特别是在软件开发中，还有其他事情可以做来改进我们的软件产品。

我将它们分为两类，即

准备质量保证
预防性质量保证
反应式质量保证

准备质量保证

未能计划，计划失败——本杰明·富兰克林

准备工作减少了意外的复杂性，从而提高了质量保证。就像任何事情一样，如果我们清楚地了解需要什么，如何处理工作，并有一个适当的流程，度过难关对所有人来说都是非常愉快的。

以下是一些有助于提高质量的准备工作…

1.尽可能缩小工作范围

什么？缩小范围？是的，少做。更少的代码，更少的错误。这是软件，我们可以增量发布我们的产品。没有必要进行大爆炸式的功能发布。这就是敏捷软件开发的全部内容。

2.真正知道需要什么。永远不要假设。

错误的假设比不理解更糟糕。不懂的人会问。但是假设的人可能不会问，结果可能会做错。始终确保程序员得到正确的需求和验收标准。

3.记录不仅仅是写作的过程，也是思考的过程。

花些时间写下需要什么。它可以简短明了。记录是它的结果。但是写作的过程使一个人能够更好地思考，我们有时可以发现没有考虑到的遗漏的边缘情况，潜在的陷阱，等等。

4.将工作分成尽可能小的部分

分而治之已经在许多领域证明了几个世纪的工作。它也适用于编程。如果我们解决了一个小问题，我们更有可能处理得比解决一个大问题更好。只要我们知道如何将所有这些小部件恰当地连接在一起，使它们独立依赖，那么我们就可以确保它们作为一个整体良好地工作。

5.编码是手工制作；不仅仅是打字。享受这个过程。

当我们编码时，享受这个过程。永远不要急于完成工作。想一想怎样才能最好地完成预期的工作。找到一种方法使代码简洁而清晰。根据需要进行重构和改进。优雅地处理边缘情况。这是一门艺术。当你热爱这项工作时，你会把它做得更好，更少出错。其实最重要的软件质量就是代码质量。

预防性质量保证

预防胜于治疗— 德西德里乌斯·伊拉斯谟

这是传统的方法。在大多数情况下，这是质量保证的首选方法，尤其是当涉及到任何潜在的高影响问题时。测试是这种质量保证的一个重要部分，但是除了测试之外，下面是我们可以做的事情。

6.自动化平凡的过程以避免意外的错误

在这里，我不是指测试自动化(尽管这是它的一大部分)。我指的是我们经常反复进行的过程。一个例子是发布过程。在敏捷实践中，我们经常发布。因此，这样一个过程理想地应该是一个命令，可以很容易地拿起。事实上，整个 CI 流程应该尽可能自动化。另一个简单的例子是代码格式化，对于一些开发来说，可以自动化。有了自动化，结果更加可预测。

7.使用机器尽可能多地发现问题

再说一次，我这里指的不是自动化测试或猴子测试，尽管它们有所帮助。相反，我指的是代码质量。如果编程工具可以帮助我们更早地发现问题，那将有助于我们以后避免很多问题。这就是为什么 TypeScript 比 JavaScript 更受欢迎，因为它可以更早地发现错误。具有空安全控制的编程语言是另一种好的编程语言。自动化代码林挺工具也将提供更好的保护。自动测试覆盖度量是确保我们留下任何未覆盖区域的另一个方面。

8.尽可能多地利用工具进行常规工作，包括编码

有一些铁杆程序员相信不要依赖工具来编码。我尊重他们。但是对于我们大多数人来说，工具在提高生产力和减少错误方面都有很大的帮助。尽可能使用工具来帮助我们的工作。今天的 IDE 可以帮助我们转换一些代码，重构，重命名等等，这样我们就可以避免错误。使用类似 Postman 或 GraphiQL 的工具，而不是纯粹的curl命令来更好地理解网络调用等。如果你能驾驶飞机，就不要成为超人。

9.结对编程、代码审查、相互学习和分享

团队合作是提高质量的关键。两对眼睛总比一对好。两个大脑合起来比两个分开的大脑包含更多的知识。在将代码合并到主分支之前，为结对编程分配一些时间，并加强代码审查。这些将有助于提高代码质量和捕捉遗漏的 bug。不时地，分享一个人学到的东西，当我们分享时，我们会惊讶地学到更多。

10.做一个用户，而不仅仅是开发者。先吃自己的狗粮。

如果您正在开发面向消费者的软件产品，这一点尤其正确。不要随便发展。使用它，感受它有多好。戴上用户的帽子，像用户一样思考。如果你开发 API 或者库，做一些使用它的东西。如果可能的话，用你的 API 或者库做一些附带的东西。当你是用户的时候，你就会明白它有多“友好”了。如果我们不喜欢它，很可能其他人也不会喜欢。避免自我否定，对自己使用时的感受撒谎。

反应式质量保证

对于软件来说，预防并不总是比治疗好

错误是昂贵的，除非修复它的成本是昂贵的。对于一个很难发现但修复成本很低的错误来说，更是如此。由于软件的本质，变化发生的越来越快，冗长乏味的预防过程不再可行。此外，与预防成本相比，一些质量问题可以用相对较低的成本来解决。因此，在这种情况下，反应式更具成本效益。

11.反馈机制:越早知道越好

我们自己永远不会对我们的产品进行足够的测试。发货时，大众用户将对我们的产品进行真正的测试。我们需要做的是确保我们有最快的方式获得反馈，特别是崩溃和错误。这些反馈机制需要在发货前嵌入到我们的产品中。当用户知道问题可以反馈时，他们会更高兴。了解我们的产品快速发生的情况将有助于我们计划任何损害控制，可能会遗漏关键问题或易于修复的问题。

12.快速反应和分发机制

除非我们能够很快做出响应，否则获得问题通知是没有用的。多亏了今天的互联网，软件几乎可以瞬间交付。如果我们恰当地坚持敏捷过程，我们将有能力频繁地执行发布。因此，错误和问题可以很快得到修复，并很快发布给用户。如果这个 bug 不是一个阻碍，大多数用户相对来说是宽容的，如果他们能很快得到一个补丁，而他们没有意识到这一点。

13.增量阶段发布是我们质量的试金石

尽管我们可以利用用户作为反馈质量问题的手段，但这并不意味着我们需要每个用户都这样做。理想情况下，我们可以分阶段向一小部分用户推广，以获得初步反馈。有了这样一种机制，可以减少任何未被发现的问题对所有用户的影响。当我们增量地发布它时，它也增加了我们对发布质量的信心。

14.远程控制装运的产品

除了网页或基于服务器的应用程序，大多数应用程序一经发布，就在用户手中。然而，幸运的是，有了互联网，我们仍然可以和他们保持联系，如果我们把它组织好的话。这种机制一旦到位，我们就可以在遇到意外问题时打开/关闭某些功能。因此，这允许人们更快地进一步控制产品的质量，而不需要发布新的版本。请注意，这种远程开关是有成本的，测试的成本也很高。谨慎使用。

特别是对于应用程序发布，有各种方法可以更好地远程处理它。下面是一篇文章。

https://betterprogramming.pub/11-solid-preparations-for-shipping-your-next-mobile-app-eaf064891ed1

一个重要的心态是，必须从产品的角度整体地看待质量，而不仅仅是在产品发布之前(例如测试阶段)。测试只是一种手段，用来衡量产品在那个时间点的质量在哪里，而不是质量本身。

所以，质量不是由测试、测试和测试决定的，质量是由我们如何准备、预防和反应决定的。

2021 年及以后的 15 个令人敬畏的 Python 和数据科学项目

原文：https://towardsdatascience.com/15-awesome-python-and-data-science-projects-for-2021-and-beyond-64acf7930c20?source=collection_archive---------17-----------------------

15 个很酷的 Python 和数据科学项目，提供有用的链接和资源，为 2021 年及以后构建您的投资组合

在 Unsplash 上陷入欢乐的照片

Python 和数据科学最棒的部分是实施令人敬畏和酷的项目来彻底改变当代人。

关于 Python 编程和数据科学领域，我最喜欢的部分是您可以用它们构建大量精彩的项目。你可以建设开创性、创新性和革命性的项目，这些项目可以造福整个社会，也可以改变整个世界的面貌，实现伟大的壮举。

科技巨头和大公司正在大量投资数据科学资源，因为这一主题的创新具有巨大的潜力。创造性的数据科学家和程序员每天都在构建各种各样的壮观项目，看看我们作为个人能取得什么样的成就会很棒。

在本文中，我们将讨论 15 个令人惊叹的 Python 和数据科学项目，您可以享受实施这些项目的乐趣。这些项目保证为您提供最好的体验，让您更详细地理解大多数基本的 Python 和数据科学概念。除了从这些项目中获得的大量知识和经验，你还可以在简历中展示它们，以获得更好的工作机会或仅仅作为一种自我骄傲的标志！

这篇文章分为三个主要部分，面向所有层次的读者。类别包括初级、中级和高级。在每个类别中，我们都提到了五个项目。这加起来总共有 15 个精彩的项目，你可以从头开始构建。你可以选择你想选择的类别或项目。但是，强烈建议您浏览一下本文中提供的所有项目想法，以获得更多创新的想法。

所以，事不宜迟，让我们开始查看这些项目想法中的每一个，并相应地分析它们。

新手

1.使用 Python 的提醒应用程序:

让我们从一个简单的项目开始，我最近在一篇文章中提到了这个项目，它是一个提醒应用程序，它会不断地通知你一天中必须完成的各种任务。通知将根据您已编程脚本执行的时间计划程序进行提醒。

该项目仅使用两个模块来完成任务。它利用了 Python 预装的时间模块和 plyer 库，后者将用于提醒我们手头特定任务完成后的及时通知。

以下项目对于理解 Python 和与该主题相关的基本概念的初级入门来说极其简单。尽管它很简单，但它对提高你的整体生产力非常有用。提供的链接将引导您从头开始构建这个项目的整个过程。

第一个项目相当简单，完成这个项目的估计时间应该在 30 分钟到 2 小时之间，这取决于程序员的兴趣和技能。但是，从后面提到的项目难度范围会逐渐增加。

2.没有任何 ML 库的 Python 中的矩阵乘法:

作者截图和图片

python 和机器学习的一个重要方面是理解这些概念背后的数学，并了解机器学习库中的一些代码。为了更好地掌握这些概念，有必要实践在 numpy 和 scikit 等科学模块中实现的思想——自学。一个这样的编程应用是在不使用任何 ML 库的情况下执行矩阵乘法运算。

要完成这项任务，主要要求是了解矩阵的工作原理。完整的解释和指导可以从我下面的文章中获得。但是，如果您只是对这个编码问题的基本要点感兴趣，并想尝试自己解决这个问题，那么使用下面的参考段落来帮助您开始。

我解决这个问题的方法是从用户那里获取所有的输入。这些是第一和第二矩阵的行数和列数。同样，根据每个矩阵的行数和列数，我们将相应地分别填充备选位置。

在做任何矩阵乘法之前，第一步是检查两个矩阵之间的运算是否实际可行。这可以通过检查第一矩阵的列是否匹配第二矩阵的行的形状来完成。这可以表述为:

→矩阵 1 的列数=矩阵 2 的行数

这应该是你入门的一个很好的起点。从这里开始，你可以利用你自己的技术，以各种方式计算问题陈述。

3.使用各种 ML 算法的房价预测:

对于初学者来说，房价预测是开始使用各种机器学习算法的最佳方式之一。尝试这个项目最棒的部分是，您可以获得对 scikit-learn(也称为 sklearn)库的高级理解，这是机器学习任务的一个极其重要的模块。

scikit-learn 模块是机器学习和预测数据分析的最佳工具之一。它提供了广泛的预建算法，如逻辑回归，支持向量机(SVM)，分类算法，如 K 均值聚类，以及更多的操作。这是初学者开始学习机器学习算法的最佳方式，因为该模块提供了简单高效的工具。

使用此模块，您可以访问波士顿住房数据集。波士顿住房数据集来自美国人口普查局收集的马萨诸塞州波士顿地区的住房信息。数据集很小，只有 506 个案例。下面描述了数据集列:

CRIM——城镇人均犯罪率
ZN——面积超过 25，000 平方英尺的住宅用地比例
印度河——每个城镇非零售商业用地的比例。
CHAS——查尔斯河虚拟变量(1 如果区域边界为河流；否则为 0)
NOX——氮氧化物浓度(百万分之一)
RM——每个住宅的平均房间数
年龄——1940 年之前建造的业主自用单元的比例
到五个波士顿就业中心的 DIS 加权距离
RAD——放射状公路可达性指数
税收—每 10，000 美元的全价值财产税税率
pt ratio——按城镇分列的学生-教师比率
B — 1000(Bk — 0.63)，其中 Bk 是按城镇划分的黑人比例
LSTAT —人口中地位较低的百分比
MEDV——以千美元为单位的自有住房的中值

在接下来的几个代码块中，我们将讨论如何利用这个模块来访问数据集，以及分析和解决这个简单的机器学习任务所需的一些附加库。这将是一个如何开始的快速指南，并将涵盖基本要求。理解这些概念后，你应该能够在下面的数据集上实现一些机器学习算法。

第一步是导入解决这个任务的所有基本需求。建议您在尝试实现各种机器学习算法时使用以下模块。代码块是解决任务可能需要的一些代码行的简单表示。(这是为了尝试决策树或随机森林方法。)

在导入执行此任务所需的所有基本库之后，您可以加载波士顿数据集，并继续为数据和目标变量分配单独的变量。要预测的价格是目标变量，而其他重要特征是数据集的信息。这将问题转化为机器学习预测任务。您可以从下面提供的代码中做到这一点。

最后，我们可以使用 pandas 数据框结构快速可视化这些数据。这可以通过下面提到的简单代码块来构建。

上图是数据集的代表。如果愿意，您可以为各个列添加功能名称。不过，这应该是大部分初学者入门的好起点。Kaggle 和 GitHub 是你解决这些机器学习任务的最好的朋友。点击此处的链接，查看 Kaggle 网站了解更多信息。

4.垃圾邮件检测:

垃圾电子邮件，也称为垃圾电子邮件，是通过电子邮件批量发送的未经请求的消息(垃圾邮件)。电子邮件过滤是根据特定标准对电子邮件进行组织的过程。该术语可以应用于人类智能的干预，但最常见的是指使用反垃圾邮件技术自动处理传入的消息，包括发出的电子邮件和收到的电子邮件。

各种分类算法可用于完成垃圾邮件检测任务。各种机器学习算法，如朴素贝叶斯、支持向量机、K-最近邻和随机森林以及许多其他算法，可用于过滤垃圾邮件消息并分类所接收的电子邮件是否是垃圾邮件。

可以使用神经网络或光学字符识别(OCR)等技术来执行高级垃圾邮件检测，Gmail 等公司也将 OCR 用于垃圾邮件过滤。

假设我们有一个 30，000 封电子邮件的数据集，其中一些被分类为垃圾邮件，一些被分类为非垃圾邮件。机器学习模型将在数据集上训练。一旦训练过程完成，我们可以用一封没有包含在我们的训练数据集中的邮件来测试它。机器学习模型可以对以下输入进行预测，并正确分类输入的电子邮件是否是垃圾邮件。

各种反垃圾邮件技术被用来防止电子邮件垃圾(未经请求的批量电子邮件)。没有一种技术可以完全解决垃圾邮件问题，每种技术都需要在不正确地拒绝合法电子邮件(误报)和不拒绝所有垃圾邮件(误报)之间进行权衡，以及相关的时间、精力和错误阻止好邮件的成本。

例如，朴素贝叶斯分类器是一种流行的电子邮件过滤统计技术。他们通常使用单词袋功能来识别垃圾邮件，这是一种常用于文本分类的方法。朴素贝叶斯分类器的工作原理是将令牌(通常是单词，有时是其他东西)的使用与垃圾邮件和非垃圾邮件相关联，然后使用贝叶斯定理来计算电子邮件是或不是垃圾邮件的概率。

朴素贝叶斯垃圾邮件过滤是一种处理垃圾邮件的基本技术，它可以根据单个用户的电子邮件需求进行调整，并提供用户通常可以接受的低误报垃圾邮件检测率。这是最古老的垃圾邮件过滤方式之一，起源于 20 世纪 90 年代。

以下内容的快速指南可从链接此处获得。

5.情感分析:

情感分析(也称为意见挖掘或情感 AI)是指使用自然语言处理、文本分析、计算语言学和生物统计学来系统地识别、提取、量化和研究情感状态和主观信息。

情感分析广泛应用于客户意见材料，如评论和调查回复、在线和社交媒体以及医疗保健材料，应用范围从营销到客户服务再到临床医学。

情感分析中的一个基本任务是在文档、句子或特征/方面级别对给定文本的极性进行分类——无论在文档、句子或实体特征/方面中表达的观点是积极的、消极的还是中性的。例如，高级的“超越极性”情感分类着眼于诸如“愤怒”、“悲伤”和“快乐”等情感状态。

然而，你可以选择否定其他评论，只将它们分为好或坏。例如，对于一个电影评论，任何评分为 1-2 星的都被标记为负面，评分为 4-5 的被标记为正面，而中性评分为 3 的可以相应忽略。

解决情感分析问题是你开始的最好的初级项目之一，因为你有广泛的选择来解决下面的任务。你可以选择任何你喜欢的方法来解决这个问题。

像逻辑和朴素贝叶斯这样的机器学习算法可以很容易地用来解决这类任务。可以使用许多方法来获得这个问题的解决方案，包括深度学习的方法。然而，即使是最简单的方法也可以用来解决这个任务，这取决于你决定将问题变得多复杂。

对于自然语言处理和情感分析概念的详细理解，我的建议是这里的链接。如果你愿意，你可以旁听课程。我还建议查看下面的文章，了解关于这个主题的更多信息。

中间的

6.用 Python 构建一个游戏:

我的第一个项目的作者过时的 GIF

你们在上面看到的过时的 GIF 是我三年前在 pygame 的帮助下完成的第一个项目。如果你想要一个更简洁的关于如何用 python 从头开始构建的指南，请告诉我。但是这里的主要思想是用 python 自己从头开始构建一个游戏。从一些简单的游戏开始，比如蛇游戏，或者井字游戏，然后通过强化学习进行更高级的游戏，比如 flappy birds。

完成这项任务背后的想法更多的是个人观点和偏好。我相信掌握任何编程语言的最好方法之一就是从一个有趣和令人愉快的项目开始。我也有点沉迷游戏。为了开始与 python 相关的游戏项目，我强烈推荐使用 Pygame 库模块来执行这类程序。

使用 pygame 模块，您可以用 python 构建一些简单有趣的游戏。然而，不要期望任何过于花哨的东西，因为它有其局限性。不管怎样，这是一个很好的开始方式，下面是开始代码。只需用一个简单的 pip 命令安装 pygame，然后使用下面的 import pygame 命令。成功导入模块后，将出现以下消息。

pygame 1.9.6
Hello from the pygame community. [https://www.pygame.org/contribute.html](https://www.pygame.org/contribute.html)

根据安装时间的不同，版本可能会有所不同，所以不要太担心。在任何情况下都使用更新的版本。我将介绍一些你应该知道的基本命令以及它们是如何工作的。下面是 pygame 入门所需了解的所有重要方面的完整代码块。

#imports the pygame library module
import pygame# initilize the pygame module
pygame.init()# Setting your screen size with a tuple of the screen width and screen height
display_screen = pygame.display.set_mode((800,600)) 

# Setting a random caption title for your pygame graphical window.
pygame.display.set_caption("pygame test")# Update your screen when required
pygame.display.update()# quit the pygame initialization and module
pygame.quit()# End the program
quit()

我强烈建议你看看 YouTube 上的一些视频，以便更好地理解和学习制作一些游戏。pygame 模块的文档虽然有点冗长，但可能是了解这个模块更多信息的最佳资源之一。

7.使用 OpenCV 处理图像:

图片来自维基

计算机视觉是一个跨学科的科学领域，研究计算机如何从数字图像或视频中获得高层次的理解。从工程的角度来看，它寻求理解和自动化人类视觉系统可以完成的任务。

RGB 是计算机视觉任务中最重要的三层颜色。这三种颜色，即红色、绿色和蓝色的组合可以用来组合几乎任何其他颜色。将它们以正确的比例混合，我们就可以设计出任何其他想要的颜色。这个概念从几十年前的阴极射线电视就存在了。

每种颜色都有一个 8 位的整数值。这意味着这些矩阵的范围可以从 0 到 255。这是因为⁸是 256，0–255 由 256 个值组成。这些颜色中的每一种都有一个这个范围的值，因为我们有一个三维图像，我们可以将这些颜色相互叠加。

OpenCV 模块是迄今为止执行复杂机器学习、深度学习和计算机视觉任务的最佳库。它为正在构建的模型的分析和性能提供了简单性和高标准。它是一个开源库，可以与 NumPy 等其他 python 模块集成，以完成复杂的实时应用程序。它被广泛的编程语言所支持，并且可以在大多数平台上运行，比如 Windows、Linux 和 MacOS。

工作和处理图像是人工智能和数据科学的计算机视觉项目的一个重要方面。图像的读取、显示和写入是计算机视觉的重要组成部分，因为你必须始终如一地处理图像。除了前面提到的优点之外，opencv 最大的优点是它还允许您访问各种图像格式。因此，我们可以处理所有这些图像格式，而不会面临任何重大问题。

下面提到的文章链接是从零开始掌握计算机视觉基础的简明指南。我已经涵盖了初学者入门的所有基本方面，并对 OpenCV 模块以及如何操作各种图像有了全面详细的理解。

8.GTTS 和 OCR:

我们将关注的下一个中级水平是拥有 python 编程知识的最酷的方面之一。复杂的任务，如文本到语音的转换和 python 的光学字符识别，只需要理解为此目的创建的 python 库模块就可以完成。

文本到语音(TTS)是将单词转换成有声音频形式的过程。程序、工具或软件从用户处获取输入文本，并使用自然语言处理方法，理解所使用语言的语言学，并对文本执行逻辑推理。该处理后的文本被传递到下一个块，在那里对处理后的文本执行数字信号处理。随着许多算法和转换的使用，这个处理过的文本最终被转换成语音格式。这整个过程包括语音合成。

光学字符识别是通过使用电子或机械设备将二维文本数据转换成机器编码的文本形式。二维文本数据可以从各种来源获得，例如 PDF 文件之类的扫描文档、具有以下格式的文本数据的图像。png 或者。jpeg、路标(如交通标志)或任何其他带有任何形式文本数据的图像。光学字符识别有广泛的有趣应用。

下面是两篇文章的列表，对于您熟悉用于语音翻译的 Google 文本到语音模块和用于光学字符识别的 pytesseract 模块非常有用。请参考下面的文章，获得全面的入门指南，并一起使用它们执行项目。

9.面部识别:

人脸识别是对人脸以及用户授权姓名的程序性识别。人脸检测是一个更简单的任务，可以被认为是一个初级水平的项目。人脸检测是人脸识别的必要步骤之一。人脸检测是一种将人脸与身体的其他部分和背景区分开的方法。

haar 级联分类器可以用于面部检测的目的，并且准确地检测帧中的多个面部。正面人脸的 haar 级联分类器通常是一个 XML 文件，可以与 open-cv 模块一起使用，用于读取人脸，然后检测人脸。一种机器学习模型，如定向梯度直方图(H.O.G ),可与标记数据和支持向量机(SVM)一起使用，以执行此任务。

人脸识别的最佳方法是利用 DNN(深度神经网络)。在检测到人脸之后，我们可以使用深度学习的方法来解决人脸识别任务。有各种各样的迁移学习模型，如 VGG-16 架构、RESNET-50 架构、face net 架构等。这可以简化构建深度学习模型的过程，并允许用户构建高质量的人脸识别系统。

你也可以建立一个定制的深度学习模型来解决人脸识别任务。为人脸识别建立的现代模型非常准确，对标记数据集的准确率几乎超过 99%。人脸识别模型的应用可以用于安全系统、监控、考勤系统等等。

下面是我使用 VGG-16 迁移学习的方法建立的人脸识别模型的例子，用于在通过 haar 级联分类器执行人脸检测之后进行人脸识别。请查看它，了解关于如何构建自己的人脸识别模型的更详细的解释。

上面的链接是一个高精度人脸识别系统的示例，该系统使用深度学习和迁移学习方法来授予授权用户访问权限，并拒绝未经授权的人员的权限。使用图像数据增加和转移学习模型的方法，授权用户面部的面部识别模型以高准确度水平进行预测。

10.下一个单词的预测:

从事数据科学项目的一个独特方面是创建令人惊叹的预测类型模型的能力。谷歌搜索栏、WhatsApp 消息等。在许多其他应用程序中，使用下一个单词预测方法在键入每个新单词后预测适当的建议。

这类似于自动完成或单词完成，这是一种应用程序预测用户正在键入的单词的剩余部分的功能。在 Android 智能手机中，这被称为预测文本。在图形用户界面中，用户通常可以按 tab 键接受一个建议，或者按向下箭头键接受几个建议中的一个。

对于从中级项目过渡到相当高级的项目，这个项目想法是一个极好的选择。这个项目想法使用了自然语言处理的主要概念，并且需要相当多的技巧来解决。你可以使用各种机器学习算法和技术来解决这个任务。然而，我建议并鼓励你们所有人尝试一些创新的深度学习方法来解决这个项目，同时旨在实现一流的结果。

对特定用户发短信或打字的下一个单词的预测可能非常棒。通过了解用户的短信模式，可以节省大量时间。这也可以用来创建一个更大的虚拟助手项目来完成某些句子。总的来说，预测搜索系统和下一个单词预测是一个非常有趣的概念。你可以看看我下面的文章，它涵盖了预测接下来单词的深度学习方法论。

上面提到的资源使用基于 LSTM 的深度学习模型，该模型采用输入单词或句子，并预测下一个合适的单词。该深度学习模型使用具有自然语言处理的长短期记忆的概念，用于语料库和文本数据的预处理。使用自定义顺序模型来预测适当的下一个单词。它在社交媒体中有广泛的应用，用于下一个单词的预测。

先进的

11.物体检测/物体跟踪—

这个计算机视觉项目很容易被认为是一个相当先进的项目，但是有这么多免费的工具和资源可供使用，你可以毫不费力地完成这项任务。对象检测任务是在识别的对象周围绘制边界框，并根据确定的标签识别识别的对象，并以特定的精度预测这些标签的方法。与对象检测相比，对象跟踪略有不同，因为您不仅要检测特定的对象，还要跟随周围有边界框的对象。

对象检测是一种计算机视觉技术，它允许我们在图像或视频中识别和定位对象。通过这种识别和定位，可以使用对象检测来计数场景中的对象，并确定和跟踪它们的精确位置，同时准确标记它们。这种情况的一个例子可以是在道路上跟随特定的车辆，或者在任何体育比赛中跟踪球，如高尔夫、板球、棒球等。

执行这些任务的各种算法有 R-CNN(基于区域的卷积神经网络)、SSD(单次检测器)和 YOLO(你只看一次)等等。我将提到两位天才程序员的两个最佳资源。

一种方法更适合像 raspberry pi 这样的嵌入式系统，另一种方法用于 PC 相关的实时网络摄像头对象检测。下面这两个资源是开始使用对象检测/对象跟踪的一些最佳方法，它们也有详细解释它们的 YouTube 视频。请务必查看这些资源，以便更好地理解对象检测。

https://github.com/EdjeElectronics/TensorFlow-Lite-Object-Detection-on-Android-and-Raspberry-Pi https://github.com/theAIGuysCode/Object-Detection-API

12.高级创新聊天机器人:

对高质量聊天机器人的需求每天都在增加。聊天机器人现在如此受欢迎的主要原因是因为它们可以提供关于网站或特定主题的自动回复。他们可以回答常见问题，并通过欢迎新用户和向他们介绍特定网站来帮助新用户。

一个训练有素的聊天机器人甚至可以像人类助手一样与用户交谈。聊天机器人还能够参与对话，并在推广网站或社交媒体网页时帮助用户了解网站的内容。他们还可以做广告，从用户那里获得更好的互动。所有这些因素使得聊天机器人对于任何小型初创公司或任何大型网站都非常重要，因为它节省了大量的人力和资源。

具有神经网络和自然语言处理(NLP)的深度学习算法是当今使用的最流行的聊天机器人方法。还有很多其他的机器学习算法可以使用。在深度学习中，使用更普遍的 LSTMs，并且优先考虑顺序到顺序的模型。下面是一个由我从头开始构建的创新聊天机器人的例子。

上面提到的资源是一个具有一维卷积层的创新聊天机器人。

一个基于一维文本分类的聊天机器人，以讽刺的方式回答常见问题。这种聊天机器人模型是虚拟助理项目的一个组成部分，它将以机智的回答来回应用户，并让用户参与有趣的对话。聊天机器人模式也非常适合随意聊天，吸引外国观众。它还拥有高质量的预测系统。

13.机器翻译:

机器翻译，有时简称为 MT，是计算语言学的一个子领域，研究使用软件将文本或语音从一种语言翻译成另一种语言。

在基本层面上，机器翻译执行一种语言中的单词对另一种语言中的单词的机械替换，但仅此一项很少产生好的翻译，因为需要识别整个短语及其在目标语言中最接近的对应物。并非一种语言中的所有单词在另一种语言中都有对应的单词，许多单词都有不止一种含义。

这些类型的问题可以用人工智能和数据科学技术来解决。这些通常致力于自然语言处理、机器学习和深度学习等概念。具有关注的序列对序列(Seq2seq) 机制可用于实现这些预测的更高准确性和更低损失。Seq2seq 是一系列机器学习方法，用于包括语言翻译的应用程序的语言处理。

Seq2seq 把一个序列变成另一个序列。它通过使用递归神经网络(RNN)或更常见的 LSTM 或 GRU 来避免消失梯度的问题。每一项的上下文都是上一步的输出。主要组件是一个编码器和一个解码器网络。编码器将每个项目转换为包含项目及其上下文的相应隐藏向量。解码器反转该过程，将向量转换为输出项，使用之前的输出作为输入上下文。

对于自然语言处理，甚至存在零拍和一拍的学习方法。可以使用相同的方法来更好地训练模型，以提高整体性能，并避免重复的训练过程，这在一些现实生活的应用程序和场景中可能是一个真正的大障碍。因此，一次性学习是在其他培训能力较低的嵌入式系统中部署和工作的一个很好的选择。

机器翻译是一个很棒的高级项目，可以尝试并从中获得乐趣。完成这项任务的一个很好的资源是 TensorFlow 的官方网站，它专注地处理神经机器翻译。他们在一个玩具数据集上工作，并就如何执行下面的复杂问题提供了很好的内幕。你可以点击查看的链接。

14.人类情感和手势检测:

这个项目使用计算机视觉和深度学习来检测各种面孔，并对特定面孔的情绪进行分类。这些模型不仅对情绪进行分类，而且还相应地对所识别的手指的不同手势进行检测和分类。

在区分人的情绪或姿势之后，由训练的模型分别提供对人的情绪或姿势的准确预测的声音响应。这个项目最好的部分是你可以选择的广泛的数据集。

该项目是一个相当先进的计算机视觉任务，这将是真棒适合你的简历广泛完成的项目。从事这个神话般的项目也将为你提供一些必须需要的经验，以完成与深度学习和计算机视觉相关的复杂和复杂的问题。

下面的链接是我通过使用计算机视觉、数据增强和库(如 TensorFlow 和 Keras)的方法来建立深度学习模型而完成的一个深度学习项目的参考。我强烈建议观众查看下面的两部分系列，了解如何计算以下高级计算机视觉任务的完整分解、分析和理解。此外，请务必参考上一节中提供的 Google 文本到语音链接，以了解文本到语音的有声文本转换是如何工作的。

上面提供的链接代表了一种识别人类情绪和手势的计算机视觉和深度学习模型。该模型还提供声音响应，并相应地对相应的情绪或手势进行分类。使用深度学习技术和定制的顺序模型来实现对人类情绪的高准确性，并基于 VGG-16 架构进行手势识别的转移学习。

15.与甘斯合作的项目:

GANs 是由 Ian Goodfellow 在 2014 年开发和发明的，他的同事最近获得了巨大的人气。GANs 被认为是深度学习的未来，因为它们拥有创造前所未有的视觉和图像的惊人能力。生成对抗网络是当前深度学习的高峰，具有非常好的改善曲线。

GANs 是一个不可否认的未来趋势，它将永远革新人工智能。GANs 是一个稍微复杂的主题，我将在接下来的文章中一部分一部分地广泛讨论它。然而，出于本帖的目的，有必要注意两个网络、一个生成器和一个鉴别器相互开战，并发生了小纠纷。

生成器试图创建逼真的假图像来绕过鉴别器的基本检查，而鉴别器的作用是捕捉假拷贝。这种猫捉老鼠的追逐导致了从未有过的独特样本的发展，而且是现实的，远远超出了人类的想象。

我不打算提及 GANs 的任何具体项目，因为有各种各样独特和令人敬畏的应用程序以及其他创新项目可以用它们来创建。GANs 的受欢迎程度正在上升，它可以从绝对无中创造出新的艺术和现实的形象。人们甚至在探索从各种子领域和流派中产生音乐。因此，它们不仅限于图像。

从名为“thispersondoesexist.com”的网站可以观察到一个著名的生成性对抗网络(GANs)的例子刷新或重新访问这个网站时，你会遇到实际上并不存在的新面孔。这个项目是由 Karras 等人和 Nvidia 开发的一种称为 style gan 2(2019 年 12 月)的 GANs(生成对抗网络)类型构建和想象的。

结论:

照片由摩根塞申斯在 Unsplash 拍摄

用 Python 和数据科学构建各种新项目，会让你更好的理解和掌握你学过的概念。用 Python 和数据科学构建新应用的热情是在这一领域取得成功的重要品质。

对于数据科学的各种主题，从理论上理解机器学习概念和数学背后的直觉至关重要。要欣赏数据科学的真正魅力，你需要尝试许多项目。大量的任务和你能解决的问题绝对是奇妙的，当你找到它们各自的解决方案时会有一种成就感。

但是，您还需要知道如何在现实生活的实际场景中实现以下项目。不要害怕接触一些代码，自己实现这些项目。尝试不同的参数，并通过尝试各种算法和方法来获得更好的解决方案。

在本文中，我们讨论了 15 个非常棒的 Python 和数据科学项目，您可以尝试一下。这些想法非常适合任何人的简历，因为它包括了你已经完成的一系列独特而又酷的项目。这将有助于你提高你的整体形象，并帮助你更有效地清除最初的选择过程。

随着这些项目的实施，你也将获得更多的实用知识和对你所研究的概念的深刻理解。如果您对本文讨论的主题有任何疑问，请在下面的评论区告诉我，我会尽快给您回复。

看看我的其他一些文章，你可能会喜欢读！

</12-steps-for-beginner-to-pro-in-data-science-in-12-months-c6f6ba01f96e> </7-tips-to-increase-your-productivity-in-python-bc1835622aa5>

谢谢你们坚持到最后。我希望你们喜欢阅读这篇文章。我希望你们都有美好的一天！

移动营销活动:ROAS(广告支出回报)

原文：https://towardsdatascience.com/15-business-questions-about-mobile-marketing-campaigns-roas-return-on-ad-spend-ff636a8095b6?source=collection_archive---------15-----------------------

探索性营销数据分析，用于监控和评估移动营销活动(EDA)的绩效

在 Unsplash 上由 Rodion Kutsaev 拍照

作为一名营销数据分析师，他的工作是共同努力，正确地进行数字营销数据分析，以准确地监控和评估公司所有正在进行的数字行动和活动的绩效。

我具体指的是创建一个有效的分析系统，能够监控指标和关键绩效指标，从中可以衡量和优化我们营销部门团队正在开展的数字化运营工作的结果。

该项目

该数据集包含一些营销活动(Vungle 和脸书合作伙伴)在每次激活后 1 个月内收集的信息，这些营销活动旨在让用户安装和试用移动应用程序，特别是一款适用于 Android 和 iOS 智能手机的在线游戏。

目标

目标是确定整体绩效，并在分析期间监控广告支出回报(ROAS ),从而为营销部门提供更新见解。

数据集

媒体来源(广告合作伙伴的名称)
活动名称(广告活动的名称)
成本(营销上的花费)
安装数(生成的安装数)
D01总收入
D03总收入
D07总收入
D30总收入

D x 总收入是在安装后的第一个 x 天内从作为特定营销活动的直接响应而安装的用户那里产生的总收入。

要计算的 KPI:

CPI(每次安装的成本)
CPI =活动/应用安装的成本
Dx ROAS(广告支出回报率)其中 x = [1，3，7，30] ROAS 是一种衡量数字广告活动效果的指标，可以理解为:
ROAS =总活动收入/广告活动成本

商业问题

以下是我们将回答的一些业务问题:

Q1。是否有更多的冯格或脸书运动？
Q2。哪个合作伙伴的活动产生了更多的用户安装？
Q3。脸书的整体消费物价指数是多少？
Q4。有多少脸书活动提供了高于平均水平的安装量？
Q5。Vungle 的整体 CPI 是多少？
Q6。有多少 Vungle 活动提供了高于平均水平的安装量？
Q7。两个平台的性能相似吗(成本与安装)？
Q8。脸书整个 D30 的房价是多少？
Q9。整个 D30 的房价是多少？
Q10。两种平台的总成本与 D30 ROAS 比较
Q11。竞选期间的各个阶段之间有什么关联吗？
Q12。roa 最高的活动总收入也最高？
Q13。第一个月之后，第一天的 roa 低于 10%的营销活动是否达到收支平衡？
Q14。假设第 7 天 roa 高于 70%的营销活动将在 30 天后达到收支平衡，这是否安全？
Q15。监控两个平台的整体 ROAS 发展

我们将在 Python 3 中进行这种探索性的数据分析。你可以在这里找到完整的代码。
可在这里下载“mkt_ua_campaigns.csv”数据集。

我们将从导入所需的 Python 库(pandas、numpy、matplotlib.pyplot、seaborn 和 regex)开始，从 CSV 文件加载数据集，检查行数(89 个观察值)和特征数(8 列)，没有缺失值，并显示几行。

作者图片

请注意,“Installs”变量的值有一个异常模式:当是脸书活动时，有一个逗号分隔千位，而在 Vungle 活动中没有逗号。

第二，特性“成本”和 D (01 到 30) 总收入将美元表示为一个类别类型，其中包括“$”符号。

要将变量的数据类型转换为数值，必须解决这些问题，并按如下方式清理数据集。

# Lowering columns' capital letters for easy typing
df.columns = map(str.lower, df.columns)# Selecting columns 
cols= ["cost","installs","d01 total revenue","d03 total revenue","d07 total. revenue","d30 total revenue"]# Cleaning unvalid characters
df[cols] = (df[cols].replace({‘,’:’’}, regex=True))df["cost"] = (df["cost"].str.replace('$','')).str.strip()df["d01 total revenue"] = (df["d01 total revenue"].str.replace('$','')).str.strip()df["d03 total revenue"] = (df["d03 total revenue"].str.replace('$','')).str.strip()df["d07 total revenue"] = (df["d07 total revenue"].str.replace('$','')).str.strip()df["d30 total revenue"] = (df["d30 total revenue"].str.replace('$','')).str.strip()# Transforming columns as float (numeric type)
df[cols] = df[cols].astype(float).copy()

作者图片

既然我们已经设置好并准备好继续前进，那么是时候计算我们的 KPI了，我们将能够从 KPI 中分析整体发展的绩效，并通过逐活动放大来分析绩效。

首先，我将从确定每个活动的 CPI (每次安装的成本)开始。为了进行计算，我们简单地将每个活动的成本除以每个活动产生的安装数量。

# Determine "Cost Per Install" in a new columndf["cpi"] = df.apply(lambda x: x["cost"] / x["installs"],axis=1)

让我们也计算一下从用户安装应用的第一天算起的第一天、第三天、第七天和第三十天的 ROAS (广告支出回报)。为此，我们将每一天的活动总成本除以总收入。

# Calculations to determine "dx_roas" in new columnsdf["d01_roas"] = df.apply(lambda x: x["d01 total revenue"] / x["cost"], axis=1)df["d03_roas"] = df.apply(lambda x: x["d03 total revenue"] / x["cost"], axis=1)df["d07_roas"] = df.apply(lambda x: x["d07 total revenue"] / x["cost"], axis=1)df["d30_roas"] = df.apply(lambda x: x["d30 total revenue"] / x["cost"], axis=1)

让我们展示我们的最终数据集，并仔细看看我们的指标和 KPI。从这一点出发，我们准备从数据中提取一些重要和相关的见解。

作者图片

探索性数据分析

Q1。是否有更多的冯格或脸书运动？

在总共 89 场活动中，77 场在脸书进行，只有 12 场通过 Vungle 平台进行，分别占 87%和 13%。

# Side table
absolut = df["media source"].value_counts().to_frame()percent = (df["media source"].value_counts(normalize=True)*100).to_frame().rename(columns={"media source":"percent"})out_bal = pd.concat([absolut,percent],axis=1).round(decimals=2)
display(out_bal)# Pie graphabsolut.plot(kind='pie', subplots=True, autopct='%1.2f%%', explode= (0.05, 0.05), startangle=80, legend=False, fontsize=12, figsize=(16,7))# Paramsplt.xticks(rotation=0, horizontalalignment="center")
plt.title("Total marketing campaigns", fontsize=10, loc="right");

图片作者。

Q2。哪个合作伙伴的活动产生了更多的用户安装？

Vungle 总共产生了 242112 个安装(55%)，而脸书负责 197357 个安装(45%)。

# Bar plotax = df.groupby(["media source"])["installs"].sum().plot(kind="bar", figsize=(9,6), fontsize=12, color=sns.color_palette("rocket"), table=False)for p in ax.patches: ax.annotate("%.2f" % p.get_height(), (p.get_x() + p.get_width() / 2., p.get_height()), ha='center', va='center', xytext=(0, 7), textcoords='offset points')# Paramsplt.xlabel("media source", fontsize=10)
plt.xticks(rotation=0, horizontalalignment="center")
plt.ylabel("Absolute frequency", fontsize=10)
plt.title("Overall installs proportion", fontsize=10, loc="right")# side tableinstalls = df.groupby(["media source"])["installs"].sum().sort_values(ascending=False).to_frame()installs["percent"] = (installs.apply(lambda x: x/x.sum())*100).round(2)display(installs)

作者图片

Q3。脸书的整体消费物价指数是多少？

为了计算总体 CPI，我们将所有脸书营销活动的成本相加，然后除以脸书的总安装成本。**结果是 1.97 美元。**为了便于计算，我们可以只选择脸书活动。

# Filtering records from Facebook onlyfb = df[["media source","cost","installs"]].copy()
fb = fb[fb["media source"] == "Facebook"].copy()

作者图片

# Calculating Costs Per Installing (Facebook)
fb.cost.sum() / fb.installs.sum()>> 1.9671306312925307# Visualizing Costs vs. Installs sorted by highest cost
fb = fb.reset_index().copy()
fb.drop(["index"], axis=1, inplace=True)fb.plot.line()plt.xlabel('Number of campaigns')
plt.ylabel('Absolute Frequency')
plt.title('Costs vs. Installs [Facebook]', fontsize=10, loc="right")
plt.show()

作者图片

Q4。有多少脸书活动提供了高于平均水平的安装量？

2563 是每个活动的平均安装次数。 14 个脸书活动产生的安装量高于脸书平均水平，只有 6 个脸书活动产生的安装量高于总平均水平(4937)。

# Filtering records from Facebook only
fb_mean = df[df["media source"] == "Facebook"].copy()# Visualizing comparisons between Facebook campaings and between Facebook average campaings and total average campaignsax = fb_mean.groupby("campaign name")["installs"].mean().sort_values(ascending=False).head(15).plot(kind="bar", figsize=(16,9), fontsize=12, color=sns.color_palette("rocket"), table=False)# Params
plt.xticks(rotation=30, horizontalalignment="right")
plt.ylabel("Absolute values", fontsize=10)
plt.xlabel("Facebook campaigns", fontsize=10)
plt.title("Facebook campaigns vs. Facebook average installs", fontsize=10, loc="right")plt.axhline(fb_mean.groupby("campaign name")["installs"].mean().mean(), linewidth=2, color ="r")
plt.axhline(df.groupby("campaign name")["installs"].mean().mean(), linewidth=2, color ="b")plt.legend(('Facebook average installs', 'Total average installs'))
plt.tight_layout()

作者图片

Q5。Vungle 的整体 CPI 是多少？

要确定 Vungle 的总体 CPI，步骤与上一步类似，我们将所有 Vungle 活动的成本相加，然后除以 Vungle 安装总数。**结果是 0.74 美元。**同样，我们只能选择 Vungle 活动。

# Filtering records from Vungle onlyvun = df[["media source","cost","installs"]].copy()
vun = vun[vun["media source"] == "Vungle"].copy()

作者图片

# Calculating Costs Per Installing (Vungle)
vun.cost.sum() / vun.installs.sum()>> 0.7351143272535026# Visualizing Costs vs. Installs sorted by highest cost
vun.reset_index(drop=True, inplace=True)vun.plot.line()plt.xlabel('Number of campaigns')
plt.ylabel('Absolute Frequency')
plt.title('Costs vs. Installs [Vungle]', fontsize=10, loc="right")
plt.show()

作者图片

Q6。有多少 Vungle 活动提供了高于平均水平的安装量？

20176 是每个活动的平均安装次数。只有 3 个 Vungle 活动产生了高于 Vungle 平均值的安装量，11 个 Vungle 活动产生了高于总平均值的安装量(4937)。

# Filtering records from Facebook only
vn_mean = df[df["media source"] == "Vungle"].copy()# Visualizing comparisons between Vungle campaings and between Vungle average campaings and total average campaignsax = vn_mean.groupby("campaign name")["installs"].mean().sort_values(ascending=False).plot(kind="bar", figsize=(16,9), fontsize=12, color=sns.color_palette("rocket"), table=False)# Paramsplt.xticks(rotation=30, horizontalalignment="right")
plt.ylabel("Absolute values", fontsize=10)
plt.xlabel("Vungle campaigns", fontsize=10)
plt.title("Vungle campaigns vs. average installs", fontsize=10, loc="right")plt.axhline(vn_mean.groupby("campaign name")["installs"].mean().mean(), linewidth=2, color ="r")
plt.axhline(df.groupby("campaign name")["installs"].mean().mean(), linewidth=2, color ="b")plt.legend(('Vungle average installs', 'Total average installs'))
plt.tight_layout()

作者图片

Q7。两个平台的性能相似吗(成本与安装)？

实际上，当比较两个平台产生的成本和安装量时，它们之间有着巨大的差异。

在广告总投资 177980 美元的情况下，Vungle 能够产生 242112 次安装，而脸书产生 197357 次安装，但投资金额为 388227 美元。

# Concatenating both Facebook + Vungle datasets
cpi2brand = pd.concat([fb, vun])# Bar plotax = cpi2brand.groupby(["media source"])[["cost","installs"]].sum().plot(kind="bar", figsize=(9,6), fontsize=12, color=sns.color_palette("rocket"), table=False)for p in ax.patches: ax.annotate("%.2f" % p.get_height(), (p.get_x() + p.get_width() / 2., p.get_height()), ha='center', va='center', xytext=(0, 7), textcoords='offset points')# Params
plt.xlabel("media source", fontsize=10)
plt.xticks(rotation=0, horizontalalignment="center")
plt.ylabel("Absolute frequency", fontsize=10)
plt.title("Overall Cost vs Installs comparison [Facebook + Vungle]", fontsize=10, loc="right")# side table
installs = cpi2brand.groupby(["media source"])[["cost","installs"]].sum().sort_values(by="cost", ascending=False)display(installs)

作者图片

Q8。脸书整个 D30 的房价是多少？

为了确定 30 天后广告支出的回报，我们需要合计第 30 天的总收入，然后除以在脸书上的总投资。

结果是在第 30 天，脸书捕获了 72.65%的 ROAS 。

# Selecting Facebook segment datasetfb_d30 = df[["media source","cost","d30 total revenue"]].copy()
fb_d30 = fb_d30[fb_d30["media source"] == "Facebook"].copy()

作者图片

# Calculating Return On Advert Spend (Facebook) over 30 daysfb_d30["d30 total revenue"].sum() / fb_d30.cost.sum()>> 0.7265414306578368# Visualizing Costs vs. installs over 30 days sorted by highest cost (Facebook)fb_d30.plot.line()plt.xlabel('Number of campaigns')
plt.ylabel('Absolute Frequency')
plt.title('Costs vs. d30 total revenue [Facebook]', fontsize=10, loc="right")
plt.show()

作者图片

Q9。整个 D30 的房价是多少？

要确定 Vungle 的 D30 回报率，将第 30 天的总收入相加，然后除以在平台上的总投资。

结果是在第 30 天，92.88%的 ROAS 被捕获用于 Vungle。

# Selecting Vungle segment datasetvun_d30 = df[["media source","cost","d30 total revenue"]].copy()
vun_d30 = vun_d30[vun_d30["media source"] == "Vungle"].copy()

作者图片

# Calculating Return On Ads Spend (Vungle) after 30 days
fb_d30["d30 total revenue"].sum() / fb_d30.cost.sum()>> 0.9287728958309922# Visualizing Costs vs. installs over 30 days sorted by highest cost (Vungle)vun_d30.plot.line()plt.xlabel('Number of campaigns')
plt.ylabel('Absolute Frequency')
plt.title('Costs vs. d30 total revenue [Vungle]', fontsize=10, loc="right")
plt.show()

作者图片

Q10。两种平台的总成本与 D30 ROAS 比较

为了确定这一结果，我们必须垂直连接(轴= 0)D30 _ 罗埃斯·脸书和冯格的上述子数据集，然后根据它们的成本和第 30 天的总收入对它们进行分组。

结果显示在下面的条形图中，告诉我们 30 天后， Vungle 活动产生了 165303 美元，这几乎是达到该平台盈亏平衡点所需的收入，换算成总成本为 177980 美元。相反方向是脸书，总投资 388277 美元，收入 282063 美元。

# Concatenating both Facebook + Vungle datasets
roas2brand = pd.concat([fb_d30, vun_d30])# Bar plotax = roas2brand.groupby(["media source"])[["cost","d30 total revenue"]].sum().plot(kind="bar", figsize=(9,6), fontsize=12, color=sns.color_palette("rocket"), table=False)for p in ax.patches:
    ax.annotate("%.2f" % p.get_height(), (p.get_x() + p.get_width() / 2., p.get_height()), ha='center', va='center', xytext=(0, 7), textcoords='offset points')# Paramsplt.xlabel("media source", fontsize=10)
plt.xticks(rotation=0, horizontalalignment="center")
plt.ylabel("Absolute frequency", fontsize=10)
plt.title("Overall Cost vs Roas _d30 comparison [Facebook + Vungle]", fontsize=10, loc="right")# side tableroas = roas2brand.groupby(["media source"])[["cost","d30 total revenue"]].sum().sort_values(by="cost", ascending=False)display(roas)

Q11。竞选期间的各个阶段之间有什么关联吗？

让我们展示一个关联热图(皮尔逊方法)。

mask = np.triu(df.corr(), 1)
plt.figure(figsize=(19, 9))sns.heatmap(df.corr(), annot=True, vmax=1, vmin=-1, square=False, cmap="BrBG", mask=mask);

作者图片

从相关性图的分析中，我们可以很容易地发现许多强相关性，正如人们可能预期的那样。但我真正感兴趣的是验证第 1、3 和 7 天的 ROAS 与第 30 天的 ROAS 之间的相关性。

d30_ROAS 与 d01_ROAS 有 71%的正相关，与 d03_ROAS 有更强的正相关，为 86%，但最强的相关性在 d07_ROAS 和 d30_ROAS 之间，为 90.37% 。

# Calculating corr. coef. between ROAS 7 days and 30 days
df['d07_roas'].corr(df['d30_roas'])>> 0.9037410337635488 # Display scatter plot: d07_ROAS and d30_ROASdf.plot(x="d07_roas", y="d30_roas", kind="scatter", figsize=(9,6), fontsize=12)
plt.title("Correlation d07_ROAS and d30_ROAS", fontsize=10, loc="right")
plt.xticks(rotation=0, horizontalalignment="center");

作者图片

Q12。roa 最高的活动总收入也最高？

我们需要检查 d01、d03、d07 和 d30 具有最大收入的活动，以及在相同时期具有最大 roa 的活动，并比较两对活动以验证它们是否匹配。

d01_ROAS

分配第一天的最大 roa 和第一天的最大总收入。

# Selecting columns to work withhigh_d01 = df[["campaign name","cost","d01 total revenue","d01_roas"]].copy()

作者图片

# Highest d01_roasd01_roas_max = high_d01['d01_roas'].max()
high_d01.loc[high_d01['d01_roas'] == d01_roas_max, 'campaign name']>> 59    IMT-FB-Android-RoW2-AE-Playables-Feed# Highest d01 total revenued01_total_max = high_d01['d01 total revenue'].max()
high_d01.loc[high_d01['d01 total revenue'] == d01_total_max, 'campaign name']>> 0    IMT-FB-iOS-EN-US-AE-Playables

d01_roas 和 d01 总收入最高的活动不匹配。

d03_ROAS

在第 3 天分配最大 roa，在第 3 天分配最大总收入。

# Selecting columns to work withhigh_d03 = df[["campaign name","cost","d03 total revenue","d03_roas"]].copy()

作者图片

# Highest d03_roasd03_roas_max = high_d03['d03_roas'].max()
high_d03.loc[high_d03['d03_roas'] == d03_roas_max, 'campaign name']>> 86    IMT-FB-Android-RoW2-AE-Value-Video-FANIS# Highest d03 total revenued03_total_max = high_d03['d03 total revenue'].max()
high_d03.loc[high_d03['d03 total revenue'] == d03_total_max, 'campaign name']>> 0    IMT-FB-iOS-EN-US-AE-Playables

d03_roas 和 d03 总收入最高的活动与不匹配。

d07_ROAS

在第 7 天分配最大 roa，在第 7 天分配最大总收入。

# Selecting columns to work withhigh_d07 = df[["campaign name","cost","d07 total revenue","d07_roas"]].copy()

作者图片

# Highest d07_roasd07_roas_max = high_d07['d07_roas'].max()
high_d07.loc[high_d07['d07_roas'] == d07_roas_max, 'campaign name']>> 86    IMT-FB-Android-RoW2-AE-Value-Video-FANIS# Highest d07 total revenud07_total_max = high_d07['d07 total revenue'].max()
high_d07.loc[high_d07['d07 total revenue'] == d07_total_max, 'campaign name']>> 0    IMT-FB-iOS-EN-US-AE-Playables

d07_roas 和 d07 总收入最高的活动与不匹配。

d30_ROAS

在第 30 天分配最大 roa，在第 30 天分配最大总收入。

# Selecting columns to work withhigh_d30 = df[["campaign name","cost","d30 total revenue","d30_roas"]].copy()

作者图片

# Highest d30_roasd30_roas_max = high_d30['d30_roas'].max()
high_d30.loc[high_d30['d30_roas'] == d30_roas_max, 'campaign name']>> 2    IMT-Vungle-iOS-CN# Highest d30 total revenued30_total_max = high_d30['d30 total revenue'].max()
high_d30.loc[high_d30['d30 total revenue'] == d30_total_max, 'campaign name']>> 0    IMT-FB-iOS-EN-US-AE-Playables

d30_roas 和 d30 总收入最高的活动与不匹配。

Q13。第一个月之后，第一天的 roa 低于 10%的营销活动是否达到收支平衡？

收入达到并等于其成本的阈值决定了活动的盈亏平衡点。

为了检查在第一天低于 10%的所有营销活动是否在 30 天后达到收支平衡，我们需要选择 d01_ROAS 低于 10%的营销活动，并从 d30 总收入高于或至少等于其成本的细分市场中选择营销活动。

# Selecting campaigns segment of ROAS d01 under 10%d01_roas_under10 = d01_roas_under10[d01_roas_under10["d01_roas"] < 0.10].copy()# Filtering campaigns segment in wihch "d30 total revenue" is higher than its costd01_roas_under10[d01_roas_under10["d30 total revenue"] > d01_roas_under10["cost"]]

作者图片

30 天后，上述 3 个营销活动实现了收支平衡。

Q14。假设第 7 天 roa 高于 70%的营销活动将在 30 天后达到收支平衡是否安全？

让我们选择 d07_ROAS 高于 70%的所有活动，并从 d30 总收入低于其成本的细分市场中选择所有活动。

# Selecting campaigns segment of ROAS 7 days above 70%
d07_roas_up70 = df[df["d07_roas"] > 0.70].copy()

作者图片

# Filtering campaigns segment in which "d30 total revenue" is lower than its cost(d07_roas_up70[d07_roas_up70["d30 total revenue"] < d07_roas_up70["cost"]]).values.any()>> False

D07 ROAS 高于 70% 的所有活动在 30 天后实现了收支平衡。

Q15。监控两个平台的整体 ROAS 发展

在下一个直方图中，我们可以观察到第一天 roa 的大多数活动高度集中在 10%左右，少数活动几乎达到 20%。

另一方面，在 3 天后，大多数活动集中在 15%和 35%之间，一些活动达到 40%和 55%之间的 ROAS，在少数情况下甚至接近 80%。

# Display histogram: d01_roas vs d03_roas evolution comparisond01_roas = df.d01_roas
d03_roas = df.d03_roasd01 = np.array(d01_roas)
d03 = np.array(d03_roas)plt.figure(figsize=(14,8))plt.hist(d01, bins=89, density=True, color="g", alpha = 0.7, label="d01_roas")
plt.hist(d03, bins=89, density=True, color="r", alpha = 0.5, label="d03_roas")plt.legend(loc='upper right')
plt.xlabel("Relative observations", fontsize=10)
plt.xticks(rotation=0, horizontalalignment="center")
plt.ylabel("Density scale", fontsize=10)
plt.title("d01_roas vs. d03_roas", fontsize=10, loc="right")
plt.show()

作者图片

虽然第三天有一大群低于 20%的活动，但超过一半的活动集中在 30%到 45%的 roa 之间。我们可以看到，有少数运动超过 60%，甚至 100%超过盈亏平衡。

作者图片

正如所料，30 天后我们可以从 d30_ROAS 的角度看到活动的公平分布。有一个集群甚至没有超过 20%,有了这些有价值的信息，营销团队可以调查广告支出回报不高的活动出了什么问题，并重新定义这些运营。

作者图片

结论

为了确定整体绩效并估计活动的广告支出回报(ROAS ),我们分析了一些重要的指标，并计算了一些关于营销运营和广告投入金额、用户成功安装应用的数量的 KPI，并监控了每个时间段内部分回报的变化，为营销团队提供了重要的见解。

在营销环境中，指标是可以衡量战术操作结果的指标，如在电子商务网站上的购买量、移动应用的安装量、用户对广告的接触行为，并且与任何转化目标(即特定目标)无关。

另一方面，**关键绩效指标(KPI)**是管理工具，允许监控、评估和控制公司、产品或服务在特定或一般运营目标方面的绩效水平，有助于全面了解与既定营销战略相关的结果的演变、绩效、影响、强度和方向。

营销报告已经完成，但从现在开始，还有更多的内容可以进行更深入的调查和分析。

你可以在这里找到完整的代码。
“mkt_ua_campaigns.csv”数据集可在此处下载。

查看您可能也会喜欢的其他文章:

联系人

领英
推特
中等
GitHub
卡格尔
电子邮件

好的阅读，伟大的编码！

为您的下一个数据科学项目提供 15 种免费开源数据资源

原文：https://towardsdatascience.com/15-free-open-source-data-resources-for-your-next-data-science-project-6480edee9bc1?source=collection_archive---------7-----------------------

为初学者和专业人士按不同类别组织的免费数据集的合并列表

Firmbee.com在 Unsplash 上拍照

自从疫情对数据科学家的需求增加以来，数据科学领域出现了许多初学者。大多数时候，他们会问我在哪里可以找到机器学习/深度学习项目的数据集？我在哪里可以获得数据科学的免费数据集？

所以在这里，我为每一个初学者写一篇非常基础的有用的信息。我希望这篇文章对初学者以及之前不熟悉这些资源的高级数据科学专业人员有所帮助。

数据！数据！数据！

它不是无处不在，但却是现成的吗？当然不是。在我带你们浏览提供几乎所有领域数据集的资源列表之前，当然是免费的。首先要明白的是，要应用数据科学技能，你首先需要有一个现成的数据集。

如何为特定的机器学习项目找到最佳数据集？去哪里看？卡住..！！花了很多时间去寻找它，却以失败告终，那么这篇简短的指南只是让你浏览一些有用的资源。

如果您曾经从零开始从事过自己的项目，您可能对在数据收集过程中遇到的障碍很熟悉。数据收集是开始数据科学项目的第一步，也是最重要的一步。

获取数据集有三种方法:

用 python 刮
使用软件刮削
提供一组不同数据集的平台(本帖)

因此，下面我将为您提供 15 个最有用的平台，您可以从中获取数据集，开始您的数据科学之旅。

数据集资源的完整列表:-

Kaggle →我敢肯定，你们中的许多人一定熟悉这个平台，因为它在数据科学领域非常有名，原因有很多。我把它放在最上面，因为我大部分时间都在用它。这对数据科学社区确实很有帮助，因为他们有有趣的数据集，几乎涵盖了每个不同的方面，如健康、金融、银行、教育等等！
如果你想要结构化的现成数据，那就把它作为你的第一选择。Kaggle 数据集不仅是开放的、可访问的数据格式，在平台上得到更好的支持，而且对于更多人来说，无论他们使用什么工具，都更容易使用它们。您还可以找到各种文件类型，比如 CSV、JSON、SQLite、BigQuery

2。UCI ML repo→UCI 机器学习知识库是机器学习社区用于机器学习算法实证分析的数据库、领域理论和数据生成器的集合。他们目前有 588 个数据科学开源数据集，作为对机器学习社区的服务，并有对机器学习项目有帮助的数据集。您可以通过可搜索的界面查看所有 UCI 数据集。
在攻读硕士学位期间，我无法为我的一个项目找到任何免费数据集。然后，我的一个教员建议我使用这个平台，它做得很好。我找到了一个非常好的大型 UCI 数据集来启动我的项目。我把它放在列表的第二位，因为 UCI 的数据集组织得相当好。你甚至可以使用你正在尝试的任务类型进行搜索，比如回归、分类或 NLP。

3。Quandl→一个资源为数据科学社区提供免费数据集，该社区专为专业人士设计，向世界各地的人们提供金融、经济和替代数据。它们涵盖了几乎两种类型的数据，时间序列和表格。你可以在这里找到有趣的金融、经济数据集。在这些领域，你可以找到非常好的机器学习项目数据集。你所需要做的就是在搜索栏中插入你感兴趣的关键词，然后从列出的数据集的结果中进行选择。

要使用特定的数据集，您必须访问其使用选项卡。由于我无法在这里涵盖所有内容，请访问此文档以充分理解如何使用这个平台来完成使用 API 的数据需求。除了 API，你还可以使用 python 库直接调用你需要的任何财务数据到你的 python IDE 中，要了解如何做，请参考这个文档。

****4。Data.gov→这个特殊的网站是由美国政府维护的，只有他们才能决定在那里发布什么样的公共免费数据集，供像你我这样的研究人员和数据科学人士使用。在这里，你可以找到按不同类别排列的免费数据集，如农业、气候、能源、海洋、地方政府、海事、老年人健康。
因此，如果你对列出的任何类别感兴趣，你可以访问这个平台，获得机器学习项目的免费数据集。只需访问网站的网址，并转到顶部的数据选项卡。这将列出所有数据集。你也可以搜索感兴趣的关键词。在浏览这个网站时，我也发现了非常好的资源。所以别忘了浏览一遍。

****5。Data.gov.in→这个特殊的遗址由印度政府维护。他们发布几乎每个领域的各种数据，如教育、金融、医疗保健等，以便像我们这样的研究人员可以使用这些数据并开发一些有用的项目。当然，您可以将这些免费数据集用于数据科学项目。你也可以在这里找到机器学习/深度学习项目的图像数据集。该网站上共享的有趣数据集包含为 ISRO DRDO 等组织构建的项目。因此，就正确使用而言，这种免费数据集的敏感度很高。

访问这个细节非常简单:

只需输入关键字并搜索，例如教育

点击相关的搜索结果。
上述步骤将带您进入包含该数据集的目录。

浏览目录中的页面，以找到正确的数据集。
以所需的格式提取数据集。
该网站将问一些基本的问题为使用目的，回答他们，并保存数据。

6。 世界银行数据 →唯一一个与银行地区和全球业务密切合作以获得高水平良好统计数据的网站，他们维护着多个宏观、金融和行业数据库。他们在任何方面都不会在数据的质量和数量上妥协，因为一个没有贫困的世界的目标对他们来说是至关重要的。
因此，如果这个选项也让你兴奋，请参考这个足够的文档，了解如何从这个特定的网站下载数据集。该文档将帮助您更好地理解该网站，因为数据集分布在不同的部分，如数据库、微数据、数据目录。

7。grouplens 是明尼苏达大学计算机科学系的一个研究实验室。他们开发了一些端到端的数据科学项目，如 movielens、本地地理信息系统、数字图书馆、cyclopath、booklens。他们还提供一些从研究和调查中获得的免费数据集。如果您对列出的任何项目感兴趣，请访问网站顶部的数据集选项卡，查看哪些项目可用，哪些项目不可用。

8。印度储备银行发布了一些免费数据。如果你还想分析货币市场运作、支付流程、银行业务的使用，那么这个网站是为你的下一个数据科学项目寻找正确数据集的必去之地。数据集按收集方式组织，无论是每天、每周、每月等。这个网站对执行一些时间序列项目非常有帮助。

9。 公开数据集的 Github repo→安牛逼的公开数据集 repo 是我在 Github 上发现有用的库。这个知识库非常棒，包含了一些高质量的免费数据集，更不用说针对不同领域的良好组织了。一定要访问这个回购，不要忘记与我分享，无论你觉得有用与否？****

10。Fivethirtyeight→是一个写互动文章和制作图形的网站，主题从政治到体育、经济、文化和科学&健康。它们提供了一些从各种开源数据集中检索到的分析故事。你可以从这个链接获得免费数据集，你所要做的就是下载你感兴趣的数据。

另一个可用的选项是他们的 GitHub repo ，用于访问他们感兴趣的数据集以及创建可视化和交互式故事背后的代码。

11. Data.world →这个网站不仅对数据科学人员非常方便，对只想获得见解的非技术人员也非常方便。人们喜欢记者、商务人士获得清晰、准确、快速的商业问题答案。他们对数据目录中的免费数据集进行了很好的组织，以便于发现、管理和访问。这是链接到 data.world 上的开放数据集的财务目录。您可以选择其他类别。

12. 谷歌数据集搜索 →与其他网站不同，它是一个为寻找免费数据集而发明的搜索引擎。谷歌数据集搜索就像常规的谷歌搜索一样，基于提供的关键词。它将关键字与数据集的描述而不是内容进行匹配。在输入特定的关键字时，如果数据集是公开可用的，那么找到它的机会很大。在推出的时候，谷歌数据集搜索拥有来自全球近 2500 万个不同的免费数据集。

13.Open ML→OpenML 是一个开放的数据科学平台，实际上是为了机器学习研究。平台非常整洁干净，所有部分都组织有序。你可以找到各种领域的免费数据集，比如医疗保健、教育、气候变化、政治、体育等等。每个感兴趣的数据集都可以以多种格式下载，如 CSV、JSON、XML 等，在这个网站上每个数据集都有一个单独的页面。

只需访问您选择的数据集，并通过选择右上角的来下载所需的格式。

你可以使用这个平台来执行你的机器学习任务，也可以从网站上其他人的任务中获得帮助，你建立的那些模型可以与他人共享，以便他们也可以使用它。

14.BuzzFeed News→是一家以分析性报道为特色的美国新闻网站。它开源了他们使用的数据集、库和工具，数据和分析，以及一些关于 Github repo 的指南。

15.国家环境信息中心→ 如果您正在寻找一些与天气和环境条件相关的数据，这是最佳选择。NCEI 是世界上最大的环境数据库。它拥有与美国各地的气候相关的数据集、海洋数据、气象数据、气候条件、地球物理数据、大气信息等。

结论

上面合并的免费数据集资源列表是从非常著名的资源到一些被低估的资源开始的，这些资源在数据科学社区中不是非常受欢迎。

我尽我最大的努力尽可能包括最好的，因为我知道得不到正确数据的痛苦。而且，如果每次都去刮的话，也是很费时间和繁琐的工作。几乎所有列出的数据聚合站点都托管开放数据集。

如果你打算从事任何数据科学项目，我希望这个列表能帮助你迈出获得正确数据的第一步。如果它在任何方面对你有帮助，别忘了评论并让我和其他人知道。如果你喜欢这个列表，并且认为它也能帮助其他人，请为这篇文章鼓掌，这样它就能帮助到那些需要帮助的人。

为你们所有人干杯并致以最美好的祝愿！！！

您可以通过以下方式联系我:

订阅我的 YouTube 频道 视频内容即将上线这里
跟我上中
通过 LinkedIn 联系我
成为会员:-https://techykajal.medium.com/membership

也可以看看我的其他博客:

****</8-ml-ai-projects-to-make-your-portfolio-stand-out-bfc5be94e063> ****

我从高效数据科学家那里学到的 15 个习惯

原文：https://towardsdatascience.com/15-habits-i-stole-from-highly-effective-data-scientists-441b1d46c572?source=collection_archive---------1-----------------------

我将在 2021 年使用这些习惯，成为一名更有效的未来数据科学家

叶夫根尼·切博塔列夫摄于佩克斯

当谈到进入数据科学领域时，你需要使用书中的每一个技巧来给自己一个优势，推动你越过终点线。

那么，为什么不试着模仿业内精英的习惯呢？

本文不是成为高效数据科学家的“快速致富”方法。相反，它展示了帮助最优秀的数据科学家获得成功的习惯。

人们常说，数据科学家的价值取决于他们对组织的影响。这种影响始于通过养成良好的习惯成为一名高效的数据科学家。

1.跟上技术的发展。

有多少当前的数据科学技术是在过去十年左右才出现的？几乎大部分都是。

带着要好好尝试的动机进入数据科学领域，你已经将自己降格为一个不断学习的人。别担心，没有听起来那么凄凉。

然而，你应该时刻牢记的是，要想在职场中保持相关性，你需要跟上技术的发展。所以，如果你整个职业生涯都在用 MATLAB 做数据分析，那就试着学习用 Python 编码吧。如果你已经用 Matplotlib 创建了你的可视化，试着用 Plotly 做些新鲜的东西。

**如何实现这个习惯:**每周花一个小时(或者尽可能多的空闲时间)，尝试新技术。通过阅读博客文章找出哪些技术是相关的，并选择一些你想添加到你的堆栈中的技术。然后，创建一些个人项目，学习如何最大限度地利用新技术。

2.保留适当的文件。

我似乎总是很幸运地阅读和处理那些糟糕的文档和没有支持性注释来帮助我理解到底发生了什么的代码。

我曾经把它归因于程序员的小声刻薄，直到有一天，我意识到这只是一个糟糕的程序员的标志。

我接触过的所有优秀程序员都提供清晰、简洁的文档来支持他们的工作，并在他们的程序中加入有用的注释来描述某些代码行在做什么。这对于使用复杂算法和机器学习模型来解决问题的数据科学家来说尤其相关。

如何实现这个习惯:花些时间阅读好的代码文档或关于如何编写好的代码文档的文章。为了练习，为旧的个人项目写文档，或者花些时间修改你当前项目的文档。由于数据科学世界的很大一部分都是在 Python 上运行的，所以请查看这篇关于如何记录 Python 代码的写得非常好的文章:

https://realpython.com/documenting-python-code/

3.加入数据科学社区。

开发人员是皮肤苍白的社会弃儿，他们把自己锁在孤独中，编写注定要统治世界的代码，这种刻板印象是一种过时的概括，不能反映整个科技行业的现代复杂性。

“没有人是一座孤岛。”—许多数据科学家最喜欢引用的一句话

数据科学的复杂性使得数据科学社区内外的专业人士需要一个庞大的支持网络来解决各种问题，这使得数据科学家成为必要。

然而，社区的重要性并不仅仅停留在专业层面。随着数据科学领域的扩展，有必要为未来的分析师和工程师铺平道路，这样他们也可以产生影响，并进一步支持其他数据科学家。

随着数据科学领域的“性感”逐渐消失，做出必要改变的唯一方式是发起一场社区范围的运动，激励行业向更好的方向转变。

**如何实现这个习惯:**成为导师，撰写内容丰富的博客文章，加入数据科学论坛并帮助回答问题，开设 Youtube 频道来分享你的经验，参加 Kaggle 比赛和黑客马拉松，或者创建课程来帮助未来的数据科学家学习他们进入该行业所需的技能。

4.定期重构您的代码。

重构是在不改变代码原有功能的情况下清理代码的过程。虽然重构是一个在软件开发环境中必然产生的过程，但是重构对于数据科学家来说是一个有用的习惯。

我重构时的口头禅是*“少即是多”*。

我发现，当我最初编写代码来解决数据科学问题时，我通常会将良好的编码实践扔在门外，以支持编写在需要时工作的代码。换句话说，会出现大量的意大利面条式代码。然后，在我让我的解决方案工作之后，我会回去清理我的代码。

如何实现这个习惯:看看旧代码，问问同样的代码是否可以写得更有效率。如果是这样，花些时间自学最佳编码实践，并寻找可以缩短、优化和阐明代码的方法。查看这篇概述代码重构最佳实践的文章:

https://www.altexsoft.com/blog/engineering/code-refactoring-best-practices-when-and-when-not-to-do-it/

5.优化您的工作空间、工具和工作流程。

有如此多的提高生产力的 ide 扩展，令人惊讶的是，有些人还没有选择优化他们的工作流。

这个习惯对每个人来说都是如此独特，以至于它真的决定了哪些工具、工作空间和工作流能让你成为最有效和最高效的数据科学家。

**如何实现这个习惯:**一年一次(或者更频繁，如果对你更有效的话)，评估你的整体效力和效率，并确定你可以改进的地方。也许这意味着早上第一件事就是研究你的机器学习算法，或者坐在健身球上而不是椅子上，或者给你的 IDE 添加一个新的扩展来为你处理代码。尝试不同的工作空间、工具和工作流程，直到您进入最佳状态。

6.专注于理解业务问题。

据我所见，数据科学 75%是理解业务问题，25%是编写模型来找出如何解决这些问题。

编码、算法和数学是容易的部分。了解如何实现它们，以便它们可以解决特定的业务问题，而不是太多。通过花更多的时间去理解业务问题和你试图解决的目标，剩下的过程会顺利得多。

要了解你所在行业面临的问题，你需要做一些调查，收集一些背景知识，以支持你对你试图解决的问题的了解。例如，你需要了解是什么让某个特定行业的客户产生兴趣，或者一个工程公司试图达到的特定目标。

**如何养成这个习惯:**花些时间研究一下你现在工作的具体公司以及他们所在的行业。写一份你可以参考的备忘单，包括公司的主要目标，以及公司在特定行业可能面临的问题。不要忘记包括你可能想用来解决商业问题的算法，或者对未来可能有用的机器学习模型的想法。每当你发现一些有用的东西时，就把它添加到这个备忘单上，很快你就会拥有一个与行业相关的珍闻宝库。

7.采用极简风格。

不，不是在生活中。在您的代码和工作流中。

人们经常说最好的数据科学家使用最少的代码、最少的数据和最简单的算法来完成工作。

虽然我说的极简主义者并不是要你马上假设稀缺性。通常，当有人讨论极简主义在代码中的重要性时，会导致人们试图开发仅使用几行代码的惊人解决方案。停下来。是的，令人印象深刻，但这真的是对你时间的最好利用吗？

相反，一旦你熟悉了数据科学的概念，就开始寻找可以优化你的代码的方法，使它简单、干净、简短。使用简单的算法来完成工作，不要忘记编写可重用的函数来消除冗余。

**如何实现这个习惯:**随着你作为数据科学家的进步，开始推动自己编写更高效的解决方案，编写更少的代码，使用更简单的算法和模型来完成工作。学习如何在不降低效率的情况下缩短代码，并留下大量注释来解释代码的压缩版本是如何工作的。

8.使用函数来消除复杂性和冗余。

我将第一个承认，当我第一次编写数据分析代码时，我严重忽视了函数。当我在不同的分析中努力推理时，我的 IDE 中充满了意大利面条式的代码。如果你看了我的代码，你可能会认为它走得太远了，并自愿把它带到谷仓后面，以结束它的痛苦。

一旦我设法拼凑出一个还算过得去的结果，我就会回去尝试修复一个相当于严重事故的东西。通过将我的代码打包成函数，我很快消除了不必要的复杂性和冗余。如果这是我对我的代码做的唯一的事情，那么我已经把它简化到一个点，我可以重新访问解决方案并理解我是如何到达那个点的。

**如何实现这个习惯:**写代码的时候不要忘记函数的重要性。人们常说，最好的开发人员是懒惰的开发人员，因为他们知道如何创建不需要太多工作的解决方案。在你写完一个解决方案后，回过头来把多余或复杂的代码捆绑到函数中，以帮助组织和简化你的代码。

9.应用测试驱动的开发方法。

测试驱动开发(TDD)是一种软件开发原则，它专注于编写不断测试的增量改进代码。TDD 运行在一个“红绿重构”系统上，该系统鼓励开发人员构建测试套件，编写实现代码，然后优化代码库。

数据科学家可以成功地实现 TDD，以产生分析管道，开发概念证明，处理数据子集，并确保功能代码在开发过程中不会被破坏。

如何实现这个习惯:研究测试驱动开发，确定这种技术是否能给你的工作流程增加一些东西。TDD 并不是所有问题的完美答案，但是如果考虑周全的话，它会很有用。查看这篇文章，它对 TDD 进行了很好的描述，并提供了一个如何在数据科学项目中实现它的例子:

10.小而频繁地犯错误。

你有没有做过一个拉请求，然后你的电脑被错误信息和 wazoo 发出的问题搞得崩溃？我有。糟透了。

当你想介绍一个对你做出如此大承诺的人时，深呼吸，记住这个人显然没有花时间去养成良好的习惯。

基于团队的软件开发的黄金法则是什么？小而频繁地犯错误。

**如何实现这个习惯:**养成经常提交代码变更的习惯，并且定期发出拉取请求以获取最新的代码。您或其他人所做的每个更改都可能会破坏整个项目，因此重要的是要做出易于恢复且可能只影响项目的一部分或一层的小更改。

11.把自我发展放在首位。

取决于你问谁，这个行业要么数据科学家太多，要么太少。

不管这个行业是变得饱和还是贫瘠，你都将和一大堆非常合格的候选人竞争一份工作。这意味着在申请工作之前，你需要已经养成了自我提升的习惯。如今，每个人都痴迷于技能提升，而且理由充分。这种趋势对于数据科学家来说应该也不例外。

**如何养成这个习惯:**做一份技能清单，看看你如何符合雇主在招聘启事中提出的要求。你是一个能够高效使用 Keras、NumPy、Pandas、PyTorch、TensorFlow、Matplotlib、Seaborn、Plotly 等相关库的 Pythonista 吗？你能写一份备忘录，详细说明你的最新发现，以及它们如何能让你的公司效率提高 25%吗？你是否愿意作为团队的一员来完成一个项目？找出任何缺点，找一些好的在线课程或资源来提高你的技能。

12.开始一个项目时要考虑到最终结果。

在《高效能人士的 7 个习惯中，史蒂芬·科维论述了“以目的为出发点”的原则。

为了有效地将这与数据科学项目联系起来，您需要在项目的规划阶段问自己，项目的预期结果是什么。这将有助于塑造项目的路径，并给你一个为达到最终目标而需要达到的结果的路线图。不仅如此，确定项目的结果会让你从整体上了解项目的可行性和可持续性。

**如何实现这个习惯:**每个项目开始时都有一个规划会议，明确列出你希望在开发期结束时实现的目标。确定你将试图解决的问题，或者你试图收集的证据。然后，你可以开始回答可行性和可持续性问题，这些问题将塑造你的项目的里程碑和成果。从那里，你可以开始编写代码和机器学习模型，并有一个清晰的计划来指导你完成项目。

13.理解，这样你才能被理解。

在试图准备一个关于为什么自旋 V2 粒子服从费米-狄拉克统计的新生讲座失败后，理查德·费曼说了一句著名的话“我不能把它简化到新生水平。这意味着我们真的不了解它。”被称为“伟大的解释者”，费曼留下了数据科学家只能希望效仿的遗产。

数据科学是一门使用数据讲述引人入胜的故事的艺术，只有当讲故事的人理解他们试图讲述的故事时，它才会成功。换句话说，理解是你的任务，这样你才能被理解。在理解你试图完成的事情的早期培养这种习惯，这样你就可以和其他人分享到一个合理的理解水平，这将使你成为房间里最有效的数据科学家。

**如何养成这个习惯:**使用费曼技巧来深入理解你试图发现的概念和试图解决的问题。这种方法与分析数据，然后向一般非数据科学利益相关者解释结果的数据科学流程保持一致。简而言之，你把你对主题的解释精炼到这样一个程度，你可以用简单的、非行话的术语来解释，任何人都可以理解。

14.阅读研究论文。

在一个由硕士和博士主导的领域，研究论文经常被用来分享行业新闻和见解。

研究论文是了解他人如何解决问题、拓宽我们的视野以及跟上最新趋势的有用途径。

**如何养成这个习惯:**每周挑选一两篇与你目前的工作或你感兴趣的技术相关的研究论文阅读。试着每周为这个文献综述留出时间，让它成为一个优先事项。熟悉阅读研究论文的三步法，这有助于你快速收集相关信息。为了真正巩固你对论文的理解，试着把你从阅读中学到的东西落实到个人项目中，或者和同事分享你学到的东西。

15.接受改变。

从使用的技术到实现的目标，数据科学的世界正在快速变化。不要成为那种固步自封、不愿改变的数据科学家。

作为一名专业人士，对变化保持开放的态度不仅能迫使你不断进步，还能让你在快速变化的行业中保持相关性，一旦你落后了，这个行业就会把你踢出局。

如何实现这个习惯:每当一项新技术或实践成为新闻，试一试，看看这项新技术或实践带来了什么。即使您只是阅读文档，您也可以随时了解行业的最新变化趋势。此外，您可以为您的公司带来对技术的看法，并帮助他们驾驭技术变革和进步。在办公室里做一个耳听八方的人可以帮助你保持领先，也可以帮助你指导你的团队和公司找到更好、更有效的解决方案。

在数据科学职业生涯的任何阶段，养成良好的习惯都可以让你发挥潜力，成为团队中的一名高效成员，对他们试图解决的任何问题产生重大影响。

没有比现在更好的时间来花时间为未来的成功做准备。

你现在应该使用的 15 个鲜为人知的有用 SkLearn 模型

原文：https://towardsdatascience.com/15-lesser-known-useful-sklearn-models-you-should-use-now-a1a566e680a6?source=collection_archive---------20-----------------------

可以从 SkLearn 库中使用的一些更有趣的模型。

(图片由作者提供)

Sk Learn 可能是 Python 最流行的机器学习模块之一。这是有充分理由的，因为 SkLearn 有一个非常棒的可用模型、缩放器、工具甚至编码器的目录！虽然有一些非常流行的模型非常有名，但是 SkLearn 是一个非常大的库，很容易忘记它附带的所有函数和类。虽然文档是一个很好的起点，但是扩展您的建模能力的另一个很好的方法是更熟悉使用不同的模型。

考虑到这一点，我开始喜欢 SkLearn 的许多不同型号。有很多很好的模型被严重的利用不足。今天，我想把我最喜欢的 SkLearn 中的一些模型带给你，也许下次你面临一个独特的问题时，你会知道这个模型及其相应的应用！

数据

今天，我们将安装模型，以展示上述模型的用法。当然，要做到这一点，我们需要传递一些一维数组来预测特征。简单来说，

我们需要数据来训练。

鉴于我们在笔记本上工作，我认为它应该是开源的，所以如果你想看到这些模型适合笔记本，你可以在这里看到源代码:

笔记本

由于我们将审查分类模型以及连续模型，我们将需要分别促进这些特征类型的目标。我要用一个旧的。我手边的 CSV 文件叫做 weatherHistory.csv:

import pandas as pd
import numpy as np
df = pd.read_csv("weatherHistory.csv")

现在让我们来看看！：

df.head(5)

(图片由作者提供)

由于我们将同时使用分类和连续模型，我需要分类和连续 y。对于连续目标，我决定使用温度。为了分类，我使用了降水类型特征。对于我的预测功能，我将使用湿度功能:

caty = "Precip Type"
cony = "Temperature (C)"
x = "Humidity"

现在，我们将训练测试相应地将数据分成两个数据帧:

from sklearn.model_selection import train_test_split
train, test = train_test_split(df)

当然，我不会对这些数据做太多的处理，只是为了举例说明一些模型。考虑到这一点，这些模型不能适用于带有缺失值的数据，所以让我们得到数据框架中缺失值计数的总和。

df.isnull().sum()

想听些有趣的事吗？我可以发誓是 is_null()而不是 isnull()。

查看摘要，

Formatted Date                0
Summary                       0
Precip Type                 517
Temperature (C)               0
Apparent Temperature (C)      0
Humidity                      0
Wind Speed (km/h)             0
Wind Bearing (degrees)        0
Visibility (km)               0
Loud Cover                    0
Pressure (millibars)          0
Daily Summary                 0
dtype: int64

很明显，我可能有点超前了，让我们放弃一些不好的观察:

df = df.dropna()from sklearn.model_selection import train_test_split
train, test = train_test_split(df)

现在让我们把它放入一维数组:

trainX = train[x]
cattrainy = train[caty]
contrainy = train[cony]
testX = test[x]
cattesty = test[caty]
contesty = test[cony]

SkLearn 经常要求将这些阵列重新调整为垂直的，因为它更喜欢矩阵列中的特征，而不是矩阵行。让我们重塑这些小狗，然后我们将准备适合一些模型。为了做到这一点，我们将需要把这些一维数组变成 NumPy 数组。这是因为 SkLearn 与 NumPy 的集成程度更高，尽管它确实喜欢 Pandas 系列，但在许多情况下，NumPy 数组更加动态，也更常用:

trainX = np.array(trainX)
cattrainy = np.array(cattrainy)
contrainy = np.array(contrainy)
testX = np.array(testX)
cattesty = np.array(cattesty)
contesty = np.array(contesty)trainX = trainX.reshape(-1, 1)
cattrainy = cattrainy.reshape(-1, 1)
contrainy = contrainy.reshape(-1, 1)
testX = testX.reshape(-1, 1)
cattesty = cattesty.reshape(-1, 1)
contesty = contesty.reshape(-1, 1)

对于连续的问题

典型地用于监督模型的两种不同类型的模型是连续模型。这些模型预测的是定量值，而不是定性值。也就是说，这些模型中的许多将利用回归来估计连续值。

№1:保序/单调回归

保序或单调回归是一种令人敬畏的回归形式，许多机器学习工程师甚至从未听说过。保序回归可以是预测连续目标的非常准确的模型，但在这方面也有其自身的局限性。这方面的一个很好的例子是，这种模型往往容易过度拟合，通常要让模型工作良好，就要平衡偏差，并试图提高准确性。

这个模型的另一个重要问题是数据必须是非递减的。这意味着该模型的典型应用通常会涉及经济和商业场景。因此，考虑到这一点，虽然这个模型对于处理经济数据的人来说可能非常有用，但对于许多科学工作来说，它不一定是最好的模型。

然而，在适当的应用和平衡偏差中，保序回归可以是一个非常强大的预测模型！如果你想了解更多关于保序回归的知识，你可以看看我写的这两篇文章，一篇是我用 C++从头开始编写保序回归器，另一篇是我详细阐述模型的工作原理:

为了适应这个模型，我们首先需要使用 make_regressor 函数，它将为我们提供一个基本的回归模型，我们可以在这个模型上构建保序回归。让我们这样做:

from sklearn.isotonic import IsotonicRegression
from sklearn.datasets import make_regression
isox, isoy = make_regression(n_samples=10, n_features=1, random_state=41)m.fit(isox, isoy)
m = IsotonicRegression(trainX, contrainy)
m = IsotonicRegression()
m.fit(isox, isoy)
m.predict(testX)

№2:正交匹配追踪

另一个只适用于某些数据特征的非常有用的工具是正交匹配追踪。该模型用于获取稀疏编码信号，并去除所述数据中的噪声和异常。这意味着这些机器学习算法被用来根据数据修复某些输入信号，我认为这是机器学习的一个非常好的应用。

虽然正交匹配追踪的主要用途可能相对简单，但该模型的用途可能会更广泛。鉴于这是一个非常独特的模型，它是如何工作的呢？

正交匹配追踪形成了其名称所描述的精确运算。为了剖析这个定义，让我们来单独看一下这些词:

直角的——在直角内或者包含直角。
匹配—将观察值与值联系起来。
追求——寻找。

因此，基本上，我们正在寻找与我们的数据完美匹配的地方，它依赖于多维跨度的数据 D，这可能是编程世界中的一种字典类型。用维基百科的话说，

。想法是从希尔伯特空间(H)创建一个近似信号(f ),作为统计函数的加权和，即 pdf/CDFs/Gamma。

虽然我们现有的数据肯定不适用于这种特定模型，但在本例中，我将创建一些稀疏信号作为数据传递:

**from** **sklearn.linear_model** **import** [OrthogonalMatchingPursuit](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.OrthogonalMatchingPursuit.html#sklearn.linear_model.OrthogonalMatchingPursuit)from sklearn.datasets import make_sparse_coded_signal
n_components, n_features = 550, 100
n_nonzero_coefs = 10

*# y = Xw*
*# |x|_0 = n_nonzero_coefs*

y, X, w = [make_sparse_coded_signal](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_sparse_coded_signal.html#sklearn.datasets.make_sparse_coded_signal)(n_samples=1,
                                   n_components=n_components,
                                   n_features=n_features,
                                   n_nonzero_coefs=n_nonzero_coefs,
                                   random_state=0)

idx, = w.nonzero()

现在我们将扭曲我们的目标数据:

y_noisy = y + 0.05 * [np.random.randn](https://numpy.org/doc/stable/reference/random/generated/numpy.random.randn.html#numpy.random.randn)(len(y))

符合我们的模型:

omp = [OrthogonalMatchingPursuit](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.OrthogonalMatchingPursuit.html#sklearn.linear_model.OrthogonalMatchingPursuit)(n_nonzero_coefs=n_nonzero_coefs)
omp.fit(X, y)
coef = omp.coef_
idx_r, = coef.nonzero()

第三名:拉斯·拉索

如果你已经使用机器学习很长时间了，你可能听说过套索回归。套索回归是一个奇妙且相当标准化的工具，已经在机器学习中被频繁使用了很长一段时间。在预测连续目标的大多数时候，这肯定是我的首选模型。

然而，拉斯拉索模型不是你正常的拉索回归。“LARS lasso 模型”中的 LARS 是最小角度回归的简称。最小角度回归是一种预测连续特征的机器学习算法。它对于处理维数非常高的数据非常有用。该模型通过协变量的线性子集来工作。

这种模型的一个伟大之处在于，虽然在尺寸方面的天花板比传统模型显著提高，但与通常以这种方式使用的模型相比，它真的没有那么慢。话虽如此，但重要的是要记住，虽然该模型是从最小角度回归得到的，但这并不使其成为线性的-这就是模型的套索部分的由来。当然，如果线性模型是您正在寻找的，您可以在使用最小角度回归的传统线性回归模型上利用相同的概念，这也在 SkLearn 中。

from sklearn import linear_model
reg = linear_model.LassoLars(alpha=0.01)
reg.fit(trainX, contrainy)
reg.predict(testX)

№4:最小角度回归

正如最小角度回归在套索模型中的类似应用中所述，最小角度回归是一种用于预测连续要素的模型，通常使用协变量的线性子集。这是最小角度回归和 LARS Lasso 回归最显著的区别。最小角度回归是指该模型的线性版本。

在计算上，最小角度回归的优点是与正向选择一样快。虽然这是一个巨大的好处，但它最大的优势是在 p >> n 的情况下。如果两个变量同等相关，那么它们的系数应该以相同的速度增加。

from sklearn import linear_model
reg = linear_model.Lars()
reg.fit(trainX, contrainy)
reg.predict(testX)

№6: SGDRegressor

SkLearn 中一个概念的另一个伟大实现是随机梯度下降。随机梯度下降是一种迭代使用的方法，用于优化数学函数和构建成本。很可能你听说过梯度下降，这是类似的-但是，这个模型名称中的随机意味着我们只对 epoch 使用单个训练示例。这是两个极端中的高端，从批次梯度下降开始，每个时期使用整个批次，中间是两者的组合。

随机梯度下降中的损失梯度是每次对每个样本进行估计的，并且模型沿着强度递减的时间表进行更新，在典型的机器学习术语中也称为学习速率。

from sklearn.linear_model import SGDRegressor
m = SGDRegressor()
m.fit(trainX, contrainy)
m.predict(testX)

№7:胡伯回归

使用回归学习方法，通常会有难以克服的模型缺点。对于线性模型来说肯定是这样的，线性模型可能很难完全适合稀疏数据或多维数据。幸运的是，SkLearn 有一个很好的 Huber 回归实现。

这种形式的回归可用于处理异常值并避免建模错误，使用 SkLearn 包中可用的典型模型可能很容易犯这种错误。这可能很有用，因为尽管该模型很有用且拟合良好，但它也相对简单，这意味着过拟合和过采样不是使用该模型时通常会遇到的问题。

Huber 回归优化了平方损失(均方误差),与简单线性回归等模型相比，它对异常值相当稳健。实际上，斯坦福大学的 Art B. Owen 发表了一篇非常有趣的论文，对于那些不熟悉这种建模方法的人来说，这篇论文可能值得一读。有兴趣可以去看看:

下面是我发现的最有效的一句话，用来从数学上分析这个模型将如何处理这些数据:

“最小二乘准则非常适合于具有高斯分布的 yi，但是当 yi 具有较重的尾部分布或几乎相同的尾部分布时，当存在异常值时，会给出较差的性能。Huber (1981)描述了一个稳健的估计量，它采用了一个受非常大的残值影响较小的损失函数

不用说，这个模型是难以置信的酷！我认为它在剔除异常值方面肯定有它的用处，异常值是造成预测连续问题的困难的一个因素——这经常被低估，但在初级统计领域似乎很明显。

既然我们在数学上对这个模型有些熟悉，我们实际上可以考虑在 Sklearn 中拟合它(那是一个笑话。)

from sklearn.linear_model import HuberRegressor
m = HuberRegressor()
m.fit(trainX, contrainy)
m.predict(testX)

№8:多项式回归

虽然这个“模型”可能更多的是与其他模型一起使用的概念，但它肯定会非常有用！机器学习的一个非常常见的模式是使用非线性函数来创建线性预测。这将保持模型的速度，同时不会浪费任何预测能力。一个很好的例子是简单线性回归上的多项式回归。

在使用多项式回归的示例中，它适合用函数构建的更高维度的数据。由于使用了多项式特征，该模型可以很容易地拟合和用于解决广泛的连续问题。

为了在 sklearn 中实际使用多项式回归，我们实际上要使用多项式特性:

**from** **sklearn.preprocessing** **import** PolynomialFeatures
poly = PolynomialFeatures(2)
poly.fit_transform(trainX)from sklearn.linear_model import LinearRegression
reg = LinearRegression()
reg.fit(trainX, contrainy)
reg.predict(testX)

№9:普通最小二乘法

普通最小二乘法是另一种预测连续特征的非常酷的数学机器学习模型。普通最小二乘法也是一种线性模型，适合用来最小化数据中点之间平方和的系数。

普通最小二乘法的权重严重依赖于用于预测目标的特征的独立性。也就是说，这个模型对于具有单一特性的实现非常有用。此外，它可以与多个特征一起使用，但肯定需要将特征向目标加权。查看这个描述，很容易看到像普通最小二乘法这样的模型在我们的机器学习武器库中的确切位置。

不幸的是，OLS 的 SkLearn 实现并不像大多数实现那样简单。OLS 系数实际上包含在线性回归类下面。系数 _:

linear_model.LinearRegression().fit(trainX, contrainy).coef_

№10:NuSVR

回到支持向量机的魔力，请允许我向您介绍 NuSVR。NuSVR 当然是和 NuSVC 一样的模型和机器实现。这两个模型都利用 libsvm，并使用参数 nu 来控制机器中支持向量的数量。但是，与 nu 代替 C 的 NuSVC 不同，这里 nu 代替了 epsilon-SVR 的参数 epsilon。

使用该模型的优点是提供了用于调整向量机的参数，该向量机用于帮助估计该回归问题。也就是说，该模型非常适合预测连续特征，这些特征对于我们的目标可能非常重要，也可能不太重要。

**from** **sklearn.svm** **import** NuSVR
from sklearn.svm import NuSVR
m = NuSVR()
m.fit(trainX, contrainy)
m.predict(testX)

№11:多任务套索

就像拉斯·拉索一样，你可能听说过拉索回归。作为复习，这是一个非常常用的预测连续特征的非线性模型。多任务套索的不同之处在于，多任务套索将使用 L1/L2 规范作为正则化。

为了证明这一点，让我们看看套索回归的优化目标:

(1 / (2 * n_samples)) * ||Y - XW||^2_Fro + alpha * ||W||_21

在本例中，||W||_21将被修改以适应多任务套索的公式:

||W||_21 = \sum_i \sqrt{\sum_j w_{ij}^2}

本质上这意味着我们得到了每一行的总和。

from sklearn.linear_model import MultiTaskLasso
m = MultiTaskLasso()
m.fit(trainX, contrainy)
m.predict(testX)

对于分类问题

在机器学习中，可能会有很多连续的问题，但是

№12:线性 SVC

LinearSVC 是一种支持向量机类型的模型。该模型的 SkLearn 实现是使用 libsvm 创建的。虽然核可以是非线性的，但是它的 SMO 通常不能很好地适用于大量样本。这就是线性支持向量分类器派上用场的地方。

也就是说，虽然 Sklearn 中还有其他一些很棒的 SVC 实现可能更有名，但是 LinearSVC 无疑是一个非常值得注意的模型！SVC 通常以多类模式工作，用一个类来衡量另一个类。在 LinearSVC 的情况下，所有这些类都是相互权衡的——这使得该模型比许多 SVC 竞争对手更全面。

至于 SkLearn 类，它是一个令人敬畏的、近乎完美的实现。它非常好地支持密集和稀疏数据，并且可能是一个令人难以置信的模型——在我看来，很容易成为 Python 中最好的线性分类模型之一！

from sklearn.svm import LinearSVC
m = LinearSVC()
m.fit(trainX, cattrainy)
m.predict(testX)

№12:SGD 分类器

正如我们在简要讨论 SGDRegressor 时所讨论的，随机梯度下降是指在每次迭代中使用每一批来加权特性的成本。当然，SGDClassifier 与现在应用于分类问题的概念完全相同。

像 SGDRegressor 一样，这个模型是一个很好的实现，尤其是在处理大量特性时，它非常有价值。虽然这可能会导致性能大幅下降，但可能需要权衡由此产生的预测是否值得这些特别的努力。

安装 SGDRegressor 非常简单，并且和这个列表中的许多人一样，将遵循

进口
合适的
预测

from sklearn.linear_model import SGDClassifier
m = SGDClassifier()
m.fit(trainX, cattrainy)
m.predict(testX)

13 号:伯努利朴素贝叶斯

伯努利朴素贝叶斯分类模型可以像任何贝叶斯分类模型一样使用，但是它有一个锦囊妙计:

伯努利分布。

您可能熟悉这个分布，因为它的 CDF 经常出现在逻辑分类模型附近。我想说这个模型的用法和多项式非常相似。然而，尽管 MultinomialNB 在计数和发生方面表现得更好，BernoulliNB 却使用伯努利分布，并且是为布尔型特征而设计的。这当然让我回想起我最初的陈述，伯努利用于逻辑回归，也就是说，这个模型本质上有相同的用途，所以它使用相同的分布是有意义的。

尽管该模型通常用于预测二元特征，但今天我们只传递一些可能更适用于多项式的典型分类数据。也就是说，记住这两个模型的用例是很重要的，因为它们非常强大，但是应该用于它们适当的特性类型。如果您不了解您试图预测的目标，那么使用模型是没有意义的，我认为这些模型之间的差异突出了数据科学家需要了解不同的模型需要不同类型的功能才能很好地工作。这是一个很好的经验，但不管怎样，它遵循了我们对 SkLearn 的典型期望:

from sklearn.naive_bayes import BernoulliNB
m = BernoulliNB()
m.fit(trainX, cattrainy)
m.predict(testX)

№14:山脊分类

如果你一直在研究机器学习模型，尤其是连续模型，你可能听说过岭回归。岭回归是一种用于预测连续特征的流行模型。当然，RidgeClassification 是这种分类问题的精确模型的分类等价物。

模型的分类版本将目标转换为{-1, 1} ，然后用典型的岭回归将其建模为回归问题。我认为这是一个非常酷的概念，因为在我看来，将回归和其他解决问题的连续方法应用于一个完全不同的问题，如分类，是非常酷的。

幸运的是，尽管这个模型真的很棒，看起来像一个先进的概念，但奇妙的 SkLearn 使它非常容易使用，符合图书馆的典型惯例:

from sklearn.linear_model import RidgeClassifier
m = RidgeClassifier()
m.fit(trainX, cattrainy)
m.predict(testX)

№15:校准分类器

这份名单上最酷的车型之一可能是 CalibratedClassifierCV。该模型使用交叉验证来估计分类器的参数。该模型可以与作为基础的逻辑回归器一起使用，这将使它成为用于对布尔类型进行分类的伟大模型。

然而，由于这个模型实际上可以采用不同的基本估计量，所以一个常用的模型实际上是保序回归。保序回归是一个非常酷的模型，但在我看来，当与分类问题结合起来时，它会变得更酷。这意味着阈值现在被附加到类，而不是连续数据中的任意分位数。

不同于这个列表中预测目标的许多其他解决方案，这是另一个将成为其他模型的补充的解决方案。换句话说，我们可以通过简单地构建一个分类器来校准任何分类器。在这个例子中，我将使用高斯朴素贝叶斯建立一个模型，这是 SkLearn 中的另一个分类模型，类似于多项式朴素贝叶斯。

from sklearn.naive_bayes import GaussianNB
from sklearn.calibration import CalibratedClassifierCV
base_clf = GaussianNB()
calibrated_clf = CalibratedClassifierCV(base_estimator=base_clf, cv=3)
calibrated_clf.fit(trainX, cattrainy)
calibrated_clf.predict(testX)

“顺便说一下，在我看来这是一个非常酷的方法，我真的认为 SkLearn 在对象的使用方式和它们作为类使用的约定上击中了要害。”

结论

SkLearn 是一个如此令人敬畏的库，以至于现在的机器学习工程师可能会认为这是理所当然的。图书馆里有很多模型是绝对不可思议的，可能会被忽视，因为冠军已经出现了。这些型号你用过几个？我希望这些对这些令人敬畏的模型的描述和介绍是有趣的，甚至对你下一个项目的模型选择有所帮助。

非常感谢你的阅读，新年快乐！我认为这些模型在未来将是非常宝贵的资产。也许如果你遇到一个好的二进制分类问题，或者线性建模问题，你会回想起我第一年写的这篇文章。希望这篇文章能激发更深入的挖掘和研究，以了解更多关于建模的知识，因为学习建模真的很有趣。

15 个非常有用的 Python 基础模块

原文：https://towardsdatascience.com/15-more-surprisingly-useful-python-base-modules-6ff1ee89b018?source=collection_archive---------3-----------------------

忘记依赖性，使用标准库！

(图片由作者提供)

I 简介

本月早些时候，我深入研究了 Python 编程语言基础上的一些非常强大且非常有用的函数。这些标准库模块和 Python 函数非常棒，但幸运的是，当谈到 Python 编程语言所能提供的东西时，它们都只是昙花一现。如果您没有时间阅读我的上一篇文章，在这篇文章中，我概述了一些其他的标准库工具，我认为它们可能比这些工具更有用，您可以在这里查看:

</10-surprisingly-useful-base-python-functions-822d86972a23>

尽管我在上一次迭代中概述了许多精彩的特性，但是 Python 标准库还可以为那些有足够决心成为它的专家的程序员提供更多的特性。Python 的真正优势在于其基础的简单性和开箱即用的能力，特别是操纵数据和使用其他语言和脚本。这当然在它提供的包中有很大反映，这些包通常提供处理外部代码、文本和数据的功能。数据操作只是 Python 编程语言标准库实际能力的一小部分。也就是说，只需要一点点知识，就可以用几个包的例子将标准的 Python 体验提升到一个新的水平。这里有 15 个我最喜欢的，我想大多数 Python 程序员可能想看一看！

笔记本

№1: cmath

复杂类型无疑证明了 Python 在某种程度上的科学和数字意图。这种类型在 Python 中出现已经有一段时间了，它允许虚数和实数作为一个完整的值存储。这一点最常见的是在浮点数上加上虚数，例如:

5.5+8.2 米

其中:

5.5 是真正的浮动。
8.2 是一个假想的浮点数。

然而，除了保存数字之外，如果没有适当的操作来支持，复杂的浮点数本质上是没有用的。这就是 cmath 模块的用武之地。cmath 不仅支持平方根和对数函数等基本运算，还提供了更高级的函数，如相位、极坐标或 x。

对于任何可能与复数进行交互的 Python 用户来说，这个模块几乎肯定是必不可少的。它不仅提供了一个足够的主干，可以处理任何至少部分是虚数的数字，还可以提供更多关于这些数字的极坐标信息。对于我的例子，我选择利用这个模块中的 exp()、log()和 phase()方法。然而，不言而喻的是，这个神奇的工具中有更多的选项值得一试！

为了使用 cmath，我们首先需要导入它。我个人通常会将它别名为 cm，但我必须承认我不确定这是否是一种约定:

import cmath as cm

接下来，我们将创建一个可以用来计算的复数:

z = 5.5 + 8.2j

最后，我们将获取新的复数值，并在新变量上使用 cmath 包中的一些精彩方法！

cm.phase(z)
cm.log(z)
cm.exp(z)

№2:迭代工具

Python 标准库中下一个非常有价值的工具是一个叫做 itertools 的小模块。我怎么推荐使用这个模块都不为过，因为它似乎真的比我想象的要方便得多。itertools 模块可用于非常有效和容易地创建更好的、有时是独特的迭代，如果不使用该模块，将会花费更多的时间。

这个模块基本上是一些业界领先的迭代工具的组合，包含在一个纯粹的 Pythonic 包中。在很多场景中，通过结合使用 Python 的其他特性，这些工具被简单地包含在 Python 中。文档中也提到了一个很好的例子。SML 编程语言提供了一种制表工具——制表()方法，可以使用标准库中已有的 map 和 count 函数在 Python 编程语言中重新创建该方法。

不用说，这个模块肯定是值得拥有的！当使用迭代时，这个模块的真正价值就体现出来了，因为它可以使许多低效或乏味的迭代任务变得轻而易举，并且在内存和计算方面效率更高。这个模块包含了一些很棒的函数，比如 count()、chain()、accumulate()等等！

在大多数情况下，我看到 itertools 别名为 it 和 its，我个人更喜欢 its。

import itertools as its

我假设我们都熟悉 Fizz Buzz 编码测试。使用这个简单的编码测试，我们可以看到利用 itertools 中更高性能的迭代解决方案相对于使用原始 Python 来处理我们的问题的价值。大多数程序员可能会采取类似的方法来解决问题:

for num in range(1, 21):
    if num % 3 == 0 and num % 5 == 0:
        print('FizzBuzz')
    elif num % 3 == 0:
        print('Fizz')
    elif num % 5 == 0:
        print('Buzz')
    else:
        print(num)

哪个当然是正确的！然而，使用 itertools，我们可以大大缩短这个函数的长度，以及计算它所需的时间:

def fizz_buzz(n):
    fizzes = its.cycle([""] * 2 + ["Fizz"])
    buzzes = its.cycle([""] * 4 + ["Buzz"])
    fizzes_buzzes = (fizz + buzz for fizz, buzz in zip(fizzes, buzzes))
    result = (word or n for word, n in zip(fizzes_buzzes, its.count(1)))
    for i in its.islice(result, 100):
        print(i)

№3:平分

与列表中的许多工具不同，等分模块有一个直接的目的。这个模块的目的是将 Python 中的数组或列表一分为二。这对于各种不同的操作都很方便，但是这个包经常被同名的 Scipy 实现扔到一边。如果我不得不猜测为什么会这样，我会说也许 Scipy 实现支持 Numpy 矩阵？

不管其文化接受程度如何，那些只使用普通 Pythonic 列表的人肯定会发现这个模块非常有价值。该模块配有工具，可以正常对分，也可以左右对分。此外，该模块还附带了一些更有趣的功能，比如 insort()，它将插入和排序所提供的值。让我们导入这个模块，看看它是如何处理列表的:

import bisect as bs

现在，我们可以使用此模块制作一个列表并将其一分为二:

ls = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90]
bs.bisect(ls, 9)

第四名:统计

os 模块是一个非常流行的 Python 模块，当然在标准库中。os 模块附带了用于操作文件系统、系统硬件甚至操作系统内核的工具。os 模块也有三个功能:

斯达
fstat
lstat

这些都是用来获取一个文件的状态，或者获取所述文件的描述符。os 模块中的 stat 函数将返回一个 stat_result 类型，这正是我们使用 stat 模块所需要的。因此，使用该模块的第一步是从操作系统模块获得一个 stat。让我们从导入模块开始，并将 stat 类型设置为一个新变量:

import os
st = os.stat("logreg.ipynb")

现在让我们看看这个新类的类型。如果一切按计划进行，st 的类型应该是 stat_result。

每当我们查看 stat 模块的文档时，我们很快就会了解到，这种类型并不是我们实际要放入新函数中的类型。我们可以观察到这一点，因为函数 stat.filemode()接受一个整数，而不是 os.stat_result。我们真正需要的实际上包含在我们刚刚创建的类中，名为 st_mode。我们可以这样称呼它:

st.st_mode

现在让我们导入 stat。

import stat as stt

现在，我们可以将新的 stat 模式从 os.stat_result 类传递到 stat.filemode()函数中:

stt.filemode(st.st_mode)

(图片由作者提供)

№5:记录

脚本任务可能非常困难！如果有许多并发服务和子流程可能在 systemctl 或类似的东西下一起在后台运行，这一点尤其正确。可能会有大量的应用程序，不可避免地，一些应用程序几乎肯定会遇到一些问题。缓解此类问题的一个很好的方法是直接从开发-运营手册中获得的，

伐木。

日志记录是一种简单的方法，可以同时跟踪几个进程，并在遇到某些问题和异常时，进一步了解幕后发生的事情。日志记录为简单的日志记录提供了一组易于使用的函数。这些是[debug()](https://docs.python.org/3/library/logging.html#logging.debug)、[info()](https://docs.python.org/3/library/logging.html#logging.info)、[warning()](https://docs.python.org/3/library/logging.html#logging.warning)、[error()](https://docs.python.org/3/library/logging.html#logging.error)和[critical()](https://docs.python.org/3/library/logging.html#logging.critical)。

不用说，日志是一个非常有用的工具，所有 Python 程序员都想熟悉它。对于某些领域，如开发运营或系统管理来说尤其如此，但这也适用于软件工程和数据科学的奇妙世界。在部署和日常计算机操作的许多情况下，日志记录都会派上用场，尤其是当您想要开发和调试自己的应用程序时。现在让我们用一些 Python 来弄脏我们的手，并开始创建我们自己的日志！我们要做的第一件事当然是导入日志模块:

import logging as lgg

现在，我将使用 basicConfig 函数来创建一个新文件，我们的日志可以放入其中:

lgg.basicConfig(filename='mylog.log', level=lgg.DEBUG)

现在我将在其中记录一些消息！

lgg.debug('This message will be in mylog.log')
lgg.info('So will this :)')

看看我们的文件系统，我们可以打开一个新的日志文件，其中包含我们的文本:

(图片由作者提供)

这个日志实现的一个很酷的特性是，我们可以忽略不想在日志中看到的信息。例如，如果我们不希望看到任何调试消息，可以将级别设置为 20。

№6: html

html 模块主要以包含在其中的名为“解析器”的子模块而闻名给定名称，实际上很容易想象这个模块的确切用途。该模块可用于轻松地逐个标签地解析 HTML。这使得处理你正在阅读的文本中的 HTML 更加容易，甚至可以用 Python API 将 HTML 翻译成基于 C 的框架。

很多时候，程序员可能会遇到他们不想浏览的大型 HTML 页面，或者从请求中接收到的字符串很难用字符串片段来解析。如果需要，您甚至可以使用解析器和一些代码来实际编写 HTML！这个工具有很多用途，但是我决定不把所有的胡萝卜放在一个篮子里，而是演示可以从 html.parser 导入的解析器。

from html.parser import HTMLParser

既然我们的解析器已经导入，我们将创建一个新变量并初始化一个 HTMLParser 类:

parser = HTMLParser()

最后但同样重要的是，我们将使用 HTMLParser 类中包含的 feed()函数，并向其中输入一些 HTML:

parser.feed('<html><head><title>parsedhtml</title></head>'
            '<body><h1>this was parsed</h1></body></html>')

在大多数情况下，这个解析器不太像 HTML 解析器，而更像 HTML 分离器。也就是说，大多数使用这个模块的程序员很可能会在这个模块上构建一个定制的解析器。

№7:网络浏览器

虽然这个模块肯定不是列表中最有用的，但我确实认为它是一个很酷的模块，可能会派上用场。也就是说，webbrowser 模块正是如此；网络浏览器的快捷方式。考虑到这一点，你可以认为它最常用于自动获取某种类型的网页链接。

可能有几个不同的原因可以让你这么做。我能想到的应用大多是在软件工程中，但几乎可以肯定，这个模块有更有用的应用。不考虑它对普通程序员的实际用处，我认为它是一个非常简洁的小模块，所以让我们来试试吧:

首先，我们可以通过 Bash 直接执行来打开我们的链接:

!python3 -m webbrowser -t "towardsdatascience.com"

或者我们当然可以使用 Python 代码导航:

import webbrowser
webbrowser.open_new("lathe.ai")

№8: ftplib

当顶级中央处理器只有四个内核时，文件传输协议(FTP)是我们用来传输文件的方式。不管它的年龄和各自的替代品(有这么多更好的解决方案)，FTP 已经设法在一定程度上坚持了多年。也就是说，在某些情况下，你可能真的不得不使用 FTP。

仅仅因为您拥有对服务器的文件访问权限并不意味着您拥有对服务器的 SSH 访问权限。记住，如果不使用 SCP 或 SSH，很难连接到一个开放的端口并移动文件。幸运的是，当情况像这样结束时，FTP 总是可以介入。

虽然我很想演示 ftplib 包，但我并不喜欢这个协议；却没有很好的方法来处理它。当然，我可能会着手在我的服务器上设置 FTP，然后在我的笔记本中返回并从 Python 连接到它，但是该模块及其文档相对来说比较基础，因此很可能只需查看那里的代码就可以理解代码:

**>>> from** **ftplib** **import** FTP
**>>>** ftp = FTP('ftp.us.debian.org')  *# connect to host, default port*
**>>>** ftp.login()                     *# user anonymous, passwd anonymous@*
'230 Login successful.'
**>>>** ftp.cwd('debian')               *# change into "debian" directory*
**>>>** ftp.retrlines('LIST')           *# list directory contents*
-rw-rw-r--    1 1176     1176         1063 Jun 15 10:18 README
**...**
drwxr-sr-x    5 1176     1176         4096 Dec 19  2000 pool
drwxr-sr-x    4 1176     1176         4096 Nov 17  2008 project
drwxr-xr-x    3 1176     1176         4096 Oct 10  2012 tools
'226 Directory send OK.'
**>>> with** open('README', 'wb') **as** fp:
**>>> **    ftp.retrbinary('RETR README', fp.write)
'226 Transfer complete.'
**>>>** ftp.quit()

https://docs.python.org/3/library/ftplib.html

№9: uuid

通用唯一标识符(UUIDs)在计算领域是一个非常重要的概念。对于现代企业计算来说尤其如此，有时可能每天都要识别和处理成百上千个不同的东西。UUIDs 允许计算机很容易地区分数据到底是什么。UUIDs 在现代计算世界的各种应用程序中广泛使用，例如

web 开发
数据库管理
进程管理
包装开发

还有更多。

uuid 模块的伟大之处在于它非常容易使用。您可以通过简单地使用四个 uuid 1–5()来检索几乎任何内容的标识符，但不包括该模块提供的两个方法。第一个也是最常用的 uuid()方法肯定是 uuid1()，但是，许多人也使用 uuid4()，因为 uuid1()还会用创建该标识符的计算机的详细信息来标记该标识符。为了启动这些函数，我们需要导入它们。

import uuid

现在我们将调用 uuid1()函数:

uuid1()

我们会看到这将返回一个 UUID。接下来我们可以做的是打印出所有不同的 UUID 函数，看看它们的输出是什么样的。为了使用另外两个函数 UUID3()和 UUID4()，我们需要提供一个名称空间标识符。这通常是通过两种不同的协议完成的，要么是域名服务器(DNS ),要么是统一资源定位器(URL ),并且允许基于名称空间创建标识符。这将基于标识符的 SHA-1 散列创建我们的新 UUID。例如，我们可以将名称空间设置为 towardsdatascience.com。对于名称空间参数，我们将提供一个名称空间对象，它打包在 uuid 模块中。至于名字，我们将提供 towardsdatascience.com。从提供的示例中可以看出，uuid 1 和 uuid 3 的中心通常保持一致:

print(uuid.uuid1())
print(uuid.uuid3(uuid.NAMESPACE_DNS, "towardsdatascience.com"))
print(uuid.uuid4())
print(uuid.uuid5(uuid.NAMESPACE_DNS, "towardsdatascience.com"))print(uuid.uuid1())
print(uuid.uuid3(uuid.NAMESPACE_DNS, "towardsdatascience.com"))

(图片由作者提供)

№10:IP 地址

无论何时，当你使用帐户，或者试图使这些帐户安全时，跟踪互联网协议地址或 IP 地址是很有意义的。该协议有两个版本，它是整个互联网上计算机和服务器之间所有通信的基础。任何时候你的电脑与其他地方的电脑连接，你都有可能被你的 IP 地址所识别。这些地址为互联网提供了更多的安全性，因为它使网站和您的互联网服务提供商更容易跟踪什么用户在做什么。

这是好是坏，在数据伦理领域是一个完全不同的话题，但事实是，IP 地址是大多数服务器管理员和程序员通常应该熟悉的工具。在 Python 中，我们有一个标准的库模块，叫做 ipaddress。在很大程度上，该模块通常用于处理 IP 网络和服务器上的本地 IP 配置。使用该模块的流行应用程序的一个很好的例子是 Gunicorn3，这是一个 Pythonic 式的高性能 web 服务器。如果你想了解更多关于 Gunicorn3 的知识，或者想用它部署 Flask，我在一年前(实际上是将近两年前)写了一篇文章，我认为这篇文章很好地利用了它:

在很大程度上，这个包只是用来创建 IP 的类，并把它们从字符串世界带到 Python 世界，在那里它们是自己独特的类型。也就是说，唯一要演示的是如何创建这样一个类:

import ipaddress
ipaddress.IPv4Address('192.168.0.1')

№11:获取文本

Get text 是另一个非常酷的工具，我可以肯定地看到它在标准库中得到了一些应用。Gettext 是一个非常酷的转换到 Python 基础上的实现，我认为这非常棒！到目前为止，在这方面最常用的方法是 gettext()方法。该方法接受一个参数，该参数将是一个字符串，并且将是我们希望翻译的文本。

import gettext as gxt

为了实际使用这个包，我们需要将语言数据加载到其中。这很常见，因为如果没有这种能力，模块很可能会非常庞大。这个过程实际上是漫长的，我计划在以后的文章中讨论它，因为在这里解释它太费时间了。然而，在讨论这个工具可能存在的一个严重问题之前，我可以解释使用 gettext 的基本过程和优点。

Gettext 通过生成一个. pot 文件来使用。的。pot 文件包含单个环境或整个应用程序的翻译信息。然后加载该文件，并在与 gettext()方法一起使用时将加载到设置的区域设置中。这是一种处理翻译的好方法，因为它将编程和翻译完全分开。

gtxt.gettext("Hello world!")

这个工具唯一的重大缺陷可能是它的许可。Gettext 是在 GPL 和其他自由软件许可下发布的。这是有问题的，因为这可能意味着该工具不可用于商业用途。这意味着基本上任何私人使用或工作中的使用都侵犯了与它一起分发的许可证。在软件世界中，许可是一件需要注意的重要事情，因为以错误的方式使用带有错误许可的软件会给你带来很多麻烦。也就是说，许可讨论的一个有趣部分是，gettext 在这种情况下是用 Python 打包的，它是在 PSF 语言下打包的——这是一个比 MIT 许可更自由的许可。这两个许可证可能暗示这可以在专业设置中使用，但是我不是律师，不能真正说这个软件的许可是否会阻止它在现实世界中使用。

№12:泡菜

可能这个列表中最有价值的数据科学标准库模块是 pickle 模块。pickle 模块用于将类型序列化为压缩数据，以后可以在不同的环境中再次加载和使用这些数据。这对于机器学习模块之类的东西非常有用，这些模块通常包含充满字典和数字的类，以确定模型在特定情况下可能需要做什么。

为了使用这个模块，我们需要准备一个我们想要序列化的类。对于这个例子，我决定做一个关于人的课程:

class Person:
    def __init__(self, feet, inches, weight):
        self.height = feet * 12 + inches
        self.bmi = weight / self.height ^ 2
        self.weight = weight

现在我将创造我自己:

emmett = Person(6, 4, 160)

(图片由作者提供)

太奇怪了…

我觉得很奇怪，Python 不考虑操作的顺序。我也觉得^(float 不工作很奇怪。我想我已经被朱利安的数学宠坏了。我们可以用一组括号来修正这个错误:

class Person:
    def __init__(self, feet, inches, weight):
        self.height = feet * 12 + inches
        self.bmi = weight / (self.height ^ 2)
        self.weight = weight

现在让我们创建我们的 emmett 对象并序列化它！

import pickle as pkl
emmett = Person(6, 4, 160)

为了将新类序列化到文件中，我们将使用 pickle.dump()函数。使用此函数的最佳方式是使用 with 语法。with 块将允许我们定义一个新变量作为一个打开的可写文件，然后将文件流插入到我们的函数中，并调用它:

with open("emmett.pkl", "wb") as output:
    pkl.dump(emmett, output)

现在我们将做同样的事情，但是我们将使用 pickle.load()函数进行加载。我们还将通过用 r 替换 w 来将写权限更改为读权限。

with open("emmett.pkl", "rb") as inp:
    emmett2 = pkl.load(inp)

现在，emmett2 与 emmett 类完全相同，可以移动、共享和重用！

№13:回复

正则表达式是一个编程概念，它可能会改变您第一次使用字符串的方式。正则表达式是很酷的小命令，可以放在一个字符串中，以告诉计算机如何处理该字符串。re 包提供了类似于 Perl 编程语言的正则表达式匹配。

也就是说，Python 中的 re 模块用于检测和解析这些正则表达式。这对于可能需要解释来自其他应用程序的大量输入字符串的应用程序非常有用。当用正则表达式编码时，这些字符串可能需要以特定的方式运行或执行特定的任务。大多数程序员可能都熟悉的一个很好的例子是 markdown。Markdown 使用表达式来告诉何时使用某些标题高度、项目符号、图像和其他文本功能，如超链接。

这个包中最常用的函数肯定是 compile()函数。这个函数可以用来将任何字符串转换成正则表达式对象，然后可以在整个包中使用。我不认为有人会觉得有必要给这个取别名:

import re

让我们在一个字符串上尝试 compile()函数:

st = "hello world, it has been a good day. \n hello world, it has been a bad day. \n"re.compile(st)

№14:复制

当处理类型时，总会有关于可变性的讨论。易变性有它的缺点和优点。Python 是一种动态类型的语言，这意味着类型可以频繁地改变。不仅如此，这种语言还具有很多迭代特性，这意味着这种语言通常不太关心数据的保存。正是由于这个原因，为了避免你的类的数据发生灾难性的、不可逆转的变化，一致地创建你的类型的副本将变得极其重要。

幸运的是，在 Python 中确保安全和复制工作相对容易。Python 安装附带了一个标准的库工具，名为 copy。

import copy as cp

复制模块将提供两个功能，copy 和 deepcopy。两者的区别在于 copy 创建对子对象的引用，而 deepcopy 递归地复制这些对象。考虑到这一点，深度复制用其下的类构建的类可能是明智的，但在处理类内部的简单数据类型时只使用 copy 可能更有意义。

emmett2 = cp.copy(emmett)
emmett2 = cp.deepcopy(emmett)

№15:功能工具

函数工具是一个广泛的工具工具箱，通常与 Python 编译器交互，可用于函数，以控制它们的特定行为方式。文档中有一个关于这种用法的很好的例子，我认为它突出了为什么它肯定是一个非常有用的软件包:

import functools as fut
from functools import lru_cache

现在让我们看一个基本的例子，functools 非常有用，非常棒！对于计算机来说，阶乘计算是一个非常困难的计算。通常这些是使用查找表计算的，因为它们的计算实际上很难做到。这是有原因的，因为阶乘本身就是解释递归的好方法。我们可以用 Python 写一个递归阶乘函数，如下所示:

**def** factorial(n):
    **return** n * factorial(n-1) **if** n **else** 1

这个函数唯一的缺点是，为了计算阶乘，它会不断地调用自己。这将破坏每次使用该函数时的性能。然而，也就是说，我们可以通过在内存中存储先前计算的结果来改进后续调用。functools 模块允许我们通过缓存调用来这样做:

[@lru_cache](http://twitter.com/lru_cache)
def factorial(n):
    return n * factorial(n-1) if n else 1

现在每次阶乘调用一个已经缓存的计算时，它只是从内存中加载数字！这将极大地节省我们的性能。

结论

Python 编程语言有超过 200，000 个包，其中许多包都非常成熟和古老。然而，依赖关系最终可能很难处理，通常有办法通过查看标准库来避开环境空间。此外，标准库中有大量的工具，肯定可以完成工作，并为您提供大量关于下一步编程的想法。在未来，希望这些神奇的工具能够派上用场，这里提供的关于这些模块的信息将会派上用场！感谢您的阅读！

15 个必须知道的机器学习算法

原文：https://towardsdatascience.com/15-must-know-machine-learning-algorithms-44faf6bc758e?source=collection_archive---------8-----------------------

机器学习综合指南

solébikes 在 Unsplash 上拍摄的照片

近年来，机器学习经历了巨大的增长。我们比以往任何时候都更清楚机器学习可以实现什么。越来越多的高质量数据和计算的进步进一步加速了机器学习的普及。

有各种各样的机器学习算法，可以分为三个主要类别:

监督学习算法在给定一组观察值的情况下，对特征(独立变量)和标签(目标)之间的关系进行建模。然后，该模型被用于使用这些特征来预测新观察的标签。根据目标变量的特性，可以是分类(离散目标变量)或回归(连续目标变量)任务。
无监督学习算法试图在无标签数据中找到结构。
强化学习基于行动奖励原则工作。一个代理通过迭代计算其行动的回报来学习达到一个目标。

在这篇文章中，我将简要解释监督和非监督类别中的 15 种流行的机器学习算法。

我们将讨论的算法有:

线性回归
逻辑回归
支持向量机
朴素贝叶斯
k-最近邻
决策图表
随机森林
梯度推进决策树
LightGBM
CatBoost
XGBoost
k 均值聚类
分层聚类
DBSCAN 聚类
主成分分析

1.线性回归

线性回归是一种监督学习算法，通过对数据拟合线性方程来模拟连续目标变量和一个或多个独立变量之间的关系。

线性回归是一个好的选择，自变量和目标变量之间需要有线性关系。我们可以使用散点图或残差图来检查线性。

线性回归模型试图将回归线拟合到最能代表关系或相关性的数据点。最常用的技术是普通最小二乘法(OLE ),它通过最小化数据点和回归线之间距离的平方和来找到最佳回归线。

下图显示了一条线性回归线，它试图根据给定的数据点对速度和距离变量之间的关系进行建模。

(图片由作者提供)

2.逻辑回归

逻辑回归是一种受监督的学习算法，最适用于二进制分类任务，如流失预测、垃圾邮件检测和广告点击预测。

逻辑回归的核心部分是逻辑(即 sigmoid)函数。它接受任何实数值，并将其映射到 0 到 1 之间的值。

(图片由作者提供)

逻辑回归模型将线性方程作为 sigmoid 函数的输入，并使用对数概率来执行二元分类任务。

逻辑回归返回概率值。下面是一个典型的逻辑回归曲线。

逻辑回归曲线(图片由作者提供)

我们可以使用概率值或将它们转换成标签(例如 1 和 0)。例如，如果概率大于 50%，则预测为正类(1)。否则，预测为负类(0)。

作为正类和负类之间的阈值的值取决于问题。我们可以调整区分正面类别和负面类别的阈值。如果设置为 70%，只有预测概率大于 70%的观测值才会被归为正类。

3.支持向量机(SVM)

SVM 是一种监督学习算法，主要用于分类任务。

SVM 生成一个决策边界来分隔类别。在创建决策边界之前，在 n 维空间中绘制每个观察值(或行)(n 是特征的数量)。例如，如果我们使用“长度”和“宽度”来对不同的“细胞”进行分类，则观察值被绘制在二维空间中，而决策边界是一条线。

支持向量是最接近决策边界的数据点。以到支持向量的距离最大化的方式绘制决策边界。

决策边界和支持向量(图片由作者提供)

如果决策边界太靠近支持向量，它将对噪声高度敏感，并且不能很好地推广。即使特征上非常小的变化也可能改变预测。

决策边界的错误选择(图片由作者提供)

如果数据点不是线性可分的，SVM 使用核技巧来测量高维空间中数据点的相似性(或接近性)。具有核的 SVM 实际上并没有将数据点转换到更高维度的空间，这是没有效率的。它只度量高维空间中的相似性。

标准 SVM 会尝试将所有数据点分为不同的类，并且不允许任何点被错误分类。这导致过度拟合模型，或者在某些情况下，无法使用标准 SVM 找到决策边界。

一个更好的选择是软边际 SVM，它试图解决一个优化问题，目标如下:

增加决策边界到类别(或支持向量)的距离
最大化训练集中正确分类的点数

该算法允许一些数据点的错误分类，以便确定更鲁棒和更一般化的决策边界。

在上面列出的两个目标之间有一个权衡。这种折衷由 C 参数控制，该参数为每个错误分类的数据点增加一个惩罚。如果 c 很小，则对误分类点的惩罚也很低，因此以更大数量的误分类为代价选择了具有大余量的决策边界。如果 c 很大，SVM 试图最小化由于高惩罚导致的错误分类的例子的数量，这导致了具有较小裕度的决策边界。对于所有错误分类的例子，惩罚是不同的。它与到决策边界的距离成正比。

4.朴素贝叶斯

朴素贝叶斯是一种用于分类任务的监督学习算法。

朴素贝叶斯假设特征是相互独立的，特征之间没有相关性。然而，现实生活中并非如此。这种特征不相关的天真假设是这种算法被称为“天真”的原因。

顾名思义，这个算法的核心元素是贝叶斯定理。

(图片由作者提供)

p(A|B):给定事件 B 已经发生的概率

p(B|A):给定事件 A 已经发生，事件 B 发生的概率

p(A):事件 A 的概率

p(B):事件 B 的概率

朴素贝叶斯计算给定一组特征值的类的概率(即 p(yi | x1，x2，…，xn))。在特征独立的假设下，我们可以使用这个概率和贝叶斯定理来实现:

(图片由作者提供)

该算法将复杂的条件概率转换为简单得多的条件概率的乘积。

所有特征都是独立的假设使得朴素贝叶斯算法比复杂算法更快。在某些情况下，速度优先于更高的精度。另一方面，相同的假设使得朴素贝叶斯算法不如复杂算法准确。速度是有代价的！

5.k-最近邻

k-最近邻(kNN)是一种受监督的学习算法，可用于解决分类和回归任务。主要思想是一个数据点的值或类是由其周围的数据点决定的。

kNN 分类器通过多数表决原则确定数据点的类别。例如，如果 k 设置为 5，则检查 5 个最近点的类。根据多数类进行预测。类似地，kNN 回归取 5 个最近点的平均值。

kNN 的最大挑战是确定 k 的最佳值。非常小的 k 值往往会导致过度拟合，因为模型对于训练集来说过于具体，并且不能很好地概括。另一方面，k 值非常大的模型在训练集和测试集上都不是很好的预测器。他们往往吃不饱。

kNN 简单且易于解释。它不做任何假设，因此可以在非线性任务中实现。随着数据点数量的增加，kNN 变得非常慢，因为模型需要存储所有的数据点。因此，它也不是内存高效的。kNN 的另一个缺点是它对异常值很敏感。

6.决策图表

决策树是一种监督学习算法。它通过反复提问来划分数据点(即行)。

(图片由作者提供)

分割不是随机确定的。选择导致最高信息增益的那些。增加节点纯度的分割更能提供信息。

节点的纯度与该节点中不同类的分布成反比。要问的问题是以增加纯度或减少杂质的方式选择的。

算法不断提问，直到所有节点都是纯的。纯节点仅包含一个特定类别的观测值。然而，这将是一个过于具体的模型，不能很好地概括。如果不对深度设置限制，决策树算法很容易溢出。树的深度由 max_depth 参数控制。

决策树算法通常不需要归一化或缩放特征。它也适用于处理混合的要素数据类型(连续、分类、二进制)。

7.随机森林

随机森林是一种监督学习算法。随机森林是结合了一种叫做装袋技术的决策树的集合。

在 bagging 中，决策树被用作并行估计器。并行组合多个决策树大大降低了过度拟合的风险，并产生更加精确的模型。

随机森林的成功高度依赖于使用不相关的决策树。如果我们使用相同或非常相似的树，总体结果将不会比单个决策树的结果有太大的不同。随机森林通过自举和特征随机性来实现不相关的决策树。

Bootsrapping 是从带有替换的训练数据中随机选择样本。它们被称为 bootstrap 样本。

通过为随机森林中的每个决策树随机选择特征来实现特征随机性。可以使用 max_features 参数控制随机森林中每棵树使用的要素数量。

随机森林算法的工作原理(图片作者提供)

随机森林是许多不同问题的高度精确的模型，不需要标准化或缩放。

8.梯度推进决策树(GBDT)

GBDT 是一种监督学习算法，它是通过将决策树与一种称为 boosting 的技术相结合而构建的。因此，GBDT 也是一种系综方法。

Boosting 是指将一个学习算法串联起来，从许多顺序连接的弱学习器中实现一个强学习器。

每棵树都试图最小化前一棵树的错误。boosting 中的树是弱学习器，但是连续添加许多树，并且每个树集中于前一个树的错误，使得 boosting 成为高效且准确的模型。与装袋不同，增压不涉及自举取样。每次添加新树时，它都适合初始数据集的修改版本。

GBDT 算法的工作原理(图片作者提供)

由于树是按顺序添加的，boosting 算法学习起来很慢。在统计学习中，学习速度慢的模型表现更好。

学习率和 n 估计量是 GBDT 的两个关键超参数。学习率，表示为α，简单地表示模型学习的速度。每个新的树修改整个模型。修改的幅度由学习速率控制。N_estimator 是模型中使用的树的数量。如果学习率低，我们需要更多的树来训练模型。然而，我们需要非常小心地选择树的数量。使用太多的树会产生过度适应的高风险。

与随机森林相比，GBDT 在分类和回归任务上都非常高效，并且提供了更准确的预测。它可以处理混合类型的特征，并且不需要预处理。GBDT 要求仔细调整超参数，以防止模型过度拟合。

GBDT 算法非常强大，已经实现了许多升级版本，如 XGBOOST、LightGBM、CatBoost。

9.LightGBM

由微软研究人员创建的 LightGBM 是梯度推进决策树的一种实现。

决策树是通过基于特征值拆分观察值(即数据实例)来构建的。决策树就是这样“学习”的。该算法寻找导致最高信息增益的最佳分割。

寻找最佳分割是决策树学习过程中最耗时的部分。随着数据量的增加，这成为一个瓶颈。LightGBM 旨在解决这个效率问题，尤其是对于大型数据集。

为了解决这个问题，LightGBM 使用了两种技术:

梯度单侧采样
EFB(独家功能捆绑)

我不会详细介绍，但我写了一篇更详细的文章来解释 LightGBM 是如何工作的。

10.CatBoost

Yandex 的研究人员创建的 LightGBM 是梯度增强决策树的另一种实现。

由于我们已经介绍了 GBDT，我将只提及 CatBoost 的特征。

CatBoost 实现了一个特定版本的增强，称为有序增强。它为处理过拟合提供了一种更好的方法。CatBoost 在处理分类特征方面也有很好的性能。另一个与众不同的特点是使用对称树。

官方文档和本教程为理解和使用 CatBoost 算法提供了全面的指导。

11.XGBoost

XGBoost 是 GBDT 的另一个实现。它如此强大，以至于统治了一些主要的 kaggle 比赛。XGboost 的目标，正如它在文档中所说，“是将机器的计算极限推向极致，以提供一个可伸缩的、可移植的和精确的库”。

XGBoost、LightGBM 和 CatBoost 的一个共同特征是它们需要仔细调整超参数。模型的性能很大程度上取决于选择最佳的超参数值。

例如，下面是 XGBoost 模型解决多类分类任务的典型超参数列表。

params_xgb = {
'boosting_type': 'dart',
'objective':'multi:softmax',
'num_class':9,
'max_depth':7,
'min_child_weight':20,
'gamma':1,
'subsample':0.8,
'colsample_bytree':0.7,
'tree_method':'hist',
'eval_metric':'mlogloss',
'eta':0.04,
'alpha': 1,
'verbose': 2
}

Max_depth:一棵树的最大深度。
Min_child_weight:一个孩子所需的实例权重的最小总和。将它保持在较高的位置可以防止孩子过于具体，从而有助于避免过度适应。
Gamma:在树的叶节点上进行进一步划分所需的最小损失减少。同样，游戏越大，模型越不可能过度拟合。
子样本:在生长树之前随机选择的行的比率。子样也可以用来避免过度拟合。
Eta:学习率。保持较高的值会使模型快速学习，但同时也会增加过度拟合的机会。
α:L1 正则化项。

XGBoost 的整个超参数列表可以在这里找到。

12.k 均值聚类

K-means 聚类是一种无监督学习算法。它旨在将数据划分为 k 个簇，使得同一簇中的数据点相似，而不同簇中的数据点相距较远。因此，它是一种基于分区的聚类技术。两点的相似性由它们之间的距离决定。

值得注意的是，这不同于我们为训练集中的数据点附加标签的分类。在聚类分析中，数据点没有标签。该算法被期望找到数据内的结构，以将数据点分组到聚类中。

K-means 聚类试图最小化一个类内的距离，最大化不同类之间的距离。

k-means 聚类的最大挑战是确定聚类数目的最优值。该算法无法确定聚类的数量，因此我们需要指定它。

初始数据点(图片由作者提供)

数据点被分组为簇(图片由作者提供)

K-Means 聚类相对较快且易于解释。它还能够以一种智能的方式选择初始质心(聚类中心)的位置，从而加快收敛速度。

13.分层聚类

分层聚类是一种无监督的学习算法。它通过迭代分组或分离数据点来创建聚类树。有两种类型的分层聚类:

凝聚聚类
分裂聚类

两种类型的层次聚类(图片由作者提供)

凝聚法是最常用的方法。每个数据点首先被假定为一个单独的聚类。然后迭代地组合相似的聚类。

层次聚类的优点之一是我们不必预先指定聚类的数量。但是，将所有数据点合并到一个聚类中是不明智的。我们应该在某个时候停止组合集群。

分层聚类总是生成相同的聚类。k-均值聚类可能会产生不同的聚类，这取决于质心(聚类的中心)是如何开始的。然而，与 k-means 相比，它是一种较慢的算法。运行分层聚类需要很长时间，尤其是对于大型数据集。

14.DBSCAN 聚类

基于分区和层次聚类技术对于正常形状的聚类非常有效。然而，当涉及到任意形状的聚类或检测异常值时，基于密度的技术更有效。

DBSCAN 代表den sity-basssclustering ofa应用与 n oise。它能够找到任意形状的聚类和带有噪声的聚类(即异常值)。

任意形状的集群(图片由作者提供)

DBSCAN 背后的主要思想是，如果一个点靠近来自该簇的许多点，则该点属于该簇。

DBSCAN 有两个关键参数:

eps :指定邻域的距离。如果两点之间的距离小于或等于 eps，则认为这两点是相邻的。
minPts: 定义一个聚类的最小数据点数。

基于这两个参数，点被分类为核心点、边界点或异常点:

**核心点:**如果一个点在其半径为 eps 的周围区域内至少有 minPts 个数的点(包括该点本身)，则该点为核心点。
**边界点:**如果一个点可以从一个核心点到达，并且其周围区域内的点数少于 minPts，那么这个点就是边界点。
**离群点:**如果一个点不是核心点并且从任何核心点都不可达，那么这个点就是离群点。

DBSCAN 不需要预先指定簇的数量。它对异常值是鲁棒的，并且能够检测异常值。

在某些情况下，确定适当的邻域距离(eps)并不容易，这需要领域知识。

15.主成分分析

PCA 是一种降维算法，它基本上从现有的特征中获得新的特征，同时尽可能多地保留信息。PCA 是一种非监督学习算法，但它也广泛用作监督学习算法的预处理步骤。

PCA 通过查找数据集中要素之间的关系来获取新要素。

PCA 是一种线性降维算法。也有非线性方法可用。

PCA 的目的是通过使用较少的特征(或列)尽可能多地解释原始数据集中的差异。新的派生特征称为主成分。主成分的顺序根据它们所解释的原始数据集的方差分数来确定。

主成分是原始数据集特征的线性组合。

PCA 的优点是使用比原始数据集少得多的特征保留了原始数据集的大量差异。主成分是根据它们解释的方差大小排序的。

结论

我们已经介绍了数据科学领域中最常用的机器学习算法。我试图为每个模型提供一个体面的介绍。为了掌握每种算法，你需要更深入一点，也需要练习。

感谢您的阅读。如果您有任何反馈，请告诉我。

15 个必须知道的 Python 字符串方法

原文：https://towardsdatascience.com/15-must-know-python-string-methods-64a4f554941b?source=collection_archive---------3-----------------------

这并不总是关于数字。

照片由你好我是尼克在 Unsplash

Python 是一门伟大的语言。它相对容易学习，语法直观。丰富的库选择也有助于 Python 的流行和成功。

然而，这不仅仅是关于第三方库。Base Python 还提供了许多方法和函数来加速和简化数据科学中的典型任务。

在本文中，我们将介绍 Python 中的 15 个内置字符串方法。你可能已经对其中一些很熟悉了，但我们也会看到一些罕见的。

这些方法是不言自明的，所以我将更多地关注示例来演示如何使用它们，而不是解释它们做什么。

1.大写

它使第一个字母大写。

txt = "python is awesome!"txt.capitalize()
'Python is awesome!'

2.上面的

它使所有的字母大写。

txt = "Python is awesome!"txt.upper()
'PYTHON IS AWESOME!'

3.降低

它让所有的字母都变成小写。

txt = "PYTHON IS AWESOME!"txt.lower()
'python is awesome!'

4.Isupper

它检查是否所有的字母都是大写的。

txt = "PYTHON IS AWESOME!"txt.isupper()
True

5.Islower

它检查是否所有的字母都是小写的

txt = "PYTHON IS AWESOME!"txt.islower()
False

下面的 3 个方法是相似的，所以我将做包括所有这些方法的例子。

6.Isnumeric

它检查是否所有的字符都是数字。

7.伊萨法

它检查是否所有的字符都在字母表中。

8.伊萨勒姆

它检查所有字符是否都是字母数字(即字母或数字)。

# Example 1
txt = "Python"print(txt.isnumeric())
Falseprint(txt.isalpha())
Trueprint(txt.isalnum())
True

# Example 2
txt = "2021"print(txt.isnumeric())
Trueprint(txt.isalpha())
Falseprint(txt.isalnum())
True

# Example 3
txt = "Python2021"print(txt.isnumeric())
Falseprint(txt.isalpha())
Falseprint(txt.isalnum())
True

# Example 4
txt = "Python-2021"print(txt.isnumeric())
Falseprint(txt.isalpha())
Falseprint(txt.isalnum())
False

9.数数

它计算给定字符在字符串中出现的次数。

txt = "Data science"txt.count("e")
2

10.发现

它返回给定字符在字符串中第一次出现的索引。

txt = "Data science"txt.find("a")
1

我们还可以找到一个字符的第二次或其他出现。

txt.find("a", 2)
3

如果我们传递一个字符序列，find 方法返回序列开始的索引。

txt.find("sci")
5

11.开始于

它检查字符串是否以给定的字符开始。我们可以在列表理解中使用这种方法作为过滤器。

mylist = ["John", "Jane", "Emily", "Jack", "Ashley"]j_list = [name for name in mylist if name.startswith("J")]j_list
['John', 'Jane', 'Jack']

12.末端

它检查字符串是否以给定的字符结尾。

txt = "Python"txt.endswith("n")
True

endswith 和 startswith 方法都区分大小写。

txt = "Python"txt.startswith("p")
Falsetxt.startswith("P")
True

13.替换

它用给定的字符集替换字符串或字符串的一部分。

txt = "Python is awesome!"txt = txt.replace("Python", "Data science")txt
'Data science is awesome!'

14.裂开

它在出现指定字符的位置拆分字符串，并返回包含拆分后每个部分的列表。

txt = 'Data science is awesome!'txt.split()
['Data', 'science', 'is', 'awesome!']

默认情况下，它在空格处分割，但我们可以根据任何字符或字符集来分割。

15.划分

它将一个字符串分成 3 部分，并返回包含这些部分的元组。

txt = "Python is awesome!"
txt.partition("is")
('Python ', 'is', ' awesome!')txt = "Python is awesome and it is easy to learn."
txt.partition("and")
('Python is awesome ', 'and', ' it is easy to learn.')

partition 方法正好返回 3 个部分。如果用于分区的字符多次出现，则考虑第一个字符。

txt = "Python and data science and machine learning"
txt.partition("and")
('Python ', 'and', ' data science and machine learning')

我们也可以通过限制拆分的数量来对拆分方法进行类似的操作。但是，也有一些不同之处。

split 方法返回一个列表
返回的列表不包括用于拆分的字符

txt = "Python and data science and machine learning"
txt.split("and", 1)
['Python ', ' data science and machine learning']

奖金

感谢 Matheus Ferreira 提醒我最伟大的字符串方法之一:join。我也使用 join 方法，但是我忘记在这里添加了。它理应作为额外奖励进入榜单。

join 方法将集合中的字符串组合成一个字符串。

mylist = ["Jane", "John", "Matt", "James"]"-".join(mylist)'Jane-John-Matt-James'

让我们也用一个元组来做一个例子。

mytuple = ("Data science", "Machine learning")" and ".join(mytuple)'Data science and Machine learning'

结论

在执行数据科学时，我们会大量处理文本数据。此外，文本数据比普通数字需要更多的预处理。幸运的是，Python 的内置字符串方法能够高效、流畅地执行这些任务。

最后但同样重要的是，如果你还不是的中级会员，并打算成为其中一员，我恳请你使用以下链接。我将从你的会员费中收取一部分，不增加你的额外费用。

https://sonery.medium.com/membership

感谢您的阅读。如果您有任何反馈，请告诉我。

每个数据科学家都必须知道的 15 个数字功能

原文：https://towardsdatascience.com/15-numpy-functionalities-that-every-data-scientist-must-know-f6d69072df68?source=collection_archive---------20-----------------------

讨论开发人员必须学习的十五个最基本的数字函数

JESHOOTS.COM在 Unsplash 上拍照

机器学习的很大一部分是处理数学运算。由于数学是大多数数据科学项目中不可或缺的一部分，对于初学数据的科学家来说，更深入地研究以下主题变得至关重要。Python 是数据科学的最佳编程语言之一，它提供了一个非常有用的工具，那就是 numpy 库。

数值 Python (NumPy)是大多数机器学习和数据科学项目的精华部分。这些 numpy 阵列在计算机视觉的应用中找到了它们的效用，用于处理图像并根据阵列来计算它们。他们还发现，在数组的向量化过程中，自然语言处理任务得到了大量使用，从而使它们与训练 ML 或 DL 模型兼容。

借助 NumPy 数组，您可以相对轻松地完成大多数数学计算。它是大多数与线性代数和计算其他类似操作相关的任务的最佳库。但是，为了简化与 Python 库的集成和区别，您还必须查看另一个库。从下面提供的链接中查看如何使用 sympy 来简化积分和微分。

这篇文章是一个初学者指南，介绍了 15 个必须知道的 numpy 功能，这些功能对各种操作都非常有益。我们将尝试涵盖大部分重要的内容，但还有很多内容需要探索。因此，让我们从作为数据科学爱好者需要学习的所有基本功能开始。

1.创建数组:

x = [1, 2, 3, 4, 5]
y = np.array(x)
y

输出:数组([1，2，3，4，5])

每个计划掌握 numpy 的数据科学家必须知道的第一个基本步骤是如何创建一个。当您可以创建一个数组时，您可以操纵它们来执行许多操作。要创建数组，可以用多种方法执行以下计算。一种方法是使用 Python 中的 list 数据结构存储数值，然后用 numpy 以数组的形式解释它们。

也可以通过使用 np.array()或 np.asarray()函数声明 numpy 数组，后跟方括号来创建一维或多维数组，从而定义数组。一旦创建了这些数组，就可以对它们执行各种操作。在接下来的几节中，让我们看看通常对数组执行什么操作。

2.阵列的形状:

a = np.array([[1, 2, 3], [2, 3, 4]])
print(a.shape)

输出:(2，3)

数组的一个基本概念是它们存在的各种形状。numpy 数组的形状决定了可以对其执行的不同类型的计算和操作。一旦创建了特定的数组，就可以解释 numpy 数组的形状。的。数组的 shape 属性将返回其特定形状的元组。

在 numpy 数组中必须理解的重要主题是 N 维(或 nd 数组)的概念。这些数组具有多个维度(不是行或列维度),包含相同大小和类型的项。n 维数组最常用于执行各种数学运算。

3.数组索引:

a = np.array([[1, 2, 3], [2, 3, 4]])
print("The middle elements are:", a[0][1], "and", a[1][1])

输出:中间的元素是:2 和 3

类似于列表的索引，我们也有一个索引数组的方法来执行和操作 numpy 数组中特定位置的特定元素。使用数组索引，我们可以访问任何知道其位置的所需元素。

在上面的示例中，我们试图从 shape (2，3)的特定数组中接收中间元素的值。数组中的第一个元素从初始索引零开始。特定的行号和列号在方括号中指定，这将允许用户计算数组的索引并接收元素的特定位置。

4.数组切片:

a = np.array([[1, 2, 3], [2, 3, 4]])
print(a[1:2])

输出:[[2 3 4]]

我们可以在类似于列表的 numpy 数组上执行的另一个很酷的操作是切片的概念。在这种技术中，我们试图从特定的 numpy 数组中只获取所需的元素。对于上面显示的示例代码块，我们试图通过相应地切掉第一行来只获取第二行的所有元素。

我建议您自己探索更多这种对 numpy 数组进行切片的操作。尝试许多切片操作，观察不同的结果。还建议您从下面的链接中查阅我以前的一篇关于掌握 Python 中的列表的文章，因为它将帮助您更好地理解索引和切片。

5.数组乘法:

由克里斯·贾维斯在 Unsplash 上拍摄的照片

a = np.array([1, 2, 3])
b = np.array([[2],[1], [0]])print(np.matmul(a, b))

输出:[4]

使用 numpy 数组，可以非常简单地计算矩阵的乘法。在上面的例子中，我们注意到形状为 1 X 3 和 3 X 1 的特定数组相乘得到 1 X 1 矩阵的输出结果。使用 numpy 数组可以进行多次这样的计算。

6.点积:

a = np.array([1, 2, 3])
b = np.array([[2],[1], [0]])print(np.dot(a, b))

输出:[4]

numpy 数组可能实现的另一个重要计算是寻找两个变量的点积。点积本质上是两个特定数组的所有倍数之和。点积的概念在机器学习中无处不在。一个例子是权重计算或计算成本函数的用例。

根据下面的参考 , matmul在两个重要方面不同于dot。

不允许标量乘法。
矩阵堆叠一起广播，就好像矩阵是元素一样。

7.数组中元素的总和:

a = np.array([1, 2, 3])print(np.sum(a))

产出:6

计算 numpy 数组中众多元素的总和是一项非常有用的任务，可以借助本库提供的 sum 函数来完成。如果您要在列表的帮助下执行类似的操作，您可能会使用 for 循环来遍历列表中的所有元素，并相应地添加它们。这种方法会增加整体的复杂性，因此，最好使用 numpy 数组来进行这种数学计算。

作为奖励，我想提到另一种方法，它在列表的帮助下执行这种计算，同时保持时间和空间的复杂性。这个操作是在 Python 中的匿名函数的帮助下执行的。您可以利用 functools 库来导入 reduce 函数。导入后，您可以利用这个高级函数在一行中计算整个计算。

from functools import reducea = [1, 2, 3]
sum = reduce(lambda x, y: x+y, a)
print(sum)

如果您想了解更多关于使用多个代码和示例理解高级函数的主题，请随意查看下面的文章。它更详细地介绍了具体的概念。

8.平均:

a = np.array([1, 2, 3])print(np.mean(a))

输出:2.0

Numpy 还允许开发人员相对容易地计算特定数组的平均值。通过将所有元素相加并将总和除以指定数组中存在的元素总数来对平均值进行置换。平均值的计算在若干机器学习算法中是重要的，例如用于计算均方误差的线性回归。

9.幂运算:

x = 5
print(np.exp(x))

输出:14860 . 486868686866

机器学习中执行的一个重要操作是取幂操作。欧拉数“e”的值约为 2.718，在基数对数计算中具有重要意义。因此，该函数有时用于执行数学运算。另一个要考虑的类似函数是 numpy 中可用的 pi 操作。

一个非常流行的使用求幂运算的场景是定义一个 sigmoid 函数。上图是以下内容的代表。要了解更多关于这种激活功能的信息，我推荐从下面的链接中查看我以前的一篇关于一种叫做校正线性单元的流行激活的文章。

10.展平数组:

a = np.array([[1, 2, 3], [2, 3, 4]])
a = np.ndarray.flatten(a)
print(a.shape)

输出:(6，)

每当我们处理多维数据时，我们可能需要为特定的任务展平它们。numpy 中的 flatten 函数将帮助您将 n 维数组缩减为单个实体。数据科学家必须探索的其他类似函数是 numpy 中可用的扩展维度或压缩维度函数。

11.阿兰格:

a = np.arange(5, 15, 2)
a

输出:数组([ 5，7，9，11，13])

arange 函数用于创建通常以指定间隔均匀分布的数组。您可以分别描述起点、终点和步数，以生成所需形状的任何 numpy 数组。要使用 numpy.arange()函数创建所需形状的多维数组，请确保使用 reshape 函数。

12.对数组排序:

a = np.array([3, 1, 2, 5, 4])
np.sort(a)

输出:数组([1，2，3，4，5])

当我们有一个混排值的数组，并且我们想把它们全部按升序排列，也就是说，按数字的升序排列时，sort 函数就相当有用了。虽然也可以对列表执行类似的操作，但值得注意的是，这种操作在 numpy 数组中也是可能的。

在执行各种操作时，您可能会遇到向特定的 numpy 数组追加更多元素的情况，但是一旦您获得了一个值列表，您可能会希望将它们全部排序在一起，以便相应地标识值。在这种用例中，sort()函数非常方便。

13.随机排列:

np.random.rand(2, 2)

输出:数组([[0.21886868，0.09692608]，

，[0.60732111，0.85815271]])

numpy 库还允许用户随机生成和创建带有随机值的数组。这个功能类似于 Python 中的随机库。但是，numpy 版本的 random.rand()函数，可以生成 n 维数组来执行大量的计算和运算。

在机器学习和深度学习中，随机数字运算通常用于的一个关键操作是，当我们想要用随机值初始化一堆权重或偏差时。通常，最好的方法是用一个随机值而不是零来初始化某些值。为了通过比例抽样的例子理解随机性的概念，建议您阅读下面的文章。

14.最小值、最大值和绝对值:

a = np.array([1, 2, -3, 4, 5])
print(np.min(a))
print(np.max(a))
print(np.abs(a))

输出:-3

5
[1 2 3 4 5]

看看我们可以用 numpy 数组执行的其他一些基本操作，找出特定 numpy 数组的最小值、最大值和绝对值。np.min()和 np.max()函数是不言自明的，因为这些操作分别用于计算给定 numpy 数组中的最小值和最大值。

其他两个函数返回一个值，或者是一个最小值或者是一个最大值，而 absolute 函数将返回一个数组。但是，返回的所有基值都不考虑负号。我建议用户尝试的其他类似功能是对天花板、地板和其他类似操作的操作。

15.三角函数:

print(np.sin(np.pi/3.))
print(np.cos(np.pi/3.))

产量:0.8660254037844386

0.50000000001

除了使用 numpy 数组完成的所有特殊任务之外，您还可以使用这个库执行三角运算。在上面的例子中，我们对正弦和余弦进行了 60 度的简单三角运算，以获得它们各自的结果。随意探索其他类似的三角函数。

结论:

达维德·扎维亚在 Unsplash 拍摄的照片

没有数学，你什么也做不了。你周围的一切都是数学。你周围的一切都是数字。 —夏琨塔拉·戴维

Numpy 是 Python 中可用于各种任务的最好的库之一。虽然机器在文本或视觉信息方面不是最好的，但当这些信息在 numpy 的帮助下被转换成数学阵列时，许多关键任务的计算就成为可能。除了提高兼容性之外，完成某些任务也变得更加容易。因此，numpy 是数据科学家必须努力掌握的最好的库之一。

在本文中，我们了解了每个数据科学家都必须了解的十五个最基本的 numpy 功能。虽然我们讨论的一些函数是可以在 numpy 数组上执行的许多活动，如整形、索引和切片，但其他函数是我们可以在 numpy 数组上执行的各种计算。其中包括 sum()、mean()、arange()和其他类似的运算。

使用这些 numpy 数组，您可以尝试更多的东西。确保探索和深入挖掘以下主题。如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。

看看我的其他一些文章，你可能会喜欢读！

</17-must-know-code-blocks-for-every-data-scientist-c39a607a844d> </6-best-projects-for-image-processing-with-useful-resources-f860f3dfe977> </7-best-free-tools-for-data-science-and-machine-learning-3e630125f87e> [## 数据科学和机器学习的 7 个最佳免费工具

towardsdatascience.com](/7-best-free-tools-for-data-science-and-machine-learning-3e630125f87e) </6-best-programming-practices-f2605c5b469c>

谢谢你们坚持到最后。我希望你们都喜欢这篇文章。祝大家有美好的一天！

我在数据科学候选人中寻找的 15 样东西

原文：https://towardsdatascience.com/15-things-i-look-for-in-data-science-candidates-e72d3d671b3?source=collection_archive---------4-----------------------

给任何寻找或招聘数据科学工作的人的建议

宏向量创建的办公向量—www.freepik.com

数据科学一如既往地受欢迎，但矛盾的是，它似乎比以往任何时候都更加支离破碎，定义也更加模糊。对于新人来说，想知道如何进入这个领域可能是相当困难的，也许更困难的是，经理们想知道如何招聘职位，除非你确切地知道你在寻找什么。

在这篇文章中，我总结了我对数据科学候选人的看法。免责声明:这些是我在生物技术和制药公司工作时的想法，在这些公司，数据科学是支持功能的*，而不是业务的核心部分；也就是说，不是那种专门从事销售预测人工智能架构的职位*，而是你必须端到端地工作，在多个业务领域创造价值的职位。**

1.激情与好奇

当然，激情和好奇心是任何从事技术工作的人都需要的品质。数据科学是一头巨兽，我认为它是这个特定领域中更普遍的先决条件。在许多其他技术领域，你可以专注于一套技能，并利用这些技能连续多年推动商业价值——也许需要每隔 X 年学习一种新的编程语言或工具。然而，数据科学本质上是一门每天都在发展的科学学科。

热情的候选人不断研究新的数据科学发展并与团队分享，这具有巨大的价值。

此外，候选人需要一定程度的热情和坚韧，才能继续希望在数据科学领域工作，而不是一直在沮丧中跳槽；调试为什么一个算法不工作可能比调试为什么一个软件或基础设施不工作更复杂和令人沮丧。你需要成为一个特殊的疯子，才能多次经历这些挫折。🤷‍♂正如我之前所说的:

如果选择站在一个普通的资深数据科学家和一个眼中充满激情的候选人之间，在其他条件相同的情况下，选择后者。

如果你对数据科学没有热情，就不要进入它；不值得。来自 xkcd.com 的漫画

2.心智能力

数据科学作为一种职业并不适合所有人。我们应该停止假装它是。最近，Alberto Romero 就这个话题写了一篇有趣的帖子，描述了许多人的谬论；如果你付出足够的努力，你可以成为一名数据科学家。这不是真的。这是一项艰巨的工作:

你需要理解数学和算法，你需要做编码和软件开发，你需要理解商业问题，和你需要有良好的讲故事和人际交往能力。不是每个人都能做好所有这些事情，甚至做得更好。

我不是说你需要 130+的智商才能成为数据科学家。我也不想吓唬任何人不要转向数据科学。相反，如果你现在处于另一个学术水平的位置，你可能会在数据科学领域做得很好。但是如果你处在智商钟形曲线的低端，努力理解新概念和新过程，这确实是一场艰苦的战斗；不断学习新事物和挑战现状是数据科学工作的基本内容。注意，我在这里不是在谈论使用低代码/无代码工具的公民数据科学家。

你不必是天才，但一定程度的智力是必需的。来自xkcd.com的漫画

3.转化为 ML 问题的能力

擅长工程机器学习(ML)算法是一回事。善于理解商业问题是另一回事。但是合并这两者并找出如何用 ML 解决商业问题是完全不同的事情。

你需要能够将现实世界的问题转化为你能够解决的机器学习问题。

最近 Brian Kent 写了一篇很棒的帖子更详细地描述了数据科学的这个方面。本质上，当你作为一名数据科学家工作时(至少在我做过的职位上)，你将很少得到“这是你的数据集，适合这个目标的回归模型”类型的任务更常见的是，您会面临如下业务问题:

“我们希望利用一些新的人工智能技术来改善我们的现金流，”
"我们想用毫升把这种化学品的产量提高 10% . "
"我们想提高这个或那个过程/机器的效率."

将这些现实世界的目标转化为可解决的 ML 问题是一项被极度低估的技能——你需要对相关的业务流程和可用的数据有一个透彻的理解，你需要一个坚实的基础，知道 ML 实际上能做什么，最后，你需要一个良好的直觉，知道如何应用不同的技术来有效地解决手头的业务目标。

这种技能很少，但是你可以练习，例如，通过熟悉大量的 ML 应用程序，并花时间思考这类问题。

什么数据？什么型号？弄清楚要解决什么并不容易。来自 xkcd.com的漫画

4.诚实和谦逊

想象一下:企业想要使用 AI/ML 来优化一些流程。他们很兴奋，你也很兴奋，每个人都期待看到结果。你做了一个模型，最初，它看起来很棒，每个人都举起了手。你随后意识到你在评估模型的方式上犯了一个错误，这实际上是可怕的——数据中根本没有信号*。*

如果你犯了错误，不管后果如何，你都需要成为完全负责并承认错误的人

会犯错误。我们都会犯错误。但是没有人会因为被掩盖的错误而受益，或者更糟糕的是，归咎于他人。在展示结果时，始终保持一定程度的谦逊，可以避免上述情况；如果它们是尚未经过同行验证的初步结果，那么在展示它们时要清楚地说明这一点。不要夸大其词。此外，一个优秀的候选人永远是自己最糟糕的批评家:

用你得出结论的时间来证明你自己的结论是错误的。这会建立信心。

诚实是数据科学的基石。漫画作者xkcd.com

5.自动化和优化

每个人都讨厌重复的任务。有些人非常讨厌它，以至于他们想尽一切办法让它自动化。我们一直在谈论诸如 autoML 和 GitHub copilot 之类的时髦东西，到自动化代码环境的设置和一般的一切代码，甚至自动化每日时间注册，等等。对我来说，自动化和优化是伟大的开发人员/数据科学家的一些标志性思维模式。

自动化一切。当有意义的时候。漫画作者xkcd.com

6.实用主义与价值追求

数据科学是一门科学学科。然而，当你被聘为数据科学家时，这份工作通常是关于应用数据科学工具来创造商业价值。很少是关于做研究，提出新算法，开拓新领域等等。有时候是，但很少。我们通常被雇佣来创造商业价值。

我们工作的目标是创造商业价值。

在从事工业数据科学工作时，你必须对这个总体目标持务实态度。我在之前的一篇文章中写了几个要避免的陷阱，这是我在这个行业中所学到的经验；您可以在此阅读更多信息:

*</20-lessons-learned-going-from-junior-data-scientist-to-chief-data-scientist-6fe09ff89d78>

总而言之，我认为务实的方法包括:

始终以客户为中心——如果业务不在船上，扼杀项目，它将永远不会创造价值。
创造和选择正确的想法——拒绝仅仅因为上级认为这是个好主意就去解决问题/想法。如果技术上不可行，你需要继续前进。
避免过度设计——如果一个更简单的方法可以用一半的时间解决问题，那就这样做。
专注于执行——不要陷入太多的陈述、讨论、如果这样会怎样、如果那样会怎样。开始做点什么。

我认为在 Medium 上有大量的读物可以帮助你成为一名更加务实的数据科学家。我最近很喜欢的这篇文章，作者是丹尼斯·艾勒斯，描述了如何在工作中变得更有效率和影响力，还有的这篇文章，作者是阿奇·德·伯克关于从学术界到工业界的转变。

务实，创造商业价值。不要专注于不创造价值的事情。漫画作者xkcd.com

7.个性与团队契合度

很明显，候选人的个性及其与团队其他成员的契合度非常重要。所有职位的所有候选人都是如此。这也是为什么许多公司都有人力资源部门，并在雇佣前做性格测试的部分原因。心理学家经常研究“五大”人格特质，我发现这对于评估你刚认识的人来说特别有见地。就这些性格特征而言，我认为有些是非常必要的，例如，一定程度的责任心(高效/有条理)、不友善(说出你的观点，不要做个傻瓜)外向(与企业交谈，举行演示等)。)、以及开放(研究新技术，干掉你的心肝宝贝)。然而，总的来说，我不认为数据科学家有一个“理想”的性格特征，所以这主要是一个避免有害性格的问题。

冷静点，友好点。漫画作者xkcd.com

8.编码经验

编码是数据科学的重要组成部分。通常，您编写的代码必须与同事共享才能投入生产，以便您和未来的同事可以在未来许多年内维护它。因此，一般软件开发和良好实践的经验是数据科学家最重要的素质之一。

如果另一个开发人员不得不花两倍的时间来审查和修复你写的代码，然后才能投入生产，那么你对团队是一种损害，而不是一种资产

请注意，我并不太关心不同的编码范例，也不关心您是喜欢笔记本还是纯脚本等等。这些是单个团队可以设定的标准。我说的是我如何看到初级开发人员编写完全可以理解并且可以在几分钟内审查的代码，我也看到有 30 多年经验的高级开发人员将 2 周的工作浓缩成 4 行难以理解的 R 代码。

如果你有一个公开的 Github 帐户，证明你可以用好的文档编写可理解的代码，这将是一个巨大的加分。

写别人能理解的代码。来自 xkcd.com 的漫画

9.调试技巧

我们经常开玩笑说，工作的一部分就是把所有的时间花在 StackOverflow 寻找代码片段上。虽然你可以用这种方式找到许多解决难题的优秀方案，但是调试的技巧远不止这些。

不要成为唯一的调试技能是堆栈溢出的人

在纯代码方面，您需要阅读文档来了解事情实际上是如何工作的，有时您甚至需要浏览您正在使用的任何开源库的源代码。在数据科学方面，事情会变得更加棘手；你可能需要通读论文，以了解事情应该如何工作，并从那里找出为什么它不工作——这可能真的是一种残酷的经历，尤其是因为人们如何实现算法的所有数字细节并不总是记录在代码或论文中。

我会发现更有趣的是看候选人如何调试一段破损的代码，而不是他们通过查看在线资源解决给定问题的能力。

调试是一种技能，也是一门艺术。漫画来自xkcd.com

10.适应性

适应性大概已经被务实和个性这两点涵盖了。即便如此，适应性是如此重要，以至于我想把它作为一个单独的点。这个领域发展很快，我们必须能够杀死我们的宝贝。在一个项目上花了几百个小时，结果却没有创造商业价值？杀了它。花了几百个小时用 Tensorflow，现在整个团队都想用 PyTorch？放下它，学习 PyTorch。花了几千个小时在 Python 上，但现在对你正在做的事情来说还不够？放下它，学习一门足够的新语言。不要纠结于你做某事花了多少时间；那只会让你慢下来。

你停止适应的那一天，就是你开始输掉数据科学游戏的那一天

保持开放的心态，保持适应性。xkcd.com漫画

11.全堆叠势

我已经在前面的中描述了我认为典型的数据科学建议是非常糟糕的建议，这种建议是为了避免成为“万事通，无所不能”。相反，一个人应该努力成为“万事通，几个大师”

不要回避“数据科学独角兽”的想法，而是努力成为其中一员。

也就是说，我永远不会寻找数据科学独角兽；人才库太匮乏，定义太不清晰。然而，我要做的是筛选那些抱怨“不可能成为数据科学独角兽”的人。在我的书中，这种在行业中相当普遍的说法是有毒的，表明了对弄脏自己的手和完成事情的厌恶。

自然，你不需要成为一名成熟的前端/后端开发人员和云/数据工程师。但我发现，对涉足其他领域持开放态度的人在交付成果方面要有效得多。

即使你可能不会成为大师，也要对扩展你的视野保持开放。来自 xkcd.com 的漫画

12.背景

当涉足数据科学时，拥有生物信息学、量子物理学或其他科学领域的背景显然是有利的；这意味着你习惯于阅读研究论文，以前做过统计分析，可能会一点编程，等等。然而，接受良好的教育绝不是必要条件。只不过是几年的结构化学习。但是很自然的，你以前做过的事情和取得的成就在申请新工作时会被考虑。

在其他条件都相同的情况下，我会雇用一个从一无所有到接受过任何高级教育的人。

你的背景自然会影响你目前的技能。xkcd.com漫画

13.讲故事

这一点之前已经说过无数次了，所以我不会在这上面花太多时间，尽管它很重要:数据科学家需要讲一个好故事。是什么意思？学会创造吸引人的视觉效果，做漂亮的演示，进行引人入胜的谈话，写博客等。

你做得越多，并试图比上一次做得更好，你就会做得更好

学会讲有影响力的故事。来自xkcd.com的漫画

14.合作

我的一个弱点是我不太擅长合作——我想这是我在得到一份“真正的”工作之前已经一个人呆了 10 多年的结果。然而，这个事实让我更加欣赏那些善于合作的人；用数据科学创造商业价值是一个团队纪律，因此你必须善于与包括以下内容的一切合作；结对编程、适当的文档、明智的 git 提交、冲刺计划、回顾等等。这种体验绝对是优势！如果你是协作的新手，找一个有趣的开源项目并参与进来。

你需要能够在团队中工作！数据科学不能做一个人的军队。漫画作者xkcd.com

15.数据科学经验

我清单上的最后一点是实际的数据科学经验。自然，如果候选人接触过该领域内的各种学科，这是有利的；与计算机视觉、自然语言处理、预测、经典的监督/非监督技术、通用深度学习等相关。

根据我的经验，你很少会多次得到“同一个”任务。因此，拥有尽可能广泛的知识库是一个优势——有一天，你可能在做销售预测，另一天，你可能在预测分子的化学性质或优化生产过程。如果我是为了销售预测而招聘，如果候选人以前从未做过销售预测，如果这个人有做其他类型的机器学习的长期历史，我不会太担心。学习如何解决新问题只是工作中的一天。

获得广泛经验的门槛相对较低；积极参与一些不同领域的 Kaggle 竞赛，然后你应该开始有一个基本的了解。此外，通过这样做，你将建立一个你能做什么的投资组合。我不是说这个容易做*，*只是说入门容易。在这个过程中，每当你遇到一个新的概念时，一定要确保你能完全理解它。

不要仅仅将算法作为黑盒来应用，而是让你明白它们实际上在做什么。

你在游戏中的时间越长，你获得的经验越多；我们都在不断学习。来自 xkcd.com的漫画

结束语

最后我写了一篇相当长的帖子。如果你已经通读了全部，我感谢你🍾我意识到许多提出的观点将适用于许多职业，特别是当涉及到类似的工作时，如数据工程、云工程等。以上是我从数据科学角度的思考。请注意，我从来不会期望一个初级开发人员完全符合所有提到的要点——相反，我会寻找一个能够成长为所有提到的要点的人。最后，我希望获得关于其他人在数据科学候选人中寻找什么的反馈，所以请随时发表评论或通过任何其他渠道联系。*

在数据科学领域取得更大成功的 15 个技巧

原文：https://towardsdatascience.com/15-tips-to-be-more-successful-in-data-science-c58aa1eb4cae?source=collection_archive---------7-----------------------

意见

作为数据科学家，每个数据科学爱好者都必须努力提高的 15 个因素

吉尔·Á·阿尔瓦雷斯在 Unsplash 上的照片

“成功的人做不成功的人不愿做的事。不要希望它更容易；希望你更好。”

— 吉米·罗恩

数据科学已经成为过去十年中最受欢迎和最具突破性的学科之一。这一新兴趋势将在未来几年持续下去。数据科学正处于发展的巅峰，随着技术的快速发展和进步，数据科学将会在当今时代占据主导地位。

除了被视为向许多数据科学爱好者提供工作的主要前景之一，无论是数据科学还是它的任何其他子领域，数据科学也被称为 21 世纪最性感的工作机会之一。

为了用简单的术语为观众定义数据科学，我们可以将数据科学视为一个包含各种子领域的广阔领域。这些概念的知识，当结合在一起时，可以有效地用于开发一些美好的和神话般的项目，为人类的整体利益。

数据科学包括使用可用的数据元素或数据集，并创建独特的发展模型。当这些模型完成时，我们可以有效地使用它们来解决它被编程来实现的特定任务。根据模型的质量和开发人员的技能，这些项目往往以极高的效率和准确性做出预测。

然而，来自维基百科的更正式的定义方法可以定义如下:

数据科学是一个跨学科领域，它使用科学的方法、流程、算法和系统来从许多结构化和非结构化数据中提取知识和见解。数据科学与数据挖掘、机器学习和大数据相关。数据科学是将统计学、数据分析及其相关方法统一起来，以便用数据来理解和分析实际现象的一个概念。

基本的正式定义和描述已经完成，现在是时候让我们关注 15 个技巧了，这些技巧将使该主题的每个爱好者更成功地成为未来的数据科学家。每个有抱负的数据科学学生都必须遵循本文中提到的步骤，以取得一流的成果，并提高自己，成为未来更好的数据科学家。在我们更深入地阅读本文之前，您需要确保您确实喜欢并享受数据科学。

当每个人都忙着跳上数据科学的宣传列车时，弄清楚数据科学是否是你喜欢学习的东西是极其重要的。如果您对数据科学的众多特性、功能和其他方面不感兴趣或着迷，那么您最好考虑掌握一个不同的领域。数据科学需要坚持不懈的努力和奉献精神，才能坚持不懈地开发出造福当代人和社会的令人惊叹的项目。

</10-wrong-reasons-to-become-a-data-scientist-319531bb874e>

在本文中，我们将尝试涵盖每个数据科学爱好者必须关注并发展其技能以实现最佳结果和成果的技术和心理方面。提到的 15 个要点中的大部分将使浏览者能够衡量一个方面，这是掌握数据科学的基本要求。对数据科学有了基本的了解，并对本文的目标有了现实的期望，让我们深入了解这些概念，并逐一理解这些技巧。

1.做好心理准备

“不做准备，就是在为失败做准备。” ——本杰明·富兰克林

数据科学或任何人工智能话题有时可能会很费力。特定问题的复杂性可能不会吸引你的大脑。你花在分析编程、数学、理论概念等几个方面的时间。，会让你的大脑紧张，产生一种糊里糊涂的感觉。

当你计划直觉地研究一个有趣的话题时，有几次你可能会对同一个话题失去兴趣。出现这些情况的一个主要原因可能是因为缺乏集中和专注，或者仅仅是因为你的思想还没有做好充分的心理准备来面对你计划实现的复杂程度。

因此，理清你的思路，专注于你计划完成的目标是非常重要的。作为一名数据科学爱好者，您的主要目标必须是生成高质量的模型和结果。确保提前计划好你的所有任务，以完美的方式接近你的目标。

在实施项目的过程中，我强烈建议制定一个待办事项清单，不断提醒你需要完成的各种任务，以便准确地完成你想要的结果。下面提供的链接是一个项目构想，它将帮助您实现一个提醒应用程序，该应用程序将不断提醒您执行任务。

基本上，努力保持动力，高度关注数据科学的积极方面。当你开始准备学习新的目标时，要更加乐观。无论您期望的最终结果是什么，都要做好接受失败的心理准备，并以绝对的信心和绝对的意志继续您掌握数据科学的旅程！

2.专门研究重要的课题

数据科学最重要的一个方面是研究该领域中众多重要的主题。试着花一些专门的时间来解码一个你可能喜欢研究、阅读或学习的特别有趣的话题。

例如，让我们考虑一个机器学习主题的例子，如逻辑回归。逻辑回归的概念在机器学习领域具有重要意义。因此，更好地掌握一个基本主题是很重要的。为了以最好的方式掌握这个概念，我强烈建议你深入研究逻辑回归的每个方面的复杂细节。

首先，尝试计算和分析大量可能的数学理论、假设和推导。了解更多关于几何，概率和其他方法的定义和推导。一旦你完成了所有必要的数学方面的分析，是时候继续进行编码和编程了。

下一步是尝试从零开始实现整个逻辑回归函数，而不使用像 scikit-learn 这样的外部库。在我以前的一篇文章中，可以看到一个不使用任何外部库(如 numpy)来实现数学问题(如矩阵乘法)的例子。下面提供了链接。

另一个重要的提示是，当你试图研究和学习某个特定的主题时，试着抓住你力所能及的所有可能的资源。要特别注意深入研究这些资源，以获得尽可能多的知识。

3.发展自信解决问题的任务

布鲁斯·马斯在 Unsplash 上的照片

在一个类似于数据科学的领域获得自信的最好方法是解决大量简单和复杂的问题。你的目标必须是付出 100%的努力来成功完成它们。无论你有多少学习数据科学的动机，在特定任务的计算中反复失败和失败的尝试都会导致动力下降，最终缺乏信心。

为了避免这种情况，一次考虑一个任务并在这段时间内解决特定的任务变得至关重要。总是从简单的编程任务或简单的数据科学项目开始，你有信心可以解决。

如果你在一个特定的问题上反复失败，不要浪费你的宝贵时间去做一些不必要的重复。这可能是一个更好的想法，向前看，在相同的时间框架内，不需要任何外部指导，你就可以潜在地解决其他问题。

此外，如果你能够对一个特定的主题进行广泛的学习、分析和研究，你最终会在解决问题时更加自信。这样做的原因是因为你对概念有一个直观的理解，以及对解决手头的任务有一个清晰和深入的理解。

4.花时间分析复杂的问题陈述

照片由 NeONBRAND 在 Unsplash 上拍摄

每个数据科学爱好者和追求者应该关注的第一个主要步骤是他们花在分析给定问题陈述或项目想法上的时间。利用你的时间去看问题的方向的最终目的是得到一个想法，并为解决这个问题建立一个框架。

在开始你的问题陈述或项目想法之前，通常最好的事情是确保你已经在你的头脑或一本书(一张纸也可以)或你的电脑上的目录中建立了一个完美的计划。规划是从事数据科学项目的重要阶段。因此，提前计划好所有的步骤来有效地开始你的工作。

我建议您花时间分析相应的问题，通常必须按照这些特定的步骤顺序如下:

试着获得对你计划处理的问题陈述的视觉感知和直觉理解。花几分钟到几小时的时间，直到你确信自己对如何完成任务有了基本的了解。
在开始着手一个项目或一个复杂的问题之前，看看一些解决方案或研究论文以及它们提供的有用信息。Kaggle 解决方案和笔记本是获取更多相关知识的绝佳来源。
在收集了大量的信息资源后，制定一个完美的计划和时间表来决定你处理问题陈述的计划。做一份完整的待办事项清单，它会指引你走上正确的道路，直到你的目标成功达成。

这些基本步骤将帮助你更好地分析你的项目。对于在 12 个月内掌握数据科学的学习计划，我强烈建议从下面提供的链接中查看下面的文章。是初学者入门的简明指南。

</12-steps-for-beginner-to-pro-in-data-science-in-12-months-c6f6ba01f96e>

5.致力于提高特定的数学和编程技能

编程和数学技能在掌握数据科学方面发挥着重要作用。虽然数学对于从直觉上和理论上理解与数据科学相关的各种概念是必不可少的，但编程对于这些主题各自的实际实现是至关重要的。

为了更深入地理解这两个领域(即编程和数学)的必要性，让我们分别看一下这两个方面并对它们进行分析。首先，我将查看与数学相关的提示，供所有级别的数据科学爱好者沉迷和学习。

数学是数据科学的重要组成部分。为了完美地利用掌握数据科学和机器学习所需的技能，数学是一个突出的优势。你需要主要关注数学的子领域，如线性代数、概率和统计以及降维技术。

线性代数对于理解数据科学的许多概念是必不可少的，尤其是像 numpy 这样重要的 python 库模块。为了更直观地理解 numpy，您还需要理解一些理论概念，比如点积、可以通过 numpy 数组计算的矩阵相关运算等等。

概率和统计对于数据科学也是至关重要的，因为这些领域的理论实现几乎被用于数据科学的每个方面。其中包括像朴素贝叶斯这样的机器学习算法，其中使用了条件概率的概念，或者在深度学习主题中，如生成式对抗网络(GANs)。

像主成分分析(PCA)和 t-分布随机邻居嵌入(TSNE)这样的降维技术也是有用的数学概念。它们用于将复杂的维度从大的视图框架减少到较小的维度范围。例如，这些技术可以用来将 MNIST 从 784 维转换到 100 维。

编程是数据科学最好的部分，它将为您的项目注入活力。因此，专注于编码将永远是你必须掌握的数据科学的一个组成部分。为了提高编程水平，作为初学者，您对数据科学领域的主要关注点应该仍然是 Python，其次是 SQL。

你可以在对数据科学这门学科建立了更简洁的理解之后，再去学习其他编程语言，慢慢完善你的简历。SQL 在数据科学中的重要性以及为什么应该给予它高度的优先权是因为它允许您存储大型数据库和数据信息集，这对于数据科学项目是至关重要的。

为了获得掌握数据科学 Python 的能力，我强烈推荐阅读下面的文章，其中包括从头开始掌握数据科学 Python 的十个步骤。这是一个循序渐进的指导过程，下面提供了链接。

</10-steps-to-master-python-for-data-science-f54199bb328d>

6.尝试多种可视化技术

作者图片

数据可视化在数据科学项目建设中发挥着重要作用。通过查看大量图像，我们可以确定我们所拥有的数据或数据集的一些基本特征和特性。

探索性数据分析是数据科学的一个重要方面，在处理任何类型的任务时都应该考虑。当你将数据可视化时，你获得了直观的理解，你的大脑可以感知到他们工作标准的各种概念。您还可以获得关于如何处理这些数据集的一些想法和反馈。

可视化的主要优势是，它们让您能够为您的数据科学项目探索最佳的直观想法。除了为开发中的项目提供基本的背景和工作空间之外，它们对于项目的长期集成和改进也很有用。

这些形象化对于你的理论工作的其他观众理解你的精确想法和为你解决特定任务的方法确定一个清晰的概念是有用的。这有助于你轻松地向他人解释你对当时正在从事的特定项目的观点。

任何数据科学项目的可视化都绝对可以改变游戏规则。我将确保在我的下一篇文章中更详细地讨论这个主题，因为数据可视化是一个庞大的主题，不能在这篇文章中讨论。请继续关注我即将发表的文章，在这篇文章中，我将讨论八种最佳可视化技术，以及如何在您的数据科学项目中利用它们。

7.奉献和坚持

处理数据并成功完成数据科学项目并不总是那么容易。在许多情况下，您可能会遇到复杂的任务，您将努力找出精确的模式或解决方案。

此外，对于数据科学爱好者来说，知道一个特定的概念却不能准确找到答案有时会变得非常沮丧。尽管你对题目有所了解，但有时你无法解决问题，这种情况发生在我们当中最优秀的人身上。

在这些令人沮丧的时期，似乎最好的选择是放弃数据科学，继续生活中更好的事情。然而，这里是奉献和坚持的地方。虽然数据科学可能令人沮丧，某些任务可能看起来很难处理和解决，但这并不是世界末日。

数据科学中最令人满意的时刻是当你能够用你的纯技能和努力解决这些复杂的问题的时候。当你能保持高昂的情绪并完成目标时，它还会给你肾上腺素激增和自信心的提升。

成功的数据科学家最重要的特征之一是他们能够坚持不懈地努力工作，直到达到目标。虽然很容易失去希望，但他们会继续努力，达到最优解。虽然，这个过程可能要花一些时间。

数据科学需要一些耐心和时间来完成特定的任务。特别是在深度学习领域，当你在构建一个特定的模型架构时，有太多不同的参数需要你考虑。

为您的特定任务定义具有许多层的模型体系结构，以及选择适当的激活函数和优化器，需要花费一些时间。老实说，要获得最好的结果和最优的解决方案，需要大量的尝试和方法。

因此，重要的是保持你的镇定，保持专注，直到你的目标达成。我强烈推荐通过下面的链接查看下面这篇关于成功数据科学家的五大品质的文章。

8.需要时寻求帮助

Icons8 团队在 Unsplash 上的照片

虽然我强调在数据科学项目上花费时间并继续工作，直到您获得最佳解决方案，但这并不表明您总能获得预期的结果。你猜怎么着？—那完全没问题。

在研究数据科学时，你并不意味着是一个完美主义者，老实说，没有人在这方面是完美的。作为数据科学家，进化是必修课。在某些时候，每个人都可能陷入困境，需要帮助以及如何处理问题陈述或任何其他疑问的指导。

当这样的时刻到来时，不要犹豫向更有经验的有志之士、爱好者、业余爱好者和专业人士寻求帮助。数据科学社区和 Python 社区充满了令人敬畏和惊奇的人，他们总是愿意提供帮助。

除了像 Stack Overflow 和 GitHub 这样非常有用并为数据科学家或数据科学爱好者遇到的大多数问题提供一些最佳解决方案的网站之外，像 discord chats 和 slack chats 这样的服务器。

互联网上有大量免费内容可供探索和检查关于数据科学和机器学习的大量细节和功能。查看我以前关于这个主题的一篇文章，了解更多关于一些潜在资源的信息，您可以从中利用信息并获得更多知识。

</10-best-free-websites-to-learn-more-about-data-science-and-machine-learning-f2c6d7387b8d>

你也可以根据你的舒适程度来选择一些免费或付费的课程。如果你对从事数据科学有百分之百的信心，并且你觉得你需要一些外部帮助或资源，确保你在这个主题上做了明显的研究。完成这些步骤后，您可以继续选择您认为对您的长期需求和要求有益的最佳选择。

无论哪种方式，只要你能从朋友、专家或老师那里获得帮助，确保你能获得同等的知识，这些知识是你在获得帮助时至少能完成特定的任务、问题或项目所需要的。以小组或两人一组的方式工作也是一个好主意，因为你们可以互相分享和传递有用的信息，每个人都可以从中受益匪浅。

9.阅读研究论文

威廉·艾文在 Unsplash 上的照片

阅读大量的研究论文！

在数据科学领域，随着不断进步和不断发展，有才华的人和数据科学家提出了创新的作品，并将它们作为研究论文发表。这些研究论文必须仔细查阅，并相应地练习。如果你是一个成功的数据科学家，我强烈建议你查看每周发布的研究论文。

虽然查阅和阅读研究论文应该是获得进一步知识的第一步，但这远远不够。如果你看到一篇关于建模体系结构的研究论文，并且对一个特定的结构是如何构建的有一个完整的解释，你应该自己探索这些概念。

如果您在研究论文中遇到的特定项目或工作是可行的，并且与您的设备兼容，那么开始探索架构构建并开始自己构建它总是一个好主意。如果你能够实现这些结构和模型，这将提高你的整体信心，并帮助你更有效地学习和掌握研究论文中涉及的主题。

除了获得研究论文中发表的特定主题的深入知识外，它还允许读者和从业者探索新技术，并与所有现代新兴趋势保持同步。在数据科学中，变化是永恒的。如果您能够适应数据科学领域的这些不断变化，您就可以完成几乎任何您试图执行的复杂任务或复杂项目。

10.休息一下

不要让你的头脑紧张，也不要让你的身体疲惫！

数据科学有时会很艰难，压力很大。你可能在一个问题上花了几个小时，按照前面提到的所有步骤，尽你所能努力工作，但仍然没有达到你希望达到的预期结果。在处理项目想法或数据科学中的任何一般问题时，很容易陷入困境，无论您遇到的特定问题有多简单或多困难。

对于每个数据科学家或数据科学爱好者来说，定期休息是一个好主意。总的来说，生活中要记住的一个重要方面是不要努力工作，而是要聪明地工作。虽然努力工作会在适当的时候得到回报，但前面的说法对数据科学来说比其他任何东西都更适用。这一评论的理由是因为数据科学是一个庞大的主题，在这个领域中有太多的主题需要学习。

然而，人们必须注意到，学习这个领域的每一个方面并不是一个强制性的要求。通过关注数据科学的基本主题和实现项目目标所需的特定概念就足够了。学习更多或对获得各种概念的进一步知识感兴趣没有坏处，但不要浪费时间在探索问题时陷入不必要的问题中。

我强烈推荐您阅读我以前的一篇文章，这篇文章略微深入地介绍了您必须关注的主题，以便尽快掌握数据科学。您可以通过下面提供的链接访问下面的文章。

有时候，当你在数据科学中处理一个特定的问题、任务或项目时，你可以多次短暂休息，除非你没有偏离你的主要目标。如果你在解决问题的过程中多次失败，那么暂停一项特定的任务也是完全可以的。

即使经过多次尝试，在获得一些额外的外部帮助后，如果你无法解决特定的任务，那么就专注于一些娱乐活动或爱好。不要因为失败的尝试而压力太大或伤透了脑筋。你已经发现了许多解决不了问题的方法，也通过不成功的尝试学到了很多。因此，保持乐观，当你的身体和大脑认为有必要的时候休息一下。

11.保持更新

修改和重温你的作品！

数据科学最棒的地方在于它每天都面临着学科的不断发展。数据科学每天都有新的发现。目前在数据科学领域流行的一种技术在未来几天、几周或几个月内可能不会那么有效。方法的进步和发展日新月异。

技术快速发展的一个例子可以通过生成对抗网络(GANs)中最精彩的神经网络技术之一的曲线急剧增长来理解。从 Ian Goodfellow 和他的同事在 2014 年设计的初始框架开始，这些网络已经走过了漫长的道路，并在过去几年中不断发展。从创建和复制简单的设计，他们现在可以创建完全更新的图形结构。这些技术非常出色，在数据科学和深度学习领域掀起了一场新的革命。

随着数据科学的不断进步，每个爱好者都必须不断学习更多知识，跟上最新趋势。如果不跟上新趋势，数据科学家就很难开发出客户或用户想要的最佳质量的产品。如前所述，研究论文是跟上技术和数据科学最新发展趋势的好方法。

除了研究论文之外，阅读关于数据科学发展和其他新兴技术的文章和新闻也是开始更新知识的绝佳方式。敏锐地研究这些进步将有助于你在数据科学发展的潮流和趋势中保持完整。因此，继续练习和阅读，让自己保持更新，以保持相关性，并成为数据科学爱好者的主导地位。

12.理解你的代码的目的

拉多万·纳基夫·雷汉在 Unsplash 上的照片

在从事数据科学项目或任何其他编程项目时，开发人员了解他们代码的用途是非常重要的。如果没有代码背后推理的基本知识，您就不可能理解概念，更重要的是，操作您最近遇到的代码或代码块。在不了解代码块重要性的情况下盲目编码可能会对您的整个数据科学之旅不利。

我们生活在一个互联网能够为我们提供任何我们正在寻找的解决方案的世界和地方。虽然信息和数据的可用性自然对我们所有人都有好处，并且需要加以利用，但对于数据科学爱好者来说，深入了解他们遇到的代码块背后的基础知识和推理是至关重要的。特定的编程项目需要对代码进行小的修改，以完美地完成特定的任务。

花一些时间了解你正在学习的库模块的必要性，并自己分析这些概念和代码块。例如，scikit-learn 库有如此多的功能和操作。确保查看每个单独的组件，并尝试理解这些代码块的用途。此外，了解每个单独参数的更多信息是一个好主意，因为它们对您的开发项目可能是必要的。

13.尝试各种架构、模型、优化器等。

如果您完成了特定数据科学项目的模型结构的构建，就没有时间放松了！有了这些模型，您可以实现更多的目标。既然你已经解决了如何解决特定任务或项目的问题，那么这是你开始探索构建模型的众多选项的最佳时机。

说起来，在深度学习方面，我们有三种主要架构的可用性，即顺序、功能 API 和模型子类(或定制模型)结构。一旦你完成了你的整个建筑结构，如果你打算参加像 Kaggle 这样的比赛，并希望产生最佳质量的模型，建议你尝试这些建筑结构，以达到最佳效果。

无论您是在构建机器学习模型还是深度学习模型，在构建代码块时开始探索众多可用的选项总是一个好主意。例如，像 VGG-16 体系结构这样的特定迁移学习模型可能比像 Inception 体系结构这样的其他迁移学习模型表现得更好。对于更好的任务，使用 LSTMs 可能比 CNN 更好。对数据科学家来说，分析这些因素极其重要。

最后一点是用于解决特定问题的激活函数和优化器。虽然 ReLU 通常被认为是最好的激活函数，Adam 是执行大多数任务的首选优化器，但探索其他激活函数和优化器，看看哪一个为特定任务产生最好的结果，总是一个好主意。下面是一篇在五分钟左右解释 ReLU 激活功能的文章。如果你想了解更多关于这个话题的信息，请查看。

14.只是探索和享受乐趣

Artem Kniaz 在 Unsplash 上拍摄的照片

在一天结束时，学习数据科学和从事众多项目的主要目的是为了获得乐趣。在探索这些概念、主题和项目时，确保你喜欢你正在努力完成的工作。当你对数据科学的众多惊人元素着迷时，你喜欢这个学科的可能性会更高。因此，完成你的任务的结果和成功率也会增加。

动机是成为一名成功的数据科学家的主要因素。随着数据科学领域的挑战和困难越来越多，您需要保持动力和信心来解决这些问题，并找到这些问题的持续解决方案。只有当你对各自的工作领域真正充满热情和兴趣时，动力的驱动力才会保持不变，在这种情况下，就是数据科学。

动机和兴趣是两个因素，只有当你每天都从探索众多概念和学习新事物中获得乐趣时，它们才会留在一个主题中。虽然陷入困境和遇到困难是很常见的，但只要你玩得开心，你就会继续表达自己，并更加努力地推动自己，直到实现所有各自的目标和主要目的。所以，尽情享受数据科学，随意尝试任何能给你带来满足感和幸福感的项目、算法或模型架构。

15.坚持练习！

照片由斯堪的纳维亚反弹在 Unsplash 上拍摄

实践是取得成功的一个重要方面。特别是作为一名数据科学家或数据科学爱好者，你的主要目标必须是获得尽可能好的结果，同时保持努力和聪明。定期练习可以让开发人员习惯不同的数据科学模式，并帮助他们成长为更独特、更完美的数据科学家。

我认为对于数据科学开发人员来说，不断回顾和修改他们的概念以及数据科学领域的众多主题是非常重要的。虽然跟上数据科学主题的发展同样重要，但数据科学家跟上实践的步伐也同样重要。当需求认为有必要的时候，你不想忘记或不记得一个重要的主题。

数学概念和数据科学的其他主题可以每月或每周查找一次，但我强烈建议将编码和编程实践融入到您的日常生活中。请查看下面的文章，其中我涵盖了每个数据科学家必须考虑的五个原因，包括在日常生活中编码的各个方面，以实现最佳结果并变得更加成功。

</5-reasons-why-you-should-code-daily-as-a-data-scientist-fa7fc6dc92c4>

在练习期间，你不需要像人们通常建议的那样非常努力。只要聪明地练习，继续尽可能有效地完成你的其他任务。你不需要从头开始一遍又一遍地重写和重新分析每一个概念或主题。快速浏览一下你想再次回顾的主题就足够了。最后，我想说，坚持练习，尽你最大的努力来结束我的演讲。你会实现你想要的一切！

结论:

由 Unsplash 上的 krakenimages 拍摄的照片

“有两种人会告诉你，你在这个世界上无法有所作为:一种是害怕尝试的人，另一种是害怕你会成功的人。”

— 雷·戈福斯

数据科学是一门奇妙的学科。如果您对学习数据科学的众多方面非常感兴趣，并希望继续探索这一领域的美妙之处，请尽可能享受其中的乐趣。如果一个概念让你着迷，那么欣赏这个特殊主题的壮观性质，并享受学习它的乐趣。随着您在数据科学领域的不断进步，您一定会取得尽可能好的结果，最终，您将成为一名成功的数据科学家。

在本文中，我们详细讨论了十五个技巧，这些技巧将使每个数据科学爱好者在开发新技能和实现心理和理论上的赢家心态方面更加成功。继续努力培养你的习惯和技能。本文中讨论的所有要点的主要目标是能够提供一个坚实的基础，并且在尝试实现您的数据科学梦想时不会引起混乱。

我相信这些提示将能够帮助大多数偶然发现这篇文章的观众。如果你觉得这篇文章有用，请告诉我，如果你认为我可能跳过或忘记了任何其他要点，也请随意评论。每一个人都可以克服生活中的障碍，为自己的目标和成功之路指明方向。

如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。

看看我的其他一些文章，你可能会喜欢读！

</5-unique-use-cases-of-ai-that-might-surprise-you-22478aaaabaf> </10-best-free-websites-to-learn-programming-939ec029009b> </5-reasons-why-you-should-develop-a-game-with-python-and-ai-9f5f276e7637>

谢谢你们坚持到最后。我希望你们喜欢阅读这篇文章。我希望你们都有美好的一天！

16 种被低估的熊猫系列方法以及何时使用它们

原文：https://towardsdatascience.com/16-underrated-pandas-series-methods-and-when-to-use-them-c696e17fbaa4?source=collection_archive---------22-----------------------

Hasnans、pct_change、is_monotonic、repeat 以及许多其他

来自 Pixabay

在本文中，我们将探索一些鲜为人知但非常有用的 pandas 方法来操作系列对象。其中一些方法仅与系列相关，而其他方法则与系列和数据框架都相关，然而，当与两种结构类型一起使用时，它们具有特定的功能。

1.`is_unique`

顾名思义，该方法检查一个系列的所有值是否都是唯一的:

import pandas as pd
print(pd.Series([1, 2, 3, 4]).is_unique)
print(pd.Series([1, 2, 3, 1]).is_unique)**Output:**
True
False

2 & 3.`is_monotonic`和`is_monotonic_decreasing`

使用这两种方法，我们可以检查一个系列的值是否按升序/降序排列:

print(pd.Series([1, 2, 3, 8]).is_monotonic)
print(pd.Series([1, 2, 3, 1]).is_monotonic)
print(pd.Series([9, 8, 4, 0]).is_monotonic_decreasing)**Output:** True
False
True

这两种方法也适用于具有字符串值的序列。在这种情况下，Python 使用字典顺序，逐字符比较两个后续字符串。这不仅仅是字母排序，实际上，上面的数字数据的例子是这种排序的一个特例。正如 Python 文档所说，

字符串的词典排序使用 Unicode 码位号来排序单个字符。

实际上，这主要意味着还考虑了字母大小写和特殊符号:

print(pd.Series(['fox', 'koala', 'panda']).is_monotonic)
print(pd.Series(['FOX', 'Fox', 'fox']).is_monotonic)
print(pd.Series(['*', '&', '_']).is_monotonic)**Output:** True
True
False

当一个序列的所有值都相同时，会发生一个奇怪的异常。在这种情况下，两种方法都返回True:

print(pd.Series([1, 1, 1, 1, 1]).is_monotonic)
print(pd.Series(['fish', 'fish']).is_monotonic_decreasing)**Output:** True
True

4.`hasnans`

此方法检查序列是否包含 NaN 值:

import numpy as np
print(pd.Series([1, 2, 3, np.nan]).hasnans)
print(pd.Series([1, 2, 3, 10, 20]).hasnans)**Output:** True
False

5.`empty`

有时，我们可能想知道一个系列是否完全为空，甚至不包含 NaN 值:

print(pd.Series().empty)
print(pd.Series(np.nan).empty)**Output:** True
False

对序列进行一些操作后，序列可能会变空，例如过滤:

s = pd.Series([1, 2, 3])
s[s > 3].empty**Output:** True

6 & 7.`first_valid_index()`和`last_valid_index()`

这两种方法返回第一个/最后一个非 NaN 值的索引，对于具有许多 NaN 的系列对象特别有用:

print(pd.Series([np.nan, np.nan, 1, 2, 3, np.nan]).first_valid_index())
print(pd.Series([np.nan, np.nan, 1, 2, 3, np.nan]).last_valid_index())**Output:** 2
4

如果一个序列的所有值都是 NaN，两个方法都返回None:

print(pd.Series([np.nan, np.nan, np.nan]).first_valid_index())
print(pd.Series([np.nan, np.nan, np.nan]).last_valid_index())**Output:** None
None

8.`truncate()`

该方法允许截断某个索引值前后的序列。让我们截断上一节中的序列，只留下非 NaN 值:

s = pd.Series([np.nan, np.nan, 1, 2, 3, np.nan])
s.truncate(before=2, after=4)**Output:** 2    1.0
3    2.0
4    3.0
dtype: float64

该系列的原始索引被保留。我们可能希望重置它，并将截断的级数赋给一个变量:

s_truncated = s.truncate(before=2, after=4).reset_index(drop=True)
print(s_truncated)**Output:** 0    1.0
1    2.0
2    3.0
dtype: float64

9.`convert_dtypes()`

正如熊猫文档所说，这种方法用于

使用支持 *pd.NA* 的数据类型将列转换为最佳数据类型。

如果只考虑 Series 对象而不考虑 DataFrames，那么该方法的唯一应用是转换所有可空的整数(即小数部分等于 0 的浮点数，如 1.0、2.0 等)。)还原为“正常”整数。当原始序列同时包含整数和 NaN 值时，就会出现这种浮点数。因为 NaN 在 numpy 和 pandas 中是一个浮点型，所以它导致带有任何缺失值的整个系列也变成浮点型。

让我们看一下上一节中的例子，看看它是如何工作的:

print(pd.Series([np.nan, np.nan, 1, 2, 3, np.nan]))
print('\n')
print(pd.Series([np.nan, np.nan, 1, 2, 3, np.nan]).convert_dtypes())**Output:** 0    NaN
1    NaN
2    1.0
3    2.0
4    3.0
5    NaN
dtype: float640    <NA>
1    <NA>
2       1
3       2
4       3
5    <NA>
dtype: Int64

10.`clip()`

我们可以在输入阈值(lower和upper参数)处裁剪一个序列的所有值:

s = pd.Series(range(1, 11))
print(s)
s_clipped = s.clip(lower=2, upper=7)
print(s_clipped)**Output:** 0     1
1     2
2     3
3     4
4     5
5     6
6     7
7     8
8     9
9    10
dtype: int640    2
1    2
2    3
3    4
4    5
5    6
6    7
7    7
8    7
9    7
dtype: int64

11.`rename_axis()`

对于 Series 对象，此方法设置索引的名称:

s = pd.Series({'flour': '300 g', 'butter': '150 g', 'sugar': '100 g'})
print(s)
s=s.rename_axis('ingredients')
print(s)**Output:** flour     300 g
butter    150 g
sugar     100 g
dtype: objectingredients
flour     300 g
butter    150 g
sugar     100 g
dtype: object

12 & 13.`nsmallest()`和`nlargest()`

这两个方法返回一个序列的最小/最大元素。默认情况下，它们返回 5 个值，对nsmallest()按升序，对nlargest()按降序。

s = pd.Series([3, 2, 1, 100, 200, 300, 4, 5, 6])
s.nsmallest()**Output:** 2    1
1    2
0    3
6    4
7    5
dtype: int64

可以指定另一组要返回的最小/最大值。此外，我们可能希望重置索引并将结果赋给一个变量:

largest_3 = s.nlargest(3).reset_index(drop=True)
print(largest_3)**Output:** 0    300
1    200
2    100
dtype: int64

14.`pct_change()`

对于 Series 对象，我们可以计算当前元素和前一个元素之间的百分比变化(或者更准确地说，分数变化)。例如，当处理时间序列时，或者创建以百分比或分数表示的瀑布图时，这种方法会很有帮助。

s = pd.Series([20, 33, 14, 97, 19])
s.pct_change()**Output:** 0         NaN
1    0.650000
2   -0.575758
3    5.928571
4   -0.804124
dtype: float64

为了使结果系列更具可读性，让我们将其四舍五入:

s.pct_change().round(2)**Output:** 0     NaN
1    0.65
2   -0.58
3    5.93
4   -0.80
dtype: float64

15.`explode()`

该方法将一个序列(列表、元组、集、系列、ndarrays)中的每个类似列表的元素转换为一行。空名单-喜欢将在一排与南转换。为了避免结果序列中的重复索引，最好重置索引:

s = pd.Series([[np.nan], {1, 2}, 3, (4, 5)])
print(s)
s_exploded = s.explode().reset_index(drop=True)
print(s_exploded)**Output:** 0     [nan]
1    {1, 2}
2         3
3    (4, 5)
dtype: object0    NaN
1      1
2      2
3      3
4      4
5      5
dtype: object

16.`repeat()`

此方法用于将一个序列中的每个元素连续重复定义的次数。同样在这种情况下，重置索引是有意义的:

s = pd.Series([1, 2, 3])
print(s)
s_repeated = s.repeat(2).reset_index(drop=True)
print(s_repeated)**Output:** 0    1
1    2
2    3
dtype: int640    1
1    1
2    2
3    2
4    3
5    3
dtype: int64

如果重复次数被指定为 0，将返回一个空序列:

s.repeat(0)**Output:** Series([], dtype: int64)

结论

总之，我们研究了 16 种很少使用的 pandas 方法及其一些应用案例。如果你知道其他一些操纵熊猫系列的有趣方法，欢迎在评论中分享。

感谢阅读！

你会发现这些文章也很有趣:

</5-pandas-methods-youve-never-used-and-you-didn-t-lose-anything-37277fae7c55> [## 在 Python 中对两个字典执行逻辑运算的最简单方法

towardsdatascience.com](/the-easiest-ways-to-perform-logical-operations-on-two-dictionaries-in-python-88c120fa0c8f) https://medium.com/geekculture/emojize-your-data-science-projects-8f19d447f03c

数据科学和挖掘中使用的 17 种聚类算法

原文：https://towardsdatascience.com/17-clustering-algorithms-used-in-data-science-mining-49dbfa5bf69a?source=collection_archive---------1-----------------------

聚类算法的概述、它们的用例以及它们的优缺点

各种聚类算法。

“要走得快，就一个人走；想走远，就一起走。”——非洲谚语。

**快速提示:**如果您通过基于 chromium 的浏览器(例如，Google Chrome、Chromium、Brave)阅读本文，下面的目录就可以了。然而，像 Firefox 这样的其他浏览器就不一样了，在 Firefox 中，你需要点击每个链接两次才能到达指定的部分。尽情享受吧！

一如既往，除非特别说明，所有文字和图像都是作者创作的。

**Table of Contents(TOC)**
**🄰.**[**Introduction**](#36be)
   ► [Machine learning](#94e3)
   ► [Cluster analysis](#c789)
   ► [Types of Clustering](#4cd4)
**🄱.**[**Clustering Algorithms**](#a176)
   ► [**Centroid-based clustering**](#7b7b)
    ** ➤** [k-means](#9136)
     ➤ [k-means++](#51f6)
     ➤ [k-means||](#9062)
     ➤ [Fuzzy C-means](#7e1d)
     ➤ [k-medoids, PAM](#a536)
     ➤ [k-Medians](#0133)
     ➤ [k-Modes](#eb7d)
     ➤ [k-prototypes](#87c6)
     ➤ [CLARA](#5190)
     ➤ [CLARANS](#a329)
   ► [**Distribution-based clustering**](#5c4a)
    ** ➤** [GMM](#8925)
     **➤** [EM](#ffbb)
     ➤ [DMM](#14a7)
   ►[**Density-based clustering**](#6178)
    ** ➤** [DBSCAN](#5588)
     ➤ [ADBSCAN](#b750)
     ➤ [DENCLUE](#eeb3)
     ➤ [OPTICS](#d22d)
**🄲.**[**Conclusion**](#9b71) **🄳.**[**Useful Resources**](#61ab)

🄰.介绍

随着信息变得越来越重要，全球各地的人们都可以获取信息，越来越多的数据科学和机器学习方法被开发出来。聚类分析模型乍看起来可能很简单，但理解如何处理大量数据是至关重要的。然而，在大量的聚类算法中做出合理的选择有时会令人望而生畏，并且需要对各种算法有相当多的了解。因此，本文汇编了 17 种聚类算法，以向读者提供关于其中大多数算法的大量信息。

⇨机器学习

机器学习是人工智能的一个子领域，其最简单而直接的定义是如何通过发现统计模式从数据(例如，从传感器、实验收集的数据……)中教会机器做出决策并自行完成任务(自动化数据驱动模型)。就这么简单。然而，困难来自于缩小的细节和应用。一切都是为了分析数据并从中学习。此外，机器学习在其核心部分为数据科学提供了基础，正如 Drew Conway ven 图所示。

从历史上来说，机器学习源于人工智能中的连接主义者，其中一组个体想要复制具有相似特征的人脑机制。此外，它主要受益于心理学和其他领域(如统计学)的思想。).此外，统计学和机器学习是根本不同的领域，前者旨在为人类提供正确的工具来分析和理解数据。后者专注于自动化人类对数据分析的干预(AI 奇点)。

⇨聚类分析

聚类分析、聚类或数据分割可以定义为一种无监督(无标签数据)的机器学习技术，旨在发现模式(例如，许多子组、每个组的大小、共同特征、数据内聚性……)，同时收集数据样本，并使用预定义的距离度量(如欧几里德距离等)将它们分组到相似的记录中。共享相似特征的数据对象或观察结果被分组到一个由保存这些数据样本的距离(例如，椭圆的长轴)描述的聚类中。).

椭圆的轴。

聚类分析被各种应用广泛采用，例如图像处理、神经科学、经济学、网络通信、医学、推荐系统、客户细分等。此外，在处理新数据集以提取见解和了解数据分布时，可以将聚类视为第一步。聚类分析也可以用于执行维数减少(例如，PCA)。它还可以作为其他算法(如分类、预测和其他数据挖掘应用程序)的预处理或中间步骤。

⇨聚类的类型

有许多方法可以将聚类方法分成不同的类别。例如，基于重叠区域，存在两种类型的聚类:

🄀 硬聚类:聚类不重叠:k-means，k-means++。一个数据点只属于一个集群。它要么属于某个集群，要么不属于。

⒈ 软聚类:聚类可以重叠:模糊 c 均值，EM。一个数据对象可以以一定的概率或隶属度存在于多个集群中。

此外，聚类算法可以根据它们试图达到的目的进行分类。因此，存在两种基于该标准的聚类技术:

🄀 单一:在聚类成员之间存在一些共同的属性(例如，25%的患者表现出疫苗 a 的副作用):数据根据单个特征生成的值进行划分。

⒈ 多面体:聚类成员之间存在某种程度的相似性，但没有共同的属性(例如，相异度):数据根据所有特征生成的值进行划分。

基于所使用的聚类分析技术，每个聚类表示一个质心、代表数据样本中心的单个观察值和一个边界界限。下图显示了一些常见的聚类分析算法类别。

聚类算法综述。

🄱.聚类算法。

► [**Go To TOC**](#04f2)◀

⓪.基于质心的聚类。

该方法的主要步骤之一是初始化聚类 k 的数量，这是一个在模型训练阶段保持不变的超参数。

ⓐ.k-means 或劳埃德算法

最流行的划分算法之一(在谷歌学者上有超过 100 万的引用)用于对数字数据属性进行聚类。使用这种多面体硬聚类技术，n 个数据对象被分成 k 个分区(k < < n)，其中每个分区代表一个聚类。每个群集必须至少包含一个数据点。此外，每个数据对象必须只属于一个组。此外，同一聚类的观察结果应该相似或相近。相反，不同组的对象必须相距很远或彼此不同。换句话说，k-means 算法的目标是最大化每对聚类中心之间的距离，最小化每个聚类内观测值之间的距离(例如，最小化一个聚类内的平方误差之和，SSE)。).

如果满足以下条件，k- means 聚类可以很好地工作:

🄀 各属性的分布方差呈球形。

⒈ 集群是线性可分的。

⒉ 星团具有相似数量的观测值(更接近大小。).

⒊ 变量呈现相同的方差。

然而，如果其中一个假设被打破，并不一定意味着 k- means 将无法聚类观察结果，因为算法的唯一目的是最小化平方误差之和(SSE)。这里有一个很好的讨论说明，如果前面的假设之一不满足，k-means 会很好地工作。

为了更好地理解数据(例如，提取信息和查找聚类)，经验法则是在二维空间中绘制数据。例如，要找到虹膜数据集中有多少聚类，一个基本的相关矩阵就可以说明很多。

如图所示，该数据集中有三个主要的集群。因此，为了进一步的培训，k 应该等于 3。然而，这不是选择 k 值的最佳方法。

在实践中，标准方法是从肘方法开始，该算法针对不同的 k 值(例如，k= 1、2、3、4……)运行，并使用一种称为 WCSS(类内平方和)的稳健方法，该方法计算每个类成员与其质心之间的距离之和，以使其最小化，从而达到 k 的最佳值

k 的最佳值是 3。

还有另一种通过计算每个聚类的轮廓系数来选择正确的 k 值的方法:相同聚类的点之间的平均距离。它根据数据对象的分类给出了数据对象相似程度的指标。为了说明这一点，在 iris 数据集上执行了侧影绘图，其中每个聚类都有一个侧影系数。

k = [2，3，…，7]的轮廓分数

使用这种方法，系数越接近 1，k 值就越适合模型。因此，k 的最佳值是 2 和 3，因为它们为每个聚类提供了比其他值更高的轮廓系数。

k 也可以使用 shoulder 方法初始化，该方法显示平方和百分比(BSS/TSS)与聚类数的关系图。

k 的最佳值是 3。

如图所示，最佳聚类数是一个肩(跃)开始形成的地方。因此，k 等于 3。

此外，还有很多其他方法可以用来估计 k 的最佳值，例如 R 平方度量。然而，剪影评分已经被证明是找到 k 的最好方法

⇨的解释。

这一切都是从在特征空间中随机放置 k 个点开始的，其中每个点代表一个唯一聚类的质心。使用某个相异度度量，迭代计算数据集的每个观察值与每个聚类中心之间的距离。此外，将每个观察值分配给最近质心的聚类。之后，对于每个聚类，计算每个聚类的点的平均值(数字属性),并将质心重新分配给结果平均值。该过程将一直重复，直到满足预定的收敛条件(例如，达到最大迭代次数，意味着差异变得不变，BSS 变得低于给定的最小值，SSE 的最小值，最小化目标函数，失真…)

k 均值的目标函数。

⇨算法。

🄀从数据集中挑选 k 个随机质心。

⒈ 使用适当的相异度度量(例如欧几里德距离)计算每个数据点 w.r.t 聚类的质心之间的距离。

⒉ 根据计算的距离将每个数据点分配到最近的聚类。

⒊ 通过计算数据点的平均值来重新定位质心。因此 k-means 只对数值数据有效！

⒋ 重复⒈，直到聚类变得稳定或者目标函数 j 达到其最小值。

⇨的优势。

🄀的学习曲线相对陡峭。

⒈ 被各种包广泛实现(r 中的 Stats package，python 中的scikit-learn…)

⒉ 聚类小数据集的快速收敛。

20 次迭代来聚类虹膜数据集。

⒊ 容易实现。

⇨无往不利。

🄀 对于大型数据集，计算开销很大(k 变大。).

⒈:有时，很难为聚类数(k)选择一个初始值。

⒉不能保证收敛到全局最小值。它对质心的初始化很敏感。不同的设置可能导致不同的结果。

⒊ 对异常值的强烈敏感性。

⒋ 只对数值数据有效。

⒌ 未能为一组具有非凸形状的点提供良好的聚类质量。

k-means 无法分离月亮形状的数据点。

然而，一些缺点可以通过使用肘方法来初始化聚类数，使用 k-means++来克服参数初始化中的敏感性，以及使用类似于遗传算法的技术来寻找全局最优解来解决。

⇨应用程序。

k-means 聚类被各种现实世界的企业所采用，例如搜索引擎(例如，文档聚类、相似文章聚类)、客户细分、垃圾邮件/ham 检测系统、学术表现、故障诊断系统、无线通信等等。

⇨目标函数最小化。

k 均值的代价函数。

为了找到 k 个集群的最优解，成本函数 J w.r.t μ 的导数必须等于零**。**

对于每个集群 J，前面的等式将导致:

每个聚类质心的梯度 w.r.t 欧几里德距离。

每次迭代后，每个聚类的质心被更新为该聚类内所有数据点的经验平均值。

注意，最小化每个聚类内的欧几里德距离的问题被称为韦伯问题。而且，从几何学上讲，均值并不是最优解。因此，需要复杂的几何中心，如中位数，medoid，以尽量减少欧几里德距离。

ⓑ k-means++

► [**Go To TOC**](#04f2)◀

k-means++背后的思想是，它试图在每次迭代分配一个新中心的同时分散中心。因此，该算法从随机(统一)从数据集中选取一个初始中心开始，这意味着所有点被选中的概率相等。然后计算从每个数据点到先前选择的中心的距离平方。之后，它通过简单地将距离除以总距离来计算每个数据点的概率。此外，将新的聚类中心分配给具有最高概率或最高距离的点。换句话说，数据对象成为新聚类中心的可能性与距离的平方成正比。

k_means++采样 k 个质心。

一旦分配了中心，k-means 算法将与这些聚类的中心一起运行，并且它将收敛得更快，因为质心已经被仔细选择并且彼此远离。

采样质心上的 k_means。大约 12 次迭代

⇨算法

初始化步骤

以均匀的方式独立地对每个质心进行采样，其概率与每个数据点到每个质心的距离的平方成比例。

聚类步骤

一旦 K 个质心被均匀采样，K-means 算法将使用这些质心运行。

⇨的优势

🄀 与 K-means 具有相同的优势。

⒈ 比 K-means 收敛更快，迭代次数更少。

⇨无往不利。

与 K-means 有相同的缺点。

初始化步骤(为 K 选择一个初始值)可以被认为是 kmeans++的主要缺点之一，就像 K-means 算法的其他风格一样。但是，它比单独运行 K-means 更容易收敛，速度更快。此外，该算法仍然对异常值敏感，这些异常值可以使用 LOF 、兰萨克和其他方法来解决。

ⓒ K-means||，可伸缩 K -means++

► [**Go To TOC**](#04f2)◀

K-means 并行是另一种充分的技术，它在每次迭代后更新样本分布的频率较低。它在 k-means 算法中引入了一个过采样因子(L ~ k 阶，例如 k，k/2，…)。利用这个因素，对于更大的数据集，它将使算法收敛得更快。

⇨ 算法。

初始化步骤

k-means||初始化步骤。

🄀 初始化过采样因子 l 的值

⒈ 对于一定数量的迭代(0 ≤ nb_iter ≤ k)，以与每个数据点到每个质心的距离的平方成比例的概率(比 kmeans++算法中的概率大 l 倍)均匀随机采样 l 个质心。

nb_iter = 0 ⇨ k 均值聚类。

nb_iter = k，而 L = 1 ⇨ k-means++聚类。

聚类步骤

一旦 K 个质心被均匀采样，K-means 算法将使用这些质心运行。

k _ means 次迭代收敛！

⇨ 优点。

🄀很适合大型数据集。运行时间~日志(k)

⒈ 比 kmeans++快，因为它每次迭代采样 l 个质心。

⇨t30】无往不利。

🄀 它会导致基于 l 值的过采样或欠采样

使用 k 均值进行过采样(L = 20) ~ 13 次迭代！

欠采样(L = 0) ~ 14 次 k 均值迭代！

ⓓ.模糊 C 均值:FCM

► [**Go To TOC**](#04f2)◀

FCM。

术语模糊用于强调这样一个事实，即一个数据点可以存在于一个或多个聚类中，允许形成各种不同的聚类阴影(例如，不相交、非分离……)。例如，橙色是红色和黄色的混合，这意味着它在某种程度上属于每个颜色组。

隶属度函数用于测量数据点属于每个聚类的程度。它描述了一个数据点属于某个聚类的概率。

该算法旨在最小化以下成本函数:

FCM 的目标函数。

⇨算法

🄀 基于预定义的权重 aij^p 和 p 的初始值选择 k 个初始模糊伪质心

⒈ 使用模糊划分更新聚类中心。

⒉ 使用以下公式更新权重。

⒊计算目标函数 j

⒋ 重复 ⒈ 直到质心稳定或者满足以下标准:新计算的代价函数和旧的代价函数之差小于某个值。

FCM 的收敛条件。

模糊 k-means 提供了大量真实世界的用例，如图像分割、异常检测。与边缘和对象检测等其他图像处理技术相比，它的计算量较小。

⇨的优势。

🄀 与 k-means 相比，重叠数据的结果更好。

⒈ 时间复杂度低。

⒉ 收敛有保证。

⇨无往不利。

🄀 对 k 和 p 的初始值敏感

⒈ 对异常值敏感。

⇨目标函数最小化。

FCM 的成本函数。

为了找到 k 个集群的最优解，成本函数 J w.r.t μ 的导数必须等于零**。**

对于每个集群 J，前面的等式将导致:

成本函数 w.r.t 形心 j 的梯度

已知对于数据集中的每个观察值，所有聚类的成员总数等于 1；因此，在每次迭代之后，每个聚类的质心被更新为其经验平均值。

每次迭代后，每个聚类的质心被更新为该聚类内所有数据点的平均值。

ⓔ.k-水母，PAM(水母周围的分区)

► [**Go To TOC**](#04f2)◀

k-means 算法的修改版本，其中 medoid 表示一个数据点，该数据点在一个聚类内的所有点中具有最低的平均相异度。目的是最小化每个集群的总成本。与 k-means 不同，它使用一个 medoid 作为度量来重新分配每个聚类的质心。水母对异常值不太敏感。这些中值线是来自数据集的实际观测值，而不是像 k-means 那样的计算点(平均值)。最好使用曼哈顿距离作为度量，因为它对异常值不太敏感。

⇨t32】算法。

🄀 随机选取 k 个观测值作为初始均值。

⒈计算观测值和流星体之间的距离。

⒉ 将每个点分配到最近的中点。

⒊ 在每个集群中选择一个新的观测值(非 medoid)并与相应的 medoid 交换。

⒋ 计算每个簇内每个 medoid 和新数据点的交换成本。

⒌ 选择具有最低成本(例如，最小相异度之和)的观察值作为新的 medoid。

⒍ 重复步骤 ⒈ 直到满足收敛条件(例如，最小化成本函数、误差平方和(PAM 中的 SSE))。

k-medoids 代价函数。

⇨的优势。

🄀 在存在异常值的情况下比 k-means 更稳健(受异常值影响较小。)

⒈:这很容易实现。

⒉ 它以固定的迭代次数收敛。

⒊ 它可以有效地处理小数据集。

⇨无往不利。

🄀 它不适合大型数据集。

⒈的计算复杂度相当昂贵。

⒉ 参数 k 需要初始化为某个值。

⒊不能保证收敛到全局最小值。它对质心的初始化很敏感。不同的设置导致不同的结果。

⒋只对数字数据有效。

为了提高 PAM 的效率，使用了 CLARA 算法。

ⓕ.k 线中位数

► [**Go To TOC**](#04f2)◀

k 线中线。

k-means 算法的一个修改版本使用中值，它代表其他观察值均匀分布在其周围的中间点。中位数对异常值的敏感度低于平均值。

中位数对异常值的敏感度低于平均值。

此外，它使用曼哈顿距离作为计算观测值之间距离的度量。此外，该算法旨在最小化以下成本函数:

k-中位数代价函数。

⇨算法。

🄀 随机选取 k 个观测值作为初始中位数。

⒈计算观察值和中间值之间的距离。

⒉ 将每个点分配到最近的中间值。

⒊ 计算每个聚类的中值，并将其指定为该聚类的新质心

⒋ 重复步骤 ⒈ 直到满足收敛条件(例如最小化类似 SSE 的成本函数)。

ⓕ.k 模式

► [**Go To TOC**](#04f2)◀

由于 k-means 只处理数字数据属性，因此开发了一种改进的 K-means 算法来对分类数据进行聚类。模式替换每个集群中的平均值。然而，有人可能会想到在分类属性和数字属性之间进行映射，然后使用 k-means 进行聚类。这有时可以在小维度数据集上工作。但是，两种不同类型的属性之间的映射不能保证高维数据的高质量聚类。因此，建议在对分类数据属性进行聚类时使用 k-modes。

k-modes 中使用的相异度度量之一是余弦相异度度量，这是一种基于频率的方法，用于计算两个观察值之间的距离(例如，两个句子或两个文档之间的距离)。

k 模式的成本函数。

⇨算法。

K-Modes 聚类过程由以下步骤组成:

🄀 随机选取 k 个观测值作为初始中心(模态)。

⒈ 计算每个数据点和聚类中心(模式)之间的相异度

分类数据的相异度(如余弦…)

⒉ 根据相异度(如余弦相异度函数)将每个观察值分配到最近的聚类中心。

⒊ 根据每个集群中计算的模式值重新定位每个质心。

⒋ 重复步骤 2，直到满足收敛条件(例如，最小化像 SSE 这样的成本函数)。

⇨的优势。

🄀 能够对分类数据属性进行聚类。

⒈itt23】比 K-prototypes 收敛的更快。

⇨无往不利。

🄀 对于大型数据集，计算开销很大(k 变大。).

⒈ 有时，很难为聚类数(k)选择正确的初始值。

⒉不能保证收敛到全局最小值。它对质心的初始化很敏感。不同的设置可能导致不同的结果。

⒊ 效率取决于算法使用的相异度(例如，斯皮尔曼相关、余弦距离……)。

⒋ 额外的变量被添加到 algorithm(𝛾中，该变量控制从每个观测值到它们的聚类中心的距离的权重。

局部最优问题可以使用全局优化算法来解决，例如布谷鸟搜索算法。

⇨应用。

k-modes 通常用于文本挖掘，如文档聚类、主题建模(其中每个聚类组代表一个给定的主题(相似的词…))、欺诈检测系统、营销(如客户细分。)、网页聚类等等。

ⓖ.k-原型

► [**Go To TOC**](#04f2)◀

这种方法适用于数值和分类数据属性的混合。该算法可以被认为是 k-means 和 k-modes 算法之间的组合。

使用该算法，每个数据点都有一个权重，该权重是数字和分类聚类的一部分。此外，每种类型的观察可以以单独的方式处理，其中质心在每种类型的聚类中扮演吸引子的角色。可以使用模糊隶属函数 aij 来控制给定数据点的隶属度，就像在 FCM 中一样。

K 原型的成本函数

𝛾 用于平衡分类数据属性和数字数据属性之间的影响。

⇨算法。

K 原型聚类过程包括以下步骤:

🄀 随机选取 k 个代表作为 k 个聚类的初始原型。

⒈ 计算距离(如欧几里德)和相异度(如余弦)。)在每个数据点和相应的聚类中心(原型)之间。

欧几里德距离和相异度。

⒉ 根据距离公式将每个观察值分配给最近的集群原型。

⒊ 根据以下公式重新定位每个聚类中心。

每种属性的聚类中心。

⒋ 重复步骤 ⒈ 直到满足收敛条件(例如，成本函数的最小值)。

⇨的优势

🄀 能够聚类混合类型的属性。

⒈在合理的迭代次数内收敛。

⇨无往不利。

🄀不同的相异措施会导致不同的结果。

⒈ 对 k 和𝛾.的初始值敏感

⒉不能保证收敛到全局最小值。它对水母的初始化很敏感。不同的设置可能导致不同的结果。

⒊ 效率取决于算法使用的相异度(例如，斯皮尔曼相关、余弦距离……)。

在聚类分类数据的情况下，⒋ 比 k-modes 慢。

ⓗ.CLARA(集群大型应用。)

► [**Go To TOC**](#04f2)◀

它是一种基于样本的方法，随机选择数据点的一个小子集，而不是考虑整个观察值，这意味着它在大型数据集上工作得很好。此外，从先前选择的样本中选择 k 个 medoids。这将有助于提高 PAM 的可伸缩性(减少计算时间和内存分配问题)。它按顺序处理不同批次的数据集，以找到最佳结果。

克拉拉

该算法的结果是具有最小成本的一组 medoids。

⇨算法

🄀 从固定大小(大小 s)的数据中随机选择多个子集。

⒈ 在一个数据块上计算 k-medoid 算法，并选择相应的 k 个 medoid。

⒉ 将原始数据集的每个观测值分配给最近的 medoid。

⒊ 计算观测值与其最近的中值的差异的平均值。

⒋ 保留均值最小的数据子集。

⒌ 重复，直到找到最优的 medoids。

⇨的优势。

🄀 能够处理大型数据集。

⒈ 在处理大型数据集时减少计算时间。

⒉处理异常值的能力。

⇨无往不利。

🄀 效率受到 k 值和样本大小的影响。

⒈聚类的质量取决于所使用的抽样方法的质量。

⒉ 难以实现。

ⓘ.基于随机搜索的大型应用集群。)

► [**Go To TOC**](#04f2)◀

它是 k-medoid 的扩展，用于数据挖掘中对大型数据集进行聚类。

克拉伦斯

该算法的结果是具有最小成本的一组 medoids。

⇨算法。

🄀 从数据集中随机选择 k-medoids。

⒈ 从先前选择的观察和医疗器械中挑选一个。

⒉ 计算两点和数据集中所有其他数据点之间的距离。

⒊ 计算交换两个数据点的成本，选择成本最低的一个作为 medoid。

⒋ 重复步骤 ⒈ 直到收敛(找到 k-medoids 的最优选择)。

⇨的优势。

在大型数据集上，🄀比帕姆和克拉拉更有效。

⒈ 处理异常值的能力。

⇨无往不利。

🄀 难以实现。

⒈ 聚类的质量取决于所用抽样方法的质量。

➀.基于模型/分布的聚类。

► [**Go To TOC**](#04f2)◀

⇨概率建模。

概率模型是由数据变量上的联合分布参数化的生成数据模型:P(x1，x2，…，xn，y1，y2，…，yn|θ)其中 X 是观察数据，y:潜在变量，θ是参数。

P(y1，…，yn|x1，…，xn，θ) = P(x1，…，xn，y1，…，yn|θ)(联合)/ P(x1，…，xn|θ)(边际概率)

学习。

使用最大似然法执行学习阶段:

θML = argmax θ P(x1，…，xn|θ)

目的是找到一个参数θ，使观测数据的概率最大化。

预测。

P(xn+1，yn+1|x1，…，xn，θ)

目标是在给定观察数据集的情况下计算潜在属性的条件分布。

分类:

目标是找到一个类，在给定学习参数θ的情况下，使未来数据的概率最大化:

argmax c P(xn+1|θc)

概率建模中使用的一些标准算法是 EM 算法、MCMC 采样、连接树等。

ⓐ.GMM:高斯混合模型

在 2-d 变量空间中，高斯分布是使用具有正态分布的两个随机变量构建的二元正态分布，每个正态分布由其平均值和标准偏差参数化。

在我看来，高斯分布如此重要是因为它使计算(如线性代数计算。)毫不费力地做。然而，它并不是现实世界应用程序的完美模型。

三维空间中的高斯及其投影。

高斯混合模型是半参数模型(随着数据增加的有限数量的参数。)用作软聚类算法，其中每个聚类对应于一个生成模型，该生成模型旨在发现给定聚类的概率分布参数(例如，均值、协方差、密度函数……)(它自己的概率分布控制每个聚类)。学习的过程是用高斯模型来拟合数据点。高斯混合模型假设聚类在 n 维空间中以正态分布分布。

协方差矩阵和一维空间中的高斯公式。

为了说明一维空间中的混合模型，假设有两个正态分布的信息源，其中从每个信息源收集了 n 个样本。要估计每个高斯分布的平均值，取观察值的总和，并除以收集的样本数(经验平均值。)，同样用于估计其他参数。

当有 k 个高斯模型，并且没有给出关于观测值来自哪里的信息时，问题就出现了；不容易搞清楚怎么把点分成 k 簇。因此，估计每个高斯参数几乎是不可能的。然而，如果高斯参数(均值、方差)是预定义的，这个问题就可以解决。

这就是 EM 方法试图解决的问题。

ⓑ.EM:集群环境下的期望最大化。

► [**Go To TOC**](#04f2)◀

这是一种众所周知的用于拟合混合分布的算法，旨在当一些数据点不可用时(例如，未知参数、潜在值等)，使用最大似然原理(寻找最优值)来估计给定分布的参数。在 GMM 的背景下，直觉是在空间中随机放置 k 个高斯模型，并计算每个数据点对某个高斯模型的隶属度。与硬聚类(例如，k-means)不同，该方法计算每个点成为某个聚类的成员的概率。此外，这些值用于重新估计聚类参数(例如，平均值、协方差)以拟合为每个聚类分配的点。

EM 广泛用于解决诸如“隐藏数据”问题、隐藏马尔可夫模型之类的问题，其中存在依赖于先前隐藏变量的状态的潜在变量序列。此外，每个观察值取决于相应隐藏变量的状态。

隐马尔可夫模型。

πₖ 是给定前一状态 k 的转移概率。箭头描述变量之间的相关性。

算法。

EM 算法包括两个步骤，期望步骤和最大化步骤。

步骤-0: 参数θs 的初始化。

E 步骤:在该步骤中，通过计算每个潜在数据点的归一化期望值 Wij (数据点在每个分布中的权重)来估计观察值来自哪个分布，假设给定聚类 J 的质心 μj 和协方差矩阵σJ当前假设成立:

P(xi|K=j，θ) 是多元正态分布 Xi~N(μi，σI)的条件概率。

每个聚类具有可以基于训练数据集估计的概率 𝜋( 先于 ) 。

M 步:使用前一步获得的信息，m 步将使用新的最大似然假设(假设每个隐藏变量的值为期望值)更新均值 μj 和协方差σj(或方差 𝜎 )的估计值。

重复 E 和 M 步骤，直到对数似然函数收敛。

对数似然函数

对数似然图。

利用每次迭代后似然性单调增加的事实，该算法更有可能收敛到最优。

为了演示 EM 算法，让我们考虑从三个高斯模型(a、b、c)生成的观察值。由于每个样本都是未标记的，所以目标是估计这三个高斯模型的参数，以将每个点标记为某个高斯分布。为了估计这些参数，将三个高斯模型随机放置在 1-d 数据集空间中。

🄀 计算从具有以下密度函数的三个高斯模型生成的每个数据点的可能性。

**⒈ E 步:**对于每个数据点，计算其权重 wi(ai，bi，ci)。

⒉ **M 步:**此时，可以估计每个模型的均值和方差。

⒊估计概率。

⒋ 重复 e 和 m 步骤，直到对数似然函数收敛。

具有 3 个集群的 1d GMM。

具有 3 个集群的 2d GMM。

⇨优势。

🄀 它产生混合分布参数的有效估计。

⒈实现起来非常简单。

⇨无往不利。

🄀 为 k(混合模型的数量)选择一个初始值，就像在 k-means 中一样。

⒈ 对初始值敏感，从而导致不同的结果。

⒉:它可能会收敛到一个局部最优解。

⒊的收敛速度可能会很慢。

ⓒ.狄利克雷混合模型。

► [**Go To TOC**](#04f2)◀

狄利克雷过程。

狄利克雷过程是一种随机过程，它在用于定义贝叶斯非参数(非固定参数集)的离散分布(概率度量)上产生分布。例如~无限数量的参数。)模特。狄利克雷分布是由浓度/精度参数/向量(α₁，…，αₖ)参数化的连续多元密度函数，具有正分量和基本分布 H: DP(α，h)。它类似于两个以上结果的 Beta 分布(如 Coinflip)。

联合分布的图形模型。

k 维狄利克雷: (π₁，π₂，…，πₖ) ~Dirichlet(α₁，α₂,…，αₖ)

θ是独立的参数，并且在 H 上同分布，目标是在给定观测值 xi 的情况下推断参数θ和潜在变量。

α > 1 的不同值的狄利克雷分布和样本。

α = (1，1，1) ，该图代表均匀分布。
α > (1，1，1) ，该图代表单峰分布。
0 < α < (1，1，1) ，该图代表多峰分布。

α < 1 不同值的狄利克雷分布和样本。

狄利克雷分布的一个很大的性质是，当合并两个不同的分量(πi，πj)时，会产生一个边际分布，这个边际分布是由参数(αi，αj)相加而参数化的狄利克雷分布。它类似于降维的思想。这种特性被称为塌陷。另一个性质是，可以证明具有伽马分布的随机变量遵循狄利克雷分布。

π 是经常用著名的断棒例子描述的概率。为了解释这些值，一根长度为一个单位的棍子被用来随机产生一个介于 0 和 1(棍子的最大长度)之间的数，在该数处棍子将被折断。一旦生成，木棒可以在长度 π 处断裂，该长度代表来自以 1 和α为参数的β分布的随机值:π∾β(1，α) 。通过折断这根棍子，它将生成一个概率质量函数(PMF)，其中两个结果的概率分别为 π 和1π。两根木棒可以类似地进一步折断，这样所有木棒的长度之和必须等于 1。并且该过程可以无限重复。

棍子折断的例子。

y 轴代表后验的期望混合权重( πi )。x 轴代表组件的数量。

狄利克雷分布经常在主题建模和 LDA(潜在{隐藏主题}狄利克雷{狄利克雷分布}分配)的上下文中解释。LDA 的工作原理是将许多文档聚类成包含相似单词的主题，而无需事先了解这些主题。LDA 通过从两个分布中采样来构建文档(按文档的主题分布，按主题的单词分布)。

联合分布的图形模型。

在 LDA 中，每个主题在单词上具有多项式分布(H)，每个文档从由 α 参数化的狄利克雷分布( π 中采样，并且每个单词(xi)从具有由 π参数化的多项式分布的隐藏主题(Zi)中采样。

通过对每个文档进行分类，LDA 倾向于通过最大化其概率来使每个文档有意义，如下所示:

然而，最大化这个公式是相当昂贵的。因此吉布斯采样用于最大化方程的每个参数(单词:x，题目:z…)。

⇨ LDA 算法。

🄀 初始化话题数量 k

⒈ 将每个文档中的每个单词随机分类到一个主题中。

⒉ 对每个文档进行迭代，并计算以下概率:

⒊把每个单词重新归类到给定的主题中。

⒋ 重复直到前一个公式达到最大值。

⇨的优势。

🄀 对于大型数据集非常高效和灵活。

⒈ 算法的工作流程独立于其他任务。

⇨无往不利。

🄀 题目的数量 k 必须事先定义。

⒈ 不相关的话题。

➁.基于密度的聚类。

► [**Go To TOC**](#04f2)◀

在基于密度的聚类中，数据空间中的密集区域与密度较低的区域是分开的。如果某个位置的密度大于预定义的阈值，则将观测值分配给给定的聚类。

对于一个集群中的给定观测，该点周围的局部密度必须超过某个阈值。局部密度由两个参数定义:包含围绕给定点的一定数量的邻居的圆的半径 ε 和围绕该半径的最小数量的点: minPts 。

⇨定义。

🄀t34】Eps-邻域:半径为 EPS 的圆对于给定点的面积。

**⒈Density 可达:**点 p 被描述为从点 q 相对于 Eps 和 MinPoints 可达的密度当且仅当存在一组点(p1，p2，…，pi，…，pn)使得 pi+1 从 pi 直接可达。

⒉

**⒊密度连通:**一个点 p 被描述为关于 Eps 和 MinPoints 连通到点 q 的密度当且仅当存在一个点 w 是从 p 和 q 可达的密度

可达性类型。

⇨的优势。

🄀 不需要簇数 k

⒈ 发现更复杂形状的星团(例如月亮形状的星团。).

⒉ 离群点检测。

⇨无往不利。

🄀 对拓扑连接的对象进行分类在计算上是不可行的。

⒈ 不像 K-means 那样保持可扩展性。

⒉ 对 Eps、MinPts 敏感

⒊ 密度测量受采样数据点的影响。

ⓐ.DBS can 😄en sity-BSSSC说明AANoise 应用

► [**Go To TOC**](#04f2)◀

DBSCAN 发现 4 个集群。

这是迄今为止最流行的基于密度的聚类算法，在谷歌学术上被引用超过 41k 次。中心思想是将观测结果分成 3 种类型的点组:

🄀核心点:在ε-邻域中有超过个 minPts 点。

minPts = 5

⒈边界点:少于 minPts 在 ε 内但在一个核心点附近。

从核心点 a 可以到达点 B。

⒉ 噪声或异常值点:所有剩余的点:不是核心点，并且没有接近到足以从核心点到达。

⇨的解释。

它从随机选择一个还没有被分配给一个簇的点开始。然后，该算法确定它是核心点还是离群点。一旦找到一个核心点，它的所有密度可达观测值将被添加到一个聚类中。之后，该算法将对每个可直接到达的点执行邻居跳转，并将它们添加到集群中。如果添加了异常值，它将被标记为边界点。然后，该算法选取另一个核心点，并重复前面的步骤，直到所有点都被分配到聚类或被标记为异常值。

⇨算法。

🄀 随机挑选一个点 p

⒈ 找出由 p 给定 eps 和 minPts 密度可达的所有点。

⒉ 检验 p 是否为核心点。一个集群将由至少一个核心点、可到达的核心点以及它们的所有边界构成。

⒊ 重复前面的步骤，直到遍历完所有的点。

⇨的优势。

🄀 能够确定任意形状的星团。

⒈ 对异常值不太敏感。

⒉ 可以作为离群点检测。

⒊可以有效地处理任何规模的数据集。

⇨无往不利。

🄀 不适用于高维数据集。

⒈ 取决于几个超参数。

⒉ 发现密度变化的星团的问题。

⒊ 只对数字数据有效。

⇨应用程序。

它广泛用于异常检测、科学文献和其他应用。

ⓑ.ADBSCAN: A 自适应 DBSCAN

► [**Go To TOC**](#04f2)◀

顾名思义，该算法与之前的算法不同，它采用代表每个聚类密度分布的 Eps 和 MinPts 的值。它会自动找到合适的 Eps 和 MinPts 值。

它首先为 Eps 随机选择一个值。然后，它对数据集运行 DBSCAN，如果它未能找到一个集群，它会将 Eps 的值增加 0.5。当算法找到一个聚类(10%的相似数据)时，它会将该聚类从数据集中排除。并且，该算法不断增加 eps 的值以找到下一个聚类。一旦算法成功地扫描完大约 95%的数据，剩余的数据点将被声明为异常值。

但是，ADBSCAN 需要数据集中聚类数的初始值。有关更多信息，请考虑阅读这篇文章。

ⓒ.登线索:登基 CLU 圣 E 环

► [**Go To TOC**](#04f2)◀

DENCLUE 应用核密度估计方法来估计产生数据样本的随机变量的未定义概率密度函数。该估计基于核密度函数(例如，高斯密度函数。)表示每个数据点的分布。然后，通过求和(或积分)来计算所有先前函数的核密度估计。

基于样本分布的核密度估计(KDE)。

核是一种数学函数，用于模拟数据点及其邻居之间的影响。此外，核密度函数具有以下特性:

🄀 非负性:K(x) ≥ 0

⒈ 对称:K(x) = K(-x)

⒉内核下的面积必须等于一个单位。

⒊ 递减:K'(x) ≤ 0

不同类型的一维核。

DENCLUE 使用了密度吸引子的概念，这些吸引子代表了周围形成集群的观察结果。

带有两个密度吸引子的二维内核示例。

有两种类型的集群:

🄀 中心定义簇:它是通过分配被吸引到给定密度吸引子的点的密度而形成的。

⒈ 任意形状的簇:它由具有高密度的密度吸引子(>给定阈值)合并而成

⇨算法。

🄀 通过将所有数据点的密度函数相加来估计数据空间的整体核密度函数。

⒈ 聚类通过识别构成估计密度函数的局部最大值的密度吸引子来形成。

⒉ 使用带有估计密度函数梯度的爬山算法计算局部最大值。

⇨的优势。

🄀 明显比 DBSCAN 快。

⒈ 灵活适用于任何任意形状的集群。

⒉可以有效地处理任何规模的数据集。

⇨无往不利。

🄀 不适合高维数据集。

⒈ 取决于几个超参数。

⒉ 只对数值数据有效。

ⓓ.光学:排序点识别聚类结构。

► [**Go To TOC**](#04f2)◀

由于 DBSCAN 的性能取决于其参数设置，Optics 扩展了 DBSCAN，使其对参数设置不太敏感，并在簇之间查找结构。直觉上，基于两个参数，较高密度的区域将在较低密度的区域之前首先被处理:

**🄀核心距离:**包含至少 MinPts 个观测值的最小半径 eps。

**⒈可达距离:**使两个观测值密度可达的最小距离。

也就是说，光学根据观测值的密度结构形成有序的集群。此外，它使用所有点的可达性距离的计算值作为阈值，以分离数据和异常值(位于红线以上的点)。

⇨算法。

🄀 从数据集中随机选取一个数据点。

⒈ 通过计算 eps 邻域内的核心距离来确定所选点是否为核心点。

⒉ 如果所选择的点是核心点，那么对于每一个其他的观察值，更新从先前选择的点的可达性距离。此外，将新的观察结果插入到 OrderSeeds 中，该 order seeds 包含按可达性距离排序的点。

⒊ 如果所选点不是核心点，则移动到 OrderSeeds 中的下一个观察点，或者如果 OrderSeeds 为空，则移动到初始数据点中的下一个观察点。

⒋ 重复，直到遍历完所有观测值。

⇨的优势。

🄀 能够发现内在的、分层嵌套的聚类结构。

⒈ 需要与 DBSCAN 相同数量的参数(eps 和 minPts ),但不需要 eps，这降低了算法的运行时复杂性。

⒉ 能够发现具有不同密度的星团。

⇨无往不利。

🄀 没有密度下降的集群的问题。

⒈ 仍然对参数 minPts 敏感。

⇨应用。

光学可用于异常检测(发现异常值)。

异常检测。

🄲.结论

► [**Go To TOC**](#04f2)◀

通过本文，您已经了解了如何使用聚类分析作为一种强大的技术来发现模式并从数据中提取洞察力。然而，决定是否选择给定的聚类算法取决于几个标准，例如聚类应用的目标(例如，主题建模、推荐系统……)、数据类型等。此外，数据挖掘团队有责任决定选择最适合他们需要的方法。

哇呜！你已经到了今天博客的结尾，这有点让人不知所措，不骗你。然而，你可以通过粉碎👏按钮，直到你感到宽慰😌。

我希望你喜欢这篇花了我很长时间(大约一个月)让它尽可能简洁明了的文章。我将感谢您的支持，请关注我，关注即将到来的工作和/或分享这篇文章，以便其他人可以找到它。

正如你可以从插图中看出的，我已经设法实现并可视化了大多数算法。当它完成后，我将在 GitHub 上发布第一个版本。

和往常一样，你可以引用这篇文章中的任何插图和其他信息:

Mahmoud Harmouch，17 数据科学和挖掘中使用的聚类算法，走向数据科学，2021 年 4 月 23 日。

如果你有任何需要传授的智慧之言，我很高兴在评论区看到你的想法。

如果您在这篇文章中遇到了任何误传或错误，为了改进内容，请不要忘记提及它们。

下一篇文章再见。

Peace✌️

🄳.有用的资源

► [**Go To TOC**](#04f2)◀

ⓐ.k-means

**【0】**笔记本: 05.11-K-Means.ipynb

**【1】**钱丹·k·雷迪，巴努基兰·温扎莫里；分区和层次聚类算法综述

**【2】**jeffp； L10: k 均值聚类

**【3】**克里斯皮赫；K 表示

ⓑ.k-means++

**【0】**大卫·亚瑟，谢尔盖·瓦西里耶维奇； k-means++:小心播种的好处。

ⓒ.k-means||

**【0】**巴赫曼·巴赫马尼、本杰明·莫塞利、安德烈·瓦塔尼、拉维·库马尔、谢尔盖·瓦西里维茨基；可扩展 K-Means++

ⓓ.FCM

马杜库马尔，桑提亚库马里，N..(2015).脑部 MR 图像 k 均值和模糊 C 均值分割的评价。埃及放射学和核医学杂志。1.2015 年 2 月 10 日

ⓔ.k-medoids

**【0】**维基百科关于 K-medoids 的文章:【https://en.wikipedia.org/wiki/K-medoids】T42

**【1】**Tri Nguyen 的 K-medoids 实现:https://towardsdatascience . com/K-me doids-clustering-on-iris-data-set-1931 BF 781 e 05

**【2】**Github 库的 scikit learn _ extra:https://Github . com/scikit-learn-contrib/scikit-learn-extra/tree/master/sk learn _ extra/cluster

ⓕ.k 线中线

**【0】**桑乔伊·达斯古普塔、纳韦·弗罗斯特、米哈尔·莫什科维茨、赛勒斯·拉什奇安；可解释的 k-均值和 k-中位数聚类

**【1】**大卫·多汉、斯特凡尼·卡普、布莱恩·马泰杰克；k-中值算法:理论实践

**【2】**李，金华&宋，史记&张，郁莉&周，甄。(2016).针对不完整数据的鲁棒 K-中值和 K-均值聚类算法。工程中的数学问题。2016.1–8.10.1155/2016/4321928.

ⓖ.k 模式

**【0】**曾永贺。K-模式聚类的近似算法

米盖尔·Á。魏冉·王·卡雷拉-佩皮尼昂。聚类的 K-modes 算法

**【2】**黄哲雪。k-Means 算法的扩展，用于聚类具有分类值的大型数据集

**【3】**夏尔马，n .和 n .高德。分类数据的 K-modes 聚类算法。国际计算机应用杂志127(2015):1–6。

**ⓗ.**k-原型

【0】【贾】、。(2020).基于混合相异系数的加权 k 原型聚类算法。工程中的数学问题。欣达维。

**【1】**黄哲雪。(1998).对 k-Means 算法的扩展，用于聚类具有分类值的大型数据集。数学和信息科学，邮政信箱 664 号，堪培拉，法案 2601，澳大利亚。

**【2】**黄，哲人。"对具有混合数值和分类值的大型数据集进行聚类。(1997)。

**【3】**Byoungwook Kim。(2017).使用部分距离计算的快速 K 原型算法。

ⓘ.克拉拉和克拉拉恩斯

**【0】**Erich Schubert，Peter J. Rousseeuw:更快的 k-Medoids 聚类:改进 PAM、CLARA 和 CLARANS 算法。相似性搜索及其应用。SISAP 2019:171–187https://doi.org/10.1007/978–3–030–32047–8 _ 16

**【1】**Ng、Raymond &韩、佳伟。(2002). CLARANS:一种用于空间数据挖掘的对象聚类方法。知识与数据工程。14.1003- 1016.10.1109/TKDE.2002

**【2】**维贾亚·萨格维卡尔，维迪亚·萨格维卡尔，卡尔帕娜·德鲁克卡尔。(2013).CLARANS 的性能评估:一种用于
空间数据挖掘的对象聚类方法。《普通高等教育发展条约》，第 2 卷第 6 期:第 1-8 页

ⓙ GMM。

**【0】**雷诺德(2009)高斯混合模型。载于:李世泽，贾恩(编)《生物识别百科全书》。马萨诸塞州波士顿斯普林格。https://doi.org/10.1007/978-0-387-73003-5_196

**【1】**笔记本: 1 高斯混合模型

**【2】**笔记本:习题——1D 高斯混合模型与期望最大化

ⓚ.数字万用表

**【0】**博客:狄利克雷过程高斯混合模型在各种 ppl 中的破棒构造

**【1】**幻灯片:狄利克雷过程混合模型的记忆化在线变分推断

**【2】**博客:用 Matplotlib 可视化狄利克雷分布

**【3】**博客:Ritchie Vink，用 Edward 和 Pymc3 中的 Dirichlet 混合对数据进行聚类。

ⓛ.数据库扫描

迈克尔·哈斯勒，马修·皮肯布洛克，德里克·多兰。 dbscan:基于密度的快速 R 聚类

埃里希·舒伯特、约格·桑德、马丁·伊斯特、汉斯-彼得·克里格尔和徐小薇。2017.DBSCAN 重温，重温:为什么和如何你应该(仍然)使用 DBSCAN。ACM Trans 数据库系统。42、3、第十九条(2017 年 7 月)，21 页。https://doi.org/10.1145/3068335

ⓜ. DENCLUE

欣内堡，a .和 h .加布里埃尔。"基于核密度估计的快速聚类."国际开发协会(IDA)(2007)。

ⓝ.光学

**【0】**安克斯特，米哈尔&布留尼格，马库斯&克里格尔，汉斯-彼得&桑德，约尔格。(1999).光学:对点进行排序，以识别聚类结构。西格蒙德记录。28.49–60.10.1145/304182.304187.

幻灯片:光学排序点识别聚类结构

17 每个数据科学家都必须知道代码块

原文：https://towardsdatascience.com/17-must-know-code-blocks-for-every-data-scientist-c39a607a844d?source=collection_archive---------7-----------------------

讨论将帮助您作为数据科学家有效处理大多数任务和项目的 17 个代码块

由 Pakata Goh 在 Unsplash 上拍摄的照片

Python 提供了一些简单而通用的代码，可以在最少的代码块中实现复杂的问题。虽然其他编程语言有更复杂的注释来解决特定的任务，但 Python 在大多数时候提供了更简单的解决方案。每个数据科学家都必须知道某些代码块，才能开始他们的数据科学和机器学习之旅。

重要的是要记住，一些代码行或特定的代码块总是可重用的，它们可以在多个程序中使用。因此，每个级别的程序员，包括初学者、中级程序员、高级或专家，都必须养成记住有用代码的习惯，以获得更快的解决方案。

在本文中，我们的主要目标是涵盖数据科学家经常使用的一些代码块，无论他们目前正在从事什么类型的项目、问题或任务。本文中展示的 17 个代码块在大多数任务中提供了很好的可重用性，只需很少或不需要修改。

虽然本文最初的重点和目标读者是初学数据的科学家，但其他从以前的编程语言转向 Python 的中级和高级数据科学爱好者会发现本文很有用。所以，事不宜迟，让我们开始探索这些代码块。

1.条件语句和迭代语句

def even(a):
    new_list = []
    for i in a:
        if i%2 == 0:
            new_list.append(i)
    return(new_list)

a = [1,2,3,4,5]
even(a)

条件语句和迭代语句是欢迎大多数用户使用他们的编程语言的代码。尽管这些元素是编码的最基本方面，但它们在机器学习和深度学习的数据科学相关任务中有着广泛的用途。没有这些代码块，几乎不可能执行最复杂的任务。

上面的代码块是一个简单的函数示例，它同时使用了条件 if 语句和 for 循环。for 循环遍历所有元素，if 语句检查偶数。虽然这个代码块只是一个简单的例子，但是用户必须记住其他几个实用程序选项。

2.列表

lst = ['one', 'two', 'three', 'four']
lst.append('five')
lst

列表是数据结构最重要的方面。大多数数据结构是以某种方式组织的不同数据元素的集合。列表有一些属性，使得它们可以用于开发人员处理的几乎每个项目或复杂任务中。列表的可变性允许它们根据特定的用例进行更改或修改。

对于任何程序，您都需要一个列表来存储一些与您正在执行的特定任务相关的信息或数据。为了在列表中存储额外的元素，您通常会在 for 循环旁边使用 append 语句来迭代特定的命令并相应地存储元素。要了解所有的概念和主列表，请查看下面提供的文章。

3.字典

# Dictionary with integer keys
my_dict = {1: 'A', 2: 'B'}
print(my_dict)

# Dictionary with string keys
my_dict = {'name': 'X', 'age': 10}
print(my_dict)

# Dictionary with mixed keys
my_dict = {'name': 'X', 1: ['A', 'B']}
print(my_dict)

我们要看的另一个重要的数据结构是字典。这种数据结构在大多数程序中也很有用。字典包含无序元素的集合。在这些字典的帮助下，您可以存储一个可以保存许多值的关键变量。当调用特定的键时，我们也可以访问它们各自的值。

字典很容易在任何程序中创建和存储。对于需要存储一对元素的各种任务，开发人员更喜欢这些数据结构。它们存储一对元素，即一个键和值。要了解更多关于字典的知识，请阅读下面这篇文章，它详细介绍了大部分方面。

4.中断并继续

a = [1,2,3,4,5]for i in a:
    if i%2 == 0:
        breakfor j in a:
    if j%2 == 0:
        continue

中断和继续操作是开发人员和程序员在计算任何与数据科学相关的复杂任务时必须牢记的两个最有用的组件。这些语句有助于终止循环或条件语句，或者通过跳过不必要的元素来继续操作。

上面显示的代码块是可以用这两条语句执行的大量任务的简单表示。如果遇到特定的变量或条件，并且想要结束循环，break 语句是该任务的正确选择。尽管输入了特定的条件或变量，但是如果您只想跳过特定的元素而继续整个操作，那么 continue 语句是您的最佳选择。

5.希腊字母的第 11 个

f = lambda x:x**2
f(5)

虽然普通函数使用 def 关键字，但它们更适合较大的代码块。然而，如果你想以最有效的时间和空间复杂度得到快速有效的结果，开发者必须考虑使用 lambda 函数。

lambda 函数计算一个值，并立即在一行代码中返回结果或输出解决方案。因此，每个开发人员都必须考虑使用 lambda 函数操作来简化代码，并相对容易和高效地执行适当的任务。

6.过滤器

a = [1, 2, 3, 4, 5]
even = list(filter(lambda x: (x%2 == 0), a))
print(even)

过滤条件用于简化大多数操作，在这些操作中，我们将删除所有不必要的元素，只保留最基本的、适合任务的必需元素。这个函数的有效性是因为任何复杂的任务都可以在一行或几行代码中解决。

在每个人都必须记住的第一个代码块中，我们讨论了一个打印所有偶数的例子。我们注意到我们使用了条件语句和迭代循环来处理下面的任务。然而，在上面的代码块中，我们可以执行同样的任务，在一行代码中只打印元素列表的偶数。

7.地图

a = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x ** 2, a))
print(squares)

map 是另一个独特的函数，它考虑给定数据结构中的所有基本元素，并相应地遍历它们。当为此操作提供参数时，它为提到的每个元素执行特定的操作。

map 函数可以总结为 Python 中的一个内置函数，它允许您处理和转换 iterable 中的所有项，而无需使用显式的 for 循环。上述代码块执行遍历所提供的列表并相应地生成所提供的每个元素的正方形的操作。

8.减少

from functools import reduce

a = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x*y, a)
print(product)

与前两个函数(即 filter()和 map())不同，reduce 函数的工作方式略有不同。它遍历可迭代数字列表，并继续返回一个值。为了使用这个函数，您将导入一个名为 functools 的附加模块，之后您可以继续使用 reduce 操作。

reduce 函数是我们将在本文中讨论的最后一个匿名函数。要探索更多关于高级函数的主题，并获得对这些概念的代码和示例的更直观的理解，请通过下面提供的链接查看我以前的一篇文章。

9.Numpy

import numpy as npX = np.array(X)
y = np.array(y)

y = to_categorical(y, num_classes=vocab_size)

Numerical Python 是计算数学问题的最佳库之一。开发人员和程序员可以在这个神奇的库的帮助下解决大量的问题和任务。您可以将带有整数元素的存储列表转换到 numpy 框架中，并开始对它们执行各种操作。

numpy 在各个领域都有大量的应用。在诸如计算机视觉这样的主题中，我们可以利用 numpy 数组来以 numpy 数组的形式可视化 RGB 或灰度图像，并相应地转换每个元素。在大多数开发的自然语言处理项目中，我们通常倾向于将文本数据转换成向量和数字的形式，以增加优化的计算。要执行下面的任务，您可以将 numpy 库作为 np 导入，然后将文本数据转换为分类数据，如上面的代码块所示。

10.熊猫

帕斯卡·米勒在 Unsplash 上的照片

import pandas as pddata = pd.read_csv("fer2013.csv")
data.head()

另一个你会不断利用来解释数据的机器学习库是熊猫的库。Pandas 是查看几乎任何格式数据的最佳库之一，尤其是 CSV 或 excel 文件。它在与机器学习项目中数据操作和数据分析相关的任务中具有特别的效用。

它处理与数据对齐、索引、切片和极大数据集的子集设置相关的大多数任务。该库以结构化格式提供了解决最复杂任务的高效工具。您可以简单地在一行代码中读取可用的数据，然后以方便的方式向用户解释这些数据。

11.Matplotlib

import matplotlib.pyplot as pltplt.bar(classes, train_counts, width=0.5)
plt.title("Bar Graph of Train Data")
plt.xlabel("Classes")
plt.ylabel("Counts")

条形图

最后一个几乎总是与 Numpy 和 Pandas 配对的机器学习算法是 matplotlib。这个库对于可视化非常有用。虽然其他两个库有助于以结构或数字的方式查看数据元素的各个方面，但 matplotlib 库有助于我们以可视化的表示形式涵盖这些方面。

拥有数据的可视化表示有助于我们在机器学习任务中执行探索性数据分析。有了这些分析方法，我们就能为解决某一特定问题找到合适的方向。代码块是以条形图的形式查看数据的表示。这种可视化是查看数据的常用技术。要了解更多考虑用于数据科学项目的可视化技术，请查看下面的文章，获取关于这方面的简明指南。

</8-best-visualizations-to-consider-for-your-data-science-projects-b9ace21564a>

12.正则表达式

import recapital = re.findall("[A-Z]\w+", sentence)
re.split("\.", sentence)
re.sub("[.?]", '!', sentence)
x = re.search("fun.", sentence)

正则表达式模块是 Python 中的一个预建库，它为开发人员提供了一些处理任何自然语言处理任务的最佳方法。它为用户提供了多种命令来简化用户可用的文本数据。在 re 库的帮助下，可以导入它对字母、单词、句子进行多种操作。

上面代码块中提到的四行代码是用户必须了解的一些最重要的正则表达式操作。要了解关于这个概念的更多信息，以及如何使用上述四种正则表达式操作来简化自然语言处理任务，请查看下面的文章。

13.自然语言处理工具包

import nltk

sentence = "Hello! Good morning."
tokens = nltk.word_tokenize(sentence)

虽然正则表达式操作非常适合处理自然语言处理项目的初级开发阶段，但使用另一个出色的库来有效地执行大多数任务(如词干化、标记化、词条化和其他类似操作)变得非常重要。由于有了自然语言处理工具包(NLTK)库，用户可以轻松地开发 NLP 项目。

NLTK 库是开发人员可以利用的最有用的工具之一，因为这个模块能够用几行代码简化最复杂的任务。这个库提供的大多数函数允许您在一行或几行代码中对文本数据执行复杂的调整。具有所提供输出的代码块中的上述示例就是一个这样的示例。

14。带枕头的图像

# Importing the required libraries
import numpy as np
from PIL import Image
import PIL# Opening and analyzing an image
image1 = Image.open('Red.png')
print(image1.format)
print(image1.size)
print(image1.mode)

对于有兴趣深入研究计算机视觉和图像处理领域的数据科学家来说，处理图像是一个重要的方面。Pillow 就是 Python 中的一个这样的库，它为用户处理图像和图片管理提供了巨大的灵活性。

在枕头库的帮助下，用户可以执行大量的任务。上面代码块中显示的例子将帮助用户打开指定路径的图像。当您在已知路径中打开特定图像时，您可以了解许多参数，如高度、宽度和通道数。您可以相应地管理和操作图像，并最终保存图像。

15.带有 Open-CV 的图像

import cv2 # Importing the opencv module

image = cv2.imread("lena.png") # Read The Image
cv2.imshow("Picture", image) # Frame Title with the image to be displayed 
cv2.waitKey(0)

Open-CV 是最好的库之一，开发人员在所有阶段都使用它来成功计算与图像、图片、视觉或视频相关的任务。该库用于大多数任务的计算，包括与实时网络摄像机操作相关的活动。该模块的整体可访问性和受欢迎程度使其成为大多数数据科学家的必备知识。

上面的代码块是一个简单的例子，用于将图像可视化到指定的目录路径。要了解更多信息，开始学习计算机视觉并掌握这个库的所有基本元素，我强烈建议查看我以前的一篇文章，其中包含了与计算机视觉相关的所有基础知识，以及几个代码和示例。

16.班级

class Derivative_Calculator:
    def power_rule(*args):
        deriv = sympy.diff(*args)
        return deriv
    def sum_rule(*args):
        derive = sympy.diff(*args)
        return derivdifferentiatie = Derivative_Calculator
differentiatie.power_rule(Derivative)

类是面向对象编程语言不可或缺的一部分。Python 利用类将数据和功能捆绑在一起。与其他编程语言相比，Python 中的类机制有点不同。它混合了 C++和 Modula-3 中的类机制。

类被广泛使用，甚至用于深度学习模型的开发。在编写张量流代码时，您可能希望创建一个自定义类来相应地定义您的模型。这种模型子类化方法被开发人员在最高阶段使用。如果您想了解以上代码块示例的更多信息，请查看下面这篇文章，它涵盖了简化机器学习数学的最佳库这一主题。

17.随意

import randomr = random.uniform(0.0,1.0)

Python 预先构建并提供的随机库是最重要的模块之一，它将帮助您完成大多数需要不确定性或一定程度随机性的任务。它们在大多数与机器学习问题中的预测相关的编程任务中有广泛的用途。

虽然人类在试图执行的大多数任务中更喜欢精确，但大多数计算机都有一个预测精确值的值范围。因此，随机变量和库是 Python 中最重要的元素，因为机器学习和深度学习项目需要用户指定最准确值所在的随机性范围。

结论:

迪安·普在 Unsplash 上的照片

*“任何傻瓜都能写出计算机能理解的代码。优秀的程序员会写出人类能理解的代码。”——*马丁·福勒

在任何编程语言中，与其他主题相比，有些方面你会更频繁地重新访问和重用。Python 编程语言也是类似的，因为我们有一些用户会比其他人更多使用的代码块，这正是我们在本文中试图涵盖的内容。虽然我们只讨论了一些元素，但是在 Python 编码的世界中还有许多其他的概念需要探索。

在本文中，我们讨论了每个数据科学开发人员和程序员在开始编码过程时必须牢记的 17 个代码块。只要记住这些简单的代码块或者知道它们的存在，就可以帮助你查找这些代码块，并为你当前正在计算的任何类型的任务找到最合适的解决方案。

如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。

看看我的其他一些文章，你可能会喜欢读！

</6-best-projects-for-image-processing-with-useful-resources-f860f3dfe977> </7-best-free-tools-for-data-science-and-machine-learning-3e630125f87e> [## 数据科学和机器学习的 7 个最佳免费工具

towardsdatascience.com](/7-best-free-tools-for-data-science-and-machine-learning-3e630125f87e) </6-best-programming-practices-f2605c5b469c>

谢谢你们坚持到最后。我希望你们都喜欢这篇文章。祝大家有美好的一天！

学习 Python 列表的 17 个快速示例

原文：https://towardsdatascience.com/17-quick-examples-to-learn-python-lists-196070a055c3?source=collection_archive---------9-----------------------

最常用的 Python 数据结构之一

穆里洛·维维亚尼在 Unsplash 上拍摄的照片

数据结构是程序的关键组成部分。它们以特定的方式保存或包含数据，以使程序更有效地工作。如何访问存储在数据结构中的数据也至关重要。

列表是 Python 中最常用的内置数据结构之一。列表能够存储不同数据类型的值，这使得它们非常有用。

有多种方法和函数可以应用于列表。我们应该掌握它们，以便在我们的节目中充分利用列表。处理数据的方式是创建高效程序的关键。

在本文中，我们将通过 17 个简单的例子来演示如何与 Python 列表进行交互和操作。让我们首先创建一个包含一些整数和字符串的简单列表。

mylist = [1, 2, 3, 4, 4, 4, 5, 5, 'a', 'b']

示例 1

count 方法返回列表中某项出现的次数。

mylist.count(4)
3mylist.count('a')
1

示例 2

pop 方法从列表中移除一项。默认情况下，它删除最后一项，但是我们可以指定要删除的项的索引。

mylist = [1, 2, 3, 4, 4, 4, 5, 5, 'a', 'b']mylist.pop()
'b'print(mylist)
[1, 2, 3, 4, 4, 4, 5, 5, 'a']

让我们用它来删除第二个项目。

mylist.pop(1)
2print(mylist)
[1, 3, 4, 4, 4, 5, 5, 'a']

示例 3

从列表中移除项目的另一个选项是 remove 方法。它要求指定要删除的项目，而不是其索引。

mylist = ['a', 'b', 'a', 'c', 'd', 'a']mylist.remove('a')print(mylist)
['b', 'a', 'c', 'd', 'a']

如果有多个项目具有相同的值，remove 方法将删除第一个匹配项。

实例 4

pop 和 remove 方法之间有一个重要的区别。pop 返回被移除的项，这样就可以将它赋给一个新的变量。另一方面，remove 方法不返回任何内容。

mylist = ['a', 'b', 'c', 'd']var_pop = mylist.pop()
var_remove = mylist.remove('a')print(var_pop)
dprint(var_remove)
None

实例 5

clear 方法删除了列表中的所有条目，所以我们最终得到了一个空列表。

mylist = ['a', 'b', 'c', 'd']mylist.clear()print(mylist)
[]

实例 6

我们可以使用 append 方法向列表中添加一个新项。

mylist = ['a', 'b', 'c', 'd']mylist.append(1)print(mylist)
['a', 'b', 'c', 'd', 1]

例 7

如果您试图将一个列表追加到另一个列表，追加的列表将是原始列表中的一个项目。

mylist = ['a', 'b', 'c', 'd']
myotherlist = [1, 2, 4]mylist.append(myotherlist)print(mylist)
['a', 'b', 'c', 'd', [1, 2, 4]]

如果要分别追加每一项，请使用 extend 方法。

mylist = ['a', 'b', 'c', 'd']
myotherlist = [1, 2, 4]mylist.extend(myotherlist)print(mylist)
['a', 'b', 'c', 'd', 1, 2, 4]

实施例 8

我们可以使用 list 构造函数根据字符串中的字符创建一个列表。

mylist = list("python")print(mylist)
['p', 'y', 't', 'h', 'o', 'n']

示例 9

reverse 方法可用于颠倒列表中项目的顺序。它就地执行反向操作，因此不返回任何内容。

mylist.reverse()print(mylist)
['n', 'o', 'h', 't', 'y', 'p']

实例 10

我们可以使用 sort 方法对列表中的项目进行排序。

mylist = ['g','a', 'c', 'd']
myotherlist = [4, 2, 11, 7]mylist.sort()
myotherlist.sort()print(mylist)
['a', 'c', 'd', 'g']print(myotherlist)
[2, 4, 7, 11]

实施例 11

默认情况下，sort 方法按升序排序。可以使用 reverse 参数进行更改。

mylist = ['g','a', 'c', 'd']
myotherlist = [4, 2, 11, 7]mylist.sort(reverse=True)
myotherlist.sort(reverse=True)print(mylist)
['g', 'd', 'c', 'a']print(myotherlist)
[11, 7, 4, 2]

实例 12

排序方法可以正常工作。因此，它修改原始列表，但不返回任何内容。如果你想更新原来的，但需要一个排序的版本，可以使用内置的排序函数。

mylist = ['g','a', 'c', 'd']
mysortedlist = sorted(mylist)print(mylist)
['g', 'a', 'c', 'd']print(mysortedlist)
['a', 'c', 'd', 'g']

原物不变。我们有一个新的列表，它是原始列表的排序版本。

实施例 13

我们已经看到了 append 方法，它用于向列表中添加一个新项。它会在末尾添加新项目。

插入方法提供了更多的灵活性。它允许为新项目指定索引。

mylist = [1, 2, 3, 4, 5]mylist.insert(2, 'AAA')print(mylist)
[1, 2, 'AAA', 3, 4, 5]

第一个参数是索引，第二个参数是要添加的项目。

实施例 14

内置的 len 函数返回列表中的项目数。

mylist = [1, 2, 3, 4, 5]len(mylist)
5

实施例 15

我们可以使用“+”操作符来组合多个列表。

first = [1, 2, 3, 4, 5]
second = [10, 11, 12]
third = [1, 'A']first + second + third
[1, 2, 3, 4, 5, 10, 11, 12, 1, 'A']

实施例 16

我们可以通过拆分一个字符串来获得一个列表。split 函数创建一个列表，其中包含拆分后的每个部分。

text = "Python is awesome"mylist = text.split(" ")print(mylist)
['Python', 'is', 'awesome']

我们指定用作分割点的字符，在我们的例子中是空格。

实例 17

列表理解是一种基于其他可重复项创建列表的技术。例如，我们可以基于另一个列表创建一个列表。

mylist = ["This", "is", "a", "great", "example"]newlist = [len(x) for x in mylist]print(newlist)
[4, 2, 1, 5, 7]

新列表包含原始列表中项目的长度。

列表理解是一个非常重要的话题。如果你想了解更多，这里有一篇关于列表理解的文章。

</11-examples-to-master-python-list-comprehensions-33c681b56212>

结论

列表是 Python 的核心数据结构之一。它们通常被用作程序的构建模块。因此，熟悉列表非常重要。

我们所做的例子几乎涵盖了 Python 列表的所有需求。剩下的只是练习。

感谢您的阅读。如果您有任何反馈，请告诉我。

每个程序员都应该知道的 17 个终端命令

原文：https://towardsdatascience.com/17-terminal-commands-every-programmer-should-know-4fc4f4a5e20e?source=collection_archive---------2-----------------------

改善您的日常工作流程

Goran Ivos 在 Unsplash 上拍摄的照片

大多数计算机用户通过图形用户界面进行交互，因为这是操纵机器的一种简单方式。尽管 GUI 应用程序在广大用户中仍然很受欢迎，但命令行界面通过运行文本命令给用户提供了对计算机的更多控制。这是一种与电脑互动的强大方式。例如，您可以运行文本命令来创建 100 个文件夹，但是通过 GUI 应用程序来实现相同的结果将花费更多的时间和精力。

mkdir test
cd test
for i in {1..100}
do
   mkdir "$i"
done

为了能够运行这些命令，我们需要使用终端应用程序。这个终端为你提供了外壳。Shell 是一个我们可以运行 shell 命令和 shell 脚本的环境。它允许我们控制命令行工具。macOS X 自带 bash shell(又是 Bourne shell)，但是你可以把你的 Shell 改成 csh (C shell)、zsh (Z shell)、ksh (Korn Shell)、tcsh (TENEX C Shell)等等。现在让我们来看看一些基本的 shell 命令，看看发生了什么。列出 macOS X 中所有可用的 shells。

cat /etc/shells

查看您运行的是哪个 shell。

echo $0

改为 bash shell。

chsh -s /bin/bash

要改成 zsh shell。

chsh -s /bin/zsh

根据您使用的 shell，您将获得不同的特性。我选择的贝壳是 zsh。从这篇文章中，您将学习一些基本的 shell 命令，通过节省时间和精力来改进日常工作流程。

1.显示当前工作目录

pwd命令代表打印工作目录。它将打印当前工作目录的完整路径。

pwd
# /Users/universe/Desktop

如果一个单词以# (hash)开头，shell 会忽略该行上的任何剩余字符。

# /Users/universe/Desktop

2.mkdir

mkdir命令代表制作目录。这里我们在我的桌面上创建一个名为neptune的目录。

mkdir neptune

我们可以使用-p选项创建多个目录。

mkdir -p space/neptune

上面的命令将创建一个名为space的文件夹和一个嵌套文件夹或子文件夹neptune。如果我们想在neptune下创建第三个文件夹naiad，我们可以使用下面的命令。我们不必为此命令提供-p选项，因为路径space/neptune已经存在。

mkdir space/neptune/naiad

3.激光唱片

cd命令代表改变目录。让我们使用这个命令来访问我们之前创建的space目录。

cd space
cd neptune
cd naiad

或者你可以使用下面的命令来访问naiad目录。

cd space/neptune/naiad

两个命令将产生相同的结果。现在我们应该在naiad目录中。

单周期和双周期

..(两个句点)表示或指向包含当前目录的目录，也称为父目录。这里naiad的父目录是neptune。让我们使用下面的命令在目录层次结构中向上移动一级。

pwd
# /Users/universe/Desktop/space/neptune/naiad
cd ..
pwd
# /Users/universe/Desktop/space/neptune

此外，我们可以移动到多个层次。在这种情况下，让我们向上移动 2 级。

cd ../..
pwd
# /Users/universe/Desktop

现在，我们回到了Desktop目录。

.(单句点)代表或指向当前工作目录。当我们在运行命令时不想写完整的路径时，这很有帮助。例如，如果我们的命令行工具在当前目录中，我们可以使用下面的命令。

./space-robot

~ (tilda)或$HOME代表或指向主目录。对于 macOS X，用户的主目录在/Users目录下。

cd ~
pwd
# /Users/universe
cd $HOME
pwd
# /Users/universe

通过使用这种简写方式，您不必键入主目录的完整路径。

此外，我们可以看到一个/(正斜杠)用于分隔路径名中的目录。通过使用下面的命令，我们可以移动到根目录。

cd /

4.触控

使用touch命令，我们可以创建一个文件。

cd ~/Desktop/neptune 
touch todo.txt

5.限位开关（Limit Switch）

ls命令代表列表。我们可以用它来列出指定目录的所有内容；如果没有指定路径，它将列出当前目录中的所有内容。

cd ~/Desktop/neptune
mkdir todo
ls
# todo     todo.txt

使用-a 标志列出隐藏的文件和目录。

ls -a

使用-l 标志列出详细信息。

ls -l

或者一起用。

ls -al

6.清楚的

我们已经写了一段时间的命令，所以让我们清除终端屏幕。

clear

7.平均变化

mv命令代表移动。我们可以使用这个命令将文件和目录从一个地方移动到另一个地方。此外，我们可以用它来重命名文件和目录。以下命令将把 todo.txt 文件从其当前目录移动到其子目录todo。

cd ~/Desktop/neptune
mv todo.txt todo/todo.txt

现在让我们重命名该文件。这里我们将 todo.txt 文件重命名为 my-todo.txt 。

cd todo
mv todo.txt my-todo.txt

8.丙酸纤维素

cp命令代表复制。现在，让我们将我们的 my-todo.txt 文件复制到父目录。

cd ~/Desktop/neptune
cp todo/my-todo.txt my-todo-bu.txt

我们可以使用-r标志来复制一个目录。下面的命令会将todo文件夹中的所有内容复制到一个名为bu的文件夹中。

cp -r todo bu

9.rm 和 rmdir

rm指令代表**移除，**和rmdir指令代表Remove Directory。rmdir命令只能删除空目录。现在让我们删除一个文件和目录。

cd ~/Desktop/neptune
rm my-todo-bu.txt
mkdir empty
rmdir empty

我们可以使用-r标志删除一个非空文件夹。

rm -r bu
rm -r todo

10. > < * ? [] ; $ \

>可用于重定向stdout(标准输出)。这里，我们将一个任务添加到我们的 todo.txt 文件中。echo命令将其参数写入标准输出。该>命令将覆盖已经存在的 todo.txt 。

cd ~/Desktop/neptune
echo 1\. Make space robot > todo_today.txt

如果我们想要追加数据，我们需要使用>>命令。

echo 2\. Make space robot v2 >> todo_today.txt

<可用于重定向stdin(标准输入)。这里，我们将 todo.txt 文件的内容重定向到wc命令，以打印行数、字数和字符数。

wc < todo_today.txt
#        2       9      43

*(星号)可以用作通配符来匹配零个或多个字符。

ls *.txt
# todo_today.txt

?(问号)可以用来匹配单个字符。

ls ????_?????.txt
# todo_today.txt

[](方括号)可以用来匹配其中任意数量的字符。

ls t[o]do_*.???
# todo_today.txt

;(分号)可用于在一行上写多个命令；我们所要做的就是用分号分隔每个命令。

cd ~/Desktop/neptune ; wc < todo.txt
#        2       9      43

$(美元)可以用来创造和储存价值。

echo $HOME
# /Users/universe
MyValue=99
echo $MyValue
# 99

\(反斜杠)可以用来转义一个特殊字符。

echo \$MyValue
# $MyValue
echo \$$MyValue
# $99

11.猫

cat命令代表连接。它将一个或多个文件的内容打印到 stdout。打印单个文件的内容。

cd ~/Desktop/neptune
cat todo.txt
# 1\. Make space robot
# 2\. Make space robot v2

打印多个文件的内容。

cd ~/Desktop/neptune
echo FILE 1 > file_1.txt
echo FILE 2 > file_2.txt
echo FILE 3 > file_3.txt
cat file_1.txt file_2.txt file_3.txt
# FILE 1
# FILE 2
# FILE 3

12.可做文件内的字符串查找

grep命令代表全局正则表达式打印。它在用给定搜索模式指定的文件中搜索文本。默认情况下，grep 区分大小写。对于案例激励搜索，我们可以使用-i标志。

cd ~/Desktop/neptune
grep "FILE" file_1.txt
# FILE 1
grep -i "file" file_1.txt
FILE 1

-r标志用于递归搜索目录。在这里，它将搜索当前目录及其子目录中的所有内容。

grep -r "FILE" .
# ./file_1.txt:FILE 1
# ./file_2.txt:FILE 2
# ./file_3.txt:FILE 3

还有其他有用的标志，比如-n标志将打印带有行号的匹配行，-c标志将打印匹配行的计数。

13. |

|命令或管道命令用于添加两个或更多命令，其中前一个命令的输出用作下一个命令的输入。

command_1 | command_2 | .................. | command_N

在这里，我们通过组合cat和sort命令，对 todo.txt 文件进行逆序排序。

cat todo.txt | sort -r
# 2\. Make space robot v2
# 1\. Make space robot

14.头和尾

命令head和tail可用于将文件内容打印到标准输出。标志-n用于定义我们想要输出多少行。现在，让我们打印文件的前 1 行。

cd ~/Desktop/neptune
head -n 1 todo.txt
# 1\. Make space robot

打印文件的最后一行。

tail -n 1 todo.txt
# 2\. Make space robot v2

处理大文件时，这些命令会很有用。

15.发现

find命令用于搜索文件。

find dir -name search_pattern

让我们找到当前目录中的所有文本文件。

cd ~/Desktop/neptune
find . -name "*.txt"
# ./file_1.txt
# ./todo.txt
# ./file_2.txt
# ./file_3.txt

16.打开

open命令可用于使用 Finder 应用程序打开文件和目录。

cd ~/Desktop/neptune
open .
open todo.txt

17.男人

最后，我们有man命令，代表手动。它打印命令的用户手册。

man cd

使用上下箭头键浏览文档。使用f键前进一页，使用b键后退一页——按q退出。

恭喜你！现在你知道了所有这些很酷的 shell 命令，它们将帮助你节省时间和精力。你可以在我的 GitHub 上找到我讨论过的所有 shell 命令。编码快乐！

数据科学中使用的 17 种相似和相异度量。

原文：https://towardsdatascience.com/17-types-of-similarity-and-dissimilarity-measures-used-in-data-science-3eb914d2681?source=collection_archive---------0-----------------------

下面的文章解释了计算距离的各种方法，并展示了它们在我们日常生活中的实例。此外，它将向您介绍 pydist2 包。

各种 ML 指标。灵感来自马腾 Grootendorst 。

"几何学没有捷径可走。"— 欧几里得

快速注释:所有文字和图像均由作者创作，除非另有说明。使用 Matplotlib、Tex、Scipy、Numpy 等工具生成插图和方程，并使用 GIMP 进行编辑。

🄰 .简介:

相似性和不相似性:

在数据科学中，相似性度量是一种衡量数据样本如何相互关联或接近的方法。另一方面，相异度度量是为了告诉数据对象有多少不同。此外，当相似的数据样本被分组到一个聚类中时，这些术语经常在聚类中使用。所有其他数据样本被分组为不同的样本。它还用于分类(例如 KNN)，其中数据对象基于特征的相似性进行标记。另一个例子是当我们谈论与其他数据样本相比的不同异常值时(例如，异常检测)。

相似性度量通常表示为一个数值:当数据样本更相似时，它变得更高。它通常通过转换表示为 0 和 1 之间的数字:0 表示低相似性(数据对象不相似)。一个意味着高度相似(数据对象非常相似)。

举个例子，每个数据点只包含一个输入要素。这可以被认为是显示三个数据点 A、B 和 c 之间不相似性的最简单示例。每个数据样本在一个轴上可以有一个值(因为我们只有一个输入要素)；让我们把它记为 x 轴。我们来取两点，A(0.5)，B(1)，C(30)。可以看出，与 C 相比，A 和 B 彼此足够接近。因此，A 和 B 之间的相似性高于 A 和 C 或 B 和 C。换句话说，A 和 B 具有很强的相关性。因此，距离越小，相似度就越大。

指标:

当且仅当满足以下四个条件时，给定的距离(例如，相异度)才意味着是度量:

1-非负: d(p，q) ≥ 0，对于任意两个不同的观测值 p 和 q

2-对称: d(p，q) = d(q，p)对于所有的 p 和 q。

3-三角形不等式: d(p，q) ≤ d(p，r) + d(r，q)对于所有 p，q，r。

仅当 p = q 时，d(p，q) = 0

距离度量是分类的基本原则，就像 k 近邻分类算法一样，它度量给定数据样本之间的不相似性。此外，选择距离度量将对分类器的性能有很大影响。因此，计算对象之间距离的方式将在分类器算法的性能中起着至关重要的作用。

🄱 .距离函数:

用于测量距离的技术取决于您正在处理的特定情况。例如，在某些领域，欧几里得距离对于计算距离可能是最佳的和有用的。其他应用程序需要更复杂的方法来计算点之间的距离或观察值，如余弦距离。以下列举的列表代表了计算每一对数据点之间距离的各种方法。

⓪. L2 范数，欧几里得距离。

欧几里德轮廓。

用于数值属性或要素的最常见的距离函数是欧几里德距离，它在以下公式中定义:

n 维空间中两点之间的欧氏距离。

如你所知，这种距离度量表示众所周知的性质，如对称、可微、凸、球形…

在二维空间中，前面的公式可以表示为:

二维空间中两点之间的欧几里得距离。

它等于直角三角形斜边的长度。

此外，欧几里得距离是一种度量，因为它满足其标准，如下图所示。

欧几里得距离满足成为度量的所有条件。

此外，使用该公式计算的距离代表每对点之间的最小距离。换句话说，这是从 A 点到 B 点(二维笛卡尔坐标系)的最短路径，如下图所示:

欧几里德距离是最短的路径(不包括量子世界中虫洞的情况)。

因此，当您想要在路径上没有障碍物的情况下计算两点之间的距离时，使用此公式非常有用。这可以被认为是你不想计算欧几里德距离的情况之一；相反，您希望使用其他度量，如曼哈顿距离，这将在本文的后面解释。

欧几里德距离不能给我们有用信息的另一种情况是，飞机的飞行路径遵循地球的曲率，而不是一条直线(除非地球是平的，但事实并非如此！).

然而，在进一步深入之前，让我们解释一下如何在机器学习的环境中使用欧几里德距离。

最著名的分类算法之一，KNN 算法，可以从使用欧氏距离对数据进行分类中获益。为了演示 KNN 如何使用欧几里德度量，选择了来自 Scipy 包的流行虹膜数据集。

正如你可能知道的，这个数据集包含三种花:鸢尾-刚毛鸢尾、鸢尾-杂色鸢尾和鸢尾-海滨鸢尾，具有以下四个特征:萼片长度、萼片宽度、花瓣长度、花瓣宽度。因此，我们有一个 4 维空间，每个数据点都可以用。

两种花在两个特征空间的虹膜数据集。

出于简单和演示的目的，让我们只选择两个特征:花瓣长度、花瓣宽度和排除 Iris-virginica 数据。这样，我们可以在二维空间中绘制数据点，其中 x 轴和 y 轴分别代表花瓣长度和花瓣宽度。

训练数据集。

每个数据点都有自己的标签:Iris-Setosa 或 Iris-versicolor(数据集中的 0 和 1)。因此，该数据集可用于 KNN 分类，因为其本质上是一种受监督的最大似然算法。假设我们的最大似然模型(KNN，k = 4)已经在这个数据集上进行了训练，我们已经选择了两个输入要素和仅仅二十个数据点，如前面的图表所示。

到目前为止，一切看起来都很好，我们的 KNN 分类器已经准备好分类一个新的数据点。因此，我们需要一种方法来让模型决定新数据点可以分类到哪里。

预测新数据点的标签。

你可能会想，欧几里德距离已经被选择来让每个训练的数据点投票决定新数据样本适合的位置:Iris-Setosa 或 Iris-versicolor。因此，已经计算了从新数据点到我们的训练数据的每个点的欧几里德距离，如下图所示:

当 k = 4 时，KNN 分类器要求选择最小的四个距离，这四个距离表示从新点到以下点的距离:点 1、点 5、点 8 和点 9，如图所示:

四个邻居投票给 Iris-Setosa。

因此，新的数据样本被归类为鸢尾属。用这个类比，可以想象更高维度和其他分类器。希望你明白了！

如前所述，每个域都需要一种特定的距离计算方法。随着本文的深入，您将会发现这样表述的含义。

➀.平方欧几里德距离。

使用这种方法计算距离避免了使用平方根函数的需要。顾名思义，SED 等于欧几里德距离的平方。因此，在计算观测值之间的距离时，SED 可以减少计算工作。例如，它可以用于聚类、分类、图像处理和其他领域。

n-D 空间中两点之间的平方欧几里得距离。

②. L1 标准、城市街区、曼哈顿或出租车距离。

曼哈顿轮廓。

这一指标在测量给定城市中两条街道之间的距离时非常有用，距离可以通过分隔两个不同地点的街区数量来测量。例如，根据下图，A 点和 B 点之间的距离大约等于 4 个街区。

现实世界中的曼哈顿距离

创建此方法是为了解决在给定的城市中计算源和目的地之间的距离，在该城市中，几乎不可能沿直线移动，因为建筑物分组到网格中，阻挡了直线路径。因此得名城市街区。

你可以说 A 和 B 之间的距离是欧几里得距离。但是，正如你可能注意到的，这个距离是没有用的。例如，您需要有一个有用的距离来估计旅行时间或您需要驾驶多长时间。相反，如果您有使用街道的最短路径，它会有所帮助。所以这取决于你如何定义和使用距离的情况。

在 n 维空间中，曼哈顿距离表示为:

n-D 空间中两点之间的曼哈顿距离。

对于二维网格，前面的公式可以写成:

二维空间中两点之间的曼哈顿距离。

回想一下前面的 KNN 示例，计算从新数据点到训练数据的曼哈顿距离将产生以下值:

KNN 使用曼哈顿距离分类(平局！)

正如你所看到的，两个数据点投票给 Iris-Setosa，另外两个数据点投票给 Iris-versicolor，这意味着平局。

曼哈顿距离:平手！

我想你可能在什么地方遇到过这个问题。直观的解决方案是改变 k 的值，如果 k 大于 1，则减少 1，否则增加 1。

但是，对于前面的每个解决方案，您将获得不同的 KNN 分类器行为。例如，在我们的例子中，k=4。将其更改为 k=3 将导致以下值:

将 k 减一。

这种花被归类为鸢尾花。同样，将其更改为 k=5 会产生以下值:

将 k 增加 1。

这种花被归类为鸢尾。所以，由你来决定是否需要增加或减少 k 的值。

然而，有人会说，如果度量标准不是问题的约束，你可以改变它。例如，计算欧几里德距离可以解决这个问题:

改变距离度量也会打破平局。

这种花被归为鸢尾属。

在我看来，如果您不必改变曼哈顿距离并对 k 使用相同的值，添加新的维度或特征(如果可用)也会打破这种束缚。例如，添加萼片宽度作为新的维度将导致以下结果:

向模型添加新特征。

这种花被归类为鸢尾花。

这是三维空间的图，其中 x 轴、y 轴和 z 轴分别代表萼片宽度、花瓣长度和花瓣宽度:

虹膜数据集的三维图。

计算曼哈顿距离在计算上比前两种方法更快。如公式所示，它只需要加法和减法，这比计算平方根和 2 的幂要快得多。

如果你曾经下过国际象棋，曼哈顿距离被象用来在两个相同颜色的水平或垂直方块之间移动:

毕晓普用的是曼哈顿距离(如果没看到，就把棋盘旋转 45°想象一下)。

换句话说，让主教越过红色方块所需的移动次数(距离)等于曼哈顿距离，也就是两次。

除此之外，如果数据存在许多异常值，曼哈顿距离将优于欧几里德距离。

此外，L1 范数给出了比 l2 范数更稀疏的估计。

除此之外，L1 范数和 L2 范数通常用于神经网络的正则化，以最小化权重或清除某些值，就像 lasso 回归中使用的一样。

套索和岭回归的约束区域的形式(来源:维基百科)。

如上图所示，L1-诺姆试图将 W1 的权重归零，并将另一个权重最小化。然而，L2 范数试图最小化 W1 和 W2 权重(如 W1 = W2)。

与此同时，我不希望这篇文章深入正则化，因为它的主要目标是解释常见的距离函数，同时在这里和那里说明一些用法，并使它尽可能容易理解。因此，让我们继续前进。

③.堪培拉距离。

它是曼哈顿距离的加权版本，用于聚类，如模糊聚类、分类、、计算机安全和垃圾邮件检测系统。与之前的度量相比，它对异常值更鲁棒。

堪培拉距离。

④. L∞范数，切比雪夫距离，最大距离。

切比雪夫等高线。

两个 n-D 观测值或向量之间的切比雪夫距离等于数据样本坐标之间变化的最大绝对值。在二维世界中，数据点之间的切比雪夫距离可以被确定为它们的二维坐标的绝对差之和。

两点 P 和 Q 之间的切比雪夫距离定义为:

切比雪夫距离

切比雪夫距离是一个度量，因为它满足成为度量的四个条件。

切比雪夫距离满足作为度量的所有条件。

但是，您可能想知道 min 函数是否也可以是一个度量！

min 函数不是度量，因为有一个反例(如水平线或垂直线)其中 d(A，B) = 0 和 A！= B .但是，只有当 A = B 时，它才应该等于零！！！！

你能想到的使用切比雪夫指标的一个用例是交易股票，加密货币的特征是交易量、出价、要价……例如，你需要找到一种方法来判断最大的加密货币，它的回报和损失之间有很大的差距。事实证明，切比雪夫距离非常适合这种特殊情况。

棋盘中使用切比雪夫距离的另一种常见情况是，国王或王后的移动次数等于到达相邻方格的距离，如下图所示:

国王利用切比雪夫距离四处走动。

女王使用切比雪夫距离的一些广场。

⑤. Lp 范数，Minkowski 距离。

不同 p 值的闵可夫斯基等高线。

闵可夫斯基距离只是以前的距离度量的概括:欧几里德、曼哈顿和切比雪夫。它被定义为 n-D 空间中两次观测之间的距离，如下式所示:

闵可夫斯基距离。

其中 P，Q 是两个给定的 n-D 点，P 代表闵可夫斯基度量。对于特定的 p 值，您可以得出以下指标:

p = 1: 曼哈顿距离。
p = 2: 欧氏距离。
**p → +∞ 😗* 切比雪夫距离，逻辑 OR(点 D = A 或 B = 1 或 1 = 1)。
p → 0: 逻辑与(点 C = A 和 B =零)。
**p → -∞ 😗* 最小距离(D 点的对称)。

⑥.余弦距离。

这种度量广泛用于文本挖掘、自然语言处理和信息检索系统。例如，它可以用来测量两个给定文档之间的相似性。它还可以用于根据邮件的长度来识别垃圾邮件。

余弦距离可以按如下方式测量:

余弦距离。

其中 P 和 Q 代表两个给定点。这两个点可以表示文档中单词的频率，这将在下面的示例中解释。

让我们以包含以下短语的三个文档为例:

文档 A: “我喜欢早上喝咖啡。”
文档 B:“我喜欢喝咖啡。”
文档 C: “我和我的朋友在家乡的一家咖啡店工作。他早上会讲一些有趣的笑话。我们喜欢以每人喝杯茶开始新的一天。”

计算每个单词的出现频率将得到以下结果:

单词的频率。

在计算出现次数之前，您已经先验地知道文档 A 和 B 在含义上非常相似:“我喜欢喝咖啡。”然而，文档 C 包含文档 A 的所有单词，但是从频率表来看，它们的意思非常不同。为了解决这个问题，你需要计算余弦相似度来确定它们是否相似。

另一方面，这可以说明信息检索或搜索引擎是如何工作的。将文档 A 想象成对给定源(图像、文本、视频……)的查询(短消息)，文档 C 想象成需要获取并返回作为查询响应的网页。

另一方面，欧几里德距离不能给出短文档和大文档之间的正确距离，因为在这种情况下它会很大。使用余弦相似性公式将计算两个文档在方向上的差异，而不是在大小上的差异。

为了说明这一点，让我们看下面两个文档:

文件 A: “比特币比特币比特币钱”
文档 B: “货币货币比特币比特币”

让我们用“比特币”这个词作为 x 轴，用“货币”这个词作为 y 轴。这意味着文档 A 可以表示为向量 A(3，1)，文档 B 可以表示为 B(2，2)。

计算余弦相似度将得到以下值:

计算余弦相似度

余弦相似度= 0.894 意味着文档 A 和 B 非常相似。cos(角度)大(接近 1)意味着角度小(26.6)，两个文档 A 和 B 彼此接近。

但是，您不能将余弦相似度的值解释为百分比。例如，值 0.894 并不意味着文档 A 是 89.4%，与 B 相似。它意味着文档 A 和 B 非常相似，但我们不知道百分比是多少！该值没有阈值。换句话说，您可以将余弦相似度的值解释如下:

它越大，文档 A 和 B 越有可能相似，反之亦然。

让我们再举一个关于 A(1，11)和 B(22，3)的例子

计算余弦相似度

然而，欧几里德距离会给出一个像 22.4 这样的大数字，它不能说明向量之间的相对相似性。

另一方面，余弦相似性也适用于更高的维度。

余弦相似性的另一个有趣的应用是 OpenPose 项目。

祝贺🎆！你已经成功了一半🏁。继续下去🏃！

⑦.皮尔森相关距离。

相关距离量化了两个属性之间的线性单调关系的强度。此外，它使用协方差值作为初始计算步骤。然而，协方差本身很难解释，并且不能显示数据与代表测量值之间趋势的线有多近或多远。

为了说明相关性的含义，让我们回到 Iris 数据集，绘制 Iris-Setosa 样本，以显示两个特征之间的关系:花瓣长度和花瓣宽度。

Iris-Setosa 样本的两个特征的测量。

如下图所示，对同一花卉样本的两个特征的样本均值和方差进行了估计。

一般来说，我们可以说花瓣长度值相对较低的花，其花瓣宽度值也相对较低。花瓣长度值相对较高的花也具有相对较高的花瓣宽度值。此外，我们可以用一行来总结这种关系。

样本均值和方差估计。

这条线代表花瓣长度和花瓣宽度同时增加的积极趋势。

协方差值可以对三种类型的关系进行分类:

三种类型的相关性。

可以使用以下公式计算相关距离:

⑧.斯皮尔曼对射。

像皮尔逊相关一样，斯皮尔曼相关也用于双变量分析。然而，与皮尔逊相关不同，斯皮尔曼相关用于两个变量都是排序的情况。它可用于分类属性和数字属性。

虹膜数据集的相关矩阵。

Spearman 相关指数可使用以下公式计算:

斯皮尔曼相关系数。

Spearman 相关常用于假设检验。

⑨ 。Mahalanobis 距离。

它是一种度量标准，主要用于多元统计测试，在这种测试中，欧几里得距离不能给出观察值之间的真实距离。它衡量一个数据点离分布有多远。

两个点具有相同的平均值。

如上图所示，红色和蓝色点与平均值的欧氏距离相同。然而，它们不属于同一区域或集群:红点更有可能与数据集相似。但是蓝色的被认为是异常值，因为它远离代表数据集中最大可变性方向的线(主轴回归)。因此，引入了 Mahalanobis 度量来解决这个问题。

Mahalanobis 度量试图减小两个要素或属性之间的协方差，也就是说，您可以将先前的图重新缩放到新的轴中。并且这些新的轴表示像前面所示的第一特征向量一样的特征向量。

特征向量的第一方向极大地影响了数据分类，因为它具有最大的特征值。此外，数据集沿着这个方向比沿着另一个垂直方向扩展得更多。

使用这种技术，我们可以沿着这个方向缩小数据集，并围绕平均值(PCA)旋转它。然后，我们可以使用欧几里德距离，它根据前面两个数据点之间的平均值给出不同的距离。这就是马哈拉诺比斯度规的作用。

两个物体 P 和 q 之间的距离。

其中 C 表示属性或特征之间的协方差矩阵。

为了演示该公式的用法，让我们根据上一个相关距离部分的示例来计算 A(1.2，0.6)和 B (3.0，1.2)之间的距离。

现在让我们评估协方差矩阵，其定义如下:

二维空间中的协方差矩阵

其中，Cov[P，P] = Var[P]，Cov[Q，Q]= Var[Q]，以及

两个特征之间的协方差公式。

因此，两个物体 A 和 B 之间的马氏距离可以计算如下:

马哈拉诺比斯距离示例。

除了其使用案例，Mahalanobis 距离还用于霍特林 t-square 测试。

⑩.标准化欧几里德距离。

标准化或规范化是在构建机器学习模型时的预处理阶段使用的技术。数据集显示了最小和最大要素范围之间的巨大差异。当聚类数据时，这种比例距离会影响 ML 模型，导致错误的解释。

例如，让我们考虑这样一种情况，我们有两个不同的特征，它们在范围变化上有很大的差异。例如，假设我们有一个从 0.1 到 2 变化的特征和另一个从 50 到 200 变化的特征。使用这些值计算距离会使第二个要素更占优势，从而导致不正确的结果。换句话说，欧氏距离将受到具有最大值的属性的极大影响。

这就是为什么标准化是必要的，以便让特性以平等的方式做出贡献。这是通过将变量转换为所有变量都具有相同的方差(等于 1)并集中平均值周围的特征来实现的，如下式所示:

z 分数标准化。

标准化欧几里德距离可以表示如下:

标准化欧几里德距离。

我们可以用这个公式来计算 A 和 b 之间的距离。

⑪.驰 - 方距离:

卡方距离通常在计算机视觉中使用，同时进行纹理分析，以便找到归一化直方图之间的相似性(不相似)，这被称为“直方图匹配”。

直方图匹配。来源:维基百科

人脸识别算法就是一个很好的例子，它使用这个度量来比较两个直方图。例如，在新面孔的预测步骤中，该模型根据新捕获的图像计算直方图，将其与保存的直方图(通常存储在. yaml 文件中)进行比较，然后尝试找到与之最匹配的直方图。这种比较是通过计算 n 个箱的每对直方图之间的卡方距离来进行的。

卡方距离

如您所知，此公式不同于标准正态分布的卡方统计检验，在卡方统计检验中，使用以下公式来决定是保留还是拒绝零假设:

卡方检验公式。

其中 O 和 E 分别代表观察到的和预期的数据值。

为了说明如何使用，我们假设对 1000 人进行了一项调查，以测试特定疫苗的副作用，并查看是否存在基于性别的显著差异。因此，每个人可以是四个类别之一:

1- 男性无副作用。

2- 有副作用的男性。

3- 女性无副作用。

4- 有副作用的女性。

无效假设是:两种性别的副作用没有显著差异。

为了保留或拒绝此假设，您需要计算以下数据的卡方检验值:

收集的数据。

将这些值代入卡方检验公式，将得到 1.7288。

使用自由度等于 1 的卡方表，您将得到 0.2 和 0.1 之间的概率> 0.05 →您保留原假设。

注意自由度=(列数-1) x(行数-1)

此外，我只是想让你们快速回顾一下假设检验。希望对你有帮助。无论如何，让我们继续前进。🏃🏃🏃

⑫.詹森-香农距离。

Jensen-Shannon 距离计算两个概率分布之间的距离。它使用 Kullback Leibler 散度(相对熵)公式来计算距离。

詹森-香农距离。

其中 R 是 P 和 q 的中点。

此外，关于如何解释熵的值，简单提一下:

事件 A 的低熵意味着对该事件将发生的高知晓度；换句话说，如果事件 A 将要发生，我不那么惊讶，我非常有信心它会发生。同样的类比适用于高熵。

另一方面，Kullback Leibler 散度本身不是距离度量，因为它不是对称的: D(P || Q)！= D(Q | | P)。

⑬.莱文斯坦距离

衡量两个字符串之间相似性的度量。它等于将一个给定的字符串转换成另一个字符串所需的最小操作数。有三种类型的操作:

替换。
插入
删除

对于 Levenshtein 距离，替代成本是两个单位，另两个操作是一个单位。

例如，让我们取两个字符串 s= "Bitcoin "和 t = "Altcoin "。要从 s 到 t，你需要用字母“A”和“l”两次替换字母“B”和“I”。因此，d(t，s) = 2 * 2 = 4。

Levenshtein 距离有许多用例，如垃圾邮件过滤、计算生物学、弹性搜索等等。

⑭.汉明距离。

汉明距离等于相同长度的两个码字不同时的位数。在二进制世界中，它等于两个二进制消息之间的不同位数。

例如，两条消息之间的汉明距离可以通过下式计算:

汉明距离。

你可能注意到了，它看起来像分类数据上下文中的曼哈顿距离。

对于长度为 2 位的消息，此公式表示分隔两个给定二进制消息的边数。它最多可以等于 2。

2 位代码字。

同样，对于长度为 3 位的消息，该公式表示分隔两个给定二进制消息的边数。最多可以等于三。

3 位代码字。

让我们举一些例子来说明如何计算汉明距离:

H(100001，010001) = 2

H(110，111) = 1

如果其中一个消息包含全零，则汉明距离称为汉明重量，等于给定消息中非零数字的数量。在我们的例子中，它等于 1 的总数。

H(110111，000000) = W (110111) = 5

如果可能的话，汉明距离用于检测和纠正在不可靠的噪声信道上传输的接收消息中的错误。

⑮.Jaccard/Tanimoto 距离。

用于测量两组数据之间相似性的度量。有人可能会说，为了度量相似性，要计算大小(基数，元素的数量。)两个给定集合的交集。

然而，仅仅是公共元素的数量并不能告诉我们它与集合的大小相比有多相关。因此 Jaccard 系数背后的直觉。

所以 Jaccard 建议，为了测量相似性，你需要用交集的大小除以两组数据的并集的大小。

雅克卡距离。

Jaccard 距离是 Jaccard 系数的补充，用于测量数据集之间的差异，计算公式如下:

Jaccard 距离 T3。

下图解释了如何将该公式用于非二进制数据。

Jaccard 索引示例。

对于二进制属性，使用以下公式计算 Jaccard 相似性:

二进制数据索引。

Jaccard 索引在语义分割、文本挖掘、电子商务和推荐系统等领域非常有用。

现在你可能在想:“好吧，但是你刚才提到余弦距离也可以用在文本挖掘中。对于给定的聚类算法，您更喜欢使用什么作为度量？这两个指标的区别是什么？”

很高兴你问了这个问题。为了回答这个问题，我们需要比较两个公式的每一项。

雅克卡和余弦公式。

这两个公式的唯一区别是分母项。不是用 Jaccard 计算两个集合之间的并集的大小，而是计算 P 和 q 之间的点积的大小。你在计算余弦公式中两者的乘积。我不知道对此的解释是什么。据我所知，点积给出了一个向量向另一个向量的方向移动了多少。除此之外，如果你有什么要补充的，我非常感激能在下面的评论中读到你的想法。

⑯.索伦森-骰子。

索伦森-骰子距离是一种统计指标，用于衡量数据集之间的相似性。它被定义为 P 和 Q 的交集大小的两倍，除以每个数据集 P 和 Q 中的元素之和。

索伦森-骰子系数。

像 Jaccard 一样，相似性值的范围是从零到一。然而，与 Jaccard 不同，这种相异度不是度量，因为它不满足三角形不等式条件。

sorensen–Dice 用于词典编纂、图像分割和其他应用。

🄲.Pydist2。

在过去的几周里，当我在研究相似性和非相似性度量时，我认为用 python 重新实现这些类型的度量作为编码实践是一个有趣/伟大的想法。我从 Matlab 编写的 Piotr Dollar 的工具箱 repo 中获得灵感，也可以在 MathWorks 网站上找到。因此，pydist2 是一个 python 包，1:1 代码采用了 pdist 和 pdist2 Matlab 函数，用于计算观测值之间的距离。pydist2 当前支持的距离测量方法列表可在阅读文档获得。

🄳.结论。

万岁！！！您刚刚到达这篇文章的结尾。希望您在这一点上没有被它的内容弄得不知所措，我尽量使它简洁明了。

在本文中，您了解了数据科学中使用的不同类型的指标，以及它们在许多领域中的应用。

对我来说，写这篇文章是我数据科学之旅中的一次愉快经历。它可以强调这样一个事实，即在编写我的第一个 python 包: pydist2 时，我花费了无数的时间来研究和探索数据科学和机器学习的数学分支，并练习我的编码技能。

如果你想为这个项目做贡献，我非常欢迎在 pydist2 repo 上看到你的拉动请求。如果你想有所贡献，你可以看看这个教程。

如果你在阅读这篇文章时发现了错误，请在下面的评论中提出来，以便改进内容。

如果您有任何建议，请在 LinkedIn 上给我留言或给我发电子邮件。

如果您想使用本文中的任何内容，请将其引用为:

Mahmoud Harmouch,《数据科学中使用的 17 种相似和相异度量》, medium.com。2021 年 3 月 14 日

如果我的分析技能说服了您，并且您想了解更多，那么关注我和/或分享这篇文章将有助于我在数据科学社区中获得曝光率，并传播有用的信息。

今天的博客就到这里。祝您在自己的数据科学之旅中好运！感谢阅读，下期再见！

18 种常见的 Python 反模式，我希望我以前就知道

原文：https://towardsdatascience.com/18-common-python-anti-patterns-i-wish-i-had-known-before-44d983805f0f?source=collection_archive---------0-----------------------

你可以从阅读糟糕的代码中学到和阅读好的代码一样多的东西

在 Unsplash 上的照片

我已经用 python 编码六年多了，直到现在，我还在学习新的概念和良好的实践来提高我的代码质量。

刚开始时，弄清楚如何做事并不容易:我不得不艰难地学习。

在这篇文章中，我决定列出 18 个反模式和最糟糕的 python 实践，我希望我以前就知道:这可能会节省你一些时间，让你在调试项目时加快速度。

这个列表是基于与 python 开发人员、编程专家的讨论以及对 Reddit 线程的深入研究。
但这不是一个详尽的列表:如果你想更深入地挖掘这个话题(一个有趣的话题，我发誓),我在最后提供了一些链接。

现在让我们看一看🚀

在开始之前，什么是反模式？

反模式是软件开发中某些被认为是糟糕的编程实践的模式。

与设计模式相反，设计模式是解决常见问题的常见方法，已经被形式化，并被普遍认为是一种良好的开发实践，反模式则相反，不受欢迎。

反模式使得代码难以阅读，难以维护，速度慢，过度设计，不稳定，容易出错，并有潜在的安全问题。

引入反模式有很多原因:

缺少代码审查
当简单的事情可能达到目的时，愿意尝试“酷”的东西
没有使用正确的工具(遵循 PEP8 约定的代码链接器和格式化器、文档字符串生成器、支持自动完成的 ide 等等)
或者只是不知道更好的选择，只要你学习和成长，这是好的

反模式可以分为一个或多个类别:

正确性:反模式会破坏你的代码或者让它做错误的事情。
可维护性:使你的代码难以维护或扩展的反模式。
可读性:反模式会使你的代码难以阅读或理解。
性能:会不必要地降低代码速度的反模式。
安全:会给你的程序带来安全风险的反模式

现在让我们看看这 18 个反模式的列表。他们中的一些人将属于一个或多个类别。

1 —使用非显式变量名

你的变量名应该总是描述性的，以提供一个最小的上下文:变量名应该用文字告诉你变量代表什么。

这使得代码对于其他开发人员来说更容易理解，对于您来说也更容易调试。

小费👉:不要害怕使用长变量名来进行描述:现代的 ide 如 VSCode 和 Pycharm 提供了快速的自动完成功能。

2-忽略注释

未记录的代码是一场噩梦。这些人可能会抱怨:

6 个月后你会忘记为什么要写那行代码
你的任何同事谁将接管这个项目

代码应该总是清楚它在做什么，注释应该阐明你为什么这样做。同时，注释代码时要简洁。当您的代码不言自明时，就不需要注释。

小费👉:如果您正在使用 VSCode，那么您可以使用这个扩展来加速生成 docstrings，它会自动为您的类和函数生成一个注释模板。

作者图片

3 —忘记更新评论

与代码相矛盾的注释比没有注释更糟糕。

这种情况发生的比你想象的更频繁:当你很匆忙，不得不修复一个损坏的产品代码时，你会没有时间去更新旧的注释。

一个过时的注释会误导每个从事代码工作的人。

总有时间更新评论。

4-在函数名中使用 CamelCase

这更多的是一种约定:PEP 8 风格指南建议函数名应该总是小写，单词之间用下划线隔开。

5-不直接迭代迭代器的元素

这是一种非常常见的反模式。如果不需要的话，不一定需要在迭代器中迭代元素的索引。您可以直接迭代元素。

这使得你的代码更有 pythonic 风格。

6-当您同时需要元素及其索引时，不使用枚举

当在迭代器上迭代时需要同时访问一个元素及其索引时，使用enumerate。

7-不使用 zip 迭代列表对

zip是一个有用的内置函数，它允许你从两个迭代器中创建一个元组列表。每个元组的第一个元素来自第一个迭代器，而第二个元素来自第二个迭代器。

如果您想同时迭代两个或更多迭代器，那么zip会很有帮助。

8-读取或写入文件时不使用上下文管理器

当你在没有上下文管理器的情况下使用open时，在你关闭文件之前发生了一些异常(当你以这种方式打开一个文件时，关闭文件是你必须记住的)，内存问题可能会发生，文件可能会在这个过程中被破坏。

当您使用with打开一个文件并且发生异常时，Python 保证该文件是关闭的。

9-使用 in 检查元素是否包含在(大)列表中

对于大型列表，使用 in 语句检查列表中是否包含元素可能会很慢。请考虑改用 set 或等分。

以下是三种方法的比较:

图片由作者修改

→来源: StackOverflow

10-将可变默认参数传递给函数(即空列表)

python 中有一件有趣的事情，可能会导致无声的错误和模糊的错误:默认参数在函数定义时计算一次，而不是每次调用函数时都计算。

这意味着，如果您使用一个可变的默认参数(比如一个 list)并对其进行变异，那么您将会并且已经变异了该对象，以便将来调用该函数。

为了避免这个问题，您可以将默认参数to设置为 None:

如果to设置为“无”的函数被调用多次，则创建一个新的空列表，每次都将元素追加到该列表中
当您将一个列表传递给to时，您向它追加了一个元素。因为它不是默认的函数参数，所以运行良好。

11-在单个函数中返回不同类型

当试图处理可能产生错误的特殊用户输入时，有时可以引入 None 作为输出。这使得您的代码不一致，因为您的函数现在至少返回两种类型:您想要的初始类型和非类型类型。

这使得以后很难测试和调试。

您可以引发一个错误并在以后捕获它，而不是返回 None。

12-当简单的 for 循环可以达到目的时，使用 while 循环

如果事先已经知道迭代次数，就不需要使用 while 循环。

13-使用堆栈和嵌套 if 语句

堆叠和嵌套的 if 语句很难理解代码逻辑。

除了嵌套条件，您还可以用布尔运算符将它们组合起来。

14-使用全局变量

避免像瘟疫一样的全局变量。它们是许多错误的来源。可以从程序的多个部分同时访问它们，这可能会导致错误。

使用全局变量时出现的典型错误是，当一个函数在另一个函数需要正确更新之前访问它的值。

15-不使用 get()从字典中返回默认值

当您使用get时，python 会检查字典中是否存在指定的键。如果是，那么get()返回那个键的值。如果键不存在，get()返回第二个参数中指定的值。

16-使用没有意义地处理异常的 try/except 块

应该避免使用 try/except 块并通过传递它来忽略异常(例如)。

17 —自豪地键入:从模块导入*

导入应该总是特定的。从模块中导入*是一个非常糟糕的做法，会污染名称空间。

18—过度设计一切

你并不总是需要上课。简单的函数可能非常有用。

类通常有方法，这些方法是与特定类相关联的函数，并且做与类相关联的事情——但是如果你想要做的只是做一些事情，那么函数就是你所需要的。

本质上，类是一种将函数(作为方法)和数据(作为属性)组合成一个围绕某种事物的逻辑单元的方式。如果不需要那种分组，那就没必要编课。

感谢阅读🙏

我希望这对你有用。如果你知道其他流行的 python 反模式，欢迎在评论中给我指出来。

祝你黑客愉快，下次再见👋

照片由卡斯滕·温吉尔特在 Unsplash 上拍摄

资源:

https://docs . quantified code . com/python-anti-patterns/index . html
https://deepsource.io/blog/8-new-python-antipatterns/
https://github.com/quantifiedcode/python-anti-patterns
https://docs . python-guide . org/writing/gotchas/# mutable-default-arguments
https://docs . python-guide . org/writing/gotchas/# mutable-default-arguments
https://towards data science . com/data-scientists-your-variable-names-are-worthy-heres-how-to-fix-them-89053d 2855 b

新到中？你可以订阅每月 5 美元，并解锁无限的文章——点击这里。

作为数据科学家，接下来要学习的 18 件有价值的事情

原文：https://towardsdatascience.com/18-effective-things-to-learn-next-as-a-data-scientist-eef7e7c70be2?source=collection_archive---------9-----------------------

接下来，您可以关注许多 so 领域来进一步提高您的 DS/ML 技能。

(src =https://pixabay.com/images/id-65049/

介绍

作为数据科学家，我们的世界可能非常可怕，很难处理。科学是艰难的，随之而来的是终身不断学习的纪律。这既是一种诅咒，也是一种祝福，因为这意味着总有东西要学——但你也永远不会知道所有的事情。不知道所有的事情会很可怕，尤其是当你刚刚进入一个领域的时候。尤其是数据科学学科可能相当难以接近，原因很简单，因为不知道从哪里开始！这是因为数据科学需要很多不同的技能，实际上并不是所有的数据科学家都做同样的工作。

一些数据科学家可能更专注于分析。另一方面，一些数据科学家专门研究机器学习算法。此外，数据科学家还经常与业务决策密切合作，这对于学习来说肯定是压倒性的。不仅要学习科学原理，还要学习数学、商业、分析和编程，这些都非常困难。使用这些不同的技能也很难一成不变，不知道下一步该做哪个或哪个部分。谢天谢地，有一些很酷的新技能，你可以随时掌握，在你的数据科学职业生涯中会派上用场！

№1:类 Unix 操作系统

O 我认为数据科学工作中经常被忽视的一个方面是类 Unix 操作系统的使用。对于数据科学家来说，知道如何使用终端以及附带的工具(如 Git、Wget 等)是有效工作的非常重要的技能。除了数据科学家可能需要忍受的重要或正常操作之外，还有一些特定但必要的任务可能需要执行，这些任务涉及许多在其他领域中常用的 Unix 管理技能。

虽然这些技能很容易在大量可能用于数据科学工作的其他技能中被忽略，但我认为如果没有这些技能，完成很多事情会困难得多。此外，Linux 知识将非常流畅地运用到工作的其他领域，比如部署。如果没有 web 服务器如何与代码和服务器系统协同工作的适当知识，实际部署您的端点可能会相当困难，而端点无疑是数据科学的重要资产和技能。如果你想准确地开始这项开发工作，我大约两年前写了一篇文章，实际上深入研究了这一点:

第 2 类:分布

另一个很容易被忽略但对成为一名有效的数据科学家非常重要的概念是分布。虽然一些数据科学家可能会将分布函数作为数据科学的重要信息，但我不同意。当然，这是因为通过其他人在大多数统计编程语言中的开源编程，已经可以很容易地访问其中的大多数。也就是说，了解测试和加权实际上是如何在幕后工作的，几乎肯定会对数据科学工作有所帮助。

一些绝对重要的信息当然是了解每个发行版的优势和劣势。知道这些分布上抛物线的形状可以教你很多关于这些测试如何在不同的分布上使用不同的尾部。此外，了解分布如何至少与它们各自的 CD 和 PD 函数一起工作，对于有效地测试和证明假设可能是有价值的信息。

№3:装配

虽然我不认为数据科学家需要了解汇编并能够编写它，但我认为知道如何编写一点汇编对任何程序员来说都是一项有价值的技能。我之所以相信这一点，是因为它会教你很多关于计算机的一般知识，以及它们实际上是如何工作的。当然，对于编程来说，理解计算机如何工作的深度和细节对于有效地编写代码来实现你设定的目标是非常重要的。出于这个原因，我真的认为汇编对于任何程序员来说都会很方便，数据科学代码当然也不例外。

第 4 类:数据收集

数据科学过程的一个重要部分总是实际获取数据。根据您的领域，您可能最终会自己创建这些数据，但是如果不是这样，您可能会很容易不知道您的数据实际上来自哪里。通过研究、自动算法和用户输入(如调查)收集的数据不会凭空出现。

也就是说，对于一些数据集来说，真正理解它们的来源是至关重要的。此外，有许多不同的策略可以用来表明某些数据集中的偏差。我认为这是我们作为数据科学家应该知道的事情。没有人希望他们的研究因为数据集的问题而没有结论。实际上，我花了很长时间来验证我用于医学迷幻用法的大量数据，通过实际采访和收集更多关于原始来源的知识。这让我对数据有了更多的了解，也让我有机会验证我的研究的第一手资料。

№5:分解

我认为许多数据科学家可能会忽略的另一个重要主题是分解。虽然使用现有库中通常提供的分解方法非常流行，但我认为真正理解分解，甚至手动尝试矩阵的奇异值分解，几乎肯定会使这些方法的使用比其他方法容易得多。

分解是机器解释数据的重要部分。随之而来的是我们对分解的理解，我认为这同样重要。此外，我们经常会反复使用一些简单的方法，比如奇异值分解，这些方法各有所长，但是我认为扩展分解库中的技能和工具也是一个很好的主意，可以让你成为一名更好的数据科学家！

№6:函数式编程

在编程的世界里，我们已经被许多允许多种不同编程风格的多范例编程语言宠坏了。其中一个编程范例，函数式编程范例，自从在第二代高级编程语言中出现以来，就已经与科学计算交织在一起了！考虑到这一点，我认为那些还没有尝试过函数式编程的人应该尝试一种以某种方式利用函数式编程范式的语言。

我认为陈述性语言是进行科学研究的一种自然方式，但是不管函数式编程在计算中的使用，我认为语言是一种有价值的学习经历。我实际上遵循了其他程序员给出的许多建议，这个想法来自 C++的作者，他说你应该尝试从每种范式中学习一种编程语言。这是因为它会给你所有编程的基础知识，而不是让你的眼睛只盯着几种不同的编程风格。这将使你成为一个更加多才多艺，反过来也更加有用的程序员。

№7:低级编程

对于许多程序员来说，汇编的建议可能很难实现，但是我认为学习一种更低级的编程语言，如 C 语言，这种语言迭代性更强，需要更多的真正的计算机管理，这也有助于让你更加了解计算机和电子处理的内部工作方式。

例如，在 C 语言中，你仍然需要分配内存和创建指针。虽然在我们的 Python 和 R 高级和声明式编程世界中，我们不习惯这样，但我认为学习一种更低级的语言对于形成对计算机如何执行计算以及我们搜索的结果如何在幕后实际实现的坚实理解是绝对重要的。

№8:开发运营

我们谈到了为什么我认为知道如何分别使用终端和 Bash 对于数据科学工作来说是很方便的。然而，正如前面提到的，开发-运营技能也是如此。我认为，作为一名程序员，知道如何部署自己的模型和创建自己的服务器肯定会有很大的价值。当然，对于数据科学家来说更是如此，因为我们的模型通常被部署到端点，并意味着被请求。学习如何至少使用像 Nginx 或 Apache 这样的 web 服务器肯定会在数据科学和服务器部署的许多不同应用中派上用场。如果您想进一步了解我刚才提到的这两个选项，我实际上有一篇比较这两个选项及其能力的几乎是古老的文章，它可能会给您一个关于从哪里开始部署您自己的模型的好主意！：

https://medium.com/chifi-media/nginx-or-apache-a3bb7ec4ca68

№9:更多语言

我认为大多数数据科学家忽略的另一件事是，学习其他语言对你的计算和编写代码知识的实际价值。正如前面讨论的低级语言和函数式编程语言一样，学习更多的编程语言总是会让你成为一个更好的程序员，不管你实际上想用哪种语言。

№10:并行计算

如果你还没有机会使用像 Nvidia 的 CUDA 这样出色的并行计算平台，我认为你应该去买一个功能强大的显卡，并尝试使用你喜欢的语言！这个行业正朝着这个方向发展，它被列为几乎所有数据科学工作申请的一项完全必要的技能。考虑到这一点，我当然认为这是一件值得投入时间的事情，以便让自己看起来像一名数据科学家一样更有价值。

№11:新包

好吧，你的编程语言做得很好。你几乎知道如何编码任何东西——你将何去何从？当然是多学包！通常，了解一种编程语言的依赖性和生态系统的能力会让你在工作应用程序中脱颖而出。有很多标准的工具被很多程序员使用，但是有时候拿出一个不同的工具可能意味着完成一个项目或者在一个问题上停滞不前的区别。

例如，在 Python 的标准库中实际上有很多包，我认为它们仍然被忽略了。如果你想了解更多我最喜欢的模块，我有一篇文章详细介绍了它们，你可以点击这里:

</15-more-surprisingly-useful-python-base-modules-6ff1ee89b018>

№12:新测试

在科学计算的世界中，将测试保留给几个选定的分布实际上是很常见的，最常见的是 t 分布。对于学习来说幸运的是，有这么多的发行版和测试，它们各有优缺点。也就是说，我认为作为一名科学家，获得一些新的测试和测试策略肯定是有价值的，因为当试图进一步证明假设时，这些往往会派上用场。

№13: Crontab

很久以前，我写过一篇文章，讲述了为什么我认为 Crontab 是一个绝对棒的自动化工具。当然，这仍然没有真正改变，我认为 Crontab 在数据科学的许多方面都派上了用场，比如脚本自动化和开发操作。最重要的是，我认为它非常容易使用，所以仅从这一点来看，它确实值得一试。如果你想阅读我关于这方面的文章，你可以点击这里查看:

№14: SSH/SCP

数据科学技能的开发-运营/系统管理员方面的另一项重要技能是 SSH/SCP 技能。SSH 是一种非常常用的工具，用于在远程系统和无头系统之间传输命令。它对于管理服务器和实际部署终端来说非常方便。SCP 是 SSH 的另一个桥梁，它允许您安全地将文件从一个地方复制到另一个地方，因此我非常肯定地建议同时使用这两者，以便将您的项目放入云中，并按照您想要的方式运行！

№16:饭桶

在很多情况下，另一个可能会被遗忘的东西是 GIT。GIT 是一个用于管理我们作为程序员编写的代码库的工具。也就是说，它绝对是当今任何程序员的必备工具。我认为所有的程序员都必须在某个时候与 Git 交互。知道如何从你的终端有效地使用软件来管理你的软件库将会使管理你实际发布的软件变得更加容易。也就是说，我认为如果你不知道 Git 中的每一个命令，基本上在任何时候都可以重温是一件很棒的事情。

第 17 位:数据伦理

我认为许多数据科学家应该了解的另一个重要概念是数据伦理的概念。在现代，有许多非常有效的数据伦理问题。我们大多数人都有自己的数据被远程存储在互联网上的任意位置——这通常会侵犯我们的个人隐私。

这项科学工作应该有一种誓言。话虽如此，它并没有得到很好的遵循，所以我认为研究人工智能的力量和数据收集的道德规范是对还是错是我们很多人需要吸取的教训。数据在某种程度上已经成为一种货币，数据被出售，数据被交换，数据被估价。考虑到这一点，就像我们不会窃取陌生人的货币一样，我们可能也不应该窃取他们的数据。在伦理学的世界里有如此多不同的观点，我认为引起了很多关注，在这个领域里当然意味着你应该至少在某种程度上参与到对话中。也就是说，我认为对这些问题的研究对数据科学家来说肯定是有价值的，他们经常与人们的数据打交道，很容易违反这些道德问题。

№18:可重复的研究

我想说的最后一点是关于可重复研究的。为了使研究和假设有效，研究的可重复性是绝对重要的。如果你的研究不可重复，它也很容易妨碍同行评议和出版。也就是说，我认为从一些简单的策略开始，让任何人都可以复制你的研究，这将是一个非常重要的概念，以便实际上得出有价值的结论。我写了一个非常酷的小指南，关于如何创建有效的可重复的研究，你可以在这里看到:

结论

数据科学家需要学习很多东西。也就是说，信息世界将会不断扩展，而且总会有新的东西需要学习，这既是这个领域的一个积极方面，也是一个消极方面。有时候很容易陷入一个小窠臼，不知道下一步该学什么。然而，使用这些建议，理想情况下，找到一些新的东西来学习会变得容易得多！非常感谢您阅读我的文章，我希望它是有见地的！继续学习！

我的数据科学之旅已经进行了 18 个月

原文：https://towardsdatascience.com/18-months-into-my-data-science-journey-dfd2fa2c8dc9?source=collection_archive---------4-----------------------

吸取的教训、犯的错误和未来的计划

照片由袁晓超尹在 Unsplash

开始

大约 18 个月前，我开始学习数据科学。

我记得这一切是如何开始的。整个新冠肺炎都被封锁了，我被困在家里。这段时间我也在大学休学一个学期，所以没有太多事情可做。

我曾经做过兼职家教，但由于封锁，我不能再做了。

我开始寻找不同的方法让自己有事可做，并决定尝试学习如何编码。我想成为一名数据科学家，但缺乏编程技能是我无法逾越的巨大障碍。

过去我曾试图自学编程，但惨败。

然而，这一次不同了。

我不只是做编程教程和跟随别人的代码，我实际上尝试自己解决问题。我也开始做一些小项目，慢慢变得更好。

然后，我参加了几个数据科学在线课程，并尝试建立自己的项目。

三个月了

在学习数据科学和构建自己的项目大约 3 个月后，我决定将它们发布到网上。我写了关于我的项目的博文，并在 Medium 上发表。

然后，我读了一篇有趣的文章，描述了拥有一个数据科学组合网站的重要性。

我决定编写自己的作品集网站，并在上面展示我所有的项目。我花了大约 3-4 天的时间完成了这个。

我得到了我的第一份数据科学实习，因为数据科学团队对我的投资组合网站印象深刻。他们喜欢我主动建立自己的项目并撰写相关文章，还给我发了实习邀请。

我的实习经历很棒，我很幸运周围都是聪明、乐于助人的团队成员。

当我刚开始实习时，一些同事让我和他们一起做项目。在这段时间里，我在我的编码环境中遇到了多重挑战，也很挣扎，因为这是一种我以前从未使用过的新编程语言。

我记得我的同事告诉我，“如果它对你不起作用，没关系，我会代它运行。“然而，过去几个月每天 8 小时解决问题已经给我灌输了一种固执，我只需要让它发挥作用。

我几乎每晚都加班加点地排除故障，让我的代码正常工作。我不想被当作“只是一个实习生”，所以我竭尽全力在截止日期前完成工作，并证明我能胜任这份工作。

六个月了

我刚刚完成了我的第一次数据科学实习。事情进行得很顺利，我得到了一个在学习期间兼职同一家公司的 offer。

就职业发展而言，我不确定自己想做什么。我的一些学长强烈建议学习商业分析并从事咨询工作。其他人建议学习 ML 和开发，以进入端到端数据科学角色。

我还参加了一些网络开发、统计学和数据工程方面的在线课程。

这段时间主要是工作和学习新的概念，以了解我想做什么。在最后一年，我还参与了一个人工智能顶点项目，该项目要求我部署机器学习模型并构建一个实时仪表板。

我在 Medium 上的文章也赢得了更多读者，并开始赚到足够支付汽油、食物和咖啡等费用的钱。

一年后

几个月前，我面临着一个非常艰难的决定。我的大学有一个强制性的工业培训模块要求，我必须实习才能毕业。

尽管我已经有了实习经验，但我不得从事全职或兼职工作。我别无选择，只能重新开始，再做一次实习。

这一次，我尝试在不同的公司申请实习，因为我想要新的体验。我设法在一家著名的跨国公司找到了一份实习工作。

然而，实习几周后，我递交了辞职信。

这是因为我被赋予了卑微的任务，我不喜欢这样。我向几个上级表达了我的担忧，但没有采取什么措施。

我不想浪费五个月的时间去做每天 8 小时的粗活，所以我离开了。我没有太多时间去找另一份实习。然而，谢天谢地，我原来的公司愿意让我回去。

我又在那里实习了四个月。

在此期间，我继续撰写和发布我正在从事的项目。来自世界各地的招聘人员在阅读了我的作品后联系了我，我收到了许多自由职业者的邀请。

我开始以自由职业者的身份为公司写作。我建立了机器学习模型。我提供基于分析的咨询。我在网上赚的比我实习的时候多得多。

我想知道在完成数据科学实习后是否继续全职工作。我喜欢接自由职业项目，喜欢按照自己的时间表工作，现在有足够的工作可以从中赚取可观的收入。

现在

大约两个月前，我在目前的公司获得了一个全职的高级职位。由于几乎没有正式的工作经验，这是一个相当不错的提议，所以我接受了。

我目前在工作和自由职业项目之间保持平衡，由于时间限制，我对自己承担的项目非常挑剔。

我还确保不断学习新工具，并通过建立个人项目来扩展工作之外的技能。

你可以在这里看看我做过的数据科学项目。

学习

开始是学习数据科学最困难的部分。

一旦我上了我的第一门数据科学课，并开始自学如何编码，其他一切就都水到渠成了。

我的第一篇文章的浏览量正好是 0，我构建的大部分项目都没人关注。我不确定我是否能在这个领域找到工作。

我工作了好几个月，几乎没有任何金钱回报——学习、建设和写作。

随着时间的推移，随着我不断在网上撰写和发布更多的项目，我开始建立一个追随者，招聘人员开始向我提供工作。

就在几个月前，一名招聘人员就一个数据分析项目联系了我。他们希望招聘一名远程数据分析师。

他们主动给我发来一个付费的测试项目，如果我能成功完成这个项目，他们就会聘用我。

在通过电子邮件沟通和交流之后，他们不确定我是否能花足够的时间为他们做项目。他们想雇一个全职的人，而我已经有一份全职工作了。

从那以后，我几个星期都没有他们的消息。

他们解释的项目似乎很有趣。尽管他们从未回到我身边，我还是决定创建这个项目。我把我在这个项目中的发现写成了一篇博客，并在网上发表了。

团队对我付出的努力印象深刻，并给了我另一个计费测试项目。他们喜欢我的工作，现在已经和我签订了一份灵活的合同，让我兼职和他们一起工作。

我今天所拥有的大部分并不是因为我比这个领域的其他人更熟练。是因为我愿意学习。如果我看到了一个学习和成长的机会，我会花几个小时去做一些不会给我带来直接回报的项目。

如果我觉得有报酬的工作对我的长期发展没有帮助，我会拒绝它，花更少的时间来优先考虑它。

这种态度在我的职业生涯中一直带着我前进，我觉得我在不断地成长。对许多人来说，我拒绝了一家知名公司的机会，而是决定去一家较小的公司工作，这可能看起来很奇怪，但我就是不觉得我在学习。

无论报酬有多高，每周花 40 个小时做琐碎的工作都不是我想做的事情。我不想纯粹为了金钱回报而交易我的时间。

本文到此为止！

我希望您喜欢阅读我的数据科学之旅，并能够从中获得一些有用的东西。

感谢阅读！

面向初学者的 18 个数据科学项目创意

原文：https://towardsdatascience.com/19-data-science-project-ideas-for-beginners-3de3db9bf830?source=collection_archive---------11-----------------------

挑一个或所有的——任何你觉得最有趣的。

来自 Pexels 的 cottonbro 摄影

数据科学项目是初学者掌握一些非常基本的数据科学技能和语言的好方法，这些技能和语言是您将数据科学作为业余爱好或职业所需要的。教程、课程和视频都很棒，但项目真的是参与数据科学和动手实践的垫脚石。

面向初学者的数据科学项目更适合学习语言和技能，因为它们更具粘性。我看了大概一万遍关于学习 Python 的视频，但是我是在接了一个项目自己做的时候才真正开始了解 Python 的。数据科学项目很棒，因为你比仅仅看在线教程获得了更多的个人既得利益。当你与某件事有利害关系时，你会有动力去做到底。

一个好的项目可以是从学习如何导入数据集到创建自己的网站甚至更复杂的东西。项目可以是个人的，只是帮你学习；他们可以作为一个投资组合来证明你知道你在说什么。

本文将为初学者提供 18 个数据科学项目思路。选择其中一个或全部——任何你觉得最有趣的。让我们跳进来。

**6** [**Data Science Project Tutorials for Beginners**](#b0fb)
· [Project 1: House Prices Regression](#51cf)
· [Project 2: Titanic Classification](#87de)
· [Project 3: Deep Learning Number Recognition](#ac66)
· [Project 4: YouTube comment sentiment analysis](#959e)
· [Project 5: Covid-19 Data Analysis Project](#2a76)
· [Project 6: YouTube APIs with Python](#bc89)
[**5 DIY Data Science Project Ideas for Beginners [Unlimited Data Science Project Ideas]**](#db96)
· [Project 7: Tidy Tuesdays](#7b31)
· [Project 8: The Pudding](#4a34)
· [Project 9: 538](#f188)
· [Project 10: NASA](#d7e9)
· [Project 11: The Tate museum](#b74c)
[**7 Skills-Based Data Science Projects**](#fc18)
· [Project 12: Collect data](#9a82)
· [Project 13: Clean data](#9f81)
· [Project 14: Explore data](#5c9f)
· [Project 15: Visualize data](#5a8f)
· [Project 16: Regression](#ea46)
· [Project 17: Statistics in general](#5e74)
· [Project 18: Machine learning](#c990)
[**Data science project ideas for beginners are unlimited**](#a514)

这七个数据科学项目混合了视频和文章。它们涵盖了各种不同的语言，这取决于你对学习什么感兴趣。您将学习如何使用 API，如何运行预测，接触深度学习，并查看回归。

这些针对初学者的项目教程是实际操作的，并且非常具体，所以如果你想开始，但又不知道从哪里开始，它们是最理想的。选择一个你喜欢的，看看你在哪里挣扎，并以此开始建立一个你可以学习的其他数据科学技能的列表。

项目一:房价回归

在疫情期间，我发现自己在 Zillow 上花了很多时间。我喜欢看所有不同的房子，因为它们的数据非常丰富。有这么多不同的方面让我去调查，让我迷失自己。这种奇怪的兴趣让我想到了这个教程，它可以让你预测爱荷华州艾姆斯的最终房价。

听起来很奇怪，但很有趣。

您可以使用 R 或 Python 来运行这个项目。老实说，这是一个雄心勃勃的项目，尤其是如果你是编码的新手。但我从它开始，因为我认为它回答了很多人的一个问题——房子值多少钱？人类本质上是好奇的，最好的数据科学项目利用这种好奇心来教你技能。

我喜欢 Kaggle 上的这个教程是因为它有大量不同的选项来完成它，并且这些不同的解决方案与社区共享。任何人都可以上传自己的代码，所以这是一个学习和复制他人代码的好地方(这是学习如何编码的最好方法之一)。

沉迷于预测、一点机器学习和一些回归。

项目 2:泰坦尼克号分类

泰坦尼克号的沉没是世界上最著名的悲剧之一。没有足够的救生艇容纳船上的每个人，导致 1500 多人死亡。如果你看看数据，似乎有些人群比其他人更有可能存活。

与上述项目相同的网站 Kaggle 运营着这个竞赛。他们试图找出哪些因素最有可能导致成功——社会经济地位、年龄、性别等等。与房价项目类似，这个项目可以访问许多其他程序员的代码，您可以从中学习。他们也有自己的专为完全初学者提供的教程。这对刚接触 Kaggle 和编码的人来说非常有用。

最后，您将建立一个预测模型来回答这个问题。我推荐 Python 做这个。

无论您是否真的加入竞争，这仍然是初学者研究的伟大数据科学项目之一。

项目三:深度学习数字识别

你知道电脑能看见东西吗？许多最新有趣的数据科学项目都与计算机视觉有关。本教程非常适合教你神经网络和分类方法的基础知识。在本教程中，您的工作是从成千上万的手写图像数据集中正确识别数字。

这个竞赛/教程也是由 Kaggle 主办的——你可以查看他们自己的一些教程，或者你也可以使用用户提交的代码。

在我看来，这个项目没有泰坦尼克号或房价教程有趣，但它会教你一个非常复杂的学科的一些基础知识。另外，你可以教一台电脑看东西，这是相当疯狂的。

项目 4: YouTube 评论情感分析

不要看评论！…除非你在做一个针对初学者的 YouTube 评论情感分析数据科学项目。

YouTube 评论情感分析的这个教程很棒，因为它确实是为初学者准备的。视频教程的创作者是自然语言处理的初学者，这是你将在本教程中学习的技能。这是一个非常酷的视频，大约 14 分钟长，非常适合 NLP 入门。这也是一个很好的展示，展示了数据科学项目如何以一种好的方式带着你跑。

视频真的很搞笑，她还链接到了她 GitHub 里的代码。自己随意进入吧！

项目 5:新冠肺炎数据分析项目

在疫情期间，我感觉事情已经超出了我的控制。这听起来很傻，但是我让自己停飞的方法之一就是记录每天的数字。有时这让我感到紧张，但我发现自己把数据作为理解不可思议事物的一种方式。

Python 程序员频道也有类似的想法。在本教程中，他将教您使用 Python 进行新冠肺炎数据分析。

这个视频教程比上一个要严肃一点，关于怎么做的更深入一点。他还介绍了一些非常重要的 Python 包的基础知识，比如 pandas。这是对熊猫和蟒蛇的非常清晰的介绍。

项目 6:使用 Python 的 YouTube APIs

说到 API，使用 API 是所有其他科学家的必要技能。当你选择一个项目时，确保至少有一个人教你使用 API，以确保你已经掌握了这一关键技能。

本教程使用 Python 引导您进行 API 调用，从频道收集视频统计数据，并将其保存为 pandas dataframe。它还提供了 Python 笔记本代码和 GitHub 上的其他资源。

5 个适合初学者的 DIY 数据科学项目创意【无限数据科学项目创意】

实际上有数百万个潜在的数据科学项目，我已经以教程和视频的形式记录下来。但是知道如何创建自己的项目也很有用。我们将讨论其他人想做什么——想想你想做什么。

提出我自己的项目是我最初开始接触 Python 的原因。我有一个问题，我需要一个答案，获得答案的唯一方法是用 python 分析我的数据。我不想列出更多单独的教程，而是想向您介绍一些可以帮助您从头开始设计自己的数据科学项目的资源。

项目 7:整洁的星期二

这个项目依赖于整洁的周二 GitHub 回购。这种回购的伟大之处在于，每周二都会上传全新的杂乱数据。这个团队分析它，将它视觉化，并且通常玩它。这是一个向他人学习并亲自尝试的好地方。

这个 repo 最适合想学 R 的人(虽然对一些 Python 也不错)。它也最适合基本的数据科学技能，如读取文件、进行介绍性分析、可视化和报告。

例如，本周整洁的周二数据集来自美国国家经济研究局。数据集的构造方式意味着学习如何连接表是很好的。也许你对论文作者中的女性代表感兴趣。也许您想了解夏季和冬季的发布频率。无论哪种方式，TidyTuesday 都可以通过每周的新数据帮助你掌握一些基本的数据科学技能。它也可以追溯到几年前，所以无论你喜欢什么类型的数据，你都可以找到一些有趣的东西，并且你永远不会用完数据科学项目的想法。

项目 8:布丁

Pudding 通常使用 JavaScript、Python 或 R. TidyTuesday 进行非常花哨的可视化和分析，但 Pudding 提供了一些非常奇怪的项目。

也许你也像我一样是一个超级社区粉丝，你想知道相对于杰夫或安妮，阿布蒂说了多少次“酷”这个词。也许你喜欢阅读知心大姐的来信，而通过《亲爱的艾比》一书对三十年来美国焦虑的洞察引起了你的兴趣。

这些项目提供了大量的文化评论。它们比这个列表中的其他一些更有挑战性，也更适合，但它们很吸引人，尤其能教会你很多关于可视化的东西。布丁在他们的 GitHub repo 上提供了他们所有的代码，我鼓励你去看看。

项目 9: 538

体育和政治在 538 博客中碰撞，在统计学和数学中相遇。在这里，你可以滚动浏览文章，找出你感兴趣的，并前往GitHub repo查看发现背后的代码和分析。从那里，你可以自己钻研数据。

我很开心地钻研的一个项目是超级碗广告。最初的文章谈到了美国人如何热爱美国、动物和性(以他们在超级碗广告中的出现频率为代表)。我很想知道这些年来是否有更多的性广告。找到你自己的问题并投入进去！

项目 10:美国航天局

谁长大了不想当宇航员？现在是你追逐梦想的机会。

美国宇航局的数据没有我上面列出的三个选项那么用户友好。但是这里提供的数据的数量(和普遍的令人惊叹的程度)使它成为任何数据科学项目列表中的必备项目。我建议您从这个“空间科学与 Python ”教程系列开始，而不是尝试在他们密集的文献和数据库中搜索。比如想知道 2020 年 5 月小行星 1997BQ 离地球有多近？现在是你找出答案的机会了。

项目 11:泰特美术馆

也许你更喜欢艺术和人文。幸运的是，您也可以使用数据来创建自己的数据科学项目。看看泰特美术馆的数据档案就知道了。在这里，你可以找到超过 3500 位艺术家的元数据。

你可以利用这些数据为自己做很多事情，但如果你已经不知道从哪里开始，泰特有用地列出了其他人利用这些数据完成的数据科学项目的例子。例如，Florian Kraeutli 做了一些华丽和介绍性的探索性分析你可以看看。

7 个基于技能的数据科学项目

这篇博文的第一部分讲述了非常具体的教程。第二部分教你在哪里寻找自己的数据科学项目创意。这最后一个将为您指出基于技能的数据科学项目理念的正确方向。这对那些正在整理简历或考虑申请一份数据科学工作的人来说是最相关的。

对于初学者来说，这七个步骤中的每一个都值得成为自己的数据科学项目，但是一旦你准备好了，你也可以使用这七个步骤为更多的中级/高级数据科学家创建一个完整的项目。

项目 12:收集数据

任何数据科学项目的第一步都值得成为数据科学项目本身:收集数据。

大多数情况下，数据不会完美地以整齐的表格形式出现在你的计算机中。你必须弄清楚如何把它从 A 点到 B 点，才能做你想做的其他事情。

把它变成一个项目，研究如何使用一些最流行的数据科学语言收集数据，比如 Python 和 SQL。

项目 13:干净的数据

数据在里面！但是很乱。当我在研究鸟类保护时，学习如何清理数据是我硕士期间最大的失望之一。我以为我可以马上得到数据并开始分析。可悲的是，存在问题:重复、不适用、数字存储为文本，以及你能想到的几乎所有其他问题。

有人说清理数据是数据科学家 80%的工作。知道怎么做是值得的。

我是用 R 做项目的，所以如果你是这样的人，我推荐这篇教程学习如何用 R 加载和清理数据。如果你是一个初露头角的 Python 爱好者，这篇教程帮助我掌握了用 Pandas 和 NumPy 清理数据，这两个都是非常常见和有用的 Python 包。

项目 14:探索数据

一旦你的数据整理好了，就到了激动人心的时候了:探索你的数据。这还没有达到可视化或分析的水平。通常，您要查看的数据非常多，这有助于您在开始创建模型之前了解实际情况。把这个项目想象成把你的脚趾浸入水中来测量温度。

这个 2.5 小时的视频教程将教你完全从零开始构建一个探索性的数据分析项目。它很长，而且 100%全面。

项目 15:可视化数据

您可以做很多事情来可视化数据，很多数据科学技能是知道哪种可视化最能代表您试图传达的想法。这就是为什么对初学者来说，简单地处理数据 viz 是一个很好的数据科学项目想法。

这个 Kaggle 教程有点无聊，但是会教你一些数据可视化的基础知识。有了这些知识，您就可以继续创建自己的数据科学可视化项目——这次使用您关心的数据。

项目 16:回归

回归是一个超级重要的预测工具，用于数据科学的所有领域。这有助于你统计确定 X 和 y 之间的关系。这是机器学习的基础。

您可以创建一个项目，该项目侧重于具有 X 和 Y 变量的任何数据集的回归。我自己用我的鸟数据做了这个，预测鸟的大小是否影响鸟的生存。挑选任何你喜欢的数据集，使用类似 Kaggle 的红酒质量数据教程的方法，链接这里。

项目 17:一般统计

很容易陷入 NLP、ML、AI、DL 和其他所有数据科学缩写词的炒作中。但是不要忘记所有类型的数据科学都依赖于统计学和数学。为了充分利用您可能有的任何数据科学项目想法，请确保您已经掌握了支撑数据科学概念的统计学基础。

我把所有这些统计基础知识放在一个小标题下有点作弊，但是我推荐 KDNuggets 的八个基本统计概念的列表。从那里，找到一个专注于这八个方面的项目。例如，以我上面链接的泰特数据集为例，通过计算艺术品的平均绘画日期来了解“集中趋势”。

你可以为这个项目使用任何编程语言。我喜欢 Python，因为它对初学者来说很棒，但是 R、SQL、JavaScript 或任何其他编码语言都可以实现同样的目标。

项目 18:机器学习

让我们用机器学习来总结这个给初学者的数据科学项目想法列表。任何称职的数据科学家都知道机器学习，并能成功地用它来预测许多事情。使用你从回归中学到的东西，并应用到这里。

要创建一个教你机器学习的项目，几乎任何数据集都可以。例如，您可以使用优步的皮卡数据，并提出类似这样的问题:优步是否会加剧拥堵？或者，这个指导你推荐电影的教程可能是个不错的项目。我推荐使用 Python，因为它的 TensorFlow 包是专门为机器学习而构建的。

初学者的数据科学项目思路是无限的

如果你有一盎司的创造力和好奇心，你可以在网上找到你需要的数据和教程来创建你自己的数据科学项目，无论你的兴趣或技能水平如何。这篇文章应该作为一个路标，指引你潜在的选择，你可以在闲暇时细读。

如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑注册成为一名媒体会员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你用我的链接注册，我会赚一点佣金。

https://zulie.medium.com/membership

20 多个有用的 Python 语法模式，用于编写访谈

原文：https://towardsdatascience.com/19-helpful-python-syntax-patterns-for-coding-interviews-3704c15b758f?source=collection_archive---------3-----------------------

通过学习 Python 中这些常见的编码面试模式，在面试中获得更多自信并节省时间

第一课:使用列表理解！

在现实生活中编码时，我有时会忘记语法，需要求助于 Google。遗憾的是，这种奢侈在编码面试中是没有的。为了解决这个问题，我一直在回顾 Python 中用于编码面试的常见语法模式。语法并没有理解核心算法和数据结构概念那么重要，但是对我来说，回顾语法可以给我的代码注入信心，并为我节省宝贵的时间。我希望它对你也一样。

第 1 部分:列表

1.整理

sorted(numbers)将按升序返回排序后的数字，并保持原始数字不变。你也可以使用numbers.sort(),它对数字进行就地排序，并对numbers进行就地变异
sorted有两个可选参数，key和reverse。key允许您修改用于比较的值。所以sorted(..., key=str.lower)排序不区分大小写。reverse让你按降序排序，所以sorted(..., reverse=True)是降序。
sorted使用具有O(nlogn)平均和最坏情况时间复杂度的 Timsort，使用O(n)空间(类似于合并排序)，具有最好情况O(n)时间复杂度(类似于插入排序)。

2。列表切片语法

一般语法是iterable[start:stop:step]
list[i:j]从索引i返回，直到但不包括 j
list[i:]从索引i开始返回，直到结束
list[:j]从起点返回，直到指数j
list[::2]返回列表中的所有其他元素(索引0, 2, ..
list[::-1]反转列表— 虽然 list.reversed()更快

列表切片的真实演示

3.列表理解(即 Pythonic 地图和过滤器)

通用语法是expression for member in iterable [if conditon]
例如，[element * 2 for element in list if element % 2 == 0]将返回一个新列表，其中每个偶数元素都是原始列表的两倍
用这个代替map和filter以获得更好的可读性

4。使用范围

一般语法是range(start, stop, step)
range(n)用于从0到n — 1的迭代
range(i, j)适用于从i到j的迭代，但不包括j
range(i, j, n)同上，但每第 n 个元素。请注意，如果您想使用step — range(10, step=2)会导致错误，那么请改为使用range(0, 10, 2)—阅读此以了解关于为什么range不支持关键字参数的更多信息

5。创建大小为 N 的列表

你可以使用 range 并转换成一个列表(例如，如果你喜欢的话，可以使用list(range(N))或[*range(N)])
对于所有相同的元素使用[element] * N
例如，[0] * 10是 10 个零的列表，[None] * 5是 5 个零的列表Nones
对于 2 维或更多维，不要做[[0] * 5] * 10。这 10 行只是对具有 5 个值的一行的引用，因此编辑一行将会改变其他 9 行。反而做，[[0 for i in range(5)] for j in range(10)]。

第 2 部分:迭代

6。使用枚举

# Use enumerate to get index and element
# from an iterable
for index, element in enumerate(list):
  print(element + ' is at index ' + str(index))

7。如何写一篇‘边做边看’

像其他语言一样的陈述—

do {
  # Write code here
} while (condition)

这是用 Python 写的吗(不是我最喜欢的语法，但有时需要这样做)—

while True:
  # Write code here
  if condition:
    break

8.如何使用发电机

我发现生成器在查找任何图类型结构的 DFS 或 BFS 问题的邻居时最有用。以 Leetcode 200 —岛屿数量为例。我们可以创建一个返回生成器的getNeighbors辅助函数。这看起来像

def numIslands(grid) -> int:        
 **def getNeighbors(i, j):
    for di, dj in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
      ni, nj = i + di, j + dj
      if 0 <= ni < len(grid) and 0 <= nj < len(grid[i]):
        yield ni, nj**

  def dfs(i, j):            
    grid[i][j] = "-1"
    **for new_i, new_j in getNeighbors(i, j):**
      if grid[new_i][new_j] == "1":
        dfs(new_i, new_j)

  islands = 0
  for i in range(len(grid)):
    for j in range(len(grid[0])):
       if grid[i][j] == "1":
         islands += 1
         dfs(i, j)

  return islands

第三部分。高阶函数

9.使用列表理解，而不是“映射”或“过滤”

list = list(range(10)) # [0, 1, ..., 9]**# Not very Pythonic 👎** evens = filter(lambda x : x % 2 == 0, list) # [0, 2, ..., 8]
evens_doubled = map(lambda x : x*2, events) # [0, 4, ..., 16]**# Using list comprehension is Pythonic 👍** evens_doubled = [x*2 for x in list if x % 2 == 0]

10.谨慎使用 reduce

谨慎使用 reduce—sum、math.prod、all和any可读性更好，值得为比这更复杂的东西编写一个可读性更好的for循环。连 Guido(Python 的创造者)自己都这么想，这也是 reduce 被从内置库降格为functools库的原因。

倒一个出来做内置还原

尽管如此，还是很高兴知道。语法是functools.reduce(function, iterable[, initializer])。下面是一些例子

from functools import reduce
nums = [1, 2, 3, 4, 5]
bools = [True, False, True, False, True]# sum
reduce(lambda a, b: a + b, nums, 0) # 15# math.prod
reduce(lambda a, b: a * b, nums, 1) # 120# min
reduce(lambda a, b: a if a < b else b, nums) # 1# max
reduce(lambda a, b: a if a > b else b, nums) # 5# any
reduce(lambda a, b: a or b, bools) # true# all
reduce(lambda a, b: a and b, bools) # false

11.使用 zip、zip_longest 和 zip_shortest

zip让你同时遍历列表

list_a = [1, 2, 3, 4]
list_b = [10, 20, 30, 40]list_sum = [a + b for a, b in **zip(list_a, list_b)**]
# OR
list_sum = []
for a, b in zip(list_a, list_b):
  list_sum.append(a + b)print(list_sum) # [11, 22, 33, 44]

对于长度不等的列表，zip将输出截断为最短的列表。itertools库中的zip_longest让你用一个fill_value填充较小的列表，这样你就可以zip好像它们是等长的。

from itertools import zip_longest, zip_shortestshort = [1, 2]
long = [10, 20, 30, 40]zip_short = [a + b for a, b in **zip(short, long)**]
print(zip_short) # [11, 22]
zip_long = [a + b for a, b in **zip_longest(short, long, fillvalue=0)**]
print(zip_long) # [11, 22, 30, 40]

第四部分。数据结构

12.Python 字典方法

要检查一个关键字是否在字典中，使用key in my_dict
my_dict[key]访问字典中的一个条目，如果字典中没有这个键，则返回一个KeyError。为了避免错误，使用my_dict.get(key, default_value=None),如果键不在字典中，它将返回default_value而不是错误
如果您知道key在my_dict中，那么使用del my_dict[key]从字典中删除一个键。否则，使用my_dict.pop(key, None)，如果key不在my_dict中，它将返回None
my_dict.setdefault(key, default_value)如果在my_dict中则返回key的当前值，如果不在，则设置为default_value并返回
setdefault对于计算元素来说特别有用，你可以做类似counts[element] = counts.setdefault(element, 0) + 1的事情
my_dict.keys()、my_dict.values()和my_dict.items()将分别从字典中返回(key, value)的键、值和元组的列表(这些有助于迭代)
您可以使用字典理解来创建新的字典，就像列表理解一样

my_basket = {'apple': 2, 'banana': 3, 'starfruit': 1}
double_my_basket = {k:v*2 for (k, v) in my_basket.items()}
print(double_my_basket) # {'apple': 4, 'banana': 6, 'starfruit': 2}

对于集合和字典，您可以分别使用合并和更新操作符|和|=来添加键和值(仅适用于 Python 3.9 版的字典)

a = {1, 2, 3} # New set
a += {4} # ❌ Returns a `TypeError`
a |= {4} # ✅ {1, 2, 3, 4}

13.使用 OrderedDict

OrderedDict不经常使用，但是它可以使一些问题变得微不足道，例如实现 LRU 缓存。一个OrderedDict实际上是一个结合了双向链表的字典，用于排序
OrderedDict有一个.popitem()方法，可以让你以后进先出的顺序移除物品(popitem(last=False)会以先进先出的顺序移除物品)。
另外.move_to_end(item_key)让我们将一个条目移动到字典的末尾(这样它可以在下一个弹出)。.move_to_end(item_key, last=False)让您将项目移到开头。

14。使用集合。计数器

通常，面试问题涉及到向散列图添加计数。为此，您可以像下面这样使用collections.Counter。一个Counter是一个dict的子类，你可以像它是一个子类一样与之交互。

things = ['a', 'a', 'b', 'c', 'b', 'b']
counts = collections.Counter(things)
print(counts) # Counter({'b': 3, 'a': 2, 'c': 1})

15。使用 heapq

不要用queue.PriorityQueue，heapq更灵活
通读官方 heapq 文档——下面的一些标注
heapify就位，那么heapify(list)就会把list变成一堆
heapq仅支持最小堆，对于最大堆，在堆之前将所有值乘以-1，在弹出后乘以-1(我知道这很烦人)
如果你想为对象创建一个堆，你应该用(priority, counter, object)把它们作为一个元组添加。counter是一个唯一的数字，用于打破优先级的界限(否则会出现错误)。我从 0 开始counter,每当我压入堆时就递增。

16.实现树

在 Python 的标准库中没有任何有助于面试的树形数据结构，所以你需要实现你自己的
对于二叉树，可以创建一个具有左右节点属性的节点类。确保跟踪代码中的“头”节点。
对于非二叉树，可以为子树使用数组或字典。如果您不希望孩子有重复的值，并且想要O(1)查找，字典可能会更好。

# Binary Tree Node
class Node:
  def __init__(value):
    self.value = value
    self.left = None
    self.right = None# Non-Binary Tree Node
class Node:
  def __init__(value):
    self.value = value
    self.children = [] # or self.children = {} for dict

17。实施 Trie

Python 的标准库中没有 Trie，但是您可以很容易地实现一个。这里有一个只有insert和search功能的，你可以在此基础上构建额外的功能。

class TrieNode:
    def __init__(self):
        self.is_complete_word = False
        self.children = {}class Trie:
    def __init__(self):
        # Blank Trie
        self.root = TrieNode()

    def insert(self, word: str) -> None:
        """
        Insert a word:
        — Iterate through all characters in the word
        - If we we encounter a char we don't have a
          node for, create a new node
        - Mark the last node as a complete word
        """
        curr = self.root
        for char in word:
            curr = curr.children.setdefault(char, TrieNode())    
        curr.is_complete_word = True

    def search(self, word: str) -> bool:
        """
        Search for a word:
        — Iterate through all characters in the word
        - If we we encounter a char we don't have a
          node for, return False
        - At the last node, return whether the word
          is a complete word in our Trie
        """
        curr = self.root
        for char in word:
            if char not in curr.children:
                return False
            curr = curr.children[char] 
        return curr.is_complete_word

第 4 部分:递归和动态编程

18.使用装饰器来记忆

只需添加@cache装饰器

# No memoization O(2**N) time complexity
def fib(n):
  return fib(n - 1) + fib(n - 2) if n > 1 else n# Memoized, now O(N) time complexity
**from functools import cache
@cache**
def fib(n):
  return fib(n - 1) + fib(n - 2) if n > 1 else n# Similar to doing this
memo = {}
def fib(n):
  return memo.setdefault(n, fib(n - 1) + fib(n - 2) if n > 1 else n)# You can limit the memo size to N
# using lru_cache (here N = 64)
**from functools import lru_cache
@lru_cache(64)**
def fib(n):
  return fib(n - 1) + fib(n - 2) if n > 1 else n

谁知道记忆这么容易！

19.使递归程序迭代

这里有一个使用制表(O(n)空间复杂度)制作迭代斐波那契函数的例子。

def fib(n):
  fibs = [None] * n
  fibs[0], fibs[1] = 0, 1
  for i in range(2, n):
    fib[i] = fib[i - 1] + fib[i - 2]
  return fib[i]

这里有一个O(1)空间复杂度版本。

def fib(n):
  if n <= 1:
    return n
  first, second = 0, 1
  for i in range(2, n + 1):
    first, second = second, first + second
  return second

另一个让程序迭代的方法是创建你自己的栈。【StackOverflow 的这个回答很好地解释了为什么。

第四部分:杂项

20.三元 if 运算符

其他语言中的condition ? a : b是 Python 中的a if condition else b

21。操作二进制字符串

通过切片去掉使用bin后烦人的0b前缀——比如bin(7) = "0b111 so bin(7)[2:] = "111"
要将前导零添加到 N 位数，添加2**N，然后切片——例如，用零填充111，直到它的长度为 5 位数，执行bin(2**5 + 7)[3:] = “00111”(注意2**N > num可以工作)

22.可变对象与不可变对象

可变对象可以被改变，而不可变对象不能。这里列出了内置类型以及它们是否是不可变的。自定义类通常是可变的。

来源:Python 的可变和不可变的一面

这只是意味着您需要小心地从可变对象的现有变量中创建变量。您可能会无意中更改现有对象！

ones = [1] * 3
twos = ones
for i, _ in enumerate(twos):
  twos[i] = 2
print(twos) # [2, 2, 2]
print(ones) # Also [2, 2, 2]!

为了避免这种情况，您需要从变量创建一个副本。

ones = [1] * 3
**twos = list(ones) # Creates a copy instead**
for i, _ in enumerate(twos):
  twos[i] = 2
print(twos) # [2, 2, 2]
print(ones) # [1, 1, 1]**# or using list comprehension** twos = [2 for i in ones]
print(twos) # [2, 2, 2]
print(ones) # [1, 1, 1]

如果你有任何问题或额外的建议，请评论，祝你面试的人好运！

1x1 卷积:去神秘化

原文：https://towardsdatascience.com/1x1-convolution-5219bbc09027?source=collection_archive---------9-----------------------

阐明了 1x1 卷积运算的概念，它出现在林等人的论文《网络中的网络》和 Google Inception 中

利亚姆·查默尔在 Unsplash 上的照片

不久前，我阅读了林等人的网络中的网络(NiN)论文，发现了一种特殊的卷积运算，它允许跨通道参数级联，通过汇集跨通道信息来学习复杂的交互作用。他们称之为“跨通道参数池层”(如果我没记错的话)，将它比作一种涉及与 1x1 卷积内核进行卷积的操作。

当时略读细节(就像我经常使用这种深奥的术语一样)，我从未想过我会写这个操作，更不用说提供我自己对其工作方式的想法了。但正如它所言，通常是术语看起来令人生畏，而不是概念本身；这点挺有用的！在完成了背景故事和效果暂停之后，让我们揭开这个奇特但多用途的 1x1 卷积层的神秘面纱。

1x1 卷积:

顾名思义，1x1 卷积运算涉及使用大小为 1x1 的滤波器对输入进行卷积，通常使用零填充，步长为 1。

举个例子，假设我们有一个(通用)卷积层，它输出一个形状为 (B，K，H，W) 的张量，其中，

B 代表批量。
K 是卷积滤波器或内核的数量
H，W 为空间尺寸，即高度和宽度。

此外，我们指定一个我们想要使用的过滤器大小，这是一个正方形过滤器的单一数字，即 size=3 意味着一个 3x3 过滤器 。

用 F 滤镜将这个张量馈入我们的 1x1 卷积层(补零和步长 1)，我们将得到形状 (B，F，H，W) 的输出，将我们的滤镜维度从 K 改为 F. Sweet！

现在，根据 F 比 K 小还是大*，我们已经减少或增加了我们在过滤空间中输入的维度，而没有应用任何空间变换(您将看到)。所有这些都使用 1x1 卷积运算！*

但是等等，这和常规的卷积运算有什么不同呢？在常规卷积运算中，我们通常有一个较大的滤波器大小，比如一个 3x3 或 5x5(甚至 7x7)的内核，然后通常需要对输入进行某种填充，这又会将其空间维度 H x W 转换为某个H’x W’； capisce？如果没有，这里是我的文章链接，任何关于卷积网及其操作的澄清。

https://cs231n.github.io/convolutional-networks/

好处？

在 CNN 中，我们经常使用某种池操作来对卷积输出的激活图进行空间下采样，以防止事情变得难以处理。难以处理的危险是由于生成的激活图的数量与 CNN 的深度成比例地急剧增加或放大。也就是说，网络越深，它生成的激活图数量就越大。如果卷积运算使用大尺寸的滤波器，如 5×5 或 7×7 滤波器，导致大量的参数，问题会进一步恶化。

理解:****滤波器指的是作为卷积运算的一部分，以滑动窗口方式应用于输入的内核。另一方面,激活图是在输入图像上应用单个滤波器的输出结果。具有多个过滤器的卷积运算通常生成多个(堆叠的)激活图。

空间缩减采样(通过池化)是通过在每一步减少输入的高度和宽度，沿空间维度聚合信息来实现的。虽然它在某种程度上保持了重要的空间特征，但是在下采样和信息损失之间确实存在一种折衷。底线:我们只能在一定程度上应用池化。

1x1 卷积可用于解决这一问题，它提供基于过滤器的池化，充当投影层，跨通道池化(或投影)信息，并通过减少过滤器数量实现降维，同时保留重要的特征相关信息。

这在 Google 的 inception 架构中被大量使用(参考文献中的链接),他们陈述如下:

上述模块的一个大问题是，至少在这种幼稚的形式中，在具有大量滤波器的卷积层上，即使是适度数量的 5×5 卷积也可能非常昂贵。

这导致了所提出的架构的第二个想法:在计算需求增加太多的地方明智地应用维度缩减和投影。这是基于嵌入 : **的成功，即使低维嵌入也可能包含大量关于相对大的图像块的信息。**除了用作还原，它们还包括使用整流线性激活，这使它们具有双重用途。

在昂贵的 3x3 和 5x5 卷积之前，他们引入了使用 1x1 卷积来计算缩减。代替使用汇集的空间维度减少，可以使用 1x1 卷积在过滤器维度中应用减少。

Yann LeCun 提供了一个有趣的思路，他将 CNN 中的全连接层比作简单的卷积层，具有 1x1 卷积核和一个全连接表。参见 2015 年的这篇文章:

履行

讨论了概念之后，是时候看看一些实现了，这对于一些基本的 PyTorch 经验来说是很容易理解的。

我复制 DeepPhys 项目的代码。作者代码

这里，我用 softconv 来表示 1x1 卷积。这是最近一个项目的代码片段，其中 1x1 卷积用于将信息投射到过滤器维度(本例中为 32 个维度)上，并将其汇集到一个维度中。这给我的用例带来了三个好处:

将来自 32 个二维激活图(通过在输入上卷积前一卷积层的滤波器生成)的信息投影到单个激活图中(记住， softconv 层的输出具有滤波器 dim = 1)。为什么我需要这样一个投影，下面的图片解释了这一点。
使用 1x1 卷积降低维度，允许控制计算需求。这是基于直觉和低维嵌入的成功，低维嵌入在自然语言处理领域中工作得相当好。
在可视化将要学习的过滤器权重方面提供了更好的易处理性，即能够回答该层实际上对给定输入做了什么，以及理解什么模型正在学习。

此外， tanh 和 sigmoid 激活是实施细节，在本文中可以忽略。

为了让大家理解可能使用 1x1 卷积的想法，我提供了一个在 DEAP 情感数据集上训练的模型的示例用例，而没有深入研究许多细节。该模型被训练为从面部视频(图像)中预测心率信号。这里，使用 1×1 卷积层将来自 32 个滤波器(从先前的卷积中获得)的信息汇集到单个通道中，允许模型创建掩模，从而能够区分皮肤和非皮肤像素。这是一项正在进行的工作，但希望人们可以看到这里使用 1x1 卷积的意义。

面部图像被用作输入。来自 DEAP 数据集的影像

应用常规卷积层后 32 个滤波器的状态。图片作者。

从 softconv 层获得的输出，其中 32 个滤波器汇集成一个通道。作者图片

关键要点:

1×1 卷积 可以被视为一种操作，其中在输入上应用1×1×K大小的滤波器，然后加权以生成 F 个激活图。
F > K 导致滤波器尺寸增加，而 F < K 将导致滤波器尺寸减小的输出。F 值很大程度上取决于项目要求。减少维度可能有助于使事情更容易处理，并且可能有类似的用例使用 1x1 卷积增加过滤器的数量。
理论上，使用这种操作，神经网络可以使用 1x1 卷积来“选择”要查看的输入“过滤器”，而不是强制乘以一切。

参考文献:

【1】Stats stack exchange:https://Stats . stack exchange . com/questions/194142/what-does-1x1-convolution-mean-in-a-neural-network

[2]林等著《谷歌盗梦空间架构:用回旋深化》

【3】文章:https://iamaaditya . github . io/2016/03/one-by-one-convolution/

【4】https://machinelingmastery . com/introduction-to-1x1-convolutions-to-reduce-the-complexity-of-convolutionary-neural-networks/

[5]“DEAP:使用生理信号进行情感分析的数据库”，S. Koelstra，C. Muehl，M. Soleymani，J.-S. Lee，A. Yazdani，t .易卜拉希米，T. Pun，A. Nijholt，I .帕特雷，IEEE 情感计算汇刊，第 3 卷，第 1 期，第 18–31 页，2012 年

测量模型不确定性的两种简单方法

原文：https://towardsdatascience.com/2-easy-ways-to-measure-your-image-classification-models-uncertainty-1c489fefaec8?source=collection_archive---------7-----------------------

更好地理解模型预测的关键

在这篇文章中，我们将介绍两种方法，让您获得模型的不确定性:蒙特卡洛漏失和深度集成。它们适用于各种各样的任务，但是在本文中，我们将展示一个关于图像分类的例子。它们都相对容易理解和实现，都可以容易地应用于任何现有的卷积神经网络架构(例如，ResNet、VGG、 RegNet 等)。).为了帮助您快速轻松地应用这些技术，我将提供用 PyTorch 编写的这些技术的补充代码。

给定一个两个杯子的图像，你的预测模型有多大把握？图片作者。

在我们开始之前，让我们回顾一下测量模型不确定性的含义，以及它如何对您的机器学习项目有用。

什么是模型不确定性？

就像人类一样，机器学习模型可以在其预测中显示一定程度的信心。一般来说，当谈到模型不确定性时，要区分认知不确定性和随机不确定性。

认知不确定性是模型参数中表示的不确定性，并捕捉关于最适合解释我们数据的模型的无知。这种类型的不确定性可以通过额外的训练数据来减少，因此具有另一个名称**“可减少的不确定性”**。对于远离训练数据的输入，模型将传播高认知不确定性，而对于训练数据附近的数据点，模型将传播低认知不确定性。

随机不确定性捕捉环境固有的噪声，即观测值。与认知不确定性相比，这种不确定性不能通过更多的数据来减少，但可以通过更精确的传感器输出来减少。

第三种类型称为预测不确定性，它是模型输出中传递的不确定性。预测不确定性可以结合认知不确定性和随机不确定性。

4 类分类器的 softmax 输出示例。该值不适用于不确定性估计。图片作者。

如果你自己已经训练了简单的神经网络，那么最直观的要考虑的是你的模型的 softmax 输出，即你经常看到的作为模型预测结果显示的百分比值。

但是使用 softmax 输出作为模型不确定性的度量可能会产生误导，并且不是很有用。这是因为 softmax 函数所做的只是计算模型的不同激活值之间的某种“关系”。因此，您的模型可以在其输出层的所有神经元中具有低激活值和仍然达到高 softmax 值。这不是我们的目标。但值得庆幸的是，有多种更有效的技术来估计模型的不确定性，如蒙特卡洛剔除和深度集成。

为什么模型不确定性有用？

评估模型的不确定性有两个主要方面很有用:

首先是透明度。假设您正在构建一个应用于医学图像分析的机器学习模型。因此，使用您的工具的医生很大程度上依赖于它的能力来做出正确的诊断。如果你的模型现在做出一个预测，它实际上是高度不确定的，但确实将这一信息传达给了医生，那么对患者治疗的后果可能是致命的。因此，在判断模型的预测时，对模型的不确定性进行估计可以极大地帮助医生。

第二是显示出改进的空间。没有一个机器学习模型是完美的。因此，了解您的模型的不确定性和弱点实际上可以通知您对您的模型进行哪些改进。实际上有一门专门的学科叫做主动学习。假设您已经用 1000 幅图像和 10 个类训练了您的 ConvNet。但是你还有 9000 多张图片没有被标记。如果您现在使用训练好的模型来预测哪些图像最不确定，您只能标记这些图像并重新训练模型。已经表明，与这些图像的随机采样相比，这种类型的不确定性采样对于模型改进更加有效。

好了，足够的先决条件，让我们来看两个技术。

技巧 1:蒙特卡洛辍学

Monte Carlo Dropout，或简称为 MC Dropout，是一种在模型中使用 Dropout 层来创建模型输出变化的技术。

一种应用于神经网络的简化的漏失可视化。图片作者。

脱层通常在训练中用作 r 均衡技术。在网络向前传递的过程中，一些神经元以一定的概率被随机丢弃。已经证明这使得模型对于过拟合更加鲁棒。通常，这些脱落层在训练后被禁用，以便不干扰新图像的向前传递。因此，要使用这种技术，请确保在您的模型中至少实现了一个 dropout 层。这可能看起来像这样。

import torch
import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

        # Dropout layer defined with 0.25 dropout probability
        self.dropout = nn.Dropout(0.25)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = torch.flatten(x, 1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))

        # Dropout applied
        x = self.dropout(x)

        x = self.fc3(x)

        return x

model = Model()

但是对于 MC 脱落，脱落层仍然被激活，这意味着神经元仍然可以随机脱落。这导致了模型的 softmax 结果的变化。要在推理或测试期间放弃，请使用以下代码:

for module in model.modules():
    if module.__class__.__name__.startswith('Dropout'):
        module.train()

现在辍学仍然适用，因为我们已经把所有辍学层进入训练模式！

假设我们现在想要获得一个图像上的模型的不确定性。为此，我们将不仅在图像上预测一次，而且多次和分析由多次向前传递产生的不同输出。我建议让模型在一张图像上预测 3 或 5 次**。我将在本文末尾讨论如何组合 3 或 5 个输出。**

技巧 2:深度合奏

估计模型不确定性的第二种技术利用了创建模型集合的优势。不是使用一个模型并使用它预测 5 次，而是使用多个相同类型的模型，随机初始化它们的权重并根据相同的数据训练它们。

多个神经网络集成的可视化，类似于深度集成方法。图片作者。

这也将产生模型参数的变化。如果模型被稳健地训练并且对图像是确定的，那么它将为每次向前传递输出相似的值。要初始化模型，最好将它们保存为模型列表:

# How many models do we want to have in our ensemble
n_ensemble = 5

# Initialize the ensemble
ensemble = [Model() for e_model in range(n_ensemble)]

初始化之后，所有模型都用相同的训练数据进行训练。**就像对于 MC 辍学生一样，3 或 5 个型号是一个不错的选择。**为了获得给定图像上的模型的不确定性，它通过集合中的每个模型，并且其预测被组合用于分析。

组合来自多个正向传递的模型输出

假设我们已经为 MC 丢失定义了 5 次前向传递，并且为深度集合定义了 5 个集合大小。**我们现在预计这些输出之间会有一些变化，显示出模型的不确定性。**为了得出不确定性的最终值，必须首先对这些输出进行叠加。该代码是一个示例，说明如何为 MC 辍学者实现这一目标:

import numpy as np

fwd_passes = 5
predictions = []

for fwd_pass in range(fwd_passes):
    output = model(image)

    np_output = output.detach().cpu().numpy()

    if fwd_pass == 0:
        predictions = np_output
    else:
        predictions = np.vstack((predictions, np_output))

首先，我们定义要执行的向前传递的次数，以及要保存所有预测的空列表。然后我们执行 5 次向前传球。第一个输出作为 numpy 结果数组的初始化，所有其他输出都堆叠在顶部。

这是具有相同基本原则的深度合奏的代码:

import numpy as np

predictions = []

for i_model, model in enumerate(ensemble):
    output = model(image)

    np_output = output.detach().cpu().numpy()

    if i_model == 0:
        predictions = np_output
    else:
        predictions = np.vstack((predictions, np_output))

现在我们已经合并了所有的输出，让我们看看如何从这些输出中计算模型的不确定性。

获得模型不确定性

为了简单起见，我们将使用预测熵来估计模型在给定图像上的不确定性。

给定 y(标签)、x(输入图像)、Dtrain(训练数据)、c(类别)、p(概率)的预测熵的数学公式。来源:【1】

一般来说，预测的不确定性告诉你你的模型看到这个图像有多“惊讶”。如果该值较低，则模型对其预测有把握。如果结果是高的，模型不知道它在图像中。

计算预测不确定性可以通过这段代码来实现，这段代码从前面接收了预测数组作为输入。

import sys
import numpy as np

def predictive_entropy(predictions):
    epsilon = sys.float_info.min
    predictive_entropy = -np.sum( np.mean(predictions, axis=0) * np.log(np.mean(predictions, axis=0) + epsilon),
            axis=-1)

    return predictive_entropy

等式中的ε防止除以 0，这在数学上没有定义。

好吧！现在，你有了一个图像的不确定度值。如前所述，值越高，您的模型越不确定。

包装它

在本文中，您已经学会了估计模型的不确定性。这种技术也可以应用到物体检测上，并且非常强大。虽然我希望这个故事让你对这个主题有了一个很好的初步了解，但还有很多东西需要发现。

最后但同样重要的是，如果你想在高级计算机视觉领域更深入地探索，考虑成为我的追随者。我试着每周发一篇文章，让你和其他人了解计算机视觉研究的最新进展。

参考资料:

[1]深度学习中的不确定性，Yarin Gal。http://mlg.eng.cam.ac.uk/yarin/thesis/thesis.pdf

用 Python 创建精美象形图的两种有效方法

原文：https://towardsdatascience.com/2-efficient-ways-of-creating-fancy-pictogram-charts-in-python-8b77d361d500?source=collection_archive---------27-----------------------

什么是象形图，何时使用，以及如何在 Plotly 和 PyWaffle 库中创建它们

作者图片

象形图使用排列在网格中的图标子集来说明相对较小的离散数据集的各个组成部分。每个图标代表整个数据集的一个单元(有时是 10 个、100 个等)。单位)，图标的每个子集—数据的相应类别。最佳实践是使用简单但有意义且直观易懂的图标，最好是对称形式，并避免部分图标。

当涉及到以一种更有影响力、更有说服力、更吸引人和更容易解释的方式向观众展示数据时，象形图是“无聊”条形图的一个很好的替代品。它们对于显示统计信息、医疗数据、比例或百分比、评级、进度状态、技能水平特别有效。

如何用 Python 创建象形图图表？在这篇文章中，我们将看看在一段时间内使用学习平台用户虚拟数据集的几种方法。比方说，我们有以下类型的用户:普通用户、新用户、变动用户和暂停用户:

import pandas as pd
dict_users = {'Regular': 62, 'New': 20, 'Churned': 16, 'Suspended': 2}
df = pd.Series(dict_users)

阴谋地

安装: pip install plotly

其中一个方法是使用 Plotly 库，在这个博客上，我找到了一个有趣的解决方案。下面是该代码的简化版本:

import plotly.graph_objs as go
num_rows = 10
row = 0
column = 0
data = []
for category, count in df.iteritems():
    rows = []
    columns = []    
    for _ in range(count):
        if row == num_rows:
            row = 0
            column += 1
        rows.append(row)
        columns.append(column)        
        row += 1
    data.append(go.Scatter(x=columns, y=rows, mode='markers', name=category))
fig = go.Figure(dict(data=data, layout=go.Layout(plot_bgcolor='white',
                                                 xaxis=dict(visible=False), 
                                                 yaxis=dict(visible=False))))
fig.show()

作者图片

标记的默认形式是一个圆形，Plotly 的默认颜色非常令人愉快。我们可以进一步定制这个图表，使它看起来更“象形”:更改标记的大小、颜色和形状，添加一个图标题并对齐它。可选地，可以改变类别的排列方向，使其水平(在我们的例子中，我们只需将rows分配给x，将columns分配给y)。让我们应用这些修改:

num_rows = 10
row = 0
column = 0
data = []
colors_list = ['slateblue', 'limegreen', 'red', 'grey']
colors = {df.index[i]:colors_list[i] for i in range(len(df))}
for category, count in df.iteritems():
    rows = []
    columns = []
    for _ in range(count):
        if row == num_rows:
            row = 0
            column += 1
        rows.append(row)
        columns.append(column)        
        row += 1
    data.append(go.Scatter(x=rows, y=columns, mode='markers', 
                           marker={'color': colors[category], 'symbol': 'star', 'size': 20},                        
                           name=category))
fig = go.Figure(dict(data=data, layout=go.Layout(plot_bgcolor='white',
                                                 xaxis=dict(visible=False), 
                                                 yaxis=dict(visible=False))))
fig.update_layout(title='User dynamics in July 2021', title_x=0.45, title_y=0.85, font=dict(size=18))
fig.show()

作者图片

现在，我们的图像一个真正的象形图。但是，仍有两个问题需要考虑:

标记形状(又名图标)的选择非常有限(你可以在这个文档页面上找到选项的完整列表)。正如我们在介绍中提到的，我们更喜欢以一种相关的、普遍可理解的形式来显示它们，比如当一个下雨的云图标代表下雨时。有一个变通办法是使用字体牛逼图标代替标准符号，的确，在有原始代码的博客中，我们可以找到它的解决方案。然而，这种解决方案虽然高效，却意味着要添加 JavaScript 代码，而且总的来说，看起来有点令人不知所措。
图表的交互性，通常反映了 Plotly 的一个奇特的方面，在这种情况下，似乎是多余的。仍然有可能禁用该功能(例如，这篇文章可能有用)。与前一种情况一样，这意味着使代码更加复杂。

现在让我们考虑用 Python 创建象形图的第二种方法，看看这次代码是否会更简洁。

PyWaffle

安装: pip install pywaffle

这个库基于 matplotlib，也需要导入它。PyWaffle 的基本图是用正方形作为图标的华夫饼图:

from pywaffle import Waffle
import matplotlib.pyplot as plt
fig = plt.figure(FigureClass=Waffle, figsize=(5,5), values=dict_users, rows=10)

作者图片

虽然生成的图表(概念上)类似于我们在开始时用 Plotly 生成的图表，但创建它的代码似乎要简洁得多。为了使它看起来像一个真正的象形图，有一些调整适用，虽然:

显示有意义的图标，而不仅仅是方块。幸运的是，在这种情况下，我们有更多的自由:

a)使用characters参数，该参数接受长度与类别数量相同的一系列 Unicode 字符。相反，如果我们想对所有类别使用相同的符号，使它们仅在颜色上有所不同，我们可以传入一个包含该字符的字符串。例如，characters = '❤️'会产生一个充满心形的象形图。

b)使用icons参数，该参数接受代表字体牛逼图标的字符串列表。同样，这个列表的长度应该与类别的数量相同；或者，我们可以只分配一个字符串，让所有类别都有相同的图标。需要注意的是，在字体很棒的图标中，有不同的样式包含不同的图标集。默认情况下，样式是纯色的，但是我们也可以从常规、双色调、品牌和浅色中选择，为参数icon_style分配一个相应的字符串(全部是小写字母)，或者一个字符串列表，以防我们希望不同的类别有不同样式的图标。

更改类别颜色，使其更加直观。要调整颜色，一个选项是将颜色列表传递给参数colors，另一个选项是将离散的 matplotlib 颜色图分配给参数cmap_name。我们将使用第一种方法，并传递与上面第二个图表相同的颜色选择。
添加地块标题。创建华夫饼图形时，可以使用接受参数matplotlib.pyplot.title的参数title作为字典，或者直接使用matplotlib.pyplot.title。
将图例移向图表的侧面或下方。可以使用接受matplotlib.pyplot.legend参数的参数legend作为字典，或者直接使用matplotlib.pyplot.legend。

fig = plt.figure(FigureClass=Waffle,
                 figsize=(10,5),
                 values=dict_users,
                 rows=10,
                 colors=list(colors.values()),
                 icons=['user','user-plus', 'user-minus', 'user-clock'],
                 font_size=22,
                 icon_legend=True,
                 legend={'bbox_to_anchor': (1.55, 1), 'fontsize': 15, 'frameon': False})
plt.title('User dynamics in July 2021', fontsize=25)
plt.show()

作者图片

对于象形图，还有一些其他参数需要调整:

starting_location —设置开始第一个块的拐角。可能的值:'SW'(默认)、'NW'、'NE'和'SE'。
vertical —是否逐列绘制块，即水平放置类别(vertical=False，默认)，还是逐行垂直绘制(True)。
block_arranging_style —指定用图标填充象形图的方式。可以是normal(默认)、snake(从对面开始每一行，像个之字形)，也可以是new-line(每个类别从新一行开始)。要使最后一个选项起作用，需要分配或仅分配columns(而不是rows)与vertical=True组合，或者默认情况下仅分配rows离开vertical。

最后，如果 PyWaffle 的功能不足以满足我们的目的，我们可以考虑添加任何我们需要的 matplotlib 方法。

让我们修改之前的象形图，将每个类别从左上角开始放在新的一行上，并添加相应的文本注释，而不是图例:

fig = plt.figure(FigureClass=Waffle,
                 figsize=(9,7),
                 values=dict_users,
                 columns=21,
                 vertical=True,
                 starting_location='NW',
                 block_arranging_style='new-line',
                 colors=list(colors.values()),
                 icons=['user','user-plus', 'user-minus', 'user-clock'],
                 font_size=18)
plt.title('User dynamics in July 2021', fontsize=25)
fig.text(x=-0.095, y=0.562, s='Regular', fontsize=15)
fig.text(x=-0.057, y=0.441, s='New', fontsize=15)
fig.text(x=-0.105, y=0.382, s='Churned', fontsize=15)
fig.text(x=-0.135, y=0.323, s='Suspended', fontsize=15)
plt.legend([])
plt.show()

作者图片

结论

在本文中，我们探讨了什么是象形图，它们何时特别有用，以及如何使用 Plotly 和 PyWaffle 库在 Python 中创建它们。

感谢阅读！

你会发现这些文章也很有趣:

https://medium.com/geekculture/creating-toyplots-in-python-49de0bb27ec1 </5-pandas-methods-youve-never-used-and-you-didn-t-lose-anything-37277fae7c55>

使用泊松分布之前你应该知道的 2 个函数

原文：https://towardsdatascience.com/2-functions-you-should-know-before-using-poisson-distribution-d470db790bfc?source=collection_archive---------17-----------------------

概率分布

我们在哪里使用泊松分布？

Marcin Jozwiak 在 Unsplash 上拍摄的照片

泊松分布依赖于在特定区域或区间发生的独立随机事件的数量。我们可以用它来计算某一特定事件在某一时间间隔内发生给定次数的概率。术语间隔通常是时间。比如 x 辆车在 13:00 到 14:00 之间穿越高速公路的数量的概率。在指定时间间隔内，停放在某个停车位的 x 辆车的数量的概率。这些是我们使用泊松分布得到概率值的例子。

根据泊松分布的这些使用案例，它看起来类似于指数分布，但是有一个重要的点将它们彼此分开。与泊松分布不同，指数分布关注事件在一个间隔内发生的秒的概率。这是指数分布和泊松分布的区别。

泊松是如何计算的？

从分布中获取概率值有两种类型的函数:质量函数和密度函数。密度函数用于连续概率分布。质量函数用于离散概率分布。由于泊松分布是一个离散的概率分布，我们使用概率质量函数这一术语。那么，我们怎么知道泊松分布是离散的。如前所述，泊松发现特定事件发生的次数的概率。所以，次数不可能是 3.435 或者 1.123，可以是 5，1，12 这样的整数。这意味着服从泊松分布的变量的值应该是离散的。

公式 1 显示了泊松概率质量函数的公式。如你所见，有两个参数“x”和“lambda”。λ代表给定时间间隔内发生的平均事件数。一些资料来源也可以将该平均值表示为“mu ”,因为它是一个平均值。“X”值表示当平均事件数等于λ值时，该事件将发生的次数。

公式 1 —泊松分布的 PMF

让我们尝试解决一个示例概率问题，以了解如何使用泊松概率质量函数计算概率值。假设我们连续十天在下午 3 点到 4 点之间观测了博斯普鲁斯海峡大桥。我们记录了穿越的车辆数量。λ值应该是每天从桥上通过的车辆数量的平均值，为 10。假设，发现平均值是 100。我们想获得第二天下午 3 点到 4 点之间 80 辆车通过的概率。那么,“x”的值应该是 80。让我们把数字放在它们应该在的地方。

公式 2——泊松分布 PMF 的计算

如你所见，80 辆汽车通过的概率为 0.0051。这是一个非常低的概率，接近于零。这是因为我们发现正好有 80 辆车通过这座桥。所以获得这么低的概率很正常。那么,“x”的哪个值给出的可能性最大？为了理解“x”和“λ”之间的关系，可以参见图 1。

图 1-基于不同λ值的车辆通过概率的泊松分布。(图片由作者提供)

图 1 显示了基于三个不同 lambda 值的穿越车辆数量概率之间的差异(穿越车辆的平均数量)。当车辆数量等于λ值时，总是获得最高的概率。因此，随着车辆数量开始在两个方向上远离λ值，概率开始降低。然而，随着λ值的增加，平均概率值减小。这是因为在此期间可能会发生更多的事件。

注意:查看图 1 中的分布形状，泊松分布和正态分布可能看起来是相同的。然而，与正态分布不同，泊松分布的方差等于其均值。此外，正态分布是一个连续的概率分布。

累积分布函数

在前面的例子中，我们已经找到了正好 80 辆汽车从桥上通过的概率。也有可能从该桥找到多于或少于 80 个交叉点的可能性。这就是毒物分布的累积分布函数(CDF)所代表的。CDF 将每个事件的概率总和取值为“k”。可以看公式 3，了解泊松分布的 CDF 是做什么的。

公式 3 —泊松分布的 CDF

让我们找出当平均通行次数为 100 时，少于 80 辆车通过这座桥的概率。

公式 4——少于 80 辆汽车过桥的概率

概率值是 0.02264。意味着 15:00-16:00 之间过桥的车辆不可能少于 80 辆。如果我们从 1 中减去 0.02264，值 0.97736 给出了在 15:00 到 16:00 之间超过 80 辆车过桥的概率。

结论

泊松分布的例子通常取决于时间间隔。但是，也可以定义您的自定义范围。该范围也可以按地区划分。例如，落在 100 米田地上的雨滴数量或停在街道前 100 米的车辆数量。您可以使用泊松分布来寻找事件数量的概率，只要您设置一个覆盖事件发生的边界。

我也强烈推荐你去了解指数分布，了解 ED 和 PD 的区别。但是，您可能对特定事件在特定时刻发生的概率感兴趣。如果有，请看我另一篇关于指数分布的文章。

我在第一份数据科学家工作中犯的两个错误

原文：https://towardsdatascience.com/2-mistakes-i-did-at-my-first-job-as-a-data-scientist-df02b03f833e?source=collection_archive---------17-----------------------

我们都从错误中学习

布雷特·乔丹在 Unsplash 上的照片

我对数据科学的热情始于大约 3 年前。经过漫长而激动人心的学习之旅，我终于找到了第一份工作，成为一名数据科学家。我已经写了几篇文章来分享我的学习经历和让我得到理想工作的过程。

在这篇文章中，我将写下我作为数据科学家开始第一份工作后的经历。到目前为止，这是令人兴奋和有趣的，我很高兴我的职业生涯转向了数据科学。

然而，我也面临过一些挑战，犯过一些错误。犯一个错误是可以的，但是如果你犯了几次同样的错误，这可能会变成一个问题。因此，我们应该从错误中吸取教训。这就是我们如何能做得更好的方法。

正如我刚才提到的，我犯了一些错误，我已经从中吸取了教训。我想和你分享其中的两个，这样你可以在你的第一份工作中为这样的错误做好准备，或者你可以避免它们，这样更好。

没有花足够的时间准备数据

我们做零售分析。我被分配了一项任务，创建一个模型来查看某些功能和销售额之间的关系。关于模型的细节在这里并不重要。重点是我如何处理问题以及我遵循的步骤。

在我获得原始数据后，我做了一些数据清理和预处理。我还创建了一个我认为对模型很重要的附加特性。然后，我想我已经准备好做模型了。

我在模型创建上花了相当长的时间。我做了几次迭代，创建一个模型，评估它，并试图通过修改来改进。然而，最终结果是不可接受的。我无法创建一个如预期那样工作的模型。

然后，我又回到了探索性数据分析阶段。我在数据上花了更多的时间去理解它。我增加了几个新功能。通过回到数据探索阶段，我认识到我构建了一个具有错误特征的模型。

我的错误是没有在数据上花足够的时间。实际上，我知道模型构建中最重要的部分是很好地理解数据。然而，我却反其道而行之。这可能是由于我异常兴奋。

这是一个很好的经验教训。我永远不会忘记它。下次我被分配到类似的文本时，我一定会相应地组织我的计划和努力。

重复行

这是一个比前一个更具体的错误，并且有一个更简单的解决方案:只需检查重复项。

当我学习数据科学时，我通常使用一个数据集进行练习。因此，我不必经常使用连接、合并或串联操作。然而，在实际任务中，数据分散在许多表或数据框中，您需要执行许多操作来将所需的数据组合在一起。

我们的技术非常丰富。我在日常工作中经常使用 Python、SQL、R 和 PySpark。使用这些工具组合数据的功能和方法是相似的，但都有自己的语法。

我认为合并数据时最大的风险是创建重复的数据点(或行)。如果正确应用该函数，生成的数据框或表将不会有任何重复。但是，这个过程容易出错。因此，您需要格外小心，在脚本中放置重复的检查。

我的任务包括从许多不同的资源中收集数据。我忘了做重复检查。当我对生成的数据帧进行分析时，我意识到了这个问题。数量相差甚远。

即使你对你的代码有把握，额外的谨慎也没有坏处。添加一个副本可能会使您免于重复工作。

重复的数据点可能会导致严重的问题，尤其是当累积数量对您的案例很重要时。我建议多次检查数据框或表中的重复条目。与其从头开始做整个操作，不如做一个额外的控制。

结论

我们都会犯错。我在这篇文章中提到的是一些新手的错误。但是，这并不意味着只有新手或初级犯错误。这可能发生在你职业生涯的任何时候。结果可能会有所不同:)

重要的是花足够的时间去理解错误的根源，以便我们从中吸取教训。这样，你会比从教程或通过阅读来学习更好。

感谢您的阅读。如果您有任何反馈，请告诉我。

训练机器学习模型时要避免的 2 个错误

原文：https://towardsdatascience.com/2-mistakes-to-avoid-when-training-your-machine-learning-model-8af1e855f30a?source=collection_archive---------35-----------------------

我们的工作就是给模特提供一顿像样的饭菜。

莎拉·基利安在 Unsplash 上的照片

机器学习可以被认为是数据科学的一个子学科。与传统编程不同，机器学习模型会自己检测规则或关系。

机器学习模型需要数据来检测或计算这些规则。这就是我们训练他们的原因。训练过程是模型创建中最重要的一步。一旦我们有了一个训练有素的模型，进行预测就会天衣无缝。

训练一个模型就是让它学习数据。这种培训的质量和表现取决于几个因素。关键的因素是给我们的模型适当和干净的数据。

我们有责任准备这些适当的数据。剩下的就看模型了。在本文中，我们将重点关注在培训阶段出现的两个潜在错误。避免这些错误对于能够建立准确且性能良好的机器学习模型至关重要。

1.一起扩展

我们通常在一个数据集中有许多特征(即列)。这些特征可能是离散的，也可能是连续的。离散变量可以是分类的，也可以是数字的。

例如，代表房屋中房间数量的特征是一个离散的数值变量。另一方面，包含性别信息的列是分类变量。

数值变量可能有不同的取值范围。房子里的房间数量和房子的平方米面积是两个具有非常不同范围的特征。

除非你住在庄园里，否则大多数房子都少于 10 个房间。然而，当我们谈论以平方米为单位的面积时，范围通常是从 100 开始向上。我们也可能有值范围差距较大的特征。

一些算法期望具有相似范围的特征。因此，他们需要调整数值变量，使它们处于相同的范围内。缩放有不同的方法。常用的一种是设置最小值为 0，最大值为 1。因此，所有值都将介于 0 和 1 之间。

缩放过程中的典型错误是将所有数据一起缩放。相反，我们应该首先拆分训练和测试数据。然后，我们分别对它们进行缩放。

在训练测试分割之前进行缩放的情况下，缩放参数基于整个数据来确定。这种方法的问题是模型学习关于测试集的信息。这违背了火车测试拆分的目的。

在我们训练了一个模型之后，我们应该用新的、以前看不到的数据来测试它。否则，我们将无法准确测量性能。无论您选择缩放还是归一化，您都需要在训练测试分割之后进行。

2.带有异常值的建模

数据集中的异常值没有严格的定义。异常值是与其他观察值非常不同的数据点(即观察值)。

异常值的原因可能是错误的数据。或者，可能只是极端的观察。假设我们有一个房价数据集。它包含了一些房子的特点和价格。

假设我们用房子的年龄作为特征。我们数据集中的大多数房子都有 2 到 10 年的历史了。如果我们有一栋 35 年的房子，我肯定会把它标为离群值。

定义极端情况的界限取决于问题、数据集的特征和您的方法。在任何情况下，都需要从训练数据中移除离群值。

我不是说一个异常值代表一个不现实的情况。然而，在离群值的情况下，机器学习算法很难捕捉数据中的关系。

机器学习算法对数值范围很敏感。异常值有可能破坏属性(即特征)的取值范围。因此，它会导致较差的性能和较不准确的结果。

需要注意的是，我们需要在拆分训练和测试数据后检测异常值。否则，我们将会向我们的模型泄露一些关于测试集的信息。

结论

机器学习模型的性能很大程度上取决于数据。没有像样的数据，我们不能指望一个算法变魔术，给我们好的结果。

我们有责任为机器学习算法准备好数据。我们在本文中讨论的两个错误可能会妨碍我们正确地准备数据。

感谢您的阅读。如果您有任何反馈，请告诉我。

Python 中两个必须知道的 OOP 概念

原文：https://towardsdatascience.com/2-must-know-oop-concepts-in-python-48d643a7385?source=collection_archive---------0-----------------------

遗传和多态性

在 Unsplash 上由zdenk macha ek拍摄的照片

面向对象编程(OOP)范式是围绕拥有属于特定类型的对象的思想而构建的。在某种意义上，类型是向我们解释对象的东西。

Python 中的一切都是对象，每个对象都有一个类型。这些类型是使用类声明和定义的。因此，类可以被认为是 OOP 的核心。

为了用 Python 开发健壮的、设计良好的软件产品，全面理解 OOP 是必不可少的。在本文中，我们将详细阐述 OOP 的两个关键概念，即继承和多态。

继承和多态都是设计健壮、灵活和易于维护的软件的关键因素。这些概念最好通过例子来解释。让我们从创建一个简单的类开始。

class Employee(): def __init__(self, emp_id, salary):
      self.emp_id = emp_id
      self.salary = salary def give_raise(self):
      self.salary = self.salary * 1.05

我们创建了一个名为 Employee 的类。它有两个数据属性，即雇员 id (emp_id)和薪金。我们还定义了一个名为 give_raise 的方法。它将雇员的工资提高了 5%。

我们可以创建 Employee 类的一个实例(即一个 Employee 类型的对象),并如下应用 give_raise 方法:

emp1 = Employee(1001, 56000)print(emp1.salary)
56000emp1.give_raise()print(emp1.salary)
58800.0

OOP 允许我们基于另一个类创建一个类。例如，我们可以基于 Employee 类创建 Manager 类。

class Manager(Employee):
   pass

在这个场景中，Manager 是 Employee 类的一个子类。子类从父类复制属性(数据和程序属性)。这个概念叫做继承。

需要注意的是，继承并不意味着复制一个类。我们可以部分继承父类(或基类)。Python 还允许添加新属性以及修改现有属性。因此，继承带来了很大的灵活性。

我们现在可以创建一个经理对象，就像创建一个雇员对象一样。

mgr1 = Manager(101, 75000)
print(mgr1.salary)
75000

除了从父类继承的属性之外，子类还可以有新的属性。此外，我们可以选择修改或覆盖继承的属性。

让我们更新 give_raise 方法，以便它为经理应用 10%的加薪。

class Manager(Employee): def give_raise(self):
      self.salary = self.salary * 1.10mgr1 = Manager(101, 75000)
print(mgr1.salary)
75000mgr1.give_raise()
print(mgr1.salary)
82500

我们将创建 Employee 类的另一个子类。Director 类继承了 Employee 类的属性，并用 20%的增量修改了 give_raise 方法。

class Director(Employee): def give_raise(self):
     self.salary = self.salary * 1.20

我们现在有三个不同类，它们都有一个 give_raise 方法。虽然方法的名称是相同的，但是对于不同类型的对象，它的行为是不同的。这是一个多态性的例子。

多态允许对不同的底层操作使用相同的接口。关于我们的 manager 和 director 对象的例子，我们可以像使用 employee 类的实例一样使用它们。

让我们看看多态性的作用。我们将定义一个将加薪应用于雇员列表的函数。

def bulk_raise(list_of_emps):
   for emp in list_of_emps:
      emp.give_raise()

bulk_raise 函数获取雇员列表，并将 give_raise 函数应用于列表中的每个对象。下一步是创建不同类型的员工列表。

emp1 = Employee(101, 45000)
emp2 = Manager(103, 60000)
emp3 = Director(105, 70000)list_of_emps = [emp1, emp2, emp3]

我们的列表包含一个雇员、一个经理和一个董事对象。我们现在可以调用 bulk_raise 函数。

bulk_raise(list_of_emps)print(emp1.salary)
47250.0print(emp2.salary)
66000.0print(emp3.salary)
84000.0

尽管列表中的每个对象都有不同的类型，但我们不必在函数中显式地声明它。Python 知道应用哪个 give_raise 方法。

正如我们在例子中看到的，多态性是通过继承实现的。子类(或子类)利用父类的方法来建立多态性。

结论

继承和多态都是面向对象编程的基本概念。这些概念帮助我们创建可扩展且易于维护的代码。

继承是消除不必要的重复代码的好方法。子类可以部分或全部继承父类。Python 在继承方面非常灵活。我们可以添加新的属性和方法以及修改现有的属性和方法。

多态性也有助于 Python 的灵活性。具有特定类型的对象可以像属于不同类型一样使用。我们已经看到了一个使用 give_raise 方法的例子。

感谢您的阅读。如果您有任何反馈，请告诉我。

当 Python 文件改变时自动重新加载的 2 个工具

原文：https://towardsdatascience.com/2-tools-to-automatically-reload-when-python-files-change-90bb28139087?source=collection_archive---------6-----------------------

现在，您可以重新加载循环体，而不会丢失其状态

作者图片

动机

您是否运行过 for 循环，并希望在 for 循环中添加更多细节？您可能决定不这样做，因为添加更多的细节意味着您需要停止您的进度并再次重新运行所有内容。

如果代码已经运行了几个小时，停止您的进度尤其不理想。如果你能在每次迭代中重新加载一个循环体而不会像下面这样丢失状态，那不是很好吗？

作者 GIF

在本文中，我将向您展示两个工具，当您的 Python 文件发生变化时，它们可以重新加载代码或运行任意命令。

Entr 当 Python 文件发生变化时运行任意命令

它是如何工作的

entr 允许你在文件改变时运行任意命令。为了理解 entr 是如何有用的，让我们假设我们想要创建一个函数，它接受一组数字并返回偶数。

我们将上面的文件命名为entr_examples.py。然后使用 pytest 检查get_evens函数是否返回偶数。

$ pytest entr_examples.py

作者图片

测试失败是因为我们还没有给get_evens函数添加任何代码。为了尝试不同的方法来获得偶数，让我们使用 entr 在代码改变时重新运行命令pytest entr_examples.py。

$ ls entr_examples.py | entr python entr_examples.py

作者 GIF

酷！通过使用 entr，我们不需要在开发我们的功能时重新运行相同的命令。

由于测试驱动开发的第一条法则是*“在你写完一个失败的单元测试之前，你不能写产品代码”*，entr 鼓励开发者测试不同的方法来写代码，直到它起作用。

句法

下面是 entr 的一般语法:

作者图片

注意，如果你想一次跟踪多个 Python 文件，使用ls *.py | entr command_to_run代替。这意味着如果任何被跟踪的文件被更改，command_to_run将被执行。

装置

要在 MacOS 上安装 entr，请键入:

brew install entr

要在 Ubuntu 上安装 entr，请键入:

sudo apt-get update
sudo apt-get install entr

另一种选择是克隆 entr repo 并遵循安装说明。

重新加载(reloading )-重新加载循环体而不丢失其状态

它是如何工作的

重载是一个 Python 库，允许你在每次迭代中重载一个循环体而不丢失其状态。

为了理解重载是如何有用的，假设您编写了一个输出偶数的 Python 循环。然而，当循环运行时，您还希望它在不停止循环的情况下打印奇数**。**

通常，这在 Python 中是做不到的。在下面的代码中，即使我们在执行过程中将print(f'{num} is odd')添加到循环体中，输出中也没有奇数。

作者 GIF

然而，这可以很容易地通过重新加载来完成。下面的 GIF 展示了在循环中添加重载是如何产生影响的。

作者 GIF

我们可以看到，在执行的过程中，在循环体中添加一个else语句后，奇数被打印出来！

重载在这里似乎没有什么帮助，因为执行一个 for 循环并不需要很长时间。但是如果你已经训练了几个小时的深度学习模型，并且你想在不停止循环的情况下在每个时期打印更多的统计数据，这将变得非常方便。

在这里找到如何使用你最喜欢的库重新加载。

句法

要使用reloading，只需将它添加到 Python 循环中，如下所示:

作者图片

装置

pip install reloading

结论

恭喜你！您刚刚学习了如何在 Python 文件发生变化时运行任意命令，以及重新加载 Python 循环体而不丢失其状态。现在，您可以避免浪费时间运行相同的命令或重新运行一个循环来显示更多的输出。

随意发挥，并在这里叉这篇文章的源代码:

https://github.com/khuyentran1401/Data-science/tree/master/terminal/reload_examples

我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上与我联系。

如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:

💔-tools-to-track-and-visualize-the-execution-of-your-python-code-666a153e435e> [## 3 个跟踪和可视化 Python 代码执行的工具

towardsdatascience.com](/3-tools-to-track-and-visualize-the-execution-of-your-python-code-666a153e435e) 💔-python-tricks-to-read-create-and-run-multiple-files-automatically-5221ebaad2ba> 💔-tools-to-monitor-and-optimize-your-linux-system-c8a46c18d692>

在数据科学家面试中，你可能会被问到的两个棘手的 SQL 问题

原文：https://towardsdatascience.com/2-tricky-sql-questions-you-might-be-asked-at-data-scientist-interviews-168f5226c023?source=collection_archive---------6-----------------------

SQL 是一个强大的数据分析和操作工具。

戴安娜·波莱希娜在 Unsplash 上拍摄的照片

SQL 是数据科学家的必备技能，这是不争的事实。大多数公司使用关系数据库来存储他们的数据，而 SQL 是我们与他们交互所需要的。

SQL 代表结构化查询语言，但是它能够执行的不仅仅是查询数据库。我们可以使用 SQL 来完成典型的探索性数据分析过程中的任务。在这个意义上，它类似于其他数据分析工具，如 Python 中的 Pandas 和 r 中的 data table。

在本文中，我们将讨论在数据科学家面试中可能会被问到的两个棘手的 SQL 问题。我知道第一个问题实际上是在面试时被问到的。我认为另外两个也很有可能被问到。如果没有，它遵循的程序肯定会有帮助。

我假设您对编写 SQL 查询有基本的了解。如果没有，你仍然可以继续，因为我会试着解释每一步的作用。

注:关系数据库管理系统有 MySQL、SQL Server、PostgreSQL 等几种。尽管它们大多采用相同的 SQL 语法，但可能会有一些细微的差别。在本文中，我们将使用 PostgreSQL。

问题 1

假设您有一个包含不同城市每日气温值的天气表。

天气表(图片由作者提供)

如何创建一个包含当天和第二天温差的表？对于第一行，差异列应包含值 1.2。

我们可以分两步完成这项任务:

创建一个公共表表达式(cte ),将第二天的温度作为新列
使用步骤 1 中创建的公共表表达式，计算温差

第一步中定义的表可以通过将 temperature 列移动一行，然后将其连接到原始表来创建。我们还需要考虑城市名称。我们不能使用城市 B 的温度作为城市 a 的第二天温度。

移位可以通过滞后或超前功能来完成。由于我们对第二天感兴趣，所以我们将使用 lead 函数。我们还需要按城市进行分区，并按日期对行进行排序。因此，我们确保为每一行输入适当的第二天温度。

在第二步中，我们将从第一步中创建的表中选择所有列，并计算温度和第二天温度列之间的差异。

以下是执行此操作的 SQL 查询:

WITH cte AS(
   SELECT
      W1.*, 
      LEAD(W2.temperature, 1) OVER(PARTITION BY W2.city ORDER BY 
      W2.date) AS temp_next                                                   
   FROM weather W1                                                                                                                                                   
   LEFT JOIN weather W2                                                                                                                                              
   ON W1.date = W2.date and W1.city = W2.city
)                                                                                                                       SELECT 
   *, 
   COALESCE((temp_next - temperature), 0) AS temp_diff 
FROM cte;

(图片由作者提供)

coalesce 函数可用于替换因连接而导致的缺失值。由于最后几天没有第二天的值，我们可以将差值设为 0。

问题 2

假设我们有下表，其中包含了墨尔本房屋的一些特征及其价格。

melb 表格的前 5 行(图片由作者提供)

数据集包含一个日期列，我认为它代表了房子被张贴出售的日期。我们想看看一周中的某一天是否会对房价产生影响。例如，周末发布的房屋价格可能比一周发布的价格高。

此任务涉及基于派生列的分组操作。我们将创建一个分类变量，包含从日期列中提取的星期几信息。

然后，该列将用于对观察值(即行)进行分组。

SELECT 
   EXTRACT(dow from date) AS day_of_week,   
   ROUND(CAST(AVG(price/1000000) AS numeric),3) AS avg_price_mio FROM melb 
GROUP BY day_of_week 
ORDER BY avg_price_mio DESC;day_of_week | avg_price_mio
------------+---------------
          5 |         1.123
          0 |         1.120
          4 |         1.093
          6 |         1.077
          3 |         1.073
          2 |         1.048
          1 |         1.023

聚合将应用于 price 列。我想用两个小数点显示平均值，所以我也使用了 cast 和 round 方法。

最后，结果按平均价格降序排列。

顺便说一下，本例中使用的数据集可以从 Kaggle 下载。

结论

我们已经做了两个例子来演示一些复杂的 SQL 查询。这种操作证明 SQL 能够执行数据分析和操作，就像 Pandas 对于 Python 和 data table 对于 r 一样。

SQL 是数据科学生态系统中的一个重要工具。事实上，使用 SQL 执行数据分析和操作任务比使用外部工具从数据库中检索所有数据更可取。

感谢您的阅读。如果您有任何反馈，请告诉我。

机器学习中的两种重复特征

原文：https://towardsdatascience.com/2-types-of-duplicate-features-in-machine-learning-2931de6c949b?source=collection_archive---------13-----------------------

使用 fast_ml 进行特征选择

由托尔加·乌尔坎在 Unsplash 拍摄的照片

介绍

在大多数情况下，顶尖数据科学家与其他人有两个区别:特征创建和特征选择。即，创建捕捉关于业务或客户的更深/隐藏的洞察力的特征，然后做出关于为您的模型选择哪些特征的正确选择。

特征选择在机器学习中的重要性

特征选择是在开发预测模型时减少输入变量数量的过程。

在一个广泛的特性工程步骤之后，你会得到大量的特性。您可能无法使用模型中的所有功能。您可能会对只给模型添加那些重要的特性感兴趣，或者删除那些没有任何预测能力的特性。它降低了模型训练的计算成本，也提高了模型的性能。

在之前的帖子中，我们已经看到了如何检测常量和准常量特征。

这篇文章是为了识别所有重复的功能。这些可能有两种类型:

重复值:当两个要素具有相同的一组值时
重复索引:当两个特征的值不同时，但是它们出现在相同的索引处

我们来详细了解一下这个

1.重复值(每条记录的值相同)

图片作者。对于每条记录，两个要素具有相同的值

如示例图像所示，汽车的销售年份与制造年份相同；那么，这两个特征本质上说的是同一个东西。你的机器学习模型不会通过训练这两个功能来学习任何有见地的东西。您最好删除其中一个功能。同样，还可能有更多这样的特性，您需要一种编程方式来识别这些特性。

1)使用get_duplicate_features函数获取所有常量特征。

图片作者。在一行代码中，您可以检测到所有具有重复值的特性

2)将所有重复要素存储为列表，以便从数据集中移除。

图片作者。所有重复的特征作为一个列表

3)从数据集中删除所有此类要素。我们可以看到功能的数量从 301 下降到了 251。

图片作者。从数据集中移除所有重复要素

2.重复索引(两个特征的值不同，但它们出现在相同的索引处)

图片作者。两个特征的值不同，但它们出现在相同的行中。

如示例图所示，所有“凯美瑞”汽车都是 2018 年的，所有“卡罗拉”汽车都是 2019 年的。从训练中的这些功能中，你的机器学习模型没有什么深刻的见解。我还可以对Car Model做整数编码，把凯美瑞换成 2018，卡罗拉换成 2019。那么它与上述重复值的情况 1 相同。你最好放弃这两个特性中的一个。同样，还可能有更多这样的特性，您需要一种编程方式来识别这些特性。

1)使用get_duplicate_features函数获取所有常量特征。

图片作者。在一行代码中，您可以检测到所有具有重复索引的特性

2)将所有重复的索引要素存储为列表，以便从数据集中移除。

图片作者。所有重复的索引特征作为一个列表

3)从数据集中删除所有此类要素。我们可以看到，功能的数量从 251 个下降到了 226 个。

图片作者。从数据集中移除所有重复的索引要素

摘要

在数据集中保留重复要素会带来多重共线性问题。
—在线性模型的情况下，两个特征之间的权重分配会有问题。
—如果你使用的是基于树的模式，这无关紧要，除非你着眼于特性的重要性。
—在基于距离的模型中，它将使该特征在距离中更重要。

用于检测具有重复值或重复索引的特征的代码片段:

**# Import required functions**
from fast_ml.utilities import display_all
from fast_ml.feature_selection import get_duplicate_features**# Use the function to get the results in dataframe**
duplicate_features = get_duplicate_features(df)
display_all(duplicate_features)**# All the constant features stored in a list**
duplicate_features_list = duplicate_features['feature2'].to_list()**# Drop all the constant features from the dataset**
df.drop(columns = duplicate_features_list, inplace=True)

关于 Fast_ml

由数据科学家为数据科学家打包；带 Scikit-learn type fit() transform()功能
有许多内置功能可以让数据科学家的生活变得更加轻松
—探索性数据分析
—缺失值处理
—异常值处理
—特征工程
—特征选择
—模型开发
—模型评估

感谢阅读！！

如果你喜欢这个，关注我的 medium 了解更多。
有兴趣合作吗？我们上 Linkedin 连线吧。
请随意写下您的想法/建议/反馈。
卡格尔链接

笔记本可在以下位置获得，并附有完整的功能代码:

https://www.kaggle.com/nextbigwhat/detect-duplicate-features-in-dataset

2 个对聚合数据有用的代码片段

原文：https://towardsdatascience.com/2-useful-code-snippets-for-aggregated-data-880d5d263a3b?source=collection_archive---------16-----------------------

当你在熊猫中“分组”后，你会想把这些代码放在身边

由彼得·伯顿在 Unsplash 上拍摄的照片

我将写一篇非常实用的文章，并附上一些代码片段。

今天早上，在处理一些 EDA 和数据争论时，我发现自己测试了许多函数，以使数据按照我想要的方式进行绘制。这就是我想和你分享的。

对于这些例子，我使用来自seaborn库的数据集taxies。

df = sns.load_dataset('taxis')
df.head(2)

数据集“出租车”。图片由作者提供。

分组、计数和重命名

让我们按付款类型对数据进行分组，并按 pickup_borough 查看首选类型。

# Preferred payment method by pickup borough
df.groupby(['payment']).pickup_borough.value_counts()

图 1 —按提货地点列出的付款类型。图片由作者提供。

或者我们可以使用normalize=True参数将其转换成百分比。

# Preferred payment method by pickup borough
df.groupby(['payment']).pickup_borough.value_counts(normalize=True)

然而，从图 1 得到的对象是一个熊猫系列。如果我想操纵那张桌子，我会有麻烦。注意，我没有计数的列名。因此，我需要重置索引，使其成为具有正确列名的数据框。但是看看当我尝试的时候会发生什么。

图 2 —试图重置 _index 时出错。图片由作者提供。

发生这种情况是因为 Pandas 将尝试转换 Dataframe 中的结果序列，并对 counts 列使用相同的名称( pickup_borough )。因为不可能有两个同名的列，所以我们得到了错误。要解决这个问题，需要转换到框架，在重置索引之前重命名列。参见下面第一个有用的代码。

# Remove the comments before running the code**# Group the data**
df.groupby(['payment']).pickup_borough.value_counts()\
**# transform to dataframe**
.to_frame()\
**# rename the column**
.rename(columns={'pickup_borough': 'freq_count'})\
**# Reset index**
.reset_index()

图 3 —结果数据帧。图片由作者提供。

对分组的数据进行分组

您知道可以对已经分组的数据进行分组吗？

让我们一步一步来看。首先，让我们专门为这个例子创建一个数据集。

# Create a dataset
df2 = pd.DataFrame({'id': [1,1,2,2,3,3,3,3,3,3,4,4,4,6,7,7,8,8,5,5],
              'register': [2,2,2,2,4,4,4,4,4,4,1,1,1,1,1,1,2,2,2,2],
             'amount': np.random.randint(2,20,20)})# Sort
df2= df2.sort_values(by='id').reset_index(drop=True)**[OUT]:** 
   id | register | amount
0   1      2         17
1   1      2         13
2   2      2         10
3   2      2         18
4   3      4         17

好的。假设你想知道登记的平均费用是多少。你可能会想:

# Mean by register
df2.groupby('register').amount.mean()**[OUT]:**
register 
1    12.333333 
2    11.125000 
4    10.000000

但这是错误的，原因只有一个。每个交易 ID 不是唯一的。这意味着在每笔交易中，不止有一个项目。因此，在按登记簿提取平均金额之前，必须使每个 ID 条目都是唯一的。

看看下面我们只对寄存器 1 切片的结果。

# Slice on register 1
df2.query('register == 1')**[OUT]:** id  register  amount
10  4     1       17
11  4     1       19
12  4     1       8
15  6     1       8
16  7     1       10
17  7     1       12

如果我只是从中提取平均值，我将合计金额(74 美元)并除以 6，这是行数，结果是 12.33 美元。

相反，我应该做的是——使每笔交易都是独一无二的，以便了解每笔交易的真实费用，而不是每件商品的费用。

# Slice register 1 then group by ID
df2.query('register == 1').groupby('id').amount.sum()id 
4    44 
6     8 
7    22

很好。现在我知道了每笔交易的实际成本，我可以计算 3 笔不同交易的平均值，即(44 + 8 + 22) / 3 = $24.66。

要在单行代码上实现这一点，可以使用两个级别的分组。下面是第二个有用的代码片段。

# Step 1: Group by register and ID and sum the amount.
# Step 2: group the result by register and calculate the mean.df2.groupby(['register','id']).amount.sum()\
                              .groupby('register').mean()

嵌套 groupby 的结果。图片由作者提供。

在你走之前

使用 groupby，您可以做更多的事情…

我的建议是你写代码，看看输出是什么，然后玩玩输出，看看你能否用点符号嵌套函数，如果你感兴趣的话。

如果你要向别人展示你的作品，不要写太长的代码行。它们可能很难读懂。

如果这些内容对你有用，欢迎关注我的博客。

https://medium.com/gustavorsantos

Java 程序员必须知道的两类

原文：https://towardsdatascience.com/2-ways-to-represent-classes-in-java-546e0eb2cec5?source=collection_archive---------29-----------------------

用传统的例子解释清楚

在 Unsplash 上 Nam Hoang 的照片

当你有一个函数限制的数据集作为
语句时，该怎么做？今天，你将有趣地了解 enum 类
和 sealed 类。

这将明确你对这两个类的概念，并且你将能够清楚的区分这两个类。你马上就会看到，一个特定的类是如何打开功能思想的大门的。

密封类

它展示了一组具体的价值观。密封类什么也不是
而是抽象类，在
相同的文件中有一定数量的子类。sealed 修饰符的作用就好像不可能在文件之外定义另一个子类一样。你可以通过评估单个文件来了解一个密封类的子类。

密封类非常适合表示 sum 类型。其值
可以为真或假，但不能同时为真和假。因此，密封类子类
可以理解特定于实例的数据。

例如，当您通知应用程序的另一部分关于
所选的支付选项时，您可以传递所选的
支付类别和支付特定数据，这些数据对于
后续处理是必要的。

密封类可以管理所有类型的事件和消息。它可以
确定是哪种事件，每个事件都可以保留数据。
各种结构的密封类函数。比如类，
对象，数据类。

密封的类子类型是类型，这些类型可以根据用途进一步扩展。

class LocallyDispatched :
      Dispatched() { } //OK

枚举类

如果你想描绘一组可能的常量函数，
你应该选择 enum 类。枚举中的每个值都是常量。enum 中的每个常量都被称为一个对象。

我们使用 values()以数组的形式获取所有的枚举常量。EnumValues()和enumValuesOf()是两个通用加法函数，用于从某个特定的枚举中恢复数据。

ValueOf()函数恢复了一个以字符串值为根的常量。例如，如果您的网站提供一组具体的付款选择，您可以用以下方式表示:

enum class PaymentOption { CASH, CARD, TRANSFER}

它处理总是特定于项目的值。科特林枚举可以包含程序。它们的执行总是特定于项目的。枚举的价值在于项目是特定的和恒定的。

此后，可以使用 values()函数或利用函数的 enum 值按类型获取所有项目。还可以使用valueOf(String)从字符串中检查枚举，或者使用enumValueOf按类型检查枚举。

因此，枚举值的重复使用非常简单。而且，它们的序列化和反序列化是直接而有价值的，这是由名称来表征的。它们由库协助进行序列化。它们还包括序数和自动执行的 toString、equals 和 hashCode。

简而言之，enum 类是呈现一组具体的
持久值的理想选择。

结论

在文章中，我们已经看到了 java 中的类的类型，我们可以根据不同的场景来使用它们。我们已经看到了它们更好的用法，以及在正确的地方使用它们的其他见解。

这就是本文的全部内容。感谢阅读！

2 年的博客，1 年的数据科学家工作，一个不同的我

原文：https://towardsdatascience.com/2-years-of-blogging-1-year-of-working-as-a-data-scientist-and-a-different-me-7c2ac8c8432b?source=collection_archive---------15-----------------------

一段旅程开始了，从拼命想得到一个面试机会到被招聘者接触

奥卡尔约翰·坎波斯在 Unsplash 上拍摄的照片

“我的一个硕士生用一位流行歌手的歌词训练了一个模特。然后，模型生成了一首一点都不差的歌”。

这些词让我进入了数据科学。

我正在听一位教授关于数据科学和人工智能的演讲。当他提到他学生的项目时，我下定决心，决定成为一名数据科学家。

这篇文章总结了我从拼命想得到一个面试机会到被招聘者伸出手的旅程。

我已经有了一份全职工作，时间也很紧。对我来说，在保持现有工作的同时学习数据科学不是一件容易的事情，但我想试一试。

起初我没有一个精心设计的计划，所以我考虑了学习的不同选择。然后，我决定先上一门 MOOC 课程，确切的说是 IBM 数据科学专业证书。

我不只是复习了这次认证的课程。我知道我必须多练习，也要利用其他资源。那是我了解媒体的时候。

我在媒体上看到了非常有价值的数据科学内容。有一篇文章几乎囊括了我所寻找的一切。有些是关于特定的主题，比如“如何用 Y 做 X”。还有很多关于数据科学的内容。

关于 Medium 的文章的一个好处是，来自该行业的人也可以分享他们的经验和学习旅程。

我在学习数据科学时做的最好的事情之一是开始在介质上写作。

2020 年 1 月 5 日我写了第一篇文章。起初，我的目标是通过写作获得对一个主题的全面理解。如果我能够向另一个人解释，那么我可以说我已经学会了。

写了几篇文章后，看到浏览量和阅读量都在增加，感觉很好。这进一步激励我去学习新的课题。

动机

我想强调激励对于有抱负的数据科学家的重要性。学习数据科学是一项漫长而耗时的工作。这需要时间、努力、精力，最重要的是动力。

数据科学是一个跨学科领域，因此需要学习几个主题。除此之外，我们需要熟悉一些软件工具和软件包。

竞争激烈的就业市场让这个过程变得更加困难。如果你以前没有工作经验，展示你的技能甚至获得面试机会都是一个挑战。

相信我，如果你之前没有数据科学方面的工作经验，你最需要的是持久的动力来实现你的目标。你总是需要保持高昂的情绪。

在媒体上写作帮助我坚持了几个月，甚至没有得到一次面试机会。除此之外，过一段时间后它开始成为一笔可观的副业收入。

拥有一个活跃的数据科学博客是一种很好的体验，但你需要更多。完成 MOOC 课程和收集证书是有帮助的，但不足以让你找到工作。

在你学完基础知识，迈出进入这个领域的第一步之后，我建议做项目。这比你手头有几个证书更可信。

我不断地学习、练习，并在媒体上写作。我也做了一些展示我的技能和我所学的项目。

我参加的面试不多，但我在面试中表现得相当不错。面试没有失败的感觉真好。这让我觉得我走对了路。

我花了将近两年的时间找到了第一份数据科学家的工作。虽然学习数据科学是一段艰难的旅程，但我很高兴我决定改变职业生涯。

得到这份工作后

我已经做了一年的数据科学家。很多事情都变了，除了学习。

数据科学仍然是一个不断发展的领域，新的发展正在不断宣布。在软件方面，新的工具和软件包正被引入数据科学社区。

为了保持竞争力，跟上新的发展和不断学习是很重要的。

在生产环境中使用真实数据集有其自身的挑战。这个过程需要学习新技术。这和自学是很不一样的。我认为这是一个提高技能的机会。

另一个变化是协作工作环境。你最有可能作为一个团队来开发一个产品。因此，沟通技巧非常重要。

团队中的每个成员都可能在某个特定的主题上有很好的技能。然而，没有在团队成员之间建立健康的沟通，最终结果注定是失败的。

我为什么写这篇文章

在我得到一份数据科学家的工作后，我没有放弃在媒体上写作。事实上，我有更多的材料可以写。

我有将近 500 篇关于媒体的文章。我写的主题范围很广:

如何使用特定的工具
我的学习经历
给有抱负的数据科学家的提示和技巧
统计数字
机器学习
诸如此类…

让我想写这篇文章的事情发生在过去的一个月里。两位数据科学家职位的招聘人员找到了我。

这让我回到了数据科学之旅的起点。我记得那些日子，我甚至非常努力地想得到一个面试机会。从那时起，我就可以搬到一个我被认为是数据科学家职位的好候选人的地方。

一如既往，努力工作得到了回报。我很高兴看到漫漫长夜和周末变成了自我提升。我现在可以做我喜欢做的事情了。

如果你计划成为一名数据科学家，或者正在学习，不要让那些没有回复的申请打破你的动力。

保持高昂的情绪。如果你投入足够的时间、努力和奉献，你最终会达到你的目标。

你可以成为媒介会员来解锁我的作品的全部访问权限，以及媒介的其余部分。如果您使用以下链接，我将收取您的一部分会员费，无需您支付额外费用。

https://sonery.medium.com/membership

感谢您的阅读。如果您有任何反馈，请告诉我。

每个开发人员都应该遵循的 20 个惊人的 GitHub 库

原文：https://towardsdatascience.com/20-amazing-github-repositories-every-developer-should-follow-d8ce4c728351?source=collection_archive---------0-----------------------

一个 GitHub 库集合，用于提高您的开发技能和促进您的职业发展

来自佩克斯的弗拉达·卡尔波维奇的照片

当 GitHub 在 2008 年成立时，它的主要目标是使用分布式版本控制系统 Git 托管开源项目。在接下来的 13 年里，GitHub 已经发展成为一个在开发者社区中托管开源项目和共享资源的中心。GitHub 拥有 4500 万个公共知识库，为开发者提供各种形式的知识共享，包括开源项目、库、学习平台、面试准备、简历写作技巧、知识库等等。

在这 4500 万个公共存储库中找到有用的存储库是非常具有挑战性的。在这篇文章中，我将列出 20 个优秀的 GitHub 库，它们具有很高的流行度、可用性和需求。此外，这个列表将是包容性的，不会集中于特定的编程语言或目标群体。

自由代码营

来源:GitHub

这个 GitHub 库提供了一个课程，使用免费的在线材料提供完整的计算机科学教育。与主要关注专业发展的 FreeCodeCamp 不同，OSSU 计算机科学提供了一个类似大学的全面课程，涵盖了计算机科学的基础和核心原则。

是按照本科计算机专业的学位要求设计的，没有通识教育(非 CS)的要求。

链接:

https://github.com/ossu/computer-science

字体真棒

来源:GitHub

无论您是开发 Web/移动应用程序、准备演示文稿，还是绘制软件工程图，您经常需要一组免费图标。字体牛逼是最著名的图标工具包。您可以在流行的 JavaScript 框架中将字体 Awesome 图标打包使用。也可以在 PowerPoint 或者 Draw.io 之类的设计工具中使用，而且，这些图标都是免费的。

链接:

https://github.com/FortAwesome/Font-Awesome

故事书

来源:GitHub

如果你是一个 CS 的学生，或者是一个开发者，你必须坚持学习。一个见多识广、受过良好教育的开发人员在行业中有着巨大的需求。这个 GitHub 存储库包含一个供好奇的开发人员使用的非详尽的站点列表。

它几乎包含了开发者需要知道的一切:面试准备、新闻链接、纪录片、MOOCs、文章、书籍等等。

链接:

https://github.com/sdmg15/Best-websites-a-programmer-should-visit https://md-kamaruzzaman.medium.com/subscribe

类似文章:

</10-excellent-github-repositories-for-every-java-developer-41084a91ade9> </21-predictions-about-the-software-development-trends-in-2021-600bfa048be>

20 烧 XGBoost 常见问题解答像专业人士一样使用库

原文：https://towardsdatascience.com/20-burning-xgboost-faqs-answered-to-use-the-library-like-a-pro-f8013b8df3e4?source=collection_archive---------8-----------------------

梯度-通过学习这些重要的课程来提升你的 XGBoost 知识

照片由hai them Ferdi上 Unsplash。 除特别注明外，所有图片均为作者所有。

XGBoost 是一个真正的野兽。

这是一个基于树的动力之马，是许多表格竞赛和数据马拉松获胜解决方案的幕后推手。目前，它是世界上“最性感”工作的“最热门”ML 框架。

虽然使用 XGBoost 进行基本建模可能很简单，但是您需要掌握细节才能获得最佳性能。

也就是说，我向你展示这篇文章，它是

数小时阅读文档(这并不有趣)
哭着通过一些可怕但有用的 Kaggle 内核
数百个谷歌关键词搜索
通过阅读大量文章，我完全耗尽了我的中等会员资格

这篇文章回答了关于 XGBoost 及其 API 的 20 个最棘手的问题。这些应该足够让你看起来像是一直在用库了。

https://ibexorigin.medium.com/membership

获得由强大的 AI-Alpha 信号选择和总结的最佳和最新的 ML 和 AI 论文:

https://alphasignal.ai/?referrer=Bex

1.应该选择哪个 API——Scikit-learn 还是核心学习 API？

Python 中的 XGBoost 有两个 API——Scikit-learn 兼容的(估计器有熟悉的fit/predict模式)和核心的 XGBoost-native API(用于分类和回归的全局train函数)。

Python 社区的大多数人，包括 Kagglers 和我自己，都使用 Scikit-learn API。

这个 API 使您能够将 XGBoost 估算器集成到您熟悉的工作流中。好处包括(但不限于)

能够将核心 XGB 算法传递到 Sklearn 管道
使用更高效的交叉验证工作流程
避免学习新 API 带来的麻烦，等等。

2.我如何完全控制 XGBoost 中的随机性？

其余对 XGBoost 算法的引用主要是指与 Sklearn 兼容的 XGBRegressor 和 XGBClassifier(或类似的)估计器。

估计器有参数random_state(替代的参数seed已经被弃用，但仍然有效)。然而，使用默认参数运行 XGBoost 将会产生相同的结果，即使种子不同。

这是因为 XGBoost 只有在使用了subsample或任何其他以colsample_by*前缀开头的参数时才会产生随机性。顾名思义，这些参数与随机抽样有很大关系。

3.XGBoost 中的目标是什么，如何为不同的任务指定它们？

回归和分类任务有不同的类型。它们根据目标函数、它们可以处理的分布以及它们的损失函数而变化。

您可以使用objective参数在这些实现之间切换。它接受 XGBoost 提供的特殊代码字符串。

回归目标以reg:为前缀，而分类以binary:或multi:开始。

我将让您从本文档的第页中探索完整的目标列表，因为有很多目标。

此外，指定正确的目标和度量可以消除在装配 XGB 分类器时出现的令人难以置信的恼人的警告。

4.XGBoost 中应该用哪个 booster——GB linear，gbtree，dart？

XGBoost 有 3 种类型的梯度增强学习器，它们是梯度增强(GB)线性函数、GB 树和 DART 树。您可以使用booster参数切换学习者。

如果你问 Kagglers，他们会在任何一天选择提升树而不是线性函数(我也是)。原因是树可以捕捉非线性的、复杂的关系，而线性函数不能。

所以，唯一的问题是您应该将哪个树助推器传递给booster参数- gbtree还是dart？

我不会用这里的全部差异来烦你。你应该知道的是，XGBoost 在与gbtree booster 一起使用时，使用了一组基于决策树的模型。

DART 树是一种改进(有待验证),它引入了决策树子集的随机丢弃，以防止过度拟合。

在我用默认参数gbtree和dart做的几个小实验中，当我把rate_drop设置在 0.1 和 0.3 之间时，我用dart得到了稍微好一点的分数。

有关更多详细信息，我建议您参考 XGB 文档的本页，以了解细微差别和附加的超参数。

5.在 XGBoost 中应该使用哪种树方法？

有 5 种控制树结构的算法。如果你在做分布式培训，你应该通过hist到tree_method。

对于其他场景，默认的(也是推荐的)是auto，对于中小型数据集从exact变为大型数据集的approx.。

6.XGBoost 中的助推轮是什么？

正如我们所说的，XGBoost 是梯度增强决策树的集合。集合中的每棵树被称为基础或弱学习器。弱学习者是任何比随机猜测表现稍好的算法。

通过组合多个弱学习者的预测，XGBoost 产生了最终的、健壮的预测(现在跳过了很多细节)。

每次我们用一棵树来拟合数据，就叫做一轮提升。

因此，要指定要构建的树的数量，请将一个整数传递给学习 API 的num_boost_round或 Sklearn API 的n_estimators。

通常，太少的树会导致拟合不足，太多的树会导致拟合过度。您通常会使用超参数优化来调整该参数。

7.XGBoost 中的`early_stopping_rounds`是什么？

从一轮提升到下一轮，XGBoost 建立在最后一棵树的预测之上。

如果预测在一系列回合后没有改善，那么停止训练是明智的，即使我们没有在num_boost_round或n_estimators中硬停下来。

为了实现这一点，XGBoost 提供了early_stopping_rounds参数。例如，将其设置为 50 意味着如果预测在最后 50 轮中没有改善，我们就停止训练。

为n_estimators设置一个较大的数值，并相应地改变提前停止以获得更好的结果，这是一个很好的做法。

在我展示如何用代码实现它的例子之前，还有两个其他的 XGBoost 参数要讨论。

8.XGBoost 中的`eval_set`有哪些？

只有当您将一组评估数据传递给fit方法时，才能启用提前停止。这些评估集用于跟踪从一轮到下一轮的整体表现。

在每一轮通过的训练集上训练一棵树，并且为了查看分数是否一直在提高，它对通过的评估集进行预测。下面是它在代码中的样子:

将verbose设置为 False 以删除日志消息。

第 14 次迭代后，分数开始下降。所以训练在第 19 次迭代时停止，因为应用了 5 轮早期停止。

也可以将多个评估集作为一个元组传递给eval_set，但是当与早期停止一起使用时，只有最后一对会被使用。

查看这篇文章以了解更多关于提前停止和评估集的信息。

9.评估指标什么时候影响 XGBoost？

您可以使用fit方法的eval_metric指定各种评估指标。通过的指标只在内部产生影响——例如，它们用于评估早期停止期间的预测质量。

您应该根据您选择的目标来更改指标。您可以在文档的本页中找到目标及其支持指标的完整列表。

以下是一个 XGBoost 分类器的示例，以多类对数损失和 ROC AUC 作为度量:

无论您传递给eval_metric什么度量，它只影响fit函数。所以，当你在分类器上调用score()时，它仍然会产生精度，这是 Sklearn 中的默认。

10.XGBoost 中的学习率(eta)是多少？

每次 XGBoost 添加一个新的树到集成中，它被用来校正最后一组树的残差。

问题是这种方法快速而强大，使得算法能够快速学习和过度拟合训练数据。因此，XGBoost 或任何其他梯度增强算法都有一个learning_rate参数来控制拟合的速度，并防止过度拟合。

learning_rate的典型值范围从 0.1 到 0.3，但也可能超过这些值，特别是接近 0。

无论传递给learning_rate的值是什么，它都作为新树所做修正的加权因子。因此，较低的学习率意味着我们不太重视新树的修正，从而避免过度拟合。

一个好的实践是为learning_rate设置一个较低的数字，并使用具有较大数量估计器的早期停止(n_estimators):

您将立即看到慢速learning_rate的效果，因为早期停止将在训练期间的更晚时间应用(在上述情况下，在第 430 次迭代之后)。

但是，每个数据集都是不同的，所以需要用超参数优化来调优这个参数。

查看这篇关于如何调整学习率的文章。

11.应该让 XGBoost 处理缺失值吗？

为此，我将给出我从两位不同的围棋比赛大师那里得到的建议。

如果您将np.nan赋予基于树的模型，那么，在每个节点分裂时，丢失的值要么被发送到节点的左边子节点，要么被发送到节点的右边子节点，这取决于哪一个是最好的。因此，在每次分割时，缺失值会得到特殊处理，这可能会导致过度拟合。一个对树非常有效的简单解决方案是用不同于其他示例的值填充空值，比如-999。
尽管像 XGBoost 和 LightGBM 这样的包可以不经过预处理就处理空值，但是开发自己的插补策略总是一个好主意。

对于真实世界的数据集，您应该始终调查缺失的类型(MCAR、马尔、马尔)，并选择插补策略(基于值的[平均值、中值、众数]或基于模型的[KNN 插补器或基于树的插补器])。

如果您不熟悉这些术语，我在这里为您介绍了。

12.用 XGBoost 进行交叉验证的最好方法是什么？

尽管 XGBoost 带有内置的 CV 支持，但请始终使用 Sklearn CV 拆分器。

我说的 Sklearn，并不是指cross_val_score或者cross_validate这样的基础效用函数。

2021 年没有人会交叉验证这种方式(至少在 Kaggle 上没有)。

为 CV 过程提供更多灵活性和控制的方法是使用 Sklearn CV 分离器的.split功能，并在for循环中实现您自己的 CV 逻辑。

下面是一个五重简历的代码:

在for循环中执行 CV 可以使用评估集和提前停止，而像cross_val_score这样的简单函数则不能。

13.如何在 Sklearn 管道中使用 XGBoost？

如果使用 Sklearn API，可以将 XGBoost 估计器作为管道的最后一步(就像其他 Sklearn 类一样):

如果想在管道中使用 XGBoost 的fit参数，可以很容易地将它们传递给管道的fit方法。唯一的区别是你应该使用stepname__parameter语法:

因为我们在管道中将 XGBoost 步骤命名为clf，所以每个fit参数都应该以clf__为前缀，这样管道才能正常工作。

此外，由于StandardScaler删除了熊猫数据帧的列名，XGBoost 不断抛出错误，因为eval_set和训练数据不匹配。因此，我在两组中都使用了.values来避免这种情况。

14.如何显著提高默认分数？

在使用默认的 XGBoost 设置建立了基本性能之后，您可以做些什么来显著提高分数呢？

许多人匆忙转向超参数调优，但它并不总是给你想要的分数带来巨大的飞跃。通常，参数优化带来的改进可能微不足道。

在实践中，任何实质性的分数增加主要来自于适当的特征工程和使用模型混合或堆叠等技术。

你应该把大部分时间花在特性工程上——有效的 FE 来自于正确的 EDA 和对数据集的深刻理解。特别是，创建特定于领域的特性可能会对性能产生奇迹。

然后，尝试将多个模型组合成一个整体。在 Kaggle 上运行良好的方法是堆叠三大组件——XGBoost、CatBoost 和 LightGBM。

15.XGBoost 中最重要的超参数有哪些？

超参数调整应该始终是项目工作流程的最后一步。

如果时间紧迫，应该优先调优 XGBoost 的超参数来控制过度拟合。这些是:

n_estimators:要训练的树木数量
learning_rate:步进收缩或eta
max_depth:每棵树的深度
gamma:复杂度控制-伪正则化参数
min_child_weight:控制树深度的另一个参数
reg_alpha : L1 正则项(如 LASSO 回归)
reg_lambda : L2 正则项(如在岭回归中)

16.如何在 XGBoost 中调优 max_depth？

max_depth是树的根节点和叶节点之间的最大长度。它是控制过拟合的最重要的参数之一。

典型值范围是 3-10，但很少需要高于 5-7。此外，使用更深的树会使 XGBoost 非常消耗内存。

17.如何在 XGBoost 中调 min_child_weight？

min_child_weight控制创建新节点时数据中所有样本的权重之和。当该值较小时，每个节点将在每个节点中分组越来越少的样本。

如果它足够小，树将很可能过度适应训练数据中的特性。因此，请为该参数设置一个较高的值，以避免过度拟合。

默认值为 1，其值仅限于定型数据中的行数。然而，一个很好的调优范围是 2–10 或高达 20。

18.如何在 XGBoost 中调 gamma？

一个更有挑战性的参数是gamma，对于我这样的外行来说，你可以把它看成是模型的复杂度控制。伽玛越高，应用的正则化越多。

它的范围从 0 到无穷大——因此，调整它可能很困难。此外，它高度依赖于数据集和其他超参数。这意味着一个模型可以有多个最佳伽马值。

通常，您可以在 0–20 之间找到最佳的伽玛。

19.XGBoost 中 reg_alpha 和 reg_lambda 如何调优？

这些参数指的是特征权重的正则化强度。换句话说，增加它们将使算法更保守，因为对具有低系数(或权重)的特征不太重视。

reg_alpha指 Lasso 回归的 L1 正则化，reg_lambda指岭回归。

调整它们可能是一个真正的挑战，因为它们的值也可以从 0 到无穷大。

首先，选择一个较宽的区间，如[1e5，1e2，0.01，10，100]。然后，根据从该范围返回的最佳值，选择其他几个附近的值。

20.如何调优 XGBoost 中的随机采样超参数？

以上 6 个参数之后，强烈建议调优那些控制随机采样的。事实上，随机采样是算法中应用的另一种方法，以进一步防止过拟合。

subsample:推荐值【0.5 - 0.9】。每个增强回合中随机抽样(不替换)的所有训练样本的比例。
colsample_by*:以此前缀开头的参数是指随机选择的列的比例
colsample_bytree:每一轮助推
colsample_bylevel:树中达到的每个深度级别
colsample_bynode:每个节点创建或在每个拆分

像subsample，推荐范围是【0.5 - 0.9】。

摘要

终于，这篇痛苦漫长但希望有用的文章结束了。

我们已经介绍了很多——如何为任务选择正确的 API、正确的目标和指标、fit最重要的参数，以及从不断更新的来源(如 Kaggle)收集的一些有价值的 XGBoost 最佳实践。

如果你对 XGBoost 有更多的问题，请在评论中发表。在 StackExchange 网站上，我会试着比其他人回答得更快(在写这篇文章的时候，我还没有得到这个恩惠😉).

这里有些你可能会感兴趣的东西…

特别感谢这些帖子:

XGBoost 超参数指南
掌握 XGBoost
使用 Python 代码在 XGBoost 中调整参数的完整指南

20 个被严重低估的用于 DS/ML 的 Python 包

原文：https://towardsdatascience.com/20-critically-underrated-python-packages-for-ds-ml-675dfb193a7f?source=collection_archive---------12-----------------------

一些我最喜欢的数据科学 Python 包…没人用

(src =https://unsplash.com/photos/fyaTq-fIlro

介绍

Python 编程语言与许多其他语言相比有许多显著的优势，这些语言可能会与其流行程度相抗衡。与其他语言相比，这种语言最显著的优势可能是 Python 多年来构建的非常强大的包生态系统。

Python 最有可能证明其生态系统优势的一个领域是数据科学。Python 编程语言有如此多的与数据科学相关的包，几乎很难与之竞争。有如此多的包，以至于许多面向机器学习、数据和其他数据科学任务的伟大包经常是看不见的。今天，我想阐明其中的一些包装。

№1:埃米特

我认为第一个被严重低估的包是 Emmett web-framework。Emmett web-framework 是通用的，可以用于 web 开发的许多不同目的。另一个好处是 Emmett web-framework 相对容易使用。它遵循类似 Flask 的语法，如果你碰巧已经知道 Flask，那么很容易被介绍。如果你想了解更多关于 Emmett 框架的知识，我已经写了一整篇文章，你可以在这里阅读:

[## 用 Python 语言用 Emmett 进行优雅的 Web 开发

towardsdatascience.com](/elegant-web-development-with-emmett-in-python-612ed898a71e)

№2: Jam.py

这个列表中下一个被低估的包是 Jam.py，Jam.py 是另一个很好地服务于一个目的的 web 框架。该包用于创建数据驱动的仪表板，实际上在这方面非常有效。这个软件包的一个很酷的地方是，你甚至不需要知道如何编程来使用它。该包将启动一个 web 服务器会话。然后，可以从 web 浏览器加入该会话，就这样，您可以使用交互式集成开发环境，并完全忽略大部分代码。

我认为这是一个非常酷的仪表板方法。即使是有经验的程序员也肯定会喜欢不用写任何代码。这使得 Jam.py 对于 Python 用户和不编程的人来说是一个非常酷和独特的解决方案！

№3:幕府

将技能转换到机器学习，这个列表上的下一个包是幕府将军。幕府将军是一个全面的机器学习库，最初用 C++编写，然后通过 API 移植到 Python。虽然幕府当然没有遵循 Sklearn 为机器学习而提出的 Python 编程语言中的典型约定，但该包仍然有足够的代码库来很好地支持其模型。该软件包实际上非常强大且易于使用。此外，如果你想阅读我的标准机器学习包的替代列表，以了解这个包和许多其他包的特点，这里有一个链接:

</5-fabulous-python-packages-for-data-science-nobody-knows-about-9fa192f312e4>

另外，我有一篇关于幕府将军的文章，你可以在这里看到:

[## 幕府将军:一个被低估的 Python 机器学习包

towardsdatascience.com](/shogun-an-underrated-python-machine-learning-package-d306ac07b0e0)

№4:火焰

说到 Blaze，Blaze 模块只是冰山一角。Blaze 是一个完整的工具生态系统，通常用于 Python 中的高性能计算和机器学习。加速 Python 算法的一个简单方法是添加一个受欢迎的包，例如，这就是 Dask 所做的。在 Blaze 生态系统中有各种各样非常有用的工具。

回到 Blaze 包，但是，这个包用于一致地查询不同类型的数据存储。Blaze 可用于在不同格式之间迁移数据，使 SQL、Hadoop/Spark 和本地数据都能轻松地通过一致的调用工作。

№5:更快

Swifter 是一个提供简单功能的库；它使得 apply()操作更快。这是通过一个更有效的 apply()方法完成的，该方法专门用于熊猫系列对象。

№6:咖啡

Caffe 是一个深度学习框架，考虑到了表达、速度和模块化。这个包非常棒，由于它的模块化性质，框架非常灵活和强大。所有的组件都是模块化的，它们组合在一起构成一个网络。还有一个相当大的重点是速度，所以这个包肯定是值得一试的一些冷静和快速的模型！

№7: Myia

我想包括这个包，主要是因为我发现它非常有趣。Myia 是一种专注于性能的编程语言。它可以通过 Python 访问，并专注于比 Python 更快。这里的要点是让 Myia 在后台运行，而 Python 在前面编写。

№8:功能工具

Featuretools 是另一个非常有用的软件包。特征工程可能是一种真正的痛苦，尤其是当你不确定从什么特征开始工程的时候。也就是说，Featuretools 旨在通过自动化功能选择来解决这个问题。在某种程度上，自动化机器学习很有趣。不管这里的幽默，这是一个真正的，我完全推荐检查这个包，因为有许多应用程序，它真的可以节省大量的时间。

№9:牛郎星

在这个列表中的所有模块中，我完全推荐下载 Altair。Altair 是一个自动化统计绘图的软件包。从表面上看，这似乎是一个非常奇怪的想法。我必须诚实地说，我很怀疑这个软件的技能。然而，当 Altair 给出了我的数据的一些非常有见地的非常漂亮的可视化时，我完全被证明是错的。看着这个人工智能为我做选择和可视化是一种非常有趣的感觉。我心想

“我的工作没了。”

№10:全息视图

遵循与牛郎星相同概念的是 Holoviews。因为它们在概念上是一样的，并且都支持相似类型的可视化，所以很难判断它们各自的优缺点。主观上，我认为全息视图的可视化在很大程度上更加完美。客观地说，Holoviews 可视化肯定比 Altair 的交互性强得多。

№11:沙普利

Shapely 是 Python 中几何数据的可视化工具。这在数据科学的许多情况下肯定会派上用场。实际上，我正在研究一种新型图的技术细节，用 Z 分数和分位数来判断数据的方差和异常值，并且我正在使用 Shapley 为未来的图建立基础模型。不用说，这肯定有办法派上用场，因为我个人正在我的一个项目中使用它！

№12:卡鲁 GP

Karoo GP 是一个用于 Python 的生物信息学机器学习包。如果你对基因组学感兴趣，而且对机器学习在基因组学中的应用感兴趣，Karoo GP 绝对是一个很好的选择，类似于下一个选项。Karoo GP 是一个可以预测基因进化的进化进展模型。如果你不觉得这听起来很棒，那我就不想认识你！

№13:猴子

虽然 Karoo GP 通常是一个单一目标，具有基因组学包的机器学习，但猴子的目标是更基本的基因组学基础。Monkeys 只是 Python 中基因组学的一个很好的起点。如果你对基因组学和生物编程感兴趣，如果你写 Python，我强烈建议你试试这个包。

14 号:助推器

Augmentor 是 Python 编程语言的一个易于使用的图像增强库。我特别喜欢这个包的一点是它非常容易使用。它采用了一种随机方法，使用允许在管道中将操作拼凑在一起的构建块。这是在 Python 中预处理图像的一个很好的选择。

№15:阿尔法镜头

Alphalens 是一个 Python 库，用于预测性(alpha)股票因素的性能分析。我认识的许多数据科学家都对预测金融市场非常感兴趣。很容易看出这是为什么，因为很多时候这些是非常不可预测的，并且数据需要是无限的才能预测它——有太多的统计显著特征影响股票在任何时间或时期的给定价格的结果。

不管怎样，这绝对是一个很酷的包，我相信那些对此感兴趣的人一定会发现这个解决方案非常合适。

第 16 位:神圣

好的——这个包真的很酷。神圣是科学家用来组织和控制他们工作的工具。让我们面对现实吧，让科学工作有条理是很难的！此外，随着这种组织斗争而来的是潜在的可复制性的缺乏！当你的实验需要可重复性时，这绝对不是一件好事！这个包的作用非常类似于 DrWatson.jl for Julia，我认为这两个包对大多数科学家来说肯定是有益的，可以确保他们通过可复制性使他们的研究尽可能有意义。

№17: QML

对量子计算感兴趣，但不确定从哪里开始？幸运的是，通过 QML，您可以将您的数据科学领域带入量子计算的世界。我必须承认，我没有尝试过这个包，但我至少学到了一个非常有教育意义的经验。如果不是真的做一些可怕的量子 ML，这个包肯定会是一个非常有价值的学习经历。

№18:瓶颈

瓶颈是一个 Python 包装器，用于 C 语言编写的 NumPy 接口，旨在加速一些数组计算。虽然不是所有的操作都会因为使用这个包而获得速度提升，但它确实是一个很好的选择。如果您没有显卡，并且无法使用并行计算技术，这也是一个很好的选择。

№19:丘比特

Cupy 是另一个试图加速 NumPy 线性代数的包。然而，与瓶颈不同，Cupy 使用 CUDA 并行计算。也就是说，很难判断哪一个可能更快——但我推测它会是 Cupy，因为 NumPy 的大部分代码都是用 C 语言编写的。

№20: OpenCV

我想讨论的最后一个数据科学 Python 包是 OpenCV。您可能听说过，或者甚至使用过 OpenCV，但是仅仅因为您以前可能使用过它并不意味着它没有被低估。当然，它被低估是有充分理由的，有太多奇妙的机器学习和深度学习包可供 Python 使用，有时很难选择。

不考虑它的竞争，我认为这个包是完全值得一试。这当然是我使用过的一款中等剂量的产品，而且非常快速可靠。计算机视觉是一个真正迷人的话题，这绝对是一个很好的选择！

结论

我认为这个列表真正证明了我们是如何被 Python 奇妙的不断扩展的工具生态系统宠坏的。由于数据科学家可能必须完成的每项任务都有如此多的优秀解决方案，我们甚至最终会为工作的某些方面提供自动化解决方案。这确实是 Python 的代表作，让这些奇妙的包为它工作。目前没有人在数据科学领域与这种级别的生态系统竞争，这也是 Python 在这一领域仍然如此受欢迎的部分原因。我希望这篇文章提供了一些见解，也许会影响眼界的开阔。非常感谢你阅读它，它对我来说真的很重要。拥有梦幻般的白天或夜晚！

20 个数据科学术语及其真正含义

原文：https://towardsdatascience.com/20-data-science-buzzwords-and-what-they-really-mean-3514ce0fde64?source=collection_archive---------51-----------------------

明智地选择你的话！通过调整针对最终用户的表述，释放数据科学的全部潜力

布雷特·乔丹在 Unsplash 上的照片

作为一家一线咨询公司的数据科学家，我渴望为客户释放价值。我的职责是通过应用核心数据科学技术带来价值。这样做的时候，我有时会遇到数据科学解决方案被排除在外的情况。

这些技术很简单，仍然被称为黑盒方法。这有时可能是真的，但通常是缺乏有效沟通的结果。

当人们将每种方法都视为黑盒方法时，我们作为数据科学家就失败了

数据科学领域应该是面向所有人的。我们的工作是传达核心技术和结果，让每个人都能理解。

从历史上看，技术部门主要充当支持功能和帮助台。当遇到技术问题或难题时，他们非常需要帮助，但他们不是团队的一员。作为一名数据科学家，你只有参与到整个过程中才能发挥作用。在这里，封闭的心态不再理想。

让我们一起终结孤立流程的时代。通过尊重最终用户，我们可以更加包容非技术人员。这将释放数据科学和分析的全部潜力！

20 个数据科学术语及其真正含义

重点领域

人工智能=使用机器进行的分析
机器学习(ML) =使用通过从数据中学习来改善结果的方法进行分析
描述性分析 =发现数据中的趋势和相关性
大数据=处理大量数据
前端 =用户直接交互区域的开发
后端 =开发用户不可见的区域
实时分析=数据一到达就进行分析
预测对未来做出最好的猜测

工具

保护代码的方法可以在每台计算机上运行
云计算=基于互联网的服务
数据仓库=从不同来源收集数据

方法

监督学习=做出已知答案的最佳猜测
无监督学习=做出最佳猜测答案未知
深度学习 =使用输入，通过网络对输出做出最佳猜测
算法 =解决问题的公式或程序
分类 =使用输入对输出所属的组进行最佳猜测
回归 =使用输入对输出做出最佳猜测

评估技术

精度 =测量距离以修正数值
过度拟合 =模型过于具体，无法正确预测新值
拟合不足 =模型过于模糊，无法正确预测新值

总结想法

通过根据最终用户调整沟通来确保透明度是关键。通过这样做，组织将对所选择的方法有更高的信任。

如果我们共同努力，我相信未来对数据科学家的需求会更大。

你有什么想法？这是否改变了你对适应沟通的重要性的看法？欢迎在评论区留下你的想法。

如果你喜欢这篇文章，你可能会喜欢我的免费简讯 这里——有新帖时我会发邮件给你。你也可以在推特上通过@ juel _ sofie联系我。

感谢阅读！

掌握熊猫系列 20 例

原文：https://towardsdatascience.com/20-examples-to-master-pandas-series-bc4c68200324?source=collection_archive---------26-----------------------

熊猫的核心数据结构

雅尼斯·萨乌格在 Unsplash 上的照片

Pandas 是一个非常流行的 Python 数据分析和操作库。它提供了多种功能强大的函数来处理表格形式的数据。

熊猫的两个核心数据结构是 DataFrame 和 Series。DataFrame 是一个带有标记行和列的二维结构。它类似于 SQL 表。Series 是一维标签数组。系列中的值的标签被称为索引。DataFrame 和 Series 都能够存储任何数据类型。

在本文中，我们将通过 20 个示例来演示我们可以对一个系列执行的各种操作。

让我们首先导入库，然后从示例开始。

import numpy as np
import pandas as pd

1.数据帧由系列组成

数据帧的单个行或列是一个系列。

考虑左边的数据帧。如果我们选择一个特定的行或列，返回的数据结构是一个序列。

a = df.iloc[0, :]
print(type(a))
pandas.core.series.Seriesb = df[0]
type(b)
pandas.core.series.Series

2.系列由数值和索引组成

Series 是带标签的数组。我们可以访问被称为索引的值和标签。

ser = pd.Series(['a','b','c','d','e'])print(ser.index)
RangeIndex(start=0, stop=5, step=1)print(ser.values)
['a' 'b' 'c' 'd' 'e']

3.索引可以定制

正如我们在前面的例子中看到的，默认情况下从零开始的整数索引被分配给一个系列。但是，我们可以使用 index 参数来更改它。

ser = pd.Series(['a','b','c','d','e'], index=[10,20,30,40,50])print(ser.index)
Int64Index([10, 20, 30, 40, 50], dtype='int64')

4.列表中的系列

我们在前面的例子中已经看到了这一点。可以将一个列表传递给 Series 函数来创建一个序列。

list_a = ['data', 'science', 'machine', 'learning']ser = pd.Series(list_a)type(ser)
pandas.core.series.Series

5.NumPy 数组中的系列

创建系列的另一种常用方法是使用 NumPy 数组。这就像从列表中创建一样。我们只改变传递给 Series 函数的数据。

arr = np.random.randint(0, 10, size=50)ser = pd.Series(arr)

6.访问单个值

由于系列包含带标签的项目，我们可以使用标签(即索引)访问特定项目。

ser = pd.Series(['a','b','c','d','e'])print(ser[0])
aprint(ser[2])
c

7.切片系列

我们还可以使用索引来分割一个系列。

ser = pd.Series(['a','b','c','d','e'])print(ser[:3])
0    a
1    b
2    c
dtype: object print(ser[2:])
2    c
3    d
4    e
dtype: object

8.数据类型

Pandas 在创建系列时会分配一个适当的数据类型。我们可以使用 dtype 参数来更改它。当然，需要选择合适的数据类型。

ser1 = pd.Series([1,2,3,4,5])
print(ser1)
0    1
1    2
2    3
3    4
4    5
dtype: int64 ser2 = pd.Series([1,2,3,4,5], dtype='float')
0    1.0
1    2.0
2    3.0
3    4.0
4    5.0
dtype: float64

9.系列中的项目数

有多种方法可以计算一个系列中值的个数。既然是集合，我们可以使用 Python 内置的 len 函数。

ser = pd.Series([1,2,3,4,5])len(ser)
5

我们还可以利用熊猫的大小和形状功能。

ser.size
5ser.shape
(5,)

shape 函数返回每个维度的大小。因为数列是一维的，我们从形状函数中得到长度。Size 返回系列或数据帧的总大小。如果在数据帧上使用，size 返回行数和列数的乘积。

10.独一无二的

unique 和 nunique 函数分别返回唯一值和唯一值的数量。

ser = pd.Series(['a','a','a','b','b','c'])ser.unique()
array(['a', 'b', 'c'], dtype=object)ser.nunique()
3

11.最大值和最小值

nlargest 和 nsmallest 函数返回序列中的最大值和最小值。默认情况下，我们得到 5 个最大或最小的值，但是可以使用 n 参数进行更改。

ser = pd.Series(np.random.random(size=500))ser.nlargest(n=3)
292    0.997681
236    0.997140
490    0.996117
dtype: float64ser.nsmallest(n=2)
157    0.001499
140    0.002313
dtype: float64

12.字典中的系列

如果我们向 series 函数传递一个字典，返回的 series 包含字典的值。索引是字典的关键词。

dict_a = {'a':1, 'b':2, 'c':8, 'd':5}pd.Series(dict_a)
a    1
b    2
c    8
d    5
dtype: int64

13.转换数据类型

创建系列时，我们可以选择数据类型。Pandas 还允许以后更改数据类型。

例如，下面的系列包含整数，但使用 object dtype 存储。我们可以使用 astype 函数将它们转换成整数。

ser = pd.Series(['1','2','3','4'])ser
0    1
1    2
2    3
3    4
dtype: objectser.astype('int')
0    1
1    2
2    3
3    4
dtype: int64

14.值出现的次数

value_counts 函数返回一个序列中每个唯一值的出现次数。了解数值分布的概况是很有用的。

ser = pd.Series(['a','a','a','b','b','c'])ser.value_counts()
a    3
b    2
c    1
dtype: int64

15.从系列到列表

就像我们可以从列表中创建一个系列一样，也可以将一个系列转换成一个列表。

ser = pd.Series(np.random.randint(10, size=10))ser.to_list()
[8, 9, 0, 0, 7, 1, 8, 6, 0, 8]

16.空值

它可能在一个序列中有缺失值。Pandas 使得检测和处理缺失值变得非常简单。

例如，count 函数返回序列中非缺失值的个数。

ser = pd.Series([1, 2, 3, np.nan, np.nan])ser.count()
3

17.空值— 2

检测缺失值的另一种方法是 isna 函数。它返回带有布尔值的序列，用 True 表示缺少值。

ser = pd.Series([1, 2, 3, np.nan, np.nan])ser.isna()
0    False
1    False
2    False
3     True
4     True
dtype: bool

我们可以通过将 sum 函数与 isna 函数链接来计算缺失值的数量。

ser.isna().sum()
2

18.向上舍入浮点数

在数据分析中，我们最有可能拥有的是数值。熊猫非常擅长处理数字数据。例如，round 函数允许将浮点数舍入到特定的小数点。

考虑以下系列。

ser
0    0.349425
1    0.552831
2    0.104823
3    0.899308
4    0.825984
dtype: float64

以下是 round 函数的使用方法:

ser.round(2)
0    0.35
1    0.55
2    0.10
3    0.90
4    0.83
dtype: float64

19.逻辑运算符

我们可以将逻辑运算符应用于一个系列，如等于、小于或大于。它们返回带有布尔值的序列，这些布尔值指示符合指定条件的值为 True。

ser = pd.Series([1, 2, 3, 4])ser.eq(3)
0    False
1    False
2     True
3    False
dtype: boolser.gt(2)
0    False
1    False
2     True
3     True
dtype: bool

逻辑运算符的完整列表:

lt:小于
乐:小于或等于
gt:大于
ge:大于或等于
eq:相等
ne:不相等

20.数据聚合

我们可以对一系列数据应用聚合函数，如平均值、总和、中位数等。将它们分别应用于一个系列的一种方法。

ser = pd.Series([1, 2, 3, 4, 10])ser.mean()
4

如果我们需要应用多个聚合函数，有一个更好的方法。我们可以将它们以列表的形式传递给 agg 函数。

ser.agg(['mean','median','sum', 'count'])mean       4.0
median     3.0
sum       20.0
count      5.0
dtype: float64

结论

我们已经做了 20 个例子，演示了级数的性质和与之交互的函数。它和数据帧一样重要，因为数据帧是由系列组成的。

本文中的示例涵盖了大量常用的序列数据操作。当然，还有更多函数和方法可以和 Series 一起使用。您可以根据需要学习更高级或更详细的操作。

感谢您的阅读。如果您有任何反馈，请告诉我。

从初级数据科学家到首席数据科学家的 20 个经验教训

原文：https://towardsdatascience.com/20-lessons-learned-going-from-junior-data-scientist-to-chief-data-scientist-6fe09ff89d78?source=collection_archive---------2-----------------------

办公时间

花了 3 年时间研究饮食、睡眠和呼吸数据科学

【www.freepik.com vector pocket 制作的 T2 横幅矢量

几年前，当我得到我的第一份企业“数据科学家”工作时，我几乎不知道决策树是什么，我不知道人们为什么一直在谈论随机森林，我也不知道人们在谈论“人工智能”时实际上是什么意思，对我来说，这主要与反乌托邦电影有关。说得委婉一点，我相当不知所措。

这些天来，我感觉轻松多了，轻松地阅读人工智能和人工智能领域广泛主题的研究论文，做主题演讲，成为一家制药公司的首席数据科学家，等等。一路走来，我们学到了很多经验教训。在这篇文章中，我将概述一些我认为最重要的见解，没有特定的顺序，以及一些在企业数据科学职位上取得成功的一般经验。

注意:“数据科学”在不同的行业有很大的不同，所以这是在生物技术/制药公司工作的人的观点。

1.激情、好奇心和能力

激情和好奇心是数据科学家最重要的品质。如果在一个普通的经验丰富的高级数据科学家和一个肚子里有一团火的候选人之间进行选择，选择后者，即使这意味着更少的经验、更短的教育或其他什么。

我见过许多数据科学家，他们有着长长的、令人印象深刻的简历和昂贵的薪水，却完全不了解正在解决的问题的技术或商业细节。与此同时，我也看到过一些没有任何工作经验的激情四射的候选人迅速取得成功。

激情和好奇心是数据科学家最重要的品质

数据科学家应该“充满激情”的想法并不新鲜。不过，对此还有一个更有争议的附录:你还需要有“心理”能力。这意味着什么的细节可能是未来帖子的主题。然而，最重要的是，它需要坚持不懈地推动自己变得更好，以及至少一定水平的大脑马力(即“智力”)。

你必须对技术充满热情和好奇。由凯文·杰瑞特在 Unsplash 上拍摄的照片

2.获得或创造合适的工作

一份“数据科学家”的工作并不能保证你会整天做很酷的人工智能工作。相反，我见过的大多数企业数据科学家从来没有或很少拟合线性回归模型，因为他们所有的时间都被分配给了会议、数据清理或争论、仪表板等。

一份“数据科学家”的工作并不能保证你会整天做很酷的人工智能工作

事情是这样的，如果你不太熟悉例如最新的 NLP 算法是如何工作的，一旦你花了几周时间消化和清理公司的所有内部文件，公司就会有很大的动机雇佣一些顾问几周时间来做实际的数据科学工作；这样做比你“赶上”学习更有效率。

如果你的目标是掌握这门手艺，你就得锻炼这门手艺。数据科学就像力量训练；你可以想读多少书就读多少书，但是除非你钻到吧台下面，举起重物，否则你不会变得强壮。在上面的例子中，这可能意味着在进行数据提取和清理的同时学习和应用 NLP 算法。如有必要，无需经理同意。或者，开始做爱好项目，Kaggle 比赛，等等来磨练你的技能。同样，在公司(和个人)时间这样做，如果有必要，不要征得你经理的同意。这可能是有争议的，但看到下一个教训，为什么我相信它是好的。

数据科学就像力量训练；你可以想读多少书就读多少书，但是除非你钻到吧台下面，举起重物，否则你不会变得强壮。

不要只是读书；到“吧”下“做”数据科学。乔治·帕甘三世在 Unsplash 上的照片

3.无限 X 数据科学家

“10 倍开发人员”的概念是几十年前引入的，用来表示比一般开发人员多 10 倍的开发人员。虽然围绕这种开发人员存在的说法有很多争议，但我个人的经验是，当涉及到数据科学家时，倍数可能会比 10 倍高得多——你可以争辩说，如果给足够的时间，一个普通的开发人员可能能够解决几乎任何任务，但我不相信一个普通的数据科学家能够在“足够的时间”下解决任何任务

你花大量的时间磨练自己的技能，拓展自己的视野，这符合你自己的利益，也符合你的雇主的利益。

例如，假设您面临一个无法用传统 ML 解决的业务问题，需要在多个错位的时间序列上定制一个基于 transformer 的架构，同时还可以解释。如果你甚至从来没有玩过简单的神经网络，你也不会能够在任何合理的时间内破解那个问题。是的，我的经验是这些问题会出现，如果你没有一个可以解决这些问题的方法论的坚实概述，要么你不会解决问题，要么问题根本不会解决。

没有足够的技能，某些问题就无法解决。马修·汉密尔顿在 Unsplash 上的照片

4.不要陷入概念验证(POC)陷阱

这是一个大的。你可能会反复看到它；你得到数据，拟合一些模型，得到一些看起来很有希望的不错的初步结果。然后，什么都没有。没人捡起来。没人把它投入生产。它从不产生价值。关键是要创造价值。

你的主要目标是创造商业价值。概念证明不产生价值。

发生这种情况的原因是多方面的，这本身就是一个话题。首先，将机器学习模型投入生产是困难的，正如我在上一篇关于 MLOps 入门的文章中所展示的。通常，另一个原因是糟糕的变更管理和业务锚定。确保有人专门负责这个过程，这样你所做的工作最终会产生价值。

概念验证陷阱意味着数据科学从未创造价值。照片由缺口缺口在缺口处拍摄

5.你的背景很重要

当我找到第一份数据科学工作时，我没有数据或计算机科学背景。然而，我已经几乎每天编码 15 年，并获得了计算生物技术的博士学位。这意味着我可以直接理解各种算法并测试它们，而不需要学习编码。我也可以一出门就开始阅读研究论文，尽管一开始会很慢，因为你必须熟悉术语。

重点是？你不可能在 1 个月、3 个月甚至 6 个月内掌握数据科学。你应该提防任何人试图告诉你不是这样。你可以在短时间内学会变得有用和可雇佣，但数据科学是一个庞大和多面的学科，需要几年或几十年才能掌握。

数据科学是一个无限的旅程。享受它，继续前进。照片由弗拉德·巴加西安在 Unsplash 拍摄

6.学习所有的科目

一个典型的数据科学建议是专注于给定的主题，以避免成为“万事通，无所不能”这是废话，如果你遵循这个建议，你就有很快过时的风险。相反，一个人应该努力成为“万事通，几个大师”

不要回避“数据科学独角兽”的想法，而是努力成为其中一员。

为什么？不同领域之间有无数的协同作用。你拥有的视角越多，你就会越经常地发现自己在一个领域中使用另一个领域中的怪异“技巧”，使你能够解决你原本无法解决的问题。如果没有其他事情，当你的特定数据科学专业最终被新技术打乱时，拥有其他优势是很好的。

你可以随时丢掉工作，但你获得的知识是你自己的。

我不仅相信你会从学习尽可能多的数据科学学科中受益，我还相信你应该追求一般编程技能、数据工程系统和工作流、设置云基础设施、前端开发等方面的知识。数据科学家可以整天坐在 RStudio 中装配模型，然后将它们交给运营团队的日子已经一去不复返了。

尽可能多的熟悉工具。塞萨尔·卡里瓦里诺·阿拉贡在 Unsplash 上的照片

7.这可能不是你的工作，但这是你的问题

一位朋友最近提出了一种观点(见此处)，即所有最成功的数据科学家通常都有一种“可能不是我的工作，仍然是我的问题”的心态。如果没有人做数据接收或建立基础设施，有人搞砸了数据清理，没有人做利益相关者管理，或者其他什么，你必须找到一种方法来处理这些。处理这些事情可以塑造性格。

取得所有权，并尽一切努力创造商业价值。

成长为数据科学家的最佳方法之一是将一个困难的数据科学问题一直带到它创造商业价值的地方，而不仅仅是创建一个概念验证。这也是许多项目即使在概念验证成功后仍然失败的另一个原因；没有人站出来接受将东西投入生产的各种挑战。

这是你的问题；想办法解决。照片由菲利普·姆罗兹在 Unsplash 上拍摄

8.定义正确的问题

数据科学项目无法产生商业价值的原因有很多。我认为经常被忽视的一个原因是未能解决正确的问题。有些人花了几个月的时间接收或清理数据，却不知道或不打算如何处理这些数据。有些人过于坚持使用特定的建模方法。更典型的是，有时候，你花了很长时间去创造一些企业实际上从来不想要或不需要的东西。

有时无法创建您想要的模型。或者更糟的是，一开始就没有人想要这个模型。

在花几个月的时间清理数据之前，明确你想用这些数据做什么，并建立一个基线 ML 模型来指导你的清理之旅。与利益相关者交谈，建立良好的关系，确保他们比你自己更渴望看到这个模型投入生产。这本身就是一项重大任务——你需要将一个现实世界的问题转化为一个可以解决的机器学习问题。

当致力于一个给定的解决方案时，如果经过大量的努力，你似乎不能创建一个足够好的模型，试着重新思考你是否能解决一个不同的“正确”的问题；例如，也许有可能解决分类问题而不是预测问题？或者将该方法重新表述为排序问题而不是回归问题，等等。

有很多解决方法；找到能产生价值的正确选择。Akhilesh Sharma 在 Unsplash 上拍摄的照片

9.养成良好的习惯

意志力和热情不足以掌握数据科学，除非你痴迷于数据科学，每天每时每刻都在吃饭、睡觉和呼吸数据科学。我在更长的时间里做了后者，虽然肯定有所收获，但最终会导致精疲力尽。相反:

良好的习惯必须建立和坚持，以确保你的技能逐步和不断提高。

建立成功的习惯本身就是一个话题，但是像《原子习惯》这样的书是一个极好的起点。习惯的例子可以是每天早餐前阅读一篇研究论文，总是编写关于函数和方法的文档字符串，总是在任何模型开发之前建立一个简单的基线，每个月从头开始重新实现一篇研究论文，等等。

掌握数据科学是一个漫长的旅程。及早建立良好的习惯。照片由 Unsplash 上的 FitNish 媒体拍摄

10.数据科学不会灭绝

在开始数据科学的第一周内，有人告诉我，几年后我们会让自己过时。是的，我相信我们的目标是让我们现在所做的一切自动化并“过时”不，数据科学不会灭绝。你的技能可能会。或者“数据科学”的名称可能会随着时间的推移而被分成子学科。但是，利用数据产生洞察力和价值的核心理念将在未来很长一段时间内保持不变。auto ml 和无/低代码数据科学工具唯一能做的就是让你专注于更有趣和更困难的问题，而不是构建模型的重复部分。

保持你的好奇心和激情，你就永远不会过时。马库斯·兰格在像素上拍摄的照片

11.学会讲故事

比方说，我们可以将你讲故事的技能映射到一个连续的尺度上，其中 0 表示完全没有能力传达你的结果，1 表示非常有效和引人入胜的沟通。现在，如果你把所有的技术技能都用在数据科学家身上，那么:

你能创造的价值将与你讲故事的能力乘以你的技术实力成正比

教训？学会交流你的结果，讲一个吸引人的故事，但不要损害你的技术能力，也就是说，不要把所有的时间都花在制作幻灯片上，即使这是你老板想要的。

训练你的沟通技巧。获得他人的反馈。Artem Podrex 在像素上拍摄的照片

12.吃你的蔬菜

掌握数据科学很难；你必须了解业务问题，你必须能够与人交谈并有效地沟通，你需要能够有效地实施复杂的编码和分析解决方案，你必须不断地做研究和重塑自己，保持在最前沿。

要做所有这些事情，你的大脑需要以最佳能力运作。尤其是如果你要挑战自己的极限。自学，实验，并客观评估不同饮食和锻炼方案的结果。不要陷入认为自己“需要”特定食物、兴奋剂等的陷阱。—如果你对这个完全陌生，也许可以读一本像《快乐陷阱》这样的书。我希望这不是真的，但对我个人来说，我知道一个事实，我的健康强烈影响我的表现。

给你的大脑最佳的工作条件。由尚塔尔·卡尼尔在 Unsplash 上拍摄的照片

13.掌握基础知识

定期重新学习基础知识。在一个典型的预测用例中，目标是创建一个在现实生活中表现良好的 ML 模型。也就是说，基于我们的训练集或测试集中从未见过的数据。为了帮助我们创建这样一个模型，它将很好地将推广到看不见的数据，我们通常使用交叉验证的基本技术。你必须确定你得到了，而不是发现自己在迭代优化一些分数，这最终不会转化为一般化。

归根结底，ML 模型的目标是处理新的看不见的数据

不要让信息从训练泄露到测试集。确保你理解分层交叉验证，时间序列交叉验证等。熟悉不同的评估标准，它们的优点和缺点。请让你有足够的经验知道，改进一个模型通常更多的是关于数据质量而不是模型本身。请记住，在一天结束时，ML 模型的目标是在新的看不见的数据上表现良好。

掌握基本面。一次又一次。照片由你好我是尼克在 Unsplash

14.建立基线

当面对一个新问题时，立刻跳到超高级模型的人并不鲜见。总是从你能想到的最简单的模型开始，并把它作为你的“基线”然后，您可以开始逐步试验数据和模型优化。使用 mlflow、W&B 等工具记录所有实验。

在进行任何预测建模之前，总是首先建立一个简单的基线。作者图片

15.不要相信你自己的结果

在没有 1)确保你的交叉验证设置是合法的，以及 2)你已经彻底检查了你的预测的 SHAP 值或类似值之前，不要给出任何结果。

在展示预测模型评估结果之前，问问你自己:1)我的验证策略有意义吗？以及 2)我是否彻底检查并解释了为什么模型预测了它的行为？

通常，从业者会发现给定的模型在给定的问题上表现得非常好，只是后来意识到在评估期间信息从测试泄露到了训练数据集。或者，实现从目标泄露了信息，例如，以一些不应该存在的高度相关的输入特征的形式。或者，在某些情况下(例如，图像)，意识到模型关注的是与我们希望它关注的完全不同的东西。

在把你的东西展示给其他人之前，对其进行完整性检查。由杰斯温·托马斯在 Unsplash 上拍摄的照片

16.不要相信别人的结果

也不要盲目接受别人的结果。这适用于科学文献和你同事的成果。即使一切都“编译”得很好，并产生了合理的结果，在给定的解决方案中仍然可能有完全不明显的错误，所以总是要仔细研究你的同事是如何解决特定问题的。希望他们也能为你做同样的事情！

我确实认为有一个很好的思考框架。这是物理学——你知道那种基本原理推理……我的意思是将事物归结为它们的基本真理，并从那里推理，而不是通过类比推理——埃隆·马斯克

不过，这一课更深入。细节决定成败。不要相信一个调整图像大小的库会像您可能在生产中使用的另一个库一样执行此操作。不要相信人们在给定的库中正确地实现了给定的算法。不要假设人们知道如何正确计算标准差——质疑一切。

对一切数据科学持怀疑态度。凯尔·格伦在 Unsplash 上的照片

17.不要相信顾问

在公司工作，你至少偶尔会和顾问一起工作。你可以在这些顾问中找到一些最聪明的头脑和最好的数据科学家。然而，你也可以找到高级/首席数据科学家，他们不知道自己在做什么。

那么，你应该总是选择大型咨询公司中最贵的顾问吗？不，实际上，我的经验恰恰相反，初创公司/较小的独立咨询公司通常会产生更好的结果。在任何情况下，都要像对待任何候选人一样，仔细评估有问题的个人(而不是整个咨询公司)，并建立良好的工作关系。

然而，最重要的是，始终让内部数据科学家(即技术人员)与顾问一起工作，以确保组织内结果的质量、一致性和稳定性。

结合内部资源使用顾问。照片由斯特芬·维恩伯格在 Unsplash 拍摄

18.当心时间序列问题

这一个可能听起来很奇怪，也许只是我，但是我已经被它烧伤了很多次。各种时间序列问题。真正的问题很少像预测教程一样，尤其是在金融问题中，您很快就会在不同的时区中为不同的项目发生的不同事件找到多个时间戳条目，在建模之前清理这些条目确实是一件麻烦的事情，需要大量关于业务流程的知识。总是为这些分配一点额外的时间，因为当你开始进入事情的商业逻辑时，它会变得令人毛骨悚然。

时间序列问题会很快变得非常混乱和纠结。照片由莉迪亚·古林金娜在 Unsplash 上拍摄

19.一切都是网络应用

即使您创建了有史以来最棒的模型，如果它只是放在您的本地机器上，或者如果您只是与最终用户共享原始实现，它也很少有价值。使用一个给定的 ML 实现的障碍必须尽可能地低，并且最容易获得的展示你的模型的方法之一是作为一个网络应用，在那里终端用户可以引导他们的浏览器到例如[www.mycompany.com/sales_forecast](http://www.mycompany.com/sales_forecast)以获得他们的销售预测。实现应用程序可以使用简单的框架，如 streamlit 或 dash ，或者使用更成熟的后端框架(如 F lask ，D jango ，或 FastAPI 和前端框架( React ， Angular ， Vue )。

你的 ML 很可能以一个 webap 结束。由 Carlos Muza 在 Unsplash 上拍摄的照片

20.谦虚一点

最后，谦逊是任何数据科学家都必须具备的美德。这个领域是巨大且不断变化的，我们不得不不断面对我们花了数年时间学习的技术现在已经过时，我们并不像自己认为的那样理解一个给定的概念，或者有很多人比我们聪明。不断学习，保持谦虚；总是有很多东西要学。

保持谦逊，记住你所知甚少。卡尔·约翰逊在 Unsplash 上拍照

结束语

这是一篇相当长的文章，所以如果你读到了这里，谢谢你读完了所有这些🙌我肯定我忘记了许多已经成为第二天性的课程，而不是受到有意识的关注。我很想听听其他人的经验教训，所以请不要客气。我确信，在科技公司工作的数据科学家的经历与我不同，我的经历是在生物技术和制药公司工作有限几年后收集的。

2023 年 30 个必须订阅的数据和人工智能简讯

原文：https://towardsdatascience.com/20-must-subscribe-data-and-ai-newsletters-in-2021-7c5ddb9b3c19?source=collection_archive---------4-----------------------

数据和人工智能

一个有声誉的时事通讯的精选列表，包含关于 DS、DE、ML 和 AI 的优质内容

Solen Feyissa 在 Unsplash 上拍摄的照片

T 互联网上有大量关于数据科学和人工智能的噪音，专注于高质量的新闻和内容可能会让人不知所措。

正如司马贺所说:

“……丰富的信息造成注意力的匮乏……”

信息过载的解决方案？

时事通讯。

如果你想跟上这个行业，并且正在寻找最好的时事通讯，那么你很幸运。

下面是 20 多份声誉卓著、内容丰富的时事通讯，从最新的新闻和观点到最好的工具、资源和教程。

· [Data Science](#e2d7)
  ∘ [Deep Grit](#1ab4)
  ∘ [Data Elixir](#3ea8)
  ∘ [Data Science Weekly](#af9e)
  ∘ [Data Phoenix](#f1dc)
  ∘ [KDnuggets News](#ac08)
  ∘ [O’Reilly Data Newsletter](#b30f)
  ∘ [Analytics Dispatch](#919b)
  ∘ [The Reshape](#38d5)
· [Data Engineering](#fad6)
  ∘ [Data News](#4864)
  ∘ [Data Engineering Weekly](#7556)
  ∘ [Start Data Engineering](#12ec)
· [Machine Learning](#df67)
  ∘ [Paper with Code Newsletter](#de86)
  ∘ [The Machine Learning Engineer Newsletter](#18b8)
  ∘ [Eugene Yan’s newsletter](#e458)
  ∘ [Machine Learning Monthly](#1a26)
  ∘ [Machine Learning Mastery](#460b)
  ∘ [Machine Learning Ops Roundup](#3ed8)
· [Artificial Intelligence](#cfce)
  ∘ [The Batch by DeepLearning.AI](#3e35)
  ∘ [Data Machina](#c9db)
  ∘ [AI tidbits](#2c6f)
  ∘ [Big Brain](#e99d)
  ∘ [Smoking Robot](#4fb5)
  ∘ [Alpha Signal](#01ff)
  ∘ [Import AI](#abd3)
  ∘ [AI Weekly](#20e1)
  ∘ [AI newsletter by Andriy Burkov](#a0aa)
  ∘ [The Sequence](#4387)
  ∘ [Last Week in AI](#c0c9)
  ∘ [Your Guide to AI](#50d8)
  ∘ [Your AI Weekly Digest](#e2e9)

在我们进入之前，计划学习数据科学和 AI？

这里是最好的免费资源👇

数据科学

深层砂砾

由bitgrit.net提供的综合性月度时事通讯，包含他们最新的人工智能竞赛、研讨会、技术文章和教程、人工智能新闻以及数据科学学习资源。

阅读最新一期 &订阅这里。

数据灵丹妙药

由 Lon Reisberg 每周策划的 data elixir 是最受欢迎的数据科学时事通讯之一，它为您带来洞察力、教程、项目观点和资源。

阅读往期 &订阅此处。

数据科学周刊

一份免费的每周时事通讯，包含与数据科学相关的精选新闻、文章和工作。

阅读往期订阅此处。

数据凤凰

收集了 ML、DL、计算机视觉、NLP、数据科学、机器人学和人工智能其他方面的最佳和最新文章、论文、课程、采访、播客、视频、数据集、事件、书籍和工作。

阅读往期 &订阅这里。

KDnuggets 新闻

KDnuggets 是机器学习、数据科学、人工智能等领域的领先网站，汇集了其特色故事、教程和概述、观点、热门故事和每周公开招聘。

阅读往期 &订阅此处。

奥赖利数据通讯

关于数据世界热点的最新信息和来源的完美融合

阅读样刊 &订阅此处。

分析调度

由团队以模式策划的关于数据、数据科学和分析的每周电子邮件。

阅读往期 &订阅这里

重塑

通过阅读每个工作日直接发送到您收件箱的顶级文章，了解人工智能和数据科学的最新动态

阅读最新一期 &订阅这里

https://medium.com/bitgrit-data-science-publication/why-is-data-engineering-popular-now-4e41b9f80cf4

数据工程

数据新闻

由数据工程负责人 Christophe 和蔻驰策划，数据新闻是一个关于数据工程相关新闻和工具的每周策划。

阅读往期订阅此处。

数据工程周刊

由 Ananth Packkildurai 策划，这份每周一期的数据工程时事通讯介绍了数据工程领域的最新趋势和新闻。

阅读往期 &订阅这里。

开始数据工程

这是一份时事通讯，每一到两周为您提供一次有关核心数据工程概念、热门软件和工具以及发展您的数据工程职业的技巧的文章。

阅读所有文章 &订阅这里。

由 Nihit Desai 和 Rishabh Bhargava 策划，这份时事通讯探讨了软件 2.0 的发展意味着什么以及出现的新挑战。他们分享了自己对如何写出更好的软件 2.0 的看法。

阅读最新一期 &订阅这里。

人工智能技术、地缘政治、研究和创业公司月度分析。

阅读往期 &订阅此处。

你的人工智能每周文摘

频道 What's AI 的创建者 Louis Bouchard 每周发一份时事通讯，他每周分享一篇论文，包含关于该论文的所有内容以及他正在从事的一些奖金项目。

阅读往期 &订阅这里。

这是我为你准备的所有时事通讯。感谢您的阅读！

如果您有任何建议或补充，欢迎在下面评论！

关注我在 LinkedIn 和 Twitter 上的精彩数据科学资源。

喜欢我的写作吗？加入媒介与我的 推荐链接 。你会直接支持我🤗

https://benedictxneo.medium.com/membership

数据科学和机器学习任务对完美笔记本电脑的 20 项必要要求

原文：https://towardsdatascience.com/20-necessary-requirements-of-a-perfect-laptop-for-data-science-and-machine-learning-tasks-7d0c59c3cb63?source=collection_archive---------0-----------------------

为数据科学和机器学习选择合适的笔记本电脑

照片由 XPS 在 Unsplash 上拍摄

如果你正在学习数据科学和机器学习，你肯定需要一台笔记本电脑。这是因为您需要编写并运行自己的代码来获得实践经验。当你考虑便携性时，笔记本电脑是最好的选择，而不是台式机。

传统的笔记本电脑可能不太适合您的数据科学和机器学习任务。你需要仔细考虑笔记本电脑的规格来选择合适的笔记本电脑。如果你想买一台笔记本电脑用于数据科学和机器学习任务，这篇文章就是为你准备的！在这里，我将讨论一个完美的笔记本电脑数据科学和机器学习任务的 20 个必要要求。

我们开始吧！

选择正确的处理器(CPU)

照片由奥利维尔·科莱在 Unsplash 上拍摄

要求 1:处理器的生成

始终考虑购买新一代处理器。英特尔第 11 代处理器和 AMD 第 5 代(5000 系列)处理器现已上市。英特尔第 8 代、英特尔第 10 代和 AMD 第 3 代(3000 系列)、AMD 第 4 代(4000 系列)处理器是您可以考虑的其他选项。然而，随着新一代处理器的出现，处理能力、新硬件兼容性、能效和散热管理都有了显著提高。

要求 2:内核和线程的数量

这是您应该考虑的最重要的需求之一。大多数机器学习任务需要并行计算。例如，当您训练随机森林算法或执行超参数调整时，如果您的处理器拥有更多内核，则可以指定更多内核供算法使用。这将大大加快这一进程。核心是单个芯片中独立 CPU 的数量。它们是硬件。线程是可以由单个 CPU 内核处理的指令。始终考虑购买具有更多 CPU 内核和线程的笔记本电脑，尤其是如果您的笔记本电脑没有单独的(独立)显卡(GPU)。4 核-8 线程处理器是我可以向您推荐的最低要求。如果你能负担得起更多的钱，你可以选择 6 核 12 线程或 8 核 16 线程或更高。

要求 3:基本时钟速度(频率)

基频是处理器的最低速度。基频越高，处理器越快。这通常以千兆赫(GHz)为单位。

要求 4:高速缓存

高速缓冲存储器充当 RAM 和 CPU 之间的缓冲器。它保存经常使用的数据和指令，以便在再次使用时 CPU 可以立即使用它们。高速缓冲存储器越高，计算机越快。高速缓存通常以兆字节(MB)为单位。建议使用 8 MB 的高速缓存。

要求 5:支持的内存类型、大小和速度

如果你打算将来升级内存，这是值得考虑的。推荐内存类型为 DDR-4，大小为 8 GB，速度为 3200 MHz。

考虑到以上需求，我可以为你推荐以下处理器。

AMD 锐龙 7 4700U (核心:8 个，线程:8 个，基本时钟:2.0 GHz，高速缓存:8 MB)
AMD 锐龙 5 4500U (核心 6 个，线程 6 个，基础时钟 2.3 GHz，缓存 8 MB)
AMD 锐龙 7 4800H (核心:8 个，线程:16 个，基础时钟:2.9 GHz，缓存:8 MB)
AMD 锐龙 5 4600H (核心:6 个，线程:12 个，基本时钟:3.0 GHz，高速缓存:8 MB)
英特尔酷睿 i5–1135 G7(内核:4 个，线程:8 个，基本时钟:2.4 GHz，高速缓存:8 MB)
英特尔酷睿 i7–10700(内核:8 个，线程:16 个，基本时钟:2.9 GHz，高速缓存:16 MB)

这是我的选择清单。您可以根据上述要求和预算自由选择合适的处理器。

选择正确的 RAM

拥有摄影的照片在 Unsplash 上

要求 6: RAM 大小

这是大多数人认为的。但是请记住，增加内存大小并不能提高计算机的速度。更大的内存容量将允许你进行多任务处理。建议至少 8 GB 的 RAM 大小。我不推荐 4 GB 的内存，因为操作系统已经占用了大约 3 GB 的内存，只有 1 GB 可用于其他任务。如果你负担得起，并且你的笔记本电脑支持，升级到 12 GB 或 16 GB 是一个完美的选择。您通常希望在笔记本电脑上安装虚拟操作系统来进行大数据分析。这种虚拟操作系统至少需要 4 GB 的内存。当前的操作系统任务大约需要 3 GB 内存。在这种情况下，8 GB 的内存是不够的，12 GB 和 16 GB 是完美的选择。

要求 7: RAM 总线速度

建议速度为 2666 MHz。不要低于这个。现代 DDR-4 ram 支持 3200 MHz 的总线速度。总线速度越高，您的计算机就越快。

选择正确的存储器(辅助存储器)

图片由 iyus sugiharto 在 Unsplash 上拍摄

要求 8:存储类型

这是最关键的要求。传统的笔记本电脑配有硬盘驱动器。硬盘非常非常慢。如果你买一台 i7 笔记本电脑，配一个传统的硬盘，你的笔记本电脑会非常慢。启动和打开程序要花很多时间。硬盘有移动的机械部件，会延迟信息处理，降低可靠性和耐用性。因此，有必要购买或升级您的笔记本电脑，配备 SSD(固态硬盘)。固态硬盘比硬盘功能强大得多。它们没有活动部件，性能卓越。NVMe 固态硬盘是普通固态硬盘的升级版本。它们比普通固态硬盘快 6 倍。如果你的笔记本电脑主板支持 NVMe 固态硬盘，你可以考虑升级。你甚至可以用普通的固态硬盘替换你的硬盘，但不能用 NVMe 的固态硬盘。为此，您应该购买 2.5 英寸的固态硬盘，而不是 M.2 的固态硬盘。NVMe 固态硬盘不支持 2.5 英寸外形。

要求 9:存储大小

如果考虑买带 SSD 的笔记本电脑，可能买不起 1 TB 的 SSD，因为贵很多。理想的大小是 512 GB。不要低于这个。

选择合适的显卡(GPU)

照片由克里斯蒂安·威迪格在 Unsplash 上拍摄

要求 10:品牌

NVIDIA 和 AMD 是显卡的两大品牌。Tensorflow 深度学习库使用 CUDA 处理器，只能在 NVIDIA 显卡上编译。因此，如果你打算做深度学习任务，我强烈建议你购买一台配备 NVIDIA GPU 的笔记本电脑。建议使用 GTX 1650 或更高的 GPU。拥有独立显卡的另一个优势是，普通的 GPU 有 100 多个核心，但标准的 CPU 有 4 个或 8 个核心。

要求 11: GPU 大小

建议至少 4 GB 的 GPU。

选择合适的显示器

丹尼尔·库切列夫在 Unsplash 上拍摄的照片

要求 12:蓝光过滤功能(眼部护理)

这是你绝对应该考虑的事情。你的眼睛真的真的很值钱。数据科学和机器学习的学生在笔记本电脑前花费数小时的时间。大多数带有显示器的电子设备都会发出有害的蓝光，笔记本电脑也是如此。然而，现代笔记本电脑有蓝光过滤技术和无闪烁屏幕。另一个很好的选择是购买一台显示器，并将其与您现有的笔记本电脑连接。大多数现代显示器都配有经过认证的低蓝光、无闪烁屏幕。

要求 13:显示尺寸

强烈建议使用 15.6 英寸或 17.3 英寸的显示器。不要低于这个。拥有 22 英寸或 24 英寸的显示器是完美的选择。所以，可以考虑买个显示器，和笔记本电脑连接。

要求 14:显示分辨率

建议使用全高清(1080p)或高清(720p)显示器。

选择正确的品牌

我不能告诉你买一个特定的品牌。这完全由你来决定。以下是一些需要考虑的要点。

要求 15:可靠性

可靠性指的是笔记本电脑运行时出现故障的频率。意外关机、蓝屏错误和其他硬件故障是最常见的问题。

要求 16:耐久性

耐用性是指你可以使用笔记本电脑多长时间。你可以通过查看笔记本电脑的保修期来猜测它的耐用性。如果你的笔记本电脑能使用至少 4 年，它就不会浪费你的钱。

要求 17:售后服务和技术支持

您选择的品牌应该提供产品手册、升级选项和技术支持。

要求 18:可升级性

您选择的品牌应该提供添加 RAM 和辅助存储(例如固态硬盘)的简单升级选项

其他要求

要求 19:键盘类型

强烈建议使用带数字键盘的全尺寸键盘。

要求 20:操作系统

推荐 Windows 10。它是用户友好的。如果你愿意，Linux 等其他操作系统也可以在 Windows 操作系统中轻松运行。

我希望你下次能买到合适的笔记本电脑！

我的读者可以通过下面的链接注册成为会员，以获得我写的每个故事的全部信息，我将收到你的一部分会员费。

报名链接:【https://rukshanpramoditha.medium.com/membership

非常感谢你一直以来的支持！下一个故事再见。祝大家学习愉快！

鲁克山·普拉莫迪塔
2021–06–05

2020 年 NFL 季后赛机器学习模型预测会议

原文：https://towardsdatascience.com/2020-nfl-postseason-predictions-from-machine-learning-model-conference-fb3be4012b89?source=collection_archive---------45-----------------------

数据科学

由于进攻激增和稳定的防守，包装工队以微弱的优势受到青睐

在 NFL 季后赛的前两周，我分享了我的模型(V 5.0)预测(外卡、分区)。在 10 场比赛后，模型表现几乎与预测赢家的测试集中的表现完全匹配(实际:7/10，70%；测试集:69.6%)。再一次，当涉及到预测比分差异时，该模型的表现比 ESPN 分享的其他估计更好(由凯撒体育图书提供，威廉希尔；CSWH) 和 FiveThirtyEight (QB 调整后的 Elo )【更多详细信息请参见部门评审部分】。相对于这些其他预测，该模型继续表现良好，本周首次预测了一个游戏中的不同赢家，比尔对酋长[更多详细信息见**为什么 V 5.0 支持比尔？**章节】。

以下是会议锦标赛的 V 5.0 预测，包括 CSWH 和 FiveThirtyEight 在撰写本文时提供的预测:

会议游戏预测对比(图片由作者提供)

与前两周相比，最受欢迎的人并不都匹配，因为 V 5.0 预测法案将获胜，而其他两人则倾向于酋长队。这三个都同意包装工受到青睐，但 V 5.0 预测比其他人更接近的比赛。

如果我们假设 V 5.0 的赢家准确率为 69.6%，那么最有可能的结果是两个预测都正确(2 个正确:48%，1 个正确:42%，0 个正确:9%)。

为什么 V 5.0 青睐票据？

上周我描述了随机森林算法的主要贡献者大多是权力排名[eattrinkandsleepfootball]，还有效率指标[number fire]和 Elo 得分[ FiveThirtyEight ]。对于比尔和酋长来说，权力排名和 Elo 得分非常相似，但效率指标略有不同，特别是在最近几周。

numberFires 的整体进攻和防守指标。对于进攻，正数更好。对于防御来说，负数更好。(图片由作者提供)

几乎整个赛季，酋长队的整体进攻得分都高于比尔队，但在第 16 周之后，比尔队在这一指标上领先，目前领先联盟。比尔队的进攻在对阵两个前 10 名防守球队(小马队和乌鸦队)时表现出色，这提高了他们的排名。另一方面，自第 13 周以来，比尔的总体防御评分一直相当稳定，而酋长队的评分则逐渐恶化。我不能不提这场比赛的一个关键因素 MVP 四分卫帕特里克·马霍斯的状况，他上周受了伤。如果他不参加，V 5.0 实际上可能低估了比尔获胜的机会。

对于海盗队和包装工队来说，虽然净效率评级有利于坦帕湾，但功率排名和 Elo 得分有利于格林湾，足以提示包装工队的方向。

部门审查

如上所述，在之前的两周，所有三个来源都预测了相同的赢家。因此，我们可以再次比较平均绝对误差(MAE，较低的值表示较好的预测)。

外卡和分区游戏的平均绝对误差比较(图片由作者提供)

在周日的比赛后，正确率肯定会有所不同，梅也可能会改变。我们将很快发现 V 5.0 是否仍然领先于其他进入超级碗 LV 的版本。

一些有趣的故事线

NFL 的球迷知道有趣的故事在联盟中比比皆是。我正在考虑参加联盟锦标赛的几个人:

与本周日比赛的其他三支球队不同，水牛比尔队从未赢得过超级碗。他们在 90 年代初连续四次出场，但都是 0-4。如果 V 5.0 是正确的，他们将在几周内再次冲击隆巴迪奖杯。
如果海盗队的一些事情进展顺利，他们能够击败包装工队，他们将是第一支在主场打超级碗的球队，可能会让他们超过他们的亚足联对手。汤姆·布拉迪也将填补他的超级碗出场记录(目前是 9 次)。

机器学习模型对 2020 年 NFL 季后赛的预测—分区

原文：https://towardsdatascience.com/2020-nfl-postseason-predictions-from-machine-learning-model-divisional-a9391ad23e79?source=collection_archive---------43-----------------------

数据科学

酋长队和包装队得分，圣徒队和比尔队勉强领先

一周前，我分享了我的模型预测(V 5.0) ，事实证明，该模型在预测赢家方面的表现与预期一致(4/6，67%)。在预测比分差距方面，该模型比其他由 T4 ESPN(由凯撒体育出版社提供，威廉希尔；CSWH) 和 FiveThirtyEight (QB 调整的 Elo )【更多详情请参见外卡审核部分】。由于该模型迄今为止似乎在预测季后赛结果方面做得不错(尽管是在一个小样本中)，我想我应该分享一下它对分区赛的预测，并看看预测背后的主要特征(即数据输入)。

以下是 5.0 版对季后赛第二轮的预测，我再一次包括了 CSWH 和 FiveThirtyEight 在撰写本文时提供的预测:

分区赛预测对比(图片由作者提供)

同样，所有的收藏夹都匹配。预测的赢家按信心大小排序是:酋长、包装工、圣徒、比尔。相对于其他预测，V 5.0 也有预测更激烈游戏的趋势。

根据历史表现，本周 V 5.0 最有可能的结果是 4 个正确的赢家中有 3 个。此外，四大热门只有大约 20%的机会获胜。换句话说，在下周的联盟锦标赛中，我们至少有五分之四的机会看到五六个种子选手。

模型特征重要性

上周我提到过随机森林算法使用的特征类型:

团队效率指标[ numberFire ]
Elo 分数，根据游戏结果和对手实力来量化团队实力[ FiveThirtyEight
不同来源的权力排名[eattringandsleepfootball

与其他一些方法不同，随机森林的一个好处是可以在不影响性能的情况下使用大量的功能，因此系统的功能选择是不必要的。不过，一个不利之处是，可能更难判断哪些特征对预测贡献最大。有各种各样的方法可以用来评估特性的重要性，我发现在过去非常有用的一种方法是 SHAP 。

我计算了模型特征的 SHAP 值，结果让我有点吃惊。在前 10 项功能中，7 项是功耗排名，2 项是效率指标，只有 1 项与 Elo 得分相关(排名第 7)。这可能有助于解释为什么上周 V 5.0 的表现优于 FiveThirtyEight 更多细节见外卡评论部分]。我原本预计客观特征会比主观特征提供更多的信息，但分析表明事实正好相反。正如在许多其他类型的机器学习任务中所看到的那样，似乎结合客观和主观数据类型比单独使用任何一种类型都会产生更准确的模型。

外卡回顾

由于上周所有三个来源都预测了相同的赢家，所以值得考虑%正确率以外的指标。评估预测性能的另一种方法是计算平均绝对误差(MAE，较低的值表示预测较好)。虽然 CSWH 和 FiveThirtyEight 都准确预测了一个分数差异，但 V 5.0 的 MAE 总体最低:

百搭牌游戏的平均绝对误差比较(图片由作者提供)

下周的正确率肯定还是一样的，所以用 MAE 来比较分区赛的表现也是有意义的。

更接近的游戏？

最终只有一场外卡比赛以分差小于达阵结束。也许会再次有一些大的胜利，酋长队最有可能赢得一场大胜，但总的来说，V 5.0 预测本周会有更接近的比赛。看到一场比赛进入加时赛或以制胜一球结束，我不会感到惊讶——新奥尔良和布法罗的比赛最有可能出现戏剧性的结局。

2020 年 NFL 季后赛机器学习模型预测-超级碗

原文：https://towardsdatascience.com/2020-nfl-postseason-predictions-from-machine-learning-model-super-bowl-d5d7804e26ae?source=collection_archive---------31-----------------------

数据科学

酋长队有 1-2 分的优势，但是模型可能低估了酋长队的进攻

在 NFL 季后赛的前三轮，我分享了我随机的基于森林的模型(V 5.0)预测(外卡、分区、大会)。虽然该模型在前两轮预测赢家后的表现与预期一致，但在会议轮中，它的预测结果是 0 比 2。进入超级碗 LV，其累计表现低于预期(实际:7/12，58%；测试集:69.6%)。然而，在预测比分差异时，在前三轮比赛中，该模型的表现超过了 ESPN(由凯撒体育杂志提供，威廉·希尔；CSWH) 和 FiveThirtyEight (QB 调整后的 Elo )【更多详情请参见会议评审部分】。对于超级碗，虽然所有三个预测都支持酋长队以 3 分或更少的优势击败海盗队，但会议回合的结果表明酋长队实际上可能有更大的优势[更多细节在**为什么 V 5.0 可能低估了酋长队？**一节】。

以下是 V 5.0、CSWH 和 FiveThirtyEight 对本赛季的最终预测(在撰写本文时可用):

超级碗预测对比(图片由作者提供)

为什么 V 5.0 可能低估了酋长的价值？

在第一轮会议中，我描述了 V 5.0 对法案胜利的预测主要是由效率指标的差异驱动的。然而，事实证明这是整个季后赛 V 5.0 最大的错误(16.5 分)。这可能仅仅是由于预测误差的典型变化，还是有可能 V 5.0 有一个系统缺陷？在仔细检查效率指标[由 numberFire 提供]并考虑到酋长队在会议回合中的出色进攻表现，我怀疑 KC 目前的整体进攻值可能被低估了。

numberFires 的整体进攻和防守指标。对于进攻，正数更好。对于防御来说，负数更好。(图片由作者提供)

酋长队和海盗队整个赛季都在提高整体进攻，进入超级碗 LV，酋长队有优势。尽管如此，考虑到这一指标在第 17-19 周之间的增长是适度的，当时 KC 休息了许多进攻首发，有一个轮空周，他们的 MVP 四分卫 Patrick Mahomes 和他们的前 3 名首发跑卫中的两名，Clyde Edwards-Helaire 和 Le'Veon Bell，错过了重要的时间。事后看来，进入第 20 周的整体进攻评分与比尔相比似乎太低了，而且可能仍然有点泄气，因为前几周关键球员在场边时产出较低。此外，防守对强大的比尔进攻做得很好，他们似乎在季后赛比常规赛打得更好。

会议评论

CSWH 和 FiveThirtyEight 在预测获胜者方面领先(8/12，67%)，并根据这一指标锁定了共同胜利，因为所有人都在选择酋长。当谈到预测得分差异时，V 5.0 保持领先，并锁定了该指标的胜利。

外卡、分区和会议游戏的平均绝对误差比较(图片由作者提供)

海盗队能赢得这场冷门吗？

虽然这三个模型都支持酋长队(如上所述，可能有点低估他们)，但海盗队在最后两轮比赛中无视预测，一致不敌包装工队和圣徒队。事实上，根据 CSWH 和 FiveThirtyEight 的说法，他们爆冷的几率实际上与前几轮一样好，甚至更好。在落后于未来名人堂成员汤姆·布拉迪之后，他们的进攻有所改善，他们的防守将是酋长队在季后赛中遇到的最艰难的单位。值得注意的是，酋长队正在处理进攻线上的伤病，所以他们可能比平时更难保护马霍斯，并为爱德华兹-海莱尔创造跑动路线。

鉴于酋长队的进攻能力，(除非一个关键的伤病)很难想象海盗队通过多次达阵获胜，但如果一些事情打破了他们的方式，坦帕湾队可能会在主场庆祝超级碗的胜利。也许一次及时的失误或者一次意想不到的恶作剧是成功的关键。

即使一支球队开局很好，这两支顶级球队都有能力迅速得分，并卷土重来。如果模型是正确的，这将可能是一场势均力敌的比赛，甚至可能归结为一场致胜的比赛。

2021:人工智能一年(至今)

原文：https://towardsdatascience.com/2021-a-year-in-ai-so-far-a97851a6869e?source=collection_archive---------29-----------------------

播客

在“让我们谈论人工智能”播客上，与我们的朋友一起回顾 2021 年最大的人工智能故事

苹果 | 谷歌 | SPOTIFY | 其他

编者按:这一集是我们关于数据科学和机器学习新兴问题的播客系列的一部分，由 Jeremie Harris 主持。除了主持播客，Jeremie 还帮助运营一家名为sharpes minds的数据科学导师初创公司。

2020 年对人工智能来说是不可思议的一年。我们第一次看到了大型语言模型潜力的强大暗示，这要归功于 OpenAI 的 GPT-3 ，DeepMind 使用人工智能解决了分子生物学中最大的公开问题之一，Boston Dynamics 展示了他们以戏剧性的方式融合人工智能和机器人技术的能力。

人工智能的进展正在呈指数级加速，尽管 2021 年刚过一半，但今年已经成为书本上的又一年。因此，我们决定与我们的朋友在“让我们谈谈人工智能”上合作，这是一个播客，由斯坦福大学博士、前谷歌公司 Sharon Zhou 和斯坦福大学博士生 Andrey Kurenkov 共同主持，内容涉及人工智能领域的时事。

这是一次有趣的聊天，我们将来肯定会更多地使用这种形式:)

以下是我们讨论的一些主要主题:

https://www.technologyreview.com/2021/01/05/1015754/avocado-armchair-future-ai-openai-deep-learning-nlp-gpt3-computer-vision-common-sense/****多模态学习。如果说 2020 年是大型语言模型和元学习的一年，那么 2021 年是将视觉和文本结合在一起的大型多模态模型的一年。OpenAI 的 CLIP 和 DALL-E 模型显示了语言建模和视觉的结合是多么的强大。尤其是 DALL-E，它已经证明自己能够根据用户指定的文本提示生成令人印象深刻的图像。据推测，这一领域还会有更多的发展，包括与机器人技术的集成，以及继续推动人工智能进入物理世界。
偏于 AI 型号 。鉴于人工智能算法中存在偏见的既定问题，关于人工智能何时以及如何应用的新问题正在被提出。最近，一名黑人男子因被计算机视觉系统误认为是商店扒手而在监狱呆了 10 天后起诉了新泽西州警察局。像这样的事件激发了国家和国际监管机构对解决人工智能系统带来的挑战的新兴趣。它们还迫使我们客观地思考什么是公平和偏见:只有当我们严格定义这些术语时，它们才能在技术上易于处理。
生成性时代的所有权权利 AI 。最近，人工智能模型被用来生成一系列虚假的——但看似怪异的——涅槃乐队的歌曲，尽管他们的主唱柯特·科本在 1994 年去世了。这就引出了一个有趣的问题:谁拥有这首音乐的版权？而谁应该？随着人工智能系统让我们以新的方式思考创造力本身，它们也迫使我们质疑几个世纪以来我们对信用分配和版权的假设。越来越明显的是，对许多人来说，不理解人工智能不再是可选的——包括律师、法官和政治家——他们曾经可以将他们的思维外包给这类问题的专家。

你可以在推特这里关注我。

章节:

0:00 介绍
六点零五分
13:05 对 GPT-3 的评论
19:43 面部识别技术的问题
27 俱乐部 31:20 丢失的磁带
42:20 总结

2021 年 NHL 预测模型:高级概述

原文：https://towardsdatascience.com/2021-nhl-projection-model-high-level-overview-2366b3be5538?source=collection_archive---------28-----------------------

关于 TopDownHockey 的最新游戏模拟模型，你需要知道什么

2021 年圣何塞鲨鱼队的预测。(图片由作者提供)

我模拟了 2021 NHL 赛季 10000 次，以便确定每个结果的概率。我已经开始在 Twitter 上分享我的工作成果，并计划很快写一个完整的季度预览，但在此之前，我必须概述一下我所做的工作，以便读者可以分析这个过程，并确定他们认为该模型的优势和劣势。

我首先使用极端梯度推进来建立一个预期目标模型，该模型确定了每次射门成为目标的概率。关于这个过程的更多信息可以在这里找到。(注意:当我在这里和本文的其余部分使用射门时，我指的是所有未被阻挡的射门，包括那些没有入网的射门。)然后，我使用事先知情的岭回归来获得每个滑冰运动员对他们的团队产生和允许射门和预期进球的速度的影响的点估计，以及力量比赛中的射门和预期进球，以及点球决胜中的射门和预期进球。为了获得每个运动员对他们自己的射门成为进球的概率的影响的点估计，以及每个守门员对他们面对的射门成为进球的概率的影响的点估计，我遵循了一个非常类似的过程，但使用了非事先知情(香草)岭回归。更多关于使用回归分析 NHL 滑手的过程可以在这里找到。

在过去的 6 个赛季中，我都重复了这个过程。(2014–2015 年至 2019–2020 年。)然后，我对这些赛季中的每一个赛季进行了线性回归，以获得系数估计值，这将为我提供放置在第 1、2 和 3 年的适当权重，以便最准确地预测球员在第 4 年的表现，然后将这一结果应用于过去 3 个赛季中每一个赛季的 NHL 选手。对于过去三个赛季都没有参加比赛的选手，我重复了这个过程，只用第一年和第二年来预测第三年，并将这些权重应用到第一年和第二年。对于只玩了一年的选手，我只是简单地复制和粘贴他们上个赛季的估计影响，并将其作为他们下个赛季的预计影响。

我最初计划对守门员使用相同的过程，但在之前赛季的测试中发现，守门员的表现每年都不太具有可重复性，并且我的预测守门员表现在解释我的预测排名中的差异方面发挥了比实际 NHL 排名更大的作用。这让我通过重复一个类似于我对溜冰者所做的过程来“减轻”守门的重量，而是直接从线性回归中获得拟合值，这将每个守门员的预期表现拉得更接近于零。这提高了模型在前几季测试中的性能。

我在这里得到的每一个投影值都是以比率的形式出现的；对于播放驱动组件，速率是每分钟，对于拍摄和保存组件，速率是每镜头。不是所有的运动员都会打相同的分钟数，也不是所有的运动员在冰场上的投篮命中率都是相同的，这使得这些数字在不知道他们下赛季会打多少和投多少的情况下毫无用处。

为了估计每个选手将上场的分钟数，我使用每个选手的冰上时间百分比(TOI%)重复了上述过程，以预测他们在 2021 年的 TOI 百分比，然后根据他们所有队友的预测 TOI 百分比调整该百分比，以确定每个选手实际上场时间的正确估计。这是用 TOI%平均力量(EV)、力量打法(PP)和点球决胜(PK)完成的。然后，我将他们在每种游戏强度下的预计 TOI%乘以我预计各队在每种游戏强度下的比赛时间——平均强度下大约为 90%,特殊团队为 10%,平均分布在 PP 和 PK 之间——然后将他们在每种游戏强度下的预计每分钟影响乘以我预计他们在该游戏强度下的比赛时间。

为了估计他们队中每个运动员投篮的百分比，我基本上重复了这个过程，得到了他们队中每个运动员投篮的百分比。然后，我将我预测的每个射手的投篮命中率乘以每个射手对投篮得分的影响。

对于守门员，我使用上赛季的比赛作为他们下赛季比赛的初步预测，然后将守门员预计参加的比赛次数除以他们团队中所有守门员预计参加的比赛次数，这为我提供了每个守门员将参加的球队比赛的百分比的估计。然后，我用每个守门员预计参加的比赛百分比乘以他们面对的射门对进球的预计影响。

对于每支球队，我使用了前 12 名前锋、前 6 名防守队员和前 2 名守门员来进行计算。我使用 EV TOI%的排名运动员来确定哪些运动员晋级，使用上赛季的比赛来确定哪些守门员晋级，但根据外部知识做出了一些随意的阵容决定。例如，亚伦·戴尔上赛季比杰克·坎贝尔打了更多的比赛，但基于多伦多枫叶队支付给每个球员的工资和他们收购坎贝尔的交易资产价格，我选择用坎贝尔代替戴尔。有几个队只有一个守门员；对于这些球队，我将守门员的预计表现乘以 47，然后除以 56，作为一种假设，他们将打 47 场比赛，而我一无所知的守门员将打 9 场比赛。对于那些我知道会使用我以前从未见过的滑手的球队，比如纽约流浪者队和亚历克西斯·拉弗雷涅尔队，我只是在那个位置上少用了一名滑手来构建团队组成。

我总结了每个团队的每个玩家对游戏每个部分的预期影响。这些因素的总和为我提供了一个团队对以下六个组成部分的独立影响:射门，射门，预期进球，预期进球，射门和守门。一支球队对前四个组成部分的影响是以每 60 分钟的影响形式出现的，而他们对后两个组成部分的影响是以每次投篮的形式出现的。这六个组件构成了模型的“核心”。

为了确定每支球队投篮和得分的比率，在我的模拟中，我将每支球队的预计影响与其对手的相应影响相结合，以确定每支球队对这些组成部分的总体影响，然后将其添加到球队投篮和得分的联盟平均比率中。为了更好地理解这个概念，想象一下下面这个虚构的游戏(由虚构的数据组成)，为了简洁起见，只关注主队的进攻:

-联盟平均水平的球队每 60 分钟射门 44 次，进球 3 个。

-成为主队增加一支球队的每小时投篮率 1，增加他们的每小时进球率 0.3。

-主队对+5.0 的投篮有影响，客队对-1.0 的投篮有影响。

-主队对预期目标的影响为+0.3，客队对预期目标的影响为-0.1。

-主队选手的射门对进球概率的影响为+0.1%，客场队选手的射门对进球概率的影响为-0.01%。

在对主队的射门质量和客场球队的守门质量进行调整之前，我们看到主队应该每小时射门 49 次，每小时进球 3.5 个，这意味着他们应该以 7.14%的射门得分。调整完成后，我们确定他们应该以 7.23%的命中率得分。

主队和客场队在每一场比赛中都重复这一过程，以获得他们投篮和得分的比率。一旦获得这些值，模拟就可以运行了。

我通过在 R 中创建一个具有 3，600 行和 2 列的数据帧来开始模拟。每行代表我正在模拟的游戏中的一秒钟，每列包含一个随机估计，即一个队是否会根据他们投篮的速度投篮；每个队的照片都有一栏。如果一支球队射门，我会根据他们射门得分的速度来判断这一球是否会成为进球。一旦每一行都完成了这个过程，每个队的进球数就会被加起来，如果一个队的进球数多，就会宣布一个队获胜。如果两个队都进了相同数量的球，我创建一个 600 行 2 列的附加数据帧来模拟加时赛。在加时赛中第一个得分的队赢得比赛，如果两个队都没有在加时赛的 600 秒内得分，将随机宣布一个获胜者，每个队获胜的概率为 50%。

我在 2019-2020 赛季按照相同的流程测试了该模型，并使用了每 82 场比赛的预计得分和每 82 场比赛的实际得分之间的对数损失和平均误差。我得到的对数损失大约为 0.678，平均误差大约为 8.1。该测试与真实和适当的测试略有不同；我同时处于不公平的优势，因为我可以进入球员效力的第一个球队，也处于不公平的劣势，因为我没有在每场比赛中更新阵容。由于这一点，我对我的结果持保留态度，但仍然对该模型在 2021 赛季的表现充满信心。

在未来，我希望建立一个更精细的模拟引擎，通过包括惩罚，得分效果，空网情况和更多的因素，更准确地反映一场 NHL 比赛，但我怀疑这不会大大改变球队赢得比赛的概率，但会花很长时间来获得这些概率。不过，就目前而言，我对自己所做的一切感到满意。

我现在已经计算了每场比赛的获胜概率。我计划根据每支球队的预计阵容更新整个赛季的阵容，并在每场比赛的前一天晚上为每场比赛进行 10，000 次模拟，并根据这些模拟的结果更新概率。在本赛季的某个时候，我计划使用事先知情的岭回归来更新我对每个球员影响的预测，但在我这样做之前，我希望获得本赛季相当大的样本数据。

2021 年综述:现代数据堆栈上的 5 大必读博客

原文：https://towardsdatascience.com/2021-roundup-the-top-5-must-read-blogs-on-the-modern-data-stack-3d2d05fada77?source=collection_archive---------18-----------------------

来自数据世界的年度最佳文章精选列表

克劳迪娅·沃尔夫在 Unsplash 上的照片

对于现代数据堆栈世界，今年有一系列新公司进入该领域，宣布融资，一些战争和许多有趣的数据模因。

我们能把这一年称为“现代数据堆栈”最终成为主流的一年吗？好吧，只有时间能告诉我们……但是这个领域肯定发生了很多事情——新的职位、框架、工具和对未来的预测。

很难赶上所有的事情，尤其是如果你刚刚开始。因此，我创建了一个今年我最喜欢的博客列表，以及一些后续阅读，以帮助您了解今年围绕现代数据堆栈出现的最新想法。

1.我们紫色的人(安娜·菲利波娃)

“紫色人的常见职业道路可能看起来像是在表面上非常不同的角色之间跳来跳去——一些分析、数据科学、数据工程、运营、人员管理(以及更多！).每一次迭代都为手头的问题建立了一种新的不同的同理心。因此，帮助紫色人在职业生涯中成长，与其说是获得一套预先定义的技能，不如说是扩大他们对企业和周围其他人的影响范围。

在未来几年，我们将会看到越来越多紫色人种的例子。你会通过诸如“分析工程师”、“运营分析师”等头衔或业务职能+“分析/分析师”的组合来了解他们，这些头衔现在还不存在，但很快就会存在。”

此处阅读完整博客 。

想了解更多？查看以下后续阅读:

建立强大的数据团队:投资初级人才

2.像管理产品团队一样管理数据团队(Emilie Schario 和 Taylor A. Murphy 博士)

“大多数数据团队并不是为了成功而成立的。多年来，数据团队一直被埋没在 IT 职能中。随着 IT 的运行，这些数据团队处理从他们的系统中获取数据，并以 CSV 的形式呈现给涉众，涉众可以从中施展魔法并得出结论。

…当数据团队作为事后想法出现在公司中时，他们通常会像基于服务的部门一样，抱着“提交一个问题，获得一个非常具体的答案”的心态。受这种模式束缚的数据人员很少花时间主动出击。如果没有有意的空间，他们就不太可能成为检票员。"

点击此处阅读完整博客。

以下是一些关于构建数据团队和角色的后续阅读材料:

Bryan Offutt 的文章数据的下一个重大挑战是组织
Rifat Majumder 的数据产品经理
数据产品角色需要专业化Eric Weber

3。现代数据文化栈的时候到了(由我！)

“在过去的四年里，现代数据堆栈取得了巨大的进步，由于采用了 Snowflake 和 dbt 等工具，它已经成为主流。由于新工具的出现，现代数据堆栈中早在去年就存在的缺口(在元数据管理、数据治理和可观察性等领域)正在迅速得到填补。随着这一领域如此多的创新，我确信在未来几年内，所有数据团队将最终拥有一个接近“完美”的数据堆栈。

*这让我相信，当我们进入 2022 年时，对话需要从需要更好的工具转移到下一个“增量”，这将最终帮助我们创建梦想数据团队—*现代数据文化堆栈 。这些是最佳实践、价值观和文化仪式，将帮助我们不同的数据人(或 dbt 创造的' 【紫色人】 '走到一起，有效地合作。”

在此阅读完整博客。

以下是一些关于建立更好的数据团队的后续阅读材料:

构建现代数据团队作者 Pedram Navid
Brian Armstrong 的《我们在比特币基地如何做决定》

4.现代数据体验(本斯坦西尔)

“…现代数据堆栈不是一个架构图，也不是 Substack 上的一篇免费的思考文章，也不是 Twitter 上的一场战斗。这是一种体验——而且通常不是很好的体验。它试图在明天的董事会前找出增长放缓的原因；当不同的工具和仪表板显示不同的东西时，它让每个人都同意季度收入数字；这是与客户分享产品使用数据，他们告诉你他们的活跃用户列表中不知何故包括了六个月前离开公司的人；这是首席执行官发来的一条愤怒的懈怠信息，他说他们的每日进度报告又坏了。

点击此处阅读完整博客。

以下是一些关于现代数据堆栈实际工作方式的后续阅读:

构建数据平台 ETL 偏差joo Vazao Vasques
构建数据平台 II——水管工的时代已经过去了
为什么数据分析师的角色从未如此艰难彼得·扬达

5.让数据分析师参与进来(Petr Zanda)

“我们不应该雇佣数据分析师来编写 SQL 查询并生成仪表盘和电子表格。我们应该雇用分析师，利用数据来分析和帮助我们理解业务问题。

找到正确的数据并把它们放在一起是必要的，但是还有更多事情要做，分析师们有独特的能力去完成。

除了出色的数据技能，我认识的最优秀的分析师还有一个更重要的特质——不断的好奇心，驱使他们不断探索。”

点击此处阅读完整博客。

以下是一些关于数据分析师在现代公司中的新角色的后续阅读:

本·斯坦西尔的《失踪的分析高管》
“分析师 2.0”会是什么样子？泰勒·布朗洛

✨特别挑选✨

如果你和我一样，利用空闲时间阅读一年的数据，我强烈推荐以下几本书。

数据仓库是新的后端
如何看待数据工作的投资回报率Mikkel dengse
我最近对数据的了解劳里·沃斯
鲍比·皮内罗的《好奇的分析师》
什么是合适的专业化水平？Erik Bernhardsson 为数据团队和其他人

觉得这个内容有帮助？在我的时事通讯《元数据周刊》上，我每周都写关于活动元数据、数据操作、数据文化和我们的学习建设的文章。 在此订阅。

网格搜索交叉验证速度提高 20 倍

原文：https://towardsdatascience.com/20x-times-faster-grid-search-cross-validation-19ef01409b7c?source=collection_archive---------4-----------------------

通过将网格搜索减半，加快交叉验证工作流程

图片由 anncapictures 来自 Pixabay

为了训练稳健的机器学习模型，必须选择正确的机器学习算法和正确的超参数组合。选择最佳参数集的过程称为超参数调整。

人们必须在所有机器学习算法和其超参数的不同组合上训练数据集，以提高性能度量。交叉验证技术可用于在各种机器学习算法上训练数据集，并从中选择最佳算法。

(图片由作者提供)，GridSearchCV 和 HalvingGridSearchCV 的时间约束比较

什么是交叉验证？

交叉验证是一种重采样技术，可用于在有限的数据集上评估和选择机器学习算法。k 折叠交叉验证是一种交叉验证，其中训练数据被分成 k 个折叠，并且(k-1)个折叠用于训练，第 k 个折叠用于模型的验证。

(来源)，k 倍交叉验证

阅读 scikit-learn 交叉验证文档以获得更好的理解。

网格搜索 CV:

网格搜索交叉验证是一种选择最佳机器学习模型的技术，由超参数网格参数化。Scikit-Learn 库附带网格搜索交叉验证实现。

网格搜索 CV 尝试模型的所有参数网格组合，并返回具有最佳性能分数的最佳参数集。这也是一个缺点，因为训练每个参数组合的模型增加了时间复杂度。

**param_grid** = {
"max_depth": [3, 4, 7, 10, 25],
"gamma": [0.5, 1, 5, 10, 25],
"min_child_weight": [1, 3, 5, 10, 25],
"reg_lambda": [5, 10, 50, 100, 300],
"scale_pos_weight": [1, 3, 5, 10, 25]
}# Grid Search CV implementation **xgb_cl = xgb.XGBClassifier(objective="binary:logistic")
grid_cv = GridSearchCV(xgb_cl, param_grid, scoring="roc_auc", n_jobs=-1, cv=3)
grid_cv.fit(X_train, y_train)**# Return set of parameters with the best performance
**grid_cv.best_params_**# Return the performance metric score
**grid_cv.best_score_**

上面的代码片段解释了网格搜索 CV 的用法，cv=3，它在所有的**param_grid** 参数组合上训练**X_train** 数据集。

对于大型数据集，网格搜索 CV 时间复杂度呈指数增长，因此实际上不可行。

可以转移到随机搜索 CV ，其中算法将随机选择参数的组合。随机搜索 CV 的性能在某种程度上等于或小于网格搜索 CV，但是时间复杂度降低，并且对大规模数据集应用网格搜索变得实际可行。

在本文中，我们将讨论一种将网格搜索 CV 减半的新算法，它的性能与网格搜索 CV 相当，但与网格搜索相比，时间复杂度大大降低。

减半网格搜索:

虽然网格搜索 CV 和随机搜索 CV 都在整个数据上训练所有成分(参数网格的组合)，但是减半网格搜索 CV 或减半随机搜索 CV 遵循一种 连续减半方法 。

将网格搜索(HGS) CV 减半的步骤如下:

HGS 将数据子集训练成所有的参数组合。
表现最好的候选人或组合被选中。
在表现最好的候选人身上训练更大的训练数据子集。
重复上述 3 个步骤，直到最佳超参数集保持不变。

使用 HGS，对于每个经过的迭代，参数分量在减少，而训练数据集在增加。由于该算法遵循连续减半的方法，因此与网格搜索 CV 相比，该算法的时间复杂度相对较小。

实施:

Scikit-Learn 库实现了减半网格搜索 CV 算法。下面的代码片段解释了算法的工作和实现。

**param_grid =** ***{
"max_depth": [3, 4, 7, 10, 25],
"gamma": [0.5, 1, 5, 10, 25],
"min_child_weight": [1, 3, 5, 10, 25],
"reg_lambda": [5, 10, 50, 100, 300],
"scale_pos_weight": [1, 3, 5, 10, 25]
}***# Grid Search CV implementation **xgb_cl = xgb.XGBClassifier(objective="binary:logistic")
halving_cv = HalvingGridSearchCV(xgb_cl, param_grid, scoring="roc_auc", n_jobs=-1, min_resources="exhaust", factor=3)**
**halving_cv.fit(X_train, y_train)**# Return set of parameters with the best performance
**halving_cv.best_params_**# Return the performance metric score
**halving_cv.best_score_**

基准时间和性能分数:

现在让我们比较网格搜索 CV 和减半搜索 CV 的性能得分和时间复杂度。

Kaggle的信用卡欺诈数据集用于计算时间数。这是一个分类问题，ROC-AUC 分数被用作比较性能的度量。

只有大约 7.5k 记录用于 cv=3 的训练，大约 3k 记录用于测试目的。

(图片由作者提供)，网格搜索(GS)和减半网格搜索(HGS)交叉验证的基准时间约束和性能 AUC-ROC 得分

观察上面的时间数字，对于具有 3125 个组合的参数网格，网格搜索 CV 花费了 10856 秒(~3 小时)，而将网格搜索 CV 减半花费了 465 秒(~8 分钟)，这大约快了 23 倍。

结论:

在本文中，我们讨论了一种网格搜索 CV 的优化方法，即将网格搜索 CV 减半，然后采用逐次减半的方法来提高时间复杂度。也可以尝试随机搜索 CV 或减半随机搜索 CV，这可以进一步降低时间复杂度，但有时会以性能分数为代价。

最好的部分是减半网格搜索 CV 实现附带 scikit-learn 包以供使用。

参考资料:

[1]等分网格搜索 CV 文档:https://sci kit-learn . org/stable/modules/generated/sk learn . model _ selection。HalvingGridSearchCV.html

感谢您的阅读

使用 Faiss 的 K 均值聚类速度提高了 20 倍

原文：https://towardsdatascience.com/20x-times-faster-k-means-clustering-with-faiss-5e1681fa2654?source=collection_archive---------15-----------------------

Scikit-learn 和 Faiss k-Means 实现之间的基准时间比较

图片由 anncapictures 来自 Pixabay

k-Means 聚类是一种基于质心的无监督聚类方法。该技术将数据点聚类成 k 个聚类或组，每个聚类或组具有几乎相等的数据点分布。每个聚类由其质心表示。

对于一组 n 个数据点，k-means 算法(也称为劳埃德算法)进行优化，以最小化簇内距离并最大化簇间距离。

(图片由作者提供)、簇间和簇内距离

阅读这篇文章，深入了解 k-Means、k-Means++和 k-Medoids 算法。

根据维基百科，劳氏算法的运行时间为**O(nkdi)**，其中:

**n** is the number of instances in the dataset***d***is the dimensionality of the vector
**k** the number of clusters
**i** the number of iterations needed until convergence

Scikit-learn 软件包附带了 k-Means 聚类算法的实现，根据 scikit-learn 文档，实现 k-Means 算法的平均时间复杂度为**O(nki)** 。

在一般实践中，k-Means 聚类算法是最快的聚类算法之一。当涉及到集群时，大规模数据集 scikit-learn 包需要大量时间来实现算法。本文将讨论使用 Faiss 库实现 k-Means，并比较算法训练和预测的基准时间数。

Faiss:

Faiss 是由脸书人工智能研究院开发的开源 Python 包，用于高效的相似性搜索和密集向量的聚类。Fiass 可以为任何大小的数据集实现算法，包括那些无法放入 RAM 的数据集。Faiss 是用 C++编写的，带有完整的 Python 包装器。Faiss 还附带了评估模型性能和进一步调整模型的实现。

Scikit-learn vs Faiss:

Scikit-learn 是一个流行的开源 Python 包，它实现了各种有监督和无监督的机器学习算法。必须需要调整两个模型的超参数来训练特定的模型。k-Means 聚类的超参数包括聚类的数量、重新开始的次数(每次都从其他初始猜测开始)和最大迭代次数。

k-Means 的核心包括搜索最近的邻居，特别是最近的质心，用于训练和预测。Faiss 提出了最近邻搜索算法的优化实现。这就是 Faiss 实现比 scikit-learn 相对更快的地方。Faiss 利用 GPU 支持和 C++实现来加快算法的实现。

使用 Scikit-learn 实现 Faiss:

(作者代码)

基准时间比较:

系统配置:英特尔 I7(第七代)，16GB 内存

下面提到的所有数据集都可以从 Kaggle 下载。

(图片由作者提供)，用于训练 k 均值模型的基准时间比较

观察上面为各种数据集计算的时间数，scikit-learn k-Means 模型的性能优于 Faiss 的实现。对于大规模数据集，Faiss 是明显的赢家。k-Means 用 Faiss 实现几乎比 scikit-learn 的 快 20x 倍 。然而，如果使用 GPU 支持，对于大规模数据集，Faiss 的性能将进一步提高。

结论:

在本文中，我们讨论了使用 Faiss 包实现 k-Means 聚类算法。通过观察上面的基准时间比较，我们可以得出结论，对于大规模数据集，Faiss 的性能远远优于 scikit-learn 实现。与 scikit-learn 相比，k-Means 聚类模型的预测时间针对 Faiss 进行了优化。

阅读下面提到的文章，深入了解聚类算法:

了解 K-Means、K-Means++和 K-Medoids 聚类算法
如何提高 k-Means 聚类算法的可解释性
模糊 C 均值聚类——比 K 均值聚类好吗？

参考资料:

[1] Faiss 文档:https://github.com/facebookresearch/faiss

感谢您的阅读

2021 年每位数据科学家的 21 条建议

原文：https://towardsdatascience.com/21-tips-for-every-data-scientist-for-2021-3d4c28471a6c?source=collection_archive---------15-----------------------

#19.学会如何设定期望值将对你在职业生涯中的“成功”程度产生很大影响。

克拉克·蒂布斯在 Unsplash 上拍摄的照片

在本文中，我将与您分享 21 条建议，这些建议是我从其他数据科学家那里学到的，也是我过去几年的亲身经历。

根据你的职业生涯有多深入，这些建议中的一些肯定会比其他的更能打动你。例如，“花些时间去发现和探索新的库和包”对于刚刚起步的人来说可能并不相关。

说到这里，让我们开始吧！

1.最简单的解决方案往往是最好的解决方案。

成为一名数据科学家并不意味着你必须用机器学习模型来解决每一个问题。如果一个案例中的查询足以完成工作，那就坚持下去。如果线性回归足以完成工作，就不要建立 10 层的神经网络。

一个更简单的解决方案有很多好处，包括更快的实现时间，更少的[技术债务](https://en.wikipedia.org/wiki/Technical_debt#:~:text=Technical%20debt%20(also%20known%20as,approach%20that%20would%20take%20longer.)，以及整体更容易维护。

2.专注地留出时间来定期发现和探索新的库和包。

坚持自己喜欢的东西很容易，但是新工具的出现是有原因的——它们的出现是为了填补现有的空白。通过花时间探索新的库和包，我发现了一些不可思议的工具，它们为我节省了大量时间。这里有几个例子:

图片由 Gradio 拍摄(经许可)

Gradio是一个 Python 包，它允许你用少至三行代码为你的机器学习模型构建和部署一个 web 应用。它的用途与 Streamlit 或 Flask 相同，但我发现它更快、更容易部署模型。
Pandas Profiling 是另一个自动进行探索性数据分析并将其合并成报告的包。当我处理较小的数据集时，我发现这非常有用。最好的部分是它只需要一行代码！
Kedro 是一个开发工作流工具，允许你创建可移植的 ML 管道。它将软件工程的最佳实践应用到您的代码中，使代码具有可重复性、模块化和良好的文档记录。

3.高效并不意味着匆忙完成重要的步骤。

有些步骤根本不能操之过急。特别是，您应该花时间深入了解您试图解决的业务问题和您正在处理的数据。

在深入研究模型之前，您应该能够回答许多问题。你可以在这里查看。

4.可以说，指标比模型本身更重要。

这一点在某种程度上与前一点联系在一起，因为你必须对你试图解决的问题有很好的理解。除了理解问题之外，还要弄清楚你试图优化什么指标，因为归根结底，机器学习是统计和优化的一个时髦词汇。

举个例子，我可以有一个 100%准确的模型，但是如果我试图开发一个异常检测模型，这是没有用的！

5.你的工作将会和你交流的能力一样好。

人们会被他们不理解的事物吓倒，并倾向于回避它们。

您必须能够以非技术人员能够理解的方式交流技术术语和建模技术。如果你花时间建立了一个伟大的模型，你应该多花一点时间来有效地沟通，这样人们才能认可你的努力！

6.学习基本面，尤其是统计学。

数据科学和机器学习本质上是统计学的现代版本。通过先学习统计学，在学习机器学习概念和算法时，你会轻松得多。

我创建了一个完整的 52 周课程，其中前 6 周专门用于统计，你可以在这里查看。****

7.了解你正在解决的问题的参数。

这可以用一个例子来最好地解释。

在我的一个项目中，我不得不开发一个模型来预测一个产品是否需要进行 RMA。最初，我认为我的输入是所有产品*，这使得它几乎像一个异常检测问题。***

只有在了解了业务需求以及如何使用模型之后，我才意识到我的模型的输入是所有被发出 RMA* 的产品(客户发送了一封关于产品问题的电子邮件)。这使得数据更加平衡，节省了我很多时间。***

8.不要低估 SQL 的力量。

SQL 是通用的数据语言——它可以说是任何类型的数据相关职业中最重要的学习技能，无论你是数据科学家、数据工程师、数据分析师还是商业分析师，不胜枚举。

SQL 不仅对于构建管道、提取数据和处理数据非常重要，而且现在您可以使用 SQL 查询来创建机器学习模型。 BigQuery ML 允许你这样做。

9.像团队运动一样对待数据科学。

作为一名数据科学家，最大的好处之一就是你被赋予了很大的自主权。但是，如果你不愿意向他人寻求建议、帮助和反馈，这很容易导致失败。

尽管自主程度很高，但数据科学是一项团队运动。你必须接受来自几个利益相关者的建议和反馈，包括终端用户、领域专家、数据工程师等等。

10.不要浪费你的时间试图记住一切。

有太多的东西需要记住。另外，这是对时间的极大浪费。你最好练习如何用谷歌搜索你的问题，这样你就能得到你需要的答案。

此外，创建一个谷歌表来保存你经常会返回的真正有用的链接。对我来说，我喜欢包含指向备忘单、速成课程和我经常搜索的问题的链接(例如电子邮件的正则表达式代码)。

11.快速部署，快速迭代，不断获得反馈。

重要的是不断地与其他利益相关者交流，让他们了解你的思维过程，你对模型的任何假设，并获得反馈。否则，您可能最终得到一个不能解决当前问题的模型。

就我个人而言，当与利益相关者，尤其是非编码人员分享时，我使用 Gradio 为我的模型的每次迭代创建 web UIs。

我发现 Gradio 非常有用，原因如下:

它允许我交互式地测试模型的不同输入。
它允许我从领域用户和领域专家(他们可能不是编码人员)那里得到反馈
它需要 3 行代码来实现，并且可以通过公共链接轻松分发。

12.全程观察一个项目。您在创建模型的同时，也同样有责任实现模型。

作为一名数据科学家，您可以将自己杂乱无章的 Jupyter 笔记本交给工程团队实施的日子已经一去不复返了。如今，数据科学家更像是数据科学家砍工程师砍产品经理。

13.一切都是推销。

作为一名数据科学家，你总是在推销自己，无论是推销一个新想法，还是推销你已经建立的模型。类似于第 5 点，你必须能够传达来自你承担的每个想法、每个模型和每个项目的商业价值。

14.建立一个可持续的学习时间表。

如果你要学习，就用正确的方法。你可能听说过遗忘曲线。简而言之，如果您希望能够保留新信息，您需要在学习数据科学和实践所学内容方面保持一致。

对自己诚实，制定一个你能坚持的时间表。但是一致性是关键。

15.学习如何使用 Git 和 GitHub。

学习软件工程最佳实践将大有裨益。版本控制尤其是最重要的实践之一，因为每个公司都使用它！

我会查看这两个资源:

Codecademy——学习 Git
学习 Git 分支

16.边做边学。

通过做而不仅仅是学习，你会学到更多的知识和技能。类似于你在学校学了一个新概念后怎么做作业，需要不断地把学到的东西运用到项目中。

这里有一些让你开始的项目想法 。

17.随时了解发生的事情。

与探索新工具和库相关的一点是，跟上数据科学的新发展非常重要，这样您就可以尽可能地保持您的技能和工具是最新的。

我喜欢通过阅读出版物、观看 YouTube 视频和阅读公司博客来做到这一点，比如 Airbnb、优步、谷歌和脸书。

18.学会运用发散和收敛思维。

在数据科学中，这是一种非常有用的技术，这样你就可以确保你已经用尽了所有的选择。发散思维仅仅意味着探索一个给定问题的多个解决方案，而聚合思维意味着将你的选择缩小到一个解决方案。这在执行 EDA 和选择要使用的模型/算法时特别有用。

你可以在这里 了解更多 。

19.开始职业生涯博士。

这是我直到我的朋友乌达拉写下它时才听说的事情。它本质上是你职业生涯的日志或日记。不像简历是给雇主看的，职业文档是给你回顾和反思的。

如果想了解更多，可以查看这里！

20.学会如何设定期望值将对你在职业生涯中的“成功”程度产生很大影响。

少承诺。交付更多。

这对于数据科学家来说尤其重要，因为数据科学家可以根据自己的意愿花尽可能多的时间来创建模型。数据科学家可以使用 auto ML 库构建一个普通的模型，或者构建一个近乎完美的模型，但需要几个月才能完成。

不管你选择什么，重要的是你要管理期望，这样利益相关者才不会失望。特别是，这意味着根据时间表和模型的性能来管理期望。

21.找一个你尊敬的愿意帮助你的导师。

在我的职业生涯中，发生在我身上的最伟大的事情之一就是找到了一位知识渊博的导师，他也非常关心我的成功。

我想说，因为他，我学到了比平时多一倍的东西。

感谢阅读！

我希望你能从中吸取一些教训！我真的相信这些建议在我的职业生涯中对我有很大的帮助，我相信对你也会有同样的帮助。

一如既往，我祝你学习一切顺利:)

不确定接下来该读什么？我为你挑选了另一篇文章:

***

又一个！

特伦斯·申

如果你喜欢这个， 跟我上媒 了解更多
对通敌感兴趣？让我们连线上LinkedIn
报名我的邮箱列表 这里！***

2022 年成为更好的数据科学家的 22 个习惯

原文：https://towardsdatascience.com/22-habits-to-become-a-better-data-scientist-in-2022-25b5747e2b57?source=collection_archive---------1-----------------------

我从成功的数据科学家那里学到了这 22 个习惯。利用他们成为他们中的一员。

Marc-Olivier Jodoin 在 Unsplash 上拍摄的照片

如果你想让 2022 年成为你的数据科学职业生涯中令人敬畏的一年，请遵循一些成功的数据科学家拥有的习惯。

这 22 个习惯将帮助你在 2022 年成为更好的数据科学家。数据科学涵盖不同的领域，所以我列出了培养你的硬技能和软技能的习惯。

如果你愿意，你可以选择 1 个、10 个或者全部 22 个，但是很可能你已经有了本文中列出的一些好习惯，所以把注意力集中在那些对你来说是新的习惯上。

1.在数据科学社区中协作

你知道学东西最快的方法是什么吗？协作！作为一名数据科学家，你需要成为社区的一员，才能更快地成长。

如果你是这个领域的新手，你可以在数据科学社区问很多问题来保持学习。如果你已经有一些经验，你可以参加 Kaggle 比赛，回答关于堆栈溢出的问题，并在博客帖子或视频教程中分享知识。

不管你在数据科学方面有什么经验，都可以考虑加入一个社区来给予和接受他人的帮助。

2.设定编码标准

作为一名数据科学家，你还需要向成功的程序员学习良好的习惯，其中之一就是制定编码标准。

在为一家公司工作时，你需要保持定义良好的标准编码风格。这为许多人编写的代码提供了统一的外观，提高了可读性，降低了复杂性，并有助于轻松检测错误。

即使你不属于一个大组织，你也应该这样做。这将帮助你适应别人已经遵循的标准、惯例和规则。

3.创建路线图来塑造您的项目

你是否曾经开始一个项目，完成一项任务，然后对下一步感到不确定？

我曾经有这个问题，直到我创建了一个路线图，显示了项目的每个阶段，以及所有涉及到的事情和人员。这有助于您了解项目的全貌，因此您可以轻松识别项目的目标以及每个阶段的输入和输出。

当清楚数据和脚本来自哪里时，修复错误变得更加容易。

4.了解业务问题

不管你在编码或创建模型方面有多熟练，如果你不能理解你所在的业务，你就不会成为一名成功的数据科学家。

如果你不帮助你工作的公司实现目标，没有人会重视你的工作——不管你的模型表现得有多好。做一些研究，更多地了解你工作的公司，他们所在的行业，花一些时间思考像你这样的数据科学家如何帮助实现公司的一些目标。

向你的老板和同事提问也很有帮助。他们可以帮助你更好地理解你在公司的角色。

5.保持最新状态

每年都有新技术出现，工具过时，代码被废弃。这就是为什么你应该通过阅读博客、研究论文和书籍来关注这个领域的新东西。

了解最新信息将有助于您利用数据科学的最新进展。因此，你会比其他人领先一步，在大多数情况下，你会在项目中获得最佳表现。

虚心学习如何使用新工具和适应变化是一种习惯，这将有助于你的职业生涯(这导致我们的下一个习惯)

6.接受改变

事情每天都在变化，但我们不愿意适应某些特定的情况。

我说不清 Python 3 发布后有多少人(没有任何特殊原因)一直在用 Python 2。在花了很多天学习 matplotlib 之后，我不愿意学习 seaborn，出于同样的原因，我也不愿意用熊猫代替 Plotly。

迟早你会意识到工具应该提高你的生产力。如果有什么东西能让你作为数据科学家的生活变得更容易，那么它就值得学习。

7.避免分心

没有焦点是不可能解决问题的。

我知道你有很多电子邮件要回复，有很多信息要回复，有很多计划要制定，但是它们会分散你完成任务的注意力，结果，你作为数据科学家的表现会下降。

多任务处理很诱人，但是，相信我，专注于一件事情的好处是惊人的！我可以说，我是在六个多月没有电话的日子里艰难地学会这一点的。

但是你不需要离开你的 iPhone 来避免分心。关闭手机和笔记本电脑的通知功能就足够了。

8.保持你的代码简单

少并不总是多(特别是在编码中)。

减少代码行可能无法帮助其他人轻松理解您的脚本应该做什么。相比之下，仅仅为了减少代码而减少代码行会使理解变得更加复杂，即使对你来说也是如此！

尽量让复杂的代码变得简单。代码越简单，越容易理解。我是在制作视频教程、指南和创建自己的课程后学会这些的。这有助于你在阅读自己的代码时设身处地地为他人着想。

分享你的代码！如果别人不能理解你的剧本，可能还有改进的空间。

9.记录您的代码

你有没有打开旧剧本，想“我到底在想什么？”

如果你很难理解自己的代码，想象一下别人会如何努力理解你的脚本。永远记住这句话。

代码被阅读的次数比被编写的次数多

—吉多·范·罗苏姆

这就是为什么记录你的代码是重要的。我认识的所有优秀的数据科学家都有评论和记录他们代码的习惯。注释有助于更好地理解代码、其目的和设计。另一方面，记录代码向用户描述了它的用途和功能。

如果您使用 Python，请查看本指南以了解如何正确记录 Python 代码。

10–12.倾听，专注于解决方案，谨慎选词(有效的沟通习惯)

根据福布斯的报道，这是高效沟通者的三个习惯。为什么这很重要？作为一名数据科学家，你需要提高你的沟通技巧。

请记住，数据科学不仅要创建最佳模型，还要将您的发现传达给非数据科学家。这将让其他人知道你清楚地了解公司的目标，并且你正在应用你作为数据科学家所拥有的知识来帮助实现这些目标。

13.问开放式问题

问问题很好，但你知道什么更好吗？问开放式的问题。

以“为什么、哪里、什么时候、谁、什么、哪个”开头的问题会帮助你更好地理解一个新话题。这也将有助于你被视为具有良好沟通技巧的数据科学家，这在你的职业生涯中很重要。

当然，在某些情况下，简单的是-否问题更合适，但是尽可能问一些开放式的问题来丰富对话。

14–15.注意你的姿势，多喝水(健康习惯)

朝九晚五坐在电脑前对你的健康没有好处。我不是要你放弃宝贵的数据科学工作，而是要你在办公室养成一些健康的习惯。

一些简单的事情，比如注意你的姿势和多喝水，会帮助你保持健康，这是在工作中保持最佳表现的关键。这是你应该做的最起码的事情，但是像花时间在外面，去散步，早起是其他健康的日常习惯，你可以从今天开始。

听从你的身体，尽你所能达到最佳状态。

16.每周学习一件新东西

我们已经提到了数据科学领域是如何随着时间的推移而发展的。这就是为什么你应该考虑每周学习一些新的东西。一年结束时，你会惊讶于自己每周学到的东西。

保持学习新事物的好奇心，你将在数据科学职业生涯中取得进步。为了更好地了解这一点，请查看我的 52 周课程，以便在 2022 年成为一名数据科学家。

或许你已经知道了这里列出的大部分内容，所以以此为例，当你想学习新的东西时，你可以创建自己的路线图。

17.整理你的桌子和电脑

如果你想提高工作效率和优化工作流程，确保你的办公桌和电脑上的所有东西都放在正确的位置。

我不知道有多少次我停止了编码，因为我找不到我在项目中使用的数据集，或者忘记了用 Python 进行可视化的正确语法。我可以通过给文件和文件夹起适当的名字并使用 Python 数据科学备忘单来解决这个问题(顺便说一下，你可以在这里下载)。

你的桌子也是一样。不要让你的笔记本充电器阻止你完成你的数据科学项目。用抽屉来存放你可能突然需要的东西，只把你经常用的东西放在桌子上。

18.阅读研究论文

作为一个过去写过几篇研究论文的人，我可以说阅读硕士和哲学博士的论文有助于任何人跟上最新的趋势。

外面有很多信息，但在某些情况下，你需要格外小心你从中提取信息的来源。也就是说，研究论文中提供的见解和信息是高度可靠的。

每周或每月至少阅读一篇与你感兴趣的主题相关的研究论文，以促进你的职业发展。

19.相信你自己

数据科学项目倾向于归属，所以在完成一项任务后给自己加分。

不要等待你的同事或老板对你所做的一切给予肯定。为你在数据科学职业生涯中的每一个小成就感到自豪。

20.定期休息

作为一名数据科学家，您可能会花费数小时来收集、清理或转换数据。只要你有规律地休息，花很多时间在工作上并没有错。

从短期来看，过度工作可能会导致愚蠢的编码错误，从长远来看，可能会导致健康问题。这就是为什么你应该不时地休息一下。

当你重新开始工作时，这会给你一个全新的视角。

21.问问你自己你所做的是否值得

作为一名数据科学家(以及在生活中)，保持成长的一个好习惯是就你每天做的事情问自己一些问题。

一些数据科学家多年来一直扮演着同样的角色。这创造了一个你并没有意识到的舒适区，直到你问自己，“这值得我花时间吗？”你可以更具体地列出你工作中的日常任务。

如果你多次回答“是”，那么你可能已经到达了你的职位的平台期，或者正在做与你的职业不再相关的任务，所以考虑在不同的部门或公司找一份新工作。

22.不要拘泥于一种编程语言

Python 是我最喜欢的编程语言，但是你知道吗？我不想被这种语言困住。

你永远不知道未来会发生什么。现在 Python 在数据科学中被广泛使用，但它可能随时会失去魅力。这就是为什么关注新趋势，至少让自己熟悉它们是很重要的。

学习多种编程语言不需要上强化班。而是在这里那里尝试新的东西，分析什么方便你认真学习，以便在职业生涯中进一步发展。

https://frankandrade.ck.page/bd063ff2d3

如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑报名成为一名媒体成员。每月 5 美元，让您可以无限制地访问数以千计的 Python 指南和数据科学文章。如果你用我的链接注册，我会赚一小笔佣金，不需要你额外付费。

**https://frank-andrade.medium.com/membership **

2022 年的 22 个新数据科学面试问题

原文：https://towardsdatascience.com/22-new-data-science-interview-questions-for-2022-964c687f735b?source=collection_archive---------9-----------------------

来自谷歌、脸书和网飞等顶级科技公司的问题

莫里茨·克纳林格在 Unsplash 上的照片

介绍

请务必点击 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！

在本文中，我将与您分享 22 个新的数据科学面试问题，这些问题是在顶级科技公司中提出的，如谷歌、网飞、脸书和亚马逊。

不出所料，你会注意到大多数问题都与统计学、机器学习和案例研究有关。

就这样，我希望你喜欢它，节日快乐！:)

1.在什么情况下你会考虑中位数的平均值？

当分布或多或少对称时，平均值比中值更好计算，因为它使用所有数据点，所以在*完整性的意义上更好。*同样，在不存在异常值的情况下，平均值也是比中位数更好的表示方法。

2.平均值的标准误差是多少？

标准误差的方程式

平均值的标准误差(SE)就是样本平均值的标准偏差。它是对样本平均值与总体平均值之间差异的度量。

3.一部电梯四个人，一栋楼四层。每个人在不同楼层下车的概率是多少？

如果四个人都是底楼出发，还有三层，那么通过鸽洞原理，每个人在不同楼层下车的概率是 0，除非有一个人在底楼下车(不上)。

那样的话，概率是 4！/(4⁴).一般来说，这个问题可以认为是从 n=4 的多项式分布中抽取计数，离散分布参数= (1/4，1/4，1/4，1/4)。设 x0、x1、x2、x3 分别为 0 至 3 层的下车人数。且 x_i >=0，x_i 之和= 4(因为有 4 个人)。所以 Pr(x) = (n！/(x0！x1！x2！x3！)p0^{x0 … p3}x3.代入适当的值，你得到 4！/(4⁴).

请务必点击 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！

4A。我有一副牌，随便拿一张。你猜对的概率是多少？

因为一副牌里有 52 张牌，所以赔率是 1/52。

4B。继续:那我给你两个问题，你只能问一个:a——这张牌是红色的吗 b——这张牌是 10 张黑桃吗你会问哪一张，为什么？

A.A 的赔率是，但黑桃 10 的赔率是 1.52。

6.解释一个非正态的概率分布以及如何应用它。

另一种分布是以λ为参数的泊松分布，它代表到达率。当您想要对给定时间范围内“到达”的单位数量的概率进行建模时，可以使用这种分布。

例如，如果您希望对工作日 9-5 点进入洗车场的汽车数量进行建模，以便估计洗车场在一个工作周内的平均收入，则可以使用泊松分布。

7.让不公平的硬币变得公平。

不公平硬币是指正面对反面的概率不是 50-50 的硬币。例如，它可能是 70-30 的赔率。在这种情况下，为了让硬币公平，你可以抛硬币两次，并在两个选项中的一个上下注:硬币是正面朝上然后反面朝上还是反面朝上然后正面朝上。如果两次抛硬币都是正面或反面，那么你要重新抛硬币。

8.如果两个预测因子高度相关，对逻辑回归中的系数有什么影响？

当两个预测值高度相关时，这被称为多重共线性。当多重共线性存在时，会产生多种后果:

第一，如果其中一个预测值只发生一点点变化，回归函数的系数将会非常敏感，换句话说，它非常不稳定。
第二，系数的方差将被夸大，使得难以检测统计显著性，这意味着 F 统计量可能是显著的，但所有单个 t 统计量都不是显著的。

9.系数的置信区间是多少？

系数置信区间为我们提供了一个范围，每个回归系数的置信区间为 100*(1-a)%。

10.线性回归的误差假设是什么？

线性回归中的误差，也称为残差，假设如下:

线性假设:误差期望值的平均值为零。
恒定方差假设:残差具有恒定方差
独立性假设:残差相互独立
最后，残差是正态分布的。

请务必点击 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！

11.对于样本大小 n，误差幅度为 3。我们还需要多少样本才能使误差幅度达到 0.3？

获得误差幅度(MOE)的公式如上所示。可以重写该等式来求解样本大小 n:

Sub MOE = 0.3 以及相应的 z 得分和标准偏差，以获得所需的样本大小，从而实现 0.3 的 MOE。

12.实验结果:一组中有 5%的人点击次数更多。这样的结果好吗？

无法回答此问题，因为没有提供足够的信息。除了结果之外，结果还取决于显著性水平，这是在进行实验之前确定的。

13.你注意到点击脸书活动搜索结果的用户数量每周增加 10%。你会如何调查？你怎么决定这是好事还是坏事？

因为这个问题可以用很多方法来回答，而且坦率地说可能要花很长时间来回答，所以我将解释我认为要触及的两个要点。但即使在触及这两点之前，在实际的面试中，你也应该调查并问更多的问题，试图从面试官那里获得更多的信息。例如，“这种增长持续了多长时间？”或者“在此之前有什么重大事件发生吗？”

一旦你提出了你的问题，你应该有一个系统的方法来调查这 10%的增长。在咨询中，有一种叫做互斥集体穷举(MECE)框架的东西，你可以用它来组织你的想法，彻底解决问题。

第二件要考虑的事情是定义什么是“好事”和“坏事”。“好”是指更多的参与度还是其他？在给出最终答案之前，请确保您对这些进行了定义。

查看本文 查看示例答案。

14.事件团队希望提升事件的排名，以便它们在搜索中显示得更靠前。你如何判断这是不是一个好主意？

您可以执行 A/B 测试，以查看该变量是否会导致指定主要指标的显著差异。在这种情况下，主要指标可能是点击事件的用户数量*。*

请务必点击 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！

15.如何用 Python 写一个 t-test？

使用 scipy 库，您可以编写以下代码:

import pandas as pd
import scipy.stats as statsstats.ttest_ind(df['result'][df['category'] == 'control'],
                df['result'][df['category'] == 'treatment'])

同样，如果您想从头开始编写 t-test，请参见这里的。

16.给你一天的大样本量和显著的测试结果，你会结束实验吗？

这最终取决于在构建实验时收集的样本大小是否等于或大于预定的所需样本大小。如果它不是很大，那么早点结束这个实验会导致声称有意义，而实际上没有任何真正的意义。这就是所谓的重复显著性检验错误。

17.解释随机森林，讨论其利弊

作者创建的图像

本质上，随机森林算法是一种集成学习算法，它通过使用多个决策树而不是一个决策树来进行预测。通过这样做，它能够基于“多数获胜”系统做出决策，将每棵决策树视为一个独立的投票者。

这样做的好处是，它比决策树更准确，因为它不容易出现一棵树本身会出现的错误。因此，它也使它更少偏差，并减少模型的可变性。

这种模型的缺点是，它不能直观地理解模型如何得到输出，使它看起来像一个“黑盒”模型。

18.为什么 L1 可以把重量缩小到 0，而 L2 不行？

由于 L2 最小化了重量的平方，它更关心减少大重量而不是小重量。这意味着它很少专注于将小权重推到零。

另一方面，L1 在减少大的或小的权重之间没有偏好，因为它最小化了权重绝对值的总和。所以不管是把一个权重从 1000 往下推 999 还是 1 往下推 0 都是一样的。

19.装袋和助推有什么区别？

装袋是用自举样本对同一模型进行多次迭代训练的过程。

作者创建的图像

Boosting 是 bagging 的更高级版本，其中每个模型都是按顺序构建的，迭代前一个模型，并从以前的错误中学习。

作者创建的图像

20.AUC 是用来做什么的？

AUC 或曲线下面积是一种评估指标，用于评估分类器区分不同类别的能力，越高越好。

21.你会如何向一个非技术人员解释 p 值？

本质上，p 值告诉我们一个给定结果可能偶然发生的概率。例如，p 值为 0.05 相当于说“我们在 5%的时间里会偶然看到这种情况”。

22.与对称的正态钟形相比，右偏斜和左偏斜分布的平均值和中值在哪里？

对于对称的正态分布，平均值等于中位数。

对于右偏斜，平均值大于中值。

对于左偏斜，平均值小于中值。

感谢阅读！

务必 订阅此处 千万不要错过另一篇关于数据科学指南、诀窍和技巧、生活经验等的文章！

不确定接下来要读什么？我为你挑选了另一篇文章:

还有一个:

-特伦斯·申

如果您喜欢这个， 订阅我的媒介 获取独家内容！
同样，你也可以 关注我上媒
报名我的个人简讯
跟我上LinkedIn其他内容

关于 2022 年软件发展趋势的 22 个预测

原文：https://towardsdatascience.com/22-predictions-about-the-software-development-trends-in-2022-fcc82c263788?source=collection_archive---------0-----------------------

云、容器、编程、数据库、人工智能、机器学习、DevOps、软件架构、软件开发、Web、App、批处理、流式、低代码、无代码、API

照片由 Unsplash 上的 h heyerlein 拍摄

再过几天，我们就要告别 2021 年，迎来新的一年: 2022 。在灾难性的疫情袭击 2020 年之后，2021 年是人类恢复和反击的一年。由于技术进步，各国能够大规模接种疫苗。对于软件开发和 IT 行业来说，2021 年是不出所料的重要一年。

2022 年，冠状病毒突变和高科技疫苗研究之间将出现一场进化军备竞赛。对于软件开发行业来说，当前的数字化趋势将随着许多变化、创新和现有技术的新用途而继续。

预测未来是一项具有挑战性的任务。像过去两年一样，我在这里预测 2022 年软件发展趋势中最重要的趋势。

1.集中式基础架构:云优先是新的标准

就像西方世界中取代当地商店的少数巨型大型超市一样，公共云将继续取代区域数据中心。在未来几年，公共云也将成为企业、政府和创业公司的首选基础设施。公共云现在是数字创新的温床，这一趋势将在 2022 年继续。公共云在安全民主化、区块链以及以可访问的方式为客户带来许多创新方面也发挥着重要作用。

Gartner 预测 2022 年公共云收入将增长 16%:

https://www.gartner.com/en/newsroom/press-releases/2021-11-10-gartner-says-cloud-will-be-the-centerpiece-of-new-digital-experiences

所以，如果你是一家数字公司的决策者，是时候认真对待云了。如果你是一名工程师，可以通过创建免费账户或参加 MOOC 课程来开始学习云计算。

2.分散式基础设施:边缘云

与我们希望将存储、计算能力和 AI/ML 放在一个中心位置(可用性区域)的公共云不同，边缘计算将存储、计算能力和 AI/ML 带到了客户附近。低延迟场景(游戏)、较差的网络带宽(离岸站点)、无网络、监管要求、实时用例(联网车辆)、智能和强大的设备(物联网)是需要边缘计算的场景。

随着 5G、Web 3.0 和其他技术创新的兴起，边缘计算将在 2022 年及以后继续被广泛采用。此外，零售商将在未来几年大规模采用边缘计算。

像 AWS、Azure 和 GCP 这样的公共云提供商也通过提供许多边缘计算服务而处于领先地位: AWS 雪族 ， AWS 物联网 Greengrass ，Azure Stack Edge，Azure Edge Zone， Google 分布式云

一项新的举措， 状态的边缘 ，是为了规范边缘计算。

3.公共云:多云将获得更多动力

采用公共云的一个主要问题是供应商锁定。一旦您将基础架构、存储和计算转移到公共云提供商，您就被供应商锁定了。许多企业试图明智地使用多个供应商来避免供应商锁定。不幸的是，它只锁定了有多个供应商的企业，而不是一个供应商。如果您无法在另一个公共云中使用一个公共云(例如，CosmosDB、AWS S3、BigTable ),将始终存在供应商锁定。

幸运的是，提供与广泛的公共云服务 API 兼容的服务是一个相反的趋势。 MinIO (与 S3 兼容) Aviatrix (云原生网络) Volterra (分布式云服务) LightOS (云原生存储)是致力于提供云中立性的众多服务中的一部分。

此外，谷歌正在努力将他们的流行服务(大查询)引入其他公共云(AWS，Azure)。

4.容器:Kubernetes 将进入后台，而 Docker 将反弹

集装箱化是现代信息产业的关键技术。Kubernetes 在普及和民主化集装箱化方面发挥了巨大作用。由于巨大的努力、精心的设计和实施，Kubernetes 现在是一项坚如磐石的技术。它扮演的角色与 Linux 在服务器领域扮演的角色相同。由于其高瞻远瞩的设计(操作、体积)，Kubernetes 可以在许多用例中使用，而不会引入突破性的变化。

随着 Kubernetes 的成熟，未来几年 Kubernetes 的吸引力将会减少。不要误解我，Kubernetes 将是现代软件开发的引擎。但是我们将会看到更多关于 Kubernetes 的新的采用和使用案例，而 Kubernetes 本身由于其成熟性将会缓慢移动。

像 Kubernetes 一样，码头工人也在集装箱化中发挥了举足轻重的作用。不幸的是，该公司在其鼎盛时期努力将 Docker 货币化。Docker 最近宣布了从 2022 年开始的新订阅模式:

https://docs.docker.com/subscription/

其定价模式实惠。考虑到它对现代云原生开发的贡献，我祝愿 Docker 的新订阅模式取得成功。

5.网络安全:每个人都会认真对待安全问题

对于初创公司或中型公司来说，网络安全就像房间里的大象。他们可以看到网络安全的需求，但由于缺乏资源而无法正确实施。只有大型企业才能负担得起专门的安全团队。

公共云供应商最显著的优势之一是他们实现了网络安全的民主化。现在，利用公共云服务，初创公司或中型公司可以轻松实现高度安全的应用。

公共云安全的一个缺点是，如果它受到损害，那么数百万公司将受到影响。2021 年，公共云存在一些引人注目的安全漏洞:

https://www.theverge.com/2021/8/27/22644161/microsoft-azure-database-vulnerabilty-chaosdb

2022 年，公有云和 Linux 在安全方面会更加努力。

关于安全性的另一个问题是当前的开源开发模型。一个开发人员经常在业余时间开发一个重要的核心模块/库。不幸的是，如果这个模块/库被破坏，那么世界上几乎所有的公司都会受到影响。log4j 漏洞就是这样一个备受关注的问题，它将影响全球近一半的 IT 公司:

https://www.computerworld.com/article/3645709/why-are-your-it-people-so-miserable-log4j2itis.html

大公司是时候重新思考当前的开源模式了，在这种模式下，开发者在没有任何经济利益和支持的情况下维护一个核心软件。

6.区块链:终于，生命开始于加密货币之外

区块链经常与加密货币联系在一起。每次出现关于加密货币的伪造，区块链技术都会受到批评。**区块链(分布式账本)**是 21 世纪最具颠覆性的技术之一。加密货币是其最知名的用例，但区块链不仅仅是加密货币。区块链可以改变我们行业的很多领域，影响我们的日常生活。

2021 年，我们已经看到了区块链的一个新的非常受欢迎的用例:NFT(不可替代的令牌)。目前，NFT 主要用于数字艺术。2022 年，我们将看到 NFT 将用于其他用例。

人们现在开始认真对待区块链，2022 年区块链技术会有一笔巨大的支出:

https://www.investopedia.com/news/blockchain-solutions-grow-75-through-2022-idc/

区块链经常被诟病大量消耗能源。许多区块链公司现在正计划从高能耗的“工作证明”模式转向节能的“利益证明”模式。Etherium 是一种流行且广泛使用的区块链，将于 2022 年转向绿色“利益证明”模式:

https://www.coindesk.com/layer2/2021/12/29/how-ethereum-will-be-transformed-in-2022/

7.机器学习:自动化和无代码人工智能将使机器学习民主化

机器学习(ML)是另一项近年来获得巨大成功和采用的颠覆性技术。然而，根据其需求，机器学习专家大量短缺。此外，许多公司希望以有限的方式采用机器学习，而不雇佣全职、昂贵的机器学习专家。

AutoML (自动机器学习)是在没有机器学习专家的情况下，以有限的方式自动使用机器学习的新举措。对于大多数用例，你需要一个机器学习专家。但是对于某些用例，你可以使用 AutoML 来增强机器学习专家，或者在没有任何机器学习专家的情况下使用 AutoML。在某种意义上，它类似于低代码/无代码计划。AutoML 在 2021 年获得了巨大的牵引力。

在 2022 年，我们将看到 AutoML 的更多采用和创新，因为 AutoML 有着广阔的市场前景:

https://www.prnewswire.com/news-releases/automl-market-revenue-to-surpass-14-830-8-million-by-2030--says-ps-intelligence-301437697.html

AutoML 是更大的无代码人工智能趋势的一个子集。2022 年，无代码人工智能也将迎来普及和采用的高潮。

8.人工智能:狭义人工智能将被广泛采用

与机器学习一样，深度学习(AI)是另一项颠覆性技术，在过去十年中获得了大量采用和快速增长。在 2022 年及以后，人工智能将继续看到更多的采用、资助和创新。

人工智能的圣杯之一是寻找“一般智能”，人工智能可以像人类一样聪明(或更聪明)。我们离实现普遍智能还很远。但人工智能将更多地用于“N arrow 人工智能”中，人工智能代理将在特定(狭窄)领域协助/增强人类。2022 年，我们将在许多非关键用例(如呼叫中心、IT) 中看到更多狭义人工智能的采用，其中人工智能代理将使用狭义人工智能来协助人类。

9.深度学习库:张量流将继续统治

有许多人工智能库，但有两个脱颖而出:谷歌的 TensorFlow 和脸书的 PyTorch。

TensorFlow 在 2.0 版本中进行了自我改进，引入了动态图形、python 友好性和许多其他变化。它还提供 Tensorflow.js 在浏览器中使用 AI 库。Tensorflow 的另一项创新是 Tensorflow Lite ，它提供在移动和网络上部署 Tensorflow。Tensorflow 还发布了 Tensorflow Extended (TFX)，这是一个用于部署生产 ML 管道的端到端平台。

PyTorch 是另一个占主导地位的 AI 库，它将动态图和 Python 作为一等公民引入。它对开发人员也更友好。它还发布了 PyTorch Mobile 来在 Android/iOS 设备上使用 PyTorch。它通过 PyTorch Profiler 调试大规模人工智能模型，为开发者提供了更多的友好性。

TensorFlow 仍然是最受欢迎的 AI 库:

来源:堆栈溢出开发者调查，2021 年

2022 年，Tensorflow 将继续成为占主导地位的人工智能库，因为它具有更好的可视化和大规模采用。

10.数据库:多模式和多用途数据库正在兴起

在过去几年中，我们看到了使用适合特定用例的特殊数据库的趋势:

RDBMS 用于结构化数据的事务用例
宽列数据库用于低延迟的分布式数据库
分布式缓存的键值存储
图形数据库用于极端关系数据
文档数据库用于半结构化数据的交易用例
搜索引擎用于全文和高级搜索(例如基于位置的搜索)。
分布式 SQL 用于具有事务保证的低延迟分布式数据库。
用于数据仓库和数据分析的 OLAP 数据库

你可以看看我的帖子，找到适合你用例的数据库:

这种方法的一个缺点是，我们经常需要一个应用程序有多个数据库。有一个新的趋势，每个数据库将提供不止一个模型，并服务于不止一个用例。 PostgreSQL (多模型) Azure CosmosDB (多模型多用途) SingleStore (OLAP 和 OLTP)就是这些数据库的前身。同样在 2022 年，我们将看到提供多模型和多用途的其他数据库。

11.数据密集型计算:Spark vs .公共云服务

Apache Spark 几乎已经取代 Hadoop 生态系统成为默认的数据密集型计算框架。Spark 还使用相同的 API 提供接近实时的流处理。

近年来， Apache Beam 获得了很大的关注，因为它提供了一个统一的编程模型来定义和执行数据处理管道:批处理和流。Google 的云数据流是一个强大的服务，实现了 Apache Beam。另外，Azure 和 AWS 提供批处理服务。

如果你想成为云不可知论者，你应该使用 Spark 或者云数据流(GCP)。

12.实时流媒体:这是 Flink 对公共云服务

虽然近实时流足以满足 90%的使用案例，但在一些使用案例(欺诈检测、异常检测、基于规则的警报、实时数据的即席分析)中，您将需要实时流。

在实时流媒体方面，Apache Flink 无疑是市场的领导者。它还支持 Apache Beam API，并提供厂商中立的解决方案来处理实时流数据。

如果你想避免供应商锁定，你应该在公共云特定技术上使用 Flink。此外，Flink 比公共云供应商提供的类似服务更强大。

13.现代智能可观测性

几年前，可观察性只对大型企业至关重要。然而，随着云原生开发和微服务架构的快速兴起，可观测性对于现代软件开发至关重要。除了传统的可观察性(日志记录、监控、跟踪)，我们还需要 Kubernetes 集群的遥测和拓扑数据。此外，我们将看到使用人工智能和时间序列数据库来开发智能可观测性平台的趋势。智能的云原生可观测性将在 2022 年及以后继续增长。

14.快速应用程序开发:低代码/无代码(LCNC)将继续蓬勃发展

低代码/无代码(LCNC)计划旨在降低在没有开发人员(或少量开发人员)的情况下开发 Web/移动应用程序的障碍。在未来几年，我们仍然需要开发人员来开发应用程序。但是也有许多低代码/无代码框架/工具可以显著加快应用程序开发的用例。

同样在 2022 年，我们将看到越来越多的 LCNC 用例:

web/移动应用程序开发
网站和登录页面
使用对话流的智能聊天机器人
电子商务
机器学习
人工智能(视频、音频、图像)
工作流程管理
使用 RPA 的流程自动化

15.软件架构:企业的微服务和微前端

我们目前有三个后端应用程序开发的选项:(模块化)整体、微服务和无服务器。它们都有自己的优点和缺点，在特定的用例中表现出色，而在其他用例中则表现不佳。微服务支持应用程序开发，其中多个团队在特定的应用程序上工作。此外，微服务非常适合云原生开发，因为较高的运营成本可以卸载到代码复杂性较低的云上。因此，对于企业而言，微服务将是 2022 年的主流架构。

如果你想了解设计微服务架构的最佳实践，你可以阅读我的博客:

我们目前有两种前端应用程序开发的选择:整体式和微型前端。我们经常低估前端应用程序的复杂性，因为大多数架构师来自后端开发。但是前端独石和后端独石一样糟糕。因此，对于企业前端开发，微前端将是 2022 年的首选架构。好消息是所有流行的 JavaScript 前端框架都支持微前端。

16.软件开发:人工智能将协助开发者和质量保证

我认为人工智能是人类的助手或助手:人工智能可以帮助单调乏味、可预测、重复、困难的任务，人类可以专注于更发人深省的智能任务。在软件开发中，我们还必须做许多枯燥、可预测和重复的任务。AI 可以使用 GPT-3 和其他 NLP 库来自动化这些任务。人工智能已经被用于自动化测试。

几个人工智能驱动的助手也可以自动为开发者生成源代码: Tabnine，GitHub Copilot，codata。尽管它们处于协助软件开发的早期阶段，还不太成熟，但我预计这些人工智能驱动的代码助手将在 2022 年成熟，这样我们就可以更快地开发和交付。

17.编程(主流):Python 将引领潮流

近年来，我们经历了作为通用编程语言的 Python 的快速崛起。在流行的编程语言排名网站 TIOBE 中，最后 Python 独占鳌头，是目前排名第一的编程语言:

来源: TIOBE

对于吉多·范·罗苏姆和其他 Python 语言设计者来说，开发一种编程语言作为业余爱好项目来降低编程门槛是一个了不起的成就。Python 是简洁的、解释的、动态的、简洁的、简单的、强大的。但是 Python 的 USP 在于它的简单性和较低的准入门槛。Python 是数据科学和数据工程领域的头号编程语言。但在许多其他领域，它是排名第二或第三的编程语言。

2022 年，Python 将继续占据主导地位，因为许多新的开发人员将加入，他们可能会从 Python 开始。在选择编程语言之前，还是值得看一看这个领域。以下是我对编程语言的建议:

Web 开发 : JavaScript、TypeScript
后端开发 : Java，Golang，JavaScript，TypeScript
安卓开发:科特林
iOS 开发 : Swift
系统编程 : C、C++、Rust、Golang
数据科学/数据工程 : Python

然而，如果你是一个学习新编程语言的新开发人员，你可以从 Python 开始。

18.编程(企业):Java 反击

很长一段时间，Java 是无可争议的头号编程语言。它是解释型的、中等复杂程度的、多线程的、垃圾收集的、功能强大的编程语言。此外，JVM 是久经考验的、强大的、成熟的，并且是业界最好的进程虚拟机之一。Java 非常适合大型、单一的企业应用程序。

不幸的是，随着微服务和无服务器的兴起，Java 是不利的，因为 JVM 似乎太大(内存占用高)和慢(启动时间慢)。另外，在现代基于容器的开发中，容器的资源是有限的。因此，人们开始在云原生开发中使用像 Node.js、Golang 这样敏捷、小巧、更快的语言。

最后，Java 社区开始提供带有 GraalVM 的现代版 Java。它是一个 JDK 发行版，提供 AOT 编译、多语言编程。此外，它直接编译成本机代码，非常适合云原生开发**(低内存占用，首次启动时间)**。此外，Java 17 最终引入了许多现代特性(例如，模式匹配)，这使得 Java 对开发人员很有吸引力。

凭借其严格和无与伦比的向后兼容性，GraalVM，最新变化，Java 将成为 2022 年企业软件开发的头号编程语言。

19.客户端 Web 框架:企业的反应和角度

在现代 Web 应用程序开发中，基于 JavaScript/TypeScript 的框架规则和趋势将在 2022 年继续。有许多基于 JavaScript/TypeScript 的 web 框架，但是有两个框架脱颖而出。其中一个是来自脸书的反应。另一个是谷歌的 Angular (Angular 2+)。React 是这两个框架中最受欢迎的、非个性化的、创新的、灵活的、SEO 友好的框架。另一方面，Angular 是一个固执己见的、端到端的、模块化的、安全的框架，具有严格的约定优先于配置。Angular 也是一个“包含电池”的框架，用于开发具有强大 CLI 的企业级 Web 应用程序。

来源: NPM 趋势

同样在 2022 年，React 和 Angular 将继续引领网络发展。尽管 Vue.js 是最受欢迎的框架，但由于安全问题和过于依赖一个人:尤雨溪，它不会在业界被广泛采用。

20.服务器端框架(Java):微服务和无服务器应用的本地框架

Spring MVC/Spring Boot 是 Java 中最主流的服务器端框架。如前所述，Spring 使用常规的 OpenJDK，慢慢失去了在云原生 Java 开发中的魅力。来自 Redhat 的 Quarkus 是云原生开发的头号框架，因为它使用了 GraalVM 而不是传统的 OpenJDK。因此，Quarkus 开发的应用程序更小，启动时间更快，更适合基于容器的开发。

最后，Spring 已经声明了 Spring Native ，它将使用 GraalVM 进行云原生开发:

https://spring.io/blog/2021/03/11/announcing-spring-native-beta

它仍处于试验阶段，将与 Spring 6 一起发布(2022 年 10 月)。Spring Native 的一个优点是，您可以将您的 Spring MVC 项目转换为 Spring Native 项目，而无需任何/很少的代码重写。

所以，如果你在 2022 年开发云原生 Java 应用，考虑使用 Java 原生框架之一。然而，对于单一的 Java 开发，您仍然可以使用基于传统(OpenJDK)的框架(例如，Spring MVC)。

21.应用开发:原生应用提供更大的灵活性

2022 年，手机用户数量将继续增长，应用程序下载数量也将增长。2022 年，预计将有 1710 亿个应用程序被下载。移动应用开发是当今软件开发的一个巨大市场。

来源:统计局

目前，开发移动应用程序有四种方式:原生应用程序开发、跨平台应用程序开发、混合应用程序开发和基于云的应用程序。

其中使用最多的是原生 App 开发和跨平台 App 开发。虽然本地应用程序开发是最昂贵的(就时间/资源而言)，但它提供了最大的灵活性。通常，企业更喜欢原生应用开发的灵活性。

跨平台应用程序开发提供了在 iOS/Android 上使用几乎相同代码的可能性。它是创业公司的首选，他们喜欢跨平台 App 开发的维护成本更低的开发速度和灵活性更小的代价。

2022 年，原生应用开发将占据主导地位，因为跨平台应用开发不如原生应用开发灵活。

22.API 技术:REST、gRPC 和 GraphQL 将共存

现代软件开发通常是 API 驱动的开发。客户端应用程序(Web、移动)通过 API 调用与后端应用程序通信。此外，后端应用程序通过 API 调用相互通信。服务之间的通信是软件开发行业的一个旧范式，有许多技术可以满足这一需求。但是其中有三个脱颖而出: REST、gRPC 和 GraphQL。

REST 是其中最古老的技术，开发于 2000 年。它使用万维网和 HTTP 技术进行客户机-服务器通信。它是最成熟、应用最广泛的。

Google 基于旧的 RPC(远程过程调用)技术创建了 gRPC 作为服务器到服务器的通信 API。这里，每个请求都被构造成一个函数调用。与使用文本格式(例如 JSON、XML)传递消息的 REST 不同，gRPC 使用基于协议缓冲区的二进制格式。因此，对于服务到服务的通信，gRPC 比 REST 更高效、更快。

如果数据结构很复杂，那么 Web 客户端到服务器的通信会有很多往返。为了缓解这个问题，脸书在 2015 年开发了 GraphQL API。在 GraphQL 中，每个客户端可以为特定用例定义数据结构的形状，并在一次行程中获取所有数据。

正如我们从上面看到的，所有三种 API 技术(REST、gRPC、GraphQL)都有它们擅长的用例，而边角用例并没有那么好。2022 年，开发者和公司也将根据他们的用例使用三者之一。

类似文章

</20-amazing-github-repositories-every-developer-should-follow-d8ce4c728351>

熊猫数据框架子集的 23 种有效方法

原文：https://towardsdatascience.com/23-efficient-ways-of-subsetting-a-pandas-dataframe-6264b8000a77?source=collection_archive---------2-----------------------

选择、切片、标引和过滤

照片由 Hans-Peter Gauster 在 Unsplash 上拍摄

在第 1 部分和第 2 部分中，我们学习了如何检查、描述和总结熊猫数据帧。今天，我们将学习如何提取熊猫数据帧的子集。这非常有用，因为我们经常想对数据子集执行操作。有许多不同的方法对熊猫数据框架进行分组。您可能需要选择包含所有行的特定列。有时，您希望选择包含所有列的特定行，或选择符合特定标准的行和列等。

所有不同的子集化方式可分为 4 类:选择、切片、索引和过滤。

(作者图片)

当您继续阅读本文时，您将了解这些类别之间的差异。

在讨论数据框的任何子集方法之前，值得区分熊猫系列对象和熊猫数据框对象。

熊猫系列和数据框架对象

系列和 数据框 是大熊猫的两种主要数据结构。简单地说，一个系列 s 类似于单个数据列，而一个 数据框 类似于有行和列的表格。请看下图:

(作者图片)

如你所见，一个系列是一维的，一个 数据框 是二维的。如果我们把两个或多个 系列对象 组合在一起，就可以得到一个 数据框对象 。让我们看看系列物体的实际视图。

import numpy as np
import pandas as pddata = np.array([85, 90, 70, 80])
series = pd.Series(data=data, 
                   name="marks")
print(series)

(作者图片)

一个序列由两部分组成:一维数据值和索引。索引为每个数据值提供了有意义的标签。用户可以使用该索引来选择值。默认情况下，索引从 0 开始。

让我们来看看一个 DataFrame 对象的实际视图。

import numpy as np
import pandas as pddata = np.array([[25, 85],
                 [25, 90],
                 [26, 70],
                 [24, 80]])dataframe = pd.DataFrame(data=data, 
                         columns=["age", "marks"])
print(dataframe)

(图片由作者提供)

一个 数据帧 由三部分组成:二维数据值、行索引和列索引。这些索引为行和列提供了有意义的标签。用户可以使用这些索引来选择行和列。默认情况下，索引从 0 开始。

现在，我们讨论给熊猫数据帧设置子集的不同方法。出于解释的目的，我将使用**“葡萄酒数据集”**。这是其中的一部分。

葡萄酒数据集的一部分

选择

当我们抓取整个列时，它被称为选择。所选列包含所有行。

方法 1:使用列名选择单个列

我们可以使用列名选择 Pandas 数据帧中的一列。如果数据帧被称为 df ，一般语法为:

df['column_name']
# Or
df.column_name # Only for single column selection

输出是一个单列的熊猫系列！

# Load some data
import pandas as pd
from sklearn.datasets import load_wine
wine = load_wine()
df = pd.DataFrame(data=wine.data,
                  columns=wine.feature_names)# Select the 'alcohol column'
print(df['alcohol'])
print(type(df['alcohol']))

(图片由作者提供)

方法 2:使用列名选择多个列

我们可以使用列名选择熊猫数据帧的多列。我们可以在列表中定义列名:

['column_1', 'column_2', ...]

然后，我们可以将这个列表包含到 df[] 中。一般语法是:

df[['column_1', 'column_2', ...]]

这一次，输出的是一个熊猫数据帧！

df[['alcohol', 'ash', 'hue']]

(图片由作者提供)

方法 3:使用。loc 属性

使用可以获得与方法 1 相同的结果。loc 属性，通过标签(列名)选择熊猫数据*。*

df.loc[:, 'alcohol']

方法 4:使用。loc 属性

使用可以获得与方法 2 相同的结果。loc 属性，通过标签(列名)选择熊猫数据*。*

df.loc[:, ['alcohol', 'ash', 'hue']]

的一般语法。loc 属性为:

df.loc['row_label', 'column_label']

如果有多个标签，应该在列表中指定它们:

df.loc[['row_1', 'row_2'], 
       ['column_1', 'column_2']]

如果我们想选择所有的行或列，可以使用:symbol。最重要的一点。loc 属性是通过标签选择熊猫数据*。*

方法 5:使用。iloc 属性

使用可以获得与方法 1 相同的结果。iloc 属性，通过位置(列索引)选择熊猫数据*。*

df.iloc[:, 0]

酒精变量在位置 0(第一个变量)。

方法 6:使用。iloc 属性

使用可以获得与方法 2 相同的结果。iloc 属性，通过位置(列索引)选择熊猫数据*。*

df.iloc[:, [0, 2, 10]]

的一般语法。iloc 的属性是:

df.iloc['row_index', 'column_index']

如果有多个标签，应该在列表中指定它们:

df.iloc[['row_index_1', 'row_index_2'], 
       ['column_index_1', 'column_index_2']]

如果我们想选择所有的行或列，可以用 : 符号来完成。最重要的一点。iloc 属性是它使用数字索引通过位置选择熊猫数据*。*

方法 7:使用。iloc 属性(简单的方法)

我们可以选择 df 的前 5 列如下:

df.iloc[:, [0, 1, 2, 3, 4]]

我们也可以用下面的简单方法来获得同样的结果。

df.iloc[:, 0:5]

要使用此功能，立柱应连续放置*。0:5 范围包括 0(第一列)，不包括 5(第六列)，并选择该范围内的每一列。*

方法 8:选择最后一列

在许多情况下，选择最后一列通常很有用。有两种方法:

首先，我们可以使用来计算数据帧中的列数。形状属性。

*df.shape
# Output: (178, 13)*

最后一列是可以通过索引 12 访问的第 13 列。通过使用*。iloc** ，*

*df.iloc[:, 12]*

葡萄酒数据集的最后一列(图片由作者提供)

第二种方法简单得多。这里，我们不需要知道数据框中的列数。

*df.iloc[:, -1]*

-1 表示最后一列。

限幅

当我们想从数据帧中提取某些行时，就称之为切片。提取的行称为切片* ，包含所有列。*

方法 9:使用。iloc 属性

提取单行的最简单方法是使用中的行索引。iloc 属性。一般语法是:

*df.iloc[row_index]*

输出是包含行值的 Pandas 系列。

*df.iloc[0]*

(图片由作者提供)

外观有点混乱，因为输出是一个熊猫系列。如果您希望它本身作为一行，只需使用列表中的索引值，如下所示:

*df.iloc[[0]]*

(图片由作者提供)

这是一个熊猫数据框，包含 1 行和所有的列！

方法 10:使用。iloc 属性

我们可以使用 Pandas 数据帧的行索引来提取其中的多行。我们在列表中包含行索引:

*[row_index_1, row_index_2, ...]*

然后我们把这个列表包含在 df.iloc[] 里面。

*df.iloc[[row_index_1, row_index_2, ...]]*

输出是一个熊猫数据帧。

*df.iloc[[0, 25, 100]]*

(图片由作者提供)

方法 11:选择最后几行

负索引从底部开始计算行数。

*df.iloc[[-1, -2, -3, -4, -5]]*

(图片由作者提供)

索引

当我们将列选择和行切片结合起来时，称为索引。在这里，我们可以使用*。锁定和。熊猫数据帧的属性。***

方法 12:使用。iloc 属性

如果我们指定单行和单列，那么交集就是一个值！

*df.iloc[0, 0]*

(图片由作者提供)

请记住，我们不能在中使用列名或行名。iloc[] 。只能使用索引号。

方法 13:使用。loc 属性

这里我们可以在中使用行或列名。loc[] 。还要记住，在我们的数据中，行标签与行索引相同。下面的代码给出了与方法 12 相同的结果。

*df.loc[0, 'alcohol']*

方法 14:使用。iloc 属性

一般语法是:

*df.iloc[[row_index_1, row_index_2, ...],
        [column_index_1, column_index_2, ...]]*

输出是一个熊猫数据帧。

*df.iloc[[0, 5, 100], [0, 3, 7]]*

(图片由作者提供)

方法 15:使用。loc 属性

一般语法是:

*df.loc[[row_name, row_name_2, ...],
        [column_name_1, column_name_2, ...]]*

输出是一个熊猫数据帧。

*df.loc[[0, 5, 100], ['alcohol', 'ash', 'hue']]*

(图片由作者提供)

这里我们可以在中使用行或列名。loc[] 。还要记住，在我们的数据中，行名与行索引相同。

方法 16:使用。loc 和。iloc 属性(简单的方法)

这可以很容易地用 : 符号来完成。为此，行和列应连续定位。**

**df.iloc[0:6, 0:5]**

(图片由作者提供)

另一个例子是:

**df.loc[0:6, ['alcohol', 'ash']]**

(图片由作者提供)

过滤

当我们根据特定的标准或条件选择行和列时，称为。我们也可以将上面讨论的方法与此结合。**

方法 17:基于单一标准对所有列进行筛选

让我们把我们的数据子集当酒精> 14.3* 时。在这里，我们选择所有的列当酒精> 14.3 时。***

***df['alcohol'] > 14.3***

(图片由作者提供)

这是一个熊猫系列的布尔数据类型。我们可以使用这个系列来获得所需的数据子集。

***df[df['alcohol'] > 14.3]***

(图片由作者提供)

方法 18:基于具有几列的单一标准进行过滤

让我们把我们的数据子集当酒精> 14.3* 时。这一次，当酒精> 14.3 时，我们只选择 3 列。为此，我们可以将上述过滤技术与相结合。loc[] 。***

***df.loc[df['alcohol'] > 14.3, 
      ['alcohol', 'ash', 'hue']]***

(图片由作者提供)

方法 19:使用 AND 运算符基于两个标准进行筛选(同一列)

当酒精>为 14.3，酒精<为 14.6* 时，让我们对数据进行子集化。这里，我们使用两个条件，并用和操作符将它们组合起来。每个条件都应该用括号括起来。***

***df[(df['alcohol'] > 14.3) & (df['alcohol'] < 14.6)]***

(图片由作者提供)

方法 20:使用 between()方法基于两个标准进行过滤

使用 between() 方法可以实现方法 19 中讨论的类似类型的过滤。

***df[df['alcohol'].between(14.3, 14.6)]***

(图片由作者提供)

这里，输出有一点不同，因为默认情况下，()方法中的包含了下界(14.3)和上界(14.6)的值。然而，如果我们不想要包含选择，我们可以通过 inclusive=False 。****

**df[df['alcohol'].between(14.3, 14.6,
                         inclusive=False)]**

(图片由作者提供)

该子集与方法 19 中获得的子集完全相同。

方法 21:使用 AND 运算符基于两个标准进行筛选(不同的列)

这里，这两个条件是使用两个不同的列生成的:酒精和色调**。**

**df[(df['alcohol'] > 14.3) & (df['hue'] > 1.0)]**

(图片由作者提供)

方法 22:使用 OR 运算符基于两个标准进行筛选

当我们使用和运算符时，过滤发生在考虑和两个条件都为真的情况下。如果我们希望至少有一个条件为真，我们可以使用或操作符。

**df[(df['alcohol'] > 14.5) | (df['hue'] > 1.4)]**

(图片由作者提供)

方法 23:基于最小值和最大值进行过滤

让我们根据酒精变量的最小值和最大值对数据进行分组。首先，我们得到最小值和最大值的指数:

**df['alcohol'].idxmin() # Min value index
df['alcohol'].idxmax() # Max value index**

然后我们用。iloc[]** 。**

**df.iloc[[df['alcohol'].idxmin(),
         df['alcohol'].idxmax()]]**

(图片由作者提供)

摘要

这些并不是熊猫数据帧子集的唯一方式。还有很多。对于复杂的子集，我们可以结合多种方法。这篇文章帮助你熟悉子集化语法。另外，您现在已经熟悉了术语选择**、切片、索引和过滤。另外，请记住**。iloc** 需要整数值( i 为整数)，而需要整数值。loc 需要标签值。**

今天的帖子到此结束。我的读者可以通过下面的链接注册成为会员，以获得我写的每个故事的全部信息，我将收到你的一部分会员费。

****报名链接:https://rukshanpramoditha.medium.com/membership

非常感谢你一直以来的支持！下一个故事再见。祝大家学习愉快！

特别要感谢 Unsplash 上的汉斯-彼得·高斯特**、为我提供了这篇文章的漂亮封面图片。**

鲁克山普拉莫迪塔
2021–06–04

用几行代码将 Python 函数的执行速度提高了 30 倍

原文：https://towardsdatascience.com/25x-times-faster-python-function-execution-in-a-few-lines-of-code-4c82bdd0f64c?source=collection_archive---------5-----------------------

Python 中多重处理的基本指南

(图片由作者提供)

Python 是一种流行的编程语言，也是数据科学社区中最受欢迎的语言。与其他流行的编程语言相比，Python 速度慢主要是因为它的动态特性和多功能性。Python 代码在运行时被解释，而不是在编译时被编译成本机代码。

C 语言的执行时间比 Python 代码快 10 到 100 倍。但是，如果比较开发时间，Python 比 C 语言要快。对于数据科学案例研究，开发时间比运行时性能更重要。Python 更受数据科学家和数据分析师的青睐，因为它提供了大量的 API、框架和包，但是在优化执行方面，它却失败得很惨。

在本文中，我们将讨论如何使用多处理模块并行执行自定义 Python 函数，并进一步比较运行时时间数。

入门—多重处理:

考虑具有单个处理器的 CPU，如果它同时被分配多个任务，它必须连续地中断每个任务并切换到单个任务以保持所有进程继续。对于多核处理器来说，CPU 可以在不同的 CPU 内核中同时执行多个任务，这个概念被称为并行处理。

为什么重要？

数据争论、特征工程和数据探索是数据科学模型开发流程中的重要元素。在输入机器学习模型之前，需要对原始数据进行设计和处理。对于小规模数据集，执行在几秒钟内完成，但对于大规模数据集，这将成为一项繁琐的任务。

并行处理是提高 Python 程序性能的有效方法。Python 有一个多处理模块，让我们能够在 CPU 的不同内核上并行执行程序。

实施:

我们将使用来自多重处理模块的**Pool**类，帮助并行执行针对多个输入值的函数。这个概念被称为数据并行，这是**Pool**类的主要目标。

我将使用从 Kaggle 下载的 Quora 问题对相似性数据集来进一步演示该模块。

上述数据集包含在 Quora 平台上提问的文本问题。我将在一个 Python 函数上执行多处理模块，该函数通过删除停用词、删除 HTML 标签、删除标点符号、词干等来处理文本数据。

**preprocess()**是执行上述文本处理步骤的函数。

找到托管在我的 GitHub 上的函数预处理() 的代码片段。

现在，让我们使用来自**multiprocessing**模块的**Pool**类为数据集的不同块并行执行函数。数据集的每个块都将被并行处理。

数据集有 537，361 条记录或文本问题需要处理。对于大小为 50，000 的存储桶，数据集被分成 11 个较小的数据块，这些数据块可以并行处理，以加快程序的执行时间。

基准测试:

经常会出现这样的问题，使用多处理模块后执行速度有多快。我比较了实现数据并行性和一次对整个数据集执行**preprocess()**函数后的基准执行时间。

性能记录在一个系统上，该系统配有 RAM: 64GB 和 10 个 CPU 内核。

(图片由作者提供)，多处理和单处理的执行时间基准测试

从上面的图中，我们可以观察到 Python 函数的并行处理将执行速度提高了近 30x 倍。

你可以在我的 GitHub 中找到用来记录基准数的 Python 文件。

(GIF by Author)，执行 Python 文件计算基准数

结论:

在本文中，我们讨论了 Python 中多重处理模块的实现，它可以用来加速 Python 函数的执行。通过添加几行多处理代码，对于具有 537k 个实例的数据集，执行时间几乎快了 30 倍。

对于处理大型数据集，建议使用并行处理，因为它可以节省大量时间并加快工作流程。

参考我关于加速 Python 工作流的其他文章:

4 个可以并行处理现有熊猫生态系统的库
熊猫数据帧迭代速度快 400 倍
为大型数据集优化熊猫的内存使用
带 PyPolars 的熊猫速度快 3 倍

参考资料:

[1]多处理文档:https://docs.python.org/3/library/multiprocessing.html

喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一小部分会员费，不需要你额外付费。

https://satyam-kumar.medium.com/membership

感谢您的阅读

为您的数据科学项目提供 26 个数据集

原文：https://towardsdatascience.com/26-datasets-for-your-data-science-projects-658601590a4c?source=collection_archive---------0-----------------------

基于任务的数据集的汇编，可用于构建您的下一个数据科学项目。

亚历克斯·阿扎巴赫在 Unsplash 上的照片

看着 Kaggle 或谷歌数据集，我总是发现很难确定一个数据集来尝试我最近学到的一个新的机器学习概念。每天都有新的数据集发布在这些流行的网站上，为新项目寻找合适的数据集的努力很快变得势不可挡。

带着这种想法，而且因为我在互联网上找不到一个合适的基于任务的编译列表，我决定自己做一个——实际上是一个主列表，当我需要选择一个数据集来练习新获得的技能时，我总是会回来。

希望这对你也有好处！

这篇文章是关于什么和不是关于什么

让这篇文章成为一个参考，让你考虑为一个你学习并想尝试的新算法尝试一个数据集。

然而，请不要认为这是机器学习任务数据集的详尽列表——我或任何人都不可能查看每个网站上的每个单个数据集。

好了，现在我们已经完成了，让我们继续列表。😃

名单

我会尽量涵盖我能想到的尽可能多的基于机器学习/深度学习的任务和相关数据集，我也会不定期更新这篇文章。所以，如果你愿意的话，也可以考虑用书签来保护它。

我将在我的数据科学之旅中一直使用的数据集(包括我个人最喜欢的)和一些我希望在未来尝试的数据集包括在内。

多用途数据集——用于尝试各种大小算法

ka ggle Titanic Survival Competition—用于尝试各种基本+高级 ML 算法进行二分类的数据集，也尝试执行广泛的特征工程。
时尚 MNIST —基于不同类别(如服装、鞋子、手袋等)执行多类图像分类任务的数据集。
信用卡审批 —信用评分好坏的二元分类任务，如果人们可能是拖欠信用卡贷款的风险。
石头剪刀布s——图像分类为那三类。

回归数据集

波士顿房价——展示回归肌肉的经典数据集。
世卫组织预期寿命——也是试验你的 EDA 技能的好机会。
加州房价——与第一名相差无几。

一般分类问题

心脏病 UCI——根据多个特征预测患者是否存在心脏病。
心脏病发作分析——对心脏病发作的可能性进行分类——用于二元分类。
校园招聘 —根据各种特征确定学生是否被录用。

图像分类问题

肺炎数据 —用于对患者 X 射线中的肺炎类型进行分类。
口罩分类—多类分类为三类类别——带口罩、不带口罩和口罩佩戴不当。
英特尔图像分类— 将自然风景分为 6 类的好方法。

时间序列分析

电子商务销售 —用于预测商店的销售/交易。经典的时间序列预测工作。
每日最低气温-该数据集描述了澳大利亚墨尔本市 10 年来的每日最低气温。
家庭电力消耗 —以一分钟的采样率测量一个家庭 4 年内的电力消耗。

面向自然语言处理任务的大规模文本数据集

亚马逊评论——情感分析任务的经典数据集。过度使用有点没错，但不可否认是一个伟大的。
新冠肺炎开放研究挑战赛 —拥有大量 Covid 研究文章的全文，这是一个很好的数据集，可以从文本摘要、语义搜索和问答系统开始。
一个 rxiv 数据集—arxiv 研究论文的集合，用于构建文本生成、抽象概括和问题回答系统。
新闻标题 —检测新闻标题中的讽刺，一个分类任务。
stack overflow Questions-60k questions on，以便预测问题的标签，并根据分数将问题分类为高质量或低质量。

文本—光学字符识别

手写识别 —这包含了大约 40 万个手写姓名，对于 OCR 任务来说是一个很好的数据集。
验证码识别

感谢阅读！我会尽量确保经常更新这个列表，并希望包括更多的问题类型。

我定期撰写关于数据科学的文章，并努力让读者觉得有趣。关注我在你的订阅源中直接获取新文章。:)

这里是我所有数据科学故事的代码库。快乐学习！⭐️

我的另一篇文章，你可能想看看:

26 个 GitHub 存储库，激发您的下一个数据科学项目

原文：https://towardsdatascience.com/26-github-repositories-to-inspire-your-next-data-science-project-3023c24f4c3c?source=collection_archive---------9-----------------------

用这个有趣的代码列表开始新的一年，包括库、路线图和项目书签

Zoltan·塔斯在 Unsplash 上的照片

在不断发展的数据科学领域，每天都有提高开发人员生产力的新工具发布。有大量伟大的项目可供学习，每天都有更好的项目添加到你寻找的每个机器学习、深度学习甚至 MLOps 主题中。

基于这一想法，我希望通过整理一系列值得注意和鼓舞人心的代码回复来开启新的一年，我认为这些代码回复应该有助于您在数据科学的许多主题中发现新的变化和有趣的进步。

为了便于理解，我选择将这些回购分成前面提到的多个主题，我认为它们可以归入这些主题。

我们走吧！👇

请注意，这是 而不是 我最喜欢的 GitHub repos 的详尽列表。这只是一个清单，我觉得这将是一个很好的提醒。

现代经典图书馆

Streamlit**—**这是一个全新的库，它通过提供一种易于使用的 Pythonic 方式为 ML 应用程序构建前端，在前端领域掀起了一场风暴。在我看来，这是当之无愧的第一名。
Optuna——广泛用于 Kaggle 笔记本和竞赛中， Optuna 是一个自动超参数优化软件框架，专门为机器学习任务而设计。
诗词——坦白说，这是在你的机器上启动任何项目的最佳方式之一。它处理依赖性、包构建以及您的虚拟环境。
SHAP——一种博弈论的、友好的解释任何 ML 模型输出的方式。
权重和偏差——帮助跟踪和可视化开发和生产中 ML 管道的所有部分的库。
Dash —一个不用任何 Javascript 就能构建仪表盘和 web 应用的漂亮框架。
SQLAlchemy —它用 ORM 在 Python 代码中带来了 SQL 的所有功能和灵活性(如果你还没有使用 Django) ).

您今天真正需要了解的工具

箭头 —在 Python 代码中更友好、更方便地使用日期时间函数。
我cedream**——**你会爱上日志用这个简单又上瘾的工具写出更好更高效的日志。
Pyenv**——**依我拙见，坦白地说，这是在您的机器和项目上安装和管理不同版本 Python 的最佳方式，而不会严重破坏您的全球环境。有趣的事实——这是我在新电脑上安装的第一件东西。
没有足够的人知道这个相当滑稽的图书馆。这为在 Python 代码中使用秘密或环境变量提供了一种极其简单的方法。
不平衡——学习——多种重采样技术可供你在任何 ML/DL 项目中重用。
AutoViz——一个新兴的工具，可以一键可视化任何数据集。
NeuralProphet—一个更新更先进的时间序列预测库，建立在 FB Prophet 本身之上。

数据科学路线图

一些伟大的存储库致力于让你在数据科学的所有不同领域从优秀走向卓越。

软件工程师的机器学习—从软件工程师到 ML 工程师的一个月学习计划。
100 天的 ML —一种视觉上吸引人的方法，在 100 天内从头掌握 ML 主题。
数据工程师路线图 —对于我所有的数据工程爱好者读者来说，这里有一个完整的 a-z 路线图，可以帮助你有条理地学习你需要的所有东西。

技术面试准备

ML 访谈书 —帮助你胜任 ML、数据科学、数据工程师、数据分析师或 MLOps 角色的最佳开源书籍。
科技面试手册**——**这无疑是我见过的最好的免费软件工程面试指南。
破解数据科学面试 —这是你可能需要的一大堆备忘单、书籍、问题。

荣誉提名

Netron——一个有用的工具，可以帮助可视化任何简单或复杂的深度学习模型架构，特别有助于在论文中表示。
Cheatsheets AI—学习任何工具或库的重要功能的一个好方法是使用方便制作的 cheat sheets。这个回购协议里有很多。好好利用它们！
MLFlow —另一个与权重和偏见直接竞争的奇妙 MLOps 工具，帮助您跟踪和管理您的 ML 项目生命周期。
ML complete—30+Jupyter 笔记本的综合商店，关于机器学习的大多数主题。

奖金—第 27 期

数据另一天 — 我自己的数据科学存储库，包含我所做的每个项目的代码和文章，以及我探索和撰写的新库！

几句临别赠言…

感谢您的阅读。

我希望这个精选的存储库列表对您选择从事的下一个数据科学项目有所帮助。几个月后，我可能会选择回来给你一份更新的清单。直到那时，快乐学习！:)

我祝你新年快乐，我希望在我的下一篇文章中再次见到你。在那之前，关注我，不要错过我的下一篇文章。我确实每周都写！

我还建议成为中等会员，千万不要错过我每周发表的任何一篇数据科学文章。在此加入👇

https://ipom.medium.com/membership/

我的另外几篇文章你可能会感兴趣:

💔1-datasets-for-your-next-data-science-project-6ef9a6f8cac6>

29 个 Pytorch 片段加速您的机器学习周期

原文：https://towardsdatascience.com/29-pytorch-snippets-to-speed-up-your-machine-learning-cycle-38e659e26b12?source=collection_archive---------29-----------------------

阿里·沙阿·拉哈尼在 Unsplash 上拍摄的照片

从创建张量到编写神经网络

为什么片段很重要

我非常支持代码片段来创建比传统机器学习管道更快的迭代周期。Pytorch 已经成为我的机器学习工具堆栈的重要组成部分有一段时间了，所以我决定将这篇文章写给 分享一些我最喜欢的代码片段，以帮助你建立 Pytorch 模型。

1.打印 Pytorch 版本

import torch
print(torch.version.__version__)# Output1.7.1

2.从 n 数组的嵌套列表中创建张量

example_list = [1,2,3]
x = torch.tensor(example_list)
print(x)# Outputtensor([1, 2, 3])

3.克隆张量

y = x.clone()
print(y)# Outputtensor([1, 2, 3])

4.获取大小和形状

x = torch.randn((10,10))
print(x.size())
# or
print(x.shape)# Outputtorch.Size([10, 10])
torch.Size([10, 10])

5.沿着维度连接张量

tensor_seq = [torch.randn(1,2),torch.randn(1,2)]
x = torch.cat(tensor_seq, dim=0)
print(x)# Outputtensor([[-0.4298,  1.3190],
        [ 0.3904, -1.4962]])

6.将张量整形为维度:(1，任意)

x = torch.randn(10,2)
y = x.view(1,-1)
print(y.shape)# Outputtorch.Size([1, 20])

7.交换张量的特定维度

x = torch.randn(1,2)
print(x)
y = x.transpose(0,1)
print(y)# Outputtensor([[-0.3085,  0.9356]])

tensor([[-0.3085],
        [ 0.9356]])

8.向张量添加轴

x = torch.randn(2,2)
print(x.shape)
y = x.unsqueeze(dim=0)                      
print(y.shape)# Outputtorch.Size([2, 2])
torch.Size([1, 2, 2])

9.删除尺寸为 1 的所有尺寸

x = torch.randn(10,10,1)
print(x.shape)
y = x.squeeze()
print(y.shape)# Outputtorch.Size([10, 10, 1])torch.Size([10, 10])

10.矩阵乘法

A = torch.ones(2,2)
B = torch.randn(2,2)
print(A)
print(B)
print(A.mm(B))# Outputtensor([[1., 1.],
        [1., 1.]])
tensor([[ 0.5804,  1.2500],
        [-0.8334,  1.1711]])

tensor([[-0.2530,  2.4212],
        [-0.2530,  2.4212]])

11.矩阵向量乘法

A = torch.tensor([[1,2],[3,4]])
x = torch.tensor([1,2])
print(A.mv(x))# Outputtensor([ 7, 10])

12.矩阵转置

x = torch.randn(1,2)
print(x)
x = x.t()
print(x)tensor([[0.1167, 0.4135]])

tensor([[0.1167],
        [0.4135]])

13.检查 cuda 可用性

print(torch.cuda.is_available())# OutputTrue

14.将张量数据从 CPU 移动到 GPU 并返回新对象

x = torch.randn(2,2)
print(x)
x = x.cuda()
print(x)# Outputtensor([[-1.0331, -3.2458],
        [ 0.0226,  1.3091]])

tensor([[-1.0331, -3.2458],
        [ 0.0226,  1.3091]], device='cuda:0')

15.将张量数据从 GPU 移动到 CPU

x = torch.randn(2,2).cuda()
print(x)
x = x.cpu()
print(x)# Outputtensor([[ 0.4664, -1.7070],
        [ 1.7160,  0.0263]], device='cuda:0')

tensor([[ 0.4664, -1.7070],
        [ 1.7160,  0.0263]])

16.与设备无关的代码和模块化

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)# Outputdevice(type='cuda', index=0)

17.将张量复制到设备(gpu、cpu)

x = x.to(device)
print(x)# Outputtensor([[ 0.4664, -1.7070],
        [ 1.7160,  0.0263]], device='cuda:0')

18.检查它是否是 Pytorch 张量

print(torch.is_tensor(x))# OutputTrue

19.检查它是否是 Pytorch 存储对象

print(torch.is_storage(x))# OutputFalse

20.获取输入张量中的元素总数

x = torch.randn(2,2) # 4 elements
torch.numel(x)# Output4

21.获取给定大小的单位矩阵

size = 5
print(torch.eye(size))# Outputtensor([[1., 0., 0., 0., 0.],
        [0., 1., 0., 0., 0.],
        [0., 0., 1., 0., 0.],
        [0., 0., 0., 1., 0.],
        [0., 0., 0., 0., 1.]])

22.从 numpy 数组到 torch 张量的转换

x = np.random.rand(2,2)
print(torch.from_numpy(x))# Outputtensor([[0.7407, 0.8823],
        [0.0352, 0.5823]], dtype=torch.float64)

23.基本的线性间距(比如 numpy 的 np.linspace)

print(np.linspace(1,5,10))
print(torch.linspace(1, 5, steps=10))# Output[1\.         1.44444444 1.88888889 2.33333333 2.77777778 3.22222222
 3.66666667 4.11111111 4.55555556 5\.        ] # numpy

tensor([1.0000, 1.4444, 1.8889, 2.3333, 2.7778, 3.2222, 3.6667, 4.1111, 4.5556,
        5.0000]) # pytorch

24.对数间距

torch.logspace(start=-10, end=10, steps=15) #logarithmic spacing# Outputtensor([1.0000e-10, 2.6827e-09, 7.1969e-08, 1.9307e-06, 5.1795e-05, 1.3895e-03,
        3.7276e-02, 1.0000e+00, 2.6827e+01, 7.1969e+02, 1.9307e+04, 5.1795e+05,
        1.3895e+07, 3.7276e+08, 1.0000e+10])

25.将 Pytorch 张量分割成小块

x = torch.linspace(1,10,10)
print(torch.chunk(x,chunks=5))# Output(tensor([1., 2.]),
 tensor([3., 4.]),
 tensor([5., 6.]),
 tensor([7., 8.]),
 tensor([ 9., 10.]))

26.基本神经网络

import torch
import torch.nn as nn
import torch

class NeuralNet(nn.Module):
    def __init__(self):
        super(NeuralNet, self).__init__()
        self.fc1 = nn.Linear(1,1)
        self.relu = nn.ReLU()

    def forward(self,x):
        x = self.fc1(x)
        x = self.relu(x)

        return x
net = NeuralNet()
net# OutputNeuralNet(
  (fc1): Linear(in_features=1, out_features=1, bias=True)
  (relu): ReLU()
)

27.创建张量来保存用于训练神经网络的输入和输出

x = torch.linspace(-10, 10, 2000).view(-1,1)
y = torch.square(x)

28.加载神经网络并设置损失函数和优化器

model = NeuralNet()
criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-6)

29.训练循环，每 10 个时期打印一次输出

epochs = 50
for t in range(epochs):
    # Forward pass: computing prediction
    y_pred = model(x)

    # Compute the loss and printing ever 10 iterations
    loss = criterion(y_pred, y)
    if t % 10 == 9:
        print(t, loss.item())

    # Zero gradients, perform a backward pass, and update the weights.
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()# Output9 1987.289306640625
19 1986.6630859375
29 1986.0374755859375
39 1985.412353515625
49 1984.78759765625

结论

我认为这样的代码片段很容易获得，这很有帮助。这使得整个迭代周期更快，也更令人愉快，因为我们不必不断地寻找如何在我们选择的框架中执行我们想要的每个任务。

我想在这里提到两个我认为对 Pytorch 中的基本代码非常有用的资源:

https://github.com/Apress/pytorch-recipes

因此，请确保您的 Pytorch 代码片段随时可用，并享受编写代码的乐趣！

如果你喜欢这篇文章，请在 Twitter 、 LinkedIn 上联系我，并在 Medium 上关注我。谢谢，下次再见！:)

参考

Pytorch 备忘单
Pytorch 食谱

3.3 关于决定使用多个数据表是否是一个好主意的争论

原文：https://towardsdatascience.com/3-3-arguments-on-deciding-if-using-multiple-date-tables-is-a-good-idea-5b1788c426a6?source=collection_archive---------11-----------------------

通常，在我们的表格模型中有一个数据表。但有时，多个日期表可能是个好主意。让我们分析一下如何决定做这件事的正确方法。

照片由 Unsplash 上的延斯·勒列拍摄

前一段时间，我写了一篇关于用扩展的数据表增强报告的文章。你可以在这里找到这篇文章:用扩展的数据表改进你的报告的 3 种方法。

从那以后，我与客户和同事讨论了为什么我在 Power BI 或 Analysis Services 的表格模型中需要不止一个日期表。

当我们试图决定是要只有一个日期表还是要有多个日期表时，有三个主题需要考虑:

可用性
更简单的 DAX 代码
简化模型

让我们看看这三个主题。

但首先，我们需要了解“问题”。

问题是

让我们看一个例子，其中我们有多个日期的事务:

图 1 —具有多个日期的交易表

在上图中，我们看到有多个日期的交易。

现在，我们希望能够根据三个日期中的每一个创建报告。

我们可以创建一个简单的模型，就像这样:

图 2 —带有一个数据表的简单数据模型

活动关系将 OrderDate 列链接到 Date 列。

或者，我们可以构建另一个数据模型，为在线销售表中的每个日期列创建一个日期表:

图 3 —每个日期列有一个数据表的数据模型

第一种更简单的模型是常见的模型。这个简单的模型对大多数用例都有帮助。

无论如何，有三个数据表的模型可能会更有帮助。

让我们深入探讨上面提到的决定哪种模式更好的三个论点。

可用性

可用性是不客观的，它取决于用户的品味，用户会使用数据模型。

当您开发 Power BI 模型以创建 Power BI 报告时，您可以遵循自己喜欢的方式。

但是当你开发一个数据模型时，其他用户也应该使用它，那么你也需要考虑他们的用户技能、习惯和对数据模型的理解。

共享数据模型可以通过 Power BI 服务或 Analysis Services 数据模型中的共享数据集来实现。

我想向您展示数据模型的哪些部分会影响可用性:

措施的复杂性
计算组
对目的的理解

措施的复杂性

当我有多个数据表时，我可以创建简单的度量。我可以对模型中的任何日期表使用这些度量。

我可以使用这个简单的 DAX 方法来衡量任何日期表的销售额:

Online Sales = SUMX(‘Online Sales’, [UnitPrice]*[SalesQuantity])

而对于只有一个日期表和多个关系的情况，我需要使用 USERELATIONSHIP()函数为一个非活动关系实现相同的功能。

根据到期日计算销售额的 DAX 度量值:

Online Sales by Due Date =
CALCULATE(
    SUMX(‘Online Sales’, [UnitPrice]*[SalesQuantity])
    ,USERELATIONSHIP(‘Online Sales’[DueDate],’Date’[Date])
    )

但是，当您有多个日期表时，您可以对所有日期表使用第一个简单的在线销售度量，而无需添加更多的度量。

此外，当用户可以选择他想要使用的日期表时，他可以这样做，这是透明的。

另一方面，用户将无法比较同一图表中基于不同日期轴的数字:

图 4 —比较两个测量的数据

但是，一旦我们需要时间智能度量，我们就必须创建相同数量的度量。

计算组

我们可以使用计算组来简化我们的模型。我们可以使用这个特性来避免不同度量中的冗余逻辑。

您可以在 SQLBI 文章介绍计算组— SQLBI 中阅读有关计算组的更多信息

不幸的是，当使用一个或多个日期表时没有区别。例如，在创建时间智能度量时，您必须为每个日期轴开发不同的计算组。无论您使用一个还是多个日期表格。

计算组不会帮助您决定选择哪条路线。

对目的的理解

相应地命名您的措施至关重要。

正如您在下图中看到的，我为每个度量添加了一个后缀来定义目的:

图 5 —有目的地测量

最好独立于您使用一个或多个日期表的决定来完成这项工作。

你必须记住，你的用户需要你的帮助来理解你的模型中每个对象的用途。

因此，如果您相应地命名您的日期表，会有所帮助，如上图所示(图 2 和图 3)。

更简单的 DAX 代码

钳工在 Unsplash 上拍照

在上一节中，我们已经看到，当我们使用一个日期表时，如果要确保根据特定的日期轴计算销售额，我们需要编写更多的代码。

当我们编写时间智能度量时也是如此。

不是小节数的问题。不管我们的决定如何，我们总是需要开发相同数量的时间智能度量。

但是，当我们有一个中央数据表时，我们必须为每个时间智能度量添加一个 USERELATIONSHIP()。

用一个日期表按到期日衡量上一年:

Online Sales PY (Due Date) =
VAR SalesAmountPY =
    CALCULATE(
        SUMX(‘Online Sales’, [UnitPrice]*[SalesQuantity])
        ,SAMEPERIODLASTYEAR(‘Date’[Date])
        ,USERELATIONSHIP(‘Online Sales’[DueDate], ‘Date’[Date])
        )RETURN
    SalesAmountPY

相比之下，当我们有一个专用的到期日表时，看下面的 DAX 代码，根据到期日计算前一年:

Online Sales PY (Due Date) =
VAR SalesAmountPY =
    CALCULATE(
        SUMX(‘Online Sales’, [UnitPrice]*[SalesQuantity])
        ,SAMEPERIODLASTYEAR(‘Due Date’[Date])
        )RETURN
    SalesAmountPY

这个解决方案更容易编写和阅读。

有时，多个日期表有助于解决只有一个日期表时很难解决的问题。

在我的文章中，我描述了一个问题，我需要使用两个日期轴对我的数据应用两个不同的日期过滤器。

我不知道上面文章中解释的问题能否用一个单独的数据表来解决。
即使这个问题可以解决，解决方案也会非常复杂，难以理解。

您需要仔细考虑需求，并相应地决定是只能使用一个日期表，还是需要多个日期表。

简化模型

在数据模型中使用一个数据表最明显的原因是为了简化数据模型。

下图显示了带有一个日期表的数据模型:

图 6 —带有一个数据表的数据模型

现在比较同一个数据模型，但是有多个数据表:

图 7 —具有多个数据表的数据模型

你看第二个更大，看起来更复杂。

但是，当您仔细观察第一个数据模型时，可以看到从在线销售表到日期表的三种关系。在外行看来，这三种关系看起来也很复杂。

在这一点上，这是你的决定，哪个数据模型看起来更容易理解，或者哪个是更复杂的数据模型。

结合两种解决方案

有时，需求会发生冲突，您不能坚持使用一种方法。

在这种情况下，您可以创建一个将两种方法结合在一起的模型:

图 8 —组合数据模型

现在您有了所有的可能性，并且您可以在您的模型中使用这两种方法的优点。

但是代价是增加了复杂性和用户使用错误数据表的危险。

假设您使用 Ship Date 表创建时间智能度量。
但是，当用户在这个模型上创建一个报表，并将数据表添加到报表中时，该度量将不再有效。

然后，您需要向您的度量添加检查，以找出报告中使用了哪个日期表。

示例 1 —带检查的动态 PY 测量

这里有一个如何做到这一点的例子:

Sales PY (by Ship Date) =
    VAR IsShipDate = ISFILTERED(‘ShipDate’)RETURN
    IF( IsShipDate
        ,CALCULATE([Sum Online Sales]
        ,SAMEPERIODLASTYEAR(‘ShipDate’[Date])
        )
        ,CALCULATE([Sum Online Sales]
            ,SAMEPERIODLASTYEAR(‘Date’[Date])
            ,USERELATIONSHIP(‘Online Sales’[ShipDate], ‘Date’[Date])
        )
    )

示例 2 —带有基本测量的动态 PY 测量

或者，可以使用 SWITCH()函数创建一个更复杂的检查，将所有的数据表合并到一个度量中。

这里是确定使用哪个日期表的基本度量:

Get used Date table =
SWITCH (
    TRUE
        ,ISFILTERED(‘OrderDate’), 1
        ,ISFILTERED(‘ShipDate’), 2
        ,ISFILTERED(‘DueDate’), 3
        ,0
    )

然后，您可以在所有其他度量中使用此基本度量，如下所示:

Sum Online Sales PY (Dynamic) =
SWITCH([Get used Date table]
    , 1
    ,CALCULATE([Sum Online Sales]
        ,SAMEPERIODLASTYEAR(‘OrderDate’[Date])
    )
    , 2
    ,CALCULATE([Sum Online Sales]
        ,SAMEPERIODLASTYEAR(‘ShipDate’[Date])
    )
    , 3
    ,CALCULATE([Sum Online Sales]
        ,SAMEPERIODLASTYEAR(‘DueDate’[Date])
    )
    ,CALCULATE([Sum Online Sales]
        ,SAMEPERIODLASTYEAR(‘Date’[Date])
    ))

当我们将这样的逻辑添加到度量中时，我们还必须考虑性能。

我用 Power BI 中的示例 1 创建了一个矩阵，并使用 Power BI Desktop 中的性能分析器将这个矩阵的查询复制到 DAX Studio。我使用了服务器计时特性来收集计时信息。

然后，我立即执行带有 on Measure 的查询，以获得有意义的度量。

作为基线，让我们使用简单的销售额合计:

图 9 —基线测量(发货日期表)

现在，用 ShipDate 日期表来度量 PY 的时间:

图 10——用装运日期表测量 PY

现在，使用 Measure 进行测量，该测量检查正在使用哪个日期表:

图 11——使用数据表检查的 PY 测量

为了进行比较，这里使用了相同的度量，但是这次使用了日期表，该表需要 USERELATIONSHIP()函数:

图 13——使用数据表检查和用户关系测量 PY

这里所有的计时都在一个表中:

图 12 —计时表

如您所见，使用在线销售和发货日期表之间的关系只多花了 127 毫秒的时间。

对已用日期表的检查只需要额外的 30 毫秒。这是非常少的时间，您不需要考虑它。

但是与使用关系相比，使用 USERELATIONSHIP()函数需要 200 毫秒以上。

当然，这些值取决于您的模型的几个因素，您需要执行您的测量以获得适当的性能差异。

结论

这个问题的答案是“我应该使用一个日期表还是需要多个日期表？”是:

视情况而定

由莎伦·麦卡琴在 Unsplash 上拍摄的照片

您必须评估报告需求和用户的能力。

我的建议是:

从一个单独的日期表格开始，除非你知道你需要专用的日期表格。
一旦你有了理由，就换成专用的日期表

到目前为止，这种方法对我来说非常有效。

但是，为什么我用“3.3 关于决定使用多个数据表是否是一个好主意的论点”作为这篇文章的标题呢？

我使用了三个主要论点:

可用性
更简单的 DAX 代码
简化模型

但是在可用性内部，我进一步提到了三个原因:

措施的复杂性
计算组
对目的的理解

因此，3.3 个参数。

3.基于大数据帧的 Spark 性能优化实例研究

原文：https://towardsdatascience.com/3-a-case-study-of-spark-performance-optimization-on-large-dataframes-8fa06fa6e0ff?source=collection_archive---------28-----------------------

火花性能优化探索

关于如何优化 Spark 性能的详细案例研究，涉及数十亿条记录

由 NASA 在 Unsplash 上拍摄的照片

欢迎回来！这是探索 Spark 性能优化系列的第三部分。在前两篇文章中，我们讨论了 Spark 的特性以及如何使用 Yarn web UI 进行代码性能检查。在这第三篇文章中，我们将继续详细讨论一个性能优化案例。

这篇文章将涵盖:

虚拟数据集简介
识别和解决数据偏斜问题
识别和解决长沿袭路径问题
其他一些小的改进

1.虚拟数据帧简介

在这个应用程序中，我们有一个大的数据框架:一个交易记录表，包含所有用户在过去一年中的信用卡交易(大约 100 亿条记录)。从这个庞大的交易记录表开始，我们首先要找到每个用户在过去 3 个月中最常使用的信用卡。然后，我们希望获得这张最常用的信用卡过去 1 年的交易记录，以便进行进一步的功能工程开发。

该任务分为两步:

过滤完整的交易记录表以获取过去 3 个月的交易记录。应用groupBy和aggregation方法获取每个用户最常用的信用卡。
将最常用的信用卡表与完整的交易记录表连接起来。

数据结构和工作流程

2.数据偏斜度

2.1 数据偏斜问题的识别

第一个问题是运行时间长。正如我们在上一篇文章中所讨论的，yarn web UI 是探测 spark 性能问题的一个非常有用的工具。因此，我在运行任务时检查了 yarn web UI，发现了长运行时间的一个潜在原因。有多个阶段由 200 个分区组成，虽然 199 个分区很快就完成了，但总有一个分区需要很长时间才能完成。由于这一个拖动分区，舞台必须等到最后一个分区完成。

然后我需要找到这个阶段对应的代码部分。Spark 安排阶段的方式是基于洗牌操作。如果某个操作导致分区洗牌，则安排一个新阶段。在我以前的经验中，有 200 个分区的阶段应该对应于map-reduce操作中的reduce部分。因为我没有传入参数来指定并行级别，所以默认分区将是 200。因此，具有 200 个分区的阶段对应于 groupby/aggregation 操作或 join 操作。

有了瓶颈阶段的线索后，我开始探查潜在的性能瓶颈代码。获取最常用的信用卡包括 groupby/aggregation 操作，获取使用最常用信用卡的过去 1 年的交易包括 join 操作。因此，我首先检查了 groupby/aggregation 操作。如果 1 年事务表是倾斜的，那么 groupby/aggregation 操作可能会受到不平衡工作负载的影响。

对于 1 年的事务表，我统计了每个 user_id 的事务记录，结果是 1/10 的事务有 NULL user_id。这是 reduce 操作期间工作负载严重不平衡的原因。因为这 10 亿条记录将被拉到同一个工作节点进行聚合，而其他 199 个工作节点的工作负载要少得多。这种不平衡的工作负载会损害 Spark 的并行计算能力。

2.2 解决数据偏斜问题

问题在于数据的偏斜。有多种方法可以缓解或解决这个问题。一种方法是通过手动传递大于 200 的并行度参数来增加并行度。另一种方法是引入盐析过程，通过随机地给关键字添加前缀。然而，这两种方法只能帮助缓解数据偏斜问题，解决该问题的最佳方法是在业务逻辑保持完整的情况下丢弃极度集中的键。在我的应用程序中，NULL user_id 是由于以前的复制错误造成的，删除 NULL user_id 记录不会影响 1 年交易记录的完整性。因此，我的解决方案是过滤掉空的 user_id 记录。

3.漫长的传承路径

在解决了数据偏斜问题后，不再有 1 个分区占用了非常长的运行时间的阶段。然而，整个任务仍然需要相当长的运行时间。检查 Spark DAG，我发现没有可重用的内存，并且沿袭路径很长。长沿袭路径可能有问题，因为早期阶段中的一个分区失败将导致后续阶段的长链的重新计算。因此，添加适当的检查点有助于缩短漫长的沿袭路径并缩短运行时间。

在我的应用程序中，获取最常用的信用卡需要很长的运行时间，因为它涉及到混洗大数据帧和使用 windows 函数。此操作花费了很长时间，占用了大量内存。因此，我决定在生成最常用的信用卡表之后添加一个检查点。通过添加一个检查点，最常用的信用卡表被写入 HDFS，复制机制从 spark 转移到 HDFS。通过切割长血统路径，后面的阶段也运行得更快。

4.其他小的改进

除了两大优化之外，还有一些小的改进:

当连接大数据帧和小数据帧时，广播小数据帧以避免混排连接。Shuffle join 一直是 Spark 性能的主要瓶颈，因为它涉及跨分区移动数据。但是，如果连接操作涉及一个大数据帧和一个小数据帧，就可以很容易地避免混洗连接。通过广播小数据帧，工作节点在每个分区上执行内存连接，而不需要打乱大数据帧。
正确使用过滤器。如果可能的话，在进行混洗操作之前，请始终使用合适的过滤器，因为过滤器有助于减小数据帧的大小，从而有助于提高性能。

摘要

这篇文章涵盖了一个涉及大型数据框架的特征工程优化案例。为了探究这个问题，yarn web UI 是一个很好的助手，因为它有助于发现潜在的性能瓶颈。那么这篇文章将介绍两个主要的和两个次要的性能改进:

检查并解决数据偏斜问题。
添加检查点以切断漫长的沿袭路径。
连接大数据帧和小数据帧时正确使用广播。
正确使用过滤器有助于在洗牌操作中减小数据帧的大小。

轻松导入和执行 Python 模块的 3 种技术

原文：https://towardsdatascience.com/3-advance-techniques-to-effortlessly-import-and-execute-your-python-modules-ccdcba017b0c?source=collection_archive---------9-----------------------

如何让你的 Python 模块更加用户友好

由弗洛里安·克劳尔在 Unsplash 上拍摄的照片

动机

作为一名数据科学家，您很可能希望与您的队友或其他用户共享您创建的有用模块。尽管你的模块可能是有用的，但是如果其他人要花很大力气才能访问你的模块中有用的函数，他们就不会使用它。

因此，你想让用户更容易使用你的模块。导入和运行模块的代码应该很短。在本文中，我将向您展示 3 种简化导入和执行 Python 模块的方法。

导入所有内容

方案

假设我们有一个名为utils.py的文件，其中包含所有重要的函数和类

在另一个脚本中，我们想要使用from utils import *从utils.py 导入除了变量a之外的所有内容。我们如何做到这一点？

解决办法

这很容易通过添加__all__ = [“add_two”, “multiply_by_two”]来实现。使用import *时，将导入__all__中指定的函数、类和包。

现在尝试在另一个脚本中使用import *

5
6
Traceback (most recent call last):
  File "main.py", line 6, in <module>
    print(a)
NameError: name 'a' is not defined

酷！该错误告诉我们只有来自utils.py的add_two和multiply_by_two被导入，而a没有被导入。

合并多个文件

方案

想象一下我们目录中的文件结构如下所示:

.
├── data_modules
│   ├── load_data.py
│   └── process_data.py
└── main.py

load_data.py看起来是这样的:

而process_data.py看起来是这样的:

为了使用两个不同文件中的类，我们需要从每个文件中导入每个类。

这个方法很好，但是使用 2 个 import 语句是多余的。有没有一种方法可以把两个 import 语句变成一个 import 语句，如下所示？

解决办法

这可以用__init__.py文件轻松解决。在data_modules目录下插入__init__.py文件:

touch data_modules/__init__.py

然后将前面提到的导入语句插入到__init__.py文件中:

我们在这里使用一个.，因为load_data.py和__init__.py在同一个目录中。

现在让我们试着从data_modules导入DataLoader和DataProcessor

Loading data from data/
Processing data1

不错！有用！

像运行主脚本一样运行一个目录

方案

我们的目录如下所示:

.
└── data_modules
    ├── __init__.py
    ├── load_data.py
    ├── main.py
    └── process_data.py

而不是逃跑

$ python data_modules/main.py

我们可能想让我们的用户或队友更简单地运行代码main.py文件，只需运行父目录:

$ python data_modules

这比运行python data_modules/main.py要好，因为它更短，用户不需要知道data_modules里有什么文件。

我们如何做到这一点？

解决办法

这就是__main__.py派上用场的时候。只需将运行顶层目录时要运行的脚本改为__main__.py。在我们的例子中，main.py将变成__main__.py。

# Rename main.py to __main__.py
$ mv data_modules/main.py data_modules/__main__.py

我们的新目录将如下所示

.
└── data_modules
    ├── __init__.py
    ├── load_data.py
    ├── __main__.py
    └── process_data.py

现在快跑

$ python data_modulesLoading data from data/
Processing data1

它的效果非常好！

结论

恭喜你！您刚刚学习了如何通过以下方式使您和您的软件包的使用者更加轻松:

使用import *时控制导入的内容
缩短您的进口陈述
将顶级目录作为主脚本运行

我希望这些技巧能让你的 Python 包更加人性化。如果你的团队成员和用户很容易访问你的有用模块，他们会很乐意使用你的包。

本文的源代码可以在这里找到:

https://github.com/khuyentran1401/Data-science/tree/master/python/module_example

我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上联系我。

如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:

💔-python-tricks-to-read-create-and-run-multiple-files-automatically-5221ebaad2ba>

参考

d . m . beazley 和 b . k . Jones(2014)。 Python 食谱。北京；剑桥；法纳姆；科隆；塞瓦斯托波尔；东京:奥赖利。

Python 列表中的 3 个高级操作及示例

原文：https://towardsdatascience.com/3-advanced-operations-in-python-lists-with-examples-eecdcdc6d4e0?source=collection_archive---------21-----------------------

合并、列表理解和附加元素

克里斯·劳顿在 Unsplash 上的照片

列表是 Python 中内置的数据类型之一。它用于存储多个 Python 对象(integer、float、string 等。)在单个变量中。这些元素放在一对方括号内。

list_1 = [1, 0, 10] # A list of integers
list_2 = [5.3, 10.0, 7.5] # A list of floats
list_3 = ['A', 'I', 'Help', 'Thanks'] # A list of strings
list_4 = [1, 5.3, 'A'] # A list of mixed Python objects!

Python 列表中一些有趣的事实

列表中的单个元素可以通过使用从零开始的索引来选择(零表示第一个元素)。
列表是可变的。在创建列表后，我们可以添加或删除项目，或者更改列表中某个元素的值。
不同数据类型的元素可以包含在同一个列表中。
list() 构造函数可以用来创建一个新的列表。
可以通过使用 list()构造函数中的 range() 函数来创建后续整数的列表。

Python 列表中的一些高级操作

Python 列表中有很多操作。这里将重点介绍合并、列表理解和追加元素。

1.用 zip()函数合并列表

函数的作用是:从两个列表中提取相应的元素，将两个列表合并成一个新列表。结果是一个 zip 对象。我们可以将该对象放在 list() 构造函数中，以显示新的元组列表。

list_1 = [1, 2, 3]
list_2 = ['one', 'two', 'tree']list(zip(list_1, list_2))

(图片由作者提供)

我们也可以合并两个不同长度的列表。在这种情况下，新列表的创建有利于最短的列表。

list_1 = [1, 2, 3, 4, 5] # 5 elements
list_2 = ['one', 'two', 'tree'] # Only 3 elementslist(zip(list_1, list_2))

(图片由作者提供)

2.列表理解

列表理解是一种单行代码技术，用于通过迭代列表中的元素来构建新列表。新列表是以原始列表元素满足特定表达式或条件或两者的方式创建的。

语法是:

[<expression> for <variable> in <list>]

假设我们有下面的列表。

new_list = [1, 2, 3, 4, 5]

现在，我们要创建一个新的列表，包含上面列表中所有元素的平方值*。为此，我们可以使用列表理解。*

*[x**2 for x in new_list]*

(图片由作者提供)

列表理解还可以包含一个条件。在这种情况下，语法是:

*[<expression> for <variable> in <list> if <condition>]*

现在，我们要创建一个新的列表，它包含原始列表中被选中的元素的 的平方值(例如奇数)。为此，我们可以使用列表理解和一个条件。

*[x**2 for x in new_list if x % 2 == 1]*

(图片由作者提供)

3.追加元素

前面的两个操作没有修改对其执行操作的原始列表。但是，append elements 是一个直接修改原始列表的就地操作。该操作将元素添加到列表的末尾。这可以通过使用列表对象的 append()方法来完成。

通常，我们创建一个空列表，然后根据需要添加元素。上述平方值问题也可以通过使用这种方法来解决。

*a = [] # Empty listfor i in new_list:
  sq = i**2
  a.append(sq)a*

(图片由作者提供)

在创建时， a 是一个空列表。现在， a 已经被修改并包含 5 个元素，这意味着附加操作已经完成。

当您希望存储计算值以供以后打印时，追加操作非常有用。举个例子，

*x = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
y = []for i in x:
  ex = i**3
  y.append(ex)import matplotlib.pyplot as plt
plt.plot(x, y)*

(图片由作者提供)

使用合并操作可以看到坐标！

*coordinates = list(zip(x, y))
coordinates*

(图片由作者提供)

结论

Python 列表非常有用，因为我们只用一两行代码就可以用它们执行一些高级操作。Python 列表的一个很好的替代品是 NumPy 数组，特别是当我们考虑性能的时候。执行时，NumPy 数组比 Python 列表快得多。然而，我们可以很容易地使用 Python 列表创建 NumPy 数组或将列表转换成数组。Python 列表是一种内置的数据类型。它与 Python 中的其他数据类型和库紧密相关。

我的读者可以通过下面的链接注册成为会员，以获得我写的每个故事的全部信息，我将收到你的一部分会员费。

报名链接:https://rukshanpramoditha.medium.com/membership

非常感谢你一直以来的支持！下一个故事再见。祝大家学习愉快！

特别感谢 Unsplash 上的 Chris Lawton ，为我提供了这篇文章的封面图片。

鲁克山·普拉莫迪塔
2021–08–28

你应该知道的 3 个低代码 Python 库

原文：https://towardsdatascience.com/3-amazing-low-code-machine-learning-libraries-that-you-should-know-about-a66895c0cc08?source=collection_archive---------14-----------------------

机器学习

以下哪一个是机器学习的最佳低代码库？

卡罗琳娜·格拉博斯卡拍摄的图片。来源: Pexels

我在 Medium 上的一些最受欢迎的博客是关于图书馆的，我认为你应该试试。在这篇博客中，我将关注低代码机器学习库。事实是，许多数据科学家认为低代码库是捷径，应该避免。恐怕我不得不反对！我认为低代码库应该包含在我们的管道中，以帮助我们在不浪费时间的情况下做出重要的决定。

例如，假设您刚开始一个项目，不知道要开始测试哪个模型。您可以从那些您认为效果不错的模型开始，在您运行了几个模型之后，您可以决定您想要超调哪些模型。不利的一面是，您只能使用自己熟悉的模型，而且设置所有这些模型会花费很多时间。另一种选择是使用低代码库，同时运行几十个模型，选择最好的一个，尝试复制它，然后调用它。哪个对你来说听起来更聪明？

幸运的是，我们有许多用于机器学习的低代码库，今天我将介绍我最喜欢的三个。这个博客的目的是介绍一些库，这样你就可以自己尝试了。你可以在这个笔记本里找到我用的代码。因此，我将不涉及微小的细节。让我们开始吧。

PyCaret

最流行的用于机器学习的低代码库之一是 PyCaret。Medium 上有很多关于它的博客，包括我几周前写的一篇，你可以在这里找到它。以下是 PyCaret 网站对此的评论:

PyCaret 是一个用 Python 编写的开源、低代码机器学习库，允许您在自己选择的笔记本环境中，在几分钟内从准备数据到部署模型。

顺便说一下，PyCaret 是这个博客中最好的图书馆网站，也是我见过的最好的网站之一。他们有详细的教程展示这个库必须提供的所有功能。现在，让我们看看如何使用 PyCaret。

首先，我们需要安装 PyCaret。为此，您可以在终端中键入pip install pycaret[full]。代码的完整部分包括所有的依赖项。为了安全起见，强烈建议您使用不同的环境。然后，我们需要一个数据集。PyCaret 内置了多个库。我不会一一赘述，但如果你想了解更多，你可以查看[这个博客](http://By the way, PyCaret has, by far, the best website among the libraries in this blog and one of the best that I have ever seen. They have detailed tutorials showing all the functions that this library has to provide. Now, let’s see how to use PyCaret.)。PyCaret 非常酷的一点是它附带了 QuickDA。这使得我们的数据集更容易理解。如果你想了解更多关于 QuickDA 的知识，你可以看看这个博客:用这个库用几行代码做一个完整的 EDA 节省了几个小时的工作。

**# Importing the dataset**
from pycaret.datasets import get_data
data = get_data('credit', profile=True)

作者图片

现在，让我们跳过所有的数据处理部分，直接进入建模。PyCaret 的网站上有多个数据预处理的例子，我强烈推荐你去看看。然而，关于 PyCaret 最酷的部分是，我们将用一行代码运行许多模型并对每个模型进行评分。

要运行所有的模型，需要输入best_model = compare_models()，就这样。此功能将训练库中的所有模型，并使用交叉验证对它们进行评分，以进行指标验证。现在你可能会问:在这一行代码中，数据集在哪里？我不知道，但是如果你发现了，请让我知道。让我们看看结果。

作者图片

正如我们在上面看到的，我们只用一行代码就运行了 15 个模型。里面甚至还有一个 XGBoost。看起来没用，但我们还有十四个其他模型要分析。所有这些模型都是在 3 分 23 秒内完成的。好吧，如果我们关注这个项目的准确性得分，线性判别分析是最好的模型。通常，我会使用 F1 分数，但为了演示的目的，我会使用准确性。现在，我们能超调这个模型吗？答案是肯定的，而且就像运行所有这些模型一样简单。

作者图片

我们走吧。精度从 0.8206 到 0.8213。有些人会说这可以忽略不计，但是请记住，您只需输入 20 个字符就可以获得这种改进。当我们谈论 PyCaret 时，还有更多的内容需要讨论。这是一个介绍，我强烈建议你检查他们的网站，并尝试它。

TPOT

TPOT 是一个自动化的机器学习库。它的目标是自动化机器学习项目中最繁琐的部分，如特征预处理、特征选择、模型选择等。这就像有人为你工作。下图展示了 TPOT 过程。

一个机器学习管道的例子。来源: TPOT 文件

以下是其网站对此的评论:

TPOT 旨在成为一个助手，通过探索你可能从未考虑过的管道配置，给你提供如何解决特定机器学习问题的想法，然后将微调留给更受约束的参数调整技术，如网格搜索。

与 PyCaret 不同，TPOT 不是在几秒钟内跑完的。相反，需要几分钟(取决于您的数据集，可能需要几个小时)才能得到最佳结果。它们的默认设置是 100 代，种群大小为 100。如果我在我的 2019 款英特尔 MacBook Pro 上运行，需要几个小时或几天。因此，出于演示目的，我将只运行一个生成。结果，我会得到一个管道。它可能不是最好的，但可能有很好的精度。要安装 TPOT，你需要在你的终端键入pip install tpot。记得使用不同的环境。

我将使用我在 PyCaret 演示中使用的相同数据集。我们需要为 TPOT 训练一个测试集，就像使用 scikit-learn 一样。

**# Creating X and y variables**
X = data.drop(columns=['default])
y = data['default'] **# Train test split**
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.2, random_state = 42)

好了，现在我们有了我们需要的一切。现在让我们运行一些管道。首先，我们需要导入将要使用的包。由于这是一个分类项目，我们将导入 TPOT 的分类包。

**from** tpot **import** TPOTClassifier

然后，我将设置管道优化器。有几十个参数可供选择。TPOT 有很好的文档，你可以很容易地找到每个参数的解释。我用的是最基础的，但是强烈推荐你找更好的参数。

**# Setting the model up**
pipeline_optimizer = TPOTClassifier(generations=1, verbosity=2, scoring='f1', n_jobs=-1)**# Fitting the model** pipeline_optimizer.fit(X_train, y_train)

作者图片

等了 33 分钟后(！)，TPOT 返回了上面的结果。我们可以看到，他们展示了模型和参数，如果你想复制它，就可以得到那个结果。如我们所见，使用树外分类器，最佳模型的精确度为 0.8283。它非常接近我们用 PyCaret 得到的结果。PyCaret 还运行了一个树外分类器。然而，TPOT 能够超调参数并获得更好的结果。

懒惰预测

LazyPredict 是一个低代码库，用两行代码运行几十个模型。它不如更受欢迎的同类产品强大。然而，LazyPredict 能够在几秒钟内返回基线模型！它并没有优化模型。但是，您可以使用 scikit-learn 轻松复制这些模型。

我已经写了一些关于 LazyPredict 的博客，我不打算再谈论这个神奇的库了。然而，这是一个关于机器学习的博客，我不能跳过 LazyPredict。你可以在这里找到我的博客，在这里找到，在这里找到。

现在，让我演示一下它是如何工作的。你可以在你的终端中输入pip install lazypredict来安装它，然后你就可以开始了。我将使用用于 PyCaret 和 TPOT 的相同数据集，以便我们可以比较结果。让我们首先导入将要使用的包。

**# Importing the packages that we will use**
import lazypredict
from lazypredict.Supervised import LazyClassifier

现在，让我们运行 30 个模型！LazyPredict 与 scikit-learn 非常相似。我们需要将模型添加到变量中，并使其适合我们的训练和测试数据集

**# Running all the models**
clf = LazyClassifier(verbose=0,ignore_warnings=True)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
models

作者图片

我们走吧！让我们仔细看看结果。

作者图片

我们得到了一些奇妙的结果，它们与我们用 PyCaret 和 TPOT 得到的结果非常相似。看起来 RandomForest 和 SVC 比我们看到的 PyCaret 和 TPOT 等更复杂的库得到了更好的结果。还记得我说过我们可以使用 scikit-learn 轻松复制这些结果吗？为什么我们不这样做，这样我们就可以看到结果是否相似？让我们使用 ExtraTree 分类器模型来检查一下。

**# Importing ExtraTreeClassifier**
from sklearn.ensemble import ExtraTreesClassifier**# Fitting and predicting model**
clf = ExtraTreesClassifier(n_estimators=100, random_state=0)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)**# Checking score**
from sklearn.metrics import accuracy_score
accuracy_score(y_test, y_pred)

作者图片

LazyPredict 返回 0.82 分，scikit-learn 返回 0.817 分。那是非常接近的。我对 LazyPredict 的出色表现感到惊讶。你明白我为什么要把 LazyPredict 写进这个博客吗？

结论

PyCaret、TPOT 和 LazyPredict 是每个数据科学家都应该知道的三个优秀的库。虽然它们不能取代数据科学家的工作，但它们可以节省我们的工作时间。我不会使用他们的结果作为最终模型，但我总是在我的管道中包括至少一个。它们都易于使用，并且包含完整的文档。

我强烈建议你自己尝试一下，发现我在这篇博客中没有提到的特性。如果你了解到任何很酷的功能，请告诉我。你知道我应该在我的下一个模型中包括任何其他机器学习库吗？

你可能也会喜欢…

5 个你不知道但应该知道的 Python 库 4 个你应该知道的很酷的 Python 库3 个你应该知道的很牛逼的 Python 库

用 Python 有效读取 CSV 数据的 3(半)个强大技巧

原文：https://towardsdatascience.com/3-and-half-powerful-tricks-to-effectively-read-csv-data-in-python-c4699a4f9d07?source=collection_archive---------33-----------------------

编程；编排

熊猫大师 read_csv()参数轻松提升您的分析能力

照片由内容 Pixie 在 Unsplash 上拍摄

将逗号分隔值(csv)文件读入 DataFrame！

数据分析的第一步是将数据导入 Python pandas 数据框架。然后探索和清理它。

在将数据加载到 DataFrame 中时，可以使用一些技巧来减少工作量。

在这 3 分钟里，你将掌握 3 种有效使用**pandas.read_csv()**的方法。💡

为了演示，我使用了来自 Kaggle 的 FIFA 2021 数据集 。先睹为快的数据集在这里。

FIFA 2021 数据集|作者图片

我们来探讨一下，如何使用pandas.read_csv()有效地导入这个文件。

1.用途

pandas.read_csv()中的参数usecols对于仅加载 csv 数据集中的特定列非常有用。

下面是有无usecols的情况下read_csv()所用时间的直接对比

pandas.read_csv() usecols |作者图片

正在导入*。csv* 文件到熊猫数据帧使用usecols是⚡️ 2.4X ⚡️比导入整个数据集快。

与其导入整个数据集然后删除不必要的列，不如只加载所需的数据。

2.组块大小

加载大型数据集的有效方法是将其加载到小部分中，即块中。💡

大型数据集的大小为千兆字节，行数超过数十万，通常需要很长时间才能加载到 Pandas 数据帧中。

熊猫 read_csv() chunksize |作者图片

直接比较显示使用chunksize比普通的数据导入要快得多。

但是，有一个条件！！！ ⚠️

在pandas.read_csv()中包含参数chunksize返回一个TextFileReader对象进行迭代。♻️

熊猫 read_csv() chunksize |图片 bu 作者

然后您需要使用**pandas.concat()**将所有的块放在一起，形成一个完整的数据帧。这可以如下进行，

连接熊猫数据帧|作者图片中的所有块

这无疑使得分块加载数据比直接读取整个数据集要慢，但在加载高达数十 GB 的文件时却很有效。

3.解析日期

通常，包含日期-时间数据的列作为对象或字符串导入。然后我们需要手动改变它的数据类型。

使用参数parse_dates来指出哪些列包含read_csv()本身的日期时间数据是个好主意。

pandas.read_csv() parse_dates |作者图片

🚩当多个列包含日期时间数据时，只需将所有列名作为列表传递给parse_dates。

3(半):用单独的日-月-年列制作一个日期列

当日期数据分布在多个列中时，也可以将它们组合在一起，形成一个包含日期值的列。

Pandas.read_csv() |作者图片

将列名作为 list 传递给parse_dates以生成一个包含日期值的列。

pandas.read_csv() parse_dates |作者图片

🚩组合这些列形成日期列的默认顺序是**year-month-day**。

总结一下，

掌握这些技巧，并明智地使用它们，可以减少数据清理中的工作，使数据分析更快。

与分块导入数据类似，您可以分块学习数据科学技能，Medium 是最适合的地方。

您可以通过下面我的推荐链接获得对媒体的完全访问权限，并阅读由我&成千上万的其他人分享的如此惊人的内容。当你加入我的链接，我会得到你的会员费的一小部分作为支持，没有任何费用给你。

https://medium.com/@17.rsuraj/membership

随时加入我的 邮箱列表 保持更新！

感谢您阅读并投入您宝贵的时间！

你应该知道的数据科学课程中遗漏的 3 个方面

原文：https://towardsdatascience.com/3-areas-missing-from-data-science-courses-you-should-know-55d4209e7db2?source=collection_archive---------36-----------------------

理查德·弗里曼博士

凭借机器学习博士学位和 18 年的应用经验，有抱负的数据科学家问我，他们可以做些什么来提升技能。鉴于我担任导师/顾问、首席技术官以及大数据和机器学习工程、AWS 云计算和自然语言处理(NLP)方面的知识，我希望与更广泛的受众分享我的学习和见解。

我看到的第一件事是，他们只会专注于 ML / NLP / Deep Learning (DL)模型的玩具数据问题的课程或教程，这是一个好的开始。但是这还不够，因为有三个重要的领域是你在数据科学课程或某些大学学位中通常找不到的。原因可能是他们更难教，需要行业经验。在这里，我不是在谈论干净的数据科学教程或研究问题，而是大多数组织都有的典型的现实世界业务数据科学问题。

数据准备

你会经常听说数据科学是 21 世纪最性感的工作，但你很少听说数据科学家 80%的时间花在数据准备上，这是很容易被遗忘的一面，因为很难营销和宣传它，但它是一个必须做的重要基础。

什么是数据准备，它可以是刮擦、清理、标准化、连接、填充缺失数据、向量化、旋转、标记等等。数据集。这一点很重要，因为使用 ML 而不是基于规则的算法的全部意义在于，你要基于数据来训练/测试它。没有干净的数据，即使最先进的 DL 模型也无法运行。

一个问题是，那里的数据集通常已经是干净的，并且有一个训练/测试集，所以给人一种错觉，你可以简单地用最少的准备直接应用你的 ML/NLP/DL 模型。在现实世界中，数据非常脏，需要连接、丰富或创建复合要素。

你能做什么？

成为用熊猫做数据准备的专家，如果你想规模化就用 pySpark。为什么要把修理的权力和依赖交给别人呢？

如果您也看看数据分析师做什么，他们清理 Excel、SQL 或 ETL 工具中的数据以创建分析仪表板，这是一个类似的任务，但理想情况下是以代码和规模进行。例如，有时您可以使用基于规则的方法或 NLP 来清理姓名、地址或日期。无论您是想为客户做分析报告，还是在数据科学模型中使用 is 培训/测试/验证集，都需要这样做。

不要低估 SQL 在您的工具包中的威力，您可以轻松地连接表，而不需要依赖其他人来查询和提取数据。我发现很多时候，使用 SQL 直接查询 Amazon Redshift 比编写一些 Python 代码要快。

领域知识

尽管数据科学家的许多技能可以移植到任何行业，但你仍然需要获得行业特定的知识才能有效。

例如，想象一下，你希望有人创建一个预测股票市场价格的数据科学模型，并且你投入一年的工资作为投资，以便模型决定购买/出售/做空哪些股票。现在想象一下，你让一名初级数据科学家做这件事，而他们在投资银行或金融服务方面没有任何经验，在你的年薪面临风险的情况下，你对该模型预测最佳股票的信心有多大？

这就是为什么没有领域知识，你的模型很可能不准确或没有意义。您将如何验证/衡量它？你真的知道你的客户/用户想要什么吗？有时，他们会有基于规则的算法，可以执行得更好，更容易解释，可以作为你在推理中做什么的基线。

你还会看到，除非你是一个研究机构，否则企业关注的主要问题是投资回报率(ROI):在我看来，这基本上是为了节省时间、省钱或赚钱。然后将这些映射回您正在进行的基于数据科学的推理。我解释了一些这方面的内容，以及根据我的经验什么时候你应该不使用人工智能而使用它。

技术和数据科学是实现这些投资回报指标的新手段之一。除非你有研究重点，否则大多数公司不会介意你使用最新的深度学习或强化学习，并且会优先考虑预训练或更简单的模型，这些模型可以更快地上市并产生 ROI，特别是当你使用大规模 GPU 服务器和云计算进行训练时，成本可能会很高。

我能怎么做呢？

在我看来，你应该对你工作的领域/领域充满热情，这将有助于你成为专家。当您选择一个行业时，深入了解领域知识，这适用于 FinTech、IsureTech、AdTech、AgroTech、MedTech、PropTech。查看现有的数据模型、客户需求、术语以及分析/数据科学的应用。

我的是医疗保健，因为我认为它对人类有巨大的积极影响，并且用例非常开放，具有挑战性。

获得技能的方法是与领域专家一起工作，阅读大量特定领域的内容，并获得处理特定行业数据的经验。

软件工程

现在你已经有了数据准备和领域知识，最后一个支柱是软件工程。

做得好，您可以在 Jupyter 笔记本中的玩具数据上本地执行样本 scikit-learn 和 Keras 代码！这对于洞察、探索性数据分析和演示很有用，但真正的投资回报是当你将你的模型转移到客户或用户直接使用的管道、产品或服务中。例如，假设一个用户访问你的网站，你将实时推荐最相关的内容，这将导致更高的用户保留率，更高的点击率或购买量。要正确地做到这一点，你需要像优秀的开发人员一样编写、测试和部署你的代码和模型。您的代码必须具有伸缩性。

例如，当我在 JustGiving 领导数据科学团队时，我们有对 2600 万用户进行实时预测的模型，代码作为服务部署在具有超低延迟的高度可用和可扩展的架构上。

当您操作 ML 模型时，有许多元素开始发挥作用，如 API、模型版本、模型准确性监控、特征存储、数据流入/流出等。此外，如果您在追求最小可行产品(MVP ),您很可能会使用预先训练的模型和/或现有的推理 API，这将需要开发技能。

我能怎么做呢？

特别是如果你不是计算机科学背景，如果你只直接学过数据科学课程，那么你接触开发或软件工程的机会将是有限的。与优秀的开发人员一起工作，提升自己的开发技能，包括测试、设计模式、Docker、AWS 等云平台和 CI/CD。许多核心技能都与数据和机器学习工程有关——对我来说，这些是紧缺人才，而不是数据科学家。我认为原因是，对于非开发人员或计算机科学背景的人来说，进入门槛会很高。不管怎样，你的代码越好，你就能越快地准备数据或者解决实际的用例。

摘要

在我看来，数据科学领域如此受欢迎，因为它似乎向所有人开放，而且很性感，但当你深入挖掘并在现实世界中工作时，你会发现你需要大量的数据准备技能、领域知识和软件工程技能，这些技能经常被遗忘，但却是必需的。致力于这三大支柱将使你成为一名更好的数据科学家，特别是随着领域的成熟，用例变得更加复杂，并且你在团队中工作。要了解更多我的观点，请阅读我的另一篇文章，如根据我的个人经验对从事数据科学、人工智能和大数据工作的建议。祝你好运，如果你有问题或意见，请给我发消息。

面试系列第一部分:使用这些技巧通过技术数据科学面试！

原文：https://towardsdatascience.com/3-areas-that-helped-me-in-passing-machine-learning-interview-75c7edca66bc?source=collection_archive---------13-----------------------

机器学习/数据科学面试系列—技术面试

我写这个博客系列是为了分享我在申请数据科学家/机器学习工程师和面试不同公司的职位时所学到的知识。我申请工作已经快 5 年了，自从我上次面试以来，事情发生了巨大的变化。这个行业发生了巨大的变化。这感觉有点像未知领域，但最终，我找到了整个过程的窍门。我学到了很多新东西，并与应用机器学习的不同行业领域的专家进行了愉快的交谈。

我将在这篇文章中具体谈谈我的技术面试经历。

在 Unsplash 上由Christina @ wocintechchat.com拍摄的照片

数据科学/机器学习中的技术讨论有时很难“预测”😉。技术面试将主要取决于工作描述和所需的经验。可能出现的问题范围很广。然而，在大多数职位中，雇主的目标始终是让求职者了解某一特定理论或应用的基础知识。没有人会要求从零开始推导/编写算法！但是他们希望了解在哪里、为什么以及何时使用特定的技术或算法。

面试的总轮数和持续时间因公司而异。通常会有 3-4 轮，每轮最多持续一个小时。根据我的几次采访，我认为采访可以分为三个不同的类别:

探索你的简历/经历
机器学习和统计问题
编码挑战

👉一、探索你的简历/经历:

马库斯·温克勒在 Unsplash 上拍摄的照片

每一位面试官都会简短地提到你的简历，可能不是整个小时，而是 5-7 分钟。谈论过去的工作和经历很容易解决。除非你认为简历中的某个特定部分在你申请的工作中过于重要，否则你不需要投入太多时间去准备。我想分享我经历过的各种事情，并分成几个部分:

面试官可能会要求解释你的任何项目:

试着准备一个你最喜欢或者曾经密切合作过的项目。以有条理的方式解释整个项目。你必须按顺序解释，以显示你的组织能力。缺乏条理会让面试官感到困惑，而且可能会让你失分。如果我从头到尾解释任何一个项目，我通常会尝试分成几个部分:

数据来源/收集
数据格式
清洁
探测
建模
估价
生产化

尽量简短，最多在 4-5 分钟内解释清楚。过于简洁或过于冗长都不会给人留下好印象。如果面试官对某个特定的话题感兴趣，他们会详细介绍职位描述中的职责。所以一定要彻底！你可以随时问面试官你是否愿意详细解释一些事情。

2.面试官基于兴趣的项目:

面试官可能会要求你谈一个他们感兴趣的或者与你申请的工作相关的项目。答案可以类似于顶题。但是在你提到的一些项目中，你的贡献可能比其他项目要少。然而，你必须对每一个项目和你的贡献彻底！在简历中提及并且难以解释，可以向雇主举起一面红旗。

3.工具/技术:

你可能提到过一些你熟悉的包、方法、工具、云环境，比如 Azure、AWS 或 GCP。准备好详细解释你熟悉他们的哪些事情。当然，你将通过一段时间的努力来建立这种形象，但是开始并努力成为多方面的全才可以让你获得高分！多样化的数据科学家/机器学习工程师是首选，而不是只在一个狭窄领域有经验的候选人。

4.向数据科学过渡:

数据科学/机器学习是一个独特的领域，来自不同背景的人已经向它们过渡。毫无疑问，学科专家比任何人都更了解他们领域的数据。然而，这可能会引起一些雇主的好奇；为什么是数据科学？或者说你是如何开始你的数据科学生涯的？为此准备好一个好的答案。不要只是说——“它正在蓬勃发展，所以我进入了它”或“我想尝试一下”。不要！记住你给雇主的每一个答案都是令人信服的，让你离终点更近。准备好一个伟大的解决方案！

确保你在简历中只写你做过或知道的事情。不要虚张声势！

👉二。ML & Stats 问题:

在 Unsplash 上由 Hitesh Choudhary 拍摄的照片

机器学习和统计问题是面试的一个组成部分。这是一把大伞，可以提出各种各样的问题！

**算法&统计问题:**基于算法的问题可以非常多样。正如我之前提到的，他们会评估你对某个问题的理论和应用知识。面试官可能会问算法是如何工作的，但不会要求你从头推导。我遇到的一些问题是:

XGBoost 和 LightGBM 有什么区别？工作是什么样的？哪个更好，为什么？
什么是正规化？为什么需要它？
L1 和 L2 正规化的区别？哪个更好？
基于树的和梯度提升的方法有什么区别？
线性回归的假设有哪些？
什么是偏差-方差权衡？
什么是 t 检验、正态分布等？
根据添加到数据集中的新数据点，平均值和中值将如何变化？

如果你想有一个可以提问的问题列表，有各种各样的资源可以利用。

**度量标准:**了解和理解回归、分类或时间序列类问题中常用的度量标准至关重要。例如，在分类问题上，他们可能会问:

什么是混淆矩阵？
什么时候应该使用精确度、回忆或 F1 分数？
当数据集的类别高度不平衡时，有什么更好的指标可以使用？
为什么要使用特定类型的指标？

这些都是基本问题，面试通常会涉及这类问题。我想在这里提一下我喜欢的各种资源:

https://elitedata science . com/machine-learning-interview-questions-answers
https://www . simpli learn . com/tutorials/machine-learning-tutorial/machine-learning-interview-questions
杰伦有一个 youtube 频道和大量的好建议:https://www.youtube.com/channel/UCcQx1UnmorvmSEZef4X7-6g

👉三。编码挑战:

丹尼尔·伊德里在 Unsplash 上的照片

编码挑战可能主要基于 Python 或 SQL 语言。一些组织可能会大量使用 SQL，所以他们会严格执行基于 SQL 的测试。然而，到目前为止，我所经历的编码挑战有两种不同的方式。两者都有可能发生，或者在某些情况下，两者都有可能发生。举几个例子，它们是:

关于有时间限制的编码平台:有 CodeSignal、HackerRank 等几个平台。雇主可以在特定的时间间隔内提出一系列固定的问题。问题简单，解释详细。在某些情况下提供了示例。这些问题可以是简单的问题要求，用来测试你的逻辑技能和解决问题的方法。

写一个程序来得到一个指定范围内所有素数的总数。
写一个程序来计算 2 位数的偶数。

2.与面试官一起编码:如果你要与面试官一起编码，那将是非常互动的。解释你的逻辑或者你的思维过程是明智的。如果你被卡住了，面试官通常会通过提供提示和必要的警告来让你的工作变得容易。不要认为你需要写功能代码！这是这种采访的错误印象。正如我之前提到的，面试官会像你的朋友一样，只评估你是如何处理问题的，如果你能以一种非常简单的方式编写代码并且足够干净的话。效率是值得赞赏的，但考虑到时间紧迫，这可能是不必要的！我看到 coderpad.io 通常是最受欢迎的程序，但它可以根据组织或面试官的选择而有所不同。

在一些面试中，面试官会给你提供数据集。他会提问，期待你对数据进行运算，为面试官提供解决方案。它可能只是运行一个假设的情况或问题，类似于组织内部使用的情况或问题。

温馨提示:

先阅读/理解问题，再直接跳转解决。当你意识到预期的结果是不同的时候，可能已经太晚了。
不要马上让你的代码变得高效！尝试通过所有的测试用例。目标是看你能不能快速写出一个管用的程序！
如果你不能完成所有的挑战也没关系。试着从最难的开始尝试所有的方法。即使你写了一个像样的代码，表现出你会写代码，给人的印象也很好！

最后，我想说，永不放弃！继续努力，接受采访，对自己有信心。你会进入你最喜欢的数据科学职位。希望这些建议能对你的求职有所帮助！还会有更多..敬请期待！

在推特或 LinkedIn 上关注我。你也可以通过 pratikkgandhi@gmail.com 联系我

想成为 中等会员 享受无限制阅读文章，请注册会员。Medium 将与我分享一部分给使用以上链接注册的成员！谢了。

你应该知道的 3 个很棒的 Python 库

原文：https://towardsdatascience.com/3-awesome-python-libraries-that-you-should-know-about-e2485e6e1cbe?source=collection_archive---------4-----------------------

大蟒

发现三个很酷的库，以及为什么你应该马上尝试它们

克里斯蒂娜·莫里路拍摄的图片。来源: Pexels

前几天我发表了一篇关于 5 个你不知道，但应该的 Python 库的博客。那个博客在不到一周的时间里有数万次浏览。因此，我决定写第二部分，介绍一些您应该尝试的很酷的库。

Python 是计算领域最流行的语言之一。其中一个主要原因是，它包含了数百个开源库，可以让我们的生活变得更加轻松。人们关注更受欢迎(也更可靠)的库。然而，其他不太知名的图书馆可以节省你的宝贵时间。也就是说，让我们看看一些很酷的图书馆，如果你不知道，你会错过的。哦，最后我会有奖金推荐的。

懒惰预测

LazyPredict 是我今天榜单上的最爱。我过去写过关于它的博客，我永远也看不够。LazyPredict 是一个低代码机器学习库，允许您用两行代码运行多达 40 个基线模型。是因为效果出奇的好。

最酷的部分是它使用 Sklearn，允许你获得模型，看看什么最适合你，并像你通常做的那样进行 hypertune。要安装，你可以在你的终端输入pip install lazypredict，你就可以开始了。下图将展示如何同时运行 30 个模型。在这个演示中，我使用了泰坦尼克号数据集。

**# Importing the packages that we will use**
import lazypredict
from lazypredict.Supervised import LazyClassifier**# Running all the models**
clf = LazyClassifier(verbose=0,ignore_warnings=True)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
models

作者图片

此时，您可能会想:刚刚发生了什么？嗯，我做了一个训练测试分割，就像我通常会做的那样，然后我导入了 LazyPredict，建立了迭代，并检查了模型。运行所有这些模型不到 3 秒钟！最后，LazyPredict 返回一个带有一些指标的 DataFrame，比如准确性、ROC AUC 和 F1-Score。这是最后一部分的样子。

作者图片

好得难以置信，对吧？怎么才能知道这些结果是正确的呢？因为 LazyPredict 使用 scikit-learn，我们可以在运行我们的模型时测试它。让我们看看我们得到了什么。

他者形象

答对了。如果您将上面的结果与我们用 LazyPredict 得到的结果进行比较，您会发现结果非常相似。如果您不知道哪些模型最适合您的项目，LazyPredict 会非常方便。但是，我不推荐你的最终模型使用 LazyPredict。

LazyPredict 有所帮助，但不能取代数据科学家的工作。如果你想了解更多关于 LazyPredict 的内容，你可以在我的博客中找到关于它的这里和这里。如果你是西班牙语使用者，你可以在这里找到西班牙语版。

勒克斯

Lux 是另一个可以节省你很多时间的库。简而言之，Lux 是一个低代码库，它允许我们通过一次点击创建数据可视化来进行快速简单的数据探索。最酷的部分是 Lux 决定向您的数据集推荐什么可视化，而无需您做出决定。你可以在你的终端中输入pip install lux-api来安装它。让我们检查一个快速演示。

作者图片

就这么简单。你点击一下，瞧，你有你的结果。对于这个数据集，Lux 返回了相关性、分布、发生率和时间序列的可视化结果。如果你想检查特定的功能，你也可以很容易地做到这一点。为此，您可以键入dataframe**.intent(**column_1, column_2**)** 。我强烈建议你尝试一下。如果你想了解更多关于 Lux 的信息，你可以在这里找到我的博客。这是我最受欢迎的博客之一，试用者的反馈非常积极。

黑色

Black 是一个代码格式化程序，可以让你的代码看起来更好。这不是一个库，而是一个方便的扩展。大多数情况下，Python 不关心代码中的空格。然而，当您在一行代码中同时输入 140 个字符时，很难理解会发生什么。这不是最佳实践，有些人并不关心它。

另一种情况是当你从其他人那里得到代码时，很难理解发生了什么。布莱克是来帮忙的。老实说，我不使用黑色，因为我试图编写干净、易读的代码。然而，当我需要审查某人的代码时，我需要在 90%的情况下使用黑色。

要安装，可以输入pip install nb_black，应该就可以了。要使用它，你只需要输入一次%load_ext nb_black，每运行一个单元格，Black 就会自动格式化你的代码。让我们用一个我从 LazyPredict 部分得到的例子来探究一下。代码没有空格。然而，当我运行单元格时，Black 会自动添加空格，使代码看起来更好。

作者图片

你能看出区别吗？让我们仔细看看。

运行单元前:

作者图片

运行单元后:

作者图片

如果您能看到不同之处，您就理解了这种最佳实践的重要性，并且会很乐意将这种扩展用于其他人的代码。如果你看不出区别…好吧，那你应该马上开始用黑色！

我的看法是代码看起来好多了！很容易阅读和理解正在发生的事情。这是一个小演示。然而，对于更多的扩展代码，这有很大的不同。

额外小费

在写这篇博客的时候，我想检查一下图书馆是否还在接收更新。我通常会单独查找每个库的最新版本是什么，以及它是否与我拥有的版本相匹配。听起来工作量很大。让我惊讶的是，我发现了一个解决这个问题的网站，我不得不分享一下。

Snyk 开源顾问帮助我们搜索库，检查它们的版本，它们的受欢迎程度，保持更新，它们的 README 页面，并发现类似的库。它与 PyPI 一起工作。因此，您可以同时检查 PyPI。都在一个好看的网站。

作者图片

它看起来很好，我不得不把它放在这里。我最喜欢的一些特性是包健康评分和维护。为什么我以前没发现这个？

分析 Lux 的页面，我们可以看到它正在定期快速更新，其最流行的版本是 0.3.0。多酷啊。

作者图片

结论

我们的时间是宝贵的，我们应该充分利用它。这些 Python 库可以方便您的下一个项目，我强烈建议您尝试一下。这样，您就可以将宝贵的时间投入到其他任务中，比如 hypertunning 您的模型。这些图书馆都不应该取代专业人员。

它们应该被视为改进我们工作的一种方式。我不建议你只依赖这些库，而是把它们作为一个附加组件。感谢阅读，并让我知道什么图书馆不在这个列表中。下次我可能会写一写。编码快乐！

你可能也会喜欢…

5 个你不知道的 Python 库，但应该知道的 4 个你应该知道的很酷的 Python 库3 个你应该知道的低代码 Python 库

每个分析师的工具箱里都应该有 3 个 Ggplot 图表

原文：https://towardsdatascience.com/3-basic-visualisations-that-should-be-in-every-analysts-toolbox-and-how-to-enhance-them-4ecb0d251e7?source=collection_archive---------34-----------------------

充分利用 ggplot2 中的颜色、形状和轴来增强 3 个基本图表；+r 中数据分析师的最佳实践。

作为分析师，我们的工作是从我们组织拥有的数据中获得洞察力。通常这来自上面的一个问题和我们的工作是决定用好的数据可视化(也就是图表)来回答这些问题的最佳方式。在我作为数据分析师工作一周年之际，我回顾了我收到的常见请求，以及我为回应这些请求而设计的图表。

本文接下来的内容是*“如何指导”(1)完成分析的逻辑，以及(2)在 r 中构建相应的可视化。最后，我分享了在编写这些图表时的最佳实践，以提高您的代码在响应这些常见请求时的寿命*。我希望这些对您作为数据分析师的工作有用！

使用以下三个图表增强您的数据分析工具箱。 照片由 苏珊·霍尔特·辛普森拍下

每位分析师都会被问到的 3 个问题:

1。“随着时间的推移，X 组之间 Y 的组成是如何变化的？”→参见三维图

2。“有什么重大变化吗？”→参见复合棒+点图

3。“一段时间以来的趋势是什么？”→参见增强型同比图

每个分析请求的相应可视化。下面我们将通过一步一步的指导来制作这些图表！

在开始之前

虚拟数据用于以下示例，，即所有数据都是虚构的，任何与现实的相似之处纯属巧合。
R 中的tidyverse包带有方便的管道操作符(%>%)，这使得数据准备快速，代码简洁。因此，对于下面的图表，我们将需要这两个包:

*## import packages in R
library(ggplot2)
library(tidyverse) # for data preparation*

分析 1:用簇状堆积条形图展示 3 个维度

考虑以下场景

有两个区域:A 和 B
每个地区有 3 类植物:草、花和树
每个季度都会测量植物群的数量:从 2018 年 Q1 到 2020 年第四季度

有三个维度，region、category和time。我们可以使用堆积条形图的聚类来可视化每个维度的趋势。

三维图表

步骤 1:数据准备—透视数据集

数据集:虚拟数据

您的数据可能看起来像左边的表 dummy_data。dummy_data还没有准备好输入到 ggplot 代码中，我们首先必须首先使“区域”成为数据集中的一列，而不是 A 和 B 分开。这在 R 中用gather函数很容易做到。

*dummy_data_long <- gather(dummy_data, # existing dataset
                          `Region`, # give a name for the keys
                          count, # give a name for the values
                          A:B, # columns to get the keys
                          factor_key = TRUE) # store keys as factors## add a 'total' column, will be used for label on top of bars
dummy_data_long_w_total <- dummy_data_long %>% 
  group_by(quarter, Region) %>%
  mutate(Total = sum(count))*

***数据集:*虚拟 _ 数据 _ 长 _ 宽 _ 总

步骤 2:创建堆积条形图——比较每个区域的类别

使用geom_bar创建 ggplot 中的条形图。只需在geom_bar()中指定position = 'stack'即可启用堆叠功能。

然后，通过使用aes中的fill参数，ggplot 知道根据category字段给条形图加阴影。因为我们已经指定了position = stack，每个category的条将被堆叠而不是并排放置。

*# geom_bar() for bar chartsstacked_bar <- geom_bar(data = dummy_data_long_w_total,
                        aes(y = count, x = `Region`, 
                            fill = factor(category,
                             levels = c('Grass','Trees','Flowers')) 
                        ),
                        stat='identity',
                        position = 'stack') # STACKING DONE HEREfill_colours_category <- scale_fill_manual(values = 
                      c('Trees' = "#ed7d31", # excel orange 
                      'Flowers' = "#4472c4", # excel blue
                      'Grass' = "#a5a5a5")) # excel grey*

第三步:对堆积条形图进行聚类

ggplot 允许我们将各种geom组件“添加”在一起，因此为了创建最终的图表，我们可以将上面创建的stacked_bar添加到其他格式行，这就是我们将如何实现聚类效果。

下面代码中的函数facet_grid()告诉绘图为我们的时间变量quarter创建一个堆积条形图。

*ggplot() +
  stacked_bar + 
  fill_colours_category +
  facet_grid(~quarter) +  # CLUSTERING DONE HERE
  scale_y_continuous(breaks = seq(0,15000, by=2500),
                     limits = c(0,15000),
                     expand = c(0,0)) +
  labs(y = 'Area of Nature',
       x = 'Region',
       title = 'Breakdown of Nature between 
                Regions A and B over Time',
       fill = 'Type of Nature' )+
  bar_total_labels + ## see below for this code 
  chart_1_theme ## a theme() ob*

只要你有一个variable_to_cluster_by，通过用你的图表替换stacked_bar并在末尾添加facet_grid()，你可以很容易地用任何其他图表(如折线图)复制这种聚类效果。

【额外】我还在剧情末尾加了一个 *bar_total_labels* 和 *chart_1_theme* ，格式化了剧情的审美。 *bar_total_labels* 是一个 *geom_text* 对象，而 *chart_1_theme* 是一个 [*theme*](https://ggplot2.tidyverse.org/reference/theme.html) 对象，你可以自定义(如果你想复制上面的主题，见代码结束)。

**# the labels in the chart
bar_total_labels <- geom_text(data = dummy_data_long_w_total,
 aes(label = ceiling(Total),
 y = Total, x = `Region`,
 fontface = 2),
 size = 4,
 vjust = -0.5)**

TLDR；绘制三维图表
---R 的-*gather*-函数对数据准备很有用
-使用-*facet_grid*-为您的图表添加第三维**

分析 2:混合不同的几何图形来标记随时间的显著变化

考虑以下场景:

你的公司销售一些产品，电话，电视，笔记本电脑等。每周都会收集售出的数量。
您想要确定最近一周每种产品的销售量是否有显著变化。

一个全面的数据可视化将解决以下 3 个问题
(1)当前的销售量是多少
(2)以前销售量的基准
(3)是否有重大变化。

下面的图表用颜色和几何图形来解决这些问题。

利用点和棒线来充分利用一个图表。

步骤 1:数据准备—标出重大变更

你如何定义“重大”实际上取决于你自己的经营环境，没有正确的答案。对于这个例子，我认为显著是指一年中与weekly average的偏差超过 2 standard deviations (sd)，以使每周的交易量波动均匀。

dummy_data_2: 起始数据集。您需要首先计算这些字段。

***dummy _ data _ 2 _ flaged:*使用 tidyverse 轻松计算偏差。

*dummy_data_2_flagged <- dummy_data_2 %>% 
  mutate(
Flag = case_when(
Volume > average+2*sd ~ 'Higher',    
Volume < average-2*sd ~ 'Lower',                   
 T                    ~ 
'No significant deviation'))*

使用tidyverse中的mutate和case_when功能，轻松计算每个产品的偏差。

第二步:用条形的颜色标出偏差

与图表 1 类似，我们使用geom_bar()来创建条形图。为了用变量Flag给条着色，我们在aes下指定了fill = Flag。与图表 1 不同，我们没有指定一个position，因此条形没有堆叠。

提示:我已经设置了 *y = reorder(Item, Volume)* ，所以条块按照 *Volume* 降序排列。

*# standard ggplot bar chartrecent_volume_bars <- geom_bar(aes(y = reorder(Item, Volume), 
                                   x = Volume,
                                   fill = Flag),
                               stat = 'identity',
                               width = 0.7) ## set colours for the bars based on deviationflag_colours = c('Higher' = '#2c4b01',
                 'Lower' = '#8b0000',
                 'No significant deviation' = '#23395d')fill_colours_flag <- scale_fill_manual(values = flag_colours)*

【额外】在条形上添加标签，显示最近一周的成交量

**label_on_bars <- geom_text(aes(label = Volume,
                               y = reorder(Item, Volume),
                               x = Volume),
                           position = position_stack(vjust=0.5),
                           color = 'white', size=6)**

第三步:用不同的几何图形表示平均周成交量

使用geom_point，我们创建一个反映平均值的点图。这给了读者一个很好的偏差比较点！

*average_point <- geom_point(aes(y = reorder(Item, Volume),
                                x = average),
                            stat = 'identity', 
                            size = 6, alpha = 0.7,
                            fill = 'white', stroke = 1,
                            shape = 21)*

步骤 4:为点添加图例

现在我们的图表上有多个元素，我们需要一种方法来解释图表上的点是什么意思。

从第 2 步开始，在条形美学(aes)下指定fill = Flag会创建一个相应的图例来解释每种颜色的含义。但是对于我的点，我实际上不希望任何点的颜色不同。因此，我没有分配一个字段colour，这将使点的颜色因字段而异，而是将我想要显示的文本作为图例标题。因此，在步骤 3 的aes下添加colour = “Average weekly volume over past year"会产生以下图例:

图表显示了 geom_point 的图例，以向读者表明该点与条形有何不同。即使任何轴上的点都没有区别，也是如此。

由于我们将colour参数用于此“非预期”目的，因此需要进行几次“清理”:

使用scale_colour_manual(values = c(‘black’))为圆指定所需的颜色

在 labs 下指定 colour = NULL，以避免显示单词 colour

在最终图表中的labs()下指定colour = NULL，这样“颜色”一词就不会显示出来。

*# Add all the elements together 
ggplot(dummy_data_2_flagged)+
  recent_volume_bars +
  fill_colours_flag +
  label_on_bars + 
  average_point + 
  scale_colour_manual(values = c('black'))+
  theme_deviation_chart +             # define theme() as you like 
  labs(title = paste('Volume sold in past week'),
       fill = "Deviation in recent week:",
       colour= NULL)*

【给感兴趣的读者】 你可能会奇怪为什么专门要用 *colour* 而不是其他的美学比如*fill**size**shape**alpha*等等。****

我们可以用 *fill* 审美代替 *colour* ，指定 *scale_fill_manual(values = c('white')* 。然而 *fill* 已经在我们的酒吧中使用，表示会干扰“清理”的偏差。我已经尝试使用 *shape* 和 *size* 但无法成功“清理”，很想听听是否有人对此有解决方案！

TLDR；复合条形图和点数图 -利用 ggplot 中的不同元素用一个图表讲述更多内容
-通过使用几何图形的美感在 ggplot 中添加几何图形的图例。****

分析三:增强同比图

同比图表是任何分析师工具箱中的主要工具，因为它能够反映最近的趋势和季节性。在 ggplot 中，基本的同比图表非常直观。通过在 geom_line 中指定一个“组”变量，我们立即得到下面的图。

ggplot 中的基本同比图…可以改进

但是通过一点点处理和 ggplot 的元素，我们可以通过:
(1)将日期周期添加到 x 轴和

(2)遮蔽感兴趣的时间段。

步骤 1:数据准备-格式化 2021 年每周的日期范围

一年中的星期并不是最直观的，所以添加 2021 年每周的日期范围将让读者更好地了解一段时间内的趋势。为此，我们将在 R 中创建一个 dataframe，将 2021 年的每周映射到一个日期范围。在本例中，一周从星期六开始，到星期五结束。

****# create a column for each date in 2021 
dates2021 <- as.data.frame(x=seq(as.Date("2021-01-01"), as.Date("2021-12-31"), by="days"))
colnames(dates2021) <- 'Date'first_sat_2021 <- as.Date('2021-01-02') # date to start year# Match each date to a week of 2021 (1 - 52) 
weeks_2021 <- dates2021 %>% 
  mutate(Week = floor(as.numeric(difftime(Date, first_sat_2021, units = "weeks")))+1,
         Year = 2021) %>%
  filter(Week > 0)****

周 _ 周期 _2021

重复上面的代码，为 2020 年做同样的事情

将每个日期与一周匹配后，使用group_by功能为一年中的每一周格式化一个日期范围。

****week_periods_2021 <- weeks_2021 %>% 
  group_by(Week) %>% 
  summarise(
week_start_date = first(Date),
week_end_date = last(Date)) %>% 
  mutate(
week_period = paste(
format(as.Date(
week_start_date),"%d %b"),
                                                   format(as.Date(week_end_date), "%d %b"),                      
sep = " - "),
                        Year = 2021)****

步骤 2:数据准备——获取每周的数量

假设你有每天卖出的产品数量，我们可以使用 R 的group_by和summarise很容易地得到每周卖出的*数量。***

****# Dataset with 2 cols: Date & Volume
dummy_data_vol <- read_csv('<YOUR DATASET>') %>%
  mutate(Date = as.Date(Date, format="%d/%m/%Y")) # Date to week mapping 
weeks_2020_2021 <- rbind(weeks_2020, weeks_2021)# Join the date to week mapping to your raw data, and calculate volume each week
volume_each_week <- dummy_data_vol %>%
  right_join(weeks_2020_2021, by = "Date") %>% 
  group_by(Year, Week) %>% 
  summarise(volume = sum(Volume)) %>% 
  ungroup() %>%
  mutate(Year = as.factor(Year))****

上面的代码将给出前 3 列。将此与步骤 1 中格式化的日期范围连接，以添加第 4 列。

data frame:volume _ each _ week _ dates，用于绘图

****# Add the 2021 date ranges to each week 
volume_each_week_dates <- volume_each_week %>% 
  left_join(week_periods_2021) %>% 
  mutate(week_period = as.Date(week_period))****

步骤 3:使用分组变量为每年绘制一条线

如上所述，使用geom_line()中的group变量来指定你想要绘制多行的字段。对于同比地块，此字段将为Year。此外，colour = Year被指定为不同的线条颜色。你也可以指定linetype = Year来区分线条的形状(如虚线、点线、粗体)。

****y_min = 40000
y_max = 80000basic_plot <- ggplot(volume_each_week_dates)+
  geom_line(aes(x = Week, y = volume,
                group = Year, colour = Year)) +
  scale_color_manual(values = c('2020' = "#95C8D8",
                                '2021' = "salmon4"))+
  labs(title = paste('Total Weekly Volume'),
       y = 'Weekly Volume',
       x = '2021 Weeks')+
  ylim(y_min, y_max) + 
  scale_x_continuous(breaks = volume_each_week_dates$Week,
                     labels = volume_each_week_dates$week_period,
                     guide = guide_axis(check.overlap=TRUE))+
  theme_trend_chart****

带日期范围的同比图

在scale_x_continuous下，指定在步骤 1 到labels中创建的日期范围，我们在左边得到相应的 x 轴。日期比第 1- 52 周更能让读者更直观地理解情节！

步骤 4:在图表中突出显示感兴趣的时间段

最后，为了增强基本线图，我们可以在 ggplot 中添加一个阴影矩形和相应的标签，以反映有趣的时间段，从而吸引读者的注意。用 ggplot 的附加结构也很容易做到这一点。

增强型同比图表

****## use dataset in step 1 to find the weeks of interest interesting_period_start = 13
interesting_period_end = 18## shaded rectangle
shaded_area <- geom_rect(
  aes(
    xmin = interesting_period_start,
    xmax = interesting_period_end,
    ymin = y_min,
    ymax = y_max
  ),
  fill = 'yellow',
  alpha = 0.01,
  color = NA
)## text label
shaded_area_label <- annotate(geom = 'label',
                 x = (interesting_period_start + interesting_period_end)/2, y = y_max, 
                 label = 'An interesting period in 2020',
                 size = 5, angle = 0,
                 fill = 'white', alpha = 0.8)## add this to the basic plot above
basic_plot + shaded_area + shaded_area_label## note: for bolder lines, add shaded_area before geom_line()****

TLDR:增强您的同比绘图 -在您的图表中为每个时间段创建日期范围
-使用 *geom_rect()* ggplot 对象添加阴影区域

增强 R 中的数据分析和可视化的主要收获

使用facet_grid()功能向图表添加第三维
在 ggplot 中混合不同的几何图形，用你的可视化表达更多；并利用aes参数为几何图形添加一个图例
对轴和标签进行一些数据预处理可以使你的可视化更具可读性

超越 viz —数据分析师的最佳实践

除了创建可视化之外，我发现花一些时间来确保代码的可读性是有用和值得的。当必须重现分析时，这将保持您自己和您的团队的理智。以下是提示的非详尽列表:

将图表开始时的 **theme()** 定义为变量。主题指定了图表的美感，如背景、网格线和大小。在代码的开头将theme()定义为一个变量，比如my_theme <- theme(<your input>)，然后将my_theme添加到每个图表中。如果您需要进行更改，尤其是如果您在一个报表中有多个图表，这将有助于提高代码的可读性和适应性。(我的每个图表的主题在下面的附件中。)
给你的代码加注释，并适当缩进。最后一条似乎很明显，但当试图匆忙做出分析时，有时会被遗忘。但是在这种情况下，一点点就足够了，当您需要重新查看代码时，您会感谢自己的！在 R 中，#用于注释代码。您可以使用至少 4 个标签在 RStudio 中创建可折叠的部分:
# This will create a collapsable section #####
保存图表时在文件名中添加日期。当您必须定期运行报告时，这有助于防止覆盖现有图表。如果代码在 2021 年 6 月 15 日运行，下面的代码将把一个名为your_chart的 ggplot 对象保存到 R 中的folder_path下。

****today <- as.character(Sys.Date(), “%y%m%d”)
plot.width = 35
plot.height = 15ggsave(filename = paste0("name_your_chart", today, ".jpeg"),
       plot = your_chart, path = folder_path,
       width = plot.width, height = plot.height, units = "cm")##[Extra] You can even code the date into folder_path so that a new folder is created each time you have to generate the charts! ##folder_path <-paste0(“~/Desktop/”, today)
if(!dir.exists(folder_path)){dir.create(folder_path)}****

就这些了，谢谢你的阅读和关注！我希望这些图表和概念也能在你作为数据分析师的旅程中派上用场。数据科学社区的开放和共享是我最喜欢的事情之一，所以如果你有任何建议或更好的方法来编码这些图表，请在下面留下评论。快乐分析！

附件:各图表主题代码

****chart_1_theme <- theme(
  panel.grid = element_blank(),
  panel.background = element_blank(),
  axis.title.y = element_text(size=12),
  axis.title.x = element_text(size = 12),
  legend.position = 'bottom',
  legend.title = element_text(size = 12),
  legend.text = element_text(size = 12),
  axis.text.x = element_text(size = 12),
  axis.text.y = element_text(size = 12),
  strip.text.x = element_text(size = 12)
)theme_deviation_chart = theme(
  axis.title.y = element_blank(),
  plot.title=element_text(size=20),
  plot.subtitle = element_text(size=16),
  axis.text.y = element_text(size = 16),
  legend.position = 'bottom',
  legend.title=element_text(size=16),
  panel.background = element_rect(fill="white", colour ="white"),
  panel.grid.major = element_line(size=0.5, linetype = "solid", colour="gray90"),
  legend.text = element_text(size=14)
)theme_trend_chart <- theme(
  axis.text.x = element_text(size = text_size, vjust=0.5, angle=90),
  axis.text.y = element_text(size = text_size),
  axis.title = element_text(size = text_size),
  axis.title.x = element_text(size = text_size),
  axis.ticks.y = element_line(linetype = "solid"),
  axis.ticks.x = element_line(linetype="solid"),
  plot.title=element_text(size=text_size),
  plot.subtitle =element_text(size=10),
  panel.background = element_rect(fill="white", colour ="white"),
  panel.grid.major = element_line(size=0.5, linetype = "solid", colour="gray90"),
  legend.text = element_text(size=text_size),
  legend.position = 'bottom')****

市场研究分析的 3 个基础

原文：https://towardsdatascience.com/3-basics-for-market-research-analysis-6ee5ee528a01?source=collection_archive---------24-----------------------

市场调研数据可以欺骗你。学习如何使用它。

图片由 Unsplash 上的 You X Ventures 提供

市场研究数据对任何商业决策都至关重要。然而，知道如何分析它是非常重要的。

业务需要推动创新和增长的见解和建议。

**你看到的杯子是半空的还是半满的？**这个问题是对如何阅读市场调研数据的隐喻。它可能有用，但具有欺骗性。

实例数据及分析

Ivona Fikejzlova 提供

这里我们有一个关于产品 x 的消费者满意度调查的结果。我们邀请了 100 名受访者参加，并向他们发送了一份在线问卷。

一旦我们得到了数据，我们就把它交给一个分析师团队。以下是他们得出的见解:

积极的分析师

我们做得很好！我们 40%的顾客对产品满意。77%的人回答说这满足了他们的需求。其质量得到了 26%的高度赞赏。

我们需要确保我们保持产品原样，以确保交付的一致性和对产品的总体满意度。

消极分析师

我们需要做出改变来保持竞争力！业务正在发生变化。四分之一的消费者对产品表示不满。

问题是它不能像过去那样满足他们的需求。最重要的是，可悲的是，产品 X 没有达到它的质量要求。

几乎三分之一的受访者对其质量持负面评价。我假设年轻人对品质的要求比较少。

因此，我们需要测试产品并将其与市场标准进行比较。然后我们应该瞄准年轻顾客。

普通分析师

总的来说，我们正以平均水平着陆。我们的消费者认为该产品一般。它在满足需求和质量方面得分一般。

但是，达到平均水平是可靠和令人满意的。样本中女性多于男性。

谁是对的？

我提出三点意见。他们都处理过数据，所以他们肯定是对的。但是，请耐心等待。

没有人是对的。

除非有一份清晰的简报，否则分析师无法做出有意义的分析。简介应包含业务背景、目的和问题。我们没有给我们的分析师任何东西。因此，他们的数据洞察力因其分析风格而异。

此外，他们中的两个没有与整个数据一起工作。他们没有对性别问题发表任何评论。

消极的分析师得出了关于年龄的结论，而这个结论在调查中并没有被问到。

所以，这些推荐是没用的。我们不能带着假设工作，我们需要数据和专业知识。当然，有时候专家的意见就足够了。但总的来说，我们从数据中获得的洞察力越多越好。

3 市场研究的基础

这不是火箭科学。它必须以数据为基础，回答商业问题。让我们简单地讨论一下内部和外部的数据和分析。

1.案情摘要

任何分析都需要摘要。您拥有大量非结构化数据。你不知道该拿它怎么办。

商业问题可以引导你度过难关。背景和假设一样重要。恰当地做简报，见解就会准确无误。它们将是具体的和可操作的。

你需要与分析师讨论，找出你的数据库、在线工具、CRM 中有什么，以及你需要得到什么。良好的简介包含:

背景 —发生了什么事？为什么重要？
商业问题——顾客满意吗？他们喜欢或不喜欢什么？为什么我们在这个市场销售的产品越来越少？
可用数据(内部销售数据、广告数据等。)，或数据要求(消费者细分、市场表现、经济因素等)。)
输出格式(表格、演示文稿、算法、新活动等)
时间线 —我们什么时候需要分析？

2.内部与外部数据

数据无处不在。它存在于你的内部数据库、绩效报告或社交网络中。您不必收集额外的数据，尽管有时这是明智的。

所以，首先，要明白自己已经有哪些数据。然后，想想还有什么更好的。获取数据可以是免费的，但也很昂贵。

市场研究是关于了解你的客户和市场。不可避免的是，你需要时不时地让顾客参与进来。Y

你既可以进行定性研究，也可以进行定量研究，就像我在示例数据集中展示的那样。顾客的意见很重要。

一个好的策略是收集关键指标并围绕它们进行分析。你可以综合运用各种数据来了解全貌。如果您需要进行调查，请确保您涵盖了所有领域。

每个问题都很重要。它可以帮助你指导未来关于产品开发或商业战略的决策。问卷的传统格式是从一般领域到具体领域，最后是回答者信息。

3.分析

数据很惊人。你可以在逻辑上将它们结合起来，并在趋势之间建立联系。

通过操纵数据、创建模型和编程交互式仪表板，您可以做很多事情。看的时候，有一些基本的东西要记住。

让我们回到关于产品 x 的表格。我对性别的影响感兴趣。我会把答案分成女人、男人和未指明的。

这样的话，我们可以看看是否有什么有趣的方向。例如，男人更关注质量，女人更关注可用性，等等。关于地点、性别或年龄的数据对于消费者细分和分析来说是非常宝贵的。

Ivona Fikejzlova 提供

市场调研数据分析的一条黄金法则是公平公正。指出积极的事情和可能的问题是很重要的。我们越早发现危险信号，就能越好地做出反应。

因此，请注意微小的数字，它们可能会对企业构成威胁。

Ivona Fikejzlova 提供

在这个例子中，我们看到了一些消极因素。人数不多——100 人中只有 5 或 10 人。

尽管如此，我们不应该低估他们。我们从实践中知道，5 个愤怒的顾客的评论可能胜过 20 个积极的评论。

所以，如果有机会，我们应该一直深入挖掘，去理解那些微小的数字。可能没什么大不了的，但是万无一失总比后悔好。

最后，但同样重要的是讲故事的力量。数据是干巴巴的。我们有无尽的报告。

平均值、平均数、百分比。听起来很无聊。你的分析可以让他们活起来。

驱动决策的不是数据本身，而是业务环境中的解释。

现在回到我的三个分析师和他们的分析。你最喜欢哪一个？

我要说，负面分析师做得相当好。他没有显示任何数据。他的演示不需要它们。然而，他可以制造一种紧迫感，让我们知道必须开发 x 产品。

市场调研正是如此。我们讲述故事，描述消费者的类型和他们的决定。因此，不要试图解释数据，而要试图解释行为。跟随客户的产品之旅。

最终想法

市场调研数据是一个百宝箱。当你打开它，你看到这么多珠宝。这是压倒性的。

但是正确的方法是用它来回答你的商业问题。这是一个支持你发展活动的过程。

在任何情况下，一定要提供一个简短的。所以，你的分析团队不会发狂。确保他们遵循基本规则(例如，客户特征或微小的报警数字)。你的数据会告诉你一个故事。现在是遵循它的时候了。

附注:你应该会收到我的邮件。 在这里做 ！如果你自己喜欢体验媒介，可以考虑通过注册会员 来支持我和其他成千上万的作家 。每月只需 5 美元。

我在数据科学职业生涯中犯的 3 个初级错误

原文：https://towardsdatascience.com/3-beginner-mistakes-ive-made-in-my-data-science-career-a177f1cf751b?source=collection_archive---------1-----------------------

写这个感觉像职业自杀

我不确定我为什么要写这个。(伊万·阿列克西奇在 Unsplash 上拍摄)

“你一直在谈论你的学习和成功；为什么不把你的错误和遗憾也说出来呢？”

昨天我打赌输了，那是我妹妹。

现在她逼我写这篇文章。我知道你在想什么——她说得有道理，但也许我(还)不愿意让世界看到我的错误。

写这个感觉像职业自杀。

即使在这之后你还会关注我的工作吗？我不知道。也许这就是为什么我没有看到很多专家谈论他们早期职业生涯的错误。拜托，他们应该也犯了一些吧？

所以伙计们，我在这里，被迫诚实地承认我在开始数据科学职业生涯时所犯的错误。我将深入揭示每个错误的原因、它对数据科学家新手的重要性，以及我们如何最终避免它们。

让我们看看这是怎么回事，好吗？

1.相信复杂的算法总能产生更好的解决方案

"那么这些聚集的居民有什么特点呢？"我的经理问。

我们使用了最近发布的最先进的模型来细分智能城市的居民。整个模型是一个黑盒，所以我们不知道它是如何分割的，但却给出了最高精度的聚类。

我想了一分钟；我想不出答案。我们的模型没有可解释性。

不过，我没有吸取教训。后来，客户拒绝了我们对一个潜在项目的概念验证。

“这个解决方案看起来很有希望，但是让我们回到您的问题上来。部署此解决方案的投资可能有点太高了。”

我们提出了一个计算机视觉系统来估计鱼的质量，使用最先进的对象检测和深度估计模型。尽管如此，我们还没有考虑到随之而来的昂贵的基于 GPU 的计算。

每当我遇到需要解决的问题时，我的大脑就会习惯于思考神经网络和复杂的算法。

计算机视觉？卷积神经网络。NLP？变形金刚。合成数据生成？甘斯。表格数据？XGBoost。简而言之，我会选择最复杂的算法，因为我相信，越复杂，解决方案越好。

在某种程度上，这个想法是正确的，尤其是当你想赢得 Kaggle 比赛的时候。这就是这些算法最初流行的原因。

这里有一个转折:在现实世界中，准确度提高 2%不需要像在黑客马拉松和竞赛中那样显著。解决方案的可解释性和运营成本更为重要。

如何避免这种情况:

我只有一条建议要给你，自从我明白了现实世界和商业是如何运作的，这条建议就一直对我有用。这一招让我们的客户最开心，也让我的生活最轻松。

你准备好了吗？

从简单开始。

你听到了。从简单的机器学习算法开始。事先把事情复杂化是没有意义的。从更简单的解决方案开始，这些解决方案更容易理解，也更具成本效益。尝试线性或逻辑回归没有坏处。

克里斯托夫·莫尔纳尔写了一本关于如何使用可解释的机器学习技术的书。让你了解这些话题总是个好主意。

如果表现令人满意，你就可以走了。如果没有，则升级到稍微复杂的级别，同时考虑可解释性和操作成本之间的权衡。这样的话，大家的期望必然是 100%符合的。双赢。

你还和我在一起吗？(照片由 JJ·乔丹在 Unsplash 上拍摄)

2.没有从一开始就建立强大的数据可视化技能

是我坦白的时候了；我只关注那些很酷的东西——建立模型和做预测。在我职业生涯的几年里，我还没有完全掌握如何通过数据来形象化或讲述一个故事。

我依赖我们的商业智能团队来构建每一个仪表板，并将见解传达给决策者。知道使用 matplotlib 之类的库不算——我说的是除此之外的东西。

数据可视化使数据对人类思维来说更加自然，并有助于使每个人的生活更加轻松。以下是我见过的数据可视化发挥重要作用的几个例子:

它帮助我们这些数据科学家建立直观的理解，并从数据中发现模式。我们建立的这种直观理解最终为更好的特征工程、模型开发和特征选择奠定了基础。
它有助于最终用户。大多数建立在 GitHub 上并发表在期刊上的项目从未被使用过。为什么？因为不是所有的最终用户都知道如何从 GitHub 使用它。在这种情况下，您最好构建易于使用的仪表盘和应用程序。
它帮助项目的涉众。人工智能项目需要大量投资。通常情况下，我们需要让他们相信我们为项目融资给企业带来的价值。在这种情况下，包含所有增值业务指标的仪表板有助于涉众做出更快、更明智的决策。

随着时间的推移，我的重要认识是，数据科学生命周期的每个阶段都有不同但不可或缺的目的，需要同等重视。忽视一个阶段太久会在以后的某个时候伤害你。

如何避免这种情况:

首先，了解数据科学生命周期中每个阶段的重要性。您可以参考本端到端项目指南，全面了解数据科学的不同阶段。一旦你理解了不同的阶段和与之相关的技能，尽快开始培养每一项技能。

具体谈到数据，我的简单行动计划是:

了解讲述数据故事和构建有效仪表板的基础知识。
在一些示例数据中练习技巧，以便更好地使用它。
在实际项目中使用这些技能，并分享它们以获得反馈。
当我把先进的技术应用到项目中时，慢慢地学习它们。

除了使用 matplolib 或 seaborn 绘制图表之外，还有很多东西需要学习；我们大多数人的学习曲线到此为止。

Coursera的这门课程帮助我理解了讲述数据故事的基础知识、基本设计原则、构建仪表板等等。这个领域最常用的工具是 PowerBI 和 Tableau，本课程使用后者。这是我希望早点注册的数据维兹课程。

然后，您选择任何数据集，并构建一个仪表板来讲述一个从数据中揭示见解的故事。在这一点上，记住，你不需要完美；你只是在练习技巧。只有你能看到你做了什么，所以请随意试验。

最后，自愿帮助你的下一个项目的数据可视化元素，看看进展如何。你可以边走边掌握先进的技术；不用着急。

3.没有费心提高我的软件工程技能

"软件工程和数据科学有什么关系？"

本科期间，我做过软件工程实习。我曾经帮助团队进行软件开发，撰写技术文档，并进行测试以评估开发质量。

实习生可以在整个堆栈上工作，以获得作为软件工程师工作的机会和体验。我非常不喜欢这种经历，以至于我知道软件工程不适合我。

幸运的是，我在数据科学中找到了自己的激情，并永远离开了软件工程。我学会了所有的基本机器学习，自愿参加项目，建立了投资组合，最终闯入这个行业。

每当在这个过程中出现软件工程方面的东西，我都会忽略它们。“软件工程和数据科学有什么关系？团队中会有软件工程师，”我想。

编写单元测试、干净代码、版本控制、构建 web 应用程序、docker 容器、面向对象类的需求不断涌现。

事后看来，我忽略了流行的数据科学维恩图的一个重要组成部分，因为我在实习期间的一次糟糕经历。

最终，我不得不屈服，拥抱软件工程。当我做的时候，它一点也不坏。我意识到我们不需要掌握所有的东西，只需要一些工具技能。他们称之为数据科学家的软件工程！

如何避免这种情况:

如果你是一个初学数据科学的人，请带着一张白纸和开放的心态，渴望知识。有很多东西要学，无论你的背景如何，你都需要一些软件工程技能。

没有必要恐慌；以下是我用过的一些资源，对你会有帮助:

面向数据科学家的软件工程将教你关于编写干净的代码、自动文档和创建包的一切，这足以让你入门。
我如何在数小时内构建机器学习应用
如何对任何机器学习应用进行分类
让 Python 代码看起来更好的九个简单步骤

我有一些朋友，他们甚至来自物理学、经济学，甚至机电一体化背景，学习了这些基础知识，并且做得很好。所以如果他们能做到，你肯定也能。

不要像我一样无知就好。仅此而已。

有时候你需要做正确的事情

是的，我最初是迫于压力才写的，但是我很高兴我把它写了出来。

我很高兴我写了这个。(丹在 Unsplash 上拍摄)

如果你一直读到现在，你可能会想，这个家伙一开始并不想写这个，但后来却深入地分享了一切。真的真的！我从没想过。随着想法开始涌入，我继续写作，因为我觉得这样做是对的。

你值得看到完整的画面——我们都值得拥有。**

人们认为一切都很好，专家不会犯任何错误。我知道你这么想，因为我也这么想。但事实并非如此。

大多数人专注于分享他们的成功和他们是如何做到的，希望能激励你变得更好。这个想法没有错。我也一直在做。

但是给出真实的完整画面难道不是正确的事情吗？

我不可能一夜之间成为的高级数据科学家，任何人也不可能。我从专家和他们的课程中学习，获得技能，应用它们，最终变得更好。

在那个过程中，我犯了错误；你也会做一些。我们都会犯错，没关系。如果你没有从错误中吸取任何教训，那就不好了。

从你的错误中学习，朝着你的目标前进。每个人都能做到这一点。你当然可以，相信我，相信你。

作为披露的提示，本文可能会有一些附属链接来分享我用过的最好的资源，而不会给你带来额外的费用。感谢您的支持！

要获得更多关于进入数据科学、真实体验和学习的有用见解，请考虑 加入我的电子邮件好友私人列表 。

如果你很看重这类文章，想支持我这个作家，可以考虑 报名成为中等会员 。每月 5 美元，你可以无限制地阅读媒体上的故事。

https://arunnthevapalan.medium.com/membership

作为一名大数据工程师，我希望早些知道 3 个惨痛的教训

原文：https://towardsdatascience.com/3-bitter-lessons-i-wish-i-knew-earlier-as-a-big-data-engineer-e2956bcc7b29?source=collection_archive---------25-----------------------

数据工程的注意事项

在 Unsplash 上拍摄的 ThisisEngineering RAEng

D 数据已经成为每个行业的重要资产。从医疗保健到电子商务，从零售到汽车。这一趋势导致数据工作者人数过剩。他们的职责是从原始的、未经处理的数据中提取最多的信息。

在这些职业中，数据工程师为了减轻其他人的工作而弄脏自己的手。他们的职责是设计和维护可靠、稳定和容错的数据管道。数据管道由许多阶段组成:数据接收、数据转换和数据存储。在这些阶段中的每一个阶段，工程系统都必须按照其预期目的工作。数据工程师的工作是结合业务和技术需求来设计这样一个系统。

数据工程师可能不是 21 世纪最性感的工作。但它是科技公司的核心专业人员之一。对于有抱负的初级数据工程师来说，事情一开始可能会令人生畏。在处理大量数据时，存在许多技术问题。这些各种各样的障碍会使没有经验的工程师气馁。随着经验的积累，事情会变得更好，所以我会列出我在大数据之旅中学到的一些经验。对于那些期待征服数据世界的人，请系好安全带！

了解你的 SQL

不管你喜不喜欢，人们倾向于用老式的方法做事。没坏就别修。在技术世界里也是一样，新的并不总是更好。

1979 年，Oracle 推出了第一个商用 SQL 关系数据库管理系统(RDBMS)。近半个世纪过去了，大部分时间公司仍然选择 RDBMS。

尽管这里和那里有一些关于 SQL 有多糟糕的争论，特别是关于它的冗长和不一致性。然而，它仍然是最流行的查询语言。根据 2021 年 DB-Engines 的 RDBMS 排名，第一名仍然属于 Oracle SQL，其次是 MySQL 和 MSSQL。

在新的大数据时代，相关数据仍然以结构化的方式进行组织。结构化语法是检索信息的最快和最有效的方法。

最流行的数据存储引擎 Hadoop 文件系统(HDFS)采用基于 SQL 的引擎，如 Hive 或 Presto 来执行特定查询。
与一些认为 SQL 对于大数据不够扩展的观点相反，一个精心制作的完整系统可以使用 SQL 处理大量数据。数据量高达几十万千兆字节的公司仍然使用 SQL。
数据分析师分析数据以最终确定他们的决策过程。他们只能在分析工具的帮助下做到这一点，比如 Vertica、Tableau 和 Power BI。你猜怎么着？这些工具大部分使用 SQL。

卢克·皮特斯在 Unsplash 上拍摄的照片

年轻的数据工程师，就像我过去的自己，经常忽视 SQL 用法的重要性。我一点也不知道，我的 SQL 中的一个小的优化可以导致显著的性能提升。一个小而巧妙的行为可以增强最终用户的体验。

如今，许多大数据工具都带有预先优化的软件包。这使得 SQL 查询成为优化的唯一场所。掌握一个人的 SQL 并不总是简单的。归结起来就是理解系统的本质。我们组织数据的方式、所需的输出和查询执行条件。

***To-Do List***- [Learning SQL: Master SQL Fundamentals](https://www.amazon.com/Learning-SQL-Master-Fundamentals/dp/0596520832)
- [Data Analyst with SQL Server](https://www.datacamp.com/tracks/data-analyst-with-sql-server)
- [How to Learn SQL](https://www.datacamp.com/community/blog/how-to-learn-sql)

商业知识为王

有抱负的毕业生申请成为数据工程师，希望满足技术先决条件。但是职位描述对商业知识只字未提。

您对 MapReduce 作业在 Hadoop 环境中的工作方式了如指掌。但是你知道什么是 A/B 测试吗？什么是 ROI ？
您熟悉 MSSQL 系统中的表索引。但是你听说过 CPC，CPM，或者 CTR 吗？

实际上，我必须在日常工作中了解这些术语。它们在我工作的地方很具体，但在你的下一份理想工作中，你可能不得不当场学习全新的定义。

我有一个梦想。总有一天，有人会在数据工程师开始工作前教给他们所有的商业知识。没有适当的入职培训，事情可能会变成一场噩梦。我很幸运地参加了关于我的公司如何运作的简短信息会议。但是我很难理解我的非技术同事。

照片由莱昂在 Unsplash 上拍摄

没有商业知识，数据工程师将在一个充满黑暗的房间里工作。为了使他的工作更加清晰，数据工程师必须揭示业务需求的原因、方式和内容。

**为什么？**公司利用数据做出商业决策。但是要做到这一点，利益相关者必须回答为什么我们需要这个决定。为什么把每个人都放在同一条船上。经理、项目负责人、设计师、分析师，最后是数据工程师。目标基于事实和真相将船驶向正确的方向。
**如何？**一旦目的地确定，我们必须选择技术来导航全体船员。我们应该使用新技术吗？现有的东西够用吗？数据工程师承认他们必须使用工具来满足为什么。
**什么？**最后的答案是确定实际工作。我们已经看到了为什么和如何，现在放下什么就更清楚了。数据工程师构建数据管道，评估输入数据，验证输出数据。但不应该就此止步。我们必须重复这个过程来验证我们是否回答了为什么。

由于招聘过程的原因，数据工程师申请人经常忽视商业知识。没有人评估他们如何看待公司业务，或者他们对特定业务术语的熟悉程度。我们都可以在工作中学习，但这不应该发生。我们应该尽快解决这些问题，甚至在上班的第一天之前。它决定了我们一天结束时的表现。

**To-Do List**- [57 Marketing Terms You Need to Know](https://blog.influenceandco.com/50-marketing-terms-you-need-to-know)
- [91 Startup Terms Every Entrepreneur Should Know](https://visionxpartners.com/startup-terms/)
- [8 Ways to Gain Business Knowledge quickly](https://enterpriseleague.com/blog/business-knowledge/)

节省一个千兆字节等于赚了一个千兆字节

数据是新的资产，存储现在是货币。我们选择如何存储数据会影响业务成果。数据工程师比任何人都认识到数据存储的价值。

因为我们想储存多少就储存多少，但这并不意味着我们应该这样做

根据这张信息图，2014 年的一份资料称，每年存储 1TB 数据的平均成本为 3351 美元。如今，便宜而可靠的云服务，如亚马逊 S3，每月每 GB 只需 0.02 美元。就存储容量而言，这是一个巨大的差异。

照片由 imgix 在 Unsplash 上拍摄

引擎存储器越来越适合处理大量数据。但是因为我们可以存储尽可能多的数据，这并不意味着我们应该这样做。即使存储层可以扩展，应用程序堆栈也赶不上庞大的数据量。

在数据存储方面，年轻的数据工程师需要谨慎行事。对于数据工程师来说，这听起来可能是一个乏味且不酷的任务，但从长远来看，它实际上为我们节省了金钱和精力。

从经济角度来说，存储的冗余数据越少，需要的空间就越少。然后是更有效的使用和廉价的数据契约。就环境而言，它减少了来自拥挤不堪的数据中心的碳足迹。

数据存储管理是一个复杂而微妙的课题。这是每个人的责任，涉及到企业的每一个角落。对于数据工程师来说，在处理数据时要记住一些想法。体贴地对待数据存储，不要使用超过你所需要的，给别人留有空间。

在数据科学面试结束时要问的 3 个有吸引力的问题

原文：https://towardsdatascience.com/3-captivating-questions-to-ask-at-the-end-of-your-data-science-interview-82c771ac664c?source=collection_archive---------47-----------------------

永远不要说你没有问题。

照片由马太·亨利发自突发

Bill 是一名有抱负的数据科学家。比尔在线申请。比尔没有得到任何回应。比尔完成了一些在线课程。比尔从事项目工作，建立了一个投资组合。比尔联系了他的关系网。比尔寻找推荐人。比尔终于得到了一家顶级公司的面试机会。

比尔研究了公司的一切。比尔为各种技术问题做了准备。比尔通过了面试。比尔很聪明。比尔想尽了一切办法。但是当被问及是否有问题时，比尔说他没有。

哦，比尔！

我两头都去过。我参加过面试，也作为候选人参加过面试。我帮助过的学生获得数据科学实习，我也指导过一些有抱负的数据科学家。在所有这些经历中，我经常看到这种情况发生，并决定把它写下来。

别误会，你不会因为没问问题就被拒绝了。但是你不想最大化你的机会吗？你做的一切都是对的；你为什么不也这样做呢？这些都是每个人都能掌握的简单事情。

永远不要说你没有问题。

为什么要问问题

他们一直在评估你。他们问了你一些技术问题。很有可能，他们甚至会给你一份带回家的作业。你不应该也评价他们吗？

我知道你在想什么。难道不是反过来吗？

让我解释一下:面试是潜在雇主和潜在候选人互相评估的机会，看看他们是否适合为相同的目标工作。

当采访接近尾声时，他们已经完成了他们的部分。现在是时候做你的了。他们可能会问你是否有任何问题。准备好这三个问题，你就万事大吉了。

1。表现出真正的兴趣

不要只是表现出兴趣，要真诚地感兴趣。有经验的面试官能看穿你。反正你对公司不感兴趣的时候也没有足够的时间去过面试。

问题:你们目前正在解决哪些有趣的数据科学问题？

替代问题:在这家公司工作，你最喜欢的事情是什么？我在你的网站上看到你致力于强化学习。你能多告诉我一些吗？

好了，这是个好的开始。(来自 Pexels 的安德里亚·皮亚卡迪奥拍摄)

我不知道你，但我很好奇我未来的公司在做什么。数据科学领域很广，大多数公司都在特定的领域工作。很多问题都等着用数据和算法去解决；你手上有哪些？

作为面试官，我们想雇佣一个足够有能力并且对我们的工作感兴趣的人。我希望我团队中的每个人都能享受工作，我相信大多数公司都是这样。

正如我之前所说，你不需要坚持确切的问题。从表现出你对他们工作的兴趣开始。保持好奇心，让他们看穿你。

2.评估机会

评估机会，他们对你来说有多合适。你宁愿现在做这件事，也不愿在加入后感到失望。

问题:就您的数据科学技术堆栈而言，你们最常用的语言和框架是什么？

备选问题:你用的最多的是哪个云平台？你如何采用在家工作的做法？

没有人知道机器学习的每一个框架。连业内专家都不知道。随着时间的推移，他们已经掌握了一些并坚持下去。当您进入一个新的机会时，您会想知道团队使用了哪些技术。这有助于你确定自己是否合适，甚至给你时间尽快熟悉这些技术。

你已经听说过他们解决的问题，现在通过这个问题，你将知道他们使用什么。迟早，这些会帮助你决定公司是否适合你。

3.展示你的自信

这是一个游戏改变者。

你离开房间后，他们会讨论并打电话。如果你在面试中表现出色，你没有理由不自信。面试官总是喜欢自信的候选人。让他们惊叹于你的自信。

问题:假设我被招聘加入你的团队；典型的一天我会做什么？

选择题:假设我被招聘加入你的团队；我要解决什么问题？

完全正确，你做到了！(照片由驼鹿照片发自派克斯)

*“假设我被录用了，”*展示了你的自信，这是很多人都没有的。相信我；很少有人在面试中表现出这种自信，这有助于你在他们心目中脱颖而出，因为他们会为你决定下一步。此外，在你加入之前，你也能更好地了解他们对你的期望。这就是问题的全部。

你只需要明白这些 3 个想法问题从何而来。不要写下你的问题，而是以此为框架，找到最适合你的风格和天性的问题。我建议将问题保持在 3 个，这就足够了。

如果你有更多关于薪酬和诸如此类的问题****，留着和人力资源/招聘人员聊天时再问。大多数技术面试官不能给你具体的答案来回答与管理相关的问题，你最好直接问人力资源/招聘人员。

最后，有很多因素会决定你是否能得到一个角色。作为一名候选人，你应该尽力做到最好，然后得到合适的工作机会只是时间问题。

This article is a part of my series on **Career Guidance for Aspiring Data Scientists**:
- [Your Data Science Journey Kickstarts Here](/your-data-science-journey-kickstarts-here-9aa0253bd182)
- [How to Secure Your First Data Science Internship](/how-to-secure-your-first-data-science-internship-7bbfd8b87bdc)
- [How to Get Yourself a Mentor in Data Science](/how-to-get-yourself-a-mentor-7e859d1e563a)
- [This 3 Step Approach Can Transform Your Data Science Journey](https://medium.com/towards-artificial-intelligence/this-3-step-approach-can-transform-your-data-science-journey-a48f6a753097)
- [3 Captivating Questions to Ask at End of Your Data Science Interview](/3-captivating-questions-to-ask-at-the-end-of-your-data-science-interview-82c771ac664c)

我希望你喜欢这篇文章，就像我喜欢为你写这篇文章一样。我很想听听你的想法，什么对你有用，什么没用。期待与您的联系！

有抱负的数据科学家面临的 3 大挑战

原文：https://towardsdatascience.com/3-challenges-for-aspiring-data-scientists-ae0c479f31b7?source=collection_archive---------27-----------------------

解决问题的第一步是了解它

由 Unsplash 上的奥比·奥尼耶德拍摄的照片

如果你正在阅读这篇文章，你可能打算进入数据科学领域。或者，你已经开始了学习之旅，并致力于提高你的技能。

无论哪种方式，你都需要克服一些挑战来达到你的目标。我花了将近两年的时间找到了第一份数据科学家的工作。当然，我也面临着这样的挑战。

在本文中，我将分享我认为大多数有抱负的数据科学家可能会遇到的 3 个挑战。

数据科学是一个跨学科领域

要成为一名数据科学家，你需要一整套全面的技能。

数据科学产品是通过软件工具和软件包实现的。因此，软件技能至关重要。然而，成为一名优秀的程序员并不足以成为一名像样的数据科学家。

数据科学的另一个组成部分是统计学。为了从数据中推断出有意义的结果，人们应该对基本的统计学概念有一个全面的了解。

完成三部曲的最后一部分是领域知识。数据科学的范围是巨大的。我们可以将它应用于几乎任何可以收集数据的商业或行业。如此大的范围是数据科学普及的支持因素。

由于我们谈论的范围非常大，数据科学家通常专攻某个特定领域。例如，零售分析与自动驾驶完全不同。

有共同的知识和技能基础。然而，如果你想在某个领域脱颖而出或专攻某个领域，你肯定需要了解那个领域的动态。

数据科学就是用数据解决问题。问题可能以不同的形式出现，如需求预测、改进生产流程、预测性维护等。你处理问题的方式会因领域的不同而有很大的不同。因此，不同的解决方案可能适用于不同的领域。

正如我们所讨论的，数据科学是一个跨学科领域，由三个主要构件组成。为了成为一名优秀的数据科学家，你需要在这三个方面找到平衡。

在一个领域拥有杰出的技能，而忽视另外两个领域，很可能以失败告终。

在我们提到的这三个方面提高你的技能是一个巨大的挑战。但是，如果你遵循一个设计良好、结构合理的学习路径，这也不是不可能的。

没有简单的方法来展示你的技能

如果你以前没有工作经验，展示你的技能是一个相当大的挑战。由于数据科学是一个相对较新的领域，大多数数据科学家候选人都是新人。因此，以前的工作经验并不常见。

不幸的是，完成几门 MOOC 课程或收集证书对说服招聘人员没有太大帮助。我们需要一个更有影响力的食谱。

一个可靠的项目可能是一个很好的起点。这使我们成为竞争激烈的就业市场中的优秀候选人。我所说的可靠项目是指由你来设计、实施的项目。

我来详细说明一下。数据科学家确定一个可以用数据解决的问题。然后，他们定义数据需求并设计解决方案。最后，实施解决方案并评估结果。

这是数据科学产品或项目的典型工作流。如果你能从头开始创建这样一个工作流，那将是非常有价值的。你不必解决一个复杂的问题。然而，能够以这种方式起草项目肯定会让你脱颖而出。它清楚地展示了你的技能。

平凡的项目有利于练习和学习。你可以在一两天内完成它们。由于这些项目中的问题和解决方案已经拟定，它们不足以说服招聘经理。

大量工具和软件包

尽管数据科学已经存在了很长时间，但它在最近几年才变得非常流行。受欢迎程度提高的一个关键因素是我们管理数据的能力。

收集、存储、传输和处理数据变得前所未有的容易。让所有这些操作变得简单的是超级高效的工具。一个新的很快就推出来了。

虽然这些工具让数据科学家的生活变得更加轻松，但它们也带来了自己的挑战。新工具意味着要学习新的东西。学习如何使用它们需要花费时间和精力。

我们不必学习每一种工具。

我们不应该试图学习每一种工具。相反，选择你需要的并掌握它们。专注于一个特定的工具会让你更容易掌握它。例如，如果你计划练习深度学习，选择 TensorFlow 或 PyTorch，而不是两者都选。当你成为一名经验丰富的数据科学家后，你可以随时比较这两者。

按需学习。

有许多用于数据分析和处理的软件包。在大多数情况下，一个就足够完成典型的任务了。例如，Pandas (Python)和 data table (R)都是非常高效的数据分析包。当然，你可以学习和使用这两者。但是，最好从一个开始，并掌握它。

生活充满了挑战。数据科学也是如此。如果你对成为一名数据科学家充满热情，你可以克服我们已经讨论过的挑战。然而，你仍然需要一个结构化的学习路径。

感谢您的阅读。如果您有任何反馈，请告诉我。

数据采用的 3 大挑战

原文：https://towardsdatascience.com/3-challenges-of-data-adoption-790a87ae3472?source=collection_archive---------25-----------------------

以及数据领导者如何克服这些困难的技巧

由 Unsplash 上的克里斯托佛罗拉拍摄的照片

不计其数的公司正在踏上数据之旅。他们越来越多地——正确地——从设计数据策略开始。但是，即使有一个伟大的计划和积极的意图，成功是不确定的。

数据计划失败的原因之一是整个组织缺乏数据采用。采用需要从最高管理层传播到所有级别的个人——一直到第一线。

如果 C-suite 的采用率很低，那么数据策略往往在遇到第一个障碍时就失败了。当整个组织的采用率很低时，数据策略的执行会变得异常困难。

简单地说，采用率越高，数据策略在创造切实的业务成果方面就越成功。但是如何推动采用呢？这样做的最大挑战是什么？

挑战 1:我们正在解决什么样的业务问题？

第一个挑战与最关键的问题相关— 我们正在解决什么业务问题？

为什么数据很重要？为什么要关注？我们将如何受益？企业将如何受益？

简单的答案是将数据策略与业务策略紧密联系起来。并确保每个数据项目都针对一个确定的业务问题。

但是，说起来容易做起来难。为什么？因为当一名数据专业人员问高管们他们想解决什么业务问题时，她经常得到的回答是:“我们需要升级 ERP 系统”、“我们需要提高数据质量”，或者“我们需要开发一个聊天机器人”。

这些都很好，但这些都不是业务问题(它们是 IT 和数据问题)。作为一名数据科学家，我们不应该接受这个答案，而应该继续探索，以找到真正的业务问题。我们希望听到这样的话:“我们需要提高 ARR”，“我们需要将我们的业务扩展到十个新市场”，或者“我们需要提高从免费试用到付费订阅的转化率”。

如果我们成功地确定了实际的业务问题，我们也‘钩住’了一个强大的高级赞助商，因为我们的数据项目解决了他们的问题！有了它，一切都变得更容易了——获得预算和资源，在事情不顺利时获得支持，为他人树立有影响力的榜样，从而更容易与其他团队合作。

切尔西·威尔金森的图片

最重要的是，其他业务同事将开始看到他们的业务问题与数据和分析必须提供的解决方案之间的联系。我们将看到在业务和数据之间架起一座桥梁。

挑战#2:做出数据驱动的决策的能力。

第二个挑战是做出数据驱动的决策的能力。这不仅仅是业务变得更加数据驱动。这是关于业务和数据世界的融合。

让我解释一下。

组织中的每个人都需要提高数据流畅性。所有人。这是一个比数据素养更广泛的概念。它超越了阅读图表的能力。是关于数据中的思维。这是关于商业语言。

在提高数据流畅性时，牢记以下两点很有帮助:

人们应该被数据的价值所驱使。这样，他们就会对学习感兴趣，并觉得自己会受益。
他们不应该被数据吓倒。它不应该被认为是一个可怕的世界，充满了困难和人为的概念。

除了数据流畅性，人们还需要访问数据，以便能够做出数据驱动的决策。重要的是，提供访问的工具必须围绕用户来设计。

一个有用的考虑是分析师和非分析师之间的区别。 Benn Stancil 用了一个很好的比喻说，当处理数据时，分析师的工作就像科学家的工作一样他们在处理数据时不断提出更多的问题，创造更多的假设。

然而，非分析师像记者一样工作。当他们有问题时，他们收集最重要的指标，添加他们的经验，用一个故事覆盖它，然后——嘭——就有了答案。

这就是为什么数据专业人员必须更贴近业务，为什么商务人士应该更加精通数据。

继续用桥来类比——这是双向交通需要被创造的地方，在一个持续的流动中，来回的。

切尔西·威尔金森

挑战#3:数据去神秘化和民主化。

一旦我们确保了数据的重要性(挑战 1)和数据驱动的决策能力(挑战 2)，我们就需要降低门槛，进一步推广应用。

四个概念有助于实现这一目标。

**产品管理方法。**与我们如何推动其他产品的采用类似，我们应该使用产品管理方法来推动数据产品的采用。我们需要对数据产品的整体成功负责——确定用户需求、拥有产品愿景、执行产品愿景、向用户营销产品并在需要时为他们提供支持。

**没有技术术语。**技术语言可能会令人生畏，妨碍人们更加流畅地使用数据。我们不应该让他们为难，所以应该尽可能使用商务语言。

**可解释的&伦理 AI/ML。**当高级分析、人工智能或人工智能成为数据解决方案的一部分时，其方法和输出应该清晰地向非数据科学家阐明。模型应该是透明的、可信的、可解释的。以便人们了解他们的工作方式。

数字双。最后，它有助于将数据视为真实世界的反映。人们倾向于直观地发现数字孪生兄弟的概念。它帮助他们理解与(可用和缺失的)数据相关的约束、限制和假设，包括其质量，因为这是他们在真实的、照常营业的世界中“看到的”。

这就是我们增加桥梁容量的方法。让更多的人(例如，其他团队和部门)能够访问和理解数据和数据解决方案。

切尔西·威尔金森

结论

广泛采用对于任何数据计划的成功都至关重要。否则，它将永远无法发挥其全部潜力。

然而，推动采用带来了一些巨大的挑战:

我们正在解决什么业务问题？
能够做出数据驱动的决策。
数据去神秘化和民主化。

这些都是有意义的挑战，但并非不可能解决。一种勤奋、务实、善解人意的方法可以帮助我们在业务和数据之间架起一座桥梁，承载不断增加和变化的双向流量。

这篇文章的故事是为一个名为 【准备您的数据以供从一线到高管团队采用】 的网络研讨会而创作的，由来自Keboola和thought spot的同事共同完成。这段录音可以在这里找到https://www.youtube.com/watch?v=VCrnuUAsHqY。

一如既往，我无限感激切尔西·威尔金森耐心地将我的想法塑造成可出版的形式。

感谢阅读！

欢迎在评论中分享你的想法或观点。

跟我上 中LinkedIn和Twitter******

神经网络初始化的 3 个常见问题

原文：https://towardsdatascience.com/3-common-problems-with-neural-network-initialisation-5e6cacfcd8e6?source=collection_archive---------12-----------------------

肖恩·奥尔登多夫在 Unsplash 上拍摄的照片

有哪些影响？我们如何避免它们？

常见的机器学习建模过程经历(1)权重初始化，(2)正向传播，(3)损失(或成本)计算，(4)反向传播，以及(5)使用优化算法的权重更新。虽然权重初始化通常就像一行代码一样简单，但人们往往容易忽略权重初始化有多精细，以及它对最终模型性能的影响有多大。

在这篇博客中，我们将研究神经网络初始化中的一些常见问题，它们相应的影响，更重要的是我们如何检测和避免它们。

**# one-liner weight initialisation for tensorflow**tf.keras.initializers.RandomUniform(minval=-0.05, maxval=0.05, seed=None)

零初始化—对称问题

**为什么会这样:**神经网络的初始化权值都为零
结果:神经网络将成为线性模型

神经网络之所以善于在数据中找出复杂的模式，部分原因是由于其非线性。通过将所有权重设置为零的相同值，反向传播中的所有偏导数对于每个神经元都是相同的。虽然这不会破坏算法，但是这将停止任何学习，因为同一层中的所有神经元将在迭代中具有相同的权重，即所有神经元将学习相同的参数。如果线性神经网络很好地服务于您的问题，它在内存和计算资源方面可能是过度的。你应该选择线性回归。另一方面，如果潜在的问题不是线性的，那么线性神经网络不够健壮或准确。

减轻消失渐变的方法有:

只需避免将所有权重初始化为零

太小的初始化-消失梯度

**为什么会这样:**神经网络的初始化权重太小
**结果:**过早收敛
**症状:**模型性能在训练过程中提升非常缓慢。训练过程也可能很早就停止。

如果神经元的初始权重相对于输入太小，当我们向后传播时，隐藏层的梯度将呈指数减少。或者你也可以说，在层层叠叠中消失。为了更好地理解这一点，让我们假设我们有一个三层完全连接的神经网络，其中每一层都有一个零偏置的 sigmoid 激活函数:

三层全连接神经网络—来源:图片由作者提供

如果我们快速回忆 sigmoid 函数及其导数的样子，我们可以看到，当 x=0 时，sigmoid 函数的导数(即梯度)的最大值是 2.5。

Sigmoid 函数和导数—来源:Sigmoid 函数的导数

sigmoid 函数的导数以其自身的形式存在——来源:图片由作者提供

当使用梯度下降来训练模型时，我们将使用反向传播来更新整个神经网络的权重，方法是对每层的权重取损失值的偏导数。为了得到上面网络的偏导数，我们需要首先知道它的数学表达式。假如

a 代表激活功能的输出，
σ 代表 sigmoid 函数(即我们的激活函数)，
z 代表一层神经元的输出，
W 代表每层的重量

上述神经网络可以表示如下:

使用 sigmoid 激活函数对上述内容进行数学表示——来源:图片由作者提供

并且用于更新第一层中的权重的偏导数看起来如下:

用于更新第一层权重的渐变—来源:作者图片

如果你觉得这看起来像一连串的呕吐，那么恭喜你，你已经掌握了它的要点！一种直观的理解方式是:因为如果所有权重都相对较小(例如 0.005)，偏导数根据链式法则相乘，那么当我们向后传播时，sigmoid 的梯度将变得越来越小。

由于梯度将用于调整每个层的权重，早期层的权重将几乎不会由于消失的梯度而改变。并且当权重变得稳定时，训练过程将结束，即模型不能从数据中学习任何其他东西。但是，模型还没有收敛；它只是遭受一个消失的梯度！

减轻消失渐变的方法有:

LSTM 可以用它的门解决渐变消失的问题
使用激活函数，如 ReLu 或 leaky ReLu，它们都不容易消失梯度
减少层数
将权重随机初始化为足够大的期望值

过大的初始化—爆炸梯度

**何时发生:**神经网络的初始化权重过大
**结果:**损失值将在最小值附近振荡，但无法收敛
**症状:**由于模型的不稳定性，每次更新时损失值都会有较大的变化。损失值也可能达到 NaN。

相反，当权重太大时，梯度(偏导数)将指数增加，因为我们向后传播以更新权重。或者你也可以说，通过层爆炸。结果，权重在迭代之间剧烈变化，导致模型不稳定。训练过程的不稳定性也将使模型更难收敛到全局最优，而是围绕全局最优振荡。

早前偏导数链的一部分—来源:作者图片

即使 sigmoid 具有 0.25 的小最大梯度，我们也可以看到，如果神经网络的所有权重都大于 4，那么导数链的所有单独部分都将变得大于 1，因此导致爆炸梯度。同样，由于偏导数链会更长，来自早期层的权重比后期层的权重遭受更多。

避免爆炸渐变的方法可以:

限制渐变大小的渐变剪辑
使用像 ReLu 或 leaky ReLu 这样激活函数，它们都不太容易爆发梯度
用足够小的期望值随机初始化权重
减少层数

初始化方法的荣誉提名

随着深度学习模型越来越复杂，消失梯度和爆炸梯度的问题只会更加明显。初始化权重的一般经验法则是(1)使其随机，(2)每层具有稳定的方差，以及(3)潜在地使分布对称。在此基础上，已经有很多优秀的工作致力于权重初始化，旨在更好和更快地收敛，减少梯度问题。这里有两种更常见的初始化方法，你可能会发现它们对构建你自己的深度学习模型很有用:

He 初始化(He et al . 2015)**:**这更适合初始化 ReLu 和漏 ReLu 激活函数的权重。

他初始化-来源:作者图片

Xavier 初始化 (Glorot 等人，2010) : 这更适合初始化 tanh 激活函数的权重

Xavier 初始化——来源:作者图片

结论

这是这个博客的内容。我们已经涵盖了对称问题，消失梯度，爆炸梯度，如何检测它们，以及如何避免它们。我们还简要地提到了 He 和 Xavier 初始化，它们分别更适合 ReLu 和 tanh。

希望你觉得这个博客有用！如果我错过了什么，或者如果你有任何问题，请随时回复或 pm。如果你想了解更多关于 Python、数据科学或机器学习的知识，你可能想看看这些帖子:

谷歌的 RFA:近似变形金刚中的 Softmax 注意力机制
TensorFlow:用 GPU 将 NumPy 加速 10000 倍以上
改进数据科学工作流程的 7 种简单方法
熊猫数据帧上的高效条件逻辑
常见 Python 数据结构的内存效率
与 Python 并行
数据科学的基本 Jupyter 扩展设置
Python 中高效的根搜索算法

如果你想了解更多关于如何将机器学习应用于交易和投资的信息，这里有一些你可能感兴趣的帖子:

Python 中交易策略优化的遗传算法
遗传算法——停止过度拟合交易策略
人工神经网络选股推荐系统

https://www.linkedin.com/in/louis-chan-b55b9287/

Python Altair 的 3 个很酷的特性

原文：https://towardsdatascience.com/3-cool-features-of-python-altair-deb3f432cc11?source=collection_archive---------15-----------------------

它不仅仅是一个数据可视化库

照片由萨曼塔·加德斯在 Unsplash 拍摄

数据可视化是数据科学不可或缺的一部分。它加速了许多任务，例如探索数据、交付结果、讲故事等等。幸运的是，Python 有很好的数据可视化库。

Altair 是一个用于 Python 的声明式统计可视化库。它提供了几个功能来执行数据分析，同时创建惊人的可视化。

在本文中，我们将介绍 Altair 的 3 个特性，它们有可能提高您的效率。

和其他软件工具和软件包一样，最好的学习方法是通过实践。因此，我将尝试用例子来解释这些特性。我们将在知识共享许可下使用 Kaggle 上的客户流失数据集。请随意下载并跟随。

Altair 可以通过 pip 轻松安装，如下所示:

pip install altair#if you are using jupyter notebook
!pip install altair

让我们导入库并将数据集读入 Pandas 数据框。

import pandas as pd
import altair as altchurn = pd.read_csv("Data\\BankChurners.csv")

我们将只使用原始数据集中的一些列。我们还需要最多 5000 个观察值(即行)才能使用 Altair。下面的代码片段执行必要的过滤操作。

features = [
    "Attrition_Flag",
    "Customer_Age",
    "Gender",
    "Marital_Status",
    "Income_Category",
    "Total_Trans_Amt",
    "Credit_Limit",
    "Months_Inactive_12_mon"
]churn = churn[features].sample(n=5000, ignore_index=True)churn.head()

(图片由作者提供)

我们现在可以开始探索 Altair 的酷功能了。

1.数据聚合

Altair 允许在创建可视化时聚合数据。它为我们节省了一些通常由数据分析和操作库(如 Pandas)完成的操作。

例如，我们可以创建一个柱状图，展示每个收入类别的平均信用限额。

(alt.
  Chart(churn).
  mark_bar().
  encode(x='Income_Category', y='mean(Credit_Limit):Q').
  properties(height=300, width=400))

(图片由作者提供)

我们在 encode 函数中传递给 y 参数的内容执行与 Pandas 的groupby函数相同的操作。

churn.groupby(["Income_Category"]).agg(
   Mean_Credit_Limit = ("Credit_Limit","mean")
)

(图片由作者提供)

2.过滤

Altair 还提供了过滤数据的功能，以便我们可以创建更集中或更具体的图。有几个谓词被传递给了transform_filter函数。每个谓词应用不同的过滤方法。

例如，其中一个谓词允许基于值列表过滤行。下面的代码创建一个条形图，显示由oneOf参数指定的列表中给出的每种婚姻状况的平均信用额度。

(alt.
  Chart(churn).
  mark_bar(width=50).
  encode(x='Marital_Status', y='mean(Credit_Limit):Q').
  transform_filter(
      alt.FieldOneOfPredicate(
          field="Marital_Status",
          oneOf=["Single","Married","Divorced"])).
  properties(height=300, width=500))

(图片由作者提供)

您可能已经注意到，第二个图中的条形比第一个图中的条形窄。可以使用mark_bar功能的宽度参数调整条的宽度。

3.动态过滤

我们也可以用 Altair 实现动态过滤。它允许使用共享过滤器将多个图绑定在一起。

我们首先创建一个捕捉用户交互的选择对象。顾名思义，它用于选择可视化上的值。选择对象可以连接到图例或另一个图。

换句话说，我们使用选择对象在一个绘图或图例上指定一个条件。然后，基于此选择过滤值。

举个例子会更清楚。

selection = alt.selection_multi(
   fields=['Attrition_Flag'], bind='legend'
)alt.Chart(churn).mark_circle(size=50).encode(
   x='Credit_Limit',
   y='Total_Trans_Amt',
   color="Attrition_Flag",
   opacity=alt.condition(selection, alt.value(1), alt.value(0.1))
).properties(
   height=350, width=500
).add_selection(
   selection
)

这段代码片段的作用如下:

它使用损耗标志列创建一个选择对象。它必然与传说有关。
然后，它创建一个信用限额和总交易金额列的散点图。这些点根据损耗标志列进行着色。
“不透明度”参数用于根据选择调整点的不透明度。
属性功能修改绘图的大小。
最后一步是将选择对象绑定到这个可视化对象。

结果如下:

(作者 GIF)

结论

在数据转换和过滤方面，Altair 是一个强大的数据可视化库。它简化了许多典型的数据操作任务。在本文中，我们介绍了 3 个很酷的特性，它们让我们能够在可视化中集成数据操作。

最后但同样重要的是，如果你还不是中级会员并打算成为其中一员，我恳请你使用以下链接。我将从你的会员费中收取一部分，不增加你的额外费用。

https://sonery.medium.com/membership

感谢您的阅读。如果您有任何反馈，请告诉我。

数据科学项目有效利益相关者管理的 3 个关键方面

原文：https://towardsdatascience.com/3-critical-aspects-of-effective-stakeholder-management-for-data-science-projects-b2bf3a472da3?source=collection_archive---------24-----------------------

照片由莱昂在 Unsplash 上拍摄

办公时间

不能忘记我们仍然要和人们一起工作

成功做数据科学需要什么？当然是数据。但是还有什么呢？伟大的工具和软件包只能让你在寻求分析见解的过程中走到这一步。除了拥有一系列技能之外，你还需要了解如何与人合作——无论他们是外部利益相关者还是你自己的团队成员。这篇博文讨论了在任何数据科学项目中对有效的利益相关者管理至关重要的三个关键方面:期望管理、建立清晰的沟通渠道、促进协作和反馈循环。

为什么很容易忘记这是关于人民的

对于我们大多数数据科学家来说，我们进入这个行业是因为我们对数据的热爱，以及为我们的客户创造价值的产品和服务。数据、模型和算法都是关于人的——他们是谁，他们有什么欲望。我们想知道为什么有人买一种产品而不买另一种，或者在他们的生命周期中什么时候出现了某种行为。

简而言之，我们在这里不只是谈论数字:人是重要的！对于数据科学项目来说也是如此。很容易忘记这一点，因为如果你从一开始就做对了，这比简单地在电脑屏幕上分析表格和图表要花更多的时间。但是不要以为涉众可以等到你项目的后期再和他们一起工作；最有可能的是，当其他组织由于良好的利益相关者管理而在你之前取得成功时，他们将会无限期地等待。

期望管理

并非所有的数据科学项目都按照我们计划的方式进行。事实上，众所周知，数据科学项目很难在截止日期前完成，也不超出预算。这不一定是因为缺乏技能；相反，这是因为试图理解人类行为的复杂性，包括其所有的细微差别和多样性。

一些数据科学家认为，他们可以通过向利益相关者(外部或内部)承诺将在特定时间点确定交付的内容来掩盖这一点。但正如我们所见，当理解人们如何围绕你正在设计的数据驱动的产品和服务行为时，没有办法控制每个变量。而且这些承诺经常以无法实现(有时被怨恨)而告终，这意味着您的组织在过程早期由于不良的利益相关者管理而浪费了宝贵的资源！

设定期望值的一种方法是让数据科学家展示一系列潜在的结果。然后，他们可以向利益相关者展示他们在计算中使用的数据和模型，这样就有了透明度和对为什么某些预期可能比其他预期更现实的理解。

数据科学项目除了不能满足最后期限或成本估计之外，还有许多地方出错:例如，项目可能需要更长时间，因为数据在分析之前需要清理；由于不可预见的外部事件，如自然灾害破坏供应链(如疫情)，基于数据的预测可能会变得不准确。重要的是，双方——利益相关方和作为数据科学家的您——在这些困难时刻保持开放的沟通，而不是让它们成为等待爆炸的定时炸弹。

在数据科学中，没有一个项目是完美的——但是如果从一开始就正确管理预期，利益相关者仍然会对结果感到满意！

建立清晰的沟通渠道

当然，从直觉上讲，数据科学家需要与数据利益相关者进行有效的沟通。但是数据科学项目通常有许多不同的利益相关者，他们并不总是在同一个部门工作，更不用说不同的需求和期望了。例如，美国数据科学家可能需要与产品经理和工程师合作，开发他们为内部和外部客户设计的数据驱动型产品或服务。

参与数据分析工作的人越多，无论是在组织内部还是外部，沟通就变得越重要。事实上，在整个企业中建立强大的渠道可能很困难，但对成功至关重要，因为数据在许多人之间共享，数据科学家需要能够交流他们正在做什么，为什么要这样做，以及其他人如何能够提供帮助。

首先，数据科学家要清楚他们的项目目标；这些应该是书面的，以便利益相关者了解你的期望。它还包括建立定期会议(例如每周一次)或其他形式的沟通渠道，如 Slack 或电子邮件，以便您可以回答数据科学团队成员以及组织内各级数据利益相关方的问题，甚至是可能不经常使用电话交谈等正式沟通方法的外部合作伙伴的问题。

促进协作和反馈循环

为了确保您的项目适应数据利益相关者的需求，数据科学家需要鼓励与内部和外部利益相关者的协作。这意味着从数据科学项目中抽出时间—这些项目本身已经是数据驱动的了！—投资建立清晰的反馈回路，确保每个人都了解正在发生的事情，以及为什么这对他们的团队成员或客户很重要。

例如，当数据科学家探索如何在项目中使用数据时，他们可能希望邀请一个部门(比如产品管理部门)的利益相关者加入到流程中。一旦数据被收集、可视化、收集、分析等。，这可能意味着邀请另一个不与分析工作密切合作的人，例如一名工程师，他将利用从您的研究中获得的数据见解为开发决策提供信息，但没有直接参与数据科学。

这听起来可能需要做大量的工作，但是它对于组织和项目的成功至关重要——甚至可以通过避免由于企业中不同团队的不同解释而导致的沟通错误或数据错误来节省您的时间。

这是一项你不能忽视的软技能

数据科学家需要确保利益相关者不会对数据科学家在项目期间能够为他们做什么抱有不切实际的期望。他们可以避免不切实际的期望的一种方法是通过与他们的利益相关者进行清晰的沟通，并建立清晰的沟通渠道，这样就不会对每个利益相关者从这项数据驱动的研究工作中的期望产生任何混淆！

此外，数据科学家应努力鼓励与组织内所有级别的利益相关者以及可能不使用正式沟通方法的外部合作伙伴进行协作和反馈。这是数据科学项目为了有效而需要的软技能！

无论您是否是数据科学家，利益相关者管理对任何项目都至关重要。我们已经看到太多的项目失败，因为利益相关者管理没有做好。如果这听起来像是你感兴趣的事情，或者如果你对如何在你的组织中做这些事情有一些问题，请在下面分享它们！

3 种数据支持的方法可以显著加快 MySQL 批量插入的速度

原文：https://towardsdatascience.com/3-data-backed-ways-to-significantly-speed-up-your-mysql-bulk-inserts-28e20b42d51e?source=collection_archive---------10-----------------------

看看数据是如何说明优化 MySQL 批量插入的最佳方法的。

粘土银行在 Unsplash 拍摄的照片

在数据科学项目中，数据管道中常见的最后一步是将结果保存到数据库中(例如 MySQL)。这种数据管道的结果通常很大，因此优化对数据库的写入对于实现可接受的管道延迟非常重要。

我对许多 MySQL 批量插入设置进行了基准测试和分析，以深入了解真正重要的因素是什么，从而显著提高这类工作负载的速度。在本文中，我将分享它们，以便您可以节省研究时间，并立即开始实施正确的设置。感兴趣吗？请继续阅读。

1.推迟建立索引

索引对插入极其不利。在上图中，index=EARLY在任何插入完成之前创建索引，而index=LATE在所有插入完成之后创建索引。我们可以看到:

随着输入大小变大，插入到索引为的表中不会像没有索引的表那样伸缩。
输入大小为 5000 万行时，两者相差 1 小时。

该图还表明，带有索引的表具有非线性延迟增长。随着时间的推移，写入带索引的表会变慢吗？

哦，是的，它是。输入越大，写入速度越慢。与没有索引的表相比，写速率是一致的。

2.并发插入

通过向没有索引的表并发插入，您可以从批量插入中减少 50%的延迟。

从上图中，我们还看到了 index 的另一个缺点:对带有 index 的表进行并发插入没有任何优势，甚至会恶化延迟。

并发插入比负载数据好得多。考虑到 MySQL reference 中的签注负载数据，这听起来令人难以置信，但事实就是如此。

公平地说，与单线程插入相比，加载数据仍然要快得多。但是，它没有 4 个并发插入快。

3.使用较大的批量和适当的提交频率

批处理是使用扩展插件(insert into table values (1, 2), (3, 4))。影响？高达 83%的延迟降低！

现在，我们来谈谈提交操作。当您请求数据库提交时，数据库将执行日志刷新到磁盘，这将“正式”地将数据保存在数据库中。

理想情况下，我们只提交一次:在工作负载结束时。然而，这并不总是可行的。考虑一下:如果您有如此多的数据，以至于您的批量插入需要 6 个小时才能运行，那么在这 6 个小时中，您不能总是保证数据库连接是稳定的。一旦它断开，你失去了整个进程，需要从头开始。因此，更实用的方法是每隔几行提交一次。

由于日志刷新操作很慢，因此提交次数越少，总体工作负载越快，对吗？

令人惊讶的是，没有。更频繁的提交比不太频繁的提交稍微快一些。但是，如果我们将批处理大小从 30，000 行调降至 300 行，这种趋势就不成立，如下图所示。

要点是在执行提交之前有一个理想的行数(或者更准确地说，字节数)。

4.额外好处:使用自动递增主键

我收到的一个提示是，自动递增主键比没有主键要快。但是说真的，到底快了多少？

回答:一点也不多，但仍然是最快的。

最慢的设置是当主键以无序的方式随数据一起提供时。即便如此，情况也没有明显恶化。

虽然这有点道理，但在数据中提供主键意味着向数据库发送更多的字节。一旦有了数百万行，每行的额外小字节就会堆积起来。

结论

在本文中，我们学习了 3 种方法，它们可以最大限度地降低批量插入工作负载的延迟。它们是:

推迟建立索引
并发插入
使用较大的批量和适当的提交频率

要避免的 3 个数据湖反模式

原文：https://towardsdatascience.com/3-data-lake-anti-patterns-to-avoid-9be741f1d866?source=collection_archive---------18-----------------------

摆脱这些令人烦恼的习惯，开始掌握数据湖的旅程

由阿里·兹比布在 Unsplash 上拍摄的照片

介绍

数据湖提供了诱人的性能提升，这是其高采用率的主要原因。尽管有时技术性能的承诺会掩盖不愉快的开发体验。

这很麻烦，因为我相信在证明技术或范例的价值时，开发人员的体验同样重要，如果不是更重要的话。

当创建和维护像数据湖这样的复杂系统时，不友好的用户工作流和界面会降低生产力，就像一个应用程序有太多的技术债务或糟糕的文档一样。

反模式#1

您经常点击 S3(或类似的)存储控制台

具有数据湖的不友好工作流的一个症状是在湖的存储服务选择上花费太多时间。

在我职业生涯早期的一个案例中，这是一个 S3 数据湖，有一天我意识到在 AWS 控制台上查看分区中存在的文件数量或某个表的数据存储在哪个路径下所花费的时间是不健康的。

相比之下，没有人会进入数据库内部查看表存储在 B 树的什么位置。

缓解策略: 在您的数据湖中不可避免地会出现问题。有一天，一个供应商在发送数据文件时会遇到问题。有人会意外地多次重新运行不应运行的摄取作业。

在调试此类问题(或在某些情况下，误报警)的过程中，通过检查文件的last_modified_date或检查当前分区中的行数来扮演侦探并调查所发生事件的证据将是有用的。

我的建议是让这个过程变得更友好，有两点:

维护一个内部调试手册文档页面，指定出现的问题，并详细说明识别和解决这些问题所采取的步骤。这有助于防止知识在团队中囤积，避免每个可怜的 it 人员不得不自己找出解决问题的最佳方法。
当常见的调试模式出现时——比如文件检查的数量——开发一种方法来在内部表格或仪表板中自动报告这些指标。下一次出现问题时，您应该有一个单一窗格视图，可以快速显示您的湖泊最近的行为。

这些做法的目标是防止您需要检查存储控制台中的大多数问题。当你这样做的时候，让它成为一个简单，快速，有针对性的调查。

反模式#2

您通过物理复制文件来创建同一数据集的多个版本

每个目录包含同一个数据集的几乎完全相同的副本。

如果您打开对象存储的控制台，看到这样的目录结构，我会立即知道您是一个数据湖爱好者。

我知道，因为物理复制文件是一个乏味的过程，招致不必要的成本。这是一个随着数据规模而增长的问题。

如果您可以编写一个 shell 命令并获得相同的效果，而不是复制文件，会怎么样呢？

> lakectl branch create <branch uri>

这是如何工作的？

幸运的是，通过在您的 lake 上连接一个 git-for-data 工具，这个问题已经基本解决了。

通过利用关于 lake 中文件及其内容的元数据，分支或提交集合等熟悉的操作成为可能。当您拥有这些操作时，对数据湖进行迭代和试验会更快、更安全。

虚拟添加到 s3 集合的分支的视觉效果。

要了解更多信息，请查看开源项目 lakeFS 及其文档页面！

反模式#3

您有基于文件路径模式的复杂数据处理逻辑

就像 Eve 站在苹果树前一样，您可能会对对象的 filepath 字符串使用逻辑来决定它在数据湖中的命运。

不要这样做！

如果您使用了上面例子中的代码，是的，您已经设法编写了一个函数来处理将不同的数据集移动到数据湖中适当的位置。

然而，你实际上所做的是增加你的数据处理代码的圈复杂度，并使它的维护复杂化。

每当添加一个新的数据源时，您都必须考虑它在哪里着陆的含义，以及基于这个集中的功能，它将在哪里结束。对一个数据集的任何更改都需要了解是否会对其他数据集产生意想不到的影响。

改做什么:

解决方案很简单-使用单独的方法来处理湖泊中的每个数据集。对于简单的操作，如将文件从一个 S3 键复制到另一个键，在这些方法中仍然应该使用公共的帮助函数。

明确地说，文件路径字符串上的一些逻辑是不可避免的。但是要小心嵌套逻辑，尽可能使代码清晰易读。

包扎

在本文中，我们讨论了为什么这是一个令人不安的迹象，如果你是:

点击存储控制台以调试每个问题。
在数据湖中物理复制文件。
在处理代码时过度依赖文件路径名。

避免这些反模式并遵循最佳实践应该有助于轻松维护您的数据湖！

注:本文为 原载于 lakeFS 博客 。

3 数据可视化错误以及如何避免它们

原文：https://towardsdatascience.com/3-data-visualisation-mistakes-and-how-to-avoid-them-bb0e0625380d?source=collection_archive---------39-----------------------

数据可视化应该讲述一个故事，而不是分散或混淆你的观众

由 Charles Deluvio 在 Unsplash 上拍摄的图像

数据可视化是一门独立的学科。正好大家不喜欢看数据表。他们更喜欢丰富多彩的故事。数字只是数字，但它们的解释才是最重要的。因此，可视化有助于理解趋势、分布和数据模式。

可视化赋予数据生命。它将数字答案转化为可操作的建议。这些支持最重要的商业决策。然而，信息可以以许多不同的方式可视化。

这是一项创造性的工作。但是太多的创造力正在偏离它的目标。我不得不经常和那些想让数据变得“漂亮”的制图同事们争吵。

他们的创意太抽象，不足以支持实际的解释。经验法则是，如果你做数据可视化，第一眼就应该清楚你在展示什么。

做一个可视化专家，不要犯这些错误。

1。太有创意还是太简单

我们有一些销售数据要在演示中展示。该数据是关于有多少女性和多少男性购买该产品。我们有 30%的女性和 70%的男性。这里有两个解决方案。哪个更好？

Ivona Fikejzlova 提供

销售分布是一条简单的信息。这就是为什么我们可以使用信息图表的方法。第一种情况是抽象的，使用性别图标和篮子。作者还增加了男性的标志，以加强我们有更多的男人的信息。

然而，它需要观众的一些心理活动来解释它。为了避免误解，我们应该避免太有创造性或太抽象。

第二种解决方案更符合字面意思。它显示图标、数字和文本。在我们看来，这本书在这种情况下更好。

尽管如此，你不必想象所有的事情。你有时可以在标题中加入一句没有任何视觉线索的关于数据的句子:“销售数据:30%的女性和 70%的男性。”

2.饼图已死

我们现在有 2019 年和 2020 年之间的销售数据对比。数据显示了性别分布。这里有两个解决方案。哪个更好？

Ivona Fikejzlova 提供

饼图是您在媒体或工作中看到的基本图表之一。在我看来，我们应该停止使用它。

馅饼应该作为甜点保存，而不是数据可视化。如果我们有一个馅饼，它仍然是很好的。但是如果我们有更多的饼图在一起，它们很难阅读和比较它们的值。

当我们需要比较达到 100%的数据时，使用条形图会好得多。乍一看，差异非常明显。另一个优点是条形图比饼图占用更少的空间，并且很容易更新。你只要再加一排或科拉姆。

3.条形图智慧

这次我们有来自员工满意度调查的数据。我们有一个矩阵问题，有陈述和一定程度的一致。我们希望显示所有陈述，并根据员工任期比较它们的平均值。这里有两个解决方案。

哪个更好？

Ivona Fikejzlova 提供

条形图是另一种经典的数据可视化。但是，通常还有改进的空间。第一个看起来还可以，但还可以更好。x 轴不容易阅读，因为语句太长。

图例在右边。这是不合逻辑的，因为人们从左向右阅读。最后，数据没有以任何方式分类。

第二种更好。由于我们在标题中包含了关键句子，所以语句被缩短了。这些数据是根据一个类别整理出来的，即最新的雇员。

所以，总的来说，阅读和从数据中获取想法更容易。

最终数据可视化思想

数据可视化在你讲故事的过程中扮演着重要的角色。

它应该加强你的观点，而不是分散观众的注意力或导致混乱。所以，永远要想好你想说什么，怎么说。

少即是多！尽量让数据美观，但要保持易读。

因此，要小心信息图的抽象，尽量避免饼图，尽可能简化条形图。即使没有你的口头陈述，你的图表和可视化也应该是可以理解的。

想象一下，你的演讲流传开来，你所有的同事都能理解吗？如果答案是肯定的，你做得很好！如果答案是否定的，那么是时候减少创造性，增加高质量的图表了。

附:在你的收件箱里获取更多的提示。 在这里做那个 ！如果你喜欢自己体验媒介，可以考虑通过注册会员 来支持我和其他成千上万的作家 。你每月只花 5 美元。

在 VSCode 中折叠文档字符串的 3 个简单步骤

原文：https://towardsdatascience.com/3-easy-steps-to-folding-docstrings-in-vscode-fbb64573611b?source=collection_archive---------6-----------------------

如何在不弄乱源代码或降低可读性的情况下向 VSCode 数据科学项目添加文档

穆罕默德·拉赫马尼在 Unsplash 上的照片

背景

使用 VSCode 的程序员应该将“文档字符串”添加到他们的项目中，当他们在 VSCode 中将鼠标悬停在该代码上或在 Jupyter 笔记本中按下 Shift-Tab 时，这些项目会为代码的用户生成文档以供阅读。

程序员也可以使用扩展来自动生成文档字符串骨架以节省时间，例如，优秀的 Python 文档字符串生成器可以在这里获得—【https://marketplace.visualstudio.com/items? itemName = njp Werner . autodocstring。

然而，文档字符串占据了大量的垂直空间，当你添加一些时，它们会使实际的代码可读性更差，更难理解。

我自己也有过这样的经历，我想要两全其美——既生成有用的描述性文档，又不降低可读性，但是当我在网上搜索时，似乎无法做到这一点—https://github.com/microsoft/vscode/issues/37052

我毫不气馁，根据我读过的文章寻找解决这个问题的方法，果然，这个问题很容易解决，你可以一边吃蛋糕一边编码！

问题是

如果您安装了 Python Docstring Generator 扩展，您只需在代码中的正确位置键入 3 个双引号，就会为您创建框架 Docstring-

步骤 1 —键入 3 个双引号

作者图片

步骤 2 —生成文档字符串

作者图片

步骤 3 —用详细信息改写默认值

作者图片

我们现在有了一个构造良好的 docstring，它将在 VSCode 或 Jupyter 笔记本中向我们代码的用户显示，但是当我们在一个中等大小的模块中添加了许多 docstring 时，它开始看起来混乱并且难以阅读。

解决方案

步骤 1 —折叠参数并返回

第一步是认识到自动生成的 docstring 确实有一些有限的折叠功能。

如果您将鼠标悬停在代码行号和代码本身之间的空白上，您会看到许多向下的 v 形符号，它们指示当前折叠的位置，您会看到 Args 和 Returns 可以被折叠并折叠起来-

作者图片

这是一个小小的改进，但是文档仍然很大，在这一点上，你已经达到了在线建议的阶段，例如在https://github.com/microsoft/vscode/issues/37052中——说文档字符串的折叠还没有实现，但是可以实现……

第二步——折叠整个文档串

诀窍的关键是实现 VSCode docstring 折叠通过缩进工作，所以如果您手动重新安排 docstring 生成器生成的 docstring 来缩进参数和返回，您现在可以折叠、折叠和隐藏您的文档-

作者图片

这就好多了，但是它仍然占用了 2 行，而 1 行要整洁得多。

第三步——把它简化成一行

最后一个技巧是将结束的 3 个双引号包含到折叠中。要做到这一点，只需用一个额外的制表符缩进它们，或者将它们移到文档注释的最后一部分，我觉得这样更整洁

作者图片

代码现在有一个完整的 docstring，它将在 VSCode 或 Jupyter 笔记本中正确显示，该 docstring 已被折叠并收起，因此不会使代码变得杂乱，除非程序员希望单击向下的 v 形图标重新完整显示它。

结论

我们已经看到了 Docstring 如何为将在 VSCode 或 Jupyter 笔记本中显示给代码消费者的代码提供文档，以及 Python Docstring 生成器如何自动生成存根。

然而，这些文档字符串不能被折叠和收起，会很快弄乱代码，使其可读性更差，更难维护。

在线建议似乎表明在 VSCode 中不能折叠、收缩和隐藏 docstrings，但实际上有 3 个简单的步骤可以做到这一点。

实现这些步骤使我们能够同时拥有我们的编码蛋糕(文档)和吃掉它(可读性)!

感谢您的阅读！

如果你喜欢读这篇文章，为什么不看看我在 https://grahamharrison-86487.medium.com/的其他文章呢？

此外，我很乐意听到您对这篇文章、我的任何其他文章或任何与数据科学和数据分析相关的内容的看法。

如果你想联系我讨论这些话题，请在 LinkedIn 上找我—https://www.linkedin.com/in/grahamharrison1或者发电子邮件到ghar rison @ Lincoln college . AC . uk。

熊猫中交叉表的 3 种简单方法

原文：https://towardsdatascience.com/3-easy-ways-to-crosstab-in-pandas-4123383bfbf2?source=collection_archive---------8-----------------------

提高数据处理技能的实用技巧

交叉制表是检验两个或更多分类变量或离散变量之间关系的简单而有效的方法。在本帖中，我们将看看在熊猫身上创建交叉表格的三种简单而有用的方法。

由马腾·德克斯在 Unsplash 上拍摄的照片

0.数据📦

在本文中，我们将使用 seaborn 的技巧数据集。

import pandas as pd # *This post uses pandas v1.3.0.*
from seaborn import load_dataset# Import data
df = load_dataset("tips")
df.head()

关于这个数据集(包括数据字典)的细节可以在这里找到(这个源实际上是针对 R 的，但是它看起来是指同一个底层数据集)。数据描述引用如下，以便快速访问:

一名服务员记录了他在一家餐馆工作几个月期间收到的每一笔小费的信息

让我们来看看数据框的摘要:

df.info()

有 244 个记录和 7 个变量(4 个分类变量和 3 个数值变量)。没有缺失值。

📍 1.使用交叉表()

第一种方法是使用crosstab()。这个函数使得计算总数和百分比变得非常容易。

📘 1.1.计数和百分比

让我们统计一下时间和日期的类别:

pd.crosstab(df['time'], df['day'])

从这个表中，我们可以看到这个数据集中没有周末午餐时间的记录。这可能暗示我们，要么记录的服务员在周末午餐时间不工作，要么餐馆在周末午餐时间不营业。

通过调整以下参数，可以使用crosstab()轻松地转换为百分比或相加总计:
✅️ ️ normalize='columns':转换为列%
✅️ ️ normalize='index':转换为行%
✅️ ️ normalize='all'或️ normalize=True:转换为表%
✅️ ️ margins=True:相加总计(总计的类型取决于normalize参数)

让我们看一个例子:

pd.crosstab(df['time'], df['day'], normalize='index', margins=True)

行总计在这里不会提供太多的值，因为每个行总计只会显示 1，所以 pandas 很聪明，在这个例子中只显示列总计。如果您正在使用 Python，尝试调整到不同的normalize和margins组合，并注意表格是如何变化的。

📙 1.2.聚合数值

除了按类别获取计数和百分比，我们还可以按类别查看数值变量的值。例如，我们可以通过日和时得到中位数小费，如下所示:

pd.crosstab(df['time'], df['day'], df['tip'], aggfunc='median')

我们还可以在行和列中包含多个变量:

pd.crosstab([df['sex'], df['smoker']], 
            [df['time'], df['day']], 
            df['tip'], aggfunc='median')

要获得多个聚合，我们可以在一个列表中传递它们:

pd.crosstab(df['time'], df['day'], df['tip'], 
            aggfunc=['median', 'mean'])

crosstab()的一个缺点是，每次我们指定一个有点重复的变量时，我们都需要引用数据帧的名称。

📍 2.使用 pivot_table()

下一个函数(或方法)是pivot_table()。当按类别聚合数字变量时，这种方法非常灵活。

📘 2.1.计数和百分比

让我们用pivot_table()重新创建上一节的第一个交叉表:

pd.pivot_table(df, 'tip', 'time', 'day', aggfunc='count')

也可以使用 DataFrame 方法编写此查询:

df.pivot_table('tip', 'time', 'day', aggfunc='count')

我们可以用margins=True得到行、列和表格的总数:

df.pivot_table('tip', 'time', 'day', aggfunc='count', margins=True)

与crosstab()不同，我们需要第三个变量:提示来获取计数，并且没有一个简单的选项来获取百分比。但是我们不必在每次引用变量时重复输入数据帧名称。

📙 2.2.聚合数值

让我们看一下从上一节中获取相同的三个表的语法:

df.pivot_table('tip', 'time', 'day', aggfunc='median')

df.pivot_table('tip', ['sex', 'smoker'], ['time', 'day'], 
               aggfunc='median')

df.pivot_table('tip', 'time', 'day', aggfunc=['median', 'mean'])

另外，我们可以用pivot_table()看多个数值变量。这在目前的crosstab()中是不可能的。我们可以按如下类别聚合多个数字列:

df.pivot_table(['tip', 'total_bill'], 'time', 'day', 
               aggfunc='median')

如果我们不指定 values 参数，它将使用 DataFrame 中的所有数字列。

df.pivot_table(index='time', columns='day', aggfunc='median')

因为没有提供第一个参数:values，所以我们不能再按位置传递参数。所以这一次，我们必须指定每个参数。

📍 3.使用 groupby() + unstack()

这种方法非常类似于 SQL 或 R (tidyverse)等语言中的聚合方式。因此，这可能是最常见的获取交叉列表的方法。

📘 3.1.计数和百分比

通过这种方法，我们可以得到时间和日期的计数，如下所示:

df.groupby(['time', 'day']).size().unstack()

获得总数或转换成百分比需要额外的数据操作，因为我们不再像前两节那样使用专门的函数。

📙 3.2.聚合数值

为了在中位数提示上得到相同的表格，我们使用:

df.groupby(['time', 'day'])['tip'].median().unstack()

df.groupby(['sex', 'smoker', 'time', 'day'])['tip']\
  .median().unstack(['time', 'day'])

此方法显示每个类别组合。结果，现在显示了周末午餐的空列，输出不如以前清晰。

我们还可以使用多个聚合函数:

df.groupby(['time', 'day'])['tip'].agg(['median', 'mean']).unstack()

类似于pivot_table()，我们也可以看多个数值变量:

df.groupby(['time', 'day'])[['tip', 'total_bill']].median()\
  .unstack()

与pivot_table()相比，通过时间和天用groupby()和unstack()更容易得到所有数值变量的统计:

df.groupby(['time', 'day']).median().unstack()

这就把它带到了这篇帖子的结尾！虽然这三种方法有相似之处，但对于某些任务，其中一种方法可以提供比其他方法更好的解决方案。希望您在下一个数据操作任务中能够熟练地使用它们！

塞缪尔·布林格森在 Unsplash 上拍摄的照片

您想访问更多这样的内容吗？媒体会员可以无限制地访问媒体上的任何文章。如果您使用 我的推荐链接成为会员，您的一部分会费将直接用于支持我。

感谢您阅读这篇文章。如果你感兴趣，这里有我关于熊猫的一些其他帖子的链接:
◼️️ 在熊猫中编写 5 个常见的 SQL 查询
◼️️ 在熊猫中编写高级 SQL 查询
◼️️ 给熊猫用户的 5 个提示
◼️️ 在熊猫中进行数据聚合的 5 个提示
◼️️ 如何在熊猫数据框架中转换变量
◼️️ 3 个简单方法

再见🏃 💨

3 个简单的方法让你的情节更好

原文：https://towardsdatascience.com/3-easy-ways-to-make-your-plots-better-d94147059470?source=collection_archive---------40-----------------------

强调外卖！

艾萨克·史密斯在 Unsplash 上拍摄的照片

图表通常是传达数据驱动的建议的最佳方式。视觉元素比文字更简单地吸引注意力并阐明复杂的想法:“一张图片胜过千言万语。”

但是并不是所有的图表都是一样的。图表应该传达外卖没有任何画外音。这篇文章列出了三个简单的技巧，让你的图表更有效。

示例-生产力水平与每周工作小时数

在 Jeff 和 J.J. Sutherland 的《Scrum:用一半的时间做两倍的工作的艺术》中，他们讨论了发现每周工作超过 40 小时的团队比每周工作少于 40 小时的团队完成得更少的研究(事实上，Henry Ford 在 1929 年测量了这一点并实施了 40 小时工作周！https://www . history . com/this-day-in-history/Ford-factory-workers-get-40 hour-week)。这是反直觉的。你可能会认为团队每周工作时间越长，回报越少，但是当他们投入更多的时间时，肯定会继续完成更多的工作。然而，这项研究表明，在 40 小时左右，你开始得到负回报！这是一个有趣的观点，可以用图表来说明。

让我们使用一家技术公司的模拟数据集，该数据集显示“小时”(工作日的哪个小时)。例如，1 =一天的第一个工作小时)和“生产率”(团队在一天中的每个小时修复的错误的平均数量)。我们将从显示关系的 ggplot2 图表开始。

不清楚的图表

现在问问你自己，如果除了图表之外没有任何背景，你能理解这个图表试图说明什么吗？大概不会。这就是第一个提示的来源。

提示 1——让标题成为外卖

总是让你的图表标题成为你希望读者从中得出的结论。这完成了两件事。

它清楚地强调了你的图表的要点
它迫使你思考为什么你首先要展示这个图表。

回到我们的例子，建议每天最多工作 8 小时(因为每天超过 8 小时，产生的错误比修复的更多)。让我们把它作为标题。此外，考虑到这一点，更容易想到对图表的其他改进:0 处的水平线表明每天工作 8 小时后继续工作是有成本的，而不是利益+红色和绿色阴影来强调坏的和好的区域。

题目中强调的外卖。标题使用 labs()，阴影使用 annotate()。

这样更好，但是如果没有解释，你仍然不能理解它的意思，这就引出了我们的第二个技巧。

提示# 2——始终要清楚地绘制轴和图例

上面的图表没有很好的坐标:不清楚“生产率”的衡量标准和“工作时间”指的是什么。我们还可以清理 x 轴，使它显示更清晰的数字，这将使键值(8)更容易阅读。

更清晰更干净的轴。轴标题使用 labs()，分隔符使用 scale_x_continuous()。

干净多了，但是趋势穿过 0 线的关键点仍然可以强调更多。

提示 3——在图表区域使用标注来突出关键点

我们可以通过直接在图表中使用大标注来突出关键点，使要点更加清晰。

标注强调关键点。这些也可以像所有之前的编辑一样添加到 ggplot2 代码(https://ggplot2-book.org/annotations.html)中。然而，我发现将图表复制并粘贴到 google slides 之类的东西中，然后为这些标注添加文本框和箭头，通常会更快、更有影响力。

总结

用你的图表把目标放在首位。首先，弄清楚你想传达的是什么信息。然后，尽你所能让这个信息清晰。

图表应该传达一个外卖，没有任何画外音。

标题应该传达要点
轴和图例应该足够清晰易懂，以消除配音的需要
标注强调图表区域中的其他关键点

附录

这是用来制作图表的代码

其中df是一个简单的数据集:

重塑熊猫数据框架的 3 种简单方法

原文：https://towardsdatascience.com/3-easy-ways-to-reshape-pandas-dataframe-5b2cbe73d60e?source=collection_archive---------11-----------------------

提高你的数据操作技能

数据有不同的形状和大小。作为处理数据的专业人员，我们经常需要将数据改造成更适合手头任务的形式。在本帖中，我们将看看重塑数据帧的 3 种简单方法。

迈克尔·泽兹奇在 Unsplash 上拍摄的照片

📍 1.使用 melt()将宽格式转换为长格式

让我们从导入库和加载示例范围的数据集开始:

import numpy as np
import pandas as pd
from seaborn import load_dataset# Load sample data
wide = load_dataset('penguins')\
        .drop(columns=['sex', 'island', 'culmen_length_mm'])\
        .sample(n=3, random_state=1).sort_index()\
        .reset_index().rename(columns={'index': 'id'})
wide

我们可以用如下的stack()将数据整形为长格式:

long = wide.set_index('id').stack().to_frame().reset_index()\
           .rename(columns={'level_1': 'variable', 0: 'value'})
long

它完成了工作，但这相当冗长，也不太优雅。幸运的是，使用melt()将数据转换成长格式变得很容易:

long = wide.melt(id_vars='id')
long

瞧啊。很简单，不是吗？值得注意的是，wide.melt(id_vars=’id’)也可以写成pd.melt(wide, id_vars='id')。

应用我们所学的知识来巩固我们的知识总是很重要的。我最喜欢的melt()的实际应用之一，你可能也会发现它很有用，那就是用它来格式化相关矩阵。虽然我们在宽中只有三个记录，但为了说明这个想法，让我们做一个相关表:

corr = wide.drop(columns='id').corr()
corr

这种格式很有用，因为我们可以将矩阵转换成热图来显示相关性。但如果你想深入细节，找到相关性高于某个阈值的变量，通常矩阵或热图是不够的。将矩阵转换成长格式会使这项任务变得容易得多:

corr.reset_index().melt(id_vars='index')

现在，有了这些长数据，我们可以很容易地通过“值”进行过滤，找到所需值之间的相关性。我们将进一步格式化数据，并过滤 0.9 和 1 之间的相关性:

corr.reset_index().melt(id_vars='index')\
    .rename(columns={'index': 'variable1', 
                     'variable': 'variable2', 
                     'value': 'correlation'})\
    .sort_values('correlation', ascending=False)\
    .query('correlation.between(.9,1, inclusive=False)', 
           engine='python') # workaround of [this bug](https://github.com/pandas-dev/pandas/issues/34251)

你甚至可以删除重复的相关性。当您拥有包含许多数字要素的大型数据集时，这种相关格式尤其有用。

📍 2.使用 pivot()将长格式转换为宽格式

另一方面，有时数据是长格式的，我们需要把它改造成宽数据。现在让我们做与之前相反的事情。与上一节类似，我们将从unstack()开始转换:

long.set_index(['id', 'variable']).unstack()

使用如下的pivot()可以完成相同的转换:

long.pivot(index='id', columns='variable', values='value')

这不一定更简洁，但与unstack()相比，可能更容易使用。到现在为止，你可能已经注意到melt()对于pivot()就像stack()对于unstack()一样。

将数据整形为宽格式的一个可能的实际应用是，如果您的数据是实体-属性-值(也称为 EAV)格式，如下所示:

eav = pd.DataFrame({'entity': np.repeat([10,25,37, 49], 2),
                    'attribute': ['name', 'age']*4,
                    'value': ['Anna', 30, 'Jane', 40, 
                              'John', 20, 'Jim', 50]})
eav

使用pivot()可以将数据重新格式化为每行代表一个实体(例如客户)的格式:

eav.pivot(index='entity', columns='attribute', values='value')

下次你知道如何重塑一个长数据！

📍 3.用 wide_to_long()将宽格式转换为长格式

我们学习了如何用melt()从长变宽。但是使用wide_to_long()功能，在某些情况下，整形比melt()更容易。这里有一个例子:

pop = pd.DataFrame({'country':['Monaco', 'Liechtenstein', 
                               'San Marino'],         
                   'population_2016' : [38070, 37658, 33504],
                   'population_2017' : [38392, 37800, 33671],
                   'population_2018' : [38682, 37910, 33785]})
pop

使用melt()，我们可以重塑数据并将其格式化如下:

new = pop.melt(id_vars='country')\
         .rename(columns={'variable': 'year', 
                          'value': 'population'})
new['year'] = new['year'].str.replace('population_', '')
new

使用wide_to_long()，获得相同的输出要简单得多:

pd.wide_to_long(pop, stubnames='population', i='country', j='year', 
                sep='_').reset_index()

使用该函数时，最好理解这三个主要术语:存根名称(stubnames)、后缀和分隔符(sep)。虽然这些术语可能是不言自明的，但一个示例可以澄清它们:人口是存根名称， 2017 是后缀，_ 是分隔符。后缀的新列名传递给参数j，唯一标识符列名传递给参数i。如果没有reset_index()，输出将如下所示，其中唯一标识符和后缀列位于索引中:

pd.wide_to_long(pop, stubnames='population', i='country', j='year', 
                sep='_')

默认情况下，后缀被设置为数值。因此，这在我们之前的例子中运行良好。但是对于这样的数据，它可能不起作用:

iris = load_dataset('iris').head()
iris

这一次，有两个存根名称:萼片和花瓣。在整形时，我们会将两者以列表形式传递给stubnames。后缀(即长度和宽度)不再是数字，因此我们需要在suffix参数中使用正则表达式指定该模式。

pd.wide_to_long(iris.reset_index(), stubnames=['sepal', 'petal'], 
                i='index', j='Measurement', sep='_', suffix='\D+')

希望这两个例子已经说明了wide_to_long()在正确的设置下是多么有用。

瞧啊。这是重塑熊猫数据的三种简单方法！如果你想了解更多，这里有他们的官方文档:[pd.melt()](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.melt.html)、[pd.pivot()](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.pivot.html)和[pd.wide_to_long()](https://pandas.pydata.org/docs/reference/api/pandas.wide_to_long.html)。

照片由迈克尔·泽兹奇在 Unsplash 拍摄

您想访问更多这样的内容吗？媒体会员可以无限制地访问媒体上的任何文章。如果您使用 我的推荐链接 ，成为会员，您的一部分会费将直接用于支持我。

感谢您阅读这篇文章。如果你感兴趣，这里有我关于熊猫的一些其他帖子的链接:
◼️️ 在熊猫中编写 5 个常见的 SQL 查询
◼️️ 在熊猫中编写高级 SQL 查询
◼️️ 给熊猫用户的 5 个提示
◼️️ 关于熊猫中数据聚合的 5 个提示
◼️️ 如何在熊猫数据框架中转换变量

再见🏃 💨

3 种有效的方法，让您的笔记本电脑性能提高 10 倍，同时节省资金

原文：https://towardsdatascience.com/3-effective-methods-to-increase-the-performance-of-your-laptop-by-10x-while-saving-money-5db0a3d86123?source=collection_archive---------40-----------------------

赋予您的笔记本电脑新的生命

照片由 XPS 在 Unsplash 上拍摄

慢速笔记本电脑？放心吧！的确，你的笔记本电脑在工作几年后可能会变慢。然而，有一些可靠的方法可以显著提高笔记本电脑的速度。与购买一台全新的笔记本电脑相比，你不需要投入大量资金来尝试这些方法。然而，实施这些方法后，您将获得与全新产品几乎相同的性能。在你去购买一台全新的笔记本电脑之前，我建议你试试这些方法，这样可以节省很多钱！

**更新(2021–08–16):**观看下面的视频，看看我的经济型和入门级笔记本电脑在我实施了这里描述的 3 种方法后，如何仅用 47 秒就启动并启动所有这些应用程序。

(视频由作者创作)

从固态硬盘启动

如果你的笔记本电脑从硬盘启动，你的笔记本电脑会非常慢。硬盘有活动部件，读写数据需要大量时间。在使用硬盘时，您肯定经历过某种滞后和性能问题。相比之下，SSD(固态硬盘)没有移动部件，并根据您使用的 SSD 类型，为您提供显著的性能提升(10 倍至 15 倍)。有两种方法可以将固态硬盘安装到笔记本电脑上:

用 SSD 替换硬盘 —当笔记本电脑主板上没有单独的 SSD 插槽时，应该使用这种方法。
只安装 SSD —当笔记本电脑主板上有单独的 SSD 插槽时，可以使用此方法。

用 SSD 更换硬盘

为了获得更好的性能，首先确保您的笔记本电脑主板有一个 SATA 6 Gbps 端口，您当前的硬盘通过该端口连接到笔记本电脑。低于 6 Gb/s 端口的速度，您不能指望固态硬盘有多高的性能。要检查这些信息，您可以使用 hwinfo 免费软件，该软件可免费用于非商业用途。访问网页并从本地(美国)服务器下载。然后运行安装程序并安装程序。使用默认设置运行已安装的程序。它将开始分析你的系统硬件。完成后，单击“摘要”选项卡。

由 hwinfo 给出的我的系统硬件信息(作者截图)

我用了 4 年的笔记本电脑有一个 6 Gbps 的 SATA 端口。如果我把硬盘换成固态硬盘并从它启动，我可以获得更好的性能。

最重要的是，你应该买一个 2.5 英寸的固态硬盘来取代硬盘。一个 m.2 外形的 SSD 是不能用你的硬盘代替的！

2.5 英寸固态硬盘(作者提供图片)

安装 SSD 后，需要将操作系统、系统驱动程序和其他程序重新安装到新的 SSD 中。因此，我强烈建议您备份您的数据、软件产品密钥和其他有用的帐户信息，以避免任何可能的损失。

正在安装固态硬盘

如果你的笔记本电脑主板有一个单独的固态硬盘插槽，你可以很容易地安装一个固态硬盘。这一次，你需要一个 m.2 外形的 SSD。笔记本电脑主板上的 m.2 插槽可以是:

PCIe 第二代
PCIe 第三代(NVMe)

如果你的主板支持 NVMe，选择比传统的第二代固态硬盘快得多的 NVMe 固态硬盘。

在这种方法中，您需要将操作系统和其他程序迁移/全新安装到 SSD，并在 UEFI (BIOS)设置中将其设置为引导驱动器。您也可以保留初始硬盘来存储您的文件。它将作为一个普通的闪存驱动器。我建议您全新安装操作系统，而不是迁移操作系统，以获得最佳性能。

另外很重要的一点是，添加新的 SSD 后，需要手动初始化才能在系统中看到。从控制面板打开磁盘管理窗口，如果你打算安装新版本的 Windows，用 GPT 分区方式初始化你的新 SSD。

从固态硬盘启动的优势

更快的启动
无延迟体验
快速打开程序
节省电池
减少噪音

添加另一个 RAM 棒来启用双通道模式(如果可能)

最好有两个闸板杆而不是只有一个总闸板杆。一些主板和处理器支持双通道模式，以实现更快的内存访问。

任务管理器给出的内存信息(作者截图)

hwinfo 给出的内存信息(作者截图)

由 hwinfo 给出的当前内存设置(作者截图)

如果你打算添加另一个内存棒，首先确保你的笔记本电脑主板有一个额外的内存插槽。然后考虑内存类型，这对于避免兼容性问题非常重要。我的情况是 DDR4 SODIMM。我的笔记本电脑支持两个内存通道！然而，现在只有一个通道是活动的。这是因为我只有一个 RAM 棒。如果我安装另一个 RAM 棒，我可以在双通道模式下运行。

使用有些现代的主板，实际上可以在双通道模式下运行两种不同的内存。但是内存类型应该是一样的。您可以安装两个相同内存类型的 RAM 棒，但品牌、时钟速度和大小不同。两个记忆棒都将在双通道模式下运行，但主板和系统 BIOS 会改变时钟速度，以匹配两个 ram 的时钟速度。举个例子，

目前，你有一个 2933 MHz 时钟速度的内存。你安装一个 3200 兆赫的记忆棒。在这种情况下，不会有性能损失。两者都将工作在 2933 MHz，这是初始时钟速度。
目前，你有一个 3200 MHz 时钟速度的内存。你安装一个 2933 兆赫的记忆棒。在这种情况下，会有少量的性能损失。两者都将工作在 2933 MHz，这不是初始时钟速度。

也可以放一个时钟速度高于主板支持速度的 RAM 棒。但是，您无法获得 RAM stick 标签上指定的速度。

为了避免任何性能损失，最好放置一个时钟速度与当前安装的相同或更高的 RAM 棒。

增加更多的内存会提高系统的性能，但不如从 SSD 启动的性能高。

添加更多内存的好处

改善多任务处理
快速打开程序
双通道模式可加快内存访问速度

执行 Windows 的全新安装

如果您当前的 Windows 操作系统有恶意软件、垃圾文件和其他类型的问题，会大大降低您系统的性能，这是强制性的。全新安装将消除所有这些问题。全新安装意味着通过删除所有分区来擦除整个磁盘或驱动器，并执行全新的 Windows 安装。这将删除系统上的所有程序、驱动程序和数据。因此，在全新安装后，您需要重新安装系统驱动程序和其他第三方软件。您需要在任务开始前备份所有数据。

要执行 Windows 的全新安装，需要从微软官网下载 Windows ISO 文件。它是免费下载的。可以通过 Windows media creation tool 下载。下载后，您需要从 ISO 文件创建一个可引导的 USB。为此，您可以使用 Rufus 及其默认设置。我建议您保留默认设置，以避免任何潜在的问题。Windows media creation tool 也有一个从 ISO 文件制作可引导 USB 的选项。如果您愿意，可以使用该选项。如果你想在将来创建多个可启动的 USB 驱动器，只需下载 ISO 文件并使用前面解释的 Refus。

大部分笔记本电脑都是吸着制造公司激活的窗口。在这种情况下，安装程序不会在新的 Windows 安装过程中要求您输入产品密钥。它会自动从系统固件中获取。

全新安装的优势

删除病毒
删除垃圾文件
删除有害程序
获取最新的操作系统和其他软件
解决软件的兼容性问题

执行这些升级需要花费多少钱？

可能是新笔记本电脑价格的 1/10 左右。你需要购买一个额外的固态硬盘和内存棒。我建议你按照上面的顺序来执行上面的方法。这些方法将大大提高你的笔记本电脑的性能，同时节省你的钱！

最后一件事。这些是一般说明。要获得特定于您的笔记本电脑的详细信息，我建议您参考设备手册或网站支持。

**你试过这些方法，需要一些技术支持吗？**请在评论区告诉我。我会尽我所能帮助你。

感谢阅读！

下次见，祝大家学习愉快！

特别感谢 Unsplash 上的 XPS ，为我提供了这篇文章的漂亮封面图片。

鲁克山普拉莫迪塔
2021–08–09

开始使用 Google Data Studio 的 3 个基本技巧

原文：https://towardsdatascience.com/3-essential-tips-to-start-using-google-data-studio-93334a403d11?source=collection_archive---------12-----------------------

路易斯·维拉斯米尔在 Unsplash 上的照片

任何称职的数据科学家都知道，数据可视化是他们向不太懂数字的受众传达具有挑战性的复杂想法的最佳工具。在业务环境中，您会发现自己的任务是尽快创建可读性强、有吸引力的报告，因此您需要一个易于使用、有效的工具，老实说，它可以为您完成大部分艰巨的工作。如果你还没有去过 Google Data Studio，你应该去看看。我最近写了一篇博文，讨论为什么这个新的免费平台值得你花时间，如果你还需要说服的话，你可以在这里看看。

也就是说，如果没有正确的提示和技巧，您可能会发现自己对迟钝的错误代码和可怕的死亡痛苦感到沮丧。我知道我花了几个月的时间处理数据源，才找到了我的最佳状态，并能够立即为我的整个团队创建漂亮的交互式仪表板，所以希望有了这些提示，你会比我更快地到达那里。

我讨厌这东西

1。如何将熊猫的数据加载到 GDS

照片由翻滚 926 上的 Unsplash

好吧，每当我用一个新的程序进行数据操作时，我想知道的第一件事就是如何上传我的熊猫数据帧，这样我就可以完全控制我的绘图功能和合并。将数据源加载到 GDS 时，您有多种选择，大多数默认设置都可以正常工作。如果你有一个谷歌分析账户，你可以上传大量的网络流量数据，尽管实时处理和过滤可能比冰风暴中的糖蜜还慢。只要您有正确的凭证和正确的查询，您还可以连接 SQL 数据库。

也就是说，出于几个原因，我最喜欢的数据源将永远是 Google Sheets。1)对于较小的数据集(100k 行或更少),连接速度可以接受；2)Google Sheets 有大量关于函数和数据操作的文档，可以转移到 Google Data Studio；3)Python 3 有一个方便的包，名为 gspread ,包含了将 google sheet 导入 Jupyter 笔记本或将 dataframe 上传到工作簿所需的所有方法。这篇文章是我构建基本 Google Sheet 脚本时的圣经。您与您的开发者帐户共享的任何表单都可以通过 gspread 访问。下面是我用来将谷歌表单导入熊猫的函数:

def open_google_sheet(wookbookname,sheet_num=0):‘’’Requests a Google sheet saved as ‘workbookname’ using credentials for developer email.Credentials for Google API are stored in /Users/#########/.config/gspread/service_account.jsonsheetname = The name of the Google sheet file as seen on Google. Entered as a string.sheet_num = The sheet number for the Google Sheet. Defaults to 0 if no entry.Parameters — — — — — workbookname: The name of the Google Sheet that you intend to opensheet_num: The number of the sheet in the Google Sheet you intend to open (numbering begins at 0)Returns — — — -DataFrame: A DataFrame of the information contained in the Google Sheet‘’’scope = [‘https://spreadsheets.google.com/feeds',‘https://www.googleapis.com/auth/drive']credentials = ServiceAccountCredentials.from_json_keyfile_name(‘/Users/######/.config/gspread/service_account.json’, scope)#If credentials change, must change json file.gc = gspread.authorize(credentials)wks = gc.open(f”{workbookname}”).get_worksheet(sheet_num)data = wks.get_all_values()headers = data.pop(0)df = pd.DataFrame(data, columns=headers)return df

这是我的代码，用来更新你选择的 Google 表单(空白或其他)。它将自动匹配单元格的更新值，因此我建议抽查重复值，或者在点击此函数的“运行”之前删除单元格值:

def update_sheet(df, workbookname, sheet_num=0):'''Updates the sheet in question by adding the requested dataframe to the end of it.You can choose which sheet number as well as which Google Sheet. There will be a result output if there are no errorsParameters----------df:    (DataFrame) - a DataFrame without any null values, sets, dictionaries, or lists contained in its rowsworkbookname:    (str) - name of the Google Sheet that is connected to the ##########@gmail.com email addresssheet_num:    (int) - the index of the sheet. Index begins at 0.Returns-------Updates the Google sheet in questions. Prints a json update to state the update was successful'''scope = ['https://spreadsheets.google.com/feeds','https://www.googleapis.com/auth/drive']credentials = ServiceAccountCredentials.from_json_keyfile_name('/Users/#####/.config/gspread/service_account.json', scope)#If credentials change, must change json file.gc = gspread.authorize(credentials)wks = gc.open(f"{workbookname}").get_worksheet(sheet_num)result = wks.update([df.columns.values.tolist()] + df.values.tolist())return result

在你不顾一切地乱丢谷歌工作簿之前，给你一些忠告。第一， gspread 包不喜欢 NaN 值。如果您的数据帧中有任何 NaNs，该函数将抛出一个错误。它也不能处理 iterables，所以如果您的任何数据包含列表，您将希望在上传它们之前解包它们。或者，您可以将列表转换为字符串，然后在 Google Data Studio 中将它们转换为新的数据类型，但这是经销商的选择。

第二，虽然 Google Sheets 给人的感觉是无限大，但事实并非如此。工作簿最多可以支持 500 万个单元格，这听起来很不错，直到您有一个 12 万行 50 列的数据集。另外，请记住，这个限制是工作簿的**，而不是工作表的，这意味着如果您有一个大规模数据集，您可能应该将它作为数据源上传到一个干净的工作簿中。**

但是有了这些函数，您现在可以创建从 python 环境到 GDS 可视化的数据管道了！不仅如此，许多主要软件公司都支持 Google Sheets 插件，以进一步自动化您的管道(Salesforce one 非常出色)。

2.知道 GDS 的局限性，不要指望技术支持

照片由 krakenimages 在 Unsplash 上拍摄

我之前提到过，但知道这一点非常重要:Google Data Studio 的优势在于它能够创建复杂的可视化效果，可以与团队进行交互和共享。而且，即使它有一些非常基本的操作能力，它也不是一个数据操作工具。据我所知，GDS 读取数据很像一个 SQL 查询，并为主动 groupby 函数提供默认聚合。如果它在一列中发现冲突的数据类型(假设一个日期列的值等于字符串‘N/A’)，它将在使用该列的任何图表或表格中抛出一个错误。

然而，Data Studio 最大的弱点是合并限制。首先，令人惊奇的是，你可以将两个以完全不同的方法交付给 GDS 的数据源连接在一起。假设您有一个客户列表、一个包含付款金额的交易列表和一个销售产品的员工列表。在 SQL 或 Pandas 中，我们知道可以很容易地用两个不同的主键连接这些表，例如:

有人从 SQL 实践中认识到这一点吗？

使用 GDS，虽然可以组合多个数据集，但是每个表中的必须存在相同的连接键。这正是我用 Pandas connection 教程作为这篇技巧的序言的原因，因为我经常在 python 脚本或 Jupyter 笔记本中混合数据，并在将预处理的数据集上传到 Google Data Studio 之前对行应用复杂的函数。

最后，如果你卡住了，你应该谷歌答案，但不要指望很快找到一个明确的答案。提交票证以获得支持时，我遇到了挑战。如果没有 Google 360 的企业许可证——它的年费高达 15 万美元以上——最好的技术支持就是把你带到论坛上去，那里的问题有时比答案还多。也就是说，功能每天都在增加，所以今天可能是一个 bug，明天可能就消失了。

哦，如果一些疯狂的事情开始发生，只要刷新数据。GDS 有时会变得…困惑。

3。列和度量的区别

这最后一个技巧将很快成为自己的博文，但是我想在开始之前给你提个醒。加载数据源后，您必须始终检查数据配置。Google 的优秀人员会尽最大努力将您的电子表格转换成干净、高效的数据类型，但是您会有错误和离群值，这会弄糟一切。这里有一个快速清单:

A)确保数据类型正确

这似乎是显而易见的，但很重要。我遇到的两个经典问题是，当 GDS 认为数字列是文本列时，可能是由于不兼容的数据或谷歌表单的奇怪格式。

B)在数据集级别创建函数，而不是在报表级别

Google Data Studio 拥有 Google Sheets 几乎所有的主要功能(说真的，Excel，因为如果它没有坏，就不要修复它！)，因此您可以使用 Google library 中的许多方法和函数来进行一些巧妙的数据操作。我最喜欢的一个方法是用 hyperlink()函数将文本转换成超链接。请记住，当您在报表上使用函数时，您可以选择添加一个函数来创建一个新的“指标”，也称为聚合列。虽然在两个不同的位置创建这些函数的过程基本上是相同的，但是如果在数据源级别创建，您将为每个报表提供对该列的相同访问权限。如果您在报表级别上这样做，您将只在特定的图表或表格中应用它，类似于 lambda 函数的工作方式。

3)指标是应用了聚合的列

这一部分对我来说不是直观的，但对你来说可能是。GDS 最强大的地方之一是它能够毫不费力地动态分组数据点。例如，如果您正在构建一个包含产品名称列和记录计数指标的表，GDS 将汇总包含该产品的每一行。如果你用产品价格来衡量呢？它很可能会将各个价格相加。您总是可以在报告或数据集级别上控制这些聚合，这很好，因为将一个列转换为指标就像将其放入指标类别一样简单。对于数字列，它将默认为 sum 聚合，但是您可以从大量的聚合选项列表中进行选择。对于文本列，您只能选择 count 或 count distinct，这两者都是必要时记录计数的可靠替代。

有一件事可能会让您犯错误，那就是，为了混合度量和列，您必须首先将列转换成度量。与几乎所有其他事情一样，您可以在报表或数据集级别上这样做。将列转换为指标的最简单方法是在公式级别应用聚合。例如:我有一个以美元为单位的销售列，我有一个记录计数指标。如果我想找到每行的平均销售额，我可以通过应用 AVG()函数或在公式中很容易地将销售额列转换为指标，您可以执行以下操作:SUM(price)/Record Count。由于记录计数已经是一个指标(蓝色表示指标，绿色表示列)，它已经应用了一个聚合。

你可以对你的数据进行大量的计算，这将有助于你根据需要进行切片、切块和分析。希望这些提示和技巧能在你遇到困难时指引你。如果您开始得到数据错误，有一大堆事情要检查，但是我的建议是确保您的列配置与列的值兼容。例如，日期列可能有一个值的格式与其他值不同。如果有疑问，请重新加载数据集，看看更改是否会自行修复。

我希望这有助于您开始使用市场上最好的、最用户友好的可视化工具之一。如果你想让我接下来谈一些具体的话题，请告诉我。我计划深入研究过滤(我最喜欢的交互特性)和 GDS 各种图表类型的最佳实践。

蒂姆·莫斯霍尔德在 Unsplash 上的照片

祝数据工作愉快！

Python 中计算要素重要性的 3 种基本方法

原文：https://towardsdatascience.com/3-essential-ways-to-calculate-feature-importance-in-python-2f9149592155?source=collection_archive---------1-----------------------

任何有抱负的数据科学家都必须知道的

由安东宁·杜阿利亚在 Unsplash 上拍摄

如何在数据集中找到最重要的要素？有大量的技术，本文将教你三种任何数据科学家都应该知道的技术。

阅读后，您将知道如何用 Python 计算特性重要性，只需几行代码。您还将学习这些技术的先决条件——这对它们正常工作至关重要。

你可以点击下载这篇文章的笔记本。

这篇文章的结构如下:

数据集加载和准备
方法#1 —从系数中获取重要性
方法#2 —从基于树的模型中获取重要性
方法#3 —从 PCA 加载分数获得重要性
结论

数据集加载和准备

让我们在这里花尽可能少的时间。您将使用内置于 Scikit-Learn 中的乳腺癌数据集。您还需要 Numpy、Pandas 和 Matplotlib 来进行各种分析和可视化。

以下代码片段向您展示了如何导入库和加载数据集:

数据集现在不是最方便的格式。大部分时间您将使用 Pandas 数据框，因此让我们快速将其转换为一个数据框。以下代码片段将预测值和目标变量连接成一个数据框:

调用head()会产生以下输出:

图片 1-乳腺癌数据集的头部(图片由作者提供)

简而言之，有 30 个预测因子和一个目标变量。所有的值都是数字，没有丢失的值。唯一明显的问题是规模。只需查看一下平均面积和平均平滑度栏，差异非常大，这可能会导致模型质量不佳。

在解决扩展问题之前，您还需要执行训练/测试分割。

以下代码片段向您展示了如何使用StandardScaler类进行训练/测试分割和缩放预测器:

这就是你开始获得特性重要性所需要的一切。让我们接下来做那件事。

方法#1 —从系数中获取重要性

检查特性重要性的最简单的方法可能是检查模型的系数。例如，线性回归和逻辑回归都可以归结为一个方程，其中的系数(重要性)被分配给每个输入值。

简而言之，如果分配的系数是一个大(负或正)数，它对预测有一些影响。相反，如果系数为零，对预测没有任何影响。

简单的逻辑，但让我们来测试一下。我们有一个分类数据集，所以逻辑回归是一个合适的算法。模型拟合后，系数存储在coef_属性中。

以下代码片段为逻辑回归模型定型，创建一个数据框，其中存储了属性及其各自的系数，并按系数降序对该数据框进行排序:

那很容易，不是吗？接下来让我们直观地检查一下系数。以下代码片段根据系数制作了一个条形图:

下面是相应的可视化:

图片 2-作为逻辑回归系数的特征重要性(图片由作者提供)

这就是这个简单技术的全部内容。一个要点是，系数越大(正向和负向)，它对预测的影响就越大。

方法#2 —从基于树的模型中获取重要性

在训练完任何基于树的模型之后，您将可以访问feature_importances_属性。这是获得特性重要性的最快方法之一。

下面的代码片段向您展示了如何在训练数据上导入和拟合XGBClassifier模型。重要性的获取方式与之前类似——存储到数据框中，然后按重要性排序:

您可以通过绘制条形图来直观地检查重要性。下面是制作一个的方法:

相应的可视化如下所示:

图 3-从基于树的模型中获得的特征重要性(图片由作者提供)

如前所述，以这种方式获得重要性并不费力，但是结果可能会有点偏差。这种方法的趋势是夸大连续特征或高基数分类变量的重要性[1]。确保先做好适当的准备和转换，然后就可以开始了。

方法#3 —从 PCA 加载分数获得重要性

主成分分析(PCA)是一种极好的降维技术，也可以用来确定特征的重要性。

PCA 不会像前两种技术那样直接显示最重要的特征。相反，它将返回 N 个主成分，其中 N 等于原始要素的数量。

如果你对 PCA 有点生疏，在本文末尾有一个完整的从头开始的指南。

首先，让我们将 PCA 与我们的缩放数据相匹配，看看会发生什么。以下代码片段就是这样做的，并且还绘制了累计解释方差的折线图:

下面是相应的可视化:

图 4——PCA 累积解释方差(作者图片)

但是这意味着什么呢？这意味着您可以用前五个主成分解释源数据集中大约 90%的差异。同样，如果您不知道这意味着什么，请参考从头开始指南。

你现在可以开始处理 PCA 加载。这些仅仅是原始变量线性组合的系数，从这些原始变量中构造出主成分[2]。您可以使用加载来寻找实际变量和主成分之间的相关性。

如果主成分和原始变量之间有很强的相关性，这意味着这个特征很重要——用最简单的话来说。

下面是用 Python 计算加载分数的片段:

相应的数据框如下所示:

图 PCA 加载分数的标题(图片由作者提供)

第一主成分是至关重要的。这只是一个单一的特征，但它解释了数据集中超过 60%的差异。从*图 5 中可以看出，*它和平均半径特征之间的相关系数几乎是 0.8——这被认为是强正相关。

让我们将所有输入特征和第一主成分之间的相关性可视化。以下是完整的代码片段(包括可视化):

相应的可视化如下所示:

图 6 —第一个主成分的 PCA 加载分数(作者图片)

这就是你如何“黑掉”PCA，将其用作特征重要性算法。让我们在下一部分总结一下。

结论

现在你知道了——你可以用三种技术来找出什么是重要的。当然，还有许多其他的，您可以在本文的了解更多部分找到其中的一些。

这三个应该很适合你做任何机器学习任务。只是要确保先做好适当的清洁、探索和准备。

感谢阅读。

喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。

https://medium.com/@radecicdario/membership

了解更多信息

2021 年学习数据科学的前 5 本书
Python 中从头开始的主成分分析
Python 中的特征选择——递归特征消除
Python-IV 和 WoE 中的属性相关性分析

参考

[1]https://towards data science . com/explaining-feature-importance-by-example-of-a-random-forest-d 9166011959 e
【2】https://scentellegher . github . io/machine-learning/2020/01/27/PCA-loadings-sk learn . html

原载于 2021 年 1 月 14 日 https://betterdatascience.com*。*

更有效地使用 Python 熊猫的 3 个例子

原文：https://towardsdatascience.com/3-examples-for-using-python-pandas-more-efficiently-8173873c0bc6?source=collection_archive---------13-----------------------

学习新工具的最好方法是通过实践。

布雷特·乔丹在 Unsplash 上拍摄的照片

Pandas 是数据科学生态系统中使用最广泛的 Python 库之一。它有许多功能和方法来执行有效和快速的数据分析和操作。

在这篇文章中，我们将通过 3 个例子来展示如何用熊猫做一些特定的操作。

练习的首要要求是数据。我准备了一个销售数据集，你可以从我的 GitHub 页面上的这个库下载。请随意使用它并跟随它。

让我们从导入 Pandas 并把数据集读入数据框开始。

import pandas as pdsales = pd.read_csv("sales.csv")sales.head()

销售数据框的前 5 行(图片由作者提供)

示例 1

熊猫最常用的功能之一是groupby。它基本上允许根据一列中的不同类别计算聚合值。

例如，我们可以计算每个产品组的平均产品价格，如下所示:

sales.groupby("product_group", as_index=False)["price"].mean()

(图片由作者提供)

有几个聚合函数可以和groupby一起使用，比如min、max、mean、count等等。这里我想展示的是，我们可以用 lambda 函数扩展groupby的功能。

数据框包含每种产品的价格和成本。假设我们想找出每个产品组中产品的平均利润。一种方法是创建一个包含利润信息的列，然后对其应用mean函数。如果您不喜欢创建新列，可以通过应用 lambda 函数来完成此操作，如下所示。

sales.groupby("product_group").apply(
   lambda x: (x["price"] - x["cost"]).mean()
)product_group
PG1    98.071795
PG2    42.973467
PG3    26.299231
PG4    13.141605
PG5    18.657765
PG6    15.200864
dtype: float64

示例 2

数据框中的重复行可能会导致严重的问题。我们所做的分析是不正确的，因此我们需要确保数据框中没有重复的行。

我们如何定义重复行取决于数据集。在我们的例子中，具有相同产品代码的两行被认为是重复的。在某些情况下，两行需要在所有列中具有相同的值才能成为重复行。

在处理重复行时，duplicated和drop_duplicates函数非常方便。

我们可以在产品代码列中找到重复条目的数量，如下所示。

sales.duplicated(subset='product_code').sum()47

如果产品代码重复，函数duplicated返回 true。通过应用sum函数，我们得到了重复产品代码的总数。

如果我们认为两行是重复的，如果它们具有相同的产品代码和产品组，那么我们将这些列作为列表传递给 subset 参数。

drop_duplicated函数从数据框中删除重复的行。

sales_new = sales.drop_duplicates(subset="product_code", keep="first")sales_new.duplicated(subset="product_code").sum()
0

keep参数用于确定数据帧中保留哪一个重复行。

对于duplicated和drop_duplicates函数，如果我们想要基于所有列评估行，我们不应该使用subset参数。

示例 3

我们并不总是有数字数据。它有不同的数据类型，如整数、浮点、字符串、对象、日期时间等等。为了执行高效准确的操作，使用适当的数据类型非常重要。

有些函数和方法只适用于某些数据类型。因此，在执行任何分析之前，我们应该转换存储不正确的列的数据类型。

假设我们有以下数据框。

df(作者图片)

df.dtypes
A      int64
B    float64
C    float64
D     object
E     object
dtype: object

列 C 似乎有整数，但由于 NaN 值，数据类型是 float。类似地，列 E 以对象数据类型存储，但它应该是布尔型的。

我们可以使用astype函数分别改变每一列的数据类型。然而，还有一个更有效的选项，那就是convert_dtypes功能。它将列转换为可能的最佳数据类型。

df_new = df.convert_dtypes()df_new.dtypes
A      Int64
B    Float64
C      Int64
D     string
E    boolean
dtype: object

(图片由作者提供)

结论

学习熊猫或任何其他软件工具的最好方法是通过练习。你的手越脏，你就越会利用熊猫。

当您开始处理需要更多清理和预处理的真实数据集时，您会更好地欣赏熊猫的功能和效率。

感谢您的阅读。如果您有任何反馈，请告诉我。

展示 PySpark 无限灵活性的 3 个示例

原文：https://towardsdatascience.com/3-examples-that-show-the-unlimited-flexibility-of-pyspark-319ab22d5a?source=collection_archive---------18-----------------------

Python 和 SQL 的结合，但比两者都简单

Genessa panainite 在 Unsplash 上拍摄的照片

Spark 是一个用于大规模数据处理的分析引擎。它让您可以将数据和计算分散到集群上，从而实现显著的性能提升。

收集、传输和存储数据比以往任何时候都更容易。因此，当我们处理现实生活中的问题时，需要处理大量的数据。因此，像 Spark 这样的分布式引擎在这种情况下变得必不可少。

PySpark 是 Spark 的 Python API。它给我们带来了 Python 语法的简单性，因此我们可以轻松地处理和分析大量数据。PySpark 的 SQL 模块更进一步，为我们提供了类似 SQL 的操作。

我在这里想说的是 PySpark 是一个非常高效的工具，具有易于使用和直观的语法。使 PySpark 成为如此简单的工具的一个重要因素是它提供的灵活性。

无论您习惯使用 Pandas 还是 SQL，学习 PySpark 都不会有困难。在本文中，我们将介绍 3 种常见的数据操作，展示其灵活性。

我们首先需要创建一个 SparkSession，作为 Spark SQL 的入口点。

from pyspark.sql import SparkSessionspark = SparkSession.builder.getOrCreate()

让我们通过读取 csv 文件来创建一个 spark 数据帧。我们将使用 Kaggle 上的墨尔本房产数据集。

file_path = "/home/sparkuser/Downloads/melb_housing.csv"
df = spark.read.csv(file_path, header=True)

1.选择列的子集

我们可能不需要数据集中的所有列。有些列可能是多余的，或者不适用于特定的任务。

PySpark 提供了多种选择列子集的方法。第一个是选择方法。

df1 = df.select("Type", "Rooms", "Regionname", "Distance", "Price")
df1.show(5)

(图片由作者提供)

我们也可以用类似熊猫的语法做同样的操作。

df2 = df["Type", "Rooms", "Regionname", "Distance", "Price"]
df2.show(5)

(图片由作者提供)

两种方法都可以。确保使用正确类型的括号。select 方法使用括号(“()”)，而另一个方法使用方括号(“[]”)。

2.筛选行

数据分析和操作中的一个常见操作是根据条件过滤观察值(即行)。我们将讨论 3 种不同的过滤方法。

第一个是过滤方法。

from pyspark.sql import functions as Fdf_sub = df2.filter(F.col("Rooms") == 4)

col 函数用于选择房间列，因此我们只选择有 4 个房间的房子。

就像前面的例子一样，我们可以用类似熊猫的语法做同样的操作。

df_sub = df2[df2.Rooms == 4]

最后但同样重要的是，可以使用 where 方法。它类似于 SQL 中的 where 子句。

df_sub = df2.where("Rooms = 4")df_sub.show(5)

(图片由作者提供)

我不认为我们可以声明一个方法比其他方法简单。这里的重点是强调使用 PySpark 进行操作的多种方式。它不会强迫你去适应一种特定的做事方式。与此相反，PySpark 符合你的口味。

3.创建新列

数据预处理通常涉及一些列操作。常见的操作之一是基于现有的列创建一个新的列。

让我们来看看在 PySpark 中创建新列的两种不同方法。我们将创建一个以百万为单位显示房价的列。因此，我们可以通过将价格列除以 100 万来实现它。

第一个选项是使用 withColumn 方法。

df2_new = df2.withColumn("Price_mio", F.col("Price") / 1000000)
df2_new.show(5)

(图片由作者提供)

第一个参数是新列的名称。第二部分包含计算值的操作。在第二部分中，我们不局限于简单的操作。事实上，PySpark 在创建新列时提供了很大的灵活性。

考虑这样一种情况，我们需要根据不同列中的值来更新价格。例如，我们可能想提高 h 类房屋的价格，其他房屋的价格将保持不变。

我们可以使用 withColumn 方法和 when 函数来执行此任务，如下所示。

df2_new = df2.withColumn(
   "Price_updated", 
   F.when(F.col("Type") == "h", F.col("Price") * 1.2).\
   otherwise(F.col("Price")))df2_new.show(5)

(图片由作者提供)

上面的代码告诉 PySpark 当类型为 h 时将价格列相乘，否则保持价格不变。

创建列的第二个选项是使用 SQL 查询。我们首先需要将数据框注册为临时表。

df2.registerTempTable("df2_table")

我们现在可以使用的就像一个 SQL 表。为了创建带有新列的数据框，我们可以编写如下 SQL 查询。

df2_updated = spark.sql(
     "select *, Price / 1000000 as Price_mio from df2_table"
)
df2_updated.show(5)

(图片由作者提供)

我们可以像查询 SQL 表一样查询临时表(df2_table)。例如，我们可以计算每个地区的平均房屋数量如下。

spark.sql(
    """
    select Regionname, avg(Price) as avg_price 
    from df2_table 
    group by Regionname
    """
).show()

(图片由作者提供)

结论

我们所做的例子清楚地展示了 PySpark 的灵活性。无论您是 Python 用户还是 SQL 用户，您都会找到使用 PySpark 的舒适方式。

PySpark 语法有点像 Python 和 SQL 的结合，但我认为它比两者都简单。

需要注意的是，Spark 针对大规模数据进行了优化。因此，在处理小规模数据时，您可能看不到任何性能提升。事实上，在处理小数据集时，Pandas 可能会比 PySpark 表现得更好。

感谢您的阅读。如果您有任何反馈，请告诉我。

3 个例子展示 Python Altair 不仅仅是一个数据可视化库

原文：https://towardsdatascience.com/3-examples-to-show-python-altair-is-more-than-a-data-visualization-library-700e37cbf95b?source=collection_archive---------12-----------------------

一个完整的数据探索工具

由 Unsplash 上的 Sigmund 拍摄的照片

Altair 是 Python 的统计数据可视化库。它为创建静态和交互式可视化提供了简单易懂的语法。

我最喜欢 Altair 的是数据转换和过滤功能。它提供了灵活多样的方法来转换和过滤数据，同时创建数据可视化。

在这个意义上，Altair 也可以被认为是一个数据分析工具。我们将讨论 3 个例子，展示 Altair 如何加快探索性数据分析过程。

我们将使用 Kaggle 上的墨尔本房屋数据集中的一个小样本作为例子。我们首先导入库并读取数据集。

import numpy as np
import pandas as pd
import altair as altcols = ['Type','Price','Distance','Date','Landsize','Regionname']melb = pd.read_csv(
   "/content/melb_data.csv", usecols = cols, parse_dates = ['Date']
).sample(n=1000).reset_index(drop=True)melb.head()

(图片由作者提供)

示例 1

我们将创建一个条形图，显示每个地区的平均房价。一种选择是使用 Pandas 的函数计算平均值，然后绘制结果。

然而，我们可以使用 Altair 一次完成所有任务。

alt.Chart(melb).mark_bar().encode(
   x = 'Regionname', y = 'avg_price:Q'
).transform_aggregate(
   avg_price = 'mean(Price)', groupby = ['Regionname']
).properties(
   height = 300, width = 500
)

语法以顶级图表对象开始，后跟绘图类型。encode 函数用于指定在传递给 Chart 对象的 dataframe 中绘制什么。

您可能已经注意到，y 编码不是数据帧中的一列。它是在下一步中使用 transform_aggregate 函数计算的聚合列。y 编码中的“Q”字母代表定量。

属性功能用于调整可视化的属性。下面是上面的代码生成的图。

(图片由作者提供)

示例 2

距离栏表示房子到中央商业区的距离。假设我们想要为距离超过 3 英里的房屋创建前面示例中的地块。

我们可以通过在代码中实现 transform_filter 函数来轻松完成这项任务。

alt.Chart(
  melb, height=300, width=500
).mark_bar().encode(
  x = 'Regionname', y = 'avg_price:Q'
).transform_filter(
  alt.FieldGTPredicate(field='Distance', gt=3)
).transform_aggregate(
  avg_price = 'mean(Price)',groupby = ['Regionname']
)

FieldGTPredicate 处理“大于”条件。Altair 还为“等于”、“小于”、“范围”等其他条件提供了谓词。

在前面的例子中，我们使用了 properties 函数来调整大小。在本例中，相同的操作在 chart 对象内部完成。

这是过滤值的条形图。

(图片由作者提供)

示例 3

这个例子包括一个查找操作，类似于 Pandas 的合并功能。

假设我们有另一个数据帧，其中包含一些关于这些房屋所有者的信息。

melb['OwnerId'] = np.arange(1,1001)df = pd.DataFrame({
  'OwnerId': melb['OwnerId'],
  'Age': np.random.randint(20, 40, size=1000),
  'Salary': np.random.randint(5000, 10000, size=1000)
})df.head()

(图片由作者提供)

我们在原始数据框架中添加了一个 id 列，并创建了一个新的包含客户的 id、年龄和工资信息的数据框架。

我们想绘制每种房屋类型的业主平均工资。我们可以使用 Pandas 函数合并数据帧，并根据房屋类型对数据点(即行)进行分组，然后计算平均值。

另一种选择是使用 Altair 的查找转换，如下所示:

alt.Chart(
  df, height=300, width=500
).mark_bar().encode(
  x = 'mean(Salary):Q', y = 'Type:O'
).transform_lookup(
  lookup='OwnerId',
  from_=alt.LookupData(data=melb, key='OwnerId', fields=['Type'])
)

lookup 参数是指用于合并的列。下面是生成的图:

(图片由作者提供)

结论

我们已经做了 3 个例子来演示 Altair 的转换和过滤功能。关于这些操作，Altair 也是一个数据分析和操作工具。

当然，熊猫对于这样的行动要强大得多。然而，能够在创建可视化的同时执行基本的数据争论操作为 Altair 增加了重要的价值。

我们只做了条形图的例子，但是转换特性可以适当地扩展到任何其他的图。

感谢您的阅读。如果您有任何反馈，请告诉我。

Python Matplotlib 的 3 个特性使数据可视化更具吸引力和信息量

原文：https://towardsdatascience.com/3-features-of-python-matplotlib-that-make-data-visualizations-more-appealing-and-informative-e326762dea85?source=collection_archive---------6-----------------------

你如何展示和你展示什么一样重要。

由塞巴斯蒂安·斯文森在 Unsplash 拍摄的照片

数据可视化是数据科学的重要组成部分。从探索性数据分析到交付结果，利用数据可视化势在必行。

仅仅向利益相关者展示简单的数字是很难说服他们的。他们通常更感兴趣的是借助数据可视化可以清晰显示的全局。

作为数据科学生态系统中的主流语言，Python 拥有非常强大的数据可视化库，Matplotlib 就是其中之一。

在本文中，我们将介绍 Matplotlib 的 3 个特性，这些特性允许定制您的绘图，使它们更具信息性和吸引力。

在一天结束的时候，你如何展示和你展示什么一样重要。

我创建了一个销售和折扣数据集样本，你可以从我的数据集 Github repo 下载。在这个回购中可以随意使用任何数据集，但在本文中我们将使用名为“sales_vs_discount.csv”的数据集。

让我们从导入库和读取数据集开始。我们将首先通过读取 csv 文件创建一个熊猫数据框。

import numpy as np
import pandas as pd
import matplotlib.pyplot as pltdf = pd.read_csv("sales_vs_discount.csv")df.head()

(图片由作者提供)

在分析时间序列数据时，我们几乎总是使用折线图。这是一个简单的线形图，显示了销售额随时间的变化。

df["date"] = df["date"].astype("datetime64[ns]")plt.figure(figsize=(12,6))
plt.plot(df["date"], df["sales_amount"])

(图片由作者提供)

注 :绘制数量与时间关系图时，最好有适当数据类型的时间信息。在我们的文件中，日期列的数据类型是“对象”。在第一行中，我们将其更改为“datetime”。

我们观察到每日销售额的峰值，并怀疑这些峰值可能是由于对此产品应用了一些折扣。

我们可以通过绘制销售额和折扣率来确认。如果它们重叠，我们可以确认折扣增加了销售额。

我们可以将它们绘制在下图中:

plt.figure(figsize=(12,6))
plt.plot(df["date"], df["sales_amount"])
plt.plot(df["date"], df["discount"])

(图片由作者提供)

我们将销售额和折扣放在同一个图上，但是这个可视化并没有告诉我们任何东西。原因是数值范围差别很大。

折扣在 0 和 1 之间变化，而销售额在数千的水平上。

我们可以通过增加一个副轴来解决这个问题。

1.添加辅助 y 轴

我们可以创建多个轴，并使用twinx功能添加辅助 y 轴。

fig, ax1 = plt.subplots(figsize=(12,6))
ax2 = ax1.twinx()ax1.plot(df["date"], df["sales_amount"])
ax2.plot(df["date"], df["discount"], color="r")ax1.set_ylabel("sales amount", fontsize=18)
ax1.set_ylim([0,6000])ax2.set_ylabel("discount rate", fontsize=18)
ax2.set_ylim([0,1])

让我们一行一行地检查这段代码，以理解每一步都做了什么。

第一行创建一个图形和轴对象。图形对象就像一个容器，把所有的东西放在一起。我们可以在一个图形中放置多个轴对象。

第二行创建带有辅助 y 轴的第二个轴对象。

第三和第四行在轴对象上创建线图。

代码的剩余部分为 y 轴创建标签并调整值的范围。

(图片由作者提供)

现在看起来好多了。我们可以清楚地看到折扣是如何对销售额产生积极影响的。

2.Xticks 和 yticks

这个特性是为了使可视化效果更吸引人。Matplotlib 允许更改 xticks 和 yticks 值以及它们的显示方式。

plt.figure(figsize=(12,6))plt.plot(df["date"], df["sales_amount"])plt.xticks(fontsize=14, rotation=45)
plt.yticks(ticks=np.arange(0,6000,500), fontsize=14)plt.ylabel("Sales Amount", fontsize=18)

在第一行中，我们创建一个人物对象。图形的大小由figsize参数指定。第二行创建线形图。

第三行更改 xticks 的字体大小，并旋转 45 度。在第四行中，我们还更改了刻度值。我们现在每 500 马克就有一个刻度，而以前只有 1000 马克才有。

最后一行为 y 轴添加了一个标签。这是由上面的代码片段创建的图。

(图片由作者提供)

注意: 你可能已经注意到，我们在前面的例子中使用了 *set_ylabel* 函数。

在对图形对象进行操作时，这些功能不是以“设置”开始的，如 *ylabel* 、 *xlabel* 、 *ylim* 等等。

我们在对 Axes 对象进行调整的时候，都是从*set_ylabel**set_xlabel**set_ylim*等“set”开始的。**

3.创建子图网格

在某些情况下，我们创建包含多个图的可视化。每一个都携带不同的信息。

回想一下我们之前创建的在同一个图表上显示折扣率和销售额的图表。

该可视化的不同版本可以是在彼此之上的两个线图。它们共享同一个 x 轴，所以我们仍然可以看到折扣对销售额的影响。

支线剧情功能可以用来创建支线剧情网格。nrows和ncols参数决定了支线剧情的数量并进行排列。

例如，“nrows=2”和“ncols=2”创建的网格如下所示:

(图片由作者提供)

我们将有两个地块，并把它们放在对方的顶部。因此，我们需要设置“nrows=2”和“ncols=1”。

**fig, (ax1, ax2) = plt.subplots(
   nrows=2, ncols=1, sharex=True, figsize=(12,6)
)fig.tight_layout(pad=2)ax1.plot(df["date"], df["sales_amount"])
ax2.plot(df["date"], df["discount"])ax1.set_ylabel("Sales", fontsize=18)
ax2.set_ylabel("Discount", fontsize=18)**

如果 x 轴是公共的，我们可以将sharex参数设置为 true，这样 x 轴将只显示在底部。否则每个支线剧情下面都会有一个 x 轴。

tight_layout函数用于在子情节之间创建一些空间。这可以防止它们重叠。

这是我们的两个支线剧情的网格。

(图片由作者提供)

注意: 在这个例子中，我们通过将支线剧情传入一个元组来显式定义它们的名称。

(ax1，ax2)

我们也可以用下标来定义支线剧情。

axs，axs[0]，axs[1]等等。

下面的代码创建了与上面相同的情节。

**fig, axs = plt.subplots(
   nrows=2, ncols=1, sharex=True, figsize=(12,6)
)fig.tight_layout(pad=2)axs[0].plot(df["date"], df["sales_amount"])
axs[1].plot(df["date"], df["discount"])axs[0].set_ylabel("Sales", fontsize=18)
axs[1].set_ylabel("Discount", fontsize=18)**

结论

我们已经看到了 Matplotlib 的 3 个不同的特性，这些特性使得可视化更加吸引人，信息更加丰富。

在任务中创建和使用数据可视化是一回事。更重要的是让它们通俗易懂，简明扼要。我们在本文中所做的例子将帮助你创建这样的可视化。

最后但同样重要的是，如果你还不是中级会员并打算成为一名，我恳请你使用以下链接。我将收取你的一部分会员费，不增加你的额外费用。

**https://sonery.medium.com/membership **

感谢您的阅读。如果您有任何反馈，请告诉我。

Python 中的 3 个无限迭代器

原文：https://towardsdatascience.com/3-infinite-iterators-in-python-98746f359d4b?source=collection_archive---------18-----------------------

由 DeltaWorks 在 Pixabay 上拍摄的照片

5 个例子让你知道何时使用它们

毫无疑问，Python 内置模块 Itertools 相当强大。的确，几乎没有人能用一篇文章把它介绍得里里外外。因此，我选择了三个迭代器函数来帮助我们产生无限数量的元素。当然，格局是我们自己定义的。

数数
循环
重复

我将演示这些函数，以及我们可以使用它们的典型场景。通过这些例子，你会对它们的设计有更好的了解。如果你有更有创意的方法来使用它们，请不要犹豫让我知道！

让我们在任何演示之前导入它们。

from itertools import count, cycle, repeat

1.Itertools.count()

由像素在像素上拍摄的照片

每个人都会数数。如果不叫我们停下来，理论上我们可以一直数下去。在 Python 世界中，使用range()函数来生成数字序列是非常常见的。然而，我们必须让函数知道在哪个点上它需要停止。

但不用于count()功能。我们不需要告诉它什么时候停下来，只是不停地下一个，下一个，下一个。

iter_count = count(0)for i in range(10):
    print(next(iter_count))

在上面的例子中，我们使用count()函数定义了一个迭代器。我们告诉它应该从 0 开始，但不需要告诉什么时候停止。然后，我们使用next()函数从中获取值。循环 10 次，迭代器会产生 10 个数字。

count()功能也接受定制步骤的第二个参数。如果未指定，默认步长为 1。

iter_count = count(0.5, 0.5)for i in range (10):
    print(next(iter_count))

所以，每次我们得到下一个数字，就会加 0.5 而不是 1。

示例 1:获取偶数和奇数

我们可以很容易地使用count()函数来生成一个算术序列。例如，我们可以用它来生成奇数或偶数的列表。

iter_count_odd = count(1, 2)
iter_count_even = count(0, 2)odds = [next(iter_count_odd) for _ in range(10)]
evens = [next(iter_count_even) for _ in range(10)]print(odds)
print(evens)

示例 2:在 zip 函数中使用 count

假设我们有一份学生名单。现在，我们想自动分配学生证给他们。学生证要从 150000 开始。我们可以使用count()函数非常方便地做到这一点。

让我们首先生成一个学生姓名的虚拟列表。

students = ['Alice', 'Bob', 'Chris', 'David', 'Eva']

然后，让我们生成学生 id。

for i in zip(count(150001), students):
    print(i)

在这里，最重要的是，我们不必知道我们有多少学生。此外，如果需要，我们可以很容易地将结果转换成字典。

2.Itertools.cycle

由像素在像素箱上拍摄的照片

第二个无限迭代器工厂是cycle()函数。与一直朝一个方向计数的count()功能不同，cycle()功能会一遍又一遍地重复一个模式。

iter_cycle = cycle(['a', 'b', 'c'])for i in range(10):
    print(next(iter_cycle))

在上面的例子中，我们传入的列表有 3 个元素。由cycle()函数生成的迭代器将按顺序逐个填充它们。当所有的元素都被使用时，它会返回到开始处再次获取第一个元素。继续循环:)

示例 3:使用 cycle 生成每日轮换花名册

假设你在一个团队中，团队成员将轮流值班一天。为了公平起见，我们需要生成一个花名册。请注意，随机可能不够公平。还有，有可能有人会连续一天以上随叫随到，这绝对是我们需要避免的。

在这种情况下，cycle()功能会有所帮助。但在此之前，我们先生成一个日期列表。

from datetime import datetime, timedeltadates = [(datetime(2021, 1, 1) + timedelta(days=i)).strftime('%Y-%m-%d') for i in range(10)]

现在，我们可以使用带有循环迭代器的zip()函数来生成花名册。

iter_cycle = cycle(['Alice', 'Bob', 'Chris'])for i in zip(dates, iter_cycle):
    print(i)

如果我们有一年的生成时间，不用担心，就用cycle()吧，因为它是无限的。

3.Itertools .重复

照片由 stevepb 在 Pixabay 上拍摄

如果我们想永远重复某件事或者重复某段时间，那么repeat()函数总是 Python 中的最佳选择。首先，让我们生成一个无限迭代器，它重复地给我们同样的东西。

iter_repeat = repeat('Towards Data Science')for i in range(10):
    print(next(iter_repeat))

请注意,repeat()函数也采用可选的第二个参数来变得有限。

list(repeat('Towards Data Science', 5))

在上面的例子中，我们为 5 个副本生成了相同字符串的列表。

示例 4:比列表更快

有理由问我们为什么需要repeat()函数？例如，生成一个包含 5 个相同字符串的列表可以像下面这样简单。

['Towards Data Science'] * 5

的确，就可读性而言，这要好得多。然而，重复迭代器将缓存结果，而列表乘法将在内存中生成 5 个不同的字符串。

我们可以看到，在这种情况下，重复迭代器大约快了 4 倍。如果我们需要 5 倍以上，速度差会更大。

示例 5:循环比 range()更快

当我们想要循环某些东西的时候，使用range()是很常见的。比如for i in range(10)会循环 10 次。

然而，当我们不需要那个i，这意味着我们不关心循环次数，重复迭代器在性能方面将是一个更好的解决方案。

我们可以看到，使用repeat()功能比使用range()功能快 2 倍。前者胜出，因为它需要做的只是更新现有None对象的引用计数。后者失败了，因为range()或xrange()需要制造 10，000 个不同的整数对象。

摘要

由塔纳乔纳在 Pixabay 上拍摄的照片

在本文中，我介绍了 Python 的 Itertools 模块的 3 个无限迭代器。通过了解它们，有时可以在很大程度上提高我们的生产力。然而，我也建议平衡可读性和性能。不要总是用代码来炫耀，只在必要的时候才使用它们。

如果您对更多 Python 内置模块感兴趣，请查看这些相关文章。

https://medium.com/@qiuyujx/membership

如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和成千上万的其他作者！(点击上面的链接)

每个 ML 工程师都应该知道的 3 个 Keras 设计模式

原文：https://towardsdatascience.com/3-keras-design-patterns-every-ml-engineer-should-know-cae87618c7e3?source=collection_archive---------6-----------------------

机器学习工程师也有自己的设计模式！

照片由爱丽丝·迪特里希在 Unsplash 拍摄

Keras 是一个建立在 TensorFlow 之上的机器学习(ML)库，使得创建和适应深度学习模型架构变得极其容易。正如他们喜欢说的，“Keras API 是为人类设计的，而不是为机器设计的。”

这是事实！如果你想快速勾画出一个想法，Keras 是这项工作的工具。然而，Keras 可以非常灵活和强大；你可以逐渐剥离复杂的层次，深入定制几乎每一个小细节。

此外，由于其 TensorFlow 支持的后端，Keras 可以利用多 GPU 配置或 TPU 训练。

在这个故事中，我们研究了三种主要的 Keras 设计模式。我们将首先构建一个简单的序列模型。然后我们将扩展我们的实现来支持非顺序用例。最后，我们将更深入地通过子类化 Keras Model类来创建和执行我们自己的训练循环。开始吧！

学习率是为那些对 AI 和 MLOps 的世界感到好奇的人准备的时事通讯。你会在每周五收到我关于最新人工智能新闻和文章的更新和想法。订阅这里！

像箭一样直

为了展示 Keras 的威力，我们需要一个运行的例子。为此，我们将使用“ Hello world ”计算机视觉的例子，即 MNIST 数据集。我知道，我知道……MNIST 的问题现在很无聊，但是我们试图让事情变得简单，这样我们就可以专注于重要的事情:代码。

首先，我们将使用序列模型求解 MNIST。这再简单不过了。从现在开始，遵循本文的最佳方式是启动 Google Colab 笔记本，并将运行时改为支持 GPU 的运行时。

在第一个代码单元格中，提供导入语句:

然后，让我们加载并准备数据:

现在，我们准备构建我们的模型。Keras sequential API 可以毫不费力地构建一个深度学习模型，它的工作方式很像一条开放的高速公路；我们通过一系列直接的层来输入数据:

最后，您所要做的就是编译模型，拟合它，并在测试数据集上评估它。广义编译意味着提供损失函数、优化器和您关心的指标。完成这一步后，你就可以开始训练了:

仅此而已！经过 15 个时期后，我在测试数据集上获得了0.9912的准确度。不错，但我相信你不会感到惊讶。毕竟，MNIST 任务被认为是已经解决的。

功能 API

但是如果你不能用一系列的层来解决你的问题呢？如果您需要执行单独计算的分支，并且模型将它们的结果合并到一起，那该怎么办？然后，是时候使用 Keras 功能 API 了。

因此，我们将输入通过两个具有不同特性的不同卷积层，然后合并它们的输出。不，对于 MNIST 问题来说，这不是真的有必要，但我们会假装有必要。

为了实现这一切，我们只需要更新模型创建步骤:

经过 15 个时期后，我在测试数据集上获得了0.9919的准确度。然而，你不能真的说这个模型更好或更差。这只是一个玩具的例子！

子类

现在是时候拿出大枪了。一些工程师需要知道fit函数内部发生了什么，并控制一切。Keras 提供了子类化 API，您可以使用它创建自己的模型类，并完全定制训练步骤。

首先，我们需要创建数据集:

然后，创建我们的模型。这与我们在顺序 API 部分中使用的模型相同:

接下来，我们需要创建我们的培训和测试步骤:

最后，让我们将所有东西放在一起，构建我们的培训循环:

经过 15 个时期后，我在测试数据集上获得了0.9910的准确度。这是一个总结！

结论

Keras 提供了三种主要方法来解决您的 ML 任务:

顺序 API
功能 API
Keras 子类化方法

每一项技术都让我们对低层次张量流更深入一步。通常，顺序的和功能的 API 解决了我们 99%的问题，但是一个好的 ML 工程师应该了解每一个设计模式。

关于作者

我的名字是迪米特里斯·波罗普洛斯，我是一名为阿里克托工作的机器学习工程师。我曾为欧洲委员会、欧盟统计局、国际货币基金组织、欧洲央行、经合组织和宜家等主要客户设计和实施过人工智能和软件解决方案。

如果你有兴趣阅读更多关于机器学习、深度学习、数据科学和数据运算的帖子，请在 Twitter 上关注我的 Medium 、 LinkedIn 或 @james2pl 。

所表达的观点仅代表我个人，并不代表我的雇主的观点或意见。

机器学习中的 3 个关键概念

原文：https://towardsdatascience.com/3-key-concepts-in-machine-learning-d6a2cd68052d?source=collection_archive---------30-----------------------

暂时远离那些花哨的算法

照片由在 Unsplash 上反推

刚开始学习数据科学的时候，支持向量机是我最喜欢的算法。当然，它不是最好的，但是它有一个很酷的名字。此外，它如何随着 c 和 gamma 参数动态地改变它的分类策略让我感到惊讶。

机器学习听起来很吸引人，很有魅力。我认为它在推动许多人进入数据科学领域方面发挥了关键作用。所有那些有着花哨名字的算法都让新来者激动不已。

我认为算法是机器学习盒子的闪亮表面。它们经过精心设计和构建，以解决数据问题。算法的成功有时会让我们忘记盒子里是什么。

为了解决机器学习的问题，我们需要全面了解盒子里有什么。它们是成功实现机器学习算法所必需的基本原则和概念。

它们可能被认为是基础。然而，它们对于机器学习算法的性能和准确性至关重要。

你的模型和数据一样好

机器学习算法所做的事情听起来像是魔术。然而，他们只捕捉数据中的内容。数据中有一些关键信息，但人眼很难或不可能捕捉到。

如果应用正确，机器学习算法可以捕获嵌入的信息，并让我们使用它来解决问题。他们不能实现的是变魔术和超越数据。

这就把我们带到了数据科学产品最重要的部分:数据。我们需要花更多的时间在数据上，而不是模型上。我说的不仅仅是清理和重新格式化数据。

信息的力量来自数据。这些特征应该提供有价值的见解。大量的时间和精力花费在预处理原始数据上。

我们不必使用原始数据中的特征。特征工程技术帮助我们从现有的特征中创建更多的信息特征。

数据泄露

当训练过程中使用的数据包含有关模型试图预测的信息时，就会发生数据泄漏。这听起来像是“欺骗”，但我们并没有意识到这一点，所以称之为“泄漏”更好。

数据泄漏是数据挖掘和机器学习中一个严重而普遍的问题，需要很好地处理以获得一个健壮和通用的模型。

数据泄露最明显的原因是将目标变量作为一个特征包括进来，这完全破坏了“预测”的目的。在训练过程中使用测试数据也是数据泄露的一个例子。这些都是显而易见的情况，很可能是错误的。

再来说说不那么明显的数据泄露例子。考虑一个预测用户是否会停留在网站上的模型。包含暴露未来访问信息的功能将导致数据泄漏。

我们应该只使用关于当前会话的特性，因为在部署模型之后，关于未来会话的信息通常是不可用的。

在数据清理和预处理过程中也可能发生数据泄漏。以下是清理和预处理数据的常见操作列表。

查找用于规格化或重新缩放的参数
要素的最小/最大值
估计缺失值的特征变量的分布
移除异常值

这些步骤应该只使用训练集来完成。如果我们使用整个数据集来执行这些操作，就会发生数据泄漏。因此，模型不仅了解训练测试，还了解测试集。这完全违背了预测的目的。

偏差和方差

当我们试图用一个相对简单的模型来近似一个复杂或错综复杂的关系时，就会出现偏差。在这种情况下，我们最终得到的模型无法捕捉数据中的结构和关系。

简单是好的，但太简单是危险的。高偏差模型的性能受到限制。即使我们有数百万个训练样本，我们也无法建立一个准确的模型。

有偏模型的预测误差倾向于某个方向。例如，在回归任务的情况下，有偏差的模型可能总是预测出小于实际值的值。具有高偏差的模型可能会对数据进行欠拟合。

与偏差相反，当模型相对于数据中的结构过于复杂时，就会出现偏差。模特试图挑选每一个细节。它甚至学习数据中的噪音，这些噪音可能只是随机的。

方差大的模型对特征值的微小变化很敏感。因此，它们不能被很好地概括，这就是所谓的过拟合。该模型过度适应训练数据，但未能很好地概括数据集内的实际关系。

高偏差和高方差都不好。完美的模型是低偏差和低方差的模型。然而，完美的模型很难找到，如果可能的话。

偏差和方差之间有一个权衡。我们应该力求在它们之间找到恰当的平衡。作为一名机器学习工程师，成功的关键是掌握在偏差和方差之间找到正确的平衡。

结论

为了创造成功的机器学习产品，我们的重点应该超越算法。基本原则对算法的成功至关重要。

在用机器学习解决问题时，我们需要记住它们。否则，即使我们创造了一个最先进的模型，它也不能产生令人满意的结果。

感谢您的阅读。如果您有任何反馈，请告诉我。

随机森林和 GBDT 的 3 个主要区别

原文：https://towardsdatascience.com/3-key-differences-between-random-forests-and-gbdt-cfc48093200b?source=collection_archive---------11-----------------------

是什么让这两个最先进的模型如此不同

诺德伍德主题公司在 Unsplash 上拍摄的照片

随机森林和梯度提升决策树(GBDT)是两种最常用的机器学习算法。两者都是集成模型，这意味着它们将许多弱学习者组合在一起，得到一个强学习者。

虽然随机森林和 GBDT 都使用相同的弱学习器，但它们是完全不同的算法。在本文中，我们将关注这些集成技术之间的 3 个关键差异。

决策树在两种算法中都被用作弱学习器。决策树建立在反复询问问题以划分数据的基础上。它在数据中寻找模式和结构，并基于它们分割数据点。

我们不会详细讨论决策树是如何工作的。相反，人们关注的是是什么让兰登森林和 GBDT 如此不同。因此，我假设你对这些算法有一个基本的理解。

装袋与增压

随机森林和 GBDT 的主要区别在于它们如何组合决策树。

随机森林是使用一种叫做打包的方法构建的，其中每棵决策树都被用作一个并行估计器。每个决策树适合从整个数据集中提取的子样本。

在分类任务的情况下，通过在所有决策树的结果中进行多数投票来确定总体结果。对于回归任务，通过取所有预测的平均值来计算总体结果。

GBDT 使用增强技术来创建一个集合学习器。决策树被顺序连接(即串联)以获得强学习器。GBDT 的决策树不适合整个数据集。

目标是最小化先前树的错误。因此，每棵树都符合前一棵树的残差。因此，模型的整体准确性和稳健性逐渐增加。

拔靴带

自举是统计学中的一个概念。它基本上意味着从数据中选择一个随机样本。每个样本称为一个引导样本。

在随机森林中，如果我们不使用自举，每个决策树都适合整个数据集。因此，我们将许多相同的算法应用于相同的数据集。这是没有意义的，因为我们会重复同样的事情，并期待更好的表现。

随机森林模型的成功高度依赖于使用不相关的决策树。如果我们使用相同或非常相似的决策树，总体结果与单个决策树的结果不会有很大不同。自举在创建不相关的决策树中起着关键作用。

GBDT 不使用也不需要自举。因为每个决策树都适合前一个的残差，所以我们不需要担心有相关的树。

通过添加新的树，整个模型逐渐得到改进。每棵树的侧重点都不一样。因此，不需要从数据集创建子样本。

过度拟合

过拟合是机器学习中的一个关键问题。不管你用什么算法，都有过度拟合的风险。因此，它可以被认为是机器学习中的一个普遍瓶颈。

当模型与训练数据拟合得太好时，就会发生过度拟合。因此，它会捕获训练数据中不必要的细节，并且无法推广到整个数据集。

由于随机森林和 GBDT 都是集合模型，模型中使用的决策树数量似乎是与过度拟合相关的关键参数。

但是，对于随机森林和 GBDT，此参数的效果有很大不同。增加随机森林中的树木数量不会导致过度适应。

在某个点之后，模型的准确性不会因为添加更多的树而增加。它也不会因为增加过多的树而受到负面影响。由于计算原因，您仍然不希望添加不必要数量的树，但是没有与随机森林中的树的数量相关联的过度拟合的风险。

然而，GBDT 的树木数量对过度种植至关重要。因为每一棵额外的树都符合前一棵的残差，所以新树的焦点在某个点之后变成了细节。

我们期望在某个时候有一个通用的模型。之后，每一次添加都覆盖了训练数据中的一个细节或噪声。因此，在 GBDT 增加太多的树木会导致过度拟合。

结论

随机森林和 GBDT 都是非常有效的算法。它们可用于解决分类和回归任务。最后，我想提供两个图表来总结这些算法是如何工作的。

(图片由作者提供)

感谢您的阅读。如果您有任何反馈，请告诉我。

关于逻辑回归算法的 3 条关键信息

原文：https://towardsdatascience.com/3-key-information-about-logistic-regression-algorithm-b2fbd9084b3c?source=collection_archive---------16-----------------------

这是一个简单但非常有效的算法

蒂埃拉·马洛卡在 Unsplash 上拍摄的照片

机器学习生态系统涵盖了广泛的算法。这些算法中有些非常复杂，而有些相对简单。算法的性能不一定与其复杂度成正比。

逻辑回归是比较简单的一种。然而，它是非常有效的，并在许多应用程序中使用，如垃圾邮件检测，流失预测，等等。

逻辑回归是一种监督学习算法，主要用于二元分类任务。在本文中，我将分享我认为对理解逻辑回归算法如何工作很重要的 3 条关键信息。

对数赔率

对数概率最好通过概率概念来解释。事件的概率是该事件发生的可能性的度量。

假设一封电子邮件是垃圾邮件。如果电子邮件是垃圾邮件的概率是 0.9，那么该电子邮件不是垃圾邮件的概率是 0.1。术语“赔率”将这两个值联系起来。

(图片由作者提供)

在我们的例子中，几率是 9。赔率值越高，事件发生的可能性越大。

对数赔率是赔率的对数。请查看下表，了解我们为什么关注逻辑回归算法的对数概率。

(图片由作者提供)

假设我向你展示了一封邮件是垃圾邮件和不是垃圾邮件的概率。然后我请你预测这封邮件是否是垃圾邮件。如果成为垃圾邮件的概率高于 0.5，那么显而易见的答案是垃圾邮件。

概率值为 0.5 的对数赔率为 0。对于逻辑回归算法来说，这是一个重要的关系，我们将在本文的下一部分看到。

Sigmoid 函数

sigmoid 函数是逻辑回归算法的核心。它接受任何实数值，并将其映射到 0 到 1 之间的值。

(图片由作者提供)

不管 x 的值是多少，y 取 0 到 1 之间的一个值。输出值在 0 和 1 之间很重要，因为我们不能有超出这个范围的概率值。

如果 x 是 0，y 变成 0.5，这是二进制分类的通用阈值。

回归与分类

虽然它的名称中包含“回归”一词，但逻辑回归是一种分类算法。通过使用 sigmoid 函数和一些对数技术，逻辑回归将分类问题转化为求解线性方程，就像我们在线性回归中所做的那样。

我们先重新排列一下 sigmoid 函数。

(图片由作者提供)

如果我们在最后一步取表达式两边的自然对数，我们得到如下结果:

(图片由作者提供)

对数表达式中的 y 用作肯定类别的概率(即电子邮件是垃圾邮件)。

如果 y = 0.5，那么 x = 0
如果 y > 0.5，则 x > 0
如果 y < 0.5，那么 x < 0

我们可以用一个线性方程代替方程 1 中的 x。

(图片由作者提供)

通过求解左手边的线性方程得到 0，我们可以找到使正类概率为 0.5 的参数。

函数的参数在训练阶段用最大似然估计算法确定。然后，对于任何给定的特征值(x1，… xn)，可以计算出正确类别的概率。

结论

逻辑回归是一个简单但非常强大的算法。虽然有许多复杂的算法可以解决分类任务，但逻辑回归因其效率而在许多应用中使用。

需要注意的是，我们不应该总是用 0.5 作为阈值来区分正负类。关于垃圾邮件的情况，为了将一封邮件归类为垃圾邮件，我们必须几乎确定。我们不希望用户错过重要的电子邮件。逻辑回归允许我们调整这类任务的阈值。

感谢您的阅读。如果您有任何反馈，请告诉我。

数据工程函数式编程的 3 个关键原则

原文：https://towardsdatascience.com/3-key-principles-of-functional-programming-for-data-engineering-67d2b82c7483?source=collection_archive---------23-----------------------

函数式编程的关键原则及其在大规模设计可复制数据管道时的意义

概述

在我之前关于我学习 Scala 的动机的文章中，我提到了我学习 Scala 进行数据工程的一个主要原因是因为编程语言主要是为函数式编程而设计的。

在我们深入编写函数式程序的细节之前，理解函数式编程的关键原则以及这些编程原则在大规模设计可复制的数据管道时如何有用是很重要的。

在这篇文章中，我介绍:

什么是函数式编程
函数式编程的关键原理及其对数据管道设计的影响

什么是函数式编程

函数式编程是一种声明式编程风格，强调只使用编写软件:

纯函数；和
不变的价值。

简而言之，函数式程序员将他们的代码视为数学函数——并将函数的组合视为具有定义的输入和输出的方程。

纯函数的概念是函数式编程的核心，对于函数式设计原则如何应用于大规模数据应用的设计具有重要意义。现在，这里有一个“纯函数”的简化定义[1，2]:

纯函数的输出仅取决于其输入参数和其内部算法(即输入参数被馈入的“黑盒”)。
一个纯粹的函数没有副作用。它与外界没有任何读/写交互。
作为上面两个语句的结果，如果用输入参数 x 无限次调用一个纯函数，它将总是返回相同的结果y——不管内部或外部过程的任何状态变化。

声明式编程与命令式编程

在命令式编程范例中，代码被视为改变程序状态的语句。命令式程序由一系列语句组成，这些语句作为显式指令写给计算机，说明程序如何改变其状态。

过程化和面向对象编程范例是命令式编程的扩展，通过将程序分成更小的组件来提高命令式程序的可维护性。过程式编程侧重于将程序分解成过程(也称为子例程或函数)，而面向对象编程侧重于将程序分解成具有状态(数据)和行为(代码)的对象。

虽然过程化和面向对象的编程允许程序以程序员更容易理解的过程来表达，而不必查看细节，但是完整的程序仍然是必要的，因为语句的执行顺序(也称为控制流)影响程序状态如何被改变。

与命令式编程相比，声明式编程范例表达了程序的计算逻辑，而没有明确描述按顺序实现它们的步骤。

函数式编程的特点是声明式编程风格，通过将表达式评估为函数应用来执行计算，并将状态突变封装在控制流中。这种编程范式使程序员能够编写自包含的可重用和可测试的程序，而无需额外的模拟对象和接口。

函数式编程的关键原则

函数式编程的主要原则是:

纯功能和避免副作用
不变
对透明性有关的

纯功能和避免副作用

当我们看一个数学函数 y = f(x) 时，我们期望函数 f 在给定其输入 x 的情况下，除了计算结果 y 之外什么也不做。

换句话说，一个纯函数除了返回一个结果(这是它的主要作用)之外，对程序执行没有可观察到的影响。

带有副作用的函数在局部函数范围之外改变状态。副作用的例子包括[1，4]:

就地修改变量或数据结构
修改全局状态
执行任何 I/O 操作(读取或写入文件/数据库、打印到控制台或读取用户输入等。)
引发带有错误的异常

为了说明纯功能的概念及其关键含义，让我们以烤箱为例:

纯粹的功能——用烤箱和披萨来说明*(作者图片)*

要烤一个薄皮夏威夷披萨(抱歉，披萨纯化论者)，我们需要披萨皮和配料，烤箱温度设定在 160 摄氏度，持续 10 分钟。烤箱烘焙功能的输入为:

比萨饼皮类型(薄皮)
配料清单(奶酪、番茄、火腿、菠萝酸辣酱)
烘箱温度(摄氏度)
烘焙时间(分钟)

如果我们假设烤箱烘焙操作是一个纯函数，我们假设操作的输出仅依赖于烤箱烘焙操作的输入和内部算法。我们预计不会有任何副作用，比如烘烤操作会烧毁厨房。

因此，我们希望烤箱每次都能返回一个烤得很好的薄皮夏威夷披萨*，不管我们执行多少次操作*，只要输入没有改变烤箱外部的状态。给定函数输入，我们不期望烤箱返回奶油比萨或烤焦的比萨。

在更正式的术语中，我们期望一个纯函数(烤箱烘焙操作)是:

1.确定性和幂等性，以及

2.没有副作用。

实际上，我们有时会打开烤箱门来检查烤箱的烘烤操作。(输入/输出操作)

我们可能会决定通过打开烤箱的计时器来缩短烘烤时间，或者在比萨饼配料中加入更多的奶酪。(就地修改变量)

烤箱可能会加热其周围环境，增加其外部环境的温度。(修改全局状态)

烤箱可能会过热或短路，影响烤箱烘烤操作的顺利完成。(抛出带有错误的异常)

除了薄皮夏威夷比萨饼之外，烤箱烘焙操作产生的这些影响还会引起烤箱外部状态的变化，因此使烤箱烘焙操作成为一种不纯的功能，并具有副作用。

不变

不变性是指一旦给变量赋值，变量的状态就不能改变。

不变性的概念在函数式编程中很重要，因为它确保函数有一个规范的状态，并且不会改变函数范围之外的其他变量。状态更改不是就地修改变量值，而是通过创建另一个实例来管理，而不会影响原始变量的状态。

不可变变量的使用也确保了函数是纯的，因为它防止了在一个值被赋给一个不可变变量后状态改变的副作用。

不变性的一个关键含义是在函数式编程中编写并行/并发程序的容易性。

在命令式编程中，状态的可变性通常使关于分布式状态和并发执行的推理变得复杂，因为在不遇到竞争条件的情况下跟踪线程、内核和处理器之间的共享状态变化是非常困难的。在并发操作中，当两个线程同时对同一内存位置执行冲突操作(其中一个是写操作)时，可能会出现数据竞争。

由于 Python 主要被设计为面向对象的编程语言，其命令式设计模式导致管理对默认可变共享变量的并发访问变得复杂——因此需要一个全局解释器锁(GIL)来锁定线程并防止数据竞争。

函数式编程中的不可变性简化了并发性的实现，并提供了构建一致的并发程序的强大方法，因为使用不可变的共享状态可以消除竞争条件，从而使并发编程与命令式方法相比问题更少。

对透明性有关的

使用纯函数产生的一个重要特性是引用透明性，它与程序的等式推理能力有着错综复杂的联系。

在保罗·丘萨诺和罗纳·比雅纳松所著的《Scala 中的函数式编程》一书中，引用透明性被正式定义如下[1]:

一个表达式 *e* 是引用透明的如果，对于所有的 *p* ， *p* 中所有出现的 *e* 都可以用对 *e* 求值的结果代替，而不影响 *p* 的含义。

换句话说，引用透明性是表达式(不仅仅是函数)的一个属性，这样一个表达式可以被它的等价结果代替，而不会影响所有程序的程序逻辑。

没有副作用是引用透明的必要条件，但不是充分条件。表达式还必须是确定性的和幂等的，以确保表达式和它的求值结果之间的等价性。

如果给定相同的输入，函数总是返回相同的输出，则该函数是确定的。

一个函数是幂等的，如果它可以被多次应用而不改变其初始应用之外的结果**。幂等函数满足以下条件: f(f(x)) = f(x) 。幂等函数的例子是单位函数、绝对值函数和常数函数。**

参照透明的充分条件可以用下面的类比来说明:

如果即使没有外界干扰，烤箱随着时间的推移发生故障，导致披萨烤得不如以前好怎么办？可能没有可观察到的副作用，但是从烤箱烘焙操作返回的输出不再与给定相同输入的先前输出相同。这使得烤箱烘焙操作具有不确定性，因为结果取决于操作何时被评估，破坏了引用透明性的属性。

引用透明性的一个关键结果是，它使得程序的等式推理成为可能。表达式可以用它的等价结果替换，计算可以通过用*“equals”代替*来执行，而不用担心求值顺序或程序状态——类似于数学中对代数表达式求值。

这种关于程序评估的推理模式，称为替代模型，推理起来更简单，因为评估的效果纯粹是局部的，不需要对状态更新进行顺序推理来理解代码。即使在开发过程中函数中有任何 bug，与命令式编程相比，推理的便利性也使得函数式编程中的调试更容易。

在大规模设计可再现的数据管道时，代码中的引用透明性提供了以下好处:

函数的幂等性向程序员保证，程序中的数据转换函数在最初的应用程序之外是可再现的。
它使程序员能够用更简洁、更易读的函数和值来表达代码，提高编码时的可读性。
它允许程序员专注于函数范围内的调试，而不用担心函数范围外的状态变化，提高了数据管道内核心转换的可维护性。

下一步:面向数据管道设计的函数式编程

在这篇文章中，我们了解了:

函数式编程及其与命令式编程的区别
纯函数的概念
函数式编程的关键原理及其对数据管道设计的影响

在我即将发表的文章中，我将深入探讨函数式编程的一些特性，以及如何在设计函数式数据管道时实现它们。

想要更多关于我作为数据专业人员的学习历程的幕后文章吗？查看我的网站:https://ongchinhwee.me ！

参考

[1]保罗·丘萨诺和罗纳·比雅纳松，Scala 中的函数式编程 (2014)

[2]阿尔文·亚历山大，“纯函数”的定义(2018)，函数式编程简化版

[3] Michael R. Clarkson，可变性 (2021)，OCaml 中的函数式编程

[4] 编程语言——什么是副作用？—软件工程栈交换

函数式编程——等式推理是引用透明性的应用吗？—计算机科学栈交换

原载于 2021 年 5 月 9 日https://ongchinhwee . me。

企业中数据科学的 3 个关键主题

原文：https://towardsdatascience.com/3-key-topics-for-data-science-in-the-enterprise-2b21e9a5f8a9?source=collection_archive---------30-----------------------

来自 CVS Health、Conde Nast 和 Dun & Bradstreet 的机器学习专家

在 Adobe Stock Photo 中创建的图像

我最近与来自 CVS Health、Conde Nast 和 Dun & Bradstreet 的三位领先的数据科学专家坐在一起，讨论他们在企业中为人工智能和机器学习带来的趋势和变化。他们还分享了什么让他们兴奋，他们关注的热门话题，以及他们对企业中 AI 和 ML 的未来的看法。当我与这些专家进行讨论时，出现了几个共同的主题，并且三个关键主题在不同的行业中是共同的:优先考虑正确的数据以进行高效的分析来释放价值，确保透明和负责任地使用数据，以及将组织调整作为成功的关键。

这些是我有机会与之交谈的数据科学专家:

CVS Health 公司企业数据战略和工程高级总监萨莉娜·卡兹米
康泰纳仕数据科学&工程负责人 Sriram Subramanian
罗谢尔·马奇，Dun & Bradstreet 的 ESG 产品负责人

让我们继续跳下去吧！

应用人工智能实施后的组织变革

实施了应用 AI 的组织已经在发生什么样的变化？我们的三位专家分享了他们的观点:

工作流效率和增强的决策

萨莉娜·卡兹米认为，让人工智能工作的一个重要组成部分是提供对适当的内部和外部信息的访问，这些信息在正确的级别上进行聚合，并集成到业务工作流程中。她说:“大多数成功的实施都涉及到用相关数据和人工智能指导的相关建议来增强商业应用，以帮助专家做出明智的决策。”“人工智能使业务专家能够在做出关键决策时了解用户、他们的行为、潜在风险或潜在的业务影响。”

此外，萨莉娜表示，除了工作流效率和增强决策的变化，实施人工智能解决方案还导致了部署可扩展基础设施的需求，从而允许团队使用大规模数据构建和部署模型。“云的采用加速了实验和交付周期，并且已经成为企业的市场差异化因素，”她分享道。

部署人工智能解决方案的正确领域的优先顺序

“成功实施的组织正在积累使用人工智能系统的好处，主要变化是对机器学习能够推动业务发展的期望提高了，”Sriram Subramanian 说。“这为数据科学团队规划和优先考虑部署人工智能解决方案的正确领域带来了更大的机会和责任。”

聚焦负责任的人工智能

对于 Rochelle March 来说，数据和元数据数量和可用性的无限增长带来了与数据增长、可用性和日益严峻的操作需求相关的问题。“在以前的技术浪潮中，公司需要人们从事数据库管理、加载数据和使用编程语言在内部操纵和分析数据，”她分享道。“虽然这些技能仍然是必不可少的，但组织越来越需要理解许可使用、知识产权、人工智能道德和特定领域专业知识等概念的专业人士。”

今年要注意的趋势

我们的专家今年关注哪些趋势，它们将如何影响未来？

MLOps 和以数据为中心的机器学习

Sriram Subramanian 指出，今年有几个重要的趋势令人感兴趣，但集中在两个最重要的问题上:MLOps，或我们如何管理机器学习管道；和 ML 模型跟踪以及附带的技术堆栈。“我认为，随着对人工智能解决方案的期望增加，正确理解这一点的组织将能够更快地扩大他们对业务的影响，”Sriram 说。第二，吴恩达最近强调的以数据为中心的机器学习，正在更密切地关注用于建立模型的数据，而不是完全在模型方面工作。“这对于这些解决方案的性能实现更高水平的提升至关重要，”他分享道。

数据过滤和深思熟虑地使用数据

对于 Rochelle March 来说，数据已经变得丰富且无处不在，强调了哪种数据有用和可用的问题。“识别感兴趣的数据变得更有价值，也更难找到，有可能放大错误、偏见或噪音，”她说，“盲目收集越来越多的数据可能会从数据湖变成数据深渊。”

她继续说道，“另一个趋势是人们意识到，人工智能和机器学习将发现隐藏的真相，但人工智能和机器学习算法往往无法评估它们获得的数据的真实性。算法通常会做出愚蠢的假设，当自动化时，其严重性会扩大。必须越来越强调深思熟虑和有意识地使用数据。数据可以是一个强大的工具，并提供重要的见解，但数据的不当使用可能会产生有害的后果。”

企业人工智能和人工智能的未来

我请专家们分享他们对企业 AI 和 ML 未来的想法和预测。以下是他们的想法:

支持机器学习操作的系统

萨莉娜·卡兹米认为，当专家提供可信、透明、可追踪的数据支持建议时，人工智能和人工智能对于企业来说是成功的和变革性的。“支持可重复和可再现的科学的系统和过程，没有偏见，有可解释的结果，将是长期成功的关键，”萨莉娜说。这是 MLOps、DevOps 和 DataOps 结合的地方

萨莉娜还看到了企业平台和服务的价值，这些平台和服务将语音、计算机视觉、自然语言处理或文本提取的定制作为一项基础能力。“以一种可以在整个企业中使用的更通用的方式来设计功能是非常强大的，”她分享道，“这允许工程师、分析师和科学家利用来自干净、可靠和可信的数据源目录的数据资产来满足特定的业务需求，而不会招致繁重的工程工作。”

规模价值

Sriram Subramanian 认为，“随着 AI/ML 的成熟，它将成为企业几乎每个方面的功能，帮助他们在规模上为客户提供更好的价值。它不是一个单独的工具，而是以对最终用户透明的方式融入到企业中。”

为不断增长的空间而兴奋

企业人工智能和机器学习绝对是一个增长空间。什么让专家们兴奋？

提高生活质量的有影响力的创新

萨莉娜·卡兹米对“创新、创造力和机会在不同领域、不同行业产生影响，并改善我们的日常生活质量”感到兴奋

关注数据责任

对于 Sriram Subramanian 来说，这是“创造的机会和以最佳方式塑造增长的责任，这种方式平衡了企业的利益，同时限制了人们广泛谈论的负面影响。”

对数据责任的高度关注，包括围绕不平等、人工智能偏见、对抗性数据操纵和数据权利的考虑，现在正成为谈话的前沿，这是让 Rochelle March 最兴奋的事情。“越来越多的人认为忽视这些因素是不可接受的，这反映了对数据力量的理解和对话更加成熟，”她说。

她还对越来越多的环境和社会数据用于量化和跟踪生态系统状况、人权侵犯和福祉感到非常兴奋。例如，可以跟踪森林砍伐、非法捕鱼和温室气体排放的卫星数据和机器学习算法越来越多，这在提供不负责任的资源消耗透明度方面非常有力。这将是衡量我们地球状况的一个重要因素，并为我们走向可持续或不可持续消费的轨迹提供信息，然后我们可以将其纳入融资、投资、采购和营销决策，以影响经济的变化。

关于协调数据科学团队、决策者和业务目标的建议

你对调整整个企业的团队以确保成功有什么建议？

允许创造性并提供学习的空间

萨莉娜·卡兹米强调让整个企业的团队富有创造性，提出并实施新的想法；有失败和学习的空间。他指出，“轮换计划、创新冲刺、黑客马拉松有助于朝着正确的方向前进。”

理解使用人工智能的必要性

“理解业务目标是必不可少的，但也要理解使用人工智能/人工智能技术的需求和风险承受能力，”Sriram Subramanian 说。“需求决定了需要投资的原因和预期的回报。风险容忍度也很重要，因为在许多情况下，解释这种解决方案的内部工作原理并不容易，因此很难确定解决方案可能失败的边缘情况。”

倾听和协作

Rochelle March 说“倾听、学习彼此的语言、理解共同的和个人的目标，并合作实现这些目标”是企业成功结盟的关键。

结束

如果你对这些见解感兴趣，你可以和我一起参加数据科学沙龙，参加下周在 VB 的 Transform World 上举行的企业轨道中的数据科学。这只是这些和来自 Peloton、Roku、Visa、Nike 的其他专家将讨论的见解的一小部分。一些主题将包括成功模型管理的考虑因素，使用数据优化内容获取生命周期，以及吸引康泰纳仕品牌受众的推荐策略等。

Tidyverse 三家不太知名的管道运营商

原文：https://towardsdatascience.com/3-lesser-known-pipe-operators-in-tidyverse-111d3411803a?source=collection_archive---------18-----------------------

用于干净代码编写的三通、展示和赋值管道操作符

照片由马丁·亚当斯在 Unsplash 拍摄

除了托管 Tidyverse 社区使用的主要管道操作符%>%之外，Tidyverse 中的 magrittr 包还托管了其他一些管道操作符。%>%管道广泛用于数据操作，并由 Tidyverse 自动加载。

管道运算符用于执行多个操作，这些操作需要前一个操作的输出作为输入参数。因此，执行从左边开始，将数据作为第一个参数传递给右边的函数，依此类推。这样，一系列数据操作可以在一个步骤中完成。

因此，这里我们将讨论 magrittr 包中的其他三个管道操作符。讨论主管操作员失败的领域以及这些功能如何补充它。

三通管

三通管操作符%T>%的工作方式几乎和%>%操作符一样，除了一系列操作中有一个操作没有返回值的情况。当我们在一系列操作中使用 print()或 plot()函数时，t 形管道操作符是很有用的，这些操作不一定在序列的末尾。由于 print()和 plot()函数不返回任何值，在这种情况下，我们可以使用%T>%操作符，在 print()/plot()操作之后使用最后一个要分配给该操作的参数值。让我们看一个例子，在这个例子中，我们使用主管操作符%>%编写了一系列操作。

# sequence of operations using main pipe operator
rnorm(100) %>% 
  matrix(ncol=2) %>% 
  sin() %>% 
  plot() %>% 
  colSums()# output
Error in colSums(.) : 'x' must be an array of at least two dimensions

作者图片

所以在上面的操作中，我们看到在执行 colSums()函数时出现了一个错误。这是因为 plot()函数不返回值。为了解决这个问题，我们将在 plot()函数之前使用 tee pipe 运算符。这样做的目的是将 sin()函数的值作为参数传递给 plot()和 colSums()函数，从而保持信息流。

用三通管道操作符重做上面的例子。

# using tee pipe operator
rnorm(100) %>% 
  matrix(ncol=2) %>% 
  sin() %T>% 
  plot() %>% 
  colSums()# output
[1]  2.372528 -4.902566

作者图片

从上面的例子中我们可以看到，使用 tee pipe 操作符可以执行完整的操作序列。

暴露管道

Exposition pipe 操作符%$%将左边数据框的变量名公开为右边函数中的匹配参数名。在 base R 中的一些函数中，没有data =…参数。所以要从数据框中引用一个变量，我们必须使用$操作符作为dataframe$variable1等等。因此，在这些情况下，我们要处理多个变量，然后我们必须重复使用$符号的过程，同时重复数据框名称。为了避免这种情况，我们可以使用 exposition 管道。让我们使用 cor()和 lm()函数来理解 exposition pipe 的用法。我们将使用来自 base R 的 mtcars 数据集。

例 1 使用 lm()函数

使用%>%运算符

mtcars %>% lm(formula = disp~mpg)# output
Call:
lm(formula = disp ~ mpg, data = .)

Coefficients:
(Intercept)          mpg  
     580.88       -17.43

使用%$%运算符

mtcars %$% lm(formula = disp~mpg)# output
Call:
lm(formula = disp ~ mpg, data = .)

Coefficients:
(Intercept)          mpg  
     580.88       -17.43

例 2 使用 cor()函数

使用%>%运算符(案例 1)

mtcars %>% cor(disp,mpg)# output
Error in cor(., disp, mpg) : invalid 'use' argument
In addition: Warning message:
In if (is.na(na.method)) stop("invalid 'use' argument") :
  the condition has length > 1 and only the first element will be used

使用%>%运算符(案例 2)

cor(mtcars$disp,mtcars$mpg)# output
[1] -0.8475514

使用%$%运算符

mtcars %$% cor(disp, mpg)# output
[1] -0.8475514

在示例 1 中，我们看到，无论使用哪种类型的管道操作符，使用两个不同管道的两个操作都工作得非常好。但是在示例 2 中，%>%操作符和%$%操作符的情况 2 是有效的。 ***这里的关键区别在于 lm()和 cor()函数的参数类型。***lm()函数有数据作为参数之一，但 cor()函数没有。因此，% > %和%$%管道操作符可以很好地使用 lm()函数。对于 cor()函数的情况，因为参数不是 x 就是 y(查看文档)。因此，我们必须通过将 x 和 y 参数定义为 mtcars$disp 和 mtcars$mpg 来明确告诉 x 和 y 值来自 mtcars 数据帧。因此，为了避免 mtcars 数据帧的重复，我们可以直接使用%$%管道操作符。

分配管道

最后一个鲜为人知的管道是赋值管道%<>%。当变量在经过某些操作后被赋值给自身时，使用管道。让我们看一个例子

a <- a %>% cos() %>% sin()# using assignment operator
a %<>% cos() %>% sin()

因此，通过使用赋值管道操作符，我们可以删除赋值操作符<-。

结论

我们探索了三个不太知名的管道操作符:tee、exposition 和 assignment 管道，来自 Tidyverse 的 magrittr package。此外，我们在不同的设置中实现了这些管道操作符，以了解它们如何补充主要管道操作符%>%的功能。

当一系列操作具有不返回值的函数时，三通管道%T>%非常有用。在 exposition pipe % $ %的情况下，它们对于没有数据作为参数的 base R 函数来说非常方便。而赋值管道% <> %，在一系列操作后将变量赋值给自身时，避免了重复。

感谢您的阅读。我希望你喜欢管道的功能。如果您有任何反馈，请告诉我。

参考资料:

https://magrittr.tidyverse.org/articles/magrittr.html
https://r4ds.had.co.nz/pipes.html
【https://magrittr.tidyverse.org/reference/exposition.html

您可以在 LinkedIn 和 Twitter 上与我联系，跟随我的数据科学和数据可视化之旅。

我开始从事数据科学家工作后学到的 3 条经验

原文：https://towardsdatascience.com/3-lessons-i-have-learned-after-i-started-working-as-a-data-scientist-893207d954b2?source=collection_archive---------16-----------------------

我会有什么不同的做法

照片由 Unsplash 上的 engin akyurt 拍摄

我从在 Coursera 上完成 IBM 数据科学专业证书开始了我的数据科学之旅。我花了将近两年时间才找到一份数据科学家的工作。

在我开始作为一名数据科学家工作后，我很快就发现了在我的学习过程中我做对了什么，做错了什么。我忽略的事情已经变得非常清楚了。

我不确定是否是因为最终找到工作或在有真实生活数据的生产环境中工作的宽慰。然而，我可以向你保证，如果我必须重新开始，我会做一些不同的事情。

在这篇文章中，我将写下我开始作为一名数据科学家工作后学到的 3 个教训。你们中的一些人可能知道这些教训，但我相信一些有抱负的数据科学家可能会从中受益。

SQL 是必须的

数据科学的燃料是数据。没有适当的、维护良好的、易于访问的数据，我们做不了多少事情。尽管 NoSQL 数据库越来越普遍，但大多数公司仍然使用关系数据库来存储数据。

SQL 是关系数据库的关键。SQL 不仅用于访问和检索数据，也是一种高效的数据分析工具。灵活多样的 SQL 函数允许在检索数据的同时执行数据分析。

我们也可以使用 if 来过滤和转换数据，这样我们就只得到我们需要的数据。它节省了我们的内存和计算。

在我的数据科学之旅中，我学习了 SQL，但这还不够。我认为自己是 SQL 的中级用户。如果我重新开始，我一定会成为一名高级 SQL 用户。

我发现了 SQL 的能力以及它对数据科学生态系统的重要性。为了成为高级用户，你应该做大量的练习。

Git 是与同事协作的方式

Git 是一个版本控制系统。它维护项目中对代码所做的所有更改的历史记录。这些变化存储在一个特殊的数据库中，称为“存储库”，也称为“回购”。

在软件开发中使用 Git 的两个主要优势:

跟踪变更和更新。我们可以看到谁做了哪些更改。Git 还提供了何时以及为什么进行了更改。
允许合作工作。软件开发项目通常需要许多人一起工作。Git 为开发人员提供了一种系统化的方法。因此，开发人员专注于项目，而不是在其他开发人员之间进行广泛的交流。

在典型的数据科学项目中，您可能会与许多人一起工作，包括数据工程师、软件开发人员或其他数据科学家。第一种也是最重要的通信方式是通过 git 完成的。

您必须熟悉 git 命令和工作流，以便与同事协作。尽管 GitHub 和 GitLab 等托管服务提供了使用 git 的简单接口，但我还是建议您学习 git bash 命令。

Python 不仅仅是关于熊猫

Pandas 是一个伟大的数据分析和处理工具。从我开始数据科学之旅的第一天起，我就一直在使用。我还使用了数据科学生态系统中的许多其他 Python 库，如 NumPy、Seaborn、Matplotlib、Scikit-learn 等等。

它们都非常有用，我绝对建议学习它们。然而，Python 不仅仅是关于数据科学库。我觉得我太专注于学习这些库了。结果，我一直没能提高作为通用语言的 Python 技能。

你可能会说数据科学家不是软件开发人员。然而，大多数公司会要求你编写基本的脚本来实现项目。此外，你应该能够阅读和理解其他数据科学家或软件开发人员编写的代码。

它不仅适用于 Python。无论您选择哪种编程语言来学习数据科学，请确保您的范围不仅仅是数据科学库。

结论

我在这篇文章中分享的 3 个教训是我作为一名数据科学家工作后的体会。我知道 SQL、Git 和 Python 很重要，并花时间学习它们，但这还不够。我应该更加关注这些主题。

我想强调的是，这些不是你唯一需要学习的东西。事实上，这些都是你可能忽略的事情。

由于数据科学在传统教育体系中并不完善，学习途径大多是通过证书和 MOOC 课程。与数据科学相关的典型证书通常集中在图书馆。因此，像我一样遵循自学过程的有抱负的数据科学家不太可能对本文中提到的工具给予足够的重视。

感谢您的阅读。如果您有任何反馈，请告诉我。

在我的数据科学生涯中，我学到的 3 个教训来得有点晚

原文：https://towardsdatascience.com/3-lessons-i-learned-a-little-late-in-my-data-science-career-7aeb227292ce?source=collection_archive---------20-----------------------

尽早学习和应用这些宝石

职业经验 FTW！(照片由 Unsplash 上的 Brooke Cagle 拍摄)

有抱负的数据科学家经常问我，我是如何在如此年轻的时候成为高级数据科学家的，他们如何才能做到这一点。

加速你职业生涯的最可靠方法是向你的前辈学习。然后在你的职业生涯中应用这些知识。

我每天都在不断寻求学习新的东西。我并不羞于承认我已经不知道很多事情了。相反，我很想通过这些专家的经验、知识和错误来借用他们的智慧。

某些课程在每个人职业生涯的早期学习会更好，但事情并不总是按计划进行。

在这篇文章中，我将介绍我在职业生涯后期学到的三个重要经验。尽管如此，当你最早应用时，它有可能改变和加速你的数据科学职业轨迹。

1.领域知识和我们的技术技能一样重要

当我们开始学习数据科学时，我们大多专注于探索性数据分析、数据清洗、机器学习算法、统计学、线性代数和编程等技术技能。是的，这是一份全面的清单，但是我们遗漏了一些更重要的东西。

如果我们看一下数据科学维恩图，领域专业知识是它的一个重要组成部分。然而，我们忽略了它，因为它不存在。

数据科学维恩图(图片由作者提供)

我们无知背后的原因是，当我们处于学习阶段时，我们很少获得领域专业知识。除非我们开始工作，否则我们如何获得零售、金融或其他方面的专业知识？

在我开始第一份工作之前，我没有任何领域的专业知识。

在我的第一份工作中，我了解了 AI 在农业和畜牧业中的应用。我的老板甚至询问我是否可以处理涉及牛肉的数据(牛被视为神圣的动物，所以即使是食肉的印度教徒也不吃牛肉。)

当我开始工作时，我意识到从特定领域的研究科学家那里可以学到很多东西，这对模型的建立很有用。

从那以后，我在几个领域工作过，比如智能城市、水产养殖、零售。毫不夸张地说，每个项目都有一个巨大的领域学习曲线。

当我们在 Titanic 或 Iris 数据集上学习和构建模型时，我们永远无法获得这一点。有些事情肯定需要改变。

如何尽早做到这一点:

在我们学习旅程的初始阶段，我们可能没有在公司工作的奢侈。因此，我们必须找到不寻常的方法，通过互联网获得这些技能。我个人遵循的一些步骤:

选择任何你感兴趣的领域。(例如，医疗保健、金融、零售等。)
不要做普通的项目，而是专注于构建一个与特定领域的真实项目相似的项目。(例如，使用糖尿病数据集来构建模拟真实世界场景的项目。)
观看 YouTube 视频和阅读科学论文，了解行业中特定领域的术语和实践。

在我参与的一个水产养殖项目中，我无法接触到团队中的领域专家。我别无选择，只能通过观看 YouTube 视频(像这样的)和在互联网上冲浪来研究养鱼的做法。

我可能只获得了交付项目所需的最低限度的知识，但这没关系。努力在你可支配的资源中找到正确的平衡。

2.从多面手开始，最终成为专家

当我开始学习数据科学时，我看到的是大多数数据科学专家都专注于一两个领域，如 NLP、计算机视觉、时间序列、MLOps。有报道称，数据科学通才不会在行业生存太久。

所以作为一个初学者，我决定我需要专注于某个方面，尽管有许多问题没有答案。

我知道我想专攻什么吗？
作为一个数据科学初学者，我知道我的优势是什么吗？
从长远来看，我是否知道我选择的利基市场是否有足够的需求？

我是为了专精而挑了一个小众，并不那么意外；我毫无进展*。我突然明白了一些事情。*

这些专家是在进入数据科学领域后立即成为专家的吗？

作为初学者，没有必要成为专家。相比之下，我首先需要专注于成为多面手。在选定一个领域之前，我必须了解整个流程，并尝试不同的领域。所以我就这么做了。

我致力于将业务问题转化为机器学习解决方案蓝图，开发仪表板，展示见解，开发模型，创建 MLOps 管道，等等。基本上，我遇到的任何事情。

快进到现在，3 年过去了，我知道我擅长什么，并且在接下来的 2-3 年里我会专注于它。

如何应用:

在你职业生涯的早期，请对机会保持开放的心态。
从致力于端到端数据科学管道中的一切可能开始。
随着时间的推移(读，2-3 年)，你会对自己的实力和兴趣有一个直观的认识。
严格根据你的优势选择数据科学中的特定领域(例如，社交媒体的 NLP、零售的计算机视觉、生产就绪的 MLOps 等)。)
记住，这个领域是不断发展的；继续在你选择的领域发展高级技能。

当你遵循“通才到专家”的方法时，好处是双重的。首先，您了解整个生命周期，这在管理团队中的初级数据科学家时至关重要。第二，你已经在某个领域建立了专业技能，这将有助于你在这个行业长期生存。

3.当我们被期望去教书时，我们学得最好

这是我不断学习更好的秘诀。如果你想偷，请随意。

在本科学习的最后一年，我开始自学数据科学。我会浏览吴恩达在 Coursera 上的讲座并建立项目。我正在向最好的人学习，但是我没有正确方向的指导。

很可能你也有同样的感觉。你知道这些是最受欢迎的课程，但你不确定这一切是否会有回报。你希望有一个支持系统来一起学习和努力在数据科学领域做大。

在这段旅程的第一年，我一直有同样的感觉，直到我被邀请去举办一个关于结构化深度学习的研讨会。突然，我的学习有了目的:一帮同事将向我学习*。*一瞬间，我意识到了我学习过程中的不同之处——即使在今天，我也能举办同样的研讨会。我全都记得。

快进到现在，我已经举办了更多的研讨会，编写了关于简单和高级主题的教程。

现在我有了你们，每当我学到新东西时，你们都希望我去教。这给了我一个全新的目标去学得更好。

谢谢你，是的，你，阅读，互动，并成为我这次旅程背后的目的。

如何尽早做到这一点:

当你在你的学习旅程中前进时，事实上，你没什么可教的。我们都知道，所以你应该这样做:

从分享你的经验开始，比如你学到了什么，和你的朋友一起工作了什么，或者在 LinkedIn，YouTube，Medium 等平台上。
这些平台帮助你找到和你有同样问题的类似水平的爱好者。一小群和你有相同目标的同龄人会成为你的支持系统。
教你的朋友任何简单的话题(比如，线性回归。)
随着你慢慢获得专业知识，试着给一个小组做一个演示。如果你还在学习，那可能是为了你的班级；如果你正在工作，它可能是为你对数据科学感兴趣的同事准备的。
你知道这些机会总会出现——你需要准备好抓住它们。
获取反馈并改进。不像我，如果你早点开始，你的学习之旅会好 10 倍。

分享知识总是能巩固你对相同事物的理解。教学是让你学得最好的最好动力。

最后的想法

感谢您阅读至此。我真心希望这对你有用，尤其是如果你开始学习数据科学的话。

我在这个平台和 LinkedIn 上广泛地写了我在数据科学领域的学习和经验。当我开始的时候，社区给了我帮助，这是我回报的方式。

整个目的是帮助你加速你的数据科学事业。总而言之:

获取领域知识与提高数据科学技能同样重要。
在数据科学领域，从通才起步，最终成为专家。
学数据科学教人。你和社区将受益匪浅。

闯入数据科学可能具有挑战性；没人说容易。但是每年都有很多人这么做。他们没什么特别的，我也是。我们所有人都向专家学习，并在旅途中应用。

现在，是什么阻止了你？

要获得更多关于进入数据科学、令人兴奋的合作和指导的有用见解，请考虑 加入我的电子邮件好友私人列表 。

作为一名数据科学家，我从艰辛的道路中学到的 3 个教训

原文：https://towardsdatascience.com/3-lessons-i-learned-from-the-hard-way-as-a-data-scientist-a0e99fa78330?source=collection_archive---------4-----------------------

把你的错误变成教训！

JESHOOTS.COM在 Unsplash 上拍照

我大约 3 年前开始学习数据科学，花了大约 2 年时间找到了我作为数据科学家的第一份工作。从我开始数据科学之旅的第一天起，我就一直在介质上写作。

我写关于我的学习经历、采访、我作为一名数据科学家的生活等等的文章。最重要的是，我写下我所学到的东西。

在过去 3 年中，我观察到学习数据科学是一个持续的过程，可以分为两个阶段。分裂点是你找到第一份工作的时候。

学习还在继续，但是当你从一个时期进入另一个时期时，它会发生巨大的变化。我的意思不是数量上的变化，而是你处理问题的方式、你获得的技能和你学习的方式的变化。

在第一个时期，你在家做甜甜圈，然后在街上卖。你只接受现金，不用担心税收。在第二个时期，你有一个甜甜圈店，你有员工，你接受任何形式的付款，你纳税。从某种意义上说，你从业余走向了专业。

当我开始作为一名数据科学家工作时，我觉得我把我的小甜甜圈摊放在一边，走进了一家甜甜圈店。我还是会做甜甜圈，但方式不同了。

我听到你说甜甜圈够了，我同意:)在这篇文章中，我将分享我作为一名数据科学家从艰辛的道路中学到的 5 个教训。

唯一真正的错误是我们从中学不到任何东西的错误。—亨利·福特

至少检查结果 3 次

数字 3 没有魔力。我只想强调彻底检查结果的重要性。根据我的经验，至少检查三次可以大大降低遗漏错误的风险。

无论您实施何种算法或进行何种分析，其结果都会用于后续流程或生产中。因此，确保结果正确至关重要。

我所说的结果是正确的，并不是指你的预测没有任何错误，或者达到 100%的准确性，这是不合理或不合法的。事实上，你应该对好得不真实的结果持怀疑态度。

我提到的错误通常是与数据相关的问题。例如，在将产品的股票信息从 SQL 表连接到主表时，您可能犯了一个错误。如果你的解决方案是基于产品库存的，这会导致严重的问题。

在你的代码中几乎总是有防止犯错的控件。然而，我们不可能想到每一个可能的错误。因此，多看一眼总是有益的。

重复，重复，重复！

关系数据库在数据科学生态系统中非常常见。数据存储在许多关系表中。在某些情况下，我们从几个表中提取数据来得到我们所需要的。

这个过程需要连接几个表，这可能会在最终的表中产生重复的数据点(或行)。在代码中多次放置重复的检查是一个很好的做法。这个错误我犯了几次，吸取了教训。

建模是最后一步

您一定从各种资源中了解到，数据准备是数据科学项目中最耗时的部分。是的，在将原始数据输入模型之前，需要花费大量的时间来收集、清理和预处理原始数据。

在数据准备和建模之间还有一个步骤:探索性数据分析。它可以被定义为学习数据中的底层结构和关系的过程。我们可以使用各种工具和技术来执行探索性数据分析，如统计测量、分布图和其他数据可视化。

作为一名热情但缺乏经验的数据科学家，我太急于开始建模了。因此，我未能彻底进行探索性数据分析。

在建模阶段之前，了解数据告诉我们什么至关重要。它影响从选择特征到决定使用哪种算法的一切。

在进入建模阶段之前，要对数据了如指掌。

机器学习算法的光辉世界很吸引人。使用奇特算法和建立模型来执行一些预测的冲动可能会导致您跳过对数据的挖掘。

当然，使用机器学习算法没有错。但是，我们都应该知道，他们和我们给他们的数据一样好。我们需要学习数据，并相应地塑造模型。指望一个模型能给我们提供一切，这太乐观了。

数据不应该是神秘的，因为我们有很多工具来探索它。然而，在某些情况下，我们可能无法从数据中挖掘出足够的信息。我们会立即在数据集中寻找某些东西，如大小、形状、缺失值的数量、分布和相关性。它们很重要，但还不够。一个像样的探索性数据分析过程只能通过将标准技术向前推进一步来实现。

您的代码运行没有任何错误并不意味着它是正确的

数据科学家编写代码，但他们不像软件开发人员那样热衷于此。大多数数据科学家没有编程或软件开发背景。

对于我们来说，编写干净、高效、可维护的脚本是一项具有挑战性的任务。刚开始写代码的时候，我觉得代码运行没有任何错误就可以了。然而，情况并非总是如此。可能会出现一些意外问题，但不会导致任何错误。

检测此类问题的一种方法是检查结果。有几次，虽然代码没有引起任何错误，但我最终得到了一个主要由空值组成的数据帧。

结论

我们都从错误中学习，这是一件好事。更好的是从别人的错误中吸取教训。从这个意义上说，我在这篇文章中分享的经验可以被认为是一个可以借鉴的资源。

我希望你不要犯同样的错误。如果你这样做了，试着想出防止你再次犯类似错误的最佳实践。

最后但同样重要的是，如果你还不是中级会员并打算成为其中一员，我恳请你使用以下链接。我将从你的会员费中收取一部分，不增加你的额外费用。

https://sonery.medium.com/membership

感谢您的阅读。如果您有任何反馈，请告诉我。

共享代码时的 3 个技术抽象层次

原文：https://towardsdatascience.com/3-levels-of-technical-abstraction-when-sharing-your-code-50ddc6e73946?source=collection_archive---------46-----------------------

探索 GitHub、Docker 和 Heroku

paweczerwi ski 在 Unsplash 上的照片

我已经编程八年了，直到几个月前，我才能够回答我一直以来的一个问题:“我如何与他人分享我的项目？”

当我说“项目”时，我指的不是一个 R 脚本或一些 bash 命令——即使 22 岁的我也能理解复制和粘贴！我指的是一个有 几个文件 的项目，也许在 多语言 ，有 外部依赖 。我是不是要把它们都扔进一个压缩文件夹里？我如何处理不向后兼容的新版本语言和软件包？如果和我分享的人根本不知道怎么编码呢？

分享你的项目的正确方式取决于你希望你的接收者看到多少代码，以及从摘要中带走多少。本帖将涵盖三个抽象层次:GitHubDockerHeroku。我们将从共享原始文件开始，以隐藏几乎所有内容结束。

第一级:GitHub

收件人需要做的事情: 确保他们的计算机拥有适用于其操作系统的正确版本的适当语言和软件包；实际上知道执行什么代码来启动你的应用程序。

GitHub 是托管您的代码、跟踪代码变更并与其他人共享代码的行业标准。通过向某人发送指向您的存储库的 URL，他们可以查看您的代码，查看更改的历史记录，将代码保存到他们的计算机上，并将更改提交给您进行审批。

通过 GitHub 共享代码是我们三个选项中最不抽象的一个—**你的接收者获得原始代码本身。**虽然这对于从另一个角度了解你的项目的内部运作很有帮助，但是对于使用你的代码的来说，GitHub repo 本身实际上是非常简单的。如果没有详细的说明，您的收件人可能不知道您的代码应该做什么或如何实际运行它！

比如看一下Python的 GitHub repo(没错，Python)。只看文件和文件夹，你有什么想法输入什么命令来安装 Python？(谢天谢地，他们的自述里有详细的说明！)

作者截图

除了如何启动项目的说明，列出外部依赖(例如 Python 库)及其版本也很重要。即使你在给某人发送 GitHub repo 时共享了原始代码，如果你的代码引用了你的接收者没有安装的库，你的项目可能仍然不能在他们的计算机上运行。

这就是为什么**提供如何在您的计算机上重建环境的说明至关重要。**事实上，基于 Python 的项目几乎总是从用户创建一个虚拟环境并安装在requirements.txt文件中提供的库开始。

但是，如果你的项目涉及到多种语言和一个数据库，即使是详细的说明和一个requirements.txt文件也可能不够。例如，这个计票 app 的回购示例涉及 Python、 Node.js 、 Redis 、 Postgres 和。网。如果你愿意隐藏一些代码来使你的应用程序更容易使用，那么转移到下一个抽象层次:Docker 可能是值得的。

第二级:码头工人

你的收件人需要做的事情: 安装 Docker，拉相关图片，运行一个 Docker 撰写 。

Docker 是一种集装箱服务。一个容器是一个隔离的软件环境，其中的库、程序、甚至操作系统都独立于你的计算机的其余部分。把 Docker 容器想象成你电脑里面的一台微型电脑。 [1]

使用 Docker，您可以将项目的各个部分——例如机器学习模型、数据库和电子邮件提醒——隔离到独立的容器中，这些容器的环境完全符合该组件的需求。然后，您可以并行运行这些容器，就像它们在同一台计算机上一样。

容器来自 Docker Hub 上公开可用的软件“快照”，或图像。例如，如果你的应用程序只运行在 Python2 上，与其让你的接收者头疼地去说服他们降级他们的 Python， 不如让他们下载一个 Python2.7 的 Docker 镜像 。

截至 2021 年 4 月，Docker Hub 上有超过 580 万张图片可以免费下载。而且实验是没有成本的:你下载的任何图像都被悄悄地从你的计算机的全局环境中隐藏起来，直到你调用它们来创建一个容器。

作者截图

更好的是，你可以创建你自己的图像。[2]下面的代码是为一个简单的 Flask 应用程序创建 Docker 映像所需的全部内容。步骤包括安装 Ubuntu 操作系统、Python 和 Flask 将您的app.py文件复制到容器中；并使您的计算机内部网络可以访问该容器。

要将多个图像捆绑在一起，您需要运行一个 Docker Compose 。下面是将 Flask 应用程序与 Postgres 数据库捆绑在一起的合成文件的样子。

使用 Docker，我们可以简单地向我们的收件人发送一些 Docker 图像和一个 Docker 合成文件，告诉他们运行docker compose up，然后在他们的浏览器中导航到一个 URL(例如http://localhost:5000)。就是这样。用户可以查看 Compose 文件以了解正在使用哪些服务(例如，我们是否正在使用 Postgres vs. MySQL 数据库)，否则大多数代码都不会被使用。

第三级:Heroku

你的收件人需要做的事情: 点击一个网址。

对于我们最后的抽象层次，我们删除所有代码。没有 GitHub repos，没有命令行。当你在像 Heroku 、 AWS 或 DigitalOcean 这样的服务上托管你的应用时，某个数据中心的服务器会负责运行你的应用。然后，你的用户只需要点击一个 URL，就可以把他们带到那个服务器。

在这个抽象层次中，你的用户看到的只是你的应用的 前端——通常是一个图形界面。【3】下面举例，是我写的一个垃圾邮件捕捉 app 的截图。除了网页上的 HTML 和 CSS，你无法知道幕后发生了什么。(除非你去看 GitHub repo 或者阅读我写的博客系列。；-))

作者截图

如果你的应用程序的前端代码写得很好，即使是狡猾的用户也无法判断你的应用程序的后端是 100 行代码还是数百万行代码。事实上，这是大多数应用程序的工作方式:当你打开谷歌地图或 Slack 时，你看不到源代码——你只看到用户界面。

在商业环境中，只向用户展示你想让他们看到的东西，而不是透露你的应用程序的所有秘密，变得至关重要。例如，你不希望好奇的用户发现其他用户的私人数据，或者与世界分享你公司漂亮的聚类算法是如何工作的。在这种情况下，我们的最终抽象层对于共享您的项目是必要的。

结论

这篇文章旨在回答这个问题，“我如何与他人分享我的编码项目？”事实证明，答案取决于你希望你的用户如何进入杂草中！

最不抽象的方法是发送一个GitHubrepo——原始代码。这是协作的理想选择，因为你的接收者可以清楚地看到你的应用程序是如何工作的。但是对他们来说，实际上运行你的项目可能很难，因为他们需要重新创建所有的库、语言，甚至可能是你正在使用的操作系统。

下一个抽象层次是 Docker ，在这里你可以创建其他人可以下载的软件“快照”。这消除了管理项目依赖关系的麻烦，并且大多数实际代码对用户是隐藏的。然而，他们仍然可以看到你的应用程序使用了哪些服务——确切的数据库风格，你的模型是使用 Python 还是 R，等等。

最后一层是用一个像 Heroku 这样的服务托管你的代码，并给你的接收者发送一个 URL。这对用户完全隐藏了任何后端代码，这在业务环境中是理想的。这种方法把你的接收者变成了你产品的消费者，而不是合作者，因为他们不知道幕后发生了什么。

正确的方法取决于你希望你的接收者如何与你的项目互动。但是你也不必只选择这些方式中的一种来共享代码！事实上，我建议与你的用户分享它们:Heroku 中的应用程序可以立即与之交互，GitHub repo 可以查看底层代码，Dockerfile 可以在本地运行。

编码快乐！

最好，
马特

脚注

1.第二级:码头工人

每当你谈论 Docker 时，你可能需要来自虚拟机的必要的歧义消除。虽然 Docker 容器与你的计算机的其余部分(以及其他 Docker 容器，除非你显式地链接它们)是隔离的，但是容器确实共享诸如 RAM 和 CPU 之类的主机资源，并且使用相同的主机内核。如果不指定限制，一个容器可以愉快地吸走 CPU，降低周围所有容器的速度。另一方面，虚拟机有自己的 RAM 和 CPU，并且是真正隔离的。

顺便提一下，当您在 Windows 或 Mac 计算机上运行带有 Linux 操作系统的 Docker 容器时，Docker 实际上是在 Linux 虚拟机上运行容器。

2.第二级:码头工人

从 GitHub 到 Docker 和 Heroku 的一个必要的飞跃是把你的项目变成一个 API，让其他软件(比如网络浏览器)和你的代码交流。你可以用 Python 中的 Flask 或者 r 中的 Plumber 来做这件事。

3.第三级:Heroku

图形界面对于那些受众包括非程序员的应用程序来说是必不可少的。但是如果你的应用是面向开发者的(例如谷歌地图 API 而不是普通的谷歌地图)，那么“前端”可能只是你命令行中的一个小小的欢迎信息。无论哪种方式，后端代码仍然对您完全隐藏。

3 个库来实时可视化 Python 代码的执行

原文：https://towardsdatascience.com/3-libraries-to-visualize-the-execution-of-your-python-code-in-real-time-cdbb5a46f216?source=collection_archive---------15-----------------------

通过可视化执行来了解性能瓶颈

图片来自 Pixabay 的妮娜·加曼

Python 比其他语言慢，因为它的动态性和多功能性。有时复杂的计算或算法在 Python 中需要花费大量时间来执行。需要跟踪代码的执行流程，深入了解性能瓶颈。

Python 中的日志模块可用于跟踪代码事件，并可用于确定代码崩溃的原因。高效使用记录器还可以跟踪代码片段的时间复杂度。日志可能是有用的，但是它太技术性了，需要正确的实现。在本文中，我们将讨论 3 个这样的开源 Python 库，它们可以帮助开发人员只用几行代码就能可视化程序的执行。

Pyheat:

Pyheat 是一个开源 Python 库，帮助开发人员获得代码执行的逐行时间分布。Pyheat 不是以表格形式呈现，而是用热图表示运行每行代码所需的时间。

安装:

Pyheat 可以从 PyPl 安装，使用

**pip install py-heat**

并使用**from pyheat import PyHeat**将其导入

用法:

Pyheat 可用于为 Python 模块的每一行代码生成时间编号的热图。将 Python 文件的路径作为参数传递给**PyHeat**函数。

**ph = PyHeat('merge_sort.py')
ph.create_heatmap()
ph.show_heatmap()**

上述代码生成一个热图，表示在merge_sort.py模块中运行每一行代码所需的时间(秒)。

(图片由作者提供)

通过观察上面的热图，第 17 行中的 while 循环花费了大部分时间(7 秒)来执行。热图有助于开发人员识别花费大部分时间执行的代码片段，这些代码片段可以进一步优化。

心率:

Heartrate 是一个开源的 Python 库，它提供了 Python 程序执行的实时可视化。它提供了执行的逐行可视化，其中的数字给出了每一行被执行的次数。它在浏览器的一个单独窗口中显示代码的执行情况。

安装:

心率库可以从 PyPl 安装，使用:

**pip install heartrate**

用法:

导入包(import heartrate)后，使用heartrate.trace(browser=True)功能将打开一个浏览器窗口，显示调用trace()的文件的可视化。

在执行代码时，如果您现在可以跟随 http://localhost:9999 来观察执行的输出可视化，那么您的浏览器中将会弹出一个窗口。

(图片由作者提供)

每行最左边的数字表示特定行被执行的次数。条形显示最近被点击的行，越长的条形表示点击越多，越浅的颜色表示越近。它还显示了一个实时堆栈跟踪。

窥探:

Snoop 是另一个可以用作调试工具的包。Snoop 帮助你识别局部变量的值并跟踪程序的执行。Snoop 主要用作调试工具，以找出为什么您的 Python 代码没有做您认为它应该做的事情。

所有这些都可以通过在您想要跟踪的函数之前使用一个 snoop 装饰器来实现。

安装:

Snoop 库可以从 PyPl 安装，使用:

**pip install snoop**

用法:

结论:

在本文中，我们转换了 3 个库，可以用来可视化 Python 代码的执行。这些库帮助开发人员深入挖掘代码，找到并理解性能瓶颈，只需添加几行代码。

参考资料:

[1]py heat GitHub:https://github.com/csurfer/pyheat

[2]心率 GitHub:https://github.com/alexmojaki/heartrate

[3]Snoop GitHub:https://github.com/alexmojaki/snoop

感谢您的阅读

用 Python Pandas 和 Numpy 创建条件列的 3 种方法

原文：https://towardsdatascience.com/3-methods-to-create-conditional-columns-with-python-pandas-and-numpy-a6cd4be9da53?source=collection_archive---------3-----------------------

扩展您的数据操作和特征工程技能。

在 Unsplash 上由 Kelli Tungay 拍摄的照片

Python 可以说是数据科学生态系统中最流行的编程语言。如此受欢迎的原因之一是用于数据科学的 Python 库的丰富选择。

这些库为执行数据操作提供了快速、灵活和高效的方法。Pandas 和 Numpy 是两个流行的 Python 库，用于数据分析和操作任务。

基于数据集中的现有列派生新列是数据预处理中的典型任务。这也是特征工程的重要组成部分。在某些情况下，新列是根据其他列上的某些条件创建的。

在本文中，我们将介绍 3 种方法，它们可用于根据其他列的某些条件创建新列。正如我们将在示例中看到的，Pandas 和 Numpy 为执行这项任务提供了很大的灵活性。

让我们从导入库和创建样本数据框开始。以下数据框包含 Kaggle 上墨尔本住房数据集的一部分。

import numpy as np
import pandas as pdmelb = pd.read_csv("/content/melb_data.csv", usecols = ["Address", "Regionname", "Type", "Rooms", "Distance", "Price"])melb.head()

(图片由作者提供)

该数据集包含墨尔本一些房屋的特征及其价格。

1.熊猫在哪里起作用

第一种方法是熊猫的 where 功能。它允许根据以下规则或标准创建新列:

符合条件的值保持不变
不符合条件的值将被替换为给定值

例如，我们可以基于 price 列创建一个新列。如果价格高于 140 万，则新列的值为“class1”。否则，它将采用与 price 列中相同的值。

melb["new1"] = melb.Price.where(melb.Price < 1400000, "class1")melb.head()

(图片由作者提供)

where 函数的第一个参数指定条件。第二个是替换不符合条件的值的值。我们的条件是价格低于 140 万英镑。第一、第三和第五列不符合条件，因此新列采用这些行中的“class1”值。

2.Numpy where 函数

虽然名字相同，但熊猫和 Numpy 的 where 功能却大不相同。首先，Numpy 的 where 函数提供了更大的灵活性。它对待特定情况的方式也与熊猫不同。

Pandas where 函数只允许更新不满足给定条件的值。但是，Numpy 的 where 函数允许更新满足和不满足给定条件的值。

下面的代码块创建一个名为“new2”的列。where 函数中的第一个参数指定条件。第二个参数指示用于符合条件的行的值。第三个参数是不满足给定条件的行的值。

melb["new2"] = np.where(
   (melb.Rooms == 3) & (melb.Price > 1400000), 
   "class1", 
   "other"
)melb.head()

(图片由作者提供)

只有截图中的第三行符合给定的条件集，因此它取值“class1”。

3.数字选择功能

select 函数比前两种方法更强大。我们可以用它来给出一组条件和一组值。因此，我们能够为每个条件分配一个特定的值。

让我们首先定义条件和相关的值。

filters = [
   (melb.Rooms == 3) & (melb.Price > 1400000),
   (melb.Rooms == 2) & (melb.Price < 1400000),
   (melb.Price < 900000)
]values = ["class1", "class2", "class3"]

如果一栋房子有 3 个房间，其价格超过 140 万英镑，则新列的值为“class1”。如果一栋房子有 2 个房间，价格低于 140 万，则价值为“class2”，以此类推。类似于写一堆 if-else 语句。

我们可以使用 select 函数应用这些条件和值，如下所示:

melb["new3"] = np.select(filters, values)melb.head()

(图片由作者提供)

第一行和第五行不满足任何给定的条件。默认情况下，这些行的值为 0。但是，可以使用默认参数对其进行更改。

下面是演示默认参数用法的另一个示例。

melb["new4"] = np.select(filters, values, default="no_class")melb.head()

(图片由作者提供)

结论

我们已经介绍了在数据框中有条件地创建新列的 3 种不同方法。根据您需要的灵活性或任务的复杂程度，您可以选择最适合自己的方法。

永远记住，越简单越好。因此，选择简单的方法，除非你需要使用多个条件和值。

感谢您的阅读。如果您有任何反馈，请告诉我。

减少机器学习模型过度拟合的 3 种方法

原文：https://towardsdatascience.com/3-methods-to-reduce-overfitting-of-machine-learning-models-4a7e2c1da9ef?source=collection_archive---------14-----------------------

过度拟合模型充满了惊喜，但不是好的。

米 PHAM 在 Unsplash 上的照片

我遇到过几种过度拟合的定义。它们都用不同的措辞表达相同的意思。我的定义是，过度拟合模型捕获了数据集中不必要的细节、噪音或过于具体的关系。

当模型不能很好地概括数据时，就会发生过度拟合。因此，过拟合模型不是很稳定，它通常表现得出乎意料。一般来说，过度拟合会导致以前看不到的数据性能不佳。

过拟合是机器学习中的一个严重问题。我们永远不能相信一个过度拟合的模型并将其投入生产。它充满了惊喜，但不是让你开心的那些。即使特征值有非常小的变化，预测也可能发生显著变化。

有一些强有力的迹象表明过度拟合。如果在训练集和测试集的精确度之间有很大的差异，我们可能会有一个过拟合模型。另一个指标是不同的测试集得到非常不同的结果。

在部署机器学习模型之前，我们需要减少或消除过度拟合。有几种技术可以减少过度拟合。在这篇文章中，我们将讨论 3 种常用的方法。

交互效度分析

减少过度拟合最可靠的方法是收集更多的数据。我们拥有的数据越多，就越容易对底层结构进行探索和建模。我们将在本文中讨论的方法是基于不可能收集更多数据的假设。

既然我们无法获得更多的数据，我们应该充分利用现有的数据。交叉验证就是这样做的一种方式。

在典型的机器学习工作流中，我们将数据分成训练和测试子集。在某些情况下，我们还将单独的一组放在一边进行验证。该模型在训练集上被训练。然后，在测试集上测量其性能。因此，我们根据以前未见过的数据来评估模型。

在这种情况下，我们不能使用数据集的一部分进行训练。我们有点浪费了。交叉验证允许使用训练集和测试集中的每个观察值。

五重交叉验证(图片由作者提供)

上图展示了一个五重交叉验证。数据集被分成 5 部分。在每次迭代中，4 个片段用于训练，剩下的一个用于测试。整个过程在 5 次迭代后完成。每一块都用于训练和测试。

从某种意义上说，交叉验证是增加训练数据量的一种方式。模型的精度是所有迭代的平均值。结果，我们得到了对我们的模型的性能的更健壮的评估。

正规化

如果模型在数据方面过于复杂，很可能会导致过度拟合。在下图中，模型用红线显示。蓝点代表数据点。

过度拟合模型(图片由作者提供)

该模型试图捕捉所有数据点的每一个细节。它不能很好地概括数据集中的趋势。

这个模型在数据方面太复杂了(蓝点)。因此，我们有一个过度拟合的问题。我们可以通过降低模型的复杂度来解决这个问题。

正则化是一种降低复杂度的方法。它通过增加对较高项的惩罚来控制模型的复杂性。通常，模型旨在根据给定的损失函数最小化损失。如果增加一个正则项，该模型试图将复杂度和损失都最小化。

两种常用的正则化技术是 L1 和 L2 正则化。在解释 L1 和 L2 是如何工作的之前，让我们先来谈谈是什么增加了模型的复杂性。

特征总数
特征的权重

L1 正则化处理由于特征总数而导致的复杂性。它的作用就像在每次迭代中从权重中减去一点点的力。因此，一些权重最终变为零。

L2 正则化处理由于特征权重的量级而导致的复杂性。它的作用就像在每次迭代中从权重中移除一小部分的力。因此，权重会减少，但永远不会变为零。

下面演示了一个更容易接受的数据集模型。

(图片由作者提供)

我们还可以通过调整超参数来降低模型的复杂性。每个算法都有自己的超参数。对于随机森林模型，树的深度对模型的复杂性有很大的影响。

集合模型

集成模型由许多小的(即弱的)学习器组成。整体模型往往比单个模型更稳健、更准确。当我们使用集合模型时，过度拟合的风险也降低了。

最常用的集成模型是随机森林和梯度提升决策树。它们是几个决策树的组合。

让我们把重点放在随机森林。它使用一种叫做 bagging 的技术将多个决策树放在一起。通过聚合各个决策树的预测来计算预测。

随机森林模型通过使用不相关的决策树来降低过度拟合的风险。它们是通过自举和特征随机性产生的。

Bootstrapping 意味着用替换从训练数据中随机选择样本(即数据点)。因此，每个决策树都在不同的数据集上进行训练。

特征随机性是通过为每个决策树随机选择特征子集来实现的。假设数据集包含 20 个特征，我们为每棵树随机选择 15 个特征。所选特征的数量可以由参数控制。

最后，我们有几个决策树，它们适用于可能与原始数据集不同的样本。我们防止整个模型过于关注某个特定的特性或一组值。因此，降低了过度拟合的风险。

结论

过拟合是机器学习中的一个严重问题。在推进我们的模型之前解决它是至关重要的。比起精度高的 overfit 模型，我更喜欢精度低的模型。

有几种技术可以减少过度拟合。我们已经介绍了 3 种常用的方法。

感谢您的阅读。如果您有任何反馈，请告诉我。

3 项指标，确保您的应用为用户提供最佳体验。

原文：https://towardsdatascience.com/3-metrics-to-make-sure-your-app-is-delivering-the-best-experience-to-its-users-93adb248553e?source=collection_archive---------28-----------------------

通过定期遵循这 3 项指标来监控您的应用健康状态。

在 Unsplash 上由 Austin Distel 拍摄的照片

在我的上一篇文章中，我介绍了一个简单的 4 步框架来组织你追踪应用的思维。在这篇文章中，我想与你分享我发现对产品团队监控应用健康状态有帮助的三个指标。

现在，让我们讨论一下指标..

**1-用途:**该指标用于回答有多少用户使用了应用程序流程/功能/事件。了解绝对数字是有益的，但将其与基准(如以前的时期或某些目标)进行比较，可以了解该数字是好是坏。即在 Spotify 应用程序示例中，您想要关注的一个事件是 upgrade_to_premium (有多少免费帐户用户升级到付费帐户)。该数字与目标值和以前的时间段相比如何。

监控这一指标的另一个好处是查看某些特性是否按预期使用。如果你的应用程序用户和你一样考虑这些功能，或者如果他们更重视其他不同于你的功能，使用趋势可能会显示给你。

upgrade _ to _ premium事件的使用趋势。

2-成功率:该指标是在没有技术问题的情况下，成功实现应用程序目标的用户百分比。也就是说，在没有技术问题的情况下成功升级到高级版的应用程序用户比例。我们希望这个百分比是 100%,但是你可能会惊讶，这通常不是事实，并且%的用户由于这样或那样的原因会出现技术错误。您可以通过收集跟踪事件的成功参数来跟踪这个指标。

成功作为事件参数被跟踪。

**3-完成率:**该指标用于衡量应用流程的流畅程度。它是完成流量的用户与开始流量的用户的比率。这应该能告诉我们用户从流量中掉得最多的是哪里。能够跟踪这一点的一个技巧是，在命名事件时要有一致的命名约定，其中事件名称中提到了事件在流中的位置。也就是说，任何带有 _start 的事件都是启动流程的事件，任何带有 _end 或 _complete 的事件都意味着它是流程中应该触发的最后一个事件。

_start & _end 后缀被添加到事件中。

摘要

在这篇文章中，我讨论了产品团队可以用来监控应用健康状态的 3 个指标。第一个是使用趋势，它旨在告诉你哪些功能受欢迎，哪些不受欢迎。

第二个指标是成功率，旨在告诉你用户在试图完成你的应用程序或数字产品中的任务时是否出现了任何错误。

我们讨论的最后一个指标是完成率，这个指标告诉你你的流程有多顺畅，以及用户是否会放弃。

感谢阅读！

创业公司在分析方面(仍然)犯的 3 个错误

原文：https://towardsdatascience.com/3-mistakes-startups-are-still-making-with-analytics-d32c6ced386b?source=collection_archive---------30-----------------------

快速行动，打破常规——但仍要了解数据。初创公司必须定制他们的数据分析实践，以专注于快速提供战略见解

首先，我们来定义一下我们说的是谁。对于从 A 轮到 C 轮的初创公司，数据分析可能由一个小型(或没有)数据科学团队提供支持，并得到 BizOps、PMs 或参谋长的帮助。分析服务于不同的利益相关者，很少已经成为惯例。随着组织快速扩展和迭代其战略，分析需要跟上:团队需要提供许多答案，并且快速完成。

但是，尽管大多数初创企业领导人希望更好地利用数据，但他们很少觉得自己获得了最大价值。分析甚至被视为一种减缓事情的奢侈品，而不是它应该成为的决策加速器。但是我们可以解决。

以下是我们从与初创公司的合作中获得的最重要的经验，因为他们在自己的组织中发展了分析能力。

不要在仪表板上过度投资，因为它们是用来创建缓慢变化的视图的工具。你的生意发展得比 Tableau 快多了。
每个人都可以分析数据，尤其是有了现代数据分析工具。走一遍分析过程，找出人们会陷入困境的地方，并购买软件或分配培训时间来疏通你的团队。
数据科学是关于善与恶的 —专门针对“善”或主动应对“恶”你对“好”的定义越狭窄，分析就变得越容易。

错误 1:过度投资仪表板

这并不是从整体上贬低商业智能(BI)工具。仪表盘就像堡垒；它们可以很好的保护特定的区域，并且随着时间的推移几乎不需要维护。你应该绝对拥有关键指标的仪表板并监控它们。找出你需要定期回顾的内容，并建立这些视图。

但是有一个诱惑(因为它更容易)来保持构建越来越多的仪表板。转换问题？用转换率和一堆过滤器做一个转换仪表板。生产线延迟？带有一组过滤器的问题仪表板。但是，仅仅通过对历史事实的陈述就能改变这个体系，这是一个注定失败的赌注。

这很漂亮，但它不会保护你。威廉·奥利维耶里在 Unsplash 上拍摄的照片

相反，我们想要的是一种快速解决新的战略问题的方法，并且能够在许多观点之间转换。

难看也不错:让分析师们全权创造难看的(记录在案的、可重复的)结果。直到董事会需要看到它，没有 PowerPoint 和仪表板。
**我们正在建立管道，而不是视觉效果:**我们需要创建一个端到端的工作流程，而不仅仅是现有数据的可视化。从强大的数据准备开始，使用支持快速原型制作的工具。当在视图间快速移动时，BI 工具显得笨拙。
**求预测分析:**描述过去就可以了。如果我给你一组未来客户，我想知道他们中谁买了什么，谁在搅拌，等等。BI 工具已经开始进入预测空间，但主要仍然是最好的状态历史数据。
**实时对话使事情进展得更快:**仪表盘是很好的异步信息源。然而，涉众团队应该愿意投入大量的时间来动态地解决大部分问题。进行实时对话是最快的沟通方式，数据分析也不例外。

如果你想了解更多关于这个领域的信息，我们最近受益于 Anthony Deighton 的一次演讲,他曾在 Qlik、Celonis 和 Tamr 担任多个高管职位，演讲主题是“为什么仪表盘已死:Viz 黑手党如何将决策者引入歧途”

错误 2:让团队成员相信他们“不是数据人”

有需要高级学位的数据问题，但没有人被要求建造自动驾驶汽车。日常的问题解决和低复杂度的数据分析可以拥有接近洞察所要服务的功能。

数据科学问题总是有机地出现在讨论、计划会议和回顾中。面临的挑战是，有时它们会被扔进带有令人憎恶的前缀“我想知道……”的以太中，并被留在那里，因为没有人负责回答它。过度劳累的单个数据分析师无法承担更多的工作。因此，这个问题只是引起深思熟虑的两秒钟沉默，然后讨论继续下一项事务，这种情况非常常见。

相反，人们需要开始掌控两个最重要的问题:

多多少(或少多少):对 KPI 数据的基本访问，以及对这些指标进行加、减、除的能力。
谁或哪些因素起了作用:识别关键驱动因素，使用基本的统计模型剔除不重要的变量。

与您的工作团队一起完成这些步骤，并确保他们能够按顺序执行分析的每个组成部分。拿一个简单的问题(这个月与上个月相比如何)来解决它。

数据在一个结构化的环境中:如果数据由于某种原因还无法访问，那么去看看像 Airbyte / Fivetran 这样的数据传输工具和像雪花这样的可扩展仓库的组合。
**可以分离出正确的数据需求子集:**许多没有代码的工具可以将 SQL 转换成简单的东西。像可视化查询这样的开发更进了一步，使用数据可视化作为交互过滤本身的工具。
**直觉可以应用于数据清理:**工具应该扫描数据集，让用户容易发现似乎不合适的值、过高的平均值等等，并进行必要的转换。
**描述性分析是响应性的:**可视化应该是拖放创建，快速呈现。将不同的变量相互联系起来也应该很容易。这是最低的关卡。
**驾驶员识别突出重要因素:**没有人有时间单独探究每个变量；我们应该被指出表现最好和最差的地方。
**预测建模是可能的，简单的，有指导的:**自动化机器学习无处不在，用户不应该需要代码就能把很多驱动因素组合成一个目标变量的统一预测。记住，ML 并不比任何其他分析工具更可怕，把它当作一个超级棒图。

如果团队中有人觉得这些步骤中的一些还不可能实现，试着找出原因(最有可能的是，这是因为 Excel 不能在所有事情上工作)。这可能意味着购买一些现成的 SaaS 产品来解决问题，也可能意味着花一天时间看几个 YouTube 教程。投资民主化分析将为团队的个人发展和公司的分析潜力带来回报。

1700 万到 7100 万种正确的方法——谷歌，2021 年 10 月 28 日检索

错误三:想去打猎却去钓鱼

这句话是任何数据分析师的噩梦燃料:“告诉我们一些见解，我们有很多数据。”

你的团队在上周进行数据分析时——来源:斯蒂芬·莫莫在 Unsplash

当然是数据(仪表盘！)可以为你指出广阔的机会；例如，哪些指标可能偏离目标。但在战略层面，你有 10 个决策要做，你应该为所有决策添加数据分析，但实际上只有资源为其中 5 个决策添加数据驱动的洞察力。花很少的分析师时间去钓鱼应该留给黑客马拉松，实习生，以及在你可以雇佣 100 名数据科学家的 D 轮之后。

但事实上，要正确构建一个数据科学问题非常困难。即使选择一个特定的 KPI 作为目标也是不够的。假设我们正在努力提高客户满意度。我们是否在努力确定需要培训的员工？随机给顾客惊喜？努力补救以前糟糕的顾客旅程？期间？之后？等等…

当指派某人承担“数据科学”任务时，我们对任务的定义越精确，问题就变得越可行、越容易解决。分解一下:

**缩小到可处理的部分:**当分析组的两个元素可能表现非常不同时，这将简化分析并防止旋转轮子。这可能是一个客户群、一个流程类型、一个机器规格、一个地理位置等等。试图同时为新客户和现有客户运行一些分析可能是不可能的。
**协调行动:**将分析师的时间集中在实际相关的问题上，并帮助做出可行/不可行的决策。如果没有人能说出分析结果可能导致的潜在变化，我们可能是在“为分析而分析”
**目标变量应该是具体的，而不是聚合的:**例如，我们不想预测一个月内流程失败的次数；我们希望在失败发生前的一小时或一天内发现哪些流程会失败。几乎总有一个真实的“事件”是我们试图预测的，而且它应该是明确可追踪的。
提高投资回报率的目标:你可以随时为每个人做每件事，但大多数计划都是有成本的(甚至发送一封电子邮件)。减少目标人群，使用你所知道的每个人的变量。即使是一个简单的条形图中的一个或两个变量的分割也可以为您节省一半的程序成本。

高级数据科学从业者会强迫提示者提供所有这些信息。但是组织领导应该开始请求分析，以根据这些组成部分支持战略计划。

结论

在较大的组织中，这些问题在某种程度上确实存在。然而，随着更大的整体数据科学带宽和更慢的决策过程，数据使用中的摩擦往往成本更低。在初创公司，“数据团队”身兼数职，在各种优先任务之间穿梭。我们希望确保团队把时间花在正确的事情上，并且他们对他们花时间做的每件事都很有效率。

这三个部分最终提供了相互支持。将数据工作的重点放在及时的战略问题上，自然会将组织的重点从仪表板转移到定制分析上。为了支持这种分析，团队将花时间提高技能来完成这些任务。为了在早期帮助团队，当分析师缺乏经验时，花时间清楚地定义问题会使问题更容易回答。

这篇博客最初发表于 https://www.einblick.ai/blog/three-mistakes-startups-make/

*Einblick 是一个可视化数据计算平台，允许用户快速构建数据科学工作流——无论有无代码。在 https://einblick.ai/try-einblick/*报名试听

改变我机器学习生涯的 3 个错误

原文：https://towardsdatascience.com/3-mistakes-that-transformed-my-machine-learning-career-de76679e0084?source=collection_archive---------25-----------------------

接受错误的一部分包括分享错误

由 Unsplash 上的 krakenimages 拍摄的照片

面对现实吧，我们都会犯错。错误有时代价高昂，但其中蕴含着我们最重要的人生教训，而且往往是成长的重要机会。我们人类，自然地试图避免犯错误，因为长久以来，错误一直与痛苦和失败等负面模式联系在一起。尽管我们勇敢地努力避免犯错，但我们最终还是会犯错，因此，我们最好还是接受错误。

接受我的错误包括分享它们。对于许多其他人来说，这可能是真的，但我发现每当我问我工作范围内的人(即机器学习工程师或数据科学家)他们在旅途中犯的错误时，他们通常会告诉我一些小错误，例如他们忘记设置随机状态的时候，他们从数据集中删除实例的时候，或者可能完全删除数据集的时候。

虽然这些灾难确实是错误，但当我问一个年长的人他们犯了什么错误时，这些不是我想要的答案。这些类型的错误有些直观。例如，我们应该已经知道，在没有观察实例并且没有强有力的理由来解释我们为什么要删除它们的情况下，不要从数据集(或整个数据集)中删除实例(即，我删除了这个实例，因为它有许多缺失值，并且在进一步检查后，意识到这个实例是多余的，并且没有向数据添加进一步的信息)。

这样的错误是很小的成长机会。我们经常犯这种错误，任何人都可能发生这种情况。当我问高级职员他们在这个领域犯了什么错误时，我真正想知道的是…

"你犯了什么错误，彻底改变了你看待人工智能的方式？"

注:你可以用一个更具体的人工智能子领域(例如，机器学习、自然语言处理、计算机视觉、自动驾驶汽车等)来代替人工智能。

我想知道这个的原因是因为这些错误把他们推到了现在的位置。它们是改变模式的课程。这种错误的一个特征是巨大的初始痛苦。这可能是停滞或尴尬的结果。尽管如此，失败的感觉是不可避免的。

我的读者们，如果你曾经问过某人他们在这个领域犯了什么错误，在心里数到 3，如果他们仍然说“呃”,就不要理会他们说的任何废话。你永远不会忘记范式转换的错误。

如果你仍然不确定，看看我犯的一些错误。

涌入工业

如果你已经支付了升级技能，下一个目标是实现你的投资。这是我完成机器学习课程后的样子。我极度绝望地回复“机器学习工程师”给那些敢问我不踢球后一直在做什么的人。

我的想法是描绘我已经摆脱过去的画面，现在我开始做更好的事情。此外，我知道我周围的人都不知道什么是机器学习，所以我可以作为一个在科技行业赚大钱的天才而获得额外的荣誉。

我被自己的自负蒙蔽了双眼，并为此付出了代价。

我已经无数次分享了我关于如何闯入机器学习领域的故事。在所有这些场合，我没能分享的是，加入我的第一家公司可能是我最大的错误。

离开邮件室去担任更有声望的机器学习工程师角色的想法引导了我的决定——对我即将获得的加薪只字不提。我忽略了无数关于公司的危险信号。例如，他们雇用我这个实习生来领导他们的机器学习集成工作。是啊没错。

说出来很伤人，因为我在那里遇到了一些很棒的人，其中一个是我的直线经理，他带我进来，激励我开始了你今天正在阅读的博客。除此之外，什么都没有。

我已经在理论上实现了成为一名机器学习工程师的目标，但除此之外，我没有学到太多其他东西。我的大部分时间都是无所事事地度过的。当我意识到我不能想走就走，因为我觉得我没有能力为任何团队增加价值时，我开始怀疑自己。

在疫情战争期间，我被裁员了——这是理所当然的。这是真相成长开始的时候。我不得不照顾自己，因为我有责任。在这个阶段，我被迫变得更好，因为我相信如果我不这样做，后果会是最糟糕的。

正是在这段时间里，我学会了用我的技能赚钱，从此我再也没有回头。

第一课:不一定要打动别人，不如打动自己。

对我的学习不负责任

自学听起来比实际上更令人愉快。事实上，没有结构是一个持续不确定的旅程，有时会觉得自己不够格。在某些情况下，这可能是真的。

我毫不犹豫地承认，目前有些事情我还不够格。例如，我现在没有资格管理谷歌的机器学习团队。承认你目前的不足是没有问题的，因为认识到这一点是改善自己的第一步。我的问题是，如果我发现自己不合格，我会觉得自己甚至没有资格学习这门学科。

孤独的时候，我会对自己说:“我要放弃学习部署机器学习模型，因为我找到工作后，他们会教我如何部署机器学习。”

这种心态阻碍了我的成长。

每当我觉得某个科目太难的时候，我就会把它加到“我想学的东西”的目录里，直到有一个比我年长的人亲自给我提供详细的信息。

因此，在我真正想找工作的时候，我却找不到工作。招聘经理和招聘人员几乎可以感觉到，我将更多地从团队中接受，而不是给予。我就像一个搭便车的人，坐在高速公路边一辆坏了的车上。

有一天，我的脑子里发生了某种变化。我开始意识到所有的事情我想做但不能做由于我缺乏资源。得知所有我推迟的事情让自己感到不舒服的原因开始超过了推迟的原因。

我开始明确自己一直在拖延的所有任务，比如学习自然语言处理、深入钻研深层学习以及构建以机器学习(Machine Learning)为动力的应用程序。在此期间，我也开始比以前更多地分享我的学习和经验。

不知不觉中，机会蜂拥而至。不仅如此。我现在从学习新事物中感觉到了更大的成就感，特别是当任务更复杂的时候。这激发了我的好奇心。

第 5 课:一旦你开始自己走路，人们就会更愿意帮助你到达目的地。

设定不切实际的目标

在过去十年中，机器学习，特别是深度学习兴起。在很大程度上，这种增长可以归功于围绕人工智能时代我们的未来前景所做的炒作。坦白地说，我也想参与其中。

就像我想向朋友和同事炫耀自己的新头衔一样，我也想在这个领域获得一些影响力。我亲眼目睹了卡格尔这样做。我开始痴迷于成为一名卡格尔大师。我想在 18 个月或更短的时间内完成。我会看博客，听播客，联系卡格勒斯。但有一个主要问题……

我从来没有承诺要努力成为一个。

新的竞争开始了，在最初的 3 天里，我会花上几个小时梳理讨论页面。然后我会停下来。这个循环反复多次。每一次，我越来越不相信自己的能力。我会想，如果我不能完成一个 Kaggle，我到底怎么才能在商界生存下来。

我并不是在对卡格尔大吼大叫。虽然它可能无法真正监督在现实世界中的工作，但它是一种锻炼要素工程和建模技能的好方法。问题出在我身上。

我经常对自己说，我要做什么事而不去做，这是在玷污我的自我形象。

当我在成为机器学习工程师的过程中开始设定更小、更可实现的目标时，我找到了更多的平静，也更加支持自己。

第七课:有一个大目标是好的，但是在你迈向大目标的过程中，设定一些小目标来获得立竿见影的效果是很重要的。

最后的想法

大多数时候，我们不会坦诚面对自己的错误——不管是出于什么原因。学会接受它们是学习新见解和成长的重要一步。如果你不得不深入思考你所犯的错误，要么是你在隐藏它，要么是你没有意识到你正在犯任何错误(我会担心)。虽然我们会犯错误，但从别人的错误中吸取教训也是件好事。

感谢阅读！

如果你喜欢这篇文章，请通过订阅我的免费每周简讯与我联系。不要错过我写的关于人工智能、数据科学和自由职业的帖子。

</5-ai-failures-you-probably-should-know-about-417ddebbc323> </5-laws-for-self-taught-data-professionals-4bf351ac5c24> [## 自学成才的数据专业人员的 5 条法则

towardsdatascience.com](/5-laws-for-self-taught-data-professionals-4bf351ac5c24)

TowardsDataScience-博客中文翻译-2021-二-更多相关文章

今日报告-66

设置Windows10暂停更新3000天

AQS公平锁的流程

AMD锐龙7 7800X3D网游专项测试：竟比i9-13900KS强了15%

常用总线技术基本参数对比

探索图像数据中的隐藏信息：语义实体识别和关系抽取的奇妙之旅

设置Chrome浏览器自动升级

JavaScript – 小技巧 Tips

postgresql在插入数据后怎么获取自增id

EF Core 的基本使用

error: failed to push some refs to 'https://github.com/*******/********.github.io.git'

欧拉降幂

编程语言能力对比

基于机器视觉的小车轨迹控制软件界面展示

随机推荐

命令拼接技巧

Fiddler抓包Android7以内版本

AJAX & AXIOS-2024/11/1

验证码处理在自动化测试中的应用

一些学科笑话

NOIP2024模拟赛20 & 11.1 小记

20241101 数据结构与算法期中机试收获

Java，启动！

什么是IT技术

即将到来！

2024/11/1日日志关于JavaScript简介&引入方式以及基础语法的学习

舍得-时间-工作是人的一生最重要的事情-自己要有私房钱-人的一生最重要的事情是书写自己的人生

2.TiUP 部署 DM 集群

原型模式的C++实现

python bytecode解析